From d5e6b6f8cc404ee5d3c1a08c6d2ef63fa96862fa Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Fri, 21 Mar 2025 19:42:17 +0100
Subject: [PATCH 0001/1889] core: simplify `Extend` for tuples

This is an alternative to #137400. The current macro is incredibly complicated and introduces subtle bugs like calling the `extend_one` of the individual collections in backwards order. This PR drastically simplifies the macro by removing recursion and moving the specialization out of the macro. It also fixes the ordering issue described above (I've stolen the test of the new behaviour from #137400). Additionally, the 1-tuple is now special-cased to allow taking advantage of the well-optimized `Extend` implementations of the individual collection.
---
 library/core/src/iter/traits/collect.rs | 432 +++++++++++++-----------
 1 file changed, 236 insertions(+), 196 deletions(-)

diff --git a/library/core/src/iter/traits/collect.rs b/library/core/src/iter/traits/collect.rs
index 97bb21c8a36e8..b4ab81d15a330 100644
--- a/library/core/src/iter/traits/collect.rs
+++ b/library/core/src/iter/traits/collect.rs
@@ -459,234 +459,274 @@ impl Extend<()> for () {
     fn extend_one(&mut self, _item: ()) {}
 }
 
-macro_rules! spec_tuple_impl {
-    (
-        (
-            $ty_name:ident, $var_name:ident, $extend_ty_name: ident,
-            $trait_name:ident, $default_fn_name:ident, $cnt:tt
-        ),
-    ) => {
-        spec_tuple_impl!(
-            $trait_name,
-            $default_fn_name,
-            #[doc(fake_variadic)]
-            #[doc = "This trait is implemented for tuples up to twelve items long. The `impl`s for \
-                     1- and 3- through 12-ary tuples were stabilized after 2-tuples, in \
-                     1.85.0."]
-            => ($ty_name, $var_name, $extend_ty_name, $cnt),
-        );
-    };
-    (
-        (
-            $ty_name:ident, $var_name:ident, $extend_ty_name: ident,
-            $trait_name:ident, $default_fn_name:ident, $cnt:tt
-        ),
-        $(
-            (
-                $ty_names:ident, $var_names:ident,  $extend_ty_names:ident,
-                $trait_names:ident, $default_fn_names:ident, $cnts:tt
-            ),
-        )*
-    ) => {
-        spec_tuple_impl!(
-            $(
-                (
-                    $ty_names, $var_names, $extend_ty_names,
-                    $trait_names, $default_fn_names, $cnts
-                ),
-            )*
-        );
-        spec_tuple_impl!(
-            $trait_name,
-            $default_fn_name,
-            #[doc(hidden)]
-            => (
-                $ty_name, $var_name, $extend_ty_name, $cnt
-            ),
-            $(
-                (
-                    $ty_names, $var_names, $extend_ty_names, $cnts
-                ),
-            )*
-        );
-    };
-    (
-        $trait_name:ident, $default_fn_name:ident, #[$meta:meta]
-        $(#[$doctext:meta])? => $(
-            (
-                $ty_names:ident, $var_names:ident, $extend_ty_names:ident, $cnts:tt
-            ),
-        )*
-    ) => {
-        #[$meta]
-        $(#[$doctext])?
-        #[stable(feature = "extend_for_tuple", since = "1.56.0")]
-        impl<$($ty_names,)* $($extend_ty_names,)*> Extend<($($ty_names,)*)> for ($($extend_ty_names,)*)
-        where
-            $($extend_ty_names: Extend<$ty_names>,)*
-        {
-            /// Allows to `extend` a tuple of collections that also implement `Extend`.
-            ///
-            /// See also: [`Iterator::unzip`]
-            ///
-            /// # Examples
-            /// ```
-            /// // Example given for a 2-tuple, but 1- through 12-tuples are supported
-            /// let mut tuple = (vec![0], vec![1]);
-            /// tuple.extend([(2, 3), (4, 5), (6, 7)]);
-            /// assert_eq!(tuple.0, [0, 2, 4, 6]);
-            /// assert_eq!(tuple.1, [1, 3, 5, 7]);
-            ///
-            /// // also allows for arbitrarily nested tuples as elements
-            /// let mut nested_tuple = (vec![1], (vec![2], vec![3]));
-            /// nested_tuple.extend([(4, (5, 6)), (7, (8, 9))]);
-            ///
-            /// let (a, (b, c)) = nested_tuple;
-            /// assert_eq!(a, [1, 4, 7]);
-            /// assert_eq!(b, [2, 5, 8]);
-            /// assert_eq!(c, [3, 6, 9]);
-            /// ```
-            fn extend<T: IntoIterator<Item = ($($ty_names,)*)>>(&mut self, into_iter: T) {
-                let ($($var_names,)*) = self;
-                let iter = into_iter.into_iter();
-                $trait_name::extend(iter, $($var_names,)*);
-            }
+/// This trait is implemented for tuples up to twelve items long. The `impl`s for
+/// 1- and 3- through 12-ary tuples were stabilized after 2-tuples, in 1.85.0.
+#[doc(fake_variadic)] // the other implementations are below.
+#[stable(feature = "extend_for_tuple", since = "1.56.0")]
+impl<T, ExtendT> Extend<(T,)> for (ExtendT,)
+where
+    ExtendT: Extend<T>,
+{
+    /// Allows to `extend` a tuple of collections that also implement `Extend`.
+    ///
+    /// See also: [`Iterator::unzip`]
+    ///
+    /// # Examples
+    /// ```
+    /// // Example given for a 2-tuple, but 1- through 12-tuples are supported
+    /// let mut tuple = (vec![0], vec![1]);
+    /// tuple.extend([(2, 3), (4, 5), (6, 7)]);
+    /// assert_eq!(tuple.0, [0, 2, 4, 6]);
+    /// assert_eq!(tuple.1, [1, 3, 5, 7]);
+    ///
+    /// // also allows for arbitrarily nested tuples as elements
+    /// let mut nested_tuple = (vec![1], (vec![2], vec![3]));
+    /// nested_tuple.extend([(4, (5, 6)), (7, (8, 9))]);
+    ///
+    /// let (a, (b, c)) = nested_tuple;
+    /// assert_eq!(a, [1, 4, 7]);
+    /// assert_eq!(b, [2, 5, 8]);
+    /// assert_eq!(c, [3, 6, 9]);
+    /// ```
+    fn extend<I: IntoIterator<Item = (T,)>>(&mut self, iter: I) {
+        self.0.extend(iter.into_iter().map(|t| t.0));
+    }
 
-            fn extend_one(&mut self, item: ($($ty_names,)*)) {
-                $(self.$cnts.extend_one(item.$cnts);)*
-            }
+    fn extend_one(&mut self, item: (T,)) {
+        self.0.extend_one(item.0)
+    }
 
-            fn extend_reserve(&mut self, additional: usize) {
-                $(self.$cnts.extend_reserve(additional);)*
-            }
+    fn extend_reserve(&mut self, additional: usize) {
+        self.0.extend_reserve(additional)
+    }
 
-            unsafe fn extend_one_unchecked(&mut self, item: ($($ty_names,)*)) {
-                // SAFETY: Those are our safety preconditions, and we correctly forward `extend_reserve`.
-                unsafe {
-                     $(self.$cnts.extend_one_unchecked(item.$cnts);)*
-                }
-            }
-        }
+    unsafe fn extend_one_unchecked(&mut self, item: (T,)) {
+        // SAFETY: the caller guarantees all preconditions.
+        unsafe { self.0.extend_one_unchecked(item.0) }
+    }
+}
 
-        trait $trait_name<$($ty_names),*> {
-            fn extend(self, $($var_names: &mut $ty_names,)*);
-        }
+/// This implementation turns an iterator of tuples into a tuple of types which implement
+/// [`Default`] and [`Extend`].
+///
+/// This is similar to [`Iterator::unzip`], but is also composable with other [`FromIterator`]
+/// implementations:
+///
+/// ```rust
+/// # fn main() -> Result<(), core::num::ParseIntError> {
+/// let string = "1,2,123,4";
+///
+/// // Example given for a 2-tuple, but 1- through 12-tuples are supported
+/// let (numbers, lengths): (Vec<_>, Vec<_>) = string
+///     .split(',')
+///     .map(|s| s.parse().map(|n: u32| (n, s.len())))
+///     .collect::<Result<_, _>>()?;
+///
+/// assert_eq!(numbers, [1, 2, 123, 4]);
+/// assert_eq!(lengths, [1, 1, 3, 1]);
+/// # Ok(()) }
+/// ```
+#[doc(fake_variadic)] // the other implementations are below.
+#[stable(feature = "from_iterator_for_tuple", since = "1.79.0")]
+impl<T, ExtendT> FromIterator<(T,)> for (ExtendT,)
+where
+    ExtendT: Default + Extend<T>,
+{
+    fn from_iter<Iter: IntoIterator<Item = (T,)>>(iter: Iter) -> Self {
+        let mut res = ExtendT::default();
+        res.extend(iter.into_iter().map(|t| t.0));
+        (res,)
+    }
+}
 
-        fn $default_fn_name<$($ty_names,)* $($extend_ty_names,)*>(
-            iter: impl Iterator<Item = ($($ty_names,)*)>,
-            $($var_names: &mut $extend_ty_names,)*
-        ) where
-            $($extend_ty_names: Extend<$ty_names>,)*
-        {
-            fn extend<'a, $($ty_names,)*>(
-                $($var_names: &'a mut impl Extend<$ty_names>,)*
-            ) -> impl FnMut((), ($($ty_names,)*)) + 'a {
-                #[allow(non_snake_case)]
-                move |(), ($($extend_ty_names,)*)| {
-                    $($var_names.extend_one($extend_ty_names);)*
-                }
-            }
+/// An implementation of [`extend`](Extend::extend) that calls `extend_one` or
+/// `extend_one_unchecked` for each element of the iterator.
+fn default_extend<ExtendT, I, T>(collection: &mut ExtendT, iter: I)
+where
+    ExtendT: Extend<T>,
+    I: IntoIterator<Item = T>,
+{
+    // Specialize on `TrustedLen` and call `extend_one_unchecked` where
+    // applicable.
+    trait SpecExtend<I> {
+        fn extend(&mut self, iter: I);
+    }
 
+    // Extracting these to separate functions avoid monomorphising the closures
+    // for every iterator type.
+    fn extender<ExtendT, T>(collection: &mut ExtendT) -> impl FnMut(T) + use<'_, ExtendT, T>
+    where
+        ExtendT: Extend<T>,
+    {
+        move |item| collection.extend_one(item)
+    }
+
+    unsafe fn unchecked_extender<ExtendT, T>(
+        collection: &mut ExtendT,
+    ) -> impl FnMut(T) + use<'_, ExtendT, T>
+    where
+        ExtendT: Extend<T>,
+    {
+        // SAFETY: we make sure that there is enough space at the callsite of
+        // this function.
+        move |item| unsafe { collection.extend_one_unchecked(item) }
+    }
+
+    impl<ExtendT, I, T> SpecExtend<I> for ExtendT
+    where
+        ExtendT: Extend<T>,
+        I: Iterator<Item = T>,
+    {
+        default fn extend(&mut self, iter: I) {
             let (lower_bound, _) = iter.size_hint();
             if lower_bound > 0 {
-                $($var_names.extend_reserve(lower_bound);)*
+                self.extend_reserve(lower_bound);
             }
 
-            iter.fold((), extend($($var_names,)*));
+            iter.for_each(extender(self))
         }
+    }
 
-        impl<$($ty_names,)* $($extend_ty_names,)* Iter> $trait_name<$($extend_ty_names),*> for Iter
-        where
-            $($extend_ty_names: Extend<$ty_names>,)*
-            Iter: Iterator<Item = ($($ty_names,)*)>,
-        {
-            default fn extend(self, $($var_names: &mut $extend_ty_names),*) {
-                $default_fn_name(self, $($var_names),*);
+    impl<ExtendT, I, T> SpecExtend<I> for ExtendT
+    where
+        ExtendT: Extend<T>,
+        I: TrustedLen<Item = T>,
+    {
+        fn extend(&mut self, iter: I) {
+            let (lower_bound, upper_bound) = iter.size_hint();
+            if lower_bound > 0 {
+                self.extend_reserve(lower_bound);
+            }
+
+            if upper_bound.is_none() {
+                // We cannot reserve more than `usize::MAX` items, and this is likely to go out of memory anyway.
+                iter.for_each(extender(self))
+            } else {
+                // SAFETY: We reserve enough space for the `size_hint`, and the iterator is
+                // `TrustedLen` so its `size_hint` is exact.
+                iter.for_each(unsafe { unchecked_extender(self) })
             }
         }
+    }
 
-        impl<$($ty_names,)* $($extend_ty_names,)* Iter> $trait_name<$($extend_ty_names),*> for Iter
+    SpecExtend::extend(collection, iter.into_iter());
+}
+
+// Implements `Extend` and `FromIterator` for tuples with length larger than one.
+macro_rules! impl_extend_tuple {
+    ($(($ty:tt, $extend_ty:tt, $index:tt)),+) => {
+        #[doc(hidden)]
+        #[stable(feature = "extend_for_tuple", since = "1.56.0")]
+        impl<$($ty,)+ $($extend_ty,)+> Extend<($($ty,)+)> for ($($extend_ty,)+)
         where
-            $($extend_ty_names: Extend<$ty_names>,)*
-            Iter: TrustedLen<Item = ($($ty_names,)*)>,
+            $($extend_ty: Extend<$ty>,)+
         {
-            fn extend(self, $($var_names: &mut $extend_ty_names,)*) {
-                fn extend<'a, $($ty_names,)*>(
-                    $($var_names: &'a mut impl Extend<$ty_names>,)*
-                ) -> impl FnMut((), ($($ty_names,)*)) + 'a {
-                    #[allow(non_snake_case)]
-                    // SAFETY: We reserve enough space for the `size_hint`, and the iterator is
-                    // `TrustedLen` so its `size_hint` is exact.
-                    move |(), ($($extend_ty_names,)*)| unsafe {
-                        $($var_names.extend_one_unchecked($extend_ty_names);)*
-                    }
-                }
+            fn extend<T: IntoIterator<Item = ($($ty,)+)>>(&mut self, iter: T) {
+                default_extend(self, iter)
+            }
 
-                let (lower_bound, upper_bound) = self.size_hint();
+            fn extend_one(&mut self, item: ($($ty,)+)) {
+                $(self.$index.extend_one(item.$index);)+
+            }
 
-                if upper_bound.is_none() {
-                    // We cannot reserve more than `usize::MAX` items, and this is likely to go out of memory anyway.
-                    $default_fn_name(self, $($var_names,)*);
-                    return;
-                }
+            fn extend_reserve(&mut self, additional: usize) {
+                $(self.$index.extend_reserve(additional);)+
+            }
 
-                if lower_bound > 0 {
-                    $($var_names.extend_reserve(lower_bound);)*
+            unsafe fn extend_one_unchecked(&mut self, item: ($($ty,)+)) {
+                // SAFETY: Those are our safety preconditions, and we correctly forward `extend_reserve`.
+                unsafe {
+                    $(self.$index.extend_one_unchecked(item.$index);)+
                 }
-
-                self.fold((), extend($($var_names,)*));
             }
         }
 
-        /// This implementation turns an iterator of tuples into a tuple of types which implement
-        /// [`Default`] and [`Extend`].
-        ///
-        /// This is similar to [`Iterator::unzip`], but is also composable with other [`FromIterator`]
-        /// implementations:
-        ///
-        /// ```rust
-        /// # fn main() -> Result<(), core::num::ParseIntError> {
-        /// let string = "1,2,123,4";
-        ///
-        /// // Example given for a 2-tuple, but 1- through 12-tuples are supported
-        /// let (numbers, lengths): (Vec<_>, Vec<_>) = string
-        ///     .split(',')
-        ///     .map(|s| s.parse().map(|n: u32| (n, s.len())))
-        ///     .collect::<Result<_, _>>()?;
-        ///
-        /// assert_eq!(numbers, [1, 2, 123, 4]);
-        /// assert_eq!(lengths, [1, 1, 3, 1]);
-        /// # Ok(()) }
-        /// ```
-        #[$meta]
-        $(#[$doctext])?
+        #[doc(hidden)]
         #[stable(feature = "from_iterator_for_tuple", since = "1.79.0")]
-        impl<$($ty_names,)* $($extend_ty_names,)*> FromIterator<($($extend_ty_names,)*)> for ($($ty_names,)*)
+        impl<$($ty,)+ $($extend_ty,)+> FromIterator<($($ty,)+)> for ($($extend_ty,)+)
         where
-            $($ty_names: Default + Extend<$extend_ty_names>,)*
+            $($extend_ty: Default + Extend<$ty>,)+
         {
-            fn from_iter<Iter: IntoIterator<Item = ($($extend_ty_names,)*)>>(iter: Iter) -> Self {
-                let mut res = <($($ty_names,)*)>::default();
+            fn from_iter<Iter: IntoIterator<Item = ($($ty,)+)>>(iter: Iter) -> Self {
+                let mut res = Self::default();
                 res.extend(iter);
-
                 res
             }
         }
-
     };
 }
 
-spec_tuple_impl!(
-    (L, l, EL, TraitL, default_extend_tuple_l, 11),
-    (K, k, EK, TraitK, default_extend_tuple_k, 10),
-    (J, j, EJ, TraitJ, default_extend_tuple_j, 9),
-    (I, i, EI, TraitI, default_extend_tuple_i, 8),
-    (H, h, EH, TraitH, default_extend_tuple_h, 7),
-    (G, g, EG, TraitG, default_extend_tuple_g, 6),
-    (F, f, EF, TraitF, default_extend_tuple_f, 5),
-    (E, e, EE, TraitE, default_extend_tuple_e, 4),
-    (D, d, ED, TraitD, default_extend_tuple_d, 3),
-    (C, c, EC, TraitC, default_extend_tuple_c, 2),
-    (B, b, EB, TraitB, default_extend_tuple_b, 1),
-    (A, a, EA, TraitA, default_extend_tuple_a, 0),
+impl_extend_tuple!((A, ExA, 0), (B, ExB, 1));
+impl_extend_tuple!((A, ExA, 0), (B, ExB, 1), (C, ExC, 2));
+impl_extend_tuple!((A, ExA, 0), (B, ExB, 1), (C, ExC, 2), (D, ExD, 3));
+impl_extend_tuple!((A, ExA, 0), (B, ExB, 1), (C, ExC, 2), (D, ExD, 3), (E, ExE, 4));
+impl_extend_tuple!((A, ExA, 0), (B, ExB, 1), (C, ExC, 2), (D, ExD, 3), (E, ExE, 4), (F, ExF, 5));
+impl_extend_tuple!(
+    (A, ExA, 0),
+    (B, ExB, 1),
+    (C, ExC, 2),
+    (D, ExD, 3),
+    (E, ExE, 4),
+    (F, ExF, 5),
+    (G, ExG, 6)
+);
+impl_extend_tuple!(
+    (A, ExA, 0),
+    (B, ExB, 1),
+    (C, ExC, 2),
+    (D, ExD, 3),
+    (E, ExE, 4),
+    (F, ExF, 5),
+    (G, ExG, 6),
+    (H, ExH, 7)
+);
+impl_extend_tuple!(
+    (A, ExA, 0),
+    (B, ExB, 1),
+    (C, ExC, 2),
+    (D, ExD, 3),
+    (E, ExE, 4),
+    (F, ExF, 5),
+    (G, ExG, 6),
+    (H, ExH, 7),
+    (I, ExI, 8)
+);
+impl_extend_tuple!(
+    (A, ExA, 0),
+    (B, ExB, 1),
+    (C, ExC, 2),
+    (D, ExD, 3),
+    (E, ExE, 4),
+    (F, ExF, 5),
+    (G, ExG, 6),
+    (H, ExH, 7),
+    (I, ExI, 8),
+    (J, ExJ, 9)
+);
+impl_extend_tuple!(
+    (A, ExA, 0),
+    (B, ExB, 1),
+    (C, ExC, 2),
+    (D, ExD, 3),
+    (E, ExE, 4),
+    (F, ExF, 5),
+    (G, ExG, 6),
+    (H, ExH, 7),
+    (I, ExI, 8),
+    (J, ExJ, 9),
+    (K, ExK, 10)
+);
+impl_extend_tuple!(
+    (A, ExA, 0),
+    (B, ExB, 1),
+    (C, ExC, 2),
+    (D, ExD, 3),
+    (E, ExE, 4),
+    (F, ExF, 5),
+    (G, ExG, 6),
+    (H, ExH, 7),
+    (I, ExI, 8),
+    (J, ExJ, 9),
+    (K, ExK, 10),
+    (L, ExL, 11)
 );

From af66ece8221eb0a20fa17407182f6d01739bf8c9 Mon Sep 17 00:00:00 2001
From: Frank Steffahn <fdsteffahn@gmail.com>
Date: Sat, 22 Feb 2025 01:09:51 +0100
Subject: [PATCH 0002/1889] Add tests for `Extend<(T, U)> for (ExtendT,
 ExtendU)` ordering of side-effects to `coretest`.

---
 .../coretests/tests/iter/traits/iterator.rs   | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/library/coretests/tests/iter/traits/iterator.rs b/library/coretests/tests/iter/traits/iterator.rs
index e31d2e15b6d7e..5ef1f797ae55d 100644
--- a/library/coretests/tests/iter/traits/iterator.rs
+++ b/library/coretests/tests/iter/traits/iterator.rs
@@ -1,3 +1,5 @@
+use core::cell::RefCell;
+use core::iter::zip;
 use core::num::NonZero;
 
 /// A wrapper struct that implements `Eq` and `Ord` based on the wrapped
@@ -642,6 +644,26 @@ fn test_collect_for_tuples() {
     assert!(e.2 == d);
 }
 
+#[test]
+fn test_extend_for_tuple_side_effects_order() {
+    struct TrackingExtender<'a, T>(&'static str, &'a RefCell<Vec<(&'static str, Vec<T>)>>, Vec<T>);
+    impl<T: Clone> Extend<T> for TrackingExtender<'_, T> {
+        fn extend<I: IntoIterator<Item = T>>(&mut self, i: I) {
+            let items = Vec::from_iter(i);
+            self.1.borrow_mut().push((self.0, items.clone()));
+            self.2.extend(items);
+        }
+    }
+
+    let effects = RefCell::new(vec![]);
+    let l = TrackingExtender("l", &effects, vec![]);
+    let r = TrackingExtender("r", &effects, vec![]);
+    let mut p = ((l, r), ());
+    p.extend(zip([(1, 2), (3, 4)], [(), ()]));
+    let effects = effects.into_inner();
+    assert_eq!(effects, [("l", vec![1]), ("r", vec![2]), ("l", vec![3]), ("r", vec![4])]);
+}
+
 // just tests by whether or not this compiles
 fn _empty_impl_all_auto_traits<T>() {
     use std::panic::{RefUnwindSafe, UnwindSafe};

From bebaa8a29da776739f7d507d4e6a679656e687f2 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Wed, 9 Apr 2025 12:43:06 -0500
Subject: [PATCH 0003/1889] add sitemap to rust docs

---
 src/bootstrap/src/core/build_steps/dist.rs | 1 +
 src/doc/robots.txt                         | 2 ++
 src/doc/sitemap.txt                        | 4 ++++
 3 files changed, 7 insertions(+)
 create mode 100644 src/doc/sitemap.txt

diff --git a/src/bootstrap/src/core/build_steps/dist.rs b/src/bootstrap/src/core/build_steps/dist.rs
index 83f71aeed7204..6ec39ffc4366c 100644
--- a/src/bootstrap/src/core/build_steps/dist.rs
+++ b/src/bootstrap/src/core/build_steps/dist.rs
@@ -82,6 +82,7 @@ impl Step for Docs {
         tarball.set_product_name("Rust Documentation");
         tarball.add_bulk_dir(builder.doc_out(host), dest);
         tarball.add_file(builder.src.join("src/doc/robots.txt"), dest, FileType::Regular);
+        tarball.add_file(builder.src.join("src/doc/sitemap.txt"), dest, FileType::Regular);
         Some(tarball.generate())
     }
 }
diff --git a/src/doc/robots.txt b/src/doc/robots.txt
index 3a2552e9a159b..71a60f89c14c6 100644
--- a/src/doc/robots.txt
+++ b/src/doc/robots.txt
@@ -9,3 +9,5 @@ Disallow: /beta/book/first-edition/
 Disallow: /beta/book/second-edition/
 Disallow: /nightly/book/first-edition/
 Disallow: /nightly/book/second-edition/
+
+Sitemap: https://doc.rust-lang.org/sitemap.txt
diff --git a/src/doc/sitemap.txt b/src/doc/sitemap.txt
new file mode 100644
index 0000000000000..6e5f0fbad37f5
--- /dev/null
+++ b/src/doc/sitemap.txt
@@ -0,0 +1,4 @@
+https://doc.rust-lang.org/stable/
+https://doc.rust-lang.org/beta/
+https://doc.rust-lang.org/nightly/
+

From a22c8ed6311979d292e835e5a5498d0e3cc95dc0 Mon Sep 17 00:00:00 2001
From: Thalia Archibald <thalia@archibald.dev>
Date: Sat, 12 Apr 2025 16:33:38 -0700
Subject: [PATCH 0004/1889] zkVM: Fix env::ArgsOs

The zkVM implementation of `env::ArgsOs` incorrectly reports the full
length even after having iterated. Instead, use a range approach which
works out to be simpler. Also, implement more iterator methods like the
other platforms in #139847.
---
 library/std/src/sys/args/zkvm.rs | 71 ++++++++++++++++++++++++--------
 1 file changed, 54 insertions(+), 17 deletions(-)

diff --git a/library/std/src/sys/args/zkvm.rs b/library/std/src/sys/args/zkvm.rs
index 194ba7159d459..e4b1ad540ac04 100644
--- a/library/std/src/sys/args/zkvm.rs
+++ b/library/std/src/sys/args/zkvm.rs
@@ -1,18 +1,19 @@
 use crate::ffi::OsString;
 use crate::fmt;
+use crate::num::NonZero;
 use crate::sys::os_str;
 use crate::sys::pal::{WORD_SIZE, abi};
 use crate::sys_common::FromInner;
 
+#[derive(Clone)]
 pub struct Args {
-    i_forward: usize,
-    i_back: usize,
-    count: usize,
+    front: usize,
+    back: usize,
 }
 
 pub fn args() -> Args {
     let count = unsafe { abi::sys_argc() };
-    Args { i_forward: 0, i_back: 0, count }
+    Args { front: 0, back: count }
 }
 
 impl Args {
@@ -38,44 +39,80 @@ impl Args {
     }
 }
 
+impl !Send for Args {}
+impl !Sync for Args {}
+
 impl fmt::Debug for Args {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_list().finish()
+        f.debug_list().entries(self.clone()).finish()
     }
 }
 
 impl Iterator for Args {
     type Item = OsString;
 
+    #[inline]
     fn next(&mut self) -> Option<OsString> {
-        if self.i_forward >= self.count - self.i_back {
+        if self.front == self.back {
             None
         } else {
-            let arg = Self::argv(self.i_forward);
-            self.i_forward += 1;
+            let arg = Self::argv(self.front);
+            self.front += 1;
             Some(arg)
         }
     }
 
+    #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.count, Some(self.count))
+        let len = self.len();
+        (len, Some(len))
     }
-}
 
-impl ExactSizeIterator for Args {
-    fn len(&self) -> usize {
-        self.count
+    #[inline]
+    fn count(self) -> usize {
+        self.len()
+    }
+
+    #[inline]
+    fn last(mut self) -> Option<OsString> {
+        self.next_back()
+    }
+
+    #[inline]
+    fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
+        let step_size = self.len().min(n);
+        self.front += step_size;
+        NonZero::new(n - step_size).map_or(Ok(()), Err)
     }
 }
 
 impl DoubleEndedIterator for Args {
+    #[inline]
     fn next_back(&mut self) -> Option<OsString> {
-        if self.i_back >= self.count - self.i_forward {
+        if self.back == self.front {
             None
         } else {
-            let arg = Self::argv(self.count - 1 - self.i_back);
-            self.i_back += 1;
-            Some(arg)
+            self.back -= 1;
+            Some(Self::argv(self.back))
         }
     }
+
+    #[inline]
+    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
+        let step_size = self.len().min(n);
+        self.back -= step_size;
+        NonZero::new(n - step_size).map_or(Ok(()), Err)
+    }
+}
+
+impl ExactSizeIterator for Args {
+    #[inline]
+    fn len(&self) -> usize {
+        self.back - self.front
+    }
+
+    #[inline]
+    fn is_empty(&self) -> bool {
+        self.front == self.back
+    }
 }

From 00095982a0d2f6c8bfb5cb2706338ad2b14304f5 Mon Sep 17 00:00:00 2001
From: Thalia Archibald <thalia@archibald.dev>
Date: Tue, 15 Apr 2025 02:41:51 -0700
Subject: [PATCH 0005/1889] zkVM: Cache args from host

Retrieve argc/argv from the host once, on demand when the first
`env::ArgsOs` is constructed, and globally cache it. Copy each argument
to an `OsString` while iterating.
---
 library/std/src/sys/args/zkvm.rs | 86 ++++++++++++--------------------
 1 file changed, 31 insertions(+), 55 deletions(-)

diff --git a/library/std/src/sys/args/zkvm.rs b/library/std/src/sys/args/zkvm.rs
index e4b1ad540ac04..d26bf1eaff91f 100644
--- a/library/std/src/sys/args/zkvm.rs
+++ b/library/std/src/sys/args/zkvm.rs
@@ -1,26 +1,20 @@
-use crate::ffi::OsString;
-use crate::fmt;
+use crate::ffi::{OsStr, OsString};
 use crate::num::NonZero;
-use crate::sys::os_str;
+use crate::sync::OnceLock;
 use crate::sys::pal::{WORD_SIZE, abi};
-use crate::sys_common::FromInner;
-
-#[derive(Clone)]
-pub struct Args {
-    front: usize,
-    back: usize,
-}
+use crate::{fmt, ptr, slice};
 
 pub fn args() -> Args {
-    let count = unsafe { abi::sys_argc() };
-    Args { front: 0, back: count }
+    Args { iter: ARGS.get_or_init(|| get_args()).iter() }
 }
 
-impl Args {
-    /// Use sys_argv to get the arg at the requested index. Does not check that i is less than argc
-    /// and will not return if the index is out of bounds.
-    fn argv(i: usize) -> OsString {
-        let arg_len = unsafe { abi::sys_argv(crate::ptr::null_mut(), 0, i) };
+fn get_args() -> Vec<&'static OsStr> {
+    let argc = unsafe { abi::sys_argc() };
+    let mut args = Vec::with_capacity(argc);
+
+    for i in 0..argc {
+        // Get the size of the argument then the data.
+        let arg_len = unsafe { abi::sys_argv(ptr::null_mut(), 0, i) };
 
         let arg_len_words = (arg_len + WORD_SIZE - 1) / WORD_SIZE;
         let words = unsafe { abi::sys_alloc_words(arg_len_words) };
@@ -28,15 +22,16 @@ impl Args {
         let arg_len2 = unsafe { abi::sys_argv(words, arg_len_words, i) };
         debug_assert_eq!(arg_len, arg_len2);
 
-        // Convert to OsString.
-        //
-        // FIXME: We can probably get rid of the extra copy here if we
-        // reimplement "os_str" instead of just using the generic unix
-        // "os_str".
-        let arg_bytes: &[u8] =
-            unsafe { crate::slice::from_raw_parts(words.cast() as *const u8, arg_len) };
-        OsString::from_inner(os_str::Buf { inner: arg_bytes.to_vec() })
+        let arg_bytes = unsafe { slice::from_raw_parts(words.cast(), arg_len) };
+        args.push(unsafe { OsStr::from_encoded_bytes_unchecked(arg_bytes) });
     }
+    args
+}
+
+static ARGS: OnceLock<Vec<&'static OsStr>> = OnceLock::new();
+
+pub struct Args {
+    iter: slice::Iter<'static, &'static OsStr>,
 }
 
 impl !Send for Args {}
@@ -44,75 +39,56 @@ impl !Sync for Args {}
 
 impl fmt::Debug for Args {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_list().entries(self.clone()).finish()
+        self.iter.as_slice().fmt(f)
     }
 }
 
 impl Iterator for Args {
     type Item = OsString;
 
-    #[inline]
     fn next(&mut self) -> Option<OsString> {
-        if self.front == self.back {
-            None
-        } else {
-            let arg = Self::argv(self.front);
-            self.front += 1;
-            Some(arg)
-        }
+        self.iter.next().map(|arg| arg.to_os_string())
     }
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        let len = self.len();
-        (len, Some(len))
+        self.iter.size_hint()
     }
 
     #[inline]
     fn count(self) -> usize {
-        self.len()
+        self.iter.len()
     }
 
-    #[inline]
-    fn last(mut self) -> Option<OsString> {
-        self.next_back()
+    fn last(self) -> Option<OsString> {
+        self.iter.last().map(|arg| arg.to_os_string())
     }
 
     #[inline]
     fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
-        let step_size = self.len().min(n);
-        self.front += step_size;
-        NonZero::new(n - step_size).map_or(Ok(()), Err)
+        self.iter.advance_by(n)
     }
 }
 
 impl DoubleEndedIterator for Args {
-    #[inline]
     fn next_back(&mut self) -> Option<OsString> {
-        if self.back == self.front {
-            None
-        } else {
-            self.back -= 1;
-            Some(Self::argv(self.back))
-        }
+        self.iter.next_back().map(|arg| arg.to_os_string())
     }
 
     #[inline]
     fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
-        let step_size = self.len().min(n);
-        self.back -= step_size;
-        NonZero::new(n - step_size).map_or(Ok(()), Err)
+        self.iter.advance_back_by(n)
     }
 }
 
 impl ExactSizeIterator for Args {
     #[inline]
     fn len(&self) -> usize {
-        self.back - self.front
+        self.iter.len()
     }
 
     #[inline]
     fn is_empty(&self) -> bool {
-        self.front == self.back
+        self.iter.is_empty()
     }
 }

From ea2ea62fd1577cc67dc61d6b1b40e5f7427ed704 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Wed, 4 Jun 2025 13:40:50 +0200
Subject: [PATCH 0006/1889] Note that using `enumerate()` will swap the
 arguments

The autofix now:

- includes the swapping of index and element in the closure in which the
  content will be consumed;
- notes, with applicability `MaybeIncorrect` (because it will be), that
  the element and the index will be swapped.
---
 .../src/methods/range_zip_with_len.rs         | 96 +++++++++++++++++--
 clippy_utils/src/sym.rs                       |  4 +
 tests/ui/range.fixed                          | 16 +++-
 tests/ui/range.rs                             | 16 +++-
 tests/ui/range.stderr                         | 29 +++++-
 tests/ui/range_unfixable.rs                   | 14 +++
 tests/ui/range_unfixable.stderr               | 12 +++
 7 files changed, 172 insertions(+), 15 deletions(-)
 create mode 100644 tests/ui/range_unfixable.rs
 create mode 100644 tests/ui/range_unfixable.stderr

diff --git a/clippy_lints/src/methods/range_zip_with_len.rs b/clippy_lints/src/methods/range_zip_with_len.rs
index 3a5e321720865..e13df18333e46 100644
--- a/clippy_lints/src/methods/range_zip_with_len.rs
+++ b/clippy_lints/src/methods/range_zip_with_len.rs
@@ -1,10 +1,9 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet;
-use clippy_utils::{SpanlessEq, higher, is_integer_const, is_trait_method};
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::{SpanRangeExt as _, snippet_with_applicability};
+use clippy_utils::{SpanlessEq, get_parent_expr, higher, is_integer_const, is_trait_method, sym};
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, QPath};
+use rustc_hir::{Expr, ExprKind, Node, Pat, PatKind, QPath};
 use rustc_lint::LateContext;
-use rustc_span::sym;
 
 use super::RANGE_ZIP_WITH_LEN;
 
@@ -21,14 +20,93 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, recv: &'
         && let ExprKind::Path(QPath::Resolved(_, len_path)) = len_recv.kind
         && SpanlessEq::new(cx).eq_path_segments(iter_path.segments, len_path.segments)
     {
-        span_lint_and_sugg(
+        span_lint_and_then(
             cx,
             RANGE_ZIP_WITH_LEN,
             expr.span,
             "using `.zip()` with a range and `.len()`",
-            "try",
-            format!("{}.iter().enumerate()", snippet(cx, recv.span, "_")),
-            Applicability::MachineApplicable,
+            |diag| {
+                // If the iterator content is consumed by a pattern with exactly two elements, swap
+                // the order of those elements. Otherwise, the suggestion will be marked as
+                // `Applicability::MaybeIncorrect` (because it will be), and a note will be added
+                // to the diagnostic to underline the swapping of the index and the content.
+                let pat = methods_pattern(cx, expr).or_else(|| for_loop_pattern(cx, expr));
+                let invert_bindings = if let Some(pat) = pat
+                    && pat.span.eq_ctxt(expr.span)
+                    && let PatKind::Tuple([first, second], _) = pat.kind
+                {
+                    Some((first.span, second.span))
+                } else {
+                    None
+                };
+                let mut app = Applicability::MachineApplicable;
+                let mut suggestions = vec![(
+                    expr.span,
+                    format!(
+                        "{}.iter().enumerate()",
+                        snippet_with_applicability(cx, recv.span, "_", &mut app)
+                    ),
+                )];
+                if let Some((left, right)) = invert_bindings
+                    && let Some(snip_left) = left.get_source_text(cx)
+                    && let Some(snip_right) = right.get_source_text(cx)
+                {
+                    suggestions.extend([(left, snip_right.to_string()), (right, snip_left.to_string())]);
+                } else {
+                    app = Applicability::MaybeIncorrect;
+                }
+                diag.multipart_suggestion("use", suggestions, app);
+                if app != Applicability::MachineApplicable {
+                    diag.note("the order of the element and the index will be swapped");
+                }
+            },
         );
     }
 }
+
+/// If `expr` is the argument of a `for` loop, return the loop pattern.
+fn for_loop_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx Pat<'tcx>> {
+    cx.tcx.hir_parent_iter(expr.hir_id).find_map(|(_, node)| {
+        if let Node::Expr(ancestor_expr) = node
+            && let Some(for_loop) = higher::ForLoop::hir(ancestor_expr)
+            && for_loop.arg.hir_id == expr.hir_id
+        {
+            Some(for_loop.pat)
+        } else {
+            None
+        }
+    })
+}
+
+/// If `expr` is the receiver of an `Iterator` method which consumes the iterator elements and feed
+/// them to a closure, return the pattern of the closure.
+fn methods_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx Pat<'tcx>> {
+    if let Some(parent_expr) = get_parent_expr(cx, expr)
+        && is_trait_method(cx, expr, sym::Iterator)
+        && let ExprKind::MethodCall(method, recv, [arg], _) = parent_expr.kind
+        && recv.hir_id == expr.hir_id
+        && matches!(
+            method.ident.name,
+            sym::all
+                | sym::any
+                | sym::filter_map
+                | sym::find_map
+                | sym::flat_map
+                | sym::for_each
+                | sym::is_partitioned
+                | sym::is_sorted_by_key
+                | sym::map
+                | sym::map_while
+                | sym::position
+                | sym::rposition
+                | sym::try_for_each
+        )
+        && let ExprKind::Closure(closure) = arg.kind
+        && let body = cx.tcx.hir_body(closure.body)
+        && let [param] = body.params
+    {
+        Some(param.pat)
+    } else {
+        None
+    }
+}
diff --git a/clippy_utils/src/sym.rs b/clippy_utils/src/sym.rs
index a544954931bad..1fe9e62fae30c 100644
--- a/clippy_utils/src/sym.rs
+++ b/clippy_utils/src/sym.rs
@@ -191,8 +191,10 @@ generate! {
     is_none,
     is_none_or,
     is_ok,
+    is_partitioned,
     is_some,
     is_some_and,
+    is_sorted_by_key,
     isqrt,
     itertools,
     join,
@@ -210,6 +212,7 @@ generate! {
     map_continue,
     map_or,
     map_or_else,
+    map_while,
     match_indices,
     matches,
     max,
@@ -349,6 +352,7 @@ generate! {
     trim_start,
     trim_start_matches,
     truncate,
+    try_for_each,
     unreachable_pub,
     unsafe_removed_from_name,
     unused,
diff --git a/tests/ui/range.fixed b/tests/ui/range.fixed
index 0e951d88091b7..c8e654600045e 100644
--- a/tests/ui/range.fixed
+++ b/tests/ui/range.fixed
@@ -1,11 +1,23 @@
 #![allow(clippy::useless_vec)]
 #[warn(clippy::range_zip_with_len)]
 fn main() {
-    let v1 = vec![1, 2, 3];
-    let v2 = vec![4, 5];
+    let v1: Vec<u64> = vec![1, 2, 3];
+    let v2: Vec<u64> = vec![4, 5];
     let _x = v1.iter().enumerate();
     //~^ range_zip_with_len
 
+    //~v range_zip_with_len
+    for (i, e) in v1.iter().enumerate() {
+        let _: &u64 = e;
+        let _: usize = i;
+    }
+
+    //~v range_zip_with_len
+    v1.iter().enumerate().for_each(|(i, e)| {
+        let _: &u64 = e;
+        let _: usize = i;
+    });
+
     let _y = v1.iter().zip(0..v2.len()); // No error
 }
 
diff --git a/tests/ui/range.rs b/tests/ui/range.rs
index 5343801647434..352d517eabdd7 100644
--- a/tests/ui/range.rs
+++ b/tests/ui/range.rs
@@ -1,11 +1,23 @@
 #![allow(clippy::useless_vec)]
 #[warn(clippy::range_zip_with_len)]
 fn main() {
-    let v1 = vec![1, 2, 3];
-    let v2 = vec![4, 5];
+    let v1: Vec<u64> = vec![1, 2, 3];
+    let v2: Vec<u64> = vec![4, 5];
     let _x = v1.iter().zip(0..v1.len());
     //~^ range_zip_with_len
 
+    //~v range_zip_with_len
+    for (e, i) in v1.iter().zip(0..v1.len()) {
+        let _: &u64 = e;
+        let _: usize = i;
+    }
+
+    //~v range_zip_with_len
+    v1.iter().zip(0..v1.len()).for_each(|(e, i)| {
+        let _: &u64 = e;
+        let _: usize = i;
+    });
+
     let _y = v1.iter().zip(0..v2.len()); // No error
 }
 
diff --git a/tests/ui/range.stderr b/tests/ui/range.stderr
index 798ce1842d8b5..b0a852a69fc5a 100644
--- a/tests/ui/range.stderr
+++ b/tests/ui/range.stderr
@@ -2,10 +2,35 @@ error: using `.zip()` with a range and `.len()`
   --> tests/ui/range.rs:6:14
    |
 LL |     let _x = v1.iter().zip(0..v1.len());
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `v1.iter().enumerate()`
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `v1.iter().enumerate()`
    |
+   = note: the order of the element and the index will be swapped
    = note: `-D clippy::range-zip-with-len` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::range_zip_with_len)]`
 
-error: aborting due to 1 previous error
+error: using `.zip()` with a range and `.len()`
+  --> tests/ui/range.rs:10:19
+   |
+LL |     for (e, i) in v1.iter().zip(0..v1.len()) {
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use
+   |
+LL -     for (e, i) in v1.iter().zip(0..v1.len()) {
+LL +     for (i, e) in v1.iter().enumerate() {
+   |
+
+error: using `.zip()` with a range and `.len()`
+  --> tests/ui/range.rs:16:5
+   |
+LL |     v1.iter().zip(0..v1.len()).for_each(|(e, i)| {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use
+   |
+LL -     v1.iter().zip(0..v1.len()).for_each(|(e, i)| {
+LL +     v1.iter().enumerate().for_each(|(i, e)| {
+   |
+
+error: aborting due to 3 previous errors
 
diff --git a/tests/ui/range_unfixable.rs b/tests/ui/range_unfixable.rs
new file mode 100644
index 0000000000000..259be23fa1e5a
--- /dev/null
+++ b/tests/ui/range_unfixable.rs
@@ -0,0 +1,14 @@
+//@no-rustfix
+#![allow(clippy::useless_vec)]
+#[warn(clippy::range_zip_with_len)]
+fn main() {
+    let v1: Vec<u64> = vec![1, 2, 3];
+    let v2: Vec<u64> = vec![4, 5];
+
+    // Do not autofix, `filter()` would not consume the iterator.
+    //~v range_zip_with_len
+    v1.iter().zip(0..v1.len()).filter(|(_, i)| *i < 2).for_each(|(e, i)| {
+        let _: &u64 = e;
+        let _: usize = i;
+    });
+}
diff --git a/tests/ui/range_unfixable.stderr b/tests/ui/range_unfixable.stderr
new file mode 100644
index 0000000000000..fb03ea2c05f6b
--- /dev/null
+++ b/tests/ui/range_unfixable.stderr
@@ -0,0 +1,12 @@
+error: using `.zip()` with a range and `.len()`
+  --> tests/ui/range_unfixable.rs:10:5
+   |
+LL |     v1.iter().zip(0..v1.len()).filter(|(_, i)| *i < 2).for_each(|(e, i)| {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `v1.iter().enumerate()`
+   |
+   = note: the order of the element and the index will be swapped
+   = note: `-D clippy::range-zip-with-len` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::range_zip_with_len)]`
+
+error: aborting due to 1 previous error
+

From 4acf3baecda9c5080bcfdc1ebb4560fbb2a4567e Mon Sep 17 00:00:00 2001
From: Martin Pool <mbp@sourcefrog.net>
Date: Fri, 20 Jun 2025 13:18:05 -0700
Subject: [PATCH 0007/1889] libtest: expose --fail-fast

---
 library/test/src/cli.rs          |  4 +++-
 src/doc/rustc/src/tests/index.md | 10 ++++++++++
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/library/test/src/cli.rs b/library/test/src/cli.rs
index 8840714a66238..d19141b8c2c73 100644
--- a/library/test/src/cli.rs
+++ b/library/test/src/cli.rs
@@ -57,6 +57,7 @@ fn optgroups() -> getopts::Options {
         .optflag("", "test", "Run tests and not benchmarks")
         .optflag("", "bench", "Run benchmarks instead of tests")
         .optflag("", "list", "List all tests and benchmarks")
+        .optflag("", "fail-fast", "Don't start new tests after the first failure")
         .optflag("h", "help", "Display this message")
         .optopt("", "logfile", "Write logs to the specified file (deprecated)", "PATH")
         .optflag(
@@ -270,6 +271,7 @@ fn parse_opts_impl(matches: getopts::Matches) -> OptRes {
     let exact = matches.opt_present("exact");
     let list = matches.opt_present("list");
     let skip = matches.opt_strs("skip");
+    let fail_fast = matches.opt_present("fail-fast");
 
     let bench_benchmarks = matches.opt_present("bench");
     let run_tests = !bench_benchmarks || matches.opt_present("test");
@@ -307,7 +309,7 @@ fn parse_opts_impl(matches: getopts::Matches) -> OptRes {
         skip,
         time_options,
         options,
-        fail_fast: false,
+        fail_fast,
     };
 
     Ok(test_opts)
diff --git a/src/doc/rustc/src/tests/index.md b/src/doc/rustc/src/tests/index.md
index 12de69a4c9eec..7033184e52aa9 100644
--- a/src/doc/rustc/src/tests/index.md
+++ b/src/doc/rustc/src/tests/index.md
@@ -158,6 +158,16 @@ unstable-options` flag. See [tracking issue
 
 The following options affect how tests are executed.
 
+#### `--fail-fast`
+
+Stops tests after the first failure.
+
+If running tests in parallel (which is the default), then tests that have already been started on
+other threads will be allowed to run to completion before the process exits.
+
+Note that when running tests in parallel, the test execution order is non-deterministic:
+if multiple tests would fail, the first failure encountered will be reported.
+
 #### `--test-threads` _NUM_THREADS_
 
 Sets the number of threads to use for running tests in parallel. By default,

From 547c72901ad145b40d7271e3ddef2b4ac0c53619 Mon Sep 17 00:00:00 2001
From: Martin Pool <mbp@sourcefrog.net>
Date: Fri, 20 Jun 2025 13:27:53 -0700
Subject: [PATCH 0008/1889] Make fail-fast unstable

---
 library/test/src/cli.rs          | 2 +-
 src/doc/rustc/src/tests/index.md | 2 ++
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/library/test/src/cli.rs b/library/test/src/cli.rs
index d19141b8c2c73..ea91ebc4e9875 100644
--- a/library/test/src/cli.rs
+++ b/library/test/src/cli.rs
@@ -262,6 +262,7 @@ fn parse_opts_impl(matches: getopts::Matches) -> OptRes {
     // Unstable flags
     let force_run_in_process = unstable_optflag!(matches, allow_unstable, "force-run-in-process");
     let exclude_should_panic = unstable_optflag!(matches, allow_unstable, "exclude-should-panic");
+    let fail_fast = unstable_optflag!(matches, allow_unstable, "fail-fast");
     let time_options = get_time_options(&matches, allow_unstable)?;
     let shuffle = get_shuffle(&matches, allow_unstable)?;
     let shuffle_seed = get_shuffle_seed(&matches, allow_unstable)?;
@@ -271,7 +272,6 @@ fn parse_opts_impl(matches: getopts::Matches) -> OptRes {
     let exact = matches.opt_present("exact");
     let list = matches.opt_present("list");
     let skip = matches.opt_strs("skip");
-    let fail_fast = matches.opt_present("fail-fast");
 
     let bench_benchmarks = matches.opt_present("bench");
     let run_tests = !bench_benchmarks || matches.opt_present("test");
diff --git a/src/doc/rustc/src/tests/index.md b/src/doc/rustc/src/tests/index.md
index 7033184e52aa9..ab96fbcd3178e 100644
--- a/src/doc/rustc/src/tests/index.md
+++ b/src/doc/rustc/src/tests/index.md
@@ -168,6 +168,8 @@ other threads will be allowed to run to completion before the process exits.
 Note that when running tests in parallel, the test execution order is non-deterministic:
 if multiple tests would fail, the first failure encountered will be reported.
 
+⚠️ 🚧 This requires the `-Z unstable-options` flag.
+
 #### `--test-threads` _NUM_THREADS_
 
 Sets the number of threads to use for running tests in parallel. By default,

From a8d417d1a53dc22c42054327aca52a3b6a034150 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 29 Mar 2025 22:46:36 +0100
Subject: [PATCH 0009/1889] rework `useless_vec` lint

---
 clippy_lints/src/vec.rs | 218 ++++++++++++++++++++++++----------------
 1 file changed, 132 insertions(+), 86 deletions(-)

diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index 7b6a25123e85e..1646f22202122 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -1,4 +1,6 @@
 use std::collections::BTreeMap;
+use std::collections::btree_map::Entry;
+use std::mem;
 use std::ops::ControlFlow;
 
 use clippy_config::Conf;
@@ -20,15 +22,36 @@ use rustc_span::{DesugaringKind, Span};
 pub struct UselessVec {
     too_large_for_stack: u64,
     msrv: Msrv,
-    span_to_lint_map: BTreeMap<Span, Option<(HirId, SuggestedType, String, Applicability)>>,
+    /// Maps from a `vec![]` source callsite invocation span to the "state" (i.e., whether we can
+    /// emit a warning there or not).
+    ///
+    /// The purpose of this is to buffer lints up until `check_expr_post` so that we can cancel a
+    /// lint while visiting, because a `vec![]` invocation span can appear multiple times when
+    /// it is passed as a macro argument, once in a context that doesn't require a `Vec<_>` and
+    /// another time that does. Consider:
+    /// ```
+    /// macro_rules! m {
+    ///     ($v:expr) => {
+    ///         let a = $v;
+    ///         $v.push(3);
+    ///     }
+    /// }
+    /// m!(vec![1, 2]);
+    /// ```
+    /// The macro invocation expands to two `vec![1, 2]` invocations. If we eagerly suggest changing
+    /// the first `vec![1, 2]` (which is shared with the other expn) to an array which indeed would
+    /// work, we get a false positive warning on the `$v.push(3)` which really requires `$v` to
+    /// be a vector.
+    span_to_state: BTreeMap<Span, VecState>,
     allow_in_test: bool,
 }
+
 impl UselessVec {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
             too_large_for_stack: conf.too_large_for_stack,
             msrv: conf.msrv,
-            span_to_lint_map: BTreeMap::new(),
+            span_to_state: BTreeMap::new(),
             allow_in_test: conf.allow_useless_vec_in_tests,
         }
     }
@@ -62,17 +85,28 @@ declare_clippy_lint! {
 
 impl_lint_pass!(UselessVec => [USELESS_VEC]);
 
-impl<'tcx> LateLintPass<'tcx> for UselessVec {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        let Some(vec_args) = higher::VecArgs::hir(cx, expr.peel_borrows()) else {
-            return;
-        };
-        if self.allow_in_test && is_in_test(cx.tcx, expr.hir_id) {
-            return;
-        }
-        // the parent callsite of this `vec!` expression, or span to the borrowed one such as `&vec!`
-        let callsite = expr.span.parent_callsite().unwrap_or(expr.span);
+/// The "state" of a `vec![]` invocation, indicating whether it can or cannot be changed.
+enum VecState {
+    Change {
+        suggest_ty: SuggestedType,
+        vec_snippet: String,
+        expr_hir_id: HirId,
+    },
+    NoChange,
+}
 
+enum VecToArray {
+    /// Expression does not need to be a `Vec<_>` and its type can be changed to an array (or
+    /// slice).
+    Possible,
+    /// Expression must be a `Vec<_>`. Type cannot change.
+    Impossible,
+}
+
+impl UselessVec {
+    /// Checks if the surrounding environment requires this expression to actually be of type
+    /// `Vec<_>`, or if it can be changed to `&[]`/`[]` without causing type errors.
+    fn expr_usage_requires_vec(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) -> VecToArray {
         match cx.tcx.parent_hir_node(expr.hir_id) {
             // search for `let foo = vec![_]` expressions where all uses of `foo`
             // adjust to slices or call a method that exist on slices (e.g. len)
@@ -100,110 +134,122 @@ impl<'tcx> LateLintPass<'tcx> for UselessVec {
                 .is_continue();
 
                 if only_slice_uses {
-                    self.check_vec_macro(cx, &vec_args, callsite, expr.hir_id, SuggestedType::Array);
+                    VecToArray::Possible
                 } else {
-                    self.span_to_lint_map.insert(callsite, None);
+                    VecToArray::Impossible
                 }
             },
             // if the local pattern has a specified type, do not lint.
             Node::LetStmt(LetStmt { ty: Some(_), .. }) if higher::VecArgs::hir(cx, expr).is_some() => {
-                self.span_to_lint_map.insert(callsite, None);
+                VecToArray::Impossible
             },
             // search for `for _ in vec![...]`
             Node::Expr(Expr { span, .. })
                 if span.is_desugaring(DesugaringKind::ForLoop) && self.msrv.meets(cx, msrvs::ARRAY_INTO_ITERATOR) =>
             {
-                let suggest_slice = suggest_type(expr);
-                self.check_vec_macro(cx, &vec_args, callsite, expr.hir_id, suggest_slice);
+                VecToArray::Possible
             },
             // search for `&vec![_]` or `vec![_]` expressions where the adjusted type is `&[_]`
             _ => {
-                let suggest_slice = suggest_type(expr);
-
                 if adjusts_to_slice(cx, expr) {
-                    self.check_vec_macro(cx, &vec_args, callsite, expr.hir_id, suggest_slice);
+                    VecToArray::Possible
                 } else {
-                    self.span_to_lint_map.insert(callsite, None);
+                    VecToArray::Impossible
                 }
             },
         }
     }
+}
+
+impl<'tcx> LateLintPass<'tcx> for UselessVec {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if let Some(vec_args) = higher::VecArgs::hir(cx, expr.peel_borrows())
+            // The `vec![]` or `&vec![]` invocation span.
+            && let vec_span = expr.span.parent_callsite().unwrap_or(expr.span)
+            && !vec_span.from_expansion()
+        {
+            if self.allow_in_test && is_in_test(cx.tcx, expr.hir_id) {
+                return;
+            }
+
+            match self.expr_usage_requires_vec(cx, expr) {
+                VecToArray::Possible => {
+                    let suggest_ty = suggest_type(expr);
+
+                    // Size and `Copy` checks don't depend on the enclosing usage of the expression
+                    // and don't need to be inserted into the state map.
+                    let vec_snippet = match vec_args {
+                        higher::VecArgs::Repeat(expr, len) => {
+                            if is_copy(cx, cx.typeck_results().expr_ty(expr))
+                                && let Some(Constant::Int(length)) = ConstEvalCtxt::new(cx).eval(len)
+                                && let Ok(length) = u64::try_from(length)
+                                && size_of(cx, expr)
+                                    .checked_mul(length)
+                                    .is_some_and(|size| size <= self.too_large_for_stack)
+                            {
+                                suggest_ty.snippet(cx, Some(expr.span), Some(len.span))
+                            } else {
+                                return;
+                            }
+                        },
+                        higher::VecArgs::Vec(args) => {
+                            if let Ok(length) = u64::try_from(args.len())
+                                && size_of(cx, expr)
+                                    .checked_mul(length)
+                                    .is_some_and(|size| size <= self.too_large_for_stack)
+                            {
+                                suggest_ty.snippet(
+                                    cx,
+                                    args.first().zip(args.last()).map(|(first, last)| {
+                                        first.span.source_callsite().to(last.span.source_callsite())
+                                    }),
+                                    None,
+                                )
+                            } else {
+                                return;
+                            }
+                        },
+                    };
+
+                    if let Entry::Vacant(entry) = self.span_to_state.entry(vec_span) {
+                        entry.insert(VecState::Change {
+                            suggest_ty,
+                            vec_snippet,
+                            expr_hir_id: expr.hir_id,
+                        });
+                    }
+                },
+                VecToArray::Impossible => {
+                    self.span_to_state.insert(vec_span, VecState::NoChange);
+                },
+            }
+        }
+    }
 
     fn check_crate_post(&mut self, cx: &LateContext<'tcx>) {
-        for (span, lint_opt) in &self.span_to_lint_map {
-            if let Some((hir_id, suggest_slice, snippet, applicability)) = lint_opt {
-                let help_msg = format!("you can use {} directly", suggest_slice.desc());
-                span_lint_hir_and_then(cx, USELESS_VEC, *hir_id, *span, "useless use of `vec!`", |diag| {
-                    // If the `vec!` macro contains comment, better not make the suggestion machine
-                    // applicable as it would remove them.
-                    let applicability = if *applicability != Applicability::Unspecified
-                        && let source_map = cx.tcx.sess.source_map()
-                        && span_contains_comment(source_map, *span)
-                    {
+        for (span, state) in mem::take(&mut self.span_to_state) {
+            if let VecState::Change {
+                suggest_ty,
+                vec_snippet,
+                expr_hir_id,
+            } = state
+            {
+                span_lint_hir_and_then(cx, USELESS_VEC, expr_hir_id, span, "useless use of `vec!`", |diag| {
+                    let help_msg = format!("you can use {} directly", suggest_ty.desc());
+                    // If the `vec!` macro contains comment, better not make the suggestion machine applicable as it
+                    // would remove them.
+                    let applicability = if span_contains_comment(cx.tcx.sess.source_map(), span) {
                         Applicability::Unspecified
                     } else {
-                        *applicability
+                        Applicability::MachineApplicable
                     };
-                    diag.span_suggestion(*span, help_msg, snippet, applicability);
+                    diag.span_suggestion(span, help_msg, vec_snippet, applicability);
                 });
             }
         }
     }
 }
 
-impl UselessVec {
-    fn check_vec_macro<'tcx>(
-        &mut self,
-        cx: &LateContext<'tcx>,
-        vec_args: &higher::VecArgs<'tcx>,
-        span: Span,
-        hir_id: HirId,
-        suggest_slice: SuggestedType,
-    ) {
-        if span.from_expansion() {
-            return;
-        }
-
-        let snippet = match *vec_args {
-            higher::VecArgs::Repeat(elem, 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;
-                    }
-
-                    #[expect(clippy::cast_possible_truncation)]
-                    if len_constant as u64 * size_of(cx, elem) > self.too_large_for_stack {
-                        return;
-                    }
-
-                    suggest_slice.snippet(cx, Some(elem.span), Some(len.span))
-                } else {
-                    return;
-                }
-            },
-            higher::VecArgs::Vec(args) => {
-                let args_span = if let Some(last) = args.iter().last() {
-                    if args.len() as u64 * size_of(cx, last) > self.too_large_for_stack {
-                        return;
-                    }
-                    Some(args[0].span.source_callsite().to(last.span.source_callsite()))
-                } else {
-                    None
-                };
-                suggest_slice.snippet(cx, args_span, None)
-            },
-        };
-
-        self.span_to_lint_map.entry(span).or_insert(Some((
-            hir_id,
-            suggest_slice,
-            snippet,
-            Applicability::MachineApplicable,
-        )));
-    }
-}
-
 #[derive(Copy, Clone)]
 pub(crate) enum SuggestedType {
     /// Suggest using a slice `&[..]` / `&mut [..]`

From bfd73ccae051b32686486d1849ea92750d259ad6 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Thu, 3 Apr 2025 17:26:22 +0200
Subject: [PATCH 0010/1889] Add test case for array false positive

---
 tests/ui/vec.fixed  | 9 +++++++++
 tests/ui/vec.rs     | 9 +++++++++
 tests/ui/vec.stderr | 8 +++++++-
 3 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/tests/ui/vec.fixed b/tests/ui/vec.fixed
index f360a8afadf61..55742459c92cf 100644
--- a/tests/ui/vec.fixed
+++ b/tests/ui/vec.fixed
@@ -242,3 +242,12 @@ fn issue_12101() {
     for a in &[1, 2] {}
     //~^ useless_vec
 }
+
+fn issue_14531() {
+    // The lint used to suggest using an array rather than a reference to a slice.
+
+    fn requires_ref_slice(v: &[()]) {}
+    let v = &[];
+    //~^ useless_vec
+    requires_ref_slice(v);
+}
diff --git a/tests/ui/vec.rs b/tests/ui/vec.rs
index a779d33557cb4..fbf7131323c3b 100644
--- a/tests/ui/vec.rs
+++ b/tests/ui/vec.rs
@@ -242,3 +242,12 @@ fn issue_12101() {
     for a in &(vec![1, 2]) {}
     //~^ useless_vec
 }
+
+fn issue_14531() {
+    // The lint used to suggest using an array rather than a reference to a slice.
+
+    fn requires_ref_slice(v: &[()]) {}
+    let v = &vec![];
+    //~^ useless_vec
+    requires_ref_slice(v);
+}
diff --git a/tests/ui/vec.stderr b/tests/ui/vec.stderr
index 806d6617200ff..d16c8a8944a24 100644
--- a/tests/ui/vec.stderr
+++ b/tests/ui/vec.stderr
@@ -127,5 +127,11 @@ error: useless use of `vec!`
 LL |     for a in &(vec![1, 2]) {}
    |              ^^^^^^^^^^^^^ help: you can use a slice directly: `&[1, 2]`
 
-error: aborting due to 21 previous errors
+error: useless use of `vec!`
+  --> tests/ui/vec.rs:250:13
+   |
+LL |     let v = &vec![];
+   |             ^^^^^^^ help: you can use a slice directly: `&[]`
+
+error: aborting due to 22 previous errors
 

From 47e8c315f3e600357f0147b867de798b1b96cd03 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 21 Jun 2025 15:34:31 +0200
Subject: [PATCH 0011/1889] Make sure spans are from the root

---
 clippy_lints/src/vec.rs | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index 1646f22202122..52b30ddce12b8 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -25,7 +25,7 @@ pub struct UselessVec {
     /// Maps from a `vec![]` source callsite invocation span to the "state" (i.e., whether we can
     /// emit a warning there or not).
     ///
-    /// The purpose of this is to buffer lints up until `check_expr_post` so that we can cancel a
+    /// The purpose of this is to buffer lints up until `check_crate_post` so that we can cancel a
     /// lint while visiting, because a `vec![]` invocation span can appear multiple times when
     /// it is passed as a macro argument, once in a context that doesn't require a `Vec<_>` and
     /// another time that does. Consider:
@@ -187,7 +187,11 @@ impl<'tcx> LateLintPass<'tcx> for UselessVec {
                                     .checked_mul(length)
                                     .is_some_and(|size| size <= self.too_large_for_stack)
                             {
-                                suggest_ty.snippet(cx, Some(expr.span), Some(len.span))
+                                suggest_ty.snippet(
+                                    cx,
+                                    Some(expr.span.source_callsite()),
+                                    Some(len.span.source_callsite()),
+                                )
                             } else {
                                 return;
                             }
@@ -267,11 +271,17 @@ impl SuggestedType {
     }
 
     fn snippet(self, cx: &LateContext<'_>, args_span: Option<Span>, len_span: Option<Span>) -> String {
+        // Invariant of the lint as implemented: all spans are from the root context (and as a result,
+        // always trivially crate-local).
+        assert!(args_span.is_none_or(|s| !s.from_expansion()));
+        assert!(len_span.is_none_or(|s| !s.from_expansion()));
+
         let maybe_args = args_span
-            .and_then(|sp| sp.get_source_text(cx))
+            .map(|sp| sp.get_source_text(cx).expect("spans are always crate-local"))
             .map_or(String::new(), |x| x.to_owned());
         let maybe_len = len_span
-            .and_then(|sp| sp.get_source_text(cx).map(|s| format!("; {s}")))
+            .map(|sp| sp.get_source_text(cx).expect("spans are always crate-local"))
+            .map(|st| format!("; {st}"))
             .unwrap_or_default();
 
         match self {

From c40e004a6bf4750c4bd03945852f2d5388d30d3b Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Wed, 2 Jul 2025 07:25:46 +0200
Subject: [PATCH 0012/1889] gai: remove typo from test file, and add a
 reference id

---
 .../generic_arg_infer/{parend_infer.rs => paren_infer.rs}        | 1 +
 1 file changed, 1 insertion(+)
 rename tests/ui/const-generics/generic_arg_infer/{parend_infer.rs => paren_infer.rs} (94%)

diff --git a/tests/ui/const-generics/generic_arg_infer/parend_infer.rs b/tests/ui/const-generics/generic_arg_infer/paren_infer.rs
similarity index 94%
rename from tests/ui/const-generics/generic_arg_infer/parend_infer.rs
rename to tests/ui/const-generics/generic_arg_infer/paren_infer.rs
index 9d7df8016cb1e..869683b705669 100644
--- a/tests/ui/const-generics/generic_arg_infer/parend_infer.rs
+++ b/tests/ui/const-generics/generic_arg_infer/paren_infer.rs
@@ -1,4 +1,5 @@
 //@ check-pass
+//@ reference: items.generics.const.inferred
 
 struct Foo<const N: usize>;
 

From 2261154549996eb7737a895e5df5fa894dc03e42 Mon Sep 17 00:00:00 2001
From: kennytm <kennytm@gmail.com>
Date: Thu, 10 Jul 2025 18:22:18 +0800
Subject: [PATCH 0013/1889] core: add Peekable::next_if_map

---
 library/core/src/iter/adapters/peekable.rs    | 102 ++++++++++++++++++
 .../coretests/tests/iter/adapters/peekable.rs |  86 +++++++++++++++
 library/coretests/tests/lib.rs                |   1 +
 3 files changed, 189 insertions(+)

diff --git a/library/core/src/iter/adapters/peekable.rs b/library/core/src/iter/adapters/peekable.rs
index a6522659620a0..a55de75d56c6e 100644
--- a/library/core/src/iter/adapters/peekable.rs
+++ b/library/core/src/iter/adapters/peekable.rs
@@ -317,6 +317,108 @@ impl<I: Iterator> Peekable<I> {
     {
         self.next_if(|next| next == expected)
     }
+
+    /// Consumes the next value of this iterator and applies a function `f` on it,
+    /// returning the result if the closure returns `Ok`.
+    ///
+    /// Otherwise if the closure returns `Err` the value is put back for the next iteration.
+    ///
+    /// The content of the `Err` variant is typically the original value of the closure,
+    /// but this is not required. If a different value is returned,
+    /// the next `peek()` or `next()` call will result in this new value.
+    /// This is similar to modifying the output of `peek_mut()`.
+    ///
+    /// If the closure panics, the next value will always be consumed and dropped
+    /// even if the panic is caught, because the closure never returned an `Err` value to put back.
+    ///
+    /// # Examples
+    ///
+    /// Parse the leading decimal number from an iterator of characters.
+    /// ```
+    /// #![feature(peekable_next_if_map)]
+    /// let mut iter = "125 GOTO 10".chars().peekable();
+    /// let mut line_num = 0_u32;
+    /// while let Some(digit) = iter.next_if_map(|c| c.to_digit(10).ok_or(c)) {
+    ///     line_num = line_num * 10 + digit;
+    /// }
+    /// assert_eq!(line_num, 125);
+    /// assert_eq!(iter.collect::<String>(), " GOTO 10");
+    /// ```
+    ///
+    /// Matching custom types.
+    /// ```
+    /// #![feature(peekable_next_if_map)]
+    ///
+    /// #[derive(Debug, PartialEq, Eq)]
+    /// enum Node {
+    ///     Comment(String),
+    ///     Red(String),
+    ///     Green(String),
+    ///     Blue(String),
+    /// }
+    ///
+    /// /// Combines all consecutive `Comment` nodes into a single one.
+    /// fn combine_comments(nodes: Vec<Node>) -> Vec<Node> {
+    ///     let mut result = Vec::with_capacity(nodes.len());
+    ///     let mut iter = nodes.into_iter().peekable();
+    ///     let mut comment_text = None::<String>;
+    ///     loop {
+    ///         // Typically the closure in .next_if_map() matches on the input,
+    ///         //  extracts the desired pattern into an `Ok`,
+    ///         //  and puts the rest into an `Err`.
+    ///         while let Some(text) = iter.next_if_map(|node| match node {
+    ///             Node::Comment(text) => Ok(text),
+    ///             other => Err(other),
+    ///         }) {
+    ///             comment_text.get_or_insert_default().push_str(&text);
+    ///         }
+    ///
+    ///         if let Some(text) = comment_text.take() {
+    ///             result.push(Node::Comment(text));
+    ///         }
+    ///         if let Some(node) = iter.next() {
+    ///             result.push(node);
+    ///         } else {
+    ///             break;
+    ///         }
+    ///     }
+    ///     result
+    /// }
+    ///# assert_eq!( // hiding the test to avoid cluttering the documentation.
+    ///#     combine_comments(vec![
+    ///#         Node::Comment("The".to_owned()),
+    ///#         Node::Comment("Quick".to_owned()),
+    ///#         Node::Comment("Brown".to_owned()),
+    ///#         Node::Red("Fox".to_owned()),
+    ///#         Node::Green("Jumped".to_owned()),
+    ///#         Node::Comment("Over".to_owned()),
+    ///#         Node::Blue("The".to_owned()),
+    ///#         Node::Comment("Lazy".to_owned()),
+    ///#         Node::Comment("Dog".to_owned()),
+    ///#     ]),
+    ///#     vec![
+    ///#         Node::Comment("TheQuickBrown".to_owned()),
+    ///#         Node::Red("Fox".to_owned()),
+    ///#         Node::Green("Jumped".to_owned()),
+    ///#         Node::Comment("Over".to_owned()),
+    ///#         Node::Blue("The".to_owned()),
+    ///#         Node::Comment("LazyDog".to_owned()),
+    ///#     ],
+    ///# )
+    /// ```
+    #[unstable(feature = "peekable_next_if_map", issue = "143702")]
+    pub fn next_if_map<R>(&mut self, f: impl FnOnce(I::Item) -> Result<R, I::Item>) -> Option<R> {
+        let unpeek = if let Some(item) = self.next() {
+            match f(item) {
+                Ok(result) => return Some(result),
+                Err(item) => Some(item),
+            }
+        } else {
+            None
+        };
+        self.peeked = Some(unpeek);
+        None
+    }
 }
 
 #[unstable(feature = "trusted_len", issue = "37572")]
diff --git a/library/coretests/tests/iter/adapters/peekable.rs b/library/coretests/tests/iter/adapters/peekable.rs
index 7f4341b8902c8..f0549e8d6c2c3 100644
--- a/library/coretests/tests/iter/adapters/peekable.rs
+++ b/library/coretests/tests/iter/adapters/peekable.rs
@@ -271,3 +271,89 @@ fn test_peekable_non_fused() {
     assert_eq!(iter.peek(), None);
     assert_eq!(iter.next_back(), None);
 }
+
+#[test]
+fn test_peekable_next_if_map_mutation() {
+    fn collatz((mut num, mut len): (u64, u32)) -> Result<u32, (u64, u32)> {
+        let jump = num.trailing_zeros();
+        num >>= jump;
+        len += jump;
+        if num == 1 { Ok(len) } else { Err((3 * num + 1, len + 1)) }
+    }
+
+    let mut iter = once((3, 0)).peekable();
+    assert_eq!(iter.peek(), Some(&(3, 0)));
+    assert_eq!(iter.next_if_map(collatz), None);
+    assert_eq!(iter.peek(), Some(&(10, 1)));
+    assert_eq!(iter.next_if_map(collatz), None);
+    assert_eq!(iter.peek(), Some(&(16, 3)));
+    assert_eq!(iter.next_if_map(collatz), Some(7));
+    assert_eq!(iter.peek(), None);
+    assert_eq!(iter.next_if_map(collatz), None);
+}
+
+#[test]
+#[cfg_attr(not(panic = "unwind"), ignore = "test requires unwinding support")]
+fn test_peekable_next_if_map_panic() {
+    use core::cell::Cell;
+    use std::panic::{AssertUnwindSafe, catch_unwind};
+
+    struct BitsetOnDrop<'a> {
+        value: u32,
+        cell: &'a Cell<u32>,
+    }
+    impl<'a> Drop for BitsetOnDrop<'a> {
+        fn drop(&mut self) {
+            self.cell.update(|v| v | self.value);
+        }
+    }
+
+    let cell = &Cell::new(0);
+    let mut it = [
+        BitsetOnDrop { value: 1, cell },
+        BitsetOnDrop { value: 2, cell },
+        BitsetOnDrop { value: 4, cell },
+        BitsetOnDrop { value: 8, cell },
+    ]
+    .into_iter()
+    .peekable();
+
+    // sanity check, .peek() won't consume the value, .next() will transfer ownership.
+    let item = it.peek().unwrap();
+    assert_eq!(item.value, 1);
+    assert_eq!(cell.get(), 0);
+    let item = it.next().unwrap();
+    assert_eq!(item.value, 1);
+    assert_eq!(cell.get(), 0);
+    drop(item);
+    assert_eq!(cell.get(), 1);
+
+    // next_if_map returning Ok should transfer the value out.
+    let item = it.next_if_map(Ok).unwrap();
+    assert_eq!(item.value, 2);
+    assert_eq!(cell.get(), 1);
+    drop(item);
+    assert_eq!(cell.get(), 3);
+
+    // next_if_map returning Err should not drop anything.
+    assert_eq!(it.next_if_map::<()>(Err), None);
+    assert_eq!(cell.get(), 3);
+    assert_eq!(it.peek().unwrap().value, 4);
+    assert_eq!(cell.get(), 3);
+
+    // next_if_map panicking should consume and drop the item.
+    let result = catch_unwind({
+        let mut it = AssertUnwindSafe(&mut it);
+        move || it.next_if_map::<()>(|_| panic!())
+    });
+    assert!(result.is_err());
+    assert_eq!(cell.get(), 7);
+    assert_eq!(it.next().unwrap().value, 8);
+    assert_eq!(cell.get(), 15);
+    assert!(it.peek().is_none());
+
+    // next_if_map should *not* execute the closure if the iterator is exhausted.
+    assert!(it.next_if_map::<()>(|_| panic!()).is_none());
+    assert!(it.peek().is_none());
+    assert_eq!(cell.get(), 15);
+}
diff --git a/library/coretests/tests/lib.rs b/library/coretests/tests/lib.rs
index fdef736c0c0f7..18e6e96c235f0 100644
--- a/library/coretests/tests/lib.rs
+++ b/library/coretests/tests/lib.rs
@@ -78,6 +78,7 @@
 #![feature(next_index)]
 #![feature(numfmt)]
 #![feature(pattern)]
+#![feature(peekable_next_if_map)]
 #![feature(pointer_is_aligned_to)]
 #![feature(portable_simd)]
 #![feature(ptr_metadata)]

From 81e8c6797cc3c94134d6fce11ddb38e03be8c85a Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 15 Jul 2025 07:18:56 -0400
Subject: [PATCH 0014/1889] `redundant_clone`: split iterator checks into
 `redundant_iter_cloned` lint

---
 CHANGELOG.md                                  |  1 +
 clippy_lints/src/declared_lints.rs            |  1 +
 .../src/methods/iter_overeager_cloned.rs      |  5 ++--
 clippy_lints/src/methods/mod.rs               | 26 +++++++++++++++++++
 tests/ui/iter_overeager_cloned.fixed          | 12 ++++-----
 tests/ui/iter_overeager_cloned.rs             | 12 ++++-----
 tests/ui/iter_overeager_cloned.stderr         |  4 +--
 7 files changed, 44 insertions(+), 17 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a92fbdc767bd4..8d770ad2a3386 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6304,6 +6304,7 @@ Released 2018-09-13
 [`redundant_feature_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_feature_names
 [`redundant_field_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_field_names
 [`redundant_guards`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_guards
+[`redundant_iter_cloned`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_iter_cloned
 [`redundant_locals`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_locals
 [`redundant_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pattern
 [`redundant_pattern_matching`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pattern_matching
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index c3f8e02b4c067..233a1c42841b4 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -449,6 +449,7 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::methods::READONLY_WRITE_LOCK_INFO,
     crate::methods::READ_LINE_WITHOUT_TRIM_INFO,
     crate::methods::REDUNDANT_AS_STR_INFO,
+    crate::methods::REDUNDANT_ITER_CLONED_INFO,
     crate::methods::REPEAT_ONCE_INFO,
     crate::methods::RESULT_FILTER_MAP_INFO,
     crate::methods::RESULT_MAP_OR_INTO_OPTION_INFO,
diff --git a/clippy_lints/src/methods/iter_overeager_cloned.rs b/clippy_lints/src/methods/iter_overeager_cloned.rs
index f5fe4316eb0d3..d43b22c2bd517 100644
--- a/clippy_lints/src/methods/iter_overeager_cloned.rs
+++ b/clippy_lints/src/methods/iter_overeager_cloned.rs
@@ -10,8 +10,7 @@ use rustc_middle::mir::{FakeReadCause, Mutability};
 use rustc_middle::ty::{self, BorrowKind};
 use rustc_span::{Symbol, sym};
 
-use super::ITER_OVEREAGER_CLONED;
-use crate::redundant_clone::REDUNDANT_CLONE;
+use super::{ITER_OVEREAGER_CLONED, REDUNDANT_ITER_CLONED};
 
 #[derive(Clone, Copy)]
 pub(super) enum Op<'a> {
@@ -96,7 +95,7 @@ pub(super) fn check<'tcx>(
         }
 
         let (lint, msg, trailing_clone) = match op {
-            Op::RmCloned | Op::NeedlessMove(_) => (REDUNDANT_CLONE, "unneeded cloning of iterator items", ""),
+            Op::RmCloned | Op::NeedlessMove(_) => (REDUNDANT_ITER_CLONED, "unneeded cloning of iterator items", ""),
             Op::LaterCloned | Op::FixClosure(_, _) => (
                 ITER_OVEREAGER_CLONED,
                 "unnecessarily eager cloning of iterator items",
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index f2dabdd343875..c68caea89bbdc 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -4565,6 +4565,31 @@ declare_clippy_lint! {
     "hardcoded localhost IP address"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calls to `Iterator::cloned` where the original value could be used
+    /// instead.
+    ///
+    /// ### Why is this bad?
+    /// It is not always possible for the compiler to eliminate useless allocations and
+    /// deallocations generated by redundant `clone()`s.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let x = vec![String::new()];
+    /// let _ = x.iter().cloned().map(|x| x.len());
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let x = vec![String::new()];
+    /// let _ = x.iter().map(|x| x.len());
+    /// ```
+    #[clippy::version = "1.90.0"]
+    pub REDUNDANT_ITER_CLONED,
+    perf,
+    "detects redundant calls to `Iterator::cloned`"
+}
+
 #[expect(clippy::struct_excessive_bools)]
 pub struct Methods {
     avoid_breaking_exported_api: bool,
@@ -4744,6 +4769,7 @@ impl_lint_pass!(Methods => [
     IO_OTHER_ERROR,
     SWAP_WITH_TEMPORARY,
     IP_CONSTANT,
+    REDUNDANT_ITER_CLONED,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
diff --git a/tests/ui/iter_overeager_cloned.fixed b/tests/ui/iter_overeager_cloned.fixed
index b0e548f179093..4171f19469a4d 100644
--- a/tests/ui/iter_overeager_cloned.fixed
+++ b/tests/ui/iter_overeager_cloned.fixed
@@ -1,4 +1,4 @@
-#![warn(clippy::iter_overeager_cloned, clippy::redundant_clone, clippy::filter_next)]
+#![warn(clippy::iter_overeager_cloned, clippy::redundant_iter_cloned, clippy::filter_next)]
 #![allow(
     dead_code,
     clippy::let_unit_value,
@@ -16,7 +16,7 @@ fn main() {
     //~^ iter_overeager_cloned
 
     let _: usize = vec.iter().filter(|x| x == &"2").count();
-    //~^ redundant_clone
+    //~^ redundant_iter_cloned
 
     let _: Vec<_> = vec.iter().take(2).cloned().collect();
     //~^ iter_overeager_cloned
@@ -77,19 +77,19 @@ fn main() {
     }
 
     let _ = vec.iter().map(|x| x.len());
-    //~^ redundant_clone
+    //~^ redundant_iter_cloned
 
     // This would fail if changed.
     let _ = vec.iter().cloned().map(|x| x + "2");
 
     let _ = vec.iter().for_each(|x| assert!(!x.is_empty()));
-    //~^ redundant_clone
+    //~^ redundant_iter_cloned
 
     let _ = vec.iter().all(|x| x.len() == 1);
-    //~^ redundant_clone
+    //~^ redundant_iter_cloned
 
     let _ = vec.iter().any(|x| x.len() == 1);
-    //~^ redundant_clone
+    //~^ redundant_iter_cloned
 
     // Should probably stay as it is.
     let _ = [0, 1, 2, 3, 4].iter().cloned().take(10);
diff --git a/tests/ui/iter_overeager_cloned.rs b/tests/ui/iter_overeager_cloned.rs
index cedf62a6b4730..fe6aba24dd3e2 100644
--- a/tests/ui/iter_overeager_cloned.rs
+++ b/tests/ui/iter_overeager_cloned.rs
@@ -1,4 +1,4 @@
-#![warn(clippy::iter_overeager_cloned, clippy::redundant_clone, clippy::filter_next)]
+#![warn(clippy::iter_overeager_cloned, clippy::redundant_iter_cloned, clippy::filter_next)]
 #![allow(
     dead_code,
     clippy::let_unit_value,
@@ -16,7 +16,7 @@ fn main() {
     //~^ iter_overeager_cloned
 
     let _: usize = vec.iter().filter(|x| x == &"2").cloned().count();
-    //~^ redundant_clone
+    //~^ redundant_iter_cloned
 
     let _: Vec<_> = vec.iter().cloned().take(2).collect();
     //~^ iter_overeager_cloned
@@ -78,19 +78,19 @@ fn main() {
     }
 
     let _ = vec.iter().cloned().map(|x| x.len());
-    //~^ redundant_clone
+    //~^ redundant_iter_cloned
 
     // This would fail if changed.
     let _ = vec.iter().cloned().map(|x| x + "2");
 
     let _ = vec.iter().cloned().for_each(|x| assert!(!x.is_empty()));
-    //~^ redundant_clone
+    //~^ redundant_iter_cloned
 
     let _ = vec.iter().cloned().all(|x| x.len() == 1);
-    //~^ redundant_clone
+    //~^ redundant_iter_cloned
 
     let _ = vec.iter().cloned().any(|x| x.len() == 1);
-    //~^ redundant_clone
+    //~^ redundant_iter_cloned
 
     // Should probably stay as it is.
     let _ = [0, 1, 2, 3, 4].iter().cloned().take(10);
diff --git a/tests/ui/iter_overeager_cloned.stderr b/tests/ui/iter_overeager_cloned.stderr
index 1616dec95b792..f234d19e4aaaa 100644
--- a/tests/ui/iter_overeager_cloned.stderr
+++ b/tests/ui/iter_overeager_cloned.stderr
@@ -25,8 +25,8 @@ LL |     let _: usize = vec.iter().filter(|x| x == &"2").cloned().count();
    |                                                    |
    |                                                    help: try: `.count()`
    |
-   = note: `-D clippy::redundant-clone` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::redundant_clone)]`
+   = note: `-D clippy::redundant-iter-cloned` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::redundant_iter_cloned)]`
 
 error: unnecessarily eager cloning of iterator items
   --> tests/ui/iter_overeager_cloned.rs:21:21

From 175afd76180d47b655377768a87a55f8581686f0 Mon Sep 17 00:00:00 2001
From: Thalia Archibald <thalia@archibald.dev>
Date: Mon, 21 Apr 2025 23:27:01 -0700
Subject: [PATCH 0015/1889] Stabilize `new_zeroed_alloc`

---
 compiler/rustc_index/src/bit_set.rs |  4 ++--
 compiler/rustc_index/src/lib.rs     |  2 +-
 library/alloc/src/boxed.rs          | 16 ++--------------
 library/alloc/src/rc.rs             | 16 ++--------------
 library/alloc/src/sync.rs           | 14 ++------------
 library/std/src/lib.rs              |  1 -
 6 files changed, 9 insertions(+), 44 deletions(-)

diff --git a/compiler/rustc_index/src/bit_set.rs b/compiler/rustc_index/src/bit_set.rs
index 645d95b1dba99..0b3bc8963a3bd 100644
--- a/compiler/rustc_index/src/bit_set.rs
+++ b/compiler/rustc_index/src/bit_set.rs
@@ -638,7 +638,7 @@ impl<T: Idx> ChunkedBitSet<T> {
                     };
                     #[cfg(not(feature = "nightly"))]
                     let mut words = {
-                        // FIXME: unconditionally use `Rc::new_zeroed` once it is stable (#63291).
+                        // FIXME: unconditionally use `Rc::new_zeroed` once it is stable (#129396).
                         let words = mem::MaybeUninit::<[Word; CHUNK_WORDS]>::zeroed();
                         // SAFETY: `words` can safely be all zeroes.
                         let words = unsafe { words.assume_init() };
@@ -704,7 +704,7 @@ impl<T: Idx> ChunkedBitSet<T> {
                     };
                     #[cfg(not(feature = "nightly"))]
                     let mut words = {
-                        // FIXME: unconditionally use `Rc::new_zeroed` once it is stable (#63291).
+                        // FIXME: unconditionally use `Rc::new_zeroed` once it is stable (#129396).
                         let words = mem::MaybeUninit::<[Word; CHUNK_WORDS]>::zeroed();
                         // SAFETY: `words` can safely be all zeroes.
                         let words = unsafe { words.assume_init() };
diff --git a/compiler/rustc_index/src/lib.rs b/compiler/rustc_index/src/lib.rs
index cc680838e7e7b..9d647209c6f89 100644
--- a/compiler/rustc_index/src/lib.rs
+++ b/compiler/rustc_index/src/lib.rs
@@ -1,9 +1,9 @@
 // tidy-alphabetical-start
 #![cfg_attr(all(feature = "nightly", test), feature(stmt_expr_attributes))]
+#![cfg_attr(bootstrap, feature(new_zeroed_alloc))]
 #![cfg_attr(feature = "nightly", allow(internal_features))]
 #![cfg_attr(feature = "nightly", feature(extend_one, step_trait, test))]
 #![cfg_attr(feature = "nightly", feature(new_range_api))]
-#![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 3db37f1d16f3d..173d0103c119b 100644
--- a/library/alloc/src/boxed.rs
+++ b/library/alloc/src/boxed.rs
@@ -290,8 +290,6 @@ impl<T> Box<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_zeroed_alloc)]
-    ///
     /// let zero = Box::<u32>::new_zeroed();
     /// let zero = unsafe { zero.assume_init() };
     ///
@@ -301,7 +299,7 @@ impl<T> Box<T> {
     /// [zeroed]: mem::MaybeUninit::zeroed
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    #[unstable(feature = "new_zeroed_alloc", issue = "129396")]
+    #[stable(feature = "new_zeroed_alloc", since = "CURRENT_RUSTC_VERSION")]
     #[must_use]
     pub fn new_zeroed() -> Box<mem::MaybeUninit<T>> {
         Self::new_zeroed_in(Global)
@@ -358,7 +356,6 @@ impl<T> Box<T> {
     /// # Ok::<(), std::alloc::AllocError>(())
     /// ```
     #[unstable(feature = "allocator_api", issue = "32838")]
-    // #[unstable(feature = "new_uninit", issue = "63291")]
     #[inline]
     pub fn try_new_uninit() -> Result<Box<mem::MaybeUninit<T>>, AllocError> {
         Box::try_new_uninit_in(Global)
@@ -384,7 +381,6 @@ impl<T> Box<T> {
     ///
     /// [zeroed]: mem::MaybeUninit::zeroed
     #[unstable(feature = "allocator_api", issue = "32838")]
-    // #[unstable(feature = "new_uninit", issue = "63291")]
     #[inline]
     pub fn try_new_zeroed() -> Result<Box<mem::MaybeUninit<T>>, AllocError> {
         Box::try_new_zeroed_in(Global)
@@ -463,7 +459,6 @@ impl<T, A: Allocator> Box<T, A> {
     #[unstable(feature = "allocator_api", issue = "32838")]
     #[cfg(not(no_global_oom_handling))]
     #[must_use]
-    // #[unstable(feature = "new_uninit", issue = "63291")]
     pub fn new_uninit_in(alloc: A) -> Box<mem::MaybeUninit<T>, A>
     where
         A: Allocator,
@@ -496,7 +491,6 @@ impl<T, A: Allocator> Box<T, A> {
     /// # Ok::<(), std::alloc::AllocError>(())
     /// ```
     #[unstable(feature = "allocator_api", issue = "32838")]
-    // #[unstable(feature = "new_uninit", issue = "63291")]
     pub fn try_new_uninit_in(alloc: A) -> Result<Box<mem::MaybeUninit<T>, A>, AllocError>
     where
         A: Allocator,
@@ -532,7 +526,6 @@ impl<T, A: Allocator> Box<T, A> {
     /// [zeroed]: mem::MaybeUninit::zeroed
     #[unstable(feature = "allocator_api", issue = "32838")]
     #[cfg(not(no_global_oom_handling))]
-    // #[unstable(feature = "new_uninit", issue = "63291")]
     #[must_use]
     pub fn new_zeroed_in(alloc: A) -> Box<mem::MaybeUninit<T>, A>
     where
@@ -570,7 +563,6 @@ impl<T, A: Allocator> Box<T, A> {
     ///
     /// [zeroed]: mem::MaybeUninit::zeroed
     #[unstable(feature = "allocator_api", issue = "32838")]
-    // #[unstable(feature = "new_uninit", issue = "63291")]
     pub fn try_new_zeroed_in(alloc: A) -> Result<Box<mem::MaybeUninit<T>, A>, AllocError>
     where
         A: Allocator,
@@ -660,8 +652,6 @@ impl<T> Box<[T]> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_zeroed_alloc)]
-    ///
     /// let values = Box::<[u32]>::new_zeroed_slice(3);
     /// let values = unsafe { values.assume_init() };
     ///
@@ -670,7 +660,7 @@ impl<T> Box<[T]> {
     ///
     /// [zeroed]: mem::MaybeUninit::zeroed
     #[cfg(not(no_global_oom_handling))]
-    #[unstable(feature = "new_zeroed_alloc", issue = "129396")]
+    #[stable(feature = "new_zeroed_alloc", since = "CURRENT_RUSTC_VERSION")]
     #[must_use]
     pub fn new_zeroed_slice(len: usize) -> Box<[mem::MaybeUninit<T>]> {
         unsafe { RawVec::with_capacity_zeroed(len).into_box(len) }
@@ -785,7 +775,6 @@ impl<T, A: Allocator> Box<[T], A> {
     /// ```
     #[cfg(not(no_global_oom_handling))]
     #[unstable(feature = "allocator_api", issue = "32838")]
-    // #[unstable(feature = "new_uninit", issue = "63291")]
     #[must_use]
     pub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit<T>], A> {
         unsafe { RawVec::with_capacity_in(len, alloc).into_box(len) }
@@ -813,7 +802,6 @@ impl<T, A: Allocator> Box<[T], A> {
     /// [zeroed]: mem::MaybeUninit::zeroed
     #[cfg(not(no_global_oom_handling))]
     #[unstable(feature = "allocator_api", issue = "32838")]
-    // #[unstable(feature = "new_uninit", issue = "63291")]
     #[must_use]
     pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit<T>], A> {
         unsafe { RawVec::with_capacity_zeroed_in(len, alloc).into_box(len) }
diff --git a/library/alloc/src/rc.rs b/library/alloc/src/rc.rs
index 5018ff4ad71f3..0b5c9240db0f1 100644
--- a/library/alloc/src/rc.rs
+++ b/library/alloc/src/rc.rs
@@ -515,8 +515,6 @@ impl<T> Rc<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_zeroed_alloc)]
-    ///
     /// use std::rc::Rc;
     ///
     /// let zero = Rc::<u32>::new_zeroed();
@@ -527,7 +525,7 @@ impl<T> Rc<T> {
     ///
     /// [zeroed]: mem::MaybeUninit::zeroed
     #[cfg(not(no_global_oom_handling))]
-    #[unstable(feature = "new_zeroed_alloc", issue = "129396")]
+    #[stable(feature = "new_zeroed_alloc", since = "CURRENT_RUSTC_VERSION")]
     #[must_use]
     pub fn new_zeroed() -> Rc<mem::MaybeUninit<T>> {
         unsafe {
@@ -589,7 +587,6 @@ impl<T> Rc<T> {
     /// # Ok::<(), std::alloc::AllocError>(())
     /// ```
     #[unstable(feature = "allocator_api", issue = "32838")]
-    // #[unstable(feature = "new_uninit", issue = "63291")]
     pub fn try_new_uninit() -> Result<Rc<mem::MaybeUninit<T>>, AllocError> {
         unsafe {
             Ok(Rc::from_ptr(Rc::try_allocate_for_layout(
@@ -622,7 +619,6 @@ impl<T> Rc<T> {
     ///
     /// [zeroed]: mem::MaybeUninit::zeroed
     #[unstable(feature = "allocator_api", issue = "32838")]
-    //#[unstable(feature = "new_uninit", issue = "63291")]
     pub fn try_new_zeroed() -> Result<Rc<mem::MaybeUninit<T>>, AllocError> {
         unsafe {
             Ok(Rc::from_ptr(Rc::try_allocate_for_layout(
@@ -690,7 +686,6 @@ impl<T, A: Allocator> Rc<T, A> {
     /// ```
     #[cfg(not(no_global_oom_handling))]
     #[unstable(feature = "allocator_api", issue = "32838")]
-    // #[unstable(feature = "new_uninit", issue = "63291")]
     #[inline]
     pub fn new_uninit_in(alloc: A) -> Rc<mem::MaybeUninit<T>, A> {
         unsafe {
@@ -728,7 +723,6 @@ impl<T, A: Allocator> Rc<T, A> {
     /// [zeroed]: mem::MaybeUninit::zeroed
     #[cfg(not(no_global_oom_handling))]
     #[unstable(feature = "allocator_api", issue = "32838")]
-    // #[unstable(feature = "new_uninit", issue = "63291")]
     #[inline]
     pub fn new_zeroed_in(alloc: A) -> Rc<mem::MaybeUninit<T>, A> {
         unsafe {
@@ -873,7 +867,6 @@ impl<T, A: Allocator> Rc<T, A> {
     /// # Ok::<(), std::alloc::AllocError>(())
     /// ```
     #[unstable(feature = "allocator_api", issue = "32838")]
-    // #[unstable(feature = "new_uninit", issue = "63291")]
     #[inline]
     pub fn try_new_uninit_in(alloc: A) -> Result<Rc<mem::MaybeUninit<T>, A>, AllocError> {
         unsafe {
@@ -912,7 +905,6 @@ impl<T, A: Allocator> Rc<T, A> {
     ///
     /// [zeroed]: mem::MaybeUninit::zeroed
     #[unstable(feature = "allocator_api", issue = "32838")]
-    //#[unstable(feature = "new_uninit", issue = "63291")]
     #[inline]
     pub fn try_new_zeroed_in(alloc: A) -> Result<Rc<mem::MaybeUninit<T>, A>, AllocError> {
         unsafe {
@@ -1054,8 +1046,6 @@ impl<T> Rc<[T]> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_zeroed_alloc)]
-    ///
     /// use std::rc::Rc;
     ///
     /// let values = Rc::<[u32]>::new_zeroed_slice(3);
@@ -1066,7 +1056,7 @@ impl<T> Rc<[T]> {
     ///
     /// [zeroed]: mem::MaybeUninit::zeroed
     #[cfg(not(no_global_oom_handling))]
-    #[unstable(feature = "new_zeroed_alloc", issue = "129396")]
+    #[stable(feature = "new_zeroed_alloc", since = "CURRENT_RUSTC_VERSION")]
     #[must_use]
     pub fn new_zeroed_slice(len: usize) -> Rc<[mem::MaybeUninit<T>]> {
         unsafe {
@@ -1129,7 +1119,6 @@ impl<T, A: Allocator> Rc<[T], A> {
     /// ```
     #[cfg(not(no_global_oom_handling))]
     #[unstable(feature = "allocator_api", issue = "32838")]
-    // #[unstable(feature = "new_uninit", issue = "63291")]
     #[inline]
     pub fn new_uninit_slice_in(len: usize, alloc: A) -> Rc<[mem::MaybeUninit<T>], A> {
         unsafe { Rc::from_ptr_in(Rc::allocate_for_slice_in(len, &alloc), alloc) }
@@ -1158,7 +1147,6 @@ impl<T, A: Allocator> Rc<[T], A> {
     /// [zeroed]: mem::MaybeUninit::zeroed
     #[cfg(not(no_global_oom_handling))]
     #[unstable(feature = "allocator_api", issue = "32838")]
-    // #[unstable(feature = "new_uninit", issue = "63291")]
     #[inline]
     pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Rc<[mem::MaybeUninit<T>], A> {
         unsafe {
diff --git a/library/alloc/src/sync.rs b/library/alloc/src/sync.rs
index b8925f4544f44..4090a04f21a9f 100644
--- a/library/alloc/src/sync.rs
+++ b/library/alloc/src/sync.rs
@@ -516,8 +516,6 @@ impl<T> Arc<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_zeroed_alloc)]
-    ///
     /// use std::sync::Arc;
     ///
     /// let zero = Arc::<u32>::new_zeroed();
@@ -529,7 +527,7 @@ impl<T> Arc<T> {
     /// [zeroed]: mem::MaybeUninit::zeroed
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    #[unstable(feature = "new_zeroed_alloc", issue = "129396")]
+    #[stable(feature = "new_zeroed_alloc", since = "CURRENT_RUSTC_VERSION")]
     #[must_use]
     pub fn new_zeroed() -> Arc<mem::MaybeUninit<T>> {
         unsafe {
@@ -603,7 +601,6 @@ impl<T> Arc<T> {
     /// # Ok::<(), std::alloc::AllocError>(())
     /// ```
     #[unstable(feature = "allocator_api", issue = "32838")]
-    // #[unstable(feature = "new_uninit", issue = "63291")]
     pub fn try_new_uninit() -> Result<Arc<mem::MaybeUninit<T>>, AllocError> {
         unsafe {
             Ok(Arc::from_ptr(Arc::try_allocate_for_layout(
@@ -636,7 +633,6 @@ impl<T> Arc<T> {
     ///
     /// [zeroed]: mem::MaybeUninit::zeroed
     #[unstable(feature = "allocator_api", issue = "32838")]
-    // #[unstable(feature = "new_uninit", issue = "63291")]
     pub fn try_new_zeroed() -> Result<Arc<mem::MaybeUninit<T>>, AllocError> {
         unsafe {
             Ok(Arc::from_ptr(Arc::try_allocate_for_layout(
@@ -703,7 +699,6 @@ impl<T, A: Allocator> Arc<T, A> {
     /// ```
     #[cfg(not(no_global_oom_handling))]
     #[unstable(feature = "allocator_api", issue = "32838")]
-    // #[unstable(feature = "new_uninit", issue = "63291")]
     #[inline]
     pub fn new_uninit_in(alloc: A) -> Arc<mem::MaybeUninit<T>, A> {
         unsafe {
@@ -741,7 +736,6 @@ impl<T, A: Allocator> Arc<T, A> {
     /// [zeroed]: mem::MaybeUninit::zeroed
     #[cfg(not(no_global_oom_handling))]
     #[unstable(feature = "allocator_api", issue = "32838")]
-    // #[unstable(feature = "new_uninit", issue = "63291")]
     #[inline]
     pub fn new_zeroed_in(alloc: A) -> Arc<mem::MaybeUninit<T>, A> {
         unsafe {
@@ -927,7 +921,6 @@ impl<T, A: Allocator> Arc<T, A> {
     /// # Ok::<(), std::alloc::AllocError>(())
     /// ```
     #[unstable(feature = "allocator_api", issue = "32838")]
-    // #[unstable(feature = "new_uninit", issue = "63291")]
     #[inline]
     pub fn try_new_uninit_in(alloc: A) -> Result<Arc<mem::MaybeUninit<T>, A>, AllocError> {
         unsafe {
@@ -966,7 +959,6 @@ impl<T, A: Allocator> Arc<T, A> {
     ///
     /// [zeroed]: mem::MaybeUninit::zeroed
     #[unstable(feature = "allocator_api", issue = "32838")]
-    // #[unstable(feature = "new_uninit", issue = "63291")]
     #[inline]
     pub fn try_new_zeroed_in(alloc: A) -> Result<Arc<mem::MaybeUninit<T>, A>, AllocError> {
         unsafe {
@@ -1197,8 +1189,6 @@ impl<T> Arc<[T]> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_zeroed_alloc)]
-    ///
     /// use std::sync::Arc;
     ///
     /// let values = Arc::<[u32]>::new_zeroed_slice(3);
@@ -1210,7 +1200,7 @@ impl<T> Arc<[T]> {
     /// [zeroed]: mem::MaybeUninit::zeroed
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    #[unstable(feature = "new_zeroed_alloc", issue = "129396")]
+    #[stable(feature = "new_zeroed_alloc", since = "CURRENT_RUSTC_VERSION")]
     #[must_use]
     pub fn new_zeroed_slice(len: usize) -> Arc<[mem::MaybeUninit<T>]> {
         unsafe {
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index 311b2cb932392..2c0061dc40320 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -376,7 +376,6 @@
 #![feature(allocator_api)]
 #![feature(get_mut_unchecked)]
 #![feature(map_try_insert)]
-#![feature(new_zeroed_alloc)]
 #![feature(slice_concat_trait)]
 #![feature(thin_box)]
 #![feature(try_reserve_kind)]

From bd33a02ea6c01a7053451b0205edb01e4172a601 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sat, 7 Jun 2025 08:25:20 +0200
Subject: [PATCH 0016/1889] Get the block content from the proper context

The first statement of the block might have been in a different context
from the expression. Walk up to the right context to get bounds
properly.

Also, switch to `snippet_with_applicability()` since we know that we are
in the right context already.
---
 clippy_lints/src/if_then_some_else_none.rs | 32 +++++++-------
 tests/ui/if_then_some_else_none.fixed      | 41 +++++++++++++++++
 tests/ui/if_then_some_else_none.rs         | 51 ++++++++++++++++++++++
 tests/ui/if_then_some_else_none.stderr     | 25 ++++++++++-
 4 files changed, 133 insertions(+), 16 deletions(-)

diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index 7158f9419c1cc..b50d91f101463 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -2,16 +2,16 @@ use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::eager_or_lazy::switch_to_eager_eval;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::source::snippet_with_context;
+use clippy_utils::source::{snippet_with_applicability, snippet_with_context, walk_span_to_context};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{
     contains_return, expr_adjustment_requires_coercion, higher, is_else_clause, is_in_const_context, is_res_lang_ctor,
-    path_res, peel_blocks,
+    path_res, peel_blocks, sym,
 };
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::impl_lint_pass;
 
 declare_clippy_lint! {
@@ -71,21 +71,21 @@ impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
             && let ExprKind::Block(then_block, _) = then.kind
             && let Some(then_expr) = then_block.expr
             && let ExprKind::Call(then_call, [then_arg]) = then_expr.kind
-            && let ctxt = expr.span.ctxt()
-            && then_expr.span.ctxt() == ctxt
+            && !expr.span.from_expansion()
+            && !then_expr.span.from_expansion()
             && 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)
             && !is_in_const_context(cx)
-            && !expr.span.in_external_macro(cx.sess().source_map())
             && self.msrv.meets(cx, msrvs::BOOL_THEN)
             && !contains_return(then_block.stmts)
         {
             let method_name = if switch_to_eager_eval(cx, expr) && self.msrv.meets(cx, msrvs::BOOL_THEN_SOME) {
-                "then_some"
+                sym::then_some
             } else {
-                "then"
+                sym::then
             };
+            let ctxt = expr.span.ctxt();
 
             span_lint_and_then(
                 cx,
@@ -98,16 +98,18 @@ impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
                     }
 
                     let mut app = Applicability::MachineApplicable;
-                    let cond_snip = Sugg::hir_with_context(cx, cond, expr.span.ctxt(), "[condition]", &mut app)
+                    let cond_snip = Sugg::hir_with_context(cx, cond, ctxt, "[condition]", &mut app)
                         .maybe_paren()
                         .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 if method_name == "then" {
+                    let method_body = if let Some(first_stmt) = then_block.stmts.first()
+                        && let Some(first_stmt_span) = walk_span_to_context(first_stmt.span, ctxt)
+                    {
+                        let block_snippet =
+                            snippet_with_applicability(cx, first_stmt_span.until(then_expr.span), "..", &mut app);
+                        let closure = if method_name == sym::then { "|| " } else { "" };
+                        format!("{closure} {{ {} {arg_snip} }}", block_snippet.trim_end())
+                    } else if method_name == sym::then {
                         (std::borrow::Cow::Borrowed("|| ") + arg_snip).into_owned()
                     } else {
                         arg_snip.into_owned()
diff --git a/tests/ui/if_then_some_else_none.fixed b/tests/ui/if_then_some_else_none.fixed
index d14a805b66679..0fd130609aee2 100644
--- a/tests/ui/if_then_some_else_none.fixed
+++ b/tests/ui/if_then_some_else_none.fixed
@@ -165,3 +165,44 @@ mod issue15257 {
         do_something((i % 2 == 0).then_some(closure_fn));
     }
 }
+
+fn issue15005() {
+    struct Counter {
+        count: u32,
+    }
+
+    impl Counter {
+        fn new() -> Counter {
+            Counter { count: 0 }
+        }
+    }
+
+    impl Iterator for Counter {
+        type Item = u32;
+
+        fn next(&mut self) -> Option<Self::Item> {
+            //~v if_then_some_else_none
+            (self.count < 5).then(||  { self.count += 1; self.count })
+        }
+    }
+}
+
+fn statements_from_macro() {
+    macro_rules! mac {
+        () => {
+            println!("foo");
+            println!("bar");
+        };
+    }
+    //~v if_then_some_else_none
+    let _ = true.then(||  { mac!(); 42 });
+}
+
+fn dont_lint_inside_macros() {
+    macro_rules! mac {
+        ($cond:expr, $res:expr) => {
+            if $cond { Some($res) } else { None }
+        };
+    }
+    let _: Option<u32> = mac!(true, 42);
+}
diff --git a/tests/ui/if_then_some_else_none.rs b/tests/ui/if_then_some_else_none.rs
index bb0072f31573f..640828aa9bf6b 100644
--- a/tests/ui/if_then_some_else_none.rs
+++ b/tests/ui/if_then_some_else_none.rs
@@ -211,3 +211,54 @@ mod issue15257 {
         });
     }
 }
+
+fn issue15005() {
+    struct Counter {
+        count: u32,
+    }
+
+    impl Counter {
+        fn new() -> Counter {
+            Counter { count: 0 }
+        }
+    }
+
+    impl Iterator for Counter {
+        type Item = u32;
+
+        fn next(&mut self) -> Option<Self::Item> {
+            //~v if_then_some_else_none
+            if self.count < 5 {
+                self.count += 1;
+                Some(self.count)
+            } else {
+                None
+            }
+        }
+    }
+}
+
+fn statements_from_macro() {
+    macro_rules! mac {
+        () => {
+            println!("foo");
+            println!("bar");
+        };
+    }
+    //~v if_then_some_else_none
+    let _ = if true {
+        mac!();
+        Some(42)
+    } else {
+        None
+    };
+}
+
+fn dont_lint_inside_macros() {
+    macro_rules! mac {
+        ($cond:expr, $res:expr) => {
+            if $cond { Some($res) } else { None }
+        };
+    }
+    let _: Option<u32> = mac!(true, 42);
+}
diff --git a/tests/ui/if_then_some_else_none.stderr b/tests/ui/if_then_some_else_none.stderr
index c2e624a0a73b4..58651a0559424 100644
--- a/tests/ui/if_then_some_else_none.stderr
+++ b/tests/ui/if_then_some_else_none.stderr
@@ -116,5 +116,28 @@ LL | |             None
 LL | |         });
    | |_________^ help: try: `(i % 2 == 0).then_some(closure_fn)`
 
-error: aborting due to 11 previous errors
+error: this could be simplified with `bool::then`
+  --> tests/ui/if_then_some_else_none.rs:231:13
+   |
+LL | /             if self.count < 5 {
+LL | |                 self.count += 1;
+LL | |                 Some(self.count)
+LL | |             } else {
+LL | |                 None
+LL | |             }
+   | |_____________^ help: try: `(self.count < 5).then(||  { self.count += 1; self.count })`
+
+error: this could be simplified with `bool::then`
+  --> tests/ui/if_then_some_else_none.rs:249:13
+   |
+LL |       let _ = if true {
+   |  _____________^
+LL | |         mac!();
+LL | |         Some(42)
+LL | |     } else {
+LL | |         None
+LL | |     };
+   | |_____^ help: try: `true.then(||  { mac!(); 42 })`
+
+error: aborting due to 13 previous errors
 

From a7162e416e73afd4fc4c72f171b8166bb9d35b8c Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sat, 2 Aug 2025 23:42:57 +0200
Subject: [PATCH 0017/1889] Remove references to two unknown lints in config

`option_map_unwrap_or` and `seek_rewind` are not current lints, and
cannot be referenced as having the `msrv` configuration option.
---
 book/src/lint_configuration.md | 2 --
 clippy_config/src/conf.rs      | 2 --
 2 files changed, 4 deletions(-)

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 7f16f3a981053..6d554170f1fe4 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -873,7 +873,6 @@ The minimum rust version that the project supports. Defaults to the `rust-versio
 * [`needless_borrow`](https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow)
 * [`non_std_lazy_statics`](https://rust-lang.github.io/rust-clippy/master/index.html#non_std_lazy_statics)
 * [`option_as_ref_deref`](https://rust-lang.github.io/rust-clippy/master/index.html#option_as_ref_deref)
-* [`option_map_unwrap_or`](https://rust-lang.github.io/rust-clippy/master/index.html#option_map_unwrap_or)
 * [`ptr_as_ptr`](https://rust-lang.github.io/rust-clippy/master/index.html#ptr_as_ptr)
 * [`question_mark`](https://rust-lang.github.io/rust-clippy/master/index.html#question_mark)
 * [`redundant_field_names`](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_field_names)
@@ -881,7 +880,6 @@ The minimum rust version that the project supports. Defaults to the `rust-versio
 * [`repeat_vec_with_capacity`](https://rust-lang.github.io/rust-clippy/master/index.html#repeat_vec_with_capacity)
 * [`same_item_push`](https://rust-lang.github.io/rust-clippy/master/index.html#same_item_push)
 * [`seek_from_current`](https://rust-lang.github.io/rust-clippy/master/index.html#seek_from_current)
-* [`seek_rewind`](https://rust-lang.github.io/rust-clippy/master/index.html#seek_rewind)
 * [`to_digit_is_some`](https://rust-lang.github.io/rust-clippy/master/index.html#to_digit_is_some)
 * [`transmute_ptr_to_ref`](https://rust-lang.github.io/rust-clippy/master/index.html#transmute_ptr_to_ref)
 * [`tuple_array_conversions`](https://rust-lang.github.io/rust-clippy/master/index.html#tuple_array_conversions)
diff --git a/clippy_config/src/conf.rs b/clippy_config/src/conf.rs
index 8167d75583eeb..a9987b4e2ec54 100644
--- a/clippy_config/src/conf.rs
+++ b/clippy_config/src/conf.rs
@@ -775,7 +775,6 @@ define_Conf! {
         needless_borrow,
         non_std_lazy_statics,
         option_as_ref_deref,
-        option_map_unwrap_or,
         ptr_as_ptr,
         question_mark,
         redundant_field_names,
@@ -783,7 +782,6 @@ define_Conf! {
         repeat_vec_with_capacity,
         same_item_push,
         seek_from_current,
-        seek_rewind,
         to_digit_is_some,
         transmute_ptr_to_ref,
         tuple_array_conversions,

From 07b04a2e04348283acf9565f3de2c500cce4df9a Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sat, 2 Aug 2025 23:52:39 +0200
Subject: [PATCH 0018/1889] Check that all configuration options reference
 existing lints

---
 tests/config-consistency.rs | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 tests/config-consistency.rs

diff --git a/tests/config-consistency.rs b/tests/config-consistency.rs
new file mode 100644
index 0000000000000..9e7ca26c7d400
--- /dev/null
+++ b/tests/config-consistency.rs
@@ -0,0 +1,30 @@
+#![feature(rustc_private)]
+
+// This test checks that all lints defined in `clippy_config::conf` in `#[lints]`
+// attributes exist as Clippy lints.
+//
+// This test is a no-op if run as part of the compiler test suite
+// and will always succeed.
+
+use std::collections::HashSet;
+
+#[test]
+fn config_consistency() {
+    if option_env!("RUSTC_TEST_SUITE").is_some() {
+        return;
+    }
+
+    let lint_names: HashSet<String> = clippy_lints::declared_lints::LINTS
+        .iter()
+        .map(|lint_info| lint_info.lint.name.strip_prefix("clippy::").unwrap().to_lowercase())
+        .collect();
+    for conf in clippy_config::get_configuration_metadata() {
+        for lint in conf.lints {
+            assert!(
+                lint_names.contains(*lint),
+                "Configuration option {} references lint `{lint}` which does not exist",
+                conf.name
+            );
+        }
+    }
+}

From 064825e734e9472925664ad681e055602ea62397 Mon Sep 17 00:00:00 2001
From: RunDevelopment <mitchi5000.ms@googlemail.com>
Date: Fri, 1 Aug 2025 20:13:48 +0200
Subject: [PATCH 0019/1889] Add suggestion to `cast_sign_loss` and
 `cast_possible_wrap` using the `cast_{un,}signed()` methods

---
 clippy_lints/src/casts/cast_possible_wrap.rs | 30 ++++++-
 clippy_lints/src/casts/cast_sign_loss.rs     | 29 ++++++-
 clippy_lints/src/casts/mod.rs                |  4 +-
 clippy_lints/src/casts/utils.rs              | 32 ++++++++
 clippy_utils/src/msrvs.rs                    |  2 +-
 tests/ui/cast.stderr                         | 82 ++++++++++----------
 6 files changed, 131 insertions(+), 48 deletions(-)

diff --git a/clippy_lints/src/casts/cast_possible_wrap.rs b/clippy_lints/src/casts/cast_possible_wrap.rs
index e26c03ccda933..5a8b3e6d9a411 100644
--- a/clippy_lints/src/casts/cast_possible_wrap.rs
+++ b/clippy_lints/src/casts/cast_possible_wrap.rs
@@ -1,4 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::sugg::Sugg;
+use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::Ty;
@@ -16,7 +19,14 @@ enum EmitState {
     LintOnPtrSize(u64),
 }
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    cast_op: &Expr<'_>,
+    cast_from: Ty<'_>,
+    cast_to: Ty<'_>,
+    msrv: Msrv,
+) {
     let (Some(from_nbits), Some(to_nbits)) = (
         utils::int_ty_to_nbits(cx.tcx, cast_from),
         utils::int_ty_to_nbits(cx.tcx, cast_to),
@@ -85,5 +95,23 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, ca
                 .note("`usize` and `isize` may be as small as 16 bits on some platforms")
                 .note("for more information see https://doc.rust-lang.org/reference/types/numeric.html#machine-dependent-integer-types");
         }
+
+        if msrv.meets(cx, msrvs::INTEGER_SIGN_CAST)
+            && let Some(cast) = utils::is_signedness_cast(cast_from, cast_to)
+        {
+            let method = match cast {
+                utils::CastTo::Signed => "cast_signed()",
+                utils::CastTo::Unsigned => "cast_unsigned()",
+            };
+            let mut app = Applicability::MaybeIncorrect;
+            let sugg = Sugg::hir_with_context(cx, cast_op, expr.span.ctxt(), "..", &mut app);
+
+            diag.span_suggestion(
+                expr.span,
+                format!("if this is intentional, consider using `{method}` instead"),
+                format!("{}.{method}", sugg.maybe_paren()),
+                app,
+            );
+        }
     });
 }
diff --git a/clippy_lints/src/casts/cast_sign_loss.rs b/clippy_lints/src/casts/cast_sign_loss.rs
index a70bd88619195..757d53e394ff5 100644
--- a/clippy_lints/src/casts/cast_sign_loss.rs
+++ b/clippy_lints/src/casts/cast_sign_loss.rs
@@ -2,15 +2,18 @@ use std::convert::Infallible;
 use std::ops::ControlFlow;
 
 use clippy_utils::consts::{ConstEvalCtxt, Constant};
-use clippy_utils::diagnostics::span_lint;
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::sugg::Sugg;
 use clippy_utils::visitors::{Descend, for_each_expr_without_closures};
 use clippy_utils::{method_chain_args, sext, sym};
+use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
 use rustc_span::Symbol;
 
-use super::CAST_SIGN_LOSS;
+use super::{CAST_SIGN_LOSS, utils};
 
 /// A list of methods that can never return a negative value.
 /// Includes methods that panic rather than returning a negative value.
@@ -42,13 +45,33 @@ pub(super) fn check<'cx>(
     cast_op: &Expr<'_>,
     cast_from: Ty<'cx>,
     cast_to: Ty<'_>,
+    msrv: Msrv,
 ) {
     if should_lint(cx, cast_op, cast_from, cast_to) {
-        span_lint(
+        span_lint_and_then(
             cx,
             CAST_SIGN_LOSS,
             expr.span,
             format!("casting `{cast_from}` to `{cast_to}` may lose the sign of the value"),
+            |diag| {
+                if msrv.meets(cx, msrvs::INTEGER_SIGN_CAST)
+                    && let Some(cast) = utils::is_signedness_cast(cast_from, cast_to)
+                {
+                    let method = match cast {
+                        utils::CastTo::Signed => "cast_signed()",
+                        utils::CastTo::Unsigned => "cast_unsigned()",
+                    };
+                    let mut app = Applicability::MaybeIncorrect;
+                    let sugg = Sugg::hir_with_context(cx, cast_op, expr.span.ctxt(), "..", &mut app);
+
+                    diag.span_suggestion(
+                        expr.span,
+                        format!("if this is intentional, consider using `{method}` instead"),
+                        format!("{}.{method}", sugg.maybe_paren()),
+                        app,
+                    );
+                }
+            },
         );
     }
 }
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 37accff5eaa81..4df2d81ea3554 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -887,9 +887,9 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             if cast_to.is_numeric() {
                 cast_possible_truncation::check(cx, expr, cast_from_expr, cast_from, cast_to, cast_to_hir.span);
                 if cast_from.is_numeric() {
-                    cast_possible_wrap::check(cx, expr, cast_from, cast_to);
+                    cast_possible_wrap::check(cx, expr, cast_from_expr, cast_from, cast_to, self.msrv);
                     cast_precision_loss::check(cx, expr, cast_from, cast_to);
-                    cast_sign_loss::check(cx, expr, cast_from_expr, cast_from, cast_to);
+                    cast_sign_loss::check(cx, expr, cast_from_expr, cast_from, cast_to, self.msrv);
                     cast_abs_to_unsigned::check(cx, expr, cast_from_expr, cast_from, cast_to, self.msrv);
                     cast_nan_to_int::check(cx, expr, cast_from_expr, cast_from, cast_to);
                 }
diff --git a/clippy_lints/src/casts/utils.rs b/clippy_lints/src/casts/utils.rs
index d846d78b9ee78..8251e48da5cdb 100644
--- a/clippy_lints/src/casts/utils.rs
+++ b/clippy_lints/src/casts/utils.rs
@@ -60,3 +60,35 @@ pub(super) fn enum_ty_to_nbits(adt: AdtDef<'_>, tcx: TyCtxt<'_>) -> u64 {
         neg_bits.max(pos_bits).into()
     }
 }
+
+pub(super) enum CastTo {
+    Signed,
+    Unsigned,
+}
+/// Returns `Some` if the type cast is between 2 integral types that differ
+/// only in signedness, otherwise `None`. The value of `Some` is which
+/// signedness is casted to.
+pub(super) fn is_signedness_cast(cast_from: Ty<'_>, cast_to: Ty<'_>) -> Option<CastTo> {
+    if !cast_from.is_integral() || !cast_to.is_integral() {
+        return None;
+    }
+    if cast_from.is_signed() == cast_to.is_signed() {
+        return None;
+    }
+    if as_uint_ty(cast_from) != as_uint_ty(cast_to) {
+        return None;
+    }
+
+    if cast_to.is_signed() {
+        Some(CastTo::Signed)
+    } else {
+        Some(CastTo::Unsigned)
+    }
+}
+fn as_uint_ty(ty: Ty<'_>) -> Option<UintTy> {
+    match ty.kind() {
+        ty::Uint(uint_ty) => Some(*uint_ty),
+        ty::Int(int_ty) => Some(int_ty.to_unsigned()),
+        _ => None,
+    }
+}
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 24ed4c3a8beca..a38550a7b5520 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -24,7 +24,7 @@ macro_rules! msrv_aliases {
 // names may refer to stabilized feature flags or library items
 msrv_aliases! {
     1,88,0 { LET_CHAINS }
-    1,87,0 { OS_STR_DISPLAY, INT_MIDPOINT, CONST_CHAR_IS_DIGIT, UNSIGNED_IS_MULTIPLE_OF }
+    1,87,0 { OS_STR_DISPLAY, INT_MIDPOINT, CONST_CHAR_IS_DIGIT, UNSIGNED_IS_MULTIPLE_OF, INTEGER_SIGN_CAST }
     1,85,0 { UINT_FLOAT_MIDPOINT, CONST_SIZE_OF_VAL }
     1,84,0 { CONST_OPTION_AS_SLICE, MANUAL_DANGLING_PTR }
     1,83,0 { CONST_EXTERN_FN, CONST_FLOAT_BITS_CONV, CONST_FLOAT_CLASSIFY, CONST_MUT_REFS, CONST_UNWRAP }
diff --git a/tests/ui/cast.stderr b/tests/ui/cast.stderr
index 1cb30d956679a..13e0a5583cdc6 100644
--- a/tests/ui/cast.stderr
+++ b/tests/ui/cast.stderr
@@ -194,7 +194,7 @@ error: casting `u8` to `i8` may wrap around the value
   --> tests/ui/cast.rs:88:5
    |
 LL |     1u8 as i8;
-   |     ^^^^^^^^^
+   |     ^^^^^^^^^ help: if this is intentional, consider using `cast_signed()` instead: `1u8.cast_signed()`
    |
    = note: `-D clippy::cast-possible-wrap` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::cast_possible_wrap)]`
@@ -203,25 +203,25 @@ error: casting `u16` to `i16` may wrap around the value
   --> tests/ui/cast.rs:91:5
    |
 LL |     1u16 as i16;
-   |     ^^^^^^^^^^^
+   |     ^^^^^^^^^^^ help: if this is intentional, consider using `cast_signed()` instead: `1u16.cast_signed()`
 
 error: casting `u32` to `i32` may wrap around the value
   --> tests/ui/cast.rs:94:5
    |
 LL |     1u32 as i32;
-   |     ^^^^^^^^^^^
+   |     ^^^^^^^^^^^ help: if this is intentional, consider using `cast_signed()` instead: `1u32.cast_signed()`
 
 error: casting `u64` to `i64` may wrap around the value
   --> tests/ui/cast.rs:97:5
    |
 LL |     1u64 as i64;
-   |     ^^^^^^^^^^^
+   |     ^^^^^^^^^^^ help: if this is intentional, consider using `cast_signed()` instead: `1u64.cast_signed()`
 
 error: casting `usize` to `isize` may wrap around the value
   --> tests/ui/cast.rs:100:5
    |
 LL |     1usize as isize;
-   |     ^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_signed()` instead: `1usize.cast_signed()`
 
 error: casting `usize` to `i8` may truncate the value
   --> tests/ui/cast.rs:104:5
@@ -321,43 +321,43 @@ error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:138:5
    |
 LL |     -1i32 as u32;
-   |     ^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(-1i32).cast_unsigned()`
 
 error: casting `isize` to `usize` may lose the sign of the value
   --> tests/ui/cast.rs:142:5
    |
 LL |     -1isize as usize;
-   |     ^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(-1isize).cast_unsigned()`
 
 error: casting `i8` to `u8` may lose the sign of the value
   --> tests/ui/cast.rs:154:5
    |
 LL |     (i8::MIN).abs() as u8;
-   |     ^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(i8::MIN).abs().cast_unsigned()`
 
 error: casting `i64` to `u64` may lose the sign of the value
   --> tests/ui/cast.rs:159:5
    |
 LL |     (-1i64).abs() as u64;
-   |     ^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(-1i64).abs().cast_unsigned()`
 
 error: casting `isize` to `usize` may lose the sign of the value
   --> tests/ui/cast.rs:161:5
    |
 LL |     (-1isize).abs() as usize;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(-1isize).abs().cast_unsigned()`
 
 error: casting `i64` to `u64` may lose the sign of the value
   --> tests/ui/cast.rs:169:5
    |
 LL |     (unsafe { (-1i64).checked_abs().unwrap_unchecked() }) as u64;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(unsafe { (-1i64).checked_abs().unwrap_unchecked() }).cast_unsigned()`
 
 error: casting `i64` to `u64` may lose the sign of the value
   --> tests/ui/cast.rs:185:5
    |
 LL |     (unsafe { (-1i64).checked_isqrt().unwrap_unchecked() }) as u64;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(unsafe { (-1i64).checked_isqrt().unwrap_unchecked() }).cast_unsigned()`
 
 error: casting `i64` to `i8` may truncate the value
   --> tests/ui/cast.rs:237:5
@@ -495,79 +495,79 @@ error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:438:9
    |
 LL |         (x * x) as u32;
-   |         ^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(x * x).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:444:32
    |
 LL |     let _a = |x: i32| -> u32 { (x * x * x * x) as u32 };
-   |                                ^^^^^^^^^^^^^^^^^^^^^^
+   |                                ^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(x * x * x * x).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:447:5
    |
 LL |     (2_i32).checked_pow(3).unwrap() as u32;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(2_i32).checked_pow(3).unwrap().cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:449:5
    |
 LL |     (-2_i32).pow(3) as u32;
-   |     ^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(-2_i32).pow(3).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:454:5
    |
 LL |     (-5_i32 % 2) as u32;
-   |     ^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(-5_i32 % 2).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:457:5
    |
 LL |     (-5_i32 % -2) as u32;
-   |     ^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(-5_i32 % -2).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:461:5
    |
 LL |     (-2_i32 >> 1) as u32;
-   |     ^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(-2_i32 >> 1).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:465:5
    |
 LL |     (x * x) as u32;
-   |     ^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(x * x).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:467:5
    |
 LL |     (x * x * x) as u32;
-   |     ^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(x * x * x).cast_unsigned()`
 
 error: casting `i16` to `u16` may lose the sign of the value
   --> tests/ui/cast.rs:471:5
    |
 LL |     (y * y * y * y * -2) as u16;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(y * y * y * y * -2).cast_unsigned()`
 
 error: casting `i16` to `u16` may lose the sign of the value
   --> tests/ui/cast.rs:474:5
    |
 LL |     (y * y * y / y * 2) as u16;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(y * y * y / y * 2).cast_unsigned()`
 
 error: casting `i16` to `u16` may lose the sign of the value
   --> tests/ui/cast.rs:476:5
    |
 LL |     (y * y / y * 2) as u16;
-   |     ^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(y * y / y * 2).cast_unsigned()`
 
 error: casting `i16` to `u16` may lose the sign of the value
   --> tests/ui/cast.rs:479:5
    |
 LL |     (y / y * y * -2) as u16;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(y / y * y * -2).cast_unsigned()`
 
 error: equal expressions as operands to `/`
   --> tests/ui/cast.rs:479:6
@@ -581,97 +581,97 @@ error: casting `i16` to `u16` may lose the sign of the value
   --> tests/ui/cast.rs:483:5
    |
 LL |     (y + y + y + -2) as u16;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(y + y + y + -2).cast_unsigned()`
 
 error: casting `i16` to `u16` may lose the sign of the value
   --> tests/ui/cast.rs:486:5
    |
 LL |     (y + y + y + 2) as u16;
-   |     ^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(y + y + y + 2).cast_unsigned()`
 
 error: casting `i16` to `u16` may lose the sign of the value
   --> tests/ui/cast.rs:490:5
    |
 LL |     (z + -2) as u16;
-   |     ^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(z + -2).cast_unsigned()`
 
 error: casting `i16` to `u16` may lose the sign of the value
   --> tests/ui/cast.rs:493:5
    |
 LL |     (z + z + 2) as u16;
-   |     ^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(z + z + 2).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:497:9
    |
 LL |         (a * a * b * b * c * c) as u32;
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(a * a * b * b * c * c).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:499:9
    |
 LL |         (a * b * c) as u32;
-   |         ^^^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(a * b * c).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:502:9
    |
 LL |         (a * -b * c) as u32;
-   |         ^^^^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(a * -b * c).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:505:9
    |
 LL |         (a * b * c * c) as u32;
-   |         ^^^^^^^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(a * b * c * c).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:507:9
    |
 LL |         (a * -2) as u32;
-   |         ^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(a * -2).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:510:9
    |
 LL |         (a * b * c * -2) as u32;
-   |         ^^^^^^^^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(a * b * c * -2).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:513:9
    |
 LL |         (a / b) as u32;
-   |         ^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(a / b).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:515:9
    |
 LL |         (a / b * c) as u32;
-   |         ^^^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(a / b * c).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:518:9
    |
 LL |         (a / b + b * c) as u32;
-   |         ^^^^^^^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(a / b + b * c).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:521:9
    |
 LL |         a.saturating_pow(3) as u32;
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `a.saturating_pow(3).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:524:9
    |
 LL |         (a.abs() * b.pow(2) / c.abs()) as u32
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(a.abs() * b.pow(2) / c.abs()).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:532:21
    |
 LL |             let _ = i32::MIN as u32; // cast_sign_loss
-   |                     ^^^^^^^^^^^^^^^
+   |                     ^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `i32::MIN.cast_unsigned()`
 ...
 LL |     m!();
    |     ---- in this macro invocation

From 0eb16ea97b5161da7874f772e20e49f02af20189 Mon Sep 17 00:00:00 2001
From: RunDevelopment <mitchi5000.ms@googlemail.com>
Date: Sat, 2 Aug 2025 00:16:08 +0200
Subject: [PATCH 0020/1889] Add test to ensure that suggestions are only
 emitted if MSRV supports it

---
 tests/ui/cast.rs     | 13 +++++++++++++
 tests/ui/cast.stderr | 14 +++++++++++++-
 2 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/tests/ui/cast.rs b/tests/ui/cast.rs
index 525be8216500a..fab02bf7b24e4 100644
--- a/tests/ui/cast.rs
+++ b/tests/ui/cast.rs
@@ -569,3 +569,16 @@ fn issue12721() {
     (255 % 999999u64) as u8;
     //~^ cast_possible_truncation
 }
+
+mod issue14150 {
+    #[clippy::msrv = "1.87"]
+    fn msrv_supports_cast_signed() {
+        _ = 1u8 as i8;
+        //~^ cast_possible_wrap
+    }
+    #[clippy::msrv = "1.86"]
+    fn msrv_doesnt_supports_cast_signed() {
+        _ = 1u8 as i8;
+        //~^ cast_possible_wrap
+    }
+}
diff --git a/tests/ui/cast.stderr b/tests/ui/cast.stderr
index 13e0a5583cdc6..f131369df2414 100644
--- a/tests/ui/cast.stderr
+++ b/tests/ui/cast.stderr
@@ -752,5 +752,17 @@ LL -     (255 % 999999u64) as u8;
 LL +     u8::try_from(255 % 999999u64);
    |
 
-error: aborting due to 92 previous errors
+error: casting `u8` to `i8` may wrap around the value
+  --> tests/ui/cast.rs:576:13
+   |
+LL |         _ = 1u8 as i8;
+   |             ^^^^^^^^^ help: if this is intentional, consider using `cast_signed()` instead: `1u8.cast_signed()`
+
+error: casting `u8` to `i8` may wrap around the value
+  --> tests/ui/cast.rs:581:13
+   |
+LL |         _ = 1u8 as i8;
+   |             ^^^^^^^^^
+
+error: aborting due to 94 previous errors
 

From 4e286bb8fb305d6ba864ff8b2c806b4fd189657a Mon Sep 17 00:00:00 2001
From: RunDevelopment <mitchi5000.ms@googlemail.com>
Date: Sun, 3 Aug 2025 13:44:56 +0200
Subject: [PATCH 0021/1889] Apply suggestions from code review

---
 clippy_lints/src/casts/cast_possible_wrap.rs |  2 +-
 clippy_lints/src/casts/cast_sign_loss.rs     |  2 +-
 clippy_lints/src/casts/utils.rs              | 23 +-----
 tests/ui/cast.stderr                         | 84 ++++++++++----------
 4 files changed, 47 insertions(+), 64 deletions(-)

diff --git a/clippy_lints/src/casts/cast_possible_wrap.rs b/clippy_lints/src/casts/cast_possible_wrap.rs
index 5a8b3e6d9a411..9eaa6e4cf26e4 100644
--- a/clippy_lints/src/casts/cast_possible_wrap.rs
+++ b/clippy_lints/src/casts/cast_possible_wrap.rs
@@ -108,7 +108,7 @@ pub(super) fn check(
 
             diag.span_suggestion(
                 expr.span,
-                format!("if this is intentional, consider using `{method}` instead"),
+                format!("if this is intentional, use `{method}` instead"),
                 format!("{}.{method}", sugg.maybe_paren()),
                 app,
             );
diff --git a/clippy_lints/src/casts/cast_sign_loss.rs b/clippy_lints/src/casts/cast_sign_loss.rs
index 757d53e394ff5..f870d27b796e8 100644
--- a/clippy_lints/src/casts/cast_sign_loss.rs
+++ b/clippy_lints/src/casts/cast_sign_loss.rs
@@ -66,7 +66,7 @@ pub(super) fn check<'cx>(
 
                     diag.span_suggestion(
                         expr.span,
-                        format!("if this is intentional, consider using `{method}` instead"),
+                        format!("if this is intentional, use `{method}` instead"),
                         format!("{}.{method}", sugg.maybe_paren()),
                         app,
                     );
diff --git a/clippy_lints/src/casts/utils.rs b/clippy_lints/src/casts/utils.rs
index 8251e48da5cdb..707fc2a8eed35 100644
--- a/clippy_lints/src/casts/utils.rs
+++ b/clippy_lints/src/casts/utils.rs
@@ -69,26 +69,9 @@ pub(super) enum CastTo {
 /// only in signedness, otherwise `None`. The value of `Some` is which
 /// signedness is casted to.
 pub(super) fn is_signedness_cast(cast_from: Ty<'_>, cast_to: Ty<'_>) -> Option<CastTo> {
-    if !cast_from.is_integral() || !cast_to.is_integral() {
-        return None;
-    }
-    if cast_from.is_signed() == cast_to.is_signed() {
-        return None;
-    }
-    if as_uint_ty(cast_from) != as_uint_ty(cast_to) {
-        return None;
-    }
-
-    if cast_to.is_signed() {
-        Some(CastTo::Signed)
-    } else {
-        Some(CastTo::Unsigned)
-    }
-}
-fn as_uint_ty(ty: Ty<'_>) -> Option<UintTy> {
-    match ty.kind() {
-        ty::Uint(uint_ty) => Some(*uint_ty),
-        ty::Int(int_ty) => Some(int_ty.to_unsigned()),
+    match (cast_from.kind(), cast_to.kind()) {
+        (ty::Int(from), ty::Uint(to)) if from.to_unsigned() == *to => Some(CastTo::Unsigned),
+        (ty::Uint(from), ty::Int(to)) if *from == to.to_unsigned() => Some(CastTo::Signed),
         _ => None,
     }
 }
diff --git a/tests/ui/cast.stderr b/tests/ui/cast.stderr
index f131369df2414..8c48855123f93 100644
--- a/tests/ui/cast.stderr
+++ b/tests/ui/cast.stderr
@@ -194,7 +194,7 @@ error: casting `u8` to `i8` may wrap around the value
   --> tests/ui/cast.rs:88:5
    |
 LL |     1u8 as i8;
-   |     ^^^^^^^^^ help: if this is intentional, consider using `cast_signed()` instead: `1u8.cast_signed()`
+   |     ^^^^^^^^^ help: if this is intentional, use `cast_signed()` instead: `1u8.cast_signed()`
    |
    = note: `-D clippy::cast-possible-wrap` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::cast_possible_wrap)]`
@@ -203,25 +203,25 @@ error: casting `u16` to `i16` may wrap around the value
   --> tests/ui/cast.rs:91:5
    |
 LL |     1u16 as i16;
-   |     ^^^^^^^^^^^ help: if this is intentional, consider using `cast_signed()` instead: `1u16.cast_signed()`
+   |     ^^^^^^^^^^^ help: if this is intentional, use `cast_signed()` instead: `1u16.cast_signed()`
 
 error: casting `u32` to `i32` may wrap around the value
   --> tests/ui/cast.rs:94:5
    |
 LL |     1u32 as i32;
-   |     ^^^^^^^^^^^ help: if this is intentional, consider using `cast_signed()` instead: `1u32.cast_signed()`
+   |     ^^^^^^^^^^^ help: if this is intentional, use `cast_signed()` instead: `1u32.cast_signed()`
 
 error: casting `u64` to `i64` may wrap around the value
   --> tests/ui/cast.rs:97:5
    |
 LL |     1u64 as i64;
-   |     ^^^^^^^^^^^ help: if this is intentional, consider using `cast_signed()` instead: `1u64.cast_signed()`
+   |     ^^^^^^^^^^^ help: if this is intentional, use `cast_signed()` instead: `1u64.cast_signed()`
 
 error: casting `usize` to `isize` may wrap around the value
   --> tests/ui/cast.rs:100:5
    |
 LL |     1usize as isize;
-   |     ^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_signed()` instead: `1usize.cast_signed()`
+   |     ^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_signed()` instead: `1usize.cast_signed()`
 
 error: casting `usize` to `i8` may truncate the value
   --> tests/ui/cast.rs:104:5
@@ -321,43 +321,43 @@ error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:138:5
    |
 LL |     -1i32 as u32;
-   |     ^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(-1i32).cast_unsigned()`
+   |     ^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(-1i32).cast_unsigned()`
 
 error: casting `isize` to `usize` may lose the sign of the value
   --> tests/ui/cast.rs:142:5
    |
 LL |     -1isize as usize;
-   |     ^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(-1isize).cast_unsigned()`
+   |     ^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(-1isize).cast_unsigned()`
 
 error: casting `i8` to `u8` may lose the sign of the value
   --> tests/ui/cast.rs:154:5
    |
 LL |     (i8::MIN).abs() as u8;
-   |     ^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(i8::MIN).abs().cast_unsigned()`
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(i8::MIN).abs().cast_unsigned()`
 
 error: casting `i64` to `u64` may lose the sign of the value
   --> tests/ui/cast.rs:159:5
    |
 LL |     (-1i64).abs() as u64;
-   |     ^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(-1i64).abs().cast_unsigned()`
+   |     ^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(-1i64).abs().cast_unsigned()`
 
 error: casting `isize` to `usize` may lose the sign of the value
   --> tests/ui/cast.rs:161:5
    |
 LL |     (-1isize).abs() as usize;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(-1isize).abs().cast_unsigned()`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(-1isize).abs().cast_unsigned()`
 
 error: casting `i64` to `u64` may lose the sign of the value
   --> tests/ui/cast.rs:169:5
    |
 LL |     (unsafe { (-1i64).checked_abs().unwrap_unchecked() }) as u64;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(unsafe { (-1i64).checked_abs().unwrap_unchecked() }).cast_unsigned()`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(unsafe { (-1i64).checked_abs().unwrap_unchecked() }).cast_unsigned()`
 
 error: casting `i64` to `u64` may lose the sign of the value
   --> tests/ui/cast.rs:185:5
    |
 LL |     (unsafe { (-1i64).checked_isqrt().unwrap_unchecked() }) as u64;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(unsafe { (-1i64).checked_isqrt().unwrap_unchecked() }).cast_unsigned()`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(unsafe { (-1i64).checked_isqrt().unwrap_unchecked() }).cast_unsigned()`
 
 error: casting `i64` to `i8` may truncate the value
   --> tests/ui/cast.rs:237:5
@@ -495,79 +495,79 @@ error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:438:9
    |
 LL |         (x * x) as u32;
-   |         ^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(x * x).cast_unsigned()`
+   |         ^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(x * x).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:444:32
    |
 LL |     let _a = |x: i32| -> u32 { (x * x * x * x) as u32 };
-   |                                ^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(x * x * x * x).cast_unsigned()`
+   |                                ^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(x * x * x * x).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:447:5
    |
 LL |     (2_i32).checked_pow(3).unwrap() as u32;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(2_i32).checked_pow(3).unwrap().cast_unsigned()`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(2_i32).checked_pow(3).unwrap().cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:449:5
    |
 LL |     (-2_i32).pow(3) as u32;
-   |     ^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(-2_i32).pow(3).cast_unsigned()`
+   |     ^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(-2_i32).pow(3).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:454:5
    |
 LL |     (-5_i32 % 2) as u32;
-   |     ^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(-5_i32 % 2).cast_unsigned()`
+   |     ^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(-5_i32 % 2).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:457:5
    |
 LL |     (-5_i32 % -2) as u32;
-   |     ^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(-5_i32 % -2).cast_unsigned()`
+   |     ^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(-5_i32 % -2).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:461:5
    |
 LL |     (-2_i32 >> 1) as u32;
-   |     ^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(-2_i32 >> 1).cast_unsigned()`
+   |     ^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(-2_i32 >> 1).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:465:5
    |
 LL |     (x * x) as u32;
-   |     ^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(x * x).cast_unsigned()`
+   |     ^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(x * x).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:467:5
    |
 LL |     (x * x * x) as u32;
-   |     ^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(x * x * x).cast_unsigned()`
+   |     ^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(x * x * x).cast_unsigned()`
 
 error: casting `i16` to `u16` may lose the sign of the value
   --> tests/ui/cast.rs:471:5
    |
 LL |     (y * y * y * y * -2) as u16;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(y * y * y * y * -2).cast_unsigned()`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(y * y * y * y * -2).cast_unsigned()`
 
 error: casting `i16` to `u16` may lose the sign of the value
   --> tests/ui/cast.rs:474:5
    |
 LL |     (y * y * y / y * 2) as u16;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(y * y * y / y * 2).cast_unsigned()`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(y * y * y / y * 2).cast_unsigned()`
 
 error: casting `i16` to `u16` may lose the sign of the value
   --> tests/ui/cast.rs:476:5
    |
 LL |     (y * y / y * 2) as u16;
-   |     ^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(y * y / y * 2).cast_unsigned()`
+   |     ^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(y * y / y * 2).cast_unsigned()`
 
 error: casting `i16` to `u16` may lose the sign of the value
   --> tests/ui/cast.rs:479:5
    |
 LL |     (y / y * y * -2) as u16;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(y / y * y * -2).cast_unsigned()`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(y / y * y * -2).cast_unsigned()`
 
 error: equal expressions as operands to `/`
   --> tests/ui/cast.rs:479:6
@@ -581,97 +581,97 @@ error: casting `i16` to `u16` may lose the sign of the value
   --> tests/ui/cast.rs:483:5
    |
 LL |     (y + y + y + -2) as u16;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(y + y + y + -2).cast_unsigned()`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(y + y + y + -2).cast_unsigned()`
 
 error: casting `i16` to `u16` may lose the sign of the value
   --> tests/ui/cast.rs:486:5
    |
 LL |     (y + y + y + 2) as u16;
-   |     ^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(y + y + y + 2).cast_unsigned()`
+   |     ^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(y + y + y + 2).cast_unsigned()`
 
 error: casting `i16` to `u16` may lose the sign of the value
   --> tests/ui/cast.rs:490:5
    |
 LL |     (z + -2) as u16;
-   |     ^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(z + -2).cast_unsigned()`
+   |     ^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(z + -2).cast_unsigned()`
 
 error: casting `i16` to `u16` may lose the sign of the value
   --> tests/ui/cast.rs:493:5
    |
 LL |     (z + z + 2) as u16;
-   |     ^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(z + z + 2).cast_unsigned()`
+   |     ^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(z + z + 2).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:497:9
    |
 LL |         (a * a * b * b * c * c) as u32;
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(a * a * b * b * c * c).cast_unsigned()`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(a * a * b * b * c * c).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:499:9
    |
 LL |         (a * b * c) as u32;
-   |         ^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(a * b * c).cast_unsigned()`
+   |         ^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(a * b * c).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:502:9
    |
 LL |         (a * -b * c) as u32;
-   |         ^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(a * -b * c).cast_unsigned()`
+   |         ^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(a * -b * c).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:505:9
    |
 LL |         (a * b * c * c) as u32;
-   |         ^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(a * b * c * c).cast_unsigned()`
+   |         ^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(a * b * c * c).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:507:9
    |
 LL |         (a * -2) as u32;
-   |         ^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(a * -2).cast_unsigned()`
+   |         ^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(a * -2).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:510:9
    |
 LL |         (a * b * c * -2) as u32;
-   |         ^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(a * b * c * -2).cast_unsigned()`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(a * b * c * -2).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:513:9
    |
 LL |         (a / b) as u32;
-   |         ^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(a / b).cast_unsigned()`
+   |         ^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(a / b).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:515:9
    |
 LL |         (a / b * c) as u32;
-   |         ^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(a / b * c).cast_unsigned()`
+   |         ^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(a / b * c).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:518:9
    |
 LL |         (a / b + b * c) as u32;
-   |         ^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(a / b + b * c).cast_unsigned()`
+   |         ^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(a / b + b * c).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:521:9
    |
 LL |         a.saturating_pow(3) as u32;
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `a.saturating_pow(3).cast_unsigned()`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `a.saturating_pow(3).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:524:9
    |
 LL |         (a.abs() * b.pow(2) / c.abs()) as u32
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `(a.abs() * b.pow(2) / c.abs()).cast_unsigned()`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(a.abs() * b.pow(2) / c.abs()).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:532:21
    |
 LL |             let _ = i32::MIN as u32; // cast_sign_loss
-   |                     ^^^^^^^^^^^^^^^ help: if this is intentional, consider using `cast_unsigned()` instead: `i32::MIN.cast_unsigned()`
+   |                     ^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `i32::MIN.cast_unsigned()`
 ...
 LL |     m!();
    |     ---- in this macro invocation
@@ -756,7 +756,7 @@ error: casting `u8` to `i8` may wrap around the value
   --> tests/ui/cast.rs:576:13
    |
 LL |         _ = 1u8 as i8;
-   |             ^^^^^^^^^ help: if this is intentional, consider using `cast_signed()` instead: `1u8.cast_signed()`
+   |             ^^^^^^^^^ help: if this is intentional, use `cast_signed()` instead: `1u8.cast_signed()`
 
 error: casting `u8` to `i8` may wrap around the value
   --> tests/ui/cast.rs:581:13

From b0bbfd1bb75794f6664334f60fa2bcf064ea3bd3 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Mon, 4 Aug 2025 01:53:10 +0800
Subject: [PATCH 0022/1889] Add assignment type analysis for ide-completion

---
 .../ide-completion/src/context/analysis.rs    | 32 ++++++++++++
 .../ide-completion/src/context/tests.rs       | 50 +++++++++++++++++++
 2 files changed, 82 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
index ea5fb39338b2e..67fc79e8032c1 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
@@ -562,6 +562,7 @@ fn expected_type_and_name<'db>(
     token: &SyntaxToken,
     name_like: &ast::NameLike,
 ) -> (Option<Type<'db>>, Option<NameOrNameRef>) {
+    let token = prev_assign_token_at_whitespace(token.clone());
     let mut node = match token.parent() {
         Some(it) => it,
         None => return (None, None),
@@ -632,6 +633,17 @@ fn expected_type_and_name<'db>(
                         .map(TypeInfo::original);
                     (ty, None)
                 },
+                ast::BinExpr(it) => {
+                    if let Some(ast::BinaryOp::Assignment { op: None }) = it.op_kind() {
+                        let ty = it.lhs()
+                            .and_then(|lhs| sema.type_of_expr(&lhs))
+                            .or_else(|| it.rhs().and_then(|rhs| sema.type_of_expr(&rhs)))
+                            .map(TypeInfo::original);
+                        (ty, None)
+                    } else {
+                        (None, None)
+                    }
+                },
                 ast::ArgList(_) => {
                     cov_mark::hit!(expected_type_fn_param);
                     ActiveParameter::at_token(
@@ -1870,3 +1882,23 @@ fn next_non_trivia_sibling(ele: SyntaxElement) -> Option<SyntaxElement> {
     }
     None
 }
+
+fn prev_assign_token_at_whitespace(mut token: SyntaxToken) -> SyntaxToken {
+    while token.kind() == SyntaxKind::WHITESPACE
+        && let Some(prev) = token.prev_token()
+        && let T![=]
+        | T![+=]
+        | T![/=]
+        | T![*=]
+        | T![%=]
+        | T![>>=]
+        | T![<<=]
+        | T![-=]
+        | T![|=]
+        | T![&=]
+        | T![^=] = prev.kind()
+    {
+        token = prev
+    }
+    token
+}
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context/tests.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context/tests.rs
index 75c20968e1e5f..7a8c70f190efc 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context/tests.rs
@@ -434,3 +434,53 @@ fn f(thing: u32) -> &u32 {
         expect!["ty: u32, name: ?"],
     );
 }
+
+#[test]
+fn expected_type_assign() {
+    check_expected_type_and_name(
+        r#"
+enum State { Stop }
+fn foo() {
+    let x: &mut State = &mut State::Stop;
+    x = $0;
+}
+"#,
+        expect![[r#"ty: &'_ mut State, name: ?"#]],
+    );
+}
+
+#[test]
+fn expected_type_deref_assign() {
+    check_expected_type_and_name(
+        r#"
+enum State { Stop }
+fn foo() {
+    let x: &mut State = &mut State::Stop;
+    match x {
+        State::Stop => {
+            *x = $0;
+        },
+    }
+}
+"#,
+        expect![[r#"ty: State, name: ?"#]],
+    );
+}
+
+#[test]
+fn expected_type_deref_assign_at_block_end() {
+    check_expected_type_and_name(
+        r#"
+enum State { Stop }
+fn foo() {
+    let x: &mut State = &mut State::Stop;
+    match x {
+        State::Stop => {
+            *x = $0
+        },
+    }
+}
+"#,
+        expect![[r#"ty: State, name: ?"#]],
+    );
+}

From b5a4e5d73fb7fd47caa1b22ffe8527c13f895c21 Mon Sep 17 00:00:00 2001
From: Kivooeo <Kivooeo123@gmail.com>
Date: Mon, 4 Aug 2025 01:24:22 +0500
Subject: [PATCH 0023/1889] remove gates

---
 library/alloc/src/collections/btree/map/entry.rs | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/library/alloc/src/collections/btree/map/entry.rs b/library/alloc/src/collections/btree/map/entry.rs
index ea8fa363c3805..b16aad0bb03dd 100644
--- a/library/alloc/src/collections/btree/map/entry.rs
+++ b/library/alloc/src/collections/btree/map/entry.rs
@@ -275,7 +275,6 @@ impl<'a, K: Ord, V, A: Allocator + Clone> Entry<'a, K, V, A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(btree_entry_insert)]
     /// use std::collections::BTreeMap;
     ///
     /// let mut map: BTreeMap<&str, String> = BTreeMap::new();
@@ -284,7 +283,7 @@ impl<'a, K: Ord, V, A: Allocator + Clone> Entry<'a, K, V, A> {
     /// assert_eq!(entry.key(), &"poneyland");
     /// ```
     #[inline]
-    #[unstable(feature = "btree_entry_insert", issue = "65225")]
+    #[stable(feature = "btree_entry_insert", since = "CURRENT_RUSTC_VERSION")]
     pub fn insert_entry(self, value: V) -> OccupiedEntry<'a, K, V, A> {
         match self {
             Occupied(mut entry) => {
@@ -383,7 +382,6 @@ impl<'a, K: Ord, V, A: Allocator + Clone> VacantEntry<'a, K, V, A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(btree_entry_insert)]
     /// use std::collections::BTreeMap;
     /// use std::collections::btree_map::Entry;
     ///
@@ -395,7 +393,7 @@ impl<'a, K: Ord, V, A: Allocator + Clone> VacantEntry<'a, K, V, A> {
     /// }
     /// assert_eq!(map["poneyland"], 37);
     /// ```
-    #[unstable(feature = "btree_entry_insert", issue = "65225")]
+    #[stable(feature = "btree_entry_insert", since = "CURRENT_RUSTC_VERSION")]
     pub fn insert_entry(mut self, value: V) -> OccupiedEntry<'a, K, V, A> {
         let handle = match self.handle {
             None => {

From bf500ec822cb27ec82a259c3edc0cba86e7b1ac4 Mon Sep 17 00:00:00 2001
From: skewb1k <skewb1kunix@gmail.com>
Date: Mon, 4 Aug 2025 14:11:06 +0300
Subject: [PATCH 0024/1889] chore: fix crates/ide/src/folding_ranges.rs file
 perms

755 -> 644
---
 src/tools/rust-analyzer/crates/ide/src/folding_ranges.rs | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 mode change 100755 => 100644 src/tools/rust-analyzer/crates/ide/src/folding_ranges.rs

diff --git a/src/tools/rust-analyzer/crates/ide/src/folding_ranges.rs b/src/tools/rust-analyzer/crates/ide/src/folding_ranges.rs
old mode 100755
new mode 100644

From 1d817dc7a782e011797de3225037241eaabdf631 Mon Sep 17 00:00:00 2001
From: skewb1k <skewb1kunix@gmail.com>
Date: Mon, 4 Aug 2025 14:42:45 +0300
Subject: [PATCH 0025/1889] fix(hover): unify horizontal rule formatting to
 `---`

Replaces all `___` with `---` in hover documentation markups.

Both styles are valid per the GitHub Flavored Markdown spec,
but `---` is less ambiguous and already more widely used in rust-analyzer
---
 .../crates/ide/src/hover/render.rs            |  8 +-
 .../crates/ide/src/hover/tests.rs             | 76 +++++++++----------
 2 files changed, 42 insertions(+), 42 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide/src/hover/render.rs b/src/tools/rust-analyzer/crates/ide/src/hover/render.rs
index 51b5900e8155a..653465e9ed5ba 100644
--- a/src/tools/rust-analyzer/crates/ide/src/hover/render.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/hover/render.rs
@@ -361,7 +361,7 @@ pub(super) fn try_for_lint(attr: &ast::Attr, token: &SyntaxToken) -> Option<Hove
     let lint =
         lints.binary_search_by_key(&needle, |lint| lint.label).ok().map(|idx| &lints[idx])?;
     Some(HoverResult {
-        markup: Markup::from(format!("```\n{}\n```\n___\n\n{}", lint.label, lint.description)),
+        markup: Markup::from(format!("```\n{}\n```\n---\n\n{}", lint.label, lint.description)),
         ..Default::default()
     })
 }
@@ -912,7 +912,7 @@ pub(super) fn literal(
     };
     let ty = ty.display(sema.db, display_target);
 
-    let mut s = format!("```rust\n{ty}\n```\n___\n\n");
+    let mut s = format!("```rust\n{ty}\n```\n---\n\n");
     match value {
         Ok(value) => {
             let backtick_len = value.chars().filter(|c| *c == '`').count();
@@ -1026,7 +1026,7 @@ fn type_info(
         if let Some(extra) =
             render_notable_trait(db, &notable_traits(db, &original), edition, display_target)
         {
-            desc.push_str("\n___\n");
+            desc.push_str("\n---\n");
             desc.push_str(&extra);
         };
         desc.into()
@@ -1094,7 +1094,7 @@ fn closure_ty(
         |_| None,
         |_| None,
     ) {
-        format_to!(markup, "\n___\n{layout}");
+        format_to!(markup, "\n---\n{layout}");
     }
     format_to!(markup, "{adjusted}\n\n## Captures\n{}", captures_rendered,);
 
diff --git a/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs b/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
index c5480217a91e2..187fd1222e89b 100644
--- a/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
@@ -357,7 +357,7 @@ fn main() {
             ```rust
             impl Fn(i32) -> i32
             ```
-            ___
+            ---
             size = 8, align = 8, niches = 1
 
             ## Captures
@@ -380,7 +380,7 @@ fn main() {
             ```rust
             impl Fn(i32) -> i32
             ```
-            ___
+            ---
             size = 0, align = 1
 
             ## Captures
@@ -414,7 +414,7 @@ fn main() {
             ```rust
             impl FnOnce()
             ```
-            ___
+            ---
             size = 16 (0x10), align = 8, niches = 1
 
             ## Captures
@@ -443,7 +443,7 @@ fn main() {
             ```rust
             impl FnMut()
             ```
-            ___
+            ---
             size = 8, align = 8, niches = 1
 
             ## Captures
@@ -468,7 +468,7 @@ fn main() {
             ```rust
             impl FnOnce() -> S2
             ```
-            ___
+            ---
             size = 8, align = 8, niches = 1
             Coerced to: &impl FnOnce() -> S2
 
@@ -6829,7 +6829,7 @@ fn hover_lint() {
                 ```
                 arithmetic_overflow
                 ```
-                ___
+                ---
 
                 arithmetic operation overflows
             "#]],
@@ -6841,7 +6841,7 @@ fn hover_lint() {
                 ```
                 arithmetic_overflow
                 ```
-                ___
+                ---
 
                 arithmetic operation overflows
             "#]],
@@ -6857,7 +6857,7 @@ fn hover_clippy_lint() {
                 ```
                 clippy::almost_swapped
                 ```
-                ___
+                ---
 
                 Checks for `foo = bar; bar = foo` sequences.
             "#]],
@@ -6869,7 +6869,7 @@ fn hover_clippy_lint() {
                 ```
                 clippy::almost_swapped
                 ```
-                ___
+                ---
 
                 Checks for `foo = bar; bar = foo` sequences.
             "#]],
@@ -8567,7 +8567,7 @@ fn main() {
             ```rust
             &'static str
             ```
-            ___
+            ---
 
             value of literal: ` 🦀🦀\A `
         "#]],
@@ -8583,7 +8583,7 @@ fn main() {
             ```rust
             &'static str
             ```
-            ___
+            ---
 
             value of literal: ` 🦀\u{1f980}\\\x41 `
         "#]],
@@ -8605,7 +8605,7 @@ fsdghs";
             ```rust
             &'static str
             ```
-            ___
+            ---
 
             value of literal (truncated up to newline): ` 🦀\u{1f980}\\\x41 `
         "#]],
@@ -8625,7 +8625,7 @@ fn main() {
             ```rust
             &'static {unknown}
             ```
-            ___
+            ---
 
             value of literal: ` 🦀🦀\A `
         "#]],
@@ -8644,7 +8644,7 @@ fn main() {
             ```rust
             &'static str
             ```
-            ___
+            ---
 
             value of literal: ```` `[^`]*` ````
         "#]],
@@ -8659,7 +8659,7 @@ fn main() {
             ```rust
             &'static str
             ```
-            ___
+            ---
 
             value of literal: `` ` ``
         "#]],
@@ -8674,7 +8674,7 @@ fn main() {
             ```rust
             &'static str
             ```
-            ___
+            ---
 
             value of literal: `    `
         "#]],
@@ -8690,7 +8690,7 @@ fn main() {
             ```rust
             &'static str
             ```
-            ___
+            ---
 
             value of literal: `  Hello World  `
         "#]],
@@ -8710,7 +8710,7 @@ fn main() {
             ```rust
             &'static [u8; 5]
             ```
-            ___
+            ---
 
             value of literal: ` [240, 159, 166, 128, 92] `
         "#]],
@@ -8726,7 +8726,7 @@ fn main() {
             ```rust
             &'static [u8; 18]
             ```
-            ___
+            ---
 
             value of literal: ` [92, 120, 70, 48, 92, 120, 57, 70, 92, 120, 65, 54, 92, 120, 56, 48, 92, 92] `
         "#]],
@@ -8746,7 +8746,7 @@ fn main() {
             ```rust
             u8
             ```
-            ___
+            ---
 
             value of literal: ` 0xF0 `
         "#]],
@@ -8762,7 +8762,7 @@ fn main() {
             ```rust
             u8
             ```
-            ___
+            ---
 
             value of literal: ` 0x5C `
         "#]],
@@ -8782,7 +8782,7 @@ fn main() {
             ```rust
             char
             ```
-            ___
+            ---
 
             value of literal: ` A `
         "#]],
@@ -8798,7 +8798,7 @@ fn main() {
             ```rust
             char
             ```
-            ___
+            ---
 
             value of literal: ` \ `
         "#]],
@@ -8814,7 +8814,7 @@ fn main() {
             ```rust
             char
             ```
-            ___
+            ---
 
             value of literal: ` 🦀 `
         "#]],
@@ -8834,7 +8834,7 @@ fn main() {
             ```rust
             f64
             ```
-            ___
+            ---
 
             value of literal: ` 1 (bits: 0x3FF0000000000000) `
         "#]],
@@ -8850,7 +8850,7 @@ fn main() {
             ```rust
             f16
             ```
-            ___
+            ---
 
             value of literal: ` 1 (bits: 0x3C00) `
         "#]],
@@ -8866,7 +8866,7 @@ fn main() {
             ```rust
             f32
             ```
-            ___
+            ---
 
             value of literal: ` 1 (bits: 0x3F800000) `
         "#]],
@@ -8882,7 +8882,7 @@ fn main() {
             ```rust
             f128
             ```
-            ___
+            ---
 
             value of literal: ` 1 (bits: 0x3FFF0000000000000000000000000000) `
         "#]],
@@ -8898,7 +8898,7 @@ fn main() {
             ```rust
             f64
             ```
-            ___
+            ---
 
             value of literal: ` 134000000000000 (bits: 0x42DE77D399980000) `
         "#]],
@@ -8914,7 +8914,7 @@ fn main() {
             ```rust
             f64
             ```
-            ___
+            ---
 
             value of literal: ` 1523527134274733600000000 (bits: 0x44F429E9249F629B) `
         "#]],
@@ -8930,7 +8930,7 @@ fn main() {
             ```rust
             f64
             ```
-            ___
+            ---
 
             invalid literal: invalid float literal
         "#]],
@@ -8950,7 +8950,7 @@ fn main() {
             ```rust
             i32
             ```
-            ___
+            ---
 
             value of literal: ` 34325236457856836345234 (0x744C659178614489D92|0b111010001001100011001011001000101111000011000010100010010001001110110010010) `
         "#]],
@@ -8966,7 +8966,7 @@ fn main() {
             ```rust
             i32
             ```
-            ___
+            ---
 
             value of literal: ` 13412342421 (0x31F701A95|0b1100011111011100000001101010010101) `
         "#]],
@@ -8982,7 +8982,7 @@ fn main() {
             ```rust
             i32
             ```
-            ___
+            ---
 
             value of literal: ` 306328611 (0x12423423|0b10010010000100011010000100011) `
         "#]],
@@ -8998,7 +8998,7 @@ fn main() {
             ```rust
             i32
             ```
-            ___
+            ---
 
             value of literal: ` 255 (0xFF|0b11111111) `
         "#]],
@@ -9014,7 +9014,7 @@ fn main() {
             ```rust
             i32
             ```
-            ___
+            ---
 
             value of literal: ` 5349 (0x14E5|0b1010011100101) `
         "#]],
@@ -9030,7 +9030,7 @@ fn main() {
             ```rust
             i32
             ```
-            ___
+            ---
 
             invalid literal: number too large to fit in target type
         "#]],
@@ -9186,7 +9186,7 @@ fn main() {
             ```rust
             S
             ```
-            ___
+            ---
             Implements notable traits: `Future<Output = u32>`, `Iterator<Item = S>`, `Notable`"#]],
     );
 }

From 6bc1d4d2aa996918838e2e9e39290756a37b8cc0 Mon Sep 17 00:00:00 2001
From: Hmikihiro <34ttrweoewiwe28@gmail.com>
Date: Mon, 4 Aug 2025 14:38:17 +0900
Subject: [PATCH 0026/1889] remvoe add_attr edit_in_place.rs because it use
 ted.

---
 .../src/handlers/convert_bool_to_enum.rs      | 37 ++++-----
 .../src/handlers/convert_closure_to_fn.rs     |  1 +
 .../src/handlers/convert_from_to_tryfrom.rs   |  1 +
 .../src/handlers/extract_function.rs          |  1 +
 .../src/handlers/extract_module.rs            |  2 +
 .../src/handlers/extract_type_alias.rs        |  5 +-
 .../src/handlers/extract_variable.rs          |  2 +-
 .../src/handlers/generate_delegate_methods.rs |  2 +
 .../src/handlers/generate_delegate_trait.rs   | 79 +++++++++++++++----
 .../src/handlers/generate_derive.rs           | 25 ++++--
 .../src/handlers/generate_fn_type_alias.rs    |  1 +
 .../src/handlers/generate_function.rs         |  3 +-
 .../src/handlers/generate_getter_or_setter.rs |  2 +
 .../ide-assists/src/handlers/generate_impl.rs |  1 +
 .../ide-assists/src/handlers/generate_new.rs  |  1 +
 .../generate_single_field_struct_from.rs      | 10 ++-
 .../src/handlers/promote_local_to_const.rs    |  2 +-
 .../src/handlers/unmerge_imports.rs           | 10 +--
 .../crates/ide-assists/src/utils.rs           | 26 ++----
 .../crates/ide-db/src/imports/insert_use.rs   |  2 +-
 .../crates/syntax/src/ast/edit_in_place.rs    | 22 ------
 .../crates/syntax/src/ast/make.rs             | 38 +++++++--
 .../src/ast/syntax_factory/constructors.rs    | 27 +++++--
 .../crates/syntax/src/syntax_editor.rs        |  1 +
 24 files changed, 185 insertions(+), 116 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_bool_to_enum.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_bool_to_enum.rs
index f73b8c4fd0f19..c208c8bf789a0 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_bool_to_enum.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_bool_to_enum.rs
@@ -13,12 +13,7 @@ use ide_db::{
 use itertools::Itertools;
 use syntax::{
     AstNode, NodeOrToken, SyntaxKind, SyntaxNode, T,
-    ast::{
-        self, HasName,
-        edit::IndentLevel,
-        edit_in_place::{AttrsOwnerEdit, Indent},
-        make,
-    },
+    ast::{self, HasName, edit::IndentLevel, edit_in_place::Indent, make},
 };
 
 use crate::{
@@ -506,18 +501,6 @@ fn node_to_insert_before(target_node: SyntaxNode) -> SyntaxNode {
 }
 
 fn make_bool_enum(make_pub: bool) -> ast::Enum {
-    let enum_def = make::enum_(
-        if make_pub { Some(make::visibility_pub()) } else { None },
-        make::name("Bool"),
-        None,
-        None,
-        make::variant_list(vec![
-            make::variant(None, make::name("True"), None, None),
-            make::variant(None, make::name("False"), None, None),
-        ]),
-    )
-    .clone_for_update();
-
     let derive_eq = make::attr_outer(make::meta_token_tree(
         make::ext::ident_path("derive"),
         make::token_tree(
@@ -529,11 +512,19 @@ fn make_bool_enum(make_pub: bool) -> ast::Enum {
                 NodeOrToken::Token(make::tokens::ident("Eq")),
             ],
         ),
-    ))
-    .clone_for_update();
-    enum_def.add_attr(derive_eq);
-
-    enum_def
+    ));
+    make::enum_(
+        [derive_eq],
+        if make_pub { Some(make::visibility_pub()) } else { None },
+        make::name("Bool"),
+        None,
+        None,
+        make::variant_list(vec![
+            make::variant(None, make::name("True"), None, None),
+            make::variant(None, make::name("False"), None, None),
+        ]),
+    )
+    .clone_for_update()
 }
 
 #[cfg(test)]
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_closure_to_fn.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_closure_to_fn.rs
index 916bb67ebb405..5f526ec899404 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_closure_to_fn.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_closure_to_fn.rs
@@ -235,6 +235,7 @@ pub(crate) fn convert_closure_to_fn(acc: &mut Assists, ctx: &AssistContext<'_>)
                 Some(make::ret_type(make::ty(&ret_ty)))
             };
             let mut fn_ = make::fn_(
+                None,
                 None,
                 closure_name_or_default.clone(),
                 closure_type_params,
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_from_to_tryfrom.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_from_to_tryfrom.rs
index f1cc3d90b9c56..7d8b763d8b87b 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_from_to_tryfrom.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_from_to_tryfrom.rs
@@ -96,6 +96,7 @@ pub(crate) fn convert_from_to_tryfrom(acc: &mut Assists, ctx: &AssistContext<'_>
             }
 
             let error_type = ast::AssocItem::TypeAlias(make::ty_alias(
+                None,
                 "Error",
                 None,
                 None,
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_function.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_function.rs
index 890b8dd64126e..d88e3311bd7bf 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_function.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_function.rs
@@ -1641,6 +1641,7 @@ fn format_function(
     let (generic_params, where_clause) = make_generic_params_and_where_clause(ctx, fun);
 
     make::fn_(
+        None,
         None,
         fun_name,
         generic_params,
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_module.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_module.rs
index c6a6b97df8245..da91d0ac28097 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_module.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_module.rs
@@ -585,6 +585,7 @@ impl Module {
 
             if (def_out_sel || !is_item) && use_stmt_not_in_sel {
                 let use_ = make::use_(
+                    None,
                     None,
                     make::use_tree(make::join_paths(use_tree_paths), None, None, false),
                 );
@@ -599,6 +600,7 @@ impl Module {
         let super_path = make::ext::ident_path("super");
         let node_path = make::ext::ident_path(&node_syntax.to_string());
         let use_ = make::use_(
+            None,
             None,
             make::use_tree(make::join_paths(vec![super_path, node_path]), None, None, false),
         );
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_type_alias.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_type_alias.rs
index 79f22381952ae..7f93506685e18 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_type_alias.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_type_alias.rs
@@ -69,8 +69,9 @@ pub(crate) fn extract_type_alias(acc: &mut Assists, ctx: &AssistContext<'_>) ->
             edit.replace(ty.syntax(), new_ty.syntax());
 
             // Insert new alias
-            let ty_alias = make::ty_alias("Type", generic_params, None, None, Some((ty, None)))
-                .clone_for_update();
+            let ty_alias =
+                make::ty_alias(None, "Type", generic_params, None, None, Some((ty, None)))
+                    .clone_for_update();
 
             if let Some(cap) = ctx.config.snippet_cap
                 && let Some(name) = ty_alias.name()
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_variable.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_variable.rs
index c9c1969b9e023..bd88e8b09ced0 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_variable.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_variable.rs
@@ -200,7 +200,7 @@ pub(crate) fn extract_variable(acc: &mut Assists, ctx: &AssistContext<'_>) -> Op
                     }
                     ExtractionKind::Constant => {
                         let ast_ty = make.ty(&ty_string);
-                        ast::Item::Const(make.item_const(None, pat_name, ast_ty, initializer))
+                        ast::Item::Const(make.item_const(None, None, pat_name, ast_ty, initializer))
                             .into()
                     }
                     ExtractionKind::Static => {
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_delegate_methods.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_delegate_methods.rs
index 2c81e2883a34a..d8a2e038d33c2 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_delegate_methods.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_delegate_methods.rs
@@ -155,6 +155,7 @@ pub(crate) fn generate_delegate_methods(acc: &mut Assists, ctx: &AssistContext<'
                 let ret_type = method_source.ret_type();
 
                 let f = make::fn_(
+                    None,
                     vis,
                     fn_name,
                     type_params,
@@ -195,6 +196,7 @@ pub(crate) fn generate_delegate_methods(acc: &mut Assists, ctx: &AssistContext<'
                         let assoc_item_list = make::assoc_item_list(Some(vec![item]));
 
                         let impl_def = make::impl_(
+                            None,
                             ty_params,
                             ty_args,
                             make::ty_path(make::ext::ident_path(name)),
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_delegate_trait.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_delegate_trait.rs
index e96250f3c50a5..e87dde5b8e427 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_delegate_trait.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_delegate_trait.rs
@@ -20,7 +20,6 @@ use syntax::{
         HasGenericParams, HasName, HasTypeBounds, HasVisibility as astHasVisibility, Path,
         WherePred,
         edit::{self, AstNodeEdit},
-        edit_in_place::AttrsOwnerEdit,
         make,
     },
     ted::{self, Position},
@@ -266,6 +265,7 @@ fn generate_impl(
             let bound_params = bound_def.generic_param_list();
 
             let delegate = make::impl_trait(
+                None,
                 delegee.is_unsafe(db),
                 bound_params.clone(),
                 bound_params.map(|params| params.to_generic_args()),
@@ -379,6 +379,7 @@ fn generate_impl(
             let path_type = transform_impl(ctx, ast_strukt, &old_impl, &transform_args, path_type)?;
             // 3) Generate delegate trait impl
             let delegate = make::impl_trait(
+                None,
                 trait_.is_unsafe(db),
                 trait_gen_params,
                 trait_gen_args,
@@ -652,8 +653,7 @@ fn process_assoc_item(
     qual_path_ty: ast::Path,
     base_name: &str,
 ) -> Option<ast::AssocItem> {
-    let attrs = item.attrs();
-    let assoc = match item {
+    match item {
         AssocItem::Const(c) => const_assoc_item(c, qual_path_ty),
         AssocItem::Fn(f) => func_assoc_item(f, qual_path_ty, base_name),
         AssocItem::MacroCall(_) => {
@@ -662,18 +662,7 @@ fn process_assoc_item(
             None
         }
         AssocItem::TypeAlias(ta) => ty_assoc_item(ta, qual_path_ty),
-    };
-    if let Some(assoc) = &assoc {
-        attrs.for_each(|attr| {
-            assoc.add_attr(attr.clone());
-            // fix indentations
-            if let Some(tok) = attr.syntax().next_sibling_or_token() {
-                let pos = Position::after(tok);
-                ted::insert(pos, make::tokens::whitespace("    "));
-            }
-        })
     }
-    assoc
 }
 
 fn const_assoc_item(item: syntax::ast::Const, qual_path_ty: ast::Path) -> Option<AssocItem> {
@@ -687,6 +676,7 @@ fn const_assoc_item(item: syntax::ast::Const, qual_path_ty: ast::Path) -> Option
     // make::path_qualified(qual_path_ty, path_expr_segment.as_single_segment().unwrap());
     let qualified_path = qualified_path(qual_path_ty, path_expr_segment);
     let inner = make::item_const(
+        item.attrs(),
         item.visibility(),
         item.name()?,
         item.ty()?,
@@ -755,6 +745,7 @@ fn func_assoc_item(
 
     let body = make::block_expr(vec![], Some(call.into())).clone_for_update();
     let func = make::fn_(
+        item.attrs(),
         item.visibility(),
         item.name()?,
         item.generic_param_list(),
@@ -779,13 +770,14 @@ fn ty_assoc_item(item: syntax::ast::TypeAlias, qual_path_ty: Path) -> Option<Ass
     let ident = item.name()?.to_string();
 
     let alias = make::ty_alias(
+        item.attrs(),
         ident.as_str(),
         item.generic_param_list(),
         None,
         item.where_clause(),
         Some((ty, None)),
     )
-    .clone_for_update();
+    .indent(edit::IndentLevel(1));
 
     Some(AssocItem::TypeAlias(alias))
 }
@@ -1813,6 +1805,63 @@ impl T for B {
         );
     }
 
+    #[test]
+    fn test_ty_alias_attrs() {
+        check_assist(
+            generate_delegate_trait,
+            r#"
+struct A;
+
+trait T {
+    #[cfg(test)]
+    type t;
+    #[cfg(not(test))]
+    type t;
+}
+
+impl T for A {
+    #[cfg(test)]
+    type t = u32;
+    #[cfg(not(test))]
+    type t = bool;
+}
+
+struct B {
+    a$0: A,
+}
+"#,
+            r#"
+struct A;
+
+trait T {
+    #[cfg(test)]
+    type t;
+    #[cfg(not(test))]
+    type t;
+}
+
+impl T for A {
+    #[cfg(test)]
+    type t = u32;
+    #[cfg(not(test))]
+    type t = bool;
+}
+
+struct B {
+    a: A,
+}
+
+impl T for B {
+    #[cfg(test)]
+    type t = <A as T>::t;
+
+    #[cfg(not(test))]
+    type t = <A as T>::t;
+}
+"#,
+        );
+    }
+
     #[test]
     fn assoc_items_attributes_mutably_cloned() {
         check_assist(
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_derive.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_derive.rs
index 73a69c82fbcdd..06fef4af22382 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_derive.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_derive.rs
@@ -1,6 +1,8 @@
 use syntax::{
+    SyntaxKind::{ATTR, COMMENT, WHITESPACE},
     T,
-    ast::{self, AstNode, HasAttrs, edit_in_place::AttrsOwnerEdit, make},
+    ast::{self, AstNode, HasAttrs, edit::IndentLevel, make},
+    syntax_editor::{Element, Position},
 };
 
 use crate::{AssistContext, AssistId, Assists};
@@ -48,8 +50,20 @@ pub(crate) fn generate_derive(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opt
                 ))
                 .clone_for_update();
 
-                let nominal = edit.make_mut(nominal);
-                nominal.add_attr(derive.clone());
+                let mut editor = edit.make_editor(nominal.syntax());
+                let indent = IndentLevel::from_node(nominal.syntax());
+                let after_attrs_and_comments = nominal
+                    .syntax()
+                    .children_with_tokens()
+                    .find(|it| !matches!(it.kind(), WHITESPACE | COMMENT | ATTR))
+                    .map_or(Position::first_child_of(nominal.syntax()), Position::before);
+                editor.insert_all(
+                    after_attrs_and_comments,
+                    vec![
+                        derive.syntax().syntax_element(),
+                        make::tokens::whitespace(&format!("\n{indent}")).syntax_element(),
+                    ],
+                );
 
                 let delimiter = derive
                     .meta()
@@ -58,8 +72,9 @@ pub(crate) fn generate_derive(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opt
                     .expect("failed to get token tree out of Meta")
                     .r_paren_token()
                     .expect("make::attr_outer was expected to have a R_PAREN");
-
-                edit.add_tabstop_before_token(cap, delimiter);
+                let tabstop_before = edit.make_tabstop_before(cap);
+                editor.add_annotation(delimiter, tabstop_before);
+                edit.add_file_edits(ctx.vfs_file_id(), editor);
             }
             Some(_) => {
                 // Just move the cursor.
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_fn_type_alias.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_fn_type_alias.rs
index 3c327a63b0f0b..0b7eca2290f62 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_fn_type_alias.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_fn_type_alias.rs
@@ -94,6 +94,7 @@ pub(crate) fn generate_fn_type_alias(acc: &mut Assists, ctx: &AssistContext<'_>)
 
                 // Insert new alias
                 let ty_alias = make::ty_alias(
+                    None,
                     &alias_name,
                     generic_params,
                     None,
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_function.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_function.rs
index 613b32fcc1653..efdb20c1e9317 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_function.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_function.rs
@@ -189,7 +189,7 @@ fn add_func_to_accumulator(
             )));
 
             // FIXME: adt may have generic params.
-            let impl_ = make::impl_(None, None, name, None, None).clone_for_update();
+            let impl_ = make::impl_(None, None, None, name, None, None).clone_for_update();
 
             func.indent(IndentLevel(1));
             impl_.get_or_create_assoc_item_list().add_item(func.into());
@@ -365,6 +365,7 @@ impl FunctionBuilder {
             Visibility::Pub => Some(make::visibility_pub()),
         };
         let fn_def = make::fn_(
+            None,
             visibility,
             self.fn_name,
             self.generic_param_list,
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_getter_or_setter.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_getter_or_setter.rs
index 807b9194b2df7..e42d0ed1b00b0 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_getter_or_setter.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_getter_or_setter.rs
@@ -263,6 +263,7 @@ fn generate_getter_from_info(
     let body = make::block_expr([], Some(body));
 
     make::fn_(
+        None,
         strukt.visibility(),
         fn_name,
         None,
@@ -299,6 +300,7 @@ fn generate_setter_from_info(info: &AssistInfo, record_field_info: &RecordFieldI
 
     // Make the setter fn
     make::fn_(
+        None,
         strukt.visibility(),
         fn_name,
         None,
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_impl.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_impl.rs
index b38ee6f7dce8e..77eb8efc6f6af 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_impl.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_impl.rs
@@ -174,6 +174,7 @@ pub(crate) fn generate_impl_trait(acc: &mut Assists, ctx: &AssistContext<'_>) ->
 
             let make_impl_ = |body| {
                 make::impl_trait(
+                    None,
                     trait_.unsafe_token().is_some(),
                     None,
                     trait_gen_args.clone(),
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_new.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_new.rs
index 351f134612f00..ac4a54a89ef1f 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_new.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_new.rs
@@ -134,6 +134,7 @@ pub(crate) fn generate_new(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option
         let ret_type = make::ret_type(make::ty_path(make::ext::ident_path("Self")));
 
         let fn_ = make::fn_(
+            None,
             strukt.visibility(),
             make::name("new"),
             None,
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_single_field_struct_from.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_single_field_struct_from.rs
index 4e95ceb2e853e..6076d5cb5cedf 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_single_field_struct_from.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_single_field_struct_from.rs
@@ -6,13 +6,12 @@ use ide_db::{
 };
 use syntax::{
     TokenText,
-    ast::{self, AstNode, HasGenericParams, HasName, edit, edit_in_place::Indent},
+    ast::{self, AstNode, HasAttrs, HasGenericParams, HasName, edit, edit_in_place::Indent},
 };
 
 use crate::{
     AssistId,
     assist_context::{AssistContext, Assists},
-    utils::add_cfg_attrs_to,
 };
 
 // Assist: generate_single_field_struct_from
@@ -89,6 +88,7 @@ pub(crate) fn generate_single_field_struct_from(
             let body = make::block_expr([], Some(constructor));
 
             let fn_ = make::fn_(
+                None,
                 None,
                 make::name("from"),
                 None,
@@ -110,8 +110,12 @@ pub(crate) fn generate_single_field_struct_from(
             .clone_for_update();
 
             fn_.indent(1.into());
+            let cfg_attrs = strukt
+                .attrs()
+                .filter(|attr| attr.as_simple_call().is_some_and(|(name, _arg)| name == "cfg"));
 
             let impl_ = make::impl_trait(
+                cfg_attrs,
                 false,
                 None,
                 trait_gen_args,
@@ -128,8 +132,6 @@ pub(crate) fn generate_single_field_struct_from(
 
             impl_.get_or_create_assoc_item_list().add_item(fn_.into());
 
-            add_cfg_attrs_to(&strukt, &impl_);
-
             impl_.reindent_to(indent);
 
             builder.insert(strukt.syntax().text_range().end(), format!("\n\n{indent}{impl_}"));
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/promote_local_to_const.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/promote_local_to_const.rs
index 603be4d66733d..547d3686e3909 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/promote_local_to_const.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/promote_local_to_const.rs
@@ -88,7 +88,7 @@ pub(crate) fn promote_local_to_const(acc: &mut Assists, ctx: &AssistContext<'_>)
                 }
             }
 
-            let item = make.item_const(None, make.name(&name), make.ty(&ty), initializer);
+            let item = make.item_const(None, None, make.name(&name), make.ty(&ty), initializer);
 
             if let Some((cap, name)) = ctx.config.snippet_cap.zip(item.name()) {
                 let tabstop = edit.make_tabstop_before(cap);
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unmerge_imports.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unmerge_imports.rs
index c066f41ca47b7..accb5c28d6ed3 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unmerge_imports.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unmerge_imports.rs
@@ -1,9 +1,6 @@
 use syntax::{
     AstNode, SyntaxKind,
-    ast::{
-        self, HasAttrs, HasVisibility, edit::IndentLevel, edit_in_place::AttrsOwnerEdit, make,
-        syntax_factory::SyntaxFactory,
-    },
+    ast::{self, HasAttrs, HasVisibility, edit::IndentLevel, make, syntax_factory::SyntaxFactory},
     syntax_editor::{Element, Position, Removable},
 };
 
@@ -46,13 +43,10 @@ pub(crate) fn unmerge_imports(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opt
     acc.add(AssistId::refactor_rewrite("unmerge_imports"), label, target, |builder| {
         let make = SyntaxFactory::with_mappings();
         let new_use = make.use_(
+            use_.attrs(),
             use_.visibility(),
             make.use_tree(path, tree.use_tree_list(), tree.rename(), tree.star_token().is_some()),
         );
-        // Add any attributes that are present on the use tree
-        use_.attrs().for_each(|attr| {
-            new_use.add_attr(attr.clone_for_update());
-        });
 
         let mut editor = builder.make_editor(use_.syntax());
         // Remove the use tree from the current use item
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
index 91aac9cf7b608..20e0302b57d70 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
@@ -736,8 +736,11 @@ fn generate_impl_inner(
         generic_params.as_ref().map(|params| params.to_generic_args().clone_for_update());
     let ty = make::ty_path(make::ext::ident_path(&adt.name().unwrap().text()));
 
-    let impl_ = match trait_ {
+    let cfg_attrs =
+        adt.attrs().filter(|attr| attr.as_simple_call().is_some_and(|(name, _arg)| name == "cfg"));
+    match trait_ {
         Some(trait_) => make::impl_trait(
+            cfg_attrs,
             is_unsafe,
             None,
             None,
@@ -750,26 +753,9 @@ fn generate_impl_inner(
             adt.where_clause(),
             body,
         ),
-        None => make::impl_(generic_params, generic_args, ty, adt.where_clause(), body),
-    }
-    .clone_for_update();
-
-    // Copy any cfg attrs from the original adt
-    add_cfg_attrs_to(adt, &impl_);
-
-    impl_
-}
-
-pub(crate) fn add_cfg_attrs_to<T, U>(from: &T, to: &U)
-where
-    T: HasAttrs,
-    U: AttrsOwnerEdit,
-{
-    let cfg_attrs =
-        from.attrs().filter(|attr| attr.as_simple_call().is_some_and(|(name, _arg)| name == "cfg"));
-    for attr in cfg_attrs {
-        to.add_attr(attr.clone_for_update());
+        None => make::impl_(cfg_attrs, generic_params, generic_args, ty, adt.where_clause(), body),
     }
+    .clone_for_update()
 }
 
 pub(crate) fn add_method_to_adt(
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/imports/insert_use.rs b/src/tools/rust-analyzer/crates/ide-db/src/imports/insert_use.rs
index 08cd8f28608ca..b174adfd7e448 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/imports/insert_use.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/imports/insert_use.rs
@@ -194,7 +194,7 @@ fn insert_use_with_alias_option(
         use_tree = use_tree.clone_for_update();
         use_tree.wrap_in_tree_list();
     }
-    let use_item = make::use_(None, use_tree).clone_for_update();
+    let use_item = make::use_(None, None, use_tree).clone_for_update();
     for attr in
         scope.required_cfgs.iter().map(|attr| attr.syntax().clone_subtree().clone_for_update())
     {
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs
index b50ce6442432d..160f000387b3d 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs
@@ -273,28 +273,6 @@ pub trait AttrsOwnerEdit: ast::HasAttrs {
             }
         }
     }
-
-    fn add_attr(&self, attr: ast::Attr) {
-        add_attr(self.syntax(), attr);
-
-        fn add_attr(node: &SyntaxNode, attr: ast::Attr) {
-            let indent = IndentLevel::from_node(node);
-            attr.reindent_to(indent);
-
-            let after_attrs_and_comments = node
-                .children_with_tokens()
-                .find(|it| !matches!(it.kind(), WHITESPACE | COMMENT | ATTR))
-                .map_or(Position::first_child_of(node), Position::before);
-
-            ted::insert_all(
-                after_attrs_and_comments,
-                vec![
-                    attr.syntax().clone().into(),
-                    make::tokens::whitespace(&format!("\n{indent}")).into(),
-                ],
-            )
-        }
-    }
 }
 
 impl<T: ast::HasAttrs> AttrsOwnerEdit for T {}
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/make.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/make.rs
index daeb79cf081dc..c5ca609760187 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/make.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/make.rs
@@ -190,6 +190,7 @@ fn ty_from_text(text: &str) -> ast::Type {
 }
 
 pub fn ty_alias(
+    attrs: impl IntoIterator<Item = ast::Attr>,
     ident: &str,
     generic_param_list: Option<ast::GenericParamList>,
     type_param_bounds: Option<ast::TypeParam>,
@@ -200,6 +201,7 @@ pub fn ty_alias(
     let assignment_where = assignment_where.flatten();
     quote! {
         TypeAlias {
+            #(#attrs "\n")*
             [type] " "
                 Name { [IDENT ident] }
                 #generic_param_list
@@ -277,12 +279,16 @@ fn merge_where_clause(
 }
 
 pub fn impl_(
+    attrs: impl IntoIterator<Item = ast::Attr>,
     generic_params: Option<ast::GenericParamList>,
     generic_args: Option<ast::GenericArgList>,
     path_type: ast::Type,
     where_clause: Option<ast::WhereClause>,
     body: Option<ast::AssocItemList>,
 ) -> ast::Impl {
+    let attrs =
+        attrs.into_iter().fold(String::new(), |mut acc, attr| format_to_acc!(acc, "{}\n", attr));
+
     let gen_args = generic_args.map_or_else(String::new, |it| it.to_string());
 
     let gen_params = generic_params.map_or_else(String::new, |it| it.to_string());
@@ -295,10 +301,11 @@ pub fn impl_(
     };
 
     let body = body.map_or_else(|| format!("{{{body_newline}}}"), |it| it.to_string());
-    ast_from_text(&format!("impl{gen_params} {path_type}{gen_args}{where_clause}{body}"))
+    ast_from_text(&format!("{attrs}impl{gen_params} {path_type}{gen_args}{where_clause}{body}"))
 }
 
 pub fn impl_trait(
+    attrs: impl IntoIterator<Item = ast::Attr>,
     is_unsafe: bool,
     trait_gen_params: Option<ast::GenericParamList>,
     trait_gen_args: Option<ast::GenericArgList>,
@@ -311,6 +318,8 @@ pub fn impl_trait(
     ty_where_clause: Option<ast::WhereClause>,
     body: Option<ast::AssocItemList>,
 ) -> ast::Impl {
+    let attrs =
+        attrs.into_iter().fold(String::new(), |mut acc, attr| format_to_acc!(acc, "{}\n", attr));
     let is_unsafe = if is_unsafe { "unsafe " } else { "" };
 
     let trait_gen_args = trait_gen_args.map(|args| args.to_string()).unwrap_or_default();
@@ -334,7 +343,7 @@ pub fn impl_trait(
     let body = body.map_or_else(|| format!("{{{body_newline}}}"), |it| it.to_string());
 
     ast_from_text(&format!(
-        "{is_unsafe}impl{gen_params} {is_negative}{path_type}{trait_gen_args} for {ty}{type_gen_args}{where_clause}{body}"
+        "{attrs}{is_unsafe}impl{gen_params} {is_negative}{path_type}{trait_gen_args} for {ty}{type_gen_args}{where_clause}{body}"
     ))
 }
 
@@ -452,12 +461,18 @@ pub fn use_tree_list(use_trees: impl IntoIterator<Item = ast::UseTree>) -> ast::
     ast_from_text(&format!("use {{{use_trees}}};"))
 }
 
-pub fn use_(visibility: Option<ast::Visibility>, use_tree: ast::UseTree) -> ast::Use {
+pub fn use_(
+    attrs: impl IntoIterator<Item = ast::Attr>,
+    visibility: Option<ast::Visibility>,
+    use_tree: ast::UseTree,
+) -> ast::Use {
+    let attrs =
+        attrs.into_iter().fold(String::new(), |mut acc, attr| format_to_acc!(acc, "{}\n", attr));
     let visibility = match visibility {
         None => String::new(),
         Some(it) => format!("{it} "),
     };
-    ast_from_text(&format!("{visibility}use {use_tree};"))
+    ast_from_text(&format!("{attrs}{visibility}use {use_tree};"))
 }
 
 pub fn record_expr(path: ast::Path, fields: ast::RecordExprFieldList) -> ast::RecordExpr {
@@ -946,16 +961,19 @@ pub fn expr_stmt(expr: ast::Expr) -> ast::ExprStmt {
 }
 
 pub fn item_const(
+    attrs: impl IntoIterator<Item = ast::Attr>,
     visibility: Option<ast::Visibility>,
     name: ast::Name,
     ty: ast::Type,
     expr: ast::Expr,
 ) -> ast::Const {
+    let attrs =
+        attrs.into_iter().fold(String::new(), |mut acc, attr| format_to_acc!(acc, "{}\n", attr));
     let visibility = match visibility {
         None => String::new(),
         Some(it) => format!("{it} "),
     };
-    ast_from_text(&format!("{visibility}const {name}: {ty} = {expr};"))
+    ast_from_text(&format!("{attrs}{visibility}const {name}: {ty} = {expr};"))
 }
 
 pub fn item_static(
@@ -1162,6 +1180,7 @@ pub fn variant(
 }
 
 pub fn fn_(
+    attrs: impl IntoIterator<Item = ast::Attr>,
     visibility: Option<ast::Visibility>,
     fn_name: ast::Name,
     type_params: Option<ast::GenericParamList>,
@@ -1174,6 +1193,8 @@ pub fn fn_(
     is_unsafe: bool,
     is_gen: bool,
 ) -> ast::Fn {
+    let attrs =
+        attrs.into_iter().fold(String::new(), |mut acc, attr| format_to_acc!(acc, "{}\n", attr));
     let type_params = match type_params {
         Some(type_params) => format!("{type_params}"),
         None => "".into(),
@@ -1197,7 +1218,7 @@ pub fn fn_(
     let gen_literal = if is_gen { "gen " } else { "" };
 
     ast_from_text(&format!(
-        "{visibility}{const_literal}{async_literal}{gen_literal}{unsafe_literal}fn {fn_name}{type_params}{params} {ret_type}{where_clause}{body}",
+        "{attrs}{visibility}{const_literal}{async_literal}{gen_literal}{unsafe_literal}fn {fn_name}{type_params}{params} {ret_type}{where_clause}{body}",
     ))
 }
 pub fn struct_(
@@ -1217,12 +1238,15 @@ pub fn struct_(
 }
 
 pub fn enum_(
+    attrs: impl IntoIterator<Item = ast::Attr>,
     visibility: Option<ast::Visibility>,
     enum_name: ast::Name,
     generic_param_list: Option<ast::GenericParamList>,
     where_clause: Option<ast::WhereClause>,
     variant_list: ast::VariantList,
 ) -> ast::Enum {
+    let attrs =
+        attrs.into_iter().fold(String::new(), |mut acc, attr| format_to_acc!(acc, "{}\n", attr));
     let visibility = match visibility {
         None => String::new(),
         Some(it) => format!("{it} "),
@@ -1232,7 +1256,7 @@ pub fn enum_(
     let where_clause = where_clause.map(|it| format!(" {it}")).unwrap_or_default();
 
     ast_from_text(&format!(
-        "{visibility}enum {enum_name}{generic_params}{where_clause} {variant_list}"
+        "{attrs}{visibility}enum {enum_name}{generic_params}{where_clause} {variant_list}"
     ))
 }
 
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
index 738a26fed5d82..8bf27f967482b 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs
@@ -2,8 +2,8 @@
 use crate::{
     AstNode, NodeOrToken, SyntaxKind, SyntaxNode, SyntaxToken,
     ast::{
-        self, HasArgList, HasGenericArgs, HasGenericParams, HasLoopBody, HasName, HasTypeBounds,
-        HasVisibility, RangeItem, make,
+        self, HasArgList, HasAttrs, HasGenericArgs, HasGenericParams, HasLoopBody, HasName,
+        HasTypeBounds, HasVisibility, RangeItem, make,
     },
     syntax_editor::SyntaxMappingBuilder,
 };
@@ -107,8 +107,13 @@ impl SyntaxFactory {
         ast
     }
 
-    pub fn use_(&self, visibility: Option<ast::Visibility>, use_tree: ast::UseTree) -> ast::Use {
-        make::use_(visibility, use_tree).clone_for_update()
+    pub fn use_(
+        &self,
+        attrs: impl IntoIterator<Item = ast::Attr>,
+        visibility: Option<ast::Visibility>,
+        use_tree: ast::UseTree,
+    ) -> ast::Use {
+        make::use_(attrs, visibility, use_tree).clone_for_update()
     }
 
     pub fn use_tree(
@@ -840,16 +845,20 @@ impl SyntaxFactory {
 
     pub fn item_const(
         &self,
+        attrs: impl IntoIterator<Item = ast::Attr>,
         visibility: Option<ast::Visibility>,
         name: ast::Name,
         ty: ast::Type,
         expr: ast::Expr,
     ) -> ast::Const {
-        let ast = make::item_const(visibility.clone(), name.clone(), ty.clone(), expr.clone())
-            .clone_for_update();
+        let (attrs, attrs_input) = iterator_input(attrs);
+        let ast =
+            make::item_const(attrs, visibility.clone(), name.clone(), ty.clone(), expr.clone())
+                .clone_for_update();
 
         if let Some(mut mapping) = self.mappings() {
             let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+            builder.map_children(attrs_input, ast.attrs().map(|attr| attr.syntax().clone()));
             if let Some(visibility) = visibility {
                 builder.map_node(
                     visibility.syntax().clone(),
@@ -1067,6 +1076,7 @@ impl SyntaxFactory {
 
     pub fn item_enum(
         &self,
+        attrs: impl IntoIterator<Item = ast::Attr>,
         visibility: Option<ast::Visibility>,
         name: ast::Name,
         generic_param_list: Option<ast::GenericParamList>,
@@ -1074,6 +1084,7 @@ impl SyntaxFactory {
         variant_list: ast::VariantList,
     ) -> ast::Enum {
         let ast = make::enum_(
+            attrs,
             visibility.clone(),
             name.clone(),
             generic_param_list.clone(),
@@ -1182,6 +1193,7 @@ impl SyntaxFactory {
 
     pub fn fn_(
         &self,
+        attrs: impl IntoIterator<Item = ast::Attr>,
         visibility: Option<ast::Visibility>,
         fn_name: ast::Name,
         type_params: Option<ast::GenericParamList>,
@@ -1194,7 +1206,9 @@ impl SyntaxFactory {
         is_unsafe: bool,
         is_gen: bool,
     ) -> ast::Fn {
+        let (attrs, input) = iterator_input(attrs);
         let ast = make::fn_(
+            attrs,
             visibility.clone(),
             fn_name.clone(),
             type_params.clone(),
@@ -1210,6 +1224,7 @@ impl SyntaxFactory {
 
         if let Some(mut mapping) = self.mappings() {
             let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
+            builder.map_children(input, ast.attrs().map(|attr| attr.syntax().clone()));
 
             if let Some(visibility) = visibility {
                 builder.map_node(
diff --git a/src/tools/rust-analyzer/crates/syntax/src/syntax_editor.rs b/src/tools/rust-analyzer/crates/syntax/src/syntax_editor.rs
index 18f5015e9eabd..0b358878fcf23 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/syntax_editor.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/syntax_editor.rs
@@ -618,6 +618,7 @@ mod tests {
     #[test]
     fn test_replace_token_in_parent() {
         let parent_fn = make::fn_(
+            None,
             None,
             make::name("it"),
             None,

From 0ef8c6f2add02bf66108f3b80c204ad2b2a2c7ff Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Mon, 4 Aug 2025 17:41:00 +0300
Subject: [PATCH 0027/1889] Correctly goto `From` impl when on `into()` even
 when the call is inside a macro

Descend into macros first.
---
 .../crates/ide/src/goto_definition.rs         | 34 ++++++++++++++++---
 1 file changed, 30 insertions(+), 4 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide/src/goto_definition.rs b/src/tools/rust-analyzer/crates/ide/src/goto_definition.rs
index 84e41277390ff..f768d4b68f469 100644
--- a/src/tools/rust-analyzer/crates/ide/src/goto_definition.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/goto_definition.rs
@@ -83,14 +83,14 @@ pub(crate) fn goto_definition(
         return Some(RangeInfo::new(original_token.text_range(), navs));
     }
 
-    if let Some(navs) = find_definition_for_known_blanket_dual_impls(sema, &original_token) {
-        return Some(RangeInfo::new(original_token.text_range(), navs));
-    }
-
     let navs = sema
         .descend_into_macros_no_opaque(original_token.clone(), false)
         .into_iter()
         .filter_map(|token| {
+            if let Some(navs) = find_definition_for_known_blanket_dual_impls(sema, &token.value) {
+                return Some(navs);
+            }
+
             let parent = token.value.parent()?;
 
             let token_file_id = token.file_id;
@@ -3275,6 +3275,32 @@ impl From<A> for B {
     }
 }
 
+fn f() {
+    let a = A;
+    let b: B = a.into$0();
+}
+        "#,
+        );
+    }
+
+    #[test]
+    fn into_call_to_from_definition_within_macro() {
+        check(
+            r#"
+//- proc_macros: identity
+//- minicore: from
+struct A;
+
+struct B;
+
+impl From<A> for B {
+    fn from(value: A) -> Self {
+     //^^^^
+        B
+    }
+}
+
+#[proc_macros::identity]
 fn f() {
     let a = A;
     let b: B = a.into$0();

From 0e44b50dbef4c8ac2520576543fcbfff7d6d99e6 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Mon, 4 Aug 2025 22:44:55 +0800
Subject: [PATCH 0028/1889] Add if..else completions in LetStmt and ArgList

Example
===
```rust
let x = $0;
```

Old completions:

```rust
let x = if $1 {
    $0
};
```

This PR current completions:

```rust
let x = if $1 {
    $2
} else {
    $0
};
```
---
 .../ide-completion/src/completions/expr.rs    |   9 +-
 .../ide-completion/src/completions/keyword.rs | 116 ++++++++++++++++++
 .../crates/ide-completion/src/context.rs      |   1 +
 .../ide-completion/src/context/analysis.rs    |   2 +
 4 files changed, 127 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/expr.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/expr.rs
index 2133291b1de15..a84927f6e2c0f 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/expr.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/expr.rs
@@ -61,6 +61,7 @@ pub(crate) fn complete_expr_path(
         after_if_expr,
         in_condition,
         incomplete_let,
+        in_value,
         ref ref_expr_parent,
         after_amp,
         ref is_func_update,
@@ -361,10 +362,16 @@ pub(crate) fn complete_expr_path(
                     add_keyword("loop", "loop {\n    $0\n}");
                     if in_match_guard {
                         add_keyword("if", "if $0");
+                    } else if in_value {
+                        add_keyword("if", "if $1 {\n    $2\n} else {\n    $0\n}");
                     } else {
                         add_keyword("if", "if $1 {\n    $0\n}");
                     }
-                    add_keyword("if let", "if let $1 = $2 {\n    $0\n}");
+                    if in_value {
+                        add_keyword("if let", "if let $1 = $2 {\n    $3\n} else {\n    $0\n}");
+                    } else {
+                        add_keyword("if let", "if let $1 = $2 {\n    $0\n}");
+                    }
                     add_keyword("for", "for $1 in $2 {\n    $0\n}");
                     add_keyword("true", "true");
                     add_keyword("false", "false");
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/keyword.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/keyword.rs
index 64bb1fce6ba02..aea4e119f2076 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/keyword.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/keyword.rs
@@ -238,6 +238,8 @@ fn main() {
             r#"
 fn main() {
     let x = if $1 {
+    $2
+} else {
     $0
 };
     let y = 92;
@@ -335,6 +337,120 @@ fn main() {
         )
     }
 
+    #[test]
+    fn if_completion_in_parameter() {
+        check_edit(
+            "if",
+            r"
+fn main() {
+    foo($0)
+}
+",
+            r"
+fn main() {
+    foo(if $1 {
+    $2
+} else {
+    $0
+})
+}
+",
+        );
+
+        check_edit(
+            "if",
+            r"
+fn main() {
+    foo($0, 2)
+}
+",
+            r"
+fn main() {
+    foo(if $1 {
+    $2
+} else {
+    $0
+}, 2)
+}
+",
+        );
+
+        check_edit(
+            "if",
+            r"
+fn main() {
+    foo(2, $0)
+}
+",
+            r"
+fn main() {
+    foo(2, if $1 {
+    $2
+} else {
+    $0
+})
+}
+",
+        );
+
+        check_edit(
+            "if let",
+            r"
+fn main() {
+    foo(2, $0)
+}
+",
+            r"
+fn main() {
+    foo(2, if let $1 = $2 {
+    $3
+} else {
+    $0
+})
+}
+",
+        );
+    }
+
+    #[test]
+    fn if_completion_in_let_statement() {
+        check_edit(
+            "if",
+            r"
+fn main() {
+    let x = $0;
+}
+",
+            r"
+fn main() {
+    let x = if $1 {
+    $2
+} else {
+    $0
+};
+}
+",
+        );
+
+        check_edit(
+            "if let",
+            r"
+fn main() {
+    let x = $0;
+}
+",
+            r"
+fn main() {
+    let x = if let $1 = $2 {
+    $3
+} else {
+    $0
+};
+}
+",
+        );
+    }
+
     #[test]
     fn completes_let_in_block() {
         check_edit(
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context.rs
index cfd7f80d40b30..bb6b13b8fb96b 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context.rs
@@ -147,6 +147,7 @@ pub(crate) struct PathExprCtx<'db> {
     /// Whether this expression is the direct condition of an if or while expression
     pub(crate) in_condition: bool,
     pub(crate) incomplete_let: bool,
+    pub(crate) in_value: bool,
     pub(crate) ref_expr_parent: Option<ast::RefExpr>,
     pub(crate) after_amp: bool,
     /// The surrounding RecordExpression we are completing a functional update
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
index ea5fb39338b2e..59077237e7534 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
@@ -1245,6 +1245,7 @@ fn classify_name_ref<'db>(
             .parent()
             .and_then(ast::LetStmt::cast)
             .is_some_and(|it| it.semicolon_token().is_none());
+        let in_value = it.parent().and_then(Either::<ast::LetStmt, ast::ArgList>::cast).is_some();
         let impl_ = fetch_immediate_impl(sema, original_file, expr.syntax());
 
         let in_match_guard = match it.parent().and_then(ast::MatchArm::cast) {
@@ -1265,6 +1266,7 @@ fn classify_name_ref<'db>(
                 is_func_update,
                 innermost_ret_ty,
                 self_param,
+                in_value,
                 incomplete_let,
                 impl_,
                 in_match_guard,

From c91f9f094025d84f9b2e123b17309c2242607247 Mon Sep 17 00:00:00 2001
From: Hmikihiro <34ttrweoewiwe28@gmail.com>
Date: Tue, 5 Aug 2025 00:36:14 +0900
Subject: [PATCH 0029/1889] remove `ted` from
 replace_named_generic_with_impl.rs

---
 .../replace_named_generic_with_impl.rs        | 36 ++++++++++---------
 1 file changed, 19 insertions(+), 17 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_named_generic_with_impl.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_named_generic_with_impl.rs
index 3cd7b58f4ddd4..df7057835c346 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_named_generic_with_impl.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_named_generic_with_impl.rs
@@ -7,11 +7,8 @@ use ide_db::{
 };
 use syntax::{
     AstNode,
-    ast::{
-        self, HasGenericParams, HasName, HasTypeBounds, Name, NameLike, PathType,
-        make::impl_trait_type,
-    },
-    match_ast, ted,
+    ast::{self, HasGenericParams, HasName, HasTypeBounds, Name, NameLike, PathType, make},
+    match_ast,
 };
 
 use crate::{AssistContext, AssistId, Assists};
@@ -74,26 +71,31 @@ pub(crate) fn replace_named_generic_with_impl(
         "Replace named generic with impl trait",
         target,
         |edit| {
-            let type_param = edit.make_mut(type_param);
-            let fn_ = edit.make_mut(fn_);
-
-            let path_types_to_replace = path_types_to_replace
-                .into_iter()
-                .map(|param| edit.make_mut(param))
-                .collect::<Vec<_>>();
+            let mut editor = edit.make_editor(type_param.syntax());
 
             // remove trait from generic param list
             if let Some(generic_params) = fn_.generic_param_list() {
-                generic_params.remove_generic_param(ast::GenericParam::TypeParam(type_param));
-                if generic_params.generic_params().count() == 0 {
-                    ted::remove(generic_params.syntax());
+                let params: Vec<ast::GenericParam> = generic_params
+                    .clone()
+                    .generic_params()
+                    .filter(|it| it.syntax() != type_param.syntax())
+                    .collect();
+                if params.is_empty() {
+                    editor.delete(generic_params.syntax());
+                } else {
+                    let new_generic_param_list = make::generic_param_list(params);
+                    editor.replace(
+                        generic_params.syntax(),
+                        new_generic_param_list.syntax().clone_for_update(),
+                    );
                 }
             }
 
-            let new_bounds = impl_trait_type(type_bound_list);
+            let new_bounds = make::impl_trait_type(type_bound_list);
             for path_type in path_types_to_replace.iter().rev() {
-                ted::replace(path_type.syntax(), new_bounds.clone_for_update().syntax());
+                editor.replace(path_type.syntax(), new_bounds.clone_for_update().syntax());
             }
+            edit.add_file_edits(ctx.vfs_file_id(), editor);
         },
     )
 }

From fa6986ebe749bc59d569e3f75d0b5764f2601d78 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Fri, 1 Aug 2025 21:19:32 +0000
Subject: [PATCH 0030/1889] Suggest bounds in more cases, accounting for type
 parameters referenced in predicate

---
 .../src/error_reporting/traits/suggestions.rs | 77 ++++++++++++++++---
 compiler/rustc_trait_selection/src/lib.rs     |  1 +
 ...ng_goal_with_repeat_expr_anon_const.stderr |  4 -
 .../suggest-complex-bound-on-method.fixed     | 23 ++++++
 .../bound/suggest-complex-bound-on-method.rs  | 23 ++++++
 .../suggest-complex-bound-on-method.stderr    | 22 ++++++
 6 files changed, 136 insertions(+), 14 deletions(-)
 create mode 100644 tests/ui/traits/bound/suggest-complex-bound-on-method.fixed
 create mode 100644 tests/ui/traits/bound/suggest-complex-bound-on-method.rs
 create mode 100644 tests/ui/traits/bound/suggest-complex-bound-on-method.stderr

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 c182fd99b17bd..d6997c8525ef4 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -31,8 +31,8 @@ use rustc_middle::ty::print::{
 };
 use rustc_middle::ty::{
     self, AdtKind, GenericArgs, InferTy, IsSuggestable, Ty, TyCtxt, TypeFoldable, TypeFolder,
-    TypeSuperFoldable, TypeVisitableExt, TypeckResults, Upcast, suggest_arbitrary_trait_bound,
-    suggest_constraining_type_param,
+    TypeSuperFoldable, TypeSuperVisitable, TypeVisitableExt, TypeVisitor, TypeckResults, Upcast,
+    suggest_arbitrary_trait_bound, suggest_constraining_type_param,
 };
 use rustc_middle::{bug, span_bug};
 use rustc_span::def_id::LocalDefId;
@@ -262,6 +262,9 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             _ => (false, None),
         };
 
+        let mut finder = ParamFinder { .. };
+        finder.visit_binder(&trait_pred);
+
         // FIXME: Add check for trait bound that is already present, particularly `?Sized` so we
         //        don't suggest `T: Sized + ?Sized`.
         loop {
@@ -410,6 +413,26 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     }
                 }
 
+                hir::Node::TraitItem(hir::TraitItem {
+                    generics,
+                    kind: hir::TraitItemKind::Fn(..),
+                    ..
+                })
+                | hir::Node::ImplItem(hir::ImplItem {
+                    generics,
+                    trait_item_def_id: None,
+                    kind: hir::ImplItemKind::Fn(..),
+                    ..
+                }) if finder.can_suggest_bound(generics) => {
+                    // Missing generic type parameter bound.
+                    suggest_arbitrary_trait_bound(
+                        self.tcx,
+                        generics,
+                        err,
+                        trait_pred,
+                        associated_ty,
+                    );
+                }
                 hir::Node::Item(hir::Item {
                     kind:
                         hir::ItemKind::Struct(_, generics, _)
@@ -422,7 +445,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         | hir::ItemKind::Const(_, generics, _, _)
                         | hir::ItemKind::TraitAlias(_, generics, _),
                     ..
-                }) if !param_ty => {
+                }) if finder.can_suggest_bound(generics) => {
                     // Missing generic type parameter bound.
                     if suggest_arbitrary_trait_bound(
                         self.tcx,
@@ -5034,8 +5057,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         // Suggesting `T: ?Sized` is only valid in an ADT if `T` is only used in a
         // borrow. `struct S<'a, T: ?Sized>(&'a T);` is valid, `struct S<T: ?Sized>(T);`
         // is not. Look for invalid "bare" parameter uses, and suggest using indirection.
-        let mut visitor =
-            FindTypeParam { param: param.name.ident().name, invalid_spans: vec![], nested: false };
+        let mut visitor = FindTypeParam { param: param.name.ident().name, .. };
         visitor.visit_item(item);
         if visitor.invalid_spans.is_empty() {
             return false;
@@ -5198,7 +5220,7 @@ fn hint_missing_borrow<'tcx>(
 /// Used to suggest replacing associated types with an explicit type in `where` clauses.
 #[derive(Debug)]
 pub struct SelfVisitor<'v> {
-    pub paths: Vec<&'v hir::Ty<'v>>,
+    pub paths: Vec<&'v hir::Ty<'v>> = Vec::new(),
     pub name: Option<Symbol>,
 }
 
@@ -5568,7 +5590,7 @@ fn point_at_assoc_type_restriction<G: EmissionGuarantee>(
                 );
                 // Search for the associated type `Self::{name}`, get
                 // its type and suggest replacing the bound with it.
-                let mut visitor = SelfVisitor { paths: vec![], name: Some(name) };
+                let mut visitor = SelfVisitor { name: Some(name), .. };
                 visitor.visit_trait_ref(trait_ref);
                 for path in visitor.paths {
                     err.span_suggestion_verbose(
@@ -5579,7 +5601,7 @@ fn point_at_assoc_type_restriction<G: EmissionGuarantee>(
                     );
                 }
             } else {
-                let mut visitor = SelfVisitor { paths: vec![], name: None };
+                let mut visitor = SelfVisitor { name: None, .. };
                 visitor.visit_trait_ref(trait_ref);
                 let span: MultiSpan =
                     visitor.paths.iter().map(|p| p.span).collect::<Vec<Span>>().into();
@@ -5609,8 +5631,8 @@ fn get_deref_type_and_refs(mut ty: Ty<'_>) -> (Ty<'_>, Vec<hir::Mutability>) {
 /// `param: ?Sized` would be a valid constraint.
 struct FindTypeParam {
     param: rustc_span::Symbol,
-    invalid_spans: Vec<Span>,
-    nested: bool,
+    invalid_spans: Vec<Span> = Vec::new(),
+    nested: bool = false,
 }
 
 impl<'v> Visitor<'v> for FindTypeParam {
@@ -5648,3 +5670,38 @@ impl<'v> Visitor<'v> for FindTypeParam {
         }
     }
 }
+
+/// Look for type parameters in predicates. We use this to identify whether a bound is suitable in
+/// on a given item.
+struct ParamFinder {
+    params: Vec<Symbol> = Vec::new(),
+}
+
+impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for ParamFinder {
+    fn visit_ty(&mut self, t: Ty<'tcx>) -> Self::Result {
+        match t.kind() {
+            ty::Param(p) => self.params.push(p.name),
+            _ => {}
+        }
+        t.super_visit_with(self)
+    }
+}
+
+impl ParamFinder {
+    /// Whether the `hir::Generics` of the current item can suggest the evaluated bound because its
+    /// references to type parameters are present in the generics.
+    fn can_suggest_bound(&self, generics: &hir::Generics<'_>) -> bool {
+        if self.params.is_empty() {
+            // There are no references to type parameters at all, so suggesting the bound
+            // would be reasonable.
+            return true;
+        }
+        generics.params.iter().any(|p| match p.name {
+            hir::ParamName::Plain(p_name) => {
+                // All of the parameters in the bound can be referenced in the current item.
+                self.params.iter().any(|p| *p == p_name.name || *p == kw::SelfUpper)
+            }
+            _ => true,
+        })
+    }
+}
diff --git a/compiler/rustc_trait_selection/src/lib.rs b/compiler/rustc_trait_selection/src/lib.rs
index e2b22f7bab744..fc0cf8f140a70 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(default_field_values)]
 #![feature(if_let_guard)]
 #![feature(iter_intersperse)]
 #![feature(iterator_try_reduce)]
diff --git a/tests/ui/const-generics/failing_goal_with_repeat_expr_anon_const.stderr b/tests/ui/const-generics/failing_goal_with_repeat_expr_anon_const.stderr
index 12de4f1dc3003..cf5b55a0ce292 100644
--- a/tests/ui/const-generics/failing_goal_with_repeat_expr_anon_const.stderr
+++ b/tests/ui/const-generics/failing_goal_with_repeat_expr_anon_const.stderr
@@ -21,10 +21,6 @@ LL |         [0u8; std::mem::size_of::<Self::A>()] == Self::P;
    |                                               ^^ no implementation for `[u8; std::mem::size_of::<Self::A>()] == <Self as T>::A`
    |
    = help: the trait `PartialEq<<Self as T>::A>` is not implemented for `[u8; std::mem::size_of::<Self::A>()]`
-help: consider introducing a `where` clause, but there might be an alternative better way to express this requirement
-   |
-LL | pub trait T where [u8; std::mem::size_of::<Self::A>()]: PartialEq<<Self as T>::A> {
-   |             +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/traits/bound/suggest-complex-bound-on-method.fixed b/tests/ui/traits/bound/suggest-complex-bound-on-method.fixed
new file mode 100644
index 0000000000000..719835af0a9fd
--- /dev/null
+++ b/tests/ui/traits/bound/suggest-complex-bound-on-method.fixed
@@ -0,0 +1,23 @@
+//@ run-rustfix
+#![allow(dead_code)]
+struct Application;
+// https://github.com/rust-lang/rust/issues/144734
+trait Trait {
+    type Error: std::error::Error;
+
+    fn run(&self) -> Result<(), Self::Error>;
+}
+
+#[derive(Debug)]
+enum ApplicationError {
+    Quit,
+}
+
+impl Application {
+    fn thing<T: Trait>(&self, t: T) -> Result<(), ApplicationError> where ApplicationError: From<<T as Trait>::Error> {
+        t.run()?; //~ ERROR E0277
+        Ok(())
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/traits/bound/suggest-complex-bound-on-method.rs b/tests/ui/traits/bound/suggest-complex-bound-on-method.rs
new file mode 100644
index 0000000000000..39cec571242dc
--- /dev/null
+++ b/tests/ui/traits/bound/suggest-complex-bound-on-method.rs
@@ -0,0 +1,23 @@
+//@ run-rustfix
+#![allow(dead_code)]
+struct Application;
+// https://github.com/rust-lang/rust/issues/144734
+trait Trait {
+    type Error: std::error::Error;
+
+    fn run(&self) -> Result<(), Self::Error>;
+}
+
+#[derive(Debug)]
+enum ApplicationError {
+    Quit,
+}
+
+impl Application {
+    fn thing<T: Trait>(&self, t: T) -> Result<(), ApplicationError> {
+        t.run()?; //~ ERROR E0277
+        Ok(())
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/traits/bound/suggest-complex-bound-on-method.stderr b/tests/ui/traits/bound/suggest-complex-bound-on-method.stderr
new file mode 100644
index 0000000000000..ac45f04954117
--- /dev/null
+++ b/tests/ui/traits/bound/suggest-complex-bound-on-method.stderr
@@ -0,0 +1,22 @@
+error[E0277]: `?` couldn't convert the error to `ApplicationError`
+  --> $DIR/suggest-complex-bound-on-method.rs:18:16
+   |
+LL |         t.run()?;
+   |           -----^ the trait `From<<T as Trait>::Error>` is not implemented for `ApplicationError`
+   |           |
+   |           this can't be annotated with `?` because it has type `Result<_, <T as Trait>::Error>`
+   |
+note: `ApplicationError` needs to implement `From<<T as Trait>::Error>`
+  --> $DIR/suggest-complex-bound-on-method.rs:12:1
+   |
+LL | enum ApplicationError {
+   | ^^^^^^^^^^^^^^^^^^^^^
+   = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
+help: consider introducing a `where` clause, but there might be an alternative better way to express this requirement
+   |
+LL |     fn thing<T: Trait>(&self, t: T) -> Result<(), ApplicationError> where ApplicationError: From<<T as Trait>::Error> {
+   |                                                                     +++++++++++++++++++++++++++++++++++++++++++++++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.

From 67d099bf2f64715e37ee7efe1cf21c14f0d93316 Mon Sep 17 00:00:00 2001
From: Hmikihiro <34ttrweoewiwe28@gmail.com>
Date: Tue, 5 Aug 2025 01:16:39 +0900
Subject: [PATCH 0031/1889] Migrate `expand_glob_import` assist to use
 `SyntaxEditor`

---
 .../ide-assists/src/handlers/expand_glob_import.rs       | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/expand_glob_import.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/expand_glob_import.rs
index 66552dd65f567..4b6d0b37854c0 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/expand_glob_import.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/expand_glob_import.rs
@@ -9,7 +9,6 @@ use stdx::never;
 use syntax::{
     AstNode, Direction, SyntaxNode, SyntaxToken, T,
     ast::{self, Use, UseTree, VisibilityKind, make},
-    ted,
 };
 
 use crate::{
@@ -165,8 +164,6 @@ fn build_expanded_import(
     let filtered_defs =
         if reexport_public_items { refs_in_target } else { refs_in_target.used_refs(ctx) };
 
-    let use_tree = builder.make_mut(use_tree);
-
     let names_to_import = find_names_to_import(filtered_defs, imported_defs);
     let expanded = make::use_tree_list(names_to_import.iter().map(|n| {
         let path = make::ext::ident_path(
@@ -176,22 +173,24 @@ fn build_expanded_import(
     }))
     .clone_for_update();
 
+    let mut editor = builder.make_editor(use_tree.syntax());
     match use_tree.star_token() {
         Some(star) => {
             let needs_braces = use_tree.path().is_some() && names_to_import.len() != 1;
             if needs_braces {
-                ted::replace(star, expanded.syntax())
+                editor.replace(star, expanded.syntax())
             } else {
                 let without_braces = expanded
                     .syntax()
                     .children_with_tokens()
                     .filter(|child| !matches!(child.kind(), T!['{'] | T!['}']))
                     .collect();
-                ted::replace_with_many(star, without_braces)
+                editor.replace_with_many(star, without_braces)
             }
         }
         None => never!(),
     }
+    builder.add_file_edits(ctx.vfs_file_id(), editor);
 }
 
 fn get_export_visibility_kind(use_item: &Use) -> VisibilityKind {

From 069c953bdf94e9a75662157953b44e8ef7e215a2 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Tue, 5 Aug 2025 00:10:21 +0300
Subject: [PATCH 0032/1889] Allow renaming when there are multiple definitions
 (due to macros) even when some cannot rename

---
 .../rust-analyzer/crates/ide/src/rename.rs    | 124 ++++++++++--------
 1 file changed, 72 insertions(+), 52 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide/src/rename.rs b/src/tools/rust-analyzer/crates/ide/src/rename.rs
index aea4ae0fd9702..8922a8eb48580 100644
--- a/src/tools/rust-analyzer/crates/ide/src/rename.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/rename.rs
@@ -27,6 +27,27 @@ pub use ide_db::rename::RenameError;
 
 type RenameResult<T> = Result<T, RenameError>;
 
+/// This is similar to `collect::<Result<Vec<_>, _>>`, but unlike it, it succeeds if there is *any* `Ok` item.
+fn ok_if_any<T, E>(iter: impl Iterator<Item = Result<T, E>>) -> Result<Vec<T>, E> {
+    let mut err = None;
+    let oks = iter
+        .filter_map(|item| match item {
+            Ok(it) => Some(it),
+            Err(it) => {
+                err = Some(it);
+                None
+            }
+        })
+        .collect::<Vec<_>>();
+    if !oks.is_empty() {
+        Ok(oks)
+    } else if let Some(err) = err {
+        Err(err)
+    } else {
+        Ok(Vec::new())
+    }
+}
+
 /// Prepares a rename. The sole job of this function is to return the TextRange of the thing that is
 /// being targeted for a rename.
 pub(crate) fn prepare_rename(
@@ -95,58 +116,57 @@ pub(crate) fn rename(
         alias_fallback(syntax, position, &new_name.display(db, edition).to_string());
 
     let ops: RenameResult<Vec<SourceChange>> = match alias_fallback {
-        Some(_) => defs
-            // FIXME: This can use the `ide_db::rename_reference` (or def.rename) method once we can
-            // properly find "direct" usages/references.
-            .map(|(.., def, new_name, _)| {
-                match kind {
-                    IdentifierKind::Ident => (),
-                    IdentifierKind::Lifetime => {
-                        bail!("Cannot alias reference to a lifetime identifier")
-                    }
-                    IdentifierKind::Underscore => bail!("Cannot alias reference to `_`"),
-                    IdentifierKind::LowercaseSelf => {
-                        bail!("Cannot rename alias reference to `self`")
-                    }
-                };
-                let mut usages = def.usages(&sema).all();
-
-                // FIXME: hack - removes the usage that triggered this rename operation.
-                match usages.references.get_mut(&file_id).and_then(|refs| {
-                    refs.iter()
-                        .position(|ref_| ref_.range.contains_inclusive(position.offset))
-                        .map(|idx| refs.remove(idx))
-                }) {
-                    Some(_) => (),
-                    None => never!(),
-                };
-
-                let mut source_change = SourceChange::default();
-                source_change.extend(usages.references.get_mut(&file_id).iter().map(|refs| {
-                    (
-                        position.file_id,
-                        source_edit_from_references(db, refs, def, &new_name, edition),
-                    )
-                }));
-
-                Ok(source_change)
-            })
-            .collect(),
-        None => defs
-            .map(|(.., def, new_name, rename_def)| {
-                if let Definition::Local(local) = def {
-                    if let Some(self_param) = local.as_self_param(sema.db) {
-                        cov_mark::hit!(rename_self_to_param);
-                        return rename_self_to_param(&sema, local, self_param, &new_name, kind);
-                    }
-                    if kind == IdentifierKind::LowercaseSelf {
-                        cov_mark::hit!(rename_to_self);
-                        return rename_to_self(&sema, local);
-                    }
+        Some(_) => ok_if_any(
+            defs
+                // FIXME: This can use the `ide_db::rename_reference` (or def.rename) method once we can
+                // properly find "direct" usages/references.
+                .map(|(.., def, new_name, _)| {
+                    match kind {
+                        IdentifierKind::Ident => (),
+                        IdentifierKind::Lifetime => {
+                            bail!("Cannot alias reference to a lifetime identifier")
+                        }
+                        IdentifierKind::Underscore => bail!("Cannot alias reference to `_`"),
+                        IdentifierKind::LowercaseSelf => {
+                            bail!("Cannot rename alias reference to `self`")
+                        }
+                    };
+                    let mut usages = def.usages(&sema).all();
+
+                    // FIXME: hack - removes the usage that triggered this rename operation.
+                    match usages.references.get_mut(&file_id).and_then(|refs| {
+                        refs.iter()
+                            .position(|ref_| ref_.range.contains_inclusive(position.offset))
+                            .map(|idx| refs.remove(idx))
+                    }) {
+                        Some(_) => (),
+                        None => never!(),
+                    };
+
+                    let mut source_change = SourceChange::default();
+                    source_change.extend(usages.references.get_mut(&file_id).iter().map(|refs| {
+                        (
+                            position.file_id,
+                            source_edit_from_references(db, refs, def, &new_name, edition),
+                        )
+                    }));
+
+                    Ok(source_change)
+                }),
+        ),
+        None => ok_if_any(defs.map(|(.., def, new_name, rename_def)| {
+            if let Definition::Local(local) = def {
+                if let Some(self_param) = local.as_self_param(sema.db) {
+                    cov_mark::hit!(rename_self_to_param);
+                    return rename_self_to_param(&sema, local, self_param, &new_name, kind);
                 }
-                def.rename(&sema, new_name.as_str(), rename_def)
-            })
-            .collect(),
+                if kind == IdentifierKind::LowercaseSelf {
+                    cov_mark::hit!(rename_to_self);
+                    return rename_to_self(&sema, local);
+                }
+            }
+            def.rename(&sema, new_name.as_str(), rename_def)
+        })),
     };
 
     ops?.into_iter()
@@ -320,7 +340,7 @@ fn find_definitions(
             })
         });
 
-    let res: RenameResult<Vec<_>> = symbols.filter_map(Result::transpose).collect();
+    let res: RenameResult<Vec<_>> = ok_if_any(symbols.filter_map(Result::transpose));
     match res {
         Ok(v) => {
             // remove duplicates, comparing `Definition`s

From d064aca3c4bb3a5b0e14b267bd859864257f2e6e Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Tue, 5 Aug 2025 01:04:21 +0300
Subject: [PATCH 0033/1889] Do not remove the original token when descending
 into derives

This caused rename to remove both, because it couldn't rename the derive-expanded one.

I spent some time trying to create a test for this, before giving up. But I checked manually that this works.
---
 .../rust-analyzer/crates/hir/src/semantics.rs | 20 +++++++++----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir/src/semantics.rs b/src/tools/rust-analyzer/crates/hir/src/semantics.rs
index d207305b4c61f..05f06f97fdc26 100644
--- a/src/tools/rust-analyzer/crates/hir/src/semantics.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/semantics.rs
@@ -1241,29 +1241,27 @@ impl<'db> SemanticsImpl<'db> {
                                         adt,
                                     ))
                                 })?;
-                            let mut res = None;
                             for (_, derive_attr, derives) in derives {
                                 // as there may be multiple derives registering the same helper
                                 // name, we gotta make sure to call this for all of them!
                                 // FIXME: We need to call `f` for all of them as well though!
-                                res = res.or(process_expansion_for_token(
-                                    ctx,
-                                    &mut stack,
-                                    derive_attr,
-                                ));
+                                process_expansion_for_token(ctx, &mut stack, derive_attr);
                                 for derive in derives.into_iter().flatten() {
-                                    res = res
-                                        .or(process_expansion_for_token(ctx, &mut stack, derive));
+                                    process_expansion_for_token(ctx, &mut stack, derive);
                                 }
                             }
                             // remove all tokens that are within the derives expansion
                             filter_duplicates(tokens, adt.syntax().text_range());
-                            Some(res)
+                            Some(())
                         });
                         // if we found derives, we can early exit. There is no way we can be in any
                         // macro call at this point given we are not in a token tree
-                        if let Some(res) = res {
-                            return res;
+                        if let Some(()) = res {
+                            // Note: derives do not remap the original token. Furthermore, we want
+                            // the original token to be before the derives in the list, because if they
+                            // upmap to the same token and we deduplicate them (e.g. in rename), we
+                            // want the original token to remain, not the derive.
+                            return None;
                         }
                     }
                     // Then check for token trees, that means we are either in a function-like macro or

From a0ca79e2eff61e4aa5d9d31f7d7e008c6587ba5d Mon Sep 17 00:00:00 2001
From: Lukas Wirth <me@lukaswirth.dev>
Date: Tue, 5 Aug 2025 10:45:54 +0200
Subject: [PATCH 0034/1889] Slim down compile time artifact progress reports

---
 .../crates/project-model/src/build_dependencies.rs        | 8 ++------
 .../rust-analyzer/crates/rust-analyzer/src/main_loop.rs   | 2 +-
 2 files changed, 3 insertions(+), 7 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/project-model/src/build_dependencies.rs b/src/tools/rust-analyzer/crates/project-model/src/build_dependencies.rs
index 5bea74bed7ed2..203173c11be40 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/build_dependencies.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/build_dependencies.rs
@@ -347,9 +347,7 @@ impl WorkspaceBuildScripts {
                 match message {
                     Message::BuildScriptExecuted(mut message) => {
                         with_output_for(&message.package_id.repr, &mut |name, data| {
-                            progress(format!(
-                                "building compile-time-deps: build script {name} run"
-                            ));
+                            progress(format!("build script {name} run"));
                             let cfgs = {
                                 let mut acc = Vec::new();
                                 for cfg in &message.cfgs {
@@ -380,9 +378,7 @@ impl WorkspaceBuildScripts {
                     }
                     Message::CompilerArtifact(message) => {
                         with_output_for(&message.package_id.repr, &mut |name, data| {
-                            progress(format!(
-                                "building compile-time-deps: proc-macro {name} built"
-                            ));
+                            progress(format!("proc-macro {name} built"));
                             if data.proc_macro_dylib_path == ProcMacroDylibPath::NotBuilt {
                                 data.proc_macro_dylib_path = ProcMacroDylibPath::NotProcMacro;
                             }
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs
index 61c758d5e86e1..f5932d8cff026 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs
@@ -812,7 +812,7 @@ impl GlobalState {
                 };
 
                 if let Some(state) = state {
-                    self.report_progress("Building build-artifacts", state, msg, None, None);
+                    self.report_progress("Building compile-time-deps", state, msg, None, None);
                 }
             }
             Task::LoadProcMacros(progress) => {

From b24866e619e83d1dae63ef1c2e16a91cc8e9c260 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Tue, 5 Aug 2025 20:54:38 +0800
Subject: [PATCH 0035/1889] Change prev whitespace to prev trivia

---
 .../crates/ide-completion/src/context/analysis.rs           | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
index 67fc79e8032c1..6c2edc3849982 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
@@ -562,7 +562,7 @@ fn expected_type_and_name<'db>(
     token: &SyntaxToken,
     name_like: &ast::NameLike,
 ) -> (Option<Type<'db>>, Option<NameOrNameRef>) {
-    let token = prev_assign_token_at_whitespace(token.clone());
+    let token = prev_assign_token_at_trivia(token.clone());
     let mut node = match token.parent() {
         Some(it) => it,
         None => return (None, None),
@@ -1883,8 +1883,8 @@ fn next_non_trivia_sibling(ele: SyntaxElement) -> Option<SyntaxElement> {
     None
 }
 
-fn prev_assign_token_at_whitespace(mut token: SyntaxToken) -> SyntaxToken {
-    while token.kind() == SyntaxKind::WHITESPACE
+fn prev_assign_token_at_trivia(mut token: SyntaxToken) -> SyntaxToken {
+    while token.kind().is_trivia()
         && let Some(prev) = token.prev_token()
         && let T![=]
         | T![+=]

From 6a20b6d0221e4a311d61ad4f39827d6c30dca48f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?vin=C3=ADcius=20x?= <viniciusximenespm@gmail.com>
Date: Mon, 4 Aug 2025 13:13:07 -0300
Subject: [PATCH 0036/1889] fix external docs for exported macros

add test
---
 .../rust-analyzer/crates/ide/src/doc_links.rs |  3 ++-
 .../crates/ide/src/doc_links/tests.rs         | 24 +++++++++++++++++++
 2 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/ide/src/doc_links.rs b/src/tools/rust-analyzer/crates/ide/src/doc_links.rs
index a5d9a10d2e5fe..d47cc65079384 100644
--- a/src/tools/rust-analyzer/crates/ide/src/doc_links.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/doc_links.rs
@@ -390,7 +390,8 @@ fn get_doc_links(
 
     let (mut web_url, mut local_url) = get_doc_base_urls(db, target, target_dir, sysroot);
 
-    if let Some(path) = mod_path_of_def(db, target) {
+    let append_mod = !matches!(def, Definition::Macro(m) if m.is_macro_export(db));
+    if append_mod && let Some(path) = mod_path_of_def(db, target) {
         web_url = join_url(web_url, &path);
         local_url = join_url(local_url, &path);
     }
diff --git a/src/tools/rust-analyzer/crates/ide/src/doc_links/tests.rs b/src/tools/rust-analyzer/crates/ide/src/doc_links/tests.rs
index 6af156fa668f5..c2f08f8ca2e6b 100644
--- a/src/tools/rust-analyzer/crates/ide/src/doc_links/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/doc_links/tests.rs
@@ -414,6 +414,30 @@ fn foo() {
     )
 }
 
+#[test]
+fn external_docs_macro_export() {
+    check_external_docs(
+        r#"
+//- /lib.rs crate:foo
+pub mod inner {
+    #[macro_export]
+    macro_rules! my_macro {
+        () => {};
+    }
+}
+
+//- /main.rs crate:bar deps:foo
+fn main() {
+    foo::my_m$0acro!();
+}
+        "#,
+        Some("/home/user/project"),
+        Some(expect![[r#"https://docs.rs/foo/*/foo/macro.my_macro.html"#]]),
+        Some(expect![[r#"file:///home/user/project/doc/foo/macro.my_macro.html"#]]),
+        Some("/sysroot"),
+    );
+}
+
 #[test]
 fn doc_links_items_simple() {
     check_doc_links(

From 0aa105740c1f9341a816e7f34ec94a4855f6158a Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Fri, 1 Aug 2025 17:37:33 +0800
Subject: [PATCH 0037/1889] Add remove simple dbg stmt for remove_dbg

Remove only contain literals dbg statement

```rust
fn foo() {
    let n = 2;
    $0dbg!(3);
    dbg!(2.6);
    dbg!(1, 2.5);
    dbg!('x');
    dbg!(&n);
    dbg!(n);
    // needless comment
    dbg!("foo");$0
}
```
->
```rust
fn foo() {
    // needless comment
}
```
Old:
```rust
fn foo() {
    3;
    2.6;
    (1, 2.5);
    'x';
    &n;
    n;
    // needless comment
    "foo";
}
```
---
 .../ide-assists/src/handlers/remove_dbg.rs    | 50 +++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/remove_dbg.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/remove_dbg.rs
index 9356d02706c93..414f6746d4404 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/remove_dbg.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/remove_dbg.rs
@@ -112,6 +112,16 @@ fn compute_dbg_replacement(
                 }
             }
         }
+        // dbg!(2, 'x', &x, x, ...);
+        exprs if ast::ExprStmt::can_cast(parent.kind()) && exprs.iter().all(pure_expr) => {
+            let mut replace = vec![parent.clone().into()];
+            if let Some(prev_sibling) = parent.prev_sibling_or_token()
+                && prev_sibling.kind() == syntax::SyntaxKind::WHITESPACE
+            {
+                replace.push(prev_sibling);
+            }
+            (replace, None)
+        }
         // dbg!(expr0)
         [expr] => {
             // dbg!(expr, &parent);
@@ -163,6 +173,20 @@ fn compute_dbg_replacement(
     })
 }
 
+fn pure_expr(expr: &ast::Expr) -> bool {
+    match_ast! {
+        match (expr.syntax()) {
+            ast::Literal(_) => true,
+            ast::RefExpr(it) => {
+                matches!(it.expr(), Some(ast::Expr::PathExpr(p))
+                    if p.path().and_then(|p| p.as_single_name_ref()).is_some())
+            },
+            ast::PathExpr(it) => it.path().and_then(|it| it.as_single_name_ref()).is_some(),
+            _ => false,
+        }
+    }
+}
+
 fn replace_nested_dbgs(expanded: ast::Expr) -> ast::Expr {
     if let ast::Expr::MacroExpr(mac) = &expanded {
         // Special-case when `expanded` itself is `dbg!()` since we cannot replace the whole tree
@@ -231,6 +255,32 @@ mod tests {
         check("dbg!{$01 + 1}", "1 + 1");
     }
 
+    #[test]
+    fn test_remove_simple_dbg_statement() {
+        check_assist(
+            remove_dbg,
+            r#"
+fn foo() {
+    let n = 2;
+    $0dbg!(3);
+    dbg!(2.6);
+    dbg!(1, 2.5);
+    dbg!('x');
+    dbg!(&n);
+    dbg!(n);
+    // needless comment
+    dbg!("foo");$0
+}
+"#,
+            r#"
+fn foo() {
+    let n = 2;
+    // needless comment
+}
+"#,
+        );
+    }
+
     #[test]
     fn test_remove_dbg_not_applicable() {
         check_assist_not_applicable(remove_dbg, "fn main() {$0vec![1, 2, 3]}");

From d339009cbfc59f04be15a9ca6c8f2d9ff98aa0f7 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukas@zed.dev>
Date: Wed, 6 Aug 2025 17:30:18 +0200
Subject: [PATCH 0038/1889] Report the incorrect payload when failing to
 deserialize lsp messages

---
 src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs       | 4 ++--
 .../rust-analyzer/crates/ide/src/inlay_hints/param_name.rs  | 6 +++++-
 src/tools/rust-analyzer/lib/lsp-server/src/msg.rs           | 2 +-
 3 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs b/src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs
index 7a8514c47af95..8c2a2f6f72f5e 100644
--- a/src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs
@@ -228,9 +228,9 @@ fn hints(
                 chaining::hints(hints, famous_defs, config, display_target, &expr);
                 adjustment::hints(hints, famous_defs, config, display_target, &expr);
                 match expr {
-                    ast::Expr::CallExpr(it) => param_name::hints(hints, famous_defs, config, ast::Expr::from(it)),
+                    ast::Expr::CallExpr(it) => param_name::hints(hints, famous_defs, config, file_id, ast::Expr::from(it)),
                     ast::Expr::MethodCallExpr(it) => {
-                        param_name::hints(hints, famous_defs, config, ast::Expr::from(it))
+                        param_name::hints(hints, famous_defs, config, file_id, ast::Expr::from(it))
                     }
                     ast::Expr::ClosureExpr(it) => {
                         closure_captures::hints(hints, famous_defs, config, it.clone());
diff --git a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/param_name.rs b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/param_name.rs
index ec0a4c46c7fec..754707784055a 100644
--- a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/param_name.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/param_name.rs
@@ -7,7 +7,7 @@
 use std::iter::zip;
 
 use either::Either;
-use hir::Semantics;
+use hir::{EditionedFileId, Semantics};
 use ide_db::{RootDatabase, famous_defs::FamousDefs};
 
 use stdx::to_lower_snake_case;
@@ -19,6 +19,7 @@ pub(super) fn hints(
     acc: &mut Vec<InlayHint>,
     FamousDefs(sema, krate): &FamousDefs<'_, '_>,
     config: &InlayHintsConfig,
+    file_id: EditionedFileId,
     expr: ast::Expr,
 ) -> Option<()> {
     if !config.parameter_hints {
@@ -39,6 +40,9 @@ pub(super) fn hints(
         .filter_map(|(p, arg)| {
             // Only annotate hints for expressions that exist in the original file
             let range = sema.original_range_opt(arg.syntax())?;
+            if range.file_id != file_id {
+                return None;
+            }
             let param_name = p.name(sema.db)?;
             Some((p, param_name, arg, range))
         })
diff --git a/src/tools/rust-analyzer/lib/lsp-server/src/msg.rs b/src/tools/rust-analyzer/lib/lsp-server/src/msg.rs
index 399d674e41d25..b20337fdbfff0 100644
--- a/src/tools/rust-analyzer/lib/lsp-server/src/msg.rs
+++ b/src/tools/rust-analyzer/lib/lsp-server/src/msg.rs
@@ -175,7 +175,7 @@ impl Message {
         let msg = match serde_json::from_str(&text) {
             Ok(msg) => msg,
             Err(e) => {
-                return Err(invalid_data!("malformed LSP payload: {:?}", e));
+                return Err(invalid_data!("malformed LSP payload `{e:?}`: {text:?}"));
             }
         };
 

From 51c6272baee4e60a525959c2fc9b96103ad5de74 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukas@zed.dev>
Date: Wed, 6 Aug 2025 17:46:39 +0200
Subject: [PATCH 0039/1889] Fix non-lsp compliant `Response` definition

---
 src/tools/rust-analyzer/Cargo.lock            |  8 ++--
 src/tools/rust-analyzer/Cargo.toml            | 38 +++++++++----------
 .../rust-analyzer/lib/lsp-server/Cargo.toml   |  6 +--
 .../rust-analyzer/lib/lsp-server/src/msg.rs   |  6 +--
 4 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/src/tools/rust-analyzer/Cargo.lock b/src/tools/rust-analyzer/Cargo.lock
index 5a29379ba4818..80a311a74abe4 100644
--- a/src/tools/rust-analyzer/Cargo.lock
+++ b/src/tools/rust-analyzer/Cargo.lock
@@ -1294,7 +1294,7 @@ checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
 
 [[package]]
 name = "lsp-server"
-version = "0.7.8"
+version = "0.7.9"
 dependencies = [
  "anyhow",
  "crossbeam-channel",
@@ -1310,9 +1310,9 @@ dependencies = [
 
 [[package]]
 name = "lsp-server"
-version = "0.7.8"
+version = "0.7.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9462c4dc73e17f971ec1f171d44bfffb72e65a130117233388a0ebc7ec5656f9"
+checksum = "7d6ada348dbc2703cbe7637b2dda05cff84d3da2819c24abcb305dd613e0ba2e"
 dependencies = [
  "crossbeam-channel",
  "log",
@@ -2007,7 +2007,7 @@ dependencies = [
  "intern",
  "itertools 0.14.0",
  "load-cargo",
- "lsp-server 0.7.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lsp-server 0.7.9 (registry+https://github.com/rust-lang/crates.io-index)",
  "lsp-types",
  "memchr",
  "mimalloc",
diff --git a/src/tools/rust-analyzer/Cargo.toml b/src/tools/rust-analyzer/Cargo.toml
index e7cf0212bf2a8..01a13a39f7b40 100644
--- a/src/tools/rust-analyzer/Cargo.toml
+++ b/src/tools/rust-analyzer/Cargo.toml
@@ -100,7 +100,7 @@ ra-ap-rustc_pattern_analysis = { version = "0.123", default-features = false }
 # in-tree crates that are published separately and follow semver. See lib/README.md
 line-index = { version = "0.1.2" }
 la-arena = { version = "0.3.1" }
-lsp-server = { version = "0.7.8" }
+lsp-server = { version = "0.7.9" }
 
 # non-local crates
 anyhow = "1.0.98"
@@ -125,11 +125,11 @@ memmap2 = "0.9.5"
 nohash-hasher = "0.2.0"
 oorandom = "11.1.5"
 object = { version = "0.36.7", default-features = false, features = [
-  "std",
-  "read_core",
-  "elf",
-  "macho",
-  "pe",
+    "std",
+    "read_core",
+    "elf",
+    "macho",
+    "pe",
 ] }
 process-wrap = { version = "8.2.1", features = ["std"] }
 pulldown-cmark-to-cmark = "10.0.4"
@@ -139,9 +139,9 @@ rowan = "=0.15.15"
 # Ideally we'd not enable the macros feature but unfortunately the `tracked` attribute does not work
 # on impls without it
 salsa = { version = "0.23.0", default-features = true, features = [
-  "rayon",
-  "salsa_unstable",
-  "macros",
+    "rayon",
+    "salsa_unstable",
+    "macros",
 ] }
 salsa-macros = "0.23.0"
 semver = "1.0.26"
@@ -151,9 +151,9 @@ serde_json = "1.0.140"
 rustc-hash = "2.1.1"
 rustc-literal-escaper = "0.0.4"
 smallvec = { version = "1.15.1", features = [
-  "const_new",
-  "union",
-  "const_generics",
+    "const_new",
+    "union",
+    "const_generics",
 ] }
 smol_str = "0.3.2"
 temp-dir = "0.1.16"
@@ -161,12 +161,12 @@ text-size = "1.1.1"
 tracing = "0.1.41"
 tracing-tree = "0.4.0"
 tracing-subscriber = { version = "0.3.19", default-features = false, features = [
-  "registry",
-  "fmt",
-  "local-time",
-  "std",
-  "time",
-  "tracing-log",
+    "registry",
+    "fmt",
+    "local-time",
+    "std",
+    "time",
+    "tracing-log",
 ] }
 triomphe = { version = "0.1.14", default-features = false, features = ["std"] }
 url = "2.5.4"
@@ -176,7 +176,7 @@ xshell = "0.2.7"
 dashmap = { version = "=6.1.0", features = ["raw-api", "inline"] }
 # We need to freeze the version of the crate, as it needs to match with dashmap
 hashbrown = { version = "0.14.*", features = [
-  "inline-more",
+    "inline-more",
 ], default-features = false }
 
 [workspace.lints.rust]
diff --git a/src/tools/rust-analyzer/lib/lsp-server/Cargo.toml b/src/tools/rust-analyzer/lib/lsp-server/Cargo.toml
index 1fc1da50a0a03..f56a0de616376 100644
--- a/src/tools/rust-analyzer/lib/lsp-server/Cargo.toml
+++ b/src/tools/rust-analyzer/lib/lsp-server/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "lsp-server"
-version = "0.7.8"
+version = "0.7.9"
 description = "Generic LSP server scaffold."
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/rust-lang/rust-analyzer/tree/master/lib/lsp-server"
@@ -16,9 +16,9 @@ crossbeam-channel.workspace = true
 [dev-dependencies]
 lsp-types = "=0.95"
 ctrlc = "3.4.7"
-anyhow.workspace     = true
+anyhow.workspace = true
 rustc-hash.workspace = true
-toolchain.workspace  = true
+toolchain.workspace = true
 
 [lints]
 workspace = true
diff --git a/src/tools/rust-analyzer/lib/lsp-server/src/msg.rs b/src/tools/rust-analyzer/lib/lsp-server/src/msg.rs
index 399d674e41d25..0b8f8da4c7d07 100644
--- a/src/tools/rust-analyzer/lib/lsp-server/src/msg.rs
+++ b/src/tools/rust-analyzer/lib/lsp-server/src/msg.rs
@@ -84,9 +84,9 @@ pub struct Response {
     // request id. We fail deserialization in that case, so we just
     // make this field mandatory.
     pub id: RequestId,
-    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none", default)]
     pub result: Option<serde_json::Value>,
-    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none", default)]
     pub error: Option<ResponseError>,
 }
 
@@ -94,7 +94,7 @@ pub struct Response {
 pub struct ResponseError {
     pub code: i32,
     pub message: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none", default)]
     pub data: Option<serde_json::Value>,
 }
 

From 92b8797a0968de124d120a77252b6df4939a1fce Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 6 Aug 2025 17:11:37 +0000
Subject: [PATCH 0040/1889] Bump tmp from 0.2.3 to 0.2.4 in /editors/code

Bumps [tmp](https://github.com/raszi/node-tmp) from 0.2.3 to 0.2.4.
- [Changelog](https://github.com/raszi/node-tmp/blob/master/CHANGELOG.md)
- [Commits](https://github.com/raszi/node-tmp/compare/v0.2.3...v0.2.4)

---
updated-dependencies:
- dependency-name: tmp
  dependency-version: 0.2.4
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 src/tools/rust-analyzer/editors/code/package-lock.json | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/tools/rust-analyzer/editors/code/package-lock.json b/src/tools/rust-analyzer/editors/code/package-lock.json
index 534c24be52e8d..1dc11ee4e4b81 100644
--- a/src/tools/rust-analyzer/editors/code/package-lock.json
+++ b/src/tools/rust-analyzer/editors/code/package-lock.json
@@ -5588,9 +5588,9 @@
             }
         },
         "node_modules/tmp": {
-            "version": "0.2.3",
-            "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.3.tgz",
-            "integrity": "sha512-nZD7m9iCPC5g0pYmcaxogYKggSfLsdxl8of3Q/oIbqCqLLIO9IAF0GWjX1z9NZRHPiXv8Wex4yDCaZsgEw0Y8w==",
+            "version": "0.2.4",
+            "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.4.tgz",
+            "integrity": "sha512-UdiSoX6ypifLmrfQ/XfiawN6hkjSBpCjhKxxZcWlUUmoXLaCKQU0bx4HF/tdDK2uzRuchf1txGvrWBzYREssoQ==",
             "dev": true,
             "license": "MIT",
             "engines": {

From 95440527af50ed95e1c4f9fcf7b8a5ebf7a992a7 Mon Sep 17 00:00:00 2001
From: Hmikihiro <34ttrweoewiwe28@gmail.com>
Date: Sun, 3 Aug 2025 23:32:35 +0900
Subject: [PATCH 0041/1889] In extract_module.rs, generate ast::Module instead
 of String

---
 .../src/handlers/extract_module.rs            | 175 +++++++++++-------
 .../crates/syntax/src/ast/make.rs             |  17 ++
 2 files changed, 126 insertions(+), 66 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_module.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_module.rs
index da91d0ac28097..e783b8693456c 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_module.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_module.rs
@@ -1,6 +1,5 @@
-use std::iter;
+use std::ops::RangeInclusive;
 
-use either::Either;
 use hir::{HasSource, ModuleSource};
 use ide_db::{
     FileId, FxHashMap, FxHashSet,
@@ -82,7 +81,15 @@ pub(crate) fn extract_module(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opti
         curr_parent_module = ast::Module::cast(mod_syn_opt);
     }
 
-    let mut module = extract_target(&node, ctx.selection_trimmed())?;
+    let selection_range = ctx.selection_trimmed();
+    let (mut module, module_text_range) = if let Some(item) = ast::Item::cast(node.clone()) {
+        let module = extract_single_target(&item);
+        (module, node.text_range())
+    } else {
+        let (module, range) = extract_child_target(&node, selection_range)?;
+        let module_text_range = range.start().text_range().cover(range.end().text_range());
+        (module, module_text_range)
+    };
     if module.body_items.is_empty() {
         return None;
     }
@@ -92,7 +99,7 @@ pub(crate) fn extract_module(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opti
     acc.add(
         AssistId::refactor_extract("extract_module"),
         "Extract Module",
-        module.text_range,
+        module_text_range,
         |builder| {
             //This takes place in three steps:
             //
@@ -110,17 +117,17 @@ pub(crate) fn extract_module(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opti
             //for change_visibility and usages for first point mentioned above in the process
 
             let (usages_to_be_processed, record_fields, use_stmts_to_be_inserted) =
-                module.get_usages_and_record_fields(ctx);
+                module.get_usages_and_record_fields(ctx, module_text_range);
 
             builder.edit_file(ctx.vfs_file_id());
             use_stmts_to_be_inserted.into_iter().for_each(|(_, use_stmt)| {
                 builder.insert(ctx.selection_trimmed().end(), format!("\n{use_stmt}"));
             });
 
-            let import_paths_to_be_removed = module.resolve_imports(curr_parent_module, ctx);
+            let import_items = module.resolve_imports(curr_parent_module, ctx);
             module.change_visibility(record_fields);
 
-            let module_def = generate_module_def(&impl_parent, &mut module, old_item_indent);
+            let module_def = generate_module_def(&impl_parent, module, old_item_indent).to_string();
 
             let mut usages_to_be_processed_for_cur_file = vec![];
             for (file_id, usages) in usages_to_be_processed {
@@ -157,15 +164,12 @@ pub(crate) fn extract_module(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opti
 
                 builder.insert(impl_.syntax().text_range().end(), format!("\n\n{module_def}"));
             } else {
-                for import_path_text_range in import_paths_to_be_removed {
-                    if module.text_range.intersect(import_path_text_range).is_some() {
-                        module.text_range = module.text_range.cover(import_path_text_range);
-                    } else {
-                        builder.delete(import_path_text_range);
+                for import_item in import_items {
+                    if !module_text_range.contains_range(import_item) {
+                        builder.delete(import_item);
                     }
                 }
-
-                builder.replace(module.text_range, module_def)
+                builder.replace(module_text_range, module_def)
             }
         },
     )
@@ -173,38 +177,50 @@ pub(crate) fn extract_module(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opti
 
 fn generate_module_def(
     parent_impl: &Option<ast::Impl>,
-    module: &mut Module,
+    module: Module,
     old_indent: IndentLevel,
-) -> String {
-    let (items_to_be_processed, new_item_indent) = if parent_impl.is_some() {
-        (Either::Left(module.body_items.iter()), old_indent + 2)
+) -> ast::Module {
+    let Module { name, body_items, use_items } = module;
+    let items = if let Some(self_ty) = parent_impl.as_ref().and_then(|imp| imp.self_ty()) {
+        let assoc_items = body_items
+            .into_iter()
+            .map(|item| item.syntax().clone())
+            .filter_map(ast::AssocItem::cast)
+            .map(|it| it.indent(IndentLevel(1)))
+            .collect_vec();
+        let assoc_item_list = make::assoc_item_list(Some(assoc_items));
+        let impl_ = make::impl_(None, None, None, self_ty.clone(), None, Some(assoc_item_list));
+        // Add the import for enum/struct corresponding to given impl block
+        let use_impl = make_use_stmt_of_node_with_super(self_ty.syntax());
+        let mut module_body_items = use_items;
+        module_body_items.insert(0, use_impl);
+        module_body_items.push(ast::Item::Impl(impl_));
+        module_body_items
     } else {
-        (Either::Right(module.use_items.iter().chain(module.body_items.iter())), old_indent + 1)
+        [use_items, body_items].concat()
     };
 
-    let mut body = items_to_be_processed
-        .map(|item| item.indent(IndentLevel(1)))
-        .map(|item| format!("{new_item_indent}{item}"))
-        .join("\n\n");
+    let items = items.into_iter().map(|it| it.reset_indent().indent(IndentLevel(1))).collect_vec();
+    let module_body = make::item_list(Some(items));
 
-    if let Some(self_ty) = parent_impl.as_ref().and_then(|imp| imp.self_ty()) {
-        let impl_indent = old_indent + 1;
-        body = format!("{impl_indent}impl {self_ty} {{\n{body}\n{impl_indent}}}");
+    let module_name = make::name(name);
+    make::mod_(module_name, Some(module_body)).indent(old_indent)
+}
 
-        // Add the import for enum/struct corresponding to given impl block
-        module.make_use_stmt_of_node_with_super(self_ty.syntax());
-        for item in module.use_items.iter() {
-            body = format!("{impl_indent}{item}\n\n{body}");
-        }
-    }
+fn make_use_stmt_of_node_with_super(node_syntax: &SyntaxNode) -> ast::Item {
+    let super_path = make::ext::ident_path("super");
+    let node_path = make::ext::ident_path(&node_syntax.to_string());
+    let use_ = make::use_(
+        None,
+        None,
+        make::use_tree(make::join_paths(vec![super_path, node_path]), None, None, false),
+    );
 
-    let module_name = module.name;
-    format!("mod {module_name} {{\n{body}\n{old_indent}}}")
+    ast::Item::from(use_)
 }
 
 #[derive(Debug)]
 struct Module {
-    text_range: TextRange,
     name: &'static str,
     /// All items except use items.
     body_items: Vec<ast::Item>,
@@ -214,22 +230,37 @@ struct Module {
     use_items: Vec<ast::Item>,
 }
 
-fn extract_target(node: &SyntaxNode, selection_range: TextRange) -> Option<Module> {
+fn extract_single_target(node: &ast::Item) -> Module {
+    let (body_items, use_items) = if matches!(node, ast::Item::Use(_)) {
+        (Vec::new(), vec![node.clone()])
+    } else {
+        (vec![node.clone()], Vec::new())
+    };
+    let name = "modname";
+    Module { name, body_items, use_items }
+}
+
+fn extract_child_target(
+    node: &SyntaxNode,
+    selection_range: TextRange,
+) -> Option<(Module, RangeInclusive<SyntaxNode>)> {
     let selected_nodes = node
         .children()
         .filter(|node| selection_range.contains_range(node.text_range()))
-        .chain(iter::once(node.clone()));
-    let (use_items, body_items) = selected_nodes
         .filter_map(ast::Item::cast)
-        .partition(|item| matches!(item, ast::Item::Use(..)));
-
-    Some(Module { text_range: selection_range, name: "modname", body_items, use_items })
+        .collect_vec();
+    let start = selected_nodes.first()?.syntax().clone();
+    let end = selected_nodes.last()?.syntax().clone();
+    let (use_items, body_items): (Vec<ast::Item>, Vec<ast::Item>) =
+        selected_nodes.into_iter().partition(|item| matches!(item, ast::Item::Use(..)));
+    Some((Module { name: "modname", body_items, use_items }, start..=end))
 }
 
 impl Module {
     fn get_usages_and_record_fields(
         &self,
         ctx: &AssistContext<'_>,
+        replace_range: TextRange,
     ) -> (FxHashMap<FileId, Vec<(TextRange, String)>>, Vec<SyntaxNode>, FxHashMap<TextSize, ast::Use>)
     {
         let mut adt_fields = Vec::new();
@@ -247,7 +278,7 @@ impl Module {
                     ast::Adt(it) => {
                         if let Some( nod ) = ctx.sema.to_def(&it) {
                             let node_def = Definition::Adt(nod);
-                            self.expand_and_group_usages_file_wise(ctx, node_def, &mut refs, &mut use_stmts_to_be_inserted);
+                            self.expand_and_group_usages_file_wise(ctx, replace_range,node_def, &mut refs, &mut use_stmts_to_be_inserted);
 
                             //Enum Fields are not allowed to explicitly specify pub, it is implied
                             match it {
@@ -281,30 +312,30 @@ impl Module {
                     ast::TypeAlias(it) => {
                         if let Some( nod ) = ctx.sema.to_def(&it) {
                             let node_def = Definition::TypeAlias(nod);
-                            self.expand_and_group_usages_file_wise(ctx, node_def, &mut refs, &mut use_stmts_to_be_inserted);
+                            self.expand_and_group_usages_file_wise(ctx,replace_range, node_def, &mut refs, &mut use_stmts_to_be_inserted);
                         }
                     },
                     ast::Const(it) => {
                         if let Some( nod ) = ctx.sema.to_def(&it) {
                             let node_def = Definition::Const(nod);
-                            self.expand_and_group_usages_file_wise(ctx, node_def, &mut refs, &mut use_stmts_to_be_inserted);
+                            self.expand_and_group_usages_file_wise(ctx,replace_range, node_def, &mut refs, &mut use_stmts_to_be_inserted);
                         }
                     },
                     ast::Static(it) => {
                         if let Some( nod ) = ctx.sema.to_def(&it) {
                             let node_def = Definition::Static(nod);
-                            self.expand_and_group_usages_file_wise(ctx, node_def, &mut refs, &mut use_stmts_to_be_inserted);
+                            self.expand_and_group_usages_file_wise(ctx,replace_range, node_def, &mut refs, &mut use_stmts_to_be_inserted);
                         }
                     },
                     ast::Fn(it) => {
                         if let Some( nod ) = ctx.sema.to_def(&it) {
                             let node_def = Definition::Function(nod);
-                            self.expand_and_group_usages_file_wise(ctx, node_def, &mut refs, &mut use_stmts_to_be_inserted);
+                            self.expand_and_group_usages_file_wise(ctx,replace_range, node_def, &mut refs, &mut use_stmts_to_be_inserted);
                         }
                     },
                     ast::Macro(it) => {
                         if let Some(nod) = ctx.sema.to_def(&it) {
-                            self.expand_and_group_usages_file_wise(ctx, Definition::Macro(nod), &mut refs, &mut use_stmts_to_be_inserted);
+                            self.expand_and_group_usages_file_wise(ctx,replace_range, Definition::Macro(nod), &mut refs, &mut use_stmts_to_be_inserted);
                         }
                     },
                     _ => (),
@@ -318,6 +349,7 @@ impl Module {
     fn expand_and_group_usages_file_wise(
         &self,
         ctx: &AssistContext<'_>,
+        replace_range: TextRange,
         node_def: Definition,
         refs_in_files: &mut FxHashMap<FileId, Vec<(TextRange, String)>>,
         use_stmts_to_be_inserted: &mut FxHashMap<TextSize, ast::Use>,
@@ -327,7 +359,7 @@ impl Module {
             syntax::NodeOrToken::Node(node) => node,
             syntax::NodeOrToken::Token(tok) => tok.parent().unwrap(), // won't panic
         };
-        let out_of_sel = |node: &SyntaxNode| !self.text_range.contains_range(node.text_range());
+        let out_of_sel = |node: &SyntaxNode| !replace_range.contains_range(node.text_range());
         let mut use_stmts_set = FxHashSet::default();
 
         for (file_id, refs) in node_def.usages(&ctx.sema).all() {
@@ -527,7 +559,8 @@ impl Module {
                     // mod -> ust_stmt transversal
                     // true  | false -> super import insertion
                     // true  | true -> super import insertion
-                    self.make_use_stmt_of_node_with_super(use_node);
+                    let super_use_node = make_use_stmt_of_node_with_super(use_node);
+                    self.use_items.insert(0, super_use_node);
                 }
                 None => {}
             }
@@ -556,7 +589,8 @@ impl Module {
 
                 use_tree_paths = Some(use_tree_str);
             } else if def_in_mod && def_out_sel {
-                self.make_use_stmt_of_node_with_super(use_node);
+                let super_use_node = make_use_stmt_of_node_with_super(use_node);
+                self.use_items.insert(0, super_use_node);
             }
         }
 
@@ -596,20 +630,6 @@ impl Module {
         import_path_to_be_removed
     }
 
-    fn make_use_stmt_of_node_with_super(&mut self, node_syntax: &SyntaxNode) -> ast::Item {
-        let super_path = make::ext::ident_path("super");
-        let node_path = make::ext::ident_path(&node_syntax.to_string());
-        let use_ = make::use_(
-            None,
-            None,
-            make::use_tree(make::join_paths(vec![super_path, node_path]), None, None, false),
-        );
-
-        let item = ast::Item::from(use_);
-        self.use_items.insert(0, item.clone());
-        item
-    }
-
     fn process_use_stmt_for_import_resolve(
         &self,
         use_stmt: Option<ast::Use>,
@@ -1424,10 +1444,10 @@ $0fn foo(x: B) {}$0
             struct B {}
 
 mod modname {
-    use super::B;
-
     use super::A;
 
+    use super::B;
+
     impl A {
         pub(crate) fn foo(x: B) {}
     }
@@ -1739,4 +1759,27 @@ fn main() {
 "#,
         );
     }
+
+    #[test]
+    fn test_miss_select_item() {
+        check_assist(
+            extract_module,
+            r#"
+mod foo {
+    mod $0bar {
+        fn foo(){}$0
+    }
+}
+"#,
+            r#"
+mod foo {
+    mod modname {
+        pub(crate) mod bar {
+            fn foo(){}
+        }
+    }
+}
+"#,
+        )
+    }
 }
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/make.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/make.rs
index c5ca609760187..9897fd0941570 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/make.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/make.rs
@@ -231,6 +231,23 @@ pub fn ty_fn_ptr<I: Iterator<Item = Param>>(
     }
 }
 
+pub fn item_list(body: Option<Vec<ast::Item>>) -> ast::ItemList {
+    let is_break_braces = body.is_some();
+    let body_newline = if is_break_braces { "\n" } else { "" };
+    let body_indent = if is_break_braces { "    " } else { "" };
+
+    let body = match body {
+        Some(bd) => bd.iter().map(|elem| elem.to_string()).join("\n\n    "),
+        None => String::new(),
+    };
+    ast_from_text(&format!("mod C {{{body_newline}{body_indent}{body}{body_newline}}}"))
+}
+
+pub fn mod_(name: ast::Name, body: Option<ast::ItemList>) -> ast::Module {
+    let body = body.map_or(";".to_owned(), |body| format!(" {body}"));
+    ast_from_text(&format!("mod {name}{body}"))
+}
+
 pub fn assoc_item_list(body: Option<Vec<ast::AssocItem>>) -> ast::AssocItemList {
     let is_break_braces = body.is_some();
     let body_newline = if is_break_braces { "\n".to_owned() } else { String::new() };

From 47cc8b75f0148b1c4f6f95571fbfda7b2d8b3e9d Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukas@zed.dev>
Date: Thu, 7 Aug 2025 15:12:26 +0200
Subject: [PATCH 0042/1889] Enable warning logs by default

---
 src/tools/rust-analyzer/crates/rust-analyzer/src/bin/main.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/bin/main.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/bin/main.rs
index ab045e0bf9ff1..7602d379c0df9 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/bin/main.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/bin/main.rs
@@ -160,9 +160,9 @@ fn setup_logging(log_file_flag: Option<PathBuf>) -> anyhow::Result<()> {
 
     rust_analyzer::tracing::Config {
         writer,
-        // Deliberately enable all `error` logs if the user has not set RA_LOG, as there is usually
+        // Deliberately enable all `warn` logs if the user has not set RA_LOG, as there is usually
         // useful information in there for debugging.
-        filter: env::var("RA_LOG").ok().unwrap_or_else(|| "error".to_owned()),
+        filter: env::var("RA_LOG").ok().unwrap_or_else(|| "warn".to_owned()),
         chalk_filter: env::var("CHALK_DEBUG").ok(),
         profile_filter: env::var("RA_PROFILE").ok(),
         json_profile_filter: std::env::var("RA_PROFILE_JSON").ok(),

From 1a73720b8051a533b402ac67e35f84d405ccb28d Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukas@zed.dev>
Date: Thu, 7 Aug 2025 15:14:22 +0200
Subject: [PATCH 0043/1889] Disable error log for position clamping, its too
 noisy due to ease of triggering

---
 .../crates/rust-analyzer/src/lsp/from_proto.rs      | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/lsp/from_proto.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/lsp/from_proto.rs
index 02757616d4ffd..333826a1790e4 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/lsp/from_proto.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/lsp/from_proto.rs
@@ -40,12 +40,13 @@ pub(crate) fn offset(
     })?;
     let col = TextSize::from(line_col.col);
     let clamped_len = col.min(line_range.len());
-    if clamped_len < col {
-        tracing::error!(
-            "Position {line_col:?} column exceeds line length {}, clamping it",
-            u32::from(line_range.len()),
-        );
-    }
+    // FIXME: The cause for this is likely our request retrying. Commented out as this log is just too chatty and very easy to trigger.
+    // if clamped_len < col {
+    //     tracing::error!(
+    //         "Position {line_col:?} column exceeds line length {}, clamping it",
+    //         u32::from(line_range.len()),
+    //     );
+    // }
     Ok(line_range.start() + clamped_len)
 }
 

From 5b9e6f1b75f14d916bc3d43c21e1e845cc049dbf Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Fri, 8 Aug 2025 23:48:12 +0800
Subject: [PATCH 0044/1889] Add write! and writeln! to minicore

---
 .../crates/test-utils/src/minicore.rs         | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/test-utils/src/minicore.rs b/src/tools/rust-analyzer/crates/test-utils/src/minicore.rs
index 7b719b5dec754..c1f2b08be942c 100644
--- a/src/tools/rust-analyzer/crates/test-utils/src/minicore.rs
+++ b/src/tools/rust-analyzer/crates/test-utils/src/minicore.rs
@@ -70,6 +70,7 @@
 //!     tuple:
 //!     unpin: sized
 //!     unsize: sized
+//!     write: fmt
 //!     todo: panic
 //!     unimplemented: panic
 //!     column:
@@ -1769,6 +1770,26 @@ mod macros {
     }
     // endregion:panic
 
+    // region:write
+    #[macro_export]
+    macro_rules! write {
+        ($dst:expr, $($arg:tt)*) => {
+            $dst.write_fmt($crate::format_args!($($arg)*))
+        };
+    }
+
+    #[macro_export]
+    #[allow_internal_unstable(format_args_nl)]
+    macro_rules! writeln {
+        ($dst:expr $(,)?) => {
+            $crate::write!($dst, "\n")
+        };
+        ($dst:expr, $($arg:tt)*) => {
+            $dst.write_fmt($crate::format_args_nl!($($arg)*))
+        };
+    }
+    // endregion:write
+
     // region:assert
     #[macro_export]
     #[rustc_builtin_macro]

From bb4fded8a35a961b749846df45f6caf55d98e5d3 Mon Sep 17 00:00:00 2001
From: BenjaminBrienen <Benjamin.Brienen@outlook.com>
Date: Fri, 8 Aug 2025 23:46:28 +0200
Subject: [PATCH 0045/1889] remove duplicate field in Debug

---
 src/tools/rust-analyzer/crates/project-model/src/workspace.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/project-model/src/workspace.rs b/src/tools/rust-analyzer/crates/project-model/src/workspace.rs
index 5b36e10fd6925..00032bcf1d2e4 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/workspace.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/workspace.rs
@@ -157,7 +157,6 @@ impl fmt::Debug for ProjectWorkspace {
                 .field("file", &file)
                 .field("cargo_script", &cargo_script.is_some())
                 .field("n_sysroot_crates", &sysroot.num_packages())
-                .field("cargo_script", &cargo_script.is_some())
                 .field("n_rustc_cfg", &rustc_cfg.len())
                 .field("toolchain", &toolchain)
                 .field("data_layout", &target_layout)

From e3d99ddcbc010de4942df34e6d5491c4b664152c Mon Sep 17 00:00:00 2001
From: Hmikihiro <34ttrweoewiwe28@gmail.com>
Date: Sat, 9 Aug 2025 14:53:34 +0900
Subject: [PATCH 0046/1889] fix: generate function by indet token

---
 .../src/handlers/generate_function.rs         | 30 ++++++++++++++++++-
 1 file changed, 29 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_function.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_function.rs
index efdb20c1e9317..88ed6f9ce124d 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_function.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_function.rs
@@ -316,7 +316,7 @@ impl FunctionBuilder {
         let current_module = ctx.sema.scope(call.syntax())?.module();
         let visibility = calculate_necessary_visibility(current_module, target_module, ctx);
 
-        let fn_name = make::name(&name.text());
+        let fn_name = make::name(name.ident_token()?.text());
         let mut necessary_generic_params = FxHashSet::default();
         necessary_generic_params.extend(receiver_ty.generic_params(ctx.db()));
         let params = fn_args(
@@ -3131,4 +3131,32 @@ fn main() {
         "#,
         )
     }
+
+    #[test]
+    fn no_generate_method_by_keyword() {
+        check_assist_not_applicable(
+            generate_function,
+            r#"
+fn main() {
+    s.super$0();
+}
+        "#,
+        );
+        check_assist_not_applicable(
+            generate_function,
+            r#"
+fn main() {
+    s.Self$0();
+}
+        "#,
+        );
+        check_assist_not_applicable(
+            generate_function,
+            r#"
+fn main() {
+    s.self$0();
+}
+        "#,
+        );
+    }
 }

From eb2bbbb9134ae3fc4d043ea12b3546b73cd90efd Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Fri, 1 Aug 2025 14:29:21 +0000
Subject: [PATCH 0047/1889] Implement next trait solver

---
 src/tools/rust-analyzer/Cargo.lock            |   83 +-
 src/tools/rust-analyzer/Cargo.toml            |   11 +-
 .../crates/hir-def/src/lang_item.rs           |    7 +-
 .../crates/hir-def/src/signatures.rs          |    6 +-
 .../rust-analyzer/crates/hir-ty/Cargo.toml    |   10 +-
 .../crates/hir-ty/src/autoderef.rs            |    4 +-
 .../crates/hir-ty/src/chalk_db.rs             |  610 +----
 .../crates/hir-ty/src/chalk_ext.rs            |    9 +-
 .../crates/hir-ty/src/consteval/tests.rs      |    3 +-
 .../crates/hir-ty/src/consteval_nextsolver.rs |  256 ++
 .../rust-analyzer/crates/hir-ty/src/db.rs     |  159 +-
 .../rust-analyzer/crates/hir-ty/src/drop.rs   |    2 +-
 .../crates/hir-ty/src/dyn_compatibility.rs    |   41 +-
 .../hir-ty/src/dyn_compatibility/tests.rs     |   25 +-
 .../crates/hir-ty/src/generics.rs             |   17 +-
 .../rust-analyzer/crates/hir-ty/src/infer.rs  |  107 +-
 .../crates/hir-ty/src/infer/closure.rs        |    9 +-
 .../crates/hir-ty/src/infer/coerce.rs         |   31 +-
 .../crates/hir-ty/src/infer/expr.rs           |   11 +-
 .../crates/hir-ty/src/infer/unify.rs          |  192 +-
 .../crates/hir-ty/src/interner.rs             |   25 +-
 .../rust-analyzer/crates/hir-ty/src/layout.rs |  364 +--
 .../crates/hir-ty/src/layout/adt.rs           |   46 +-
 .../crates/hir-ty/src/layout/tests.rs         |    3 +
 .../rust-analyzer/crates/hir-ty/src/lib.rs    |  133 +-
 .../rust-analyzer/crates/hir-ty/src/lower.rs  |   49 +-
 .../crates/hir-ty/src/lower_nextsolver.rs     | 1609 ++++++++++++
 .../hir-ty/src/lower_nextsolver/path.rs       | 1459 +++++++++++
 .../crates/hir-ty/src/method_resolution.rs    |  135 +-
 .../crates/hir-ty/src/mir/eval/tests.rs       |    5 +-
 .../crates/hir-ty/src/mir/lower.rs            |    4 +-
 .../crates/hir-ty/src/next_solver.rs          |   46 +
 .../crates/hir-ty/src/next_solver/abi.rs      |   68 +
 .../crates/hir-ty/src/next_solver/consts.rs   |  404 +++
 .../crates/hir-ty/src/next_solver/def_id.rs   |   96 +
 .../crates/hir-ty/src/next_solver/fold.rs     |  129 +
 .../crates/hir-ty/src/next_solver/fulfill.rs  |  229 ++
 .../hir-ty/src/next_solver/generic_arg.rs     |  525 ++++
 .../crates/hir-ty/src/next_solver/generics.rs |  147 ++
 .../crates/hir-ty/src/next_solver/infer/at.rs |  333 +++
 .../infer/canonical/instantiate.rs            |  106 +
 .../src/next_solver/infer/canonical/mod.rs    |  156 ++
 .../hir-ty/src/next_solver/infer/context.rs   |  316 +++
 .../hir-ty/src/next_solver/infer/mod.rs       | 1066 ++++++++
 .../src/next_solver/infer/opaque_types/mod.rs |   56 +
 .../next_solver/infer/opaque_types/table.rs   |  166 ++
 .../infer/region_constraints/mod.rs           |  640 +++++
 .../next_solver/infer/relate/generalize.rs    |  720 ++++++
 .../next_solver/infer/relate/higher_ranked.rs |   89 +
 .../src/next_solver/infer/relate/mod.rs       |   13 +
 .../hir-ty/src/next_solver/infer/resolve.rs   |   62 +
 .../src/next_solver/infer/snapshot/mod.rs     |  111 +
 .../next_solver/infer/snapshot/undo_log.rs    |  198 ++
 .../hir-ty/src/next_solver/infer/traits.rs    |  175 ++
 .../src/next_solver/infer/type_variable.rs    |  268 ++
 .../hir-ty/src/next_solver/infer/unify_key.rs |  176 ++
 .../crates/hir-ty/src/next_solver/interner.rs | 2173 +++++++++++++++++
 .../crates/hir-ty/src/next_solver/ir_print.rs |  267 ++
 .../crates/hir-ty/src/next_solver/mapping.rs  | 1368 +++++++++++
 .../crates/hir-ty/src/next_solver/opaques.rs  |  167 ++
 .../hir-ty/src/next_solver/predicate.rs       |  894 +++++++
 .../crates/hir-ty/src/next_solver/project.rs  |    3 +
 .../next_solver/project/solve_normalize.rs    |  264 ++
 .../crates/hir-ty/src/next_solver/region.rs   |  332 +++
 .../crates/hir-ty/src/next_solver/solver.rs   |  289 +++
 .../crates/hir-ty/src/next_solver/ty.rs       |  943 +++++++
 .../crates/hir-ty/src/next_solver/util.rs     | 1064 ++++++++
 .../rust-analyzer/crates/hir-ty/src/tests.rs  |   23 +-
 .../hir-ty/src/tests/closure_captures.rs      |    3 +-
 .../crates/hir-ty/src/tests/coercion.rs       |   16 +-
 .../crates/hir-ty/src/tests/incremental.rs    |   20 +-
 .../crates/hir-ty/src/tests/macros.rs         |   24 +-
 .../hir-ty/src/tests/method_resolution.rs     |   34 +-
 .../crates/hir-ty/src/tests/regression.rs     |   37 +-
 .../crates/hir-ty/src/tests/simple.rs         |    4 +-
 .../crates/hir-ty/src/tests/traits.rs         |  100 +-
 .../rust-analyzer/crates/hir-ty/src/tls.rs    |    2 +
 .../rust-analyzer/crates/hir-ty/src/traits.rs |  252 +-
 src/tools/rust-analyzer/crates/hir/Cargo.toml |    5 +
 src/tools/rust-analyzer/crates/hir/src/lib.rs |  172 +-
 .../handlers/generate_from_impl_for_enum.rs   |   24 +-
 .../generate_single_field_struct_from.rs      |   17 +-
 .../crates/ide-assists/src/lib.rs             |    9 +-
 .../crates/ide-assists/src/tests.rs           |    9 +-
 .../ide-completion/src/completions/dot.rs     |    7 +-
 .../crates/ide-completion/src/lib.rs          |    5 +-
 .../crates/ide-completion/src/tests.rs        |    4 +-
 .../ide-completion/src/tests/flyimport.rs     |   39 +-
 .../ide-completion/src/tests/special.rs       |    3 +
 .../src/handlers/moved_out_of_ref.rs          |    4 +-
 .../crates/ide-diagnostics/src/lib.rs         |   12 +-
 .../crates/ide-diagnostics/src/tests.rs       |    3 +
 .../crates/ide-ssr/src/resolving.rs           |   26 +-
 .../crates/ide/src/doc_links/tests.rs         |    7 +-
 .../crates/ide/src/goto_definition.rs         |    4 +-
 .../crates/ide/src/goto_implementation.rs     |    2 +-
 .../rust-analyzer/crates/ide/src/hover.rs     |    5 +-
 .../crates/ide/src/hover/render.rs            |    3 +-
 .../crates/ide/src/hover/tests.rs             |    3 +
 .../crates/ide/src/inlay_hints.rs             |    6 +-
 .../crates/ide/src/inlay_hints/adjustment.rs  |   10 +-
 .../crates/ide/src/inlay_hints/bind_pat.rs    |    2 +-
 .../crates/ide/src/signature_help.rs          |    4 +-
 .../crates/ide/src/syntax_highlighting.rs     |   22 +-
 .../test_data/highlight_general.html          |   12 +-
 .../crates/intern/src/symbol/symbols.rs       |    5 +
 .../crates/profile/src/stop_watch.rs          |    8 +-
 .../crates/query-group-macro/src/queries.rs   |    3 +-
 .../crates/test-utils/src/minicore.rs         |   15 +-
 109 files changed, 19140 insertions(+), 1309 deletions(-)
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver/path.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/abi.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fold.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generic_arg.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generics.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/at.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/instantiate.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/mod.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/context.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/opaque_types/mod.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/opaque_types/table.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/region_constraints/mod.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/relate/generalize.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/relate/higher_ranked.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/relate/mod.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/resolve.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/snapshot/mod.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/snapshot/undo_log.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/traits.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/type_variable.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/unify_key.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ir_print.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/opaques.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/predicate.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/project.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/project/solve_normalize.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/region.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/util.rs

diff --git a/src/tools/rust-analyzer/Cargo.lock b/src/tools/rust-analyzer/Cargo.lock
index 80a311a74abe4..f72e698f60631 100644
--- a/src/tools/rust-analyzer/Cargo.lock
+++ b/src/tools/rust-analyzer/Cargo.lock
@@ -259,9 +259,9 @@ checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
 
 [[package]]
 name = "chalk-derive"
-version = "0.103.0"
+version = "0.104.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb4899682de915ca7c0b025bdd0a3d34c75fe12184122fda6805a7baddaa293c"
+checksum = "9ea9b1e80910f66ae87c772247591432032ef3f6a67367ff17f8343db05beafa"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -271,9 +271,9 @@ dependencies = [
 
 [[package]]
 name = "chalk-ir"
-version = "0.103.0"
+version = "0.104.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90a37d2ab99352b4caca135061e7b4ac67024b648c28ed0b787feec4bea4caed"
+checksum = "7047a516de16226cd17344d41a319d0ea1064bf9e60bd612ab341ab4a34bbfa8"
 dependencies = [
  "bitflags 2.9.1",
  "chalk-derive",
@@ -281,9 +281,9 @@ dependencies = [
 
 [[package]]
 name = "chalk-recursive"
-version = "0.103.0"
+version = "0.104.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c855be60e646664bc37c2496d3dc81ca5ef60520930e5e0f0057a0575aff6c19"
+checksum = "882959c242558cc686de7ff0aa59860295598d119e84a4b100215f44c3d606c4"
 dependencies = [
  "chalk-derive",
  "chalk-ir",
@@ -294,9 +294,9 @@ dependencies = [
 
 [[package]]
 name = "chalk-solve"
-version = "0.103.0"
+version = "0.104.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "477ac6cdfd2013e9f93b09b036c2b607a67b2e728f4777b8422d55a79e9e3a34"
+checksum = "72860086494ccfa05bbd3779a74babb8ace27da9a0cbabffa1315223c7290927"
 dependencies = [
  "chalk-derive",
  "chalk-ir",
@@ -445,6 +445,17 @@ dependencies = [
  "powerfmt",
 ]
 
+[[package]]
+name = "derive-where"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "510c292c8cf384b1a340b816a9a6cf2599eb8f566a44949024af88418000c50b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "derive_arbitrary"
 version = "1.4.1"
@@ -696,6 +707,7 @@ dependencies = [
  "indexmap",
  "intern",
  "itertools 0.14.0",
+ "ra-ap-rustc_type_ir",
  "rustc-hash 2.1.1",
  "smallvec",
  "span",
@@ -705,6 +717,8 @@ dependencies = [
  "test-fixture",
  "test-utils",
  "tracing",
+ "tracing-subscriber",
+ "tracing-tree",
  "triomphe",
  "tt",
 ]
@@ -801,8 +815,11 @@ dependencies = [
  "project-model",
  "query-group-macro",
  "ra-ap-rustc_abi",
+ "ra-ap-rustc_ast_ir",
  "ra-ap-rustc_index",
+ "ra-ap-rustc_next_trait_solver",
  "ra-ap-rustc_pattern_analysis",
+ "ra-ap-rustc_type_ir",
  "rustc-hash 2.1.1",
  "rustc_apfloat",
  "salsa",
@@ -1856,6 +1873,12 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "ra-ap-rustc_ast_ir"
+version = "0.123.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87cc17e8ce797f2a8d03b838fbf166749b876164432ce81e37d283bf69e3cf80"
+
 [[package]]
 name = "ra-ap-rustc_hashes"
 version = "0.123.0"
@@ -1908,6 +1931,19 @@ dependencies = [
  "unicode-xid",
 ]
 
+[[package]]
+name = "ra-ap-rustc_next_trait_solver"
+version = "0.123.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14f7dfbdf1d045ff4e385e1efdfc3799379895e9c3f3b9b379a0bef4cb238441"
+dependencies = [
+ "derive-where",
+ "ra-ap-rustc_index",
+ "ra-ap-rustc_type_ir",
+ "ra-ap-rustc_type_ir_macros",
+ "tracing",
+]
+
 [[package]]
 name = "ra-ap-rustc_parse_format"
 version = "0.121.0"
@@ -1931,6 +1967,37 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "ra-ap-rustc_type_ir"
+version = "0.123.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bc59fb10a922c38a24cb8a1494f799b0af30bd041acbea689378d3bf330534b"
+dependencies = [
+ "bitflags 2.9.1",
+ "derive-where",
+ "ena",
+ "indexmap",
+ "ra-ap-rustc_ast_ir",
+ "ra-ap-rustc_index",
+ "ra-ap-rustc_type_ir_macros",
+ "rustc-hash 2.1.1",
+ "smallvec",
+ "thin-vec",
+ "tracing",
+]
+
+[[package]]
+name = "ra-ap-rustc_type_ir_macros"
+version = "0.123.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "58878914b6dac7499baeecc8dbb4b9d9dda88030e4ab90cd3b4e87523fbedafe"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
 [[package]]
 name = "rayon"
 version = "1.10.0"
diff --git a/src/tools/rust-analyzer/Cargo.toml b/src/tools/rust-analyzer/Cargo.toml
index 01a13a39f7b40..bb8444ed73422 100644
--- a/src/tools/rust-analyzer/Cargo.toml
+++ b/src/tools/rust-analyzer/Cargo.toml
@@ -94,6 +94,9 @@ ra-ap-rustc_parse_format = { version = "0.121", default-features = false }
 ra-ap-rustc_index = { version = "0.123", default-features = false }
 ra-ap-rustc_abi = { version = "0.123", default-features = false }
 ra-ap-rustc_pattern_analysis = { version = "0.123", default-features = false }
+ra-ap-rustc_ast_ir = { version = "0.123", default-features = false }
+ra-ap-rustc_type_ir = { version = "0.123", default-features = false }
+ra-ap-rustc_next_trait_solver = { version = "0.123", default-features = false }
 
 # local crates that aren't published to crates.io. These should not have versions.
 
@@ -108,10 +111,10 @@ arrayvec = "0.7.6"
 bitflags = "2.9.1"
 cargo_metadata = "0.21.0"
 camino = "1.1.10"
-chalk-solve = { version = "0.103.0", default-features = false }
-chalk-ir = "0.103.0"
-chalk-recursive = { version = "0.103.0", default-features = false }
-chalk-derive = "0.103.0"
+chalk-solve = { version = "0.104.0", default-features = false }
+chalk-ir = "0.104.0"
+chalk-recursive = { version = "0.104.0", default-features = false }
+chalk-derive = "0.104.0"
 crossbeam-channel = "0.5.15"
 dissimilar = "1.0.10"
 dot = "0.1.4"
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/lang_item.rs b/src/tools/rust-analyzer/crates/hir-def/src/lang_item.rs
index d431f2140165e..a0be69cb2f96e 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/lang_item.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/lang_item.rs
@@ -383,12 +383,17 @@ language_item_table! {
     AsyncFnMut,              sym::async_fn_mut,        async_fn_mut_trait,         Target::Trait,          GenericRequirement::Exact(1);
     AsyncFnOnce,             sym::async_fn_once,       async_fn_once_trait,        Target::Trait,          GenericRequirement::Exact(1);
 
-    AsyncFnOnceOutput,       sym::async_fn_once_output,async_fn_once_output,       Target::AssocTy,        GenericRequirement::None;
+    CallRefFuture,           sym::call_ref_future,     call_ref_future_ty,         Target::AssocTy,        GenericRequirement::None;
+    CallOnceFuture,          sym::call_once_future,    call_once_future_ty,        Target::AssocTy,        GenericRequirement::None;
+    AsyncFnOnceOutput,       sym::async_fn_once_output, async_fn_once_output_ty,   Target::AssocTy,        GenericRequirement::None;
+
     FnOnceOutput,            sym::fn_once_output,      fn_once_output,             Target::AssocTy,        GenericRequirement::None;
 
     Future,                  sym::future_trait,        future_trait,               Target::Trait,          GenericRequirement::Exact(0);
     CoroutineState,          sym::coroutine_state,     coroutine_state,            Target::Enum,           GenericRequirement::None;
     Coroutine,               sym::coroutine,           coroutine_trait,            Target::Trait,          GenericRequirement::Minimum(1);
+    CoroutineReturn,         sym::coroutine_return,    coroutine_return_ty,        Target::AssocTy,        GenericRequirement::None;
+    CoroutineYield,          sym::coroutine_yield,     coroutine_yield_ty,         Target::AssocTy,        GenericRequirement::None;
     Unpin,                   sym::unpin,               unpin_trait,                Target::Trait,          GenericRequirement::None;
     Pin,                     sym::pin,                 pin_type,                   Target::Struct,         GenericRequirement::None;
 
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs b/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
index 92e610b36acd0..598b2c0314a94 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
@@ -395,7 +395,7 @@ impl ImplSignature {
 
 bitflags::bitflags! {
     #[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
-    pub struct TraitFlags: u8 {
+    pub struct TraitFlags: u16 {
         const RUSTC_HAS_INCOHERENT_INHERENT_IMPLS = 1 << 1;
         const FUNDAMENTAL = 1 << 2;
         const UNSAFE = 1 << 3;
@@ -403,6 +403,7 @@ bitflags::bitflags! {
         const SKIP_ARRAY_DURING_METHOD_DISPATCH = 1 << 5;
         const SKIP_BOXED_SLICE_DURING_METHOD_DISPATCH = 1 << 6;
         const RUSTC_PAREN_SUGAR = 1 << 7;
+        const COINDUCTIVE = 1 << 8;
     }
 }
 
@@ -436,6 +437,9 @@ impl TraitSignature {
         if attrs.by_key(sym::rustc_paren_sugar).exists() {
             flags |= TraitFlags::RUSTC_PAREN_SUGAR;
         }
+        if attrs.by_key(sym::rustc_coinductive).exists() {
+            flags |= TraitFlags::COINDUCTIVE;
+        }
         let mut skip_array_during_method_dispatch =
             attrs.by_key(sym::rustc_skip_array_during_method_dispatch).exists();
         let mut skip_boxed_slice_during_method_dispatch = false;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/Cargo.toml b/src/tools/rust-analyzer/crates/hir-ty/Cargo.toml
index 7cc0a26d37c80..64182110e1862 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/Cargo.toml
+++ b/src/tools/rust-analyzer/crates/hir-ty/Cargo.toml
@@ -40,7 +40,14 @@ salsa-macros.workspace = true
 ra-ap-rustc_abi.workspace = true
 ra-ap-rustc_index.workspace = true
 ra-ap-rustc_pattern_analysis.workspace = true
+ra-ap-rustc_ast_ir.workspace = true
+ra-ap-rustc_type_ir.workspace = true
+ra-ap-rustc_next_trait_solver.workspace = true
 
+# These moved to dev deps if `setup_tracing` was a macro and dependents also
+# included these
+tracing-subscriber.workspace = true
+tracing-tree.workspace = true
 
 # local deps
 stdx.workspace = true
@@ -53,9 +60,6 @@ span.workspace = true
 
 [dev-dependencies]
 expect-test = "1.5.1"
-tracing.workspace = true
-tracing-subscriber.workspace = true
-tracing-tree.workspace = true
 project-model.workspace = true
 
 # local deps
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs b/src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs
index 26ca7fb9a15ec..4ea0156e1248a 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs
@@ -225,7 +225,9 @@ pub(crate) fn deref_by_trait(
     // Check that the type implements Deref at all
     let trait_ref = projection.trait_ref(db);
     let implements_goal: Goal = trait_ref.cast(Interner);
-    table.try_obligation(implements_goal.clone())?;
+    if table.try_obligation(implements_goal.clone()).no_solution() {
+        return None;
+    }
 
     table.register_obligation(implements_goal);
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/chalk_db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/chalk_db.rs
index 3ba7c93d4fb76..f523a5e8bfa05 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/chalk_db.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/chalk_db.rs
@@ -1,47 +1,36 @@
 //! The implementation of `RustIrDatabase` for Chalk, which provides information
 //! about the code that Chalk needs.
-use core::ops;
-use std::{iter, ops::ControlFlow, sync::Arc};
+use std::sync::Arc;
 
-use hir_expand::name::Name;
-use intern::sym;
-use span::Edition;
 use tracing::debug;
 
-use chalk_ir::{CanonicalVarKinds, cast::Caster, fold::shift::Shift};
-use chalk_solve::rust_ir::{self, OpaqueTyDatumBound, WellKnownTrait};
+use chalk_ir::{cast::Caster, fold::shift::Shift};
+use chalk_solve::rust_ir::{self, WellKnownTrait};
 
 use base_db::Crate;
 use hir_def::{
-    AssocItemId, BlockId, CallableDefId, GenericDefId, HasModule, ItemContainerId, Lookup,
-    TypeAliasId, VariantId,
-    hir::Movability,
+    AssocItemId, CallableDefId, GenericDefId, HasModule, ItemContainerId, Lookup, TypeAliasId,
+    VariantId,
     lang_item::LangItem,
     signatures::{ImplFlags, StructFlags, TraitFlags},
 };
 
 use crate::{
-    AliasEq, AliasTy, BoundVar, DebruijnIndex, Interner, ProjectionTy, ProjectionTyExt,
-    QuantifiedWhereClause, Substitution, TraitRef, TraitRefExt, Ty, TyBuilder, TyExt, TyKind,
-    WhereClause,
-    db::{HirDatabase, InternedCoroutine},
-    from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id,
+    AliasEq, AliasTy, DebruijnIndex, Interner, ProjectionTyExt, QuantifiedWhereClause,
+    Substitution, TraitRefExt, Ty, TyBuilder, TyExt, TyKind, WhereClause,
+    db::HirDatabase,
+    from_assoc_type_id, from_chalk_trait_id,
     generics::generics,
     lower::LifetimeElisionKind,
-    make_binders, make_single_type_binders,
+    make_binders,
     mapping::{ToChalk, TypeAliasAsValue, from_chalk},
-    method_resolution::{ALL_FLOAT_FPS, ALL_INT_FPS, TraitImpls, TyFingerprint},
     to_assoc_type_id, to_chalk_trait_id,
-    traits::ChalkContext,
-    utils::ClosureSubst,
-    wrap_empty_binders,
 };
 
 pub(crate) type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum<Interner>;
 pub(crate) type TraitDatum = chalk_solve::rust_ir::TraitDatum<Interner>;
 pub(crate) type AdtDatum = chalk_solve::rust_ir::AdtDatum<Interner>;
 pub(crate) type ImplDatum = chalk_solve::rust_ir::ImplDatum<Interner>;
-pub(crate) type OpaqueTyDatum = chalk_solve::rust_ir::OpaqueTyDatum<Interner>;
 
 pub(crate) type AssocTypeId = chalk_ir::AssocTypeId<Interner>;
 pub(crate) type TraitId = chalk_ir::TraitId<Interner>;
@@ -52,551 +41,6 @@ pub(crate) type AssociatedTyValue = chalk_solve::rust_ir::AssociatedTyValue<Inte
 pub(crate) type FnDefDatum = chalk_solve::rust_ir::FnDefDatum<Interner>;
 pub(crate) type Variances = chalk_ir::Variances<Interner>;
 
-impl chalk_solve::RustIrDatabase<Interner> for ChalkContext<'_> {
-    fn associated_ty_data(&self, id: AssocTypeId) -> Arc<AssociatedTyDatum> {
-        self.db.associated_ty_data(from_assoc_type_id(id))
-    }
-    fn associated_ty_from_impl(
-        &self,
-        impl_id: chalk_ir::ImplId<Interner>,
-        assoc_type_id: chalk_ir::AssocTypeId<Interner>,
-    ) -> Option<rust_ir::AssociatedTyValueId<Interner>> {
-        let alias_id = from_assoc_type_id(assoc_type_id);
-        let trait_sig = self.db.type_alias_signature(alias_id);
-        hir_def::ImplId::from_chalk(self.db, impl_id).impl_items(self.db).items.iter().find_map(
-            |(name, item)| match item {
-                AssocItemId::TypeAliasId(alias) if &trait_sig.name == name => {
-                    Some(TypeAliasAsValue(*alias).to_chalk(self.db))
-                }
-                _ => None,
-            },
-        )
-    }
-    fn trait_datum(&self, trait_id: TraitId) -> Arc<TraitDatum> {
-        self.db.trait_datum(self.krate, trait_id)
-    }
-    fn adt_datum(&self, struct_id: AdtId) -> Arc<AdtDatum> {
-        self.db.adt_datum(self.krate, struct_id)
-    }
-    fn adt_repr(&self, _struct_id: AdtId) -> Arc<rust_ir::AdtRepr<Interner>> {
-        // FIXME: keep track of these
-        Arc::new(rust_ir::AdtRepr { c: false, packed: false, int: None })
-    }
-    fn discriminant_type(&self, ty: chalk_ir::Ty<Interner>) -> chalk_ir::Ty<Interner> {
-        if let chalk_ir::TyKind::Adt(id, _) = ty.kind(Interner)
-            && let hir_def::AdtId::EnumId(e) = id.0
-        {
-            let enum_data = self.db.enum_signature(e);
-            let ty = enum_data.repr.unwrap_or_default().discr_type();
-            return chalk_ir::TyKind::Scalar(match ty {
-                hir_def::layout::IntegerType::Pointer(is_signed) => match is_signed {
-                    true => chalk_ir::Scalar::Int(chalk_ir::IntTy::Isize),
-                    false => chalk_ir::Scalar::Uint(chalk_ir::UintTy::Usize),
-                },
-                hir_def::layout::IntegerType::Fixed(size, is_signed) => match is_signed {
-                    true => chalk_ir::Scalar::Int(match size {
-                        hir_def::layout::Integer::I8 => chalk_ir::IntTy::I8,
-                        hir_def::layout::Integer::I16 => chalk_ir::IntTy::I16,
-                        hir_def::layout::Integer::I32 => chalk_ir::IntTy::I32,
-                        hir_def::layout::Integer::I64 => chalk_ir::IntTy::I64,
-                        hir_def::layout::Integer::I128 => chalk_ir::IntTy::I128,
-                    }),
-                    false => chalk_ir::Scalar::Uint(match size {
-                        hir_def::layout::Integer::I8 => chalk_ir::UintTy::U8,
-                        hir_def::layout::Integer::I16 => chalk_ir::UintTy::U16,
-                        hir_def::layout::Integer::I32 => chalk_ir::UintTy::U32,
-                        hir_def::layout::Integer::I64 => chalk_ir::UintTy::U64,
-                        hir_def::layout::Integer::I128 => chalk_ir::UintTy::U128,
-                    }),
-                },
-            })
-            .intern(Interner);
-        }
-        chalk_ir::TyKind::Scalar(chalk_ir::Scalar::Uint(chalk_ir::UintTy::U8)).intern(Interner)
-    }
-    fn impl_datum(&self, impl_id: ImplId) -> Arc<ImplDatum> {
-        self.db.impl_datum(self.krate, impl_id)
-    }
-
-    fn fn_def_datum(
-        &self,
-        fn_def_id: chalk_ir::FnDefId<Interner>,
-    ) -> Arc<rust_ir::FnDefDatum<Interner>> {
-        self.db.fn_def_datum(from_chalk(self.db, fn_def_id))
-    }
-
-    fn impls_for_trait(
-        &self,
-        trait_id: TraitId,
-        parameters: &[chalk_ir::GenericArg<Interner>],
-        binders: &CanonicalVarKinds<Interner>,
-    ) -> Vec<ImplId> {
-        debug!("impls_for_trait {:?}", trait_id);
-        let trait_: hir_def::TraitId = from_chalk_trait_id(trait_id);
-
-        let ty: Ty = parameters[0].assert_ty_ref(Interner).clone();
-
-        fn binder_kind(
-            ty: &Ty,
-            binders: &CanonicalVarKinds<Interner>,
-        ) -> Option<chalk_ir::TyVariableKind> {
-            if let TyKind::BoundVar(bv) = ty.kind(Interner) {
-                let binders = binders.as_slice(Interner);
-                if bv.debruijn == DebruijnIndex::INNERMOST
-                    && let chalk_ir::VariableKind::Ty(tk) = binders[bv.index].kind
-                {
-                    return Some(tk);
-                }
-            }
-            None
-        }
-
-        let self_ty_fp = TyFingerprint::for_trait_impl(&ty);
-        let fps: &[TyFingerprint] = match binder_kind(&ty, binders) {
-            Some(chalk_ir::TyVariableKind::Integer) => &ALL_INT_FPS,
-            Some(chalk_ir::TyVariableKind::Float) => &ALL_FLOAT_FPS,
-            _ => self_ty_fp.as_slice(),
-        };
-
-        let id_to_chalk = |id: hir_def::ImplId| id.to_chalk(self.db);
-
-        let mut result = vec![];
-        if fps.is_empty() {
-            debug!("Unrestricted search for {:?} impls...", trait_);
-            _ = self.for_trait_impls(trait_, self_ty_fp, |impls| {
-                result.extend(impls.for_trait(trait_).map(id_to_chalk));
-                ControlFlow::Continue(())
-            });
-        } else {
-            _ =
-                self.for_trait_impls(trait_, self_ty_fp, |impls| {
-                    result.extend(fps.iter().flat_map(move |fp| {
-                        impls.for_trait_and_self_ty(trait_, *fp).map(id_to_chalk)
-                    }));
-                    ControlFlow::Continue(())
-                });
-        };
-
-        debug!("impls_for_trait returned {} impls", result.len());
-        result
-    }
-
-    fn impl_provided_for(&self, auto_trait_id: TraitId, kind: &chalk_ir::TyKind<Interner>) -> bool {
-        debug!("impl_provided_for {:?}, {:?}", auto_trait_id, kind);
-
-        let trait_id = from_chalk_trait_id(auto_trait_id);
-        let self_ty = kind.clone().intern(Interner);
-        // We cannot filter impls by `TyFingerprint` for the following types:
-        let self_ty_fp = match kind {
-            // because we need to find any impl whose Self type is a ref with the same mutability
-            // (we don't care about the inner type).
-            TyKind::Ref(..) => None,
-            // because we need to find any impl whose Self type is a tuple with the same arity.
-            TyKind::Tuple(..) => None,
-            _ => TyFingerprint::for_trait_impl(&self_ty),
-        };
-
-        let check_kind = |impl_id| {
-            let impl_self_ty = self.db.impl_self_ty(impl_id);
-            // NOTE(skip_binders): it's safe to skip binders here as we don't check substitutions.
-            let impl_self_kind = impl_self_ty.skip_binders().kind(Interner);
-
-            match (kind, impl_self_kind) {
-                (TyKind::Adt(id_a, _), TyKind::Adt(id_b, _)) => id_a == id_b,
-                (TyKind::AssociatedType(id_a, _), TyKind::AssociatedType(id_b, _)) => id_a == id_b,
-                (TyKind::Scalar(scalar_a), TyKind::Scalar(scalar_b)) => scalar_a == scalar_b,
-                (TyKind::Error, TyKind::Error)
-                | (TyKind::Str, TyKind::Str)
-                | (TyKind::Slice(_), TyKind::Slice(_))
-                | (TyKind::Never, TyKind::Never)
-                | (TyKind::Array(_, _), TyKind::Array(_, _)) => true,
-                (TyKind::Tuple(arity_a, _), TyKind::Tuple(arity_b, _)) => arity_a == arity_b,
-                (TyKind::OpaqueType(id_a, _), TyKind::OpaqueType(id_b, _)) => id_a == id_b,
-                (TyKind::FnDef(id_a, _), TyKind::FnDef(id_b, _)) => id_a == id_b,
-                (TyKind::Ref(id_a, _, _), TyKind::Ref(id_b, _, _))
-                | (TyKind::Raw(id_a, _), TyKind::Raw(id_b, _)) => id_a == id_b,
-                (TyKind::Closure(id_a, _), TyKind::Closure(id_b, _)) => id_a == id_b,
-                (TyKind::Coroutine(id_a, _), TyKind::Coroutine(id_b, _))
-                | (TyKind::CoroutineWitness(id_a, _), TyKind::CoroutineWitness(id_b, _)) => {
-                    id_a == id_b
-                }
-                (TyKind::Foreign(id_a), TyKind::Foreign(id_b)) => id_a == id_b,
-                (_, _) => false,
-            }
-        };
-
-        if let Some(fp) = self_ty_fp {
-            self.for_trait_impls(trait_id, self_ty_fp, |impls| {
-                match impls.for_trait_and_self_ty(trait_id, fp).any(check_kind) {
-                    true => ControlFlow::Break(()),
-                    false => ControlFlow::Continue(()),
-                }
-            })
-        } else {
-            self.for_trait_impls(trait_id, self_ty_fp, |impls| {
-                match impls.for_trait(trait_id).any(check_kind) {
-                    true => ControlFlow::Break(()),
-                    false => ControlFlow::Continue(()),
-                }
-            })
-        }
-        .is_break()
-    }
-
-    fn associated_ty_value(&self, id: AssociatedTyValueId) -> Arc<AssociatedTyValue> {
-        self.db.associated_ty_value(self.krate, id)
-    }
-
-    fn custom_clauses(&self) -> Vec<chalk_ir::ProgramClause<Interner>> {
-        vec![]
-    }
-    fn local_impls_to_coherence_check(&self, _trait_id: TraitId) -> Vec<ImplId> {
-        // We don't do coherence checking (yet)
-        unimplemented!()
-    }
-    fn interner(&self) -> Interner {
-        Interner
-    }
-    fn well_known_trait_id(
-        &self,
-        well_known_trait: WellKnownTrait,
-    ) -> Option<chalk_ir::TraitId<Interner>> {
-        let lang_item = lang_item_from_well_known_trait(well_known_trait);
-        let trait_ = lang_item.resolve_trait(self.db, self.krate)?;
-        Some(to_chalk_trait_id(trait_))
-    }
-    fn well_known_assoc_type_id(
-        &self,
-        assoc_type: rust_ir::WellKnownAssocType,
-    ) -> Option<chalk_ir::AssocTypeId<Interner>> {
-        let lang_item = match assoc_type {
-            rust_ir::WellKnownAssocType::AsyncFnOnceOutput => LangItem::AsyncFnOnceOutput,
-        };
-        let alias = lang_item.resolve_type_alias(self.db, self.krate)?;
-        Some(to_assoc_type_id(alias))
-    }
-
-    fn program_clauses_for_env(
-        &self,
-        environment: &chalk_ir::Environment<Interner>,
-    ) -> chalk_ir::ProgramClauses<Interner> {
-        self.db.program_clauses_for_chalk_env(self.krate, self.block, environment.clone())
-    }
-
-    fn opaque_ty_data(&self, id: chalk_ir::OpaqueTyId<Interner>) -> Arc<OpaqueTyDatum> {
-        let full_id = self.db.lookup_intern_impl_trait_id(id.into());
-        let bound = match full_id {
-            crate::ImplTraitId::ReturnTypeImplTrait(func, idx) => {
-                let datas = self
-                    .db
-                    .return_type_impl_traits(func)
-                    .expect("impl trait id without impl traits");
-                let (datas, binders) = (*datas).as_ref().into_value_and_skipped_binders();
-                let data = &datas.impl_traits[idx];
-                let bound = OpaqueTyDatumBound {
-                    bounds: make_single_type_binders(data.bounds.skip_binders().to_vec()),
-                    where_clauses: chalk_ir::Binders::empty(Interner, vec![]),
-                };
-                chalk_ir::Binders::new(binders, bound)
-            }
-            crate::ImplTraitId::TypeAliasImplTrait(alias, idx) => {
-                let datas = self
-                    .db
-                    .type_alias_impl_traits(alias)
-                    .expect("impl trait id without impl traits");
-                let (datas, binders) = (*datas).as_ref().into_value_and_skipped_binders();
-                let data = &datas.impl_traits[idx];
-                let bound = OpaqueTyDatumBound {
-                    bounds: make_single_type_binders(data.bounds.skip_binders().to_vec()),
-                    where_clauses: chalk_ir::Binders::empty(Interner, vec![]),
-                };
-                chalk_ir::Binders::new(binders, bound)
-            }
-            crate::ImplTraitId::AsyncBlockTypeImplTrait(..) => {
-                if let Some((future_trait, future_output)) =
-                    LangItem::Future.resolve_trait(self.db, self.krate).and_then(|trait_| {
-                        let alias = trait_
-                            .trait_items(self.db)
-                            .associated_type_by_name(&Name::new_symbol_root(sym::Output))?;
-                        Some((trait_, alias))
-                    })
-                {
-                    // Making up Symbol’s value as variable is void: AsyncBlock<T>:
-                    //
-                    // |--------------------OpaqueTyDatum-------------------|
-                    //        |-------------OpaqueTyDatumBound--------------|
-                    // for<T> <Self> [Future<Self>, Future::Output<Self> = T]
-                    //     ^1  ^0            ^0                    ^0      ^1
-                    let impl_bound = WhereClause::Implemented(TraitRef {
-                        trait_id: to_chalk_trait_id(future_trait),
-                        // Self type as the first parameter.
-                        substitution: Substitution::from1(
-                            Interner,
-                            TyKind::BoundVar(BoundVar {
-                                debruijn: DebruijnIndex::INNERMOST,
-                                index: 0,
-                            })
-                            .intern(Interner),
-                        ),
-                    });
-                    let mut binder = vec![];
-                    binder.push(crate::wrap_empty_binders(impl_bound));
-                    let sized_trait = LangItem::Sized.resolve_trait(self.db, self.krate);
-                    if let Some(sized_trait_) = sized_trait {
-                        let sized_bound = WhereClause::Implemented(TraitRef {
-                            trait_id: to_chalk_trait_id(sized_trait_),
-                            // Self type as the first parameter.
-                            substitution: Substitution::from1(
-                                Interner,
-                                TyKind::BoundVar(BoundVar {
-                                    debruijn: DebruijnIndex::INNERMOST,
-                                    index: 0,
-                                })
-                                .intern(Interner),
-                            ),
-                        });
-                        binder.push(crate::wrap_empty_binders(sized_bound));
-                    }
-                    let proj_bound = WhereClause::AliasEq(AliasEq {
-                        alias: AliasTy::Projection(ProjectionTy {
-                            associated_ty_id: to_assoc_type_id(future_output),
-                            // Self type as the first parameter.
-                            substitution: Substitution::from1(
-                                Interner,
-                                TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0))
-                                    .intern(Interner),
-                            ),
-                        }),
-                        // The parameter of the opaque type.
-                        ty: TyKind::BoundVar(BoundVar { debruijn: DebruijnIndex::ONE, index: 0 })
-                            .intern(Interner),
-                    });
-                    binder.push(crate::wrap_empty_binders(proj_bound));
-                    let bound = OpaqueTyDatumBound {
-                        bounds: make_single_type_binders(binder),
-                        where_clauses: chalk_ir::Binders::empty(Interner, vec![]),
-                    };
-                    // The opaque type has 1 parameter.
-                    make_single_type_binders(bound)
-                } else {
-                    // If failed to find Symbol’s value as variable is void: Future::Output, return empty bounds as fallback.
-                    let bound = OpaqueTyDatumBound {
-                        bounds: chalk_ir::Binders::empty(Interner, vec![]),
-                        where_clauses: chalk_ir::Binders::empty(Interner, vec![]),
-                    };
-                    // The opaque type has 1 parameter.
-                    make_single_type_binders(bound)
-                }
-            }
-        };
-
-        Arc::new(OpaqueTyDatum { opaque_ty_id: id, bound })
-    }
-
-    fn hidden_opaque_type(&self, _id: chalk_ir::OpaqueTyId<Interner>) -> chalk_ir::Ty<Interner> {
-        // FIXME: actually provide the hidden type; it is relevant for auto traits
-        TyKind::Error.intern(Interner)
-    }
-
-    // object safety was renamed to dyn-compatibility but still remains here in chalk.
-    // This will be removed since we are going to migrate to next-gen trait solver.
-    fn is_object_safe(&self, trait_id: chalk_ir::TraitId<Interner>) -> bool {
-        let trait_ = from_chalk_trait_id(trait_id);
-        crate::dyn_compatibility::dyn_compatibility(self.db, trait_).is_none()
-    }
-
-    fn closure_kind(
-        &self,
-        _closure_id: chalk_ir::ClosureId<Interner>,
-        _substs: &chalk_ir::Substitution<Interner>,
-    ) -> rust_ir::ClosureKind {
-        // Fn is the closure kind that implements all three traits
-        rust_ir::ClosureKind::Fn
-    }
-    fn closure_inputs_and_output(
-        &self,
-        _closure_id: chalk_ir::ClosureId<Interner>,
-        substs: &chalk_ir::Substitution<Interner>,
-    ) -> chalk_ir::Binders<rust_ir::FnDefInputsAndOutputDatum<Interner>> {
-        let sig_ty = ClosureSubst(substs).sig_ty();
-        let sig = &sig_ty.callable_sig(self.db).expect("first closure param should be fn ptr");
-        let io = rust_ir::FnDefInputsAndOutputDatum {
-            argument_types: sig.params().to_vec(),
-            return_type: sig.ret().clone(),
-        };
-        chalk_ir::Binders::empty(Interner, io.shifted_in(Interner))
-    }
-    fn closure_upvars(
-        &self,
-        _closure_id: chalk_ir::ClosureId<Interner>,
-        _substs: &chalk_ir::Substitution<Interner>,
-    ) -> chalk_ir::Binders<chalk_ir::Ty<Interner>> {
-        let ty = TyBuilder::unit();
-        chalk_ir::Binders::empty(Interner, ty)
-    }
-    fn closure_fn_substitution(
-        &self,
-        _closure_id: chalk_ir::ClosureId<Interner>,
-        _substs: &chalk_ir::Substitution<Interner>,
-    ) -> chalk_ir::Substitution<Interner> {
-        Substitution::empty(Interner)
-    }
-
-    fn trait_name(&self, trait_id: chalk_ir::TraitId<Interner>) -> String {
-        let id = from_chalk_trait_id(trait_id);
-        self.db.trait_signature(id).name.display(self.db, self.edition()).to_string()
-    }
-    fn adt_name(&self, chalk_ir::AdtId(adt_id): AdtId) -> String {
-        let edition = self.edition();
-        match adt_id {
-            hir_def::AdtId::StructId(id) => {
-                self.db.struct_signature(id).name.display(self.db, edition).to_string()
-            }
-            hir_def::AdtId::EnumId(id) => {
-                self.db.enum_signature(id).name.display(self.db, edition).to_string()
-            }
-            hir_def::AdtId::UnionId(id) => {
-                self.db.union_signature(id).name.display(self.db, edition).to_string()
-            }
-        }
-    }
-    fn adt_size_align(&self, _id: chalk_ir::AdtId<Interner>) -> Arc<rust_ir::AdtSizeAlign> {
-        // FIXME
-        Arc::new(rust_ir::AdtSizeAlign::from_one_zst(false))
-    }
-    fn assoc_type_name(&self, assoc_ty_id: chalk_ir::AssocTypeId<Interner>) -> String {
-        let id = self.db.associated_ty_data(from_assoc_type_id(assoc_ty_id)).name;
-        self.db.type_alias_signature(id).name.display(self.db, self.edition()).to_string()
-    }
-    fn opaque_type_name(&self, opaque_ty_id: chalk_ir::OpaqueTyId<Interner>) -> String {
-        format!("Opaque_{:?}", opaque_ty_id.0)
-    }
-    fn fn_def_name(&self, fn_def_id: chalk_ir::FnDefId<Interner>) -> String {
-        format!("fn_{:?}", fn_def_id.0)
-    }
-    fn coroutine_datum(
-        &self,
-        id: chalk_ir::CoroutineId<Interner>,
-    ) -> Arc<chalk_solve::rust_ir::CoroutineDatum<Interner>> {
-        let InternedCoroutine(parent, expr) = self.db.lookup_intern_coroutine(id.into());
-
-        // We fill substitution with unknown type, because we only need to know whether the generic
-        // params are types or consts to build `Binders` and those being filled up are for
-        // `resume_type`, `yield_type`, and `return_type` of the coroutine in question.
-        let subst = TyBuilder::subst_for_coroutine(self.db, parent).fill_with_unknown().build();
-
-        let len = subst.len(Interner);
-        let input_output = rust_ir::CoroutineInputOutputDatum {
-            resume_type: TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, len - 3))
-                .intern(Interner),
-            yield_type: TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, len - 2))
-                .intern(Interner),
-            return_type: TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, len - 1))
-                .intern(Interner),
-            // FIXME: calculate upvars
-            upvars: vec![],
-        };
-
-        let it = subst
-            .iter(Interner)
-            .map(|it| it.constant(Interner).map(|c| c.data(Interner).ty.clone()));
-        let input_output = crate::make_type_and_const_binders(it, input_output);
-
-        let movability = match self.db.body(parent)[expr] {
-            hir_def::hir::Expr::Closure {
-                closure_kind: hir_def::hir::ClosureKind::Coroutine(movability),
-                ..
-            } => movability,
-            _ => unreachable!("non coroutine expression interned as coroutine"),
-        };
-        let movability = match movability {
-            Movability::Static => rust_ir::Movability::Static,
-            Movability::Movable => rust_ir::Movability::Movable,
-        };
-
-        Arc::new(rust_ir::CoroutineDatum { movability, input_output })
-    }
-    fn coroutine_witness_datum(
-        &self,
-        id: chalk_ir::CoroutineId<Interner>,
-    ) -> Arc<chalk_solve::rust_ir::CoroutineWitnessDatum<Interner>> {
-        // FIXME: calculate inner types
-        let inner_types =
-            rust_ir::CoroutineWitnessExistential { types: wrap_empty_binders(vec![]) };
-
-        let InternedCoroutine(parent, _) = self.db.lookup_intern_coroutine(id.into());
-        // See the comment in `coroutine_datum()` for unknown types.
-        let subst = TyBuilder::subst_for_coroutine(self.db, parent).fill_with_unknown().build();
-        let it = subst
-            .iter(Interner)
-            .map(|it| it.constant(Interner).map(|c| c.data(Interner).ty.clone()));
-        let inner_types = crate::make_type_and_const_binders(it, inner_types);
-
-        Arc::new(rust_ir::CoroutineWitnessDatum { inner_types })
-    }
-
-    fn unification_database(&self) -> &dyn chalk_ir::UnificationDatabase<Interner> {
-        &self.db
-    }
-}
-
-impl ChalkContext<'_> {
-    fn edition(&self) -> Edition {
-        self.krate.data(self.db).edition
-    }
-
-    fn for_trait_impls(
-        &self,
-        trait_id: hir_def::TraitId,
-        self_ty_fp: Option<TyFingerprint>,
-        mut f: impl FnMut(&TraitImpls) -> ControlFlow<()>,
-    ) -> ControlFlow<()> {
-        // Note: Since we're using `impls_for_trait` and `impl_provided_for`,
-        // only impls where the trait can be resolved should ever reach Chalk.
-        // `impl_datum` relies on that and will panic if the trait can't be resolved.
-        let in_deps = self.db.trait_impls_in_deps(self.krate);
-        let in_self = self.db.trait_impls_in_crate(self.krate);
-        let trait_module = trait_id.module(self.db);
-        let type_module = match self_ty_fp {
-            Some(TyFingerprint::Adt(adt_id)) => Some(adt_id.module(self.db)),
-            Some(TyFingerprint::ForeignType(type_id)) => {
-                Some(from_foreign_def_id(type_id).module(self.db))
-            }
-            Some(TyFingerprint::Dyn(trait_id)) => Some(trait_id.module(self.db)),
-            _ => None,
-        };
-
-        let mut def_blocks =
-            [trait_module.containing_block(), type_module.and_then(|it| it.containing_block())];
-
-        let block_impls = iter::successors(self.block, |&block_id| {
-            cov_mark::hit!(block_local_impls);
-            block_id.loc(self.db).module.containing_block()
-        })
-        .inspect(|&block_id| {
-            // make sure we don't search the same block twice
-            def_blocks.iter_mut().for_each(|block| {
-                if *block == Some(block_id) {
-                    *block = None;
-                }
-            });
-        })
-        .filter_map(|block_id| self.db.trait_impls_in_block(block_id));
-        f(&in_self)?;
-        for it in in_deps.iter().map(ops::Deref::deref) {
-            f(it)?;
-        }
-        for it in block_impls {
-            f(&it)?;
-        }
-        for it in def_blocks.into_iter().flatten().filter_map(|it| self.db.trait_impls_in_block(it))
-        {
-            f(&it)?;
-        }
-        ControlFlow::Continue(())
-    }
-}
-
 impl chalk_ir::UnificationDatabase<Interner> for &dyn HirDatabase {
     fn fn_def_variance(
         &self,
@@ -610,15 +54,6 @@ impl chalk_ir::UnificationDatabase<Interner> for &dyn HirDatabase {
     }
 }
 
-pub(crate) fn program_clauses_for_chalk_env_query(
-    db: &dyn HirDatabase,
-    krate: Crate,
-    block: Option<BlockId>,
-    environment: chalk_ir::Environment<Interner>,
-) -> chalk_ir::ProgramClauses<Interner> {
-    chalk_solve::program_clauses_for_env(&ChalkContext { db, krate, block }, &environment)
-}
-
 pub(crate) fn associated_ty_data_query(
     db: &dyn HirDatabase,
     type_alias: TypeAliasId,
@@ -749,31 +184,6 @@ fn well_known_trait_from_lang_item(item: LangItem) -> Option<WellKnownTrait> {
     })
 }
 
-fn lang_item_from_well_known_trait(trait_: WellKnownTrait) -> LangItem {
-    match trait_ {
-        WellKnownTrait::Clone => LangItem::Clone,
-        WellKnownTrait::CoerceUnsized => LangItem::CoerceUnsized,
-        WellKnownTrait::Copy => LangItem::Copy,
-        WellKnownTrait::DiscriminantKind => LangItem::DiscriminantKind,
-        WellKnownTrait::DispatchFromDyn => LangItem::DispatchFromDyn,
-        WellKnownTrait::Drop => LangItem::Drop,
-        WellKnownTrait::Fn => LangItem::Fn,
-        WellKnownTrait::FnMut => LangItem::FnMut,
-        WellKnownTrait::FnOnce => LangItem::FnOnce,
-        WellKnownTrait::AsyncFn => LangItem::AsyncFn,
-        WellKnownTrait::AsyncFnMut => LangItem::AsyncFnMut,
-        WellKnownTrait::AsyncFnOnce => LangItem::AsyncFnOnce,
-        WellKnownTrait::Coroutine => LangItem::Coroutine,
-        WellKnownTrait::Sized => LangItem::Sized,
-        WellKnownTrait::Tuple => LangItem::Tuple,
-        WellKnownTrait::Unpin => LangItem::Unpin,
-        WellKnownTrait::Unsize => LangItem::Unsize,
-        WellKnownTrait::Pointee => LangItem::PointeeTrait,
-        WellKnownTrait::FnPtr => LangItem::FnPtrTrait,
-        WellKnownTrait::Future => LangItem::Future,
-    }
-}
-
 pub(crate) fn adt_datum_query(
     db: &dyn HirDatabase,
     krate: Crate,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/chalk_ext.rs b/src/tools/rust-analyzer/crates/hir-ty/src/chalk_ext.rs
index 836cc96233eb8..8fa1aff0ef636 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/chalk_ext.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/chalk_ext.rs
@@ -14,10 +14,9 @@ use hir_def::{
 use crate::{
     AdtId, AliasEq, AliasTy, Binders, CallableDefId, CallableSig, Canonical, CanonicalVarKinds,
     ClosureId, DynTy, FnPointer, ImplTraitId, InEnvironment, Interner, Lifetime, ProjectionTy,
-    QuantifiedWhereClause, Substitution, TraitRef, Ty, TyBuilder, TyKind, TypeFlags, WhereClause,
-    db::HirDatabase, from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id,
-    from_placeholder_idx, generics::generics, mapping::ToChalk, to_chalk_trait_id,
-    utils::ClosureSubst,
+    QuantifiedWhereClause, Substitution, ToChalk, TraitRef, Ty, TyBuilder, TyKind, TypeFlags,
+    WhereClause, db::HirDatabase, from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id,
+    from_placeholder_idx, generics::generics, to_chalk_trait_id, utils::ClosureSubst,
 };
 
 pub trait TyExt {
@@ -371,7 +370,7 @@ impl TyExt for Ty {
             value: InEnvironment::new(&env.env, trait_ref.cast(Interner)),
             binders: CanonicalVarKinds::empty(Interner),
         };
-        db.trait_solve(crate_id, None, goal).is_some()
+        !db.trait_solve(crate_id, None, goal).no_solution()
     }
 
     fn equals_ctor(&self, other: &Ty) -> bool {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs
index 6449a4dc7e8c6..22b152fe034a6 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs
@@ -11,7 +11,7 @@ use test_utils::skip_slow_tests;
 
 use crate::{
     Const, ConstScalar, Interner, MemoryMap, consteval::try_const_usize, db::HirDatabase,
-    display::DisplayTarget, mir::pad16, test_db::TestDB,
+    display::DisplayTarget, mir::pad16, setup_tracing, test_db::TestDB,
 };
 
 use super::{
@@ -116,6 +116,7 @@ fn pretty_print_err(e: ConstEvalError, db: TestDB) -> String {
 }
 
 fn eval_goal(db: &TestDB, file_id: EditionedFileId) -> Result<Const, ConstEvalError> {
+    let _tracing = setup_tracing();
     let module_id = db.module_for_file(file_id.file_id(db));
     let def_map = module_id.def_map(db);
     let scope = &def_map[module_id.local_id].scope;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs
new file mode 100644
index 0000000000000..da4aff54de378
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs
@@ -0,0 +1,256 @@
+//! Constant evaluation details
+// FIXME(next-solver): this should get removed as things get moved to rustc_type_ir from chalk_ir
+#![allow(unused)]
+
+use base_db::Crate;
+use hir_def::{
+    EnumVariantId, GeneralConstId,
+    expr_store::{Body, HygieneId, path::Path},
+    hir::{Expr, ExprId},
+    resolver::{Resolver, ValueNs},
+    type_ref::LiteralConstRef,
+};
+use hir_expand::Lookup;
+use rustc_type_ir::{
+    UnevaluatedConst,
+    inherent::{IntoKind, SliceLike},
+};
+use stdx::never;
+use triomphe::Arc;
+
+use crate::{
+    ConstScalar, Interner, MemoryMap, Substitution, TraitEnvironment,
+    consteval::ConstEvalError,
+    db::HirDatabase,
+    generics::Generics,
+    infer::InferenceContext,
+    next_solver::{
+        Const, ConstBytes, ConstKind, DbInterner, ErrorGuaranteed, GenericArg, GenericArgs,
+        ParamConst, SolverDefId, Ty, ValueConst,
+        mapping::{ChalkToNextSolver, convert_args_for_result, convert_binder_to_early_binder},
+    },
+};
+
+use super::mir::{interpret_mir, lower_to_mir, pad16};
+
+pub(crate) fn path_to_const<'a, 'g>(
+    db: &'a dyn HirDatabase,
+    resolver: &Resolver<'a>,
+    path: &Path,
+    args: impl FnOnce() -> &'g Generics,
+    expected_ty: Ty<'a>,
+) -> Option<Const<'a>> {
+    let interner = DbInterner::new_with(db, Some(resolver.krate()), None);
+    match resolver.resolve_path_in_value_ns_fully(db, path, HygieneId::ROOT) {
+        Some(ValueNs::GenericParam(p)) => {
+            let args = args();
+            match args
+                .type_or_const_param(p.into())
+                .and_then(|(idx, p)| p.const_param().map(|p| (idx, p.clone())))
+            {
+                Some((idx, _param)) => {
+                    Some(Const::new_param(interner, ParamConst { index: idx as u32 }))
+                }
+                None => {
+                    never!(
+                        "Generic list doesn't contain this param: {:?}, {:?}, {:?}",
+                        args,
+                        path,
+                        p
+                    );
+                    None
+                }
+            }
+        }
+        Some(ValueNs::ConstId(c)) => {
+            let args = GenericArgs::new_from_iter(interner, []);
+            Some(Const::new(
+                interner,
+                rustc_type_ir::ConstKind::Unevaluated(UnevaluatedConst::new(
+                    SolverDefId::ConstId(c),
+                    args,
+                )),
+            ))
+        }
+        _ => None,
+    }
+}
+
+pub fn unknown_const<'db>(ty: Ty<'db>) -> Const<'db> {
+    Const::new(DbInterner::conjure(), rustc_type_ir::ConstKind::Error(ErrorGuaranteed))
+}
+
+pub fn unknown_const_as_generic<'db>(ty: Ty<'db>) -> GenericArg<'db> {
+    unknown_const(ty).into()
+}
+
+/// Interns a constant scalar with the given type
+pub fn intern_const_ref<'a>(
+    db: &'a dyn HirDatabase,
+    value: &LiteralConstRef,
+    ty: Ty<'a>,
+    krate: Crate,
+) -> Const<'a> {
+    let interner = DbInterner::new_with(db, Some(krate), None);
+    let layout = db.layout_of_ty_ns(ty, TraitEnvironment::empty(krate));
+    let kind = match value {
+        LiteralConstRef::Int(i) => {
+            // FIXME: We should handle failure of layout better.
+            let size = layout.map(|it| it.size.bytes_usize()).unwrap_or(16);
+            rustc_type_ir::ConstKind::Value(ValueConst::new(
+                ty,
+                ConstBytes(i.to_le_bytes()[0..size].into(), MemoryMap::default()),
+            ))
+        }
+        LiteralConstRef::UInt(i) => {
+            let size = layout.map(|it| it.size.bytes_usize()).unwrap_or(16);
+            rustc_type_ir::ConstKind::Value(ValueConst::new(
+                ty,
+                ConstBytes(i.to_le_bytes()[0..size].into(), MemoryMap::default()),
+            ))
+        }
+        LiteralConstRef::Bool(b) => rustc_type_ir::ConstKind::Value(ValueConst::new(
+            ty,
+            ConstBytes(Box::new([*b as u8]), MemoryMap::default()),
+        )),
+        LiteralConstRef::Char(c) => rustc_type_ir::ConstKind::Value(ValueConst::new(
+            ty,
+            ConstBytes((*c as u32).to_le_bytes().into(), MemoryMap::default()),
+        )),
+        LiteralConstRef::Unknown => rustc_type_ir::ConstKind::Error(ErrorGuaranteed),
+    };
+    Const::new(interner, kind)
+}
+
+/// Interns a possibly-unknown target usize
+pub fn usize_const<'db>(db: &'db dyn HirDatabase, value: Option<u128>, krate: Crate) -> Const<'db> {
+    intern_const_ref(
+        db,
+        &value.map_or(LiteralConstRef::Unknown, LiteralConstRef::UInt),
+        Ty::new_uint(DbInterner::new_with(db, Some(krate), None), rustc_type_ir::UintTy::Usize),
+        krate,
+    )
+}
+
+pub fn try_const_usize<'db>(db: &'db dyn HirDatabase, c: &Const<'db>) -> Option<u128> {
+    let interner = DbInterner::new_with(db, None, None);
+    match (*c).kind() {
+        ConstKind::Param(_) => None,
+        ConstKind::Infer(_) => None,
+        ConstKind::Bound(_, _) => None,
+        ConstKind::Placeholder(_) => None,
+        ConstKind::Unevaluated(unevaluated_const) => {
+            let c = match unevaluated_const.def {
+                SolverDefId::ConstId(id) => GeneralConstId::ConstId(id),
+                SolverDefId::StaticId(id) => GeneralConstId::StaticId(id),
+                _ => unreachable!(),
+            };
+            let subst = convert_args_for_result(interner, unevaluated_const.args.as_slice());
+            let ec = db.const_eval(c, subst, None).ok()?.to_nextsolver(interner);
+            try_const_usize(db, &ec)
+        }
+        ConstKind::Value(val) => Some(u128::from_le_bytes(pad16(&val.value.inner().0, false))),
+        ConstKind::Error(_) => None,
+        ConstKind::Expr(_) => None,
+    }
+}
+
+pub fn try_const_isize<'db>(db: &'db dyn HirDatabase, c: &Const<'db>) -> Option<i128> {
+    let interner = DbInterner::new_with(db, None, None);
+    match (*c).kind() {
+        ConstKind::Param(_) => None,
+        ConstKind::Infer(_) => None,
+        ConstKind::Bound(_, _) => None,
+        ConstKind::Placeholder(_) => None,
+        ConstKind::Unevaluated(unevaluated_const) => {
+            let c = match unevaluated_const.def {
+                SolverDefId::ConstId(id) => GeneralConstId::ConstId(id),
+                SolverDefId::StaticId(id) => GeneralConstId::StaticId(id),
+                _ => unreachable!(),
+            };
+            let subst = convert_args_for_result(interner, unevaluated_const.args.as_slice());
+            let ec = db.const_eval(c, subst, None).ok()?.to_nextsolver(interner);
+            try_const_isize(db, &ec)
+        }
+        ConstKind::Value(val) => Some(i128::from_le_bytes(pad16(&val.value.inner().0, true))),
+        ConstKind::Error(_) => None,
+        ConstKind::Expr(_) => None,
+    }
+}
+
+pub(crate) fn const_eval_discriminant_variant(
+    db: &dyn HirDatabase,
+    variant_id: EnumVariantId,
+) -> Result<i128, ConstEvalError> {
+    let interner = DbInterner::new_with(db, None, None);
+    let def = variant_id.into();
+    let body = db.body(def);
+    let loc = variant_id.lookup(db);
+    if matches!(body[body.body_expr], Expr::Missing) {
+        let prev_idx = loc.index.checked_sub(1);
+        let value = match prev_idx {
+            Some(prev_idx) => {
+                1 + db.const_eval_discriminant(
+                    loc.parent.enum_variants(db).variants[prev_idx as usize].0,
+                )?
+            }
+            _ => 0,
+        };
+        return Ok(value);
+    }
+
+    let repr = db.enum_signature(loc.parent).repr;
+    let is_signed = repr.and_then(|repr| repr.int).is_none_or(|int| int.is_signed());
+
+    let mir_body = db.monomorphized_mir_body(
+        def,
+        Substitution::empty(Interner),
+        db.trait_environment_for_body(def),
+    )?;
+    let c = interpret_mir(db, mir_body, false, None)?.0?;
+    let c = c.to_nextsolver(interner);
+    let c = if is_signed {
+        try_const_isize(db, &c).unwrap()
+    } else {
+        try_const_usize(db, &c).unwrap() as i128
+    };
+    Ok(c)
+}
+
+// FIXME: Ideally constants in const eval should have separate body (issue #7434), and this function should
+// get an `InferenceResult` instead of an `InferenceContext`. And we should remove `ctx.clone().resolve_all()` here
+// and make this function private. See the fixme comment on `InferenceContext::resolve_all`.
+pub(crate) fn eval_to_const<'db>(expr: ExprId, ctx: &mut InferenceContext<'db>) -> Const<'db> {
+    let interner = DbInterner::new_with(ctx.db, None, None);
+    let infer = ctx.clone().resolve_all();
+    fn has_closure(body: &Body, expr: ExprId) -> bool {
+        if matches!(body[expr], Expr::Closure { .. }) {
+            return true;
+        }
+        let mut r = false;
+        body.walk_child_exprs(expr, |idx| r |= has_closure(body, idx));
+        r
+    }
+    if has_closure(ctx.body, expr) {
+        // Type checking clousres need an isolated body (See the above FIXME). Bail out early to prevent panic.
+        return unknown_const(infer[expr].clone().to_nextsolver(interner));
+    }
+    if let Expr::Path(p) = &ctx.body[expr] {
+        let resolver = &ctx.resolver;
+        if let Some(c) = path_to_const(
+            ctx.db,
+            resolver,
+            p,
+            || ctx.generics(),
+            infer[expr].to_nextsolver(interner),
+        ) {
+            return c;
+        }
+    }
+    if let Ok(mir_body) = lower_to_mir(ctx.db, ctx.owner, ctx.body, &infer, expr)
+        && let Ok((Ok(result), _)) = interpret_mir(ctx.db, Arc::new(mir_body), true, None)
+    {
+        return result.to_nextsolver(interner);
+    }
+    unknown_const(infer[expr].to_nextsolver(interner))
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
index b3d46845c443a..18b8db21161fd 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
@@ -17,7 +17,7 @@ use smallvec::SmallVec;
 use triomphe::Arc;
 
 use crate::{
-    Binders, Const, ImplTraitId, ImplTraits, InferenceResult, Interner, PolyFnSig, Substitution,
+    Binders, Const, ImplTraitId, ImplTraits, InferenceResult, PolyFnSig, Substitution,
     TraitEnvironment, TraitRef, Ty, TyDefId, ValueTyDefId, chalk_db,
     consteval::ConstEvalError,
     drop::DropGlue,
@@ -26,6 +26,7 @@ use crate::{
     lower::{Diagnostics, GenericDefaults, GenericPredicates},
     method_resolution::{InherentImpls, TraitImpls, TyFingerprint},
     mir::{BorrowckResult, MirBody, MirLowerError},
+    traits::NextTraitSolveResult,
 };
 
 #[query_group::query_group]
@@ -295,24 +296,162 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
     ) -> Ty;
 
     #[salsa::invoke(crate::traits::trait_solve_query)]
+    #[salsa::transparent]
     fn trait_solve(
         &self,
         krate: Crate,
         block: Option<BlockId>,
         goal: crate::Canonical<crate::InEnvironment<crate::Goal>>,
-    ) -> Option<crate::Solution>;
-
-    #[salsa::invoke(chalk_db::program_clauses_for_chalk_env_query)]
-    fn program_clauses_for_chalk_env(
-        &self,
-        krate: Crate,
-        block: Option<BlockId>,
-        env: chalk_ir::Environment<Interner>,
-    ) -> chalk_ir::ProgramClauses<Interner>;
+    ) -> NextTraitSolveResult;
 
     #[salsa::invoke(crate::drop::has_drop_glue)]
     #[salsa::cycle(cycle_result = crate::drop::has_drop_glue_cycle_result)]
     fn has_drop_glue(&self, ty: Ty, env: Arc<TraitEnvironment>) -> DropGlue;
+
+    // next trait solver
+
+    #[salsa::invoke(crate::layout::layout_of_adt_ns_query)]
+    #[salsa::cycle(cycle_result = crate::layout::layout_of_adt_ns_cycle_result)]
+    fn layout_of_adt_ns<'db>(
+        &'db self,
+        def: AdtId,
+        args: crate::next_solver::GenericArgs<'db>,
+        trait_env: Arc<TraitEnvironment>,
+    ) -> Result<Arc<Layout>, LayoutError>;
+
+    #[salsa::invoke(crate::layout::layout_of_ty_ns_query)]
+    #[salsa::cycle(cycle_result = crate::layout::layout_of_ty_ns_cycle_result)]
+    fn layout_of_ty_ns<'db>(
+        &'db self,
+        ty: crate::next_solver::Ty<'db>,
+        env: Arc<TraitEnvironment>,
+    ) -> Result<Arc<Layout>, LayoutError>;
+
+    #[salsa::invoke(crate::lower_nextsolver::ty_query)]
+    #[salsa::transparent]
+    fn ty_ns<'db>(
+        &'db self,
+        def: TyDefId,
+    ) -> crate::next_solver::EarlyBinder<'db, crate::next_solver::Ty<'db>>;
+
+    #[salsa::invoke(crate::lower_nextsolver::type_for_type_alias_with_diagnostics_query)]
+    #[salsa::cycle(cycle_result = crate::lower_nextsolver::type_for_type_alias_with_diagnostics_cycle_result)]
+    fn type_for_type_alias_with_diagnostics_ns<'db>(
+        &'db self,
+        def: TypeAliasId,
+    ) -> (crate::next_solver::EarlyBinder<'db, crate::next_solver::Ty<'db>>, Diagnostics);
+
+    #[salsa::invoke(crate::lower_nextsolver::impl_self_ty_with_diagnostics_query)]
+    #[salsa::cycle(cycle_result = crate::lower_nextsolver::impl_self_ty_with_diagnostics_cycle_result)]
+    fn impl_self_ty_with_diagnostics_ns<'db>(
+        &'db self,
+        def: ImplId,
+    ) -> (crate::next_solver::EarlyBinder<'db, crate::next_solver::Ty<'db>>, Diagnostics);
+
+    #[salsa::invoke(crate::lower_nextsolver::impl_self_ty_query)]
+    #[salsa::transparent]
+    fn impl_self_ty_ns<'db>(
+        &'db self,
+        def: ImplId,
+    ) -> crate::next_solver::EarlyBinder<'db, crate::next_solver::Ty<'db>>;
+
+    // FIXME: Make this a non-interned query.
+    #[salsa::invoke_interned(crate::lower_nextsolver::const_param_ty_with_diagnostics_query)]
+    fn const_param_ty_with_diagnostics_ns<'db>(
+        &'db self,
+        def: ConstParamId,
+    ) -> (crate::next_solver::Ty<'db>, Diagnostics);
+
+    #[salsa::invoke(crate::lower_nextsolver::const_param_ty_query)]
+    #[salsa::transparent]
+    fn const_param_ty_ns<'db>(&'db self, def: ConstParamId) -> crate::next_solver::Ty<'db>;
+
+    #[salsa::invoke(crate::lower_nextsolver::impl_trait_with_diagnostics_query)]
+    fn impl_trait_with_diagnostics_ns<'db>(
+        &'db self,
+        def: ImplId,
+    ) -> Option<(
+        crate::next_solver::EarlyBinder<'db, crate::next_solver::TraitRef<'db>>,
+        Diagnostics,
+    )>;
+
+    #[salsa::invoke(crate::lower_nextsolver::impl_trait_query)]
+    #[salsa::transparent]
+    fn impl_trait_ns<'db>(
+        &'db self,
+        def: ImplId,
+    ) -> Option<crate::next_solver::EarlyBinder<'db, crate::next_solver::TraitRef<'db>>>;
+
+    #[salsa::invoke(crate::lower_nextsolver::field_types_with_diagnostics_query)]
+    fn field_types_with_diagnostics_ns<'db>(
+        &'db self,
+        var: VariantId,
+    ) -> (
+        Arc<
+            ArenaMap<
+                LocalFieldId,
+                crate::next_solver::EarlyBinder<'db, crate::next_solver::Ty<'db>>,
+            >,
+        >,
+        Diagnostics,
+    );
+
+    #[salsa::invoke(crate::lower_nextsolver::field_types_query)]
+    #[salsa::transparent]
+    fn field_types_ns<'db>(
+        &'db self,
+        var: VariantId,
+    ) -> Arc<
+        ArenaMap<LocalFieldId, crate::next_solver::EarlyBinder<'db, crate::next_solver::Ty<'db>>>,
+    >;
+
+    #[salsa::invoke(crate::lower_nextsolver::callable_item_signature_query)]
+    fn callable_item_signature_ns<'db>(
+        &'db self,
+        def: CallableDefId,
+    ) -> crate::next_solver::EarlyBinder<'db, crate::next_solver::PolyFnSig<'db>>;
+
+    #[salsa::invoke(crate::lower_nextsolver::return_type_impl_traits)]
+    fn return_type_impl_traits_ns<'db>(
+        &'db self,
+        def: FunctionId,
+    ) -> Option<Arc<crate::next_solver::EarlyBinder<'db, crate::lower_nextsolver::ImplTraits<'db>>>>;
+
+    #[salsa::invoke(crate::lower_nextsolver::type_alias_impl_traits)]
+    fn type_alias_impl_traits_ns<'db>(
+        &'db self,
+        def: TypeAliasId,
+    ) -> Option<Arc<crate::next_solver::EarlyBinder<'db, crate::lower_nextsolver::ImplTraits<'db>>>>;
+
+    #[salsa::invoke(crate::lower_nextsolver::generic_predicates_for_param_query)]
+    #[salsa::cycle(cycle_result = crate::lower_nextsolver::generic_predicates_for_param_cycle_result)]
+    fn generic_predicates_for_param_ns<'db>(
+        &'db self,
+        def: GenericDefId,
+        param_id: TypeOrConstParamId,
+        assoc_name: Option<Name>,
+    ) -> crate::lower_nextsolver::GenericPredicates<'db>;
+
+    #[salsa::invoke(crate::lower_nextsolver::generic_predicates_query)]
+    fn generic_predicates_ns<'db>(
+        &'db self,
+        def: GenericDefId,
+    ) -> crate::lower_nextsolver::GenericPredicates<'db>;
+
+    #[salsa::invoke(
+        crate::lower_nextsolver::generic_predicates_without_parent_with_diagnostics_query
+    )]
+    fn generic_predicates_without_parent_with_diagnostics_ns<'db>(
+        &'db self,
+        def: GenericDefId,
+    ) -> (crate::lower_nextsolver::GenericPredicates<'db>, Diagnostics);
+
+    #[salsa::invoke(crate::lower_nextsolver::generic_predicates_without_parent_query)]
+    #[salsa::transparent]
+    fn generic_predicates_without_parent_ns<'db>(
+        &'db self,
+        def: GenericDefId,
+    ) -> crate::lower_nextsolver::GenericPredicates<'db>;
 }
 
 #[test]
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/drop.rs b/src/tools/rust-analyzer/crates/hir-ty/src/drop.rs
index 5577be890da34..a7e942d92442c 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/drop.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/drop.rs
@@ -187,7 +187,7 @@ fn is_copy(db: &dyn HirDatabase, ty: Ty, env: Arc<TraitEnvironment>) -> bool {
         value: InEnvironment::new(&env.env, trait_ref.cast(Interner)),
         binders: CanonicalVarKinds::empty(Interner),
     };
-    db.trait_solve(env.krate, env.block, goal).is_some()
+    db.trait_solve(env.krate, env.block, goal).certain()
 }
 
 pub(crate) fn has_drop_glue_cycle_result(
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
index 6294d683e6c02..2d21947ec60fc 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
@@ -16,8 +16,8 @@ use rustc_hash::FxHashSet;
 use smallvec::SmallVec;
 
 use crate::{
-    AliasEq, AliasTy, Binders, BoundVar, CallableSig, GoalData, ImplTraitId, Interner, OpaqueTyId,
-    ProjectionTyExt, Solution, Substitution, TraitRef, Ty, TyKind, WhereClause, all_super_traits,
+    AliasEq, AliasTy, Binders, BoundVar, CallableSig, DomainGoal, GoalData, ImplTraitId, Interner,
+    OpaqueTyId, ProjectionTyExt, Substitution, TraitRef, Ty, TyKind, WhereClause, all_super_traits,
     db::HirDatabase,
     from_assoc_type_id, from_chalk_trait_id,
     generics::{generics, trait_self_param_idx},
@@ -510,6 +510,8 @@ fn receiver_is_dispatchable(
         trait_id: to_chalk_trait_id(unsize_did),
         substitution: Substitution::from_iter(Interner, [self_ty.clone(), unsized_self_ty.clone()]),
     });
+    let unsized_predicate =
+        Binders::empty(Interner, unsized_predicate.cast::<DomainGoal>(Interner));
     let trait_predicate = WhereClause::Implemented(TraitRef {
         trait_id: to_chalk_trait_id(trait_),
         substitution: Substitution::from_iter(
@@ -518,18 +520,32 @@ fn receiver_is_dispatchable(
                 .chain(placeholder_subst.iter(Interner).skip(1).cloned()),
         ),
     });
+    let trait_predicate = Binders::empty(Interner, trait_predicate.cast::<DomainGoal>(Interner));
 
     let generic_predicates = &*db.generic_predicates(func.into());
 
-    let clauses = std::iter::once(unsized_predicate)
-        .chain(std::iter::once(trait_predicate))
-        .chain(generic_predicates.iter().map(|pred| {
-            pred.clone().substitute(Interner, &placeholder_subst).into_value_and_skipped_binders().0
-        }))
-        .map(|pred| {
-            pred.cast::<chalk_ir::ProgramClause<Interner>>(Interner).into_from_env_clause(Interner)
-        });
-    let env = chalk_ir::Environment::new(Interner).add_clauses(Interner, clauses);
+    let goals = std::iter::once(unsized_predicate).chain(std::iter::once(trait_predicate)).chain(
+        generic_predicates.iter().map(|pred| {
+            pred.clone()
+                .substitute(Interner, &placeholder_subst)
+                .map(|g| g.cast::<DomainGoal>(Interner))
+        }),
+    );
+    let clauses = chalk_ir::ProgramClauses::from_iter(
+        Interner,
+        goals.into_iter().map(|g| {
+            chalk_ir::ProgramClause::new(
+                Interner,
+                chalk_ir::ProgramClauseData(g.map(|g| chalk_ir::ProgramClauseImplication {
+                    consequence: g,
+                    conditions: chalk_ir::Goals::empty(Interner),
+                    constraints: chalk_ir::Constraints::empty(Interner),
+                    priority: chalk_ir::ClausePriority::High,
+                })),
+            )
+        }),
+    );
+    let env: chalk_ir::Environment<Interner> = chalk_ir::Environment { clauses };
 
     let obligation = WhereClause::Implemented(TraitRef {
         trait_id: to_chalk_trait_id(dispatch_from_dyn_did),
@@ -541,9 +557,8 @@ fn receiver_is_dispatchable(
 
     let mut table = chalk_solve::infer::InferenceTable::<Interner>::new();
     let canonicalized = table.canonicalize(Interner, in_env);
-    let solution = db.trait_solve(krate, None, canonicalized.quantified);
 
-    matches!(solution, Some(Solution::Unique(_)))
+    db.trait_solve(krate, None, canonicalized.quantified).certain()
 }
 
 fn receiver_for_self_ty(db: &dyn HirDatabase, func: FunctionId, ty: Ty) -> Option<Ty> {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility/tests.rs
index 5078e8cfaa8b9..4ffa455084971 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility/tests.rs
@@ -56,18 +56,21 @@ fn check_dyn_compatibility<'a>(
             continue;
         };
         let mut osvs = FxHashSet::default();
-        _ = dyn_compatibility_with_callback(&db, trait_id, &mut |osv| {
-            osvs.insert(match osv {
-                DynCompatibilityViolation::SizedSelf => SizedSelf,
-                DynCompatibilityViolation::SelfReferential => SelfReferential,
-                DynCompatibilityViolation::Method(_, mvc) => Method(mvc),
-                DynCompatibilityViolation::AssocConst(_) => AssocConst,
-                DynCompatibilityViolation::GAT(_) => GAT,
-                DynCompatibilityViolation::HasNonCompatibleSuperTrait(_) => {
-                    HasNonCompatibleSuperTrait
-                }
+        let db = &db;
+        salsa::attach(db, || {
+            _ = dyn_compatibility_with_callback(db, trait_id, &mut |osv| {
+                osvs.insert(match osv {
+                    DynCompatibilityViolation::SizedSelf => SizedSelf,
+                    DynCompatibilityViolation::SelfReferential => SelfReferential,
+                    DynCompatibilityViolation::Method(_, mvc) => Method(mvc),
+                    DynCompatibilityViolation::AssocConst(_) => AssocConst,
+                    DynCompatibilityViolation::GAT(_) => GAT,
+                    DynCompatibilityViolation::HasNonCompatibleSuperTrait(_) => {
+                        HasNonCompatibleSuperTrait
+                    }
+                });
+                ControlFlow::Continue(())
             });
-            ControlFlow::Continue(())
         });
         assert_eq!(osvs, expected, "dyn-compatibility violations for `{name}` do not match;");
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/generics.rs b/src/tools/rust-analyzer/crates/hir-ty/src/generics.rs
index f14872e68c3f5..e6470e5272d05 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/generics.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/generics.rs
@@ -165,6 +165,21 @@ impl Generics {
         (parent_len, self_param, type_params, const_params, impl_trait_params, lifetime_params)
     }
 
+    pub(crate) fn type_or_const_param(
+        &self,
+        param: TypeOrConstParamId,
+    ) -> Option<(usize, TypeOrConstParamData)> {
+        let idx = self.find_type_or_const_param(param)?;
+        self.iter().nth(idx).and_then(|p| {
+            let data = match p.1 {
+                GenericParamDataRef::TypeParamData(p) => p.clone().into(),
+                GenericParamDataRef::ConstParamData(p) => p.clone().into(),
+                _ => return None,
+            };
+            Some((idx, data))
+        })
+    }
+
     pub fn type_or_const_param_idx(&self, param: TypeOrConstParamId) -> Option<usize> {
         self.find_type_or_const_param(param)
     }
@@ -272,7 +287,7 @@ pub(crate) fn trait_self_param_idx(db: &dyn DefDatabase, def: GenericDefId) -> O
     }
 }
 
-fn parent_generic_def(db: &dyn DefDatabase, def: GenericDefId) -> Option<GenericDefId> {
+pub(crate) fn parent_generic_def(db: &dyn DefDatabase, def: GenericDefId) -> Option<GenericDefId> {
     let container = match def {
         GenericDefId::FunctionId(it) => it.lookup(db).container,
         GenericDefId::TypeAliasId(it) => it.lookup(db).container,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
index 86345b23364d3..7a11ec660d04b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
@@ -88,52 +88,54 @@ pub(crate) use closure::{CaptureKind, CapturedItem, CapturedItemWithoutTy};
 
 /// The entry point of type inference.
 pub(crate) fn infer_query(db: &dyn HirDatabase, def: DefWithBodyId) -> Arc<InferenceResult> {
-    let _p = tracing::info_span!("infer_query").entered();
-    let resolver = def.resolver(db);
-    let body = db.body(def);
-    let mut ctx = InferenceContext::new(db, def, &body, resolver);
-
-    match def {
-        DefWithBodyId::FunctionId(f) => {
-            ctx.collect_fn(f);
-        }
-        DefWithBodyId::ConstId(c) => ctx.collect_const(c, &db.const_signature(c)),
-        DefWithBodyId::StaticId(s) => ctx.collect_static(&db.static_signature(s)),
-        DefWithBodyId::VariantId(v) => {
-            ctx.return_ty = TyBuilder::builtin(
-                match db.enum_signature(v.lookup(db).parent).variant_body_type() {
-                    hir_def::layout::IntegerType::Pointer(signed) => match signed {
-                        true => BuiltinType::Int(BuiltinInt::Isize),
-                        false => BuiltinType::Uint(BuiltinUint::Usize),
-                    },
-                    hir_def::layout::IntegerType::Fixed(size, signed) => match signed {
-                        true => BuiltinType::Int(match size {
-                            Integer::I8 => BuiltinInt::I8,
-                            Integer::I16 => BuiltinInt::I16,
-                            Integer::I32 => BuiltinInt::I32,
-                            Integer::I64 => BuiltinInt::I64,
-                            Integer::I128 => BuiltinInt::I128,
-                        }),
-                        false => BuiltinType::Uint(match size {
-                            Integer::I8 => BuiltinUint::U8,
-                            Integer::I16 => BuiltinUint::U16,
-                            Integer::I32 => BuiltinUint::U32,
-                            Integer::I64 => BuiltinUint::U64,
-                            Integer::I128 => BuiltinUint::U128,
-                        }),
+    crate::next_solver::with_new_cache(|| {
+        let _p = tracing::info_span!("infer_query").entered();
+        let resolver = def.resolver(db);
+        let body = db.body(def);
+        let mut ctx = InferenceContext::new(db, def, &body, resolver);
+
+        match def {
+            DefWithBodyId::FunctionId(f) => {
+                ctx.collect_fn(f);
+            }
+            DefWithBodyId::ConstId(c) => ctx.collect_const(c, &db.const_signature(c)),
+            DefWithBodyId::StaticId(s) => ctx.collect_static(&db.static_signature(s)),
+            DefWithBodyId::VariantId(v) => {
+                ctx.return_ty = TyBuilder::builtin(
+                    match db.enum_signature(v.lookup(db).parent).variant_body_type() {
+                        hir_def::layout::IntegerType::Pointer(signed) => match signed {
+                            true => BuiltinType::Int(BuiltinInt::Isize),
+                            false => BuiltinType::Uint(BuiltinUint::Usize),
+                        },
+                        hir_def::layout::IntegerType::Fixed(size, signed) => match signed {
+                            true => BuiltinType::Int(match size {
+                                Integer::I8 => BuiltinInt::I8,
+                                Integer::I16 => BuiltinInt::I16,
+                                Integer::I32 => BuiltinInt::I32,
+                                Integer::I64 => BuiltinInt::I64,
+                                Integer::I128 => BuiltinInt::I128,
+                            }),
+                            false => BuiltinType::Uint(match size {
+                                Integer::I8 => BuiltinUint::U8,
+                                Integer::I16 => BuiltinUint::U16,
+                                Integer::I32 => BuiltinUint::U32,
+                                Integer::I64 => BuiltinUint::U64,
+                                Integer::I128 => BuiltinUint::U128,
+                            }),
+                        },
                     },
-                },
-            );
+                );
+            }
         }
-    }
 
-    ctx.infer_body();
+        ctx.infer_body();
 
-    ctx.infer_mut_body();
+        ctx.infer_mut_body();
 
-    ctx.infer_closures();
+        ctx.infer_closures();
 
-    Arc::new(ctx.resolve_all())
+        Arc::new(ctx.resolve_all())
+    })
 }
 
 pub(crate) fn infer_cycle_result(_: &dyn HirDatabase, _: DefWithBodyId) -> Arc<InferenceResult> {
@@ -144,6 +146,7 @@ pub(crate) fn infer_cycle_result(_: &dyn HirDatabase, _: DefWithBodyId) -> Arc<I
 ///
 /// This is appropriate to use only after type-check: it assumes
 /// that normalization will succeed, for example.
+#[tracing::instrument(level = "debug", skip(db))]
 pub(crate) fn normalize(db: &dyn HirDatabase, trait_env: Arc<TraitEnvironment>, ty: Ty) -> Ty {
     // FIXME: TypeFlags::HAS_CT_PROJECTION is not implemented in chalk, so TypeFlags::HAS_PROJECTION only
     // works for the type case, so we check array unconditionally. Remove the array part
@@ -1077,14 +1080,22 @@ impl<'db> InferenceContext<'db> {
         // Functions might be defining usage sites of TAITs.
         // To define an TAITs, that TAIT must appear in the function's signatures.
         // So, it suffices to check for params and return types.
-        if self
-            .return_ty
-            .data(Interner)
-            .flags
-            .intersects(TypeFlags::HAS_TY_OPAQUE.union(TypeFlags::HAS_TY_INFER))
-        {
-            tait_candidates.insert(self.return_ty.clone());
-        }
+        fold_tys(
+            self.return_ty.clone(),
+            |ty, _| {
+                match ty.kind(Interner) {
+                    TyKind::OpaqueType(..)
+                    | TyKind::Alias(AliasTy::Opaque(..))
+                    | TyKind::InferenceVar(..) => {
+                        tait_candidates.insert(self.return_ty.clone());
+                    }
+                    _ => {}
+                }
+                ty
+            },
+            DebruijnIndex::INNERMOST,
+        );
+
         self.make_tait_coercion_table(tait_candidates.iter());
     }
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
index 8024c1a9a4e92..d8fc20e8741cd 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
@@ -3,12 +3,13 @@
 use std::{cmp, convert::Infallible, mem, ops::ControlFlow};
 
 use chalk_ir::{
-    BoundVar, DebruijnIndex, FnSubst, Mutability, TyKind,
+    BoundVar, DebruijnIndex, FnSubst, GenericArg, Mutability, TyKind,
     cast::Cast,
     fold::{FallibleTypeFolder, Shift, TypeFoldable},
     visit::{TypeSuperVisitable, TypeVisitable, TypeVisitor},
 };
 use either::Either;
+use hir_def::Lookup;
 use hir_def::{
     DefWithBodyId, FieldId, HasModule, TupleFieldId, TupleId, VariantId,
     expr_store::path::Path,
@@ -19,8 +20,8 @@ use hir_def::{
     item_tree::FieldsShape,
     lang_item::LangItem,
     resolver::ValueNs,
+    type_ref::TypeRefId,
 };
-use hir_def::{Lookup, type_ref::TypeRefId};
 use hir_expand::name::Name;
 use intern::sym;
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -30,8 +31,8 @@ use syntax::utils::is_raw_identifier;
 
 use crate::{
     Adjust, Adjustment, AliasEq, AliasTy, Binders, BindingMode, ChalkTraitId, ClosureId, DynTy,
-    DynTyExt, FnAbi, FnPointer, FnSig, GenericArg, Interner, OpaqueTy, ProjectionTy,
-    ProjectionTyExt, Substitution, Ty, TyBuilder, TyExt, WhereClause,
+    DynTyExt, FnAbi, FnPointer, FnSig, Interner, OpaqueTy, ProjectionTy, ProjectionTyExt,
+    Substitution, Ty, TyBuilder, TyExt, WhereClause,
     db::{HirDatabase, InternedClosure, InternedCoroutine},
     error_lifetime, from_assoc_type_id, from_chalk_trait_id, from_placeholder_idx,
     generics::Generics,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
index 761a2564aa799..631a91bac481b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
@@ -13,14 +13,15 @@ use stdx::always;
 use triomphe::Arc;
 
 use crate::{
-    Canonical, DomainGoal, FnAbi, FnPointer, FnSig, Guidance, InEnvironment, Interner, Lifetime,
-    Solution, Substitution, TraitEnvironment, Ty, TyBuilder, TyExt,
+    Canonical, DomainGoal, FnAbi, FnPointer, FnSig, InEnvironment, Interner, Lifetime,
+    Substitution, TraitEnvironment, Ty, TyBuilder, TyExt,
     autoderef::{Autoderef, AutoderefKind},
     db::HirDatabase,
     infer::{
         Adjust, Adjustment, AutoBorrow, InferOk, InferenceContext, OverloadedDeref, PointerCast,
         TypeError, TypeMismatch,
     },
+    traits::NextTraitSolveResult,
     utils::ClosureSubst,
 };
 
@@ -715,13 +716,18 @@ impl InferenceTable<'_> {
         // solve `CoerceUnsized` and `Unsize` goals at this point and leaves the
         // rest for later. Also, there's some logic about sized type variables.
         // Need to find out in what cases this is necessary
-        let solution = self
-            .db
-            .trait_solve(krate, self.trait_env.block, canonicalized.value.clone().cast(Interner))
-            .ok_or(TypeError)?;
+        let solution = self.db.trait_solve(
+            krate,
+            self.trait_env.block,
+            canonicalized.value.clone().cast(Interner),
+        );
 
         match solution {
-            Solution::Unique(v) => {
+            // FIXME: this is a weaker guarantee than Chalk's `Guidance::Unique`
+            // was. Chalk's unique guidance at least guarantees that the real solution
+            // is some "subset" of the solutions matching the guidance, but the
+            // substs for `Certainty::No` don't have that same guarantee (I think).
+            NextTraitSolveResult::Certain(v) => {
                 canonicalized.apply_solution(
                     self,
                     Canonical {
@@ -731,13 +737,12 @@ impl InferenceTable<'_> {
                     },
                 );
             }
-            Solution::Ambig(Guidance::Definite(subst)) => {
-                // FIXME need to record an obligation here
-                canonicalized.apply_solution(self, subst)
+            // ...so, should think about how to get some actually get some guidance here
+            NextTraitSolveResult::Uncertain(..) | NextTraitSolveResult::NoSolution => {
+                return Err(TypeError);
             }
-            // FIXME actually we maybe should also accept unknown guidance here
-            _ => return Err(TypeError),
-        };
+        }
+
         let unsize =
             Adjustment { kind: Adjust::Pointer(PointerCast::Unsize), target: to_ty.clone() };
         let adjustments = match reborrow {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
index 16fc2bfc0631f..261c02386822d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
@@ -278,6 +278,7 @@ impl InferenceContext<'_> {
         }
     }
 
+    #[tracing::instrument(level = "debug", skip(self, is_read), ret)]
     fn infer_expr_inner(
         &mut self,
         tgt_expr: ExprId,
@@ -286,7 +287,9 @@ impl InferenceContext<'_> {
     ) -> Ty {
         self.db.unwind_if_revision_cancelled();
 
-        let ty = match &self.body[tgt_expr] {
+        let expr = &self.body[tgt_expr];
+        tracing::trace!(?expr);
+        let ty = match expr {
             Expr::Missing => self.err_ty(),
             &Expr::If { condition, then_branch, else_branch } => {
                 let expected = &expected.adjust_for_branches(&mut self.table);
@@ -1949,7 +1952,11 @@ impl InferenceContext<'_> {
                     sig.ret().clone(),
                     sig.is_varargs,
                 ),
-                None => ((self.err_ty(), Vec::new()), self.err_ty(), true),
+                None => {
+                    let formal_receiver_ty = self.table.new_type_var();
+                    let ret_ty = self.table.new_type_var();
+                    ((formal_receiver_ty, Vec::new()), ret_ty, true)
+                }
             };
         self.unify(&formal_receiver_ty, &receiver_ty);
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
index c07755535f2a6..a709aebfa9c1b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
@@ -19,11 +19,13 @@ use triomphe::Arc;
 use super::{InferOk, InferResult, InferenceContext, TypeError};
 use crate::{
     AliasEq, AliasTy, BoundVar, Canonical, Const, ConstValue, DebruijnIndex, DomainGoal,
-    GenericArg, GenericArgData, Goal, GoalData, Guidance, InEnvironment, InferenceVar, Interner,
-    Lifetime, OpaqueTyId, ParamKind, ProjectionTy, ProjectionTyExt, Scalar, Solution, Substitution,
-    TraitEnvironment, TraitRef, Ty, TyBuilder, TyExt, TyKind, VariableKind, WhereClause,
-    consteval::unknown_const, db::HirDatabase, fold_generic_args, fold_tys_and_consts,
-    to_chalk_trait_id, traits::FnTrait,
+    GenericArg, GenericArgData, Goal, GoalData, InEnvironment, InferenceVar, Interner, Lifetime,
+    OpaqueTyId, ParamKind, ProjectionTy, ProjectionTyExt, Scalar, Substitution, TraitEnvironment,
+    TraitRef, Ty, TyBuilder, TyExt, TyKind, VariableKind, WhereClause,
+    consteval::unknown_const,
+    db::HirDatabase,
+    fold_generic_args, fold_tys_and_consts, to_chalk_trait_id,
+    traits::{FnTrait, NextTraitSolveResult},
 };
 
 impl InferenceContext<'_> {
@@ -116,9 +118,12 @@ impl<T: HasInterner<Interner = Interner>> Canonicalized<T> {
                 // eagerly replace projections in the type; we may be getting types
                 // e.g. from where clauses where this hasn't happened yet
                 let ty = ctx.normalize_associated_types_in(new_vars.apply(ty.clone(), Interner));
+                tracing::debug!("unifying {:?} {:?}", var, ty);
                 ctx.unify(var.assert_ty_ref(Interner), &ty);
             } else {
-                let _ = ctx.try_unify(var, &new_vars.apply(v.clone(), Interner));
+                let v = new_vars.apply(v.clone(), Interner);
+                tracing::debug!("try_unifying {:?} {:?}", var, v);
+                let _ = ctx.try_unify(var, &v);
             }
         }
     }
@@ -326,6 +331,7 @@ impl<'a> InferenceTable<'a> {
     /// type annotation (e.g. from a let type annotation, field type or function
     /// call). `make_ty` handles this already, but e.g. for field types we need
     /// to do it as well.
+    #[tracing::instrument(skip(self), ret)]
     pub(crate) fn normalize_associated_types_in<T>(&mut self, ty: T) -> T
     where
         T: HasInterner<Interner = Interner> + TypeFoldable<Interner>,
@@ -333,12 +339,88 @@ impl<'a> InferenceTable<'a> {
         fold_tys_and_consts(
             ty,
             |e, _| match e {
-                Either::Left(ty) => Either::Left(match ty.kind(Interner) {
-                    TyKind::Alias(AliasTy::Projection(proj_ty)) => {
-                        self.normalize_projection_ty(proj_ty.clone())
-                    }
-                    _ => ty,
-                }),
+                Either::Left(ty) => {
+                    let ty = self.resolve_ty_shallow(&ty);
+                    tracing::debug!(?ty);
+                    Either::Left(match ty.kind(Interner) {
+                        TyKind::Alias(AliasTy::Projection(proj_ty)) => {
+                            let ty = self.normalize_projection_ty(proj_ty.clone());
+                            self.resolve_ty_shallow(&ty)
+                        }
+                        TyKind::AssociatedType(id, subst) => {
+                            if ty.data(Interner).flags.intersects(
+                                chalk_ir::TypeFlags::HAS_TY_INFER
+                                    | chalk_ir::TypeFlags::HAS_CT_INFER,
+                            ) {
+                                return Either::Left(ty);
+                            }
+                            let var = self.new_type_var();
+                            let proj_ty = chalk_ir::ProjectionTy {
+                                associated_ty_id: *id,
+                                substitution: subst.clone(),
+                            };
+                            let normalize = chalk_ir::Normalize {
+                                alias: AliasTy::Projection(proj_ty),
+                                ty: var.clone(),
+                            };
+                            let goal = chalk_ir::Goal::new(
+                                Interner,
+                                chalk_ir::GoalData::DomainGoal(chalk_ir::DomainGoal::Normalize(
+                                    normalize,
+                                )),
+                            );
+                            let in_env = InEnvironment::new(&self.trait_env.env, goal);
+
+                            let canonicalized = {
+                                let result =
+                                    self.var_unification_table.canonicalize(Interner, in_env);
+                                let free_vars = result
+                                    .free_vars
+                                    .into_iter()
+                                    .map(|free_var| free_var.to_generic_arg(Interner))
+                                    .collect();
+                                Canonicalized { value: result.quantified, free_vars }
+                            };
+                            let solution = self.db.trait_solve(
+                                self.trait_env.krate,
+                                self.trait_env.block,
+                                canonicalized.value.clone(),
+                            );
+                            if let NextTraitSolveResult::Certain(canonical_subst) = solution {
+                                // This is not great :) But let's just assert this for now and come back to it later.
+                                if canonical_subst.value.subst.len(Interner) != 1 {
+                                    ty
+                                } else {
+                                    let normalized = canonical_subst.value.subst.as_slice(Interner)
+                                        [0]
+                                    .assert_ty_ref(Interner);
+                                    match normalized.kind(Interner) {
+                                        TyKind::Alias(AliasTy::Projection(proj_ty)) => {
+                                            if id == &proj_ty.associated_ty_id
+                                                && subst == &proj_ty.substitution
+                                            {
+                                                ty
+                                            } else {
+                                                normalized.clone()
+                                            }
+                                        }
+                                        TyKind::AssociatedType(new_id, new_subst) => {
+                                            if new_id == id && new_subst == subst {
+                                                ty
+                                            } else {
+                                                normalized.clone()
+                                            }
+                                        }
+                                        _ => normalized.clone(),
+                                    }
+                                }
+                            } else {
+                                ty
+                            }
+                        }
+                        _ => ty,
+                    })
+                }
                 Either::Right(c) => Either::Right(match &c.data(Interner).value {
                     chalk_ir::ConstValue::Concrete(cc) => match &cc.interned {
                         crate::ConstScalar::UnevaluatedConst(c_id, subst) => {
@@ -588,7 +670,6 @@ impl<'a> InferenceTable<'a> {
     }
 
     /// Unify two relatable values (e.g. `Ty`) and register new trait goals that arise from that.
-    #[tracing::instrument(skip_all)]
     pub(crate) fn unify<T: ?Sized + Zip<Interner>>(&mut self, ty1: &T, ty2: &T) -> bool {
         let result = match self.try_unify(ty1, ty2) {
             Ok(r) => r,
@@ -606,7 +687,7 @@ impl<'a> InferenceTable<'a> {
         };
         result.goals.iter().all(|goal| {
             let canonicalized = self.canonicalize_with_free_vars(goal.clone());
-            self.try_resolve_obligation(&canonicalized).is_some()
+            self.try_resolve_obligation(&canonicalized).certain()
         })
     }
 
@@ -633,6 +714,9 @@ impl<'a> InferenceTable<'a> {
     /// If `ty` is a type variable with known type, returns that type;
     /// otherwise, return ty.
     pub(crate) fn resolve_ty_shallow(&mut self, ty: &Ty) -> Ty {
+        if !ty.data(Interner).flags.intersects(chalk_ir::TypeFlags::HAS_FREE_LOCAL_NAMES) {
+            return ty.clone();
+        }
         self.resolve_obligations_as_possible();
         self.var_unification_table.normalize_ty_shallow(Interner, ty).unwrap_or_else(|| ty.clone())
     }
@@ -662,7 +746,8 @@ impl<'a> InferenceTable<'a> {
     /// Checks an obligation without registering it. Useful mostly to check
     /// whether a trait *might* be implemented before deciding to 'lock in' the
     /// choice (during e.g. method resolution or deref).
-    pub(crate) fn try_obligation(&mut self, goal: Goal) -> Option<Solution> {
+    #[tracing::instrument(level = "debug", skip(self))]
+    pub(crate) fn try_obligation(&mut self, goal: Goal) -> NextTraitSolveResult {
         let in_env = InEnvironment::new(&self.trait_env.env, goal);
         let canonicalized = self.canonicalize(in_env);
 
@@ -674,10 +759,45 @@ impl<'a> InferenceTable<'a> {
         self.register_obligation_in_env(in_env)
     }
 
+    #[tracing::instrument(level = "debug", skip(self))]
     fn register_obligation_in_env(&mut self, goal: InEnvironment<Goal>) {
-        let canonicalized = self.canonicalize_with_free_vars(goal);
+        match goal.goal.data(Interner) {
+            chalk_ir::GoalData::DomainGoal(chalk_ir::DomainGoal::Holds(
+                chalk_ir::WhereClause::AliasEq(chalk_ir::AliasEq { alias, ty }),
+            )) => {
+                if ty.inference_var(Interner).is_some() {
+                    match alias {
+                        chalk_ir::AliasTy::Opaque(opaque) => {
+                            if self.unify(
+                                &chalk_ir::TyKind::OpaqueType(
+                                    opaque.opaque_ty_id,
+                                    opaque.substitution.clone(),
+                                )
+                                .intern(Interner),
+                                ty,
+                            ) {
+                                return;
+                            }
+                        }
+                        _ => {}
+                    }
+                }
+            }
+            _ => {}
+        }
+        let canonicalized = {
+            let result = self.var_unification_table.canonicalize(Interner, goal);
+            let free_vars = result
+                .free_vars
+                .into_iter()
+                .map(|free_var| free_var.to_generic_arg(Interner))
+                .collect();
+            Canonicalized { value: result.quantified, free_vars }
+        };
+        tracing::debug!(?canonicalized);
         let solution = self.try_resolve_obligation(&canonicalized);
-        if matches!(solution, Some(Solution::Ambig(_))) {
+        tracing::debug!(?solution);
+        if solution.uncertain() {
             self.pending_obligations.push(canonicalized);
         }
     }
@@ -694,7 +814,9 @@ impl<'a> InferenceTable<'a> {
             mem::swap(&mut self.pending_obligations, &mut obligations);
 
             for canonicalized in obligations.drain(..) {
+                tracing::debug!(obligation = ?canonicalized);
                 if !self.check_changed(&canonicalized) {
+                    tracing::debug!("not changed");
                     self.pending_obligations.push(canonicalized);
                     continue;
                 }
@@ -799,37 +921,36 @@ impl<'a> InferenceTable<'a> {
         })
     }
 
+    #[tracing::instrument(level = "debug", skip(self))]
     fn try_resolve_obligation(
         &mut self,
         canonicalized: &Canonicalized<InEnvironment<Goal>>,
-    ) -> Option<chalk_solve::Solution<Interner>> {
+    ) -> NextTraitSolveResult {
         let solution = self.db.trait_solve(
             self.trait_env.krate,
             self.trait_env.block,
             canonicalized.value.clone(),
         );
 
+        tracing::debug!(?solution, ?canonicalized);
         match &solution {
-            Some(Solution::Unique(canonical_subst)) => {
+            NextTraitSolveResult::Certain(v) => {
                 canonicalized.apply_solution(
                     self,
                     Canonical {
-                        binders: canonical_subst.binders.clone(),
-                        // FIXME: handle constraints
-                        value: canonical_subst.value.subst.clone(),
+                        binders: v.binders.clone(),
+                        // FIXME handle constraints
+                        value: v.value.subst.clone(),
                     },
                 );
             }
-            Some(Solution::Ambig(Guidance::Definite(substs))) => {
-                canonicalized.apply_solution(self, substs.clone());
-            }
-            Some(_) => {
-                // FIXME use this when trying to resolve everything at the end
-            }
-            None => {
-                // FIXME obligation cannot be fulfilled => diagnostic
+            // ...so, should think about how to get some actually get some guidance here
+            NextTraitSolveResult::Uncertain(v) => {
+                canonicalized.apply_solution(self, v.clone());
             }
+            NextTraitSolveResult::NoSolution => {}
         }
+
         solution
     }
 
@@ -896,7 +1017,10 @@ impl<'a> InferenceTable<'a> {
                 environment: trait_env.clone(),
             };
             let canonical = self.canonicalize(obligation.clone());
-            if self.db.trait_solve(krate, self.trait_env.block, canonical.cast(Interner)).is_some()
+            if !self
+                .db
+                .trait_solve(krate, self.trait_env.block, canonical.cast(Interner))
+                .no_solution()
             {
                 self.register_obligation(obligation.goal);
                 let return_ty = self.normalize_projection_ty(projection);
@@ -909,10 +1033,10 @@ impl<'a> InferenceTable<'a> {
                             environment: trait_env.clone(),
                         };
                     let canonical = self.canonicalize(obligation.clone());
-                    if self
+                    if !self
                         .db
                         .trait_solve(krate, self.trait_env.block, canonical.cast(Interner))
-                        .is_some()
+                        .no_solution()
                     {
                         return Some((fn_x, arg_tys, return_ty));
                     }
@@ -1032,7 +1156,7 @@ impl<'a> InferenceTable<'a> {
             substitution: Substitution::from1(Interner, ty),
         });
         let goal = GoalData::DomainGoal(chalk_ir::DomainGoal::Holds(sized_pred)).intern(Interner);
-        matches!(self.try_obligation(goal), Some(Solution::Unique(_)))
+        self.try_obligation(goal).certain()
     }
 }
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/interner.rs b/src/tools/rust-analyzer/crates/hir-ty/src/interner.rs
index fecb3f4242a92..57ef5523b4332 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/interner.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/interner.rs
@@ -2,11 +2,10 @@
 //! representation of the various objects Chalk deals with (types, goals etc.).
 
 use crate::{
-    AliasTy, CanonicalVarKind, CanonicalVarKinds, ClosureId, Const, ConstData, ConstScalar,
-    Constraint, Constraints, FnAbi, FnDefId, GenericArg, GenericArgData, Goal, GoalData, Goals,
-    InEnvironment, Lifetime, LifetimeData, OpaqueTy, OpaqueTyId, ProgramClause, ProgramClauseData,
-    ProgramClauses, ProjectionTy, QuantifiedWhereClause, QuantifiedWhereClauses, Substitution, Ty,
-    TyData, TyKind, VariableKind, VariableKinds, chalk_db, tls,
+    AliasTy, CanonicalVarKind, CanonicalVarKinds, ClosureId, Const, ConstData, ConstScalar, FnAbi,
+    FnDefId, GenericArg, GenericArgData, Goal, GoalData, InEnvironment, Lifetime, LifetimeData,
+    OpaqueTy, OpaqueTyId, ProgramClause, ProjectionTy, QuantifiedWhereClause,
+    QuantifiedWhereClauses, Substitution, Ty, TyKind, VariableKind, chalk_db, tls,
 };
 use chalk_ir::{ProgramClauseImplication, SeparatorTraitRef, Variance};
 use hir_def::TypeAliasId;
@@ -15,11 +14,19 @@ use smallvec::SmallVec;
 use std::fmt;
 use triomphe::Arc;
 
+type TyData = chalk_ir::TyData<Interner>;
+type VariableKinds = chalk_ir::VariableKinds<Interner>;
+type Goals = chalk_ir::Goals<Interner>;
+type ProgramClauseData = chalk_ir::ProgramClauseData<Interner>;
+type Constraint = chalk_ir::Constraint<Interner>;
+type Constraints = chalk_ir::Constraints<Interner>;
+type ProgramClauses = chalk_ir::ProgramClauses<Interner>;
+
 #[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
 pub struct Interner;
 
-#[derive(PartialEq, Eq, Hash)]
-pub struct InternedWrapper<T>(T);
+#[derive(PartialEq, Eq, Hash, PartialOrd, Ord, Clone)]
+pub struct InternedWrapper<T>(pub(crate) T);
 
 impl<T: fmt::Debug> fmt::Debug for InternedWrapper<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -27,6 +34,9 @@ impl<T: fmt::Debug> fmt::Debug for InternedWrapper<T> {
     }
 }
 
+#[derive(PartialEq, Eq, Hash, PartialOrd, Ord, Clone)]
+pub struct InternedWrapperNoDebug<T>(pub(crate) T);
+
 impl<T> std::ops::Deref for InternedWrapper<T> {
     type Target = T;
 
@@ -124,6 +134,7 @@ impl chalk_ir::interner::Interner for Interner {
         fmt: &mut fmt::Formatter<'_>,
     ) -> Option<fmt::Result> {
         tls::with_current_program(|prog| Some(prog?.debug_projection_ty(proj, fmt)))
+            .or_else(|| Some(fmt.write_str("ProjectionTy")))
     }
 
     fn debug_opaque_ty(opaque_ty: &OpaqueTy, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
index 107da6a5af6d6..819bd583deaed 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
@@ -2,33 +2,43 @@
 
 use std::fmt;
 
-use chalk_ir::{AdtId, FloatTy, IntTy, TyKind, UintTy};
 use hir_def::{
-    LocalFieldId, StructId,
-    layout::{
-        Float, Integer, LayoutCalculator, LayoutCalculatorError, LayoutData, Primitive,
-        ReprOptions, Scalar, StructKind, TargetDataLayout, WrappingRange,
-    },
+    AdtId, LocalFieldId, StructId,
+    layout::{LayoutCalculatorError, LayoutData},
 };
 use la_arena::{Idx, RawIdx};
-use rustc_abi::AddressSpace;
-use rustc_index::IndexVec;
 
+use rustc_abi::{
+    AddressSpace, Float, Integer, LayoutCalculator, Primitive, ReprOptions, Scalar, StructKind,
+    TargetDataLayout, WrappingRange,
+};
+use rustc_index::IndexVec;
+use rustc_type_ir::{
+    FloatTy, IntTy, UintTy,
+    inherent::{IntoKind, SliceLike},
+};
 use triomphe::Arc;
 
 use crate::{
-    Interner, ProjectionTy, Substitution, TraitEnvironment, Ty,
-    consteval::try_const_usize,
-    db::{HirDatabase, InternedClosure},
-    infer::normalize,
-    utils::ClosureSubst,
+    TraitEnvironment,
+    consteval_nextsolver::try_const_usize,
+    db::HirDatabase,
+    next_solver::{
+        DbInterner, GenericArgs, ParamEnv, SolverDefId, Ty, TyKind, TypingMode,
+        infer::{DbInternerInferExt, traits::ObligationCause},
+        mapping::{ChalkToNextSolver, convert_binder_to_early_binder},
+        project::solve_normalize::deeply_normalize,
+    },
 };
 
-pub(crate) use self::adt::layout_of_adt_cycle_result;
-pub use self::{adt::layout_of_adt_query, target::target_data_layout_query};
+pub(crate) use self::adt::{layout_of_adt_cycle_result, layout_of_adt_ns_cycle_result};
+pub use self::{
+    adt::{layout_of_adt_ns_query, layout_of_adt_query},
+    target::target_data_layout_query,
+};
 
-mod adt;
-mod target;
+pub(crate) mod adt;
+pub(crate) mod target;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct RustcEnumVariantIdx(pub usize);
@@ -119,11 +129,12 @@ impl<'a> LayoutCx<'a> {
     }
 }
 
-fn layout_of_simd_ty(
-    db: &dyn HirDatabase,
+// FIXME: move this to the `rustc_abi`.
+fn layout_of_simd_ty<'db>(
+    db: &'db dyn HirDatabase,
     id: StructId,
     repr_packed: bool,
-    subst: &Substitution,
+    args: &GenericArgs<'db>,
     env: Arc<TraitEnvironment>,
     dl: &TargetDataLayout,
 ) -> Result<Arc<Layout>, LayoutError> {
@@ -132,18 +143,18 @@ fn layout_of_simd_ty(
     // * #[repr(simd)] struct S([T; 4])
     //
     // where T is a primitive scalar (integer/float/pointer).
-    let fields = db.field_types(id.into());
+    let fields = db.field_types_ns(id.into());
     let mut fields = fields.iter();
     let Some(TyKind::Array(e_ty, e_len)) = fields
         .next()
         .filter(|_| fields.next().is_none())
-        .map(|f| f.1.clone().substitute(Interner, subst).kind(Interner).clone())
+        .map(|f| (*f.1).instantiate(DbInterner::new_with(db, None, None), args).kind())
     else {
         return Err(LayoutError::InvalidSimdType);
     };
 
     let e_len = try_const_usize(db, &e_len).ok_or(LayoutError::HasErrorConst)? as u64;
-    let e_ly = db.layout_of_ty(e_ty, env)?;
+    let e_ly = db.layout_of_ty_ns(e_ty, env)?;
 
     let cx = LayoutCx::new(dl);
     Ok(Arc::new(cx.calc.simd_type(e_ly, e_len, repr_packed)?))
@@ -151,108 +162,122 @@ fn layout_of_simd_ty(
 
 pub fn layout_of_ty_query(
     db: &dyn HirDatabase,
-    ty: Ty,
+    ty: crate::Ty,
     trait_env: Arc<TraitEnvironment>,
 ) -> Result<Arc<Layout>, LayoutError> {
     let krate = trait_env.krate;
+    let interner = DbInterner::new_with(db, Some(krate), trait_env.block);
+    db.layout_of_ty_ns(ty.to_nextsolver(interner), trait_env)
+}
+
+pub fn layout_of_ty_ns_query<'db>(
+    db: &'db dyn HirDatabase,
+    ty: Ty<'db>,
+    trait_env: Arc<TraitEnvironment>,
+) -> Result<Arc<Layout>, LayoutError> {
+    let krate = trait_env.krate;
+    let interner = DbInterner::new_with(db, Some(krate), trait_env.block);
     let Ok(target) = db.target_data_layout(krate) else {
         return Err(LayoutError::TargetLayoutNotAvailable);
     };
     let dl = &*target;
     let cx = LayoutCx::new(dl);
-    let ty = normalize(db, trait_env.clone(), ty);
-    let kind = ty.kind(Interner);
-    let result = match kind {
-        TyKind::Adt(AdtId(def), subst) => {
-            if let hir_def::AdtId::StructId(s) = def {
-                let data = db.struct_signature(*s);
-                let repr = data.repr.unwrap_or_default();
-                if repr.simd() {
-                    return layout_of_simd_ty(db, *s, repr.packed(), subst, trait_env, &target);
+    let infer_ctxt = interner.infer_ctxt().build(TypingMode::non_body_analysis());
+    let cause = ObligationCause::dummy();
+    let ty = deeply_normalize(infer_ctxt.at(&cause, ParamEnv::empty()), ty).unwrap_or(ty);
+    let result = match ty.kind() {
+        TyKind::Adt(def, args) => {
+            match def.inner().id {
+                hir_def::AdtId::StructId(s) => {
+                    let data = db.struct_signature(s);
+                    let repr = data.repr.unwrap_or_default();
+                    if repr.simd() {
+                        return layout_of_simd_ty(db, s, repr.packed(), &args, trait_env, &target);
+                    }
                 }
-            };
-            return db.layout_of_adt(*def, subst.clone(), trait_env);
+                _ => {}
+            }
+            return db.layout_of_adt_ns(def.inner().id, args, trait_env);
         }
-        TyKind::Scalar(s) => match s {
-            chalk_ir::Scalar::Bool => Layout::scalar(
-                dl,
-                Scalar::Initialized {
-                    value: Primitive::Int(Integer::I8, false),
-                    valid_range: WrappingRange { start: 0, end: 1 },
-                },
-            ),
-            chalk_ir::Scalar::Char => Layout::scalar(
-                dl,
-                Scalar::Initialized {
-                    value: Primitive::Int(Integer::I32, false),
-                    valid_range: WrappingRange { start: 0, end: 0x10FFFF },
-                },
-            ),
-            chalk_ir::Scalar::Int(i) => Layout::scalar(
+        TyKind::Bool => Layout::scalar(
+            dl,
+            Scalar::Initialized {
+                value: Primitive::Int(Integer::I8, false),
+                valid_range: WrappingRange { start: 0, end: 1 },
+            },
+        ),
+        TyKind::Char => Layout::scalar(
+            dl,
+            Scalar::Initialized {
+                value: Primitive::Int(Integer::I32, false),
+                valid_range: WrappingRange { start: 0, end: 0x10FFFF },
+            },
+        ),
+        TyKind::Int(i) => Layout::scalar(
+            dl,
+            scalar_unit(
                 dl,
-                scalar_unit(
-                    dl,
-                    Primitive::Int(
-                        match i {
-                            IntTy::Isize => dl.ptr_sized_integer(),
-                            IntTy::I8 => Integer::I8,
-                            IntTy::I16 => Integer::I16,
-                            IntTy::I32 => Integer::I32,
-                            IntTy::I64 => Integer::I64,
-                            IntTy::I128 => Integer::I128,
-                        },
-                        true,
-                    ),
+                Primitive::Int(
+                    match i {
+                        IntTy::Isize => dl.ptr_sized_integer(),
+                        IntTy::I8 => Integer::I8,
+                        IntTy::I16 => Integer::I16,
+                        IntTy::I32 => Integer::I32,
+                        IntTy::I64 => Integer::I64,
+                        IntTy::I128 => Integer::I128,
+                    },
+                    true,
                 ),
             ),
-            chalk_ir::Scalar::Uint(i) => Layout::scalar(
+        ),
+        TyKind::Uint(i) => Layout::scalar(
+            dl,
+            scalar_unit(
                 dl,
-                scalar_unit(
-                    dl,
-                    Primitive::Int(
-                        match i {
-                            UintTy::Usize => dl.ptr_sized_integer(),
-                            UintTy::U8 => Integer::I8,
-                            UintTy::U16 => Integer::I16,
-                            UintTy::U32 => Integer::I32,
-                            UintTy::U64 => Integer::I64,
-                            UintTy::U128 => Integer::I128,
-                        },
-                        false,
-                    ),
+                Primitive::Int(
+                    match i {
+                        UintTy::Usize => dl.ptr_sized_integer(),
+                        UintTy::U8 => Integer::I8,
+                        UintTy::U16 => Integer::I16,
+                        UintTy::U32 => Integer::I32,
+                        UintTy::U64 => Integer::I64,
+                        UintTy::U128 => Integer::I128,
+                    },
+                    false,
                 ),
             ),
-            chalk_ir::Scalar::Float(f) => Layout::scalar(
+        ),
+        TyKind::Float(f) => Layout::scalar(
+            dl,
+            scalar_unit(
                 dl,
-                scalar_unit(
-                    dl,
-                    Primitive::Float(match f {
-                        FloatTy::F16 => Float::F16,
-                        FloatTy::F32 => Float::F32,
-                        FloatTy::F64 => Float::F64,
-                        FloatTy::F128 => Float::F128,
-                    }),
-                ),
+                Primitive::Float(match f {
+                    FloatTy::F16 => Float::F16,
+                    FloatTy::F32 => Float::F32,
+                    FloatTy::F64 => Float::F64,
+                    FloatTy::F128 => Float::F128,
+                }),
             ),
-        },
-        TyKind::Tuple(len, tys) => {
-            let kind = if *len == 0 { StructKind::AlwaysSized } else { StructKind::MaybeUnsized };
+        ),
+        TyKind::Tuple(tys) => {
+            let kind =
+                if tys.len() == 0 { StructKind::AlwaysSized } else { StructKind::MaybeUnsized };
 
             let fields = tys
-                .iter(Interner)
-                .map(|k| db.layout_of_ty(k.assert_ty_ref(Interner).clone(), trait_env.clone()))
+                .iter()
+                .map(|k| db.layout_of_ty_ns(k, trait_env.clone()))
                 .collect::<Result<Vec<_>, _>>()?;
             let fields = fields.iter().map(|it| &**it).collect::<Vec<_>>();
             let fields = fields.iter().collect::<IndexVec<_, _>>();
             cx.calc.univariant(&fields, &ReprOptions::default(), kind)?
         }
         TyKind::Array(element, count) => {
-            let count = try_const_usize(db, count).ok_or(LayoutError::HasErrorConst)? as u64;
-            let element = db.layout_of_ty(element.clone(), trait_env)?;
+            let count = try_const_usize(db, &count).ok_or(LayoutError::HasErrorConst)? as u64;
+            let element = db.layout_of_ty_ns(element, trait_env)?;
             cx.calc.array_like::<_, _, ()>(&element, Some(count))?
         }
         TyKind::Slice(element) => {
-            let element = db.layout_of_ty(element.clone(), trait_env)?;
+            let element = db.layout_of_ty_ns(element, trait_env)?;
             cx.calc.array_like::<_, _, ()>(&element, None)?
         }
         TyKind::Str => {
@@ -260,18 +285,21 @@ pub fn layout_of_ty_query(
             cx.calc.array_like::<_, _, ()>(&Layout::scalar(dl, element), None)?
         }
         // Potentially-wide pointers.
-        TyKind::Ref(_, _, pointee) | TyKind::Raw(_, pointee) => {
+        TyKind::Ref(_, pointee, _) | TyKind::RawPtr(pointee, _) => {
             let mut data_ptr = scalar_unit(dl, Primitive::Pointer(AddressSpace::ZERO));
-            if matches!(ty.kind(Interner), TyKind::Ref(..)) {
+            if matches!(ty.kind(), TyKind::Ref(..)) {
                 data_ptr.valid_range_mut().start = 1;
             }
 
+            // FIXME(next-solver)
             // let pointee = tcx.normalize_erasing_regions(param_env, pointee);
             // if pointee.is_sized(tcx.at(DUMMY_SP), param_env) {
-            //     return Ok(tcx.mk_layout(LayoutData::scalar(cx, data_ptr)));
+            //     return Ok(tcx.mk_layout(LayoutS::scalar(cx, data_ptr)));
             // }
 
-            let mut unsized_part = struct_tail_erasing_lifetimes(db, pointee.clone());
+            let unsized_part = struct_tail_erasing_lifetimes(db, pointee);
+            // FIXME(next-solver)
+            /*
             if let TyKind::AssociatedType(id, subst) = unsized_part.kind(Interner) {
                 unsized_part = TyKind::Alias(chalk_ir::AliasTy::Projection(ProjectionTy {
                     associated_ty_id: *id,
@@ -280,11 +308,12 @@ pub fn layout_of_ty_query(
                 .intern(Interner);
             }
             unsized_part = normalize(db, trait_env, unsized_part);
-            let metadata = match unsized_part.kind(Interner) {
+            */
+            let metadata = match unsized_part.kind() {
                 TyKind::Slice(_) | TyKind::Str => {
                     scalar_unit(dl, Primitive::Int(dl.ptr_sized_integer(), false))
                 }
-                TyKind::Dyn(..) => {
+                TyKind::Dynamic(..) => {
                     let mut vtable = scalar_unit(dl, Primitive::Pointer(AddressSpace::ZERO));
                     vtable.valid_range_mut().start = 1;
                     vtable
@@ -299,97 +328,110 @@ pub fn layout_of_ty_query(
             LayoutData::scalar_pair(dl, data_ptr, metadata)
         }
         TyKind::Never => LayoutData::never_type(dl),
-        TyKind::FnDef(..) | TyKind::Dyn(_) | TyKind::Foreign(_) => {
-            let sized = matches!(kind, TyKind::FnDef(..));
-            LayoutData::unit(dl, sized)
-        }
-        TyKind::Function(_) => {
+        TyKind::FnDef(..) => LayoutData::unit(dl, true),
+        TyKind::Dynamic(..) | TyKind::Foreign(_) => LayoutData::unit(dl, false),
+        TyKind::FnPtr(..) => {
             let mut ptr = scalar_unit(dl, Primitive::Pointer(dl.instruction_address_space));
             ptr.valid_range_mut().start = 1;
             Layout::scalar(dl, ptr)
         }
-        TyKind::OpaqueType(opaque_ty_id, _) => {
-            let impl_trait_id = db.lookup_intern_impl_trait_id((*opaque_ty_id).into());
-            match impl_trait_id {
-                crate::ImplTraitId::ReturnTypeImplTrait(func, idx) => {
-                    let infer = db.infer(func.into());
-                    return db.layout_of_ty(infer.type_of_rpit[idx].clone(), trait_env);
-                }
-                crate::ImplTraitId::TypeAliasImplTrait(..) => {
-                    return Err(LayoutError::NotImplemented);
-                }
-                crate::ImplTraitId::AsyncBlockTypeImplTrait(_, _) => {
-                    return Err(LayoutError::NotImplemented);
+        TyKind::Alias(_, ty) => match ty.def_id {
+            SolverDefId::TypeAliasId(_) => {
+                return Err(LayoutError::HasPlaceholder);
+            }
+            SolverDefId::InternedOpaqueTyId(opaque) => {
+                let impl_trait_id = db.lookup_intern_impl_trait_id(opaque);
+                match impl_trait_id {
+                    crate::ImplTraitId::ReturnTypeImplTrait(func, idx) => {
+                        let infer = db.infer(func.into());
+                        return db.layout_of_ty(infer.type_of_rpit[idx].clone(), trait_env);
+                    }
+                    crate::ImplTraitId::TypeAliasImplTrait(..) => {
+                        return Err(LayoutError::NotImplemented);
+                    }
+                    crate::ImplTraitId::AsyncBlockTypeImplTrait(_, _) => {
+                        return Err(LayoutError::NotImplemented);
+                    }
                 }
             }
-        }
-        TyKind::Closure(c, subst) => {
-            let InternedClosure(def, _) = db.lookup_intern_closure((*c).into());
-            let infer = db.infer(def);
-            let (captures, _) = infer.closure_info(c);
+            _ => unreachable!(),
+        },
+        TyKind::Closure(c, args) => {
+            let id = match c {
+                SolverDefId::InternedClosureId(id) => id,
+                _ => unreachable!(),
+            };
+            let def = db.lookup_intern_closure(id);
+            let infer = db.infer(def.0);
+            let (captures, _) = infer.closure_info(&id.into());
             let fields = captures
                 .iter()
                 .map(|it| {
-                    db.layout_of_ty(
-                        it.ty.clone().substitute(Interner, ClosureSubst(subst).parent_subst()),
-                        trait_env.clone(),
-                    )
+                    let ty =
+                        convert_binder_to_early_binder(interner, it.ty.to_nextsolver(interner))
+                            .instantiate(interner, args);
+                    db.layout_of_ty_ns(ty, trait_env.clone())
                 })
                 .collect::<Result<Vec<_>, _>>()?;
             let fields = fields.iter().map(|it| &**it).collect::<Vec<_>>();
             let fields = fields.iter().collect::<IndexVec<_, _>>();
             cx.calc.univariant(&fields, &ReprOptions::default(), StructKind::AlwaysSized)?
         }
-        TyKind::Coroutine(_, _) | TyKind::CoroutineWitness(_, _) => {
+
+        TyKind::Coroutine(_, _)
+        | TyKind::CoroutineWitness(_, _)
+        | TyKind::CoroutineClosure(_, _) => {
             return Err(LayoutError::NotImplemented);
         }
-        TyKind::Error => return Err(LayoutError::HasErrorType),
-        TyKind::AssociatedType(id, subst) => {
-            // Try again with `TyKind::Alias` to normalize the associated type.
-            // Usually we should not try to normalize `TyKind::AssociatedType`, but layout calculation is used
-            // in monomorphized MIR where this is okay. If outside monomorphization, this will lead to cycle,
-            // which we will recover from with an error.
-            let ty = TyKind::Alias(chalk_ir::AliasTy::Projection(ProjectionTy {
-                associated_ty_id: *id,
-                substitution: subst.clone(),
-            }))
-            .intern(Interner);
-            return db.layout_of_ty(ty, trait_env);
+
+        TyKind::Pat(_, _) | TyKind::UnsafeBinder(_) => {
+            return Err(LayoutError::NotImplemented);
+        }
+
+        TyKind::Error(_) => return Err(LayoutError::HasErrorType),
+        TyKind::Placeholder(_) | TyKind::Bound(..) | TyKind::Infer(..) | TyKind::Param(..) => {
+            return Err(LayoutError::HasPlaceholder);
         }
-        TyKind::Alias(_)
-        | TyKind::Placeholder(_)
-        | TyKind::BoundVar(_)
-        | TyKind::InferenceVar(_, _) => return Err(LayoutError::HasPlaceholder),
     };
     Ok(Arc::new(result))
 }
 
 pub(crate) fn layout_of_ty_cycle_result(
     _: &dyn HirDatabase,
-    _: Ty,
+    _: crate::Ty,
+    _: Arc<TraitEnvironment>,
+) -> Result<Arc<Layout>, LayoutError> {
+    Err(LayoutError::RecursiveTypeWithoutIndirection)
+}
+
+pub(crate) fn layout_of_ty_ns_cycle_result<'db>(
+    _: &dyn HirDatabase,
+    _: Ty<'db>,
     _: Arc<TraitEnvironment>,
 ) -> Result<Arc<Layout>, LayoutError> {
     Err(LayoutError::RecursiveTypeWithoutIndirection)
 }
 
-fn struct_tail_erasing_lifetimes(db: &dyn HirDatabase, pointee: Ty) -> Ty {
-    match pointee.kind(Interner) {
-        &TyKind::Adt(AdtId(hir_def::AdtId::StructId(i)), ref subst) => {
-            let data = i.fields(db);
+fn struct_tail_erasing_lifetimes<'a>(db: &'a dyn HirDatabase, pointee: Ty<'a>) -> Ty<'a> {
+    match pointee.kind() {
+        TyKind::Adt(def, args) => {
+            let struct_id = match def.inner().id {
+                AdtId::StructId(id) => id,
+                _ => return pointee,
+            };
+            let data = struct_id.fields(db);
             let mut it = data.fields().iter().rev();
             match it.next() {
                 Some((f, _)) => {
-                    let last_field_ty = field_ty(db, i.into(), f, subst);
+                    let last_field_ty = field_ty(db, struct_id.into(), f, &args);
                     struct_tail_erasing_lifetimes(db, last_field_ty)
                 }
                 None => pointee,
             }
         }
-        TyKind::Tuple(_, subst) => {
-            if let Some(last_field_ty) =
-                subst.iter(Interner).last().and_then(|arg| arg.ty(Interner))
-            {
-                struct_tail_erasing_lifetimes(db, last_field_ty.clone())
+        TyKind::Tuple(tys) => {
+            if let Some(last_field_ty) = tys.iter().last() {
+                struct_tail_erasing_lifetimes(db, last_field_ty)
             } else {
                 pointee
             }
@@ -398,13 +440,13 @@ fn struct_tail_erasing_lifetimes(db: &dyn HirDatabase, pointee: Ty) -> Ty {
     }
 }
 
-fn field_ty(
-    db: &dyn HirDatabase,
+fn field_ty<'a>(
+    db: &'a dyn HirDatabase,
     def: hir_def::VariantId,
     fd: LocalFieldId,
-    subst: &Substitution,
-) -> Ty {
-    db.field_types(def)[fd].clone().substitute(Interner, subst)
+    args: &GenericArgs<'a>,
+) -> Ty<'a> {
+    db.field_types_ns(def)[fd].instantiate(DbInterner::new_with(db, None, None), args)
 }
 
 fn scalar_unit(dl: &TargetDataLayout, value: Primitive) -> Scalar {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs
index 3f310c26ec14a..2fa01b6b41abc 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs
@@ -4,10 +4,10 @@ use std::{cmp, ops::Bound};
 
 use hir_def::{
     AdtId, VariantId,
-    layout::{Integer, ReprOptions, TargetDataLayout},
     signatures::{StructFlags, VariantFields},
 };
 use intern::sym;
+use rustc_abi::{Integer, ReprOptions, TargetDataLayout};
 use rustc_index::IndexVec;
 use smallvec::SmallVec;
 use triomphe::Arc;
@@ -15,16 +15,25 @@ use triomphe::Arc;
 use crate::{
     Substitution, TraitEnvironment,
     db::HirDatabase,
-    layout::{Layout, LayoutError, field_ty},
+    layout::{Layout, LayoutCx, LayoutError, field_ty},
+    next_solver::{DbInterner, GenericArgs, mapping::ChalkToNextSolver},
 };
 
-use super::LayoutCx;
-
 pub fn layout_of_adt_query(
     db: &dyn HirDatabase,
     def: AdtId,
     subst: Substitution,
     trait_env: Arc<TraitEnvironment>,
+) -> Result<Arc<Layout>, LayoutError> {
+    let interner = DbInterner::new_with(db, Some(trait_env.krate), trait_env.block);
+    db.layout_of_adt_ns(def, subst.to_nextsolver(interner), trait_env)
+}
+
+pub fn layout_of_adt_ns_query<'db>(
+    db: &'db dyn HirDatabase,
+    def: AdtId,
+    args: GenericArgs<'db>,
+    trait_env: Arc<TraitEnvironment>,
 ) -> Result<Arc<Layout>, LayoutError> {
     let krate = trait_env.krate;
     let Ok(target) = db.target_data_layout(krate) else {
@@ -35,7 +44,7 @@ pub fn layout_of_adt_query(
     let handle_variant = |def: VariantId, var: &VariantFields| {
         var.fields()
             .iter()
-            .map(|(fd, _)| db.layout_of_ty(field_ty(db, def, fd, &subst), trait_env.clone()))
+            .map(|(fd, _)| db.layout_of_ty_ns(field_ty(db, def, fd, &args), trait_env.clone()))
             .collect::<Result<Vec<_>, _>>()
     };
     let (variants, repr, is_special_no_niche) = match def {
@@ -96,6 +105,24 @@ pub fn layout_of_adt_query(
     Ok(Arc::new(result))
 }
 
+pub(crate) fn layout_of_adt_cycle_result(
+    _: &dyn HirDatabase,
+    _: AdtId,
+    _: Substitution,
+    _: Arc<TraitEnvironment>,
+) -> Result<Arc<Layout>, LayoutError> {
+    Err(LayoutError::RecursiveTypeWithoutIndirection)
+}
+
+pub(crate) fn layout_of_adt_ns_cycle_result<'db>(
+    _: &'db dyn HirDatabase,
+    _def: AdtId,
+    _args: GenericArgs<'db>,
+    _trait_env: Arc<TraitEnvironment>,
+) -> Result<Arc<Layout>, LayoutError> {
+    Err(LayoutError::RecursiveTypeWithoutIndirection)
+}
+
 fn layout_scalar_valid_range(db: &dyn HirDatabase, def: AdtId) -> (Bound<u128>, Bound<u128>) {
     let attrs = db.attrs(def.into());
     let get = |name| {
@@ -120,15 +147,6 @@ fn layout_scalar_valid_range(db: &dyn HirDatabase, def: AdtId) -> (Bound<u128>,
     (get(sym::rustc_layout_scalar_valid_range_start), get(sym::rustc_layout_scalar_valid_range_end))
 }
 
-pub(crate) fn layout_of_adt_cycle_result(
-    _: &dyn HirDatabase,
-    _: AdtId,
-    _: Substitution,
-    _: Arc<TraitEnvironment>,
-) -> Result<Arc<Layout>, LayoutError> {
-    Err(LayoutError::RecursiveTypeWithoutIndirection)
-}
-
 /// Finds the appropriate Integer type and signedness for the given
 /// signed discriminant range and `#[repr]` attribute.
 /// N.B.: `u128` values above `i128::MAX` will be treated as signed, but
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs
index b3bc226ec93c7..93f2e123dca58 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs
@@ -11,6 +11,7 @@ use crate::{
     Interner, Substitution,
     db::HirDatabase,
     layout::{Layout, LayoutError},
+    setup_tracing,
     test_db::TestDB,
 };
 
@@ -29,6 +30,7 @@ fn eval_goal(
     #[rust_analyzer::rust_fixture] ra_fixture: &str,
     minicore: &str,
 ) -> Result<Arc<Layout>, LayoutError> {
+    let _tracing = setup_tracing();
     let target_data_layout = current_machine_data_layout();
     let ra_fixture = format!(
         "//- target_data_layout: {target_data_layout}\n{minicore}//- /main.rs crate:test\n{ra_fixture}",
@@ -97,6 +99,7 @@ fn eval_expr(
     #[rust_analyzer::rust_fixture] ra_fixture: &str,
     minicore: &str,
 ) -> Result<Arc<Layout>, LayoutError> {
+    let _tracing = setup_tracing();
     let target_data_layout = current_machine_data_layout();
     let ra_fixture = format!(
         "//- target_data_layout: {target_data_layout}\n{minicore}//- /main.rs crate:test\nfn main(){{let goal = {{{ra_fixture}}};}}",
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 e787fd9b1e584..2b0dc931eaf4a 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
@@ -21,6 +21,24 @@ extern crate rustc_pattern_analysis;
 #[cfg(not(feature = "in-rust-tree"))]
 extern crate ra_ap_rustc_pattern_analysis as rustc_pattern_analysis;
 
+#[cfg(feature = "in-rust-tree")]
+extern crate rustc_ast_ir;
+
+#[cfg(not(feature = "in-rust-tree"))]
+extern crate ra_ap_rustc_ast_ir as rustc_ast_ir;
+
+#[cfg(feature = "in-rust-tree")]
+extern crate rustc_type_ir;
+
+#[cfg(not(feature = "in-rust-tree"))]
+extern crate ra_ap_rustc_type_ir as rustc_type_ir;
+
+#[cfg(feature = "in-rust-tree")]
+extern crate rustc_next_trait_solver;
+
+#[cfg(not(feature = "in-rust-tree"))]
+extern crate ra_ap_rustc_next_trait_solver as rustc_next_trait_solver;
+
 mod builder;
 mod chalk_db;
 mod chalk_ext;
@@ -29,13 +47,16 @@ mod infer;
 mod inhabitedness;
 mod interner;
 mod lower;
+mod lower_nextsolver;
 mod mapping;
+pub mod next_solver;
 mod target_feature;
 mod tls;
 mod utils;
 
 pub mod autoderef;
 pub mod consteval;
+pub mod consteval_nextsolver;
 pub mod db;
 pub mod diagnostics;
 pub mod display;
@@ -57,7 +78,7 @@ mod variance;
 use std::hash::Hash;
 
 use chalk_ir::{
-    NoSolution,
+    NoSolution, VariableKinds,
     fold::{Shift, TypeFoldable},
     interner::HasInterner,
 };
@@ -121,9 +142,9 @@ pub type ClosureId = chalk_ir::ClosureId<Interner>;
 pub type OpaqueTyId = chalk_ir::OpaqueTyId<Interner>;
 pub type PlaceholderIndex = chalk_ir::PlaceholderIndex;
 
-pub type VariableKind = chalk_ir::VariableKind<Interner>;
-pub type VariableKinds = chalk_ir::VariableKinds<Interner>;
 pub type CanonicalVarKinds = chalk_ir::CanonicalVarKinds<Interner>;
+
+pub(crate) type VariableKind = chalk_ir::VariableKind<Interner>;
 /// Represents generic parameters and an item bound by them. When the item has parent, the binders
 /// also contain the generic parameters for its parent. See chalk's documentation for details.
 ///
@@ -145,52 +166,45 @@ pub type GenericArgData = chalk_ir::GenericArgData<Interner>;
 pub type Ty = chalk_ir::Ty<Interner>;
 pub type TyKind = chalk_ir::TyKind<Interner>;
 pub type TypeFlags = chalk_ir::TypeFlags;
-pub type DynTy = chalk_ir::DynTy<Interner>;
+pub(crate) type DynTy = chalk_ir::DynTy<Interner>;
 pub type FnPointer = chalk_ir::FnPointer<Interner>;
-// pub type FnSubst = chalk_ir::FnSubst<Interner>; // a re-export so we don't lose the tuple constructor
-pub use chalk_ir::FnSubst;
-pub type ProjectionTy = chalk_ir::ProjectionTy<Interner>;
+pub(crate) use chalk_ir::FnSubst; // a re-export so we don't lose the tuple constructor
+
 pub type AliasTy = chalk_ir::AliasTy<Interner>;
-pub type OpaqueTy = chalk_ir::OpaqueTy<Interner>;
-pub type InferenceVar = chalk_ir::InferenceVar;
 
-pub type Lifetime = chalk_ir::Lifetime<Interner>;
-pub type LifetimeData = chalk_ir::LifetimeData<Interner>;
-pub type LifetimeOutlives = chalk_ir::LifetimeOutlives<Interner>;
+pub type ProjectionTy = chalk_ir::ProjectionTy<Interner>;
+pub(crate) type OpaqueTy = chalk_ir::OpaqueTy<Interner>;
+pub(crate) type InferenceVar = chalk_ir::InferenceVar;
+
+pub(crate) type Lifetime = chalk_ir::Lifetime<Interner>;
+pub(crate) type LifetimeData = chalk_ir::LifetimeData<Interner>;
+pub(crate) type LifetimeOutlives = chalk_ir::LifetimeOutlives<Interner>;
 
-pub type Const = chalk_ir::Const<Interner>;
-pub type ConstData = chalk_ir::ConstData<Interner>;
 pub type ConstValue = chalk_ir::ConstValue<Interner>;
-pub type ConcreteConst = chalk_ir::ConcreteConst<Interner>;
 
-pub type ChalkTraitId = chalk_ir::TraitId<Interner>;
+pub type Const = chalk_ir::Const<Interner>;
+pub(crate) type ConstData = chalk_ir::ConstData<Interner>;
+pub(crate) type ConcreteConst = chalk_ir::ConcreteConst<Interner>;
+
 pub type TraitRef = chalk_ir::TraitRef<Interner>;
 pub type QuantifiedWhereClause = Binders<WhereClause>;
-pub type QuantifiedWhereClauses = chalk_ir::QuantifiedWhereClauses<Interner>;
 pub type Canonical<T> = chalk_ir::Canonical<T>;
 
-pub type FnSig = chalk_ir::FnSig<Interner>;
+pub(crate) type ChalkTraitId = chalk_ir::TraitId<Interner>;
+pub(crate) type QuantifiedWhereClauses = chalk_ir::QuantifiedWhereClauses<Interner>;
+
+pub(crate) type FnSig = chalk_ir::FnSig<Interner>;
 
 pub type InEnvironment<T> = chalk_ir::InEnvironment<T>;
-pub type Environment = chalk_ir::Environment<Interner>;
-pub type DomainGoal = chalk_ir::DomainGoal<Interner>;
-pub type Goal = chalk_ir::Goal<Interner>;
 pub type AliasEq = chalk_ir::AliasEq<Interner>;
-pub type Solution = chalk_solve::Solution<Interner>;
-pub type Constraint = chalk_ir::Constraint<Interner>;
-pub type Constraints = chalk_ir::Constraints<Interner>;
-pub type ConstrainedSubst = chalk_ir::ConstrainedSubst<Interner>;
-pub type Guidance = chalk_solve::Guidance<Interner>;
 pub type WhereClause = chalk_ir::WhereClause<Interner>;
 
-pub type CanonicalVarKind = chalk_ir::CanonicalVarKind<Interner>;
-pub type GoalData = chalk_ir::GoalData<Interner>;
-pub type Goals = chalk_ir::Goals<Interner>;
-pub type ProgramClauseData = chalk_ir::ProgramClauseData<Interner>;
-pub type ProgramClause = chalk_ir::ProgramClause<Interner>;
-pub type ProgramClauses = chalk_ir::ProgramClauses<Interner>;
-pub type TyData = chalk_ir::TyData<Interner>;
-pub type Variances = chalk_ir::Variances<Interner>;
+pub(crate) type DomainGoal = chalk_ir::DomainGoal<Interner>;
+pub(crate) type Goal = chalk_ir::Goal<Interner>;
+
+pub(crate) type CanonicalVarKind = chalk_ir::CanonicalVarKind<Interner>;
+pub(crate) type GoalData = chalk_ir::GoalData<Interner>;
+pub(crate) type ProgramClause = chalk_ir::ProgramClause<Interner>;
 
 /// A constant can have reference to other things. Memory map job is holding
 /// the necessary bits of memory of the const eval session to keep the constant
@@ -311,30 +325,11 @@ where
     Binders::empty(Interner, value.shifted_in_from(Interner, DebruijnIndex::ONE))
 }
 
-pub(crate) fn make_type_and_const_binders<T: HasInterner<Interner = Interner>>(
-    which_is_const: impl Iterator<Item = Option<Ty>>,
-    value: T,
-) -> Binders<T> {
-    Binders::new(
-        VariableKinds::from_iter(
-            Interner,
-            which_is_const.map(|x| {
-                if let Some(ty) = x {
-                    chalk_ir::VariableKind::Const(ty)
-                } else {
-                    chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General)
-                }
-            }),
-        ),
-        value,
-    )
-}
-
 pub(crate) fn make_single_type_binders<T: HasInterner<Interner = Interner>>(
     value: T,
 ) -> Binders<T> {
     Binders::new(
-        VariableKinds::from_iter(
+        chalk_ir::VariableKinds::from_iter(
             Interner,
             std::iter::once(chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General)),
         ),
@@ -353,7 +348,7 @@ pub(crate) fn make_binders<T: HasInterner<Interner = Interner>>(
 pub(crate) fn variable_kinds_from_iter(
     db: &dyn HirDatabase,
     iter: impl Iterator<Item = hir_def::GenericParamId>,
-) -> VariableKinds {
+) -> VariableKinds<Interner> {
     VariableKinds::from_iter(
         Interner,
         iter.map(|x| match x {
@@ -918,7 +913,7 @@ pub fn callable_sig_from_fn_trait(
     let obligation =
         InEnvironment { goal: trait_ref.clone().cast(Interner), environment: trait_env.clone() };
     let canonical = table.canonicalize(obligation.clone());
-    if db.trait_solve(krate, block, canonical.cast(Interner)).is_some() {
+    if !db.trait_solve(krate, block, canonical.cast(Interner)).no_solution() {
         table.register_obligation(obligation.goal);
         let return_ty = table.normalize_projection_ty(projection);
         for fn_x in [FnTrait::Fn, FnTrait::FnMut, FnTrait::FnOnce] {
@@ -929,7 +924,7 @@ pub fn callable_sig_from_fn_trait(
                 environment: trait_env.clone(),
             };
             let canonical = table.canonicalize(obligation.clone());
-            if db.trait_solve(krate, block, canonical.cast(Interner)).is_some() {
+            if !db.trait_solve(krate, block, canonical.cast(Interner)).no_solution() {
                 let ret_ty = table.resolve_completely(return_ty);
                 let args_ty = table.resolve_completely(args_ty);
                 let params = args_ty
@@ -985,7 +980,7 @@ impl TypeVisitor<Interner> for PlaceholderCollector<'_> {
         outer_binder: DebruijnIndex,
     ) -> std::ops::ControlFlow<Self::BreakTy> {
         let has_placeholder_bits = TypeFlags::HAS_TY_PLACEHOLDER | TypeFlags::HAS_CT_PLACEHOLDER;
-        let TyData { kind, flags } = ty.data(Interner);
+        let chalk_ir::TyData { kind, flags } = ty.data(Interner);
 
         if let TyKind::Placeholder(idx) = kind {
             self.collect(*idx);
@@ -1045,3 +1040,25 @@ pub(crate) enum DeclOrigin {
 pub(crate) struct DeclContext {
     pub(crate) origin: DeclOrigin,
 }
+
+pub fn setup_tracing() -> Option<tracing::subscriber::DefaultGuard> {
+    use std::env;
+    use std::sync::LazyLock;
+    use tracing_subscriber::{Registry, layer::SubscriberExt};
+    use tracing_tree::HierarchicalLayer;
+
+    static ENABLE: LazyLock<bool> = LazyLock::new(|| env::var("CHALK_DEBUG").is_ok());
+    if !*ENABLE {
+        return None;
+    }
+
+    let filter: tracing_subscriber::filter::Targets =
+        env::var("CHALK_DEBUG").ok().and_then(|it| it.parse().ok()).unwrap_or_default();
+    let layer = HierarchicalLayer::default()
+        .with_indent_lines(true)
+        .with_ansi(false)
+        .with_indent_amount(2)
+        .with_writer(std::io::stderr);
+    let subscriber = Registry::default().with(filter).with(layer);
+    Some(tracing::subscriber::set_default(subscriber))
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
index afee9606bd5f8..7b6b3c3f8181a 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
@@ -46,9 +46,9 @@ use stdx::{impl_from, never};
 use triomphe::{Arc, ThinArc};
 
 use crate::{
-    AliasTy, Binders, BoundVar, CallableSig, Const, DebruijnIndex, DynTy, FnAbi, FnPointer, FnSig,
-    FnSubst, ImplTrait, ImplTraitId, ImplTraits, Interner, Lifetime, LifetimeData,
-    LifetimeOutlives, PolyFnSig, ProgramClause, QuantifiedWhereClause, QuantifiedWhereClauses,
+    AliasTy, Binders, BoundVar, CallableSig, Const, DebruijnIndex, DomainGoal, DynTy, FnAbi,
+    FnPointer, FnSig, FnSubst, ImplTrait, ImplTraitId, ImplTraits, Interner, Lifetime,
+    LifetimeData, LifetimeOutlives, PolyFnSig, QuantifiedWhereClause, QuantifiedWhereClauses,
     Substitution, TraitEnvironment, TraitRef, TraitRefExt, Ty, TyBuilder, TyKind, WhereClause,
     all_super_traits,
     consteval::{intern_const_ref, path_to_const, unknown_const, unknown_const_as_generic},
@@ -81,7 +81,7 @@ impl ImplTraitLoweringState {
     }
 }
 
-pub(crate) struct PathDiagnosticCallbackData(TypeRefId);
+pub(crate) struct PathDiagnosticCallbackData(pub(crate) TypeRefId);
 
 #[derive(Debug, Clone)]
 pub enum LifetimeElisionKind {
@@ -889,7 +889,7 @@ fn named_associated_type_shorthand_candidates<R>(
 
 pub(crate) type Diagnostics = Option<ThinArc<(), TyLoweringDiagnostic>>;
 
-fn create_diagnostics(diagnostics: Vec<TyLoweringDiagnostic>) -> Diagnostics {
+pub(crate) fn create_diagnostics(diagnostics: Vec<TyLoweringDiagnostic>) -> Diagnostics {
     (!diagnostics.is_empty()).then(|| ThinArc::from_header_and_iter((), diagnostics.into_iter()))
 }
 
@@ -1105,8 +1105,9 @@ pub(crate) fn trait_environment_query(
                     traits_in_scope
                         .push((tr.self_type_parameter(Interner).clone(), tr.hir_trait_id()));
                 }
-                let program_clause: chalk_ir::ProgramClause<Interner> = pred.cast(Interner);
-                clauses.push(program_clause.into_from_env_clause(Interner));
+                let program_clause: Binders<DomainGoal> =
+                    pred.map(|pred| pred.into_from_env_goal(Interner).cast(Interner));
+                clauses.push(program_clause);
             }
         }
     }
@@ -1119,7 +1120,10 @@ pub(crate) fn trait_environment_query(
         let substs = TyBuilder::placeholder_subst(db, trait_id);
         let trait_ref = TraitRef { trait_id: to_chalk_trait_id(trait_id), substitution: substs };
         let pred = WhereClause::Implemented(trait_ref);
-        clauses.push(pred.cast::<ProgramClause>(Interner).into_from_env_clause(Interner));
+        clauses.push(Binders::empty(
+            Interner,
+            pred.cast::<DomainGoal>(Interner).into_from_env_goal(Interner),
+        ));
     }
 
     let subst = generics.placeholder_subst(db);
@@ -1128,15 +1132,30 @@ pub(crate) fn trait_environment_query(
         if let Some(implicitly_sized_clauses) =
             implicitly_sized_clauses(db, def, &explicitly_unsized_tys, &subst, &resolver)
         {
-            clauses.extend(
-                implicitly_sized_clauses.map(|pred| {
-                    pred.cast::<ProgramClause>(Interner).into_from_env_clause(Interner)
-                }),
-            );
+            clauses.extend(implicitly_sized_clauses.map(|pred| {
+                Binders::empty(
+                    Interner,
+                    pred.into_from_env_goal(Interner).cast::<DomainGoal>(Interner),
+                )
+            }));
         };
     }
 
-    let env = chalk_ir::Environment::new(Interner).add_clauses(Interner, clauses);
+    let clauses = chalk_ir::ProgramClauses::from_iter(
+        Interner,
+        clauses.into_iter().map(|g| {
+            chalk_ir::ProgramClause::new(
+                Interner,
+                chalk_ir::ProgramClauseData(g.map(|g| chalk_ir::ProgramClauseImplication {
+                    consequence: g,
+                    conditions: chalk_ir::Goals::empty(Interner),
+                    constraints: chalk_ir::Constraints::empty(Interner),
+                    priority: chalk_ir::ClausePriority::High,
+                })),
+            )
+        }),
+    );
+    let env = chalk_ir::Environment { clauses };
 
     TraitEnvironment::new(resolver.krate(), None, traits_in_scope.into_boxed_slice(), env)
 }
@@ -1177,7 +1196,7 @@ pub(crate) fn generic_predicates_without_parent_with_diagnostics_query(
 }
 
 /// Resolve the where clause(s) of an item with generics,
-/// except the ones inherited from the parent
+/// with a given filter
 fn generic_predicates_filtered_by<F>(
     db: &dyn HirDatabase,
     def: GenericDefId,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
new file mode 100644
index 0000000000000..24bda43ca634f
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
@@ -0,0 +1,1609 @@
+//! Methods for lowering the HIR to types. There are two main cases here:
+//!
+//!  - Lowering a type reference like `&usize` or `Option<foo::bar::Baz>` to a
+//!    type: The entry point for this is `TyLoweringContext::lower_ty`.
+//!  - Building the type for an item: This happens through the `ty` query.
+//!
+//! This usually involves resolving names, collecting generic arguments etc.
+#![allow(unused)]
+// FIXME(next-solver): this should get removed as things get moved to rustc_type_ir from chalk_ir
+pub(crate) mod path;
+
+use std::{
+    cell::OnceCell,
+    iter, mem,
+    ops::{self, Not as _},
+};
+
+use base_db::Crate;
+use either::Either;
+use hir_def::{
+    AdtId, AssocItemId, CallableDefId, ConstParamId, EnumVariantId, FunctionId, GenericDefId,
+    GenericParamId, ImplId, ItemContainerId, LocalFieldId, Lookup, StructId, TypeAliasId,
+    TypeOrConstParamId, VariantId,
+    expr_store::{
+        ExpressionStore,
+        path::{GenericArg, Path},
+    },
+    hir::generics::{TypeOrConstParamData, WherePredicate},
+    lang_item::LangItem,
+    resolver::{HasResolver, LifetimeNs, Resolver, TypeNs},
+    signatures::{FunctionSignature, TraitFlags, TypeAliasFlags},
+    type_ref::{
+        ConstRef, LifetimeRefId, LiteralConstRef, PathId, TraitBoundModifier,
+        TraitRef as HirTraitRef, TypeBound, TypeRef, TypeRefId,
+    },
+};
+use hir_expand::name::Name;
+use intern::sym;
+use la_arena::{Arena, ArenaMap, Idx};
+use path::{PathDiagnosticCallback, PathLoweringContext, builtin};
+use rustc_ast_ir::Mutability;
+use rustc_hash::FxHashSet;
+use rustc_pattern_analysis::Captures;
+use rustc_type_ir::{
+    AliasTyKind, ConstKind, DebruijnIndex, ExistentialPredicate, ExistentialProjection,
+    ExistentialTraitRef, FnSig, OutlivesPredicate,
+    TyKind::{self},
+    TypeVisitableExt,
+    inherent::{GenericArg as _, GenericArgs as _, IntoKind as _, Region as _, SliceLike, Ty as _},
+};
+use salsa::plumbing::AsId;
+use stdx::never;
+use triomphe::Arc;
+
+use crate::{
+    FnAbi, ImplTraitId, Interner, ParamKind, TyDefId, TyLoweringDiagnostic,
+    TyLoweringDiagnosticKind,
+    consteval_nextsolver::{intern_const_ref, path_to_const, unknown_const_as_generic},
+    db::HirDatabase,
+    generics::{Generics, generics, trait_self_param_idx},
+    lower::{Diagnostics, PathDiagnosticCallbackData, create_diagnostics},
+    next_solver::{
+        AdtDef, AliasTy, Binder, BoundExistentialPredicates, BoundRegionKind, BoundTyKind,
+        BoundVarKind, BoundVarKinds, Clause, Const, DbInterner, EarlyBinder, EarlyParamRegion,
+        ErrorGuaranteed, GenericArgs, PolyFnSig, Predicate, Region, SolverDefId, TraitPredicate,
+        TraitRef, Ty, Tys, abi::Safety, generics::GenericParamDefKind, mapping::ChalkToNextSolver,
+    },
+};
+
+#[derive(PartialEq, Eq, Debug, Hash)]
+pub struct ImplTraits<'db> {
+    pub(crate) impl_traits: Arena<ImplTrait<'db>>,
+}
+
+#[derive(PartialEq, Eq, Debug, Hash)]
+pub(crate) struct ImplTrait<'db> {
+    pub(crate) predicates: Vec<Clause<'db>>,
+}
+
+pub(crate) type ImplTraitIdx<'db> = Idx<ImplTrait<'db>>;
+
+#[derive(Debug, Default)]
+struct ImplTraitLoweringState<'db> {
+    /// When turning `impl Trait` into opaque types, we have to collect the
+    /// bounds at the same time to get the IDs correct (without becoming too
+    /// complicated).
+    mode: ImplTraitLoweringMode,
+    // This is structured as a struct with fields and not as an enum because it helps with the borrow checker.
+    opaque_type_data: Arena<ImplTrait<'db>>,
+    param_and_variable_counter: u16,
+}
+impl<'db> ImplTraitLoweringState<'db> {
+    fn new(mode: ImplTraitLoweringMode) -> ImplTraitLoweringState<'db> {
+        Self { mode, opaque_type_data: Arena::new(), param_and_variable_counter: 0 }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub(crate) enum LifetimeElisionKind<'db> {
+    /// Create a new anonymous lifetime parameter and reference it.
+    ///
+    /// If `report_in_path`, report an error when encountering lifetime elision in a path:
+    /// ```compile_fail
+    /// struct Foo<'a> { x: &'a () }
+    /// async fn foo(x: Foo) {}
+    /// ```
+    ///
+    /// Note: the error should not trigger when the elided lifetime is in a pattern or
+    /// expression-position path:
+    /// ```
+    /// struct Foo<'a> { x: &'a () }
+    /// async fn foo(Foo { x: _ }: Foo<'_>) {}
+    /// ```
+    AnonymousCreateParameter { report_in_path: bool },
+
+    /// Replace all anonymous lifetimes by provided lifetime.
+    Elided(Region<'db>),
+
+    /// Give a hard error when either `&` or `'_` is written. Used to
+    /// rule out things like `where T: Foo<'_>`. Does not imply an
+    /// error on default object bounds (e.g., `Box<dyn Foo>`).
+    AnonymousReportError,
+
+    /// Resolves elided lifetimes to `'static` if there are no other lifetimes in scope,
+    /// otherwise give a warning that the previous behavior of introducing a new early-bound
+    /// lifetime is a bug and will be removed (if `only_lint` is enabled).
+    StaticIfNoLifetimeInScope { only_lint: bool },
+
+    /// Signal we cannot find which should be the anonymous lifetime.
+    ElisionFailure,
+
+    /// Infer all elided lifetimes.
+    Infer,
+}
+
+impl<'db> LifetimeElisionKind<'db> {
+    #[inline]
+    pub(crate) fn for_const(
+        interner: DbInterner<'db>,
+        const_parent: ItemContainerId,
+    ) -> LifetimeElisionKind<'db> {
+        match const_parent {
+            ItemContainerId::ExternBlockId(_) | ItemContainerId::ModuleId(_) => {
+                LifetimeElisionKind::Elided(Region::new_static(interner))
+            }
+            ItemContainerId::ImplId(_) => {
+                LifetimeElisionKind::StaticIfNoLifetimeInScope { only_lint: true }
+            }
+            ItemContainerId::TraitId(_) => {
+                LifetimeElisionKind::StaticIfNoLifetimeInScope { only_lint: false }
+            }
+        }
+    }
+
+    #[inline]
+    pub(crate) fn for_fn_params(data: &FunctionSignature) -> LifetimeElisionKind<'db> {
+        LifetimeElisionKind::AnonymousCreateParameter { report_in_path: data.is_async() }
+    }
+
+    #[inline]
+    pub(crate) fn for_fn_ret(interner: DbInterner<'db>) -> LifetimeElisionKind<'db> {
+        // FIXME: We should use the elided lifetime here, or `ElisionFailure`.
+        LifetimeElisionKind::Elided(Region::error(interner))
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct TyLoweringContext<'db, 'a> {
+    pub db: &'db dyn HirDatabase,
+    interner: DbInterner<'db>,
+    resolver: &'a Resolver<'db>,
+    store: &'a ExpressionStore,
+    def: GenericDefId,
+    generics: OnceCell<Generics>,
+    in_binders: DebruijnIndex,
+    impl_trait_mode: ImplTraitLoweringState<'db>,
+    /// Tracks types with explicit `?Sized` bounds.
+    pub(crate) unsized_types: FxHashSet<Ty<'db>>,
+    pub(crate) diagnostics: Vec<TyLoweringDiagnostic>,
+    lifetime_elision: LifetimeElisionKind<'db>,
+}
+
+impl<'db, 'a> TyLoweringContext<'db, 'a> {
+    pub(crate) fn new(
+        db: &'db dyn HirDatabase,
+        resolver: &'a Resolver<'db>,
+        store: &'a ExpressionStore,
+        def: GenericDefId,
+        lifetime_elision: LifetimeElisionKind<'db>,
+    ) -> Self {
+        let impl_trait_mode = ImplTraitLoweringState::new(ImplTraitLoweringMode::Disallowed);
+        let in_binders = DebruijnIndex::ZERO;
+        Self {
+            db,
+            interner: DbInterner::new_with(db, Some(resolver.krate()), None),
+            resolver,
+            def,
+            generics: Default::default(),
+            store,
+            in_binders,
+            impl_trait_mode,
+            unsized_types: FxHashSet::default(),
+            diagnostics: Vec::new(),
+            lifetime_elision,
+        }
+    }
+
+    pub(crate) fn with_debruijn<T>(
+        &mut self,
+        debruijn: DebruijnIndex,
+        f: impl FnOnce(&mut TyLoweringContext<'db, '_>) -> T,
+    ) -> T {
+        let old_debruijn = mem::replace(&mut self.in_binders, debruijn);
+        let result = f(self);
+        self.in_binders = old_debruijn;
+        result
+    }
+
+    pub(crate) fn with_shifted_in<T>(
+        &mut self,
+        debruijn: DebruijnIndex,
+        f: impl FnOnce(&mut TyLoweringContext<'db, '_>) -> T,
+    ) -> T {
+        self.with_debruijn(self.in_binders.shifted_in(debruijn.as_u32()), f)
+    }
+
+    pub(crate) fn with_impl_trait_mode(self, impl_trait_mode: ImplTraitLoweringMode) -> Self {
+        Self { impl_trait_mode: ImplTraitLoweringState::new(impl_trait_mode), ..self }
+    }
+
+    pub(crate) fn impl_trait_mode(&mut self, impl_trait_mode: ImplTraitLoweringMode) -> &mut Self {
+        self.impl_trait_mode = ImplTraitLoweringState::new(impl_trait_mode);
+        self
+    }
+
+    pub(crate) fn push_diagnostic(&mut self, type_ref: TypeRefId, kind: TyLoweringDiagnosticKind) {
+        self.diagnostics.push(TyLoweringDiagnostic { source: type_ref, kind });
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Default)]
+pub(crate) enum ImplTraitLoweringMode {
+    /// `impl Trait` gets lowered into an opaque type that doesn't unify with
+    /// anything except itself. This is used in places where values flow 'out',
+    /// i.e. for arguments of the function we're currently checking, and return
+    /// types of functions we're calling.
+    Opaque,
+    /// `impl Trait` is disallowed and will be an error.
+    #[default]
+    Disallowed,
+}
+
+impl<'db, 'a> TyLoweringContext<'db, 'a> {
+    pub(crate) fn lower_ty(&mut self, type_ref: TypeRefId) -> Ty<'db> {
+        self.lower_ty_ext(type_ref).0
+    }
+
+    pub(crate) fn lower_const(&mut self, const_ref: &ConstRef, const_type: Ty<'db>) -> Const<'db> {
+        let const_ref = &self.store[const_ref.expr];
+        match const_ref {
+            hir_def::hir::Expr::Path(path) => {
+                path_to_const(self.db, self.resolver, path, || self.generics(), const_type)
+                    .unwrap_or_else(|| unknown_const(const_type))
+            }
+            hir_def::hir::Expr::Literal(literal) => intern_const_ref(
+                self.db,
+                &match *literal {
+                    hir_def::hir::Literal::Float(_, _)
+                    | hir_def::hir::Literal::String(_)
+                    | hir_def::hir::Literal::ByteString(_)
+                    | hir_def::hir::Literal::CString(_) => LiteralConstRef::Unknown,
+                    hir_def::hir::Literal::Char(c) => LiteralConstRef::Char(c),
+                    hir_def::hir::Literal::Bool(b) => LiteralConstRef::Bool(b),
+                    hir_def::hir::Literal::Int(val, _) => LiteralConstRef::Int(val),
+                    hir_def::hir::Literal::Uint(val, _) => LiteralConstRef::UInt(val),
+                },
+                const_type,
+                self.resolver.krate(),
+            ),
+            _ => unknown_const(const_type),
+        }
+    }
+
+    pub(crate) fn lower_path_as_const(&mut self, path: &Path, const_type: Ty<'db>) -> Const<'db> {
+        path_to_const(self.db, self.resolver, path, || self.generics(), const_type)
+            .unwrap_or_else(|| unknown_const(const_type))
+    }
+
+    fn generics(&self) -> &Generics {
+        self.generics.get_or_init(|| generics(self.db, self.def))
+    }
+
+    #[tracing::instrument(skip(self), ret)]
+    pub(crate) fn lower_ty_ext(&mut self, type_ref_id: TypeRefId) -> (Ty<'db>, Option<TypeNs>) {
+        let interner = self.interner;
+        let mut res = None;
+        let type_ref = &self.store[type_ref_id];
+        tracing::debug!(?type_ref);
+        let ty = match type_ref {
+            TypeRef::Never => Ty::new(interner, TyKind::Never),
+            TypeRef::Tuple(inner) => {
+                let inner_tys = inner.iter().map(|&tr| self.lower_ty(tr));
+                Ty::new_tup_from_iter(interner, inner_tys)
+            }
+            TypeRef::Path(path) => {
+                let (ty, res_) =
+                    self.lower_path(path, PathId::from_type_ref_unchecked(type_ref_id));
+                res = res_;
+                ty
+            }
+            &TypeRef::TypeParam(type_param_id) => {
+                res = Some(TypeNs::GenericParam(type_param_id));
+
+                let generics = self.generics();
+                let (idx, data) =
+                    generics.type_or_const_param(type_param_id.into()).expect("matching generics");
+                let type_data = match data {
+                    TypeOrConstParamData::TypeParamData(ty) => ty,
+                    _ => unreachable!(),
+                };
+                Ty::new_param(
+                    self.interner,
+                    idx as u32,
+                    type_data
+                        .name
+                        .as_ref()
+                        .map_or_else(|| sym::MISSING_NAME.clone(), |d| d.symbol().clone()),
+                )
+            }
+            &TypeRef::RawPtr(inner, mutability) => {
+                let inner_ty = self.lower_ty(inner);
+                Ty::new(interner, TyKind::RawPtr(inner_ty, lower_mutability(mutability)))
+            }
+            TypeRef::Array(array) => {
+                let inner_ty = self.lower_ty(array.ty);
+                let const_len = self.lower_const(&array.len, Ty::new_usize(interner));
+                Ty::new_array_with_const_len(interner, inner_ty, const_len)
+            }
+            &TypeRef::Slice(inner) => {
+                let inner_ty = self.lower_ty(inner);
+                Ty::new_slice(interner, inner_ty)
+            }
+            TypeRef::Reference(ref_) => {
+                let inner_ty = self.lower_ty(ref_.ty);
+                // FIXME: It should infer the eldided lifetimes instead of stubbing with error
+                let lifetime = ref_
+                    .lifetime
+                    .map_or_else(|| Region::error(interner), |lr| self.lower_lifetime(lr));
+                Ty::new_ref(interner, lifetime, inner_ty, lower_mutability(ref_.mutability))
+            }
+            TypeRef::Placeholder => Ty::new_error(interner, ErrorGuaranteed),
+            TypeRef::Fn(fn_) => {
+                let substs = self.with_shifted_in(
+                    DebruijnIndex::from_u32(1),
+                    |ctx: &mut TyLoweringContext<'_, '_>| {
+                        Tys::new_from_iter(
+                            interner,
+                            fn_.params.iter().map(|&(_, tr)| ctx.lower_ty(tr)),
+                        )
+                    },
+                );
+                Ty::new_fn_ptr(
+                    interner,
+                    Binder::dummy(FnSig {
+                        abi: fn_.abi.as_ref().map_or(FnAbi::Rust, FnAbi::from_symbol),
+                        safety: if fn_.is_unsafe { Safety::Unsafe } else { Safety::Safe },
+                        c_variadic: fn_.is_varargs,
+                        inputs_and_output: substs,
+                    }),
+                )
+            }
+            TypeRef::DynTrait(bounds) => self.lower_dyn_trait(bounds),
+            TypeRef::ImplTrait(bounds) => {
+                match self.impl_trait_mode.mode {
+                    ImplTraitLoweringMode::Opaque => {
+                        let origin = match self.resolver.generic_def() {
+                            Some(GenericDefId::FunctionId(it)) => Either::Left(it),
+                            Some(GenericDefId::TypeAliasId(it)) => Either::Right(it),
+                            _ => panic!(
+                                "opaque impl trait lowering must be in function or type alias"
+                            ),
+                        };
+
+                        // this dance is to make sure the data is in the right
+                        // place even if we encounter more opaque types while
+                        // lowering the bounds
+                        let idx = self
+                            .impl_trait_mode
+                            .opaque_type_data
+                            .alloc(ImplTrait { predicates: Vec::default() });
+
+                        // FIXME(next-solver): this from_raw/into_raw dance isn't nice, but it's minimal
+                        let impl_trait_id = origin.either(
+                            |f| ImplTraitId::ReturnTypeImplTrait(f, Idx::from_raw(idx.into_raw())),
+                            |a| ImplTraitId::TypeAliasImplTrait(a, Idx::from_raw(idx.into_raw())),
+                        );
+                        let opaque_ty_id: SolverDefId =
+                            self.db.intern_impl_trait_id(impl_trait_id).into();
+
+                        // We don't want to lower the bounds inside the binders
+                        // we're currently in, because they don't end up inside
+                        // those binders. E.g. when we have `impl Trait<impl
+                        // OtherTrait<T>>`, the `impl OtherTrait<T>` can't refer
+                        // to the self parameter from `impl Trait`, and the
+                        // bounds aren't actually stored nested within each
+                        // other, but separately. So if the `T` refers to a type
+                        // parameter of the outer function, it's just one binder
+                        // away instead of two.
+                        let actual_opaque_type_data = self
+                            .with_debruijn(DebruijnIndex::ZERO, |ctx| {
+                                ctx.lower_impl_trait(opaque_ty_id, bounds, self.resolver.krate())
+                            });
+                        self.impl_trait_mode.opaque_type_data[idx] = actual_opaque_type_data;
+
+                        let args = GenericArgs::identity_for_item(self.interner, opaque_ty_id);
+                        Ty::new_alias(
+                            self.interner,
+                            AliasTyKind::Opaque,
+                            AliasTy::new_from_args(self.interner, opaque_ty_id, args),
+                        )
+                    }
+                    ImplTraitLoweringMode::Disallowed => {
+                        // FIXME: report error
+                        Ty::new_error(self.interner, ErrorGuaranteed)
+                    }
+                }
+            }
+            TypeRef::Error => Ty::new_error(self.interner, ErrorGuaranteed),
+        };
+        (ty, res)
+    }
+
+    /// This is only for `generic_predicates_for_param`, where we can't just
+    /// lower the self types of the predicates since that could lead to cycles.
+    /// So we just check here if the `type_ref` resolves to a generic param, and which.
+    fn lower_ty_only_param(&self, type_ref: TypeRefId) -> Option<TypeOrConstParamId> {
+        let type_ref = &self.store[type_ref];
+        let path = match type_ref {
+            TypeRef::Path(path) => path,
+            &TypeRef::TypeParam(idx) => return Some(idx.into()),
+            _ => return None,
+        };
+        if path.type_anchor().is_some() {
+            return None;
+        }
+        if path.segments().len() > 1 {
+            return None;
+        }
+        let resolution = match self.resolver.resolve_path_in_type_ns(self.db, path) {
+            Some((it, None, _)) => it,
+            _ => return None,
+        };
+        match resolution {
+            TypeNs::GenericParam(param_id) => Some(param_id.into()),
+            _ => None,
+        }
+    }
+
+    #[inline]
+    fn on_path_diagnostic_callback(type_ref: TypeRefId) -> PathDiagnosticCallback<'static, 'db> {
+        PathDiagnosticCallback {
+            data: Either::Left(PathDiagnosticCallbackData(type_ref)),
+            callback: |data, this, diag| {
+                let type_ref = data.as_ref().left().unwrap().0;
+                this.push_diagnostic(type_ref, TyLoweringDiagnosticKind::PathDiagnostic(diag))
+            },
+        }
+    }
+
+    #[inline]
+    fn at_path(&mut self, path_id: PathId) -> PathLoweringContext<'_, 'a, 'db> {
+        PathLoweringContext::new(
+            self,
+            Self::on_path_diagnostic_callback(path_id.type_ref()),
+            &self.store[path_id],
+        )
+    }
+
+    pub(crate) fn lower_path(&mut self, path: &Path, path_id: PathId) -> (Ty<'db>, Option<TypeNs>) {
+        // Resolve the path (in type namespace)
+        if let Some(type_ref) = path.type_anchor() {
+            let (ty, res) = self.lower_ty_ext(type_ref);
+            let mut ctx = self.at_path(path_id);
+            return ctx.lower_ty_relative_path(ty, res);
+        }
+
+        let mut ctx = self.at_path(path_id);
+        let (resolution, remaining_index) = match ctx.resolve_path_in_type_ns() {
+            Some(it) => it,
+            None => return (Ty::new_error(self.interner, ErrorGuaranteed), None),
+        };
+
+        if matches!(resolution, TypeNs::TraitId(_)) && remaining_index.is_none() {
+            // trait object type without dyn
+            let bound = TypeBound::Path(path_id, TraitBoundModifier::None);
+            let ty = self.lower_dyn_trait(&[bound]);
+            return (ty, None);
+        }
+
+        ctx.lower_partly_resolved_path(resolution, false)
+    }
+
+    fn lower_trait_ref_from_path(
+        &mut self,
+        path_id: PathId,
+        explicit_self_ty: Ty<'db>,
+    ) -> Option<(TraitRef<'db>, PathLoweringContext<'_, 'a, 'db>)> {
+        let mut ctx = self.at_path(path_id);
+        let resolved = match ctx.resolve_path_in_type_ns_fully()? {
+            // FIXME(trait_alias): We need to handle trait alias here.
+            TypeNs::TraitId(tr) => tr,
+            _ => return None,
+        };
+        Some((ctx.lower_trait_ref_from_resolved_path(resolved, explicit_self_ty), ctx))
+    }
+
+    fn lower_trait_ref(
+        &mut self,
+        trait_ref: &HirTraitRef,
+        explicit_self_ty: Ty<'db>,
+    ) -> Option<TraitRef<'db>> {
+        self.lower_trait_ref_from_path(trait_ref.path, explicit_self_ty).map(|it| it.0)
+    }
+
+    pub(crate) fn lower_where_predicate<'b>(
+        &'b mut self,
+        where_predicate: &'b WherePredicate,
+        ignore_bindings: bool,
+        generics: &Generics,
+        predicate_filter: PredicateFilter,
+    ) -> impl Iterator<Item = Clause<'db>> + use<'a, 'b, 'db> {
+        match where_predicate {
+            WherePredicate::ForLifetime { target, bound, .. }
+            | WherePredicate::TypeBound { target, bound } => {
+                if let PredicateFilter::SelfTrait = predicate_filter {
+                    let target_type = &self.store[*target];
+                    let self_type = 'is_self: {
+                        if let TypeRef::Path(path) = target_type
+                            && path.is_self_type()
+                        {
+                            break 'is_self true;
+                        }
+                        if let TypeRef::TypeParam(param) = target_type
+                            && generics[param.local_id()].is_trait_self()
+                        {
+                            break 'is_self true;
+                        }
+                        false
+                    };
+                    if !self_type {
+                        return Either::Left(Either::Left(iter::empty()));
+                    }
+                }
+                let self_ty = self.lower_ty(*target);
+                Either::Left(Either::Right(self.lower_type_bound(bound, self_ty, ignore_bindings)))
+            }
+            &WherePredicate::Lifetime { bound, target } => {
+                Either::Right(iter::once(Clause(Predicate::new(
+                    self.interner,
+                    Binder::dummy(rustc_type_ir::PredicateKind::Clause(
+                        rustc_type_ir::ClauseKind::RegionOutlives(OutlivesPredicate(
+                            self.lower_lifetime(bound),
+                            self.lower_lifetime(target),
+                        )),
+                    )),
+                ))))
+            }
+        }
+        .into_iter()
+    }
+
+    pub(crate) fn lower_type_bound<'b>(
+        &'b mut self,
+        bound: &'b TypeBound,
+        self_ty: Ty<'db>,
+        ignore_bindings: bool,
+    ) -> impl Iterator<Item = Clause<'db>> + use<'b, 'a, 'db> {
+        let interner = self.interner;
+        let mut assoc_bounds = None;
+        let mut clause = None;
+        match bound {
+            &TypeBound::Path(path, TraitBoundModifier::None) | &TypeBound::ForLifetime(_, path) => {
+                // FIXME Don't silently drop the hrtb lifetimes here
+                if let Some((trait_ref, mut ctx)) = self.lower_trait_ref_from_path(path, self_ty) {
+                    // FIXME(sized-hierarchy): Remove this bound modifications once we have implemented
+                    // sized-hierarchy correctly.
+                    let meta_sized = LangItem::MetaSized
+                        .resolve_trait(ctx.ty_ctx().db, ctx.ty_ctx().resolver.krate());
+                    let pointee_sized = LangItem::PointeeSized
+                        .resolve_trait(ctx.ty_ctx().db, ctx.ty_ctx().resolver.krate());
+                    if meta_sized.is_some_and(|it| SolverDefId::TraitId(it) == trait_ref.def_id) {
+                        // Ignore this bound
+                    } else if pointee_sized
+                        .is_some_and(|it| SolverDefId::TraitId(it) == trait_ref.def_id)
+                    {
+                        // Regard this as `?Sized` bound
+                        ctx.ty_ctx().unsized_types.insert(self_ty);
+                    } else {
+                        if !ignore_bindings {
+                            assoc_bounds = ctx.assoc_type_bindings_from_type_bound(trait_ref);
+                        }
+                        clause = Some(Clause(Predicate::new(
+                            interner,
+                            Binder::dummy(rustc_type_ir::PredicateKind::Clause(
+                                rustc_type_ir::ClauseKind::Trait(TraitPredicate {
+                                    trait_ref,
+                                    polarity: rustc_type_ir::PredicatePolarity::Positive,
+                                }),
+                            )),
+                        )));
+                    }
+                }
+            }
+            &TypeBound::Path(path, TraitBoundModifier::Maybe) => {
+                let sized_trait = LangItem::Sized.resolve_trait(self.db, self.resolver.krate());
+                // Don't lower associated type bindings as the only possible relaxed trait bound
+                // `?Sized` has no of them.
+                // If we got another trait here ignore the bound completely.
+                let trait_id =
+                    self.lower_trait_ref_from_path(path, self_ty).map(|(trait_ref, _)| {
+                        match trait_ref.def_id {
+                            SolverDefId::TraitId(id) => id,
+                            _ => unreachable!(),
+                        }
+                    });
+                if trait_id == sized_trait {
+                    self.unsized_types.insert(self_ty);
+                }
+            }
+            &TypeBound::Lifetime(l) => {
+                let lifetime = self.lower_lifetime(l);
+                clause = Some(Clause(Predicate::new(
+                    self.interner,
+                    Binder::dummy(rustc_type_ir::PredicateKind::Clause(
+                        rustc_type_ir::ClauseKind::TypeOutlives(OutlivesPredicate(
+                            self_ty, lifetime,
+                        )),
+                    )),
+                )));
+            }
+            TypeBound::Use(_) | TypeBound::Error => {}
+        }
+        clause.into_iter().chain(assoc_bounds.into_iter().flatten())
+    }
+
+    fn lower_dyn_trait(&mut self, bounds: &[TypeBound]) -> Ty<'db> {
+        let interner = self.interner;
+        // FIXME: we should never create non-existential predicates in the first place
+        // For now, use an error type so we don't run into dummy binder issues
+        let self_ty = Ty::new_error(interner, ErrorGuaranteed);
+        // INVARIANT: The principal trait bound, if present, must come first. Others may be in any
+        // order but should be in the same order for the same set but possibly different order of
+        // bounds in the input.
+        // INVARIANT: If this function returns `DynTy`, there should be at least one trait bound.
+        // These invariants are utilized by `TyExt::dyn_trait()` and chalk.
+        let mut lifetime = None;
+        let bounds = self.with_shifted_in(DebruijnIndex::from_u32(1), |ctx| {
+            let mut lowered_bounds: Vec<
+                rustc_type_ir::Binder<DbInterner<'db>, ExistentialPredicate<DbInterner<'db>>>,
+            > = Vec::new();
+            for b in bounds {
+                let db = ctx.db;
+                ctx.lower_type_bound(b, self_ty, false).for_each(|b| {
+                    if let Some(bound) = b
+                        .kind()
+                        .map_bound(|c| match c {
+                            rustc_type_ir::ClauseKind::Trait(t) => {
+                                let id = t.def_id();
+                                let id = match id {
+                                    SolverDefId::TraitId(id) => id,
+                                    _ => unreachable!(),
+                                };
+                                let is_auto =
+                                    db.trait_signature(id).flags.contains(TraitFlags::AUTO);
+                                if is_auto {
+                                    Some(ExistentialPredicate::AutoTrait(t.def_id()))
+                                } else {
+                                    Some(ExistentialPredicate::Trait(
+                                        ExistentialTraitRef::new_from_args(
+                                            interner,
+                                            t.def_id(),
+                                            GenericArgs::new_from_iter(
+                                                interner,
+                                                t.trait_ref.args.iter().skip(1),
+                                            ),
+                                        ),
+                                    ))
+                                }
+                            }
+                            rustc_type_ir::ClauseKind::Projection(p) => {
+                                Some(ExistentialPredicate::Projection(
+                                    ExistentialProjection::new_from_args(
+                                        interner,
+                                        p.def_id(),
+                                        GenericArgs::new_from_iter(
+                                            interner,
+                                            p.projection_term.args.iter().skip(1),
+                                        ),
+                                        p.term,
+                                    ),
+                                ))
+                            }
+                            rustc_type_ir::ClauseKind::TypeOutlives(outlives_predicate) => {
+                                lifetime = Some(outlives_predicate.1);
+                                None
+                            }
+                            rustc_type_ir::ClauseKind::RegionOutlives(_)
+                            | rustc_type_ir::ClauseKind::ConstArgHasType(_, _)
+                            | rustc_type_ir::ClauseKind::WellFormed(_)
+                            | rustc_type_ir::ClauseKind::ConstEvaluatable(_)
+                            | rustc_type_ir::ClauseKind::HostEffect(_)
+                            | rustc_type_ir::ClauseKind::UnstableFeature(_) => unreachable!(),
+                        })
+                        .transpose()
+                    {
+                        lowered_bounds.push(bound);
+                    }
+                })
+            }
+
+            let mut multiple_regular_traits = false;
+            let mut multiple_same_projection = false;
+            lowered_bounds.sort_unstable_by(|lhs, rhs| {
+                use std::cmp::Ordering;
+                match ((*lhs).skip_binder(), (*rhs).skip_binder()) {
+                    (ExistentialPredicate::Trait(_), ExistentialPredicate::Trait(_)) => {
+                        multiple_regular_traits = true;
+                        // Order doesn't matter - we error
+                        Ordering::Equal
+                    }
+                    (
+                        ExistentialPredicate::AutoTrait(lhs_id),
+                        ExistentialPredicate::AutoTrait(rhs_id),
+                    ) => {
+                        let lhs_id = match lhs_id {
+                            SolverDefId::TraitId(id) => id,
+                            _ => unreachable!(),
+                        };
+                        let rhs_id = match rhs_id {
+                            SolverDefId::TraitId(id) => id,
+                            _ => unreachable!(),
+                        };
+                        lhs_id.cmp(&rhs_id)
+                    }
+                    (ExistentialPredicate::Trait(_), _) => Ordering::Less,
+                    (_, ExistentialPredicate::Trait(_)) => Ordering::Greater,
+                    (ExistentialPredicate::AutoTrait(_), _) => Ordering::Less,
+                    (_, ExistentialPredicate::AutoTrait(_)) => Ordering::Greater,
+                    (
+                        ExistentialPredicate::Projection(lhs),
+                        ExistentialPredicate::Projection(rhs),
+                    ) => {
+                        let lhs_id = match lhs.def_id {
+                            SolverDefId::TypeAliasId(id) => id,
+                            _ => unreachable!(),
+                        };
+                        let rhs_id = match rhs.def_id {
+                            SolverDefId::TypeAliasId(id) => id,
+                            _ => unreachable!(),
+                        };
+                        // We only compare the `associated_ty_id`s. We shouldn't have
+                        // multiple bounds for an associated type in the correct Rust code,
+                        // and if we do, we error out.
+                        if lhs_id == rhs_id {
+                            multiple_same_projection = true;
+                        }
+                        lhs_id.as_id().index().cmp(&rhs_id.as_id().index())
+                    }
+                }
+            });
+
+            if multiple_regular_traits || multiple_same_projection {
+                return None;
+            }
+
+            if !lowered_bounds.first().map_or(false, |b| {
+                matches!(
+                    b.as_ref().skip_binder(),
+                    ExistentialPredicate::Trait(_) | ExistentialPredicate::AutoTrait(_)
+                )
+            }) {
+                return None;
+            }
+
+            // As multiple occurrences of the same auto traits *are* permitted, we deduplicate the
+            // bounds. We shouldn't have repeated elements besides auto traits at this point.
+            lowered_bounds.dedup();
+
+            Some(BoundExistentialPredicates::new_from_iter(interner, lowered_bounds))
+        });
+
+        if let Some(bounds) = bounds {
+            let region = match lifetime {
+                Some(it) => match it.kind() {
+                    rustc_type_ir::RegionKind::ReBound(db, var) => Region::new_bound(
+                        self.interner,
+                        db.shifted_out_to_binder(DebruijnIndex::from_u32(2)),
+                        var,
+                    ),
+                    _ => it,
+                },
+                None => Region::new_static(self.interner),
+            };
+            Ty::new_dynamic(self.interner, bounds, region, rustc_type_ir::DynKind::Dyn)
+        } else {
+            // FIXME: report error
+            // (additional non-auto traits, associated type rebound, or no resolved trait)
+            Ty::new_error(self.interner, ErrorGuaranteed)
+        }
+    }
+
+    fn lower_impl_trait(
+        &mut self,
+        def_id: SolverDefId,
+        bounds: &[TypeBound],
+        krate: Crate,
+    ) -> ImplTrait<'db> {
+        let interner = self.interner;
+        cov_mark::hit!(lower_rpit);
+        let args = GenericArgs::identity_for_item(interner, def_id);
+        let self_ty = Ty::new_alias(
+            self.interner,
+            rustc_type_ir::AliasTyKind::Opaque,
+            AliasTy::new_from_args(interner, def_id, args),
+        );
+        let predicates = self.with_shifted_in(DebruijnIndex::from_u32(1), |ctx| {
+            let mut predicates = Vec::new();
+            for b in bounds {
+                predicates.extend(ctx.lower_type_bound(b, self_ty, false));
+            }
+
+            if !ctx.unsized_types.contains(&self_ty) {
+                let sized_trait = LangItem::Sized.resolve_trait(self.db, krate);
+                let sized_clause = sized_trait.map(|trait_id| {
+                    let trait_ref = TraitRef::new_from_args(
+                        interner,
+                        trait_id.into(),
+                        GenericArgs::new_from_iter(interner, [self_ty.into()]),
+                    );
+                    Clause(Predicate::new(
+                        interner,
+                        Binder::dummy(rustc_type_ir::PredicateKind::Clause(
+                            rustc_type_ir::ClauseKind::Trait(TraitPredicate {
+                                trait_ref,
+                                polarity: rustc_type_ir::PredicatePolarity::Positive,
+                            }),
+                        )),
+                    ))
+                });
+                predicates.extend(sized_clause);
+            }
+            predicates.shrink_to_fit();
+            predicates
+        });
+        ImplTrait { predicates }
+    }
+
+    pub(crate) fn lower_lifetime(&self, lifetime: LifetimeRefId) -> Region<'db> {
+        match self.resolver.resolve_lifetime(&self.store[lifetime]) {
+            Some(resolution) => match resolution {
+                LifetimeNs::Static => Region::new_static(self.interner),
+                LifetimeNs::LifetimeParam(id) => {
+                    let idx = match self.generics().lifetime_idx(id) {
+                        None => return Region::error(self.interner),
+                        Some(idx) => idx,
+                    };
+                    Region::new_early_param(self.interner, EarlyParamRegion { index: idx as u32 })
+                }
+            },
+            None => Region::error(self.interner),
+        }
+    }
+}
+
+pub(crate) fn lower_mutability(m: hir_def::type_ref::Mutability) -> Mutability {
+    match m {
+        hir_def::type_ref::Mutability::Shared => Mutability::Not,
+        hir_def::type_ref::Mutability::Mut => Mutability::Mut,
+    }
+}
+
+fn unknown_const(_ty: Ty<'_>) -> Const<'_> {
+    Const::new(DbInterner::conjure(), ConstKind::Error(ErrorGuaranteed))
+}
+
+pub(crate) fn impl_trait_query<'db>(
+    db: &'db dyn HirDatabase,
+    impl_id: ImplId,
+) -> Option<EarlyBinder<'db, TraitRef<'db>>> {
+    db.impl_trait_with_diagnostics_ns(impl_id).map(|it| it.0)
+}
+
+pub(crate) fn impl_trait_with_diagnostics_query<'db>(
+    db: &'db dyn HirDatabase,
+    impl_id: ImplId,
+) -> Option<(EarlyBinder<'db, TraitRef<'db>>, Diagnostics)> {
+    let impl_data = db.impl_signature(impl_id);
+    let resolver = impl_id.resolver(db);
+    let mut ctx = TyLoweringContext::new(
+        db,
+        &resolver,
+        &impl_data.store,
+        impl_id.into(),
+        LifetimeElisionKind::AnonymousCreateParameter { report_in_path: true },
+    );
+    let self_ty = db.impl_self_ty_ns(impl_id).skip_binder();
+    let target_trait = impl_data.target_trait.as_ref()?;
+    let trait_ref = EarlyBinder::bind(ctx.lower_trait_ref(target_trait, self_ty)?);
+    Some((trait_ref, create_diagnostics(ctx.diagnostics)))
+}
+
+pub(crate) fn return_type_impl_traits<'db>(
+    db: &'db dyn HirDatabase,
+    def: hir_def::FunctionId,
+) -> Option<Arc<EarlyBinder<'db, ImplTraits<'db>>>> {
+    // FIXME unify with fn_sig_for_fn instead of doing lowering twice, maybe
+    let data = db.function_signature(def);
+    let resolver = def.resolver(db);
+    let mut ctx_ret =
+        TyLoweringContext::new(db, &resolver, &data.store, def.into(), LifetimeElisionKind::Infer)
+            .with_impl_trait_mode(ImplTraitLoweringMode::Opaque);
+    if let Some(ret_type) = data.ret_type {
+        let _ret = ctx_ret.lower_ty(ret_type);
+    }
+    let return_type_impl_traits =
+        ImplTraits { impl_traits: ctx_ret.impl_trait_mode.opaque_type_data };
+    if return_type_impl_traits.impl_traits.is_empty() {
+        None
+    } else {
+        Some(Arc::new(EarlyBinder::bind(return_type_impl_traits)))
+    }
+}
+
+pub(crate) fn type_alias_impl_traits<'db>(
+    db: &'db dyn HirDatabase,
+    def: hir_def::TypeAliasId,
+) -> Option<Arc<EarlyBinder<'db, ImplTraits<'db>>>> {
+    let data = db.type_alias_signature(def);
+    let resolver = def.resolver(db);
+    let mut ctx = TyLoweringContext::new(
+        db,
+        &resolver,
+        &data.store,
+        def.into(),
+        LifetimeElisionKind::AnonymousReportError,
+    )
+    .with_impl_trait_mode(ImplTraitLoweringMode::Opaque);
+    if let Some(type_ref) = data.ty {
+        let _ty = ctx.lower_ty(type_ref);
+    }
+    let type_alias_impl_traits = ImplTraits { impl_traits: ctx.impl_trait_mode.opaque_type_data };
+    if type_alias_impl_traits.impl_traits.is_empty() {
+        None
+    } else {
+        Some(Arc::new(EarlyBinder::bind(type_alias_impl_traits)))
+    }
+}
+
+/// Build the declared type of an item. This depends on the namespace; e.g. for
+/// `struct Foo(usize)`, we have two types: The type of the struct itself, and
+/// the constructor function `(usize) -> Foo` which lives in the values
+/// namespace.
+pub(crate) fn ty_query<'db>(db: &'db dyn HirDatabase, def: TyDefId) -> EarlyBinder<'db, Ty<'db>> {
+    let interner = DbInterner::new_with(db, None, None);
+    match def {
+        TyDefId::BuiltinType(it) => EarlyBinder::bind(builtin(interner, it)),
+        TyDefId::AdtId(it) => EarlyBinder::bind(Ty::new_adt(
+            interner,
+            AdtDef::new(it, interner),
+            GenericArgs::identity_for_item(interner, it.into()),
+        )),
+        TyDefId::TypeAliasId(it) => db.type_for_type_alias_with_diagnostics_ns(it).0,
+    }
+}
+
+pub(crate) fn type_for_type_alias_with_diagnostics_query<'db>(
+    db: &'db dyn HirDatabase,
+    t: TypeAliasId,
+) -> (EarlyBinder<'db, Ty<'db>>, Diagnostics) {
+    let type_alias_data = db.type_alias_signature(t);
+    let mut diags = None;
+    let resolver = t.resolver(db);
+    let interner = DbInterner::new_with(db, Some(resolver.krate()), None);
+    let inner = if type_alias_data.flags.contains(TypeAliasFlags::IS_EXTERN) {
+        EarlyBinder::bind(Ty::new_foreign(interner, t.into()))
+    } else {
+        let mut ctx = TyLoweringContext::new(
+            db,
+            &resolver,
+            &type_alias_data.store,
+            t.into(),
+            LifetimeElisionKind::AnonymousReportError,
+        )
+        .with_impl_trait_mode(ImplTraitLoweringMode::Opaque);
+        let res = EarlyBinder::bind(
+            type_alias_data
+                .ty
+                .map(|type_ref| ctx.lower_ty(type_ref))
+                .unwrap_or_else(|| Ty::new_error(interner, ErrorGuaranteed)),
+        );
+        diags = create_diagnostics(ctx.diagnostics);
+        res
+    };
+    (inner, diags)
+}
+
+pub(crate) fn type_for_type_alias_with_diagnostics_cycle_result<'db>(
+    db: &'db dyn HirDatabase,
+    _adt: TypeAliasId,
+) -> (EarlyBinder<'db, Ty<'db>>, Diagnostics) {
+    (EarlyBinder::bind(Ty::new_error(DbInterner::new_with(db, None, None), ErrorGuaranteed)), None)
+}
+
+pub(crate) fn impl_self_ty_query<'db>(
+    db: &'db dyn HirDatabase,
+    impl_id: ImplId,
+) -> EarlyBinder<'db, Ty<'db>> {
+    db.impl_self_ty_with_diagnostics_ns(impl_id).0
+}
+
+pub(crate) fn impl_self_ty_with_diagnostics_query<'db>(
+    db: &'db dyn HirDatabase,
+    impl_id: ImplId,
+) -> (EarlyBinder<'db, Ty<'db>>, Diagnostics) {
+    let resolver = impl_id.resolver(db);
+    let interner = DbInterner::new_with(db, Some(resolver.krate()), None);
+
+    let impl_data = db.impl_signature(impl_id);
+    let mut ctx = TyLoweringContext::new(
+        db,
+        &resolver,
+        &impl_data.store,
+        impl_id.into(),
+        LifetimeElisionKind::AnonymousCreateParameter { report_in_path: true },
+    );
+    let ty = ctx.lower_ty(impl_data.self_ty);
+    assert!(!ty.has_escaping_bound_vars());
+    (EarlyBinder::bind(ty), create_diagnostics(ctx.diagnostics))
+}
+
+pub(crate) fn impl_self_ty_with_diagnostics_cycle_result(
+    db: &dyn HirDatabase,
+    _impl_id: ImplId,
+) -> (EarlyBinder<'_, Ty<'_>>, Diagnostics) {
+    (EarlyBinder::bind(Ty::new_error(DbInterner::new_with(db, None, None), ErrorGuaranteed)), None)
+}
+
+pub(crate) fn const_param_ty_query<'db>(db: &'db dyn HirDatabase, def: ConstParamId) -> Ty<'db> {
+    db.const_param_ty_with_diagnostics_ns(def).0
+}
+
+// returns None if def is a type arg
+pub(crate) fn const_param_ty_with_diagnostics_query<'db>(
+    db: &'db dyn HirDatabase,
+    def: ConstParamId,
+) -> (Ty<'db>, Diagnostics) {
+    let (parent_data, store) = db.generic_params_and_store(def.parent());
+    let data = &parent_data[def.local_id()];
+    let resolver = def.parent().resolver(db);
+    let interner = DbInterner::new_with(db, Some(resolver.krate()), None);
+    let mut ctx = TyLoweringContext::new(
+        db,
+        &resolver,
+        &store,
+        def.parent(),
+        LifetimeElisionKind::AnonymousReportError,
+    );
+    let ty = match data {
+        TypeOrConstParamData::TypeParamData(_) => {
+            never!();
+            Ty::new_error(interner, ErrorGuaranteed)
+        }
+        TypeOrConstParamData::ConstParamData(d) => ctx.lower_ty(d.ty),
+    };
+    (ty, create_diagnostics(ctx.diagnostics))
+}
+
+pub(crate) fn field_types_query<'db>(
+    db: &'db dyn HirDatabase,
+    variant_id: VariantId,
+) -> Arc<ArenaMap<LocalFieldId, EarlyBinder<'db, Ty<'db>>>> {
+    db.field_types_with_diagnostics_ns(variant_id).0
+}
+
+/// Build the type of all specific fields of a struct or enum variant.
+pub(crate) fn field_types_with_diagnostics_query<'db>(
+    db: &'db dyn HirDatabase,
+    variant_id: VariantId,
+) -> (Arc<ArenaMap<LocalFieldId, EarlyBinder<'db, Ty<'db>>>>, Diagnostics) {
+    let var_data = variant_id.fields(db);
+    let fields = var_data.fields();
+    if fields.is_empty() {
+        return (Arc::new(ArenaMap::default()), None);
+    }
+
+    let (resolver, def): (_, GenericDefId) = match variant_id {
+        VariantId::StructId(it) => (it.resolver(db), it.into()),
+        VariantId::UnionId(it) => (it.resolver(db), it.into()),
+        VariantId::EnumVariantId(it) => (it.resolver(db), it.lookup(db).parent.into()),
+    };
+    let mut res = ArenaMap::default();
+    let mut ctx = TyLoweringContext::new(
+        db,
+        &resolver,
+        &var_data.store,
+        def,
+        LifetimeElisionKind::AnonymousReportError,
+    );
+    for (field_id, field_data) in var_data.fields().iter() {
+        res.insert(field_id, EarlyBinder::bind(ctx.lower_ty(field_data.type_ref)));
+    }
+    (Arc::new(res), create_diagnostics(ctx.diagnostics))
+}
+
+/// This query exists only to be used when resolving short-hand associated types
+/// like `T::Item`.
+///
+/// See the analogous query in rustc and its comment:
+/// <https://github.com/rust-lang/rust/blob/9150f844e2624eb013ec78ca08c1d416e6644026/src/librustc_typeck/astconv.rs#L46>
+/// This is a query mostly to handle cycles somewhat gracefully; e.g. the
+/// following bounds are disallowed: `T: Foo<U::Item>, U: Foo<T::Item>`, but
+/// these are fine: `T: Foo<U::Item>, U: Foo<()>`.
+#[tracing::instrument(skip(db), ret)]
+pub(crate) fn generic_predicates_for_param_query<'db>(
+    db: &'db dyn HirDatabase,
+    def: GenericDefId,
+    param_id: TypeOrConstParamId,
+    assoc_name: Option<Name>,
+) -> GenericPredicates<'db> {
+    let generics = generics(db, def);
+    let interner = DbInterner::new_with(db, None, None);
+    let resolver = def.resolver(db);
+    let mut ctx = TyLoweringContext::new(
+        db,
+        &resolver,
+        generics.store(),
+        def,
+        LifetimeElisionKind::AnonymousReportError,
+    );
+
+    // we have to filter out all other predicates *first*, before attempting to lower them
+    let predicate = |pred: &_, ctx: &mut TyLoweringContext<'_, '_>| match pred {
+        WherePredicate::ForLifetime { target, bound, .. }
+        | WherePredicate::TypeBound { target, bound, .. } => {
+            let invalid_target = { ctx.lower_ty_only_param(*target) != Some(param_id) };
+            if invalid_target {
+                // FIXME(sized-hierarchy): Revisit and adjust this properly once we have implemented
+                // sized-hierarchy correctly.
+                // If this is filtered out without lowering, `?Sized` or `PointeeSized` is not gathered into
+                // `ctx.unsized_types`
+                let lower = || -> bool {
+                    match bound {
+                        TypeBound::Path(_, TraitBoundModifier::Maybe) => true,
+                        TypeBound::Path(path, _) | TypeBound::ForLifetime(_, path) => {
+                            let TypeRef::Path(path) = &ctx.store[path.type_ref()] else {
+                                return false;
+                            };
+                            let Some(pointee_sized) =
+                                LangItem::PointeeSized.resolve_trait(ctx.db, ctx.resolver.krate())
+                            else {
+                                return false;
+                            };
+                            // Lower the path directly with `Resolver` instead of PathLoweringContext`
+                            // to prevent diagnostics duplications.
+                            ctx.resolver.resolve_path_in_type_ns_fully(ctx.db, path).is_some_and(
+                                |it| matches!(it, TypeNs::TraitId(tr) if tr == pointee_sized),
+                            )
+                        }
+                        _ => false,
+                    }
+                }();
+                if lower {
+                    ctx.lower_where_predicate(pred, true, &generics, PredicateFilter::All)
+                        .for_each(drop);
+                }
+                return false;
+            }
+
+            match bound {
+                &TypeBound::ForLifetime(_, path) | &TypeBound::Path(path, _) => {
+                    // Only lower the bound if the trait could possibly define the associated
+                    // type we're looking for.
+                    let path = &ctx.store[path];
+
+                    let Some(assoc_name) = &assoc_name else { return true };
+                    let Some(TypeNs::TraitId(tr)) =
+                        resolver.resolve_path_in_type_ns_fully(db, path)
+                    else {
+                        return false;
+                    };
+
+                    rustc_type_ir::elaborate::supertrait_def_ids(interner, tr.into()).any(|tr| {
+                        let tr = match tr {
+                            SolverDefId::TraitId(id) => id,
+                            _ => unreachable!(),
+                        };
+                        tr.trait_items(db).items.iter().any(|(name, item)| {
+                            matches!(item, AssocItemId::TypeAliasId(_)) && name == assoc_name
+                        })
+                    })
+                }
+                TypeBound::Use(_) | TypeBound::Lifetime(_) | TypeBound::Error => false,
+            }
+        }
+        WherePredicate::Lifetime { .. } => false,
+    };
+    let mut predicates = Vec::new();
+    for maybe_parent_generics in
+        std::iter::successors(Some(&generics), |generics| generics.parent_generics())
+    {
+        ctx.store = maybe_parent_generics.store();
+        for pred in maybe_parent_generics.where_predicates() {
+            if predicate(pred, &mut ctx) {
+                predicates.extend(ctx.lower_where_predicate(
+                    pred,
+                    true,
+                    maybe_parent_generics,
+                    PredicateFilter::All,
+                ));
+            }
+        }
+    }
+
+    let args = GenericArgs::identity_for_item(interner, def.into());
+    if !args.is_empty() {
+        let explicitly_unsized_tys = ctx.unsized_types;
+        if let Some(implicitly_sized_predicates) =
+            implicitly_sized_clauses(db, param_id.parent, &explicitly_unsized_tys, &args, &resolver)
+        {
+            predicates.extend(implicitly_sized_predicates);
+        };
+    }
+    GenericPredicates(predicates.is_empty().not().then(|| predicates.into()))
+}
+
+pub(crate) fn generic_predicates_for_param_cycle_result(
+    _db: &dyn HirDatabase,
+    _def: GenericDefId,
+    _param_id: TypeOrConstParamId,
+    _assoc_name: Option<Name>,
+) -> GenericPredicates<'_> {
+    GenericPredicates(None)
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct GenericPredicates<'db>(Option<Arc<[Clause<'db>]>>);
+
+impl<'db> ops::Deref for GenericPredicates<'db> {
+    type Target = [Clause<'db>];
+
+    fn deref(&self) -> &Self::Target {
+        self.0.as_deref().unwrap_or(&[])
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+pub(crate) enum PredicateFilter {
+    SelfTrait,
+    All,
+}
+
+/// Resolve the where clause(s) of an item with generics.
+#[tracing::instrument(skip(db))]
+pub(crate) fn generic_predicates_query<'db>(
+    db: &'db dyn HirDatabase,
+    def: GenericDefId,
+) -> GenericPredicates<'db> {
+    generic_predicates_filtered_by(db, def, PredicateFilter::All, |_| true).0
+}
+
+pub(crate) fn generic_predicates_without_parent_query<'db>(
+    db: &'db dyn HirDatabase,
+    def: GenericDefId,
+) -> GenericPredicates<'db> {
+    generic_predicates_filtered_by(db, def, PredicateFilter::All, |d| d == def).0
+}
+
+/// Resolve the where clause(s) of an item with generics,
+/// except the ones inherited from the parent
+pub(crate) fn generic_predicates_without_parent_with_diagnostics_query<'db>(
+    db: &'db dyn HirDatabase,
+    def: GenericDefId,
+) -> (GenericPredicates<'db>, Diagnostics) {
+    generic_predicates_filtered_by(db, def, PredicateFilter::All, |d| d == def)
+}
+
+/// Resolve the where clause(s) of an item with generics,
+/// with a given filter
+#[tracing::instrument(skip(db, filter), ret)]
+pub(crate) fn generic_predicates_filtered_by<'db, F>(
+    db: &'db dyn HirDatabase,
+    def: GenericDefId,
+    predicate_filter: PredicateFilter,
+    filter: F,
+) -> (GenericPredicates<'db>, Diagnostics)
+where
+    F: Fn(GenericDefId) -> bool,
+{
+    let generics = generics(db, def);
+    let resolver = def.resolver(db);
+    let interner = DbInterner::new_with(db, Some(resolver.krate()), None);
+    let mut ctx = TyLoweringContext::new(
+        db,
+        &resolver,
+        generics.store(),
+        def,
+        LifetimeElisionKind::AnonymousReportError,
+    );
+
+    let mut predicates = Vec::new();
+    for maybe_parent_generics in
+        std::iter::successors(Some(&generics), |generics| generics.parent_generics())
+    {
+        ctx.store = maybe_parent_generics.store();
+        for pred in maybe_parent_generics.where_predicates() {
+            tracing::debug!(?pred);
+            if filter(maybe_parent_generics.def()) {
+                // We deliberately use `generics` and not `maybe_parent_generics` here. This is not a mistake!
+                // If we use the parent generics
+                predicates.extend(ctx.lower_where_predicate(
+                    pred,
+                    false,
+                    maybe_parent_generics,
+                    predicate_filter,
+                ));
+            }
+        }
+    }
+
+    let explicitly_unsized_tys = ctx.unsized_types;
+
+    let sized_trait = LangItem::Sized.resolve_trait(db, resolver.krate());
+    if let Some(sized_trait) = sized_trait {
+        let (mut generics, mut def_id) =
+            (crate::next_solver::generics::generics(db, def.into()), def);
+        loop {
+            if filter(def_id) {
+                let self_idx = trait_self_param_idx(db, def_id);
+                for (idx, p) in generics.own_params.iter().enumerate() {
+                    if let Some(self_idx) = self_idx
+                        && p.index() as usize == self_idx
+                    {
+                        continue;
+                    }
+                    let GenericParamDefKind::Type = p.kind else {
+                        continue;
+                    };
+                    let idx = idx as u32 + generics.parent_count as u32;
+                    let param_ty = Ty::new_param(interner, idx, p.name.clone());
+                    if explicitly_unsized_tys.contains(&param_ty) {
+                        continue;
+                    }
+                    let trait_ref = TraitRef::new_from_args(
+                        interner,
+                        sized_trait.into(),
+                        GenericArgs::new_from_iter(interner, [param_ty.into()]),
+                    );
+                    let clause = Clause(Predicate::new(
+                        interner,
+                        Binder::dummy(rustc_type_ir::PredicateKind::Clause(
+                            rustc_type_ir::ClauseKind::Trait(TraitPredicate {
+                                trait_ref,
+                                polarity: rustc_type_ir::PredicatePolarity::Positive,
+                            }),
+                        )),
+                    ));
+                    predicates.push(clause);
+                }
+            }
+
+            if let Some(g) = generics.parent {
+                generics = crate::next_solver::generics::generics(db, g.into());
+                def_id = g;
+            } else {
+                break;
+            }
+        }
+    }
+
+    (
+        GenericPredicates(predicates.is_empty().not().then(|| predicates.into())),
+        create_diagnostics(ctx.diagnostics),
+    )
+}
+
+/// Generate implicit `: Sized` predicates for all generics that has no `?Sized` bound.
+/// Exception is Self of a trait def.
+fn implicitly_sized_clauses<'a, 'subst, 'db>(
+    db: &'db dyn HirDatabase,
+    def: GenericDefId,
+    explicitly_unsized_tys: &'a FxHashSet<Ty<'db>>,
+    args: &'subst GenericArgs<'db>,
+    resolver: &Resolver<'db>,
+) -> Option<impl Iterator<Item = Clause<'db>> + Captures<'a> + Captures<'subst>> {
+    let interner = DbInterner::new_with(db, Some(resolver.krate()), None);
+    let sized_trait = LangItem::Sized.resolve_trait(db, resolver.krate())?;
+
+    let trait_self_idx = trait_self_param_idx(db, def);
+
+    Some(
+        args.iter()
+            .enumerate()
+            .filter_map(
+                move |(idx, generic_arg)| {
+                    if Some(idx) == trait_self_idx { None } else { Some(generic_arg) }
+                },
+            )
+            .filter_map(|generic_arg| generic_arg.as_type())
+            .filter(move |self_ty| !explicitly_unsized_tys.contains(self_ty))
+            .map(move |self_ty| {
+                let trait_ref = TraitRef::new_from_args(
+                    interner,
+                    sized_trait.into(),
+                    GenericArgs::new_from_iter(interner, [self_ty.into()]),
+                );
+                Clause(Predicate::new(
+                    interner,
+                    Binder::dummy(rustc_type_ir::PredicateKind::Clause(
+                        rustc_type_ir::ClauseKind::Trait(TraitPredicate {
+                            trait_ref,
+                            polarity: rustc_type_ir::PredicatePolarity::Positive,
+                        }),
+                    )),
+                ))
+            }),
+    )
+}
+
+pub(crate) fn make_binders<'db, T: rustc_type_ir::TypeVisitable<DbInterner<'db>>>(
+    interner: DbInterner<'db>,
+    generics: &Generics,
+    value: T,
+) -> Binder<'db, T> {
+    Binder::bind_with_vars(
+        value,
+        BoundVarKinds::new_from_iter(
+            interner,
+            generics.iter_id().map(|x| match x {
+                hir_def::GenericParamId::ConstParamId(_) => BoundVarKind::Const,
+                hir_def::GenericParamId::TypeParamId(_) => BoundVarKind::Ty(BoundTyKind::Anon),
+                hir_def::GenericParamId::LifetimeParamId(_) => {
+                    BoundVarKind::Region(BoundRegionKind::Anon)
+                }
+            }),
+        ),
+    )
+}
+
+/// Checks if the provided generic arg matches its expected kind, then lower them via
+/// provided closures. Use unknown if there was kind mismatch.
+///
+pub(crate) fn lower_generic_arg<'a, 'db, T>(
+    db: &'db dyn HirDatabase,
+    kind_id: GenericParamId,
+    arg: &'a GenericArg,
+    this: &mut T,
+    store: &ExpressionStore,
+    for_type: impl FnOnce(&mut T, TypeRefId) -> Ty<'db> + 'a,
+    for_const: impl FnOnce(&mut T, &ConstRef, Ty<'db>) -> Const<'db> + 'a,
+    for_const_ty_path_fallback: impl FnOnce(&mut T, &Path, Ty<'db>) -> Const<'db> + 'a,
+    for_lifetime: impl FnOnce(&mut T, &LifetimeRefId) -> Region<'db> + 'a,
+) -> crate::next_solver::GenericArg<'db> {
+    let interner = DbInterner::new_with(db, None, None);
+    let kind = match kind_id {
+        GenericParamId::TypeParamId(_) => ParamKind::Type,
+        GenericParamId::ConstParamId(id) => {
+            let ty = db.const_param_ty(id);
+            ParamKind::Const(ty)
+        }
+        GenericParamId::LifetimeParamId(_) => ParamKind::Lifetime,
+    };
+    match (arg, kind) {
+        (GenericArg::Type(type_ref), ParamKind::Type) => for_type(this, *type_ref).into(),
+        (GenericArg::Const(c), ParamKind::Const(c_ty)) => {
+            for_const(this, c, c_ty.to_nextsolver(interner)).into()
+        }
+        (GenericArg::Lifetime(lifetime_ref), ParamKind::Lifetime) => {
+            for_lifetime(this, lifetime_ref).into()
+        }
+        (GenericArg::Const(_), ParamKind::Type) => Ty::new_error(interner, ErrorGuaranteed).into(),
+        (GenericArg::Lifetime(_), ParamKind::Type) => {
+            Ty::new_error(interner, ErrorGuaranteed).into()
+        }
+        (GenericArg::Type(t), ParamKind::Const(c_ty)) => match &store[*t] {
+            TypeRef::Path(p) => {
+                for_const_ty_path_fallback(this, p, c_ty.to_nextsolver(interner)).into()
+            }
+            _ => unknown_const_as_generic(c_ty.to_nextsolver(interner)),
+        },
+        (GenericArg::Lifetime(_), ParamKind::Const(c_ty)) => {
+            unknown_const(c_ty.to_nextsolver(interner)).into()
+        }
+        (GenericArg::Type(_), ParamKind::Lifetime) => Region::error(interner).into(),
+        (GenericArg::Const(_), ParamKind::Lifetime) => Region::error(interner).into(),
+    }
+}
+
+/// Build the signature of a callable item (function, struct or enum variant).
+pub(crate) fn callable_item_signature_query<'db>(
+    db: &'db dyn HirDatabase,
+    def: CallableDefId,
+) -> EarlyBinder<'db, PolyFnSig<'db>> {
+    match def {
+        CallableDefId::FunctionId(f) => fn_sig_for_fn(db, f),
+        CallableDefId::StructId(s) => fn_sig_for_struct_constructor(db, s),
+        CallableDefId::EnumVariantId(e) => fn_sig_for_enum_variant_constructor(db, e),
+    }
+}
+
+fn fn_sig_for_fn<'db>(
+    db: &'db dyn HirDatabase,
+    def: FunctionId,
+) -> EarlyBinder<'db, PolyFnSig<'db>> {
+    let data = db.function_signature(def);
+    let resolver = def.resolver(db);
+    let interner = DbInterner::new_with(db, Some(resolver.krate()), None);
+    let mut ctx_params = TyLoweringContext::new(
+        db,
+        &resolver,
+        &data.store,
+        def.into(),
+        LifetimeElisionKind::for_fn_params(&data),
+    );
+    let params = data.params.iter().map(|&tr| ctx_params.lower_ty(tr));
+
+    let ret = match data.ret_type {
+        Some(ret_type) => {
+            let mut ctx_ret = TyLoweringContext::new(
+                db,
+                &resolver,
+                &data.store,
+                def.into(),
+                LifetimeElisionKind::for_fn_ret(interner),
+            )
+            .with_impl_trait_mode(ImplTraitLoweringMode::Opaque);
+            ctx_ret.lower_ty(ret_type)
+        }
+        None => Ty::new_tup(interner, &[]),
+    };
+
+    let inputs_and_output = Tys::new_from_iter(interner, params.chain(Some(ret)));
+    // If/when we track late bound vars, we need to switch this to not be `dummy`
+    EarlyBinder::bind(rustc_type_ir::Binder::dummy(FnSig {
+        abi: data.abi.as_ref().map_or(FnAbi::Rust, FnAbi::from_symbol),
+        c_variadic: data.is_varargs(),
+        safety: if data.is_unsafe() { Safety::Unsafe } else { Safety::Safe },
+        inputs_and_output,
+    }))
+}
+
+fn type_for_adt<'db>(db: &'db dyn HirDatabase, adt: AdtId) -> EarlyBinder<'db, Ty<'db>> {
+    let interner = DbInterner::new_with(db, None, None);
+    let args = GenericArgs::identity_for_item(interner, adt.into());
+    let ty = Ty::new_adt(interner, AdtDef::new(adt, interner), args);
+    EarlyBinder::bind(ty)
+}
+
+fn fn_sig_for_struct_constructor<'db>(
+    db: &'db dyn HirDatabase,
+    def: StructId,
+) -> EarlyBinder<'db, PolyFnSig<'db>> {
+    let field_tys = db.field_types_ns(def.into());
+    let params = field_tys.iter().map(|(_, ty)| ty.skip_binder());
+    let ret = type_for_adt(db, def.into()).skip_binder();
+
+    let inputs_and_output =
+        Tys::new_from_iter(DbInterner::new_with(db, None, None), params.chain(Some(ret)));
+    EarlyBinder::bind(Binder::dummy(FnSig {
+        abi: FnAbi::RustCall,
+        c_variadic: false,
+        safety: Safety::Safe,
+        inputs_and_output,
+    }))
+}
+
+fn fn_sig_for_enum_variant_constructor<'db>(
+    db: &'db dyn HirDatabase,
+    def: EnumVariantId,
+) -> EarlyBinder<'db, PolyFnSig<'db>> {
+    let field_tys = db.field_types_ns(def.into());
+    let params = field_tys.iter().map(|(_, ty)| ty.skip_binder());
+    let parent = def.lookup(db).parent;
+    let ret = type_for_adt(db, parent.into()).skip_binder();
+
+    let inputs_and_output =
+        Tys::new_from_iter(DbInterner::new_with(db, None, None), params.chain(Some(ret)));
+    EarlyBinder::bind(Binder::dummy(FnSig {
+        abi: FnAbi::RustCall,
+        c_variadic: false,
+        safety: Safety::Safe,
+        inputs_and_output,
+    }))
+}
+
+pub(crate) fn associated_type_by_name_including_super_traits<'db>(
+    db: &'db dyn HirDatabase,
+    trait_ref: TraitRef<'db>,
+    name: &Name,
+) -> Option<(TraitRef<'db>, TypeAliasId)> {
+    let interner = DbInterner::new_with(db, None, None);
+    rustc_type_ir::elaborate::supertraits(interner, Binder::dummy(trait_ref)).find_map(|t| {
+        let trait_id = match t.as_ref().skip_binder().def_id {
+            SolverDefId::TraitId(id) => id,
+            _ => unreachable!(),
+        };
+        let assoc_type = trait_id.trait_items(db).associated_type_by_name(name)?;
+        Some((t.skip_binder(), assoc_type))
+    })
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver/path.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver/path.rs
new file mode 100644
index 0000000000000..b95bb1130fa20
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver/path.rs
@@ -0,0 +1,1459 @@
+//! A wrapper around [`TyLoweringContext`] specifically for lowering paths.
+
+use std::ops::Deref;
+
+use either::Either;
+use hir_def::{
+    AssocItemId, GenericDefId, GenericParamId, Lookup, TraitId,
+    builtin_type::BuiltinType,
+    expr_store::{
+        ExpressionStore, HygieneId,
+        path::{GenericArg, GenericArgs, GenericArgsParentheses, Path, PathSegment, PathSegments},
+    },
+    hir::generics::{
+        GenericParamDataRef, TypeOrConstParamData, TypeParamData, TypeParamProvenance,
+    },
+    resolver::{ResolveValueResult, TypeNs, ValueNs},
+    signatures::TraitFlags,
+    type_ref::{TypeRef, TypeRefId},
+};
+use intern::sym;
+use rustc_hash::FxHashSet;
+use rustc_type_ir::{
+    AliasTerm, AliasTy, AliasTyKind, TypeVisitableExt,
+    inherent::{GenericArgs as _, IntoKind, Region as _, SliceLike, Ty as _},
+};
+use smallvec::{SmallVec, smallvec};
+use stdx::never;
+
+use crate::{
+    GenericArgsProhibitedReason, IncorrectGenericsLenKind, PathGenericsSource,
+    PathLoweringDiagnostic, TyDefId, ValueTyDefId,
+    consteval_nextsolver::{unknown_const, unknown_const_as_generic},
+    db::HirDatabase,
+    generics::{Generics, generics},
+    lower::PathDiagnosticCallbackData,
+    lower_nextsolver::{LifetimeElisionKind, PredicateFilter, generic_predicates_filtered_by},
+    next_solver::{
+        AdtDef, Binder, Clause, Const, DbInterner, ErrorGuaranteed, Predicate, ProjectionPredicate,
+        Region, SolverDefId, TraitRef, Ty,
+        mapping::{ChalkToNextSolver, convert_binder_to_early_binder},
+    },
+    primitive,
+};
+
+use super::{
+    ImplTraitLoweringMode, TyLoweringContext, associated_type_by_name_including_super_traits,
+    const_param_ty_query, ty_query,
+};
+
+type CallbackData<'a> =
+    Either<PathDiagnosticCallbackData, crate::infer::diagnostics::PathDiagnosticCallbackData<'a>>;
+
+// We cannot use `&mut dyn FnMut()` because of lifetime issues, and we don't want to use `Box<dyn FnMut()>`
+// because of the allocation, so we create a lifetime-less callback, tailored for our needs.
+pub(crate) struct PathDiagnosticCallback<'a, 'db> {
+    pub(crate) data: CallbackData<'a>,
+    pub(crate) callback:
+        fn(&CallbackData<'_>, &mut TyLoweringContext<'db, '_>, PathLoweringDiagnostic),
+}
+
+pub(crate) struct PathLoweringContext<'a, 'b, 'db> {
+    ctx: &'a mut TyLoweringContext<'db, 'b>,
+    on_diagnostic: PathDiagnosticCallback<'a, 'db>,
+    path: &'a Path,
+    segments: PathSegments<'a>,
+    current_segment_idx: usize,
+    /// Contains the previous segment if `current_segment_idx == segments.len()`
+    current_or_prev_segment: PathSegment<'a>,
+}
+
+impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
+    #[inline]
+    pub(crate) fn new(
+        ctx: &'a mut TyLoweringContext<'db, 'b>,
+        on_diagnostic: PathDiagnosticCallback<'a, 'db>,
+        path: &'a Path,
+    ) -> Self {
+        let segments = path.segments();
+        let first_segment = segments.first().unwrap_or(PathSegment::MISSING);
+        Self {
+            ctx,
+            on_diagnostic,
+            path,
+            segments,
+            current_segment_idx: 0,
+            current_or_prev_segment: first_segment,
+        }
+    }
+
+    #[inline]
+    #[cold]
+    fn on_diagnostic(&mut self, diag: PathLoweringDiagnostic) {
+        (self.on_diagnostic.callback)(&self.on_diagnostic.data, self.ctx, diag);
+    }
+
+    #[inline]
+    pub(crate) fn ty_ctx(&mut self) -> &mut TyLoweringContext<'db, 'b> {
+        self.ctx
+    }
+
+    #[inline]
+    fn current_segment_u32(&self) -> u32 {
+        self.current_segment_idx as u32
+    }
+
+    #[inline]
+    fn skip_resolved_segment(&mut self) {
+        if !matches!(self.path, Path::LangItem(..)) {
+            // In lang items, the resolved "segment" is not one of the segments. Perhaps we should've put it
+            // point at -1, but I don't feel this is clearer.
+            self.current_segment_idx += 1;
+        }
+        self.update_current_segment();
+    }
+
+    #[inline]
+    fn update_current_segment(&mut self) {
+        self.current_or_prev_segment =
+            self.segments.get(self.current_segment_idx).unwrap_or(self.current_or_prev_segment);
+    }
+
+    #[inline]
+    pub(crate) fn ignore_last_segment(&mut self) {
+        self.segments = self.segments.strip_last();
+    }
+
+    #[inline]
+    pub(crate) fn set_current_segment(&mut self, segment: usize) {
+        self.current_segment_idx = segment;
+        self.current_or_prev_segment = self
+            .segments
+            .get(segment)
+            .expect("invalid segment passed to PathLoweringContext::set_current_segment()");
+    }
+
+    #[inline]
+    fn with_lifetime_elision<T>(
+        &mut self,
+        lifetime_elision: LifetimeElisionKind<'db>,
+        f: impl FnOnce(&mut PathLoweringContext<'_, '_, 'db>) -> T,
+    ) -> T {
+        let old_lifetime_elision =
+            std::mem::replace(&mut self.ctx.lifetime_elision, lifetime_elision);
+        let result = f(self);
+        self.ctx.lifetime_elision = old_lifetime_elision;
+        result
+    }
+
+    pub(crate) fn lower_ty_relative_path(
+        &mut self,
+        ty: Ty<'db>,
+        // We need the original resolution to lower `Self::AssocTy` correctly
+        res: Option<TypeNs>,
+    ) -> (Ty<'db>, Option<TypeNs>) {
+        let remaining_segments = self.segments.len() - self.current_segment_idx;
+        match remaining_segments {
+            0 => (ty, res),
+            1 => {
+                // resolve unselected assoc types
+                (self.select_associated_type(res), None)
+            }
+            _ => {
+                // FIXME report error (ambiguous associated type)
+                (Ty::new_error(self.ctx.interner, ErrorGuaranteed), None)
+            }
+        }
+    }
+
+    fn prohibit_parenthesized_generic_args(&mut self) -> bool {
+        if let Some(generic_args) = self.current_or_prev_segment.args_and_bindings {
+            match generic_args.parenthesized {
+                GenericArgsParentheses::No => {}
+                GenericArgsParentheses::ReturnTypeNotation | GenericArgsParentheses::ParenSugar => {
+                    let segment = self.current_segment_u32();
+                    self.on_diagnostic(
+                        PathLoweringDiagnostic::ParenthesizedGenericArgsWithoutFnTrait { segment },
+                    );
+                    return true;
+                }
+            }
+        }
+        false
+    }
+
+    // When calling this, the current segment is the resolved segment (we don't advance it yet).
+    pub(crate) fn lower_partly_resolved_path(
+        &mut self,
+        resolution: TypeNs,
+        infer_args: bool,
+    ) -> (Ty<'db>, Option<TypeNs>) {
+        let remaining_segments = self.segments.skip(self.current_segment_idx + 1);
+        tracing::debug!(?remaining_segments);
+        let rem_seg_len = remaining_segments.len();
+        tracing::debug!(?rem_seg_len);
+
+        let ty = match resolution {
+            TypeNs::TraitId(trait_) => {
+                let ty = match remaining_segments.len() {
+                    1 => {
+                        let trait_ref = self.lower_trait_ref_from_resolved_path(
+                            trait_,
+                            Ty::new_error(self.ctx.interner, ErrorGuaranteed),
+                        );
+                        tracing::debug!(?trait_ref);
+                        self.skip_resolved_segment();
+                        let segment = self.current_or_prev_segment;
+                        let trait_id = match trait_ref.def_id {
+                            SolverDefId::TraitId(id) => id,
+                            _ => unreachable!(),
+                        };
+                        let found =
+                            trait_id.trait_items(self.ctx.db).associated_type_by_name(segment.name);
+
+                        tracing::debug!(?found);
+                        match found {
+                            Some(associated_ty) => {
+                                // FIXME: `substs_from_path_segment()` pushes `TyKind::Error` for every parent
+                                // generic params. It's inefficient to splice the `Substitution`s, so we may want
+                                // that method to optionally take parent `Substitution` as we already know them at
+                                // this point (`trait_ref.substitution`).
+                                let substitution = self.substs_from_path_segment(
+                                    associated_ty.into(),
+                                    false,
+                                    None,
+                                    true,
+                                );
+                                let args = crate::next_solver::GenericArgs::new_from_iter(
+                                    self.ctx.interner,
+                                    trait_ref
+                                        .args
+                                        .iter()
+                                        .chain(substitution.iter().skip(trait_ref.args.len())),
+                                );
+                                Ty::new_alias(
+                                    self.ctx.interner,
+                                    AliasTyKind::Projection,
+                                    AliasTy::new_from_args(
+                                        self.ctx.interner,
+                                        associated_ty.into(),
+                                        args,
+                                    ),
+                                )
+                            }
+                            None => {
+                                // FIXME: report error (associated type not found)
+                                Ty::new_error(self.ctx.interner, ErrorGuaranteed)
+                            }
+                        }
+                    }
+                    0 => {
+                        // Trait object type without dyn; this should be handled in upstream. See
+                        // `lower_path()`.
+                        stdx::never!("unexpected fully resolved trait path");
+                        Ty::new_error(self.ctx.interner, ErrorGuaranteed)
+                    }
+                    _ => {
+                        // FIXME report error (ambiguous associated type)
+                        Ty::new_error(self.ctx.interner, ErrorGuaranteed)
+                    }
+                };
+                return (ty, None);
+            }
+            TypeNs::TraitAliasId(_) => {
+                // FIXME(trait_alias): Implement trait alias.
+                return (Ty::new_error(self.ctx.interner, ErrorGuaranteed), None);
+            }
+            TypeNs::GenericParam(param_id) => {
+                let generics = self.ctx.generics();
+                let idx = generics.type_or_const_param_idx(param_id.into());
+                match idx {
+                    None => {
+                        never!("no matching generics");
+                        Ty::new_error(self.ctx.interner, ErrorGuaranteed)
+                    }
+                    Some(idx) => {
+                        let (pidx, param) = generics.iter().nth(idx).unwrap();
+                        assert_eq!(pidx, param_id.into());
+                        let p = match param {
+                            GenericParamDataRef::TypeParamData(p) => p,
+                            _ => unreachable!(),
+                        };
+                        Ty::new_param(
+                            self.ctx.interner,
+                            idx as u32,
+                            p.name
+                                .as_ref()
+                                .map_or_else(|| sym::MISSING_NAME.clone(), |p| p.symbol().clone()),
+                        )
+                    }
+                }
+            }
+            TypeNs::SelfType(impl_id) => self.ctx.db.impl_self_ty_ns(impl_id).skip_binder(),
+            TypeNs::AdtSelfType(adt) => {
+                let args = crate::next_solver::GenericArgs::identity_for_item(
+                    self.ctx.interner,
+                    adt.into(),
+                );
+                Ty::new_adt(self.ctx.interner, AdtDef::new(adt, self.ctx.interner), args)
+            }
+
+            TypeNs::AdtId(it) => self.lower_path_inner(it.into(), infer_args),
+            TypeNs::BuiltinType(it) => self.lower_path_inner(it.into(), infer_args),
+            TypeNs::TypeAliasId(it) => self.lower_path_inner(it.into(), infer_args),
+            // FIXME: report error
+            TypeNs::EnumVariantId(_) | TypeNs::ModuleId(_) => {
+                return (Ty::new_error(self.ctx.interner, ErrorGuaranteed), None);
+            }
+        };
+
+        tracing::debug!(?ty);
+
+        self.skip_resolved_segment();
+        self.lower_ty_relative_path(ty, Some(resolution))
+    }
+
+    fn handle_type_ns_resolution(&mut self, resolution: &TypeNs) {
+        let mut prohibit_generics_on_resolved = |reason| {
+            if self.current_or_prev_segment.args_and_bindings.is_some() {
+                let segment = self.current_segment_u32();
+                self.on_diagnostic(PathLoweringDiagnostic::GenericArgsProhibited {
+                    segment,
+                    reason,
+                });
+            }
+        };
+
+        match resolution {
+            TypeNs::SelfType(_) => {
+                prohibit_generics_on_resolved(GenericArgsProhibitedReason::SelfTy)
+            }
+            TypeNs::GenericParam(_) => {
+                prohibit_generics_on_resolved(GenericArgsProhibitedReason::TyParam)
+            }
+            TypeNs::AdtSelfType(_) => {
+                prohibit_generics_on_resolved(GenericArgsProhibitedReason::SelfTy)
+            }
+            TypeNs::BuiltinType(_) => {
+                prohibit_generics_on_resolved(GenericArgsProhibitedReason::PrimitiveTy)
+            }
+            TypeNs::ModuleId(_) => {
+                prohibit_generics_on_resolved(GenericArgsProhibitedReason::Module)
+            }
+            TypeNs::AdtId(_)
+            | TypeNs::EnumVariantId(_)
+            | TypeNs::TypeAliasId(_)
+            | TypeNs::TraitId(_)
+            | TypeNs::TraitAliasId(_) => {}
+        }
+    }
+
+    pub(crate) fn resolve_path_in_type_ns_fully(&mut self) -> Option<TypeNs> {
+        let (res, unresolved) = self.resolve_path_in_type_ns()?;
+        if unresolved.is_some() {
+            return None;
+        }
+        Some(res)
+    }
+
+    #[tracing::instrument(skip(self), ret)]
+    pub(crate) fn resolve_path_in_type_ns(&mut self) -> Option<(TypeNs, Option<usize>)> {
+        let (resolution, remaining_index, _, prefix_info) =
+            self.ctx.resolver.resolve_path_in_type_ns_with_prefix_info(self.ctx.db, self.path)?;
+
+        let segments = self.segments;
+        if segments.is_empty() || matches!(self.path, Path::LangItem(..)) {
+            // `segments.is_empty()` can occur with `self`.
+            return Some((resolution, remaining_index));
+        }
+
+        let (module_segments, resolved_segment_idx, enum_segment) = match remaining_index {
+            None if prefix_info.enum_variant => {
+                (segments.strip_last_two(), segments.len() - 1, Some(segments.len() - 2))
+            }
+            None => (segments.strip_last(), segments.len() - 1, None),
+            Some(i) => (segments.take(i - 1), i - 1, None),
+        };
+
+        self.current_segment_idx = resolved_segment_idx;
+        self.current_or_prev_segment =
+            segments.get(resolved_segment_idx).expect("should have resolved segment");
+
+        if matches!(self.path, Path::BarePath(..)) {
+            // Bare paths cannot have generics, so skip them as an optimization.
+            return Some((resolution, remaining_index));
+        }
+
+        for (i, mod_segment) in module_segments.iter().enumerate() {
+            if mod_segment.args_and_bindings.is_some() {
+                self.on_diagnostic(PathLoweringDiagnostic::GenericArgsProhibited {
+                    segment: i as u32,
+                    reason: GenericArgsProhibitedReason::Module,
+                });
+            }
+        }
+
+        if let Some(enum_segment) = enum_segment
+            && segments.get(enum_segment).is_some_and(|it| it.args_and_bindings.is_some())
+            && segments.get(enum_segment + 1).is_some_and(|it| it.args_and_bindings.is_some())
+        {
+            self.on_diagnostic(PathLoweringDiagnostic::GenericArgsProhibited {
+                segment: (enum_segment + 1) as u32,
+                reason: GenericArgsProhibitedReason::EnumVariant,
+            });
+        }
+
+        self.handle_type_ns_resolution(&resolution);
+
+        Some((resolution, remaining_index))
+    }
+
+    pub(crate) fn resolve_path_in_value_ns(
+        &mut self,
+        hygiene_id: HygieneId,
+    ) -> Option<ResolveValueResult> {
+        let (res, prefix_info) = self.ctx.resolver.resolve_path_in_value_ns_with_prefix_info(
+            self.ctx.db,
+            self.path,
+            hygiene_id,
+        )?;
+
+        let segments = self.segments;
+        if segments.is_empty() || matches!(self.path, Path::LangItem(..)) {
+            // `segments.is_empty()` can occur with `self`.
+            return Some(res);
+        }
+
+        let (mod_segments, enum_segment, resolved_segment_idx) = match res {
+            ResolveValueResult::Partial(_, unresolved_segment, _) => {
+                (segments.take(unresolved_segment - 1), None, unresolved_segment - 1)
+            }
+            ResolveValueResult::ValueNs(ValueNs::EnumVariantId(_), _)
+                if prefix_info.enum_variant =>
+            {
+                (segments.strip_last_two(), segments.len().checked_sub(2), segments.len() - 1)
+            }
+            ResolveValueResult::ValueNs(..) => (segments.strip_last(), None, segments.len() - 1),
+        };
+
+        self.current_segment_idx = resolved_segment_idx;
+        self.current_or_prev_segment =
+            segments.get(resolved_segment_idx).expect("should have resolved segment");
+
+        for (i, mod_segment) in mod_segments.iter().enumerate() {
+            if mod_segment.args_and_bindings.is_some() {
+                self.on_diagnostic(PathLoweringDiagnostic::GenericArgsProhibited {
+                    segment: i as u32,
+                    reason: GenericArgsProhibitedReason::Module,
+                });
+            }
+        }
+
+        if let Some(enum_segment) = enum_segment
+            && segments.get(enum_segment).is_some_and(|it| it.args_and_bindings.is_some())
+            && segments.get(enum_segment + 1).is_some_and(|it| it.args_and_bindings.is_some())
+        {
+            self.on_diagnostic(PathLoweringDiagnostic::GenericArgsProhibited {
+                segment: (enum_segment + 1) as u32,
+                reason: GenericArgsProhibitedReason::EnumVariant,
+            });
+        }
+
+        match &res {
+            ResolveValueResult::ValueNs(resolution, _) => {
+                let resolved_segment_idx = self.current_segment_u32();
+                let resolved_segment = self.current_or_prev_segment;
+
+                let mut prohibit_generics_on_resolved = |reason| {
+                    if resolved_segment.args_and_bindings.is_some() {
+                        self.on_diagnostic(PathLoweringDiagnostic::GenericArgsProhibited {
+                            segment: resolved_segment_idx,
+                            reason,
+                        });
+                    }
+                };
+
+                match resolution {
+                    ValueNs::ImplSelf(_) => {
+                        prohibit_generics_on_resolved(GenericArgsProhibitedReason::SelfTy)
+                    }
+                    // FIXME: rustc generates E0107 (incorrect number of generic arguments) and not
+                    // E0109 (generic arguments provided for a type that doesn't accept them) for
+                    // consts and statics, presumably as a defense against future in which consts
+                    // and statics can be generic, or just because it was easier for rustc implementors.
+                    // That means we'll show the wrong error code. Because of us it's easier to do it
+                    // this way :)
+                    ValueNs::GenericParam(_) | ValueNs::ConstId(_) => {
+                        prohibit_generics_on_resolved(GenericArgsProhibitedReason::Const)
+                    }
+                    ValueNs::StaticId(_) => {
+                        prohibit_generics_on_resolved(GenericArgsProhibitedReason::Static)
+                    }
+                    ValueNs::FunctionId(_) | ValueNs::StructId(_) | ValueNs::EnumVariantId(_) => {}
+                    ValueNs::LocalBinding(_) => {}
+                }
+            }
+            ResolveValueResult::Partial(resolution, _, _) => {
+                self.handle_type_ns_resolution(resolution);
+            }
+        };
+        Some(res)
+    }
+
+    #[tracing::instrument(skip(self), ret)]
+    fn select_associated_type(&mut self, res: Option<TypeNs>) -> Ty<'db> {
+        let interner = self.ctx.interner;
+        let Some(res) = res else {
+            return Ty::new_error(self.ctx.interner, ErrorGuaranteed);
+        };
+        let segment = self.current_or_prev_segment;
+        let assoc_name = segment.name;
+        let db = self.ctx.db;
+        let def = self.ctx.def;
+        let mut search = |t: TraitRef<'db>| {
+            let trait_id = match t.def_id {
+                SolverDefId::TraitId(id) => id,
+                _ => unreachable!(),
+            };
+            let mut checked_traits = FxHashSet::default();
+            let mut check_trait = |trait_id: TraitId| {
+                let name = &db.trait_signature(trait_id).name;
+                tracing::debug!(?trait_id, ?name);
+                if !checked_traits.insert(trait_id) {
+                    return None;
+                }
+                let data = trait_id.trait_items(db);
+
+                tracing::debug!(?data.items);
+                for (name, assoc_id) in &data.items {
+                    if let &AssocItemId::TypeAliasId(alias) = assoc_id {
+                        if name != assoc_name {
+                            continue;
+                        }
+
+                        // FIXME: `substs_from_path_segment()` pushes `TyKind::Error` for every parent
+                        // generic params. It's inefficient to splice the `Substitution`s, so we may want
+                        // that method to optionally take parent `Substitution` as we already know them at
+                        // this point (`t.substitution`).
+                        let substs = self.substs_from_path_segment(alias.into(), false, None, true);
+
+                        let substs = crate::next_solver::GenericArgs::new_from_iter(
+                            interner,
+                            t.args.iter().chain(substs.iter().skip(t.args.len())),
+                        );
+
+                        return Some(Ty::new_alias(
+                            interner,
+                            AliasTyKind::Projection,
+                            AliasTy::new(interner, alias.into(), substs),
+                        ));
+                    }
+                }
+                None
+            };
+            let mut stack: SmallVec<[_; 4]> = smallvec![trait_id];
+            while let Some(trait_def_id) = stack.pop() {
+                if let Some(alias) = check_trait(trait_def_id) {
+                    return alias;
+                }
+                for pred in generic_predicates_filtered_by(
+                    db,
+                    GenericDefId::TraitId(trait_def_id),
+                    PredicateFilter::SelfTrait,
+                    |pred| pred == GenericDefId::TraitId(trait_def_id),
+                )
+                .0
+                .deref()
+                {
+                    tracing::debug!(?pred);
+                    let trait_id = match pred.kind().skip_binder() {
+                        rustc_type_ir::ClauseKind::Trait(pred) => pred.def_id(),
+                        _ => continue,
+                    };
+                    let trait_id = match trait_id {
+                        SolverDefId::TraitId(trait_id) => trait_id,
+                        _ => continue,
+                    };
+                    stack.push(trait_id);
+                }
+                tracing::debug!(?stack);
+            }
+
+            Ty::new_error(interner, ErrorGuaranteed)
+        };
+
+        match res {
+            TypeNs::SelfType(impl_id) => {
+                let trait_ref = db.impl_trait_ns(impl_id);
+                let Some(trait_ref) = trait_ref else {
+                    return Ty::new_error(interner, ErrorGuaranteed);
+                };
+
+                // we're _in_ the impl -- the binders get added back later. Correct,
+                // but it would be nice to make this more explicit
+                search(trait_ref.skip_binder())
+            }
+            TypeNs::GenericParam(param_id) => {
+                // Handle `Self::Type` referring to own associated type in trait definitions
+                // This *must* be done first to avoid cycles with
+                // `generic_predicates_for_param`, but not sure that it's sufficient,
+                // see FIXME in `search`.
+                if let GenericDefId::TraitId(trait_id) = param_id.parent() {
+                    let trait_name = &db.trait_signature(trait_id).name;
+                    tracing::debug!(?trait_name);
+                    let trait_generics = generics(db, trait_id.into());
+                    tracing::debug!(?trait_generics);
+                    if trait_generics[param_id.local_id()].is_trait_self() {
+                        let args = crate::next_solver::GenericArgs::identity_for_item(
+                            interner,
+                            trait_id.into(),
+                        );
+                        let trait_ref = TraitRef::new_from_args(interner, trait_id.into(), args);
+                        tracing::debug!(?args, ?trait_ref);
+                        return search(trait_ref);
+                    }
+                }
+
+                let predicates = db.generic_predicates_for_param_ns(
+                    def,
+                    param_id.into(),
+                    Some(segment.name.clone()),
+                );
+                predicates
+                    .iter()
+                    .find_map(|pred| match (*pred).kind().skip_binder() {
+                        rustc_type_ir::ClauseKind::Trait(trait_predicate) => Some(trait_predicate),
+                        _ => None,
+                    })
+                    .map(|trait_predicate| {
+                        let trait_ref = trait_predicate.trait_ref;
+                        assert!(
+                            !trait_ref.has_escaping_bound_vars(),
+                            "FIXME unexpected higher-ranked trait bound"
+                        );
+                        search(trait_ref)
+                    })
+                    .unwrap_or_else(|| Ty::new_error(interner, ErrorGuaranteed))
+            }
+            _ => Ty::new_error(interner, ErrorGuaranteed),
+        }
+    }
+
+    fn lower_path_inner(&mut self, typeable: TyDefId, infer_args: bool) -> Ty<'db> {
+        let generic_def = match typeable {
+            TyDefId::BuiltinType(builtinty) => return builtin(self.ctx.interner, builtinty),
+            TyDefId::AdtId(it) => it.into(),
+            TyDefId::TypeAliasId(it) => it.into(),
+        };
+        let args = self.substs_from_path_segment(generic_def, infer_args, None, false);
+        let ty = ty_query(self.ctx.db, typeable);
+        ty.instantiate(self.ctx.interner, args)
+    }
+
+    /// Collect generic arguments from a path into a `Substs`. See also
+    /// `create_substs_for_ast_path` and `def_to_ty` in rustc.
+    pub(crate) fn substs_from_path(
+        &mut self,
+        // Note that we don't call `db.value_type(resolved)` here,
+        // `ValueTyDefId` is just a convenient way to pass generics and
+        // special-case enum variants
+        resolved: ValueTyDefId,
+        infer_args: bool,
+        lowering_assoc_type_generics: bool,
+    ) -> crate::next_solver::GenericArgs<'db> {
+        let interner = self.ctx.interner;
+        let prev_current_segment_idx = self.current_segment_idx;
+        let prev_current_segment = self.current_or_prev_segment;
+
+        let generic_def = match resolved {
+            ValueTyDefId::FunctionId(it) => it.into(),
+            ValueTyDefId::StructId(it) => it.into(),
+            ValueTyDefId::UnionId(it) => it.into(),
+            ValueTyDefId::ConstId(it) => it.into(),
+            ValueTyDefId::StaticId(_) => {
+                return crate::next_solver::GenericArgs::new_from_iter(interner, []);
+            }
+            ValueTyDefId::EnumVariantId(var) => {
+                // the generic args for an enum variant may be either specified
+                // on the segment referring to the enum, or on the segment
+                // referring to the variant. So `Option::<T>::None` and
+                // `Option::None::<T>` are both allowed (though the former is
+                // FIXME: This isn't strictly correct, enum variants may be used not through the enum
+                // (via `use Enum::Variant`). The resolver returns whether they were, but we don't have its result
+                // available here. The worst that can happen is that we will show some confusing diagnostics to the user,
+                // if generics exist on the module and they don't match with the variant.
+                // preferred). See also `def_ids_for_path_segments` in rustc.
+                //
+                // `wrapping_sub(1)` will return a number which `get` will return None for if current_segment_idx<2.
+                // This simplifies the code a bit.
+                let penultimate_idx = self.current_segment_idx.wrapping_sub(1);
+                let penultimate = self.segments.get(penultimate_idx);
+                if let Some(penultimate) = penultimate
+                    && self.current_or_prev_segment.args_and_bindings.is_none()
+                    && penultimate.args_and_bindings.is_some()
+                {
+                    self.current_segment_idx = penultimate_idx;
+                    self.current_or_prev_segment = penultimate;
+                }
+                var.lookup(self.ctx.db).parent.into()
+            }
+        };
+        let result = self.substs_from_path_segment(
+            generic_def,
+            infer_args,
+            None,
+            lowering_assoc_type_generics,
+        );
+        self.current_segment_idx = prev_current_segment_idx;
+        self.current_or_prev_segment = prev_current_segment;
+        result
+    }
+
+    pub(crate) fn substs_from_path_segment(
+        &mut self,
+        def: GenericDefId,
+        infer_args: bool,
+        explicit_self_ty: Option<Ty<'db>>,
+        lowering_assoc_type_generics: bool,
+    ) -> crate::next_solver::GenericArgs<'db> {
+        let mut lifetime_elision = self.ctx.lifetime_elision.clone();
+
+        if let Some(args) = self.current_or_prev_segment.args_and_bindings
+            && args.parenthesized != GenericArgsParentheses::No
+        {
+            let prohibit_parens = match def {
+                GenericDefId::TraitId(trait_) => {
+                    // RTN is prohibited anyways if we got here.
+                    let is_rtn = args.parenthesized == GenericArgsParentheses::ReturnTypeNotation;
+                    let is_fn_trait = self
+                        .ctx
+                        .db
+                        .trait_signature(trait_)
+                        .flags
+                        .contains(TraitFlags::RUSTC_PAREN_SUGAR);
+                    is_rtn || !is_fn_trait
+                }
+                _ => true,
+            };
+
+            if prohibit_parens {
+                let segment = self.current_segment_u32();
+                self.on_diagnostic(
+                    PathLoweringDiagnostic::ParenthesizedGenericArgsWithoutFnTrait { segment },
+                );
+
+                return unknown_subst(self.ctx.interner, def);
+            }
+
+            // `Fn()`-style generics are treated like functions for the purpose of lifetime elision.
+            lifetime_elision =
+                LifetimeElisionKind::AnonymousCreateParameter { report_in_path: false };
+        }
+
+        self.substs_from_args_and_bindings(
+            self.current_or_prev_segment.args_and_bindings,
+            def,
+            infer_args,
+            explicit_self_ty,
+            PathGenericsSource::Segment(self.current_segment_u32()),
+            lowering_assoc_type_generics,
+            lifetime_elision,
+        )
+    }
+
+    pub(super) fn substs_from_args_and_bindings(
+        &mut self,
+        args_and_bindings: Option<&GenericArgs>,
+        def: GenericDefId,
+        infer_args: bool,
+        explicit_self_ty: Option<Ty<'db>>,
+        generics_source: PathGenericsSource,
+        lowering_assoc_type_generics: bool,
+        lifetime_elision: LifetimeElisionKind<'db>,
+    ) -> crate::next_solver::GenericArgs<'db> {
+        struct LowererCtx<'a, 'b, 'c, 'db> {
+            ctx: &'a mut PathLoweringContext<'b, 'c, 'db>,
+            generics_source: PathGenericsSource,
+        }
+
+        impl<'db> GenericArgsLowerer<'db> for LowererCtx<'_, '_, '_, 'db> {
+            fn report_len_mismatch(
+                &mut self,
+                def: GenericDefId,
+                provided_count: u32,
+                expected_count: u32,
+                kind: IncorrectGenericsLenKind,
+            ) {
+                self.ctx.on_diagnostic(PathLoweringDiagnostic::IncorrectGenericsLen {
+                    generics_source: self.generics_source,
+                    provided_count,
+                    expected_count,
+                    kind,
+                    def,
+                });
+            }
+
+            fn report_arg_mismatch(
+                &mut self,
+                param_id: GenericParamId,
+                arg_idx: u32,
+                has_self_arg: bool,
+            ) {
+                self.ctx.on_diagnostic(PathLoweringDiagnostic::IncorrectGenericsOrder {
+                    generics_source: self.generics_source,
+                    param_id,
+                    arg_idx,
+                    has_self_arg,
+                });
+            }
+
+            fn provided_kind(
+                &mut self,
+                param_id: GenericParamId,
+                param: GenericParamDataRef<'_>,
+                arg: &GenericArg,
+            ) -> crate::next_solver::GenericArg<'db> {
+                match (param, arg) {
+                    (GenericParamDataRef::LifetimeParamData(_), GenericArg::Lifetime(lifetime)) => {
+                        self.ctx.ctx.lower_lifetime(*lifetime).into()
+                    }
+                    (GenericParamDataRef::TypeParamData(_), GenericArg::Type(type_ref)) => {
+                        self.ctx.ctx.lower_ty(*type_ref).into()
+                    }
+                    (GenericParamDataRef::ConstParamData(_), GenericArg::Const(konst)) => {
+                        let GenericParamId::ConstParamId(const_id) = param_id else {
+                            unreachable!("non-const param ID for const param");
+                        };
+                        self.ctx
+                            .ctx
+                            .lower_const(konst, const_param_ty_query(self.ctx.ctx.db, const_id))
+                            .into()
+                    }
+                    _ => unreachable!("unmatching param kinds were passed to `provided_kind()`"),
+                }
+            }
+
+            fn provided_type_like_const(
+                &mut self,
+                const_ty: Ty<'db>,
+                arg: TypeLikeConst<'_>,
+            ) -> crate::next_solver::Const<'db> {
+                match arg {
+                    TypeLikeConst::Path(path) => self.ctx.ctx.lower_path_as_const(path, const_ty),
+                    TypeLikeConst::Infer => unknown_const(const_ty),
+                }
+            }
+
+            fn inferred_kind(
+                &mut self,
+                def: GenericDefId,
+                param_id: GenericParamId,
+                param: GenericParamDataRef<'_>,
+                infer_args: bool,
+                preceding_args: &[crate::next_solver::GenericArg<'db>],
+            ) -> crate::next_solver::GenericArg<'db> {
+                let default = || {
+                    self.ctx.ctx.db.generic_defaults(def).get(preceding_args.len()).map(|default| {
+                        convert_binder_to_early_binder(
+                            self.ctx.ctx.interner,
+                            default.to_nextsolver(self.ctx.ctx.interner),
+                        )
+                        .instantiate(self.ctx.ctx.interner, preceding_args)
+                    })
+                };
+                match param {
+                    GenericParamDataRef::LifetimeParamData(_) => {
+                        Region::new(self.ctx.ctx.interner, rustc_type_ir::ReError(ErrorGuaranteed))
+                            .into()
+                    }
+                    GenericParamDataRef::TypeParamData(param) => {
+                        if !infer_args
+                            && param.default.is_some()
+                            && let Some(default) = default()
+                        {
+                            return default;
+                        }
+                        Ty::new_error(self.ctx.ctx.interner, ErrorGuaranteed).into()
+                    }
+                    GenericParamDataRef::ConstParamData(param) => {
+                        if !infer_args
+                            && param.default.is_some()
+                            && let Some(default) = default()
+                        {
+                            return default;
+                        }
+                        let GenericParamId::ConstParamId(const_id) = param_id else {
+                            unreachable!("non-const param ID for const param");
+                        };
+                        unknown_const_as_generic(const_param_ty_query(self.ctx.ctx.db, const_id))
+                    }
+                }
+            }
+
+            fn parent_arg(
+                &mut self,
+                param_id: GenericParamId,
+            ) -> crate::next_solver::GenericArg<'db> {
+                match param_id {
+                    GenericParamId::TypeParamId(_) => {
+                        Ty::new_error(self.ctx.ctx.interner, ErrorGuaranteed).into()
+                    }
+                    GenericParamId::ConstParamId(const_id) => {
+                        unknown_const_as_generic(const_param_ty_query(self.ctx.ctx.db, const_id))
+                    }
+                    GenericParamId::LifetimeParamId(_) => {
+                        Region::new(self.ctx.ctx.interner, rustc_type_ir::ReError(ErrorGuaranteed))
+                            .into()
+                    }
+                }
+            }
+
+            fn report_elided_lifetimes_in_path(
+                &mut self,
+                def: GenericDefId,
+                expected_count: u32,
+                hard_error: bool,
+            ) {
+                self.ctx.on_diagnostic(PathLoweringDiagnostic::ElidedLifetimesInPath {
+                    generics_source: self.generics_source,
+                    def,
+                    expected_count,
+                    hard_error,
+                });
+            }
+
+            fn report_elision_failure(&mut self, def: GenericDefId, expected_count: u32) {
+                self.ctx.on_diagnostic(PathLoweringDiagnostic::ElisionFailure {
+                    generics_source: self.generics_source,
+                    def,
+                    expected_count,
+                });
+            }
+
+            fn report_missing_lifetime(&mut self, def: GenericDefId, expected_count: u32) {
+                self.ctx.on_diagnostic(PathLoweringDiagnostic::MissingLifetime {
+                    generics_source: self.generics_source,
+                    def,
+                    expected_count,
+                });
+            }
+        }
+
+        substs_from_args_and_bindings(
+            self.ctx.db,
+            self.ctx.store,
+            args_and_bindings,
+            def,
+            infer_args,
+            lifetime_elision,
+            lowering_assoc_type_generics,
+            explicit_self_ty,
+            &mut LowererCtx { ctx: self, generics_source },
+        )
+    }
+
+    pub(crate) fn lower_trait_ref_from_resolved_path(
+        &mut self,
+        resolved: TraitId,
+        explicit_self_ty: Ty<'db>,
+    ) -> TraitRef<'db> {
+        let args = self.trait_ref_substs_from_path(resolved, explicit_self_ty);
+        TraitRef::new_from_args(self.ctx.interner, resolved.into(), args)
+    }
+
+    fn trait_ref_substs_from_path(
+        &mut self,
+        resolved: TraitId,
+        explicit_self_ty: Ty<'db>,
+    ) -> crate::next_solver::GenericArgs<'db> {
+        self.substs_from_path_segment(resolved.into(), false, Some(explicit_self_ty), false)
+    }
+
+    pub(super) fn assoc_type_bindings_from_type_bound<'c>(
+        mut self,
+        trait_ref: TraitRef<'db>,
+    ) -> Option<impl Iterator<Item = Clause<'db>> + use<'a, 'b, 'c, 'db>> {
+        let interner = self.ctx.interner;
+        self.current_or_prev_segment.args_and_bindings.map(|args_and_bindings| {
+            args_and_bindings.bindings.iter().enumerate().flat_map(move |(binding_idx, binding)| {
+                let found = associated_type_by_name_including_super_traits(
+                    self.ctx.db,
+                    trait_ref,
+                    &binding.name,
+                );
+                let (super_trait_ref, associated_ty) = match found {
+                    None => return SmallVec::new(),
+                    Some(t) => t,
+                };
+                let args =
+                    self.with_lifetime_elision(LifetimeElisionKind::AnonymousReportError, |this| {
+                        // FIXME: `substs_from_path_segment()` pushes `TyKind::Error` for every parent
+                        // generic params. It's inefficient to splice the `Substitution`s, so we may want
+                        // that method to optionally take parent `Substitution` as we already know them at
+                        // this point (`super_trait_ref.substitution`).
+                        this.substs_from_args_and_bindings(
+                            binding.args.as_ref(),
+                            associated_ty.into(),
+                            false, // this is not relevant
+                            Some(super_trait_ref.self_ty()),
+                            PathGenericsSource::AssocType {
+                                segment: this.current_segment_u32(),
+                                assoc_type: binding_idx as u32,
+                            },
+                            false,
+                            this.ctx.lifetime_elision.clone(),
+                        )
+                    });
+                let args = crate::next_solver::GenericArgs::new_from_iter(
+                    interner,
+                    super_trait_ref.args.iter().chain(args.iter().skip(super_trait_ref.args.len())),
+                );
+                let projection_term =
+                    AliasTerm::new_from_args(interner, associated_ty.into(), args);
+                let mut predicates: SmallVec<[_; 1]> = SmallVec::with_capacity(
+                    binding.type_ref.as_ref().map_or(0, |_| 1) + binding.bounds.len(),
+                );
+                if let Some(type_ref) = binding.type_ref {
+                    match (&self.ctx.store[type_ref], self.ctx.impl_trait_mode.mode) {
+                        (TypeRef::ImplTrait(_), ImplTraitLoweringMode::Disallowed) => (),
+                        (_, ImplTraitLoweringMode::Disallowed | ImplTraitLoweringMode::Opaque) => {
+                            let ty = self.ctx.lower_ty(type_ref);
+                            let pred = Clause(Predicate::new(
+                                interner,
+                                Binder::dummy(rustc_type_ir::PredicateKind::Clause(
+                                    rustc_type_ir::ClauseKind::Projection(ProjectionPredicate {
+                                        projection_term,
+                                        term: ty.into(),
+                                    }),
+                                )),
+                            ));
+                            predicates.push(pred);
+                        }
+                    }
+                }
+                for bound in binding.bounds.iter() {
+                    predicates.extend(self.ctx.lower_type_bound(
+                        bound,
+                        Ty::new_alias(
+                            self.ctx.interner,
+                            AliasTyKind::Projection,
+                            AliasTy::new_from_args(self.ctx.interner, associated_ty.into(), args),
+                        ),
+                        false,
+                    ));
+                }
+                predicates
+            })
+        })
+    }
+}
+
+/// A const that were parsed like a type.
+pub(crate) enum TypeLikeConst<'a> {
+    Infer,
+    Path(&'a Path),
+}
+
+pub(crate) trait GenericArgsLowerer<'db> {
+    fn report_elided_lifetimes_in_path(
+        &mut self,
+        def: GenericDefId,
+        expected_count: u32,
+        hard_error: bool,
+    );
+
+    fn report_elision_failure(&mut self, def: GenericDefId, expected_count: u32);
+
+    fn report_missing_lifetime(&mut self, def: GenericDefId, expected_count: u32);
+
+    fn report_len_mismatch(
+        &mut self,
+        def: GenericDefId,
+        provided_count: u32,
+        expected_count: u32,
+        kind: IncorrectGenericsLenKind,
+    );
+
+    fn report_arg_mismatch(&mut self, param_id: GenericParamId, arg_idx: u32, has_self_arg: bool);
+
+    fn provided_kind(
+        &mut self,
+        param_id: GenericParamId,
+        param: GenericParamDataRef<'_>,
+        arg: &GenericArg,
+    ) -> crate::next_solver::GenericArg<'db>;
+
+    fn provided_type_like_const(&mut self, const_ty: Ty<'db>, arg: TypeLikeConst<'_>)
+    -> Const<'db>;
+
+    fn inferred_kind(
+        &mut self,
+        def: GenericDefId,
+        param_id: GenericParamId,
+        param: GenericParamDataRef<'_>,
+        infer_args: bool,
+        preceding_args: &[crate::next_solver::GenericArg<'db>],
+    ) -> crate::next_solver::GenericArg<'db>;
+
+    fn parent_arg(&mut self, param_id: GenericParamId) -> crate::next_solver::GenericArg<'db>;
+}
+
+/// Returns true if there was an error.
+fn check_generic_args_len<'db>(
+    args_and_bindings: Option<&GenericArgs>,
+    def: GenericDefId,
+    def_generics: &Generics,
+    infer_args: bool,
+    lifetime_elision: &LifetimeElisionKind<'db>,
+    lowering_assoc_type_generics: bool,
+    ctx: &mut impl GenericArgsLowerer<'db>,
+) -> bool {
+    let mut had_error = false;
+
+    let (mut provided_lifetimes_count, mut provided_types_and_consts_count) = (0usize, 0usize);
+    if let Some(args_and_bindings) = args_and_bindings {
+        let args_no_self = &args_and_bindings.args[usize::from(args_and_bindings.has_self_type)..];
+        for arg in args_no_self {
+            match arg {
+                GenericArg::Lifetime(_) => provided_lifetimes_count += 1,
+                GenericArg::Type(_) | GenericArg::Const(_) => provided_types_and_consts_count += 1,
+            }
+        }
+    }
+
+    let lifetime_args_len = def_generics.len_lifetimes_self();
+    if provided_lifetimes_count == 0 && lifetime_args_len > 0 && !lowering_assoc_type_generics {
+        // In generic associated types, we never allow inferring the lifetimes.
+        match lifetime_elision {
+            &LifetimeElisionKind::AnonymousCreateParameter { report_in_path } => {
+                ctx.report_elided_lifetimes_in_path(def, lifetime_args_len as u32, report_in_path);
+                had_error |= report_in_path;
+            }
+            LifetimeElisionKind::AnonymousReportError => {
+                ctx.report_missing_lifetime(def, lifetime_args_len as u32);
+                had_error = true
+            }
+            LifetimeElisionKind::ElisionFailure => {
+                ctx.report_elision_failure(def, lifetime_args_len as u32);
+                had_error = true;
+            }
+            LifetimeElisionKind::StaticIfNoLifetimeInScope { only_lint: _ } => {
+                // FIXME: Check there are other lifetimes in scope, and error/lint.
+            }
+            LifetimeElisionKind::Elided(_) => {
+                ctx.report_elided_lifetimes_in_path(def, lifetime_args_len as u32, false);
+            }
+            LifetimeElisionKind::Infer => {
+                // Allow eliding lifetimes.
+            }
+        }
+    } else if lifetime_args_len != provided_lifetimes_count {
+        ctx.report_len_mismatch(
+            def,
+            provided_lifetimes_count as u32,
+            lifetime_args_len as u32,
+            IncorrectGenericsLenKind::Lifetimes,
+        );
+        had_error = true;
+    }
+
+    let defaults_count =
+        def_generics.iter_self_type_or_consts().filter(|(_, param)| param.has_default()).count();
+    let named_type_and_const_params_count = def_generics
+        .iter_self_type_or_consts()
+        .filter(|(_, param)| match param {
+            TypeOrConstParamData::TypeParamData(param) => {
+                param.provenance == TypeParamProvenance::TypeParamList
+            }
+            TypeOrConstParamData::ConstParamData(_) => true,
+        })
+        .count();
+    let expected_max = named_type_and_const_params_count;
+    let expected_min =
+        if infer_args { 0 } else { named_type_and_const_params_count - defaults_count };
+    if provided_types_and_consts_count < expected_min
+        || expected_max < provided_types_and_consts_count
+    {
+        ctx.report_len_mismatch(
+            def,
+            provided_types_and_consts_count as u32,
+            named_type_and_const_params_count as u32,
+            IncorrectGenericsLenKind::TypesAndConsts,
+        );
+        had_error = true;
+    }
+
+    had_error
+}
+
+pub(crate) fn substs_from_args_and_bindings<'db>(
+    db: &'db dyn HirDatabase,
+    store: &ExpressionStore,
+    args_and_bindings: Option<&GenericArgs>,
+    def: GenericDefId,
+    mut infer_args: bool,
+    lifetime_elision: LifetimeElisionKind<'db>,
+    lowering_assoc_type_generics: bool,
+    explicit_self_ty: Option<Ty<'db>>,
+    ctx: &mut impl GenericArgsLowerer<'db>,
+) -> crate::next_solver::GenericArgs<'db> {
+    let interner = DbInterner::new_with(db, None, None);
+
+    tracing::debug!(?args_and_bindings);
+
+    // Order is
+    // - Parent parameters
+    // - Optional Self parameter
+    // - Lifetime parameters
+    // - Type or Const parameters
+    let def_generics = generics(db, def);
+    let args_slice = args_and_bindings.map(|it| &*it.args).unwrap_or_default();
+
+    // We do not allow inference if there are specified args, i.e. we do not allow partial inference.
+    let has_non_lifetime_args =
+        args_slice.iter().any(|arg| !matches!(arg, GenericArg::Lifetime(_)));
+    infer_args &= !has_non_lifetime_args;
+
+    let had_count_error = check_generic_args_len(
+        args_and_bindings,
+        def,
+        &def_generics,
+        infer_args,
+        &lifetime_elision,
+        lowering_assoc_type_generics,
+        ctx,
+    );
+
+    let mut substs = Vec::with_capacity(def_generics.len());
+
+    substs.extend(def_generics.iter_parent_id().map(|id| ctx.parent_arg(id)));
+
+    let mut args = args_slice.iter().enumerate().peekable();
+    let mut params = def_generics.iter_self().peekable();
+
+    // If we encounter a type or const when we expect a lifetime, we infer the lifetimes.
+    // If we later encounter a lifetime, we know that the arguments were provided in the
+    // wrong order. `force_infer_lt` records the type or const that forced lifetimes to be
+    // inferred, so we can use it for diagnostics later.
+    let mut force_infer_lt = None;
+
+    let has_self_arg = args_and_bindings.is_some_and(|it| it.has_self_type);
+    // First, handle `Self` parameter. Consume it from the args if provided, otherwise from `explicit_self_ty`,
+    // and lastly infer it.
+    if let Some(&(
+        self_param_id,
+        self_param @ GenericParamDataRef::TypeParamData(TypeParamData {
+            provenance: TypeParamProvenance::TraitSelf,
+            ..
+        }),
+    )) = params.peek()
+    {
+        let self_ty = if has_self_arg {
+            let (_, self_ty) = args.next().expect("has_self_type=true, should have Self type");
+            ctx.provided_kind(self_param_id, self_param, self_ty)
+        } else {
+            explicit_self_ty.map(|it| it.into()).unwrap_or_else(|| {
+                ctx.inferred_kind(def, self_param_id, self_param, infer_args, &substs)
+            })
+        };
+        params.next();
+        substs.push(self_ty);
+    }
+
+    loop {
+        // We're going to iterate through the generic arguments that the user
+        // provided, matching them with the generic parameters we expect.
+        // Mismatches can occur as a result of elided lifetimes, or for malformed
+        // input. We try to handle both sensibly.
+        match (args.peek(), params.peek()) {
+            (Some(&(arg_idx, arg)), Some(&(param_id, param))) => match (arg, param) {
+                (GenericArg::Type(_), GenericParamDataRef::TypeParamData(type_param))
+                    if type_param.provenance == TypeParamProvenance::ArgumentImplTrait =>
+                {
+                    // Do not allow specifying `impl Trait` explicitly. We already err at that, but if we won't handle it here
+                    // we will handle it as if it was specified, instead of inferring it.
+                    substs.push(ctx.inferred_kind(def, param_id, param, infer_args, &substs));
+                    params.next();
+                }
+                (GenericArg::Lifetime(_), GenericParamDataRef::LifetimeParamData(_))
+                | (GenericArg::Type(_), GenericParamDataRef::TypeParamData(_))
+                | (GenericArg::Const(_), GenericParamDataRef::ConstParamData(_)) => {
+                    substs.push(ctx.provided_kind(param_id, param, arg));
+                    args.next();
+                    params.next();
+                }
+                (
+                    GenericArg::Type(_) | GenericArg::Const(_),
+                    GenericParamDataRef::LifetimeParamData(_),
+                ) => {
+                    // We expected a lifetime argument, but got a type or const
+                    // argument. That means we're inferring the lifetime.
+                    substs.push(ctx.inferred_kind(def, param_id, param, infer_args, &substs));
+                    params.next();
+                    force_infer_lt = Some((arg_idx as u32, param_id));
+                }
+                (GenericArg::Type(type_ref), GenericParamDataRef::ConstParamData(_)) => {
+                    if let Some(konst) = type_looks_like_const(store, *type_ref) {
+                        let GenericParamId::ConstParamId(param_id) = param_id else {
+                            panic!("unmatching param kinds");
+                        };
+                        let const_ty = const_param_ty_query(db, param_id);
+                        substs.push(ctx.provided_type_like_const(const_ty, konst).into());
+                        args.next();
+                        params.next();
+                    } else {
+                        // See the `_ => { ... }` branch.
+                        if !had_count_error {
+                            ctx.report_arg_mismatch(param_id, arg_idx as u32, has_self_arg);
+                        }
+                        while args.next().is_some() {}
+                    }
+                }
+                _ => {
+                    // We expected one kind of parameter, but the user provided
+                    // another. This is an error. However, if we already know that
+                    // the arguments don't match up with the parameters, we won't issue
+                    // an additional error, as the user already knows what's wrong.
+                    if !had_count_error {
+                        ctx.report_arg_mismatch(param_id, arg_idx as u32, has_self_arg);
+                    }
+
+                    // We've reported the error, but we want to make sure that this
+                    // problem doesn't bubble down and create additional, irrelevant
+                    // errors. In this case, we're simply going to ignore the argument
+                    // and any following arguments. The rest of the parameters will be
+                    // inferred.
+                    while args.next().is_some() {}
+                }
+            },
+
+            (Some(&(_, arg)), None) => {
+                // We should never be able to reach this point with well-formed input.
+                // There are two situations in which we can encounter this issue.
+                //
+                //  1. The number of arguments is incorrect. In this case, an error
+                //     will already have been emitted, and we can ignore it.
+                //  2. We've inferred some lifetimes, which have been provided later (i.e.
+                //     after a type or const). We want to throw an error in this case.
+                if !had_count_error {
+                    assert!(
+                        matches!(arg, GenericArg::Lifetime(_)),
+                        "the only possible situation here is incorrect lifetime order"
+                    );
+                    let (provided_arg_idx, param_id) =
+                        force_infer_lt.expect("lifetimes ought to have been inferred");
+                    ctx.report_arg_mismatch(param_id, provided_arg_idx, has_self_arg);
+                }
+
+                break;
+            }
+
+            (None, Some(&(param_id, param))) => {
+                // If there are fewer arguments than parameters, it means we're inferring the remaining arguments.
+                let param = if let GenericParamId::LifetimeParamId(_) = param_id {
+                    match &lifetime_elision {
+                        LifetimeElisionKind::ElisionFailure
+                        | LifetimeElisionKind::AnonymousCreateParameter { report_in_path: true }
+                        | LifetimeElisionKind::AnonymousReportError => {
+                            assert!(had_count_error);
+                            ctx.inferred_kind(def, param_id, param, infer_args, &substs)
+                        }
+                        LifetimeElisionKind::StaticIfNoLifetimeInScope { only_lint: _ } => {
+                            Region::new_static(interner).into()
+                        }
+                        LifetimeElisionKind::Elided(lifetime) => (*lifetime).into(),
+                        LifetimeElisionKind::AnonymousCreateParameter { report_in_path: false }
+                        | LifetimeElisionKind::Infer => {
+                            // FIXME: With `AnonymousCreateParameter`, we need to create a new lifetime parameter here
+                            // (but this will probably be done in hir-def lowering instead).
+                            ctx.inferred_kind(def, param_id, param, infer_args, &substs)
+                        }
+                    }
+                } else {
+                    ctx.inferred_kind(def, param_id, param, infer_args, &substs)
+                };
+                substs.push(param);
+                params.next();
+            }
+
+            (None, None) => break,
+        }
+    }
+
+    crate::next_solver::GenericArgs::new_from_iter(interner, substs)
+}
+
+fn type_looks_like_const(
+    store: &ExpressionStore,
+    type_ref: TypeRefId,
+) -> Option<TypeLikeConst<'_>> {
+    // A path/`_` const will be parsed as a type, instead of a const, because when parsing/lowering
+    // in hir-def we don't yet know the expected argument kind. rustc does this a bit differently,
+    // when lowering to HIR it resolves the path, and if it doesn't resolve to the type namespace
+    // it is lowered as a const. Our behavior could deviate from rustc when the value is resolvable
+    // in both the type and value namespaces, but I believe we only allow more code.
+    let type_ref = &store[type_ref];
+    match type_ref {
+        TypeRef::Path(path) => Some(TypeLikeConst::Path(path)),
+        TypeRef::Placeholder => Some(TypeLikeConst::Infer),
+        _ => None,
+    }
+}
+
+fn unknown_subst<'db>(
+    interner: DbInterner<'db>,
+    def: impl Into<GenericDefId>,
+) -> crate::next_solver::GenericArgs<'db> {
+    let params = generics(interner.db(), def.into());
+    crate::next_solver::GenericArgs::new_from_iter(
+        interner,
+        params.iter_id().map(|id| match id {
+            GenericParamId::TypeParamId(_) => Ty::new_error(interner, ErrorGuaranteed).into(),
+            GenericParamId::ConstParamId(id) => {
+                unknown_const_as_generic(const_param_ty_query(interner.db(), id))
+            }
+            GenericParamId::LifetimeParamId(_) => {
+                crate::next_solver::Region::error(interner).into()
+            }
+        }),
+    )
+}
+
+pub(crate) fn builtin<'db>(interner: DbInterner<'db>, builtin: BuiltinType) -> Ty<'db> {
+    match builtin {
+        BuiltinType::Char => Ty::new(interner, rustc_type_ir::TyKind::Char),
+        BuiltinType::Bool => Ty::new_bool(interner),
+        BuiltinType::Str => Ty::new(interner, rustc_type_ir::TyKind::Str),
+        BuiltinType::Int(t) => {
+            let int_ty = match primitive::int_ty_from_builtin(t) {
+                chalk_ir::IntTy::Isize => rustc_type_ir::IntTy::Isize,
+                chalk_ir::IntTy::I8 => rustc_type_ir::IntTy::I8,
+                chalk_ir::IntTy::I16 => rustc_type_ir::IntTy::I16,
+                chalk_ir::IntTy::I32 => rustc_type_ir::IntTy::I32,
+                chalk_ir::IntTy::I64 => rustc_type_ir::IntTy::I64,
+                chalk_ir::IntTy::I128 => rustc_type_ir::IntTy::I128,
+            };
+            Ty::new_int(interner, int_ty)
+        }
+        BuiltinType::Uint(t) => {
+            let uint_ty = match primitive::uint_ty_from_builtin(t) {
+                chalk_ir::UintTy::Usize => rustc_type_ir::UintTy::Usize,
+                chalk_ir::UintTy::U8 => rustc_type_ir::UintTy::U8,
+                chalk_ir::UintTy::U16 => rustc_type_ir::UintTy::U16,
+                chalk_ir::UintTy::U32 => rustc_type_ir::UintTy::U32,
+                chalk_ir::UintTy::U64 => rustc_type_ir::UintTy::U64,
+                chalk_ir::UintTy::U128 => rustc_type_ir::UintTy::U128,
+            };
+            Ty::new_uint(interner, uint_ty)
+        }
+        BuiltinType::Float(t) => {
+            let float_ty = match primitive::float_ty_from_builtin(t) {
+                chalk_ir::FloatTy::F16 => rustc_type_ir::FloatTy::F16,
+                chalk_ir::FloatTy::F32 => rustc_type_ir::FloatTy::F32,
+                chalk_ir::FloatTy::F64 => rustc_type_ir::FloatTy::F64,
+                chalk_ir::FloatTy::F128 => rustc_type_ir::FloatTy::F128,
+            };
+            Ty::new_float(interner, float_ty)
+        }
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
index b22781e947013..49438151bbff5 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
@@ -16,22 +16,24 @@ use hir_def::{
 use hir_expand::name::Name;
 use intern::sym;
 use rustc_hash::{FxHashMap, FxHashSet};
+use rustc_type_ir::inherent::{IntoKind, SliceLike};
 use smallvec::{SmallVec, smallvec};
 use stdx::never;
 use triomphe::Arc;
 
 use crate::{
     AdtId, Canonical, CanonicalVarKinds, DebruijnIndex, DynTyExt, ForeignDefId, GenericArgData,
-    Goal, Guidance, InEnvironment, Interner, Mutability, Scalar, Solution, Substitution,
-    TraitEnvironment, TraitRef, TraitRefExt, Ty, TyBuilder, TyExt, TyKind, TyVariableKind,
-    VariableKind, WhereClause,
+    Goal, InEnvironment, Interner, Mutability, Scalar, Substitution, TraitEnvironment, TraitRef,
+    TraitRefExt, Ty, TyBuilder, TyExt, TyKind, TyVariableKind, VariableKind, WhereClause,
     autoderef::{self, AutoderefKind},
     db::HirDatabase,
     error_lifetime, from_chalk_trait_id, from_foreign_def_id,
     infer::{Adjust, Adjustment, OverloadedDeref, PointerCast, unify::InferenceTable},
     lang_items::is_box,
+    next_solver::SolverDefId,
     primitive::{FloatTy, IntTy, UintTy},
     to_chalk_trait_id,
+    traits::NextTraitSolveResult,
     utils::all_super_traits,
 };
 
@@ -43,6 +45,7 @@ pub enum TyFingerprint {
     Slice,
     Array,
     Never,
+    Ref(Mutability),
     RawPtr(Mutability),
     Scalar(Scalar),
     // These can have user-defined impls:
@@ -88,7 +91,7 @@ impl TyFingerprint {
             TyKind::Raw(mutability, ..) => TyFingerprint::RawPtr(*mutability),
             TyKind::Foreign(alias_id, ..) => TyFingerprint::ForeignType(*alias_id),
             TyKind::Dyn(_) => ty.dyn_trait().map(TyFingerprint::Dyn)?,
-            TyKind::Ref(_, _, ty) => return TyFingerprint::for_trait_impl(ty),
+            TyKind::Ref(mutability, _, _) => TyFingerprint::Ref(*mutability),
             TyKind::Tuple(_, subst) => {
                 let first_ty = subst.interned().first().map(|arg| arg.assert_ty_ref(Interner));
                 match first_ty {
@@ -113,6 +116,94 @@ impl TyFingerprint {
         };
         Some(fp)
     }
+
+    /// Creates a TyFingerprint for looking up a trait impl.
+    pub fn for_trait_impl_ns<'db>(ty: &crate::next_solver::Ty<'db>) -> Option<TyFingerprint> {
+        use rustc_type_ir::TyKind;
+        let fp = match (*ty).kind() {
+            TyKind::Str => TyFingerprint::Str,
+            TyKind::Never => TyFingerprint::Never,
+            TyKind::Slice(..) => TyFingerprint::Slice,
+            TyKind::Array(..) => TyFingerprint::Array,
+            TyKind::Int(int) => TyFingerprint::Scalar(Scalar::Int(match int {
+                rustc_type_ir::IntTy::Isize => IntTy::Isize,
+                rustc_type_ir::IntTy::I8 => IntTy::I8,
+                rustc_type_ir::IntTy::I16 => IntTy::I16,
+                rustc_type_ir::IntTy::I32 => IntTy::I32,
+                rustc_type_ir::IntTy::I64 => IntTy::I64,
+                rustc_type_ir::IntTy::I128 => IntTy::I128,
+            })),
+            TyKind::Uint(uint) => TyFingerprint::Scalar(Scalar::Uint(match uint {
+                rustc_type_ir::UintTy::Usize => UintTy::Usize,
+                rustc_type_ir::UintTy::U8 => UintTy::U8,
+                rustc_type_ir::UintTy::U16 => UintTy::U16,
+                rustc_type_ir::UintTy::U32 => UintTy::U32,
+                rustc_type_ir::UintTy::U64 => UintTy::U64,
+                rustc_type_ir::UintTy::U128 => UintTy::U128,
+            })),
+            TyKind::Float(float) => TyFingerprint::Scalar(Scalar::Float(match float {
+                rustc_type_ir::FloatTy::F16 => FloatTy::F16,
+                rustc_type_ir::FloatTy::F32 => FloatTy::F32,
+                rustc_type_ir::FloatTy::F64 => FloatTy::F64,
+                rustc_type_ir::FloatTy::F128 => FloatTy::F128,
+            })),
+            TyKind::Bool => TyFingerprint::Scalar(Scalar::Bool),
+            TyKind::Char => TyFingerprint::Scalar(Scalar::Char),
+            TyKind::Adt(def, _) => TyFingerprint::Adt(def.inner().id),
+            TyKind::RawPtr(.., mutability) => match mutability {
+                rustc_ast_ir::Mutability::Mut => TyFingerprint::RawPtr(Mutability::Mut),
+                rustc_ast_ir::Mutability::Not => TyFingerprint::RawPtr(Mutability::Not),
+            },
+            TyKind::Foreign(def) => {
+                let SolverDefId::ForeignId(def) = def else { unreachable!() };
+                TyFingerprint::ForeignType(crate::to_foreign_def_id(def))
+            }
+            TyKind::Dynamic(bounds, _, _) => {
+                let trait_ref = bounds
+                    .as_slice()
+                    .iter()
+                    .map(|b| (*b).skip_binder())
+                    .filter_map(|b| match b {
+                        rustc_type_ir::ExistentialPredicate::Trait(t) => Some(t.def_id),
+                        _ => None,
+                    })
+                    .next()?;
+                let trait_id = match trait_ref {
+                    SolverDefId::TraitId(id) => id,
+                    _ => panic!("Bad GenericDefId in trait ref"),
+                };
+                TyFingerprint::Dyn(trait_id)
+            }
+            TyKind::Ref(_, _, mutability) => match mutability {
+                rustc_ast_ir::Mutability::Mut => TyFingerprint::Ref(Mutability::Mut),
+                rustc_ast_ir::Mutability::Not => TyFingerprint::Ref(Mutability::Not),
+            },
+            TyKind::Tuple(tys) => {
+                let first_ty = tys.as_slice().iter().next();
+                match first_ty {
+                    Some(ty) => return TyFingerprint::for_trait_impl_ns(ty),
+                    None => TyFingerprint::Unit,
+                }
+            }
+            TyKind::FnDef(_, _)
+            | TyKind::Closure(_, _)
+            | TyKind::Coroutine(..)
+            | TyKind::CoroutineWitness(..)
+            | TyKind::Pat(..)
+            | TyKind::CoroutineClosure(..) => TyFingerprint::Unnameable,
+            TyKind::FnPtr(sig, _) => {
+                TyFingerprint::Function(sig.inputs().skip_binder().len() as u32)
+            }
+            TyKind::Alias(..)
+            | TyKind::Placeholder(_)
+            | TyKind::Bound(..)
+            | TyKind::Infer(_)
+            | TyKind::Error(_)
+            | TyKind::Param(..)
+            | TyKind::UnsafeBinder(..) => return None,
+        };
+        Some(fp)
+    }
 }
 
 pub(crate) const ALL_INT_FPS: [TyFingerprint; 12] = [
@@ -807,10 +898,13 @@ fn find_matching_impl(
 
             let wcs = crate::chalk_db::convert_where_clauses(db, impl_.into(), &impl_substs)
                 .into_iter()
-                .map(|b| b.cast(Interner));
-            let goal = crate::Goal::all(Interner, wcs);
-            table.try_obligation(goal.clone())?;
-            table.register_obligation(goal);
+                .map(|b| -> Goal { b.cast(Interner) });
+            for goal in wcs {
+                if table.try_obligation(goal.clone()).no_solution() {
+                    return None;
+                }
+                table.register_obligation(goal);
+            }
             Some((impl_.impl_items(db), table.resolve_completely(impl_substs)))
         })
     })
@@ -1313,7 +1407,7 @@ fn iterate_trait_method_candidates(
                 };
             if !known_implemented {
                 let goal = generic_implements_goal(db, &table.trait_env, t, &canonical_self_ty);
-                if db.trait_solve(krate, block, goal.cast(Interner)).is_none() {
+                if db.trait_solve(krate, block, goal.cast(Interner)).no_solution() {
                     continue 'traits;
                 }
             }
@@ -1496,9 +1590,9 @@ pub(crate) fn resolve_indexing_op(
     let deref_chain = autoderef_method_receiver(&mut table, ty);
     for (ty, adj) in deref_chain {
         let goal = generic_implements_goal(db, &table.trait_env, index_trait, &ty);
-        if db
+        if !db
             .trait_solve(table.trait_env.krate, table.trait_env.block, goal.cast(Interner))
-            .is_some()
+            .no_solution()
         {
             return Some(adj);
         }
@@ -1692,7 +1786,7 @@ fn is_valid_impl_fn_candidate(
             );
 
             match solution {
-                Some(Solution::Unique(canonical_subst)) => {
+                NextTraitSolveResult::Certain(canonical_subst) => {
                     canonicalized.apply_solution(
                         table,
                         Canonical {
@@ -1701,16 +1795,13 @@ fn is_valid_impl_fn_candidate(
                         },
                     );
                 }
-                Some(Solution::Ambig(Guidance::Definite(substs))) => {
-                    canonicalized.apply_solution(table, substs);
-                }
-                Some(_) => (),
-                None => return IsValidCandidate::No,
+                NextTraitSolveResult::Uncertain(..) => {}
+                NextTraitSolveResult::NoSolution => return IsValidCandidate::No,
             }
         }
 
         for goal in goals {
-            if table.try_obligation(goal).is_none() {
+            if table.try_obligation(goal).no_solution() {
                 return IsValidCandidate::No;
             }
         }
@@ -1726,9 +1817,7 @@ pub fn implements_trait(
     trait_: TraitId,
 ) -> bool {
     let goal = generic_implements_goal(db, env, trait_, ty);
-    let solution = db.trait_solve(env.krate, env.block, goal.cast(Interner));
-
-    solution.is_some()
+    !db.trait_solve(env.krate, env.block, goal.cast(Interner)).no_solution()
 }
 
 pub fn implements_trait_unique(
@@ -1738,9 +1827,7 @@ pub fn implements_trait_unique(
     trait_: TraitId,
 ) -> bool {
     let goal = generic_implements_goal(db, env, trait_, ty);
-    let solution = db.trait_solve(env.krate, env.block, goal.cast(Interner));
-
-    matches!(solution, Some(crate::Solution::Unique(_)))
+    db.trait_solve(env.krate, env.block, goal.cast(Interner)).certain()
 }
 
 /// This creates Substs for a trait with the given Self type and type variables
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/tests.rs
index c1f86960e154c..eb5af58f2ea18 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/tests.rs
@@ -5,7 +5,9 @@ use syntax::{TextRange, TextSize};
 use test_fixture::WithFixture;
 
 use crate::display::DisplayTarget;
-use crate::{Interner, Substitution, db::HirDatabase, mir::MirLowerError, test_db::TestDB};
+use crate::{
+    Interner, Substitution, db::HirDatabase, mir::MirLowerError, setup_tracing, test_db::TestDB,
+};
 
 use super::{MirEvalError, interpret_mir};
 
@@ -49,6 +51,7 @@ fn check_pass_and_stdio(
     expected_stdout: &str,
     expected_stderr: &str,
 ) {
+    let _tracing = setup_tracing();
     let (db, file_ids) = TestDB::with_many_files(ra_fixture);
     let file_id = *file_ids.last().unwrap();
     let x = eval_main(&db, file_id);
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
index eb80e8706fa0c..0bb8e6fe79d65 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
@@ -2163,7 +2163,9 @@ pub fn mir_body_query(db: &dyn HirDatabase, def: DefWithBodyId) -> Result<Arc<Mi
     let _p = tracing::info_span!("mir_body_query", ?detail).entered();
     let body = db.body(def);
     let infer = db.infer(def);
-    let mut result = lower_to_mir(db, def, &body, &infer, body.body_expr)?;
+    let mut result = crate::next_solver::with_new_cache(|| {
+        lower_to_mir(db, def, &body, &infer, body.body_expr)
+    })?;
     result.shrink_to_fit();
     Ok(Arc::new(result))
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver.rs
new file mode 100644
index 0000000000000..21762aa66a858
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver.rs
@@ -0,0 +1,46 @@
+//! Things relevant to the next trait solver.
+#![allow(unused, unreachable_pub)]
+
+pub mod abi;
+mod consts;
+mod def_id;
+pub mod fold;
+mod fulfill;
+mod generic_arg;
+pub mod generics;
+pub mod infer;
+//mod infer_new;
+pub mod interner;
+mod ir_print;
+pub mod mapping;
+mod opaques;
+pub mod predicate;
+pub(crate) mod project;
+mod region;
+mod solver;
+mod ty;
+pub mod util;
+
+pub use consts::*;
+pub use def_id::*;
+pub use generic_arg::*;
+//pub use infer_new::*;
+pub use interner::*;
+pub use opaques::*;
+pub use predicate::*;
+pub use region::*;
+pub use solver::*;
+pub use ty::*;
+
+pub type Binder<'db, T> = rustc_type_ir::Binder<DbInterner<'db>, T>;
+pub type EarlyBinder<'db, T> = rustc_type_ir::EarlyBinder<DbInterner<'db>, T>;
+pub type Canonical<'db, T> = rustc_type_ir::Canonical<DbInterner<'db>, T>;
+pub type CanonicalVarValues<'db> = rustc_type_ir::CanonicalVarValues<DbInterner<'db>>;
+pub type CanonicalVarKind<'db> = rustc_type_ir::CanonicalVarKind<DbInterner<'db>>;
+pub type CanonicalQueryInput<'db, V> = rustc_type_ir::CanonicalQueryInput<DbInterner<'db>, V>;
+pub type AliasTy<'db> = rustc_type_ir::AliasTy<DbInterner<'db>>;
+pub type PolyFnSig<'db> = Binder<'db, rustc_type_ir::FnSig<DbInterner<'db>>>;
+pub type TypingMode<'db> = rustc_type_ir::TypingMode<DbInterner<'db>>;
+
+pub type FxIndexMap<K, V> =
+    indexmap::IndexMap<K, V, std::hash::BuildHasherDefault<rustc_hash::FxHasher>>;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/abi.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/abi.rs
new file mode 100644
index 0000000000000..80d1ea4aa4d00
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/abi.rs
@@ -0,0 +1,68 @@
+//! ABI-related things in the next-trait-solver.
+use rustc_type_ir::{error::TypeError, relate::Relate};
+
+use crate::FnAbi;
+
+use super::interner::DbInterner;
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+pub enum Safety {
+    Unsafe,
+    Safe,
+}
+
+impl<'db> Relate<DbInterner<'db>> for Safety {
+    fn relate<R: rustc_type_ir::relate::TypeRelation<DbInterner<'db>>>(
+        _relation: &mut R,
+        a: Self,
+        b: Self,
+    ) -> rustc_type_ir::relate::RelateResult<DbInterner<'db>, Self> {
+        if a != b {
+            Err(TypeError::SafetyMismatch(rustc_type_ir::error::ExpectedFound::new(a, b)))
+        } else {
+            Ok(a)
+        }
+    }
+}
+
+impl<'db> rustc_type_ir::inherent::Safety<DbInterner<'db>> for Safety {
+    fn safe() -> Self {
+        Self::Safe
+    }
+
+    fn is_safe(self) -> bool {
+        matches!(self, Safety::Safe)
+    }
+
+    fn prefix_str(self) -> &'static str {
+        match self {
+            Self::Unsafe => "unsafe ",
+            Self::Safe => "",
+        }
+    }
+}
+
+impl<'db> Relate<DbInterner<'db>> for FnAbi {
+    fn relate<R: rustc_type_ir::relate::TypeRelation<DbInterner<'db>>>(
+        _relation: &mut R,
+        a: Self,
+        b: Self,
+    ) -> rustc_type_ir::relate::RelateResult<DbInterner<'db>, Self> {
+        if a == b {
+            Ok(a)
+        } else {
+            Err(TypeError::AbiMismatch(rustc_type_ir::error::ExpectedFound::new(a, b)))
+        }
+    }
+}
+
+impl<'db> rustc_type_ir::inherent::Abi<DbInterner<'db>> for FnAbi {
+    fn rust() -> Self {
+        FnAbi::Rust
+    }
+
+    fn is_rust(self) -> bool {
+        // TODO: rustc does not consider `RustCall` to be true here, but Chalk does
+        matches!(self, FnAbi::Rust | FnAbi::RustCall)
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs
new file mode 100644
index 0000000000000..5698ff290f748
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs
@@ -0,0 +1,404 @@
+//! Things related to consts in the next-trait-solver.
+
+use std::hash::Hash;
+
+use intern::{Interned, Symbol};
+use rustc_ast_ir::try_visit;
+use rustc_ast_ir::visit::VisitorResult;
+use rustc_type_ir::{
+    BoundVar, FlagComputation, Flags, TypeFoldable, TypeSuperFoldable, TypeSuperVisitable,
+    TypeVisitable, WithCachedTypeInfo,
+    inherent::{IntoKind, PlaceholderLike},
+    relate::Relate,
+};
+
+use crate::{ConstScalar, MemoryMap, interner::InternedWrapperNoDebug};
+
+use super::{BoundVarKind, DbInterner, ErrorGuaranteed, GenericArgs, Placeholder, Ty};
+
+pub type ConstKind<'db> = rustc_type_ir::ConstKind<DbInterner<'db>>;
+pub type UnevaluatedConst<'db> = rustc_type_ir::UnevaluatedConst<DbInterner<'db>>;
+
+#[salsa::interned(constructor = new_, debug)]
+pub struct Const<'db> {
+    #[returns(ref)]
+    kind_: InternedWrapperNoDebug<WithCachedTypeInfo<ConstKind<'db>>>,
+}
+
+impl<'db> Const<'db> {
+    pub fn new(interner: DbInterner<'db>, kind: ConstKind<'db>) -> Self {
+        let flags = FlagComputation::for_const_kind(&kind);
+        let cached = WithCachedTypeInfo {
+            internee: kind,
+            flags: flags.flags,
+            outer_exclusive_binder: flags.outer_exclusive_binder,
+        };
+        Const::new_(interner.db(), InternedWrapperNoDebug(cached))
+    }
+
+    pub fn inner(&self) -> &WithCachedTypeInfo<ConstKind<'db>> {
+        salsa::with_attached_database(|db| {
+            let inner = &self.kind_(db).0;
+            // SAFETY: The caller already has access to a `Const<'db>`, so borrowchecking will
+            // make sure that our returned value is valid for the lifetime `'db`.
+            unsafe { std::mem::transmute(inner) }
+        })
+        .unwrap()
+    }
+
+    pub fn error(interner: DbInterner<'db>) -> Self {
+        Const::new(interner, rustc_type_ir::ConstKind::Error(ErrorGuaranteed))
+    }
+
+    pub fn new_param(interner: DbInterner<'db>, param: ParamConst) -> Self {
+        Const::new(interner, rustc_type_ir::ConstKind::Param(param))
+    }
+
+    pub fn new_placeholder(interner: DbInterner<'db>, placeholder: PlaceholderConst) -> Self {
+        Const::new(interner, ConstKind::Placeholder(placeholder))
+    }
+
+    pub fn is_ct_infer(&self) -> bool {
+        matches!(&self.inner().internee, ConstKind::Infer(_))
+    }
+
+    pub fn is_trivially_wf(self) -> bool {
+        match self.kind() {
+            ConstKind::Param(_) | ConstKind::Placeholder(_) | ConstKind::Bound(..) => true,
+            ConstKind::Infer(_)
+            | ConstKind::Unevaluated(..)
+            | ConstKind::Value(_)
+            | ConstKind::Error(_)
+            | ConstKind::Expr(_) => false,
+        }
+    }
+}
+
+impl<'db> std::fmt::Debug for InternedWrapperNoDebug<WithCachedTypeInfo<ConstKind<'db>>> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.0.internee.fmt(f)
+    }
+}
+
+pub type PlaceholderConst = Placeholder<rustc_type_ir::BoundVar>;
+
+#[derive(Copy, Clone, Hash, Eq, PartialEq)]
+pub struct ParamConst {
+    pub index: u32,
+}
+
+impl std::fmt::Debug for ParamConst {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "#{}", self.index)
+    }
+}
+
+/// A type-level constant value.
+///
+/// Represents a typed, fully evaluated constant.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub struct ValueConst<'db> {
+    pub(crate) ty: Ty<'db>,
+    pub(crate) value: Valtree<'db>,
+}
+
+impl<'db> ValueConst<'db> {
+    pub fn new(ty: Ty<'db>, bytes: ConstBytes) -> Self {
+        let value = Valtree::new(bytes);
+        ValueConst { ty, value }
+    }
+}
+
+impl<'db> rustc_type_ir::inherent::ValueConst<DbInterner<'db>> for ValueConst<'db> {
+    fn ty(self) -> Ty<'db> {
+        self.ty
+    }
+
+    fn valtree(self) -> Valtree<'db> {
+        self.value
+    }
+}
+
+impl<'db> rustc_type_ir::TypeVisitable<DbInterner<'db>> for ValueConst<'db> {
+    fn visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>(
+        &self,
+        visitor: &mut V,
+    ) -> V::Result {
+        self.ty.visit_with(visitor)
+    }
+}
+
+impl<'db> rustc_type_ir::TypeFoldable<DbInterner<'db>> for ValueConst<'db> {
+    fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self {
+        ValueConst { ty: self.ty.fold_with(folder), value: self.value }
+    }
+    fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>(
+        self,
+        folder: &mut F,
+    ) -> Result<Self, F::Error> {
+        Ok(ValueConst { ty: self.ty.try_fold_with(folder)?, value: self.value })
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ConstBytes(pub Box<[u8]>, pub MemoryMap);
+
+impl Hash for ConstBytes {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.0.hash(state)
+    }
+}
+
+#[salsa::interned(constructor = new_, debug)]
+pub struct Valtree<'db> {
+    #[returns(ref)]
+    bytes_: ConstBytes,
+}
+
+impl<'db> Valtree<'db> {
+    pub fn new(bytes: ConstBytes) -> Self {
+        salsa::with_attached_database(|db| unsafe {
+            // SAFETY: ¯\_(ツ)_/¯
+            std::mem::transmute(Valtree::new_(db, bytes))
+        })
+        .unwrap()
+    }
+
+    pub fn inner(&self) -> &ConstBytes {
+        salsa::with_attached_database(|db| {
+            let inner = self.bytes_(db);
+            // SAFETY: The caller already has access to a `Valtree<'db>`, so borrowchecking will
+            // make sure that our returned value is valid for the lifetime `'db`.
+            unsafe { std::mem::transmute(inner) }
+        })
+        .unwrap()
+    }
+}
+
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+pub struct ExprConst;
+
+impl rustc_type_ir::inherent::ParamLike for ParamConst {
+    fn index(self) -> u32 {
+        self.index
+    }
+}
+
+impl<'db> IntoKind for Const<'db> {
+    type Kind = ConstKind<'db>;
+
+    fn kind(self) -> Self::Kind {
+        self.inner().internee
+    }
+}
+
+impl<'db> TypeVisitable<DbInterner<'db>> for Const<'db> {
+    fn visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>(
+        &self,
+        visitor: &mut V,
+    ) -> V::Result {
+        visitor.visit_const(*self)
+    }
+}
+
+impl<'db> TypeSuperVisitable<DbInterner<'db>> for Const<'db> {
+    fn super_visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>(
+        &self,
+        visitor: &mut V,
+    ) -> V::Result {
+        match self.kind() {
+            ConstKind::Unevaluated(uv) => uv.visit_with(visitor),
+            ConstKind::Value(v) => v.visit_with(visitor),
+            ConstKind::Expr(e) => e.visit_with(visitor),
+            ConstKind::Error(e) => e.visit_with(visitor),
+
+            ConstKind::Param(_)
+            | ConstKind::Infer(_)
+            | ConstKind::Bound(..)
+            | ConstKind::Placeholder(_) => V::Result::output(),
+        }
+    }
+}
+
+impl<'db> TypeFoldable<DbInterner<'db>> for Const<'db> {
+    fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>(
+        self,
+        folder: &mut F,
+    ) -> Result<Self, F::Error> {
+        folder.try_fold_const(self)
+    }
+    fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self {
+        folder.fold_const(self)
+    }
+}
+
+impl<'db> TypeSuperFoldable<DbInterner<'db>> for Const<'db> {
+    fn try_super_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>(
+        self,
+        folder: &mut F,
+    ) -> Result<Self, F::Error> {
+        let kind = match self.kind() {
+            ConstKind::Unevaluated(uv) => ConstKind::Unevaluated(uv.try_fold_with(folder)?),
+            ConstKind::Value(v) => ConstKind::Value(v.try_fold_with(folder)?),
+            ConstKind::Expr(e) => ConstKind::Expr(e.try_fold_with(folder)?),
+
+            ConstKind::Param(_)
+            | ConstKind::Infer(_)
+            | ConstKind::Bound(..)
+            | ConstKind::Placeholder(_)
+            | ConstKind::Error(_) => return Ok(self),
+        };
+        if kind != self.kind() { Ok(Const::new(folder.cx(), kind)) } else { Ok(self) }
+    }
+    fn super_fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(
+        self,
+        folder: &mut F,
+    ) -> Self {
+        let kind = match self.kind() {
+            ConstKind::Unevaluated(uv) => ConstKind::Unevaluated(uv.fold_with(folder)),
+            ConstKind::Value(v) => ConstKind::Value(v.fold_with(folder)),
+            ConstKind::Expr(e) => ConstKind::Expr(e.fold_with(folder)),
+
+            ConstKind::Param(_)
+            | ConstKind::Infer(_)
+            | ConstKind::Bound(..)
+            | ConstKind::Placeholder(_)
+            | ConstKind::Error(_) => return self,
+        };
+        if kind != self.kind() { Const::new(folder.cx(), kind) } else { self }
+    }
+}
+
+impl<'db> Relate<DbInterner<'db>> for Const<'db> {
+    fn relate<R: rustc_type_ir::relate::TypeRelation<DbInterner<'db>>>(
+        relation: &mut R,
+        a: Self,
+        b: Self,
+    ) -> rustc_type_ir::relate::RelateResult<DbInterner<'db>, Self> {
+        relation.consts(a, b)
+    }
+}
+
+impl<'db> Flags for Const<'db> {
+    fn flags(&self) -> rustc_type_ir::TypeFlags {
+        self.inner().flags
+    }
+
+    fn outer_exclusive_binder(&self) -> rustc_type_ir::DebruijnIndex {
+        self.inner().outer_exclusive_binder
+    }
+}
+
+impl<'db> rustc_type_ir::inherent::Const<DbInterner<'db>> for Const<'db> {
+    fn new_infer(interner: DbInterner<'db>, var: rustc_type_ir::InferConst) -> Self {
+        Const::new(interner, ConstKind::Infer(var))
+    }
+
+    fn new_var(interner: DbInterner<'db>, var: rustc_type_ir::ConstVid) -> Self {
+        Const::new(interner, ConstKind::Infer(rustc_type_ir::InferConst::Var(var)))
+    }
+
+    fn new_bound(
+        interner: DbInterner<'db>,
+        debruijn: rustc_type_ir::DebruijnIndex,
+        var: BoundVar,
+    ) -> Self {
+        Const::new(interner, ConstKind::Bound(debruijn, var))
+    }
+
+    fn new_anon_bound(
+        interner: DbInterner<'db>,
+        debruijn: rustc_type_ir::DebruijnIndex,
+        var: rustc_type_ir::BoundVar,
+    ) -> Self {
+        Const::new(interner, ConstKind::Bound(debruijn, var))
+    }
+
+    fn new_unevaluated(
+        interner: DbInterner<'db>,
+        uv: rustc_type_ir::UnevaluatedConst<DbInterner<'db>>,
+    ) -> Self {
+        Const::new(interner, ConstKind::Unevaluated(uv))
+    }
+
+    fn new_expr(interner: DbInterner<'db>, expr: ExprConst) -> Self {
+        Const::new(interner, ConstKind::Expr(expr))
+    }
+
+    fn new_error(interner: DbInterner<'db>, guar: ErrorGuaranteed) -> Self {
+        Const::new(interner, ConstKind::Error(guar))
+    }
+
+    fn new_placeholder(
+        interner: DbInterner<'db>,
+        param: <DbInterner<'db> as rustc_type_ir::Interner>::PlaceholderConst,
+    ) -> Self {
+        Const::new(interner, ConstKind::Placeholder(param))
+    }
+}
+
+impl<'db> PlaceholderLike<DbInterner<'db>> for PlaceholderConst {
+    type Bound = rustc_type_ir::BoundVar;
+
+    fn universe(self) -> rustc_type_ir::UniverseIndex {
+        self.universe
+    }
+
+    fn var(self) -> rustc_type_ir::BoundVar {
+        self.bound
+    }
+
+    fn with_updated_universe(self, ui: rustc_type_ir::UniverseIndex) -> Self {
+        Placeholder { universe: ui, bound: self.bound }
+    }
+
+    fn new(ui: rustc_type_ir::UniverseIndex, var: rustc_type_ir::BoundVar) -> Self {
+        Placeholder { universe: ui, bound: var }
+    }
+    fn new_anon(ui: rustc_type_ir::UniverseIndex, var: rustc_type_ir::BoundVar) -> Self {
+        Placeholder { universe: ui, bound: var }
+    }
+}
+
+impl<'db> TypeVisitable<DbInterner<'db>> for ExprConst {
+    fn visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>(
+        &self,
+        visitor: &mut V,
+    ) -> V::Result {
+        // Ensure we get back to this when we fill in the fields
+        let ExprConst = &self;
+        V::Result::output()
+    }
+}
+
+impl<'db> TypeFoldable<DbInterner<'db>> for ExprConst {
+    fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>(
+        self,
+        folder: &mut F,
+    ) -> Result<Self, F::Error> {
+        Ok(ExprConst)
+    }
+    fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self {
+        ExprConst
+    }
+}
+
+impl<'db> Relate<DbInterner<'db>> for ExprConst {
+    fn relate<R: rustc_type_ir::relate::TypeRelation<DbInterner<'db>>>(
+        relation: &mut R,
+        a: Self,
+        b: Self,
+    ) -> rustc_type_ir::relate::RelateResult<DbInterner<'db>, Self> {
+        // Ensure we get back to this when we fill in the fields
+        let ExprConst = b;
+        Ok(a)
+    }
+}
+
+impl<'db> rustc_type_ir::inherent::ExprConst<DbInterner<'db>> for ExprConst {
+    fn args(self) -> <DbInterner<'db> as rustc_type_ir::Interner>::GenericArgs {
+        // Ensure we get back to this when we fill in the fields
+        let ExprConst = self;
+        GenericArgs::default()
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
new file mode 100644
index 0000000000000..cfbc10e740e4b
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
@@ -0,0 +1,96 @@
+//! Definition of `SolverDefId`
+
+use hir_def::{
+    AdtId, ConstId, EnumId, EnumVariantId, FunctionId, GenericDefId, ImplId, StaticId, StructId,
+    TraitAliasId, TraitId, TypeAliasId, UnionId,
+};
+use rustc_type_ir::inherent;
+use stdx::impl_from;
+
+use crate::db::{InternedClosureId, InternedCoroutineId, InternedOpaqueTyId};
+
+use super::DbInterner;
+
+#[derive(Debug, PartialOrd, Ord, Clone, Copy, PartialEq, Eq, Hash, salsa::Supertype)]
+pub enum Ctor {
+    Struct(StructId),
+    Enum(EnumVariantId),
+}
+
+#[derive(Debug, PartialOrd, Ord, Clone, Copy, PartialEq, Eq, Hash, salsa::Supertype)]
+pub enum SolverDefId {
+    AdtId(AdtId),
+    ConstId(ConstId),
+    FunctionId(FunctionId),
+    ImplId(ImplId),
+    StaticId(StaticId),
+    TraitAliasId(TraitAliasId),
+    TraitId(TraitId),
+    TypeAliasId(TypeAliasId),
+    ForeignId(TypeAliasId),
+    InternedClosureId(InternedClosureId),
+    InternedCoroutineId(InternedCoroutineId),
+    InternedOpaqueTyId(InternedOpaqueTyId),
+    Ctor(Ctor),
+}
+
+impl_from!(
+    AdtId(StructId, EnumId, UnionId),
+    ConstId,
+    FunctionId,
+    ImplId,
+    StaticId,
+    TraitAliasId,
+    TraitId,
+    TypeAliasId,
+    InternedClosureId,
+    InternedCoroutineId,
+    InternedOpaqueTyId
+    for SolverDefId
+);
+
+impl From<GenericDefId> for SolverDefId {
+    fn from(value: GenericDefId) -> Self {
+        match value {
+            GenericDefId::AdtId(adt_id) => SolverDefId::AdtId(adt_id),
+            GenericDefId::ConstId(const_id) => SolverDefId::ConstId(const_id),
+            GenericDefId::FunctionId(function_id) => SolverDefId::FunctionId(function_id),
+            GenericDefId::ImplId(impl_id) => SolverDefId::ImplId(impl_id),
+            GenericDefId::StaticId(static_id) => SolverDefId::StaticId(static_id),
+            GenericDefId::TraitAliasId(trait_alias_id) => SolverDefId::TraitAliasId(trait_alias_id),
+            GenericDefId::TraitId(trait_id) => SolverDefId::TraitId(trait_id),
+            GenericDefId::TypeAliasId(type_alias_id) => SolverDefId::TypeAliasId(type_alias_id),
+        }
+    }
+}
+
+impl TryFrom<SolverDefId> for GenericDefId {
+    type Error = SolverDefId;
+
+    fn try_from(value: SolverDefId) -> Result<Self, Self::Error> {
+        Ok(match value {
+            SolverDefId::AdtId(adt_id) => GenericDefId::AdtId(adt_id),
+            SolverDefId::ConstId(const_id) => GenericDefId::ConstId(const_id),
+            SolverDefId::FunctionId(function_id) => GenericDefId::FunctionId(function_id),
+            SolverDefId::ImplId(impl_id) => GenericDefId::ImplId(impl_id),
+            SolverDefId::StaticId(static_id) => GenericDefId::StaticId(static_id),
+            SolverDefId::TraitAliasId(trait_alias_id) => GenericDefId::TraitAliasId(trait_alias_id),
+            SolverDefId::TraitId(trait_id) => GenericDefId::TraitId(trait_id),
+            SolverDefId::TypeAliasId(type_alias_id) => GenericDefId::TypeAliasId(type_alias_id),
+            SolverDefId::ForeignId(_) => return Err(value),
+            SolverDefId::InternedClosureId(_) => return Err(value),
+            SolverDefId::InternedCoroutineId(_) => return Err(value),
+            SolverDefId::InternedOpaqueTyId(_) => return Err(value),
+            SolverDefId::Ctor(_) => return Err(value),
+        })
+    }
+}
+
+impl<'db> inherent::DefId<DbInterner<'db>> for SolverDefId {
+    fn as_local(self) -> Option<SolverDefId> {
+        Some(self)
+    }
+    fn is_local(self) -> bool {
+        true
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fold.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fold.rs
new file mode 100644
index 0000000000000..3cc1e64b6add0
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fold.rs
@@ -0,0 +1,129 @@
+//! Fold impls for the next-trait-solver.
+
+use rustc_type_ir::{
+    BoundVar, DebruijnIndex, RegionKind, TypeFoldable, TypeFolder, TypeSuperFoldable,
+    TypeVisitableExt,
+    inherent::{IntoKind, Region as _},
+};
+
+use super::{
+    Binder, BoundRegion, BoundTy, Const, ConstKind, DbInterner, Predicate, Region, Ty, TyKind,
+};
+
+/// A delegate used when instantiating bound vars.
+///
+/// Any implementation must make sure that each bound variable always
+/// gets mapped to the same result. `BoundVarReplacer` caches by using
+/// a `DelayedMap` which does not cache the first few types it encounters.
+pub trait BoundVarReplacerDelegate<'db> {
+    fn replace_region(&mut self, br: BoundRegion) -> Region<'db>;
+    fn replace_ty(&mut self, bt: BoundTy) -> Ty<'db>;
+    fn replace_const(&mut self, bv: BoundVar) -> Const<'db>;
+}
+
+/// A simple delegate taking 3 mutable functions. The used functions must
+/// always return the same result for each bound variable, no matter how
+/// frequently they are called.
+pub struct FnMutDelegate<'db, 'a> {
+    pub regions: &'a mut (dyn FnMut(BoundRegion) -> Region<'db> + 'a),
+    pub types: &'a mut (dyn FnMut(BoundTy) -> Ty<'db> + 'a),
+    pub consts: &'a mut (dyn FnMut(BoundVar) -> Const<'db> + 'a),
+}
+
+impl<'db, 'a> BoundVarReplacerDelegate<'db> for FnMutDelegate<'db, 'a> {
+    fn replace_region(&mut self, br: BoundRegion) -> Region<'db> {
+        (self.regions)(br)
+    }
+    fn replace_ty(&mut self, bt: BoundTy) -> Ty<'db> {
+        (self.types)(bt)
+    }
+    fn replace_const(&mut self, bv: BoundVar) -> Const<'db> {
+        (self.consts)(bv)
+    }
+}
+
+/// Replaces the escaping bound vars (late bound regions or bound types) in a type.
+pub(crate) struct BoundVarReplacer<'db, D> {
+    interner: DbInterner<'db>,
+    /// As with `RegionFolder`, represents the index of a binder *just outside*
+    /// the ones we have visited.
+    current_index: DebruijnIndex,
+
+    delegate: D,
+}
+
+impl<'db, D: BoundVarReplacerDelegate<'db>> BoundVarReplacer<'db, D> {
+    pub fn new(tcx: DbInterner<'db>, delegate: D) -> Self {
+        BoundVarReplacer { interner: tcx, current_index: DebruijnIndex::ZERO, delegate }
+    }
+}
+
+impl<'db, D> TypeFolder<DbInterner<'db>> for BoundVarReplacer<'db, D>
+where
+    D: BoundVarReplacerDelegate<'db>,
+{
+    fn cx(&self) -> DbInterner<'db> {
+        self.interner
+    }
+
+    fn fold_binder<T: TypeFoldable<DbInterner<'db>>>(
+        &mut self,
+        t: Binder<'db, T>,
+    ) -> Binder<'db, T> {
+        self.current_index.shift_in(1);
+        let t = t.super_fold_with(self);
+        self.current_index.shift_out(1);
+        t
+    }
+
+    fn fold_ty(&mut self, t: Ty<'db>) -> Ty<'db> {
+        match t.kind() {
+            TyKind::Bound(debruijn, bound_ty) if debruijn == self.current_index => {
+                let ty = self.delegate.replace_ty(bound_ty);
+                debug_assert!(!ty.has_vars_bound_above(DebruijnIndex::ZERO));
+                rustc_type_ir::shift_vars(self.interner, ty, self.current_index.as_u32())
+            }
+            _ => {
+                if !t.has_vars_bound_at_or_above(self.current_index) {
+                    t
+                } else {
+                    t.super_fold_with(self)
+                }
+            }
+        }
+    }
+
+    fn fold_region(&mut self, r: Region<'db>) -> Region<'db> {
+        match r.kind() {
+            RegionKind::ReBound(debruijn, br) if debruijn == self.current_index => {
+                let region = self.delegate.replace_region(br);
+                if let RegionKind::ReBound(debruijn1, br) = region.kind() {
+                    // If the callback returns a bound region,
+                    // that region should always use the INNERMOST
+                    // debruijn index. Then we adjust it to the
+                    // correct depth.
+                    assert_eq!(debruijn1, DebruijnIndex::ZERO);
+                    Region::new_bound(self.interner, debruijn, br)
+                } else {
+                    region
+                }
+            }
+            _ => r,
+        }
+    }
+
+    fn fold_const(&mut self, ct: Const<'db>) -> Const<'db> {
+        match ct.kind() {
+            ConstKind::Bound(debruijn, bound_const) if debruijn == self.current_index => {
+                let ct = self.delegate.replace_const(bound_const);
+                debug_assert!(!ct.has_vars_bound_above(DebruijnIndex::ZERO));
+                rustc_type_ir::shift_vars(self.interner, ct, self.current_index.as_u32())
+            }
+            _ => ct.super_fold_with(self),
+        }
+    }
+
+    fn fold_predicate(&mut self, p: Predicate<'db>) -> Predicate<'db> {
+        if p.has_vars_bound_at_or_above(self.current_index) { p.super_fold_with(self) } else { p }
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill.rs
new file mode 100644
index 0000000000000..007a674ad399a
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill.rs
@@ -0,0 +1,229 @@
+//! Fulfill loop for next-solver.
+
+use std::marker::PhantomData;
+use std::mem;
+use std::ops::ControlFlow;
+use std::vec::ExtractIf;
+
+use rustc_next_trait_solver::delegate::SolverDelegate;
+use rustc_next_trait_solver::solve::{
+    GoalEvaluation, GoalStalledOn, HasChanged, SolverDelegateEvalExt,
+};
+use rustc_type_ir::Interner;
+use rustc_type_ir::inherent::Span as _;
+use rustc_type_ir::solve::{Certainty, NoSolution};
+
+use crate::next_solver::infer::InferCtxt;
+use crate::next_solver::infer::traits::{PredicateObligation, PredicateObligations};
+use crate::next_solver::{DbInterner, SolverContext, Span, TypingMode};
+
+type PendingObligations<'db> =
+    Vec<(PredicateObligation<'db>, Option<GoalStalledOn<DbInterner<'db>>>)>;
+
+/// A trait engine using the new trait solver.
+///
+/// This is mostly identical to how `evaluate_all` works inside of the
+/// solver, except that the requirements are slightly different.
+///
+/// Unlike `evaluate_all` it is possible to add new obligations later on
+/// and we also have to track diagnostics information by using `Obligation`
+/// instead of `Goal`.
+///
+/// It is also likely that we want to use slightly different datastructures
+/// here as this will have to deal with far more root goals than `evaluate_all`.
+pub struct FulfillmentCtxt<'db> {
+    obligations: ObligationStorage<'db>,
+
+    /// The snapshot in which this context was created. Using the context
+    /// outside of this snapshot leads to subtle bugs if the snapshot
+    /// gets rolled back. Because of this we explicitly check that we only
+    /// use the context in exactly this snapshot.
+    usable_in_snapshot: usize,
+}
+
+#[derive(Default, Debug)]
+struct ObligationStorage<'db> {
+    /// Obligations which resulted in an overflow in fulfillment itself.
+    ///
+    /// We cannot eagerly return these as error so we instead store them here
+    /// to avoid recomputing them each time `select_where_possible` is called.
+    /// This also allows us to return the correct `FulfillmentError` for them.
+    overflowed: Vec<PredicateObligation<'db>>,
+    pending: PendingObligations<'db>,
+}
+
+impl<'db> ObligationStorage<'db> {
+    fn register(
+        &mut self,
+        obligation: PredicateObligation<'db>,
+        stalled_on: Option<GoalStalledOn<DbInterner<'db>>>,
+    ) {
+        self.pending.push((obligation, stalled_on));
+    }
+
+    fn has_pending_obligations(&self) -> bool {
+        !self.pending.is_empty() || !self.overflowed.is_empty()
+    }
+
+    fn clone_pending(&self) -> PredicateObligations<'db> {
+        let mut obligations: PredicateObligations<'db> =
+            self.pending.iter().map(|(o, _)| o.clone()).collect();
+        obligations.extend(self.overflowed.iter().cloned());
+        obligations
+    }
+
+    fn drain_pending(
+        &mut self,
+        cond: impl Fn(&PredicateObligation<'db>) -> bool,
+    ) -> PendingObligations<'db> {
+        let (not_stalled, pending) =
+            mem::take(&mut self.pending).into_iter().partition(|(o, _)| cond(o));
+        self.pending = pending;
+        not_stalled
+    }
+
+    fn on_fulfillment_overflow(&mut self, infcx: &InferCtxt<'db>) {
+        infcx.probe(|_| {
+            // IMPORTANT: we must not use solve any inference variables in the obligations
+            // as this is all happening inside of a probe. We use a probe to make sure
+            // we get all obligations involved in the overflow. We pretty much check: if
+            // we were to do another step of `select_where_possible`, which goals would
+            // change.
+            // FIXME: <https://github.com/Gankra/thin-vec/pull/66> is merged, this can be removed.
+            self.overflowed.extend(
+                self.pending
+                    .extract_if(.., |(o, stalled_on)| {
+                        let goal = o.as_goal();
+                        let result = <&SolverContext<'db>>::from(infcx).evaluate_root_goal(
+                            goal,
+                            Span::dummy(),
+                            stalled_on.take(),
+                        );
+                        matches!(result, Ok(GoalEvaluation { has_changed: HasChanged::Yes, .. }))
+                    })
+                    .map(|(o, _)| o),
+            );
+        })
+    }
+}
+
+impl<'db> FulfillmentCtxt<'db> {
+    pub fn new(infcx: &InferCtxt<'db>) -> FulfillmentCtxt<'db> {
+        FulfillmentCtxt {
+            obligations: Default::default(),
+            usable_in_snapshot: infcx.num_open_snapshots(),
+        }
+    }
+}
+
+impl<'db> FulfillmentCtxt<'db> {
+    #[tracing::instrument(level = "trace", skip(self, infcx))]
+    pub(crate) fn register_predicate_obligation(
+        &mut self,
+        infcx: &InferCtxt<'db>,
+        obligation: PredicateObligation<'db>,
+    ) {
+        assert_eq!(self.usable_in_snapshot, infcx.num_open_snapshots());
+        self.obligations.register(obligation, None);
+    }
+
+    pub(crate) fn collect_remaining_errors(
+        &mut self,
+        infcx: &InferCtxt<'db>,
+    ) -> Vec<NextSolverError<'db>> {
+        self.obligations
+            .pending
+            .drain(..)
+            .map(|(obligation, _)| NextSolverError::Ambiguity(obligation))
+            .chain(self.obligations.overflowed.drain(..).map(NextSolverError::Overflow))
+            .collect()
+    }
+
+    pub(crate) fn select_where_possible(
+        &mut self,
+        infcx: &InferCtxt<'db>,
+    ) -> Vec<NextSolverError<'db>> {
+        assert_eq!(self.usable_in_snapshot, infcx.num_open_snapshots());
+        let mut errors = Vec::new();
+        loop {
+            let mut any_changed = false;
+            for (mut obligation, stalled_on) in self.obligations.drain_pending(|_| true) {
+                if obligation.recursion_depth >= infcx.interner.recursion_limit() {
+                    self.obligations.on_fulfillment_overflow(infcx);
+                    // Only return true errors that we have accumulated while processing.
+                    return errors;
+                }
+
+                let goal = obligation.as_goal();
+                let delegate = <&SolverContext<'db>>::from(infcx);
+                if let Some(certainty) = delegate.compute_goal_fast_path(goal, Span::dummy()) {
+                    match certainty {
+                        Certainty::Yes => {}
+                        Certainty::Maybe(_) => {
+                            self.obligations.register(obligation, None);
+                        }
+                    }
+                    continue;
+                }
+
+                let result = delegate.evaluate_root_goal(goal, Span::dummy(), stalled_on);
+                let GoalEvaluation { certainty, has_changed, stalled_on } = match result {
+                    Ok(result) => result,
+                    Err(NoSolution) => {
+                        errors.push(NextSolverError::TrueError(obligation));
+                        continue;
+                    }
+                };
+
+                if has_changed == HasChanged::Yes {
+                    // We increment the recursion depth here to track the number of times
+                    // this goal has resulted in inference progress. This doesn't precisely
+                    // model the way that we track recursion depth in the old solver due
+                    // to the fact that we only process root obligations, but it is a good
+                    // approximation and should only result in fulfillment overflow in
+                    // pathological cases.
+                    obligation.recursion_depth += 1;
+                    any_changed = true;
+                }
+
+                match certainty {
+                    Certainty::Yes => {}
+                    Certainty::Maybe(_) => self.obligations.register(obligation, stalled_on),
+                }
+            }
+
+            if !any_changed {
+                break;
+            }
+        }
+
+        errors
+    }
+
+    pub(crate) fn select_all_or_error(
+        &mut self,
+        infcx: &InferCtxt<'db>,
+    ) -> Vec<NextSolverError<'db>> {
+        let errors = self.select_where_possible(infcx);
+        if !errors.is_empty() {
+            return errors;
+        }
+
+        self.collect_remaining_errors(infcx)
+    }
+
+    fn has_pending_obligations(&self) -> bool {
+        self.obligations.has_pending_obligations()
+    }
+
+    fn pending_obligations(&self) -> PredicateObligations<'db> {
+        self.obligations.clone_pending()
+    }
+}
+
+#[derive(Debug)]
+pub enum NextSolverError<'db> {
+    TrueError(PredicateObligation<'db>),
+    Ambiguity(PredicateObligation<'db>),
+    Overflow(PredicateObligation<'db>),
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generic_arg.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generic_arg.rs
new file mode 100644
index 0000000000000..85a79923a7295
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generic_arg.rs
@@ -0,0 +1,525 @@
+//! Things related to generic args in the next-trait-solver.
+
+use intern::{Interned, Symbol};
+use rustc_type_ir::{
+    ClosureArgs, CollectAndApply, ConstVid, CoroutineArgs, CoroutineClosureArgs, FnSig, FnSigTys,
+    GenericArgKind, IntTy, Interner, TermKind, TyKind, TyVid, TypeFoldable, TypeVisitable,
+    Variance,
+    inherent::{GenericArg as _, GenericsOf, IntoKind, SliceLike, Term as _, Ty as _},
+    relate::{Relate, VarianceDiagInfo},
+};
+use smallvec::SmallVec;
+
+use crate::db::HirDatabase;
+
+use super::{
+    Const, DbInterner, EarlyParamRegion, ErrorGuaranteed, ParamConst, Region, SolverDefId, Ty, Tys,
+    generics::{GenericParamDef, GenericParamDefKind, Generics},
+    interned_vec_db,
+};
+
+#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+pub enum GenericArg<'db> {
+    Ty(Ty<'db>),
+    Lifetime(Region<'db>),
+    Const(Const<'db>),
+}
+
+impl<'db> std::fmt::Debug for GenericArg<'db> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Ty(t) => std::fmt::Debug::fmt(t, f),
+            Self::Lifetime(r) => std::fmt::Debug::fmt(r, f),
+            Self::Const(c) => std::fmt::Debug::fmt(c, f),
+        }
+    }
+}
+
+impl<'db> From<Term<'db>> for GenericArg<'db> {
+    fn from(value: Term<'db>) -> Self {
+        match value {
+            Term::Ty(ty) => GenericArg::Ty(ty),
+            Term::Const(c) => GenericArg::Const(c),
+        }
+    }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+pub enum Term<'db> {
+    Ty(Ty<'db>),
+    Const(Const<'db>),
+}
+
+impl<'db> std::fmt::Debug for Term<'db> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Ty(t) => std::fmt::Debug::fmt(t, f),
+            Self::Const(c) => std::fmt::Debug::fmt(c, f),
+        }
+    }
+}
+
+impl<'db> Term<'db> {
+    pub fn expect_type(&self) -> Ty<'db> {
+        self.as_type().expect("expected a type, but found a const")
+    }
+
+    pub fn is_trivially_wf(&self, tcx: DbInterner<'db>) -> bool {
+        match self.kind() {
+            TermKind::Ty(ty) => ty.is_trivially_wf(tcx),
+            TermKind::Const(ct) => ct.is_trivially_wf(),
+        }
+    }
+}
+
+impl<'db> From<Ty<'db>> for GenericArg<'db> {
+    fn from(value: Ty<'db>) -> Self {
+        Self::Ty(value)
+    }
+}
+
+impl<'db> From<Region<'db>> for GenericArg<'db> {
+    fn from(value: Region<'db>) -> Self {
+        Self::Lifetime(value)
+    }
+}
+
+impl<'db> From<Const<'db>> for GenericArg<'db> {
+    fn from(value: Const<'db>) -> Self {
+        Self::Const(value)
+    }
+}
+
+impl<'db> IntoKind for GenericArg<'db> {
+    type Kind = GenericArgKind<DbInterner<'db>>;
+
+    fn kind(self) -> Self::Kind {
+        match self {
+            GenericArg::Ty(ty) => GenericArgKind::Type(ty),
+            GenericArg::Lifetime(region) => GenericArgKind::Lifetime(region),
+            GenericArg::Const(c) => GenericArgKind::Const(c),
+        }
+    }
+}
+
+impl<'db> TypeVisitable<DbInterner<'db>> for GenericArg<'db> {
+    fn visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>(
+        &self,
+        visitor: &mut V,
+    ) -> V::Result {
+        match self {
+            GenericArg::Lifetime(lt) => lt.visit_with(visitor),
+            GenericArg::Ty(ty) => ty.visit_with(visitor),
+            GenericArg::Const(ct) => ct.visit_with(visitor),
+        }
+    }
+}
+
+impl<'db> TypeFoldable<DbInterner<'db>> for GenericArg<'db> {
+    fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>(
+        self,
+        folder: &mut F,
+    ) -> Result<Self, F::Error> {
+        match self.kind() {
+            GenericArgKind::Lifetime(lt) => lt.try_fold_with(folder).map(Into::into),
+            GenericArgKind::Type(ty) => ty.try_fold_with(folder).map(Into::into),
+            GenericArgKind::Const(ct) => ct.try_fold_with(folder).map(Into::into),
+        }
+    }
+    fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self {
+        match self.kind() {
+            GenericArgKind::Lifetime(lt) => lt.fold_with(folder).into(),
+            GenericArgKind::Type(ty) => ty.fold_with(folder).into(),
+            GenericArgKind::Const(ct) => ct.fold_with(folder).into(),
+        }
+    }
+}
+
+impl<'db> Relate<DbInterner<'db>> for GenericArg<'db> {
+    fn relate<R: rustc_type_ir::relate::TypeRelation<DbInterner<'db>>>(
+        relation: &mut R,
+        a: Self,
+        b: Self,
+    ) -> rustc_type_ir::relate::RelateResult<DbInterner<'db>, Self> {
+        match (a.kind(), b.kind()) {
+            (GenericArgKind::Lifetime(a_lt), GenericArgKind::Lifetime(b_lt)) => {
+                Ok(relation.relate(a_lt, b_lt)?.into())
+            }
+            (GenericArgKind::Type(a_ty), GenericArgKind::Type(b_ty)) => {
+                Ok(relation.relate(a_ty, b_ty)?.into())
+            }
+            (GenericArgKind::Const(a_ct), GenericArgKind::Const(b_ct)) => {
+                Ok(relation.relate(a_ct, b_ct)?.into())
+            }
+            (GenericArgKind::Lifetime(unpacked), x) => {
+                unreachable!("impossible case reached: can't relate: {:?} with {:?}", unpacked, x)
+            }
+            (GenericArgKind::Type(unpacked), x) => {
+                unreachable!("impossible case reached: can't relate: {:?} with {:?}", unpacked, x)
+            }
+            (GenericArgKind::Const(unpacked), x) => {
+                unreachable!("impossible case reached: can't relate: {:?} with {:?}", unpacked, x)
+            }
+        }
+    }
+}
+
+interned_vec_db!(GenericArgs, GenericArg);
+
+impl<'db> rustc_type_ir::inherent::GenericArg<DbInterner<'db>> for GenericArg<'db> {}
+
+impl<'db> GenericArgs<'db> {
+    /// Creates an `GenericArgs` for generic parameter definitions,
+    /// by calling closures to obtain each kind.
+    /// The closures get to observe the `GenericArgs` as they're
+    /// being built, which can be used to correctly
+    /// replace defaults of generic parameters.
+    pub fn for_item<F>(
+        interner: DbInterner<'db>,
+        def_id: SolverDefId,
+        mut mk_kind: F,
+    ) -> GenericArgs<'db>
+    where
+        F: FnMut(&Symbol, u32, GenericParamDefKind, &[GenericArg<'db>]) -> GenericArg<'db>,
+    {
+        let defs = interner.generics_of(def_id);
+        let count = defs.count();
+        let mut args = SmallVec::with_capacity(count);
+        Self::fill_item(&mut args, interner, defs, &mut mk_kind);
+        interner.mk_args(&args)
+    }
+
+    fn fill_item<F>(
+        args: &mut SmallVec<[GenericArg<'db>; 8]>,
+        interner: DbInterner<'_>,
+        defs: Generics,
+        mk_kind: &mut F,
+    ) where
+        F: FnMut(&Symbol, u32, GenericParamDefKind, &[GenericArg<'db>]) -> GenericArg<'db>,
+    {
+        let self_len = defs.own_params.len() as u32;
+        if let Some(def_id) = defs.parent {
+            let parent_defs = interner.generics_of(def_id.into());
+            Self::fill_item(args, interner, parent_defs, mk_kind);
+        }
+        Self::fill_single(args, &defs, mk_kind);
+    }
+
+    fn fill_single<F>(args: &mut SmallVec<[GenericArg<'db>; 8]>, defs: &Generics, mk_kind: &mut F)
+    where
+        F: FnMut(&Symbol, u32, GenericParamDefKind, &[GenericArg<'db>]) -> GenericArg<'db>,
+    {
+        let start_len = args.len();
+        args.reserve(defs.own_params.len());
+        for param in &defs.own_params {
+            let kind = mk_kind(&param.name, args.len() as u32, param.kind, args);
+            args.push(kind);
+        }
+    }
+}
+
+impl<'db> rustc_type_ir::relate::Relate<DbInterner<'db>> for GenericArgs<'db> {
+    fn relate<R: rustc_type_ir::relate::TypeRelation<DbInterner<'db>>>(
+        relation: &mut R,
+        a: Self,
+        b: Self,
+    ) -> rustc_type_ir::relate::RelateResult<DbInterner<'db>, Self> {
+        let interner = relation.cx();
+        CollectAndApply::collect_and_apply(
+            std::iter::zip(a.iter(), b.iter()).map(|(a, b)| {
+                relation.relate_with_variance(
+                    Variance::Invariant,
+                    VarianceDiagInfo::default(),
+                    a,
+                    b,
+                )
+            }),
+            |g| GenericArgs::new_from_iter(interner, g.iter().cloned()),
+        )
+    }
+}
+
+impl<'db> rustc_type_ir::inherent::GenericArgs<DbInterner<'db>> for GenericArgs<'db> {
+    fn as_closure(self) -> ClosureArgs<DbInterner<'db>> {
+        ClosureArgs { args: self }
+    }
+    fn as_coroutine(self) -> CoroutineArgs<DbInterner<'db>> {
+        CoroutineArgs { args: self }
+    }
+    fn as_coroutine_closure(self) -> CoroutineClosureArgs<DbInterner<'db>> {
+        CoroutineClosureArgs { args: self }
+    }
+    fn rebase_onto(
+        self,
+        interner: DbInterner<'db>,
+        source_def_id: <DbInterner<'db> as rustc_type_ir::Interner>::DefId,
+        target: <DbInterner<'db> as rustc_type_ir::Interner>::GenericArgs,
+    ) -> <DbInterner<'db> as rustc_type_ir::Interner>::GenericArgs {
+        let defs = interner.generics_of(source_def_id);
+        interner.mk_args_from_iter(target.iter().chain(self.iter().skip(defs.count())))
+    }
+
+    fn identity_for_item(
+        interner: DbInterner<'db>,
+        def_id: <DbInterner<'db> as rustc_type_ir::Interner>::DefId,
+    ) -> <DbInterner<'db> as rustc_type_ir::Interner>::GenericArgs {
+        Self::for_item(interner, def_id, |name, index, kind, _| mk_param(index, name, kind))
+    }
+
+    fn extend_with_error(
+        interner: DbInterner<'db>,
+        def_id: <DbInterner<'db> as rustc_type_ir::Interner>::DefId,
+        original_args: &[<DbInterner<'db> as rustc_type_ir::Interner>::GenericArg],
+    ) -> <DbInterner<'db> as rustc_type_ir::Interner>::GenericArgs {
+        Self::for_item(interner, def_id, |name, index, kind, _| {
+            if let Some(arg) = original_args.get(index as usize) {
+                *arg
+            } else {
+                error_for_param_kind(kind, interner)
+            }
+        })
+    }
+    fn type_at(self, i: usize) -> <DbInterner<'db> as rustc_type_ir::Interner>::Ty {
+        self.inner()
+            .get(i)
+            .and_then(|g| g.as_type())
+            .unwrap_or_else(|| Ty::new_error(DbInterner::conjure(), ErrorGuaranteed))
+    }
+
+    fn region_at(self, i: usize) -> <DbInterner<'db> as rustc_type_ir::Interner>::Region {
+        self.inner()
+            .get(i)
+            .and_then(|g| g.as_region())
+            .unwrap_or_else(|| Region::error(DbInterner::conjure()))
+    }
+
+    fn const_at(self, i: usize) -> <DbInterner<'db> as rustc_type_ir::Interner>::Const {
+        self.inner()
+            .get(i)
+            .and_then(|g| g.as_const())
+            .unwrap_or_else(|| Const::error(DbInterner::conjure()))
+    }
+
+    fn split_closure_args(self) -> rustc_type_ir::ClosureArgsParts<DbInterner<'db>> {
+        // FIXME: should use `ClosureSubst` when possible
+        match self.inner().as_slice() {
+            [parent_args @ .., sig_ty] => {
+                let interner = DbInterner::conjure();
+                // This is stupid, but the next solver expects the first input to actually be a tuple
+                let sig_ty = match sig_ty.expect_ty().kind() {
+                    TyKind::FnPtr(sig_tys, header) => Ty::new(
+                        interner,
+                        TyKind::FnPtr(
+                            sig_tys.map_bound(|s| {
+                                let inputs = Ty::new_tup_from_iter(interner, s.inputs().iter());
+                                let output = s.output();
+                                FnSigTys {
+                                    inputs_and_output: Tys::new_from_iter(
+                                        interner,
+                                        [inputs, output],
+                                    ),
+                                }
+                            }),
+                            header,
+                        ),
+                    ),
+                    _ => unreachable!("sig_ty should be last"),
+                };
+                rustc_type_ir::ClosureArgsParts {
+                    parent_args: GenericArgs::new_from_iter(interner, parent_args.iter().cloned()),
+                    closure_sig_as_fn_ptr_ty: sig_ty,
+                    closure_kind_ty: Ty::new(interner, TyKind::Int(IntTy::I8)),
+                    tupled_upvars_ty: Ty::new_unit(interner),
+                }
+            }
+            _ => {
+                unreachable!("unexpected closure sig");
+            }
+        }
+    }
+
+    fn split_coroutine_closure_args(
+        self,
+    ) -> rustc_type_ir::CoroutineClosureArgsParts<DbInterner<'db>> {
+        match self.inner().as_slice() {
+            [
+                parent_args @ ..,
+                closure_kind_ty,
+                signature_parts_ty,
+                tupled_upvars_ty,
+                coroutine_captures_by_ref_ty,
+                coroutine_witness_ty,
+            ] => rustc_type_ir::CoroutineClosureArgsParts {
+                parent_args: GenericArgs::new_from_iter(
+                    DbInterner::conjure(),
+                    parent_args.iter().cloned(),
+                ),
+                closure_kind_ty: closure_kind_ty.expect_ty(),
+                signature_parts_ty: signature_parts_ty.expect_ty(),
+                tupled_upvars_ty: tupled_upvars_ty.expect_ty(),
+                coroutine_captures_by_ref_ty: coroutine_captures_by_ref_ty.expect_ty(),
+                coroutine_witness_ty: coroutine_witness_ty.expect_ty(),
+            },
+            _ => panic!("GenericArgs were likely not for a CoroutineClosure."),
+        }
+    }
+
+    fn split_coroutine_args(self) -> rustc_type_ir::CoroutineArgsParts<DbInterner<'db>> {
+        let interner = DbInterner::conjure();
+        match self.inner().as_slice() {
+            [parent_args @ .., resume_ty, yield_ty, return_ty] => {
+                rustc_type_ir::CoroutineArgsParts {
+                    parent_args: GenericArgs::new_from_iter(interner, parent_args.iter().cloned()),
+                    kind_ty: Ty::new_unit(interner),
+                    resume_ty: resume_ty.expect_ty(),
+                    yield_ty: yield_ty.expect_ty(),
+                    return_ty: return_ty.expect_ty(),
+                    witness: Ty::new_unit(interner),
+                    tupled_upvars_ty: Ty::new_unit(interner),
+                }
+            }
+            _ => panic!("GenericArgs were likely not for a Coroutine."),
+        }
+    }
+}
+
+pub fn mk_param<'db>(index: u32, name: &Symbol, kind: GenericParamDefKind) -> GenericArg<'db> {
+    let name = name.clone();
+    match kind {
+        GenericParamDefKind::Lifetime => {
+            Region::new_early_param(DbInterner::conjure(), EarlyParamRegion { index }).into()
+        }
+        GenericParamDefKind::Type => Ty::new_param(DbInterner::conjure(), index, name).into(),
+        GenericParamDefKind::Const => {
+            Const::new_param(DbInterner::conjure(), ParamConst { index }).into()
+        }
+    }
+}
+
+pub fn error_for_param_kind<'db>(
+    kind: GenericParamDefKind,
+    interner: DbInterner<'db>,
+) -> GenericArg<'db> {
+    match kind {
+        GenericParamDefKind::Lifetime => Region::error(interner).into(),
+        GenericParamDefKind::Type => Ty::new_error(interner, ErrorGuaranteed).into(),
+        GenericParamDefKind::Const => Const::error(interner).into(),
+    }
+}
+
+impl<'db> IntoKind for Term<'db> {
+    type Kind = TermKind<DbInterner<'db>>;
+
+    fn kind(self) -> Self::Kind {
+        match self {
+            Term::Ty(ty) => TermKind::Ty(ty),
+            Term::Const(c) => TermKind::Const(c),
+        }
+    }
+}
+
+impl<'db> From<Ty<'db>> for Term<'db> {
+    fn from(value: Ty<'db>) -> Self {
+        Self::Ty(value)
+    }
+}
+
+impl<'db> From<Const<'db>> for Term<'db> {
+    fn from(value: Const<'db>) -> Self {
+        Self::Const(value)
+    }
+}
+
+impl<'db> TypeVisitable<DbInterner<'db>> for Term<'db> {
+    fn visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>(
+        &self,
+        visitor: &mut V,
+    ) -> V::Result {
+        match self {
+            Term::Ty(ty) => ty.visit_with(visitor),
+            Term::Const(ct) => ct.visit_with(visitor),
+        }
+    }
+}
+
+impl<'db> TypeFoldable<DbInterner<'db>> for Term<'db> {
+    fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>(
+        self,
+        folder: &mut F,
+    ) -> Result<Self, F::Error> {
+        match self.kind() {
+            TermKind::Ty(ty) => ty.try_fold_with(folder).map(Into::into),
+            TermKind::Const(ct) => ct.try_fold_with(folder).map(Into::into),
+        }
+    }
+    fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self {
+        match self.kind() {
+            TermKind::Ty(ty) => ty.fold_with(folder).into(),
+            TermKind::Const(ct) => ct.fold_with(folder).into(),
+        }
+    }
+}
+
+impl<'db> Relate<DbInterner<'db>> for Term<'db> {
+    fn relate<R: rustc_type_ir::relate::TypeRelation<DbInterner<'db>>>(
+        relation: &mut R,
+        a: Self,
+        b: Self,
+    ) -> rustc_type_ir::relate::RelateResult<DbInterner<'db>, Self> {
+        match (a.kind(), b.kind()) {
+            (TermKind::Ty(a_ty), TermKind::Ty(b_ty)) => Ok(relation.relate(a_ty, b_ty)?.into()),
+            (TermKind::Const(a_ct), TermKind::Const(b_ct)) => {
+                Ok(relation.relate(a_ct, b_ct)?.into())
+            }
+            (TermKind::Ty(unpacked), x) => {
+                unreachable!("impossible case reached: can't relate: {:?} with {:?}", unpacked, x)
+            }
+            (TermKind::Const(unpacked), x) => {
+                unreachable!("impossible case reached: can't relate: {:?} with {:?}", unpacked, x)
+            }
+        }
+    }
+}
+
+impl<'db> rustc_type_ir::inherent::Term<DbInterner<'db>> for Term<'db> {}
+
+#[derive(Clone, Eq, PartialEq, Debug)]
+pub enum TermVid {
+    Ty(TyVid),
+    Const(ConstVid),
+}
+
+impl From<TyVid> for TermVid {
+    fn from(value: TyVid) -> Self {
+        TermVid::Ty(value)
+    }
+}
+
+impl From<ConstVid> for TermVid {
+    fn from(value: ConstVid) -> Self {
+        TermVid::Const(value)
+    }
+}
+
+impl<'db> DbInterner<'db> {
+    pub(super) fn mk_args(self, args: &[GenericArg<'db>]) -> GenericArgs<'db> {
+        GenericArgs::new_from_iter(self, args.iter().cloned())
+    }
+
+    pub(super) fn mk_args_from_iter<I, T>(self, iter: I) -> T::Output
+    where
+        I: Iterator<Item = T>,
+        T: rustc_type_ir::CollectAndApply<GenericArg<'db>, GenericArgs<'db>>,
+    {
+        T::collect_and_apply(iter, |xs| self.mk_args(xs))
+    }
+
+    pub(super) fn check_args_compatible(self, def_id: SolverDefId, args: GenericArgs<'db>) -> bool {
+        // TODO
+        true
+    }
+
+    pub(super) fn debug_assert_args_compatible(self, def_id: SolverDefId, args: GenericArgs<'db>) {
+        // TODO
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generics.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generics.rs
new file mode 100644
index 0000000000000..48f5e73f2562d
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generics.rs
@@ -0,0 +1,147 @@
+//! Things related to generics in the next-trait-solver.
+
+use hir_def::{
+    ConstParamId, GenericDefId, GenericParamId, ItemContainerId, LifetimeParamId, Lookup,
+    TypeOrConstParamId, TypeParamId,
+    db::DefDatabase,
+    expr_store::ExpressionStore,
+    hir::generics::{
+        GenericParamDataRef, GenericParams, LifetimeParamData, LocalLifetimeParamId,
+        LocalTypeOrConstParamId, TypeOrConstParamData, TypeParamData, TypeParamProvenance,
+        WherePredicate,
+    },
+};
+use hir_expand::name::Name;
+use intern::Symbol;
+use la_arena::Arena;
+use rustc_type_ir::inherent::Ty as _;
+use triomphe::Arc;
+
+use crate::{db::HirDatabase, generics::parent_generic_def, next_solver::Ty};
+
+use super::{Const, EarlyParamRegion, ErrorGuaranteed, ParamConst, Region, SolverDefId};
+
+use super::{DbInterner, GenericArg};
+
+pub(crate) fn generics(db: &dyn HirDatabase, def: SolverDefId) -> Generics {
+    let mk_lt = |(index, (_, lt)): (usize, (_, &LifetimeParamData))| {
+        let name = lt.name.symbol().clone();
+        let index = index as u32;
+        let kind = GenericParamDefKind::Lifetime;
+        GenericParamDef { name, index, kind }
+    };
+    let mk_ty = |len_lt, (index, p): (usize, &TypeOrConstParamData)| {
+        let name = p
+            .name()
+            .map(|n| n.symbol().clone())
+            .unwrap_or_else(|| Name::missing().symbol().clone());
+        let index = (len_lt + index) as u32;
+        let kind = match p {
+            TypeOrConstParamData::TypeParamData(_) => GenericParamDefKind::Type,
+            TypeOrConstParamData::ConstParamData(_) => GenericParamDefKind::Const,
+        };
+        GenericParamDef { name, index, kind }
+    };
+    let own_params_for_generic_params = |params: &GenericParams| {
+        if params.trait_self_param().is_some() {
+            let len_lt = params.len_lifetimes() + 1;
+            params
+                .iter_type_or_consts()
+                .take(1)
+                .enumerate()
+                .map(|t| mk_ty(0, (t.0, t.1.1)))
+                .chain(params.iter_lt().enumerate().map(mk_lt))
+                .chain(
+                    params
+                        .iter_type_or_consts()
+                        .skip(1)
+                        .enumerate()
+                        .map(|t| mk_ty(len_lt, (t.0, t.1.1))),
+                )
+                .collect()
+        } else {
+            let len_lt = params.len_lifetimes();
+            params
+                .iter_lt()
+                .enumerate()
+                .map(mk_lt)
+                .chain(
+                    params.iter_type_or_consts().enumerate().map(|t| mk_ty(len_lt, (t.0, t.1.1))),
+                )
+                .collect()
+        }
+    };
+
+    let (parent, own_params) = match (def.try_into(), def) {
+        (Ok(def), _) => {
+            (parent_generic_def(db, def), own_params_for_generic_params(&db.generic_params(def)))
+        }
+        (_, SolverDefId::InternedOpaqueTyId(id)) => {
+            match db.lookup_intern_impl_trait_id(id) {
+                crate::ImplTraitId::ReturnTypeImplTrait(function_id, _) => {
+                    // The opaque type itself does not have generics - only the parent function
+                    (Some(GenericDefId::FunctionId(function_id)), vec![])
+                }
+                crate::ImplTraitId::TypeAliasImplTrait(type_alias_id, _) => (
+                    None,
+                    own_params_for_generic_params(
+                        &db.generic_params(GenericDefId::TypeAliasId(type_alias_id)),
+                    ),
+                ),
+                crate::ImplTraitId::AsyncBlockTypeImplTrait(def, _) => {
+                    let param = TypeOrConstParamData::TypeParamData(TypeParamData {
+                        name: None,
+                        default: None,
+                        provenance: TypeParamProvenance::TypeParamList,
+                    });
+                    // Yes, there is a parent but we don't include it in the generics
+                    (None, vec![mk_ty(0, (0, &param))])
+                }
+            }
+        }
+        _ => panic!("No generics for {def:?}"),
+    };
+    let parent_generics = parent.map(|def| Box::new(generics(db, def.into())));
+
+    Generics {
+        parent,
+        parent_count: parent_generics.map_or(0, |g| g.parent_count + g.own_params.len()),
+        own_params,
+    }
+}
+
+#[derive(Debug)]
+pub struct Generics {
+    pub parent: Option<GenericDefId>,
+    pub parent_count: usize,
+    pub own_params: Vec<GenericParamDef>,
+}
+
+#[derive(Debug)]
+pub struct GenericParamDef {
+    pub(crate) name: Symbol,
+    //def_id: GenericDefId,
+    index: u32,
+    pub(crate) kind: GenericParamDefKind,
+}
+
+impl GenericParamDef {
+    /// Returns the index of the param on the self generics only
+    /// (i.e. not including parent generics)
+    pub fn index(&self) -> u32 {
+        self.index
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum GenericParamDefKind {
+    Lifetime,
+    Type,
+    Const,
+}
+
+impl<'db> rustc_type_ir::inherent::GenericsOf<DbInterner<'db>> for Generics {
+    fn count(&self) -> usize {
+        self.parent_count + self.own_params.len()
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/at.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/at.rs
new file mode 100644
index 0000000000000..d64c7ed626eb2
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/at.rs
@@ -0,0 +1,333 @@
+//! A nice interface for working with the infcx. The basic idea is to
+//! do `infcx.at(cause, param_env)`, which sets the "cause" of the
+//! operation as well as the surrounding parameter environment. Then
+//! you can do something like `.sub(a, b)` or `.eq(a, b)` to create a
+//! subtype or equality relationship respectively. The first argument
+//! is always the "expected" output from the POV of diagnostics.
+//!
+//! Examples:
+//! ```ignore (fragment)
+//!     infcx.at(cause, param_env).sub(a, b)
+//!     // requires that `a <: b`, with `a` considered the "expected" type
+//!
+//!     infcx.at(cause, param_env).sup(a, b)
+//!     // requires that `b <: a`, with `a` considered the "expected" type
+//!
+//!     infcx.at(cause, param_env).eq(a, b)
+//!     // requires that `a == b`, with `a` considered the "expected" type
+//! ```
+//! For finer-grained control, you can also do use `trace`:
+//! ```ignore (fragment)
+//!     infcx.at(...).trace(a, b).sub(&c, &d)
+//! ```
+//! This will set `a` and `b` as the "root" values for
+//! error-reporting, but actually operate on `c` and `d`. This is
+//! sometimes useful when the types of `c` and `d` are not traceable
+//! things. (That system should probably be refactored.)
+
+use rustc_type_ir::{
+    FnSig, GenericArgKind, TypingMode, Variance,
+    error::ExpectedFound,
+    inherent::{IntoKind, Span as _},
+    relate::{Relate, TypeRelation, solver_relating::RelateExt},
+};
+
+use crate::next_solver::{
+    AliasTerm, AliasTy, Binder, Const, DbInterner, GenericArg, Goal, ParamEnv,
+    PolyExistentialProjection, PolyExistentialTraitRef, PolyFnSig, Predicate, Region, Span, Term,
+    TraitRef, Ty,
+};
+
+use super::{
+    InferCtxt, InferOk, InferResult, TypeTrace, ValuePairs,
+    traits::{Obligation, ObligationCause},
+};
+
+/// Whether we should define opaque types or just treat them opaquely.
+///
+/// Currently only used to prevent predicate matching from matching anything
+/// against opaque types.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum DefineOpaqueTypes {
+    Yes,
+    No,
+}
+
+#[derive(Clone, Copy)]
+pub struct At<'a, 'db> {
+    pub infcx: &'a InferCtxt<'db>,
+    pub cause: &'a ObligationCause,
+    pub param_env: ParamEnv<'db>,
+}
+
+impl<'db> InferCtxt<'db> {
+    #[inline]
+    pub fn at<'a>(&'a self, cause: &'a ObligationCause, param_env: ParamEnv<'db>) -> At<'a, 'db> {
+        At { infcx: self, cause, param_env }
+    }
+
+    /// Forks the inference context, creating a new inference context with the same inference
+    /// variables in the same state. This can be used to "branch off" many tests from the same
+    /// common state.
+    pub fn fork(&self) -> Self {
+        Self {
+            interner: self.interner,
+            typing_mode: self.typing_mode,
+            inner: self.inner.clone(),
+            tainted_by_errors: self.tainted_by_errors.clone(),
+            universe: self.universe.clone(),
+        }
+    }
+
+    /// Forks the inference context, creating a new inference context with the same inference
+    /// variables in the same state, except possibly changing the intercrate mode. This can be
+    /// used to "branch off" many tests from the same common state. Used in negative coherence.
+    pub fn fork_with_typing_mode(&self, typing_mode: TypingMode<DbInterner<'db>>) -> Self {
+        // Unlike `fork`, this invalidates all cache entries as they may depend on the
+        // typing mode.
+
+        Self {
+            interner: self.interner,
+            typing_mode,
+            inner: self.inner.clone(),
+            tainted_by_errors: self.tainted_by_errors.clone(),
+            universe: self.universe.clone(),
+        }
+    }
+}
+
+pub trait ToTrace<'db>: Relate<DbInterner<'db>> {
+    fn to_trace(cause: &ObligationCause, a: Self, b: Self) -> TypeTrace<'db>;
+}
+
+impl<'a, 'db> At<'a, 'db> {
+    /// Makes `actual <: expected`. For example, if type-checking a
+    /// call like `foo(x)`, where `foo: fn(i32)`, you might have
+    /// `sup(i32, x)`, since the "expected" type is the type that
+    /// appears in the signature.
+    pub fn sup<T>(
+        self,
+        define_opaque_types: DefineOpaqueTypes,
+        expected: T,
+        actual: T,
+    ) -> InferResult<'db, ()>
+    where
+        T: ToTrace<'db>,
+    {
+        RelateExt::relate(
+            self.infcx,
+            self.param_env,
+            expected,
+            Variance::Contravariant,
+            actual,
+            Span::dummy(),
+        )
+        .map(|goals| self.goals_to_obligations(goals))
+    }
+
+    /// Makes `expected <: actual`.
+    pub fn sub<T>(
+        self,
+        define_opaque_types: DefineOpaqueTypes,
+        expected: T,
+        actual: T,
+    ) -> InferResult<'db, ()>
+    where
+        T: ToTrace<'db>,
+    {
+        RelateExt::relate(
+            self.infcx,
+            self.param_env,
+            expected,
+            Variance::Covariant,
+            actual,
+            Span::dummy(),
+        )
+        .map(|goals| self.goals_to_obligations(goals))
+    }
+
+    /// Makes `expected == actual`.
+    pub fn eq<T>(
+        self,
+        define_opaque_types: DefineOpaqueTypes,
+        expected: T,
+        actual: T,
+    ) -> InferResult<'db, ()>
+    where
+        T: ToTrace<'db>,
+    {
+        self.eq_trace(
+            define_opaque_types,
+            ToTrace::to_trace(self.cause, expected, actual),
+            expected,
+            actual,
+        )
+    }
+
+    /// Makes `expected == actual`.
+    pub fn eq_trace<T>(
+        self,
+        define_opaque_types: DefineOpaqueTypes,
+        trace: TypeTrace<'db>,
+        expected: T,
+        actual: T,
+    ) -> InferResult<'db, ()>
+    where
+        T: Relate<DbInterner<'db>>,
+    {
+        RelateExt::relate(
+            self.infcx,
+            self.param_env,
+            expected,
+            Variance::Invariant,
+            actual,
+            Span::dummy(),
+        )
+        .map(|goals| self.goals_to_obligations(goals))
+    }
+
+    pub fn relate<T>(
+        self,
+        define_opaque_types: DefineOpaqueTypes,
+        expected: T,
+        variance: Variance,
+        actual: T,
+    ) -> InferResult<'db, ()>
+    where
+        T: ToTrace<'db>,
+    {
+        match variance {
+            Variance::Covariant => self.sub(define_opaque_types, expected, actual),
+            Variance::Invariant => self.eq(define_opaque_types, expected, actual),
+            Variance::Contravariant => self.sup(define_opaque_types, expected, actual),
+
+            // We could make this make sense but it's not readily
+            // exposed and I don't feel like dealing with it. Note
+            // that bivariance in general does a bit more than just
+            // *nothing*, it checks that the types are the same
+            // "modulo variance" basically.
+            Variance::Bivariant => panic!("Bivariant given to `relate()`"),
+        }
+    }
+
+    fn goals_to_obligations(&self, goals: Vec<Goal<'db, Predicate<'db>>>) -> InferOk<'db, ()> {
+        InferOk {
+            value: (),
+            obligations: goals
+                .into_iter()
+                .map(|goal| {
+                    Obligation::new(
+                        self.infcx.interner,
+                        self.cause.clone(),
+                        goal.param_env,
+                        goal.predicate,
+                    )
+                })
+                .collect(),
+        }
+    }
+}
+
+impl<'db> ToTrace<'db> for Ty<'db> {
+    fn to_trace(cause: &ObligationCause, a: Self, b: Self) -> TypeTrace<'db> {
+        TypeTrace {
+            cause: cause.clone(),
+            values: ValuePairs::Terms(ExpectedFound::new(a.into(), b.into())),
+        }
+    }
+}
+
+impl<'db> ToTrace<'db> for Region<'db> {
+    fn to_trace(cause: &ObligationCause, a: Self, b: Self) -> TypeTrace<'db> {
+        TypeTrace { cause: cause.clone(), values: ValuePairs::Regions(ExpectedFound::new(a, b)) }
+    }
+}
+
+impl<'db> ToTrace<'db> for Const<'db> {
+    fn to_trace(cause: &ObligationCause, a: Self, b: Self) -> TypeTrace<'db> {
+        TypeTrace {
+            cause: cause.clone(),
+            values: ValuePairs::Terms(ExpectedFound::new(a.into(), b.into())),
+        }
+    }
+}
+
+impl<'db> ToTrace<'db> for GenericArg<'db> {
+    fn to_trace(cause: &ObligationCause, a: Self, b: Self) -> TypeTrace<'db> {
+        TypeTrace {
+            cause: cause.clone(),
+            values: match (a.kind(), b.kind()) {
+                (GenericArgKind::Lifetime(a), GenericArgKind::Lifetime(b)) => {
+                    ValuePairs::Regions(ExpectedFound::new(a, b))
+                }
+                (GenericArgKind::Type(a), GenericArgKind::Type(b)) => {
+                    ValuePairs::Terms(ExpectedFound::new(a.into(), b.into()))
+                }
+                (GenericArgKind::Const(a), GenericArgKind::Const(b)) => {
+                    ValuePairs::Terms(ExpectedFound::new(a.into(), b.into()))
+                }
+                _ => panic!("relating different kinds: {a:?} {b:?}"),
+            },
+        }
+    }
+}
+
+impl<'db> ToTrace<'db> for Term<'db> {
+    fn to_trace(cause: &ObligationCause, a: Self, b: Self) -> TypeTrace<'db> {
+        TypeTrace { cause: cause.clone(), values: ValuePairs::Terms(ExpectedFound::new(a, b)) }
+    }
+}
+
+impl<'db> ToTrace<'db> for TraitRef<'db> {
+    fn to_trace(cause: &ObligationCause, a: Self, b: Self) -> TypeTrace<'db> {
+        TypeTrace { cause: cause.clone(), values: ValuePairs::TraitRefs(ExpectedFound::new(a, b)) }
+    }
+}
+
+impl<'db> ToTrace<'db> for AliasTy<'db> {
+    fn to_trace(cause: &ObligationCause, a: Self, b: Self) -> TypeTrace<'db> {
+        TypeTrace {
+            cause: cause.clone(),
+            values: ValuePairs::Aliases(ExpectedFound::new(a.into(), b.into())),
+        }
+    }
+}
+
+impl<'db> ToTrace<'db> for AliasTerm<'db> {
+    fn to_trace(cause: &ObligationCause, a: Self, b: Self) -> TypeTrace<'db> {
+        TypeTrace { cause: cause.clone(), values: ValuePairs::Aliases(ExpectedFound::new(a, b)) }
+    }
+}
+
+impl<'db> ToTrace<'db> for FnSig<DbInterner<'db>> {
+    fn to_trace(cause: &ObligationCause, a: Self, b: Self) -> TypeTrace<'db> {
+        TypeTrace {
+            cause: cause.clone(),
+            values: ValuePairs::PolySigs(ExpectedFound::new(Binder::dummy(a), Binder::dummy(b))),
+        }
+    }
+}
+
+impl<'db> ToTrace<'db> for PolyFnSig<'db> {
+    fn to_trace(cause: &ObligationCause, a: Self, b: Self) -> TypeTrace<'db> {
+        TypeTrace { cause: cause.clone(), values: ValuePairs::PolySigs(ExpectedFound::new(a, b)) }
+    }
+}
+
+impl<'db> ToTrace<'db> for PolyExistentialTraitRef<'db> {
+    fn to_trace(cause: &ObligationCause, a: Self, b: Self) -> TypeTrace<'db> {
+        TypeTrace {
+            cause: cause.clone(),
+            values: ValuePairs::ExistentialTraitRef(ExpectedFound::new(a, b)),
+        }
+    }
+}
+
+impl<'db> ToTrace<'db> for PolyExistentialProjection<'db> {
+    fn to_trace(cause: &ObligationCause, a: Self, b: Self) -> TypeTrace<'db> {
+        TypeTrace {
+            cause: cause.clone(),
+            values: ValuePairs::ExistentialProjection(ExpectedFound::new(a, b)),
+        }
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/instantiate.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/instantiate.rs
new file mode 100644
index 0000000000000..0448f03463e4b
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/instantiate.rs
@@ -0,0 +1,106 @@
+//! This module contains code to instantiate new values into a
+//! `Canonical<'tcx, T>`.
+//!
+//! For an overview of what canonicalization is and how it fits into
+//! rustc, check out the [chapter in the rustc dev guide][c].
+//!
+//! [c]: https://rust-lang.github.io/chalk/book/canonical_queries/canonicalization.html
+
+use crate::next_solver::{
+    AliasTy, Binder, BoundRegion, BoundTy, Canonical, CanonicalVarValues, Const, DbInterner, Goal,
+    ParamEnv, Predicate, PredicateKind, Region, Ty, TyKind,
+    fold::FnMutDelegate,
+    infer::{
+        DefineOpaqueTypes, InferCtxt, TypeTrace,
+        traits::{Obligation, PredicateObligations},
+    },
+};
+use rustc_type_ir::{
+    AliasRelationDirection, AliasTyKind, BoundVar, GenericArgKind, InferTy, TypeFoldable, Upcast,
+    Variance,
+    inherent::{IntoKind, SliceLike},
+    relate::{
+        Relate, TypeRelation, VarianceDiagInfo,
+        combine::{super_combine_consts, super_combine_tys},
+    },
+};
+
+pub trait CanonicalExt<'db, V> {
+    fn instantiate(&self, tcx: DbInterner<'db>, var_values: &CanonicalVarValues<'db>) -> V
+    where
+        V: TypeFoldable<DbInterner<'db>>;
+    fn instantiate_projected<T>(
+        &self,
+        tcx: DbInterner<'db>,
+        var_values: &CanonicalVarValues<'db>,
+        projection_fn: impl FnOnce(&V) -> T,
+    ) -> T
+    where
+        T: TypeFoldable<DbInterner<'db>>;
+}
+
+/// FIXME(-Znext-solver): This or public because it is shared with the
+/// new trait solver implementation. We should deduplicate canonicalization.
+impl<'db, V> CanonicalExt<'db, V> for Canonical<'db, V> {
+    /// Instantiate the wrapped value, replacing each canonical value
+    /// with the value given in `var_values`.
+    fn instantiate(&self, tcx: DbInterner<'db>, var_values: &CanonicalVarValues<'db>) -> V
+    where
+        V: TypeFoldable<DbInterner<'db>>,
+    {
+        self.instantiate_projected(tcx, var_values, |value| value.clone())
+    }
+
+    /// Allows one to apply a instantiation to some subset of
+    /// `self.value`. Invoke `projection_fn` with `self.value` to get
+    /// a value V that is expressed in terms of the same canonical
+    /// variables bound in `self` (usually this extracts from subset
+    /// of `self`). Apply the instantiation `var_values` to this value
+    /// V, replacing each of the canonical variables.
+    fn instantiate_projected<T>(
+        &self,
+        tcx: DbInterner<'db>,
+        var_values: &CanonicalVarValues<'db>,
+        projection_fn: impl FnOnce(&V) -> T,
+    ) -> T
+    where
+        T: TypeFoldable<DbInterner<'db>>,
+    {
+        assert_eq!(self.variables.len(), var_values.len());
+        let value = projection_fn(&self.value);
+        instantiate_value(tcx, var_values, value)
+    }
+}
+
+/// Instantiate the values from `var_values` into `value`. `var_values`
+/// must be values for the set of canonical variables that appear in
+/// `value`.
+pub(super) fn instantiate_value<'db, T>(
+    tcx: DbInterner<'db>,
+    var_values: &CanonicalVarValues<'db>,
+    value: T,
+) -> T
+where
+    T: TypeFoldable<DbInterner<'db>>,
+{
+    if var_values.var_values.is_empty() {
+        value
+    } else {
+        let delegate = FnMutDelegate {
+            regions: &mut |br: BoundRegion| match var_values[br.var].kind() {
+                GenericArgKind::Lifetime(l) => l,
+                r => panic!("{br:?} is a region but value is {r:?}"),
+            },
+            types: &mut |bound_ty: BoundTy| match var_values[bound_ty.var].kind() {
+                GenericArgKind::Type(ty) => ty,
+                r => panic!("{bound_ty:?} is a type but value is {r:?}"),
+            },
+            consts: &mut |bound_ct: BoundVar| match var_values[bound_ct].kind() {
+                GenericArgKind::Const(ct) => ct,
+                c => panic!("{bound_ct:?} is a const but value is {c:?}"),
+            },
+        };
+
+        tcx.replace_escaping_bound_vars_uncached(value, delegate)
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/mod.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/mod.rs
new file mode 100644
index 0000000000000..4457e1340d584
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/mod.rs
@@ -0,0 +1,156 @@
+//! **Canonicalization** is the key to constructing a query in the
+//! middle of type inference. Ordinarily, it is not possible to store
+//! types from type inference in query keys, because they contain
+//! references to inference variables whose lifetimes are too short
+//! and so forth. Canonicalizing a value T1 using `canonicalize_query`
+//! produces two things:
+//!
+//! - a value T2 where each unbound inference variable has been
+//!   replaced with a **canonical variable**;
+//! - a map M (of type `CanonicalVarValues`) from those canonical
+//!   variables back to the original.
+//!
+//! We can then do queries using T2. These will give back constraints
+//! on the canonical variables which can be translated, using the map
+//! M, into constraints in our source context. This process of
+//! translating the results back is done by the
+//! `instantiate_query_result` method.
+//!
+//! For a more detailed look at what is happening here, check
+//! out the [chapter in the rustc dev guide][c].
+//!
+//! [c]: https://rust-lang.github.io/chalk/book/canonical_queries/canonicalization.html
+
+use crate::next_solver::{
+    AliasTy, Binder, Canonical, CanonicalVarValues, CanonicalVars, Const, DbInterner, GenericArg,
+    Goal, ParamEnv, PlaceholderConst, PlaceholderRegion, PlaceholderTy, Predicate, PredicateKind,
+    Region, Ty, TyKind,
+    infer::{
+        DefineOpaqueTypes, InferCtxt, TypeTrace,
+        traits::{Obligation, PredicateObligations},
+    },
+};
+use instantiate::CanonicalExt;
+use rustc_index::IndexVec;
+use rustc_type_ir::{
+    AliasRelationDirection, AliasTyKind, CanonicalTyVarKind, CanonicalVarKind, InferTy,
+    TypeFoldable, UniverseIndex, Upcast, Variance,
+    inherent::{SliceLike, Ty as _},
+    relate::{
+        Relate, TypeRelation, VarianceDiagInfo,
+        combine::{super_combine_consts, super_combine_tys},
+    },
+};
+
+pub mod instantiate;
+
+impl<'db> InferCtxt<'db> {
+    /// Creates an instantiation S for the canonical value with fresh inference
+    /// variables and placeholders then applies it to the canonical value.
+    /// Returns both the instantiated result *and* the instantiation S.
+    ///
+    /// This can be invoked as part of constructing an
+    /// inference context at the start of a query (see
+    /// `InferCtxtBuilder::build_with_canonical`). It basically
+    /// brings the canonical value "into scope" within your new infcx.
+    ///
+    /// At the end of processing, the instantiation S (once
+    /// canonicalized) then represents the values that you computed
+    /// for each of the canonical inputs to your query.
+    pub fn instantiate_canonical<T>(
+        &self,
+        canonical: &Canonical<'db, T>,
+    ) -> (T, CanonicalVarValues<'db>)
+    where
+        T: TypeFoldable<DbInterner<'db>>,
+    {
+        // For each universe that is referred to in the incoming
+        // query, create a universe in our local inference context. In
+        // practice, as of this writing, all queries have no universes
+        // in them, so this code has no effect, but it is looking
+        // forward to the day when we *do* want to carry universes
+        // through into queries.
+        //
+        // Instantiate the root-universe content into the current universe,
+        // and create fresh universes for the higher universes.
+        let universes: IndexVec<UniverseIndex, _> = std::iter::once(self.universe())
+            .chain((1..=canonical.max_universe.as_u32()).map(|_| self.create_next_universe()))
+            .collect();
+
+        let canonical_inference_vars =
+            self.instantiate_canonical_vars(canonical.variables, |ui| universes[ui]);
+        let result = canonical.instantiate(self.interner, &canonical_inference_vars);
+        (result, canonical_inference_vars)
+    }
+
+    /// Given the "infos" about the canonical variables from some
+    /// canonical, creates fresh variables with the same
+    /// characteristics (see `instantiate_canonical_var` for
+    /// details). You can then use `instantiate` to instantiate the
+    /// canonical variable with these inference variables.
+    fn instantiate_canonical_vars(
+        &self,
+        variables: CanonicalVars<'db>,
+        universe_map: impl Fn(UniverseIndex) -> UniverseIndex,
+    ) -> CanonicalVarValues<'db> {
+        CanonicalVarValues {
+            var_values: self.interner.mk_args_from_iter(
+                variables.iter().map(|info| self.instantiate_canonical_var(info, &universe_map)),
+            ),
+        }
+    }
+
+    /// Given the "info" about a canonical variable, creates a fresh
+    /// variable for it. If this is an existentially quantified
+    /// variable, then you'll get a new inference variable; if it is a
+    /// universally quantified variable, you get a placeholder.
+    ///
+    /// FIXME(-Znext-solver): This is public because it's used by the
+    /// new trait solver which has a different canonicalization routine.
+    /// We should somehow deduplicate all of this.
+    pub fn instantiate_canonical_var(
+        &self,
+        cv_info: CanonicalVarKind<DbInterner<'db>>,
+        universe_map: impl Fn(UniverseIndex) -> UniverseIndex,
+    ) -> GenericArg<'db> {
+        match cv_info {
+            CanonicalVarKind::Ty(ty_kind) => {
+                let ty = match ty_kind {
+                    CanonicalTyVarKind::General(ui) => {
+                        self.next_ty_var_in_universe(universe_map(ui))
+                    }
+
+                    CanonicalTyVarKind::Int => self.next_int_var(),
+
+                    CanonicalTyVarKind::Float => self.next_float_var(),
+                };
+                ty.into()
+            }
+
+            CanonicalVarKind::PlaceholderTy(PlaceholderTy { universe, bound }) => {
+                let universe_mapped = universe_map(universe);
+                let placeholder_mapped = PlaceholderTy { universe: universe_mapped, bound };
+                Ty::new_placeholder(self.interner, placeholder_mapped).into()
+            }
+
+            CanonicalVarKind::Region(ui) => {
+                self.next_region_var_in_universe(universe_map(ui)).into()
+            }
+
+            CanonicalVarKind::PlaceholderRegion(PlaceholderRegion { universe, bound }) => {
+                let universe_mapped = universe_map(universe);
+                let placeholder_mapped: crate::next_solver::Placeholder<
+                    crate::next_solver::BoundRegion,
+                > = PlaceholderRegion { universe: universe_mapped, bound };
+                Region::new_placeholder(self.interner, placeholder_mapped).into()
+            }
+
+            CanonicalVarKind::Const(ui) => self.next_const_var_in_universe(universe_map(ui)).into(),
+            CanonicalVarKind::PlaceholderConst(PlaceholderConst { universe, bound }) => {
+                let universe_mapped = universe_map(universe);
+                let placeholder_mapped = PlaceholderConst { universe: universe_mapped, bound };
+                Const::new_placeholder(self.interner, placeholder_mapped).into()
+            }
+        }
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/context.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/context.rs
new file mode 100644
index 0000000000000..93fd6eeab34e4
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/context.rs
@@ -0,0 +1,316 @@
+//! Definition of `InferCtxtLike` from the librarified type layer.
+
+use rustc_type_ir::{
+    ConstVid, FloatVarValue, FloatVid, GenericArgKind, InferConst, InferTy, IntTy, IntVarValue,
+    IntVid, RegionVid, TyVid, TypeFoldable, TypingMode, UniverseIndex,
+    inherent::{Const as _, IntoKind, Span as _, Ty as _},
+    relate::combine::PredicateEmittingRelation,
+};
+
+use crate::next_solver::{
+    Binder, Const, ConstKind, DbInterner, ErrorGuaranteed, GenericArgs, OpaqueTypeKey, ParamEnv,
+    Region, SolverDefId, Span, Ty, TyKind,
+    infer::opaque_types::{OpaqueHiddenType, table::OpaqueTypeStorageEntries},
+};
+
+use super::{BoundRegionConversionTime, InferCtxt, relate::RelateResult, traits::ObligationCause};
+
+impl<'db> rustc_type_ir::InferCtxtLike for InferCtxt<'db> {
+    type Interner = DbInterner<'db>;
+
+    fn cx(&self) -> DbInterner<'db> {
+        self.interner
+    }
+
+    fn next_trait_solver(&self) -> bool {
+        true
+    }
+
+    fn typing_mode(&self) -> TypingMode<DbInterner<'db>> {
+        self.typing_mode()
+    }
+
+    fn universe(&self) -> UniverseIndex {
+        self.universe()
+    }
+
+    fn create_next_universe(&self) -> UniverseIndex {
+        self.create_next_universe()
+    }
+
+    fn universe_of_ty(&self, vid: TyVid) -> Option<UniverseIndex> {
+        self.probe_ty_var(vid).err()
+    }
+
+    fn universe_of_lt(&self, lt: RegionVid) -> Option<UniverseIndex> {
+        self.inner.borrow_mut().unwrap_region_constraints().probe_value(lt).err()
+    }
+
+    fn universe_of_ct(&self, ct: ConstVid) -> Option<UniverseIndex> {
+        self.probe_const_var(ct).err()
+    }
+
+    fn root_ty_var(&self, var: TyVid) -> TyVid {
+        self.root_var(var)
+    }
+
+    fn root_const_var(&self, var: ConstVid) -> ConstVid {
+        self.root_const_var(var)
+    }
+
+    fn opportunistic_resolve_ty_var(&self, vid: TyVid) -> Ty<'db> {
+        match self.probe_ty_var(vid) {
+            Ok(ty) => ty,
+            Err(_) => Ty::new_var(self.interner, self.root_var(vid)),
+        }
+    }
+
+    fn opportunistic_resolve_int_var(&self, vid: IntVid) -> Ty<'db> {
+        self.opportunistic_resolve_int_var(vid)
+    }
+
+    fn opportunistic_resolve_float_var(&self, vid: FloatVid) -> Ty<'db> {
+        self.opportunistic_resolve_float_var(vid)
+    }
+
+    fn opportunistic_resolve_ct_var(&self, vid: ConstVid) -> Const<'db> {
+        match self.probe_const_var(vid) {
+            Ok(ct) => ct,
+            Err(_) => Const::new_var(self.interner, self.root_const_var(vid)),
+        }
+    }
+
+    fn opportunistic_resolve_lt_var(&self, vid: RegionVid) -> Region<'db> {
+        self.inner
+            .borrow_mut()
+            .unwrap_region_constraints()
+            .opportunistic_resolve_var(self.interner, vid)
+    }
+
+    fn is_changed_arg(&self, arg: <Self::Interner as rustc_type_ir::Interner>::GenericArg) -> bool {
+        match arg.kind() {
+            GenericArgKind::Lifetime(_) => {
+                // Lifetimes should not change affect trait selection.
+                false
+            }
+            GenericArgKind::Type(ty) => {
+                if let TyKind::Infer(infer_ty) = ty.kind() {
+                    match infer_ty {
+                        InferTy::TyVar(vid) => {
+                            !self.probe_ty_var(vid).is_err_and(|_| self.root_var(vid) == vid)
+                        }
+                        InferTy::IntVar(vid) => {
+                            let mut inner = self.inner.borrow_mut();
+                            !matches!(
+                                inner.int_unification_table().probe_value(vid),
+                                IntVarValue::Unknown
+                                    if inner.int_unification_table().find(vid) == vid
+                            )
+                        }
+                        InferTy::FloatVar(vid) => {
+                            let mut inner = self.inner.borrow_mut();
+                            !matches!(
+                                inner.float_unification_table().probe_value(vid),
+                                FloatVarValue::Unknown
+                                    if inner.float_unification_table().find(vid) == vid
+                            )
+                        }
+                        InferTy::FreshTy(_) | InferTy::FreshIntTy(_) | InferTy::FreshFloatTy(_) => {
+                            true
+                        }
+                    }
+                } else {
+                    true
+                }
+            }
+            GenericArgKind::Const(ct) => {
+                if let ConstKind::Infer(infer_ct) = ct.kind() {
+                    match infer_ct {
+                        InferConst::Var(vid) => !self
+                            .probe_const_var(vid)
+                            .is_err_and(|_| self.root_const_var(vid) == vid),
+                        InferConst::Fresh(_) => true,
+                    }
+                } else {
+                    true
+                }
+            }
+        }
+    }
+
+    fn next_ty_infer(&self) -> Ty<'db> {
+        self.next_ty_var()
+    }
+
+    fn next_region_infer(&self) -> <Self::Interner as rustc_type_ir::Interner>::Region {
+        self.next_region_var()
+    }
+
+    fn next_const_infer(&self) -> Const<'db> {
+        self.next_const_var()
+    }
+
+    fn fresh_args_for_item(&self, def_id: SolverDefId) -> GenericArgs<'db> {
+        self.fresh_args_for_item(def_id)
+    }
+
+    fn instantiate_binder_with_infer<T: TypeFoldable<DbInterner<'db>> + Clone>(
+        &self,
+        value: Binder<'db, T>,
+    ) -> T {
+        self.instantiate_binder_with_fresh_vars(BoundRegionConversionTime::HigherRankedType, value)
+    }
+
+    fn enter_forall<T: TypeFoldable<DbInterner<'db>> + Clone, U>(
+        &self,
+        value: Binder<'db, T>,
+        f: impl FnOnce(T) -> U,
+    ) -> U {
+        self.enter_forall(value, f)
+    }
+
+    fn equate_ty_vids_raw(&self, a: rustc_type_ir::TyVid, b: rustc_type_ir::TyVid) {
+        self.inner.borrow_mut().type_variables().equate(a, b);
+    }
+
+    fn equate_int_vids_raw(&self, a: rustc_type_ir::IntVid, b: rustc_type_ir::IntVid) {
+        self.inner.borrow_mut().int_unification_table().union(a, b);
+    }
+
+    fn equate_float_vids_raw(&self, a: rustc_type_ir::FloatVid, b: rustc_type_ir::FloatVid) {
+        self.inner.borrow_mut().float_unification_table().union(a, b);
+    }
+
+    fn equate_const_vids_raw(&self, a: rustc_type_ir::ConstVid, b: rustc_type_ir::ConstVid) {
+        self.inner.borrow_mut().const_unification_table().union(a, b);
+    }
+
+    fn instantiate_ty_var_raw<R: PredicateEmittingRelation<Self>>(
+        &self,
+        relation: &mut R,
+        target_is_expected: bool,
+        target_vid: rustc_type_ir::TyVid,
+        instantiation_variance: rustc_type_ir::Variance,
+        source_ty: Ty<'db>,
+    ) -> RelateResult<'db, ()> {
+        self.instantiate_ty_var(
+            relation,
+            target_is_expected,
+            target_vid,
+            instantiation_variance,
+            source_ty,
+        )
+    }
+
+    fn instantiate_int_var_raw(
+        &self,
+        vid: rustc_type_ir::IntVid,
+        value: rustc_type_ir::IntVarValue,
+    ) {
+        self.inner.borrow_mut().int_unification_table().union_value(vid, value);
+    }
+
+    fn instantiate_float_var_raw(
+        &self,
+        vid: rustc_type_ir::FloatVid,
+        value: rustc_type_ir::FloatVarValue,
+    ) {
+        self.inner.borrow_mut().float_unification_table().union_value(vid, value);
+    }
+
+    fn instantiate_const_var_raw<R: PredicateEmittingRelation<Self>>(
+        &self,
+        relation: &mut R,
+        target_is_expected: bool,
+        target_vid: rustc_type_ir::ConstVid,
+        source_ct: Const<'db>,
+    ) -> RelateResult<'db, ()> {
+        self.instantiate_const_var(relation, target_is_expected, target_vid, source_ct)
+    }
+
+    fn set_tainted_by_errors(&self, e: ErrorGuaranteed) {
+        self.set_tainted_by_errors(e)
+    }
+
+    fn shallow_resolve(&self, ty: Ty<'db>) -> Ty<'db> {
+        self.shallow_resolve(ty)
+    }
+    fn shallow_resolve_const(&self, ct: Const<'db>) -> Const<'db> {
+        self.shallow_resolve_const(ct)
+    }
+
+    fn resolve_vars_if_possible<T>(&self, value: T) -> T
+    where
+        T: TypeFoldable<DbInterner<'db>>,
+    {
+        self.resolve_vars_if_possible(value)
+    }
+
+    fn probe<T>(&self, probe: impl FnOnce() -> T) -> T {
+        self.probe(|_| probe())
+    }
+
+    fn sub_regions(&self, sub: Region<'db>, sup: Region<'db>, span: Span) {
+        self.inner.borrow_mut().unwrap_region_constraints().make_subregion(sub, sup);
+    }
+
+    fn equate_regions(&self, a: Region<'db>, b: Region<'db>, span: Span) {
+        self.inner.borrow_mut().unwrap_region_constraints().make_eqregion(a, b);
+    }
+
+    fn register_ty_outlives(&self, ty: Ty<'db>, r: Region<'db>, span: Span) {
+        //self.register_region_obligation_with_cause(ty, r, &ObligationCause::dummy_with_span(Span::dummy()));
+    }
+
+    type OpaqueTypeStorageEntries = OpaqueTypeStorageEntries;
+
+    fn opaque_types_storage_num_entries(&self) -> OpaqueTypeStorageEntries {
+        self.inner.borrow_mut().opaque_types().num_entries()
+    }
+    fn clone_opaque_types_lookup_table(&self) -> Vec<(OpaqueTypeKey<'db>, Ty<'db>)> {
+        self.inner.borrow_mut().opaque_types().iter_lookup_table().map(|(k, h)| (k, h.ty)).collect()
+    }
+    fn clone_duplicate_opaque_types(&self) -> Vec<(OpaqueTypeKey<'db>, Ty<'db>)> {
+        self.inner
+            .borrow_mut()
+            .opaque_types()
+            .iter_duplicate_entries()
+            .map(|(k, h)| (k, h.ty))
+            .collect()
+    }
+    fn clone_opaque_types_added_since(
+        &self,
+        prev_entries: OpaqueTypeStorageEntries,
+    ) -> Vec<(OpaqueTypeKey<'db>, Ty<'db>)> {
+        self.inner
+            .borrow_mut()
+            .opaque_types()
+            .opaque_types_added_since(prev_entries)
+            .map(|(k, h)| (k, h.ty))
+            .collect()
+    }
+
+    fn register_hidden_type_in_storage(
+        &self,
+        opaque_type_key: OpaqueTypeKey<'db>,
+        hidden_ty: Ty<'db>,
+        _span: Span,
+    ) -> Option<Ty<'db>> {
+        self.register_hidden_type_in_storage(opaque_type_key, OpaqueHiddenType { ty: hidden_ty })
+    }
+    fn add_duplicate_opaque_type(
+        &self,
+        opaque_type_key: OpaqueTypeKey<'db>,
+        hidden_ty: Ty<'db>,
+        _span: Span,
+    ) {
+        self.inner
+            .borrow_mut()
+            .opaque_types()
+            .add_duplicate(opaque_type_key, OpaqueHiddenType { ty: hidden_ty })
+    }
+
+    fn reset_opaque_types(&self) {
+        let _ = self.take_opaque_types();
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs
new file mode 100644
index 0000000000000..19ae76f7e358f
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs
@@ -0,0 +1,1066 @@
+//! Infer context the next-trait-solver.
+
+use std::cell::{Cell, RefCell};
+use std::fmt;
+use std::sync::Arc;
+
+pub use BoundRegionConversionTime::*;
+pub use at::DefineOpaqueTypes;
+use ena::undo_log::UndoLogs;
+use ena::unify as ut;
+use intern::Symbol;
+use opaque_types::{OpaqueHiddenType, OpaqueTypeStorage};
+use region_constraints::{
+    GenericKind, RegionConstraintCollector, RegionConstraintStorage, UndoLog, VarInfos, VerifyBound,
+};
+pub use relate::StructurallyRelateAliases;
+pub use relate::combine::PredicateEmittingRelation;
+use rustc_hash::{FxHashMap, FxHashSet};
+use rustc_pattern_analysis::Captures;
+use rustc_type_ir::error::{ExpectedFound, TypeError};
+use rustc_type_ir::inherent::{
+    Const as _, GenericArg as _, GenericArgs as _, IntoKind, ParamEnv as _, SliceLike, Term as _,
+    Ty as _,
+};
+use rustc_type_ir::{
+    BoundVar, ClosureKind, ConstVid, FloatTy, FloatVarValue, FloatVid, GenericArgKind, InferConst,
+    InferTy, IntTy, IntVarValue, IntVid, OutlivesPredicate, RegionVid, TyVid, UniverseIndex,
+};
+use rustc_type_ir::{TermKind, TypeVisitableExt};
+use rustc_type_ir::{TypeFoldable, TypeFolder, TypeSuperFoldable};
+use snapshot::undo_log::InferCtxtUndoLogs;
+use tracing::{debug, instrument};
+use traits::{ObligationCause, PredicateObligations};
+use type_variable::TypeVariableOrigin;
+use unify_key::{ConstVariableOrigin, ConstVariableValue, ConstVidKey};
+
+use crate::next_solver::fold::BoundVarReplacerDelegate;
+use crate::next_solver::infer::opaque_types::table::OpaqueTypeStorageEntries;
+use crate::next_solver::{BoundRegion, BoundTy, BoundVarKind};
+
+use super::generics::{GenericParamDef, GenericParamDefKind};
+use super::{
+    AliasTerm, Binder, BoundRegionKind, CanonicalQueryInput, CanonicalVarValues, Const, ConstKind,
+    DbInterner, ErrorGuaranteed, FxIndexMap, GenericArg, GenericArgs, OpaqueTypeKey, ParamEnv,
+    PlaceholderRegion, PolyCoercePredicate, PolyExistentialProjection, PolyExistentialTraitRef,
+    PolyFnSig, PolyRegionOutlivesPredicate, PolySubtypePredicate, Predicate, Region, SolverDefId,
+    SubtypePredicate, Term, TraitPredicate, TraitRef, Ty, TyKind, TypingMode,
+};
+
+pub mod at;
+pub mod canonical;
+mod context;
+mod opaque_types;
+pub mod region_constraints;
+pub mod relate;
+pub mod resolve;
+pub(crate) mod snapshot;
+pub(crate) mod traits;
+mod type_variable;
+mod unify_key;
+
+/// `InferOk<'tcx, ()>` is used a lot. It may seem like a useless wrapper
+/// around `PredicateObligations`, but it has one important property:
+/// because `InferOk` is marked with `#[must_use]`, if you have a method
+/// `InferCtxt::f` that returns `InferResult<()>` and you call it with
+/// `infcx.f()?;` you'll get a warning about the obligations being discarded
+/// without use, which is probably unintentional and has been a source of bugs
+/// in the past.
+#[must_use]
+#[derive(Debug)]
+pub struct InferOk<'db, T> {
+    pub value: T,
+    pub obligations: PredicateObligations<'db>,
+}
+pub type InferResult<'db, T> = Result<InferOk<'db, T>, TypeError<DbInterner<'db>>>;
+
+pub(crate) type FixupResult<T> = Result<T, FixupError>; // "fixup result"
+
+pub(crate) type UnificationTable<'a, 'db, T> = ut::UnificationTable<
+    ut::InPlace<T, &'a mut ut::UnificationStorage<T>, &'a mut InferCtxtUndoLogs<'db>>,
+>;
+
+/// This type contains all the things within `InferCtxt` that sit within a
+/// `RefCell` and are involved with taking/rolling back snapshots. Snapshot
+/// operations are hot enough that we want only one call to `borrow_mut` per
+/// call to `start_snapshot` and `rollback_to`.
+#[derive(Clone)]
+pub struct InferCtxtInner<'db> {
+    pub(crate) undo_log: InferCtxtUndoLogs<'db>,
+
+    /// We instantiate `UnificationTable` with `bounds<Ty>` because the types
+    /// that might instantiate a general type variable have an order,
+    /// represented by its upper and lower bounds.
+    pub(crate) type_variable_storage: type_variable::TypeVariableStorage<'db>,
+
+    /// Map from const parameter variable to the kind of const it represents.
+    pub(crate) const_unification_storage: ut::UnificationTableStorage<ConstVidKey<'db>>,
+
+    /// Map from integral variable to the kind of integer it represents.
+    pub(crate) int_unification_storage: ut::UnificationTableStorage<IntVid>,
+
+    /// Map from floating variable to the kind of float it represents.
+    pub(crate) float_unification_storage: ut::UnificationTableStorage<FloatVid>,
+
+    /// Tracks the set of region variables and the constraints between them.
+    ///
+    /// This is initially `Some(_)` but when
+    /// `resolve_regions_and_report_errors` is invoked, this gets set to `None`
+    /// -- further attempts to perform unification, etc., may fail if new
+    /// region constraints would've been added.
+    pub(crate) region_constraint_storage: Option<RegionConstraintStorage<'db>>,
+
+    /// A set of constraints that regionck must validate.
+    ///
+    /// Each constraint has the form `T:'a`, meaning "some type `T` must
+    /// outlive the lifetime 'a". These constraints derive from
+    /// instantiated type parameters. So if you had a struct defined
+    /// like the following:
+    /// ```ignore (illustrative)
+    /// struct Foo<T: 'static> { ... }
+    /// ```
+    /// In some expression `let x = Foo { ... }`, it will
+    /// instantiate the type parameter `T` with a fresh type `$0`. At
+    /// the same time, it will record a region obligation of
+    /// `$0: 'static`. This will get checked later by regionck. (We
+    /// can't generally check these things right away because we have
+    /// to wait until types are resolved.)
+    ///
+    /// These are stored in a map keyed to the id of the innermost
+    /// enclosing fn body / static initializer expression. This is
+    /// because the location where the obligation was incurred can be
+    /// relevant with respect to which sublifetime assumptions are in
+    /// place. The reason that we store under the fn-id, and not
+    /// something more fine-grained, is so that it is easier for
+    /// regionck to be sure that it has found *all* the region
+    /// obligations (otherwise, it's easy to fail to walk to a
+    /// particular node-id).
+    ///
+    /// Before running `resolve_regions_and_report_errors`, the creator
+    /// of the inference context is expected to invoke
+    /// [`InferCtxt::process_registered_region_obligations`]
+    /// for each body-id in this map, which will process the
+    /// obligations within. This is expected to be done 'late enough'
+    /// that all type inference variables have been bound and so forth.
+    pub(crate) region_obligations: Vec<RegionObligation<'db>>,
+
+    /// Caches for opaque type inference.
+    pub(crate) opaque_type_storage: OpaqueTypeStorage<'db>,
+}
+
+impl<'db> InferCtxtInner<'db> {
+    fn new() -> InferCtxtInner<'db> {
+        InferCtxtInner {
+            undo_log: InferCtxtUndoLogs::default(),
+
+            type_variable_storage: Default::default(),
+            const_unification_storage: Default::default(),
+            int_unification_storage: Default::default(),
+            float_unification_storage: Default::default(),
+            region_constraint_storage: Some(Default::default()),
+            region_obligations: vec![],
+            opaque_type_storage: Default::default(),
+        }
+    }
+
+    #[inline]
+    pub fn region_obligations(&self) -> &[RegionObligation<'db>] {
+        &self.region_obligations
+    }
+
+    #[inline]
+    fn try_type_variables_probe_ref(
+        &self,
+        vid: TyVid,
+    ) -> Option<&type_variable::TypeVariableValue<'db>> {
+        // Uses a read-only view of the unification table, this way we don't
+        // need an undo log.
+        self.type_variable_storage.eq_relations_ref().try_probe_value(vid)
+    }
+
+    #[inline]
+    fn type_variables(&mut self) -> type_variable::TypeVariableTable<'_, 'db> {
+        self.type_variable_storage.with_log(&mut self.undo_log)
+    }
+
+    #[inline]
+    pub(crate) fn opaque_types(&mut self) -> opaque_types::OpaqueTypeTable<'_, 'db> {
+        self.opaque_type_storage.with_log(&mut self.undo_log)
+    }
+
+    #[inline]
+    fn int_unification_table(&mut self) -> UnificationTable<'_, 'db, IntVid> {
+        self.int_unification_storage.with_log(&mut self.undo_log)
+    }
+
+    #[inline]
+    fn float_unification_table(&mut self) -> UnificationTable<'_, 'db, FloatVid> {
+        self.float_unification_storage.with_log(&mut self.undo_log)
+    }
+
+    #[inline]
+    fn const_unification_table(&mut self) -> UnificationTable<'_, 'db, ConstVidKey<'db>> {
+        self.const_unification_storage.with_log(&mut self.undo_log)
+    }
+
+    #[inline]
+    pub fn unwrap_region_constraints(&mut self) -> RegionConstraintCollector<'db, '_> {
+        self.region_constraint_storage
+            .as_mut()
+            .expect("region constraints already solved")
+            .with_log(&mut self.undo_log)
+    }
+}
+
+pub struct InferCtxt<'db> {
+    pub interner: DbInterner<'db>,
+
+    /// The mode of this inference context, see the struct documentation
+    /// for more details.
+    typing_mode: TypingMode<'db>,
+
+    pub inner: RefCell<InferCtxtInner<'db>>,
+
+    /// When an error occurs, we want to avoid reporting "derived"
+    /// errors that are due to this original failure. We have this
+    /// flag that one can set whenever one creates a type-error that
+    /// is due to an error in a prior pass.
+    ///
+    /// Don't read this flag directly, call `is_tainted_by_errors()`
+    /// and `set_tainted_by_errors()`.
+    tainted_by_errors: Cell<Option<ErrorGuaranteed>>,
+
+    /// What is the innermost universe we have created? Starts out as
+    /// `UniverseIndex::root()` but grows from there as we enter
+    /// universal quantifiers.
+    ///
+    /// N.B., at present, we exclude the universal quantifiers on the
+    /// item we are type-checking, and just consider those names as
+    /// part of the root universe. So this would only get incremented
+    /// when we enter into a higher-ranked (`for<..>`) type or trait
+    /// bound.
+    universe: Cell<UniverseIndex>,
+}
+
+/// See the `error_reporting` module for more details.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum ValuePairs<'db> {
+    Regions(ExpectedFound<Region<'db>>),
+    Terms(ExpectedFound<Term<'db>>),
+    Aliases(ExpectedFound<AliasTerm<'db>>),
+    TraitRefs(ExpectedFound<TraitRef<'db>>),
+    PolySigs(ExpectedFound<PolyFnSig<'db>>),
+    ExistentialTraitRef(ExpectedFound<PolyExistentialTraitRef<'db>>),
+    ExistentialProjection(ExpectedFound<PolyExistentialProjection<'db>>),
+}
+
+impl<'db> ValuePairs<'db> {
+    pub fn ty(&self) -> Option<(Ty<'db>, Ty<'db>)> {
+        if let ValuePairs::Terms(ExpectedFound { expected, found }) = self
+            && let Some(expected) = expected.as_type()
+            && let Some(found) = found.as_type()
+        {
+            return Some((expected, found));
+        }
+        None
+    }
+}
+
+/// The trace designates the path through inference that we took to
+/// encounter an error or subtyping constraint.
+///
+/// See the `error_reporting` module for more details.
+#[derive(Clone, Debug)]
+pub struct TypeTrace<'db> {
+    pub cause: ObligationCause,
+    pub values: ValuePairs<'db>,
+}
+
+/// Times when we replace bound regions with existentials:
+#[derive(Clone, Copy, Debug)]
+pub enum BoundRegionConversionTime {
+    /// when a fn is called
+    FnCall,
+
+    /// when two higher-ranked types are compared
+    HigherRankedType,
+
+    /// when projecting an associated type
+    AssocTypeProjection(SolverDefId),
+}
+
+#[derive(Copy, Clone, Debug)]
+pub struct FixupError {
+    unresolved: TyOrConstInferVar,
+}
+
+impl fmt::Display for FixupError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use TyOrConstInferVar::*;
+
+        match self.unresolved {
+            TyInt(_) => write!(
+                f,
+                "cannot determine the type of this integer; \
+                 add a suffix to specify the type explicitly"
+            ),
+            TyFloat(_) => write!(
+                f,
+                "cannot determine the type of this number; \
+                 add a suffix to specify the type explicitly"
+            ),
+            Ty(_) => write!(f, "unconstrained type"),
+            Const(_) => write!(f, "unconstrained const value"),
+        }
+    }
+}
+
+/// See the `region_obligations` field for more information.
+#[derive(Clone, Debug)]
+pub struct RegionObligation<'db> {
+    pub sub_region: Region<'db>,
+    pub sup_type: Ty<'db>,
+}
+
+/// Used to configure inference contexts before their creation.
+pub struct InferCtxtBuilder<'db> {
+    interner: DbInterner<'db>,
+}
+
+pub trait DbInternerInferExt<'db> {
+    fn infer_ctxt(self) -> InferCtxtBuilder<'db>;
+}
+
+impl<'db> DbInternerInferExt<'db> for DbInterner<'db> {
+    fn infer_ctxt(self) -> InferCtxtBuilder<'db> {
+        InferCtxtBuilder { interner: self }
+    }
+}
+
+impl<'db> InferCtxtBuilder<'db> {
+    /// Given a canonical value `C` as a starting point, create an
+    /// inference context that contains each of the bound values
+    /// within instantiated as a fresh variable. The `f` closure is
+    /// invoked with the new infcx, along with the instantiated value
+    /// `V` and a instantiation `S`. This instantiation `S` maps from
+    /// the bound values in `C` to their instantiated values in `V`
+    /// (in other words, `S(C) = V`).
+    pub fn build_with_canonical<T>(
+        mut self,
+        input: &CanonicalQueryInput<'db, T>,
+    ) -> (InferCtxt<'db>, T, CanonicalVarValues<'db>)
+    where
+        T: TypeFoldable<DbInterner<'db>>,
+    {
+        let infcx = self.build(input.typing_mode);
+        let (value, args) = infcx.instantiate_canonical(&input.canonical);
+        (infcx, value, args)
+    }
+
+    pub fn build(&mut self, typing_mode: TypingMode<'db>) -> InferCtxt<'db> {
+        let InferCtxtBuilder { interner } = *self;
+        InferCtxt {
+            interner,
+            typing_mode,
+            inner: RefCell::new(InferCtxtInner::new()),
+            tainted_by_errors: Cell::new(None),
+            universe: Cell::new(UniverseIndex::ROOT),
+        }
+    }
+}
+
+impl<'db> InferOk<'db, ()> {
+    pub fn into_obligations(self) -> PredicateObligations<'db> {
+        self.obligations
+    }
+}
+
+impl<'db> InferCtxt<'db> {
+    #[inline(always)]
+    pub fn typing_mode(&self) -> TypingMode<'db> {
+        self.typing_mode
+    }
+
+    #[inline(always)]
+    pub fn typing_mode_unchecked(&self) -> TypingMode<'db> {
+        self.typing_mode
+    }
+
+    pub fn unresolved_variables(&self) -> Vec<Ty<'db>> {
+        let mut inner = self.inner.borrow_mut();
+        let mut vars: Vec<Ty<'db>> = inner
+            .type_variables()
+            .unresolved_variables()
+            .into_iter()
+            .map(|t| Ty::new_var(self.interner, t))
+            .collect();
+        vars.extend(
+            (0..inner.int_unification_table().len())
+                .map(IntVid::from_usize)
+                .filter(|&vid| inner.int_unification_table().probe_value(vid).is_unknown())
+                .map(|v| Ty::new_int_var(self.interner, v)),
+        );
+        vars.extend(
+            (0..inner.float_unification_table().len())
+                .map(FloatVid::from_usize)
+                .filter(|&vid| inner.float_unification_table().probe_value(vid).is_unknown())
+                .map(|v| Ty::new_float_var(self.interner, v)),
+        );
+        vars
+    }
+
+    #[instrument(skip(self), level = "debug")]
+    pub fn sub_regions(&self, a: Region<'db>, b: Region<'db>) {
+        self.inner.borrow_mut().unwrap_region_constraints().make_subregion(a, b);
+    }
+
+    /// Processes a `Coerce` predicate from the fulfillment context.
+    /// This is NOT the preferred way to handle coercion, which is to
+    /// invoke `FnCtxt::coerce` or a similar method (see `coercion.rs`).
+    ///
+    /// This method here is actually a fallback that winds up being
+    /// invoked when `FnCtxt::coerce` encounters unresolved type variables
+    /// and records a coercion predicate. Presently, this method is equivalent
+    /// to `subtype_predicate` -- that is, "coercing" `a` to `b` winds up
+    /// actually requiring `a <: b`. This is of course a valid coercion,
+    /// but it's not as flexible as `FnCtxt::coerce` would be.
+    ///
+    /// (We may refactor this in the future, but there are a number of
+    /// practical obstacles. Among other things, `FnCtxt::coerce` presently
+    /// records adjustments that are required on the HIR in order to perform
+    /// the coercion, and we don't currently have a way to manage that.)
+    pub fn coerce_predicate(
+        &self,
+        cause: &ObligationCause,
+        param_env: ParamEnv<'db>,
+        predicate: PolyCoercePredicate<'db>,
+    ) -> Result<InferResult<'db, ()>, (TyVid, TyVid)> {
+        let subtype_predicate = predicate.map_bound(|p| SubtypePredicate {
+            a_is_expected: false, // when coercing from `a` to `b`, `b` is expected
+            a: p.a,
+            b: p.b,
+        });
+        self.subtype_predicate(cause, param_env, subtype_predicate)
+    }
+
+    pub fn subtype_predicate(
+        &self,
+        cause: &ObligationCause,
+        param_env: ParamEnv<'db>,
+        predicate: PolySubtypePredicate<'db>,
+    ) -> Result<InferResult<'db, ()>, (TyVid, TyVid)> {
+        // Check for two unresolved inference variables, in which case we can
+        // make no progress. This is partly a micro-optimization, but it's
+        // also an opportunity to "sub-unify" the variables. This isn't
+        // *necessary* to prevent cycles, because they would eventually be sub-unified
+        // anyhow during generalization, but it helps with diagnostics (we can detect
+        // earlier that they are sub-unified).
+        //
+        // Note that we can just skip the binders here because
+        // type variables can't (at present, at
+        // least) capture any of the things bound by this binder.
+        //
+        // Note that this sub here is not just for diagnostics - it has semantic
+        // effects as well.
+        let r_a = self.shallow_resolve(predicate.skip_binder().a);
+        let r_b = self.shallow_resolve(predicate.skip_binder().b);
+        match (r_a.kind(), r_b.kind()) {
+            (TyKind::Infer(InferTy::TyVar(a_vid)), TyKind::Infer(InferTy::TyVar(b_vid))) => {
+                return Err((a_vid, b_vid));
+            }
+            _ => {}
+        }
+
+        self.enter_forall(predicate, |SubtypePredicate { a_is_expected, a, b }| {
+            if a_is_expected {
+                Ok(self.at(cause, param_env).sub(DefineOpaqueTypes::Yes, a, b))
+            } else {
+                Ok(self.at(cause, param_env).sup(DefineOpaqueTypes::Yes, b, a))
+            }
+        })
+    }
+
+    pub fn region_outlives_predicate(
+        &self,
+        cause: &traits::ObligationCause,
+        predicate: PolyRegionOutlivesPredicate<'db>,
+    ) {
+        self.enter_forall(predicate, |OutlivesPredicate(r_a, r_b)| {
+            self.sub_regions(r_b, r_a); // `b : a` ==> `a <= b`
+        })
+    }
+
+    /// Number of type variables created so far.
+    pub fn num_ty_vars(&self) -> usize {
+        self.inner.borrow_mut().type_variables().num_vars()
+    }
+
+    pub fn next_ty_var(&self) -> Ty<'db> {
+        self.next_ty_var_with_origin(TypeVariableOrigin { param_def_id: None })
+    }
+
+    pub fn next_ty_var_with_origin(&self, origin: TypeVariableOrigin) -> Ty<'db> {
+        let vid = self.inner.borrow_mut().type_variables().new_var(self.universe(), origin);
+        Ty::new_var(self.interner, vid)
+    }
+
+    pub fn next_ty_var_id_in_universe(&self, universe: UniverseIndex) -> TyVid {
+        let origin = TypeVariableOrigin { param_def_id: None };
+        self.inner.borrow_mut().type_variables().new_var(universe, origin)
+    }
+
+    pub fn next_ty_var_in_universe(&self, universe: UniverseIndex) -> Ty<'db> {
+        let vid = self.next_ty_var_id_in_universe(universe);
+        Ty::new_var(self.interner, vid)
+    }
+
+    pub fn next_const_var(&self) -> Const<'db> {
+        self.next_const_var_with_origin(ConstVariableOrigin { param_def_id: None })
+    }
+
+    pub fn next_const_var_with_origin(&self, origin: ConstVariableOrigin) -> Const<'db> {
+        let vid = self
+            .inner
+            .borrow_mut()
+            .const_unification_table()
+            .new_key(ConstVariableValue::Unknown { origin, universe: self.universe() })
+            .vid;
+        Const::new_var(self.interner, vid)
+    }
+
+    pub fn next_const_var_in_universe(&self, universe: UniverseIndex) -> Const<'db> {
+        let origin = ConstVariableOrigin { param_def_id: None };
+        let vid = self
+            .inner
+            .borrow_mut()
+            .const_unification_table()
+            .new_key(ConstVariableValue::Unknown { origin, universe })
+            .vid;
+        Const::new_var(self.interner, vid)
+    }
+
+    pub fn next_int_var(&self) -> Ty<'db> {
+        let next_int_var_id =
+            self.inner.borrow_mut().int_unification_table().new_key(IntVarValue::Unknown);
+        Ty::new_int_var(self.interner, next_int_var_id)
+    }
+
+    pub fn next_float_var(&self) -> Ty<'db> {
+        let next_float_var_id =
+            self.inner.borrow_mut().float_unification_table().new_key(FloatVarValue::Unknown);
+        Ty::new_float_var(self.interner, next_float_var_id)
+    }
+
+    /// Creates a fresh region variable with the next available index.
+    /// The variable will be created in the maximum universe created
+    /// thus far, allowing it to name any region created thus far.
+    pub fn next_region_var(&self) -> Region<'db> {
+        self.next_region_var_in_universe(self.universe())
+    }
+
+    /// Creates a fresh region variable with the next available index
+    /// in the given universe; typically, you can use
+    /// `next_region_var` and just use the maximal universe.
+    pub fn next_region_var_in_universe(&self, universe: UniverseIndex) -> Region<'db> {
+        let region_var =
+            self.inner.borrow_mut().unwrap_region_constraints().new_region_var(universe);
+        Region::new_var(self.interner, region_var)
+    }
+
+    pub fn next_term_var_of_kind(&self, term: Term<'db>) -> Term<'db> {
+        match term.kind() {
+            TermKind::Ty(_) => self.next_ty_var().into(),
+            TermKind::Const(_) => self.next_const_var().into(),
+        }
+    }
+
+    /// Return the universe that the region `r` was created in. For
+    /// most regions (e.g., `'static`, named regions from the user,
+    /// etc) this is the root universe U0. For inference variables or
+    /// placeholders, however, it will return the universe which they
+    /// are associated.
+    pub fn universe_of_region(&self, r: Region<'db>) -> UniverseIndex {
+        self.inner.borrow_mut().unwrap_region_constraints().universe(r)
+    }
+
+    /// Number of region variables created so far.
+    pub fn num_region_vars(&self) -> usize {
+        self.inner.borrow_mut().unwrap_region_constraints().num_region_vars()
+    }
+
+    /// Just a convenient wrapper of `next_region_var` for using during NLL.
+    #[instrument(skip(self), level = "debug")]
+    pub fn next_nll_region_var(&self) -> Region<'db> {
+        self.next_region_var()
+    }
+
+    /// Just a convenient wrapper of `next_region_var` for using during NLL.
+    #[instrument(skip(self), level = "debug")]
+    pub fn next_nll_region_var_in_universe(&self, universe: UniverseIndex) -> Region<'db> {
+        self.next_region_var_in_universe(universe)
+    }
+
+    fn var_for_def(&self, kind: GenericParamDefKind, name: &Symbol) -> GenericArg<'db> {
+        match kind {
+            GenericParamDefKind::Lifetime => {
+                // Create a region inference variable for the given
+                // region parameter definition.
+                self.next_region_var().into()
+            }
+            GenericParamDefKind::Type => {
+                // Create a type inference variable for the given
+                // type parameter definition. The generic parameters are
+                // for actual parameters that may be referred to by
+                // the default of this type parameter, if it exists.
+                // e.g., `struct Foo<A, B, C = (A, B)>(...);` when
+                // used in a path such as `Foo::<T, U>::new()` will
+                // use an inference variable for `C` with `[T, U]`
+                // as the generic parameters for the default, `(T, U)`.
+                let ty_var_id = self
+                    .inner
+                    .borrow_mut()
+                    .type_variables()
+                    .new_var(self.universe(), TypeVariableOrigin { param_def_id: None });
+
+                Ty::new_var(self.interner, ty_var_id).into()
+            }
+            GenericParamDefKind::Const => {
+                let origin = ConstVariableOrigin { param_def_id: None };
+                let const_var_id = self
+                    .inner
+                    .borrow_mut()
+                    .const_unification_table()
+                    .new_key(ConstVariableValue::Unknown { origin, universe: self.universe() })
+                    .vid;
+                Const::new_var(self.interner, const_var_id).into()
+            }
+        }
+    }
+
+    /// Given a set of generics defined on a type or impl, returns the generic parameters mapping
+    /// each type/region parameter to a fresh inference variable.
+    pub fn fresh_args_for_item(&self, def_id: SolverDefId) -> GenericArgs<'db> {
+        GenericArgs::for_item(self.interner, def_id, |name, index, kind, _| {
+            self.var_for_def(kind, name)
+        })
+    }
+
+    /// Returns `true` if errors have been reported since this infcx was
+    /// created. This is sometimes used as a heuristic to skip
+    /// reporting errors that often occur as a result of earlier
+    /// errors, but where it's hard to be 100% sure (e.g., unresolved
+    /// inference variables, regionck errors).
+    #[must_use = "this method does not have any side effects"]
+    pub fn tainted_by_errors(&self) -> Option<ErrorGuaranteed> {
+        self.tainted_by_errors.get()
+    }
+
+    /// Set the "tainted by errors" flag to true. We call this when we
+    /// observe an error from a prior pass.
+    pub fn set_tainted_by_errors(&self, e: ErrorGuaranteed) {
+        debug!("set_tainted_by_errors(ErrorGuaranteed)");
+        self.tainted_by_errors.set(Some(e));
+    }
+
+    #[instrument(level = "debug", skip(self), ret)]
+    pub fn take_opaque_types(&self) -> Vec<(OpaqueTypeKey<'db>, OpaqueHiddenType<'db>)> {
+        self.inner.borrow_mut().opaque_type_storage.take_opaque_types().collect()
+    }
+
+    #[instrument(level = "debug", skip(self), ret)]
+    pub fn clone_opaque_types(&self) -> Vec<(OpaqueTypeKey<'db>, OpaqueHiddenType<'db>)> {
+        self.inner.borrow_mut().opaque_type_storage.iter_opaque_types().collect()
+    }
+
+    #[inline(always)]
+    pub fn can_define_opaque_ty(&self, id: impl Into<SolverDefId>) -> bool {
+        match self.typing_mode_unchecked() {
+            TypingMode::Analysis { defining_opaque_types_and_generators } => {
+                defining_opaque_types_and_generators.contains(&id.into())
+            }
+            TypingMode::Coherence | TypingMode::PostAnalysis => false,
+            TypingMode::Borrowck { defining_opaque_types } => unimplemented!(),
+            TypingMode::PostBorrowckAnalysis { defined_opaque_types } => unimplemented!(),
+        }
+    }
+
+    /// If `TyVar(vid)` resolves to a type, return that type. Else, return the
+    /// universe index of `TyVar(vid)`.
+    pub fn probe_ty_var(&self, vid: TyVid) -> Result<Ty<'db>, UniverseIndex> {
+        use self::type_variable::TypeVariableValue;
+
+        match self.inner.borrow_mut().type_variables().probe(vid) {
+            TypeVariableValue::Known { value } => Ok(value),
+            TypeVariableValue::Unknown { universe } => Err(universe),
+        }
+    }
+
+    pub fn shallow_resolve(&self, ty: Ty<'db>) -> Ty<'db> {
+        if let TyKind::Infer(v) = ty.kind() {
+            match v {
+                InferTy::TyVar(v) => {
+                    // Not entirely obvious: if `typ` is a type variable,
+                    // it can be resolved to an int/float variable, which
+                    // can then be recursively resolved, hence the
+                    // recursion. Note though that we prevent type
+                    // variables from unifying to other type variables
+                    // directly (though they may be embedded
+                    // structurally), and we prevent cycles in any case,
+                    // so this recursion should always be of very limited
+                    // depth.
+                    //
+                    // Note: if these two lines are combined into one we get
+                    // dynamic borrow errors on `self.inner`.
+                    let known = self.inner.borrow_mut().type_variables().probe(v).known();
+                    known.map_or(ty, |t| self.shallow_resolve(t))
+                }
+
+                InferTy::IntVar(v) => {
+                    match self.inner.borrow_mut().int_unification_table().probe_value(v) {
+                        IntVarValue::IntType(ty) => Ty::new_int(self.interner, ty),
+                        IntVarValue::UintType(ty) => Ty::new_uint(self.interner, ty),
+                        IntVarValue::Unknown => ty,
+                    }
+                }
+
+                InferTy::FloatVar(v) => {
+                    match self.inner.borrow_mut().float_unification_table().probe_value(v) {
+                        FloatVarValue::Known(ty) => Ty::new_float(self.interner, ty),
+                        FloatVarValue::Unknown => ty,
+                    }
+                }
+
+                InferTy::FreshTy(_) | InferTy::FreshIntTy(_) | InferTy::FreshFloatTy(_) => ty,
+            }
+        } else {
+            ty
+        }
+    }
+
+    pub fn shallow_resolve_const(&self, ct: Const<'db>) -> Const<'db> {
+        match ct.kind() {
+            ConstKind::Infer(infer_ct) => match infer_ct {
+                InferConst::Var(vid) => self
+                    .inner
+                    .borrow_mut()
+                    .const_unification_table()
+                    .probe_value(vid)
+                    .known()
+                    .unwrap_or(ct),
+                InferConst::Fresh(_) => ct,
+            },
+            ConstKind::Param(_)
+            | ConstKind::Bound(_, _)
+            | ConstKind::Placeholder(_)
+            | ConstKind::Unevaluated(_)
+            | ConstKind::Value(_)
+            | ConstKind::Error(_)
+            | ConstKind::Expr(_) => ct,
+        }
+    }
+
+    pub fn root_var(&self, var: TyVid) -> TyVid {
+        self.inner.borrow_mut().type_variables().root_var(var)
+    }
+
+    pub fn root_const_var(&self, var: ConstVid) -> ConstVid {
+        self.inner.borrow_mut().const_unification_table().find(var).vid
+    }
+
+    /// Resolves an int var to a rigid int type, if it was constrained to one,
+    /// or else the root int var in the unification table.
+    pub fn opportunistic_resolve_int_var(&self, vid: IntVid) -> Ty<'db> {
+        let mut inner = self.inner.borrow_mut();
+        let value = inner.int_unification_table().probe_value(vid);
+        match value {
+            IntVarValue::IntType(ty) => Ty::new_int(self.interner, ty),
+            IntVarValue::UintType(ty) => Ty::new_uint(self.interner, ty),
+            IntVarValue::Unknown => {
+                Ty::new_int_var(self.interner, inner.int_unification_table().find(vid))
+            }
+        }
+    }
+
+    /// Resolves a float var to a rigid int type, if it was constrained to one,
+    /// or else the root float var in the unification table.
+    pub fn opportunistic_resolve_float_var(&self, vid: FloatVid) -> Ty<'db> {
+        let mut inner = self.inner.borrow_mut();
+        let value = inner.float_unification_table().probe_value(vid);
+        match value {
+            FloatVarValue::Known(ty) => Ty::new_float(self.interner, ty),
+            FloatVarValue::Unknown => {
+                Ty::new_float_var(self.interner, inner.float_unification_table().find(vid))
+            }
+        }
+    }
+
+    /// Where possible, replaces type/const variables in
+    /// `value` with their final value. Note that region variables
+    /// are unaffected. If a type/const variable has not been unified, it
+    /// is left as is. This is an idempotent operation that does
+    /// not affect inference state in any way and so you can do it
+    /// at will.
+    pub fn resolve_vars_if_possible<T>(&self, value: T) -> T
+    where
+        T: TypeFoldable<DbInterner<'db>>,
+    {
+        if let Err(guar) = value.error_reported() {
+            self.set_tainted_by_errors(guar);
+        }
+        if !value.has_non_region_infer() {
+            return value;
+        }
+        let mut r = resolve::OpportunisticVarResolver::new(self);
+        value.fold_with(&mut r)
+    }
+
+    pub fn probe_const_var(&self, vid: ConstVid) -> Result<Const<'db>, UniverseIndex> {
+        match self.inner.borrow_mut().const_unification_table().probe_value(vid) {
+            ConstVariableValue::Known { value } => Ok(value),
+            ConstVariableValue::Unknown { origin: _, universe } => Err(universe),
+        }
+    }
+
+    // Instantiates the bound variables in a given binder with fresh inference
+    // variables in the current universe.
+    //
+    // Use this method if you'd like to find some generic parameters of the binder's
+    // variables (e.g. during a method call). If there isn't a [`BoundRegionConversionTime`]
+    // that corresponds to your use case, consider whether or not you should
+    // use [`InferCtxt::enter_forall`] instead.
+    pub fn instantiate_binder_with_fresh_vars<T>(
+        &self,
+        lbrct: BoundRegionConversionTime,
+        value: Binder<'db, T>,
+    ) -> T
+    where
+        T: TypeFoldable<DbInterner<'db>> + Clone,
+    {
+        if let Some(inner) = value.clone().no_bound_vars() {
+            return inner;
+        }
+
+        let bound_vars = value.clone().bound_vars();
+        let mut args = Vec::with_capacity(bound_vars.len());
+
+        for bound_var_kind in bound_vars {
+            let arg: GenericArg<'db> = match bound_var_kind {
+                BoundVarKind::Ty(_) => self.next_ty_var().into(),
+                BoundVarKind::Region(br) => self.next_region_var().into(),
+                BoundVarKind::Const => self.next_const_var().into(),
+            };
+            args.push(arg);
+        }
+
+        struct ToFreshVars<'db> {
+            args: Vec<GenericArg<'db>>,
+        }
+
+        impl<'db> BoundVarReplacerDelegate<'db> for ToFreshVars<'db> {
+            fn replace_region(&mut self, br: BoundRegion) -> Region<'db> {
+                self.args[br.var.index()].expect_region()
+            }
+            fn replace_ty(&mut self, bt: BoundTy) -> Ty<'db> {
+                self.args[bt.var.index()].expect_ty()
+            }
+            fn replace_const(&mut self, bv: BoundVar) -> Const<'db> {
+                self.args[bv.index()].expect_const()
+            }
+        }
+        let delegate = ToFreshVars { args };
+        self.interner.replace_bound_vars_uncached(value, delegate)
+    }
+
+    /// Obtains the latest type of the given closure; this may be a
+    /// closure in the current function, in which case its
+    /// `ClosureKind` may not yet be known.
+    pub fn closure_kind(&self, closure_ty: Ty<'db>) -> Option<ClosureKind> {
+        let unresolved_kind_ty = match closure_ty.kind() {
+            TyKind::Closure(_, args) => args.as_closure().kind_ty(),
+            TyKind::CoroutineClosure(_, args) => args.as_coroutine_closure().kind_ty(),
+            _ => panic!("unexpected type {closure_ty:?}"),
+        };
+        let closure_kind_ty = self.shallow_resolve(unresolved_kind_ty);
+        closure_kind_ty.to_opt_closure_kind()
+    }
+
+    pub fn universe(&self) -> UniverseIndex {
+        self.universe.get()
+    }
+
+    /// Creates and return a fresh universe that extends all previous
+    /// universes. Updates `self.universe` to that new universe.
+    pub fn create_next_universe(&self) -> UniverseIndex {
+        let u = self.universe.get().next_universe();
+        debug!("create_next_universe {u:?}");
+        self.universe.set(u);
+        u
+    }
+
+    /// The returned function is used in a fast path. If it returns `true` the variable is
+    /// unchanged, `false` indicates that the status is unknown.
+    #[inline]
+    pub fn is_ty_infer_var_definitely_unchanged<'a>(
+        &'a self,
+    ) -> (impl Fn(TyOrConstInferVar) -> bool + Captures<'db> + 'a) {
+        // This hoists the borrow/release out of the loop body.
+        let inner = self.inner.try_borrow();
+
+        move |infer_var: TyOrConstInferVar| match (infer_var, &inner) {
+            (TyOrConstInferVar::Ty(ty_var), Ok(inner)) => {
+                use self::type_variable::TypeVariableValue;
+
+                matches!(
+                    inner.try_type_variables_probe_ref(ty_var),
+                    Some(TypeVariableValue::Unknown { .. })
+                )
+            }
+            _ => false,
+        }
+    }
+
+    /// `ty_or_const_infer_var_changed` is equivalent to one of these two:
+    ///   * `shallow_resolve(ty) != ty` (where `ty.kind = Infer(_)`)
+    ///   * `shallow_resolve(ct) != ct` (where `ct.kind = ConstKind::Infer(_)`)
+    ///
+    /// However, `ty_or_const_infer_var_changed` is more efficient. It's always
+    /// inlined, despite being large, because it has only two call sites that
+    /// are extremely hot (both in `traits::fulfill`'s checking of `stalled_on`
+    /// inference variables), and it handles both `Ty` and `Const` without
+    /// having to resort to storing full `GenericArg`s in `stalled_on`.
+    #[inline(always)]
+    pub fn ty_or_const_infer_var_changed(&self, infer_var: TyOrConstInferVar) -> bool {
+        match infer_var {
+            TyOrConstInferVar::Ty(v) => {
+                use self::type_variable::TypeVariableValue;
+
+                // If `inlined_probe` returns a `Known` value, it never equals
+                // `Infer(TyVar(v))`.
+                match self.inner.borrow_mut().type_variables().inlined_probe(v) {
+                    TypeVariableValue::Unknown { .. } => false,
+                    TypeVariableValue::Known { .. } => true,
+                }
+            }
+
+            TyOrConstInferVar::TyInt(v) => {
+                // If `inlined_probe_value` returns a value it's always a
+                // `Int(_)` or `UInt(_)`, which never matches a
+                // `Infer(_)`.
+                self.inner.borrow_mut().int_unification_table().inlined_probe_value(v).is_known()
+            }
+
+            TyOrConstInferVar::TyFloat(v) => {
+                // If `probe_value` returns a value it's always a
+                // `Float(_)`, which never matches a `Infer(_)`.
+                //
+                // Not `inlined_probe_value(v)` because this call site is colder.
+                self.inner.borrow_mut().float_unification_table().probe_value(v).is_known()
+            }
+
+            TyOrConstInferVar::Const(v) => {
+                // If `probe_value` returns a `Known` value, it never equals
+                // `ConstKind::Infer(InferConst::Var(v))`.
+                //
+                // Not `inlined_probe_value(v)` because this call site is colder.
+                match self.inner.borrow_mut().const_unification_table().probe_value(v) {
+                    ConstVariableValue::Unknown { .. } => false,
+                    ConstVariableValue::Known { .. } => true,
+                }
+            }
+        }
+    }
+}
+
+/// Helper for [InferCtxt::ty_or_const_infer_var_changed] (see comment on that), currently
+/// used only for `traits::fulfill`'s list of `stalled_on` inference variables.
+#[derive(Copy, Clone, Debug)]
+pub enum TyOrConstInferVar {
+    /// Equivalent to `Infer(TyVar(_))`.
+    Ty(TyVid),
+    /// Equivalent to `Infer(IntVar(_))`.
+    TyInt(IntVid),
+    /// Equivalent to `Infer(FloatVar(_))`.
+    TyFloat(FloatVid),
+
+    /// Equivalent to `ConstKind::Infer(InferConst::Var(_))`.
+    Const(ConstVid),
+}
+
+impl TyOrConstInferVar {
+    /// Tries to extract an inference variable from a type or a constant, returns `None`
+    /// for types other than `Infer(_)` (or `InferTy::Fresh*`) and
+    /// for constants other than `ConstKind::Infer(_)` (or `InferConst::Fresh`).
+    pub fn maybe_from_generic_arg<'db>(arg: GenericArg<'db>) -> Option<Self> {
+        match arg.kind() {
+            GenericArgKind::Type(ty) => Self::maybe_from_ty(ty),
+            GenericArgKind::Const(ct) => Self::maybe_from_const(ct),
+            GenericArgKind::Lifetime(_) => None,
+        }
+    }
+
+    /// Tries to extract an inference variable from a type, returns `None`
+    /// for types other than `Infer(_)` (or `InferTy::Fresh*`).
+    fn maybe_from_ty<'db>(ty: Ty<'db>) -> Option<Self> {
+        match ty.kind() {
+            TyKind::Infer(InferTy::TyVar(v)) => Some(TyOrConstInferVar::Ty(v)),
+            TyKind::Infer(InferTy::IntVar(v)) => Some(TyOrConstInferVar::TyInt(v)),
+            TyKind::Infer(InferTy::FloatVar(v)) => Some(TyOrConstInferVar::TyFloat(v)),
+            _ => None,
+        }
+    }
+
+    /// Tries to extract an inference variable from a constant, returns `None`
+    /// for constants other than `ConstKind::Infer(_)` (or `InferConst::Fresh`).
+    fn maybe_from_const<'db>(ct: Const<'db>) -> Option<Self> {
+        match ct.kind() {
+            ConstKind::Infer(InferConst::Var(v)) => Some(TyOrConstInferVar::Const(v)),
+            _ => None,
+        }
+    }
+}
+
+impl<'db> TypeTrace<'db> {
+    pub fn types(cause: &ObligationCause, a: Ty<'db>, b: Ty<'db>) -> TypeTrace<'db> {
+        TypeTrace {
+            cause: cause.clone(),
+            values: ValuePairs::Terms(ExpectedFound::new(a.into(), b.into())),
+        }
+    }
+
+    pub fn trait_refs(
+        cause: &ObligationCause,
+        a: TraitRef<'db>,
+        b: TraitRef<'db>,
+    ) -> TypeTrace<'db> {
+        TypeTrace { cause: cause.clone(), values: ValuePairs::TraitRefs(ExpectedFound::new(a, b)) }
+    }
+
+    pub fn consts(cause: &ObligationCause, a: Const<'db>, b: Const<'db>) -> TypeTrace<'db> {
+        TypeTrace {
+            cause: cause.clone(),
+            values: ValuePairs::Terms(ExpectedFound::new(a.into(), b.into())),
+        }
+    }
+}
+
+/// Requires that `region` must be equal to one of the regions in `choice_regions`.
+/// We often denote this using the syntax:
+///
+/// ```text
+/// R0 member of [O1..On]
+/// ```
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct MemberConstraint<'db> {
+    /// The `DefId` and args of the opaque type causing this constraint.
+    /// Used for error reporting.
+    pub key: OpaqueTypeKey<'db>,
+
+    /// The hidden type in which `member_region` appears: used for error reporting.
+    pub hidden_ty: Ty<'db>,
+
+    /// The region `R0`.
+    pub member_region: Region<'db>,
+
+    /// The options `O1..On`.
+    pub choice_regions: Arc<Vec<Region<'db>>>,
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/opaque_types/mod.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/opaque_types/mod.rs
new file mode 100644
index 0000000000000..0f68ec8cdb5b4
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/opaque_types/mod.rs
@@ -0,0 +1,56 @@
+//! Things related to the infer context of the next-trait-solver.
+
+use std::sync::Arc;
+
+use tracing::{debug, instrument};
+
+use crate::next_solver::{
+    Clause, ClauseKind, FxIndexMap, GenericArgs, OpaqueTypeKey, ProjectionPredicate, SolverDefId,
+    TypingMode, util::BottomUpFolder,
+};
+
+pub(crate) mod table;
+
+pub(crate) use table::{OpaqueTypeStorage, OpaqueTypeTable};
+
+use crate::next_solver::{
+    AliasTy, Binder, BoundRegion, BoundTy, Canonical, CanonicalVarValues, Const, DbInterner, Goal,
+    ParamEnv, Predicate, PredicateKind, Region, Ty, TyKind,
+    fold::FnMutDelegate,
+    infer::{
+        DefineOpaqueTypes, InferCtxt, TypeTrace,
+        traits::{Obligation, PredicateObligations},
+    },
+};
+use rustc_type_ir::{
+    AliasRelationDirection, AliasTyKind, BoundConstness, BoundVar, Flags, GenericArgKind, InferTy,
+    Interner, RegionKind, TypeFlags, TypeFoldable, TypeSuperVisitable, TypeVisitable,
+    TypeVisitableExt, TypeVisitor, Upcast, Variance,
+    error::{ExpectedFound, TypeError},
+    inherent::{DefId, GenericArgs as _, IntoKind, SliceLike},
+    relate::{
+        Relate, TypeRelation, VarianceDiagInfo,
+        combine::{super_combine_consts, super_combine_tys},
+    },
+};
+
+use super::{InferOk, traits::ObligationCause};
+
+#[derive(Copy, Clone, Debug)]
+pub struct OpaqueHiddenType<'db> {
+    pub ty: Ty<'db>,
+}
+
+impl<'db> InferCtxt<'db> {
+    /// Insert a hidden type into the opaque type storage, making sure
+    /// it hasn't previously been defined. This does not emit any
+    /// constraints and it's the responsibility of the caller to make
+    /// sure that the item bounds of the opaque are checked.
+    pub fn register_hidden_type_in_storage(
+        &self,
+        opaque_type_key: OpaqueTypeKey<'db>,
+        hidden_ty: OpaqueHiddenType<'db>,
+    ) -> Option<Ty<'db>> {
+        self.inner.borrow_mut().opaque_types().register(opaque_type_key, hidden_ty)
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/opaque_types/table.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/opaque_types/table.rs
new file mode 100644
index 0000000000000..8ab409d782813
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/opaque_types/table.rs
@@ -0,0 +1,166 @@
+//! Things related to storage opaques in the infer context of the next-trait-solver.
+
+use std::ops::Deref;
+
+use ena::undo_log::UndoLogs;
+use tracing::instrument;
+
+use super::OpaqueHiddenType;
+use crate::next_solver::{
+    FxIndexMap, OpaqueTypeKey, Ty,
+    infer::snapshot::undo_log::{InferCtxtUndoLogs, UndoLog},
+};
+
+#[derive(Default, Debug, Clone)]
+pub(crate) struct OpaqueTypeStorage<'db> {
+    opaque_types: FxIndexMap<OpaqueTypeKey<'db>, OpaqueHiddenType<'db>>,
+    duplicate_entries: Vec<(OpaqueTypeKey<'db>, OpaqueHiddenType<'db>)>,
+}
+
+/// The number of entries in the opaque type storage at a given point.
+///
+/// Used to check that we haven't added any new opaque types after checking
+/// the opaque types currently in the storage.
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
+pub struct OpaqueTypeStorageEntries {
+    opaque_types: usize,
+    duplicate_entries: usize,
+}
+
+impl rustc_type_ir::inherent::OpaqueTypeStorageEntries for OpaqueTypeStorageEntries {
+    fn needs_reevaluation(self, canonicalized: usize) -> bool {
+        self.opaque_types != canonicalized
+    }
+}
+
+impl<'db> OpaqueTypeStorage<'db> {
+    #[instrument(level = "debug")]
+    pub(crate) fn remove(&mut self, key: OpaqueTypeKey<'db>, prev: Option<OpaqueHiddenType<'db>>) {
+        if let Some(prev) = prev {
+            *self.opaque_types.get_mut(&key).unwrap() = prev;
+        } else {
+            // FIXME(#120456) - is `swap_remove` correct?
+            match self.opaque_types.swap_remove(&key) {
+                None => {
+                    panic!("reverted opaque type inference that was never registered: {key:?}")
+                }
+                Some(_) => {}
+            }
+        }
+    }
+
+    pub(crate) fn pop_duplicate_entry(&mut self) {
+        let entry = self.duplicate_entries.pop();
+        assert!(entry.is_some());
+    }
+
+    pub fn is_empty(&self) -> bool {
+        let OpaqueTypeStorage { opaque_types, duplicate_entries } = self;
+        opaque_types.is_empty() && duplicate_entries.is_empty()
+    }
+
+    pub(crate) fn take_opaque_types(
+        &mut self,
+    ) -> impl Iterator<Item = (OpaqueTypeKey<'db>, OpaqueHiddenType<'db>)> {
+        let OpaqueTypeStorage { opaque_types, duplicate_entries } = self;
+        std::mem::take(opaque_types).into_iter().chain(std::mem::take(duplicate_entries))
+    }
+
+    pub fn num_entries(&self) -> OpaqueTypeStorageEntries {
+        OpaqueTypeStorageEntries {
+            opaque_types: self.opaque_types.len(),
+            duplicate_entries: self.duplicate_entries.len(),
+        }
+    }
+
+    pub fn opaque_types_added_since(
+        &self,
+        prev_entries: OpaqueTypeStorageEntries,
+    ) -> impl Iterator<Item = (OpaqueTypeKey<'db>, OpaqueHiddenType<'db>)> {
+        self.opaque_types
+            .iter()
+            .skip(prev_entries.opaque_types)
+            .map(|(k, v)| (*k, *v))
+            .chain(self.duplicate_entries.iter().skip(prev_entries.duplicate_entries).copied())
+    }
+
+    /// Only returns the opaque types from the lookup table. These are used
+    /// when normalizing opaque types and have a unique key.
+    ///
+    /// Outside of canonicalization one should generally use `iter_opaque_types`
+    /// to also consider duplicate entries.
+    pub fn iter_lookup_table(
+        &self,
+    ) -> impl Iterator<Item = (OpaqueTypeKey<'db>, OpaqueHiddenType<'db>)> {
+        self.opaque_types.iter().map(|(k, v)| (*k, *v))
+    }
+
+    /// Only returns the opaque types which are stored in `duplicate_entries`.
+    ///
+    /// These have to considered when checking all opaque type uses but are e.g.
+    /// irrelevant for canonical inputs as nested queries never meaningfully
+    /// accesses them.
+    pub fn iter_duplicate_entries(
+        &self,
+    ) -> impl Iterator<Item = (OpaqueTypeKey<'db>, OpaqueHiddenType<'db>)> {
+        self.duplicate_entries.iter().copied()
+    }
+
+    pub fn iter_opaque_types(
+        &self,
+    ) -> impl Iterator<Item = (OpaqueTypeKey<'db>, OpaqueHiddenType<'db>)> {
+        let OpaqueTypeStorage { opaque_types, duplicate_entries } = self;
+        opaque_types.iter().map(|(k, v)| (*k, *v)).chain(duplicate_entries.iter().copied())
+    }
+
+    #[inline]
+    pub(crate) fn with_log<'a>(
+        &'a mut self,
+        undo_log: &'a mut InferCtxtUndoLogs<'db>,
+    ) -> OpaqueTypeTable<'a, 'db> {
+        OpaqueTypeTable { storage: self, undo_log }
+    }
+}
+
+impl<'db> Drop for OpaqueTypeStorage<'db> {
+    fn drop(&mut self) {
+        if !self.opaque_types.is_empty() {
+            panic!("{:?}", self.opaque_types)
+        }
+    }
+}
+
+pub(crate) struct OpaqueTypeTable<'a, 'db> {
+    storage: &'a mut OpaqueTypeStorage<'db>,
+
+    undo_log: &'a mut InferCtxtUndoLogs<'db>,
+}
+impl<'db> Deref for OpaqueTypeTable<'_, 'db> {
+    type Target = OpaqueTypeStorage<'db>;
+    fn deref(&self) -> &Self::Target {
+        self.storage
+    }
+}
+
+impl<'a, 'db> OpaqueTypeTable<'a, 'db> {
+    #[instrument(skip(self), level = "debug")]
+    pub fn register(
+        &mut self,
+        key: OpaqueTypeKey<'db>,
+        hidden_type: OpaqueHiddenType<'db>,
+    ) -> Option<Ty<'db>> {
+        if let Some(entry) = self.storage.opaque_types.get_mut(&key) {
+            let prev = std::mem::replace(entry, hidden_type);
+            self.undo_log.push(UndoLog::OpaqueTypes(key, Some(prev)));
+            return Some(prev.ty);
+        }
+        self.storage.opaque_types.insert(key, hidden_type);
+        self.undo_log.push(UndoLog::OpaqueTypes(key, None));
+        None
+    }
+
+    pub fn add_duplicate(&mut self, key: OpaqueTypeKey<'db>, hidden_type: OpaqueHiddenType<'db>) {
+        self.storage.duplicate_entries.push((key, hidden_type));
+        self.undo_log.push(UndoLog::DuplicateOpaqueType);
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/region_constraints/mod.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/region_constraints/mod.rs
new file mode 100644
index 0000000000000..50549694c3f23
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/region_constraints/mod.rs
@@ -0,0 +1,640 @@
+//! See `README.md`.
+
+use std::ops::Range;
+use std::sync::Arc;
+use std::{cmp, fmt, mem};
+
+use ena::undo_log::{Rollback, UndoLogs};
+use ena::unify as ut;
+use rustc_hash::FxHashMap;
+use rustc_index::IndexVec;
+use rustc_type_ir::inherent::IntoKind;
+use rustc_type_ir::{RegionKind, RegionVid, UniverseIndex};
+use tracing::{debug, instrument};
+
+use self::CombineMapType::*;
+use self::UndoLog::*;
+use super::MemberConstraint;
+use super::unify_key::RegionVidKey;
+use crate::next_solver::infer::snapshot::undo_log::{InferCtxtUndoLogs, Snapshot};
+use crate::next_solver::infer::unify_key::RegionVariableValue;
+use crate::next_solver::{
+    AliasTy, Binder, DbInterner, OpaqueTypeKey, ParamTy, PlaceholderTy, Region, Ty,
+};
+
+#[derive(Clone, Default)]
+pub struct RegionConstraintStorage<'db> {
+    /// For each `RegionVid`, the corresponding `RegionVariableOrigin`.
+    pub(super) var_infos: IndexVec<RegionVid, RegionVariableInfo>,
+
+    pub(super) data: RegionConstraintData<'db>,
+
+    /// For a given pair of regions (R1, R2), maps to a region R3 that
+    /// is designated as their LUB (edges R1 <= R3 and R2 <= R3
+    /// exist). This prevents us from making many such regions.
+    lubs: CombineMap<'db>,
+
+    /// For a given pair of regions (R1, R2), maps to a region R3 that
+    /// is designated as their GLB (edges R3 <= R1 and R3 <= R2
+    /// exist). This prevents us from making many such regions.
+    glbs: CombineMap<'db>,
+
+    /// When we add a R1 == R2 constraint, we currently add (a) edges
+    /// R1 <= R2 and R2 <= R1 and (b) we unify the two regions in this
+    /// table. You can then call `opportunistic_resolve_var` early
+    /// which will map R1 and R2 to some common region (i.e., either
+    /// R1 or R2). This is important when fulfillment, dropck and other such
+    /// code is iterating to a fixed point, because otherwise we sometimes
+    /// would wind up with a fresh stream of region variables that have been
+    /// equated but appear distinct.
+    pub(super) unification_table: ut::UnificationTableStorage<RegionVidKey<'db>>,
+
+    /// a flag set to true when we perform any unifications; this is used
+    /// to micro-optimize `take_and_reset_data`
+    any_unifications: bool,
+}
+
+pub struct RegionConstraintCollector<'db, 'a> {
+    storage: &'a mut RegionConstraintStorage<'db>,
+    undo_log: &'a mut InferCtxtUndoLogs<'db>,
+}
+
+pub type VarInfos = IndexVec<RegionVid, RegionVariableInfo>;
+
+/// The full set of region constraints gathered up by the collector.
+/// Describes constraints between the region variables and other
+/// regions, as well as other conditions that must be verified, or
+/// assumptions that can be made.
+#[derive(Debug, Default, Clone)]
+pub struct RegionConstraintData<'db> {
+    /// Constraints of the form `A <= B`, where either `A` or `B` can
+    /// be a region variable (or neither, as it happens).
+    pub constraints: Vec<Constraint<'db>>,
+
+    /// Constraints of the form `R0 member of [R1, ..., Rn]`, meaning that
+    /// `R0` must be equal to one of the regions `R1..Rn`. These occur
+    /// with `impl Trait` quite frequently.
+    pub member_constraints: Vec<MemberConstraint<'db>>,
+
+    /// A "verify" is something that we need to verify after inference
+    /// is done, but which does not directly affect inference in any
+    /// way.
+    ///
+    /// An example is a `A <= B` where neither `A` nor `B` are
+    /// inference variables.
+    pub verifys: Vec<Verify<'db>>,
+}
+
+/// Represents a constraint that influences the inference process.
+#[derive(Clone, PartialEq, Eq, Debug, Hash)]
+pub enum Constraint<'db> {
+    /// A region variable is a subregion of another.
+    VarSubVar(RegionVid, RegionVid),
+
+    /// A concrete region is a subregion of region variable.
+    RegSubVar(Region<'db>, RegionVid),
+
+    /// A region variable is a subregion of a concrete region. This does not
+    /// directly affect inference, but instead is checked after
+    /// inference is complete.
+    VarSubReg(RegionVid, Region<'db>),
+
+    /// A constraint where neither side is a variable. This does not
+    /// directly affect inference, but instead is checked after
+    /// inference is complete.
+    RegSubReg(Region<'db>, Region<'db>),
+}
+
+impl<'db> Constraint<'db> {
+    pub fn involves_placeholders(&self) -> bool {
+        match self {
+            Constraint::VarSubVar(_, _) => false,
+            Constraint::VarSubReg(_, r) | Constraint::RegSubVar(r, _) => r.is_placeholder(),
+            Constraint::RegSubReg(r, s) => r.is_placeholder() || s.is_placeholder(),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Verify<'db> {
+    pub kind: GenericKind<'db>,
+    pub region: Region<'db>,
+    pub bound: VerifyBound<'db>,
+}
+
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub enum GenericKind<'db> {
+    Param(ParamTy),
+    Placeholder(PlaceholderTy),
+    Alias(AliasTy<'db>),
+}
+
+/// Describes the things that some `GenericKind` value `G` is known to
+/// outlive. Each variant of `VerifyBound` can be thought of as a
+/// function:
+/// ```ignore (pseudo-rust)
+/// fn(min: Region) -> bool { .. }
+/// ```
+/// where `true` means that the region `min` meets that `G: min`.
+/// (False means nothing.)
+///
+/// So, for example, if we have the type `T` and we have in scope that
+/// `T: 'a` and `T: 'b`, then the verify bound might be:
+/// ```ignore (pseudo-rust)
+/// fn(min: Region) -> bool {
+///    ('a: min) || ('b: min)
+/// }
+/// ```
+/// This is described with an `AnyRegion('a, 'b)` node.
+#[derive(Debug, Clone)]
+pub enum VerifyBound<'db> {
+    /// See [`VerifyIfEq`] docs
+    IfEq(Binder<'db, VerifyIfEq<'db>>),
+
+    /// Given a region `R`, expands to the function:
+    ///
+    /// ```ignore (pseudo-rust)
+    /// fn(min) -> bool {
+    ///     R: min
+    /// }
+    /// ```
+    ///
+    /// This is used when we can establish that `G: R` -- therefore,
+    /// if `R: min`, then by transitivity `G: min`.
+    OutlivedBy(Region<'db>),
+
+    /// Given a region `R`, true if it is `'empty`.
+    IsEmpty,
+
+    /// Given a set of bounds `B`, expands to the function:
+    ///
+    /// ```ignore (pseudo-rust)
+    /// fn(min) -> bool {
+    ///     exists (b in B) { b(min) }
+    /// }
+    /// ```
+    ///
+    /// In other words, if we meet some bound in `B`, that suffices.
+    /// This is used when all the bounds in `B` are known to apply to `G`.
+    AnyBound(Vec<VerifyBound<'db>>),
+
+    /// Given a set of bounds `B`, expands to the function:
+    ///
+    /// ```ignore (pseudo-rust)
+    /// fn(min) -> bool {
+    ///     forall (b in B) { b(min) }
+    /// }
+    /// ```
+    ///
+    /// In other words, if we meet *all* bounds in `B`, that suffices.
+    /// This is used when *some* bound in `B` is known to suffice, but
+    /// we don't know which.
+    AllBounds(Vec<VerifyBound<'db>>),
+}
+
+/// This is a "conditional bound" that checks the result of inference
+/// and supplies a bound if it ended up being relevant. It's used in situations
+/// like this:
+///
+/// ```rust,ignore (pseudo-Rust)
+/// fn foo<'a, 'b, T: SomeTrait<'a>>
+/// where
+///    <T as SomeTrait<'a>>::Item: 'b
+/// ```
+///
+/// If we have an obligation like `<T as SomeTrait<'?x>>::Item: 'c`, then
+/// we don't know yet whether it suffices to show that `'b: 'c`. If `'?x` winds
+/// up being equal to `'a`, then the where-clauses on function applies, and
+/// in that case we can show `'b: 'c`. But if `'?x` winds up being something
+/// else, the bound isn't relevant.
+///
+/// In the [`VerifyBound`], this struct is enclosed in `Binder` to account
+/// for cases like
+///
+/// ```rust,ignore (pseudo-Rust)
+/// where for<'a> <T as SomeTrait<'a>::Item: 'a
+/// ```
+///
+/// The idea is that we have to find some instantiation of `'a` that can
+/// make `<T as SomeTrait<'a>>::Item` equal to the final value of `G`,
+/// the generic we are checking.
+///
+/// ```ignore (pseudo-rust)
+/// fn(min) -> bool {
+///     exists<'a> {
+///         if G == K {
+///             B(min)
+///         } else {
+///             false
+///         }
+///     }
+/// }
+/// ```
+#[derive(Debug, Clone)]
+pub struct VerifyIfEq<'db> {
+    /// Type which must match the generic `G`
+    pub ty: Ty<'db>,
+
+    /// Bound that applies if `ty` is equal.
+    pub bound: Region<'db>,
+}
+
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub(crate) struct TwoRegions<'db> {
+    a: Region<'db>,
+    b: Region<'db>,
+}
+
+#[derive(Clone, PartialEq)]
+pub(crate) enum UndoLog<'db> {
+    /// We added `RegionVid`.
+    AddVar(RegionVid),
+
+    /// We added the given `constraint`.
+    AddConstraint(usize),
+
+    /// We added the given `verify`.
+    AddVerify(usize),
+
+    /// We added a GLB/LUB "combination variable".
+    AddCombination(CombineMapType, TwoRegions<'db>),
+}
+
+#[derive(Clone, PartialEq)]
+pub(crate) enum CombineMapType {
+    Lub,
+    Glb,
+}
+
+type CombineMap<'db> = FxHashMap<TwoRegions<'db>, RegionVid>;
+
+#[derive(Debug, Clone)]
+pub struct RegionVariableInfo {
+    // FIXME: This is only necessary for `fn take_and_reset_data` and
+    // `lexical_region_resolve`. We should rework `lexical_region_resolve`
+    // in the near/medium future anyways and could move the unverse info
+    // for `fn take_and_reset_data` into a separate table which is
+    // only populated when needed.
+    //
+    // For both of these cases it is fine that this can diverge from the
+    // actual universe of the variable, which is directly stored in the
+    // unification table for unknown region variables. At some point we could
+    // stop emitting bidirectional outlives constraints if equate succeeds.
+    // This would be currently unsound as it would cause us to drop the universe
+    // changes in `lexical_region_resolve`.
+    pub universe: UniverseIndex,
+}
+
+pub(crate) struct RegionSnapshot {
+    any_unifications: bool,
+}
+
+impl<'db> RegionConstraintStorage<'db> {
+    #[inline]
+    pub(crate) fn with_log<'a>(
+        &'a mut self,
+        undo_log: &'a mut InferCtxtUndoLogs<'db>,
+    ) -> RegionConstraintCollector<'db, 'a> {
+        RegionConstraintCollector { storage: self, undo_log }
+    }
+}
+
+impl<'db> RegionConstraintCollector<'db, '_> {
+    pub fn num_region_vars(&self) -> usize {
+        self.storage.var_infos.len()
+    }
+
+    pub fn region_constraint_data(&self) -> &RegionConstraintData<'db> {
+        &self.storage.data
+    }
+
+    /// Takes (and clears) the current set of constraints. Note that
+    /// the set of variables remains intact, but all relationships
+    /// between them are reset. This is used during NLL checking to
+    /// grab the set of constraints that arose from a particular
+    /// operation.
+    ///
+    /// We don't want to leak relationships between variables between
+    /// points because just because (say) `r1 == r2` was true at some
+    /// point P in the graph doesn't imply that it will be true at
+    /// some other point Q, in NLL.
+    ///
+    /// Not legal during a snapshot.
+    pub fn take_and_reset_data(&mut self) -> RegionConstraintData<'db> {
+        assert!(!UndoLogs::<UndoLog<'db>>::in_snapshot(&self.undo_log));
+
+        // If you add a new field to `RegionConstraintCollector`, you
+        // should think carefully about whether it needs to be cleared
+        // or updated in some way.
+        let RegionConstraintStorage {
+            var_infos: _,
+            data,
+            lubs,
+            glbs,
+            unification_table: _,
+            any_unifications,
+        } = self.storage;
+
+        // Clear the tables of (lubs, glbs), so that we will create
+        // fresh regions if we do a LUB operation. As it happens,
+        // LUB/GLB are not performed by the MIR type-checker, which is
+        // the one that uses this method, but it's good to be correct.
+        lubs.clear();
+        glbs.clear();
+
+        let data = mem::take(data);
+
+        // Clear all unifications and recreate the variables a "now
+        // un-unified" state. Note that when we unify `a` and `b`, we
+        // also insert `a <= b` and a `b <= a` edges, so the
+        // `RegionConstraintData` contains the relationship here.
+        if *any_unifications {
+            *any_unifications = false;
+            // Manually inlined `self.unification_table_mut()` as `self` is used in the closure.
+            ut::UnificationTable::with_log(&mut self.storage.unification_table, &mut self.undo_log)
+                .reset_unifications(|key| RegionVariableValue::Unknown {
+                    universe: self.storage.var_infos[key.vid].universe,
+                });
+        }
+
+        data
+    }
+
+    pub fn data(&self) -> &RegionConstraintData<'db> {
+        &self.storage.data
+    }
+
+    pub(super) fn start_snapshot(&self) -> RegionSnapshot {
+        debug!("RegionConstraintCollector: start_snapshot");
+        RegionSnapshot { any_unifications: self.storage.any_unifications }
+    }
+
+    pub(super) fn rollback_to(&mut self, snapshot: RegionSnapshot) {
+        debug!("RegionConstraintCollector: rollback_to({:?})", snapshot);
+        self.storage.any_unifications = snapshot.any_unifications;
+    }
+
+    pub(super) fn new_region_var(&mut self, universe: UniverseIndex) -> RegionVid {
+        let vid = self.storage.var_infos.push(RegionVariableInfo { universe });
+
+        let u_vid = self.unification_table_mut().new_key(RegionVariableValue::Unknown { universe });
+        assert_eq!(vid, u_vid.vid);
+        self.undo_log.push(AddVar(vid));
+        debug!("created new region variable {:?} in {:?}", vid, universe);
+        vid
+    }
+
+    fn add_constraint(&mut self, constraint: Constraint<'db>) {
+        // cannot add constraints once regions are resolved
+        debug!("RegionConstraintCollector: add_constraint({:?})", constraint);
+
+        let index = self.storage.data.constraints.len();
+        self.storage.data.constraints.push(constraint);
+        self.undo_log.push(AddConstraint(index));
+    }
+
+    pub(super) fn make_eqregion(&mut self, a: Region<'db>, b: Region<'db>) {
+        if a != b {
+            // Eventually, it would be nice to add direct support for
+            // equating regions.
+            self.make_subregion(a, b);
+            self.make_subregion(b, a);
+
+            match (a.kind(), b.kind()) {
+                (RegionKind::ReVar(a), RegionKind::ReVar(b)) => {
+                    debug!("make_eqregion: unifying {:?} with {:?}", a, b);
+                    if self.unification_table_mut().unify_var_var(a, b).is_ok() {
+                        self.storage.any_unifications = true;
+                    }
+                }
+                (RegionKind::ReVar(vid), _) => {
+                    debug!("make_eqregion: unifying {:?} with {:?}", vid, b);
+                    if self
+                        .unification_table_mut()
+                        .unify_var_value(vid, RegionVariableValue::Known { value: b })
+                        .is_ok()
+                    {
+                        self.storage.any_unifications = true;
+                    };
+                }
+                (_, RegionKind::ReVar(vid)) => {
+                    debug!("make_eqregion: unifying {:?} with {:?}", a, vid);
+                    if self
+                        .unification_table_mut()
+                        .unify_var_value(vid, RegionVariableValue::Known { value: a })
+                        .is_ok()
+                    {
+                        self.storage.any_unifications = true;
+                    };
+                }
+                (_, _) => {}
+            }
+        }
+    }
+
+    #[instrument(skip(self), level = "debug")]
+    pub(super) fn make_subregion(&mut self, sub: Region<'db>, sup: Region<'db>) {
+        // cannot add constraints once regions are resolved
+
+        match (sub.kind(), sup.kind()) {
+            (RegionKind::ReBound(..), _) | (_, RegionKind::ReBound(..)) => {
+                panic!("cannot relate bound region: {sub:?} <= {sup:?}");
+            }
+            (_, RegionKind::ReStatic) => {
+                // all regions are subregions of static, so we can ignore this
+            }
+            (RegionKind::ReVar(sub_id), RegionKind::ReVar(sup_id)) => {
+                self.add_constraint(Constraint::VarSubVar(sub_id, sup_id));
+            }
+            (_, RegionKind::ReVar(sup_id)) => {
+                self.add_constraint(Constraint::RegSubVar(sub, sup_id));
+            }
+            (RegionKind::ReVar(sub_id), _) => {
+                self.add_constraint(Constraint::VarSubReg(sub_id, sup));
+            }
+            _ => {
+                self.add_constraint(Constraint::RegSubReg(sub, sup));
+            }
+        }
+    }
+
+    /// Resolves a region var to its value in the unification table, if it exists.
+    /// Otherwise, it is resolved to the root `ReVar` in the table.
+    pub fn opportunistic_resolve_var(
+        &mut self,
+        cx: DbInterner<'db>,
+        vid: RegionVid,
+    ) -> Region<'db> {
+        let mut ut = self.unification_table_mut();
+        let root_vid = ut.find(vid).vid;
+        match ut.probe_value(root_vid) {
+            RegionVariableValue::Known { value } => value,
+            RegionVariableValue::Unknown { .. } => Region::new_var(cx, root_vid),
+        }
+    }
+
+    pub fn probe_value(&mut self, vid: RegionVid) -> Result<Region<'db>, UniverseIndex> {
+        match self.unification_table_mut().probe_value(vid) {
+            RegionVariableValue::Known { value } => Ok(value),
+            RegionVariableValue::Unknown { universe } => Err(universe),
+        }
+    }
+
+    fn combine_map(&mut self, t: CombineMapType) -> &mut CombineMap<'db> {
+        match t {
+            Glb => &mut self.storage.glbs,
+            Lub => &mut self.storage.lubs,
+        }
+    }
+
+    fn combine_vars(
+        &mut self,
+        cx: DbInterner<'db>,
+        t: CombineMapType,
+        a: Region<'db>,
+        b: Region<'db>,
+    ) -> Region<'db> {
+        let vars = TwoRegions { a, b };
+        if let Some(c) = self.combine_map(t.clone()).get(&vars) {
+            return Region::new_var(cx, *c);
+        }
+        let a_universe = self.universe(a);
+        let b_universe = self.universe(b);
+        let c_universe = cmp::max(a_universe, b_universe);
+        let c = self.new_region_var(c_universe);
+        self.combine_map(t.clone()).insert(vars.clone(), c);
+        self.undo_log.push(AddCombination(t.clone(), vars));
+        let new_r = Region::new_var(cx, c);
+        for old_r in [a, b] {
+            match t {
+                Glb => self.make_subregion(new_r, old_r),
+                Lub => self.make_subregion(old_r, new_r),
+            }
+        }
+        debug!("combine_vars() c={:?}", c);
+        new_r
+    }
+
+    pub fn universe(&mut self, region: Region<'db>) -> UniverseIndex {
+        match region.kind() {
+            RegionKind::ReStatic
+            | RegionKind::ReErased
+            | RegionKind::ReLateParam(..)
+            | RegionKind::ReEarlyParam(..)
+            | RegionKind::ReError(_) => UniverseIndex::ROOT,
+            RegionKind::RePlaceholder(placeholder) => placeholder.universe,
+            RegionKind::ReVar(vid) => match self.probe_value(vid) {
+                Ok(value) => self.universe(value),
+                Err(universe) => universe,
+            },
+            RegionKind::ReBound(..) => panic!("universe(): encountered bound region {region:?}"),
+        }
+    }
+
+    #[inline]
+    fn unification_table_mut(&mut self) -> super::UnificationTable<'_, 'db, RegionVidKey<'db>> {
+        ut::UnificationTable::with_log(&mut self.storage.unification_table, self.undo_log)
+    }
+}
+
+impl fmt::Debug for RegionSnapshot {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "RegionSnapshot")
+    }
+}
+
+impl<'db> fmt::Debug for GenericKind<'db> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            GenericKind::Param(ref p) => write!(f, "{p:?}"),
+            GenericKind::Placeholder(ref p) => write!(f, "{p:?}"),
+            GenericKind::Alias(ref p) => write!(f, "{p:?}"),
+        }
+    }
+}
+
+impl<'db> fmt::Display for GenericKind<'db> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            GenericKind::Param(ref p) => write!(f, "{p:?}"),
+            GenericKind::Placeholder(ref p) => write!(f, "{p:?}"),
+            GenericKind::Alias(ref p) => write!(f, "{p}"),
+        }
+    }
+}
+
+impl<'db> GenericKind<'db> {
+    pub fn to_ty(&self, interner: DbInterner<'db>) -> Ty<'db> {
+        match *self {
+            GenericKind::Param(ref p) => (*p).to_ty(interner),
+            GenericKind::Placeholder(ref p) => Ty::new_placeholder(interner, *p),
+            GenericKind::Alias(ref p) => (*p).to_ty(interner),
+        }
+    }
+}
+
+impl<'db> VerifyBound<'db> {
+    pub fn must_hold(&self) -> bool {
+        match self {
+            VerifyBound::IfEq(..) => false,
+            VerifyBound::OutlivedBy(re) => re.is_static(),
+            VerifyBound::IsEmpty => false,
+            VerifyBound::AnyBound(bs) => bs.iter().any(|b| b.must_hold()),
+            VerifyBound::AllBounds(bs) => bs.iter().all(|b| b.must_hold()),
+        }
+    }
+
+    pub fn cannot_hold(&self) -> bool {
+        match self {
+            VerifyBound::IfEq(..) => false,
+            VerifyBound::IsEmpty => false,
+            VerifyBound::OutlivedBy(_) => false,
+            VerifyBound::AnyBound(bs) => bs.iter().all(|b| b.cannot_hold()),
+            VerifyBound::AllBounds(bs) => bs.iter().any(|b| b.cannot_hold()),
+        }
+    }
+
+    pub fn or(self, vb: VerifyBound<'db>) -> VerifyBound<'db> {
+        if self.must_hold() || vb.cannot_hold() {
+            self
+        } else if self.cannot_hold() || vb.must_hold() {
+            vb
+        } else {
+            VerifyBound::AnyBound(vec![self, vb])
+        }
+    }
+}
+
+impl<'db> RegionConstraintData<'db> {
+    /// Returns `true` if this region constraint data contains no constraints, and `false`
+    /// otherwise.
+    pub fn is_empty(&self) -> bool {
+        let RegionConstraintData { constraints, member_constraints, verifys } = self;
+        constraints.is_empty() && member_constraints.is_empty() && verifys.is_empty()
+    }
+}
+
+impl<'db> Rollback<UndoLog<'db>> for RegionConstraintStorage<'db> {
+    fn reverse(&mut self, undo: UndoLog<'db>) {
+        match undo {
+            AddVar(vid) => {
+                self.var_infos.pop().unwrap();
+                assert_eq!(self.var_infos.len(), vid.index());
+            }
+            AddConstraint(index) => {
+                self.data.constraints.pop().unwrap();
+                assert_eq!(self.data.constraints.len(), index);
+            }
+            AddVerify(index) => {
+                self.data.verifys.pop();
+                assert_eq!(self.data.verifys.len(), index);
+            }
+            AddCombination(Glb, ref regions) => {
+                self.glbs.remove(regions);
+            }
+            AddCombination(Lub, ref regions) => {
+                self.lubs.remove(regions);
+            }
+        }
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/relate/generalize.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/relate/generalize.rs
new file mode 100644
index 0000000000000..de336c69b3180
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/relate/generalize.rs
@@ -0,0 +1,720 @@
+//! Type generation code.
+
+use std::mem;
+
+use rustc_hash::FxHashMap;
+use rustc_type_ir::error::TypeError;
+use rustc_type_ir::inherent::{Const as _, IntoKind, Ty as _};
+use rustc_type_ir::relate::VarianceDiagInfo;
+use rustc_type_ir::{
+    AliasRelationDirection, AliasTyKind, ConstVid, InferConst, InferCtxtLike, InferTy, RegionKind,
+    TermKind, TyVid, UniverseIndex, Variance,
+};
+use rustc_type_ir::{Interner, TypeVisitable, TypeVisitableExt};
+use tracing::{debug, instrument, warn};
+
+use super::{
+    PredicateEmittingRelation, Relate, RelateResult, StructurallyRelateAliases, TypeRelation,
+};
+use crate::next_solver::infer::type_variable::TypeVariableValue;
+use crate::next_solver::infer::unify_key::ConstVariableValue;
+use crate::next_solver::infer::{InferCtxt, relate};
+use crate::next_solver::util::MaxUniverse;
+use crate::next_solver::{
+    AliasTy, Binder, ClauseKind, Const, ConstKind, DbInterner, GenericArgs, PredicateKind,
+    ProjectionPredicate, Region, SolverDefId, Term, TermVid, Ty, TyKind, TypingMode,
+    UnevaluatedConst,
+};
+
+impl<'db> InferCtxt<'db> {
+    /// The idea is that we should ensure that the type variable `target_vid`
+    /// is equal to, a subtype of, or a supertype of `source_ty`.
+    ///
+    /// For this, we will instantiate `target_vid` with a *generalized* version
+    /// of `source_ty`. Generalization introduces other inference variables wherever
+    /// subtyping could occur. This also does the occurs checks, detecting whether
+    /// instantiating `target_vid` would result in a cyclic type. We eagerly error
+    /// in this case.
+    ///
+    /// This is *not* expected to be used anywhere except for an implementation of
+    /// `TypeRelation`. Do not use this, and instead please use `At::eq`, for all
+    /// other usecases (i.e. setting the value of a type var).
+    #[instrument(level = "debug", skip(self, relation))]
+    pub fn instantiate_ty_var<R: PredicateEmittingRelation<InferCtxt<'db>>>(
+        &self,
+        relation: &mut R,
+        target_is_expected: bool,
+        target_vid: TyVid,
+        instantiation_variance: Variance,
+        source_ty: Ty<'db>,
+    ) -> RelateResult<'db, ()> {
+        debug_assert!(self.inner.borrow_mut().type_variables().probe(target_vid).is_unknown());
+
+        // Generalize `source_ty` depending on the current variance. As an example, assume
+        // `?target <: &'x ?1`, where `'x` is some free region and `?1` is an inference
+        // variable.
+        //
+        // Then the `generalized_ty` would be `&'?2 ?3`, where `'?2` and `?3` are fresh
+        // region/type inference variables.
+        //
+        // We then relate `generalized_ty <: source_ty`, adding constraints like `'x: '?2` and
+        // `?1 <: ?3`.
+        let Generalization { value_may_be_infer: generalized_ty, has_unconstrained_ty_var } = self
+            .generalize(
+                relation.structurally_relate_aliases(),
+                target_vid,
+                instantiation_variance,
+                source_ty,
+            )?;
+
+        // Constrain `b_vid` to the generalized type `generalized_ty`.
+        if let TyKind::Infer(InferTy::TyVar(generalized_vid)) = generalized_ty.kind() {
+            self.inner.borrow_mut().type_variables().equate(target_vid, generalized_vid);
+        } else {
+            self.inner.borrow_mut().type_variables().instantiate(target_vid, generalized_ty);
+        }
+
+        // See the comment on `Generalization::has_unconstrained_ty_var`.
+        if has_unconstrained_ty_var {
+            relation.register_predicates([ClauseKind::WellFormed(generalized_ty.into())]);
+        }
+
+        // Finally, relate `generalized_ty` to `source_ty`, as described in previous comment.
+        //
+        // FIXME(#16847): This code is non-ideal because all these subtype
+        // relations wind up attributed to the same spans. We need
+        // to associate causes/spans with each of the relations in
+        // the stack to get this right.
+        if generalized_ty.is_ty_var() {
+            // This happens for cases like `<?0 as Trait>::Assoc == ?0`.
+            // We can't instantiate `?0` here as that would result in a
+            // cyclic type. We instead delay the unification in case
+            // the alias can be normalized to something which does not
+            // mention `?0`.
+            let (lhs, rhs, direction) = match instantiation_variance {
+                Variance::Invariant => {
+                    (generalized_ty.into(), source_ty.into(), AliasRelationDirection::Equate)
+                }
+                Variance::Covariant => {
+                    (generalized_ty.into(), source_ty.into(), AliasRelationDirection::Subtype)
+                }
+                Variance::Contravariant => {
+                    (source_ty.into(), generalized_ty.into(), AliasRelationDirection::Subtype)
+                }
+                Variance::Bivariant => unreachable!("bivariant generalization"),
+            };
+
+            relation.register_predicates([PredicateKind::AliasRelate(lhs, rhs, direction)]);
+        } else {
+            // NOTE: The `instantiation_variance` is not the same variance as
+            // used by the relation. When instantiating `b`, `target_is_expected`
+            // is flipped and the `instantiation_variance` is also flipped. To
+            // constrain the `generalized_ty` while using the original relation,
+            // we therefore only have to flip the arguments.
+            //
+            // ```ignore (not code)
+            // ?a rel B
+            // instantiate_ty_var(?a, B) # expected and variance not flipped
+            // B' rel B
+            // ```
+            // or
+            // ```ignore (not code)
+            // A rel ?b
+            // instantiate_ty_var(?b, A) # expected and variance flipped
+            // A rel A'
+            // ```
+            if target_is_expected {
+                relation.relate(generalized_ty, source_ty)?;
+            } else {
+                debug!("flip relation");
+                relation.relate(source_ty, generalized_ty)?;
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Instantiates the const variable `target_vid` with the given constant.
+    ///
+    /// This also tests if the given const `ct` contains an inference variable which was previously
+    /// unioned with `target_vid`. If this is the case, inferring `target_vid` to `ct`
+    /// would result in an infinite type as we continuously replace an inference variable
+    /// in `ct` with `ct` itself.
+    ///
+    /// This is especially important as unevaluated consts use their parents generics.
+    /// They therefore often contain unused args, making these errors far more likely.
+    ///
+    /// A good example of this is the following:
+    ///
+    /// ```compile_fail,E0308
+    /// #![feature(generic_const_exprs)]
+    ///
+    /// fn bind<const N: usize>(value: [u8; N]) -> [u8; 3 + 4] {
+    ///     todo!()
+    /// }
+    ///
+    /// fn main() {
+    ///     let mut arr = Default::default();
+    ///     arr = bind(arr);
+    /// }
+    /// ```
+    ///
+    /// Here `3 + 4` ends up as `ConstKind::Unevaluated` which uses the generics
+    /// of `fn bind` (meaning that its args contain `N`).
+    ///
+    /// `bind(arr)` now infers that the type of `arr` must be `[u8; N]`.
+    /// The assignment `arr = bind(arr)` now tries to equate `N` with `3 + 4`.
+    ///
+    /// As `3 + 4` contains `N` in its args, this must not succeed.
+    ///
+    /// See `tests/ui/const-generics/occurs-check/` for more examples where this is relevant.
+    #[instrument(level = "debug", skip(self, relation))]
+    pub(crate) fn instantiate_const_var<R: PredicateEmittingRelation<InferCtxt<'db>>>(
+        &self,
+        relation: &mut R,
+        target_is_expected: bool,
+        target_vid: ConstVid,
+        source_ct: Const<'db>,
+    ) -> RelateResult<'db, ()> {
+        // FIXME(generic_const_exprs): Occurs check failures for unevaluated
+        // constants and generic expressions are not yet handled correctly.
+        let Generalization { value_may_be_infer: generalized_ct, has_unconstrained_ty_var } = self
+            .generalize(
+                relation.structurally_relate_aliases(),
+                target_vid,
+                Variance::Invariant,
+                source_ct,
+            )?;
+
+        debug_assert!(!generalized_ct.is_ct_infer());
+        if has_unconstrained_ty_var {
+            panic!("unconstrained ty var when generalizing `{source_ct:?}`");
+        }
+
+        self.inner
+            .borrow_mut()
+            .const_unification_table()
+            .union_value(target_vid, ConstVariableValue::Known { value: generalized_ct });
+
+        // Make sure that the order is correct when relating the
+        // generalized const and the source.
+        if target_is_expected {
+            relation.relate_with_variance(
+                Variance::Invariant,
+                VarianceDiagInfo::default(),
+                generalized_ct,
+                source_ct,
+            )?;
+        } else {
+            relation.relate_with_variance(
+                Variance::Invariant,
+                VarianceDiagInfo::default(),
+                source_ct,
+                generalized_ct,
+            )?;
+        }
+
+        Ok(())
+    }
+
+    /// Attempts to generalize `source_term` for the type variable `target_vid`.
+    /// This checks for cycles -- that is, whether `source_term` references `target_vid`.
+    fn generalize<T: Into<Term<'db>> + Relate<DbInterner<'db>>>(
+        &self,
+        structurally_relate_aliases: StructurallyRelateAliases,
+        target_vid: impl Into<TermVid>,
+        ambient_variance: Variance,
+        source_term: T,
+    ) -> RelateResult<'db, Generalization<T>> {
+        assert!(!source_term.clone().has_escaping_bound_vars());
+        let (for_universe, root_vid) = match target_vid.into() {
+            TermVid::Ty(ty_vid) => {
+                (self.probe_ty_var(ty_vid).unwrap_err(), TermVid::Ty(self.root_var(ty_vid)))
+            }
+            TermVid::Const(ct_vid) => (
+                self.probe_const_var(ct_vid).unwrap_err(),
+                TermVid::Const(self.inner.borrow_mut().const_unification_table().find(ct_vid).vid),
+            ),
+        };
+
+        let mut generalizer = Generalizer {
+            infcx: self,
+            structurally_relate_aliases,
+            root_vid,
+            for_universe,
+            root_term: source_term.into(),
+            ambient_variance,
+            in_alias: false,
+            cache: Default::default(),
+            has_unconstrained_ty_var: false,
+        };
+
+        let value_may_be_infer = generalizer.relate(source_term, source_term)?;
+        let has_unconstrained_ty_var = generalizer.has_unconstrained_ty_var;
+        Ok(Generalization { value_may_be_infer, has_unconstrained_ty_var })
+    }
+}
+
+/// The "generalizer" is used when handling inference variables.
+///
+/// The basic strategy for handling a constraint like `?A <: B` is to
+/// apply a "generalization strategy" to the term `B` -- this replaces
+/// all the lifetimes in the term `B` with fresh inference variables.
+/// (You can read more about the strategy in this [blog post].)
+///
+/// As an example, if we had `?A <: &'x u32`, we would generalize `&'x
+/// u32` to `&'0 u32` where `'0` is a fresh variable. This becomes the
+/// value of `A`. Finally, we relate `&'0 u32 <: &'x u32`, which
+/// establishes `'0: 'x` as a constraint.
+///
+/// [blog post]: https://is.gd/0hKvIr
+struct Generalizer<'me, 'db> {
+    infcx: &'me InferCtxt<'db>,
+
+    /// Whether aliases should be related structurally. If not, we have to
+    /// be careful when generalizing aliases.
+    structurally_relate_aliases: StructurallyRelateAliases,
+
+    /// The vid of the type variable that is in the process of being
+    /// instantiated. If we find this within the value we are folding,
+    /// that means we would have created a cyclic value.
+    root_vid: TermVid,
+
+    /// The universe of the type variable that is in the process of being
+    /// instantiated. If we find anything that this universe cannot name,
+    /// we reject the relation.
+    for_universe: UniverseIndex,
+
+    /// The root term (const or type) we're generalizing. Used for cycle errors.
+    root_term: Term<'db>,
+
+    /// After we generalize this type, we are going to relate it to
+    /// some other type. What will be the variance at this point?
+    ambient_variance: Variance,
+
+    /// This is set once we're generalizing the arguments of an alias.
+    ///
+    /// This is necessary to correctly handle
+    /// `<T as Bar<<?0 as Foo>::Assoc>::Assoc == ?0`. This equality can
+    /// hold by either normalizing the outer or the inner associated type.
+    in_alias: bool,
+
+    cache: FxHashMap<(Ty<'db>, Variance, bool), Ty<'db>>,
+
+    /// See the field `has_unconstrained_ty_var` in `Generalization`.
+    has_unconstrained_ty_var: bool,
+}
+
+impl<'db> Generalizer<'_, 'db> {
+    /// Create an error that corresponds to the term kind in `root_term`
+    fn cyclic_term_error(&self) -> TypeError<DbInterner<'db>> {
+        match self.root_term.kind() {
+            TermKind::Ty(ty) => TypeError::CyclicTy(ty),
+            TermKind::Const(ct) => TypeError::CyclicConst(ct),
+        }
+    }
+
+    /// Create a new type variable in the universe of the target when
+    /// generalizing an alias. This has to set `has_unconstrained_ty_var`
+    /// if we're currently in a bivariant context.
+    fn next_ty_var_for_alias(&mut self) -> Ty<'db> {
+        self.has_unconstrained_ty_var |= self.ambient_variance == Variance::Bivariant;
+        self.infcx.next_ty_var_in_universe(self.for_universe)
+    }
+
+    /// An occurs check failure inside of an alias does not mean
+    /// that the types definitely don't unify. We may be able
+    /// to normalize the alias after all.
+    ///
+    /// We handle this by lazily equating the alias and generalizing
+    /// it to an inference variable. In the new solver, we always
+    /// generalize to an infer var unless the alias contains escaping
+    /// bound variables.
+    ///
+    /// Correctly handling aliases with escaping bound variables is
+    /// difficult and currently incomplete in two opposite ways:
+    /// - if we get an occurs check failure in the alias, replace it with a new infer var.
+    ///   This causes us to later emit an alias-relate goal and is incomplete in case the
+    ///   alias normalizes to type containing one of the bound variables.
+    /// - if the alias contains an inference variable not nameable by `for_universe`, we
+    ///   continue generalizing the alias. This ends up pulling down the universe of the
+    ///   inference variable and is incomplete in case the alias would normalize to a type
+    ///   which does not mention that inference variable.
+    fn generalize_alias_ty(
+        &mut self,
+        alias: AliasTy<'db>,
+    ) -> Result<Ty<'db>, TypeError<DbInterner<'db>>> {
+        // We do not eagerly replace aliases with inference variables if they have
+        // escaping bound vars, see the method comment for details. However, when we
+        // are inside of an alias with escaping bound vars replacing nested aliases
+        // with inference variables can cause incorrect ambiguity.
+        //
+        // cc trait-system-refactor-initiative#110
+        if self.infcx.next_trait_solver() && !alias.has_escaping_bound_vars() && !self.in_alias {
+            return Ok(self.next_ty_var_for_alias());
+        }
+
+        let is_nested_alias = mem::replace(&mut self.in_alias, true);
+        let result = match self.relate(alias, alias) {
+            Ok(alias) => Ok(alias.to_ty(self.cx())),
+            Err(e) => {
+                if is_nested_alias {
+                    return Err(e);
+                } else {
+                    let mut visitor = MaxUniverse::new();
+                    alias.visit_with(&mut visitor);
+                    let infer_replacement_is_complete =
+                        self.for_universe.can_name(visitor.max_universe())
+                            && !alias.has_escaping_bound_vars();
+                    if !infer_replacement_is_complete {
+                        warn!("may incompletely handle alias type: {alias:?}");
+                    }
+
+                    debug!("generalization failure in alias");
+                    Ok(self.next_ty_var_for_alias())
+                }
+            }
+        };
+        self.in_alias = is_nested_alias;
+        result
+    }
+}
+
+impl<'db> TypeRelation<DbInterner<'db>> for Generalizer<'_, 'db> {
+    fn cx(&self) -> DbInterner<'db> {
+        self.infcx.interner
+    }
+
+    fn relate_item_args(
+        &mut self,
+        item_def_id: SolverDefId,
+        a_arg: GenericArgs<'db>,
+        b_arg: GenericArgs<'db>,
+    ) -> RelateResult<'db, GenericArgs<'db>> {
+        if self.ambient_variance == Variance::Invariant {
+            // Avoid fetching the variance if we are in an invariant
+            // context; no need, and it can induce dependency cycles
+            // (e.g., #41849).
+            relate::relate_args_invariantly(self, a_arg, b_arg)
+        } else {
+            let tcx = self.cx();
+            let opt_variances = tcx.variances_of(item_def_id);
+            relate::relate_args_with_variances(
+                self,
+                item_def_id,
+                opt_variances,
+                a_arg,
+                b_arg,
+                false,
+            )
+        }
+    }
+
+    #[instrument(level = "debug", skip(self, variance, b), ret)]
+    fn relate_with_variance<T: Relate<DbInterner<'db>>>(
+        &mut self,
+        variance: Variance,
+        _info: VarianceDiagInfo<DbInterner<'db>>,
+        a: T,
+        b: T,
+    ) -> RelateResult<'db, T> {
+        let old_ambient_variance = self.ambient_variance;
+        self.ambient_variance = self.ambient_variance.xform(variance);
+        debug!(?self.ambient_variance, "new ambient variance");
+        // Recursive calls to `relate` can overflow the stack. For example a deeper version of
+        // `ui/associated-consts/issue-93775.rs`.
+        let r = self.relate(a, b);
+        self.ambient_variance = old_ambient_variance;
+        r
+    }
+
+    #[instrument(level = "debug", skip(self, t2), ret)]
+    fn tys(&mut self, t: Ty<'db>, t2: Ty<'db>) -> RelateResult<'db, Ty<'db>> {
+        assert_eq!(t, t2); // we are misusing TypeRelation here; both LHS and RHS ought to be ==
+
+        if let Some(result) = self.cache.get(&(t, self.ambient_variance, self.in_alias)) {
+            return Ok(*result);
+        }
+
+        // Check to see whether the type we are generalizing references
+        // any other type variable related to `vid` via
+        // subtyping. This is basically our "occurs check", preventing
+        // us from creating infinitely sized types.
+        let g = match t.kind() {
+            TyKind::Infer(
+                InferTy::FreshTy(_) | InferTy::FreshIntTy(_) | InferTy::FreshFloatTy(_),
+            ) => {
+                panic!("unexpected infer type: {t:?}")
+            }
+
+            TyKind::Infer(InferTy::TyVar(vid)) => {
+                let mut inner = self.infcx.inner.borrow_mut();
+                let vid = inner.type_variables().root_var(vid);
+                if TermVid::Ty(vid) == self.root_vid {
+                    // If sub-roots are equal, then `root_vid` and
+                    // `vid` are related via subtyping.
+                    Err(self.cyclic_term_error())
+                } else {
+                    let probe = inner.type_variables().probe(vid);
+                    match probe {
+                        TypeVariableValue::Known { value: u } => {
+                            drop(inner);
+                            self.relate(u, u)
+                        }
+                        TypeVariableValue::Unknown { universe } => {
+                            match self.ambient_variance {
+                                // Invariant: no need to make a fresh type variable
+                                // if we can name the universe.
+                                Variance::Invariant => {
+                                    if self.for_universe.can_name(universe) {
+                                        return Ok(t);
+                                    }
+                                }
+
+                                // Bivariant: make a fresh var, but remember that
+                                // it is unconstrained. See the comment in
+                                // `Generalization`.
+                                Variance::Bivariant => self.has_unconstrained_ty_var = true,
+
+                                // Co/contravariant: this will be
+                                // sufficiently constrained later on.
+                                Variance::Covariant | Variance::Contravariant => (),
+                            }
+
+                            let origin = inner.type_variables().var_origin(vid);
+                            let new_var_id =
+                                inner.type_variables().new_var(self.for_universe, origin);
+                            // If we're in the new solver and create a new inference
+                            // variable inside of an alias we eagerly constrain that
+                            // inference variable to prevent unexpected ambiguity errors.
+                            //
+                            // This is incomplete as it pulls down the universe of the
+                            // original inference variable, even though the alias could
+                            // normalize to a type which does not refer to that type at
+                            // all. I don't expect this to cause unexpected errors in
+                            // practice.
+                            //
+                            // We only need to do so for type and const variables, as
+                            // region variables do not impact normalization, and will get
+                            // correctly constrained by `AliasRelate` later on.
+                            //
+                            // cc trait-system-refactor-initiative#108
+                            if self.infcx.next_trait_solver()
+                                && !matches!(
+                                    self.infcx.typing_mode_unchecked(),
+                                    TypingMode::Coherence
+                                )
+                                && self.in_alias
+                            {
+                                inner.type_variables().equate(vid, new_var_id);
+                            }
+
+                            debug!("replacing original vid={:?} with new={:?}", vid, new_var_id);
+                            Ok(Ty::new_var(self.infcx.interner, new_var_id))
+                        }
+                    }
+                }
+            }
+
+            TyKind::Infer(InferTy::IntVar(_) | InferTy::FloatVar(_)) => {
+                // No matter what mode we are in,
+                // integer/floating-point types must be equal to be
+                // relatable.
+                Ok(t)
+            }
+
+            TyKind::Placeholder(placeholder) => {
+                if self.for_universe.can_name(placeholder.universe) {
+                    Ok(t)
+                } else {
+                    debug!(
+                        "root universe {:?} cannot name placeholder in universe {:?}",
+                        self.for_universe, placeholder.universe
+                    );
+                    Err(TypeError::Mismatch)
+                }
+            }
+
+            TyKind::Alias(_, data) => match self.structurally_relate_aliases {
+                StructurallyRelateAliases::No => self.generalize_alias_ty(data),
+                StructurallyRelateAliases::Yes => relate::structurally_relate_tys(self, t, t),
+            },
+
+            _ => relate::structurally_relate_tys(self, t, t),
+        }?;
+
+        self.cache.insert((t, self.ambient_variance, self.in_alias), g);
+        Ok(g)
+    }
+
+    #[instrument(level = "debug", skip(self, r2), ret)]
+    fn regions(&mut self, r: Region<'db>, r2: Region<'db>) -> RelateResult<'db, Region<'db>> {
+        assert_eq!(r, r2); // we are misusing TypeRelation here; both LHS and RHS ought to be ==
+
+        match r.kind() {
+            // Never make variables for regions bound within the type itself,
+            // nor for erased regions.
+            RegionKind::ReBound(..) | RegionKind::ReErased => {
+                return Ok(r);
+            }
+
+            // It doesn't really matter for correctness if we generalize ReError,
+            // since we're already on a doomed compilation path.
+            RegionKind::ReError(_) => {
+                return Ok(r);
+            }
+
+            RegionKind::RePlaceholder(..)
+            | RegionKind::ReVar(..)
+            | RegionKind::ReStatic
+            | RegionKind::ReEarlyParam(..)
+            | RegionKind::ReLateParam(..) => {
+                // see common code below
+            }
+        }
+
+        // If we are in an invariant context, we can re-use the region
+        // as is, unless it happens to be in some universe that we
+        // can't name.
+        if let Variance::Invariant = self.ambient_variance {
+            let r_universe = self.infcx.universe_of_region(r);
+            if self.for_universe.can_name(r_universe) {
+                return Ok(r);
+            }
+        }
+
+        Ok(self.infcx.next_region_var_in_universe(self.for_universe))
+    }
+
+    #[instrument(level = "debug", skip(self, c2), ret)]
+    fn consts(&mut self, c: Const<'db>, c2: Const<'db>) -> RelateResult<'db, Const<'db>> {
+        assert_eq!(c, c2); // we are misusing TypeRelation here; both LHS and RHS ought to be ==
+
+        match c.kind() {
+            ConstKind::Infer(InferConst::Var(vid)) => {
+                // If root const vids are equal, then `root_vid` and
+                // `vid` are related and we'd be inferring an infinitely
+                // deep const.
+                if TermVid::Const(
+                    self.infcx.inner.borrow_mut().const_unification_table().find(vid).vid,
+                ) == self.root_vid
+                {
+                    return Err(self.cyclic_term_error());
+                }
+
+                let mut inner = self.infcx.inner.borrow_mut();
+                let variable_table = &mut inner.const_unification_table();
+                match variable_table.probe_value(vid) {
+                    ConstVariableValue::Known { value: u } => {
+                        drop(inner);
+                        self.relate(u, u)
+                    }
+                    ConstVariableValue::Unknown { origin, universe } => {
+                        if self.for_universe.can_name(universe) {
+                            Ok(c)
+                        } else {
+                            let new_var_id = variable_table
+                                .new_key(ConstVariableValue::Unknown {
+                                    origin,
+                                    universe: self.for_universe,
+                                })
+                                .vid;
+
+                            // See the comment for type inference variables
+                            // for more details.
+                            if self.infcx.next_trait_solver()
+                                && !matches!(
+                                    self.infcx.typing_mode_unchecked(),
+                                    TypingMode::Coherence
+                                )
+                                && self.in_alias
+                            {
+                                variable_table.union(vid, new_var_id);
+                            }
+                            Ok(Const::new_var(self.infcx.interner, new_var_id))
+                        }
+                    }
+                }
+            }
+            // FIXME: Unevaluated constants are also not rigid, so the current
+            // approach of always relating them structurally is incomplete.
+            //
+            // FIXME: remove this branch once `structurally_relate_consts` is fully
+            // structural.
+            ConstKind::Unevaluated(UnevaluatedConst { def, args }) => {
+                let args = self.relate_with_variance(
+                    Variance::Invariant,
+                    VarianceDiagInfo::default(),
+                    args,
+                    args,
+                )?;
+                Ok(Const::new_unevaluated(self.infcx.interner, UnevaluatedConst { def, args }))
+            }
+            ConstKind::Placeholder(placeholder) => {
+                if self.for_universe.can_name(placeholder.universe) {
+                    Ok(c)
+                } else {
+                    debug!(
+                        "root universe {:?} cannot name placeholder in universe {:?}",
+                        self.for_universe, placeholder.universe
+                    );
+                    Err(TypeError::Mismatch)
+                }
+            }
+            _ => relate::structurally_relate_consts(self, c, c),
+        }
+    }
+
+    #[instrument(level = "debug", skip(self), ret)]
+    fn binders<T>(
+        &mut self,
+        a: Binder<'db, T>,
+        _: Binder<'db, T>,
+    ) -> RelateResult<'db, Binder<'db, T>>
+    where
+        T: Relate<DbInterner<'db>>,
+    {
+        let result = self.relate(a.skip_binder(), a.skip_binder())?;
+        Ok(a.rebind(result))
+    }
+}
+
+/// Result from a generalization operation. This includes
+/// not only the generalized type, but also a bool flag
+/// indicating whether further WF checks are needed.
+#[derive(Debug)]
+struct Generalization<T> {
+    /// When generalizing `<?0 as Trait>::Assoc` or
+    /// `<T as Bar<<?0 as Foo>::Assoc>>::Assoc`
+    /// for `?0` generalization returns an inference
+    /// variable.
+    ///
+    /// This has to be handled wotj care as it can
+    /// otherwise very easily result in infinite
+    /// recursion.
+    pub value_may_be_infer: T,
+
+    /// In general, we do not check whether all types which occur during
+    /// type checking are well-formed. We only check wf of user-provided types
+    /// and when actually using a type, e.g. for method calls.
+    ///
+    /// This means that when subtyping, we may end up with unconstrained
+    /// inference variables if a generalized type has bivariant parameters.
+    /// A parameter may only be bivariant if it is constrained by a projection
+    /// bound in a where-clause. As an example, imagine a type:
+    ///
+    ///     struct Foo<A, B> where A: Iterator<Item = B> {
+    ///         data: A
+    ///     }
+    ///
+    /// here, `A` will be covariant, but `B` is unconstrained.
+    ///
+    /// However, whatever it is, for `Foo` to be WF, it must be equal to `A::Item`.
+    /// If we have an input `Foo<?A, ?B>`, then after generalization we will wind
+    /// up with a type like `Foo<?C, ?D>`. When we enforce `Foo<?A, ?B> <: Foo<?C, ?D>`,
+    /// we will wind up with the requirement that `?A <: ?C`, but no particular
+    /// relationship between `?B` and `?D` (after all, these types may be completely
+    /// different). If we do nothing else, this may mean that `?D` goes unconstrained
+    /// (as in #41677). To avoid this we emit a `WellFormed` obligation in these cases.
+    pub has_unconstrained_ty_var: bool,
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/relate/higher_ranked.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/relate/higher_ranked.rs
new file mode 100644
index 0000000000000..bb80c5157109c
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/relate/higher_ranked.rs
@@ -0,0 +1,89 @@
+//! Helper routines for higher-ranked things. See the `doc` module at
+//! the end of the file for details.
+
+use rustc_type_ir::TypeFoldable;
+use rustc_type_ir::{BoundVar, UniverseIndex};
+use tracing::{debug, instrument};
+
+use super::RelateResult;
+use crate::next_solver::fold::FnMutDelegate;
+use crate::next_solver::infer::InferCtxt;
+use crate::next_solver::infer::snapshot::CombinedSnapshot;
+use crate::next_solver::{
+    Binder, BoundRegion, BoundTy, Const, DbInterner, PlaceholderConst, PlaceholderRegion,
+    PlaceholderTy, Region, Ty,
+};
+
+impl<'db> InferCtxt<'db> {
+    /// Replaces all bound variables (lifetimes, types, and constants) bound by
+    /// `binder` with placeholder variables in a new universe. This means that the
+    /// new placeholders can only be named by inference variables created after
+    /// this method has been called.
+    ///
+    /// This is the first step of checking subtyping when higher-ranked things are involved.
+    /// For more details visit the relevant sections of the [rustc dev guide].
+    ///
+    /// `fn enter_forall` should be preferred over this method.
+    ///
+    /// [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/traits/hrtb.html
+    #[instrument(level = "debug", skip(self), ret)]
+    pub fn enter_forall_and_leak_universe<T>(&self, binder: Binder<'db, T>) -> T
+    where
+        T: TypeFoldable<DbInterner<'db>> + Clone,
+    {
+        if let Some(inner) = binder.clone().no_bound_vars() {
+            return inner;
+        }
+
+        let next_universe = self.create_next_universe();
+
+        let delegate = FnMutDelegate {
+            regions: &mut |br: BoundRegion| {
+                Region::new_placeholder(
+                    self.interner,
+                    PlaceholderRegion { universe: next_universe, bound: br },
+                )
+            },
+            types: &mut |bound_ty: BoundTy| {
+                Ty::new_placeholder(
+                    self.interner,
+                    PlaceholderTy { universe: next_universe, bound: bound_ty },
+                )
+            },
+            consts: &mut |bound_var: BoundVar| {
+                Const::new_placeholder(
+                    self.interner,
+                    PlaceholderConst { universe: next_universe, bound: bound_var },
+                )
+            },
+        };
+
+        debug!(?next_universe);
+        self.interner.replace_bound_vars_uncached(binder, delegate)
+    }
+
+    /// Replaces all bound variables (lifetimes, types, and constants) bound by
+    /// `binder` with placeholder variables in a new universe and then calls the
+    /// closure `f` with the instantiated value. The new placeholders can only be
+    /// named by inference variables created inside of the closure `f` or afterwards.
+    ///
+    /// This is the first step of checking subtyping when higher-ranked things are involved.
+    /// For more details visit the relevant sections of the [rustc dev guide].
+    ///
+    /// This method should be preferred over `fn enter_forall_and_leak_universe`.
+    ///
+    /// [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/traits/hrtb.html
+    #[instrument(level = "debug", skip(self, f))]
+    pub fn enter_forall<T, U>(&self, forall: Binder<'db, T>, f: impl FnOnce(T) -> U) -> U
+    where
+        T: TypeFoldable<DbInterner<'db>> + Clone,
+    {
+        // FIXME: currently we do nothing to prevent placeholders with the new universe being
+        // used after exiting `f`. For example region subtyping can result in outlives constraints
+        // that name placeholders created in this function. Nested goals from type relations can
+        // also contain placeholders created by this function.
+        let value = self.enter_forall_and_leak_universe(forall);
+        debug!(?value);
+        f(value)
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/relate/mod.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/relate/mod.rs
new file mode 100644
index 0000000000000..836ae39dc5253
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/relate/mod.rs
@@ -0,0 +1,13 @@
+//! This module contains the definitions of most `TypeRelation`s in the type system
+//! (except for some relations used for diagnostics and heuristics in the compiler).
+//! As well as the implementation of `Relate` for interned things (`Ty`/`Const`/etc).
+
+pub use rustc_type_ir::relate::combine::PredicateEmittingRelation;
+pub use rustc_type_ir::relate::*;
+
+use crate::next_solver::DbInterner;
+
+mod generalize;
+mod higher_ranked;
+
+pub type RelateResult<'db, T> = rustc_type_ir::relate::RelateResult<DbInterner<'db>, T>;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/resolve.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/resolve.rs
new file mode 100644
index 0000000000000..84338ade6e354
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/resolve.rs
@@ -0,0 +1,62 @@
+//! Things for resolving vars in the infer context of the next-trait-solver.
+
+use rustc_type_ir::{
+    ConstKind, FallibleTypeFolder, InferConst, InferTy, RegionKind, TyKind, TypeFoldable,
+    TypeFolder, TypeSuperFoldable, TypeVisitableExt, data_structures::DelayedMap,
+    inherent::IntoKind,
+};
+
+use crate::next_solver::{Const, DbInterner, Region, Ty};
+
+use super::{FixupError, FixupResult, InferCtxt};
+
+///////////////////////////////////////////////////////////////////////////
+// OPPORTUNISTIC VAR RESOLVER
+
+/// The opportunistic resolver can be used at any time. It simply replaces
+/// type/const variables that have been unified with the things they have
+/// been unified with (similar to `shallow_resolve`, but deep). This is
+/// useful for printing messages etc but also required at various
+/// points for correctness.
+pub struct OpportunisticVarResolver<'a, 'db> {
+    infcx: &'a InferCtxt<'db>,
+    /// We're able to use a cache here as the folder does
+    /// not have any mutable state.
+    cache: DelayedMap<Ty<'db>, Ty<'db>>,
+}
+
+impl<'a, 'db> OpportunisticVarResolver<'a, 'db> {
+    #[inline]
+    pub fn new(infcx: &'a InferCtxt<'db>) -> Self {
+        OpportunisticVarResolver { infcx, cache: Default::default() }
+    }
+}
+
+impl<'a, 'db> TypeFolder<DbInterner<'db>> for OpportunisticVarResolver<'a, 'db> {
+    fn cx(&self) -> DbInterner<'db> {
+        self.infcx.interner
+    }
+
+    #[inline]
+    fn fold_ty(&mut self, t: Ty<'db>) -> Ty<'db> {
+        if !t.has_non_region_infer() {
+            t // micro-optimize -- if there is nothing in this type that this fold affects...
+        } else if let Some(ty) = self.cache.get(&t) {
+            *ty
+        } else {
+            let shallow = self.infcx.shallow_resolve(t);
+            let res = shallow.super_fold_with(self);
+            assert!(self.cache.insert(t, res));
+            res
+        }
+    }
+
+    fn fold_const(&mut self, ct: Const<'db>) -> Const<'db> {
+        if !ct.has_non_region_infer() {
+            ct // micro-optimize -- if there is nothing in this const that this fold affects...
+        } else {
+            let ct = self.infcx.shallow_resolve_const(ct);
+            ct.super_fold_with(self)
+        }
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/snapshot/mod.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/snapshot/mod.rs
new file mode 100644
index 0000000000000..eb426205575ad
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/snapshot/mod.rs
@@ -0,0 +1,111 @@
+//! Snapshotting in the infer ctxt of the next-trait-solver.
+
+use ena::undo_log::UndoLogs;
+use rustc_type_ir::UniverseIndex;
+use tracing::{debug, instrument};
+
+use super::InferCtxt;
+use super::region_constraints::RegionSnapshot;
+
+pub(crate) mod undo_log;
+
+use undo_log::{Snapshot, UndoLog};
+
+#[must_use = "once you start a snapshot, you should always consume it"]
+pub struct CombinedSnapshot {
+    pub(super) undo_snapshot: Snapshot,
+    region_constraints_snapshot: RegionSnapshot,
+    universe: UniverseIndex,
+}
+
+struct VariableLengths {
+    region_constraints_len: usize,
+    type_var_len: usize,
+    int_var_len: usize,
+    float_var_len: usize,
+    const_var_len: usize,
+}
+
+impl<'db> InferCtxt<'db> {
+    fn variable_lengths(&self) -> VariableLengths {
+        let mut inner = self.inner.borrow_mut();
+        VariableLengths {
+            region_constraints_len: inner.unwrap_region_constraints().num_region_vars(),
+            type_var_len: inner.type_variables().num_vars(),
+            int_var_len: inner.int_unification_table().len(),
+            float_var_len: inner.float_unification_table().len(),
+            const_var_len: inner.const_unification_table().len(),
+        }
+    }
+
+    pub fn in_snapshot(&self) -> bool {
+        UndoLogs::<UndoLog<'db>>::in_snapshot(&self.inner.borrow_mut().undo_log)
+    }
+
+    pub fn num_open_snapshots(&self) -> usize {
+        UndoLogs::<UndoLog<'db>>::num_open_snapshots(&self.inner.borrow_mut().undo_log)
+    }
+
+    fn start_snapshot(&self) -> CombinedSnapshot {
+        debug!("start_snapshot()");
+
+        let mut inner = self.inner.borrow_mut();
+
+        CombinedSnapshot {
+            undo_snapshot: inner.undo_log.start_snapshot(),
+            region_constraints_snapshot: inner.unwrap_region_constraints().start_snapshot(),
+            universe: self.universe(),
+        }
+    }
+
+    #[instrument(skip(self, snapshot), level = "debug")]
+    fn rollback_to(&self, snapshot: CombinedSnapshot) {
+        let CombinedSnapshot { undo_snapshot, region_constraints_snapshot, universe } = snapshot;
+
+        self.universe.set(universe);
+
+        let mut inner = self.inner.borrow_mut();
+        inner.rollback_to(undo_snapshot);
+        inner.unwrap_region_constraints().rollback_to(region_constraints_snapshot);
+    }
+
+    #[instrument(skip(self, snapshot), level = "debug")]
+    fn commit_from(&self, snapshot: CombinedSnapshot) {
+        let CombinedSnapshot { undo_snapshot, region_constraints_snapshot: _, universe: _ } =
+            snapshot;
+
+        self.inner.borrow_mut().commit(undo_snapshot);
+    }
+
+    /// Execute `f` and commit the bindings if closure `f` returns `Ok(_)`.
+    #[instrument(skip(self, f), level = "debug")]
+    pub fn commit_if_ok<T, E, F>(&self, f: F) -> Result<T, E>
+    where
+        F: FnOnce(&CombinedSnapshot) -> Result<T, E>,
+    {
+        let snapshot = self.start_snapshot();
+        let r = f(&snapshot);
+        debug!("commit_if_ok() -- r.is_ok() = {}", r.is_ok());
+        match r {
+            Ok(_) => {
+                self.commit_from(snapshot);
+            }
+            Err(_) => {
+                self.rollback_to(snapshot);
+            }
+        }
+        r
+    }
+
+    /// Execute `f` then unroll any bindings it creates.
+    #[instrument(skip(self, f), level = "debug")]
+    pub fn probe<R, F>(&self, f: F) -> R
+    where
+        F: FnOnce(&CombinedSnapshot) -> R,
+    {
+        let snapshot = self.start_snapshot();
+        let r = f(&snapshot);
+        self.rollback_to(snapshot);
+        r
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/snapshot/undo_log.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/snapshot/undo_log.rs
new file mode 100644
index 0000000000000..0fa6421f517de
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/snapshot/undo_log.rs
@@ -0,0 +1,198 @@
+//! Snapshotting in the infer ctxt of the next-trait-solver.
+
+use std::marker::PhantomData;
+
+use ena::snapshot_vec as sv;
+use ena::undo_log::{Rollback, UndoLogs};
+use ena::unify as ut;
+use rustc_type_ir::FloatVid;
+use rustc_type_ir::IntVid;
+use tracing::debug;
+
+use crate::next_solver::OpaqueTypeKey;
+use crate::next_solver::infer::opaque_types::OpaqueHiddenType;
+use crate::next_solver::infer::unify_key::ConstVidKey;
+use crate::next_solver::infer::unify_key::RegionVidKey;
+use crate::next_solver::infer::{InferCtxtInner, region_constraints, type_variable};
+use crate::traits;
+
+pub struct Snapshot {
+    pub(crate) undo_len: usize,
+}
+
+/// Records the "undo" data for a single operation that affects some form of inference variable.
+#[derive(Clone)]
+pub(crate) enum UndoLog<'db> {
+    DuplicateOpaqueType,
+    OpaqueTypes(OpaqueTypeKey<'db>, Option<OpaqueHiddenType<'db>>),
+    TypeVariables(sv::UndoLog<ut::Delegate<type_variable::TyVidEqKey<'db>>>),
+    ConstUnificationTable(sv::UndoLog<ut::Delegate<ConstVidKey<'db>>>),
+    IntUnificationTable(sv::UndoLog<ut::Delegate<IntVid>>),
+    FloatUnificationTable(sv::UndoLog<ut::Delegate<FloatVid>>),
+    RegionConstraintCollector(region_constraints::UndoLog<'db>),
+    RegionUnificationTable(sv::UndoLog<ut::Delegate<RegionVidKey<'db>>>),
+    PushRegionObligation,
+}
+
+macro_rules! impl_from {
+    ($($ctor:ident ($ty:ty),)*) => {
+        $(
+        impl<'db> From<$ty> for UndoLog<'db> {
+            fn from(x: $ty) -> Self {
+                UndoLog::$ctor(x.into())
+            }
+        }
+        )*
+    }
+}
+
+// Upcast from a single kind of "undoable action" to the general enum
+impl_from! {
+    RegionConstraintCollector(region_constraints::UndoLog<'db>),
+
+    TypeVariables(sv::UndoLog<ut::Delegate<type_variable::TyVidEqKey<'db>>>),
+    IntUnificationTable(sv::UndoLog<ut::Delegate<IntVid>>),
+    FloatUnificationTable(sv::UndoLog<ut::Delegate<FloatVid>>),
+
+    ConstUnificationTable(sv::UndoLog<ut::Delegate<ConstVidKey<'db>>>),
+
+    RegionUnificationTable(sv::UndoLog<ut::Delegate<RegionVidKey<'db>>>),
+}
+
+/// The Rollback trait defines how to rollback a particular action.
+impl<'db> Rollback<UndoLog<'db>> for InferCtxtInner<'db> {
+    fn reverse(&mut self, undo: UndoLog<'db>) {
+        match undo {
+            UndoLog::DuplicateOpaqueType => self.opaque_type_storage.pop_duplicate_entry(),
+            UndoLog::OpaqueTypes(key, idx) => self.opaque_type_storage.remove(key, idx),
+            UndoLog::TypeVariables(undo) => self.type_variable_storage.reverse(undo),
+            UndoLog::ConstUnificationTable(undo) => self.const_unification_storage.reverse(undo),
+            UndoLog::IntUnificationTable(undo) => self.int_unification_storage.reverse(undo),
+            UndoLog::FloatUnificationTable(undo) => self.float_unification_storage.reverse(undo),
+            UndoLog::RegionConstraintCollector(undo) => {
+                self.region_constraint_storage.as_mut().unwrap().reverse(undo)
+            }
+            UndoLog::RegionUnificationTable(undo) => {
+                self.region_constraint_storage.as_mut().unwrap().unification_table.reverse(undo)
+            }
+            UndoLog::PushRegionObligation => {
+                self.region_obligations.pop();
+            }
+        }
+    }
+}
+
+/// The combined undo log for all the various unification tables. For each change to the storage
+/// for any kind of inference variable, we record an UndoLog entry in the vector here.
+#[derive(Clone, Default)]
+pub(crate) struct InferCtxtUndoLogs<'db> {
+    logs: Vec<UndoLog<'db>>,
+    num_open_snapshots: usize,
+}
+
+/// The UndoLogs trait defines how we undo a particular kind of action (of type T). We can undo any
+/// action that is convertible into an UndoLog (per the From impls above).
+impl<'db, T> UndoLogs<T> for InferCtxtUndoLogs<'db>
+where
+    UndoLog<'db>: From<T>,
+{
+    #[inline]
+    fn num_open_snapshots(&self) -> usize {
+        self.num_open_snapshots
+    }
+
+    #[inline]
+    fn push(&mut self, undo: T) {
+        if self.in_snapshot() {
+            self.logs.push(undo.into())
+        }
+    }
+
+    fn clear(&mut self) {
+        self.logs.clear();
+        self.num_open_snapshots = 0;
+    }
+
+    fn extend<J>(&mut self, undos: J)
+    where
+        Self: Sized,
+        J: IntoIterator<Item = T>,
+    {
+        if self.in_snapshot() {
+            self.logs.extend(undos.into_iter().map(UndoLog::from))
+        }
+    }
+}
+
+impl<'db> InferCtxtInner<'db> {
+    pub fn rollback_to(&mut self, snapshot: Snapshot) {
+        debug!("rollback_to({})", snapshot.undo_len);
+        self.undo_log.assert_open_snapshot(&snapshot);
+
+        while self.undo_log.logs.len() > snapshot.undo_len {
+            let undo = self.undo_log.logs.pop().unwrap();
+            self.reverse(undo);
+        }
+
+        self.type_variable_storage.finalize_rollback();
+
+        if self.undo_log.num_open_snapshots == 1 {
+            // After the root snapshot the undo log should be empty.
+            assert!(snapshot.undo_len == 0);
+            assert!(self.undo_log.logs.is_empty());
+        }
+
+        self.undo_log.num_open_snapshots -= 1;
+    }
+
+    pub fn commit(&mut self, snapshot: Snapshot) {
+        debug!("commit({})", snapshot.undo_len);
+
+        if self.undo_log.num_open_snapshots == 1 {
+            // The root snapshot. It's safe to clear the undo log because
+            // there's no snapshot further out that we might need to roll back
+            // to.
+            assert!(snapshot.undo_len == 0);
+            self.undo_log.logs.clear();
+        }
+
+        self.undo_log.num_open_snapshots -= 1;
+    }
+}
+
+impl<'db> InferCtxtUndoLogs<'db> {
+    pub(crate) fn start_snapshot(&mut self) -> Snapshot {
+        self.num_open_snapshots += 1;
+        Snapshot { undo_len: self.logs.len() }
+    }
+
+    pub(crate) fn region_constraints_in_snapshot(
+        &self,
+        s: &Snapshot,
+    ) -> impl Iterator<Item = &'_ region_constraints::UndoLog<'db>> + Clone {
+        self.logs[s.undo_len..].iter().filter_map(|log| match log {
+            UndoLog::RegionConstraintCollector(log) => Some(log),
+            _ => None,
+        })
+    }
+
+    fn assert_open_snapshot(&self, snapshot: &Snapshot) {
+        // Failures here may indicate a failure to follow a stack discipline.
+        assert!(self.logs.len() >= snapshot.undo_len);
+        assert!(self.num_open_snapshots > 0);
+    }
+}
+
+impl<'db> std::ops::Index<usize> for InferCtxtUndoLogs<'db> {
+    type Output = UndoLog<'db>;
+
+    fn index(&self, key: usize) -> &Self::Output {
+        &self.logs[key]
+    }
+}
+
+impl<'db> std::ops::IndexMut<usize> for InferCtxtUndoLogs<'db> {
+    fn index_mut(&mut self, key: usize) -> &mut Self::Output {
+        &mut self.logs[key]
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/traits.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/traits.rs
new file mode 100644
index 0000000000000..f1df806ab3187
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/traits.rs
@@ -0,0 +1,175 @@
+//! Trait Resolution. See the [rustc-dev-guide] for more information on how this works.
+//!
+//! [rustc-dev-guide]: https://rustc-dev-guide.rust-lang.org/traits/resolution.html
+
+use std::{
+    cmp,
+    hash::{Hash, Hasher},
+};
+
+use rustc_type_ir::{
+    PredicatePolarity, Upcast,
+    solve::{Certainty, NoSolution},
+};
+
+use crate::next_solver::{
+    Binder, DbInterner, Goal, ParamEnv, PolyTraitPredicate, Predicate, SolverDefId, TraitPredicate,
+    Ty,
+};
+
+use super::InferCtxt;
+
+/// The reason why we incurred this obligation; used for error reporting.
+///
+/// Non-misc `ObligationCauseCode`s are stored on the heap. This gives the
+/// best trade-off between keeping the type small (which makes copies cheaper)
+/// while not doing too many heap allocations.
+///
+/// We do not want to intern this as there are a lot of obligation causes which
+/// only live for a short period of time.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ObligationCause {
+    /// The ID of the fn body that triggered this obligation. This is
+    /// used for region obligations to determine the precise
+    /// environment in which the region obligation should be evaluated
+    /// (in particular, closures can add new assumptions). See the
+    /// field `region_obligations` of the `FulfillmentContext` for more
+    /// information.
+    pub body_id: Option<SolverDefId>,
+}
+
+impl ObligationCause {
+    #[inline]
+    pub fn new(body_id: SolverDefId) -> ObligationCause {
+        ObligationCause { body_id: Some(body_id) }
+    }
+
+    #[inline(always)]
+    pub fn dummy() -> ObligationCause {
+        ObligationCause { body_id: None }
+    }
+}
+
+/// An `Obligation` represents some trait reference (e.g., `i32: Eq`) for
+/// which the "impl_source" must be found. The process of finding an "impl_source" is
+/// called "resolving" the `Obligation`. This process consists of
+/// either identifying an `impl` (e.g., `impl Eq for i32`) that
+/// satisfies the obligation, or else finding a bound that is in
+/// scope. The eventual result is usually a `Selection` (defined below).
+#[derive(Clone, Debug)]
+pub struct Obligation<'db, T> {
+    /// The reason we have to prove this thing.
+    pub cause: ObligationCause,
+
+    /// The environment in which we should prove this thing.
+    pub param_env: ParamEnv<'db>,
+
+    /// The thing we are trying to prove.
+    pub predicate: T,
+
+    /// If we started proving this as a result of trying to prove
+    /// something else, track the total depth to ensure termination.
+    /// If this goes over a certain threshold, we abort compilation --
+    /// in such cases, we can not say whether or not the predicate
+    /// holds for certain. Stupid halting problem; such a drag.
+    pub recursion_depth: usize,
+}
+
+impl<'db, T: Copy> Obligation<'db, T> {
+    pub fn as_goal(&self) -> Goal<'db, T> {
+        Goal { param_env: self.param_env, predicate: self.predicate }
+    }
+}
+
+impl<'db, T: PartialEq> PartialEq<Obligation<'db, T>> for Obligation<'db, T> {
+    #[inline]
+    fn eq(&self, other: &Obligation<'db, T>) -> bool {
+        // Ignore `cause` and `recursion_depth`. This is a small performance
+        // win for a few crates, and a huge performance win for the crate in
+        // https://github.com/rust-lang/rustc-perf/pull/1680, which greatly
+        // stresses the trait system.
+        self.param_env == other.param_env && self.predicate == other.predicate
+    }
+}
+
+impl<'db, T: Eq> Eq for Obligation<'db, T> {}
+
+impl<'db, T: Hash> Hash for Obligation<'db, T> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        // See the comment on `Obligation::eq`.
+        self.param_env.hash(state);
+        self.predicate.hash(state);
+    }
+}
+
+impl<'db, P> From<Obligation<'db, P>> for Goal<'db, P> {
+    fn from(value: Obligation<'db, P>) -> Self {
+        Goal { param_env: value.param_env, predicate: value.predicate }
+    }
+}
+
+pub type PredicateObligation<'db> = Obligation<'db, Predicate<'db>>;
+pub type TraitObligation<'db> = Obligation<'db, TraitPredicate<'db>>;
+
+pub type PredicateObligations<'db> = Vec<PredicateObligation<'db>>;
+
+impl<'db> PredicateObligation<'db> {
+    /// Flips the polarity of the inner predicate.
+    ///
+    /// Given `T: Trait` predicate it returns `T: !Trait` and given `T: !Trait` returns `T: Trait`.
+    pub fn flip_polarity(&self, tcx: DbInterner<'db>) -> Option<PredicateObligation<'db>> {
+        Some(PredicateObligation {
+            cause: self.cause.clone(),
+            param_env: self.param_env,
+            predicate: self.predicate.flip_polarity()?,
+            recursion_depth: self.recursion_depth,
+        })
+    }
+}
+
+impl<'db, O> Obligation<'db, O> {
+    pub fn new(
+        tcx: DbInterner<'db>,
+        cause: ObligationCause,
+        param_env: ParamEnv<'db>,
+        predicate: impl Upcast<DbInterner<'db>, O>,
+    ) -> Obligation<'db, O> {
+        Self::with_depth(tcx, cause, 0, param_env, predicate)
+    }
+
+    /// We often create nested obligations without setting the correct depth.
+    ///
+    /// To deal with this evaluate and fulfill explicitly update the depth
+    /// of nested obligations using this function.
+    pub fn set_depth_from_parent(&mut self, parent_depth: usize) {
+        self.recursion_depth = cmp::max(parent_depth + 1, self.recursion_depth);
+    }
+
+    pub fn with_depth(
+        tcx: DbInterner<'db>,
+        cause: ObligationCause,
+        recursion_depth: usize,
+        param_env: ParamEnv<'db>,
+        predicate: impl Upcast<DbInterner<'db>, O>,
+    ) -> Obligation<'db, O> {
+        let predicate = predicate.upcast(tcx);
+        Obligation { cause, param_env, recursion_depth, predicate }
+    }
+
+    pub fn misc(
+        tcx: DbInterner<'db>,
+        body_id: SolverDefId,
+        param_env: ParamEnv<'db>,
+        trait_ref: impl Upcast<DbInterner<'db>, O>,
+    ) -> Obligation<'db, O> {
+        Obligation::new(tcx, ObligationCause::new(body_id), param_env, trait_ref)
+    }
+
+    pub fn with<P>(
+        &self,
+        tcx: DbInterner<'db>,
+        value: impl Upcast<DbInterner<'db>, P>,
+    ) -> Obligation<'db, P> {
+        Obligation::with_depth(tcx, self.cause.clone(), self.recursion_depth, self.param_env, value)
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/type_variable.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/type_variable.rs
new file mode 100644
index 0000000000000..5217308af473c
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/type_variable.rs
@@ -0,0 +1,268 @@
+//! Storage for type variables for the infer context the next-trait-solver.
+
+use std::cmp;
+use std::marker::PhantomData;
+use std::ops::Range;
+
+use ena::snapshot_vec as sv;
+use ena::undo_log::Rollback;
+use ena::unify as ut;
+use rustc_index::IndexVec;
+use rustc_type_ir::TyVid;
+use rustc_type_ir::UniverseIndex;
+use rustc_type_ir::inherent::Ty as _;
+use tracing::debug;
+
+use crate::next_solver::SolverDefId;
+use crate::next_solver::Ty;
+use crate::next_solver::infer::InferCtxtUndoLogs;
+
+impl<'db> Rollback<sv::UndoLog<ut::Delegate<TyVidEqKey<'db>>>> for TypeVariableStorage<'db> {
+    fn reverse(&mut self, undo: sv::UndoLog<ut::Delegate<TyVidEqKey<'db>>>) {
+        self.eq_relations.reverse(undo)
+    }
+}
+
+#[derive(Clone, Default)]
+pub(crate) struct TypeVariableStorage<'db> {
+    /// The origins of each type variable.
+    values: IndexVec<TyVid, TypeVariableData>,
+    /// Two variables are unified in `eq_relations` when we have a
+    /// constraint `?X == ?Y`. This table also stores, for each key,
+    /// the known value.
+    eq_relations: ut::UnificationTableStorage<TyVidEqKey<'db>>,
+}
+
+pub(crate) struct TypeVariableTable<'a, 'db> {
+    storage: &'a mut TypeVariableStorage<'db>,
+
+    undo_log: &'a mut InferCtxtUndoLogs<'db>,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub struct TypeVariableOrigin {
+    /// `DefId` of the type parameter this was instantiated for, if any.
+    ///
+    /// This should only be used for diagnostics.
+    pub param_def_id: Option<SolverDefId>,
+}
+
+#[derive(Clone)]
+pub(crate) struct TypeVariableData {
+    origin: TypeVariableOrigin,
+}
+
+#[derive(Clone, Debug)]
+pub(crate) enum TypeVariableValue<'db> {
+    Known { value: Ty<'db> },
+    Unknown { universe: UniverseIndex },
+}
+
+impl<'db> TypeVariableValue<'db> {
+    /// If this value is known, returns the type it is known to be.
+    /// Otherwise, `None`.
+    pub(crate) fn known(&self) -> Option<Ty<'db>> {
+        match self {
+            TypeVariableValue::Unknown { .. } => None,
+            TypeVariableValue::Known { value } => Some(*value),
+        }
+    }
+
+    pub(crate) fn is_unknown(&self) -> bool {
+        match *self {
+            TypeVariableValue::Unknown { .. } => true,
+            TypeVariableValue::Known { .. } => false,
+        }
+    }
+}
+
+impl<'db> TypeVariableStorage<'db> {
+    #[inline]
+    pub(crate) fn with_log<'a>(
+        &'a mut self,
+        undo_log: &'a mut InferCtxtUndoLogs<'db>,
+    ) -> TypeVariableTable<'a, 'db> {
+        TypeVariableTable { storage: self, undo_log }
+    }
+
+    #[inline]
+    pub(crate) fn eq_relations_ref(&self) -> &ut::UnificationTableStorage<TyVidEqKey<'db>> {
+        &self.eq_relations
+    }
+
+    pub(super) fn finalize_rollback(&mut self) {
+        debug_assert!(self.values.len() >= self.eq_relations.len());
+        self.values.truncate(self.eq_relations.len());
+    }
+}
+
+impl<'db> TypeVariableTable<'_, 'db> {
+    /// Returns the origin that was given when `vid` was created.
+    ///
+    /// Note that this function does not return care whether
+    /// `vid` has been unified with something else or not.
+    pub(crate) fn var_origin(&self, vid: TyVid) -> TypeVariableOrigin {
+        self.storage.values[vid].origin
+    }
+
+    /// Records that `a == b`, depending on `dir`.
+    ///
+    /// Precondition: neither `a` nor `b` are known.
+    pub(crate) fn equate(&mut self, a: TyVid, b: TyVid) {
+        debug_assert!(self.probe(a).is_unknown());
+        debug_assert!(self.probe(b).is_unknown());
+        self.eq_relations().union(a, b);
+    }
+
+    /// Instantiates `vid` with the type `ty`.
+    ///
+    /// Precondition: `vid` must not have been previously instantiated.
+    pub(crate) fn instantiate(&mut self, vid: TyVid, ty: Ty<'db>) {
+        let vid = self.root_var(vid);
+        debug_assert!(!ty.is_ty_var(), "instantiating ty var with var: {vid:?} {ty:?}");
+        debug_assert!(self.probe(vid).is_unknown());
+        debug_assert!(
+            self.eq_relations().probe_value(vid).is_unknown(),
+            "instantiating type variable `{vid:?}` twice: new-value = {ty:?}, old-value={:?}",
+            self.eq_relations().probe_value(vid)
+        );
+        self.eq_relations().union_value(vid, TypeVariableValue::Known { value: ty });
+    }
+
+    /// Creates a new type variable.
+    ///
+    /// - `diverging`: indicates if this is a "diverging" type
+    ///   variable, e.g.,  one created as the type of a `return`
+    ///   expression. The code in this module doesn't care if a
+    ///   variable is diverging, but the main Rust type-checker will
+    ///   sometimes "unify" such variables with the `!` or `()` types.
+    /// - `origin`: indicates *why* the type variable was created.
+    ///   The code in this module doesn't care, but it can be useful
+    ///   for improving error messages.
+    pub(crate) fn new_var(&mut self, universe: UniverseIndex, origin: TypeVariableOrigin) -> TyVid {
+        let eq_key = self.eq_relations().new_key(TypeVariableValue::Unknown { universe });
+        let index = self.storage.values.push(TypeVariableData { origin });
+        debug_assert_eq!(eq_key.vid, index);
+
+        debug!("new_var(index={:?}, universe={:?}, origin={:?})", eq_key.vid, universe, origin);
+
+        index
+    }
+
+    /// Returns the number of type variables created thus far.
+    pub(crate) fn num_vars(&self) -> usize {
+        self.storage.values.len()
+    }
+
+    /// Returns the "root" variable of `vid` in the `eq_relations`
+    /// equivalence table. All type variables that have been equated
+    /// will yield the same root variable (per the union-find
+    /// algorithm), so `root_var(a) == root_var(b)` implies that `a ==
+    /// b` (transitively).
+    pub(crate) fn root_var(&mut self, vid: TyVid) -> TyVid {
+        self.eq_relations().find(vid).vid
+    }
+
+    /// Retrieves the type to which `vid` has been instantiated, if
+    /// any.
+    pub(crate) fn probe(&mut self, vid: TyVid) -> TypeVariableValue<'db> {
+        self.inlined_probe(vid)
+    }
+
+    /// An always-inlined variant of `probe`, for very hot call sites.
+    #[inline(always)]
+    pub(crate) fn inlined_probe(&mut self, vid: TyVid) -> TypeVariableValue<'db> {
+        self.eq_relations().inlined_probe_value(vid)
+    }
+
+    #[inline]
+    fn eq_relations(&mut self) -> super::UnificationTable<'_, 'db, TyVidEqKey<'db>> {
+        self.storage.eq_relations.with_log(self.undo_log)
+    }
+
+    /// Returns indices of all variables that are not yet
+    /// instantiated.
+    pub(crate) fn unresolved_variables(&mut self) -> Vec<TyVid> {
+        (0..self.num_vars())
+            .filter_map(|i| {
+                let vid = TyVid::from_usize(i);
+                match self.probe(vid) {
+                    TypeVariableValue::Unknown { .. } => Some(vid),
+                    TypeVariableValue::Known { .. } => None,
+                }
+            })
+            .collect()
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+/// These structs (a newtyped TyVid) are used as the unification key
+/// for the `eq_relations`; they carry a `TypeVariableValue` along
+/// with them.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub(crate) struct TyVidEqKey<'db> {
+    vid: TyVid,
+
+    // in the table, we map each ty-vid to one of these:
+    phantom: PhantomData<TypeVariableValue<'db>>,
+}
+
+impl<'db> From<TyVid> for TyVidEqKey<'db> {
+    #[inline] // make this function eligible for inlining - it is quite hot.
+    fn from(vid: TyVid) -> Self {
+        TyVidEqKey { vid, phantom: PhantomData }
+    }
+}
+
+impl<'db> ut::UnifyKey for TyVidEqKey<'db> {
+    type Value = TypeVariableValue<'db>;
+    #[inline(always)]
+    fn index(&self) -> u32 {
+        self.vid.as_u32()
+    }
+    #[inline]
+    fn from_index(i: u32) -> Self {
+        TyVidEqKey::from(TyVid::from_u32(i))
+    }
+    fn tag() -> &'static str {
+        "TyVidEqKey"
+    }
+}
+
+impl<'db> ut::UnifyValue for TypeVariableValue<'db> {
+    type Error = ut::NoError;
+
+    fn unify_values(value1: &Self, value2: &Self) -> Result<Self, ut::NoError> {
+        match (value1, value2) {
+            // We never equate two type variables, both of which
+            // have known types. Instead, we recursively equate
+            // those types.
+            (&TypeVariableValue::Known { .. }, &TypeVariableValue::Known { .. }) => {
+                panic!("equating two type variables, both of which have known types")
+            }
+
+            // If one side is known, prefer that one.
+            (&TypeVariableValue::Known { .. }, &TypeVariableValue::Unknown { .. }) => {
+                Ok(value1.clone())
+            }
+            (&TypeVariableValue::Unknown { .. }, &TypeVariableValue::Known { .. }) => {
+                Ok(value2.clone())
+            }
+
+            // If both sides are *unknown*, it hardly matters, does it?
+            (
+                &TypeVariableValue::Unknown { universe: universe1 },
+                &TypeVariableValue::Unknown { universe: universe2 },
+            ) => {
+                // If we unify two unbound variables, ?T and ?U, then whatever
+                // value they wind up taking (which must be the same value) must
+                // be nameable by both universes. Therefore, the resulting
+                // universe is the minimum of the two universes, because that is
+                // the one which contains the fewest names in scope.
+                let universe = cmp::min(universe1, universe2);
+                Ok(TypeVariableValue::Unknown { universe })
+            }
+        }
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/unify_key.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/unify_key.rs
new file mode 100644
index 0000000000000..b9afb45ba89da
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/unify_key.rs
@@ -0,0 +1,176 @@
+//! Unification keyes for the infer context the next-trait-solver.
+
+use std::cmp;
+use std::marker::PhantomData;
+
+use ena::unify::{NoError, UnifyKey, UnifyValue};
+use rustc_type_ir::{ConstVid, RegionKind, RegionVid, UniverseIndex, inherent::IntoKind};
+
+use crate::next_solver::{Const, Region, SolverDefId, Ty};
+
+#[derive(Clone, Debug)]
+pub enum RegionVariableValue<'db> {
+    Known { value: Region<'db> },
+    Unknown { universe: UniverseIndex },
+}
+
+#[derive(PartialEq, Copy, Clone, Debug)]
+pub struct RegionVidKey<'db> {
+    pub vid: RegionVid,
+    pub phantom: PhantomData<RegionVariableValue<'db>>,
+}
+
+impl<'db> From<RegionVid> for RegionVidKey<'db> {
+    fn from(vid: RegionVid) -> Self {
+        RegionVidKey { vid, phantom: PhantomData }
+    }
+}
+
+impl<'db> UnifyKey for RegionVidKey<'db> {
+    type Value = RegionVariableValue<'db>;
+    #[inline]
+    fn index(&self) -> u32 {
+        self.vid.as_u32()
+    }
+    #[inline]
+    fn from_index(i: u32) -> Self {
+        RegionVidKey::from(RegionVid::from_u32(i))
+    }
+    fn tag() -> &'static str {
+        "RegionVidKey"
+    }
+}
+
+pub struct RegionUnificationError;
+impl<'db> UnifyValue for RegionVariableValue<'db> {
+    type Error = RegionUnificationError;
+
+    fn unify_values(value1: &Self, value2: &Self) -> Result<Self, Self::Error> {
+        match (value1, value2) {
+            (RegionVariableValue::Known { .. }, RegionVariableValue::Known { .. }) => {
+                Err(RegionUnificationError)
+            }
+
+            (RegionVariableValue::Known { value }, RegionVariableValue::Unknown { universe })
+            | (RegionVariableValue::Unknown { universe }, RegionVariableValue::Known { value }) => {
+                let universe_of_value = match (*value).kind() {
+                    RegionKind::ReStatic
+                    | RegionKind::ReErased
+                    | RegionKind::ReLateParam(..)
+                    | RegionKind::ReEarlyParam(..)
+                    | RegionKind::ReError(_) => UniverseIndex::ROOT,
+                    RegionKind::RePlaceholder(placeholder) => placeholder.universe,
+                    RegionKind::ReVar(..) | RegionKind::ReBound(..) => {
+                        panic!("not a universal region")
+                    }
+                };
+
+                if universe.can_name(universe_of_value) {
+                    Ok(RegionVariableValue::Known { value: *value })
+                } else {
+                    Err(RegionUnificationError)
+                }
+            }
+
+            (
+                RegionVariableValue::Unknown { universe: a },
+                RegionVariableValue::Unknown { universe: b },
+            ) => {
+                // If we unify two unconstrained regions then whatever
+                // value they wind up taking (which must be the same value) must
+                // be nameable by both universes. Therefore, the resulting
+                // universe is the minimum of the two universes, because that is
+                // the one which contains the fewest names in scope.
+                Ok(RegionVariableValue::Unknown { universe: (*a).min(*b) })
+            }
+        }
+    }
+}
+
+// Generic consts.
+
+#[derive(Copy, Clone, Debug)]
+pub struct ConstVariableOrigin {
+    /// `DefId` of the const parameter this was instantiated for, if any.
+    ///
+    /// This should only be used for diagnostics.
+    pub param_def_id: Option<SolverDefId>,
+}
+
+#[derive(Clone, Debug)]
+pub enum ConstVariableValue<'db> {
+    Known { value: Const<'db> },
+    Unknown { origin: ConstVariableOrigin, universe: UniverseIndex },
+}
+
+impl<'db> ConstVariableValue<'db> {
+    /// If this value is known, returns the const it is known to be.
+    /// Otherwise, `None`.
+    pub fn known(&self) -> Option<Const<'db>> {
+        match self {
+            ConstVariableValue::Unknown { .. } => None,
+            ConstVariableValue::Known { value } => Some(*value),
+        }
+    }
+}
+
+#[derive(PartialEq, Copy, Clone, Debug)]
+pub struct ConstVidKey<'db> {
+    pub vid: ConstVid,
+    pub phantom: PhantomData<Const<'db>>,
+}
+
+impl<'db> From<ConstVid> for ConstVidKey<'db> {
+    fn from(vid: ConstVid) -> Self {
+        ConstVidKey { vid, phantom: PhantomData }
+    }
+}
+
+impl<'db> UnifyKey for ConstVidKey<'db> {
+    type Value = ConstVariableValue<'db>;
+    #[inline]
+    fn index(&self) -> u32 {
+        self.vid.as_u32()
+    }
+    #[inline]
+    fn from_index(i: u32) -> Self {
+        ConstVidKey::from(ConstVid::from_u32(i))
+    }
+    fn tag() -> &'static str {
+        "ConstVidKey"
+    }
+}
+
+impl<'db> UnifyValue for ConstVariableValue<'db> {
+    type Error = NoError;
+
+    fn unify_values(value1: &Self, value2: &Self) -> Result<Self, Self::Error> {
+        match (value1, value2) {
+            (ConstVariableValue::Known { .. }, ConstVariableValue::Known { .. }) => {
+                panic!("equating two const variables, both of which have known values")
+            }
+
+            // If one side is known, prefer that one.
+            (ConstVariableValue::Known { .. }, ConstVariableValue::Unknown { .. }) => {
+                Ok(value1.clone())
+            }
+            (ConstVariableValue::Unknown { .. }, ConstVariableValue::Known { .. }) => {
+                Ok(value2.clone())
+            }
+
+            // If both sides are *unknown*, it hardly matters, does it?
+            (
+                ConstVariableValue::Unknown { origin, universe: universe1 },
+                ConstVariableValue::Unknown { origin: _, universe: universe2 },
+            ) => {
+                // If we unify two unbound variables, ?T and ?U, then whatever
+                // value they wind up taking (which must be the same value) must
+                // be nameable by both universes. Therefore, the resulting
+                // universe is the minimum of the two universes, because that is
+                // the one which contains the fewest names in scope.
+                let universe = cmp::min(*universe1, *universe2);
+                Ok(ConstVariableValue::Unknown { origin: *origin, universe })
+            }
+        }
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
new file mode 100644
index 0000000000000..9c1bd52065fd2
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
@@ -0,0 +1,2173 @@
+//! Things related to the Interner in the next-trait-solver.
+#![allow(unused)]
+
+use base_db::Crate;
+use chalk_ir::{ProgramClauseImplication, SeparatorTraitRef, Variances};
+use hir_def::lang_item::LangItem;
+use hir_def::signatures::{FieldData, FnFlags, ImplFlags, StructFlags, TraitFlags};
+use hir_def::{AdtId, BlockId, TypeAliasId, VariantId};
+use hir_def::{AttrDefId, Lookup};
+use hir_def::{CallableDefId, EnumVariantId, ItemContainerId, StructId, UnionId};
+use intern::sym::non_exhaustive;
+use intern::{Interned, impl_internable, sym};
+use la_arena::Idx;
+use rustc_abi::{Align, ReprFlags, ReprOptions};
+use rustc_hash::FxHashSet;
+use rustc_index::bit_set::DenseBitSet;
+use rustc_type_ir::elaborate::elaborate;
+use rustc_type_ir::error::TypeError;
+use rustc_type_ir::inherent::{
+    AdtDef as _, GenericArgs as _, GenericsOf, IntoKind, SliceLike as _, Span as _,
+};
+use rustc_type_ir::lang_items::TraitSolverLangItem;
+use rustc_type_ir::solve::SizedTraitKind;
+use rustc_type_ir::{
+    AliasTerm, AliasTermKind, AliasTy, EarlyBinder, FlagComputation, Flags, ImplPolarity, InferTy,
+    ProjectionPredicate, TraitPredicate, TraitRef, Upcast,
+};
+use salsa::plumbing::AsId;
+use smallvec::{SmallVec, smallvec};
+use std::fmt;
+use std::ops::ControlFlow;
+use syntax::ast::SelfParamKind;
+use triomphe::Arc;
+
+use rustc_ast_ir::visit::VisitorResult;
+use rustc_index::IndexVec;
+use rustc_type_ir::TypeVisitableExt;
+use rustc_type_ir::{
+    BoundVar, CollectAndApply, DebruijnIndex, GenericArgKind, RegionKind, TermKind, UniverseIndex,
+    Variance, WithCachedTypeInfo, elaborate,
+    inherent::{self, Const as _, Region as _, Ty as _},
+    ir_print, relate,
+};
+
+use crate::lower_nextsolver::{self, TyLoweringContext};
+use crate::method_resolution::{ALL_FLOAT_FPS, ALL_INT_FPS, TyFingerprint};
+use crate::next_solver::util::{ContainsTypeErrors, explicit_item_bounds, for_trait_impls};
+use crate::next_solver::{
+    CanonicalVarKind, FxIndexMap, InternedWrapperNoDebug, RegionAssumptions, SolverDefIds,
+};
+use crate::{ConstScalar, FnAbi, Interner, db::HirDatabase};
+
+use super::generics::generics;
+use super::util::sizedness_constraint_for_ty;
+use super::{
+    Binder, BoundExistentialPredicate, BoundExistentialPredicates, BoundTy, BoundTyKind, Clause,
+    Clauses, Const, ConstKind, ErrorGuaranteed, ExprConst, ExternalConstraints,
+    ExternalConstraintsData, GenericArg, GenericArgs, InternedClausesWrapper, ParamConst, ParamEnv,
+    ParamTy, PlaceholderConst, PlaceholderTy, PredefinedOpaques, PredefinedOpaquesData, Predicate,
+    PredicateKind, Term, Ty, TyKind, Tys, ValueConst,
+    abi::Safety,
+    fold::{BoundVarReplacer, BoundVarReplacerDelegate, FnMutDelegate},
+    generics::Generics,
+    mapping::ChalkToNextSolver,
+    region::{
+        BoundRegion, BoundRegionKind, EarlyParamRegion, LateParamRegion, PlaceholderRegion, Region,
+    },
+};
+use super::{ClauseKind, SolverDefId, Valtree};
+
+#[macro_export]
+#[doc(hidden)]
+macro_rules! _interned_vec_nolifetime_salsa {
+    ($name:ident, $ty:ty) => {
+        interned_vec_nolifetime_salsa!($name, $ty, nofold);
+
+        impl<'db> rustc_type_ir::TypeFoldable<DbInterner<'db>> for $name {
+            fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>(
+                self,
+                folder: &mut F,
+            ) -> Result<Self, F::Error> {
+                use rustc_type_ir::inherent::SliceLike as _;
+                let inner: smallvec::SmallVec<[_; 2]> =
+                    self.iter().map(|v| v.try_fold_with(folder)).collect::<Result<_, _>>()?;
+                Ok($name::new_(folder.cx().db(), inner))
+            }
+            fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(
+                self,
+                folder: &mut F,
+            ) -> Self {
+                use rustc_type_ir::inherent::SliceLike as _;
+                let inner: smallvec::SmallVec<[_; 2]> =
+                    self.iter().map(|v| v.fold_with(folder)).collect();
+                $name::new_(folder.cx().db(), inner)
+            }
+        }
+
+        impl<'db> rustc_type_ir::TypeVisitable<DbInterner<'db>> for $name {
+            fn visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>(
+                &self,
+                visitor: &mut V,
+            ) -> V::Result {
+                use rustc_ast_ir::visit::VisitorResult;
+                use rustc_type_ir::inherent::SliceLike as _;
+                rustc_ast_ir::walk_visitable_list!(visitor, self.as_slice().iter());
+                V::Result::output()
+            }
+        }
+    };
+    ($name:ident, $ty:ty, nofold) => {
+        #[salsa::interned(no_lifetime, constructor = new_, debug)]
+        pub struct $name {
+            #[returns(ref)]
+            inner_: smallvec::SmallVec<[$ty; 2]>,
+        }
+
+        impl $name {
+            pub fn new_from_iter<'db>(
+                interner: DbInterner<'db>,
+                data: impl IntoIterator<Item = $ty>,
+            ) -> Self {
+                $name::new_(interner.db(), data.into_iter().collect::<smallvec::SmallVec<[_; 2]>>())
+            }
+
+            pub fn inner(&self) -> &smallvec::SmallVec<[$ty; 2]> {
+                // SAFETY: ¯\_(ツ)_/¯
+                salsa::with_attached_database(|db| {
+                    let inner = self.inner_(db);
+                    unsafe { std::mem::transmute(inner) }
+                })
+                .unwrap()
+            }
+        }
+
+        impl rustc_type_ir::inherent::SliceLike for $name {
+            type Item = $ty;
+
+            type IntoIter = <smallvec::SmallVec<[$ty; 2]> as IntoIterator>::IntoIter;
+
+            fn iter(self) -> Self::IntoIter {
+                self.inner().clone().into_iter()
+            }
+
+            fn as_slice(&self) -> &[Self::Item] {
+                self.inner().as_slice()
+            }
+        }
+
+        impl IntoIterator for $name {
+            type Item = $ty;
+            type IntoIter = <Self as rustc_type_ir::inherent::SliceLike>::IntoIter;
+
+            fn into_iter(self) -> Self::IntoIter {
+                rustc_type_ir::inherent::SliceLike::iter(self)
+            }
+        }
+
+        impl Default for $name {
+            fn default() -> Self {
+                $name::new_from_iter(DbInterner::conjure(), [])
+            }
+        }
+    };
+}
+
+pub use crate::_interned_vec_nolifetime_salsa as interned_vec_nolifetime_salsa;
+
+#[macro_export]
+#[doc(hidden)]
+macro_rules! _interned_vec_db {
+    ($name:ident, $ty:ident) => {
+        interned_vec_db!($name, $ty, nofold);
+
+        impl<'db> rustc_type_ir::TypeFoldable<DbInterner<'db>> for $name<'db> {
+            fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>(
+                self,
+                folder: &mut F,
+            ) -> Result<Self, F::Error> {
+                use rustc_type_ir::inherent::SliceLike as _;
+                let inner: smallvec::SmallVec<[_; 2]> =
+                    self.iter().map(|v| v.try_fold_with(folder)).collect::<Result<_, _>>()?;
+                Ok($name::new_(folder.cx().db(), inner))
+            }
+            fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(
+                self,
+                folder: &mut F,
+            ) -> Self {
+                use rustc_type_ir::inherent::SliceLike as _;
+                let inner: smallvec::SmallVec<[_; 2]> =
+                    self.iter().map(|v| v.fold_with(folder)).collect();
+                $name::new_(folder.cx().db(), inner)
+            }
+        }
+
+        impl<'db> rustc_type_ir::TypeVisitable<DbInterner<'db>> for $name<'db> {
+            fn visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>(
+                &self,
+                visitor: &mut V,
+            ) -> V::Result {
+                use rustc_ast_ir::visit::VisitorResult;
+                use rustc_type_ir::inherent::SliceLike as _;
+                rustc_ast_ir::walk_visitable_list!(visitor, self.as_slice().iter());
+                V::Result::output()
+            }
+        }
+    };
+    ($name:ident, $ty:ident, nofold) => {
+        #[salsa::interned(constructor = new_)]
+        pub struct $name<'db> {
+            #[returns(ref)]
+            inner_: smallvec::SmallVec<[$ty<'db>; 2]>,
+        }
+
+        impl<'db> std::fmt::Debug for $name<'db> {
+            fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                self.as_slice().fmt(fmt)
+            }
+        }
+
+        impl<'db> $name<'db> {
+            pub fn new_from_iter(
+                interner: DbInterner<'db>,
+                data: impl IntoIterator<Item = $ty<'db>>,
+            ) -> Self {
+                $name::new_(interner.db(), data.into_iter().collect::<smallvec::SmallVec<[_; 2]>>())
+            }
+
+            pub fn inner(&self) -> &smallvec::SmallVec<[$ty<'db>; 2]> {
+                // SAFETY: ¯\_(ツ)_/¯
+                salsa::with_attached_database(|db| {
+                    let inner = self.inner_(db);
+                    unsafe { std::mem::transmute(inner) }
+                })
+                .unwrap()
+            }
+        }
+
+        impl<'db> rustc_type_ir::inherent::SliceLike for $name<'db> {
+            type Item = $ty<'db>;
+
+            type IntoIter = <smallvec::SmallVec<[$ty<'db>; 2]> as IntoIterator>::IntoIter;
+
+            fn iter(self) -> Self::IntoIter {
+                self.inner().clone().into_iter()
+            }
+
+            fn as_slice(&self) -> &[Self::Item] {
+                self.inner().as_slice()
+            }
+        }
+
+        impl<'db> IntoIterator for $name<'db> {
+            type Item = $ty<'db>;
+            type IntoIter = <Self as rustc_type_ir::inherent::SliceLike>::IntoIter;
+
+            fn into_iter(self) -> Self::IntoIter {
+                rustc_type_ir::inherent::SliceLike::iter(self)
+            }
+        }
+
+        impl<'db> Default for $name<'db> {
+            fn default() -> Self {
+                $name::new_from_iter(DbInterner::conjure(), [])
+            }
+        }
+    };
+}
+
+pub use crate::_interned_vec_db as interned_vec_db;
+
+#[derive(Debug, Copy, Clone)]
+pub struct DbInterner<'db> {
+    pub(crate) db: &'db dyn HirDatabase,
+    pub(crate) krate: Option<Crate>,
+    pub(crate) block: Option<BlockId>,
+}
+
+// FIXME: very wrong, see https://github.com/rust-lang/rust/pull/144808
+unsafe impl Send for DbInterner<'_> {}
+unsafe impl Sync for DbInterner<'_> {}
+
+impl<'db> DbInterner<'db> {
+    // FIXME(next-solver): remove this method
+    pub fn conjure() -> DbInterner<'db> {
+        salsa::with_attached_database(|db| DbInterner {
+            db: unsafe {
+                std::mem::transmute::<&dyn HirDatabase, &'db dyn HirDatabase>(db.as_view())
+            },
+            krate: None,
+            block: None,
+        })
+        .unwrap()
+    }
+
+    pub fn new_with(
+        db: &'db dyn HirDatabase,
+        krate: Option<Crate>,
+        block: Option<BlockId>,
+    ) -> DbInterner<'db> {
+        DbInterner { db, krate, block }
+    }
+
+    pub fn db(&self) -> &'db dyn HirDatabase {
+        self.db
+    }
+}
+
+// This is intentionally left as `()`
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+pub struct Span(());
+
+impl<'db> inherent::Span<DbInterner<'db>> for Span {
+    fn dummy() -> Self {
+        Span(())
+    }
+}
+
+interned_vec_nolifetime_salsa!(BoundVarKinds, BoundVarKind, nofold);
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub enum BoundVarKind {
+    Ty(BoundTyKind),
+    Region(BoundRegionKind),
+    Const,
+}
+
+impl BoundVarKind {
+    pub fn expect_region(self) -> BoundRegionKind {
+        match self {
+            BoundVarKind::Region(lt) => lt,
+            _ => panic!("expected a region, but found another kind"),
+        }
+    }
+
+    pub fn expect_ty(self) -> BoundTyKind {
+        match self {
+            BoundVarKind::Ty(ty) => ty,
+            _ => panic!("expected a type, but found another kind"),
+        }
+    }
+
+    pub fn expect_const(self) {
+        match self {
+            BoundVarKind::Const => (),
+            _ => panic!("expected a const, but found another kind"),
+        }
+    }
+}
+
+interned_vec_db!(CanonicalVars, CanonicalVarKind, nofold);
+
+pub struct DepNodeIndex;
+
+#[derive(Debug)]
+pub struct Tracked<T: fmt::Debug + Clone>(T);
+
+#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct Placeholder<T> {
+    pub universe: UniverseIndex,
+    pub bound: T,
+}
+
+impl<T: std::fmt::Debug> std::fmt::Debug for Placeholder<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> fmt::Result {
+        if self.universe == UniverseIndex::ROOT {
+            write!(f, "!{:?}", self.bound)
+        } else {
+            write!(f, "!{}_{:?}", self.universe.index(), self.bound)
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+pub struct AllocId;
+
+interned_vec_nolifetime_salsa!(VariancesOf, Variance, nofold);
+
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+pub struct VariantIdx(usize);
+
+// FIXME: could/should store actual data?
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+pub enum VariantDef {
+    Struct(StructId),
+    Union(UnionId),
+    Enum(EnumVariantId),
+}
+
+impl VariantDef {
+    pub fn id(&self) -> VariantId {
+        match self {
+            VariantDef::Struct(struct_id) => VariantId::StructId(*struct_id),
+            VariantDef::Union(union_id) => VariantId::UnionId(*union_id),
+            VariantDef::Enum(enum_variant_id) => VariantId::EnumVariantId(*enum_variant_id),
+        }
+    }
+
+    pub fn fields(&self, db: &dyn HirDatabase) -> Vec<(Idx<FieldData>, FieldData)> {
+        let id: VariantId = match self {
+            VariantDef::Struct(it) => (*it).into(),
+            VariantDef::Union(it) => (*it).into(),
+            VariantDef::Enum(it) => (*it).into(),
+        };
+        id.fields(db).fields().iter().map(|(id, data)| (id, data.clone())).collect()
+    }
+}
+
+/*
+/// Definition of a variant -- a struct's fields or an enum variant.
+#[derive(Debug, HashStable, TyEncodable, TyDecodable)]
+pub struct VariantDef {
+    /// `DefId` that identifies the variant itself.
+    /// If this variant belongs to a struct or union, then this is a copy of its `DefId`.
+    pub def_id: DefId,
+    /// `DefId` that identifies the variant's constructor.
+    /// If this variant is a struct variant, then this is `None`.
+    pub ctor: Option<(CtorKind, DefId)>,
+    /// Variant or struct name, maybe empty for anonymous adt (struct or union).
+    pub name: Symbol,
+    /// Discriminant of this variant.
+    pub discr: VariantDiscr,
+    /// Fields of this variant.
+    pub fields: IndexVec<FieldIdx, FieldDef>,
+    /// The error guarantees from parser, if any.
+    tainted: Option<ErrorGuaranteed>,
+    /// Flags of the variant (e.g. is field list non-exhaustive)?
+    flags: VariantFlags,
+}
+*/
+
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+pub struct AdtFlags {
+    is_enum: bool,
+    is_union: bool,
+    is_struct: bool,
+    is_phantom_data: bool,
+    is_fundamental: bool,
+    is_box: bool,
+    is_manually_drop: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct AdtDefInner {
+    pub id: AdtId,
+    variants: Vec<(VariantIdx, VariantDef)>,
+    flags: AdtFlags,
+    repr: ReprOptions,
+}
+
+// We're gonna cheat a little bit and implement `Hash` on only the `DefId` and
+// accept there might be collisions for def ids from different crates (or across
+// different tests, oh my).
+impl std::hash::Hash for AdtDefInner {
+    #[inline]
+    fn hash<H: std::hash::Hasher>(&self, s: &mut H) {
+        self.id.hash(s)
+    }
+}
+
+#[salsa::interned(no_lifetime, constructor = new_)]
+pub struct AdtDef {
+    #[returns(ref)]
+    data_: AdtDefInner,
+}
+
+impl AdtDef {
+    pub fn new<'db>(def_id: AdtId, interner: DbInterner<'db>) -> Self {
+        let db = interner.db();
+        let (flags, variants, repr) = match def_id {
+            AdtId::StructId(struct_id) => {
+                let data = db.struct_signature(struct_id);
+
+                let flags = AdtFlags {
+                    is_enum: false,
+                    is_union: false,
+                    is_struct: true,
+                    is_phantom_data: data.flags.contains(StructFlags::IS_PHANTOM_DATA),
+                    is_fundamental: data.flags.contains(StructFlags::FUNDAMENTAL),
+                    is_box: data.flags.contains(StructFlags::IS_BOX),
+                    is_manually_drop: data.flags.contains(StructFlags::IS_MANUALLY_DROP),
+                };
+
+                let variants = vec![(VariantIdx(0), VariantDef::Struct(struct_id))];
+
+                let mut repr = ReprOptions::default();
+                repr.align = data.repr.and_then(|r| r.align);
+                repr.pack = data.repr.and_then(|r| r.pack);
+                repr.int = data.repr.and_then(|r| r.int);
+
+                let mut repr_flags = ReprFlags::empty();
+                if flags.is_box {
+                    repr_flags.insert(ReprFlags::IS_LINEAR);
+                }
+                if data.repr.is_some_and(|r| r.c()) {
+                    repr_flags.insert(ReprFlags::IS_C);
+                }
+                if data.repr.is_some_and(|r| r.simd()) {
+                    repr_flags.insert(ReprFlags::IS_SIMD);
+                }
+                repr.flags = repr_flags;
+
+                (flags, variants, repr)
+            }
+            AdtId::UnionId(union_id) => {
+                let data = db.union_signature(union_id);
+
+                let flags = AdtFlags {
+                    is_enum: false,
+                    is_union: true,
+                    is_struct: false,
+                    is_phantom_data: false,
+                    is_fundamental: false,
+                    is_box: false,
+                    is_manually_drop: false,
+                };
+
+                let variants = vec![(VariantIdx(0), VariantDef::Union(union_id))];
+
+                let mut repr = ReprOptions::default();
+                repr.align = data.repr.and_then(|r| r.align);
+                repr.pack = data.repr.and_then(|r| r.pack);
+                repr.int = data.repr.and_then(|r| r.int);
+
+                let mut repr_flags = ReprFlags::empty();
+                if flags.is_box {
+                    repr_flags.insert(ReprFlags::IS_LINEAR);
+                }
+                if data.repr.is_some_and(|r| r.c()) {
+                    repr_flags.insert(ReprFlags::IS_C);
+                }
+                if data.repr.is_some_and(|r| r.simd()) {
+                    repr_flags.insert(ReprFlags::IS_SIMD);
+                }
+                repr.flags = repr_flags;
+
+                (flags, variants, repr)
+            }
+            AdtId::EnumId(enum_id) => {
+                let flags = AdtFlags {
+                    is_enum: true,
+                    is_union: false,
+                    is_struct: false,
+                    is_phantom_data: false,
+                    is_fundamental: false,
+                    is_box: false,
+                    is_manually_drop: false,
+                };
+
+                let variants = enum_id
+                    .enum_variants(db)
+                    .variants
+                    .iter()
+                    .enumerate()
+                    .map(|(idx, v)| (VariantIdx(idx), v))
+                    .map(|(idx, v)| (idx, VariantDef::Enum(v.0)))
+                    .collect();
+
+                let data = db.enum_signature(enum_id);
+
+                let mut repr = ReprOptions::default();
+                repr.align = data.repr.and_then(|r| r.align);
+                repr.pack = data.repr.and_then(|r| r.pack);
+                repr.int = data.repr.and_then(|r| r.int);
+
+                let mut repr_flags = ReprFlags::empty();
+                if flags.is_box {
+                    repr_flags.insert(ReprFlags::IS_LINEAR);
+                }
+                if data.repr.is_some_and(|r| r.c()) {
+                    repr_flags.insert(ReprFlags::IS_C);
+                }
+                if data.repr.is_some_and(|r| r.simd()) {
+                    repr_flags.insert(ReprFlags::IS_SIMD);
+                }
+                repr.flags = repr_flags;
+
+                (flags, variants, repr)
+            }
+        };
+
+        AdtDef::new_(db, AdtDefInner { id: def_id, variants, flags, repr })
+    }
+
+    pub fn inner(&self) -> &AdtDefInner {
+        salsa::with_attached_database(|db| {
+            let inner = self.data_(db);
+            // SAFETY: ¯\_(ツ)_/¯
+            unsafe { std::mem::transmute(inner) }
+        })
+        .unwrap()
+    }
+
+    pub fn is_enum(&self) -> bool {
+        self.inner().flags.is_enum
+    }
+
+    #[inline]
+    pub fn repr(self) -> ReprOptions {
+        self.inner().repr
+    }
+
+    /// Asserts this is a struct or union and returns its unique variant.
+    pub fn non_enum_variant(self) -> VariantDef {
+        assert!(self.inner().flags.is_struct || self.inner().flags.is_union);
+        self.inner().variants[0].1.clone()
+    }
+}
+
+impl<'db> inherent::AdtDef<DbInterner<'db>> for AdtDef {
+    fn def_id(self) -> <DbInterner<'db> as rustc_type_ir::Interner>::DefId {
+        SolverDefId::AdtId(self.inner().id)
+    }
+
+    fn is_struct(self) -> bool {
+        self.inner().flags.is_struct
+    }
+
+    fn is_phantom_data(self) -> bool {
+        self.inner().flags.is_phantom_data
+    }
+
+    fn is_fundamental(self) -> bool {
+        self.inner().flags.is_fundamental
+    }
+
+    fn struct_tail_ty(
+        self,
+        interner: DbInterner<'db>,
+    ) -> Option<
+        rustc_type_ir::EarlyBinder<
+            DbInterner<'db>,
+            <DbInterner<'db> as rustc_type_ir::Interner>::Ty,
+        >,
+    > {
+        let db = interner.db();
+        let hir_def::AdtId::StructId(struct_id) = self.inner().id else {
+            return None;
+        };
+        let id: VariantId = struct_id.into();
+        let field_types = interner.db().field_types_ns(id);
+
+        field_types.iter().last().map(|f| *f.1)
+    }
+
+    fn all_field_tys(
+        self,
+        interner: DbInterner<'db>,
+    ) -> rustc_type_ir::EarlyBinder<
+        DbInterner<'db>,
+        impl IntoIterator<Item = <DbInterner<'db> as rustc_type_ir::Interner>::Ty>,
+    > {
+        let db = interner.db();
+        // FIXME: this is disabled just to match the behavior with chalk right now
+        let field_tys = |id: VariantId| {
+            let variant_data = id.fields(db);
+            let fields = if variant_data.fields().is_empty() {
+                vec![]
+            } else {
+                let field_types = db.field_types_ns(id);
+                variant_data
+                    .fields()
+                    .iter()
+                    .map(|(idx, _)| {
+                        let ty = field_types[idx];
+                        ty.skip_binder()
+                    })
+                    .collect()
+            };
+        };
+        let field_tys = |id: VariantId| vec![];
+        let tys: Vec<_> = match self.inner().id {
+            hir_def::AdtId::StructId(id) => field_tys(id.into()),
+            hir_def::AdtId::UnionId(id) => field_tys(id.into()),
+            hir_def::AdtId::EnumId(id) => id
+                .enum_variants(db)
+                .variants
+                .iter()
+                .flat_map(|&(variant_id, _, _)| field_tys(variant_id.into()))
+                .collect(),
+        };
+
+        rustc_type_ir::EarlyBinder::bind(tys)
+    }
+
+    fn sizedness_constraint(
+        self,
+        interner: DbInterner<'db>,
+        sizedness: SizedTraitKind,
+    ) -> Option<
+        rustc_type_ir::EarlyBinder<
+            DbInterner<'db>,
+            <DbInterner<'db> as rustc_type_ir::Interner>::Ty,
+        >,
+    > {
+        if self.is_struct() {
+            let tail_ty = self.all_field_tys(interner).skip_binder().into_iter().last()?;
+
+            let constraint_ty = sizedness_constraint_for_ty(interner, sizedness, tail_ty)?;
+
+            Some(EarlyBinder::bind(constraint_ty))
+        } else {
+            None
+        }
+    }
+
+    fn destructor(
+        self,
+        interner: DbInterner<'db>,
+    ) -> Option<rustc_type_ir::solve::AdtDestructorKind> {
+        // FIXME(next-solver)
+        None
+    }
+
+    fn is_manually_drop(self) -> bool {
+        self.inner().flags.is_manually_drop
+    }
+}
+
+impl fmt::Debug for AdtDef {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        salsa::with_attached_database(|db| match self.inner().id {
+            AdtId::StructId(struct_id) => {
+                let data = db.as_view::<dyn HirDatabase>().struct_signature(struct_id);
+                f.write_str(data.name.as_str())
+            }
+            AdtId::UnionId(union_id) => {
+                let data = db.as_view::<dyn HirDatabase>().union_signature(union_id);
+                f.write_str(data.name.as_str())
+            }
+            AdtId::EnumId(enum_id) => {
+                let data = db.as_view::<dyn HirDatabase>().enum_signature(enum_id);
+                f.write_str(data.name.as_str())
+            }
+        })
+        .unwrap_or_else(|| f.write_str(&format!("AdtDef({:?})", self.inner().id)))
+    }
+}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub struct Features;
+
+impl<'db> inherent::Features<DbInterner<'db>> for Features {
+    fn generic_const_exprs(self) -> bool {
+        false
+    }
+
+    fn coroutine_clone(self) -> bool {
+        false
+    }
+
+    fn associated_const_equality(self) -> bool {
+        false
+    }
+
+    fn feature_bound_holds_in_crate(self, symbol: ()) -> bool {
+        false
+    }
+}
+
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+pub struct UnsizingParams(pub(crate) DenseBitSet<u32>);
+
+impl std::ops::Deref for UnsizingParams {
+    type Target = DenseBitSet<u32>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+pub type PatternKind<'db> = rustc_type_ir::PatternKind<DbInterner<'db>>;
+
+#[salsa::interned(constructor = new_, debug)]
+pub struct Pattern<'db> {
+    #[returns(ref)]
+    kind_: InternedWrapperNoDebug<PatternKind<'db>>,
+}
+
+impl<'db> std::fmt::Debug for InternedWrapperNoDebug<PatternKind<'db>> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl<'db> Pattern<'db> {
+    pub fn new(interner: DbInterner<'db>, kind: PatternKind<'db>) -> Self {
+        Pattern::new_(interner.db(), InternedWrapperNoDebug(kind))
+    }
+
+    pub fn inner(&self) -> &PatternKind<'db> {
+        salsa::with_attached_database(|db| {
+            let inner = &self.kind_(db).0;
+            // SAFETY: The caller already has access to a `Ty<'db>`, so borrowchecking will
+            // make sure that our returned value is valid for the lifetime `'db`.
+            unsafe { std::mem::transmute(inner) }
+        })
+        .unwrap()
+    }
+}
+
+impl<'db> Flags for Pattern<'db> {
+    fn flags(&self) -> rustc_type_ir::TypeFlags {
+        match self.inner() {
+            PatternKind::Range { start, end } => {
+                FlagComputation::for_const_kind(&start.kind()).flags
+                    | FlagComputation::for_const_kind(&end.kind()).flags
+            }
+            PatternKind::Or(pats) => {
+                let mut flags = pats.as_slice()[0].flags();
+                for pat in pats.as_slice()[1..].iter() {
+                    flags |= pat.flags();
+                }
+                flags
+            }
+        }
+    }
+
+    fn outer_exclusive_binder(&self) -> rustc_type_ir::DebruijnIndex {
+        match self.inner() {
+            PatternKind::Range { start, end } => {
+                start.outer_exclusive_binder().max(end.outer_exclusive_binder())
+            }
+            PatternKind::Or(pats) => {
+                let mut idx = pats.as_slice()[0].outer_exclusive_binder();
+                for pat in pats.as_slice()[1..].iter() {
+                    idx = idx.max(pat.outer_exclusive_binder());
+                }
+                idx
+            }
+        }
+    }
+}
+
+impl<'db> rustc_type_ir::inherent::IntoKind for Pattern<'db> {
+    type Kind = rustc_type_ir::PatternKind<DbInterner<'db>>;
+    fn kind(self) -> Self::Kind {
+        *self.inner()
+    }
+}
+
+impl<'db> rustc_type_ir::relate::Relate<DbInterner<'db>> for Pattern<'db> {
+    fn relate<R: rustc_type_ir::relate::TypeRelation<DbInterner<'db>>>(
+        relation: &mut R,
+        a: Self,
+        b: Self,
+    ) -> rustc_type_ir::relate::RelateResult<DbInterner<'db>, Self> {
+        let tcx = relation.cx();
+        match (a.kind(), b.kind()) {
+            (
+                PatternKind::Range { start: start_a, end: end_a },
+                PatternKind::Range { start: start_b, end: end_b },
+            ) => {
+                let start = relation.relate(start_a, start_b)?;
+                let end = relation.relate(end_a, end_b)?;
+                Ok(Pattern::new(tcx, PatternKind::Range { start, end }))
+            }
+            (PatternKind::Or(a), PatternKind::Or(b)) => {
+                if a.len() != b.len() {
+                    return Err(TypeError::Mismatch);
+                }
+                let pats = CollectAndApply::collect_and_apply(
+                    std::iter::zip(a.iter(), b.iter()).map(|(a, b)| relation.relate(a, b)),
+                    |g| PatList::new_from_iter(tcx, g.iter().cloned()),
+                )?;
+                Ok(Pattern::new(tcx, PatternKind::Or(pats)))
+            }
+            (PatternKind::Range { .. } | PatternKind::Or(_), _) => Err(TypeError::Mismatch),
+        }
+    }
+}
+
+interned_vec_db!(PatList, Pattern);
+
+impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
+    type DefId = SolverDefId;
+    type LocalDefId = SolverDefId;
+    type LocalDefIds = SolverDefIds;
+    type Span = Span;
+
+    type GenericArgs = GenericArgs<'db>;
+    type GenericArgsSlice = GenericArgs<'db>;
+    type GenericArg = GenericArg<'db>;
+
+    type Term = Term<'db>;
+
+    type BoundVarKinds = BoundVarKinds;
+    type BoundVarKind = BoundVarKind;
+
+    type PredefinedOpaques = PredefinedOpaques<'db>;
+
+    fn mk_predefined_opaques_in_body(
+        self,
+        data: rustc_type_ir::solve::PredefinedOpaquesData<Self>,
+    ) -> Self::PredefinedOpaques {
+        PredefinedOpaques::new(self, data)
+    }
+
+    type CanonicalVarKinds = CanonicalVars<'db>;
+
+    fn mk_canonical_var_kinds(
+        self,
+        kinds: &[rustc_type_ir::CanonicalVarKind<Self>],
+    ) -> Self::CanonicalVarKinds {
+        CanonicalVars::new_from_iter(self, kinds.iter().cloned())
+    }
+
+    type ExternalConstraints = ExternalConstraints<'db>;
+
+    fn mk_external_constraints(
+        self,
+        data: rustc_type_ir::solve::ExternalConstraintsData<Self>,
+    ) -> Self::ExternalConstraints {
+        ExternalConstraints::new(self, data)
+    }
+
+    type DepNodeIndex = DepNodeIndex;
+
+    type Tracked<T: fmt::Debug + Clone> = Tracked<T>;
+
+    type Ty = Ty<'db>;
+    type Tys = Tys<'db>;
+    type FnInputTys = Tys<'db>;
+    type ParamTy = ParamTy;
+    type BoundTy = BoundTy;
+    type PlaceholderTy = PlaceholderTy;
+    type Symbol = ();
+
+    type ErrorGuaranteed = ErrorGuaranteed;
+    type BoundExistentialPredicates = BoundExistentialPredicates<'db>;
+    type AllocId = AllocId;
+    type Pat = Pattern<'db>;
+    type PatList = PatList<'db>;
+    type Safety = Safety;
+    type Abi = FnAbi;
+
+    type Const = Const<'db>;
+    type PlaceholderConst = PlaceholderConst;
+    type ParamConst = ParamConst;
+    type BoundConst = rustc_type_ir::BoundVar;
+    type ValueConst = ValueConst<'db>;
+    type ValTree = Valtree<'db>;
+    type ExprConst = ExprConst;
+
+    type Region = Region<'db>;
+    type EarlyParamRegion = EarlyParamRegion;
+    type LateParamRegion = LateParamRegion;
+    type BoundRegion = BoundRegion;
+    type PlaceholderRegion = PlaceholderRegion;
+
+    type RegionAssumptions = RegionAssumptions<'db>;
+
+    type ParamEnv = ParamEnv<'db>;
+    type Predicate = Predicate<'db>;
+    type Clause = Clause<'db>;
+    type Clauses = Clauses<'db>;
+
+    type GenericsOf = Generics;
+
+    type VariancesOf = VariancesOf;
+
+    type AdtDef = AdtDef;
+
+    type Features = Features;
+
+    fn mk_args(self, args: &[Self::GenericArg]) -> Self::GenericArgs {
+        GenericArgs::new_from_iter(self, args.iter().cloned())
+    }
+
+    fn mk_args_from_iter<I, T>(self, args: I) -> T::Output
+    where
+        I: Iterator<Item = T>,
+        T: rustc_type_ir::CollectAndApply<Self::GenericArg, Self::GenericArgs>,
+    {
+        CollectAndApply::collect_and_apply(args, |g| {
+            GenericArgs::new_from_iter(self, g.iter().cloned())
+        })
+    }
+
+    type UnsizingParams = UnsizingParams;
+
+    fn mk_tracked<T: fmt::Debug + Clone>(
+        self,
+        data: T,
+        dep_node: Self::DepNodeIndex,
+    ) -> Self::Tracked<T> {
+        Tracked(data)
+    }
+
+    fn get_tracked<T: fmt::Debug + Clone>(self, tracked: &Self::Tracked<T>) -> T {
+        tracked.0.clone()
+    }
+
+    fn with_cached_task<T>(self, task: impl FnOnce() -> T) -> (T, Self::DepNodeIndex) {
+        (task(), DepNodeIndex)
+    }
+
+    fn with_global_cache<R>(
+        self,
+        f: impl FnOnce(&mut rustc_type_ir::search_graph::GlobalCache<Self>) -> R,
+    ) -> R {
+        salsa::with_attached_database(|db| {
+            tls_cache::with_cache(
+                unsafe {
+                    std::mem::transmute::<&dyn HirDatabase, &'db dyn HirDatabase>(
+                        db.as_view::<dyn HirDatabase>(),
+                    )
+                },
+                f,
+            )
+        })
+        .unwrap()
+    }
+
+    fn canonical_param_env_cache_get_or_insert<R>(
+        self,
+        param_env: Self::ParamEnv,
+        f: impl FnOnce() -> rustc_type_ir::CanonicalParamEnvCacheEntry<Self>,
+        from_entry: impl FnOnce(&rustc_type_ir::CanonicalParamEnvCacheEntry<Self>) -> R,
+    ) -> R {
+        from_entry(&f())
+    }
+
+    fn evaluation_is_concurrent(&self) -> bool {
+        false
+    }
+
+    fn expand_abstract_consts<T: rustc_type_ir::TypeFoldable<Self>>(self, t: T) -> T {
+        t
+    }
+
+    fn generics_of(self, def_id: Self::DefId) -> Self::GenericsOf {
+        generics(self.db(), def_id)
+    }
+
+    fn variances_of(self, def_id: Self::DefId) -> Self::VariancesOf {
+        match def_id {
+            SolverDefId::FunctionId(def_id) => VariancesOf::new_from_iter(
+                self,
+                self.db()
+                    .variances_of(hir_def::GenericDefId::FunctionId(def_id))
+                    .as_deref()
+                    .unwrap_or_default()
+                    .iter()
+                    .map(|v| v.to_nextsolver(self)),
+            ),
+            SolverDefId::AdtId(def_id) => VariancesOf::new_from_iter(
+                self,
+                self.db()
+                    .variances_of(hir_def::GenericDefId::AdtId(def_id))
+                    .as_deref()
+                    .unwrap_or_default()
+                    .iter()
+                    .map(|v| v.to_nextsolver(self)),
+            ),
+            SolverDefId::InternedOpaqueTyId(_def_id) => {
+                // FIXME(next-solver): track variances
+                VariancesOf::new_from_iter(
+                    self,
+                    (0..self.generics_of(def_id).count()).map(|_| Variance::Invariant),
+                )
+            }
+            _ => VariancesOf::new_from_iter(self, []),
+        }
+    }
+
+    fn type_of(self, def_id: Self::DefId) -> rustc_type_ir::EarlyBinder<Self, Self::Ty> {
+        let def_id = match def_id {
+            SolverDefId::TypeAliasId(id) => {
+                use hir_def::Lookup;
+                match id.lookup(self.db()).container {
+                    ItemContainerId::ImplId(it) => it,
+                    _ => panic!("assoc ty value should be in impl"),
+                };
+                crate::TyDefId::TypeAliasId(id)
+            }
+            SolverDefId::AdtId(id) => crate::TyDefId::AdtId(id),
+            _ => panic!("Unexpected def_id `{def_id:?}` provided for `type_of`"),
+        };
+        self.db().ty_ns(def_id)
+    }
+
+    fn adt_def(self, adt_def_id: Self::DefId) -> Self::AdtDef {
+        let def_id = match adt_def_id {
+            SolverDefId::AdtId(adt_id) => adt_id,
+            _ => panic!("Invalid DefId passed to adt_def"),
+        };
+        AdtDef::new(def_id, self)
+    }
+
+    fn alias_ty_kind(self, alias: rustc_type_ir::AliasTy<Self>) -> rustc_type_ir::AliasTyKind {
+        // FIXME: not currently creating any others
+        rustc_type_ir::AliasTyKind::Projection
+    }
+
+    fn alias_term_kind(
+        self,
+        alias: rustc_type_ir::AliasTerm<Self>,
+    ) -> rustc_type_ir::AliasTermKind {
+        match alias.def_id {
+            SolverDefId::InternedOpaqueTyId(_) => AliasTermKind::OpaqueTy,
+            SolverDefId::TypeAliasId(_) => AliasTermKind::ProjectionTy,
+            SolverDefId::ConstId(_) => AliasTermKind::UnevaluatedConst,
+            _ => unreachable!("Unexpected alias: {:?}", alias.def_id),
+        }
+    }
+
+    fn trait_ref_and_own_args_for_alias(
+        self,
+        def_id: Self::DefId,
+        args: Self::GenericArgs,
+    ) -> (rustc_type_ir::TraitRef<Self>, Self::GenericArgsSlice) {
+        let trait_def_id = self.parent(def_id);
+        let trait_generics = self.generics_of(trait_def_id);
+        let trait_args = GenericArgs::new_from_iter(
+            self,
+            args.as_slice()[0..trait_generics.own_params.len()].iter().cloned(),
+        );
+        let alias_args =
+            GenericArgs::new_from_iter(self, args.iter().skip(trait_generics.own_params.len()));
+        (TraitRef::new_from_args(self, trait_def_id, trait_args), alias_args)
+    }
+
+    fn check_args_compatible(self, def_id: Self::DefId, args: Self::GenericArgs) -> bool {
+        // FIXME
+        true
+    }
+
+    fn debug_assert_args_compatible(self, def_id: Self::DefId, args: Self::GenericArgs) {}
+
+    fn debug_assert_existential_args_compatible(
+        self,
+        def_id: Self::DefId,
+        args: Self::GenericArgs,
+    ) {
+    }
+
+    fn mk_type_list_from_iter<I, T>(self, args: I) -> T::Output
+    where
+        I: Iterator<Item = T>,
+        T: rustc_type_ir::CollectAndApply<Self::Ty, Self::Tys>,
+    {
+        CollectAndApply::collect_and_apply(args, |g| Tys::new_from_iter(self, g.iter().cloned()))
+    }
+
+    fn parent(self, def_id: Self::DefId) -> Self::DefId {
+        use hir_def::Lookup;
+
+        let container = match def_id {
+            SolverDefId::FunctionId(it) => it.lookup(self.db()).container,
+            SolverDefId::TypeAliasId(it) => it.lookup(self.db()).container,
+            SolverDefId::ForeignId(it) => it.lookup(self.db()).container,
+            SolverDefId::ConstId(it) => it.lookup(self.db()).container,
+            SolverDefId::InternedClosureId(it) => {
+                return self
+                    .db()
+                    .lookup_intern_closure(it)
+                    .0
+                    .as_generic_def_id(self.db())
+                    .unwrap()
+                    .into();
+            }
+            SolverDefId::InternedCoroutineId(it) => {
+                return self
+                    .db()
+                    .lookup_intern_coroutine(it)
+                    .0
+                    .as_generic_def_id(self.db())
+                    .unwrap()
+                    .into();
+            }
+            SolverDefId::StaticId(_)
+            | SolverDefId::AdtId(_)
+            | SolverDefId::TraitId(_)
+            | SolverDefId::ImplId(_)
+            | SolverDefId::TraitAliasId(_)
+            | SolverDefId::Ctor(..)
+            | SolverDefId::InternedOpaqueTyId(..) => panic!(),
+        };
+
+        match container {
+            ItemContainerId::ImplId(it) => it.into(),
+            ItemContainerId::TraitId(it) => it.into(),
+            ItemContainerId::ModuleId(_) | ItemContainerId::ExternBlockId(_) => panic!(),
+        }
+    }
+
+    fn recursion_limit(self) -> usize {
+        50
+    }
+
+    fn features(self) -> Self::Features {
+        Features
+    }
+
+    fn fn_sig(
+        self,
+        def_id: Self::DefId,
+    ) -> rustc_type_ir::EarlyBinder<Self, rustc_type_ir::Binder<Self, rustc_type_ir::FnSig<Self>>>
+    {
+        let id = match def_id {
+            SolverDefId::FunctionId(id) => CallableDefId::FunctionId(id),
+            SolverDefId::Ctor(ctor) => match ctor {
+                super::Ctor::Struct(struct_id) => CallableDefId::StructId(struct_id),
+                super::Ctor::Enum(enum_variant_id) => CallableDefId::EnumVariantId(enum_variant_id),
+            },
+            def => unreachable!("{:?}", def),
+        };
+        self.db().callable_item_signature_ns(id)
+    }
+
+    fn coroutine_movability(self, def_id: Self::DefId) -> rustc_ast_ir::Movability {
+        unimplemented!()
+    }
+
+    fn coroutine_for_closure(self, def_id: Self::DefId) -> Self::DefId {
+        unimplemented!()
+    }
+
+    fn generics_require_sized_self(self, def_id: Self::DefId) -> bool {
+        let sized_trait =
+            LangItem::Sized.resolve_trait(self.db(), self.krate.expect("Must have self.krate"));
+        let Some(sized_id) = sized_trait else {
+            return false; /* No Sized trait, can't require it! */
+        };
+        let sized_def_id = sized_id.into();
+
+        // Search for a predicate like `Self : Sized` amongst the trait bounds.
+        let predicates = self.predicates_of(def_id);
+        elaborate(self, predicates.iter_identity()).any(|pred| match pred.kind().skip_binder() {
+            ClauseKind::Trait(ref trait_pred) => {
+                trait_pred.def_id() == sized_def_id
+                    && matches!(
+                        trait_pred.self_ty().kind(),
+                        TyKind::Param(ParamTy { index: 0, .. })
+                    )
+            }
+            ClauseKind::RegionOutlives(_)
+            | ClauseKind::TypeOutlives(_)
+            | ClauseKind::Projection(_)
+            | ClauseKind::ConstArgHasType(_, _)
+            | ClauseKind::WellFormed(_)
+            | ClauseKind::ConstEvaluatable(_)
+            | ClauseKind::HostEffect(..)
+            | ClauseKind::UnstableFeature(_) => false,
+        })
+    }
+
+    #[tracing::instrument(skip(self), ret)]
+    fn item_bounds(
+        self,
+        def_id: Self::DefId,
+    ) -> rustc_type_ir::EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>> {
+        explicit_item_bounds(self, def_id).map_bound(|bounds| {
+            Clauses::new_from_iter(self, elaborate(self, bounds).collect::<Vec<_>>())
+        })
+    }
+
+    #[tracing::instrument(skip(self), ret)]
+    fn item_self_bounds(
+        self,
+        def_id: Self::DefId,
+    ) -> rustc_type_ir::EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>> {
+        explicit_item_bounds(self, def_id).map_bound(|bounds| {
+            Clauses::new_from_iter(
+                self,
+                elaborate(self, bounds).filter_only_self().collect::<Vec<_>>(),
+            )
+        })
+    }
+
+    fn item_non_self_bounds(
+        self,
+        def_id: Self::DefId,
+    ) -> rustc_type_ir::EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>> {
+        let all_bounds: FxHashSet<_> = self.item_bounds(def_id).skip_binder().into_iter().collect();
+        let own_bounds: FxHashSet<_> =
+            self.item_self_bounds(def_id).skip_binder().into_iter().collect();
+        if all_bounds.len() == own_bounds.len() {
+            EarlyBinder::bind(Clauses::new_from_iter(self, []))
+        } else {
+            EarlyBinder::bind(Clauses::new_from_iter(
+                self,
+                all_bounds.difference(&own_bounds).cloned(),
+            ))
+        }
+    }
+
+    #[tracing::instrument(level = "debug", skip(self), ret)]
+    fn predicates_of(
+        self,
+        def_id: Self::DefId,
+    ) -> rustc_type_ir::EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>> {
+        let predicates = self.db().generic_predicates_ns(def_id.try_into().unwrap());
+        let predicates: Vec<_> = predicates.iter().cloned().collect();
+        EarlyBinder::bind(predicates.into_iter())
+    }
+
+    #[tracing::instrument(level = "debug", skip(self), ret)]
+    fn own_predicates_of(
+        self,
+        def_id: Self::DefId,
+    ) -> rustc_type_ir::EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>> {
+        let predicates = self.db().generic_predicates_without_parent_ns(def_id.try_into().unwrap());
+        let predicates: Vec<_> = predicates.iter().cloned().collect();
+        EarlyBinder::bind(predicates.into_iter())
+    }
+
+    #[tracing::instrument(skip(self), ret)]
+    fn explicit_super_predicates_of(
+        self,
+        def_id: Self::DefId,
+    ) -> rustc_type_ir::EarlyBinder<Self, impl IntoIterator<Item = (Self::Clause, Self::Span)>>
+    {
+        let predicates: Vec<(Clause<'db>, Span)> = self
+            .db()
+            .generic_predicates_ns(def_id.try_into().unwrap())
+            .iter()
+            .cloned()
+            .map(|p| (p, Span::dummy()))
+            .collect();
+        rustc_type_ir::EarlyBinder::bind(predicates)
+    }
+
+    #[tracing::instrument(skip(self), ret)]
+    fn explicit_implied_predicates_of(
+        self,
+        def_id: Self::DefId,
+    ) -> rustc_type_ir::EarlyBinder<Self, impl IntoIterator<Item = (Self::Clause, Self::Span)>>
+    {
+        let predicates: Vec<(Clause<'db>, Span)> = self
+            .db()
+            .generic_predicates_ns(def_id.try_into().unwrap())
+            .iter()
+            .cloned()
+            .map(|p| (p, Span::dummy()))
+            .collect();
+        rustc_type_ir::EarlyBinder::bind(predicates)
+    }
+
+    fn impl_super_outlives(
+        self,
+        impl_def_id: Self::DefId,
+    ) -> rustc_type_ir::EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>> {
+        let impl_id = match impl_def_id {
+            SolverDefId::ImplId(id) => id,
+            _ => unreachable!(),
+        };
+        let trait_ref = self.db().impl_trait_ns(impl_id).expect("expected an impl of trait");
+        trait_ref.map_bound(|trait_ref| {
+            let clause: Clause<'_> = trait_ref.upcast(self);
+            Clauses::new_from_iter(
+                self,
+                rustc_type_ir::elaborate::elaborate(self, [clause]).filter(|clause| {
+                    matches!(
+                        clause.kind().skip_binder(),
+                        ClauseKind::TypeOutlives(_) | ClauseKind::RegionOutlives(_)
+                    )
+                }),
+            )
+        })
+    }
+
+    fn const_conditions(
+        self,
+        def_id: Self::DefId,
+    ) -> rustc_type_ir::EarlyBinder<
+        Self,
+        impl IntoIterator<Item = rustc_type_ir::Binder<Self, rustc_type_ir::TraitRef<Self>>>,
+    > {
+        rustc_type_ir::EarlyBinder::bind([unimplemented!()])
+    }
+
+    fn has_target_features(self, def_id: Self::DefId) -> bool {
+        false
+    }
+
+    fn require_lang_item(
+        self,
+        lang_item: rustc_type_ir::lang_items::TraitSolverLangItem,
+    ) -> Self::DefId {
+        let lang_item = match lang_item {
+            rustc_type_ir::lang_items::TraitSolverLangItem::AsyncFn => LangItem::AsyncFn,
+            rustc_type_ir::lang_items::TraitSolverLangItem::AsyncFnKindHelper => unimplemented!(),
+            rustc_type_ir::lang_items::TraitSolverLangItem::AsyncFnKindUpvars => unimplemented!(),
+            rustc_type_ir::lang_items::TraitSolverLangItem::AsyncFnMut => LangItem::AsyncFnMut,
+            rustc_type_ir::lang_items::TraitSolverLangItem::AsyncFnOnce => LangItem::AsyncFnOnce,
+            rustc_type_ir::lang_items::TraitSolverLangItem::AsyncFnOnceOutput => {
+                LangItem::AsyncFnOnceOutput
+            }
+            rustc_type_ir::lang_items::TraitSolverLangItem::AsyncIterator => unimplemented!(),
+            rustc_type_ir::lang_items::TraitSolverLangItem::CallOnceFuture => {
+                LangItem::CallOnceFuture
+            }
+            rustc_type_ir::lang_items::TraitSolverLangItem::CallRefFuture => {
+                LangItem::CallRefFuture
+            }
+            rustc_type_ir::lang_items::TraitSolverLangItem::Clone => LangItem::Clone,
+            rustc_type_ir::lang_items::TraitSolverLangItem::Copy => LangItem::Copy,
+            rustc_type_ir::lang_items::TraitSolverLangItem::Coroutine => LangItem::Coroutine,
+            rustc_type_ir::lang_items::TraitSolverLangItem::CoroutineReturn => {
+                LangItem::CoroutineReturn
+            }
+            rustc_type_ir::lang_items::TraitSolverLangItem::CoroutineYield => {
+                LangItem::CoroutineYield
+            }
+            rustc_type_ir::lang_items::TraitSolverLangItem::Destruct => LangItem::Destruct,
+            rustc_type_ir::lang_items::TraitSolverLangItem::DiscriminantKind => {
+                LangItem::DiscriminantKind
+            }
+            rustc_type_ir::lang_items::TraitSolverLangItem::Drop => LangItem::Drop,
+            rustc_type_ir::lang_items::TraitSolverLangItem::DynMetadata => LangItem::DynMetadata,
+            rustc_type_ir::lang_items::TraitSolverLangItem::Fn => LangItem::Fn,
+            rustc_type_ir::lang_items::TraitSolverLangItem::FnMut => LangItem::FnMut,
+            rustc_type_ir::lang_items::TraitSolverLangItem::FnOnce => LangItem::FnOnce,
+            rustc_type_ir::lang_items::TraitSolverLangItem::FnPtrTrait => LangItem::FnPtrTrait,
+            rustc_type_ir::lang_items::TraitSolverLangItem::FusedIterator => unimplemented!(),
+            rustc_type_ir::lang_items::TraitSolverLangItem::Future => LangItem::Future,
+            rustc_type_ir::lang_items::TraitSolverLangItem::FutureOutput => LangItem::FutureOutput,
+            rustc_type_ir::lang_items::TraitSolverLangItem::Iterator => LangItem::Iterator,
+            rustc_type_ir::lang_items::TraitSolverLangItem::Metadata => LangItem::Metadata,
+            rustc_type_ir::lang_items::TraitSolverLangItem::Option => LangItem::Option,
+            rustc_type_ir::lang_items::TraitSolverLangItem::PointeeTrait => LangItem::PointeeTrait,
+            rustc_type_ir::lang_items::TraitSolverLangItem::Poll => LangItem::Poll,
+            rustc_type_ir::lang_items::TraitSolverLangItem::Sized => LangItem::Sized,
+            rustc_type_ir::lang_items::TraitSolverLangItem::MetaSized => LangItem::MetaSized,
+            rustc_type_ir::lang_items::TraitSolverLangItem::PointeeSized => LangItem::PointeeSized,
+            rustc_type_ir::lang_items::TraitSolverLangItem::TransmuteTrait => {
+                LangItem::TransmuteTrait
+            }
+            rustc_type_ir::lang_items::TraitSolverLangItem::Tuple => LangItem::Tuple,
+            rustc_type_ir::lang_items::TraitSolverLangItem::Unpin => LangItem::Unpin,
+            rustc_type_ir::lang_items::TraitSolverLangItem::Unsize => LangItem::Unsize,
+            rustc_type_ir::lang_items::TraitSolverLangItem::BikeshedGuaranteedNoDrop => {
+                unimplemented!()
+            }
+        };
+        let target = hir_def::lang_item::lang_item(
+            self.db(),
+            self.krate.expect("Must have self.krate"),
+            lang_item,
+        )
+        .unwrap_or_else(|| panic!("Lang item {lang_item:?} required but not found."));
+        match target {
+            hir_def::lang_item::LangItemTarget::EnumId(enum_id) => enum_id.into(),
+            hir_def::lang_item::LangItemTarget::Function(function_id) => function_id.into(),
+            hir_def::lang_item::LangItemTarget::ImplDef(impl_id) => impl_id.into(),
+            hir_def::lang_item::LangItemTarget::Static(static_id) => static_id.into(),
+            hir_def::lang_item::LangItemTarget::Struct(struct_id) => struct_id.into(),
+            hir_def::lang_item::LangItemTarget::Union(union_id) => union_id.into(),
+            hir_def::lang_item::LangItemTarget::TypeAlias(type_alias_id) => type_alias_id.into(),
+            hir_def::lang_item::LangItemTarget::Trait(trait_id) => trait_id.into(),
+            hir_def::lang_item::LangItemTarget::EnumVariant(enum_variant_id) => unimplemented!(),
+        }
+    }
+
+    #[allow(clippy::match_like_matches_macro)]
+    fn is_lang_item(
+        self,
+        def_id: Self::DefId,
+        lang_item: rustc_type_ir::lang_items::TraitSolverLangItem,
+    ) -> bool {
+        use rustc_type_ir::lang_items::TraitSolverLangItem::*;
+
+        // FIXME: derive PartialEq on TraitSolverLangItem
+        self.as_lang_item(def_id).map_or(false, |l| match (l, lang_item) {
+            (AsyncFn, AsyncFn) => true,
+            (AsyncFnKindHelper, AsyncFnKindHelper) => true,
+            (AsyncFnKindUpvars, AsyncFnKindUpvars) => true,
+            (AsyncFnMut, AsyncFnMut) => true,
+            (AsyncFnOnce, AsyncFnOnce) => true,
+            (AsyncFnOnceOutput, AsyncFnOnceOutput) => true,
+            (AsyncIterator, AsyncIterator) => true,
+            (CallOnceFuture, CallOnceFuture) => true,
+            (CallRefFuture, CallRefFuture) => true,
+            (Clone, Clone) => true,
+            (Copy, Copy) => true,
+            (Coroutine, Coroutine) => true,
+            (CoroutineReturn, CoroutineReturn) => true,
+            (CoroutineYield, CoroutineYield) => true,
+            (Destruct, Destruct) => true,
+            (DiscriminantKind, DiscriminantKind) => true,
+            (Drop, Drop) => true,
+            (DynMetadata, DynMetadata) => true,
+            (Fn, Fn) => true,
+            (FnMut, FnMut) => true,
+            (FnOnce, FnOnce) => true,
+            (FnPtrTrait, FnPtrTrait) => true,
+            (FusedIterator, FusedIterator) => true,
+            (Future, Future) => true,
+            (FutureOutput, FutureOutput) => true,
+            (Iterator, Iterator) => true,
+            (Metadata, Metadata) => true,
+            (Option, Option) => true,
+            (PointeeTrait, PointeeTrait) => true,
+            (Poll, Poll) => true,
+            (Sized, Sized) => true,
+            (TransmuteTrait, TransmuteTrait) => true,
+            (Tuple, Tuple) => true,
+            (Unpin, Unpin) => true,
+            (Unsize, Unsize) => true,
+            _ => false,
+        })
+    }
+
+    fn as_lang_item(
+        self,
+        def_id: Self::DefId,
+    ) -> Option<rustc_type_ir::lang_items::TraitSolverLangItem> {
+        use rustc_type_ir::lang_items::TraitSolverLangItem;
+
+        let def_id: AttrDefId = match def_id {
+            SolverDefId::TraitId(id) => id.into(),
+            SolverDefId::TypeAliasId(id) => id.into(),
+            _ => panic!("Unexpected SolverDefId in as_lang_item"),
+        };
+        let lang_item = self.db().lang_attr(def_id)?;
+        Some(match lang_item {
+            LangItem::Sized => TraitSolverLangItem::Sized,
+            LangItem::MetaSized => TraitSolverLangItem::MetaSized,
+            LangItem::PointeeSized => TraitSolverLangItem::PointeeSized,
+            LangItem::Unsize => TraitSolverLangItem::Unsize,
+            LangItem::StructuralPeq => return None,
+            LangItem::StructuralTeq => return None,
+            LangItem::Copy => TraitSolverLangItem::Copy,
+            LangItem::Clone => TraitSolverLangItem::Clone,
+            LangItem::Sync => return None,
+            LangItem::DiscriminantKind => TraitSolverLangItem::DiscriminantKind,
+            LangItem::Discriminant => return None,
+            LangItem::PointeeTrait => TraitSolverLangItem::PointeeTrait,
+            LangItem::Metadata => TraitSolverLangItem::Metadata,
+            LangItem::DynMetadata => TraitSolverLangItem::DynMetadata,
+            LangItem::Freeze => return None,
+            LangItem::FnPtrTrait => TraitSolverLangItem::FnPtrTrait,
+            LangItem::FnPtrAddr => return None,
+            LangItem::Drop => TraitSolverLangItem::Drop,
+            LangItem::Destruct => TraitSolverLangItem::Destruct,
+            LangItem::CoerceUnsized => return None,
+            LangItem::DispatchFromDyn => return None,
+            LangItem::TransmuteOpts => return None,
+            LangItem::TransmuteTrait => TraitSolverLangItem::TransmuteTrait,
+            LangItem::Add => return None,
+            LangItem::Sub => return None,
+            LangItem::Mul => return None,
+            LangItem::Div => return None,
+            LangItem::Rem => return None,
+            LangItem::Neg => return None,
+            LangItem::Not => return None,
+            LangItem::BitXor => return None,
+            LangItem::BitAnd => return None,
+            LangItem::BitOr => return None,
+            LangItem::Shl => return None,
+            LangItem::Shr => return None,
+            LangItem::AddAssign => return None,
+            LangItem::SubAssign => return None,
+            LangItem::MulAssign => return None,
+            LangItem::DivAssign => return None,
+            LangItem::RemAssign => return None,
+            LangItem::BitXorAssign => return None,
+            LangItem::BitAndAssign => return None,
+            LangItem::BitOrAssign => return None,
+            LangItem::ShlAssign => return None,
+            LangItem::ShrAssign => return None,
+            LangItem::Index => return None,
+            LangItem::IndexMut => return None,
+            LangItem::UnsafeCell => return None,
+            LangItem::VaList => return None,
+            LangItem::Deref => return None,
+            LangItem::DerefMut => return None,
+            LangItem::DerefTarget => return None,
+            LangItem::Receiver => return None,
+            LangItem::Fn => TraitSolverLangItem::Fn,
+            LangItem::FnMut => TraitSolverLangItem::FnMut,
+            LangItem::FnOnce => TraitSolverLangItem::FnOnce,
+            LangItem::FnOnceOutput => return None,
+            LangItem::Future => TraitSolverLangItem::Future,
+            LangItem::CoroutineState => return None,
+            LangItem::Coroutine => TraitSolverLangItem::Coroutine,
+            LangItem::CoroutineReturn => TraitSolverLangItem::CoroutineReturn,
+            LangItem::CoroutineYield => TraitSolverLangItem::CoroutineYield,
+            LangItem::Unpin => TraitSolverLangItem::Unpin,
+            LangItem::Pin => return None,
+            LangItem::PartialEq => return None,
+            LangItem::PartialOrd => return None,
+            LangItem::CVoid => return None,
+            LangItem::Panic => return None,
+            LangItem::PanicNounwind => return None,
+            LangItem::PanicFmt => return None,
+            LangItem::PanicDisplay => return None,
+            LangItem::ConstPanicFmt => return None,
+            LangItem::PanicBoundsCheck => return None,
+            LangItem::PanicMisalignedPointerDereference => return None,
+            LangItem::PanicInfo => return None,
+            LangItem::PanicLocation => return None,
+            LangItem::PanicImpl => return None,
+            LangItem::PanicCannotUnwind => return None,
+            LangItem::BeginPanic => return None,
+            LangItem::FormatAlignment => return None,
+            LangItem::FormatArgument => return None,
+            LangItem::FormatArguments => return None,
+            LangItem::FormatCount => return None,
+            LangItem::FormatPlaceholder => return None,
+            LangItem::FormatUnsafeArg => return None,
+            LangItem::ExchangeMalloc => return None,
+            LangItem::BoxFree => return None,
+            LangItem::DropInPlace => return None,
+            LangItem::AllocLayout => return None,
+            LangItem::Start => return None,
+            LangItem::EhPersonality => return None,
+            LangItem::EhCatchTypeinfo => return None,
+            LangItem::OwnedBox => return None,
+            LangItem::PhantomData => return None,
+            LangItem::ManuallyDrop => return None,
+            LangItem::MaybeUninit => return None,
+            LangItem::AlignOffset => return None,
+            LangItem::Termination => return None,
+            LangItem::Try => return None,
+            LangItem::Tuple => TraitSolverLangItem::Tuple,
+            LangItem::SliceLen => return None,
+            LangItem::TryTraitFromResidual => return None,
+            LangItem::TryTraitFromOutput => return None,
+            LangItem::TryTraitBranch => return None,
+            LangItem::TryTraitFromYeet => return None,
+            LangItem::PointerLike => return None,
+            LangItem::ConstParamTy => return None,
+            LangItem::Poll => TraitSolverLangItem::Poll,
+            LangItem::PollReady => return None,
+            LangItem::PollPending => return None,
+            LangItem::ResumeTy => return None,
+            LangItem::GetContext => return None,
+            LangItem::Context => return None,
+            LangItem::FuturePoll => return None,
+            LangItem::FutureOutput => TraitSolverLangItem::FutureOutput,
+            LangItem::Option => TraitSolverLangItem::Option,
+            LangItem::OptionSome => return None,
+            LangItem::OptionNone => return None,
+            LangItem::ResultOk => return None,
+            LangItem::ResultErr => return None,
+            LangItem::ControlFlowContinue => return None,
+            LangItem::ControlFlowBreak => return None,
+            LangItem::IntoFutureIntoFuture => return None,
+            LangItem::IntoIterIntoIter => return None,
+            LangItem::IteratorNext => return None,
+            LangItem::Iterator => TraitSolverLangItem::Iterator,
+            LangItem::PinNewUnchecked => return None,
+            LangItem::RangeFrom => return None,
+            LangItem::RangeFull => return None,
+            LangItem::RangeInclusiveStruct => return None,
+            LangItem::RangeInclusiveNew => return None,
+            LangItem::Range => return None,
+            LangItem::RangeToInclusive => return None,
+            LangItem::RangeTo => return None,
+            LangItem::String => return None,
+            LangItem::CStr => return None,
+            LangItem::AsyncFn => TraitSolverLangItem::AsyncFn,
+            LangItem::AsyncFnMut => TraitSolverLangItem::AsyncFnMut,
+            LangItem::AsyncFnOnce => TraitSolverLangItem::AsyncFnOnce,
+            LangItem::AsyncFnOnceOutput => TraitSolverLangItem::AsyncFnOnceOutput,
+            LangItem::CallRefFuture => TraitSolverLangItem::CallRefFuture,
+            LangItem::CallOnceFuture => TraitSolverLangItem::CallOnceFuture,
+            LangItem::Ordering => return None,
+            LangItem::PanicNullPointerDereference => return None,
+            LangItem::ReceiverTarget => return None,
+            LangItem::UnsafePinned => return None,
+            LangItem::AsyncFnOnceOutput => TraitSolverLangItem::AsyncFnOnceOutput,
+        })
+    }
+
+    fn associated_type_def_ids(self, def_id: Self::DefId) -> impl IntoIterator<Item = Self::DefId> {
+        let trait_ = match def_id {
+            SolverDefId::TraitId(id) => id,
+            _ => unreachable!(),
+        };
+        trait_.trait_items(self.db()).associated_types().map(|id| id.into())
+    }
+
+    fn for_each_relevant_impl(
+        self,
+        trait_def_id: Self::DefId,
+        self_ty: Self::Ty,
+        mut f: impl FnMut(Self::DefId),
+    ) {
+        let trait_ = match trait_def_id {
+            SolverDefId::TraitId(id) => id,
+            _ => panic!("for_each_relevant_impl called for non-trait"),
+        };
+
+        let self_ty_fp = TyFingerprint::for_trait_impl_ns(&self_ty);
+        let fps: &[TyFingerprint] = match self_ty.kind() {
+            TyKind::Infer(InferTy::IntVar(..)) => &ALL_INT_FPS,
+            TyKind::Infer(InferTy::FloatVar(..)) => &ALL_FLOAT_FPS,
+            _ => self_ty_fp.as_slice(),
+        };
+
+        if fps.is_empty() {
+            for_trait_impls(
+                self.db(),
+                self.krate.expect("Must have self.krate"),
+                self.block,
+                trait_,
+                self_ty_fp,
+                |impls| {
+                    for i in impls.for_trait(trait_) {
+                        use rustc_type_ir::TypeVisitable;
+                        let contains_errors = self.db().impl_trait_ns(i).map_or(false, |b| {
+                            b.skip_binder().visit_with(&mut ContainsTypeErrors).is_break()
+                        });
+                        if contains_errors {
+                            continue;
+                        }
+
+                        f(SolverDefId::ImplId(i));
+                    }
+                    ControlFlow::Continue(())
+                },
+            );
+        } else {
+            for_trait_impls(
+                self.db(),
+                self.krate.expect("Must have self.krate"),
+                self.block,
+                trait_,
+                self_ty_fp,
+                |impls| {
+                    for fp in fps {
+                        for i in impls.for_trait_and_self_ty(trait_, *fp) {
+                            use rustc_type_ir::TypeVisitable;
+                            let contains_errors = self.db().impl_trait_ns(i).map_or(false, |b| {
+                                b.skip_binder().visit_with(&mut ContainsTypeErrors).is_break()
+                            });
+                            if contains_errors {
+                                continue;
+                            }
+
+                            f(SolverDefId::ImplId(i));
+                        }
+                    }
+                    ControlFlow::Continue(())
+                },
+            );
+        }
+    }
+
+    fn has_item_definition(self, def_id: Self::DefId) -> bool {
+        // FIXME: should check if has value
+        true
+    }
+
+    fn impl_is_default(self, impl_def_id: Self::DefId) -> bool {
+        // FIXME
+        false
+    }
+
+    #[tracing::instrument(skip(self), ret)]
+    fn impl_trait_ref(
+        self,
+        impl_def_id: Self::DefId,
+    ) -> rustc_type_ir::EarlyBinder<Self, rustc_type_ir::TraitRef<Self>> {
+        let impl_id = match impl_def_id {
+            SolverDefId::ImplId(id) => id,
+            _ => panic!("Unexpected SolverDefId in impl_trait_ref"),
+        };
+
+        let db = self.db();
+
+        db.impl_trait_ns(impl_id)
+            // ImplIds for impls where the trait ref can't be resolved should never reach trait solving
+            .expect("invalid impl passed to trait solver")
+    }
+
+    fn impl_polarity(self, impl_def_id: Self::DefId) -> rustc_type_ir::ImplPolarity {
+        let impl_id = match impl_def_id {
+            SolverDefId::ImplId(id) => id,
+            _ => unreachable!(),
+        };
+        let impl_data = self.db().impl_signature(impl_id);
+        if impl_data.flags.contains(ImplFlags::NEGATIVE) {
+            ImplPolarity::Negative
+        } else {
+            ImplPolarity::Positive
+        }
+    }
+
+    fn trait_is_auto(self, trait_def_id: Self::DefId) -> bool {
+        let trait_ = match trait_def_id {
+            SolverDefId::TraitId(id) => id,
+            _ => panic!("Unexpected SolverDefId in trait_is_auto"),
+        };
+        let trait_data = self.db().trait_signature(trait_);
+        trait_data.flags.contains(TraitFlags::AUTO)
+    }
+
+    fn trait_is_alias(self, trait_def_id: Self::DefId) -> bool {
+        matches!(trait_def_id, SolverDefId::TraitAliasId(_))
+    }
+
+    fn trait_is_dyn_compatible(self, trait_def_id: Self::DefId) -> bool {
+        let trait_ = match trait_def_id {
+            SolverDefId::TraitId(id) => id,
+            _ => unreachable!(),
+        };
+        crate::dyn_compatibility::dyn_compatibility(self.db(), trait_).is_none()
+    }
+
+    fn trait_is_fundamental(self, def_id: Self::DefId) -> bool {
+        let trait_ = match def_id {
+            SolverDefId::TraitId(id) => id,
+            _ => panic!("Unexpected SolverDefId in trait_is_fundamental"),
+        };
+        let trait_data = self.db().trait_signature(trait_);
+        trait_data.flags.contains(TraitFlags::FUNDAMENTAL)
+    }
+
+    fn trait_may_be_implemented_via_object(self, trait_def_id: Self::DefId) -> bool {
+        // FIXME(next-solver)
+        true
+    }
+
+    fn is_impl_trait_in_trait(self, def_id: Self::DefId) -> bool {
+        // FIXME(next-solver)
+        false
+    }
+
+    fn delay_bug(self, msg: impl ToString) -> Self::ErrorGuaranteed {
+        panic!("Bug encountered in next-trait-solver.")
+    }
+
+    fn is_general_coroutine(self, coroutine_def_id: Self::DefId) -> bool {
+        // FIXME(next-solver)
+        true
+    }
+
+    fn coroutine_is_async(self, coroutine_def_id: Self::DefId) -> bool {
+        // FIXME(next-solver)
+        true
+    }
+
+    fn coroutine_is_gen(self, coroutine_def_id: Self::DefId) -> bool {
+        // FIXME(next-solver)
+        false
+    }
+
+    fn coroutine_is_async_gen(self, coroutine_def_id: Self::DefId) -> bool {
+        // FIXME(next-solver)
+        false
+    }
+
+    fn unsizing_params_for_adt(self, adt_def_id: Self::DefId) -> Self::UnsizingParams {
+        let id = match adt_def_id {
+            SolverDefId::AdtId(id) => id,
+            _ => unreachable!(),
+        };
+        let def = AdtDef::new(id, self);
+        let num_params = self.generics_of(adt_def_id).count();
+
+        let maybe_unsizing_param_idx = |arg: GenericArg<'db>| match arg.kind() {
+            GenericArgKind::Type(ty) => match ty.kind() {
+                rustc_type_ir::TyKind::Param(p) => Some(p.index),
+                _ => None,
+            },
+            GenericArgKind::Lifetime(_) => None,
+            GenericArgKind::Const(ct) => match ct.kind() {
+                rustc_type_ir::ConstKind::Param(p) => Some(p.index),
+                _ => None,
+            },
+        };
+
+        // The last field of the structure has to exist and contain type/const parameters.
+        let variant = def.non_enum_variant();
+        let fields = variant.fields(self.db());
+        let Some((tail_field, prefix_fields)) = fields.split_last() else {
+            return UnsizingParams(DenseBitSet::new_empty(num_params));
+        };
+
+        let field_types = self.db().field_types_ns(variant.id());
+        let mut unsizing_params = DenseBitSet::new_empty(num_params);
+        let ty = field_types[tail_field.0];
+        for arg in ty.instantiate_identity().walk() {
+            if let Some(i) = maybe_unsizing_param_idx(arg) {
+                unsizing_params.insert(i);
+            }
+        }
+
+        // Ensure none of the other fields mention the parameters used
+        // in unsizing.
+        for field in prefix_fields {
+            for arg in field_types[field.0].instantiate_identity().walk() {
+                if let Some(i) = maybe_unsizing_param_idx(arg) {
+                    unsizing_params.remove(i);
+                }
+            }
+        }
+
+        UnsizingParams(unsizing_params)
+    }
+
+    fn anonymize_bound_vars<T: rustc_type_ir::TypeFoldable<Self>>(
+        self,
+        value: rustc_type_ir::Binder<Self, T>,
+    ) -> rustc_type_ir::Binder<Self, T> {
+        struct Anonymize<'a, 'db> {
+            interner: DbInterner<'db>,
+            map: &'a mut FxIndexMap<BoundVar, BoundVarKind>,
+        }
+        impl<'db> BoundVarReplacerDelegate<'db> for Anonymize<'_, 'db> {
+            fn replace_region(&mut self, br: BoundRegion) -> Region<'db> {
+                let entry = self.map.entry(br.var);
+                let index = entry.index();
+                let var = BoundVar::from_usize(index);
+                let kind = (*entry.or_insert_with(|| BoundVarKind::Region(BoundRegionKind::Anon)))
+                    .expect_region();
+                let br = BoundRegion { var, kind };
+                Region::new_bound(self.interner, DebruijnIndex::ZERO, br)
+            }
+            fn replace_ty(&mut self, bt: BoundTy) -> Ty<'db> {
+                let entry = self.map.entry(bt.var);
+                let index = entry.index();
+                let var = BoundVar::from_usize(index);
+                let kind =
+                    (*entry.or_insert_with(|| BoundVarKind::Ty(BoundTyKind::Anon))).expect_ty();
+                Ty::new_bound(self.interner, DebruijnIndex::ZERO, BoundTy { var, kind })
+            }
+            fn replace_const(&mut self, bv: BoundVar) -> Const<'db> {
+                let entry = self.map.entry(bv);
+                let index = entry.index();
+                let var = BoundVar::from_usize(index);
+                let () = (*entry.or_insert_with(|| BoundVarKind::Const)).expect_const();
+                Const::new_bound(self.interner, DebruijnIndex::ZERO, var)
+            }
+        }
+
+        let mut map = Default::default();
+        let delegate = Anonymize { interner: self, map: &mut map };
+        let inner = self.replace_escaping_bound_vars_uncached(value.skip_binder(), delegate);
+        let bound_vars = CollectAndApply::collect_and_apply(map.into_values(), |xs| {
+            BoundVarKinds::new_from_iter(self, xs.iter().cloned())
+        });
+        Binder::bind_with_vars(inner, bound_vars)
+    }
+
+    fn opaque_types_defined_by(self, defining_anchor: Self::LocalDefId) -> Self::LocalDefIds {
+        // FIXME(next-solver)
+        SolverDefIds::new_from_iter(self, [])
+    }
+
+    fn alias_has_const_conditions(self, def_id: Self::DefId) -> bool {
+        // FIXME(next-solver)
+        false
+    }
+
+    fn explicit_implied_const_bounds(
+        self,
+        def_id: Self::DefId,
+    ) -> rustc_type_ir::EarlyBinder<
+        Self,
+        impl IntoIterator<Item = rustc_type_ir::Binder<Self, rustc_type_ir::TraitRef<Self>>>,
+    > {
+        // FIXME(next-solver)
+        rustc_type_ir::EarlyBinder::bind([])
+    }
+
+    fn fn_is_const(self, def_id: Self::DefId) -> bool {
+        let id = match def_id {
+            SolverDefId::FunctionId(id) => id,
+            _ => unreachable!(),
+        };
+        self.db().function_signature(id).flags.contains(FnFlags::CONST)
+    }
+
+    fn impl_is_const(self, def_id: Self::DefId) -> bool {
+        false
+    }
+
+    fn opt_alias_variances(
+        self,
+        kind: impl Into<rustc_type_ir::AliasTermKind>,
+        def_id: Self::DefId,
+    ) -> Option<Self::VariancesOf> {
+        None
+    }
+
+    fn type_of_opaque_hir_typeck(
+        self,
+        def_id: Self::LocalDefId,
+    ) -> rustc_type_ir::EarlyBinder<Self, Self::Ty> {
+        // FIXME(next-solver)
+        unimplemented!()
+    }
+
+    fn coroutine_hidden_types(
+        self,
+        def_id: Self::DefId,
+    ) -> rustc_type_ir::EarlyBinder<
+        Self,
+        rustc_type_ir::Binder<Self, rustc_type_ir::CoroutineWitnessTypes<Self>>,
+    > {
+        // FIXME(next-solver)
+        unimplemented!()
+    }
+
+    fn is_default_trait(self, def_id: Self::DefId) -> bool {
+        self.as_lang_item(def_id).map_or(false, |l| matches!(l, TraitSolverLangItem::Sized))
+    }
+
+    fn trait_is_coinductive(self, trait_def_id: Self::DefId) -> bool {
+        let id = match trait_def_id {
+            SolverDefId::TraitId(id) => id,
+            _ => unreachable!(),
+        };
+        self.db().trait_signature(id).flags.contains(TraitFlags::COINDUCTIVE)
+    }
+
+    fn trait_is_unsafe(self, trait_def_id: Self::DefId) -> bool {
+        let id = match trait_def_id {
+            SolverDefId::TraitId(id) => id,
+            _ => unreachable!(),
+        };
+        self.db().trait_signature(id).flags.contains(TraitFlags::UNSAFE)
+    }
+
+    fn impl_self_is_guaranteed_unsized(self, def_id: Self::DefId) -> bool {
+        false
+    }
+
+    fn impl_specializes(self, impl_def_id: Self::DefId, victim_def_id: Self::DefId) -> bool {
+        false
+    }
+
+    fn next_trait_solver_globally(self) -> bool {
+        true
+    }
+
+    fn opaque_types_and_coroutines_defined_by(
+        self,
+        defining_anchor: Self::LocalDefId,
+    ) -> Self::LocalDefIds {
+        // FIXME(next-solver)
+        unimplemented!()
+    }
+}
+
+impl<'db> DbInterner<'db> {
+    pub fn shift_bound_var_indices<T>(self, bound_vars: usize, value: T) -> T
+    where
+        T: rustc_type_ir::TypeFoldable<Self>,
+    {
+        let shift_bv = |bv: BoundVar| BoundVar::from_usize(bv.as_usize() + bound_vars);
+        self.replace_escaping_bound_vars_uncached(
+            value,
+            FnMutDelegate {
+                regions: &mut |r: BoundRegion| {
+                    Region::new_bound(
+                        self,
+                        DebruijnIndex::ZERO,
+                        BoundRegion { var: shift_bv(r.var), kind: r.kind },
+                    )
+                },
+                types: &mut |t: BoundTy| {
+                    Ty::new_bound(
+                        self,
+                        DebruijnIndex::ZERO,
+                        BoundTy { var: shift_bv(t.var), kind: t.kind },
+                    )
+                },
+                consts: &mut |c| Const::new_bound(self, DebruijnIndex::ZERO, shift_bv(c)),
+            },
+        )
+    }
+
+    pub fn replace_escaping_bound_vars_uncached<T: rustc_type_ir::TypeFoldable<DbInterner<'db>>>(
+        self,
+        value: T,
+        delegate: impl BoundVarReplacerDelegate<'db>,
+    ) -> T {
+        if !value.has_escaping_bound_vars() {
+            value
+        } else {
+            let mut replacer = BoundVarReplacer::new(self, delegate);
+            value.fold_with(&mut replacer)
+        }
+    }
+
+    pub fn replace_bound_vars_uncached<T: rustc_type_ir::TypeFoldable<DbInterner<'db>>>(
+        self,
+        value: Binder<'db, T>,
+        delegate: impl BoundVarReplacerDelegate<'db>,
+    ) -> T {
+        self.replace_escaping_bound_vars_uncached(value.skip_binder(), delegate)
+    }
+}
+
+macro_rules! TrivialTypeTraversalImpls {
+    ($($ty:ty,)+) => {
+        $(
+            impl<'db> rustc_type_ir::TypeFoldable<DbInterner<'db>> for $ty {
+                fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>(
+                    self,
+                    _: &mut F,
+                ) -> ::std::result::Result<Self, F::Error> {
+                    Ok(self)
+                }
+
+                #[inline]
+                fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(
+                    self,
+                    _: &mut F,
+                ) -> Self {
+                    self
+                }
+            }
+
+            impl<'db> rustc_type_ir::TypeVisitable<DbInterner<'db>> for $ty {
+                #[inline]
+                fn visit_with<F: rustc_type_ir::TypeVisitor<DbInterner<'db>>>(
+                    &self,
+                    _: &mut F)
+                    -> F::Result
+                {
+                    <F::Result as rustc_ast_ir::visit::VisitorResult>::output()
+                }
+            }
+        )+
+    };
+}
+
+TrivialTypeTraversalImpls! {
+    SolverDefId,
+    Pattern<'db>,
+    Safety,
+    FnAbi,
+    Span,
+    ParamConst,
+    ParamTy,
+    BoundRegion,
+    BoundVar,
+    Placeholder<BoundRegion>,
+    Placeholder<BoundTy>,
+    Placeholder<BoundVar>,
+}
+
+pub(crate) use tls_cache::with_new_cache;
+mod tls_cache {
+    use crate::db::HirDatabase;
+
+    use super::DbInterner;
+    use rustc_type_ir::search_graph::GlobalCache;
+    use std::cell::RefCell;
+
+    scoped_tls::scoped_thread_local!(static GLOBAL_CACHE: RefCell<rustc_type_ir::search_graph::GlobalCache<DbInterner<'static>>>);
+
+    pub(crate) fn with_new_cache<T>(f: impl FnOnce() -> T) -> T {
+        GLOBAL_CACHE.set(&RefCell::new(GlobalCache::default()), f)
+    }
+
+    pub(super) fn with_cache<'db, T>(
+        _db: &'db dyn HirDatabase,
+        f: impl FnOnce(&mut GlobalCache<DbInterner<'db>>) -> T,
+    ) -> T {
+        // SAFETY: No idea
+        let call = move |slot: &RefCell<_>| {
+            f(unsafe {
+                std::mem::transmute::<
+                    &mut GlobalCache<DbInterner<'static>>,
+                    &mut GlobalCache<DbInterner<'db>>,
+                >(&mut *slot.borrow_mut())
+            })
+        };
+        if GLOBAL_CACHE.is_set() {
+            GLOBAL_CACHE.with(call)
+        } else {
+            GLOBAL_CACHE.set(&RefCell::new(GlobalCache::default()), || GLOBAL_CACHE.with(call))
+        }
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ir_print.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ir_print.rs
new file mode 100644
index 0000000000000..4d32b27132357
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ir_print.rs
@@ -0,0 +1,267 @@
+//! Things related to IR printing in the next-trait-solver.
+
+use std::any::type_name_of_val;
+
+use rustc_type_ir::inherent::SliceLike;
+use rustc_type_ir::{self as ty, ir_print::IrPrint};
+
+use crate::db::HirDatabase;
+
+use super::SolverDefId;
+use super::interner::DbInterner;
+
+impl<'db> IrPrint<ty::AliasTy<Self>> for DbInterner<'db> {
+    fn print(t: &ty::AliasTy<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        Self::print_debug(t, fmt)
+    }
+
+    fn print_debug(t: &ty::AliasTy<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        salsa::with_attached_database(|db| match t.def_id {
+            SolverDefId::TypeAliasId(id) => fmt.write_str(&format!(
+                "AliasTy({:?}[{:?}])",
+                db.as_view::<dyn HirDatabase>().type_alias_signature(id).name.as_str(),
+                t.args
+            )),
+            SolverDefId::InternedOpaqueTyId(id) => {
+                fmt.write_str(&format!("AliasTy({:?}[{:?}])", id, t.args))
+            }
+            _ => panic!("Expected TypeAlias or OpaqueTy."),
+        })
+        .unwrap_or_else(|| fmt.write_str(&format!("AliasTy({:?}[{:?}])", t.def_id, t.args)))
+    }
+}
+
+impl<'db> IrPrint<ty::AliasTerm<Self>> for DbInterner<'db> {
+    fn print(t: &ty::AliasTerm<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        Self::print_debug(t, fmt)
+    }
+
+    fn print_debug(t: &ty::AliasTerm<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        salsa::with_attached_database(|db| match t.def_id {
+            SolverDefId::TypeAliasId(id) => fmt.write_str(&format!(
+                "AliasTerm({:?}[{:?}])",
+                db.as_view::<dyn HirDatabase>().type_alias_signature(id).name.as_str(),
+                t.args
+            )),
+            SolverDefId::InternedOpaqueTyId(id) => {
+                fmt.write_str(&format!("AliasTerm({:?}[{:?}])", id, t.args))
+            }
+            _ => panic!("Expected TypeAlias or OpaqueTy."),
+        })
+        .unwrap_or_else(|| fmt.write_str(&format!("AliasTerm({:?}[{:?}])", t.def_id, t.args)))
+    }
+}
+impl<'db> IrPrint<ty::TraitRef<Self>> for DbInterner<'db> {
+    fn print(t: &ty::TraitRef<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        Self::print_debug(t, fmt)
+    }
+
+    fn print_debug(t: &ty::TraitRef<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        salsa::with_attached_database(|db| {
+            let trait_ = match t.def_id {
+                SolverDefId::TraitId(id) => id,
+                _ => panic!("Expected trait."),
+            };
+            let self_ty = &t.args.as_slice()[0];
+            let trait_args = &t.args.as_slice()[1..];
+            if trait_args.is_empty() {
+                fmt.write_str(&format!(
+                    "{:?}: {}",
+                    self_ty,
+                    db.as_view::<dyn HirDatabase>().trait_signature(trait_).name.as_str()
+                ))
+            } else {
+                fmt.write_str(&format!(
+                    "{:?}: {}<{:?}>",
+                    self_ty,
+                    db.as_view::<dyn HirDatabase>().trait_signature(trait_).name.as_str(),
+                    trait_args
+                ))
+            }
+        })
+        .unwrap_or_else(|| fmt.write_str(&format!("TraitRef({:?}[{:?}])", t.def_id, t.args)))
+    }
+}
+impl<'db> IrPrint<ty::TraitPredicate<Self>> for DbInterner<'db> {
+    fn print(t: &ty::TraitPredicate<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        Self::print_debug(t, fmt)
+    }
+
+    fn print_debug(
+        t: &ty::TraitPredicate<Self>,
+        fmt: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
+        fmt.write_str(&format!("TODO: {:?}", type_name_of_val(t)))
+    }
+}
+impl<'db> IrPrint<rustc_type_ir::HostEffectPredicate<Self>> for DbInterner<'db> {
+    fn print(
+        t: &rustc_type_ir::HostEffectPredicate<Self>,
+        fmt: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
+        Self::print_debug(t, fmt)
+    }
+
+    fn print_debug(
+        t: &rustc_type_ir::HostEffectPredicate<Self>,
+        fmt: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
+        fmt.write_str(&format!("TODO: {:?}", type_name_of_val(t)))
+    }
+}
+impl<'db> IrPrint<ty::ExistentialTraitRef<Self>> for DbInterner<'db> {
+    fn print(
+        t: &ty::ExistentialTraitRef<Self>,
+        fmt: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
+        Self::print_debug(t, fmt)
+    }
+
+    fn print_debug(
+        t: &ty::ExistentialTraitRef<Self>,
+        fmt: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
+        salsa::with_attached_database(|db| {
+            let trait_ = match t.def_id {
+                SolverDefId::TraitId(id) => id,
+                _ => panic!("Expected trait."),
+            };
+            fmt.write_str(&format!(
+                "ExistentialTraitRef({:?}[{:?}])",
+                db.as_view::<dyn HirDatabase>().trait_signature(trait_).name.as_str(),
+                t.args
+            ))
+        })
+        .unwrap_or_else(|| {
+            fmt.write_str(&format!("ExistentialTraitRef({:?}[{:?}])", t.def_id, t.args))
+        })
+    }
+}
+impl<'db> IrPrint<ty::ExistentialProjection<Self>> for DbInterner<'db> {
+    fn print(
+        t: &ty::ExistentialProjection<Self>,
+        fmt: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
+        Self::print_debug(t, fmt)
+    }
+
+    fn print_debug(
+        t: &ty::ExistentialProjection<Self>,
+        fmt: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
+        salsa::with_attached_database(|db| {
+            let id = match t.def_id {
+                SolverDefId::TypeAliasId(id) => id,
+                _ => panic!("Expected trait."),
+            };
+            fmt.write_str(&format!(
+                "ExistentialProjection(({:?}[{:?}]) -> {:?})",
+                db.as_view::<dyn HirDatabase>().type_alias_signature(id).name.as_str(),
+                t.args,
+                t.term
+            ))
+        })
+        .unwrap_or_else(|| {
+            fmt.write_str(&format!(
+                "ExistentialProjection(({:?}[{:?}]) -> {:?})",
+                t.def_id, t.args, t.term
+            ))
+        })
+    }
+}
+impl<'db> IrPrint<ty::ProjectionPredicate<Self>> for DbInterner<'db> {
+    fn print(
+        t: &ty::ProjectionPredicate<Self>,
+        fmt: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
+        Self::print_debug(t, fmt)
+    }
+
+    fn print_debug(
+        t: &ty::ProjectionPredicate<Self>,
+        fmt: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
+        salsa::with_attached_database(|db| {
+            let id = match t.projection_term.def_id {
+                SolverDefId::TypeAliasId(id) => id,
+                _ => panic!("Expected trait."),
+            };
+            fmt.write_str(&format!(
+                "ProjectionPredicate(({:?}[{:?}]) -> {:?})",
+                db.as_view::<dyn HirDatabase>().type_alias_signature(id).name.as_str(),
+                t.projection_term.args,
+                t.term
+            ))
+        })
+        .unwrap_or_else(|| {
+            fmt.write_str(&format!(
+                "ProjectionPredicate(({:?}[{:?}]) -> {:?})",
+                t.projection_term.def_id, t.projection_term.args, t.term
+            ))
+        })
+    }
+}
+impl<'db> IrPrint<ty::NormalizesTo<Self>> for DbInterner<'db> {
+    fn print(t: &ty::NormalizesTo<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        Self::print_debug(t, fmt)
+    }
+
+    fn print_debug(
+        t: &ty::NormalizesTo<Self>,
+        fmt: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
+        fmt.write_str(&format!("TODO: {:?}", type_name_of_val(t)))
+    }
+}
+impl<'db> IrPrint<ty::SubtypePredicate<Self>> for DbInterner<'db> {
+    fn print(
+        t: &ty::SubtypePredicate<Self>,
+        fmt: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
+        Self::print_debug(t, fmt)
+    }
+
+    fn print_debug(
+        t: &ty::SubtypePredicate<Self>,
+        fmt: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
+        fmt.write_str(&format!("TODO: {:?}", type_name_of_val(t)))
+    }
+}
+impl<'db> IrPrint<ty::CoercePredicate<Self>> for DbInterner<'db> {
+    fn print(t: &ty::CoercePredicate<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        Self::print_debug(t, fmt)
+    }
+
+    fn print_debug(
+        t: &ty::CoercePredicate<Self>,
+        fmt: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
+        fmt.write_str(&format!("TODO: {:?}", type_name_of_val(t)))
+    }
+}
+impl<'db> IrPrint<ty::FnSig<Self>> for DbInterner<'db> {
+    fn print(t: &ty::FnSig<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        Self::print_debug(t, fmt)
+    }
+
+    fn print_debug(t: &ty::FnSig<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        fmt.write_str(&format!("TODO: {:?}", type_name_of_val(t)))
+    }
+}
+
+impl<'db> IrPrint<rustc_type_ir::PatternKind<DbInterner<'db>>> for DbInterner<'db> {
+    fn print(
+        t: &rustc_type_ir::PatternKind<DbInterner<'db>>,
+        fmt: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
+        Self::print_debug(t, fmt)
+    }
+
+    fn print_debug(
+        t: &rustc_type_ir::PatternKind<DbInterner<'db>>,
+        fmt: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
+        fmt.write_str(&format!("TODO: {:?}", type_name_of_val(t)))
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
new file mode 100644
index 0000000000000..3a3206bef38b5
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
@@ -0,0 +1,1368 @@
+//! Things useful for mapping to/from Chalk and next-trait-solver types.
+
+use base_db::Crate;
+use chalk_ir::{
+    CanonicalVarKind, CanonicalVarKinds, ForeignDefId, InferenceVar, Substitution, TyVariableKind,
+    WellFormed, fold::Shift, interner::HasInterner,
+};
+use hir_def::{
+    CallableDefId, ConstParamId, FunctionId, GeneralConstId, LifetimeParamId, TypeAliasId,
+    TypeOrConstParamId, TypeParamId, signatures::TraitFlags,
+};
+use intern::sym;
+use rustc_type_ir::{
+    AliasTerm, BoundVar, DebruijnIndex, ExistentialProjection, ExistentialTraitRef, Interner as _,
+    OutlivesPredicate, ProjectionPredicate, TypeFoldable, TypeSuperFoldable, TypeVisitable,
+    TypeVisitableExt, UniverseIndex, elaborate,
+    inherent::{BoundVarLike, Clause as _, IntoKind, PlaceholderLike, SliceLike, Ty as _},
+    shift_vars,
+    solve::Goal,
+};
+use salsa::plumbing::AsId;
+
+use crate::{
+    ConcreteConst, ConstScalar, ImplTraitId, Interner,
+    db::{
+        HirDatabase, InternedClosureId, InternedCoroutineId, InternedOpaqueTyId,
+        InternedTypeOrConstParamId,
+    },
+    from_assoc_type_id, from_chalk_trait_id,
+    mapping::ToChalk,
+    next_solver::{
+        Binder, ClauseKind, ConstBytes, TraitPredicate, UnevaluatedConst,
+        interner::{AdtDef, BoundVarKind, BoundVarKinds, DbInterner},
+    },
+    to_assoc_type_id, to_chalk_trait_id, to_foreign_def_id,
+};
+
+use super::{
+    BoundExistentialPredicate, BoundExistentialPredicates, BoundRegion, BoundRegionKind, BoundTy,
+    BoundTyKind, Canonical, CanonicalVars, Clause, Clauses, Const, Ctor, EarlyParamRegion,
+    ErrorGuaranteed, ExistentialPredicate, GenericArg, GenericArgs, ParamConst, ParamEnv, ParamTy,
+    Placeholder, PlaceholderConst, PlaceholderRegion, PlaceholderTy, Predicate, PredicateKind,
+    Region, SolverDefId, SubtypePredicate, Term, TraitRef, Ty, Tys, ValueConst, VariancesOf,
+};
+
+pub fn to_placeholder_idx<T: Clone + std::fmt::Debug>(
+    db: &dyn HirDatabase,
+    id: TypeOrConstParamId,
+    map: impl Fn(BoundVar) -> T,
+) -> Placeholder<T> {
+    let interned_id = InternedTypeOrConstParamId::new(db, id);
+    Placeholder {
+        universe: UniverseIndex::ZERO,
+        bound: map(BoundVar::from_usize(interned_id.as_id().index() as usize)),
+    }
+}
+
+pub fn convert_binder_to_early_binder<'db, T: rustc_type_ir::TypeFoldable<DbInterner<'db>>>(
+    interner: DbInterner<'db>,
+    binder: rustc_type_ir::Binder<DbInterner<'db>, T>,
+) -> rustc_type_ir::EarlyBinder<DbInterner<'db>, T> {
+    let mut folder = BinderToEarlyBinder { interner, debruijn: rustc_type_ir::DebruijnIndex::ZERO };
+    rustc_type_ir::EarlyBinder::bind(binder.skip_binder().fold_with(&mut folder))
+}
+
+struct BinderToEarlyBinder<'db> {
+    interner: DbInterner<'db>,
+    debruijn: rustc_type_ir::DebruijnIndex,
+}
+
+impl<'db> rustc_type_ir::TypeFolder<DbInterner<'db>> for BinderToEarlyBinder<'db> {
+    fn cx(&self) -> DbInterner<'db> {
+        self.interner
+    }
+
+    fn fold_binder<T>(
+        &mut self,
+        t: rustc_type_ir::Binder<DbInterner<'db>, T>,
+    ) -> rustc_type_ir::Binder<DbInterner<'db>, T>
+    where
+        T: TypeFoldable<DbInterner<'db>>,
+    {
+        self.debruijn.shift_in(1);
+        let result = t.super_fold_with(self);
+        self.debruijn.shift_out(1);
+        result
+    }
+
+    fn fold_ty(&mut self, t: Ty<'db>) -> Ty<'db> {
+        match t.kind() {
+            rustc_type_ir::TyKind::Bound(debruijn, bound_ty) if self.debruijn == debruijn => {
+                let var: rustc_type_ir::BoundVar = bound_ty.var();
+                Ty::new(self.cx(), rustc_type_ir::TyKind::Param(ParamTy { index: var.as_u32() }))
+            }
+            _ => t.super_fold_with(self),
+        }
+    }
+
+    fn fold_region(&mut self, r: Region<'db>) -> Region<'db> {
+        match r.kind() {
+            rustc_type_ir::ReBound(debruijn, bound_region) if self.debruijn == debruijn => {
+                let var: rustc_type_ir::BoundVar = bound_region.var();
+                Region::new(
+                    self.cx(),
+                    rustc_type_ir::RegionKind::ReEarlyParam(EarlyParamRegion {
+                        index: var.as_u32(),
+                    }),
+                )
+            }
+            _ => r,
+        }
+    }
+
+    fn fold_const(&mut self, c: Const<'db>) -> Const<'db> {
+        match c.kind() {
+            rustc_type_ir::ConstKind::Bound(debruijn, var) if self.debruijn == debruijn => {
+                Const::new(
+                    self.cx(),
+                    rustc_type_ir::ConstKind::Param(ParamConst { index: var.as_u32() }),
+                )
+            }
+            _ => c.super_fold_with(self),
+        }
+    }
+}
+
+pub trait ChalkToNextSolver<'db, Out> {
+    fn to_nextsolver(&self, interner: DbInterner<'db>) -> Out;
+}
+
+impl<'db> ChalkToNextSolver<'db, Ty<'db>> for chalk_ir::Ty<Interner> {
+    fn to_nextsolver(&self, interner: DbInterner<'db>) -> Ty<'db> {
+        Ty::new(
+            interner,
+            match self.kind(Interner) {
+                chalk_ir::TyKind::Adt(adt_id, substitution) => {
+                    let def = AdtDef::new(adt_id.0, interner);
+                    let args = substitution.to_nextsolver(interner);
+                    rustc_type_ir::TyKind::Adt(def, args)
+                }
+                chalk_ir::TyKind::AssociatedType(assoc_type_id, substitution) => {
+                    let def_id = SolverDefId::TypeAliasId(from_assoc_type_id(*assoc_type_id));
+                    let args: GenericArgs<'db> = substitution.to_nextsolver(interner);
+                    let alias_ty = rustc_type_ir::AliasTy::new(interner, def_id, args.iter());
+                    rustc_type_ir::TyKind::Alias(rustc_type_ir::AliasTyKind::Projection, alias_ty)
+                }
+                chalk_ir::TyKind::Scalar(scalar) => match scalar {
+                    chalk_ir::Scalar::Bool => rustc_type_ir::TyKind::Bool,
+                    chalk_ir::Scalar::Char => rustc_type_ir::TyKind::Char,
+                    chalk_ir::Scalar::Int(chalk_ir::IntTy::Isize) => {
+                        rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::Isize)
+                    }
+                    chalk_ir::Scalar::Int(chalk_ir::IntTy::I8) => {
+                        rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::I8)
+                    }
+                    chalk_ir::Scalar::Int(chalk_ir::IntTy::I16) => {
+                        rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::I16)
+                    }
+                    chalk_ir::Scalar::Int(chalk_ir::IntTy::I32) => {
+                        rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::I32)
+                    }
+                    chalk_ir::Scalar::Int(chalk_ir::IntTy::I64) => {
+                        rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::I64)
+                    }
+                    chalk_ir::Scalar::Int(chalk_ir::IntTy::I128) => {
+                        rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::I128)
+                    }
+                    chalk_ir::Scalar::Uint(chalk_ir::UintTy::Usize) => {
+                        rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::Usize)
+                    }
+                    chalk_ir::Scalar::Uint(chalk_ir::UintTy::U8) => {
+                        rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::U8)
+                    }
+                    chalk_ir::Scalar::Uint(chalk_ir::UintTy::U16) => {
+                        rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::U16)
+                    }
+                    chalk_ir::Scalar::Uint(chalk_ir::UintTy::U32) => {
+                        rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::U32)
+                    }
+                    chalk_ir::Scalar::Uint(chalk_ir::UintTy::U64) => {
+                        rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::U64)
+                    }
+                    chalk_ir::Scalar::Uint(chalk_ir::UintTy::U128) => {
+                        rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::U128)
+                    }
+                    chalk_ir::Scalar::Float(chalk_ir::FloatTy::F16) => {
+                        rustc_type_ir::TyKind::Float(rustc_type_ir::FloatTy::F16)
+                    }
+                    chalk_ir::Scalar::Float(chalk_ir::FloatTy::F32) => {
+                        rustc_type_ir::TyKind::Float(rustc_type_ir::FloatTy::F32)
+                    }
+                    chalk_ir::Scalar::Float(chalk_ir::FloatTy::F64) => {
+                        rustc_type_ir::TyKind::Float(rustc_type_ir::FloatTy::F64)
+                    }
+                    chalk_ir::Scalar::Float(chalk_ir::FloatTy::F128) => {
+                        rustc_type_ir::TyKind::Float(rustc_type_ir::FloatTy::F128)
+                    }
+                },
+                chalk_ir::TyKind::Tuple(_, substitution) => {
+                    let args = substitution.to_nextsolver(interner);
+                    rustc_type_ir::TyKind::Tuple(args)
+                }
+                chalk_ir::TyKind::Array(ty, len) => rustc_type_ir::TyKind::Array(
+                    ty.to_nextsolver(interner),
+                    len.to_nextsolver(interner),
+                ),
+                chalk_ir::TyKind::Slice(ty) => {
+                    rustc_type_ir::TyKind::Slice(ty.to_nextsolver(interner))
+                }
+                chalk_ir::TyKind::Raw(mutability, ty) => rustc_type_ir::RawPtr(
+                    ty.to_nextsolver(interner),
+                    mutability.to_nextsolver(interner),
+                ),
+                chalk_ir::TyKind::Ref(mutability, lifetime, ty) => rustc_type_ir::TyKind::Ref(
+                    lifetime.to_nextsolver(interner),
+                    ty.to_nextsolver(interner),
+                    mutability.to_nextsolver(interner),
+                ),
+                chalk_ir::TyKind::OpaqueType(def_id, substitution) => {
+                    let id: InternedOpaqueTyId = (*def_id).into();
+                    let args: GenericArgs<'db> = substitution.to_nextsolver(interner);
+                    let alias_ty = rustc_type_ir::AliasTy::new(interner, id.into(), args);
+                    rustc_type_ir::TyKind::Alias(rustc_type_ir::AliasTyKind::Opaque, alias_ty)
+                }
+                chalk_ir::TyKind::FnDef(fn_def_id, substitution) => {
+                    let def_id = CallableDefId::from_chalk(interner.db(), *fn_def_id);
+                    let id: SolverDefId = match def_id {
+                        CallableDefId::FunctionId(id) => id.into(),
+                        CallableDefId::StructId(id) => SolverDefId::Ctor(Ctor::Struct(id)),
+                        CallableDefId::EnumVariantId(id) => SolverDefId::Ctor(Ctor::Enum(id)),
+                    };
+                    rustc_type_ir::TyKind::FnDef(id, substitution.to_nextsolver(interner))
+                }
+                chalk_ir::TyKind::Str => rustc_type_ir::TyKind::Str,
+                chalk_ir::TyKind::Never => rustc_type_ir::TyKind::Never,
+                chalk_ir::TyKind::Closure(closure_id, substitution) => {
+                    let id: InternedClosureId = (*closure_id).into();
+                    rustc_type_ir::TyKind::Closure(id.into(), substitution.to_nextsolver(interner))
+                }
+                chalk_ir::TyKind::Coroutine(coroutine_id, substitution) => {
+                    let id: InternedCoroutineId = (*coroutine_id).into();
+                    rustc_type_ir::TyKind::Coroutine(
+                        id.into(),
+                        substitution.to_nextsolver(interner),
+                    )
+                }
+                chalk_ir::TyKind::CoroutineWitness(coroutine_id, substitution) => {
+                    let id: InternedCoroutineId = (*coroutine_id).into();
+                    rustc_type_ir::TyKind::CoroutineWitness(
+                        id.into(),
+                        substitution.to_nextsolver(interner),
+                    )
+                }
+                chalk_ir::TyKind::Foreign(foreign_def_id) => rustc_type_ir::TyKind::Foreign(
+                    SolverDefId::ForeignId(crate::from_foreign_def_id(*foreign_def_id)),
+                ),
+                chalk_ir::TyKind::Error => rustc_type_ir::TyKind::Error(ErrorGuaranteed),
+                chalk_ir::TyKind::Placeholder(placeholder_index) => {
+                    rustc_type_ir::TyKind::Placeholder(PlaceholderTy::new_anon(
+                        placeholder_index.ui.to_nextsolver(interner),
+                        rustc_type_ir::BoundVar::from_usize(placeholder_index.idx),
+                    ))
+                }
+                chalk_ir::TyKind::Dyn(dyn_ty) => {
+                    // exists<type> { for<...> ^1.0: ... }
+                    let bounds = BoundExistentialPredicates::new_from_iter(
+                        interner,
+                        dyn_ty.bounds.skip_binders().iter(Interner).filter_map(|pred| {
+                            // for<...> ^1.0: ...
+                            let (val, binders) = pred.clone().into_value_and_skipped_binders();
+                            let bound_vars = binders.to_nextsolver(interner);
+                            let clause = match val {
+                                chalk_ir::WhereClause::Implemented(trait_ref) => {
+                                    let trait_id = from_chalk_trait_id(trait_ref.trait_id);
+                                    if interner
+                                        .db()
+                                        .trait_signature(trait_id)
+                                        .flags
+                                        .contains(TraitFlags::AUTO)
+                                    {
+                                        ExistentialPredicate::AutoTrait(SolverDefId::TraitId(
+                                            trait_id,
+                                        ))
+                                    } else {
+                                        let def_id = SolverDefId::TraitId(trait_id);
+                                        let args = GenericArgs::new_from_iter(
+                                            interner,
+                                            trait_ref
+                                                .substitution
+                                                .iter(Interner)
+                                                .skip(1)
+                                                .map(|a| a.clone().shifted_out(Interner).unwrap())
+                                                .map(|a| a.to_nextsolver(interner)),
+                                        );
+                                        let trait_ref = ExistentialTraitRef::new_from_args(
+                                            interner, def_id, args,
+                                        );
+                                        ExistentialPredicate::Trait(trait_ref)
+                                    }
+                                }
+                                chalk_ir::WhereClause::AliasEq(alias_eq) => {
+                                    let (def_id, args) = match &alias_eq.alias {
+                                        chalk_ir::AliasTy::Projection(projection) => {
+                                            let id =
+                                                from_assoc_type_id(projection.associated_ty_id);
+                                            let def_id = SolverDefId::TypeAliasId(id);
+                                            let generics = interner.generics_of(def_id);
+                                            let parent_len = generics.parent_count;
+                                            let substs = projection.substitution.iter(Interner).skip(1);
+
+                                            let args = GenericArgs::new_from_iter(
+                                                interner,
+                                                substs
+                                                    .map(|a| {
+                                                        a.clone().shifted_out(Interner).unwrap()
+                                                    })
+                                                    .map(|a| a.to_nextsolver(interner)),
+                                            );
+                                            (def_id, args)
+                                        }
+                                        chalk_ir::AliasTy::Opaque(opaque_ty) => {
+                                            panic!("Invalid ExistentialPredicate (opaques can't be named).");
+                                        }
+                                    };
+                                    let term = alias_eq
+                                        .ty
+                                        .clone()
+                                        .shifted_out(Interner)
+                                        .unwrap()
+                                        .to_nextsolver(interner)
+                                        .into();
+                                    let projection = ExistentialProjection::new_from_args(
+                                        interner, def_id, args, term,
+                                    );
+                                    ExistentialPredicate::Projection(projection)
+                                }
+                                chalk_ir::WhereClause::LifetimeOutlives(lifetime_outlives) => {
+                                    return None;
+                                }
+                                chalk_ir::WhereClause::TypeOutlives(type_outlives) => return None,
+                            };
+
+                            Some(Binder::bind_with_vars(clause, bound_vars))
+                        }),
+                    );
+                    let region = dyn_ty.lifetime.to_nextsolver(interner);
+                    let kind = rustc_type_ir::DynKind::Dyn;
+                    rustc_type_ir::TyKind::Dynamic(bounds, region, kind)
+                }
+                chalk_ir::TyKind::Alias(alias_ty) => match alias_ty {
+                    chalk_ir::AliasTy::Projection(projection_ty) => {
+                        let def_id = SolverDefId::TypeAliasId(from_assoc_type_id(
+                            projection_ty.associated_ty_id,
+                        ));
+                        let alias_ty = rustc_type_ir::AliasTy::new_from_args(
+                            interner,
+                            def_id,
+                            projection_ty.substitution.to_nextsolver(interner),
+                        );
+                        rustc_type_ir::TyKind::Alias(
+                            rustc_type_ir::AliasTyKind::Projection,
+                            alias_ty,
+                        )
+                    }
+                    chalk_ir::AliasTy::Opaque(opaque_ty) => {
+                        let id: InternedOpaqueTyId = opaque_ty.opaque_ty_id.into();
+                        let def_id = SolverDefId::InternedOpaqueTyId(id);
+                        let alias_ty = rustc_type_ir::AliasTy::new_from_args(
+                            interner,
+                            def_id,
+                            opaque_ty.substitution.to_nextsolver(interner),
+                        );
+                        rustc_type_ir::TyKind::Alias(rustc_type_ir::AliasTyKind::Opaque, alias_ty)
+                    }
+                },
+                chalk_ir::TyKind::Function(fn_pointer) => {
+                    let sig_tys = fn_pointer.clone().into_binders(Interner).to_nextsolver(interner);
+                    let header = rustc_type_ir::FnHeader {
+                        abi: fn_pointer.sig.abi,
+                        c_variadic: fn_pointer.sig.variadic,
+                        safety: match fn_pointer.sig.safety {
+                            chalk_ir::Safety::Safe => super::abi::Safety::Safe,
+                            chalk_ir::Safety::Unsafe => super::abi::Safety::Unsafe,
+                        },
+                    };
+
+                    rustc_type_ir::TyKind::FnPtr(sig_tys, header)
+                }
+                chalk_ir::TyKind::BoundVar(bound_var) => rustc_type_ir::TyKind::Bound(
+                    bound_var.debruijn.to_nextsolver(interner),
+                    BoundTy {
+                        var: rustc_type_ir::BoundVar::from_usize(bound_var.index),
+                        kind: BoundTyKind::Anon,
+                    },
+                ),
+                chalk_ir::TyKind::InferenceVar(inference_var, ty_variable_kind) => {
+                    rustc_type_ir::TyKind::Infer(
+                        (*inference_var, *ty_variable_kind).to_nextsolver(interner),
+                    )
+                }
+            },
+        )
+    }
+}
+
+impl<'db> ChalkToNextSolver<'db, Region<'db>> for chalk_ir::Lifetime<Interner> {
+    fn to_nextsolver(&self, interner: DbInterner<'db>) -> Region<'db> {
+        Region::new(
+            interner,
+            match self.data(Interner) {
+                chalk_ir::LifetimeData::BoundVar(bound_var) => rustc_type_ir::RegionKind::ReBound(
+                    bound_var.debruijn.to_nextsolver(interner),
+                    BoundRegion {
+                        var: rustc_type_ir::BoundVar::from_u32(bound_var.index as u32),
+                        kind: BoundRegionKind::Anon,
+                    },
+                ),
+                chalk_ir::LifetimeData::InferenceVar(inference_var) => {
+                    rustc_type_ir::RegionKind::ReVar(rustc_type_ir::RegionVid::from_u32(
+                        inference_var.index(),
+                    ))
+                }
+                chalk_ir::LifetimeData::Placeholder(placeholder_index) => {
+                    rustc_type_ir::RegionKind::RePlaceholder(PlaceholderRegion::new_anon(
+                        rustc_type_ir::UniverseIndex::from_u32(placeholder_index.ui.counter as u32),
+                        rustc_type_ir::BoundVar::from_u32(placeholder_index.idx as u32),
+                    ))
+                }
+                chalk_ir::LifetimeData::Static => rustc_type_ir::RegionKind::ReStatic,
+                chalk_ir::LifetimeData::Erased => rustc_type_ir::RegionKind::ReErased,
+                chalk_ir::LifetimeData::Phantom(_, _) => {
+                    unreachable!()
+                }
+                chalk_ir::LifetimeData::Error => {
+                    rustc_type_ir::RegionKind::ReError(ErrorGuaranteed)
+                }
+            },
+        )
+    }
+}
+
+impl<'db> ChalkToNextSolver<'db, Const<'db>> for chalk_ir::Const<Interner> {
+    fn to_nextsolver(&self, interner: DbInterner<'db>) -> Const<'db> {
+        let data = self.data(Interner);
+        Const::new(
+            interner,
+            match &data.value {
+                chalk_ir::ConstValue::BoundVar(bound_var) => rustc_type_ir::ConstKind::Bound(
+                    bound_var.debruijn.to_nextsolver(interner),
+                    rustc_type_ir::BoundVar::from_usize(bound_var.index),
+                ),
+                chalk_ir::ConstValue::InferenceVar(inference_var) => {
+                    rustc_type_ir::ConstKind::Infer(rustc_type_ir::InferConst::Var(
+                        rustc_type_ir::ConstVid::from_u32(inference_var.index()),
+                    ))
+                }
+                chalk_ir::ConstValue::Placeholder(placeholder_index) => {
+                    rustc_type_ir::ConstKind::Placeholder(PlaceholderConst::new(
+                        placeholder_index.ui.to_nextsolver(interner),
+                        rustc_type_ir::BoundVar::from_usize(placeholder_index.idx),
+                    ))
+                }
+                chalk_ir::ConstValue::Concrete(concrete_const) => match &concrete_const.interned {
+                    ConstScalar::Bytes(bytes, memory) => {
+                        rustc_type_ir::ConstKind::Value(ValueConst::new(
+                            data.ty.to_nextsolver(interner),
+                            ConstBytes(bytes.clone(), memory.clone()),
+                        ))
+                    }
+                    ConstScalar::UnevaluatedConst(c, subst) => {
+                        let def = match *c {
+                            GeneralConstId::ConstId(id) => SolverDefId::ConstId(id),
+                            GeneralConstId::StaticId(id) => SolverDefId::StaticId(id),
+                        };
+                        let args = subst.to_nextsolver(interner);
+                        rustc_type_ir::ConstKind::Unevaluated(UnevaluatedConst::new(def, args))
+                    }
+                    ConstScalar::Unknown => rustc_type_ir::ConstKind::Error(ErrorGuaranteed),
+                },
+            },
+        )
+    }
+}
+
+impl<'db> ChalkToNextSolver<'db, rustc_type_ir::FnSigTys<DbInterner<'db>>>
+    for chalk_ir::FnSubst<Interner>
+{
+    fn to_nextsolver(&self, interner: DbInterner<'db>) -> rustc_type_ir::FnSigTys<DbInterner<'db>> {
+        rustc_type_ir::FnSigTys {
+            inputs_and_output: Tys::new_from_iter(
+                interner,
+                self.0.iter(Interner).map(|g| g.assert_ty_ref(Interner).to_nextsolver(interner)),
+            ),
+        }
+    }
+}
+
+impl<
+    'db,
+    U: TypeVisitable<DbInterner<'db>>,
+    T: Clone + ChalkToNextSolver<'db, U> + HasInterner<Interner = Interner>,
+> ChalkToNextSolver<'db, rustc_type_ir::Binder<DbInterner<'db>, U>> for chalk_ir::Binders<T>
+{
+    fn to_nextsolver(
+        &self,
+        interner: DbInterner<'db>,
+    ) -> rustc_type_ir::Binder<DbInterner<'db>, U> {
+        let (val, binders) = self.clone().into_value_and_skipped_binders();
+        rustc_type_ir::Binder::bind_with_vars(
+            val.to_nextsolver(interner),
+            binders.to_nextsolver(interner),
+        )
+    }
+}
+
+impl<'db> ChalkToNextSolver<'db, BoundVarKinds> for chalk_ir::VariableKinds<Interner> {
+    fn to_nextsolver(&self, interner: DbInterner<'db>) -> BoundVarKinds {
+        BoundVarKinds::new_from_iter(
+            interner,
+            self.iter(Interner).map(|v| v.to_nextsolver(interner)),
+        )
+    }
+}
+
+impl<'db> ChalkToNextSolver<'db, BoundVarKind> for chalk_ir::VariableKind<Interner> {
+    fn to_nextsolver(&self, interner: DbInterner<'db>) -> BoundVarKind {
+        match self {
+            chalk_ir::VariableKind::Ty(_ty_variable_kind) => BoundVarKind::Ty(BoundTyKind::Anon),
+            chalk_ir::VariableKind::Lifetime => BoundVarKind::Region(BoundRegionKind::Anon),
+            chalk_ir::VariableKind::Const(_ty) => BoundVarKind::Const,
+        }
+    }
+}
+
+impl<'db> ChalkToNextSolver<'db, GenericArg<'db>> for chalk_ir::GenericArg<Interner> {
+    fn to_nextsolver(&self, interner: DbInterner<'db>) -> GenericArg<'db> {
+        match self.data(Interner) {
+            chalk_ir::GenericArgData::Ty(ty) => ty.to_nextsolver(interner).into(),
+            chalk_ir::GenericArgData::Lifetime(lifetime) => lifetime.to_nextsolver(interner).into(),
+            chalk_ir::GenericArgData::Const(const_) => const_.to_nextsolver(interner).into(),
+        }
+    }
+}
+impl<'db> ChalkToNextSolver<'db, GenericArgs<'db>> for chalk_ir::Substitution<Interner> {
+    fn to_nextsolver(&self, interner: DbInterner<'db>) -> GenericArgs<'db> {
+        GenericArgs::new_from_iter(
+            interner,
+            self.iter(Interner).map(|arg| -> GenericArg<'db> { arg.to_nextsolver(interner) }),
+        )
+    }
+}
+
+impl<'db> ChalkToNextSolver<'db, Tys<'db>> for chalk_ir::Substitution<Interner> {
+    fn to_nextsolver(&self, interner: DbInterner<'db>) -> Tys<'db> {
+        Tys::new_from_iter(
+            interner,
+            self.iter(Interner).map(|arg| -> Ty<'db> {
+                match arg.data(Interner) {
+                    chalk_ir::GenericArgData::Ty(ty) => ty.to_nextsolver(interner),
+                    chalk_ir::GenericArgData::Lifetime(_) => unreachable!(),
+                    chalk_ir::GenericArgData::Const(_) => unreachable!(),
+                }
+            }),
+        )
+    }
+}
+
+impl<'db> ChalkToNextSolver<'db, rustc_type_ir::DebruijnIndex> for chalk_ir::DebruijnIndex {
+    fn to_nextsolver(&self, interner: DbInterner<'db>) -> rustc_type_ir::DebruijnIndex {
+        rustc_type_ir::DebruijnIndex::from_u32(self.depth())
+    }
+}
+
+impl<'db> ChalkToNextSolver<'db, rustc_type_ir::UniverseIndex> for chalk_ir::UniverseIndex {
+    fn to_nextsolver(&self, interner: DbInterner<'db>) -> rustc_type_ir::UniverseIndex {
+        rustc_type_ir::UniverseIndex::from_u32(self.counter as u32)
+    }
+}
+
+impl<'db> ChalkToNextSolver<'db, rustc_type_ir::InferTy>
+    for (chalk_ir::InferenceVar, chalk_ir::TyVariableKind)
+{
+    fn to_nextsolver(&self, interner: DbInterner<'db>) -> rustc_type_ir::InferTy {
+        match self.1 {
+            chalk_ir::TyVariableKind::General => {
+                rustc_type_ir::InferTy::TyVar(rustc_type_ir::TyVid::from_u32(self.0.index()))
+            }
+            chalk_ir::TyVariableKind::Integer => {
+                rustc_type_ir::InferTy::IntVar(rustc_type_ir::IntVid::from_u32(self.0.index()))
+            }
+            chalk_ir::TyVariableKind::Float => {
+                rustc_type_ir::InferTy::FloatVar(rustc_type_ir::FloatVid::from_u32(self.0.index()))
+            }
+        }
+    }
+}
+
+impl<'db> ChalkToNextSolver<'db, rustc_ast_ir::Mutability> for chalk_ir::Mutability {
+    fn to_nextsolver(&self, interner: DbInterner<'db>) -> rustc_ast_ir::Mutability {
+        match self {
+            chalk_ir::Mutability::Mut => rustc_ast_ir::Mutability::Mut,
+            chalk_ir::Mutability::Not => rustc_ast_ir::Mutability::Not,
+        }
+    }
+}
+
+impl<'db> ChalkToNextSolver<'db, rustc_type_ir::Variance> for crate::Variance {
+    fn to_nextsolver(&self, interner: DbInterner<'db>) -> rustc_type_ir::Variance {
+        match self {
+            crate::Variance::Covariant => rustc_type_ir::Variance::Covariant,
+            crate::Variance::Invariant => rustc_type_ir::Variance::Invariant,
+            crate::Variance::Contravariant => rustc_type_ir::Variance::Contravariant,
+            crate::Variance::Bivariant => rustc_type_ir::Variance::Bivariant,
+        }
+    }
+}
+
+impl<'db> ChalkToNextSolver<'db, Canonical<'db, Goal<DbInterner<'db>, Predicate<'db>>>>
+    for chalk_ir::Canonical<chalk_ir::InEnvironment<chalk_ir::Goal<Interner>>>
+{
+    fn to_nextsolver(
+        &self,
+        interner: DbInterner<'db>,
+    ) -> Canonical<'db, Goal<DbInterner<'db>, Predicate<'db>>> {
+        let param_env = self.value.environment.to_nextsolver(interner);
+        let variables = CanonicalVars::new_from_iter(
+            interner,
+            self.binders.iter(Interner).map(|k| match &k.kind {
+                chalk_ir::VariableKind::Ty(ty_variable_kind) => match ty_variable_kind {
+                    TyVariableKind::General => rustc_type_ir::CanonicalVarKind::Ty(
+                        rustc_type_ir::CanonicalTyVarKind::General(UniverseIndex::ROOT),
+                    ),
+                    TyVariableKind::Integer => {
+                        rustc_type_ir::CanonicalVarKind::Ty(rustc_type_ir::CanonicalTyVarKind::Int)
+                    }
+                    TyVariableKind::Float => rustc_type_ir::CanonicalVarKind::Ty(
+                        rustc_type_ir::CanonicalTyVarKind::Float,
+                    ),
+                },
+                chalk_ir::VariableKind::Lifetime => {
+                    rustc_type_ir::CanonicalVarKind::Region(UniverseIndex::ROOT)
+                }
+                chalk_ir::VariableKind::Const(ty) => {
+                    rustc_type_ir::CanonicalVarKind::Const(UniverseIndex::ROOT)
+                }
+            }),
+        );
+        Canonical {
+            max_universe: UniverseIndex::ROOT,
+            value: Goal::new(interner, param_env, self.value.goal.to_nextsolver(interner)),
+            variables,
+        }
+    }
+}
+
+impl<'db> ChalkToNextSolver<'db, Predicate<'db>> for chalk_ir::Goal<Interner> {
+    fn to_nextsolver(&self, interner: DbInterner<'db>) -> Predicate<'db> {
+        match self.data(Interner) {
+            chalk_ir::GoalData::Quantified(quantifier_kind, binders) => {
+                if !binders.binders.is_empty(Interner) {
+                    panic!("Should not be constructed.");
+                }
+                let (val, _) = binders.clone().into_value_and_skipped_binders();
+                val.shifted_out(Interner).unwrap().to_nextsolver(interner)
+            }
+            chalk_ir::GoalData::Implies(program_clauses, goal) => {
+                panic!("Should not be constructed.")
+            }
+            chalk_ir::GoalData::All(goals) => panic!("Should not be constructed."),
+            chalk_ir::GoalData::Not(goal) => panic!("Should not be constructed."),
+            chalk_ir::GoalData::EqGoal(eq_goal) => panic!("Should not be constructed."),
+            chalk_ir::GoalData::SubtypeGoal(subtype_goal) => {
+                let subtype_predicate = SubtypePredicate {
+                    a: subtype_goal.a.to_nextsolver(interner),
+                    b: subtype_goal.b.to_nextsolver(interner),
+                    a_is_expected: true,
+                };
+                let pred_kind = PredicateKind::Subtype(subtype_predicate);
+                let pred_kind = Binder::bind_with_vars(
+                    shift_vars(interner, pred_kind, 1),
+                    BoundVarKinds::new_from_iter(interner, []),
+                );
+                Predicate::new(interner, pred_kind)
+            }
+            chalk_ir::GoalData::DomainGoal(domain_goal) => {
+                let pred_kind = domain_goal.to_nextsolver(interner);
+                let pred_kind = Binder::bind_with_vars(
+                    shift_vars(interner, pred_kind, 1),
+                    BoundVarKinds::new_from_iter(interner, []),
+                );
+                Predicate::new(interner, pred_kind)
+            }
+            chalk_ir::GoalData::CannotProve => panic!("Should not be constructed."),
+        }
+    }
+}
+
+impl<'db> ChalkToNextSolver<'db, ParamEnv<'db>> for chalk_ir::Environment<Interner> {
+    fn to_nextsolver(&self, interner: DbInterner<'db>) -> ParamEnv<'db> {
+        let clauses = Clauses::new_from_iter(
+            interner,
+            self.clauses.iter(Interner).map(|c| c.to_nextsolver(interner)),
+        );
+        let clauses =
+            Clauses::new_from_iter(interner, elaborate::elaborate(interner, clauses.iter()));
+        ParamEnv { clauses }
+    }
+}
+
+impl<'db> ChalkToNextSolver<'db, Clause<'db>> for chalk_ir::ProgramClause<Interner> {
+    fn to_nextsolver(&self, interner: DbInterner<'db>) -> Clause<'db> {
+        Clause(Predicate::new(interner, self.data(Interner).0.to_nextsolver(interner)))
+    }
+}
+
+impl<'db> ChalkToNextSolver<'db, PredicateKind<'db>>
+    for chalk_ir::ProgramClauseImplication<Interner>
+{
+    fn to_nextsolver(&self, interner: DbInterner<'db>) -> PredicateKind<'db> {
+        assert!(self.conditions.is_empty(Interner));
+        assert!(self.constraints.is_empty(Interner));
+        self.consequence.to_nextsolver(interner)
+    }
+}
+
+impl<'db> ChalkToNextSolver<'db, PredicateKind<'db>> for chalk_ir::DomainGoal<Interner> {
+    fn to_nextsolver(&self, interner: DbInterner<'db>) -> PredicateKind<'db> {
+        match self {
+            chalk_ir::DomainGoal::Holds(where_clause) => match where_clause {
+                chalk_ir::WhereClause::Implemented(trait_ref) => {
+                    let predicate = TraitPredicate {
+                        trait_ref: trait_ref.to_nextsolver(interner),
+                        polarity: rustc_type_ir::PredicatePolarity::Positive,
+                    };
+                    PredicateKind::Clause(ClauseKind::Trait(predicate))
+                }
+                chalk_ir::WhereClause::AliasEq(alias_eq) => match &alias_eq.alias {
+                    chalk_ir::AliasTy::Projection(p) => {
+                        let def_id =
+                            SolverDefId::TypeAliasId(from_assoc_type_id(p.associated_ty_id));
+                        let args = p.substitution.to_nextsolver(interner);
+                        let term: Ty<'db> = alias_eq.ty.to_nextsolver(interner);
+                        let term: Term<'db> = term.into();
+                        let predicate = ProjectionPredicate {
+                            projection_term: AliasTerm::new_from_args(interner, def_id, args),
+                            term,
+                        };
+                        PredicateKind::Clause(ClauseKind::Projection(predicate))
+                    }
+                    chalk_ir::AliasTy::Opaque(opaque) => {
+                        let id: InternedOpaqueTyId = opaque.opaque_ty_id.into();
+                        let def_id = SolverDefId::InternedOpaqueTyId(id);
+                        let args = opaque.substitution.to_nextsolver(interner);
+                        let term: Ty<'db> = alias_eq.ty.to_nextsolver(interner);
+                        let term: Term<'db> = term.into();
+                        let opaque_ty = Ty::new(
+                            interner,
+                            rustc_type_ir::TyKind::Alias(
+                                rustc_type_ir::AliasTyKind::Opaque,
+                                rustc_type_ir::AliasTy::new_from_args(interner, def_id, args),
+                            ),
+                        )
+                        .into();
+                        PredicateKind::AliasRelate(
+                            opaque_ty,
+                            term,
+                            rustc_type_ir::AliasRelationDirection::Equate,
+                        )
+                    }
+                },
+                chalk_ir::WhereClause::LifetimeOutlives(lifetime_outlives) => {
+                    let predicate = OutlivesPredicate(
+                        lifetime_outlives.a.to_nextsolver(interner),
+                        lifetime_outlives.b.to_nextsolver(interner),
+                    );
+                    PredicateKind::Clause(ClauseKind::RegionOutlives(predicate))
+                }
+                chalk_ir::WhereClause::TypeOutlives(type_outlives) => {
+                    let predicate = OutlivesPredicate(
+                        type_outlives.ty.to_nextsolver(interner),
+                        type_outlives.lifetime.to_nextsolver(interner),
+                    );
+                    PredicateKind::Clause(ClauseKind::TypeOutlives(predicate))
+                }
+            },
+            chalk_ir::DomainGoal::Normalize(normalize) => {
+                let proj_ty = match &normalize.alias {
+                    chalk_ir::AliasTy::Projection(proj) => proj,
+                    _ => unimplemented!(),
+                };
+                let args: GenericArgs<'db> = proj_ty.substitution.to_nextsolver(interner);
+                let alias = rustc_type_ir::AliasTerm::new(
+                    interner,
+                    from_assoc_type_id(proj_ty.associated_ty_id).into(),
+                    args,
+                );
+                let term = normalize.ty.to_nextsolver(interner).into();
+                let normalizes_to = rustc_type_ir::NormalizesTo { alias, term };
+                PredicateKind::NormalizesTo(normalizes_to)
+            }
+            chalk_ir::DomainGoal::WellFormed(well_formed) => {
+                let term = match well_formed {
+                    WellFormed::Trait(_) => panic!("Should not be constructed."),
+                    WellFormed::Ty(ty) => Term::Ty(ty.to_nextsolver(interner)),
+                };
+                PredicateKind::Clause(rustc_type_ir::ClauseKind::WellFormed(term))
+            }
+            chalk_ir::DomainGoal::FromEnv(from_env) => match from_env {
+                chalk_ir::FromEnv::Trait(trait_ref) => {
+                    let predicate = TraitPredicate {
+                        trait_ref: trait_ref.to_nextsolver(interner),
+                        polarity: rustc_type_ir::PredicatePolarity::Positive,
+                    };
+                    PredicateKind::Clause(ClauseKind::Trait(predicate))
+                }
+                chalk_ir::FromEnv::Ty(ty) => PredicateKind::Clause(ClauseKind::WellFormed(
+                    Term::Ty(ty.to_nextsolver(interner)),
+                )),
+            },
+            chalk_ir::DomainGoal::IsLocal(ty) => panic!("Should not be constructed."),
+            chalk_ir::DomainGoal::IsUpstream(ty) => panic!("Should not be constructed."),
+            chalk_ir::DomainGoal::IsFullyVisible(ty) => panic!("Should not be constructed."),
+            chalk_ir::DomainGoal::LocalImplAllowed(trait_ref) => {
+                panic!("Should not be constructed.")
+            }
+            chalk_ir::DomainGoal::Compatible => panic!("Should not be constructed."),
+            chalk_ir::DomainGoal::DownstreamType(ty) => panic!("Should not be constructed."),
+            chalk_ir::DomainGoal::Reveal => panic!("Should not be constructed."),
+            chalk_ir::DomainGoal::ObjectSafe(trait_id) => panic!("Should not be constructed."),
+        }
+    }
+}
+
+impl<'db> ChalkToNextSolver<'db, TraitRef<'db>> for chalk_ir::TraitRef<Interner> {
+    fn to_nextsolver(&self, interner: DbInterner<'db>) -> TraitRef<'db> {
+        let args = self.substitution.to_nextsolver(interner);
+        TraitRef::new_from_args(
+            interner,
+            SolverDefId::TraitId(from_chalk_trait_id(self.trait_id)),
+            args,
+        )
+    }
+}
+
+impl<'db> ChalkToNextSolver<'db, PredicateKind<'db>> for chalk_ir::WhereClause<Interner> {
+    fn to_nextsolver(&self, interner: DbInterner<'db>) -> PredicateKind<'db> {
+        match self {
+            chalk_ir::WhereClause::Implemented(trait_ref) => {
+                let predicate = TraitPredicate {
+                    trait_ref: trait_ref.to_nextsolver(interner),
+                    polarity: rustc_type_ir::PredicatePolarity::Positive,
+                };
+                PredicateKind::Clause(ClauseKind::Trait(predicate))
+            }
+            chalk_ir::WhereClause::AliasEq(alias_eq) => {
+                let projection = match &alias_eq.alias {
+                    chalk_ir::AliasTy::Projection(p) => p,
+                    _ => unimplemented!(),
+                };
+                let def_id =
+                    SolverDefId::TypeAliasId(from_assoc_type_id(projection.associated_ty_id));
+                let args = projection.substitution.to_nextsolver(interner);
+                let term: Ty<'db> = alias_eq.ty.to_nextsolver(interner);
+                let term: Term<'db> = term.into();
+                let predicate = ProjectionPredicate {
+                    projection_term: AliasTerm::new_from_args(interner, def_id, args),
+                    term,
+                };
+                PredicateKind::Clause(ClauseKind::Projection(predicate))
+            }
+            chalk_ir::WhereClause::TypeOutlives(type_outlives) => {
+                let ty = type_outlives.ty.to_nextsolver(interner);
+                let r = type_outlives.lifetime.to_nextsolver(interner);
+                PredicateKind::Clause(ClauseKind::TypeOutlives(OutlivesPredicate(ty, r)))
+            }
+            chalk_ir::WhereClause::LifetimeOutlives(lifetime_outlives) => {
+                let a = lifetime_outlives.a.to_nextsolver(interner);
+                let b = lifetime_outlives.b.to_nextsolver(interner);
+                PredicateKind::Clause(ClauseKind::RegionOutlives(OutlivesPredicate(a, b)))
+            }
+        }
+    }
+}
+
+pub fn convert_canonical_args_for_result<'db>(
+    interner: DbInterner<'db>,
+    args: Canonical<'db, Vec<GenericArg<'db>>>,
+) -> chalk_ir::Canonical<chalk_ir::ConstrainedSubst<Interner>> {
+    let Canonical { value, variables, max_universe } = args;
+    let binders = CanonicalVarKinds::from_iter(
+        Interner,
+        variables.iter().map(|v| match v {
+            rustc_type_ir::CanonicalVarKind::Ty(rustc_type_ir::CanonicalTyVarKind::General(_)) => {
+                CanonicalVarKind::new(
+                    chalk_ir::VariableKind::Ty(TyVariableKind::General),
+                    chalk_ir::UniverseIndex::ROOT,
+                )
+            }
+            rustc_type_ir::CanonicalVarKind::Ty(rustc_type_ir::CanonicalTyVarKind::Int) => {
+                CanonicalVarKind::new(
+                    chalk_ir::VariableKind::Ty(TyVariableKind::Integer),
+                    chalk_ir::UniverseIndex::ROOT,
+                )
+            }
+            rustc_type_ir::CanonicalVarKind::Ty(rustc_type_ir::CanonicalTyVarKind::Float) => {
+                CanonicalVarKind::new(
+                    chalk_ir::VariableKind::Ty(TyVariableKind::Float),
+                    chalk_ir::UniverseIndex::ROOT,
+                )
+            }
+            rustc_type_ir::CanonicalVarKind::Region(universe_index) => CanonicalVarKind::new(
+                chalk_ir::VariableKind::Lifetime,
+                chalk_ir::UniverseIndex::ROOT,
+            ),
+            rustc_type_ir::CanonicalVarKind::Const(universe_index) => CanonicalVarKind::new(
+                chalk_ir::VariableKind::Const(crate::TyKind::Error.intern(Interner)),
+                chalk_ir::UniverseIndex::ROOT,
+            ),
+            rustc_type_ir::CanonicalVarKind::PlaceholderTy(_) => unimplemented!(),
+            rustc_type_ir::CanonicalVarKind::PlaceholderRegion(_) => unimplemented!(),
+            rustc_type_ir::CanonicalVarKind::PlaceholderConst(_) => unimplemented!(),
+        }),
+    );
+    chalk_ir::Canonical {
+        binders,
+        value: chalk_ir::ConstrainedSubst {
+            constraints: chalk_ir::Constraints::empty(Interner),
+            subst: convert_args_for_result(interner, &value),
+        },
+    }
+}
+
+pub fn convert_args_for_result<'db>(
+    interner: DbInterner<'db>,
+    args: &[GenericArg<'db>],
+) -> crate::Substitution {
+    let mut substs = Vec::with_capacity(args.len());
+    for arg in args {
+        match (*arg).kind() {
+            rustc_type_ir::GenericArgKind::Type(ty) => {
+                let ty = convert_ty_for_result(interner, ty);
+                substs.push(chalk_ir::GenericArgData::Ty(ty).intern(Interner));
+            }
+            rustc_type_ir::GenericArgKind::Lifetime(region) => {
+                let lifetime = convert_region_for_result(region);
+                substs.push(chalk_ir::GenericArgData::Lifetime(lifetime).intern(Interner));
+            }
+            rustc_type_ir::GenericArgKind::Const(const_) => {
+                substs.push(
+                    chalk_ir::GenericArgData::Const(convert_const_for_result(interner, const_))
+                        .intern(Interner),
+                );
+            }
+        }
+    }
+    Substitution::from_iter(Interner, substs)
+}
+
+pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>) -> crate::Ty {
+    use crate::{Scalar, TyKind};
+    use chalk_ir::{FloatTy, IntTy, UintTy};
+    match ty.kind() {
+        rustc_type_ir::TyKind::Bool => TyKind::Scalar(Scalar::Bool),
+        rustc_type_ir::TyKind::Char => TyKind::Scalar(Scalar::Char),
+        rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::I8) => {
+            TyKind::Scalar(Scalar::Int(IntTy::I8))
+        }
+        rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::I16) => {
+            TyKind::Scalar(Scalar::Int(IntTy::I16))
+        }
+        rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::I32) => {
+            TyKind::Scalar(Scalar::Int(IntTy::I32))
+        }
+        rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::I64) => {
+            TyKind::Scalar(Scalar::Int(IntTy::I64))
+        }
+        rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::I128) => {
+            TyKind::Scalar(Scalar::Int(IntTy::I128))
+        }
+        rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::Isize) => {
+            TyKind::Scalar(Scalar::Int(IntTy::Isize))
+        }
+        rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::U8) => {
+            TyKind::Scalar(Scalar::Uint(UintTy::U8))
+        }
+        rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::U16) => {
+            TyKind::Scalar(Scalar::Uint(UintTy::U16))
+        }
+        rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::U32) => {
+            TyKind::Scalar(Scalar::Uint(UintTy::U32))
+        }
+        rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::U64) => {
+            TyKind::Scalar(Scalar::Uint(UintTy::U64))
+        }
+        rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::U128) => {
+            TyKind::Scalar(Scalar::Uint(UintTy::U128))
+        }
+        rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::Usize) => {
+            TyKind::Scalar(Scalar::Uint(UintTy::Usize))
+        }
+        rustc_type_ir::TyKind::Float(rustc_type_ir::FloatTy::F16) => {
+            TyKind::Scalar(Scalar::Float(FloatTy::F16))
+        }
+        rustc_type_ir::TyKind::Float(rustc_type_ir::FloatTy::F32) => {
+            TyKind::Scalar(Scalar::Float(FloatTy::F32))
+        }
+        rustc_type_ir::TyKind::Float(rustc_type_ir::FloatTy::F64) => {
+            TyKind::Scalar(Scalar::Float(FloatTy::F64))
+        }
+        rustc_type_ir::TyKind::Float(rustc_type_ir::FloatTy::F128) => {
+            TyKind::Scalar(Scalar::Float(FloatTy::F128))
+        }
+        rustc_type_ir::TyKind::Str => TyKind::Str,
+        rustc_type_ir::TyKind::Error(_) => TyKind::Error,
+        rustc_type_ir::TyKind::Never => TyKind::Never,
+
+        rustc_type_ir::TyKind::Adt(def, args) => {
+            let adt_id = def.inner().id;
+            let subst = convert_args_for_result(interner, args.as_slice());
+            TyKind::Adt(chalk_ir::AdtId(adt_id), subst)
+        }
+
+        rustc_type_ir::TyKind::Infer(infer_ty) => {
+            let (var, kind) = match infer_ty {
+                rustc_type_ir::InferTy::TyVar(var) => {
+                    (InferenceVar::from(var.as_u32()), TyVariableKind::General)
+                }
+                rustc_type_ir::InferTy::IntVar(var) => {
+                    (InferenceVar::from(var.as_u32()), TyVariableKind::Integer)
+                }
+                rustc_type_ir::InferTy::FloatVar(var) => {
+                    (InferenceVar::from(var.as_u32()), TyVariableKind::Float)
+                }
+                rustc_type_ir::InferTy::FreshFloatTy(..)
+                | rustc_type_ir::InferTy::FreshIntTy(..)
+                | rustc_type_ir::InferTy::FreshTy(..) => {
+                    panic!("Freshening shouldn't happen.")
+                }
+            };
+            TyKind::InferenceVar(var, kind)
+        }
+
+        rustc_type_ir::TyKind::Ref(r, ty, mutability) => {
+            let mutability = match mutability {
+                rustc_ast_ir::Mutability::Mut => chalk_ir::Mutability::Mut,
+                rustc_ast_ir::Mutability::Not => chalk_ir::Mutability::Not,
+            };
+            let r = convert_region_for_result(r);
+            let ty = convert_ty_for_result(interner, ty);
+            TyKind::Ref(mutability, r, ty)
+        }
+
+        rustc_type_ir::TyKind::Tuple(tys) => {
+            let size = tys.len();
+            let subst = Substitution::from_iter(
+                Interner,
+                tys.iter().map(|ty| {
+                    chalk_ir::GenericArgData::Ty(convert_ty_for_result(interner, ty))
+                        .intern(Interner)
+                }),
+            );
+            TyKind::Tuple(size, subst)
+        }
+
+        rustc_type_ir::TyKind::Array(ty, const_) => {
+            let ty = convert_ty_for_result(interner, ty);
+            let const_ = convert_const_for_result(interner, const_);
+            TyKind::Array(ty, const_)
+        }
+
+        rustc_type_ir::TyKind::Alias(alias_ty_kind, alias_ty) => match alias_ty_kind {
+            rustc_type_ir::AliasTyKind::Projection => {
+                let assoc_ty_id = match alias_ty.def_id {
+                    SolverDefId::TypeAliasId(id) => id,
+                    _ => unreachable!(),
+                };
+                let associated_ty_id = to_assoc_type_id(assoc_ty_id);
+                let substitution = convert_args_for_result(interner, alias_ty.args.as_slice());
+                TyKind::AssociatedType(associated_ty_id, substitution)
+            }
+            rustc_type_ir::AliasTyKind::Opaque => {
+                let opaque_ty_id = match alias_ty.def_id {
+                    SolverDefId::InternedOpaqueTyId(id) => id,
+                    _ => unreachable!(),
+                };
+                let substitution = convert_args_for_result(interner, alias_ty.args.as_slice());
+                TyKind::Alias(chalk_ir::AliasTy::Opaque(chalk_ir::OpaqueTy {
+                    opaque_ty_id: opaque_ty_id.into(),
+                    substitution,
+                }))
+            }
+            rustc_type_ir::AliasTyKind::Inherent => unimplemented!(),
+            rustc_type_ir::AliasTyKind::Free => unimplemented!(),
+        },
+
+        rustc_type_ir::TyKind::Placeholder(placeholder) => {
+            let ui = chalk_ir::UniverseIndex { counter: placeholder.universe.as_usize() };
+            let placeholder_index =
+                chalk_ir::PlaceholderIndex { idx: placeholder.bound.var.as_usize(), ui };
+            TyKind::Placeholder(placeholder_index)
+        }
+
+        rustc_type_ir::TyKind::Bound(debruijn_index, ty) => TyKind::BoundVar(chalk_ir::BoundVar {
+            debruijn: chalk_ir::DebruijnIndex::new(debruijn_index.as_u32()),
+            index: ty.var.as_usize(),
+        }),
+
+        rustc_type_ir::TyKind::FnPtr(bound_sig, fn_header) => {
+            let num_binders = bound_sig.bound_vars().len();
+            let sig = chalk_ir::FnSig {
+                abi: fn_header.abi,
+                safety: match fn_header.safety {
+                    crate::next_solver::abi::Safety::Safe => chalk_ir::Safety::Safe,
+                    crate::next_solver::abi::Safety::Unsafe => chalk_ir::Safety::Unsafe,
+                },
+                variadic: fn_header.c_variadic,
+            };
+            let args = GenericArgs::new_from_iter(
+                interner,
+                bound_sig.skip_binder().inputs_and_output.iter().map(|a| a.into()),
+            );
+            let substitution = convert_args_for_result(interner, args.as_slice());
+            let substitution = chalk_ir::FnSubst(substitution);
+            let fnptr = chalk_ir::FnPointer { num_binders, sig, substitution };
+            TyKind::Function(fnptr)
+        }
+
+        rustc_type_ir::TyKind::Dynamic(preds, region, dyn_kind) => {
+            assert!(matches!(dyn_kind, rustc_type_ir::DynKind::Dyn));
+            let self_ty = Ty::new_bound(
+                interner,
+                DebruijnIndex::from_u32(1),
+                BoundTy { kind: BoundTyKind::Anon, var: BoundVar::from_u32(0) },
+            );
+            let bounds = chalk_ir::QuantifiedWhereClauses::from_iter(
+                Interner,
+                preds.iter().map(|p| {
+                    let binders = chalk_ir::VariableKinds::from_iter(
+                        Interner,
+                        p.bound_vars().iter().map(|b| match b {
+                            BoundVarKind::Ty(kind) => {
+                                chalk_ir::VariableKind::Ty(TyVariableKind::General)
+                            }
+                            BoundVarKind::Region(kind) => chalk_ir::VariableKind::Lifetime,
+                            BoundVarKind::Const => {
+                                chalk_ir::VariableKind::Const(crate::TyKind::Error.intern(Interner))
+                            }
+                        }),
+                    );
+                    let where_clause = match p.skip_binder() {
+                        rustc_type_ir::ExistentialPredicate::Trait(trait_ref) => {
+                            let trait_ref = TraitRef::new(
+                                interner,
+                                trait_ref.def_id,
+                                [self_ty.into()].into_iter().chain(trait_ref.args.iter()),
+                            );
+                            let trait_id = match trait_ref.def_id {
+                                SolverDefId::TraitId(id) => to_chalk_trait_id(id),
+                                _ => unreachable!(),
+                            };
+                            let substitution =
+                                convert_args_for_result(interner, trait_ref.args.as_slice());
+                            let trait_ref = chalk_ir::TraitRef { trait_id, substitution };
+                            chalk_ir::WhereClause::Implemented(trait_ref)
+                        }
+                        rustc_type_ir::ExistentialPredicate::AutoTrait(trait_) => {
+                            let trait_id = match trait_ {
+                                SolverDefId::TraitId(id) => to_chalk_trait_id(id),
+                                _ => unreachable!(),
+                            };
+                            let substitution = chalk_ir::Substitution::empty(Interner);
+                            let trait_ref = chalk_ir::TraitRef { trait_id, substitution };
+                            chalk_ir::WhereClause::Implemented(trait_ref)
+                        }
+                        rustc_type_ir::ExistentialPredicate::Projection(existential_projection) => {
+                            let projection = ProjectionPredicate {
+                                projection_term: AliasTerm::new(
+                                    interner,
+                                    existential_projection.def_id,
+                                    [self_ty.into()]
+                                        .iter()
+                                        .chain(existential_projection.args.iter()),
+                                ),
+                                term: existential_projection.term,
+                            };
+                            let associated_ty_id = match projection.projection_term.def_id {
+                                SolverDefId::TypeAliasId(id) => to_assoc_type_id(id),
+                                _ => unreachable!(),
+                            };
+                            let substitution = convert_args_for_result(
+                                interner,
+                                projection.projection_term.args.as_slice(),
+                            );
+                            let alias = chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy {
+                                associated_ty_id,
+                                substitution,
+                            });
+                            let ty = match projection.term {
+                                Term::Ty(ty) => ty,
+                                _ => unreachable!(),
+                            };
+                            let ty = convert_ty_for_result(interner, ty);
+                            let alias_eq = chalk_ir::AliasEq { alias, ty };
+                            chalk_ir::WhereClause::AliasEq(alias_eq)
+                        }
+                    };
+                    chalk_ir::Binders::new(binders, where_clause)
+                }),
+            );
+            let binders = chalk_ir::VariableKinds::from1(
+                Interner,
+                chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General),
+            );
+            let bounds = chalk_ir::Binders::new(binders, bounds);
+            let dyn_ty = chalk_ir::DynTy { bounds, lifetime: convert_region_for_result(region) };
+            TyKind::Dyn(dyn_ty)
+        }
+
+        rustc_type_ir::TyKind::Slice(ty) => {
+            let ty = convert_ty_for_result(interner, ty);
+            TyKind::Slice(ty)
+        }
+
+        rustc_type_ir::TyKind::Foreign(foreign) => {
+            let def_id = match foreign {
+                SolverDefId::ForeignId(id) => id,
+                _ => unreachable!(),
+            };
+            TyKind::Foreign(to_foreign_def_id(def_id))
+        }
+        rustc_type_ir::TyKind::Pat(_, _) => unimplemented!(),
+        rustc_type_ir::TyKind::RawPtr(ty, mutability) => {
+            let mutability = match mutability {
+                rustc_ast_ir::Mutability::Mut => chalk_ir::Mutability::Mut,
+                rustc_ast_ir::Mutability::Not => chalk_ir::Mutability::Not,
+            };
+            let ty = convert_ty_for_result(interner, ty);
+            TyKind::Raw(mutability, ty)
+        }
+        rustc_type_ir::TyKind::FnDef(def_id, args) => {
+            let id = match def_id {
+                SolverDefId::FunctionId(id) => CallableDefId::FunctionId(id),
+                SolverDefId::Ctor(Ctor::Struct(id)) => CallableDefId::StructId(id),
+                SolverDefId::Ctor(Ctor::Enum(id)) => CallableDefId::EnumVariantId(id),
+                _ => unreachable!(),
+            };
+            let subst = convert_args_for_result(interner, args.as_slice());
+            TyKind::FnDef(id.to_chalk(interner.db()), subst)
+        }
+
+        rustc_type_ir::TyKind::Closure(def_id, args) => {
+            let id = match def_id {
+                SolverDefId::InternedClosureId(id) => id,
+                _ => unreachable!(),
+            };
+            let subst = convert_args_for_result(interner, args.as_slice());
+            TyKind::Closure(id.into(), subst)
+        }
+        rustc_type_ir::TyKind::CoroutineClosure(_, _) => unimplemented!(),
+        rustc_type_ir::TyKind::Coroutine(def_id, args) => {
+            let id = match def_id {
+                SolverDefId::InternedCoroutineId(id) => id,
+                _ => unreachable!(),
+            };
+            let subst = convert_args_for_result(interner, args.as_slice());
+            TyKind::Coroutine(id.into(), subst)
+        }
+        rustc_type_ir::TyKind::CoroutineWitness(def_id, args) => {
+            let id = match def_id {
+                SolverDefId::InternedCoroutineId(id) => id,
+                _ => unreachable!(),
+            };
+            let subst = convert_args_for_result(interner, args.as_slice());
+            TyKind::CoroutineWitness(id.into(), subst)
+        }
+
+        rustc_type_ir::TyKind::Param(_) => unimplemented!(),
+        rustc_type_ir::TyKind::UnsafeBinder(_) => unimplemented!(),
+    }
+    .intern(Interner)
+}
+
+fn convert_const_for_result<'db>(interner: DbInterner<'db>, const_: Const<'db>) -> crate::Const {
+    let value: chalk_ir::ConstValue<Interner> = match const_.kind() {
+        rustc_type_ir::ConstKind::Param(_) => unimplemented!(),
+        rustc_type_ir::ConstKind::Infer(rustc_type_ir::InferConst::Var(var)) => {
+            chalk_ir::ConstValue::InferenceVar(chalk_ir::InferenceVar::from(var.as_u32()))
+        }
+        rustc_type_ir::ConstKind::Infer(rustc_type_ir::InferConst::Fresh(fresh)) => {
+            panic!("Vars should not be freshened.")
+        }
+        rustc_type_ir::ConstKind::Bound(debruijn_index, var) => {
+            chalk_ir::ConstValue::BoundVar(chalk_ir::BoundVar::new(
+                chalk_ir::DebruijnIndex::new(debruijn_index.as_u32()),
+                var.index(),
+            ))
+        }
+        rustc_type_ir::ConstKind::Placeholder(placeholder_const) => {
+            chalk_ir::ConstValue::Placeholder(chalk_ir::PlaceholderIndex {
+                ui: chalk_ir::UniverseIndex { counter: placeholder_const.universe.as_usize() },
+                idx: placeholder_const.bound.as_usize(),
+            })
+        }
+        rustc_type_ir::ConstKind::Unevaluated(unevaluated_const) => {
+            let id = match unevaluated_const.def {
+                SolverDefId::ConstId(id) => GeneralConstId::ConstId(id),
+                SolverDefId::StaticId(id) => GeneralConstId::StaticId(id),
+                _ => unreachable!(),
+            };
+            let subst = convert_args_for_result(interner, unevaluated_const.args.as_slice());
+            chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst {
+                interned: ConstScalar::UnevaluatedConst(id, subst),
+            })
+        }
+        rustc_type_ir::ConstKind::Value(value_const) => {
+            let bytes = value_const.value.inner();
+            let value = chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst {
+                interned: ConstScalar::Bytes(bytes.0.clone(), bytes.1.clone()),
+            });
+            return chalk_ir::ConstData {
+                ty: convert_ty_for_result(interner, value_const.ty),
+                value,
+            }
+            .intern(Interner);
+        }
+        rustc_type_ir::ConstKind::Error(_) => {
+            chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst {
+                interned: ConstScalar::Unknown,
+            })
+        }
+        rustc_type_ir::ConstKind::Expr(_) => unimplemented!(),
+    };
+    chalk_ir::ConstData { ty: crate::TyKind::Error.intern(Interner), value }.intern(Interner)
+}
+
+fn convert_region_for_result<'db>(region: Region<'db>) -> crate::Lifetime {
+    match region.kind() {
+        rustc_type_ir::RegionKind::ReEarlyParam(early) => unimplemented!(),
+        rustc_type_ir::RegionKind::ReBound(db, bound) => chalk_ir::Lifetime::new(
+            Interner,
+            chalk_ir::LifetimeData::BoundVar(chalk_ir::BoundVar::new(
+                chalk_ir::DebruijnIndex::new(db.as_u32()),
+                bound.var.as_usize(),
+            )),
+        ),
+        rustc_type_ir::RegionKind::ReLateParam(_) => unimplemented!(),
+        rustc_type_ir::RegionKind::ReStatic => {
+            chalk_ir::Lifetime::new(Interner, chalk_ir::LifetimeData::Static)
+        }
+        rustc_type_ir::RegionKind::ReVar(vid) => chalk_ir::Lifetime::new(
+            Interner,
+            chalk_ir::LifetimeData::InferenceVar(chalk_ir::InferenceVar::from(vid.as_u32())),
+        ),
+        rustc_type_ir::RegionKind::RePlaceholder(placeholder) => chalk_ir::Lifetime::new(
+            Interner,
+            chalk_ir::LifetimeData::Placeholder(chalk_ir::PlaceholderIndex {
+                idx: placeholder.bound.var.as_usize(),
+                ui: chalk_ir::UniverseIndex { counter: placeholder.universe.as_usize() },
+            }),
+        ),
+        rustc_type_ir::RegionKind::ReErased => {
+            chalk_ir::Lifetime::new(Interner, chalk_ir::LifetimeData::Erased)
+        }
+        rustc_type_ir::RegionKind::ReError(_) => {
+            chalk_ir::Lifetime::new(Interner, chalk_ir::LifetimeData::Error)
+        }
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/opaques.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/opaques.rs
new file mode 100644
index 0000000000000..43589ab2ef139
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/opaques.rs
@@ -0,0 +1,167 @@
+//! Things related to opaques in the next-trait-solver.
+
+use intern::Interned;
+use rustc_ast_ir::try_visit;
+
+use crate::next_solver::SolverDefId;
+
+use super::{CanonicalVarKind, DbInterner, interned_vec_nolifetime_salsa};
+
+pub type OpaqueTypeKey<'db> = rustc_type_ir::OpaqueTypeKey<DbInterner<'db>>;
+pub type PredefinedOpaquesData<'db> = rustc_type_ir::solve::PredefinedOpaquesData<DbInterner<'db>>;
+pub type ExternalConstraintsData<'db> =
+    rustc_type_ir::solve::ExternalConstraintsData<DbInterner<'db>>;
+
+#[salsa::interned(constructor = new_, debug)]
+pub struct PredefinedOpaques<'db> {
+    #[returns(ref)]
+    kind_: rustc_type_ir::solve::PredefinedOpaquesData<DbInterner<'db>>,
+}
+
+impl<'db> PredefinedOpaques<'db> {
+    pub fn new(interner: DbInterner<'db>, data: PredefinedOpaquesData<'db>) -> Self {
+        PredefinedOpaques::new_(interner.db(), data)
+    }
+
+    pub fn inner(&self) -> &PredefinedOpaquesData<'db> {
+        salsa::with_attached_database(|db| {
+            let inner = self.kind_(db);
+            // SAFETY: ¯\_(ツ)_/¯
+            unsafe { std::mem::transmute(inner) }
+        })
+        .unwrap()
+    }
+}
+
+impl<'db> rustc_type_ir::TypeVisitable<DbInterner<'db>> for PredefinedOpaques<'db> {
+    fn visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>(
+        &self,
+        visitor: &mut V,
+    ) -> V::Result {
+        self.opaque_types.visit_with(visitor)
+    }
+}
+
+impl<'db> rustc_type_ir::TypeFoldable<DbInterner<'db>> for PredefinedOpaques<'db> {
+    fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>(
+        self,
+        folder: &mut F,
+    ) -> Result<Self, F::Error> {
+        Ok(PredefinedOpaques::new(
+            folder.cx(),
+            PredefinedOpaquesData {
+                opaque_types: self
+                    .opaque_types
+                    .iter()
+                    .cloned()
+                    .map(|opaque| opaque.try_fold_with(folder))
+                    .collect::<Result<_, F::Error>>()?,
+            },
+        ))
+    }
+    fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self {
+        PredefinedOpaques::new(
+            folder.cx(),
+            PredefinedOpaquesData {
+                opaque_types: self
+                    .opaque_types
+                    .iter()
+                    .cloned()
+                    .map(|opaque| opaque.fold_with(folder))
+                    .collect(),
+            },
+        )
+    }
+}
+
+impl<'db> std::ops::Deref for PredefinedOpaques<'db> {
+    type Target = PredefinedOpaquesData<'db>;
+
+    fn deref(&self) -> &Self::Target {
+        self.inner()
+    }
+}
+
+interned_vec_nolifetime_salsa!(SolverDefIds, SolverDefId);
+
+#[salsa::interned(constructor = new_, debug)]
+pub struct ExternalConstraints<'db> {
+    #[returns(ref)]
+    kind_: rustc_type_ir::solve::ExternalConstraintsData<DbInterner<'db>>,
+}
+
+impl<'db> ExternalConstraints<'db> {
+    pub fn new(interner: DbInterner<'db>, data: ExternalConstraintsData<'db>) -> Self {
+        ExternalConstraints::new_(interner.db(), data)
+    }
+
+    pub fn inner(&self) -> &ExternalConstraintsData<'db> {
+        salsa::with_attached_database(|db| {
+            let inner = self.kind_(db);
+            // SAFETY: ¯\_(ツ)_/¯
+            unsafe { std::mem::transmute(inner) }
+        })
+        .unwrap()
+    }
+}
+
+impl<'db> std::ops::Deref for ExternalConstraints<'db> {
+    type Target = ExternalConstraintsData<'db>;
+
+    fn deref(&self) -> &Self::Target {
+        self.inner()
+    }
+}
+
+impl<'db> rustc_type_ir::TypeVisitable<DbInterner<'db>> for ExternalConstraints<'db> {
+    fn visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>(
+        &self,
+        visitor: &mut V,
+    ) -> V::Result {
+        try_visit!(self.region_constraints.visit_with(visitor));
+        try_visit!(self.opaque_types.visit_with(visitor));
+        self.normalization_nested_goals.visit_with(visitor)
+    }
+}
+
+impl<'db> rustc_type_ir::TypeFoldable<DbInterner<'db>> for ExternalConstraints<'db> {
+    fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>(
+        self,
+        folder: &mut F,
+    ) -> Result<Self, F::Error> {
+        Ok(ExternalConstraints::new(
+            folder.cx(),
+            ExternalConstraintsData {
+                region_constraints: self.region_constraints.clone().try_fold_with(folder)?,
+                opaque_types: self
+                    .opaque_types
+                    .iter()
+                    .cloned()
+                    .map(|opaque| opaque.try_fold_with(folder))
+                    .collect::<Result<_, F::Error>>()?,
+                normalization_nested_goals: self
+                    .normalization_nested_goals
+                    .clone()
+                    .try_fold_with(folder)?,
+            },
+        ))
+    }
+    fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self {
+        ExternalConstraints::new(
+            folder.cx(),
+            ExternalConstraintsData {
+                region_constraints: self.region_constraints.clone().fold_with(folder),
+                opaque_types: self
+                    .opaque_types
+                    .iter()
+                    .cloned()
+                    .map(|opaque| opaque.fold_with(folder))
+                    .collect(),
+                normalization_nested_goals: self
+                    .normalization_nested_goals
+                    .clone()
+                    .fold_with(folder),
+            },
+        )
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/predicate.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/predicate.rs
new file mode 100644
index 0000000000000..50261bb5e3816
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/predicate.rs
@@ -0,0 +1,894 @@
+//! Things related to predicates.
+
+use std::cmp::Ordering;
+
+use intern::Interned;
+use rustc_ast_ir::try_visit;
+use rustc_type_ir::{
+    self as ty, CollectAndApply, DebruijnIndex, EarlyBinder, FlagComputation, Flags,
+    PredicatePolarity, TypeFlags, TypeFoldable, TypeSuperFoldable, TypeSuperVisitable,
+    TypeVisitable, Upcast, UpcastFrom, VisitorResult, WithCachedTypeInfo,
+    elaborate::Elaboratable,
+    error::{ExpectedFound, TypeError},
+    inherent::{IntoKind, SliceLike},
+    relate::Relate,
+};
+use smallvec::{SmallVec, smallvec};
+
+use super::{Binder, BoundVarKinds, DbInterner, Region, Ty, interned_vec_db};
+
+pub type BoundExistentialPredicate<'db> = Binder<'db, ExistentialPredicate<'db>>;
+
+pub type TraitRef<'db> = ty::TraitRef<DbInterner<'db>>;
+pub type AliasTerm<'db> = ty::AliasTerm<DbInterner<'db>>;
+pub type ProjectionPredicate<'db> = ty::ProjectionPredicate<DbInterner<'db>>;
+pub type ExistentialPredicate<'db> = ty::ExistentialPredicate<DbInterner<'db>>;
+pub type ExistentialTraitRef<'db> = ty::ExistentialTraitRef<DbInterner<'db>>;
+pub type ExistentialProjection<'db> = ty::ExistentialProjection<DbInterner<'db>>;
+pub type TraitPredicate<'db> = ty::TraitPredicate<DbInterner<'db>>;
+pub type ClauseKind<'db> = ty::ClauseKind<DbInterner<'db>>;
+pub type PredicateKind<'db> = ty::PredicateKind<DbInterner<'db>>;
+pub type NormalizesTo<'db> = ty::NormalizesTo<DbInterner<'db>>;
+pub type CoercePredicate<'db> = ty::CoercePredicate<DbInterner<'db>>;
+pub type SubtypePredicate<'db> = ty::SubtypePredicate<DbInterner<'db>>;
+pub type OutlivesPredicate<'db, T> = ty::OutlivesPredicate<DbInterner<'db>, T>;
+pub type RegionOutlivesPredicate<'db> = OutlivesPredicate<'db, Region<'db>>;
+pub type TypeOutlivesPredicate<'db> = OutlivesPredicate<'db, Ty<'db>>;
+pub type PolyTraitPredicate<'db> = Binder<'db, TraitPredicate<'db>>;
+pub type PolyRegionOutlivesPredicate<'db> = Binder<'db, RegionOutlivesPredicate<'db>>;
+pub type PolyTypeOutlivesPredicate<'db> = Binder<'db, TypeOutlivesPredicate<'db>>;
+pub type PolySubtypePredicate<'db> = Binder<'db, SubtypePredicate<'db>>;
+pub type PolyCoercePredicate<'db> = Binder<'db, CoercePredicate<'db>>;
+pub type PolyProjectionPredicate<'db> = Binder<'db, ProjectionPredicate<'db>>;
+pub type PolyTraitRef<'db> = Binder<'db, TraitRef<'db>>;
+pub type PolyExistentialTraitRef<'db> = Binder<'db, ExistentialTraitRef<'db>>;
+pub type PolyExistentialProjection<'db> = Binder<'db, ExistentialProjection<'db>>;
+
+/// Compares via an ordering that will not change if modules are reordered or other changes are
+/// made to the tree. In particular, this ordering is preserved across incremental compilations.
+fn stable_cmp_existential_predicate<'db>(
+    a: &ExistentialPredicate<'db>,
+    b: &ExistentialPredicate<'db>,
+) -> Ordering {
+    // FIXME: this is actual unstable - see impl in predicate.rs in `rustc_middle`
+    match (a, b) {
+        (ExistentialPredicate::Trait(_), ExistentialPredicate::Trait(_)) => Ordering::Equal,
+        (ExistentialPredicate::Projection(a), ExistentialPredicate::Projection(b)) => {
+            // Should sort by def path hash
+            Ordering::Equal
+        }
+        (ExistentialPredicate::AutoTrait(a), ExistentialPredicate::AutoTrait(b)) => {
+            // Should sort by def path hash
+            Ordering::Equal
+        }
+        (ExistentialPredicate::Trait(_), _) => Ordering::Less,
+        (ExistentialPredicate::Projection(_), ExistentialPredicate::Trait(_)) => Ordering::Greater,
+        (ExistentialPredicate::Projection(_), _) => Ordering::Less,
+        (ExistentialPredicate::AutoTrait(_), _) => Ordering::Greater,
+    }
+}
+interned_vec_db!(BoundExistentialPredicates, BoundExistentialPredicate);
+
+impl<'db> rustc_type_ir::inherent::BoundExistentialPredicates<DbInterner<'db>>
+    for BoundExistentialPredicates<'db>
+{
+    fn principal_def_id(self) -> Option<<DbInterner<'db> as rustc_type_ir::Interner>::DefId> {
+        self.principal().map(|trait_ref| trait_ref.skip_binder().def_id)
+    }
+
+    fn principal(
+        self,
+    ) -> Option<
+        rustc_type_ir::Binder<DbInterner<'db>, rustc_type_ir::ExistentialTraitRef<DbInterner<'db>>>,
+    > {
+        self.inner()[0]
+            .map_bound(|this| match this {
+                ExistentialPredicate::Trait(tr) => Some(tr),
+                _ => None,
+            })
+            .transpose()
+    }
+
+    fn auto_traits(
+        self,
+    ) -> impl IntoIterator<Item = <DbInterner<'db> as rustc_type_ir::Interner>::DefId> {
+        self.iter().filter_map(|predicate| match predicate.skip_binder() {
+            ExistentialPredicate::AutoTrait(did) => Some(did),
+            _ => None,
+        })
+    }
+
+    fn projection_bounds(
+        self,
+    ) -> impl IntoIterator<
+        Item = rustc_type_ir::Binder<
+            DbInterner<'db>,
+            rustc_type_ir::ExistentialProjection<DbInterner<'db>>,
+        >,
+    > {
+        self.iter().filter_map(|predicate| {
+            predicate
+                .map_bound(|pred| match pred {
+                    ExistentialPredicate::Projection(projection) => Some(projection),
+                    _ => None,
+                })
+                .transpose()
+        })
+    }
+}
+
+impl<'db> rustc_type_ir::relate::Relate<DbInterner<'db>> for BoundExistentialPredicates<'db> {
+    fn relate<R: rustc_type_ir::relate::TypeRelation<DbInterner<'db>>>(
+        relation: &mut R,
+        a: Self,
+        b: Self,
+    ) -> rustc_type_ir::relate::RelateResult<DbInterner<'db>, Self> {
+        let interner = relation.cx();
+
+        // We need to perform this deduplication as we sometimes generate duplicate projections in `a`.
+        let mut a_v: Vec<_> = a.into_iter().collect();
+        let mut b_v: Vec<_> = b.into_iter().collect();
+        // `skip_binder` here is okay because `stable_cmp` doesn't look at binders
+        a_v.sort_by(|a, b| {
+            stable_cmp_existential_predicate(a.as_ref().skip_binder(), b.as_ref().skip_binder())
+        });
+        a_v.dedup();
+        b_v.sort_by(|a, b| {
+            stable_cmp_existential_predicate(a.as_ref().skip_binder(), b.as_ref().skip_binder())
+        });
+        b_v.dedup();
+        if a_v.len() != b_v.len() {
+            return Err(TypeError::ExistentialMismatch(ExpectedFound::new(a, b)));
+        }
+
+        let v = std::iter::zip(a_v, b_v).map(
+            |(ep_a, ep_b): (
+                Binder<'_, ty::ExistentialPredicate<_>>,
+                Binder<'_, ty::ExistentialPredicate<_>>,
+            )| {
+                match (ep_a.skip_binder(), ep_b.skip_binder()) {
+                    (ty::ExistentialPredicate::Trait(a), ty::ExistentialPredicate::Trait(b)) => {
+                        Ok(ep_a.rebind(ty::ExistentialPredicate::Trait(
+                            relation.relate(ep_a.rebind(a), ep_b.rebind(b))?.skip_binder(),
+                        )))
+                    }
+                    (
+                        ty::ExistentialPredicate::Projection(a),
+                        ty::ExistentialPredicate::Projection(b),
+                    ) => Ok(ep_a.rebind(ty::ExistentialPredicate::Projection(
+                        relation.relate(ep_a.rebind(a), ep_b.rebind(b))?.skip_binder(),
+                    ))),
+                    (
+                        ty::ExistentialPredicate::AutoTrait(a),
+                        ty::ExistentialPredicate::AutoTrait(b),
+                    ) if a == b => Ok(ep_a.rebind(ty::ExistentialPredicate::AutoTrait(a))),
+                    _ => Err(TypeError::ExistentialMismatch(ExpectedFound::new(a, b))),
+                }
+            },
+        );
+
+        CollectAndApply::collect_and_apply(v, |g| {
+            BoundExistentialPredicates::new_from_iter(interner, g.iter().cloned())
+        })
+    }
+}
+
+#[derive(PartialEq, Eq, Hash, PartialOrd, Ord, Clone)]
+pub struct InternedWrapperNoDebug<T>(pub(crate) T);
+
+#[salsa::interned(constructor = new_)]
+pub struct Predicate<'db> {
+    #[returns(ref)]
+    kind_: InternedWrapperNoDebug<WithCachedTypeInfo<Binder<'db, PredicateKind<'db>>>>,
+}
+
+impl<'db> std::fmt::Debug for Predicate<'db> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.inner().internee.fmt(f)
+    }
+}
+
+impl<'db> std::fmt::Debug
+    for InternedWrapperNoDebug<WithCachedTypeInfo<Binder<'db, PredicateKind<'db>>>>
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Binder<")?;
+        match self.0.internee.skip_binder() {
+            rustc_type_ir::PredicateKind::Clause(clause_kind) => {
+                write!(f, "{clause_kind:?}")
+            }
+            rustc_type_ir::PredicateKind::DynCompatible(trait_def_id) => {
+                write!(f, "the trait `{trait_def_id:?}` is dyn-compatible")
+            }
+            rustc_type_ir::PredicateKind::Subtype(subtype_predicate) => {
+                write!(f, "{subtype_predicate:?}")
+            }
+            rustc_type_ir::PredicateKind::Coerce(coerce_predicate) => {
+                write!(f, "{coerce_predicate:?}")
+            }
+            rustc_type_ir::PredicateKind::ConstEquate(c1, c2) => {
+                write!(f, "the constant `{c1:?}` equals `{c2:?}`")
+            }
+            rustc_type_ir::PredicateKind::Ambiguous => write!(f, "ambiguous"),
+            rustc_type_ir::PredicateKind::NormalizesTo(data) => write!(f, "{data:?}"),
+            rustc_type_ir::PredicateKind::AliasRelate(t1, t2, dir) => {
+                write!(f, "{t1:?} {dir:?} {t2:?}")
+            }
+        }?;
+        write!(f, ", [{:?}]>", self.0.internee.bound_vars())?;
+        Ok(())
+    }
+}
+
+impl<'db> Predicate<'db> {
+    pub fn new(interner: DbInterner<'db>, kind: Binder<'db, PredicateKind<'db>>) -> Self {
+        let flags = FlagComputation::for_predicate(kind);
+        let cached = WithCachedTypeInfo {
+            internee: kind,
+            flags: flags.flags,
+            outer_exclusive_binder: flags.outer_exclusive_binder,
+        };
+        Predicate::new_(interner.db(), InternedWrapperNoDebug(cached))
+    }
+
+    pub fn inner(&self) -> &WithCachedTypeInfo<Binder<'db, PredicateKind<'db>>> {
+        salsa::with_attached_database(|db| {
+            let inner = &self.kind_(db).0;
+            // SAFETY: The caller already has access to a `Predicate<'db>`, so borrowchecking will
+            // make sure that our returned value is valid for the lifetime `'db`.
+            unsafe { std::mem::transmute(inner) }
+        })
+        .unwrap()
+    }
+
+    /// Flips the polarity of a Predicate.
+    ///
+    /// Given `T: Trait` predicate it returns `T: !Trait` and given `T: !Trait` returns `T: Trait`.
+    pub fn flip_polarity(self) -> Option<Predicate<'db>> {
+        let kind = self
+            .kind()
+            .map_bound(|kind| match kind {
+                PredicateKind::Clause(ClauseKind::Trait(TraitPredicate {
+                    trait_ref,
+                    polarity,
+                })) => Some(PredicateKind::Clause(ClauseKind::Trait(TraitPredicate {
+                    trait_ref,
+                    polarity: polarity.flip(),
+                }))),
+
+                _ => None,
+            })
+            .transpose()?;
+
+        Some(Predicate::new(DbInterner::conjure(), kind))
+    }
+
+    pub fn as_trait_clause(self) -> Option<PolyTraitPredicate<'db>> {
+        let predicate = self.kind();
+        match predicate.skip_binder() {
+            PredicateKind::Clause(ClauseKind::Trait(t)) => Some(predicate.rebind(t)),
+            PredicateKind::Clause(ClauseKind::Projection(..))
+            | PredicateKind::Clause(ClauseKind::HostEffect(..))
+            | PredicateKind::Clause(ClauseKind::ConstArgHasType(..))
+            | PredicateKind::Clause(ClauseKind::UnstableFeature(_))
+            | PredicateKind::NormalizesTo(..)
+            | PredicateKind::AliasRelate(..)
+            | PredicateKind::Subtype(..)
+            | PredicateKind::Coerce(..)
+            | PredicateKind::Clause(ClauseKind::RegionOutlives(..))
+            | PredicateKind::Clause(ClauseKind::WellFormed(..))
+            | PredicateKind::DynCompatible(..)
+            | PredicateKind::Clause(ClauseKind::TypeOutlives(..))
+            | PredicateKind::Clause(ClauseKind::ConstEvaluatable(..))
+            | PredicateKind::ConstEquate(..)
+            | PredicateKind::Ambiguous => None,
+        }
+    }
+}
+
+// FIXME: should make a "header" in interned_vec
+
+#[derive(Debug, Clone)]
+pub struct InternedClausesWrapper<'db>(SmallVec<[Clause<'db>; 2]>, TypeFlags, DebruijnIndex);
+
+impl<'db> PartialEq for InternedClausesWrapper<'db> {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.eq(&other.0)
+    }
+}
+
+impl<'db> Eq for InternedClausesWrapper<'db> {}
+
+impl<'db> std::hash::Hash for InternedClausesWrapper<'db> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.0.hash(state)
+    }
+}
+
+type InternedClauses<'db> = Interned<InternedClausesWrapper<'db>>;
+
+#[salsa::interned(constructor = new_)]
+pub struct Clauses<'db> {
+    #[returns(ref)]
+    inner_: InternedClausesWrapper<'db>,
+}
+
+impl<'db> Clauses<'db> {
+    pub fn new_from_iter(
+        interner: DbInterner<'db>,
+        data: impl IntoIterator<Item = Clause<'db>>,
+    ) -> Self {
+        let clauses: SmallVec<_> = data.into_iter().collect();
+        let flags = FlagComputation::<DbInterner<'db>>::for_clauses(&clauses);
+        let wrapper = InternedClausesWrapper(clauses, flags.flags, flags.outer_exclusive_binder);
+        Clauses::new_(interner.db(), wrapper)
+    }
+
+    pub fn inner(&self) -> &InternedClausesWrapper<'db> {
+        salsa::with_attached_database(|db| {
+            let inner = self.inner_(db);
+            // SAFETY: The caller already has access to a `Clauses<'db>`, so borrowchecking will
+            // make sure that our returned value is valid for the lifetime `'db`.
+            unsafe { std::mem::transmute(inner) }
+        })
+        .unwrap()
+    }
+}
+
+impl<'db> std::fmt::Debug for Clauses<'db> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.inner().0.fmt(f)
+    }
+}
+
+impl<'db> rustc_type_ir::inherent::Clauses<DbInterner<'db>> for Clauses<'db> {}
+
+impl<'db> rustc_type_ir::inherent::SliceLike for Clauses<'db> {
+    type Item = Clause<'db>;
+
+    type IntoIter = <smallvec::SmallVec<[Clause<'db>; 2]> as IntoIterator>::IntoIter;
+
+    fn iter(self) -> Self::IntoIter {
+        self.inner().0.clone().into_iter()
+    }
+
+    fn as_slice(&self) -> &[Self::Item] {
+        self.inner().0.as_slice()
+    }
+}
+
+impl<'db> IntoIterator for Clauses<'db> {
+    type Item = Clause<'db>;
+    type IntoIter = <Self as rustc_type_ir::inherent::SliceLike>::IntoIter;
+
+    fn into_iter(self) -> Self::IntoIter {
+        rustc_type_ir::inherent::SliceLike::iter(self)
+    }
+}
+
+impl<'db> Default for Clauses<'db> {
+    fn default() -> Self {
+        Clauses::new_from_iter(DbInterner::conjure(), [])
+    }
+}
+
+impl<'db> rustc_type_ir::TypeSuperFoldable<DbInterner<'db>> for Clauses<'db> {
+    fn try_super_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>(
+        self,
+        folder: &mut F,
+    ) -> Result<Self, F::Error> {
+        let mut clauses: SmallVec<[_; 2]> = SmallVec::with_capacity(self.inner().0.len());
+        for c in self {
+            clauses.push(c.try_fold_with(folder)?);
+        }
+        Ok(Clauses::new_from_iter(folder.cx(), clauses))
+    }
+
+    fn super_fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(
+        self,
+        folder: &mut F,
+    ) -> Self {
+        let mut clauses: SmallVec<[_; 2]> = SmallVec::with_capacity(self.inner().0.len());
+        for c in self {
+            clauses.push(c.fold_with(folder));
+        }
+        Clauses::new_from_iter(folder.cx(), clauses)
+    }
+}
+
+impl<'db> rustc_type_ir::TypeFoldable<DbInterner<'db>> for Clauses<'db> {
+    fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>(
+        self,
+        folder: &mut F,
+    ) -> Result<Self, F::Error> {
+        use rustc_type_ir::inherent::SliceLike as _;
+        let inner: smallvec::SmallVec<[_; 2]> =
+            self.iter().map(|v| v.try_fold_with(folder)).collect::<Result<_, _>>()?;
+        Ok(Clauses::new_from_iter(folder.cx(), inner))
+    }
+    fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self {
+        use rustc_type_ir::inherent::SliceLike as _;
+        let inner: smallvec::SmallVec<[_; 2]> = self.iter().map(|v| v.fold_with(folder)).collect();
+        Clauses::new_from_iter(folder.cx(), inner)
+    }
+}
+
+impl<'db> rustc_type_ir::TypeVisitable<DbInterner<'db>> for Clauses<'db> {
+    fn visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>(
+        &self,
+        visitor: &mut V,
+    ) -> V::Result {
+        use rustc_ast_ir::visit::VisitorResult;
+        use rustc_type_ir::inherent::SliceLike as _;
+        rustc_ast_ir::walk_visitable_list!(visitor, self.as_slice().iter());
+        V::Result::output()
+    }
+}
+
+impl<'db> rustc_type_ir::Flags for Clauses<'db> {
+    fn flags(&self) -> rustc_type_ir::TypeFlags {
+        self.inner().1
+    }
+
+    fn outer_exclusive_binder(&self) -> rustc_type_ir::DebruijnIndex {
+        self.inner().2
+    }
+}
+
+impl<'db> rustc_type_ir::TypeSuperVisitable<DbInterner<'db>> for Clauses<'db> {
+    fn super_visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>(
+        &self,
+        visitor: &mut V,
+    ) -> V::Result {
+        self.as_slice().visit_with(visitor)
+    }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)] // TODO implement Debug by hand
+pub struct Clause<'db>(pub(crate) Predicate<'db>);
+
+// We could cram the reveal into the clauses like rustc does, probably
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+pub struct ParamEnv<'db> {
+    pub(crate) clauses: Clauses<'db>,
+}
+
+impl<'db> ParamEnv<'db> {
+    pub fn empty() -> Self {
+        ParamEnv { clauses: Clauses::new_from_iter(DbInterner::conjure(), []) }
+    }
+}
+
+impl<'db> TypeVisitable<DbInterner<'db>> for ParamEnv<'db> {
+    fn visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>(
+        &self,
+        visitor: &mut V,
+    ) -> V::Result {
+        try_visit!(self.clauses.visit_with(visitor));
+        V::Result::output()
+    }
+}
+
+impl<'db> TypeFoldable<DbInterner<'db>> for ParamEnv<'db> {
+    fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>(
+        self,
+        folder: &mut F,
+    ) -> Result<Self, F::Error> {
+        Ok(ParamEnv { clauses: self.clauses.try_fold_with(folder)? })
+    }
+    fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self {
+        ParamEnv { clauses: self.clauses.fold_with(folder) }
+    }
+}
+
+impl<'db> rustc_type_ir::inherent::ParamEnv<DbInterner<'db>> for ParamEnv<'db> {
+    fn caller_bounds(self) -> impl rustc_type_ir::inherent::SliceLike<Item = Clause<'db>> {
+        self.clauses
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct ParamEnvAnd<'db, T> {
+    pub param_env: ParamEnv<'db>,
+    pub value: T,
+}
+
+impl<'db, T> ParamEnvAnd<'db, T> {
+    pub fn into_parts(self) -> (ParamEnv<'db>, T) {
+        (self.param_env, self.value)
+    }
+}
+
+impl<'db> TypeVisitable<DbInterner<'db>> for Predicate<'db> {
+    fn visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>(
+        &self,
+        visitor: &mut V,
+    ) -> V::Result {
+        visitor.visit_predicate(*self)
+    }
+}
+
+impl<'db> TypeSuperVisitable<DbInterner<'db>> for Predicate<'db> {
+    fn super_visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>(
+        &self,
+        visitor: &mut V,
+    ) -> V::Result {
+        (*self).kind().visit_with(visitor)
+    }
+}
+
+impl<'db> TypeFoldable<DbInterner<'db>> for Predicate<'db> {
+    fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>(
+        self,
+        folder: &mut F,
+    ) -> Result<Self, F::Error> {
+        folder.try_fold_predicate(self)
+    }
+    fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self {
+        folder.fold_predicate(self)
+    }
+}
+
+impl<'db> TypeSuperFoldable<DbInterner<'db>> for Predicate<'db> {
+    fn try_super_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>(
+        self,
+        folder: &mut F,
+    ) -> Result<Self, F::Error> {
+        let new = self.kind().try_fold_with(folder)?;
+        Ok(Predicate::new(folder.cx(), new))
+    }
+    fn super_fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(
+        self,
+        folder: &mut F,
+    ) -> Self {
+        let new = self.kind().fold_with(folder);
+        Predicate::new(folder.cx(), new)
+    }
+}
+
+impl<'db> Elaboratable<DbInterner<'db>> for Predicate<'db> {
+    fn predicate(&self) -> <DbInterner<'db> as rustc_type_ir::Interner>::Predicate {
+        *self
+    }
+
+    fn child(&self, clause: <DbInterner<'db> as rustc_type_ir::Interner>::Clause) -> Self {
+        clause.as_predicate()
+    }
+
+    fn child_with_derived_cause(
+        &self,
+        clause: <DbInterner<'db> as rustc_type_ir::Interner>::Clause,
+        _span: <DbInterner<'db> as rustc_type_ir::Interner>::Span,
+        _parent_trait_pred: rustc_type_ir::Binder<
+            DbInterner<'db>,
+            rustc_type_ir::TraitPredicate<DbInterner<'db>>,
+        >,
+        _index: usize,
+    ) -> Self {
+        clause.as_predicate()
+    }
+}
+
+impl<'db> Flags for Predicate<'db> {
+    fn flags(&self) -> rustc_type_ir::TypeFlags {
+        self.inner().flags
+    }
+
+    fn outer_exclusive_binder(&self) -> rustc_type_ir::DebruijnIndex {
+        self.inner().outer_exclusive_binder
+    }
+}
+
+impl<'db> IntoKind for Predicate<'db> {
+    type Kind = Binder<'db, PredicateKind<'db>>;
+
+    fn kind(self) -> Self::Kind {
+        self.inner().internee
+    }
+}
+
+impl<'db> UpcastFrom<DbInterner<'db>, ty::PredicateKind<DbInterner<'db>>> for Predicate<'db> {
+    fn upcast_from(from: ty::PredicateKind<DbInterner<'db>>, interner: DbInterner<'db>) -> Self {
+        Binder::dummy(from).upcast(interner)
+    }
+}
+impl<'db>
+    UpcastFrom<DbInterner<'db>, ty::Binder<DbInterner<'db>, ty::PredicateKind<DbInterner<'db>>>>
+    for Predicate<'db>
+{
+    fn upcast_from(
+        from: ty::Binder<DbInterner<'db>, ty::PredicateKind<DbInterner<'db>>>,
+        interner: DbInterner<'db>,
+    ) -> Self {
+        Predicate::new(interner, from)
+    }
+}
+impl<'db> UpcastFrom<DbInterner<'db>, ty::ClauseKind<DbInterner<'db>>> for Predicate<'db> {
+    fn upcast_from(from: ty::ClauseKind<DbInterner<'db>>, interner: DbInterner<'db>) -> Self {
+        Binder::dummy(PredicateKind::Clause(from)).upcast(interner)
+    }
+}
+impl<'db> UpcastFrom<DbInterner<'db>, ty::Binder<DbInterner<'db>, ty::ClauseKind<DbInterner<'db>>>>
+    for Predicate<'db>
+{
+    fn upcast_from(
+        from: ty::Binder<DbInterner<'db>, ty::ClauseKind<DbInterner<'db>>>,
+        interner: DbInterner<'db>,
+    ) -> Self {
+        from.map_bound(PredicateKind::Clause).upcast(interner)
+    }
+}
+impl<'db> UpcastFrom<DbInterner<'db>, Clause<'db>> for Predicate<'db> {
+    fn upcast_from(from: Clause<'db>, _interner: DbInterner<'db>) -> Self {
+        from.0
+    }
+}
+impl<'db> UpcastFrom<DbInterner<'db>, ty::NormalizesTo<DbInterner<'db>>> for Predicate<'db> {
+    fn upcast_from(from: ty::NormalizesTo<DbInterner<'db>>, interner: DbInterner<'db>) -> Self {
+        PredicateKind::NormalizesTo(from).upcast(interner)
+    }
+}
+impl<'db> UpcastFrom<DbInterner<'db>, ty::TraitRef<DbInterner<'db>>> for Predicate<'db> {
+    fn upcast_from(from: ty::TraitRef<DbInterner<'db>>, interner: DbInterner<'db>) -> Self {
+        Binder::dummy(from).upcast(interner)
+    }
+}
+impl<'db> UpcastFrom<DbInterner<'db>, ty::Binder<DbInterner<'db>, ty::TraitRef<DbInterner<'db>>>>
+    for Predicate<'db>
+{
+    fn upcast_from(
+        from: ty::Binder<DbInterner<'db>, ty::TraitRef<DbInterner<'db>>>,
+        interner: DbInterner<'db>,
+    ) -> Self {
+        from.map_bound(|trait_ref| TraitPredicate {
+            trait_ref,
+            polarity: PredicatePolarity::Positive,
+        })
+        .upcast(interner)
+    }
+}
+impl<'db> UpcastFrom<DbInterner<'db>, Binder<'db, ty::TraitPredicate<DbInterner<'db>>>>
+    for Predicate<'db>
+{
+    fn upcast_from(
+        from: Binder<'db, ty::TraitPredicate<DbInterner<'db>>>,
+        interner: DbInterner<'db>,
+    ) -> Self {
+        from.map_bound(|it| PredicateKind::Clause(ClauseKind::Trait(it))).upcast(interner)
+    }
+}
+impl<'db> UpcastFrom<DbInterner<'db>, Binder<'db, ProjectionPredicate<'db>>> for Predicate<'db> {
+    fn upcast_from(from: Binder<'db, ProjectionPredicate<'db>>, interner: DbInterner<'db>) -> Self {
+        from.map_bound(|it| PredicateKind::Clause(ClauseKind::Projection(it))).upcast(interner)
+    }
+}
+impl<'db> UpcastFrom<DbInterner<'db>, ProjectionPredicate<'db>> for Predicate<'db> {
+    fn upcast_from(from: ProjectionPredicate<'db>, interner: DbInterner<'db>) -> Self {
+        PredicateKind::Clause(ClauseKind::Projection(from)).upcast(interner)
+    }
+}
+impl<'db> UpcastFrom<DbInterner<'db>, ty::TraitPredicate<DbInterner<'db>>> for Predicate<'db> {
+    fn upcast_from(from: ty::TraitPredicate<DbInterner<'db>>, interner: DbInterner<'db>) -> Self {
+        PredicateKind::Clause(ClauseKind::Trait(from)).upcast(interner)
+    }
+}
+impl<'db> UpcastFrom<DbInterner<'db>, ty::OutlivesPredicate<DbInterner<'db>, Ty<'db>>>
+    for Predicate<'db>
+{
+    fn upcast_from(
+        from: ty::OutlivesPredicate<DbInterner<'db>, Ty<'db>>,
+        interner: DbInterner<'db>,
+    ) -> Self {
+        PredicateKind::Clause(ClauseKind::TypeOutlives(from)).upcast(interner)
+    }
+}
+impl<'db> UpcastFrom<DbInterner<'db>, ty::OutlivesPredicate<DbInterner<'db>, Region<'db>>>
+    for Predicate<'db>
+{
+    fn upcast_from(
+        from: ty::OutlivesPredicate<DbInterner<'db>, Region<'db>>,
+        interner: DbInterner<'db>,
+    ) -> Self {
+        PredicateKind::Clause(ClauseKind::RegionOutlives(from)).upcast(interner)
+    }
+}
+
+impl<'db> rustc_type_ir::inherent::Predicate<DbInterner<'db>> for Predicate<'db> {
+    fn as_clause(self) -> Option<<DbInterner<'db> as rustc_type_ir::Interner>::Clause> {
+        match self.kind().skip_binder() {
+            PredicateKind::Clause(..) => Some(self.expect_clause()),
+            _ => None,
+        }
+    }
+
+    /// Whether this projection can be soundly normalized.
+    ///
+    /// Wf predicates must not be normalized, as normalization
+    /// can remove required bounds which would cause us to
+    /// unsoundly accept some programs. See #91068.
+    fn allow_normalization(self) -> bool {
+        // TODO: this should probably live in rustc_type_ir
+        match self.inner().as_ref().skip_binder() {
+            PredicateKind::Clause(ClauseKind::WellFormed(_))
+            | PredicateKind::AliasRelate(..)
+            | PredicateKind::NormalizesTo(..) => false,
+            PredicateKind::Clause(ClauseKind::Trait(_))
+            | PredicateKind::Clause(ClauseKind::RegionOutlives(_))
+            | PredicateKind::Clause(ClauseKind::TypeOutlives(_))
+            | PredicateKind::Clause(ClauseKind::Projection(_))
+            | PredicateKind::Clause(ClauseKind::ConstArgHasType(..))
+            | PredicateKind::Clause(ClauseKind::HostEffect(..))
+            | PredicateKind::Clause(ClauseKind::UnstableFeature(_))
+            | PredicateKind::DynCompatible(_)
+            | PredicateKind::Subtype(_)
+            | PredicateKind::Coerce(_)
+            | PredicateKind::Clause(ClauseKind::ConstEvaluatable(_))
+            | PredicateKind::ConstEquate(_, _)
+            | PredicateKind::Ambiguous => true,
+        }
+    }
+}
+
+impl<'db> Predicate<'db> {
+    /// Assert that the predicate is a clause.
+    pub fn expect_clause(self) -> Clause<'db> {
+        match self.kind().skip_binder() {
+            PredicateKind::Clause(..) => Clause(self),
+            _ => panic!("{self:?} is not a clause"),
+        }
+    }
+}
+
+impl<'db> TypeVisitable<DbInterner<'db>> for Clause<'db> {
+    fn visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>(
+        &self,
+        visitor: &mut V,
+    ) -> V::Result {
+        visitor.visit_predicate((*self).as_predicate())
+    }
+}
+
+impl<'db> TypeFoldable<DbInterner<'db>> for Clause<'db> {
+    fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>(
+        self,
+        folder: &mut F,
+    ) -> Result<Self, F::Error> {
+        Ok(folder.try_fold_predicate(self.as_predicate())?.expect_clause())
+    }
+    fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self {
+        folder.fold_predicate(self.as_predicate()).expect_clause()
+    }
+}
+
+impl<'db> IntoKind for Clause<'db> {
+    type Kind = Binder<'db, ClauseKind<'db>>;
+
+    fn kind(self) -> Self::Kind {
+        self.0.kind().map_bound(|pk| match pk {
+            PredicateKind::Clause(kind) => kind,
+            _ => unreachable!(),
+        })
+    }
+}
+
+impl<'db> Clause<'db> {
+    pub fn as_predicate(self) -> Predicate<'db> {
+        self.0
+    }
+}
+
+impl<'db> Elaboratable<DbInterner<'db>> for Clause<'db> {
+    fn predicate(&self) -> <DbInterner<'db> as rustc_type_ir::Interner>::Predicate {
+        self.0
+    }
+
+    fn child(&self, clause: <DbInterner<'db> as rustc_type_ir::Interner>::Clause) -> Self {
+        clause
+    }
+
+    fn child_with_derived_cause(
+        &self,
+        clause: <DbInterner<'db> as rustc_type_ir::Interner>::Clause,
+        _span: <DbInterner<'db> as rustc_type_ir::Interner>::Span,
+        _parent_trait_pred: rustc_type_ir::Binder<
+            DbInterner<'db>,
+            rustc_type_ir::TraitPredicate<DbInterner<'db>>,
+        >,
+        _index: usize,
+    ) -> Self {
+        clause
+    }
+}
+
+impl<'db> UpcastFrom<DbInterner<'db>, ty::Binder<DbInterner<'db>, ty::ClauseKind<DbInterner<'db>>>>
+    for Clause<'db>
+{
+    fn upcast_from(
+        from: ty::Binder<DbInterner<'db>, ty::ClauseKind<DbInterner<'db>>>,
+        interner: DbInterner<'db>,
+    ) -> Self {
+        Clause(from.map_bound(PredicateKind::Clause).upcast(interner))
+    }
+}
+impl<'db> UpcastFrom<DbInterner<'db>, ty::TraitRef<DbInterner<'db>>> for Clause<'db> {
+    fn upcast_from(from: ty::TraitRef<DbInterner<'db>>, interner: DbInterner<'db>) -> Self {
+        Clause(from.upcast(interner))
+    }
+}
+impl<'db> UpcastFrom<DbInterner<'db>, ty::Binder<DbInterner<'db>, ty::TraitRef<DbInterner<'db>>>>
+    for Clause<'db>
+{
+    fn upcast_from(
+        from: ty::Binder<DbInterner<'db>, ty::TraitRef<DbInterner<'db>>>,
+        interner: DbInterner<'db>,
+    ) -> Self {
+        Clause(from.upcast(interner))
+    }
+}
+impl<'db> UpcastFrom<DbInterner<'db>, ty::TraitPredicate<DbInterner<'db>>> for Clause<'db> {
+    fn upcast_from(from: ty::TraitPredicate<DbInterner<'db>>, interner: DbInterner<'db>) -> Self {
+        Clause(from.upcast(interner))
+    }
+}
+impl<'db>
+    UpcastFrom<DbInterner<'db>, ty::Binder<DbInterner<'db>, ty::TraitPredicate<DbInterner<'db>>>>
+    for Clause<'db>
+{
+    fn upcast_from(
+        from: ty::Binder<DbInterner<'db>, ty::TraitPredicate<DbInterner<'db>>>,
+        interner: DbInterner<'db>,
+    ) -> Self {
+        Clause(from.upcast(interner))
+    }
+}
+impl<'db> UpcastFrom<DbInterner<'db>, ty::ProjectionPredicate<DbInterner<'db>>> for Clause<'db> {
+    fn upcast_from(
+        from: ty::ProjectionPredicate<DbInterner<'db>>,
+        interner: DbInterner<'db>,
+    ) -> Self {
+        Clause(from.upcast(interner))
+    }
+}
+impl<'db>
+    UpcastFrom<
+        DbInterner<'db>,
+        ty::Binder<DbInterner<'db>, ty::ProjectionPredicate<DbInterner<'db>>>,
+    > for Clause<'db>
+{
+    fn upcast_from(
+        from: ty::Binder<DbInterner<'db>, ty::ProjectionPredicate<DbInterner<'db>>>,
+        interner: DbInterner<'db>,
+    ) -> Self {
+        Clause(from.upcast(interner))
+    }
+}
+
+impl<'db> rustc_type_ir::inherent::Clause<DbInterner<'db>> for Clause<'db> {
+    fn as_predicate(self) -> <DbInterner<'db> as rustc_type_ir::Interner>::Predicate {
+        self.0
+    }
+
+    fn instantiate_supertrait(
+        self,
+        cx: DbInterner<'db>,
+        trait_ref: rustc_type_ir::Binder<DbInterner<'db>, rustc_type_ir::TraitRef<DbInterner<'db>>>,
+    ) -> Self {
+        tracing::debug!(?self, ?trait_ref);
+        // See the rustc impl for a long comment
+        let bound_pred = self.kind();
+        let pred_bound_vars = bound_pred.bound_vars();
+        let trait_bound_vars = trait_ref.bound_vars();
+        // 1) Self: Bar1<'a, '^0.0> -> Self: Bar1<'a, '^0.1>
+        let shifted_pred =
+            cx.shift_bound_var_indices(trait_bound_vars.len(), bound_pred.skip_binder());
+        // 2) Self: Bar1<'a, '^0.1> -> T: Bar1<'^0.0, '^0.1>
+        let new = EarlyBinder::bind(shifted_pred).instantiate(cx, trait_ref.skip_binder().args);
+        // 3) ['x] + ['b] -> ['x, 'b]
+        let bound_vars =
+            BoundVarKinds::new_from_iter(cx, trait_bound_vars.iter().chain(pred_bound_vars.iter()));
+
+        let predicate: Predicate<'db> =
+            ty::Binder::bind_with_vars(PredicateKind::Clause(new), bound_vars).upcast(cx);
+        predicate.expect_clause()
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/project.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/project.rs
new file mode 100644
index 0000000000000..e57808728ae96
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/project.rs
@@ -0,0 +1,3 @@
+//! Projection code for next-solver.
+
+pub(crate) mod solve_normalize;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/project/solve_normalize.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/project/solve_normalize.rs
new file mode 100644
index 0000000000000..a8fb2ae14f1c3
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/project/solve_normalize.rs
@@ -0,0 +1,264 @@
+//! Normalization within a next-solver infer context.
+
+use std::fmt::Debug;
+
+use rustc_next_trait_solver::placeholder::BoundVarReplacer;
+use rustc_type_ir::{
+    AliasRelationDirection, FallibleTypeFolder, Flags, Interner, TermKind, TypeFoldable,
+    TypeFolder, TypeSuperFoldable, TypeVisitableExt, UniverseIndex,
+    inherent::{IntoKind, Span as _, Term as _},
+};
+
+use crate::next_solver::{
+    Binder, Const, ConstKind, DbInterner, Goal, ParamEnv, Predicate, PredicateKind, Span, Term, Ty,
+    TyKind,
+    fulfill::{FulfillmentCtxt, NextSolverError},
+    infer::{
+        InferCtxt,
+        at::At,
+        traits::{Obligation, ObligationCause},
+    },
+    util::PlaceholderReplacer,
+};
+
+/// Deeply normalize all aliases in `value`. This does not handle inference and expects
+/// its input to be already fully resolved.
+pub fn deeply_normalize<'db, T>(at: At<'_, 'db>, value: T) -> Result<T, Vec<NextSolverError<'db>>>
+where
+    T: TypeFoldable<DbInterner<'db>>,
+{
+    assert!(!value.has_escaping_bound_vars());
+    deeply_normalize_with_skipped_universes(at, value, vec![])
+}
+
+/// Deeply normalize all aliases in `value`. This does not handle inference and expects
+/// its input to be already fully resolved.
+///
+/// Additionally takes a list of universes which represents the binders which have been
+/// entered before passing `value` to the function. This is currently needed for
+/// `normalize_erasing_regions`, which skips binders as it walks through a type.
+pub fn deeply_normalize_with_skipped_universes<'db, T>(
+    at: At<'_, 'db>,
+    value: T,
+    universes: Vec<Option<UniverseIndex>>,
+) -> Result<T, Vec<NextSolverError<'db>>>
+where
+    T: TypeFoldable<DbInterner<'db>>,
+{
+    let (value, coroutine_goals) =
+        deeply_normalize_with_skipped_universes_and_ambiguous_coroutine_goals(
+            at, value, universes,
+        )?;
+    assert_eq!(coroutine_goals, vec![]);
+
+    Ok(value)
+}
+
+/// Deeply normalize all aliases in `value`. This does not handle inference and expects
+/// its input to be already fully resolved.
+///
+/// Additionally takes a list of universes which represents the binders which have been
+/// entered before passing `value` to the function. This is currently needed for
+/// `normalize_erasing_regions`, which skips binders as it walks through a type.
+///
+/// This returns a set of stalled obligations involving coroutines if the typing mode of
+/// the underlying infcx has any stalled coroutine def ids.
+pub fn deeply_normalize_with_skipped_universes_and_ambiguous_coroutine_goals<'db, T>(
+    at: At<'_, 'db>,
+    value: T,
+    universes: Vec<Option<UniverseIndex>>,
+) -> Result<(T, Vec<Goal<'db, Predicate<'db>>>), Vec<NextSolverError<'db>>>
+where
+    T: TypeFoldable<DbInterner<'db>>,
+{
+    let fulfill_cx = FulfillmentCtxt::new(at.infcx);
+    let mut folder = NormalizationFolder { at, fulfill_cx, depth: 0, universes };
+    let value = value.try_fold_with(&mut folder)?;
+    let errors = folder.fulfill_cx.select_all_or_error(at.infcx);
+    if errors.is_empty() { Ok((value, vec![])) } else { Err(errors) }
+}
+
+struct NormalizationFolder<'me, 'db> {
+    at: At<'me, 'db>,
+    fulfill_cx: FulfillmentCtxt<'db>,
+    depth: usize,
+    universes: Vec<Option<UniverseIndex>>,
+}
+
+impl<'db> NormalizationFolder<'_, 'db> {
+    fn normalize_alias_term(
+        &mut self,
+        alias_term: Term<'db>,
+    ) -> Result<Term<'db>, Vec<NextSolverError<'db>>> {
+        let infcx = self.at.infcx;
+        let tcx = infcx.interner;
+        let recursion_limit = tcx.recursion_limit();
+        if self.depth > recursion_limit {
+            return Err(vec![]);
+        }
+
+        self.depth += 1;
+
+        let infer_term = infcx.next_term_var_of_kind(alias_term);
+        let obligation = Obligation::new(
+            tcx,
+            self.at.cause.clone(),
+            self.at.param_env,
+            PredicateKind::AliasRelate(alias_term, infer_term, AliasRelationDirection::Equate),
+        );
+
+        self.fulfill_cx.register_predicate_obligation(infcx, obligation);
+        self.select_all_and_stall_coroutine_predicates()?;
+
+        // Alias is guaranteed to be fully structurally resolved,
+        // so we can super fold here.
+        let term = infcx.resolve_vars_if_possible(infer_term);
+        // super-folding the `term` will directly fold the `Ty` or `Const` so
+        // we have to match on the term and super-fold them manually.
+        let result = match term.kind() {
+            TermKind::Ty(ty) => ty.try_super_fold_with(self)?.into(),
+            TermKind::Const(ct) => ct.try_super_fold_with(self)?.into(),
+        };
+        self.depth -= 1;
+        Ok(result)
+    }
+
+    fn select_all_and_stall_coroutine_predicates(
+        &mut self,
+    ) -> Result<(), Vec<NextSolverError<'db>>> {
+        let errors = self.fulfill_cx.select_where_possible(self.at.infcx);
+        if !errors.is_empty() {
+            return Err(errors);
+        }
+
+        let errors = self.fulfill_cx.collect_remaining_errors(self.at.infcx);
+        if !errors.is_empty() {
+            return Err(errors);
+        }
+
+        Ok(())
+    }
+}
+
+impl<'db> FallibleTypeFolder<DbInterner<'db>> for NormalizationFolder<'_, 'db> {
+    type Error = Vec<NextSolverError<'db>>;
+
+    fn cx(&self) -> DbInterner<'db> {
+        self.at.infcx.interner
+    }
+
+    fn try_fold_binder<T: TypeFoldable<DbInterner<'db>>>(
+        &mut self,
+        t: Binder<'db, T>,
+    ) -> Result<Binder<'db, T>, Self::Error> {
+        self.universes.push(None);
+        let t = t.try_super_fold_with(self)?;
+        self.universes.pop();
+        Ok(t)
+    }
+
+    #[tracing::instrument(level = "trace", skip(self), ret)]
+    fn try_fold_ty(&mut self, ty: Ty<'db>) -> Result<Ty<'db>, Self::Error> {
+        let infcx = self.at.infcx;
+        debug_assert_eq!(ty, infcx.shallow_resolve(ty));
+        if !ty.has_aliases() {
+            return Ok(ty);
+        }
+
+        let TyKind::Alias(..) = ty.kind() else { return ty.try_super_fold_with(self) };
+
+        if ty.has_escaping_bound_vars() {
+            let (ty, mapped_regions, mapped_types, mapped_consts) =
+                BoundVarReplacer::replace_bound_vars(infcx, &mut self.universes, ty);
+            let result = self.normalize_alias_term(ty.into())?.expect_type();
+            Ok(PlaceholderReplacer::replace_placeholders(
+                infcx,
+                mapped_regions,
+                mapped_types,
+                mapped_consts,
+                &self.universes,
+                result,
+            ))
+        } else {
+            Ok(self.normalize_alias_term(ty.into())?.expect_type())
+        }
+    }
+
+    #[tracing::instrument(level = "trace", skip(self), ret)]
+    fn try_fold_const(&mut self, ct: Const<'db>) -> Result<Const<'db>, Self::Error> {
+        let infcx = self.at.infcx;
+        debug_assert_eq!(ct, infcx.shallow_resolve_const(ct));
+        if !ct.has_aliases() {
+            return Ok(ct);
+        }
+
+        let ConstKind::Unevaluated(..) = ct.kind() else { return ct.try_super_fold_with(self) };
+
+        if ct.has_escaping_bound_vars() {
+            let (ct, mapped_regions, mapped_types, mapped_consts) =
+                BoundVarReplacer::replace_bound_vars(infcx, &mut self.universes, ct);
+            let result = self.normalize_alias_term(ct.into())?.expect_const();
+            Ok(PlaceholderReplacer::replace_placeholders(
+                infcx,
+                mapped_regions,
+                mapped_types,
+                mapped_consts,
+                &self.universes,
+                result,
+            ))
+        } else {
+            Ok(self.normalize_alias_term(ct.into())?.expect_const())
+        }
+    }
+}
+
+// Deeply normalize a value and return it
+pub(crate) fn deeply_normalize_for_diagnostics<'db, T: TypeFoldable<DbInterner<'db>>>(
+    infcx: &InferCtxt<'db>,
+    param_env: ParamEnv<'db>,
+    t: T,
+) -> T {
+    t.fold_with(&mut DeeplyNormalizeForDiagnosticsFolder {
+        at: infcx.at(&ObligationCause::dummy(), param_env),
+    })
+}
+
+struct DeeplyNormalizeForDiagnosticsFolder<'a, 'db> {
+    at: At<'a, 'db>,
+}
+
+impl<'db> TypeFolder<DbInterner<'db>> for DeeplyNormalizeForDiagnosticsFolder<'_, 'db> {
+    fn cx(&self) -> DbInterner<'db> {
+        self.at.infcx.interner
+    }
+
+    fn fold_ty(&mut self, ty: Ty<'db>) -> Ty<'db> {
+        let infcx = self.at.infcx;
+        let result: Result<_, Vec<NextSolverError<'db>>> = infcx.commit_if_ok(|_| {
+            deeply_normalize_with_skipped_universes_and_ambiguous_coroutine_goals(
+                self.at,
+                ty,
+                vec![None; ty.outer_exclusive_binder().as_usize()],
+            )
+        });
+        match result {
+            Ok((ty, _)) => ty,
+            Err(_) => ty.super_fold_with(self),
+        }
+    }
+
+    fn fold_const(&mut self, ct: Const<'db>) -> Const<'db> {
+        let infcx = self.at.infcx;
+        let result: Result<_, Vec<NextSolverError<'db>>> = infcx.commit_if_ok(|_| {
+            deeply_normalize_with_skipped_universes_and_ambiguous_coroutine_goals(
+                self.at,
+                ct,
+                vec![None; ct.outer_exclusive_binder().as_usize()],
+            )
+        });
+        match result {
+            Ok((ct, _)) => ct,
+            Err(_) => ct.super_fold_with(self),
+        }
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/region.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/region.rs
new file mode 100644
index 0000000000000..c59cdac5f99f6
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/region.rs
@@ -0,0 +1,332 @@
+//! Things related to regions.
+
+use intern::{Interned, Symbol};
+use rustc_type_ir::{
+    BoundVar, Flags, INNERMOST, RegionVid, TypeFlags, TypeFoldable, TypeVisitable, VisitorResult,
+    inherent::{IntoKind, PlaceholderLike, SliceLike},
+    relate::Relate,
+};
+
+use crate::next_solver::{GenericArg, OutlivesPredicate};
+
+use super::{
+    ErrorGuaranteed, SolverDefId, interned_vec_db,
+    interner::{BoundVarKind, DbInterner, Placeholder},
+};
+
+type RegionKind<'db> = rustc_type_ir::RegionKind<DbInterner<'db>>;
+
+#[salsa::interned(constructor = new_, debug)]
+pub struct Region<'db> {
+    #[returns(ref)]
+    kind_: RegionKind<'db>,
+}
+
+impl<'db> Region<'db> {
+    pub fn new(interner: DbInterner<'db>, kind: RegionKind<'db>) -> Self {
+        Region::new_(interner.db(), kind)
+    }
+
+    pub fn inner(&self) -> &RegionKind<'db> {
+        salsa::with_attached_database(|db| {
+            let inner = self.kind_(db);
+            // SAFETY: The caller already has access to a `Region<'db>`, so borrowchecking will
+            // make sure that our returned value is valid for the lifetime `'db`.
+            unsafe { std::mem::transmute::<&RegionKind<'_>, &RegionKind<'db>>(inner) }
+        })
+        .unwrap()
+    }
+
+    pub fn new_early_param(
+        interner: DbInterner<'db>,
+        early_bound_region: EarlyParamRegion,
+    ) -> Self {
+        Region::new(interner, RegionKind::ReEarlyParam(early_bound_region))
+    }
+
+    pub fn new_placeholder(interner: DbInterner<'db>, placeholder: PlaceholderRegion) -> Self {
+        Region::new(interner, RegionKind::RePlaceholder(placeholder))
+    }
+
+    pub fn new_var(interner: DbInterner<'db>, v: RegionVid) -> Region<'db> {
+        Region::new(interner, RegionKind::ReVar(v))
+    }
+
+    pub fn is_placeholder(&self) -> bool {
+        matches!(self.inner(), RegionKind::RePlaceholder(..))
+    }
+
+    pub fn is_static(&self) -> bool {
+        matches!(self.inner(), RegionKind::ReStatic)
+    }
+
+    pub fn error(interner: DbInterner<'db>) -> Self {
+        Region::new(interner, RegionKind::ReError(ErrorGuaranteed))
+    }
+
+    pub fn type_flags(&self) -> TypeFlags {
+        let mut flags = TypeFlags::empty();
+
+        match &self.inner() {
+            RegionKind::ReVar(..) => {
+                flags |= TypeFlags::HAS_FREE_REGIONS;
+                flags |= TypeFlags::HAS_FREE_LOCAL_REGIONS;
+                flags |= TypeFlags::HAS_RE_INFER;
+            }
+            RegionKind::RePlaceholder(..) => {
+                flags |= TypeFlags::HAS_FREE_REGIONS;
+                flags |= TypeFlags::HAS_FREE_LOCAL_REGIONS;
+                flags |= TypeFlags::HAS_RE_PLACEHOLDER;
+            }
+            RegionKind::ReEarlyParam(..) => {
+                flags |= TypeFlags::HAS_FREE_REGIONS;
+                flags |= TypeFlags::HAS_FREE_LOCAL_REGIONS;
+                flags |= TypeFlags::HAS_RE_PARAM;
+            }
+            RegionKind::ReLateParam(..) => {
+                flags |= TypeFlags::HAS_FREE_REGIONS;
+                flags |= TypeFlags::HAS_FREE_LOCAL_REGIONS;
+            }
+            RegionKind::ReStatic => {
+                flags |= TypeFlags::HAS_FREE_REGIONS;
+            }
+            RegionKind::ReBound(..) => {
+                flags |= TypeFlags::HAS_RE_BOUND;
+            }
+            RegionKind::ReErased => {
+                flags |= TypeFlags::HAS_RE_ERASED;
+            }
+            RegionKind::ReError(..) => {
+                flags |= TypeFlags::HAS_FREE_REGIONS;
+                flags |= TypeFlags::HAS_ERROR;
+            }
+        }
+
+        flags
+    }
+}
+
+pub type PlaceholderRegion = Placeholder<BoundRegion>;
+
+#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+pub struct EarlyParamRegion {
+    pub index: u32,
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+/// The parameter representation of late-bound function parameters, "some region
+/// at least as big as the scope `fr.scope`".
+///
+/// Similar to a placeholder region as we create `LateParam` regions when entering a binder
+/// except they are always in the root universe and instead of using a boundvar to distinguish
+/// between others we use the `DefId` of the parameter. For this reason the `bound_region` field
+/// should basically always be `BoundRegionKind::Named` as otherwise there is no way of telling
+/// different parameters apart.
+pub struct LateParamRegion {
+    pub scope: SolverDefId,
+    pub bound_region: BoundRegionKind,
+}
+
+impl std::fmt::Debug for LateParamRegion {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "ReLateParam({:?}, {:?})", self.scope, self.bound_region)
+    }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+pub enum BoundRegionKind {
+    /// An anonymous region parameter for a given fn (&T)
+    Anon,
+
+    /// Named region parameters for functions (a in &'a T)
+    ///
+    /// The `DefId` is needed to distinguish free regions in
+    /// the event of shadowing.
+    Named(SolverDefId),
+
+    /// Anonymous region for the implicit env pointer parameter
+    /// to a closure
+    ClosureEnv,
+}
+
+impl std::fmt::Debug for BoundRegionKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match *self {
+            BoundRegionKind::Anon => write!(f, "BrAnon"),
+            BoundRegionKind::Named(did) => {
+                write!(f, "BrNamed({did:?})")
+            }
+            BoundRegionKind::ClosureEnv => write!(f, "BrEnv"),
+        }
+    }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+pub struct BoundRegion {
+    pub var: BoundVar,
+    pub kind: BoundRegionKind,
+}
+
+impl rustc_type_ir::inherent::ParamLike for EarlyParamRegion {
+    fn index(self) -> u32 {
+        self.index
+    }
+}
+
+impl std::fmt::Debug for EarlyParamRegion {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "#{}", self.index)
+        // write!(f, "{}/#{}", self.name, self.index)
+    }
+}
+
+impl<'db> rustc_type_ir::inherent::BoundVarLike<DbInterner<'db>> for BoundRegion {
+    fn var(self) -> BoundVar {
+        self.var
+    }
+
+    fn assert_eq(self, var: BoundVarKind) {
+        assert_eq!(self.kind, var.expect_region())
+    }
+}
+
+impl core::fmt::Debug for BoundRegion {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match &self.kind {
+            BoundRegionKind::Anon => write!(f, "{:?}", self.var),
+            BoundRegionKind::ClosureEnv => write!(f, "{:?}.Env", self.var),
+            BoundRegionKind::Named(def) => {
+                write!(f, "{:?}.Named({:?})", self.var, def)
+            }
+        }
+    }
+}
+
+impl BoundRegionKind {
+    pub fn is_named(&self) -> bool {
+        matches!(self, BoundRegionKind::Named(_))
+    }
+
+    pub fn get_name(&self) -> Option<Symbol> {
+        None
+    }
+
+    pub fn get_id(&self) -> Option<SolverDefId> {
+        match self {
+            BoundRegionKind::Named(id) => Some(*id),
+            _ => None,
+        }
+    }
+}
+
+impl<'db> IntoKind for Region<'db> {
+    type Kind = RegionKind<'db>;
+
+    fn kind(self) -> Self::Kind {
+        *self.inner()
+    }
+}
+
+impl<'db> TypeVisitable<DbInterner<'db>> for Region<'db> {
+    fn visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>(
+        &self,
+        visitor: &mut V,
+    ) -> V::Result {
+        visitor.visit_region(*self)
+    }
+}
+
+impl<'db> TypeFoldable<DbInterner<'db>> for Region<'db> {
+    fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>(
+        self,
+        folder: &mut F,
+    ) -> Result<Self, F::Error> {
+        folder.try_fold_region(self)
+    }
+    fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self {
+        folder.fold_region(self)
+    }
+}
+
+impl<'db> Relate<DbInterner<'db>> for Region<'db> {
+    fn relate<R: rustc_type_ir::relate::TypeRelation<DbInterner<'db>>>(
+        relation: &mut R,
+        a: Self,
+        b: Self,
+    ) -> rustc_type_ir::relate::RelateResult<DbInterner<'db>, Self> {
+        relation.regions(a, b)
+    }
+}
+
+impl<'db> Flags for Region<'db> {
+    fn flags(&self) -> rustc_type_ir::TypeFlags {
+        self.type_flags()
+    }
+
+    fn outer_exclusive_binder(&self) -> rustc_type_ir::DebruijnIndex {
+        match &self.inner() {
+            RegionKind::ReBound(debruijn, _) => debruijn.shifted_in(1),
+            _ => INNERMOST,
+        }
+    }
+}
+
+impl<'db> rustc_type_ir::inherent::Region<DbInterner<'db>> for Region<'db> {
+    fn new_bound(
+        interner: DbInterner<'db>,
+        debruijn: rustc_type_ir::DebruijnIndex,
+        var: BoundRegion,
+    ) -> Self {
+        Region::new(interner, RegionKind::ReBound(debruijn, var))
+    }
+
+    fn new_anon_bound(
+        interner: DbInterner<'db>,
+        debruijn: rustc_type_ir::DebruijnIndex,
+        var: rustc_type_ir::BoundVar,
+    ) -> Self {
+        Region::new(
+            interner,
+            RegionKind::ReBound(debruijn, BoundRegion { var, kind: BoundRegionKind::Anon }),
+        )
+    }
+
+    fn new_static(interner: DbInterner<'db>) -> Self {
+        Region::new(interner, RegionKind::ReStatic)
+    }
+
+    fn new_placeholder(
+        interner: DbInterner<'db>,
+        var: <DbInterner<'db> as rustc_type_ir::Interner>::PlaceholderRegion,
+    ) -> Self {
+        Region::new(interner, RegionKind::RePlaceholder(var))
+    }
+}
+
+impl<'db> PlaceholderLike<DbInterner<'db>> for PlaceholderRegion {
+    type Bound = BoundRegion;
+
+    fn universe(self) -> rustc_type_ir::UniverseIndex {
+        self.universe
+    }
+
+    fn var(self) -> rustc_type_ir::BoundVar {
+        self.bound.var
+    }
+
+    fn with_updated_universe(self, ui: rustc_type_ir::UniverseIndex) -> Self {
+        Placeholder { universe: ui, bound: self.bound }
+    }
+
+    fn new(ui: rustc_type_ir::UniverseIndex, bound: Self::Bound) -> Self {
+        Placeholder { universe: ui, bound }
+    }
+
+    fn new_anon(ui: rustc_type_ir::UniverseIndex, var: rustc_type_ir::BoundVar) -> Self {
+        Placeholder { universe: ui, bound: BoundRegion { var, kind: BoundRegionKind::Anon } }
+    }
+}
+
+type GenericArgOutlivesPredicate<'db> = OutlivesPredicate<'db, GenericArg<'db>>;
+
+interned_vec_db!(RegionAssumptions, GenericArgOutlivesPredicate);
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
new file mode 100644
index 0000000000000..45888ac4d2352
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
@@ -0,0 +1,289 @@
+//! Defining `SolverContext` for next-trait-solver.
+
+use hir_def::{AssocItemId, GeneralConstId, TypeAliasId};
+use rustc_next_trait_solver::delegate::SolverDelegate;
+use rustc_type_ir::{
+    InferCtxtLike, Interner, PredicatePolarity, TypeFlags, TypeVisitableExt, UniverseIndex,
+    inherent::{IntoKind, SliceLike, Span as _, Term as _, Ty as _},
+    lang_items::TraitSolverLangItem,
+    solve::{Certainty, NoSolution},
+};
+
+use crate::{
+    TraitRefExt,
+    db::HirDatabase,
+    next_solver::{
+        ClauseKind, CoercePredicate, PredicateKind, SubtypePredicate,
+        mapping::{ChalkToNextSolver, convert_args_for_result},
+        util::sizedness_fast_path,
+    },
+};
+
+use super::{
+    Canonical, CanonicalVarValues, Const, DbInterner, ErrorGuaranteed, GenericArg, GenericArgs,
+    ParamEnv, Predicate, SolverDefId, Span, Ty, UnevaluatedConst,
+    infer::{DbInternerInferExt, InferCtxt, canonical::instantiate::CanonicalExt},
+};
+
+pub type Goal<'db, P> = rustc_type_ir::solve::Goal<DbInterner<'db>, P>;
+
+#[repr(transparent)]
+pub(crate) struct SolverContext<'db>(pub(crate) InferCtxt<'db>);
+
+impl<'a, 'db> From<&'a InferCtxt<'db>> for &'a SolverContext<'db> {
+    fn from(infcx: &'a InferCtxt<'db>) -> Self {
+        // SAFETY: `repr(transparent)`
+        unsafe { std::mem::transmute(infcx) }
+    }
+}
+
+impl<'db> std::ops::Deref for SolverContext<'db> {
+    type Target = InferCtxt<'db>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<'db> SolverDelegate for SolverContext<'db> {
+    type Interner = DbInterner<'db>;
+    type Infcx = InferCtxt<'db>;
+
+    fn cx(&self) -> Self::Interner {
+        self.0.interner
+    }
+
+    fn build_with_canonical<V>(
+        cx: Self::Interner,
+        canonical: &rustc_type_ir::CanonicalQueryInput<Self::Interner, V>,
+    ) -> (Self, V, rustc_type_ir::CanonicalVarValues<Self::Interner>)
+    where
+        V: rustc_type_ir::TypeFoldable<Self::Interner>,
+    {
+        let (infcx, value, vars) = cx.infer_ctxt().build_with_canonical(canonical);
+        (SolverContext(infcx), value, vars)
+    }
+
+    fn fresh_var_for_kind_with_span(
+        &self,
+        arg: <Self::Interner as rustc_type_ir::Interner>::GenericArg,
+        span: <Self::Interner as rustc_type_ir::Interner>::Span,
+    ) -> <Self::Interner as rustc_type_ir::Interner>::GenericArg {
+        unimplemented!()
+    }
+
+    fn leak_check(
+        &self,
+        max_input_universe: rustc_type_ir::UniverseIndex,
+    ) -> Result<(), NoSolution> {
+        Ok(())
+    }
+
+    fn well_formed_goals(
+        &self,
+        param_env: <Self::Interner as rustc_type_ir::Interner>::ParamEnv,
+        arg: <Self::Interner as rustc_type_ir::Interner>::Term,
+    ) -> Option<
+        Vec<
+            rustc_type_ir::solve::Goal<
+                Self::Interner,
+                <Self::Interner as rustc_type_ir::Interner>::Predicate,
+            >,
+        >,
+    > {
+        unimplemented!()
+    }
+
+    fn make_deduplicated_outlives_constraints(
+        &self,
+    ) -> Vec<
+        rustc_type_ir::OutlivesPredicate<
+            Self::Interner,
+            <Self::Interner as rustc_type_ir::Interner>::GenericArg,
+        >,
+    > {
+        // FIXME: add if we care about regions
+        vec![]
+    }
+
+    fn instantiate_canonical<V>(
+        &self,
+        canonical: rustc_type_ir::Canonical<Self::Interner, V>,
+        values: rustc_type_ir::CanonicalVarValues<Self::Interner>,
+    ) -> V
+    where
+        V: rustc_type_ir::TypeFoldable<Self::Interner>,
+    {
+        canonical.instantiate(self.cx(), &values)
+    }
+
+    fn instantiate_canonical_var_with_infer(
+        &self,
+        cv_info: rustc_type_ir::CanonicalVarKind<Self::Interner>,
+        _span: <Self::Interner as rustc_type_ir::Interner>::Span,
+        universe_map: impl Fn(rustc_type_ir::UniverseIndex) -> rustc_type_ir::UniverseIndex,
+    ) -> <Self::Interner as rustc_type_ir::Interner>::GenericArg {
+        self.0.instantiate_canonical_var(cv_info, universe_map)
+    }
+
+    fn add_item_bounds_for_hidden_type(
+        &self,
+        def_id: <Self::Interner as rustc_type_ir::Interner>::DefId,
+        args: <Self::Interner as rustc_type_ir::Interner>::GenericArgs,
+        param_env: <Self::Interner as rustc_type_ir::Interner>::ParamEnv,
+        hidden_ty: <Self::Interner as rustc_type_ir::Interner>::Ty,
+        goals: &mut Vec<
+            rustc_type_ir::solve::Goal<
+                Self::Interner,
+                <Self::Interner as rustc_type_ir::Interner>::Predicate,
+            >,
+        >,
+    ) {
+        unimplemented!()
+    }
+
+    fn fetch_eligible_assoc_item(
+        &self,
+        goal_trait_ref: rustc_type_ir::TraitRef<Self::Interner>,
+        trait_assoc_def_id: <Self::Interner as rustc_type_ir::Interner>::DefId,
+        impl_def_id: <Self::Interner as rustc_type_ir::Interner>::DefId,
+    ) -> Result<Option<<Self::Interner as rustc_type_ir::Interner>::DefId>, ErrorGuaranteed> {
+        let impl_id = match impl_def_id {
+            SolverDefId::ImplId(id) => id,
+            _ => panic!("Unexpected SolverDefId"),
+        };
+        let trait_assoc_id = match trait_assoc_def_id {
+            SolverDefId::TypeAliasId(id) => id,
+            _ => panic!("Unexpected SolverDefId"),
+        };
+        let trait_ref = self
+            .0
+            .interner
+            .db()
+            .impl_trait(impl_id)
+            // ImplIds for impls where the trait ref can't be resolved should never reach solver
+            .expect("invalid impl passed to next-solver")
+            .into_value_and_skipped_binders()
+            .0;
+        let trait_ = trait_ref.hir_trait_id();
+        let trait_data = trait_.trait_items(self.0.interner.db());
+        let id =
+            impl_id.impl_items(self.0.interner.db()).items.iter().find_map(|item| -> Option<_> {
+                match item {
+                    (_, AssocItemId::TypeAliasId(type_alias)) => {
+                        let name = &self.0.interner.db().type_alias_signature(*type_alias).name;
+                        let found_trait_assoc_id = trait_data.associated_type_by_name(name)?;
+                        (found_trait_assoc_id == trait_assoc_id).then_some(*type_alias)
+                    }
+                    _ => None,
+                }
+            });
+        Ok(id.map(SolverDefId::TypeAliasId))
+    }
+
+    fn is_transmutable(
+        &self,
+        dst: <Self::Interner as rustc_type_ir::Interner>::Ty,
+        src: <Self::Interner as rustc_type_ir::Interner>::Ty,
+        assume: <Self::Interner as rustc_type_ir::Interner>::Const,
+    ) -> Result<Certainty, NoSolution> {
+        unimplemented!()
+    }
+
+    fn evaluate_const(
+        &self,
+        param_env: <Self::Interner as rustc_type_ir::Interner>::ParamEnv,
+        uv: rustc_type_ir::UnevaluatedConst<Self::Interner>,
+    ) -> Option<<Self::Interner as rustc_type_ir::Interner>::Const> {
+        let c = match uv.def {
+            SolverDefId::ConstId(c) => GeneralConstId::ConstId(c),
+            SolverDefId::StaticId(c) => GeneralConstId::StaticId(c),
+            _ => unreachable!(),
+        };
+        let subst = convert_args_for_result(self.interner, uv.args.as_slice());
+        let ec = self.cx().db.const_eval(c, subst, None).ok()?;
+        Some(ec.to_nextsolver(self.interner))
+    }
+
+    fn compute_goal_fast_path(
+        &self,
+        goal: rustc_type_ir::solve::Goal<
+            Self::Interner,
+            <Self::Interner as rustc_type_ir::Interner>::Predicate,
+        >,
+        span: <Self::Interner as rustc_type_ir::Interner>::Span,
+    ) -> Option<Certainty> {
+        if let Some(trait_pred) = goal.predicate.as_trait_clause() {
+            if self.shallow_resolve(trait_pred.self_ty().skip_binder()).is_ty_var()
+                // We don't do this fast path when opaques are defined since we may
+                // eventually use opaques to incompletely guide inference via ty var
+                // self types.
+                // FIXME: Properly consider opaques here.
+                && self.inner.borrow_mut().opaque_types().is_empty()
+            {
+                return Some(Certainty::AMBIGUOUS);
+            }
+
+            if trait_pred.polarity() == PredicatePolarity::Positive {
+                match self.0.cx().as_lang_item(trait_pred.def_id()) {
+                    Some(TraitSolverLangItem::Sized) | Some(TraitSolverLangItem::MetaSized) => {
+                        let predicate = self.resolve_vars_if_possible(goal.predicate);
+                        if sizedness_fast_path(self.cx(), predicate, goal.param_env) {
+                            return Some(Certainty::Yes);
+                        }
+                    }
+                    Some(TraitSolverLangItem::Copy | TraitSolverLangItem::Clone) => {
+                        let self_ty =
+                            self.resolve_vars_if_possible(trait_pred.self_ty().skip_binder());
+                        // Unlike `Sized` traits, which always prefer the built-in impl,
+                        // `Copy`/`Clone` may be shadowed by a param-env candidate which
+                        // could force a lifetime error or guide inference. While that's
+                        // not generally desirable, it is observable, so for now let's
+                        // ignore this fast path for types that have regions or infer.
+                        if !self_ty
+                            .has_type_flags(TypeFlags::HAS_FREE_REGIONS | TypeFlags::HAS_INFER)
+                            && self_ty.is_trivially_pure_clone_copy()
+                        {
+                            return Some(Certainty::Yes);
+                        }
+                    }
+                    _ => {}
+                }
+            }
+        }
+
+        let pred = goal.predicate.kind();
+        match pred.no_bound_vars()? {
+            PredicateKind::Clause(ClauseKind::RegionOutlives(outlives)) => Some(Certainty::Yes),
+            PredicateKind::Clause(ClauseKind::TypeOutlives(outlives)) => Some(Certainty::Yes),
+            PredicateKind::Subtype(SubtypePredicate { a, b, .. })
+            | PredicateKind::Coerce(CoercePredicate { a, b }) => {
+                if self.shallow_resolve(a).is_ty_var() && self.shallow_resolve(b).is_ty_var() {
+                    // FIXME: We also need to register a subtype relation between these vars
+                    // when those are added, and if they aren't in the same sub root then
+                    // we should mark this goal as `has_changed`.
+                    Some(Certainty::AMBIGUOUS)
+                } else {
+                    None
+                }
+            }
+            PredicateKind::Clause(ClauseKind::ConstArgHasType(ct, _)) => {
+                if self.shallow_resolve_const(ct).is_ct_infer() {
+                    Some(Certainty::AMBIGUOUS)
+                } else {
+                    None
+                }
+            }
+            PredicateKind::Clause(ClauseKind::WellFormed(arg)) => {
+                if arg.is_trivially_wf(self.interner) {
+                    Some(Certainty::Yes)
+                } else if arg.is_infer() {
+                    Some(Certainty::AMBIGUOUS)
+                } else {
+                    None
+                }
+            }
+            _ => None,
+        }
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
new file mode 100644
index 0000000000000..0c0fe686b77d1
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
@@ -0,0 +1,943 @@
+//! Things related to tys in the next-trait-solver.
+
+use intern::{Interned, Symbol, sym};
+use rustc_abi::{Float, Integer, Size};
+use rustc_ast_ir::{Mutability, try_visit, visit::VisitorResult};
+use rustc_type_ir::{
+    BoundVar, ClosureKind, FlagComputation, Flags, FloatTy, FloatVid, InferTy, IntTy, IntVid,
+    TypeFoldable, TypeSuperFoldable, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, UintTy,
+    WithCachedTypeInfo,
+    inherent::{
+        AdtDef, BoundVarLike, GenericArgs as _, IntoKind, ParamLike, PlaceholderLike, SliceLike,
+    },
+    relate::Relate,
+    solve::SizedTraitKind,
+    walk::TypeWalker,
+};
+use salsa::plumbing::{AsId, FromId};
+use smallvec::SmallVec;
+
+use crate::{
+    db::HirDatabase,
+    interner::InternedWrapperNoDebug,
+    next_solver::util::{CoroutineArgsExt, IntegerTypeExt},
+};
+
+use super::{
+    BoundVarKind, DbInterner, GenericArgs, Placeholder, SolverDefId, interned_vec_db,
+    util::{FloatExt, IntegerExt},
+};
+
+pub type TyKind<'db> = rustc_type_ir::TyKind<DbInterner<'db>>;
+pub type FnHeader<'db> = rustc_type_ir::FnHeader<DbInterner<'db>>;
+
+#[salsa::interned(constructor = new_)]
+pub struct Ty<'db> {
+    #[returns(ref)]
+    kind_: InternedWrapperNoDebug<WithCachedTypeInfo<TyKind<'db>>>,
+}
+
+const _: () = {
+    const fn is_copy<T: Copy>() {}
+    is_copy::<Ty<'static>>();
+};
+
+impl<'db> Ty<'db> {
+    pub fn new(interner: DbInterner<'db>, kind: TyKind<'db>) -> Self {
+        let flags = FlagComputation::for_kind(&kind);
+        let cached = WithCachedTypeInfo {
+            internee: kind,
+            flags: flags.flags,
+            outer_exclusive_binder: flags.outer_exclusive_binder,
+        };
+        Ty::new_(interner.db(), InternedWrapperNoDebug(cached))
+    }
+
+    pub fn inner(&self) -> &WithCachedTypeInfo<TyKind<'db>> {
+        salsa::with_attached_database(|db| {
+            let inner = &self.kind_(db).0;
+            // SAFETY: The caller already has access to a `Ty<'db>`, so borrowchecking will
+            // make sure that our returned value is valid for the lifetime `'db`.
+            unsafe { std::mem::transmute(inner) }
+        })
+        .unwrap()
+    }
+
+    pub fn new_param(interner: DbInterner<'db>, index: u32, name: Symbol) -> Self {
+        Ty::new(interner, TyKind::Param(ParamTy { index }))
+    }
+
+    pub fn new_placeholder(interner: DbInterner<'db>, placeholder: PlaceholderTy) -> Self {
+        Ty::new(interner, TyKind::Placeholder(placeholder))
+    }
+
+    pub fn new_infer(interner: DbInterner<'db>, infer: InferTy) -> Self {
+        Ty::new(interner, TyKind::Infer(infer))
+    }
+
+    pub fn new_int_var(interner: DbInterner<'db>, v: IntVid) -> Self {
+        Ty::new_infer(interner, InferTy::IntVar(v))
+    }
+
+    pub fn new_float_var(interner: DbInterner<'db>, v: FloatVid) -> Self {
+        Ty::new_infer(interner, InferTy::FloatVar(v))
+    }
+
+    pub fn new_int(interner: DbInterner<'db>, i: IntTy) -> Self {
+        Ty::new(interner, TyKind::Int(i))
+    }
+
+    pub fn new_uint(interner: DbInterner<'db>, ui: UintTy) -> Self {
+        Ty::new(interner, TyKind::Uint(ui))
+    }
+
+    pub fn new_float(interner: DbInterner<'db>, f: FloatTy) -> Self {
+        Ty::new(interner, TyKind::Float(f))
+    }
+
+    pub fn new_fresh(interner: DbInterner<'db>, n: u32) -> Self {
+        Ty::new_infer(interner, InferTy::FreshTy(n))
+    }
+
+    pub fn new_fresh_int(interner: DbInterner<'db>, n: u32) -> Self {
+        Ty::new_infer(interner, InferTy::FreshIntTy(n))
+    }
+
+    pub fn new_fresh_float(interner: DbInterner<'db>, n: u32) -> Self {
+        Ty::new_infer(interner, InferTy::FreshFloatTy(n))
+    }
+
+    /// Returns the `Size` for primitive types (bool, uint, int, char, float).
+    pub fn primitive_size(self, interner: DbInterner<'db>) -> Size {
+        match self.kind() {
+            TyKind::Bool => Size::from_bytes(1),
+            TyKind::Char => Size::from_bytes(4),
+            TyKind::Int(ity) => Integer::from_int_ty(&interner, ity).size(),
+            TyKind::Uint(uty) => Integer::from_uint_ty(&interner, uty).size(),
+            TyKind::Float(fty) => Float::from_float_ty(fty).size(),
+            _ => panic!("non primitive type"),
+        }
+    }
+
+    pub fn int_size_and_signed(self, interner: DbInterner<'db>) -> (Size, bool) {
+        match self.kind() {
+            TyKind::Int(ity) => (Integer::from_int_ty(&interner, ity).size(), true),
+            TyKind::Uint(uty) => (Integer::from_uint_ty(&interner, uty).size(), false),
+            _ => panic!("non integer discriminant"),
+        }
+    }
+
+    pub fn walk(self) -> TypeWalker<DbInterner<'db>> {
+        TypeWalker::new(self.into())
+    }
+
+    /// Fast path helper for testing if a type is `Sized` or `MetaSized`.
+    ///
+    /// Returning true means the type is known to implement the sizedness trait. Returning `false`
+    /// means nothing -- could be sized, might not be.
+    ///
+    /// Note that we could never rely on the fact that a type such as `[_]` is trivially `!Sized`
+    /// because we could be in a type environment with a bound such as `[_]: Copy`. A function with
+    /// such a bound obviously never can be called, but that doesn't mean it shouldn't typecheck.
+    /// This is why this method doesn't return `Option<bool>`.
+    #[tracing::instrument(skip(tcx), level = "debug")]
+    pub fn has_trivial_sizedness(self, tcx: DbInterner<'db>, sizedness: SizedTraitKind) -> bool {
+        match self.kind() {
+            TyKind::Infer(InferTy::IntVar(_) | InferTy::FloatVar(_))
+            | TyKind::Uint(_)
+            | TyKind::Int(_)
+            | TyKind::Bool
+            | TyKind::Float(_)
+            | TyKind::FnDef(..)
+            | TyKind::FnPtr(..)
+            | TyKind::UnsafeBinder(_)
+            | TyKind::RawPtr(..)
+            | TyKind::Char
+            | TyKind::Ref(..)
+            | TyKind::Coroutine(..)
+            | TyKind::CoroutineWitness(..)
+            | TyKind::Array(..)
+            | TyKind::Pat(..)
+            | TyKind::Closure(..)
+            | TyKind::CoroutineClosure(..)
+            | TyKind::Never
+            | TyKind::Error(_) => true,
+
+            TyKind::Str | TyKind::Slice(_) | TyKind::Dynamic(_, _, _) => match sizedness {
+                SizedTraitKind::Sized => false,
+                SizedTraitKind::MetaSized => true,
+            },
+
+            TyKind::Foreign(..) => match sizedness {
+                SizedTraitKind::Sized | SizedTraitKind::MetaSized => false,
+            },
+
+            TyKind::Tuple(tys) => {
+                tys.last().is_none_or(|ty| ty.has_trivial_sizedness(tcx, sizedness))
+            }
+
+            TyKind::Adt(def, args) => def
+                .sizedness_constraint(tcx, sizedness)
+                .is_none_or(|ty| ty.instantiate(tcx, args).has_trivial_sizedness(tcx, sizedness)),
+
+            TyKind::Alias(..) | TyKind::Param(_) | TyKind::Placeholder(..) | TyKind::Bound(..) => {
+                false
+            }
+
+            TyKind::Infer(InferTy::TyVar(_)) => false,
+
+            TyKind::Infer(
+                InferTy::FreshTy(_) | InferTy::FreshIntTy(_) | InferTy::FreshFloatTy(_),
+            ) => {
+                panic!("`has_trivial_sizedness` applied to unexpected type: {self:?}")
+            }
+        }
+    }
+
+    /// Fast path helper for primitives which are always `Copy` and which
+    /// have a side-effect-free `Clone` impl.
+    ///
+    /// Returning true means the type is known to be pure and `Copy+Clone`.
+    /// Returning `false` means nothing -- could be `Copy`, might not be.
+    ///
+    /// This is mostly useful for optimizations, as these are the types
+    /// on which we can replace cloning with dereferencing.
+    pub fn is_trivially_pure_clone_copy(self) -> bool {
+        match self.kind() {
+            TyKind::Bool | TyKind::Char | TyKind::Never => true,
+
+            // These aren't even `Clone`
+            TyKind::Str | TyKind::Slice(..) | TyKind::Foreign(..) | TyKind::Dynamic(..) => false,
+
+            TyKind::Infer(InferTy::FloatVar(_) | InferTy::IntVar(_))
+            | TyKind::Int(..)
+            | TyKind::Uint(..)
+            | TyKind::Float(..) => true,
+
+            // ZST which can't be named are fine.
+            TyKind::FnDef(..) => true,
+
+            TyKind::Array(element_ty, _len) => element_ty.is_trivially_pure_clone_copy(),
+
+            // A 100-tuple isn't "trivial", so doing this only for reasonable sizes.
+            TyKind::Tuple(field_tys) => {
+                field_tys.len() <= 3 && field_tys.iter().all(Self::is_trivially_pure_clone_copy)
+            }
+
+            TyKind::Pat(ty, _) => ty.is_trivially_pure_clone_copy(),
+
+            // Sometimes traits aren't implemented for every ABI or arity,
+            // because we can't be generic over everything yet.
+            TyKind::FnPtr(..) => false,
+
+            // Definitely absolutely not copy.
+            TyKind::Ref(_, _, Mutability::Mut) => false,
+
+            // The standard library has a blanket Copy impl for shared references and raw pointers,
+            // for all unsized types.
+            TyKind::Ref(_, _, Mutability::Not) | TyKind::RawPtr(..) => true,
+
+            TyKind::Coroutine(..) | TyKind::CoroutineWitness(..) => false,
+
+            // Might be, but not "trivial" so just giving the safe answer.
+            TyKind::Adt(..) | TyKind::Closure(..) | TyKind::CoroutineClosure(..) => false,
+
+            TyKind::UnsafeBinder(_) => false,
+
+            // Needs normalization or revealing to determine, so no is the safe answer.
+            TyKind::Alias(..) => false,
+
+            TyKind::Param(..)
+            | TyKind::Placeholder(..)
+            | TyKind::Bound(..)
+            | TyKind::Infer(..)
+            | TyKind::Error(..) => false,
+        }
+    }
+
+    pub fn is_trivially_wf(self, tcx: DbInterner<'db>) -> bool {
+        match self.kind() {
+            TyKind::Bool
+            | TyKind::Char
+            | TyKind::Int(_)
+            | TyKind::Uint(_)
+            | TyKind::Float(_)
+            | TyKind::Str
+            | TyKind::Never
+            | TyKind::Param(_)
+            | TyKind::Placeholder(_)
+            | TyKind::Bound(..) => true,
+
+            TyKind::Slice(ty) => {
+                ty.is_trivially_wf(tcx) && ty.has_trivial_sizedness(tcx, SizedTraitKind::Sized)
+            }
+            TyKind::RawPtr(ty, _) => ty.is_trivially_wf(tcx),
+
+            TyKind::FnPtr(sig_tys, _) => {
+                sig_tys.skip_binder().inputs_and_output.iter().all(|ty| ty.is_trivially_wf(tcx))
+            }
+            TyKind::Ref(_, ty, _) => ty.is_global() && ty.is_trivially_wf(tcx),
+
+            TyKind::Infer(infer) => match infer {
+                InferTy::TyVar(_) => false,
+                InferTy::IntVar(_) | InferTy::FloatVar(_) => true,
+                InferTy::FreshTy(_) | InferTy::FreshIntTy(_) | InferTy::FreshFloatTy(_) => true,
+            },
+
+            TyKind::Adt(_, _)
+            | TyKind::Tuple(_)
+            | TyKind::Array(..)
+            | TyKind::Foreign(_)
+            | TyKind::Pat(_, _)
+            | TyKind::FnDef(..)
+            | TyKind::UnsafeBinder(..)
+            | TyKind::Dynamic(..)
+            | TyKind::Closure(..)
+            | TyKind::CoroutineClosure(..)
+            | TyKind::Coroutine(..)
+            | TyKind::CoroutineWitness(..)
+            | TyKind::Alias(..)
+            | TyKind::Error(_) => false,
+        }
+    }
+}
+
+impl<'db> std::fmt::Debug for Ty<'db> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.inner().internee.fmt(f)
+    }
+}
+
+impl<'db> std::fmt::Debug for InternedWrapperNoDebug<WithCachedTypeInfo<TyKind<'db>>> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.0.internee.fmt(f)
+    }
+}
+
+impl<'db> IntoKind for Ty<'db> {
+    type Kind = TyKind<'db>;
+
+    fn kind(self) -> Self::Kind {
+        self.inner().internee
+    }
+}
+
+impl<'db> TypeVisitable<DbInterner<'db>> for Ty<'db> {
+    fn visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>(
+        &self,
+        visitor: &mut V,
+    ) -> V::Result {
+        visitor.visit_ty(*self)
+    }
+}
+
+impl<'db> TypeSuperVisitable<DbInterner<'db>> for Ty<'db> {
+    fn super_visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>(
+        &self,
+        visitor: &mut V,
+    ) -> V::Result {
+        match (*self).kind() {
+            TyKind::RawPtr(ty, _mutbl) => ty.visit_with(visitor),
+            TyKind::Array(typ, sz) => {
+                try_visit!(typ.visit_with(visitor));
+                sz.visit_with(visitor)
+            }
+            TyKind::Slice(typ) => typ.visit_with(visitor),
+            TyKind::Adt(_, args) => args.visit_with(visitor),
+            TyKind::Dynamic(ref trait_ty, ref reg, _) => {
+                try_visit!(trait_ty.visit_with(visitor));
+                reg.visit_with(visitor)
+            }
+            TyKind::Tuple(ts) => ts.visit_with(visitor),
+            TyKind::FnDef(_, args) => args.visit_with(visitor),
+            TyKind::FnPtr(ref sig_tys, _) => sig_tys.visit_with(visitor),
+            TyKind::UnsafeBinder(f) => f.visit_with(visitor),
+            TyKind::Ref(r, ty, _) => {
+                try_visit!(r.visit_with(visitor));
+                ty.visit_with(visitor)
+            }
+            TyKind::Coroutine(_did, ref args) => args.visit_with(visitor),
+            TyKind::CoroutineWitness(_did, ref args) => args.visit_with(visitor),
+            TyKind::Closure(_did, ref args) => args.visit_with(visitor),
+            TyKind::CoroutineClosure(_did, ref args) => args.visit_with(visitor),
+            TyKind::Alias(_, ref data) => data.visit_with(visitor),
+
+            TyKind::Pat(ty, pat) => {
+                try_visit!(ty.visit_with(visitor));
+                pat.visit_with(visitor)
+            }
+
+            TyKind::Error(guar) => guar.visit_with(visitor),
+
+            TyKind::Bool
+            | TyKind::Char
+            | TyKind::Str
+            | TyKind::Int(_)
+            | TyKind::Uint(_)
+            | TyKind::Float(_)
+            | TyKind::Infer(_)
+            | TyKind::Bound(..)
+            | TyKind::Placeholder(..)
+            | TyKind::Param(..)
+            | TyKind::Never
+            | TyKind::Foreign(..) => V::Result::output(),
+        }
+    }
+}
+
+impl<'db> TypeFoldable<DbInterner<'db>> for Ty<'db> {
+    fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>(
+        self,
+        folder: &mut F,
+    ) -> Result<Self, F::Error> {
+        folder.try_fold_ty(self)
+    }
+    fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self {
+        folder.fold_ty(self)
+    }
+}
+
+impl<'db> TypeSuperFoldable<DbInterner<'db>> for Ty<'db> {
+    fn try_super_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>(
+        self,
+        folder: &mut F,
+    ) -> Result<Self, F::Error> {
+        let kind = match self.kind() {
+            TyKind::RawPtr(ty, mutbl) => TyKind::RawPtr(ty.try_fold_with(folder)?, mutbl),
+            TyKind::Array(typ, sz) => {
+                TyKind::Array(typ.try_fold_with(folder)?, sz.try_fold_with(folder)?)
+            }
+            TyKind::Slice(typ) => TyKind::Slice(typ.try_fold_with(folder)?),
+            TyKind::Adt(tid, args) => TyKind::Adt(tid, args.try_fold_with(folder)?),
+            TyKind::Dynamic(trait_ty, region, representation) => TyKind::Dynamic(
+                trait_ty.try_fold_with(folder)?,
+                region.try_fold_with(folder)?,
+                representation,
+            ),
+            TyKind::Tuple(ts) => TyKind::Tuple(ts.try_fold_with(folder)?),
+            TyKind::FnDef(def_id, args) => TyKind::FnDef(def_id, args.try_fold_with(folder)?),
+            TyKind::FnPtr(sig_tys, hdr) => TyKind::FnPtr(sig_tys.try_fold_with(folder)?, hdr),
+            TyKind::UnsafeBinder(f) => TyKind::UnsafeBinder(f.try_fold_with(folder)?),
+            TyKind::Ref(r, ty, mutbl) => {
+                TyKind::Ref(r.try_fold_with(folder)?, ty.try_fold_with(folder)?, mutbl)
+            }
+            TyKind::Coroutine(did, args) => TyKind::Coroutine(did, args.try_fold_with(folder)?),
+            TyKind::CoroutineWitness(did, args) => {
+                TyKind::CoroutineWitness(did, args.try_fold_with(folder)?)
+            }
+            TyKind::Closure(did, args) => TyKind::Closure(did, args.try_fold_with(folder)?),
+            TyKind::CoroutineClosure(did, args) => {
+                TyKind::CoroutineClosure(did, args.try_fold_with(folder)?)
+            }
+            TyKind::Alias(kind, data) => TyKind::Alias(kind, data.try_fold_with(folder)?),
+            TyKind::Pat(ty, pat) => {
+                TyKind::Pat(ty.try_fold_with(folder)?, pat.try_fold_with(folder)?)
+            }
+
+            TyKind::Bool
+            | TyKind::Char
+            | TyKind::Str
+            | TyKind::Int(_)
+            | TyKind::Uint(_)
+            | TyKind::Float(_)
+            | TyKind::Error(_)
+            | TyKind::Infer(_)
+            | TyKind::Param(..)
+            | TyKind::Bound(..)
+            | TyKind::Placeholder(..)
+            | TyKind::Never
+            | TyKind::Foreign(..) => return Ok(self),
+        };
+
+        Ok(if self.kind() == kind { self } else { Ty::new(folder.cx(), kind) })
+    }
+    fn super_fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(
+        self,
+        folder: &mut F,
+    ) -> Self {
+        let kind = match self.kind() {
+            TyKind::RawPtr(ty, mutbl) => TyKind::RawPtr(ty.fold_with(folder), mutbl),
+            TyKind::Array(typ, sz) => TyKind::Array(typ.fold_with(folder), sz.fold_with(folder)),
+            TyKind::Slice(typ) => TyKind::Slice(typ.fold_with(folder)),
+            TyKind::Adt(tid, args) => TyKind::Adt(tid, args.fold_with(folder)),
+            TyKind::Dynamic(trait_ty, region, representation) => TyKind::Dynamic(
+                trait_ty.fold_with(folder),
+                region.fold_with(folder),
+                representation,
+            ),
+            TyKind::Tuple(ts) => TyKind::Tuple(ts.fold_with(folder)),
+            TyKind::FnDef(def_id, args) => TyKind::FnDef(def_id, args.fold_with(folder)),
+            TyKind::FnPtr(sig_tys, hdr) => TyKind::FnPtr(sig_tys.fold_with(folder), hdr),
+            TyKind::UnsafeBinder(f) => TyKind::UnsafeBinder(f.fold_with(folder)),
+            TyKind::Ref(r, ty, mutbl) => {
+                TyKind::Ref(r.fold_with(folder), ty.fold_with(folder), mutbl)
+            }
+            TyKind::Coroutine(did, args) => TyKind::Coroutine(did, args.fold_with(folder)),
+            TyKind::CoroutineWitness(did, args) => {
+                TyKind::CoroutineWitness(did, args.fold_with(folder))
+            }
+            TyKind::Closure(did, args) => TyKind::Closure(did, args.fold_with(folder)),
+            TyKind::CoroutineClosure(did, args) => {
+                TyKind::CoroutineClosure(did, args.fold_with(folder))
+            }
+            TyKind::Alias(kind, data) => TyKind::Alias(kind, data.fold_with(folder)),
+            TyKind::Pat(ty, pat) => TyKind::Pat(ty.fold_with(folder), pat.fold_with(folder)),
+
+            TyKind::Bool
+            | TyKind::Char
+            | TyKind::Str
+            | TyKind::Int(_)
+            | TyKind::Uint(_)
+            | TyKind::Float(_)
+            | TyKind::Error(_)
+            | TyKind::Infer(_)
+            | TyKind::Param(..)
+            | TyKind::Bound(..)
+            | TyKind::Placeholder(..)
+            | TyKind::Never
+            | TyKind::Foreign(..) => return self,
+        };
+
+        if self.kind() == kind { self } else { Ty::new(folder.cx(), kind) }
+    }
+}
+
+impl<'db> Relate<DbInterner<'db>> for Ty<'db> {
+    fn relate<R: rustc_type_ir::relate::TypeRelation<DbInterner<'db>>>(
+        relation: &mut R,
+        a: Self,
+        b: Self,
+    ) -> rustc_type_ir::relate::RelateResult<DbInterner<'db>, Self> {
+        relation.tys(a, b)
+    }
+}
+
+impl<'db> Flags for Ty<'db> {
+    fn flags(&self) -> rustc_type_ir::TypeFlags {
+        self.inner().flags
+    }
+
+    fn outer_exclusive_binder(&self) -> rustc_type_ir::DebruijnIndex {
+        self.inner().outer_exclusive_binder
+    }
+}
+
+impl<'db> rustc_type_ir::inherent::Ty<DbInterner<'db>> for Ty<'db> {
+    fn new_unit(interner: DbInterner<'db>) -> Self {
+        Ty::new(interner, TyKind::Tuple(Default::default()))
+    }
+
+    fn new_bool(interner: DbInterner<'db>) -> Self {
+        Ty::new(interner, TyKind::Bool)
+    }
+
+    fn new_u8(interner: DbInterner<'db>) -> Self {
+        Ty::new(interner, TyKind::Uint(rustc_type_ir::UintTy::U8))
+    }
+
+    fn new_usize(interner: DbInterner<'db>) -> Self {
+        Ty::new(interner, TyKind::Uint(rustc_type_ir::UintTy::Usize))
+    }
+
+    fn new_infer(interner: DbInterner<'db>, var: rustc_type_ir::InferTy) -> Self {
+        Ty::new(interner, TyKind::Infer(var))
+    }
+
+    fn new_var(interner: DbInterner<'db>, var: rustc_type_ir::TyVid) -> Self {
+        Ty::new(interner, TyKind::Infer(rustc_type_ir::InferTy::TyVar(var)))
+    }
+
+    fn new_param(interner: DbInterner<'db>, param: ParamTy) -> Self {
+        Ty::new(interner, TyKind::Param(param))
+    }
+
+    fn new_placeholder(interner: DbInterner<'db>, param: PlaceholderTy) -> Self {
+        Ty::new(interner, TyKind::Placeholder(param))
+    }
+
+    fn new_bound(
+        interner: DbInterner<'db>,
+        debruijn: rustc_type_ir::DebruijnIndex,
+        var: BoundTy,
+    ) -> Self {
+        Ty::new(interner, TyKind::Bound(debruijn, var))
+    }
+
+    fn new_anon_bound(
+        interner: DbInterner<'db>,
+        debruijn: rustc_type_ir::DebruijnIndex,
+        var: BoundVar,
+    ) -> Self {
+        Ty::new(interner, TyKind::Bound(debruijn, BoundTy { var, kind: BoundTyKind::Anon }))
+    }
+
+    fn new_alias(
+        interner: DbInterner<'db>,
+        kind: rustc_type_ir::AliasTyKind,
+        alias_ty: rustc_type_ir::AliasTy<DbInterner<'db>>,
+    ) -> Self {
+        Ty::new(interner, TyKind::Alias(kind, alias_ty))
+    }
+
+    fn new_error(interner: DbInterner<'db>, guar: ErrorGuaranteed) -> Self {
+        Ty::new(interner, TyKind::Error(guar))
+    }
+
+    fn new_adt(
+        interner: DbInterner<'db>,
+        adt_def: <DbInterner<'db> as rustc_type_ir::Interner>::AdtDef,
+        args: GenericArgs<'db>,
+    ) -> Self {
+        Ty::new(interner, TyKind::Adt(adt_def, args))
+    }
+
+    fn new_foreign(
+        interner: DbInterner<'db>,
+        def_id: <DbInterner<'db> as rustc_type_ir::Interner>::DefId,
+    ) -> Self {
+        Ty::new(interner, TyKind::Foreign(def_id))
+    }
+
+    fn new_dynamic(
+        interner: DbInterner<'db>,
+        preds: <DbInterner<'db> as rustc_type_ir::Interner>::BoundExistentialPredicates,
+        region: <DbInterner<'db> as rustc_type_ir::Interner>::Region,
+        kind: rustc_type_ir::DynKind,
+    ) -> Self {
+        Ty::new(interner, TyKind::Dynamic(preds, region, kind))
+    }
+
+    fn new_coroutine(
+        interner: DbInterner<'db>,
+        def_id: <DbInterner<'db> as rustc_type_ir::Interner>::DefId,
+        args: <DbInterner<'db> as rustc_type_ir::Interner>::GenericArgs,
+    ) -> Self {
+        Ty::new(interner, TyKind::Coroutine(def_id, args))
+    }
+
+    fn new_coroutine_closure(
+        interner: DbInterner<'db>,
+        def_id: <DbInterner<'db> as rustc_type_ir::Interner>::DefId,
+        args: <DbInterner<'db> as rustc_type_ir::Interner>::GenericArgs,
+    ) -> Self {
+        Ty::new(interner, TyKind::CoroutineClosure(def_id, args))
+    }
+
+    fn new_closure(
+        interner: DbInterner<'db>,
+        def_id: <DbInterner<'db> as rustc_type_ir::Interner>::DefId,
+        args: <DbInterner<'db> as rustc_type_ir::Interner>::GenericArgs,
+    ) -> Self {
+        Ty::new(interner, TyKind::Closure(def_id, args))
+    }
+
+    fn new_coroutine_witness(
+        interner: DbInterner<'db>,
+        def_id: <DbInterner<'db> as rustc_type_ir::Interner>::DefId,
+        args: <DbInterner<'db> as rustc_type_ir::Interner>::GenericArgs,
+    ) -> Self {
+        Ty::new(interner, TyKind::CoroutineWitness(def_id, args))
+    }
+
+    fn new_ptr(interner: DbInterner<'db>, ty: Self, mutbl: rustc_ast_ir::Mutability) -> Self {
+        Ty::new(interner, TyKind::RawPtr(ty, mutbl))
+    }
+
+    fn new_ref(
+        interner: DbInterner<'db>,
+        region: <DbInterner<'db> as rustc_type_ir::Interner>::Region,
+        ty: Self,
+        mutbl: rustc_ast_ir::Mutability,
+    ) -> Self {
+        Ty::new(interner, TyKind::Ref(region, ty, mutbl))
+    }
+
+    fn new_array_with_const_len(
+        interner: DbInterner<'db>,
+        ty: Self,
+        len: <DbInterner<'db> as rustc_type_ir::Interner>::Const,
+    ) -> Self {
+        Ty::new(interner, TyKind::Array(ty, len))
+    }
+
+    fn new_slice(interner: DbInterner<'db>, ty: Self) -> Self {
+        Ty::new(interner, TyKind::Slice(ty))
+    }
+
+    fn new_tup(
+        interner: DbInterner<'db>,
+        tys: &[<DbInterner<'db> as rustc_type_ir::Interner>::Ty],
+    ) -> Self {
+        Ty::new(interner, TyKind::Tuple(Tys::new_from_iter(interner, tys.iter().cloned())))
+    }
+
+    fn new_tup_from_iter<It, T>(interner: DbInterner<'db>, iter: It) -> T::Output
+    where
+        It: Iterator<Item = T>,
+        T: rustc_type_ir::CollectAndApply<Self, Self>,
+    {
+        T::collect_and_apply(iter, |ts| Ty::new_tup(interner, ts))
+    }
+
+    fn new_fn_def(
+        interner: DbInterner<'db>,
+        def_id: <DbInterner<'db> as rustc_type_ir::Interner>::DefId,
+        args: <DbInterner<'db> as rustc_type_ir::Interner>::GenericArgs,
+    ) -> Self {
+        Ty::new(interner, TyKind::FnDef(def_id, args))
+    }
+
+    fn new_fn_ptr(
+        interner: DbInterner<'db>,
+        sig: rustc_type_ir::Binder<DbInterner<'db>, rustc_type_ir::FnSig<DbInterner<'db>>>,
+    ) -> Self {
+        let (sig_tys, header) = sig.split();
+        Ty::new(interner, TyKind::FnPtr(sig_tys, header))
+    }
+
+    fn new_pat(
+        interner: DbInterner<'db>,
+        ty: Self,
+        pat: <DbInterner<'db> as rustc_type_ir::Interner>::Pat,
+    ) -> Self {
+        Ty::new(interner, TyKind::Pat(ty, pat))
+    }
+
+    fn tuple_fields(self) -> <DbInterner<'db> as rustc_type_ir::Interner>::Tys {
+        match self.kind() {
+            TyKind::Tuple(args) => args,
+            _ => panic!("tuple_fields called on non-tuple: {self:?}"),
+        }
+    }
+
+    fn to_opt_closure_kind(self) -> Option<rustc_type_ir::ClosureKind> {
+        match self.kind() {
+            TyKind::Int(int_ty) => match int_ty {
+                IntTy::I8 => Some(ClosureKind::Fn),
+                IntTy::I16 => Some(ClosureKind::FnMut),
+                IntTy::I32 => Some(ClosureKind::FnOnce),
+                _ => unreachable!("cannot convert type `{:?}` to a closure kind", self),
+            },
+
+            // "Bound" types appear in canonical queries when the
+            // closure type is not yet known, and `Placeholder` and `Param`
+            // may be encountered in generic `AsyncFnKindHelper` goals.
+            TyKind::Bound(..) | TyKind::Placeholder(_) | TyKind::Param(_) | TyKind::Infer(_) => {
+                None
+            }
+
+            TyKind::Error(_) => Some(ClosureKind::Fn),
+
+            _ => unreachable!("cannot convert type `{:?}` to a closure kind", self),
+        }
+    }
+
+    fn from_closure_kind(interner: DbInterner<'db>, kind: rustc_type_ir::ClosureKind) -> Self {
+        match kind {
+            ClosureKind::Fn => Ty::new(interner, TyKind::Int(IntTy::I8)),
+            ClosureKind::FnMut => Ty::new(interner, TyKind::Int(IntTy::I16)),
+            ClosureKind::FnOnce => Ty::new(interner, TyKind::Int(IntTy::I32)),
+        }
+    }
+
+    fn from_coroutine_closure_kind(
+        interner: DbInterner<'db>,
+        kind: rustc_type_ir::ClosureKind,
+    ) -> Self {
+        match kind {
+            ClosureKind::Fn | ClosureKind::FnMut => Ty::new(interner, TyKind::Int(IntTy::I16)),
+            ClosureKind::FnOnce => Ty::new(interner, TyKind::Int(IntTy::I32)),
+        }
+    }
+
+    fn discriminant_ty(
+        self,
+        interner: DbInterner<'db>,
+    ) -> <DbInterner<'db> as rustc_type_ir::Interner>::Ty {
+        match self.kind() {
+            TyKind::Adt(adt, _) if adt.is_enum() => adt.repr().discr_type().to_ty(interner),
+            TyKind::Coroutine(_, args) => args.as_coroutine().discr_ty(interner),
+
+            TyKind::Param(_) | TyKind::Alias(..) | TyKind::Infer(InferTy::TyVar(_)) => {
+                /*
+                let assoc_items = tcx.associated_item_def_ids(
+                    tcx.require_lang_item(hir::LangItem::DiscriminantKind, None),
+                );
+                TyKind::new_projection_from_args(tcx, assoc_items[0], tcx.mk_args(&[self.into()]))
+                */
+                unimplemented!()
+            }
+
+            TyKind::Pat(ty, _) => ty.discriminant_ty(interner),
+
+            TyKind::Bool
+            | TyKind::Char
+            | TyKind::Int(_)
+            | TyKind::Uint(_)
+            | TyKind::Float(_)
+            | TyKind::Adt(..)
+            | TyKind::Foreign(_)
+            | TyKind::Str
+            | TyKind::Array(..)
+            | TyKind::Slice(_)
+            | TyKind::RawPtr(_, _)
+            | TyKind::Ref(..)
+            | TyKind::FnDef(..)
+            | TyKind::FnPtr(..)
+            | TyKind::Dynamic(..)
+            | TyKind::Closure(..)
+            | TyKind::CoroutineClosure(..)
+            | TyKind::CoroutineWitness(..)
+            | TyKind::Never
+            | TyKind::Tuple(_)
+            | TyKind::Error(_)
+            | TyKind::Infer(InferTy::IntVar(_) | InferTy::FloatVar(_)) => {
+                Ty::new(interner, TyKind::Uint(UintTy::U8))
+            }
+
+            TyKind::Bound(..)
+            | TyKind::Placeholder(_)
+            | TyKind::Infer(
+                InferTy::FreshTy(_) | InferTy::FreshIntTy(_) | InferTy::FreshFloatTy(_),
+            ) => {
+                panic!(
+                    "`dself.iter().map(|v| v.try_fold_with(folder)).collect::<Result<_, _>>()?iscriminant_ty` applied to unexpected type: {self:?}"
+                )
+            }
+            TyKind::UnsafeBinder(..) => unimplemented!(),
+        }
+    }
+
+    fn new_unsafe_binder(
+        interner: DbInterner<'db>,
+        ty: rustc_type_ir::Binder<
+            DbInterner<'db>,
+            <DbInterner<'db> as rustc_type_ir::Interner>::Ty,
+        >,
+    ) -> Self {
+        Ty::new(interner, TyKind::UnsafeBinder(ty.into()))
+    }
+
+    fn has_unsafe_fields(self) -> bool {
+        false
+    }
+}
+
+interned_vec_db!(Tys, Ty);
+
+impl<'db> rustc_type_ir::inherent::Tys<DbInterner<'db>> for Tys<'db> {
+    fn inputs(self) -> <DbInterner<'db> as rustc_type_ir::Interner>::FnInputTys {
+        Tys::new_from_iter(
+            DbInterner::conjure(),
+            self.as_slice().split_last().unwrap().1.iter().cloned(),
+        )
+    }
+
+    fn output(self) -> <DbInterner<'db> as rustc_type_ir::Interner>::Ty {
+        *self.as_slice().split_last().unwrap().0
+    }
+}
+
+pub type PlaceholderTy = Placeholder<BoundTy>;
+
+#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+pub struct ParamTy {
+    pub index: u32,
+}
+
+impl ParamTy {
+    pub fn to_ty<'db>(self, interner: DbInterner<'db>) -> Ty<'db> {
+        Ty::new_param(interner, self.index, sym::MISSING_NAME.clone())
+    }
+}
+
+impl std::fmt::Debug for ParamTy {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "#{}", self.index)
+    }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+pub struct BoundTy {
+    pub var: BoundVar,
+    pub kind: BoundTyKind,
+}
+
+impl std::fmt::Debug for BoundTy {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self.kind {
+            BoundTyKind::Anon => write!(f, "{:?}", self.var),
+            BoundTyKind::Param(def_id) => write!(f, "{def_id:?}"),
+        }
+    }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
+pub enum BoundTyKind {
+    Anon,
+    Param(SolverDefId),
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+pub struct ErrorGuaranteed;
+
+impl<'db> TypeVisitable<DbInterner<'db>> for ErrorGuaranteed {
+    fn visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>(
+        &self,
+        visitor: &mut V,
+    ) -> V::Result {
+        visitor.visit_error(*self)
+    }
+}
+
+impl<'db> TypeFoldable<DbInterner<'db>> for ErrorGuaranteed {
+    fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>(
+        self,
+        folder: &mut F,
+    ) -> Result<Self, F::Error> {
+        Ok(self)
+    }
+    fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self {
+        self
+    }
+}
+
+impl ParamLike for ParamTy {
+    fn index(self) -> u32 {
+        self.index
+    }
+}
+
+impl<'db> BoundVarLike<DbInterner<'db>> for BoundTy {
+    fn var(self) -> BoundVar {
+        self.var
+    }
+
+    fn assert_eq(self, var: BoundVarKind) {
+        assert_eq!(self.kind, var.expect_ty())
+    }
+}
+
+impl<'db> PlaceholderLike<DbInterner<'db>> for PlaceholderTy {
+    type Bound = BoundTy;
+
+    fn universe(self) -> rustc_type_ir::UniverseIndex {
+        self.universe
+    }
+
+    fn var(self) -> BoundVar {
+        self.bound.var
+    }
+
+    fn with_updated_universe(self, ui: rustc_type_ir::UniverseIndex) -> Self {
+        Placeholder { universe: ui, bound: self.bound }
+    }
+
+    fn new(ui: rustc_type_ir::UniverseIndex, bound: BoundTy) -> Self {
+        Placeholder { universe: ui, bound }
+    }
+
+    fn new_anon(ui: rustc_type_ir::UniverseIndex, var: rustc_type_ir::BoundVar) -> Self {
+        Placeholder { universe: ui, bound: BoundTy { var, kind: BoundTyKind::Anon } }
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/util.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/util.rs
new file mode 100644
index 0000000000000..cedc203f7f5aa
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/util.rs
@@ -0,0 +1,1064 @@
+//! Various utilities for the next-trait-solver.
+
+use std::iter;
+use std::ops::{self, ControlFlow};
+
+use base_db::Crate;
+use hir_def::lang_item::LangItem;
+use hir_def::{BlockId, HasModule, ItemContainerId, Lookup};
+use intern::sym;
+use la_arena::Idx;
+use rustc_abi::{Float, HasDataLayout, Integer, IntegerType, Primitive, ReprOptions};
+use rustc_type_ir::data_structures::IndexMap;
+use rustc_type_ir::inherent::{
+    AdtDef, Const as _, GenericArg as _, GenericArgs as _, ParamEnv as _, Region as _, SliceLike,
+    Ty as _,
+};
+use rustc_type_ir::lang_items::TraitSolverLangItem;
+use rustc_type_ir::solve::SizedTraitKind;
+use rustc_type_ir::{
+    BoundVar, Canonical, DebruijnIndex, GenericArgKind, INNERMOST, Interner, PredicatePolarity,
+    TypeFlags, TypeVisitable, TypeVisitableExt,
+};
+use rustc_type_ir::{
+    ConstKind, CoroutineArgs, FloatTy, IntTy, RegionKind, TypeFolder, TypeSuperFoldable,
+    TypeSuperVisitable, TypeVisitor, UintTy, UniverseIndex, inherent::IntoKind,
+};
+use rustc_type_ir::{InferCtxtLike, TypeFoldable};
+
+use crate::lower_nextsolver::{LifetimeElisionKind, TyLoweringContext};
+use crate::next_solver::infer::InferCtxt;
+use crate::next_solver::{
+    CanonicalVarKind, FxIndexMap, ParamEnv, Placeholder, PlaceholderConst, PlaceholderRegion,
+    TypingMode,
+};
+use crate::{
+    db::HirDatabase,
+    from_foreign_def_id,
+    method_resolution::{TraitImpls, TyFingerprint},
+};
+
+use super::fold::{BoundVarReplacer, FnMutDelegate};
+use super::generics::generics;
+use super::{
+    AliasTerm, AliasTy, Binder, BoundRegion, BoundTy, BoundTyKind, BoundVarKind, BoundVarKinds,
+    CanonicalVars, Clause, ClauseKind, Clauses, Const, DbInterner, EarlyBinder, GenericArg,
+    GenericArgs, Predicate, PredicateKind, ProjectionPredicate, Region, SolverContext, SolverDefId,
+    Term, TraitPredicate, TraitRef, Ty, TyKind,
+};
+
+#[derive(Clone, Debug)]
+pub struct Discr<'db> {
+    /// Bit representation of the discriminant (e.g., `-128i8` is `0xFF_u128`).
+    pub val: u128,
+    pub ty: Ty<'db>,
+}
+
+impl<'db> Discr<'db> {
+    /// Adds `1` to the value and wraps around if the maximum for the type is reached.
+    pub fn wrap_incr(self, interner: DbInterner<'db>) -> Self {
+        self.checked_add(interner, 1).0
+    }
+    pub fn checked_add(self, interner: DbInterner<'db>, n: u128) -> (Self, bool) {
+        let (size, signed) = self.ty.int_size_and_signed(interner);
+        let (val, oflo) = if signed {
+            let min = size.signed_int_min();
+            let max = size.signed_int_max();
+            let val = size.sign_extend(self.val);
+            assert!(n < (i128::MAX as u128));
+            let n = n as i128;
+            let oflo = val > max - n;
+            let val = if oflo { min + (n - (max - val) - 1) } else { val + n };
+            // zero the upper bits
+            let val = val as u128;
+            let val = size.truncate(val);
+            (val, oflo)
+        } else {
+            let max = size.unsigned_int_max();
+            let val = self.val;
+            let oflo = val > max - n;
+            let val = if oflo { n - (max - val) - 1 } else { val + n };
+            (val, oflo)
+        };
+        (Self { val, ty: self.ty }, oflo)
+    }
+}
+
+pub trait IntegerTypeExt {
+    fn to_ty<'db>(&self, interner: DbInterner<'db>) -> Ty<'db>;
+    fn initial_discriminant<'db>(&self, interner: DbInterner<'db>) -> Discr<'db>;
+    fn disr_incr<'db>(
+        &self,
+        interner: DbInterner<'db>,
+        val: Option<Discr<'db>>,
+    ) -> Option<Discr<'db>>;
+}
+
+impl IntegerTypeExt for IntegerType {
+    fn to_ty<'db>(&self, interner: DbInterner<'db>) -> Ty<'db> {
+        match self {
+            IntegerType::Pointer(true) => Ty::new(interner, TyKind::Int(IntTy::Isize)),
+            IntegerType::Pointer(false) => Ty::new(interner, TyKind::Uint(UintTy::Usize)),
+            IntegerType::Fixed(i, s) => i.to_ty(interner, *s),
+        }
+    }
+
+    fn initial_discriminant<'db>(&self, interner: DbInterner<'db>) -> Discr<'db> {
+        Discr { val: 0, ty: self.to_ty(interner) }
+    }
+
+    fn disr_incr<'db>(
+        &self,
+        interner: DbInterner<'db>,
+        val: Option<Discr<'db>>,
+    ) -> Option<Discr<'db>> {
+        if let Some(val) = val {
+            assert_eq!(self.to_ty(interner), val.ty);
+            let (new, oflo) = val.checked_add(interner, 1);
+            if oflo { None } else { Some(new) }
+        } else {
+            Some(self.initial_discriminant(interner))
+        }
+    }
+}
+
+pub trait IntegerExt {
+    fn to_ty<'db>(&self, interner: DbInterner<'db>, signed: bool) -> Ty<'db>;
+    fn from_int_ty<C: HasDataLayout>(cx: &C, ity: IntTy) -> Integer;
+    fn from_uint_ty<C: HasDataLayout>(cx: &C, ity: UintTy) -> Integer;
+    fn repr_discr<'db>(
+        interner: DbInterner<'db>,
+        ty: Ty<'db>,
+        repr: &ReprOptions,
+        min: i128,
+        max: i128,
+    ) -> (Integer, bool);
+}
+
+impl IntegerExt for Integer {
+    #[inline]
+    fn to_ty<'db>(&self, interner: DbInterner<'db>, signed: bool) -> Ty<'db> {
+        use Integer::*;
+        match (*self, signed) {
+            (I8, false) => Ty::new(interner, TyKind::Uint(UintTy::U8)),
+            (I16, false) => Ty::new(interner, TyKind::Uint(UintTy::U16)),
+            (I32, false) => Ty::new(interner, TyKind::Uint(UintTy::U32)),
+            (I64, false) => Ty::new(interner, TyKind::Uint(UintTy::U64)),
+            (I128, false) => Ty::new(interner, TyKind::Uint(UintTy::U128)),
+            (I8, true) => Ty::new(interner, TyKind::Int(IntTy::I8)),
+            (I16, true) => Ty::new(interner, TyKind::Int(IntTy::I16)),
+            (I32, true) => Ty::new(interner, TyKind::Int(IntTy::I32)),
+            (I64, true) => Ty::new(interner, TyKind::Int(IntTy::I64)),
+            (I128, true) => Ty::new(interner, TyKind::Int(IntTy::I128)),
+        }
+    }
+
+    fn from_int_ty<C: HasDataLayout>(cx: &C, ity: IntTy) -> Integer {
+        use Integer::*;
+        match ity {
+            IntTy::I8 => I8,
+            IntTy::I16 => I16,
+            IntTy::I32 => I32,
+            IntTy::I64 => I64,
+            IntTy::I128 => I128,
+            IntTy::Isize => cx.data_layout().ptr_sized_integer(),
+        }
+    }
+    fn from_uint_ty<C: HasDataLayout>(cx: &C, ity: UintTy) -> Integer {
+        use Integer::*;
+        match ity {
+            UintTy::U8 => I8,
+            UintTy::U16 => I16,
+            UintTy::U32 => I32,
+            UintTy::U64 => I64,
+            UintTy::U128 => I128,
+            UintTy::Usize => cx.data_layout().ptr_sized_integer(),
+        }
+    }
+
+    /// Finds the appropriate Integer type and signedness for the given
+    /// signed discriminant range and `#[repr]` attribute.
+    /// N.B.: `u128` values above `i128::MAX` will be treated as signed, but
+    /// that shouldn't affect anything, other than maybe debuginfo.
+    fn repr_discr<'db>(
+        interner: DbInterner<'db>,
+        ty: Ty<'db>,
+        repr: &ReprOptions,
+        min: i128,
+        max: i128,
+    ) -> (Integer, bool) {
+        // Theoretically, negative values could be larger in unsigned representation
+        // than the unsigned representation of the signed minimum. However, if there
+        // are any negative values, the only valid unsigned representation is u128
+        // which can fit all i128 values, so the result remains unaffected.
+        let unsigned_fit = Integer::fit_unsigned(std::cmp::max(min as u128, max as u128));
+        let signed_fit = std::cmp::max(Integer::fit_signed(min), Integer::fit_signed(max));
+
+        if let Some(ity) = repr.int {
+            let discr = Integer::from_attr(&interner, ity);
+            let fit = if ity.is_signed() { signed_fit } else { unsigned_fit };
+            if discr < fit {
+                panic!(
+                    "Integer::repr_discr: `#[repr]` hint too small for \
+                      discriminant range of enum `{ty:?}`"
+                )
+            }
+            return (discr, ity.is_signed());
+        }
+
+        let at_least = if repr.c() {
+            // This is usually I32, however it can be different on some platforms,
+            // notably hexagon and arm-none/thumb-none
+            interner.data_layout().c_enum_min_size
+        } else {
+            // repr(Rust) enums try to be as small as possible
+            Integer::I8
+        };
+
+        // If there are no negative values, we can use the unsigned fit.
+        if min >= 0 {
+            (std::cmp::max(unsigned_fit, at_least), false)
+        } else {
+            (std::cmp::max(signed_fit, at_least), true)
+        }
+    }
+}
+
+pub trait FloatExt {
+    fn to_ty<'db>(&self, interner: DbInterner<'db>) -> Ty<'db>;
+    fn from_float_ty(fty: FloatTy) -> Self;
+}
+
+impl FloatExt for Float {
+    #[inline]
+    fn to_ty<'db>(&self, interner: DbInterner<'db>) -> Ty<'db> {
+        use Float::*;
+        match *self {
+            F16 => Ty::new(interner, TyKind::Float(FloatTy::F16)),
+            F32 => Ty::new(interner, TyKind::Float(FloatTy::F32)),
+            F64 => Ty::new(interner, TyKind::Float(FloatTy::F64)),
+            F128 => Ty::new(interner, TyKind::Float(FloatTy::F128)),
+        }
+    }
+
+    fn from_float_ty(fty: FloatTy) -> Self {
+        use Float::*;
+        match fty {
+            FloatTy::F16 => F16,
+            FloatTy::F32 => F32,
+            FloatTy::F64 => F64,
+            FloatTy::F128 => F128,
+        }
+    }
+}
+
+pub trait PrimitiveExt {
+    fn to_ty<'db>(&self, interner: DbInterner<'db>) -> Ty<'db>;
+    fn to_int_ty<'db>(&self, interner: DbInterner<'db>) -> Ty<'db>;
+}
+
+impl PrimitiveExt for Primitive {
+    #[inline]
+    fn to_ty<'db>(&self, interner: DbInterner<'db>) -> Ty<'db> {
+        match *self {
+            Primitive::Int(i, signed) => i.to_ty(interner, signed),
+            Primitive::Float(f) => f.to_ty(interner),
+            Primitive::Pointer(_) => Ty::new(
+                interner,
+                TyKind::RawPtr(
+                    Ty::new(interner, TyKind::Tuple(Default::default())),
+                    rustc_ast_ir::Mutability::Mut,
+                ),
+            ),
+        }
+    }
+
+    /// Return an *integer* type matching this primitive.
+    /// Useful in particular when dealing with enum discriminants.
+    #[inline]
+    fn to_int_ty<'db>(&self, interner: DbInterner<'db>) -> Ty<'db> {
+        match *self {
+            Primitive::Int(i, signed) => i.to_ty(interner, signed),
+            Primitive::Pointer(_) => {
+                let signed = false;
+                interner.data_layout().ptr_sized_integer().to_ty(interner, signed)
+            }
+            Primitive::Float(_) => panic!("floats do not have an int type"),
+        }
+    }
+}
+
+impl<'db> HasDataLayout for DbInterner<'db> {
+    fn data_layout(&self) -> &rustc_abi::TargetDataLayout {
+        unimplemented!()
+    }
+}
+
+pub trait CoroutineArgsExt<'db> {
+    fn discr_ty(&self, interner: DbInterner<'db>) -> Ty<'db>;
+}
+
+impl<'db> CoroutineArgsExt<'db> for CoroutineArgs<DbInterner<'db>> {
+    /// The type of the state discriminant used in the coroutine type.
+    #[inline]
+    fn discr_ty(&self, interner: DbInterner<'db>) -> Ty<'db> {
+        Ty::new(interner, TyKind::Uint(UintTy::U32))
+    }
+}
+
+/// Finds the max universe present
+pub struct MaxUniverse {
+    max_universe: UniverseIndex,
+}
+
+impl Default for MaxUniverse {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl MaxUniverse {
+    pub fn new() -> Self {
+        MaxUniverse { max_universe: UniverseIndex::ROOT }
+    }
+
+    pub fn max_universe(self) -> UniverseIndex {
+        self.max_universe
+    }
+}
+
+impl<'db> TypeVisitor<DbInterner<'db>> for MaxUniverse {
+    type Result = ();
+
+    fn visit_ty(&mut self, t: Ty<'db>) {
+        if let TyKind::Placeholder(placeholder) = t.kind() {
+            self.max_universe = UniverseIndex::from_u32(
+                self.max_universe.as_u32().max(placeholder.universe.as_u32()),
+            );
+        }
+
+        t.super_visit_with(self)
+    }
+
+    fn visit_const(&mut self, c: Const<'db>) {
+        if let ConstKind::Placeholder(placeholder) = c.kind() {
+            self.max_universe = UniverseIndex::from_u32(
+                self.max_universe.as_u32().max(placeholder.universe.as_u32()),
+            );
+        }
+
+        c.super_visit_with(self)
+    }
+
+    fn visit_region(&mut self, r: Region<'db>) {
+        if let RegionKind::RePlaceholder(placeholder) = r.kind() {
+            self.max_universe = UniverseIndex::from_u32(
+                self.max_universe.as_u32().max(placeholder.universe.as_u32()),
+            );
+        }
+    }
+}
+
+pub struct BottomUpFolder<'db, F, G, H>
+where
+    F: FnMut(Ty<'db>) -> Ty<'db>,
+    G: FnMut(Region<'db>) -> Region<'db>,
+    H: FnMut(Const<'db>) -> Const<'db>,
+{
+    pub interner: DbInterner<'db>,
+    pub ty_op: F,
+    pub lt_op: G,
+    pub ct_op: H,
+}
+
+impl<'db, F, G, H> TypeFolder<DbInterner<'db>> for BottomUpFolder<'db, F, G, H>
+where
+    F: FnMut(Ty<'db>) -> Ty<'db>,
+    G: FnMut(Region<'db>) -> Region<'db>,
+    H: FnMut(Const<'db>) -> Const<'db>,
+{
+    fn cx(&self) -> DbInterner<'db> {
+        self.interner
+    }
+
+    fn fold_ty(&mut self, ty: Ty<'db>) -> Ty<'db> {
+        let t = ty.super_fold_with(self);
+        (self.ty_op)(t)
+    }
+
+    fn fold_region(&mut self, r: Region<'db>) -> Region<'db> {
+        // This one is a little different, because `super_fold_with` is not
+        // implemented on non-recursive `Region`.
+        (self.lt_op)(r)
+    }
+
+    fn fold_const(&mut self, ct: Const<'db>) -> Const<'db> {
+        let ct = ct.super_fold_with(self);
+        (self.ct_op)(ct)
+    }
+}
+
+pub(crate) fn for_trait_impls(
+    db: &dyn HirDatabase,
+    krate: Crate,
+    block: Option<BlockId>,
+    trait_id: hir_def::TraitId,
+    self_ty_fp: Option<TyFingerprint>,
+    mut f: impl FnMut(&TraitImpls) -> ControlFlow<()>,
+) -> ControlFlow<()> {
+    // Note: Since we're using `impls_for_trait` and `impl_provided_for`,
+    // only impls where the trait can be resolved should ever reach Chalk.
+    // `impl_datum` relies on that and will panic if the trait can't be resolved.
+    let in_deps = db.trait_impls_in_deps(krate);
+    let in_self = db.trait_impls_in_crate(krate);
+    let trait_module = trait_id.module(db);
+    let type_module = match self_ty_fp {
+        Some(TyFingerprint::Adt(adt_id)) => Some(adt_id.module(db)),
+        Some(TyFingerprint::ForeignType(type_id)) => Some(from_foreign_def_id(type_id).module(db)),
+        Some(TyFingerprint::Dyn(trait_id)) => Some(trait_id.module(db)),
+        _ => None,
+    };
+
+    let mut def_blocks =
+        [trait_module.containing_block(), type_module.and_then(|it| it.containing_block())];
+
+    let block_impls = iter::successors(block, |&block_id| {
+        cov_mark::hit!(block_local_impls);
+        block_id.loc(db).module.containing_block()
+    })
+    .inspect(|&block_id| {
+        // make sure we don't search the same block twice
+        def_blocks.iter_mut().for_each(|block| {
+            if *block == Some(block_id) {
+                *block = None;
+            }
+        });
+    })
+    .filter_map(|block_id| db.trait_impls_in_block(block_id));
+    f(&in_self)?;
+    for it in in_deps.iter().map(ops::Deref::deref) {
+        f(it)?;
+    }
+    for it in block_impls {
+        f(&it)?;
+    }
+    for it in def_blocks.into_iter().flatten().filter_map(|it| db.trait_impls_in_block(it)) {
+        f(&it)?;
+    }
+    ControlFlow::Continue(())
+}
+
+// FIXME(next-trait-solver): uplift
+pub fn sizedness_constraint_for_ty<'db>(
+    interner: DbInterner<'db>,
+    sizedness: SizedTraitKind,
+    ty: Ty<'db>,
+) -> Option<Ty<'db>> {
+    use rustc_type_ir::TyKind::*;
+
+    match ty.kind() {
+        // these are always sized
+        Bool | Char | Int(..) | Uint(..) | Float(..) | RawPtr(..) | Ref(..) | FnDef(..)
+        | FnPtr(..) | Array(..) | Closure(..) | CoroutineClosure(..) | Coroutine(..)
+        | CoroutineWitness(..) | Never => None,
+
+        // these are never sized
+        Str | Slice(..) | Dynamic(_, _, rustc_type_ir::DynKind::Dyn) => match sizedness {
+            // Never `Sized`
+            SizedTraitKind::Sized => Some(ty),
+            // Always `MetaSized`
+            SizedTraitKind::MetaSized => None,
+        },
+
+        // Maybe `Sized` or `MetaSized`
+        Param(..) | Alias(..) | Error(_) => Some(ty),
+
+        // We cannot instantiate the binder, so just return the *original* type back,
+        // but only if the inner type has a sized constraint. Thus we skip the binder,
+        // but don't actually use the result from `sized_constraint_for_ty`.
+        UnsafeBinder(inner_ty) => {
+            sizedness_constraint_for_ty(interner, sizedness, inner_ty.skip_binder()).map(|_| ty)
+        }
+
+        // Never `MetaSized` or `Sized`
+        Foreign(..) => Some(ty),
+
+        // Recursive cases
+        Pat(ty, _) => sizedness_constraint_for_ty(interner, sizedness, ty),
+
+        Tuple(tys) => tys
+            .into_iter()
+            .last()
+            .and_then(|ty| sizedness_constraint_for_ty(interner, sizedness, ty)),
+
+        Adt(adt, args) => {
+            let tail_ty =
+                EarlyBinder::bind(adt.all_field_tys(interner).skip_binder().into_iter().last()?)
+                    .instantiate(interner, args);
+            sizedness_constraint_for_ty(interner, sizedness, tail_ty)
+        }
+
+        Placeholder(..) | Bound(..) | Infer(..) => {
+            panic!("unexpected type `{ty:?}` in sizedness_constraint_for_ty")
+        }
+    }
+}
+
+pub fn apply_args_to_binder<'db, T: TypeFoldable<DbInterner<'db>>>(
+    b: Binder<'db, T>,
+    args: GenericArgs<'db>,
+    interner: DbInterner<'db>,
+) -> T {
+    let types = &mut |ty: BoundTy| args.as_slice()[ty.var.index()].expect_ty();
+    let regions = &mut |region: BoundRegion| args.as_slice()[region.var.index()].expect_region();
+    let consts = &mut |const_: BoundVar| args.as_slice()[const_.index()].expect_const();
+    let mut instantiate = BoundVarReplacer::new(interner, FnMutDelegate { types, regions, consts });
+    b.skip_binder().fold_with(&mut instantiate)
+}
+
+pub(crate) fn mini_canonicalize<'db, T: TypeFoldable<DbInterner<'db>>>(
+    mut context: SolverContext<'db>,
+    val: T,
+) -> Canonical<DbInterner<'db>, T> {
+    let mut canon = MiniCanonicalizer {
+        context: &mut context,
+        db: DebruijnIndex::ZERO,
+        vars: IndexMap::default(),
+    };
+    let canon_val = val.fold_with(&mut canon);
+    let vars = canon.vars;
+    Canonical {
+        value: canon_val,
+        max_universe: UniverseIndex::from_u32(1),
+        variables: CanonicalVars::new_from_iter(
+            context.cx(),
+            vars.iter().map(|(k, v)| match (*k).kind() {
+                GenericArgKind::Type(ty) => match ty.kind() {
+                    TyKind::Int(..) | TyKind::Uint(..) => {
+                        rustc_type_ir::CanonicalVarKind::Ty(rustc_type_ir::CanonicalTyVarKind::Int)
+                    }
+                    TyKind::Float(..) => rustc_type_ir::CanonicalVarKind::Ty(
+                        rustc_type_ir::CanonicalTyVarKind::Float,
+                    ),
+                    _ => rustc_type_ir::CanonicalVarKind::Ty(
+                        rustc_type_ir::CanonicalTyVarKind::General(UniverseIndex::ZERO),
+                    ),
+                },
+                GenericArgKind::Lifetime(_) => {
+                    rustc_type_ir::CanonicalVarKind::Region(UniverseIndex::ZERO)
+                }
+                GenericArgKind::Const(_) => {
+                    rustc_type_ir::CanonicalVarKind::Const(UniverseIndex::ZERO)
+                }
+            }),
+        ),
+    }
+}
+
+struct MiniCanonicalizer<'a, 'db> {
+    context: &'a mut SolverContext<'db>,
+    db: DebruijnIndex,
+    vars: IndexMap<GenericArg<'db>, usize>,
+}
+
+impl<'db> TypeFolder<DbInterner<'db>> for MiniCanonicalizer<'_, 'db> {
+    fn cx(&self) -> DbInterner<'db> {
+        self.context.cx()
+    }
+
+    fn fold_binder<T: TypeFoldable<DbInterner<'db>>>(
+        &mut self,
+        t: rustc_type_ir::Binder<DbInterner<'db>, T>,
+    ) -> rustc_type_ir::Binder<DbInterner<'db>, T> {
+        self.db.shift_in(1);
+        let res = t.map_bound(|t| t.fold_with(self));
+        self.db.shift_out(1);
+        res
+    }
+
+    fn fold_ty(&mut self, t: Ty<'db>) -> Ty<'db> {
+        match t.kind() {
+            rustc_type_ir::TyKind::Bound(db, _) => {
+                if db >= self.db {
+                    panic!("Unexpected bound var");
+                }
+                t
+            }
+            rustc_type_ir::TyKind::Infer(infer) => {
+                let t = match infer {
+                    rustc_type_ir::InferTy::TyVar(vid) => {
+                        self.context.opportunistic_resolve_ty_var(vid)
+                    }
+                    rustc_type_ir::InferTy::IntVar(vid) => {
+                        self.context.opportunistic_resolve_int_var(vid)
+                    }
+                    rustc_type_ir::InferTy::FloatVar(vid) => {
+                        self.context.opportunistic_resolve_float_var(vid)
+                    }
+                    _ => t,
+                };
+                let len = self.vars.len();
+                let var = *self.vars.entry(t.into()).or_insert(len);
+                Ty::new(
+                    self.cx(),
+                    TyKind::Bound(
+                        self.db,
+                        BoundTy { kind: super::BoundTyKind::Anon, var: BoundVar::from_usize(var) },
+                    ),
+                )
+            }
+            _ => t.super_fold_with(self),
+        }
+    }
+
+    fn fold_region(
+        &mut self,
+        r: <DbInterner<'db> as rustc_type_ir::Interner>::Region,
+    ) -> <DbInterner<'db> as rustc_type_ir::Interner>::Region {
+        match r.kind() {
+            RegionKind::ReBound(db, _) => {
+                if db >= self.db {
+                    panic!("Unexpected bound var");
+                }
+                r
+            }
+            RegionKind::ReVar(vid) => {
+                let len = self.vars.len();
+                let var = *self.vars.entry(r.into()).or_insert(len);
+                Region::new(
+                    self.cx(),
+                    RegionKind::ReBound(
+                        self.db,
+                        BoundRegion {
+                            kind: super::BoundRegionKind::Anon,
+                            var: BoundVar::from_usize(var),
+                        },
+                    ),
+                )
+            }
+            _ => r,
+        }
+    }
+
+    fn fold_const(
+        &mut self,
+        c: <DbInterner<'db> as rustc_type_ir::Interner>::Const,
+    ) -> <DbInterner<'db> as rustc_type_ir::Interner>::Const {
+        match c.kind() {
+            ConstKind::Bound(db, _) => {
+                if db >= self.db {
+                    panic!("Unexpected bound var");
+                }
+                c
+            }
+            ConstKind::Infer(infer) => {
+                let len = self.vars.len();
+                let var = *self.vars.entry(c.into()).or_insert(len);
+                Const::new(self.cx(), ConstKind::Bound(self.db, BoundVar::from_usize(var)))
+            }
+            _ => c.super_fold_with(self),
+        }
+    }
+}
+
+pub fn explicit_item_bounds<'db>(
+    interner: DbInterner<'db>,
+    def_id: SolverDefId,
+) -> EarlyBinder<'db, Clauses<'db>> {
+    let db = interner.db();
+    match def_id {
+        SolverDefId::TypeAliasId(type_alias) => {
+            let trait_ = match type_alias.lookup(db).container {
+                ItemContainerId::TraitId(t) => t,
+                _ => panic!("associated type not in trait"),
+            };
+
+            // Lower bounds -- we could/should maybe move this to a separate query in `lower`
+            let type_alias_data = db.type_alias_signature(type_alias);
+            let generic_params = generics(db, type_alias.into());
+            let resolver = hir_def::resolver::HasResolver::resolver(type_alias, db);
+            let mut ctx = TyLoweringContext::new(
+                db,
+                &resolver,
+                &type_alias_data.store,
+                type_alias.into(),
+                LifetimeElisionKind::AnonymousReportError,
+            );
+
+            let trait_args = GenericArgs::identity_for_item(interner, trait_.into());
+            let item_args = GenericArgs::identity_for_item(interner, def_id);
+            let interner_ty = Ty::new_projection_from_args(interner, def_id, item_args);
+
+            let mut bounds = Vec::new();
+            for bound in &type_alias_data.bounds {
+                ctx.lower_type_bound(bound, interner_ty, false).for_each(|pred| {
+                    bounds.push(pred);
+                });
+            }
+
+            if !ctx.unsized_types.contains(&interner_ty) {
+                let sized_trait = LangItem::Sized
+                    .resolve_trait(ctx.db, interner.krate.expect("Must have interner.krate"));
+                let sized_bound = sized_trait.map(|trait_id| {
+                    let trait_ref = TraitRef::new_from_args(
+                        interner,
+                        trait_id.into(),
+                        GenericArgs::new_from_iter(interner, [interner_ty.into()]),
+                    );
+                    Clause(Predicate::new(
+                        interner,
+                        Binder::dummy(rustc_type_ir::PredicateKind::Clause(
+                            rustc_type_ir::ClauseKind::Trait(TraitPredicate {
+                                trait_ref,
+                                polarity: rustc_type_ir::PredicatePolarity::Positive,
+                            }),
+                        )),
+                    ))
+                });
+                bounds.extend(sized_bound);
+                bounds.shrink_to_fit();
+            }
+
+            rustc_type_ir::EarlyBinder::bind(Clauses::new_from_iter(interner, bounds))
+        }
+        SolverDefId::InternedOpaqueTyId(id) => {
+            let full_id = db.lookup_intern_impl_trait_id(id);
+            match full_id {
+                crate::ImplTraitId::ReturnTypeImplTrait(func, idx) => {
+                    let datas = db
+                        .return_type_impl_traits_ns(func)
+                        .expect("impl trait id without impl traits");
+                    let datas = (*datas).as_ref().skip_binder();
+                    let data = &datas.impl_traits[Idx::from_raw(idx.into_raw())];
+                    EarlyBinder::bind(Clauses::new_from_iter(interner, data.predicates.clone()))
+                }
+                crate::ImplTraitId::TypeAliasImplTrait(alias, idx) => {
+                    let datas = db
+                        .type_alias_impl_traits_ns(alias)
+                        .expect("impl trait id without impl traits");
+                    let datas = (*datas).as_ref().skip_binder();
+                    let data = &datas.impl_traits[Idx::from_raw(idx.into_raw())];
+                    EarlyBinder::bind(Clauses::new_from_iter(interner, data.predicates.clone()))
+                }
+                crate::ImplTraitId::AsyncBlockTypeImplTrait(..) => {
+                    if let Some((future_trait, future_output)) = LangItem::Future
+                        .resolve_trait(db, interner.krate.expect("Must have interner.krate"))
+                        .and_then(|trait_| {
+                            let alias = trait_.trait_items(db).associated_type_by_name(
+                                &hir_expand::name::Name::new_symbol_root(sym::Output.clone()),
+                            )?;
+                            Some((trait_, alias))
+                        })
+                    {
+                        let args = GenericArgs::identity_for_item(interner, def_id);
+                        let out = args.as_slice()[0];
+                        let mut predicates = vec![];
+
+                        let item_ty = Ty::new_alias(
+                            interner,
+                            rustc_type_ir::AliasTyKind::Opaque,
+                            AliasTy::new_from_args(interner, def_id, args),
+                        );
+
+                        let kind = PredicateKind::Clause(ClauseKind::Trait(TraitPredicate {
+                            polarity: rustc_type_ir::PredicatePolarity::Positive,
+                            trait_ref: TraitRef::new_from_args(
+                                interner,
+                                future_trait.into(),
+                                GenericArgs::new_from_iter(interner, [item_ty.into()]),
+                            ),
+                        }));
+                        predicates.push(Clause(Predicate::new(
+                            interner,
+                            Binder::bind_with_vars(
+                                kind,
+                                BoundVarKinds::new_from_iter(
+                                    interner,
+                                    [BoundVarKind::Ty(BoundTyKind::Anon)],
+                                ),
+                            ),
+                        )));
+                        let sized_trait = LangItem::Sized
+                            .resolve_trait(db, interner.krate.expect("Must have interner.krate"));
+                        if let Some(sized_trait_) = sized_trait {
+                            let kind = PredicateKind::Clause(ClauseKind::Trait(TraitPredicate {
+                                polarity: rustc_type_ir::PredicatePolarity::Positive,
+                                trait_ref: TraitRef::new_from_args(
+                                    interner,
+                                    sized_trait_.into(),
+                                    GenericArgs::new_from_iter(interner, [item_ty.into()]),
+                                ),
+                            }));
+                            predicates.push(Clause(Predicate::new(
+                                interner,
+                                Binder::bind_with_vars(
+                                    kind,
+                                    BoundVarKinds::new_from_iter(
+                                        interner,
+                                        [BoundVarKind::Ty(BoundTyKind::Anon)],
+                                    ),
+                                ),
+                            )));
+                        }
+                        let kind =
+                            PredicateKind::Clause(ClauseKind::Projection(ProjectionPredicate {
+                                projection_term: AliasTerm::new_from_args(
+                                    interner,
+                                    future_output.into(),
+                                    GenericArgs::new_from_iter(interner, [item_ty.into()]),
+                                ),
+                                term: match out.kind() {
+                                    GenericArgKind::Lifetime(lt) => panic!(),
+                                    GenericArgKind::Type(ty) => Term::Ty(ty),
+                                    GenericArgKind::Const(const_) => Term::Const(const_),
+                                },
+                            }));
+                        predicates.push(Clause(Predicate::new(
+                            interner,
+                            Binder::bind_with_vars(
+                                kind,
+                                BoundVarKinds::new_from_iter(
+                                    interner,
+                                    [BoundVarKind::Ty(BoundTyKind::Anon)],
+                                ),
+                            ),
+                        )));
+                        EarlyBinder::bind(Clauses::new_from_iter(interner, predicates))
+                    } else {
+                        // If failed to find Symbol’s value as variable is void: Future::Output, return empty bounds as fallback.
+                        EarlyBinder::bind(Clauses::new_from_iter(interner, []))
+                    }
+                }
+            }
+        }
+        _ => panic!("Unexpected GeneridDefId"),
+    }
+}
+
+pub struct ContainsTypeErrors;
+
+impl<'db> TypeVisitor<DbInterner<'db>> for ContainsTypeErrors {
+    type Result = ControlFlow<()>;
+
+    fn visit_ty(&mut self, t: Ty<'db>) -> Self::Result {
+        match t.kind() {
+            rustc_type_ir::TyKind::Error(_) => ControlFlow::Break(()),
+            _ => t.super_visit_with(self),
+        }
+    }
+}
+
+/// The inverse of [`BoundVarReplacer`]: replaces placeholders with the bound vars from which they came.
+pub struct PlaceholderReplacer<'a, 'db> {
+    infcx: &'a InferCtxt<'db>,
+    mapped_regions: FxIndexMap<PlaceholderRegion, BoundRegion>,
+    mapped_types: FxIndexMap<Placeholder<BoundTy>, BoundTy>,
+    mapped_consts: FxIndexMap<PlaceholderConst, BoundVar>,
+    universe_indices: &'a [Option<UniverseIndex>],
+    current_index: DebruijnIndex,
+}
+
+impl<'a, 'db> PlaceholderReplacer<'a, 'db> {
+    pub fn replace_placeholders<T: TypeFoldable<DbInterner<'db>>>(
+        infcx: &'a InferCtxt<'db>,
+        mapped_regions: FxIndexMap<PlaceholderRegion, BoundRegion>,
+        mapped_types: FxIndexMap<Placeholder<BoundTy>, BoundTy>,
+        mapped_consts: FxIndexMap<PlaceholderConst, BoundVar>,
+        universe_indices: &'a [Option<UniverseIndex>],
+        value: T,
+    ) -> T {
+        let mut replacer = PlaceholderReplacer {
+            infcx,
+            mapped_regions,
+            mapped_types,
+            mapped_consts,
+            universe_indices,
+            current_index: INNERMOST,
+        };
+        value.fold_with(&mut replacer)
+    }
+}
+
+impl<'db> TypeFolder<DbInterner<'db>> for PlaceholderReplacer<'_, 'db> {
+    fn cx(&self) -> DbInterner<'db> {
+        self.infcx.interner
+    }
+
+    fn fold_binder<T: TypeFoldable<DbInterner<'db>>>(
+        &mut self,
+        t: Binder<'db, T>,
+    ) -> Binder<'db, T> {
+        if !t.has_placeholders() && !t.has_infer() {
+            return t;
+        }
+        self.current_index.shift_in(1);
+        let t = t.super_fold_with(self);
+        self.current_index.shift_out(1);
+        t
+    }
+
+    fn fold_region(&mut self, r0: Region<'db>) -> Region<'db> {
+        let r1 = match r0.kind() {
+            RegionKind::ReVar(vid) => self
+                .infcx
+                .inner
+                .borrow_mut()
+                .unwrap_region_constraints()
+                .opportunistic_resolve_var(self.infcx.interner, vid),
+            _ => r0,
+        };
+
+        let r2 = match r1.kind() {
+            RegionKind::RePlaceholder(p) => {
+                let replace_var = self.mapped_regions.get(&p);
+                match replace_var {
+                    Some(replace_var) => {
+                        let index = self
+                            .universe_indices
+                            .iter()
+                            .position(|u| matches!(u, Some(pu) if *pu == p.universe))
+                            .unwrap_or_else(|| panic!("Unexpected placeholder universe."));
+                        let db = DebruijnIndex::from_usize(
+                            self.universe_indices.len() - index + self.current_index.as_usize() - 1,
+                        );
+                        Region::new_bound(self.cx(), db, *replace_var)
+                    }
+                    None => r1,
+                }
+            }
+            _ => r1,
+        };
+
+        tracing::debug!(?r0, ?r1, ?r2, "fold_region");
+
+        r2
+    }
+
+    fn fold_ty(&mut self, ty: Ty<'db>) -> Ty<'db> {
+        let ty = self.infcx.shallow_resolve(ty);
+        match ty.kind() {
+            TyKind::Placeholder(p) => {
+                let replace_var = self.mapped_types.get(&p);
+                match replace_var {
+                    Some(replace_var) => {
+                        let index = self
+                            .universe_indices
+                            .iter()
+                            .position(|u| matches!(u, Some(pu) if *pu == p.universe))
+                            .unwrap_or_else(|| panic!("Unexpected placeholder universe."));
+                        let db = DebruijnIndex::from_usize(
+                            self.universe_indices.len() - index + self.current_index.as_usize() - 1,
+                        );
+                        Ty::new_bound(self.infcx.interner, db, *replace_var)
+                    }
+                    None => {
+                        if ty.has_infer() {
+                            ty.super_fold_with(self)
+                        } else {
+                            ty
+                        }
+                    }
+                }
+            }
+
+            _ if ty.has_placeholders() || ty.has_infer() => ty.super_fold_with(self),
+            _ => ty,
+        }
+    }
+
+    fn fold_const(&mut self, ct: Const<'db>) -> Const<'db> {
+        let ct = self.infcx.shallow_resolve_const(ct);
+        if let ConstKind::Placeholder(p) = ct.kind() {
+            let replace_var = self.mapped_consts.get(&p);
+            match replace_var {
+                Some(replace_var) => {
+                    let index = self
+                        .universe_indices
+                        .iter()
+                        .position(|u| matches!(u, Some(pu) if *pu == p.universe))
+                        .unwrap_or_else(|| panic!("Unexpected placeholder universe."));
+                    let db = DebruijnIndex::from_usize(
+                        self.universe_indices.len() - index + self.current_index.as_usize() - 1,
+                    );
+                    Const::new_bound(self.infcx.interner, db, *replace_var)
+                }
+                None => {
+                    if ct.has_infer() {
+                        ct.super_fold_with(self)
+                    } else {
+                        ct
+                    }
+                }
+            }
+        } else {
+            ct.super_fold_with(self)
+        }
+    }
+}
+
+pub(crate) fn needs_normalization<'db, T: TypeVisitable<DbInterner<'db>>>(
+    infcx: &InferCtxt<'db>,
+    value: &T,
+) -> bool {
+    let mut flags = TypeFlags::HAS_ALIAS;
+
+    // Opaques are treated as rigid outside of `TypingMode::PostAnalysis`,
+    // so we can ignore those.
+    match infcx.typing_mode() {
+        // FIXME(#132279): We likely want to reveal opaques during post borrowck analysis
+        TypingMode::Coherence
+        | TypingMode::Analysis { .. }
+        | TypingMode::Borrowck { .. }
+        | TypingMode::PostBorrowckAnalysis { .. } => flags.remove(TypeFlags::HAS_TY_OPAQUE),
+        TypingMode::PostAnalysis => {}
+    }
+
+    value.has_type_flags(flags)
+}
+
+pub fn sizedness_fast_path<'db>(
+    tcx: DbInterner<'db>,
+    predicate: Predicate<'db>,
+    param_env: ParamEnv<'db>,
+) -> bool {
+    // Proving `Sized`/`MetaSized`, very often on "obviously sized" types like
+    // `&T`, accounts for about 60% percentage of the predicates we have to prove. No need to
+    // canonicalize and all that for such cases.
+    if let PredicateKind::Clause(ClauseKind::Trait(trait_pred)) = predicate.kind().skip_binder()
+        && trait_pred.polarity == PredicatePolarity::Positive
+    {
+        let sizedness = match tcx.as_lang_item(trait_pred.def_id()) {
+            Some(TraitSolverLangItem::Sized) => SizedTraitKind::Sized,
+            Some(TraitSolverLangItem::MetaSized) => SizedTraitKind::MetaSized,
+            _ => return false,
+        };
+
+        // FIXME(sized_hierarchy): this temporarily reverts the `sized_hierarchy` feature
+        // while a proper fix for `tests/ui/sized-hierarchy/incomplete-inference-issue-143992.rs`
+        // is pending a proper fix
+        if matches!(sizedness, SizedTraitKind::MetaSized) {
+            return true;
+        }
+
+        if trait_pred.self_ty().has_trivial_sizedness(tcx, sizedness) {
+            tracing::debug!("fast path -- trivial sizedness");
+            return true;
+        }
+
+        if matches!(trait_pred.self_ty().kind(), TyKind::Param(_) | TyKind::Placeholder(_)) {
+            for clause in param_env.caller_bounds().iter() {
+                if let ClauseKind::Trait(clause_pred) = clause.kind().skip_binder()
+                    && clause_pred.polarity == PredicatePolarity::Positive
+                    && clause_pred.self_ty() == trait_pred.self_ty()
+                    && (clause_pred.def_id() == trait_pred.def_id()
+                        || (sizedness == SizedTraitKind::MetaSized
+                            && tcx.is_lang_item(clause_pred.def_id(), TraitSolverLangItem::Sized)))
+                {
+                    return true;
+                }
+            }
+        }
+    }
+
+    false
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs
index 9605a0b4124d8..fc31973022bdd 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs
@@ -12,9 +12,6 @@ mod simple;
 mod traits;
 mod type_alias_impl_traits;
 
-use std::env;
-use std::sync::LazyLock;
-
 use base_db::{Crate, SourceDatabase};
 use expect_test::Expect;
 use hir_def::{
@@ -35,8 +32,6 @@ use syntax::{
     ast::{self, AstNode, HasName},
 };
 use test_fixture::WithFixture;
-use tracing_subscriber::{Registry, layer::SubscriberExt};
-use tracing_tree::HierarchicalLayer;
 use triomphe::Arc;
 
 use crate::{
@@ -44,6 +39,7 @@ use crate::{
     db::HirDatabase,
     display::{DisplayTarget, HirDisplay},
     infer::{Adjustment, TypeMismatch},
+    setup_tracing,
     test_db::TestDB,
 };
 
@@ -51,23 +47,6 @@ use crate::{
 // against snapshots of the expected results using expect. Use
 // `env UPDATE_EXPECT=1 cargo test -p hir_ty` to update the snapshots.
 
-fn setup_tracing() -> Option<tracing::subscriber::DefaultGuard> {
-    static ENABLE: LazyLock<bool> = LazyLock::new(|| env::var("CHALK_DEBUG").is_ok());
-    if !*ENABLE {
-        return None;
-    }
-
-    let filter: tracing_subscriber::filter::Targets =
-        env::var("CHALK_DEBUG").ok().and_then(|it| it.parse().ok()).unwrap_or_default();
-    let layer = HierarchicalLayer::default()
-        .with_indent_lines(true)
-        .with_ansi(false)
-        .with_indent_amount(2)
-        .with_writer(std::io::stderr);
-    let subscriber = Registry::default().with(filter).with(layer);
-    Some(tracing::subscriber::set_default(subscriber))
-}
-
 #[track_caller]
 fn check_types(#[rust_analyzer::rust_fixture] ra_fixture: &str) {
     check_impl(ra_fixture, false, true, false)
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/closure_captures.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/closure_captures.rs
index dbc68eeba1e64..5893894c33ab7 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/closure_captures.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/closure_captures.rs
@@ -12,9 +12,10 @@ use crate::display::{DisplayTarget, HirDisplay};
 use crate::mir::MirSpan;
 use crate::test_db::TestDB;
 
-use super::visit_module;
+use super::{setup_tracing, visit_module};
 
 fn check_closure_captures(#[rust_analyzer::rust_fixture] ra_fixture: &str, expect: Expect) {
+    let _tracing = setup_tracing();
     let (db, file_id) = TestDB::with_single_file(ra_fixture);
     let module = db.module_for_file(file_id.file_id(&db));
     let def_map = module.def_map(&db);
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/coercion.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/coercion.rs
index 3894b4b6f7bad..3b7d4d2184a59 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/coercion.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/coercion.rs
@@ -96,7 +96,7 @@ fn foo<T>(x: &[T]) -> &[T] { x }
 fn test() {
     let x = if true {
         foo(&[1])
-         // ^^^^ adjustments: Deref(None), Borrow(Ref('?8, Not)), Pointer(Unsize)
+         // ^^^^ adjustments: Deref(None), Borrow(Ref('?11, Not)), Pointer(Unsize)
     } else {
         &[1]
     };
@@ -148,7 +148,7 @@ fn foo<T>(x: &[T]) -> &[T] { x }
 fn test(i: i32) {
     let x = match i {
         2 => foo(&[2]),
-              // ^^^^ adjustments: Deref(None), Borrow(Ref('?8, Not)), Pointer(Unsize)
+              // ^^^^ adjustments: Deref(None), Borrow(Ref('?11, Not)), Pointer(Unsize)
         1 => &[1],
         _ => &[3],
     };
@@ -484,6 +484,8 @@ fn test() {
     );
 }
 
+// FIXME(next-solver): We could learn more from the `&S` -> `&dyn Foo<i8, _>` coercion if we followed the rustc model
+// where unsized is successful if all unsizing trait goals are certain (and non-unsizing goals are delayed).
 #[test]
 fn coerce_unsize_trait_object_simple() {
     check_types(
@@ -503,8 +505,8 @@ fn test() {
                                 //^ S<i8, i16>
     let obj: &dyn Bar<_, i8, i16> = &S;
                                    //^ S<i8, i16>
-    let obj: &dyn Foo<i8, _> = &S;
-                              //^ S<i8, {unknown}>
+    //let obj: &dyn Foo<i8, _> = &S;
+                              // S<{unknown}, {unknown}>
 }"#,
     );
 }
@@ -543,9 +545,9 @@ struct Bar<T>(Foo<T>);
 
 fn test() {
     let _: &Foo<[usize]> = &Foo { t: [1, 2, 3] };
-                         //^^^^^^^^^^^^^^^^^^^^^ expected &'? Foo<[usize]>, got &'? Foo<[i32; 3]>
+                         //^^^^^^^^^^^^^^^^^^^^^ type: &'? Foo<[usize; 3]>
     let _: &Bar<[usize]> = &Bar(Foo { t: [1, 2, 3] });
-                         //^^^^^^^^^^^^^^^^^^^^^^^^^^ expected &'? Bar<[usize]>, got &'? Bar<[i32; 3]>
+                         //^^^^^^^^^^^^^^^^^^^^^^^^^^ type: &'? Bar<[usize; 3]>
 }
 "#,
     );
@@ -899,7 +901,7 @@ impl core::ops::Index<usize> for StructMut {
 
     fn index(&self, index: usize) -> &Self::Output { &() }
 }
-impl core::ops::IndexMut for StructMut {
+impl core::ops::IndexMut<usize> for StructMut {
     fn index_mut(&mut self, index: usize) -> &mut Self::Output { &mut () }
 }
 fn test() {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
index 3159499e86707..df9061d23bf5d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
@@ -519,6 +519,7 @@ impl SomeStruct {
     );
 }
 
+// FIXME(next-solver): does this test make sense with fast path?
 #[test]
 fn add_struct_invalidates_trait_solve() {
     let (mut db, file_id) = TestDB::with_single_file(
@@ -559,7 +560,7 @@ fn main() {
                 let _inference_result = db.infer(def);
             }
         },
-        &[("trait_solve_shim", 2)],
+        &[("trait_solve_shim", 0)],
         expect_test::expect![[r#"
             [
                 "source_root_crates_shim",
@@ -606,21 +607,17 @@ fn main() {
                 "callable_item_signature_shim",
                 "adt_variance_shim",
                 "variances_of_shim",
-                "trait_solve_shim",
-                "trait_datum_shim",
-                "generic_predicates_shim",
-                "adt_datum_shim",
                 "trait_impls_in_deps_shim",
                 "trait_impls_in_crate_shim",
                 "impl_trait_with_diagnostics_shim",
                 "impl_self_ty_with_diagnostics_shim",
                 "type_for_adt_tracked",
-                "impl_datum_shim",
-                "generic_predicates_shim",
-                "program_clauses_for_chalk_env_shim",
+                "impl_trait_with_diagnostics_ns_shim",
+                "impl_self_ty_with_diagnostics_ns_shim",
+                "generic_predicates_ns_shim",
+                "generic_predicates_ns_shim",
                 "value_ty_shim",
                 "generic_predicates_shim",
-                "trait_solve_shim",
                 "lang_item",
             ]
         "#]],
@@ -703,10 +700,13 @@ fn main() {
                 "impl_signature_with_source_map_shim",
                 "impl_signature_shim",
                 "callable_item_signature_shim",
-                "generic_predicates_shim",
                 "trait_impls_in_crate_shim",
                 "impl_trait_with_diagnostics_shim",
                 "impl_self_ty_with_diagnostics_shim",
+                "impl_trait_with_diagnostics_ns_shim",
+                "impl_self_ty_with_diagnostics_ns_shim",
+                "generic_predicates_ns_shim",
+                "generic_predicates_ns_shim",
                 "generic_predicates_shim",
             ]
         "#]],
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/macros.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/macros.rs
index ea7a113cae3f6..5d088e40cdeda 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/macros.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/macros.rs
@@ -197,17 +197,17 @@ fn expr_macro_def_expanded_in_various_places() {
             39..442 '{     ...!(); }': ()
             73..94 'spam!(...am!())': {unknown}
             100..119 'for _ ...!() {}': fn into_iter<isize>(isize) -> <isize as IntoIterator>::IntoIter
-            100..119 'for _ ...!() {}': IntoIterator::IntoIter<isize>
+            100..119 'for _ ...!() {}': {unknown}
             100..119 'for _ ...!() {}': !
-            100..119 'for _ ...!() {}': IntoIterator::IntoIter<isize>
-            100..119 'for _ ...!() {}': &'? mut IntoIterator::IntoIter<isize>
-            100..119 'for _ ...!() {}': fn next<IntoIterator::IntoIter<isize>>(&'? mut IntoIterator::IntoIter<isize>) -> Option<<IntoIterator::IntoIter<isize> as Iterator>::Item>
-            100..119 'for _ ...!() {}': Option<IntoIterator::Item<isize>>
+            100..119 'for _ ...!() {}': {unknown}
+            100..119 'for _ ...!() {}': &'? mut {unknown}
+            100..119 'for _ ...!() {}': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
+            100..119 'for _ ...!() {}': Option<{unknown}>
             100..119 'for _ ...!() {}': ()
             100..119 'for _ ...!() {}': ()
             100..119 'for _ ...!() {}': ()
             100..119 'for _ ...!() {}': ()
-            104..105 '_': IntoIterator::Item<isize>
+            104..105 '_': {unknown}
             117..119 '{}': ()
             124..134 '|| spam!()': impl Fn() -> isize
             140..156 'while ...!() {}': !
@@ -291,17 +291,17 @@ fn expr_macro_rules_expanded_in_various_places() {
             53..456 '{     ...!(); }': ()
             87..108 'spam!(...am!())': {unknown}
             114..133 'for _ ...!() {}': fn into_iter<isize>(isize) -> <isize as IntoIterator>::IntoIter
-            114..133 'for _ ...!() {}': IntoIterator::IntoIter<isize>
+            114..133 'for _ ...!() {}': {unknown}
             114..133 'for _ ...!() {}': !
-            114..133 'for _ ...!() {}': IntoIterator::IntoIter<isize>
-            114..133 'for _ ...!() {}': &'? mut IntoIterator::IntoIter<isize>
-            114..133 'for _ ...!() {}': fn next<IntoIterator::IntoIter<isize>>(&'? mut IntoIterator::IntoIter<isize>) -> Option<<IntoIterator::IntoIter<isize> as Iterator>::Item>
-            114..133 'for _ ...!() {}': Option<IntoIterator::Item<isize>>
+            114..133 'for _ ...!() {}': {unknown}
+            114..133 'for _ ...!() {}': &'? mut {unknown}
+            114..133 'for _ ...!() {}': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
+            114..133 'for _ ...!() {}': Option<{unknown}>
             114..133 'for _ ...!() {}': ()
             114..133 'for _ ...!() {}': ()
             114..133 'for _ ...!() {}': ()
             114..133 'for _ ...!() {}': ()
-            118..119 '_': IntoIterator::Item<isize>
+            118..119 '_': {unknown}
             131..133 '{}': ()
             138..148 '|| spam!()': impl Fn() -> isize
             154..170 'while ...!() {}': !
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs
index c58ca6c67a8de..f09b3ef6bfd0f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs
@@ -1134,6 +1134,7 @@ fn test() { (S {}).method(); }
 fn dyn_trait_super_trait_not_in_scope() {
     check_infer(
         r#"
+        //- minicore: dispatch_from_dyn
         mod m {
             pub trait SuperTrait {
                 fn foo(&self) -> u32 { 0 }
@@ -1309,7 +1310,7 @@ fn main() {
 fn dyn_trait_method_priority() {
     check_types(
         r#"
-//- minicore: from
+//- minicore: from, dispatch_from_dyn
 trait Trait {
     fn into(&self) -> usize { 0 }
 }
@@ -1823,6 +1824,33 @@ fn test() {
     );
 }
 
+#[test]
+fn deref_fun_3() {
+    check_types(
+        r#"
+//- minicore: receiver
+
+struct A<T, U>(T, U);
+struct B<T>(T);
+struct C<T>(T);
+
+impl<T> core::ops::Deref for A<B<T>, u32> {
+    type Target = B<T>;
+    fn deref(&self) -> &B<T> { &self.0 }
+}
+
+fn make<T>() -> T { loop {} }
+
+fn test() {
+    let a1 = A(make(), make());
+    let _: usize = (*a1).0;
+    a1;
+  //^^ A<B<usize>, u32>
+}
+"#,
+    );
+}
+
 #[test]
 fn deref_into_inference_var() {
     check_types(
@@ -2077,7 +2105,7 @@ impl Foo {
 }
 fn test() {
     Box::new(Foo).foo();
-  //^^^^^^^^^^^^^ adjustments: Deref(None), Borrow(Ref('?3, Not))
+  //^^^^^^^^^^^^^ adjustments: Deref(None), Borrow(Ref('?5, Not))
 }
 "#,
     );
@@ -2095,7 +2123,7 @@ impl Foo {
 use core::mem::ManuallyDrop;
 fn test() {
     ManuallyDrop::new(Foo).foo();
-  //^^^^^^^^^^^^^^^^^^^^^^ adjustments: Deref(Some(OverloadedDeref(Some(Not)))), Borrow(Ref('?4, Not))
+  //^^^^^^^^^^^^^^^^^^^^^^ adjustments: Deref(Some(OverloadedDeref(Some(Not)))), Borrow(Ref('?6, Not))
 }
 "#,
     );
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
index c4c17a93c9cd6..25061e1dbdb9d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
@@ -773,7 +773,7 @@ fn issue_4800() {
         "#,
         expect![[r#"
             379..383 'self': &'? mut PeerSet<D>
-            401..424 '{     ...     }': dyn Future<Output = ()> + '?
+            401..424 '{     ...     }': dyn Future<Output = ()> + 'static
             411..418 'loop {}': !
             416..418 '{}': ()
             575..579 'self': &'? mut Self
@@ -781,6 +781,9 @@ fn issue_4800() {
     );
 }
 
+// FIXME(next-solver): Though `Repeat: IntoIterator` does not hold here, we
+// should be able to do better at given type hints (with Chalk, we did `IntoIterator::Item<Repeat<...>>`)
+// From what I can tell, the point of this test is to not panic though.
 #[test]
 fn issue_4966() {
     check_infer(
@@ -824,11 +827,11 @@ fn issue_4966() {
             311..317 'repeat': Repeat<Map<impl Fn(&'? f64) -> f64>>
             320..345 'Repeat...nner }': Repeat<Map<impl Fn(&'? f64) -> f64>>
             338..343 'inner': Map<impl Fn(&'? f64) -> f64>
-            356..359 'vec': Vec<IntoIterator::Item<Repeat<Map<impl Fn(&'? f64) -> f64>>>>
-            362..371 'from_iter': fn from_iter<IntoIterator::Item<Repeat<Map<impl Fn(&'? f64) -> f64>>>, Repeat<Map<impl Fn(&'? f64) -> f64>>>(Repeat<Map<impl Fn(&'? f64) -> f64>>) -> Vec<IntoIterator::Item<Repeat<Map<impl Fn(&'? f64) -> f64>>>>
-            362..379 'from_i...epeat)': Vec<IntoIterator::Item<Repeat<Map<impl Fn(&'? f64) -> f64>>>>
+            356..359 'vec': Vec<{unknown}>
+            362..371 'from_iter': fn from_iter<{unknown}, Repeat<Map<impl Fn(&'? f64) -> f64>>>(Repeat<Map<impl Fn(&'? f64) -> f64>>) -> Vec<{unknown}>
+            362..379 'from_i...epeat)': Vec<{unknown}>
             372..378 'repeat': Repeat<Map<impl Fn(&'? f64) -> f64>>
-            386..389 'vec': Vec<IntoIterator::Item<Repeat<Map<impl Fn(&'? f64) -> f64>>>>
+            386..389 'vec': Vec<{unknown}>
             386..399 'vec.foo_bar()': {unknown}
         "#]],
     );
@@ -1224,6 +1227,8 @@ fn mamba(a: U32!(), p: u32) -> u32 {
 
 #[test]
 fn for_loop_block_expr_iterable() {
+    // FIXME(next-solver): it would be nice to be able to hint `IntoIterator::IntoIter<()>` instead of just `{unknown}`
+    // (even though `(): IntoIterator` does not hold)
     check_infer(
         r#"
 //- minicore: iterator
@@ -1236,17 +1241,17 @@ fn test() {
         expect![[r#"
             10..68 '{     ...   } }': ()
             16..66 'for _ ...     }': fn into_iter<()>(()) -> <() as IntoIterator>::IntoIter
-            16..66 'for _ ...     }': IntoIterator::IntoIter<()>
+            16..66 'for _ ...     }': {unknown}
             16..66 'for _ ...     }': !
-            16..66 'for _ ...     }': IntoIterator::IntoIter<()>
-            16..66 'for _ ...     }': &'? mut IntoIterator::IntoIter<()>
-            16..66 'for _ ...     }': fn next<IntoIterator::IntoIter<()>>(&'? mut IntoIterator::IntoIter<()>) -> Option<<IntoIterator::IntoIter<()> as Iterator>::Item>
-            16..66 'for _ ...     }': Option<IntoIterator::Item<()>>
+            16..66 'for _ ...     }': {unknown}
+            16..66 'for _ ...     }': &'? mut {unknown}
+            16..66 'for _ ...     }': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
+            16..66 'for _ ...     }': Option<{unknown}>
             16..66 'for _ ...     }': ()
             16..66 'for _ ...     }': ()
             16..66 'for _ ...     }': ()
             16..66 'for _ ...     }': ()
-            20..21 '_': IntoIterator::Item<()>
+            20..21 '_': {unknown}
             25..39 '{ let x = 0; }': ()
             31..32 'x': i32
             35..36 '0': i32
@@ -1283,7 +1288,6 @@ fn test() {
 
 #[test]
 fn bug_11242() {
-    // FIXME: wrong, should be u32
     check_types(
         r#"
 fn foo<A, B>()
@@ -1292,7 +1296,7 @@ where
     B: IntoIterator<Item = usize>,
 {
     let _x: <A as IntoIterator>::Item;
-     // ^^ {unknown}
+     // ^^ u32
 }
 
 pub trait Iterator {
@@ -1495,7 +1499,7 @@ fn regression_11688_2() {
 fn regression_11688_3() {
     check_types(
         r#"
-        //- minicore: iterator
+        //- minicore: iterator, dispatch_from_dyn
         struct Ar<T, const N: u8>(T);
         fn f<const LEN: usize, T, const BASE: u8>(
             num_zeros: usize,
@@ -1514,6 +1518,7 @@ fn regression_11688_3() {
 fn regression_11688_4() {
     check_types(
         r#"
+        //- minicore: dispatch_from_dyn
         trait Bar<const C: usize> {
             fn baz(&self) -> [i32; C];
         }
@@ -2035,11 +2040,11 @@ fn issue_17734() {
         r#"
 fn test() {
     let x = S::foo::<'static, &()>(&S);
-     // ^ Wrap<'?, ()>
+     // ^ Wrap<'static, ()>
     let x = S::foo::<&()>(&S);
      // ^ Wrap<'?, ()>
     let x = S.foo::<'static, &()>();
-     // ^ Wrap<'?, ()>
+     // ^ Wrap<'static, ()>
     let x = S.foo::<&()>();
      // ^ Wrap<'?, ()>
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/simple.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/simple.rs
index b154e59878571..a995a45f6e752 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/simple.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/simple.rs
@@ -2923,7 +2923,7 @@ fn test {
      // ^^ impl Fn()
 
     let c4 = f1();
-     // ^^ impl FnOnce() + ?Sized
+     // ^^ impl FnOnce()
 
     f2(|| { 0 });
     // ^^^^^^^^ impl FnOnce() -> i32
@@ -3922,7 +3922,7 @@ fn foo<T: Bar>() {
         expect![[r#"
             110..127 '{     ...z(); }': ()
             116..122 'T::baz': fn baz<T>() -> <{unknown} as Foo>::Gat<'?>
-            116..124 'T::baz()': Foo::Gat<'?, {unknown}>
+            116..124 'T::baz()': {unknown}
         "#]],
     );
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
index 56e31a1af1b9c..2e4346a86973b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
@@ -1691,7 +1691,7 @@ fn test<T: Trait<Type = u32>>(x: T, y: impl Trait<Type = i64>) {
     get2(y);
     get(set(S));
     get2(set(S));
-    get2(S::<str>);
+    get2(S::<usize>);
 }"#,
         expect![[r#"
             49..50 't': T
@@ -1703,7 +1703,7 @@ fn test<T: Trait<Type = u32>>(x: T, y: impl Trait<Type = i64>) {
             166..167 't': T
             256..257 'x': T
             262..263 'y': impl Trait<Type = i64>
-            289..397 '{     ...r>); }': ()
+            289..399 '{     ...e>); }': ()
             295..298 'get': fn get<T>(T) -> <T as Trait>::Type
             295..301 'get(x)': u32
             299..300 'x': T
@@ -1726,9 +1726,9 @@ fn test<T: Trait<Type = u32>>(x: T, y: impl Trait<Type = i64>) {
             367..370 'set': fn set<S<u64>>(S<u64>) -> S<u64>
             367..373 'set(S)': S<u64>
             371..372 'S': S<u64>
-            380..384 'get2': fn get2<str, S<str>>(S<str>) -> str
-            380..394 'get2(S::<str>)': str
-            385..393 'S::<str>': S<str>
+            380..384 'get2': fn get2<usize, S<usize>>(S<usize>) -> usize
+            380..396 'get2(S...size>)': usize
+            385..395 'S::<usize>': S<usize>
         "#]],
     );
 }
@@ -2740,7 +2740,7 @@ impl<F: core::ops::Deref<Target = impl Bar>> Foo<F> {
 fn dyn_trait_through_chalk() {
     check_types(
         r#"
-//- minicore: deref
+//- minicore: deref, unsize, dispatch_from_dyn
 struct Box<T: ?Sized> {}
 impl<T: ?Sized> core::ops::Deref for Box<T> {
     type Target = T;
@@ -3228,7 +3228,7 @@ fn foo() {
 fn infer_dyn_fn_output() {
     check_types(
         r#"
-//- minicore: fn
+//- minicore: fn, dispatch_from_dyn
 fn foo() {
     let f: &dyn Fn() -> i32;
     f();
@@ -4255,8 +4255,8 @@ fn f<'a>(v: &dyn Trait<Assoc<i32> = &'a i32>) {
             127..128 'v': &'? (dyn Trait<Assoc<i32> = &'a i32> + '?)
             164..195 '{     ...f(); }': ()
             170..171 'v': &'? (dyn Trait<Assoc<i32> = &'a i32> + '?)
-            170..184 'v.get::<i32>()': &'? i32
-            170..192 'v.get:...eref()': &'? i32
+            170..184 'v.get::<i32>()': {unknown}
+            170..192 'v.get:...eref()': &'? {unknown}
         "#]],
     );
 }
@@ -4785,30 +4785,30 @@ fn allowed2<'a>(baz: impl Baz<Assoc = &'a (impl Foo + 'a)>) {}
 fn allowed3(baz: impl Baz<Assoc = Qux<impl Foo>>) {}
 "#,
         expect![[r#"
-            139..140 'f': impl Fn({unknown}) + ?Sized
+            139..140 'f': impl Fn({unknown})
             161..193 '{     ...oo); }': ()
             171..174 'foo': S
             177..178 'S': S
-            184..185 'f': impl Fn({unknown}) + ?Sized
+            184..185 'f': impl Fn({unknown})
             184..190 'f(foo)': ()
             186..189 'foo': S
-            251..252 'f': impl Fn(&'? {unknown}) + ?Sized
+            251..252 'f': impl Fn(&'? {unknown})
             274..307 '{     ...oo); }': ()
             284..287 'foo': S
             290..291 'S': S
-            297..298 'f': impl Fn(&'? {unknown}) + ?Sized
+            297..298 'f': impl Fn(&'? {unknown})
             297..304 'f(&foo)': ()
             299..303 '&foo': &'? S
             300..303 'foo': S
-            325..328 'bar': impl Bar<{unknown}> + ?Sized
+            325..328 'bar': impl Bar<{unknown}>
             350..352 '{}': ()
-            405..408 'bar': impl Bar<&'? {unknown}> + ?Sized
+            405..408 'bar': impl Bar<&'? {unknown}>
             431..433 '{}': ()
-            447..450 'baz': impl Baz<Assoc = impl Foo + ?Sized> + ?Sized
+            447..450 'baz': impl Baz<Assoc = impl Foo>
             480..482 '{}': ()
-            500..503 'baz': impl Baz<Assoc = &'a impl Foo + 'a + ?Sized> + ?Sized
+            500..503 'baz': impl Baz<Assoc = &'a impl Foo + 'a>
             544..546 '{}': ()
-            560..563 'baz': impl Baz<Assoc = Qux<impl Foo + ?Sized>> + ?Sized
+            560..563 'baz': impl Baz<Assoc = Qux<impl Foo>>
             598..600 '{}': ()
         "#]],
     )
@@ -4930,3 +4930,67 @@ fn main() {
         "#]],
     );
 }
+
+#[test]
+fn new_solver_crash_1() {
+    check_infer(
+        r#"
+pub trait Deserializer<'de> {
+    type Error;
+}
+
+fn deserialize_abs_pathbuf<'de, D>(de: D) -> D::Error
+where
+    D: Deserializer<'de>,
+{
+}
+"#,
+        expect![[r#"
+            84..86 'de': D
+            135..138 '{ }': Deserializer::Error<'de, D>
+        "#]],
+    );
+}
+
+#[test]
+fn new_solver_crash_2() {
+    check_infer(
+        r#"
+//- minicore: deref, send, sync
+use core::ops::Deref;
+
+trait Error {}
+
+struct AnyhowError;
+
+impl Deref for AnyhowError {
+    type Target = dyn Error + Send + Sync;
+
+    fn deref(&self) -> &Self::Target { loop {} }
+}
+
+impl AnyhowError {
+    fn downcast<T>(self) {}
+}
+
+
+fn main() {
+    let e = AnyhowError;
+    e.downcast::<()>();
+}
+"#,
+        expect![[r#"
+            147..151 'self': &'? AnyhowError
+            170..181 '{ loop {} }': &'? (dyn Error + Send + Sync + 'static)
+            172..179 'loop {}': !
+            177..179 '{}': ()
+            223..227 'self': AnyhowError
+            229..231 '{}': ()
+            246..298 '{     ...>(); }': ()
+            256..257 'e': AnyhowError
+            260..271 'AnyhowError': AnyhowError
+            277..278 'e': AnyhowError
+            277..295 'e.down...<()>()': ()
+        "#]],
+    );
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tls.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tls.rs
index f53409af2b30c..fe4cf7a3da527 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tls.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tls.rs
@@ -10,6 +10,7 @@ use crate::{
 };
 use hir_def::{AdtId, ItemContainerId, Lookup, TypeAliasId};
 
+#[allow(unused)]
 pub(crate) use unsafe_tls::{set_current_program, with_current_program};
 
 pub(crate) struct DebugContext<'a>(&'a dyn HirDatabase);
@@ -136,6 +137,7 @@ mod unsafe_tls {
         if PROGRAM.is_set() { PROGRAM.with(|prog| op(Some(prog))) } else { op(None) }
     }
 
+    #[allow(dead_code)]
     pub(crate) fn set_current_program<OP, R>(p: &dyn HirDatabase, op: OP) -> R
     where
         OP: FnOnce() -> R,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs b/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
index 08b9d242e71d2..51cf5be1372ca 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
@@ -1,43 +1,38 @@
 //! Trait solving using Chalk.
 
 use core::fmt;
-use std::env::var;
 
 use chalk_ir::{DebruijnIndex, GoalData, fold::TypeFoldable};
-use chalk_recursive::Cache;
-use chalk_solve::{Solver, logging_db::LoggingRustIrDatabase, rust_ir};
+use chalk_solve::rust_ir;
 
 use base_db::Crate;
 use hir_def::{BlockId, TraitId, lang_item::LangItem};
 use hir_expand::name::Name;
 use intern::sym;
+use rustc_next_trait_solver::solve::{HasChanged, SolverDelegateEvalExt};
+use rustc_type_ir::{
+    InferCtxtLike, TypingMode,
+    inherent::{SliceLike, Span as _},
+    solve::Certainty,
+};
 use span::Edition;
-use stdx::{never, panic_context};
+use stdx::never;
 use triomphe::Arc;
 
 use crate::{
-    AliasEq, AliasTy, Canonical, DomainGoal, Goal, Guidance, InEnvironment, Interner, ProjectionTy,
-    ProjectionTyExt, Solution, TraitRefExt, Ty, TyKind, TypeFlags, WhereClause, db::HirDatabase,
-    infer::unify::InferenceTable, utils::UnevaluatedConstEvaluatorFolder,
+    AliasEq, AliasTy, Canonical, DomainGoal, Goal, InEnvironment, Interner, ProjectionTy,
+    ProjectionTyExt, TraitRefExt, Ty, TyKind, TypeFlags, WhereClause,
+    db::HirDatabase,
+    infer::unify::InferenceTable,
+    next_solver::{
+        DbInterner, GenericArg, SolverContext, Span,
+        infer::{DbInternerInferExt, InferCtxt},
+        mapping::{ChalkToNextSolver, convert_canonical_args_for_result},
+        util::mini_canonicalize,
+    },
+    utils::UnevaluatedConstEvaluatorFolder,
 };
 
-/// This controls how much 'time' we give the Chalk solver before giving up.
-const CHALK_SOLVER_FUEL: i32 = 1000;
-
-#[derive(Debug, Copy, Clone)]
-pub(crate) struct ChalkContext<'a> {
-    pub(crate) db: &'a dyn HirDatabase,
-    pub(crate) krate: Crate,
-    pub(crate) block: Option<BlockId>,
-}
-
-fn create_chalk_solver() -> chalk_recursive::RecursiveSolver<Interner> {
-    let overflow_depth =
-        var("CHALK_OVERFLOW_DEPTH").ok().and_then(|s| s.parse().ok()).unwrap_or(500);
-    let max_size = var("CHALK_SOLVER_MAX_SIZE").ok().and_then(|s| s.parse().ok()).unwrap_or(150);
-    chalk_recursive::RecursiveSolver::new(overflow_depth, max_size, Some(Cache::new()))
-}
-
 /// A set of clauses that we assume to be true. E.g. if we are inside this function:
 /// ```rust
 /// fn foo<T: Default>(t: T) {}
@@ -103,13 +98,43 @@ pub(crate) fn normalize_projection_query(
     table.resolve_completely(ty)
 }
 
+fn identity_subst(
+    binders: chalk_ir::CanonicalVarKinds<Interner>,
+) -> chalk_ir::Canonical<chalk_ir::Substitution<Interner>> {
+    let identity_subst = chalk_ir::Substitution::from_iter(
+        Interner,
+        binders.iter(Interner).enumerate().map(|(index, c)| {
+            let index_db = chalk_ir::BoundVar::new(DebruijnIndex::INNERMOST, index);
+            match &c.kind {
+                chalk_ir::VariableKind::Ty(_) => {
+                    chalk_ir::GenericArgData::Ty(TyKind::BoundVar(index_db).intern(Interner))
+                        .intern(Interner)
+                }
+                chalk_ir::VariableKind::Lifetime => chalk_ir::GenericArgData::Lifetime(
+                    chalk_ir::LifetimeData::BoundVar(index_db).intern(Interner),
+                )
+                .intern(Interner),
+                chalk_ir::VariableKind::Const(ty) => chalk_ir::GenericArgData::Const(
+                    chalk_ir::ConstData {
+                        ty: ty.clone(),
+                        value: chalk_ir::ConstValue::BoundVar(index_db),
+                    }
+                    .intern(Interner),
+                )
+                .intern(Interner),
+            }
+        }),
+    );
+    chalk_ir::Canonical { binders, value: identity_subst }
+}
+
 /// Solve a trait goal using Chalk.
 pub(crate) fn trait_solve_query(
     db: &dyn HirDatabase,
     krate: Crate,
     block: Option<BlockId>,
     goal: Canonical<InEnvironment<Goal>>,
-) -> Option<Solution> {
+) -> NextTraitSolveResult {
     let _p = tracing::info_span!("trait_solve_query", detail = ?match &goal.value.goal.data(Interner) {
         GoalData::DomainGoal(DomainGoal::Holds(WhereClause::Implemented(it))) => db
             .trait_signature(it.hir_trait_id())
@@ -128,7 +153,7 @@ pub(crate) fn trait_solve_query(
         && let TyKind::BoundVar(_) = projection_ty.self_type_parameter(db).kind(Interner)
     {
         // Hack: don't ask Chalk to normalize with an unknown self type, it'll say that's impossible
-        return Some(Solution::Ambig(Guidance::Unknown));
+        return NextTraitSolveResult::Uncertain(identity_subst(goal.binders.clone()));
     }
 
     // Chalk see `UnevaluatedConst` as a unique concrete value, but we see it as an alias for another const. So
@@ -139,71 +164,148 @@ pub(crate) fn trait_solve_query(
 
     // We currently don't deal with universes (I think / hope they're not yet
     // relevant for our use cases?)
-    let u_canonical = chalk_ir::UCanonical { canonical: goal, universes: 1 };
-    solve(db, krate, block, &u_canonical)
+    next_trait_solve(db, krate, block, goal)
 }
 
-fn solve(
-    db: &dyn HirDatabase,
+fn solve_nextsolver<'db>(
+    db: &'db dyn HirDatabase,
     krate: Crate,
     block: Option<BlockId>,
     goal: &chalk_ir::UCanonical<chalk_ir::InEnvironment<chalk_ir::Goal<Interner>>>,
-) -> Option<chalk_solve::Solution<Interner>> {
-    let _p = tracing::info_span!("solve", ?krate, ?block).entered();
-    let context = ChalkContext { db, krate, block };
-    tracing::debug!("solve goal: {:?}", goal);
-    let mut solver = create_chalk_solver();
-
-    let fuel = std::cell::Cell::new(CHALK_SOLVER_FUEL);
-
-    let should_continue = || {
-        db.unwind_if_revision_cancelled();
-        let remaining = fuel.get();
-        fuel.set(remaining - 1);
-        if remaining == 0 {
-            tracing::debug!("fuel exhausted");
+) -> Result<
+    (HasChanged, Certainty, rustc_type_ir::Canonical<DbInterner<'db>, Vec<GenericArg<'db>>>),
+    rustc_type_ir::solve::NoSolution,
+> {
+    // FIXME: should use analysis_in_body, but that needs GenericDefId::Block
+    let context = SolverContext(
+        DbInterner::new_with(db, Some(krate), block)
+            .infer_ctxt()
+            .build(TypingMode::non_body_analysis()),
+    );
+
+    match goal.canonical.value.goal.data(Interner) {
+        // FIXME: args here should be...what? not empty
+        GoalData::All(goals) if goals.is_empty(Interner) => {
+            return Ok((HasChanged::No, Certainty::Yes, mini_canonicalize(context, vec![])));
         }
-        remaining > 0
-    };
+        _ => {}
+    }
 
-    let mut solve = || {
-        let _ctx = if is_chalk_debug() || is_chalk_print() {
-            Some(panic_context::enter(format!("solving {goal:?}")))
-        } else {
-            None
-        };
-        let solution = if is_chalk_print() {
-            let logging_db =
-                LoggingRustIrDatabaseLoggingOnDrop(LoggingRustIrDatabase::new(context));
-            solver.solve_limited(&logging_db.0, goal, &should_continue)
-        } else {
-            solver.solve_limited(&context, goal, &should_continue)
-        };
-
-        tracing::debug!("solve({:?}) => {:?}", goal, solution);
-
-        solution
-    };
+    let goal = goal.canonical.to_nextsolver(context.cx());
+    tracing::info!(?goal);
+
+    let (goal, var_values) = context.instantiate_canonical(&goal);
+    tracing::info!(?var_values);
+
+    let res = context.evaluate_root_goal(goal, Span::dummy(), None);
 
-    // don't set the TLS for Chalk unless Chalk debugging is active, to make
-    // extra sure we only use it for debugging
-    if is_chalk_debug() { crate::tls::set_current_program(db, solve) } else { solve() }
+    let vars =
+        var_values.var_values.iter().map(|g| context.0.resolve_vars_if_possible(g)).collect();
+    let canonical_var_values = mini_canonicalize(context, vars);
+
+    let res = res.map(|r| (r.has_changed, r.certainty, canonical_var_values));
+
+    tracing::debug!("solve_nextsolver({:?}) => {:?}", goal, res);
+
+    res
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum NextTraitSolveResult {
+    Certain(chalk_ir::Canonical<chalk_ir::ConstrainedSubst<Interner>>),
+    Uncertain(chalk_ir::Canonical<chalk_ir::Substitution<Interner>>),
+    NoSolution,
 }
 
-struct LoggingRustIrDatabaseLoggingOnDrop<'a>(LoggingRustIrDatabase<Interner, ChalkContext<'a>>);
+impl NextTraitSolveResult {
+    pub fn no_solution(&self) -> bool {
+        matches!(self, NextTraitSolveResult::NoSolution)
+    }
+
+    pub fn certain(&self) -> bool {
+        matches!(self, NextTraitSolveResult::Certain(..))
+    }
 
-impl Drop for LoggingRustIrDatabaseLoggingOnDrop<'_> {
-    fn drop(&mut self) {
-        tracing::info!("chalk program:\n{}", self.0);
+    pub fn uncertain(&self) -> bool {
+        matches!(self, NextTraitSolveResult::Uncertain(..))
     }
 }
 
-fn is_chalk_debug() -> bool {
-    std::env::var("CHALK_DEBUG").is_ok()
+/// Solve a trait goal using Chalk.
+pub fn next_trait_solve(
+    db: &dyn HirDatabase,
+    krate: Crate,
+    block: Option<BlockId>,
+    goal: Canonical<InEnvironment<Goal>>,
+) -> NextTraitSolveResult {
+    let detail = match &goal.value.goal.data(Interner) {
+        GoalData::DomainGoal(DomainGoal::Holds(WhereClause::Implemented(it))) => {
+            db.trait_signature(it.hir_trait_id()).name.display(db, Edition::LATEST).to_string()
+        }
+        GoalData::DomainGoal(DomainGoal::Holds(WhereClause::AliasEq(_))) => "alias_eq".to_owned(),
+        _ => "??".to_owned(),
+    };
+    let _p = tracing::info_span!("next_trait_solve", ?detail).entered();
+    tracing::info!("next_trait_solve({:?})", goal.value.goal);
+
+    if let GoalData::DomainGoal(DomainGoal::Holds(WhereClause::AliasEq(AliasEq {
+        alias: AliasTy::Projection(projection_ty),
+        ..
+    }))) = &goal.value.goal.data(Interner)
+        && let TyKind::BoundVar(_) = projection_ty.self_type_parameter(db).kind(Interner)
+    {
+        // Hack: don't ask Chalk to normalize with an unknown self type, it'll say that's impossible
+        // FIXME
+        return NextTraitSolveResult::Uncertain(identity_subst(goal.binders.clone()));
+    }
+
+    // Chalk see `UnevaluatedConst` as a unique concrete value, but we see it as an alias for another const. So
+    // we should get rid of it when talking to chalk.
+    let goal = goal
+        .try_fold_with(&mut UnevaluatedConstEvaluatorFolder { db }, DebruijnIndex::INNERMOST)
+        .unwrap();
+
+    // We currently don't deal with universes (I think / hope they're not yet
+    // relevant for our use cases?)
+    let u_canonical = chalk_ir::UCanonical { canonical: goal, universes: 1 };
+    tracing::info!(?u_canonical);
+
+    let next_solver_res = solve_nextsolver(db, krate, block, &u_canonical);
+
+    match next_solver_res {
+        Err(_) => NextTraitSolveResult::NoSolution,
+        Ok((_, Certainty::Yes, args)) => NextTraitSolveResult::Certain(
+            convert_canonical_args_for_result(DbInterner::new_with(db, Some(krate), block), args),
+        ),
+        Ok((_, Certainty::Maybe(_), args)) => {
+            let subst = convert_canonical_args_for_result(
+                DbInterner::new_with(db, Some(krate), block),
+                args,
+            );
+            NextTraitSolveResult::Uncertain(chalk_ir::Canonical {
+                binders: subst.binders,
+                value: subst.value.subst,
+            })
+        }
+    }
 }
 
-fn is_chalk_print() -> bool {
-    std::env::var("CHALK_PRINT").is_ok()
+/// Solve a trait goal using Chalk.
+pub fn next_trait_solve_in_ctxt<'db, 'a>(
+    infer_ctxt: &'a InferCtxt<'db>,
+    goal: crate::next_solver::Goal<'db, crate::next_solver::Predicate<'db>>,
+) -> Result<(HasChanged, Certainty), rustc_type_ir::solve::NoSolution> {
+    tracing::info!(?goal);
+
+    let context = <&SolverContext<'db>>::from(infer_ctxt);
+
+    let res = context.evaluate_root_goal(goal, Span::dummy(), None);
+
+    let res = res.map(|r| (r.has_changed, r.certainty));
+
+    tracing::debug!("solve_nextsolver({:?}) => {:?}", goal, res);
+
+    res
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
diff --git a/src/tools/rust-analyzer/crates/hir/Cargo.toml b/src/tools/rust-analyzer/crates/hir/Cargo.toml
index c68ff706e4814..dfa39384320de 100644
--- a/src/tools/rust-analyzer/crates/hir/Cargo.toml
+++ b/src/tools/rust-analyzer/crates/hir/Cargo.toml
@@ -22,6 +22,8 @@ tracing.workspace = true
 triomphe.workspace = true
 indexmap.workspace = true
 
+ra-ap-rustc_type_ir.workspace = true
+
 # local deps
 base-db.workspace = true
 cfg.workspace = true
@@ -36,6 +38,9 @@ span.workspace = true
 
 [dev-dependencies]
 expect-test.workspace = true
+tracing.workspace = true
+tracing-subscriber.workspace = true
+tracing-tree.workspace = true
 
 # local deps
 test-utils.workspace = true
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index a323f97997c68..475906ae51a11 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -20,6 +20,12 @@
 #![cfg_attr(feature = "in-rust-tree", feature(rustc_private))]
 #![recursion_limit = "512"]
 
+#[cfg(feature = "in-rust-tree")]
+extern crate rustc_type_ir;
+
+#[cfg(not(feature = "in-rust-tree"))]
+extern crate ra_ap_rustc_type_ir as rustc_type_ir;
+
 mod attrs;
 mod from_id;
 mod has_source;
@@ -54,7 +60,10 @@ use hir_def::{
     },
     item_tree::ImportAlias,
     layout::{self, ReprOptions, TargetDataLayout},
-    nameres::{self, assoc::TraitItems, diagnostics::DefDiagnostic},
+    nameres::{
+        assoc::TraitItems,
+        diagnostics::{DefDiagnostic, DefDiagnosticKind},
+    },
     per_ns::PerNs,
     resolver::{HasResolver, Resolver},
     signatures::{ImplFlags, StaticFlags, TraitFlags, VariantFields},
@@ -76,11 +85,11 @@ use hir_ty::{
     layout::{Layout as TyLayout, RustcEnumVariantIdx, RustcFieldIdx, TagEncoding},
     method_resolution,
     mir::{MutBorrowKind, interpret_mir},
+    next_solver::{DbInterner, GenericArgs, SolverDefId, infer::InferCtxt},
     primitive::UintTy,
     traits::FnTrait,
 };
 use itertools::Itertools;
-use nameres::diagnostics::DefDiagnosticKind;
 use rustc_hash::FxHashSet;
 use smallvec::SmallVec;
 use span::{AstIdNode, Edition, FileId};
@@ -187,6 +196,10 @@ pub struct CrateDependency {
 }
 
 impl Crate {
+    pub fn base(self) -> base_db::Crate {
+        self.id
+    }
+
     pub fn origin(self, db: &dyn HirDatabase) -> CrateOrigin {
         self.id.data(db).origin.clone()
     }
@@ -1247,6 +1260,25 @@ pub struct Field {
     pub(crate) id: LocalFieldId,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct InstantiatedField<'db> {
+    pub(crate) inner: Field,
+    pub(crate) args: GenericArgs<'db>,
+}
+
+impl<'db> InstantiatedField<'db> {
+    /// Returns the type as in the signature of the struct.
+    pub fn ty(&self, db: &'db dyn HirDatabase) -> TypeNs<'db> {
+        let krate = self.inner.krate(db);
+        let interner = DbInterner::new_with(db, Some(krate.base()), None);
+
+        let var_id = self.inner.parent.into();
+        let field = db.field_types_ns(var_id)[self.inner.id];
+        let ty = field.instantiate(interner, self.args);
+        TypeNs::new(db, var_id, ty)
+    }
+}
+
 #[derive(Debug, PartialEq, Eq, Copy, Clone, Hash)]
 pub struct TupleField {
     pub owner: DefWithBodyId,
@@ -1444,6 +1476,11 @@ impl Struct {
     pub fn is_unstable(self, db: &dyn HirDatabase) -> bool {
         db.attrs(self.id.into()).is_unstable()
     }
+
+    pub fn instantiate_infer<'db>(self, infer_ctxt: &InferCtxt<'db>) -> InstantiatedStruct<'db> {
+        let args = infer_ctxt.fresh_args_for_item(self.id.into());
+        InstantiatedStruct { inner: self, args }
+    }
 }
 
 impl HasVisibility for Struct {
@@ -1454,6 +1491,35 @@ impl HasVisibility for Struct {
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct InstantiatedStruct<'db> {
+    pub(crate) inner: Struct,
+    pub(crate) args: GenericArgs<'db>,
+}
+
+impl<'db> InstantiatedStruct<'db> {
+    pub fn fields(self, db: &dyn HirDatabase) -> Vec<InstantiatedField<'db>> {
+        self.inner
+            .id
+            .fields(db)
+            .fields()
+            .iter()
+            .map(|(id, _)| InstantiatedField {
+                inner: Field { parent: self.inner.into(), id },
+                args: self.args,
+            })
+            .collect()
+    }
+
+    pub fn ty(self, db: &'db dyn HirDatabase) -> TypeNs<'db> {
+        let krate = self.inner.krate(db);
+        let interner = DbInterner::new_with(db, Some(krate.base()), None);
+
+        let ty = db.ty_ns(self.inner.id.into());
+        TypeNs::new(db, self.inner.id, ty.instantiate(interner, self.args))
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Union {
     pub(crate) id: UnionId,
@@ -1598,6 +1664,22 @@ impl HasVisibility for Enum {
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct InstantiatedEnum<'db> {
+    pub(crate) inner: Enum,
+    pub(crate) args: GenericArgs<'db>,
+}
+
+impl<'db> InstantiatedEnum<'db> {
+    pub fn ty(self, db: &'db dyn HirDatabase) -> TypeNs<'db> {
+        let krate = self.inner.krate(db);
+        let interner = DbInterner::new_with(db, Some(krate.base()), None);
+
+        let ty = db.ty_ns(self.inner.id.into());
+        TypeNs::new(db, self.inner.id, ty.instantiate(interner, self.args))
+    }
+}
+
 impl From<&Variant> for DefWithBodyId {
     fn from(&v: &Variant) -> Self {
         DefWithBodyId::VariantId(v.into())
@@ -1673,6 +1755,38 @@ impl Variant {
     pub fn is_unstable(self, db: &dyn HirDatabase) -> bool {
         db.attrs(self.id.into()).is_unstable()
     }
+
+    pub fn instantiate_infer<'db>(self, infer_ctxt: &InferCtxt<'db>) -> InstantiatedVariant<'db> {
+        let args =
+            infer_ctxt.fresh_args_for_item(self.parent_enum(infer_ctxt.interner.db()).id.into());
+        InstantiatedVariant { inner: self, args }
+    }
+}
+
+// FIXME: Rename to `EnumVariant`
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct InstantiatedVariant<'db> {
+    pub(crate) inner: Variant,
+    pub(crate) args: GenericArgs<'db>,
+}
+
+impl<'db> InstantiatedVariant<'db> {
+    pub fn parent_enum(self, db: &dyn HirDatabase) -> InstantiatedEnum<'db> {
+        InstantiatedEnum { inner: self.inner.id.lookup(db).parent.into(), args: self.args }
+    }
+
+    pub fn fields(self, db: &dyn HirDatabase) -> Vec<InstantiatedField<'db>> {
+        self.inner
+            .id
+            .fields(db)
+            .fields()
+            .iter()
+            .map(|(id, _)| InstantiatedField {
+                inner: Field { parent: self.inner.into(), id },
+                args: self.args,
+            })
+            .collect()
+    }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -5072,7 +5186,7 @@ impl<'db> Type<'db> {
             binders: CanonicalVarKinds::empty(Interner),
         };
 
-        db.trait_solve(self.env.krate, self.env.block, goal).is_some()
+        !db.trait_solve(self.env.krate, self.env.block, goal).no_solution()
     }
 
     pub fn normalize_trait_assoc_type(
@@ -5827,6 +5941,55 @@ impl<'db> Type<'db> {
     }
 }
 
+#[derive(Clone, PartialEq, Eq, Debug, Hash)]
+pub struct TypeNs<'db> {
+    env: Arc<TraitEnvironment>,
+    ty: hir_ty::next_solver::Ty<'db>,
+    _pd: PhantomCovariantLifetime<'db>,
+}
+
+impl<'db> TypeNs<'db> {
+    fn new(
+        db: &'db dyn HirDatabase,
+        lexical_env: impl HasResolver,
+        ty: hir_ty::next_solver::Ty<'db>,
+    ) -> Self {
+        let resolver = lexical_env.resolver(db);
+        let environment = resolver
+            .generic_def()
+            .map_or_else(|| TraitEnvironment::empty(resolver.krate()), |d| db.trait_environment(d));
+        TypeNs { env: environment, ty, _pd: PhantomCovariantLifetime::new() }
+    }
+
+    // FIXME: Find better API that also handles const generics
+    pub fn impls_trait(&self, infcx: InferCtxt<'db>, trait_: Trait, args: &[TypeNs<'db>]) -> bool {
+        let args = GenericArgs::new_from_iter(
+            infcx.interner,
+            [self.ty].into_iter().chain(args.iter().map(|t| t.ty)).map(|t| t.into()),
+        );
+        let trait_ref = hir_ty::next_solver::TraitRef::new(
+            infcx.interner,
+            SolverDefId::TraitId(trait_.id),
+            args,
+        );
+
+        let pred_kind = rustc_type_ir::Binder::dummy(rustc_type_ir::PredicateKind::Clause(
+            rustc_type_ir::ClauseKind::Trait(rustc_type_ir::TraitPredicate {
+                trait_ref,
+                polarity: rustc_type_ir::PredicatePolarity::Positive,
+            }),
+        ));
+        let predicate = hir_ty::next_solver::Predicate::new(infcx.interner, pred_kind);
+        let goal = hir_ty::next_solver::Goal::new(
+            infcx.interner,
+            hir_ty::next_solver::ParamEnv::empty(),
+            predicate,
+        );
+        let res = hir_ty::traits::next_trait_solve_in_ctxt(&infcx, goal);
+        res.map_or(false, |res| matches!(res.1, rustc_type_ir::solve::Certainty::Yes))
+    }
+}
+
 #[derive(Debug, PartialEq, Eq, Copy, Clone, Hash)]
 pub struct InlineAsmOperand {
     owner: DefWithBodyId,
@@ -6476,3 +6639,6 @@ pub fn resolve_absolute_path<'a, I: Iterator<Item = Symbol> + Clone + 'a>(
 fn as_name_opt(name: Option<impl AsName>) -> Name {
     name.map_or_else(Name::missing, |name| name.as_name())
 }
+
+pub use hir_ty::next_solver;
+pub use hir_ty::setup_tracing;
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_from_impl_for_enum.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_from_impl_for_enum.rs
index af949a0649899..cb83c67c99535 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_from_impl_for_enum.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_from_impl_for_enum.rs
@@ -1,3 +1,4 @@
+use hir::next_solver::{DbInterner, TypingMode};
 use ide_db::{RootDatabase, famous_defs::FamousDefs};
 use syntax::ast::{self, AstNode, HasName};
 
@@ -80,17 +81,20 @@ fn existing_from_impl(
     sema: &'_ hir::Semantics<'_, RootDatabase>,
     variant: &ast::Variant,
 ) -> Option<()> {
+    let db = sema.db;
     let variant = sema.to_def(variant)?;
-    let enum_ = variant.parent_enum(sema.db);
-    let krate = enum_.module(sema.db).krate();
-
+    let krate = variant.module(db).krate();
     let from_trait = FamousDefs(sema, krate).core_convert_From()?;
+    let interner = DbInterner::new_with(db, Some(krate.base()), None);
+    use hir::next_solver::infer::DbInternerInferExt;
+    let infcx = interner.infer_ctxt().build(TypingMode::PostAnalysis);
 
-    let enum_type = enum_.ty(sema.db);
-
-    let wrapped_type = variant.fields(sema.db).first()?.ty(sema.db);
-
-    if enum_type.impls_trait(sema.db, from_trait, &[wrapped_type]) { Some(()) } else { None }
+    let variant = variant.instantiate_infer(&infcx);
+    let enum_ = variant.parent_enum(sema.db);
+    let field_ty = variant.fields(sema.db).first()?.ty(sema.db);
+    let enum_ty = enum_.ty(sema.db);
+    tracing::debug!(?enum_, ?field_ty, ?enum_ty);
+    enum_ty.impls_trait(infcx, from_trait, &[field_ty]).then_some(())
 }
 
 #[cfg(test)]
@@ -119,15 +123,19 @@ impl From<u32> for A {
         );
     }
 
+    // FIXME(next-solver): it would be nice to not be *required* to resolve the
+    // path in order to properly generate assists
     #[test]
     fn test_generate_from_impl_for_enum_complicated_path() {
         check_assist(
             generate_from_impl_for_enum,
             r#"
 //- minicore: from
+mod foo { pub mod bar { pub mod baz { pub struct Boo; } } }
 enum A { $0One(foo::bar::baz::Boo) }
 "#,
             r#"
+mod foo { pub mod bar { pub mod baz { pub struct Boo; } } }
 enum A { One(foo::bar::baz::Boo) }
 
 impl From<foo::bar::baz::Boo> for A {
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_single_field_struct_from.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_single_field_struct_from.rs
index 6076d5cb5cedf..deef4a9aac6db 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_single_field_struct_from.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_single_field_struct_from.rs
@@ -1,4 +1,5 @@
 use ast::make;
+use hir::next_solver::{DbInterner, TypingMode};
 use hir::{HasCrate, ModuleDef, Semantics};
 use ide_db::{
     RootDatabase, famous_defs::FamousDefs, helpers::mod_path_to_ast,
@@ -47,6 +48,7 @@ pub(crate) fn generate_single_field_struct_from(
     let strukt_name = ctx.find_node_at_offset::<ast::Name>()?;
     let adt = ast::Adt::cast(strukt_name.syntax().parent()?)?;
     let ast::Adt::Struct(strukt) = adt else {
+        tracing::debug!(?adt);
         return None;
     };
 
@@ -57,10 +59,12 @@ pub(crate) fn generate_single_field_struct_from(
     let constructors = make_constructors(ctx, module, &types);
 
     if constructors.iter().filter(|expr| expr.is_none()).count() != 1 {
+        tracing::debug!(?constructors);
         return None;
     }
     let main_field_i = constructors.iter().position(Option::is_none)?;
     if from_impl_exists(&strukt, main_field_i, &ctx.sema).is_some() {
+        tracing::debug!(?strukt, ?main_field_i);
         return None;
     }
 
@@ -200,6 +204,7 @@ fn get_fields(strukt: &ast::Struct) -> Option<(Option<Vec<ast::Name>>, Vec<ast::
     })
 }
 
+#[tracing::instrument(ret)]
 fn from_impl_exists(
     strukt: &ast::Struct,
     main_field_i: usize,
@@ -209,9 +214,15 @@ fn from_impl_exists(
     let strukt = sema.to_def(strukt)?;
     let krate = strukt.krate(db);
     let from_trait = FamousDefs(sema, krate).core_convert_From()?;
-    let ty = strukt.fields(db).get(main_field_i)?.ty(db);
-
-    strukt.ty(db).impls_trait(db, from_trait, &[ty]).then_some(())
+    let interner = DbInterner::new_with(db, Some(krate.base()), None);
+    use hir::next_solver::infer::DbInternerInferExt;
+    let infcx = interner.infer_ctxt().build(TypingMode::PostAnalysis);
+
+    let strukt = strukt.instantiate_infer(&infcx);
+    let field_ty = strukt.fields(db).get(main_field_i)?.ty(db);
+    let struct_ty = strukt.ty(db);
+    tracing::debug!(?strukt, ?field_ty, ?struct_ty);
+    struct_ty.impls_trait(infcx, from_trait, &[field_ty]).then_some(())
 }
 
 #[cfg(test)]
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/lib.rs b/src/tools/rust-analyzer/crates/ide-assists/src/lib.rs
index 4682c04732389..5008f97447b76 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/lib.rs
@@ -67,7 +67,7 @@ mod tests;
 pub mod utils;
 
 use hir::Semantics;
-use ide_db::{EditionedFileId, RootDatabase};
+use ide_db::{EditionedFileId, RootDatabase, base_db::salsa};
 use syntax::{Edition, TextRange};
 
 pub(crate) use crate::assist_context::{AssistContext, Assists};
@@ -93,8 +93,11 @@ pub fn assists(
         .unwrap_or_else(|| EditionedFileId::new(db, range.file_id, Edition::CURRENT));
     let ctx = AssistContext::new(sema, config, hir::FileRange { file_id, range: range.range });
     let mut acc = Assists::new(&ctx, resolve);
-    handlers::all().iter().for_each(|handler| {
-        handler(&mut acc, &ctx);
+    // the handlers may invoke trait solving related things which accesses salsa structs outside queries
+    salsa::attach(db, || {
+        handlers::all().iter().for_each(|handler| {
+            handler(&mut acc, &ctx);
+        });
     });
     acc.finish()
 }
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/tests.rs b/src/tools/rust-analyzer/crates/ide-assists/src/tests.rs
index cda2ad43278ac..f4daabfe915d7 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/tests.rs
@@ -1,11 +1,11 @@
 mod generated;
 
 use expect_test::expect;
-use hir::Semantics;
+use hir::{Semantics, setup_tracing};
 use ide_db::{
     EditionedFileId, FileRange, RootDatabase, SnippetCap,
     assists::ExprFillDefaultMode,
-    base_db::SourceDatabase,
+    base_db::{SourceDatabase, salsa},
     imports::insert_use::{ImportGranularity, InsertUseConfig},
     source_change::FileSystemEdit,
 };
@@ -305,6 +305,7 @@ fn check_with_config(
     expected: ExpectedResult<'_>,
     assist_label: Option<&str>,
 ) {
+    let _tracing = setup_tracing();
     let (mut db, file_with_caret_id, range_or_offset) = RootDatabase::with_range_or_offset(before);
     db.enable_proc_attr_macros();
     let text_without_caret = db.file_text(file_with_caret_id.file_id(&db)).text(&db).to_string();
@@ -318,7 +319,9 @@ fn check_with_config(
         _ => AssistResolveStrategy::All,
     };
     let mut acc = Assists::new(&ctx, resolve);
-    handler(&mut acc, &ctx);
+    salsa::attach(&db, || {
+        handler(&mut acc, &ctx);
+    });
     let mut res = acc.finish();
 
     let assist = match assist_label {
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/dot.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/dot.rs
index f75123324f377..129964f8387a3 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/dot.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/dot.rs
@@ -1384,14 +1384,15 @@ fn baz() {
     fn skip_iter() {
         check_no_kw(
             r#"
-        //- minicore: iterator
+        //- minicore: iterator, clone, builtin_impls
         fn foo() {
             [].$0
         }
         "#,
             expect![[r#"
-                me clone() (as Clone)                                       fn(&self) -> Self
-                me into_iter() (as IntoIterator) fn(self) -> <Self as IntoIterator>::IntoIter
+                me clone() (as Clone)                                             fn(&self) -> Self
+                me fmt(…) (use core::fmt::Debug) fn(&self, &mut Formatter<'_>) -> Result<(), Error>
+                me into_iter() (as IntoIterator)       fn(self) -> <Self as IntoIterator>::IntoIter
             "#]],
         );
         check_no_kw(
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/lib.rs b/src/tools/rust-analyzer/crates/ide-completion/src/lib.rs
index a70a1138d2f42..1a4c97e70b4ae 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/lib.rs
@@ -10,6 +10,7 @@ mod snippet;
 #[cfg(test)]
 mod tests;
 
+use base_db::salsa;
 use ide_db::{
     FilePosition, FxHashSet, RootDatabase,
     imports::insert_use::{self, ImportScope},
@@ -228,7 +229,7 @@ pub fn completions(
     {
         let acc = &mut completions;
 
-        match analysis {
+        salsa::attach(db, || match analysis {
             CompletionAnalysis::Name(name_ctx) => completions::complete_name(acc, ctx, name_ctx),
             CompletionAnalysis::NameRef(name_ref_ctx) => {
                 completions::complete_name_ref(acc, ctx, name_ref_ctx)
@@ -256,7 +257,7 @@ pub fn completions(
                 );
             }
             CompletionAnalysis::UnexpandedAttrTT { .. } | CompletionAnalysis::String { .. } => (),
-        }
+        })
     }
 
     Some(completions.into())
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/tests.rs b/src/tools/rust-analyzer/crates/ide-completion/src/tests.rs
index fdc3d9a13bc92..4b3b271ca20ef 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/tests.rs
@@ -26,7 +26,7 @@ mod visibility;
 
 use base_db::SourceDatabase;
 use expect_test::Expect;
-use hir::PrefixKind;
+use hir::{PrefixKind, setup_tracing};
 use ide_db::{
     FilePosition, RootDatabase, SnippetCap,
     imports::insert_use::{ImportGranularity, InsertUseConfig},
@@ -120,6 +120,8 @@ fn completion_list_with_config_raw(
     include_keywords: bool,
     trigger_character: Option<char>,
 ) -> Vec<CompletionItem> {
+    let _tracing = setup_tracing();
+
     // filter out all but one built-in type completion for smaller test outputs
     let items = get_all_items(config, ra_fixture, trigger_character);
     items
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/tests/flyimport.rs b/src/tools/rust-analyzer/crates/ide-completion/src/tests/flyimport.rs
index 27c91bc7c4558..bb10086a08c64 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/tests/flyimport.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/tests/flyimport.rs
@@ -1,3 +1,4 @@
+use base_db::salsa;
 use expect_test::{Expect, expect};
 
 use crate::{
@@ -19,25 +20,29 @@ fn check_with_config(
     let (ctx, analysis) = crate::context::CompletionContext::new(&db, position, &config).unwrap();
 
     let mut acc = crate::completions::Completions::default();
-    if let CompletionAnalysis::Name(NameContext { kind: NameKind::IdentPat(pat_ctx), .. }) =
-        &analysis
-    {
-        crate::completions::flyimport::import_on_the_fly_pat(&mut acc, &ctx, pat_ctx);
-    }
-    if let CompletionAnalysis::NameRef(name_ref_ctx) = &analysis {
-        match &name_ref_ctx.kind {
-            NameRefKind::Path(path) => {
-                crate::completions::flyimport::import_on_the_fly_path(&mut acc, &ctx, path);
-            }
-            NameRefKind::DotAccess(dot_access) => {
-                crate::completions::flyimport::import_on_the_fly_dot(&mut acc, &ctx, dot_access);
-            }
-            NameRefKind::Pattern(pattern) => {
-                crate::completions::flyimport::import_on_the_fly_pat(&mut acc, &ctx, pattern);
+    salsa::attach(ctx.db, || {
+        if let CompletionAnalysis::Name(NameContext { kind: NameKind::IdentPat(pat_ctx), .. }) =
+            &analysis
+        {
+            crate::completions::flyimport::import_on_the_fly_pat(&mut acc, &ctx, pat_ctx);
+        }
+        if let CompletionAnalysis::NameRef(name_ref_ctx) = &analysis {
+            match &name_ref_ctx.kind {
+                NameRefKind::Path(path) => {
+                    crate::completions::flyimport::import_on_the_fly_path(&mut acc, &ctx, path);
+                }
+                NameRefKind::DotAccess(dot_access) => {
+                    crate::completions::flyimport::import_on_the_fly_dot(
+                        &mut acc, &ctx, dot_access,
+                    );
+                }
+                NameRefKind::Pattern(pattern) => {
+                    crate::completions::flyimport::import_on_the_fly_pat(&mut acc, &ctx, pattern);
+                }
+                _ => (),
             }
-            _ => (),
         }
-    }
+    });
 
     expect.assert_eq(&super::render_completion_list(Vec::from(acc)));
 }
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/tests/special.rs b/src/tools/rust-analyzer/crates/ide-completion/src/tests/special.rs
index 148203107c4cf..84ddff8f617ac 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/tests/special.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/tests/special.rs
@@ -677,6 +677,7 @@ fn bar() -> Bar {
         expect![[r#"
             fn foo() (as Foo) fn() -> Self
             ex Bar
+            ex Bar::foo()
             ex bar()
         "#]],
     );
@@ -706,6 +707,7 @@ fn bar() -> Bar {
             fn bar()                  fn()
             fn foo() (as Foo) fn() -> Self
             ex Bar
+            ex Bar::foo()
             ex bar()
         "#]],
     );
@@ -734,6 +736,7 @@ fn bar() -> Bar {
         expect![[r#"
             fn foo() (as Foo) fn() -> Self
             ex Bar
+            ex Bar::foo()
             ex bar()
         "#]],
     );
diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/moved_out_of_ref.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/moved_out_of_ref.rs
index 1e80d02926d1b..6331090d9c90a 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/moved_out_of_ref.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/moved_out_of_ref.rs
@@ -157,7 +157,7 @@ fn h(x: &Y<Unknown>) -> Y<Unknown> {
     fn no_false_positive_dyn_fn() {
         check_diagnostics(
             r#"
-//- minicore: copy, fn
+//- minicore: copy, fn, dispatch_from_dyn
 fn f(x: &mut &mut dyn Fn()) {
     x();
 }
@@ -166,7 +166,7 @@ struct X<'a> {
     field: &'a mut dyn Fn(),
 }
 
-fn f(x: &mut X<'_>) {
+fn g(x: &mut X<'_>) {
     (x.field)();
 }
 "#,
diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/lib.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/lib.rs
index a1db92641f5ee..a4eb3d47d708b 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/lib.rs
@@ -92,7 +92,7 @@ use hir::{
 use ide_db::{
     EditionedFileId, FileId, FileRange, FxHashMap, FxHashSet, RootDatabase, Severity, SnippetCap,
     assists::{Assist, AssistId, AssistResolveStrategy, ExprFillDefaultMode},
-    base_db::{ReleaseChannel, RootQueryDb as _},
+    base_db::{ReleaseChannel, RootQueryDb as _, salsa},
     generated::lints::{CLIPPY_LINT_GROUPS, DEFAULT_LINT_GROUPS, DEFAULT_LINTS, Lint, LintGroup},
     imports::insert_use::InsertUseConfig,
     label::Label,
@@ -537,10 +537,12 @@ pub fn full_diagnostics(
     resolve: &AssistResolveStrategy,
     file_id: FileId,
 ) -> Vec<Diagnostic> {
-    let mut res = syntax_diagnostics(db, config, file_id);
-    let sema = semantic_diagnostics(db, config, resolve, file_id);
-    res.extend(sema);
-    res
+    salsa::attach(db, || {
+        let mut res = syntax_diagnostics(db, config, file_id);
+        let sema = semantic_diagnostics(db, config, resolve, file_id);
+        res.extend(sema);
+        res
+    })
 }
 
 /// Returns whether to keep this diagnostic (or remove it).
diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/tests.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/tests.rs
index 181993154e59f..c3cc5a08b56b5 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/tests.rs
@@ -2,6 +2,7 @@
 
 mod overly_long_real_world_cases;
 
+use hir::setup_tracing;
 use ide_db::{
     LineIndexDatabase, RootDatabase,
     assists::{AssistResolveStrategy, ExprFillDefaultMode},
@@ -198,6 +199,8 @@ pub(crate) fn check_diagnostics_with_config(
     config: DiagnosticsConfig,
     #[rust_analyzer::rust_fixture] ra_fixture: &str,
 ) {
+    let _tracing = setup_tracing();
+
     let (db, files) = RootDatabase::with_many_files(ra_fixture);
     let mut annotations = files
         .iter()
diff --git a/src/tools/rust-analyzer/crates/ide-ssr/src/resolving.rs b/src/tools/rust-analyzer/crates/ide-ssr/src/resolving.rs
index a4e2cfbaee27d..1d5f5adf2eefe 100644
--- a/src/tools/rust-analyzer/crates/ide-ssr/src/resolving.rs
+++ b/src/tools/rust-analyzer/crates/ide-ssr/src/resolving.rs
@@ -1,7 +1,7 @@
 //! This module is responsible for resolving paths within rules.
 
 use hir::AsAssocItem;
-use ide_db::FxHashMap;
+use ide_db::{FxHashMap, base_db::salsa};
 use parsing::Placeholder;
 use syntax::{
     SmolStr, SyntaxKind, SyntaxNode, SyntaxToken,
@@ -48,16 +48,20 @@ impl<'db> ResolvedRule<'db> {
         resolution_scope: &ResolutionScope<'db>,
         index: usize,
     ) -> Result<ResolvedRule<'db>, SsrError> {
-        let resolver =
-            Resolver { resolution_scope, placeholders_by_stand_in: rule.placeholders_by_stand_in };
-        let resolved_template = match rule.template {
-            Some(template) => Some(resolver.resolve_pattern_tree(template)?),
-            None => None,
-        };
-        Ok(ResolvedRule {
-            pattern: resolver.resolve_pattern_tree(rule.pattern)?,
-            template: resolved_template,
-            index,
+        salsa::attach(resolution_scope.scope.db, || {
+            let resolver = Resolver {
+                resolution_scope,
+                placeholders_by_stand_in: rule.placeholders_by_stand_in,
+            };
+            let resolved_template = match rule.template {
+                Some(template) => Some(resolver.resolve_pattern_tree(template)?),
+                None => None,
+            };
+            Ok(ResolvedRule {
+                pattern: resolver.resolve_pattern_tree(rule.pattern)?,
+                template: resolved_template,
+                index,
+            })
         })
     }
 
diff --git a/src/tools/rust-analyzer/crates/ide/src/doc_links/tests.rs b/src/tools/rust-analyzer/crates/ide/src/doc_links/tests.rs
index c2f08f8ca2e6b..b004c07576748 100644
--- a/src/tools/rust-analyzer/crates/ide/src/doc_links/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/doc_links/tests.rs
@@ -4,6 +4,7 @@ use expect_test::{Expect, expect};
 use hir::Semantics;
 use ide_db::{
     FilePosition, FileRange, RootDatabase,
+    base_db::salsa,
     defs::Definition,
     documentation::{DocsRangeMap, Documentation, HasDocs},
 };
@@ -63,8 +64,10 @@ fn check_doc_links(#[rust_analyzer::rust_fixture] ra_fixture: &str) {
         .flat_map(|(text_range, link, ns)| {
             let attr = range.map(text_range);
             let is_inner_attr = attr.map(|(_file, attr)| attr.is_inner_attr()).unwrap_or(false);
-            let def = resolve_doc_path_for_def(sema.db, cursor_def, &link, ns, is_inner_attr)
-                .unwrap_or_else(|| panic!("Failed to resolve {link}"));
+            let def = salsa::attach(sema.db, || {
+                resolve_doc_path_for_def(sema.db, cursor_def, &link, ns, is_inner_attr)
+                    .unwrap_or_else(|| panic!("Failed to resolve {link}"))
+            });
             def.try_to_nav(sema.db).unwrap().into_iter().zip(iter::repeat(link))
         })
         .map(|(nav_target, link)| {
diff --git a/src/tools/rust-analyzer/crates/ide/src/goto_definition.rs b/src/tools/rust-analyzer/crates/ide/src/goto_definition.rs
index f768d4b68f469..633feec622cd9 100644
--- a/src/tools/rust-analyzer/crates/ide/src/goto_definition.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/goto_definition.rs
@@ -10,7 +10,7 @@ use hir::{
 };
 use ide_db::{
     RootDatabase, SymbolKind,
-    base_db::{AnchoredPath, SourceDatabase},
+    base_db::{AnchoredPath, SourceDatabase, salsa},
     defs::{Definition, IdentClass},
     famous_defs::FamousDefs,
     helpers::pick_best_token,
@@ -108,7 +108,7 @@ pub(crate) fn goto_definition(
             }
 
             Some(
-                IdentClass::classify_node(sema, &parent)?
+                salsa::attach(sema.db, || IdentClass::classify_node(sema, &parent))?
                     .definitions()
                     .into_iter()
                     .flat_map(|(def, _)| {
diff --git a/src/tools/rust-analyzer/crates/ide/src/goto_implementation.rs b/src/tools/rust-analyzer/crates/ide/src/goto_implementation.rs
index 02d96a6473281..4f172621908c5 100644
--- a/src/tools/rust-analyzer/crates/ide/src/goto_implementation.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/goto_implementation.rs
@@ -234,6 +234,7 @@ impl crate::T for crate::Foo {}
         );
     }
 
+    // FIXME(next-solver): it would be nice to be able to also point to `&Foo`
     #[test]
     fn goto_implementation_all_impls() {
         check(
@@ -246,7 +247,6 @@ impl Foo {}
 impl T for Foo {}
          //^^^
 impl T for &Foo {}
-         //^^^^
 "#,
         );
     }
diff --git a/src/tools/rust-analyzer/crates/ide/src/hover.rs b/src/tools/rust-analyzer/crates/ide/src/hover.rs
index 44c98a43f6944..a48fe43e80803 100644
--- a/src/tools/rust-analyzer/crates/ide/src/hover.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/hover.rs
@@ -12,6 +12,7 @@ use hir::{
 };
 use ide_db::{
     FileRange, FxIndexSet, Ranker, RootDatabase,
+    base_db::salsa,
     defs::{Definition, IdentClass, NameRefClass, OperatorClass},
     famous_defs::FamousDefs,
     helpers::pick_best_token,
@@ -290,7 +291,7 @@ fn hover_offset(
                 .into_iter()
                 .unique_by(|&((def, _), _, _, _)| def)
                 .map(|((def, subst), macro_arm, hovered_definition, node)| {
-                    hover_for_definition(
+                    salsa::attach(sema.db, || hover_for_definition(
                         sema,
                         file_id,
                         def,
@@ -301,7 +302,7 @@ fn hover_offset(
                         config,
                         edition,
                         display_target,
-                    )
+                    ))
                 })
                 .collect::<Vec<_>>(),
             )
diff --git a/src/tools/rust-analyzer/crates/ide/src/hover/render.rs b/src/tools/rust-analyzer/crates/ide/src/hover/render.rs
index 51b5900e8155a..1c0272cdfacd1 100644
--- a/src/tools/rust-analyzer/crates/ide/src/hover/render.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/hover/render.rs
@@ -10,6 +10,7 @@ use hir::{
 };
 use ide_db::{
     RootDatabase,
+    base_db::salsa,
     defs::Definition,
     documentation::{DocsRangeMap, HasDocs},
     famous_defs::FamousDefs,
@@ -44,7 +45,7 @@ pub(super) fn type_info_of(
         Either::Left(expr) => sema.type_of_expr(expr)?,
         Either::Right(pat) => sema.type_of_pat(pat)?,
     };
-    type_info(sema, _config, ty_info, edition, display_target)
+    salsa::attach(sema.db, || type_info(sema, _config, ty_info, edition, display_target))
 }
 
 pub(super) fn closure_expr(
diff --git a/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs b/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
index c5480217a91e2..6f1bbad6ba169 100644
--- a/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
@@ -6,6 +6,8 @@ use crate::{
     HoverConfig, HoverDocFormat, MemoryLayoutHoverConfig, MemoryLayoutHoverRenderKind, fixture,
 };
 
+use hir::setup_tracing;
+
 const HOVER_BASE_CONFIG: HoverConfig = HoverConfig {
     links_in_hover: false,
     memory_layout: Some(MemoryLayoutHoverConfig {
@@ -38,6 +40,7 @@ fn check_hover_no_result(#[rust_analyzer::rust_fixture] ra_fixture: &str) {
 
 #[track_caller]
 fn check(#[rust_analyzer::rust_fixture] ra_fixture: &str, expect: Expect) {
+    let _tracing = setup_tracing();
     let (analysis, position) = fixture::position(ra_fixture);
     let hover = analysis
         .hover(
diff --git a/src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs b/src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs
index 8c2a2f6f72f5e..f6416fe51c307 100644
--- a/src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs
@@ -8,7 +8,9 @@ use hir::{
     ClosureStyle, DisplayTarget, EditionedFileId, HasVisibility, HirDisplay, HirDisplayError,
     HirWrite, InRealFile, ModuleDef, ModuleDefId, Semantics, sym,
 };
-use ide_db::{FileRange, RootDatabase, famous_defs::FamousDefs, text_edit::TextEditBuilder};
+use ide_db::{
+    FileRange, RootDatabase, base_db::salsa, famous_defs::FamousDefs, text_edit::TextEditBuilder,
+};
 use ide_db::{FxHashSet, text_edit::TextEdit};
 use itertools::Itertools;
 use smallvec::{SmallVec, smallvec};
@@ -734,7 +736,7 @@ fn label_of_ty(
         config: &InlayHintsConfig,
         display_target: DisplayTarget,
     ) -> Result<(), HirDisplayError> {
-        let iter_item_type = hint_iterator(sema, famous_defs, ty);
+        let iter_item_type = salsa::attach(sema.db, || hint_iterator(sema, famous_defs, ty));
         match iter_item_type {
             Some((iter_trait, item, ty)) => {
                 const LABEL_START: &str = "impl ";
diff --git a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/adjustment.rs b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/adjustment.rs
index 4d020bac3aad4..39554d777795c 100644
--- a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/adjustment.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/adjustment.rs
@@ -411,10 +411,9 @@ fn main() {
     (()) == {()};
   // ^^&
          // ^^^^&
-    let closure: dyn Fn = || ();
+    let closure: &dyn Fn = &|| ();
+                         //^^^^^^<unsize>&*
     closure();
-  //^^^^^^^(&
-  //^^^^^^^)
     Struct[0];
   //^^^^^^(&
   //^^^^^^)
@@ -507,9 +506,10 @@ fn main() {
     (()) == {()};
   // ^^.&
          // ^^^^.&
-    let closure: dyn Fn = || ();
+    let closure: &dyn Fn = &|| ();
+                         //^^^^^^(
+                         //^^^^^^).*.&.<unsize>
     closure();
-  //^^^^^^^.&
     Struct[0];
   //^^^^^^.&
     &mut Struct[0];
diff --git a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/bind_pat.rs b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/bind_pat.rs
index 922e9598aa017..7a4af4f7549c6 100644
--- a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/bind_pat.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/bind_pat.rs
@@ -909,7 +909,7 @@ fn main() {
     foo(plus_one);
 
     let add_mul = bar(|x: u8| { x + 1 });
-    //  ^^^^^^^ impl FnOnce(u8) -> u8 + ?Sized
+    //  ^^^^^^^ impl FnOnce(u8) -> u8
 
     let closure = if let Some(6) = add_mul(2).checked_sub(1) {
     //  ^^^^^^^ fn(i32) -> i32
diff --git a/src/tools/rust-analyzer/crates/ide/src/signature_help.rs b/src/tools/rust-analyzer/crates/ide/src/signature_help.rs
index 382573b680113..2cccb9639f3eb 100644
--- a/src/tools/rust-analyzer/crates/ide/src/signature_help.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/signature_help.rs
@@ -733,7 +733,7 @@ fn signature_help_for_tuple_pat_ish<'db>(
 mod tests {
 
     use expect_test::{Expect, expect};
-    use ide_db::FilePosition;
+    use ide_db::{FilePosition, base_db::salsa};
     use stdx::format_to;
     use test_fixture::ChangeFixture;
 
@@ -762,7 +762,7 @@ mod tests {
             "#
         );
         let (db, position) = position(&fixture);
-        let sig_help = crate::signature_help::signature_help(&db, position);
+        let sig_help = salsa::attach(&db, || crate::signature_help::signature_help(&db, position));
         let actual = match sig_help {
             Some(sig_help) => {
                 let mut rendered = String::new();
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting.rs b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting.rs
index 3ca172977cb9e..e3dc3ed3c742a 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting.rs
@@ -16,7 +16,7 @@ use std::ops::ControlFlow;
 
 use either::Either;
 use hir::{DefWithBody, EditionedFileId, InFile, InRealFile, MacroKind, Name, Semantics};
-use ide_db::{FxHashMap, FxHashSet, Ranker, RootDatabase, SymbolKind};
+use ide_db::{FxHashMap, FxHashSet, Ranker, RootDatabase, SymbolKind, base_db::salsa};
 use syntax::{
     AstNode, AstToken, NodeOrToken,
     SyntaxKind::*,
@@ -434,15 +434,17 @@ fn traverse(
             |node| unsafe_ops.contains(&InFile::new(descended_element.file_id, node));
         let element = match descended_element.value {
             NodeOrToken::Node(name_like) => {
-                let hl = highlight::name_like(
-                    sema,
-                    krate,
-                    bindings_shadow_count,
-                    &is_unsafe_node,
-                    config.syntactic_name_ref_highlighting,
-                    name_like,
-                    edition,
-                );
+                let hl = salsa::attach(sema.db, || {
+                    highlight::name_like(
+                        sema,
+                        krate,
+                        bindings_shadow_count,
+                        &is_unsafe_node,
+                        config.syntactic_name_ref_highlighting,
+                        name_like,
+                        edition,
+                    )
+                });
                 if hl.is_some() && !in_macro {
                     // skip highlighting the contained token of our name-like node
                     // as that would potentially overwrite our result
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_general.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_general.html
index 00925bd81ed8e..d99b29cfb8fa6 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_general.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_general.html
@@ -127,9 +127,9 @@
     <span class="keyword">let</span> <span class="variable declaration mutable reference">y</span> <span class="operator">=</span> <span class="operator">&</span><span class="keyword">mut</span> <span class="variable mutable">x</span><span class="semicolon">;</span>
     <span class="keyword">let</span> <span class="variable declaration reference">z</span> <span class="operator">=</span> <span class="operator">&</span><span class="variable mutable reference">y</span><span class="semicolon">;</span>
 
-    <span class="keyword">let</span> <span class="struct">Foo</span> <span class="brace">{</span> <span class="field">x</span><span class="colon">:</span> <span class="variable declaration">z</span><span class="comma">,</span> <span class="variable declaration">y</span> <span class="brace">}</span> <span class="operator">=</span> <span class="struct">Foo</span> <span class="brace">{</span> <span class="field">x</span><span class="colon">:</span> <span class="variable reference">z</span><span class="comma">,</span> <span class="variable mutable reference">y</span> <span class="brace">}</span><span class="semicolon">;</span>
+    <span class="keyword">let</span> <span class="struct">Foo</span> <span class="brace">{</span> <span class="field">x</span><span class="colon">:</span> <span class="variable declaration">z</span><span class="comma">,</span> <span class="variable callable declaration">y</span> <span class="brace">}</span> <span class="operator">=</span> <span class="struct">Foo</span> <span class="brace">{</span> <span class="field">x</span><span class="colon">:</span> <span class="variable reference">z</span><span class="comma">,</span> <span class="variable mutable reference">y</span> <span class="brace">}</span><span class="semicolon">;</span>
 
-    <span class="variable">y</span><span class="semicolon">;</span>
+    <span class="variable callable">y</span><span class="semicolon">;</span>
 
     <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">foo</span> <span class="operator">=</span> <span class="struct">Foo</span> <span class="brace">{</span> <span class="field">x</span><span class="comma">,</span> <span class="unresolved_reference">y</span><span class="colon">:</span> <span class="variable mutable">x</span> <span class="brace">}</span><span class="semicolon">;</span>
     <span class="keyword">let</span> <span class="variable declaration">foo2</span> <span class="operator">=</span> <span class="struct">Foo</span> <span class="brace">{</span> <span class="field">x</span><span class="comma">,</span> <span class="unresolved_reference">y</span><span class="colon">:</span> <span class="variable mutable">x</span> <span class="brace">}</span><span class="semicolon">;</span>
@@ -142,7 +142,7 @@
     <span class="variable mutable">copy</span><span class="operator">.</span><span class="method mutable reference">qux</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
     <span class="variable mutable">copy</span><span class="operator">.</span><span class="method">baz</span><span class="parenthesis">(</span><span class="variable mutable">copy</span><span class="parenthesis">)</span><span class="semicolon">;</span>
 
-    <span class="keyword">let</span> <span class="variable callable declaration">a</span> <span class="operator">=</span> <span class="punctuation">|</span><span class="value_param declaration">x</span><span class="punctuation">|</span> <span class="value_param">x</span><span class="semicolon">;</span>
+    <span class="keyword">let</span> <span class="variable callable declaration">a</span> <span class="operator">=</span> <span class="punctuation">|</span><span class="value_param callable declaration">x</span><span class="punctuation">|</span> <span class="value_param callable">x</span><span class="semicolon">;</span>
     <span class="keyword">let</span> <span class="variable callable declaration">bar</span> <span class="operator">=</span> <span class="struct">Foo</span><span class="operator">::</span><span class="method associated consuming">baz</span><span class="semicolon">;</span>
 
     <span class="keyword">let</span> <span class="variable declaration">baz</span> <span class="operator">=</span> <span class="parenthesis">(</span><span class="numeric_literal">-</span><span class="numeric_literal">42</span><span class="comma">,</span><span class="parenthesis">)</span><span class="semicolon">;</span>
@@ -172,13 +172,13 @@
 <span class="brace">}</span>
 
 <span class="keyword async">async</span> <span class="keyword">fn</span> <span class="function async declaration">learn_and_sing</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
-    <span class="keyword">let</span> <span class="variable declaration">song</span> <span class="operator">=</span> <span class="unresolved_reference">learn_song</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="operator">.</span><span class="keyword async control">await</span><span class="semicolon">;</span>
-    <span class="unresolved_reference">sing_song</span><span class="parenthesis">(</span><span class="variable consuming">song</span><span class="parenthesis">)</span><span class="operator">.</span><span class="keyword async control">await</span><span class="semicolon">;</span>
+    <span class="keyword">let</span> <span class="variable callable declaration">song</span> <span class="operator">=</span> <span class="unresolved_reference">learn_song</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="operator">.</span><span class="keyword async control">await</span><span class="semicolon">;</span>
+    <span class="unresolved_reference">sing_song</span><span class="parenthesis">(</span><span class="variable callable">song</span><span class="parenthesis">)</span><span class="operator">.</span><span class="keyword async control">await</span><span class="semicolon">;</span>
 <span class="brace">}</span>
 
 <span class="keyword async">async</span> <span class="keyword">fn</span> <span class="function async declaration">async_main</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
     <span class="keyword">let</span> <span class="variable declaration">f1</span> <span class="operator">=</span> <span class="function async">learn_and_sing</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
-    <span class="keyword">let</span> <span class="variable declaration">f2</span> <span class="operator">=</span> <span class="unresolved_reference">dance</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="keyword">let</span> <span class="variable callable declaration">f2</span> <span class="operator">=</span> <span class="unresolved_reference">dance</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
     <span class="unresolved_reference">futures</span><span class="operator">::</span><span class="unresolved_reference">join</span><span class="macro_bang">!</span><span class="parenthesis">(</span>f1<span class="comma">,</span> f2<span class="parenthesis">)</span><span class="semicolon">;</span>
 <span class="brace">}</span>
 
diff --git a/src/tools/rust-analyzer/crates/intern/src/symbol/symbols.rs b/src/tools/rust-analyzer/crates/intern/src/symbol/symbols.rs
index 4780743c4d92a..983ed3684a4f6 100644
--- a/src/tools/rust-analyzer/crates/intern/src/symbol/symbols.rs
+++ b/src/tools/rust-analyzer/crates/intern/src/symbol/symbols.rs
@@ -178,6 +178,8 @@ define_symbols! {
     core,
     coroutine_state,
     coroutine,
+    coroutine_return,
+    coroutine_yield,
     count,
     crate_type,
     CStr,
@@ -226,6 +228,8 @@ define_symbols! {
     async_fn_once_output,
     async_fn_mut,
     async_fn,
+    call_ref_future,
+    call_once_future,
     fn_ptr_addr,
     fn_ptr_trait,
     format_alignment,
@@ -416,6 +420,7 @@ define_symbols! {
     rustc_allow_incoherent_impl,
     rustc_builtin_macro,
     rustc_coherence_is_core,
+    rustc_coinductive,
     rustc_const_panic_str,
     rustc_deallocator,
     rustc_deprecated_safe_2024,
diff --git a/src/tools/rust-analyzer/crates/profile/src/stop_watch.rs b/src/tools/rust-analyzer/crates/profile/src/stop_watch.rs
index 9f3e636ef816a..00c37c01d25e2 100644
--- a/src/tools/rust-analyzer/crates/profile/src/stop_watch.rs
+++ b/src/tools/rust-analyzer/crates/profile/src/stop_watch.rs
@@ -37,10 +37,10 @@ impl StopWatch {
                     .build()
                     .map_err(|err| eprintln!("Failed to create perf counter: {err}"))
                     .ok();
-                if let Some(counter) = &mut counter {
-                    if let Err(err) = counter.enable() {
-                        eprintln!("Failed to start perf counter: {err}")
-                    }
+                if let Some(counter) = &mut counter
+                    && let Err(err) = counter.enable()
+                {
+                    eprintln!("Failed to start perf counter: {err}")
                 }
                 counter
             } else {
diff --git a/src/tools/rust-analyzer/crates/query-group-macro/src/queries.rs b/src/tools/rust-analyzer/crates/query-group-macro/src/queries.rs
index c151cca07272a..22a26c49fa530 100644
--- a/src/tools/rust-analyzer/crates/query-group-macro/src/queries.rs
+++ b/src/tools/rust-analyzer/crates/query-group-macro/src/queries.rs
@@ -48,7 +48,8 @@ impl ToTokens for TrackedQuery {
                 quote!(#(#options),*)
             })
             .into_iter()
-            .chain(self.lru.map(|lru| quote!(lru = #lru)));
+            .chain(self.lru.map(|lru| quote!(lru = #lru)))
+            .chain(Some(quote!(unsafe(non_update_return_type))));
         let annotation = quote!(#[salsa_macros::tracked( #(#options),* )]);
 
         let pat_and_tys = &self.pat_and_tys;
diff --git a/src/tools/rust-analyzer/crates/test-utils/src/minicore.rs b/src/tools/rust-analyzer/crates/test-utils/src/minicore.rs
index 7b719b5dec754..b735b323ce430 100644
--- a/src/tools/rust-analyzer/crates/test-utils/src/minicore.rs
+++ b/src/tools/rust-analyzer/crates/test-utils/src/minicore.rs
@@ -35,7 +35,7 @@
 //!     error: fmt
 //!     fmt: option, result, transmute, coerce_unsized, copy, clone, derive
 //!     fmt_before_1_89_0: fmt
-//!     fn: tuple
+//!     fn: sized, tuple
 //!     from: sized, result
 //!     future: pin
 //!     coroutine: pin
@@ -325,6 +325,18 @@ pub mod clone {
             *self
         }
     }
+
+    impl<T: Clone> Clone for [T; 0] {
+        fn clone(&self) -> Self {
+            []
+        }
+    }
+
+    impl<T: Clone> Clone for [T; 1] {
+        fn clone(&self) -> Self {
+            [self[0].clone()]
+        }
+    }
     // endregion:builtin_impls
 
     // region:derive
@@ -1035,6 +1047,7 @@ pub mod ops {
 
         #[lang = "coroutine"]
         pub trait Coroutine<R = ()> {
+            #[lang = "coroutine_yield"]
             type Yield;
             #[lang = "coroutine_return"]
             type Return;

From 6b8a812aafaad6b0edd04d12569fe43ee1e69eed Mon Sep 17 00:00:00 2001
From: Nathaniel McCallum <nathaniel@mccallum.life>
Date: Sun, 10 Aug 2025 01:38:17 -0400
Subject: [PATCH 0048/1889] parser: fix parsing of trait bound polarity and
 for-binders
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The rustc AST allows both `for<>` binders and `?` polarity
modifiers in trait bounds, but they are parsed in a specific
order and validated for correctness:

  1. `for<>` binder is parsed first.
  2. Polarity modifiers (`?`, `!`) are parsed second.
  3. The parser validates that binders and polarity modifiers
     do not conflict:

```rust
if let Some(binder_span) = binder_span {
    match modifiers.polarity {
        BoundPolarity::Maybe(polarity_span) => {
            // Error: "for<...> binder not allowed with ? polarity"
        }
    }
}
```

This implies:

- `for<> ?Sized` → Valid syntax. Invalid semantics.
- `?for<> Sized` → Invalid syntax.

However, rust-analyzer incorrectly had special-case logic that
allowed `?for<>` as valid syntax. This fix removes that incorrect
special case, making rust-analyzer reject `?for<> Sized` as a
syntax error, matching rustc behavior.

This has caused confusion in other crates (such as syn) which
rely on these files to implement correct syntax evaluation.
---
 .../parser/src/grammar/generic_params.rs      | 11 ++---
 .../parser/test_data/generated/runner.rs      |  6 +++
 ...invalid_question_for_type_trait_bound.rast | 49 +++++++++++++++++++
 .../invalid_question_for_type_trait_bound.rs  |  1 +
 .../ok/question_for_type_trait_bound.rast     | 23 +++++----
 .../ok/question_for_type_trait_bound.rs       |  2 +-
 6 files changed, 73 insertions(+), 19 deletions(-)
 create mode 100644 src/tools/rust-analyzer/crates/parser/test_data/parser/inline/err/invalid_question_for_type_trait_bound.rast
 create mode 100644 src/tools/rust-analyzer/crates/parser/test_data/parser/inline/err/invalid_question_for_type_trait_bound.rs

diff --git a/src/tools/rust-analyzer/crates/parser/src/grammar/generic_params.rs b/src/tools/rust-analyzer/crates/parser/src/grammar/generic_params.rs
index cb1b59f649774..d419817e5cd70 100644
--- a/src/tools/rust-analyzer/crates/parser/src/grammar/generic_params.rs
+++ b/src/tools/rust-analyzer/crates/parser/src/grammar/generic_params.rs
@@ -182,12 +182,6 @@ fn type_bound(p: &mut Parser<'_>) -> bool {
             );
             m.complete(p, USE_BOUND_GENERIC_ARGS);
         }
-        T![?] if p.nth_at(1, T![for]) => {
-            // test question_for_type_trait_bound
-            // fn f<T>() where T: ?for<> Sized {}
-            p.bump_any();
-            types::for_type(p, false)
-        }
         _ => {
             if path_type_bound(p).is_err() {
                 m.abandon(p);
@@ -219,8 +213,13 @@ fn path_type_bound(p: &mut Parser<'_>) -> Result<(), ()> {
     // test async_trait_bound
     // fn async_foo(_: impl async Fn(&i32)) {}
     p.eat(T![async]);
+    // test question_for_type_trait_bound
+    // fn f<T>() where T: for<> ?Sized {}
     p.eat(T![?]);
 
+    // test_err invalid_question_for_type_trait_bound
+    // fn f<T>() where T: ?for<> Sized {}
+
     if paths::is_use_path_start(p) {
         types::path_type_bounds(p, false);
         // test_err type_bounds_macro_call_recovery
diff --git a/src/tools/rust-analyzer/crates/parser/test_data/generated/runner.rs b/src/tools/rust-analyzer/crates/parser/test_data/generated/runner.rs
index c642e1a3354fc..a3cfe64e6e739 100644
--- a/src/tools/rust-analyzer/crates/parser/test_data/generated/runner.rs
+++ b/src/tools/rust-analyzer/crates/parser/test_data/generated/runner.rs
@@ -796,6 +796,12 @@ mod err {
     #[test]
     fn impl_type() { run_and_expect_errors("test_data/parser/inline/err/impl_type.rs"); }
     #[test]
+    fn invalid_question_for_type_trait_bound() {
+        run_and_expect_errors(
+            "test_data/parser/inline/err/invalid_question_for_type_trait_bound.rs",
+        );
+    }
+    #[test]
     fn let_else_right_curly_brace() {
         run_and_expect_errors("test_data/parser/inline/err/let_else_right_curly_brace.rs");
     }
diff --git a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/err/invalid_question_for_type_trait_bound.rast b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/err/invalid_question_for_type_trait_bound.rast
new file mode 100644
index 0000000000000..b060ee81d6178
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/err/invalid_question_for_type_trait_bound.rast
@@ -0,0 +1,49 @@
+SOURCE_FILE
+  FN
+    FN_KW "fn"
+    WHITESPACE " "
+    NAME
+      IDENT "f"
+    GENERIC_PARAM_LIST
+      L_ANGLE "<"
+      TYPE_PARAM
+        NAME
+          IDENT "T"
+      R_ANGLE ">"
+    PARAM_LIST
+      L_PAREN "("
+      R_PAREN ")"
+    WHITESPACE " "
+    WHERE_CLAUSE
+      WHERE_KW "where"
+      WHITESPACE " "
+      WHERE_PRED
+        PATH_TYPE
+          PATH
+            PATH_SEGMENT
+              NAME_REF
+                IDENT "T"
+        COLON ":"
+        WHITESPACE " "
+        TYPE_BOUND_LIST
+          QUESTION "?"
+      WHERE_PRED
+        FOR_BINDER
+          FOR_KW "for"
+          GENERIC_PARAM_LIST
+            L_ANGLE "<"
+            R_ANGLE ">"
+        WHITESPACE " "
+        PATH_TYPE
+          PATH
+            PATH_SEGMENT
+              NAME_REF
+                IDENT "Sized"
+    WHITESPACE " "
+    BLOCK_EXPR
+      STMT_LIST
+        L_CURLY "{"
+        R_CURLY "}"
+  WHITESPACE "\n"
+error 20: expected comma
+error 31: expected colon
diff --git a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/err/invalid_question_for_type_trait_bound.rs b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/err/invalid_question_for_type_trait_bound.rs
new file mode 100644
index 0000000000000..f80dd90d446c5
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/err/invalid_question_for_type_trait_bound.rs
@@ -0,0 +1 @@
+fn f<T>() where T: ?for<> Sized {}
diff --git a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/question_for_type_trait_bound.rast b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/question_for_type_trait_bound.rast
index cb296153c8f1a..69db1aee2c5a5 100644
--- a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/question_for_type_trait_bound.rast
+++ b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/question_for_type_trait_bound.rast
@@ -27,19 +27,18 @@ SOURCE_FILE
         WHITESPACE " "
         TYPE_BOUND_LIST
           TYPE_BOUND
+            FOR_BINDER
+              FOR_KW "for"
+              GENERIC_PARAM_LIST
+                L_ANGLE "<"
+                R_ANGLE ">"
+            WHITESPACE " "
             QUESTION "?"
-            FOR_TYPE
-              FOR_BINDER
-                FOR_KW "for"
-                GENERIC_PARAM_LIST
-                  L_ANGLE "<"
-                  R_ANGLE ">"
-              WHITESPACE " "
-              PATH_TYPE
-                PATH
-                  PATH_SEGMENT
-                    NAME_REF
-                      IDENT "Sized"
+            PATH_TYPE
+              PATH
+                PATH_SEGMENT
+                  NAME_REF
+                    IDENT "Sized"
     WHITESPACE " "
     BLOCK_EXPR
       STMT_LIST
diff --git a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/question_for_type_trait_bound.rs b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/question_for_type_trait_bound.rs
index f80dd90d446c5..96353df3b9b33 100644
--- a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/question_for_type_trait_bound.rs
+++ b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/question_for_type_trait_bound.rs
@@ -1 +1 @@
-fn f<T>() where T: ?for<> Sized {}
+fn f<T>() where T: for<> ?Sized {}

From 8c0f4b40803a6d0c6ed6525026217c8d2532d205 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Sun, 10 Aug 2025 14:37:35 +0800
Subject: [PATCH 0049/1889] Fix extract_expressions_from_format_string on
 write!

**Input**:

```rust
fn main() {
    write!(f, "{2+3}$0")
}
```

**Old output**:

```rust
fn main() {
    write!("{}"$0, 2+3)
}
```

**This PR output**:

```rust
fn main() {
    write!(f, "{}"$0, 2+3)
}
```
---
 .../extract_expressions_from_format_string.rs | 46 ++++++++++++++++---
 1 file changed, 40 insertions(+), 6 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_expressions_from_format_string.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_expressions_from_format_string.rs
index cdc0e967101a4..e3c7ea1b09391 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_expressions_from_format_string.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_expressions_from_format_string.rs
@@ -7,8 +7,8 @@ use itertools::Itertools;
 use syntax::{
     AstNode, AstToken, NodeOrToken,
     SyntaxKind::WHITESPACE,
-    T,
-    ast::{self, make, syntax_factory::SyntaxFactory},
+    SyntaxToken, T,
+    ast::{self, TokenTree, make, syntax_factory::SyntaxFactory},
 };
 
 // Assist: extract_expressions_from_format_string
@@ -58,10 +58,11 @@ pub(crate) fn extract_expressions_from_format_string(
         tt.syntax().text_range(),
         |edit| {
             // Extract existing arguments in macro
-            let tokens = tt.token_trees_and_tokens().collect_vec();
+            let mut raw_tokens = tt.token_trees_and_tokens().skip(1).collect_vec();
+            let format_string_index = format_str_index(&raw_tokens, &fmt_string);
+            let tokens = raw_tokens.split_off(format_string_index);
 
             let existing_args = if let [
-                _opening_bracket,
                 NodeOrToken::Token(_format_string),
                 _args_start_comma,
                 tokens @ ..,
@@ -90,9 +91,11 @@ pub(crate) fn extract_expressions_from_format_string(
 
             // Start building the new args
             let mut existing_args = existing_args.into_iter();
-            let mut new_tt_bits = vec![NodeOrToken::Token(make::tokens::literal(&new_fmt))];
+            let mut new_tt_bits = raw_tokens;
             let mut placeholder_indexes = vec![];
 
+            new_tt_bits.push(NodeOrToken::Token(make::tokens::literal(&new_fmt)));
+
             for arg in extracted_args {
                 if matches!(arg, Arg::Expr(_) | Arg::Placeholder) {
                     // insert ", " before each arg
@@ -150,7 +153,9 @@ pub(crate) fn extract_expressions_from_format_string(
                 }
 
                 // Add the final tabstop after the format literal
-                if let Some(NodeOrToken::Token(literal)) = new_tt.token_trees_and_tokens().nth(1) {
+                if let Some(NodeOrToken::Token(literal)) =
+                    new_tt.token_trees_and_tokens().nth(1 + format_string_index)
+                {
                     let annotation = edit.make_tabstop_after(cap);
                     editor.add_annotation(literal, annotation);
                 }
@@ -163,6 +168,17 @@ pub(crate) fn extract_expressions_from_format_string(
     Some(())
 }
 
+fn format_str_index(
+    raw_tokens: &[NodeOrToken<TokenTree, SyntaxToken>],
+    fmt_string: &ast::String,
+) -> usize {
+    let fmt_string = fmt_string.syntax();
+    raw_tokens
+        .iter()
+        .position(|tt| tt.as_token().is_some_and(|tt| tt == fmt_string))
+        .unwrap_or_default()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -186,6 +202,24 @@ fn main() {
         );
     }
 
+    #[test]
+    fn multiple_middle_arg_on_write() {
+        check_assist(
+            extract_expressions_from_format_string,
+            r#"
+//- minicore: write
+fn main() {
+    write!(writer(), "{} {x + 1:b} {}$0", y + 2, 2);
+}
+"#,
+            r#"
+fn main() {
+    write!(writer(), "{} {:b} {}"$0, y + 2, x + 1, 2);
+}
+"#,
+        );
+    }
+
     #[test]
     fn single_arg() {
         check_assist(

From 49044d0d4044960fbb96d47f51640bc5fa8004af Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 20 Jan 2025 16:57:30 +0100
Subject: [PATCH 0050/1889] Add support for trait associated items

---
 src/librustdoc/html/render/span_map.rs   | 61 ++++++++++++------------
 tests/rustdoc/jump-to-def-assoc-items.rs | 15 ++++++
 2 files changed, 46 insertions(+), 30 deletions(-)
 create mode 100644 tests/rustdoc/jump-to-def-assoc-items.rs

diff --git a/src/librustdoc/html/render/span_map.rs b/src/librustdoc/html/render/span_map.rs
index 846d3ad310ce4..ebbc61db688f7 100644
--- a/src/librustdoc/html/render/span_map.rs
+++ b/src/librustdoc/html/render/span_map.rs
@@ -4,9 +4,7 @@ use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{DefId, LOCAL_CRATE};
 use rustc_hir::intravisit::{self, Visitor};
-use rustc_hir::{
-    ExprKind, HirId, Item, ItemKind, Mod, Node, Pat, PatExpr, PatExprKind, PatKind, QPath,
-};
+use rustc_hir::{ExprKind, HirId, Item, ItemKind, Mod, Node, QPath};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::TyCtxt;
 use rustc_span::hygiene::MacroKind;
@@ -189,31 +187,6 @@ impl SpanMapVisitor<'_> {
             self.matches.insert(span, link);
         }
     }
-
-    fn handle_pat(&mut self, p: &Pat<'_>) {
-        let mut check_qpath = |qpath, hir_id| match qpath {
-            QPath::TypeRelative(_, path) if matches!(path.res, Res::Err) => {
-                self.infer_id(path.hir_id, Some(hir_id), qpath.span());
-            }
-            QPath::Resolved(_, path) => self.handle_path(path),
-            _ => {}
-        };
-        match p.kind {
-            PatKind::Binding(_, _, _, Some(p)) => self.handle_pat(p),
-            PatKind::Struct(qpath, _, _) | PatKind::TupleStruct(qpath, _, _) => {
-                check_qpath(qpath, p.hir_id)
-            }
-            PatKind::Expr(PatExpr { kind: PatExprKind::Path(qpath), hir_id, .. }) => {
-                check_qpath(*qpath, *hir_id)
-            }
-            PatKind::Or(pats) => {
-                for pat in pats {
-                    self.handle_pat(pat);
-                }
-            }
-            _ => {}
-        }
-    }
 }
 
 impl<'tcx> Visitor<'tcx> for SpanMapVisitor<'tcx> {
@@ -231,8 +204,36 @@ impl<'tcx> Visitor<'tcx> for SpanMapVisitor<'tcx> {
         intravisit::walk_path(self, path);
     }
 
-    fn visit_pat(&mut self, p: &Pat<'tcx>) {
-        self.handle_pat(p);
+    fn visit_qpath(&mut self, qpath: &QPath<'tcx>, id: HirId, span: Span) {
+        match *qpath {
+            QPath::TypeRelative(qself, path) => {
+                if matches!(path.res, Res::Err) {
+                    let tcx = self.tcx;
+                    let hir = tcx.hir();
+                    let body_id = hir.enclosing_body_owner(id);
+                    let typeck_results = tcx.typeck_body(hir.body_owned_by(body_id).id());
+                    let path = rustc_hir::Path {
+                        // We change the span to not include parens.
+                        span: span.with_hi(path.ident.span.hi()),
+                        res: typeck_results.qpath_res(qpath, id),
+                        segments: &[],
+                    };
+                    self.handle_path(&path);
+                } else {
+                    self.infer_id(path.hir_id, Some(id), span);
+                }
+
+                rustc_ast::visit::try_visit!(self.visit_ty(qself));
+                self.visit_path_segment(path);
+            }
+            QPath::Resolved(maybe_qself, path) => {
+                self.handle_path(path);
+
+                rustc_ast::visit::visit_opt!(self, visit_ty, maybe_qself);
+                self.visit_path(path, id)
+            }
+            _ => {}
+        }
     }
 
     fn visit_mod(&mut self, m: &'tcx Mod<'tcx>, span: Span, id: HirId) {
diff --git a/tests/rustdoc/jump-to-def-assoc-items.rs b/tests/rustdoc/jump-to-def-assoc-items.rs
new file mode 100644
index 0000000000000..1229c36317253
--- /dev/null
+++ b/tests/rustdoc/jump-to-def-assoc-items.rs
@@ -0,0 +1,15 @@
+//@ compile-flags: -Zunstable-options --generate-link-to-definition
+
+#![crate_name = "foo"]
+
+pub enum Ty {
+    Var,
+}
+
+//@ has 'src/foo/jump-to-def-assoc-items.rs.html'
+//@ has - '//a[@href="#6"]' 'Self::Var'
+impl Ty {
+    fn f() {
+        let _ = Self::Var;
+    }
+}

From f1649a4e4379aa0f5eb1181ca8e04c7790c21e5e Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sun, 26 Jan 2025 21:24:36 +0100
Subject: [PATCH 0051/1889] Better handling of paths in link to def feature

---
 src/librustdoc/html/highlight.rs              | 120 +++++++++++-------
 src/librustdoc/html/render/span_map.rs        |  70 ++++++----
 tests/rustdoc/jump-to-def-assoc-items.rs      |  53 +++++++-
 .../jump-to-def-doc-links-calls.rs            |   4 +-
 tests/rustdoc/jump-to-def/jump-to-def-pats.rs |  10 +-
 .../jump-to-def/jump-to-non-local-method.rs   |   7 +-
 .../check-source-code-urls-to-def.rs          |   2 +-
 7 files changed, 175 insertions(+), 91 deletions(-)

diff --git a/src/librustdoc/html/highlight.rs b/src/librustdoc/html/highlight.rs
index 272180fb9904c..c88db697be1f7 100644
--- a/src/librustdoc/html/highlight.rs
+++ b/src/librustdoc/html/highlight.rs
@@ -1059,6 +1059,64 @@ fn string<T: Display, W: Write>(
     }
 }
 
+fn generate_link_to_def(
+    out: &mut impl Write,
+    text_s: &str,
+    klass: Class,
+    href_context: &Option<HrefContext<'_, '_>>,
+    def_span: Span,
+    open_tag: bool,
+) -> bool {
+    if let Some(href_context) = href_context
+        && let Some(href) =
+            href_context.context.shared.span_correspondence_map.get(&def_span).and_then(|href| {
+                let context = href_context.context;
+                // FIXME: later on, it'd be nice to provide two links (if possible) for all items:
+                // one to the documentation page and one to the source definition.
+                // FIXME: currently, external items only generate a link to their documentation,
+                // a link to their definition can be generated using this:
+                // https://github.com/rust-lang/rust/blob/60f1a2fc4b535ead9c85ce085fdce49b1b097531/src/librustdoc/html/render/context.rs#L315-L338
+                match href {
+                    LinkFromSrc::Local(span) => {
+                        context.href_from_span_relative(*span, &href_context.current_href)
+                    }
+                    LinkFromSrc::External(def_id) => {
+                        format::href_with_root_path(*def_id, context, Some(href_context.root_path))
+                            .ok()
+                            .map(|(url, _, _)| url)
+                    }
+                    LinkFromSrc::Primitive(prim) => format::href_with_root_path(
+                        PrimitiveType::primitive_locations(context.tcx())[prim],
+                        context,
+                        Some(href_context.root_path),
+                    )
+                    .ok()
+                    .map(|(url, _, _)| url),
+                    LinkFromSrc::Doc(def_id) => {
+                        format::href_with_root_path(*def_id, context, Some(href_context.root_path))
+                            .ok()
+                            .map(|(doc_link, _, _)| doc_link)
+                    }
+                }
+            })
+    {
+        if !open_tag {
+            // We're already inside an element which has the same klass, no need to give it
+            // again.
+            write!(out, "<a href=\"{href}\">{text_s}").unwrap();
+        } else {
+            let klass_s = klass.as_html();
+            if klass_s.is_empty() {
+                write!(out, "<a href=\"{href}\">{text_s}").unwrap();
+            } else {
+                write!(out, "<a class=\"{klass_s}\" href=\"{href}\">{text_s}").unwrap();
+            }
+        }
+        return true;
+    }
+    false
+}
+
 /// This function writes `text` into `out` with some modifications depending on `klass`:
 ///
 /// * If `klass` is `None`, `text` is written into `out` with no modification.
@@ -1088,10 +1146,14 @@ fn string_without_closing_tag<T: Display>(
         return Some("</span>");
     };
 
+    let mut added_links = false;
     let mut text_s = text.to_string();
     if text_s.contains("::") {
+        let mut span = def_span.with_hi(def_span.lo());
         text_s = text_s.split("::").intersperse("::").fold(String::new(), |mut path, t| {
+            span = span.with_hi(span.hi() + BytePos(t.len() as _));
             match t {
+                "::" => write!(&mut path, "::"),
                 "self" | "Self" => write!(
                     &mut path,
                     "<span class=\"{klass}\">{t}</span>",
@@ -1104,58 +1166,24 @@ fn string_without_closing_tag<T: Display>(
                         klass = Class::KeyWord.as_html(),
                     )
                 }
-                t => write!(&mut path, "{t}"),
+                t => {
+                    if !t.is_empty()
+                        && generate_link_to_def(&mut path, t, klass, href_context, span, open_tag)
+                    {
+                        added_links = true;
+                        write!(&mut path, "</a>")
+                    } else {
+                        write!(&mut path, "{t}")
+                    }
+                }
             }
             .expect("Failed to build source HTML path");
+            span = span.with_lo(span.lo() + BytePos(t.len() as _));
             path
         });
     }
 
-    if let Some(href_context) = href_context
-        && let Some(href) = href_context.context.shared.span_correspondence_map.get(&def_span)
-        && let Some(href) = {
-            let context = href_context.context;
-            // FIXME: later on, it'd be nice to provide two links (if possible) for all items:
-            // one to the documentation page and one to the source definition.
-            // FIXME: currently, external items only generate a link to their documentation,
-            // a link to their definition can be generated using this:
-            // https://github.com/rust-lang/rust/blob/60f1a2fc4b535ead9c85ce085fdce49b1b097531/src/librustdoc/html/render/context.rs#L315-L338
-            match href {
-                LinkFromSrc::Local(span) => {
-                    context.href_from_span_relative(*span, &href_context.current_href)
-                }
-                LinkFromSrc::External(def_id) => {
-                    format::href_with_root_path(*def_id, context, Some(href_context.root_path))
-                        .ok()
-                        .map(|(url, _, _)| url)
-                }
-                LinkFromSrc::Primitive(prim) => format::href_with_root_path(
-                    PrimitiveType::primitive_locations(context.tcx())[prim],
-                    context,
-                    Some(href_context.root_path),
-                )
-                .ok()
-                .map(|(url, _, _)| url),
-                LinkFromSrc::Doc(def_id) => {
-                    format::href_with_root_path(*def_id, context, Some(href_context.root_path))
-                        .ok()
-                        .map(|(doc_link, _, _)| doc_link)
-                }
-            }
-        }
-    {
-        if !open_tag {
-            // We're already inside an element which has the same klass, no need to give it
-            // again.
-            write!(out, "<a href=\"{href}\">{text_s}").unwrap();
-        } else {
-            let klass_s = klass.as_html();
-            if klass_s.is_empty() {
-                write!(out, "<a href=\"{href}\">{text_s}").unwrap();
-            } else {
-                write!(out, "<a class=\"{klass_s}\" href=\"{href}\">{text_s}").unwrap();
-            }
-        }
+    if !added_links && generate_link_to_def(out, &text_s, klass, href_context, def_span, open_tag) {
         return Some("</a>");
     }
     if !open_tag {
diff --git a/src/librustdoc/html/render/span_map.rs b/src/librustdoc/html/render/span_map.rs
index ebbc61db688f7..342cf5073f716 100644
--- a/src/librustdoc/html/render/span_map.rs
+++ b/src/librustdoc/html/render/span_map.rs
@@ -65,7 +65,7 @@ struct SpanMapVisitor<'tcx> {
 
 impl SpanMapVisitor<'_> {
     /// This function is where we handle `hir::Path` elements and add them into the "span map".
-    fn handle_path(&mut self, path: &rustc_hir::Path<'_>) {
+    fn handle_path(&mut self, path: &rustc_hir::Path<'_>, only_use_last_segment: bool) {
         match path.res {
             // FIXME: For now, we handle `DefKind` if it's not a `DefKind::TyParam`.
             // Would be nice to support them too alongside the other `DefKind`
@@ -77,24 +77,36 @@ impl SpanMapVisitor<'_> {
                     LinkFromSrc::External(def_id)
                 };
                 // In case the path ends with generics, we remove them from the span.
-                let span = path
-                    .segments
-                    .last()
-                    .map(|last| {
-                        // In `use` statements, the included item is not in the path segments.
-                        // However, it doesn't matter because you can't have generics on `use`
-                        // statements.
-                        if path.span.contains(last.ident.span) {
-                            path.span.with_hi(last.ident.span.hi())
-                        } else {
-                            path.span
-                        }
-                    })
-                    .unwrap_or(path.span);
+                let span = if only_use_last_segment
+                    && let Some(path_span) = path.segments.last().map(|segment| segment.ident.span)
+                {
+                    path_span
+                } else {
+                    path.segments
+                        .last()
+                        .map(|last| {
+                            // In `use` statements, the included item is not in the path segments.
+                            // However, it doesn't matter because you can't have generics on `use`
+                            // statements.
+                            if path.span.contains(last.ident.span) {
+                                path.span.with_hi(last.ident.span.hi())
+                            } else {
+                                path.span
+                            }
+                        })
+                        .unwrap_or(path.span)
+                };
                 self.matches.insert(span, link);
             }
             Res::Local(_) if let Some(span) = self.tcx.hir_res_span(path.res) => {
-                self.matches.insert(path.span, LinkFromSrc::Local(clean::Span::new(span)));
+                let path_span = if only_use_last_segment
+                    && let Some(path_span) = path.segments.last().map(|segment| segment.ident.span)
+                {
+                    path_span
+                } else {
+                    path.span
+                };
+                self.matches.insert(path_span, LinkFromSrc::Local(clean::Span::new(span)));
             }
             Res::PrimTy(p) => {
                 // FIXME: Doesn't handle "path-like" primitives like arrays or tuples.
@@ -200,37 +212,41 @@ impl<'tcx> Visitor<'tcx> for SpanMapVisitor<'tcx> {
         if self.handle_macro(path.span) {
             return;
         }
-        self.handle_path(path);
+        self.handle_path(path, false);
         intravisit::walk_path(self, path);
     }
 
-    fn visit_qpath(&mut self, qpath: &QPath<'tcx>, id: HirId, span: Span) {
+    fn visit_qpath(&mut self, qpath: &QPath<'tcx>, id: HirId, _span: Span) {
         match *qpath {
             QPath::TypeRelative(qself, path) => {
                 if matches!(path.res, Res::Err) {
                     let tcx = self.tcx;
-                    let hir = tcx.hir();
-                    let body_id = hir.enclosing_body_owner(id);
-                    let typeck_results = tcx.typeck_body(hir.body_owned_by(body_id).id());
+                    let body_id = tcx.hir_enclosing_body_owner(id);
+                    let typeck_results = tcx.typeck_body(tcx.hir_body_owned_by(body_id).id());
                     let path = rustc_hir::Path {
                         // We change the span to not include parens.
-                        span: span.with_hi(path.ident.span.hi()),
+                        span: path.ident.span,
                         res: typeck_results.qpath_res(qpath, id),
                         segments: &[],
                     };
-                    self.handle_path(&path);
+                    self.handle_path(&path, false);
                 } else {
-                    self.infer_id(path.hir_id, Some(id), span);
+                    self.infer_id(path.hir_id, Some(id), path.ident.span);
                 }
 
-                rustc_ast::visit::try_visit!(self.visit_ty(qself));
+                if let Some(qself) = qself.try_as_ambig_ty() {
+                    rustc_ast::visit::try_visit!(self.visit_ty(qself));
+                }
                 self.visit_path_segment(path);
             }
             QPath::Resolved(maybe_qself, path) => {
-                self.handle_path(path);
+                self.handle_path(path, true);
 
+                let maybe_qself = maybe_qself.and_then(|maybe_qself| maybe_qself.try_as_ambig_ty());
                 rustc_ast::visit::visit_opt!(self, visit_ty, maybe_qself);
-                self.visit_path(path, id)
+                if !self.handle_macro(path.span) {
+                    intravisit::walk_path(self, path);
+                }
             }
             _ => {}
         }
diff --git a/tests/rustdoc/jump-to-def-assoc-items.rs b/tests/rustdoc/jump-to-def-assoc-items.rs
index 1229c36317253..8cbf990628386 100644
--- a/tests/rustdoc/jump-to-def-assoc-items.rs
+++ b/tests/rustdoc/jump-to-def-assoc-items.rs
@@ -1,15 +1,54 @@
+// This test ensures that patterns also get a link generated.
+
 //@ compile-flags: -Zunstable-options --generate-link-to-definition
 
 #![crate_name = "foo"]
 
-pub enum Ty {
-    Var,
+//@ has 'src/foo/jump-to-def-assoc-items.rs.html'
+
+pub trait Trait {
+    type T;
+}
+pub trait Another {
+    type T;
+    const X: u32;
 }
 
-//@ has 'src/foo/jump-to-def-assoc-items.rs.html'
-//@ has - '//a[@href="#6"]' 'Self::Var'
-impl Ty {
-    fn f() {
-        let _ = Self::Var;
+pub struct Foo;
+
+impl Foo {
+    pub fn new() -> Self { Foo }
+}
+
+pub struct C;
+
+impl C {
+    pub fn wat() {}
+}
+
+pub struct Bar;
+impl Trait for Bar {
+    type T = Foo;
+}
+impl Another for Bar {
+    type T = C;
+    const X: u32 = 12;
+}
+
+pub fn bar() {
+    //@ has - '//a[@href="#20"]' 'new'
+    <Bar as Trait>::T::new();
+    //@ has - '//a[@href="#26"]' 'wat'
+    <Bar as Another>::T::wat();
+
+    match 12u32 {
+        //@ has - '//a[@href="#14"]' 'X'
+        <Bar as Another>::X => {}
+        _ => {}
     }
 }
+
+pub struct Far {
+        //@ has - '//a[@href="#10"]' 'T'
+    x: <Bar as Trait>::T,
+}
diff --git a/tests/rustdoc/jump-to-def/jump-to-def-doc-links-calls.rs b/tests/rustdoc/jump-to-def/jump-to-def-doc-links-calls.rs
index 618569787733c..55e59f23b6f28 100644
--- a/tests/rustdoc/jump-to-def/jump-to-def-doc-links-calls.rs
+++ b/tests/rustdoc/jump-to-def/jump-to-def-doc-links-calls.rs
@@ -8,7 +8,7 @@
 pub struct Bar;
 
 impl std::default::Default for Bar {
-    //@ has - '//a[@href="#20-22"]' 'Self::new'
+    //@ has - '//a[@href="#20-22"]' 'new'
     fn default() -> Self {
         Self::new()
     }
@@ -16,7 +16,7 @@ impl std::default::Default for Bar {
 
 //@ has - '//a[@href="#8"]' 'Bar'
 impl Bar {
-     //@ has - '//a[@href="#24-26"]' 'Self::bar'
+     //@ has - '//a[@href="#24-26"]' 'bar'
      pub fn new()-> Self {
          Self::bar()
      }
diff --git a/tests/rustdoc/jump-to-def/jump-to-def-pats.rs b/tests/rustdoc/jump-to-def/jump-to-def-pats.rs
index 147902b44cf5c..852eba208db01 100644
--- a/tests/rustdoc/jump-to-def/jump-to-def-pats.rs
+++ b/tests/rustdoc/jump-to-def/jump-to-def-pats.rs
@@ -30,13 +30,13 @@ pub fn foo() -> Result<(), ()> {
 impl<T, E> fmt::Display for MyEnum<T, E> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            //@ has - '//a[@href="#12"]' 'Self::Ok'
+            //@ has - '//a[@href="#12"]' 'Ok'
             Self::Ok(_) => f.write_str("MyEnum::Ok"),
-            //@ has - '//a[@href="#13"]' 'MyEnum::Err'
+            //@ has - '//a[@href="#13"]' 'Err'
             MyEnum::Err(_) => f.write_str("MyEnum::Err"),
-            //@ has - '//a[@href="#14"]' 'Self::Some'
+            //@ has - '//a[@href="#14"]' 'Some'
             Self::Some(_) => f.write_str("MyEnum::Some"),
-            //@ has - '//a[@href="#15"]' 'Self::None'
+            //@ has - '//a[@href="#15"]' 'None'
             Self::None => f.write_str("MyEnum::None"),
         }
     }
@@ -45,7 +45,7 @@ impl<T, E> fmt::Display for MyEnum<T, E> {
 impl X {
     fn p(&self) -> &str {
         match self {
-            //@ has - '//a[@href="#19"]' 'Self::A'
+            //@ has - '//a[@href="#19"]' 'A'
             Self::A => "X::A",
         }
     }
diff --git a/tests/rustdoc/jump-to-def/jump-to-non-local-method.rs b/tests/rustdoc/jump-to-def/jump-to-non-local-method.rs
index e2f530425f0db..1d6d6b8d18faa 100644
--- a/tests/rustdoc/jump-to-def/jump-to-non-local-method.rs
+++ b/tests/rustdoc/jump-to-def/jump-to-non-local-method.rs
@@ -21,9 +21,10 @@ pub fn bar2<T: Read>(readable: T) {
 }
 
 pub fn bar() {
-    //@ has - '//a[@href="{{channel}}/core/sync/atomic/struct.AtomicIsize.html#method.new"]' 'AtomicIsize::new'
+    //@ has - '//a[@href="{{channel}}/core/sync/atomic/struct.AtomicIsize.html"]' 'AtomicIsize'
+    //@ has - '//a[@href="{{channel}}/core/sync/atomic/struct.AtomicIsize.html#method.new"]' 'new'
     let _ = AtomicIsize::new(0);
-    //@ has - '//a[@href="#48"]' 'local_private'
+    //@ has - '//a[@href="#49"]' 'local_private'
     local_private();
 }
 
@@ -39,7 +40,7 @@ pub fn macro_call() -> Result<(), ()> {
 }
 
 pub fn variant() {
-    //@ has - '//a[@href="{{channel}}/core/cmp/enum.Ordering.html#variant.Less"]' 'Ordering::Less'
+    //@ has - '//a[@href="{{channel}}/core/cmp/enum.Ordering.html#variant.Less"]' 'Less'
     let _ = Ordering::Less;
     //@ has - '//a[@href="{{channel}}/core/marker/struct.PhantomData.html"]' 'PhantomData'
     let _: PhantomData::<usize> = PhantomData;
diff --git a/tests/rustdoc/source-code-pages/check-source-code-urls-to-def.rs b/tests/rustdoc/source-code-pages/check-source-code-urls-to-def.rs
index d701b88bf9fd0..a7b944fa2f6fc 100644
--- a/tests/rustdoc/source-code-pages/check-source-code-urls-to-def.rs
+++ b/tests/rustdoc/source-code-pages/check-source-code-urls-to-def.rs
@@ -34,7 +34,7 @@ fn babar() {}
 // The 5 links to line 23 and the line 23 itself.
 //@ count - '//pre[@class="rust"]//a[@href="#23"]' 6
 //@ has - '//pre[@class="rust"]//a[@href="../../source_code/struct.SourceCode.html"]' \
-//        'source_code::SourceCode'
+//        'SourceCode'
 pub fn foo(a: u32, b: &str, c: String, d: Foo, e: bar::Bar, f: source_code::SourceCode) {
     let x = 12;
     let y: Foo = Foo;

From 1a6d6363d090961a1efe513d413f5b51ecd81ab8 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sun, 26 Jan 2025 21:50:50 +0100
Subject: [PATCH 0052/1889] Update to last rustc_hir Visitor changes

---
 src/librustdoc/html/render/span_map.rs | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/src/librustdoc/html/render/span_map.rs b/src/librustdoc/html/render/span_map.rs
index 342cf5073f716..505797ccc0b2f 100644
--- a/src/librustdoc/html/render/span_map.rs
+++ b/src/librustdoc/html/render/span_map.rs
@@ -3,7 +3,7 @@ use std::path::{Path, PathBuf};
 use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{DefId, LOCAL_CRATE};
-use rustc_hir::intravisit::{self, Visitor};
+use rustc_hir::intravisit::{self, Visitor, VisitorExt};
 use rustc_hir::{ExprKind, HirId, Item, ItemKind, Mod, Node, QPath};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::TyCtxt;
@@ -234,16 +234,13 @@ impl<'tcx> Visitor<'tcx> for SpanMapVisitor<'tcx> {
                     self.infer_id(path.hir_id, Some(id), path.ident.span);
                 }
 
-                if let Some(qself) = qself.try_as_ambig_ty() {
-                    rustc_ast::visit::try_visit!(self.visit_ty(qself));
-                }
+                rustc_ast::visit::try_visit!(self.visit_ty_unambig(qself));
                 self.visit_path_segment(path);
             }
             QPath::Resolved(maybe_qself, path) => {
                 self.handle_path(path, true);
 
-                let maybe_qself = maybe_qself.and_then(|maybe_qself| maybe_qself.try_as_ambig_ty());
-                rustc_ast::visit::visit_opt!(self, visit_ty, maybe_qself);
+                rustc_ast::visit::visit_opt!(self, visit_ty_unambig, maybe_qself);
                 if !self.handle_macro(path.span) {
                     intravisit::walk_path(self, path);
                 }

From d528a49fd7c0447cc51406908fb13fe055d273aa Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sun, 4 May 2025 19:08:23 +0200
Subject: [PATCH 0053/1889] Fix panic if an item does not have a body

---
 src/librustdoc/html/render/span_map.rs | 32 ++++++++++++++++++--------
 tests/rustdoc/jump-to-def-ice.rs       | 24 +++++++++++++++++++
 2 files changed, 46 insertions(+), 10 deletions(-)
 create mode 100644 tests/rustdoc/jump-to-def-ice.rs

diff --git a/src/librustdoc/html/render/span_map.rs b/src/librustdoc/html/render/span_map.rs
index 505797ccc0b2f..6906e6e30ff86 100644
--- a/src/librustdoc/html/render/span_map.rs
+++ b/src/librustdoc/html/render/span_map.rs
@@ -2,7 +2,7 @@ use std::path::{Path, PathBuf};
 
 use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
 use rustc_hir::def::{DefKind, Res};
-use rustc_hir::def_id::{DefId, LOCAL_CRATE};
+use rustc_hir::def_id::{DefId, LOCAL_CRATE, LocalDefId};
 use rustc_hir::intravisit::{self, Visitor, VisitorExt};
 use rustc_hir::{ExprKind, HirId, Item, ItemKind, Mod, Node, QPath};
 use rustc_middle::hir::nested_filter;
@@ -201,6 +201,17 @@ impl SpanMapVisitor<'_> {
     }
 }
 
+// This is a reimplementation of `hir_enclosing_body_owner` which allows to fail without
+// panicking.
+fn hir_enclosing_body_owner(tcx: TyCtxt<'_>, hir_id: HirId) -> Option<LocalDefId> {
+    for (_, node) in tcx.hir_parent_iter(hir_id) {
+        if let Some((def_id, _)) = node.associated_body() {
+            return Some(def_id);
+        }
+    }
+    None
+}
+
 impl<'tcx> Visitor<'tcx> for SpanMapVisitor<'tcx> {
     type NestedFilter = nested_filter::All;
 
@@ -221,15 +232,16 @@ impl<'tcx> Visitor<'tcx> for SpanMapVisitor<'tcx> {
             QPath::TypeRelative(qself, path) => {
                 if matches!(path.res, Res::Err) {
                     let tcx = self.tcx;
-                    let body_id = tcx.hir_enclosing_body_owner(id);
-                    let typeck_results = tcx.typeck_body(tcx.hir_body_owned_by(body_id).id());
-                    let path = rustc_hir::Path {
-                        // We change the span to not include parens.
-                        span: path.ident.span,
-                        res: typeck_results.qpath_res(qpath, id),
-                        segments: &[],
-                    };
-                    self.handle_path(&path, false);
+                    if let Some(body_id) = hir_enclosing_body_owner(tcx, id) {
+                        let typeck_results = tcx.typeck_body(tcx.hir_body_owned_by(body_id).id());
+                        let path = rustc_hir::Path {
+                            // We change the span to not include parens.
+                            span: path.ident.span,
+                            res: typeck_results.qpath_res(qpath, id),
+                            segments: &[],
+                        };
+                        self.handle_path(&path, false);
+                    }
                 } else {
                     self.infer_id(path.hir_id, Some(id), path.ident.span);
                 }
diff --git a/tests/rustdoc/jump-to-def-ice.rs b/tests/rustdoc/jump-to-def-ice.rs
new file mode 100644
index 0000000000000..5578b9af3d74f
--- /dev/null
+++ b/tests/rustdoc/jump-to-def-ice.rs
@@ -0,0 +1,24 @@
+// This test ensures that items with no body don't panic when generating
+// jump to def links.
+
+//@ compile-flags: -Zunstable-options --generate-link-to-definition
+
+#![crate_name = "foo"]
+
+//@ has 'src/foo/jump-to-def-ice.rs.html'
+
+pub trait A {
+    type T;
+    type U;
+}
+
+impl A for () {
+    type T = Self::U;
+    type U = ();
+}
+
+pub trait C {
+    type X;
+}
+
+pub struct F<T: C>(pub T::X);

From b9f2bb7dd11f23c7922fdc024a270bf8a4675616 Mon Sep 17 00:00:00 2001
From: Shoyu Vanilla <modulo641@gmail.com>
Date: Sun, 10 Aug 2025 16:43:36 +0900
Subject: [PATCH 0054/1889] internal: Make flycheck generational

---
 .../crates/rust-analyzer/src/diagnostics.rs   |  47 ++++++--
 .../crates/rust-analyzer/src/flycheck.rs      | 112 ++++++++++++++----
 .../crates/rust-analyzer/src/main_loop.rs     |  24 +++-
 .../crates/rust-analyzer/src/reload.rs        |   3 +
 4 files changed, 148 insertions(+), 38 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/diagnostics.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/diagnostics.rs
index 438a2a0ba1ea1..cd7c632d105e0 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/diagnostics.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/diagnostics.rs
@@ -26,6 +26,19 @@ pub struct DiagnosticsMapConfig {
 
 pub(crate) type DiagnosticsGeneration = usize;
 
+#[derive(Debug, Clone)]
+pub(crate) struct WorkspaceFlycheckDiagnostic {
+    pub(crate) generation: DiagnosticsGeneration,
+    pub(crate) per_package:
+        FxHashMap<Option<Arc<PackageId>>, FxHashMap<FileId, Vec<lsp_types::Diagnostic>>>,
+}
+
+impl WorkspaceFlycheckDiagnostic {
+    fn new(generation: DiagnosticsGeneration) -> Self {
+        WorkspaceFlycheckDiagnostic { generation, per_package: Default::default() }
+    }
+}
+
 #[derive(Debug, Default, Clone)]
 pub(crate) struct DiagnosticCollection {
     // FIXME: should be FxHashMap<FileId, Vec<ra_id::Diagnostic>>
@@ -33,9 +46,7 @@ pub(crate) struct DiagnosticCollection {
         FxHashMap<FileId, (DiagnosticsGeneration, Vec<lsp_types::Diagnostic>)>,
     pub(crate) native_semantic:
         FxHashMap<FileId, (DiagnosticsGeneration, Vec<lsp_types::Diagnostic>)>,
-    // FIXME: should be Vec<flycheck::Diagnostic>
-    pub(crate) check:
-        Vec<FxHashMap<Option<Arc<PackageId>>, FxHashMap<FileId, Vec<lsp_types::Diagnostic>>>>,
+    pub(crate) check: Vec<WorkspaceFlycheckDiagnostic>,
     pub(crate) check_fixes: CheckFixes,
     changes: FxHashSet<FileId>,
     /// Counter for supplying a new generation number for diagnostics.
@@ -57,7 +68,7 @@ impl DiagnosticCollection {
         let Some(check) = self.check.get_mut(flycheck_id) else {
             return;
         };
-        self.changes.extend(check.drain().flat_map(|(_, v)| v.into_keys()));
+        self.changes.extend(check.per_package.drain().flat_map(|(_, v)| v.into_keys()));
         if let Some(fixes) = Arc::make_mut(&mut self.check_fixes).get_mut(flycheck_id) {
             fixes.clear();
         }
@@ -66,7 +77,9 @@ impl DiagnosticCollection {
     pub(crate) fn clear_check_all(&mut self) {
         Arc::make_mut(&mut self.check_fixes).clear();
         self.changes.extend(
-            self.check.iter_mut().flat_map(|it| it.drain().flat_map(|(_, v)| v.into_keys())),
+            self.check
+                .iter_mut()
+                .flat_map(|it| it.per_package.drain().flat_map(|(_, v)| v.into_keys())),
         )
     }
 
@@ -79,7 +92,7 @@ impl DiagnosticCollection {
             return;
         };
         let package_id = Some(package_id);
-        if let Some(checks) = check.remove(&package_id) {
+        if let Some(checks) = check.per_package.remove(&package_id) {
             self.changes.extend(checks.into_keys());
         }
         if let Some(fixes) = Arc::make_mut(&mut self.check_fixes).get_mut(flycheck_id) {
@@ -87,6 +100,16 @@ impl DiagnosticCollection {
         }
     }
 
+    pub(crate) fn clear_check_older_than(
+        &mut self,
+        flycheck_id: usize,
+        generation: DiagnosticsGeneration,
+    ) {
+        if self.check[flycheck_id].generation < generation {
+            self.clear_check(flycheck_id);
+        }
+    }
+
     pub(crate) fn clear_native_for(&mut self, file_id: FileId) {
         self.native_syntax.remove(&file_id);
         self.native_semantic.remove(&file_id);
@@ -96,15 +119,23 @@ impl DiagnosticCollection {
     pub(crate) fn add_check_diagnostic(
         &mut self,
         flycheck_id: usize,
+        generation: DiagnosticsGeneration,
         package_id: &Option<Arc<PackageId>>,
         file_id: FileId,
         diagnostic: lsp_types::Diagnostic,
         fix: Option<Box<Fix>>,
     ) {
         if self.check.len() <= flycheck_id {
-            self.check.resize_with(flycheck_id + 1, Default::default);
+            self.check
+                .resize_with(flycheck_id + 1, || WorkspaceFlycheckDiagnostic::new(generation));
+        }
+
+        // Getting message from old generation. Might happen in restarting checks.
+        if self.check[flycheck_id].generation > generation {
+            return;
         }
         let diagnostics = self.check[flycheck_id]
+            .per_package
             .entry(package_id.clone())
             .or_default()
             .entry(file_id)
@@ -177,7 +208,7 @@ impl DiagnosticCollection {
         let check = self
             .check
             .iter()
-            .flat_map(|it| it.values())
+            .flat_map(|it| it.per_package.values())
             .filter_map(move |it| it.get(&file_id))
             .flatten();
         native_syntax.chain(native_semantic).chain(check)
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs
index e4e0bcdc1cd08..233bedec6900a 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs
@@ -1,7 +1,12 @@
 //! Flycheck provides the functionality needed to run `cargo check` to provide
 //! LSP diagnostics based on the output of the command.
 
-use std::{fmt, io, process::Command, time::Duration};
+use std::{
+    fmt, io,
+    process::Command,
+    sync::atomic::{AtomicUsize, Ordering},
+    time::Duration,
+};
 
 use cargo_metadata::PackageId;
 use crossbeam_channel::{Receiver, Sender, select_biased, unbounded};
@@ -18,7 +23,10 @@ pub(crate) use cargo_metadata::diagnostic::{
 use toolchain::Tool;
 use triomphe::Arc;
 
-use crate::command::{CargoParser, CommandHandle};
+use crate::{
+    command::{CargoParser, CommandHandle},
+    diagnostics::DiagnosticsGeneration,
+};
 
 #[derive(Clone, Debug, Default, PartialEq, Eq)]
 pub(crate) enum InvocationStrategy {
@@ -138,36 +146,54 @@ pub(crate) struct FlycheckHandle {
     sender: Sender<StateChange>,
     _thread: stdx::thread::JoinHandle,
     id: usize,
+    generation: AtomicUsize,
 }
 
 impl FlycheckHandle {
     pub(crate) fn spawn(
         id: usize,
+        generation: DiagnosticsGeneration,
         sender: Sender<FlycheckMessage>,
         config: FlycheckConfig,
         sysroot_root: Option<AbsPathBuf>,
         workspace_root: AbsPathBuf,
         manifest_path: Option<AbsPathBuf>,
     ) -> FlycheckHandle {
-        let actor =
-            FlycheckActor::new(id, sender, config, sysroot_root, workspace_root, manifest_path);
+        let actor = FlycheckActor::new(
+            id,
+            generation,
+            sender,
+            config,
+            sysroot_root,
+            workspace_root,
+            manifest_path,
+        );
         let (sender, receiver) = unbounded::<StateChange>();
         let thread =
             stdx::thread::Builder::new(stdx::thread::ThreadIntent::Worker, format!("Flycheck{id}"))
                 .spawn(move || actor.run(receiver))
                 .expect("failed to spawn thread");
-        FlycheckHandle { id, sender, _thread: thread }
+        FlycheckHandle { id, generation: generation.into(), sender, _thread: thread }
     }
 
     /// Schedule a re-start of the cargo check worker to do a workspace wide check.
     pub(crate) fn restart_workspace(&self, saved_file: Option<AbsPathBuf>) {
-        self.sender.send(StateChange::Restart { package: None, saved_file, target: None }).unwrap();
+        let generation = self.generation.fetch_add(1, Ordering::Relaxed) + 1;
+        self.sender
+            .send(StateChange::Restart { generation, package: None, saved_file, target: None })
+            .unwrap();
     }
 
     /// Schedule a re-start of the cargo check worker to do a package wide check.
     pub(crate) fn restart_for_package(&self, package: String, target: Option<Target>) {
+        let generation = self.generation.fetch_add(1, Ordering::Relaxed) + 1;
         self.sender
-            .send(StateChange::Restart { package: Some(package), saved_file: None, target })
+            .send(StateChange::Restart {
+                generation,
+                package: Some(package),
+                saved_file: None,
+                target,
+            })
             .unwrap();
     }
 
@@ -179,23 +205,31 @@ impl FlycheckHandle {
     pub(crate) fn id(&self) -> usize {
         self.id
     }
+
+    pub(crate) fn generation(&self) -> DiagnosticsGeneration {
+        self.generation.load(Ordering::Relaxed)
+    }
+}
+
+#[derive(Debug)]
+pub(crate) enum ClearDiagnosticsKind {
+    All,
+    OlderThan(DiagnosticsGeneration),
+    Package(Arc<PackageId>),
 }
 
 pub(crate) enum FlycheckMessage {
     /// Request adding a diagnostic with fixes included to a file
     AddDiagnostic {
         id: usize,
+        generation: DiagnosticsGeneration,
         workspace_root: Arc<AbsPathBuf>,
         diagnostic: Diagnostic,
         package_id: Option<Arc<PackageId>>,
     },
 
     /// Request clearing all outdated diagnostics.
-    ClearDiagnostics {
-        id: usize,
-        /// The package whose diagnostics to clear, or if unspecified, all diagnostics.
-        package_id: Option<Arc<PackageId>>,
-    },
+    ClearDiagnostics { id: usize, kind: ClearDiagnosticsKind },
 
     /// Request check progress notification to client
     Progress {
@@ -208,18 +242,23 @@ pub(crate) enum FlycheckMessage {
 impl fmt::Debug for FlycheckMessage {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            FlycheckMessage::AddDiagnostic { id, workspace_root, diagnostic, package_id } => f
+            FlycheckMessage::AddDiagnostic {
+                id,
+                generation,
+                workspace_root,
+                diagnostic,
+                package_id,
+            } => f
                 .debug_struct("AddDiagnostic")
                 .field("id", id)
+                .field("generation", generation)
                 .field("workspace_root", workspace_root)
                 .field("package_id", package_id)
                 .field("diagnostic_code", &diagnostic.code.as_ref().map(|it| &it.code))
                 .finish(),
-            FlycheckMessage::ClearDiagnostics { id, package_id } => f
-                .debug_struct("ClearDiagnostics")
-                .field("id", id)
-                .field("package_id", package_id)
-                .finish(),
+            FlycheckMessage::ClearDiagnostics { id, kind } => {
+                f.debug_struct("ClearDiagnostics").field("id", id).field("kind", kind).finish()
+            }
             FlycheckMessage::Progress { id, progress } => {
                 f.debug_struct("Progress").field("id", id).field("progress", progress).finish()
             }
@@ -237,7 +276,12 @@ pub(crate) enum Progress {
 }
 
 enum StateChange {
-    Restart { package: Option<String>, saved_file: Option<AbsPathBuf>, target: Option<Target> },
+    Restart {
+        generation: DiagnosticsGeneration,
+        package: Option<String>,
+        saved_file: Option<AbsPathBuf>,
+        target: Option<Target>,
+    },
     Cancel,
 }
 
@@ -246,6 +290,7 @@ struct FlycheckActor {
     /// The workspace id of this flycheck instance.
     id: usize,
 
+    generation: DiagnosticsGeneration,
     sender: Sender<FlycheckMessage>,
     config: FlycheckConfig,
     manifest_path: Option<AbsPathBuf>,
@@ -283,6 +328,7 @@ pub(crate) const SAVED_FILE_PLACEHOLDER: &str = "$saved_file";
 impl FlycheckActor {
     fn new(
         id: usize,
+        generation: DiagnosticsGeneration,
         sender: Sender<FlycheckMessage>,
         config: FlycheckConfig,
         sysroot_root: Option<AbsPathBuf>,
@@ -292,6 +338,7 @@ impl FlycheckActor {
         tracing::info!(%id, ?workspace_root, "Spawning flycheck");
         FlycheckActor {
             id,
+            generation,
             sender,
             config,
             sysroot_root,
@@ -327,7 +374,12 @@ impl FlycheckActor {
                     tracing::debug!(flycheck_id = self.id, "flycheck cancelled");
                     self.cancel_check_process();
                 }
-                Event::RequestStateChange(StateChange::Restart { package, saved_file, target }) => {
+                Event::RequestStateChange(StateChange::Restart {
+                    generation,
+                    package,
+                    saved_file,
+                    target,
+                }) => {
                     // Cancel the previously spawned process
                     self.cancel_check_process();
                     while let Ok(restart) = inbox.recv_timeout(Duration::from_millis(50)) {
@@ -337,6 +389,8 @@ impl FlycheckActor {
                         }
                     }
 
+                    self.generation = generation;
+
                     let Some(command) =
                         self.check_command(package.as_deref(), saved_file.as_deref(), target)
                     else {
@@ -383,7 +437,16 @@ impl FlycheckActor {
                         // Clear everything for good measure
                         self.send(FlycheckMessage::ClearDiagnostics {
                             id: self.id,
-                            package_id: None,
+                            kind: ClearDiagnosticsKind::All,
+                        });
+                    } else if res.is_ok() {
+                        // We clear diagnostics for packages on
+                        // `[CargoCheckMessage::CompilerArtifact]` but there seem to be setups where
+                        // cargo may not report an artifact to our runner at all. To handle such
+                        // cases, clear stale diagnostics when flycheck completes successfully.
+                        self.send(FlycheckMessage::ClearDiagnostics {
+                            id: self.id,
+                            kind: ClearDiagnosticsKind::OlderThan(self.generation),
                         });
                     }
                     self.clear_diagnostics_state();
@@ -412,7 +475,7 @@ impl FlycheckActor {
                             );
                             self.send(FlycheckMessage::ClearDiagnostics {
                                 id: self.id,
-                                package_id: Some(package_id),
+                                kind: ClearDiagnosticsKind::Package(package_id),
                             });
                         }
                     }
@@ -435,7 +498,7 @@ impl FlycheckActor {
                                 );
                                 self.send(FlycheckMessage::ClearDiagnostics {
                                     id: self.id,
-                                    package_id: Some(package_id.clone()),
+                                    kind: ClearDiagnosticsKind::Package(package_id.clone()),
                                 });
                             }
                         } else if self.diagnostics_received
@@ -444,11 +507,12 @@ impl FlycheckActor {
                             self.diagnostics_received = DiagnosticsReceived::YesAndClearedForAll;
                             self.send(FlycheckMessage::ClearDiagnostics {
                                 id: self.id,
-                                package_id: None,
+                                kind: ClearDiagnosticsKind::All,
                             });
                         }
                         self.send(FlycheckMessage::AddDiagnostic {
                             id: self.id,
+                            generation: self.generation,
                             package_id,
                             workspace_root: self.root.clone(),
                             diagnostic,
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs
index f5932d8cff026..c6762f318326a 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs
@@ -20,7 +20,7 @@ use crate::{
     config::Config,
     diagnostics::{DiagnosticsGeneration, NativeDiagnosticsFetchKind, fetch_native_diagnostics},
     discover::{DiscoverArgument, DiscoverCommand, DiscoverProjectMessage},
-    flycheck::{self, FlycheckMessage},
+    flycheck::{self, ClearDiagnosticsKind, FlycheckMessage},
     global_state::{
         FetchBuildDataResponse, FetchWorkspaceRequest, FetchWorkspaceResponse, GlobalState,
         file_id_to_url, url_to_file_id,
@@ -1008,7 +1008,13 @@ impl GlobalState {
 
     fn handle_flycheck_msg(&mut self, message: FlycheckMessage) {
         match message {
-            FlycheckMessage::AddDiagnostic { id, workspace_root, diagnostic, package_id } => {
+            FlycheckMessage::AddDiagnostic {
+                id,
+                generation,
+                workspace_root,
+                diagnostic,
+                package_id,
+            } => {
                 let snap = self.snapshot();
                 let diagnostics = crate::diagnostics::to_proto::map_rust_diagnostic_to_lsp(
                     &self.config.diagnostics_map(None),
@@ -1020,6 +1026,7 @@ impl GlobalState {
                     match url_to_file_id(&self.vfs.read().0, &diag.url) {
                         Ok(Some(file_id)) => self.diagnostics.add_check_diagnostic(
                             id,
+                            generation,
                             &package_id,
                             file_id,
                             diag.diagnostic,
@@ -1035,12 +1042,17 @@ impl GlobalState {
                     };
                 }
             }
-            FlycheckMessage::ClearDiagnostics { id, package_id: None } => {
+            FlycheckMessage::ClearDiagnostics { id, kind: ClearDiagnosticsKind::All } => {
                 self.diagnostics.clear_check(id)
             }
-            FlycheckMessage::ClearDiagnostics { id, package_id: Some(package_id) } => {
-                self.diagnostics.clear_check_for_package(id, package_id)
-            }
+            FlycheckMessage::ClearDiagnostics {
+                id,
+                kind: ClearDiagnosticsKind::OlderThan(generation),
+            } => self.diagnostics.clear_check_older_than(id, generation),
+            FlycheckMessage::ClearDiagnostics {
+                id,
+                kind: ClearDiagnosticsKind::Package(package_id),
+            } => self.diagnostics.clear_check_for_package(id, package_id),
             FlycheckMessage::Progress { id, progress } => {
                 let (state, message) = match progress {
                     flycheck::Progress::DidStart => (Progress::Begin, None),
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/reload.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/reload.rs
index aa38aa72d44eb..f8f29eee126ed 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/reload.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/reload.rs
@@ -855,11 +855,13 @@ impl GlobalState {
                 invocation_strategy.clone()
             }
         };
+        let next_gen = self.flycheck.iter().map(|f| f.generation() + 1).max().unwrap_or_default();
 
         self.flycheck = match invocation_strategy {
             crate::flycheck::InvocationStrategy::Once => {
                 vec![FlycheckHandle::spawn(
                     0,
+                    next_gen,
                     sender,
                     config,
                     None,
@@ -898,6 +900,7 @@ impl GlobalState {
                     .map(|(id, (root, manifest_path), sysroot_root)| {
                         FlycheckHandle::spawn(
                             id,
+                            next_gen,
                             sender.clone(),
                             config.clone(),
                             sysroot_root,

From 25e767b0ee95d21b62d2fb509809946005081d40 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sun, 10 Aug 2025 15:49:22 +0200
Subject: [PATCH 0055/1889] Ignore impl associated types in jump to def feature

---
 src/librustdoc/html/render/span_map.rs       |  8 +++++++-
 tests/rustdoc/jump-to-def-ice-assoc-types.rs | 20 ++++++++++++++++++++
 2 files changed, 27 insertions(+), 1 deletion(-)
 create mode 100644 tests/rustdoc/jump-to-def-ice-assoc-types.rs

diff --git a/src/librustdoc/html/render/span_map.rs b/src/librustdoc/html/render/span_map.rs
index 6906e6e30ff86..e5bdc2a941c80 100644
--- a/src/librustdoc/html/render/span_map.rs
+++ b/src/librustdoc/html/render/span_map.rs
@@ -205,7 +205,13 @@ impl SpanMapVisitor<'_> {
 // panicking.
 fn hir_enclosing_body_owner(tcx: TyCtxt<'_>, hir_id: HirId) -> Option<LocalDefId> {
     for (_, node) in tcx.hir_parent_iter(hir_id) {
-        if let Some((def_id, _)) = node.associated_body() {
+        // FIXME: associated type impl items don't have an associated body, so we don't handle
+        // them currently.
+        if let Node::ImplItem(impl_item) = node
+            && matches!(impl_item.kind, rustc_hir::ImplItemKind::Type(_))
+        {
+            return None;
+        } else if let Some((def_id, _)) = node.associated_body() {
             return Some(def_id);
         }
     }
diff --git a/tests/rustdoc/jump-to-def-ice-assoc-types.rs b/tests/rustdoc/jump-to-def-ice-assoc-types.rs
new file mode 100644
index 0000000000000..9915c53668f0d
--- /dev/null
+++ b/tests/rustdoc/jump-to-def-ice-assoc-types.rs
@@ -0,0 +1,20 @@
+// This test ensures that associated types don't crash rustdoc jump to def.
+
+//@ compile-flags: -Zunstable-options --generate-link-to-definition
+
+
+#![crate_name = "foo"]
+
+//@ has 'src/foo/jump-to-def-ice-assoc-types.rs.html'
+
+pub trait Trait {
+    type Node;
+}
+
+pub fn y<G: Trait>() {
+    struct X<G>(G);
+
+    impl<G: Trait> Trait for X<G> {
+        type Node = G::Node;
+    }
+}

From f2c0c3dd44471e46ebb3823cc751c9c42aabc1aa Mon Sep 17 00:00:00 2001
From: Daniel Paoliello <danpao@microsoft.com>
Date: Sun, 10 Aug 2025 11:56:35 -0700
Subject: [PATCH 0056/1889] Add testing for Arm64EC Windows

---
 library/stdarch/.github/workflows/main.yml    |  10 +-
 .../core_arch/src/aarch64/neon/generated.rs   | 248 ++++++++++++++
 .../src/arm_shared/neon/generated.rs          | 308 ++++++++++++++++++
 .../core_arch/src/arm_shared/neon/mod.rs      |   8 +-
 .../spec/neon/aarch64.spec.yml                | 144 ++++++++
 .../spec/neon/arm_shared.spec.yml             | 111 +++++++
 .../crates/stdarch-test/src/disassembly.rs    |   6 +-
 7 files changed, 823 insertions(+), 12 deletions(-)

diff --git a/library/stdarch/.github/workflows/main.yml b/library/stdarch/.github/workflows/main.yml
index 048ce9864604e..b0d476f0e2ea5 100644
--- a/library/stdarch/.github/workflows/main.yml
+++ b/library/stdarch/.github/workflows/main.yml
@@ -117,6 +117,8 @@ jobs:
           os: windows-2025
         - tuple: aarch64-pc-windows-msvc
           os: windows-11-arm
+        - tuple: arm64ec-pc-windows-msvc
+          os: windows-11-arm
         - tuple: x86_64-pc-windows-gnu
           os: windows-2025
         # - tuple: i686-pc-windows-gnu
@@ -207,14 +209,6 @@ jobs:
         rustup update nightly --no-self-update
         rustup default nightly
       shell: bash
-      if: matrix.target.os != 'windows-11-arm'
-    - name: Install Rust for `windows-11-arm` runners
-      # The arm runners don't have Rust pre-installed (https://github.com/actions/partner-runner-images/issues/77)
-      run: |
-        curl https://sh.rustup.rs | sh -s -- -y --default-toolchain nightly
-        echo "$HOME/.cargo/bin" >> $GITHUB_PATH
-      shell: bash
-      if: matrix.target.os == 'windows-11-arm'
 
     - run: rustup target add ${{ matrix.target.tuple }}
       shell: bash
diff --git a/library/stdarch/crates/core_arch/src/aarch64/neon/generated.rs b/library/stdarch/crates/core_arch/src/aarch64/neon/generated.rs
index bc4c438038dc5..554a809db8db2 100644
--- a/library/stdarch/crates/core_arch/src/aarch64/neon/generated.rs
+++ b/library/stdarch/crates/core_arch/src/aarch64/neon/generated.rs
@@ -188,6 +188,7 @@ pub fn vabds_f32(a: f32, b: f32) -> f32 {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fabd))]
 pub fn vabdh_f16(a: f16, b: f16) -> f16 {
     unsafe { simd_extract!(vabd_f16(vdup_n_f16(a), vdup_n_f16(b)), 0) }
@@ -947,6 +948,7 @@ pub fn vbcaxq_u64(a: uint64x2_t, b: uint64x2_t, c: uint64x2_t) -> uint64x2_t {
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fcma"))]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fcadd))]
 pub fn vcadd_rot270_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
@@ -964,6 +966,7 @@ pub fn vcadd_rot270_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fcma"))]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fcadd))]
 pub fn vcaddq_rot270_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
@@ -1029,6 +1032,7 @@ pub fn vcaddq_rot270_f64(a: float64x2_t, b: float64x2_t) -> float64x2_t {
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fcma"))]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fcadd))]
 pub fn vcadd_rot90_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
@@ -1046,6 +1050,7 @@ pub fn vcadd_rot90_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fcma"))]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fcadd))]
 pub fn vcaddq_rot90_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
@@ -1175,6 +1180,7 @@ pub fn vcages_f32(a: f32, b: f32) -> u32 {
 #[cfg_attr(test, assert_instr(facge))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcageh_f16(a: f16, b: f16) -> u16 {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -1255,6 +1261,7 @@ pub fn vcagts_f32(a: f32, b: f32) -> u32 {
 #[cfg_attr(test, assert_instr(facgt))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcagth_f16(a: f16, b: f16) -> u16 {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -1307,6 +1314,7 @@ pub fn vcales_f32(a: f32, b: f32) -> u32 {
 #[cfg_attr(test, assert_instr(facge))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcaleh_f16(a: f16, b: f16) -> u16 {
     vcageh_f16(b, a)
 }
@@ -1352,6 +1360,7 @@ pub fn vcalts_f32(a: f32, b: f32) -> u32 {
 #[cfg_attr(test, assert_instr(facgt))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcalth_f16(a: f16, b: f16) -> u16 {
     vcagth_f16(b, a)
 }
@@ -1469,6 +1478,7 @@ pub fn vceqd_u64(a: u64, b: u64) -> u64 {
 #[cfg_attr(test, assert_instr(fcmp))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vceqh_f16(a: f16, b: f16) -> u16 {
     unsafe { simd_extract!(vceq_f16(vdup_n_f16(a), vdup_n_f16(b)), 0) }
 }
@@ -1478,6 +1488,7 @@ pub fn vceqh_f16(a: f16, b: f16) -> u16 {
 #[cfg_attr(test, assert_instr(fcmeq))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vceqz_f16(a: float16x4_t) -> uint16x4_t {
     let b: f16x4 = f16x4::new(0.0, 0.0, 0.0, 0.0);
     unsafe { simd_eq(a, transmute(b)) }
@@ -1488,6 +1499,7 @@ pub fn vceqz_f16(a: float16x4_t) -> uint16x4_t {
 #[cfg_attr(test, assert_instr(fcmeq))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vceqzq_f16(a: float16x8_t) -> uint16x8_t {
     let b: f16x8 = f16x8::new(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
     unsafe { simd_eq(a, transmute(b)) }
@@ -1756,6 +1768,7 @@ pub fn vceqzd_u64(a: u64) -> u64 {
 #[cfg_attr(test, assert_instr(fcmp))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vceqzh_f16(a: f16) -> u16 {
     unsafe { simd_extract!(vceqz_f16(vdup_n_f16(a)), 0) }
 }
@@ -1873,6 +1886,7 @@ pub fn vcged_u64(a: u64, b: u64) -> u64 {
 #[cfg_attr(test, assert_instr(fcmp))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcgeh_f16(a: f16, b: f16) -> u16 {
     unsafe { simd_extract!(vcge_f16(vdup_n_f16(a), vdup_n_f16(b)), 0) }
 }
@@ -2029,6 +2043,7 @@ pub fn vcgezd_s64(a: i64) -> u64 {
 #[cfg_attr(test, assert_instr(fcmp))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcgezh_f16(a: f16) -> u16 {
     unsafe { simd_extract!(vcgez_f16(vdup_n_f16(a)), 0) }
 }
@@ -2128,6 +2143,7 @@ pub fn vcgtd_u64(a: u64, b: u64) -> u64 {
 #[cfg_attr(test, assert_instr(fcmp))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcgth_f16(a: f16, b: f16) -> u16 {
     unsafe { simd_extract!(vcgt_f16(vdup_n_f16(a), vdup_n_f16(b)), 0) }
 }
@@ -2284,6 +2300,7 @@ pub fn vcgtzd_s64(a: i64) -> u64 {
 #[cfg_attr(test, assert_instr(fcmp))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcgtzh_f16(a: f16) -> u16 {
     unsafe { simd_extract!(vcgtz_f16(vdup_n_f16(a)), 0) }
 }
@@ -2383,6 +2400,7 @@ pub fn vcled_s64(a: i64, b: i64) -> u64 {
 #[cfg_attr(test, assert_instr(fcmp))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcleh_f16(a: f16, b: f16) -> u16 {
     unsafe { simd_extract!(vcle_f16(vdup_n_f16(a), vdup_n_f16(b)), 0) }
 }
@@ -2539,6 +2557,7 @@ pub fn vclezd_s64(a: i64) -> u64 {
 #[cfg_attr(test, assert_instr(fcmp))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vclezh_f16(a: f16) -> u16 {
     unsafe { simd_extract!(vclez_f16(vdup_n_f16(a)), 0) }
 }
@@ -2620,6 +2639,7 @@ pub fn vcltd_s64(a: i64, b: i64) -> u64 {
 #[cfg_attr(test, assert_instr(fcmp))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vclth_f16(a: f16, b: f16) -> u16 {
     unsafe { simd_extract!(vclt_f16(vdup_n_f16(a), vdup_n_f16(b)), 0) }
 }
@@ -2794,6 +2814,7 @@ pub fn vcltzd_s64(a: i64) -> u64 {
 #[cfg_attr(test, assert_instr(fcmp))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcltzh_f16(a: f16) -> u16 {
     unsafe { simd_extract!(vcltz_f16(vdup_n_f16(a)), 0) }
 }
@@ -2803,6 +2824,7 @@ pub fn vcltzh_f16(a: f16) -> u16 {
 #[target_feature(enable = "neon,fcma")]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fcmla))]
 pub fn vcmla_f16(a: float16x4_t, b: float16x4_t, c: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
@@ -2820,6 +2842,7 @@ pub fn vcmla_f16(a: float16x4_t, b: float16x4_t, c: float16x4_t) -> float16x4_t
 #[target_feature(enable = "neon,fcma")]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fcmla))]
 pub fn vcmlaq_f16(a: float16x8_t, b: float16x8_t, c: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
@@ -2887,6 +2910,7 @@ pub fn vcmlaq_f64(a: float64x2_t, b: float64x2_t, c: float64x2_t) -> float64x2_t
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmla_lane_f16<const LANE: i32>(
     a: float16x4_t,
     b: float16x4_t,
@@ -2915,6 +2939,7 @@ pub fn vcmla_lane_f16<const LANE: i32>(
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmlaq_lane_f16<const LANE: i32>(
     a: float16x8_t,
     b: float16x8_t,
@@ -2992,6 +3017,7 @@ pub fn vcmlaq_lane_f32<const LANE: i32>(
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmla_laneq_f16<const LANE: i32>(
     a: float16x4_t,
     b: float16x4_t,
@@ -3020,6 +3046,7 @@ pub fn vcmla_laneq_f16<const LANE: i32>(
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmlaq_laneq_f16<const LANE: i32>(
     a: float16x8_t,
     b: float16x8_t,
@@ -3095,6 +3122,7 @@ pub fn vcmlaq_laneq_f32<const LANE: i32>(
 #[target_feature(enable = "neon,fcma")]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fcmla))]
 pub fn vcmla_rot180_f16(a: float16x4_t, b: float16x4_t, c: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
@@ -3112,6 +3140,7 @@ pub fn vcmla_rot180_f16(a: float16x4_t, b: float16x4_t, c: float16x4_t) -> float
 #[target_feature(enable = "neon,fcma")]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fcmla))]
 pub fn vcmlaq_rot180_f16(a: float16x8_t, b: float16x8_t, c: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
@@ -3179,6 +3208,7 @@ pub fn vcmlaq_rot180_f64(a: float64x2_t, b: float64x2_t, c: float64x2_t) -> floa
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmla_rot180_lane_f16<const LANE: i32>(
     a: float16x4_t,
     b: float16x4_t,
@@ -3207,6 +3237,7 @@ pub fn vcmla_rot180_lane_f16<const LANE: i32>(
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmlaq_rot180_lane_f16<const LANE: i32>(
     a: float16x8_t,
     b: float16x8_t,
@@ -3284,6 +3315,7 @@ pub fn vcmlaq_rot180_lane_f32<const LANE: i32>(
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmla_rot180_laneq_f16<const LANE: i32>(
     a: float16x4_t,
     b: float16x4_t,
@@ -3312,6 +3344,7 @@ pub fn vcmla_rot180_laneq_f16<const LANE: i32>(
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmlaq_rot180_laneq_f16<const LANE: i32>(
     a: float16x8_t,
     b: float16x8_t,
@@ -3387,6 +3420,7 @@ pub fn vcmlaq_rot180_laneq_f32<const LANE: i32>(
 #[target_feature(enable = "neon,fcma")]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fcmla))]
 pub fn vcmla_rot270_f16(a: float16x4_t, b: float16x4_t, c: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
@@ -3404,6 +3438,7 @@ pub fn vcmla_rot270_f16(a: float16x4_t, b: float16x4_t, c: float16x4_t) -> float
 #[target_feature(enable = "neon,fcma")]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fcmla))]
 pub fn vcmlaq_rot270_f16(a: float16x8_t, b: float16x8_t, c: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
@@ -3471,6 +3506,7 @@ pub fn vcmlaq_rot270_f64(a: float64x2_t, b: float64x2_t, c: float64x2_t) -> floa
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmla_rot270_lane_f16<const LANE: i32>(
     a: float16x4_t,
     b: float16x4_t,
@@ -3499,6 +3535,7 @@ pub fn vcmla_rot270_lane_f16<const LANE: i32>(
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmlaq_rot270_lane_f16<const LANE: i32>(
     a: float16x8_t,
     b: float16x8_t,
@@ -3576,6 +3613,7 @@ pub fn vcmlaq_rot270_lane_f32<const LANE: i32>(
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmla_rot270_laneq_f16<const LANE: i32>(
     a: float16x4_t,
     b: float16x4_t,
@@ -3604,6 +3642,7 @@ pub fn vcmla_rot270_laneq_f16<const LANE: i32>(
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmlaq_rot270_laneq_f16<const LANE: i32>(
     a: float16x8_t,
     b: float16x8_t,
@@ -3679,6 +3718,7 @@ pub fn vcmlaq_rot270_laneq_f32<const LANE: i32>(
 #[target_feature(enable = "neon,fcma")]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fcmla))]
 pub fn vcmla_rot90_f16(a: float16x4_t, b: float16x4_t, c: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
@@ -3696,6 +3736,7 @@ pub fn vcmla_rot90_f16(a: float16x4_t, b: float16x4_t, c: float16x4_t) -> float1
 #[target_feature(enable = "neon,fcma")]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fcmla))]
 pub fn vcmlaq_rot90_f16(a: float16x8_t, b: float16x8_t, c: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
@@ -3763,6 +3804,7 @@ pub fn vcmlaq_rot90_f64(a: float64x2_t, b: float64x2_t, c: float64x2_t) -> float
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmla_rot90_lane_f16<const LANE: i32>(
     a: float16x4_t,
     b: float16x4_t,
@@ -3791,6 +3833,7 @@ pub fn vcmla_rot90_lane_f16<const LANE: i32>(
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmlaq_rot90_lane_f16<const LANE: i32>(
     a: float16x8_t,
     b: float16x8_t,
@@ -3868,6 +3911,7 @@ pub fn vcmlaq_rot90_lane_f32<const LANE: i32>(
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmla_rot90_laneq_f16<const LANE: i32>(
     a: float16x4_t,
     b: float16x4_t,
@@ -3896,6 +3940,7 @@ pub fn vcmla_rot90_laneq_f16<const LANE: i32>(
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcmlaq_rot90_laneq_f16<const LANE: i32>(
     a: float16x8_t,
     b: float16x8_t,
@@ -7161,6 +7206,7 @@ pub fn vcvtq_f64_u64(a: uint64x2_t) -> float64x2_t {
 #[cfg_attr(test, assert_instr(fcvtn2))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvt_high_f16_f32(a: float16x4_t, b: float32x4_t) -> float16x8_t {
     vcombine_f16(a, vcvt_f16_f32(b))
 }
@@ -7170,6 +7216,7 @@ pub fn vcvt_high_f16_f32(a: float16x4_t, b: float32x4_t) -> float16x8_t {
 #[cfg_attr(test, assert_instr(fcvtl2))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvt_high_f32_f16(a: float16x8_t) -> float32x4_t {
     vcvt_f32_f16(vget_high_f16(a))
 }
@@ -7408,6 +7455,7 @@ pub fn vcvtq_u64_f64(a: float64x2_t) -> uint64x2_t {
 #[cfg_attr(test, assert_instr(fcvtas))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvta_s16_f16(a: float16x4_t) -> int16x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -7424,6 +7472,7 @@ pub fn vcvta_s16_f16(a: float16x4_t) -> int16x4_t {
 #[cfg_attr(test, assert_instr(fcvtas))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtaq_s16_f16(a: float16x8_t) -> int16x8_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -7504,6 +7553,7 @@ pub fn vcvtaq_s64_f64(a: float64x2_t) -> int64x2_t {
 #[cfg_attr(test, assert_instr(fcvtau))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvta_u16_f16(a: float16x4_t) -> uint16x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -7520,6 +7570,7 @@ pub fn vcvta_u16_f16(a: float16x4_t) -> uint16x4_t {
 #[cfg_attr(test, assert_instr(fcvtau))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtaq_u16_f16(a: float16x8_t) -> uint16x8_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -7600,6 +7651,7 @@ pub fn vcvtaq_u64_f64(a: float64x2_t) -> uint64x2_t {
 #[cfg_attr(test, assert_instr(fcvtas))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtah_s16_f16(a: f16) -> i16 {
     vcvtah_s32_f16(a) as i16
 }
@@ -7609,6 +7661,7 @@ pub fn vcvtah_s16_f16(a: f16) -> i16 {
 #[cfg_attr(test, assert_instr(fcvtas))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtah_s32_f16(a: f16) -> i32 {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -7625,6 +7678,7 @@ pub fn vcvtah_s32_f16(a: f16) -> i32 {
 #[cfg_attr(test, assert_instr(fcvtas))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtah_s64_f16(a: f16) -> i64 {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -7641,6 +7695,7 @@ pub fn vcvtah_s64_f16(a: f16) -> i64 {
 #[cfg_attr(test, assert_instr(fcvtau))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtah_u16_f16(a: f16) -> u16 {
     vcvtah_u32_f16(a) as u16
 }
@@ -7650,6 +7705,7 @@ pub fn vcvtah_u16_f16(a: f16) -> u16 {
 #[cfg_attr(test, assert_instr(fcvtau))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtah_u32_f16(a: f16) -> u32 {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -7666,6 +7722,7 @@ pub fn vcvtah_u32_f16(a: f16) -> u32 {
 #[cfg_attr(test, assert_instr(fcvtau))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtah_u64_f16(a: f16) -> u64 {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -7764,6 +7821,7 @@ pub fn vcvts_f32_s32(a: i32) -> f32 {
 #[cfg_attr(test, assert_instr(scvtf))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvth_f16_s16(a: i16) -> f16 {
     a as f16
 }
@@ -7773,6 +7831,7 @@ pub fn vcvth_f16_s16(a: i16) -> f16 {
 #[cfg_attr(test, assert_instr(scvtf))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvth_f16_s32(a: i32) -> f16 {
     a as f16
 }
@@ -7782,6 +7841,7 @@ pub fn vcvth_f16_s32(a: i32) -> f16 {
 #[cfg_attr(test, assert_instr(scvtf))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvth_f16_s64(a: i64) -> f16 {
     a as f16
 }
@@ -7791,6 +7851,7 @@ pub fn vcvth_f16_s64(a: i64) -> f16 {
 #[cfg_attr(test, assert_instr(ucvtf))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvth_f16_u16(a: u16) -> f16 {
     a as f16
 }
@@ -7800,6 +7861,7 @@ pub fn vcvth_f16_u16(a: u16) -> f16 {
 #[cfg_attr(test, assert_instr(ucvtf))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvth_f16_u32(a: u32) -> f16 {
     a as f16
 }
@@ -7809,6 +7871,7 @@ pub fn vcvth_f16_u32(a: u32) -> f16 {
 #[cfg_attr(test, assert_instr(ucvtf))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvth_f16_u64(a: u64) -> f16 {
     a as f16
 }
@@ -7819,6 +7882,7 @@ pub fn vcvth_f16_u64(a: u64) -> f16 {
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvth_n_f16_s16<const N: i32>(a: i16) -> f16 {
     static_assert!(N >= 1 && N <= 16);
     vcvth_n_f16_s32::<N>(a as i32)
@@ -7830,6 +7894,7 @@ pub fn vcvth_n_f16_s16<const N: i32>(a: i16) -> f16 {
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvth_n_f16_s32<const N: i32>(a: i32) -> f16 {
     static_assert!(N >= 1 && N <= 16);
     unsafe extern "unadjusted" {
@@ -7848,6 +7913,7 @@ pub fn vcvth_n_f16_s32<const N: i32>(a: i32) -> f16 {
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvth_n_f16_s64<const N: i32>(a: i64) -> f16 {
     static_assert!(N >= 1 && N <= 16);
     unsafe extern "unadjusted" {
@@ -7866,6 +7932,7 @@ pub fn vcvth_n_f16_s64<const N: i32>(a: i64) -> f16 {
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvth_n_f16_u16<const N: i32>(a: u16) -> f16 {
     static_assert!(N >= 1 && N <= 16);
     vcvth_n_f16_u32::<N>(a as u32)
@@ -7877,6 +7944,7 @@ pub fn vcvth_n_f16_u16<const N: i32>(a: u16) -> f16 {
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvth_n_f16_u32<const N: i32>(a: u32) -> f16 {
     static_assert!(N >= 1 && N <= 16);
     unsafe extern "unadjusted" {
@@ -7895,6 +7963,7 @@ pub fn vcvth_n_f16_u32<const N: i32>(a: u32) -> f16 {
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvth_n_f16_u64<const N: i32>(a: u64) -> f16 {
     static_assert!(N >= 1 && N <= 16);
     unsafe extern "unadjusted" {
@@ -7913,6 +7982,7 @@ pub fn vcvth_n_f16_u64<const N: i32>(a: u64) -> f16 {
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvth_n_s16_f16<const N: i32>(a: f16) -> i16 {
     static_assert!(N >= 1 && N <= 16);
     vcvth_n_s32_f16::<N>(a) as i16
@@ -7924,6 +7994,7 @@ pub fn vcvth_n_s16_f16<const N: i32>(a: f16) -> i16 {
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvth_n_s32_f16<const N: i32>(a: f16) -> i32 {
     static_assert!(N >= 1 && N <= 16);
     unsafe extern "unadjusted" {
@@ -7942,6 +8013,7 @@ pub fn vcvth_n_s32_f16<const N: i32>(a: f16) -> i32 {
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvth_n_s64_f16<const N: i32>(a: f16) -> i64 {
     static_assert!(N >= 1 && N <= 16);
     unsafe extern "unadjusted" {
@@ -7960,6 +8032,7 @@ pub fn vcvth_n_s64_f16<const N: i32>(a: f16) -> i64 {
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvth_n_u16_f16<const N: i32>(a: f16) -> u16 {
     static_assert!(N >= 1 && N <= 16);
     vcvth_n_u32_f16::<N>(a) as u16
@@ -7971,6 +8044,7 @@ pub fn vcvth_n_u16_f16<const N: i32>(a: f16) -> u16 {
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvth_n_u32_f16<const N: i32>(a: f16) -> u32 {
     static_assert!(N >= 1 && N <= 16);
     unsafe extern "unadjusted" {
@@ -7989,6 +8063,7 @@ pub fn vcvth_n_u32_f16<const N: i32>(a: f16) -> u32 {
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvth_n_u64_f16<const N: i32>(a: f16) -> u64 {
     static_assert!(N >= 1 && N <= 16);
     unsafe extern "unadjusted" {
@@ -8006,6 +8081,7 @@ pub fn vcvth_n_u64_f16<const N: i32>(a: f16) -> u64 {
 #[cfg_attr(test, assert_instr(fcvtzs))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvth_s16_f16(a: f16) -> i16 {
     a as i16
 }
@@ -8015,6 +8091,7 @@ pub fn vcvth_s16_f16(a: f16) -> i16 {
 #[cfg_attr(test, assert_instr(fcvtzs))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvth_s32_f16(a: f16) -> i32 {
     a as i32
 }
@@ -8024,6 +8101,7 @@ pub fn vcvth_s32_f16(a: f16) -> i32 {
 #[cfg_attr(test, assert_instr(fcvtzs))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvth_s64_f16(a: f16) -> i64 {
     a as i64
 }
@@ -8033,6 +8111,7 @@ pub fn vcvth_s64_f16(a: f16) -> i64 {
 #[cfg_attr(test, assert_instr(fcvtzu))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvth_u16_f16(a: f16) -> u16 {
     a as u16
 }
@@ -8042,6 +8121,7 @@ pub fn vcvth_u16_f16(a: f16) -> u16 {
 #[cfg_attr(test, assert_instr(fcvtzu))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvth_u32_f16(a: f16) -> u32 {
     a as u32
 }
@@ -8051,6 +8131,7 @@ pub fn vcvth_u32_f16(a: f16) -> u32 {
 #[cfg_attr(test, assert_instr(fcvtzu))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvth_u64_f16(a: f16) -> u64 {
     a as u64
 }
@@ -8060,6 +8141,7 @@ pub fn vcvth_u64_f16(a: f16) -> u64 {
 #[cfg_attr(test, assert_instr(fcvtms))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtm_s16_f16(a: float16x4_t) -> int16x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -8076,6 +8158,7 @@ pub fn vcvtm_s16_f16(a: float16x4_t) -> int16x4_t {
 #[cfg_attr(test, assert_instr(fcvtms))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtmq_s16_f16(a: float16x8_t) -> int16x8_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -8156,6 +8239,7 @@ pub fn vcvtmq_s64_f64(a: float64x2_t) -> int64x2_t {
 #[cfg_attr(test, assert_instr(fcvtmu))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtm_u16_f16(a: float16x4_t) -> uint16x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -8172,6 +8256,7 @@ pub fn vcvtm_u16_f16(a: float16x4_t) -> uint16x4_t {
 #[cfg_attr(test, assert_instr(fcvtmu))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtmq_u16_f16(a: float16x8_t) -> uint16x8_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -8252,6 +8337,7 @@ pub fn vcvtmq_u64_f64(a: float64x2_t) -> uint64x2_t {
 #[cfg_attr(test, assert_instr(fcvtms))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtmh_s16_f16(a: f16) -> i16 {
     vcvtmh_s32_f16(a) as i16
 }
@@ -8261,6 +8347,7 @@ pub fn vcvtmh_s16_f16(a: f16) -> i16 {
 #[cfg_attr(test, assert_instr(fcvtms))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtmh_s32_f16(a: f16) -> i32 {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -8277,6 +8364,7 @@ pub fn vcvtmh_s32_f16(a: f16) -> i32 {
 #[cfg_attr(test, assert_instr(fcvtms))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtmh_s64_f16(a: f16) -> i64 {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -8293,6 +8381,7 @@ pub fn vcvtmh_s64_f16(a: f16) -> i64 {
 #[cfg_attr(test, assert_instr(fcvtmu))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtmh_u16_f16(a: f16) -> u16 {
     vcvtmh_u32_f16(a) as u16
 }
@@ -8302,6 +8391,7 @@ pub fn vcvtmh_u16_f16(a: f16) -> u16 {
 #[cfg_attr(test, assert_instr(fcvtmu))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtmh_u32_f16(a: f16) -> u32 {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -8318,6 +8408,7 @@ pub fn vcvtmh_u32_f16(a: f16) -> u32 {
 #[cfg_attr(test, assert_instr(fcvtmu))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtmh_u64_f16(a: f16) -> u64 {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -8398,6 +8489,7 @@ pub fn vcvtmd_u64_f64(a: f64) -> u64 {
 #[cfg_attr(test, assert_instr(fcvtns))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtn_s16_f16(a: float16x4_t) -> int16x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -8414,6 +8506,7 @@ pub fn vcvtn_s16_f16(a: float16x4_t) -> int16x4_t {
 #[cfg_attr(test, assert_instr(fcvtns))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtnq_s16_f16(a: float16x8_t) -> int16x8_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -8494,6 +8587,7 @@ pub fn vcvtnq_s64_f64(a: float64x2_t) -> int64x2_t {
 #[cfg_attr(test, assert_instr(fcvtnu))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtn_u16_f16(a: float16x4_t) -> uint16x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -8510,6 +8604,7 @@ pub fn vcvtn_u16_f16(a: float16x4_t) -> uint16x4_t {
 #[cfg_attr(test, assert_instr(fcvtnu))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtnq_u16_f16(a: float16x8_t) -> uint16x8_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -8590,6 +8685,7 @@ pub fn vcvtnq_u64_f64(a: float64x2_t) -> uint64x2_t {
 #[cfg_attr(test, assert_instr(fcvtns))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtnh_s16_f16(a: f16) -> i16 {
     vcvtnh_s32_f16(a) as i16
 }
@@ -8599,6 +8695,7 @@ pub fn vcvtnh_s16_f16(a: f16) -> i16 {
 #[cfg_attr(test, assert_instr(fcvtns))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtnh_s32_f16(a: f16) -> i32 {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -8615,6 +8712,7 @@ pub fn vcvtnh_s32_f16(a: f16) -> i32 {
 #[cfg_attr(test, assert_instr(fcvtns))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtnh_s64_f16(a: f16) -> i64 {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -8631,6 +8729,7 @@ pub fn vcvtnh_s64_f16(a: f16) -> i64 {
 #[cfg_attr(test, assert_instr(fcvtnu))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtnh_u16_f16(a: f16) -> u16 {
     vcvtnh_u32_f16(a) as u16
 }
@@ -8640,6 +8739,7 @@ pub fn vcvtnh_u16_f16(a: f16) -> u16 {
 #[cfg_attr(test, assert_instr(fcvtnu))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtnh_u32_f16(a: f16) -> u32 {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -8656,6 +8756,7 @@ pub fn vcvtnh_u32_f16(a: f16) -> u32 {
 #[cfg_attr(test, assert_instr(fcvtnu))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtnh_u64_f16(a: f16) -> u64 {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -8736,6 +8837,7 @@ pub fn vcvtnd_u64_f64(a: f64) -> u64 {
 #[cfg_attr(test, assert_instr(fcvtps))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtp_s16_f16(a: float16x4_t) -> int16x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -8752,6 +8854,7 @@ pub fn vcvtp_s16_f16(a: float16x4_t) -> int16x4_t {
 #[cfg_attr(test, assert_instr(fcvtps))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtpq_s16_f16(a: float16x8_t) -> int16x8_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -8832,6 +8935,7 @@ pub fn vcvtpq_s64_f64(a: float64x2_t) -> int64x2_t {
 #[cfg_attr(test, assert_instr(fcvtpu))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtp_u16_f16(a: float16x4_t) -> uint16x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -8848,6 +8952,7 @@ pub fn vcvtp_u16_f16(a: float16x4_t) -> uint16x4_t {
 #[cfg_attr(test, assert_instr(fcvtpu))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtpq_u16_f16(a: float16x8_t) -> uint16x8_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -8928,6 +9033,7 @@ pub fn vcvtpq_u64_f64(a: float64x2_t) -> uint64x2_t {
 #[cfg_attr(test, assert_instr(fcvtps))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtph_s16_f16(a: f16) -> i16 {
     vcvtph_s32_f16(a) as i16
 }
@@ -8937,6 +9043,7 @@ pub fn vcvtph_s16_f16(a: f16) -> i16 {
 #[cfg_attr(test, assert_instr(fcvtps))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtph_s32_f16(a: f16) -> i32 {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -8953,6 +9060,7 @@ pub fn vcvtph_s32_f16(a: f16) -> i32 {
 #[cfg_attr(test, assert_instr(fcvtps))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtph_s64_f16(a: f16) -> i64 {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -8969,6 +9077,7 @@ pub fn vcvtph_s64_f16(a: f16) -> i64 {
 #[cfg_attr(test, assert_instr(fcvtpu))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtph_u16_f16(a: f16) -> u16 {
     vcvtph_u32_f16(a) as u16
 }
@@ -8978,6 +9087,7 @@ pub fn vcvtph_u16_f16(a: f16) -> u16 {
 #[cfg_attr(test, assert_instr(fcvtpu))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtph_u32_f16(a: f16) -> u32 {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -8994,6 +9104,7 @@ pub fn vcvtph_u32_f16(a: f16) -> u32 {
 #[cfg_attr(test, assert_instr(fcvtpu))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtph_u64_f16(a: f16) -> u64 {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -9305,6 +9416,7 @@ pub fn vcvtxd_f32_f64(a: f64) -> f32 {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fdiv))]
 pub fn vdiv_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe { simd_div(a, b) }
@@ -9314,6 +9426,7 @@ pub fn vdiv_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fdiv))]
 pub fn vdivq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe { simd_div(a, b) }
@@ -9359,6 +9472,7 @@ pub fn vdivq_f64(a: float64x2_t, b: float64x2_t) -> float64x2_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vdivh_f16(a: f16, b: f16) -> f16 {
     a / b
@@ -9608,6 +9722,7 @@ pub fn vdupd_lane_u64<const N: i32>(a: uint64x1_t) -> u64 {
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vduph_lane_f16<const N: i32>(a: float16x4_t) -> f16 {
     static_assert_uimm_bits!(N, 2);
     unsafe { simd_extract!(a, N as u32) }
@@ -9619,6 +9734,7 @@ pub fn vduph_lane_f16<const N: i32>(a: float16x4_t) -> f16 {
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vduph_laneq_f16<const N: i32>(a: float16x8_t) -> f16 {
     static_assert_uimm_bits!(N, 4);
     unsafe { simd_extract!(a, N as u32) }
@@ -9977,6 +10093,7 @@ pub fn vfma_f64(a: float64x1_t, b: float64x1_t, c: float64x1_t) -> float64x1_t {
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfma_lane_f16<const LANE: i32>(
     a: float16x4_t,
     b: float16x4_t,
@@ -9992,6 +10109,7 @@ pub fn vfma_lane_f16<const LANE: i32>(
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfma_laneq_f16<const LANE: i32>(
     a: float16x4_t,
     b: float16x4_t,
@@ -10007,6 +10125,7 @@ pub fn vfma_laneq_f16<const LANE: i32>(
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmaq_lane_f16<const LANE: i32>(
     a: float16x8_t,
     b: float16x8_t,
@@ -10022,6 +10141,7 @@ pub fn vfmaq_lane_f16<const LANE: i32>(
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmaq_laneq_f16<const LANE: i32>(
     a: float16x8_t,
     b: float16x8_t,
@@ -10140,6 +10260,7 @@ pub fn vfma_laneq_f64<const LANE: i32>(
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmla))]
 pub fn vfma_n_f16(a: float16x4_t, b: float16x4_t, c: f16) -> float16x4_t {
     vfma_f16(a, b, vdup_n_f16(c))
@@ -10149,6 +10270,7 @@ pub fn vfma_n_f16(a: float16x4_t, b: float16x4_t, c: f16) -> float16x4_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmla))]
 pub fn vfmaq_n_f16(a: float16x8_t, b: float16x8_t, c: f16) -> float16x8_t {
     vfmaq_f16(a, b, vdupq_n_f16(c))
@@ -10182,6 +10304,7 @@ pub fn vfmad_lane_f64<const LANE: i32>(a: f64, b: f64, c: float64x1_t) -> f64 {
 #[cfg_attr(test, assert_instr(fmadd))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmah_f16(a: f16, b: f16, c: f16) -> f16 {
     unsafe { fmaf16(b, c, a) }
 }
@@ -10192,6 +10315,7 @@ pub fn vfmah_f16(a: f16, b: f16, c: f16) -> f16 {
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmah_lane_f16<const LANE: i32>(a: f16, b: f16, v: float16x4_t) -> f16 {
     static_assert_uimm_bits!(LANE, 2);
     unsafe {
@@ -10206,6 +10330,7 @@ pub fn vfmah_lane_f16<const LANE: i32>(a: f16, b: f16, v: float16x4_t) -> f16 {
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmah_laneq_f16<const LANE: i32>(a: f16, b: f16, v: float16x8_t) -> f16 {
     static_assert_uimm_bits!(LANE, 3);
     unsafe {
@@ -10294,6 +10419,7 @@ pub fn vfmad_laneq_f64<const LANE: i32>(a: f64, b: f64, c: float64x2_t) -> f64 {
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmlal2))]
 pub fn vfmlal_high_f16(r: float32x2_t, a: float16x4_t, b: float16x4_t) -> float32x2_t {
     unsafe extern "unadjusted" {
@@ -10311,6 +10437,7 @@ pub fn vfmlal_high_f16(r: float32x2_t, a: float16x4_t, b: float16x4_t) -> float3
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmlal2))]
 pub fn vfmlalq_high_f16(r: float32x4_t, a: float16x8_t, b: float16x8_t) -> float32x4_t {
     unsafe extern "unadjusted" {
@@ -10330,6 +10457,7 @@ pub fn vfmlalq_high_f16(r: float32x4_t, a: float16x8_t, b: float16x8_t) -> float
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlal_lane_high_f16<const LANE: i32>(
     r: float32x2_t,
     a: float16x4_t,
@@ -10346,6 +10474,7 @@ pub fn vfmlal_lane_high_f16<const LANE: i32>(
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlal_laneq_high_f16<const LANE: i32>(
     r: float32x2_t,
     a: float16x4_t,
@@ -10362,6 +10491,7 @@ pub fn vfmlal_laneq_high_f16<const LANE: i32>(
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlalq_lane_high_f16<const LANE: i32>(
     r: float32x4_t,
     a: float16x8_t,
@@ -10378,6 +10508,7 @@ pub fn vfmlalq_lane_high_f16<const LANE: i32>(
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlalq_laneq_high_f16<const LANE: i32>(
     r: float32x4_t,
     a: float16x8_t,
@@ -10394,6 +10525,7 @@ pub fn vfmlalq_laneq_high_f16<const LANE: i32>(
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlal_lane_low_f16<const LANE: i32>(
     r: float32x2_t,
     a: float16x4_t,
@@ -10410,6 +10542,7 @@ pub fn vfmlal_lane_low_f16<const LANE: i32>(
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlal_laneq_low_f16<const LANE: i32>(
     r: float32x2_t,
     a: float16x4_t,
@@ -10426,6 +10559,7 @@ pub fn vfmlal_laneq_low_f16<const LANE: i32>(
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlalq_lane_low_f16<const LANE: i32>(
     r: float32x4_t,
     a: float16x8_t,
@@ -10442,6 +10576,7 @@ pub fn vfmlalq_lane_low_f16<const LANE: i32>(
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlalq_laneq_low_f16<const LANE: i32>(
     r: float32x4_t,
     a: float16x8_t,
@@ -10456,6 +10591,7 @@ pub fn vfmlalq_laneq_low_f16<const LANE: i32>(
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmlal))]
 pub fn vfmlal_low_f16(r: float32x2_t, a: float16x4_t, b: float16x4_t) -> float32x2_t {
     unsafe extern "unadjusted" {
@@ -10473,6 +10609,7 @@ pub fn vfmlal_low_f16(r: float32x2_t, a: float16x4_t, b: float16x4_t) -> float32
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmlal))]
 pub fn vfmlalq_low_f16(r: float32x4_t, a: float16x8_t, b: float16x8_t) -> float32x4_t {
     unsafe extern "unadjusted" {
@@ -10490,6 +10627,7 @@ pub fn vfmlalq_low_f16(r: float32x4_t, a: float16x8_t, b: float16x8_t) -> float3
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmlsl2))]
 pub fn vfmlsl_high_f16(r: float32x2_t, a: float16x4_t, b: float16x4_t) -> float32x2_t {
     unsafe extern "unadjusted" {
@@ -10507,6 +10645,7 @@ pub fn vfmlsl_high_f16(r: float32x2_t, a: float16x4_t, b: float16x4_t) -> float3
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmlsl2))]
 pub fn vfmlslq_high_f16(r: float32x4_t, a: float16x8_t, b: float16x8_t) -> float32x4_t {
     unsafe extern "unadjusted" {
@@ -10526,6 +10665,7 @@ pub fn vfmlslq_high_f16(r: float32x4_t, a: float16x8_t, b: float16x8_t) -> float
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlsl_lane_high_f16<const LANE: i32>(
     r: float32x2_t,
     a: float16x4_t,
@@ -10542,6 +10682,7 @@ pub fn vfmlsl_lane_high_f16<const LANE: i32>(
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlsl_laneq_high_f16<const LANE: i32>(
     r: float32x2_t,
     a: float16x4_t,
@@ -10558,6 +10699,7 @@ pub fn vfmlsl_laneq_high_f16<const LANE: i32>(
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlslq_lane_high_f16<const LANE: i32>(
     r: float32x4_t,
     a: float16x8_t,
@@ -10574,6 +10716,7 @@ pub fn vfmlslq_lane_high_f16<const LANE: i32>(
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlslq_laneq_high_f16<const LANE: i32>(
     r: float32x4_t,
     a: float16x8_t,
@@ -10590,6 +10733,7 @@ pub fn vfmlslq_laneq_high_f16<const LANE: i32>(
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlsl_lane_low_f16<const LANE: i32>(
     r: float32x2_t,
     a: float16x4_t,
@@ -10606,6 +10750,7 @@ pub fn vfmlsl_lane_low_f16<const LANE: i32>(
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlsl_laneq_low_f16<const LANE: i32>(
     r: float32x2_t,
     a: float16x4_t,
@@ -10622,6 +10767,7 @@ pub fn vfmlsl_laneq_low_f16<const LANE: i32>(
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlslq_lane_low_f16<const LANE: i32>(
     r: float32x4_t,
     a: float16x8_t,
@@ -10638,6 +10784,7 @@ pub fn vfmlslq_lane_low_f16<const LANE: i32>(
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[rustc_legacy_const_generics(3)]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmlslq_laneq_low_f16<const LANE: i32>(
     r: float32x4_t,
     a: float16x8_t,
@@ -10652,6 +10799,7 @@ pub fn vfmlslq_laneq_low_f16<const LANE: i32>(
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmlsl))]
 pub fn vfmlsl_low_f16(r: float32x2_t, a: float16x4_t, b: float16x4_t) -> float32x2_t {
     unsafe extern "unadjusted" {
@@ -10669,6 +10817,7 @@ pub fn vfmlsl_low_f16(r: float32x2_t, a: float16x4_t, b: float16x4_t) -> float32
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(not(target_arch = "arm"), target_feature(enable = "fhm"))]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmlsl))]
 pub fn vfmlslq_low_f16(r: float32x4_t, a: float16x8_t, b: float16x8_t) -> float32x4_t {
     unsafe extern "unadjusted" {
@@ -10699,6 +10848,7 @@ pub fn vfms_f64(a: float64x1_t, b: float64x1_t, c: float64x1_t) -> float64x1_t {
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfms_lane_f16<const LANE: i32>(
     a: float16x4_t,
     b: float16x4_t,
@@ -10714,6 +10864,7 @@ pub fn vfms_lane_f16<const LANE: i32>(
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfms_laneq_f16<const LANE: i32>(
     a: float16x4_t,
     b: float16x4_t,
@@ -10729,6 +10880,7 @@ pub fn vfms_laneq_f16<const LANE: i32>(
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmsq_lane_f16<const LANE: i32>(
     a: float16x8_t,
     b: float16x8_t,
@@ -10744,6 +10896,7 @@ pub fn vfmsq_lane_f16<const LANE: i32>(
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmsq_laneq_f16<const LANE: i32>(
     a: float16x8_t,
     b: float16x8_t,
@@ -10862,6 +11015,7 @@ pub fn vfms_laneq_f64<const LANE: i32>(
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmls))]
 pub fn vfms_n_f16(a: float16x4_t, b: float16x4_t, c: f16) -> float16x4_t {
     vfms_f16(a, b, vdup_n_f16(c))
@@ -10871,6 +11025,7 @@ pub fn vfms_n_f16(a: float16x4_t, b: float16x4_t, c: f16) -> float16x4_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmls))]
 pub fn vfmsq_n_f16(a: float16x8_t, b: float16x8_t, c: f16) -> float16x8_t {
     vfmsq_f16(a, b, vdupq_n_f16(c))
@@ -10890,6 +11045,7 @@ pub fn vfms_n_f64(a: float64x1_t, b: float64x1_t, c: f64) -> float64x1_t {
 #[cfg_attr(test, assert_instr(fmsub))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmsh_f16(a: f16, b: f16, c: f16) -> f16 {
     vfmah_f16(a, -b, c)
 }
@@ -10900,6 +11056,7 @@ pub fn vfmsh_f16(a: f16, b: f16, c: f16) -> f16 {
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmsh_lane_f16<const LANE: i32>(a: f16, b: f16, v: float16x4_t) -> f16 {
     static_assert_uimm_bits!(LANE, 2);
     unsafe {
@@ -10914,6 +11071,7 @@ pub fn vfmsh_lane_f16<const LANE: i32>(a: f16, b: f16, v: float16x4_t) -> f16 {
 #[rustc_legacy_const_generics(3)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmsh_laneq_f16<const LANE: i32>(a: f16, b: f16, v: float16x8_t) -> f16 {
     static_assert_uimm_bits!(LANE, 3);
     unsafe {
@@ -11005,6 +11163,7 @@ pub fn vfmsd_laneq_f64<const LANE: i32>(a: f64, b: f64, c: float64x2_t) -> f64 {
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(test, assert_instr(ldr))]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld1_f16(ptr: *const f16) -> float16x4_t {
     crate::ptr::read_unaligned(ptr.cast())
 }
@@ -11016,6 +11175,7 @@ pub unsafe fn vld1_f16(ptr: *const f16) -> float16x4_t {
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(test, assert_instr(ldr))]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld1q_f16(ptr: *const f16) -> float16x8_t {
     crate::ptr::read_unaligned(ptr.cast())
 }
@@ -13107,6 +13267,7 @@ pub fn vmaxq_f64(a: float64x2_t, b: float64x2_t) -> float64x2_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmax))]
 pub fn vmaxh_f16(a: f16, b: f16) -> f16 {
     unsafe extern "unadjusted" {
@@ -13141,6 +13302,7 @@ pub fn vmaxnmq_f64(a: float64x2_t, b: float64x2_t) -> float64x2_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmaxnm))]
 pub fn vmaxnmh_f16(a: f16, b: f16) -> f16 {
     f16::max(a, b)
@@ -13150,6 +13312,7 @@ pub fn vmaxnmh_f16(a: f16, b: f16) -> f16 {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmaxnmv))]
 pub fn vmaxnmv_f16(a: float16x4_t) -> f16 {
     unsafe { simd_reduce_max(a) }
@@ -13159,6 +13322,7 @@ pub fn vmaxnmv_f16(a: float16x4_t) -> f16 {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmaxnmv))]
 pub fn vmaxnmvq_f16(a: float16x8_t) -> f16 {
     unsafe { simd_reduce_max(a) }
@@ -13195,6 +13359,7 @@ pub fn vmaxnmvq_f32(a: float32x4_t) -> f32 {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmaxv))]
 pub fn vmaxv_f16(a: float16x4_t) -> f16 {
     unsafe extern "unadjusted" {
@@ -13211,6 +13376,7 @@ pub fn vmaxv_f16(a: float16x4_t) -> f16 {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmaxv))]
 pub fn vmaxvq_f16(a: float16x8_t) -> f16 {
     unsafe extern "unadjusted" {
@@ -13415,6 +13581,7 @@ pub fn vminq_f64(a: float64x2_t, b: float64x2_t) -> float64x2_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmin))]
 pub fn vminh_f16(a: f16, b: f16) -> f16 {
     unsafe extern "unadjusted" {
@@ -13449,6 +13616,7 @@ pub fn vminnmq_f64(a: float64x2_t, b: float64x2_t) -> float64x2_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fminnm))]
 pub fn vminnmh_f16(a: f16, b: f16) -> f16 {
     f16::min(a, b)
@@ -13458,6 +13626,7 @@ pub fn vminnmh_f16(a: f16, b: f16) -> f16 {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fminnmv))]
 pub fn vminnmv_f16(a: float16x4_t) -> f16 {
     unsafe { simd_reduce_min(a) }
@@ -13467,6 +13636,7 @@ pub fn vminnmv_f16(a: float16x4_t) -> f16 {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fminnmv))]
 pub fn vminnmvq_f16(a: float16x8_t) -> f16 {
     unsafe { simd_reduce_min(a) }
@@ -13503,6 +13673,7 @@ pub fn vminnmvq_f32(a: float32x4_t) -> f32 {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fminv))]
 pub fn vminv_f16(a: float16x4_t) -> f16 {
     unsafe extern "unadjusted" {
@@ -13519,6 +13690,7 @@ pub fn vminv_f16(a: float16x4_t) -> f16 {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fminv))]
 pub fn vminvq_f16(a: float16x8_t) -> f16 {
     unsafe extern "unadjusted" {
@@ -14554,6 +14726,7 @@ pub fn vmul_lane_f64<const LANE: i32>(a: float64x1_t, b: float64x1_t) -> float64
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vmul_laneq_f16<const LANE: i32>(a: float16x4_t, b: float16x8_t) -> float16x4_t {
     static_assert_uimm_bits!(LANE, 3);
     unsafe {
@@ -14570,6 +14743,7 @@ pub fn vmul_laneq_f16<const LANE: i32>(a: float16x4_t, b: float16x8_t) -> float1
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vmulq_laneq_f16<const LANE: i32>(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     static_assert_uimm_bits!(LANE, 3);
     unsafe {
@@ -14640,6 +14814,7 @@ pub fn vmuld_lane_f64<const LANE: i32>(a: f64, b: float64x1_t) -> f64 {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vmulh_f16(a: f16, b: f16) -> f16 {
     a * b
@@ -14651,6 +14826,7 @@ pub fn vmulh_f16(a: f16, b: f16) -> f16 {
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vmulh_lane_f16<const LANE: i32>(a: f16, b: float16x4_t) -> f16 {
     static_assert_uimm_bits!(LANE, 2);
     unsafe {
@@ -14665,6 +14841,7 @@ pub fn vmulh_lane_f16<const LANE: i32>(a: f16, b: float16x4_t) -> f16 {
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vmulh_laneq_f16<const LANE: i32>(a: f16, b: float16x8_t) -> f16 {
     static_assert_uimm_bits!(LANE, 3);
     unsafe {
@@ -15073,6 +15250,7 @@ pub fn vmuld_laneq_f64<const LANE: i32>(a: f64, b: float64x2_t) -> f64 {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmulx))]
 pub fn vmulx_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
@@ -15089,6 +15267,7 @@ pub fn vmulx_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmulx))]
 pub fn vmulxq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
@@ -15171,6 +15350,7 @@ pub fn vmulxq_f64(a: float64x2_t, b: float64x2_t) -> float64x2_t {
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vmulx_lane_f16<const LANE: i32>(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     static_assert_uimm_bits!(LANE, 2);
     unsafe {
@@ -15187,6 +15367,7 @@ pub fn vmulx_lane_f16<const LANE: i32>(a: float16x4_t, b: float16x4_t) -> float1
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vmulx_laneq_f16<const LANE: i32>(a: float16x4_t, b: float16x8_t) -> float16x4_t {
     static_assert_uimm_bits!(LANE, 3);
     unsafe {
@@ -15203,6 +15384,7 @@ pub fn vmulx_laneq_f16<const LANE: i32>(a: float16x4_t, b: float16x8_t) -> float
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vmulxq_lane_f16<const LANE: i32>(a: float16x8_t, b: float16x4_t) -> float16x8_t {
     static_assert_uimm_bits!(LANE, 2);
     unsafe {
@@ -15232,6 +15414,7 @@ pub fn vmulxq_lane_f16<const LANE: i32>(a: float16x8_t, b: float16x4_t) -> float
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vmulxq_laneq_f16<const LANE: i32>(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     static_assert_uimm_bits!(LANE, 3);
     unsafe {
@@ -15347,6 +15530,7 @@ pub fn vmulx_laneq_f64<const LANE: i32>(a: float64x1_t, b: float64x2_t) -> float
 #[cfg_attr(test, assert_instr(fmulx))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vmulx_n_f16(a: float16x4_t, b: f16) -> float16x4_t {
     vmulx_f16(a, vdup_n_f16(b))
 }
@@ -15356,6 +15540,7 @@ pub fn vmulx_n_f16(a: float16x4_t, b: f16) -> float16x4_t {
 #[cfg_attr(test, assert_instr(fmulx))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vmulxq_n_f16(a: float16x8_t, b: f16) -> float16x8_t {
     vmulxq_f16(a, vdupq_n_f16(b))
 }
@@ -15440,6 +15625,7 @@ pub fn vmulxs_laneq_f32<const LANE: i32>(a: f32, b: float32x4_t) -> f32 {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmulx))]
 pub fn vmulxh_f16(a: f16, b: f16) -> f16 {
     unsafe extern "unadjusted" {
@@ -15458,6 +15644,7 @@ pub fn vmulxh_f16(a: f16, b: f16) -> f16 {
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vmulxh_lane_f16<const LANE: i32>(a: f16, b: float16x4_t) -> f16 {
     static_assert_uimm_bits!(LANE, 2);
     unsafe { vmulxh_f16(a, simd_extract!(b, LANE as u32)) }
@@ -15469,6 +15656,7 @@ pub fn vmulxh_lane_f16<const LANE: i32>(a: f16, b: float16x4_t) -> f16 {
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vmulxh_laneq_f16<const LANE: i32>(a: f16, b: float16x8_t) -> f16 {
     static_assert_uimm_bits!(LANE, 3);
     unsafe { vmulxh_f16(a, simd_extract!(b, LANE as u32)) }
@@ -15534,6 +15722,7 @@ pub fn vnegd_s64(a: i64) -> i64 {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fneg))]
 pub fn vnegh_f16(a: f16) -> f16 {
     -a
@@ -15587,6 +15776,7 @@ pub fn vpaddd_u64(a: uint64x2_t) -> u64 {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(faddp))]
 pub fn vpaddq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
@@ -15805,6 +15995,7 @@ pub fn vpaddq_u64(a: uint64x2_t, b: uint64x2_t) -> uint64x2_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmaxp))]
 pub fn vpmax_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
@@ -15821,6 +16012,7 @@ pub fn vpmax_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmaxp))]
 pub fn vpmaxq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
@@ -15837,6 +16029,7 @@ pub fn vpmaxq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmaxnmp))]
 pub fn vpmaxnm_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
@@ -15853,6 +16046,7 @@ pub fn vpmaxnm_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fmaxnmp))]
 pub fn vpmaxnmq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
@@ -16109,6 +16303,7 @@ pub fn vpmaxs_f32(a: float32x2_t) -> f32 {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fminp))]
 pub fn vpmin_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
@@ -16125,6 +16320,7 @@ pub fn vpmin_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fminp))]
 pub fn vpminq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
@@ -16141,6 +16337,7 @@ pub fn vpminq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fminnmp))]
 pub fn vpminnm_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
@@ -16157,6 +16354,7 @@ pub fn vpminnm_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fminnmp))]
 pub fn vpminnmq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
@@ -21135,6 +21333,7 @@ pub fn vrecpes_f32(a: f32) -> f32 {
 #[cfg_attr(test, assert_instr(frecpe))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vrecpeh_f16(a: f16) -> f16 {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -21215,6 +21414,7 @@ pub fn vrecpss_f32(a: f32, b: f32) -> f32 {
 #[cfg_attr(test, assert_instr(frecps))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vrecpsh_f16(a: f16, b: f16) -> f16 {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -21263,6 +21463,7 @@ pub fn vrecpxs_f32(a: f32) -> f32 {
 #[cfg_attr(test, assert_instr(frecpx))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vrecpxh_f16(a: f16) -> f16 {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -21279,6 +21480,7 @@ pub fn vrecpxh_f16(a: f16) -> f16 {
 #[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vreinterpret_f64_f16(a: float16x4_t) -> float64x1_t {
     unsafe { transmute(a) }
@@ -21289,6 +21491,7 @@ pub fn vreinterpret_f64_f16(a: float16x4_t) -> float64x1_t {
 #[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vreinterpret_f64_f16(a: float16x4_t) -> float64x1_t {
     let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
@@ -21300,6 +21503,7 @@ pub fn vreinterpret_f64_f16(a: float16x4_t) -> float64x1_t {
 #[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vreinterpretq_f64_f16(a: float16x8_t) -> float64x2_t {
     unsafe { transmute(a) }
@@ -21310,6 +21514,7 @@ pub fn vreinterpretq_f64_f16(a: float16x8_t) -> float64x2_t {
 #[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vreinterpretq_f64_f16(a: float16x8_t) -> float64x2_t {
     let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
@@ -21324,6 +21529,7 @@ pub fn vreinterpretq_f64_f16(a: float16x8_t) -> float64x2_t {
 #[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vreinterpret_f16_f64(a: float64x1_t) -> float16x4_t {
     unsafe { transmute(a) }
@@ -21334,6 +21540,7 @@ pub fn vreinterpret_f16_f64(a: float64x1_t) -> float16x4_t {
 #[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vreinterpret_f16_f64(a: float64x1_t) -> float16x4_t {
     unsafe {
@@ -21347,6 +21554,7 @@ pub fn vreinterpret_f16_f64(a: float64x1_t) -> float16x4_t {
 #[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vreinterpretq_f16_f64(a: float64x2_t) -> float16x8_t {
     unsafe { transmute(a) }
@@ -21357,6 +21565,7 @@ pub fn vreinterpretq_f16_f64(a: float64x2_t) -> float16x8_t {
 #[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vreinterpretq_f16_f64(a: float64x2_t) -> float16x8_t {
     let a: float64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
@@ -22935,6 +23144,7 @@ pub fn vrnd64z_f64(a: float64x1_t) -> float64x1_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frintz))]
 pub fn vrnd_f16(a: float16x4_t) -> float16x4_t {
     unsafe { simd_trunc(a) }
@@ -22944,6 +23154,7 @@ pub fn vrnd_f16(a: float16x4_t) -> float16x4_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frintz))]
 pub fn vrndq_f16(a: float16x8_t) -> float16x8_t {
     unsafe { simd_trunc(a) }
@@ -22989,6 +23200,7 @@ pub fn vrndq_f64(a: float64x2_t) -> float64x2_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frinta))]
 pub fn vrnda_f16(a: float16x4_t) -> float16x4_t {
     unsafe { simd_round(a) }
@@ -22998,6 +23210,7 @@ pub fn vrnda_f16(a: float16x4_t) -> float16x4_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frinta))]
 pub fn vrndaq_f16(a: float16x8_t) -> float16x8_t {
     unsafe { simd_round(a) }
@@ -23043,6 +23256,7 @@ pub fn vrndaq_f64(a: float64x2_t) -> float64x2_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frinta))]
 pub fn vrndah_f16(a: f16) -> f16 {
     unsafe { roundf16(a) }
@@ -23052,6 +23266,7 @@ pub fn vrndah_f16(a: f16) -> f16 {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frintz))]
 pub fn vrndh_f16(a: f16) -> f16 {
     unsafe { truncf16(a) }
@@ -23061,6 +23276,7 @@ pub fn vrndh_f16(a: f16) -> f16 {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frinti))]
 pub fn vrndi_f16(a: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
@@ -23077,6 +23293,7 @@ pub fn vrndi_f16(a: float16x4_t) -> float16x4_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frinti))]
 pub fn vrndiq_f16(a: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
@@ -23157,6 +23374,7 @@ pub fn vrndiq_f64(a: float64x2_t) -> float64x2_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frinti))]
 pub fn vrndih_f16(a: f16) -> f16 {
     unsafe extern "unadjusted" {
@@ -23173,6 +23391,7 @@ pub fn vrndih_f16(a: f16) -> f16 {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frintm))]
 pub fn vrndm_f16(a: float16x4_t) -> float16x4_t {
     unsafe { simd_floor(a) }
@@ -23182,6 +23401,7 @@ pub fn vrndm_f16(a: float16x4_t) -> float16x4_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frintm))]
 pub fn vrndmq_f16(a: float16x8_t) -> float16x8_t {
     unsafe { simd_floor(a) }
@@ -23227,6 +23447,7 @@ pub fn vrndmq_f64(a: float64x2_t) -> float64x2_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frintm))]
 pub fn vrndmh_f16(a: f16) -> f16 {
     unsafe { floorf16(a) }
@@ -23268,6 +23489,7 @@ pub fn vrndnq_f64(a: float64x2_t) -> float64x2_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frintn))]
 pub fn vrndnh_f16(a: f16) -> f16 {
     unsafe extern "unadjusted" {
@@ -23300,6 +23522,7 @@ pub fn vrndns_f32(a: f32) -> f32 {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frintp))]
 pub fn vrndp_f16(a: float16x4_t) -> float16x4_t {
     unsafe { simd_ceil(a) }
@@ -23309,6 +23532,7 @@ pub fn vrndp_f16(a: float16x4_t) -> float16x4_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frintp))]
 pub fn vrndpq_f16(a: float16x8_t) -> float16x8_t {
     unsafe { simd_ceil(a) }
@@ -23354,6 +23578,7 @@ pub fn vrndpq_f64(a: float64x2_t) -> float64x2_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frintp))]
 pub fn vrndph_f16(a: f16) -> f16 {
     unsafe { ceilf16(a) }
@@ -23363,6 +23588,7 @@ pub fn vrndph_f16(a: f16) -> f16 {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frintx))]
 pub fn vrndx_f16(a: float16x4_t) -> float16x4_t {
     unsafe { simd_round_ties_even(a) }
@@ -23372,6 +23598,7 @@ pub fn vrndx_f16(a: float16x4_t) -> float16x4_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frintx))]
 pub fn vrndxq_f16(a: float16x8_t) -> float16x8_t {
     unsafe { simd_round_ties_even(a) }
@@ -23417,6 +23644,7 @@ pub fn vrndxq_f64(a: float64x2_t) -> float64x2_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frintx))]
 pub fn vrndxh_f16(a: f16) -> f16 {
     round_ties_even_f16(a)
@@ -23623,6 +23851,7 @@ pub fn vrsqrtes_f32(a: f32) -> f32 {
 #[cfg_attr(test, assert_instr(frsqrte))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vrsqrteh_f16(a: f16) -> f16 {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -23703,6 +23932,7 @@ pub fn vrsqrtss_f32(a: f32, b: f32) -> f32 {
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(test, assert_instr(frsqrts))]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vrsqrtsh_f16(a: f16, b: f16) -> f16 {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -24791,6 +25021,7 @@ pub fn vsqadds_u32(a: u32, b: i32) -> u32 {
 #[cfg_attr(test, assert_instr(fsqrt))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vsqrt_f16(a: float16x4_t) -> float16x4_t {
     unsafe { simd_fsqrt(a) }
 }
@@ -24800,6 +25031,7 @@ pub fn vsqrt_f16(a: float16x4_t) -> float16x4_t {
 #[cfg_attr(test, assert_instr(fsqrt))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vsqrtq_f16(a: float16x8_t) -> float16x8_t {
     unsafe { simd_fsqrt(a) }
 }
@@ -24844,6 +25076,7 @@ pub fn vsqrtq_f64(a: float64x2_t) -> float64x2_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fsqrt))]
 pub fn vsqrth_f16(a: f16) -> f16 {
     unsafe { sqrtf16(a) }
@@ -25177,6 +25410,7 @@ pub fn vsrid_n_u64<const N: i32>(a: u64, b: u64) -> u64 {
 #[cfg_attr(test, assert_instr(str))]
 #[allow(clippy::cast_ptr_alignment)]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vst1_f16(ptr: *mut f16, a: float16x4_t) {
     crate::ptr::write_unaligned(ptr.cast(), a)
 }
@@ -25189,6 +25423,7 @@ pub unsafe fn vst1_f16(ptr: *mut f16, a: float16x4_t) {
 #[cfg_attr(test, assert_instr(str))]
 #[allow(clippy::cast_ptr_alignment)]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vst1q_f16(ptr: *mut f16, a: float16x8_t) {
     crate::ptr::write_unaligned(ptr.cast(), a)
 }
@@ -26488,6 +26723,7 @@ pub fn vsubd_u64(a: u64, b: u64) -> u64 {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vsubh_f16(a: f16, b: f16) -> f16 {
     a - b
@@ -27283,6 +27519,7 @@ pub fn vtbx4_p8(a: poly8x8_t, b: poly8x8x4_t, c: uint8x8_t) -> poly8x8_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, not(target_env = "msvc")), assert_instr(trn1))]
 pub fn vtrn1_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe { simd_shuffle!(a, b, [0, 4, 2, 6]) }
@@ -27292,6 +27529,7 @@ pub fn vtrn1_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, not(target_env = "msvc")), assert_instr(trn1))]
 pub fn vtrn1q_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe { simd_shuffle!(a, b, [0, 8, 2, 10, 4, 12, 6, 14]) }
@@ -27517,6 +27755,7 @@ pub fn vtrn1q_p16(a: poly16x8_t, b: poly16x8_t) -> poly16x8_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, not(target_env = "msvc")), assert_instr(trn2))]
 pub fn vtrn2_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe { simd_shuffle!(a, b, [1, 5, 3, 7]) }
@@ -27526,6 +27765,7 @@ pub fn vtrn2_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, not(target_env = "msvc")), assert_instr(trn2))]
 pub fn vtrn2q_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe { simd_shuffle!(a, b, [1, 9, 3, 11, 5, 13, 7, 15]) }
@@ -28056,6 +28296,7 @@ pub fn vusdotq_laneq_s32<const LANE: i32>(a: int32x4_t, b: uint8x16_t, c: int8x1
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, not(target_env = "msvc")), assert_instr(uzp1))]
 pub fn vuzp1_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe { simd_shuffle!(a, b, [0, 2, 4, 6]) }
@@ -28065,6 +28306,7 @@ pub fn vuzp1_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, not(target_env = "msvc")), assert_instr(uzp1))]
 pub fn vuzp1q_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe { simd_shuffle!(a, b, [0, 2, 4, 6, 8, 10, 12, 14]) }
@@ -28290,6 +28532,7 @@ pub fn vuzp1q_p16(a: poly16x8_t, b: poly16x8_t) -> poly16x8_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, not(target_env = "msvc")), assert_instr(uzp2))]
 pub fn vuzp2_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe { simd_shuffle!(a, b, [1, 3, 5, 7]) }
@@ -28299,6 +28542,7 @@ pub fn vuzp2_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, not(target_env = "msvc")), assert_instr(uzp2))]
 pub fn vuzp2q_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe { simd_shuffle!(a, b, [1, 3, 5, 7, 9, 11, 13, 15]) }
@@ -28542,6 +28786,7 @@ pub fn vxarq_u64<const IMM6: i32>(a: uint64x2_t, b: uint64x2_t) -> uint64x2_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, not(target_env = "msvc")), assert_instr(zip1))]
 pub fn vzip1_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe { simd_shuffle!(a, b, [0, 4, 1, 5]) }
@@ -28551,6 +28796,7 @@ pub fn vzip1_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, not(target_env = "msvc")), assert_instr(zip1))]
 pub fn vzip1q_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe { simd_shuffle!(a, b, [0, 8, 1, 9, 2, 10, 3, 11]) }
@@ -28776,6 +29022,7 @@ pub fn vzip1q_p64(a: poly64x2_t, b: poly64x2_t) -> poly64x2_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, not(target_env = "msvc")), assert_instr(zip2))]
 pub fn vzip2_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe { simd_shuffle!(a, b, [2, 6, 3, 7]) }
@@ -28785,6 +29032,7 @@ pub fn vzip2_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 #[inline]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, not(target_env = "msvc")), assert_instr(zip2))]
 pub fn vzip2q_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe { simd_shuffle!(a, b, [4, 12, 5, 13, 6, 14, 7, 15]) }
diff --git a/library/stdarch/crates/core_arch/src/arm_shared/neon/generated.rs b/library/stdarch/crates/core_arch/src/arm_shared/neon/generated.rs
index 32531c7da1356..fd150bcaf2b7f 100644
--- a/library/stdarch/crates/core_arch/src/arm_shared/neon/generated.rs
+++ b/library/stdarch/crates/core_arch/src/arm_shared/neon/generated.rs
@@ -820,6 +820,7 @@ pub fn vabaq_u8(a: uint8x16_t, b: uint8x16_t, c: uint8x16_t) -> uint8x16_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vabd_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vabds.v4f16")]
@@ -842,6 +843,7 @@ pub fn vabd_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vabdq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vabds.v8f16")]
@@ -1405,6 +1407,7 @@ pub fn vabdl_u32(a: uint32x2_t, b: uint32x2_t) -> uint64x2_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vabs_f16(a: float16x4_t) -> float16x4_t {
     unsafe { simd_fabs(a) }
 }
@@ -1419,6 +1422,7 @@ pub fn vabs_f16(a: float16x4_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vabsq_f16(a: float16x8_t) -> float16x8_t {
     unsafe { simd_fabs(a) }
 }
@@ -1625,6 +1629,7 @@ pub fn vabsq_s32(a: int32x4_t) -> int32x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vabsh_f16(a: f16) -> f16 {
     unsafe { simd_extract!(vabs_f16(vdup_n_f16(a)), 0) }
 }
@@ -1639,6 +1644,7 @@ pub fn vabsh_f16(a: f16) -> f16 {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vadd_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe { simd_add(a, b) }
 }
@@ -1653,6 +1659,7 @@ pub fn vadd_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vaddq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe { simd_add(a, b) }
 }
@@ -2129,6 +2136,7 @@ pub fn vaddq_p64(a: poly64x2_t, b: poly64x2_t) -> poly64x2_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vaddh_f16(a: f16, b: f16) -> f16 {
     a + b
 }
@@ -3828,6 +3836,7 @@ pub fn vbicq_u8(a: uint8x16_t, b: uint8x16_t) -> uint8x16_t {
     assert_instr(bsl)
 )]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vbsl_f16(a: uint16x4_t, b: float16x4_t, c: float16x4_t) -> float16x4_t {
     let not = int16x4_t::splat(-1);
     unsafe {
@@ -3848,6 +3857,7 @@ pub fn vbsl_f16(a: uint16x4_t, b: float16x4_t, c: float16x4_t) -> float16x4_t {
     assert_instr(bsl)
 )]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vbslq_f16(a: uint16x8_t, b: float16x8_t, c: float16x8_t) -> float16x8_t {
     let not = int16x8_t::splat(-1);
     unsafe {
@@ -4462,6 +4472,7 @@ pub fn vbslq_u8(a: uint8x16_t, b: uint8x16_t, c: uint8x16_t) -> uint8x16_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcage_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vacge.v4i16.v4f16")]
@@ -4484,6 +4495,7 @@ pub fn vcage_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcageq_f16(a: float16x8_t, b: float16x8_t) -> uint16x8_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vacge.v8i16.v8f16")]
@@ -4564,6 +4576,7 @@ pub fn vcageq_f32(a: float32x4_t, b: float32x4_t) -> uint32x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcagt_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vacgt.v4i16.v4f16")]
@@ -4586,6 +4599,7 @@ pub fn vcagt_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcagtq_f16(a: float16x8_t, b: float16x8_t) -> uint16x8_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vacgt.v8i16.v8f16")]
@@ -4666,6 +4680,7 @@ pub fn vcagtq_f32(a: float32x4_t, b: float32x4_t) -> uint32x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcale_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
     vcage_f16(b, a)
 }
@@ -4680,6 +4695,7 @@ pub fn vcale_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcaleq_f16(a: float16x8_t, b: float16x8_t) -> uint16x8_t {
     vcageq_f16(b, a)
 }
@@ -4736,6 +4752,7 @@ pub fn vcaleq_f32(a: float32x4_t, b: float32x4_t) -> uint32x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcalt_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
     vcagt_f16(b, a)
 }
@@ -4750,6 +4767,7 @@ pub fn vcalt_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcaltq_f16(a: float16x8_t, b: float16x8_t) -> uint16x8_t {
     vcagtq_f16(b, a)
 }
@@ -4806,6 +4824,7 @@ pub fn vcaltq_f32(a: float32x4_t, b: float32x4_t) -> uint32x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vceq_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
     unsafe { simd_eq(a, b) }
 }
@@ -4820,6 +4839,7 @@ pub fn vceq_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vceqq_f16(a: float16x8_t, b: float16x8_t) -> uint16x8_t {
     unsafe { simd_eq(a, b) }
 }
@@ -5170,6 +5190,7 @@ pub fn vceqq_p8(a: poly8x16_t, b: poly8x16_t) -> uint8x16_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcge_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
     unsafe { simd_ge(a, b) }
 }
@@ -5184,6 +5205,7 @@ pub fn vcge_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcgeq_f16(a: float16x8_t, b: float16x8_t) -> uint16x8_t {
     unsafe { simd_ge(a, b) }
 }
@@ -5492,6 +5514,7 @@ pub fn vcgeq_u32(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcgez_f16(a: float16x4_t) -> uint16x4_t {
     let b: f16x4 = f16x4::new(0.0, 0.0, 0.0, 0.0);
     unsafe { simd_ge(a, transmute(b)) }
@@ -5507,6 +5530,7 @@ pub fn vcgez_f16(a: float16x4_t) -> uint16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcgezq_f16(a: float16x8_t) -> uint16x8_t {
     let b: f16x8 = f16x8::new(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
     unsafe { simd_ge(a, transmute(b)) }
@@ -5522,6 +5546,7 @@ pub fn vcgezq_f16(a: float16x8_t) -> uint16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcgt_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
     unsafe { simd_gt(a, b) }
 }
@@ -5536,6 +5561,7 @@ pub fn vcgt_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcgtq_f16(a: float16x8_t, b: float16x8_t) -> uint16x8_t {
     unsafe { simd_gt(a, b) }
 }
@@ -5844,6 +5870,7 @@ pub fn vcgtq_u32(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcgtz_f16(a: float16x4_t) -> uint16x4_t {
     let b: f16x4 = f16x4::new(0.0, 0.0, 0.0, 0.0);
     unsafe { simd_gt(a, transmute(b)) }
@@ -5859,6 +5886,7 @@ pub fn vcgtz_f16(a: float16x4_t) -> uint16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcgtzq_f16(a: float16x8_t) -> uint16x8_t {
     let b: f16x8 = f16x8::new(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
     unsafe { simd_gt(a, transmute(b)) }
@@ -5874,6 +5902,7 @@ pub fn vcgtzq_f16(a: float16x8_t) -> uint16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcle_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
     unsafe { simd_le(a, b) }
 }
@@ -5888,6 +5917,7 @@ pub fn vcle_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcleq_f16(a: float16x8_t, b: float16x8_t) -> uint16x8_t {
     unsafe { simd_le(a, b) }
 }
@@ -6196,6 +6226,7 @@ pub fn vcleq_u32(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vclez_f16(a: float16x4_t) -> uint16x4_t {
     let b: f16x4 = f16x4::new(0.0, 0.0, 0.0, 0.0);
     unsafe { simd_le(a, transmute(b)) }
@@ -6211,6 +6242,7 @@ pub fn vclez_f16(a: float16x4_t) -> uint16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vclezq_f16(a: float16x8_t) -> uint16x8_t {
     let b: f16x8 = f16x8::new(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
     unsafe { simd_le(a, transmute(b)) }
@@ -6526,6 +6558,7 @@ pub fn vclsq_u32(a: uint32x4_t) -> int32x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vclt_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
     unsafe { simd_lt(a, b) }
 }
@@ -6540,6 +6573,7 @@ pub fn vclt_f16(a: float16x4_t, b: float16x4_t) -> uint16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcltq_f16(a: float16x8_t, b: float16x8_t) -> uint16x8_t {
     unsafe { simd_lt(a, b) }
 }
@@ -6848,6 +6882,7 @@ pub fn vcltq_u32(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcltz_f16(a: float16x4_t) -> uint16x4_t {
     let b: f16x4 = f16x4::new(0.0, 0.0, 0.0, 0.0);
     unsafe { simd_lt(a, transmute(b)) }
@@ -6863,6 +6898,7 @@ pub fn vcltz_f16(a: float16x4_t) -> uint16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcltzq_f16(a: float16x8_t) -> uint16x8_t {
     let b: f16x8 = f16x8::new(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
     unsafe { simd_lt(a, transmute(b)) }
@@ -7536,6 +7572,7 @@ pub fn vcntq_p8(a: poly8x16_t) -> poly8x16_t {
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vcombine_f16(a: float16x4_t, b: float16x4_t) -> float16x8_t {
     unsafe { simd_shuffle!(a, b, [0, 1, 2, 3, 4, 5, 6, 7]) }
@@ -7756,6 +7793,7 @@ pub fn vcombine_p64(a: poly64x1_t, b: poly64x1_t) -> poly64x2_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcreate_f16(a: u64) -> float16x4_t {
     unsafe { transmute(a) }
 }
@@ -7771,6 +7809,7 @@ pub fn vcreate_f16(a: u64) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcreate_f16(a: u64) -> float16x4_t {
     unsafe {
         let ret_val: float16x4_t = transmute(a);
@@ -8274,6 +8313,7 @@ pub fn vcreate_p64(a: u64) -> poly64x1_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvt_f16_f32(a: float32x4_t) -> float16x4_t {
     unsafe { simd_cast(a) }
 }
@@ -8288,6 +8328,7 @@ pub fn vcvt_f16_f32(a: float32x4_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvt_f16_s16(a: int16x4_t) -> float16x4_t {
     unsafe { simd_cast(a) }
 }
@@ -8302,6 +8343,7 @@ pub fn vcvt_f16_s16(a: int16x4_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtq_f16_s16(a: int16x8_t) -> float16x8_t {
     unsafe { simd_cast(a) }
 }
@@ -8316,6 +8358,7 @@ pub fn vcvtq_f16_s16(a: int16x8_t) -> float16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvt_f16_u16(a: uint16x4_t) -> float16x4_t {
     unsafe { simd_cast(a) }
 }
@@ -8330,6 +8373,7 @@ pub fn vcvt_f16_u16(a: uint16x4_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtq_f16_u16(a: uint16x8_t) -> float16x8_t {
     unsafe { simd_cast(a) }
 }
@@ -8344,6 +8388,7 @@ pub fn vcvtq_f16_u16(a: uint16x8_t) -> float16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvt_f32_f16(a: float16x4_t) -> float32x4_t {
     unsafe { simd_cast(a) }
 }
@@ -8443,6 +8488,7 @@ pub fn vcvtq_f32_u32(a: uint32x4_t) -> float32x4_t {
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvt_n_f16_s16<const N: i32>(a: int16x4_t) -> float16x4_t {
     static_assert!(N >= 1 && N <= 16);
     unsafe extern "unadjusted" {
@@ -8470,6 +8516,7 @@ pub fn vcvt_n_f16_s16<const N: i32>(a: int16x4_t) -> float16x4_t {
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtq_n_f16_s16<const N: i32>(a: int16x8_t) -> float16x8_t {
     static_assert!(N >= 1 && N <= 16);
     unsafe extern "unadjusted" {
@@ -8497,6 +8544,7 @@ pub fn vcvtq_n_f16_s16<const N: i32>(a: int16x8_t) -> float16x8_t {
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvt_n_f16_u16<const N: i32>(a: uint16x4_t) -> float16x4_t {
     static_assert!(N >= 1 && N <= 16);
     unsafe extern "unadjusted" {
@@ -8524,6 +8572,7 @@ pub fn vcvt_n_f16_u16<const N: i32>(a: uint16x4_t) -> float16x4_t {
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtq_n_f16_u16<const N: i32>(a: uint16x8_t) -> float16x8_t {
     static_assert!(N >= 1 && N <= 16);
     unsafe extern "unadjusted" {
@@ -8703,6 +8752,7 @@ pub fn vcvtq_n_f32_u32<const N: i32>(a: uint32x4_t) -> float32x4_t {
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvt_n_s16_f16<const N: i32>(a: float16x4_t) -> int16x4_t {
     static_assert!(N >= 1 && N <= 16);
     unsafe extern "unadjusted" {
@@ -8730,6 +8780,7 @@ pub fn vcvt_n_s16_f16<const N: i32>(a: float16x4_t) -> int16x4_t {
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtq_n_s16_f16<const N: i32>(a: float16x8_t) -> int16x8_t {
     static_assert!(N >= 1 && N <= 16);
     unsafe extern "unadjusted" {
@@ -8833,6 +8884,7 @@ pub fn vcvtq_n_s32_f32<const N: i32>(a: float32x4_t) -> int32x4_t {
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvt_n_u16_f16<const N: i32>(a: float16x4_t) -> uint16x4_t {
     static_assert!(N >= 1 && N <= 16);
     unsafe extern "unadjusted" {
@@ -8860,6 +8912,7 @@ pub fn vcvt_n_u16_f16<const N: i32>(a: float16x4_t) -> uint16x4_t {
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtq_n_u16_f16<const N: i32>(a: float16x8_t) -> uint16x8_t {
     static_assert!(N >= 1 && N <= 16);
     unsafe extern "unadjusted" {
@@ -8962,6 +9015,7 @@ pub fn vcvtq_n_u32_f32<const N: i32>(a: float32x4_t) -> uint32x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvt_s16_f16(a: float16x4_t) -> int16x4_t {
     unsafe { simd_cast(a) }
 }
@@ -8976,6 +9030,7 @@ pub fn vcvt_s16_f16(a: float16x4_t) -> int16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtq_s16_f16(a: float16x8_t) -> int16x8_t {
     unsafe { simd_cast(a) }
 }
@@ -9048,6 +9103,7 @@ pub fn vcvtq_s32_f32(a: float32x4_t) -> int32x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvt_u16_f16(a: float16x4_t) -> uint16x4_t {
     unsafe { simd_cast(a) }
 }
@@ -9062,6 +9118,7 @@ pub fn vcvt_u16_f16(a: float16x4_t) -> uint16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vcvtq_u16_f16(a: float16x8_t) -> uint16x8_t {
     unsafe { simd_cast(a) }
 }
@@ -9361,6 +9418,7 @@ pub fn vdotq_u32(a: uint32x4_t, b: uint8x16_t, c: uint8x16_t) -> uint32x4_t {
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vdup_lane_f16<const N: i32>(a: float16x4_t) -> float16x4_t {
     static_assert_uimm_bits!(N, 2);
     unsafe { simd_shuffle!(a, a, [N as u32, N as u32, N as u32, N as u32]) }
@@ -9377,6 +9435,7 @@ pub fn vdup_lane_f16<const N: i32>(a: float16x4_t) -> float16x4_t {
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vdupq_lane_f16<const N: i32>(a: float16x4_t) -> float16x8_t {
     static_assert_uimm_bits!(N, 2);
     unsafe {
@@ -9922,6 +9981,7 @@ pub fn vdup_lane_u64<const N: i32>(a: uint64x1_t) -> uint64x1_t {
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vdup_laneq_f16<const N: i32>(a: float16x8_t) -> float16x4_t {
     static_assert_uimm_bits!(N, 3);
     unsafe { simd_shuffle!(a, a, [N as u32, N as u32, N as u32, N as u32]) }
@@ -9938,6 +9998,7 @@ pub fn vdup_laneq_f16<const N: i32>(a: float16x8_t) -> float16x4_t {
 #[rustc_legacy_const_generics(1)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vdupq_laneq_f16<const N: i32>(a: float16x8_t) -> float16x8_t {
     static_assert_uimm_bits!(N, 3);
     unsafe {
@@ -10482,6 +10543,7 @@ pub fn vdup_laneq_u64<const N: i32>(a: uint64x2_t) -> uint64x1_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vdup_n_f16(a: f16) -> float16x4_t {
     float16x4_t::splat(a)
 }
@@ -10496,6 +10558,7 @@ pub fn vdup_n_f16(a: f16) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vdupq_n_f16(a: f16) -> float16x8_t {
     float16x8_t::splat(a)
 }
@@ -11443,6 +11506,7 @@ pub fn veorq_u64(a: uint64x2_t, b: uint64x2_t) -> uint64x2_t {
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vext_f16<const N: i32>(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     static_assert_uimm_bits!(N, 2);
     unsafe {
@@ -11814,6 +11878,7 @@ pub fn vextq_p16<const N: i32>(a: poly16x8_t, b: poly16x8_t) -> poly16x8_t {
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vextq_f16<const N: i32>(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     static_assert_uimm_bits!(N, 3);
     unsafe {
@@ -12394,6 +12459,7 @@ pub fn vextq_p8<const N: i32>(a: poly8x16_t, b: poly8x16_t) -> poly8x16_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfma_f16(a: float16x4_t, b: float16x4_t, c: float16x4_t) -> float16x4_t {
     unsafe { simd_fma(b, c, a) }
 }
@@ -12408,6 +12474,7 @@ pub fn vfma_f16(a: float16x4_t, b: float16x4_t, c: float16x4_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmaq_f16(a: float16x8_t, b: float16x8_t, c: float16x8_t) -> float16x8_t {
     unsafe { simd_fma(b, c, a) }
 }
@@ -12507,6 +12574,7 @@ pub fn vfmaq_n_f32(a: float32x4_t, b: float32x4_t, c: f32) -> float32x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfms_f16(a: float16x4_t, b: float16x4_t, c: float16x4_t) -> float16x4_t {
     unsafe {
         let b: float16x4_t = simd_neg(b);
@@ -12525,6 +12593,7 @@ pub fn vfms_f16(a: float16x4_t, b: float16x4_t, c: float16x4_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmsq_f16(a: float16x8_t, b: float16x8_t, c: float16x8_t) -> float16x8_t {
     unsafe {
         let b: float16x8_t = simd_neg(b);
@@ -12627,6 +12696,7 @@ pub fn vfmsq_n_f32(a: float32x4_t, b: float32x4_t, c: f32) -> float32x4_t {
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vget_high_f16(a: float16x8_t) -> float16x4_t {
     unsafe { simd_shuffle!(a, a, [4, 5, 6, 7]) }
@@ -12637,6 +12707,7 @@ pub fn vget_high_f16(a: float16x8_t) -> float16x4_t {
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vget_low_f16(a: float16x8_t) -> float16x4_t {
     unsafe { simd_shuffle!(a, a, [0, 1, 2, 3]) }
@@ -12884,6 +12955,7 @@ pub fn vget_high_u64(a: uint64x2_t) -> uint64x1_t {
 )]
 #[rustc_legacy_const_generics(1)]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vget_lane_f16<const LANE: i32>(a: float16x4_t) -> f16 {
     static_assert_uimm_bits!(LANE, 2);
     unsafe { simd_extract!(a, LANE as u32) }
@@ -12900,6 +12972,7 @@ pub fn vget_lane_f16<const LANE: i32>(a: float16x4_t) -> f16 {
 )]
 #[rustc_legacy_const_generics(1)]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vgetq_lane_f16<const LANE: i32>(a: float16x8_t) -> f16 {
     static_assert_uimm_bits!(LANE, 3);
     unsafe { simd_extract!(a, LANE as u32) }
@@ -14256,6 +14329,7 @@ pub fn vhsubq_u32(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld1_dup_f16(ptr: *const f16) -> float16x4_t {
     let x: float16x4_t = vld1_lane_f16::<0>(ptr, transmute(f16x4::splat(0.0)));
     simd_shuffle!(x, x, [0, 0, 0, 0])
@@ -14273,6 +14347,7 @@ pub unsafe fn vld1_dup_f16(ptr: *const f16) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld1q_dup_f16(ptr: *const f16) -> float16x8_t {
     let x: float16x8_t = vld1q_lane_f16::<0>(ptr, transmute(f16x8::splat(0.0)));
     simd_shuffle!(x, x, [0, 0, 0, 0, 0, 0, 0, 0])
@@ -14843,6 +14918,7 @@ pub unsafe fn vld1_dup_u64(ptr: *const u64) -> uint64x1_t {
 #[target_feature(enable = "neon,v7")]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr("vld1.16"))]
 pub unsafe fn vld1_f16(ptr: *const f16) -> float16x4_t {
     transmute(vld1_v4f16(
@@ -14860,6 +14936,7 @@ pub unsafe fn vld1_f16(ptr: *const f16) -> float16x4_t {
 #[target_feature(enable = "neon,v7")]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr("vld1.16"))]
 pub unsafe fn vld1_f16(ptr: *const f16) -> float16x4_t {
     let ret_val: float16x4_t = transmute(vld1_v4f16(
@@ -14878,6 +14955,7 @@ pub unsafe fn vld1_f16(ptr: *const f16) -> float16x4_t {
 #[target_feature(enable = "neon,v7")]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr("vld1.16"))]
 pub unsafe fn vld1q_f16(ptr: *const f16) -> float16x8_t {
     transmute(vld1q_v8f16(
@@ -14895,6 +14973,7 @@ pub unsafe fn vld1q_f16(ptr: *const f16) -> float16x8_t {
 #[target_feature(enable = "neon,v7")]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr("vld1.16"))]
 pub unsafe fn vld1q_f16(ptr: *const f16) -> float16x8_t {
     let ret_val: float16x8_t = transmute(vld1q_v8f16(
@@ -14916,6 +14995,7 @@ pub unsafe fn vld1q_f16(ptr: *const f16) -> float16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld1_f16_x2(a: *const f16) -> float16x4x2_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -14940,6 +15020,7 @@ pub unsafe fn vld1_f16_x2(a: *const f16) -> float16x4x2_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld1_f16_x3(a: *const f16) -> float16x4x3_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -14964,6 +15045,7 @@ pub unsafe fn vld1_f16_x3(a: *const f16) -> float16x4x3_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld1_f16_x4(a: *const f16) -> float16x4x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -14988,6 +15070,7 @@ pub unsafe fn vld1_f16_x4(a: *const f16) -> float16x4x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld1q_f16_x2(a: *const f16) -> float16x8x2_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -15012,6 +15095,7 @@ pub unsafe fn vld1q_f16_x2(a: *const f16) -> float16x8x2_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld1q_f16_x3(a: *const f16) -> float16x8x3_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -15036,6 +15120,7 @@ pub unsafe fn vld1q_f16_x3(a: *const f16) -> float16x8x3_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld1q_f16_x4(a: *const f16) -> float16x8x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -15732,6 +15817,7 @@ pub unsafe fn vld1q_f32_x4(a: *const f32) -> float32x4x4_t {
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld1_lane_f16<const LANE: i32>(ptr: *const f16, src: float16x4_t) -> float16x4_t {
     static_assert_uimm_bits!(LANE, 2);
     simd_insert!(src, LANE as u32, *ptr)
@@ -15750,6 +15836,7 @@ pub unsafe fn vld1_lane_f16<const LANE: i32>(ptr: *const f16, src: float16x4_t)
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld1q_lane_f16<const LANE: i32>(ptr: *const f16, src: float16x8_t) -> float16x8_t {
     static_assert_uimm_bits!(LANE, 3);
     simd_insert!(src, LANE as u32, *ptr)
@@ -19490,6 +19577,7 @@ unsafe fn vld1q_v8i16(a: *const i8, b: i32) -> int16x8_t {
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 unsafe fn vld1_v4f16(a: *const i8, b: i32) -> float16x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vld1.v4f16")]
@@ -19507,6 +19595,7 @@ unsafe fn vld1_v4f16(a: *const i8, b: i32) -> float16x4_t {
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 unsafe fn vld1q_v8f16(a: *const i8, b: i32) -> float16x8_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vld1.v8f16")]
@@ -19548,6 +19637,7 @@ pub unsafe fn vld1q_dup_p64(ptr: *const p64) -> poly64x2_t {
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(vld2))]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld2_dup_f16(a: *const f16) -> float16x4x2_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vld2dup.v4f16.p0")]
@@ -19565,6 +19655,7 @@ pub unsafe fn vld2_dup_f16(a: *const f16) -> float16x4x2_t {
 #[target_feature(enable = "neon,fp16")]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(vld2))]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld2q_dup_f16(a: *const f16) -> float16x8x2_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vld2dup.v8f16.p0")]
@@ -19584,6 +19675,7 @@ pub unsafe fn vld2q_dup_f16(a: *const f16) -> float16x8x2_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld2_dup_f16(a: *const f16) -> float16x4x2_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -19606,6 +19698,7 @@ pub unsafe fn vld2_dup_f16(a: *const f16) -> float16x4x2_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld2q_dup_f16(a: *const f16) -> float16x8x2_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -20521,6 +20614,7 @@ pub unsafe fn vld2q_dup_p16(a: *const p16) -> poly16x8x2_t {
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(vld2))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld2_f16(a: *const f16) -> float16x4x2_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vld2.v4f16.p0")]
@@ -20538,6 +20632,7 @@ pub unsafe fn vld2_f16(a: *const f16) -> float16x4x2_t {
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(vld2))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld2q_f16(a: *const f16) -> float16x8x2_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vld2.v8f16.p0")]
@@ -20557,6 +20652,7 @@ pub unsafe fn vld2q_f16(a: *const f16) -> float16x8x2_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld2_f16(a: *const f16) -> float16x4x2_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -20579,6 +20675,7 @@ pub unsafe fn vld2_f16(a: *const f16) -> float16x4x2_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld2q_f16(a: *const f16) -> float16x8x2_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -20880,6 +20977,7 @@ pub unsafe fn vld2q_s32(a: *const i32) -> int32x4x2_t {
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld2_lane_f16<const LANE: i32>(a: *const f16, b: float16x4x2_t) -> float16x4x2_t {
     static_assert_uimm_bits!(LANE, 2);
     unsafe extern "unadjusted" {
@@ -20905,6 +21003,7 @@ pub unsafe fn vld2_lane_f16<const LANE: i32>(a: *const f16, b: float16x4x2_t) ->
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld2q_lane_f16<const LANE: i32>(a: *const f16, b: float16x8x2_t) -> float16x8x2_t {
     static_assert_uimm_bits!(LANE, 3);
     unsafe extern "unadjusted" {
@@ -20932,6 +21031,7 @@ pub unsafe fn vld2q_lane_f16<const LANE: i32>(a: *const f16, b: float16x8x2_t) -
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld2_lane_f16<const LANE: i32>(a: *const f16, b: float16x4x2_t) -> float16x4x2_t {
     static_assert_uimm_bits!(LANE, 2);
     unsafe extern "unadjusted" {
@@ -20957,6 +21057,7 @@ pub unsafe fn vld2_lane_f16<const LANE: i32>(a: *const f16, b: float16x4x2_t) ->
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld2q_lane_f16<const LANE: i32>(a: *const f16, b: float16x8x2_t) -> float16x8x2_t {
     static_assert_uimm_bits!(LANE, 3);
     unsafe extern "unadjusted" {
@@ -22109,6 +22210,7 @@ pub unsafe fn vld2q_p16(a: *const p16) -> poly16x8x2_t {
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(vld3))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld3_dup_f16(a: *const f16) -> float16x4x3_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vld3dup.v4f16.p0")]
@@ -22126,6 +22228,7 @@ pub unsafe fn vld3_dup_f16(a: *const f16) -> float16x4x3_t {
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(vld3))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld3q_dup_f16(a: *const f16) -> float16x8x3_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vld3dup.v8f16.p0")]
@@ -22145,6 +22248,7 @@ pub unsafe fn vld3q_dup_f16(a: *const f16) -> float16x8x3_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld3_dup_f16(a: *const f16) -> float16x4x3_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -22167,6 +22271,7 @@ pub unsafe fn vld3_dup_f16(a: *const f16) -> float16x4x3_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld3q_dup_f16(a: *const f16) -> float16x8x3_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -23104,6 +23209,7 @@ pub unsafe fn vld3q_dup_p16(a: *const p16) -> poly16x8x3_t {
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(vld3))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld3_f16(a: *const f16) -> float16x4x3_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vld3.v4f16.p0")]
@@ -23121,6 +23227,7 @@ pub unsafe fn vld3_f16(a: *const f16) -> float16x4x3_t {
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(vld3))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld3q_f16(a: *const f16) -> float16x8x3_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vld3.v8f16.p0")]
@@ -23140,6 +23247,7 @@ pub unsafe fn vld3q_f16(a: *const f16) -> float16x8x3_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld3_f16(a: *const f16) -> float16x4x3_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -23162,6 +23270,7 @@ pub unsafe fn vld3_f16(a: *const f16) -> float16x4x3_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld3q_f16(a: *const f16) -> float16x8x3_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -23463,6 +23572,7 @@ pub unsafe fn vld3q_s32(a: *const i32) -> int32x4x3_t {
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld3_lane_f16<const LANE: i32>(a: *const f16, b: float16x4x3_t) -> float16x4x3_t {
     static_assert_uimm_bits!(LANE, 2);
     unsafe extern "unadjusted" {
@@ -23489,6 +23599,7 @@ pub unsafe fn vld3_lane_f16<const LANE: i32>(a: *const f16, b: float16x4x3_t) ->
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld3q_lane_f16<const LANE: i32>(a: *const f16, b: float16x8x3_t) -> float16x8x3_t {
     static_assert_uimm_bits!(LANE, 3);
     unsafe extern "unadjusted" {
@@ -23517,6 +23628,7 @@ pub unsafe fn vld3q_lane_f16<const LANE: i32>(a: *const f16, b: float16x8x3_t) -
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld3_lane_f16<const LANE: i32>(a: *const f16, b: float16x4x3_t) -> float16x4x3_t {
     static_assert_uimm_bits!(LANE, 2);
     unsafe extern "unadjusted" {
@@ -23547,6 +23659,7 @@ pub unsafe fn vld3_lane_f16<const LANE: i32>(a: *const f16, b: float16x4x3_t) ->
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld3q_lane_f16<const LANE: i32>(a: *const f16, b: float16x8x3_t) -> float16x8x3_t {
     static_assert_uimm_bits!(LANE, 3);
     unsafe extern "unadjusted" {
@@ -24775,6 +24888,7 @@ pub unsafe fn vld3q_lane_f32<const LANE: i32>(a: *const f32, b: float32x4x3_t) -
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(vld4))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld4_dup_f16(a: *const f16) -> float16x4x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vld4dup.v4f16.p0")]
@@ -24792,6 +24906,7 @@ pub unsafe fn vld4_dup_f16(a: *const f16) -> float16x4x4_t {
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(vld4))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld4q_dup_f16(a: *const f16) -> float16x8x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vld4dup.v8f16.p0")]
@@ -24811,6 +24926,7 @@ pub unsafe fn vld4q_dup_f16(a: *const f16) -> float16x8x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld4_dup_f16(a: *const f16) -> float16x4x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -24833,6 +24949,7 @@ pub unsafe fn vld4_dup_f16(a: *const f16) -> float16x4x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld4q_dup_f16(a: *const f16) -> float16x8x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -25792,6 +25909,7 @@ pub unsafe fn vld4q_dup_p16(a: *const p16) -> poly16x8x4_t {
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(vld4))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld4_f16(a: *const f16) -> float16x4x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vld4.v4f16.p0")]
@@ -25809,6 +25927,7 @@ pub unsafe fn vld4_f16(a: *const f16) -> float16x4x4_t {
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(vld4))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld4q_f16(a: *const f16) -> float16x8x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vld4.v8f16.p0")]
@@ -25828,6 +25947,7 @@ pub unsafe fn vld4q_f16(a: *const f16) -> float16x8x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld4_f16(a: *const f16) -> float16x4x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -25850,6 +25970,7 @@ pub unsafe fn vld4_f16(a: *const f16) -> float16x4x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld4q_f16(a: *const f16) -> float16x8x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -26151,6 +26272,7 @@ pub unsafe fn vld4q_s32(a: *const i32) -> int32x4x4_t {
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld4_lane_f16<const LANE: i32>(a: *const f16, b: float16x4x4_t) -> float16x4x4_t {
     static_assert_uimm_bits!(LANE, 2);
     unsafe extern "unadjusted" {
@@ -26178,6 +26300,7 @@ pub unsafe fn vld4_lane_f16<const LANE: i32>(a: *const f16, b: float16x4x4_t) ->
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld4q_lane_f16<const LANE: i32>(a: *const f16, b: float16x8x4_t) -> float16x8x4_t {
     static_assert_uimm_bits!(LANE, 3);
     unsafe extern "unadjusted" {
@@ -26207,6 +26330,7 @@ pub unsafe fn vld4q_lane_f16<const LANE: i32>(a: *const f16, b: float16x8x4_t) -
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld4_lane_f16<const LANE: i32>(a: *const f16, b: float16x4x4_t) -> float16x4x4_t {
     static_assert_uimm_bits!(LANE, 2);
     unsafe extern "unadjusted" {
@@ -26238,6 +26362,7 @@ pub unsafe fn vld4_lane_f16<const LANE: i32>(a: *const f16, b: float16x4x4_t) ->
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vld4q_lane_f16<const LANE: i32>(a: *const f16, b: float16x8x4_t) -> float16x8x4_t {
     static_assert_uimm_bits!(LANE, 3);
     unsafe extern "unadjusted" {
@@ -27527,6 +27652,7 @@ pub unsafe fn vldrq_p128(a: *const p128) -> p128 {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vmax_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vmaxs.v4f16")]
@@ -27549,6 +27675,7 @@ pub fn vmax_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vmaxq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vmaxs.v8f16")]
@@ -27917,6 +28044,7 @@ pub fn vmaxq_u32(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vmaxnm_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe { simd_fmax(a, b) }
 }
@@ -27931,6 +28059,7 @@ pub fn vmaxnm_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vmaxnmq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe { simd_fmax(a, b) }
 }
@@ -27987,6 +28116,7 @@ pub fn vmaxnmq_f32(a: float32x4_t, b: float32x4_t) -> float32x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vmin_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vmins.v4f16")]
@@ -28009,6 +28139,7 @@ pub fn vmin_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vminq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vmins.v8f16")]
@@ -28377,6 +28508,7 @@ pub fn vminq_u32(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vminnm_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe { simd_fmin(a, b) }
 }
@@ -28391,6 +28523,7 @@ pub fn vminnm_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vminnmq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe { simd_fmin(a, b) }
 }
@@ -31573,6 +31706,7 @@ pub fn vmmlaq_u32(a: uint32x4_t, b: uint8x16_t, c: uint8x16_t) -> uint32x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vmov_n_f16(a: f16) -> float16x4_t {
     vdup_n_f16(a)
 }
@@ -31587,6 +31721,7 @@ pub fn vmov_n_f16(a: f16) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vmovq_n_f16(a: f16) -> float16x8_t {
     vdupq_n_f16(a)
 }
@@ -32315,6 +32450,7 @@ pub fn vmovn_u64(a: uint64x2_t) -> uint32x2_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vmul_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe { simd_mul(a, b) }
 }
@@ -32329,6 +32465,7 @@ pub fn vmul_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vmulq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe { simd_mul(a, b) }
 }
@@ -32386,6 +32523,7 @@ pub fn vmulq_f32(a: float32x4_t, b: float32x4_t) -> float32x4_t {
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vmul_lane_f16<const LANE: i32>(a: float16x4_t, v: float16x4_t) -> float16x4_t {
     static_assert_uimm_bits!(LANE, 2);
     unsafe {
@@ -32407,6 +32545,7 @@ pub fn vmul_lane_f16<const LANE: i32>(a: float16x4_t, v: float16x4_t) -> float16
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vmulq_lane_f16<const LANE: i32>(a: float16x8_t, v: float16x4_t) -> float16x8_t {
     static_assert_uimm_bits!(LANE, 2);
     unsafe {
@@ -33022,6 +33161,7 @@ pub fn vmulq_laneq_u32<const LANE: i32>(a: uint32x4_t, b: uint32x4_t) -> uint32x
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vmul_n_f16(a: float16x4_t, b: f16) -> float16x4_t {
     unsafe { simd_mul(a, vdup_n_f16(b)) }
 }
@@ -33036,6 +33176,7 @@ pub fn vmul_n_f16(a: float16x4_t, b: f16) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vmulq_n_f16(a: float16x8_t, b: f16) -> float16x8_t {
     unsafe { simd_mul(a, vdupq_n_f16(b)) }
 }
@@ -34369,6 +34510,7 @@ pub fn vmvnq_u8(a: uint8x16_t) -> uint8x16_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vneg_f16(a: float16x4_t) -> float16x4_t {
     unsafe { simd_neg(a) }
 }
@@ -34383,6 +34525,7 @@ pub fn vneg_f16(a: float16x4_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vnegq_f16(a: float16x8_t) -> float16x8_t {
     unsafe { simd_neg(a) }
 }
@@ -35613,6 +35756,7 @@ pub fn vpadalq_u32(a: uint64x2_t, b: uint32x4_t) -> uint64x2_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vpadd_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vpadd.v4f16")]
@@ -41943,6 +42087,7 @@ pub fn vraddhn_u64(a: uint64x2_t, b: uint64x2_t) -> uint32x2_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vrecpe_f16(a: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vrecpe.v4f16")]
@@ -41965,6 +42110,7 @@ pub fn vrecpe_f16(a: float16x4_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vrecpeq_f16(a: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vrecpe.v8f16")]
@@ -42103,6 +42249,7 @@ pub fn vrecpeq_u32(a: uint32x4_t) -> uint32x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vrecps_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vrecps.v4f16")]
@@ -42125,6 +42272,7 @@ pub fn vrecps_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vrecpsq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vrecps.v8f16")]
@@ -42206,6 +42354,7 @@ pub fn vrecpsq_f32(a: float32x4_t, b: float32x4_t) -> float32x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f32_f16(a: float16x4_t) -> float32x2_t {
     unsafe { transmute(a) }
 }
@@ -42221,6 +42370,7 @@ pub fn vreinterpret_f32_f16(a: float16x4_t) -> float32x2_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f32_f16(a: float16x4_t) -> float32x2_t {
     let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
     unsafe {
@@ -42240,6 +42390,7 @@ pub fn vreinterpret_f32_f16(a: float16x4_t) -> float32x2_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_s8_f16(a: float16x4_t) -> int8x8_t {
     unsafe { transmute(a) }
 }
@@ -42255,6 +42406,7 @@ pub fn vreinterpret_s8_f16(a: float16x4_t) -> int8x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_s8_f16(a: float16x4_t) -> int8x8_t {
     let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
     unsafe {
@@ -42274,6 +42426,7 @@ pub fn vreinterpret_s8_f16(a: float16x4_t) -> int8x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_s16_f16(a: float16x4_t) -> int16x4_t {
     unsafe { transmute(a) }
 }
@@ -42289,6 +42442,7 @@ pub fn vreinterpret_s16_f16(a: float16x4_t) -> int16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_s16_f16(a: float16x4_t) -> int16x4_t {
     let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
     unsafe {
@@ -42308,6 +42462,7 @@ pub fn vreinterpret_s16_f16(a: float16x4_t) -> int16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_s32_f16(a: float16x4_t) -> int32x2_t {
     unsafe { transmute(a) }
 }
@@ -42323,6 +42478,7 @@ pub fn vreinterpret_s32_f16(a: float16x4_t) -> int32x2_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_s32_f16(a: float16x4_t) -> int32x2_t {
     let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
     unsafe {
@@ -42342,6 +42498,7 @@ pub fn vreinterpret_s32_f16(a: float16x4_t) -> int32x2_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_s64_f16(a: float16x4_t) -> int64x1_t {
     unsafe { transmute(a) }
 }
@@ -42357,6 +42514,7 @@ pub fn vreinterpret_s64_f16(a: float16x4_t) -> int64x1_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_s64_f16(a: float16x4_t) -> int64x1_t {
     let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
     unsafe { transmute(a) }
@@ -42373,6 +42531,7 @@ pub fn vreinterpret_s64_f16(a: float16x4_t) -> int64x1_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_u8_f16(a: float16x4_t) -> uint8x8_t {
     unsafe { transmute(a) }
 }
@@ -42388,6 +42547,7 @@ pub fn vreinterpret_u8_f16(a: float16x4_t) -> uint8x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_u8_f16(a: float16x4_t) -> uint8x8_t {
     let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
     unsafe {
@@ -42407,6 +42567,7 @@ pub fn vreinterpret_u8_f16(a: float16x4_t) -> uint8x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_u16_f16(a: float16x4_t) -> uint16x4_t {
     unsafe { transmute(a) }
 }
@@ -42422,6 +42583,7 @@ pub fn vreinterpret_u16_f16(a: float16x4_t) -> uint16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_u16_f16(a: float16x4_t) -> uint16x4_t {
     let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
     unsafe {
@@ -42441,6 +42603,7 @@ pub fn vreinterpret_u16_f16(a: float16x4_t) -> uint16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_u32_f16(a: float16x4_t) -> uint32x2_t {
     unsafe { transmute(a) }
 }
@@ -42456,6 +42619,7 @@ pub fn vreinterpret_u32_f16(a: float16x4_t) -> uint32x2_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_u32_f16(a: float16x4_t) -> uint32x2_t {
     let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
     unsafe {
@@ -42475,6 +42639,7 @@ pub fn vreinterpret_u32_f16(a: float16x4_t) -> uint32x2_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_u64_f16(a: float16x4_t) -> uint64x1_t {
     unsafe { transmute(a) }
 }
@@ -42490,6 +42655,7 @@ pub fn vreinterpret_u64_f16(a: float16x4_t) -> uint64x1_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_u64_f16(a: float16x4_t) -> uint64x1_t {
     let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
     unsafe { transmute(a) }
@@ -42506,6 +42672,7 @@ pub fn vreinterpret_u64_f16(a: float16x4_t) -> uint64x1_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_p8_f16(a: float16x4_t) -> poly8x8_t {
     unsafe { transmute(a) }
 }
@@ -42521,6 +42688,7 @@ pub fn vreinterpret_p8_f16(a: float16x4_t) -> poly8x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_p8_f16(a: float16x4_t) -> poly8x8_t {
     let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
     unsafe {
@@ -42540,6 +42708,7 @@ pub fn vreinterpret_p8_f16(a: float16x4_t) -> poly8x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_p16_f16(a: float16x4_t) -> poly16x4_t {
     unsafe { transmute(a) }
 }
@@ -42555,6 +42724,7 @@ pub fn vreinterpret_p16_f16(a: float16x4_t) -> poly16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_p16_f16(a: float16x4_t) -> poly16x4_t {
     let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
     unsafe {
@@ -42574,6 +42744,7 @@ pub fn vreinterpret_p16_f16(a: float16x4_t) -> poly16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f32_f16(a: float16x8_t) -> float32x4_t {
     unsafe { transmute(a) }
 }
@@ -42589,6 +42760,7 @@ pub fn vreinterpretq_f32_f16(a: float16x8_t) -> float32x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f32_f16(a: float16x8_t) -> float32x4_t {
     let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
     unsafe {
@@ -42608,6 +42780,7 @@ pub fn vreinterpretq_f32_f16(a: float16x8_t) -> float32x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_s8_f16(a: float16x8_t) -> int8x16_t {
     unsafe { transmute(a) }
 }
@@ -42623,6 +42796,7 @@ pub fn vreinterpretq_s8_f16(a: float16x8_t) -> int8x16_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_s8_f16(a: float16x8_t) -> int8x16_t {
     let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
     unsafe {
@@ -42646,6 +42820,7 @@ pub fn vreinterpretq_s8_f16(a: float16x8_t) -> int8x16_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_s16_f16(a: float16x8_t) -> int16x8_t {
     unsafe { transmute(a) }
 }
@@ -42661,6 +42836,7 @@ pub fn vreinterpretq_s16_f16(a: float16x8_t) -> int16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_s16_f16(a: float16x8_t) -> int16x8_t {
     let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
     unsafe {
@@ -42680,6 +42856,7 @@ pub fn vreinterpretq_s16_f16(a: float16x8_t) -> int16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_s32_f16(a: float16x8_t) -> int32x4_t {
     unsafe { transmute(a) }
 }
@@ -42695,6 +42872,7 @@ pub fn vreinterpretq_s32_f16(a: float16x8_t) -> int32x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_s32_f16(a: float16x8_t) -> int32x4_t {
     let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
     unsafe {
@@ -42714,6 +42892,7 @@ pub fn vreinterpretq_s32_f16(a: float16x8_t) -> int32x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_s64_f16(a: float16x8_t) -> int64x2_t {
     unsafe { transmute(a) }
 }
@@ -42729,6 +42908,7 @@ pub fn vreinterpretq_s64_f16(a: float16x8_t) -> int64x2_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_s64_f16(a: float16x8_t) -> int64x2_t {
     let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
     unsafe {
@@ -42748,6 +42928,7 @@ pub fn vreinterpretq_s64_f16(a: float16x8_t) -> int64x2_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_u8_f16(a: float16x8_t) -> uint8x16_t {
     unsafe { transmute(a) }
 }
@@ -42763,6 +42944,7 @@ pub fn vreinterpretq_u8_f16(a: float16x8_t) -> uint8x16_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_u8_f16(a: float16x8_t) -> uint8x16_t {
     let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
     unsafe {
@@ -42786,6 +42968,7 @@ pub fn vreinterpretq_u8_f16(a: float16x8_t) -> uint8x16_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_u16_f16(a: float16x8_t) -> uint16x8_t {
     unsafe { transmute(a) }
 }
@@ -42801,6 +42984,7 @@ pub fn vreinterpretq_u16_f16(a: float16x8_t) -> uint16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_u16_f16(a: float16x8_t) -> uint16x8_t {
     let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
     unsafe {
@@ -42820,6 +43004,7 @@ pub fn vreinterpretq_u16_f16(a: float16x8_t) -> uint16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_u32_f16(a: float16x8_t) -> uint32x4_t {
     unsafe { transmute(a) }
 }
@@ -42835,6 +43020,7 @@ pub fn vreinterpretq_u32_f16(a: float16x8_t) -> uint32x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_u32_f16(a: float16x8_t) -> uint32x4_t {
     let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
     unsafe {
@@ -42854,6 +43040,7 @@ pub fn vreinterpretq_u32_f16(a: float16x8_t) -> uint32x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_u64_f16(a: float16x8_t) -> uint64x2_t {
     unsafe { transmute(a) }
 }
@@ -42869,6 +43056,7 @@ pub fn vreinterpretq_u64_f16(a: float16x8_t) -> uint64x2_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_u64_f16(a: float16x8_t) -> uint64x2_t {
     let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
     unsafe {
@@ -42888,6 +43076,7 @@ pub fn vreinterpretq_u64_f16(a: float16x8_t) -> uint64x2_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_p8_f16(a: float16x8_t) -> poly8x16_t {
     unsafe { transmute(a) }
 }
@@ -42903,6 +43092,7 @@ pub fn vreinterpretq_p8_f16(a: float16x8_t) -> poly8x16_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_p8_f16(a: float16x8_t) -> poly8x16_t {
     let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
     unsafe {
@@ -42926,6 +43116,7 @@ pub fn vreinterpretq_p8_f16(a: float16x8_t) -> poly8x16_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_p16_f16(a: float16x8_t) -> poly16x8_t {
     unsafe { transmute(a) }
 }
@@ -42941,6 +43132,7 @@ pub fn vreinterpretq_p16_f16(a: float16x8_t) -> poly16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_p16_f16(a: float16x8_t) -> poly16x8_t {
     let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
     unsafe {
@@ -42960,6 +43152,7 @@ pub fn vreinterpretq_p16_f16(a: float16x8_t) -> poly16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_f32(a: float32x2_t) -> float16x4_t {
     unsafe { transmute(a) }
 }
@@ -42975,6 +43168,7 @@ pub fn vreinterpret_f16_f32(a: float32x2_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_f32(a: float32x2_t) -> float16x4_t {
     let a: float32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
     unsafe {
@@ -42994,6 +43188,7 @@ pub fn vreinterpret_f16_f32(a: float32x2_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_f32(a: float32x4_t) -> float16x8_t {
     unsafe { transmute(a) }
 }
@@ -43009,6 +43204,7 @@ pub fn vreinterpretq_f16_f32(a: float32x4_t) -> float16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_f32(a: float32x4_t) -> float16x8_t {
     let a: float32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
     unsafe {
@@ -43028,6 +43224,7 @@ pub fn vreinterpretq_f16_f32(a: float32x4_t) -> float16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_s8(a: int8x8_t) -> float16x4_t {
     unsafe { transmute(a) }
 }
@@ -43043,6 +43240,7 @@ pub fn vreinterpret_f16_s8(a: int8x8_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_s8(a: int8x8_t) -> float16x4_t {
     let a: int8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
     unsafe {
@@ -43062,6 +43260,7 @@ pub fn vreinterpret_f16_s8(a: int8x8_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_s8(a: int8x16_t) -> float16x8_t {
     unsafe { transmute(a) }
 }
@@ -43077,6 +43276,7 @@ pub fn vreinterpretq_f16_s8(a: int8x16_t) -> float16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_s8(a: int8x16_t) -> float16x8_t {
     let a: int8x16_t =
         unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
@@ -43097,6 +43297,7 @@ pub fn vreinterpretq_f16_s8(a: int8x16_t) -> float16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_s16(a: int16x4_t) -> float16x4_t {
     unsafe { transmute(a) }
 }
@@ -43112,6 +43313,7 @@ pub fn vreinterpret_f16_s16(a: int16x4_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_s16(a: int16x4_t) -> float16x4_t {
     let a: int16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
     unsafe {
@@ -43131,6 +43333,7 @@ pub fn vreinterpret_f16_s16(a: int16x4_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_s16(a: int16x8_t) -> float16x8_t {
     unsafe { transmute(a) }
 }
@@ -43146,6 +43349,7 @@ pub fn vreinterpretq_f16_s16(a: int16x8_t) -> float16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_s16(a: int16x8_t) -> float16x8_t {
     let a: int16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
     unsafe {
@@ -43165,6 +43369,7 @@ pub fn vreinterpretq_f16_s16(a: int16x8_t) -> float16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_s32(a: int32x2_t) -> float16x4_t {
     unsafe { transmute(a) }
 }
@@ -43180,6 +43385,7 @@ pub fn vreinterpret_f16_s32(a: int32x2_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_s32(a: int32x2_t) -> float16x4_t {
     let a: int32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
     unsafe {
@@ -43199,6 +43405,7 @@ pub fn vreinterpret_f16_s32(a: int32x2_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_s32(a: int32x4_t) -> float16x8_t {
     unsafe { transmute(a) }
 }
@@ -43214,6 +43421,7 @@ pub fn vreinterpretq_f16_s32(a: int32x4_t) -> float16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_s32(a: int32x4_t) -> float16x8_t {
     let a: int32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
     unsafe {
@@ -43233,6 +43441,7 @@ pub fn vreinterpretq_f16_s32(a: int32x4_t) -> float16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_s64(a: int64x1_t) -> float16x4_t {
     unsafe { transmute(a) }
 }
@@ -43248,6 +43457,7 @@ pub fn vreinterpret_f16_s64(a: int64x1_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_s64(a: int64x1_t) -> float16x4_t {
     unsafe {
         let ret_val: float16x4_t = transmute(a);
@@ -43266,6 +43476,7 @@ pub fn vreinterpret_f16_s64(a: int64x1_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_s64(a: int64x2_t) -> float16x8_t {
     unsafe { transmute(a) }
 }
@@ -43281,6 +43492,7 @@ pub fn vreinterpretq_f16_s64(a: int64x2_t) -> float16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_s64(a: int64x2_t) -> float16x8_t {
     let a: int64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
     unsafe {
@@ -43300,6 +43512,7 @@ pub fn vreinterpretq_f16_s64(a: int64x2_t) -> float16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_u8(a: uint8x8_t) -> float16x4_t {
     unsafe { transmute(a) }
 }
@@ -43315,6 +43528,7 @@ pub fn vreinterpret_f16_u8(a: uint8x8_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_u8(a: uint8x8_t) -> float16x4_t {
     let a: uint8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
     unsafe {
@@ -43334,6 +43548,7 @@ pub fn vreinterpret_f16_u8(a: uint8x8_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_u8(a: uint8x16_t) -> float16x8_t {
     unsafe { transmute(a) }
 }
@@ -43349,6 +43564,7 @@ pub fn vreinterpretq_f16_u8(a: uint8x16_t) -> float16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_u8(a: uint8x16_t) -> float16x8_t {
     let a: uint8x16_t =
         unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
@@ -43369,6 +43585,7 @@ pub fn vreinterpretq_f16_u8(a: uint8x16_t) -> float16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_u16(a: uint16x4_t) -> float16x4_t {
     unsafe { transmute(a) }
 }
@@ -43384,6 +43601,7 @@ pub fn vreinterpret_f16_u16(a: uint16x4_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_u16(a: uint16x4_t) -> float16x4_t {
     let a: uint16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
     unsafe {
@@ -43403,6 +43621,7 @@ pub fn vreinterpret_f16_u16(a: uint16x4_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_u16(a: uint16x8_t) -> float16x8_t {
     unsafe { transmute(a) }
 }
@@ -43418,6 +43637,7 @@ pub fn vreinterpretq_f16_u16(a: uint16x8_t) -> float16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_u16(a: uint16x8_t) -> float16x8_t {
     let a: uint16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
     unsafe {
@@ -43437,6 +43657,7 @@ pub fn vreinterpretq_f16_u16(a: uint16x8_t) -> float16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_u32(a: uint32x2_t) -> float16x4_t {
     unsafe { transmute(a) }
 }
@@ -43452,6 +43673,7 @@ pub fn vreinterpret_f16_u32(a: uint32x2_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_u32(a: uint32x2_t) -> float16x4_t {
     let a: uint32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
     unsafe {
@@ -43471,6 +43693,7 @@ pub fn vreinterpret_f16_u32(a: uint32x2_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_u32(a: uint32x4_t) -> float16x8_t {
     unsafe { transmute(a) }
 }
@@ -43486,6 +43709,7 @@ pub fn vreinterpretq_f16_u32(a: uint32x4_t) -> float16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_u32(a: uint32x4_t) -> float16x8_t {
     let a: uint32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
     unsafe {
@@ -43505,6 +43729,7 @@ pub fn vreinterpretq_f16_u32(a: uint32x4_t) -> float16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_u64(a: uint64x1_t) -> float16x4_t {
     unsafe { transmute(a) }
 }
@@ -43520,6 +43745,7 @@ pub fn vreinterpret_f16_u64(a: uint64x1_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_u64(a: uint64x1_t) -> float16x4_t {
     unsafe {
         let ret_val: float16x4_t = transmute(a);
@@ -43538,6 +43764,7 @@ pub fn vreinterpret_f16_u64(a: uint64x1_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_u64(a: uint64x2_t) -> float16x8_t {
     unsafe { transmute(a) }
 }
@@ -43553,6 +43780,7 @@ pub fn vreinterpretq_f16_u64(a: uint64x2_t) -> float16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_u64(a: uint64x2_t) -> float16x8_t {
     let a: uint64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
     unsafe {
@@ -43572,6 +43800,7 @@ pub fn vreinterpretq_f16_u64(a: uint64x2_t) -> float16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_p8(a: poly8x8_t) -> float16x4_t {
     unsafe { transmute(a) }
 }
@@ -43587,6 +43816,7 @@ pub fn vreinterpret_f16_p8(a: poly8x8_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_p8(a: poly8x8_t) -> float16x4_t {
     let a: poly8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
     unsafe {
@@ -43606,6 +43836,7 @@ pub fn vreinterpret_f16_p8(a: poly8x8_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_p8(a: poly8x16_t) -> float16x8_t {
     unsafe { transmute(a) }
 }
@@ -43621,6 +43852,7 @@ pub fn vreinterpretq_f16_p8(a: poly8x16_t) -> float16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_p8(a: poly8x16_t) -> float16x8_t {
     let a: poly8x16_t =
         unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
@@ -43641,6 +43873,7 @@ pub fn vreinterpretq_f16_p8(a: poly8x16_t) -> float16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_p16(a: poly16x4_t) -> float16x4_t {
     unsafe { transmute(a) }
 }
@@ -43656,6 +43889,7 @@ pub fn vreinterpret_f16_p16(a: poly16x4_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_p16(a: poly16x4_t) -> float16x4_t {
     let a: poly16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
     unsafe {
@@ -43675,6 +43909,7 @@ pub fn vreinterpret_f16_p16(a: poly16x4_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_p16(a: poly16x8_t) -> float16x8_t {
     unsafe { transmute(a) }
 }
@@ -43690,6 +43925,7 @@ pub fn vreinterpretq_f16_p16(a: poly16x8_t) -> float16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_p16(a: poly16x8_t) -> float16x8_t {
     let a: poly16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
     unsafe {
@@ -43709,6 +43945,7 @@ pub fn vreinterpretq_f16_p16(a: poly16x8_t) -> float16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_p128(a: p128) -> float16x8_t {
     unsafe { transmute(a) }
 }
@@ -43724,6 +43961,7 @@ pub fn vreinterpretq_f16_p128(a: p128) -> float16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_p128(a: p128) -> float16x8_t {
     unsafe {
         let ret_val: float16x8_t = transmute(a);
@@ -43742,6 +43980,7 @@ pub fn vreinterpretq_f16_p128(a: p128) -> float16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_p64_f16(a: float16x4_t) -> poly64x1_t {
     unsafe { transmute(a) }
 }
@@ -43757,6 +43996,7 @@ pub fn vreinterpret_p64_f16(a: float16x4_t) -> poly64x1_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_p64_f16(a: float16x4_t) -> poly64x1_t {
     let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
     unsafe { transmute(a) }
@@ -43773,6 +44013,7 @@ pub fn vreinterpret_p64_f16(a: float16x4_t) -> poly64x1_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_p128_f16(a: float16x8_t) -> p128 {
     unsafe { transmute(a) }
 }
@@ -43788,6 +44029,7 @@ pub fn vreinterpretq_p128_f16(a: float16x8_t) -> p128 {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_p128_f16(a: float16x8_t) -> p128 {
     let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
     unsafe { transmute(a) }
@@ -43804,6 +44046,7 @@ pub fn vreinterpretq_p128_f16(a: float16x8_t) -> p128 {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_p64_f16(a: float16x8_t) -> poly64x2_t {
     unsafe { transmute(a) }
 }
@@ -43819,6 +44062,7 @@ pub fn vreinterpretq_p64_f16(a: float16x8_t) -> poly64x2_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_p64_f16(a: float16x8_t) -> poly64x2_t {
     let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
     unsafe {
@@ -43838,6 +44082,7 @@ pub fn vreinterpretq_p64_f16(a: float16x8_t) -> poly64x2_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_p64(a: poly64x1_t) -> float16x4_t {
     unsafe { transmute(a) }
 }
@@ -43853,6 +44098,7 @@ pub fn vreinterpret_f16_p64(a: poly64x1_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpret_f16_p64(a: poly64x1_t) -> float16x4_t {
     unsafe {
         let ret_val: float16x4_t = transmute(a);
@@ -43871,6 +44117,7 @@ pub fn vreinterpret_f16_p64(a: poly64x1_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_p64(a: poly64x2_t) -> float16x8_t {
     unsafe { transmute(a) }
 }
@@ -43886,6 +44133,7 @@ pub fn vreinterpretq_f16_p64(a: poly64x2_t) -> float16x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vreinterpretq_f16_p64(a: poly64x2_t) -> float16x8_t {
     let a: poly64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
     unsafe {
@@ -57882,6 +58130,7 @@ pub fn vrev64q_u8(a: uint8x16_t) -> uint8x16_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vrev64_f16(a: float16x4_t) -> float16x4_t {
     unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) }
 }
@@ -57896,6 +58145,7 @@ pub fn vrev64_f16(a: float16x4_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vrev64q_f16(a: float16x8_t) -> float16x8_t {
     unsafe { simd_shuffle!(a, a, [3, 2, 1, 0, 7, 6, 5, 4]) }
 }
@@ -58258,6 +58508,7 @@ pub fn vrhaddq_u32(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vrndn_f16(a: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -58280,6 +58531,7 @@ pub fn vrndn_f16(a: float16x4_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vrndnq_f16(a: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -59366,6 +59618,7 @@ pub fn vrshrn_n_u64<const N: i32>(a: uint64x2_t) -> uint32x2_t {
     assert_instr(frsqrte)
 )]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vrsqrte_f16(a: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vrsqrte.v4f16")]
@@ -59388,6 +59641,7 @@ pub fn vrsqrte_f16(a: float16x4_t) -> float16x4_t {
     assert_instr(frsqrte)
 )]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vrsqrteq_f16(a: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vrsqrte.v8f16")]
@@ -59526,6 +59780,7 @@ pub fn vrsqrteq_u32(a: uint32x4_t) -> uint32x4_t {
     assert_instr(frsqrts)
 )]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vrsqrts_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vrsqrts.v4f16")]
@@ -59548,6 +59803,7 @@ pub fn vrsqrts_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     assert_instr(frsqrts)
 )]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vrsqrtsq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vrsqrts.v8f16")]
@@ -60231,6 +60487,7 @@ pub fn vrsubhn_u64(a: uint64x2_t, b: uint64x2_t) -> uint32x2_t {
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vset_lane_f16<const LANE: i32>(a: f16, b: float16x4_t) -> float16x4_t {
     static_assert_uimm_bits!(LANE, 2);
     unsafe { simd_insert!(b, LANE as u32, a) }
@@ -60247,6 +60504,7 @@ pub fn vset_lane_f16<const LANE: i32>(a: f16, b: float16x4_t) -> float16x4_t {
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vsetq_lane_f16<const LANE: i32>(a: f16, b: float16x8_t) -> float16x8_t {
     static_assert_uimm_bits!(LANE, 3);
     unsafe { simd_insert!(b, LANE as u32, a) }
@@ -63699,6 +63957,7 @@ pub fn vsriq_n_p16<const N: i32>(a: poly16x8_t, b: poly16x8_t) -> poly16x8_t {
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr("vst1.16"))]
 pub unsafe fn vst1_f16(ptr: *mut f16, a: float16x4_t) {
     vst1_v4f16(
@@ -63716,6 +63975,7 @@ pub unsafe fn vst1_f16(ptr: *mut f16, a: float16x4_t) {
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr("vst1.16"))]
 pub unsafe fn vst1q_f16(ptr: *mut f16, a: float16x8_t) {
     vst1q_v8f16(
@@ -63734,6 +63994,7 @@ pub unsafe fn vst1q_f16(ptr: *mut f16, a: float16x8_t) {
 #[cfg_attr(test, assert_instr(vst1))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vst1_f16_x2(a: *mut f16, b: float16x4x2_t) {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vst1x2.p0.v4f16")]
@@ -63751,6 +64012,7 @@ pub unsafe fn vst1_f16_x2(a: *mut f16, b: float16x4x2_t) {
 #[cfg_attr(test, assert_instr(vst1))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vst1q_f16_x2(a: *mut f16, b: float16x8x2_t) {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vst1x2.p0.v8f16")]
@@ -63767,6 +64029,7 @@ pub unsafe fn vst1q_f16_x2(a: *mut f16, b: float16x8x2_t) {
 #[cfg_attr(test, assert_instr(st1))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vst1_f16_x2(a: *mut f16, b: float16x4x2_t) {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -63786,6 +64049,7 @@ pub unsafe fn vst1_f16_x2(a: *mut f16, b: float16x4x2_t) {
 #[cfg_attr(test, assert_instr(st1))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vst1q_f16_x2(a: *mut f16, b: float16x8x2_t) {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -63806,6 +64070,7 @@ pub unsafe fn vst1q_f16_x2(a: *mut f16, b: float16x8x2_t) {
 #[cfg_attr(test, assert_instr(vst1))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vst1_f16_x3(a: *mut f16, b: float16x4x3_t) {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vst1x3.p0.v4f16")]
@@ -63823,6 +64088,7 @@ pub unsafe fn vst1_f16_x3(a: *mut f16, b: float16x4x3_t) {
 #[cfg_attr(test, assert_instr(vst1))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vst1q_f16_x3(a: *mut f16, b: float16x8x3_t) {
     unsafe extern "unadjusted" {
         #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vst1x3.p0.v8f16")]
@@ -63839,6 +64105,7 @@ pub unsafe fn vst1q_f16_x3(a: *mut f16, b: float16x8x3_t) {
 #[cfg_attr(test, assert_instr(st1))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vst1_f16_x3(a: *mut f16, b: float16x4x3_t) {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -63858,6 +64125,7 @@ pub unsafe fn vst1_f16_x3(a: *mut f16, b: float16x4x3_t) {
 #[cfg_attr(test, assert_instr(st1))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vst1q_f16_x3(a: *mut f16, b: float16x8x3_t) {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -63877,6 +64145,7 @@ pub unsafe fn vst1q_f16_x3(a: *mut f16, b: float16x8x3_t) {
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(vst1))]
 pub unsafe fn vst1_f16_x4(a: *mut f16, b: float16x4x4_t) {
     unsafe extern "unadjusted" {
@@ -63900,6 +64169,7 @@ pub unsafe fn vst1_f16_x4(a: *mut f16, b: float16x4x4_t) {
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(vst1))]
 pub unsafe fn vst1q_f16_x4(a: *mut f16, b: float16x8x4_t) {
     unsafe extern "unadjusted" {
@@ -63923,6 +64193,7 @@ pub unsafe fn vst1q_f16_x4(a: *mut f16, b: float16x8x4_t) {
 #[cfg_attr(test, assert_instr(st1))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vst1_f16_x4(a: *mut f16, b: float16x4x4_t) {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -63948,6 +64219,7 @@ pub unsafe fn vst1_f16_x4(a: *mut f16, b: float16x4x4_t) {
 #[cfg_attr(test, assert_instr(st1))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vst1q_f16_x4(a: *mut f16, b: float16x8x4_t) {
     unsafe extern "unadjusted" {
         #[cfg_attr(
@@ -64556,6 +64828,7 @@ pub unsafe fn vst1q_f32_x4(a: *mut f32, b: float32x4x4_t) {
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vst1_lane_f16<const LANE: i32>(a: *mut f16, b: float16x4_t) {
     static_assert_uimm_bits!(LANE, 2);
     *a = simd_extract!(b, LANE as u32);
@@ -64574,6 +64847,7 @@ pub unsafe fn vst1_lane_f16<const LANE: i32>(a: *mut f16, b: float16x4_t) {
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vst1q_lane_f16<const LANE: i32>(a: *mut f16, b: float16x8_t) {
     static_assert_uimm_bits!(LANE, 3);
     *a = simd_extract!(b, LANE as u32);
@@ -67138,6 +67412,7 @@ unsafe fn vst1q_v8i16(addr: *const i8, val: int16x8_t, align: i32) {
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr("vst1.16"))]
 unsafe fn vst1_v4f16(addr: *const i8, val: float16x4_t, align: i32) {
     unsafe extern "unadjusted" {
@@ -67155,6 +67430,7 @@ unsafe fn vst1_v4f16(addr: *const i8, val: float16x4_t, align: i32) {
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr("vst1.16"))]
 unsafe fn vst1q_v8f16(addr: *const i8, val: float16x8_t, align: i32) {
     unsafe extern "unadjusted" {
@@ -67196,6 +67472,7 @@ pub unsafe fn vst1q_lane_p64<const LANE: i32>(a: *mut p64, b: poly64x2_t) {
 #[cfg(not(target_arch = "arm"))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(st2))]
 pub unsafe fn vst2_f16(a: *mut f16, b: float16x4x2_t) {
     unsafe extern "unadjusted" {
@@ -67215,6 +67492,7 @@ pub unsafe fn vst2_f16(a: *mut f16, b: float16x4x2_t) {
 #[cfg(not(target_arch = "arm"))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(st2))]
 pub unsafe fn vst2q_f16(a: *mut f16, b: float16x8x2_t) {
     unsafe extern "unadjusted" {
@@ -67235,6 +67513,7 @@ pub unsafe fn vst2q_f16(a: *mut f16, b: float16x8x2_t) {
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(vst2))]
 pub unsafe fn vst2_f16(a: *mut f16, b: float16x4x2_t) {
     unsafe extern "unadjusted" {
@@ -67252,6 +67531,7 @@ pub unsafe fn vst2_f16(a: *mut f16, b: float16x4x2_t) {
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(vst2))]
 pub unsafe fn vst2q_f16(a: *mut f16, b: float16x8x2_t) {
     unsafe extern "unadjusted" {
@@ -67550,6 +67830,7 @@ pub unsafe fn vst2q_s32(a: *mut i32, b: int32x4x2_t) {
 #[cfg_attr(test, assert_instr(st2, LANE = 0))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vst2_lane_f16<const LANE: i32>(a: *mut f16, b: float16x4x2_t) {
     static_assert_uimm_bits!(LANE, 2);
     unsafe extern "unadjusted" {
@@ -67571,6 +67852,7 @@ pub unsafe fn vst2_lane_f16<const LANE: i32>(a: *mut f16, b: float16x4x2_t) {
 #[cfg_attr(test, assert_instr(st2, LANE = 0))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vst2q_lane_f16<const LANE: i32>(a: *mut f16, b: float16x8x2_t) {
     static_assert_uimm_bits!(LANE, 3);
     unsafe extern "unadjusted" {
@@ -67593,6 +67875,7 @@ pub unsafe fn vst2q_lane_f16<const LANE: i32>(a: *mut f16, b: float16x8x2_t) {
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vst2_lane_f16<const LANE: i32>(a: *mut f16, b: float16x4x2_t) {
     static_assert_uimm_bits!(LANE, 2);
     unsafe extern "unadjusted" {
@@ -67612,6 +67895,7 @@ pub unsafe fn vst2_lane_f16<const LANE: i32>(a: *mut f16, b: float16x4x2_t) {
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vst2q_lane_f16<const LANE: i32>(a: *mut f16, b: float16x8x2_t) {
     static_assert_uimm_bits!(LANE, 1);
     unsafe extern "unadjusted" {
@@ -68413,6 +68697,7 @@ pub unsafe fn vst2q_p16(a: *mut p16, b: poly16x8x2_t) {
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(vst3))]
 pub unsafe fn vst3_f16(a: *mut f16, b: float16x4x3_t) {
     unsafe extern "unadjusted" {
@@ -68430,6 +68715,7 @@ pub unsafe fn vst3_f16(a: *mut f16, b: float16x4x3_t) {
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(vst3))]
 pub unsafe fn vst3q_f16(a: *mut f16, b: float16x8x3_t) {
     unsafe extern "unadjusted" {
@@ -68446,6 +68732,7 @@ pub unsafe fn vst3q_f16(a: *mut f16, b: float16x8x3_t) {
 #[cfg(not(target_arch = "arm"))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(st3))]
 pub unsafe fn vst3_f16(a: *mut f16, b: float16x4x3_t) {
     unsafe extern "unadjusted" {
@@ -68465,6 +68752,7 @@ pub unsafe fn vst3_f16(a: *mut f16, b: float16x4x3_t) {
 #[cfg(not(target_arch = "arm"))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(st3))]
 pub unsafe fn vst3q_f16(a: *mut f16, b: float16x8x3_t) {
     unsafe extern "unadjusted" {
@@ -68767,6 +69055,7 @@ pub unsafe fn vst3q_s32(a: *mut i32, b: int32x4x3_t) {
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vst3_lane_f16<const LANE: i32>(a: *mut f16, b: float16x4x3_t) {
     static_assert_uimm_bits!(LANE, 2);
     unsafe extern "unadjusted" {
@@ -68793,6 +69082,7 @@ pub unsafe fn vst3_lane_f16<const LANE: i32>(a: *mut f16, b: float16x4x3_t) {
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vst3q_lane_f16<const LANE: i32>(a: *mut f16, b: float16x8x3_t) {
     static_assert_uimm_bits!(LANE, 3);
     unsafe extern "unadjusted" {
@@ -68818,6 +69108,7 @@ pub unsafe fn vst3q_lane_f16<const LANE: i32>(a: *mut f16, b: float16x8x3_t) {
 #[cfg_attr(test, assert_instr(st3, LANE = 0))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vst3_lane_f16<const LANE: i32>(a: *mut f16, b: float16x4x3_t) {
     static_assert_uimm_bits!(LANE, 2);
     unsafe extern "unadjusted" {
@@ -68839,6 +69130,7 @@ pub unsafe fn vst3_lane_f16<const LANE: i32>(a: *mut f16, b: float16x4x3_t) {
 #[cfg_attr(test, assert_instr(st3, LANE = 0))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vst3q_lane_f16<const LANE: i32>(a: *mut f16, b: float16x8x3_t) {
     static_assert_uimm_bits!(LANE, 3);
     unsafe extern "unadjusted" {
@@ -69685,6 +69977,7 @@ pub unsafe fn vst3q_p16(a: *mut p16, b: poly16x8x3_t) {
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(vst4))]
 pub unsafe fn vst4_f16(a: *mut f16, b: float16x4x4_t) {
     unsafe extern "unadjusted" {
@@ -69709,6 +70002,7 @@ pub unsafe fn vst4_f16(a: *mut f16, b: float16x4x4_t) {
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(vst4))]
 pub unsafe fn vst4q_f16(a: *mut f16, b: float16x8x4_t) {
     unsafe extern "unadjusted" {
@@ -69732,6 +70026,7 @@ pub unsafe fn vst4q_f16(a: *mut f16, b: float16x8x4_t) {
 #[cfg(not(target_arch = "arm"))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(st4))]
 pub unsafe fn vst4_f16(a: *mut f16, b: float16x4x4_t) {
     unsafe extern "unadjusted" {
@@ -69751,6 +70046,7 @@ pub unsafe fn vst4_f16(a: *mut f16, b: float16x4x4_t) {
 #[cfg(not(target_arch = "arm"))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(st4))]
 pub unsafe fn vst4q_f16(a: *mut f16, b: float16x8x4_t) {
     unsafe extern "unadjusted" {
@@ -70102,6 +70398,7 @@ pub unsafe fn vst4q_s32(a: *mut i32, b: int32x4x4_t) {
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vst4_lane_f16<const LANE: i32>(a: *mut f16, b: float16x4x4_t) {
     static_assert_uimm_bits!(LANE, 2);
     unsafe extern "unadjusted" {
@@ -70129,6 +70426,7 @@ pub unsafe fn vst4_lane_f16<const LANE: i32>(a: *mut f16, b: float16x4x4_t) {
 #[rustc_legacy_const_generics(2)]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vst4q_lane_f16<const LANE: i32>(a: *mut f16, b: float16x8x4_t) {
     static_assert_uimm_bits!(LANE, 3);
     unsafe extern "unadjusted" {
@@ -70155,6 +70453,7 @@ pub unsafe fn vst4q_lane_f16<const LANE: i32>(a: *mut f16, b: float16x8x4_t) {
 #[cfg_attr(test, assert_instr(st4, LANE = 0))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vst4_lane_f16<const LANE: i32>(a: *mut f16, b: float16x4x4_t) {
     static_assert_uimm_bits!(LANE, 2);
     unsafe extern "unadjusted" {
@@ -70183,6 +70482,7 @@ pub unsafe fn vst4_lane_f16<const LANE: i32>(a: *mut f16, b: float16x4x4_t) {
 #[cfg_attr(test, assert_instr(st4, LANE = 0))]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub unsafe fn vst4q_lane_f16<const LANE: i32>(a: *mut f16, b: float16x8x4_t) {
     static_assert_uimm_bits!(LANE, 3);
     unsafe extern "unadjusted" {
@@ -71124,6 +71424,7 @@ pub unsafe fn vstrq_p128(a: *mut p128, b: p128) {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vsub_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
     unsafe { simd_sub(a, b) }
 }
@@ -71138,6 +71439,7 @@ pub fn vsub_f16(a: float16x4_t, b: float16x4_t) -> float16x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vsubq_f16(a: float16x8_t, b: float16x8_t) -> float16x8_t {
     unsafe { simd_sub(a, b) }
 }
@@ -73002,6 +73304,7 @@ pub fn vtbx4_p8(a: poly8x8_t, b: poly8x8x4_t, c: uint8x8_t) -> poly8x8_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vtrn_f16(a: float16x4_t, b: float16x4_t) -> float16x4x2_t {
     unsafe {
         let a1: float16x4_t = simd_shuffle!(a, b, [0, 4, 2, 6]);
@@ -73024,6 +73327,7 @@ pub fn vtrn_f16(a: float16x4_t, b: float16x4_t) -> float16x4x2_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vtrnq_f16(a: float16x8_t, b: float16x8_t) -> float16x8x2_t {
     unsafe {
         let a1: float16x8_t = simd_shuffle!(a, b, [0, 8, 2, 10, 4, 12, 6, 14]);
@@ -74134,6 +74438,7 @@ pub fn vusmmlaq_s32(a: int32x4_t, b: uint8x16_t, c: int8x16_t) -> int32x4_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vuzp_f16(a: float16x4_t, b: float16x4_t) -> float16x4x2_t {
     unsafe {
         let a0: float16x4_t = simd_shuffle!(a, b, [0, 2, 4, 6]);
@@ -74156,6 +74461,7 @@ pub fn vuzp_f16(a: float16x4_t, b: float16x4_t) -> float16x4x2_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vuzpq_f16(a: float16x8_t, b: float16x8_t) -> float16x8x2_t {
     unsafe {
         let a0: float16x8_t = simd_shuffle!(a, b, [0, 2, 4, 6, 8, 10, 12, 14]);
@@ -74724,6 +75030,7 @@ pub fn vuzpq_p16(a: poly16x8_t, b: poly16x8_t) -> poly16x8x2_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vzip_f16(a: float16x4_t, b: float16x4_t) -> float16x4x2_t {
     unsafe {
         let a0: float16x4_t = simd_shuffle!(a, b, [0, 4, 1, 5]);
@@ -74746,6 +75053,7 @@ pub fn vzip_f16(a: float16x4_t, b: float16x4_t) -> float16x4x2_t {
 )]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
 pub fn vzipq_f16(a: float16x8_t, b: float16x8_t) -> float16x8x2_t {
     unsafe {
         let a0: float16x8_t = simd_shuffle!(a, b, [0, 8, 1, 9, 2, 10, 3, 11]);
diff --git a/library/stdarch/crates/core_arch/src/arm_shared/neon/mod.rs b/library/stdarch/crates/core_arch/src/arm_shared/neon/mod.rs
index 60c9daef68c42..fbd1967c544ad 100644
--- a/library/stdarch/crates/core_arch/src/arm_shared/neon/mod.rs
+++ b/library/stdarch/crates/core_arch/src/arm_shared/neon/mod.rs
@@ -5503,8 +5503,12 @@ mod tests {
     test_vcombine!(test_vcombine_s16 => vcombine_s16([3_i16, -4, 5, -6], [13_i16, -14, 15, -16]));
     test_vcombine!(test_vcombine_u16 => vcombine_u16([3_u16, 4, 5, 6], [13_u16, 14, 15, 16]));
     test_vcombine!(test_vcombine_p16 => vcombine_p16([3_u16, 4, 5, 6], [13_u16, 14, 15, 16]));
-    test_vcombine!(test_vcombine_f16 => vcombine_f16([3_f16, 4., 5., 6.],
-    [13_f16, 14., 15., 16.]));
+    #[cfg(not(target_arch = "arm64ec"))]
+    mod fp16 {
+        use super::*;
+        test_vcombine!(test_vcombine_f16 => vcombine_f16([3_f16, 4., 5., 6.],
+        [13_f16, 14., 15., 16.]));
+    }
 
     test_vcombine!(test_vcombine_s32 => vcombine_s32([3_i32, -4], [13_i32, -14]));
     test_vcombine!(test_vcombine_u32 => vcombine_u32([3_u32, 4], [13_u32, 14]));
diff --git a/library/stdarch/crates/stdarch-gen-arm/spec/neon/aarch64.spec.yml b/library/stdarch/crates/stdarch-gen-arm/spec/neon/aarch64.spec.yml
index a31613e6b1aef..a1a837bc61064 100644
--- a/library/stdarch/crates/stdarch-gen-arm/spec/neon/aarch64.spec.yml
+++ b/library/stdarch/crates/stdarch-gen-arm/spec/neon/aarch64.spec.yml
@@ -17,6 +17,10 @@ neon-stable: &neon-stable
 target-not-arm: &target-not-arm
   FnCall: [cfg, [{ FnCall: [not, ['target_arch = "arm"']]}]]
 
+# #[cfg(not(target_arch = "arm64ec"))]
+target-not-arm64ec: &target-not-arm64ec
+  FnCall: [cfg, [{ FnCall: [not, ['target_arch = "arm64ec"']]}]]
+
 # #[cfg_attr(all(test, not(target_env = "msvc"))]
 msvc-disabled: &msvc-disabled
   FnCall: [all, [test, {FnCall: [not, ['target_env = "msvc"']]}]]
@@ -169,6 +173,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fabd]
     safety: safe
     types:
@@ -368,6 +373,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcmp]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["h_f16", "f16", "u16"]
@@ -559,6 +565,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcmp]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["h_f16", "f16", "u16"]
@@ -642,6 +649,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcmp]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["h_f16", "f16", "u16"]
@@ -777,6 +785,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcmp]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["h_f16", "f16", "u16"]
@@ -859,6 +868,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcmp]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["h_f16", "f16", "u16"]
@@ -931,6 +941,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [facgt]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["h_f16", "f16", "u16", i32]
@@ -988,6 +999,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [facge]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["h_f16", "f16", "u16", i32]
@@ -1036,6 +1048,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [facgt]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["h_f16", "f16", "u16"]
@@ -1078,6 +1091,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [facge]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["h_f16", "f16", "u16"]
@@ -1175,6 +1189,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['1']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const N: i32']
     safety: safe
     types:
@@ -1202,6 +1217,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['1']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const N: i32']
     safety: safe
     types:
@@ -1219,6 +1235,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['1']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const N: i32']
     safety: safe
     types:
@@ -1246,6 +1263,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['1']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const N: i32']
     safety: safe
     types:
@@ -1264,6 +1282,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['1']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const N: i32']
     safety: safe
     types:
@@ -1386,6 +1405,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [scvtf]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["s16", "f16", "h_f16_s16", i16]
@@ -1402,6 +1422,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtzs]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["f16", "s16", "h", i16, 'a as i16']
@@ -1418,6 +1439,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtzu]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["f16", "u16", "h", 'a as u16']
@@ -1435,6 +1457,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [ucvtf]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["u16", "f16", "h_f16_u16"]
@@ -1486,6 +1509,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtn2]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x8_t, float16x4_t, float32x4_t]
@@ -1503,6 +1527,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtl2]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float32x4_t, float16x8_t]
@@ -1650,6 +1675,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['1']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const N: i32']
     safety: safe
     types:
@@ -1675,6 +1701,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['1']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const N: i32']
     safety: safe
     types:
@@ -1693,6 +1720,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['1']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const N: i32']
     safety: safe
     types:
@@ -1783,6 +1811,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtas]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, int16x4_t]
@@ -1821,6 +1850,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtau]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["f16", "u32", 'h_u32_f16']
@@ -1842,6 +1872,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtas]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["f16", "i32", 'h_s32_f16']
@@ -1863,6 +1894,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtas]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["f16", "i16", 'h_s16_f16', 's32']
@@ -1877,6 +1909,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtau]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["f16", "u16", 'h_u16_f16', 'u32']
@@ -1948,6 +1981,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtns]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, int16x4_t]
@@ -1968,6 +2002,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtnu]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, uint16x4_t]
@@ -1987,6 +2022,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtns]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["f16", "i32", 'h']
@@ -2007,6 +2043,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtns]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["f16", "i16", 'h', 'i32']
@@ -2022,6 +2059,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtnu]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["f16", "u32", 'h']
@@ -2042,6 +2080,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtnu]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["f16", "u16", 'h', 'u32']
@@ -2077,6 +2116,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtms]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, int16x4_t]
@@ -2097,6 +2137,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtmu]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, uint16x4_t]
@@ -2291,6 +2332,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtps]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, int16x4_t]
@@ -2311,6 +2353,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtpu]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, uint16x4_t]
@@ -2331,6 +2374,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtps]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["f16", "i32", 'h']
@@ -2351,6 +2395,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtps]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["f16", "i16", 'h', 'i32']
@@ -2365,6 +2410,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtpu]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["f16", "u32", 'h']
@@ -2385,6 +2431,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtpu]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["f16", "u16", 'h', 'u32']
@@ -2531,6 +2578,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['1']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const N: i32']
     safety: safe
     types:
@@ -2549,6 +2597,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['1']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const N: i32']
     safety: safe
     types:
@@ -2770,6 +2819,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fneg]
     safety: safe
     types:
@@ -2986,6 +3036,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [frintx]
     safety: safe
     types:
@@ -3002,6 +3053,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [frintx]
     safety: safe
     types:
@@ -3033,6 +3085,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [frinta]
     safety: safe
     types:
@@ -3049,6 +3102,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [frinta]
     safety: safe
     types:
@@ -3096,6 +3150,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [frintn]
     safety: safe
     types:
@@ -3130,6 +3185,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [frintm]
     safety: safe
     types:
@@ -3146,6 +3202,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [frintm]
     safety: safe
     types:
@@ -3178,6 +3235,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [frintp]
     safety: safe
     types:
@@ -3193,6 +3251,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [frintp]
     safety: safe
     types:
@@ -3222,6 +3281,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [frintz]
     safety: safe
     types:
@@ -3238,6 +3298,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [frintz]
     safety: safe
     types:
@@ -3273,6 +3334,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [frinti]
     safety: safe
     types:
@@ -3293,6 +3355,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     # TODO: double check me
     assert_instr: [frinti]
     safety: safe
@@ -5205,6 +5268,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fmulx]
     safety: safe
     types:
@@ -5243,6 +5307,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fmulx]
     safety: safe
     types:
@@ -5385,6 +5450,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['2']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ["const LANE: i32"]
     safety: safe
     types:
@@ -5438,6 +5504,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['2']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ["const LANE: i32"]
     safety: safe
     types:
@@ -5462,6 +5529,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fmulx]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, "f16"]
@@ -5546,6 +5614,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fmla]
     safety: safe
     types:
@@ -5582,6 +5651,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fdiv]
     safety: safe
     types:
@@ -5597,6 +5667,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [nop]
     safety: safe
     types:
@@ -5637,6 +5708,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [nop]
     safety: safe
     types:
@@ -5928,6 +6000,7 @@ intrinsics:
       - *neon-fp16
       - *enable-fcma
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fcadd]
     safety: safe
     types:
@@ -5948,6 +6021,7 @@ intrinsics:
       - *neon-fp16
       - *enable-fcma
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fcadd]
     safety: safe
     types:
@@ -5988,6 +6062,7 @@ intrinsics:
       - FnCall: [target_feature, ['enable = "neon,fcma"']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fcmla]
     safety: safe
     types:
@@ -6028,6 +6103,7 @@ intrinsics:
       - FnCall: [target_feature, ['enable = "neon,fcma"']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fcmla]
     safety: safe
     types:
@@ -6069,6 +6145,7 @@ intrinsics:
       - FnCall: [target_feature, ['enable = "neon,fcma"']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fcmla]
     safety: safe
     types:
@@ -6113,6 +6190,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['3']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ["const LANE: i32"]
     safety: safe
     types:
@@ -6158,6 +6236,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['3']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ["const LANE: i32"]
     safety: safe
     types:
@@ -6203,6 +6282,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['3']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ["const LANE: i32"]
     safety: safe
     types:
@@ -6245,6 +6325,7 @@ intrinsics:
       - FnCall: [target_feature, ['enable = "neon,fcma"']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fcmla]
     safety: safe
     types:
@@ -6290,6 +6371,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['3']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ["const LANE: i32"]
     safety: safe
     types:
@@ -6337,6 +6419,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['3']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ["const LANE: i32"]
     safety: safe
     types:
@@ -6384,6 +6467,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['3']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ["const LANE: i32"]
     safety: safe
     types:
@@ -6430,6 +6514,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['3']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ["const LANE: i32"]
     safety: safe
     types:
@@ -6473,6 +6558,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['3']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ["const LANE: i32"]
     safety: safe
     types:
@@ -6568,6 +6654,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fmax]
     safety: safe
     types:
@@ -6601,6 +6688,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fmaxnm]
     safety: safe
     types:
@@ -6616,6 +6704,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fminnm]
     safety: safe
     types:
@@ -6657,6 +6746,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fmaxnmv]
     safety: safe
     types:
@@ -6673,6 +6763,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fminnmv]
     safety: safe
     types:
@@ -6689,6 +6780,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fmaxv]
     safety: safe
     types:
@@ -6708,6 +6800,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fminv]
     safety: safe
     types:
@@ -6762,6 +6855,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fmin]
     safety: safe
     types:
@@ -6875,6 +6969,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [faddp]
     safety: safe
     types:
@@ -6894,6 +6989,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fmaxp]
     safety: safe
     types:
@@ -6914,6 +7010,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fmaxnmp]
     safety: safe
     types:
@@ -6934,6 +7031,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fminp]
     safety: safe
     types:
@@ -6954,6 +7052,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fminnmp]
     safety: safe
     types:
@@ -8379,6 +8478,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fsqrt]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - float16x4_t
@@ -8393,6 +8493,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fsqrt]
     safety: safe
     types:
@@ -8445,6 +8546,7 @@ intrinsics:
       - *neon-fp16
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [frsqrts]]}]]
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [h_f16, "f16"]
@@ -8501,6 +8603,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [frecpe]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [h_f16, "f16"]
@@ -8557,6 +8660,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [frecps]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [h_f16, "f16"]
@@ -8595,6 +8699,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [frecpx]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [h_f16, "f16"]
@@ -8687,6 +8792,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [nop]
     safety: safe
     types:
@@ -9586,6 +9692,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
       - FnCall: [cfg_attr, [{FnCall: [all, [test, {FnCall: [not, ['target_env = "msvc"']]}]]}, {FnCall: [assert_instr, [trn1]]}]]
     safety: safe
     types:
@@ -9647,6 +9754,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
       - FnCall: [cfg_attr, [{FnCall: [all, [test, {FnCall: [not, ['target_env = "msvc"']]}]]}, {FnCall: [assert_instr, [trn2]]}]]
     safety: safe
     types:
@@ -9715,6 +9823,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
       - FnCall: [cfg_attr, [{FnCall: [all, [test, {FnCall: [not, ['target_env = "msvc"']]}]]}, {FnCall: [assert_instr, [zip2]]}]]
     safety: safe
     types:
@@ -9765,6 +9874,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
       - FnCall: [cfg_attr, [{FnCall: [all, [test, {FnCall: [not, ['target_env = "msvc"']]}]]}, {FnCall: [assert_instr, [zip1]]}]]
     safety: safe
     types:
@@ -9826,6 +9936,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
       - FnCall: [cfg_attr, [{FnCall: [all, [test, {FnCall: [not, ['target_env = "msvc"']]}]]}, {FnCall: [assert_instr, [uzp1]]}]]
     safety: safe
     types:
@@ -9891,6 +10002,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
       - FnCall: [cfg_attr, [{FnCall: [all, [test, {FnCall: [not, ['target_env = "msvc"']]}]]}, {FnCall: [assert_instr, [uzp2]]}]]
     safety: safe
     types:
@@ -10180,6 +10292,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['3']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const LANE: i32']
     safety: safe
     types:
@@ -10206,6 +10319,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['3']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const LANE: i32']
     safety: safe
     types:
@@ -10230,6 +10344,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fmsub]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["f16", "h_f16"]
@@ -10342,6 +10457,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fmadd]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["f16", "h_f16"]
@@ -10358,6 +10474,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['3']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const LANE: i32']
     safety: safe
     types:
@@ -10377,6 +10494,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['3']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const LANE: i32']
     safety: safe
     types:
@@ -10541,6 +10659,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcmeq]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, uint16x4_t, 'f16x4', 'f16x4::new(0.0, 0.0, 0.0, 0.0)']
@@ -10576,6 +10695,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcmp]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["f16", "u16", "h_f16"]
@@ -10700,6 +10820,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcmp]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["h_f16", "f16", "u16"]
@@ -10842,6 +10963,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcmp]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["h_f16", "f16", "u16"]
@@ -10972,6 +11094,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcmp]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["h_f16", "f16", "u16"]
@@ -11126,6 +11249,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['2']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const LANE: i32']
     safety: safe
     types:
@@ -11146,6 +11270,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [nop]
     safety: safe
     types:
@@ -11183,6 +11308,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['2']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const LANE: i32']
     safety: safe
     types:
@@ -11328,6 +11454,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcmp]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["f16", "u16", 'h_f16']
@@ -11399,6 +11526,7 @@ intrinsics:
     attr:
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fmls]
     safety: safe
     types:
@@ -11651,6 +11779,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [frsqrte]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["h_f16", "f16"]
@@ -11734,6 +11863,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtau]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, uint16x4_t]
@@ -11772,6 +11902,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtms]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["f16", "i32", 'h']
@@ -11792,6 +11923,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtms]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["f16", "i16", 'h', 'i32']
@@ -11807,6 +11939,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtmu]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["f16", "u32", 'h']
@@ -11827,6 +11960,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [fcvtmu]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["f16", "u16", 'h', 'u32']
@@ -12857,6 +12991,7 @@ intrinsics:
       - FnCall: [target_feature, ['enable = "{type[2]}"']]
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [ldr]]}]]
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety:
       unsafe: [neon]
     types:
@@ -12924,6 +13059,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [str]]}]]
       - FnCall: [allow, ['clippy::cast_ptr_alignment']]
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety:
       unsafe: [neon]
     types:
@@ -13637,6 +13773,7 @@ intrinsics:
       - *neon-fp16
       - *enable-fhm
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fmlal2]
     safety: safe
     types:
@@ -13660,6 +13797,7 @@ intrinsics:
       - *enable-fhm
       - FnCall: [rustc_legacy_const_generics, ['3']]
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const LANE: i32']
     safety: safe
     types:
@@ -13684,6 +13822,7 @@ intrinsics:
       - *neon-fp16
       - *enable-fhm
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fmlal]
     safety: safe
     types:
@@ -13707,6 +13846,7 @@ intrinsics:
       - *enable-fhm
       - FnCall: [rustc_legacy_const_generics, ['3']]
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const LANE: i32']
     safety: safe
     types:
@@ -13731,6 +13871,7 @@ intrinsics:
       - *neon-fp16
       - *enable-fhm
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fmlsl2]
     safety: safe
     types:
@@ -13753,6 +13894,7 @@ intrinsics:
       - *enable-fhm
       - FnCall: [rustc_legacy_const_generics, ['3']]
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const LANE: i32']
     safety: safe
     types:
@@ -13777,6 +13919,7 @@ intrinsics:
       - *neon-fp16
       - *enable-fhm
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [fmlsl]
     safety: safe
     types:
@@ -13799,6 +13942,7 @@ intrinsics:
       - *enable-fhm
       - FnCall: [rustc_legacy_const_generics, ['3']]
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const LANE: i32']
     safety: safe
     types:
diff --git a/library/stdarch/crates/stdarch-gen-arm/spec/neon/arm_shared.spec.yml b/library/stdarch/crates/stdarch-gen-arm/spec/neon/arm_shared.spec.yml
index c96c6e2a0c0b5..f16a257399bc8 100644
--- a/library/stdarch/crates/stdarch-gen-arm/spec/neon/arm_shared.spec.yml
+++ b/library/stdarch/crates/stdarch-gen-arm/spec/neon/arm_shared.spec.yml
@@ -37,6 +37,10 @@ target-is-arm: &target-is-arm
 target-not-arm: &target-not-arm
   FnCall: [cfg, [{ FnCall: [not, ['target_arch = "arm"']]}]]
 
+# #[cfg(not(target_arch = "arm64ec"))]
+target-not-arm64ec: &target-not-arm64ec
+  FnCall: [cfg, [{ FnCall: [not, ['target_arch = "arm64ec"']]}]]
+
 not-arm: &not-arm
   FnCall: [not, ['target_arch = "arm"']]
 
@@ -278,6 +282,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fabd]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - float16x4_t
@@ -396,6 +401,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fcmeq]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, uint16x4_t]
@@ -457,6 +463,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fabs]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - float16x4_t
@@ -474,6 +481,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fabs]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ['h_f16', 'f16']
@@ -555,6 +563,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fcmgt]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, uint16x4_t]
@@ -573,6 +582,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fcmgt]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, uint16x4_t, f16x4, 'f16x4::new(0.0, 0.0, 0.0, 0.0)']
@@ -651,6 +661,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fcmge]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, uint16x4_t]
@@ -668,6 +679,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fcmle]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, uint16x4_t, f16x4, 'f16x4::new(0.0, 0.0, 0.0, 0.0)']
@@ -849,6 +861,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [facgt]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, uint16x4_t]
@@ -895,6 +908,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [facge]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, uint16x4_t]
@@ -935,6 +949,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [facgt]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, uint16x4_t]
@@ -970,6 +985,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [facge]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, uint16x4_t]
@@ -1004,6 +1020,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [scvtf]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [int16x4_t, float16x4_t]
@@ -1038,6 +1055,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [ucvtf]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [uint16x4_t, float16x4_t]
@@ -1109,6 +1127,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['1']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const N: i32']
     safety: safe
     types:
@@ -1140,6 +1159,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['1']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const N: i32']
     safety: safe
     types:
@@ -1171,6 +1191,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['1']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const N: i32']
     safety: safe
     types:
@@ -1229,6 +1250,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['1']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const N: i32']
     safety: safe
     types:
@@ -1482,6 +1504,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['1']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const N: i32']
     safety: safe
     types:
@@ -1501,6 +1524,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [dup]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, f16, 'float16x4', '_n_']
@@ -1519,6 +1543,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['1']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const N: i32']
     safety: safe
     types:
@@ -1740,6 +1765,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['2']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const N: i32']
     safety: safe
     types:
@@ -1758,6 +1784,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['2']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const N: i32']
     safety: safe
     types:
@@ -2207,6 +2234,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fneg]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, 'f16']
@@ -2478,6 +2506,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [frintn]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - float16x4_t
@@ -2743,6 +2772,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [ld1]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety:
       unsafe: [neon]
     types:
@@ -2773,6 +2803,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ["2"]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const LANE: i32']
     safety:
       unsafe: [neon]
@@ -2793,6 +2824,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [ld1r]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety:
       unsafe: [neon]
     types:
@@ -3385,6 +3417,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [vld2]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety:
       unsafe: [neon]
     types:
@@ -3413,6 +3446,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [ld2]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety:
       unsafe: [neon]
     types:
@@ -3440,6 +3474,7 @@ intrinsics:
       - *neon-fp16
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [vld2]]}]]
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety:
       unsafe: [neon]
     types:
@@ -3469,6 +3504,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [ld2r]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety:
       unsafe: [neon]
     types:
@@ -3498,6 +3534,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ["2"]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs:
       - "const LANE: i32"
     safety:
@@ -3540,6 +3577,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ["2"]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs:
       - "const LANE: i32"
     safety:
@@ -3580,6 +3618,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [vld3]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety:
       unsafe: [neon]
     types:
@@ -3608,6 +3647,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [ld3]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety:
       unsafe: [neon]
     types:
@@ -3635,6 +3675,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [vld3]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety:
       unsafe: [neon]
     types:
@@ -3664,6 +3705,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [ld3r]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety:
       unsafe: [neon]
     types:
@@ -3693,6 +3735,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ["2"]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs:
       - "const LANE: i32"
     safety:
@@ -3737,6 +3780,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ["2"]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs:
       - "const LANE: i32"
     safety:
@@ -4718,6 +4762,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ["2"]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     types:
       - ['*mut f16', float16x4_t, '2']
       - ['*mut f16', float16x8_t, '3']
@@ -4955,6 +5000,7 @@ intrinsics:
       - *neon-v7
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [vst1]
     types:
       - [f16, float16x4x4_t, float16x4_t]
@@ -5098,6 +5144,7 @@ intrinsics:
       - *target-not-arm
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [st2]
     safety:
       unsafe: [neon]
@@ -5188,6 +5235,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [st2, 'LANE = 0']]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const LANE: i32']
     safety:
       unsafe: [neon]
@@ -5279,6 +5327,7 @@ intrinsics:
       - *neon-v7
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [vst2]
     safety:
       unsafe: [neon]
@@ -5345,6 +5394,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['2']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const LANE: i32']
     safety:
       unsafe: [neon]
@@ -5555,6 +5605,7 @@ intrinsics:
       - *neon-v7
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [vst3]
     safety:
       unsafe: [neon]
@@ -5623,6 +5674,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['2']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const LANE: i32']
     safety:
       unsafe: [neon]
@@ -5683,6 +5735,7 @@ intrinsics:
       - *target-not-arm
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [st3]
     safety:
       unsafe: [neon]
@@ -5747,6 +5800,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [st3, 'LANE = 0']]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const LANE: i32']
     safety:
       unsafe: [neon]
@@ -5960,6 +6014,7 @@ intrinsics:
       - *neon-v7
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [vst4]
     safety:
       unsafe: [neon]
@@ -6029,6 +6084,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['2']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const LANE: i32']
     safety:
       unsafe: [neon]
@@ -6091,6 +6147,7 @@ intrinsics:
       - *target-not-arm
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [st4]
     safety:
       unsafe: [neon]
@@ -6157,6 +6214,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [st4, 'LANE = 0']]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const LANE: i32']
     safety:
       unsafe: [neon]
@@ -6317,6 +6375,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fmul]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [f16, float16x4_t]
@@ -6366,6 +6425,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['2']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ["const LANE: i32"]
     safety: safe
     types:
@@ -6569,6 +6629,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fmla]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - float16x4_t
@@ -6678,6 +6739,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fsub]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ['f16', float16x4_t]
@@ -6696,6 +6758,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fadd]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - float16x4_t
@@ -6716,6 +6779,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fadd]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ['h_f16', 'f16']
@@ -7194,6 +7258,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fmax]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - float16x4_t
@@ -7236,6 +7301,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fmaxnm]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - float16x4_t
@@ -7254,6 +7320,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fminnm]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - float16x4_t
@@ -7340,6 +7407,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fmin]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - float16x4_t
@@ -7404,6 +7472,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [faddp]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - float16x4_t
@@ -8247,6 +8316,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [vrsqrts]]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [frsqrts]]}]]
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - float16x4_t
@@ -8295,6 +8365,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [frecpe]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - float16x4_t
@@ -8343,6 +8414,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [frecps]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - float16x4_t
@@ -8675,6 +8747,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [nop]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       # non-q
@@ -8737,6 +8810,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [nop]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [poly64x1_t, float16x4_t]
@@ -8759,6 +8833,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [rev64]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, "[3, 2, 1, 0]"]
@@ -9074,6 +9149,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [nop]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ["u64", float16x4_t]
@@ -9147,6 +9223,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ['2']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const LANE: i32']
     safety: safe
     types:
@@ -9578,6 +9655,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [trn2]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, float16x4x2_t, '[0, 4, 2, 6]', '[1, 5, 3, 7]']
@@ -9733,6 +9811,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [zip2]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, float16x4x2_t, '[0, 4, 1, 5]', '[2, 6, 3, 7]']
@@ -9803,6 +9882,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [uzp2]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, float16x4x2_t, '[0, 2, 4, 6]', '[1, 3, 5, 7]']
@@ -10050,6 +10130,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [vst1]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety:
       unsafe: [neon]
     types:
@@ -10077,6 +10158,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [st1]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety:
       unsafe: [neon]
     types:
@@ -10103,6 +10185,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [vst1]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety:
       unsafe: [neon]
     types:
@@ -10179,6 +10262,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [st1]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety:
       unsafe: [neon]
     types:
@@ -10233,6 +10317,7 @@ intrinsics:
       - FnCall: [cfg_attr, [test, {FnCall: [assert_instr, [st1]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety:
       unsafe: [neon]
     types:
@@ -10376,6 +10461,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fcmge]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, uint16x4_t]
@@ -10394,6 +10480,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fcmge]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, uint16x4_t, f16x4, 'f16x4::new(0.0, 0.0, 0.0, 0.0)']
@@ -10633,6 +10720,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fcvtzu]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, uint16x4_t]
@@ -10652,6 +10740,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fcvtn]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float32x4_t, float16x4_t]
@@ -10668,6 +10757,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fcvtl]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, float32x4_t]
@@ -11029,6 +11119,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fmul]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, "f16"]
@@ -11141,6 +11232,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fcmgt]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, uint16x4_t]
@@ -11159,6 +11251,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fcmlt]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, uint16x4_t, f16x4, 'f16x4::new(0.0, 0.0, 0.0, 0.0)']
@@ -11271,6 +11364,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fmls]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - float16x4_t
@@ -11386,6 +11480,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [vrsqrte]]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [frsqrte]]}]]
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - float16x4_t
@@ -11499,6 +11594,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [fcvtzs]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, int16x4_t]
@@ -11748,6 +11844,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [nop]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety:
       unsafe: [neon]
     types:
@@ -11834,6 +11931,7 @@ intrinsics:
       - FnCall: [target_feature, ['enable = "{type[3]}"']]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, ['{type[2]}']]}]]
     types:
       - ['*const f16', float16x4_t, '"vld1.16"', 'neon,v7', 'crate::mem::align_of::<f16>() as i32', '_v4f16']
@@ -12117,6 +12215,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [vld4]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety:
       unsafe: [neon]
     types:
@@ -12145,6 +12244,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [ld4]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety:
       unsafe: [neon]
     types:
@@ -12172,6 +12272,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, [vld4]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety:
       unsafe: [neon]
     types:
@@ -12201,6 +12302,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [ld4r]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety:
       unsafe: [neon]
     types:
@@ -12230,6 +12332,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ["2"]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs:
       - "const LANE: i32"
     safety:
@@ -12276,6 +12379,7 @@ intrinsics:
       - FnCall: [rustc_legacy_const_generics, ["2"]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs:
       - "const LANE: i32"
     safety:
@@ -13674,6 +13778,7 @@ intrinsics:
       - *neon-v7
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, ['"vst1.{type[4]}"']]}]]
     types:
       - ['_v4f16', '* const i8', float16x4_t, i32, '16']
@@ -13738,6 +13843,7 @@ intrinsics:
       - *neon-v7
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
       - FnCall: [cfg_attr, [*test-is-arm, {FnCall: [assert_instr, ['"vst1.{type[2]}"']]}]]
     types:
       - ['*mut f16', float16x4_t, '16', 'transmute(a)', 'crate::mem::align_of::<f16>() as i32', '_v4f16']
@@ -13918,6 +14024,7 @@ intrinsics:
       - *neon-v7
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [nop]
     safety: safe
     types:
@@ -13933,6 +14040,7 @@ intrinsics:
       - *neon-v7
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     assert_instr: [nop]
     safety: safe
     types:
@@ -13952,6 +14060,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [nop, 'LANE = 0']]}]]
       - FnCall: [rustc_legacy_const_generics, ["1"]]
       - *neon-unstable-f16
+      - *target-not-arm64ec
     static_defs: ['const LANE: i32']
     safety: safe
     types:
@@ -13971,6 +14080,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, [dup]]}]]
       - *neon-fp16
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - [float16x4_t, f16]
@@ -14585,6 +14695,7 @@ intrinsics:
       - FnCall: [cfg_attr, [*test-is-arm, { FnCall: [assert_instr, ['vbsl']]}]]
       - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, ['bsl']]}]]
       - *neon-unstable-f16
+      - *target-not-arm64ec
     safety: safe
     types:
       - ['vbslq_f16', 'uint16x8_t', 'float16x8_t', 'int16x8_t::splat(-1)']
diff --git a/library/stdarch/crates/stdarch-test/src/disassembly.rs b/library/stdarch/crates/stdarch-test/src/disassembly.rs
index f5167ea8d8ef3..4c136cff02ae6 100644
--- a/library/stdarch/crates/stdarch-test/src/disassembly.rs
+++ b/library/stdarch/crates/stdarch-test/src/disassembly.rs
@@ -27,9 +27,9 @@ fn normalize(mut symbol: &str) -> String {
         symbol = symbol[last_colon + 1..].to_string();
     }
 
-    // Normalize to no leading underscore to handle platforms that may
+    // Normalize to no leading mangling chars to handle platforms that may
     // inject extra ones in symbol names.
-    while symbol.starts_with('_') || symbol.starts_with('.') {
+    while symbol.starts_with('_') || symbol.starts_with('.') || symbol.starts_with('#') {
         symbol.remove(0);
     }
     // Windows/x86 has a suffix such as @@4.
@@ -49,6 +49,8 @@ pub(crate) fn disassemble_myself() -> HashSet<Function> {
         "i686-pc-windows-msvc"
     } else if cfg!(target_arch = "aarch64") {
         "aarch64-pc-windows-msvc"
+    } else if cfg!(target_arch = "arm64ec") {
+        "arm64ec-pc-windows-msvc"
     } else {
         panic!("disassembly unimplemented")
     };

From 802fa9255b59c8787d679f5da1f5534f9c0580b0 Mon Sep 17 00:00:00 2001
From: Ifeanyi Orizu <iorizu1811@gmail.com>
Date: Sun, 10 Aug 2025 10:02:03 -0500
Subject: [PATCH 0057/1889] Add config option to exclude locals from doc search

---
 .../crates/ide/src/file_structure.rs          | 307 +++++++++++++++++-
 src/tools/rust-analyzer/crates/ide/src/lib.rs |  12 +-
 .../crates/rust-analyzer/src/cli/symbols.rs   |   9 +-
 .../crates/rust-analyzer/src/config.rs        |  16 +
 .../rust-analyzer/src/handlers/request.rs     |  17 +-
 .../docs/book/src/configuration_generated.md  |   7 +
 .../rust-analyzer/editors/code/package.json   |  10 +
 7 files changed, 350 insertions(+), 28 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide/src/file_structure.rs b/src/tools/rust-analyzer/crates/ide/src/file_structure.rs
index 6820f99facf2c..e0cd32baa97e3 100644
--- a/src/tools/rust-analyzer/crates/ide/src/file_structure.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/file_structure.rs
@@ -23,6 +23,11 @@ pub enum StructureNodeKind {
     Region,
 }
 
+#[derive(Debug, Clone)]
+pub struct FileStructureConfig {
+    pub exclude_locals: bool,
+}
+
 // Feature: File Structure
 //
 // Provides a tree of the symbols defined in the file. Can be used to
@@ -36,21 +41,24 @@ pub enum StructureNodeKind {
 // | VS Code | <kbd>Ctrl+Shift+O</kbd> |
 //
 // ![File Structure](https://user-images.githubusercontent.com/48062697/113020654-b42fc800-917a-11eb-8388-e7dc4d92b02e.gif)
-pub(crate) fn file_structure(file: &SourceFile) -> Vec<StructureNode> {
+pub(crate) fn file_structure(
+    file: &SourceFile,
+    config: &FileStructureConfig,
+) -> Vec<StructureNode> {
     let mut res = Vec::new();
     let mut stack = Vec::new();
 
     for event in file.syntax().preorder_with_tokens() {
         match event {
             WalkEvent::Enter(NodeOrToken::Node(node)) => {
-                if let Some(mut symbol) = structure_node(&node) {
+                if let Some(mut symbol) = structure_node(&node, config) {
                     symbol.parent = stack.last().copied();
                     stack.push(res.len());
                     res.push(symbol);
                 }
             }
             WalkEvent::Leave(NodeOrToken::Node(node)) => {
-                if structure_node(&node).is_some() {
+                if structure_node(&node, config).is_some() {
                     stack.pop().unwrap();
                 }
             }
@@ -71,7 +79,7 @@ pub(crate) fn file_structure(file: &SourceFile) -> Vec<StructureNode> {
     res
 }
 
-fn structure_node(node: &SyntaxNode) -> Option<StructureNode> {
+fn structure_node(node: &SyntaxNode, config: &FileStructureConfig) -> Option<StructureNode> {
     fn decl<N: HasName + HasAttrs>(node: N, kind: StructureNodeKind) -> Option<StructureNode> {
         decl_with_detail(&node, None, kind)
     }
@@ -187,6 +195,10 @@ fn structure_node(node: &SyntaxNode) -> Option<StructureNode> {
                 Some(node)
             },
             ast::LetStmt(it) => {
+                if config.exclude_locals {
+                    return None;
+                }
+
                 let pat = it.pat()?;
 
                 let mut label = String::new();
@@ -254,9 +266,19 @@ mod tests {
 
     use super::*;
 
+    const DEFAULT_CONFIG: FileStructureConfig = FileStructureConfig { exclude_locals: true };
+
     fn check(#[rust_analyzer::rust_fixture] ra_fixture: &str, expect: Expect) {
+        check_with_config(ra_fixture, &DEFAULT_CONFIG, expect);
+    }
+
+    fn check_with_config(
+        #[rust_analyzer::rust_fixture] ra_fixture: &str,
+        config: &FileStructureConfig,
+        expect: Expect,
+    ) {
         let file = SourceFile::parse(ra_fixture, span::Edition::CURRENT).ok().unwrap();
-        let structure = file_structure(&file);
+        let structure = file_structure(&file, config);
         expect.assert_debug_eq(&structure)
     }
 
@@ -701,13 +723,264 @@ fn let_statements() {
                         ),
                         deprecated: false,
                     },
+                ]
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_file_structure_include_locals() {
+        check_with_config(
+            r#"
+struct Foo {
+    x: i32
+}
+
+mod m {
+    fn bar1() {}
+    fn bar2<T>(t: T) -> T {}
+    fn bar3<A,
+        B>(a: A,
+        b: B) -> Vec<
+        u32
+    > {}
+}
+
+enum E { X, Y(i32) }
+type T = ();
+static S: i32 = 42;
+const C: i32 = 42;
+trait Tr {}
+trait Alias = Tr;
+
+macro_rules! mc {
+    () => {}
+}
+
+fn let_statements() {
+    let x = 42;
+    let mut y = x;
+    let Foo {
+        ..
+    } = Foo { x };
+    _ = ();
+    let _ = g();
+}
+"#,
+            &FileStructureConfig { exclude_locals: false },
+            expect![[r#"
+                [
+                    StructureNode {
+                        parent: None,
+                        label: "Foo",
+                        navigation_range: 8..11,
+                        node_range: 1..26,
+                        kind: SymbolKind(
+                            Struct,
+                        ),
+                        detail: None,
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: Some(
+                            0,
+                        ),
+                        label: "x",
+                        navigation_range: 18..19,
+                        node_range: 18..24,
+                        kind: SymbolKind(
+                            Field,
+                        ),
+                        detail: Some(
+                            "i32",
+                        ),
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: None,
+                        label: "m",
+                        navigation_range: 32..33,
+                        node_range: 28..158,
+                        kind: SymbolKind(
+                            Module,
+                        ),
+                        detail: None,
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: Some(
+                            2,
+                        ),
+                        label: "bar1",
+                        navigation_range: 43..47,
+                        node_range: 40..52,
+                        kind: SymbolKind(
+                            Function,
+                        ),
+                        detail: Some(
+                            "fn()",
+                        ),
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: Some(
+                            2,
+                        ),
+                        label: "bar2",
+                        navigation_range: 60..64,
+                        node_range: 57..81,
+                        kind: SymbolKind(
+                            Function,
+                        ),
+                        detail: Some(
+                            "fn<T>(t: T) -> T",
+                        ),
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: Some(
+                            2,
+                        ),
+                        label: "bar3",
+                        navigation_range: 89..93,
+                        node_range: 86..156,
+                        kind: SymbolKind(
+                            Function,
+                        ),
+                        detail: Some(
+                            "fn<A, B>(a: A, b: B) -> Vec< u32 >",
+                        ),
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: None,
+                        label: "E",
+                        navigation_range: 165..166,
+                        node_range: 160..180,
+                        kind: SymbolKind(
+                            Enum,
+                        ),
+                        detail: None,
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: Some(
+                            6,
+                        ),
+                        label: "X",
+                        navigation_range: 169..170,
+                        node_range: 169..170,
+                        kind: SymbolKind(
+                            Variant,
+                        ),
+                        detail: None,
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: Some(
+                            6,
+                        ),
+                        label: "Y",
+                        navigation_range: 172..173,
+                        node_range: 172..178,
+                        kind: SymbolKind(
+                            Variant,
+                        ),
+                        detail: None,
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: None,
+                        label: "T",
+                        navigation_range: 186..187,
+                        node_range: 181..193,
+                        kind: SymbolKind(
+                            TypeAlias,
+                        ),
+                        detail: Some(
+                            "()",
+                        ),
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: None,
+                        label: "S",
+                        navigation_range: 201..202,
+                        node_range: 194..213,
+                        kind: SymbolKind(
+                            Static,
+                        ),
+                        detail: Some(
+                            "i32",
+                        ),
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: None,
+                        label: "C",
+                        navigation_range: 220..221,
+                        node_range: 214..232,
+                        kind: SymbolKind(
+                            Const,
+                        ),
+                        detail: Some(
+                            "i32",
+                        ),
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: None,
+                        label: "Tr",
+                        navigation_range: 239..241,
+                        node_range: 233..244,
+                        kind: SymbolKind(
+                            Trait,
+                        ),
+                        detail: None,
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: None,
+                        label: "Alias",
+                        navigation_range: 251..256,
+                        node_range: 245..262,
+                        kind: SymbolKind(
+                            TraitAlias,
+                        ),
+                        detail: None,
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: None,
+                        label: "mc",
+                        navigation_range: 277..279,
+                        node_range: 264..296,
+                        kind: SymbolKind(
+                            Macro,
+                        ),
+                        detail: None,
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: None,
+                        label: "let_statements",
+                        navigation_range: 301..315,
+                        node_range: 298..429,
+                        kind: SymbolKind(
+                            Function,
+                        ),
+                        detail: Some(
+                            "fn()",
+                        ),
+                        deprecated: false,
+                    },
                     StructureNode {
                         parent: Some(
-                            27,
+                            15,
                         ),
                         label: "x",
-                        navigation_range: 684..685,
-                        node_range: 680..691,
+                        navigation_range: 328..329,
+                        node_range: 324..335,
                         kind: SymbolKind(
                             Local,
                         ),
@@ -716,11 +989,11 @@ fn let_statements() {
                     },
                     StructureNode {
                         parent: Some(
-                            27,
+                            15,
                         ),
                         label: "mut y",
-                        navigation_range: 700..705,
-                        node_range: 696..710,
+                        navigation_range: 344..349,
+                        node_range: 340..354,
                         kind: SymbolKind(
                             Local,
                         ),
@@ -729,11 +1002,11 @@ fn let_statements() {
                     },
                     StructureNode {
                         parent: Some(
-                            27,
+                            15,
                         ),
                         label: "Foo { .. }",
-                        navigation_range: 719..741,
-                        node_range: 715..754,
+                        navigation_range: 363..385,
+                        node_range: 359..398,
                         kind: SymbolKind(
                             Local,
                         ),
@@ -742,11 +1015,11 @@ fn let_statements() {
                     },
                     StructureNode {
                         parent: Some(
-                            27,
+                            15,
                         ),
                         label: "_",
-                        navigation_range: 804..805,
-                        node_range: 800..812,
+                        navigation_range: 419..420,
+                        node_range: 415..427,
                         kind: SymbolKind(
                             Local,
                         ),
diff --git a/src/tools/rust-analyzer/crates/ide/src/lib.rs b/src/tools/rust-analyzer/crates/ide/src/lib.rs
index 98877482ed863..5349ebb7c82a5 100644
--- a/src/tools/rust-analyzer/crates/ide/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/lib.rs
@@ -81,7 +81,7 @@ pub use crate::{
     annotations::{Annotation, AnnotationConfig, AnnotationKind, AnnotationLocation},
     call_hierarchy::{CallHierarchyConfig, CallItem},
     expand_macro::ExpandedMacro,
-    file_structure::{StructureNode, StructureNodeKind},
+    file_structure::{FileStructureConfig, StructureNode, StructureNodeKind},
     folding_ranges::{Fold, FoldKind},
     highlight_related::{HighlightRelatedConfig, HighlightedRange},
     hover::{
@@ -430,12 +430,16 @@ impl Analysis {
 
     /// Returns a tree representation of symbols in the file. Useful to draw a
     /// file outline.
-    pub fn file_structure(&self, file_id: FileId) -> Cancellable<Vec<StructureNode>> {
+    pub fn file_structure(
+        &self,
+        config: &FileStructureConfig,
+        file_id: FileId,
+    ) -> Cancellable<Vec<StructureNode>> {
         // FIXME: Edition
         self.with_db(|db| {
             let editioned_file_id_wrapper = EditionedFileId::current_edition(&self.db, file_id);
-
-            file_structure::file_structure(&db.parse(editioned_file_id_wrapper).tree())
+            let source_file = db.parse(editioned_file_id_wrapper).tree();
+            file_structure::file_structure(&source_file, config)
         })
     }
 
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/symbols.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/symbols.rs
index 9fad6723afcd9..d7af56d3e15be 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/symbols.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/symbols.rs
@@ -1,5 +1,5 @@
 //! Read Rust code on stdin, print syntax tree on stdout.
-use ide::Analysis;
+use ide::{Analysis, FileStructureConfig};
 
 use crate::cli::{flags, read_stdin};
 
@@ -7,7 +7,12 @@ impl flags::Symbols {
     pub fn run(self) -> anyhow::Result<()> {
         let text = read_stdin()?;
         let (analysis, file_id) = Analysis::from_single_file(text);
-        let structure = analysis.file_structure(file_id).unwrap();
+        let structure = analysis
+            // The default setting in config.rs (document_symbol_search_excludeLocals) is to exclude
+            // locals because it is unlikely that users want document search to return the names of
+            // local variables, but here we include them deliberately.
+            .file_structure(&FileStructureConfig { exclude_locals: false }, file_id)
+            .unwrap();
         for s in structure {
             println!("{s:?}");
         }
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
index 1a00295b9ac18..77e5a8e079f84 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
@@ -858,6 +858,9 @@ config_data! {
         /// check will be performed.
         check_workspace: bool = true,
 
+        /// Exclude all locals from document symbol search.
+        document_symbol_search_excludeLocals: bool = true,
+
         /// These proc-macros will be ignored when trying to expand them.
         ///
         /// This config takes a map of crate names with the exported proc-macro names to ignore as values.
@@ -1481,6 +1484,13 @@ pub enum FilesWatcher {
     Server,
 }
 
+/// Configuration for document symbol search requests.
+#[derive(Debug, Clone)]
+pub struct DocumentSymbolConfig {
+    /// Should locals be excluded.
+    pub search_exclude_locals: bool,
+}
+
 #[derive(Debug, Clone)]
 pub struct NotificationsConfig {
     pub cargo_toml_not_found: bool,
@@ -2438,6 +2448,12 @@ impl Config {
         }
     }
 
+    pub fn document_symbol(&self, source_root: Option<SourceRootId>) -> DocumentSymbolConfig {
+        DocumentSymbolConfig {
+            search_exclude_locals: *self.document_symbol_search_excludeLocals(source_root),
+        }
+    }
+
     pub fn workspace_symbol(&self, source_root: Option<SourceRootId>) -> WorkspaceSymbolConfig {
         WorkspaceSymbolConfig {
             search_exclude_imports: *self.workspace_symbol_search_excludeImports(source_root),
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/request.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/request.rs
index 25c0aac405e79..74ed5e344af6d 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/request.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/request.rs
@@ -8,8 +8,9 @@ use anyhow::Context;
 use base64::{Engine, prelude::BASE64_STANDARD};
 use ide::{
     AnnotationConfig, AssistKind, AssistResolveStrategy, Cancellable, CompletionFieldsToResolve,
-    FilePosition, FileRange, HoverAction, HoverGotoTypeData, InlayFieldsToResolve, Query,
-    RangeInfo, ReferenceCategory, Runnable, RunnableKind, SingleResolve, SourceChange, TextEdit,
+    FilePosition, FileRange, FileStructureConfig, HoverAction, HoverGotoTypeData,
+    InlayFieldsToResolve, Query, RangeInfo, ReferenceCategory, Runnable, RunnableKind,
+    SingleResolve, SourceChange, TextEdit,
 };
 use ide_db::{FxHashMap, SymbolKind};
 use itertools::Itertools;
@@ -568,7 +569,14 @@ pub(crate) fn handle_document_symbol(
 
     let mut parents: Vec<(lsp_types::DocumentSymbol, Option<usize>)> = Vec::new();
 
-    for symbol in snap.analysis.file_structure(file_id)? {
+    let config = snap.config.document_symbol(None);
+
+    let structure_nodes = snap.analysis.file_structure(
+        &FileStructureConfig { exclude_locals: config.search_exclude_locals },
+        file_id,
+    )?;
+
+    for symbol in structure_nodes {
         let mut tags = Vec::new();
         if symbol.deprecated {
             tags.push(SymbolTag::DEPRECATED)
@@ -588,8 +596,7 @@ pub(crate) fn handle_document_symbol(
         parents.push((doc_symbol, symbol.parent));
     }
 
-    // Builds hierarchy from a flat list, in reverse order (so that indices
-    // makes sense)
+    // Builds hierarchy from a flat list, in reverse order (so that indices make sense)
     let document_symbols = {
         let mut acc = Vec::new();
         while let Some((mut node, parent_idx)) = parents.pop() {
diff --git a/src/tools/rust-analyzer/docs/book/src/configuration_generated.md b/src/tools/rust-analyzer/docs/book/src/configuration_generated.md
index 99a30d8f62138..6ee956fe0dbf4 100644
--- a/src/tools/rust-analyzer/docs/book/src/configuration_generated.md
+++ b/src/tools/rust-analyzer/docs/book/src/configuration_generated.md
@@ -610,6 +610,13 @@ The warnings will be indicated by a blue squiggly underline in code and a blue i
 the `Problems Panel`.
 
 
+## rust-analyzer.document.symbol.search.excludeLocals {#document.symbol.search.excludeLocals}
+
+Default: `true`
+
+Exclude all locals from document symbol search.
+
+
 ## rust-analyzer.files.exclude {#files.exclude}
 
 Default: `[]`
diff --git a/src/tools/rust-analyzer/editors/code/package.json b/src/tools/rust-analyzer/editors/code/package.json
index 470db244f14bd..328eb509b4eea 100644
--- a/src/tools/rust-analyzer/editors/code/package.json
+++ b/src/tools/rust-analyzer/editors/code/package.json
@@ -1585,6 +1585,16 @@
                     }
                 }
             },
+            {
+                "title": "Document",
+                "properties": {
+                    "rust-analyzer.document.symbol.search.excludeLocals": {
+                        "markdownDescription": "Exclude all locals from document symbol search.",
+                        "default": true,
+                        "type": "boolean"
+                    }
+                }
+            },
             {
                 "title": "Files",
                 "properties": {

From 00d000ce74f8e3bed8abc4cff382f62dcca0d8d5 Mon Sep 17 00:00:00 2001
From: Ifeanyi Orizu <iorizu1811@gmail.com>
Date: Sun, 10 Aug 2025 10:02:34 -0500
Subject: [PATCH 0058/1889] Fix minor things

---
 .../crates/ide/src/file_structure.rs          |  1 -
 .../crates/rust-analyzer/src/config.rs        |  2 +-
 .../rust-analyzer/src/handlers/request.rs     | 38 +++++++++----------
 3 files changed, 20 insertions(+), 21 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide/src/file_structure.rs b/src/tools/rust-analyzer/crates/ide/src/file_structure.rs
index e0cd32baa97e3..ac15af0334fc8 100644
--- a/src/tools/rust-analyzer/crates/ide/src/file_structure.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/file_structure.rs
@@ -213,7 +213,6 @@ fn structure_node(node: &SyntaxNode, config: &FileStructureConfig) -> Option<Str
                     detail: it.ty().map(|ty| ty.to_string()),
                     deprecated: false,
                 };
-
                 Some(node)
             },
             ast::ExternBlock(it) => {
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
index 77e5a8e079f84..d4cd56dc55bf6 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
@@ -3083,7 +3083,7 @@ macro_rules! _config_data {
     }) => {
         /// Default config values for this grouping.
         #[allow(non_snake_case)]
-        #[derive(Debug, Clone )]
+        #[derive(Debug, Clone)]
         struct $name { $($field: $ty,)* }
 
         impl_for_config_data!{
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/request.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/request.rs
index 74ed5e344af6d..6cb28aecf748f 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/request.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/request.rs
@@ -567,7 +567,7 @@ pub(crate) fn handle_document_symbol(
     let file_id = try_default!(from_proto::file_id(&snap, &params.text_document.uri)?);
     let line_index = snap.file_line_index(file_id)?;
 
-    let mut parents: Vec<(lsp_types::DocumentSymbol, Option<usize>)> = Vec::new();
+    let mut symbols: Vec<(lsp_types::DocumentSymbol, Option<usize>)> = Vec::new();
 
     let config = snap.config.document_symbol(None);
 
@@ -576,38 +576,38 @@ pub(crate) fn handle_document_symbol(
         file_id,
     )?;
 
-    for symbol in structure_nodes {
+    for node in structure_nodes {
         let mut tags = Vec::new();
-        if symbol.deprecated {
+        if node.deprecated {
             tags.push(SymbolTag::DEPRECATED)
         };
 
         #[allow(deprecated)]
-        let doc_symbol = lsp_types::DocumentSymbol {
-            name: symbol.label,
-            detail: symbol.detail,
-            kind: to_proto::structure_node_kind(symbol.kind),
+        let symbol = lsp_types::DocumentSymbol {
+            name: node.label,
+            detail: node.detail,
+            kind: to_proto::structure_node_kind(node.kind),
             tags: Some(tags),
-            deprecated: Some(symbol.deprecated),
-            range: to_proto::range(&line_index, symbol.node_range),
-            selection_range: to_proto::range(&line_index, symbol.navigation_range),
+            deprecated: Some(node.deprecated),
+            range: to_proto::range(&line_index, node.node_range),
+            selection_range: to_proto::range(&line_index, node.navigation_range),
             children: None,
         };
-        parents.push((doc_symbol, symbol.parent));
+        symbols.push((symbol, node.parent));
     }
 
-    // Builds hierarchy from a flat list, in reverse order (so that indices make sense)
+    // Builds hierarchy from a flat list, in reverse order (so that the indices make sense)
     let document_symbols = {
         let mut acc = Vec::new();
-        while let Some((mut node, parent_idx)) = parents.pop() {
-            if let Some(children) = &mut node.children {
+        while let Some((mut symbol, parent_idx)) = symbols.pop() {
+            if let Some(children) = &mut symbol.children {
                 children.reverse();
             }
             let parent = match parent_idx {
                 None => &mut acc,
-                Some(i) => parents[i].0.children.get_or_insert_with(Vec::new),
+                Some(i) => symbols[i].0.children.get_or_insert_with(Vec::new),
             };
-            parent.push(node);
+            parent.push(symbol);
         }
         acc.reverse();
         acc
@@ -617,7 +617,7 @@ pub(crate) fn handle_document_symbol(
         document_symbols.into()
     } else {
         let url = to_proto::url(&snap, file_id);
-        let mut symbol_information = Vec::<SymbolInformation>::new();
+        let mut symbol_information = Vec::new();
         for symbol in document_symbols {
             flatten_document_symbol(&symbol, None, &url, &mut symbol_information);
         }
@@ -654,7 +654,7 @@ pub(crate) fn handle_workspace_symbol(
     let _p = tracing::info_span!("handle_workspace_symbol").entered();
 
     let config = snap.config.workspace_symbol(None);
-    let (all_symbols, libs) = decide_search_scope_and_kind(&params, &config);
+    let (all_symbols, libs) = decide_search_kind_and_scope(&params, &config);
 
     let query = {
         let query: String = params.query.chars().filter(|&c| c != '#' && c != '*').collect();
@@ -677,7 +677,7 @@ pub(crate) fn handle_workspace_symbol(
 
     return Ok(Some(lsp_types::WorkspaceSymbolResponse::Nested(res)));
 
-    fn decide_search_scope_and_kind(
+    fn decide_search_kind_and_scope(
         params: &WorkspaceSymbolParams,
         config: &WorkspaceSymbolConfig,
     ) -> (bool, bool) {

From af10cb727fd55ce8638653f18d2edd4b8005add7 Mon Sep 17 00:00:00 2001
From: The rustc-josh-sync Cronjob Bot <github-actions@github.com>
Date: Mon, 11 Aug 2025 04:25:52 +0000
Subject: [PATCH 0059/1889] Prepare for merging from rust-lang/rust

This updates the rust-version file to 21a19c297d4f5a03501d92ca251bd7a17073c08a.
---
 src/tools/rust-analyzer/rust-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/rust-version b/src/tools/rust-analyzer/rust-version
index 2178caf63968a..02b217f7d80dc 100644
--- a/src/tools/rust-analyzer/rust-version
+++ b/src/tools/rust-analyzer/rust-version
@@ -1 +1 @@
-733dab558992d902d6d17576de1da768094e2cf3
+21a19c297d4f5a03501d92ca251bd7a17073c08a

From 7daaa4ee01f4c4d026293a6e3a90e4c8b4f5aa12 Mon Sep 17 00:00:00 2001
From: "Shoyu Vanilla (Flint)" <modulo641@gmail.com>
Date: Mon, 11 Aug 2025 18:18:55 +0900
Subject: [PATCH 0060/1889] hotfix: Update flycheck diagnostics generation

---
 src/tools/rust-analyzer/crates/rust-analyzer/src/diagnostics.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/diagnostics.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/diagnostics.rs
index cd7c632d105e0..2711bdba693bf 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/diagnostics.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/diagnostics.rs
@@ -134,6 +134,7 @@ impl DiagnosticCollection {
         if self.check[flycheck_id].generation > generation {
             return;
         }
+        self.check[flycheck_id].generation = generation;
         let diagnostics = self.check[flycheck_id]
             .per_package
             .entry(package_id.clone())

From 380d89d82f514d7e998f7b3b0e6bdb2065b711bc Mon Sep 17 00:00:00 2001
From: Shoyu Vanilla <modulo641@gmail.com>
Date: Mon, 11 Aug 2025 01:57:27 +0900
Subject: [PATCH 0061/1889] Make import sorting order follow 2024 edition style

---
 .../ide-assists/src/handlers/merge_imports.rs |   2 +-
 .../src/handlers/normalize_import.rs          |  22 +-
 .../ide-completion/src/tests/flyimport.rs     |   2 +-
 .../ide-db/src/imports/insert_use/tests.rs    |  26 +--
 .../ide-db/src/imports/merge_imports.rs       | 217 ++++++++++++++++--
 5 files changed, 219 insertions(+), 50 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/merge_imports.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/merge_imports.rs
index 6bf7f5849148f..9ba73d23dd243 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/merge_imports.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/merge_imports.rs
@@ -605,7 +605,7 @@ use foo::$0{
 ",
             r"
 use foo::{
-    bar::baz, FooBar
+    FooBar, bar::baz,
 };
 ",
         )
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/normalize_import.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/normalize_import.rs
index bba28b5fc8af5..36da1d1788247 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/normalize_import.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/normalize_import.rs
@@ -109,8 +109,8 @@ mod tests {
     #[test]
     fn test_order() {
         check_assist_variations!(
-            "foo::{*, Qux, bar::{Quux, Bar}, baz, FOO_BAZ, self, Baz}",
-            "foo::{self, bar::{Bar, Quux}, baz, Baz, Qux, FOO_BAZ, *}"
+            "foo::{*, Qux, bar::{Quux, Bar}, baz, FOO_BAZ, self, Baz, v10, v9, r#aaa}",
+            "foo::{self, Baz, FOO_BAZ, Qux, r#aaa, bar::{Bar, Quux}, baz, v9, v10, *}"
         );
     }
 
@@ -145,17 +145,17 @@ fn main() {
 
     #[test]
     fn test_redundant_braces() {
-        check_assist_variations!("foo::{bar::{baz, Qux}}", "foo::bar::{baz, Qux}");
+        check_assist_variations!("foo::{bar::{baz, Qux}}", "foo::bar::{Qux, baz}");
         check_assist_variations!("foo::{bar::{self}}", "foo::bar::{self}");
         check_assist_variations!("foo::{bar::{*}}", "foo::bar::*");
         check_assist_variations!("foo::{bar::{Qux as Quux}}", "foo::bar::Qux as Quux");
         check_assist_variations!(
             "foo::bar::{{FOO_BAZ, Qux, self}, {*, baz}}",
-            "foo::bar::{self, baz, Qux, FOO_BAZ, *}"
+            "foo::bar::{self, FOO_BAZ, Qux, baz, *}"
         );
         check_assist_variations!(
             "foo::bar::{{{FOO_BAZ}, {{Qux}, {self}}}, {{*}, {baz}}}",
-            "foo::bar::{self, baz, Qux, FOO_BAZ, *}"
+            "foo::bar::{self, FOO_BAZ, Qux, baz, *}"
         );
     }
 
@@ -163,11 +163,11 @@ fn main() {
     fn test_merge() {
         check_assist_variations!(
             "foo::{*, bar, {FOO_BAZ, qux}, bar::{*, baz}, {Quux}}",
-            "foo::{bar::{self, baz, *}, qux, Quux, FOO_BAZ, *}"
+            "foo::{FOO_BAZ, Quux, bar::{self, baz, *}, qux, *}"
         );
         check_assist_variations!(
             "foo::{*, bar, {FOO_BAZ, qux}, bar::{*, baz}, {Quux, bar::{baz::Foo}}}",
-            "foo::{bar::{self, baz::{self, Foo}, *}, qux, Quux, FOO_BAZ, *}"
+            "foo::{FOO_BAZ, Quux, bar::{self, baz::{self, Foo}, *}, qux, *}"
         );
     }
 
@@ -229,15 +229,15 @@ use {
         check_assist_not_applicable_variations!("foo::bar");
         check_assist_not_applicable_variations!("foo::bar::*");
         check_assist_not_applicable_variations!("foo::bar::Qux as Quux");
-        check_assist_not_applicable_variations!("foo::bar::{self, baz, Qux, FOO_BAZ, *}");
+        check_assist_not_applicable_variations!("foo::bar::{self, FOO_BAZ, Qux, baz, *}");
         check_assist_not_applicable_variations!(
-            "foo::{self, bar::{Bar, Quux}, baz, Baz, Qux, FOO_BAZ, *}"
+            "foo::{self, Baz, FOO_BAZ, Qux, bar::{Bar, Quux}, baz, *}"
         );
         check_assist_not_applicable_variations!(
-            "foo::{bar::{self, baz, *}, qux, Quux, FOO_BAZ, *}"
+            "foo::{FOO_BAZ, Quux, bar::{self, baz, *}, qux, *}"
         );
         check_assist_not_applicable_variations!(
-            "foo::{bar::{self, baz::{self, Foo}, *}, qux, Quux, FOO_BAZ, *}"
+            "foo::{bar::{self, FOO_BAZ, Quux, baz::{self, Foo}, *}, qux, *}"
         );
     }
 }
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/tests/flyimport.rs b/src/tools/rust-analyzer/crates/ide-completion/src/tests/flyimport.rs
index 27c91bc7c4558..04bed418eec79 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/tests/flyimport.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/tests/flyimport.rs
@@ -114,7 +114,7 @@ fn main() {
 }
 "#,
         r#"
-use dep::{some_module::{SecondStruct, ThirdStruct}, FirstStruct};
+use dep::{FirstStruct, some_module::{SecondStruct, ThirdStruct}};
 
 fn main() {
     ThirdStruct
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/imports/insert_use/tests.rs b/src/tools/rust-analyzer/crates/ide-db/src/imports/insert_use/tests.rs
index 4a00854f01a5f..3350e1c3d207f 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/imports/insert_use/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/imports/insert_use/tests.rs
@@ -782,18 +782,18 @@ fn merge_groups_long_last_list() {
 fn merge_groups_long_full_nested() {
     check_crate(
         "std::foo::bar::Baz",
-        r"use std::foo::bar::{Qux, quux::{Fez, Fizz}};",
-        r"use std::foo::bar::{quux::{Fez, Fizz}, Baz, Qux};",
+        r"use std::foo::bar::{quux::{Fez, Fizz}, Qux};",
+        r"use std::foo::bar::{Baz, Qux, quux::{Fez, Fizz}};",
     );
     check_crate(
         "std::foo::bar::r#Baz",
-        r"use std::foo::bar::{Qux, quux::{Fez, Fizz}};",
-        r"use std::foo::bar::{quux::{Fez, Fizz}, r#Baz, Qux};",
+        r"use std::foo::bar::{quux::{Fez, Fizz}, Qux};",
+        r"use std::foo::bar::{r#Baz, Qux, quux::{Fez, Fizz}};",
     );
     check_one(
         "std::foo::bar::Baz",
-        r"use {std::foo::bar::{Qux, quux::{Fez, Fizz}}};",
-        r"use {std::foo::bar::{quux::{Fez, Fizz}, Baz, Qux}};",
+        r"use {std::foo::bar::{quux::{Fez, Fizz}}, Qux};",
+        r"use {Qux, std::foo::bar::{Baz, quux::{Fez, Fizz}}};",
     );
 }
 
@@ -811,13 +811,13 @@ use std::foo::bar::{Qux, quux::{Fez, Fizz}};",
 fn merge_groups_full_nested_deep() {
     check_crate(
         "std::foo::bar::quux::Baz",
-        r"use std::foo::bar::{Qux, quux::{Fez, Fizz}};",
-        r"use std::foo::bar::{quux::{Baz, Fez, Fizz}, Qux};",
+        r"use std::foo::bar::{quux::{Fez, Fizz}, Qux};",
+        r"use std::foo::bar::{Qux, quux::{Baz, Fez, Fizz}};",
     );
     check_one(
         "std::foo::bar::quux::Baz",
-        r"use {std::foo::bar::{Qux, quux::{Fez, Fizz}}};",
-        r"use {std::foo::bar::{quux::{Baz, Fez, Fizz}, Qux}};",
+        r"use {std::foo::bar::{quux::{Fez, Fizz}}, Qux};",
+        r"use {Qux, std::foo::bar::quux::{Baz, Fez, Fizz}};",
     );
 }
 
@@ -988,8 +988,8 @@ use syntax::SyntaxKind::{self, *};",
 fn merge_glob_nested() {
     check_crate(
         "foo::bar::quux::Fez",
-        r"use foo::bar::{Baz, quux::*};",
-        r"use foo::bar::{quux::{Fez, *}, Baz};",
+        r"use foo::bar::{quux::*, Baz};",
+        r"use foo::bar::{Baz, quux::{Fez, *}};",
     )
 }
 
@@ -998,7 +998,7 @@ fn merge_nested_considers_first_segments() {
     check_crate(
         "hir_ty::display::write_bounds_like_dyn_trait",
         r"use hir_ty::{autoderef, display::{HirDisplayError, HirFormatter}, method_resolution};",
-        r"use hir_ty::{autoderef, display::{write_bounds_like_dyn_trait, HirDisplayError, HirFormatter}, method_resolution};",
+        r"use hir_ty::{autoderef, display::{HirDisplayError, HirFormatter, write_bounds_like_dyn_trait}, method_resolution};",
     );
 }
 
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/imports/merge_imports.rs b/src/tools/rust-analyzer/crates/ide-db/src/imports/merge_imports.rs
index 61962e593476c..4e779a7d858e5 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/imports/merge_imports.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/imports/merge_imports.rs
@@ -3,7 +3,6 @@ use std::cmp::Ordering;
 
 use itertools::{EitherOrBoth, Itertools};
 use parser::T;
-use stdx::is_upper_snake_case;
 use syntax::{
     Direction, SyntaxElement, algo,
     ast::{
@@ -543,12 +542,13 @@ fn use_tree_cmp_bin_search(lhs: &ast::UseTree, rhs: &ast::UseTree) -> Ordering {
     }
 }
 
-/// Orders use trees following `rustfmt`'s algorithm for ordering imports, which is `self`, `super`
-/// and `crate` first, then identifier imports with lowercase ones first and upper snake case
-/// (e.g. UPPER_SNAKE_CASE) ones last, then glob imports, and at last list imports.
+/// Orders use trees following `rustfmt`'s version sorting algorithm for ordering imports.
 ///
-/// Example: `foo::{self, baz, foo, Baz, Qux, FOO_BAZ, *, {Bar}}`
-/// Ref: <https://github.com/rust-lang/rustfmt/blob/6356fca675bd756d71f5c123cd053d17b16c573e/src/imports.rs#L83-L86>.
+/// Example: `foo::{self, Baz, FOO_BAZ, Qux, baz, foo, *, {Bar}}`
+///
+/// Ref:
+///   - <https://doc.rust-lang.org/style-guide/index.html#sorting>
+///   - <https://doc.rust-lang.org/edition-guide/rust-2024/rustfmt.html>
 pub(super) fn use_tree_cmp(a: &ast::UseTree, b: &ast::UseTree) -> Ordering {
     let a_is_simple_path = a.is_simple_path() && a.rename().is_none();
     let b_is_simple_path = b.is_simple_path() && b.rename().is_none();
@@ -613,26 +613,9 @@ fn path_segment_cmp(a: &ast::PathSegment, b: &ast::PathSegment) -> Ordering {
                 (Some(_), None) => Ordering::Greater,
                 (None, Some(_)) => Ordering::Less,
                 (Some(a_name), Some(b_name)) => {
-                    // snake_case < UpperCamelCase < UPPER_SNAKE_CASE
                     let a_text = a_name.as_str().trim_start_matches("r#");
                     let b_text = b_name.as_str().trim_start_matches("r#");
-                    if a_text.starts_with(char::is_lowercase)
-                        && b_text.starts_with(char::is_uppercase)
-                    {
-                        return Ordering::Less;
-                    }
-                    if a_text.starts_with(char::is_uppercase)
-                        && b_text.starts_with(char::is_lowercase)
-                    {
-                        return Ordering::Greater;
-                    }
-                    if !is_upper_snake_case(a_text) && is_upper_snake_case(b_text) {
-                        return Ordering::Less;
-                    }
-                    if is_upper_snake_case(a_text) && !is_upper_snake_case(b_text) {
-                        return Ordering::Greater;
-                    }
-                    a_text.cmp(b_text)
+                    version_sort::version_sort(a_text, b_text)
                 }
             }
         }
@@ -740,3 +723,189 @@ fn remove_subtree_if_only_self(use_tree: &ast::UseTree) {
         _ => (),
     }
 }
+
+// Taken from rustfmt
+// https://github.com/rust-lang/rustfmt/blob/0332da01486508710f2a542111e40513bfb215aa/src/sort.rs
+mod version_sort {
+    // Original rustfmt code contains some clippy lints.
+    // Suppress them to minimize changes from upstream.
+    #![allow(clippy::all)]
+
+    use std::cmp::Ordering;
+
+    use itertools::{EitherOrBoth, Itertools};
+
+    struct VersionChunkIter<'a> {
+        ident: &'a str,
+        start: usize,
+    }
+
+    impl<'a> VersionChunkIter<'a> {
+        pub(crate) fn new(ident: &'a str) -> Self {
+            Self { ident, start: 0 }
+        }
+
+        fn parse_numeric_chunk(
+            &mut self,
+            mut chars: std::str::CharIndices<'a>,
+        ) -> Option<VersionChunk<'a>> {
+            let mut end = self.start;
+            let mut is_end_of_chunk = false;
+
+            while let Some((idx, c)) = chars.next() {
+                end = self.start + idx;
+
+                if c.is_ascii_digit() {
+                    continue;
+                }
+
+                is_end_of_chunk = true;
+                break;
+            }
+
+            let source = if is_end_of_chunk {
+                let value = &self.ident[self.start..end];
+                self.start = end;
+                value
+            } else {
+                let value = &self.ident[self.start..];
+                self.start = self.ident.len();
+                value
+            };
+
+            let zeros = source.chars().take_while(|c| *c == '0').count();
+            let value = source.parse::<usize>().ok()?;
+
+            Some(VersionChunk::Number { value, zeros, source })
+        }
+
+        fn parse_str_chunk(
+            &mut self,
+            mut chars: std::str::CharIndices<'a>,
+        ) -> Option<VersionChunk<'a>> {
+            let mut end = self.start;
+            let mut is_end_of_chunk = false;
+
+            while let Some((idx, c)) = chars.next() {
+                end = self.start + idx;
+
+                if c == '_' {
+                    is_end_of_chunk = true;
+                    break;
+                }
+
+                if !c.is_ascii_digit() {
+                    continue;
+                }
+
+                is_end_of_chunk = true;
+                break;
+            }
+
+            let source = if is_end_of_chunk {
+                let value = &self.ident[self.start..end];
+                self.start = end;
+                value
+            } else {
+                let value = &self.ident[self.start..];
+                self.start = self.ident.len();
+                value
+            };
+
+            Some(VersionChunk::Str(source))
+        }
+    }
+
+    impl<'a> Iterator for VersionChunkIter<'a> {
+        type Item = VersionChunk<'a>;
+
+        fn next(&mut self) -> Option<Self::Item> {
+            let mut chars = self.ident[self.start..].char_indices();
+            let (_, next) = chars.next()?;
+
+            if next == '_' {
+                self.start = self.start + next.len_utf8();
+                return Some(VersionChunk::Underscore);
+            }
+
+            if next.is_ascii_digit() {
+                return self.parse_numeric_chunk(chars);
+            }
+
+            self.parse_str_chunk(chars)
+        }
+    }
+
+    /// Represents a chunk in the version-sort algorithm
+    #[derive(Debug, PartialEq, Eq)]
+    enum VersionChunk<'a> {
+        /// A single `_` in an identifier. Underscores are sorted before all other characters.
+        Underscore,
+        /// A &str chunk in the version sort.
+        Str(&'a str),
+        /// A numeric chunk in the version sort. Keeps track of the numeric value and leading zeros.
+        Number { value: usize, zeros: usize, source: &'a str },
+    }
+
+    /// Determine which side of the version-sort comparison had more leading zeros.
+    #[derive(Debug, PartialEq, Eq)]
+    enum MoreLeadingZeros {
+        Left,
+        Right,
+        Equal,
+    }
+
+    pub(super) fn version_sort(a: &str, b: &str) -> Ordering {
+        let iter_a = VersionChunkIter::new(a);
+        let iter_b = VersionChunkIter::new(b);
+        let mut more_leading_zeros = MoreLeadingZeros::Equal;
+
+        for either_or_both in iter_a.zip_longest(iter_b) {
+            match either_or_both {
+                EitherOrBoth::Left(_) => return std::cmp::Ordering::Greater,
+                EitherOrBoth::Right(_) => return std::cmp::Ordering::Less,
+                EitherOrBoth::Both(a, b) => match (a, b) {
+                    (VersionChunk::Underscore, VersionChunk::Underscore) => {
+                        continue;
+                    }
+                    (VersionChunk::Underscore, _) => return std::cmp::Ordering::Less,
+                    (_, VersionChunk::Underscore) => return std::cmp::Ordering::Greater,
+                    (VersionChunk::Str(ca), VersionChunk::Str(cb))
+                    | (VersionChunk::Str(ca), VersionChunk::Number { source: cb, .. })
+                    | (VersionChunk::Number { source: ca, .. }, VersionChunk::Str(cb)) => {
+                        match ca.cmp(&cb) {
+                            std::cmp::Ordering::Equal => {
+                                continue;
+                            }
+                            order @ _ => return order,
+                        }
+                    }
+                    (
+                        VersionChunk::Number { value: va, zeros: lza, .. },
+                        VersionChunk::Number { value: vb, zeros: lzb, .. },
+                    ) => match va.cmp(&vb) {
+                        std::cmp::Ordering::Equal => {
+                            if lza == lzb {
+                                continue;
+                            }
+
+                            if more_leading_zeros == MoreLeadingZeros::Equal && lza > lzb {
+                                more_leading_zeros = MoreLeadingZeros::Left;
+                            } else if more_leading_zeros == MoreLeadingZeros::Equal && lza < lzb {
+                                more_leading_zeros = MoreLeadingZeros::Right;
+                            }
+                            continue;
+                        }
+                        order @ _ => return order,
+                    },
+                },
+            }
+        }
+
+        match more_leading_zeros {
+            MoreLeadingZeros::Equal => std::cmp::Ordering::Equal,
+            MoreLeadingZeros::Left => std::cmp::Ordering::Less,
+            MoreLeadingZeros::Right => std::cmp::Ordering::Greater,
+        }
+    }
+}

From 6c3c620e6b65a130a6996cca14cb9e19cc8ea65c Mon Sep 17 00:00:00 2001
From: Shoyu Vanilla <modulo641@gmail.com>
Date: Tue, 12 Aug 2025 00:24:44 +0900
Subject: [PATCH 0062/1889] fix: Panic while trying to clear old diagnostics
 while there's nothing

---
 src/tools/rust-analyzer/crates/rust-analyzer/src/diagnostics.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/diagnostics.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/diagnostics.rs
index 2711bdba693bf..30f530100f9df 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/diagnostics.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/diagnostics.rs
@@ -105,7 +105,7 @@ impl DiagnosticCollection {
         flycheck_id: usize,
         generation: DiagnosticsGeneration,
     ) {
-        if self.check[flycheck_id].generation < generation {
+        if self.check.get(flycheck_id).is_some_and(|it| it.generation < generation) {
             self.clear_check(flycheck_id);
         }
     }

From 875c158686fc47e083c83d1ccee4359ba4cc64f9 Mon Sep 17 00:00:00 2001
From: sgasho <SuganoShota1999@gmail.com>
Date: Mon, 11 Aug 2025 22:19:50 +0900
Subject: [PATCH 0063/1889] fix: Implement default member to resolve IdentPat

---
 .../src/handlers/add_missing_impl_members.rs  | 49 +++++++++++++++
 .../crates/ide-db/src/path_transform.rs       | 61 ++++++++++++++++---
 2 files changed, 102 insertions(+), 8 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_impl_members.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_impl_members.rs
index 11201afb8a7f2..7e03eb30304bf 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_impl_members.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_impl_members.rs
@@ -2418,6 +2418,55 @@ pub struct MyStruct;
 
 impl other_file_2::Trait for MyStruct {
     $0type Iter;
+}"#,
+        );
+    }
+
+    #[test]
+    fn test_qualify_ident_pat_in_default_members() {
+        check_assist(
+            add_missing_default_members,
+            r#"
+//- /lib.rs crate:b new_source_root:library
+pub enum State {
+    Active,
+    Inactive,
+}
+
+use State::*;
+
+pub trait Checker {
+    fn check(&self) -> State;
+
+    fn is_active(&self) -> bool {
+        match self.check() {
+            Active => true,
+            Inactive => false,
+        }
+    }
+}
+//- /main.rs crate:a deps:b
+struct MyChecker;
+
+impl b::Checker for MyChecker {
+    fn check(&self) -> b::State {
+        todo!();
+    }$0
+}"#,
+            r#"
+struct MyChecker;
+
+impl b::Checker for MyChecker {
+    fn check(&self) -> b::State {
+        todo!();
+    }
+
+    $0fn is_active(&self) -> bool {
+        match self.check() {
+            b::State::Active => true,
+            b::State::Inactive => false,
+        }
+    }
 }"#,
         );
     }
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/path_transform.rs b/src/tools/rust-analyzer/crates/ide-db/src/path_transform.rs
index 5d88afec50951..a76a0551dd8db 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/path_transform.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/path_transform.rs
@@ -11,7 +11,7 @@ use rustc_hash::FxHashMap;
 use span::Edition;
 use syntax::{
     NodeOrToken, SyntaxNode,
-    ast::{self, AstNode, HasGenericArgs, make},
+    ast::{self, AstNode, HasGenericArgs, HasName, make},
     syntax_editor::{self, SyntaxEditor},
 };
 
@@ -315,32 +315,49 @@ impl Ctx<'_> {
     }
 
     fn transform_path(&self, path: &SyntaxNode) -> SyntaxNode {
-        fn find_child_paths(root_path: &SyntaxNode) -> Vec<ast::Path> {
-            let mut result = Vec::new();
+        fn find_child_paths_and_ident_pats(
+            root_path: &SyntaxNode,
+        ) -> Vec<Either<ast::Path, ast::IdentPat>> {
+            let mut result: Vec<Either<ast::Path, ast::IdentPat>> = Vec::new();
             for child in root_path.children() {
                 if let Some(child_path) = ast::Path::cast(child.clone()) {
-                    result.push(child_path);
+                    result.push(either::Left(child_path));
+                } else if let Some(child_ident_pat) = ast::IdentPat::cast(child.clone()) {
+                    result.push(either::Right(child_ident_pat));
                 } else {
-                    result.extend(find_child_paths(&child));
+                    result.extend(find_child_paths_and_ident_pats(&child));
                 }
             }
             result
         }
+
         let root_path = path.clone_subtree();
-        let result = find_child_paths(&root_path);
+
+        let result = find_child_paths_and_ident_pats(&root_path);
         let mut editor = SyntaxEditor::new(root_path.clone());
         for sub_path in result {
             let new = self.transform_path(sub_path.syntax());
             editor.replace(sub_path.syntax(), new);
         }
+
         let update_sub_item = editor.finish().new_root().clone().clone_subtree();
-        let item = find_child_paths(&update_sub_item);
+        let item = find_child_paths_and_ident_pats(&update_sub_item);
         let mut editor = SyntaxEditor::new(update_sub_item);
         for sub_path in item {
-            self.transform_path_(&mut editor, &sub_path);
+            self.transform_path_or_ident_pat(&mut editor, &sub_path);
         }
         editor.finish().new_root().clone()
     }
+    fn transform_path_or_ident_pat(
+        &self,
+        editor: &mut SyntaxEditor,
+        item: &Either<ast::Path, ast::IdentPat>,
+    ) -> Option<()> {
+        match item {
+            Either::Left(path) => self.transform_path_(editor, path),
+            Either::Right(ident_pat) => self.transform_ident_pat(editor, ident_pat),
+        }
+    }
 
     fn transform_path_(&self, editor: &mut SyntaxEditor, path: &ast::Path) -> Option<()> {
         if path.qualifier().is_some() {
@@ -515,6 +532,34 @@ impl Ctx<'_> {
         }
         Some(())
     }
+
+    fn transform_ident_pat(
+        &self,
+        editor: &mut SyntaxEditor,
+        ident_pat: &ast::IdentPat,
+    ) -> Option<()> {
+        let name = ident_pat.name()?;
+
+        let temp_path = make::path_from_text(&name.text());
+
+        let resolution = self.source_scope.speculative_resolve(&temp_path)?;
+
+        match resolution {
+            hir::PathResolution::Def(def) if def.as_assoc_item(self.source_scope.db).is_none() => {
+                let cfg = ImportPathConfig {
+                    prefer_no_std: false,
+                    prefer_prelude: true,
+                    prefer_absolute: false,
+                    allow_unstable: true,
+                };
+                let found_path = self.target_module.find_path(self.source_scope.db, def, cfg)?;
+                let res = mod_path_to_ast(&found_path, self.target_edition).clone_for_update();
+                editor.replace(ident_pat.syntax(), res.syntax());
+                Some(())
+            }
+            _ => None,
+        }
+    }
 }
 
 // FIXME: It would probably be nicer if we could get this via HIR (i.e. get the

From 49ebe9f849202561ac02ece6e8683a6602bf1f38 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Wed, 13 Aug 2025 05:23:58 +0300
Subject: [PATCH 0064/1889] Only import the item in "Unqualify method call" if
 needed

---
 .../rust-analyzer/crates/hir/src/semantics.rs |   5 +
 .../src/handlers/unqualify_method_call.rs     | 118 +++++++++++++++++-
 2 files changed, 122 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/hir/src/semantics.rs b/src/tools/rust-analyzer/crates/hir/src/semantics.rs
index 05f06f97fdc26..6be44532d033f 100644
--- a/src/tools/rust-analyzer/crates/hir/src/semantics.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/semantics.rs
@@ -2247,6 +2247,11 @@ impl<'db> SemanticsScope<'db> {
         }
     }
 
+    /// Checks if a trait is in scope, either because of an import or because we're in an impl of it.
+    pub fn can_use_trait_methods(&self, t: Trait) -> bool {
+        self.resolver.traits_in_scope(self.db).contains(&t.id)
+    }
+
     /// Resolve a path as-if it was written at the given scope. This is
     /// necessary a heuristic, as it doesn't take hygiene into account.
     pub fn speculative_resolve(&self, ast_path: &ast::Path) -> Option<PathResolution> {
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unqualify_method_call.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unqualify_method_call.rs
index 1f89a3d5f17c9..a58b1da621c7c 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unqualify_method_call.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unqualify_method_call.rs
@@ -1,3 +1,4 @@
+use hir::AsAssocItem;
 use syntax::{
     TextRange,
     ast::{self, AstNode, HasArgList, prec::ExprPrecedence},
@@ -43,6 +44,7 @@ pub(crate) fn unqualify_method_call(acc: &mut Assists, ctx: &AssistContext<'_>)
     let qualifier = path.qualifier()?;
     let method_name = path.segment()?.name_ref()?;
 
+    let scope = ctx.sema.scope(path.syntax())?;
     let res = ctx.sema.resolve_path(&path)?;
     let hir::PathResolution::Def(hir::ModuleDef::Function(fun)) = res else { return None };
     if !fun.has_self_param(ctx.sema.db) {
@@ -78,7 +80,14 @@ pub(crate) fn unqualify_method_call(acc: &mut Assists, ctx: &AssistContext<'_>)
                 edit.insert(close, ")");
             }
             edit.replace(replace_comma, format!(".{method_name}("));
-            add_import(qualifier, ctx, edit);
+
+            if let Some(fun) = fun.as_assoc_item(ctx.db())
+                && let Some(trait_) = fun.container_or_implemented_trait(ctx.db())
+                && !scope.can_use_trait_methods(trait_)
+            {
+                // Only add an import for trait methods that are not already imported.
+                add_import(qualifier, ctx, edit);
+            }
         },
     )
 }
@@ -235,4 +244,111 @@ impl S { fn assoc(S: S, S: S) {} }
 fn f() { S::assoc$0(S, S); }"#,
         );
     }
+
+    #[test]
+    fn inherent_method() {
+        check_assist(
+            unqualify_method_call,
+            r#"
+mod foo {
+    pub struct Bar;
+    impl Bar {
+        pub fn bar(self) {}
+    }
+}
+
+fn baz() {
+    foo::Bar::b$0ar(foo::Bar);
+}
+        "#,
+            r#"
+mod foo {
+    pub struct Bar;
+    impl Bar {
+        pub fn bar(self) {}
+    }
+}
+
+fn baz() {
+    foo::Bar.bar();
+}
+        "#,
+        );
+    }
+
+    #[test]
+    fn trait_method_in_impl() {
+        check_assist(
+            unqualify_method_call,
+            r#"
+mod foo {
+    pub trait Bar {
+        pub fn bar(self) {}
+    }
+}
+
+struct Baz;
+impl foo::Bar for Baz {
+    fn bar(self) {
+        foo::Bar::b$0ar(Baz);
+    }
+}
+        "#,
+            r#"
+mod foo {
+    pub trait Bar {
+        pub fn bar(self) {}
+    }
+}
+
+struct Baz;
+impl foo::Bar for Baz {
+    fn bar(self) {
+        Baz.bar();
+    }
+}
+        "#,
+        );
+    }
+
+    #[test]
+    fn trait_method_already_imported() {
+        check_assist(
+            unqualify_method_call,
+            r#"
+mod foo {
+    pub struct Foo;
+    pub trait Bar {
+        pub fn bar(self) {}
+    }
+    impl Bar for Foo {
+        pub fn bar(self) {}
+    }
+}
+
+use foo::Bar;
+
+fn baz() {
+    foo::Bar::b$0ar(foo::Foo);
+}
+        "#,
+            r#"
+mod foo {
+    pub struct Foo;
+    pub trait Bar {
+        pub fn bar(self) {}
+    }
+    impl Bar for Foo {
+        pub fn bar(self) {}
+    }
+}
+
+use foo::Bar;
+
+fn baz() {
+    foo::Foo.bar();
+}
+        "#,
+        );
+    }
 }

From 8d247472e5f9612b4bf9668de937ad9c373b891c Mon Sep 17 00:00:00 2001
From: Deadbeef <ent3rm4n@gmail.com>
Date: Mon, 4 Aug 2025 16:11:51 +0800
Subject: [PATCH 0065/1889] Merge Trait and TraitAlias handling

---
 .../rust-analyzer/crates/hir-def/src/attr.rs  |  2 -
 .../rust-analyzer/crates/hir-def/src/db.rs    | 20 +---
 .../crates/hir-def/src/dyn_map.rs             |  5 +-
 .../crates/hir-def/src/expr_store/lower.rs    | 24 +----
 .../crates/hir-def/src/expr_store/pretty.rs   |  1 -
 .../src/expr_store/tests/signatures.rs        |  2 -
 .../crates/hir-def/src/hir/generics.rs        | 11 ---
 .../crates/hir-def/src/item_scope.rs          |  1 -
 .../crates/hir-def/src/item_tree.rs           |  8 --
 .../crates/hir-def/src/item_tree/lower.rs     | 16 +--
 .../crates/hir-def/src/item_tree/pretty.rs    |  8 +-
 .../rust-analyzer/crates/hir-def/src/lib.rs   | 14 ---
 .../crates/hir-def/src/nameres/assoc.rs       | 10 +-
 .../crates/hir-def/src/nameres/collector.rs   | 16 +--
 .../crates/hir-def/src/resolver.rs            | 13 +--
 .../crates/hir-def/src/signatures.rs          | 31 +-----
 .../rust-analyzer/crates/hir-def/src/src.rs   |  9 +-
 .../crates/hir-ty/src/generics.rs             |  5 +-
 .../rust-analyzer/crates/hir-ty/src/infer.rs  |  1 -
 .../crates/hir-ty/src/lower/path.rs           |  7 +-
 .../rust-analyzer/crates/hir-ty/src/tests.rs  |  1 +
 .../crates/hir-ty/src/variance.rs             |  5 -
 .../rust-analyzer/crates/hir/src/attrs.rs     |  8 +-
 .../rust-analyzer/crates/hir/src/display.rs   | 21 +---
 .../rust-analyzer/crates/hir/src/from_id.rs   |  5 -
 .../crates/hir/src/has_source.rs              | 11 +--
 src/tools/rust-analyzer/crates/hir/src/lib.rs | 51 +---------
 .../rust-analyzer/crates/hir/src/semantics.rs | 12 +--
 .../hir/src/semantics/child_by_source.rs      |  3 -
 .../crates/hir/src/semantics/source_to_def.rs | 16 +--
 .../crates/hir/src/source_analyzer.rs         |  4 +-
 .../rust-analyzer/crates/hir/src/symbols.rs   |  3 -
 .../src/handlers/extract_module.rs            |  1 -
 .../src/handlers/fix_visibility.rs            |  4 -
 .../ide-assists/src/handlers/move_bounds.rs   |  1 -
 .../ide-completion/src/completions/type.rs    |  4 +-
 .../crates/ide-completion/src/context.rs      |  1 -
 .../ide-completion/src/context/analysis.rs    |  3 -
 .../crates/ide-completion/src/item.rs         |  1 -
 .../crates/ide-completion/src/render.rs       |  8 +-
 .../crates/ide-db/src/active_parameter.rs     |  1 -
 .../rust-analyzer/crates/ide-db/src/defs.rs   | 15 +--
 .../crates/ide-db/src/documentation.rs        |  3 +-
 .../ide-db/src/imports/import_assets.rs       |  2 -
 .../rust-analyzer/crates/ide-db/src/lib.rs    |  2 -
 .../rust-analyzer/crates/ide-db/src/rename.rs |  1 -
 .../rust-analyzer/crates/ide-db/src/search.rs |  1 -
 .../crates/ide-db/src/symbol_index.rs         |  1 -
 .../rust-analyzer/crates/ide/src/doc_links.rs |  5 +-
 .../crates/ide/src/file_structure.rs          |  3 +-
 .../crates/ide/src/folding_ranges.rs          |  7 --
 .../crates/ide/src/hover/render.rs            |  1 -
 .../rust-analyzer/crates/ide/src/moniker.rs   |  1 -
 .../rust-analyzer/crates/ide/src/move_item.rs |  1 -
 .../crates/ide/src/navigation_target.rs       | 11 ---
 .../crates/ide/src/references.rs              |  2 +-
 .../rust-analyzer/crates/ide/src/runnables.rs |  1 -
 .../crates/ide/src/signature_help.rs          |  4 -
 .../ide/src/syntax_highlighting/highlight.rs  |  2 -
 .../ide/src/syntax_highlighting/inject.rs     |  1 -
 .../ide/src/syntax_highlighting/tags.rs       |  1 -
 .../test_data/highlight_strings.html          |  4 +-
 .../crates/parser/src/grammar/items/traits.rs |  2 +-
 .../parser/src/syntax_kind/generated.rs       |  2 -
 .../parser/inline/ok/trait_alias.rast         |  2 +-
 .../inline/ok/trait_alias_where_clause.rast   |  4 +-
 .../crates/rust-analyzer/src/lsp/to_proto.rs  |  5 +-
 .../rust-analyzer/crates/span/src/ast_id.rs   |  3 +-
 .../rust-analyzer/crates/syntax/rust.ungram   |  8 +-
 .../rust-analyzer/crates/syntax/src/ast.rs    |  3 +-
 .../crates/syntax/src/ast/edit_in_place.rs    | 36 +------
 .../crates/syntax/src/ast/generated/nodes.rs  | 97 +------------------
 .../crates/syntax/src/ast/node_ext.rs         | 45 ---------
 .../xtask/src/codegen/grammar.rs              |  1 -
 74 files changed, 68 insertions(+), 577 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-def/src/attr.rs b/src/tools/rust-analyzer/crates/hir-def/src/attr.rs
index 53250510f875c..b4fcfa11aea74 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/attr.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/attr.rs
@@ -554,7 +554,6 @@ impl AttrsWithOwner {
                 AdtId::UnionId(it) => attrs_from_ast_id_loc(db, it),
             },
             AttrDefId::TraitId(it) => attrs_from_ast_id_loc(db, it),
-            AttrDefId::TraitAliasId(it) => attrs_from_ast_id_loc(db, it),
             AttrDefId::MacroId(it) => match it {
                 MacroId::Macro2Id(it) => attrs_from_ast_id_loc(db, it),
                 MacroId::MacroRulesId(it) => attrs_from_ast_id_loc(db, it),
@@ -659,7 +658,6 @@ impl AttrsWithOwner {
             AttrDefId::StaticId(id) => any_has_attrs(db, id),
             AttrDefId::ConstId(id) => any_has_attrs(db, id),
             AttrDefId::TraitId(id) => any_has_attrs(db, id),
-            AttrDefId::TraitAliasId(id) => any_has_attrs(db, id),
             AttrDefId::TypeAliasId(id) => any_has_attrs(db, id),
             AttrDefId::MacroId(id) => match id {
                 MacroId::Macro2Id(id) => any_has_attrs(db, id),
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/db.rs b/src/tools/rust-analyzer/crates/hir-def/src/db.rs
index c67bb2422ac65..4e1d598623abe 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/db.rs
@@ -15,8 +15,8 @@ use crate::{
     EnumVariantId, EnumVariantLoc, ExternBlockId, ExternBlockLoc, ExternCrateId, ExternCrateLoc,
     FunctionId, FunctionLoc, GenericDefId, ImplId, ImplLoc, LocalFieldId, Macro2Id, Macro2Loc,
     MacroExpander, MacroId, MacroRulesId, MacroRulesLoc, MacroRulesLocFlags, ProcMacroId,
-    ProcMacroLoc, StaticId, StaticLoc, StructId, StructLoc, TraitAliasId, TraitAliasLoc, TraitId,
-    TraitLoc, TypeAliasId, TypeAliasLoc, UnionId, UnionLoc, UseId, UseLoc, VariantId,
+    ProcMacroLoc, StaticId, StaticLoc, StructId, StructLoc, TraitId, TraitLoc, TypeAliasId,
+    TypeAliasLoc, UnionId, UnionLoc, UseId, UseLoc, VariantId,
     attr::{Attrs, AttrsWithOwner},
     expr_store::{
         Body, BodySourceMap, ExpressionStore, ExpressionStoreSourceMap, scope::ExprScopes,
@@ -28,7 +28,7 @@ use crate::{
     nameres::crate_def_map,
     signatures::{
         ConstSignature, EnumSignature, FunctionSignature, ImplSignature, StaticSignature,
-        StructSignature, TraitAliasSignature, TraitSignature, TypeAliasSignature, UnionSignature,
+        StructSignature, TraitSignature, TypeAliasSignature, UnionSignature,
     },
     tt,
     visibility::{self, Visibility},
@@ -69,9 +69,6 @@ pub trait InternDatabase: RootQueryDb {
     #[salsa::interned]
     fn intern_trait(&self, loc: TraitLoc) -> TraitId;
 
-    #[salsa::interned]
-    fn intern_trait_alias(&self, loc: TraitAliasLoc) -> TraitAliasId;
-
     #[salsa::interned]
     fn intern_type_alias(&self, loc: TypeAliasLoc) -> TypeAliasId;
 
@@ -152,11 +149,6 @@ pub trait DefDatabase: InternDatabase + ExpandDatabase + SourceDatabase {
         self.function_signature_with_source_map(e).0
     }
 
-    #[salsa::tracked]
-    fn trait_alias_signature(&self, e: TraitAliasId) -> Arc<TraitAliasSignature> {
-        self.trait_alias_signature_with_source_map(e).0
-    }
-
     #[salsa::tracked]
     fn type_alias_signature(&self, e: TypeAliasId) -> Arc<TypeAliasSignature> {
         self.type_alias_signature_with_source_map(e).0
@@ -210,12 +202,6 @@ pub trait DefDatabase: InternDatabase + ExpandDatabase + SourceDatabase {
         e: FunctionId,
     ) -> (Arc<FunctionSignature>, Arc<ExpressionStoreSourceMap>);
 
-    #[salsa::invoke(TraitAliasSignature::query)]
-    fn trait_alias_signature_with_source_map(
-        &self,
-        e: TraitAliasId,
-    ) -> (Arc<TraitAliasSignature>, Arc<ExpressionStoreSourceMap>);
-
     #[salsa::invoke(TypeAliasSignature::query)]
     fn type_alias_signature_with_source_map(
         &self,
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/dyn_map.rs b/src/tools/rust-analyzer/crates/hir-def/src/dyn_map.rs
index 20018b61e5cc0..7d3a94b038330 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/dyn_map.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/dyn_map.rs
@@ -33,8 +33,8 @@ pub mod keys {
 
     use crate::{
         BlockId, ConstId, EnumId, EnumVariantId, ExternBlockId, ExternCrateId, FieldId, FunctionId,
-        ImplId, LifetimeParamId, Macro2Id, MacroRulesId, ProcMacroId, StaticId, StructId,
-        TraitAliasId, TraitId, TypeAliasId, TypeOrConstParamId, UnionId, UseId,
+        ImplId, LifetimeParamId, Macro2Id, MacroRulesId, ProcMacroId, StaticId, StructId, TraitId,
+        TypeAliasId, TypeOrConstParamId, UnionId, UseId,
         dyn_map::{DynMap, Policy},
     };
 
@@ -48,7 +48,6 @@ pub mod keys {
     pub const IMPL: Key<ast::Impl, ImplId> = Key::new();
     pub const EXTERN_BLOCK: Key<ast::ExternBlock, ExternBlockId> = Key::new();
     pub const TRAIT: Key<ast::Trait, TraitId> = Key::new();
-    pub const TRAIT_ALIAS: Key<ast::TraitAlias, TraitAliasId> = Key::new();
     pub const STRUCT: Key<ast::Struct, StructId> = Key::new();
     pub const UNION: Key<ast::Union, UnionId> = Key::new();
     pub const ENUM: Key<ast::Enum, EnumId> = Key::new();
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs
index 3b9281ffb9c12..3794cb18e9360 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs
@@ -33,7 +33,7 @@ use tt::TextRange;
 
 use crate::{
     AdtId, BlockId, BlockLoc, DefWithBodyId, FunctionId, GenericDefId, ImplId, MacroId,
-    ModuleDefId, ModuleId, TraitAliasId, TraitId, TypeAliasId, UnresolvedMacro,
+    ModuleDefId, ModuleId, TraitId, TypeAliasId, UnresolvedMacro,
     builtin_type::BuiltinUint,
     db::DefDatabase,
     expr_store::{
@@ -252,28 +252,6 @@ pub(crate) fn lower_trait(
     (store, source_map, params)
 }
 
-pub(crate) fn lower_trait_alias(
-    db: &dyn DefDatabase,
-    module: ModuleId,
-    trait_syntax: InFile<ast::TraitAlias>,
-    trait_id: TraitAliasId,
-) -> (ExpressionStore, ExpressionStoreSourceMap, Arc<GenericParams>) {
-    let mut expr_collector = ExprCollector::new(db, module, trait_syntax.file_id);
-    let mut collector = generics::GenericParamsCollector::with_self_param(
-        &mut expr_collector,
-        trait_id.into(),
-        trait_syntax.value.type_bound_list(),
-    );
-    collector.lower(
-        &mut expr_collector,
-        trait_syntax.value.generic_param_list(),
-        trait_syntax.value.where_clause(),
-    );
-    let params = collector.finish();
-    let (store, source_map) = expr_collector.store.finish();
-    (store, source_map, params)
-}
-
 pub(crate) fn lower_type_alias(
     db: &dyn DefDatabase,
     module: ModuleId,
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/pretty.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/pretty.rs
index b81dcc1fe96df..5b9da3c5e6680 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/pretty.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/pretty.rs
@@ -183,7 +183,6 @@ pub fn print_signature(db: &dyn DefDatabase, owner: GenericDefId, edition: Editi
         }
         GenericDefId::ImplId(id) => format!("unimplemented {id:?}"),
         GenericDefId::StaticId(id) => format!("unimplemented {id:?}"),
-        GenericDefId::TraitAliasId(id) => format!("unimplemented {id:?}"),
         GenericDefId::TraitId(id) => format!("unimplemented {id:?}"),
         GenericDefId::TypeAliasId(id) => format!("unimplemented {id:?}"),
     }
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/tests/signatures.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/tests/signatures.rs
index efb558a775816..b68674c7a74f4 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/tests/signatures.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/tests/signatures.rs
@@ -24,7 +24,6 @@ fn lower_and_print(#[rust_analyzer::rust_fixture] ra_fixture: &str, expect: Expe
                 ModuleDefId::ConstId(id) => id.into(),
                 ModuleDefId::StaticId(id) => id.into(),
                 ModuleDefId::TraitId(id) => id.into(),
-                ModuleDefId::TraitAliasId(id) => id.into(),
                 ModuleDefId::TypeAliasId(id) => id.into(),
                 ModuleDefId::EnumVariantId(_) => continue,
                 ModuleDefId::BuiltinType(_) => continue,
@@ -51,7 +50,6 @@ fn lower_and_print(#[rust_analyzer::rust_fixture] ra_fixture: &str, expect: Expe
 
             GenericDefId::ImplId(_id) => (),
             GenericDefId::StaticId(_id) => (),
-            GenericDefId::TraitAliasId(_id) => (),
             GenericDefId::TraitId(_id) => (),
             GenericDefId::TypeAliasId(_id) => (),
         }
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/hir/generics.rs b/src/tools/rust-analyzer/crates/hir-def/src/hir/generics.rs
index 94e683cb0f8fa..60cd66bf6b082 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/hir/generics.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/hir/generics.rs
@@ -203,9 +203,6 @@ impl GenericParams {
             }
             GenericDefId::ImplId(impl_id) => db.impl_signature(impl_id).generic_params.clone(),
             GenericDefId::StaticId(_) => EMPTY.clone(),
-            GenericDefId::TraitAliasId(trait_alias_id) => {
-                db.trait_alias_signature(trait_alias_id).generic_params.clone()
-            }
             GenericDefId::TraitId(trait_id) => db.trait_signature(trait_id).generic_params.clone(),
             GenericDefId::TypeAliasId(type_alias_id) => {
                 db.type_alias_signature(type_alias_id).generic_params.clone()
@@ -246,10 +243,6 @@ impl GenericParams {
                 let sig = db.static_signature(id);
                 (EMPTY.clone(), sig.store.clone())
             }
-            GenericDefId::TraitAliasId(id) => {
-                let sig = db.trait_alias_signature(id);
-                (sig.generic_params.clone(), sig.store.clone())
-            }
             GenericDefId::TraitId(id) => {
                 let sig = db.trait_signature(id);
                 (sig.generic_params.clone(), sig.store.clone())
@@ -294,10 +287,6 @@ impl GenericParams {
                 let (sig, sm) = db.static_signature_with_source_map(id);
                 (EMPTY.clone(), sig.store.clone(), sm)
             }
-            GenericDefId::TraitAliasId(id) => {
-                let (sig, sm) = db.trait_alias_signature_with_source_map(id);
-                (sig.generic_params.clone(), sig.store.clone(), sm)
-            }
             GenericDefId::TraitId(id) => {
                 let (sig, sm) = db.trait_signature_with_source_map(id);
                 (sig.generic_params.clone(), sig.store.clone(), sm)
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs b/src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs
index 8f526d1a2369a..77ed664f4443d 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs
@@ -872,7 +872,6 @@ impl PerNs {
                 PerNs::values(def, v, import.and_then(ImportOrExternCrate::import_or_glob))
             }
             ModuleDefId::TraitId(_) => PerNs::types(def, v, import),
-            ModuleDefId::TraitAliasId(_) => PerNs::types(def, v, import),
             ModuleDefId::TypeAliasId(_) => PerNs::types(def, v, import),
             ModuleDefId::BuiltinType(_) => PerNs::types(def, v, import),
             ModuleDefId::MacroId(mac) => PerNs::macros(mac, v, import),
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/item_tree.rs b/src/tools/rust-analyzer/crates/hir-def/src/item_tree.rs
index c633339857492..f35df8d3a7e11 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/item_tree.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/item_tree.rs
@@ -276,7 +276,6 @@ enum SmallModItem {
     Static(Static),
     Struct(Struct),
     Trait(Trait),
-    TraitAlias(TraitAlias),
     TypeAlias(TypeAlias),
     Union(Union),
 }
@@ -404,7 +403,6 @@ ModItemId ->
     Static in small_data -> ast::Static,
     Struct in small_data -> ast::Struct,
     Trait in small_data -> ast::Trait,
-    TraitAlias in small_data -> ast::TraitAlias,
     TypeAlias in small_data -> ast::TypeAlias,
     Union in small_data -> ast::Union,
     Use in big_data -> ast::Use,
@@ -583,12 +581,6 @@ pub struct Trait {
     pub(crate) visibility: RawVisibilityId,
 }
 
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub struct TraitAlias {
-    pub name: Name,
-    pub(crate) visibility: RawVisibilityId,
-}
-
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct Impl {}
 
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/item_tree/lower.rs b/src/tools/rust-analyzer/crates/hir-def/src/item_tree/lower.rs
index 032b287cd6a82..454e06399583c 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/item_tree/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/item_tree/lower.rs
@@ -23,7 +23,7 @@ use crate::{
         BigModItem, Const, Enum, ExternBlock, ExternCrate, FieldsShape, Function, Impl,
         ImportAlias, Interned, ItemTree, ItemTreeAstId, Macro2, MacroCall, MacroRules, Mod,
         ModItemId, ModKind, ModPath, RawAttrs, RawVisibility, RawVisibilityId, SmallModItem,
-        Static, Struct, StructKind, Trait, TraitAlias, TypeAlias, Union, Use, UseTree, UseTreeKind,
+        Static, Struct, StructKind, Trait, TypeAlias, Union, Use, UseTree, UseTreeKind,
         VisibilityExplicitness,
     },
 };
@@ -134,7 +134,6 @@ impl<'a> Ctx<'a> {
             ast::Item::Const(ast) => self.lower_const(ast).into(),
             ast::Item::Module(ast) => self.lower_module(ast)?.into(),
             ast::Item::Trait(ast) => self.lower_trait(ast)?.into(),
-            ast::Item::TraitAlias(ast) => self.lower_trait_alias(ast)?.into(),
             ast::Item::Impl(ast) => self.lower_impl(ast).into(),
             ast::Item::Use(ast) => self.lower_use(ast)?.into(),
             ast::Item::ExternCrate(ast) => self.lower_extern_crate(ast)?.into(),
@@ -267,19 +266,6 @@ impl<'a> Ctx<'a> {
         Some(ast_id)
     }
 
-    fn lower_trait_alias(
-        &mut self,
-        trait_alias_def: &ast::TraitAlias,
-    ) -> Option<ItemTreeAstId<TraitAlias>> {
-        let name = trait_alias_def.name()?.as_name();
-        let visibility = self.lower_visibility(trait_alias_def);
-        let ast_id = self.source_ast_id_map.ast_id(trait_alias_def);
-
-        let alias = TraitAlias { name, visibility };
-        self.tree.small_data.insert(ast_id.upcast(), SmallModItem::TraitAlias(alias));
-        Some(ast_id)
-    }
-
     fn lower_impl(&mut self, impl_def: &ast::Impl) -> ItemTreeAstId<Impl> {
         let ast_id = self.source_ast_id_map.ast_id(impl_def);
         // Note that trait impls don't get implicit `Self` unlike traits, because here they are a
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/item_tree/pretty.rs b/src/tools/rust-analyzer/crates/hir-def/src/item_tree/pretty.rs
index 696174cb072bf..94a6cce3ce33a 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/item_tree/pretty.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/item_tree/pretty.rs
@@ -8,7 +8,7 @@ use crate::{
     item_tree::{
         Const, DefDatabase, Enum, ExternBlock, ExternCrate, FieldsShape, Function, Impl, ItemTree,
         Macro2, MacroCall, MacroRules, Mod, ModItemId, ModKind, RawAttrs, RawVisibilityId, Static,
-        Struct, Trait, TraitAlias, TypeAlias, Union, Use, UseTree, UseTreeKind,
+        Struct, Trait, TypeAlias, Union, Use, UseTree, UseTreeKind,
     },
     visibility::RawVisibility,
 };
@@ -250,12 +250,6 @@ impl Printer<'_> {
                 self.print_visibility(*visibility);
                 w!(self, "trait {} {{ ... }}", name.display(self.db, self.edition));
             }
-            ModItemId::TraitAlias(ast_id) => {
-                let TraitAlias { name, visibility } = &self.tree[ast_id];
-                self.print_ast_id(ast_id.erase());
-                self.print_visibility(*visibility);
-                wln!(self, "trait {} = ..;", name.display(self.db, self.edition));
-            }
             ModItemId::Impl(ast_id) => {
                 let Impl {} = &self.tree[ast_id];
                 self.print_ast_id(ast_id.erase());
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/lib.rs b/src/tools/rust-analyzer/crates/hir-def/src/lib.rs
index bdf8b453e2d65..1f5b1e023702f 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/lib.rs
@@ -318,9 +318,6 @@ impl TraitId {
     }
 }
 
-pub type TraitAliasLoc = ItemLoc<ast::TraitAlias>;
-impl_intern!(TraitAliasId, TraitAliasLoc, intern_trait_alias, lookup_intern_trait_alias);
-
 type TypeAliasLoc = AssocItemLoc<ast::TypeAlias>;
 impl_intern!(TypeAliasId, TypeAliasLoc, intern_type_alias, lookup_intern_type_alias);
 
@@ -742,7 +739,6 @@ pub enum ModuleDefId {
     ConstId(ConstId),
     StaticId(StaticId),
     TraitId(TraitId),
-    TraitAliasId(TraitAliasId),
     TypeAliasId(TypeAliasId),
     BuiltinType(BuiltinType),
     MacroId(MacroId),
@@ -756,7 +752,6 @@ impl_from!(
     ConstId,
     StaticId,
     TraitId,
-    TraitAliasId,
     TypeAliasId,
     BuiltinType
     for ModuleDefId
@@ -862,7 +857,6 @@ pub enum GenericDefId {
     // More importantly, this completes the set of items that contain type references
     // which is to be used by the signature expression store in the future.
     StaticId(StaticId),
-    TraitAliasId(TraitAliasId),
     TraitId(TraitId),
     TypeAliasId(TypeAliasId),
 }
@@ -872,7 +866,6 @@ impl_from!(
     FunctionId,
     ImplId,
     StaticId,
-    TraitAliasId,
     TraitId,
     TypeAliasId
     for GenericDefId
@@ -902,7 +895,6 @@ impl GenericDefId {
             GenericDefId::AdtId(AdtId::UnionId(it)) => file_id_and_params_of_item_loc(db, it),
             GenericDefId::AdtId(AdtId::EnumId(it)) => file_id_and_params_of_item_loc(db, it),
             GenericDefId::TraitId(it) => file_id_and_params_of_item_loc(db, it),
-            GenericDefId::TraitAliasId(it) => file_id_and_params_of_item_loc(db, it),
             GenericDefId::ImplId(it) => file_id_and_params_of_item_loc(db, it),
             GenericDefId::ConstId(it) => (it.lookup(db).id.file_id, None),
             GenericDefId::StaticId(it) => (it.lookup(db).id.file_id, None),
@@ -978,7 +970,6 @@ pub enum AttrDefId {
     StaticId(StaticId),
     ConstId(ConstId),
     TraitId(TraitId),
-    TraitAliasId(TraitAliasId),
     TypeAliasId(TypeAliasId),
     MacroId(MacroId),
     ImplId(ImplId),
@@ -997,7 +988,6 @@ impl_from!(
     ConstId,
     FunctionId,
     TraitId,
-    TraitAliasId,
     TypeAliasId,
     MacroId(Macro2Id, MacroRulesId, ProcMacroId),
     ImplId,
@@ -1020,7 +1010,6 @@ impl TryFrom<ModuleDefId> for AttrDefId {
             ModuleDefId::StaticId(it) => Ok(it.into()),
             ModuleDefId::TraitId(it) => Ok(it.into()),
             ModuleDefId::TypeAliasId(it) => Ok(it.into()),
-            ModuleDefId::TraitAliasId(id) => Ok(id.into()),
             ModuleDefId::MacroId(id) => Ok(id.into()),
             ModuleDefId::BuiltinType(_) => Err(()),
         }
@@ -1266,7 +1255,6 @@ impl HasModule for GenericDefId {
             GenericDefId::FunctionId(it) => it.module(db),
             GenericDefId::AdtId(it) => it.module(db),
             GenericDefId::TraitId(it) => it.module(db),
-            GenericDefId::TraitAliasId(it) => it.module(db),
             GenericDefId::TypeAliasId(it) => it.module(db),
             GenericDefId::ImplId(it) => it.module(db),
             GenericDefId::ConstId(it) => it.module(db),
@@ -1286,7 +1274,6 @@ impl HasModule for AttrDefId {
             AttrDefId::StaticId(it) => it.module(db),
             AttrDefId::ConstId(it) => it.module(db),
             AttrDefId::TraitId(it) => it.module(db),
-            AttrDefId::TraitAliasId(it) => it.module(db),
             AttrDefId::TypeAliasId(it) => it.module(db),
             AttrDefId::ImplId(it) => it.module(db),
             AttrDefId::ExternBlockId(it) => it.module(db),
@@ -1316,7 +1303,6 @@ impl ModuleDefId {
             ModuleDefId::ConstId(id) => id.module(db),
             ModuleDefId::StaticId(id) => id.module(db),
             ModuleDefId::TraitId(id) => id.module(db),
-            ModuleDefId::TraitAliasId(id) => id.module(db),
             ModuleDefId::TypeAliasId(id) => id.module(db),
             ModuleDefId::MacroId(id) => id.module(db),
             ModuleDefId::BuiltinType(_) => return None,
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/nameres/assoc.rs b/src/tools/rust-analyzer/crates/hir-def/src/nameres/assoc.rs
index 07210df887369..8d2a386de8ecc 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/nameres/assoc.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/nameres/assoc.rs
@@ -51,10 +51,18 @@ impl TraitItems {
         tr: TraitId,
     ) -> (TraitItems, DefDiagnostics) {
         let ItemLoc { container: module_id, id: ast_id } = tr.lookup(db);
+        let ast_id_map = db.ast_id_map(ast_id.file_id);
+        let source = ast_id.with_value(ast_id_map.get(ast_id.value)).to_node(db);
+        if source.eq_token().is_some() {
+            // FIXME(trait-alias) probably needs special handling here
+            return (
+                TraitItems { macro_calls: ThinVec::new(), items: Box::default() },
+                DefDiagnostics::new(vec![]),
+            );
+        }
 
         let collector =
             AssocItemCollector::new(db, module_id, ItemContainerId::TraitId(tr), ast_id.file_id);
-        let source = ast_id.with_value(collector.ast_id_map.get(ast_id.value)).to_node(db);
         let (items, macro_calls, diagnostics) = collector.collect(source.assoc_item_list());
 
         (TraitItems { macro_calls, items }, DefDiagnostics::new(diagnostics))
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/nameres/collector.rs b/src/tools/rust-analyzer/crates/hir-def/src/nameres/collector.rs
index 267c4451b9d71..07e61718222bf 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/nameres/collector.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/nameres/collector.rs
@@ -30,7 +30,7 @@ use crate::{
     ExternCrateId, ExternCrateLoc, FunctionId, FunctionLoc, ImplLoc, Intern, ItemContainerId,
     LocalModuleId, Lookup, Macro2Id, Macro2Loc, MacroExpander, MacroId, MacroRulesId,
     MacroRulesLoc, MacroRulesLocFlags, ModuleDefId, ModuleId, ProcMacroId, ProcMacroLoc, StaticLoc,
-    StructLoc, TraitAliasLoc, TraitLoc, TypeAliasLoc, UnionLoc, UnresolvedMacro, UseId, UseLoc,
+    StructLoc, TraitLoc, TypeAliasLoc, UnionLoc, UnresolvedMacro, UseId, UseLoc,
     attr::Attrs,
     db::DefDatabase,
     item_scope::{GlobId, ImportId, ImportOrExternCrate, PerNsGlobImports},
@@ -1954,20 +1954,6 @@ impl ModCollector<'_, '_> {
                         false,
                     );
                 }
-                ModItemId::TraitAlias(id) => {
-                    let it = &self.item_tree[id];
-
-                    let vis = resolve_vis(def_map, local_def_map, &self.item_tree[it.visibility]);
-                    update_def(
-                        self.def_collector,
-                        TraitAliasLoc { container: module, id: InFile::new(self.file_id(), id) }
-                            .intern(db)
-                            .into(),
-                        &it.name,
-                        vis,
-                        false,
-                    );
-                }
                 ModItemId::TypeAlias(id) => {
                     let it = &self.item_tree[id];
 
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs b/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
index a10990e6a8f9f..698292c2fbea4 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
@@ -20,7 +20,7 @@ use crate::{
     EnumVariantId, ExternBlockId, ExternCrateId, FunctionId, FxIndexMap, GenericDefId,
     GenericParamId, HasModule, ImplId, ItemContainerId, LifetimeParamId, LocalModuleId, Lookup,
     Macro2Id, MacroId, MacroRulesId, ModuleDefId, ModuleId, ProcMacroId, StaticId, StructId,
-    TraitAliasId, TraitId, TypeAliasId, TypeOrConstParamId, TypeParamId, UseId, VariantId,
+    TraitId, TypeAliasId, TypeOrConstParamId, TypeParamId, UseId, VariantId,
     builtin_type::BuiltinType,
     db::DefDatabase,
     expr_store::{
@@ -105,7 +105,6 @@ pub enum TypeNs {
     TypeAliasId(TypeAliasId),
     BuiltinType(BuiltinType),
     TraitId(TraitId),
-    TraitAliasId(TraitAliasId),
 
     ModuleId(ModuleId),
 }
@@ -1150,7 +1149,6 @@ impl<'db> ModuleItemMap<'db> {
                 let ty = match def.def {
                     ModuleDefId::AdtId(it) => TypeNs::AdtId(it),
                     ModuleDefId::TraitId(it) => TypeNs::TraitId(it),
-                    ModuleDefId::TraitAliasId(it) => TypeNs::TraitAliasId(it),
                     ModuleDefId::TypeAliasId(it) => TypeNs::TypeAliasId(it),
                     ModuleDefId::BuiltinType(it) => TypeNs::BuiltinType(it),
 
@@ -1195,7 +1193,6 @@ fn to_value_ns(per_ns: PerNs) -> Option<(ValueNs, Option<ImportOrGlob>)> {
 
         ModuleDefId::AdtId(AdtId::EnumId(_) | AdtId::UnionId(_))
         | ModuleDefId::TraitId(_)
-        | ModuleDefId::TraitAliasId(_)
         | ModuleDefId::TypeAliasId(_)
         | ModuleDefId::BuiltinType(_)
         | ModuleDefId::MacroId(_)
@@ -1214,7 +1211,6 @@ fn to_type_ns(per_ns: PerNs) -> Option<(TypeNs, Option<ImportOrExternCrate>)> {
         ModuleDefId::BuiltinType(it) => TypeNs::BuiltinType(it),
 
         ModuleDefId::TraitId(it) => TypeNs::TraitId(it),
-        ModuleDefId::TraitAliasId(it) => TypeNs::TraitAliasId(it),
 
         ModuleDefId::ModuleId(it) => TypeNs::ModuleId(it),
 
@@ -1320,12 +1316,6 @@ impl HasResolver for TraitId {
     }
 }
 
-impl HasResolver for TraitAliasId {
-    fn resolver(self, db: &dyn DefDatabase) -> Resolver<'_> {
-        lookup_resolver(db, self).push_generic_params_scope(db, self.into())
-    }
-}
-
 impl<T: Into<AdtId> + Copy> HasResolver for T {
     fn resolver(self, db: &dyn DefDatabase) -> Resolver<'_> {
         let def = self.into();
@@ -1410,7 +1400,6 @@ impl HasResolver for GenericDefId {
             GenericDefId::FunctionId(inner) => inner.resolver(db),
             GenericDefId::AdtId(adt) => adt.resolver(db),
             GenericDefId::TraitId(inner) => inner.resolver(db),
-            GenericDefId::TraitAliasId(inner) => inner.resolver(db),
             GenericDefId::TypeAliasId(inner) => inner.resolver(db),
             GenericDefId::ImplId(inner) => inner.resolver(db),
             GenericDefId::ConstId(inner) => inner.resolver(db),
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs b/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
index 598b2c0314a94..906c1c0e9ff14 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
@@ -20,15 +20,13 @@ use triomphe::Arc;
 
 use crate::{
     ConstId, EnumId, EnumVariantId, EnumVariantLoc, ExternBlockId, FunctionId, HasModule, ImplId,
-    ItemContainerId, ModuleId, StaticId, StructId, TraitAliasId, TraitId, TypeAliasId, UnionId,
-    VariantId,
+    ItemContainerId, ModuleId, StaticId, StructId, TraitId, TypeAliasId, UnionId, VariantId,
     attr::Attrs,
     db::DefDatabase,
     expr_store::{
         ExpressionStore, ExpressionStoreSourceMap,
         lower::{
-            ExprCollector, lower_function, lower_generic_params, lower_trait, lower_trait_alias,
-            lower_type_alias,
+            ExprCollector, lower_function, lower_generic_params, lower_trait, lower_type_alias,
         },
     },
     hir::{ExprId, PatId, generics::GenericParams},
@@ -469,31 +467,6 @@ impl TraitSignature {
     }
 }
 
-#[derive(Debug, PartialEq, Eq)]
-pub struct TraitAliasSignature {
-    pub name: Name,
-    pub generic_params: Arc<GenericParams>,
-    pub store: Arc<ExpressionStore>,
-}
-
-impl TraitAliasSignature {
-    pub fn query(
-        db: &dyn DefDatabase,
-        id: TraitAliasId,
-    ) -> (Arc<Self>, Arc<ExpressionStoreSourceMap>) {
-        let loc = id.lookup(db);
-
-        let source = loc.source(db);
-        let name = as_name_opt(source.value.name());
-        let (store, source_map, generic_params) = lower_trait_alias(db, loc.container, source, id);
-
-        (
-            Arc::new(TraitAliasSignature { generic_params, store: Arc::new(store), name }),
-            Arc::new(source_map),
-        )
-    }
-}
-
 bitflags! {
     #[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
     pub struct FnFlags: u16 {
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/src.rs b/src/tools/rust-analyzer/crates/hir-def/src/src.rs
index aa373a27b0d52..367b543cf9080 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/src.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/src.rs
@@ -71,7 +71,7 @@ impl HasChildSource<la_arena::Idx<ast::UseTree>> for UseId {
 }
 
 impl HasChildSource<LocalTypeOrConstParamId> for GenericDefId {
-    type Value = Either<ast::TypeOrConstParam, ast::TraitOrAlias>;
+    type Value = Either<ast::TypeOrConstParam, ast::Trait>;
     fn child_source(
         &self,
         db: &dyn DefDatabase,
@@ -89,12 +89,7 @@ impl HasChildSource<LocalTypeOrConstParamId> for GenericDefId {
             GenericDefId::TraitId(id) => {
                 let trait_ref = id.lookup(db).source(db).value;
                 let idx = idx_iter.next().unwrap();
-                params.insert(idx, Either::Right(ast::TraitOrAlias::Trait(trait_ref)));
-            }
-            GenericDefId::TraitAliasId(id) => {
-                let alias = id.lookup(db).source(db).value;
-                let idx = idx_iter.next().unwrap();
-                params.insert(idx, Either::Right(ast::TraitOrAlias::TraitAlias(alias)));
+                params.insert(idx, Either::Right(trait_ref));
             }
             _ => {}
         }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/generics.rs b/src/tools/rust-analyzer/crates/hir-ty/src/generics.rs
index e6470e5272d05..412b3ac425028 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/generics.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/generics.rs
@@ -273,7 +273,7 @@ impl Generics {
 
 pub(crate) fn trait_self_param_idx(db: &dyn DefDatabase, def: GenericDefId) -> Option<usize> {
     match def {
-        GenericDefId::TraitId(_) | GenericDefId::TraitAliasId(_) => {
+        GenericDefId::TraitId(_) => {
             let params = db.generic_params(def);
             params.trait_self_param().map(|idx| idx.into_raw().into_u32() as usize)
         }
@@ -295,8 +295,7 @@ pub(crate) fn parent_generic_def(db: &dyn DefDatabase, def: GenericDefId) -> Opt
         GenericDefId::StaticId(_)
         | GenericDefId::AdtId(_)
         | GenericDefId::TraitId(_)
-        | GenericDefId::ImplId(_)
-        | GenericDefId::TraitAliasId(_) => return None,
+        | GenericDefId::ImplId(_) => return None,
     };
 
     match container {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
index 7a11ec660d04b..d778cc0e30ed4 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
@@ -1790,7 +1790,6 @@ impl<'db> InferenceContext<'db> {
             TypeNs::AdtId(AdtId::EnumId(_))
             | TypeNs::BuiltinType(_)
             | TypeNs::TraitId(_)
-            | TypeNs::TraitAliasId(_)
             | TypeNs::ModuleId(_) => {
                 // FIXME diagnostic
                 (self.err_ty(), None)
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs
index 9519c38eeddfd..fb85909d7f41e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs
@@ -220,10 +220,6 @@ impl<'a, 'b> PathLoweringContext<'a, 'b> {
                 };
                 return (ty, None);
             }
-            TypeNs::TraitAliasId(_) => {
-                // FIXME(trait_alias): Implement trait alias.
-                return (TyKind::Error.intern(Interner), None);
-            }
             TypeNs::GenericParam(param_id) => match self.ctx.type_param_mode {
                 ParamLoweringMode::Placeholder => {
                     TyKind::Placeholder(to_placeholder_idx(self.ctx.db, param_id.into()))
@@ -311,8 +307,7 @@ impl<'a, 'b> PathLoweringContext<'a, 'b> {
             TypeNs::AdtId(_)
             | TypeNs::EnumVariantId(_)
             | TypeNs::TypeAliasId(_)
-            | TypeNs::TraitId(_)
-            | TypeNs::TraitAliasId(_) => {}
+            | TypeNs::TraitId(_) => {}
         }
     }
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs
index fc31973022bdd..c5f78e2f3cecb 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs
@@ -9,6 +9,7 @@ mod never_type;
 mod patterns;
 mod regression;
 mod simple;
+mod trait_aliases;
 mod traits;
 mod type_alias_impl_traits;
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/variance.rs b/src/tools/rust-analyzer/crates/hir-ty/src/variance.rs
index 08a215fecf623..d8a058533f761 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/variance.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/variance.rs
@@ -990,7 +990,6 @@ struct FixedPoint<T, U, V>(&'static FixedPoint<(), T, U>, V);
                 ModuleDefId::AdtId(it) => it.into(),
                 ModuleDefId::ConstId(it) => it.into(),
                 ModuleDefId::TraitId(it) => it.into(),
-                ModuleDefId::TraitAliasId(it) => it.into(),
                 ModuleDefId::TypeAliasId(it) => it.into(),
                 _ => return,
             })
@@ -1021,10 +1020,6 @@ struct FixedPoint<T, U, V>(&'static FixedPoint<(), T, U>, V);
                             let loc = it.lookup(&db);
                             loc.source(&db).value.name().unwrap()
                         }
-                        GenericDefId::TraitAliasId(it) => {
-                            let loc = it.lookup(&db);
-                            loc.source(&db).value.name().unwrap()
-                        }
                         GenericDefId::TypeAliasId(it) => {
                             let loc = it.lookup(&db);
                             loc.source(&db).value.name().unwrap()
diff --git a/src/tools/rust-analyzer/crates/hir/src/attrs.rs b/src/tools/rust-analyzer/crates/hir/src/attrs.rs
index c8645b6282392..928753ef0edeb 100644
--- a/src/tools/rust-analyzer/crates/hir/src/attrs.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/attrs.rs
@@ -19,7 +19,7 @@ use hir_ty::{db::HirDatabase, method_resolution};
 use crate::{
     Adt, AsAssocItem, AssocItem, BuiltinType, Const, ConstParam, DocLinkDef, Enum, ExternCrateDecl,
     Field, Function, GenericParam, HasCrate, Impl, LifetimeParam, Macro, Module, ModuleDef, Static,
-    Struct, Trait, TraitAlias, Type, TypeAlias, TypeParam, Union, Variant, VariantDef,
+    Struct, Trait, Type, TypeAlias, TypeParam, Union, Variant, VariantDef,
 };
 
 pub trait HasAttrs {
@@ -48,7 +48,6 @@ impl_has_attrs![
     (Static, StaticId),
     (Const, ConstId),
     (Trait, TraitId),
-    (TraitAlias, TraitAliasId),
     (TypeAlias, TypeAliasId),
     (Macro, MacroId),
     (Function, FunctionId),
@@ -137,7 +136,6 @@ fn resolve_doc_path_on_(
         AttrDefId::StaticId(it) => it.resolver(db),
         AttrDefId::ConstId(it) => it.resolver(db),
         AttrDefId::TraitId(it) => it.resolver(db),
-        AttrDefId::TraitAliasId(it) => it.resolver(db),
         AttrDefId::TypeAliasId(it) => it.resolver(db),
         AttrDefId::ImplId(it) => it.resolver(db),
         AttrDefId::ExternBlockId(it) => it.resolver(db),
@@ -216,10 +214,6 @@ fn resolve_assoc_or_field(
                 DocLinkDef::ModuleDef(def)
             });
         }
-        TypeNs::TraitAliasId(_) => {
-            // XXX: Do these get resolved?
-            return None;
-        }
         TypeNs::ModuleId(_) => {
             return None;
         }
diff --git a/src/tools/rust-analyzer/crates/hir/src/display.rs b/src/tools/rust-analyzer/crates/hir/src/display.rs
index 2960ebedf3806..b9c5131ffbb55 100644
--- a/src/tools/rust-analyzer/crates/hir/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/display.rs
@@ -23,8 +23,8 @@ use itertools::Itertools;
 use crate::{
     Adt, AsAssocItem, AssocItem, AssocItemContainer, Const, ConstParam, Crate, Enum,
     ExternCrateDecl, Field, Function, GenericParam, HasCrate, HasVisibility, Impl, LifetimeParam,
-    Macro, Module, SelfParam, Static, Struct, StructKind, Trait, TraitAlias, TraitRef, TupleField,
-    TyBuilder, Type, TypeAlias, TypeOrConstParam, TypeParam, Union, Variant,
+    Macro, Module, SelfParam, Static, Struct, StructKind, Trait, TraitRef, TupleField, TyBuilder,
+    Type, TypeAlias, TypeOrConstParam, TypeParam, Union, Variant,
 };
 
 impl HirDisplay for Function {
@@ -751,6 +751,7 @@ impl HirDisplay for TraitRef<'_> {
 
 impl HirDisplay for Trait {
     fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+        // FIXME(trait-alias) needs special handling to print the equal sign
         write_trait_header(self, f)?;
         let def_id = GenericDefId::TraitId(self.id);
         let has_where_clause = write_where_clause(def_id, f)?;
@@ -802,22 +803,6 @@ fn write_trait_header(trait_: &Trait, f: &mut HirFormatter<'_>) -> Result<(), Hi
     Ok(())
 }
 
-impl HirDisplay for TraitAlias {
-    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
-        write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
-        let data = f.db.trait_alias_signature(self.id);
-        write!(f, "trait {}", data.name.display(f.db, f.edition()))?;
-        let def_id = GenericDefId::TraitAliasId(self.id);
-        write_generic_params(def_id, f)?;
-        f.write_str(" = ")?;
-        // FIXME: Currently we lower every bounds in a trait alias as a trait bound on `Self` i.e.
-        // `trait Foo = Bar` is stored and displayed as `trait Foo = where Self: Bar`, which might
-        // be less readable.
-        write_where_clause(def_id, f)?;
-        Ok(())
-    }
-}
-
 impl HirDisplay for TypeAlias {
     fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
         write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
diff --git a/src/tools/rust-analyzer/crates/hir/src/from_id.rs b/src/tools/rust-analyzer/crates/hir/src/from_id.rs
index c6446693df3e4..bc025c5ef5cf1 100644
--- a/src/tools/rust-analyzer/crates/hir/src/from_id.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/from_id.rs
@@ -37,7 +37,6 @@ from_id![
     (hir_def::EnumId, crate::Enum),
     (hir_def::TypeAliasId, crate::TypeAlias),
     (hir_def::TraitId, crate::Trait),
-    (hir_def::TraitAliasId, crate::TraitAlias),
     (hir_def::StaticId, crate::Static),
     (hir_def::ConstId, crate::Const),
     (hir_def::FunctionId, crate::Function),
@@ -113,7 +112,6 @@ impl From<ModuleDefId> for ModuleDef {
             ModuleDefId::ConstId(it) => ModuleDef::Const(it.into()),
             ModuleDefId::StaticId(it) => ModuleDef::Static(it.into()),
             ModuleDefId::TraitId(it) => ModuleDef::Trait(it.into()),
-            ModuleDefId::TraitAliasId(it) => ModuleDef::TraitAlias(it.into()),
             ModuleDefId::TypeAliasId(it) => ModuleDef::TypeAlias(it.into()),
             ModuleDefId::BuiltinType(it) => ModuleDef::BuiltinType(it.into()),
             ModuleDefId::MacroId(it) => ModuleDef::Macro(it.into()),
@@ -131,7 +129,6 @@ impl From<ModuleDef> for ModuleDefId {
             ModuleDef::Const(it) => ModuleDefId::ConstId(it.into()),
             ModuleDef::Static(it) => ModuleDefId::StaticId(it.into()),
             ModuleDef::Trait(it) => ModuleDefId::TraitId(it.into()),
-            ModuleDef::TraitAlias(it) => ModuleDefId::TraitAliasId(it.into()),
             ModuleDef::TypeAlias(it) => ModuleDefId::TypeAliasId(it.into()),
             ModuleDef::BuiltinType(it) => ModuleDefId::BuiltinType(it.into()),
             ModuleDef::Macro(it) => ModuleDefId::MacroId(it.into()),
@@ -177,7 +174,6 @@ impl From<GenericDef> for GenericDefId {
             GenericDef::Function(it) => GenericDefId::FunctionId(it.id),
             GenericDef::Adt(it) => GenericDefId::AdtId(it.into()),
             GenericDef::Trait(it) => GenericDefId::TraitId(it.id),
-            GenericDef::TraitAlias(it) => GenericDefId::TraitAliasId(it.id),
             GenericDef::TypeAlias(it) => GenericDefId::TypeAliasId(it.id),
             GenericDef::Impl(it) => GenericDefId::ImplId(it.id),
             GenericDef::Const(it) => GenericDefId::ConstId(it.id),
@@ -192,7 +188,6 @@ impl From<GenericDefId> for GenericDef {
             GenericDefId::FunctionId(it) => GenericDef::Function(it.into()),
             GenericDefId::AdtId(it) => GenericDef::Adt(it.into()),
             GenericDefId::TraitId(it) => GenericDef::Trait(it.into()),
-            GenericDefId::TraitAliasId(it) => GenericDef::TraitAlias(it.into()),
             GenericDefId::TypeAliasId(it) => GenericDef::TypeAlias(it.into()),
             GenericDefId::ImplId(it) => GenericDef::Impl(it.into()),
             GenericDefId::ConstId(it) => GenericDef::Const(it.into()),
diff --git a/src/tools/rust-analyzer/crates/hir/src/has_source.rs b/src/tools/rust-analyzer/crates/hir/src/has_source.rs
index 4767d4792e718..ae82275e38736 100644
--- a/src/tools/rust-analyzer/crates/hir/src/has_source.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/has_source.rs
@@ -14,8 +14,7 @@ use tt::TextRange;
 use crate::{
     Adt, Callee, Const, Enum, ExternCrateDecl, Field, FieldSource, Function, Impl,
     InlineAsmOperand, Label, LifetimeParam, LocalSource, Macro, Module, Param, SelfParam, Static,
-    Struct, Trait, TraitAlias, TypeAlias, TypeOrConstParam, Union, Variant, VariantDef,
-    db::HirDatabase,
+    Struct, Trait, TypeAlias, TypeOrConstParam, Union, Variant, VariantDef, db::HirDatabase,
 };
 
 pub trait HasSource {
@@ -168,12 +167,6 @@ impl HasSource for Trait {
         Some(self.id.lookup(db).source(db))
     }
 }
-impl HasSource for TraitAlias {
-    type Ast = ast::TraitAlias;
-    fn source(self, db: &dyn HirDatabase) -> Option<InFile<Self::Ast>> {
-        Some(self.id.lookup(db).source(db))
-    }
-}
 impl HasSource for TypeAlias {
     type Ast = ast::TypeAlias;
     fn source(self, db: &dyn HirDatabase) -> Option<InFile<Self::Ast>> {
@@ -202,7 +195,7 @@ impl HasSource for Impl {
 }
 
 impl HasSource for TypeOrConstParam {
-    type Ast = Either<ast::TypeOrConstParam, ast::TraitOrAlias>;
+    type Ast = Either<ast::TypeOrConstParam, ast::Trait>;
     fn source(self, db: &dyn HirDatabase) -> Option<InFile<Self::Ast>> {
         let child_source = self.id.parent.child_source(db);
         child_source.map(|it| it.get(self.id.local_id).cloned()).transpose()
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index 475906ae51a11..4eb50c1c31c52 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -52,7 +52,7 @@ use hir_def::{
     CrateRootModuleId, DefWithBodyId, EnumId, EnumVariantId, ExternBlockId, ExternCrateId,
     FunctionId, GenericDefId, GenericParamId, HasModule, ImplId, ItemContainerId, LifetimeParamId,
     LocalFieldId, Lookup, MacroExpander, MacroId, ModuleId, StaticId, StructId, SyntheticSyntax,
-    TraitAliasId, TupleId, TypeAliasId, TypeOrConstParamId, TypeParamId, UnionId,
+    TupleId, TypeAliasId, TypeOrConstParamId, TypeParamId, UnionId,
     expr_store::{ExpressionStoreDiagnostics, ExpressionStoreSourceMap},
     hir::{
         BindingAnnotation, BindingId, Expr, ExprId, ExprOrPatId, LabelId, Pat,
@@ -333,7 +333,6 @@ pub enum ModuleDef {
     Const(Const),
     Static(Static),
     Trait(Trait),
-    TraitAlias(TraitAlias),
     TypeAlias(TypeAlias),
     BuiltinType(BuiltinType),
     Macro(Macro),
@@ -346,7 +345,6 @@ impl_from!(
     Const,
     Static,
     Trait,
-    TraitAlias,
     TypeAlias,
     BuiltinType,
     Macro
@@ -373,7 +371,6 @@ impl ModuleDef {
             ModuleDef::Const(it) => Some(it.module(db)),
             ModuleDef::Static(it) => Some(it.module(db)),
             ModuleDef::Trait(it) => Some(it.module(db)),
-            ModuleDef::TraitAlias(it) => Some(it.module(db)),
             ModuleDef::TypeAlias(it) => Some(it.module(db)),
             ModuleDef::Macro(it) => Some(it.module(db)),
             ModuleDef::BuiltinType(_) => None,
@@ -402,7 +399,6 @@ impl ModuleDef {
             ModuleDef::Const(it) => it.name(db)?,
             ModuleDef::Adt(it) => it.name(db),
             ModuleDef::Trait(it) => it.name(db),
-            ModuleDef::TraitAlias(it) => it.name(db),
             ModuleDef::Function(it) => it.name(db),
             ModuleDef::Variant(it) => it.name(db),
             ModuleDef::TypeAlias(it) => it.name(db),
@@ -425,7 +421,6 @@ impl ModuleDef {
                 Adt::Union(it) => it.id.into(),
             },
             ModuleDef::Trait(it) => it.id.into(),
-            ModuleDef::TraitAlias(it) => it.id.into(),
             ModuleDef::Function(it) => it.id.into(),
             ModuleDef::TypeAlias(it) => it.id.into(),
             ModuleDef::Module(it) => it.id.into(),
@@ -465,7 +460,6 @@ impl ModuleDef {
             ModuleDef::Module(_)
             | ModuleDef::Adt(_)
             | ModuleDef::Trait(_)
-            | ModuleDef::TraitAlias(_)
             | ModuleDef::TypeAlias(_)
             | ModuleDef::Macro(_)
             | ModuleDef::BuiltinType(_) => None,
@@ -478,7 +472,6 @@ impl ModuleDef {
             ModuleDef::Function(it) => Some(it.into()),
             ModuleDef::Adt(it) => Some(it.into()),
             ModuleDef::Trait(it) => Some(it.into()),
-            ModuleDef::TraitAlias(it) => Some(it.into()),
             ModuleDef::TypeAlias(it) => Some(it.into()),
             ModuleDef::Module(_)
             | ModuleDef::Variant(_)
@@ -498,7 +491,6 @@ impl ModuleDef {
             ModuleDef::Const(it) => it.attrs(db),
             ModuleDef::Static(it) => it.attrs(db),
             ModuleDef::Trait(it) => it.attrs(db),
-            ModuleDef::TraitAlias(it) => it.attrs(db),
             ModuleDef::TypeAlias(it) => it.attrs(db),
             ModuleDef::Macro(it) => it.attrs(db),
             ModuleDef::BuiltinType(_) => return None,
@@ -524,7 +516,6 @@ impl HasVisibility for ModuleDef {
             ModuleDef::Const(it) => it.visibility(db),
             ModuleDef::Static(it) => it.visibility(db),
             ModuleDef::Trait(it) => it.visibility(db),
-            ModuleDef::TraitAlias(it) => it.visibility(db),
             ModuleDef::TypeAlias(it) => it.visibility(db),
             ModuleDef::Variant(it) => it.visibility(db),
             ModuleDef::Macro(it) => it.visibility(db),
@@ -3045,29 +3036,6 @@ impl HasVisibility for Trait {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct TraitAlias {
-    pub(crate) id: TraitAliasId,
-}
-
-impl TraitAlias {
-    pub fn module(self, db: &dyn HirDatabase) -> Module {
-        Module { id: self.id.lookup(db).container }
-    }
-
-    pub fn name(self, db: &dyn HirDatabase) -> Name {
-        db.trait_alias_signature(self.id).name.clone()
-    }
-}
-
-impl HasVisibility for TraitAlias {
-    fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
-        let loc = self.id.lookup(db);
-        let source = loc.source(db);
-        visibility_from_ast(db, self.id, source.map(|src| src.visibility()))
-    }
-}
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct TypeAlias {
     pub(crate) id: TypeAliasId,
@@ -3690,7 +3658,6 @@ pub enum GenericDef {
     Function(Function),
     Adt(Adt),
     Trait(Trait),
-    TraitAlias(TraitAlias),
     TypeAlias(TypeAlias),
     Impl(Impl),
     // consts can have type parameters from their parents (i.e. associated consts of traits)
@@ -3701,7 +3668,6 @@ impl_from!(
     Function,
     Adt(Struct, Enum, Union),
     Trait,
-    TraitAlias,
     TypeAlias,
     Impl,
     Const,
@@ -3751,7 +3717,6 @@ impl GenericDef {
             GenericDef::Function(it) => it.id.into(),
             GenericDef::Adt(it) => it.into(),
             GenericDef::Trait(it) => it.id.into(),
-            GenericDef::TraitAlias(it) => it.id.into(),
             GenericDef::TypeAlias(it) => it.id.into(),
             GenericDef::Impl(it) => it.id.into(),
             GenericDef::Const(it) => it.id.into(),
@@ -3776,7 +3741,6 @@ impl GenericDef {
             GenericDefId::FunctionId(it) => db.function_signature_with_source_map(it).1,
             GenericDefId::ImplId(it) => db.impl_signature_with_source_map(it).1,
             GenericDefId::StaticId(_) => return,
-            GenericDefId::TraitAliasId(it) => db.trait_alias_signature_with_source_map(it).1,
             GenericDefId::TraitId(it) => db.trait_signature_with_source_map(it).1,
             GenericDefId::TypeAliasId(it) => db.type_alias_signature_with_source_map(it).1,
         };
@@ -3813,7 +3777,6 @@ impl GenericDef {
             GenericDef::Adt(Adt::Enum(_)) => "enum",
             GenericDef::Adt(Adt::Union(_)) => "union",
             GenericDef::Trait(_) => "trait",
-            GenericDef::TraitAlias(_) => "trait alias",
             GenericDef::TypeAlias(_) => "type alias",
             GenericDef::Impl(_) => "impl",
             GenericDef::Const(_) => "constant",
@@ -6401,12 +6364,6 @@ impl HasCrate for Trait {
     }
 }
 
-impl HasCrate for TraitAlias {
-    fn krate(&self, db: &dyn HirDatabase) -> Crate {
-        self.module(db).krate()
-    }
-}
-
 impl HasCrate for Static {
     fn krate(&self, db: &dyn HirDatabase) -> Crate {
         self.module(db).krate()
@@ -6500,12 +6457,6 @@ impl HasContainer for Trait {
     }
 }
 
-impl HasContainer for TraitAlias {
-    fn container(&self, db: &dyn HirDatabase) -> ItemContainer {
-        ItemContainer::Module(Module { id: self.id.lookup(db).container })
-    }
-}
-
 impl HasContainer for ExternBlock {
     fn container(&self, db: &dyn HirDatabase) -> ItemContainer {
         ItemContainer::Module(Module { id: self.id.lookup(db).container })
diff --git a/src/tools/rust-analyzer/crates/hir/src/semantics.rs b/src/tools/rust-analyzer/crates/hir/src/semantics.rs
index 05f06f97fdc26..b43165fd8ad70 100644
--- a/src/tools/rust-analyzer/crates/hir/src/semantics.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/semantics.rs
@@ -46,8 +46,8 @@ use crate::{
     Adjust, Adjustment, Adt, AutoBorrow, BindingMode, BuiltinAttr, Callable, Const, ConstParam,
     Crate, DefWithBody, DeriveHelper, Enum, Field, Function, GenericSubstitution, HasSource, Impl,
     InFile, InlineAsmOperand, ItemInNs, Label, LifetimeParam, Local, Macro, Module, ModuleDef,
-    Name, OverloadedDeref, ScopeDef, Static, Struct, ToolModule, Trait, TraitAlias, TupleField,
-    Type, TypeAlias, TypeParam, Union, Variant, VariantDef,
+    Name, OverloadedDeref, ScopeDef, Static, Struct, ToolModule, Trait, TupleField, Type,
+    TypeAlias, TypeParam, Union, Variant, VariantDef,
     db::HirDatabase,
     semantics::source_to_def::{ChildContainer, SourceToDefCache, SourceToDefCtx},
     source_analyzer::{SourceAnalyzer, name_hygiene, resolve_hir_path},
@@ -85,8 +85,7 @@ impl PathResolution {
                 | ModuleDef::Function(_)
                 | ModuleDef::Module(_)
                 | ModuleDef::Static(_)
-                | ModuleDef::Trait(_)
-                | ModuleDef::TraitAlias(_),
+                | ModuleDef::Trait(_),
             ) => None,
             PathResolution::Def(ModuleDef::TypeAlias(alias)) => {
                 Some(TypeNs::TypeAliasId((*alias).into()))
@@ -343,10 +342,6 @@ impl<DB: HirDatabase + ?Sized> Semantics<'_, DB> {
         self.imp.to_def(s)
     }
 
-    pub fn to_trait_alias_def(&self, t: &ast::TraitAlias) -> Option<TraitAlias> {
-        self.imp.to_def(t)
-    }
-
     pub fn to_trait_def(&self, t: &ast::Trait) -> Option<Trait> {
         self.imp.to_def(t)
     }
@@ -2138,7 +2133,6 @@ to_def_impls![
     (crate::Enum, ast::Enum, enum_to_def),
     (crate::Union, ast::Union, union_to_def),
     (crate::Trait, ast::Trait, trait_to_def),
-    (crate::TraitAlias, ast::TraitAlias, trait_alias_to_def),
     (crate::Impl, ast::Impl, impl_to_def),
     (crate::TypeAlias, ast::TypeAlias, type_alias_to_def),
     (crate::Const, ast::Const, const_to_def),
diff --git a/src/tools/rust-analyzer/crates/hir/src/semantics/child_by_source.rs b/src/tools/rust-analyzer/crates/hir/src/semantics/child_by_source.rs
index e7db93d375d33..5019a5987e513 100644
--- a/src/tools/rust-analyzer/crates/hir/src/semantics/child_by_source.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/semantics/child_by_source.rs
@@ -154,9 +154,6 @@ impl ChildBySource for ItemScope {
                 }
                 ModuleDefId::StaticId(id) => insert_item_loc(db, map, file_id, id, keys::STATIC),
                 ModuleDefId::TraitId(id) => insert_item_loc(db, map, file_id, id, keys::TRAIT),
-                ModuleDefId::TraitAliasId(id) => {
-                    insert_item_loc(db, map, file_id, id, keys::TRAIT_ALIAS)
-                }
                 ModuleDefId::AdtId(adt) => match adt {
                     AdtId::StructId(id) => insert_item_loc(db, map, file_id, id, keys::STRUCT),
                     AdtId::UnionId(id) => insert_item_loc(db, map, file_id, id, keys::UNION),
diff --git a/src/tools/rust-analyzer/crates/hir/src/semantics/source_to_def.rs b/src/tools/rust-analyzer/crates/hir/src/semantics/source_to_def.rs
index 71ee0f6938960..44df4d8fc8c80 100644
--- a/src/tools/rust-analyzer/crates/hir/src/semantics/source_to_def.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/semantics/source_to_def.rs
@@ -89,8 +89,8 @@ use either::Either;
 use hir_def::{
     AdtId, BlockId, ConstId, ConstParamId, DefWithBodyId, EnumId, EnumVariantId, ExternBlockId,
     ExternCrateId, FieldId, FunctionId, GenericDefId, GenericParamId, ImplId, LifetimeParamId,
-    Lookup, MacroId, ModuleId, StaticId, StructId, TraitAliasId, TraitId, TypeAliasId, TypeParamId,
-    UnionId, UseId, VariantId,
+    Lookup, MacroId, ModuleId, StaticId, StructId, TraitId, TypeAliasId, TypeParamId, UnionId,
+    UseId, VariantId,
     dyn_map::{
         DynMap,
         keys::{self, Key},
@@ -252,12 +252,6 @@ impl SourceToDefCtx<'_, '_> {
     pub(super) fn trait_to_def(&mut self, src: InFile<&ast::Trait>) -> Option<TraitId> {
         self.to_def(src, keys::TRAIT)
     }
-    pub(super) fn trait_alias_to_def(
-        &mut self,
-        src: InFile<&ast::TraitAlias>,
-    ) -> Option<TraitAliasId> {
-        self.to_def(src, keys::TRAIT_ALIAS)
-    }
     pub(super) fn impl_to_def(&mut self, src: InFile<&ast::Impl>) -> Option<ImplId> {
         self.to_def(src, keys::IMPL)
     }
@@ -555,9 +549,6 @@ impl SourceToDefCtx<'_, '_> {
                 }
                 ast::Item::Enum(it) => this.enum_to_def(InFile::new(file_id, it)).map(Into::into),
                 ast::Item::Trait(it) => this.trait_to_def(InFile::new(file_id, it)).map(Into::into),
-                ast::Item::TraitAlias(it) => {
-                    this.trait_alias_to_def(InFile::new(file_id, it)).map(Into::into)
-                }
                 ast::Item::TypeAlias(it) => {
                     this.type_alias_to_def(InFile::new(file_id, it)).map(Into::into)
                 }
@@ -636,9 +627,6 @@ impl SourceToDefCtx<'_, '_> {
                 ast::Item::TypeAlias(it) => ChildContainer::GenericDefId(
                     self.type_alias_to_def(container.with_value(it))?.into(),
                 ),
-                ast::Item::TraitAlias(it) => ChildContainer::GenericDefId(
-                    self.trait_alias_to_def(container.with_value(it))?.into(),
-                ),
                 ast::Item::Struct(it) => {
                     let def = self.struct_to_def(container.with_value(it))?;
                     let is_in_body = it.field_list().is_some_and(|it| {
diff --git a/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs b/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
index d25fb1d8cdb7e..126392af4619a 100644
--- a/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
@@ -10,7 +10,7 @@ use std::iter::{self, once};
 use crate::{
     Adt, AssocItem, BindingMode, BuiltinAttr, BuiltinType, Callable, Const, DeriveHelper, Field,
     Function, GenericSubstitution, Local, Macro, ModuleDef, Static, Struct, ToolModule, Trait,
-    TraitAlias, TupleField, Type, TypeAlias, Variant,
+    TupleField, Type, TypeAlias, Variant,
     db::HirDatabase,
     semantics::{PathResolution, PathResolutionPerNs},
 };
@@ -1587,7 +1587,6 @@ fn resolve_hir_path_(
             TypeNs::TypeAliasId(it) => PathResolution::Def(TypeAlias::from(it).into()),
             TypeNs::BuiltinType(it) => PathResolution::Def(BuiltinType::from(it).into()),
             TypeNs::TraitId(it) => PathResolution::Def(Trait::from(it).into()),
-            TypeNs::TraitAliasId(it) => PathResolution::Def(TraitAlias::from(it).into()),
             TypeNs::ModuleId(it) => PathResolution::Def(ModuleDef::Module(it.into())),
         };
         match unresolved {
@@ -1737,7 +1736,6 @@ fn resolve_hir_path_qualifier(
             TypeNs::TypeAliasId(it) => PathResolution::Def(TypeAlias::from(it).into()),
             TypeNs::BuiltinType(it) => PathResolution::Def(BuiltinType::from(it).into()),
             TypeNs::TraitId(it) => PathResolution::Def(Trait::from(it).into()),
-            TypeNs::TraitAliasId(it) => PathResolution::Def(TraitAlias::from(it).into()),
             TypeNs::ModuleId(it) => PathResolution::Def(ModuleDef::Module(it.into())),
         };
         match unresolved {
diff --git a/src/tools/rust-analyzer/crates/hir/src/symbols.rs b/src/tools/rust-analyzer/crates/hir/src/symbols.rs
index dca10193e29bf..d8c624e5c6896 100644
--- a/src/tools/rust-analyzer/crates/hir/src/symbols.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/symbols.rs
@@ -148,9 +148,6 @@ impl<'a> SymbolCollector<'a> {
                     let trait_do_not_complete = this.push_decl(id, name, false, None);
                     this.collect_from_trait(id, trait_do_not_complete);
                 }
-                ModuleDefId::TraitAliasId(id) => {
-                    this.push_decl(id, name, false, None);
-                }
                 ModuleDefId::TypeAliasId(id) => {
                     this.push_decl(id, name, false, None);
                 }
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_module.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_module.rs
index e783b8693456c..dad19bfb8a2c8 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_module.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_module.rs
@@ -613,7 +613,6 @@ impl Module {
                     | Definition::Const(_)
                     | Definition::Static(_)
                     | Definition::Trait(_)
-                    | Definition::TraitAlias(_)
                     | Definition::TypeAlias(_)
             );
 
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/fix_visibility.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/fix_visibility.rs
index 3badc17d01af4..55de537debf3d 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/fix_visibility.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/fix_visibility.rs
@@ -136,10 +136,6 @@ fn target_data_for_def(
             target_name = Some(t.name(db));
             offset_target_and_file_id(db, t)?
         }
-        hir::ModuleDef::TraitAlias(t) => {
-            target_name = Some(t.name(db));
-            offset_target_and_file_id(db, t)?
-        }
         hir::ModuleDef::TypeAlias(t) => {
             target_name = Some(t.name(db));
             offset_target_and_file_id(db, t)?
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/move_bounds.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/move_bounds.rs
index a9df6f6fc3669..e5425abab097a 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/move_bounds.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/move_bounds.rs
@@ -55,7 +55,6 @@ pub(crate) fn move_bounds_to_where_clause(
                 match parent {
                     ast::Fn(it) => it.get_or_create_where_clause(),
                     ast::Trait(it) => it.get_or_create_where_clause(),
-                    ast::TraitAlias(it) => it.get_or_create_where_clause(),
                     ast::Impl(it) => it.get_or_create_where_clause(),
                     ast::Enum(it) => it.get_or_create_where_clause(),
                     ast::Struct(it) => it.get_or_create_where_clause(),
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/type.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/type.rs
index 7c38c7d8ce44f..fc27cbd65a1ee 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/type.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/type.rs
@@ -37,9 +37,7 @@ pub(crate) fn complete_type_path(
                 true
             }
             // Type things are fine
-            ScopeDef::ModuleDef(
-                BuiltinType(_) | Adt(_) | Module(_) | Trait(_) | TraitAlias(_) | TypeAlias(_),
-            )
+            ScopeDef::ModuleDef(BuiltinType(_) | Adt(_) | Module(_) | Trait(_) | TypeAlias(_))
             | ScopeDef::AdtSelfType(_)
             | ScopeDef::Unknown
             | ScopeDef::GenericParam(TypeParam(_)) => location.complete_types(),
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context.rs
index cfd7f80d40b30..28c00cde126ca 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context.rs
@@ -525,7 +525,6 @@ impl CompletionContext<'_> {
                 hir::ModuleDef::Const(it) => self.is_visible(it),
                 hir::ModuleDef::Static(it) => self.is_visible(it),
                 hir::ModuleDef::Trait(it) => self.is_visible(it),
-                hir::ModuleDef::TraitAlias(it) => self.is_visible(it),
                 hir::ModuleDef::TypeAlias(it) => self.is_visible(it),
                 hir::ModuleDef::Macro(it) => self.is_visible(it),
                 hir::ModuleDef::BuiltinType(_) => Visible::Yes,
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
index 9d246017131a0..23db63c1a95fe 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
@@ -1037,9 +1037,6 @@ fn classify_name_ref<'db>(
                                             sema.source(trait_)?.value.generic_param_list()
                                         }
                                     }
-                                    hir::ModuleDef::TraitAlias(trait_) => {
-                                        sema.source(trait_)?.value.generic_param_list()
-                                    }
                                     hir::ModuleDef::TypeAlias(ty_) => {
                                         sema.source(ty_)?.value.generic_param_list()
                                     }
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/item.rs b/src/tools/rust-analyzer/crates/ide-completion/src/item.rs
index f27cd07816657..5fb9dc93c93da 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/item.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/item.rs
@@ -399,7 +399,6 @@ impl CompletionItemKind {
                 SymbolKind::Struct => "st",
                 SymbolKind::ToolModule => "tm",
                 SymbolKind::Trait => "tt",
-                SymbolKind::TraitAlias => "tr",
                 SymbolKind::TypeAlias => "ta",
                 SymbolKind::TypeParam => "tp",
                 SymbolKind::Union => "un",
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/render.rs b/src/tools/rust-analyzer/crates/ide-completion/src/render.rs
index 3d7a4067c2cd0..7d23f9d14c66f 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/render.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/render.rs
@@ -486,10 +486,7 @@ fn render_resolution_path(
         | ScopeDef::Label(_)
         | ScopeDef::Unknown
         | ScopeDef::ModuleDef(
-            ModuleDef::Trait(_)
-            | ModuleDef::TraitAlias(_)
-            | ModuleDef::Module(_)
-            | ModuleDef::TypeAlias(_),
+            ModuleDef::Trait(_) | ModuleDef::Module(_) | ModuleDef::TypeAlias(_),
         ) => (),
     };
 
@@ -542,9 +539,6 @@ fn res_to_kind(resolution: ScopeDef) -> CompletionItemKind {
         ScopeDef::ModuleDef(Const(..)) => CompletionItemKind::SymbolKind(SymbolKind::Const),
         ScopeDef::ModuleDef(Static(..)) => CompletionItemKind::SymbolKind(SymbolKind::Static),
         ScopeDef::ModuleDef(Trait(..)) => CompletionItemKind::SymbolKind(SymbolKind::Trait),
-        ScopeDef::ModuleDef(TraitAlias(..)) => {
-            CompletionItemKind::SymbolKind(SymbolKind::TraitAlias)
-        }
         ScopeDef::ModuleDef(TypeAlias(..)) => CompletionItemKind::SymbolKind(SymbolKind::TypeAlias),
         ScopeDef::ModuleDef(BuiltinType(..)) => CompletionItemKind::BuiltinType,
         ScopeDef::GenericParam(param) => CompletionItemKind::SymbolKind(match param {
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/active_parameter.rs b/src/tools/rust-analyzer/crates/ide-db/src/active_parameter.rs
index 9edfc113f764c..4fb7d142ed5f1 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/active_parameter.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/active_parameter.rs
@@ -125,7 +125,6 @@ pub fn generic_def_for_node(
                     hir::PathResolution::Def(hir::ModuleDef::Adt(it)) => it.into(),
                     hir::PathResolution::Def(hir::ModuleDef::Function(it)) => it.into(),
                     hir::PathResolution::Def(hir::ModuleDef::Trait(it)) => it.into(),
-                    hir::PathResolution::Def(hir::ModuleDef::TraitAlias(it)) => it.into(),
                     hir::PathResolution::Def(hir::ModuleDef::TypeAlias(it)) => it.into(),
                     hir::PathResolution::Def(hir::ModuleDef::Variant(it)) => {
                         variant = Some(it);
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/defs.rs b/src/tools/rust-analyzer/crates/ide-db/src/defs.rs
index 2a4fcf6a2e5f7..61a21ccf2f775 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/defs.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/defs.rs
@@ -16,7 +16,7 @@ use hir::{
     ExternCrateDecl, Field, Function, GenericDef, GenericParam, GenericSubstitution, HasContainer,
     HasVisibility, HirDisplay, Impl, InlineAsmOperand, ItemContainer, Label, Local, Macro, Module,
     ModuleDef, Name, PathResolution, Semantics, Static, StaticLifetime, Struct, ToolModule, Trait,
-    TraitAlias, TupleField, TypeAlias, Variant, VariantDef, Visibility,
+    TupleField, TypeAlias, Variant, VariantDef, Visibility,
 };
 use span::Edition;
 use stdx::{format_to, impl_from};
@@ -40,7 +40,6 @@ pub enum Definition {
     Const(Const),
     Static(Static),
     Trait(Trait),
-    TraitAlias(TraitAlias),
     TypeAlias(TypeAlias),
     SelfType(Impl),
     GenericParam(GenericParam),
@@ -83,7 +82,6 @@ impl Definition {
             Definition::Const(it) => it.module(db),
             Definition::Static(it) => it.module(db),
             Definition::Trait(it) => it.module(db),
-            Definition::TraitAlias(it) => it.module(db),
             Definition::TypeAlias(it) => it.module(db),
             Definition::Variant(it) => it.module(db),
             Definition::SelfType(it) => it.module(db),
@@ -122,7 +120,6 @@ impl Definition {
             Definition::Const(it) => container_to_definition(it.container(db)),
             Definition::Static(it) => container_to_definition(it.container(db)),
             Definition::Trait(it) => container_to_definition(it.container(db)),
-            Definition::TraitAlias(it) => container_to_definition(it.container(db)),
             Definition::TypeAlias(it) => container_to_definition(it.container(db)),
             Definition::Variant(it) => Some(Adt::Enum(it.parent_enum(db)).into()),
             Definition::SelfType(it) => Some(it.module(db).into()),
@@ -151,7 +148,6 @@ impl Definition {
             Definition::Const(it) => it.visibility(db),
             Definition::Static(it) => it.visibility(db),
             Definition::Trait(it) => it.visibility(db),
-            Definition::TraitAlias(it) => it.visibility(db),
             Definition::TypeAlias(it) => it.visibility(db),
             Definition::Variant(it) => it.visibility(db),
             Definition::ExternCrateDecl(it) => it.visibility(db),
@@ -185,7 +181,6 @@ impl Definition {
             Definition::Const(it) => it.name(db)?,
             Definition::Static(it) => it.name(db),
             Definition::Trait(it) => it.name(db),
-            Definition::TraitAlias(it) => it.name(db),
             Definition::TypeAlias(it) => it.name(db),
             Definition::BuiltinType(it) => it.name(),
             Definition::TupleField(it) => it.name(),
@@ -230,7 +225,6 @@ impl Definition {
             Definition::Const(it) => it.docs_with_rangemap(db),
             Definition::Static(it) => it.docs_with_rangemap(db),
             Definition::Trait(it) => it.docs_with_rangemap(db),
-            Definition::TraitAlias(it) => it.docs_with_rangemap(db),
             Definition::TypeAlias(it) => {
                 it.docs_with_rangemap(db).or_else(|| {
                     // docs are missing, try to fall back to the docs of the aliased item.
@@ -321,7 +315,6 @@ impl Definition {
             Definition::Const(it) => it.display(db, display_target).to_string(),
             Definition::Static(it) => it.display(db, display_target).to_string(),
             Definition::Trait(it) => it.display(db, display_target).to_string(),
-            Definition::TraitAlias(it) => it.display(db, display_target).to_string(),
             Definition::TypeAlias(it) => it.display(db, display_target).to_string(),
             Definition::BuiltinType(it) => {
                 it.name().display(db, display_target.edition).to_string()
@@ -589,7 +582,6 @@ impl<'db> NameClass<'db> {
                 ast::Item::Module(it) => Definition::Module(sema.to_def(&it)?),
                 ast::Item::Static(it) => Definition::Static(sema.to_def(&it)?),
                 ast::Item::Trait(it) => Definition::Trait(sema.to_def(&it)?),
-                ast::Item::TraitAlias(it) => Definition::TraitAlias(sema.to_def(&it)?),
                 ast::Item::TypeAlias(it) => Definition::TypeAlias(sema.to_def(&it)?),
                 ast::Item::Enum(it) => Definition::Adt(hir::Adt::Enum(sema.to_def(&it)?)),
                 ast::Item::Struct(it) => Definition::Adt(hir::Adt::Struct(sema.to_def(&it)?)),
@@ -895,7 +887,7 @@ impl<'db> NameRefClass<'db> {
 }
 
 impl_from!(
-    Field, Module, Function, Adt, Variant, Const, Static, Trait, TraitAlias, TypeAlias, BuiltinType, Local,
+    Field, Module, Function, Adt, Variant, Const, Static, Trait, TypeAlias, BuiltinType, Local,
     GenericParam, Label, Macro, ExternCrateDecl
     for Definition
 );
@@ -975,7 +967,6 @@ impl From<ModuleDef> for Definition {
             ModuleDef::Const(it) => Definition::Const(it),
             ModuleDef::Static(it) => Definition::Static(it),
             ModuleDef::Trait(it) => Definition::Trait(it),
-            ModuleDef::TraitAlias(it) => Definition::TraitAlias(it),
             ModuleDef::TypeAlias(it) => Definition::TypeAlias(it),
             ModuleDef::Macro(it) => Definition::Macro(it),
             ModuleDef::BuiltinType(it) => Definition::BuiltinType(it),
@@ -1017,7 +1008,6 @@ impl From<GenericDef> for Definition {
             GenericDef::Function(it) => it.into(),
             GenericDef::Adt(it) => it.into(),
             GenericDef::Trait(it) => it.into(),
-            GenericDef::TraitAlias(it) => it.into(),
             GenericDef::TypeAlias(it) => it.into(),
             GenericDef::Impl(it) => it.into(),
             GenericDef::Const(it) => it.into(),
@@ -1033,7 +1023,6 @@ impl TryFrom<Definition> for GenericDef {
             Definition::Function(it) => Ok(it.into()),
             Definition::Adt(it) => Ok(it.into()),
             Definition::Trait(it) => Ok(it.into()),
-            Definition::TraitAlias(it) => Ok(it.into()),
             Definition::TypeAlias(it) => Ok(it.into()),
             Definition::SelfType(it) => Ok(it.into()),
             Definition::Const(it) => Ok(it.into()),
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/documentation.rs b/src/tools/rust-analyzer/crates/ide-db/src/documentation.rs
index 30c355f8b3f93..cab19aadfd010 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/documentation.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/documentation.rs
@@ -195,8 +195,7 @@ macro_rules! impl_has_docs {
 }
 
 impl_has_docs![
-    Variant, Field, Static, Const, Trait, TraitAlias, TypeAlias, Macro, Function, Adt, Module,
-    Impl, Crate,
+    Variant, Field, Static, Const, Trait, TypeAlias, Macro, Function, Adt, Module, Impl, Crate,
 ];
 
 macro_rules! impl_has_docs_enum {
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/imports/import_assets.rs b/src/tools/rust-analyzer/crates/ide-db/src/imports/import_assets.rs
index 9f35988924b92..1012f993344fe 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/imports/import_assets.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/imports/import_assets.rs
@@ -475,8 +475,6 @@ fn validate_resolvable(
         }
         // FIXME
         ModuleDef::Trait(_) => return None,
-        // FIXME
-        ModuleDef::TraitAlias(_) => return None,
         ModuleDef::TypeAlias(alias) => alias.ty(db),
         ModuleDef::BuiltinType(builtin) => builtin.ty(db),
         ModuleDef::Adt(adt) => adt.ty(db),
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/lib.rs b/src/tools/rust-analyzer/crates/ide-db/src/lib.rs
index 49f7f63a04a42..1f074de4cd7d2 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/lib.rs
@@ -273,7 +273,6 @@ pub enum SymbolKind {
     Struct,
     ToolModule,
     Trait,
-    TraitAlias,
     TypeAlias,
     TypeParam,
     Union,
@@ -306,7 +305,6 @@ impl From<hir::ModuleDef> for SymbolKind {
             hir::ModuleDef::Adt(hir::Adt::Enum(..)) => SymbolKind::Enum,
             hir::ModuleDef::Adt(hir::Adt::Union(..)) => SymbolKind::Union,
             hir::ModuleDef::Trait(..) => SymbolKind::Trait,
-            hir::ModuleDef::TraitAlias(..) => SymbolKind::TraitAlias,
             hir::ModuleDef::TypeAlias(..) => SymbolKind::TypeAlias,
             hir::ModuleDef::BuiltinType(..) => SymbolKind::TypeAlias,
         }
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/rename.rs b/src/tools/rust-analyzer/crates/ide-db/src/rename.rs
index 424b27a398b20..a8800c142a22e 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/rename.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/rename.rs
@@ -163,7 +163,6 @@ impl Definition {
             Definition::Const(it) => name_range(it, sema).and_then(syn_ctx_is_root),
             Definition::Static(it) => name_range(it, sema).and_then(syn_ctx_is_root),
             Definition::Trait(it) => name_range(it, sema).and_then(syn_ctx_is_root),
-            Definition::TraitAlias(it) => name_range(it, sema).and_then(syn_ctx_is_root),
             Definition::TypeAlias(it) => name_range(it, sema).and_then(syn_ctx_is_root),
             Definition::Local(it) => {
                 name_range(it.primary_source(sema.db), sema).and_then(syn_ctx_is_root)
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/search.rs b/src/tools/rust-analyzer/crates/ide-db/src/search.rs
index abd4dc8300b39..f1d076e874d5c 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/search.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/search.rs
@@ -352,7 +352,6 @@ impl Definition {
                 hir::GenericDef::Function(it) => it.source(db).map(|src| src.syntax().cloned()),
                 hir::GenericDef::Adt(it) => it.source(db).map(|src| src.syntax().cloned()),
                 hir::GenericDef::Trait(it) => it.source(db).map(|src| src.syntax().cloned()),
-                hir::GenericDef::TraitAlias(it) => it.source(db).map(|src| src.syntax().cloned()),
                 hir::GenericDef::TypeAlias(it) => it.source(db).map(|src| src.syntax().cloned()),
                 hir::GenericDef::Impl(it) => it.source(db).map(|src| src.syntax().cloned()),
                 hir::GenericDef::Const(it) => it.source(db).map(|src| src.syntax().cloned()),
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/symbol_index.rs b/src/tools/rust-analyzer/crates/ide-db/src/symbol_index.rs
index 9c4e6f5cbf82f..78ade30c7e3ed 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/symbol_index.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/symbol_index.rs
@@ -357,7 +357,6 @@ impl Query {
                             hir::ModuleDef::Adt(..)
                                 | hir::ModuleDef::TypeAlias(..)
                                 | hir::ModuleDef::BuiltinType(..)
-                                | hir::ModuleDef::TraitAlias(..)
                                 | hir::ModuleDef::Trait(..)
                         );
                     if non_type_for_type_only_query || !self.matches_assoc_mode(symbol.is_assoc) {
diff --git a/src/tools/rust-analyzer/crates/ide/src/doc_links.rs b/src/tools/rust-analyzer/crates/ide/src/doc_links.rs
index d47cc65079384..c197d559aa89a 100644
--- a/src/tools/rust-analyzer/crates/ide/src/doc_links.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/doc_links.rs
@@ -225,7 +225,6 @@ pub(crate) fn resolve_doc_path_for_def(
         Definition::Const(it) => it.resolve_doc_path(db, link, ns, is_inner_doc),
         Definition::Static(it) => it.resolve_doc_path(db, link, ns, is_inner_doc),
         Definition::Trait(it) => it.resolve_doc_path(db, link, ns, is_inner_doc),
-        Definition::TraitAlias(it) => it.resolve_doc_path(db, link, ns, is_inner_doc),
         Definition::TypeAlias(it) => it.resolve_doc_path(db, link, ns, is_inner_doc),
         Definition::Macro(it) => it.resolve_doc_path(db, link, ns, is_inner_doc),
         Definition::Field(it) => it.resolve_doc_path(db, link, ns, is_inner_doc),
@@ -671,11 +670,9 @@ fn filename_and_frag_for_def(
             None => String::from("index.html"),
         },
         Definition::Trait(t) => {
+            // FIXME(trait-alias): url should be traitalias. for aliases
             format!("trait.{}.html", t.name(db).as_str())
         }
-        Definition::TraitAlias(t) => {
-            format!("traitalias.{}.html", t.name(db).as_str())
-        }
         Definition::TypeAlias(t) => {
             format!("type.{}.html", t.name(db).as_str())
         }
diff --git a/src/tools/rust-analyzer/crates/ide/src/file_structure.rs b/src/tools/rust-analyzer/crates/ide/src/file_structure.rs
index ac15af0334fc8..d5c6eaca97448 100644
--- a/src/tools/rust-analyzer/crates/ide/src/file_structure.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/file_structure.rs
@@ -162,7 +162,6 @@ fn structure_node(node: &SyntaxNode, config: &FileStructureConfig) -> Option<Str
             ast::Enum(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Enum)),
             ast::Variant(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Variant)),
             ast::Trait(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Trait)),
-            ast::TraitAlias(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::TraitAlias)),
             ast::Module(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Module)),
             ast::Macro(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Macro)),
             ast::TypeAlias(it) => decl_with_type_ref(&it, it.ty(), StructureNodeKind::SymbolKind(SymbolKind::TypeAlias)),
@@ -553,7 +552,7 @@ fn let_statements() {
                         navigation_range: 251..256,
                         node_range: 245..262,
                         kind: SymbolKind(
-                            TraitAlias,
+                            Trait,
                         ),
                         detail: None,
                         deprecated: false,
diff --git a/src/tools/rust-analyzer/crates/ide/src/folding_ranges.rs b/src/tools/rust-analyzer/crates/ide/src/folding_ranges.rs
index ac64413effebf..3969490e8dcf5 100644
--- a/src/tools/rust-analyzer/crates/ide/src/folding_ranges.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/folding_ranges.rs
@@ -29,7 +29,6 @@ pub enum FoldKind {
     Consts,
     Statics,
     TypeAliases,
-    TraitAliases,
     ExternCrates,
     // endregion: item runs
 }
@@ -147,11 +146,6 @@ pub(crate) fn folding_ranges(file: &SourceFile) -> Vec<Fold> {
                                 res.push(Fold { range, kind: FoldKind::TypeAliases })
                             }
                         },
-                        ast::TraitAlias(alias) => {
-                            if let Some(range) = contiguous_range_for_item_group(alias, &mut visited_nodes) {
-                                res.push(Fold { range, kind: FoldKind::TraitAliases })
-                            }
-                        },
                         ast::ExternCrate(extern_crate) => {
                             if let Some(range) = contiguous_range_for_item_group(extern_crate, &mut visited_nodes) {
                                 res.push(Fold { range, kind: FoldKind::ExternCrates })
@@ -351,7 +345,6 @@ mod tests {
                 FoldKind::ReturnType => "returntype",
                 FoldKind::MatchArm => "matcharm",
                 FoldKind::Function => "function",
-                FoldKind::TraitAliases => "traitaliases",
                 FoldKind::ExternCrates => "externcrates",
             };
             assert_eq!(kind, &attr.unwrap());
diff --git a/src/tools/rust-analyzer/crates/ide/src/hover/render.rs b/src/tools/rust-analyzer/crates/ide/src/hover/render.rs
index 1c0272cdfacd1..e4c7d42ffe3b1 100644
--- a/src/tools/rust-analyzer/crates/ide/src/hover/render.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/hover/render.rs
@@ -401,7 +401,6 @@ fn definition_owner_name(db: &RootDatabase, def: Definition, edition: Edition) -
         Definition::GenericParam(generic_param) => match generic_param.parent() {
             hir::GenericDef::Adt(it) => Some(it.name(db)),
             hir::GenericDef::Trait(it) => Some(it.name(db)),
-            hir::GenericDef::TraitAlias(it) => Some(it.name(db)),
             hir::GenericDef::TypeAlias(it) => Some(it.name(db)),
 
             hir::GenericDef::Impl(i) => i.self_ty(db).as_adt().map(|adt| adt.name(db)),
diff --git a/src/tools/rust-analyzer/crates/ide/src/moniker.rs b/src/tools/rust-analyzer/crates/ide/src/moniker.rs
index 795c1f2ca3c0b..f1aa03c8f2672 100644
--- a/src/tools/rust-analyzer/crates/ide/src/moniker.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/moniker.rs
@@ -209,7 +209,6 @@ pub(crate) fn def_to_kind(db: &RootDatabase, def: Definition) -> SymbolInformati
         Definition::Const(..) => Constant,
         Definition::Static(..) => StaticVariable,
         Definition::Trait(..) => Trait,
-        Definition::TraitAlias(..) => Trait,
         Definition::TypeAlias(it) => {
             if it.as_assoc_item(db).is_some() {
                 AssociatedType
diff --git a/src/tools/rust-analyzer/crates/ide/src/move_item.rs b/src/tools/rust-analyzer/crates/ide/src/move_item.rs
index f3bb3df1cd8d7..b5d47c83a5543 100644
--- a/src/tools/rust-analyzer/crates/ide/src/move_item.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/move_item.rs
@@ -72,7 +72,6 @@ fn find_ancestors(item: SyntaxElement, direction: Direction, range: TextRange) -
         SyntaxKind::MACRO_CALL,
         SyntaxKind::TYPE_ALIAS,
         SyntaxKind::TRAIT,
-        SyntaxKind::TRAIT_ALIAS,
         SyntaxKind::IMPL,
         SyntaxKind::MACRO_DEF,
         SyntaxKind::STRUCT,
diff --git a/src/tools/rust-analyzer/crates/ide/src/navigation_target.rs b/src/tools/rust-analyzer/crates/ide/src/navigation_target.rs
index 7dc18141bdbc1..61b4de0e0e396 100644
--- a/src/tools/rust-analyzer/crates/ide/src/navigation_target.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/navigation_target.rs
@@ -226,9 +226,6 @@ impl TryToNav for FileSymbol {
                         hir::ModuleDef::Trait(it) => {
                             Some(it.display(db, display_target).to_string())
                         }
-                        hir::ModuleDef::TraitAlias(it) => {
-                            Some(it.display(db, display_target).to_string())
-                        }
                         hir::ModuleDef::TypeAlias(it) => {
                             Some(it.display(db, display_target).to_string())
                         }
@@ -261,7 +258,6 @@ impl TryToNav for Definition {
             Definition::Const(it) => it.try_to_nav(db),
             Definition::Static(it) => it.try_to_nav(db),
             Definition::Trait(it) => it.try_to_nav(db),
-            Definition::TraitAlias(it) => it.try_to_nav(db),
             Definition::TypeAlias(it) => it.try_to_nav(db),
             Definition::ExternCrateDecl(it) => it.try_to_nav(db),
             Definition::InlineAsmOperand(it) => it.try_to_nav(db),
@@ -287,7 +283,6 @@ impl TryToNav for hir::ModuleDef {
             hir::ModuleDef::Const(it) => it.try_to_nav(db),
             hir::ModuleDef::Static(it) => it.try_to_nav(db),
             hir::ModuleDef::Trait(it) => it.try_to_nav(db),
-            hir::ModuleDef::TraitAlias(it) => it.try_to_nav(db),
             hir::ModuleDef::TypeAlias(it) => it.try_to_nav(db),
             hir::ModuleDef::Macro(it) => it.try_to_nav(db),
             hir::ModuleDef::BuiltinType(_) => None,
@@ -366,12 +361,6 @@ impl ToNavFromAst for hir::Trait {
         container_name(db, self, self.krate(db).edition(db))
     }
 }
-impl ToNavFromAst for hir::TraitAlias {
-    const KIND: SymbolKind = SymbolKind::TraitAlias;
-    fn container_name(self, db: &RootDatabase) -> Option<SmolStr> {
-        container_name(db, self, self.krate(db).edition(db))
-    }
-}
 
 impl<D> TryToNav for D
 where
diff --git a/src/tools/rust-analyzer/crates/ide/src/references.rs b/src/tools/rust-analyzer/crates/ide/src/references.rs
index 86b88a17c75fc..dc509b3858389 100644
--- a/src/tools/rust-analyzer/crates/ide/src/references.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/references.rs
@@ -1783,7 +1783,7 @@ trait Bar$0 = Foo where Self: ;
 fn foo<T: Bar>(_: impl Bar, _: &dyn Bar) {}
 "#,
             expect![[r#"
-                Bar TraitAlias FileId(0) 13..42 19..22
+                Bar Trait FileId(0) 13..42 19..22
 
                 FileId(0) 53..56
                 FileId(0) 66..69
diff --git a/src/tools/rust-analyzer/crates/ide/src/runnables.rs b/src/tools/rust-analyzer/crates/ide/src/runnables.rs
index 83e5c5ab1dfeb..77c84292cf3e9 100644
--- a/src/tools/rust-analyzer/crates/ide/src/runnables.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/runnables.rs
@@ -493,7 +493,6 @@ fn module_def_doctest(db: &RootDatabase, def: Definition) -> Option<Runnable> {
         Definition::Const(it) => it.attrs(db),
         Definition::Static(it) => it.attrs(db),
         Definition::Trait(it) => it.attrs(db),
-        Definition::TraitAlias(it) => it.attrs(db),
         Definition::TypeAlias(it) => it.attrs(db),
         Definition::Macro(it) => it.attrs(db),
         Definition::SelfType(it) => it.attrs(db),
diff --git a/src/tools/rust-analyzer/crates/ide/src/signature_help.rs b/src/tools/rust-analyzer/crates/ide/src/signature_help.rs
index 2cccb9639f3eb..86d02b4098bd2 100644
--- a/src/tools/rust-analyzer/crates/ide/src/signature_help.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/signature_help.rs
@@ -339,10 +339,6 @@ fn signature_help_for_generics(
             res.doc = it.docs(db);
             format_to!(res.signature, "trait {}", it.name(db).display(db, edition));
         }
-        hir::GenericDef::TraitAlias(it) => {
-            res.doc = it.docs(db);
-            format_to!(res.signature, "trait {}", it.name(db).display(db, edition));
-        }
         hir::GenericDef::TypeAlias(it) => {
             res.doc = it.docs(db);
             format_to!(res.signature, "type {}", it.name(db).display(db, edition));
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/highlight.rs b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/highlight.rs
index 8bde8fd970063..d73575fb9549a 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/highlight.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/highlight.rs
@@ -576,7 +576,6 @@ pub(super) fn highlight_def(
             h
         }
         Definition::Trait(_) => Highlight::new(HlTag::Symbol(SymbolKind::Trait)),
-        Definition::TraitAlias(_) => Highlight::new(HlTag::Symbol(SymbolKind::TraitAlias)),
         Definition::TypeAlias(type_) => {
             let mut h = Highlight::new(HlTag::Symbol(SymbolKind::TypeAlias));
 
@@ -780,7 +779,6 @@ fn highlight_name_by_syntax(name: ast::Name) -> Highlight {
         MACRO_RULES => SymbolKind::Macro,
         CONST_PARAM => SymbolKind::ConstParam,
         SELF_PARAM => SymbolKind::SelfParam,
-        TRAIT_ALIAS => SymbolKind::TraitAlias,
         ASM_OPERAND_NAMED => SymbolKind::Local,
         _ => return default.into(),
     };
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/inject.rs b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/inject.rs
index 7f5c2c1ec849b..fb33307249a77 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/inject.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/inject.rs
@@ -311,7 +311,6 @@ fn module_def_to_hl_tag(def: Definition) -> HlTag {
         Definition::Const(_) => SymbolKind::Const,
         Definition::Static(_) => SymbolKind::Static,
         Definition::Trait(_) => SymbolKind::Trait,
-        Definition::TraitAlias(_) => SymbolKind::TraitAlias,
         Definition::TypeAlias(_) => SymbolKind::TypeAlias,
         Definition::BuiltinLifetime(_) => SymbolKind::LifetimeParam,
         Definition::BuiltinType(_) => return HlTag::BuiltinType,
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/tags.rs b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/tags.rs
index 3b5d1af0ac72a..4b8762640c743 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/tags.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/tags.rs
@@ -160,7 +160,6 @@ impl HlTag {
                 SymbolKind::Struct => "struct",
                 SymbolKind::ToolModule => "tool_module",
                 SymbolKind::Trait => "trait",
-                SymbolKind::TraitAlias => "trait_alias",
                 SymbolKind::TypeAlias => "type_alias",
                 SymbolKind::TypeParam => "type_param",
                 SymbolKind::Union => "union",
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
index f7d798208037e..47ee2ad1c0d70 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
@@ -78,8 +78,8 @@
 <span class="brace">}</span>
 
 <span class="keyword">use</span> <span class="unresolved_reference">foo</span><span class="operator">::</span><span class="unresolved_reference">bar</span> <span class="keyword">as</span> <span class="variable declaration">baz</span><span class="semicolon">;</span>
-<span class="keyword">trait</span> <span class="trait_alias declaration">Bar</span> <span class="operator">=</span> <span class="unresolved_reference">Baz</span><span class="semicolon">;</span>
-<span class="keyword">trait</span> <span class="trait_alias declaration">Foo</span> <span class="operator">=</span> <span class="trait_alias">Bar</span><span class="semicolon">;</span>
+<span class="keyword">trait</span> <span class="trait declaration">Bar</span> <span class="operator">=</span> <span class="unresolved_reference">Baz</span><span class="semicolon">;</span>
+<span class="keyword">trait</span> <span class="trait declaration">Foo</span> <span class="operator">=</span> <span class="trait">Bar</span><span class="semicolon">;</span>
 
 <span class="keyword">fn</span> <span class="function declaration">main</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
     <span class="keyword">let</span> <span class="variable declaration">a</span> <span class="operator">=</span> <span class="char_literal">'</span><span class="escape_sequence">\n</span><span class="char_literal">'</span><span class="semicolon">;</span>
diff --git a/src/tools/rust-analyzer/crates/parser/src/grammar/items/traits.rs b/src/tools/rust-analyzer/crates/parser/src/grammar/items/traits.rs
index 47f86ce8c6cc4..c1b1a3fc8a94a 100644
--- a/src/tools/rust-analyzer/crates/parser/src/grammar/items/traits.rs
+++ b/src/tools/rust-analyzer/crates/parser/src/grammar/items/traits.rs
@@ -20,7 +20,7 @@ pub(super) fn trait_(p: &mut Parser<'_>, m: Marker) {
         // trait Z<U> = where Self: T<U>;
         generic_params::opt_where_clause(p);
         p.expect(T![;]);
-        m.complete(p, TRAIT_ALIAS);
+        m.complete(p, TRAIT);
         return;
     }
 
diff --git a/src/tools/rust-analyzer/crates/parser/src/syntax_kind/generated.rs b/src/tools/rust-analyzer/crates/parser/src/syntax_kind/generated.rs
index 3a8041d2df9ee..93e02a92abdad 100644
--- a/src/tools/rust-analyzer/crates/parser/src/syntax_kind/generated.rs
+++ b/src/tools/rust-analyzer/crates/parser/src/syntax_kind/generated.rs
@@ -284,7 +284,6 @@ pub enum SyntaxKind {
     STRUCT,
     TOKEN_TREE,
     TRAIT,
-    TRAIT_ALIAS,
     TRY_EXPR,
     TUPLE_EXPR,
     TUPLE_FIELD,
@@ -457,7 +456,6 @@ impl SyntaxKind {
             | STRUCT
             | TOKEN_TREE
             | TRAIT
-            | TRAIT_ALIAS
             | TRY_EXPR
             | TUPLE_EXPR
             | TUPLE_FIELD
diff --git a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/trait_alias.rast b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/trait_alias.rast
index c45f870898007..2ef66484ae48f 100644
--- a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/trait_alias.rast
+++ b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/trait_alias.rast
@@ -1,5 +1,5 @@
 SOURCE_FILE
-  TRAIT_ALIAS
+  TRAIT
     TRAIT_KW "trait"
     WHITESPACE " "
     NAME
diff --git a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/trait_alias_where_clause.rast b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/trait_alias_where_clause.rast
index 8f678247731dc..4443d9d142630 100644
--- a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/trait_alias_where_clause.rast
+++ b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/trait_alias_where_clause.rast
@@ -1,5 +1,5 @@
 SOURCE_FILE
-  TRAIT_ALIAS
+  TRAIT
     TRAIT_KW "trait"
     WHITESPACE " "
     NAME
@@ -50,7 +50,7 @@ SOURCE_FILE
                     IDENT "Copy"
     SEMICOLON ";"
   WHITESPACE "\n"
-  TRAIT_ALIAS
+  TRAIT
     TRAIT_KW "trait"
     WHITESPACE " "
     NAME
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/lsp/to_proto.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/lsp/to_proto.rs
index 292be1d5315de..d51ddb86d197f 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/lsp/to_proto.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/lsp/to_proto.rs
@@ -61,7 +61,7 @@ pub(crate) fn symbol_kind(symbol_kind: SymbolKind) -> lsp_types::SymbolKind {
         SymbolKind::Struct => lsp_types::SymbolKind::STRUCT,
         SymbolKind::Enum => lsp_types::SymbolKind::ENUM,
         SymbolKind::Variant => lsp_types::SymbolKind::ENUM_MEMBER,
-        SymbolKind::Trait | SymbolKind::TraitAlias => lsp_types::SymbolKind::INTERFACE,
+        SymbolKind::Trait => lsp_types::SymbolKind::INTERFACE,
         SymbolKind::Macro
         | SymbolKind::ProcMacro
         | SymbolKind::BuiltinAttr
@@ -156,7 +156,6 @@ pub(crate) fn completion_item_kind(
             SymbolKind::Static => lsp_types::CompletionItemKind::VALUE,
             SymbolKind::Struct => lsp_types::CompletionItemKind::STRUCT,
             SymbolKind::Trait => lsp_types::CompletionItemKind::INTERFACE,
-            SymbolKind::TraitAlias => lsp_types::CompletionItemKind::INTERFACE,
             SymbolKind::TypeAlias => lsp_types::CompletionItemKind::STRUCT,
             SymbolKind::TypeParam => lsp_types::CompletionItemKind::TYPE_PARAMETER,
             SymbolKind::Union => lsp_types::CompletionItemKind::STRUCT,
@@ -817,7 +816,6 @@ fn semantic_token_type_and_modifiers(
             SymbolKind::Union => types::UNION,
             SymbolKind::TypeAlias => types::TYPE_ALIAS,
             SymbolKind::Trait => types::INTERFACE,
-            SymbolKind::TraitAlias => types::INTERFACE,
             SymbolKind::Macro => types::MACRO,
             SymbolKind::ProcMacro => types::PROC_MACRO,
             SymbolKind::BuiltinAttr => types::BUILTIN_ATTRIBUTE,
@@ -909,7 +907,6 @@ pub(crate) fn folding_range(
         | FoldKind::WhereClause
         | FoldKind::ReturnType
         | FoldKind::Array
-        | FoldKind::TraitAliases
         | FoldKind::ExternCrates
         | FoldKind::MatchArm
         | FoldKind::Function => None,
diff --git a/src/tools/rust-analyzer/crates/span/src/ast_id.rs b/src/tools/rust-analyzer/crates/span/src/ast_id.rs
index a9288ecd6fa1f..e803747998b54 100644
--- a/src/tools/rust-analyzer/crates/span/src/ast_id.rs
+++ b/src/tools/rust-analyzer/crates/span/src/ast_id.rs
@@ -485,8 +485,7 @@ register_has_name_ast_id! {
         MacroRules = name,
         Module = name,
         Static = name,
-        Trait = name,
-        TraitAlias = name
+        Trait = name
 }
 
 macro_rules! register_assoc_item_ast_id {
diff --git a/src/tools/rust-analyzer/crates/syntax/rust.ungram b/src/tools/rust-analyzer/crates/syntax/rust.ungram
index 6d8a360d715b7..d73d60c51f0c8 100644
--- a/src/tools/rust-analyzer/crates/syntax/rust.ungram
+++ b/src/tools/rust-analyzer/crates/syntax/rust.ungram
@@ -154,7 +154,6 @@ Item =
 | Static
 | Struct
 | Trait
-| TraitAlias
 | TypeAlias
 | Union
 | Use
@@ -306,11 +305,8 @@ Trait =
   Attr* Visibility?
   'unsafe'? 'auto'?
   'trait' Name GenericParamList?
-  (':' TypeBoundList?)? WhereClause? AssocItemList
-
-TraitAlias =
-  Attr* Visibility?
-  'trait' Name GenericParamList? '=' TypeBoundList? WhereClause? ';'
+  (((':' TypeBoundList?)? WhereClause? AssocItemList) |
+  ('=' TypeBoundList? WhereClause? ';'))
 
 AssocItemList =
   '{' Attr* AssocItem* '}'
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast.rs b/src/tools/rust-analyzer/crates/syntax/src/ast.rs
index a9aeeedb6542e..19c1c5ebea333 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast.rs
@@ -26,8 +26,7 @@ pub use self::{
     generated::{nodes::*, tokens::*},
     node_ext::{
         AttrKind, FieldKind, Macro, NameLike, NameOrNameRef, PathSegmentKind, SelfParamKind,
-        SlicePatComponents, StructKind, TraitOrAlias, TypeBoundKind, TypeOrConstParam,
-        VisibilityKind,
+        SlicePatComponents, StructKind, TypeBoundKind, TypeOrConstParam, VisibilityKind,
     },
     operators::{ArithOp, BinaryOp, CmpOp, LogicOp, Ordering, RangeOp, UnaryOp},
     token_ext::{CommentKind, CommentPlacement, CommentShape, IsString, QuoteOffsets, Radix},
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs
index 160f000387b3d..1cd8146f68630 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs
@@ -99,38 +99,10 @@ impl GenericParamsOwnerEdit for ast::Trait {
 
     fn get_or_create_where_clause(&self) -> ast::WhereClause {
         if self.where_clause().is_none() {
-            let position = match self.assoc_item_list() {
-                Some(items) => Position::before(items.syntax()),
-                None => Position::last_child_of(self.syntax()),
-            };
-            create_where_clause(position);
-        }
-        self.where_clause().unwrap()
-    }
-}
-
-impl GenericParamsOwnerEdit for ast::TraitAlias {
-    fn get_or_create_generic_param_list(&self) -> ast::GenericParamList {
-        match self.generic_param_list() {
-            Some(it) => it,
-            None => {
-                let position = if let Some(name) = self.name() {
-                    Position::after(name.syntax)
-                } else if let Some(trait_token) = self.trait_token() {
-                    Position::after(trait_token)
-                } else {
-                    Position::last_child_of(self.syntax())
-                };
-                create_generic_param_list(position)
-            }
-        }
-    }
-
-    fn get_or_create_where_clause(&self) -> ast::WhereClause {
-        if self.where_clause().is_none() {
-            let position = match self.semicolon_token() {
-                Some(tok) => Position::before(tok),
-                None => Position::last_child_of(self.syntax()),
+            let position = match (self.assoc_item_list(), self.semicolon_token()) {
+                (Some(items), _) => Position::before(items.syntax()),
+                (_, Some(tok)) => Position::before(tok),
+                (None, None) => Position::last_child_of(self.syntax()),
             };
             create_where_clause(position);
         }
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/generated/nodes.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/generated/nodes.rs
index ceb2866ebcdf7..d60196d492fc3 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/generated/nodes.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/generated/nodes.rs
@@ -1614,29 +1614,15 @@ impl Trait {
     #[inline]
     pub fn assoc_item_list(&self) -> Option<AssocItemList> { support::child(&self.syntax) }
     #[inline]
-    pub fn auto_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![auto]) }
-    #[inline]
-    pub fn trait_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![trait]) }
-    #[inline]
-    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
-}
-pub struct TraitAlias {
-    pub(crate) syntax: SyntaxNode,
-}
-impl ast::HasAttrs for TraitAlias {}
-impl ast::HasDocComments for TraitAlias {}
-impl ast::HasGenericParams for TraitAlias {}
-impl ast::HasName for TraitAlias {}
-impl ast::HasVisibility for TraitAlias {}
-impl TraitAlias {
-    #[inline]
-    pub fn type_bound_list(&self) -> Option<TypeBoundList> { support::child(&self.syntax) }
-    #[inline]
     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
     #[inline]
     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
     #[inline]
+    pub fn auto_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![auto]) }
+    #[inline]
     pub fn trait_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![trait]) }
+    #[inline]
+    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
 }
 pub struct TryExpr {
     pub(crate) syntax: SyntaxNode,
@@ -2107,7 +2093,6 @@ pub enum Item {
     Static(Static),
     Struct(Struct),
     Trait(Trait),
-    TraitAlias(TraitAlias),
     TypeAlias(TypeAlias),
     Union(Union),
     Use(Use),
@@ -6801,42 +6786,6 @@ impl fmt::Debug for Trait {
         f.debug_struct("Trait").field("syntax", &self.syntax).finish()
     }
 }
-impl AstNode for TraitAlias {
-    #[inline]
-    fn kind() -> SyntaxKind
-    where
-        Self: Sized,
-    {
-        TRAIT_ALIAS
-    }
-    #[inline]
-    fn can_cast(kind: SyntaxKind) -> bool { kind == TRAIT_ALIAS }
-    #[inline]
-    fn cast(syntax: SyntaxNode) -> Option<Self> {
-        if Self::can_cast(syntax.kind()) {
-            Some(Self { syntax })
-        } else {
-            None
-        }
-    }
-    #[inline]
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-impl hash::Hash for TraitAlias {
-    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
-}
-impl Eq for TraitAlias {}
-impl PartialEq for TraitAlias {
-    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
-}
-impl Clone for TraitAlias {
-    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
-}
-impl fmt::Debug for TraitAlias {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("TraitAlias").field("syntax", &self.syntax).finish()
-    }
-}
 impl AstNode for TryExpr {
     #[inline]
     fn kind() -> SyntaxKind
@@ -8471,10 +8420,6 @@ impl From<Trait> for Item {
     #[inline]
     fn from(node: Trait) -> Item { Item::Trait(node) }
 }
-impl From<TraitAlias> for Item {
-    #[inline]
-    fn from(node: TraitAlias) -> Item { Item::TraitAlias(node) }
-}
 impl From<TypeAlias> for Item {
     #[inline]
     fn from(node: TypeAlias) -> Item { Item::TypeAlias(node) }
@@ -8506,7 +8451,6 @@ impl AstNode for Item {
                 | STATIC
                 | STRUCT
                 | TRAIT
-                | TRAIT_ALIAS
                 | TYPE_ALIAS
                 | UNION
                 | USE
@@ -8529,7 +8473,6 @@ impl AstNode for Item {
             STATIC => Item::Static(Static { syntax }),
             STRUCT => Item::Struct(Struct { syntax }),
             TRAIT => Item::Trait(Trait { syntax }),
-            TRAIT_ALIAS => Item::TraitAlias(TraitAlias { syntax }),
             TYPE_ALIAS => Item::TypeAlias(TypeAlias { syntax }),
             UNION => Item::Union(Union { syntax }),
             USE => Item::Use(Use { syntax }),
@@ -8554,7 +8497,6 @@ impl AstNode for Item {
             Item::Static(it) => &it.syntax,
             Item::Struct(it) => &it.syntax,
             Item::Trait(it) => &it.syntax,
-            Item::TraitAlias(it) => &it.syntax,
             Item::TypeAlias(it) => &it.syntax,
             Item::Union(it) => &it.syntax,
             Item::Use(it) => &it.syntax,
@@ -8984,7 +8926,6 @@ impl AstNode for AnyHasAttrs {
                 | STMT_LIST
                 | STRUCT
                 | TRAIT
-                | TRAIT_ALIAS
                 | TRY_EXPR
                 | TUPLE_EXPR
                 | TUPLE_FIELD
@@ -9257,10 +9198,6 @@ impl From<Trait> for AnyHasAttrs {
     #[inline]
     fn from(node: Trait) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
 }
-impl From<TraitAlias> for AnyHasAttrs {
-    #[inline]
-    fn from(node: TraitAlias) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
-}
 impl From<TryExpr> for AnyHasAttrs {
     #[inline]
     fn from(node: TryExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
@@ -9330,7 +9267,6 @@ impl AstNode for AnyHasDocComments {
                 | STATIC
                 | STRUCT
                 | TRAIT
-                | TRAIT_ALIAS
                 | TUPLE_FIELD
                 | TYPE_ALIAS
                 | UNION
@@ -9420,10 +9356,6 @@ impl From<Trait> for AnyHasDocComments {
     #[inline]
     fn from(node: Trait) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
 }
-impl From<TraitAlias> for AnyHasDocComments {
-    #[inline]
-    fn from(node: TraitAlias) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
-}
 impl From<TupleField> for AnyHasDocComments {
     #[inline]
     fn from(node: TupleField) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
@@ -9488,7 +9420,7 @@ impl ast::HasGenericParams for AnyHasGenericParams {}
 impl AstNode for AnyHasGenericParams {
     #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
-        matches!(kind, CONST | ENUM | FN | IMPL | STRUCT | TRAIT | TRAIT_ALIAS | TYPE_ALIAS | UNION)
+        matches!(kind, CONST | ENUM | FN | IMPL | STRUCT | TRAIT | TYPE_ALIAS | UNION)
     }
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -9536,10 +9468,6 @@ impl From<Trait> for AnyHasGenericParams {
     #[inline]
     fn from(node: Trait) -> AnyHasGenericParams { AnyHasGenericParams { syntax: node.syntax } }
 }
-impl From<TraitAlias> for AnyHasGenericParams {
-    #[inline]
-    fn from(node: TraitAlias) -> AnyHasGenericParams { AnyHasGenericParams { syntax: node.syntax } }
-}
 impl From<TypeAlias> for AnyHasGenericParams {
     #[inline]
     fn from(node: TypeAlias) -> AnyHasGenericParams { AnyHasGenericParams { syntax: node.syntax } }
@@ -9646,7 +9574,6 @@ impl AstNode for AnyHasName {
                 | STATIC
                 | STRUCT
                 | TRAIT
-                | TRAIT_ALIAS
                 | TYPE_ALIAS
                 | TYPE_PARAM
                 | UNION
@@ -9739,10 +9666,6 @@ impl From<Trait> for AnyHasName {
     #[inline]
     fn from(node: Trait) -> AnyHasName { AnyHasName { syntax: node.syntax } }
 }
-impl From<TraitAlias> for AnyHasName {
-    #[inline]
-    fn from(node: TraitAlias) -> AnyHasName { AnyHasName { syntax: node.syntax } }
-}
 impl From<TypeAlias> for AnyHasName {
     #[inline]
     fn from(node: TypeAlias) -> AnyHasName { AnyHasName { syntax: node.syntax } }
@@ -9832,7 +9755,6 @@ impl AstNode for AnyHasVisibility {
                 | STATIC
                 | STRUCT
                 | TRAIT
-                | TRAIT_ALIAS
                 | TUPLE_FIELD
                 | TYPE_ALIAS
                 | UNION
@@ -9910,10 +9832,6 @@ impl From<Trait> for AnyHasVisibility {
     #[inline]
     fn from(node: Trait) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
 }
-impl From<TraitAlias> for AnyHasVisibility {
-    #[inline]
-    fn from(node: TraitAlias) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
-}
 impl From<TupleField> for AnyHasVisibility {
     #[inline]
     fn from(node: TupleField) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
@@ -10639,11 +10557,6 @@ impl std::fmt::Display for Trait {
         std::fmt::Display::fmt(self.syntax(), f)
     }
 }
-impl std::fmt::Display for TraitAlias {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        std::fmt::Display::fmt(self.syntax(), f)
-    }
-}
 impl std::fmt::Display for TryExpr {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self.syntax(), f)
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/node_ext.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/node_ext.rs
index 62a7d4df2cf6b..42b0f5cf2da1c 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/node_ext.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/node_ext.rs
@@ -880,51 +880,6 @@ impl AstNode for TypeOrConstParam {
 
 impl HasAttrs for TypeOrConstParam {}
 
-#[derive(Debug, Clone)]
-pub enum TraitOrAlias {
-    Trait(ast::Trait),
-    TraitAlias(ast::TraitAlias),
-}
-
-impl TraitOrAlias {
-    pub fn name(&self) -> Option<ast::Name> {
-        match self {
-            TraitOrAlias::Trait(x) => x.name(),
-            TraitOrAlias::TraitAlias(x) => x.name(),
-        }
-    }
-}
-
-impl AstNode for TraitOrAlias {
-    fn can_cast(kind: SyntaxKind) -> bool
-    where
-        Self: Sized,
-    {
-        matches!(kind, SyntaxKind::TRAIT | SyntaxKind::TRAIT_ALIAS)
-    }
-
-    fn cast(syntax: SyntaxNode) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        let res = match syntax.kind() {
-            SyntaxKind::TRAIT => TraitOrAlias::Trait(ast::Trait { syntax }),
-            SyntaxKind::TRAIT_ALIAS => TraitOrAlias::TraitAlias(ast::TraitAlias { syntax }),
-            _ => return None,
-        };
-        Some(res)
-    }
-
-    fn syntax(&self) -> &SyntaxNode {
-        match self {
-            TraitOrAlias::Trait(it) => it.syntax(),
-            TraitOrAlias::TraitAlias(it) => it.syntax(),
-        }
-    }
-}
-
-impl HasAttrs for TraitOrAlias {}
-
 pub enum VisibilityKind {
     In(ast::Path),
     PubCrate,
diff --git a/src/tools/rust-analyzer/xtask/src/codegen/grammar.rs b/src/tools/rust-analyzer/xtask/src/codegen/grammar.rs
index 824b38fc872d8..9bd87a7ef5fe0 100644
--- a/src/tools/rust-analyzer/xtask/src/codegen/grammar.rs
+++ b/src/tools/rust-analyzer/xtask/src/codegen/grammar.rs
@@ -1081,7 +1081,6 @@ fn extract_struct_traits(ast: &mut AstSrc) {
         "Enum",
         "Variant",
         "Trait",
-        "TraitAlias",
         "Module",
         "Static",
         "Const",

From 0d2f8aff1be821907a824e5bad705c9385570fdc Mon Sep 17 00:00:00 2001
From: Deadbeef <ent3rm4n@gmail.com>
Date: Mon, 4 Aug 2025 16:11:59 +0800
Subject: [PATCH 0066/1889] add test for trait alias projections

---
 .../crates/hir-ty/src/tests/trait_aliases.rs  | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/tests/trait_aliases.rs

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/trait_aliases.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/trait_aliases.rs
new file mode 100644
index 0000000000000..302ce550b8534
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/trait_aliases.rs
@@ -0,0 +1,21 @@
+use crate::tests::check_types;
+
+#[test]
+fn projection() {
+    check_types(
+        r#"
+#![feature(trait_alias)]
+
+pub trait A {
+    type Output;
+}
+
+pub trait B = A<Output = u32>;
+
+pub fn a<T: B>(x: T::Output) {
+    x;
+//  ^ u32
+}
+"#,
+    );
+}

From b416845683e0892075352dd55889c625aef0e55c Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukas@zed.dev>
Date: Wed, 13 Aug 2025 09:18:50 +0200
Subject: [PATCH 0067/1889] Print fields of interned IDs in hir-ty instead of
 just the ID

---
 .../rust-analyzer/crates/hir-ty/src/db.rs     | 46 ++++++++++---------
 1 file changed, 25 insertions(+), 21 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
index 18b8db21161fd..6e24aea76d445 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
@@ -3,7 +3,7 @@
 
 use std::sync;
 
-use base_db::{Crate, impl_intern_key};
+use base_db::Crate;
 use hir_def::{
     AdtId, BlockId, CallableDefId, ConstParamId, DefWithBodyId, EnumVariantId, FunctionId,
     GeneralConstId, GenericDefId, ImplId, LifetimeParamId, LocalFieldId, StaticId, TraitId,
@@ -459,40 +459,44 @@ fn hir_database_is_dyn_compatible() {
     fn _assert_dyn_compatible(_: &dyn HirDatabase) {}
 }
 
-#[salsa_macros::interned(no_lifetime, revisions = usize::MAX)]
+#[salsa_macros::interned(no_lifetime, debug, revisions = usize::MAX)]
 #[derive(PartialOrd, Ord)]
 pub struct InternedTypeOrConstParamId {
     pub loc: TypeOrConstParamId,
 }
-impl ::std::fmt::Debug for InternedTypeOrConstParamId {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        f.debug_tuple(stringify!(InternedTypeOrConstParamId))
-            .field(&format_args!("{:04x}", self.0.index()))
-            .finish()
-    }
-}
 
-#[salsa_macros::interned(no_lifetime, revisions = usize::MAX)]
+#[salsa_macros::interned(no_lifetime, debug, revisions = usize::MAX)]
 #[derive(PartialOrd, Ord)]
 pub struct InternedLifetimeParamId {
     pub loc: LifetimeParamId,
 }
-impl ::std::fmt::Debug for InternedLifetimeParamId {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        f.debug_tuple(stringify!(InternedLifetimeParamId))
-            .field(&format_args!("{:04x}", self.0.index()))
-            .finish()
-    }
-}
 
-impl_intern_key!(InternedConstParamId, ConstParamId);
+#[salsa_macros::interned(no_lifetime, debug, revisions = usize::MAX)]
+#[derive(PartialOrd, Ord)]
+pub struct InternedConstParamId {
+    pub loc: ConstParamId,
+}
 
-impl_intern_key!(InternedOpaqueTyId, ImplTraitId);
+#[salsa_macros::interned(no_lifetime, debug, revisions = usize::MAX)]
+#[derive(PartialOrd, Ord)]
+pub struct InternedOpaqueTyId {
+    pub loc: ImplTraitId,
+}
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct InternedClosure(pub DefWithBodyId, pub ExprId);
-impl_intern_key!(InternedClosureId, InternedClosure);
+
+#[salsa_macros::interned(no_lifetime, debug, revisions = usize::MAX)]
+#[derive(PartialOrd, Ord)]
+pub struct InternedClosureId {
+    pub loc: InternedClosure,
+}
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct InternedCoroutine(pub DefWithBodyId, pub ExprId);
-impl_intern_key!(InternedCoroutineId, InternedCoroutine);
+
+#[salsa_macros::interned(no_lifetime, debug, revisions = usize::MAX)]
+#[derive(PartialOrd, Ord)]
+pub struct InternedCoroutineId {
+    pub loc: InternedCoroutine,
+}

From 2a509717b4ddc1a8d73575583c8487956804121a Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukas@zed.dev>
Date: Wed, 13 Aug 2025 09:18:50 +0200
Subject: [PATCH 0068/1889] Fix metrics checking out repos into toplevel folder
 instead of `target`

---
 src/tools/rust-analyzer/xtask/src/metrics.rs | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/src/tools/rust-analyzer/xtask/src/metrics.rs b/src/tools/rust-analyzer/xtask/src/metrics.rs
index 6ff6a1b15310a..c9eea87106060 100644
--- a/src/tools/rust-analyzer/xtask/src/metrics.rs
+++ b/src/tools/rust-analyzer/xtask/src/metrics.rs
@@ -16,13 +16,16 @@ type Unit = String;
 impl flags::Metrics {
     pub(crate) fn run(self, sh: &Shell) -> anyhow::Result<()> {
         let mut metrics = Metrics::new(sh)?;
-        if !Path::new("./target/rustc-perf").exists() {
-            sh.create_dir("./target/rustc-perf")?;
-            cmd!(sh, "git clone https://github.com/rust-lang/rustc-perf.git ./target/rustc-perf")
-                .run()?;
+        if !Path::new("./target/metrics/rustc-perf").exists() {
+            sh.create_dir("./target/metrics/rustc-perf")?;
+            cmd!(
+                sh,
+                "git clone https://github.com/rust-lang/rustc-perf.git ./target/metrics/rustc-perf"
+            )
+            .run()?;
         }
         {
-            let _d = sh.push_dir("./target/rustc-perf");
+            let _d = sh.push_dir("./target/metrics/rustc-perf");
             let revision = &metrics.perf_revision;
             cmd!(sh, "git reset --hard {revision}").run()?;
         }
@@ -88,11 +91,12 @@ impl Metrics {
 
         cmd!(
             sh,
-            "git clone --depth=1 --branch 1.76.0 https://github.com/rust-lang/rust.git --single-branch"
+            "git clone --depth=1 --branch 1.76.0 https://github.com/rust-lang/rust.git --single-branch ./target/metrics/rust"
         )
         .run()?;
 
-        let output = cmd!(sh, "./target/release/rust-analyzer rustc-tests ./rust").read()?;
+        let output =
+            cmd!(sh, "./target/release/rust-analyzer rustc-tests ./target/metrics/rust").read()?;
         for (metric, value, unit) in parse_metrics(&output) {
             self.report(metric, value, unit.into());
         }
@@ -106,7 +110,7 @@ impl Metrics {
         self.measure_analysis_stats_path(
             sh,
             bench,
-            &format!("./target/rustc-perf/collector/compile-benchmarks/{bench}"),
+            &format!("./target/metrics/rustc-perf/collector/compile-benchmarks/{bench}"),
         )
     }
     fn measure_analysis_stats_path(

From b62116bda772584e90591bbc6ebf3880a22b0080 Mon Sep 17 00:00:00 2001
From: Deadbeef <ent3rm4n@gmail.com>
Date: Wed, 13 Aug 2025 15:33:08 +0800
Subject: [PATCH 0069/1889] fix errors after rebase

---
 src/tools/rust-analyzer/crates/hir-def/src/signatures.rs  | 4 ++++
 .../crates/hir-ty/src/lower_nextsolver/path.rs            | 7 +------
 .../rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs | 6 +-----
 .../crates/hir-ty/src/next_solver/interner.rs             | 8 ++++++--
 src/tools/rust-analyzer/crates/ide/src/file_structure.rs  | 2 +-
 5 files changed, 13 insertions(+), 14 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs b/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
index 906c1c0e9ff14..bf72fafeae724 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
@@ -402,6 +402,7 @@ bitflags::bitflags! {
         const SKIP_BOXED_SLICE_DURING_METHOD_DISPATCH = 1 << 6;
         const RUSTC_PAREN_SUGAR = 1 << 7;
         const COINDUCTIVE = 1 << 8;
+        const ALIAS = 1 << 9;
     }
 }
 
@@ -426,6 +427,9 @@ impl TraitSignature {
         if source.value.unsafe_token().is_some() {
             flags.insert(TraitFlags::UNSAFE);
         }
+        if source.value.eq_token().is_some() {
+            flags.insert(TraitFlags::ALIAS);
+        }
         if attrs.by_key(sym::fundamental).exists() {
             flags |= TraitFlags::FUNDAMENTAL;
         }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver/path.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver/path.rs
index b95bb1130fa20..df67b2c59b512 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver/path.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver/path.rs
@@ -260,10 +260,6 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
                 };
                 return (ty, None);
             }
-            TypeNs::TraitAliasId(_) => {
-                // FIXME(trait_alias): Implement trait alias.
-                return (Ty::new_error(self.ctx.interner, ErrorGuaranteed), None);
-            }
             TypeNs::GenericParam(param_id) => {
                 let generics = self.ctx.generics();
                 let idx = generics.type_or_const_param_idx(param_id.into());
@@ -343,8 +339,7 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
             TypeNs::AdtId(_)
             | TypeNs::EnumVariantId(_)
             | TypeNs::TypeAliasId(_)
-            | TypeNs::TraitId(_)
-            | TypeNs::TraitAliasId(_) => {}
+            | TypeNs::TraitId(_) => {}
         }
     }
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
index cfbc10e740e4b..64eab2d6b8185 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
@@ -2,7 +2,7 @@
 
 use hir_def::{
     AdtId, ConstId, EnumId, EnumVariantId, FunctionId, GenericDefId, ImplId, StaticId, StructId,
-    TraitAliasId, TraitId, TypeAliasId, UnionId,
+    TraitId, TypeAliasId, UnionId,
 };
 use rustc_type_ir::inherent;
 use stdx::impl_from;
@@ -24,7 +24,6 @@ pub enum SolverDefId {
     FunctionId(FunctionId),
     ImplId(ImplId),
     StaticId(StaticId),
-    TraitAliasId(TraitAliasId),
     TraitId(TraitId),
     TypeAliasId(TypeAliasId),
     ForeignId(TypeAliasId),
@@ -40,7 +39,6 @@ impl_from!(
     FunctionId,
     ImplId,
     StaticId,
-    TraitAliasId,
     TraitId,
     TypeAliasId,
     InternedClosureId,
@@ -57,7 +55,6 @@ impl From<GenericDefId> for SolverDefId {
             GenericDefId::FunctionId(function_id) => SolverDefId::FunctionId(function_id),
             GenericDefId::ImplId(impl_id) => SolverDefId::ImplId(impl_id),
             GenericDefId::StaticId(static_id) => SolverDefId::StaticId(static_id),
-            GenericDefId::TraitAliasId(trait_alias_id) => SolverDefId::TraitAliasId(trait_alias_id),
             GenericDefId::TraitId(trait_id) => SolverDefId::TraitId(trait_id),
             GenericDefId::TypeAliasId(type_alias_id) => SolverDefId::TypeAliasId(type_alias_id),
         }
@@ -74,7 +71,6 @@ impl TryFrom<SolverDefId> for GenericDefId {
             SolverDefId::FunctionId(function_id) => GenericDefId::FunctionId(function_id),
             SolverDefId::ImplId(impl_id) => GenericDefId::ImplId(impl_id),
             SolverDefId::StaticId(static_id) => GenericDefId::StaticId(static_id),
-            SolverDefId::TraitAliasId(trait_alias_id) => GenericDefId::TraitAliasId(trait_alias_id),
             SolverDefId::TraitId(trait_id) => GenericDefId::TraitId(trait_id),
             SolverDefId::TypeAliasId(type_alias_id) => GenericDefId::TypeAliasId(type_alias_id),
             SolverDefId::ForeignId(_) => return Err(value),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
index 9c1bd52065fd2..17a4e7290c2cc 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
@@ -1172,7 +1172,6 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
             | SolverDefId::AdtId(_)
             | SolverDefId::TraitId(_)
             | SolverDefId::ImplId(_)
-            | SolverDefId::TraitAliasId(_)
             | SolverDefId::Ctor(..)
             | SolverDefId::InternedOpaqueTyId(..) => panic!(),
         };
@@ -1790,7 +1789,12 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
     }
 
     fn trait_is_alias(self, trait_def_id: Self::DefId) -> bool {
-        matches!(trait_def_id, SolverDefId::TraitAliasId(_))
+        let trait_ = match trait_def_id {
+            SolverDefId::TraitId(id) => id,
+            _ => panic!("Unexpected SolverDefId in trait_is_alias"),
+        };
+        let trait_data = self.db().trait_signature(trait_);
+        trait_data.flags.contains(TraitFlags::ALIAS)
     }
 
     fn trait_is_dyn_compatible(self, trait_def_id: Self::DefId) -> bool {
diff --git a/src/tools/rust-analyzer/crates/ide/src/file_structure.rs b/src/tools/rust-analyzer/crates/ide/src/file_structure.rs
index d5c6eaca97448..21254fc4d6a22 100644
--- a/src/tools/rust-analyzer/crates/ide/src/file_structure.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/file_structure.rs
@@ -943,7 +943,7 @@ fn let_statements() {
                         navigation_range: 251..256,
                         node_range: 245..262,
                         kind: SymbolKind(
-                            TraitAlias,
+                            Trait,
                         ),
                         detail: None,
                         deprecated: false,

From 4bbbe6ee2b0c3c630d605c47ba0d4215d2522240 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukas@zed.dev>
Date: Wed, 13 Aug 2025 09:42:32 +0200
Subject: [PATCH 0070/1889] fix: Attach db for inlay hint compute

---
 .../crates/hir-ty/src/next_solver/interner.rs  |  2 +-
 .../crates/ide/src/inlay_hints.rs              | 18 ++++++++++--------
 2 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
index 9c1bd52065fd2..54fec4aefbd45 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
@@ -289,7 +289,7 @@ impl<'db> DbInterner<'db> {
             krate: None,
             block: None,
         })
-        .unwrap()
+        .expect("db is expected to be attached")
     }
 
     pub fn new_with(
diff --git a/src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs b/src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs
index f6416fe51c307..424890fe370c4 100644
--- a/src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs
@@ -107,14 +107,16 @@ pub(crate) fn inlay_hints(
         }
     };
     let mut preorder = file.preorder();
-    while let Some(event) = preorder.next() {
-        if matches!((&event, range_limit), (WalkEvent::Enter(node), Some(range)) if range.intersect(node.text_range()).is_none())
-        {
-            preorder.skip_subtree();
-            continue;
+    salsa::attach(sema.db, || {
+        while let Some(event) = preorder.next() {
+            if matches!((&event, range_limit), (WalkEvent::Enter(node), Some(range)) if range.intersect(node.text_range()).is_none())
+            {
+                preorder.skip_subtree();
+                continue;
+            }
+            hints(event);
         }
-        hints(event);
-    }
+    });
     if let Some(range_limit) = range_limit {
         acc.retain(|hint| range_limit.contains_range(hint.range));
     }
@@ -736,7 +738,7 @@ fn label_of_ty(
         config: &InlayHintsConfig,
         display_target: DisplayTarget,
     ) -> Result<(), HirDisplayError> {
-        let iter_item_type = salsa::attach(sema.db, || hint_iterator(sema, famous_defs, ty));
+        let iter_item_type = hint_iterator(sema, famous_defs, ty);
         match iter_item_type {
             Some((iter_trait, item, ty)) => {
                 const LABEL_START: &str = "impl ";

From 39ac6e1eed6312dfb41cd45410804bf629a8b7d1 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Wed, 13 Aug 2025 10:01:17 +0200
Subject: [PATCH 0071/1889] update a few fixmes, and one trivial improvement

---
 .../crates/hir-ty/src/next_solver/interner.rs | 33 ++++++++++++-------
 1 file changed, 22 insertions(+), 11 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
index 9c1bd52065fd2..402c73bb88223 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
@@ -22,8 +22,8 @@ use rustc_type_ir::inherent::{
 use rustc_type_ir::lang_items::TraitSolverLangItem;
 use rustc_type_ir::solve::SizedTraitKind;
 use rustc_type_ir::{
-    AliasTerm, AliasTermKind, AliasTy, EarlyBinder, FlagComputation, Flags, ImplPolarity, InferTy,
-    ProjectionPredicate, TraitPredicate, TraitRef, Upcast,
+    AliasTerm, AliasTermKind, AliasTy, AliasTyKind, EarlyBinder, FlagComputation, Flags,
+    ImplPolarity, InferTy, ProjectionPredicate, TraitPredicate, TraitRef, Upcast,
 };
 use salsa::plumbing::AsId;
 use smallvec::{SmallVec, smallvec};
@@ -1024,8 +1024,8 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
         false
     }
 
-    fn expand_abstract_consts<T: rustc_type_ir::TypeFoldable<Self>>(self, t: T) -> T {
-        t
+    fn expand_abstract_consts<T: rustc_type_ir::TypeFoldable<Self>>(self, _: T) -> T {
+        unreachable!("only used by the old trait solver in rustc");
     }
 
     fn generics_of(self, def_id: Self::DefId) -> Self::GenericsOf {
@@ -1054,6 +1054,9 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
             ),
             SolverDefId::InternedOpaqueTyId(_def_id) => {
                 // FIXME(next-solver): track variances
+                //
+                // We compute them based on the only `Ty` level info in rustc,
+                // move `variances_of_opaque` into `rustc_next_trait_solver` for reuse.
                 VariancesOf::new_from_iter(
                     self,
                     (0..self.generics_of(def_id).count()).map(|_| Variance::Invariant),
@@ -1074,6 +1077,9 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
                 crate::TyDefId::TypeAliasId(id)
             }
             SolverDefId::AdtId(id) => crate::TyDefId::AdtId(id),
+            // FIXME(next-solver): need to support opaque types. This uses the types of
+            // `query mir_borrowck` in rustc. If we're ignoring regions, we could simply
+            // use the type inferred by general type inference here.
             _ => panic!("Unexpected def_id `{def_id:?}` provided for `type_of`"),
         };
         self.db().ty_ns(def_id)
@@ -1087,9 +1093,12 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
         AdtDef::new(def_id, self)
     }
 
-    fn alias_ty_kind(self, alias: rustc_type_ir::AliasTy<Self>) -> rustc_type_ir::AliasTyKind {
-        // FIXME: not currently creating any others
-        rustc_type_ir::AliasTyKind::Projection
+    fn alias_ty_kind(self, alias: rustc_type_ir::AliasTy<Self>) -> AliasTyKind {
+        match alias.def_id {
+            SolverDefId::InternedOpaqueTyId(_) => AliasTyKind::Opaque,
+            SolverDefId::TypeAliasId(_) => AliasTyKind::Projection,
+            _ => unimplemented!("Unexpected alias: {:?}", alias.def_id),
+        }
     }
 
     fn alias_term_kind(
@@ -1100,7 +1109,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
             SolverDefId::InternedOpaqueTyId(_) => AliasTermKind::OpaqueTy,
             SolverDefId::TypeAliasId(_) => AliasTermKind::ProjectionTy,
             SolverDefId::ConstId(_) => AliasTermKind::UnevaluatedConst,
-            _ => unreachable!("Unexpected alias: {:?}", alias.def_id),
+            _ => todo!("Unexpected alias: {:?}", alias.def_id),
         }
     }
 
@@ -1741,7 +1750,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
     }
 
     fn has_item_definition(self, def_id: Self::DefId) -> bool {
-        // FIXME: should check if has value
+        // FIXME(next-solver): should check if the associated item has a value.
         true
     }
 
@@ -1811,7 +1820,8 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
     }
 
     fn trait_may_be_implemented_via_object(self, trait_def_id: Self::DefId) -> bool {
-        // FIXME(next-solver)
+        // FIXME(next-solver): should check the `TraitFlags` for
+        // the `#[rustc_do_not_implement_via_object]` flag
         true
     }
 
@@ -1982,7 +1992,8 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
         self,
         def_id: Self::LocalDefId,
     ) -> rustc_type_ir::EarlyBinder<Self, Self::Ty> {
-        // FIXME(next-solver)
+        // FIXME(next-solver): This should look at the type computed for the
+        // opaque by HIR typeck.
         unimplemented!()
     }
 

From bbf08d87eb92f618120b6517651588950780b3e4 Mon Sep 17 00:00:00 2001
From: dianne <diannes.gm@gmail.com>
Date: Tue, 12 Aug 2025 23:55:29 -0700
Subject: [PATCH 0072/1889] add a test with incorrect `if let`-`super let` drop
 order

---
 tests/ui/drop/if-let-super-let.rs | 112 ++++++++++++++++++++++++++++++
 1 file changed, 112 insertions(+)
 create mode 100644 tests/ui/drop/if-let-super-let.rs

diff --git a/tests/ui/drop/if-let-super-let.rs b/tests/ui/drop/if-let-super-let.rs
new file mode 100644
index 0000000000000..0f966e793a31f
--- /dev/null
+++ b/tests/ui/drop/if-let-super-let.rs
@@ -0,0 +1,112 @@
+//! Test for #145328: ensure the lifetime of a `super let` binding within an `if let` scrutinee is
+//! at most the scope of the `if` condition's temporaries. Additionally, test `pin!` since it's
+//! implemented in terms of `super let` and exposes this behavior.
+//@ run-pass
+//@ revisions: e2021 e2024
+//@ [e2021] edition: 2021
+//@ [e2024] edition: 2024
+
+#![feature(if_let_guard)]
+#![feature(super_let)]
+#![expect(irrefutable_let_patterns)]
+
+use std::cell::RefCell;
+use std::pin::pin;
+
+fn main() {
+    // The `super let` bindings here should have the same scope as `if let` temporaries.
+    // In Rust 2021, this means it lives past the end of the `if` expression.
+    // In Rust 2024, this means it lives to the end of the `if`'s success block.
+    assert_drop_order(0..=2, |o| {
+        #[cfg(e2021)]
+        (
+            if let _ = { super let _x = o.log(2); } { o.push(0) },
+            o.push(1),
+        );
+        #[cfg(e2024)]
+        (
+            if let _ = { super let _x = o.log(2); } { o.push(0) },
+            o.push(1),
+        );
+    });
+    assert_drop_order(0..=2, |o| {
+        #[cfg(e2021)]
+        (
+            if let true = { super let _x = o.log(2); false } {} else { o.push(0) },
+            o.push(1),
+        );
+        #[cfg(e2024)]
+        (
+            if let true = { super let _x = o.log(2); false } {} else { o.push(0) },
+            o.push(1),
+        );
+    });
+
+    // `pin!` should behave likewise.
+    assert_drop_order(0..=2, |o| {
+        #[cfg(e2021)] (if let _ = pin!(o.log(2)) { o.push(0) }, o.push(1));
+        #[cfg(e2024)] (if let _ = pin!(o.log(2)) { o.push(0) }, o.push(1));
+    });
+    assert_drop_order(0..=2, |o| {
+        #[cfg(e2021)]
+        (
+            if let None = Some(pin!(o.log(2))) {} else { o.push(0) },
+            o.push(1),
+        );
+        #[cfg(e2024)]
+        (
+            if let None = Some(pin!(o.log(2))) {} else { o.push(0) },
+            o.push(1),
+        );
+    });
+
+    // `super let` bindings' scope should also be consistent with `if let` temporaries in guards.
+    // Here, that means the `super let` binding in the second guard condition operand should be
+    // dropped before the first operand's temporary. This is consistent across Editions.
+    assert_drop_order(0..=1, |o| {
+        match () {
+            _ if let _ = o.log(0)
+                && let _ = { super let _x = o.log(1); } => {}
+            _ => unreachable!(),
+        }
+    });
+    assert_drop_order(0..=1, |o| {
+        match () {
+            _ if let _ = o.log(0)
+                && let _ = pin!(o.log(1)) => {}
+            _ => unreachable!(),
+        }
+    });
+}
+
+// # Test scaffolding...
+
+struct DropOrder(RefCell<Vec<u64>>);
+struct LogDrop<'o>(&'o DropOrder, u64);
+
+impl DropOrder {
+    fn log(&self, n: u64) -> LogDrop<'_> {
+        LogDrop(self, n)
+    }
+    fn push(&self, n: u64) {
+        self.0.borrow_mut().push(n);
+    }
+}
+
+impl<'o> Drop for LogDrop<'o> {
+    fn drop(&mut self) {
+        self.0.push(self.1);
+    }
+}
+
+#[track_caller]
+fn assert_drop_order(
+    ex: impl IntoIterator<Item = u64>,
+    f: impl Fn(&DropOrder),
+) {
+    let order = DropOrder(RefCell::new(Vec::new()));
+    f(&order);
+    let order = order.0.into_inner();
+    let expected: Vec<u64> = ex.into_iter().collect();
+    assert_eq!(order, expected);
+}

From 8fc3938d9961568dfec38b10506f33fd9bc7c147 Mon Sep 17 00:00:00 2001
From: dianne <diannes.gm@gmail.com>
Date: Wed, 13 Aug 2025 01:02:13 -0700
Subject: [PATCH 0073/1889] fix scope of `super let` bindings within `if let`

They now use the enclosing temporary scope as their scope, regardless of
which `ScopeData` was used to mark it.
---
 .../rustc_hir_analysis/src/check/region.rs    |  8 +---
 compiler/rustc_middle/src/middle/region.rs    | 39 +++++++++++++++++++
 compiler/rustc_middle/src/ty/rvalue_scopes.rs | 37 +-----------------
 tests/ui/drop/if-let-super-let.rs             | 22 +++++------
 4 files changed, 54 insertions(+), 52 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/check/region.rs b/compiler/rustc_hir_analysis/src/check/region.rs
index f5770b7312ddf..2ba7ed46f92c4 100644
--- a/compiler/rustc_hir_analysis/src/check/region.rs
+++ b/compiler/rustc_hir_analysis/src/check/region.rs
@@ -490,12 +490,8 @@ fn resolve_local<'tcx>(
             //
             // Iterate up to the enclosing destruction scope to find the same scope that will also
             // be used for the result of the block itself.
-            while let Some(s) = visitor.cx.var_parent {
-                let parent = visitor.scope_tree.parent_map.get(&s).cloned();
-                if let Some(Scope { data: ScopeData::Destruction, .. }) = parent {
-                    break;
-                }
-                visitor.cx.var_parent = parent;
+            if let Some(inner_scope) = visitor.cx.var_parent {
+                (visitor.cx.var_parent, _) = visitor.scope_tree.default_temporary_scope(inner_scope)
             }
         }
     }
diff --git a/compiler/rustc_middle/src/middle/region.rs b/compiler/rustc_middle/src/middle/region.rs
index 857d041224fa9..5367e5edd496a 100644
--- a/compiler/rustc_middle/src/middle/region.rs
+++ b/compiler/rustc_middle/src/middle/region.rs
@@ -299,4 +299,43 @@ impl ScopeTree {
 
         true
     }
+
+    /// Returns the scope of non-lifetime-extended temporaries within a given scope, as well as
+    /// whether we've recorded a potential backwards-incompatible change to lint on.
+    /// Returns `None` when no enclosing temporary scope is found, such as for static items.
+    pub fn default_temporary_scope(&self, inner: Scope) -> (Option<Scope>, Option<Scope>) {
+        let mut id = inner;
+        let mut backwards_incompatible = None;
+
+        while let Some(&p) = self.parent_map.get(&id) {
+            match p.data {
+                ScopeData::Destruction => {
+                    debug!("temporary_scope({inner:?}) = {id:?} [enclosing]");
+                    return (Some(id), backwards_incompatible);
+                }
+                ScopeData::IfThenRescope | ScopeData::MatchGuard => {
+                    debug!("temporary_scope({inner:?}) = {p:?} [enclosing]");
+                    return (Some(p), backwards_incompatible);
+                }
+                ScopeData::Node
+                | ScopeData::CallSite
+                | ScopeData::Arguments
+                | ScopeData::IfThen
+                | ScopeData::Remainder(_) => {
+                    // If we haven't already passed through a backwards-incompatible node,
+                    // then check if we are passing through one now and record it if so.
+                    // This is for now only working for cases where a temporary lifetime is
+                    // *shortened*.
+                    if backwards_incompatible.is_none() {
+                        backwards_incompatible =
+                            self.backwards_incompatible_scope.get(&p.local_id).copied();
+                    }
+                    id = p
+                }
+            }
+        }
+
+        debug!("temporary_scope({inner:?}) = None");
+        (None, backwards_incompatible)
+    }
 }
diff --git a/compiler/rustc_middle/src/ty/rvalue_scopes.rs b/compiler/rustc_middle/src/ty/rvalue_scopes.rs
index 7dfe2d280514f..8b92e48ed1a07 100644
--- a/compiler/rustc_middle/src/ty/rvalue_scopes.rs
+++ b/compiler/rustc_middle/src/ty/rvalue_scopes.rs
@@ -35,41 +35,8 @@ impl RvalueScopes {
         // if there's one. Static items, for instance, won't
         // have an enclosing scope, hence no scope will be
         // returned.
-        let mut id = Scope { local_id: expr_id, data: ScopeData::Node };
-        let mut backwards_incompatible = None;
-
-        while let Some(&p) = region_scope_tree.parent_map.get(&id) {
-            match p.data {
-                ScopeData::Destruction => {
-                    debug!("temporary_scope({expr_id:?}) = {id:?} [enclosing]");
-                    return (Some(id), backwards_incompatible);
-                }
-                ScopeData::IfThenRescope | ScopeData::MatchGuard => {
-                    debug!("temporary_scope({expr_id:?}) = {p:?} [enclosing]");
-                    return (Some(p), backwards_incompatible);
-                }
-                ScopeData::Node
-                | ScopeData::CallSite
-                | ScopeData::Arguments
-                | ScopeData::IfThen
-                | ScopeData::Remainder(_) => {
-                    // If we haven't already passed through a backwards-incompatible node,
-                    // then check if we are passing through one now and record it if so.
-                    // This is for now only working for cases where a temporary lifetime is
-                    // *shortened*.
-                    if backwards_incompatible.is_none() {
-                        backwards_incompatible = region_scope_tree
-                            .backwards_incompatible_scope
-                            .get(&p.local_id)
-                            .copied();
-                    }
-                    id = p
-                }
-            }
-        }
-
-        debug!("temporary_scope({expr_id:?}) = None");
-        (None, backwards_incompatible)
+        region_scope_tree
+            .default_temporary_scope(Scope { local_id: expr_id, data: ScopeData::Node })
     }
 
     /// Make an association between a sub-expression and an extended lifetime
diff --git a/tests/ui/drop/if-let-super-let.rs b/tests/ui/drop/if-let-super-let.rs
index 0f966e793a31f..c6543e6d3dc97 100644
--- a/tests/ui/drop/if-let-super-let.rs
+++ b/tests/ui/drop/if-let-super-let.rs
@@ -25,8 +25,8 @@ fn main() {
         );
         #[cfg(e2024)]
         (
-            if let _ = { super let _x = o.log(2); } { o.push(0) },
-            o.push(1),
+            if let _ = { super let _x = o.log(1); } { o.push(0) },
+            o.push(2),
         );
     });
     assert_drop_order(0..=2, |o| {
@@ -37,15 +37,15 @@ fn main() {
         );
         #[cfg(e2024)]
         (
-            if let true = { super let _x = o.log(2); false } {} else { o.push(0) },
-            o.push(1),
+            if let true = { super let _x = o.log(0); false } {} else { o.push(1) },
+            o.push(2),
         );
     });
 
     // `pin!` should behave likewise.
     assert_drop_order(0..=2, |o| {
         #[cfg(e2021)] (if let _ = pin!(o.log(2)) { o.push(0) }, o.push(1));
-        #[cfg(e2024)] (if let _ = pin!(o.log(2)) { o.push(0) }, o.push(1));
+        #[cfg(e2024)] (if let _ = pin!(o.log(1)) { o.push(0) }, o.push(2));
     });
     assert_drop_order(0..=2, |o| {
         #[cfg(e2021)]
@@ -55,8 +55,8 @@ fn main() {
         );
         #[cfg(e2024)]
         (
-            if let None = Some(pin!(o.log(2))) {} else { o.push(0) },
-            o.push(1),
+            if let None = Some(pin!(o.log(0))) {} else { o.push(1) },
+            o.push(2),
         );
     });
 
@@ -65,15 +65,15 @@ fn main() {
     // dropped before the first operand's temporary. This is consistent across Editions.
     assert_drop_order(0..=1, |o| {
         match () {
-            _ if let _ = o.log(0)
-                && let _ = { super let _x = o.log(1); } => {}
+            _ if let _ = o.log(1)
+                && let _ = { super let _x = o.log(0); } => {}
             _ => unreachable!(),
         }
     });
     assert_drop_order(0..=1, |o| {
         match () {
-            _ if let _ = o.log(0)
-                && let _ = pin!(o.log(1)) => {}
+            _ if let _ = o.log(1)
+                && let _ = pin!(o.log(0)) => {}
             _ => unreachable!(),
         }
     });

From 00941b3142bf7b50a39b1a2dfa167d3642b5f3db Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Wed, 13 Aug 2025 10:07:12 +0200
Subject: [PATCH 0074/1889] implement `type_of_opaque`

---
 .../rust-analyzer/crates/hir-ty/src/layout.rs |  23 +---
 .../crates/hir-ty/src/next_solver/interner.rs | 100 +++++++++---------
 .../rust-analyzer/crates/hir-ty/src/tests.rs  |   2 +-
 ...e_alias_impl_traits.rs => opaque_types.rs} |  16 +++
 4 files changed, 69 insertions(+), 72 deletions(-)
 rename src/tools/rust-analyzer/crates/hir-ty/src/tests/{type_alias_impl_traits.rs => opaque_types.rs} (92%)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
index 819bd583deaed..e7bb529ad8f26 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
@@ -335,27 +335,6 @@ pub fn layout_of_ty_ns_query<'db>(
             ptr.valid_range_mut().start = 1;
             Layout::scalar(dl, ptr)
         }
-        TyKind::Alias(_, ty) => match ty.def_id {
-            SolverDefId::TypeAliasId(_) => {
-                return Err(LayoutError::HasPlaceholder);
-            }
-            SolverDefId::InternedOpaqueTyId(opaque) => {
-                let impl_trait_id = db.lookup_intern_impl_trait_id(opaque);
-                match impl_trait_id {
-                    crate::ImplTraitId::ReturnTypeImplTrait(func, idx) => {
-                        let infer = db.infer(func.into());
-                        return db.layout_of_ty(infer.type_of_rpit[idx].clone(), trait_env);
-                    }
-                    crate::ImplTraitId::TypeAliasImplTrait(..) => {
-                        return Err(LayoutError::NotImplemented);
-                    }
-                    crate::ImplTraitId::AsyncBlockTypeImplTrait(_, _) => {
-                        return Err(LayoutError::NotImplemented);
-                    }
-                }
-            }
-            _ => unreachable!(),
-        },
         TyKind::Closure(c, args) => {
             let id = match c {
                 SolverDefId::InternedClosureId(id) => id,
@@ -389,7 +368,7 @@ pub fn layout_of_ty_ns_query<'db>(
         }
 
         TyKind::Error(_) => return Err(LayoutError::HasErrorType),
-        TyKind::Placeholder(_) | TyKind::Bound(..) | TyKind::Infer(..) | TyKind::Param(..) => {
+        TyKind::Placeholder(_) | TyKind::Bound(..) | TyKind::Infer(..) | TyKind::Param(..) | TyKind::Alias(..) => {
             return Err(LayoutError::HasPlaceholder);
         }
     };
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
index 402c73bb88223..294d071f58aef 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
@@ -626,12 +626,8 @@ impl<'db> inherent::AdtDef<DbInterner<'db>> for AdtDef {
     fn struct_tail_ty(
         self,
         interner: DbInterner<'db>,
-    ) -> Option<
-        rustc_type_ir::EarlyBinder<
-            DbInterner<'db>,
-            <DbInterner<'db> as rustc_type_ir::Interner>::Ty,
-        >,
-    > {
+    ) -> Option<EarlyBinder<DbInterner<'db>, <DbInterner<'db> as rustc_type_ir::Interner>::Ty>>
+    {
         let db = interner.db();
         let hir_def::AdtId::StructId(struct_id) = self.inner().id else {
             return None;
@@ -645,7 +641,7 @@ impl<'db> inherent::AdtDef<DbInterner<'db>> for AdtDef {
     fn all_field_tys(
         self,
         interner: DbInterner<'db>,
-    ) -> rustc_type_ir::EarlyBinder<
+    ) -> EarlyBinder<
         DbInterner<'db>,
         impl IntoIterator<Item = <DbInterner<'db> as rustc_type_ir::Interner>::Ty>,
     > {
@@ -679,19 +675,15 @@ impl<'db> inherent::AdtDef<DbInterner<'db>> for AdtDef {
                 .collect(),
         };
 
-        rustc_type_ir::EarlyBinder::bind(tys)
+        EarlyBinder::bind(tys)
     }
 
     fn sizedness_constraint(
         self,
         interner: DbInterner<'db>,
         sizedness: SizedTraitKind,
-    ) -> Option<
-        rustc_type_ir::EarlyBinder<
-            DbInterner<'db>,
-            <DbInterner<'db> as rustc_type_ir::Interner>::Ty,
-        >,
-    > {
+    ) -> Option<EarlyBinder<DbInterner<'db>, <DbInterner<'db> as rustc_type_ir::Interner>::Ty>>
+    {
         if self.is_struct() {
             let tail_ty = self.all_field_tys(interner).skip_binder().into_iter().last()?;
 
@@ -1066,7 +1058,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
         }
     }
 
-    fn type_of(self, def_id: Self::DefId) -> rustc_type_ir::EarlyBinder<Self, Self::Ty> {
+    fn type_of(self, def_id: Self::DefId) -> EarlyBinder<Self, Self::Ty> {
         let def_id = match def_id {
             SolverDefId::TypeAliasId(id) => {
                 use hir_def::Lookup;
@@ -1077,9 +1069,13 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
                 crate::TyDefId::TypeAliasId(id)
             }
             SolverDefId::AdtId(id) => crate::TyDefId::AdtId(id),
-            // FIXME(next-solver): need to support opaque types. This uses the types of
-            // `query mir_borrowck` in rustc. If we're ignoring regions, we could simply
-            // use the type inferred by general type inference here.
+            // FIXME(next-solver): This uses the types of `query mir_borrowck` in rustc.
+            //
+            // We currently always use the type from HIR typeck which ignores regions. This
+            // should be fine.
+            SolverDefId::InternedOpaqueTyId(_) => {
+                return self.type_of_opaque_hir_typeck(def_id);
+            }
             _ => panic!("Unexpected def_id `{def_id:?}` provided for `type_of`"),
         };
         self.db().ty_ns(def_id)
@@ -1109,7 +1105,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
             SolverDefId::InternedOpaqueTyId(_) => AliasTermKind::OpaqueTy,
             SolverDefId::TypeAliasId(_) => AliasTermKind::ProjectionTy,
             SolverDefId::ConstId(_) => AliasTermKind::UnevaluatedConst,
-            _ => todo!("Unexpected alias: {:?}", alias.def_id),
+            _ => unimplemented!("Unexpected alias: {:?}", alias.def_id),
         }
     }
 
@@ -1204,8 +1200,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
     fn fn_sig(
         self,
         def_id: Self::DefId,
-    ) -> rustc_type_ir::EarlyBinder<Self, rustc_type_ir::Binder<Self, rustc_type_ir::FnSig<Self>>>
-    {
+    ) -> EarlyBinder<Self, rustc_type_ir::Binder<Self, rustc_type_ir::FnSig<Self>>> {
         let id = match def_id {
             SolverDefId::FunctionId(id) => CallableDefId::FunctionId(id),
             SolverDefId::Ctor(ctor) => match ctor {
@@ -1258,7 +1253,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
     fn item_bounds(
         self,
         def_id: Self::DefId,
-    ) -> rustc_type_ir::EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>> {
+    ) -> EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>> {
         explicit_item_bounds(self, def_id).map_bound(|bounds| {
             Clauses::new_from_iter(self, elaborate(self, bounds).collect::<Vec<_>>())
         })
@@ -1268,7 +1263,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
     fn item_self_bounds(
         self,
         def_id: Self::DefId,
-    ) -> rustc_type_ir::EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>> {
+    ) -> EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>> {
         explicit_item_bounds(self, def_id).map_bound(|bounds| {
             Clauses::new_from_iter(
                 self,
@@ -1280,7 +1275,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
     fn item_non_self_bounds(
         self,
         def_id: Self::DefId,
-    ) -> rustc_type_ir::EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>> {
+    ) -> EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>> {
         let all_bounds: FxHashSet<_> = self.item_bounds(def_id).skip_binder().into_iter().collect();
         let own_bounds: FxHashSet<_> =
             self.item_self_bounds(def_id).skip_binder().into_iter().collect();
@@ -1298,7 +1293,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
     fn predicates_of(
         self,
         def_id: Self::DefId,
-    ) -> rustc_type_ir::EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>> {
+    ) -> EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>> {
         let predicates = self.db().generic_predicates_ns(def_id.try_into().unwrap());
         let predicates: Vec<_> = predicates.iter().cloned().collect();
         EarlyBinder::bind(predicates.into_iter())
@@ -1308,7 +1303,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
     fn own_predicates_of(
         self,
         def_id: Self::DefId,
-    ) -> rustc_type_ir::EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>> {
+    ) -> EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>> {
         let predicates = self.db().generic_predicates_without_parent_ns(def_id.try_into().unwrap());
         let predicates: Vec<_> = predicates.iter().cloned().collect();
         EarlyBinder::bind(predicates.into_iter())
@@ -1318,8 +1313,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
     fn explicit_super_predicates_of(
         self,
         def_id: Self::DefId,
-    ) -> rustc_type_ir::EarlyBinder<Self, impl IntoIterator<Item = (Self::Clause, Self::Span)>>
-    {
+    ) -> EarlyBinder<Self, impl IntoIterator<Item = (Self::Clause, Self::Span)>> {
         let predicates: Vec<(Clause<'db>, Span)> = self
             .db()
             .generic_predicates_ns(def_id.try_into().unwrap())
@@ -1327,15 +1321,14 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
             .cloned()
             .map(|p| (p, Span::dummy()))
             .collect();
-        rustc_type_ir::EarlyBinder::bind(predicates)
+        EarlyBinder::bind(predicates)
     }
 
     #[tracing::instrument(skip(self), ret)]
     fn explicit_implied_predicates_of(
         self,
         def_id: Self::DefId,
-    ) -> rustc_type_ir::EarlyBinder<Self, impl IntoIterator<Item = (Self::Clause, Self::Span)>>
-    {
+    ) -> EarlyBinder<Self, impl IntoIterator<Item = (Self::Clause, Self::Span)>> {
         let predicates: Vec<(Clause<'db>, Span)> = self
             .db()
             .generic_predicates_ns(def_id.try_into().unwrap())
@@ -1343,13 +1336,13 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
             .cloned()
             .map(|p| (p, Span::dummy()))
             .collect();
-        rustc_type_ir::EarlyBinder::bind(predicates)
+        EarlyBinder::bind(predicates)
     }
 
     fn impl_super_outlives(
         self,
         impl_def_id: Self::DefId,
-    ) -> rustc_type_ir::EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>> {
+    ) -> EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>> {
         let impl_id = match impl_def_id {
             SolverDefId::ImplId(id) => id,
             _ => unreachable!(),
@@ -1372,11 +1365,11 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
     fn const_conditions(
         self,
         def_id: Self::DefId,
-    ) -> rustc_type_ir::EarlyBinder<
+    ) -> EarlyBinder<
         Self,
         impl IntoIterator<Item = rustc_type_ir::Binder<Self, rustc_type_ir::TraitRef<Self>>>,
     > {
-        rustc_type_ir::EarlyBinder::bind([unimplemented!()])
+        EarlyBinder::bind([unimplemented!()])
     }
 
     fn has_target_features(self, def_id: Self::DefId) -> bool {
@@ -1763,7 +1756,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
     fn impl_trait_ref(
         self,
         impl_def_id: Self::DefId,
-    ) -> rustc_type_ir::EarlyBinder<Self, rustc_type_ir::TraitRef<Self>> {
+    ) -> EarlyBinder<Self, rustc_type_ir::TraitRef<Self>> {
         let impl_id = match impl_def_id {
             SolverDefId::ImplId(id) => id,
             _ => panic!("Unexpected SolverDefId in impl_trait_ref"),
@@ -1960,12 +1953,12 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
     fn explicit_implied_const_bounds(
         self,
         def_id: Self::DefId,
-    ) -> rustc_type_ir::EarlyBinder<
+    ) -> EarlyBinder<
         Self,
         impl IntoIterator<Item = rustc_type_ir::Binder<Self, rustc_type_ir::TraitRef<Self>>>,
     > {
         // FIXME(next-solver)
-        rustc_type_ir::EarlyBinder::bind([])
+        EarlyBinder::bind([])
     }
 
     fn fn_is_const(self, def_id: Self::DefId) -> bool {
@@ -1988,22 +1981,31 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
         None
     }
 
-    fn type_of_opaque_hir_typeck(
-        self,
-        def_id: Self::LocalDefId,
-    ) -> rustc_type_ir::EarlyBinder<Self, Self::Ty> {
-        // FIXME(next-solver): This should look at the type computed for the
-        // opaque by HIR typeck.
-        unimplemented!()
+    fn type_of_opaque_hir_typeck(self, def_id: Self::LocalDefId) -> EarlyBinder<Self, Self::Ty> {
+        match def_id {
+            SolverDefId::InternedOpaqueTyId(opaque) => {
+                let impl_trait_id = self.db().lookup_intern_impl_trait_id(opaque);
+                match impl_trait_id {
+                    crate::ImplTraitId::ReturnTypeImplTrait(func, idx) => {
+                        let infer = self.db().infer(func.into());
+                        EarlyBinder::bind(infer.type_of_rpit[idx].to_nextsolver(self))
+                    }
+                    crate::ImplTraitId::TypeAliasImplTrait(..)
+                    | crate::ImplTraitId::AsyncBlockTypeImplTrait(_, _) => {
+                        // FIXME(next-solver)
+                        EarlyBinder::bind(Ty::new_error(self, ErrorGuaranteed))
+                    }
+                }
+            }
+            _ => panic!("Unexpected SolverDefId in type_of_opaque_hir_typeck"),
+        }
     }
 
     fn coroutine_hidden_types(
         self,
         def_id: Self::DefId,
-    ) -> rustc_type_ir::EarlyBinder<
-        Self,
-        rustc_type_ir::Binder<Self, rustc_type_ir::CoroutineWitnessTypes<Self>>,
-    > {
+    ) -> EarlyBinder<Self, rustc_type_ir::Binder<Self, rustc_type_ir::CoroutineWitnessTypes<Self>>>
+    {
         // FIXME(next-solver)
         unimplemented!()
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs
index fc31973022bdd..d89cf4bcd45cd 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs
@@ -6,11 +6,11 @@ mod incremental;
 mod macros;
 mod method_resolution;
 mod never_type;
+mod opaque_types;
 mod patterns;
 mod regression;
 mod simple;
 mod traits;
-mod type_alias_impl_traits;
 
 use base_db::{Crate, SourceDatabase};
 use expect_test::Expect;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/type_alias_impl_traits.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/opaque_types.rs
similarity index 92%
rename from src/tools/rust-analyzer/crates/hir-ty/src/tests/type_alias_impl_traits.rs
rename to src/tools/rust-analyzer/crates/hir-ty/src/tests/opaque_types.rs
index e2b7bf379cc3b..36578545a9f49 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/type_alias_impl_traits.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/opaque_types.rs
@@ -159,3 +159,19 @@ static ALIAS: i32 = {
         "#]],
     )
 }
+
+#[test]
+fn leak_auto_traits() {
+    check_no_mismatches(
+        r#"
+//- minicore: send
+fn foo() -> impl Sized {}
+
+fn is_send<T: Send>(_: T) {}
+
+fn main() {
+    is_send(foo());
+}
+        "#,
+    );
+}

From 5849fef132daf525016379b6bfc6bd25459371dd Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Wed, 13 Aug 2025 10:30:34 +0200
Subject: [PATCH 0075/1889] layout_of uses `PostAnalysis`

---
 src/tools/rust-analyzer/crates/hir-ty/src/layout.rs | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
index e7bb529ad8f26..2d0471d7e5545 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
@@ -182,7 +182,7 @@ pub fn layout_of_ty_ns_query<'db>(
     };
     let dl = &*target;
     let cx = LayoutCx::new(dl);
-    let infer_ctxt = interner.infer_ctxt().build(TypingMode::non_body_analysis());
+    let infer_ctxt = interner.infer_ctxt().build(TypingMode::PostAnalysis);
     let cause = ObligationCause::dummy();
     let ty = deeply_normalize(infer_ctxt.at(&cause, ParamEnv::empty()), ty).unwrap_or(ty);
     let result = match ty.kind() {
@@ -368,7 +368,11 @@ pub fn layout_of_ty_ns_query<'db>(
         }
 
         TyKind::Error(_) => return Err(LayoutError::HasErrorType),
-        TyKind::Placeholder(_) | TyKind::Bound(..) | TyKind::Infer(..) | TyKind::Param(..) | TyKind::Alias(..) => {
+        TyKind::Placeholder(_)
+        | TyKind::Bound(..)
+        | TyKind::Infer(..)
+        | TyKind::Param(..)
+        | TyKind::Alias(..) => {
             return Err(LayoutError::HasPlaceholder);
         }
     };

From 67b1e329080519085716c8e444a43eede0d196a6 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Wed, 13 Aug 2025 11:00:00 +0200
Subject: [PATCH 0076/1889] manually normalize alias

---
 .../crates/hir-ty/src/next_solver/interner.rs         | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
index 294d071f58aef..c530c28f88613 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
@@ -626,8 +626,7 @@ impl<'db> inherent::AdtDef<DbInterner<'db>> for AdtDef {
     fn struct_tail_ty(
         self,
         interner: DbInterner<'db>,
-    ) -> Option<EarlyBinder<DbInterner<'db>, <DbInterner<'db> as rustc_type_ir::Interner>::Ty>>
-    {
+    ) -> Option<EarlyBinder<DbInterner<'db>, Ty<'db>>> {
         let db = interner.db();
         let hir_def::AdtId::StructId(struct_id) = self.inner().id else {
             return None;
@@ -641,10 +640,7 @@ impl<'db> inherent::AdtDef<DbInterner<'db>> for AdtDef {
     fn all_field_tys(
         self,
         interner: DbInterner<'db>,
-    ) -> EarlyBinder<
-        DbInterner<'db>,
-        impl IntoIterator<Item = <DbInterner<'db> as rustc_type_ir::Interner>::Ty>,
-    > {
+    ) -> EarlyBinder<DbInterner<'db>, impl IntoIterator<Item = Ty<'db>>> {
         let db = interner.db();
         // FIXME: this is disabled just to match the behavior with chalk right now
         let field_tys = |id: VariantId| {
@@ -682,8 +678,7 @@ impl<'db> inherent::AdtDef<DbInterner<'db>> for AdtDef {
         self,
         interner: DbInterner<'db>,
         sizedness: SizedTraitKind,
-    ) -> Option<EarlyBinder<DbInterner<'db>, <DbInterner<'db> as rustc_type_ir::Interner>::Ty>>
-    {
+    ) -> Option<EarlyBinder<DbInterner<'db>, Ty<'db>>> {
         if self.is_struct() {
             let tail_ty = self.all_field_tys(interner).skip_binder().into_iter().last()?;
 

From 1d57d7800db05934a466457c443975d71c4d1e29 Mon Sep 17 00:00:00 2001
From: donni-h <56559005+donni-h@users.noreply.github.com>
Date: Wed, 13 Aug 2025 13:03:52 +0200
Subject: [PATCH 0077/1889] Fix dead link to Cargo.toml in documentation

../../Cargo.toml resolves to https://rust-analyzer.github.io/Cargo.toml, which is an invalid link
---
 src/tools/rust-analyzer/docs/book/src/contributing/style.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/docs/book/src/contributing/style.md b/src/tools/rust-analyzer/docs/book/src/contributing/style.md
index 746f3eb132117..fe09fb6c2fd52 100644
--- a/src/tools/rust-analyzer/docs/book/src/contributing/style.md
+++ b/src/tools/rust-analyzer/docs/book/src/contributing/style.md
@@ -101,7 +101,7 @@ Including a description and GIF suitable for the changelog means less work for t
 
 ## Clippy
 
-We use Clippy to improve the code, but if some lints annoy you, allow them in the [Cargo.toml](../../Cargo.toml) [workspace.lints.clippy] section.
+We use Clippy to improve the code, but if some lints annoy you, allow them in the [Cargo.toml](https://github.com/rust-lang/rust-analyzer/blob/master/Cargo.toml) [workspace.lints.clippy] section.
 
 # Code
 

From 8ef6a8ff6defd019dff7865ab602bc7acba1afc2 Mon Sep 17 00:00:00 2001
From: Wilfred Hughes <me@wilfred.me.uk>
Date: Wed, 13 Aug 2025 15:24:53 +0100
Subject: [PATCH 0078/1889] [internal] Update to the latest @vscode/vsce for
 extension build

This isn't a logic change, but it fixes an npm warning during the
build. vsce itself hasn't had any major changes between 3.2.2 and 3.6.

* https://github.com/microsoft/vscode-vsce/releases/tag/v3.3.0
* https://github.com/microsoft/vscode-vsce/releases/tag/v3.4.0
* https://github.com/microsoft/vscode-vsce/releases/tag/v3.5.0
* https://github.com/microsoft/vscode-vsce/releases/tag/v3.6.0
---
 .../editors/code/package-lock.json            | 1368 ++++++++++++++---
 .../rust-analyzer/editors/code/package.json   |    2 +-
 2 files changed, 1169 insertions(+), 201 deletions(-)

diff --git a/src/tools/rust-analyzer/editors/code/package-lock.json b/src/tools/rust-analyzer/editors/code/package-lock.json
index 1dc11ee4e4b81..ad8708e00c519 100644
--- a/src/tools/rust-analyzer/editors/code/package-lock.json
+++ b/src/tools/rust-analyzer/editors/code/package-lock.json
@@ -26,7 +26,7 @@
                 "@typescript-eslint/eslint-plugin": "^8.25.0",
                 "@typescript-eslint/parser": "^8.25.0",
                 "@vscode/test-electron": "^2.4.1",
-                "@vscode/vsce": "^3.2.2",
+                "@vscode/vsce": "^3.6.0",
                 "esbuild": "^0.25.0",
                 "eslint": "^9.21.0",
                 "eslint-config-prettier": "^10.0.2",
@@ -41,6 +41,23 @@
                 "vscode": "^1.93.0"
             }
         },
+        "node_modules/@azu/format-text": {
+            "version": "1.0.2",
+            "resolved": "https://registry.npmjs.org/@azu/format-text/-/format-text-1.0.2.tgz",
+            "integrity": "sha512-Swi4N7Edy1Eqq82GxgEECXSSLyn6GOb5htRFPzBDdUkECGXtlf12ynO5oJSpWKPwCaUssOu7NfhDcCWpIC6Ywg==",
+            "dev": true,
+            "license": "BSD-3-Clause"
+        },
+        "node_modules/@azu/style-format": {
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/@azu/style-format/-/style-format-1.0.1.tgz",
+            "integrity": "sha512-AHcTojlNBdD/3/KxIKlg8sxIWHfOtQszLvOpagLTO+bjC3u7SAszu1lf//u7JJC50aUSH+BVWDD/KvaA6Gfn5g==",
+            "dev": true,
+            "license": "WTFPL",
+            "dependencies": {
+                "@azu/format-text": "^1.0.1"
+            }
+        },
         "node_modules/@azure/abort-controller": {
             "version": "2.1.2",
             "resolved": "https://registry.npmjs.org/@azure/abort-controller/-/abort-controller-2.1.2.tgz",
@@ -212,6 +229,31 @@
                 "node": ">=16"
             }
         },
+        "node_modules/@babel/code-frame": {
+            "version": "7.27.1",
+            "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz",
+            "integrity": "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@babel/helper-validator-identifier": "^7.27.1",
+                "js-tokens": "^4.0.0",
+                "picocolors": "^1.1.1"
+            },
+            "engines": {
+                "node": ">=6.9.0"
+            }
+        },
+        "node_modules/@babel/helper-validator-identifier": {
+            "version": "7.27.1",
+            "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz",
+            "integrity": "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=6.9.0"
+            }
+        },
         "node_modules/@esbuild/aix-ppc64": {
             "version": "0.25.0",
             "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.0.tgz",
@@ -947,6 +989,217 @@
                 "node": ">= 8"
             }
         },
+        "node_modules/@secretlint/config-creator": {
+            "version": "10.2.2",
+            "resolved": "https://registry.npmjs.org/@secretlint/config-creator/-/config-creator-10.2.2.tgz",
+            "integrity": "sha512-BynOBe7Hn3LJjb3CqCHZjeNB09s/vgf0baBaHVw67w7gHF0d25c3ZsZ5+vv8TgwSchRdUCRrbbcq5i2B1fJ2QQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@secretlint/types": "^10.2.2"
+            },
+            "engines": {
+                "node": ">=20.0.0"
+            }
+        },
+        "node_modules/@secretlint/config-loader": {
+            "version": "10.2.2",
+            "resolved": "https://registry.npmjs.org/@secretlint/config-loader/-/config-loader-10.2.2.tgz",
+            "integrity": "sha512-ndjjQNgLg4DIcMJp4iaRD6xb9ijWQZVbd9694Ol2IszBIbGPPkwZHzJYKICbTBmh6AH/pLr0CiCaWdGJU7RbpQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@secretlint/profiler": "^10.2.2",
+                "@secretlint/resolver": "^10.2.2",
+                "@secretlint/types": "^10.2.2",
+                "ajv": "^8.17.1",
+                "debug": "^4.4.1",
+                "rc-config-loader": "^4.1.3"
+            },
+            "engines": {
+                "node": ">=20.0.0"
+            }
+        },
+        "node_modules/@secretlint/config-loader/node_modules/ajv": {
+            "version": "8.17.1",
+            "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
+            "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "fast-deep-equal": "^3.1.3",
+                "fast-uri": "^3.0.1",
+                "json-schema-traverse": "^1.0.0",
+                "require-from-string": "^2.0.2"
+            },
+            "funding": {
+                "type": "github",
+                "url": "https://github.com/sponsors/epoberezkin"
+            }
+        },
+        "node_modules/@secretlint/config-loader/node_modules/json-schema-traverse": {
+            "version": "1.0.0",
+            "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+            "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/@secretlint/core": {
+            "version": "10.2.2",
+            "resolved": "https://registry.npmjs.org/@secretlint/core/-/core-10.2.2.tgz",
+            "integrity": "sha512-6rdwBwLP9+TO3rRjMVW1tX+lQeo5gBbxl1I5F8nh8bgGtKwdlCMhMKsBWzWg1ostxx/tIG7OjZI0/BxsP8bUgw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@secretlint/profiler": "^10.2.2",
+                "@secretlint/types": "^10.2.2",
+                "debug": "^4.4.1",
+                "structured-source": "^4.0.0"
+            },
+            "engines": {
+                "node": ">=20.0.0"
+            }
+        },
+        "node_modules/@secretlint/formatter": {
+            "version": "10.2.2",
+            "resolved": "https://registry.npmjs.org/@secretlint/formatter/-/formatter-10.2.2.tgz",
+            "integrity": "sha512-10f/eKV+8YdGKNQmoDUD1QnYL7TzhI2kzyx95vsJKbEa8akzLAR5ZrWIZ3LbcMmBLzxlSQMMccRmi05yDQ5YDA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@secretlint/resolver": "^10.2.2",
+                "@secretlint/types": "^10.2.2",
+                "@textlint/linter-formatter": "^15.2.0",
+                "@textlint/module-interop": "^15.2.0",
+                "@textlint/types": "^15.2.0",
+                "chalk": "^5.4.1",
+                "debug": "^4.4.1",
+                "pluralize": "^8.0.0",
+                "strip-ansi": "^7.1.0",
+                "table": "^6.9.0",
+                "terminal-link": "^4.0.0"
+            },
+            "engines": {
+                "node": ">=20.0.0"
+            }
+        },
+        "node_modules/@secretlint/formatter/node_modules/chalk": {
+            "version": "5.5.0",
+            "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.5.0.tgz",
+            "integrity": "sha512-1tm8DTaJhPBG3bIkVeZt1iZM9GfSX2lzOeDVZH9R9ffRHpmHvxZ/QhgQH/aDTkswQVt+YHdXAdS/In/30OjCbg==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": "^12.17.0 || ^14.13 || >=16.0.0"
+            },
+            "funding": {
+                "url": "https://github.com/chalk/chalk?sponsor=1"
+            }
+        },
+        "node_modules/@secretlint/node": {
+            "version": "10.2.2",
+            "resolved": "https://registry.npmjs.org/@secretlint/node/-/node-10.2.2.tgz",
+            "integrity": "sha512-eZGJQgcg/3WRBwX1bRnss7RmHHK/YlP/l7zOQsrjexYt6l+JJa5YhUmHbuGXS94yW0++3YkEJp0kQGYhiw1DMQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@secretlint/config-loader": "^10.2.2",
+                "@secretlint/core": "^10.2.2",
+                "@secretlint/formatter": "^10.2.2",
+                "@secretlint/profiler": "^10.2.2",
+                "@secretlint/source-creator": "^10.2.2",
+                "@secretlint/types": "^10.2.2",
+                "debug": "^4.4.1",
+                "p-map": "^7.0.3"
+            },
+            "engines": {
+                "node": ">=20.0.0"
+            }
+        },
+        "node_modules/@secretlint/profiler": {
+            "version": "10.2.2",
+            "resolved": "https://registry.npmjs.org/@secretlint/profiler/-/profiler-10.2.2.tgz",
+            "integrity": "sha512-qm9rWfkh/o8OvzMIfY8a5bCmgIniSpltbVlUVl983zDG1bUuQNd1/5lUEeWx5o/WJ99bXxS7yNI4/KIXfHexig==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/@secretlint/resolver": {
+            "version": "10.2.2",
+            "resolved": "https://registry.npmjs.org/@secretlint/resolver/-/resolver-10.2.2.tgz",
+            "integrity": "sha512-3md0cp12e+Ae5V+crPQYGd6aaO7ahw95s28OlULGyclyyUtf861UoRGS2prnUrKh7MZb23kdDOyGCYb9br5e4w==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/@secretlint/secretlint-formatter-sarif": {
+            "version": "10.2.2",
+            "resolved": "https://registry.npmjs.org/@secretlint/secretlint-formatter-sarif/-/secretlint-formatter-sarif-10.2.2.tgz",
+            "integrity": "sha512-ojiF9TGRKJJw308DnYBucHxkpNovDNu1XvPh7IfUp0A12gzTtxuWDqdpuVezL7/IP8Ua7mp5/VkDMN9OLp1doQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "node-sarif-builder": "^3.2.0"
+            }
+        },
+        "node_modules/@secretlint/secretlint-rule-no-dotenv": {
+            "version": "10.2.2",
+            "resolved": "https://registry.npmjs.org/@secretlint/secretlint-rule-no-dotenv/-/secretlint-rule-no-dotenv-10.2.2.tgz",
+            "integrity": "sha512-KJRbIShA9DVc5Va3yArtJ6QDzGjg3PRa1uYp9As4RsyKtKSSZjI64jVca57FZ8gbuk4em0/0Jq+uy6485wxIdg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@secretlint/types": "^10.2.2"
+            },
+            "engines": {
+                "node": ">=20.0.0"
+            }
+        },
+        "node_modules/@secretlint/secretlint-rule-preset-recommend": {
+            "version": "10.2.2",
+            "resolved": "https://registry.npmjs.org/@secretlint/secretlint-rule-preset-recommend/-/secretlint-rule-preset-recommend-10.2.2.tgz",
+            "integrity": "sha512-K3jPqjva8bQndDKJqctnGfwuAxU2n9XNCPtbXVI5JvC7FnQiNg/yWlQPbMUlBXtBoBGFYp08A94m6fvtc9v+zA==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=20.0.0"
+            }
+        },
+        "node_modules/@secretlint/source-creator": {
+            "version": "10.2.2",
+            "resolved": "https://registry.npmjs.org/@secretlint/source-creator/-/source-creator-10.2.2.tgz",
+            "integrity": "sha512-h6I87xJfwfUTgQ7irWq7UTdq/Bm1RuQ/fYhA3dtTIAop5BwSFmZyrchph4WcoEvbN460BWKmk4RYSvPElIIvxw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@secretlint/types": "^10.2.2",
+                "istextorbinary": "^9.5.0"
+            },
+            "engines": {
+                "node": ">=20.0.0"
+            }
+        },
+        "node_modules/@secretlint/types": {
+            "version": "10.2.2",
+            "resolved": "https://registry.npmjs.org/@secretlint/types/-/types-10.2.2.tgz",
+            "integrity": "sha512-Nqc90v4lWCXyakD6xNyNACBJNJ0tNCwj2WNk/7ivyacYHxiITVgmLUFXTBOeCdy79iz6HtN9Y31uw/jbLrdOAg==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=20.0.0"
+            }
+        },
+        "node_modules/@sindresorhus/merge-streams": {
+            "version": "2.3.0",
+            "resolved": "https://registry.npmjs.org/@sindresorhus/merge-streams/-/merge-streams-2.3.0.tgz",
+            "integrity": "sha512-LtoMMhxAlorcGhmFYI+LhPgbPZCkgP6ra1YL604EeF6U98pLlQ3iWIGMdWSC+vWmPBWBNgmDBAhnAobLROJmwg==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=18"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
         "node_modules/@stylistic/eslint-plugin": {
             "version": "4.1.0",
             "resolved": "https://registry.npmjs.org/@stylistic/eslint-plugin/-/eslint-plugin-4.1.0.tgz",
@@ -984,6 +1237,136 @@
                 "eslint": ">=9.0.0"
             }
         },
+        "node_modules/@textlint/ast-node-types": {
+            "version": "15.2.1",
+            "resolved": "https://registry.npmjs.org/@textlint/ast-node-types/-/ast-node-types-15.2.1.tgz",
+            "integrity": "sha512-20fEcLPsXg81yWpApv4FQxrZmlFF/Ta7/kz1HGIL+pJo5cSTmkc+eCki3GpOPZIoZk0tbJU8hrlwUb91F+3SNQ==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/@textlint/linter-formatter": {
+            "version": "15.2.1",
+            "resolved": "https://registry.npmjs.org/@textlint/linter-formatter/-/linter-formatter-15.2.1.tgz",
+            "integrity": "sha512-oollG/BHa07+mMt372amxHohteASC+Zxgollc1sZgiyxo4S6EuureV3a4QIQB0NecA+Ak3d0cl0WI/8nou38jw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@azu/format-text": "^1.0.2",
+                "@azu/style-format": "^1.0.1",
+                "@textlint/module-interop": "15.2.1",
+                "@textlint/resolver": "15.2.1",
+                "@textlint/types": "15.2.1",
+                "chalk": "^4.1.2",
+                "debug": "^4.4.1",
+                "js-yaml": "^3.14.1",
+                "lodash": "^4.17.21",
+                "pluralize": "^2.0.0",
+                "string-width": "^4.2.3",
+                "strip-ansi": "^6.0.1",
+                "table": "^6.9.0",
+                "text-table": "^0.2.0"
+            }
+        },
+        "node_modules/@textlint/linter-formatter/node_modules/ansi-regex": {
+            "version": "5.0.1",
+            "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+            "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=8"
+            }
+        },
+        "node_modules/@textlint/linter-formatter/node_modules/argparse": {
+            "version": "1.0.10",
+            "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz",
+            "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "sprintf-js": "~1.0.2"
+            }
+        },
+        "node_modules/@textlint/linter-formatter/node_modules/emoji-regex": {
+            "version": "8.0.0",
+            "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+            "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/@textlint/linter-formatter/node_modules/js-yaml": {
+            "version": "3.14.1",
+            "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz",
+            "integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "argparse": "^1.0.7",
+                "esprima": "^4.0.0"
+            },
+            "bin": {
+                "js-yaml": "bin/js-yaml.js"
+            }
+        },
+        "node_modules/@textlint/linter-formatter/node_modules/pluralize": {
+            "version": "2.0.0",
+            "resolved": "https://registry.npmjs.org/pluralize/-/pluralize-2.0.0.tgz",
+            "integrity": "sha512-TqNZzQCD4S42De9IfnnBvILN7HAW7riLqsCyp8lgjXeysyPlX5HhqKAcJHHHb9XskE4/a+7VGC9zzx8Ls0jOAw==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/@textlint/linter-formatter/node_modules/string-width": {
+            "version": "4.2.3",
+            "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+            "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "emoji-regex": "^8.0.0",
+                "is-fullwidth-code-point": "^3.0.0",
+                "strip-ansi": "^6.0.1"
+            },
+            "engines": {
+                "node": ">=8"
+            }
+        },
+        "node_modules/@textlint/linter-formatter/node_modules/strip-ansi": {
+            "version": "6.0.1",
+            "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+            "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "ansi-regex": "^5.0.1"
+            },
+            "engines": {
+                "node": ">=8"
+            }
+        },
+        "node_modules/@textlint/module-interop": {
+            "version": "15.2.1",
+            "resolved": "https://registry.npmjs.org/@textlint/module-interop/-/module-interop-15.2.1.tgz",
+            "integrity": "sha512-b/C/ZNrm05n1ypymDknIcpkBle30V2ZgE3JVqQlA9PnQV46Ky510qrZk6s9yfKgA3m1YRnAw04m8xdVtqjq1qg==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/@textlint/resolver": {
+            "version": "15.2.1",
+            "resolved": "https://registry.npmjs.org/@textlint/resolver/-/resolver-15.2.1.tgz",
+            "integrity": "sha512-FY3aK4tElEcOJVUsaMj4Zro4jCtKEEwUMIkDL0tcn6ljNcgOF7Em+KskRRk/xowFWayqDtdz5T3u7w/6fjjuJQ==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/@textlint/types": {
+            "version": "15.2.1",
+            "resolved": "https://registry.npmjs.org/@textlint/types/-/types-15.2.1.tgz",
+            "integrity": "sha512-zyqNhSatK1cwxDUgosEEN43hFh3WCty9Zm2Vm3ogU566IYegifwqN54ey/CiRy/DiO4vMcFHykuQnh2Zwp6LLw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@textlint/ast-node-types": "15.2.1"
+            }
+        },
         "node_modules/@tsconfig/strictest": {
             "version": "2.0.5",
             "resolved": "https://registry.npmjs.org/@tsconfig/strictest/-/strictest-2.0.5.tgz",
@@ -1015,6 +1398,20 @@
                 "undici-types": "~6.20.0"
             }
         },
+        "node_modules/@types/normalize-package-data": {
+            "version": "2.4.4",
+            "resolved": "https://registry.npmjs.org/@types/normalize-package-data/-/normalize-package-data-2.4.4.tgz",
+            "integrity": "sha512-37i+OaWTh9qeK4LSHPsyRC7NahnGotNuZvjLSgcPzblpHB3rrCJxAOgI5gCdKm7coonsaX1Of0ILiTcnZjbfxA==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/@types/sarif": {
+            "version": "2.1.7",
+            "resolved": "https://registry.npmjs.org/@types/sarif/-/sarif-2.1.7.tgz",
+            "integrity": "sha512-kRz0VEkJqWLf1LLVN4pT1cg1Z9wAuvI6L97V3m2f5B76Tg8d413ddvLBPTEHAZJlnn4XSvu0FkZtViCQGVyrXQ==",
+            "dev": true,
+            "license": "MIT"
+        },
         "node_modules/@types/vscode": {
             "version": "1.93.0",
             "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.93.0.tgz",
@@ -1220,16 +1617,20 @@
             }
         },
         "node_modules/@vscode/vsce": {
-            "version": "3.2.2",
-            "resolved": "https://registry.npmjs.org/@vscode/vsce/-/vsce-3.2.2.tgz",
-            "integrity": "sha512-4TqdUq/yKlQTHcQMk/DamR632bq/+IJDomSbexOMee/UAYWqYm0XHWA6scGslsCpzY+sCWEhhl0nqdOB0XW1kw==",
+            "version": "3.6.0",
+            "resolved": "https://registry.npmjs.org/@vscode/vsce/-/vsce-3.6.0.tgz",
+            "integrity": "sha512-u2ZoMfymRNJb14aHNawnXJtXHLXDVKc1oKZaH4VELKT/9iWKRVgtQOdwxCgtwSxJoqYvuK4hGlBWQJ05wxADhg==",
             "dev": true,
             "license": "MIT",
             "dependencies": {
                 "@azure/identity": "^4.1.0",
+                "@secretlint/node": "^10.1.1",
+                "@secretlint/secretlint-formatter-sarif": "^10.1.1",
+                "@secretlint/secretlint-rule-no-dotenv": "^10.1.1",
+                "@secretlint/secretlint-rule-preset-recommend": "^10.1.1",
                 "@vscode/vsce-sign": "^2.0.0",
                 "azure-devops-node-api": "^12.5.0",
-                "chalk": "^2.4.2",
+                "chalk": "^4.1.2",
                 "cheerio": "^1.0.0-rc.9",
                 "cockatiel": "^3.1.2",
                 "commander": "^12.1.0",
@@ -1243,6 +1644,7 @@
                 "minimatch": "^3.0.3",
                 "parse-semver": "^1.1.1",
                 "read": "^1.0.7",
+                "secretlint": "^10.1.1",
                 "semver": "^7.5.2",
                 "tmp": "^0.2.3",
                 "typed-rest-client": "^1.8.4",
@@ -1486,6 +1888,22 @@
             "integrity": "sha512-PMqBCBvrOVDRqLGooQb+z+t1Q0PiPyurUQeZRR5uHBOVZcW8B04KMmnT12USnhpNX2wCPagWzLVppQMUG3u0Dw==",
             "license": "MIT"
         },
+        "node_modules/ansi-escapes": {
+            "version": "7.0.0",
+            "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-7.0.0.tgz",
+            "integrity": "sha512-GdYO7a61mR0fOlAsvC9/rIHf7L96sBc6dEWzeOu+KAea5bZyQRPIpojrVoI4AXGJS/ycu/fBTdLrUkA4ODrvjw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "environment": "^1.0.0"
+            },
+            "engines": {
+                "node": ">=18"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
         "node_modules/ansi-regex": {
             "version": "6.1.0",
             "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz",
@@ -1500,16 +1918,18 @@
             }
         },
         "node_modules/ansi-styles": {
-            "version": "3.2.1",
-            "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
-            "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
-            "dev": true,
+            "version": "4.3.0",
+            "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+            "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
             "license": "MIT",
             "dependencies": {
-                "color-convert": "^1.9.0"
+                "color-convert": "^2.0.1"
             },
             "engines": {
-                "node": ">=4"
+                "node": ">=8"
+            },
+            "funding": {
+                "url": "https://github.com/chalk/ansi-styles?sponsor=1"
             }
         },
         "node_modules/argparse": {
@@ -1519,6 +1939,16 @@
             "dev": true,
             "license": "Python-2.0"
         },
+        "node_modules/astral-regex": {
+            "version": "2.0.0",
+            "resolved": "https://registry.npmjs.org/astral-regex/-/astral-regex-2.0.0.tgz",
+            "integrity": "sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=8"
+            }
+        },
         "node_modules/asynckit": {
             "version": "0.4.0",
             "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
@@ -1564,6 +1994,22 @@
             ],
             "license": "MIT"
         },
+        "node_modules/binaryextensions": {
+            "version": "6.11.0",
+            "resolved": "https://registry.npmjs.org/binaryextensions/-/binaryextensions-6.11.0.tgz",
+            "integrity": "sha512-sXnYK/Ij80TO3lcqZVV2YgfKN5QjUWIRk/XSm2J/4bd/lPko3lvk0O4ZppH6m+6hB2/GTu+ptNwVFe1xh+QLQw==",
+            "dev": true,
+            "license": "Artistic-2.0",
+            "dependencies": {
+                "editions": "^6.21.0"
+            },
+            "engines": {
+                "node": ">=4"
+            },
+            "funding": {
+                "url": "https://bevry.me/fund"
+            }
+        },
         "node_modules/bl": {
             "version": "5.1.0",
             "resolved": "https://registry.npmjs.org/bl/-/bl-5.1.0.tgz",
@@ -1598,6 +2044,13 @@
             "dev": true,
             "license": "ISC"
         },
+        "node_modules/boundary": {
+            "version": "2.0.0",
+            "resolved": "https://registry.npmjs.org/boundary/-/boundary-2.0.0.tgz",
+            "integrity": "sha512-rJKn5ooC9u8q13IMCrW0RSp31pxBCHE3y9V/tp3TdWSLf8Em3p6Di4NBpfzbJge9YjjFEsD0RtFEjtvHL5VyEA==",
+            "dev": true,
+            "license": "BSD-2-Clause"
+        },
         "node_modules/brace-expansion": {
             "version": "2.0.2",
             "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
@@ -1720,18 +2173,20 @@
             }
         },
         "node_modules/chalk": {
-            "version": "2.4.2",
-            "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
-            "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
-            "dev": true,
+            "version": "4.1.2",
+            "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+            "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+            "dev": true,
             "license": "MIT",
             "dependencies": {
-                "ansi-styles": "^3.2.1",
-                "escape-string-regexp": "^1.0.5",
-                "supports-color": "^5.3.0"
+                "ansi-styles": "^4.1.0",
+                "supports-color": "^7.1.0"
             },
             "engines": {
-                "node": ">=4"
+                "node": ">=10"
+            },
+            "funding": {
+                "url": "https://github.com/chalk/chalk?sponsor=1"
             }
         },
         "node_modules/cheerio": {
@@ -1845,39 +2300,6 @@
                 "node": ">=8"
             }
         },
-        "node_modules/cliui/node_modules/ansi-styles": {
-            "version": "4.3.0",
-            "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-            "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-            "license": "MIT",
-            "dependencies": {
-                "color-convert": "^2.0.1"
-            },
-            "engines": {
-                "node": ">=8"
-            },
-            "funding": {
-                "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-            }
-        },
-        "node_modules/cliui/node_modules/color-convert": {
-            "version": "2.0.1",
-            "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
-            "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
-            "license": "MIT",
-            "dependencies": {
-                "color-name": "~1.1.4"
-            },
-            "engines": {
-                "node": ">=7.0.0"
-            }
-        },
-        "node_modules/cliui/node_modules/color-name": {
-            "version": "1.1.4",
-            "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
-            "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
-            "license": "MIT"
-        },
         "node_modules/cliui/node_modules/emoji-regex": {
             "version": "8.0.0",
             "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
@@ -1938,20 +2360,21 @@
             }
         },
         "node_modules/color-convert": {
-            "version": "1.9.3",
-            "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
-            "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
-            "dev": true,
+            "version": "2.0.1",
+            "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+            "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
             "license": "MIT",
             "dependencies": {
-                "color-name": "1.1.3"
+                "color-name": "~1.1.4"
+            },
+            "engines": {
+                "node": ">=7.0.0"
             }
         },
         "node_modules/color-name": {
-            "version": "1.1.3",
-            "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
-            "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==",
-            "dev": true,
+            "version": "1.1.4",
+            "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+            "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
             "license": "MIT"
         },
         "node_modules/combined-stream": {
@@ -2469,9 +2892,9 @@
             }
         },
         "node_modules/debug": {
-            "version": "4.4.0",
-            "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz",
-            "integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==",
+            "version": "4.4.1",
+            "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+            "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
             "dev": true,
             "license": "MIT",
             "dependencies": {
@@ -2685,6 +3108,23 @@
                 "safe-buffer": "^5.0.1"
             }
         },
+        "node_modules/editions": {
+            "version": "6.22.0",
+            "resolved": "https://registry.npmjs.org/editions/-/editions-6.22.0.tgz",
+            "integrity": "sha512-UgGlf8IW75je7HZjNDpJdCv4cGJWIi6yumFdZ0R7A8/CIhQiWUjyGLCxdHpd8bmyD1gnkfUNK0oeOXqUS2cpfQ==",
+            "dev": true,
+            "license": "Artistic-2.0",
+            "dependencies": {
+                "version-range": "^4.15.0"
+            },
+            "engines": {
+                "ecmascript": ">= es5",
+                "node": ">=4"
+            },
+            "funding": {
+                "url": "https://bevry.me/fund"
+            }
+        },
         "node_modules/emoji-regex": {
             "version": "9.2.2",
             "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz",
@@ -2730,6 +3170,19 @@
                 "url": "https://github.com/fb55/entities?sponsor=1"
             }
         },
+        "node_modules/environment": {
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/environment/-/environment-1.1.0.tgz",
+            "integrity": "sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=18"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
         "node_modules/es-define-property": {
             "version": "1.0.1",
             "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
@@ -2829,16 +3282,6 @@
                 "node": ">=6"
             }
         },
-        "node_modules/escape-string-regexp": {
-            "version": "1.0.5",
-            "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
-            "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==",
-            "dev": true,
-            "license": "MIT",
-            "engines": {
-                "node": ">=0.8.0"
-            }
-        },
         "node_modules/eslint": {
             "version": "9.21.0",
             "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.21.0.tgz",
@@ -2964,22 +3407,6 @@
                 "url": "https://opencollective.com/eslint"
             }
         },
-        "node_modules/eslint/node_modules/ansi-styles": {
-            "version": "4.3.0",
-            "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-            "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-            "dev": true,
-            "license": "MIT",
-            "dependencies": {
-                "color-convert": "^2.0.1"
-            },
-            "engines": {
-                "node": ">=8"
-            },
-            "funding": {
-                "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-            }
-        },
         "node_modules/eslint/node_modules/brace-expansion": {
             "version": "1.1.12",
             "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
@@ -2991,43 +3418,6 @@
                 "concat-map": "0.0.1"
             }
         },
-        "node_modules/eslint/node_modules/chalk": {
-            "version": "4.1.2",
-            "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
-            "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
-            "dev": true,
-            "license": "MIT",
-            "dependencies": {
-                "ansi-styles": "^4.1.0",
-                "supports-color": "^7.1.0"
-            },
-            "engines": {
-                "node": ">=10"
-            },
-            "funding": {
-                "url": "https://github.com/chalk/chalk?sponsor=1"
-            }
-        },
-        "node_modules/eslint/node_modules/color-convert": {
-            "version": "2.0.1",
-            "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
-            "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
-            "dev": true,
-            "license": "MIT",
-            "dependencies": {
-                "color-name": "~1.1.4"
-            },
-            "engines": {
-                "node": ">=7.0.0"
-            }
-        },
-        "node_modules/eslint/node_modules/color-name": {
-            "version": "1.1.4",
-            "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
-            "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
-            "dev": true,
-            "license": "MIT"
-        },
         "node_modules/eslint/node_modules/escape-string-regexp": {
             "version": "4.0.0",
             "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
@@ -3041,16 +3431,6 @@
                 "url": "https://github.com/sponsors/sindresorhus"
             }
         },
-        "node_modules/eslint/node_modules/has-flag": {
-            "version": "4.0.0",
-            "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
-            "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
-            "dev": true,
-            "license": "MIT",
-            "engines": {
-                "node": ">=8"
-            }
-        },
         "node_modules/eslint/node_modules/minimatch": {
             "version": "3.1.2",
             "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
@@ -3064,19 +3444,6 @@
                 "node": "*"
             }
         },
-        "node_modules/eslint/node_modules/supports-color": {
-            "version": "7.2.0",
-            "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
-            "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
-            "dev": true,
-            "license": "MIT",
-            "dependencies": {
-                "has-flag": "^4.0.0"
-            },
-            "engines": {
-                "node": ">=8"
-            }
-        },
         "node_modules/espree": {
             "version": "10.3.0",
             "resolved": "https://registry.npmjs.org/espree/-/espree-10.3.0.tgz",
@@ -3095,6 +3462,20 @@
                 "url": "https://opencollective.com/eslint"
             }
         },
+        "node_modules/esprima": {
+            "version": "4.0.1",
+            "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
+            "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
+            "dev": true,
+            "license": "BSD-2-Clause",
+            "bin": {
+                "esparse": "bin/esparse.js",
+                "esvalidate": "bin/esvalidate.js"
+            },
+            "engines": {
+                "node": ">=4"
+            }
+        },
         "node_modules/esquery": {
             "version": "1.6.0",
             "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.6.0.tgz",
@@ -3213,6 +3594,23 @@
             "dev": true,
             "license": "MIT"
         },
+        "node_modules/fast-uri": {
+            "version": "3.0.6",
+            "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.0.6.tgz",
+            "integrity": "sha512-Atfo14OibSv5wAp4VWNsFYE1AchQRTv9cBGWET4pZWHzYshFSS9NQI6I57rdKn9croWVMbYFbLhJ+yJvmZIIHw==",
+            "dev": true,
+            "funding": [
+                {
+                    "type": "github",
+                    "url": "https://github.com/sponsors/fastify"
+                },
+                {
+                    "type": "opencollective",
+                    "url": "https://opencollective.com/fastify"
+                }
+            ],
+            "license": "BSD-3-Clause"
+        },
         "node_modules/fastq": {
             "version": "1.19.0",
             "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.19.0.tgz",
@@ -3360,6 +3758,21 @@
             "license": "MIT",
             "optional": true
         },
+        "node_modules/fs-extra": {
+            "version": "11.3.1",
+            "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.1.tgz",
+            "integrity": "sha512-eXvGGwZ5CL17ZSwHWd3bbgk7UUpF6IFHtP57NYYakPvHOs8GDgDe5KJI36jIJzDkJ6eJjuzRA8eBQb6SkKue0g==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "graceful-fs": "^4.2.0",
+                "jsonfile": "^6.0.1",
+                "universalify": "^2.0.0"
+            },
+            "engines": {
+                "node": ">=14.14"
+            }
+        },
         "node_modules/function-bind": {
             "version": "1.1.2",
             "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
@@ -3492,6 +3905,37 @@
                 "url": "https://github.com/sponsors/sindresorhus"
             }
         },
+        "node_modules/globby": {
+            "version": "14.1.0",
+            "resolved": "https://registry.npmjs.org/globby/-/globby-14.1.0.tgz",
+            "integrity": "sha512-0Ia46fDOaT7k4og1PDW4YbodWWr3scS2vAr2lTbsplOt2WkKp0vQbkI9wKis/T5LV/dqPjO3bpS/z6GTJB82LA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@sindresorhus/merge-streams": "^2.1.0",
+                "fast-glob": "^3.3.3",
+                "ignore": "^7.0.3",
+                "path-type": "^6.0.0",
+                "slash": "^5.1.0",
+                "unicorn-magic": "^0.3.0"
+            },
+            "engines": {
+                "node": ">=18"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
+        "node_modules/globby/node_modules/ignore": {
+            "version": "7.0.5",
+            "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.5.tgz",
+            "integrity": "sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 4"
+            }
+        },
         "node_modules/gopd": {
             "version": "1.2.0",
             "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
@@ -3505,6 +3949,13 @@
                 "url": "https://github.com/sponsors/ljharb"
             }
         },
+        "node_modules/graceful-fs": {
+            "version": "4.2.11",
+            "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
+            "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
+            "dev": true,
+            "license": "ISC"
+        },
         "node_modules/graphemer": {
             "version": "1.4.0",
             "resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz",
@@ -3513,13 +3964,13 @@
             "license": "MIT"
         },
         "node_modules/has-flag": {
-            "version": "3.0.0",
-            "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
-            "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==",
+            "version": "4.0.0",
+            "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+            "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
             "dev": true,
             "license": "MIT",
             "engines": {
-                "node": ">=4"
+                "node": ">=8"
             }
         },
         "node_modules/has-symbols": {
@@ -3702,6 +4153,19 @@
                 "node": ">=0.8.19"
             }
         },
+        "node_modules/index-to-position": {
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/index-to-position/-/index-to-position-1.1.0.tgz",
+            "integrity": "sha512-XPdx9Dq4t9Qk1mTMbWONJqU7boCoumEH7fRET37HX5+khDUl3J2W6PdALxhILYlIYx2amlwYcRPp28p0tSiojg==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=18"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
         "node_modules/inherits": {
             "version": "2.0.4",
             "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
@@ -3872,6 +4336,24 @@
             "dev": true,
             "license": "ISC"
         },
+        "node_modules/istextorbinary": {
+            "version": "9.5.0",
+            "resolved": "https://registry.npmjs.org/istextorbinary/-/istextorbinary-9.5.0.tgz",
+            "integrity": "sha512-5mbUj3SiZXCuRf9fT3ibzbSSEWiy63gFfksmGfdOzujPjW3k+z8WvIBxcJHBoQNlaZaiyB25deviif2+osLmLw==",
+            "dev": true,
+            "license": "Artistic-2.0",
+            "dependencies": {
+                "binaryextensions": "^6.11.0",
+                "editions": "^6.21.0",
+                "textextensions": "^6.11.0"
+            },
+            "engines": {
+                "node": ">=4"
+            },
+            "funding": {
+                "url": "https://bevry.me/fund"
+            }
+        },
         "node_modules/jackspeak": {
             "version": "4.1.0",
             "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-4.1.0.tgz",
@@ -3897,6 +4379,13 @@
                 "jiti": "lib/jiti-cli.mjs"
             }
         },
+        "node_modules/js-tokens": {
+            "version": "4.0.0",
+            "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+            "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+            "dev": true,
+            "license": "MIT"
+        },
         "node_modules/js-yaml": {
             "version": "4.1.0",
             "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
@@ -3931,6 +4420,19 @@
             "dev": true,
             "license": "MIT"
         },
+        "node_modules/json5": {
+            "version": "2.2.3",
+            "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+            "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+            "dev": true,
+            "license": "MIT",
+            "bin": {
+                "json5": "lib/cli.js"
+            },
+            "engines": {
+                "node": ">=6"
+            }
+        },
         "node_modules/jsonc-parser": {
             "version": "3.3.1",
             "resolved": "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-3.3.1.tgz",
@@ -3938,6 +4440,19 @@
             "dev": true,
             "license": "MIT"
         },
+        "node_modules/jsonfile": {
+            "version": "6.2.0",
+            "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz",
+            "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "universalify": "^2.0.0"
+            },
+            "optionalDependencies": {
+                "graceful-fs": "^4.1.6"
+            }
+        },
         "node_modules/jsonwebtoken": {
             "version": "9.0.2",
             "resolved": "https://registry.npmjs.org/jsonwebtoken/-/jsonwebtoken-9.0.2.tgz",
@@ -4103,6 +4618,13 @@
                 "url": "https://github.com/sponsors/sindresorhus"
             }
         },
+        "node_modules/lodash": {
+            "version": "4.17.21",
+            "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
+            "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==",
+            "dev": true,
+            "license": "MIT"
+        },
         "node_modules/lodash.includes": {
             "version": "4.3.0",
             "resolved": "https://registry.npmjs.org/lodash.includes/-/lodash.includes-4.3.0.tgz",
@@ -4159,6 +4681,13 @@
             "dev": true,
             "license": "MIT"
         },
+        "node_modules/lodash.truncate": {
+            "version": "4.4.2",
+            "resolved": "https://registry.npmjs.org/lodash.truncate/-/lodash.truncate-4.4.2.tgz",
+            "integrity": "sha512-jttmRe7bRse52OsWIMDLaXxWqRAmtIUccAQ3garviCqJjafXOfNMO0yMfNpdD6zbGaTU0P5Nz7e7gAT6cKmJRw==",
+            "dev": true,
+            "license": "MIT"
+        },
         "node_modules/log-symbols": {
             "version": "5.1.0",
             "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-5.1.0.tgz",
@@ -4430,12 +4959,61 @@
             "license": "MIT",
             "optional": true
         },
-        "node_modules/nth-check": {
-            "version": "2.1.1",
-            "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz",
-            "integrity": "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==",
+        "node_modules/node-sarif-builder": {
+            "version": "3.2.0",
+            "resolved": "https://registry.npmjs.org/node-sarif-builder/-/node-sarif-builder-3.2.0.tgz",
+            "integrity": "sha512-kVIOdynrF2CRodHZeP/97Rh1syTUHBNiw17hUCIVhlhEsWlfJm19MuO56s4MdKbr22xWx6mzMnNAgXzVlIYM9Q==",
             "dev": true,
-            "license": "BSD-2-Clause",
+            "license": "MIT",
+            "dependencies": {
+                "@types/sarif": "^2.1.7",
+                "fs-extra": "^11.1.1"
+            },
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/normalize-package-data": {
+            "version": "6.0.2",
+            "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-6.0.2.tgz",
+            "integrity": "sha512-V6gygoYb/5EmNI+MEGrWkC+e6+Rr7mTmfHrxDbLzxQogBkgzo76rkok0Am6thgSF7Mv2nLOajAJj5vDJZEFn7g==",
+            "dev": true,
+            "license": "BSD-2-Clause",
+            "dependencies": {
+                "hosted-git-info": "^7.0.0",
+                "semver": "^7.3.5",
+                "validate-npm-package-license": "^3.0.4"
+            },
+            "engines": {
+                "node": "^16.14.0 || >=18.0.0"
+            }
+        },
+        "node_modules/normalize-package-data/node_modules/hosted-git-info": {
+            "version": "7.0.2",
+            "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-7.0.2.tgz",
+            "integrity": "sha512-puUZAUKT5m8Zzvs72XWy3HtvVbTWljRE66cP60bxJzAqf2DgICo7lYTY2IHUmLnNpjYvw5bvmoHvPc0QO2a62w==",
+            "dev": true,
+            "license": "ISC",
+            "dependencies": {
+                "lru-cache": "^10.0.1"
+            },
+            "engines": {
+                "node": "^16.14.0 || >=18.0.0"
+            }
+        },
+        "node_modules/normalize-package-data/node_modules/lru-cache": {
+            "version": "10.4.3",
+            "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
+            "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
+            "dev": true,
+            "license": "ISC"
+        },
+        "node_modules/nth-check": {
+            "version": "2.1.1",
+            "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz",
+            "integrity": "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==",
+            "dev": true,
+            "license": "BSD-2-Clause",
             "dependencies": {
                 "boolbase": "^1.0.0"
             },
@@ -4661,6 +5239,19 @@
                 "url": "https://github.com/sponsors/sindresorhus"
             }
         },
+        "node_modules/p-map": {
+            "version": "7.0.3",
+            "resolved": "https://registry.npmjs.org/p-map/-/p-map-7.0.3.tgz",
+            "integrity": "sha512-VkndIv2fIB99swvQoA65bm+fsmt6UNdGeIB0oxBs+WhAhdh08QA04JXpI7rbB9r08/nkbysKoya9rtDERYOYMA==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=18"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
         "node_modules/package-json-from-dist": {
             "version": "1.0.1",
             "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz",
@@ -4688,6 +5279,24 @@
                 "node": ">=6"
             }
         },
+        "node_modules/parse-json": {
+            "version": "8.3.0",
+            "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-8.3.0.tgz",
+            "integrity": "sha512-ybiGyvspI+fAoRQbIPRddCcSTV9/LsJbf0e/S85VLowVGzRmokfneg2kwVW/KU5rOXrPSbF1qAKPMgNTqqROQQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@babel/code-frame": "^7.26.2",
+                "index-to-position": "^1.1.0",
+                "type-fest": "^4.39.1"
+            },
+            "engines": {
+                "node": ">=18"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
         "node_modules/parse-semver": {
             "version": "1.1.1",
             "resolved": "https://registry.npmjs.org/parse-semver/-/parse-semver-1.1.1.tgz",
@@ -4795,6 +5404,19 @@
                 "node": "20 || >=22"
             }
         },
+        "node_modules/path-type": {
+            "version": "6.0.0",
+            "resolved": "https://registry.npmjs.org/path-type/-/path-type-6.0.0.tgz",
+            "integrity": "sha512-Vj7sf++t5pBD637NSfkxpHSMfWaeig5+DKWLhcqIYx6mWQz5hdJTGDVMQiJcw1ZYkhs7AazKDGpRVji1LJCZUQ==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=18"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
         "node_modules/pend": {
             "version": "1.2.0",
             "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz",
@@ -4802,6 +5424,13 @@
             "dev": true,
             "license": "MIT"
         },
+        "node_modules/picocolors": {
+            "version": "1.1.1",
+            "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+            "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+            "dev": true,
+            "license": "ISC"
+        },
         "node_modules/picomatch": {
             "version": "4.0.2",
             "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.2.tgz",
@@ -4815,6 +5444,16 @@
                 "url": "https://github.com/sponsors/jonschlinkert"
             }
         },
+        "node_modules/pluralize": {
+            "version": "8.0.0",
+            "resolved": "https://registry.npmjs.org/pluralize/-/pluralize-8.0.0.tgz",
+            "integrity": "sha512-Nc3IT5yHzflTfbjgqWcCPpo7DaKy4FnpB0l/zCAW0Tc7jxAiuqSxHasntB3D7887LSrA93kDJ9IXovxJYxyLCA==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=4"
+            }
+        },
         "node_modules/prebuild-install": {
             "version": "7.1.3",
             "resolved": "https://registry.npmjs.org/prebuild-install/-/prebuild-install-7.1.3.tgz",
@@ -4962,6 +5601,19 @@
                 "rc": "cli.js"
             }
         },
+        "node_modules/rc-config-loader": {
+            "version": "4.1.3",
+            "resolved": "https://registry.npmjs.org/rc-config-loader/-/rc-config-loader-4.1.3.tgz",
+            "integrity": "sha512-kD7FqML7l800i6pS6pvLyIE2ncbk9Du8Q0gp/4hMPhJU6ZxApkoLcGD8ZeqgiAlfwZ6BlETq6qqe+12DUL207w==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "debug": "^4.3.4",
+                "js-yaml": "^4.1.0",
+                "json5": "^2.2.2",
+                "require-from-string": "^2.0.2"
+            }
+        },
         "node_modules/rc/node_modules/strip-json-comments": {
             "version": "2.0.1",
             "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz",
@@ -4986,6 +5638,39 @@
                 "node": ">=0.8"
             }
         },
+        "node_modules/read-pkg": {
+            "version": "9.0.1",
+            "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-9.0.1.tgz",
+            "integrity": "sha512-9viLL4/n1BJUCT1NXVTdS1jtm80yDEgR5T4yCelII49Mbj0v1rZdKqj7zCiYdbB0CuCgdrvHcNogAKTFPBocFA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@types/normalize-package-data": "^2.4.3",
+                "normalize-package-data": "^6.0.0",
+                "parse-json": "^8.0.0",
+                "type-fest": "^4.6.0",
+                "unicorn-magic": "^0.1.0"
+            },
+            "engines": {
+                "node": ">=18"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
+        "node_modules/read-pkg/node_modules/unicorn-magic": {
+            "version": "0.1.0",
+            "resolved": "https://registry.npmjs.org/unicorn-magic/-/unicorn-magic-0.1.0.tgz",
+            "integrity": "sha512-lRfVq8fE8gz6QMBuDM6a+LO3IAzTi05H6gCVaUpir2E1Rwpo4ZUog45KpNXKC/Mn3Yb9UDuHumeFTo9iV/D9FQ==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=18"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
         "node_modules/readable-stream": {
             "version": "2.3.8",
             "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
@@ -5018,6 +5703,16 @@
                 "node": ">=0.10.0"
             }
         },
+        "node_modules/require-from-string": {
+            "version": "2.0.2",
+            "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
+            "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=0.10.0"
+            }
+        },
         "node_modules/resolve-from": {
             "version": "4.0.0",
             "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
@@ -5146,6 +5841,28 @@
             "dev": true,
             "license": "ISC"
         },
+        "node_modules/secretlint": {
+            "version": "10.2.2",
+            "resolved": "https://registry.npmjs.org/secretlint/-/secretlint-10.2.2.tgz",
+            "integrity": "sha512-xVpkeHV/aoWe4vP4TansF622nBEImzCY73y/0042DuJ29iKIaqgoJ8fGxre3rVSHHbxar4FdJobmTnLp9AU0eg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@secretlint/config-creator": "^10.2.2",
+                "@secretlint/formatter": "^10.2.2",
+                "@secretlint/node": "^10.2.2",
+                "@secretlint/profiler": "^10.2.2",
+                "debug": "^4.4.1",
+                "globby": "^14.1.0",
+                "read-pkg": "^9.0.1"
+            },
+            "bin": {
+                "secretlint": "bin/secretlint.js"
+            },
+            "engines": {
+                "node": ">=20.0.0"
+            }
+        },
         "node_modules/semver": {
             "version": "7.7.1",
             "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.1.tgz",
@@ -5326,6 +6043,80 @@
                 "simple-concat": "^1.0.0"
             }
         },
+        "node_modules/slash": {
+            "version": "5.1.0",
+            "resolved": "https://registry.npmjs.org/slash/-/slash-5.1.0.tgz",
+            "integrity": "sha512-ZA6oR3T/pEyuqwMgAKT0/hAv8oAXckzbkmR0UkUosQ+Mc4RxGoJkRmwHgHufaenlyAgE1Mxgpdcrf75y6XcnDg==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=14.16"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
+        "node_modules/slice-ansi": {
+            "version": "4.0.0",
+            "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-4.0.0.tgz",
+            "integrity": "sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "ansi-styles": "^4.0.0",
+                "astral-regex": "^2.0.0",
+                "is-fullwidth-code-point": "^3.0.0"
+            },
+            "engines": {
+                "node": ">=10"
+            },
+            "funding": {
+                "url": "https://github.com/chalk/slice-ansi?sponsor=1"
+            }
+        },
+        "node_modules/spdx-correct": {
+            "version": "3.2.0",
+            "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.2.0.tgz",
+            "integrity": "sha512-kN9dJbvnySHULIluDHy32WHRUu3Og7B9sbY7tsFLctQkIqnMh3hErYgdMjTYuqmcXX+lK5T1lnUt3G7zNswmZA==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "dependencies": {
+                "spdx-expression-parse": "^3.0.0",
+                "spdx-license-ids": "^3.0.0"
+            }
+        },
+        "node_modules/spdx-exceptions": {
+            "version": "2.5.0",
+            "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.5.0.tgz",
+            "integrity": "sha512-PiU42r+xO4UbUS1buo3LPJkjlO7430Xn5SVAhdpzzsPHsjbYVflnnFdATgabnLude+Cqu25p6N+g2lw/PFsa4w==",
+            "dev": true,
+            "license": "CC-BY-3.0"
+        },
+        "node_modules/spdx-expression-parse": {
+            "version": "3.0.1",
+            "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz",
+            "integrity": "sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "spdx-exceptions": "^2.1.0",
+                "spdx-license-ids": "^3.0.0"
+            }
+        },
+        "node_modules/spdx-license-ids": {
+            "version": "3.0.22",
+            "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.22.tgz",
+            "integrity": "sha512-4PRT4nh1EImPbt2jASOKHX7PB7I+e4IWNLvkKFDxNhJlfjbYlleYQh285Z/3mPTHSAK/AvdMmw5BNNuYH8ShgQ==",
+            "dev": true,
+            "license": "CC0-1.0"
+        },
+        "node_modules/sprintf-js": {
+            "version": "1.0.3",
+            "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz",
+            "integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==",
+            "dev": true,
+            "license": "BSD-3-Clause"
+        },
         "node_modules/stdin-discarder": {
             "version": "0.1.0",
             "resolved": "https://registry.npmjs.org/stdin-discarder/-/stdin-discarder-0.1.0.tgz",
@@ -5487,17 +6278,130 @@
                 "url": "https://github.com/sponsors/sindresorhus"
             }
         },
+        "node_modules/structured-source": {
+            "version": "4.0.0",
+            "resolved": "https://registry.npmjs.org/structured-source/-/structured-source-4.0.0.tgz",
+            "integrity": "sha512-qGzRFNJDjFieQkl/sVOI2dUjHKRyL9dAJi2gCPGJLbJHBIkyOHxjuocpIEfbLioX+qSJpvbYdT49/YCdMznKxA==",
+            "dev": true,
+            "license": "BSD-2-Clause",
+            "dependencies": {
+                "boundary": "^2.0.0"
+            }
+        },
         "node_modules/supports-color": {
-            "version": "5.5.0",
-            "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
-            "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+            "version": "7.2.0",
+            "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+            "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
             "dev": true,
             "license": "MIT",
             "dependencies": {
-                "has-flag": "^3.0.0"
+                "has-flag": "^4.0.0"
             },
             "engines": {
-                "node": ">=4"
+                "node": ">=8"
+            }
+        },
+        "node_modules/supports-hyperlinks": {
+            "version": "3.2.0",
+            "resolved": "https://registry.npmjs.org/supports-hyperlinks/-/supports-hyperlinks-3.2.0.tgz",
+            "integrity": "sha512-zFObLMyZeEwzAoKCyu1B91U79K2t7ApXuQfo8OuxwXLDgcKxuwM+YvcbIhm6QWqz7mHUH1TVytR1PwVVjEuMig==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "has-flag": "^4.0.0",
+                "supports-color": "^7.0.0"
+            },
+            "engines": {
+                "node": ">=14.18"
+            },
+            "funding": {
+                "url": "https://github.com/chalk/supports-hyperlinks?sponsor=1"
+            }
+        },
+        "node_modules/table": {
+            "version": "6.9.0",
+            "resolved": "https://registry.npmjs.org/table/-/table-6.9.0.tgz",
+            "integrity": "sha512-9kY+CygyYM6j02t5YFHbNz2FN5QmYGv9zAjVp4lCDjlCw7amdckXlEt/bjMhUIfj4ThGRE4gCUH5+yGnNuPo5A==",
+            "dev": true,
+            "license": "BSD-3-Clause",
+            "dependencies": {
+                "ajv": "^8.0.1",
+                "lodash.truncate": "^4.4.2",
+                "slice-ansi": "^4.0.0",
+                "string-width": "^4.2.3",
+                "strip-ansi": "^6.0.1"
+            },
+            "engines": {
+                "node": ">=10.0.0"
+            }
+        },
+        "node_modules/table/node_modules/ajv": {
+            "version": "8.17.1",
+            "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
+            "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "fast-deep-equal": "^3.1.3",
+                "fast-uri": "^3.0.1",
+                "json-schema-traverse": "^1.0.0",
+                "require-from-string": "^2.0.2"
+            },
+            "funding": {
+                "type": "github",
+                "url": "https://github.com/sponsors/epoberezkin"
+            }
+        },
+        "node_modules/table/node_modules/ansi-regex": {
+            "version": "5.0.1",
+            "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+            "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=8"
+            }
+        },
+        "node_modules/table/node_modules/emoji-regex": {
+            "version": "8.0.0",
+            "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+            "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/table/node_modules/json-schema-traverse": {
+            "version": "1.0.0",
+            "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+            "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/table/node_modules/string-width": {
+            "version": "4.2.3",
+            "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+            "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "emoji-regex": "^8.0.0",
+                "is-fullwidth-code-point": "^3.0.0",
+                "strip-ansi": "^6.0.1"
+            },
+            "engines": {
+                "node": ">=8"
+            }
+        },
+        "node_modules/table/node_modules/strip-ansi": {
+            "version": "6.0.1",
+            "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+            "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "ansi-regex": "^5.0.1"
+            },
+            "engines": {
+                "node": ">=8"
             }
         },
         "node_modules/tar-fs": {
@@ -5587,6 +6491,46 @@
                 "node": ">= 6"
             }
         },
+        "node_modules/terminal-link": {
+            "version": "4.0.0",
+            "resolved": "https://registry.npmjs.org/terminal-link/-/terminal-link-4.0.0.tgz",
+            "integrity": "sha512-lk+vH+MccxNqgVqSnkMVKx4VLJfnLjDBGzH16JVZjKE2DoxP57s6/vt6JmXV5I3jBcfGrxNrYtC+mPtU7WJztA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "ansi-escapes": "^7.0.0",
+                "supports-hyperlinks": "^3.2.0"
+            },
+            "engines": {
+                "node": ">=18"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
+        "node_modules/text-table": {
+            "version": "0.2.0",
+            "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz",
+            "integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/textextensions": {
+            "version": "6.11.0",
+            "resolved": "https://registry.npmjs.org/textextensions/-/textextensions-6.11.0.tgz",
+            "integrity": "sha512-tXJwSr9355kFJI3lbCkPpUH5cP8/M0GGy2xLO34aZCjMXBaK3SoPnZwr/oWmo1FdCnELcs4npdCIOFtq9W3ruQ==",
+            "dev": true,
+            "license": "Artistic-2.0",
+            "dependencies": {
+                "editions": "^6.21.0"
+            },
+            "engines": {
+                "node": ">=4"
+            },
+            "funding": {
+                "url": "https://bevry.me/fund"
+            }
+        },
         "node_modules/tmp": {
             "version": "0.2.4",
             "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.4.tgz",
@@ -5667,6 +6611,19 @@
                 "node": ">= 0.8.0"
             }
         },
+        "node_modules/type-fest": {
+            "version": "4.41.0",
+            "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-4.41.0.tgz",
+            "integrity": "sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==",
+            "dev": true,
+            "license": "(MIT OR CC0-1.0)",
+            "engines": {
+                "node": ">=16"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
         "node_modules/typed-rest-client": {
             "version": "1.8.11",
             "resolved": "https://registry.npmjs.org/typed-rest-client/-/typed-rest-client-1.8.11.tgz",
@@ -5747,6 +6704,29 @@
             "dev": true,
             "license": "MIT"
         },
+        "node_modules/unicorn-magic": {
+            "version": "0.3.0",
+            "resolved": "https://registry.npmjs.org/unicorn-magic/-/unicorn-magic-0.3.0.tgz",
+            "integrity": "sha512-+QBBXBCvifc56fsbuxZQ6Sic3wqqc3WWaqxs58gvJrcOuN83HGTCwz3oS5phzU9LthRNE9VrJCFCLUgHeeFnfA==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=18"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
+        "node_modules/universalify": {
+            "version": "2.0.1",
+            "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+            "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 10.0.0"
+            }
+        },
         "node_modules/uri-js": {
             "version": "4.4.1",
             "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
@@ -5781,6 +6761,30 @@
                 "uuid": "dist/bin/uuid"
             }
         },
+        "node_modules/validate-npm-package-license": {
+            "version": "3.0.4",
+            "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz",
+            "integrity": "sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "dependencies": {
+                "spdx-correct": "^3.0.0",
+                "spdx-expression-parse": "^3.0.0"
+            }
+        },
+        "node_modules/version-range": {
+            "version": "4.15.0",
+            "resolved": "https://registry.npmjs.org/version-range/-/version-range-4.15.0.tgz",
+            "integrity": "sha512-Ck0EJbAGxHwprkzFO966t4/5QkRuzh+/I1RxhLgUKKwEn+Cd8NwM60mE3AqBZg5gYODoXW0EFsQvbZjRlvdqbg==",
+            "dev": true,
+            "license": "Artistic-2.0",
+            "engines": {
+                "node": ">=4"
+            },
+            "funding": {
+                "url": "https://bevry.me/fund"
+            }
+        },
         "node_modules/vscode-jsonrpc": {
             "version": "8.2.0",
             "resolved": "https://registry.npmjs.org/vscode-jsonrpc/-/vscode-jsonrpc-8.2.0.tgz",
@@ -5928,42 +6932,6 @@
                 "node": ">=8"
             }
         },
-        "node_modules/wrap-ansi-cjs/node_modules/ansi-styles": {
-            "version": "4.3.0",
-            "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-            "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-            "dev": true,
-            "license": "MIT",
-            "dependencies": {
-                "color-convert": "^2.0.1"
-            },
-            "engines": {
-                "node": ">=8"
-            },
-            "funding": {
-                "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-            }
-        },
-        "node_modules/wrap-ansi-cjs/node_modules/color-convert": {
-            "version": "2.0.1",
-            "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
-            "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
-            "dev": true,
-            "license": "MIT",
-            "dependencies": {
-                "color-name": "~1.1.4"
-            },
-            "engines": {
-                "node": ">=7.0.0"
-            }
-        },
-        "node_modules/wrap-ansi-cjs/node_modules/color-name": {
-            "version": "1.1.4",
-            "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
-            "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
-            "dev": true,
-            "license": "MIT"
-        },
         "node_modules/wrap-ansi-cjs/node_modules/emoji-regex": {
             "version": "8.0.0",
             "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
diff --git a/src/tools/rust-analyzer/editors/code/package.json b/src/tools/rust-analyzer/editors/code/package.json
index 328eb509b4eea..4975ca858671b 100644
--- a/src/tools/rust-analyzer/editors/code/package.json
+++ b/src/tools/rust-analyzer/editors/code/package.json
@@ -63,7 +63,7 @@
         "@typescript-eslint/eslint-plugin": "^8.25.0",
         "@typescript-eslint/parser": "^8.25.0",
         "@vscode/test-electron": "^2.4.1",
-        "@vscode/vsce": "^3.2.2",
+        "@vscode/vsce": "^3.6.0",
         "esbuild": "^0.25.0",
         "eslint": "^9.21.0",
         "eslint-config-prettier": "^10.0.2",

From 52063ae24860bb5cb3abc6f3dd83904bc18a3b0f Mon Sep 17 00:00:00 2001
From: Hanna Kruppe <hanna.kruppe@gmail.com>
Date: Sun, 10 Aug 2025 11:21:43 +0200
Subject: [PATCH 0079/1889] stabilize path_add_extension

---
 library/std/src/path.rs   | 8 ++------
 library/std/tests/path.rs | 2 +-
 2 files changed, 3 insertions(+), 7 deletions(-)

diff --git a/library/std/src/path.rs b/library/std/src/path.rs
index 3b52804d6be40..2af6249f3b989 100644
--- a/library/std/src/path.rs
+++ b/library/std/src/path.rs
@@ -1575,8 +1575,6 @@ impl PathBuf {
     /// # Examples
     ///
     /// ```
-    /// #![feature(path_add_extension)]
-    ///
     /// use std::path::{Path, PathBuf};
     ///
     /// let mut p = PathBuf::from("/feel/the");
@@ -1596,7 +1594,7 @@ impl PathBuf {
     /// p.add_extension("");
     /// assert_eq!(Path::new("/feel/the.formatted.dark"), p.as_path());
     /// ```
-    #[unstable(feature = "path_add_extension", issue = "127292")]
+    #[stable(feature = "path_add_extension", since = "CURRENT_RUSTC_VERSION")]
     pub fn add_extension<S: AsRef<OsStr>>(&mut self, extension: S) -> bool {
         self._add_extension(extension.as_ref())
     }
@@ -2846,8 +2844,6 @@ impl Path {
     /// # Examples
     ///
     /// ```
-    /// #![feature(path_add_extension)]
-    ///
     /// use std::path::{Path, PathBuf};
     ///
     /// let path = Path::new("foo.rs");
@@ -2858,7 +2854,7 @@ impl Path {
     /// assert_eq!(path.with_added_extension("xz"), PathBuf::from("foo.tar.gz.xz"));
     /// assert_eq!(path.with_added_extension("").with_added_extension("txt"), PathBuf::from("foo.tar.gz.txt"));
     /// ```
-    #[unstable(feature = "path_add_extension", issue = "127292")]
+    #[stable(feature = "path_add_extension", since = "CURRENT_RUSTC_VERSION")]
     pub fn with_added_extension<S: AsRef<OsStr>>(&self, extension: S) -> PathBuf {
         let mut new_path = self.to_path_buf();
         new_path.add_extension(extension);
diff --git a/library/std/tests/path.rs b/library/std/tests/path.rs
index e1576a0d4231a..3577f0d9c7bb6 100644
--- a/library/std/tests/path.rs
+++ b/library/std/tests/path.rs
@@ -1,4 +1,4 @@
-#![feature(clone_to_uninit, path_add_extension, maybe_uninit_slice, normalize_lexically)]
+#![feature(clone_to_uninit, maybe_uninit_slice, normalize_lexically)]
 
 use std::clone::CloneToUninit;
 use std::ffi::OsStr;

From 23e8a1e1398f5c17f4c64fe740479c2df31c9fd0 Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Wed, 13 Aug 2025 19:49:59 +0000
Subject: [PATCH 0080/1889] Don't panic if unable to identify host in metrics

---
 src/tools/rust-analyzer/xtask/src/metrics.rs | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/xtask/src/metrics.rs b/src/tools/rust-analyzer/xtask/src/metrics.rs
index c9eea87106060..fd4b600b03470 100644
--- a/src/tools/rust-analyzer/xtask/src/metrics.rs
+++ b/src/tools/rust-analyzer/xtask/src/metrics.rs
@@ -160,7 +160,7 @@ struct Host {
 
 impl Metrics {
     fn new(sh: &Shell) -> anyhow::Result<Metrics> {
-        let host = Host::new(sh)?;
+        let host = Host::new(sh).unwrap_or_else(|_| Host::unknown());
         let timestamp = SystemTime::now();
         let revision = cmd!(sh, "git rev-parse HEAD").read()?;
         let perf_revision = "a584462e145a0c04760fd9391daefb4f6bd13a99".into();
@@ -191,9 +191,13 @@ impl Metrics {
 }
 
 impl Host {
+    fn unknown() -> Host {
+        Host { os: "unknown".into(), cpu: "unknown".into(), mem: "unknown".into() }
+    }
+
     fn new(sh: &Shell) -> anyhow::Result<Host> {
         if cfg!(not(target_os = "linux")) {
-            return Ok(Host { os: "unknown".into(), cpu: "unknown".into(), mem: "unknown".into() });
+            return Ok(Host::unknown());
         }
 
         let os = read_field(sh, "/etc/os-release", "PRETTY_NAME=")?.trim_matches('"').to_owned();

From 8e5818df2eb7d77f3cbed5cbf0c292e8a770d760 Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Wed, 13 Aug 2025 19:50:15 +0000
Subject: [PATCH 0081/1889] Shift vars when mapping Dyn

---
 .../rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs     | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
index 3a3206bef38b5..4696cf479c191 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
@@ -1147,6 +1147,9 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
                             }
                         }),
                     );
+
+                    let p = shift_vars(interner, p, 1);
+
                     let where_clause = match p.skip_binder() {
                         rustc_type_ir::ExistentialPredicate::Trait(trait_ref) => {
                             let trait_ref = TraitRef::new(

From 0170d6cecd1e8592774ccd94dd2a5bf30ff2495a Mon Sep 17 00:00:00 2001
From: Daniel Wagner-Hall <dawagner@gmail.com>
Date: Thu, 14 Aug 2025 00:53:34 +0100
Subject: [PATCH 0082/1889] or_then_unwrap suggestion preserves macro calls

Before this change, the suggestion for
`Option.or(Some(vec![])).unwrap()` expanded the `vec!` macro which broke
the code, both in terms of readability, and because the expansion
references `$crate` which cannot be inlined.
---
 clippy_lints/src/methods/or_then_unwrap.rs |  2 +-
 tests/ui/or_then_unwrap.fixed              |  6 ++++++
 tests/ui/or_then_unwrap.rs                 |  6 ++++++
 tests/ui/or_then_unwrap.stderr             | 10 ++++++++--
 4 files changed, 21 insertions(+), 3 deletions(-)

diff --git a/clippy_lints/src/methods/or_then_unwrap.rs b/clippy_lints/src/methods/or_then_unwrap.rs
index 3e64e15dc8602..1a760ea733d7f 100644
--- a/clippy_lints/src/methods/or_then_unwrap.rs
+++ b/clippy_lints/src/methods/or_then_unwrap.rs
@@ -62,7 +62,7 @@ fn get_content_if_ctor_matches(cx: &LateContext<'_>, expr: &Expr<'_>, item: Lang
     if let ExprKind::Call(some_expr, [arg]) = expr.kind
         && is_res_lang_ctor(cx, path_res(cx, some_expr), item)
     {
-        Some(arg.span)
+        Some(arg.span.source_callsite())
     } else {
         None
     }
diff --git a/tests/ui/or_then_unwrap.fixed b/tests/ui/or_then_unwrap.fixed
index ba9beef57afaa..9660b82fe7d61 100644
--- a/tests/ui/or_then_unwrap.fixed
+++ b/tests/ui/or_then_unwrap.fixed
@@ -28,6 +28,12 @@ fn main() {
     //
     //~^^ or_then_unwrap
 
+    // Call with macro should preserve the macro call rather than expand it
+    let option: Option<Vec<&str>> = None;
+    let _ = option.unwrap_or(vec!["fallback"]); // should trigger lint
+    //
+    //~^^ or_then_unwrap
+
     // as part of a method chain
     let option: Option<&str> = None;
     let _ = option.map(|v| v).unwrap_or("fallback").to_string().chars(); // should trigger lint
diff --git a/tests/ui/or_then_unwrap.rs b/tests/ui/or_then_unwrap.rs
index fac90249a243c..c387335211643 100644
--- a/tests/ui/or_then_unwrap.rs
+++ b/tests/ui/or_then_unwrap.rs
@@ -28,6 +28,12 @@ fn main() {
     //
     //~^^ or_then_unwrap
 
+    // Call with macro should preserve the macro call rather than expand it
+    let option: Option<Vec<&str>> = None;
+    let _ = option.or(Some(vec!["fallback"])).unwrap(); // should trigger lint
+    //
+    //~^^ or_then_unwrap
+
     // as part of a method chain
     let option: Option<&str> = None;
     let _ = option.map(|v| v).or(Some("fallback")).unwrap().to_string().chars(); // should trigger lint
diff --git a/tests/ui/or_then_unwrap.stderr b/tests/ui/or_then_unwrap.stderr
index 1160498c6053b..3e66b15edbd65 100644
--- a/tests/ui/or_then_unwrap.stderr
+++ b/tests/ui/or_then_unwrap.stderr
@@ -14,10 +14,16 @@ LL |     let _ = result.or::<&str>(Ok("fallback")).unwrap(); // should trigger l
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or("fallback")`
 
 error: found `.or(Some(…)).unwrap()`
-  --> tests/ui/or_then_unwrap.rs:33:31
+  --> tests/ui/or_then_unwrap.rs:33:20
+   |
+LL |     let _ = option.or(Some(vec!["fallback"])).unwrap(); // should trigger lint
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or(vec!["fallback"])`
+
+error: found `.or(Some(…)).unwrap()`
+  --> tests/ui/or_then_unwrap.rs:39:31
    |
 LL |     let _ = option.map(|v| v).or(Some("fallback")).unwrap().to_string().chars(); // should trigger lint
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or("fallback")`
 
-error: aborting due to 3 previous errors
+error: aborting due to 4 previous errors
 

From 861f9122c899a8ec52c62ecb0a1435226dd5fc1a Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Thu, 14 Aug 2025 08:34:31 +0800
Subject: [PATCH 0083/1889] Fix indent for convert_match_to_let_else

Example
---
```
//- minicore: option
fn f() {
    let x$0 = match Some(()) {
        Some(it) => it,
        None => {//comment
            println!("nope");
            return
        },
    };
}
```

**Old output**:

```rust
fn f() {
    let Some(x) = Some(()) else {//comment
            println!("nope");
            return
        };
}
```

**This PR output**:

```rust
fn f() {
    let Some(x) = Some(()) else {//comment
        println!("nope");
        return
    };
}
```
---
 .../src/handlers/convert_match_to_let_else.rs | 64 +++++++++++++++++--
 1 file changed, 58 insertions(+), 6 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_match_to_let_else.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_match_to_let_else.rs
index 9126e869b9a05..1a6d176c9054c 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_match_to_let_else.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_match_to_let_else.rs
@@ -1,7 +1,7 @@
 use ide_db::defs::{Definition, NameRefClass};
 use syntax::{
     AstNode, SyntaxNode,
-    ast::{self, HasName, Name, syntax_factory::SyntaxFactory},
+    ast::{self, HasName, Name, edit::AstNodeEdit, syntax_factory::SyntaxFactory},
     syntax_editor::SyntaxEditor,
 };
 
@@ -45,7 +45,7 @@ pub(crate) fn convert_match_to_let_else(acc: &mut Assists, ctx: &AssistContext<'
         return None;
     }
 
-    let diverging_arm_expr = match diverging_arm.expr()? {
+    let diverging_arm_expr = match diverging_arm.expr()?.dedent(1.into()) {
         ast::Expr::BlockExpr(block) if block.modifier().is_none() && block.label().is_none() => {
             block.to_string()
         }
@@ -150,7 +150,12 @@ fn rename_variable(pat: &ast::Pat, extracted: &[Name], binding: ast::Pat) -> Syn
         }
     }
     editor.add_mappings(make.finish_with_mappings());
-    editor.finish().new_root().clone()
+    let new_node = editor.finish().new_root().clone();
+    if let Some(pat) = ast::Pat::cast(new_node.clone()) {
+        pat.dedent(1.into()).syntax().clone()
+    } else {
+        new_node
+    }
 }
 
 #[cfg(test)]
@@ -209,6 +214,53 @@ fn foo(opt: Option<Foo>) -> Result<u32, ()> {
         );
     }
 
+    #[test]
+    fn indent_level() {
+        check_assist(
+            convert_match_to_let_else,
+            r#"
+//- minicore: option
+enum Foo {
+    A(u32),
+    B(u32),
+    C(String),
+}
+
+fn foo(opt: Option<Foo>) -> Result<u32, ()> {
+    let mut state = 2;
+    let va$0lue = match opt {
+        Some(
+            Foo::A(it)
+            | Foo::B(it)
+        ) => it,
+        _ => {
+            state = 3;
+            return Err(())
+        },
+    };
+}
+    "#,
+            r#"
+enum Foo {
+    A(u32),
+    B(u32),
+    C(String),
+}
+
+fn foo(opt: Option<Foo>) -> Result<u32, ()> {
+    let mut state = 2;
+    let Some(
+        Foo::A(value)
+        | Foo::B(value)
+    ) = opt else {
+        state = 3;
+        return Err(())
+    };
+}
+    "#,
+        );
+    }
+
     #[test]
     fn should_not_be_applicable_if_extracting_arm_is_not_an_identity_expr() {
         cov_mark::check_count!(extracting_arm_is_not_an_identity_expr, 2);
@@ -489,9 +541,9 @@ fn f() {
             r#"
 fn f() {
     let Some(x) = Some(()) else {//comment
-            println!("nope");
-            return
-        };
+        println!("nope");
+        return
+    };
 }
 "#,
         );

From c78177b7f93c9b691a9b8365eaba9c8d11df4cd0 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Thu, 14 Aug 2025 10:05:11 +0800
Subject: [PATCH 0084/1889] Add guard to let-chain for
 replace_match_with_if_let

```rust
fn main() {
    match$0 Some(0) {
        Some(n) if n % 2 == 0 && n != 6 => (),
        _ => code(),
    }
}
```
->
```rust
fn main() {
    if let Some(n) = Some(0) && n % 2 == 0 && n != 6 {
        ()
    } else {
        code()
    }
}
---
 .../src/handlers/replace_if_let_with_match.rs | 64 +++++++++++++++----
 1 file changed, 52 insertions(+), 12 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_if_let_with_match.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_if_let_with_match.rs
index 15d3db5e749f0..dd244375dc91e 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_if_let_with_match.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_if_let_with_match.rs
@@ -8,7 +8,7 @@ use ide_db::{
     ty_filter::TryEnum,
 };
 use syntax::{
-    AstNode, T, TextRange,
+    AstNode, Edition, T, TextRange,
     ast::{self, HasName, edit::IndentLevel, edit_in_place::Indent, syntax_factory::SyntaxFactory},
 };
 
@@ -187,7 +187,7 @@ fn make_else_arm(
 
 // Assist: replace_match_with_if_let
 //
-// Replaces a binary `match` with a wildcard pattern and no guards with an `if let` expression.
+// Replaces a binary `match` with a wildcard pattern with an `if let` expression.
 //
 // ```
 // enum Action { Move { distance: u32 }, Stop }
@@ -225,18 +225,24 @@ pub(crate) fn replace_match_with_if_let(acc: &mut Assists, ctx: &AssistContext<'
 
     let mut arms = match_arm_list.arms();
     let (first_arm, second_arm) = (arms.next()?, arms.next()?);
-    if arms.next().is_some() || first_arm.guard().is_some() || second_arm.guard().is_some() {
+    if arms.next().is_some() || second_arm.guard().is_some() {
+        return None;
+    }
+    if first_arm.guard().is_some() && ctx.edition() < Edition::Edition2024 {
         return None;
     }
 
-    let (if_let_pat, then_expr, else_expr) = pick_pattern_and_expr_order(
+    let (if_let_pat, guard, then_expr, else_expr) = pick_pattern_and_expr_order(
         &ctx.sema,
         first_arm.pat()?,
         second_arm.pat()?,
         first_arm.expr()?,
         second_arm.expr()?,
+        first_arm.guard(),
+        second_arm.guard(),
     )?;
     let scrutinee = match_expr.expr()?;
+    let guard = guard.and_then(|it| it.condition());
 
     let let_ = match &if_let_pat {
         ast::Pat::LiteralPat(p)
@@ -277,6 +283,11 @@ pub(crate) fn replace_match_with_if_let(acc: &mut Assists, ctx: &AssistContext<'
                 }
                 _ => make.expr_let(if_let_pat, scrutinee).into(),
             };
+            let condition = if let Some(guard) = guard {
+                make.expr_bin(condition, ast::BinaryOp::LogicOp(ast::LogicOp::And), guard).into()
+            } else {
+                condition
+            };
             let then_expr = then_expr.clone_for_update();
             then_expr.reindent_to(IndentLevel::single());
             let then_block = make_block_expr(then_expr);
@@ -303,18 +314,23 @@ fn pick_pattern_and_expr_order(
     pat2: ast::Pat,
     expr: ast::Expr,
     expr2: ast::Expr,
-) -> Option<(ast::Pat, ast::Expr, ast::Expr)> {
+    guard: Option<ast::MatchGuard>,
+    guard2: Option<ast::MatchGuard>,
+) -> Option<(ast::Pat, Option<ast::MatchGuard>, ast::Expr, ast::Expr)> {
+    if guard.is_some() && guard2.is_some() {
+        return None;
+    }
     let res = match (pat, pat2) {
         (ast::Pat::WildcardPat(_), _) => return None,
-        (pat, ast::Pat::WildcardPat(_)) => (pat, expr, expr2),
-        (pat, _) if is_empty_expr(&expr2) => (pat, expr, expr2),
-        (_, pat) if is_empty_expr(&expr) => (pat, expr2, expr),
+        (pat, ast::Pat::WildcardPat(_)) => (pat, guard, expr, expr2),
+        (pat, _) if is_empty_expr(&expr2) => (pat, guard, expr, expr2),
+        (_, pat) if is_empty_expr(&expr) => (pat, guard, expr2, expr),
         (pat, pat2) => match (binds_name(sema, &pat), binds_name(sema, &pat2)) {
             (true, true) => return None,
-            (true, false) => (pat, expr, expr2),
-            (false, true) => (pat2, expr2, expr),
-            _ if is_sad_pat(sema, &pat) => (pat2, expr2, expr),
-            (false, false) => (pat, expr, expr2),
+            (true, false) => (pat, guard, expr, expr2),
+            (false, true) => (pat2, guard2, expr2, expr),
+            _ if is_sad_pat(sema, &pat) => (pat2, guard2, expr2, expr),
+            (false, false) => (pat, guard, expr, expr2),
         },
     };
     Some(res)
@@ -1849,6 +1865,30 @@ fn main() {
         code()
     }
 }
+"#,
+        )
+    }
+
+    #[test]
+    fn test_replace_match_with_if_let_chain() {
+        check_assist(
+            replace_match_with_if_let,
+            r#"
+fn main() {
+    match$0 Some(0) {
+        Some(n) if n % 2 == 0 && n != 6 => (),
+        _ => code(),
+    }
+}
+"#,
+            r#"
+fn main() {
+    if let Some(n) = Some(0) && n % 2 == 0 && n != 6 {
+        ()
+    } else {
+        code()
+    }
+}
 "#,
         )
     }

From 6772f18557e24d9d1f8572839d0ef3cde3b0ac44 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukas@zed.dev>
Date: Thu, 14 Aug 2025 14:33:33 +0200
Subject: [PATCH 0085/1889] Track diagnostic generations per package

---
 .../crates/rust-analyzer/src/diagnostics.rs   | 56 +++++++++++--------
 1 file changed, 32 insertions(+), 24 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/diagnostics.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/diagnostics.rs
index 30f530100f9df..ee50237c405e6 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/diagnostics.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/diagnostics.rs
@@ -26,17 +26,15 @@ pub struct DiagnosticsMapConfig {
 
 pub(crate) type DiagnosticsGeneration = usize;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub(crate) struct WorkspaceFlycheckDiagnostic {
-    pub(crate) generation: DiagnosticsGeneration,
-    pub(crate) per_package:
-        FxHashMap<Option<Arc<PackageId>>, FxHashMap<FileId, Vec<lsp_types::Diagnostic>>>,
+    pub(crate) per_package: FxHashMap<Option<Arc<PackageId>>, PackageFlycheckDiagnostic>,
 }
 
-impl WorkspaceFlycheckDiagnostic {
-    fn new(generation: DiagnosticsGeneration) -> Self {
-        WorkspaceFlycheckDiagnostic { generation, per_package: Default::default() }
-    }
+#[derive(Debug, Clone)]
+pub(crate) struct PackageFlycheckDiagnostic {
+    generation: DiagnosticsGeneration,
+    per_file: FxHashMap<FileId, Vec<lsp_types::Diagnostic>>,
 }
 
 #[derive(Debug, Default, Clone)]
@@ -68,7 +66,7 @@ impl DiagnosticCollection {
         let Some(check) = self.check.get_mut(flycheck_id) else {
             return;
         };
-        self.changes.extend(check.per_package.drain().flat_map(|(_, v)| v.into_keys()));
+        self.changes.extend(check.per_package.drain().flat_map(|(_, v)| v.per_file.into_keys()));
         if let Some(fixes) = Arc::make_mut(&mut self.check_fixes).get_mut(flycheck_id) {
             fixes.clear();
         }
@@ -79,7 +77,7 @@ impl DiagnosticCollection {
         self.changes.extend(
             self.check
                 .iter_mut()
-                .flat_map(|it| it.per_package.drain().flat_map(|(_, v)| v.into_keys())),
+                .flat_map(|it| it.per_package.drain().flat_map(|(_, v)| v.per_file.into_keys())),
         )
     }
 
@@ -93,7 +91,7 @@ impl DiagnosticCollection {
         };
         let package_id = Some(package_id);
         if let Some(checks) = check.per_package.remove(&package_id) {
-            self.changes.extend(checks.into_keys());
+            self.changes.extend(checks.per_file.into_keys());
         }
         if let Some(fixes) = Arc::make_mut(&mut self.check_fixes).get_mut(flycheck_id) {
             fixes.remove(&package_id);
@@ -105,8 +103,20 @@ impl DiagnosticCollection {
         flycheck_id: usize,
         generation: DiagnosticsGeneration,
     ) {
-        if self.check.get(flycheck_id).is_some_and(|it| it.generation < generation) {
-            self.clear_check(flycheck_id);
+        if let Some(flycheck) = self.check.get_mut(flycheck_id) {
+            let mut packages = vec![];
+            self.changes.extend(
+                flycheck
+                    .per_package
+                    .extract_if(|_, v| v.generation < generation)
+                    .inspect(|(package_id, _)| packages.push(package_id.clone()))
+                    .flat_map(|(_, v)| v.per_file.into_keys()),
+            );
+            if let Some(fixes) = Arc::make_mut(&mut self.check_fixes).get_mut(flycheck_id) {
+                for package in packages {
+                    fixes.remove(&package);
+                }
+            }
         }
     }
 
@@ -126,21 +136,19 @@ impl DiagnosticCollection {
         fix: Option<Box<Fix>>,
     ) {
         if self.check.len() <= flycheck_id {
-            self.check
-                .resize_with(flycheck_id + 1, || WorkspaceFlycheckDiagnostic::new(generation));
+            self.check.resize_with(flycheck_id + 1, WorkspaceFlycheckDiagnostic::default);
         }
 
+        let check = &mut self.check[flycheck_id];
+        let package = check.per_package.entry(package_id.clone()).or_insert_with(|| {
+            PackageFlycheckDiagnostic { generation, per_file: FxHashMap::default() }
+        });
         // Getting message from old generation. Might happen in restarting checks.
-        if self.check[flycheck_id].generation > generation {
+        if package.generation > generation {
             return;
         }
-        self.check[flycheck_id].generation = generation;
-        let diagnostics = self.check[flycheck_id]
-            .per_package
-            .entry(package_id.clone())
-            .or_default()
-            .entry(file_id)
-            .or_default();
+        package.generation = generation;
+        let diagnostics = package.per_file.entry(file_id).or_default();
         for existing_diagnostic in diagnostics.iter() {
             if are_diagnostics_equal(existing_diagnostic, &diagnostic) {
                 return;
@@ -210,7 +218,7 @@ impl DiagnosticCollection {
             .check
             .iter()
             .flat_map(|it| it.per_package.values())
-            .filter_map(move |it| it.get(&file_id))
+            .filter_map(move |it| it.per_file.get(&file_id))
             .flatten();
         native_syntax.chain(native_semantic).chain(check)
     }

From 58ec13d79389f3886e71d43a0fcf501b84c1a40f Mon Sep 17 00:00:00 2001
From: Ralf Anton Beier <ralf_beier@me.com>
Date: Mon, 11 Aug 2025 06:16:34 +0200
Subject: [PATCH 0086/1889] feat: hint at unterminated strings in unknown
 prefix errors

When encountering 'unknown literal prefix' errors, check for unbalanced
quotes in recent code and suggest checking for unterminated string literals.
---
 .../crates/parser/src/lexed_str.rs            | 30 ++++++++++++++++++-
 .../unterminated_string_unknown_prefix.rast   | 15 ++++++++++
 .../err/unterminated_string_unknown_prefix.rs |  5 ++++
 3 files changed, 49 insertions(+), 1 deletion(-)
 create mode 100644 src/tools/rust-analyzer/crates/parser/test_data/lexer/err/unterminated_string_unknown_prefix.rast
 create mode 100644 src/tools/rust-analyzer/crates/parser/test_data/lexer/err/unterminated_string_unknown_prefix.rs

diff --git a/src/tools/rust-analyzer/crates/parser/src/lexed_str.rs b/src/tools/rust-analyzer/crates/parser/src/lexed_str.rs
index 8fff1c3db7485..dcf397142cac0 100644
--- a/src/tools/rust-analyzer/crates/parser/src/lexed_str.rs
+++ b/src/tools/rust-analyzer/crates/parser/src/lexed_str.rs
@@ -149,6 +149,24 @@ impl<'a> Converter<'a> {
         }
     }
 
+    /// Check for likely unterminated string by analyzing STRING token content
+    fn has_likely_unterminated_string(&self) -> bool {
+        let Some(last_idx) = self.res.kind.len().checked_sub(1) else { return false };
+
+        for i in (0..=last_idx).rev().take(5) {
+            if self.res.kind[i] == STRING {
+                let start = self.res.start[i] as usize;
+                let end = self.res.start.get(i + 1).map(|&s| s as usize).unwrap_or(self.offset);
+                let content = &self.res.text[start..end];
+
+                if content.contains('(') && (content.contains("//") || content.contains(";\n")) {
+                    return true;
+                }
+            }
+        }
+        false
+    }
+
     fn finalize_with_eof(mut self) -> LexedStr<'a> {
         self.res.push(EOF, self.offset);
         self.res
@@ -267,7 +285,17 @@ impl<'a> Converter<'a> {
                 rustc_lexer::TokenKind::Unknown => ERROR,
                 rustc_lexer::TokenKind::UnknownPrefix if token_text == "builtin" => IDENT,
                 rustc_lexer::TokenKind::UnknownPrefix => {
-                    errors.push("unknown literal prefix".into());
+                    let has_unterminated = self.has_likely_unterminated_string();
+
+                    let error_msg = if has_unterminated {
+                        format!(
+                            "unknown literal prefix `{}` (note: check for unterminated string literal)",
+                            token_text
+                        )
+                    } else {
+                        "unknown literal prefix".to_owned()
+                    };
+                    errors.push(error_msg);
                     IDENT
                 }
                 rustc_lexer::TokenKind::Eof => EOF,
diff --git a/src/tools/rust-analyzer/crates/parser/test_data/lexer/err/unterminated_string_unknown_prefix.rast b/src/tools/rust-analyzer/crates/parser/test_data/lexer/err/unterminated_string_unknown_prefix.rast
new file mode 100644
index 0000000000000..f7f24ca3f810a
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/parser/test_data/lexer/err/unterminated_string_unknown_prefix.rast
@@ -0,0 +1,15 @@
+FN_KW "fn"
+WHITESPACE " "
+IDENT "main"
+L_PAREN "("
+R_PAREN ")"
+WHITESPACE " "
+L_CURLY "{"
+WHITESPACE "\n    "
+IDENT "hello"
+L_PAREN "("
+STRING "\"world);\n    // a bunch of code was here\n    env(\"FLAGS"
+STRING "\", \""
+MINUS "-"
+IDENT "help" error: unknown literal prefix `help` (note: check for unterminated string literal)
+STRING "\")\n}" error: Missing trailing `"` symbol to terminate the string literal
diff --git a/src/tools/rust-analyzer/crates/parser/test_data/lexer/err/unterminated_string_unknown_prefix.rs b/src/tools/rust-analyzer/crates/parser/test_data/lexer/err/unterminated_string_unknown_prefix.rs
new file mode 100644
index 0000000000000..338b9582605bd
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/parser/test_data/lexer/err/unterminated_string_unknown_prefix.rs
@@ -0,0 +1,5 @@
+fn main() {
+    hello("world);
+    // a bunch of code was here
+    env("FLAGS", "-help")
+}
\ No newline at end of file

From c99224536152cff14639b64a3fa4f7a215fd037c Mon Sep 17 00:00:00 2001
From: Karl Meakin <karl.meakin@arm.com>
Date: Sat, 9 Aug 2025 23:52:11 +0100
Subject: [PATCH 0087/1889] refactor: Include table sizes in comment at top of
 `unicode_data.rs`

To make changes in table size obvious from git diffs
---
 library/core/src/unicode/unicode_data.rs      | 10 ++++++++++
 src/tools/unicode-table-generator/src/main.rs | 20 +++++++++----------
 2 files changed, 19 insertions(+), 11 deletions(-)

diff --git a/library/core/src/unicode/unicode_data.rs b/library/core/src/unicode/unicode_data.rs
index b57234bbee9a2..6059f7d6450b1 100644
--- a/library/core/src/unicode/unicode_data.rs
+++ b/library/core/src/unicode/unicode_data.rs
@@ -1,4 +1,14 @@
 ///! This file is generated by `./x run src/tools/unicode-table-generator`; do not edit manually!
+// Alphabetic      :  1727 bytes, 142759 codepoints in 757 ranges (U+000041 - U+0323B0) using skiplist
+// Case_Ignorable  :  1053 bytes,   2749 codepoints in 452 ranges (U+000027 - U+0E01F0) using skiplist
+// Cased           :   407 bytes,   4578 codepoints in 159 ranges (U+000041 - U+01F18A) using skiplist
+// Cc              :     9 bytes,     65 codepoints in   2 ranges (U+000000 - U+0000A0) using skiplist
+// Grapheme_Extend :   887 bytes,   2193 codepoints in 375 ranges (U+000300 - U+0E01F0) using skiplist
+// Lowercase       :   935 bytes,   2569 codepoints in 675 ranges (U+000061 - U+01E944) using bitset
+// N               :   457 bytes,   1911 codepoints in 144 ranges (U+000030 - U+01FBFA) using skiplist
+// Uppercase       :   799 bytes,   1978 codepoints in 656 ranges (U+000041 - U+01F18A) using bitset
+// White_Space     :   256 bytes,     25 codepoints in  10 ranges (U+000009 - U+003001) using cascading
+// Total           :  6530 bytes
 
 #[inline(always)]
 const fn bitset_search<
diff --git a/src/tools/unicode-table-generator/src/main.rs b/src/tools/unicode-table-generator/src/main.rs
index 6cdb82a87bdff..c1017142097f0 100644
--- a/src/tools/unicode-table-generator/src/main.rs
+++ b/src/tools/unicode-table-generator/src/main.rs
@@ -239,6 +239,11 @@ fn main() {
         std::fs::write(&path, generate_tests(&write_location, ranges_by_property)).unwrap();
     }
 
+    let mut table_file = String::new();
+    table_file.push_str(
+        "///! This file is generated by `./x run src/tools/unicode-table-generator`; do not edit manually!\n",
+    );
+
     let mut total_bytes = 0;
     let mut modules = Vec::new();
     for (property, ranges) in ranges_by_property {
@@ -252,8 +257,8 @@ fn main() {
         }
 
         modules.push((property.to_lowercase().to_string(), emitter.file));
-        println!(
-            "{:15}: {} bytes, {} codepoints in {} ranges ({} - {}) using {}",
+        table_file.push_str(&format!(
+            "// {:16}: {:5} bytes, {:6} codepoints in {:3} ranges (U+{:06X} - U+{:06X}) using {}\n",
             property,
             emitter.bytes_used,
             datapoints,
@@ -261,15 +266,10 @@ fn main() {
             ranges.first().unwrap().start,
             ranges.last().unwrap().end,
             emitter.desc,
-        );
+        ));
         total_bytes += emitter.bytes_used;
     }
-
-    let mut table_file = String::new();
-
-    table_file.push_str(
-        "///! This file is generated by `./x run src/tools/unicode-table-generator`; do not edit manually!\n",
-    );
+    table_file.push_str(&format!("// {:16}: {:5} bytes\n", "Total", total_bytes));
 
     // Include the range search function
     table_file.push('\n');
@@ -296,8 +296,6 @@ fn main() {
     }
 
     std::fs::write(&write_location, format!("{}\n", table_file.trim_end())).unwrap();
-
-    println!("Total table sizes: {total_bytes} bytes");
 }
 
 fn version() -> String {

From 69e1974bb0bfbcc679d29950b1e4540cd0b9b3ee Mon Sep 17 00:00:00 2001
From: Karl Meakin <karl.meakin@arm.com>
Date: Sun, 10 Aug 2025 00:18:04 +0100
Subject: [PATCH 0088/1889] refactor: Include size of case conversion tables

Include the sizes of the `to_lowercase` and `to_uppercase` tables in the
total size calculations.
---
 library/core/src/unicode/unicode_data.rs      | 12 +++---
 .../src/case_mapping.rs                       | 41 +++++++++++++------
 src/tools/unicode-table-generator/src/main.rs |  7 +++-
 3 files changed, 42 insertions(+), 18 deletions(-)

diff --git a/library/core/src/unicode/unicode_data.rs b/library/core/src/unicode/unicode_data.rs
index 6059f7d6450b1..787efcc091454 100644
--- a/library/core/src/unicode/unicode_data.rs
+++ b/library/core/src/unicode/unicode_data.rs
@@ -8,7 +8,9 @@
 // N               :   457 bytes,   1911 codepoints in 144 ranges (U+000030 - U+01FBFA) using skiplist
 // Uppercase       :   799 bytes,   1978 codepoints in 656 ranges (U+000041 - U+01F18A) using bitset
 // White_Space     :   256 bytes,     25 codepoints in  10 ranges (U+000009 - U+003001) using cascading
-// Total           :  6530 bytes
+// to_lower        : 11484 bytes
+// to_upper        : 13432 bytes
+// Total           : 31446 bytes
 
 #[inline(always)]
 const fn bitset_search<
@@ -782,7 +784,7 @@ pub mod conversions {
         }
     }
 
-    static LOWERCASE_TABLE: &[(char, u32)] = &[
+    static LOWERCASE_TABLE: &[(char, u32); 1434] = &[
         ('\u{c0}', 224), ('\u{c1}', 225), ('\u{c2}', 226), ('\u{c3}', 227), ('\u{c4}', 228),
         ('\u{c5}', 229), ('\u{c6}', 230), ('\u{c7}', 231), ('\u{c8}', 232), ('\u{c9}', 233),
         ('\u{ca}', 234), ('\u{cb}', 235), ('\u{cc}', 236), ('\u{cd}', 237), ('\u{ce}', 238),
@@ -1132,11 +1134,11 @@ pub mod conversions {
         ('\u{1e921}', 125251),
     ];
 
-    static LOWERCASE_TABLE_MULTI: &[[char; 3]] = &[
+    static LOWERCASE_TABLE_MULTI: &[[char; 3]; 1] = &[
         ['i', '\u{307}', '\u{0}'],
     ];
 
-    static UPPERCASE_TABLE: &[(char, u32)] = &[
+    static UPPERCASE_TABLE: &[(char, u32); 1526] = &[
         ('\u{b5}', 924), ('\u{df}', 4194304), ('\u{e0}', 192), ('\u{e1}', 193), ('\u{e2}', 194),
         ('\u{e3}', 195), ('\u{e4}', 196), ('\u{e5}', 197), ('\u{e6}', 198), ('\u{e7}', 199),
         ('\u{e8}', 200), ('\u{e9}', 201), ('\u{ea}', 202), ('\u{eb}', 203), ('\u{ec}', 204),
@@ -1509,7 +1511,7 @@ pub mod conversions {
         ('\u{1e941}', 125215), ('\u{1e942}', 125216), ('\u{1e943}', 125217),
     ];
 
-    static UPPERCASE_TABLE_MULTI: &[[char; 3]] = &[
+    static UPPERCASE_TABLE_MULTI: &[[char; 3]; 102] = &[
         ['S', 'S', '\u{0}'], ['\u{2bc}', 'N', '\u{0}'], ['J', '\u{30c}', '\u{0}'],
         ['\u{399}', '\u{308}', '\u{301}'], ['\u{3a5}', '\u{308}', '\u{301}'],
         ['\u{535}', '\u{552}', '\u{0}'], ['H', '\u{331}', '\u{0}'], ['T', '\u{308}', '\u{0}'],
diff --git a/src/tools/unicode-table-generator/src/case_mapping.rs b/src/tools/unicode-table-generator/src/case_mapping.rs
index 9c6454492e7e0..a8527ea9a429a 100644
--- a/src/tools/unicode-table-generator/src/case_mapping.rs
+++ b/src/tools/unicode-table-generator/src/case_mapping.rs
@@ -6,20 +6,22 @@ use crate::{UnicodeData, fmt_list};
 
 const INDEX_MASK: u32 = 1 << 22;
 
-pub(crate) fn generate_case_mapping(data: &UnicodeData) -> String {
+pub(crate) fn generate_case_mapping(data: &UnicodeData) -> (String, [usize; 2]) {
     let mut file = String::new();
 
     write!(file, "const INDEX_MASK: u32 = 0x{INDEX_MASK:x};").unwrap();
     file.push_str("\n\n");
     file.push_str(HEADER.trim_start());
     file.push('\n');
-    file.push_str(&generate_tables("LOWER", &data.to_lower));
+    let (lower_tables, lower_size) = generate_tables("LOWER", &data.to_lower);
+    file.push_str(&lower_tables);
     file.push_str("\n\n");
-    file.push_str(&generate_tables("UPPER", &data.to_upper));
-    file
+    let (upper_tables, upper_size) = generate_tables("UPPER", &data.to_upper);
+    file.push_str(&upper_tables);
+    (file, [lower_size, upper_size])
 }
 
-fn generate_tables(case: &str, data: &BTreeMap<u32, (u32, u32, u32)>) -> String {
+fn generate_tables(case: &str, data: &BTreeMap<u32, (u32, u32, u32)>) -> (String, usize) {
     let mut mappings = Vec::with_capacity(data.len());
     let mut multis = Vec::new();
 
@@ -46,16 +48,31 @@ fn generate_tables(case: &str, data: &BTreeMap<u32, (u32, u32, u32)>) -> String
     }
 
     let mut tables = String::new();
-
-    write!(tables, "static {}CASE_TABLE: &[(char, u32)] = &[{}];", case, fmt_list(mappings))
-        .unwrap();
+    let mut size = 0;
+
+    size += size_of_val(mappings.as_slice());
+    write!(
+        tables,
+        "static {}CASE_TABLE: &[(char, u32); {}] = &[{}];",
+        case,
+        mappings.len(),
+        fmt_list(mappings),
+    )
+    .unwrap();
 
     tables.push_str("\n\n");
 
-    write!(tables, "static {}CASE_TABLE_MULTI: &[[char; 3]] = &[{}];", case, fmt_list(multis))
-        .unwrap();
-
-    tables
+    size += size_of_val(multis.as_slice());
+    write!(
+        tables,
+        "static {}CASE_TABLE_MULTI: &[[char; 3]; {}] = &[{}];",
+        case,
+        multis.len(),
+        fmt_list(multis),
+    )
+    .unwrap();
+
+    (tables, size)
 }
 
 struct CharEscape(char);
diff --git a/src/tools/unicode-table-generator/src/main.rs b/src/tools/unicode-table-generator/src/main.rs
index c1017142097f0..f755ad048e4a4 100644
--- a/src/tools/unicode-table-generator/src/main.rs
+++ b/src/tools/unicode-table-generator/src/main.rs
@@ -269,6 +269,11 @@ fn main() {
         ));
         total_bytes += emitter.bytes_used;
     }
+    let (conversions, sizes) = case_mapping::generate_case_mapping(&unicode_data);
+    for (name, size) in ["to_lower", "to_upper"].iter().zip(sizes) {
+        table_file.push_str(&format!("// {:16}: {:5} bytes\n", name, size));
+        total_bytes += size;
+    }
     table_file.push_str(&format!("// {:16}: {:5} bytes\n", "Total", total_bytes));
 
     // Include the range search function
@@ -280,7 +285,7 @@ fn main() {
 
     table_file.push('\n');
 
-    modules.push((String::from("conversions"), case_mapping::generate_case_mapping(&unicode_data)));
+    modules.push((String::from("conversions"), conversions));
 
     for (name, contents) in modules {
         table_file.push_str("#[rustfmt::skip]\n");

From 5d54ac5276eade9d9424fc4fbfa6f77bcd5d4940 Mon Sep 17 00:00:00 2001
From: Karl Meakin <karl.meakin@arm.com>
Date: Sun, 10 Aug 2025 01:10:15 +0100
Subject: [PATCH 0089/1889] refactor: rewrite `ranges_from_set`

The `merge_ranges` function was very complicated and hard to understand.
Forunately, we can use `slice::chunk_by` to achieve the same thing.
---
 src/tools/unicode-table-generator/src/main.rs | 83 ++++---------------
 1 file changed, 17 insertions(+), 66 deletions(-)

diff --git a/src/tools/unicode-table-generator/src/main.rs b/src/tools/unicode-table-generator/src/main.rs
index f755ad048e4a4..bf0511a2c77ef 100644
--- a/src/tools/unicode-table-generator/src/main.rs
+++ b/src/tools/unicode-table-generator/src/main.rs
@@ -187,33 +187,19 @@ fn load_data() -> UnicodeData {
         }
     }
 
-    let mut properties: HashMap<&'static str, Vec<Range<u32>>> = properties
+    let mut properties: Vec<(&'static str, Vec<Range<u32>>)> = properties
         .into_iter()
-        .map(|(k, v)| {
-            (
-                k,
-                v.into_iter()
-                    .flat_map(|codepoints| match codepoints {
-                        Codepoints::Single(c) => c
-                            .scalar()
-                            .map(|ch| ch as u32..ch as u32 + 1)
-                            .into_iter()
-                            .collect::<Vec<_>>(),
-                        Codepoints::Range(c) => c
-                            .into_iter()
-                            .flat_map(|c| c.scalar().map(|ch| ch as u32..ch as u32 + 1))
-                            .collect::<Vec<_>>(),
-                    })
-                    .collect::<Vec<Range<u32>>>(),
-            )
+        .map(|(prop, codepoints)| {
+            let codepoints = codepoints
+                .into_iter()
+                .flatten()
+                .flat_map(|cp| cp.scalar())
+                .map(u32::from)
+                .collect::<Vec<_>>();
+            (prop, ranges_from_set(&codepoints))
         })
         .collect();
 
-    for ranges in properties.values_mut() {
-        merge_ranges(ranges);
-    }
-
-    let mut properties = properties.into_iter().collect::<Vec<_>>();
     properties.sort_by_key(|p| p.0);
     UnicodeData { ranges: properties, to_lower, to_upper }
 }
@@ -402,48 +388,13 @@ fn generate_asserts(s: &mut String, property: &str, points: &[u32], truthy: bool
     }
 }
 
+/// Group the elements of `set` into contigous ranges
 fn ranges_from_set(set: &[u32]) -> Vec<Range<u32>> {
-    let mut ranges = set.iter().map(|e| (*e)..(*e + 1)).collect::<Vec<Range<u32>>>();
-    merge_ranges(&mut ranges);
-    ranges
-}
-
-fn merge_ranges(ranges: &mut Vec<Range<u32>>) {
-    loop {
-        let mut new_ranges = Vec::new();
-        let mut idx_iter = 0..(ranges.len() - 1);
-        let mut should_insert_last = true;
-        while let Some(idx) = idx_iter.next() {
-            let cur = ranges[idx].clone();
-            let next = ranges[idx + 1].clone();
-            if cur.end == next.start {
-                if idx_iter.next().is_none() {
-                    // We're merging the last element
-                    should_insert_last = false;
-                }
-                new_ranges.push(cur.start..next.end);
-            } else {
-                // We're *not* merging the last element
-                should_insert_last = true;
-                new_ranges.push(cur);
-            }
-        }
-        if should_insert_last {
-            new_ranges.push(ranges.last().unwrap().clone());
-        }
-        if new_ranges.len() == ranges.len() {
-            *ranges = new_ranges;
-            break;
-        } else {
-            *ranges = new_ranges;
-        }
-    }
-
-    let mut last_end = None;
-    for range in ranges {
-        if let Some(last) = last_end {
-            assert!(range.start > last, "{range:?}");
-        }
-        last_end = Some(range.end);
-    }
+    set.chunk_by(|a, b| a + 1 == *b)
+        .map(|chunk| {
+            let start = *chunk.first().unwrap();
+            let end = *chunk.last().unwrap();
+            start..(end + 1)
+        })
+        .collect()
 }

From 30d1bc7ba869c0f86bc6d2e1d9ed1ad3b58f7865 Mon Sep 17 00:00:00 2001
From: Karl Meakin <karl.meakin@arm.com>
Date: Sun, 10 Aug 2025 01:46:00 +0100
Subject: [PATCH 0090/1889] refactor: `generate_tests`

Rewrite `generate_tests` to be more idiomatic.
---
 src/tools/unicode-table-generator/src/main.rs | 97 +++++++++----------
 1 file changed, 45 insertions(+), 52 deletions(-)

diff --git a/src/tools/unicode-table-generator/src/main.rs b/src/tools/unicode-table-generator/src/main.rs
index bf0511a2c77ef..c9530fec48a00 100644
--- a/src/tools/unicode-table-generator/src/main.rs
+++ b/src/tools/unicode-table-generator/src/main.rs
@@ -72,6 +72,8 @@
 //! or not.
 
 use std::collections::{BTreeMap, HashMap};
+use std::fmt;
+use std::fmt::Write;
 use std::ops::Range;
 
 use ucd_parse::Codepoints;
@@ -222,7 +224,7 @@ fn main() {
     let ranges_by_property = &unicode_data.ranges;
 
     if let Some(path) = test_path {
-        std::fs::write(&path, generate_tests(&write_location, ranges_by_property)).unwrap();
+        std::fs::write(&path, generate_tests(ranges_by_property).unwrap()).unwrap();
     }
 
     let mut table_file = String::new();
@@ -326,66 +328,57 @@ fn fmt_list<V: std::fmt::Debug>(values: impl IntoIterator<Item = V>) -> String {
     out
 }
 
-fn generate_tests(data_path: &str, ranges: &[(&str, Vec<Range<u32>>)]) -> String {
+fn generate_tests(ranges: &[(&str, Vec<Range<u32>>)]) -> Result<String, fmt::Error> {
     let mut s = String::new();
-    s.push_str("#![allow(incomplete_features, unused)]\n");
-    s.push_str("#![feature(const_generics)]\n\n");
-    s.push_str("\n#[allow(unused)]\nuse std::hint;\n");
-    s.push_str(&format!("#[path = \"{data_path}\"]\n"));
-    s.push_str("mod unicode_data;\n\n");
-
-    s.push_str("\nfn main() {\n");
-
+    writeln!(s, "#![feature(core_intrinsics)]")?;
+    writeln!(s, "#![allow(internal_features, dead_code)]")?;
+    writeln!(s, "// ignore-tidy-filelength")?;
+    writeln!(s, "use std::intrinsics;")?;
+    writeln!(s, "mod unicode_data;")?;
+    writeln!(s, "fn main() {{")?;
     for (property, ranges) in ranges {
-        s.push_str(&format!(r#"    println!("Testing {property}");"#));
-        s.push('\n');
-        s.push_str(&format!("    {}_true();\n", property.to_lowercase()));
-        s.push_str(&format!("    {}_false();\n", property.to_lowercase()));
-        let mut is_true = Vec::new();
-        let mut is_false = Vec::new();
-        for ch_num in 0..(std::char::MAX as u32) {
-            if std::char::from_u32(ch_num).is_none() {
-                continue;
-            }
-            if ranges.iter().any(|r| r.contains(&ch_num)) {
-                is_true.push(ch_num);
-            } else {
-                is_false.push(ch_num);
-            }
-        }
-
-        s.push_str(&format!("    fn {}_true() {{\n", property.to_lowercase()));
-        generate_asserts(&mut s, property, &is_true, true);
-        s.push_str("    }\n\n");
-        s.push_str(&format!("    fn {}_false() {{\n", property.to_lowercase()));
-        generate_asserts(&mut s, property, &is_false, false);
-        s.push_str("    }\n\n");
+        let prop = property.to_lowercase();
+        writeln!(s, r#"    println!("Testing {prop}");"#)?;
+        writeln!(s, "    {prop}_true();")?;
+        writeln!(s, "    {prop}_false();")?;
+        let (is_true, is_false): (Vec<_>, Vec<_>) = (char::MIN..=char::MAX)
+            .filter(|c| !c.is_ascii())
+            .map(u32::from)
+            .partition(|c| ranges.iter().any(|r| r.contains(c)));
+
+        writeln!(s, "    fn {prop}_true() {{")?;
+        generate_asserts(&mut s, &prop, &is_true, true)?;
+        writeln!(s, "    }}")?;
+
+        writeln!(s, "    fn {prop}_false() {{")?;
+        generate_asserts(&mut s, &prop, &is_false, false)?;
+        writeln!(s, "    }}")?;
     }
 
-    s.push('}');
-    s
+    writeln!(s, "}}")?;
+    Ok(s)
 }
 
-fn generate_asserts(s: &mut String, property: &str, points: &[u32], truthy: bool) {
+fn generate_asserts(
+    s: &mut String,
+    prop: &str,
+    points: &[u32],
+    truthy: bool,
+) -> Result<(), fmt::Error> {
+    let truthy = if truthy { "" } else { "!" };
     for range in ranges_from_set(points) {
-        if range.end == range.start + 1 {
-            s.push_str(&format!(
-                "        assert!({}unicode_data::{}::lookup({:?}), \"{}\");\n",
-                if truthy { "" } else { "!" },
-                property.to_lowercase(),
-                std::char::from_u32(range.start).unwrap(),
-                range.start,
-            ));
-        } else {
-            s.push_str(&format!("        for chn in {range:?}u32 {{\n"));
-            s.push_str(&format!(
-                "            assert!({}unicode_data::{}::lookup(std::char::from_u32(chn).unwrap()), \"{{:?}}\", chn);\n",
-                if truthy { "" } else { "!" },
-                property.to_lowercase(),
-            ));
-            s.push_str("        }\n");
+        let start = char::from_u32(range.start).unwrap();
+        let end = char::from_u32(range.end - 1).unwrap();
+        match range.len() {
+            1 => writeln!(s, "        assert!({truthy}unicode_data::{prop}::lookup({start:?}));")?,
+            _ => {
+                writeln!(s, "        for c in {start:?}..={end:?} {{")?;
+                writeln!(s, "            assert!({truthy}unicode_data::{prop}::lookup(c));")?;
+                writeln!(s, "        }}")?;
+            }
         }
     }
+    Ok(())
 }
 
 /// Group the elements of `set` into contigous ranges

From c3ce0796544152460554d8b8db4e56528fe362db Mon Sep 17 00:00:00 2001
From: Karl Meakin <karl.meakin@arm.com>
Date: Sun, 10 Aug 2025 02:13:03 +0100
Subject: [PATCH 0091/1889] refactor: Add tests for case conversions

---
 .../src/case_mapping.rs                       |  4 +-
 src/tools/unicode-table-generator/src/main.rs | 48 +++++++++++++++----
 2 files changed, 41 insertions(+), 11 deletions(-)

diff --git a/src/tools/unicode-table-generator/src/case_mapping.rs b/src/tools/unicode-table-generator/src/case_mapping.rs
index a8527ea9a429a..49aef3ec33ec7 100644
--- a/src/tools/unicode-table-generator/src/case_mapping.rs
+++ b/src/tools/unicode-table-generator/src/case_mapping.rs
@@ -21,11 +21,11 @@ pub(crate) fn generate_case_mapping(data: &UnicodeData) -> (String, [usize; 2])
     (file, [lower_size, upper_size])
 }
 
-fn generate_tables(case: &str, data: &BTreeMap<u32, (u32, u32, u32)>) -> (String, usize) {
+fn generate_tables(case: &str, data: &BTreeMap<u32, [u32; 3]>) -> (String, usize) {
     let mut mappings = Vec::with_capacity(data.len());
     let mut multis = Vec::new();
 
-    for (&key, &(a, b, c)) in data.iter() {
+    for (&key, &[a, b, c]) in data.iter() {
         let key = char::from_u32(key).unwrap();
 
         if key.is_ascii() {
diff --git a/src/tools/unicode-table-generator/src/main.rs b/src/tools/unicode-table-generator/src/main.rs
index c9530fec48a00..1d70eebdbc6c2 100644
--- a/src/tools/unicode-table-generator/src/main.rs
+++ b/src/tools/unicode-table-generator/src/main.rs
@@ -100,11 +100,11 @@ static PROPERTIES: &[&str] = &[
 
 struct UnicodeData {
     ranges: Vec<(&'static str, Vec<Range<u32>>)>,
-    to_upper: BTreeMap<u32, (u32, u32, u32)>,
-    to_lower: BTreeMap<u32, (u32, u32, u32)>,
+    to_upper: BTreeMap<u32, [u32; 3]>,
+    to_lower: BTreeMap<u32, [u32; 3]>,
 }
 
-fn to_mapping(origin: u32, codepoints: Vec<ucd_parse::Codepoint>) -> Option<(u32, u32, u32)> {
+fn to_mapping(origin: u32, codepoints: Vec<ucd_parse::Codepoint>) -> Option<[u32; 3]> {
     let mut a = None;
     let mut b = None;
     let mut c = None;
@@ -125,7 +125,7 @@ fn to_mapping(origin: u32, codepoints: Vec<ucd_parse::Codepoint>) -> Option<(u32
         }
     }
 
-    Some((a.unwrap(), b.unwrap_or(0), c.unwrap_or(0)))
+    Some([a.unwrap(), b.unwrap_or(0), c.unwrap_or(0)])
 }
 
 static UNICODE_DIRECTORY: &str = "unicode-downloads";
@@ -165,12 +165,12 @@ fn load_data() -> UnicodeData {
         if let Some(mapped) = row.simple_lowercase_mapping
             && mapped != row.codepoint
         {
-            to_lower.insert(row.codepoint.value(), (mapped.value(), 0, 0));
+            to_lower.insert(row.codepoint.value(), [mapped.value(), 0, 0]);
         }
         if let Some(mapped) = row.simple_uppercase_mapping
             && mapped != row.codepoint
         {
-            to_upper.insert(row.codepoint.value(), (mapped.value(), 0, 0));
+            to_upper.insert(row.codepoint.value(), [mapped.value(), 0, 0]);
         }
     }
 
@@ -224,7 +224,7 @@ fn main() {
     let ranges_by_property = &unicode_data.ranges;
 
     if let Some(path) = test_path {
-        std::fs::write(&path, generate_tests(ranges_by_property).unwrap()).unwrap();
+        std::fs::write(&path, generate_tests(&unicode_data).unwrap()).unwrap();
     }
 
     let mut table_file = String::new();
@@ -328,7 +328,7 @@ fn fmt_list<V: std::fmt::Debug>(values: impl IntoIterator<Item = V>) -> String {
     out
 }
 
-fn generate_tests(ranges: &[(&str, Vec<Range<u32>>)]) -> Result<String, fmt::Error> {
+fn generate_tests(data: &UnicodeData) -> Result<String, fmt::Error> {
     let mut s = String::new();
     writeln!(s, "#![feature(core_intrinsics)]")?;
     writeln!(s, "#![allow(internal_features, dead_code)]")?;
@@ -336,7 +336,7 @@ fn generate_tests(ranges: &[(&str, Vec<Range<u32>>)]) -> Result<String, fmt::Err
     writeln!(s, "use std::intrinsics;")?;
     writeln!(s, "mod unicode_data;")?;
     writeln!(s, "fn main() {{")?;
-    for (property, ranges) in ranges {
+    for (property, ranges) in &data.ranges {
         let prop = property.to_lowercase();
         writeln!(s, r#"    println!("Testing {prop}");"#)?;
         writeln!(s, "    {prop}_true();")?;
@@ -355,6 +355,36 @@ fn generate_tests(ranges: &[(&str, Vec<Range<u32>>)]) -> Result<String, fmt::Err
         writeln!(s, "    }}")?;
     }
 
+    for (name, conversion) in ["to_lower", "to_upper"].iter().zip([&data.to_lower, &data.to_upper])
+    {
+        writeln!(s, r#"    println!("Testing {name}");"#)?;
+        for (c, mapping) in conversion {
+            let c = char::from_u32(*c).unwrap();
+            let mapping = mapping.map(|c| char::from_u32(c).unwrap());
+            writeln!(
+                s,
+                r#"    assert_eq!(unicode_data::conversions::{name}({c:?}), {mapping:?});"#
+            )?;
+        }
+        let unmapped: Vec<_> = (char::MIN..=char::MAX)
+            .filter(|c| !c.is_ascii())
+            .map(u32::from)
+            .filter(|c| !conversion.contains_key(c))
+            .collect();
+        let unmapped_ranges = ranges_from_set(&unmapped);
+        for range in unmapped_ranges {
+            let start = char::from_u32(range.start).unwrap();
+            let end = char::from_u32(range.end - 1).unwrap();
+            writeln!(s, "    for c in {start:?}..={end:?} {{")?;
+            writeln!(
+                s,
+                r#"        assert_eq!(unicode_data::conversions::{name}(c), [c, '\0', '\0']);"#
+            )?;
+
+            writeln!(s, "    }}")?;
+        }
+    }
+
     writeln!(s, "}}")?;
     Ok(s)
 }

From cc3c5cfb2e46c04778ebba4b0c71e87cb7f7cef7 Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Thu, 14 Aug 2025 17:04:54 +0000
Subject: [PATCH 0092/1889] Add test for webrender-2022 metrics

---
 .../crates/hir-ty/src/tests/traits.rs         | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
index 2e4346a86973b..9d72105624a05 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
@@ -4994,3 +4994,35 @@ fn main() {
         "#]],
     );
 }
+
+#[test]
+fn trait_object_binders() {
+    check_infer(
+        r#"
+//- minicore: iterator, dispatch_from_dyn
+fn main() {
+    struct Box<T: ?Sized>(*const T);
+    impl<I: Iterator + ?Sized> Iterator for Box<I> {
+        type Item = I::Item;
+        fn next(&mut self) -> Option<I::Item> {
+            loop {}
+        }
+    }
+    let iter: Box<dyn Iterator<Item = &[u8]> + 'static> = loop {};
+    let _ = iter.into_iter();
+}"#,
+        expect![[r#"
+            10..313 '{     ...r(); }': ()
+            223..227 'iter': Box<dyn Iterator<Item = &'? [u8]> + 'static>
+            273..280 'loop {}': !
+            278..280 '{}': ()
+            290..291 '_': Box<dyn Iterator<Item = &'? [u8]> + 'static>
+            294..298 'iter': Box<dyn Iterator<Item = &'? [u8]> + 'static>
+            294..310 'iter.i...iter()': Box<dyn Iterator<Item = &'? [u8]> + 'static>
+            152..156 'self': &'? mut Box<I>
+            177..208 '{     ...     }': Option<Iterator::Item<I>>
+            191..198 'loop {}': !
+            196..198 '{}': ()
+        "#]],
+    );
+}

From 06336efca9cd5851a72ff43db3641485e0e06a79 Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Fri, 15 Aug 2025 03:07:43 +0000
Subject: [PATCH 0093/1889] add comment

---
 .../rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
index 4696cf479c191..20cd8626f299b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
@@ -1148,6 +1148,13 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
                         }),
                     );
 
+                    // Rust and chalk have slightly different
+                    // representation for trait objects.
+                    //
+                    // Chalk uses `for<T0> for<'a> T0: Trait<'a>` while rustc
+                    // uses `ExistentialPredicate`s, which do not have a self ty.
+                    // We need to shift escaping bound vars by 1 to accommodate
+                    // the newly introduced `for<T0>` binder.
                     let p = shift_vars(interner, p, 1);
 
                     let where_clause = match p.skip_binder() {

From b38dd2acb598adb14bd1f08f39090909be13498b Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <mail4score@gmail.com>
Date: Fri, 15 Aug 2025 20:15:21 +0300
Subject: [PATCH 0094/1889] Use a more specific error message when talking
 about the server logs

---
 src/tools/rust-analyzer/crates/rust-analyzer/src/reload.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/reload.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/reload.rs
index f8f29eee126ed..a8a54930c6e5e 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/reload.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/reload.rs
@@ -152,7 +152,9 @@ impl GlobalState {
         if self.fetch_build_data_error().is_err() {
             status.health |= lsp_ext::Health::Warning;
             message.push_str("Failed to run build scripts of some packages.\n\n");
-            message.push_str("Please refer to the logs for more details on the errors.");
+            message.push_str(
+                "Please refer to the language server logs for more details on the errors.",
+            );
         }
         if let Some(err) = &self.config_errors {
             status.health |= lsp_ext::Health::Warning;

From 41405456daf54af9182e73277c417a6572d14200 Mon Sep 17 00:00:00 2001
From: Zihan <zihanli0822@gmail.com>
Date: Sat, 16 Aug 2025 01:23:37 -0400
Subject: [PATCH 0095/1889] `missing_inline_in_public_items`: fix lint emission
 source HirId

use trait item's HirId when emitting lint at `check_item` level

changelog: [`missing_inline_in_public_items`]: fix trait item lint emission

Signed-off-by: Zihan <zihanli0822@gmail.com>
---
 clippy_lints/src/missing_inline.rs | 38 ++++++++++++++----------------
 tests/ui/missing_inline.rs         |  7 ++++++
 2 files changed, 25 insertions(+), 20 deletions(-)

diff --git a/clippy_lints/src/missing_inline.rs b/clippy_lints/src/missing_inline.rs
index d02952eb48702..28555a6109001 100644
--- a/clippy_lints/src/missing_inline.rs
+++ b/clippy_lints/src/missing_inline.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint;
+use clippy_utils::diagnostics::{span_lint, span_lint_hir};
 use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{self as hir, Attribute, find_attr};
@@ -64,14 +64,20 @@ declare_clippy_lint! {
     "detects missing `#[inline]` attribute for public callables (functions, trait methods, methods...)"
 }
 
-fn check_missing_inline_attrs(cx: &LateContext<'_>, attrs: &[Attribute], sp: Span, desc: &'static str) {
+fn check_missing_inline_attrs(
+    cx: &LateContext<'_>,
+    attrs: &[Attribute],
+    sp: Span,
+    desc: &'static str,
+    hir_id: Option<hir::HirId>,
+) {
     if !find_attr!(attrs, AttributeKind::Inline(..)) {
-        span_lint(
-            cx,
-            MISSING_INLINE_IN_PUBLIC_ITEMS,
-            sp,
-            format!("missing `#[inline]` for {desc}"),
-        );
+        let msg = format!("missing `#[inline]` for {desc}");
+        if let Some(hir_id) = hir_id {
+            span_lint_hir(cx, MISSING_INLINE_IN_PUBLIC_ITEMS, hir_id, sp, msg);
+        } else {
+            span_lint(cx, MISSING_INLINE_IN_PUBLIC_ITEMS, sp, msg);
+        }
     }
 }
 
@@ -103,17 +109,9 @@ impl<'tcx> LateLintPass<'tcx> for MissingInline {
 
                 let desc = "a function";
                 let attrs = cx.tcx.hir_attrs(it.hir_id());
-                check_missing_inline_attrs(cx, attrs, it.span, desc);
+                check_missing_inline_attrs(cx, attrs, it.span, desc, None);
             },
-            hir::ItemKind::Trait(
-                ref _constness,
-                ref _is_auto,
-                ref _unsafe,
-                _ident,
-                _generics,
-                _bounds,
-                trait_items,
-            ) => {
+            hir::ItemKind::Trait(.., trait_items) => {
                 // note: we need to check if the trait is exported so we can't use
                 // `LateLintPass::check_trait_item` here.
                 for &tit in trait_items {
@@ -127,7 +125,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingInline {
                                 let desc = "a default trait method";
                                 let item = cx.tcx.hir_trait_item(tit);
                                 let attrs = cx.tcx.hir_attrs(item.hir_id());
-                                check_missing_inline_attrs(cx, attrs, item.span, desc);
+                                check_missing_inline_attrs(cx, attrs, item.span, desc, Some(tit.hir_id()));
                             }
                         },
                     }
@@ -182,7 +180,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingInline {
         }
 
         let attrs = cx.tcx.hir_attrs(impl_item.hir_id());
-        check_missing_inline_attrs(cx, attrs, impl_item.span, desc);
+        check_missing_inline_attrs(cx, attrs, impl_item.span, desc, None);
     }
 }
 
diff --git a/tests/ui/missing_inline.rs b/tests/ui/missing_inline.rs
index 223c7447975aa..8e937d609512a 100644
--- a/tests/ui/missing_inline.rs
+++ b/tests/ui/missing_inline.rs
@@ -97,3 +97,10 @@ pub mod issue15301 {
         println!("Just called a Rust function from Rust!");
     }
 }
+
+pub mod issue15491 {
+    pub trait Foo {
+        #[allow(clippy::missing_inline_in_public_items)]
+        fn foo(&self) {}
+    }
+}

From b9861fb75dda32fb349894fe8c73ab68d0c2f5f7 Mon Sep 17 00:00:00 2001
From: Shoyu Vanilla <modulo641@gmail.com>
Date: Sun, 17 Aug 2025 16:09:52 +0900
Subject: [PATCH 0096/1889] fix: Make lang items query properly filter out
 overwritten/excluded sysroots

---
 .../rust-analyzer/crates/base-db/src/lib.rs   |   2 +
 .../crates/hir-def/src/lang_item.rs           |  16 ++-
 .../crates/hir-def/src/nameres.rs             |   4 +
 .../crates/hir-def/src/nameres/collector.rs   |  19 +--
 .../crates/hir-ty/src/tests/regression.rs     |  51 +++++++
 .../rust-analyzer/crates/ide-db/src/lib.rs    |   6 +-
 .../crates/test-fixture/src/lib.rs            | 136 +++++++++++-------
 7 files changed, 166 insertions(+), 68 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/base-db/src/lib.rs b/src/tools/rust-analyzer/crates/base-db/src/lib.rs
index b8eadb608fea5..dbf949c470c4d 100644
--- a/src/tools/rust-analyzer/crates/base-db/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/base-db/src/lib.rs
@@ -30,6 +30,8 @@ use triomphe::Arc;
 pub use vfs::{AnchoredPath, AnchoredPathBuf, FileId, VfsPath, file_set::FileSet};
 
 pub type FxIndexSet<T> = indexmap::IndexSet<T, rustc_hash::FxBuildHasher>;
+pub type FxIndexMap<K, V> =
+    indexmap::IndexMap<K, V, std::hash::BuildHasherDefault<rustc_hash::FxHasher>>;
 
 #[macro_export]
 macro_rules! impl_intern_key {
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/lang_item.rs b/src/tools/rust-analyzer/crates/hir-def/src/lang_item.rs
index a0be69cb2f96e..600f206770016 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/lang_item.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/lang_item.rs
@@ -12,7 +12,7 @@ use crate::{
     StaticId, StructId, TraitId, TypeAliasId, UnionId,
     db::DefDatabase,
     expr_store::path::Path,
-    nameres::{assoc::TraitItems, crate_def_map},
+    nameres::{assoc::TraitItems, crate_def_map, crate_local_def_map},
 };
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -170,7 +170,19 @@ pub fn lang_item(
     {
         return Some(target);
     }
-    start_crate.data(db).dependencies.iter().find_map(|dep| lang_item(db, dep.crate_id, item))
+
+    // Our `CrateGraph` eagerly inserts sysroot dependencies like `core` or `std` into dependencies
+    // even if the target crate has `#![no_std]`, `#![no_core]` or shadowed sysroot dependencies
+    // like `dependencies.std.path = ".."`. So we use `extern_prelude()` instead of
+    // `CrateData.dependencies` here, which has already come through such sysroot complexities
+    // while nameres.
+    //
+    // See https://github.com/rust-lang/rust-analyzer/pull/20475 for details.
+    crate_local_def_map(db, start_crate).local(db).extern_prelude().find_map(|(_, (krate, _))| {
+        // Some crates declares themselves as extern crate like `extern crate self as core`.
+        // Ignore these to prevent cycles.
+        if krate.krate == start_crate { None } else { lang_item(db, krate.krate, item) }
+    })
 }
 
 #[derive(Default, Debug, Clone, PartialEq, Eq)]
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/nameres.rs b/src/tools/rust-analyzer/crates/hir-def/src/nameres.rs
index 5030585147dee..bf6fc15b7d199 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/nameres.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/nameres.rs
@@ -545,6 +545,10 @@ impl DefMap {
         self.data.no_std || self.data.no_core
     }
 
+    pub fn is_no_core(&self) -> bool {
+        self.data.no_core
+    }
+
     pub fn fn_as_proc_macro(&self, id: FunctionId) -> Option<ProcMacroId> {
         self.data.fn_proc_macro_mapping.get(&id).copied()
     }
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/nameres/collector.rs b/src/tools/rust-analyzer/crates/hir-def/src/nameres/collector.rs
index 07e61718222bf..0f84728dcb4a8 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/nameres/collector.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/nameres/collector.rs
@@ -27,10 +27,11 @@ use triomphe::Arc;
 
 use crate::{
     AdtId, AssocItemId, AstId, AstIdWithPath, ConstLoc, CrateRootModuleId, EnumLoc, ExternBlockLoc,
-    ExternCrateId, ExternCrateLoc, FunctionId, FunctionLoc, ImplLoc, Intern, ItemContainerId,
-    LocalModuleId, Lookup, Macro2Id, Macro2Loc, MacroExpander, MacroId, MacroRulesId,
-    MacroRulesLoc, MacroRulesLocFlags, ModuleDefId, ModuleId, ProcMacroId, ProcMacroLoc, StaticLoc,
-    StructLoc, TraitLoc, TypeAliasLoc, UnionLoc, UnresolvedMacro, UseId, UseLoc,
+    ExternCrateId, ExternCrateLoc, FunctionId, FunctionLoc, FxIndexMap, ImplLoc, Intern,
+    ItemContainerId, LocalModuleId, Lookup, Macro2Id, Macro2Loc, MacroExpander, MacroId,
+    MacroRulesId, MacroRulesLoc, MacroRulesLocFlags, ModuleDefId, ModuleId, ProcMacroId,
+    ProcMacroLoc, StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc, UnresolvedMacro, UseId,
+    UseLoc,
     attr::Attrs,
     db::DefDatabase,
     item_scope::{GlobId, ImportId, ImportOrExternCrate, PerNsGlobImports},
@@ -69,7 +70,7 @@ pub(super) fn collect_defs(
 
     // populate external prelude and dependency list
     let mut deps =
-        FxHashMap::with_capacity_and_hasher(krate.dependencies.len(), Default::default());
+        FxIndexMap::with_capacity_and_hasher(krate.dependencies.len(), Default::default());
     for dep in &krate.dependencies {
         tracing::debug!("crate dep {:?} -> {:?}", dep.name, dep.crate_id);
 
@@ -220,7 +221,7 @@ struct DefCollector<'db> {
     /// Set only in case of blocks.
     crate_local_def_map: Option<&'db LocalDefMap>,
     // The dependencies of the current crate, including optional deps like `test`.
-    deps: FxHashMap<Name, BuiltDependency>,
+    deps: FxIndexMap<Name, BuiltDependency>,
     glob_imports: FxHashMap<LocalModuleId, Vec<(LocalModuleId, Visibility, GlobId)>>,
     unresolved_imports: Vec<ImportDirective>,
     indeterminate_imports: Vec<(ImportDirective, PerNs)>,
@@ -332,7 +333,9 @@ impl<'db> DefCollector<'db> {
                 let skip = dep.is_sysroot()
                     && match dep.crate_id.data(self.db).origin {
                         CrateOrigin::Lang(LangCrateOrigin::Core) => crate_data.no_core,
-                        CrateOrigin::Lang(LangCrateOrigin::Std) => crate_data.no_std,
+                        CrateOrigin::Lang(LangCrateOrigin::Std) => {
+                            crate_data.no_core || crate_data.no_std
+                        }
                         _ => false,
                     };
                 if skip {
@@ -2550,7 +2553,7 @@ mod tests {
             def_map,
             local_def_map: LocalDefMap::default(),
             crate_local_def_map: None,
-            deps: FxHashMap::default(),
+            deps: FxIndexMap::default(),
             glob_imports: FxHashMap::default(),
             unresolved_imports: Vec::new(),
             indeterminate_imports: Vec::new(),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
index 25061e1dbdb9d..212fec4a4e4f4 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
@@ -2388,3 +2388,54 @@ pub trait Destruct {}
 "#,
     );
 }
+
+#[test]
+fn no_duplicated_lang_item_metadata() {
+    check_types(
+        r#"
+//- minicore: pointee
+//- /main.rs crate:main deps:std,core
+use std::AtomicPtr;
+use std::null_mut;
+
+fn main() {
+    let x: AtomicPtr<()> = AtomicPtr::new(null_mut());
+      //^ AtomicPtr<()>
+}
+
+//- /lib.rs crate:r#std deps:core
+#![no_std]
+pub use core::*;
+
+//- /lib.rs crate:r#core
+#![no_core]
+
+#[lang = "pointee_trait"]
+pub trait Pointee {
+    #[lang = "metadata_type"]
+    type Metadata;
+}
+
+pub struct AtomicPtr<T>(T);
+
+impl<T> AtomicPtr<T> {
+    pub fn new(p: *mut T) -> AtomicPtr<T> {
+        loop {}
+    }
+}
+
+#[lang = "pointee_sized"]
+pub trait PointeeSized {}
+#[lang = "meta_sized"]
+pub trait MetaSized: PointeeSized {}
+#[lang = "sized"]
+pub trait Sized: MetaSized {}
+
+pub trait Thin = Pointee<Metadata = ()> + PointeeSized;
+
+pub fn null_mut<T: PointeeSized + Thin>() -> *mut T {
+    loop {}
+}
+"#,
+    );
+}
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/lib.rs b/src/tools/rust-analyzer/crates/ide-db/src/lib.rs
index 1f074de4cd7d2..9d2474d91da67 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/lib.rs
@@ -66,13 +66,9 @@ pub use rustc_hash::{FxHashMap, FxHashSet, FxHasher};
 pub use ::line_index;
 
 /// `base_db` is normally also needed in places where `ide_db` is used, so this re-export is for convenience.
-pub use base_db;
+pub use base_db::{self, FxIndexMap, FxIndexSet};
 pub use span::{self, FileId};
 
-pub type FxIndexSet<T> = indexmap::IndexSet<T, std::hash::BuildHasherDefault<rustc_hash::FxHasher>>;
-pub type FxIndexMap<K, V> =
-    indexmap::IndexMap<K, V, std::hash::BuildHasherDefault<rustc_hash::FxHasher>>;
-
 pub type FilePosition = FilePositionWrapper<FileId>;
 pub type FileRange = FileRangeWrapper<FileId>;
 
diff --git a/src/tools/rust-analyzer/crates/test-fixture/src/lib.rs b/src/tools/rust-analyzer/crates/test-fixture/src/lib.rs
index 4413d2f222c15..57fca70547bf9 100644
--- a/src/tools/rust-analyzer/crates/test-fixture/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/test-fixture/src/lib.rs
@@ -3,8 +3,8 @@ use std::{any::TypeId, mem, str::FromStr, sync};
 
 use base_db::{
     Crate, CrateDisplayName, CrateGraphBuilder, CrateName, CrateOrigin, CrateWorkspaceData,
-    DependencyBuilder, Env, FileChange, FileSet, LangCrateOrigin, SourceDatabase, SourceRoot,
-    Version, VfsPath, salsa,
+    DependencyBuilder, Env, FileChange, FileSet, FxIndexMap, LangCrateOrigin, SourceDatabase,
+    SourceRoot, Version, VfsPath, salsa,
 };
 use cfg::CfgOptions;
 use hir_expand::{
@@ -20,7 +20,6 @@ use hir_expand::{
 };
 use intern::{Symbol, sym};
 use paths::AbsPathBuf;
-use rustc_hash::FxHashMap;
 use span::{Edition, FileId, Span};
 use stdx::itertools::Itertools;
 use test_utils::{
@@ -147,7 +146,7 @@ impl ChangeFixture {
 
         let mut files = Vec::new();
         let mut crate_graph = CrateGraphBuilder::default();
-        let mut crates = FxHashMap::default();
+        let mut crates = FxIndexMap::default();
         let mut crate_deps = Vec::new();
         let mut default_crate_root: Option<FileId> = None;
         let mut default_edition = Edition::CURRENT;
@@ -249,37 +248,7 @@ impl ChangeFixture {
             file_id = FileId::from_raw(file_id.index() + 1);
         }
 
-        if crates.is_empty() {
-            let crate_root = default_crate_root
-                .expect("missing default crate root, specify a main.rs or lib.rs");
-            crate_graph.add_crate_root(
-                crate_root,
-                default_edition,
-                Some(CrateName::new("ra_test_fixture").unwrap().into()),
-                None,
-                default_cfg.clone(),
-                Some(default_cfg),
-                default_env,
-                CrateOrigin::Local { repo: None, name: None },
-                false,
-                proc_macro_cwd.clone(),
-                crate_ws_data.clone(),
-            );
-        } else {
-            for (from, to, prelude) in crate_deps {
-                let from_id = crates[&from];
-                let to_id = crates[&to];
-                let sysroot = crate_graph[to_id].basic.origin.is_lang();
-                crate_graph
-                    .add_dep(
-                        from_id,
-                        DependencyBuilder::with_prelude(to.clone(), to_id, prelude, sysroot),
-                    )
-                    .unwrap();
-            }
-        }
-
-        if let Some(mini_core) = mini_core {
+        let mini_core = mini_core.map(|mini_core| {
             let core_file = file_id;
             file_id = FileId::from_raw(file_id.index() + 1);
 
@@ -289,8 +258,6 @@ impl ChangeFixture {
 
             source_change.change_file(core_file, Some(mini_core.source_code()));
 
-            let all_crates = crate_graph.iter().collect::<Vec<_>>();
-
             let core_crate = crate_graph.add_crate_root(
                 core_file,
                 Edition::CURRENT,
@@ -308,16 +275,58 @@ impl ChangeFixture {
                 crate_ws_data.clone(),
             );
 
-            for krate in all_crates {
+            (
+                move || {
+                    DependencyBuilder::with_prelude(
+                        CrateName::new("core").unwrap(),
+                        core_crate,
+                        true,
+                        true,
+                    )
+                },
+                core_crate,
+            )
+        });
+
+        if crates.is_empty() {
+            let crate_root = default_crate_root
+                .expect("missing default crate root, specify a main.rs or lib.rs");
+            let root = crate_graph.add_crate_root(
+                crate_root,
+                default_edition,
+                Some(CrateName::new("ra_test_fixture").unwrap().into()),
+                None,
+                default_cfg.clone(),
+                Some(default_cfg),
+                default_env,
+                CrateOrigin::Local { repo: None, name: None },
+                false,
+                proc_macro_cwd.clone(),
+                crate_ws_data.clone(),
+            );
+            if let Some((mini_core, _)) = mini_core {
+                crate_graph.add_dep(root, mini_core()).unwrap();
+            }
+        } else {
+            // Insert minicore first to match with `project-model::workspace`
+            if let Some((mini_core, core_crate)) = mini_core {
+                let all_crates = crate_graph.iter().collect::<Vec<_>>();
+                for krate in all_crates {
+                    if krate == core_crate {
+                        continue;
+                    }
+                    crate_graph.add_dep(krate, mini_core()).unwrap();
+                }
+            }
+
+            for (from, to, prelude) in crate_deps {
+                let from_id = crates[&from];
+                let to_id = crates[&to];
+                let sysroot = crate_graph[to_id].basic.origin.is_lang();
                 crate_graph
                     .add_dep(
-                        krate,
-                        DependencyBuilder::with_prelude(
-                            CrateName::new("core").unwrap(),
-                            core_crate,
-                            true,
-                            true,
-                        ),
+                        from_id,
+                        DependencyBuilder::with_prelude(to.clone(), to_id, prelude, sysroot),
                     )
                     .unwrap();
             }
@@ -627,11 +636,23 @@ impl FileMeta {
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum ForceNoneLangOrigin {
+    Yes,
+    No,
+}
+
 fn parse_crate(
     crate_str: String,
     current_source_root_kind: SourceRootKind,
     explicit_non_workspace_member: bool,
 ) -> (String, CrateOrigin, Option<String>) {
+    let (crate_str, force_non_lang_origin) = if let Some(s) = crate_str.strip_prefix("r#") {
+        (s.to_owned(), ForceNoneLangOrigin::Yes)
+    } else {
+        (crate_str, ForceNoneLangOrigin::No)
+    };
+
     // syntax:
     //   "my_awesome_crate"
     //   "my_awesome_crate@0.0.1,http://example.com"
@@ -646,16 +667,25 @@ fn parse_crate(
     let non_workspace_member = explicit_non_workspace_member
         || matches!(current_source_root_kind, SourceRootKind::Library);
 
-    let origin = match LangCrateOrigin::from(&*name) {
-        LangCrateOrigin::Other => {
-            let name = Symbol::intern(&name);
-            if non_workspace_member {
-                CrateOrigin::Library { repo, name }
-            } else {
-                CrateOrigin::Local { repo, name: Some(name) }
+    let origin = if force_non_lang_origin == ForceNoneLangOrigin::Yes {
+        let name = Symbol::intern(&name);
+        if non_workspace_member {
+            CrateOrigin::Library { repo, name }
+        } else {
+            CrateOrigin::Local { repo, name: Some(name) }
+        }
+    } else {
+        match LangCrateOrigin::from(&*name) {
+            LangCrateOrigin::Other => {
+                let name = Symbol::intern(&name);
+                if non_workspace_member {
+                    CrateOrigin::Library { repo, name }
+                } else {
+                    CrateOrigin::Local { repo, name: Some(name) }
+                }
             }
+            origin => CrateOrigin::Lang(origin),
         }
-        origin => CrateOrigin::Lang(origin),
     };
 
     (name, origin, version)

From 9c7ef48a7bedda1847acb0bfdfe7271e2268c2b7 Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Fri, 8 Aug 2025 02:06:01 +0000
Subject: [PATCH 0097/1889] Convert some of dyn_compatibility to next-solver
 and remove generic_predicates_without_parent_query

---
 .../rust-analyzer/crates/hir-ty/src/db.rs     |  10 --
 .../crates/hir-ty/src/dyn_compatibility.rs    | 104 +++++++++++++-----
 .../rust-analyzer/crates/hir-ty/src/lower.rs  |  16 ---
 src/tools/rust-analyzer/crates/hir/src/lib.rs |   2 +-
 4 files changed, 79 insertions(+), 53 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
index 6e24aea76d445..7a5daac69922f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
@@ -179,16 +179,6 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
     #[salsa::invoke(crate::lower::generic_predicates_query)]
     fn generic_predicates(&self, def: GenericDefId) -> GenericPredicates;
 
-    #[salsa::invoke(crate::lower::generic_predicates_without_parent_with_diagnostics_query)]
-    fn generic_predicates_without_parent_with_diagnostics(
-        &self,
-        def: GenericDefId,
-    ) -> (GenericPredicates, Diagnostics);
-
-    #[salsa::invoke(crate::lower::generic_predicates_without_parent_query)]
-    #[salsa::transparent]
-    fn generic_predicates_without_parent(&self, def: GenericDefId) -> GenericPredicates;
-
     #[salsa::invoke(crate::lower::trait_environment_for_body_query)]
     #[salsa::transparent]
     fn trait_environment_for_body(&self, def: DefWithBodyId) -> Arc<TraitEnvironment>;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
index 2d21947ec60fc..f571b64464d92 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
@@ -13,6 +13,9 @@ use hir_def::{
     TypeAliasId, lang_item::LangItem, signatures::TraitFlags,
 };
 use rustc_hash::FxHashSet;
+use rustc_type_ir::{
+    AliasTyKind, ClauseKind, PredicatePolarity, TypeSuperVisitable as _, inherent::IntoKind,
+};
 use smallvec::SmallVec;
 
 use crate::{
@@ -21,6 +24,7 @@ use crate::{
     db::HirDatabase,
     from_assoc_type_id, from_chalk_trait_id,
     generics::{generics, trait_self_param_idx},
+    next_solver::{DbInterner, SolverDefId, TraitPredicate},
     to_chalk_trait_id,
     utils::elaborate_clause_supertraits,
 };
@@ -319,6 +323,61 @@ fn contains_illegal_self_type_reference<T: TypeVisitable<Interner>>(
     t.visit_with(visitor.as_dyn(), outer_binder).is_break()
 }
 
+fn contains_illegal_self_type_reference_ns<
+    'db,
+    T: rustc_type_ir::TypeVisitable<DbInterner<'db>>,
+>(
+    db: &'db dyn HirDatabase,
+    trait_: TraitId,
+    t: &T,
+    allow_self_projection: AllowSelfProjection,
+) -> bool {
+    struct IllegalSelfTypeVisitor<'db> {
+        db: &'db dyn HirDatabase,
+        trait_: TraitId,
+        super_traits: Option<SmallVec<[TraitId; 4]>>,
+        allow_self_projection: AllowSelfProjection,
+    }
+    impl<'db> rustc_type_ir::TypeVisitor<DbInterner<'db>> for IllegalSelfTypeVisitor<'db> {
+        type Result = ControlFlow<()>;
+
+        fn visit_ty(
+            &mut self,
+            ty: <DbInterner<'db> as rustc_type_ir::Interner>::Ty,
+        ) -> Self::Result {
+            match ty.kind() {
+                rustc_type_ir::TyKind::Param(param) if param.index == 0 => ControlFlow::Break(()),
+                rustc_type_ir::TyKind::Param(_) => ControlFlow::Continue(()),
+                rustc_type_ir::TyKind::Alias(AliasTyKind::Projection, proj) => match self
+                    .allow_self_projection
+                {
+                    AllowSelfProjection::Yes => {
+                        let trait_ = proj.trait_def_id(DbInterner::new_with(self.db, None, None));
+                        let trait_ = match trait_ {
+                            SolverDefId::TraitId(id) => id,
+                            _ => unreachable!(),
+                        };
+                        if self.super_traits.is_none() {
+                            self.super_traits = Some(all_super_traits(self.db, self.trait_));
+                        }
+                        if self.super_traits.as_ref().is_some_and(|s| s.contains(&trait_)) {
+                            ControlFlow::Continue(())
+                        } else {
+                            ty.super_visit_with(self)
+                        }
+                    }
+                    AllowSelfProjection::No => ty.super_visit_with(self),
+                },
+                _ => ty.super_visit_with(self),
+            }
+        }
+    }
+
+    let mut visitor =
+        IllegalSelfTypeVisitor { db, trait_, super_traits: None, allow_self_projection };
+    t.visit_with(&mut visitor).is_break()
+}
+
 fn dyn_compatibility_violation_for_assoc_item<F>(
     db: &dyn HirDatabase,
     trait_: TraitId,
@@ -415,40 +474,33 @@ where
         cb(MethodViolationCode::UndispatchableReceiver)?;
     }
 
-    let predicates = &*db.generic_predicates_without_parent(func.into());
-    let trait_self_idx = trait_self_param_idx(db, func.into());
+    let predicates = &*db.generic_predicates_without_parent_ns(func.into());
     for pred in predicates {
-        let pred = pred.skip_binders().skip_binders();
+        let pred = pred.kind().skip_binder();
 
-        if matches!(pred, WhereClause::TypeOutlives(_)) {
+        if matches!(pred, ClauseKind::TypeOutlives(_)) {
             continue;
         }
 
         // Allow `impl AutoTrait` predicates
-        if let WhereClause::Implemented(TraitRef { trait_id, substitution }) = pred {
-            let trait_data = db.trait_signature(from_chalk_trait_id(*trait_id));
-            if trait_data.flags.contains(TraitFlags::AUTO)
-                && substitution
-                    .as_slice(Interner)
-                    .first()
-                    .and_then(|arg| arg.ty(Interner))
-                    .and_then(|ty| ty.bound_var(Interner))
-                    .is_some_and(|b| {
-                        b.debruijn == DebruijnIndex::ONE && Some(b.index) == trait_self_idx
-                    })
-            {
-                continue;
-            }
+        let interner = DbInterner::new_with(db, None, None);
+        if let ClauseKind::Trait(TraitPredicate {
+            trait_ref: pred_trait_ref,
+            polarity: PredicatePolarity::Positive,
+        }) = pred
+            && let SolverDefId::TraitId(trait_id) = pred_trait_ref.def_id
+            && let trait_data = db.trait_signature(trait_id)
+            && trait_data.flags.contains(TraitFlags::AUTO)
+            && pred_trait_ref.self_ty()
+                == crate::next_solver::Ty::new(
+                    interner,
+                    rustc_type_ir::TyKind::Param(crate::next_solver::ParamTy { index: 0 }),
+                )
+        {
+            continue;
         }
 
-        if contains_illegal_self_type_reference(
-            db,
-            func.into(),
-            trait_,
-            pred,
-            DebruijnIndex::ONE,
-            AllowSelfProjection::Yes,
-        ) {
+        if contains_illegal_self_type_reference_ns(db, trait_, &pred, AllowSelfProjection::Yes) {
             cb(MethodViolationCode::WhereClauseReferencesSelf)?;
             break;
         }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
index 7b6b3c3f8181a..065d2ea084070 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
@@ -1179,22 +1179,6 @@ pub(crate) fn generic_predicates_query(
     generic_predicates_filtered_by(db, def, |_, _| true).0
 }
 
-pub(crate) fn generic_predicates_without_parent_query(
-    db: &dyn HirDatabase,
-    def: GenericDefId,
-) -> GenericPredicates {
-    db.generic_predicates_without_parent_with_diagnostics(def).0
-}
-
-/// Resolve the where clause(s) of an item with generics,
-/// except the ones inherited from the parent
-pub(crate) fn generic_predicates_without_parent_with_diagnostics_query(
-    db: &dyn HirDatabase,
-    def: GenericDefId,
-) -> (GenericPredicates, Diagnostics) {
-    generic_predicates_filtered_by(db, def, |_, d| d == def)
-}
-
 /// Resolve the where clause(s) of an item with generics,
 /// with a given filter
 fn generic_predicates_filtered_by<F>(
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index 4eb50c1c31c52..11486ec8d6690 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -3750,7 +3750,7 @@ impl GenericDef {
         push_ty_diagnostics(
             db,
             acc,
-            db.generic_predicates_without_parent_with_diagnostics(def).1,
+            db.generic_predicates_without_parent_with_diagnostics_ns(def).1,
             &source_map,
         );
         for (param_id, param) in generics.iter_type_or_consts() {

From a25a1e34eca61265a78593e5438062033b68f2ca Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Fri, 8 Aug 2025 21:10:47 +0000
Subject: [PATCH 0098/1889] Convert more of dyn_compatibility to next-solver

---
 .../crates/hir-ty/src/dyn_compatibility.rs    | 253 +++++++++---------
 1 file changed, 123 insertions(+), 130 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
index f571b64464d92..237cc34d7099b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
@@ -4,7 +4,6 @@ use std::ops::ControlFlow;
 
 use chalk_ir::{
     DebruijnIndex,
-    cast::Cast,
     visit::{TypeSuperVisitable, TypeVisitable, TypeVisitor},
 };
 use chalk_solve::rust_ir::InlineBound;
@@ -12,20 +11,26 @@ use hir_def::{
     AssocItemId, ConstId, CrateRootModuleId, FunctionId, GenericDefId, HasModule, TraitId,
     TypeAliasId, lang_item::LangItem, signatures::TraitFlags,
 };
+use intern::Symbol;
 use rustc_hash::FxHashSet;
 use rustc_type_ir::{
-    AliasTyKind, ClauseKind, PredicatePolarity, TypeSuperVisitable as _, inherent::IntoKind,
+    AliasTyKind, ClauseKind, PredicatePolarity, TypeSuperVisitable as _, TypeVisitable as _,
+    Upcast,
+    inherent::{IntoKind, SliceLike},
 };
 use smallvec::SmallVec;
 
 use crate::{
-    AliasEq, AliasTy, Binders, BoundVar, CallableSig, DomainGoal, GoalData, ImplTraitId, Interner,
-    OpaqueTyId, ProjectionTyExt, Substitution, TraitRef, Ty, TyKind, WhereClause, all_super_traits,
-    db::HirDatabase,
+    AliasEq, AliasTy, Binders, BoundVar, ImplTraitId, Interner, ProjectionTyExt, Ty, TyKind,
+    WhereClause, all_super_traits,
+    db::{HirDatabase, InternedOpaqueTyId},
     from_assoc_type_id, from_chalk_trait_id,
-    generics::{generics, trait_self_param_idx},
-    next_solver::{DbInterner, SolverDefId, TraitPredicate},
-    to_chalk_trait_id,
+    generics::trait_self_param_idx,
+    next_solver::{
+        Clauses, DbInterner, GenericArgs, ParamEnv, SolverDefId, TraitPredicate, TypingMode,
+        infer::DbInternerInferExt, mk_param,
+    },
+    traits::next_trait_solve_in_ctxt,
     utils::elaborate_clause_supertraits,
 };
 
@@ -434,26 +439,17 @@ where
         cb(MethodViolationCode::AsyncFn)?;
     }
 
-    let sig = db.callable_item_signature(func.into());
-    if sig.skip_binders().params().iter().skip(1).any(|ty| {
-        contains_illegal_self_type_reference(
-            db,
-            func.into(),
-            trait_,
-            ty,
-            DebruijnIndex::INNERMOST,
-            AllowSelfProjection::Yes,
-        )
+    let sig = db.callable_item_signature_ns(func.into());
+    if sig.skip_binder().inputs().iter().skip(1).any(|ty| {
+        contains_illegal_self_type_reference_ns(db, trait_, &ty, AllowSelfProjection::Yes)
     }) {
         cb(MethodViolationCode::ReferencesSelfInput)?;
     }
 
-    if contains_illegal_self_type_reference(
+    if contains_illegal_self_type_reference_ns(
         db,
-        func.into(),
         trait_,
-        sig.skip_binders().ret(),
-        DebruijnIndex::INNERMOST,
+        &sig.skip_binder().output(),
         AllowSelfProjection::Yes,
     ) {
         cb(MethodViolationCode::ReferencesSelfOutput)?;
@@ -483,7 +479,7 @@ where
         }
 
         // Allow `impl AutoTrait` predicates
-        let interner = DbInterner::new_with(db, None, None);
+        let interner = DbInterner::new_with(db, Some(trait_.krate(db)), None);
         if let ClauseKind::Trait(TraitPredicate {
             trait_ref: pred_trait_ref,
             polarity: PredicatePolarity::Positive,
@@ -509,34 +505,30 @@ where
     ControlFlow::Continue(())
 }
 
-fn receiver_is_dispatchable(
+fn receiver_is_dispatchable<'db>(
     db: &dyn HirDatabase,
     trait_: TraitId,
     func: FunctionId,
-    sig: &Binders<CallableSig>,
+    sig: &crate::next_solver::EarlyBinder<
+        'db,
+        crate::next_solver::Binder<'db, rustc_type_ir::FnSig<DbInterner<'db>>>,
+    >,
 ) -> bool {
-    let Some(trait_self_idx) = trait_self_param_idx(db, func.into()) else {
-        return false;
-    };
+    let sig = sig.instantiate_identity();
+
+    let interner: DbInterner<'_> = DbInterner::new_with(db, Some(trait_.krate(db)), None);
+    let self_param_ty = crate::next_solver::Ty::new(
+        interner,
+        rustc_type_ir::TyKind::Param(crate::next_solver::ParamTy { index: 0 }),
+    );
 
     // `self: Self` can't be dispatched on, but this is already considered dyn-compatible
     // See rustc's comment on https://github.com/rust-lang/rust/blob/3f121b9461cce02a703a0e7e450568849dfaa074/compiler/rustc_trait_selection/src/traits/object_safety.rs#L433-L437
-    if sig
-        .skip_binders()
-        .params()
-        .first()
-        .and_then(|receiver| receiver.bound_var(Interner))
-        .is_some_and(|b| {
-            b == BoundVar { debruijn: DebruijnIndex::INNERMOST, index: trait_self_idx }
-        })
-    {
+    if sig.inputs().iter().next().is_some_and(|p| p.skip_binder() == self_param_ty) {
         return true;
     }
 
-    let placeholder_subst = generics(db, func.into()).placeholder_subst(db);
-
-    let substituted_sig = sig.clone().substitute(Interner, &placeholder_subst);
-    let Some(receiver_ty) = substituted_sig.params().first() else {
+    let Some(&receiver_ty) = sig.inputs().skip_binder().as_slice().first() else {
         return false;
     };
 
@@ -549,118 +541,119 @@ fn receiver_is_dispatchable(
         return false;
     };
 
-    // Type `U`
-    let unsized_self_ty =
-        TyKind::Scalar(chalk_ir::Scalar::Uint(chalk_ir::UintTy::U32)).intern(Interner);
-    // `Receiver[Self => U]`
-    let Some(unsized_receiver_ty) = receiver_for_self_ty(db, func, unsized_self_ty.clone()) else {
+    let meta_sized_did = LangItem::MetaSized.resolve_trait(db, krate);
+    let Some(meta_sized_did) = meta_sized_did else {
         return false;
     };
 
-    let self_ty = placeholder_subst.as_slice(Interner)[trait_self_idx].assert_ty_ref(Interner);
-    let unsized_predicate = WhereClause::Implemented(TraitRef {
-        trait_id: to_chalk_trait_id(unsize_did),
-        substitution: Substitution::from_iter(Interner, [self_ty.clone(), unsized_self_ty.clone()]),
-    });
-    let unsized_predicate =
-        Binders::empty(Interner, unsized_predicate.cast::<DomainGoal>(Interner));
-    let trait_predicate = WhereClause::Implemented(TraitRef {
-        trait_id: to_chalk_trait_id(trait_),
-        substitution: Substitution::from_iter(
-            Interner,
-            std::iter::once(unsized_self_ty.cast(Interner))
-                .chain(placeholder_subst.iter(Interner).skip(1).cloned()),
-        ),
-    });
-    let trait_predicate = Binders::empty(Interner, trait_predicate.cast::<DomainGoal>(Interner));
-
-    let generic_predicates = &*db.generic_predicates(func.into());
+    // Type `U`
+    let unsized_self_ty = crate::next_solver::Ty::new_param(interner, u32::MAX, Symbol::empty());
+    // `Receiver[Self => U]`
+    let unsized_receiver_ty = receiver_for_self_ty(interner, func, receiver_ty, unsized_self_ty);
+
+    let param_env = {
+        let generic_predicates = &*db.generic_predicates_ns(func.into());
+
+        // Self: Unsize<U>
+        let unsize_predicate = crate::next_solver::TraitRef::new(
+            interner,
+            SolverDefId::TraitId(unsize_did),
+            [self_param_ty, unsized_self_ty],
+        );
+
+        // U: Trait<Arg1, ..., ArgN>
+        let trait_def_id = SolverDefId::TraitId(trait_);
+        let args = GenericArgs::for_item(interner, trait_def_id, |name, index, kind, _| {
+            if index == 0 { unsized_self_ty.into() } else { mk_param(index, name, kind) }
+        });
+        let trait_predicate =
+            crate::next_solver::TraitRef::new_from_args(interner, trait_def_id, args);
+
+        let meta_sized_predicate = crate::next_solver::TraitRef::new(
+            interner,
+            SolverDefId::TraitId(meta_sized_did),
+            [unsized_self_ty],
+        );
+
+        ParamEnv {
+            clauses: Clauses::new_from_iter(
+                interner,
+                generic_predicates.iter().copied().chain([
+                    unsize_predicate.upcast(interner),
+                    trait_predicate.upcast(interner),
+                    meta_sized_predicate.upcast(interner),
+                ]),
+            ),
+        }
+    };
 
-    let goals = std::iter::once(unsized_predicate).chain(std::iter::once(trait_predicate)).chain(
-        generic_predicates.iter().map(|pred| {
-            pred.clone()
-                .substitute(Interner, &placeholder_subst)
-                .map(|g| g.cast::<DomainGoal>(Interner))
-        }),
-    );
-    let clauses = chalk_ir::ProgramClauses::from_iter(
-        Interner,
-        goals.into_iter().map(|g| {
-            chalk_ir::ProgramClause::new(
-                Interner,
-                chalk_ir::ProgramClauseData(g.map(|g| chalk_ir::ProgramClauseImplication {
-                    consequence: g,
-                    conditions: chalk_ir::Goals::empty(Interner),
-                    constraints: chalk_ir::Constraints::empty(Interner),
-                    priority: chalk_ir::ClausePriority::High,
-                })),
-            )
-        }),
+    // Receiver: DispatchFromDyn<Receiver[Self => U]>
+    let predicate = crate::next_solver::TraitRef::new(
+        interner,
+        SolverDefId::TraitId(dispatch_from_dyn_did),
+        [receiver_ty, unsized_receiver_ty],
     );
-    let env: chalk_ir::Environment<Interner> = chalk_ir::Environment { clauses };
-
-    let obligation = WhereClause::Implemented(TraitRef {
-        trait_id: to_chalk_trait_id(dispatch_from_dyn_did),
-        substitution: Substitution::from_iter(Interner, [receiver_ty.clone(), unsized_receiver_ty]),
-    });
-    let goal = GoalData::DomainGoal(chalk_ir::DomainGoal::Holds(obligation)).intern(Interner);
-
-    let in_env = chalk_ir::InEnvironment::new(&env, goal);
+    let goal = crate::next_solver::Goal::new(interner, param_env, predicate);
 
-    let mut table = chalk_solve::infer::InferenceTable::<Interner>::new();
-    let canonicalized = table.canonicalize(Interner, in_env);
-
-    db.trait_solve(krate, None, canonicalized.quantified).certain()
+    let infcx = interner.infer_ctxt().build(TypingMode::non_body_analysis());
+    // the receiver is dispatchable iff the obligation holds
+    let res = next_trait_solve_in_ctxt(&infcx, goal);
+    res.map_or(false, |res| matches!(res.1, rustc_type_ir::solve::Certainty::Yes))
 }
 
-fn receiver_for_self_ty(db: &dyn HirDatabase, func: FunctionId, ty: Ty) -> Option<Ty> {
-    let generics = generics(db, func.into());
-    let trait_self_idx = trait_self_param_idx(db, func.into())?;
-    let subst = generics.placeholder_subst(db);
-    let subst = Substitution::from_iter(
-        Interner,
-        subst.iter(Interner).enumerate().map(|(idx, arg)| {
-            if idx == trait_self_idx { ty.clone().cast(Interner) } else { arg.clone() }
-        }),
+fn receiver_for_self_ty<'db>(
+    interner: DbInterner<'db>,
+    func: FunctionId,
+    receiver_ty: crate::next_solver::Ty<'db>,
+    self_ty: crate::next_solver::Ty<'db>,
+) -> crate::next_solver::Ty<'db> {
+    let args = crate::next_solver::GenericArgs::for_item(
+        interner,
+        SolverDefId::FunctionId(func),
+        |name, index, kind, _| {
+            if index == 0 { self_ty.into() } else { mk_param(index, name, kind) }
+        },
     );
-    let sig = db.callable_item_signature(func.into());
-    let sig = sig.substitute(Interner, &subst);
-    sig.params_and_return.first().cloned()
+
+    
+    crate::next_solver::EarlyBinder::bind(receiver_ty).instantiate(interner, args)
 }
 
-fn contains_illegal_impl_trait_in_trait(
-    db: &dyn HirDatabase,
-    sig: &Binders<CallableSig>,
+fn contains_illegal_impl_trait_in_trait<'db>(
+    db: &'db dyn HirDatabase,
+    sig: &crate::next_solver::EarlyBinder<
+        'db,
+        crate::next_solver::Binder<'db, rustc_type_ir::FnSig<DbInterner<'db>>>,
+    >,
 ) -> Option<MethodViolationCode> {
-    struct OpaqueTypeCollector(FxHashSet<OpaqueTyId>);
-
-    impl TypeVisitor<Interner> for OpaqueTypeCollector {
-        type BreakTy = ();
-
-        fn as_dyn(&mut self) -> &mut dyn TypeVisitor<Interner, BreakTy = Self::BreakTy> {
-            self
-        }
+    struct OpaqueTypeCollector(FxHashSet<InternedOpaqueTyId>);
 
-        fn interner(&self) -> Interner {
-            Interner
-        }
+    impl<'db> rustc_type_ir::TypeVisitor<DbInterner<'db>> for OpaqueTypeCollector {
+        type Result = ControlFlow<()>;
 
-        fn visit_ty(&mut self, ty: &Ty, outer_binder: DebruijnIndex) -> ControlFlow<Self::BreakTy> {
-            if let TyKind::OpaqueType(opaque_ty_id, _) = ty.kind(Interner) {
-                self.0.insert(*opaque_ty_id);
+        fn visit_ty(
+            &mut self,
+            ty: <DbInterner<'db> as rustc_type_ir::Interner>::Ty,
+        ) -> Self::Result {
+            if let rustc_type_ir::TyKind::Alias(AliasTyKind::Opaque, op) = ty.kind() {
+                let id = match op.def_id {
+                    SolverDefId::InternedOpaqueTyId(id) => id,
+                    _ => unreachable!(),
+                };
+                self.0.insert(id);
             }
-            ty.super_visit_with(self.as_dyn(), outer_binder)
+            ty.super_visit_with(self)
         }
     }
 
-    let ret = sig.skip_binders().ret();
+    let ret = sig.skip_binder().output();
     let mut visitor = OpaqueTypeCollector(FxHashSet::default());
-    _ = ret.visit_with(visitor.as_dyn(), DebruijnIndex::INNERMOST);
+    _ = ret.visit_with(&mut visitor);
 
     // Since we haven't implemented RPITIT in proper way like rustc yet,
     // just check whether `ret` contains RPIT for now
     for opaque_ty in visitor.0 {
-        let impl_trait_id = db.lookup_intern_impl_trait_id(opaque_ty.into());
+        let impl_trait_id = db.lookup_intern_impl_trait_id(opaque_ty);
         if matches!(impl_trait_id, ImplTraitId::ReturnTypeImplTrait(..)) {
             return Some(MethodViolationCode::ReferencesImplTraitInTrait);
         }

From 3f78a1fd5af1bc436062b9b5045b813304b9bb05 Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Sat, 9 Aug 2025 23:28:48 +0000
Subject: [PATCH 0099/1889] impl HirDisplay for next_solver::Ty

---
 .../crates/hir-ty/src/consteval_nextsolver.rs |   8 +-
 .../crates/hir-ty/src/display.rs              | 551 ++++++++++--------
 .../crates/hir-ty/src/dyn_compatibility.rs    |   1 -
 .../rust-analyzer/crates/hir-ty/src/layout.rs |   4 +-
 .../rust-analyzer/crates/hir-ty/src/lib.rs    |  23 +
 .../crates/hir-ty/src/next_solver/mapping.rs  |   7 +-
 .../next_solver/project/solve_normalize.rs    |  13 +-
 .../crates/hir-ty/src/primitive.rs            |  34 ++
 .../rust-analyzer/crates/hir-ty/src/tests.rs  |  40 +-
 .../hir-ty/src/tests/closure_captures.rs      |  12 +-
 .../crates/hir-ty/src/tests/opaque_types.rs   |   2 +-
 .../crates/hir-ty/src/tests/regression.rs     |   6 +-
 .../crates/hir-ty/src/tests/traits.rs         |  52 +-
 src/tools/rust-analyzer/crates/hir/src/lib.rs |  13 +-
 .../ide-completion/src/context/tests.rs       |   7 +-
 .../crates/ide/src/hover/render.rs            |   2 +-
 .../crates/ide/src/inlay_hints.rs             |  76 +--
 .../crates/ide/src/inlay_hints/adjustment.rs  |  18 +-
 src/tools/rust-analyzer/crates/ide/src/lib.rs |  12 +-
 .../crates/ide/src/navigation_target.rs       |  11 +-
 .../rust-analyzer/crates/ide/src/runnables.rs |  18 +-
 .../crates/ide/src/signature_help.rs          |   5 +-
 .../crates/ide/src/static_index.rs            |  52 +-
 .../crates/ide/src/view_memory_layout.rs      |   9 +-
 24 files changed, 584 insertions(+), 392 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs
index da4aff54de378..cdf861290ab92 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs
@@ -132,9 +132,9 @@ pub fn usize_const<'db>(db: &'db dyn HirDatabase, value: Option<u128>, krate: Cr
     )
 }
 
-pub fn try_const_usize<'db>(db: &'db dyn HirDatabase, c: &Const<'db>) -> Option<u128> {
+pub fn try_const_usize<'db>(db: &'db dyn HirDatabase, c: Const<'db>) -> Option<u128> {
     let interner = DbInterner::new_with(db, None, None);
-    match (*c).kind() {
+    match c.kind() {
         ConstKind::Param(_) => None,
         ConstKind::Infer(_) => None,
         ConstKind::Bound(_, _) => None,
@@ -147,7 +147,7 @@ pub fn try_const_usize<'db>(db: &'db dyn HirDatabase, c: &Const<'db>) -> Option<
             };
             let subst = convert_args_for_result(interner, unevaluated_const.args.as_slice());
             let ec = db.const_eval(c, subst, None).ok()?.to_nextsolver(interner);
-            try_const_usize(db, &ec)
+            try_const_usize(db, ec)
         }
         ConstKind::Value(val) => Some(u128::from_le_bytes(pad16(&val.value.inner().0, false))),
         ConstKind::Error(_) => None,
@@ -212,7 +212,7 @@ pub(crate) fn const_eval_discriminant_variant(
     let c = if is_signed {
         try_const_isize(db, &c).unwrap()
     } else {
-        try_const_usize(db, &c).unwrap() as i128
+        try_const_usize(db, c).unwrap() as i128
     };
     Ok(c)
 }
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 8f35a3c214551..9f87c37834d77 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
@@ -11,8 +11,8 @@ use base_db::Crate;
 use chalk_ir::{BoundVar, Safety, TyKind};
 use either::Either;
 use hir_def::{
-    GenericDefId, HasModule, ImportPathConfig, ItemContainerId, LocalFieldId, Lookup, ModuleDefId,
-    ModuleId, TraitId,
+    GenericDefId, HasModule, ImportPathConfig, LocalFieldId, Lookup, ModuleDefId, ModuleId,
+    TraitId,
     db::DefDatabase,
     expr_store::{ExpressionStore, path::Path},
     find_path::{self, PrefixKind},
@@ -37,26 +37,34 @@ use rustc_apfloat::{
     ieee::{Half as f16, Quad as f128},
 };
 use rustc_hash::FxHashSet;
+use rustc_type_ir::{
+    AliasTyKind,
+    inherent::{AdtDef, IntoKind, SliceLike},
+};
 use smallvec::SmallVec;
 use span::Edition;
 use stdx::never;
 use triomphe::Arc;
 
 use crate::{
-    AdtId, AliasEq, AliasTy, Binders, CallableDefId, CallableSig, ConcreteConst, Const,
-    ConstScalar, ConstValue, DomainGoal, FnAbi, GenericArg, ImplTraitId, Interner, Lifetime,
-    LifetimeData, LifetimeOutlives, MemoryMap, Mutability, OpaqueTy, ProjectionTy, ProjectionTyExt,
-    QuantifiedWhereClause, Scalar, Substitution, TraitEnvironment, TraitRef, TraitRefExt, Ty,
-    TyExt, WhereClause,
-    consteval::try_const_usize,
+    AliasEq, AliasTy, Binders, CallableDefId, CallableSig, ConcreteConst, Const, ConstScalar,
+    ConstValue, DomainGoal, FnAbi, GenericArg, ImplTraitId, Interner, Lifetime, LifetimeData,
+    LifetimeOutlives, MemoryMap, OpaqueTy, ProjectionTy, ProjectionTyExt, QuantifiedWhereClause,
+    TraitEnvironment, TraitRef, TraitRefExt, Ty, TyExt, WhereClause, consteval_nextsolver,
     db::{HirDatabase, InternedClosure},
-    from_assoc_type_id, from_foreign_def_id, from_placeholder_idx,
+    from_assoc_type_id, from_placeholder_idx,
     generics::generics,
     infer::normalize,
     layout::Layout,
     lt_from_placeholder_idx,
-    mapping::from_chalk,
     mir::pad16,
+    next_solver::{
+        BoundExistentialPredicate, Ctor, DbInterner, GenericArgs, SolverDefId,
+        mapping::{
+            ChalkToNextSolver, convert_args_for_result, convert_const_for_result,
+            convert_region_for_result, convert_ty_for_result,
+        },
+    },
     primitive, to_assoc_type_id,
     utils::{self, ClosureSubst, detect_variant_from_bytes},
 };
@@ -185,6 +193,29 @@ impl HirFormatter<'_> {
             DisplayLifetime::Never => false,
         }
     }
+
+    fn render_region(&self, lifetime: crate::next_solver::Region<'_>) -> bool {
+        match self.display_lifetimes {
+            DisplayLifetime::Always => true,
+            DisplayLifetime::OnlyStatic => {
+                matches!(lifetime.kind(), rustc_type_ir::RegionKind::ReStatic)
+            }
+            DisplayLifetime::OnlyNamed => {
+                matches!(
+                    lifetime.kind(),
+                    rustc_type_ir::RegionKind::RePlaceholder(_)
+                        | rustc_type_ir::RegionKind::ReEarlyParam(_)
+                )
+            }
+            DisplayLifetime::OnlyNamedOrStatic => matches!(
+                lifetime.kind(),
+                rustc_type_ir::RegionKind::ReStatic
+                    | rustc_type_ir::RegionKind::RePlaceholder(_)
+                    | rustc_type_ir::RegionKind::ReEarlyParam(_)
+            ),
+            DisplayLifetime::Never => false,
+        }
+    }
 }
 
 pub trait HirDisplay {
@@ -476,10 +507,6 @@ impl DisplayKind {
         matches!(self, Self::SourceCode { .. })
     }
 
-    fn is_test(self) -> bool {
-        matches!(self, Self::Test)
-    }
-
     fn allows_opaque(self) -> bool {
         match self {
             Self::SourceCode { allow_opaque, .. } => allow_opaque,
@@ -721,59 +748,87 @@ fn render_const_scalar(
     ty: &Ty,
 ) -> Result<(), HirDisplayError> {
     let trait_env = TraitEnvironment::empty(f.krate());
+    let interner = DbInterner::new_with(f.db, Some(trait_env.krate), trait_env.block);
     let ty = normalize(f.db, trait_env.clone(), ty.clone());
-    match ty.kind(Interner) {
-        TyKind::Scalar(s) => match s {
-            Scalar::Bool => write!(f, "{}", b[0] != 0),
-            Scalar::Char => {
-                let it = u128::from_le_bytes(pad16(b, false)) as u32;
-                let Ok(c) = char::try_from(it) else {
-                    return f.write_str("<unicode-error>");
-                };
-                write!(f, "{c:?}")
-            }
-            Scalar::Int(_) => {
-                let it = i128::from_le_bytes(pad16(b, true));
-                write!(f, "{it}")
-            }
-            Scalar::Uint(_) => {
-                let it = u128::from_le_bytes(pad16(b, false));
-                write!(f, "{it}")
-            }
-            Scalar::Float(fl) => match fl {
-                chalk_ir::FloatTy::F16 => {
-                    // FIXME(#17451): Replace with builtins once they are stabilised.
-                    let it = f16::from_bits(u16::from_le_bytes(b.try_into().unwrap()).into());
-                    let s = it.to_string();
-                    if s.strip_prefix('-').unwrap_or(&s).chars().all(|c| c.is_ascii_digit()) {
-                        // Match Rust debug formatting
-                        write!(f, "{s}.0")
-                    } else {
-                        write!(f, "{s}")
-                    }
-                }
-                chalk_ir::FloatTy::F32 => {
-                    let it = f32::from_le_bytes(b.try_into().unwrap());
-                    write!(f, "{it:?}")
-                }
-                chalk_ir::FloatTy::F64 => {
-                    let it = f64::from_le_bytes(b.try_into().unwrap());
-                    write!(f, "{it:?}")
+    let ty = ty.to_nextsolver(interner);
+    render_const_scalar_inner(f, b, memory_map, ty, trait_env, interner)
+}
+
+fn render_const_scalar_ns(
+    f: &mut HirFormatter<'_>,
+    b: &[u8],
+    memory_map: &MemoryMap,
+    ty: crate::next_solver::Ty<'_>,
+) -> Result<(), HirDisplayError> {
+    let trait_env = TraitEnvironment::empty(f.krate());
+    let interner = DbInterner::new_with(f.db, Some(trait_env.krate), trait_env.block);
+    let ty = crate::next_solver::project::solve_normalize::normalize(
+        interner,
+        trait_env.env.to_nextsolver(interner),
+        ty,
+    );
+    render_const_scalar_inner(f, b, memory_map, ty, trait_env, interner)
+}
+
+fn render_const_scalar_inner(
+    f: &mut HirFormatter<'_>,
+    b: &[u8],
+    memory_map: &MemoryMap,
+    ty: crate::next_solver::Ty<'_>,
+    trait_env: Arc<TraitEnvironment>,
+    interner: DbInterner<'_>,
+) -> Result<(), HirDisplayError> {
+    use rustc_type_ir::TyKind;
+    match ty.kind() {
+        TyKind::Bool => write!(f, "{}", b[0] != 0),
+        TyKind::Char => {
+            let it = u128::from_le_bytes(pad16(b, false)) as u32;
+            let Ok(c) = char::try_from(it) else {
+                return f.write_str("<unicode-error>");
+            };
+            write!(f, "{c:?}")
+        }
+        TyKind::Int(_) => {
+            let it = i128::from_le_bytes(pad16(b, true));
+            write!(f, "{it}")
+        }
+        TyKind::Uint(_) => {
+            let it = u128::from_le_bytes(pad16(b, false));
+            write!(f, "{it}")
+        }
+        TyKind::Float(fl) => match fl {
+            rustc_type_ir::FloatTy::F16 => {
+                // FIXME(#17451): Replace with builtins once they are stabilised.
+                let it = f16::from_bits(u16::from_le_bytes(b.try_into().unwrap()).into());
+                let s = it.to_string();
+                if s.strip_prefix('-').unwrap_or(&s).chars().all(|c| c.is_ascii_digit()) {
+                    // Match Rust debug formatting
+                    write!(f, "{s}.0")
+                } else {
+                    write!(f, "{s}")
                 }
-                chalk_ir::FloatTy::F128 => {
-                    // FIXME(#17451): Replace with builtins once they are stabilised.
-                    let it = f128::from_bits(u128::from_le_bytes(b.try_into().unwrap()));
-                    let s = it.to_string();
-                    if s.strip_prefix('-').unwrap_or(&s).chars().all(|c| c.is_ascii_digit()) {
-                        // Match Rust debug formatting
-                        write!(f, "{s}.0")
-                    } else {
-                        write!(f, "{s}")
-                    }
+            }
+            rustc_type_ir::FloatTy::F32 => {
+                let it = f32::from_le_bytes(b.try_into().unwrap());
+                write!(f, "{it:?}")
+            }
+            rustc_type_ir::FloatTy::F64 => {
+                let it = f64::from_le_bytes(b.try_into().unwrap());
+                write!(f, "{it:?}")
+            }
+            rustc_type_ir::FloatTy::F128 => {
+                // FIXME(#17451): Replace with builtins once they are stabilised.
+                let it = f128::from_bits(u128::from_le_bytes(b.try_into().unwrap()));
+                let s = it.to_string();
+                if s.strip_prefix('-').unwrap_or(&s).chars().all(|c| c.is_ascii_digit()) {
+                    // Match Rust debug formatting
+                    write!(f, "{s}.0")
+                } else {
+                    write!(f, "{s}")
                 }
-            },
+            }
         },
-        TyKind::Ref(_, _, t) => match t.kind(Interner) {
+        TyKind::Ref(_, t, _) => match t.kind() {
             TyKind::Str => {
                 let addr = usize::from_le_bytes(b[0..b.len() / 2].try_into().unwrap());
                 let size = usize::from_le_bytes(b[b.len() / 2..].try_into().unwrap());
@@ -786,7 +841,7 @@ fn render_const_scalar(
             TyKind::Slice(ty) => {
                 let addr = usize::from_le_bytes(b[0..b.len() / 2].try_into().unwrap());
                 let count = usize::from_le_bytes(b[b.len() / 2..].try_into().unwrap());
-                let Ok(layout) = f.db.layout_of_ty(ty.clone(), trait_env) else {
+                let Ok(layout) = f.db.layout_of_ty_ns(ty, trait_env) else {
                     return f.write_str("<layout-error>");
                 };
                 let size_one = layout.size.bytes_usize();
@@ -810,11 +865,11 @@ fn render_const_scalar(
                         f.write_str(", ")?;
                     }
                     let offset = size_one * i;
-                    render_const_scalar(f, &bytes[offset..offset + size_one], memory_map, ty)?;
+                    render_const_scalar_ns(f, &bytes[offset..offset + size_one], memory_map, ty)?;
                 }
                 f.write_str("]")
             }
-            TyKind::Dyn(_) => {
+            TyKind::Dynamic(_, _, _) => {
                 let addr = usize::from_le_bytes(b[0..b.len() / 2].try_into().unwrap());
                 let ty_id = usize::from_le_bytes(b[b.len() / 2..].try_into().unwrap());
                 let Ok(t) = memory_map.vtable_ty(ty_id) else {
@@ -828,15 +883,16 @@ fn render_const_scalar(
                     return f.write_str("<ref-data-not-available>");
                 };
                 f.write_str("&")?;
-                render_const_scalar(f, bytes, memory_map, t)
+                render_const_scalar_ns(f, bytes, memory_map, t.to_nextsolver(interner))
             }
-            TyKind::Adt(adt, _) if b.len() == 2 * size_of::<usize>() => match adt.0 {
-                hir_def::AdtId::StructId(s) => {
+            TyKind::Adt(adt, _) if b.len() == 2 * size_of::<usize>() => match adt.def_id() {
+                SolverDefId::AdtId(hir_def::AdtId::StructId(s)) => {
                     let data = f.db.struct_signature(s);
                     write!(f, "&{}", data.name.display(f.db, f.edition()))?;
                     Ok(())
                 }
-                _ => f.write_str("<unsized-enum-or-union>"),
+                SolverDefId::AdtId(_) => f.write_str("<unsized-enum-or-union>"),
+                _ => unreachable!(),
             },
             _ => {
                 let addr = usize::from_le_bytes(match b.try_into() {
@@ -850,7 +906,7 @@ fn render_const_scalar(
                         return f.write_str("<layout-error>");
                     }
                 });
-                let Ok(layout) = f.db.layout_of_ty(t.clone(), trait_env) else {
+                let Ok(layout) = f.db.layout_of_ty_ns(t, trait_env) else {
                     return f.write_str("<layout-error>");
                 };
                 let size = layout.size.bytes_usize();
@@ -858,37 +914,40 @@ fn render_const_scalar(
                     return f.write_str("<ref-data-not-available>");
                 };
                 f.write_str("&")?;
-                render_const_scalar(f, bytes, memory_map, t)
+                render_const_scalar_ns(f, bytes, memory_map, t)
             }
         },
-        TyKind::Tuple(_, subst) => {
-            let Ok(layout) = f.db.layout_of_ty(ty.clone(), trait_env.clone()) else {
+        TyKind::Tuple(tys) => {
+            let Ok(layout) = f.db.layout_of_ty_ns(ty, trait_env.clone()) else {
                 return f.write_str("<layout-error>");
             };
             f.write_str("(")?;
             let mut first = true;
-            for (id, ty) in subst.iter(Interner).enumerate() {
+            for (id, ty) in tys.iter().enumerate() {
                 if first {
                     first = false;
                 } else {
                     f.write_str(", ")?;
                 }
-                let ty = ty.assert_ty_ref(Interner); // Tuple only has type argument
                 let offset = layout.fields.offset(id).bytes_usize();
-                let Ok(layout) = f.db.layout_of_ty(ty.clone(), trait_env.clone()) else {
+                let Ok(layout) = f.db.layout_of_ty_ns(ty, trait_env.clone()) else {
                     f.write_str("<layout-error>")?;
                     continue;
                 };
                 let size = layout.size.bytes_usize();
-                render_const_scalar(f, &b[offset..offset + size], memory_map, ty)?;
+                render_const_scalar_ns(f, &b[offset..offset + size], memory_map, ty)?;
             }
             f.write_str(")")
         }
-        TyKind::Adt(adt, subst) => {
-            let Ok(layout) = f.db.layout_of_adt(adt.0, subst.clone(), trait_env.clone()) else {
+        TyKind::Adt(def, args) => {
+            let def = match def.def_id() {
+                SolverDefId::AdtId(def) => def,
+                _ => unreachable!(),
+            };
+            let Ok(layout) = f.db.layout_of_adt_ns(def, args, trait_env.clone()) else {
                 return f.write_str("<layout-error>");
             };
-            match adt.0 {
+            match def {
                 hir_def::AdtId::StructId(s) => {
                     let data = f.db.struct_signature(s);
                     write!(f, "{}", data.name.display(f.db, f.edition()))?;
@@ -897,9 +956,9 @@ fn render_const_scalar(
                         s.fields(f.db),
                         f,
                         &field_types,
-                        f.db.trait_environment(adt.0.into()),
+                        f.db.trait_environment(def.into()),
                         &layout,
-                        subst,
+                        args,
                         b,
                         memory_map,
                     )
@@ -929,9 +988,9 @@ fn render_const_scalar(
                         var_id.fields(f.db),
                         f,
                         &field_types,
-                        f.db.trait_environment(adt.0.into()),
+                        f.db.trait_environment(def.into()),
                         var_layout,
-                        subst,
+                        args,
                         b,
                         memory_map,
                     )
@@ -939,16 +998,16 @@ fn render_const_scalar(
             }
         }
         TyKind::FnDef(..) => ty.hir_fmt(f),
-        TyKind::Function(_) | TyKind::Raw(_, _) => {
+        TyKind::FnPtr(_, _) | TyKind::RawPtr(_, _) => {
             let it = u128::from_le_bytes(pad16(b, false));
             write!(f, "{it:#X} as ")?;
             ty.hir_fmt(f)
         }
         TyKind::Array(ty, len) => {
-            let Some(len) = try_const_usize(f.db, len) else {
+            let Some(len) = consteval_nextsolver::try_const_usize(f.db, len) else {
                 return f.write_str("<unknown-array-len>");
             };
-            let Ok(layout) = f.db.layout_of_ty(ty.clone(), trait_env) else {
+            let Ok(layout) = f.db.layout_of_ty_ns(ty, trait_env) else {
                 return f.write_str("<layout-error>");
             };
             let size_one = layout.size.bytes_usize();
@@ -961,7 +1020,7 @@ fn render_const_scalar(
                     f.write_str(", ")?;
                 }
                 let offset = size_one * i;
-                render_const_scalar(f, &b[offset..offset + size_one], memory_map, ty)?;
+                render_const_scalar_ns(f, &b[offset..offset + size_one], memory_map, ty)?;
             }
             f.write_str("]")
         }
@@ -969,17 +1028,19 @@ fn render_const_scalar(
         TyKind::Closure(_, _) => f.write_str("<closure>"),
         TyKind::Coroutine(_, _) => f.write_str("<coroutine>"),
         TyKind::CoroutineWitness(_, _) => f.write_str("<coroutine-witness>"),
+        TyKind::CoroutineClosure(_, _) => f.write_str("<coroutine-closure>"),
+        TyKind::UnsafeBinder(_) => f.write_str("<unsafe-binder>"),
         // The below arms are unreachable, since const eval will bail out before here.
         TyKind::Foreign(_) => f.write_str("<extern-type>"),
-        TyKind::Error
+        TyKind::Pat(_, _) => f.write_str("<pat>"),
+        TyKind::Error(..)
         | TyKind::Placeholder(_)
-        | TyKind::Alias(_)
-        | TyKind::AssociatedType(_, _)
-        | TyKind::OpaqueType(_, _)
-        | TyKind::BoundVar(_)
-        | TyKind::InferenceVar(_, _) => f.write_str("<placeholder-or-unknown-type>"),
+        | TyKind::Alias(_, _)
+        | TyKind::Param(_)
+        | TyKind::Bound(_, _)
+        | TyKind::Infer(_) => f.write_str("<placeholder-or-unknown-type>"),
         // The below arms are unreachable, since we handled them in ref case.
-        TyKind::Slice(_) | TyKind::Str | TyKind::Dyn(_) => f.write_str("<unsized-value>"),
+        TyKind::Slice(_) | TyKind::Str | TyKind::Dynamic(_, _, _) => f.write_str("<unsized-value>"),
     }
 }
 
@@ -989,15 +1050,18 @@ fn render_variant_after_name(
     field_types: &ArenaMap<LocalFieldId, Binders<Ty>>,
     trait_env: Arc<TraitEnvironment>,
     layout: &Layout,
-    subst: &Substitution,
+    args: GenericArgs<'_>,
     b: &[u8],
     memory_map: &MemoryMap,
 ) -> Result<(), HirDisplayError> {
+    let interner = DbInterner::new_with(f.db, Some(trait_env.krate), trait_env.block);
     match data.shape {
         FieldsShape::Record | FieldsShape::Tuple => {
             let render_field = |f: &mut HirFormatter<'_>, id: LocalFieldId| {
                 let offset = layout.fields.offset(u32::from(id.into_raw()) as usize).bytes_usize();
-                let ty = field_types[id].clone().substitute(Interner, subst);
+                let ty = field_types[id]
+                    .clone()
+                    .substitute(Interner, &convert_args_for_result(interner, args.as_slice()));
                 let Ok(layout) = f.db.layout_of_ty(ty.clone(), trait_env.clone()) else {
                     return f.write_str("<layout-error>");
                 };
@@ -1045,18 +1109,30 @@ impl HirDisplay for Ty {
         &self,
         f @ &mut HirFormatter { db, .. }: &mut HirFormatter<'_>,
     ) -> Result<(), HirDisplayError> {
+        let ty = self.to_nextsolver(DbInterner::new_with(db, None, None));
+        ty.hir_fmt(f)
+    }
+}
+
+impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
+    fn hir_fmt(
+        &self,
+        f @ &mut HirFormatter { db, .. }: &mut HirFormatter<'_>,
+    ) -> Result<(), HirDisplayError> {
+        let interner = DbInterner::new_with(db, None, None);
         if f.should_truncate() {
             return write!(f, "{TYPE_HINT_TRUNCATION}");
         }
 
-        match self.kind(Interner) {
+        use rustc_type_ir::TyKind;
+        match self.kind() {
             TyKind::Never => write!(f, "!")?,
             TyKind::Str => write!(f, "str")?,
-            TyKind::Scalar(Scalar::Bool) => write!(f, "bool")?,
-            TyKind::Scalar(Scalar::Char) => write!(f, "char")?,
-            &TyKind::Scalar(Scalar::Float(t)) => write!(f, "{}", primitive::float_ty_to_string(t))?,
-            &TyKind::Scalar(Scalar::Int(t)) => write!(f, "{}", primitive::int_ty_to_string(t))?,
-            &TyKind::Scalar(Scalar::Uint(t)) => write!(f, "{}", primitive::uint_ty_to_string(t))?,
+            TyKind::Bool => write!(f, "bool")?,
+            TyKind::Char => write!(f, "char")?,
+            TyKind::Float(t) => write!(f, "{}", primitive::float_ty_to_string_ns(t))?,
+            TyKind::Int(t) => write!(f, "{}", primitive::int_ty_to_string_ns(t))?,
+            TyKind::Uint(t) => write!(f, "{}", primitive::uint_ty_to_string_ns(t))?,
             TyKind::Slice(t) => {
                 write!(f, "[")?;
                 t.hir_fmt(f)?;
@@ -1066,27 +1142,27 @@ impl HirDisplay for Ty {
                 write!(f, "[")?;
                 t.hir_fmt(f)?;
                 write!(f, "; ")?;
-                c.hir_fmt(f)?;
+                convert_const_for_result(interner, c).hir_fmt(f)?;
                 write!(f, "]")?;
             }
-            kind @ (TyKind::Raw(m, t) | TyKind::Ref(m, _, t)) => {
-                if let TyKind::Ref(_, l, _) = kind {
+            kind @ (TyKind::RawPtr(t, m) | TyKind::Ref(_, t, m)) => {
+                if let TyKind::Ref(l, _, _) = kind {
                     f.write_char('&')?;
-                    if f.render_lifetime(l) {
-                        l.hir_fmt(f)?;
+                    if f.render_region(l) {
+                        convert_region_for_result(l).hir_fmt(f)?;
                         f.write_char(' ')?;
                     }
                     match m {
-                        Mutability::Not => (),
-                        Mutability::Mut => f.write_str("mut ")?,
+                        rustc_ast_ir::Mutability::Not => (),
+                        rustc_ast_ir::Mutability::Mut => f.write_str("mut ")?,
                     }
                 } else {
                     write!(
                         f,
                         "*{}",
                         match m {
-                            Mutability::Not => "const ",
-                            Mutability::Mut => "mut ",
+                            rustc_ast_ir::Mutability::Not => "const ",
+                            rustc_ast_ir::Mutability::Mut => "mut ",
                         }
                     )?;
                 }
@@ -1102,25 +1178,42 @@ impl HirDisplay for Ty {
                         }
                     })
                 };
-                let (preds_to_print, has_impl_fn_pred) = match t.kind(Interner) {
-                    TyKind::Dyn(dyn_ty) => {
-                        let bounds = dyn_ty.bounds.skip_binders().interned();
-                        let render_lifetime = f.render_lifetime(&dyn_ty.lifetime);
-                        (bounds.len() + render_lifetime as usize, contains_impl_fn(bounds))
+                let contains_impl_fn_ns = |bounds: &[BoundExistentialPredicate<'_>]| {
+                    bounds.iter().any(|bound| match bound.skip_binder() {
+                        rustc_type_ir::ExistentialPredicate::Trait(trait_ref) => {
+                            let trait_ = match trait_ref.def_id {
+                                SolverDefId::TraitId(id) => id,
+                                _ => unreachable!(),
+                            };
+                            fn_traits(db, trait_).any(|it| it == trait_)
+                        }
+                        _ => false,
+                    })
+                };
+                let (preds_to_print, has_impl_fn_pred) = match t.kind() {
+                    TyKind::Dynamic(bounds, region, _) => {
+                        let render_lifetime = f.render_region(region);
+                        (
+                            bounds.len() + render_lifetime as usize,
+                            contains_impl_fn_ns(bounds.as_slice()),
+                        )
                     }
-                    TyKind::Alias(AliasTy::Opaque(OpaqueTy {
-                        opaque_ty_id,
-                        substitution: parameters,
-                    }))
-                    | TyKind::OpaqueType(opaque_ty_id, parameters) => {
-                        let impl_trait_id = db.lookup_intern_impl_trait_id((*opaque_ty_id).into());
+                    TyKind::Alias(AliasTyKind::Opaque, ty) => {
+                        let opaque_ty_id = match ty.def_id {
+                            SolverDefId::InternedOpaqueTyId(id) => id,
+                            _ => unreachable!(),
+                        };
+                        let impl_trait_id = db.lookup_intern_impl_trait_id(opaque_ty_id);
                         if let ImplTraitId::ReturnTypeImplTrait(func, idx) = impl_trait_id {
                             let datas = db
                                 .return_type_impl_traits(func)
                                 .expect("impl trait id without data");
                             let data =
                                 (*datas).as_ref().map(|rpit| rpit.impl_traits[idx].bounds.clone());
-                            let bounds = data.substitute(Interner, parameters);
+                            let bounds = data.substitute(
+                                Interner,
+                                &convert_args_for_result(interner, ty.args.as_slice()),
+                            );
                             let mut len = bounds.skip_binders().len();
 
                             // Don't count Sized but count when it absent
@@ -1167,24 +1260,31 @@ impl HirDisplay for Ty {
                     t.hir_fmt(f)?;
                 }
             }
-            TyKind::Tuple(_, substs) => {
-                if substs.len(Interner) == 1 {
+            TyKind::Tuple(tys) => {
+                if tys.len() == 1 {
                     write!(f, "(")?;
-                    substs.at(Interner, 0).hir_fmt(f)?;
+                    tys.as_slice()[0].hir_fmt(f)?;
                     write!(f, ",)")?;
                 } else {
                     write!(f, "(")?;
-                    f.write_joined(substs.as_slice(Interner), ", ")?;
+                    f.write_joined(tys.as_slice(), ", ")?;
                     write!(f, ")")?;
                 }
             }
-            TyKind::Function(fn_ptr) => {
-                let sig = CallableSig::from_fn_ptr(fn_ptr);
+            TyKind::FnPtr(sig, header) => {
+                let sig = CallableSig::from_fn_sig_and_header(interner, sig, header);
                 sig.hir_fmt(f)?;
             }
-            TyKind::FnDef(def, parameters) => {
-                let def = from_chalk(db, *def);
-                let sig = db.callable_item_signature(def).substitute(Interner, parameters);
+            TyKind::FnDef(def, args) => {
+                let def = match def {
+                    SolverDefId::FunctionId(id) => CallableDefId::FunctionId(id),
+                    SolverDefId::Ctor(Ctor::Enum(e)) => CallableDefId::EnumVariantId(e),
+                    SolverDefId::Ctor(Ctor::Struct(s)) => CallableDefId::StructId(s),
+                    _ => unreachable!(),
+                };
+                let sig = db
+                    .callable_item_signature(def)
+                    .substitute(Interner, &convert_args_for_result(interner, args.as_slice()));
 
                 if f.display_kind.is_source_code() {
                     // `FnDef` is anonymous and there's no surface syntax for it. Show it as a
@@ -1222,6 +1322,7 @@ impl HirDisplay for Ty {
                 };
                 f.end_location_link();
 
+                let parameters = convert_args_for_result(interner, args.as_slice());
                 if parameters.len(Interner) > 0 {
                     let generic_def_id = GenericDefId::from_callable(db, def);
                     let generics = generics(db, generic_def_id);
@@ -1280,11 +1381,15 @@ impl HirDisplay for Ty {
                     ret.hir_fmt(f)?;
                 }
             }
-            TyKind::Adt(AdtId(def_id), parameters) => {
-                f.start_location_link((*def_id).into());
+            TyKind::Adt(def, parameters) => {
+                let def_id = match def.def_id() {
+                    SolverDefId::AdtId(id) => id,
+                    _ => unreachable!(),
+                };
+                f.start_location_link(def_id.into());
                 match f.display_kind {
                     DisplayKind::Diagnostics | DisplayKind::Test => {
-                        let name = match *def_id {
+                        let name = match def_id {
                             hir_def::AdtId::StructId(it) => db.struct_signature(it).name.clone(),
                             hir_def::AdtId::UnionId(it) => db.union_signature(it).name.clone(),
                             hir_def::AdtId::EnumId(it) => db.enum_signature(it).name.clone(),
@@ -1294,7 +1399,7 @@ impl HirDisplay for Ty {
                     DisplayKind::SourceCode { target_module_id: module_id, allow_opaque: _ } => {
                         if let Some(path) = find_path::find_path(
                             db,
-                            ItemInNs::Types((*def_id).into()),
+                            ItemInNs::Types(def_id.into()),
                             module_id,
                             PrefixKind::Plain,
                             false,
@@ -1316,55 +1421,49 @@ impl HirDisplay for Ty {
                 }
                 f.end_location_link();
 
-                let generic_def = self.as_generic_def(db);
-
-                hir_fmt_generics(f, parameters.as_slice(Interner), generic_def, None)?;
+                hir_fmt_generics(
+                    f,
+                    convert_args_for_result(interner, parameters.as_slice()).as_slice(Interner),
+                    def.def_id().try_into().ok(),
+                    None,
+                )?;
             }
-            TyKind::AssociatedType(assoc_type_id, parameters) => {
-                let type_alias = from_assoc_type_id(*assoc_type_id);
-                let trait_ = match type_alias.lookup(db).container {
-                    ItemContainerId::TraitId(it) => it,
-                    _ => panic!("not an associated type"),
+            TyKind::Alias(AliasTyKind::Projection, alias_ty) => {
+                let type_alias = match alias_ty.def_id {
+                    SolverDefId::TypeAliasId(id) => id,
+                    _ => unreachable!(),
                 };
-                let trait_data = db.trait_signature(trait_);
-                let type_alias_data = db.type_alias_signature(type_alias);
-
-                // Use placeholder associated types when the target is test (https://rust-lang.github.io/chalk/book/clauses/type_equality.html#placeholder-associated-types)
-                if f.display_kind.is_test() {
-                    f.start_location_link(trait_.into());
-                    write!(f, "{}", trait_data.name.display(f.db, f.edition()))?;
-                    f.end_location_link();
-                    write!(f, "::")?;
+                let parameters = convert_args_for_result(interner, alias_ty.args.as_slice());
 
-                    f.start_location_link(type_alias.into());
-                    write!(f, "{}", type_alias_data.name.display(f.db, f.edition()))?;
-                    f.end_location_link();
-                    // Note that the generic args for the associated type come before those for the
-                    // trait (including the self type).
-                    hir_fmt_generics(f, parameters.as_slice(Interner), None, None)
-                } else {
-                    let projection_ty = ProjectionTy {
-                        associated_ty_id: to_assoc_type_id(type_alias),
-                        substitution: parameters.clone(),
-                    };
+                let projection_ty = ProjectionTy {
+                    associated_ty_id: to_assoc_type_id(type_alias),
+                    substitution: parameters.clone(),
+                };
 
-                    projection_ty.hir_fmt(f)
-                }?;
+                projection_ty.hir_fmt(f)?;
             }
             TyKind::Foreign(type_alias) => {
-                let alias = from_foreign_def_id(*type_alias);
+                let alias = match type_alias {
+                    SolverDefId::ForeignId(id) => id,
+                    _ => unreachable!(),
+                };
                 let type_alias = db.type_alias_signature(alias);
                 f.start_location_link(alias.into());
                 write!(f, "{}", type_alias.name.display(f.db, f.edition()))?;
                 f.end_location_link();
             }
-            TyKind::OpaqueType(opaque_ty_id, parameters) => {
+            TyKind::Alias(AliasTyKind::Opaque, alias_ty) => {
+                let opaque_ty_id = match alias_ty.def_id {
+                    SolverDefId::InternedOpaqueTyId(id) => id,
+                    _ => unreachable!(),
+                };
+                let parameters = convert_args_for_result(interner, alias_ty.args.as_slice());
                 if !f.display_kind.allows_opaque() {
                     return Err(HirDisplayError::DisplaySourceCodeError(
                         DisplaySourceCodeError::OpaqueType,
                     ));
                 }
-                let impl_trait_id = db.lookup_intern_impl_trait_id((*opaque_ty_id).into());
+                let impl_trait_id = db.lookup_intern_impl_trait_id(opaque_ty_id);
                 match impl_trait_id {
                     ImplTraitId::ReturnTypeImplTrait(func, idx) => {
                         let datas =
@@ -1376,7 +1475,7 @@ impl HirDisplay for Ty {
                         write_bounds_like_dyn_trait_with_prefix(
                             f,
                             "impl",
-                            Either::Left(self),
+                            Either::Left(&convert_ty_for_result(interner, *self)),
                             bounds.skip_binders(),
                             SizedByDefault::Sized { anchor: krate },
                         )?;
@@ -1391,7 +1490,7 @@ impl HirDisplay for Ty {
                         write_bounds_like_dyn_trait_with_prefix(
                             f,
                             "impl",
-                            Either::Left(self),
+                            Either::Left(&convert_ty_for_result(interner, *self)),
                             bounds.skip_binders(),
                             SizedByDefault::Sized { anchor: krate },
                         )?;
@@ -1426,6 +1525,11 @@ impl HirDisplay for Ty {
                 }
             }
             TyKind::Closure(id, substs) => {
+                let id = match id {
+                    SolverDefId::InternedClosureId(id) => id,
+                    _ => unreachable!(),
+                };
+                let substs = convert_args_for_result(interner, substs.as_slice());
                 if f.display_kind.is_source_code() {
                     if !f.display_kind.allows_opaque() {
                         return Err(HirDisplayError::DisplaySourceCodeError(
@@ -1435,22 +1539,23 @@ impl HirDisplay for Ty {
                         never!("Only `impl Fn` is valid for displaying closures in source code");
                     }
                 }
+                let chalk_id: chalk_ir::ClosureId<_> = id.into();
                 match f.closure_style {
                     ClosureStyle::Hide => return write!(f, "{TYPE_HINT_TRUNCATION}"),
                     ClosureStyle::ClosureWithId => {
-                        return write!(f, "{{closure#{:?}}}", id.0.index());
+                        return write!(f, "{{closure#{:?}}}", chalk_id.0.index());
                     }
                     ClosureStyle::ClosureWithSubst => {
-                        write!(f, "{{closure#{:?}}}", id.0.index())?;
+                        write!(f, "{{closure#{:?}}}", chalk_id.0.index())?;
                         return hir_fmt_generics(f, substs.as_slice(Interner), None, None);
                     }
                     _ => (),
                 }
-                let sig = ClosureSubst(substs).sig_ty().callable_sig(db);
+                let sig = ClosureSubst(&substs).sig_ty().callable_sig(db);
                 if let Some(sig) = sig {
-                    let InternedClosure(def, _) = db.lookup_intern_closure((*id).into());
+                    let InternedClosure(def, _) = db.lookup_intern_closure(id);
                     let infer = db.infer(def);
-                    let (_, kind) = infer.closure_info(id);
+                    let (_, kind) = infer.closure_info(&chalk_id);
                     match f.closure_style {
                         ClosureStyle::ImplFn => write!(f, "impl {kind:?}(")?,
                         ClosureStyle::RANotation => write!(f, "|")?,
@@ -1478,7 +1583,11 @@ impl HirDisplay for Ty {
                 }
             }
             TyKind::Placeholder(idx) => {
-                let id = from_placeholder_idx(db, *idx);
+                let placeholder_index = chalk_ir::PlaceholderIndex {
+                    idx: idx.bound.var.as_usize(),
+                    ui: chalk_ir::UniverseIndex { counter: idx.universe.as_usize() },
+                };
+                let id = from_placeholder_idx(db, placeholder_index);
                 let generics = generics(db, id.parent);
                 let param_data = &generics[id.local_id];
                 match param_data {
@@ -1501,14 +1610,20 @@ impl HirDisplay for Ty {
                                 .map(|pred| pred.clone().substitute(Interner, &substs))
                                 .filter(|wc| match wc.skip_binders() {
                                     WhereClause::Implemented(tr) => {
-                                        tr.self_type_parameter(Interner) == *self
+                                        tr.self_type_parameter(Interner)
+                                            == convert_ty_for_result(interner, *self)
                                     }
                                     WhereClause::AliasEq(AliasEq {
                                         alias: AliasTy::Projection(proj),
                                         ty: _,
-                                    }) => proj.self_type_parameter(db) == *self,
+                                    }) => {
+                                        proj.self_type_parameter(db)
+                                            == convert_ty_for_result(interner, *self)
+                                    }
                                     WhereClause::AliasEq(_) => false,
-                                    WhereClause::TypeOutlives(to) => to.ty == *self,
+                                    WhereClause::TypeOutlives(to) => {
+                                        to.ty == convert_ty_for_result(interner, *self)
+                                    }
                                     WhereClause::LifetimeOutlives(_) => false,
                                 })
                                 .collect::<Vec<_>>();
@@ -1516,7 +1631,7 @@ impl HirDisplay for Ty {
                             write_bounds_like_dyn_trait_with_prefix(
                                 f,
                                 "impl",
-                                Either::Left(self),
+                                Either::Left(&convert_ty_for_result(interner, *self)),
                                 &bounds,
                                 SizedByDefault::Sized { anchor: krate },
                             )?;
@@ -1527,8 +1642,17 @@ impl HirDisplay for Ty {
                     }
                 }
             }
-            TyKind::BoundVar(idx) => idx.hir_fmt(f)?,
-            TyKind::Dyn(dyn_ty) => {
+            TyKind::Param(_) => write!(f, "{{param}}")?,
+            TyKind::Bound(debruijn_index, ty) => {
+                let idx = chalk_ir::BoundVar {
+                    debruijn: chalk_ir::DebruijnIndex::new(debruijn_index.as_u32()),
+                    index: ty.var.as_usize(),
+                };
+                idx.hir_fmt(f)?
+            }
+            TyKind::Dynamic(..) => {
+                let ty = convert_ty_for_result(interner, *self);
+                let chalk_ir::TyKind::Dyn(dyn_ty) = ty.kind(Interner) else { unreachable!() };
                 // Reorder bounds to satisfy `write_bounds_like_dyn_trait()`'s expectation.
                 // FIXME: `Iterator::partition_in_place()` or `Vec::extract_if()` may make it
                 // more efficient when either of them hits stable.
@@ -1544,7 +1668,7 @@ impl HirDisplay for Ty {
                     bounds.push(Binders::empty(
                         Interner,
                         chalk_ir::WhereClause::TypeOutlives(chalk_ir::TypeOutlives {
-                            ty: self.clone(),
+                            ty: ty.clone(),
                             lifetime: dyn_ty.lifetime.clone(),
                         }),
                     ));
@@ -1553,69 +1677,26 @@ impl HirDisplay for Ty {
                 write_bounds_like_dyn_trait_with_prefix(
                     f,
                     "dyn",
-                    Either::Left(self),
+                    Either::Left(&ty),
                     &bounds,
                     SizedByDefault::NotSized,
                 )?;
             }
-            TyKind::Alias(AliasTy::Projection(p_ty)) => p_ty.hir_fmt(f)?,
-            TyKind::Alias(AliasTy::Opaque(opaque_ty)) => {
-                if !f.display_kind.allows_opaque() {
-                    return Err(HirDisplayError::DisplaySourceCodeError(
-                        DisplaySourceCodeError::OpaqueType,
-                    ));
-                }
-                let impl_trait_id = db.lookup_intern_impl_trait_id(opaque_ty.opaque_ty_id.into());
-                match impl_trait_id {
-                    ImplTraitId::ReturnTypeImplTrait(func, idx) => {
-                        let datas =
-                            db.return_type_impl_traits(func).expect("impl trait id without data");
-                        let data =
-                            (*datas).as_ref().map(|rpit| rpit.impl_traits[idx].bounds.clone());
-                        let bounds = data.substitute(Interner, &opaque_ty.substitution);
-                        let krate = func.krate(db);
-                        write_bounds_like_dyn_trait_with_prefix(
-                            f,
-                            "impl",
-                            Either::Left(self),
-                            bounds.skip_binders(),
-                            SizedByDefault::Sized { anchor: krate },
-                        )?;
-                    }
-                    ImplTraitId::TypeAliasImplTrait(alias, idx) => {
-                        let datas =
-                            db.type_alias_impl_traits(alias).expect("impl trait id without data");
-                        let data =
-                            (*datas).as_ref().map(|rpit| rpit.impl_traits[idx].bounds.clone());
-                        let bounds = data.substitute(Interner, &opaque_ty.substitution);
-                        let krate = alias.krate(db);
-                        write_bounds_like_dyn_trait_with_prefix(
-                            f,
-                            "impl",
-                            Either::Left(self),
-                            bounds.skip_binders(),
-                            SizedByDefault::Sized { anchor: krate },
-                        )?;
-                    }
-                    ImplTraitId::AsyncBlockTypeImplTrait(..) => {
-                        write!(f, "{{async block}}")?;
-                    }
-                };
-            }
-            TyKind::Error => {
+            TyKind::Error(_) => {
                 if f.display_kind.is_source_code() {
                     f.write_char('_')?;
                 } else {
                     write!(f, "{{unknown}}")?;
                 }
             }
-            TyKind::InferenceVar(..) => write!(f, "_")?,
+            TyKind::Infer(..) => write!(f, "_")?,
             TyKind::Coroutine(_, subst) => {
                 if f.display_kind.is_source_code() {
                     return Err(HirDisplayError::DisplaySourceCodeError(
                         DisplaySourceCodeError::Coroutine,
                     ));
                 }
+                let subst = convert_args_for_result(interner, subst.as_slice());
                 let subst = subst.as_slice(Interner);
                 let a: Option<SmallVec<[&Ty; 3]>> = subst
                     .get(subst.len() - 3..)
@@ -1637,6 +1718,10 @@ impl HirDisplay for Ty {
                 }
             }
             TyKind::CoroutineWitness(..) => write!(f, "{{coroutine witness}}")?,
+            TyKind::Pat(_, _) => write!(f, "{{pat}}")?,
+            TyKind::UnsafeBinder(_) => write!(f, "{{unsafe binder}}")?,
+            TyKind::CoroutineClosure(_, _) => write!(f, "{{coroutine closure}}")?,
+            TyKind::Alias(_, _) => write!(f, "{{alias}}")?,
         }
         Ok(())
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
index 237cc34d7099b..8bd555f5c08f3 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
@@ -615,7 +615,6 @@ fn receiver_for_self_ty<'db>(
         },
     );
 
-    
     crate::next_solver::EarlyBinder::bind(receiver_ty).instantiate(interner, args)
 }
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
index 2d0471d7e5545..fb7b5e1c83e4c 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
@@ -153,7 +153,7 @@ fn layout_of_simd_ty<'db>(
         return Err(LayoutError::InvalidSimdType);
     };
 
-    let e_len = try_const_usize(db, &e_len).ok_or(LayoutError::HasErrorConst)? as u64;
+    let e_len = try_const_usize(db, e_len).ok_or(LayoutError::HasErrorConst)? as u64;
     let e_ly = db.layout_of_ty_ns(e_ty, env)?;
 
     let cx = LayoutCx::new(dl);
@@ -272,7 +272,7 @@ pub fn layout_of_ty_ns_query<'db>(
             cx.calc.univariant(&fields, &ReprOptions::default(), kind)?
         }
         TyKind::Array(element, count) => {
-            let count = try_const_usize(db, &count).ok_or(LayoutError::HasErrorConst)? as u64;
+            let count = try_const_usize(db, count).ok_or(LayoutError::HasErrorConst)? as u64;
             let element = db.layout_of_ty_ns(element, trait_env)?;
             cx.calc.array_like::<_, _, ()>(&element, Some(count))?
         }
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 2b0dc931eaf4a..81894830b5b47 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
@@ -90,6 +90,7 @@ use intern::{Symbol, sym};
 use la_arena::{Arena, Idx};
 use mir::{MirEvalError, VTableMap};
 use rustc_hash::{FxBuildHasher, FxHashMap, FxHashSet};
+use rustc_type_ir::inherent::SliceLike;
 use syntax::ast::{ConstArg, make};
 use traits::FnTrait;
 use triomphe::Arc;
@@ -100,6 +101,7 @@ use crate::{
     display::{DisplayTarget, HirDisplay},
     generics::Generics,
     infer::unify::InferenceTable,
+    next_solver::{DbInterner, mapping::convert_ty_for_result},
 };
 
 pub use autoderef::autoderef;
@@ -560,6 +562,27 @@ impl CallableSig {
             abi: fn_ptr.sig.abi,
         }
     }
+    pub fn from_fn_sig_and_header<'db>(
+        interner: DbInterner<'db>,
+        sig: crate::next_solver::Binder<'db, rustc_type_ir::FnSigTys<DbInterner<'db>>>,
+        header: rustc_type_ir::FnHeader<DbInterner<'db>>,
+    ) -> CallableSig {
+        CallableSig {
+            // FIXME: what to do about lifetime params? -> return PolyFnSig
+            params_and_return: Arc::from_iter(
+                sig.skip_binder()
+                    .inputs_and_output
+                    .iter()
+                    .map(|t| convert_ty_for_result(interner, t)),
+            ),
+            is_varargs: header.c_variadic,
+            safety: match header.safety {
+                next_solver::abi::Safety::Safe => chalk_ir::Safety::Safe,
+                next_solver::abi::Safety::Unsafe => chalk_ir::Safety::Unsafe,
+            },
+            abi: header.abi,
+        }
+    }
 
     pub fn to_fn_ptr(&self) -> FnPointer {
         FnPointer {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
index 20cd8626f299b..b50fccb832625 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
@@ -1290,7 +1290,10 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
     .intern(Interner)
 }
 
-fn convert_const_for_result<'db>(interner: DbInterner<'db>, const_: Const<'db>) -> crate::Const {
+pub fn convert_const_for_result<'db>(
+    interner: DbInterner<'db>,
+    const_: Const<'db>,
+) -> crate::Const {
     let value: chalk_ir::ConstValue<Interner> = match const_.kind() {
         rustc_type_ir::ConstKind::Param(_) => unimplemented!(),
         rustc_type_ir::ConstKind::Infer(rustc_type_ir::InferConst::Var(var)) => {
@@ -1343,7 +1346,7 @@ fn convert_const_for_result<'db>(interner: DbInterner<'db>, const_: Const<'db>)
     chalk_ir::ConstData { ty: crate::TyKind::Error.intern(Interner), value }.intern(Interner)
 }
 
-fn convert_region_for_result<'db>(region: Region<'db>) -> crate::Lifetime {
+pub fn convert_region_for_result<'db>(region: Region<'db>) -> crate::Lifetime {
     match region.kind() {
         rustc_type_ir::RegionKind::ReEarlyParam(early) => unimplemented!(),
         rustc_type_ir::RegionKind::ReBound(db, bound) => chalk_ir::Lifetime::new(
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/project/solve_normalize.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/project/solve_normalize.rs
index a8fb2ae14f1c3..42c238febf6f6 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/project/solve_normalize.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/project/solve_normalize.rs
@@ -11,16 +11,25 @@ use rustc_type_ir::{
 
 use crate::next_solver::{
     Binder, Const, ConstKind, DbInterner, Goal, ParamEnv, Predicate, PredicateKind, Span, Term, Ty,
-    TyKind,
+    TyKind, TypingMode,
     fulfill::{FulfillmentCtxt, NextSolverError},
     infer::{
-        InferCtxt,
+        DbInternerInferExt, InferCtxt,
         at::At,
         traits::{Obligation, ObligationCause},
     },
     util::PlaceholderReplacer,
 };
 
+pub fn normalize<'db, T>(interner: DbInterner<'db>, param_env: ParamEnv<'db>, value: T) -> T
+where
+    T: TypeFoldable<DbInterner<'db>>,
+{
+    let infer_ctxt = interner.infer_ctxt().build(TypingMode::non_body_analysis());
+    let cause = ObligationCause::dummy();
+    deeply_normalize(infer_ctxt.at(&cause, param_env), value.clone()).unwrap_or(value)
+}
+
 /// Deeply normalize all aliases in `value`. This does not handle inference and expects
 /// its input to be already fully resolved.
 pub fn deeply_normalize<'db, T>(at: At<'_, 'db>, value: T) -> Result<T, Vec<NextSolverError<'db>>>
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/primitive.rs b/src/tools/rust-analyzer/crates/hir-ty/src/primitive.rs
index a4e077ba6359f..d2901f7fc53d2 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/primitive.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/primitive.rs
@@ -34,6 +34,40 @@ pub fn float_ty_to_string(ty: FloatTy) -> &'static str {
     }
 }
 
+pub fn int_ty_to_string_ns(ty: rustc_type_ir::IntTy) -> &'static str {
+    use rustc_type_ir::IntTy;
+    match ty {
+        IntTy::Isize => "isize",
+        IntTy::I8 => "i8",
+        IntTy::I16 => "i16",
+        IntTy::I32 => "i32",
+        IntTy::I64 => "i64",
+        IntTy::I128 => "i128",
+    }
+}
+
+pub fn uint_ty_to_string_ns(ty: rustc_type_ir::UintTy) -> &'static str {
+    use rustc_type_ir::UintTy;
+    match ty {
+        UintTy::Usize => "usize",
+        UintTy::U8 => "u8",
+        UintTy::U16 => "u16",
+        UintTy::U32 => "u32",
+        UintTy::U64 => "u64",
+        UintTy::U128 => "u128",
+    }
+}
+
+pub fn float_ty_to_string_ns(ty: rustc_type_ir::FloatTy) -> &'static str {
+    use rustc_type_ir::FloatTy;
+    match ty {
+        FloatTy::F16 => "f16",
+        FloatTy::F32 => "f32",
+        FloatTy::F64 => "f64",
+        FloatTy::F128 => "f128",
+    }
+}
+
 pub(super) fn int_ty_from_builtin(t: BuiltinInt) -> IntTy {
     match t {
         BuiltinInt::Isize => IntTy::Isize,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs
index d98b6602efe8c..1c3da438cb364 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs
@@ -157,11 +157,13 @@ fn check_impl(
             };
             let range = node.as_ref().original_file_range_rooted(&db);
             if let Some(expected) = types.remove(&range) {
-                let actual = if display_source {
-                    ty.display_source_code(&db, def.module(&db), true).unwrap()
-                } else {
-                    ty.display_test(&db, display_target).to_string()
-                };
+                let actual = salsa::attach(&db, || {
+                    if display_source {
+                        ty.display_source_code(&db, def.module(&db), true).unwrap()
+                    } else {
+                        ty.display_test(&db, display_target).to_string()
+                    }
+                });
                 assert_eq!(actual, expected, "type annotation differs at {:#?}", range.range);
             }
         }
@@ -173,11 +175,13 @@ fn check_impl(
             };
             let range = node.as_ref().original_file_range_rooted(&db);
             if let Some(expected) = types.remove(&range) {
-                let actual = if display_source {
-                    ty.display_source_code(&db, def.module(&db), true).unwrap()
-                } else {
-                    ty.display_test(&db, display_target).to_string()
-                };
+                let actual = salsa::attach(&db, || {
+                    if display_source {
+                        ty.display_source_code(&db, def.module(&db), true).unwrap()
+                    } else {
+                        ty.display_test(&db, display_target).to_string()
+                    }
+                });
                 assert_eq!(actual, expected, "type annotation differs at {:#?}", range.range);
             }
             if let Some(expected) = adjustments.remove(&range) {
@@ -203,11 +207,13 @@ fn check_impl(
                 continue;
             };
             let range = node.as_ref().original_file_range_rooted(&db);
-            let actual = format!(
-                "expected {}, got {}",
-                mismatch.expected.display_test(&db, display_target),
-                mismatch.actual.display_test(&db, display_target)
-            );
+            let actual = salsa::attach(&db, || {
+                format!(
+                    "expected {}, got {}",
+                    mismatch.expected.display_test(&db, display_target),
+                    mismatch.actual.display_test(&db, display_target)
+                )
+            });
             match mismatches.remove(&range) {
                 Some(annotation) => assert_eq!(actual, annotation),
                 None => format_to!(unexpected_type_mismatches, "{:?}: {}\n", range.range, actual),
@@ -402,7 +408,9 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
     for (def, krate) in defs {
         let (body, source_map) = db.body_with_source_map(def);
         let infer = db.infer(def);
-        infer_def(infer, body, source_map, krate);
+        salsa::attach(&db, || {
+            infer_def(infer, body, source_map, krate);
+        })
     }
 
     buf.truncate(buf.trim_end().len());
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/closure_captures.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/closure_captures.rs
index 5893894c33ab7..b001ac1e82ea2 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/closure_captures.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/closure_captures.rs
@@ -67,11 +67,13 @@ fn check_closure_captures(#[rust_analyzer::rust_fixture] ra_fixture: &str, expec
                         .join(", "),
                 };
                 let place = capture.display_place(closure.0, db);
-                let capture_ty = capture
-                    .ty
-                    .skip_binders()
-                    .display_test(db, DisplayTarget::from_crate(db, module.krate()))
-                    .to_string();
+                let capture_ty = salsa::attach(db, || {
+                    capture
+                        .ty
+                        .skip_binders()
+                        .display_test(db, DisplayTarget::from_crate(db, module.krate()))
+                        .to_string()
+                });
                 let spans = capture
                     .spans()
                     .iter()
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/opaque_types.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/opaque_types.rs
index 36578545a9f49..11d1a58e5367e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/opaque_types.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/opaque_types.rs
@@ -71,7 +71,7 @@ fn test() {
     let x = S3.baz();
       //^ Binary<impl Foo + ?Sized, Unary<impl Bar + ?Sized>>
     let y = x.1.0.bar();
-      //^ Unary<Bar::Item<impl Bar + ?Sized>>
+      //^ Unary<<impl Bar + ?Sized as Bar>::Item>
 }
         "#,
     );
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
index 212fec4a4e4f4..fd8c641d86eb0 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
@@ -2299,10 +2299,10 @@ trait Foo {
 }
 "#,
         expect![[r#"
-            83..86 'bar': Foo::Bar<Self, A, B>
+            83..86 'bar': <Self as Foo>::Bar<A, B>
             105..133 '{     ...     }': ()
-            119..120 '_': Foo::Bar<Self, A, B>
-            123..126 'bar': Foo::Bar<Self, A, B>
+            119..120 '_': <Self as Foo>::Bar<A, B>
+            123..126 'bar': <Self as Foo>::Bar<A, B>
         "#]],
     );
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
index 9d72105624a05..a311e579744df 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
@@ -408,11 +408,11 @@ fn test<T: Iterable>() {
     let x: <S as Iterable>::Item = 1;
                                 // ^ u32
     let y: <T as Iterable>::Item = u;
-                                // ^ Iterable::Item<T>
+                                // ^ <T as Iterable>::Item
     let z: T::Item = u;
-                  // ^ Iterable::Item<T>
+                  // ^ <T as Iterable>::Item
     let a: <T>::Item = u;
-                    // ^ Iterable::Item<T>
+                    // ^ <T as Iterable>::Item
 }"#,
     );
 }
@@ -454,7 +454,7 @@ impl<T> S<T> {
 fn test<T: Iterable>() {
     let s: S<T>;
     s.foo();
- // ^^^^^^^ Iterable::Item<T>
+ // ^^^^^^^ <T as Iterable>::Item
 }"#,
     );
 }
@@ -470,7 +470,7 @@ trait Foo {
     type A;
     fn test(a: Self::A, _: impl Bar) {
         a;
-      //^ Foo::A<Self>
+      //^ <Self as Foo>::A
     }
 }"#,
     );
@@ -969,7 +969,7 @@ impl<T> ApplyL for RefMutL<T> {
 fn test<T: ApplyL>() {
     let y: <RefMutL<T> as ApplyL>::Out = no_matter;
     y;
-} //^ ApplyL::Out<T>
+} //^ <T as ApplyL>::Out
 "#,
     );
 }
@@ -986,7 +986,7 @@ fn foo<T: ApplyL>(t: T) -> <T as ApplyL>::Out;
 fn test<T: ApplyL>(t: T) {
     let y = foo(t);
     y;
-} //^ ApplyL::Out<T>
+} //^ <T as ApplyL>::Out
 "#,
     );
 }
@@ -1695,7 +1695,7 @@ fn test<T: Trait<Type = u32>>(x: T, y: impl Trait<Type = i64>) {
 }"#,
         expect![[r#"
             49..50 't': T
-            77..79 '{}': Trait::Type<T>
+            77..79 '{}': <T as Trait>::Type
             111..112 't': T
             122..124 '{}': U
             154..155 't': T
@@ -2293,7 +2293,7 @@ impl Trait for S2 {
 }"#,
         expect![[r#"
             40..44 'self': &'? Self
-            46..47 'x': Trait::Item<Self>
+            46..47 'x': <Self as Trait>::Item
             126..130 'self': &'? S
             132..133 'x': u32
             147..161 '{ let y = x; }': ()
@@ -2410,7 +2410,7 @@ trait Trait2<T> {}
 
 fn test<T: Trait>() where T: Trait2<T::Item> {
     let x: T::Item = no_matter;
-}                  //^^^^^^^^^ Trait::Item<T>
+}                  //^^^^^^^^^ <T as Trait>::Item
 "#,
     );
 }
@@ -2445,7 +2445,7 @@ trait Trait {
 
 fn test<T>() where T: Trait<OtherItem = T::Item> {
     let x: T::Item = no_matter;
-}                  //^^^^^^^^^ Trait::Item<T>
+}                  //^^^^^^^^^ <T as Trait>::Item
 "#,
     );
 }
@@ -2475,7 +2475,7 @@ fn test<T>(t: T) where T: UnificationStoreMut {
     t.push(x);
     let y: Key<T>;
     (x, y);
-} //^^^^^^ (UnificationStoreBase::Key<T>, UnificationStoreBase::Key<T>)
+} //^^^^^^ (<T as UnificationStoreBase>::Key, <T as UnificationStoreBase>::Key)
 "#,
     );
 }
@@ -3488,7 +3488,7 @@ fn foo() {
     let x = <F as Bar>::boo();
 }"#,
         expect![[r#"
-            132..163 '{     ...     }': Bar::Output<Self>
+            132..163 '{     ...     }': <Self as Bar>::Output
             146..153 'loop {}': !
             151..153 '{}': ()
             306..358 '{     ...o(); }': ()
@@ -4213,7 +4213,7 @@ fn g<'a, T: 'a>(v: impl Trait<Assoc<T> = &'a T>) {
     let a = v.get::<T>();
       //^ &'a T
     let a = v.get::<()>();
-      //^ Trait::Assoc<impl Trait<Assoc<T> = &'a T>, ()>
+      //^ <impl Trait<Assoc<T> = &'a T> as Trait>::Assoc<()>
 }
 fn h<'a>(v: impl Trait<Assoc<i32> = &'a i32> + Trait<Assoc<i64> = &'a i64>) {
     let a = v.get::<i32>();
@@ -4280,7 +4280,7 @@ where
     let a = t.get::<isize>();
       //^ usize
     let a = t.get::<()>();
-      //^ Trait::Assoc<T, ()>
+      //^ <T as Trait>::Assoc<()>
 }
 
     "#,
@@ -4857,29 +4857,29 @@ async fn baz<T: AsyncFnOnce(u32) -> i32>(c: T) {
             37..38 'a': T
             43..83 '{     ...ait; }': ()
             43..83 '{     ...ait; }': impl Future<Output = ()>
-            53..57 'fut1': AsyncFnMut::CallRefFuture<'?, T, (u32,)>
+            53..57 'fut1': <T as AsyncFnMut<(u32,)>>::CallRefFuture<'?>
             60..61 'a': T
-            60..64 'a(0)': AsyncFnMut::CallRefFuture<'?, T, (u32,)>
+            60..64 'a(0)': <T as AsyncFnMut<(u32,)>>::CallRefFuture<'?>
             62..63 '0': u32
-            70..74 'fut1': AsyncFnMut::CallRefFuture<'?, T, (u32,)>
+            70..74 'fut1': <T as AsyncFnMut<(u32,)>>::CallRefFuture<'?>
             70..80 'fut1.await': i32
             124..129 'mut b': T
             134..174 '{     ...ait; }': ()
             134..174 '{     ...ait; }': impl Future<Output = ()>
-            144..148 'fut2': AsyncFnMut::CallRefFuture<'?, T, (u32,)>
+            144..148 'fut2': <T as AsyncFnMut<(u32,)>>::CallRefFuture<'?>
             151..152 'b': T
-            151..155 'b(0)': AsyncFnMut::CallRefFuture<'?, T, (u32,)>
+            151..155 'b(0)': <T as AsyncFnMut<(u32,)>>::CallRefFuture<'?>
             153..154 '0': u32
-            161..165 'fut2': AsyncFnMut::CallRefFuture<'?, T, (u32,)>
+            161..165 'fut2': <T as AsyncFnMut<(u32,)>>::CallRefFuture<'?>
             161..171 'fut2.await': i32
             216..217 'c': T
             222..262 '{     ...ait; }': ()
             222..262 '{     ...ait; }': impl Future<Output = ()>
-            232..236 'fut3': AsyncFnOnce::CallOnceFuture<T, (u32,)>
+            232..236 'fut3': <T as AsyncFnOnce<(u32,)>>::CallOnceFuture
             239..240 'c': T
-            239..243 'c(0)': AsyncFnOnce::CallOnceFuture<T, (u32,)>
+            239..243 'c(0)': <T as AsyncFnOnce<(u32,)>>::CallOnceFuture
             241..242 '0': u32
-            249..253 'fut3': AsyncFnOnce::CallOnceFuture<T, (u32,)>
+            249..253 'fut3': <T as AsyncFnOnce<(u32,)>>::CallOnceFuture
             249..259 'fut3.await': i32
         "#]],
     );
@@ -4947,7 +4947,7 @@ where
 "#,
         expect![[r#"
             84..86 'de': D
-            135..138 '{ }': Deserializer::Error<'de, D>
+            135..138 '{ }': <D as Deserializer<'de>>::Error
         "#]],
     );
 }
@@ -5020,7 +5020,7 @@ fn main() {
             294..298 'iter': Box<dyn Iterator<Item = &'? [u8]> + 'static>
             294..310 'iter.i...iter()': Box<dyn Iterator<Item = &'? [u8]> + 'static>
             152..156 'self': &'? mut Box<I>
-            177..208 '{     ...     }': Option<Iterator::Item<I>>
+            177..208 '{     ...     }': Option<<I as Iterator>::Item>
             191..198 'loop {}': !
             196..198 '{}': ()
         "#]],
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index 11486ec8d6690..4dde019b50063 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -85,7 +85,9 @@ use hir_ty::{
     layout::{Layout as TyLayout, RustcEnumVariantIdx, RustcFieldIdx, TagEncoding},
     method_resolution,
     mir::{MutBorrowKind, interpret_mir},
-    next_solver::{DbInterner, GenericArgs, SolverDefId, infer::InferCtxt},
+    next_solver::{
+        DbInterner, GenericArgs, SolverDefId, infer::InferCtxt, mapping::ChalkToNextSolver,
+    },
     primitive::UintTy,
     traits::FnTrait,
 };
@@ -1814,12 +1816,15 @@ impl Adt {
     }
 
     pub fn layout(self, db: &dyn HirDatabase) -> Result<Layout, LayoutError> {
-        db.layout_of_adt(
+        let env = db.trait_environment(self.into());
+        let interner = DbInterner::new_with(db, Some(env.krate), env.block);
+        db.layout_of_adt_ns(
             self.into(),
             TyBuilder::adt(db, self.into())
                 .fill_with_defaults(db, || TyKind::Error.intern(Interner))
-                .build_into_subst(),
-            db.trait_environment(self.into()),
+                .build_into_subst()
+                .to_nextsolver(interner),
+            env,
         )
         .map(|layout| Layout(layout, db.target_data_layout(self.krate(db).id).unwrap()))
     }
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context/tests.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context/tests.rs
index 7a8c70f190efc..f03f61d10e5f7 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context/tests.rs
@@ -1,3 +1,4 @@
+use base_db::salsa;
 use expect_test::{Expect, expect};
 use hir::HirDisplay;
 
@@ -13,7 +14,11 @@ fn check_expected_type_and_name(#[rust_analyzer::rust_fixture] ra_fixture: &str,
 
     let ty = completion_context
         .expected_type
-        .map(|t| t.display_test(&db, completion_context.krate.to_display_target(&db)).to_string())
+        .map(|t| {
+            salsa::attach(&db, || {
+                t.display_test(&db, completion_context.krate.to_display_target(&db)).to_string()
+            })
+        })
         .unwrap_or("?".to_owned());
 
     let name =
diff --git a/src/tools/rust-analyzer/crates/ide/src/hover/render.rs b/src/tools/rust-analyzer/crates/ide/src/hover/render.rs
index e4c7d42ffe3b1..1f9d10c92b1df 100644
--- a/src/tools/rust-analyzer/crates/ide/src/hover/render.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/hover/render.rs
@@ -912,7 +912,7 @@ pub(super) fn literal(
     };
     let ty = ty.display(sema.db, display_target);
 
-    let mut s = format!("```rust\n{ty}\n```\n___\n\n");
+    let mut s = salsa::attach(sema.db, || format!("```rust\n{ty}\n```\n___\n\n"));
     match value {
         Ok(value) => {
             let backtick_len = value.chars().filter(|c| *c == '`').count();
diff --git a/src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs b/src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs
index 424890fe370c4..d7d3171664945 100644
--- a/src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs
@@ -738,44 +738,46 @@ fn label_of_ty(
         config: &InlayHintsConfig,
         display_target: DisplayTarget,
     ) -> Result<(), HirDisplayError> {
-        let iter_item_type = hint_iterator(sema, famous_defs, ty);
-        match iter_item_type {
-            Some((iter_trait, item, ty)) => {
-                const LABEL_START: &str = "impl ";
-                const LABEL_ITERATOR: &str = "Iterator";
-                const LABEL_MIDDLE: &str = "<";
-                const LABEL_ITEM: &str = "Item";
-                const LABEL_MIDDLE2: &str = " = ";
-                const LABEL_END: &str = ">";
-
-                max_length = max_length.map(|len| {
-                    len.saturating_sub(
-                        LABEL_START.len()
-                            + LABEL_ITERATOR.len()
-                            + LABEL_MIDDLE.len()
-                            + LABEL_MIDDLE2.len()
-                            + LABEL_END.len(),
-                    )
-                });
-
-                label_builder.write_str(LABEL_START)?;
-                label_builder.start_location_link(ModuleDef::from(iter_trait).into());
-                label_builder.write_str(LABEL_ITERATOR)?;
-                label_builder.end_location_link();
-                label_builder.write_str(LABEL_MIDDLE)?;
-                label_builder.start_location_link(ModuleDef::from(item).into());
-                label_builder.write_str(LABEL_ITEM)?;
-                label_builder.end_location_link();
-                label_builder.write_str(LABEL_MIDDLE2)?;
-                rec(sema, famous_defs, max_length, &ty, label_builder, config, display_target)?;
-                label_builder.write_str(LABEL_END)?;
-                Ok(())
+        salsa::attach(sema.db, || {
+            let iter_item_type = hint_iterator(sema, famous_defs, ty);
+            match iter_item_type {
+                Some((iter_trait, item, ty)) => {
+                    const LABEL_START: &str = "impl ";
+                    const LABEL_ITERATOR: &str = "Iterator";
+                    const LABEL_MIDDLE: &str = "<";
+                    const LABEL_ITEM: &str = "Item";
+                    const LABEL_MIDDLE2: &str = " = ";
+                    const LABEL_END: &str = ">";
+
+                    max_length = max_length.map(|len| {
+                        len.saturating_sub(
+                            LABEL_START.len()
+                                + LABEL_ITERATOR.len()
+                                + LABEL_MIDDLE.len()
+                                + LABEL_MIDDLE2.len()
+                                + LABEL_END.len(),
+                        )
+                    });
+
+                    label_builder.write_str(LABEL_START)?;
+                    label_builder.start_location_link(ModuleDef::from(iter_trait).into());
+                    label_builder.write_str(LABEL_ITERATOR)?;
+                    label_builder.end_location_link();
+                    label_builder.write_str(LABEL_MIDDLE)?;
+                    label_builder.start_location_link(ModuleDef::from(item).into());
+                    label_builder.write_str(LABEL_ITEM)?;
+                    label_builder.end_location_link();
+                    label_builder.write_str(LABEL_MIDDLE2)?;
+                    rec(sema, famous_defs, max_length, &ty, label_builder, config, display_target)?;
+                    label_builder.write_str(LABEL_END)?;
+                    Ok(())
+                }
+                None => ty
+                    .display_truncated(sema.db, max_length, display_target)
+                    .with_closure_style(config.closure_style)
+                    .write_to(label_builder),
             }
-            None => ty
-                .display_truncated(sema.db, max_length, display_target)
-                .with_closure_style(config.closure_style)
-                .write_to(label_builder),
-        }
+        })
     }
 
     let mut label_builder = InlayHintLabelBuilder {
diff --git a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/adjustment.rs b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/adjustment.rs
index 39554d777795c..e39a5f8889a2c 100644
--- a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/adjustment.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/adjustment.rs
@@ -10,7 +10,7 @@ use hir::{
     Adjust, Adjustment, AutoBorrow, DisplayTarget, HirDisplay, Mutability, OverloadedDeref,
     PointerCast, Safety,
 };
-use ide_db::famous_defs::FamousDefs;
+use ide_db::{base_db::salsa, famous_defs::FamousDefs};
 
 use ide_db::text_edit::TextEditBuilder;
 use syntax::ast::{self, AstNode, prec::ExprPrecedence};
@@ -201,13 +201,15 @@ pub(super) fn hints(
             text: if postfix { format!(".{}", text.trim_end()) } else { text.to_owned() },
             linked_location: None,
             tooltip: Some(config.lazy_tooltip(|| {
-                InlayTooltip::Markdown(format!(
-                    "`{}` → `{}`\n\n**{}**\n\n{}",
-                    source.display(sema.db, display_target),
-                    target.display(sema.db, display_target),
-                    coercion,
-                    detailed_tooltip
-                ))
+                salsa::attach(sema.db, || {
+                    InlayTooltip::Markdown(format!(
+                        "`{}` → `{}`\n\n**{}**\n\n{}",
+                        source.display(sema.db, display_target),
+                        target.display(sema.db, display_target),
+                        coercion,
+                        detailed_tooltip
+                    ))
+                })
             })),
         };
         if postfix { &mut post } else { &mut pre }.label.append_part(label);
diff --git a/src/tools/rust-analyzer/crates/ide/src/lib.rs b/src/tools/rust-analyzer/crates/ide/src/lib.rs
index 5349ebb7c82a5..1c66473bf9874 100644
--- a/src/tools/rust-analyzer/crates/ide/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/lib.rs
@@ -67,7 +67,7 @@ use ide_db::{
     FxHashMap, FxIndexSet, LineIndexDatabase,
     base_db::{
         CrateOrigin, CrateWorkspaceData, Env, FileSet, RootQueryDb, SourceDatabase, VfsPath,
-        salsa::Cancelled,
+        salsa::{self, Cancelled},
     },
     prime_caches, symbol_index,
 };
@@ -461,7 +461,9 @@ impl Analysis {
         hasher: impl Fn(&InlayHint) -> u64 + Send + UnwindSafe,
     ) -> Cancellable<Option<InlayHint>> {
         self.with_db(|db| {
-            inlay_hints::inlay_hints_resolve(db, file_id, resolve_range, hash, config, hasher)
+            salsa::attach(db, || {
+                inlay_hints::inlay_hints_resolve(db, file_id, resolve_range, hash, config, hasher)
+            })
         })
     }
 
@@ -536,7 +538,7 @@ impl Analysis {
         config: &HoverConfig,
         range: FileRange,
     ) -> Cancellable<Option<RangeInfo<HoverResult>>> {
-        self.with_db(|db| hover::hover(db, range, config))
+        self.with_db(|db| salsa::attach(db, || hover::hover(db, range, config)))
     }
 
     /// Returns moniker of symbol at position.
@@ -544,7 +546,7 @@ impl Analysis {
         &self,
         position: FilePosition,
     ) -> Cancellable<Option<RangeInfo<Vec<moniker::MonikerResult>>>> {
-        self.with_db(|db| moniker::moniker(db, position))
+        self.with_db(|db| salsa::attach(db, || moniker::moniker(db, position)))
     }
 
     /// Returns URL(s) for the documentation of the symbol under the cursor.
@@ -640,7 +642,7 @@ impl Analysis {
 
     /// Returns the set of possible targets to run for the current file.
     pub fn runnables(&self, file_id: FileId) -> Cancellable<Vec<Runnable>> {
-        self.with_db(|db| runnables::runnables(db, file_id))
+        self.with_db(|db| salsa::attach(db, || runnables::runnables(db, file_id)))
     }
 
     /// Returns the set of tests for the given file position.
diff --git a/src/tools/rust-analyzer/crates/ide/src/navigation_target.rs b/src/tools/rust-analyzer/crates/ide/src/navigation_target.rs
index 61b4de0e0e396..1b6a4b726e831 100644
--- a/src/tools/rust-analyzer/crates/ide/src/navigation_target.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/navigation_target.rs
@@ -10,6 +10,7 @@ use hir::{
 };
 use ide_db::{
     FileId, FileRange, RootDatabase, SymbolKind,
+    base_db::salsa,
     defs::Definition,
     documentation::{Documentation, HasDocs},
 };
@@ -377,8 +378,9 @@ where
             )
             .map(|mut res| {
                 res.docs = self.docs(db);
-                res.description =
-                    Some(self.display(db, self.krate(db).to_display_target(db)).to_string());
+                res.description = salsa::attach(db, || {
+                    Some(self.display(db, self.krate(db).to_display_target(db)).to_string())
+                });
                 res.container_name = self.container_name(db);
                 res
             }),
@@ -485,8 +487,9 @@ impl TryToNav for hir::Field {
                 NavigationTarget::from_named(db, src.with_value(it), SymbolKind::Field).map(
                     |mut res| {
                         res.docs = self.docs(db);
-                        res.description =
-                            Some(self.display(db, krate.to_display_target(db)).to_string());
+                        res.description = salsa::attach(db, || {
+                            Some(self.display(db, krate.to_display_target(db)).to_string())
+                        });
                         res
                     },
                 )
diff --git a/src/tools/rust-analyzer/crates/ide/src/runnables.rs b/src/tools/rust-analyzer/crates/ide/src/runnables.rs
index 77c84292cf3e9..6d33ddcde0479 100644
--- a/src/tools/rust-analyzer/crates/ide/src/runnables.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/runnables.rs
@@ -10,7 +10,7 @@ use hir::{
 use ide_assists::utils::{has_test_related_attribute, test_related_attribute_syn};
 use ide_db::{
     FilePosition, FxHashMap, FxIndexMap, FxIndexSet, RootDatabase, SymbolKind,
-    base_db::RootQueryDb,
+    base_db::{RootQueryDb, salsa},
     defs::Definition,
     documentation::docs_from_attrs,
     helpers::visit_file_defs,
@@ -414,11 +414,13 @@ pub(crate) fn runnable_impl(
     let ty = def.self_ty(sema.db);
     let adt_name = ty.as_adt()?.name(sema.db);
     let mut ty_args = ty.generic_parameters(sema.db, display_target).peekable();
-    let params = if ty_args.peek().is_some() {
-        format!("<{}>", ty_args.format_with(",", |ty, cb| cb(&ty)))
-    } else {
-        String::new()
-    };
+    let params = salsa::attach(sema.db, || {
+        if ty_args.peek().is_some() {
+            format!("<{}>", ty_args.format_with(",", |ty, cb| cb(&ty)))
+        } else {
+            String::new()
+        }
+    });
     let mut test_id = format!("{}{params}", adt_name.display(sema.db, edition));
     test_id.retain(|c| c != ' ');
     let test_id = TestId::Path(test_id);
@@ -521,7 +523,9 @@ fn module_def_doctest(db: &RootDatabase, def: Definition) -> Option<Runnable> {
             let mut ty_args = ty.generic_parameters(db, display_target).peekable();
             format_to!(path, "{}", name.display(db, edition));
             if ty_args.peek().is_some() {
-                format_to!(path, "<{}>", ty_args.format_with(",", |ty, cb| cb(&ty)));
+                salsa::attach(db, || {
+                    format_to!(path, "<{}>", ty_args.format_with(",", |ty, cb| cb(&ty)));
+                });
             }
             format_to!(path, "::{}", def_name.display(db, edition));
             path.retain(|c| c != ' ');
diff --git a/src/tools/rust-analyzer/crates/ide/src/signature_help.rs b/src/tools/rust-analyzer/crates/ide/src/signature_help.rs
index 86d02b4098bd2..f45d096ac1904 100644
--- a/src/tools/rust-analyzer/crates/ide/src/signature_help.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/signature_help.rs
@@ -11,6 +11,7 @@ use hir::{
 use ide_db::{
     FilePosition, FxIndexMap,
     active_parameter::{callable_for_arg_list, generic_def_for_node},
+    base_db::salsa,
     documentation::{Documentation, HasDocs},
 };
 use itertools::Itertools;
@@ -266,12 +267,12 @@ fn signature_help_for_call(
             // In that case, fall back to render definitions of the respective parameters.
             // This is overly conservative: we do not substitute known type vars
             // (see FIXME in tests::impl_trait) and falling back on any unknowns.
-            match (p.ty().contains_unknown(), fn_params.as_deref()) {
+            salsa::attach(db, || match (p.ty().contains_unknown(), fn_params.as_deref()) {
                 (true, Some(fn_params)) => {
                     format_to!(buf, "{}", fn_params[idx].ty().display(db, display_target))
                 }
                 _ => format_to!(buf, "{}", p.ty().display(db, display_target)),
-            }
+            });
             res.push_call_param(&buf);
         }
     }
diff --git a/src/tools/rust-analyzer/crates/ide/src/static_index.rs b/src/tools/rust-analyzer/crates/ide/src/static_index.rs
index 694ac22e1993b..14b6529c61f8c 100644
--- a/src/tools/rust-analyzer/crates/ide/src/static_index.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/static_index.rs
@@ -5,7 +5,7 @@ use arrayvec::ArrayVec;
 use hir::{Crate, Module, Semantics, db::HirDatabase};
 use ide_db::{
     FileId, FileRange, FxHashMap, FxHashSet, RootDatabase,
-    base_db::{RootQueryDb, SourceDatabase, VfsPath},
+    base_db::{RootQueryDb, SourceDatabase, VfsPath, salsa},
     defs::{Definition, IdentClass},
     documentation::Documentation,
     famous_defs::FamousDefs,
@@ -227,30 +227,32 @@ impl StaticIndex<'_> {
             let id = if let Some(it) = self.def_map.get(&def) {
                 *it
             } else {
-                let it = self.tokens.insert(TokenStaticData {
-                    documentation: documentation_for_definition(&sema, def, scope_node),
-                    hover: Some(hover_for_definition(
-                        &sema,
-                        file_id,
-                        def,
-                        None,
-                        scope_node,
-                        None,
-                        false,
-                        &hover_config,
-                        edition,
-                        display_target,
-                    )),
-                    definition: def.try_to_nav(self.db).map(UpmappingResult::call_site).map(|it| {
-                        FileRange { file_id: it.file_id, range: it.focus_or_full_range() }
-                    }),
-                    references: vec![],
-                    moniker: current_crate.and_then(|cc| def_to_moniker(self.db, def, cc)),
-                    display_name: def
-                        .name(self.db)
-                        .map(|name| name.display(self.db, edition).to_string()),
-                    signature: Some(def.label(self.db, display_target)),
-                    kind: def_to_kind(self.db, def),
+                let it = salsa::attach(sema.db, || {
+                    self.tokens.insert(TokenStaticData {
+                        documentation: documentation_for_definition(&sema, def, scope_node),
+                        hover: Some(hover_for_definition(
+                            &sema,
+                            file_id,
+                            def,
+                            None,
+                            scope_node,
+                            None,
+                            false,
+                            &hover_config,
+                            edition,
+                            display_target,
+                        )),
+                        definition: def.try_to_nav(self.db).map(UpmappingResult::call_site).map(
+                            |it| FileRange { file_id: it.file_id, range: it.focus_or_full_range() },
+                        ),
+                        references: vec![],
+                        moniker: current_crate.and_then(|cc| def_to_moniker(self.db, def, cc)),
+                        display_name: def
+                            .name(self.db)
+                            .map(|name| name.display(self.db, edition).to_string()),
+                        signature: Some(def.label(self.db, display_target)),
+                        kind: def_to_kind(self.db, def),
+                    })
                 });
                 self.def_map.insert(def, it);
                 it
diff --git a/src/tools/rust-analyzer/crates/ide/src/view_memory_layout.rs b/src/tools/rust-analyzer/crates/ide/src/view_memory_layout.rs
index 63701a4d15e94..1eb0fd4fd8b76 100644
--- a/src/tools/rust-analyzer/crates/ide/src/view_memory_layout.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/view_memory_layout.rs
@@ -3,6 +3,7 @@ use std::fmt;
 use hir::{DisplayTarget, Field, HirDisplay, Layout, Semantics, Type};
 use ide_db::{
     RootDatabase,
+    base_db::salsa,
     defs::Definition,
     helpers::{get_definition, pick_best_token},
 };
@@ -141,7 +142,9 @@ pub(crate) fn view_memory_layout(
             if let Ok(child_layout) = child_ty.layout(db) {
                 nodes.push(MemoryLayoutNode {
                     item_name: field.name(db),
-                    typename: child_ty.display(db, display_target).to_string(),
+                    typename: salsa::attach(db, || {
+                        child_ty.display(db, display_target).to_string()
+                    }),
                     size: child_layout.size(),
                     alignment: child_layout.align(),
                     offset: match *field {
@@ -175,7 +178,7 @@ pub(crate) fn view_memory_layout(
         }
     }
 
-    ty.layout(db)
+    salsa::attach(db, || ty.layout(db))
         .map(|layout| {
             let item_name = match def {
                 // def is a datatype
@@ -188,7 +191,7 @@ pub(crate) fn view_memory_layout(
                 def => def.name(db).map(|n| n.as_str().to_owned()).unwrap_or("[ROOT]".to_owned()),
             };
 
-            let typename = ty.display(db, display_target).to_string();
+            let typename = salsa::attach(db, || ty.display(db, display_target).to_string());
 
             let mut nodes = vec![MemoryLayoutNode {
                 item_name,

From faf0dd978dc16873e22e62acfe8c54fb81fafe36 Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Sun, 10 Aug 2025 00:53:11 +0000
Subject: [PATCH 0100/1889] Deduplicate layout_of_adt

---
 .../rust-analyzer/crates/hir-ty/src/db.rs     | 17 +++---------
 .../crates/hir-ty/src/display.rs              |  2 +-
 .../rust-analyzer/crates/hir-ty/src/layout.rs |  9 +++----
 .../crates/hir-ty/src/layout/adt.rs           | 27 +++----------------
 src/tools/rust-analyzer/crates/hir/src/lib.rs |  2 +-
 .../rust-analyzer/src/cli/analysis_stats.rs   |  9 ++++---
 6 files changed, 19 insertions(+), 47 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
index 7a5daac69922f..161ad31e579b2 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
@@ -94,11 +94,11 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
 
     #[salsa::invoke(crate::layout::layout_of_adt_query)]
     #[salsa::cycle(cycle_result = crate::layout::layout_of_adt_cycle_result)]
-    fn layout_of_adt(
-        &self,
+    fn layout_of_adt<'db>(
+        &'db self,
         def: AdtId,
-        subst: Substitution,
-        env: Arc<TraitEnvironment>,
+        args: crate::next_solver::GenericArgs<'db>,
+        trait_env: Arc<TraitEnvironment>,
     ) -> Result<Arc<Layout>, LayoutError>;
 
     #[salsa::invoke(crate::layout::layout_of_ty_query)]
@@ -300,15 +300,6 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
 
     // next trait solver
 
-    #[salsa::invoke(crate::layout::layout_of_adt_ns_query)]
-    #[salsa::cycle(cycle_result = crate::layout::layout_of_adt_ns_cycle_result)]
-    fn layout_of_adt_ns<'db>(
-        &'db self,
-        def: AdtId,
-        args: crate::next_solver::GenericArgs<'db>,
-        trait_env: Arc<TraitEnvironment>,
-    ) -> Result<Arc<Layout>, LayoutError>;
-
     #[salsa::invoke(crate::layout::layout_of_ty_ns_query)]
     #[salsa::cycle(cycle_result = crate::layout::layout_of_ty_ns_cycle_result)]
     fn layout_of_ty_ns<'db>(
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 9f87c37834d77..81bc48eecfc8b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
@@ -944,7 +944,7 @@ fn render_const_scalar_inner(
                 SolverDefId::AdtId(def) => def,
                 _ => unreachable!(),
             };
-            let Ok(layout) = f.db.layout_of_adt_ns(def, args, trait_env.clone()) else {
+            let Ok(layout) = f.db.layout_of_adt(def, args, trait_env.clone()) else {
                 return f.write_str("<layout-error>");
             };
             match def {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
index fb7b5e1c83e4c..0a8ec949b7c0a 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
@@ -31,11 +31,8 @@ use crate::{
     },
 };
 
-pub(crate) use self::adt::{layout_of_adt_cycle_result, layout_of_adt_ns_cycle_result};
-pub use self::{
-    adt::{layout_of_adt_ns_query, layout_of_adt_query},
-    target::target_data_layout_query,
-};
+pub(crate) use self::adt::layout_of_adt_cycle_result;
+pub use self::{adt::layout_of_adt_query, target::target_data_layout_query};
 
 pub(crate) mod adt;
 pub(crate) mod target;
@@ -197,7 +194,7 @@ pub fn layout_of_ty_ns_query<'db>(
                 }
                 _ => {}
             }
-            return db.layout_of_adt_ns(def.inner().id, args, trait_env);
+            return db.layout_of_adt(def.inner().id, args, trait_env);
         }
         TyKind::Bool => Layout::scalar(
             dl,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs
index 2fa01b6b41abc..fefa3f2617439 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs
@@ -13,23 +13,13 @@ use smallvec::SmallVec;
 use triomphe::Arc;
 
 use crate::{
-    Substitution, TraitEnvironment,
+    TraitEnvironment,
     db::HirDatabase,
     layout::{Layout, LayoutCx, LayoutError, field_ty},
-    next_solver::{DbInterner, GenericArgs, mapping::ChalkToNextSolver},
+    next_solver::GenericArgs,
 };
 
-pub fn layout_of_adt_query(
-    db: &dyn HirDatabase,
-    def: AdtId,
-    subst: Substitution,
-    trait_env: Arc<TraitEnvironment>,
-) -> Result<Arc<Layout>, LayoutError> {
-    let interner = DbInterner::new_with(db, Some(trait_env.krate), trait_env.block);
-    db.layout_of_adt_ns(def, subst.to_nextsolver(interner), trait_env)
-}
-
-pub fn layout_of_adt_ns_query<'db>(
+pub fn layout_of_adt_query<'db>(
     db: &'db dyn HirDatabase,
     def: AdtId,
     args: GenericArgs<'db>,
@@ -105,16 +95,7 @@ pub fn layout_of_adt_ns_query<'db>(
     Ok(Arc::new(result))
 }
 
-pub(crate) fn layout_of_adt_cycle_result(
-    _: &dyn HirDatabase,
-    _: AdtId,
-    _: Substitution,
-    _: Arc<TraitEnvironment>,
-) -> Result<Arc<Layout>, LayoutError> {
-    Err(LayoutError::RecursiveTypeWithoutIndirection)
-}
-
-pub(crate) fn layout_of_adt_ns_cycle_result<'db>(
+pub(crate) fn layout_of_adt_cycle_result<'db>(
     _: &'db dyn HirDatabase,
     _def: AdtId,
     _args: GenericArgs<'db>,
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index 4dde019b50063..9accb33368980 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -1818,7 +1818,7 @@ impl Adt {
     pub fn layout(self, db: &dyn HirDatabase) -> Result<Layout, LayoutError> {
         let env = db.trait_environment(self.into());
         let interner = DbInterner::new_with(db, Some(env.krate), env.block);
-        db.layout_of_adt_ns(
+        db.layout_of_adt(
             self.into(),
             TyBuilder::adt(db, self.into())
                 .fill_with_defaults(db, || TyKind::Error.intern(Interner))
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
index 97886844a9f9e..6c0aa19f57482 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -10,15 +10,17 @@ use std::{
 
 use cfg::{CfgAtom, CfgDiff};
 use hir::{
-    Adt, AssocItem, Crate, DefWithBody, HasSource, HirDisplay, ImportPathConfig, ModuleDef, Name,
+    Adt, AssocItem, Crate, DefWithBody, HasCrate, HasSource, HirDisplay, ImportPathConfig,
+    ModuleDef, Name,
     db::{DefDatabase, ExpandDatabase, HirDatabase},
+    next_solver::{DbInterner, GenericArgs},
 };
 use hir_def::{
     SyntheticSyntax,
     expr_store::BodySourceMap,
     hir::{ExprId, PatId},
 };
-use hir_ty::{Interner, Substitution, TyExt, TypeFlags};
+use hir_ty::{Interner, TyExt, TypeFlags};
 use ide::{
     Analysis, AnalysisHost, AnnotationConfig, DiagnosticsConfig, Edition, InlayFieldsToResolve,
     InlayHintsConfig, LineCol, RootDatabase,
@@ -361,6 +363,7 @@ impl flags::AnalysisStats {
         let mut all = 0;
         let mut fail = 0;
         for &a in adts {
+            let interner = DbInterner::new_with(db, Some(a.krate(db).base()), None);
             let generic_params = db.generic_params(a.into());
             if generic_params.iter_type_or_consts().next().is_some()
                 || generic_params.iter_lt().next().is_some()
@@ -371,7 +374,7 @@ impl flags::AnalysisStats {
             all += 1;
             let Err(e) = db.layout_of_adt(
                 hir_def::AdtId::from(a),
-                Substitution::empty(Interner),
+                GenericArgs::new_from_iter(interner, []),
                 db.trait_environment(a.into()),
             ) else {
                 continue;

From 1b03009e7c34db88899228fb7a47a655e4b77a3c Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Sun, 10 Aug 2025 18:00:40 +0000
Subject: [PATCH 0101/1889] Convert some of mir/eval to next-solver types

---
 .../crates/hir-ty/src/consteval/tests.rs      |   2 +-
 .../crates/hir-ty/src/display.rs              |  17 +-
 .../rust-analyzer/crates/hir-ty/src/lib.rs    |  41 ++-
 .../rust-analyzer/crates/hir-ty/src/mir.rs    |   2 +-
 .../crates/hir-ty/src/mir/eval.rs             | 282 ++++++++++++------
 .../crates/hir-ty/src/mir/eval/shim.rs        |  25 +-
 .../crates/hir-ty/src/mir/eval/tests.rs       |   2 +-
 .../crates/hir-ty/src/next_solver/consts.rs   |  12 +-
 .../crates/hir-ty/src/next_solver/mapping.rs  |   7 +-
 9 files changed, 258 insertions(+), 132 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs
index 22b152fe034a6..299b73a7d6cc4 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs
@@ -76,7 +76,7 @@ fn check_str(#[rust_analyzer::rust_fixture] ra_fixture: &str, answer: &str) {
 #[track_caller]
 fn check_answer(
     #[rust_analyzer::rust_fixture] ra_fixture: &str,
-    check: impl FnOnce(&[u8], &MemoryMap),
+    check: impl FnOnce(&[u8], &MemoryMap<'_>),
 ) {
     let (db, file_ids) = TestDB::with_many_files(ra_fixture);
     let file_id = *file_ids.last().unwrap();
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 81bc48eecfc8b..5adbea75a67dd 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
@@ -744,20 +744,20 @@ impl HirDisplay for Const {
 fn render_const_scalar(
     f: &mut HirFormatter<'_>,
     b: &[u8],
-    memory_map: &MemoryMap,
+    memory_map: &MemoryMap<'_>,
     ty: &Ty,
 ) -> Result<(), HirDisplayError> {
     let trait_env = TraitEnvironment::empty(f.krate());
     let interner = DbInterner::new_with(f.db, Some(trait_env.krate), trait_env.block);
     let ty = normalize(f.db, trait_env.clone(), ty.clone());
     let ty = ty.to_nextsolver(interner);
-    render_const_scalar_inner(f, b, memory_map, ty, trait_env, interner)
+    render_const_scalar_inner(f, b, memory_map, ty, trait_env)
 }
 
 fn render_const_scalar_ns(
     f: &mut HirFormatter<'_>,
     b: &[u8],
-    memory_map: &MemoryMap,
+    memory_map: &MemoryMap<'_>,
     ty: crate::next_solver::Ty<'_>,
 ) -> Result<(), HirDisplayError> {
     let trait_env = TraitEnvironment::empty(f.krate());
@@ -767,16 +767,15 @@ fn render_const_scalar_ns(
         trait_env.env.to_nextsolver(interner),
         ty,
     );
-    render_const_scalar_inner(f, b, memory_map, ty, trait_env, interner)
+    render_const_scalar_inner(f, b, memory_map, ty, trait_env)
 }
 
 fn render_const_scalar_inner(
     f: &mut HirFormatter<'_>,
     b: &[u8],
-    memory_map: &MemoryMap,
+    memory_map: &MemoryMap<'_>,
     ty: crate::next_solver::Ty<'_>,
     trait_env: Arc<TraitEnvironment>,
-    interner: DbInterner<'_>,
 ) -> Result<(), HirDisplayError> {
     use rustc_type_ir::TyKind;
     match ty.kind() {
@@ -875,7 +874,7 @@ fn render_const_scalar_inner(
                 let Ok(t) = memory_map.vtable_ty(ty_id) else {
                     return f.write_str("<ty-missing-in-vtable-map>");
                 };
-                let Ok(layout) = f.db.layout_of_ty(t.clone(), trait_env) else {
+                let Ok(layout) = f.db.layout_of_ty_ns(t, trait_env) else {
                     return f.write_str("<layout-error>");
                 };
                 let size = layout.size.bytes_usize();
@@ -883,7 +882,7 @@ fn render_const_scalar_inner(
                     return f.write_str("<ref-data-not-available>");
                 };
                 f.write_str("&")?;
-                render_const_scalar_ns(f, bytes, memory_map, t.to_nextsolver(interner))
+                render_const_scalar_ns(f, bytes, memory_map, t)
             }
             TyKind::Adt(adt, _) if b.len() == 2 * size_of::<usize>() => match adt.def_id() {
                 SolverDefId::AdtId(hir_def::AdtId::StructId(s)) => {
@@ -1052,7 +1051,7 @@ fn render_variant_after_name(
     layout: &Layout,
     args: GenericArgs<'_>,
     b: &[u8],
-    memory_map: &MemoryMap,
+    memory_map: &MemoryMap<'_>,
 ) -> Result<(), HirDisplayError> {
     let interner = DbInterner::new_with(f.db, Some(trait_env.krate), trait_env.block);
     match data.shape {
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 81894830b5b47..8ce0aeb5532ad 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
@@ -212,20 +212,20 @@ pub(crate) type ProgramClause = chalk_ir::ProgramClause<Interner>;
 /// the necessary bits of memory of the const eval session to keep the constant
 /// meaningful.
 #[derive(Debug, Default, Clone, PartialEq, Eq)]
-pub enum MemoryMap {
+pub enum MemoryMap<'db> {
     #[default]
     Empty,
     Simple(Box<[u8]>),
-    Complex(Box<ComplexMemoryMap>),
+    Complex(Box<ComplexMemoryMap<'db>>),
 }
 
 #[derive(Debug, Default, Clone, PartialEq, Eq)]
-pub struct ComplexMemoryMap {
+pub struct ComplexMemoryMap<'db> {
     memory: IndexMap<usize, Box<[u8]>, FxBuildHasher>,
-    vtable: VTableMap,
+    vtable: VTableMap<'db>,
 }
 
-impl ComplexMemoryMap {
+impl ComplexMemoryMap<'_> {
     fn insert(&mut self, addr: usize, val: Box<[u8]>) {
         match self.memory.entry(addr) {
             Entry::Occupied(mut e) => {
@@ -240,8 +240,8 @@ impl ComplexMemoryMap {
     }
 }
 
-impl MemoryMap {
-    pub fn vtable_ty(&self, id: usize) -> Result<&Ty, MirEvalError> {
+impl<'db> MemoryMap<'db> {
+    pub fn vtable_ty(&self, id: usize) -> Result<crate::next_solver::Ty<'db>, MirEvalError> {
         match self {
             MemoryMap::Empty | MemoryMap::Simple(_) => Err(MirEvalError::InvalidVTableId(id)),
             MemoryMap::Complex(cm) => cm.vtable.ty(id),
@@ -291,10 +291,11 @@ impl MemoryMap {
     }
 }
 
+// FIXME(next-solver):
 /// A concrete constant value
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ConstScalar {
-    Bytes(Box<[u8]>, MemoryMap),
+    Bytes(Box<[u8]>, MemoryMap<'static>),
     // FIXME: this is a hack to get around chalk not being able to represent unevaluatable
     // constants
     UnevaluatedConst(GeneralConstId, Substitution),
@@ -315,6 +316,30 @@ impl Hash for ConstScalar {
     }
 }
 
+/// A concrete constant value
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ConstScalarNs<'db> {
+    Bytes(Box<[u8]>, MemoryMap<'db>),
+    // FIXME: this is a hack to get around chalk not being able to represent unevaluatable
+    // constants
+    UnevaluatedConst(GeneralConstId, Substitution),
+    /// Case of an unknown value that rustc might know but we don't
+    // FIXME: this is a hack to get around chalk not being able to represent unevaluatable
+    // constants
+    // https://github.com/rust-lang/rust-analyzer/pull/8813#issuecomment-840679177
+    // https://rust-lang.zulipchat.com/#narrow/stream/144729-wg-traits/topic/Handling.20non.20evaluatable.20constants'.20equality/near/238386348
+    Unknown,
+}
+
+impl Hash for ConstScalarNs<'_> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        core::mem::discriminant(self).hash(state);
+        if let ConstScalarNs::Bytes(b, _) = self {
+            b.hash(state)
+        }
+    }
+}
+
 /// Return an index of a parameter in the generic type parameter list by it's id.
 pub fn param_idx(db: &dyn HirDatabase, id: TypeOrConstParamId) -> Option<usize> {
     generics::generics(db, id.parent).type_or_const_param_idx(id)
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir.rs
index 482b420279c90..8c48a16537a2e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir.rs
@@ -107,7 +107,7 @@ pub enum OperandKind {
 }
 
 impl Operand {
-    fn from_concrete_const(data: Box<[u8]>, memory_map: MemoryMap, ty: Ty) -> Self {
+    fn from_concrete_const(data: Box<[u8]>, memory_map: MemoryMap<'static>, ty: Ty) -> Self {
         Operand {
             kind: OperandKind::Constant(intern_const_scalar(
                 ConstScalar::Bytes(data, memory_map),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
index dfb8ae704b996..d0ae92961efc0 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
@@ -25,21 +25,26 @@ use rustc_apfloat::{
     ieee::{Half as f16, Quad as f128},
 };
 use rustc_hash::{FxHashMap, FxHashSet};
+use rustc_type_ir::inherent::{AdtDef, IntoKind, SliceLike, Ty as _};
 use span::FileId;
 use stdx::never;
 use syntax::{SyntaxNodePtr, TextRange};
 use triomphe::Arc;
 
 use crate::{
-    AliasTy, CallableDefId, ClosureId, ComplexMemoryMap, Const, ConstData, ConstScalar, FnDefId,
-    Interner, MemoryMap, Substitution, ToChalk, TraitEnvironment, Ty, TyBuilder, TyExt, TyKind,
+    AliasTy, CallableDefId, ClosureId, ComplexMemoryMap, Const, ConstData, ConstScalar, Interner,
+    MemoryMap, Substitution, ToChalk, TraitEnvironment, Ty, TyBuilder, TyExt, TyKind,
     consteval::{ConstEvalError, intern_const_scalar, try_const_usize},
+    consteval_nextsolver,
     db::{HirDatabase, InternedClosure},
     display::{ClosureStyle, DisplayTarget, HirDisplay},
     infer::PointerCast,
     layout::{Layout, LayoutError, RustcEnumVariantIdx},
-    mapping::from_chalk,
     method_resolution::{is_dyn_method, lookup_impl_const},
+    next_solver::{
+        Ctor, DbInterner, SolverDefId,
+        mapping::{ChalkToNextSolver, convert_args_for_result, convert_ty_for_result},
+    },
     static_lifetime,
     traits::FnTrait,
     utils::{ClosureSubst, detect_variant_from_bytes},
@@ -78,31 +83,31 @@ macro_rules! not_supported {
 }
 
 #[derive(Debug, Default, Clone, PartialEq, Eq)]
-pub struct VTableMap {
-    ty_to_id: FxHashMap<Ty, usize>,
-    id_to_ty: Vec<Ty>,
+pub struct VTableMap<'db> {
+    ty_to_id: FxHashMap<crate::next_solver::Ty<'db>, usize>,
+    id_to_ty: Vec<crate::next_solver::Ty<'db>>,
 }
 
-impl VTableMap {
+impl<'db> VTableMap<'db> {
     const OFFSET: usize = 1000; // We should add some offset to ids to make 0 (null) an invalid id.
 
-    fn id(&mut self, ty: Ty) -> usize {
+    fn id(&mut self, ty: crate::next_solver::Ty<'db>) -> usize {
         if let Some(it) = self.ty_to_id.get(&ty) {
             return *it;
         }
         let id = self.id_to_ty.len() + VTableMap::OFFSET;
-        self.id_to_ty.push(ty.clone());
+        self.id_to_ty.push(ty);
         self.ty_to_id.insert(ty, id);
         id
     }
 
-    pub(crate) fn ty(&self, id: usize) -> Result<&Ty> {
+    pub(crate) fn ty(&self, id: usize) -> Result<crate::next_solver::Ty<'db>> {
         id.checked_sub(VTableMap::OFFSET)
-            .and_then(|id| self.id_to_ty.get(id))
+            .and_then(|id| self.id_to_ty.get(id).copied())
             .ok_or(MirEvalError::InvalidVTableId(id))
     }
 
-    fn ty_of_bytes(&self, bytes: &[u8]) -> Result<&Ty> {
+    fn ty_of_bytes(&self, bytes: &[u8]) -> Result<crate::next_solver::Ty<'db>> {
         let id = from_bytes!(usize, bytes);
         self.ty(id)
     }
@@ -170,12 +175,12 @@ pub struct Evaluator<'a> {
     /// We don't really have function pointers, i.e. pointers to some assembly instructions that we can run. Instead, we
     /// store the type as an interned id in place of function and vtable pointers, and we recover back the type at the
     /// time of use.
-    vtable_map: VTableMap,
+    vtable_map: VTableMap<'a>,
     thread_local_storage: TlsData,
     random_state: oorandom::Rand64,
     stdout: Vec<u8>,
     stderr: Vec<u8>,
-    layout_cache: RefCell<FxHashMap<Ty, Arc<Layout>>>,
+    layout_cache: RefCell<FxHashMap<crate::next_solver::Ty<'a>, Arc<Layout>>>,
     projected_ty_cache: RefCell<FxHashMap<(Ty, PlaceElem), Ty>>,
     not_special_fn_cache: RefCell<FxHashSet<FunctionId>>,
     mir_or_dyn_index_cache: RefCell<FxHashMap<(FunctionId, Substitution), MirOrDynIndex>>,
@@ -224,7 +229,7 @@ impl Interval {
         Self { addr, size }
     }
 
-    fn get<'a>(&self, memory: &'a Evaluator<'a>) -> Result<&'a [u8]> {
+    fn get<'a, 'db>(&self, memory: &'a Evaluator<'db>) -> Result<&'a [u8]> {
         memory.read_memory(self.addr, self.size)
     }
 
@@ -242,7 +247,7 @@ impl Interval {
 }
 
 impl IntervalAndTy {
-    fn get<'a>(&self, memory: &'a Evaluator<'a>) -> Result<&'a [u8]> {
+    fn get<'a, 'db>(&self, memory: &'a Evaluator<'db>) -> Result<&'a [u8]> {
         memory.read_memory(self.interval.addr, self.interval.size)
     }
 
@@ -269,7 +274,7 @@ impl From<Interval> for IntervalOrOwned {
 }
 
 impl IntervalOrOwned {
-    fn get<'a>(&'a self, memory: &'a Evaluator<'a>) -> Result<&'a [u8]> {
+    fn get<'a, 'db>(&'a self, memory: &'a Evaluator<'db>) -> Result<&'a [u8]> {
         Ok(match self {
             IntervalOrOwned::Owned(o) => o,
             IntervalOrOwned::Borrowed(b) => b.get(memory)?,
@@ -608,7 +613,13 @@ pub fn interpret_mir(
             memory_map.vtable.shrink_to_fit();
             MemoryMap::Complex(Box::new(memory_map))
         };
-        Ok(intern_const_scalar(ConstScalar::Bytes(bytes, memory_map), ty))
+        // SAFETY: will never use this without a db
+        Ok(intern_const_scalar(
+            ConstScalar::Bytes(bytes, unsafe {
+                std::mem::transmute::<MemoryMap<'_>, MemoryMap<'static>>(memory_map)
+            }),
+            ty,
+        ))
     })();
     Ok((it, MirOutput { stdout: evaluator.stdout, stderr: evaluator.stderr }))
 }
@@ -618,7 +629,7 @@ const EXECUTION_LIMIT: usize = 100_000;
 #[cfg(not(test))]
 const EXECUTION_LIMIT: usize = 10_000_000;
 
-impl Evaluator<'_> {
+impl<'db> Evaluator<'db> {
     pub fn new(
         db: &dyn HirDatabase,
         owner: DefWithBodyId,
@@ -719,6 +730,7 @@ impl Evaluator<'_> {
         p: &Place,
         locals: &'a Locals,
     ) -> Result<(Address, Ty, Option<IntervalOrOwned>)> {
+        let interner = DbInterner::new_with(self.db, None, None);
         let mut addr = locals.ptr[p.local].addr;
         let mut ty: Ty = locals.body.locals[p.local].ty.clone();
         let mut metadata: Option<IntervalOrOwned> = None; // locals are always sized
@@ -791,19 +803,19 @@ impl Evaluator<'_> {
                     addr = addr.offset(ty_size * (from as usize));
                 }
                 &ProjectionElem::ClosureField(f) => {
-                    let layout = self.layout(&prev_ty)?;
+                    let layout = self.layout(prev_ty.to_nextsolver(interner))?;
                     let offset = layout.fields.offset(f).bytes_usize();
                     addr = addr.offset(offset);
                     metadata = None;
                 }
                 ProjectionElem::Field(Either::Right(f)) => {
-                    let layout = self.layout(&prev_ty)?;
+                    let layout = self.layout(prev_ty.to_nextsolver(interner))?;
                     let offset = layout.fields.offset(f.index as usize).bytes_usize();
                     addr = addr.offset(offset);
                     metadata = None; // tuple field is always sized FIXME: This is wrong, the tail can be unsized
                 }
                 ProjectionElem::Field(Either::Left(f)) => {
-                    let layout = self.layout(&prev_ty)?;
+                    let layout = self.layout(prev_ty.to_nextsolver(interner))?;
                     let variant_layout = match &layout.variants {
                         Variants::Single { .. } | Variants::Empty => &layout,
                         Variants::Multiple { variants, .. } => {
@@ -835,20 +847,28 @@ impl Evaluator<'_> {
         Ok((addr, ty, metadata))
     }
 
-    fn layout(&self, ty: &Ty) -> Result<Arc<Layout>> {
-        if let Some(x) = self.layout_cache.borrow().get(ty) {
+    fn layout(&self, ty: crate::next_solver::Ty<'db>) -> Result<Arc<Layout>> {
+        if let Some(x) = self.layout_cache.borrow().get(&ty) {
             return Ok(x.clone());
         }
+        let interner = DbInterner::new_with(self.db, None, None);
         let r = self
             .db
-            .layout_of_ty(ty.clone(), self.trait_env.clone())
-            .map_err(|e| MirEvalError::LayoutError(e, ty.clone()))?;
-        self.layout_cache.borrow_mut().insert(ty.clone(), r.clone());
+            .layout_of_ty_ns(ty, self.trait_env.clone())
+            .map_err(|e| MirEvalError::LayoutError(e, convert_ty_for_result(interner, ty)))?;
+        self.layout_cache.borrow_mut().insert(ty, r.clone());
         Ok(r)
     }
 
     fn layout_adt(&self, adt: AdtId, subst: Substitution) -> Result<Arc<Layout>> {
-        self.layout(&TyKind::Adt(chalk_ir::AdtId(adt), subst).intern(Interner))
+        let interner = DbInterner::new_with(self.db, None, None);
+        self.layout(crate::next_solver::Ty::new(
+            interner,
+            rustc_type_ir::TyKind::Adt(
+                crate::next_solver::AdtDef::new(adt, interner),
+                subst.to_nextsolver(interner),
+            ),
+        ))
     }
 
     fn place_ty<'a>(&'a self, p: &Place, locals: &'a Locals) -> Result<Ty> {
@@ -952,7 +972,7 @@ impl Evaluator<'_> {
                                     )?
                                 }
                                 TyKind::FnDef(def, generic_args) => self.exec_fn_def(
-                                    *def,
+                                    CallableDefId::from_chalk(self.db, *def),
                                     generic_args,
                                     destination_interval,
                                     &args,
@@ -1113,6 +1133,7 @@ impl Evaluator<'_> {
     }
 
     fn eval_rvalue(&mut self, r: &Rvalue, locals: &mut Locals) -> Result<IntervalOrOwned> {
+        let interner = DbInterner::new_with(self.db, None, None);
         use IntervalOrOwned::*;
         Ok(match r {
             Rvalue::Use(it) => Borrowed(self.eval_operand(it, locals)?),
@@ -1436,7 +1457,7 @@ impl Evaluator<'_> {
                         Owned(r)
                     }
                     AggregateKind::Tuple(ty) => {
-                        let layout = self.layout(ty)?;
+                        let layout = self.layout(ty.to_nextsolver(interner))?;
                         Owned(self.construct_with_layout(
                             layout.size.bytes_usize(),
                             &layout,
@@ -1467,7 +1488,7 @@ impl Evaluator<'_> {
                         )?)
                     }
                     AggregateKind::Closure(ty) => {
-                        let layout = self.layout(ty)?;
+                        let layout = self.layout(ty.to_nextsolver(interner))?;
                         Owned(self.construct_with_layout(
                             layout.size.bytes_usize(),
                             &layout,
@@ -1484,6 +1505,8 @@ impl Evaluator<'_> {
                         if let TyKind::FnDef(_, _) | TyKind::Closure(_, _) =
                             &current_ty.kind(Interner)
                         {
+                            let interner = DbInterner::new_with(self.db, None, None);
+                            let current_ty = current_ty.to_nextsolver(interner);
                             let id = self.vtable_map.id(current_ty);
                             let ptr_size = self.ptr_size();
                             Owned(id.to_le_bytes()[0..ptr_size].to_vec())
@@ -1623,7 +1646,8 @@ impl Evaluator<'_> {
     }
 
     fn compute_discriminant(&self, ty: Ty, bytes: &[u8]) -> Result<i128> {
-        let layout = self.layout(&ty)?;
+        let interner = DbInterner::new_with(self.db, None, None);
+        let layout = self.layout(ty.to_nextsolver(interner))?;
         let &TyKind::Adt(chalk_ir::AdtId(AdtId::EnumId(e)), _) = ty.kind(Interner) else {
             return Ok(0);
         };
@@ -1732,6 +1756,8 @@ impl Evaluator<'_> {
                 }
             },
             TyKind::Dyn(_) => {
+                let interner = DbInterner::new_with(self.db, None, None);
+                let current_ty = current_ty.to_nextsolver(interner);
                 let vtable = self.vtable_map.id(current_ty);
                 let mut r = Vec::with_capacity(16);
                 let addr = addr.get(self)?;
@@ -1777,6 +1803,7 @@ impl Evaluator<'_> {
         subst: Substitution,
         locals: &Locals,
     ) -> Result<(usize, Arc<Layout>, Option<(usize, usize, i128)>)> {
+        let interner = DbInterner::new_with(self.db, None, None);
         let adt = it.adt_id(self.db);
         if let DefWithBodyId::VariantId(f) = locals.body.owner
             && let VariantId::EnumVariantId(it) = it
@@ -1786,7 +1813,11 @@ impl Evaluator<'_> {
             // Computing the exact size of enums require resolving the enum discriminants. In order to prevent loops (and
             // infinite sized type errors) we use a dummy layout
             let i = self.const_eval_discriminant(it)?;
-            return Ok((16, self.layout(&TyBuilder::unit())?, Some((0, 16, i))));
+            return Ok((
+                16,
+                self.layout(crate::next_solver::Ty::new_tup(interner, &[]))?,
+                Some((0, 16, i)),
+            ));
         }
         let layout = self.layout_adt(adt, subst)?;
         Ok(match &layout.variants {
@@ -1885,6 +1916,7 @@ impl Evaluator<'_> {
 
     #[allow(clippy::double_parens)]
     fn allocate_const_in_heap(&mut self, locals: &Locals, konst: &Const) -> Result<Interval> {
+        let interner = DbInterner::new_with(self.db, None, None);
         let ConstData { ty, value: chalk_ir::ConstValue::Concrete(c) } = &konst.data(Interner)
         else {
             not_supported!("evaluating non concrete constant");
@@ -1945,7 +1977,7 @@ impl Evaluator<'_> {
                 MemoryMap::Complex(cm) => cm.vtable.ty_of_bytes(bytes),
             },
             addr,
-            ty,
+            ty.to_nextsolver(interner),
             locals,
         )?;
         Ok(Interval::new(addr, size))
@@ -2048,7 +2080,8 @@ impl Evaluator<'_> {
     }
 
     fn size_align_of(&self, ty: &Ty, locals: &Locals) -> Result<Option<(usize, usize)>> {
-        if let Some(layout) = self.layout_cache.borrow().get(ty) {
+        let interner = DbInterner::new_with(self.db, None, None);
+        if let Some(layout) = self.layout_cache.borrow().get(&ty.to_nextsolver(interner)) {
             return Ok(layout
                 .is_sized()
                 .then(|| (layout.size.bytes_usize(), layout.align.abi.bytes() as usize)));
@@ -2061,7 +2094,7 @@ impl Evaluator<'_> {
             // infinite sized type errors) we use a dummy size
             return Ok(Some((16, 16)));
         }
-        let layout = self.layout(ty);
+        let layout = self.layout(ty.to_nextsolver(interner));
         if self.assert_placeholder_ty_is_unused
             && matches!(layout, Err(MirEvalError::LayoutError(LayoutError::HasPlaceholder, _)))
         {
@@ -2129,15 +2162,16 @@ impl Evaluator<'_> {
         bytes: &[u8],
         ty: &Ty,
         locals: &Locals,
-    ) -> Result<ComplexMemoryMap> {
-        fn rec(
-            this: &Evaluator<'_>,
+    ) -> Result<ComplexMemoryMap<'db>> {
+        fn rec<'db>(
+            this: &Evaluator<'db>,
             bytes: &[u8],
             ty: &Ty,
             locals: &Locals,
-            mm: &mut ComplexMemoryMap,
+            mm: &mut ComplexMemoryMap<'db>,
             stack_depth_limit: usize,
         ) -> Result<()> {
+            let interner = DbInterner::new_with(this.db, None, None);
             if stack_depth_limit.checked_sub(1).is_none() {
                 return Err(MirEvalError::StackOverflow);
             }
@@ -2158,13 +2192,14 @@ impl Evaluator<'_> {
                             let element_size = match t.kind(Interner) {
                                 TyKind::Str => 1,
                                 TyKind::Slice(t) => {
-                                    check_inner = Some(t);
+                                    check_inner = Some(t.clone());
                                     this.size_of_sized(t, locals, "slice inner type")?
                                 }
                                 TyKind::Dyn(_) => {
                                     let t = this.vtable_map.ty_of_bytes(meta)?;
-                                    check_inner = Some(t);
-                                    this.size_of_sized(t, locals, "dyn concrete type")?
+                                    let t = convert_ty_for_result(interner, t);
+                                    check_inner = Some(t.clone());
+                                    this.size_of_sized(&t, locals, "dyn concrete type")?
                                 }
                                 _ => return Ok(()),
                             };
@@ -2176,7 +2211,7 @@ impl Evaluator<'_> {
                             let addr = Address::from_bytes(addr)?;
                             let b = this.read_memory(addr, size)?;
                             mm.insert(addr.to_usize(), b.into());
-                            if let Some(ty) = check_inner {
+                            if let Some(ty) = &check_inner {
                                 for i in 0..count {
                                     let offset = element_size * i;
                                     rec(
@@ -2211,11 +2246,11 @@ impl Evaluator<'_> {
                     }
                 }
                 TyKind::Tuple(_, subst) => {
-                    let layout = this.layout(ty)?;
+                    let layout = this.layout(ty.to_nextsolver(interner))?;
                     for (id, ty) in subst.iter(Interner).enumerate() {
                         let ty = ty.assert_ty_ref(Interner); // Tuple only has type argument
                         let offset = layout.fields.offset(id).bytes_usize();
-                        let size = this.layout(ty)?.size.bytes_usize();
+                        let size = this.layout(ty.to_nextsolver(interner))?.size.bytes_usize();
                         rec(
                             this,
                             &bytes[offset..offset + size],
@@ -2229,7 +2264,7 @@ impl Evaluator<'_> {
                 TyKind::Adt(adt, subst) => match adt.0 {
                     AdtId::StructId(s) => {
                         let data = s.fields(this.db);
-                        let layout = this.layout(ty)?;
+                        let layout = this.layout(ty.to_nextsolver(interner))?;
                         let field_types = this.db.field_types(s.into());
                         for (f, _) in data.fields().iter() {
                             let offset = layout
@@ -2237,7 +2272,7 @@ impl Evaluator<'_> {
                                 .offset(u32::from(f.into_raw()) as usize)
                                 .bytes_usize();
                             let ty = &field_types[f].clone().substitute(Interner, subst);
-                            let size = this.layout(ty)?.size.bytes_usize();
+                            let size = this.layout(ty.to_nextsolver(interner))?.size.bytes_usize();
                             rec(
                                 this,
                                 &bytes[offset..offset + size],
@@ -2249,7 +2284,7 @@ impl Evaluator<'_> {
                         }
                     }
                     AdtId::EnumId(e) => {
-                        let layout = this.layout(ty)?;
+                        let layout = this.layout(ty.to_nextsolver(interner))?;
                         if let Some((v, l)) = detect_variant_from_bytes(
                             &layout,
                             this.db,
@@ -2263,7 +2298,8 @@ impl Evaluator<'_> {
                                 let offset =
                                     l.fields.offset(u32::from(f.into_raw()) as usize).bytes_usize();
                                 let ty = &field_types[f].clone().substitute(Interner, subst);
-                                let size = this.layout(ty)?.size.bytes_usize();
+                                let size =
+                                    this.layout(ty.to_nextsolver(interner))?.size.bytes_usize();
                                 rec(
                                     this,
                                     &bytes[offset..offset + size],
@@ -2290,20 +2326,26 @@ impl Evaluator<'_> {
         Ok(mm)
     }
 
-    fn patch_addresses<'vtable>(
+    fn patch_addresses(
         &mut self,
         patch_map: &FxHashMap<usize, usize>,
-        ty_of_bytes: impl Fn(&[u8]) -> Result<&'vtable Ty> + Copy,
+        ty_of_bytes: impl Fn(&[u8]) -> Result<crate::next_solver::Ty<'db>> + Copy,
         addr: Address,
-        ty: &Ty,
+        ty: crate::next_solver::Ty<'db>,
         locals: &Locals,
     ) -> Result<()> {
+        let interner = DbInterner::new_with(self.db, None, None);
         // FIXME: support indirect references
         let layout = self.layout(ty)?;
-        let my_size = self.size_of_sized(ty, locals, "value to patch address")?;
-        match ty.kind(Interner) {
-            TyKind::Ref(_, _, t) => {
-                let size = self.size_align_of(t, locals)?;
+        let my_size = self.size_of_sized(
+            &convert_ty_for_result(interner, ty),
+            locals,
+            "value to patch address",
+        )?;
+        use rustc_type_ir::TyKind;
+        match ty.kind() {
+            TyKind::Ref(_, t, _) => {
+                let size = self.size_align_of(&convert_ty_for_result(interner, t), locals)?;
                 match size {
                     Some(_) => {
                         let current = from_bytes!(usize, self.read_memory(addr, my_size)?);
@@ -2319,27 +2361,27 @@ impl Evaluator<'_> {
                     }
                 }
             }
-            TyKind::Function(_) => {
-                let ty = ty_of_bytes(self.read_memory(addr, my_size)?)?.clone();
+            TyKind::FnPtr(_, _) => {
+                let ty = ty_of_bytes(self.read_memory(addr, my_size)?)?;
                 let new_id = self.vtable_map.id(ty);
                 self.write_memory(addr, &new_id.to_le_bytes())?;
             }
-            TyKind::Adt(id, subst) => match id.0 {
-                AdtId::StructId(s) => {
-                    for (i, (_, ty)) in self.db.field_types(s.into()).iter().enumerate() {
+            TyKind::Adt(id, args) => match id.def_id() {
+                SolverDefId::AdtId(AdtId::StructId(s)) => {
+                    for (i, (_, ty)) in self.db.field_types_ns(s.into()).iter().enumerate() {
                         let offset = layout.fields.offset(i).bytes_usize();
-                        let ty = ty.clone().substitute(Interner, subst);
+                        let ty = ty.instantiate(interner, args);
                         self.patch_addresses(
                             patch_map,
                             ty_of_bytes,
                             addr.offset(offset),
-                            &ty,
+                            ty,
                             locals,
                         )?;
                     }
                 }
-                AdtId::UnionId(_) => (),
-                AdtId::EnumId(e) => {
+                SolverDefId::AdtId(AdtId::UnionId(_)) => (),
+                SolverDefId::AdtId(AdtId::EnumId(e)) => {
                     if let Some((ev, layout)) = detect_variant_from_bytes(
                         &layout,
                         self.db,
@@ -2347,33 +2389,37 @@ impl Evaluator<'_> {
                         self.read_memory(addr, layout.size.bytes_usize())?,
                         e,
                     ) {
-                        for (i, (_, ty)) in self.db.field_types(ev.into()).iter().enumerate() {
+                        for (i, (_, ty)) in self.db.field_types_ns(ev.into()).iter().enumerate() {
                             let offset = layout.fields.offset(i).bytes_usize();
-                            let ty = ty.clone().substitute(Interner, subst);
+                            let ty = ty.instantiate(interner, args);
                             self.patch_addresses(
                                 patch_map,
                                 ty_of_bytes,
                                 addr.offset(offset),
-                                &ty,
+                                ty,
                                 locals,
                             )?;
                         }
                     }
                 }
+                _ => unreachable!(),
             },
-            TyKind::Tuple(_, subst) => {
-                for (id, ty) in subst.iter(Interner).enumerate() {
-                    let ty = ty.assert_ty_ref(Interner); // Tuple only has type argument
+            TyKind::Tuple(tys) => {
+                for (id, ty) in tys.iter().enumerate() {
                     let offset = layout.fields.offset(id).bytes_usize();
                     self.patch_addresses(patch_map, ty_of_bytes, addr.offset(offset), ty, locals)?;
                 }
             }
             TyKind::Array(inner, len) => {
-                let len = match try_const_usize(self.db, len) {
+                let len = match consteval_nextsolver::try_const_usize(self.db, len) {
                     Some(it) => it as usize,
                     None => not_supported!("non evaluatable array len in patching addresses"),
                 };
-                let size = self.size_of_sized(inner, locals, "inner of array")?;
+                let size = self.size_of_sized(
+                    &convert_ty_for_result(interner, inner),
+                    locals,
+                    "inner of array",
+                )?;
                 for i in 0..len {
                     self.patch_addresses(
                         patch_map,
@@ -2384,11 +2430,13 @@ impl Evaluator<'_> {
                     )?;
                 }
             }
-            TyKind::AssociatedType(_, _)
-            | TyKind::Scalar(_)
+            TyKind::Bool
+            | TyKind::Char
+            | TyKind::Int(_)
+            | TyKind::Uint(_)
+            | TyKind::Float(_)
             | TyKind::Slice(_)
-            | TyKind::Raw(_, _)
-            | TyKind::OpaqueType(_, _)
+            | TyKind::RawPtr(_, _)
             | TyKind::FnDef(_, _)
             | TyKind::Str
             | TyKind::Never
@@ -2396,12 +2444,16 @@ impl Evaluator<'_> {
             | TyKind::Coroutine(_, _)
             | TyKind::CoroutineWitness(_, _)
             | TyKind::Foreign(_)
-            | TyKind::Error
+            | TyKind::Error(_)
             | TyKind::Placeholder(_)
-            | TyKind::Dyn(_)
-            | TyKind::Alias(_)
-            | TyKind::BoundVar(_)
-            | TyKind::InferenceVar(_, _) => (),
+            | TyKind::Dynamic(_, _, _)
+            | TyKind::Alias(_, _)
+            | TyKind::Bound(_, _)
+            | TyKind::Infer(_)
+            | TyKind::Pat(_, _)
+            | TyKind::Param(_)
+            | TyKind::UnsafeBinder(_)
+            | TyKind::CoroutineClosure(_, _) => (),
         }
         Ok(())
     }
@@ -2416,13 +2468,41 @@ impl Evaluator<'_> {
         span: MirSpan,
     ) -> Result<Option<StackFrame>> {
         let id = from_bytes!(usize, bytes.get(self)?);
-        let next_ty = self.vtable_map.ty(id)?.clone();
-        match next_ty.kind(Interner) {
+        let next_ty = self.vtable_map.ty(id)?;
+        let interner = DbInterner::new_with(self.db, None, None);
+        use rustc_type_ir::TyKind;
+        match next_ty.kind() {
             TyKind::FnDef(def, generic_args) => {
-                self.exec_fn_def(*def, generic_args, destination, args, locals, target_bb, span)
+                let def = match def {
+                    SolverDefId::FunctionId(id) => CallableDefId::FunctionId(id),
+                    SolverDefId::Ctor(Ctor::Struct(s)) => CallableDefId::StructId(s),
+                    SolverDefId::Ctor(Ctor::Enum(e)) => CallableDefId::EnumVariantId(e),
+                    _ => unreachable!(),
+                };
+                self.exec_fn_def(
+                    def,
+                    &convert_args_for_result(interner, generic_args.as_slice()),
+                    destination,
+                    args,
+                    locals,
+                    target_bb,
+                    span,
+                )
             }
-            TyKind::Closure(id, subst) => {
-                self.exec_closure(*id, bytes.slice(0..0), subst, destination, args, locals, span)
+            TyKind::Closure(id, generic_args) => {
+                let id = match id {
+                    SolverDefId::InternedClosureId(id) => id,
+                    _ => unreachable!(),
+                };
+                self.exec_closure(
+                    id.into(),
+                    bytes.slice(0..0),
+                    &convert_args_for_result(interner, generic_args.as_slice()),
+                    destination,
+                    args,
+                    locals,
+                    span,
+                )
             }
             _ => Err(MirEvalError::InternalError("function pointer to non function".into())),
         }
@@ -2469,7 +2549,7 @@ impl Evaluator<'_> {
 
     fn exec_fn_def(
         &mut self,
-        def: FnDefId,
+        def: CallableDefId,
         generic_args: &Substitution,
         destination: Interval,
         args: &[IntervalAndTy],
@@ -2477,7 +2557,6 @@ impl Evaluator<'_> {
         target_bb: Option<BasicBlockId>,
         span: MirSpan,
     ) -> Result<Option<StackFrame>> {
-        let def: CallableDefId = from_chalk(self.db, def);
         let generic_args = generic_args.clone();
         match def {
             CallableDefId::FunctionId(def) => {
@@ -2574,6 +2653,7 @@ impl Evaluator<'_> {
         target_bb: Option<BasicBlockId>,
         span: MirSpan,
     ) -> Result<Option<StackFrame>> {
+        let interner = DbInterner::new_with(self.db, None, None);
         if self.detect_and_exec_special_function(
             def,
             args,
@@ -2600,6 +2680,7 @@ impl Evaluator<'_> {
                     .vtable_map
                     .ty_of_bytes(&first_arg[self.ptr_size()..self.ptr_size() * 2])?;
                 let mut args_for_target = args.to_vec();
+                let ty = convert_ty_for_result(interner, ty);
                 args_for_target[0] = IntervalAndTy {
                     interval: args_for_target[0].interval.slice(0..self.ptr_size()),
                     ty: ty.clone(),
@@ -2672,6 +2753,7 @@ impl Evaluator<'_> {
         target_bb: Option<BasicBlockId>,
         span: MirSpan,
     ) -> Result<Option<StackFrame>> {
+        let interner = DbInterner::new_with(self.db, None, None);
         let func = args
             .first()
             .ok_or_else(|| MirEvalError::InternalError("fn trait with no arg".into()))?;
@@ -2683,15 +2765,21 @@ impl Evaluator<'_> {
                 let id =
                     from_bytes!(usize, &func_data.get(self)?[self.ptr_size()..self.ptr_size() * 2]);
                 func_data = func_data.slice(0..self.ptr_size());
-                func_ty = self.vtable_map.ty(id)?.clone();
+                func_ty = convert_ty_for_result(interner, self.vtable_map.ty(id)?);
             }
             let size = self.size_of_sized(&func_ty, locals, "self type of fn trait")?;
             func_data = Interval { addr: Address::from_bytes(func_data.get(self)?)?, size };
         }
         match &func_ty.kind(Interner) {
-            TyKind::FnDef(def, subst) => {
-                self.exec_fn_def(*def, subst, destination, &args[1..], locals, target_bb, span)
-            }
+            TyKind::FnDef(def, subst) => self.exec_fn_def(
+                CallableDefId::from_chalk(self.db, *def),
+                subst,
+                destination,
+                &args[1..],
+                locals,
+                target_bb,
+                span,
+            ),
             TyKind::Function(_) => {
                 self.exec_fn_pointer(func_data, destination, &args[1..], locals, target_bb, span)
             }
@@ -2714,7 +2802,7 @@ impl Evaluator<'_> {
                         Substitution::from_iter(Interner, args.iter().map(|it| it.ty.clone())),
                     )
                     .intern(Interner);
-                    let layout = self.layout(&ty)?;
+                    let layout = self.layout(ty.to_nextsolver(interner))?;
                     let result = self.construct_with_layout(
                         layout.size.bytes_usize(),
                         &layout,
@@ -2901,6 +2989,7 @@ pub fn render_const_using_debug_impl(
     owner: DefWithBodyId,
     c: &Const,
 ) -> Result<String> {
+    let interner = DbInterner::new_with(db, None, None);
     let mut evaluator = Evaluator::new(db, owner, false, None)?;
     let locals = &Locals {
         ptr: ArenaMap::new(),
@@ -2933,7 +3022,8 @@ pub fn render_const_using_debug_impl(
         CallableDefId::FunctionId(debug_fmt_fn).to_chalk(db),
         Substitution::from1(Interner, c.data(Interner).ty.clone()),
     )
-    .intern(Interner));
+    .intern(Interner)
+    .to_nextsolver(interner));
     evaluator.write_memory(a2.offset(evaluator.ptr_size()), &debug_fmt_fn_ptr.to_le_bytes())?;
     // a3 = ::core::fmt::Arguments::new_v1(a1, a2)
     // FIXME: similarly, we should call function here, not directly working with memory.
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs
index bb4c963a8ae15..e27d334d2a991 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs
@@ -23,6 +23,10 @@ use crate::{
         LangItem, Layout, Locals, Lookup, MirEvalError, MirSpan, Mutability, Result, Substitution,
         Ty, TyBuilder, TyExt, pad16,
     },
+    next_solver::{
+        DbInterner,
+        mapping::{ChalkToNextSolver, convert_ty_for_result},
+    },
 };
 
 mod simd;
@@ -171,6 +175,7 @@ impl Evaluator<'_> {
         destination: Interval,
         span: MirSpan,
     ) -> Result<()> {
+        let interner = DbInterner::new_with(self.db, None, None);
         match self_ty.kind(Interner) {
             TyKind::Function(_) => {
                 let [arg] = args else {
@@ -188,7 +193,7 @@ impl Evaluator<'_> {
                 let InternedClosure(closure_owner, _) = self.db.lookup_intern_closure((*id).into());
                 let infer = self.db.infer(closure_owner);
                 let (captures, _) = infer.closure_info(id);
-                let layout = self.layout(&self_ty)?;
+                let layout = self.layout(self_ty.to_nextsolver(interner))?;
                 let ty_iter = captures.iter().map(|c| c.ty(subst));
                 self.exec_clone_for_fields(ty_iter, layout, addr, def, locals, destination, span)?;
             }
@@ -197,7 +202,7 @@ impl Evaluator<'_> {
                     not_supported!("wrong arg count for clone");
                 };
                 let addr = Address::from_bytes(arg.get(self)?)?;
-                let layout = self.layout(&self_ty)?;
+                let layout = self.layout(self_ty.to_nextsolver(interner))?;
                 let ty_iter = subst.iter(Interner).map(|ga| ga.assert_ty_ref(Interner).clone());
                 self.exec_clone_for_fields(ty_iter, layout, addr, def, locals, destination, span)?;
             }
@@ -226,8 +231,9 @@ impl Evaluator<'_> {
         destination: Interval,
         span: MirSpan,
     ) -> Result<()> {
+        let interner = DbInterner::new_with(self.db, None, None);
         for (i, ty) in ty_iter.enumerate() {
-            let size = self.layout(&ty)?.size.bytes_usize();
+            let size = self.layout(ty.to_nextsolver(interner))?.size.bytes_usize();
             let tmp = self.heap_allocate(self.ptr_size(), self.ptr_size())?;
             let arg = IntervalAndTy {
                 interval: Interval { addr: tmp, size: self.ptr_size() },
@@ -592,6 +598,7 @@ impl Evaluator<'_> {
         span: MirSpan,
         needs_override: bool,
     ) -> Result<bool> {
+        let interner = DbInterner::new_with(self.db, None, None);
         if let Some(name) = name.strip_prefix("atomic_") {
             return self
                 .exec_atomic_intrinsic(name, args, generic_args, destination, locals, span)
@@ -769,7 +776,7 @@ impl Evaluator<'_> {
                         "align_of generic arg is not provided".into(),
                     ));
                 };
-                let align = self.layout(ty)?.align.abi.bytes();
+                let align = self.layout(ty.to_nextsolver(interner))?.align.abi.bytes();
                 destination.write_from_bytes(self, &align.to_le_bytes()[0..destination.size])
             }
             "size_of_val" => {
@@ -1025,7 +1032,7 @@ impl Evaluator<'_> {
                 let is_overflow = u128overflow
                     || ans.to_le_bytes()[op_size..].iter().any(|&it| it != 0 && it != 255);
                 let is_overflow = vec![u8::from(is_overflow)];
-                let layout = self.layout(&result_ty)?;
+                let layout = self.layout(result_ty.to_nextsolver(interner))?;
                 let result = self.construct_with_layout(
                     layout.size.bytes_usize(),
                     &layout,
@@ -1249,7 +1256,7 @@ impl Evaluator<'_> {
                         "const_eval_select arg[0] is not a tuple".into(),
                     ));
                 };
-                let layout = self.layout(&tuple.ty)?;
+                let layout = self.layout(tuple.ty.to_nextsolver(interner))?;
                 for (i, field) in fields.iter(Interner).enumerate() {
                     let field = field.assert_ty_ref(Interner).clone();
                     let offset = layout.fields.offset(i).bytes_usize();
@@ -1408,6 +1415,7 @@ impl Evaluator<'_> {
         metadata: Interval,
         locals: &Locals,
     ) -> Result<(usize, usize)> {
+        let interner = DbInterner::new_with(self.db, None, None);
         Ok(match ty.kind(Interner) {
             TyKind::Str => (from_bytes!(usize, metadata.get(self)?), 1),
             TyKind::Slice(inner) => {
@@ -1416,7 +1424,7 @@ impl Evaluator<'_> {
                 (size * len, align)
             }
             TyKind::Dyn(_) => self.size_align_of_sized(
-                self.vtable_map.ty_of_bytes(metadata.get(self)?)?,
+                &convert_ty_for_result(interner, self.vtable_map.ty_of_bytes(metadata.get(self)?)?),
                 locals,
                 "dyn concrete type",
             )?,
@@ -1463,6 +1471,7 @@ impl Evaluator<'_> {
         locals: &Locals,
         _span: MirSpan,
     ) -> Result<()> {
+        let interner = DbInterner::new_with(self.db, None, None);
         // We are a single threaded runtime with no UB checking and no optimization, so
         // we can implement atomic intrinsics as normal functions.
 
@@ -1560,7 +1569,7 @@ impl Evaluator<'_> {
                 Substitution::from_iter(Interner, [ty.clone(), TyBuilder::bool()]),
             )
             .intern(Interner);
-            let layout = self.layout(&result_ty)?;
+            let layout = self.layout(result_ty.to_nextsolver(interner))?;
             let result = self.construct_with_layout(
                 layout.size.bytes_usize(),
                 &layout,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/tests.rs
index eb5af58f2ea18..5a56d99fbaa29 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/tests.rs
@@ -37,7 +37,7 @@ fn eval_main(db: &TestDB, file_id: EditionedFileId) -> Result<(String, String),
         )
         .map_err(|e| MirEvalError::MirLowerError(func_id, e))?;
 
-    let (result, output) = interpret_mir(db, body, false, None)?;
+    let (result, output) = salsa::attach(db, || interpret_mir(db, body, false, None))?;
     result?;
     Ok((output.stdout().into_owned(), output.stderr().into_owned()))
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs
index 5698ff290f748..ce581cfad4b26 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs
@@ -103,7 +103,7 @@ pub struct ValueConst<'db> {
 }
 
 impl<'db> ValueConst<'db> {
-    pub fn new(ty: Ty<'db>, bytes: ConstBytes) -> Self {
+    pub fn new(ty: Ty<'db>, bytes: ConstBytes<'db>) -> Self {
         let value = Valtree::new(bytes);
         ValueConst { ty, value }
     }
@@ -141,9 +141,9 @@ impl<'db> rustc_type_ir::TypeFoldable<DbInterner<'db>> for ValueConst<'db> {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ConstBytes(pub Box<[u8]>, pub MemoryMap);
+pub struct ConstBytes<'db>(pub Box<[u8]>, pub MemoryMap<'db>);
 
-impl Hash for ConstBytes {
+impl Hash for ConstBytes<'_> {
     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
         self.0.hash(state)
     }
@@ -152,11 +152,11 @@ impl Hash for ConstBytes {
 #[salsa::interned(constructor = new_, debug)]
 pub struct Valtree<'db> {
     #[returns(ref)]
-    bytes_: ConstBytes,
+    bytes_: ConstBytes<'db>,
 }
 
 impl<'db> Valtree<'db> {
-    pub fn new(bytes: ConstBytes) -> Self {
+    pub fn new(bytes: ConstBytes<'db>) -> Self {
         salsa::with_attached_database(|db| unsafe {
             // SAFETY: ¯\_(ツ)_/¯
             std::mem::transmute(Valtree::new_(db, bytes))
@@ -164,7 +164,7 @@ impl<'db> Valtree<'db> {
         .unwrap()
     }
 
-    pub fn inner(&self) -> &ConstBytes {
+    pub fn inner(&self) -> &ConstBytes<'db> {
         salsa::with_attached_database(|db| {
             let inner = self.bytes_(db);
             // SAFETY: The caller already has access to a `Valtree<'db>`, so borrowchecking will
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
index b50fccb832625..5fefb04a5e768 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
@@ -21,7 +21,7 @@ use rustc_type_ir::{
 use salsa::plumbing::AsId;
 
 use crate::{
-    ConcreteConst, ConstScalar, ImplTraitId, Interner,
+    ConcreteConst, ConstScalar, ImplTraitId, Interner, MemoryMap,
     db::{
         HirDatabase, InternedClosureId, InternedCoroutineId, InternedOpaqueTyId,
         InternedTypeOrConstParamId,
@@ -1328,7 +1328,10 @@ pub fn convert_const_for_result<'db>(
         rustc_type_ir::ConstKind::Value(value_const) => {
             let bytes = value_const.value.inner();
             let value = chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst {
-                interned: ConstScalar::Bytes(bytes.0.clone(), bytes.1.clone()),
+                // SAFETY: we will never actually use this without a database
+                interned: ConstScalar::Bytes(bytes.0.clone(), unsafe {
+                    std::mem::transmute::<MemoryMap<'db>, MemoryMap<'static>>(bytes.1.clone())
+                }),
             });
             return chalk_ir::ConstData {
                 ty: convert_ty_for_result(interner, value_const.ty),

From 73a5134722d362299bdecbd8418b4728f918a23e Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Mon, 11 Aug 2025 02:34:53 +0000
Subject: [PATCH 0102/1889] Change direct_super_traits to use
 generic_predicates_for_param_ns

---
 .../rust-analyzer/crates/hir-ty/src/utils.rs  | 43 +++++++++++++------
 src/tools/rust-analyzer/crates/hir/src/lib.rs | 16 ++++---
 .../rust-analyzer/crates/ide/src/hover.rs     | 12 +++---
 src/tools/rust-analyzer/crates/ide/src/lib.rs |  4 +-
 4 files changed, 50 insertions(+), 25 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/utils.rs b/src/tools/rust-analyzer/crates/hir-ty/src/utils.rs
index 209ec7926e825..092d4e3a8d9e9 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/utils.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/utils.rs
@@ -4,10 +4,7 @@
 use std::{cell::LazyCell, iter};
 
 use base_db::Crate;
-use chalk_ir::{
-    DebruijnIndex,
-    fold::{FallibleTypeFolder, Shift},
-};
+use chalk_ir::{DebruijnIndex, fold::FallibleTypeFolder};
 use hir_def::{
     EnumId, EnumVariantId, FunctionId, Lookup, TraitId, TypeAliasId, TypeOrConstParamId,
     db::DefDatabase,
@@ -20,6 +17,7 @@ use hir_expand::name::Name;
 use intern::sym;
 use rustc_abi::TargetDataLayout;
 use rustc_hash::FxHashSet;
+use rustc_type_ir::inherent::{IntoKind, SliceLike};
 use smallvec::{SmallVec, smallvec};
 use span::Edition;
 use stdx::never;
@@ -31,6 +29,11 @@ use crate::{
     db::HirDatabase,
     layout::{Layout, TagEncoding},
     mir::pad16,
+    next_solver::{
+        DbInterner,
+        mapping::{ChalkToNextSolver, convert_args_for_result},
+    },
+    to_chalk_trait_id,
 };
 
 pub(crate) fn fn_traits(db: &dyn DefDatabase, krate: Crate) -> impl Iterator<Item = TraitId> + '_ {
@@ -191,25 +194,37 @@ fn direct_super_traits_cb(db: &dyn DefDatabase, trait_: TraitId, cb: impl FnMut(
 }
 
 fn direct_super_trait_refs(db: &dyn HirDatabase, trait_ref: &TraitRef, cb: impl FnMut(TraitRef)) {
+    let interner = DbInterner::new_with(db, None, None);
     let generic_params = db.generic_params(trait_ref.hir_trait_id().into());
     let trait_self = match generic_params.trait_self_param() {
         Some(p) => TypeOrConstParamId { parent: trait_ref.hir_trait_id().into(), local_id: p },
         None => return,
     };
-    db.generic_predicates_for_param(trait_self.parent, trait_self, None)
+    let trait_ref_args: crate::next_solver::GenericArgs<'_> =
+        trait_ref.substitution.to_nextsolver(interner);
+    db.generic_predicates_for_param_ns(trait_self.parent, trait_self, None)
         .iter()
         .filter_map(|pred| {
-            pred.as_ref().filter_map(|pred| match pred.skip_binders() {
-                // FIXME: how to correctly handle higher-ranked bounds here?
-                WhereClause::Implemented(tr) => Some(
-                    tr.clone()
-                        .shifted_out_to(Interner, DebruijnIndex::ONE)
-                        .expect("FIXME unexpected higher-ranked trait bound"),
-                ),
+            let pred = pred.kind();
+            // FIXME: how to correctly handle higher-ranked bounds here?
+            let pred = pred.no_bound_vars().expect("FIXME unexpected higher-ranked trait bound");
+            match pred {
+                rustc_type_ir::ClauseKind::Trait(t) => {
+                    let t =
+                        rustc_type_ir::EarlyBinder::bind(t).instantiate(interner, trait_ref_args);
+                    let trait_id = match t.def_id() {
+                        crate::next_solver::SolverDefId::TraitId(id) => to_chalk_trait_id(id),
+                        _ => unreachable!(),
+                    };
+
+                    let substitution =
+                        convert_args_for_result(interner, t.trait_ref.args.as_slice());
+                    let tr = chalk_ir::TraitRef { trait_id, substitution };
+                    Some(tr)
+                }
                 _ => None,
-            })
+            }
         })
-        .map(|pred| pred.substitute(Interner, &trait_ref.substitution))
         .for_each(cb);
 }
 
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index 9accb33368980..18c3ea05614a8 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -86,7 +86,8 @@ use hir_ty::{
     method_resolution,
     mir::{MutBorrowKind, interpret_mir},
     next_solver::{
-        DbInterner, GenericArgs, SolverDefId, infer::InferCtxt, mapping::ChalkToNextSolver,
+        ClauseKind, DbInterner, GenericArgs, SolverDefId, infer::InferCtxt,
+        mapping::ChalkToNextSolver,
     },
     primitive::UintTy,
     traits::FnTrait,
@@ -114,6 +115,7 @@ pub use crate::{
         VisibleTraits,
     },
 };
+use rustc_type_ir::inherent::IntoKind;
 
 // Be careful with these re-exports.
 //
@@ -4245,11 +4247,15 @@ impl TypeParam {
     /// parameter, not additional bounds that might be added e.g. by a method if
     /// the parameter comes from an impl!
     pub fn trait_bounds(self, db: &dyn HirDatabase) -> Vec<Trait> {
-        db.generic_predicates_for_param(self.id.parent(), self.id.into(), None)
+        db.generic_predicates_for_param_ns(self.id.parent(), self.id.into(), None)
             .iter()
-            .filter_map(|pred| match &pred.skip_binders().skip_binders() {
-                hir_ty::WhereClause::Implemented(trait_ref) => {
-                    Some(Trait::from(trait_ref.hir_trait_id()))
+            .filter_map(|pred| match &pred.kind().skip_binder() {
+                ClauseKind::Trait(trait_ref) => {
+                    let trait_ = match trait_ref.def_id() {
+                        SolverDefId::TraitId(t) => t,
+                        _ => unreachable!(),
+                    };
+                    Some(Trait::from(trait_))
                 }
                 _ => None,
             })
diff --git a/src/tools/rust-analyzer/crates/ide/src/hover.rs b/src/tools/rust-analyzer/crates/ide/src/hover.rs
index a48fe43e80803..fc45dc3faf40f 100644
--- a/src/tools/rust-analyzer/crates/ide/src/hover.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/hover.rs
@@ -581,11 +581,13 @@ fn goto_type_action_for_def(
         });
     }
 
-    if let Ok(generic_def) = GenericDef::try_from(def) {
-        generic_def.type_or_const_params(db).into_iter().for_each(|it| {
-            walk_and_push_ty(db, &it.ty(db), &mut push_new_def);
-        });
-    }
+    salsa::attach(db, || {
+        if let Ok(generic_def) = GenericDef::try_from(def) {
+            generic_def.type_or_const_params(db).into_iter().for_each(|it| {
+                walk_and_push_ty(db, &it.ty(db), &mut push_new_def);
+            });
+        }
+    });
 
     let ty = match def {
         Definition::Local(it) => Some(it.ty(db)),
diff --git a/src/tools/rust-analyzer/crates/ide/src/lib.rs b/src/tools/rust-analyzer/crates/ide/src/lib.rs
index 1c66473bf9874..2afdf18b83685 100644
--- a/src/tools/rust-analyzer/crates/ide/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/lib.rs
@@ -674,7 +674,9 @@ impl Analysis {
         position: FilePosition,
     ) -> Cancellable<Option<Vec<HighlightedRange>>> {
         self.with_db(|db| {
-            highlight_related::highlight_related(&Semantics::new(db), config, position)
+            salsa::attach(db, || {
+                highlight_related::highlight_related(&Semantics::new(db), config, position)
+            })
         })
     }
 

From 418f419d60240e7ed24953cab9089027fa666be4 Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Mon, 11 Aug 2025 04:12:43 +0000
Subject: [PATCH 0103/1889] Cleanup assoc_type_shorthand_candidates

---
 .../rust-analyzer/crates/hir/src/semantics.rs | 21 ++++++++++---------
 .../ide-completion/src/completions/expr.rs    |  3 +--
 .../ide-completion/src/completions/type.rs    |  3 +--
 3 files changed, 13 insertions(+), 14 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir/src/semantics.rs b/src/tools/rust-analyzer/crates/hir/src/semantics.rs
index b43165fd8ad70..6af0c2c3c56fb 100644
--- a/src/tools/rust-analyzer/crates/hir/src/semantics.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/semantics.rs
@@ -2288,18 +2288,19 @@ impl<'db> SemanticsScope<'db> {
 
     /// Iterates over associated types that may be specified after the given path (using
     /// `Ty::Assoc` syntax).
-    pub fn assoc_type_shorthand_candidates<R>(
+    pub fn assoc_type_shorthand_candidates(
         &self,
         resolution: &PathResolution,
-        mut cb: impl FnMut(&Name, TypeAlias) -> Option<R>,
-    ) -> Option<R> {
-        let def = self.resolver.generic_def()?;
-        hir_ty::associated_type_shorthand_candidates(
-            self.db,
-            def,
-            resolution.in_type_ns()?,
-            |name, id| cb(name, id.into()),
-        )
+        mut cb: impl FnMut(TypeAlias),
+    ) {
+        let (Some(def), Some(resolution)) = (self.resolver.generic_def(), resolution.in_type_ns())
+        else {
+            return;
+        };
+        hir_ty::associated_type_shorthand_candidates(self.db, def, resolution, |_, id| {
+            cb(id.into());
+            None::<()>
+        });
     }
 
     pub fn generic_def(&self) -> Option<crate::GenericDef> {
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/expr.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/expr.rs
index a84927f6e2c0f..1972f166134a4 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/expr.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/expr.rs
@@ -140,9 +140,8 @@ pub(crate) fn complete_expr_path(
         Qualified::With { resolution: None, .. } => {}
         Qualified::With { resolution: Some(resolution), .. } => {
             // Add associated types on type parameters and `Self`.
-            ctx.scope.assoc_type_shorthand_candidates(resolution, |_, alias| {
+            ctx.scope.assoc_type_shorthand_candidates(resolution, |alias| {
                 acc.add_type_alias(ctx, alias);
-                None::<()>
             });
             match resolution {
                 hir::PathResolution::Def(hir::ModuleDef::Module(module)) => {
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/type.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/type.rs
index fc27cbd65a1ee..3112462cda4e8 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/type.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/type.rs
@@ -77,9 +77,8 @@ pub(crate) fn complete_type_path(
         Qualified::With { resolution: None, .. } => {}
         Qualified::With { resolution: Some(resolution), .. } => {
             // Add associated types on type parameters and `Self`.
-            ctx.scope.assoc_type_shorthand_candidates(resolution, |_, alias| {
+            ctx.scope.assoc_type_shorthand_candidates(resolution, |alias| {
                 acc.add_type_alias(ctx, alias);
-                None::<()>
             });
 
             match resolution {

From 064f1c7c8321547e114d576f07ecdf0b1bee97e1 Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Mon, 11 Aug 2025 05:19:44 +0000
Subject: [PATCH 0104/1889] Switch associated_type_shorthand_candidates to
 lower_nextsolver

---
 .../crates/hir-ty/src/dyn_compatibility.rs    |   4 +-
 .../rust-analyzer/crates/hir-ty/src/lib.rs    |   3 +-
 .../rust-analyzer/crates/hir-ty/src/lower.rs  |   9 -
 .../crates/hir-ty/src/lower_nextsolver.rs     | 133 +++++++++++++-
 .../hir-ty/src/lower_nextsolver/path.rs       | 163 ++++--------------
 .../hir-ty/src/next_solver/generic_arg.rs     |  19 +-
 .../rust-analyzer/crates/hir/src/semantics.rs |   2 +-
 .../crates/hir/src/source_analyzer.rs         |  17 +-
 src/tools/rust-analyzer/crates/ide/src/lib.rs |   6 +-
 9 files changed, 197 insertions(+), 159 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
index 8bd555f5c08f3..48c0c81b47815 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
@@ -564,7 +564,7 @@ fn receiver_is_dispatchable<'db>(
         // U: Trait<Arg1, ..., ArgN>
         let trait_def_id = SolverDefId::TraitId(trait_);
         let args = GenericArgs::for_item(interner, trait_def_id, |name, index, kind, _| {
-            if index == 0 { unsized_self_ty.into() } else { mk_param(index, name, kind) }
+            if index == 0 { unsized_self_ty.into() } else { mk_param(interner, index, name, kind) }
         });
         let trait_predicate =
             crate::next_solver::TraitRef::new_from_args(interner, trait_def_id, args);
@@ -611,7 +611,7 @@ fn receiver_for_self_ty<'db>(
         interner,
         SolverDefId::FunctionId(func),
         |name, index, kind, _| {
-            if index == 0 { self_ty.into() } else { mk_param(index, name, kind) }
+            if index == 0 { self_ty.into() } else { mk_param(interner, index, name, kind) }
         },
     );
 
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 8ce0aeb5532ad..2f8eb627462b7 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
@@ -118,8 +118,9 @@ pub use infer::{
 pub use interner::Interner;
 pub use lower::{
     ImplTraitLoweringMode, LifetimeElisionKind, ParamLoweringMode, TyDefId, TyLoweringContext,
-    ValueTyDefId, associated_type_shorthand_candidates, diagnostics::*,
+    ValueTyDefId, diagnostics::*,
 };
+pub use lower_nextsolver::associated_type_shorthand_candidates;
 pub use mapping::{
     ToChalk, from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id, from_placeholder_idx,
     lt_from_placeholder_idx, lt_to_placeholder_idx, to_assoc_type_id, to_chalk_trait_id,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
index 065d2ea084070..098c62ba97a29 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
@@ -804,15 +804,6 @@ pub(crate) fn callable_item_signature_query(db: &dyn HirDatabase, def: CallableD
     }
 }
 
-pub fn associated_type_shorthand_candidates<R>(
-    db: &dyn HirDatabase,
-    def: GenericDefId,
-    res: TypeNs,
-    mut cb: impl FnMut(&Name, TypeAliasId) -> Option<R>,
-) -> Option<R> {
-    named_associated_type_shorthand_candidates(db, def, res, None, |name, _, id| cb(name, id))
-}
-
 fn named_associated_type_shorthand_candidates<R>(
     db: &dyn HirDatabase,
     // If the type parameter is defined in an impl and we're in a method, there
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
index 24bda43ca634f..15c675be58199 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
@@ -12,14 +12,14 @@ pub(crate) mod path;
 use std::{
     cell::OnceCell,
     iter, mem,
-    ops::{self, Not as _},
+    ops::{self, Deref, Not as _},
 };
 
 use base_db::Crate;
 use either::Either;
 use hir_def::{
     AdtId, AssocItemId, CallableDefId, ConstParamId, EnumVariantId, FunctionId, GenericDefId,
-    GenericParamId, ImplId, ItemContainerId, LocalFieldId, Lookup, StructId, TypeAliasId,
+    GenericParamId, ImplId, ItemContainerId, LocalFieldId, Lookup, StructId, TraitId, TypeAliasId,
     TypeOrConstParamId, VariantId,
     expr_store::{
         ExpressionStore,
@@ -49,6 +49,7 @@ use rustc_type_ir::{
     inherent::{GenericArg as _, GenericArgs as _, IntoKind as _, Region as _, SliceLike, Ty as _},
 };
 use salsa::plumbing::AsId;
+use smallvec::{SmallVec, smallvec};
 use stdx::never;
 use triomphe::Arc;
 
@@ -1607,3 +1608,131 @@ pub(crate) fn associated_type_by_name_including_super_traits<'db>(
         Some((t.skip_binder(), assoc_type))
     })
 }
+
+pub fn associated_type_shorthand_candidates(
+    db: &dyn HirDatabase,
+    def: GenericDefId,
+    res: TypeNs,
+    mut cb: impl FnMut(&Name, TypeAliasId) -> bool,
+) -> Option<TypeAliasId> {
+    let interner = DbInterner::new_with(db, None, None);
+    named_associated_type_shorthand_candidates(interner, def, res, None, |name, _, id| {
+        cb(name, id).then_some(id)
+    })
+}
+
+#[tracing::instrument(skip(interner, check_alias))]
+fn named_associated_type_shorthand_candidates<'db, R>(
+    interner: DbInterner<'db>,
+    // If the type parameter is defined in an impl and we're in a method, there
+    // might be additional where clauses to consider
+    def: GenericDefId,
+    res: TypeNs,
+    assoc_name: Option<Name>,
+    mut check_alias: impl FnMut(&Name, TraitRef<'db>, TypeAliasId) -> Option<R>,
+) -> Option<R> {
+    let db = interner.db;
+    let mut search = |t: TraitRef<'db>| -> Option<R> {
+        let trait_id = match t.def_id {
+            SolverDefId::TraitId(id) => id,
+            _ => unreachable!(),
+        };
+        let mut checked_traits = FxHashSet::default();
+        let mut check_trait = |trait_id: TraitId| {
+            let name = &db.trait_signature(trait_id).name;
+            tracing::debug!(?trait_id, ?name);
+            if !checked_traits.insert(trait_id) {
+                return None;
+            }
+            let data = trait_id.trait_items(db);
+
+            tracing::debug!(?data.items);
+            for (name, assoc_id) in &data.items {
+                if let &AssocItemId::TypeAliasId(alias) = assoc_id
+                    && let Some(ty) = check_alias(name, t, alias)
+                {
+                    return Some(ty);
+                }
+            }
+            None
+        };
+        let mut stack: SmallVec<[_; 4]> = smallvec![trait_id];
+        while let Some(trait_def_id) = stack.pop() {
+            if let Some(alias) = check_trait(trait_def_id) {
+                return Some(alias);
+            }
+            for pred in generic_predicates_filtered_by(
+                db,
+                GenericDefId::TraitId(trait_def_id),
+                PredicateFilter::SelfTrait,
+                |pred| pred == GenericDefId::TraitId(trait_def_id),
+            )
+            .0
+            .deref()
+            {
+                tracing::debug!(?pred);
+                let trait_id = match pred.kind().skip_binder() {
+                    rustc_type_ir::ClauseKind::Trait(pred) => pred.def_id(),
+                    _ => continue,
+                };
+                let trait_id = match trait_id {
+                    SolverDefId::TraitId(trait_id) => trait_id,
+                    _ => continue,
+                };
+                stack.push(trait_id);
+            }
+            tracing::debug!(?stack);
+        }
+
+        None
+    };
+
+    match res {
+        TypeNs::SelfType(impl_id) => {
+            let trait_ref = db.impl_trait_ns(impl_id)?;
+
+            // we're _in_ the impl -- the binders get added back later. Correct,
+            // but it would be nice to make this more explicit
+            search(trait_ref.skip_binder())
+        }
+        TypeNs::GenericParam(param_id) => {
+            // Handle `Self::Type` referring to own associated type in trait definitions
+            // This *must* be done first to avoid cycles with
+            // `generic_predicates_for_param`, but not sure that it's sufficient,
+            // see FIXME in `search`.
+            if let GenericDefId::TraitId(trait_id) = param_id.parent() {
+                let trait_name = &db.trait_signature(trait_id).name;
+                tracing::debug!(?trait_name);
+                let trait_generics = generics(db, trait_id.into());
+                tracing::debug!(?trait_generics);
+                if trait_generics[param_id.local_id()].is_trait_self() {
+                    let args = crate::next_solver::GenericArgs::identity_for_item(
+                        interner,
+                        trait_id.into(),
+                    );
+                    let trait_ref = TraitRef::new_from_args(interner, trait_id.into(), args);
+                    tracing::debug!(?args, ?trait_ref);
+                    return search(trait_ref);
+                }
+            }
+
+            let predicates =
+                db.generic_predicates_for_param_ns(def, param_id.into(), assoc_name.clone());
+            predicates
+                .iter()
+                .find_map(|pred| match (*pred).kind().skip_binder() {
+                    rustc_type_ir::ClauseKind::Trait(trait_predicate) => Some(trait_predicate),
+                    _ => None,
+                })
+                .and_then(|trait_predicate| {
+                    let trait_ref = trait_predicate.trait_ref;
+                    assert!(
+                        !trait_ref.has_escaping_bound_vars(),
+                        "FIXME unexpected higher-ranked trait bound"
+                    );
+                    search(trait_ref)
+                })
+        }
+        _ => None,
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver/path.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver/path.rs
index df67b2c59b512..e3efb38306408 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver/path.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver/path.rs
@@ -4,7 +4,7 @@ use std::ops::Deref;
 
 use either::Either;
 use hir_def::{
-    AssocItemId, GenericDefId, GenericParamId, Lookup, TraitId,
+    AssocItemId, GenericDefId, GenericParamId, Lookup, TraitId, TypeAliasId,
     builtin_type::BuiltinType,
     expr_store::{
         ExpressionStore, HygieneId,
@@ -17,6 +17,7 @@ use hir_def::{
     signatures::TraitFlags,
     type_ref::{TypeRef, TypeRefId},
 };
+use hir_expand::name::Name;
 use intern::sym;
 use rustc_hash::FxHashSet;
 use rustc_type_ir::{
@@ -33,7 +34,10 @@ use crate::{
     db::HirDatabase,
     generics::{Generics, generics},
     lower::PathDiagnosticCallbackData,
-    lower_nextsolver::{LifetimeElisionKind, PredicateFilter, generic_predicates_filtered_by},
+    lower_nextsolver::{
+        LifetimeElisionKind, PredicateFilter, generic_predicates_filtered_by,
+        named_associated_type_shorthand_candidates,
+    },
     next_solver::{
         AdtDef, Binder, Clause, Const, DbInterner, ErrorGuaranteed, Predicate, ProjectionPredicate,
         Region, SolverDefId, TraitRef, Ty,
@@ -501,137 +505,40 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
         let Some(res) = res else {
             return Ty::new_error(self.ctx.interner, ErrorGuaranteed);
         };
-        let segment = self.current_or_prev_segment;
-        let assoc_name = segment.name;
         let db = self.ctx.db;
         let def = self.ctx.def;
-        let mut search = |t: TraitRef<'db>| {
-            let trait_id = match t.def_id {
-                SolverDefId::TraitId(id) => id,
-                _ => unreachable!(),
-            };
-            let mut checked_traits = FxHashSet::default();
-            let mut check_trait = |trait_id: TraitId| {
-                let name = &db.trait_signature(trait_id).name;
-                tracing::debug!(?trait_id, ?name);
-                if !checked_traits.insert(trait_id) {
-                    return None;
-                }
-                let data = trait_id.trait_items(db);
-
-                tracing::debug!(?data.items);
-                for (name, assoc_id) in &data.items {
-                    if let &AssocItemId::TypeAliasId(alias) = assoc_id {
-                        if name != assoc_name {
-                            continue;
-                        }
-
-                        // FIXME: `substs_from_path_segment()` pushes `TyKind::Error` for every parent
-                        // generic params. It's inefficient to splice the `Substitution`s, so we may want
-                        // that method to optionally take parent `Substitution` as we already know them at
-                        // this point (`t.substitution`).
-                        let substs = self.substs_from_path_segment(alias.into(), false, None, true);
-
-                        let substs = crate::next_solver::GenericArgs::new_from_iter(
-                            interner,
-                            t.args.iter().chain(substs.iter().skip(t.args.len())),
-                        );
-
-                        return Some(Ty::new_alias(
-                            interner,
-                            AliasTyKind::Projection,
-                            AliasTy::new(interner, alias.into(), substs),
-                        ));
-                    }
-                }
-                None
-            };
-            let mut stack: SmallVec<[_; 4]> = smallvec![trait_id];
-            while let Some(trait_def_id) = stack.pop() {
-                if let Some(alias) = check_trait(trait_def_id) {
-                    return alias;
-                }
-                for pred in generic_predicates_filtered_by(
-                    db,
-                    GenericDefId::TraitId(trait_def_id),
-                    PredicateFilter::SelfTrait,
-                    |pred| pred == GenericDefId::TraitId(trait_def_id),
-                )
-                .0
-                .deref()
-                {
-                    tracing::debug!(?pred);
-                    let trait_id = match pred.kind().skip_binder() {
-                        rustc_type_ir::ClauseKind::Trait(pred) => pred.def_id(),
-                        _ => continue,
-                    };
-                    let trait_id = match trait_id {
-                        SolverDefId::TraitId(trait_id) => trait_id,
-                        _ => continue,
-                    };
-                    stack.push(trait_id);
-                }
-                tracing::debug!(?stack);
+        let segment = self.current_or_prev_segment;
+        let assoc_name = segment.name;
+        let mut check_alias = |name: &Name, t: TraitRef<'db>, associated_ty: TypeAliasId| {
+            if name != assoc_name {
+                return None;
             }
 
-            Ty::new_error(interner, ErrorGuaranteed)
+            // FIXME: `substs_from_path_segment()` pushes `TyKind::Error` for every parent
+            // generic params. It's inefficient to splice the `Substitution`s, so we may want
+            // that method to optionally take parent `Substitution` as we already know them at
+            // this point (`t.substitution`).
+            let substs = self.substs_from_path_segment(associated_ty.into(), false, None, true);
+
+            let substs = crate::next_solver::GenericArgs::new_from_iter(
+                interner,
+                t.args.iter().chain(substs.iter().skip(t.args.len())),
+            );
+
+            Some(Ty::new_alias(
+                interner,
+                AliasTyKind::Projection,
+                AliasTy::new(interner, associated_ty.into(), substs),
+            ))
         };
-
-        match res {
-            TypeNs::SelfType(impl_id) => {
-                let trait_ref = db.impl_trait_ns(impl_id);
-                let Some(trait_ref) = trait_ref else {
-                    return Ty::new_error(interner, ErrorGuaranteed);
-                };
-
-                // we're _in_ the impl -- the binders get added back later. Correct,
-                // but it would be nice to make this more explicit
-                search(trait_ref.skip_binder())
-            }
-            TypeNs::GenericParam(param_id) => {
-                // Handle `Self::Type` referring to own associated type in trait definitions
-                // This *must* be done first to avoid cycles with
-                // `generic_predicates_for_param`, but not sure that it's sufficient,
-                // see FIXME in `search`.
-                if let GenericDefId::TraitId(trait_id) = param_id.parent() {
-                    let trait_name = &db.trait_signature(trait_id).name;
-                    tracing::debug!(?trait_name);
-                    let trait_generics = generics(db, trait_id.into());
-                    tracing::debug!(?trait_generics);
-                    if trait_generics[param_id.local_id()].is_trait_self() {
-                        let args = crate::next_solver::GenericArgs::identity_for_item(
-                            interner,
-                            trait_id.into(),
-                        );
-                        let trait_ref = TraitRef::new_from_args(interner, trait_id.into(), args);
-                        tracing::debug!(?args, ?trait_ref);
-                        return search(trait_ref);
-                    }
-                }
-
-                let predicates = db.generic_predicates_for_param_ns(
-                    def,
-                    param_id.into(),
-                    Some(segment.name.clone()),
-                );
-                predicates
-                    .iter()
-                    .find_map(|pred| match (*pred).kind().skip_binder() {
-                        rustc_type_ir::ClauseKind::Trait(trait_predicate) => Some(trait_predicate),
-                        _ => None,
-                    })
-                    .map(|trait_predicate| {
-                        let trait_ref = trait_predicate.trait_ref;
-                        assert!(
-                            !trait_ref.has_escaping_bound_vars(),
-                            "FIXME unexpected higher-ranked trait bound"
-                        );
-                        search(trait_ref)
-                    })
-                    .unwrap_or_else(|| Ty::new_error(interner, ErrorGuaranteed))
-            }
-            _ => Ty::new_error(interner, ErrorGuaranteed),
-        }
+        named_associated_type_shorthand_candidates(
+            interner,
+            def,
+            res,
+            Some(assoc_name.clone()),
+            check_alias,
+        )
+        .unwrap_or_else(|| Ty::new_error(interner, ErrorGuaranteed))
     }
 
     fn lower_path_inner(&mut self, typeable: TyDefId, infer_args: bool) -> Ty<'db> {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generic_arg.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generic_arg.rs
index 85a79923a7295..046b4303c3261 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generic_arg.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generic_arg.rs
@@ -263,7 +263,9 @@ impl<'db> rustc_type_ir::inherent::GenericArgs<DbInterner<'db>> for GenericArgs<
         interner: DbInterner<'db>,
         def_id: <DbInterner<'db> as rustc_type_ir::Interner>::DefId,
     ) -> <DbInterner<'db> as rustc_type_ir::Interner>::GenericArgs {
-        Self::for_item(interner, def_id, |name, index, kind, _| mk_param(index, name, kind))
+        Self::for_item(interner, def_id, |name, index, kind, _| {
+            mk_param(interner, index, name, kind)
+        })
     }
 
     fn extend_with_error(
@@ -383,16 +385,19 @@ impl<'db> rustc_type_ir::inherent::GenericArgs<DbInterner<'db>> for GenericArgs<
     }
 }
 
-pub fn mk_param<'db>(index: u32, name: &Symbol, kind: GenericParamDefKind) -> GenericArg<'db> {
+pub fn mk_param<'db>(
+    interner: DbInterner<'db>,
+    index: u32,
+    name: &Symbol,
+    kind: GenericParamDefKind,
+) -> GenericArg<'db> {
     let name = name.clone();
     match kind {
         GenericParamDefKind::Lifetime => {
-            Region::new_early_param(DbInterner::conjure(), EarlyParamRegion { index }).into()
-        }
-        GenericParamDefKind::Type => Ty::new_param(DbInterner::conjure(), index, name).into(),
-        GenericParamDefKind::Const => {
-            Const::new_param(DbInterner::conjure(), ParamConst { index }).into()
+            Region::new_early_param(interner, EarlyParamRegion { index }).into()
         }
+        GenericParamDefKind::Type => Ty::new_param(interner, index, name).into(),
+        GenericParamDefKind::Const => Const::new_param(interner, ParamConst { index }).into(),
     }
 }
 
diff --git a/src/tools/rust-analyzer/crates/hir/src/semantics.rs b/src/tools/rust-analyzer/crates/hir/src/semantics.rs
index 6af0c2c3c56fb..fa239a28f7bcd 100644
--- a/src/tools/rust-analyzer/crates/hir/src/semantics.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/semantics.rs
@@ -2299,7 +2299,7 @@ impl<'db> SemanticsScope<'db> {
         };
         hir_ty::associated_type_shorthand_candidates(self.db, def, resolution, |_, id| {
             cb(id.into());
-            None::<()>
+            false
         });
     }
 
diff --git a/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs b/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
index 126392af4619a..e3070c5f74ce2 100644
--- a/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
@@ -14,6 +14,7 @@ use crate::{
     db::HirDatabase,
     semantics::{PathResolution, PathResolutionPerNs},
 };
+use base_db::salsa;
 use either::Either;
 use hir_def::{
     AdtId, AssocItemId, CallableDefId, ConstId, DefWithBodyId, FieldId, FunctionId, GenericDefId,
@@ -1593,12 +1594,14 @@ fn resolve_hir_path_(
             Some(unresolved) => resolver
                 .generic_def()
                 .and_then(|def| {
-                    hir_ty::associated_type_shorthand_candidates(
-                        db,
-                        def,
-                        res.in_type_ns()?,
-                        |name, id| (name == unresolved.name).then_some(id),
-                    )
+                    salsa::attach(db, || {
+                        hir_ty::associated_type_shorthand_candidates(
+                            db,
+                            def,
+                            res.in_type_ns()?,
+                            |name, _| name == unresolved.name,
+                        )
+                    })
                 })
                 .map(TypeAlias::from)
                 .map(Into::into)
@@ -1746,7 +1749,7 @@ fn resolve_hir_path_qualifier(
                         db,
                         def,
                         res.in_type_ns()?,
-                        |name, id| (name == unresolved.name).then_some(id),
+                        |name, _| name == unresolved.name,
                     )
                 })
                 .map(TypeAlias::from)
diff --git a/src/tools/rust-analyzer/crates/ide/src/lib.rs b/src/tools/rust-analyzer/crates/ide/src/lib.rs
index 2afdf18b83685..e491c9214b437 100644
--- a/src/tools/rust-analyzer/crates/ide/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/lib.rs
@@ -528,7 +528,9 @@ impl Analysis {
         let search_scope = AssertUnwindSafe(search_scope);
         self.with_db(|db| {
             let _ = &search_scope;
-            references::find_all_refs(&Semantics::new(db), position, search_scope.0)
+            salsa::attach(db, || {
+                references::find_all_refs(&Semantics::new(db), position, search_scope.0)
+            })
         })
     }
 
@@ -574,7 +576,7 @@ impl Analysis {
         &self,
         position: FilePosition,
     ) -> Cancellable<Option<RangeInfo<Vec<NavigationTarget>>>> {
-        self.with_db(|db| call_hierarchy::call_hierarchy(db, position))
+        self.with_db(|db| salsa::attach(db, || call_hierarchy::call_hierarchy(db, position)))
     }
 
     /// Computes incoming calls for the given file position.

From d10e5d10fe08b3b19e72891b6069c8eee0754e37 Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Tue, 12 Aug 2025 06:07:02 +0000
Subject: [PATCH 0105/1889] Convert more of dyn_compatibility to next-solver

---
 .../crates/hir-ty/src/dyn_compatibility.rs    | 187 ++++--------------
 .../crates/hir-ty/src/lower_nextsolver.rs     |  96 ++++++++-
 2 files changed, 130 insertions(+), 153 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
index 48c0c81b47815..54d78dea3d3b6 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
@@ -2,11 +2,7 @@
 
 use std::ops::ControlFlow;
 
-use chalk_ir::{
-    DebruijnIndex,
-    visit::{TypeSuperVisitable, TypeVisitable, TypeVisitor},
-};
-use chalk_solve::rust_ir::InlineBound;
+use chalk_ir::DebruijnIndex;
 use hir_def::{
     AssocItemId, ConstId, CrateRootModuleId, FunctionId, GenericDefId, HasModule, TraitId,
     TypeAliasId, lang_item::LangItem, signatures::TraitFlags,
@@ -21,14 +17,14 @@ use rustc_type_ir::{
 use smallvec::SmallVec;
 
 use crate::{
-    AliasEq, AliasTy, Binders, BoundVar, ImplTraitId, Interner, ProjectionTyExt, Ty, TyKind,
-    WhereClause, all_super_traits,
+    ImplTraitId, Interner, TyKind, WhereClause, all_super_traits,
     db::{HirDatabase, InternedOpaqueTyId},
-    from_assoc_type_id, from_chalk_trait_id,
+    from_chalk_trait_id,
     generics::trait_self_param_idx,
+    lower_nextsolver::associated_ty_item_bounds,
     next_solver::{
-        Clauses, DbInterner, GenericArgs, ParamEnv, SolverDefId, TraitPredicate, TypingMode,
-        infer::DbInternerInferExt, mk_param,
+        Clause, Clauses, DbInterner, GenericArgs, ParamEnv, SolverDefId, TraitPredicate,
+        TypingMode, infer::DbInternerInferExt, mk_param,
     },
     traits::next_trait_solve_in_ctxt,
     utils::elaborate_clause_supertraits,
@@ -165,7 +161,7 @@ pub fn generics_require_sized_self(db: &dyn HirDatabase, def: GenericDefId) -> b
 // but we don't have good way to render such locations.
 // So, just return single boolean value for existence of such `Self` reference
 fn predicates_reference_self(db: &dyn HirDatabase, trait_: TraitId) -> bool {
-    db.generic_predicates(trait_.into())
+    db.generic_predicates_ns(trait_.into())
         .iter()
         .any(|pred| predicate_references_self(db, trait_, pred, AllowSelfProjection::No))
 }
@@ -177,37 +173,18 @@ fn bounds_reference_self(db: &dyn HirDatabase, trait_: TraitId) -> bool {
         .items
         .iter()
         .filter_map(|(_, it)| match *it {
-            AssocItemId::TypeAliasId(id) => {
-                let assoc_ty_data = db.associated_ty_data(id);
-                Some(assoc_ty_data)
-            }
+            AssocItemId::TypeAliasId(id) => Some(associated_ty_item_bounds(db, id)),
             _ => None,
         })
-        .any(|assoc_ty_data| {
-            assoc_ty_data.binders.skip_binders().bounds.iter().any(|bound| {
-                let def = from_assoc_type_id(assoc_ty_data.id).into();
-                match bound.skip_binders() {
-                    InlineBound::TraitBound(it) => it.args_no_self.iter().any(|arg| {
-                        contains_illegal_self_type_reference(
-                            db,
-                            def,
-                            trait_,
-                            arg,
-                            DebruijnIndex::ONE,
-                            AllowSelfProjection::Yes,
-                        )
-                    }),
-                    InlineBound::AliasEqBound(it) => it.parameters.iter().any(|arg| {
-                        contains_illegal_self_type_reference(
-                            db,
-                            def,
-                            trait_,
-                            arg,
-                            DebruijnIndex::ONE,
-                            AllowSelfProjection::Yes,
-                        )
-                    }),
-                }
+        .any(|bounds| {
+            bounds.skip_binder().iter().any(|pred| match pred.skip_binder() {
+                rustc_type_ir::ExistentialPredicate::Trait(it) => it.args.iter().any(|arg| {
+                    contains_illegal_self_type_reference(db, trait_, &arg, AllowSelfProjection::Yes)
+                }),
+                rustc_type_ir::ExistentialPredicate::Projection(it) => it.args.iter().any(|arg| {
+                    contains_illegal_self_type_reference(db, trait_, &arg, AllowSelfProjection::Yes)
+                }),
+                rustc_type_ir::ExistentialPredicate::AutoTrait(_) => false,
             })
         })
 }
@@ -218,120 +195,26 @@ enum AllowSelfProjection {
     No,
 }
 
-fn predicate_references_self(
-    db: &dyn HirDatabase,
+fn predicate_references_self<'db>(
+    db: &'db dyn HirDatabase,
     trait_: TraitId,
-    predicate: &Binders<Binders<WhereClause>>,
+    predicate: &Clause<'db>,
     allow_self_projection: AllowSelfProjection,
 ) -> bool {
-    match predicate.skip_binders().skip_binders() {
-        WhereClause::Implemented(trait_ref) => {
-            trait_ref.substitution.iter(Interner).skip(1).any(|arg| {
-                contains_illegal_self_type_reference(
-                    db,
-                    trait_.into(),
-                    trait_,
-                    arg,
-                    DebruijnIndex::ONE,
-                    allow_self_projection,
-                )
-            })
-        }
-        WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(proj), .. }) => {
-            proj.substitution.iter(Interner).skip(1).any(|arg| {
-                contains_illegal_self_type_reference(
-                    db,
-                    trait_.into(),
-                    trait_,
-                    arg,
-                    DebruijnIndex::ONE,
-                    allow_self_projection,
-                )
+    match predicate.kind().skip_binder() {
+        ClauseKind::Trait(trait_pred) => trait_pred.trait_ref.args.iter().skip(1).any(|arg| {
+            contains_illegal_self_type_reference(db, trait_, &arg, allow_self_projection)
+        }),
+        ClauseKind::Projection(proj_pred) => {
+            proj_pred.projection_term.args.iter().skip(1).any(|arg| {
+                contains_illegal_self_type_reference(db, trait_, &arg, allow_self_projection)
             })
         }
         _ => false,
     }
 }
 
-fn contains_illegal_self_type_reference<T: TypeVisitable<Interner>>(
-    db: &dyn HirDatabase,
-    def: GenericDefId,
-    trait_: TraitId,
-    t: &T,
-    outer_binder: DebruijnIndex,
-    allow_self_projection: AllowSelfProjection,
-) -> bool {
-    let Some(trait_self_param_idx) = trait_self_param_idx(db, def) else {
-        return false;
-    };
-    struct IllegalSelfTypeVisitor<'a> {
-        db: &'a dyn HirDatabase,
-        trait_: TraitId,
-        super_traits: Option<SmallVec<[TraitId; 4]>>,
-        trait_self_param_idx: usize,
-        allow_self_projection: AllowSelfProjection,
-    }
-    impl TypeVisitor<Interner> for IllegalSelfTypeVisitor<'_> {
-        type BreakTy = ();
-
-        fn as_dyn(&mut self) -> &mut dyn TypeVisitor<Interner, BreakTy = Self::BreakTy> {
-            self
-        }
-
-        fn interner(&self) -> Interner {
-            Interner
-        }
-
-        fn visit_ty(&mut self, ty: &Ty, outer_binder: DebruijnIndex) -> ControlFlow<Self::BreakTy> {
-            match ty.kind(Interner) {
-                TyKind::BoundVar(BoundVar { debruijn, index }) => {
-                    if *debruijn == outer_binder && *index == self.trait_self_param_idx {
-                        ControlFlow::Break(())
-                    } else {
-                        ty.super_visit_with(self.as_dyn(), outer_binder)
-                    }
-                }
-                TyKind::Alias(AliasTy::Projection(proj)) => match self.allow_self_projection {
-                    AllowSelfProjection::Yes => {
-                        let trait_ = proj.trait_(self.db);
-                        if self.super_traits.is_none() {
-                            self.super_traits = Some(all_super_traits(self.db, self.trait_));
-                        }
-                        if self.super_traits.as_ref().is_some_and(|s| s.contains(&trait_)) {
-                            ControlFlow::Continue(())
-                        } else {
-                            ty.super_visit_with(self.as_dyn(), outer_binder)
-                        }
-                    }
-                    AllowSelfProjection::No => ty.super_visit_with(self.as_dyn(), outer_binder),
-                },
-                _ => ty.super_visit_with(self.as_dyn(), outer_binder),
-            }
-        }
-
-        fn visit_const(
-            &mut self,
-            constant: &chalk_ir::Const<Interner>,
-            outer_binder: DebruijnIndex,
-        ) -> std::ops::ControlFlow<Self::BreakTy> {
-            constant.data(Interner).ty.super_visit_with(self.as_dyn(), outer_binder)
-        }
-    }
-
-    let mut visitor = IllegalSelfTypeVisitor {
-        db,
-        trait_,
-        super_traits: None,
-        trait_self_param_idx,
-        allow_self_projection,
-    };
-    t.visit_with(visitor.as_dyn(), outer_binder).is_break()
-}
-
-fn contains_illegal_self_type_reference_ns<
-    'db,
-    T: rustc_type_ir::TypeVisitable<DbInterner<'db>>,
->(
+fn contains_illegal_self_type_reference<'db, T: rustc_type_ir::TypeVisitable<DbInterner<'db>>>(
     db: &'db dyn HirDatabase,
     trait_: TraitId,
     t: &T,
@@ -440,13 +323,17 @@ where
     }
 
     let sig = db.callable_item_signature_ns(func.into());
-    if sig.skip_binder().inputs().iter().skip(1).any(|ty| {
-        contains_illegal_self_type_reference_ns(db, trait_, &ty, AllowSelfProjection::Yes)
-    }) {
+    if sig
+        .skip_binder()
+        .inputs()
+        .iter()
+        .skip(1)
+        .any(|ty| contains_illegal_self_type_reference(db, trait_, &ty, AllowSelfProjection::Yes))
+    {
         cb(MethodViolationCode::ReferencesSelfInput)?;
     }
 
-    if contains_illegal_self_type_reference_ns(
+    if contains_illegal_self_type_reference(
         db,
         trait_,
         &sig.skip_binder().output(),
@@ -496,7 +383,7 @@ where
             continue;
         }
 
-        if contains_illegal_self_type_reference_ns(db, trait_, &pred, AllowSelfProjection::Yes) {
+        if contains_illegal_self_type_reference(db, trait_, &pred, AllowSelfProjection::Yes) {
             cb(MethodViolationCode::WhereClauseReferencesSelf)?;
             break;
         }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
index 15c675be58199..2777869bd48e5 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
@@ -62,9 +62,10 @@ use crate::{
     lower::{Diagnostics, PathDiagnosticCallbackData, create_diagnostics},
     next_solver::{
         AdtDef, AliasTy, Binder, BoundExistentialPredicates, BoundRegionKind, BoundTyKind,
-        BoundVarKind, BoundVarKinds, Clause, Const, DbInterner, EarlyBinder, EarlyParamRegion,
-        ErrorGuaranteed, GenericArgs, PolyFnSig, Predicate, Region, SolverDefId, TraitPredicate,
-        TraitRef, Ty, Tys, abi::Safety, generics::GenericParamDefKind, mapping::ChalkToNextSolver,
+        BoundVarKind, BoundVarKinds, Clause, Clauses, Const, DbInterner, EarlyBinder,
+        EarlyParamRegion, ErrorGuaranteed, GenericArgs, PolyFnSig, Predicate, Region, SolverDefId,
+        TraitPredicate, TraitRef, Ty, Tys, abi::Safety, generics::GenericParamDefKind,
+        mapping::ChalkToNextSolver,
     },
 };
 
@@ -1593,6 +1594,95 @@ fn fn_sig_for_enum_variant_constructor<'db>(
     }))
 }
 
+pub(crate) fn associated_ty_item_bounds<'db>(
+    db: &'db dyn HirDatabase,
+    type_alias: TypeAliasId,
+) -> EarlyBinder<'db, BoundExistentialPredicates<'db>> {
+    let trait_ = match type_alias.lookup(db).container {
+        ItemContainerId::TraitId(t) => t,
+        _ => panic!("associated type not in trait"),
+    };
+
+    let type_alias_data = db.type_alias_signature(type_alias);
+    let resolver = hir_def::resolver::HasResolver::resolver(type_alias, db);
+    let interner = DbInterner::new_with(db, Some(resolver.krate()), None);
+    let mut ctx = TyLoweringContext::new(
+        db,
+        &resolver,
+        &type_alias_data.store,
+        type_alias.into(),
+        LifetimeElisionKind::AnonymousReportError,
+    );
+    // FIXME: we should never create non-existential predicates in the first place
+    // For now, use an error type so we don't run into dummy binder issues
+    let self_ty = Ty::new_error(interner, ErrorGuaranteed);
+
+    let mut bounds = Vec::new();
+    for bound in &type_alias_data.bounds {
+        ctx.lower_type_bound(bound, self_ty, false).for_each(|pred| {
+            if let Some(bound) = pred
+                .kind()
+                .map_bound(|c| match c {
+                    rustc_type_ir::ClauseKind::Trait(t) => {
+                        let id = t.def_id();
+                        let id = match id {
+                            SolverDefId::TraitId(id) => id,
+                            _ => unreachable!(),
+                        };
+                        let is_auto = db.trait_signature(id).flags.contains(TraitFlags::AUTO);
+                        if is_auto {
+                            Some(ExistentialPredicate::AutoTrait(t.def_id()))
+                        } else {
+                            Some(ExistentialPredicate::Trait(ExistentialTraitRef::new_from_args(
+                                interner,
+                                t.def_id(),
+                                GenericArgs::new_from_iter(
+                                    interner,
+                                    t.trait_ref.args.iter().skip(1),
+                                ),
+                            )))
+                        }
+                    }
+                    rustc_type_ir::ClauseKind::Projection(p) => Some(
+                        ExistentialPredicate::Projection(ExistentialProjection::new_from_args(
+                            interner,
+                            p.def_id(),
+                            GenericArgs::new_from_iter(
+                                interner,
+                                p.projection_term.args.iter().skip(1),
+                            ),
+                            p.term,
+                        )),
+                    ),
+                    rustc_type_ir::ClauseKind::TypeOutlives(outlives_predicate) => None,
+                    rustc_type_ir::ClauseKind::RegionOutlives(_)
+                    | rustc_type_ir::ClauseKind::ConstArgHasType(_, _)
+                    | rustc_type_ir::ClauseKind::WellFormed(_)
+                    | rustc_type_ir::ClauseKind::ConstEvaluatable(_)
+                    | rustc_type_ir::ClauseKind::HostEffect(_)
+                    | rustc_type_ir::ClauseKind::UnstableFeature(_) => unreachable!(),
+                })
+                .transpose()
+            {
+                bounds.push(bound);
+            }
+        });
+    }
+
+    if !ctx.unsized_types.contains(&self_ty) {
+        let sized_trait = LangItem::Sized.resolve_trait(db, resolver.krate());
+        let sized_clause = Binder::dummy(ExistentialPredicate::Trait(ExistentialTraitRef::new(
+            interner,
+            SolverDefId::TraitId(trait_),
+            [] as [crate::next_solver::GenericArg<'_>; 0],
+        )));
+        bounds.push(sized_clause);
+        bounds.shrink_to_fit();
+    }
+
+    EarlyBinder::bind(BoundExistentialPredicates::new_from_iter(interner, bounds))
+}
+
 pub(crate) fn associated_type_by_name_including_super_traits<'db>(
     db: &'db dyn HirDatabase,
     trait_ref: TraitRef<'db>,

From cd0e0957bff2fca7f46b87477b46ba1e21535494 Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Tue, 12 Aug 2025 20:46:19 +0000
Subject: [PATCH 0106/1889] Switch generics_require_sized_self to next solver

---
 .../crates/hir-ty/src/dyn_compatibility.rs    | 42 ++++++++-----------
 1 file changed, 17 insertions(+), 25 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
index 54d78dea3d3b6..be8e23f7ceb15 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
@@ -2,7 +2,6 @@
 
 use std::ops::ControlFlow;
 
-use chalk_ir::DebruijnIndex;
 use hir_def::{
     AssocItemId, ConstId, CrateRootModuleId, FunctionId, GenericDefId, HasModule, TraitId,
     TypeAliasId, lang_item::LangItem, signatures::TraitFlags,
@@ -11,23 +10,20 @@ use intern::Symbol;
 use rustc_hash::FxHashSet;
 use rustc_type_ir::{
     AliasTyKind, ClauseKind, PredicatePolarity, TypeSuperVisitable as _, TypeVisitable as _,
-    Upcast,
+    Upcast, elaborate,
     inherent::{IntoKind, SliceLike},
 };
 use smallvec::SmallVec;
 
 use crate::{
-    ImplTraitId, Interner, TyKind, WhereClause, all_super_traits,
+    ImplTraitId, all_super_traits,
     db::{HirDatabase, InternedOpaqueTyId},
-    from_chalk_trait_id,
-    generics::trait_self_param_idx,
     lower_nextsolver::associated_ty_item_bounds,
     next_solver::{
         Clause, Clauses, DbInterner, GenericArgs, ParamEnv, SolverDefId, TraitPredicate,
         TypingMode, infer::DbInternerInferExt, mk_param,
     },
     traits::next_trait_solve_in_ctxt,
-    utils::elaborate_clause_supertraits,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -133,27 +129,23 @@ pub fn generics_require_sized_self(db: &dyn HirDatabase, def: GenericDefId) -> b
         return false;
     };
 
-    let Some(trait_self_param_idx) = trait_self_param_idx(db, def) else {
-        return false;
-    };
-
-    let predicates = &*db.generic_predicates(def);
-    let predicates = predicates.iter().map(|p| p.skip_binders().skip_binders().clone());
-    elaborate_clause_supertraits(db, predicates).any(|pred| match pred {
-        WhereClause::Implemented(trait_ref) => {
-            if from_chalk_trait_id(trait_ref.trait_id) == sized
-                && let TyKind::BoundVar(it) =
-                    *trait_ref.self_type_parameter(Interner).kind(Interner)
-            {
-                // Since `generic_predicates` is `Binder<Binder<..>>`, the `DebrujinIndex` of
-                // self-parameter is `1`
-                return it
-                    .index_if_bound_at(DebruijnIndex::ONE)
-                    .is_some_and(|idx| idx == trait_self_param_idx);
+    let interner = DbInterner::new_with(db, Some(krate), None);
+    let predicates = db.generic_predicates_ns(def);
+    elaborate::elaborate(interner, predicates.iter().copied()).any(|pred| {
+        match pred.kind().skip_binder() {
+            ClauseKind::Trait(trait_pred) => {
+                if SolverDefId::TraitId(sized) == trait_pred.def_id()
+                    && let rustc_type_ir::TyKind::Param(param_ty) =
+                        trait_pred.trait_ref.self_ty().kind()
+                    && param_ty.index == 0
+                {
+                    true
+                } else {
+                    false
+                }
             }
-            false
+            _ => false,
         }
-        _ => false,
     })
 }
 

From 00856fc250be4a8e9da6630f0ee23120486418e8 Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Tue, 12 Aug 2025 21:45:03 +0000
Subject: [PATCH 0107/1889] Remove all_super_traits in dyn_compatibility

---
 .../crates/hir-ty/src/dyn_compatibility.rs    | 40 +++++++++++++++----
 1 file changed, 33 insertions(+), 7 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
index be8e23f7ceb15..b0c61c29db0b5 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
@@ -16,7 +16,7 @@ use rustc_type_ir::{
 use smallvec::SmallVec;
 
 use crate::{
-    ImplTraitId, all_super_traits,
+    ImplTraitId,
     db::{HirDatabase, InternedOpaqueTyId},
     lower_nextsolver::associated_ty_item_bounds,
     next_solver::{
@@ -53,13 +53,22 @@ pub fn dyn_compatibility(
     db: &dyn HirDatabase,
     trait_: TraitId,
 ) -> Option<DynCompatibilityViolation> {
-    for super_trait in all_super_traits(db, trait_).into_iter().skip(1).rev() {
-        if db.dyn_compatibility_of_trait(super_trait).is_some() {
-            return Some(DynCompatibilityViolation::HasNonCompatibleSuperTrait(super_trait));
+    let interner = DbInterner::new_with(db, Some(trait_.krate(db)), None);
+    for super_trait in elaborate::supertrait_def_ids(interner, SolverDefId::TraitId(trait_)) {
+        let super_trait = match super_trait {
+            SolverDefId::TraitId(id) => id,
+            _ => unreachable!(),
+        };
+        if let Some(v) = db.dyn_compatibility_of_trait(super_trait) {
+            return if super_trait == trait_ {
+                Some(v)
+            } else {
+                Some(DynCompatibilityViolation::HasNonCompatibleSuperTrait(super_trait))
+            };
         }
     }
 
-    db.dyn_compatibility_of_trait(trait_)
+    None
 }
 
 pub fn dyn_compatibility_with_callback<F>(
@@ -70,7 +79,13 @@ pub fn dyn_compatibility_with_callback<F>(
 where
     F: FnMut(DynCompatibilityViolation) -> ControlFlow<()>,
 {
-    for super_trait in all_super_traits(db, trait_).into_iter().skip(1).rev() {
+    let interner = DbInterner::new_with(db, Some(trait_.krate(db)), None);
+    for super_trait in elaborate::supertrait_def_ids(interner, SolverDefId::TraitId(trait_)).skip(1)
+    {
+        let super_trait = match super_trait {
+            SolverDefId::TraitId(id) => id,
+            _ => unreachable!(),
+        };
         if db.dyn_compatibility_of_trait(super_trait).is_some() {
             cb(DynCompatibilityViolation::HasNonCompatibleSuperTrait(trait_))?;
         }
@@ -225,6 +240,7 @@ fn contains_illegal_self_type_reference<'db, T: rustc_type_ir::TypeVisitable<DbI
             &mut self,
             ty: <DbInterner<'db> as rustc_type_ir::Interner>::Ty,
         ) -> Self::Result {
+            let interner = DbInterner::new_with(self.db, None, None);
             match ty.kind() {
                 rustc_type_ir::TyKind::Param(param) if param.index == 0 => ControlFlow::Break(()),
                 rustc_type_ir::TyKind::Param(_) => ControlFlow::Continue(()),
@@ -238,7 +254,17 @@ fn contains_illegal_self_type_reference<'db, T: rustc_type_ir::TypeVisitable<DbI
                             _ => unreachable!(),
                         };
                         if self.super_traits.is_none() {
-                            self.super_traits = Some(all_super_traits(self.db, self.trait_));
+                            self.super_traits = Some(
+                                elaborate::supertrait_def_ids(
+                                    interner,
+                                    SolverDefId::TraitId(self.trait_),
+                                )
+                                .map(|super_trait| match super_trait {
+                                    SolverDefId::TraitId(id) => id,
+                                    _ => unreachable!(),
+                                })
+                                .collect(),
+                            )
                         }
                         if self.super_traits.as_ref().is_some_and(|s| s.contains(&trait_)) {
                             ControlFlow::Continue(())

From f92ca612a8bbb71159fbfc11510b5ce393534c2e Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Tue, 12 Aug 2025 22:21:48 +0000
Subject: [PATCH 0108/1889] Replace layout_of_ty with layout_of_ty_ns

---
 .../crates/hir-ty/src/consteval.rs            | 13 ++++++--
 .../crates/hir-ty/src/consteval_nextsolver.rs |  2 +-
 .../rust-analyzer/crates/hir-ty/src/db.rs     | 14 +++-----
 .../crates/hir-ty/src/display.rs              | 15 +++++----
 .../rust-analyzer/crates/hir-ty/src/layout.rs | 32 ++++---------------
 .../crates/hir-ty/src/layout/adt.rs           |  2 +-
 .../crates/hir-ty/src/layout/tests.rs         | 23 ++++++++-----
 .../crates/hir-ty/src/mir/eval.rs             |  2 +-
 .../crates/hir-ty/src/mir/lower.rs            |  9 ++++--
 src/tools/rust-analyzer/crates/hir/src/lib.rs |  6 ++--
 .../rust-analyzer/crates/ide/src/hover.rs     | 26 ++++++++-------
 .../crates/ide/src/view_memory_layout.rs      |  4 +--
 12 files changed, 75 insertions(+), 73 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
index f30ec839a0096..abf97f3d0e302 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
@@ -15,8 +15,14 @@ use triomphe::Arc;
 
 use crate::{
     Const, ConstData, ConstScalar, ConstValue, GenericArg, Interner, MemoryMap, Substitution,
-    TraitEnvironment, Ty, TyBuilder, db::HirDatabase, display::DisplayTarget, generics::Generics,
-    infer::InferenceContext, lower::ParamLoweringMode, to_placeholder_idx,
+    TraitEnvironment, Ty, TyBuilder,
+    db::HirDatabase,
+    display::DisplayTarget,
+    generics::Generics,
+    infer::InferenceContext,
+    lower::ParamLoweringMode,
+    next_solver::{DbInterner, mapping::ChalkToNextSolver},
+    to_placeholder_idx,
 };
 
 use super::mir::{MirEvalError, MirLowerError, interpret_mir, lower_to_mir, pad16};
@@ -157,7 +163,8 @@ pub fn intern_const_ref(
     ty: Ty,
     krate: Crate,
 ) -> Const {
-    let layout = || db.layout_of_ty(ty.clone(), TraitEnvironment::empty(krate));
+    let interner = DbInterner::new_with(db, Some(krate), None);
+    let layout = || db.layout_of_ty(ty.to_nextsolver(interner), TraitEnvironment::empty(krate));
     let bytes = match value {
         LiteralConstRef::Int(i) => {
             // FIXME: We should handle failure of layout better.
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs
index cdf861290ab92..00fc4e5610dce 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs
@@ -92,7 +92,7 @@ pub fn intern_const_ref<'a>(
     krate: Crate,
 ) -> Const<'a> {
     let interner = DbInterner::new_with(db, Some(krate), None);
-    let layout = db.layout_of_ty_ns(ty, TraitEnvironment::empty(krate));
+    let layout = db.layout_of_ty(ty, TraitEnvironment::empty(krate));
     let kind = match value {
         LiteralConstRef::Int(i) => {
             // FIXME: We should handle failure of layout better.
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
index 161ad31e579b2..9affd3b48c587 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
@@ -103,7 +103,11 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
 
     #[salsa::invoke(crate::layout::layout_of_ty_query)]
     #[salsa::cycle(cycle_result = crate::layout::layout_of_ty_cycle_result)]
-    fn layout_of_ty(&self, ty: Ty, env: Arc<TraitEnvironment>) -> Result<Arc<Layout>, LayoutError>;
+    fn layout_of_ty<'db>(
+        &'db self,
+        ty: crate::next_solver::Ty<'db>,
+        env: Arc<TraitEnvironment>,
+    ) -> Result<Arc<Layout>, LayoutError>;
 
     #[salsa::invoke(crate::layout::target_data_layout_query)]
     fn target_data_layout(&self, krate: Crate) -> Result<Arc<TargetDataLayout>, Arc<str>>;
@@ -300,14 +304,6 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
 
     // next trait solver
 
-    #[salsa::invoke(crate::layout::layout_of_ty_ns_query)]
-    #[salsa::cycle(cycle_result = crate::layout::layout_of_ty_ns_cycle_result)]
-    fn layout_of_ty_ns<'db>(
-        &'db self,
-        ty: crate::next_solver::Ty<'db>,
-        env: Arc<TraitEnvironment>,
-    ) -> Result<Arc<Layout>, LayoutError>;
-
     #[salsa::invoke(crate::lower_nextsolver::ty_query)]
     #[salsa::transparent]
     fn ty_ns<'db>(
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 5adbea75a67dd..cdf6085b65348 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
@@ -840,7 +840,7 @@ fn render_const_scalar_inner(
             TyKind::Slice(ty) => {
                 let addr = usize::from_le_bytes(b[0..b.len() / 2].try_into().unwrap());
                 let count = usize::from_le_bytes(b[b.len() / 2..].try_into().unwrap());
-                let Ok(layout) = f.db.layout_of_ty_ns(ty, trait_env) else {
+                let Ok(layout) = f.db.layout_of_ty(ty, trait_env) else {
                     return f.write_str("<layout-error>");
                 };
                 let size_one = layout.size.bytes_usize();
@@ -874,7 +874,7 @@ fn render_const_scalar_inner(
                 let Ok(t) = memory_map.vtable_ty(ty_id) else {
                     return f.write_str("<ty-missing-in-vtable-map>");
                 };
-                let Ok(layout) = f.db.layout_of_ty_ns(t, trait_env) else {
+                let Ok(layout) = f.db.layout_of_ty(t, trait_env) else {
                     return f.write_str("<layout-error>");
                 };
                 let size = layout.size.bytes_usize();
@@ -905,7 +905,7 @@ fn render_const_scalar_inner(
                         return f.write_str("<layout-error>");
                     }
                 });
-                let Ok(layout) = f.db.layout_of_ty_ns(t, trait_env) else {
+                let Ok(layout) = f.db.layout_of_ty(t, trait_env) else {
                     return f.write_str("<layout-error>");
                 };
                 let size = layout.size.bytes_usize();
@@ -917,7 +917,7 @@ fn render_const_scalar_inner(
             }
         },
         TyKind::Tuple(tys) => {
-            let Ok(layout) = f.db.layout_of_ty_ns(ty, trait_env.clone()) else {
+            let Ok(layout) = f.db.layout_of_ty(ty, trait_env.clone()) else {
                 return f.write_str("<layout-error>");
             };
             f.write_str("(")?;
@@ -929,7 +929,7 @@ fn render_const_scalar_inner(
                     f.write_str(", ")?;
                 }
                 let offset = layout.fields.offset(id).bytes_usize();
-                let Ok(layout) = f.db.layout_of_ty_ns(ty, trait_env.clone()) else {
+                let Ok(layout) = f.db.layout_of_ty(ty, trait_env.clone()) else {
                     f.write_str("<layout-error>")?;
                     continue;
                 };
@@ -1006,7 +1006,7 @@ fn render_const_scalar_inner(
             let Some(len) = consteval_nextsolver::try_const_usize(f.db, len) else {
                 return f.write_str("<unknown-array-len>");
             };
-            let Ok(layout) = f.db.layout_of_ty_ns(ty, trait_env) else {
+            let Ok(layout) = f.db.layout_of_ty(ty, trait_env) else {
                 return f.write_str("<layout-error>");
             };
             let size_one = layout.size.bytes_usize();
@@ -1061,7 +1061,8 @@ fn render_variant_after_name(
                 let ty = field_types[id]
                     .clone()
                     .substitute(Interner, &convert_args_for_result(interner, args.as_slice()));
-                let Ok(layout) = f.db.layout_of_ty(ty.clone(), trait_env.clone()) else {
+                let Ok(layout) = f.db.layout_of_ty(ty.to_nextsolver(interner), trait_env.clone())
+                else {
                     return f.write_str("<layout-error>");
                 };
                 let size = layout.size.bytes_usize();
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
index 0a8ec949b7c0a..e2ee8935a8855 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
@@ -151,23 +151,13 @@ fn layout_of_simd_ty<'db>(
     };
 
     let e_len = try_const_usize(db, e_len).ok_or(LayoutError::HasErrorConst)? as u64;
-    let e_ly = db.layout_of_ty_ns(e_ty, env)?;
+    let e_ly = db.layout_of_ty(e_ty, env)?;
 
     let cx = LayoutCx::new(dl);
     Ok(Arc::new(cx.calc.simd_type(e_ly, e_len, repr_packed)?))
 }
 
-pub fn layout_of_ty_query(
-    db: &dyn HirDatabase,
-    ty: crate::Ty,
-    trait_env: Arc<TraitEnvironment>,
-) -> Result<Arc<Layout>, LayoutError> {
-    let krate = trait_env.krate;
-    let interner = DbInterner::new_with(db, Some(krate), trait_env.block);
-    db.layout_of_ty_ns(ty.to_nextsolver(interner), trait_env)
-}
-
-pub fn layout_of_ty_ns_query<'db>(
+pub fn layout_of_ty_query<'db>(
     db: &'db dyn HirDatabase,
     ty: Ty<'db>,
     trait_env: Arc<TraitEnvironment>,
@@ -262,7 +252,7 @@ pub fn layout_of_ty_ns_query<'db>(
 
             let fields = tys
                 .iter()
-                .map(|k| db.layout_of_ty_ns(k, trait_env.clone()))
+                .map(|k| db.layout_of_ty(k, trait_env.clone()))
                 .collect::<Result<Vec<_>, _>>()?;
             let fields = fields.iter().map(|it| &**it).collect::<Vec<_>>();
             let fields = fields.iter().collect::<IndexVec<_, _>>();
@@ -270,11 +260,11 @@ pub fn layout_of_ty_ns_query<'db>(
         }
         TyKind::Array(element, count) => {
             let count = try_const_usize(db, count).ok_or(LayoutError::HasErrorConst)? as u64;
-            let element = db.layout_of_ty_ns(element, trait_env)?;
+            let element = db.layout_of_ty(element, trait_env)?;
             cx.calc.array_like::<_, _, ()>(&element, Some(count))?
         }
         TyKind::Slice(element) => {
-            let element = db.layout_of_ty_ns(element, trait_env)?;
+            let element = db.layout_of_ty(element, trait_env)?;
             cx.calc.array_like::<_, _, ()>(&element, None)?
         }
         TyKind::Str => {
@@ -346,7 +336,7 @@ pub fn layout_of_ty_ns_query<'db>(
                     let ty =
                         convert_binder_to_early_binder(interner, it.ty.to_nextsolver(interner))
                             .instantiate(interner, args);
-                    db.layout_of_ty_ns(ty, trait_env.clone())
+                    db.layout_of_ty(ty, trait_env.clone())
                 })
                 .collect::<Result<Vec<_>, _>>()?;
             let fields = fields.iter().map(|it| &**it).collect::<Vec<_>>();
@@ -376,15 +366,7 @@ pub fn layout_of_ty_ns_query<'db>(
     Ok(Arc::new(result))
 }
 
-pub(crate) fn layout_of_ty_cycle_result(
-    _: &dyn HirDatabase,
-    _: crate::Ty,
-    _: Arc<TraitEnvironment>,
-) -> Result<Arc<Layout>, LayoutError> {
-    Err(LayoutError::RecursiveTypeWithoutIndirection)
-}
-
-pub(crate) fn layout_of_ty_ns_cycle_result<'db>(
+pub(crate) fn layout_of_ty_cycle_result<'db>(
     _: &dyn HirDatabase,
     _: Ty<'db>,
     _: Arc<TraitEnvironment>,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs
index fefa3f2617439..9a746ca888589 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs
@@ -34,7 +34,7 @@ pub fn layout_of_adt_query<'db>(
     let handle_variant = |def: VariantId, var: &VariantFields| {
         var.fields()
             .iter()
-            .map(|(fd, _)| db.layout_of_ty_ns(field_ty(db, def, fd, &args), trait_env.clone()))
+            .map(|(fd, _)| db.layout_of_ty(field_ty(db, def, fd, &args), trait_env.clone()))
             .collect::<Result<Vec<_>, _>>()
     };
     let (variants, repr, is_special_no_niche) = match def {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs
index 93f2e123dca58..90de7e5ca633d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs
@@ -11,6 +11,7 @@ use crate::{
     Interner, Substitution,
     db::HirDatabase,
     layout::{Layout, LayoutError},
+    next_solver::{DbInterner, mapping::ChalkToNextSolver},
     setup_tracing,
     test_db::TestDB,
 };
@@ -85,13 +86,16 @@ fn eval_goal(
             db.ty(ty_id.into()).substitute(Interner, &Substitution::empty(Interner))
         }
     };
-    db.layout_of_ty(
-        goal_ty,
-        db.trait_environment(match adt_or_type_alias_id {
-            Either::Left(adt) => hir_def::GenericDefId::AdtId(adt),
-            Either::Right(ty) => hir_def::GenericDefId::TypeAliasId(ty),
-        }),
-    )
+    salsa::attach(&db, || {
+        let interner = DbInterner::new_with(&db, None, None);
+        db.layout_of_ty(
+            goal_ty.to_nextsolver(interner),
+            db.trait_environment(match adt_or_type_alias_id {
+                Either::Left(adt) => hir_def::GenericDefId::AdtId(adt),
+                Either::Right(ty) => hir_def::GenericDefId::TypeAliasId(ty),
+            }),
+        )
+    })
 }
 
 /// A version of `eval_goal` for types that can not be expressed in ADTs, like closures and `impl Trait`
@@ -128,7 +132,10 @@ fn eval_expr(
         .0;
     let infer = db.infer(function_id.into());
     let goal_ty = infer.type_of_binding[b].clone();
-    db.layout_of_ty(goal_ty, db.trait_environment(function_id.into()))
+    salsa::attach(&db, || {
+        let interner = DbInterner::new_with(&db, None, None);
+        db.layout_of_ty(goal_ty.to_nextsolver(interner), db.trait_environment(function_id.into()))
+    })
 }
 
 #[track_caller]
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
index d0ae92961efc0..9deaa4ac5a6b5 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
@@ -854,7 +854,7 @@ impl<'db> Evaluator<'db> {
         let interner = DbInterner::new_with(self.db, None, None);
         let r = self
             .db
-            .layout_of_ty_ns(ty, self.trait_env.clone())
+            .layout_of_ty(ty, self.trait_env.clone())
             .map_err(|e| MirEvalError::LayoutError(e, convert_ty_for_result(interner, ty)))?;
         self.layout_cache.borrow_mut().insert(ty, r.clone());
         Ok(r)
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
index 0bb8e6fe79d65..052be11e433f3 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
@@ -43,6 +43,7 @@ use crate::{
         Terminator, TerminatorKind, TupleFieldId, Ty, UnOp, VariantId, intern_const_scalar,
         return_slot,
     },
+    next_solver::{DbInterner, mapping::ChalkToNextSolver},
     static_lifetime,
     traits::FnTrait,
     utils::ClosureSubst,
@@ -1411,8 +1412,12 @@ impl<'ctx> MirLowerCtx<'ctx> {
     }
 
     fn lower_literal_to_operand(&mut self, ty: Ty, l: &Literal) -> Result<Operand> {
-        let size =
-            || self.db.layout_of_ty(ty.clone(), self.env.clone()).map(|it| it.size.bytes_usize());
+        let interner = DbInterner::new_with(self.db, None, None);
+        let size = || {
+            self.db
+                .layout_of_ty(ty.to_nextsolver(interner), self.env.clone())
+                .map(|it| it.size.bytes_usize())
+        };
         const USIZE_SIZE: usize = size_of::<usize>();
         let bytes: Box<[_]> = match l {
             hir_def::hir::Literal::String(b) => {
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index 18c3ea05614a8..e423d2c07c159 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -1389,8 +1389,9 @@ impl Field {
     }
 
     pub fn layout(&self, db: &dyn HirDatabase) -> Result<Layout, LayoutError> {
+        let interner = DbInterner::new_with(db, None, None);
         db.layout_of_ty(
-            self.ty(db).ty,
+            self.ty(db).ty.to_nextsolver(interner),
             db.trait_environment(match hir_def::VariantId::from(self.parent) {
                 hir_def::VariantId::EnumVariantId(id) => {
                     GenericDefId::AdtId(id.lookup(db).parent.into())
@@ -5906,7 +5907,8 @@ impl<'db> Type<'db> {
     }
 
     pub fn layout(&self, db: &'db dyn HirDatabase) -> Result<Layout, LayoutError> {
-        db.layout_of_ty(self.ty.clone(), self.env.clone())
+        let interner = DbInterner::new_with(db, None, None);
+        db.layout_of_ty(self.ty.to_nextsolver(interner), self.env.clone())
             .map(|layout| Layout(layout, db.target_data_layout(self.env.krate).unwrap()))
     }
 
diff --git a/src/tools/rust-analyzer/crates/ide/src/hover.rs b/src/tools/rust-analyzer/crates/ide/src/hover.rs
index fc45dc3faf40f..b0ef83e0501b3 100644
--- a/src/tools/rust-analyzer/crates/ide/src/hover.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/hover.rs
@@ -137,18 +137,20 @@ pub(crate) fn hover(
     let edition =
         sema.attach_first_edition(file_id).map(|it| it.edition(db)).unwrap_or(Edition::CURRENT);
     let display_target = sema.first_crate(file_id)?.to_display_target(db);
-    let mut res = if range.is_empty() {
-        hover_offset(
-            sema,
-            FilePosition { file_id, offset: range.start() },
-            file,
-            config,
-            edition,
-            display_target,
-        )
-    } else {
-        hover_ranged(sema, frange, file, config, edition, display_target)
-    }?;
+    let mut res = salsa::attach(sema.db, || {
+        if range.is_empty() {
+            hover_offset(
+                sema,
+                FilePosition { file_id, offset: range.start() },
+                file,
+                config,
+                edition,
+                display_target,
+            )
+        } else {
+            hover_ranged(sema, frange, file, config, edition, display_target)
+        }
+    })?;
 
     if let HoverDocFormat::PlainText = config.format {
         res.info.markup = remove_markdown(res.info.markup.as_str()).into();
diff --git a/src/tools/rust-analyzer/crates/ide/src/view_memory_layout.rs b/src/tools/rust-analyzer/crates/ide/src/view_memory_layout.rs
index 1eb0fd4fd8b76..950f3f6c64706 100644
--- a/src/tools/rust-analyzer/crates/ide/src/view_memory_layout.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/view_memory_layout.rs
@@ -139,7 +139,7 @@ pub(crate) fn view_memory_layout(
         nodes[parent_idx].children_len = fields.len() as u64;
 
         for (field, child_ty) in fields.iter() {
-            if let Ok(child_layout) = child_ty.layout(db) {
+            if let Ok(child_layout) = salsa::attach(db, || child_ty.layout(db)) {
                 nodes.push(MemoryLayoutNode {
                     item_name: field.name(db),
                     typename: salsa::attach(db, || {
@@ -172,7 +172,7 @@ pub(crate) fn view_memory_layout(
         }
 
         for (i, (_, child_ty)) in fields.iter().enumerate() {
-            if let Ok(child_layout) = child_ty.layout(db) {
+            if let Ok(child_layout) = salsa::attach(db, || child_ty.layout(db)) {
                 read_layout(nodes, db, child_ty, &child_layout, children_start + i, display_target);
             }
         }

From 05bc1818dac760fac07c9c6d562977cd9b51dab1 Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Wed, 13 Aug 2025 03:13:45 +0000
Subject: [PATCH 0109/1889] Switch TraitRef in hir::TraitRef to next solver

---
 .../crates/hir-ty/src/display.rs              | 238 ++++++++++++++++--
 .../hir-ty/src/next_solver/generic_arg.rs     |  23 ++
 .../crates/hir-ty/src/next_solver/mapping.rs  |  25 +-
 src/tools/rust-analyzer/crates/hir/src/lib.rs |  43 ++--
 4 files changed, 288 insertions(+), 41 deletions(-)

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 cdf6085b65348..ae0113fcbd7f0 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
@@ -11,8 +11,8 @@ use base_db::Crate;
 use chalk_ir::{BoundVar, Safety, TyKind};
 use either::Either;
 use hir_def::{
-    GenericDefId, HasModule, ImportPathConfig, LocalFieldId, Lookup, ModuleDefId, ModuleId,
-    TraitId,
+    GeneralConstId, GenericDefId, HasModule, ImportPathConfig, LocalFieldId, Lookup, ModuleDefId,
+    ModuleId, TraitId,
     db::DefDatabase,
     expr_store::{ExpressionStore, path::Path},
     find_path::{self, PrefixKind},
@@ -38,7 +38,7 @@ use rustc_apfloat::{
 };
 use rustc_hash::FxHashSet;
 use rustc_type_ir::{
-    AliasTyKind,
+    AliasTyKind, RegionKind,
     inherent::{AdtDef, IntoKind, SliceLike},
 };
 use smallvec::SmallVec;
@@ -61,8 +61,9 @@ use crate::{
     next_solver::{
         BoundExistentialPredicate, Ctor, DbInterner, GenericArgs, SolverDefId,
         mapping::{
-            ChalkToNextSolver, convert_args_for_result, convert_const_for_result,
-            convert_region_for_result, convert_ty_for_result,
+            ChalkToNextSolver, bound_var_to_lifetime_idx, bound_var_to_type_or_const_param_idx,
+            convert_args_for_result, convert_const_for_result, convert_region_for_result,
+            convert_ty_for_result,
         },
     },
     primitive, to_assoc_type_id,
@@ -715,28 +716,56 @@ impl HirDisplay for GenericArg {
     }
 }
 
+impl<'db> HirDisplay for crate::next_solver::GenericArg<'db> {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+        match self.kind() {
+            rustc_type_ir::GenericArgKind::Type(ty) => ty.hir_fmt(f),
+            rustc_type_ir::GenericArgKind::Lifetime(lt) => lt.hir_fmt(f),
+            rustc_type_ir::GenericArgKind::Const(c) => c.hir_fmt(f),
+        }
+    }
+}
+
 impl HirDisplay for Const {
     fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
-        let data = self.interned();
-        match &data.value {
-            ConstValue::BoundVar(idx) => idx.hir_fmt(f),
-            ConstValue::InferenceVar(..) => write!(f, "#c#"),
-            ConstValue::Placeholder(idx) => {
-                let id = from_placeholder_idx(f.db, *idx);
+        let c = self.to_nextsolver(DbInterner::new_with(f.db, None, None));
+        c.hir_fmt(f)
+    }
+}
+
+impl<'db> HirDisplay for crate::next_solver::Const<'db> {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+        match self.kind() {
+            rustc_type_ir::ConstKind::Bound(db, bound_const) => {
+                write!(f, "?{}.{}", db.as_u32(), bound_const.as_u32())
+            }
+            rustc_type_ir::ConstKind::Infer(..) => write!(f, "#c#"),
+            rustc_type_ir::ConstKind::Placeholder(idx) => {
+                let id = bound_var_to_type_or_const_param_idx(f.db, idx.bound);
                 let generics = generics(f.db, id.parent);
                 let param_data = &generics[id.local_id];
                 write!(f, "{}", param_data.name().unwrap().display(f.db, f.edition()))?;
                 Ok(())
             }
-            ConstValue::Concrete(c) => match &c.interned {
-                ConstScalar::Bytes(b, m) => render_const_scalar(f, b, m, &data.ty),
-                ConstScalar::UnevaluatedConst(c, parameters) => {
-                    write!(f, "{}", c.name(f.db))?;
-                    hir_fmt_generics(f, parameters.as_slice(Interner), c.generic_def(f.db), None)?;
-                    Ok(())
-                }
-                ConstScalar::Unknown => f.write_char('_'),
-            },
+            rustc_type_ir::ConstKind::Value(const_bytes) => render_const_scalar_ns(
+                f,
+                &const_bytes.value.inner().0,
+                &const_bytes.value.inner().1,
+                const_bytes.ty,
+            ),
+            rustc_type_ir::ConstKind::Unevaluated(unev) => {
+                let c = match unev.def {
+                    SolverDefId::ConstId(id) => GeneralConstId::ConstId(id),
+                    SolverDefId::StaticId(id) => GeneralConstId::StaticId(id),
+                    _ => unreachable!(),
+                };
+                write!(f, "{}", c.name(f.db))?;
+                hir_fmt_generics_ns(f, unev.args.as_slice(), c.generic_def(f.db), None)?;
+                Ok(())
+            }
+            rustc_type_ir::ConstKind::Error(..) => f.write_char('_'),
+            rustc_type_ir::ConstKind::Expr(..) => write!(f, "<const-expr>"),
+            rustc_type_ir::ConstKind::Param(_) => write!(f, "<param>"),
         }
     }
 }
@@ -1748,6 +1777,27 @@ fn hir_fmt_generics(
     Ok(())
 }
 
+fn hir_fmt_generics_ns<'db>(
+    f: &mut HirFormatter<'_>,
+    parameters: &[crate::next_solver::GenericArg<'db>],
+    generic_def: Option<hir_def::GenericDefId>,
+    self_: Option<crate::next_solver::Ty<'db>>,
+) -> Result<(), HirDisplayError> {
+    if parameters.is_empty() {
+        return Ok(());
+    }
+
+    let parameters_to_write = generic_args_sans_defaults_ns(f, generic_def, parameters);
+
+    if !parameters_to_write.is_empty() {
+        write!(f, "<")?;
+        hir_fmt_generic_arguments_ns(f, parameters_to_write, self_)?;
+        write!(f, ">")?;
+    }
+
+    Ok(())
+}
+
 fn generic_args_sans_defaults<'ga>(
     f: &mut HirFormatter<'_>,
     generic_def: Option<hir_def::GenericDefId>,
@@ -1803,6 +1853,87 @@ fn generic_args_sans_defaults<'ga>(
     }
 }
 
+fn hir_fmt_generic_args<'db>(
+    f: &mut HirFormatter<'_>,
+    parameters: &[crate::next_solver::GenericArg<'db>],
+    generic_def: Option<hir_def::GenericDefId>,
+    self_: Option<crate::next_solver::Ty<'db>>,
+) -> Result<(), HirDisplayError> {
+    if parameters.is_empty() {
+        return Ok(());
+    }
+
+    let parameters_to_write = generic_args_sans_defaults_ns(f, generic_def, parameters);
+
+    if !parameters_to_write.is_empty() {
+        write!(f, "<")?;
+        hir_fmt_generic_arguments_ns(f, parameters_to_write, self_)?;
+        write!(f, ">")?;
+    }
+
+    Ok(())
+}
+
+fn generic_args_sans_defaults_ns<'ga, 'db>(
+    f: &mut HirFormatter<'_>,
+    generic_def: Option<hir_def::GenericDefId>,
+    parameters: &'ga [crate::next_solver::GenericArg<'db>],
+) -> &'ga [crate::next_solver::GenericArg<'db>] {
+    let interner = DbInterner::new_with(f.db, Some(f.krate()), None);
+    if f.display_kind.is_source_code() || f.omit_verbose_types() {
+        match generic_def
+            .map(|generic_def_id| f.db.generic_defaults(generic_def_id))
+            .filter(|it| !it.is_empty())
+        {
+            None => parameters,
+            Some(default_parameters) => {
+                let should_show = |arg: &crate::next_solver::GenericArg<'db>, i: usize| {
+                    let is_err = |arg: &crate::next_solver::GenericArg<'db>| match arg.kind() {
+                        rustc_type_ir::GenericArgKind::Lifetime(it) => {
+                            matches!(it.kind(), RegionKind::ReError(..))
+                        }
+                        rustc_type_ir::GenericArgKind::Type(it) => {
+                            matches!(it.kind(), rustc_type_ir::TyKind::Error(..))
+                        }
+                        rustc_type_ir::GenericArgKind::Const(it) => {
+                            matches!(it.kind(), rustc_type_ir::ConstKind::Error(..),)
+                        }
+                    };
+                    // if the arg is error like, render it to inform the user
+                    if is_err(arg) {
+                        return true;
+                    }
+                    // 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)
+                    match default_parameters.get(i) {
+                        None => true,
+                        Some(default_parameter) => {
+                            // !is_err(default_parameter.skip_binders())
+                            // &&
+                            arg != &default_parameter
+                                .clone()
+                                .substitute(
+                                    Interner,
+                                    &convert_args_for_result(interner, &parameters[..i]),
+                                )
+                                .to_nextsolver(interner)
+                        }
+                    }
+                };
+                let mut default_from = 0;
+                for (i, parameter) in parameters.iter().enumerate() {
+                    if should_show(parameter, i) {
+                        default_from = i + 1;
+                    }
+                }
+                &parameters[0..default_from]
+            }
+        }
+    } else {
+        parameters
+    }
+}
+
 fn hir_fmt_generic_arguments(
     f: &mut HirFormatter<'_>,
     parameters: &[GenericArg],
@@ -1827,6 +1958,30 @@ fn hir_fmt_generic_arguments(
     Ok(())
 }
 
+fn hir_fmt_generic_arguments_ns<'db>(
+    f: &mut HirFormatter<'_>,
+    parameters: &[crate::next_solver::GenericArg<'db>],
+    self_: Option<crate::next_solver::Ty<'db>>,
+) -> Result<(), HirDisplayError> {
+    let mut first = true;
+    let lifetime_offset = parameters.iter().position(|arg| arg.region().is_some());
+
+    let (ty_or_const, lifetimes) = match lifetime_offset {
+        Some(offset) => parameters.split_at(offset),
+        None => (parameters, &[][..]),
+    };
+    for generic_arg in lifetimes.iter().chain(ty_or_const) {
+        if !mem::take(&mut first) {
+            write!(f, ", ")?;
+        }
+        match self_ {
+            self_ @ Some(_) if generic_arg.ty() == self_ => write!(f, "Self")?,
+            _ => generic_arg.hir_fmt(f)?,
+        }
+    }
+    Ok(())
+}
+
 impl HirDisplay for CallableSig {
     fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
         let CallableSig { params_and_return: _, is_varargs, safety, abi: _ } = *self;
@@ -2067,6 +2222,20 @@ impl HirDisplay for TraitRef {
     }
 }
 
+impl<'db> HirDisplay for crate::next_solver::TraitRef<'db> {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+        let trait_ = match self.def_id {
+            SolverDefId::TraitId(id) => id,
+            _ => unreachable!(),
+        };
+        f.start_location_link(trait_.into());
+        write!(f, "{}", f.db.trait_signature(trait_).name.display(f.db, f.edition()))?;
+        f.end_location_link();
+        let substs = self.args.as_slice();
+        hir_fmt_generic_args(f, &substs[1..], None, substs[0].ty())
+    }
+}
+
 impl HirDisplay for WhereClause {
     fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
         if f.should_truncate() {
@@ -2147,6 +2316,35 @@ impl HirDisplay for LifetimeData {
     }
 }
 
+impl<'db> HirDisplay for crate::next_solver::Region<'db> {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+        match self.kind() {
+            rustc_type_ir::RegionKind::RePlaceholder(idx) => {
+                let id = bound_var_to_lifetime_idx(f.db, idx.bound.var);
+                let generics = generics(f.db, id.parent);
+                let param_data = &generics[id.local_id];
+                write!(f, "{}", param_data.name.display(f.db, f.edition()))?;
+                Ok(())
+            }
+            rustc_type_ir::RegionKind::ReBound(db, idx) => {
+                write!(f, "?{}.{}", db.as_u32(), idx.var.as_u32())
+            }
+            rustc_type_ir::RegionKind::ReVar(_) => write!(f, "_"),
+            rustc_type_ir::RegionKind::ReStatic => write!(f, "'static"),
+            rustc_type_ir::RegionKind::ReError(..) => {
+                if cfg!(test) {
+                    write!(f, "'?")
+                } else {
+                    write!(f, "'_")
+                }
+            }
+            rustc_type_ir::RegionKind::ReErased => write!(f, "'<erased>"),
+            rustc_type_ir::RegionKind::ReEarlyParam(_) => write!(f, "<param>"),
+            rustc_type_ir::RegionKind::ReLateParam(_) => write!(f, "<late-param>"),
+        }
+    }
+}
+
 impl HirDisplay for DomainGoal {
     fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
         match self {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generic_arg.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generic_arg.rs
index 046b4303c3261..834f4e3765ee8 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generic_arg.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generic_arg.rs
@@ -35,6 +35,29 @@ impl<'db> std::fmt::Debug for GenericArg<'db> {
     }
 }
 
+impl<'db> GenericArg<'db> {
+    pub fn ty(self) -> Option<Ty<'db>> {
+        match self.kind() {
+            GenericArgKind::Type(ty) => Some(ty),
+            _ => None,
+        }
+    }
+
+    pub fn expect_ty(self) -> Ty<'db> {
+        match self.kind() {
+            GenericArgKind::Type(ty) => ty,
+            _ => panic!("Expected ty, got {:?}", self),
+        }
+    }
+
+    pub fn region(self) -> Option<Region<'db>> {
+        match self.kind() {
+            GenericArgKind::Lifetime(r) => Some(r),
+            _ => None,
+        }
+    }
+}
+
 impl<'db> From<Term<'db>> for GenericArg<'db> {
     fn from(value: Term<'db>) -> Self {
         match value {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
index 5fefb04a5e768..cad51fd85f55a 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
@@ -18,13 +18,14 @@ use rustc_type_ir::{
     shift_vars,
     solve::Goal,
 };
-use salsa::plumbing::AsId;
+use salsa::plumbing::FromId;
+use salsa::{Id, plumbing::AsId};
 
 use crate::{
     ConcreteConst, ConstScalar, ImplTraitId, Interner, MemoryMap,
     db::{
-        HirDatabase, InternedClosureId, InternedCoroutineId, InternedOpaqueTyId,
-        InternedTypeOrConstParamId,
+        HirDatabase, InternedClosureId, InternedCoroutineId, InternedLifetimeParamId,
+        InternedOpaqueTyId, InternedTypeOrConstParamId,
     },
     from_assoc_type_id, from_chalk_trait_id,
     mapping::ToChalk,
@@ -55,6 +56,24 @@ pub fn to_placeholder_idx<T: Clone + std::fmt::Debug>(
     }
 }
 
+pub fn bound_var_to_type_or_const_param_idx(
+    db: &dyn HirDatabase,
+    var: rustc_type_ir::BoundVar,
+) -> TypeOrConstParamId {
+    // SAFETY: We cannot really encapsulate this unfortunately, so just hope this is sound.
+    let interned_id = InternedTypeOrConstParamId::from_id(unsafe { Id::from_index(var.as_u32()) });
+    interned_id.loc(db)
+}
+
+pub fn bound_var_to_lifetime_idx(
+    db: &dyn HirDatabase,
+    var: rustc_type_ir::BoundVar,
+) -> LifetimeParamId {
+    // SAFETY: We cannot really encapsulate this unfortunately, so just hope this is sound.
+    let interned_id = InternedLifetimeParamId::from_id(unsafe { Id::from_index(var.as_u32()) });
+    interned_id.loc(db)
+}
+
 pub fn convert_binder_to_early_binder<'db, T: rustc_type_ir::TypeFoldable<DbInterner<'db>>>(
     interner: DbInterner<'db>,
     binder: rustc_type_ir::Binder<DbInterner<'db>, T>,
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index e423d2c07c159..46a0f584c0131 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -115,7 +115,7 @@ pub use crate::{
         VisibleTraits,
     },
 };
-use rustc_type_ir::inherent::IntoKind;
+use rustc_type_ir::inherent::{IntoKind, SliceLike};
 
 // Be careful with these re-exports.
 //
@@ -4513,14 +4513,20 @@ impl Impl {
     }
 
     pub fn trait_(self, db: &dyn HirDatabase) -> Option<Trait> {
-        let trait_ref = db.impl_trait(self.id)?;
-        let id = trait_ref.skip_binders().hir_trait_id();
+        let trait_ref = db.impl_trait_ns(self.id)?;
+        let id = trait_ref.skip_binder().def_id;
+        let id = match id {
+            SolverDefId::TraitId(id) => id,
+            _ => unreachable!(),
+        };
         Some(Trait { id })
     }
 
     pub fn trait_ref(self, db: &dyn HirDatabase) -> Option<TraitRef<'_>> {
+        let interner = DbInterner::new_with(db, None, None);
         let substs = TyBuilder::placeholder_subst(db, self.id);
-        let trait_ref = db.impl_trait(self.id)?.substitute(Interner, &substs);
+        let trait_ref =
+            db.impl_trait(self.id)?.substitute(Interner, &substs).to_nextsolver(interner);
         let resolver = self.id.resolver(db);
         Some(TraitRef::new_with_resolver(db, &resolver, trait_ref))
     }
@@ -4589,7 +4595,7 @@ impl Impl {
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub struct TraitRef<'db> {
     env: Arc<TraitEnvironment>,
-    trait_ref: hir_ty::TraitRef,
+    trait_ref: hir_ty::next_solver::TraitRef<'db>,
     _pd: PhantomCovariantLifetime<'db>,
 }
 
@@ -4597,7 +4603,7 @@ impl<'db> TraitRef<'db> {
     pub(crate) fn new_with_resolver(
         db: &'db dyn HirDatabase,
         resolver: &Resolver<'_>,
-        trait_ref: hir_ty::TraitRef,
+        trait_ref: hir_ty::next_solver::TraitRef<'db>,
     ) -> Self {
         let env = resolver
             .generic_def()
@@ -4606,25 +4612,26 @@ impl<'db> TraitRef<'db> {
     }
 
     pub fn trait_(&self) -> Trait {
-        let id = self.trait_ref.hir_trait_id();
+        let id = match self.trait_ref.def_id {
+            SolverDefId::TraitId(id) => id,
+            _ => unreachable!(),
+        };
         Trait { id }
     }
 
-    pub fn self_ty(&self) -> Type<'_> {
-        let ty = self.trait_ref.self_type_parameter(Interner);
-        Type { env: self.env.clone(), ty, _pd: PhantomCovariantLifetime::new() }
+    pub fn self_ty(&self) -> TypeNs<'_> {
+        let ty = self.trait_ref.self_ty();
+        TypeNs { env: self.env.clone(), ty, _pd: PhantomCovariantLifetime::new() }
     }
 
     /// Returns `idx`-th argument of this trait reference if it is a type argument. Note that the
     /// first argument is the `Self` type.
-    pub fn get_type_argument(&self, idx: usize) -> Option<Type<'db>> {
-        self.trait_ref
-            .substitution
-            .as_slice(Interner)
-            .get(idx)
-            .and_then(|arg| arg.ty(Interner))
-            .cloned()
-            .map(|ty| Type { env: self.env.clone(), ty, _pd: PhantomCovariantLifetime::new() })
+    pub fn get_type_argument(&self, idx: usize) -> Option<TypeNs<'db>> {
+        self.trait_ref.args.as_slice().get(idx).and_then(|arg| arg.ty()).map(|ty| TypeNs {
+            env: self.env.clone(),
+            ty,
+            _pd: PhantomCovariantLifetime::new(),
+        })
     }
 }
 

From 49f166029f6956c6422b73bfa52f416cd2be12f0 Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Wed, 13 Aug 2025 03:35:01 +0000
Subject: [PATCH 0110/1889] Use impl_trait_ns in Impl::trait_ref

---
 src/tools/rust-analyzer/crates/hir/src/lib.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index 46a0f584c0131..ff7d116dcce3e 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -4523,10 +4523,7 @@ impl Impl {
     }
 
     pub fn trait_ref(self, db: &dyn HirDatabase) -> Option<TraitRef<'_>> {
-        let interner = DbInterner::new_with(db, None, None);
-        let substs = TyBuilder::placeholder_subst(db, self.id);
-        let trait_ref =
-            db.impl_trait(self.id)?.substitute(Interner, &substs).to_nextsolver(interner);
+        let trait_ref = db.impl_trait_ns(self.id)?.instantiate_identity();
         let resolver = self.id.resolver(db);
         Some(TraitRef::new_with_resolver(db, &resolver, trait_ref))
     }

From e5d320fd6c28b5099389e0a34a688e8d37d90f4b Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Wed, 13 Aug 2025 04:23:00 +0000
Subject: [PATCH 0111/1889] Remove a bunch of stuff from chalk_db

---
 .../crates/hir-ty/src/chalk_db.rs             | 425 +-----------------
 .../rust-analyzer/crates/hir-ty/src/db.rs     |  29 --
 .../crates/hir-ty/src/diagnostics/expr.rs     |   7 +-
 .../crates/hir-ty/src/infer/cast.rs           |  12 +-
 .../crates/hir-ty/src/infer/closure.rs        |  26 +-
 .../crates/hir-ty/src/mapping.rs              |  19 -
 src/tools/rust-analyzer/crates/hir/src/lib.rs |  75 +++-
 7 files changed, 80 insertions(+), 513 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/chalk_db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/chalk_db.rs
index f523a5e8bfa05..546991cf6571e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/chalk_db.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/chalk_db.rs
@@ -1,44 +1,13 @@
 //! The implementation of `RustIrDatabase` for Chalk, which provides information
 //! about the code that Chalk needs.
-use std::sync::Arc;
+use hir_def::{CallableDefId, GenericDefId};
 
-use tracing::debug;
-
-use chalk_ir::{cast::Caster, fold::shift::Shift};
-use chalk_solve::rust_ir::{self, WellKnownTrait};
-
-use base_db::Crate;
-use hir_def::{
-    AssocItemId, CallableDefId, GenericDefId, HasModule, ItemContainerId, Lookup, TypeAliasId,
-    VariantId,
-    lang_item::LangItem,
-    signatures::{ImplFlags, StructFlags, TraitFlags},
-};
-
-use crate::{
-    AliasEq, AliasTy, DebruijnIndex, Interner, ProjectionTyExt, QuantifiedWhereClause,
-    Substitution, TraitRefExt, Ty, TyBuilder, TyExt, TyKind, WhereClause,
-    db::HirDatabase,
-    from_assoc_type_id, from_chalk_trait_id,
-    generics::generics,
-    lower::LifetimeElisionKind,
-    make_binders,
-    mapping::{ToChalk, TypeAliasAsValue, from_chalk},
-    to_assoc_type_id, to_chalk_trait_id,
-};
-
-pub(crate) type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum<Interner>;
-pub(crate) type TraitDatum = chalk_solve::rust_ir::TraitDatum<Interner>;
-pub(crate) type AdtDatum = chalk_solve::rust_ir::AdtDatum<Interner>;
-pub(crate) type ImplDatum = chalk_solve::rust_ir::ImplDatum<Interner>;
+use crate::{Interner, Substitution, db::HirDatabase, mapping::from_chalk};
 
 pub(crate) type AssocTypeId = chalk_ir::AssocTypeId<Interner>;
 pub(crate) type TraitId = chalk_ir::TraitId<Interner>;
 pub(crate) type AdtId = chalk_ir::AdtId<Interner>;
 pub(crate) type ImplId = chalk_ir::ImplId<Interner>;
-pub(crate) type AssociatedTyValueId = chalk_solve::rust_ir::AssociatedTyValueId<Interner>;
-pub(crate) type AssociatedTyValue = chalk_solve::rust_ir::AssociatedTyValue<Interner>;
-pub(crate) type FnDefDatum = chalk_solve::rust_ir::FnDefDatum<Interner>;
 pub(crate) type Variances = chalk_ir::Variances<Interner>;
 
 impl chalk_ir::UnificationDatabase<Interner> for &dyn HirDatabase {
@@ -54,340 +23,6 @@ impl chalk_ir::UnificationDatabase<Interner> for &dyn HirDatabase {
     }
 }
 
-pub(crate) fn associated_ty_data_query(
-    db: &dyn HirDatabase,
-    type_alias: TypeAliasId,
-) -> Arc<AssociatedTyDatum> {
-    debug!("associated_ty_data {:?}", type_alias);
-    let trait_ = match type_alias.lookup(db).container {
-        ItemContainerId::TraitId(t) => t,
-        _ => panic!("associated type not in trait"),
-    };
-
-    // Lower bounds -- we could/should maybe move this to a separate query in `lower`
-    let type_alias_data = db.type_alias_signature(type_alias);
-    let generic_params = generics(db, type_alias.into());
-    let resolver = hir_def::resolver::HasResolver::resolver(type_alias, db);
-    let mut ctx = crate::TyLoweringContext::new(
-        db,
-        &resolver,
-        &type_alias_data.store,
-        type_alias.into(),
-        LifetimeElisionKind::AnonymousReportError,
-    )
-    .with_type_param_mode(crate::lower::ParamLoweringMode::Variable);
-
-    let trait_subst = TyBuilder::subst_for_def(db, trait_, None)
-        .fill_with_bound_vars(crate::DebruijnIndex::INNERMOST, 0)
-        .build();
-    let pro_ty = TyBuilder::assoc_type_projection(db, type_alias, Some(trait_subst))
-        .fill_with_bound_vars(
-            crate::DebruijnIndex::INNERMOST,
-            generic_params.parent_generics().map_or(0, |it| it.len()),
-        )
-        .build();
-    let self_ty = TyKind::Alias(AliasTy::Projection(pro_ty)).intern(Interner);
-
-    let mut bounds = Vec::new();
-    for bound in &type_alias_data.bounds {
-        ctx.lower_type_bound(bound, self_ty.clone(), false).for_each(|pred| {
-            if let Some(pred) = generic_predicate_to_inline_bound(db, &pred, &self_ty) {
-                bounds.push(pred);
-            }
-        });
-    }
-
-    if !ctx.unsized_types.contains(&self_ty) {
-        let sized_trait =
-            LangItem::Sized.resolve_trait(db, resolver.krate()).map(to_chalk_trait_id);
-        let sized_bound = sized_trait.into_iter().map(|sized_trait| {
-            let trait_bound =
-                rust_ir::TraitBound { trait_id: sized_trait, args_no_self: Default::default() };
-            let inline_bound = rust_ir::InlineBound::TraitBound(trait_bound);
-            chalk_ir::Binders::empty(Interner, inline_bound)
-        });
-        bounds.extend(sized_bound);
-        bounds.shrink_to_fit();
-    }
-
-    // FIXME: Re-enable where clauses on associated types when an upstream chalk bug is fixed.
-    //        (rust-analyzer#9052)
-    // let where_clauses = convert_where_clauses(db, type_alias.into(), &bound_vars);
-    let bound_data = rust_ir::AssociatedTyDatumBound { bounds, where_clauses: vec![] };
-    let datum = AssociatedTyDatum {
-        trait_id: to_chalk_trait_id(trait_),
-        id: to_assoc_type_id(type_alias),
-        name: type_alias,
-        binders: make_binders(db, &generic_params, bound_data),
-    };
-    Arc::new(datum)
-}
-
-pub(crate) fn trait_datum_query(
-    db: &dyn HirDatabase,
-    krate: Crate,
-    trait_id: TraitId,
-) -> Arc<TraitDatum> {
-    debug!("trait_datum {:?}", trait_id);
-    let trait_ = from_chalk_trait_id(trait_id);
-    let trait_data = db.trait_signature(trait_);
-    debug!("trait {:?} = {:?}", trait_id, trait_data.name);
-    let generic_params = generics(db, trait_.into());
-    let bound_vars = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST);
-    let flags = rust_ir::TraitFlags {
-        auto: trait_data.flags.contains(TraitFlags::AUTO),
-        upstream: trait_.lookup(db).container.krate() != krate,
-        non_enumerable: true,
-        coinductive: false, // only relevant for Chalk testing
-        // FIXME: set these flags correctly
-        marker: false,
-        fundamental: trait_data.flags.contains(TraitFlags::FUNDAMENTAL),
-    };
-    let where_clauses = convert_where_clauses(db, trait_.into(), &bound_vars);
-    let associated_ty_ids =
-        trait_.trait_items(db).associated_types().map(to_assoc_type_id).collect();
-    let trait_datum_bound = rust_ir::TraitDatumBound { where_clauses };
-    let well_known = db.lang_attr(trait_.into()).and_then(well_known_trait_from_lang_item);
-    let trait_datum = TraitDatum {
-        id: trait_id,
-        binders: make_binders(db, &generic_params, trait_datum_bound),
-        flags,
-        associated_ty_ids,
-        well_known,
-    };
-    Arc::new(trait_datum)
-}
-
-fn well_known_trait_from_lang_item(item: LangItem) -> Option<WellKnownTrait> {
-    Some(match item {
-        LangItem::Clone => WellKnownTrait::Clone,
-        LangItem::CoerceUnsized => WellKnownTrait::CoerceUnsized,
-        LangItem::Copy => WellKnownTrait::Copy,
-        LangItem::DiscriminantKind => WellKnownTrait::DiscriminantKind,
-        LangItem::DispatchFromDyn => WellKnownTrait::DispatchFromDyn,
-        LangItem::Drop => WellKnownTrait::Drop,
-        LangItem::Fn => WellKnownTrait::Fn,
-        LangItem::FnMut => WellKnownTrait::FnMut,
-        LangItem::FnOnce => WellKnownTrait::FnOnce,
-        LangItem::AsyncFn => WellKnownTrait::AsyncFn,
-        LangItem::AsyncFnMut => WellKnownTrait::AsyncFnMut,
-        LangItem::AsyncFnOnce => WellKnownTrait::AsyncFnOnce,
-        LangItem::Coroutine => WellKnownTrait::Coroutine,
-        LangItem::Sized => WellKnownTrait::Sized,
-        LangItem::Unpin => WellKnownTrait::Unpin,
-        LangItem::Unsize => WellKnownTrait::Unsize,
-        LangItem::Tuple => WellKnownTrait::Tuple,
-        LangItem::PointeeTrait => WellKnownTrait::Pointee,
-        LangItem::FnPtrTrait => WellKnownTrait::FnPtr,
-        LangItem::Future => WellKnownTrait::Future,
-        _ => return None,
-    })
-}
-
-pub(crate) fn adt_datum_query(
-    db: &dyn HirDatabase,
-    krate: Crate,
-    chalk_ir::AdtId(adt_id): AdtId,
-) -> Arc<AdtDatum> {
-    debug!("adt_datum {:?}", adt_id);
-    let generic_params = generics(db, adt_id.into());
-    let bound_vars_subst = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST);
-    let where_clauses = convert_where_clauses(db, adt_id.into(), &bound_vars_subst);
-
-    let (fundamental, phantom_data) = match adt_id {
-        hir_def::AdtId::StructId(s) => {
-            let flags = db.struct_signature(s).flags;
-            (flags.contains(StructFlags::FUNDAMENTAL), flags.contains(StructFlags::IS_PHANTOM_DATA))
-        }
-        // FIXME set fundamental flags correctly
-        hir_def::AdtId::UnionId(_) => (false, false),
-        hir_def::AdtId::EnumId(_) => (false, false),
-    };
-    let flags = rust_ir::AdtFlags {
-        upstream: adt_id.module(db).krate() != krate,
-        fundamental,
-        phantom_data,
-    };
-
-    // this slows down rust-analyzer by quite a bit unfortunately, so enabling this is currently not worth it
-    let _variant_id_to_fields = |id: VariantId| {
-        let variant_data = &id.fields(db);
-        let fields = if variant_data.fields().is_empty() {
-            vec![]
-        } else {
-            let field_types = db.field_types(id);
-            variant_data
-                .fields()
-                .iter()
-                .map(|(idx, _)| field_types[idx].clone().substitute(Interner, &bound_vars_subst))
-                .filter(|it| !it.contains_unknown())
-                .collect()
-        };
-        rust_ir::AdtVariantDatum { fields }
-    };
-    let variant_id_to_fields = |_: VariantId| rust_ir::AdtVariantDatum { fields: vec![] };
-
-    let (kind, variants) = match adt_id {
-        hir_def::AdtId::StructId(id) => {
-            (rust_ir::AdtKind::Struct, vec![variant_id_to_fields(id.into())])
-        }
-        hir_def::AdtId::EnumId(id) => {
-            let variants = id
-                .enum_variants(db)
-                .variants
-                .iter()
-                .map(|&(variant_id, _, _)| variant_id_to_fields(variant_id.into()))
-                .collect();
-            (rust_ir::AdtKind::Enum, variants)
-        }
-        hir_def::AdtId::UnionId(id) => {
-            (rust_ir::AdtKind::Union, vec![variant_id_to_fields(id.into())])
-        }
-    };
-
-    let struct_datum_bound = rust_ir::AdtDatumBound { variants, where_clauses };
-    let struct_datum = AdtDatum {
-        kind,
-        id: chalk_ir::AdtId(adt_id),
-        binders: make_binders(db, &generic_params, struct_datum_bound),
-        flags,
-    };
-    Arc::new(struct_datum)
-}
-
-pub(crate) fn impl_datum_query(
-    db: &dyn HirDatabase,
-    krate: Crate,
-    impl_id: ImplId,
-) -> Arc<ImplDatum> {
-    let _p = tracing::info_span!("impl_datum_query").entered();
-    debug!("impl_datum {:?}", impl_id);
-    let impl_: hir_def::ImplId = from_chalk(db, impl_id);
-    impl_def_datum(db, krate, impl_)
-}
-
-fn impl_def_datum(db: &dyn HirDatabase, krate: Crate, impl_id: hir_def::ImplId) -> Arc<ImplDatum> {
-    let trait_ref = db
-        .impl_trait(impl_id)
-        // ImplIds for impls where the trait ref can't be resolved should never reach Chalk
-        .expect("invalid impl passed to Chalk")
-        .into_value_and_skipped_binders()
-        .0;
-    let impl_data = db.impl_signature(impl_id);
-
-    let generic_params = generics(db, impl_id.into());
-    let bound_vars = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST);
-    let trait_ = trait_ref.hir_trait_id();
-    let impl_type = if impl_id.lookup(db).container.krate() == krate {
-        rust_ir::ImplType::Local
-    } else {
-        rust_ir::ImplType::External
-    };
-    let where_clauses = convert_where_clauses(db, impl_id.into(), &bound_vars);
-    let negative = impl_data.flags.contains(ImplFlags::NEGATIVE);
-    let polarity = if negative { rust_ir::Polarity::Negative } else { rust_ir::Polarity::Positive };
-
-    let impl_datum_bound = rust_ir::ImplDatumBound { trait_ref, where_clauses };
-    let trait_data = trait_.trait_items(db);
-    let associated_ty_value_ids = impl_id
-        .impl_items(db)
-        .items
-        .iter()
-        .filter_map(|(_, item)| match item {
-            AssocItemId::TypeAliasId(type_alias) => Some(*type_alias),
-            _ => None,
-        })
-        .filter(|&type_alias| {
-            // don't include associated types that don't exist in the trait
-            let name = &db.type_alias_signature(type_alias).name;
-            trait_data.associated_type_by_name(name).is_some()
-        })
-        .map(|type_alias| TypeAliasAsValue(type_alias).to_chalk(db))
-        .collect();
-    debug!("impl_datum: {:?}", impl_datum_bound);
-    let impl_datum = ImplDatum {
-        binders: make_binders(db, &generic_params, impl_datum_bound),
-        impl_type,
-        polarity,
-        associated_ty_value_ids,
-    };
-    Arc::new(impl_datum)
-}
-
-pub(crate) fn associated_ty_value_query(
-    db: &dyn HirDatabase,
-    krate: Crate,
-    id: AssociatedTyValueId,
-) -> Arc<AssociatedTyValue> {
-    let type_alias: TypeAliasAsValue = from_chalk(db, id);
-    type_alias_associated_ty_value(db, krate, type_alias.0)
-}
-
-fn type_alias_associated_ty_value(
-    db: &dyn HirDatabase,
-    _krate: Crate,
-    type_alias: TypeAliasId,
-) -> Arc<AssociatedTyValue> {
-    let type_alias_data = db.type_alias_signature(type_alias);
-    let impl_id = match type_alias.lookup(db).container {
-        ItemContainerId::ImplId(it) => it,
-        _ => panic!("assoc ty value should be in impl"),
-    };
-
-    let trait_ref = db
-        .impl_trait(impl_id)
-        .expect("assoc ty value should not exist")
-        .into_value_and_skipped_binders()
-        .0; // we don't return any assoc ty values if the impl'd trait can't be resolved
-
-    let assoc_ty = trait_ref
-        .hir_trait_id()
-        .trait_items(db)
-        .associated_type_by_name(&type_alias_data.name)
-        .expect("assoc ty value should not exist"); // validated when building the impl data as well
-    let (ty, binders) = db.ty(type_alias.into()).into_value_and_skipped_binders();
-    let value_bound = rust_ir::AssociatedTyValueBound { ty };
-    let value = rust_ir::AssociatedTyValue {
-        impl_id: impl_id.to_chalk(db),
-        associated_ty_id: to_assoc_type_id(assoc_ty),
-        value: chalk_ir::Binders::new(binders, value_bound),
-    };
-    Arc::new(value)
-}
-
-pub(crate) fn fn_def_datum_query(
-    db: &dyn HirDatabase,
-    callable_def: CallableDefId,
-) -> Arc<FnDefDatum> {
-    let generic_def = GenericDefId::from_callable(db, callable_def);
-    let generic_params = generics(db, generic_def);
-    let (sig, binders) = db.callable_item_signature(callable_def).into_value_and_skipped_binders();
-    let bound_vars = generic_params.bound_vars_subst(db, DebruijnIndex::INNERMOST);
-    let where_clauses = convert_where_clauses(db, generic_def, &bound_vars);
-    let bound = rust_ir::FnDefDatumBound {
-        // Note: Chalk doesn't actually use this information yet as far as I am aware, but we provide it anyway
-        inputs_and_output: chalk_ir::Binders::empty(
-            Interner,
-            rust_ir::FnDefInputsAndOutputDatum {
-                argument_types: sig.params().to_vec(),
-                return_type: sig.ret().clone(),
-            }
-            .shifted_in(Interner),
-        ),
-        where_clauses,
-    };
-    let datum = FnDefDatum {
-        id: callable_def.to_chalk(db),
-        sig: chalk_ir::FnSig {
-            abi: sig.abi,
-            safety: chalk_ir::Safety::Safe,
-            variadic: sig.is_varargs,
-        },
-        binders: chalk_ir::Binders::new(binders, bound),
-    };
-    Arc::new(datum)
-}
-
 pub(crate) fn fn_def_variance_query(
     db: &dyn HirDatabase,
     callable_def: CallableDefId,
@@ -431,59 +66,3 @@ pub(super) fn convert_where_clauses(
         .map(|pred| pred.substitute(Interner, substs))
         .collect()
 }
-
-pub(super) fn generic_predicate_to_inline_bound(
-    db: &dyn HirDatabase,
-    pred: &QuantifiedWhereClause,
-    self_ty: &Ty,
-) -> Option<chalk_ir::Binders<rust_ir::InlineBound<Interner>>> {
-    // An InlineBound is like a GenericPredicate, except the self type is left out.
-    // We don't have a special type for this, but Chalk does.
-    let self_ty_shifted_in = self_ty.clone().shifted_in_from(Interner, DebruijnIndex::ONE);
-    let (pred, binders) = pred.as_ref().into_value_and_skipped_binders();
-    match pred {
-        WhereClause::Implemented(trait_ref) => {
-            if trait_ref.self_type_parameter(Interner) != self_ty_shifted_in {
-                // we can only convert predicates back to type bounds if they
-                // have the expected self type
-                return None;
-            }
-            let args_no_self = trait_ref.substitution.as_slice(Interner)[1..]
-                .iter()
-                .cloned()
-                .casted(Interner)
-                .collect();
-            let trait_bound = rust_ir::TraitBound { trait_id: trait_ref.trait_id, args_no_self };
-            Some(chalk_ir::Binders::new(binders, rust_ir::InlineBound::TraitBound(trait_bound)))
-        }
-        WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(projection_ty), ty }) => {
-            let generics = generics(db, from_assoc_type_id(projection_ty.associated_ty_id).into());
-            let parent_len = generics.parent_generics().map_or(0, |g| g.len_self());
-            let (trait_args, assoc_args) =
-                projection_ty.substitution.as_slice(Interner).split_at(parent_len);
-            let (self_ty, args_no_self) =
-                trait_args.split_first().expect("projection without trait self type");
-            if self_ty.assert_ty_ref(Interner) != &self_ty_shifted_in {
-                return None;
-            }
-
-            let args_no_self = args_no_self.iter().cloned().casted(Interner).collect();
-            let parameters = assoc_args.to_vec();
-
-            let alias_eq_bound = rust_ir::AliasEqBound {
-                value: ty.clone(),
-                trait_bound: rust_ir::TraitBound {
-                    trait_id: to_chalk_trait_id(projection_ty.trait_(db)),
-                    args_no_self,
-                },
-                associated_ty_id: projection_ty.associated_ty_id,
-                parameters,
-            };
-            Some(chalk_ir::Binders::new(
-                binders,
-                rust_ir::InlineBound::AliasEqBound(alias_eq_bound),
-            ))
-        }
-        _ => None,
-    }
-}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
index 9affd3b48c587..97754f47233b2 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
@@ -1,8 +1,6 @@
 //! The home of `HirDatabase`, which is the Salsa database containing all the
 //! type inference-related queries.
 
-use std::sync;
-
 use base_db::Crate;
 use hir_def::{
     AdtId, BlockId, CallableDefId, ConstParamId, DefWithBodyId, EnumVariantId, FunctionId,
@@ -240,26 +238,6 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
     #[salsa::interned]
     fn intern_coroutine(&self, id: InternedCoroutine) -> InternedCoroutineId;
 
-    #[salsa::invoke(chalk_db::associated_ty_data_query)]
-    fn associated_ty_data(&self, id: TypeAliasId) -> sync::Arc<chalk_db::AssociatedTyDatum>;
-
-    #[salsa::invoke(chalk_db::trait_datum_query)]
-    fn trait_datum(
-        &self,
-        krate: Crate,
-        trait_id: chalk_db::TraitId,
-    ) -> sync::Arc<chalk_db::TraitDatum>;
-
-    #[salsa::invoke(chalk_db::adt_datum_query)]
-    fn adt_datum(&self, krate: Crate, struct_id: chalk_db::AdtId) -> sync::Arc<chalk_db::AdtDatum>;
-
-    #[salsa::invoke(chalk_db::impl_datum_query)]
-    fn impl_datum(&self, krate: Crate, impl_id: chalk_db::ImplId)
-    -> sync::Arc<chalk_db::ImplDatum>;
-
-    #[salsa::invoke(chalk_db::fn_def_datum_query)]
-    fn fn_def_datum(&self, fn_def_id: CallableDefId) -> sync::Arc<chalk_db::FnDefDatum>;
-
     #[salsa::invoke(chalk_db::fn_def_variance_query)]
     fn fn_def_variance(&self, fn_def_id: CallableDefId) -> chalk_db::Variances;
 
@@ -274,13 +252,6 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
     )]
     fn variances_of(&self, def: GenericDefId) -> Option<Arc<[crate::variance::Variance]>>;
 
-    #[salsa::invoke(chalk_db::associated_ty_value_query)]
-    fn associated_ty_value(
-        &self,
-        krate: Crate,
-        id: chalk_db::AssociatedTyValueId,
-    ) -> sync::Arc<chalk_db::AssociatedTyValue>;
-
     #[salsa::invoke(crate::traits::normalize_projection_query)]
     #[salsa::transparent]
     fn normalize_projection(
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/expr.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/expr.rs
index b26bd2b8fa9c4..403ea05a4f53c 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/expr.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/expr.rs
@@ -5,7 +5,6 @@
 use std::fmt;
 
 use base_db::Crate;
-use chalk_solve::rust_ir::AdtKind;
 use either::Either;
 use hir_def::{
     AdtId, AssocItemId, DefWithBodyId, HasModule, ItemContainerId, Lookup,
@@ -300,11 +299,7 @@ impl ExprValidator {
                 value_or_partial.is_none_or(|v| !matches!(v, ValueNs::StaticId(_)))
             }
             Expr::Field { expr, .. } => match self.infer.type_of_expr[*expr].kind(Interner) {
-                TyKind::Adt(adt, ..)
-                    if db.adt_datum(self.owner.krate(db), *adt).kind == AdtKind::Union =>
-                {
-                    false
-                }
+                TyKind::Adt(adt, ..) if matches!(adt.0, AdtId::UnionId(_)) => false,
                 _ => self.is_known_valid_scrutinee(*expr, db),
             },
             Expr::Index { base, .. } => self.is_known_valid_scrutinee(*base, db),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs
index f0a4167f8e250..09b983a580d97 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs
@@ -1,12 +1,12 @@
 //! Type cast logic. Basically coercion + additional casts.
 
 use chalk_ir::{Mutability, Scalar, TyVariableKind, UintTy};
-use hir_def::{AdtId, hir::ExprId};
+use hir_def::{AdtId, hir::ExprId, signatures::TraitFlags};
 use stdx::never;
 
 use crate::{
     Adjustment, Binders, DynTy, InferenceDiagnostic, Interner, PlaceholderIndex,
-    QuantifiedWhereClauses, Ty, TyExt, TyKind, TypeFlags, WhereClause,
+    QuantifiedWhereClauses, Ty, TyExt, TyKind, TypeFlags, WhereClause, from_chalk_trait_id,
     infer::{coerce::CoerceNever, unify::InferenceTable},
 };
 
@@ -290,10 +290,12 @@ impl CastCheck {
                             return Ok(());
                         }
                         let src_principal =
-                            table.db.trait_datum(table.trait_env.krate, src_principal);
+                            table.db.trait_signature(from_chalk_trait_id(src_principal));
                         let dst_principal =
-                            table.db.trait_datum(table.trait_env.krate, dst_principal);
-                        if src_principal.is_auto_trait() && dst_principal.is_auto_trait() {
+                            table.db.trait_signature(from_chalk_trait_id(dst_principal));
+                        if src_principal.flags.contains(TraitFlags::AUTO)
+                            && dst_principal.flags.contains(TraitFlags::AUTO)
+                        {
                             Ok(())
                         } else {
                             Err(CastError::DifferingKinds)
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
index d8fc20e8741cd..38ac2e1170773 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
@@ -9,7 +9,6 @@ use chalk_ir::{
     visit::{TypeSuperVisitable, TypeVisitable, TypeVisitor},
 };
 use either::Either;
-use hir_def::Lookup;
 use hir_def::{
     DefWithBodyId, FieldId, HasModule, TupleFieldId, TupleId, VariantId,
     expr_store::path::Path,
@@ -22,6 +21,7 @@ use hir_def::{
     resolver::ValueNs,
     type_ref::TypeRefId,
 };
+use hir_def::{ItemContainerId, Lookup, TraitId};
 use hir_expand::name::Name;
 use intern::sym;
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -30,16 +30,16 @@ use stdx::{format_to, never};
 use syntax::utils::is_raw_identifier;
 
 use crate::{
-    Adjust, Adjustment, AliasEq, AliasTy, Binders, BindingMode, ChalkTraitId, ClosureId, DynTy,
-    DynTyExt, FnAbi, FnPointer, FnSig, Interner, OpaqueTy, ProjectionTy, ProjectionTyExt,
-    Substitution, Ty, TyBuilder, TyExt, WhereClause,
+    Adjust, Adjustment, AliasEq, AliasTy, Binders, BindingMode, ClosureId, DynTy, DynTyExt, FnAbi,
+    FnPointer, FnSig, Interner, OpaqueTy, ProjectionTy, ProjectionTyExt, Substitution, Ty,
+    TyBuilder, TyExt, WhereClause,
     db::{HirDatabase, InternedClosure, InternedCoroutine},
     error_lifetime, from_assoc_type_id, from_chalk_trait_id, from_placeholder_idx,
     generics::Generics,
     infer::{BreakableKind, CoerceMany, Diverges, coerce::CoerceNever},
     make_binders,
     mir::{BorrowKind, MirSpan, MutBorrowKind, ProjectionElem},
-    to_assoc_type_id, to_chalk_trait_id,
+    to_assoc_type_id,
     traits::FnTrait,
     utils::{self, elaborate_clause_supertraits},
 };
@@ -321,10 +321,8 @@ impl InferenceContext<'_> {
     fn deduce_sig_from_dyn_ty(&self, dyn_ty: &DynTy) -> Option<FnPointer> {
         // Search for a predicate like `<$self as FnX<Args>>::Output == Ret`
 
-        let fn_traits: SmallVec<[ChalkTraitId; 3]> =
-            utils::fn_traits(self.db, self.owner.module(self.db).krate())
-                .map(to_chalk_trait_id)
-                .collect();
+        let fn_traits: SmallVec<[TraitId; 3]> =
+            utils::fn_traits(self.db, self.owner.module(self.db).krate()).collect();
 
         let self_ty = self.result.standard_types.unknown.clone();
         let bounds = dyn_ty.bounds.clone().substitute(Interner, &[self_ty.cast(Interner)]);
@@ -333,9 +331,13 @@ impl InferenceContext<'_> {
             if let WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(projection), ty }) =
                 bound.skip_binders()
             {
-                let assoc_data =
-                    self.db.associated_ty_data(from_assoc_type_id(projection.associated_ty_id));
-                if !fn_traits.contains(&assoc_data.trait_id) {
+                let trait_ =
+                    match from_assoc_type_id(projection.associated_ty_id).lookup(self.db).container
+                    {
+                        ItemContainerId::TraitId(t) => t,
+                        _ => panic!("associated type not in trait"),
+                    };
+                if !fn_traits.contains(&trait_) {
                     return None;
                 }
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mapping.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mapping.rs
index 9d3d2044c43e4..448fbdf673655 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mapping.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mapping.rs
@@ -3,8 +3,6 @@
 //! Chalk (in both directions); plus some helper functions for more specialized
 //! conversions.
 
-use chalk_solve::rust_ir;
-
 use hir_def::{LifetimeParamId, TraitId, TypeAliasId, TypeOrConstParamId};
 use salsa::{
     Id,
@@ -54,23 +52,6 @@ impl ToChalk for CallableDefId {
     }
 }
 
-pub(crate) struct TypeAliasAsValue(pub(crate) TypeAliasId);
-
-impl ToChalk for TypeAliasAsValue {
-    type Chalk = chalk_db::AssociatedTyValueId;
-
-    fn to_chalk(self, _db: &dyn HirDatabase) -> chalk_db::AssociatedTyValueId {
-        rust_ir::AssociatedTyValueId(self.0.as_id())
-    }
-
-    fn from_chalk(
-        _db: &dyn HirDatabase,
-        assoc_ty_value_id: chalk_db::AssociatedTyValueId,
-    ) -> TypeAliasAsValue {
-        TypeAliasAsValue(TypeAliasId::from_id(assoc_ty_value_id.0))
-    }
-}
-
 impl From<OpaqueTyId> for crate::db::InternedOpaqueTyId {
     fn from(id: OpaqueTyId) -> Self {
         FromId::from_id(id.0)
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index ff7d116dcce3e..f03f542e5bce3 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -66,7 +66,7 @@ use hir_def::{
     },
     per_ns::PerNs,
     resolver::{HasResolver, Resolver},
-    signatures::{ImplFlags, StaticFlags, TraitFlags, VariantFields},
+    signatures::{ImplFlags, StaticFlags, StructFlags, TraitFlags, VariantFields},
     src::HasSource as _,
     visibility::visibility_from_ast,
 };
@@ -4945,42 +4945,79 @@ impl<'db> Type<'db> {
     }
 
     pub fn contains_reference(&self, db: &'db dyn HirDatabase) -> bool {
-        return go(db, self.env.krate, &self.ty);
+        return go(db, &self.ty);
 
-        fn go(db: &dyn HirDatabase, krate: base_db::Crate, ty: &Ty) -> bool {
+        fn is_phantom_data(db: &dyn HirDatabase, adt_id: AdtId) -> bool {
+            match adt_id {
+                hir_def::AdtId::StructId(s) => {
+                    let flags = db.struct_signature(s).flags;
+                    flags.contains(StructFlags::IS_PHANTOM_DATA)
+                }
+                hir_def::AdtId::UnionId(_) => false,
+                hir_def::AdtId::EnumId(_) => false,
+            }
+        }
+
+        fn go(db: &dyn HirDatabase, ty: &Ty) -> bool {
             match ty.kind(Interner) {
                 // Reference itself
                 TyKind::Ref(_, _, _) => true,
 
                 // For non-phantom_data adts we check variants/fields as well as generic parameters
-                TyKind::Adt(adt_id, substitution)
-                    if !db.adt_datum(krate, *adt_id).flags.phantom_data =>
-                {
-                    let adt_datum = &db.adt_datum(krate, *adt_id);
-                    let adt_datum_bound =
-                        adt_datum.binders.clone().substitute(Interner, substitution);
-                    adt_datum_bound
-                        .variants
+                TyKind::Adt(adt_id, substitution) if !is_phantom_data(db, adt_id.0) => {
+                    let _variant_id_to_fields = |id: VariantId| {
+                        let variant_data = &id.fields(db);
+                        if variant_data.fields().is_empty() {
+                            vec![]
+                        } else {
+                            let field_types = db.field_types(id);
+                            variant_data
+                                .fields()
+                                .iter()
+                                .map(|(idx, _)| {
+                                    field_types[idx].clone().substitute(Interner, substitution)
+                                })
+                                .filter(|it| !it.contains_unknown())
+                                .collect()
+                        }
+                    };
+                    let variant_id_to_fields = |_: VariantId| vec![];
+
+                    let variants = match adt_id.0 {
+                        hir_def::AdtId::StructId(id) => {
+                            vec![variant_id_to_fields(id.into())]
+                        }
+                        hir_def::AdtId::EnumId(id) => id
+                            .enum_variants(db)
+                            .variants
+                            .iter()
+                            .map(|&(variant_id, _, _)| variant_id_to_fields(variant_id.into()))
+                            .collect(),
+                        hir_def::AdtId::UnionId(id) => {
+                            vec![variant_id_to_fields(id.into())]
+                        }
+                    };
+
+                    variants
                         .into_iter()
-                        .flat_map(|variant| variant.fields.into_iter())
-                        .any(|ty| go(db, krate, &ty))
+                        .flat_map(|variant| variant.into_iter())
+                        .any(|ty| go(db, &ty))
                         || substitution
                             .iter(Interner)
                             .filter_map(|x| x.ty(Interner))
-                            .any(|ty| go(db, krate, ty))
+                            .any(|ty| go(db, ty))
                 }
                 // And for `PhantomData<T>`, we check `T`.
                 TyKind::Adt(_, substitution)
                 | TyKind::Tuple(_, substitution)
                 | TyKind::OpaqueType(_, substitution)
                 | TyKind::AssociatedType(_, substitution)
-                | TyKind::FnDef(_, substitution) => substitution
-                    .iter(Interner)
-                    .filter_map(|x| x.ty(Interner))
-                    .any(|ty| go(db, krate, ty)),
+                | TyKind::FnDef(_, substitution) => {
+                    substitution.iter(Interner).filter_map(|x| x.ty(Interner)).any(|ty| go(db, ty))
+                }
 
                 // For `[T]` or `*T` we check `T`
-                TyKind::Array(ty, _) | TyKind::Slice(ty) | TyKind::Raw(_, ty) => go(db, krate, ty),
+                TyKind::Array(ty, _) | TyKind::Slice(ty) | TyKind::Raw(_, ty) => go(db, ty),
 
                 // Consider everything else as not reference
                 _ => false,

From 5c893461719c3d4da1201a0080b60f1ca95c5c88 Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Fri, 15 Aug 2025 04:36:53 +0000
Subject: [PATCH 0112/1889] Add new_empty_tuple

---
 src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs       | 4 ++--
 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs | 5 +++++
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
index 9deaa4ac5a6b5..c60ace85be124 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
@@ -25,7 +25,7 @@ use rustc_apfloat::{
     ieee::{Half as f16, Quad as f128},
 };
 use rustc_hash::{FxHashMap, FxHashSet};
-use rustc_type_ir::inherent::{AdtDef, IntoKind, SliceLike, Ty as _};
+use rustc_type_ir::inherent::{AdtDef, IntoKind, SliceLike};
 use span::FileId;
 use stdx::never;
 use syntax::{SyntaxNodePtr, TextRange};
@@ -1815,7 +1815,7 @@ impl<'db> Evaluator<'db> {
             let i = self.const_eval_discriminant(it)?;
             return Ok((
                 16,
-                self.layout(crate::next_solver::Ty::new_tup(interner, &[]))?,
+                self.layout(crate::next_solver::Ty::new_empty_tuple(interner))?,
                 Some((0, 16, i)),
             ));
         }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
index 0c0fe686b77d1..5ffae981a6094 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
@@ -9,6 +9,7 @@ use rustc_type_ir::{
     WithCachedTypeInfo,
     inherent::{
         AdtDef, BoundVarLike, GenericArgs as _, IntoKind, ParamLike, PlaceholderLike, SliceLike,
+        Ty as _,
     },
     relate::Relate,
     solve::SizedTraitKind,
@@ -107,6 +108,10 @@ impl<'db> Ty<'db> {
         Ty::new_infer(interner, InferTy::FreshFloatTy(n))
     }
 
+    pub fn new_empty_tuple(interner: DbInterner<'db>) -> Self {
+        Ty::new_tup(interner, &[])
+    }
+
     /// Returns the `Size` for primitive types (bool, uint, int, char, float).
     pub fn primitive_size(self, interner: DbInterner<'db>) -> Size {
         match self.kind() {

From 0e2b63cd875e0496b3a2da237282e02333b632ee Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Fri, 15 Aug 2025 04:38:50 +0000
Subject: [PATCH 0113/1889] Update fixme

---
 src/tools/rust-analyzer/crates/hir-ty/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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 2f8eb627462b7..7fdfb205721ec 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
@@ -292,7 +292,7 @@ impl<'db> MemoryMap<'db> {
     }
 }
 
-// FIXME(next-solver):
+// FIXME(next-solver): add a lifetime to this
 /// A concrete constant value
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ConstScalar {

From 3e41e85b2761bbe21169e7dd72cb959fb63a31fa Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Fri, 15 Aug 2025 04:41:23 +0000
Subject: [PATCH 0114/1889] Add fixme to associated_ty_item_bounds

---
 src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
index 2777869bd48e5..99411e4ab138c 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
@@ -1594,6 +1594,7 @@ fn fn_sig_for_enum_variant_constructor<'db>(
     }))
 }
 
+// FIXME(next-solver): should merge this with `explicit_item_bounds` in some way
 pub(crate) fn associated_ty_item_bounds<'db>(
     db: &'db dyn HirDatabase,
     type_alias: TypeAliasId,

From 058a398f9fd11783aa62691bfb4b029c1a3d313c Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Fri, 15 Aug 2025 04:50:21 +0000
Subject: [PATCH 0115/1889] Add FIXME in
 named_associated_type_shorthand_candidates

---
 src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
index 99411e4ab138c..7a2bd37bce6d4 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
@@ -1782,6 +1782,9 @@ fn named_associated_type_shorthand_candidates<'db, R>(
         TypeNs::SelfType(impl_id) => {
             let trait_ref = db.impl_trait_ns(impl_id)?;
 
+            // FIXME(next-solver): same method in `lower` checks for impl or not
+            // Is that needed here?
+
             // we're _in_ the impl -- the binders get added back later. Correct,
             // but it would be nice to make this more explicit
             search(trait_ref.skip_binder())

From 3486a2c3e735d51750e1127607eefcf0496a4d00 Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Fri, 15 Aug 2025 04:52:12 +0000
Subject: [PATCH 0116/1889] Remove fixme comment

---
 src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
index 7a2bd37bce6d4..ce953fdcb8298 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
@@ -1793,7 +1793,6 @@ fn named_associated_type_shorthand_candidates<'db, R>(
             // Handle `Self::Type` referring to own associated type in trait definitions
             // This *must* be done first to avoid cycles with
             // `generic_predicates_for_param`, but not sure that it's sufficient,
-            // see FIXME in `search`.
             if let GenericDefId::TraitId(trait_id) = param_id.parent() {
                 let trait_name = &db.trait_signature(trait_id).name;
                 tracing::debug!(?trait_name);

From b9d225b6d8dff5eaccf8bac4ab969ab1fe98ea6d Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukas@zed.dev>
Date: Sat, 16 Aug 2025 16:26:30 +0200
Subject: [PATCH 0117/1889] Auto-attach database in `Analysis` calls

---
 .../hir-ty/src/next_solver/generic_arg.rs     |  2 +-
 .../crates/ide-assists/src/lib.rs             |  9 +--
 .../crates/ide-assists/src/tests.rs           | 17 ++++-
 .../crates/ide-completion/src/lib.rs          |  5 +-
 .../crates/ide-completion/src/tests.rs        |  6 +-
 .../crates/ide-diagnostics/src/lib.rs         | 12 ++-
 .../crates/ide-diagnostics/src/tests.rs       | 75 ++++++++++++-------
 .../crates/ide/src/goto_definition.rs         |  4 +-
 .../rust-analyzer/crates/ide/src/hover.rs     | 43 +++++------
 .../crates/ide/src/hover/render.rs            |  5 +-
 src/tools/rust-analyzer/crates/ide/src/lib.rs | 57 +++++++++-----
 .../crates/parser/src/lexed_str.rs            |  3 +-
 12 files changed, 137 insertions(+), 101 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generic_arg.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generic_arg.rs
index 834f4e3765ee8..76186e374608e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generic_arg.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generic_arg.rs
@@ -46,7 +46,7 @@ impl<'db> GenericArg<'db> {
     pub fn expect_ty(self) -> Ty<'db> {
         match self.kind() {
             GenericArgKind::Type(ty) => ty,
-            _ => panic!("Expected ty, got {:?}", self),
+            _ => panic!("Expected ty, got {self:?}"),
         }
     }
 
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/lib.rs b/src/tools/rust-analyzer/crates/ide-assists/src/lib.rs
index 5008f97447b76..4682c04732389 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/lib.rs
@@ -67,7 +67,7 @@ mod tests;
 pub mod utils;
 
 use hir::Semantics;
-use ide_db::{EditionedFileId, RootDatabase, base_db::salsa};
+use ide_db::{EditionedFileId, RootDatabase};
 use syntax::{Edition, TextRange};
 
 pub(crate) use crate::assist_context::{AssistContext, Assists};
@@ -93,11 +93,8 @@ pub fn assists(
         .unwrap_or_else(|| EditionedFileId::new(db, range.file_id, Edition::CURRENT));
     let ctx = AssistContext::new(sema, config, hir::FileRange { file_id, range: range.range });
     let mut acc = Assists::new(&ctx, resolve);
-    // the handlers may invoke trait solving related things which accesses salsa structs outside queries
-    salsa::attach(db, || {
-        handlers::all().iter().for_each(|handler| {
-            handler(&mut acc, &ctx);
-        });
+    handlers::all().iter().for_each(|handler| {
+        handler(&mut acc, &ctx);
     });
     acc.finish()
 }
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/tests.rs b/src/tools/rust-analyzer/crates/ide-assists/src/tests.rs
index f4daabfe915d7..c7c322a15e541 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/tests.rs
@@ -1,7 +1,7 @@
 mod generated;
 
 use expect_test::expect;
-use hir::{Semantics, setup_tracing};
+use hir::{Semantics, db::HirDatabase, setup_tracing};
 use ide_db::{
     EditionedFileId, FileRange, RootDatabase, SnippetCap,
     assists::ExprFillDefaultMode,
@@ -16,7 +16,7 @@ use test_utils::{assert_eq_text, extract_offset};
 
 use crate::{
     Assist, AssistConfig, AssistContext, AssistKind, AssistResolveStrategy, Assists, SingleResolve,
-    assists, handlers::Handler,
+    handlers::Handler,
 };
 
 pub(crate) const TEST_CONFIG: AssistConfig = AssistConfig {
@@ -103,6 +103,18 @@ pub(crate) const TEST_CONFIG_IMPORT_ONE: AssistConfig = AssistConfig {
     prefer_self_ty: false,
 };
 
+fn assists(
+    db: &RootDatabase,
+    config: &AssistConfig,
+    resolve: AssistResolveStrategy,
+    range: ide_db::FileRange,
+) -> Vec<Assist> {
+    salsa::attach(db, || {
+        HirDatabase::zalsa_register_downcaster(db);
+        crate::assists(db, config, resolve, range)
+    })
+}
+
 pub(crate) fn with_single_file(text: &str) -> (RootDatabase, EditionedFileId) {
     RootDatabase::with_single_file(text)
 }
@@ -320,6 +332,7 @@ fn check_with_config(
     };
     let mut acc = Assists::new(&ctx, resolve);
     salsa::attach(&db, || {
+        HirDatabase::zalsa_register_downcaster(&db);
         handler(&mut acc, &ctx);
     });
     let mut res = acc.finish();
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/lib.rs b/src/tools/rust-analyzer/crates/ide-completion/src/lib.rs
index 1a4c97e70b4ae..a70a1138d2f42 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/lib.rs
@@ -10,7 +10,6 @@ mod snippet;
 #[cfg(test)]
 mod tests;
 
-use base_db::salsa;
 use ide_db::{
     FilePosition, FxHashSet, RootDatabase,
     imports::insert_use::{self, ImportScope},
@@ -229,7 +228,7 @@ pub fn completions(
     {
         let acc = &mut completions;
 
-        salsa::attach(db, || match analysis {
+        match analysis {
             CompletionAnalysis::Name(name_ctx) => completions::complete_name(acc, ctx, name_ctx),
             CompletionAnalysis::NameRef(name_ref_ctx) => {
                 completions::complete_name_ref(acc, ctx, name_ref_ctx)
@@ -257,7 +256,7 @@ pub fn completions(
                 );
             }
             CompletionAnalysis::UnexpandedAttrTT { .. } | CompletionAnalysis::String { .. } => (),
-        })
+        }
     }
 
     Some(completions.into())
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/tests.rs b/src/tools/rust-analyzer/crates/ide-completion/src/tests.rs
index 4b3b271ca20ef..809a26bf5de47 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/tests.rs
@@ -24,7 +24,7 @@ mod type_pos;
 mod use_tree;
 mod visibility;
 
-use base_db::SourceDatabase;
+use base_db::{SourceDatabase, salsa};
 use expect_test::Expect;
 use hir::{PrefixKind, setup_tracing};
 use ide_db::{
@@ -243,7 +243,7 @@ pub(crate) fn check_edit_with_config(
     let ra_fixture_after = trim_indent(ra_fixture_after);
     let (db, position) = position(ra_fixture_before);
     let completions: Vec<CompletionItem> =
-        crate::completions(&db, &config, position, None).unwrap();
+        salsa::attach(&db, || crate::completions(&db, &config, position, None).unwrap());
     let (completion,) = completions
         .iter()
         .filter(|it| it.lookup() == what)
@@ -306,7 +306,7 @@ pub(crate) fn get_all_items(
     trigger_character: Option<char>,
 ) -> Vec<CompletionItem> {
     let (db, position) = position(code);
-    let res = crate::completions(&db, &config, position, trigger_character)
+    let res = salsa::attach(&db, || crate::completions(&db, &config, position, trigger_character))
         .map_or_else(Vec::default, Into::into);
     // validate
     res.iter().for_each(|it| {
diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/lib.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/lib.rs
index a4eb3d47d708b..a1db92641f5ee 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/lib.rs
@@ -92,7 +92,7 @@ use hir::{
 use ide_db::{
     EditionedFileId, FileId, FileRange, FxHashMap, FxHashSet, RootDatabase, Severity, SnippetCap,
     assists::{Assist, AssistId, AssistResolveStrategy, ExprFillDefaultMode},
-    base_db::{ReleaseChannel, RootQueryDb as _, salsa},
+    base_db::{ReleaseChannel, RootQueryDb as _},
     generated::lints::{CLIPPY_LINT_GROUPS, DEFAULT_LINT_GROUPS, DEFAULT_LINTS, Lint, LintGroup},
     imports::insert_use::InsertUseConfig,
     label::Label,
@@ -537,12 +537,10 @@ pub fn full_diagnostics(
     resolve: &AssistResolveStrategy,
     file_id: FileId,
 ) -> Vec<Diagnostic> {
-    salsa::attach(db, || {
-        let mut res = syntax_diagnostics(db, config, file_id);
-        let sema = semantic_diagnostics(db, config, resolve, file_id);
-        res.extend(sema);
-        res
-    })
+    let mut res = syntax_diagnostics(db, config, file_id);
+    let sema = semantic_diagnostics(db, config, resolve, file_id);
+    res.extend(sema);
+    res
 }
 
 /// Returns whether to keep this diagnostic (or remove it).
diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/tests.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/tests.rs
index c3cc5a08b56b5..1839ab1c58c1e 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/tests.rs
@@ -6,7 +6,7 @@ use hir::setup_tracing;
 use ide_db::{
     LineIndexDatabase, RootDatabase,
     assists::{AssistResolveStrategy, ExprFillDefaultMode},
-    base_db::SourceDatabase,
+    base_db::{SourceDatabase, salsa},
 };
 use itertools::Itertools;
 use stdx::trim_indent;
@@ -74,14 +74,16 @@ fn check_nth_fix_with_config(
     let after = trim_indent(ra_fixture_after);
 
     let (db, file_position) = RootDatabase::with_position(ra_fixture_before);
-    let diagnostic = super::full_diagnostics(
-        &db,
-        &config,
-        &AssistResolveStrategy::All,
-        file_position.file_id.file_id(&db),
-    )
-    .pop()
-    .expect("no diagnostics");
+    let diagnostic = salsa::attach(&db, || {
+        super::full_diagnostics(
+            &db,
+            &config,
+            &AssistResolveStrategy::All,
+            file_position.file_id.file_id(&db),
+        )
+        .pop()
+        .expect("no diagnostics")
+    });
     let fix = &diagnostic
         .fixes
         .unwrap_or_else(|| panic!("{:?} diagnostic misses fixes", diagnostic.code))[nth];
@@ -127,12 +129,14 @@ pub(crate) fn check_has_fix(
     let (db, file_position) = RootDatabase::with_position(ra_fixture_before);
     let mut conf = DiagnosticsConfig::test_sample();
     conf.expr_fill_default = ExprFillDefaultMode::Default;
-    let fix = super::full_diagnostics(
-        &db,
-        &conf,
-        &AssistResolveStrategy::All,
-        file_position.file_id.file_id(&db),
-    )
+    let fix = salsa::attach(&db, || {
+        super::full_diagnostics(
+            &db,
+            &conf,
+            &AssistResolveStrategy::All,
+            file_position.file_id.file_id(&db),
+        )
+    })
     .into_iter()
     .find(|d| {
         d.fixes
@@ -166,12 +170,14 @@ pub(crate) fn check_has_fix(
 /// Checks that there's a diagnostic *without* fix at `$0`.
 pub(crate) fn check_no_fix(#[rust_analyzer::rust_fixture] ra_fixture: &str) {
     let (db, file_position) = RootDatabase::with_position(ra_fixture);
-    let diagnostic = super::full_diagnostics(
-        &db,
-        &DiagnosticsConfig::test_sample(),
-        &AssistResolveStrategy::All,
-        file_position.file_id.file_id(&db),
-    )
+    let diagnostic = salsa::attach(&db, || {
+        super::full_diagnostics(
+            &db,
+            &DiagnosticsConfig::test_sample(),
+            &AssistResolveStrategy::All,
+            file_position.file_id.file_id(&db),
+        )
+    })
     .pop()
     .unwrap();
     assert!(diagnostic.fixes.is_none(), "got a fix when none was expected: {diagnostic:?}");
@@ -206,7 +212,13 @@ pub(crate) fn check_diagnostics_with_config(
         .iter()
         .copied()
         .flat_map(|file_id| {
-            super::full_diagnostics(&db, &config, &AssistResolveStrategy::All, file_id.file_id(&db))
+            salsa::attach(&db, || {
+                super::full_diagnostics(
+                    &db,
+                    &config,
+                    &AssistResolveStrategy::All,
+                    file_id.file_id(&db),
+                )
                 .into_iter()
                 .map(|d| {
                     let mut annotation = String::new();
@@ -224,6 +236,7 @@ pub(crate) fn check_diagnostics_with_config(
                     annotation.push_str(&d.message);
                     (d.range, annotation)
                 })
+            })
         })
         .map(|(diagnostic, annotation)| (diagnostic.file_id, (diagnostic.range, annotation)))
         .into_group_map();
@@ -275,15 +288,19 @@ fn test_disabled_diagnostics() {
     let (db, file_id) = RootDatabase::with_single_file(r#"mod foo;"#);
     let file_id = file_id.file_id(&db);
 
-    let diagnostics = super::full_diagnostics(&db, &config, &AssistResolveStrategy::All, file_id);
+    let diagnostics = salsa::attach(&db, || {
+        super::full_diagnostics(&db, &config, &AssistResolveStrategy::All, file_id)
+    });
     assert!(diagnostics.is_empty());
 
-    let diagnostics = super::full_diagnostics(
-        &db,
-        &DiagnosticsConfig::test_sample(),
-        &AssistResolveStrategy::All,
-        file_id,
-    );
+    let diagnostics = salsa::attach(&db, || {
+        super::full_diagnostics(
+            &db,
+            &DiagnosticsConfig::test_sample(),
+            &AssistResolveStrategy::All,
+            file_id,
+        )
+    });
     assert!(!diagnostics.is_empty());
 }
 
diff --git a/src/tools/rust-analyzer/crates/ide/src/goto_definition.rs b/src/tools/rust-analyzer/crates/ide/src/goto_definition.rs
index 633feec622cd9..f768d4b68f469 100644
--- a/src/tools/rust-analyzer/crates/ide/src/goto_definition.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/goto_definition.rs
@@ -10,7 +10,7 @@ use hir::{
 };
 use ide_db::{
     RootDatabase, SymbolKind,
-    base_db::{AnchoredPath, SourceDatabase, salsa},
+    base_db::{AnchoredPath, SourceDatabase},
     defs::{Definition, IdentClass},
     famous_defs::FamousDefs,
     helpers::pick_best_token,
@@ -108,7 +108,7 @@ pub(crate) fn goto_definition(
             }
 
             Some(
-                salsa::attach(sema.db, || IdentClass::classify_node(sema, &parent))?
+                IdentClass::classify_node(sema, &parent)?
                     .definitions()
                     .into_iter()
                     .flat_map(|(def, _)| {
diff --git a/src/tools/rust-analyzer/crates/ide/src/hover.rs b/src/tools/rust-analyzer/crates/ide/src/hover.rs
index b0ef83e0501b3..44c98a43f6944 100644
--- a/src/tools/rust-analyzer/crates/ide/src/hover.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/hover.rs
@@ -12,7 +12,6 @@ use hir::{
 };
 use ide_db::{
     FileRange, FxIndexSet, Ranker, RootDatabase,
-    base_db::salsa,
     defs::{Definition, IdentClass, NameRefClass, OperatorClass},
     famous_defs::FamousDefs,
     helpers::pick_best_token,
@@ -137,20 +136,18 @@ pub(crate) fn hover(
     let edition =
         sema.attach_first_edition(file_id).map(|it| it.edition(db)).unwrap_or(Edition::CURRENT);
     let display_target = sema.first_crate(file_id)?.to_display_target(db);
-    let mut res = salsa::attach(sema.db, || {
-        if range.is_empty() {
-            hover_offset(
-                sema,
-                FilePosition { file_id, offset: range.start() },
-                file,
-                config,
-                edition,
-                display_target,
-            )
-        } else {
-            hover_ranged(sema, frange, file, config, edition, display_target)
-        }
-    })?;
+    let mut res = if range.is_empty() {
+        hover_offset(
+            sema,
+            FilePosition { file_id, offset: range.start() },
+            file,
+            config,
+            edition,
+            display_target,
+        )
+    } else {
+        hover_ranged(sema, frange, file, config, edition, display_target)
+    }?;
 
     if let HoverDocFormat::PlainText = config.format {
         res.info.markup = remove_markdown(res.info.markup.as_str()).into();
@@ -293,7 +290,7 @@ fn hover_offset(
                 .into_iter()
                 .unique_by(|&((def, _), _, _, _)| def)
                 .map(|((def, subst), macro_arm, hovered_definition, node)| {
-                    salsa::attach(sema.db, || hover_for_definition(
+                    hover_for_definition(
                         sema,
                         file_id,
                         def,
@@ -304,7 +301,7 @@ fn hover_offset(
                         config,
                         edition,
                         display_target,
-                    ))
+                    )
                 })
                 .collect::<Vec<_>>(),
             )
@@ -583,13 +580,11 @@ fn goto_type_action_for_def(
         });
     }
 
-    salsa::attach(db, || {
-        if let Ok(generic_def) = GenericDef::try_from(def) {
-            generic_def.type_or_const_params(db).into_iter().for_each(|it| {
-                walk_and_push_ty(db, &it.ty(db), &mut push_new_def);
-            });
-        }
-    });
+    if let Ok(generic_def) = GenericDef::try_from(def) {
+        generic_def.type_or_const_params(db).into_iter().for_each(|it| {
+            walk_and_push_ty(db, &it.ty(db), &mut push_new_def);
+        });
+    }
 
     let ty = match def {
         Definition::Local(it) => Some(it.ty(db)),
diff --git a/src/tools/rust-analyzer/crates/ide/src/hover/render.rs b/src/tools/rust-analyzer/crates/ide/src/hover/render.rs
index 1f9d10c92b1df..290ee80984edc 100644
--- a/src/tools/rust-analyzer/crates/ide/src/hover/render.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/hover/render.rs
@@ -10,7 +10,6 @@ use hir::{
 };
 use ide_db::{
     RootDatabase,
-    base_db::salsa,
     defs::Definition,
     documentation::{DocsRangeMap, HasDocs},
     famous_defs::FamousDefs,
@@ -45,7 +44,7 @@ pub(super) fn type_info_of(
         Either::Left(expr) => sema.type_of_expr(expr)?,
         Either::Right(pat) => sema.type_of_pat(pat)?,
     };
-    salsa::attach(sema.db, || type_info(sema, _config, ty_info, edition, display_target))
+    type_info(sema, _config, ty_info, edition, display_target)
 }
 
 pub(super) fn closure_expr(
@@ -912,7 +911,7 @@ pub(super) fn literal(
     };
     let ty = ty.display(sema.db, display_target);
 
-    let mut s = salsa::attach(sema.db, || format!("```rust\n{ty}\n```\n___\n\n"));
+    let mut s = format!("```rust\n{ty}\n```\n___\n\n");
     match value {
         Ok(value) => {
             let backtick_len = value.chars().filter(|c| *c == '`').count();
diff --git a/src/tools/rust-analyzer/crates/ide/src/lib.rs b/src/tools/rust-analyzer/crates/ide/src/lib.rs
index e491c9214b437..874e04702e241 100644
--- a/src/tools/rust-analyzer/crates/ide/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/lib.rs
@@ -62,7 +62,7 @@ use std::panic::{AssertUnwindSafe, UnwindSafe};
 
 use cfg::CfgOptions;
 use fetch_crates::CrateInfo;
-use hir::{ChangeWithProcMacros, EditionedFileId, crate_def_map, sym};
+use hir::{ChangeWithProcMacros, EditionedFileId, crate_def_map, db::HirDatabase, sym};
 use ide_db::{
     FxHashMap, FxIndexSet, LineIndexDatabase,
     base_db::{
@@ -478,10 +478,12 @@ impl Analysis {
 
     /// Fuzzy searches for a symbol.
     pub fn symbol_search(&self, query: Query, limit: usize) -> Cancellable<Vec<NavigationTarget>> {
-        self.with_db(|db| {
-            symbol_index::world_symbols(db, query)
-                .into_iter() // xx: should we make this a par iter?
-                .filter_map(|s| s.try_to_nav(db))
+        // `world_symbols` currently clones the database to run stuff in parallel, which will make any query panic
+        // if we were to attach it here.
+        Cancelled::catch(|| {
+            symbol_index::world_symbols(&self.db, query)
+                .into_iter()
+                .filter_map(|s| s.try_to_nav(&self.db))
                 .take(limit)
                 .map(UpmappingResult::call_site)
                 .collect::<Vec<_>>()
@@ -660,15 +662,6 @@ impl Analysis {
         })
     }
 
-    /// Computes syntax highlighting for the given file
-    pub fn highlight(
-        &self,
-        highlight_config: HighlightConfig,
-        file_id: FileId,
-    ) -> Cancellable<Vec<HlRange>> {
-        self.with_db(|db| syntax_highlighting::highlight(db, highlight_config, file_id, None))
-    }
-
     /// Computes all ranges to highlight for a given item in a file.
     pub fn highlight_related(
         &self,
@@ -682,20 +675,42 @@ impl Analysis {
         })
     }
 
+    /// Computes syntax highlighting for the given file
+    pub fn highlight(
+        &self,
+        highlight_config: HighlightConfig,
+        file_id: FileId,
+    ) -> Cancellable<Vec<HlRange>> {
+        // highlighting may construct a new database for "speculative" execution, so we can't currently attach the database
+        // highlighting instead sets up the attach hook where neceesary for the trait solver
+        Cancelled::catch(|| {
+            syntax_highlighting::highlight(&self.db, highlight_config, file_id, None)
+        })
+    }
+
     /// Computes syntax highlighting for the given file range.
     pub fn highlight_range(
         &self,
         highlight_config: HighlightConfig,
         frange: FileRange,
     ) -> Cancellable<Vec<HlRange>> {
-        self.with_db(|db| {
-            syntax_highlighting::highlight(db, highlight_config, frange.file_id, Some(frange.range))
+        // highlighting may construct a new database for "speculative" execution, so we can't currently attach the database
+        // highlighting instead sets up the attach hook where neceesary for the trait solver
+        Cancelled::catch(|| {
+            syntax_highlighting::highlight(
+                &self.db,
+                highlight_config,
+                frange.file_id,
+                Some(frange.range),
+            )
         })
     }
 
     /// Computes syntax highlighting for the given file.
     pub fn highlight_as_html(&self, file_id: FileId, rainbow: bool) -> Cancellable<String> {
-        self.with_db(|db| syntax_highlighting::highlight_as_html(db, file_id, rainbow))
+        // highlighting may construct a new database for "speculative" execution, so we can't currently attach the database
+        // highlighting instead sets up the attach hook where neceesary for the trait solver
+        Cancelled::catch(|| syntax_highlighting::highlight_as_html(&self.db, file_id, rainbow))
     }
 
     /// Computes completions at the given position.
@@ -873,8 +888,12 @@ impl Analysis {
     where
         F: FnOnce(&RootDatabase) -> T + std::panic::UnwindSafe,
     {
-        let snap = self.db.clone();
-        Cancelled::catch(|| f(&snap))
+        salsa::attach(&self.db, || {
+            // the trait solver code may invoke `as_view<HirDatabase>` outside of queries,
+            // so technically we might run into a panic in salsa if the downcaster has not yet been registered.
+            HirDatabase::zalsa_register_downcaster(&self.db);
+            Cancelled::catch(|| f(&self.db))
+        })
     }
 }
 
diff --git a/src/tools/rust-analyzer/crates/parser/src/lexed_str.rs b/src/tools/rust-analyzer/crates/parser/src/lexed_str.rs
index dcf397142cac0..edc3f406a67e8 100644
--- a/src/tools/rust-analyzer/crates/parser/src/lexed_str.rs
+++ b/src/tools/rust-analyzer/crates/parser/src/lexed_str.rs
@@ -289,8 +289,7 @@ impl<'a> Converter<'a> {
 
                     let error_msg = if has_unterminated {
                         format!(
-                            "unknown literal prefix `{}` (note: check for unterminated string literal)",
-                            token_text
+                            "unknown literal prefix `{token_text}` (note: check for unterminated string literal)"
                         )
                     } else {
                         "unknown literal prefix".to_owned()

From ea44f12f72888528ddb5b26492c3b72ad4b7bcb4 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Fri, 15 Aug 2025 21:47:39 +0800
Subject: [PATCH 0118/1889] Rename and move tuple index suffix regression test

To make it more obvious what it's testing.

This is its own commit to make git blame easier.
---
 src/tools/tidy/src/issues.txt                                    | 1 -
 tests/ui/parser/{issues/issue-59418.rs => tuple-index-suffix.rs} | 0
 .../{issues/issue-59418.stderr => tuple-index-suffix.stderr}     | 0
 3 files changed, 1 deletion(-)
 rename tests/ui/parser/{issues/issue-59418.rs => tuple-index-suffix.rs} (100%)
 rename tests/ui/parser/{issues/issue-59418.stderr => tuple-index-suffix.stderr} (100%)

diff --git a/src/tools/tidy/src/issues.txt b/src/tools/tidy/src/issues.txt
index ee06707415f59..849dcb9e88fb1 100644
--- a/src/tools/tidy/src/issues.txt
+++ b/src/tools/tidy/src/issues.txt
@@ -2021,7 +2021,6 @@ ui/parser/issues/issue-5806.rs
 ui/parser/issues/issue-58094-missing-right-square-bracket.rs
 ui/parser/issues/issue-58856-1.rs
 ui/parser/issues/issue-58856-2.rs
-ui/parser/issues/issue-59418.rs
 ui/parser/issues/issue-60075.rs
 ui/parser/issues/issue-61858.rs
 ui/parser/issues/issue-62524.rs
diff --git a/tests/ui/parser/issues/issue-59418.rs b/tests/ui/parser/tuple-index-suffix.rs
similarity index 100%
rename from tests/ui/parser/issues/issue-59418.rs
rename to tests/ui/parser/tuple-index-suffix.rs
diff --git a/tests/ui/parser/issues/issue-59418.stderr b/tests/ui/parser/tuple-index-suffix.stderr
similarity index 100%
rename from tests/ui/parser/issues/issue-59418.stderr
rename to tests/ui/parser/tuple-index-suffix.stderr

From d7f7443a9540761c7cc2540c4b7b07b31b6120e5 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Fri, 15 Aug 2025 22:11:10 +0800
Subject: [PATCH 0119/1889] Expand `tuple-index-suffix` test coverage

Actually, the accidentally accepted invalid suffixes also include tuple
struct indexing positions, struct numeral field name positions. So
before changing anything, first expand test coverage, so we can observe
the effect of bumping the non-lint pseudo-FCW warning into a hard error.
---
 tests/ui/parser/tuple-index-suffix.rs     |  75 ++++++++--
 tests/ui/parser/tuple-index-suffix.stderr | 166 ++++++++++++++++++++--
 2 files changed, 222 insertions(+), 19 deletions(-)

diff --git a/tests/ui/parser/tuple-index-suffix.rs b/tests/ui/parser/tuple-index-suffix.rs
index 0fa191d4a7ef4..31c5bc25063dd 100644
--- a/tests/ui/parser/tuple-index-suffix.rs
+++ b/tests/ui/parser/tuple-index-suffix.rs
@@ -1,18 +1,77 @@
+//! See #60210.
+//!
+//! Check that we hard error on invalid suffixes in tuple indexing subexpressions and struct numeral
+//! field names, modulo carve-outs for `{i,u}{32,usize}` at warning level to mitigate ecosystem
+//! impact.
+
 struct X(i32,i32,i32);
 
 fn main() {
-    let a = X(1, 2, 3);
-    let b = a.1suffix;
+    let tup_struct = X(1, 2, 3);
+    let invalid_tup_struct_suffix = tup_struct.0suffix;
     //~^ ERROR suffixes on a tuple index are invalid
-    println!("{}", b);
-    let c = (1, 2, 3);
-    let d = c.1suffix;
+    let carve_out_tup_struct_suffix = tup_struct.0i32;
+    //~^ WARN suffixes on a tuple index are invalid
+
+    let tup = (1, 2, 3);
+    let invalid_tup_suffix = tup.0suffix;
     //~^ ERROR suffixes on a tuple index are invalid
-    println!("{}", d);
-    let s = X { 0suffix: 0, 1: 1, 2: 2 };
+    let carve_out_tup_suffix = tup.0u32;
+    //~^ WARN suffixes on a tuple index are invalid
+
+    numeral_struct_field_name_suffix_invalid();
+    numeral_struct_field_name_suffix_carve_out();
+}
+
+// Very limited carve outs as a ecosystem impact mitigation implemented in #60186. *Only*
+// `{i,u}{32,usize}` suffixes are temporarily accepted.
+fn carve_outs() {
+    // Ok, only pseudo-FCW warnings.
+
+    let carve_out_i32 = (42,).0i32;     //~ WARN suffixes on a tuple index are invalid
+    let carve_out_i32 = (42,).0u32;     //~ WARN suffixes on a tuple index are invalid
+    let carve_out_isize = (42,).0isize; //~ WARN suffixes on a tuple index are invalid
+    let carve_out_usize = (42,).0usize; //~ WARN suffixes on a tuple index are invalid
+
+    // Not part of the carve outs!
+    let error_i8 = (42,).0i8;      //~ ERROR suffixes on a tuple index are invalid
+    let error_u8 = (42,).0u8;      //~ ERROR suffixes on a tuple index are invalid
+    let error_i16 = (42,).0i16;    //~ ERROR suffixes on a tuple index are invalid
+    let error_u16 = (42,).0u16;    //~ ERROR suffixes on a tuple index are invalid
+    let error_i64 = (42,).0i64;    //~ ERROR suffixes on a tuple index are invalid
+    let error_u64 = (42,).0u64;    //~ ERROR suffixes on a tuple index are invalid
+    let error_i128 = (42,).0i128;  //~ ERROR suffixes on a tuple index are invalid
+    let error_u128 = (42,).0u128;  //~ ERROR suffixes on a tuple index are invalid
+}
+
+fn numeral_struct_field_name_suffix_invalid() {
+    let invalid_struct_name = X { 0suffix: 0, 1: 1, 2: 2 };
     //~^ ERROR suffixes on a tuple index are invalid
-    match s {
+    match invalid_struct_name {
         X { 0suffix: _, .. } => {}
         //~^ ERROR suffixes on a tuple index are invalid
     }
 }
+
+fn numeral_struct_field_name_suffix_carve_out() {
+    let carve_out_struct_name = X { 0u32: 0, 1: 1, 2: 2 };
+    //~^ WARN suffixes on a tuple index are invalid
+    match carve_out_struct_name {
+        X { 0u32: _, .. } => {}
+        //~^ WARN suffixes on a tuple index are invalid
+    }
+}
+
+// Unfortunately, it turns out `std::mem::offset_of!` uses the same expect suffix code path.
+fn offset_of_suffix() {
+    #[repr(C)]
+    pub struct Struct<T>(u8, T);
+
+    // Carve outs
+    assert_eq!(std::mem::offset_of!(Struct<u32>, 0usize), 0);
+    //~^ WARN suffixes on a tuple index are invalid
+
+    // Not part of carve outs
+    assert_eq!(std::mem::offset_of!(Struct<u32>, 0u8), 0);
+    //~^ ERROR suffixes on a tuple index are invalid
+}
diff --git a/tests/ui/parser/tuple-index-suffix.stderr b/tests/ui/parser/tuple-index-suffix.stderr
index 347051e9f921c..3a499dd6a8dff 100644
--- a/tests/ui/parser/tuple-index-suffix.stderr
+++ b/tests/ui/parser/tuple-index-suffix.stderr
@@ -1,26 +1,170 @@
 error: suffixes on a tuple index are invalid
-  --> $DIR/issue-59418.rs:5:15
+  --> $DIR/tuple-index-suffix.rs:11:48
    |
-LL |     let b = a.1suffix;
-   |               ^^^^^^^ invalid suffix `suffix`
+LL |     let invalid_tup_struct_suffix = tup_struct.0suffix;
+   |                                                ^^^^^^^ invalid suffix `suffix`
+
+warning: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:13:50
+   |
+LL |     let carve_out_tup_struct_suffix = tup_struct.0i32;
+   |                                                  ^^^^ invalid suffix `i32`
+   |
+   = help: `i32` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
+   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
+   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
+
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:17:34
+   |
+LL |     let invalid_tup_suffix = tup.0suffix;
+   |                                  ^^^^^^^ invalid suffix `suffix`
+
+warning: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:19:36
+   |
+LL |     let carve_out_tup_suffix = tup.0u32;
+   |                                    ^^^^ invalid suffix `u32`
+   |
+   = help: `u32` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
+   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
+   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
+
+warning: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:31:31
+   |
+LL |     let carve_out_i32 = (42,).0i32;
+   |                               ^^^^ invalid suffix `i32`
+   |
+   = help: `i32` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
+   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
+   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
+
+warning: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:32:31
+   |
+LL |     let carve_out_i32 = (42,).0u32;
+   |                               ^^^^ invalid suffix `u32`
+   |
+   = help: `u32` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
+   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
+   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
+
+warning: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:33:33
+   |
+LL |     let carve_out_isize = (42,).0isize;
+   |                                 ^^^^^^ invalid suffix `isize`
+   |
+   = help: `isize` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
+   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
+   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
+
+warning: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:34:33
+   |
+LL |     let carve_out_usize = (42,).0usize;
+   |                                 ^^^^^^ invalid suffix `usize`
+   |
+   = help: `usize` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
+   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
+   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
+
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:37:26
+   |
+LL |     let error_i8 = (42,).0i8;
+   |                          ^^^ invalid suffix `i8`
+
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:38:26
+   |
+LL |     let error_u8 = (42,).0u8;
+   |                          ^^^ invalid suffix `u8`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/issue-59418.rs:9:15
+  --> $DIR/tuple-index-suffix.rs:39:27
    |
-LL |     let d = c.1suffix;
-   |               ^^^^^^^ invalid suffix `suffix`
+LL |     let error_i16 = (42,).0i16;
+   |                           ^^^^ invalid suffix `i16`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/issue-59418.rs:12:17
+  --> $DIR/tuple-index-suffix.rs:40:27
    |
-LL |     let s = X { 0suffix: 0, 1: 1, 2: 2 };
-   |                 ^^^^^^^ invalid suffix `suffix`
+LL |     let error_u16 = (42,).0u16;
+   |                           ^^^^ invalid suffix `u16`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/issue-59418.rs:15:13
+  --> $DIR/tuple-index-suffix.rs:41:27
+   |
+LL |     let error_i64 = (42,).0i64;
+   |                           ^^^^ invalid suffix `i64`
+
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:42:27
+   |
+LL |     let error_u64 = (42,).0u64;
+   |                           ^^^^ invalid suffix `u64`
+
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:43:28
+   |
+LL |     let error_i128 = (42,).0i128;
+   |                            ^^^^^ invalid suffix `i128`
+
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:44:28
+   |
+LL |     let error_u128 = (42,).0u128;
+   |                            ^^^^^ invalid suffix `u128`
+
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:48:35
+   |
+LL |     let invalid_struct_name = X { 0suffix: 0, 1: 1, 2: 2 };
+   |                                   ^^^^^^^ invalid suffix `suffix`
+
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:51:13
    |
 LL |         X { 0suffix: _, .. } => {}
    |             ^^^^^^^ invalid suffix `suffix`
 
-error: aborting due to 4 previous errors
+warning: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:57:37
+   |
+LL |     let carve_out_struct_name = X { 0u32: 0, 1: 1, 2: 2 };
+   |                                     ^^^^ invalid suffix `u32`
+   |
+   = help: `u32` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
+   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
+   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
+
+warning: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:60:13
+   |
+LL |         X { 0u32: _, .. } => {}
+   |             ^^^^ invalid suffix `u32`
+   |
+   = help: `u32` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
+   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
+   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
+
+warning: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:71:50
+   |
+LL |     assert_eq!(std::mem::offset_of!(Struct<u32>, 0usize), 0);
+   |                                                  ^^^^^^ invalid suffix `usize`
+   |
+   = help: `usize` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
+   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
+   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
+
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:75:50
+   |
+LL |     assert_eq!(std::mem::offset_of!(Struct<u32>, 0u8), 0);
+   |                                                  ^^^ invalid suffix `u8`
+
+error: aborting due to 13 previous errors; 9 warnings emitted
 

From eb3441b25a7acbce8cec0571b3f8ec87cca8c349 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Fri, 15 Aug 2025 22:41:43 +0800
Subject: [PATCH 0120/1889] Add test coverage for proc-macro invalid tup index
 suffixes

---
 .../tuple-index-suffix-proc-macro-aux.rs      | 33 ++++++++++++++++++
 .../parser/tuple-index-suffix-proc-macro.rs   | 31 +++++++++++++++++
 .../tuple-index-suffix-proc-macro.stderr      | 34 +++++++++++++++++++
 3 files changed, 98 insertions(+)
 create mode 100644 tests/ui/parser/auxiliary/tuple-index-suffix-proc-macro-aux.rs
 create mode 100644 tests/ui/parser/tuple-index-suffix-proc-macro.rs
 create mode 100644 tests/ui/parser/tuple-index-suffix-proc-macro.stderr

diff --git a/tests/ui/parser/auxiliary/tuple-index-suffix-proc-macro-aux.rs b/tests/ui/parser/auxiliary/tuple-index-suffix-proc-macro-aux.rs
new file mode 100644
index 0000000000000..fa40ed948a623
--- /dev/null
+++ b/tests/ui/parser/auxiliary/tuple-index-suffix-proc-macro-aux.rs
@@ -0,0 +1,33 @@
+#![feature(proc_macro_quote, proc_macro_span)]
+
+extern crate proc_macro;
+
+use proc_macro::{Ident, Literal, Span, TokenStream, TokenTree, quote};
+
+#[proc_macro]
+pub fn bad_tup_indexing(input: TokenStream) -> TokenStream {
+    let tt = input.into_iter().next().unwrap();
+    let TokenTree::Literal(indexing_expr) = tt else {
+        unreachable!();
+    };
+    quote! { (42,).$indexing_expr }
+}
+
+// Expects {IDENT, COMMA, LITERAL}
+#[proc_macro]
+pub fn bad_tup_struct_indexing(input: TokenStream) -> TokenStream {
+    let mut input = input.into_iter();
+
+    let id_tt = input.next().unwrap();
+    let _comma = input.next().unwrap();
+    let tt = input.next().unwrap();
+
+    let TokenTree::Ident(ident) = id_tt else {
+        unreachable!("id");
+    };
+    let TokenTree::Literal(indexing_expr) = tt else {
+        unreachable!("lit");
+    };
+
+    quote! { $ident.$indexing_expr }
+}
diff --git a/tests/ui/parser/tuple-index-suffix-proc-macro.rs b/tests/ui/parser/tuple-index-suffix-proc-macro.rs
new file mode 100644
index 0000000000000..feca6f9cdfb06
--- /dev/null
+++ b/tests/ui/parser/tuple-index-suffix-proc-macro.rs
@@ -0,0 +1,31 @@
+//! See #59418.
+//!
+//! Like `tuple-index-suffix.rs`, but exercises the proc-macro interaction.
+
+//@ proc-macro: tuple-index-suffix-proc-macro-aux.rs
+
+extern crate tuple_index_suffix_proc_macro_aux;
+use tuple_index_suffix_proc_macro_aux as aux;
+
+fn main() {
+    struct TupStruct(i32);
+    let tup_struct = TupStruct(42);
+
+    // #60186 carve outs `{i,u}{32,usize}` as non-lint pseudo-FCW warnings.
+
+    aux::bad_tup_indexing!(0usize);
+    //~^ WARN suffixes on a tuple index are invalid
+    aux::bad_tup_struct_indexing!(tup_struct, 0isize);
+    //~^ WARN suffixes on a tuple index are invalid
+
+    // Not part of the #60186 carve outs.
+
+    aux::bad_tup_indexing!(0u8);
+    //~^ ERROR suffixes on a tuple index are invalid
+    aux::bad_tup_struct_indexing!(tup_struct, 0u64);
+    //~^ ERROR suffixes on a tuple index are invalid
+
+    // NOTE: didn't bother with trying to figure out how to generate `struct P { 0u32: u32 }` using
+    // *only* `proc_macro` without help with `syn`/`quote`, looks like you can't with just
+    // `proc_macro::quote`?
+}
diff --git a/tests/ui/parser/tuple-index-suffix-proc-macro.stderr b/tests/ui/parser/tuple-index-suffix-proc-macro.stderr
new file mode 100644
index 0000000000000..c8bc3a4576b40
--- /dev/null
+++ b/tests/ui/parser/tuple-index-suffix-proc-macro.stderr
@@ -0,0 +1,34 @@
+warning: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix-proc-macro.rs:16:28
+   |
+LL |     aux::bad_tup_indexing!(0usize);
+   |                            ^^^^^^ invalid suffix `usize`
+   |
+   = help: `usize` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
+   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
+   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
+
+warning: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix-proc-macro.rs:18:47
+   |
+LL |     aux::bad_tup_struct_indexing!(tup_struct, 0isize);
+   |                                               ^^^^^^ invalid suffix `isize`
+   |
+   = help: `isize` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
+   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
+   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
+
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix-proc-macro.rs:23:28
+   |
+LL |     aux::bad_tup_indexing!(0u8);
+   |                            ^^^ invalid suffix `u8`
+
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix-proc-macro.rs:25:47
+   |
+LL |     aux::bad_tup_struct_indexing!(tup_struct, 0u64);
+   |                                               ^^^^ invalid suffix `u64`
+
+error: aborting due to 2 previous errors; 2 warnings emitted
+

From ddd99930f34b79f209c61cc25706a1dac1173762 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Fri, 15 Aug 2025 23:39:33 +0800
Subject: [PATCH 0121/1889] Turn invalid index suffixes into hard errors

---
 compiler/rustc_parse/messages.ftl             |   3 -
 compiler/rustc_parse/src/errors.rs            |   4 -
 compiler/rustc_parse/src/parser/expr.rs       |  26 +---
 compiler/rustc_parse/src/parser/mod.rs        |   5 +-
 .../tuple-index-suffix-proc-macro-aux.rs      |   8 +-
 .../parser/tuple-index-suffix-proc-macro.rs   |   7 +-
 .../tuple-index-suffix-proc-macro.stderr      |  22 +---
 tests/ui/parser/tuple-index-suffix.rs         |  44 ++++---
 tests/ui/parser/tuple-index-suffix.stderr     | 124 +++++++-----------
 9 files changed, 92 insertions(+), 151 deletions(-)

diff --git a/compiler/rustc_parse/messages.ftl b/compiler/rustc_parse/messages.ftl
index 9e0075c21b9ed..0d1a3c783890a 100644
--- a/compiler/rustc_parse/messages.ftl
+++ b/compiler/rustc_parse/messages.ftl
@@ -473,9 +473,6 @@ parse_invalid_label =
 
 parse_invalid_literal_suffix_on_tuple_index = suffixes on a tuple index are invalid
     .label = invalid suffix `{$suffix}`
-    .tuple_exception_line_1 = `{$suffix}` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
-    .tuple_exception_line_2 = on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
-    .tuple_exception_line_3 = see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
 
 parse_invalid_logical_operator = `{$incorrect}` is not a logical operator
     .note = unlike in e.g., Python and PHP, `&&` and `||` are used for logical operators
diff --git a/compiler/rustc_parse/src/errors.rs b/compiler/rustc_parse/src/errors.rs
index a105dd1909e93..8a10e7d05ebeb 100644
--- a/compiler/rustc_parse/src/errors.rs
+++ b/compiler/rustc_parse/src/errors.rs
@@ -1016,10 +1016,6 @@ pub(crate) struct InvalidLiteralSuffixOnTupleIndex {
     #[label]
     pub span: Span,
     pub suffix: Symbol,
-    #[help(parse_tuple_exception_line_1)]
-    #[help(parse_tuple_exception_line_2)]
-    #[help(parse_tuple_exception_line_3)]
-    pub exception: bool,
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index d0604f763171b..7d33f3de15cc4 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -1163,7 +1163,10 @@ impl<'a> Parser<'a> {
                         suffix,
                     }) => {
                         if let Some(suffix) = suffix {
-                            self.expect_no_tuple_index_suffix(current.span, suffix);
+                            self.dcx().emit_err(errors::InvalidLiteralSuffixOnTupleIndex {
+                                span: current.span,
+                                suffix,
+                            });
                         }
                         match self.break_up_float(symbol, current.span) {
                             // 1e2
@@ -1239,7 +1242,8 @@ impl<'a> Parser<'a> {
         suffix: Option<Symbol>,
     ) -> Box<Expr> {
         if let Some(suffix) = suffix {
-            self.expect_no_tuple_index_suffix(ident_span, suffix);
+            self.dcx()
+                .emit_err(errors::InvalidLiteralSuffixOnTupleIndex { span: ident_span, suffix });
         }
         self.mk_expr(lo.to(ident_span), ExprKind::Field(base, Ident::new(field, ident_span)))
     }
@@ -2225,24 +2229,6 @@ impl<'a> Parser<'a> {
         })
     }
 
-    pub(super) fn expect_no_tuple_index_suffix(&self, span: Span, suffix: Symbol) {
-        if [sym::i32, sym::u32, sym::isize, sym::usize].contains(&suffix) {
-            // #59553: warn instead of reject out of hand to allow the fix to percolate
-            // through the ecosystem when people fix their macros
-            self.dcx().emit_warn(errors::InvalidLiteralSuffixOnTupleIndex {
-                span,
-                suffix,
-                exception: true,
-            });
-        } else {
-            self.dcx().emit_err(errors::InvalidLiteralSuffixOnTupleIndex {
-                span,
-                suffix,
-                exception: false,
-            });
-        }
-    }
-
     /// Matches `'-' lit | lit` (cf. `ast_validation::AstValidator::check_expr_within_pat`).
     /// Keep this in sync with `Token::can_begin_literal_maybe_minus`.
     pub fn parse_literal_maybe_minus(&mut self) -> PResult<'a, Box<Expr>> {
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
index 41ed1f95a010f..db72faf4ec7a7 100644
--- a/compiler/rustc_parse/src/parser/mod.rs
+++ b/compiler/rustc_parse/src/parser/mod.rs
@@ -1333,7 +1333,10 @@ impl<'a> Parser<'a> {
         if let token::Literal(token::Lit { kind: token::Integer, symbol, suffix }) = self.token.kind
         {
             if let Some(suffix) = suffix {
-                self.expect_no_tuple_index_suffix(self.token.span, suffix);
+                self.dcx().emit_err(errors::InvalidLiteralSuffixOnTupleIndex {
+                    span: self.token.span,
+                    suffix,
+                });
             }
             self.bump();
             Ok(Ident::new(symbol, self.prev_token.span))
diff --git a/tests/ui/parser/auxiliary/tuple-index-suffix-proc-macro-aux.rs b/tests/ui/parser/auxiliary/tuple-index-suffix-proc-macro-aux.rs
index fa40ed948a623..a5084b55aac79 100644
--- a/tests/ui/parser/auxiliary/tuple-index-suffix-proc-macro-aux.rs
+++ b/tests/ui/parser/auxiliary/tuple-index-suffix-proc-macro-aux.rs
@@ -18,14 +18,14 @@ pub fn bad_tup_indexing(input: TokenStream) -> TokenStream {
 pub fn bad_tup_struct_indexing(input: TokenStream) -> TokenStream {
     let mut input = input.into_iter();
 
-    let id_tt = input.next().unwrap();
+    let ident = input.next().unwrap();
     let _comma = input.next().unwrap();
-    let tt = input.next().unwrap();
+    let lit = input.next().unwrap();
 
-    let TokenTree::Ident(ident) = id_tt else {
+    let TokenTree::Ident(ident) = ident else {
         unreachable!("id");
     };
-    let TokenTree::Literal(indexing_expr) = tt else {
+    let TokenTree::Literal(indexing_expr) = lit else {
         unreachable!("lit");
     };
 
diff --git a/tests/ui/parser/tuple-index-suffix-proc-macro.rs b/tests/ui/parser/tuple-index-suffix-proc-macro.rs
index feca6f9cdfb06..557c67738d30f 100644
--- a/tests/ui/parser/tuple-index-suffix-proc-macro.rs
+++ b/tests/ui/parser/tuple-index-suffix-proc-macro.rs
@@ -11,12 +11,13 @@ fn main() {
     struct TupStruct(i32);
     let tup_struct = TupStruct(42);
 
-    // #60186 carve outs `{i,u}{32,usize}` as non-lint pseudo-FCW warnings.
+    // Previously, #60186 had carve outs for `{i,u}{32,usize}` as non-lint pseudo-FCW warnings. Now,
+    // they all hard error.
 
     aux::bad_tup_indexing!(0usize);
-    //~^ WARN suffixes on a tuple index are invalid
+    //~^ ERROR suffixes on a tuple index are invalid
     aux::bad_tup_struct_indexing!(tup_struct, 0isize);
-    //~^ WARN suffixes on a tuple index are invalid
+    //~^ ERROR suffixes on a tuple index are invalid
 
     // Not part of the #60186 carve outs.
 
diff --git a/tests/ui/parser/tuple-index-suffix-proc-macro.stderr b/tests/ui/parser/tuple-index-suffix-proc-macro.stderr
index c8bc3a4576b40..47d179d355513 100644
--- a/tests/ui/parser/tuple-index-suffix-proc-macro.stderr
+++ b/tests/ui/parser/tuple-index-suffix-proc-macro.stderr
@@ -1,34 +1,26 @@
-warning: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix-proc-macro.rs:16:28
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix-proc-macro.rs:17:28
    |
 LL |     aux::bad_tup_indexing!(0usize);
    |                            ^^^^^^ invalid suffix `usize`
-   |
-   = help: `usize` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
-   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
-   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
 
-warning: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix-proc-macro.rs:18:47
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix-proc-macro.rs:19:47
    |
 LL |     aux::bad_tup_struct_indexing!(tup_struct, 0isize);
    |                                               ^^^^^^ invalid suffix `isize`
-   |
-   = help: `isize` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
-   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
-   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix-proc-macro.rs:23:28
+  --> $DIR/tuple-index-suffix-proc-macro.rs:24:28
    |
 LL |     aux::bad_tup_indexing!(0u8);
    |                            ^^^ invalid suffix `u8`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix-proc-macro.rs:25:47
+  --> $DIR/tuple-index-suffix-proc-macro.rs:26:47
    |
 LL |     aux::bad_tup_struct_indexing!(tup_struct, 0u64);
    |                                               ^^^^ invalid suffix `u64`
 
-error: aborting due to 2 previous errors; 2 warnings emitted
+error: aborting due to 4 previous errors
 
diff --git a/tests/ui/parser/tuple-index-suffix.rs b/tests/ui/parser/tuple-index-suffix.rs
index 31c5bc25063dd..c476950000545 100644
--- a/tests/ui/parser/tuple-index-suffix.rs
+++ b/tests/ui/parser/tuple-index-suffix.rs
@@ -1,8 +1,10 @@
-//! See #60210.
+//! Regression test for both the original regression in #59418 where invalid suffixes in indexing
+//! positions were accidentally accepted, and also for the removal of the temporary carve out that
+//! mitigated ecosystem impact following trying to reject #59418 (this was implemented as a FCW
+//! tracked in #60210).
 //!
 //! Check that we hard error on invalid suffixes in tuple indexing subexpressions and struct numeral
-//! field names, modulo carve-outs for `{i,u}{32,usize}` at warning level to mitigate ecosystem
-//! impact.
+//! field names.
 
 struct X(i32,i32,i32);
 
@@ -10,28 +12,28 @@ fn main() {
     let tup_struct = X(1, 2, 3);
     let invalid_tup_struct_suffix = tup_struct.0suffix;
     //~^ ERROR suffixes on a tuple index are invalid
-    let carve_out_tup_struct_suffix = tup_struct.0i32;
-    //~^ WARN suffixes on a tuple index are invalid
+    let previous_carve_out_tup_struct_suffix = tup_struct.0i32;
+    //~^ ERROR suffixes on a tuple index are invalid
 
     let tup = (1, 2, 3);
     let invalid_tup_suffix = tup.0suffix;
     //~^ ERROR suffixes on a tuple index are invalid
-    let carve_out_tup_suffix = tup.0u32;
-    //~^ WARN suffixes on a tuple index are invalid
+    let previous_carve_out_tup_suffix = tup.0u32;
+    //~^ ERROR suffixes on a tuple index are invalid
 
     numeral_struct_field_name_suffix_invalid();
-    numeral_struct_field_name_suffix_carve_out();
+    numeral_struct_field_name_suffix_previous_carve_out();
 }
 
-// Very limited carve outs as a ecosystem impact mitigation implemented in #60186. *Only*
-// `{i,u}{32,usize}` suffixes are temporarily accepted.
-fn carve_outs() {
-    // Ok, only pseudo-FCW warnings.
+// Previously, there were very limited carve outs as a ecosystem impact mitigation implemented in
+// #60186. *Only* `{i,u}{32,usize}` suffixes were temporarily accepted. Now, they all hard error.
+fn previous_carve_outs() {
+    // Previously temporarily accepted by a pseudo-FCW (#60210), now hard error.
 
-    let carve_out_i32 = (42,).0i32;     //~ WARN suffixes on a tuple index are invalid
-    let carve_out_i32 = (42,).0u32;     //~ WARN suffixes on a tuple index are invalid
-    let carve_out_isize = (42,).0isize; //~ WARN suffixes on a tuple index are invalid
-    let carve_out_usize = (42,).0usize; //~ WARN suffixes on a tuple index are invalid
+    let previous_carve_out_i32 = (42,).0i32;     //~ ERROR suffixes on a tuple index are invalid
+    let previous_carve_out_i32 = (42,).0u32;     //~ ERROR suffixes on a tuple index are invalid
+    let previous_carve_out_isize = (42,).0isize; //~ ERROR suffixes on a tuple index are invalid
+    let previous_carve_out_usize = (42,).0usize; //~ ERROR suffixes on a tuple index are invalid
 
     // Not part of the carve outs!
     let error_i8 = (42,).0i8;      //~ ERROR suffixes on a tuple index are invalid
@@ -53,12 +55,12 @@ fn numeral_struct_field_name_suffix_invalid() {
     }
 }
 
-fn numeral_struct_field_name_suffix_carve_out() {
+fn numeral_struct_field_name_suffix_previous_carve_out() {
     let carve_out_struct_name = X { 0u32: 0, 1: 1, 2: 2 };
-    //~^ WARN suffixes on a tuple index are invalid
+    //~^ ERROR suffixes on a tuple index are invalid
     match carve_out_struct_name {
         X { 0u32: _, .. } => {}
-        //~^ WARN suffixes on a tuple index are invalid
+        //~^ ERROR suffixes on a tuple index are invalid
     }
 }
 
@@ -67,9 +69,9 @@ fn offset_of_suffix() {
     #[repr(C)]
     pub struct Struct<T>(u8, T);
 
-    // Carve outs
+    // Previous pseudo-FCW carve outs
     assert_eq!(std::mem::offset_of!(Struct<u32>, 0usize), 0);
-    //~^ WARN suffixes on a tuple index are invalid
+    //~^ ERROR suffixes on a tuple index are invalid
 
     // Not part of carve outs
     assert_eq!(std::mem::offset_of!(Struct<u32>, 0u8), 0);
diff --git a/tests/ui/parser/tuple-index-suffix.stderr b/tests/ui/parser/tuple-index-suffix.stderr
index 3a499dd6a8dff..6d96c6d3cbf88 100644
--- a/tests/ui/parser/tuple-index-suffix.stderr
+++ b/tests/ui/parser/tuple-index-suffix.stderr
@@ -1,170 +1,134 @@
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:11:48
+  --> $DIR/tuple-index-suffix.rs:13:48
    |
 LL |     let invalid_tup_struct_suffix = tup_struct.0suffix;
    |                                                ^^^^^^^ invalid suffix `suffix`
 
-warning: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:13:50
-   |
-LL |     let carve_out_tup_struct_suffix = tup_struct.0i32;
-   |                                                  ^^^^ invalid suffix `i32`
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:15:59
    |
-   = help: `i32` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
-   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
-   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
+LL |     let previous_carve_out_tup_struct_suffix = tup_struct.0i32;
+   |                                                           ^^^^ invalid suffix `i32`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:17:34
+  --> $DIR/tuple-index-suffix.rs:19:34
    |
 LL |     let invalid_tup_suffix = tup.0suffix;
    |                                  ^^^^^^^ invalid suffix `suffix`
 
-warning: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:19:36
-   |
-LL |     let carve_out_tup_suffix = tup.0u32;
-   |                                    ^^^^ invalid suffix `u32`
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:21:45
    |
-   = help: `u32` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
-   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
-   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
+LL |     let previous_carve_out_tup_suffix = tup.0u32;
+   |                                             ^^^^ invalid suffix `u32`
 
-warning: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:31:31
-   |
-LL |     let carve_out_i32 = (42,).0i32;
-   |                               ^^^^ invalid suffix `i32`
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:33:40
    |
-   = help: `i32` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
-   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
-   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
+LL |     let previous_carve_out_i32 = (42,).0i32;
+   |                                        ^^^^ invalid suffix `i32`
 
-warning: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:32:31
-   |
-LL |     let carve_out_i32 = (42,).0u32;
-   |                               ^^^^ invalid suffix `u32`
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:34:40
    |
-   = help: `u32` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
-   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
-   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
+LL |     let previous_carve_out_i32 = (42,).0u32;
+   |                                        ^^^^ invalid suffix `u32`
 
-warning: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:33:33
-   |
-LL |     let carve_out_isize = (42,).0isize;
-   |                                 ^^^^^^ invalid suffix `isize`
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:35:42
    |
-   = help: `isize` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
-   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
-   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
+LL |     let previous_carve_out_isize = (42,).0isize;
+   |                                          ^^^^^^ invalid suffix `isize`
 
-warning: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:34:33
-   |
-LL |     let carve_out_usize = (42,).0usize;
-   |                                 ^^^^^^ invalid suffix `usize`
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:36:42
    |
-   = help: `usize` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
-   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
-   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
+LL |     let previous_carve_out_usize = (42,).0usize;
+   |                                          ^^^^^^ invalid suffix `usize`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:37:26
+  --> $DIR/tuple-index-suffix.rs:39:26
    |
 LL |     let error_i8 = (42,).0i8;
    |                          ^^^ invalid suffix `i8`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:38:26
+  --> $DIR/tuple-index-suffix.rs:40:26
    |
 LL |     let error_u8 = (42,).0u8;
    |                          ^^^ invalid suffix `u8`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:39:27
+  --> $DIR/tuple-index-suffix.rs:41:27
    |
 LL |     let error_i16 = (42,).0i16;
    |                           ^^^^ invalid suffix `i16`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:40:27
+  --> $DIR/tuple-index-suffix.rs:42:27
    |
 LL |     let error_u16 = (42,).0u16;
    |                           ^^^^ invalid suffix `u16`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:41:27
+  --> $DIR/tuple-index-suffix.rs:43:27
    |
 LL |     let error_i64 = (42,).0i64;
    |                           ^^^^ invalid suffix `i64`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:42:27
+  --> $DIR/tuple-index-suffix.rs:44:27
    |
 LL |     let error_u64 = (42,).0u64;
    |                           ^^^^ invalid suffix `u64`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:43:28
+  --> $DIR/tuple-index-suffix.rs:45:28
    |
 LL |     let error_i128 = (42,).0i128;
    |                            ^^^^^ invalid suffix `i128`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:44:28
+  --> $DIR/tuple-index-suffix.rs:46:28
    |
 LL |     let error_u128 = (42,).0u128;
    |                            ^^^^^ invalid suffix `u128`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:48:35
+  --> $DIR/tuple-index-suffix.rs:50:35
    |
 LL |     let invalid_struct_name = X { 0suffix: 0, 1: 1, 2: 2 };
    |                                   ^^^^^^^ invalid suffix `suffix`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:51:13
+  --> $DIR/tuple-index-suffix.rs:53:13
    |
 LL |         X { 0suffix: _, .. } => {}
    |             ^^^^^^^ invalid suffix `suffix`
 
-warning: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:57:37
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:59:37
    |
 LL |     let carve_out_struct_name = X { 0u32: 0, 1: 1, 2: 2 };
    |                                     ^^^^ invalid suffix `u32`
-   |
-   = help: `u32` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
-   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
-   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
 
-warning: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:60:13
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:62:13
    |
 LL |         X { 0u32: _, .. } => {}
    |             ^^^^ invalid suffix `u32`
-   |
-   = help: `u32` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
-   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
-   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
 
-warning: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:71:50
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:73:50
    |
 LL |     assert_eq!(std::mem::offset_of!(Struct<u32>, 0usize), 0);
    |                                                  ^^^^^^ invalid suffix `usize`
-   |
-   = help: `usize` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
-   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
-   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:75:50
+  --> $DIR/tuple-index-suffix.rs:77:50
    |
 LL |     assert_eq!(std::mem::offset_of!(Struct<u32>, 0u8), 0);
    |                                                  ^^^ invalid suffix `u8`
 
-error: aborting due to 13 previous errors; 9 warnings emitted
+error: aborting due to 22 previous errors
 

From 443860d1ae4310e12188e05278fc34fd01ace1c6 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Mon, 18 Aug 2025 22:15:03 -0700
Subject: [PATCH 0122/1889] ptr_as_ptr: use correct span context for
 `pointer::cast` sugg

---
 clippy_lints/src/casts/ptr_as_ptr.rs | 2 +-
 tests/ui/ptr_as_ptr.fixed            | 6 ++++++
 tests/ui/ptr_as_ptr.rs               | 6 ++++++
 tests/ui/ptr_as_ptr.stderr           | 8 +++++++-
 4 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/clippy_lints/src/casts/ptr_as_ptr.rs b/clippy_lints/src/casts/ptr_as_ptr.rs
index 890754090989f..30e4adefd1f17 100644
--- a/clippy_lints/src/casts/ptr_as_ptr.rs
+++ b/clippy_lints/src/casts/ptr_as_ptr.rs
@@ -78,7 +78,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, msrv: Msrv)
             let method = snippet_with_applicability(cx, qpath_span_without_turbofish(method), "..", &mut app);
             ("try call directly", format!("{method}{turbofish}()"))
         } else {
-            let cast_expr_sugg = Sugg::hir_with_applicability(cx, cast_expr, "_", &mut app);
+            let cast_expr_sugg = Sugg::hir_with_context(cx, cast_expr, expr.span.ctxt(), "_", &mut app);
 
             (
                 "try `pointer::cast`, a safer alternative",
diff --git a/tests/ui/ptr_as_ptr.fixed b/tests/ui/ptr_as_ptr.fixed
index 78e1ceb480a5f..4457878b6faf1 100644
--- a/tests/ui/ptr_as_ptr.fixed
+++ b/tests/ui/ptr_as_ptr.fixed
@@ -229,3 +229,9 @@ fn issue15283() {
         //~^ ptr_as_ptr
     }
 }
+
+fn issue15232() {
+    let mut b = Box::new(0i32);
+    let _ptr = std::ptr::addr_of_mut!(*b).cast::<()>();
+    //~^ ptr_as_ptr
+}
diff --git a/tests/ui/ptr_as_ptr.rs b/tests/ui/ptr_as_ptr.rs
index 70732cf0a6c16..9124fc912d2c6 100644
--- a/tests/ui/ptr_as_ptr.rs
+++ b/tests/ui/ptr_as_ptr.rs
@@ -229,3 +229,9 @@ fn issue15283() {
         //~^ ptr_as_ptr
     }
 }
+
+fn issue15232() {
+    let mut b = Box::new(0i32);
+    let _ptr = std::ptr::addr_of_mut!(*b) as *mut ();
+    //~^ ptr_as_ptr
+}
diff --git a/tests/ui/ptr_as_ptr.stderr b/tests/ui/ptr_as_ptr.stderr
index c0a2a4b6d204d..af21c1e35f52a 100644
--- a/tests/ui/ptr_as_ptr.stderr
+++ b/tests/ui/ptr_as_ptr.stderr
@@ -199,5 +199,11 @@ error: `as` casting between raw pointers without changing their constness
 LL |         let _: fn() = std::mem::transmute(std::ptr::null::<()>() as *const u8);
    |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `std::ptr::null::<u8>()`
 
-error: aborting due to 33 previous errors
+error: `as` casting between raw pointers without changing their constness
+  --> tests/ui/ptr_as_ptr.rs:235:16
+   |
+LL |     let _ptr = std::ptr::addr_of_mut!(*b) as *mut ();
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `std::ptr::addr_of_mut!(*b).cast::<()>()`
+
+error: aborting due to 34 previous errors
 

From 8eaa4ad7a4cf371114f9e26a92b41cd3fc25e27e Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Wed, 13 Aug 2025 10:31:57 +0200
Subject: [PATCH 0123/1889] user facing code should use not use `PostAnalysis`

---
 .../ide-assists/src/handlers/generate_from_impl_for_enum.rs     | 2 +-
 .../src/handlers/generate_single_field_struct_from.rs           | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_from_impl_for_enum.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_from_impl_for_enum.rs
index cb83c67c99535..d88b0f34b7969 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_from_impl_for_enum.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_from_impl_for_enum.rs
@@ -87,7 +87,7 @@ fn existing_from_impl(
     let from_trait = FamousDefs(sema, krate).core_convert_From()?;
     let interner = DbInterner::new_with(db, Some(krate.base()), None);
     use hir::next_solver::infer::DbInternerInferExt;
-    let infcx = interner.infer_ctxt().build(TypingMode::PostAnalysis);
+    let infcx = interner.infer_ctxt().build(TypingMode::non_body_analysis());
 
     let variant = variant.instantiate_infer(&infcx);
     let enum_ = variant.parent_enum(sema.db);
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_single_field_struct_from.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_single_field_struct_from.rs
index deef4a9aac6db..943795d40d551 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_single_field_struct_from.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_single_field_struct_from.rs
@@ -216,7 +216,7 @@ fn from_impl_exists(
     let from_trait = FamousDefs(sema, krate).core_convert_From()?;
     let interner = DbInterner::new_with(db, Some(krate.base()), None);
     use hir::next_solver::infer::DbInternerInferExt;
-    let infcx = interner.infer_ctxt().build(TypingMode::PostAnalysis);
+    let infcx = interner.infer_ctxt().build(TypingMode::non_body_analysis());
 
     let strukt = strukt.instantiate_infer(&infcx);
     let field_ty = strukt.fields(db).get(main_field_i)?.ty(db);

From 3141739bad36c517cd2425d06dc35df327ee1b3a Mon Sep 17 00:00:00 2001
From: lumiscosity <averyrudelphe@gmail.com>
Date: Tue, 19 Aug 2025 11:41:58 +0200
Subject: [PATCH 0124/1889] Optimize icon

Losslessly optimizes the icon with:

```
oxipng -o max -a -s
oxipng -o max --zopfli -a -s
```
---
 src/tools/rust-analyzer/editors/code/icon.png | Bin 15341 -> 9761 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/src/tools/rust-analyzer/editors/code/icon.png b/src/tools/rust-analyzer/editors/code/icon.png
index 072090c6f4a1fbebc0a2e1ba20d991d5a75d513a..29a9679039010500e7d2b4db1e832f904618081b 100644
GIT binary patch
literal 9761
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
Tb%jNN=)hF&XxuJAJ$m+EN?yW=

literal 15341
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


From f9bc63d78f48002d6d4e55c0a46a87a024b2549c Mon Sep 17 00:00:00 2001
From: Nikita Popov <npopov@redhat.com>
Date: Wed, 20 Aug 2025 10:10:56 +0200
Subject: [PATCH 0125/1889] Drop no longer needed feature gates

---
 library/stdarch/crates/core_arch/src/lib.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/library/stdarch/crates/core_arch/src/lib.rs b/library/stdarch/crates/core_arch/src/lib.rs
index c58580f641780..7d3cbd55ad85c 100644
--- a/library/stdarch/crates/core_arch/src/lib.rs
+++ b/library/stdarch/crates/core_arch/src/lib.rs
@@ -18,8 +18,6 @@
     rustc_attrs,
     staged_api,
     doc_cfg,
-    tbm_target_feature,
-    sse4a_target_feature,
     riscv_target_feature,
     arm_target_feature,
     mips_target_feature,

From 135de7c8df64b8ef85ad348db09b02194779e68e Mon Sep 17 00:00:00 2001
From: Nikita Popov <npopov@redhat.com>
Date: Thu, 14 Aug 2025 11:05:03 +0200
Subject: [PATCH 0126/1889] Use intrinsics for some s390x operations

---
 .../stdarch/crates/core_arch/src/s390x/vector.rs    | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/library/stdarch/crates/core_arch/src/s390x/vector.rs b/library/stdarch/crates/core_arch/src/s390x/vector.rs
index 0ce720a9244cd..9927ff2c62555 100644
--- a/library/stdarch/crates/core_arch/src/s390x/vector.rs
+++ b/library/stdarch/crates/core_arch/src/s390x/vector.rs
@@ -114,6 +114,9 @@ unsafe extern "unadjusted" {
     #[link_name = "llvm.s390.vsumqf"] fn vsumqf(a: vector_unsigned_int, b: vector_unsigned_int) -> u128;
     #[link_name = "llvm.s390.vsumqg"] fn vsumqg(a: vector_unsigned_long_long, b: vector_unsigned_long_long) -> u128;
 
+    #[link_name = "llvm.s390.vaccq"] fn vaccq(a: u128, b: u128) -> u128;
+    #[link_name = "llvm.s390.vacccq"] fn vacccq(a: u128, b: u128, c: u128) -> u128;
+
     #[link_name = "llvm.s390.vscbiq"] fn vscbiq(a: u128, b: u128) -> u128;
     #[link_name = "llvm.s390.vsbiq"] fn vsbiq(a: u128, b: u128, c: u128) -> u128;
     #[link_name = "llvm.s390.vsbcbiq"] fn vsbcbiq(a: u128, b: u128, c: u128) -> u128;
@@ -4694,7 +4697,9 @@ pub unsafe fn vec_addc_u128(
 ) -> vector_unsigned_char {
     let a: u128 = transmute(a);
     let b: u128 = transmute(b);
-    transmute(a.overflowing_add(b).1 as u128)
+    // FIXME(llvm) https://github.com/llvm/llvm-project/pull/153557
+    // transmute(a.overflowing_add(b).1 as u128)
+    transmute(vaccq(a, b))
 }
 
 /// Vector Add With Carry unsigned 128-bits
@@ -4729,8 +4734,10 @@ pub unsafe fn vec_addec_u128(
     let a: u128 = transmute(a);
     let b: u128 = transmute(b);
     let c: u128 = transmute(c);
-    let (_d, carry) = a.carrying_add(b, c & 1 != 0);
-    transmute(carry as u128)
+    // FIXME(llvm) https://github.com/llvm/llvm-project/pull/153557
+    // let (_d, carry) = a.carrying_add(b, c & 1 != 0);
+    // transmute(carry as u128)
+    transmute(vacccq(a, b, c))
 }
 
 /// Vector Subtract with Carryout

From 4a8b8231b1e7263ae5d8da82ccd5c1490f1db9e7 Mon Sep 17 00:00:00 2001
From: Nikita Popov <npopov@redhat.com>
Date: Wed, 20 Aug 2025 10:18:03 +0200
Subject: [PATCH 0127/1889] Add missing avx512vl target features

---
 .../crates/core_arch/src/x86/avx512fp16.rs    | 376 +++++++++---------
 1 file changed, 188 insertions(+), 188 deletions(-)

diff --git a/library/stdarch/crates/core_arch/src/x86/avx512fp16.rs b/library/stdarch/crates/core_arch/src/x86/avx512fp16.rs
index 8c914803c665d..a86fc7199b83c 100644
--- a/library/stdarch/crates/core_arch/src/x86/avx512fp16.rs
+++ b/library/stdarch/crates/core_arch/src/x86/avx512fp16.rs
@@ -17282,14 +17282,14 @@ mod tests {
         assert_eq_m512h(a, b);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_load_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_load_sh(addr_of!(a).cast());
         assert_eq_m128h(a, b);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_load_sh() {
         let a = _mm_set_sh(1.0);
         let src = _mm_set_sh(2.);
@@ -17299,7 +17299,7 @@ mod tests {
         assert_eq_m128h(src, b);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_load_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_maskz_load_sh(1, addr_of!(a).cast());
@@ -17344,7 +17344,7 @@ mod tests {
         assert_eq_m512h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_move_sh() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let b = _mm_set_sh(9.0);
@@ -17353,7 +17353,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_move_sh() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let b = _mm_set_sh(9.0);
@@ -17363,7 +17363,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_move_sh() {
         let a = _mm_set_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let b = _mm_set_sh(9.0);
@@ -17402,7 +17402,7 @@ mod tests {
         assert_eq_m512h(a, b);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_store_sh() {
         let a = _mm_set_sh(1.0);
         let mut b = _mm_setzero_ph();
@@ -17410,7 +17410,7 @@ mod tests {
         assert_eq_m128h(a, b);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_store_sh() {
         let a = _mm_set_sh(1.0);
         let mut b = _mm_setzero_ph();
@@ -17655,7 +17655,7 @@ mod tests {
         assert_eq_m512h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_add_round_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
@@ -17664,7 +17664,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_add_round_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
@@ -17681,7 +17681,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_add_round_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
@@ -17695,7 +17695,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_add_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
@@ -17704,7 +17704,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_add_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
@@ -17717,7 +17717,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_add_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
@@ -17945,7 +17945,7 @@ mod tests {
         assert_eq_m512h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_sub_round_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
@@ -17954,7 +17954,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_sub_round_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
@@ -17971,7 +17971,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_sub_round_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
@@ -17985,7 +17985,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_sub_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
@@ -17994,7 +17994,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_sub_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
@@ -18007,7 +18007,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_sub_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
@@ -18235,7 +18235,7 @@ mod tests {
         assert_eq_m512h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mul_round_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
@@ -18244,7 +18244,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_mul_round_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
@@ -18261,7 +18261,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_mul_round_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
@@ -18275,7 +18275,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mul_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
@@ -18284,7 +18284,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_mul_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
@@ -18297,7 +18297,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_mul_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
@@ -18457,7 +18457,7 @@ mod tests {
         assert_eq_m512h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_div_round_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
@@ -18466,7 +18466,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_div_round_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
@@ -18483,7 +18483,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_div_round_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
@@ -18497,7 +18497,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_div_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
@@ -18506,7 +18506,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_div_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
@@ -18519,7 +18519,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_div_sh() {
         let a = _mm_set_sh(1.0);
         let b = _mm_set_sh(2.0);
@@ -18680,7 +18680,7 @@ mod tests {
         assert_eq_m512h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mul_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 1.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
@@ -18689,7 +18689,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_mul_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 1.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
@@ -18701,7 +18701,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_mul_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 1.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
@@ -18711,7 +18711,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mul_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 1.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
@@ -18720,7 +18720,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_mul_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 1.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
@@ -18730,7 +18730,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_mul_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 1.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
@@ -18888,7 +18888,7 @@ mod tests {
         assert_eq_m512h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_fmul_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 1.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
@@ -18897,7 +18897,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_fmul_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 1.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
@@ -18909,7 +18909,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_fmul_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 1.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
@@ -18919,7 +18919,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_fmul_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 1.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
@@ -18928,7 +18928,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_fmul_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 1.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
@@ -18938,7 +18938,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_fmul_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 1.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
@@ -19096,7 +19096,7 @@ mod tests {
         assert_eq_m512h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_cmul_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, -1.0, 8.0, -9.0, 10.0, -11.0, 12.0, -13.0);
@@ -19105,7 +19105,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_cmul_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, -1.0, 8.0, -9.0, 10.0, -11.0, 12.0, -13.0);
@@ -19115,7 +19115,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_cmul_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, -1.0, 8.0, -9.0, 10.0, -11.0, 12.0, -13.0);
@@ -19124,7 +19124,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_cmul_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, -1.0, 8.0, -9.0, 10.0, -11.0, 12.0, -13.0);
@@ -19133,7 +19133,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_cmul_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, -1.0, 8.0, -9.0, 10.0, -11.0, 12.0, -13.0);
@@ -19145,7 +19145,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_cmul_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, -1.0, 8.0, -9.0, 10.0, -11.0, 12.0, -13.0);
@@ -19304,7 +19304,7 @@ mod tests {
         assert_eq_m512h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_fcmul_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, -1.0, 8.0, -9.0, 10.0, -11.0, 12.0, -13.0);
@@ -19313,7 +19313,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_fcmul_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, -1.0, 8.0, -9.0, 10.0, -11.0, 12.0, -13.0);
@@ -19323,7 +19323,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_fcmul_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, -1.0, 8.0, -9.0, 10.0, -11.0, 12.0, -13.0);
@@ -19332,7 +19332,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_fcmul_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, -1.0, 8.0, -9.0, 10.0, -11.0, 12.0, -13.0);
@@ -19341,7 +19341,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_fcmul_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, -1.0, 8.0, -9.0, 10.0, -11.0, 12.0, -13.0);
@@ -19353,7 +19353,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_fcmul_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, -1.0, 8.0, -9.0, 10.0, -11.0, 12.0, -13.0);
@@ -19692,7 +19692,7 @@ mod tests {
         assert_eq_m512h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_fmadd_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
@@ -19702,7 +19702,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_fmadd_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
@@ -19715,7 +19715,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask3_fmadd_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
@@ -19728,7 +19728,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_fmadd_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
@@ -19741,7 +19741,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_fmadd_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
@@ -19751,7 +19751,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_fmadd_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
@@ -19768,7 +19768,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask3_fmadd_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
@@ -19785,7 +19785,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_fmadd_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
@@ -20002,7 +20002,7 @@ mod tests {
         assert_eq_m512h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_fcmadd_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
@@ -20012,7 +20012,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_fcmadd_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
@@ -20025,7 +20025,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask3_fcmadd_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
@@ -20038,7 +20038,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_fcmadd_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
@@ -20051,7 +20051,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_fcmadd_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
@@ -20061,7 +20061,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_fcmadd_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
@@ -20078,7 +20078,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask3_fcmadd_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
@@ -20095,7 +20095,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_fcmadd_round_sch() {
         let a = _mm_setr_ph(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
         let b = _mm_setr_ph(0.0, 2.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0);
@@ -20311,7 +20311,7 @@ mod tests {
         assert_eq_m512h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_fmadd_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -20321,7 +20321,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_fmadd_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -20334,7 +20334,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask3_fmadd_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -20347,7 +20347,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_fmadd_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -20360,7 +20360,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_fmadd_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -20370,7 +20370,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_fmadd_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -20387,7 +20387,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask3_fmadd_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -20404,7 +20404,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_fmadd_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -20620,7 +20620,7 @@ mod tests {
         assert_eq_m512h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_fmsub_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -20630,7 +20630,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_fmsub_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -20643,7 +20643,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask3_fmsub_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -20656,7 +20656,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_fmsub_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -20669,7 +20669,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_fmsub_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -20930,7 +20930,7 @@ mod tests {
         assert_eq_m512h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_fnmadd_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -20940,7 +20940,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_fnmadd_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -20953,7 +20953,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask3_fnmadd_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -20966,7 +20966,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_fnmadd_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -20979,7 +20979,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_fnmadd_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -20989,7 +20989,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_fnmadd_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -21006,7 +21006,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask3_fnmadd_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -21023,7 +21023,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_fnmadd_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -21240,7 +21240,7 @@ mod tests {
         assert_eq_m512h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_fnmsub_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -21250,7 +21250,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_fnmsub_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -21263,7 +21263,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask3_fnmsub_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -21276,7 +21276,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_fnmsub_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -21289,7 +21289,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_fnmsub_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -21299,7 +21299,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_fnmsub_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -21316,7 +21316,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask3_fnmsub_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -21333,7 +21333,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_fnmsub_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(2.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -21851,7 +21851,7 @@ mod tests {
         assert_eq_m512h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_rcp_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
@@ -21860,7 +21860,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_rcp_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
@@ -21873,7 +21873,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_rcp_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
@@ -21970,7 +21970,7 @@ mod tests {
         assert_eq_m512h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_rsqrt_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(4.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0);
@@ -21979,7 +21979,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_rsqrt_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(4.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0);
@@ -21992,7 +21992,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_rsqrt_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(4.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0);
@@ -22127,7 +22127,7 @@ mod tests {
         assert_eq_m512h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_sqrt_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(4.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0);
@@ -22136,7 +22136,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_sqrt_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(4.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0);
@@ -22149,7 +22149,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_sqrt_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(4.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0);
@@ -22161,7 +22161,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_sqrt_round_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(4.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0);
@@ -22170,7 +22170,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_sqrt_round_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(4.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0);
@@ -22187,7 +22187,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_sqrt_round_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(4.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0);
@@ -22338,7 +22338,7 @@ mod tests {
         assert_eq_m512h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_max_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
@@ -22347,7 +22347,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_max_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
@@ -22360,7 +22360,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_max_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
@@ -22372,7 +22372,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_max_round_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
@@ -22381,7 +22381,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_max_round_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
@@ -22398,7 +22398,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_max_round_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
@@ -22549,7 +22549,7 @@ mod tests {
         assert_eq_m512h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_min_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
@@ -22558,7 +22558,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_min_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
@@ -22571,7 +22571,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_min_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
@@ -22583,7 +22583,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_min_round_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
@@ -22592,7 +22592,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_min_round_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
@@ -22609,7 +22609,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_min_round_sh() {
         let a = _mm_setr_ph(1.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
         let b = _mm_setr_ph(2.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0);
@@ -22746,7 +22746,7 @@ mod tests {
         assert_eq_m512h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_getexp_sh() {
         let a = _mm_setr_ph(4.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(3.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -22755,7 +22755,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_getexp_sh() {
         let a = _mm_setr_ph(4.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(3.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -22768,7 +22768,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_getexp_sh() {
         let a = _mm_setr_ph(4.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(3.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -22780,7 +22780,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_getexp_round_sh() {
         let a = _mm_setr_ph(4.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(3.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -22789,7 +22789,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_getexp_round_sh() {
         let a = _mm_setr_ph(4.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(3.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -22802,7 +22802,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_getexp_round_sh() {
         let a = _mm_setr_ph(4.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(3.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -22958,7 +22958,7 @@ mod tests {
         assert_eq_m512h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_getmant_sh() {
         let a = _mm_setr_ph(15.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(10.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -22967,7 +22967,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_getmant_sh() {
         let a = _mm_setr_ph(15.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(10.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -22980,7 +22980,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_getmant_sh() {
         let a = _mm_setr_ph(15.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(10.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -22992,7 +22992,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_getmant_round_sh() {
         let a = _mm_setr_ph(15.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(10.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -23003,7 +23003,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_getmant_round_sh() {
         let a = _mm_setr_ph(15.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(10.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -23024,7 +23024,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_getmant_round_sh() {
         let a = _mm_setr_ph(15.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(10.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -23167,7 +23167,7 @@ mod tests {
         assert_eq_m512h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_roundscale_sh() {
         let a = _mm_setr_ph(2.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(1.1, 20., 21., 22., 23., 24., 25., 26.);
@@ -23176,7 +23176,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_roundscale_sh() {
         let a = _mm_setr_ph(2.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(1.1, 20., 21., 22., 23., 24., 25., 26.);
@@ -23189,7 +23189,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_roundscale_sh() {
         let a = _mm_setr_ph(2.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(1.1, 20., 21., 22., 23., 24., 25., 26.);
@@ -23201,7 +23201,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_roundscale_round_sh() {
         let a = _mm_setr_ph(2.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(1.1, 20., 21., 22., 23., 24., 25., 26.);
@@ -23210,7 +23210,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_roundscale_round_sh() {
         let a = _mm_setr_ph(2.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(1.1, 20., 21., 22., 23., 24., 25., 26.);
@@ -23223,7 +23223,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_roundscale_round_sh() {
         let a = _mm_setr_ph(2.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(1.1, 20., 21., 22., 23., 24., 25., 26.);
@@ -23372,7 +23372,7 @@ mod tests {
         assert_eq_m512h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_scalef_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(3.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -23381,7 +23381,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_scalef_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(3.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -23394,7 +23394,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_scalef_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(3.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -23406,7 +23406,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_scalef_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(3.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -23415,7 +23415,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_scalef_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(3.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -23432,7 +23432,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_scalef_round_sh() {
         let a = _mm_setr_ph(1.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(3.0, 20., 21., 22., 23., 24., 25., 26.);
@@ -23576,7 +23576,7 @@ mod tests {
         assert_eq_m512h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_reduce_sh() {
         let a = _mm_setr_ph(3.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(1.25, 20., 21., 22., 23., 24., 25., 26.);
@@ -23585,7 +23585,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_reduce_sh() {
         let a = _mm_setr_ph(3.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(1.25, 20., 21., 22., 23., 24., 25., 26.);
@@ -23598,7 +23598,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_reduce_sh() {
         let a = _mm_setr_ph(3.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(1.25, 20., 21., 22., 23., 24., 25., 26.);
@@ -23610,7 +23610,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_reduce_round_sh() {
         let a = _mm_setr_ph(3.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(1.25, 20., 21., 22., 23., 24., 25., 26.);
@@ -23619,7 +23619,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_reduce_round_sh() {
         let a = _mm_setr_ph(3.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(1.25, 20., 21., 22., 23., 24., 25., 26.);
@@ -23636,7 +23636,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_reduce_round_sh() {
         let a = _mm_setr_ph(3.0, 10., 11., 12., 13., 14., 15., 16.);
         let b = _mm_setr_ph(1.25, 20., 21., 22., 23., 24., 25., 26.);
@@ -24505,7 +24505,7 @@ mod tests {
         assert_eq_m256h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_cvti32_sh() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvti32_sh(a, 10);
@@ -24513,7 +24513,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_cvt_roundi32_sh() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvt_roundi32_sh::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, 10);
@@ -24645,7 +24645,7 @@ mod tests {
         assert_eq_m256h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_cvtu32_sh() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvtu32_sh(a, 10);
@@ -24653,7 +24653,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_cvt_roundu32_sh() {
         let a = _mm_setr_ph(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm_cvt_roundu32_sh::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a, 10);
@@ -24711,7 +24711,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm512_cvtepi64_ph() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_cvtepi64_ph(a);
@@ -24719,7 +24719,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm512_mask_cvtepi64_ph() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let src = _mm_set_ph(10., 11., 12., 13., 14., 15., 16., 17.);
@@ -24728,7 +24728,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm512_maskz_cvtepi64_ph() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_maskz_cvtepi64_ph(0b01010101, a);
@@ -24736,7 +24736,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm512_cvt_roundepi64_ph() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_cvt_roundepi64_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a);
@@ -24755,7 +24755,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm512_maskz_cvt_roundepi64_ph() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_maskz_cvt_roundepi64_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -24815,7 +24815,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm512_cvtepu64_ph() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_cvtepu64_ph(a);
@@ -24823,7 +24823,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm512_mask_cvtepu64_ph() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let src = _mm_set_ph(10., 11., 12., 13., 14., 15., 16., 17.);
@@ -24832,7 +24832,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm512_maskz_cvtepu64_ph() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_maskz_cvtepu64_ph(0b01010101, a);
@@ -24840,7 +24840,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm512_cvt_roundepu64_ph() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_cvt_roundepu64_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a);
@@ -24848,7 +24848,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm512_mask_cvt_roundepu64_ph() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let src = _mm_set_ph(10., 11., 12., 13., 14., 15., 16., 17.);
@@ -24859,7 +24859,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm512_maskz_cvt_roundepu64_ph() {
         let a = _mm512_set_epi64(1, 2, 3, 4, 5, 6, 7, 8);
         let r = _mm512_maskz_cvt_roundepu64_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -25005,7 +25005,7 @@ mod tests {
         assert_eq_m256h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_cvtss_sh() {
         let a = _mm_setr_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let b = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
@@ -25014,7 +25014,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_cvtss_sh() {
         let a = _mm_setr_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let b = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
@@ -25027,7 +25027,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_cvtss_sh() {
         let a = _mm_setr_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let b = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
@@ -25039,7 +25039,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_cvt_roundss_sh() {
         let a = _mm_setr_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let b = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
@@ -25048,7 +25048,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_cvt_roundss_sh() {
         let a = _mm_setr_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let b = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
@@ -25065,7 +25065,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_cvt_roundss_sh() {
         let a = _mm_setr_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let b = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
@@ -25129,7 +25129,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm512_cvtpd_ph() {
         let a = _mm512_set_pd(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_cvtpd_ph(a);
@@ -25137,7 +25137,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm512_mask_cvtpd_ph() {
         let a = _mm512_set_pd(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let src = _mm_set_ph(10., 11., 12., 13., 14., 15., 16., 17.);
@@ -25146,7 +25146,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm512_maskz_cvtpd_ph() {
         let a = _mm512_set_pd(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_maskz_cvtpd_ph(0b01010101, a);
@@ -25154,7 +25154,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm512_cvt_roundpd_ph() {
         let a = _mm512_set_pd(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_cvt_roundpd_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(a);
@@ -25162,7 +25162,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm512_mask_cvt_roundpd_ph() {
         let a = _mm512_set_pd(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let src = _mm_set_ph(10., 11., 12., 13., 14., 15., 16., 17.);
@@ -25173,7 +25173,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm512_maskz_cvt_roundpd_ph() {
         let a = _mm512_set_pd(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
         let r = _mm512_maskz_cvt_roundpd_ph::<{ _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC }>(
@@ -25183,7 +25183,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_cvtsd_sh() {
         let a = _mm_setr_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let b = _mm_setr_pd(1.0, 2.0);
@@ -25192,7 +25192,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_cvtsd_sh() {
         let a = _mm_setr_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let b = _mm_setr_pd(1.0, 2.0);
@@ -25205,7 +25205,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_cvtsd_sh() {
         let a = _mm_setr_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let b = _mm_setr_pd(1.0, 2.0);
@@ -25217,7 +25217,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_cvt_roundsd_sh() {
         let a = _mm_setr_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let b = _mm_setr_pd(1.0, 2.0);
@@ -25226,7 +25226,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_mask_cvt_roundsd_sh() {
         let a = _mm_setr_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let b = _mm_setr_pd(1.0, 2.0);
@@ -25243,7 +25243,7 @@ mod tests {
         assert_eq_m128h(r, e);
     }
 
-    #[simd_test(enable = "avx512fp16")]
+    #[simd_test(enable = "avx512fp16,avx512vl")]
     unsafe fn test_mm_maskz_cvt_roundsd_sh() {
         let a = _mm_setr_ph(10., 11., 12., 13., 14., 15., 16., 17.);
         let b = _mm_setr_pd(1.0, 2.0);

From 92f6310890e16790eb44abcb33cffa0f8090e0c3 Mon Sep 17 00:00:00 2001
From: Nikita Popov <npopov@redhat.com>
Date: Wed, 20 Aug 2025 11:00:47 +0200
Subject: [PATCH 0128/1889] Work around selection failure without avx512vl

---
 library/stdarch/crates/core_arch/src/x86/avx512f.rs    | 8 ++++++--
 library/stdarch/crates/core_arch/src/x86_64/avx512f.rs | 8 ++++++--
 2 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/library/stdarch/crates/core_arch/src/x86/avx512f.rs b/library/stdarch/crates/core_arch/src/x86/avx512f.rs
index d53f83c0a10bc..cad8ca0c63ce0 100644
--- a/library/stdarch/crates/core_arch/src/x86/avx512f.rs
+++ b/library/stdarch/crates/core_arch/src/x86/avx512f.rs
@@ -49621,7 +49621,9 @@ mod tests {
         assert_eq_m512i(r, e);
     }
 
-    #[simd_test(enable = "avx512f")]
+    // FIXME(llvm): https://github.com/llvm/llvm-project/issues/154492
+    //#[simd_test(enable = "avx512f")]
+    #[simd_test(enable = "avx512f,avx512vl")]
     unsafe fn test_mm512_mask_cvttps_epu32() {
         let a = _mm512_setr_ps(
             0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5,
@@ -49634,7 +49636,9 @@ mod tests {
         assert_eq_m512i(r, e);
     }
 
-    #[simd_test(enable = "avx512f")]
+    // FIXME(llvm): https://github.com/llvm/llvm-project/issues/154492
+    //#[simd_test(enable = "avx512f")]
+    #[simd_test(enable = "avx512f,avx512vl")]
     unsafe fn test_mm512_maskz_cvttps_epu32() {
         let a = _mm512_setr_ps(
             0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5,
diff --git a/library/stdarch/crates/core_arch/src/x86_64/avx512f.rs b/library/stdarch/crates/core_arch/src/x86_64/avx512f.rs
index 934c9e2812c42..a8dd340bd6605 100644
--- a/library/stdarch/crates/core_arch/src/x86_64/avx512f.rs
+++ b/library/stdarch/crates/core_arch/src/x86_64/avx512f.rs
@@ -5311,7 +5311,9 @@ mod tests {
         assert_eq_m256i(r, e);
     }
 
-    #[simd_test(enable = "avx512f")]
+    // FIXME(llvm): https://github.com/llvm/llvm-project/issues/154492
+    //#[simd_test(enable = "avx512f")]
+    #[simd_test(enable = "avx512f,avx512vl")]
     unsafe fn test_mm512_mask_cvttpd_epu32() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let src = _mm256_set1_epi32(0);
@@ -5322,7 +5324,9 @@ mod tests {
         assert_eq_m256i(r, e);
     }
 
-    #[simd_test(enable = "avx512f")]
+    // FIXME(llvm): https://github.com/llvm/llvm-project/issues/154492
+    //#[simd_test(enable = "avx512f")]
+    #[simd_test(enable = "avx512f,avx512vl")]
     unsafe fn test_mm512_maskz_cvttpd_epu32() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let r = _mm512_maskz_cvttpd_epu32(0, a);

From 3302e3e09a2f843ba7a20102f0f5f18909bc0b47 Mon Sep 17 00:00:00 2001
From: Nikita Popov <npopov@redhat.com>
Date: Wed, 20 Aug 2025 11:12:26 +0200
Subject: [PATCH 0129/1889] Adjust immediate for vrndscalepd tests

The immediate here encodes both the rounding mode (in the low bits)
and the scale (in the high bits). Make sure the scale is non-zero.
---
 library/stdarch/crates/core_arch/src/x86/avx512f.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/library/stdarch/crates/core_arch/src/x86/avx512f.rs b/library/stdarch/crates/core_arch/src/x86/avx512f.rs
index cad8ca0c63ce0..0803f2f81b215 100644
--- a/library/stdarch/crates/core_arch/src/x86/avx512f.rs
+++ b/library/stdarch/crates/core_arch/src/x86/avx512f.rs
@@ -5823,7 +5823,7 @@ pub fn _mm512_maskz_roundscale_pd<const IMM8: i32>(k: __mmask8, a: __m512d) -> _
 #[inline]
 #[target_feature(enable = "avx512f,avx512vl")]
 #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
-#[cfg_attr(test, assert_instr(vrndscalepd, IMM8 = 0))]
+#[cfg_attr(test, assert_instr(vrndscalepd, IMM8 = 16))]
 #[rustc_legacy_const_generics(1)]
 pub fn _mm256_roundscale_pd<const IMM8: i32>(a: __m256d) -> __m256d {
     unsafe {
@@ -5897,7 +5897,7 @@ pub fn _mm256_maskz_roundscale_pd<const IMM8: i32>(k: __mmask8, a: __m256d) -> _
 #[inline]
 #[target_feature(enable = "avx512f,avx512vl")]
 #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
-#[cfg_attr(test, assert_instr(vrndscalepd, IMM8 = 0))]
+#[cfg_attr(test, assert_instr(vrndscalepd, IMM8 = 16))]
 #[rustc_legacy_const_generics(1)]
 pub fn _mm_roundscale_pd<const IMM8: i32>(a: __m128d) -> __m128d {
     unsafe {

From 7d09ce84ee0b9b63e44ec90241ff9e6584068164 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 20 Aug 2025 09:50:54 +0000
Subject: [PATCH 0130/1889] Bump slab from 0.4.10 to 0.4.11 in /tests/deps

Bumps [slab](https://github.com/tokio-rs/slab) from 0.4.10 to 0.4.11.
- [Release notes](https://github.com/tokio-rs/slab/releases)
- [Changelog](https://github.com/tokio-rs/slab/blob/master/CHANGELOG.md)
- [Commits](https://github.com/tokio-rs/slab/compare/v0.4.10...v0.4.11)

---
updated-dependencies:
- dependency-name: slab
  dependency-version: 0.4.11
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 src/tools/miri/tests/deps/Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/tools/miri/tests/deps/Cargo.lock b/src/tools/miri/tests/deps/Cargo.lock
index 4b783ebdc4eed..65ca4215c6001 100644
--- a/src/tools/miri/tests/deps/Cargo.lock
+++ b/src/tools/miri/tests/deps/Cargo.lock
@@ -296,9 +296,9 @@ dependencies = [
 
 [[package]]
 name = "slab"
-version = "0.4.10"
+version = "0.4.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04dc19736151f35336d325007ac991178d504a119863a2fcb3758cdb5e52c50d"
+checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589"
 
 [[package]]
 name = "socket2"

From fa163a1fcaa1d46a62d4a19b9354da5583dbf5d1 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Wed, 20 Aug 2025 18:02:12 +0200
Subject: [PATCH 0131/1889] s390x: define `unpack_low` using
 `core::intrinsics::simd`

---
 .../crates/core_arch/src/s390x/vector.rs        | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/library/stdarch/crates/core_arch/src/s390x/vector.rs b/library/stdarch/crates/core_arch/src/s390x/vector.rs
index 9927ff2c62555..2969516c9ae44 100644
--- a/library/stdarch/crates/core_arch/src/s390x/vector.rs
+++ b/library/stdarch/crates/core_arch/src/s390x/vector.rs
@@ -169,13 +169,6 @@ unsafe extern "unadjusted" {
     #[link_name = "llvm.s390.vpklsfs"] fn vpklsfs(a: vector_unsigned_int, b: vector_unsigned_int) -> PackedTuple<vector_unsigned_short, i32>;
     #[link_name = "llvm.s390.vpklsgs"] fn vpklsgs(a: vector_unsigned_long_long, b: vector_unsigned_long_long) -> PackedTuple<vector_unsigned_int, i32>;
 
-    #[link_name = "llvm.s390.vuplb"] fn vuplb (a: vector_signed_char) -> vector_signed_short;
-    #[link_name = "llvm.s390.vuplhw"] fn vuplhw (a: vector_signed_short) -> vector_signed_int;
-    #[link_name = "llvm.s390.vuplf"] fn vuplf (a: vector_signed_int) -> vector_signed_long_long;
-    #[link_name = "llvm.s390.vupllb"] fn vupllb (a: vector_unsigned_char) -> vector_unsigned_short;
-    #[link_name = "llvm.s390.vupllh"] fn vupllh (a: vector_unsigned_short) -> vector_unsigned_int;
-    #[link_name = "llvm.s390.vupllf"] fn vupllf (a: vector_unsigned_int) -> vector_unsigned_long_long;
-
     #[link_name = "llvm.s390.vavgb"] fn vavgb(a: vector_signed_char, b: vector_signed_char) -> vector_signed_char;
     #[link_name = "llvm.s390.vavgh"] fn vavgh(a: vector_signed_short, b: vector_signed_short) -> vector_signed_short;
     #[link_name = "llvm.s390.vavgf"] fn vavgf(a: vector_signed_int, b: vector_signed_int) -> vector_signed_int;
@@ -2583,8 +2576,14 @@ mod sealed {
         unsafe fn vec_unpackl(self) -> Self::Result;
     }
 
-    // FIXME(llvm): a shuffle + simd_as does not currently optimize into a single instruction like
-    // unpachk above. Tracked in https://github.com/llvm/llvm-project/issues/129576.
+    // NOTE: `vuplh` is used for "unpack logical high", hence `vuplhw`.
+    impl_vec_unpack!(unpack_low vuplb vector_signed_char i8x8 vector_signed_short 8);
+    impl_vec_unpack!(unpack_low vuplhw vector_signed_short i16x4 vector_signed_int 4);
+    impl_vec_unpack!(unpack_low vuplf vector_signed_int i32x2 vector_signed_long_long 2);
+
+    impl_vec_unpack!(unpack_low vupllb vector_unsigned_char u8x8 vector_unsigned_short 8);
+    impl_vec_unpack!(unpack_low vupllh vector_unsigned_short u16x4 vector_unsigned_int 4);
+    impl_vec_unpack!(unpack_low vupllf vector_unsigned_int u32x2 vector_unsigned_long_long 2);
 
     impl_vec_trait! {[VectorUnpackl vec_unpackl] vuplb (vector_signed_char) -> vector_signed_short}
     impl_vec_trait! {[VectorUnpackl vec_unpackl] vuplhw (vector_signed_short) -> vector_signed_int}

From c5ec0960f0a1d78584b4957dd71613bdbcb91de8 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Wed, 20 Aug 2025 18:03:04 +0200
Subject: [PATCH 0132/1889] s390x: add `assert_instr` for `vec_round`

---
 library/stdarch/crates/core_arch/src/s390x/vector.rs | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/library/stdarch/crates/core_arch/src/s390x/vector.rs b/library/stdarch/crates/core_arch/src/s390x/vector.rs
index 2969516c9ae44..066ae1607316d 100644
--- a/library/stdarch/crates/core_arch/src/s390x/vector.rs
+++ b/library/stdarch/crates/core_arch/src/s390x/vector.rs
@@ -1194,10 +1194,8 @@ mod sealed {
     test_impl! { vec_roundc_f32 (a: vector_float) -> vector_float [nearbyint_v4f32,  "vector-enhancements-1" vfisb] }
     test_impl! { vec_roundc_f64 (a: vector_double) -> vector_double [nearbyint_v2f64, vfidb] }
 
-    // FIXME(llvm) llvm trunk already lowers roundeven to vfidb, but rust does not use it yet
-    // use https://godbolt.org/z/cWq95fexe to check, and enable the instruction test when it works
-    test_impl! { vec_round_f32 (a: vector_float) -> vector_float [roundeven_v4f32, _] }
-    test_impl! { vec_round_f64 (a: vector_double) -> vector_double [roundeven_v2f64, _] }
+    test_impl! { vec_round_f32 (a: vector_float) -> vector_float [roundeven_v4f32, "vector-enhancements-1" vfisb] }
+    test_impl! { vec_round_f64 (a: vector_double) -> vector_double [roundeven_v2f64, vfidb] }
 
     #[unstable(feature = "stdarch_s390x", issue = "135681")]
     pub trait VectorRoundc {

From 97d64665b9e4e390cd3cadf403de5cfa67b3216a Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Wed, 20 Aug 2025 18:03:41 +0200
Subject: [PATCH 0133/1889] s390x: add `assert_instr` for `vec_extend`

---
 library/stdarch/crates/core_arch/src/s390x/vector.rs | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/library/stdarch/crates/core_arch/src/s390x/vector.rs b/library/stdarch/crates/core_arch/src/s390x/vector.rs
index 066ae1607316d..b010b7e38267e 100644
--- a/library/stdarch/crates/core_arch/src/s390x/vector.rs
+++ b/library/stdarch/crates/core_arch/src/s390x/vector.rs
@@ -3319,8 +3319,7 @@ mod sealed {
 
     #[inline]
     #[target_feature(enable = "vector")]
-    // FIXME(llvm): https://github.com/llvm/llvm-project/issues/129899
-    // #[cfg_attr(test, assert_instr(vsegb))]
+    #[cfg_attr(test, assert_instr(vsegb))]
     pub unsafe fn vsegb(a: vector_signed_char) -> vector_signed_long_long {
         simd_as(simd_shuffle::<_, _, i8x2>(
             a,
@@ -3331,8 +3330,7 @@ mod sealed {
 
     #[inline]
     #[target_feature(enable = "vector")]
-    // FIXME(llvm): https://github.com/llvm/llvm-project/issues/129899
-    // #[cfg_attr(test, assert_instr(vsegh))]
+    #[cfg_attr(test, assert_instr(vsegh))]
     pub unsafe fn vsegh(a: vector_signed_short) -> vector_signed_long_long {
         simd_as(simd_shuffle::<_, _, i16x2>(
             a,
@@ -3343,8 +3341,7 @@ mod sealed {
 
     #[inline]
     #[target_feature(enable = "vector")]
-    // FIXME(llvm): https://github.com/llvm/llvm-project/issues/129899
-    // #[cfg_attr(test, assert_instr(vsegf))]
+    #[cfg_attr(test, assert_instr(vsegf))]
     pub unsafe fn vsegf(a: vector_signed_int) -> vector_signed_long_long {
         simd_as(simd_shuffle::<_, _, i32x2>(
             a,

From 1cda88aca15307dbcd1f6404875999373105a93d Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Wed, 20 Aug 2025 18:04:15 +0200
Subject: [PATCH 0134/1889] s390x: implement `vec_mule` using
 `core::intrinsics::simd`

---
 .../crates/core_arch/src/s390x/vector.rs      | 85 ++++++++++---------
 1 file changed, 47 insertions(+), 38 deletions(-)

diff --git a/library/stdarch/crates/core_arch/src/s390x/vector.rs b/library/stdarch/crates/core_arch/src/s390x/vector.rs
index b010b7e38267e..2af5edb9fb005 100644
--- a/library/stdarch/crates/core_arch/src/s390x/vector.rs
+++ b/library/stdarch/crates/core_arch/src/s390x/vector.rs
@@ -181,14 +181,6 @@ unsafe extern "unadjusted" {
 
     #[link_name = "llvm.s390.vcksm"] fn vcksm(a: vector_unsigned_int, b: vector_unsigned_int) -> vector_unsigned_int;
 
-    #[link_name = "llvm.s390.vmeb"] fn vmeb(a: vector_signed_char, b: vector_signed_char) -> vector_signed_short;
-    #[link_name = "llvm.s390.vmeh"] fn vmeh(a: vector_signed_short, b: vector_signed_short) -> vector_signed_int;
-    #[link_name = "llvm.s390.vmef"] fn vmef(a: vector_signed_int, b: vector_signed_int) -> vector_signed_long_long;
-
-    #[link_name = "llvm.s390.vmleb"] fn vmleb(a: vector_unsigned_char, b: vector_unsigned_char) -> vector_unsigned_short;
-    #[link_name = "llvm.s390.vmleh"] fn vmleh(a: vector_unsigned_short, b: vector_unsigned_short) -> vector_unsigned_int;
-    #[link_name = "llvm.s390.vmlef"] fn vmlef(a: vector_unsigned_int, b: vector_unsigned_int) -> vector_unsigned_long_long;
-
     #[link_name = "llvm.s390.vmob"] fn vmob(a: vector_signed_char, b: vector_signed_char) -> vector_signed_short;
     #[link_name = "llvm.s390.vmoh"] fn vmoh(a: vector_signed_short, b: vector_signed_short) -> vector_signed_int;
     #[link_name = "llvm.s390.vmof"] fn vmof(a: vector_signed_int, b: vector_signed_int) -> vector_signed_long_long;
@@ -372,6 +364,19 @@ impl<const N: usize> ShuffleMask<N> {
         ShuffleMask(mask)
     }
 
+    const fn even() -> Self {
+        let mut mask = [0; N];
+        let mut i = 0;
+        let mut index = 0;
+        while index < N {
+            mask[index] = i as u32;
+
+            i += 2;
+            index += 1;
+        }
+        ShuffleMask(mask)
+    }
+
     const fn pack() -> Self {
         let mut mask = [0; N];
         let mut i = 1;
@@ -2642,40 +2647,44 @@ mod sealed {
         unsafe fn vec_mule(self, b: Self) -> Result;
     }
 
-    // FIXME(llvm) sadly this does not yet work https://github.com/llvm/llvm-project/issues/129705
-    //    #[target_feature(enable = "vector")]
-    //    #[cfg_attr(test, assert_instr(vmleh))]
-    //    unsafe fn vec_vmleh(a: vector_unsigned_short, b: vector_unsigned_short) -> vector_unsigned_int {
-    //        let even_a: vector_unsigned_int = simd_as(simd_shuffle::<_, _, u16x4>(
-    //            a,
-    //            a,
-    //            const { ShuffleMask([0, 2, 4, 6]) },
-    //        ));
-    //
-    //        let even_b: vector_unsigned_int = simd_as(simd_shuffle::<_, _, u16x4>(
-    //            b,
-    //            b,
-    //            const { ShuffleMask([0, 2, 4, 6]) },
-    //        ));
-    //
-    //        simd_mul(even_a, even_b)
-    //    }
+    macro_rules! impl_vec_mule {
+        ($instr:ident $src:ident $shuffled:ident $dst:ident $width:literal) => {
+            #[inline]
+            #[target_feature(enable = "vector")]
+            #[cfg_attr(test, assert_instr($instr))]
+            unsafe fn $instr(a: $src, b: $src) -> $dst {
+                let even_a: $dst = simd_as(simd_shuffle::<_, _, $shuffled>(
+                    a,
+                    a,
+                    const { ShuffleMask::<$width>::even() },
+                ));
+
+                let even_b: $dst = simd_as(simd_shuffle::<_, _, $shuffled>(
+                    b,
+                    b,
+                    const { ShuffleMask::<$width>::even() },
+                ));
+
+                simd_mul(even_a, even_b)
+            }
+        };
+    }
 
-    test_impl! { vec_vmeb(a: vector_signed_char, b: vector_signed_char) -> vector_signed_short [ vmeb, vmeb ] }
-    test_impl! { vec_vmeh(a: vector_signed_short, b: vector_signed_short) -> vector_signed_int[ vmeh, vmeh ] }
-    test_impl! { vec_vmef(a: vector_signed_int, b: vector_signed_int) -> vector_signed_long_long [ vmef, vmef ] }
+    impl_vec_mule! { vmeb vector_signed_char i8x8 vector_signed_short 8 }
+    impl_vec_mule! { vmeh vector_signed_short i16x4 vector_signed_int 4 }
+    impl_vec_mule! { vmef vector_signed_int i32x2 vector_signed_long_long 2 }
 
-    test_impl! { vec_vmleb(a: vector_unsigned_char, b: vector_unsigned_char) -> vector_unsigned_short [ vmleb, vmleb ] }
-    test_impl! { vec_vmleh(a: vector_unsigned_short, b: vector_unsigned_short) -> vector_unsigned_int[ vmleh, vmleh ] }
-    test_impl! { vec_vmlef(a: vector_unsigned_int, b: vector_unsigned_int) -> vector_unsigned_long_long [ vmlef, vmlef ] }
+    impl_vec_mule! { vmleb vector_unsigned_char u8x8 vector_unsigned_short 8 }
+    impl_vec_mule! { vmleh vector_unsigned_short u16x4 vector_unsigned_int 4 }
+    impl_vec_mule! { vmlef vector_unsigned_int u32x2 vector_unsigned_long_long 2 }
 
-    impl_mul!([VectorMule vec_mule] vec_vmeb (vector_signed_char, vector_signed_char) -> vector_signed_short );
-    impl_mul!([VectorMule vec_mule] vec_vmeh (vector_signed_short, vector_signed_short) -> vector_signed_int);
-    impl_mul!([VectorMule vec_mule] vec_vmef (vector_signed_int, vector_signed_int) -> vector_signed_long_long );
+    impl_mul!([VectorMule vec_mule] vmeb (vector_signed_char, vector_signed_char) -> vector_signed_short );
+    impl_mul!([VectorMule vec_mule] vmeh (vector_signed_short, vector_signed_short) -> vector_signed_int);
+    impl_mul!([VectorMule vec_mule] vmef (vector_signed_int, vector_signed_int) -> vector_signed_long_long );
 
-    impl_mul!([VectorMule vec_mule] vec_vmleb (vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_short );
-    impl_mul!([VectorMule vec_mule] vec_vmleh (vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_int);
-    impl_mul!([VectorMule vec_mule] vec_vmlef (vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_long_long );
+    impl_mul!([VectorMule vec_mule] vmleb (vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_short );
+    impl_mul!([VectorMule vec_mule] vmleh (vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_int);
+    impl_mul!([VectorMule vec_mule] vmlef (vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_long_long );
 
     #[unstable(feature = "stdarch_s390x", issue = "135681")]
     pub trait VectorMulo<Result> {

From d5cb1c49fa415b512c0616730193467fd5fe2a9a Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Thu, 14 Aug 2025 18:51:39 +0200
Subject: [PATCH 0135/1889] wasm: use `{read, write}_unaligned` methods

---
 .../crates/core_arch/src/wasm32/simd128.rs    | 38 +++++++------------
 1 file changed, 14 insertions(+), 24 deletions(-)

diff --git a/library/stdarch/crates/core_arch/src/wasm32/simd128.rs b/library/stdarch/crates/core_arch/src/wasm32/simd128.rs
index 108bc3125c5f3..c864d6a516e08 100644
--- a/library/stdarch/crates/core_arch/src/wasm32/simd128.rs
+++ b/library/stdarch/crates/core_arch/src/wasm32/simd128.rs
@@ -141,16 +141,6 @@ unsafe extern "unadjusted" {
     fn llvm_f64x2_max(x: simd::f64x2, y: simd::f64x2) -> simd::f64x2;
 }
 
-#[repr(C, packed)]
-#[derive(Copy)]
-struct Unaligned<T>(T);
-
-impl<T: Copy> Clone for Unaligned<T> {
-    fn clone(&self) -> Unaligned<T> {
-        *self
-    }
-}
-
 /// Loads a `v128` vector from the given heap address.
 ///
 /// This intrinsic will emit a load with an alignment of 1. While this is
@@ -179,7 +169,7 @@ impl<T: Copy> Clone for Unaligned<T> {
 #[doc(alias("v128.load"))]
 #[stable(feature = "wasm_simd", since = "1.54.0")]
 pub unsafe fn v128_load(m: *const v128) -> v128 {
-    (*(m as *const Unaligned<v128>)).0
+    m.read_unaligned()
 }
 
 /// Load eight 8-bit integers and sign extend each one to a 16-bit lane
@@ -196,8 +186,8 @@ pub unsafe fn v128_load(m: *const v128) -> v128 {
 #[doc(alias("v128.load8x8_s"))]
 #[stable(feature = "wasm_simd", since = "1.54.0")]
 pub unsafe fn i16x8_load_extend_i8x8(m: *const i8) -> v128 {
-    let m = *(m as *const Unaligned<simd::i8x8>);
-    simd_cast::<_, simd::i16x8>(m.0).v128()
+    let m = m.cast::<simd::i8x8>().read_unaligned();
+    simd_cast::<_, simd::i16x8>(m).v128()
 }
 
 /// Load eight 8-bit integers and zero extend each one to a 16-bit lane
@@ -214,8 +204,8 @@ pub unsafe fn i16x8_load_extend_i8x8(m: *const i8) -> v128 {
 #[doc(alias("v128.load8x8_u"))]
 #[stable(feature = "wasm_simd", since = "1.54.0")]
 pub unsafe fn i16x8_load_extend_u8x8(m: *const u8) -> v128 {
-    let m = *(m as *const Unaligned<simd::u8x8>);
-    simd_cast::<_, simd::u16x8>(m.0).v128()
+    let m = m.cast::<simd::u8x8>().read_unaligned();
+    simd_cast::<_, simd::u16x8>(m).v128()
 }
 
 #[stable(feature = "wasm_simd", since = "1.54.0")]
@@ -235,8 +225,8 @@ pub use i16x8_load_extend_u8x8 as u16x8_load_extend_u8x8;
 #[doc(alias("v128.load16x4_s"))]
 #[stable(feature = "wasm_simd", since = "1.54.0")]
 pub unsafe fn i32x4_load_extend_i16x4(m: *const i16) -> v128 {
-    let m = *(m as *const Unaligned<simd::i16x4>);
-    simd_cast::<_, simd::i32x4>(m.0).v128()
+    let m = m.cast::<simd::i16x4>().read_unaligned();
+    simd_cast::<_, simd::i32x4>(m).v128()
 }
 
 /// Load four 16-bit integers and zero extend each one to a 32-bit lane
@@ -253,8 +243,8 @@ pub unsafe fn i32x4_load_extend_i16x4(m: *const i16) -> v128 {
 #[doc(alias("v128.load16x4_u"))]
 #[stable(feature = "wasm_simd", since = "1.54.0")]
 pub unsafe fn i32x4_load_extend_u16x4(m: *const u16) -> v128 {
-    let m = *(m as *const Unaligned<simd::u16x4>);
-    simd_cast::<_, simd::u32x4>(m.0).v128()
+    let m = m.cast::<simd::u16x4>().read_unaligned();
+    simd_cast::<_, simd::u32x4>(m).v128()
 }
 
 #[stable(feature = "wasm_simd", since = "1.54.0")]
@@ -274,8 +264,8 @@ pub use i32x4_load_extend_u16x4 as u32x4_load_extend_u16x4;
 #[doc(alias("v128.load32x2_s"))]
 #[stable(feature = "wasm_simd", since = "1.54.0")]
 pub unsafe fn i64x2_load_extend_i32x2(m: *const i32) -> v128 {
-    let m = *(m as *const Unaligned<simd::i32x2>);
-    simd_cast::<_, simd::i64x2>(m.0).v128()
+    let m = m.cast::<simd::i32x2>().read_unaligned();
+    simd_cast::<_, simd::i64x2>(m).v128()
 }
 
 /// Load two 32-bit integers and zero extend each one to a 64-bit lane
@@ -292,8 +282,8 @@ pub unsafe fn i64x2_load_extend_i32x2(m: *const i32) -> v128 {
 #[doc(alias("v128.load32x2_u"))]
 #[stable(feature = "wasm_simd", since = "1.54.0")]
 pub unsafe fn i64x2_load_extend_u32x2(m: *const u32) -> v128 {
-    let m = *(m as *const Unaligned<simd::u32x2>);
-    simd_cast::<_, simd::u64x2>(m.0).v128()
+    let m = m.cast::<simd::u32x2>().read_unaligned();
+    simd_cast::<_, simd::u64x2>(m).v128()
 }
 
 #[stable(feature = "wasm_simd", since = "1.54.0")]
@@ -453,7 +443,7 @@ pub unsafe fn v128_load64_zero(m: *const u64) -> v128 {
 #[doc(alias("v128.store"))]
 #[stable(feature = "wasm_simd", since = "1.54.0")]
 pub unsafe fn v128_store(m: *mut v128, a: v128) {
-    *(m as *mut Unaligned<v128>) = Unaligned(a);
+    m.write_unaligned(a)
 }
 
 /// Loads an 8-bit value from `m` and sets lane `L` of `v` to that value.

From e1a1b1ded2d14c2bb40d236a93ad629222db4da2 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Wed, 20 Aug 2025 21:18:39 +0200
Subject: [PATCH 0136/1889] s390x: implement `vec_mulo` using
 `core::intrinsics::simd`

---
 .../crates/core_arch/src/s390x/vector.rs      | 68 +++++++++----------
 1 file changed, 32 insertions(+), 36 deletions(-)

diff --git a/library/stdarch/crates/core_arch/src/s390x/vector.rs b/library/stdarch/crates/core_arch/src/s390x/vector.rs
index 2af5edb9fb005..6775225788925 100644
--- a/library/stdarch/crates/core_arch/src/s390x/vector.rs
+++ b/library/stdarch/crates/core_arch/src/s390x/vector.rs
@@ -181,14 +181,6 @@ unsafe extern "unadjusted" {
 
     #[link_name = "llvm.s390.vcksm"] fn vcksm(a: vector_unsigned_int, b: vector_unsigned_int) -> vector_unsigned_int;
 
-    #[link_name = "llvm.s390.vmob"] fn vmob(a: vector_signed_char, b: vector_signed_char) -> vector_signed_short;
-    #[link_name = "llvm.s390.vmoh"] fn vmoh(a: vector_signed_short, b: vector_signed_short) -> vector_signed_int;
-    #[link_name = "llvm.s390.vmof"] fn vmof(a: vector_signed_int, b: vector_signed_int) -> vector_signed_long_long;
-
-    #[link_name = "llvm.s390.vmlob"] fn vmlob(a: vector_unsigned_char, b: vector_unsigned_char) -> vector_unsigned_short;
-    #[link_name = "llvm.s390.vmloh"] fn vmloh(a: vector_unsigned_short, b: vector_unsigned_short) -> vector_unsigned_int;
-    #[link_name = "llvm.s390.vmlof"] fn vmlof(a: vector_unsigned_int, b: vector_unsigned_int) -> vector_unsigned_long_long;
-
     #[link_name = "llvm.s390.vmhb"] fn vmhb(a: vector_signed_char, b: vector_signed_char) -> vector_signed_char;
     #[link_name = "llvm.s390.vmhh"] fn vmhh(a: vector_signed_short, b: vector_signed_short) -> vector_signed_short;
     #[link_name = "llvm.s390.vmhf"] fn vmhf(a: vector_signed_int, b: vector_signed_int) -> vector_signed_int;
@@ -377,7 +369,7 @@ impl<const N: usize> ShuffleMask<N> {
         ShuffleMask(mask)
     }
 
-    const fn pack() -> Self {
+    const fn odd() -> Self {
         let mut mask = [0; N];
         let mut i = 1;
         let mut index = 0;
@@ -390,6 +382,10 @@ impl<const N: usize> ShuffleMask<N> {
         ShuffleMask(mask)
     }
 
+    const fn pack() -> Self {
+        Self::odd()
+    }
+
     const fn unpack_low() -> Self {
         let mut mask = [0; N];
         let mut i = 0;
@@ -2647,36 +2643,36 @@ mod sealed {
         unsafe fn vec_mule(self, b: Self) -> Result;
     }
 
-    macro_rules! impl_vec_mule {
-        ($instr:ident $src:ident $shuffled:ident $dst:ident $width:literal) => {
+    macro_rules! impl_vec_mul_even_odd {
+        ($mask:ident $instr:ident $src:ident $shuffled:ident $dst:ident $width:literal) => {
             #[inline]
             #[target_feature(enable = "vector")]
             #[cfg_attr(test, assert_instr($instr))]
             unsafe fn $instr(a: $src, b: $src) -> $dst {
-                let even_a: $dst = simd_as(simd_shuffle::<_, _, $shuffled>(
-                    a,
+                let elems_a: $dst = simd_as(simd_shuffle::<_, _, $shuffled>(
                     a,
-                    const { ShuffleMask::<$width>::even() },
+                    a, // this argument is ignored entirely.
+                    const { ShuffleMask::<$width>::$mask() },
                 ));
 
-                let even_b: $dst = simd_as(simd_shuffle::<_, _, $shuffled>(
+                let elems_b: $dst = simd_as(simd_shuffle::<_, _, $shuffled>(
                     b,
-                    b,
-                    const { ShuffleMask::<$width>::even() },
+                    b, // this argument is ignored entirely.
+                    const { ShuffleMask::<$width>::$mask() },
                 ));
 
-                simd_mul(even_a, even_b)
+                simd_mul(elems_a, elems_b)
             }
         };
     }
 
-    impl_vec_mule! { vmeb vector_signed_char i8x8 vector_signed_short 8 }
-    impl_vec_mule! { vmeh vector_signed_short i16x4 vector_signed_int 4 }
-    impl_vec_mule! { vmef vector_signed_int i32x2 vector_signed_long_long 2 }
+    impl_vec_mul_even_odd! { even vmeb vector_signed_char i8x8 vector_signed_short 8 }
+    impl_vec_mul_even_odd! { even vmeh vector_signed_short i16x4 vector_signed_int 4 }
+    impl_vec_mul_even_odd! { even vmef vector_signed_int i32x2 vector_signed_long_long 2 }
 
-    impl_vec_mule! { vmleb vector_unsigned_char u8x8 vector_unsigned_short 8 }
-    impl_vec_mule! { vmleh vector_unsigned_short u16x4 vector_unsigned_int 4 }
-    impl_vec_mule! { vmlef vector_unsigned_int u32x2 vector_unsigned_long_long 2 }
+    impl_vec_mul_even_odd! { even vmleb vector_unsigned_char u8x8 vector_unsigned_short 8 }
+    impl_vec_mul_even_odd! { even vmleh vector_unsigned_short u16x4 vector_unsigned_int 4 }
+    impl_vec_mul_even_odd! { even vmlef vector_unsigned_int u32x2 vector_unsigned_long_long 2 }
 
     impl_mul!([VectorMule vec_mule] vmeb (vector_signed_char, vector_signed_char) -> vector_signed_short );
     impl_mul!([VectorMule vec_mule] vmeh (vector_signed_short, vector_signed_short) -> vector_signed_int);
@@ -2691,21 +2687,21 @@ mod sealed {
         unsafe fn vec_mulo(self, b: Self) -> Result;
     }
 
-    test_impl! { vec_vmob(a: vector_signed_char, b: vector_signed_char) -> vector_signed_short [ vmob, vmob ] }
-    test_impl! { vec_vmoh(a: vector_signed_short, b: vector_signed_short) -> vector_signed_int[ vmoh, vmoh ] }
-    test_impl! { vec_vmof(a: vector_signed_int, b: vector_signed_int) -> vector_signed_long_long [ vmof, vmof ] }
+    impl_vec_mul_even_odd! { odd vmob vector_signed_char i8x8 vector_signed_short 8 }
+    impl_vec_mul_even_odd! { odd vmoh vector_signed_short i16x4 vector_signed_int 4 }
+    impl_vec_mul_even_odd! { odd vmof vector_signed_int i32x2 vector_signed_long_long 2 }
 
-    test_impl! { vec_vmlob(a: vector_unsigned_char, b: vector_unsigned_char) -> vector_unsigned_short [ vmlob, vmlob ] }
-    test_impl! { vec_vmloh(a: vector_unsigned_short, b: vector_unsigned_short) -> vector_unsigned_int[ vmloh, vmloh ] }
-    test_impl! { vec_vmlof(a: vector_unsigned_int, b: vector_unsigned_int) -> vector_unsigned_long_long [ vmlof, vmlof ] }
+    impl_vec_mul_even_odd! { odd vmlob vector_unsigned_char u8x8 vector_unsigned_short 8 }
+    impl_vec_mul_even_odd! { odd vmloh vector_unsigned_short u16x4 vector_unsigned_int 4 }
+    impl_vec_mul_even_odd! { odd vmlof vector_unsigned_int u32x2 vector_unsigned_long_long 2 }
 
-    impl_mul!([VectorMulo vec_mulo] vec_vmob (vector_signed_char, vector_signed_char) -> vector_signed_short );
-    impl_mul!([VectorMulo vec_mulo] vec_vmoh (vector_signed_short, vector_signed_short) -> vector_signed_int);
-    impl_mul!([VectorMulo vec_mulo] vec_vmof (vector_signed_int, vector_signed_int) -> vector_signed_long_long );
+    impl_mul!([VectorMulo vec_mulo] vmob (vector_signed_char, vector_signed_char) -> vector_signed_short );
+    impl_mul!([VectorMulo vec_mulo] vmoh (vector_signed_short, vector_signed_short) -> vector_signed_int);
+    impl_mul!([VectorMulo vec_mulo] vmof (vector_signed_int, vector_signed_int) -> vector_signed_long_long );
 
-    impl_mul!([VectorMulo vec_mulo] vec_vmlob (vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_short );
-    impl_mul!([VectorMulo vec_mulo] vec_vmloh (vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_int);
-    impl_mul!([VectorMulo vec_mulo] vec_vmlof (vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_long_long );
+    impl_mul!([VectorMulo vec_mulo] vmlob (vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_short );
+    impl_mul!([VectorMulo vec_mulo] vmloh (vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_int);
+    impl_mul!([VectorMulo vec_mulo] vmlof (vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_long_long );
 
     #[unstable(feature = "stdarch_s390x", issue = "135681")]
     pub trait VectorMulh<Result> {

From dfa95c6fa40374df410d3215d99d697c58f5da50 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Wed, 20 Aug 2025 18:08:51 +0200
Subject: [PATCH 0137/1889] s390x: implement `vec_subc_u128` using
 `overflowing_sub`

---
 library/stdarch/crates/core_arch/src/s390x/vector.rs | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/library/stdarch/crates/core_arch/src/s390x/vector.rs b/library/stdarch/crates/core_arch/src/s390x/vector.rs
index 6775225788925..4e4161dbb7f7f 100644
--- a/library/stdarch/crates/core_arch/src/s390x/vector.rs
+++ b/library/stdarch/crates/core_arch/src/s390x/vector.rs
@@ -4678,11 +4678,9 @@ pub unsafe fn vec_subc_u128(
     a: vector_unsigned_char,
     b: vector_unsigned_char,
 ) -> vector_unsigned_char {
-    // FIXME(llvm) sadly this does not work https://github.com/llvm/llvm-project/issues/129608
-    // let a: u128 = transmute(a);
-    // let b: u128 = transmute(b);
-    // transmute(!a.overflowing_sub(b).1 as u128)
-    transmute(vscbiq(transmute(a), transmute(b)))
+    let a: u128 = transmute(a);
+    let b: u128 = transmute(b);
+    transmute(!a.overflowing_sub(b).1 as u128)
 }
 
 /// Vector Add Compute Carryout unsigned 128-bits
@@ -4714,7 +4712,7 @@ pub unsafe fn vec_adde_u128(
     let a: u128 = transmute(a);
     let b: u128 = transmute(b);
     let c: u128 = transmute(c);
-    // FIXME(llvm) sadly this does not work
+    // FIXME(llvm) https://github.com/llvm/llvm-project/pull/153557
     //     let (d, _carry) = a.carrying_add(b, c & 1 != 0);
     //     transmute(d)
     transmute(vacq(a, b, c))

From e9162f221a154ff8dbf353275f3288f69c2c431f Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Wed, 20 Aug 2025 20:00:22 +0200
Subject: [PATCH 0138/1889] s390x: implement `vec_sld` using `fshl`

---
 .../crates/core_arch/src/s390x/vector.rs      | 55 ++++++++++++++++---
 1 file changed, 46 insertions(+), 9 deletions(-)

diff --git a/library/stdarch/crates/core_arch/src/s390x/vector.rs b/library/stdarch/crates/core_arch/src/s390x/vector.rs
index 4e4161dbb7f7f..9c2941129c869 100644
--- a/library/stdarch/crates/core_arch/src/s390x/vector.rs
+++ b/library/stdarch/crates/core_arch/src/s390x/vector.rs
@@ -94,8 +94,6 @@ unsafe extern "unadjusted" {
     #[link_name = "llvm.s390.vsrlb"] fn vsrlb(a: vector_signed_char, b: vector_signed_char) -> vector_signed_char;
     #[link_name = "llvm.s390.vslb"] fn vslb(a: vector_signed_char, b: vector_signed_char) -> vector_signed_char;
 
-    #[link_name = "llvm.s390.vsldb"] fn vsldb(a: i8x16, b: i8x16, c: u32) -> i8x16;
-    #[link_name = "llvm.s390.vsld"] fn vsld(a: i8x16, b: i8x16, c: u32) -> i8x16;
     #[link_name = "llvm.s390.vsrd"] fn vsrd(a: i8x16, b: i8x16, c: u32) -> i8x16;
 
     #[link_name = "llvm.s390.verimb"] fn verimb(a: vector_signed_char, b: vector_signed_char, c: vector_signed_char, d: i32) -> vector_signed_char;
@@ -3484,10 +3482,44 @@ mod sealed {
         unsafe fn vec_sldb<const C: u32>(self, b: Self) -> Self;
     }
 
-    // FIXME(llvm) https://github.com/llvm/llvm-project/issues/129955
-    // ideally we could implement this in terms of llvm.fshl.i128
-    // #[link_name = "llvm.fshl.i128"] fn fshl_i128(a: u128, b: u128, c: u128) -> u128;
-    // transmute(fshl_i128(transmute(a), transmute(b), const { C * 8 } ))
+    #[inline]
+    #[target_feature(enable = "vector")]
+    #[cfg_attr(test, assert_instr(vsldb))]
+    unsafe fn test_vec_sld(a: vector_signed_int, b: vector_signed_int) -> vector_signed_int {
+        a.vec_sld::<13>(b)
+    }
+
+    #[inline]
+    #[target_feature(enable = "vector")]
+    #[cfg_attr(test, assert_instr(vsldb))]
+    unsafe fn test_vec_sldw(a: vector_signed_int, b: vector_signed_int) -> vector_signed_int {
+        a.vec_sldw::<3>(b)
+    }
+
+    #[inline]
+    #[target_feature(enable = "vector-enhancements-2")]
+    #[cfg_attr(test, assert_instr(vsld))]
+    unsafe fn test_vec_sldb(a: vector_signed_int, b: vector_signed_int) -> vector_signed_int {
+        a.vec_sldb::<7>(b)
+    }
+
+    #[inline]
+    #[target_feature(enable = "vector-enhancements-2")]
+    #[cfg_attr(test, assert_instr(vsrd))]
+    unsafe fn test_vec_srdb(a: vector_signed_int, b: vector_signed_int) -> vector_signed_int {
+        a.vec_srdb::<7>(b)
+    }
+
+    unsafe fn funnel_shl_u128(a: u128, b: u128, c: u128) -> u128 {
+        #[repr(simd)]
+        struct Single([u128; 1]);
+
+        transmute(simd_funnel_shl::<Single>(
+            transmute(a),
+            transmute(b),
+            transmute(c),
+        ))
+    }
 
     macro_rules! impl_vec_sld {
         ($($ty:ident)*) => {
@@ -3498,21 +3530,21 @@ mod sealed {
                     #[target_feature(enable = "vector")]
                     unsafe fn vec_sld<const C: u32>(self, b: Self) -> Self {
                         static_assert_uimm_bits!(C, 4);
-                        transmute(vsldb(transmute(self), transmute(b), C))
+                        transmute(funnel_shl_u128(transmute(self), transmute(b), const { C as u128 * 8 }))
                     }
 
                     #[inline]
                     #[target_feature(enable = "vector")]
                     unsafe fn vec_sldw<const C: u32>(self, b: Self) -> Self {
                         static_assert_uimm_bits!(C, 2);
-                        transmute(vsldb(transmute(self), transmute(b), const { 4 * C }))
+                        transmute(funnel_shl_u128(transmute(self), transmute(b), const { C as u128 * 4 * 8 }))
                     }
 
                     #[inline]
                     #[target_feature(enable = "vector-enhancements-2")]
                     unsafe fn vec_sldb<const C: u32>(self, b: Self) -> Self {
                         static_assert_uimm_bits!(C, 3);
-                        transmute(vsld(transmute(self), transmute(b), C))
+                        transmute(funnel_shl_u128(transmute(self), transmute(b), const { C as u128 }))
                     }
                 }
 
@@ -3523,6 +3555,11 @@ mod sealed {
                     unsafe fn vec_srdb<const C: u32>(self, b: Self) -> Self {
                         static_assert_uimm_bits!(C, 3);
                         transmute(vsrd(transmute(self), transmute(b), C))
+                        // FIXME(llvm): https://github.com/llvm/llvm-project/issues/129955#issuecomment-3207488190
+                        // LLVM currently rewrites `fshr` to `fshl`, and the logic in the s390x
+                        // backend cannot deal with that yet.
+                        // #[link_name = "llvm.fshr.i128"] fn fshr_i128(a: u128, b: u128, c: u128) -> u128;
+                        // transmute(fshr_i128(transmute(self), transmute(b), const { C as u128 }))
                     }
                 }
             )*

From 45af206618d516571e6f526e4600ebaca92de6c0 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Wed, 20 Aug 2025 21:12:52 +0200
Subject: [PATCH 0139/1889] s390x: link to a missed optimization

---
 library/stdarch/crates/core_arch/src/s390x/vector.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/library/stdarch/crates/core_arch/src/s390x/vector.rs b/library/stdarch/crates/core_arch/src/s390x/vector.rs
index 9c2941129c869..f6d14c45e0d2b 100644
--- a/library/stdarch/crates/core_arch/src/s390x/vector.rs
+++ b/library/stdarch/crates/core_arch/src/s390x/vector.rs
@@ -2352,6 +2352,9 @@ mod sealed {
         unsafe fn vec_packs(self, b: Other) -> Self::Result;
     }
 
+    // FIXME(llvm): https://github.com/llvm/llvm-project/issues/153655
+    // Other targets can use a min/max for the saturation + a truncation.
+
     impl_vec_trait! { [VectorPacks vec_packs] vpksh (vector_signed_short, vector_signed_short) -> vector_signed_char }
     impl_vec_trait! { [VectorPacks vec_packs] vpklsh (vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_char }
     impl_vec_trait! { [VectorPacks vec_packs] vpksf (vector_signed_int, vector_signed_int) -> vector_signed_short }

From 220249eebb4cbd96fd77abb5878727f4ae4f6a6f Mon Sep 17 00:00:00 2001
From: yanglsh <yanglsh@shanghaitech.edu.cn>
Date: Wed, 18 Jun 2025 21:45:47 +0800
Subject: [PATCH 0140/1889] fix: `redundant_closure` suggests wrongly with
 deref overload

---
 clippy_lints/src/eta_reduction.rs | 21 ++++++++++++---
 tests/ui/eta.fixed                | 45 +++++++++++++++++++++++++++++++
 tests/ui/eta.rs                   | 45 +++++++++++++++++++++++++++++++
 tests/ui/eta.stderr               | 28 +++++++++++++++----
 4 files changed, 130 insertions(+), 9 deletions(-)

diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 0eefc2f610969..2da1c2bad1174 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -12,6 +12,7 @@ use rustc_hir::attrs::AttributeKind;
 use rustc_hir::{BindingMode, Expr, ExprKind, FnRetTy, GenericArgs, Param, PatKind, QPath, Safety, TyKind, find_attr};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::adjustment::Adjust;
 use rustc_middle::ty::{
     self, Binder, ClosureKind, FnSig, GenericArg, GenericArgKind, List, Region, Ty, TypeVisitableExt, TypeckResults,
 };
@@ -148,10 +149,9 @@ fn check_closure<'tcx>(cx: &LateContext<'tcx>, outer_receiver: Option<&Expr<'tcx
             {
                 return;
             }
-            let callee_ty_adjusted = typeck
-                .expr_adjustments(callee)
-                .last()
-                .map_or(callee_ty, |a| a.target.peel_refs());
+
+            let callee_ty_adjustments = typeck.expr_adjustments(callee);
+            let callee_ty_adjusted = callee_ty_adjustments.last().map_or(callee_ty, |a| a.target);
 
             let sig = match callee_ty_adjusted.kind() {
                 ty::FnDef(def, _) => {
@@ -230,7 +230,20 @@ fn check_closure<'tcx>(cx: &LateContext<'tcx>, outer_receiver: Option<&Expr<'tcx
                                     },
                                     _ => (),
                                 }
+                            } else if let n_refs =
+                                callee_ty_adjustments
+                                    .iter()
+                                    .rev()
+                                    .fold(0, |acc, adjustment| match adjustment.kind {
+                                        Adjust::Deref(Some(_)) => acc + 1,
+                                        Adjust::Deref(_) if acc > 0 => acc + 1,
+                                        _ => acc,
+                                    })
+                                && n_refs > 0
+                            {
+                                snippet = format!("{}{snippet}", "*".repeat(n_refs));
                             }
+
                             let replace_with = match callee_ty_adjusted.kind() {
                                 ty::FnDef(def, _) => cx.tcx.def_descr(*def),
                                 _ => "function",
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index 3d2b41b8fb81c..6944a979c05e6 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -565,6 +565,51 @@ fn issue_14789() {
     );
 }
 
+fn issue_15072() {
+    use std::ops::Deref;
+
+    struct Foo;
+    impl Deref for Foo {
+        type Target = fn() -> &'static str;
+
+        fn deref(&self) -> &Self::Target {
+            fn hello() -> &'static str {
+                "Hello, world!"
+            }
+            &(hello as fn() -> &'static str)
+        }
+    }
+
+    fn accepts_fn(f: impl Fn() -> &'static str) {
+        println!("{}", f());
+    }
+
+    fn some_fn() -> &'static str {
+        todo!()
+    }
+
+    let f = &Foo;
+    accepts_fn(**f);
+    //~^ redundant_closure
+
+    let g = &some_fn;
+    accepts_fn(g);
+    //~^ redundant_closure
+
+    struct Bar(Foo);
+    impl Deref for Bar {
+        type Target = Foo;
+
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    let b = &Bar(Foo);
+    accepts_fn(***b);
+    //~^ redundant_closure
+}
+
 fn issue8817() {
     fn f(_: u32) -> u32 {
         todo!()
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index 79d1103410d9d..5bcc1cb26fd78 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -565,6 +565,51 @@ fn issue_14789() {
     );
 }
 
+fn issue_15072() {
+    use std::ops::Deref;
+
+    struct Foo;
+    impl Deref for Foo {
+        type Target = fn() -> &'static str;
+
+        fn deref(&self) -> &Self::Target {
+            fn hello() -> &'static str {
+                "Hello, world!"
+            }
+            &(hello as fn() -> &'static str)
+        }
+    }
+
+    fn accepts_fn(f: impl Fn() -> &'static str) {
+        println!("{}", f());
+    }
+
+    fn some_fn() -> &'static str {
+        todo!()
+    }
+
+    let f = &Foo;
+    accepts_fn(|| f());
+    //~^ redundant_closure
+
+    let g = &some_fn;
+    accepts_fn(|| g());
+    //~^ redundant_closure
+
+    struct Bar(Foo);
+    impl Deref for Bar {
+        type Target = Foo;
+
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    let b = &Bar(Foo);
+    accepts_fn(|| b());
+    //~^ redundant_closure
+}
+
 fn issue8817() {
     fn f(_: u32) -> u32 {
         todo!()
diff --git a/tests/ui/eta.stderr b/tests/ui/eta.stderr
index aa32ed1a38ef6..0b401cdea9875 100644
--- a/tests/ui/eta.stderr
+++ b/tests/ui/eta.stderr
@@ -215,28 +215,46 @@ LL |         let _field = bind.or_else(|| get_default()).unwrap();
    |                                   ^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `get_default`
 
 error: redundant closure
-  --> tests/ui/eta.rs:588:14
+  --> tests/ui/eta.rs:592:16
+   |
+LL |     accepts_fn(|| f());
+   |                ^^^^^^ help: replace the closure with the function itself: `**f`
+
+error: redundant closure
+  --> tests/ui/eta.rs:596:16
+   |
+LL |     accepts_fn(|| g());
+   |                ^^^^^^ help: replace the closure with the function itself: `g`
+
+error: redundant closure
+  --> tests/ui/eta.rs:609:16
+   |
+LL |     accepts_fn(|| b());
+   |                ^^^^^^ help: replace the closure with the function itself: `***b`
+
+error: redundant closure
+  --> tests/ui/eta.rs:633:14
    |
 LL |         .map(|n| MyError::A(n))
    |              ^^^^^^^^^^^^^^^^^ help: replace the closure with the tuple variant itself: `MyError::A`
 
 error: redundant closure
-  --> tests/ui/eta.rs:585:14
+  --> tests/ui/eta.rs:630:14
    |
 LL |         .map(|n| S(n))
    |              ^^^^^^^^ help: replace the closure with the tuple struct itself: `S`
 
 error: redundant closure
-  --> tests/ui/eta.rs:582:14
+  --> tests/ui/eta.rs:627:14
    |
 LL |         .map(|n| g(n))
    |              ^^^^^^^^ help: replace the closure with the function itself: `g`
 
 error: redundant closure
-  --> tests/ui/eta.rs:579:14
+  --> tests/ui/eta.rs:624:14
    |
 LL |         .map(|n| f(n))
    |              ^^^^^^^^ help: replace the closure with the function itself: `f`
 
-error: aborting due to 39 previous errors
+error: aborting due to 42 previous errors
 

From f11d51273ccb540154748d9668c069bb8e50de3a Mon Sep 17 00:00:00 2001
From: yanglsh <yanglsh@shanghaitech.edu.cn>
Date: Wed, 13 Aug 2025 22:30:35 +0800
Subject: [PATCH 0141/1889] fix: `semicolon_inside_block` FP when attribute
 over expr is not enabled

---
 clippy_lints/src/semicolon_block.rs              |  5 +++++
 tests/ui/semicolon_inside_block.fixed            |  5 +++++
 tests/ui/semicolon_inside_block.rs               |  5 +++++
 .../semicolon_inside_block_stmt_expr_attrs.fixed | 11 +++++++++++
 .../ui/semicolon_inside_block_stmt_expr_attrs.rs | 11 +++++++++++
 ...semicolon_inside_block_stmt_expr_attrs.stderr | 16 ++++++++++++++++
 6 files changed, 53 insertions(+)
 create mode 100644 tests/ui/semicolon_inside_block_stmt_expr_attrs.fixed
 create mode 100644 tests/ui/semicolon_inside_block_stmt_expr_attrs.rs
 create mode 100644 tests/ui/semicolon_inside_block_stmt_expr_attrs.stderr

diff --git a/clippy_lints/src/semicolon_block.rs b/clippy_lints/src/semicolon_block.rs
index db91c57b18160..1dea8f17c34be 100644
--- a/clippy_lints/src/semicolon_block.rs
+++ b/clippy_lints/src/semicolon_block.rs
@@ -155,6 +155,11 @@ impl LateLintPass<'_> for SemicolonBlock {
                 kind: ExprKind::Block(block, _),
                 ..
             }) if !block.span.from_expansion() => {
+                let attrs = cx.tcx.hir_attrs(stmt.hir_id);
+                if !attrs.is_empty() && !cx.tcx.features().stmt_expr_attributes() {
+                    return;
+                }
+
                 if let Some(tail) = block.expr {
                     self.semicolon_inside_block(cx, block, tail, stmt.span);
                 }
diff --git a/tests/ui/semicolon_inside_block.fixed b/tests/ui/semicolon_inside_block.fixed
index 7eb53e733ad50..7308e78aae263 100644
--- a/tests/ui/semicolon_inside_block.fixed
+++ b/tests/ui/semicolon_inside_block.fixed
@@ -86,3 +86,8 @@ fn main() {
 
     unit_fn_block()
 }
+
+pub fn issue15388() {
+    #[rustfmt::skip]
+    {0; 0};
+}
diff --git a/tests/ui/semicolon_inside_block.rs b/tests/ui/semicolon_inside_block.rs
index 9fa5b117194d7..467bf4d779f2a 100644
--- a/tests/ui/semicolon_inside_block.rs
+++ b/tests/ui/semicolon_inside_block.rs
@@ -86,3 +86,8 @@ fn main() {
 
     unit_fn_block()
 }
+
+pub fn issue15388() {
+    #[rustfmt::skip]
+    {0; 0};
+}
diff --git a/tests/ui/semicolon_inside_block_stmt_expr_attrs.fixed b/tests/ui/semicolon_inside_block_stmt_expr_attrs.fixed
new file mode 100644
index 0000000000000..5b93a91da003a
--- /dev/null
+++ b/tests/ui/semicolon_inside_block_stmt_expr_attrs.fixed
@@ -0,0 +1,11 @@
+// Test when the feature `stmt_expr_attributes` is enabled
+
+#![feature(stmt_expr_attributes)]
+#![allow(clippy::no_effect)]
+#![warn(clippy::semicolon_inside_block)]
+
+pub fn issue15388() {
+    #[rustfmt::skip]
+    {0; 0;}
+    //~^ semicolon_inside_block
+}
diff --git a/tests/ui/semicolon_inside_block_stmt_expr_attrs.rs b/tests/ui/semicolon_inside_block_stmt_expr_attrs.rs
new file mode 100644
index 0000000000000..aa2c0cb50299c
--- /dev/null
+++ b/tests/ui/semicolon_inside_block_stmt_expr_attrs.rs
@@ -0,0 +1,11 @@
+// Test when the feature `stmt_expr_attributes` is enabled
+
+#![feature(stmt_expr_attributes)]
+#![allow(clippy::no_effect)]
+#![warn(clippy::semicolon_inside_block)]
+
+pub fn issue15388() {
+    #[rustfmt::skip]
+    {0; 0};
+    //~^ semicolon_inside_block
+}
diff --git a/tests/ui/semicolon_inside_block_stmt_expr_attrs.stderr b/tests/ui/semicolon_inside_block_stmt_expr_attrs.stderr
new file mode 100644
index 0000000000000..5bb91915a5fd8
--- /dev/null
+++ b/tests/ui/semicolon_inside_block_stmt_expr_attrs.stderr
@@ -0,0 +1,16 @@
+error: consider moving the `;` inside the block for consistent formatting
+  --> tests/ui/semicolon_inside_block_stmt_expr_attrs.rs:9:5
+   |
+LL |     {0; 0};
+   |     ^^^^^^^
+   |
+   = note: `-D clippy::semicolon-inside-block` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::semicolon_inside_block)]`
+help: put the `;` here
+   |
+LL -     {0; 0};
+LL +     {0; 0;}
+   |
+
+error: aborting due to 1 previous error
+

From 4a9b73bc98417d2335b7d3d86edf301bdd7be230 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Thu, 21 Aug 2025 07:14:55 +0300
Subject: [PATCH 0142/1889] Attach the DB in symbol queries

---
 .../crates/ide-db/src/symbol_index.rs         | 28 +++++++++++--------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-db/src/symbol_index.rs b/src/tools/rust-analyzer/crates/ide-db/src/symbol_index.rs
index 78ade30c7e3ed..76b647f8e9f2d 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/symbol_index.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/symbol_index.rs
@@ -133,23 +133,27 @@ pub trait SymbolsDatabase: HirDatabase + SourceDatabase {
 fn library_symbols(db: &dyn SymbolsDatabase, source_root_id: SourceRootId) -> Arc<SymbolIndex> {
     let _p = tracing::info_span!("library_symbols").entered();
 
-    let mut symbol_collector = SymbolCollector::new(db);
-
-    db.source_root_crates(source_root_id)
-        .iter()
-        .flat_map(|&krate| Crate::from(krate).modules(db))
-        // we specifically avoid calling other SymbolsDatabase queries here, even though they do the same thing,
-        // as the index for a library is not going to really ever change, and we do not want to store each
-        // the module or crate indices for those in salsa unless we need to.
-        .for_each(|module| symbol_collector.collect(module));
-
-    Arc::new(SymbolIndex::new(symbol_collector.finish()))
+    // We call this without attaching because this runs in parallel, so we need to attach here.
+    salsa::attach(db, || {
+        let mut symbol_collector = SymbolCollector::new(db);
+
+        db.source_root_crates(source_root_id)
+            .iter()
+            .flat_map(|&krate| Crate::from(krate).modules(db))
+            // we specifically avoid calling other SymbolsDatabase queries here, even though they do the same thing,
+            // as the index for a library is not going to really ever change, and we do not want to store each
+            // the module or crate indices for those in salsa unless we need to.
+            .for_each(|module| symbol_collector.collect(module));
+
+        Arc::new(SymbolIndex::new(symbol_collector.finish()))
+    })
 }
 
 fn module_symbols(db: &dyn SymbolsDatabase, module: Module) -> Arc<SymbolIndex> {
     let _p = tracing::info_span!("module_symbols").entered();
 
-    Arc::new(SymbolIndex::new(SymbolCollector::new_module(db, module)))
+    // We call this without attaching because this runs in parallel, so we need to attach here.
+    salsa::attach(db, || Arc::new(SymbolIndex::new(SymbolCollector::new_module(db, module))))
 }
 
 pub fn crate_symbols(db: &dyn SymbolsDatabase, krate: Crate) -> Box<[Arc<SymbolIndex>]> {

From 07aff76dda8fe022052de2ad7624df7de3306529 Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Thu, 21 Aug 2025 04:53:54 +0000
Subject: [PATCH 0143/1889] Prepare for merging from rust-lang/rust

This updates the rust-version file to 125ff8a788c5d6a66917f499abdc00051afe6886.
---
 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 59adc572eaa4b..85ce9ed79f431 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-f605b57042ffeb320d7ae44490113a827139b766
+125ff8a788c5d6a66917f499abdc00051afe6886

From 73d1aa9e8248d22cc6425714b9f3f44d34257e7a Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Thu, 21 Aug 2025 08:06:43 +0300
Subject: [PATCH 0144/1889] Attach the DB when mapping the result of
 `world_symbols()`

We call `try_to_nav()` there.
---
 src/tools/rust-analyzer/crates/ide/src/lib.rs | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide/src/lib.rs b/src/tools/rust-analyzer/crates/ide/src/lib.rs
index 874e04702e241..4b93535c89438 100644
--- a/src/tools/rust-analyzer/crates/ide/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/lib.rs
@@ -481,12 +481,15 @@ impl Analysis {
         // `world_symbols` currently clones the database to run stuff in parallel, which will make any query panic
         // if we were to attach it here.
         Cancelled::catch(|| {
-            symbol_index::world_symbols(&self.db, query)
-                .into_iter()
-                .filter_map(|s| s.try_to_nav(&self.db))
-                .take(limit)
-                .map(UpmappingResult::call_site)
-                .collect::<Vec<_>>()
+            let symbols = symbol_index::world_symbols(&self.db, query);
+            salsa::attach(&self.db, || {
+                symbols
+                    .into_iter()
+                    .filter_map(|s| s.try_to_nav(&self.db))
+                    .take(limit)
+                    .map(UpmappingResult::call_site)
+                    .collect::<Vec<_>>()
+            })
         })
     }
 

From 98bd1d744562947b54174668423bee572ed5b7ee Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Mon, 2 Jun 2025 00:02:35 +0200
Subject: [PATCH 0145/1889] use `simd_saturating_{add, sub}` on neon

---
 .../src/arm_shared/neon/generated.rs          | 320 ++----------------
 .../spec/neon/arm_shared.spec.yml             |  44 +--
 2 files changed, 48 insertions(+), 316 deletions(-)

diff --git a/library/stdarch/crates/core_arch/src/arm_shared/neon/generated.rs b/library/stdarch/crates/core_arch/src/arm_shared/neon/generated.rs
index fd150bcaf2b7f..22d31d4e25682 100644
--- a/library/stdarch/crates/core_arch/src/arm_shared/neon/generated.rs
+++ b/library/stdarch/crates/core_arch/src/arm_shared/neon/generated.rs
@@ -36978,15 +36978,7 @@ pub fn vqabsq_s32(a: int32x4_t) -> int32x4_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqadd_s8(a: int8x8_t, b: int8x8_t) -> int8x8_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.sqadd.v8i8"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.sadd.sat.v8i8")]
-        fn _vqadd_s8(a: int8x8_t, b: int8x8_t) -> int8x8_t;
-    }
-    unsafe { _vqadd_s8(a, b) }
+    unsafe { simd_saturating_add(a, b) }
 }
 #[doc = "Saturating add"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddq_s8)"]
@@ -37007,15 +36999,7 @@ pub fn vqadd_s8(a: int8x8_t, b: int8x8_t) -> int8x8_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqaddq_s8(a: int8x16_t, b: int8x16_t) -> int8x16_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.sqadd.v16i8"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.sadd.sat.v16i8")]
-        fn _vqaddq_s8(a: int8x16_t, b: int8x16_t) -> int8x16_t;
-    }
-    unsafe { _vqaddq_s8(a, b) }
+    unsafe { simd_saturating_add(a, b) }
 }
 #[doc = "Saturating add"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqadd_s16)"]
@@ -37036,15 +37020,7 @@ pub fn vqaddq_s8(a: int8x16_t, b: int8x16_t) -> int8x16_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqadd_s16(a: int16x4_t, b: int16x4_t) -> int16x4_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.sqadd.v4i16"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.sadd.sat.v4i16")]
-        fn _vqadd_s16(a: int16x4_t, b: int16x4_t) -> int16x4_t;
-    }
-    unsafe { _vqadd_s16(a, b) }
+    unsafe { simd_saturating_add(a, b) }
 }
 #[doc = "Saturating add"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddq_s16)"]
@@ -37065,15 +37041,7 @@ pub fn vqadd_s16(a: int16x4_t, b: int16x4_t) -> int16x4_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqaddq_s16(a: int16x8_t, b: int16x8_t) -> int16x8_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.sqadd.v8i16"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.sadd.sat.v8i16")]
-        fn _vqaddq_s16(a: int16x8_t, b: int16x8_t) -> int16x8_t;
-    }
-    unsafe { _vqaddq_s16(a, b) }
+    unsafe { simd_saturating_add(a, b) }
 }
 #[doc = "Saturating add"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqadd_s32)"]
@@ -37094,15 +37062,7 @@ pub fn vqaddq_s16(a: int16x8_t, b: int16x8_t) -> int16x8_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqadd_s32(a: int32x2_t, b: int32x2_t) -> int32x2_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.sqadd.v2i32"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.sadd.sat.v2i32")]
-        fn _vqadd_s32(a: int32x2_t, b: int32x2_t) -> int32x2_t;
-    }
-    unsafe { _vqadd_s32(a, b) }
+    unsafe { simd_saturating_add(a, b) }
 }
 #[doc = "Saturating add"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddq_s32)"]
@@ -37123,15 +37083,7 @@ pub fn vqadd_s32(a: int32x2_t, b: int32x2_t) -> int32x2_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqaddq_s32(a: int32x4_t, b: int32x4_t) -> int32x4_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.sqadd.v4i32"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.sadd.sat.v4i32")]
-        fn _vqaddq_s32(a: int32x4_t, b: int32x4_t) -> int32x4_t;
-    }
-    unsafe { _vqaddq_s32(a, b) }
+    unsafe { simd_saturating_add(a, b) }
 }
 #[doc = "Saturating add"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqadd_s64)"]
@@ -37152,15 +37104,7 @@ pub fn vqaddq_s32(a: int32x4_t, b: int32x4_t) -> int32x4_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqadd_s64(a: int64x1_t, b: int64x1_t) -> int64x1_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.sqadd.v1i64"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.sadd.sat.v1i64")]
-        fn _vqadd_s64(a: int64x1_t, b: int64x1_t) -> int64x1_t;
-    }
-    unsafe { _vqadd_s64(a, b) }
+    unsafe { simd_saturating_add(a, b) }
 }
 #[doc = "Saturating add"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddq_s64)"]
@@ -37181,15 +37125,7 @@ pub fn vqadd_s64(a: int64x1_t, b: int64x1_t) -> int64x1_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqaddq_s64(a: int64x2_t, b: int64x2_t) -> int64x2_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.sqadd.v2i64"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.sadd.sat.v2i64")]
-        fn _vqaddq_s64(a: int64x2_t, b: int64x2_t) -> int64x2_t;
-    }
-    unsafe { _vqaddq_s64(a, b) }
+    unsafe { simd_saturating_add(a, b) }
 }
 #[doc = "Saturating add"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqadd_u8)"]
@@ -37210,15 +37146,7 @@ pub fn vqaddq_s64(a: int64x2_t, b: int64x2_t) -> int64x2_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqadd_u8(a: uint8x8_t, b: uint8x8_t) -> uint8x8_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.uqadd.v8i8"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.uadd.sat.v8i8")]
-        fn _vqadd_u8(a: uint8x8_t, b: uint8x8_t) -> uint8x8_t;
-    }
-    unsafe { _vqadd_u8(a, b) }
+    unsafe { simd_saturating_add(a, b) }
 }
 #[doc = "Saturating add"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddq_u8)"]
@@ -37239,15 +37167,7 @@ pub fn vqadd_u8(a: uint8x8_t, b: uint8x8_t) -> uint8x8_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqaddq_u8(a: uint8x16_t, b: uint8x16_t) -> uint8x16_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.uqadd.v16i8"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.uadd.sat.v16i8")]
-        fn _vqaddq_u8(a: uint8x16_t, b: uint8x16_t) -> uint8x16_t;
-    }
-    unsafe { _vqaddq_u8(a, b) }
+    unsafe { simd_saturating_add(a, b) }
 }
 #[doc = "Saturating add"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqadd_u16)"]
@@ -37268,15 +37188,7 @@ pub fn vqaddq_u8(a: uint8x16_t, b: uint8x16_t) -> uint8x16_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqadd_u16(a: uint16x4_t, b: uint16x4_t) -> uint16x4_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.uqadd.v4i16"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.uadd.sat.v4i16")]
-        fn _vqadd_u16(a: uint16x4_t, b: uint16x4_t) -> uint16x4_t;
-    }
-    unsafe { _vqadd_u16(a, b) }
+    unsafe { simd_saturating_add(a, b) }
 }
 #[doc = "Saturating add"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddq_u16)"]
@@ -37297,15 +37209,7 @@ pub fn vqadd_u16(a: uint16x4_t, b: uint16x4_t) -> uint16x4_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqaddq_u16(a: uint16x8_t, b: uint16x8_t) -> uint16x8_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.uqadd.v8i16"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.uadd.sat.v8i16")]
-        fn _vqaddq_u16(a: uint16x8_t, b: uint16x8_t) -> uint16x8_t;
-    }
-    unsafe { _vqaddq_u16(a, b) }
+    unsafe { simd_saturating_add(a, b) }
 }
 #[doc = "Saturating add"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqadd_u32)"]
@@ -37326,15 +37230,7 @@ pub fn vqaddq_u16(a: uint16x8_t, b: uint16x8_t) -> uint16x8_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqadd_u32(a: uint32x2_t, b: uint32x2_t) -> uint32x2_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.uqadd.v2i32"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.uadd.sat.v2i32")]
-        fn _vqadd_u32(a: uint32x2_t, b: uint32x2_t) -> uint32x2_t;
-    }
-    unsafe { _vqadd_u32(a, b) }
+    unsafe { simd_saturating_add(a, b) }
 }
 #[doc = "Saturating add"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddq_u32)"]
@@ -37355,15 +37251,7 @@ pub fn vqadd_u32(a: uint32x2_t, b: uint32x2_t) -> uint32x2_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqaddq_u32(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.uqadd.v4i32"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.uadd.sat.v4i32")]
-        fn _vqaddq_u32(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t;
-    }
-    unsafe { _vqaddq_u32(a, b) }
+    unsafe { simd_saturating_add(a, b) }
 }
 #[doc = "Saturating add"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqadd_u64)"]
@@ -37384,15 +37272,7 @@ pub fn vqaddq_u32(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqadd_u64(a: uint64x1_t, b: uint64x1_t) -> uint64x1_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.uqadd.v1i64"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.uadd.sat.v1i64")]
-        fn _vqadd_u64(a: uint64x1_t, b: uint64x1_t) -> uint64x1_t;
-    }
-    unsafe { _vqadd_u64(a, b) }
+    unsafe { simd_saturating_add(a, b) }
 }
 #[doc = "Saturating add"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddq_u64)"]
@@ -37413,15 +37293,7 @@ pub fn vqadd_u64(a: uint64x1_t, b: uint64x1_t) -> uint64x1_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqaddq_u64(a: uint64x2_t, b: uint64x2_t) -> uint64x2_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.uqadd.v2i64"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.uadd.sat.v2i64")]
-        fn _vqaddq_u64(a: uint64x2_t, b: uint64x2_t) -> uint64x2_t;
-    }
-    unsafe { _vqaddq_u64(a, b) }
+    unsafe { simd_saturating_add(a, b) }
 }
 #[doc = "Vector widening saturating doubling multiply accumulate with scalar"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqdmlal_lane_s16)"]
@@ -41259,15 +41131,7 @@ pub fn vqshrun_n_s64<const N: i32>(a: int64x2_t) -> uint32x2_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqsub_s8(a: int8x8_t, b: int8x8_t) -> int8x8_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.sqsub.v8i8"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.ssub.sat.v8i8")]
-        fn _vqsub_s8(a: int8x8_t, b: int8x8_t) -> int8x8_t;
-    }
-    unsafe { _vqsub_s8(a, b) }
+    unsafe { simd_saturating_sub(a, b) }
 }
 #[doc = "Saturating subtract"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubq_s8)"]
@@ -41288,15 +41152,7 @@ pub fn vqsub_s8(a: int8x8_t, b: int8x8_t) -> int8x8_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqsubq_s8(a: int8x16_t, b: int8x16_t) -> int8x16_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.sqsub.v16i8"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.ssub.sat.v16i8")]
-        fn _vqsubq_s8(a: int8x16_t, b: int8x16_t) -> int8x16_t;
-    }
-    unsafe { _vqsubq_s8(a, b) }
+    unsafe { simd_saturating_sub(a, b) }
 }
 #[doc = "Saturating subtract"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsub_s16)"]
@@ -41317,15 +41173,7 @@ pub fn vqsubq_s8(a: int8x16_t, b: int8x16_t) -> int8x16_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqsub_s16(a: int16x4_t, b: int16x4_t) -> int16x4_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.sqsub.v4i16"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.ssub.sat.v4i16")]
-        fn _vqsub_s16(a: int16x4_t, b: int16x4_t) -> int16x4_t;
-    }
-    unsafe { _vqsub_s16(a, b) }
+    unsafe { simd_saturating_sub(a, b) }
 }
 #[doc = "Saturating subtract"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubq_s16)"]
@@ -41346,15 +41194,7 @@ pub fn vqsub_s16(a: int16x4_t, b: int16x4_t) -> int16x4_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqsubq_s16(a: int16x8_t, b: int16x8_t) -> int16x8_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.sqsub.v8i16"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.ssub.sat.v8i16")]
-        fn _vqsubq_s16(a: int16x8_t, b: int16x8_t) -> int16x8_t;
-    }
-    unsafe { _vqsubq_s16(a, b) }
+    unsafe { simd_saturating_sub(a, b) }
 }
 #[doc = "Saturating subtract"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsub_s32)"]
@@ -41375,15 +41215,7 @@ pub fn vqsubq_s16(a: int16x8_t, b: int16x8_t) -> int16x8_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqsub_s32(a: int32x2_t, b: int32x2_t) -> int32x2_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.sqsub.v2i32"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.ssub.sat.v2i32")]
-        fn _vqsub_s32(a: int32x2_t, b: int32x2_t) -> int32x2_t;
-    }
-    unsafe { _vqsub_s32(a, b) }
+    unsafe { simd_saturating_sub(a, b) }
 }
 #[doc = "Saturating subtract"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubq_s32)"]
@@ -41404,15 +41236,7 @@ pub fn vqsub_s32(a: int32x2_t, b: int32x2_t) -> int32x2_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqsubq_s32(a: int32x4_t, b: int32x4_t) -> int32x4_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.sqsub.v4i32"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.ssub.sat.v4i32")]
-        fn _vqsubq_s32(a: int32x4_t, b: int32x4_t) -> int32x4_t;
-    }
-    unsafe { _vqsubq_s32(a, b) }
+    unsafe { simd_saturating_sub(a, b) }
 }
 #[doc = "Saturating subtract"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsub_s64)"]
@@ -41433,15 +41257,7 @@ pub fn vqsubq_s32(a: int32x4_t, b: int32x4_t) -> int32x4_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqsub_s64(a: int64x1_t, b: int64x1_t) -> int64x1_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.sqsub.v1i64"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.ssub.sat.v1i64")]
-        fn _vqsub_s64(a: int64x1_t, b: int64x1_t) -> int64x1_t;
-    }
-    unsafe { _vqsub_s64(a, b) }
+    unsafe { simd_saturating_sub(a, b) }
 }
 #[doc = "Saturating subtract"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubq_s64)"]
@@ -41462,15 +41278,7 @@ pub fn vqsub_s64(a: int64x1_t, b: int64x1_t) -> int64x1_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqsubq_s64(a: int64x2_t, b: int64x2_t) -> int64x2_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.sqsub.v2i64"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.ssub.sat.v2i64")]
-        fn _vqsubq_s64(a: int64x2_t, b: int64x2_t) -> int64x2_t;
-    }
-    unsafe { _vqsubq_s64(a, b) }
+    unsafe { simd_saturating_sub(a, b) }
 }
 #[doc = "Saturating subtract"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsub_u8)"]
@@ -41491,15 +41299,7 @@ pub fn vqsubq_s64(a: int64x2_t, b: int64x2_t) -> int64x2_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqsub_u8(a: uint8x8_t, b: uint8x8_t) -> uint8x8_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.uqsub.v8i8"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.usub.sat.v8i8")]
-        fn _vqsub_u8(a: uint8x8_t, b: uint8x8_t) -> uint8x8_t;
-    }
-    unsafe { _vqsub_u8(a, b) }
+    unsafe { simd_saturating_sub(a, b) }
 }
 #[doc = "Saturating subtract"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubq_u8)"]
@@ -41520,15 +41320,7 @@ pub fn vqsub_u8(a: uint8x8_t, b: uint8x8_t) -> uint8x8_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqsubq_u8(a: uint8x16_t, b: uint8x16_t) -> uint8x16_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.uqsub.v16i8"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.usub.sat.v16i8")]
-        fn _vqsubq_u8(a: uint8x16_t, b: uint8x16_t) -> uint8x16_t;
-    }
-    unsafe { _vqsubq_u8(a, b) }
+    unsafe { simd_saturating_sub(a, b) }
 }
 #[doc = "Saturating subtract"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsub_u16)"]
@@ -41549,15 +41341,7 @@ pub fn vqsubq_u8(a: uint8x16_t, b: uint8x16_t) -> uint8x16_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqsub_u16(a: uint16x4_t, b: uint16x4_t) -> uint16x4_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.uqsub.v4i16"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.usub.sat.v4i16")]
-        fn _vqsub_u16(a: uint16x4_t, b: uint16x4_t) -> uint16x4_t;
-    }
-    unsafe { _vqsub_u16(a, b) }
+    unsafe { simd_saturating_sub(a, b) }
 }
 #[doc = "Saturating subtract"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubq_u16)"]
@@ -41578,15 +41362,7 @@ pub fn vqsub_u16(a: uint16x4_t, b: uint16x4_t) -> uint16x4_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqsubq_u16(a: uint16x8_t, b: uint16x8_t) -> uint16x8_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.uqsub.v8i16"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.usub.sat.v8i16")]
-        fn _vqsubq_u16(a: uint16x8_t, b: uint16x8_t) -> uint16x8_t;
-    }
-    unsafe { _vqsubq_u16(a, b) }
+    unsafe { simd_saturating_sub(a, b) }
 }
 #[doc = "Saturating subtract"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsub_u32)"]
@@ -41607,15 +41383,7 @@ pub fn vqsubq_u16(a: uint16x8_t, b: uint16x8_t) -> uint16x8_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqsub_u32(a: uint32x2_t, b: uint32x2_t) -> uint32x2_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.uqsub.v2i32"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.usub.sat.v2i32")]
-        fn _vqsub_u32(a: uint32x2_t, b: uint32x2_t) -> uint32x2_t;
-    }
-    unsafe { _vqsub_u32(a, b) }
+    unsafe { simd_saturating_sub(a, b) }
 }
 #[doc = "Saturating subtract"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubq_u32)"]
@@ -41636,15 +41404,7 @@ pub fn vqsub_u32(a: uint32x2_t, b: uint32x2_t) -> uint32x2_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqsubq_u32(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.uqsub.v4i32"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.usub.sat.v4i32")]
-        fn _vqsubq_u32(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t;
-    }
-    unsafe { _vqsubq_u32(a, b) }
+    unsafe { simd_saturating_sub(a, b) }
 }
 #[doc = "Saturating subtract"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsub_u64)"]
@@ -41665,15 +41425,7 @@ pub fn vqsubq_u32(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqsub_u64(a: uint64x1_t, b: uint64x1_t) -> uint64x1_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.uqsub.v1i64"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.usub.sat.v1i64")]
-        fn _vqsub_u64(a: uint64x1_t, b: uint64x1_t) -> uint64x1_t;
-    }
-    unsafe { _vqsub_u64(a, b) }
+    unsafe { simd_saturating_sub(a, b) }
 }
 #[doc = "Saturating subtract"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubq_u64)"]
@@ -41694,15 +41446,7 @@ pub fn vqsub_u64(a: uint64x1_t, b: uint64x1_t) -> uint64x1_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vqsubq_u64(a: uint64x2_t, b: uint64x2_t) -> uint64x2_t {
-    unsafe extern "unadjusted" {
-        #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
-            link_name = "llvm.aarch64.neon.uqsub.v2i64"
-        )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.usub.sat.v2i64")]
-        fn _vqsubq_u64(a: uint64x2_t, b: uint64x2_t) -> uint64x2_t;
-    }
-    unsafe { _vqsubq_u64(a, b) }
+    unsafe { simd_saturating_sub(a, b) }
 }
 #[doc = "Rounding Add returning High Narrow (high half)."]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vraddhn_high_s16)"]
diff --git a/library/stdarch/crates/stdarch-gen-arm/spec/neon/arm_shared.spec.yml b/library/stdarch/crates/stdarch-gen-arm/spec/neon/arm_shared.spec.yml
index f16a257399bc8..1543ab1f866e8 100644
--- a/library/stdarch/crates/stdarch-gen-arm/spec/neon/arm_shared.spec.yml
+++ b/library/stdarch/crates/stdarch-gen-arm/spec/neon/arm_shared.spec.yml
@@ -2290,13 +2290,10 @@ intrinsics:
       - [uint64x1_t, u64, i64]
       - [uint64x2_t, u64, i64]
     compose:
-      - LLVMLink:
-          name: "uqsub.{neon_type[0]}"
-          links:
-            - link: "llvm.aarch64.neon.uqsub.v{neon_type[0].lane}{type[2]}"
-              arch: aarch64,arm64ec
-            - link: "llvm.usub.sat.v{neon_type[0].lane}{type[2]}"
-              arch: arm
+      - FnCall:
+        - simd_saturating_sub
+        - - a
+          - b
 
   - name: "vqsub{neon_type[0].no}"
     doc: Saturating subtract
@@ -2319,13 +2316,10 @@ intrinsics:
       - [int64x1_t, s64, i64]
       - [int64x2_t, s64, i64]
     compose:
-      - LLVMLink:
-          name: "sqsub.{neon_type[0]}"
-          links:
-            - link: "llvm.aarch64.neon.sqsub.v{neon_type[0].lane}{type[2]}"
-              arch: aarch64,arm64ec
-            - link: "llvm.ssub.sat.v{neon_type[0].lane}{type[2]}"
-              arch: arm
+      - FnCall:
+        - simd_saturating_sub
+        - - a
+          - b
 
   - name: "vhadd{neon_type.no}"
     doc: Halving add
@@ -2541,13 +2535,10 @@ intrinsics:
       - uint64x1_t
       - uint64x2_t
     compose:
-      - LLVMLink:
-          name: "uqadd.{neon_type}"
-          links:
-            - link: "llvm.aarch64.neon.uqadd.{neon_type}"
-              arch: aarch64,arm64ec
-            - link: "llvm.uadd.sat.{neon_type}"
-              arch: arm
+      - FnCall:
+        - simd_saturating_add
+        - - a
+          - b
 
   - name: "vqadd{neon_type.no}"
     doc: Saturating add
@@ -2570,13 +2561,10 @@ intrinsics:
       - int64x1_t
       - int64x2_t
     compose:
-      - LLVMLink:
-          name: "sqadd.{neon_type}"
-          links:
-            - link: "llvm.aarch64.neon.sqadd.{neon_type}"
-              arch: aarch64,arm64ec
-            - link: "llvm.sadd.sat.{neon_type}"
-              arch: arm
+      - FnCall:
+        - simd_saturating_add
+        - - a
+          - b
 
   - name: "vld1{neon_type[1].no}"
     doc: "Load multiple single-element structures to one, two, three, or four registers"

From 6d637dfeccd7d22523e584203e666535db878165 Mon Sep 17 00:00:00 2001
From: Andrew Zhogin <andrew.zhogin@gmail.com>
Date: Thu, 20 Mar 2025 12:43:44 +0700
Subject: [PATCH 0146/1889] -Zsanitize and -Zsanitizer-cfi-normalize-integers
 flags are now target modifiers with custom consistency check function

---
 compiler/rustc_metadata/src/creader.rs        | 18 +++--
 compiler/rustc_session/src/options.rs         | 71 ++++++++++++++++++-
 .../address-sanitizer-globals-tracking.rs     |  2 +-
 .../cfi/add-canonical-jump-tables-flag.rs     |  2 +-
 .../cfi/add-cfi-normalize-integers-flag.rs    |  2 +-
 .../cfi/add-enable-split-lto-unit-flag.rs     |  2 +-
 .../cfi/dbg-location-on-cfi-blocks.rs         |  2 +-
 .../cfi/emit-type-checks-attr-sanitize-off.rs |  2 +-
 .../sanitizer/cfi/emit-type-checks.rs         |  2 +-
 .../emit-type-metadata-attr-cfi-encoding.rs   |  2 +-
 ...adata-id-itanium-cxx-abi-const-generics.rs |  2 +-
 ...tadata-id-itanium-cxx-abi-drop-in-place.rs |  2 +-
 ...adata-id-itanium-cxx-abi-function-types.rs |  2 +-
 ...e-metadata-id-itanium-cxx-abi-lifetimes.rs |  2 +-
 ...itanium-cxx-abi-method-secondary-typeid.rs |  2 +-
 ...-type-metadata-id-itanium-cxx-abi-paths.rs |  2 +-
 ...tadata-id-itanium-cxx-abi-pointer-types.rs |  2 +-
 ...data-id-itanium-cxx-abi-primitive-types.rs |  2 +-
 ...-itanium-cxx-abi-repr-transparent-types.rs |  2 +-
 ...adata-id-itanium-cxx-abi-sequence-types.rs |  2 +-
 ...metadata-id-itanium-cxx-abi-trait-types.rs |  2 +-
 ...a-id-itanium-cxx-abi-user-defined-types.rs |  2 +-
 ...pe-metadata-itanium-cxx-abi-generalized.rs |  2 +-
 ...-itanium-cxx-abi-normalized-generalized.rs |  2 +-
 ...ype-metadata-itanium-cxx-abi-normalized.rs |  2 +-
 .../cfi/emit-type-metadata-itanium-cxx-abi.rs |  2 +-
 .../cfi/emit-type-metadata-trait-objects.rs   |  2 +-
 .../sanitizer/cfi/external_weak_symbols.rs    |  2 +-
 .../sanitizer/cfi/generalize-pointers.rs      |  2 +-
 .../sanitizer/cfi/normalize-integers.rs       |  2 +-
 .../dataflow-instrument-functions.rs          |  2 +-
 .../sanitizer/memory-track-origins.rs         |  2 +-
 .../sanitizer/memtag-attr-check.rs            |  2 +-
 .../sanitizer/safestack-attr-check.rs         |  2 +-
 .../sanitizer/sanitize-off-inlining.rs        |  2 +-
 .../sanitizer/sanitize-off-kasan-asan.rs      |  2 +-
 .../sanitizer/sanitizer-recover.rs            |  2 +-
 tests/run-make/sanitizer-cdylib-link/rmake.rs |  2 +
 tests/run-make/sanitizer-dylib-link/rmake.rs  |  2 +
 .../sanitizer-staticlib-link/rmake.rs         |  2 +
 tests/rustdoc/sanitizer-option.rs             |  2 +-
 .../asm/global-asm-isnt-really-a-mir-body.rs  |  2 +
 tests/ui/lto/issue-100772.rs                  |  2 +-
 tests/ui/sanitizer/address.rs                 |  2 +-
 tests/ui/sanitizer/asan_odr_windows.rs        |  2 +-
 tests/ui/sanitizer/badfree.rs                 |  2 +-
 .../cfi/assoc-ty-lifetime-issue-123053.rs     |  2 +-
 tests/ui/sanitizer/cfi/async-closures.rs      |  2 +-
 tests/ui/sanitizer/cfi/can-reveal-opaques.rs  |  2 +-
 tests/ui/sanitizer/cfi/closures.rs            |  2 +-
 tests/ui/sanitizer/cfi/complex-receiver.rs    |  2 +-
 tests/ui/sanitizer/cfi/coroutine.rs           |  1 +
 tests/ui/sanitizer/cfi/drop-in-place.rs       |  1 +
 tests/ui/sanitizer/cfi/drop-no-principal.rs   |  2 +-
 tests/ui/sanitizer/cfi/fn-ptr.rs              |  1 +
 .../cfi/generalize-pointers-attr-cfg.rs       |  1 +
 .../cfi/normalize-integers-attr-cfg.rs        |  2 +-
 tests/ui/sanitizer/cfi/self-ref.rs            |  2 +-
 tests/ui/sanitizer/cfi/sized-associated-ty.rs |  2 +-
 tests/ui/sanitizer/cfi/supertraits.rs         |  2 +-
 .../sanitizer/cfi/transparent-has-regions.rs  |  2 +-
 tests/ui/sanitizer/cfi/virtual-auto.rs        |  2 +-
 tests/ui/sanitizer/dataflow.rs                |  2 +-
 tests/ui/sanitizer/hwaddress.rs               |  2 +-
 .../issue-111184-cfi-coroutine-witness.rs     |  2 +-
 ...issue-114275-cfi-const-expr-in-arry-len.rs |  2 +-
 .../issue-72154-address-lifetime-markers.rs   |  2 +-
 tests/ui/sanitizer/kcfi-mangling.rs           |  2 +-
 tests/ui/sanitizer/leak.rs                    |  2 +-
 tests/ui/sanitizer/memory-eager.rs            |  2 +
 tests/ui/sanitizer/memory-passing.rs          |  2 +
 tests/ui/sanitizer/memory.rs                  |  2 +
 .../new-llvm-pass-manager-thin-lto.rs         |  2 +
 tests/ui/sanitizer/thread.rs                  |  2 +-
 tests/ui/sanitizer/use-after-scope.rs         |  2 +-
 .../auxiliary/kcfi-normalize-ints.rs          |  7 ++
 .../auxiliary/no-sanitizers.rs                |  6 ++
 .../auxiliary/safestack-and-kcfi.rs           | 10 +++
 .../sanitizer-kcfi-normalize-ints.rs          | 18 +++++
 ...izer-kcfi-normalize-ints.wrong_flag.stderr | 13 ++++
 ...kcfi-normalize-ints.wrong_sanitizer.stderr | 13 ++++
 .../sanitizers-good-for-inconsistency.rs      | 19 +++++
 ...zers-safestack-and-kcfi.missed_both.stderr | 13 ++++
 ...zers-safestack-and-kcfi.missed_kcfi.stderr | 13 ++++
 ...safestack-and-kcfi.missed_safestack.stderr | 13 ++++
 .../sanitizers-safestack-and-kcfi.rs          | 23 ++++++
 86 files changed, 311 insertions(+), 68 deletions(-)
 create mode 100644 tests/ui/target_modifiers/auxiliary/kcfi-normalize-ints.rs
 create mode 100644 tests/ui/target_modifiers/auxiliary/no-sanitizers.rs
 create mode 100644 tests/ui/target_modifiers/auxiliary/safestack-and-kcfi.rs
 create mode 100644 tests/ui/target_modifiers/sanitizer-kcfi-normalize-ints.rs
 create mode 100644 tests/ui/target_modifiers/sanitizer-kcfi-normalize-ints.wrong_flag.stderr
 create mode 100644 tests/ui/target_modifiers/sanitizer-kcfi-normalize-ints.wrong_sanitizer.stderr
 create mode 100644 tests/ui/target_modifiers/sanitizers-good-for-inconsistency.rs
 create mode 100644 tests/ui/target_modifiers/sanitizers-safestack-and-kcfi.missed_both.stderr
 create mode 100644 tests/ui/target_modifiers/sanitizers-safestack-and-kcfi.missed_kcfi.stderr
 create mode 100644 tests/ui/target_modifiers/sanitizers-safestack-and-kcfi.missed_safestack.stderr
 create mode 100644 tests/ui/target_modifiers/sanitizers-safestack-and-kcfi.rs

diff --git a/compiler/rustc_metadata/src/creader.rs b/compiler/rustc_metadata/src/creader.rs
index 5d776ea581dd2..9e23da88f5e1e 100644
--- a/compiler/rustc_metadata/src/creader.rs
+++ b/compiler/rustc_metadata/src/creader.rs
@@ -412,7 +412,7 @@ impl CStore {
             match (&left_name_val, &right_name_val) {
                 (Some(l), Some(r)) => match l.1.opt.cmp(&r.1.opt) {
                     cmp::Ordering::Equal => {
-                        if l.0.tech_value != r.0.tech_value {
+                        if !l.1.consistent(&tcx.sess.opts, Some(&r.1)) {
                             report_diff(
                                 &l.0.prefix,
                                 &l.0.name,
@@ -424,20 +424,28 @@ impl CStore {
                         right_name_val = None;
                     }
                     cmp::Ordering::Greater => {
-                        report_diff(&r.0.prefix, &r.0.name, None, Some(&r.1.value_name));
+                        if !r.1.consistent(&tcx.sess.opts, None) {
+                            report_diff(&r.0.prefix, &r.0.name, None, Some(&r.1.value_name));
+                        }
                         right_name_val = None;
                     }
                     cmp::Ordering::Less => {
-                        report_diff(&l.0.prefix, &l.0.name, Some(&l.1.value_name), None);
+                        if !l.1.consistent(&tcx.sess.opts, None) {
+                            report_diff(&l.0.prefix, &l.0.name, Some(&l.1.value_name), None);
+                        }
                         left_name_val = None;
                     }
                 },
                 (Some(l), None) => {
-                    report_diff(&l.0.prefix, &l.0.name, Some(&l.1.value_name), None);
+                    if !l.1.consistent(&tcx.sess.opts, None) {
+                        report_diff(&l.0.prefix, &l.0.name, Some(&l.1.value_name), None);
+                    }
                     left_name_val = None;
                 }
                 (None, Some(r)) => {
-                    report_diff(&r.0.prefix, &r.0.name, None, Some(&r.1.value_name));
+                    if !r.1.consistent(&tcx.sess.opts, None) {
+                        report_diff(&r.0.prefix, &r.0.name, None, Some(&r.1.value_name));
+                    }
                     right_name_val = None;
                 }
                 (None, None) => break,
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
index 6d5be2d92cd2a..69facde693689 100644
--- a/compiler/rustc_session/src/options.rs
+++ b/compiler/rustc_session/src/options.rs
@@ -83,10 +83,77 @@ pub struct TargetModifier {
     pub value_name: String,
 }
 
+mod target_modifier_consistency_check {
+    use super::*;
+    pub(super) fn sanitizer(l: &TargetModifier, r: Option<&TargetModifier>) -> bool {
+        let mut lparsed: SanitizerSet = Default::default();
+        let lval = if l.value_name.is_empty() { None } else { Some(l.value_name.as_str()) };
+        parse::parse_sanitizers(&mut lparsed, lval);
+
+        let mut rparsed: SanitizerSet = Default::default();
+        let rval = r.filter(|v| !v.value_name.is_empty()).map(|v| v.value_name.as_str());
+        parse::parse_sanitizers(&mut rparsed, rval);
+
+        // Some sanitizers need to be target modifiers, and some do not.
+        // For now, we should mark all sanitizers as target modifiers except for these:
+        // AddressSanitizer, LeakSanitizer
+        let tmod_sanitizers = SanitizerSet::MEMORY
+            | SanitizerSet::THREAD
+            | SanitizerSet::HWADDRESS
+            | SanitizerSet::CFI
+            | SanitizerSet::MEMTAG
+            | SanitizerSet::SHADOWCALLSTACK
+            | SanitizerSet::KCFI
+            | SanitizerSet::KERNELADDRESS
+            | SanitizerSet::SAFESTACK
+            | SanitizerSet::DATAFLOW;
+
+        lparsed & tmod_sanitizers == rparsed & tmod_sanitizers
+    }
+    pub(super) fn sanitizer_cfi_normalize_integers(
+        opts: &Options,
+        l: &TargetModifier,
+        r: Option<&TargetModifier>,
+    ) -> bool {
+        // For kCFI, the helper flag -Zsanitizer-cfi-normalize-integers should also be a target modifier
+        if opts.unstable_opts.sanitizer.contains(SanitizerSet::KCFI) {
+            if let Some(r) = r {
+                return l.extend().tech_value == r.extend().tech_value;
+            } else {
+                return false;
+            }
+        }
+        true
+    }
+}
+
 impl TargetModifier {
     pub fn extend(&self) -> ExtendedTargetModifierInfo {
         self.opt.reparse(&self.value_name)
     }
+    // Custom consistency check for target modifiers (or default `l.tech_value == r.tech_value`)
+    // When other is None, consistency with default value is checked
+    pub fn consistent(&self, opts: &Options, other: Option<&TargetModifier>) -> bool {
+        assert!(other.is_none() || self.opt == other.unwrap().opt);
+        match self.opt {
+            OptionsTargetModifiers::UnstableOptions(unstable) => match unstable {
+                UnstableOptionsTargetModifiers::sanitizer => {
+                    return target_modifier_consistency_check::sanitizer(self, other);
+                }
+                UnstableOptionsTargetModifiers::sanitizer_cfi_normalize_integers => {
+                    return target_modifier_consistency_check::sanitizer_cfi_normalize_integers(
+                        opts, self, other,
+                    );
+                }
+                _ => {}
+            },
+            _ => {}
+        };
+        match other {
+            Some(other) => self.extend().tech_value == other.extend().tech_value,
+            None => false,
+        }
+    }
 }
 
 fn tmod_push_impl(
@@ -2504,13 +2571,13 @@ written to standard error output)"),
     retpoline_external_thunk: bool = (false, parse_bool, [TRACKED TARGET_MODIFIER],
         "enables retpoline-external-thunk, retpoline-indirect-branches and retpoline-indirect-calls \
         target features (default: no)"),
-    sanitizer: SanitizerSet = (SanitizerSet::empty(), parse_sanitizers, [TRACKED],
+    sanitizer: SanitizerSet = (SanitizerSet::empty(), parse_sanitizers, [TRACKED TARGET_MODIFIER],
         "use a sanitizer"),
     sanitizer_cfi_canonical_jump_tables: Option<bool> = (Some(true), parse_opt_bool, [TRACKED],
         "enable canonical jump tables (default: yes)"),
     sanitizer_cfi_generalize_pointers: Option<bool> = (None, parse_opt_bool, [TRACKED],
         "enable generalizing pointer types (default: no)"),
-    sanitizer_cfi_normalize_integers: Option<bool> = (None, parse_opt_bool, [TRACKED],
+    sanitizer_cfi_normalize_integers: Option<bool> = (None, parse_opt_bool, [TRACKED TARGET_MODIFIER],
         "enable normalizing integer types (default: no)"),
     sanitizer_dataflow_abilist: Vec<String> = (Vec::new(), parse_comma_list, [TRACKED],
         "additional ABI list files that control how shadow parameters are passed (comma separated)"),
diff --git a/tests/codegen-llvm/sanitizer/address-sanitizer-globals-tracking.rs b/tests/codegen-llvm/sanitizer/address-sanitizer-globals-tracking.rs
index 642bf5e75762b..ada525b6c8033 100644
--- a/tests/codegen-llvm/sanitizer/address-sanitizer-globals-tracking.rs
+++ b/tests/codegen-llvm/sanitizer/address-sanitizer-globals-tracking.rs
@@ -19,7 +19,7 @@
 //@ only-linux
 //
 //@ revisions:ASAN ASAN-FAT-LTO
-//@ compile-flags: -Zsanitizer=address -Ctarget-feature=-crt-static
+//@ compile-flags: -Zsanitizer=address -Ctarget-feature=-crt-static -C unsafe-allow-abi-mismatch=sanitizer
 // [ASAN] no extra compile-flags
 //@[ASAN-FAT-LTO] compile-flags: -Cprefer-dynamic=false -Clto=fat
 
diff --git a/tests/codegen-llvm/sanitizer/cfi/add-canonical-jump-tables-flag.rs b/tests/codegen-llvm/sanitizer/cfi/add-canonical-jump-tables-flag.rs
index 22577e2a3c46b..77857ca4ccb9e 100644
--- a/tests/codegen-llvm/sanitizer/cfi/add-canonical-jump-tables-flag.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/add-canonical-jump-tables-flag.rs
@@ -1,7 +1,7 @@
 // Verifies that "CFI Canonical Jump Tables" module flag is added.
 //
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Ctarget-feature=-crt-static -Zsanitizer=cfi
+//@ compile-flags: -Clto -Ctarget-feature=-crt-static -Zsanitizer=cfi -C unsafe-allow-abi-mismatch=sanitizer
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/sanitizer/cfi/add-cfi-normalize-integers-flag.rs b/tests/codegen-llvm/sanitizer/cfi/add-cfi-normalize-integers-flag.rs
index a54a6d84a8073..6cf9a72b7488d 100644
--- a/tests/codegen-llvm/sanitizer/cfi/add-cfi-normalize-integers-flag.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/add-cfi-normalize-integers-flag.rs
@@ -1,7 +1,7 @@
 // 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
+//@ compile-flags: -Clto -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-normalize-integers -C unsafe-allow-abi-mismatch=sanitizer,sanitizer-cfi-normalize-integers
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/sanitizer/cfi/add-enable-split-lto-unit-flag.rs b/tests/codegen-llvm/sanitizer/cfi/add-enable-split-lto-unit-flag.rs
index 283b8f2610294..0bfdbfba5d2e2 100644
--- a/tests/codegen-llvm/sanitizer/cfi/add-enable-split-lto-unit-flag.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/add-enable-split-lto-unit-flag.rs
@@ -1,7 +1,7 @@
 // Verifies that "EnableSplitLTOUnit" module flag is added.
 //
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Ctarget-feature=-crt-static -Zsanitizer=cfi
+//@ compile-flags: -Clto -Ctarget-feature=-crt-static -Zsanitizer=cfi -C unsafe-allow-abi-mismatch=sanitizer
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/sanitizer/cfi/dbg-location-on-cfi-blocks.rs b/tests/codegen-llvm/sanitizer/cfi/dbg-location-on-cfi-blocks.rs
index df65960dfe0be..2a18e30e2b0de 100644
--- a/tests/codegen-llvm/sanitizer/cfi/dbg-location-on-cfi-blocks.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/dbg-location-on-cfi-blocks.rs
@@ -1,7 +1,7 @@
 // Verifies that the parent block's debug information are assigned to the inserted cfi block.
 //
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static -Cdebuginfo=1
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static -Cdebuginfo=1 -C unsafe-allow-abi-mismatch=sanitizer
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-checks-attr-sanitize-off.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-checks-attr-sanitize-off.rs
index 651afb3322869..c49438f43186f 100644
--- a/tests/codegen-llvm/sanitizer/cfi/emit-type-checks-attr-sanitize-off.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-checks-attr-sanitize-off.rs
@@ -1,7 +1,7 @@
 // Verifies that pointer type membership tests for indirect calls are omitted.
 //
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Copt-level=0
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Copt-level=0 -C unsafe-allow-abi-mismatch=sanitizer
 
 #![crate_type = "lib"]
 #![feature(sanitize)]
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-checks.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-checks.rs
index ebc66a015df69..9cad88f651820 100644
--- a/tests/codegen-llvm/sanitizer/cfi/emit-type-checks.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-checks.rs
@@ -1,7 +1,7 @@
 // Verifies that pointer type membership tests for indirect calls are emitted.
 //
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Copt-level=0
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Copt-level=0 -C unsafe-allow-abi-mismatch=sanitizer
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-attr-cfi-encoding.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-attr-cfi-encoding.rs
index 9bc2e42db0f61..cd9088f58af4a 100644
--- a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-attr-cfi-encoding.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-attr-cfi-encoding.rs
@@ -1,7 +1,7 @@
 // Verifies that user-defined CFI encoding for types are emitted.
 //
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Copt-level=0
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Copt-level=0 -C unsafe-allow-abi-mismatch=sanitizer
 
 #![crate_type = "lib"]
 #![feature(cfi_encoding, extern_types)]
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-const-generics.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-const-generics.rs
index 9048c6a1f1838..cf26c17af1ed3 100644
--- a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-const-generics.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-const-generics.rs
@@ -2,7 +2,7 @@
 // for const generics.
 //
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Copt-level=0
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Copt-level=0 -C unsafe-allow-abi-mismatch=sanitizer
 
 #![crate_type = "lib"]
 #![feature(type_alias_impl_trait)]
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-drop-in-place.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-drop-in-place.rs
index 8fec275fd0646..279350d20c5f0 100644
--- a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-drop-in-place.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-drop-in-place.rs
@@ -5,7 +5,7 @@
 // future.
 //
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static -C unsafe-allow-abi-mismatch=sanitizer
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-function-types.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-function-types.rs
index 7e60aafff6802..047b532e994ea 100644
--- a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-function-types.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-function-types.rs
@@ -2,7 +2,7 @@
 // for function types.
 //
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static -C unsafe-allow-abi-mismatch=sanitizer
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-lifetimes.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-lifetimes.rs
index 36d2e8c9f25a2..92b2ab32ea036 100644
--- a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-lifetimes.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-lifetimes.rs
@@ -2,7 +2,7 @@
 // for lifetimes/regions.
 //
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Copt-level=0
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Copt-level=0 -C unsafe-allow-abi-mismatch=sanitizer
 
 #![crate_type = "lib"]
 #![feature(type_alias_impl_trait)]
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-method-secondary-typeid.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-method-secondary-typeid.rs
index 9d611777ff0ba..5de39dc85c17e 100644
--- a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-method-secondary-typeid.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-method-secondary-typeid.rs
@@ -2,7 +2,7 @@
 // self so they can be used as function pointers.
 //
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static -C unsafe-allow-abi-mismatch=sanitizer
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-paths.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-paths.rs
index a8ba8db1be3b4..f5846713bd531 100644
--- a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-paths.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-paths.rs
@@ -2,7 +2,7 @@
 // for paths.
 //
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static -C unsafe-allow-abi-mismatch=sanitizer
 
 #![crate_type = "lib"]
 #![feature(type_alias_impl_trait)]
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-pointer-types.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-pointer-types.rs
index d37bb740f5505..ad4fe11d08723 100644
--- a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-pointer-types.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-pointer-types.rs
@@ -2,7 +2,7 @@
 // for pointer types.
 //
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static -C unsafe-allow-abi-mismatch=sanitizer
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-primitive-types.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-primitive-types.rs
index 7d9e4d0587276..93845d0519541 100644
--- a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-primitive-types.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-primitive-types.rs
@@ -2,7 +2,7 @@
 // for primitive types.
 //
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static -C unsafe-allow-abi-mismatch=sanitizer
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-repr-transparent-types.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-repr-transparent-types.rs
index 0f97c70f3f923..025aa902658ec 100644
--- a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-repr-transparent-types.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-repr-transparent-types.rs
@@ -2,7 +2,7 @@
 // for repr transparent types.
 //
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static -C unsafe-allow-abi-mismatch=sanitizer
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-sequence-types.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-sequence-types.rs
index bdee3f47a837d..76c8150b77859 100644
--- a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-sequence-types.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-sequence-types.rs
@@ -2,7 +2,7 @@
 // for sequence types.
 //
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static -C unsafe-allow-abi-mismatch=sanitizer
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-trait-types.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-trait-types.rs
index 55e816178f8fc..4fafdd2f040fc 100644
--- a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-trait-types.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-trait-types.rs
@@ -2,7 +2,7 @@
 // for trait types.
 //
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static -C unsafe-allow-abi-mismatch=sanitizer
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-user-defined-types.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-user-defined-types.rs
index c1f3ca61afeb1..91351096ca201 100644
--- a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-user-defined-types.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-user-defined-types.rs
@@ -2,7 +2,7 @@
 // for user-defined types.
 //
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static -C unsafe-allow-abi-mismatch=sanitizer
 
 #![crate_type = "lib"]
 #![feature(extern_types)]
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-generalized.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-generalized.rs
index 32637b64b3ea8..22d518cca7442 100644
--- a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-generalized.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-generalized.rs
@@ -1,7 +1,7 @@
 // Verifies that generalized type metadata for functions are emitted.
 //
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-generalize-pointers
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-generalize-pointers -C unsafe-allow-abi-mismatch=sanitizer
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-normalized-generalized.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-normalized-generalized.rs
index 51121b0aef1aa..7639ce7b10448 100644
--- a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-normalized-generalized.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-normalized-generalized.rs
@@ -1,7 +1,7 @@
 // Verifies that normalized and generalized type metadata for functions are emitted.
 //
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-normalize-integers -Zsanitizer-cfi-generalize-pointers
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-normalize-integers -Zsanitizer-cfi-generalize-pointers -C unsafe-allow-abi-mismatch=sanitizer,sanitizer-cfi-normalize-integers
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-normalized.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-normalized.rs
index 1cfdd23006e3a..acd72b0ca3cff 100644
--- a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-normalized.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-normalized.rs
@@ -1,7 +1,7 @@
 // Verifies that normalized type metadata for functions are emitted.
 //
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-normalize-integers
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-normalize-integers -C unsafe-allow-abi-mismatch=sanitizer,sanitizer-cfi-normalize-integers
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi.rs
index 56ab1ce4b3582..fa5cd471466e2 100644
--- a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi.rs
@@ -1,7 +1,7 @@
 // Verifies that type metadata for functions are emitted.
 //
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -C unsafe-allow-abi-mismatch=sanitizer
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-trait-objects.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-trait-objects.rs
index 0e57ce322d127..82873e935b292 100644
--- a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-trait-objects.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-trait-objects.rs
@@ -1,7 +1,7 @@
 // Verifies that type metadata identifiers for trait objects are emitted correctly.
 //
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Ctarget-feature=-crt-static -Zsanitizer=cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Ctarget-feature=-crt-static -Zsanitizer=cfi -C unsafe-allow-abi-mismatch=sanitizer
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/sanitizer/cfi/external_weak_symbols.rs b/tests/codegen-llvm/sanitizer/cfi/external_weak_symbols.rs
index b3cb6dfdd37d7..893b016769368 100644
--- a/tests/codegen-llvm/sanitizer/cfi/external_weak_symbols.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/external_weak_symbols.rs
@@ -2,7 +2,7 @@
 // emitted correctly.
 //
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clinker-plugin-lto -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
+//@ compile-flags: -Clinker-plugin-lto -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static -C unsafe-allow-abi-mismatch=sanitizer
 #![crate_type = "bin"]
 #![feature(linkage)]
 
diff --git a/tests/codegen-llvm/sanitizer/cfi/generalize-pointers.rs b/tests/codegen-llvm/sanitizer/cfi/generalize-pointers.rs
index 57004da6f8e06..caa2f258f8f2a 100644
--- a/tests/codegen-llvm/sanitizer/cfi/generalize-pointers.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/generalize-pointers.rs
@@ -1,7 +1,7 @@
 // Verifies that pointer types are generalized.
 //
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-generalize-pointers -Copt-level=0
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-generalize-pointers -Copt-level=0 -C unsafe-allow-abi-mismatch=sanitizer
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/sanitizer/cfi/normalize-integers.rs b/tests/codegen-llvm/sanitizer/cfi/normalize-integers.rs
index 770ee4e64e089..16f76adafb826 100644
--- a/tests/codegen-llvm/sanitizer/cfi/normalize-integers.rs
+++ b/tests/codegen-llvm/sanitizer/cfi/normalize-integers.rs
@@ -1,7 +1,7 @@
 // Verifies that integer types are normalized.
 //
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-normalize-integers -Copt-level=0
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-normalize-integers -Copt-level=0 -C unsafe-allow-abi-mismatch=sanitizer,sanitizer-cfi-normalize-integers
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/sanitizer/dataflow-instrument-functions.rs b/tests/codegen-llvm/sanitizer/dataflow-instrument-functions.rs
index a2d0d63cc1754..cd8c2c48ea4f7 100644
--- a/tests/codegen-llvm/sanitizer/dataflow-instrument-functions.rs
+++ b/tests/codegen-llvm/sanitizer/dataflow-instrument-functions.rs
@@ -1,7 +1,7 @@
 // Verifies that functions are instrumented.
 //
 //@ needs-sanitizer-dataflow
-//@ compile-flags: -Copt-level=0 -Zsanitizer=dataflow
+//@ compile-flags: -Copt-level=0 -Zsanitizer=dataflow -C unsafe-allow-abi-mismatch=sanitizer
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/sanitizer/memory-track-origins.rs b/tests/codegen-llvm/sanitizer/memory-track-origins.rs
index 5eb5b356b0510..a72e523c4e193 100644
--- a/tests/codegen-llvm/sanitizer/memory-track-origins.rs
+++ b/tests/codegen-llvm/sanitizer/memory-track-origins.rs
@@ -4,7 +4,7 @@
 //@ needs-sanitizer-memory
 //@ revisions:MSAN-0 MSAN-1 MSAN-2 MSAN-1-LTO MSAN-2-LTO
 //
-//@ compile-flags: -Zsanitizer=memory -Ctarget-feature=-crt-static
+//@ compile-flags: -Zsanitizer=memory -Ctarget-feature=-crt-static -C unsafe-allow-abi-mismatch=sanitizer
 // [MSAN-0] no extra compile-flags
 //@[MSAN-1] compile-flags: -Zsanitizer-memory-track-origins=1
 //@[MSAN-2] compile-flags: -Zsanitizer-memory-track-origins
diff --git a/tests/codegen-llvm/sanitizer/memtag-attr-check.rs b/tests/codegen-llvm/sanitizer/memtag-attr-check.rs
index ffe3a2322a20e..fc430f3a57003 100644
--- a/tests/codegen-llvm/sanitizer/memtag-attr-check.rs
+++ b/tests/codegen-llvm/sanitizer/memtag-attr-check.rs
@@ -2,7 +2,7 @@
 // applied when enabling the memtag sanitizer.
 //
 //@ needs-sanitizer-memtag
-//@ compile-flags: -Zsanitizer=memtag -Ctarget-feature=+mte -Copt-level=0
+//@ compile-flags: -C unsafe-allow-abi-mismatch=sanitizer -Zsanitizer=memtag -Ctarget-feature=+mte -Copt-level=0
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/sanitizer/safestack-attr-check.rs b/tests/codegen-llvm/sanitizer/safestack-attr-check.rs
index 050a60333afa1..414dd89a58072 100644
--- a/tests/codegen-llvm/sanitizer/safestack-attr-check.rs
+++ b/tests/codegen-llvm/sanitizer/safestack-attr-check.rs
@@ -1,7 +1,7 @@
 // This tests that the safestack attribute is applied when enabling the safe-stack sanitizer.
 //
 //@ needs-sanitizer-safestack
-//@ compile-flags: -Zsanitizer=safestack -Copt-level=0
+//@ compile-flags: -Zsanitizer=safestack -Copt-level=0 -C unsafe-allow-abi-mismatch=sanitizer
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/sanitizer/sanitize-off-inlining.rs b/tests/codegen-llvm/sanitizer/sanitize-off-inlining.rs
index 69771827c3a7e..0f43e6b8393dd 100644
--- a/tests/codegen-llvm/sanitizer/sanitize-off-inlining.rs
+++ b/tests/codegen-llvm/sanitizer/sanitize-off-inlining.rs
@@ -1,9 +1,9 @@
 // Verifies that sanitize(xyz = "off") attribute prevents inlining when
 // given sanitizer is enabled, but has no effect on inlining otherwise.
-//
 //@ needs-sanitizer-address
 //@ needs-sanitizer-leak
 //@ revisions: ASAN LSAN
+//@       compile-flags: -C unsafe-allow-abi-mismatch=sanitizer
 //@       compile-flags: -Copt-level=3 -Zmir-opt-level=4 -Ctarget-feature=-crt-static
 //@[ASAN] compile-flags: -Zsanitizer=address
 //@[LSAN] compile-flags: -Zsanitizer=leak
diff --git a/tests/codegen-llvm/sanitizer/sanitize-off-kasan-asan.rs b/tests/codegen-llvm/sanitizer/sanitize-off-kasan-asan.rs
index 94945f2b2e6ec..61ad0ba7d90d3 100644
--- a/tests/codegen-llvm/sanitizer/sanitize-off-kasan-asan.rs
+++ b/tests/codegen-llvm/sanitizer/sanitize-off-kasan-asan.rs
@@ -2,7 +2,7 @@
 // the address sanitizer.
 //
 //@ needs-sanitizer-address
-//@ compile-flags: -Zsanitizer=address -Ctarget-feature=-crt-static -Copt-level=0
+//@ compile-flags: -Zsanitizer=address -Ctarget-feature=-crt-static -Copt-level=0 -C unsafe-allow-abi-mismatch=sanitizer
 
 #![crate_type = "lib"]
 #![feature(sanitize)]
diff --git a/tests/codegen-llvm/sanitizer/sanitizer-recover.rs b/tests/codegen-llvm/sanitizer/sanitizer-recover.rs
index 6b65932048184..b8a24e31c30bb 100644
--- a/tests/codegen-llvm/sanitizer/sanitizer-recover.rs
+++ b/tests/codegen-llvm/sanitizer/sanitizer-recover.rs
@@ -5,7 +5,7 @@
 //@ needs-sanitizer-memory
 //@ revisions:ASAN ASAN-RECOVER MSAN MSAN-RECOVER MSAN-RECOVER-LTO
 //@ no-prefer-dynamic
-//
+//@                   compile-flags: -C unsafe-allow-abi-mismatch=sanitizer
 //@                   compile-flags: -Ctarget-feature=-crt-static
 //@[ASAN]             compile-flags: -Zsanitizer=address -Copt-level=0
 //@[ASAN-RECOVER]     compile-flags: -Zsanitizer=address -Zsanitizer-recover=address -Copt-level=0
diff --git a/tests/run-make/sanitizer-cdylib-link/rmake.rs b/tests/run-make/sanitizer-cdylib-link/rmake.rs
index f9d7fd98789e6..8ff58594d109a 100644
--- a/tests/run-make/sanitizer-cdylib-link/rmake.rs
+++ b/tests/run-make/sanitizer-cdylib-link/rmake.rs
@@ -8,6 +8,8 @@
 //@ needs-sanitizer-support
 //@ needs-sanitizer-address
 
+//@ compile-flags: -C unsafe-allow-abi-mismatch=sanitizer
+
 use run_make_support::{run_fail, rustc};
 
 fn main() {
diff --git a/tests/run-make/sanitizer-dylib-link/rmake.rs b/tests/run-make/sanitizer-dylib-link/rmake.rs
index b43420adc72ba..bae3240a23648 100644
--- a/tests/run-make/sanitizer-dylib-link/rmake.rs
+++ b/tests/run-make/sanitizer-dylib-link/rmake.rs
@@ -7,6 +7,8 @@
 //@ needs-sanitizer-support
 //@ needs-sanitizer-address
 
+//@ compile-flags: -C unsafe-allow-abi-mismatch=sanitizer
+
 use run_make_support::{run_fail, rustc};
 
 fn main() {
diff --git a/tests/run-make/sanitizer-staticlib-link/rmake.rs b/tests/run-make/sanitizer-staticlib-link/rmake.rs
index e38d15a8a3c4b..dda9262618903 100644
--- a/tests/run-make/sanitizer-staticlib-link/rmake.rs
+++ b/tests/run-make/sanitizer-staticlib-link/rmake.rs
@@ -11,6 +11,8 @@
 //@ needs-sanitizer-support
 //@ needs-sanitizer-address
 
+//@ compile-flags: -C unsafe-allow-abi-mismatch=sanitizer
+
 use run_make_support::{cc, extra_c_flags, extra_cxx_flags, run_fail, rustc, static_lib_name};
 
 fn main() {
diff --git a/tests/rustdoc/sanitizer-option.rs b/tests/rustdoc/sanitizer-option.rs
index 2adf1be51fd7f..7b0038138f09f 100644
--- a/tests/rustdoc/sanitizer-option.rs
+++ b/tests/rustdoc/sanitizer-option.rs
@@ -1,6 +1,6 @@
 //@ needs-sanitizer-support
 //@ needs-sanitizer-address
-//@ compile-flags: --test -Z sanitizer=address
+//@ compile-flags: --test -Z sanitizer=address -C unsafe-allow-abi-mismatch=sanitizer
 //
 // #43031: Verify that rustdoc passes `-Z` options to rustc. Use an extern
 // function that is provided by the sanitizer runtime, if flag is not passed
diff --git a/tests/ui/asm/global-asm-isnt-really-a-mir-body.rs b/tests/ui/asm/global-asm-isnt-really-a-mir-body.rs
index b7636d116ec6c..aef25d057d4ba 100644
--- a/tests/ui/asm/global-asm-isnt-really-a-mir-body.rs
+++ b/tests/ui/asm/global-asm-isnt-really-a-mir-body.rs
@@ -1,5 +1,7 @@
 //@ revisions: emit_mir instrument cfi
 
+//@ compile-flags: -C unsafe-allow-abi-mismatch=sanitizer
+
 // Make sure we don't try to emit MIR for it.
 //@[emit_mir] compile-flags: --emit=mir
 
diff --git a/tests/ui/lto/issue-100772.rs b/tests/ui/lto/issue-100772.rs
index 29ec5b9bf9647..9468e20894ace 100644
--- a/tests/ui/lto/issue-100772.rs
+++ b/tests/ui/lto/issue-100772.rs
@@ -1,6 +1,6 @@
 //@ build-pass
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Ccodegen-units=1 -Clto -Ctarget-feature=-crt-static -Zsanitizer=cfi
+//@ compile-flags: -Ccodegen-units=1 -Clto -Ctarget-feature=-crt-static -Zsanitizer=cfi -C unsafe-allow-abi-mismatch=sanitizer
 //@ no-prefer-dynamic
 //@ only-x86_64-unknown-linux-gnu
 
diff --git a/tests/ui/sanitizer/address.rs b/tests/ui/sanitizer/address.rs
index 704d84764c168..1688f46c2d556 100644
--- a/tests/ui/sanitizer/address.rs
+++ b/tests/ui/sanitizer/address.rs
@@ -2,7 +2,7 @@
 //@ needs-sanitizer-address
 //@ ignore-cross-compile
 //
-//@ compile-flags: -Z sanitizer=address -O -g
+//@ compile-flags: -Z sanitizer=address -O -g -C unsafe-allow-abi-mismatch=sanitizer
 //
 //@ run-fail-or-crash
 //@ error-pattern: AddressSanitizer: stack-buffer-overflow
diff --git a/tests/ui/sanitizer/asan_odr_windows.rs b/tests/ui/sanitizer/asan_odr_windows.rs
index 28c2471676155..b638d6eb9694c 100644
--- a/tests/ui/sanitizer/asan_odr_windows.rs
+++ b/tests/ui/sanitizer/asan_odr_windows.rs
@@ -2,7 +2,7 @@
 //! See <https://github.com/rust-lang/rust/issues/124390>.
 
 //@ run-pass
-//@ compile-flags:-Zsanitizer=address
+//@ compile-flags:-Zsanitizer=address -C unsafe-allow-abi-mismatch=sanitizer
 //@ aux-build: asan_odr_win-2.rs
 //@ only-windows-msvc
 //@ needs-sanitizer-support
diff --git a/tests/ui/sanitizer/badfree.rs b/tests/ui/sanitizer/badfree.rs
index 6b3aea7239c24..b1b02649dccdc 100644
--- a/tests/ui/sanitizer/badfree.rs
+++ b/tests/ui/sanitizer/badfree.rs
@@ -2,7 +2,7 @@
 //@ needs-sanitizer-address
 //@ ignore-cross-compile
 //
-//@ compile-flags: -Z sanitizer=address -O
+//@ compile-flags: -Z sanitizer=address -O -C unsafe-allow-abi-mismatch=sanitizer
 //
 //@ run-fail-or-crash
 //@ regex-error-pattern: AddressSanitizer: (SEGV|attempting free on address which was not malloc)
diff --git a/tests/ui/sanitizer/cfi/assoc-ty-lifetime-issue-123053.rs b/tests/ui/sanitizer/cfi/assoc-ty-lifetime-issue-123053.rs
index fad57198dfbeb..5de5e99f6d0cc 100644
--- a/tests/ui/sanitizer/cfi/assoc-ty-lifetime-issue-123053.rs
+++ b/tests/ui/sanitizer/cfi/assoc-ty-lifetime-issue-123053.rs
@@ -2,7 +2,7 @@
 // trait object type to fail, causing an ICE.
 //
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Ccodegen-units=1 -Clto -Ctarget-feature=-crt-static -Zsanitizer=cfi
+//@ compile-flags: -Ccodegen-units=1 -Clto -Ctarget-feature=-crt-static -Zsanitizer=cfi -C unsafe-allow-abi-mismatch=sanitizer
 //@ edition: 2021
 //@ no-prefer-dynamic
 //@ only-x86_64-unknown-linux-gnu
diff --git a/tests/ui/sanitizer/cfi/async-closures.rs b/tests/ui/sanitizer/cfi/async-closures.rs
index 9b0992630002f..621a0882c91b2 100644
--- a/tests/ui/sanitizer/cfi/async-closures.rs
+++ b/tests/ui/sanitizer/cfi/async-closures.rs
@@ -7,7 +7,7 @@
 //@ ignore-backends: gcc
 //@ [cfi] needs-sanitizer-cfi
 //@ [kcfi] needs-sanitizer-kcfi
-//@ compile-flags: -C target-feature=-crt-static
+//@ compile-flags: -C target-feature=-crt-static -C unsafe-allow-abi-mismatch=sanitizer
 //@ [cfi] compile-flags: -C codegen-units=1 -C lto -C prefer-dynamic=off -C opt-level=0
 //@ [cfi] compile-flags: -Z sanitizer=cfi
 //@ [kcfi] compile-flags: -Z sanitizer=kcfi
diff --git a/tests/ui/sanitizer/cfi/can-reveal-opaques.rs b/tests/ui/sanitizer/cfi/can-reveal-opaques.rs
index a881c6b92b285..310ce04c55240 100644
--- a/tests/ui/sanitizer/cfi/can-reveal-opaques.rs
+++ b/tests/ui/sanitizer/cfi/can-reveal-opaques.rs
@@ -1,5 +1,5 @@
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Ccodegen-units=1 -Clto -Ctarget-feature=-crt-static -Zsanitizer=cfi
+//@ compile-flags: -Ccodegen-units=1 -Clto -Ctarget-feature=-crt-static -Zsanitizer=cfi -C unsafe-allow-abi-mismatch=sanitizer
 //@ no-prefer-dynamic
 //@ only-x86_64-unknown-linux-gnu
 //@ ignore-backends: gcc
diff --git a/tests/ui/sanitizer/cfi/closures.rs b/tests/ui/sanitizer/cfi/closures.rs
index fc9718faa2869..7493dba4928b0 100644
--- a/tests/ui/sanitizer/cfi/closures.rs
+++ b/tests/ui/sanitizer/cfi/closures.rs
@@ -6,7 +6,7 @@
 //@ ignore-backends: gcc
 //@ [cfi] needs-sanitizer-cfi
 //@ [kcfi] needs-sanitizer-kcfi
-//@ compile-flags: -C target-feature=-crt-static
+//@ compile-flags: -C target-feature=-crt-static -C unsafe-allow-abi-mismatch=sanitizer
 //@ [cfi] compile-flags: -C codegen-units=1 -C lto -C prefer-dynamic=off -C opt-level=0
 //@ [cfi] compile-flags: -Z sanitizer=cfi
 //@ [kcfi] compile-flags: -Z sanitizer=kcfi
diff --git a/tests/ui/sanitizer/cfi/complex-receiver.rs b/tests/ui/sanitizer/cfi/complex-receiver.rs
index aac44c33227fd..adacc0d6c5df7 100644
--- a/tests/ui/sanitizer/cfi/complex-receiver.rs
+++ b/tests/ui/sanitizer/cfi/complex-receiver.rs
@@ -8,7 +8,7 @@
 //@ ignore-backends: gcc
 //@ [cfi] needs-sanitizer-cfi
 //@ [kcfi] needs-sanitizer-kcfi
-//@ compile-flags: -C target-feature=-crt-static
+//@ compile-flags: -C target-feature=-crt-static -C unsafe-allow-abi-mismatch=sanitizer
 //@ [cfi] compile-flags: -C codegen-units=1 -C lto -C prefer-dynamic=off -C opt-level=0
 //@ [cfi] compile-flags: -Z sanitizer=cfi
 //@ [kcfi] compile-flags: -Z sanitizer=kcfi
diff --git a/tests/ui/sanitizer/cfi/coroutine.rs b/tests/ui/sanitizer/cfi/coroutine.rs
index 084a521f597fb..d85615b597de2 100644
--- a/tests/ui/sanitizer/cfi/coroutine.rs
+++ b/tests/ui/sanitizer/cfi/coroutine.rs
@@ -8,6 +8,7 @@
 //@ [cfi] needs-sanitizer-cfi
 //@ [kcfi] needs-sanitizer-kcfi
 //@ compile-flags: -C target-feature=-crt-static
+//@ compile-flags: -C unsafe-allow-abi-mismatch=sanitizer
 //@ [cfi] compile-flags: -C codegen-units=1 -C lto -C prefer-dynamic=off -C opt-level=0
 //@ [cfi] compile-flags: -Z sanitizer=cfi
 //@ [kcfi] compile-flags: -Z sanitizer=kcfi
diff --git a/tests/ui/sanitizer/cfi/drop-in-place.rs b/tests/ui/sanitizer/cfi/drop-in-place.rs
index 160338a5b54a7..fe59d54631248 100644
--- a/tests/ui/sanitizer/cfi/drop-in-place.rs
+++ b/tests/ui/sanitizer/cfi/drop-in-place.rs
@@ -5,6 +5,7 @@
 //@ ignore-backends: gcc
 //@ needs-sanitizer-cfi
 //@ compile-flags: -Clto -Copt-level=0 -Cprefer-dynamic=off -Ctarget-feature=-crt-static -Zsanitizer=cfi
+//@ compile-flags: -C unsafe-allow-abi-mismatch=sanitizer
 //@ run-pass
 
 struct EmptyDrop;
diff --git a/tests/ui/sanitizer/cfi/drop-no-principal.rs b/tests/ui/sanitizer/cfi/drop-no-principal.rs
index e3a46fe9d7595..4fb905eb51d05 100644
--- a/tests/ui/sanitizer/cfi/drop-no-principal.rs
+++ b/tests/ui/sanitizer/cfi/drop-no-principal.rs
@@ -4,7 +4,7 @@
 // FIXME(#122848) Remove only-linux once OSX CFI binaries works
 //@ only-linux
 //@ ignore-backends: gcc
-//@ compile-flags: --crate-type=bin -Cprefer-dynamic=off -Clto -Zsanitizer=cfi
+//@ compile-flags: --crate-type=bin -Cprefer-dynamic=off -Clto -Zsanitizer=cfi -C unsafe-allow-abi-mismatch=sanitizer
 //@ compile-flags: -C target-feature=-crt-static -C codegen-units=1 -C opt-level=0
 // FIXME(#118761) Should be run-pass once the labels on drop are compatible.
 // This test is being landed ahead of that to test that the compiler doesn't ICE while labeling the
diff --git a/tests/ui/sanitizer/cfi/fn-ptr.rs b/tests/ui/sanitizer/cfi/fn-ptr.rs
index d3209c62ddf91..bdb8c7ceb328c 100644
--- a/tests/ui/sanitizer/cfi/fn-ptr.rs
+++ b/tests/ui/sanitizer/cfi/fn-ptr.rs
@@ -7,6 +7,7 @@
 //@ [cfi] needs-sanitizer-cfi
 //@ [kcfi] needs-sanitizer-kcfi
 //@ compile-flags: -C target-feature=-crt-static
+//@ compile-flags: -C unsafe-allow-abi-mismatch=sanitizer
 //@ [cfi] compile-flags: -C opt-level=0 -C codegen-units=1 -C lto
 //@ [cfi] compile-flags: -C prefer-dynamic=off
 //@ [cfi] compile-flags: -Z sanitizer=cfi
diff --git a/tests/ui/sanitizer/cfi/generalize-pointers-attr-cfg.rs b/tests/ui/sanitizer/cfi/generalize-pointers-attr-cfg.rs
index d46002c69fda0..44cdcb250e701 100644
--- a/tests/ui/sanitizer/cfi/generalize-pointers-attr-cfg.rs
+++ b/tests/ui/sanitizer/cfi/generalize-pointers-attr-cfg.rs
@@ -4,6 +4,7 @@
 //@ needs-sanitizer-cfi
 //@ check-pass
 //@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-generalize-pointers
+//@ compile-flags: -C unsafe-allow-abi-mismatch=sanitizer
 
 #![feature(cfg_sanitizer_cfi)]
 
diff --git a/tests/ui/sanitizer/cfi/normalize-integers-attr-cfg.rs b/tests/ui/sanitizer/cfi/normalize-integers-attr-cfg.rs
index 24c2c2c13da75..ce4e31eb69b5a 100644
--- a/tests/ui/sanitizer/cfi/normalize-integers-attr-cfg.rs
+++ b/tests/ui/sanitizer/cfi/normalize-integers-attr-cfg.rs
@@ -3,7 +3,7 @@
 //
 //@ needs-sanitizer-cfi
 //@ check-pass
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-normalize-integers
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-normalize-integers -C unsafe-allow-abi-mismatch=sanitizer,sanitizer-cfi-normalize-integers
 
 #![feature(cfg_sanitizer_cfi)]
 
diff --git a/tests/ui/sanitizer/cfi/self-ref.rs b/tests/ui/sanitizer/cfi/self-ref.rs
index b93d49296b639..827610a261064 100644
--- a/tests/ui/sanitizer/cfi/self-ref.rs
+++ b/tests/ui/sanitizer/cfi/self-ref.rs
@@ -6,7 +6,7 @@
 //@ ignore-backends: gcc
 //@ [cfi] needs-sanitizer-cfi
 //@ [kcfi] needs-sanitizer-kcfi
-//@ compile-flags: -C target-feature=-crt-static
+//@ compile-flags: -C target-feature=-crt-static -C unsafe-allow-abi-mismatch=sanitizer
 //@ [cfi] compile-flags: -C codegen-units=1 -C lto -C prefer-dynamic=off -C opt-level=0
 //@ [cfi] compile-flags: -Z sanitizer=cfi
 //@ [kcfi] compile-flags: -Z sanitizer=kcfi
diff --git a/tests/ui/sanitizer/cfi/sized-associated-ty.rs b/tests/ui/sanitizer/cfi/sized-associated-ty.rs
index eefc3e2e9db9f..da8c385c6fc8b 100644
--- a/tests/ui/sanitizer/cfi/sized-associated-ty.rs
+++ b/tests/ui/sanitizer/cfi/sized-associated-ty.rs
@@ -7,7 +7,7 @@
 //@ ignore-backends: gcc
 //@ [cfi] needs-sanitizer-cfi
 //@ [kcfi] needs-sanitizer-kcfi
-//@ compile-flags: -C target-feature=-crt-static
+//@ compile-flags: -C target-feature=-crt-static -C unsafe-allow-abi-mismatch=sanitizer
 //@ [cfi] compile-flags: -C codegen-units=1 -C lto -C prefer-dynamic=off -C opt-level=0
 //@ [cfi] compile-flags: -Z sanitizer=cfi
 //@ [kcfi] compile-flags: -Z sanitizer=kcfi
diff --git a/tests/ui/sanitizer/cfi/supertraits.rs b/tests/ui/sanitizer/cfi/supertraits.rs
index f5a984b9583da..b2782dff5d555 100644
--- a/tests/ui/sanitizer/cfi/supertraits.rs
+++ b/tests/ui/sanitizer/cfi/supertraits.rs
@@ -6,7 +6,7 @@
 //@ ignore-backends: gcc
 //@ [cfi] needs-sanitizer-cfi
 //@ [kcfi] needs-sanitizer-kcfi
-//@ compile-flags: -C target-feature=-crt-static
+//@ compile-flags: -C target-feature=-crt-static -C unsafe-allow-abi-mismatch=sanitizer
 //@ [cfi] compile-flags: -C codegen-units=1 -C lto -C prefer-dynamic=off -C opt-level=0
 //@ [cfi] compile-flags: -Z sanitizer=cfi
 //@ [kcfi] compile-flags: -Z sanitizer=kcfi
diff --git a/tests/ui/sanitizer/cfi/transparent-has-regions.rs b/tests/ui/sanitizer/cfi/transparent-has-regions.rs
index b70e1ea179121..b82850133c100 100644
--- a/tests/ui/sanitizer/cfi/transparent-has-regions.rs
+++ b/tests/ui/sanitizer/cfi/transparent-has-regions.rs
@@ -1,5 +1,5 @@
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Ccodegen-units=1 -Clto -Ctarget-feature=-crt-static -Zsanitizer=cfi
+//@ compile-flags: -Ccodegen-units=1 -Clto -Ctarget-feature=-crt-static -Zsanitizer=cfi -C unsafe-allow-abi-mismatch=sanitizer
 //@ no-prefer-dynamic
 //@ only-x86_64-unknown-linux-gnu
 //@ build-pass
diff --git a/tests/ui/sanitizer/cfi/virtual-auto.rs b/tests/ui/sanitizer/cfi/virtual-auto.rs
index e6f2ebd4b2cd7..d3a715c079aa6 100644
--- a/tests/ui/sanitizer/cfi/virtual-auto.rs
+++ b/tests/ui/sanitizer/cfi/virtual-auto.rs
@@ -6,7 +6,7 @@
 //@ ignore-backends: gcc
 //@ [cfi] needs-sanitizer-cfi
 //@ [kcfi] needs-sanitizer-kcfi
-//@ compile-flags: -C target-feature=-crt-static
+//@ compile-flags: -C target-feature=-crt-static -C unsafe-allow-abi-mismatch=sanitizer
 //@ [cfi] compile-flags: -C codegen-units=1 -C lto -C prefer-dynamic=off -C opt-level=0
 //@ [cfi] compile-flags: -Z sanitizer=cfi
 //@ [kcfi] compile-flags: -Z sanitizer=kcfi
diff --git a/tests/ui/sanitizer/dataflow.rs b/tests/ui/sanitizer/dataflow.rs
index 658a9e4808664..d99a1a6ac2479 100644
--- a/tests/ui/sanitizer/dataflow.rs
+++ b/tests/ui/sanitizer/dataflow.rs
@@ -4,7 +4,7 @@
 //@ needs-sanitizer-support
 //@ needs-sanitizer-dataflow
 //@ run-pass
-//@ compile-flags: -Zsanitizer=dataflow -Zsanitizer-dataflow-abilist={{src-base}}/sanitizer/dataflow-abilist.txt
+//@ compile-flags: -Zsanitizer=dataflow -Zsanitizer-dataflow-abilist={{src-base}}/sanitizer/dataflow-abilist.txt -C unsafe-allow-abi-mismatch=sanitizer
 
 use std::mem::size_of;
 use std::os::raw::{c_int, c_long, c_void};
diff --git a/tests/ui/sanitizer/hwaddress.rs b/tests/ui/sanitizer/hwaddress.rs
index e5939eb734b66..05fcab17506b9 100644
--- a/tests/ui/sanitizer/hwaddress.rs
+++ b/tests/ui/sanitizer/hwaddress.rs
@@ -5,7 +5,7 @@
 //@ ignore-aarch64-unknown-linux-gnu
 //
 // FIXME(#83989): codegen-units=1 triggers linker errors on aarch64-gnu
-//@ compile-flags: -Z sanitizer=hwaddress -O -g -C codegen-units=16
+//@ compile-flags: -Z sanitizer=hwaddress -O -g -C codegen-units=16 -C unsafe-allow-abi-mismatch=sanitizer
 //
 //@ run-fail
 //@ error-pattern: HWAddressSanitizer: tag-mismatch
diff --git a/tests/ui/sanitizer/issue-111184-cfi-coroutine-witness.rs b/tests/ui/sanitizer/issue-111184-cfi-coroutine-witness.rs
index 7d0c73c2841e8..be81c7bd0cac1 100644
--- a/tests/ui/sanitizer/issue-111184-cfi-coroutine-witness.rs
+++ b/tests/ui/sanitizer/issue-111184-cfi-coroutine-witness.rs
@@ -2,7 +2,7 @@
 // encode_ty and caused the compiler to ICE.
 //
 //@ needs-sanitizer-cfi
-//@ compile-flags: -Ccodegen-units=1 -Clto -Ctarget-feature=-crt-static -Zsanitizer=cfi
+//@ compile-flags: -Ccodegen-units=1 -Clto -Ctarget-feature=-crt-static -Zsanitizer=cfi -C unsafe-allow-abi-mismatch=sanitizer
 //@ edition: 2021
 //@ no-prefer-dynamic
 //@ only-x86_64-unknown-linux-gnu
diff --git a/tests/ui/sanitizer/issue-114275-cfi-const-expr-in-arry-len.rs b/tests/ui/sanitizer/issue-114275-cfi-const-expr-in-arry-len.rs
index b1b7487fa2a4d..f7af2842ad613 100644
--- a/tests/ui/sanitizer/issue-114275-cfi-const-expr-in-arry-len.rs
+++ b/tests/ui/sanitizer/issue-114275-cfi-const-expr-in-arry-len.rs
@@ -2,7 +2,7 @@
 // was expecting array type lengths to be evaluated, this was causing an ICE.
 //
 //@ build-pass
-//@ compile-flags: -Ccodegen-units=1 -Clto -Zsanitizer=cfi -Ctarget-feature=-crt-static
+//@ compile-flags: -Ccodegen-units=1 -Clto -Zsanitizer=cfi -Ctarget-feature=-crt-static -C unsafe-allow-abi-mismatch=sanitizer
 //@ needs-sanitizer-cfi
 
 #![crate_type = "lib"]
diff --git a/tests/ui/sanitizer/issue-72154-address-lifetime-markers.rs b/tests/ui/sanitizer/issue-72154-address-lifetime-markers.rs
index aa0c19db9a12b..edeb1b0bf946e 100644
--- a/tests/ui/sanitizer/issue-72154-address-lifetime-markers.rs
+++ b/tests/ui/sanitizer/issue-72154-address-lifetime-markers.rs
@@ -7,7 +7,7 @@
 //@ needs-sanitizer-address
 //@ ignore-cross-compile
 //
-//@ compile-flags: -Copt-level=0 -Zsanitizer=address
+//@ compile-flags: -Copt-level=0 -Zsanitizer=address -C unsafe-allow-abi-mismatch=sanitizer
 //@ run-pass
 
 pub struct Wrap {
diff --git a/tests/ui/sanitizer/kcfi-mangling.rs b/tests/ui/sanitizer/kcfi-mangling.rs
index ba36dc184ec7e..371f34ba72af2 100644
--- a/tests/ui/sanitizer/kcfi-mangling.rs
+++ b/tests/ui/sanitizer/kcfi-mangling.rs
@@ -2,7 +2,7 @@
 
 //@ needs-sanitizer-kcfi
 //@ no-prefer-dynamic
-//@ compile-flags: -C panic=abort -Zsanitizer=kcfi -C symbol-mangling-version=v0
+//@ compile-flags: -C panic=abort -Zsanitizer=kcfi -C symbol-mangling-version=v0 -C unsafe-allow-abi-mismatch=sanitizer
 //@ build-pass
 //@ ignore-backends: gcc
 
diff --git a/tests/ui/sanitizer/leak.rs b/tests/ui/sanitizer/leak.rs
index 65915ec24b723..4ce3f7ab1b951 100644
--- a/tests/ui/sanitizer/leak.rs
+++ b/tests/ui/sanitizer/leak.rs
@@ -1,7 +1,7 @@
 //@ needs-sanitizer-support
 //@ needs-sanitizer-leak
 //
-//@ compile-flags: -Z sanitizer=leak -O
+//@ compile-flags: -Z sanitizer=leak -O -C unsafe-allow-abi-mismatch=sanitizer
 //
 //@ run-fail
 //@ error-pattern: LeakSanitizer: detected memory leaks
diff --git a/tests/ui/sanitizer/memory-eager.rs b/tests/ui/sanitizer/memory-eager.rs
index 709299f87d49f..9498336abb7d0 100644
--- a/tests/ui/sanitizer/memory-eager.rs
+++ b/tests/ui/sanitizer/memory-eager.rs
@@ -1,6 +1,8 @@
 //@ needs-sanitizer-support
 //@ needs-sanitizer-memory
 //
+//@ compile-flags: -C unsafe-allow-abi-mismatch=sanitizer
+//
 //@ revisions: unoptimized optimized
 //
 //@ [optimized]compile-flags: -Z sanitizer=memory -Zsanitizer-memory-track-origins -O
diff --git a/tests/ui/sanitizer/memory-passing.rs b/tests/ui/sanitizer/memory-passing.rs
index 96a4cd909c7c2..6ac41b178fe7f 100644
--- a/tests/ui/sanitizer/memory-passing.rs
+++ b/tests/ui/sanitizer/memory-passing.rs
@@ -1,6 +1,8 @@
 //@ needs-sanitizer-support
 //@ needs-sanitizer-memory
 //
+//@ compile-flags: -C unsafe-allow-abi-mismatch=sanitizer
+//
 //@ revisions: unoptimized optimized
 //
 //@ [optimized]compile-flags: -Z sanitizer=memory -Zsanitizer-memory-track-origins -O
diff --git a/tests/ui/sanitizer/memory.rs b/tests/ui/sanitizer/memory.rs
index a91fefe4d16da..1566637acd222 100644
--- a/tests/ui/sanitizer/memory.rs
+++ b/tests/ui/sanitizer/memory.rs
@@ -1,6 +1,8 @@
 //@ needs-sanitizer-support
 //@ needs-sanitizer-memory
 //
+//@ compile-flags: -C unsafe-allow-abi-mismatch=sanitizer
+//
 //@ revisions: unoptimized optimized
 //
 //@ [optimized]compile-flags: -Z sanitizer=memory -Zsanitizer-memory-track-origins -O
diff --git a/tests/ui/sanitizer/new-llvm-pass-manager-thin-lto.rs b/tests/ui/sanitizer/new-llvm-pass-manager-thin-lto.rs
index c1a2c2f26ace5..b66568474277e 100644
--- a/tests/ui/sanitizer/new-llvm-pass-manager-thin-lto.rs
+++ b/tests/ui/sanitizer/new-llvm-pass-manager-thin-lto.rs
@@ -6,6 +6,8 @@
 //@ needs-sanitizer-address
 //@ ignore-cross-compile
 //
+//@ compile-flags: -C unsafe-allow-abi-mismatch=sanitizer
+//
 //@ no-prefer-dynamic
 //@ revisions: opt0 opt1
 //@ compile-flags: -Zsanitizer=address -Clto=thin
diff --git a/tests/ui/sanitizer/thread.rs b/tests/ui/sanitizer/thread.rs
index 9073124d1bd38..8f72b1b41a84c 100644
--- a/tests/ui/sanitizer/thread.rs
+++ b/tests/ui/sanitizer/thread.rs
@@ -13,7 +13,7 @@
 //@ needs-sanitizer-support
 //@ needs-sanitizer-thread
 //
-//@ compile-flags: -Z sanitizer=thread -O
+//@ compile-flags: -Z sanitizer=thread -O -C unsafe-allow-abi-mismatch=sanitizer
 //
 //@ run-fail-or-crash
 //@ error-pattern: WARNING: ThreadSanitizer: data race
diff --git a/tests/ui/sanitizer/use-after-scope.rs b/tests/ui/sanitizer/use-after-scope.rs
index 106dc6466d6a2..1c477d0be14b8 100644
--- a/tests/ui/sanitizer/use-after-scope.rs
+++ b/tests/ui/sanitizer/use-after-scope.rs
@@ -2,7 +2,7 @@
 //@ needs-sanitizer-address
 //@ ignore-cross-compile
 //
-//@ compile-flags: -Zsanitizer=address
+//@ compile-flags: -Zsanitizer=address -C unsafe-allow-abi-mismatch=sanitizer
 //@ run-fail-or-crash
 //@ error-pattern: ERROR: AddressSanitizer: stack-use-after-scope
 
diff --git a/tests/ui/target_modifiers/auxiliary/kcfi-normalize-ints.rs b/tests/ui/target_modifiers/auxiliary/kcfi-normalize-ints.rs
new file mode 100644
index 0000000000000..f97005a14502d
--- /dev/null
+++ b/tests/ui/target_modifiers/auxiliary/kcfi-normalize-ints.rs
@@ -0,0 +1,7 @@
+//@ no-prefer-dynamic
+//@ needs-sanitizer-kcfi
+//@ compile-flags: -C panic=abort -Zsanitizer=kcfi -Zsanitizer-cfi-normalize-integers
+
+#![feature(no_core)]
+#![crate_type = "rlib"]
+#![no_core]
diff --git a/tests/ui/target_modifiers/auxiliary/no-sanitizers.rs b/tests/ui/target_modifiers/auxiliary/no-sanitizers.rs
new file mode 100644
index 0000000000000..1d47ff6826dab
--- /dev/null
+++ b/tests/ui/target_modifiers/auxiliary/no-sanitizers.rs
@@ -0,0 +1,6 @@
+//@ no-prefer-dynamic
+//@ compile-flags: -C panic=abort
+
+#![feature(no_core)]
+#![crate_type = "rlib"]
+#![no_core]
diff --git a/tests/ui/target_modifiers/auxiliary/safestack-and-kcfi.rs b/tests/ui/target_modifiers/auxiliary/safestack-and-kcfi.rs
new file mode 100644
index 0000000000000..029744d2a1fe4
--- /dev/null
+++ b/tests/ui/target_modifiers/auxiliary/safestack-and-kcfi.rs
@@ -0,0 +1,10 @@
+//@ no-prefer-dynamic
+
+//@ needs-sanitizer-kcfi
+//@ needs-sanitizer-safestack
+
+//@ compile-flags: -C panic=abort -Zsanitizer=safestack,kcfi
+
+#![feature(no_core)]
+#![crate_type = "rlib"]
+#![no_core]
diff --git a/tests/ui/target_modifiers/sanitizer-kcfi-normalize-ints.rs b/tests/ui/target_modifiers/sanitizer-kcfi-normalize-ints.rs
new file mode 100644
index 0000000000000..cb9f701349ae6
--- /dev/null
+++ b/tests/ui/target_modifiers/sanitizer-kcfi-normalize-ints.rs
@@ -0,0 +1,18 @@
+// For kCFI, the helper flag -Zsanitizer-cfi-normalize-integers should also be a target modifier.
+
+//@ needs-sanitizer-kcfi
+//@ aux-build:kcfi-normalize-ints.rs
+//@ compile-flags: -Cpanic=abort
+
+//@ revisions: ok wrong_flag wrong_sanitizer
+//@[ok] compile-flags: -Zsanitizer=kcfi -Zsanitizer-cfi-normalize-integers
+//@[wrong_flag] compile-flags: -Zsanitizer=kcfi
+//@[ok] check-pass
+
+#![feature(no_core)]
+//[wrong_flag]~^ ERROR mixing `-Zsanitizer-cfi-normalize-integers` will cause an ABI mismatch in crate `sanitizer_kcfi_normalize_ints`
+//[wrong_sanitizer]~^^ ERROR mixing `-Zsanitizer` will cause an ABI mismatch in crate `sanitizer_kcfi_normalize_ints`
+#![crate_type = "rlib"]
+#![no_core]
+
+extern crate kcfi_normalize_ints;
diff --git a/tests/ui/target_modifiers/sanitizer-kcfi-normalize-ints.wrong_flag.stderr b/tests/ui/target_modifiers/sanitizer-kcfi-normalize-ints.wrong_flag.stderr
new file mode 100644
index 0000000000000..1db79b025e9c9
--- /dev/null
+++ b/tests/ui/target_modifiers/sanitizer-kcfi-normalize-ints.wrong_flag.stderr
@@ -0,0 +1,13 @@
+error: mixing `-Zsanitizer-cfi-normalize-integers` will cause an ABI mismatch in crate `sanitizer_kcfi_normalize_ints`
+  --> $DIR/sanitizer-kcfi-normalize-ints.rs:12:1
+   |
+LL | #![feature(no_core)]
+   | ^
+   |
+   = help: the `-Zsanitizer-cfi-normalize-integers` flag modifies the ABI so Rust crates compiled with different values of this flag cannot be used together safely
+   = note: unset `-Zsanitizer-cfi-normalize-integers` in this crate is incompatible with `-Zsanitizer-cfi-normalize-integers=` in dependency `kcfi_normalize_ints`
+   = help: set `-Zsanitizer-cfi-normalize-integers=` in this crate or unset `-Zsanitizer-cfi-normalize-integers` in `kcfi_normalize_ints`
+   = help: if you are sure this will not cause problems, you may use `-Cunsafe-allow-abi-mismatch=sanitizer-cfi-normalize-integers` to silence this error
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/target_modifiers/sanitizer-kcfi-normalize-ints.wrong_sanitizer.stderr b/tests/ui/target_modifiers/sanitizer-kcfi-normalize-ints.wrong_sanitizer.stderr
new file mode 100644
index 0000000000000..5b949c87350b9
--- /dev/null
+++ b/tests/ui/target_modifiers/sanitizer-kcfi-normalize-ints.wrong_sanitizer.stderr
@@ -0,0 +1,13 @@
+error: mixing `-Zsanitizer` will cause an ABI mismatch in crate `sanitizer_kcfi_normalize_ints`
+  --> $DIR/sanitizer-kcfi-normalize-ints.rs:12:1
+   |
+LL | #![feature(no_core)]
+   | ^
+   |
+   = help: the `-Zsanitizer` flag modifies the ABI so Rust crates compiled with different values of this flag cannot be used together safely
+   = note: unset `-Zsanitizer` in this crate is incompatible with `-Zsanitizer=kcfi` in dependency `kcfi_normalize_ints`
+   = help: set `-Zsanitizer=kcfi` in this crate or unset `-Zsanitizer` in `kcfi_normalize_ints`
+   = help: if you are sure this will not cause problems, you may use `-Cunsafe-allow-abi-mismatch=sanitizer` to silence this error
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/target_modifiers/sanitizers-good-for-inconsistency.rs b/tests/ui/target_modifiers/sanitizers-good-for-inconsistency.rs
new file mode 100644
index 0000000000000..abda7be9e4057
--- /dev/null
+++ b/tests/ui/target_modifiers/sanitizers-good-for-inconsistency.rs
@@ -0,0 +1,19 @@
+// AddressSanitizer, LeakSanitizer are good to be inconsistent (they are not a target modifiers)
+
+//@ revisions: wrong_address_san wrong_leak_san
+
+//@[wrong_address_san] needs-sanitizer-address
+//@[wrong_leak_san] needs-sanitizer-leak
+
+//@ aux-build:no-sanitizers.rs
+//@ compile-flags: -Cpanic=abort -C target-feature=-crt-static
+
+//@[wrong_address_san] compile-flags: -Zsanitizer=address
+//@[wrong_leak_san] compile-flags: -Zsanitizer=leak
+//@ check-pass
+
+#![feature(no_core)]
+#![crate_type = "rlib"]
+#![no_core]
+
+extern crate no_sanitizers;
diff --git a/tests/ui/target_modifiers/sanitizers-safestack-and-kcfi.missed_both.stderr b/tests/ui/target_modifiers/sanitizers-safestack-and-kcfi.missed_both.stderr
new file mode 100644
index 0000000000000..440a91c7707f8
--- /dev/null
+++ b/tests/ui/target_modifiers/sanitizers-safestack-and-kcfi.missed_both.stderr
@@ -0,0 +1,13 @@
+error: mixing `-Zsanitizer` will cause an ABI mismatch in crate `sanitizers_safestack_and_kcfi`
+  --> $DIR/sanitizers-safestack-and-kcfi.rs:16:1
+   |
+LL | #![feature(no_core)]
+   | ^
+   |
+   = help: the `-Zsanitizer` flag modifies the ABI so Rust crates compiled with different values of this flag cannot be used together safely
+   = note: unset `-Zsanitizer` in this crate is incompatible with `-Zsanitizer=safestack,kcfi` in dependency `safestack_and_kcfi`
+   = help: set `-Zsanitizer=safestack,kcfi` in this crate or unset `-Zsanitizer` in `safestack_and_kcfi`
+   = help: if you are sure this will not cause problems, you may use `-Cunsafe-allow-abi-mismatch=sanitizer` to silence this error
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/target_modifiers/sanitizers-safestack-and-kcfi.missed_kcfi.stderr b/tests/ui/target_modifiers/sanitizers-safestack-and-kcfi.missed_kcfi.stderr
new file mode 100644
index 0000000000000..6cdd7facc3781
--- /dev/null
+++ b/tests/ui/target_modifiers/sanitizers-safestack-and-kcfi.missed_kcfi.stderr
@@ -0,0 +1,13 @@
+error: mixing `-Zsanitizer` will cause an ABI mismatch in crate `sanitizers_safestack_and_kcfi`
+  --> $DIR/sanitizers-safestack-and-kcfi.rs:16:1
+   |
+LL | #![feature(no_core)]
+   | ^
+   |
+   = help: the `-Zsanitizer` flag modifies the ABI so Rust crates compiled with different values of this flag cannot be used together safely
+   = note: `-Zsanitizer=safestack` in this crate is incompatible with `-Zsanitizer=safestack,kcfi` in dependency `safestack_and_kcfi`
+   = help: set `-Zsanitizer=safestack,kcfi` in this crate or `-Zsanitizer=safestack` in `safestack_and_kcfi`
+   = help: if you are sure this will not cause problems, you may use `-Cunsafe-allow-abi-mismatch=sanitizer` to silence this error
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/target_modifiers/sanitizers-safestack-and-kcfi.missed_safestack.stderr b/tests/ui/target_modifiers/sanitizers-safestack-and-kcfi.missed_safestack.stderr
new file mode 100644
index 0000000000000..ecfbcace39fe5
--- /dev/null
+++ b/tests/ui/target_modifiers/sanitizers-safestack-and-kcfi.missed_safestack.stderr
@@ -0,0 +1,13 @@
+error: mixing `-Zsanitizer` will cause an ABI mismatch in crate `sanitizers_safestack_and_kcfi`
+  --> $DIR/sanitizers-safestack-and-kcfi.rs:16:1
+   |
+LL | #![feature(no_core)]
+   | ^
+   |
+   = help: the `-Zsanitizer` flag modifies the ABI so Rust crates compiled with different values of this flag cannot be used together safely
+   = note: `-Zsanitizer=kcfi` in this crate is incompatible with `-Zsanitizer=safestack,kcfi` in dependency `safestack_and_kcfi`
+   = help: set `-Zsanitizer=safestack,kcfi` in this crate or `-Zsanitizer=kcfi` in `safestack_and_kcfi`
+   = help: if you are sure this will not cause problems, you may use `-Cunsafe-allow-abi-mismatch=sanitizer` to silence this error
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/target_modifiers/sanitizers-safestack-and-kcfi.rs b/tests/ui/target_modifiers/sanitizers-safestack-and-kcfi.rs
new file mode 100644
index 0000000000000..6c3ceb7e91008
--- /dev/null
+++ b/tests/ui/target_modifiers/sanitizers-safestack-and-kcfi.rs
@@ -0,0 +1,23 @@
+//@ needs-sanitizer-kcfi
+//@ needs-sanitizer-safestack
+
+//@ aux-build:safestack-and-kcfi.rs
+//@ compile-flags: -Cpanic=abort
+
+//@ revisions: good good_reverted missed_safestack missed_kcfi missed_both
+//@[good] compile-flags: -Zsanitizer=safestack,kcfi
+//@[good_reverted] compile-flags: -Zsanitizer=kcfi,safestack
+//@[missed_safestack] compile-flags: -Zsanitizer=kcfi
+//@[missed_kcfi] compile-flags: -Zsanitizer=safestack
+// [missed_both] no additional compile-flags:
+//@[good] check-pass
+//@[good_reverted] check-pass
+
+#![feature(no_core)]
+//[missed_safestack]~^ ERROR mixing `-Zsanitizer` will cause an ABI mismatch in crate `sanitizers_safestack_and_kcfi`
+//[missed_kcfi]~^^ ERROR mixing `-Zsanitizer` will cause an ABI mismatch in crate `sanitizers_safestack_and_kcfi`
+//[missed_both]~^^^ ERROR mixing `-Zsanitizer` will cause an ABI mismatch in crate `sanitizers_safestack_and_kcfi`
+#![crate_type = "rlib"]
+#![no_core]
+
+extern crate safestack_and_kcfi;

From b65a177b63237398dc3f49cb5598b16bb9318136 Mon Sep 17 00:00:00 2001
From: WANG Rui <wangrui@loongson.cn>
Date: Thu, 21 Aug 2025 14:15:08 +0800
Subject: [PATCH 0147/1889] Fix LoongArch C function ABI when passing/returning
 structs containing floats

---
 .../rustc_target/src/callconv/loongarch.rs    | 137 ++++++++++++++----
 .../loongarch-float-struct-abi.rs             | 134 +++++++++++++++++
 tests/codegen-llvm/cast-target-abi.rs         |  52 ++++++-
 .../loongarch-abi/cast-local-large-enough.rs  |  44 ++++++
 4 files changed, 327 insertions(+), 40 deletions(-)
 create mode 100644 tests/assembly-llvm/loongarch-float-struct-abi.rs
 create mode 100644 tests/codegen-llvm/loongarch-abi/cast-local-large-enough.rs

diff --git a/compiler/rustc_target/src/callconv/loongarch.rs b/compiler/rustc_target/src/callconv/loongarch.rs
index d567ad401bb1f..9213d73e24eac 100644
--- a/compiler/rustc_target/src/callconv/loongarch.rs
+++ b/compiler/rustc_target/src/callconv/loongarch.rs
@@ -8,16 +8,16 @@ use crate::spec::HasTargetSpec;
 
 #[derive(Copy, Clone)]
 enum RegPassKind {
-    Float(Reg),
-    Integer(Reg),
+    Float { offset_from_start: Size, ty: Reg },
+    Integer { offset_from_start: Size, ty: Reg },
     Unknown,
 }
 
 #[derive(Copy, Clone)]
 enum FloatConv {
-    FloatPair(Reg, Reg),
+    FloatPair { first_ty: Reg, second_ty_offset_from_start: Size, second_ty: Reg },
     Float(Reg),
-    MixedPair(Reg, Reg),
+    MixedPair { first_ty: Reg, second_ty_offset_from_start: Size, second_ty: Reg },
 }
 
 #[derive(Copy, Clone)]
@@ -37,6 +37,7 @@ fn should_use_fp_conv_helper<'a, Ty, C>(
     flen: u64,
     field1_kind: &mut RegPassKind,
     field2_kind: &mut RegPassKind,
+    offset_from_start: Size,
 ) -> Result<(), CannotUseFpConv>
 where
     Ty: TyAbiInterface<'a, C> + Copy,
@@ -49,16 +50,16 @@ where
                 }
                 match (*field1_kind, *field2_kind) {
                     (RegPassKind::Unknown, _) => {
-                        *field1_kind = RegPassKind::Integer(Reg {
-                            kind: RegKind::Integer,
-                            size: arg_layout.size,
-                        });
+                        *field1_kind = RegPassKind::Integer {
+                            offset_from_start,
+                            ty: Reg { kind: RegKind::Integer, size: arg_layout.size },
+                        };
                     }
-                    (RegPassKind::Float(_), RegPassKind::Unknown) => {
-                        *field2_kind = RegPassKind::Integer(Reg {
-                            kind: RegKind::Integer,
-                            size: arg_layout.size,
-                        });
+                    (RegPassKind::Float { .. }, RegPassKind::Unknown) => {
+                        *field2_kind = RegPassKind::Integer {
+                            offset_from_start,
+                            ty: Reg { kind: RegKind::Integer, size: arg_layout.size },
+                        };
                     }
                     _ => return Err(CannotUseFpConv),
                 }
@@ -69,12 +70,16 @@ where
                 }
                 match (*field1_kind, *field2_kind) {
                     (RegPassKind::Unknown, _) => {
-                        *field1_kind =
-                            RegPassKind::Float(Reg { kind: RegKind::Float, size: arg_layout.size });
+                        *field1_kind = RegPassKind::Float {
+                            offset_from_start,
+                            ty: Reg { kind: RegKind::Float, size: arg_layout.size },
+                        };
                     }
                     (_, RegPassKind::Unknown) => {
-                        *field2_kind =
-                            RegPassKind::Float(Reg { kind: RegKind::Float, size: arg_layout.size });
+                        *field2_kind = RegPassKind::Float {
+                            offset_from_start,
+                            ty: Reg { kind: RegKind::Float, size: arg_layout.size },
+                        };
                     }
                     _ => return Err(CannotUseFpConv),
                 }
@@ -96,13 +101,14 @@ where
                             flen,
                             field1_kind,
                             field2_kind,
+                            offset_from_start,
                         );
                     }
                     return Err(CannotUseFpConv);
                 }
             }
             FieldsShape::Array { count, .. } => {
-                for _ in 0..count {
+                for i in 0..count {
                     let elem_layout = arg_layout.field(cx, 0);
                     should_use_fp_conv_helper(
                         cx,
@@ -111,6 +117,7 @@ where
                         flen,
                         field1_kind,
                         field2_kind,
+                        offset_from_start + elem_layout.size * i,
                     )?;
                 }
             }
@@ -121,7 +128,15 @@ where
                 }
                 for i in arg_layout.fields.index_by_increasing_offset() {
                     let field = arg_layout.field(cx, i);
-                    should_use_fp_conv_helper(cx, &field, xlen, flen, field1_kind, field2_kind)?;
+                    should_use_fp_conv_helper(
+                        cx,
+                        &field,
+                        xlen,
+                        flen,
+                        field1_kind,
+                        field2_kind,
+                        offset_from_start + arg_layout.fields.offset(i),
+                    )?;
                 }
             }
         },
@@ -140,14 +155,52 @@ where
 {
     let mut field1_kind = RegPassKind::Unknown;
     let mut field2_kind = RegPassKind::Unknown;
-    if should_use_fp_conv_helper(cx, arg, xlen, flen, &mut field1_kind, &mut field2_kind).is_err() {
+    if should_use_fp_conv_helper(
+        cx,
+        arg,
+        xlen,
+        flen,
+        &mut field1_kind,
+        &mut field2_kind,
+        Size::ZERO,
+    )
+    .is_err()
+    {
         return None;
     }
     match (field1_kind, field2_kind) {
-        (RegPassKind::Integer(l), RegPassKind::Float(r)) => Some(FloatConv::MixedPair(l, r)),
-        (RegPassKind::Float(l), RegPassKind::Integer(r)) => Some(FloatConv::MixedPair(l, r)),
-        (RegPassKind::Float(l), RegPassKind::Float(r)) => Some(FloatConv::FloatPair(l, r)),
-        (RegPassKind::Float(f), RegPassKind::Unknown) => Some(FloatConv::Float(f)),
+        (
+            RegPassKind::Integer { offset_from_start, .. }
+            | RegPassKind::Float { offset_from_start, .. },
+            _,
+        ) if offset_from_start != Size::ZERO => {
+            panic!("type {:?} has a first field with non-zero offset {offset_from_start:?}", arg.ty)
+        }
+        (
+            RegPassKind::Integer { ty: first_ty, .. },
+            RegPassKind::Float { offset_from_start, ty: second_ty },
+        ) => Some(FloatConv::MixedPair {
+            first_ty,
+            second_ty_offset_from_start: offset_from_start,
+            second_ty,
+        }),
+        (
+            RegPassKind::Float { ty: first_ty, .. },
+            RegPassKind::Integer { offset_from_start, ty: second_ty },
+        ) => Some(FloatConv::MixedPair {
+            first_ty,
+            second_ty_offset_from_start: offset_from_start,
+            second_ty,
+        }),
+        (
+            RegPassKind::Float { ty: first_ty, .. },
+            RegPassKind::Float { offset_from_start, ty: second_ty },
+        ) => Some(FloatConv::FloatPair {
+            first_ty,
+            second_ty_offset_from_start: offset_from_start,
+            second_ty,
+        }),
+        (RegPassKind::Float { ty, .. }, RegPassKind::Unknown) => Some(FloatConv::Float(ty)),
         _ => None,
     }
 }
@@ -165,11 +218,19 @@ where
             FloatConv::Float(f) => {
                 arg.cast_to(f);
             }
-            FloatConv::FloatPair(l, r) => {
-                arg.cast_to(CastTarget::pair(l, r));
+            FloatConv::FloatPair { first_ty, second_ty_offset_from_start, second_ty } => {
+                arg.cast_to(CastTarget::offset_pair(
+                    first_ty,
+                    second_ty_offset_from_start,
+                    second_ty,
+                ));
             }
-            FloatConv::MixedPair(l, r) => {
-                arg.cast_to(CastTarget::pair(l, r));
+            FloatConv::MixedPair { first_ty, second_ty_offset_from_start, second_ty } => {
+                arg.cast_to(CastTarget::offset_pair(
+                    first_ty,
+                    second_ty_offset_from_start,
+                    second_ty,
+                ));
             }
         }
         return false;
@@ -233,15 +294,27 @@ fn classify_arg<'a, Ty, C>(
                 arg.cast_to(f);
                 return;
             }
-            Some(FloatConv::FloatPair(l, r)) if *avail_fprs >= 2 => {
+            Some(FloatConv::FloatPair { first_ty, second_ty_offset_from_start, second_ty })
+                if *avail_fprs >= 2 =>
+            {
                 *avail_fprs -= 2;
-                arg.cast_to(CastTarget::pair(l, r));
+                arg.cast_to(CastTarget::offset_pair(
+                    first_ty,
+                    second_ty_offset_from_start,
+                    second_ty,
+                ));
                 return;
             }
-            Some(FloatConv::MixedPair(l, r)) if *avail_fprs >= 1 && *avail_gprs >= 1 => {
+            Some(FloatConv::MixedPair { first_ty, second_ty_offset_from_start, second_ty })
+                if *avail_fprs >= 1 && *avail_gprs >= 1 =>
+            {
                 *avail_gprs -= 1;
                 *avail_fprs -= 1;
-                arg.cast_to(CastTarget::pair(l, r));
+                arg.cast_to(CastTarget::offset_pair(
+                    first_ty,
+                    second_ty_offset_from_start,
+                    second_ty,
+                ));
                 return;
             }
             _ => (),
diff --git a/tests/assembly-llvm/loongarch-float-struct-abi.rs b/tests/assembly-llvm/loongarch-float-struct-abi.rs
new file mode 100644
index 0000000000000..4991004fc05a8
--- /dev/null
+++ b/tests/assembly-llvm/loongarch-float-struct-abi.rs
@@ -0,0 +1,134 @@
+//@ add-core-stubs
+//@ assembly-output: emit-asm
+//@ compile-flags: -Copt-level=3 --target loongarch64-unknown-linux-gnu
+//@ needs-llvm-components: loongarch
+
+#![feature(no_core, lang_items)]
+#![no_std]
+#![no_core]
+#![crate_type = "lib"]
+
+extern crate minicore;
+use minicore::*;
+
+#[repr(C, align(64))]
+struct Aligned(f64);
+
+#[repr(C)]
+struct Padded(u8, Aligned);
+
+#[repr(C, packed)]
+struct Packed(u8, f32);
+
+impl Copy for Aligned {}
+impl Copy for Padded {}
+impl Copy for Packed {}
+
+extern "C" {
+    fn take_padded(x: Padded);
+    fn get_padded() -> Padded;
+    fn take_packed(x: Packed);
+    fn get_packed() -> Packed;
+}
+
+// CHECK-LABEL: pass_padded
+#[unsafe(no_mangle)]
+extern "C" fn pass_padded(out: &mut Padded, x: Padded) {
+    // CHECK: st.b $a1, $a0, 0
+    // CHECK-NEXT: fst.d $fa0, $a0, 64
+    // CHECK-NEXT: ret
+    *out = x;
+}
+
+// CHECK-LABEL: ret_padded
+#[unsafe(no_mangle)]
+extern "C" fn ret_padded(x: &Padded) -> Padded {
+    // CHECK: fld.d $fa0, $a0, 64
+    // CHECK-NEXT: ld.b $a0, $a0, 0
+    // CHECK-NEXT: ret
+    *x
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn call_padded(x: &Padded) {
+    // CHECK: fld.d $fa0, $a0, 64
+    // CHECK-NEXT: ld.b $a0, $a0, 0
+    // CHECK-NEXT: pcaddu18i $t8, %call36(take_padded)
+    // CHECK-NEXT: jr $t8
+    unsafe {
+        take_padded(*x);
+    }
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn receive_padded(out: &mut Padded) {
+    // CHECK: addi.d $sp, $sp, -16
+    // CHECK-NEXT: .cfi_def_cfa_offset 16
+    // CHECK-NEXT: st.d $ra, $sp, [[#%d,RA_SPILL:]]
+    // CHECK-NEXT: st.d [[TEMP:.*]], $sp, [[#%d,TEMP_SPILL:]]
+    // CHECK-NEXT: .cfi_offset 1, [[#%d,RA_SPILL - 16]]
+    // CHECK-NEXT: .cfi_offset [[#%d,TEMP_NUM:]], [[#%d,TEMP_SPILL - 16]]
+    // CHECK-NEXT: move [[TEMP]], $a0
+    // CHECK-NEXT: pcaddu18i $ra, %call36(get_padded)
+    // CHECK-NEXT: jirl $ra, $ra, 0
+    // CHECK-NEXT: st.b $a0, [[TEMP]], 0
+    // CHECK-NEXT: fst.d $fa0, [[TEMP]], 64
+    // CHECK-NEXT: ld.d [[TEMP]], $sp, [[#%d,TEMP_SPILL]]
+    // CHECK-NEXT: ld.d $ra, $sp, [[#%d,RA_SPILL]]
+    // CHECK: addi.d $sp, $sp, 16
+    // CHECK: ret
+    unsafe {
+        *out = get_padded();
+    }
+}
+
+// CHECK-LABEL: pass_packed
+#[unsafe(no_mangle)]
+extern "C" fn pass_packed(out: &mut Packed, x: Packed) {
+    // CHECK: st.b $a1, $a0, 0
+    // CHECK-NEXT: fst.s $fa0, $a0, 1
+    // CHECK-NEXT: ret
+    *out = x;
+}
+
+// CHECK-LABEL: ret_packed
+#[unsafe(no_mangle)]
+extern "C" fn ret_packed(x: &Packed) -> Packed {
+    // CHECK: fld.s $fa0, $a0, 1
+    // CHECK-NEXT: ld.b $a0, $a0, 0
+    // CHECK-NEXT: ret
+    *x
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn call_packed(x: &Packed) {
+    // CHECK: fld.s $fa0, $a0, 1
+    // CHECK-NEXT: ld.b $a0, $a0, 0
+    // CHECK-NEXT: pcaddu18i $t8, %call36(take_packed)
+    // CHECK-NEXT: jr $t8
+    unsafe {
+        take_packed(*x);
+    }
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn receive_packed(out: &mut Packed) {
+    // CHECK: addi.d $sp, $sp, -16
+    // CHECK-NEXT: .cfi_def_cfa_offset 16
+    // CHECK-NEXT: st.d $ra, $sp, [[#%d,RA_SPILL:]]
+    // CHECK-NEXT: st.d [[TEMP:.*]], $sp, [[#%d,TEMP_SPILL:]]
+    // CHECK-NEXT: .cfi_offset 1, [[#%d,RA_SPILL - 16]]
+    // CHECK-NEXT: .cfi_offset [[#%d,TEMP_NUM:]], [[#%d,TEMP_SPILL - 16]]
+    // CHECK-NEXT: move [[TEMP]], $a0
+    // CHECK-NEXT: pcaddu18i $ra, %call36(get_packed)
+    // CHECK-NEXT: jirl $ra, $ra, 0
+    // CHECK-NEXT: st.b $a0, [[TEMP]], 0
+    // CHECK-NEXT: fst.s $fa0, [[TEMP]], 1
+    // CHECK-NEXT: ld.d [[TEMP]], $sp, [[#%d,TEMP_SPILL]]
+    // CHECK-NEXT: ld.d $ra, $sp, [[#%d,RA_SPILL]]
+    // CHECK: addi.d $sp, $sp, 16
+    // CHECK: ret
+    unsafe {
+        *out = get_packed();
+    }
+}
diff --git a/tests/codegen-llvm/cast-target-abi.rs b/tests/codegen-llvm/cast-target-abi.rs
index 28d3ad5f61c7f..090de00df9367 100644
--- a/tests/codegen-llvm/cast-target-abi.rs
+++ b/tests/codegen-llvm/cast-target-abi.rs
@@ -171,7 +171,15 @@ pub extern "C" fn receives_doubledouble(x: DoubleDouble) {
 
     // CHECK: [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
 
-    // CHECK: store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // aarch64: store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_VALUE_0:%.+]] = extractvalue [[ABI_TYPE]] [[ABI_VALUE:%.+]], 0
+    // loongarch64: [[ABI_VALUE_1:%.+]] = extractvalue [[ABI_TYPE]] [[ABI_VALUE:%.+]], 1
+    // loongarch64: store double [[ABI_VALUE_0]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_ALLOCA_1:%.+]] = getelementptr inbounds i8, ptr [[ABI_ALLOCA]], i64 8
+    // loongarch64: store double [[ABI_VALUE_1]], ptr [[ABI_ALLOCA_1]], align [[ABI_ALIGN]]
+    // powerpc64: store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // sparc64: store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // x86_64: store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
 
     // CHECK: call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 16, i1 false)
 }
@@ -190,7 +198,11 @@ pub extern "C" fn returns_doubledouble() -> DoubleDouble {
     // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
 
     // aarch64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x double\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // loongarch64: [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, double }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_VALUE_0:%.+]] = load double, ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_ALLOCA_1:%.+]] = getelementptr inbounds i8, ptr [[ABI_ALLOCA]], i64 8
+    // loongarch64: [[ABI_VALUE_1:%.+]] = load double, ptr [[ABI_ALLOCA_1]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_VALUE_2:%.+]] = insertvalue [[ABI_TYPE:{ double, double }]] poison, double [[ABI_VALUE_0]], 0
+    // loongarch64: [[ABI_VALUE:%.+]] = insertvalue { double, double } [[ABI_VALUE_2]], double [[ABI_VALUE_1]], 1
     // sparc64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, double }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
     // x86_64:      [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, double }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
 
@@ -269,7 +281,11 @@ pub extern "C" fn receives_doublefloat(x: DoubleFloat) {
     // x86_64:      [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
 
     // aarch64:     store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // loongarch64: store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_VALUE_0:%.+]] = extractvalue { double, float } [[ABI_VALUE]], 0
+    // loongarch64: [[ABI_VALUE_1:%.+]] = extractvalue { double, float } [[ABI_VALUE]], 1
+    // loongarch64: store double [[ABI_VALUE_0]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_ALLOCA_1:%.+]] = getelementptr inbounds i8, ptr [[ABI_ALLOCA]], i64 8
+    // loongarch64: store float [[ABI_VALUE_1]], ptr [[ABI_ALLOCA_1]], align [[ABI_ALIGN]]
     // powerpc64:   store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
     // x86_64:      store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
 
@@ -297,7 +313,11 @@ pub extern "C" fn returns_doublefloat() -> DoubleFloat {
     // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
 
     // aarch64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // loongarch64: [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, float }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_VALUE_0:%.+]] = load double, ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_ALLOCA_1:%.+]] = getelementptr inbounds i8, ptr [[ABI_ALLOCA]], i64 8
+    // loongarch64: [[ABI_VALUE_1:%.+]] = load float, ptr [[ABI_ALLOCA_1]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_VALUE_2:%.+]] = insertvalue [[ABI_TYPE:{ double, float }]] poison, double [[ABI_VALUE_0]], 0
+    // loongarch64: [[ABI_VALUE:%.+]] = insertvalue { double, float } [[ABI_VALUE_2]], float [[ABI_VALUE_1]], 1
     // x86_64:      [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, double }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
 
     // aarch64:     ret [[ABI_TYPE]] [[ABI_VALUE]]
@@ -429,7 +449,11 @@ pub fn call_doubledouble() {
     // CHECK: call void @llvm.memcpy.{{.+}}(ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], i64 16, i1 false)
 
     // aarch64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x double\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // loongarch64: [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, double }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_VALUE_0:%.+]] = load double, ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_ALLOCA_1:%.+]] = getelementptr inbounds i8, ptr [[ABI_ALLOCA]], i64 8
+    // loongarch64: [[ABI_VALUE_1:%.+]] = load double, ptr [[ABI_ALLOCA_1]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_VALUE_2:%.+]] = insertvalue [[ABI_TYPE:{ double, double }]] poison, double [[ABI_VALUE_0]], 0
+    // loongarch64: [[ABI_VALUE:%.+]] = insertvalue { double, double } [[ABI_VALUE_2]], double [[ABI_VALUE_1]], 1
     // powerpc64:   [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
     // sparc64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, double }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
     // x86_64:      [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, double }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
@@ -465,7 +489,11 @@ pub fn return_doubledouble() -> DoubleDouble {
     // x86_64:      [[ABI_VALUE:%.+]] = call [[ABI_TYPE:{ double, double }]] @returns_doubledouble()
 
     // aarch64:     store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // loongarch64: store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_VALUE_0:%.+]] = extractvalue { double, double } [[ABI_VALUE]], 0
+    // loongarch64: [[ABI_VALUE_1:%.+]] = extractvalue { double, double } [[ABI_VALUE]], 1
+    // loongarch64: store double [[ABI_VALUE_0]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_ALLOCA_1:%.+]] = getelementptr inbounds i8, ptr [[ABI_ALLOCA]], i64 8
+    // loongarch64: store double [[ABI_VALUE_1]], ptr [[ABI_ALLOCA_1]], align [[ABI_ALIGN]]
     // sparc64:     store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
     // x86_64:      store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
 
@@ -500,7 +528,11 @@ pub fn call_doublefloat() {
     // x86_64:      call void @llvm.memcpy.{{.+}}(ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], i64 16, i1 false)
 
     // aarch64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // loongarch64: [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, float }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_VALUE_0:%.+]] = load double, ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_ALLOCA_1:%.+]] = getelementptr inbounds i8, ptr [[ABI_ALLOCA]], i64 8
+    // loongarch64: [[ABI_VALUE_1:%.+]] = load float, ptr [[ABI_ALLOCA_1]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_VALUE_2:%.+]] = insertvalue [[ABI_TYPE:{ double, float }]] poison, double [[ABI_VALUE_0]], 0
+    // loongarch64: [[ABI_VALUE:%.+]] = insertvalue { double, float } [[ABI_VALUE_2]], float [[ABI_VALUE_1]], 1
     // powerpc64:   [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
     // x86_64:      [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, double }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
 
@@ -540,7 +572,11 @@ pub fn return_doublefloat() -> DoubleFloat {
     // x86_64:      [[ABI_VALUE:%.+]] = call [[ABI_TYPE:{ double, double }]] @returns_doublefloat()
 
     // aarch64:     store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // loongarch64: store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_VALUE_0:%.+]] = extractvalue { double, float } [[ABI_VALUE]], 0
+    // loongarch64: [[ABI_VALUE_1:%.+]] = extractvalue { double, float } [[ABI_VALUE]], 1
+    // loongarch64: store double [[ABI_VALUE_0]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_ALLOCA_1:%.+]] = getelementptr inbounds i8, ptr [[ABI_ALLOCA]], i64 8
+    // loongarch64: store float [[ABI_VALUE_1]], ptr [[ABI_ALLOCA_1]], align [[ABI_ALIGN]]
     // x86_64:      store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
 
     // aarch64:     call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 16, i1 false)
diff --git a/tests/codegen-llvm/loongarch-abi/cast-local-large-enough.rs b/tests/codegen-llvm/loongarch-abi/cast-local-large-enough.rs
new file mode 100644
index 0000000000000..e5a0e4cd3a2c4
--- /dev/null
+++ b/tests/codegen-llvm/loongarch-abi/cast-local-large-enough.rs
@@ -0,0 +1,44 @@
+//@ add-core-stubs
+//@ compile-flags: -Copt-level=0 -Cdebuginfo=0 --target loongarch64-unknown-linux-gnu
+//@ needs-llvm-components: loongarch
+
+#![feature(no_core, lang_items)]
+#![no_std]
+#![no_core]
+#![crate_type = "lib"]
+
+extern crate minicore;
+use minicore::*;
+
+#[repr(C, align(64))]
+struct Aligned(f64);
+
+#[repr(C, align(64))]
+struct AlignedPair(f32, f64);
+
+impl Copy for Aligned {}
+impl Copy for AlignedPair {}
+
+// CHECK-LABEL: define double @read_aligned
+#[unsafe(no_mangle)]
+pub extern "C" fn read_aligned(x: &Aligned) -> Aligned {
+    // CHECK: %[[TEMP:.*]] = alloca [64 x i8], align 64
+    // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 64 %[[TEMP]], ptr align 64 %[[PTR:.*]], i64 64, i1 false)
+    // CHECK-NEXT: %[[RES:.*]] = load double, ptr %[[TEMP]], align 64
+    // CHECK-NEXT: ret double %[[RES]]
+    *x
+}
+
+// CHECK-LABEL: define { float, double } @read_aligned_pair
+#[unsafe(no_mangle)]
+pub extern "C" fn read_aligned_pair(x: &AlignedPair) -> AlignedPair {
+    // CHECK: %[[TEMP:.*]] = alloca [64 x i8], align 64
+    // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 64 %[[TEMP]], ptr align 64 %[[PTR:.*]], i64 64, i1 false)
+    // CHECK-NEXT: %[[FIRST:.*]] = load float, ptr %[[TEMP]], align 64
+    // CHECK-NEXT: %[[SECOND_PTR:.*]] = getelementptr inbounds i8, ptr %[[TEMP]], i64 8
+    // CHECK-NEXT: %[[SECOND:.*]] = load double, ptr %[[SECOND_PTR]], align 8
+    // CHECK-NEXT: %[[RES1:.*]] = insertvalue { float, double } poison, float %[[FIRST]], 0
+    // CHECK-NEXT: %[[RES2:.*]] = insertvalue { float, double } %[[RES1]], double %[[SECOND]], 1
+    // CHECK-NEXT: ret { float, double } %[[RES2]]
+    *x
+}

From f702219ba61d94a50ecb581a4e0ab51dc459e99e Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 21 Aug 2025 16:12:43 +0200
Subject: [PATCH 0148/1889] update rustc-build-sysroot

---
 src/tools/miri/cargo-miri/Cargo.lock | 4 ++--
 src/tools/miri/cargo-miri/Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/tools/miri/cargo-miri/Cargo.lock b/src/tools/miri/cargo-miri/Cargo.lock
index b3f5dafab6437..ea9c04a3cb515 100644
--- a/src/tools/miri/cargo-miri/Cargo.lock
+++ b/src/tools/miri/cargo-miri/Cargo.lock
@@ -429,9 +429,9 @@ dependencies = [
 
 [[package]]
 name = "rustc-build-sysroot"
-version = "0.5.9"
+version = "0.5.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdb13874a0e55baf4ac3d49d38206aecb31a55b75d6c4d04fd850b53942c8cc8"
+checksum = "dd41ead66a69880951b2f7df3139db401d44451b4da123344d27eaa791b89c95"
 dependencies = [
  "anyhow",
  "rustc_version",
diff --git a/src/tools/miri/cargo-miri/Cargo.toml b/src/tools/miri/cargo-miri/Cargo.toml
index 77cb1df8e747f..64b56ea114ecf 100644
--- a/src/tools/miri/cargo-miri/Cargo.toml
+++ b/src/tools/miri/cargo-miri/Cargo.toml
@@ -18,7 +18,7 @@ directories = "6"
 rustc_version = "0.4"
 serde_json = "1.0.40"
 cargo_metadata = "0.21"
-rustc-build-sysroot = "0.5.8"
+rustc-build-sysroot = "0.5.10"
 
 # Enable some feature flags that dev-dependencies need but dependencies
 # do not.  This makes `./miri install` after `./miri build` faster.

From 0a5383c35a56886a6638832862132eafb288f94b Mon Sep 17 00:00:00 2001
From: Daniel Paoliello <danpao@microsoft.com>
Date: Wed, 20 Aug 2025 14:39:50 -0700
Subject: [PATCH 0149/1889] Promote aarch64-pc-windows-msvc to Tier 1

---
 .../rustc_target/src/spec/targets/aarch64_pc_windows_msvc.rs | 2 +-
 src/bootstrap/src/core/build_steps/llvm.rs                   | 2 +-
 src/doc/rustc/src/platform-support.md                        | 2 +-
 src/doc/rustc/src/platform-support/windows-msvc.md           | 5 +----
 4 files changed, 4 insertions(+), 7 deletions(-)

diff --git a/compiler/rustc_target/src/spec/targets/aarch64_pc_windows_msvc.rs b/compiler/rustc_target/src/spec/targets/aarch64_pc_windows_msvc.rs
index f1b6fa123deb4..cd55576ef8167 100644
--- a/compiler/rustc_target/src/spec/targets/aarch64_pc_windows_msvc.rs
+++ b/compiler/rustc_target/src/spec/targets/aarch64_pc_windows_msvc.rs
@@ -15,7 +15,7 @@ pub(crate) fn target() -> Target {
         llvm_target: "aarch64-pc-windows-msvc".into(),
         metadata: TargetMetadata {
             description: Some("ARM64 Windows MSVC".into()),
-            tier: Some(2),
+            tier: Some(1),
             host_tools: Some(true),
             std: Some(true),
         },
diff --git a/src/bootstrap/src/core/build_steps/llvm.rs b/src/bootstrap/src/core/build_steps/llvm.rs
index 260108292e031..303b185919e83 100644
--- a/src/bootstrap/src/core/build_steps/llvm.rs
+++ b/src/bootstrap/src/core/build_steps/llvm.rs
@@ -205,6 +205,7 @@ pub(crate) fn is_ci_llvm_available_for_target(
         // tier 1
         ("aarch64-unknown-linux-gnu", false),
         ("aarch64-apple-darwin", false),
+        ("aarch64-pc-windows-msvc", false),
         ("i686-pc-windows-gnu", false),
         ("i686-pc-windows-msvc", false),
         ("i686-unknown-linux-gnu", false),
@@ -213,7 +214,6 @@ pub(crate) fn is_ci_llvm_available_for_target(
         ("x86_64-pc-windows-gnu", true),
         ("x86_64-pc-windows-msvc", true),
         // tier 2 with host tools
-        ("aarch64-pc-windows-msvc", false),
         ("aarch64-unknown-linux-musl", false),
         ("arm-unknown-linux-gnueabi", false),
         ("arm-unknown-linux-gnueabihf", false),
diff --git a/src/doc/rustc/src/platform-support.md b/src/doc/rustc/src/platform-support.md
index c039517a97039..13f03ac7c4200 100644
--- a/src/doc/rustc/src/platform-support.md
+++ b/src/doc/rustc/src/platform-support.md
@@ -33,6 +33,7 @@ All tier 1 targets with host tools support the full standard library.
 target | notes
 -------|-------
 [`aarch64-apple-darwin`](platform-support/apple-darwin.md) | ARM64 macOS (11.0+, Big Sur+)
+[`aarch64-pc-windows-msvc`](platform-support/windows-msvc.md) | ARM64 Windows MSVC
 `aarch64-unknown-linux-gnu` | ARM64 Linux (kernel 4.1+, glibc 2.17+)
 [`i686-pc-windows-msvc`](platform-support/windows-msvc.md) | 32-bit MSVC (Windows 10+, Windows Server 2016+, Pentium 4) [^x86_32-floats-return-ABI] [^win32-msvc-alignment]
 `i686-unknown-linux-gnu` | 32-bit Linux (kernel 3.2+, glibc 2.17+, Pentium 4) [^x86_32-floats-return-ABI]
@@ -88,7 +89,6 @@ so Rustup may install the documentation for a similar tier 1 target instead.
 target | notes
 -------|-------
 [`aarch64-pc-windows-gnullvm`](platform-support/windows-gnullvm.md) | ARM64 MinGW (Windows 10+), LLVM ABI
-[`aarch64-pc-windows-msvc`](platform-support/windows-msvc.md) | ARM64 Windows MSVC
 [`aarch64-unknown-linux-musl`](platform-support/aarch64-unknown-linux-musl.md) | ARM64 Linux with musl 1.2.3
 [`aarch64-unknown-linux-ohos`](platform-support/openharmony.md) | ARM64 OpenHarmony
 `arm-unknown-linux-gnueabi` | Armv6 Linux (kernel 3.2+, glibc 2.17)
diff --git a/src/doc/rustc/src/platform-support/windows-msvc.md b/src/doc/rustc/src/platform-support/windows-msvc.md
index 71dc4ddc2e65c..826c75b79c572 100644
--- a/src/doc/rustc/src/platform-support/windows-msvc.md
+++ b/src/doc/rustc/src/platform-support/windows-msvc.md
@@ -4,13 +4,10 @@ Windows MSVC targets.
 
 **Tier 1 with host tools:**
 
+- `aarch64-pc-windows-msvc`: Windows on ARM64.
 - `i686-pc-windows-msvc`: Windows on 32-bit x86.
 - `x86_64-pc-windows-msvc`: Windows on 64-bit x86.
 
-**Tier 2 with host tools:**
-
-- `aarch64-pc-windows-msvc`: Windows on ARM64.
-
 ## Target maintainers
 
 [@ChrisDenton](https://github.com/ChrisDenton)

From 5c3f317187c86fe06cd40a81b7072323a2f8ec55 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 21 Aug 2025 21:20:28 +0200
Subject: [PATCH 0150/1889] CI: also test on powerpc

---
 src/tools/miri/.github/workflows/ci.yml | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/tools/miri/.github/workflows/ci.yml b/src/tools/miri/.github/workflows/ci.yml
index 7d79c384f85a3..c0fed96d4e6e3 100644
--- a/src/tools/miri/.github/workflows/ci.yml
+++ b/src/tools/miri/.github/workflows/ci.yml
@@ -41,6 +41,11 @@ jobs:
             multiarch: s390x
             gcc_cross: s390x-linux-gnu
             qemu: true
+          - host_target: powerpc64le-unknown-linux-gnu
+            os: ubuntu-latest
+            multiarch: ppc64el
+            gcc_cross: powerpc64le-linux-gnu
+            qemu: true
           - host_target: aarch64-apple-darwin
             os: macos-latest
           - host_target: i686-pc-windows-msvc

From b5e3230f8f8f66de3f5db05a28ac496fa4a05ad4 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Thu, 21 Aug 2025 22:40:58 +0300
Subject: [PATCH 0151/1889] Remove unnecessary `salsa::attach()` calls

---
 src/tools/rust-analyzer/crates/ide/src/lib.rs | 20 +++++++------------
 1 file changed, 7 insertions(+), 13 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide/src/lib.rs b/src/tools/rust-analyzer/crates/ide/src/lib.rs
index 4b93535c89438..cddf5f04f2442 100644
--- a/src/tools/rust-analyzer/crates/ide/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/lib.rs
@@ -461,9 +461,7 @@ impl Analysis {
         hasher: impl Fn(&InlayHint) -> u64 + Send + UnwindSafe,
     ) -> Cancellable<Option<InlayHint>> {
         self.with_db(|db| {
-            salsa::attach(db, || {
-                inlay_hints::inlay_hints_resolve(db, file_id, resolve_range, hash, config, hasher)
-            })
+            inlay_hints::inlay_hints_resolve(db, file_id, resolve_range, hash, config, hasher)
         })
     }
 
@@ -533,9 +531,7 @@ impl Analysis {
         let search_scope = AssertUnwindSafe(search_scope);
         self.with_db(|db| {
             let _ = &search_scope;
-            salsa::attach(db, || {
-                references::find_all_refs(&Semantics::new(db), position, search_scope.0)
-            })
+            references::find_all_refs(&Semantics::new(db), position, search_scope.0)
         })
     }
 
@@ -545,7 +541,7 @@ impl Analysis {
         config: &HoverConfig,
         range: FileRange,
     ) -> Cancellable<Option<RangeInfo<HoverResult>>> {
-        self.with_db(|db| salsa::attach(db, || hover::hover(db, range, config)))
+        self.with_db(|db| hover::hover(db, range, config))
     }
 
     /// Returns moniker of symbol at position.
@@ -553,7 +549,7 @@ impl Analysis {
         &self,
         position: FilePosition,
     ) -> Cancellable<Option<RangeInfo<Vec<moniker::MonikerResult>>>> {
-        self.with_db(|db| salsa::attach(db, || moniker::moniker(db, position)))
+        self.with_db(|db| moniker::moniker(db, position))
     }
 
     /// Returns URL(s) for the documentation of the symbol under the cursor.
@@ -581,7 +577,7 @@ impl Analysis {
         &self,
         position: FilePosition,
     ) -> Cancellable<Option<RangeInfo<Vec<NavigationTarget>>>> {
-        self.with_db(|db| salsa::attach(db, || call_hierarchy::call_hierarchy(db, position)))
+        self.with_db(|db| call_hierarchy::call_hierarchy(db, position))
     }
 
     /// Computes incoming calls for the given file position.
@@ -649,7 +645,7 @@ impl Analysis {
 
     /// Returns the set of possible targets to run for the current file.
     pub fn runnables(&self, file_id: FileId) -> Cancellable<Vec<Runnable>> {
-        self.with_db(|db| salsa::attach(db, || runnables::runnables(db, file_id)))
+        self.with_db(|db| runnables::runnables(db, file_id))
     }
 
     /// Returns the set of tests for the given file position.
@@ -672,9 +668,7 @@ impl Analysis {
         position: FilePosition,
     ) -> Cancellable<Option<Vec<HighlightedRange>>> {
         self.with_db(|db| {
-            salsa::attach(db, || {
-                highlight_related::highlight_related(&Semantics::new(db), config, position)
-            })
+            highlight_related::highlight_related(&Semantics::new(db), config, position)
         })
     }
 

From f0fd9cdffd72659ec6308fa92e81dbb895e18e3e Mon Sep 17 00:00:00 2001
From: Jeremy Smart <jeremy3141592@gmail.com>
Date: Thu, 21 Aug 2025 16:21:28 -0400
Subject: [PATCH 0152/1889] implement Extend<{Group, Literal, Punct, Ident}>
 for TokenStream

---
 library/proc_macro/src/lib.rs | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/library/proc_macro/src/lib.rs b/library/proc_macro/src/lib.rs
index 162b4fdcc8ae2..8178af15b7393 100644
--- a/library/proc_macro/src/lib.rs
+++ b/library/proc_macro/src/lib.rs
@@ -377,6 +377,21 @@ impl Extend<TokenStream> for TokenStream {
     }
 }
 
+macro_rules! extend_items {
+    ($($item:ident)*) => {
+        $(
+            #[stable(feature = "token_stream_extend_tt_items", since = "CURRENT_RUSTC_VERSION")]
+            impl Extend<$item> for TokenStream {
+                fn extend<T: IntoIterator<Item = $item>>(&mut self, iter: T) {
+                    self.extend(iter.into_iter().map(|i| TokenTree::$item(i)));
+                }
+            }
+        )*
+    };
+}
+
+extend_items!(Group Literal Punct Ident);
+
 /// Public implementation details for the `TokenStream` type, such as iterators.
 #[stable(feature = "proc_macro_lib2", since = "1.29.0")]
 pub mod token_stream {

From 99576aa3f7f6148480608fb62fa10a38cd64f1fd Mon Sep 17 00:00:00 2001
From: Shoyu Vanilla <modulo641@gmail.com>
Date: Fri, 22 Aug 2025 05:24:33 +0900
Subject: [PATCH 0153/1889] fix: Infinite recursion while lowering assoc type
 bounds from supertraits

---
 .../crates/hir-ty/src/lower_nextsolver.rs     |  6 ++-
 .../crates/hir-ty/src/tests/regression.rs     | 53 +++++++++++++++++++
 2 files changed, 58 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
index ce953fdcb8298..d87181f545d88 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
@@ -1756,7 +1756,11 @@ fn named_associated_type_shorthand_candidates<'db, R>(
                 db,
                 GenericDefId::TraitId(trait_def_id),
                 PredicateFilter::SelfTrait,
-                |pred| pred == GenericDefId::TraitId(trait_def_id),
+                // We are likely in the midst of lowering generic predicates of `def`.
+                // So, if we allow `pred == def` we might fall into an infinite recursion.
+                // Actually, we have already checked for the case `pred == def` above as we started
+                // with a stack including `trait_id`
+                |pred| pred != def && pred == GenericDefId::TraitId(trait_def_id),
             )
             .0
             .deref()
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
index fd8c641d86eb0..966433369aa88 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
@@ -2439,3 +2439,56 @@ pub fn null_mut<T: PointeeSized + Thin>() -> *mut T {
 "#,
     );
 }
+
+#[test]
+fn issue_20484() {
+    check_no_mismatches(
+        r#"
+struct Eth;
+
+trait FullBlockBody {
+    type Transaction;
+}
+
+impl FullBlockBody for () {
+    type Transaction = ();
+}
+
+trait NodePrimitives {
+    type BlockBody;
+    type SignedTx;
+}
+
+impl NodePrimitives for () {
+    type BlockBody = ();
+    type SignedTx = ();
+}
+
+impl NodePrimitives for Eth {
+    type BlockBody = ();
+    type SignedTx = ();
+}
+
+trait FullNodePrimitives
+where
+    Self: NodePrimitives<BlockBody: FullBlockBody<Transaction = Self::SignedTx>>,
+{
+}
+
+impl<T> FullNodePrimitives for T where
+    T: NodePrimitives<BlockBody: FullBlockBody<Transaction = Self::SignedTx>>,
+{
+}
+
+fn node<N>(_: N)
+where
+    N: FullNodePrimitives,
+{
+}
+
+fn main() {
+    node(Eth);
+}
+"#,
+    );
+}

From 3715fc623a8464d27601309693b826063564bfcd Mon Sep 17 00:00:00 2001
From: Josh Triplett <josh@joshtriplett.org>
Date: Thu, 21 Aug 2025 18:34:59 -0700
Subject: [PATCH 0154/1889] style-guide: Document absence of trailing
 whitespace

---
 src/doc/style-guide/src/README.md | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/doc/style-guide/src/README.md b/src/doc/style-guide/src/README.md
index f42b9cb597843..a20f62d65a59d 100644
--- a/src/doc/style-guide/src/README.md
+++ b/src/doc/style-guide/src/README.md
@@ -112,6 +112,11 @@ fn bar() {}
 fn baz() {}
 ```
 
+### Trailing whitespace
+
+Do not include trailing whitespace on the end of any line. This includes blank
+lines, comment lines, and code lines.
+
 ### Sorting
 
 In various cases, the default Rust style specifies to sort things. If not
@@ -225,8 +230,8 @@ newline after the opening sigil, and a newline before the closing sigil.
 
 Prefer to put a comment on its own line. Where a comment follows code, put a
 single space before it. Where a block comment appears inline, use surrounding
-whitespace as if it were an identifier or keyword. Do not include trailing
-whitespace after a comment or at the end of any line in a multi-line comment.
+whitespace as if it were an identifier or keyword.
+
 Examples:
 
 ```rust

From b20ddc2d3f029bdbade7d86cdcf021a7cb8c3d8b Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Fri, 22 Aug 2025 11:38:19 +0800
Subject: [PATCH 0155/1889] Fix indent for move_guard_to_arm_body

Input:

```rust
fn main() {
    match 92 {
        x $0if true
            && true
            && true =>
        {
            {
                false
            }
        },
        _ => true
    }
}
```

Old output:

```rust
fn main() {
    match 92 {
        x =>
        if true
                    && true
                    && true {
            {
                    {
                        false
                    }
                }
        },
        _ => true
    };
}
```

This PR fixed:

```rust
fn main() {
    match 92 {
        x => if true
            && true
            && true {
            {
                {
                    false
                }
            }
        },
        _ => true
    }
}
```
---
 .../ide-assists/src/handlers/move_guard.rs    | 70 +++++++++++++++----
 1 file changed, 57 insertions(+), 13 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/move_guard.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/move_guard.rs
index 644d1f6cafefc..6b50718424c72 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/move_guard.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/move_guard.rs
@@ -40,28 +40,34 @@ pub(crate) fn move_guard_to_arm_body(acc: &mut Assists, ctx: &AssistContext<'_>)
         return None;
     }
     let space_before_guard = guard.syntax().prev_sibling_or_token();
+    let space_after_arrow = match_arm.fat_arrow_token()?.next_sibling_or_token();
 
-    let guard_condition = guard.condition()?;
+    let guard_condition = guard.condition()?.reset_indent();
     let arm_expr = match_arm.expr()?;
-    let if_expr =
-        make::expr_if(guard_condition, make::block_expr(None, Some(arm_expr.clone())), None)
-            .indent(arm_expr.indent_level());
+    let then_branch = make::block_expr(None, Some(arm_expr.reset_indent().indent(1.into())));
+    let if_expr = make::expr_if(guard_condition, then_branch, None).indent(arm_expr.indent_level());
 
     let target = guard.syntax().text_range();
     acc.add(
         AssistId::refactor_rewrite("move_guard_to_arm_body"),
         "Move guard to arm body",
         target,
-        |edit| {
-            match space_before_guard {
-                Some(element) if element.kind() == WHITESPACE => {
-                    edit.delete(element.text_range());
-                }
-                _ => (),
-            };
+        |builder| {
+            let mut edit = builder.make_editor(match_arm.syntax());
+            if let Some(element) = space_before_guard
+                && element.kind() == WHITESPACE
+            {
+                edit.delete(element);
+            }
+            if let Some(element) = space_after_arrow
+                && element.kind() == WHITESPACE
+            {
+                edit.replace(element, make::tokens::single_space());
+            }
 
-            edit.delete(guard.syntax().text_range());
-            edit.replace_ast(arm_expr, if_expr.into());
+            edit.delete(guard.syntax());
+            edit.replace(arm_expr.syntax(), if_expr.syntax());
+            builder.add_file_edits(ctx.vfs_file_id(), edit);
         },
     )
 }
@@ -298,6 +304,44 @@ fn main() {
         );
     }
 
+    #[test]
+    fn move_multiline_guard_to_arm_body_works() {
+        check_assist(
+            move_guard_to_arm_body,
+            r#"
+fn main() {
+    match 92 {
+        x $0if true
+            && true
+            && true =>
+        {
+            {
+                false
+            }
+        },
+        _ => true
+    }
+}
+"#,
+            r#"
+fn main() {
+    match 92 {
+        x => if true
+            && true
+            && true {
+            {
+                {
+                    false
+                }
+            }
+        },
+        _ => true
+    }
+}
+"#,
+        );
+    }
+
     #[test]
     fn move_guard_to_arm_body_works_complex_match() {
         check_assist(

From 9f15771d16d14490481e53445f4eb7a49442c52e Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Fri, 22 Aug 2025 04:54:12 +0000
Subject: [PATCH 0156/1889] Prepare for merging from rust-lang/rust

This updates the rust-version file to 8e3710ef31a0b2cdf5a1c2f3929b7735d1e28c20.
---
 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 85ce9ed79f431..d0757e58bf909 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-125ff8a788c5d6a66917f499abdc00051afe6886
+8e3710ef31a0b2cdf5a1c2f3929b7735d1e28c20

From cf478a02c74aac664cc2e2cfa7ce91e50be1d3a4 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukas@zed.dev>
Date: Fri, 22 Aug 2025 08:58:48 +0200
Subject: [PATCH 0157/1889] Fix panic in syntax_highlighting

---
 .../crates/ide/src/syntax_highlighting.rs     |  4 +-
 .../ide/src/syntax_highlighting/inject.rs     | 52 ++++++++++---------
 2 files changed, 29 insertions(+), 27 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting.rs b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting.rs
index e3dc3ed3c742a..f98770805a451 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting.rs
@@ -452,10 +452,10 @@ fn traverse(
                 }
                 hl
             }
-            NodeOrToken::Token(token) => {
+            NodeOrToken::Token(token) => salsa::attach(sema.db, || {
                 highlight::token(sema, token, edition, &is_unsafe_node, tt_level > 0)
                     .zip(Some(None))
-            }
+            }),
         };
         if let Some((mut highlight, binding_hash)) = element {
             if is_unlinked && highlight.tag == HlTag::UnresolvedReference {
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/inject.rs b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/inject.rs
index fb33307249a77..7785891169c64 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/inject.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/inject.rs
@@ -5,7 +5,7 @@ use std::mem;
 use either::Either;
 use hir::{EditionedFileId, HirFileId, InFile, Semantics, sym};
 use ide_db::{
-    SymbolKind, active_parameter::ActiveParameter, defs::Definition,
+    SymbolKind, active_parameter::ActiveParameter, base_db::salsa, defs::Definition,
     documentation::docs_with_rangemap, rust_doc::is_rust_fence,
 };
 use syntax::{
@@ -126,32 +126,34 @@ pub(super) fn doc_comment(
 
     // Extract intra-doc links and emit highlights for them.
     if let Some((docs, doc_mapping)) = docs_with_rangemap(sema.db, &attributes) {
-        extract_definitions_from_docs(&docs)
-            .into_iter()
-            .filter_map(|(range, link, ns)| {
-                doc_mapping
-                    .map(range)
-                    .filter(|(mapping, _)| mapping.file_id == src_file_id)
-                    .and_then(|(InFile { value: mapped_range, .. }, attr_id)| {
-                        Some(mapped_range).zip(resolve_doc_path_for_def(
-                            sema.db,
-                            def,
-                            &link,
-                            ns,
-                            attr_id.is_inner_attr(),
-                        ))
+        salsa::attach(sema.db, || {
+            extract_definitions_from_docs(&docs)
+                .into_iter()
+                .filter_map(|(range, link, ns)| {
+                    doc_mapping
+                        .map(range)
+                        .filter(|(mapping, _)| mapping.file_id == src_file_id)
+                        .and_then(|(InFile { value: mapped_range, .. }, attr_id)| {
+                            Some(mapped_range).zip(resolve_doc_path_for_def(
+                                sema.db,
+                                def,
+                                &link,
+                                ns,
+                                attr_id.is_inner_attr(),
+                            ))
+                        })
+                })
+                .for_each(|(range, def)| {
+                    hl.add(HlRange {
+                        range,
+                        highlight: module_def_to_hl_tag(def)
+                            | HlMod::Documentation
+                            | HlMod::Injected
+                            | HlMod::IntraDocLink,
+                        binding_hash: None,
                     })
-            })
-            .for_each(|(range, def)| {
-                hl.add(HlRange {
-                    range,
-                    highlight: module_def_to_hl_tag(def)
-                        | HlMod::Documentation
-                        | HlMod::Injected
-                        | HlMod::IntraDocLink,
-                    binding_hash: None,
                 })
-            });
+        });
     }
 
     // Extract doc-test sources from the docs and calculate highlighting for them.

From 5068317842a770371d6fcbca358fdb237bd30865 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 22 Aug 2025 10:15:57 +0200
Subject: [PATCH 0158/1889] add some ZST reborrow tests

---
 .../pass/both_borrows/basic_aliasing_model.rs | 22 ++++++++++++++++++-
 1 file changed, 21 insertions(+), 1 deletion(-)

diff --git a/src/tools/miri/tests/pass/both_borrows/basic_aliasing_model.rs b/src/tools/miri/tests/pass/both_borrows/basic_aliasing_model.rs
index 6a625e597df18..82976326a8df3 100644
--- a/src/tools/miri/tests/pass/both_borrows/basic_aliasing_model.rs
+++ b/src/tools/miri/tests/pass/both_borrows/basic_aliasing_model.rs
@@ -23,7 +23,8 @@ fn main() {
     not_unpin_not_protected();
     write_does_not_invalidate_all_aliases();
     box_into_raw_allows_interior_mutable_alias();
-    cell_inside_struct()
+    cell_inside_struct();
+    zst();
 }
 
 // Make sure that reading from an `&mut` does, like reborrowing to `&`,
@@ -287,3 +288,22 @@ fn cell_inside_struct() {
     // Writing to `field1`, which is reserved, should also be allowed.
     (*a).field1 = 88;
 }
+
+/// ZST reborrows on various kinds of dangling pointers are valid.
+fn zst() {
+    unsafe {
+        // Integer pointer.
+        let ptr = ptr::without_provenance_mut::<()>(15);
+        let _ref = &mut *ptr;
+
+        // Out-of-bounds pointer.
+        let mut b = Box::new(0u8);
+        let ptr = (&raw mut *b).wrapping_add(15) as *mut ();
+        let _ref = &mut *ptr;
+
+        // Deallocated pointer.
+        let ptr = &raw mut *b as *mut ();
+        drop(b);
+        let _ref = &mut *ptr;
+    }
+}

From 3868f8ad5c2ef77fa823dc17da14ba13c2d508f7 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Fri, 22 Aug 2025 17:06:21 +0800
Subject: [PATCH 0159/1889] fix: convert_integer_literal not on selected

`convert_integer_literal` can only convert the first literal,
it is not reasonable to apply it when selected

Example
---

```rust
fn main() {
    $01+1$0;
}
```

**Assist old outputs**:

```
Convert 1 to 0b1
Convert 1 to 0o1
Convert 1 to 0x1
Replace arithmetic with call to checked_*
Replace arithmetic with call to saturating_*
Replace arithmetic with call to wrapping_*
Extract into variable
Extract into constant
Extract into static
Extract into function
```

**Assist this PR outputs**:

```
Replace arithmetic with call to checked_*
Replace arithmetic with call to saturating_*
Replace arithmetic with call to wrapping_*
Extract into variable
Extract into constant
Extract into static
Extract into function
```
---
 .../ide-assists/src/handlers/convert_integer_literal.rs   | 8 ++++++++
 src/tools/rust-analyzer/crates/ide-assists/src/tests.rs   | 2 --
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_integer_literal.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_integer_literal.rs
index 846f4e9b258ae..bc76ade97f69d 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_integer_literal.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_integer_literal.rs
@@ -14,6 +14,9 @@ use crate::{AssistContext, AssistId, Assists, GroupLabel};
 // const _: i32 = 0b1010;
 // ```
 pub(crate) fn convert_integer_literal(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {
+    if !ctx.has_empty_selection() {
+        return None;
+    }
     let literal = ctx.find_node_at_offset::<ast::Literal>()?;
     let literal = match literal.kind() {
         ast::LiteralKind::IntNumber(it) => it,
@@ -265,4 +268,9 @@ mod tests {
             111111111111111111111111111111111111111111111111111111111111111111111111$0;";
         check_assist_not_applicable(convert_integer_literal, before);
     }
+
+    #[test]
+    fn convert_non_empty_selection_literal() {
+        check_assist_not_applicable(convert_integer_literal, "const _: i32 = $00b1010$0;");
+    }
 }
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/tests.rs b/src/tools/rust-analyzer/crates/ide-assists/src/tests.rs
index f4daabfe915d7..44bf6a4316942 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/tests.rs
@@ -456,7 +456,6 @@ pub fn test_some_range(a: int) -> bool {
     let expected = labels(&assists);
 
     expect![[r#"
-        Convert integer base
         Extract into...
         Replace if let with match
     "#]]
@@ -489,7 +488,6 @@ pub fn test_some_range(a: int) -> bool {
         let expected = labels(&assists);
 
         expect![[r#"
-            Convert integer base
             Extract into...
             Replace if let with match
         "#]]

From 71b79ab46603f542fce1bf125d9429920693abbb Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Fri, 22 Aug 2025 14:57:22 +0200
Subject: [PATCH 0160/1889] Merge commit
 '877967959ae8da9814df4f2614971f4d784bf53f' into clippy-subtree-update

---
 .github/workflows/clippy_dev.yml              |   2 +-
 .github/workflows/clippy_mq.yml               |   8 +-
 .github/workflows/clippy_pr.yml               |   2 +-
 .github/workflows/deploy.yml                  |   4 +-
 .github/workflows/feature_freeze.yml          |   2 +-
 .github/workflows/lintcheck.yml               |   6 +-
 .github/workflows/remark.yml                  |   2 +-
 CONTRIBUTING.md                               |  12 +-
 Cargo.toml                                    |  11 +
 .../continuous_integration/github_actions.md  |   2 +-
 book/src/development/basics.md                |   4 +-
 .../development/common_tools_writing_lints.md |   2 +-
 book/src/lint_configuration.md                |   2 +-
 clippy_config/src/conf.rs                     |   2 +-
 clippy_dev/src/dogfood.rs                     |  49 ++---
 clippy_dev/src/lib.rs                         |   7 +-
 clippy_dev/src/lint.rs                        |  56 ++---
 clippy_dev/src/main.rs                        |  11 +-
 clippy_dev/src/serve.rs                       | 107 ++++++----
 clippy_dev/src/setup/git_hook.rs              |   6 -
 clippy_dev/src/setup/mod.rs                   |  20 --
 clippy_dev/src/setup/toolchain.rs             |  19 +-
 clippy_dev/src/setup/vscode.rs                |   6 -
 clippy_dev/src/utils.rs                       |  62 +++---
 clippy_lints/src/casts/borrow_as_ptr.rs       |   9 +-
 clippy_lints/src/casts/char_lit_as_u8.rs      |  11 +-
 clippy_lints/src/casts/mod.rs                 |   2 +-
 clippy_lints/src/casts/ptr_as_ptr.rs          |   4 +-
 clippy_lints/src/cognitive_complexity.rs      |   2 +-
 clippy_lints/src/collapsible_if.rs            |  22 +-
 clippy_lints/src/declared_lints.rs            |   2 +-
 clippy_lints/src/dereference.rs               |  11 +-
 clippy_lints/src/doc/mod.rs                   |   4 +-
 clippy_lints/src/eta_reduction.rs             |   6 +-
 clippy_lints/src/from_str_radix_10.rs         |   4 +-
 .../duplicate_underscore_argument.rs          |  34 +++
 clippy_lints/src/functions/mod.rs             |  39 +++-
 .../src/functions/renamed_function_params.rs  |  21 +-
 clippy_lints/src/functions/result.rs          |   6 +-
 clippy_lints/src/functions/too_many_lines.rs  |   6 +-
 clippy_lints/src/len_zero.rs                  |  41 ++--
 clippy_lints/src/lib.rs                       |   3 +-
 clippy_lints/src/loops/infinite_loop.rs       |  48 ++++-
 clippy_lints/src/manual_let_else.rs           |   2 +-
 clippy_lints/src/matches/match_bool.rs        |   6 +-
 clippy_lints/src/matches/match_ref_pats.rs    |   5 +
 .../src/matches/match_str_case_mismatch.rs    |   2 +-
 .../src/methods/double_ended_iterator_last.rs |   4 +-
 clippy_lints/src/methods/expect_fun_call.rs   |  75 ++++---
 clippy_lints/src/methods/filter_map.rs        |   4 +-
 clippy_lints/src/methods/filter_next.rs       |  18 +-
 clippy_lints/src/misc_early/mod.rs            |  57 +----
 .../src/mixed_read_write_in_expression.rs     |   2 +-
 clippy_lints/src/needless_bool.rs             |   4 +-
 .../src/needless_borrows_for_generic_args.rs  |   2 +-
 clippy_lints/src/no_effect.rs                 |   3 +-
 clippy_lints/src/non_copy_const.rs            |   2 +-
 clippy_lints/src/non_expressive_names.rs      |   5 +
 clippy_lints/src/only_used_in_recursion.rs    |   2 +-
 .../src/operators/arithmetic_side_effects.rs  |   2 +-
 .../src/operators/numeric_arithmetic.rs       |   2 +-
 clippy_lints/src/pass_by_ref_or_value.rs      |   2 +-
 clippy_lints/src/ptr.rs                       |  61 +++---
 clippy_lints/src/raw_strings.rs               |  10 +-
 clippy_lints/src/redundant_pub_crate.rs       |   3 +-
 clippy_lints/src/reference.rs                 | 141 +++++++------
 clippy_lints/src/swap.rs                      |   4 +-
 clippy_lints/src/transmute/eager_transmute.rs |   8 +-
 clippy_lints/src/transmute/mod.rs             |   2 +-
 .../src/undocumented_unsafe_blocks.rs         | 194 ++++++++++--------
 clippy_lints/src/unnecessary_box_returns.rs   |   2 +-
 clippy_lints/src/unnecessary_semicolon.rs     |   4 +-
 clippy_lints/src/unnested_or_patterns.rs      |   8 +-
 clippy_lints/src/unwrap.rs                    |  72 +++----
 clippy_lints/src/zero_sized_map_values.rs     |   3 +
 .../derive_deserialize_allowing_unknown.rs    |  15 +-
 clippy_test_deps/Cargo.lock                   |   4 +-
 clippy_utils/README.md                        |   2 +-
 clippy_utils/src/ast_utils/mod.rs             |  55 ++---
 clippy_utils/src/check_proc_macro.rs          |   9 +-
 clippy_utils/src/diagnostics.rs               |  15 +-
 clippy_utils/src/hir_utils.rs                 |   2 +-
 clippy_utils/src/lib.rs                       |  17 ++
 clippy_utils/src/msrvs.rs                     |  36 ++--
 clippy_utils/src/ty/mod.rs                    |  12 +-
 rust-toolchain.toml                           |   2 +-
 .../fail/Cargo.stderr                         |  26 +++
 .../fail/Cargo.toml                           |  12 ++
 .../fail/src/main.rs                          |   7 +
 tests/ui-toml/functions_maxlines/test.stderr  |  35 +---
 tests/ui/as_ptr_cast_mut.fixed                |  38 ++++
 tests/ui/as_ptr_cast_mut.rs                   |   4 -
 tests/ui/as_ptr_cast_mut.stderr               |  10 +-
 tests/ui/as_ptr_cast_mut_unfixable.rs         |  16 ++
 tests/ui/as_ptr_cast_mut_unfixable.stderr     |  11 +
 tests/ui/borrow_as_ptr.fixed                  |  12 ++
 tests/ui/borrow_as_ptr.rs                     |  12 ++
 tests/ui/borrow_as_ptr.stderr                 |  14 +-
 ...suggestions.fixed => char_lit_as_u8.fixed} |   0
 tests/ui/char_lit_as_u8.rs                    |   9 +-
 tests/ui/char_lit_as_u8.stderr                |  32 ++-
 tests/ui/char_lit_as_u8_suggestions.rs        |  12 --
 tests/ui/char_lit_as_u8_suggestions.stderr    |  36 ----
 tests/ui/char_lit_as_u8_unfixable.rs          |   8 +
 tests/ui/char_lit_as_u8_unfixable.stderr      |  12 ++
 tests/ui/deref_addrof.fixed                   |  88 ++++++--
 tests/ui/deref_addrof.rs                      |  88 ++++++--
 tests/ui/deref_addrof.stderr                  |  56 ++++-
 tests/ui/doc/doc-fixable.fixed                |   2 +-
 tests/ui/doc/doc-fixable.rs                   |   2 +-
 tests/ui/double_ended_iterator_last.fixed     |  11 +
 tests/ui/double_ended_iterator_last.rs        |  11 +
 tests/ui/double_ended_iterator_last.stderr    |  17 +-
 .../double_ended_iterator_last_unfixable.rs   |  39 ----
 ...ouble_ended_iterator_last_unfixable.stderr |  19 --
 tests/ui/eta.fixed                            |  29 +++
 tests/ui/eta.rs                               |  29 +++
 tests/ui/eta.stderr                           |  96 +++++----
 tests/ui/from_str_radix_10.fixed              |  10 +
 tests/ui/from_str_radix_10.rs                 |  10 +
 tests/ui/from_str_radix_10.stderr             |  14 +-
 tests/ui/functions_maxlines.rs                | 115 ++++++++++-
 tests/ui/functions_maxlines.stderr            |  22 +-
 tests/ui/infinite_loops.rs                    |  71 +++++++
 tests/ui/infinite_loops.stderr                |  24 ++-
 tests/ui/match_bool.fixed                     |  13 ++
 tests/ui/match_bool.rs                        |  13 ++
 tests/ui/match_ref_pats.fixed                 |  36 +++-
 tests/ui/match_ref_pats.rs                    |  36 +++-
 tests/ui/match_ref_pats.stderr                |  10 +-
 tests/ui/ptr_as_ptr.fixed                     |   8 +-
 tests/ui/ptr_as_ptr.rs                        |   6 +-
 tests/ui/ptr_as_ptr.stderr                    |  64 +++---
 tests/ui/similar_names.rs                     |   4 +
 tests/ui/similar_names.stderr                 |   4 +-
 tests/ui/unnecessary_operation.fixed          |  10 +-
 tests/ui/unnecessary_operation.stderr         |  10 +-
 .../unnecessary_semicolon.edition2021.fixed   |   9 +
 .../unnecessary_semicolon.edition2024.fixed   |   9 +
 tests/ui/unnecessary_semicolon.rs             |   9 +
 tests/ui/zero_sized_hashmap_values.rs         |   8 +
 tests/ui/zero_sized_hashmap_values.stderr     |   6 +-
 142 files changed, 1823 insertions(+), 1050 deletions(-)
 create mode 100644 clippy_lints/src/functions/duplicate_underscore_argument.rs
 create mode 100644 tests/ui-cargo/undocumented_unsafe_blocks/fail/Cargo.stderr
 create mode 100644 tests/ui-cargo/undocumented_unsafe_blocks/fail/Cargo.toml
 create mode 100644 tests/ui-cargo/undocumented_unsafe_blocks/fail/src/main.rs
 create mode 100644 tests/ui/as_ptr_cast_mut.fixed
 create mode 100644 tests/ui/as_ptr_cast_mut_unfixable.rs
 create mode 100644 tests/ui/as_ptr_cast_mut_unfixable.stderr
 rename tests/ui/{char_lit_as_u8_suggestions.fixed => char_lit_as_u8.fixed} (100%)
 delete mode 100644 tests/ui/char_lit_as_u8_suggestions.rs
 delete mode 100644 tests/ui/char_lit_as_u8_suggestions.stderr
 create mode 100644 tests/ui/char_lit_as_u8_unfixable.rs
 create mode 100644 tests/ui/char_lit_as_u8_unfixable.stderr
 delete mode 100644 tests/ui/double_ended_iterator_last_unfixable.rs
 delete mode 100644 tests/ui/double_ended_iterator_last_unfixable.stderr

diff --git a/.github/workflows/clippy_dev.yml b/.github/workflows/clippy_dev.yml
index d6534fbaff946..d530eb6c73a37 100644
--- a/.github/workflows/clippy_dev.yml
+++ b/.github/workflows/clippy_dev.yml
@@ -16,7 +16,7 @@ jobs:
     steps:
     # Setup
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v5
       with:
         # Unsetting this would make so that any malicious package could get our Github Token
         persist-credentials: false
diff --git a/.github/workflows/clippy_mq.yml b/.github/workflows/clippy_mq.yml
index 07d5a08304e87..0bcb713593593 100644
--- a/.github/workflows/clippy_mq.yml
+++ b/.github/workflows/clippy_mq.yml
@@ -36,7 +36,7 @@ jobs:
     steps:
     # Setup
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v5
       with:
         persist-credentials: false
 
@@ -96,7 +96,7 @@ jobs:
     steps:
      # Setup
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v5
       with:
         persist-credentials: false
 
@@ -114,7 +114,7 @@ jobs:
     steps:
     # Setup
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v5
       with:
         persist-credentials: false
 
@@ -170,7 +170,7 @@ jobs:
     steps:
     # Setup
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v5
       with:
         persist-credentials: false
 
diff --git a/.github/workflows/clippy_pr.yml b/.github/workflows/clippy_pr.yml
index 880ebd6e5d5c7..d91c638a8fb50 100644
--- a/.github/workflows/clippy_pr.yml
+++ b/.github/workflows/clippy_pr.yml
@@ -24,7 +24,7 @@ jobs:
     steps:
     # Setup
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v5
       with:
         # Unsetting this would make so that any malicious package could get our Github Token
         persist-credentials: false
diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index ede19c11257ee..48c5bd36dbcd8 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -25,13 +25,13 @@ jobs:
     steps:
     # Setup
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v5
       with:
         # Unsetting this would make so that any malicious package could get our Github Token
         persist-credentials: false
 
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v5
       with:
         ref: ${{ env.TARGET_BRANCH }}
         path: 'out'
diff --git a/.github/workflows/feature_freeze.yml b/.github/workflows/feature_freeze.yml
index ec59be3e7f67c..5b139e767007b 100644
--- a/.github/workflows/feature_freeze.yml
+++ b/.github/workflows/feature_freeze.yml
@@ -16,7 +16,7 @@ jobs:
     permissions:
       pull-requests: write
 
-    # Do not in any case add code that runs anything coming from the  the content
+    # Do not in any case add code that runs anything coming from the content
     # of the pull request, as malicious code would be able to access the private
     # GitHub token.
     steps:
diff --git a/.github/workflows/lintcheck.yml b/.github/workflows/lintcheck.yml
index 003d03957399e..390d6a0f74758 100644
--- a/.github/workflows/lintcheck.yml
+++ b/.github/workflows/lintcheck.yml
@@ -24,7 +24,7 @@ jobs:
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v5
       with:
         fetch-depth: 2
         # Unsetting this would make so that any malicious package could get our Github Token
@@ -80,7 +80,7 @@ jobs:
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v5
       with:
         # Unsetting this would make so that any malicious package could get our Github Token
         persist-credentials: false
@@ -113,7 +113,7 @@ jobs:
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v5
       with:
         # Unsetting this would make so that any malicious package could get our Github Token
         persist-credentials: false
diff --git a/.github/workflows/remark.yml b/.github/workflows/remark.yml
index 7e7e26818c094..c9d350ee0b304 100644
--- a/.github/workflows/remark.yml
+++ b/.github/workflows/remark.yml
@@ -11,7 +11,7 @@ jobs:
     steps:
     # Setup
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v5
       with:
         # Unsetting this would make so that any malicious package could get our Github Token
         persist-credentials: false
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 42ed624ec2128..f7f0a1ce2499a 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -17,7 +17,7 @@ All contributors are expected to follow the [Rust Code of Conduct].
   - [High level approach](#high-level-approach)
   - [Finding something to fix/improve](#finding-something-to-fiximprove)
   - [Getting code-completion for rustc internals to work](#getting-code-completion-for-rustc-internals-to-work)
-    - [IntelliJ Rust](#intellij-rust)
+    - [RustRover](#rustrover)
     - [Rust Analyzer](#rust-analyzer)
   - [How Clippy works](#how-clippy-works)
   - [Issue and PR triage](#issue-and-pr-triage)
@@ -92,22 +92,22 @@ an AST expression).
 
 ## Getting code-completion for rustc internals to work
 
-### IntelliJ Rust
-Unfortunately, [`IntelliJ Rust`][IntelliJ_rust_homepage] does not (yet?) understand how Clippy uses compiler-internals
+### RustRover
+Unfortunately, [`RustRover`][RustRover_homepage] does not (yet?) understand how Clippy uses compiler-internals
 using `extern crate` and it also needs to be able to read the source files of the rustc-compiler which are not
 available via a `rustup` component at the time of writing.
 To work around this, you need to have a copy of the [rustc-repo][rustc_repo] available which can be obtained via
 `git clone https://github.com/rust-lang/rust/`.
 Then you can run a `cargo dev` command to automatically make Clippy use the rustc-repo via path-dependencies
-which `IntelliJ Rust` will be able to understand.
+which `RustRover` will be able to understand.
 Run `cargo dev setup intellij --repo-path <repo-path>` where `<repo-path>` is a path to the rustc repo
 you just cloned.
 The command will add path-dependencies pointing towards rustc-crates inside the rustc repo to
-Clippy's `Cargo.toml`s and should allow `IntelliJ Rust` to understand most of the types that Clippy uses.
+Clippy's `Cargo.toml`s and should allow `RustRover` to understand most of the types that Clippy uses.
 Just make sure to remove the dependencies again before finally making a pull request!
 
 [rustc_repo]: https://github.com/rust-lang/rust/
-[IntelliJ_rust_homepage]: https://intellij-rust.github.io/
+[RustRover_homepage]: https://www.jetbrains.com/rust/
 
 ### Rust Analyzer
 For [`rust-analyzer`][ra_homepage] to work correctly make sure that in the `rust-analyzer` configuration you set
diff --git a/Cargo.toml b/Cargo.toml
index daf1c98cdc946..2add525b7e8ae 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -64,3 +64,14 @@ harness = false
 [[test]]
 name = "dogfood"
 harness = false
+
+# quine-mc_cluskey makes up a significant part of the runtime in dogfood
+# due to the number of conditions in the clippy_lints crate
+# and enabling optimizations for that specific dependency helps a bit
+# without increasing total build times.
+[profile.dev.package.quine-mc_cluskey]
+opt-level = 3
+
+[lints.rust.unexpected_cfgs]
+level = "warn"
+check-cfg = ['cfg(bootstrap)']
diff --git a/book/src/continuous_integration/github_actions.md b/book/src/continuous_integration/github_actions.md
index b588c8f0f02c4..62d32446d9202 100644
--- a/book/src/continuous_integration/github_actions.md
+++ b/book/src/continuous_integration/github_actions.md
@@ -15,7 +15,7 @@ jobs:
   clippy_check:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - name: Run Clippy
         run: cargo clippy --all-targets --all-features
 ```
diff --git a/book/src/development/basics.md b/book/src/development/basics.md
index fc405249bcfe8..19f626ab804ee 100644
--- a/book/src/development/basics.md
+++ b/book/src/development/basics.md
@@ -95,7 +95,7 @@ cargo dev new_lint
 cargo dev deprecate
 # automatically formatting all code before each commit
 cargo dev setup git-hook
-# (experimental) Setup Clippy to work with IntelliJ-Rust
+# (experimental) Setup Clippy to work with RustRover
 cargo dev setup intellij
 # runs the `dogfood` tests
 cargo dev dogfood
@@ -103,7 +103,7 @@ cargo dev dogfood
 
 More about [intellij] command usage and reasons.
 
-[intellij]: https://github.com/rust-lang/rust-clippy/blob/master/CONTRIBUTING.md#intellij-rust
+[intellij]: https://github.com/rust-lang/rust-clippy/blob/master/CONTRIBUTING.md#rustrover
 
 ## lintcheck
 
diff --git a/book/src/development/common_tools_writing_lints.md b/book/src/development/common_tools_writing_lints.md
index e23b32039c90b..3bec3ce33af36 100644
--- a/book/src/development/common_tools_writing_lints.md
+++ b/book/src/development/common_tools_writing_lints.md
@@ -141,7 +141,7 @@ impl LateLintPass<'_> for MyStructLint {
             // we are looking for the `DefId` of `Drop` trait in lang items
             .drop_trait()
             // then we use it with our type `ty` by calling `implements_trait` from Clippy's utils
-            .map_or(false, |id| implements_trait(cx, ty, id, &[])) {
+            .is_some_and(|id| implements_trait(cx, ty, id, &[])) {
                 // `expr` implements `Drop` trait
             }
     }
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 7f16f3a981053..05590ff7b1c9b 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -555,7 +555,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:** `["KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "MHz", "GHz", "THz", "AccessKit", "CoAP", "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", "NixOS", "TeX", "LaTeX", "BibTeX", "BibLaTeX", "MinGW", "CamelCase"]`
+**Default Value:** `["KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "MHz", "GHz", "THz", "AccessKit", "CoAP", "CoreFoundation", "CoreGraphics", "CoreText", "DevOps", "Direct2D", "Direct3D", "DirectWrite", "DirectX", "ECMAScript", "GPLv2", "GPLv3", "GitHub", "GitLab", "IPv4", "IPv6", "ClojureScript", "CoffeeScript", "JavaScript", "PostScript", "PureScript", "TypeScript", "PowerPC", "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", "NixOS", "TeX", "LaTeX", "BibTeX", "BibLaTeX", "MinGW", "CamelCase"]`
 
 ---
 **Affected lints:**
diff --git a/clippy_config/src/conf.rs b/clippy_config/src/conf.rs
index 8167d75583eeb..2ad3f2efcdd7a 100644
--- a/clippy_config/src/conf.rs
+++ b/clippy_config/src/conf.rs
@@ -34,7 +34,7 @@ const DEFAULT_DOC_VALID_IDENTS: &[&str] = &[
     "GitHub", "GitLab",
     "IPv4", "IPv6",
     "ClojureScript", "CoffeeScript", "JavaScript", "PostScript", "PureScript", "TypeScript",
-    "WebAssembly",
+    "PowerPC", "WebAssembly",
     "NaN", "NaNs",
     "OAuth", "GraphQL",
     "OCaml",
diff --git a/clippy_dev/src/dogfood.rs b/clippy_dev/src/dogfood.rs
index 7e9d92458d057..d0fca952b9322 100644
--- a/clippy_dev/src/dogfood.rs
+++ b/clippy_dev/src/dogfood.rs
@@ -1,35 +1,28 @@
-use crate::utils::exit_if_err;
-use std::process::Command;
+use crate::utils::{cargo_cmd, run_exit_on_err};
+use itertools::Itertools;
 
 /// # Panics
 ///
 /// Panics if unable to run the dogfood test
 #[allow(clippy::fn_params_excessive_bools)]
 pub fn dogfood(fix: bool, allow_dirty: bool, allow_staged: bool, allow_no_vcs: bool) {
-    let mut cmd = Command::new("cargo");
-
-    cmd.args(["test", "--test", "dogfood"])
-        .args(["--features", "internal"])
-        .args(["--", "dogfood_clippy", "--nocapture"]);
-
-    let mut dogfood_args = Vec::new();
-    if fix {
-        dogfood_args.push("--fix");
-    }
-
-    if allow_dirty {
-        dogfood_args.push("--allow-dirty");
-    }
-
-    if allow_staged {
-        dogfood_args.push("--allow-staged");
-    }
-
-    if allow_no_vcs {
-        dogfood_args.push("--allow-no-vcs");
-    }
-
-    cmd.env("__CLIPPY_DOGFOOD_ARGS", dogfood_args.join(" "));
-
-    exit_if_err(cmd.status());
+    run_exit_on_err(
+        "cargo test",
+        cargo_cmd()
+            .args(["test", "--test", "dogfood"])
+            .args(["--features", "internal"])
+            .args(["--", "dogfood_clippy", "--nocapture"])
+            .env(
+                "__CLIPPY_DOGFOOD_ARGS",
+                [
+                    if fix { "--fix" } else { "" },
+                    if allow_dirty { "--allow-dirty" } else { "" },
+                    if allow_staged { "--allow-staged" } else { "" },
+                    if allow_no_vcs { "--allow-no-vcs" } else { "" },
+                ]
+                .iter()
+                .filter(|x| !x.is_empty())
+                .join(" "),
+            ),
+    );
 }
diff --git a/clippy_dev/src/lib.rs b/clippy_dev/src/lib.rs
index 40aadf4589a77..16f413e0c862f 100644
--- a/clippy_dev/src/lib.rs
+++ b/clippy_dev/src/lib.rs
@@ -15,8 +15,7 @@
 )]
 #![allow(clippy::missing_panics_doc)]
 
-// The `rustc_driver` crate seems to be required in order to use the `rust_lexer` crate.
-#[allow(unused_extern_crates)]
+#[expect(unused_extern_crates, reason = "required to link to rustc crates")]
 extern crate rustc_driver;
 extern crate rustc_lexer;
 extern crate rustc_literal_escaper;
@@ -32,4 +31,6 @@ pub mod serve;
 pub mod setup;
 pub mod sync;
 pub mod update_lints;
-pub mod utils;
+
+mod utils;
+pub use utils::{ClippyInfo, UpdateMode};
diff --git a/clippy_dev/src/lint.rs b/clippy_dev/src/lint.rs
index 0d66f167a386d..2d9f563cdae28 100644
--- a/clippy_dev/src/lint.rs
+++ b/clippy_dev/src/lint.rs
@@ -1,19 +1,18 @@
-use crate::utils::{cargo_clippy_path, exit_if_err};
-use std::process::{self, Command};
+use crate::utils::{ErrAction, cargo_cmd, expect_action, run_exit_on_err};
+use std::process::Command;
 use std::{env, fs};
 
-pub fn run<'a>(path: &str, edition: &str, args: impl Iterator<Item = &'a String>) {
-    let is_file = match fs::metadata(path) {
-        Ok(metadata) => metadata.is_file(),
-        Err(e) => {
-            eprintln!("Failed to read {path}: {e:?}");
-            process::exit(1);
-        },
-    };
+#[cfg(not(windows))]
+static CARGO_CLIPPY_EXE: &str = "cargo-clippy";
+#[cfg(windows)]
+static CARGO_CLIPPY_EXE: &str = "cargo-clippy.exe";
 
+pub fn run<'a>(path: &str, edition: &str, args: impl Iterator<Item = &'a String>) {
+    let is_file = expect_action(fs::metadata(path), ErrAction::Read, path).is_file();
     if is_file {
-        exit_if_err(
-            Command::new(env::var("CARGO").unwrap_or_else(|_| "cargo".into()))
+        run_exit_on_err(
+            "cargo run",
+            cargo_cmd()
                 .args(["run", "--bin", "clippy-driver", "--"])
                 .args(["-L", "./target/debug"])
                 .args(["-Z", "no-codegen"])
@@ -21,24 +20,25 @@ pub fn run<'a>(path: &str, edition: &str, args: impl Iterator<Item = &'a String>
                 .arg(path)
                 .args(args)
                 // Prevent rustc from creating `rustc-ice-*` files the console output is enough.
-                .env("RUSTC_ICE", "0")
-                .status(),
+                .env("RUSTC_ICE", "0"),
         );
     } else {
-        exit_if_err(
-            Command::new(env::var("CARGO").unwrap_or_else(|_| "cargo".into()))
-                .arg("build")
-                .status(),
-        );
-
-        let status = Command::new(cargo_clippy_path())
-            .arg("clippy")
-            .args(args)
-            // Prevent rustc from creating `rustc-ice-*` files the console output is enough.
-            .env("RUSTC_ICE", "0")
-            .current_dir(path)
-            .status();
+        // Ideally this would just be `cargo run`, but the working directory needs to be
+        // set to clippy's directory when building, and the target project's directory
+        // when running clippy. `cargo` can only set a single working directory for both
+        // when using `run`.
+        run_exit_on_err("cargo build", cargo_cmd().arg("build"));
 
-        exit_if_err(status);
+        let mut exe = env::current_exe().expect("failed to get current executable name");
+        exe.set_file_name(CARGO_CLIPPY_EXE);
+        run_exit_on_err(
+            "cargo clippy",
+            Command::new(exe)
+                .arg("clippy")
+                .args(args)
+                // Prevent rustc from creating `rustc-ice-*` files the console output is enough.
+                .env("RUSTC_ICE", "0")
+                .current_dir(path),
+        );
     }
 }
diff --git a/clippy_dev/src/main.rs b/clippy_dev/src/main.rs
index 26aa269fb6388..5fef231f6ca1c 100644
--- a/clippy_dev/src/main.rs
+++ b/clippy_dev/src/main.rs
@@ -4,14 +4,15 @@
 
 use clap::{Args, Parser, Subcommand};
 use clippy_dev::{
-    deprecate_lint, dogfood, fmt, lint, new_lint, release, rename_lint, serve, setup, sync, update_lints, utils,
+    ClippyInfo, UpdateMode, deprecate_lint, dogfood, fmt, lint, new_lint, release, rename_lint, serve, setup, sync,
+    update_lints,
 };
 use std::convert::Infallible;
 use std::env;
 
 fn main() {
     let dev = Dev::parse();
-    let clippy = utils::ClippyInfo::search_for_manifest();
+    let clippy = ClippyInfo::search_for_manifest();
     if let Err(e) = env::set_current_dir(&clippy.path) {
         panic!("error setting current directory to `{}`: {e}", clippy.path.display());
     }
@@ -26,8 +27,8 @@ fn main() {
             allow_staged,
             allow_no_vcs,
         } => dogfood::dogfood(fix, allow_dirty, allow_staged, allow_no_vcs),
-        DevCommand::Fmt { check } => fmt::run(utils::UpdateMode::from_check(check)),
-        DevCommand::UpdateLints { check } => update_lints::update(utils::UpdateMode::from_check(check)),
+        DevCommand::Fmt { check } => fmt::run(UpdateMode::from_check(check)),
+        DevCommand::UpdateLints { check } => update_lints::update(UpdateMode::from_check(check)),
         DevCommand::NewLint {
             pass,
             name,
@@ -35,7 +36,7 @@ fn main() {
             r#type,
             msrv,
         } => match new_lint::create(clippy.version, pass, &name, &category, r#type.as_deref(), msrv) {
-            Ok(()) => update_lints::update(utils::UpdateMode::Change),
+            Ok(()) => update_lints::update(UpdateMode::Change),
             Err(e) => eprintln!("Unable to create lint: {e}"),
         },
         DevCommand::Setup(SetupCommand { subcommand }) => match subcommand {
diff --git a/clippy_dev/src/serve.rs b/clippy_dev/src/serve.rs
index 498ffeba9d67c..d9e018133813d 100644
--- a/clippy_dev/src/serve.rs
+++ b/clippy_dev/src/serve.rs
@@ -1,7 +1,11 @@
+use crate::utils::{ErrAction, cargo_cmd, expect_action};
+use core::fmt::Display;
+use core::mem;
 use std::path::Path;
 use std::process::Command;
 use std::time::{Duration, SystemTime};
-use std::{env, thread};
+use std::{fs, thread};
+use walkdir::WalkDir;
 
 #[cfg(windows)]
 const PYTHON: &str = "python";
@@ -18,56 +22,83 @@ pub fn run(port: u16, lint: Option<String>) -> ! {
         Some(lint) => format!("http://localhost:{port}/#{lint}"),
     });
 
+    let mut last_update = mtime("util/gh-pages/index.html");
     loop {
-        let index_time = mtime("util/gh-pages/index.html");
-        let times = [
-            "clippy_lints/src",
-            "util/gh-pages/index_template.html",
-            "tests/compile-test.rs",
-        ]
-        .map(mtime);
-
-        if times.iter().any(|&time| index_time < time) {
-            Command::new(env::var("CARGO").unwrap_or_else(|_| "cargo".into()))
-                .arg("collect-metadata")
-                .spawn()
-                .unwrap()
-                .wait()
-                .unwrap();
+        if is_metadata_outdated(mem::replace(&mut last_update, SystemTime::now())) {
+            // Ignore the command result; we'll fall back to displaying the old metadata.
+            let _ = expect_action(
+                cargo_cmd().arg("collect-metadata").status(),
+                ErrAction::Run,
+                "cargo collect-metadata",
+            );
+            last_update = SystemTime::now();
         }
+
+        // Only start the web server the first time around.
         if let Some(url) = url.take() {
             thread::spawn(move || {
-                let mut child = Command::new(PYTHON)
-                    .arg("-m")
-                    .arg("http.server")
-                    .arg(port.to_string())
-                    .current_dir("util/gh-pages")
-                    .spawn()
-                    .unwrap();
+                let mut child = expect_action(
+                    Command::new(PYTHON)
+                        .args(["-m", "http.server", port.to_string().as_str()])
+                        .current_dir("util/gh-pages")
+                        .spawn(),
+                    ErrAction::Run,
+                    "python -m http.server",
+                );
                 // Give some time for python to start
                 thread::sleep(Duration::from_millis(500));
                 // Launch browser after first export.py has completed and http.server is up
                 let _result = opener::open(url);
-                child.wait().unwrap();
+                expect_action(child.wait(), ErrAction::Run, "python -m http.server");
             });
         }
+
+        // Delay to avoid updating the metadata too aggressively.
         thread::sleep(Duration::from_millis(1000));
     }
 }
 
-fn mtime(path: impl AsRef<Path>) -> SystemTime {
-    let path = path.as_ref();
-    if path.is_dir() {
-        path.read_dir()
-            .into_iter()
-            .flatten()
-            .flatten()
-            .map(|entry| mtime(entry.path()))
-            .max()
-            .unwrap_or(SystemTime::UNIX_EPOCH)
-    } else {
-        path.metadata()
-            .and_then(|metadata| metadata.modified())
-            .unwrap_or(SystemTime::UNIX_EPOCH)
+fn log_err_and_continue<T>(res: Result<T, impl Display>, path: &Path) -> Option<T> {
+    match res {
+        Ok(x) => Some(x),
+        Err(ref e) => {
+            eprintln!("error reading `{}`: {e}", path.display());
+            None
+        },
     }
 }
+
+fn mtime(path: &str) -> SystemTime {
+    log_err_and_continue(fs::metadata(path), path.as_ref())
+        .and_then(|metadata| log_err_and_continue(metadata.modified(), path.as_ref()))
+        .unwrap_or(SystemTime::UNIX_EPOCH)
+}
+
+fn is_metadata_outdated(time: SystemTime) -> bool {
+    // Ignore all IO errors here. We don't want to stop them from hosting the server.
+    if time < mtime("util/gh-pages/index_template.html") || time < mtime("tests/compile-test.rs") {
+        return true;
+    }
+    let Some(dir) = log_err_and_continue(fs::read_dir("."), ".".as_ref()) else {
+        return false;
+    };
+    dir.map_while(|e| log_err_and_continue(e, ".".as_ref())).any(|e| {
+        let name = e.file_name();
+        let name_bytes = name.as_encoded_bytes();
+        if (name_bytes.starts_with(b"clippy_lints") && name_bytes != b"clippy_lints_internal")
+            || name_bytes == b"clippy_config"
+        {
+            WalkDir::new(&name)
+                .into_iter()
+                .map_while(|e| log_err_and_continue(e, name.as_ref()))
+                .filter(|e| e.file_type().is_file())
+                .filter_map(|e| {
+                    log_err_and_continue(e.metadata(), e.path())
+                        .and_then(|m| log_err_and_continue(m.modified(), e.path()))
+                })
+                .any(|ftime| time < ftime)
+        } else {
+            false
+        }
+    })
+}
diff --git a/clippy_dev/src/setup/git_hook.rs b/clippy_dev/src/setup/git_hook.rs
index c7c53bc69d0b8..c5a1e8264c7f4 100644
--- a/clippy_dev/src/setup/git_hook.rs
+++ b/clippy_dev/src/setup/git_hook.rs
@@ -1,8 +1,6 @@
 use std::fs;
 use std::path::Path;
 
-use super::verify_inside_clippy_dir;
-
 /// Rusts setup uses `git rev-parse --git-common-dir` to get the root directory of the repo.
 /// I've decided against this for the sake of simplicity and to make sure that it doesn't install
 /// the hook if `clippy_dev` would be used in the rust tree. The hook also references this tool
@@ -35,10 +33,6 @@ pub fn install_hook(force_override: bool) {
 }
 
 fn check_precondition(force_override: bool) -> bool {
-    if !verify_inside_clippy_dir() {
-        return false;
-    }
-
     // Make sure that we can find the git repository
     let git_path = Path::new(REPO_GIT_DIR);
     if !git_path.exists() || !git_path.is_dir() {
diff --git a/clippy_dev/src/setup/mod.rs b/clippy_dev/src/setup/mod.rs
index b0d3181463918..5e938fff126d4 100644
--- a/clippy_dev/src/setup/mod.rs
+++ b/clippy_dev/src/setup/mod.rs
@@ -2,23 +2,3 @@ pub mod git_hook;
 pub mod intellij;
 pub mod toolchain;
 pub mod vscode;
-
-use std::path::Path;
-
-const CLIPPY_DEV_DIR: &str = "clippy_dev";
-
-/// This function verifies that the tool is being executed in the clippy directory.
-/// This is useful to ensure that setups only modify Clippy's resources. The verification
-/// is done by checking that `clippy_dev` is a sub directory of the current directory.
-///
-/// It will print an error message and return `false` if the directory could not be
-/// verified.
-fn verify_inside_clippy_dir() -> bool {
-    let path = Path::new(CLIPPY_DEV_DIR);
-    if path.exists() && path.is_dir() {
-        true
-    } else {
-        eprintln!("error: unable to verify that the working directory is clippy's directory");
-        false
-    }
-}
diff --git a/clippy_dev/src/setup/toolchain.rs b/clippy_dev/src/setup/toolchain.rs
index ecd80215f7e8f..c64ae4ef3c36b 100644
--- a/clippy_dev/src/setup/toolchain.rs
+++ b/clippy_dev/src/setup/toolchain.rs
@@ -1,20 +1,12 @@
+use crate::utils::{cargo_cmd, run_exit_on_err};
 use std::env::consts::EXE_SUFFIX;
 use std::env::current_dir;
 use std::ffi::OsStr;
 use std::fs;
 use std::path::{Path, PathBuf};
-use std::process::Command;
 use walkdir::WalkDir;
 
-use crate::utils::exit_if_err;
-
-use super::verify_inside_clippy_dir;
-
 pub fn create(standalone: bool, force: bool, release: bool, name: &str) {
-    if !verify_inside_clippy_dir() {
-        return;
-    }
-
     let rustup_home = std::env::var("RUSTUP_HOME").unwrap();
     let toolchain = std::env::var("RUSTUP_TOOLCHAIN").unwrap();
 
@@ -51,11 +43,10 @@ pub fn create(standalone: bool, force: bool, release: bool, name: &str) {
         }
     }
 
-    let status = Command::new("cargo")
-        .arg("build")
-        .args(release.then_some("--release"))
-        .status();
-    exit_if_err(status);
+    run_exit_on_err(
+        "cargo build",
+        cargo_cmd().arg("build").args(release.then_some("--release")),
+    );
 
     install_bin("cargo-clippy", &dest, standalone, release);
     install_bin("clippy-driver", &dest, standalone, release);
diff --git a/clippy_dev/src/setup/vscode.rs b/clippy_dev/src/setup/vscode.rs
index a37c873eed4f3..a24aef65991f5 100644
--- a/clippy_dev/src/setup/vscode.rs
+++ b/clippy_dev/src/setup/vscode.rs
@@ -1,8 +1,6 @@
 use std::fs;
 use std::path::Path;
 
-use super::verify_inside_clippy_dir;
-
 const VSCODE_DIR: &str = ".vscode";
 const TASK_SOURCE_FILE: &str = "util/etc/vscode-tasks.json";
 const TASK_TARGET_FILE: &str = ".vscode/tasks.json";
@@ -22,10 +20,6 @@ pub fn install_tasks(force_override: bool) {
 }
 
 fn check_install_precondition(force_override: bool) -> bool {
-    if !verify_inside_clippy_dir() {
-        return false;
-    }
-
     let vs_dir_path = Path::new(VSCODE_DIR);
     if vs_dir_path.exists() {
         // verify the target will be valid
diff --git a/clippy_dev/src/utils.rs b/clippy_dev/src/utils.rs
index 89962a110341d..057951d0e33bd 100644
--- a/clippy_dev/src/utils.rs
+++ b/clippy_dev/src/utils.rs
@@ -8,15 +8,10 @@ use std::ffi::OsStr;
 use std::fs::{self, OpenOptions};
 use std::io::{self, Read as _, Seek as _, SeekFrom, Write};
 use std::path::{Path, PathBuf};
-use std::process::{self, Command, ExitStatus, Stdio};
+use std::process::{self, Command, Stdio};
 use std::{env, thread};
 use walkdir::WalkDir;
 
-#[cfg(not(windows))]
-static CARGO_CLIPPY_EXE: &str = "cargo-clippy";
-#[cfg(windows)]
-static CARGO_CLIPPY_EXE: &str = "cargo-clippy.exe";
-
 #[derive(Clone, Copy)]
 pub enum ErrAction {
     Open,
@@ -118,16 +113,14 @@ impl<'a> File<'a> {
     }
 }
 
-/// Returns the path to the `cargo-clippy` binary
-///
-/// # Panics
-///
-/// Panics if the path of current executable could not be retrieved.
+/// Creates a `Command` for running cargo.
 #[must_use]
-pub fn cargo_clippy_path() -> PathBuf {
-    let mut path = env::current_exe().expect("failed to get current executable name");
-    path.set_file_name(CARGO_CLIPPY_EXE);
-    path
+pub fn cargo_cmd() -> Command {
+    if let Some(path) = env::var_os("CARGO") {
+        Command::new(path)
+    } else {
+        Command::new("cargo")
+    }
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
@@ -288,19 +281,6 @@ impl ClippyInfo {
     }
 }
 
-/// # Panics
-/// Panics if given command result was failed.
-pub fn exit_if_err(status: io::Result<ExitStatus>) {
-    match status.expect("failed to run command").code() {
-        Some(0) => {},
-        Some(n) => process::exit(n),
-        None => {
-            eprintln!("Killed by signal");
-            process::exit(1);
-        },
-    }
-}
-
 #[derive(Clone, Copy)]
 pub enum UpdateStatus {
     Unchanged,
@@ -341,6 +321,7 @@ pub struct FileUpdater {
     dst_buf: String,
 }
 impl FileUpdater {
+    #[track_caller]
     fn update_file_checked_inner(
         &mut self,
         tool: &str,
@@ -364,6 +345,7 @@ impl FileUpdater {
         }
     }
 
+    #[track_caller]
     fn update_file_inner(&mut self, path: &Path, update: &mut dyn FnMut(&Path, &str, &mut String) -> UpdateStatus) {
         let mut file = File::open(path, OpenOptions::new().read(true).write(true));
         file.read_to_cleared_string(&mut self.src_buf);
@@ -373,6 +355,7 @@ impl FileUpdater {
         }
     }
 
+    #[track_caller]
     pub fn update_file_checked(
         &mut self,
         tool: &str,
@@ -383,6 +366,7 @@ impl FileUpdater {
         self.update_file_checked_inner(tool, mode, path.as_ref(), update);
     }
 
+    #[track_caller]
     pub fn update_file(
         &mut self,
         path: impl AsRef<Path>,
@@ -450,7 +434,6 @@ pub enum Token<'a> {
     OpenParen,
     Pound,
     Semi,
-    Slash,
 }
 
 pub struct RustSearcher<'txt> {
@@ -528,7 +511,6 @@ impl<'txt> RustSearcher<'txt> {
                 | (Token::OpenParen, lexer::TokenKind::OpenParen)
                 | (Token::Pound, lexer::TokenKind::Pound)
                 | (Token::Semi, lexer::TokenKind::Semi)
-                | (Token::Slash, lexer::TokenKind::Slash)
                 | (
                     Token::LitStr,
                     lexer::TokenKind::Literal {
@@ -601,7 +583,7 @@ impl<'txt> RustSearcher<'txt> {
     }
 }
 
-#[expect(clippy::must_use_candidate)]
+#[track_caller]
 pub fn try_rename_file(old_name: &Path, new_name: &Path) -> bool {
     match OpenOptions::new().create_new(true).write(true).open(new_name) {
         Ok(file) => drop(file),
@@ -623,7 +605,7 @@ pub fn try_rename_file(old_name: &Path, new_name: &Path) -> bool {
     }
 }
 
-#[expect(clippy::must_use_candidate)]
+#[track_caller]
 pub fn try_rename_dir(old_name: &Path, new_name: &Path) -> bool {
     match fs::create_dir(new_name) {
         Ok(()) => {},
@@ -649,10 +631,19 @@ pub fn try_rename_dir(old_name: &Path, new_name: &Path) -> bool {
     }
 }
 
-pub fn write_file(path: &Path, contents: &str) {
-    expect_action(fs::write(path, contents), ErrAction::Write, path);
+#[track_caller]
+pub fn run_exit_on_err(path: &(impl AsRef<Path> + ?Sized), cmd: &mut Command) {
+    match expect_action(cmd.status(), ErrAction::Run, path.as_ref()).code() {
+        Some(0) => {},
+        Some(n) => process::exit(n),
+        None => {
+            eprintln!("{} killed by signal", path.as_ref().display());
+            process::exit(1);
+        },
+    }
 }
 
+#[track_caller]
 #[must_use]
 pub fn run_with_output(path: &(impl AsRef<Path> + ?Sized), cmd: &mut Command) -> Vec<u8> {
     fn f(path: &Path, cmd: &mut Command) -> Vec<u8> {
@@ -738,7 +729,7 @@ pub fn split_args_for_threads(
     }
 }
 
-#[expect(clippy::must_use_candidate)]
+#[track_caller]
 pub fn delete_file_if_exists(path: &Path) -> bool {
     match fs::remove_file(path) {
         Ok(()) => true,
@@ -747,6 +738,7 @@ pub fn delete_file_if_exists(path: &Path) -> bool {
     }
 }
 
+#[track_caller]
 pub fn delete_dir_if_exists(path: &Path) {
     match fs::remove_dir_all(path) {
         Ok(()) => {},
diff --git a/clippy_lints/src/casts/borrow_as_ptr.rs b/clippy_lints/src/casts/borrow_as_ptr.rs
index e3b125a8d5b9d..eb75d5576f5cf 100644
--- a/clippy_lints/src/casts/borrow_as_ptr.rs
+++ b/clippy_lints/src/casts/borrow_as_ptr.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::msrvs::Msrv;
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::has_enclosing_paren;
-use clippy_utils::{get_parent_expr, is_expr_temporary_value, is_lint_allowed, msrvs, std_or_core};
+use clippy_utils::{get_parent_expr, is_expr_temporary_value, is_from_proc_macro, is_lint_allowed, msrvs, std_or_core};
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, Ty, TyKind};
 use rustc_lint::LateContext;
@@ -22,13 +22,12 @@ pub(super) fn check<'tcx>(
         && !matches!(target.ty.kind, TyKind::TraitObject(..))
         && let ExprKind::AddrOf(BorrowKind::Ref, mutability, e) = cast_expr.kind
         && !is_lint_allowed(cx, BORROW_AS_PTR, expr.hir_id)
+        // Fix #9884
+        && !is_expr_temporary_value(cx, e)
+        && !is_from_proc_macro(cx, expr)
     {
         let mut app = Applicability::MachineApplicable;
         let snip = snippet_with_context(cx, e.span, cast_expr.span.ctxt(), "..", &mut app).0;
-        // Fix #9884
-        if is_expr_temporary_value(cx, e) {
-            return false;
-        }
 
         let (suggestion, span) = if msrv.meets(cx, msrvs::RAW_REF_OP) {
             // Make sure that the span to be replaced doesn't include parentheses, that could break the
diff --git a/clippy_lints/src/casts/char_lit_as_u8.rs b/clippy_lints/src/casts/char_lit_as_u8.rs
index a7d3868f76c60..964eaf2a0a2d9 100644
--- a/clippy_lints/src/casts/char_lit_as_u8.rs
+++ b/clippy_lints/src/casts/char_lit_as_u8.rs
@@ -4,18 +4,17 @@ use rustc_ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
-use rustc_middle::ty::{self, UintTy};
+use rustc_middle::ty::{self, Ty, UintTy};
 
 use super::CHAR_LIT_AS_U8;
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
-    if let ExprKind::Cast(e, _) = &expr.kind
-        && let ExprKind::Lit(l) = &e.kind
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from_expr: &Expr<'_>, cast_to: Ty<'_>) {
+    if let ExprKind::Lit(l) = &cast_from_expr.kind
         && let LitKind::Char(c) = l.node
-        && ty::Uint(UintTy::U8) == *cx.typeck_results().expr_ty(expr).kind()
+        && ty::Uint(UintTy::U8) == *cast_to.kind()
     {
         let mut applicability = Applicability::MachineApplicable;
-        let snippet = snippet_with_applicability(cx, e.span, "'x'", &mut applicability);
+        let snippet = snippet_with_applicability(cx, cast_from_expr.span, "'x'", &mut applicability);
 
         span_lint_and_then(
             cx,
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index dcc439a272cf8..e25df9dd249a6 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -871,6 +871,7 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             if !expr.span.from_expansion() && unnecessary_cast::check(cx, expr, cast_from_expr, cast_from, cast_to) {
                 return;
             }
+            char_lit_as_u8::check(cx, expr, cast_from_expr, cast_to);
             cast_slice_from_raw_parts::check(cx, expr, cast_from_expr, cast_to, self.msrv);
             ptr_cast_constness::check(cx, expr, cast_from_expr, cast_from, cast_to, self.msrv);
             as_ptr_cast_mut::check(cx, expr, cast_from_expr, cast_to);
@@ -911,7 +912,6 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             borrow_as_ptr::check_implicit_cast(cx, expr);
         }
         cast_ptr_alignment::check(cx, expr);
-        char_lit_as_u8::check(cx, expr);
         ptr_as_ptr::check(cx, expr, self.msrv);
         cast_slice_different_sizes::check(cx, expr, self.msrv);
         ptr_cast_constness::check_null_ptr_cast_method(cx, expr);
diff --git a/clippy_lints/src/casts/ptr_as_ptr.rs b/clippy_lints/src/casts/ptr_as_ptr.rs
index ee0f3fa81c6d9..890754090989f 100644
--- a/clippy_lints/src/casts/ptr_as_ptr.rs
+++ b/clippy_lints/src/casts/ptr_as_ptr.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_from_proc_macro;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
@@ -25,7 +26,7 @@ impl OmitFollowedCastReason<'_> {
     }
 }
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: Msrv) {
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, msrv: Msrv) {
     if let ExprKind::Cast(cast_expr, cast_to_hir_ty) = expr.kind
         && let (cast_from, cast_to) = (cx.typeck_results().expr_ty(cast_expr), cx.typeck_results().expr_ty(expr))
         && let ty::RawPtr(_, from_mutbl) = cast_from.kind()
@@ -36,6 +37,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: Msrv) {
         // as explained here: https://github.com/rust-lang/rust/issues/60602.
         && to_pointee_ty.is_sized(cx.tcx, cx.typing_env())
         && msrv.meets(cx, msrvs::POINTER_CAST)
+        && !is_from_proc_macro(cx, expr)
     {
         let mut app = Applicability::MachineApplicable;
         let turbofish = match &cast_to_hir_ty.kind {
diff --git a/clippy_lints/src/cognitive_complexity.rs b/clippy_lints/src/cognitive_complexity.rs
index 8f1c02965244c..8f95c63a854f5 100644
--- a/clippy_lints/src/cognitive_complexity.rs
+++ b/clippy_lints/src/cognitive_complexity.rs
@@ -56,7 +56,7 @@ impl_lint_pass!(CognitiveComplexity => [COGNITIVE_COMPLEXITY]);
 
 impl CognitiveComplexity {
     fn check<'tcx>(
-        &mut self,
+        &self,
         cx: &LateContext<'tcx>,
         kind: FnKind<'tcx>,
         decl: &'tcx FnDecl<'_>,
diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index e3103e2d3016b..ad610fbd8d2c3 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -5,7 +5,7 @@ use clippy_utils::source::{IntoSpan as _, SpanRangeExt, snippet, snippet_block_w
 use clippy_utils::{span_contains_non_whitespace, tokenize_with_text};
 use rustc_ast::BinOpKind;
 use rustc_errors::Applicability;
-use rustc_hir::{Block, Expr, ExprKind, Stmt, StmtKind};
+use rustc_hir::{Block, Expr, ExprKind, StmtKind};
 use rustc_lexer::TokenKind;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::impl_lint_pass;
@@ -141,11 +141,7 @@ impl CollapsibleIf {
 
                     // Prevent "elseif"
                     // Check that the "else" is followed by whitespace
-                    let requires_space = if let Some(c) = snippet(cx, up_to_else, "..").chars().last() {
-                        !c.is_whitespace()
-                    } else {
-                        false
-                    };
+                    let requires_space = snippet(cx, up_to_else, "..").ends_with(|c: char| !c.is_whitespace());
                     let mut applicability = Applicability::MachineApplicable;
                     diag.span_suggestion(
                         else_block.span,
@@ -173,8 +169,7 @@ impl CollapsibleIf {
             && cx.tcx.hir_attrs(inner.hir_id).is_empty()
             && let ExprKind::If(check_inner, _, None) = &inner.kind
             && self.eligible_condition(cx, check_inner)
-            && let ctxt = expr.span.ctxt()
-            && inner.span.ctxt() == ctxt
+            && expr.span.eq_ctxt(inner.span)
             && !block_starts_with_significant_tokens(cx, then, inner, self.lint_commented_code)
         {
             span_lint_and_then(
@@ -262,14 +257,9 @@ fn block_starts_with_significant_tokens(
 /// If `block` is a block with either one expression or a statement containing an expression,
 /// return the expression. We don't peel blocks recursively, as extra blocks might be intentional.
 fn expr_block<'tcx>(block: &Block<'tcx>) -> Option<&'tcx Expr<'tcx>> {
-    match block.stmts {
-        [] => block.expr,
-        [
-            Stmt {
-                kind: StmtKind::Semi(expr),
-                ..
-            },
-        ] if block.expr.is_none() => Some(expr),
+    match (block.stmts, block.expr) {
+        ([], expr) => expr,
+        ([stmt], None) if let StmtKind::Semi(expr) = stmt.kind => Some(expr),
         _ => None,
     }
 }
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index e1cb08e361ca8..e67e8d9070f2c 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -187,6 +187,7 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::from_raw_with_void_ptr::FROM_RAW_WITH_VOID_PTR_INFO,
     crate::from_str_radix_10::FROM_STR_RADIX_10_INFO,
     crate::functions::DOUBLE_MUST_USE_INFO,
+    crate::functions::DUPLICATE_UNDERSCORE_ARGUMENT_INFO,
     crate::functions::IMPL_TRAIT_IN_PARAMS_INFO,
     crate::functions::MISNAMED_GETTERS_INFO,
     crate::functions::MUST_USE_CANDIDATE_INFO,
@@ -505,7 +506,6 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::misc::USED_UNDERSCORE_BINDING_INFO,
     crate::misc::USED_UNDERSCORE_ITEMS_INFO,
     crate::misc_early::BUILTIN_TYPE_SHADOW_INFO,
-    crate::misc_early::DUPLICATE_UNDERSCORE_ARGUMENT_INFO,
     crate::misc_early::MIXED_CASE_HEX_LITERALS_INFO,
     crate::misc_early::REDUNDANT_AT_REST_PATTERN_INFO,
     crate::misc_early::REDUNDANT_PATTERN_INFO,
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 995a1209595e9..9aa2f3cf0a5b7 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1,12 +1,11 @@
 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};
+use clippy_utils::ty::{adjust_derefs_manually_drop, implements_trait, is_manually_drop};
 use clippy_utils::{
     DefinedTy, ExprUseNode, expr_use_ctxt, get_parent_expr, is_block_like, is_lint_allowed, path_to_local,
     peel_middle_ty_refs,
 };
-use core::mem;
 use rustc_ast::util::parser::ExprPrecedence;
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::Applicability;
@@ -707,14 +706,6 @@ fn try_parse_ref_op<'tcx>(
     ))
 }
 
-// Checks if the adjustments contains a deref of `ManuallyDrop<_>`
-fn adjust_derefs_manually_drop<'tcx>(adjustments: &'tcx [Adjustment<'tcx>], mut ty: Ty<'tcx>) -> bool {
-    adjustments.iter().any(|a| {
-        let ty = mem::replace(&mut ty, a.target);
-        matches!(a.kind, Adjust::Deref(Some(ref op)) if op.mutbl == Mutability::Mut) && is_manually_drop(ty)
-    })
-}
-
 // Checks whether the type for a deref call actually changed the type, not just the mutability of
 // the reference.
 fn deref_method_same_type<'tcx>(result_ty: Ty<'tcx>, arg_ty: Ty<'tcx>) -> bool {
diff --git a/clippy_lints/src/doc/mod.rs b/clippy_lints/src/doc/mod.rs
index d27d68d386645..eca3bc390d778 100644
--- a/clippy_lints/src/doc/mod.rs
+++ b/clippy_lints/src/doc/mod.rs
@@ -1139,12 +1139,12 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
                         None,
                         "a backtick may be missing a pair",
                     );
+                    text_to_check.clear();
                 } else {
-                    for (text, range, assoc_code_level) in text_to_check {
+                    for (text, range, assoc_code_level) in text_to_check.drain(..) {
                         markdown::check(cx, valid_idents, &text, &fragments, range, assoc_code_level, blockquote_level);
                     }
                 }
-                text_to_check = Vec::new();
             },
             Start(FootnoteDefinition(..)) => in_footnote_definition = true,
             End(TagEnd::FootnoteDefinition) => in_footnote_definition = false,
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index e467246741ce5..0eefc2f610969 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -231,9 +231,13 @@ fn check_closure<'tcx>(cx: &LateContext<'tcx>, outer_receiver: Option<&Expr<'tcx
                                     _ => (),
                                 }
                             }
+                            let replace_with = match callee_ty_adjusted.kind() {
+                                ty::FnDef(def, _) => cx.tcx.def_descr(*def),
+                                _ => "function",
+                            };
                             diag.span_suggestion(
                                 expr.span,
-                                "replace the closure with the function itself",
+                                format!("replace the closure with the {replace_with} itself"),
                                 snippet,
                                 Applicability::MachineApplicable,
                             );
diff --git a/clippy_lints/src/from_str_radix_10.rs b/clippy_lints/src/from_str_radix_10.rs
index b816963cc825b..d5873b3f85aa1 100644
--- a/clippy_lints/src/from_str_radix_10.rs
+++ b/clippy_lints/src/from_str_radix_10.rs
@@ -1,6 +1,6 @@
 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::ty::is_type_lang_item;
 use clippy_utils::{is_in_const_context, is_integer_literal, sym};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, LangItem, PrimTy, QPath, TyKind, def};
@@ -89,5 +89,5 @@ impl<'tcx> LateLintPass<'tcx> for FromStrRadix10 {
 
 /// Checks if a Ty is `String` or `&str`
 fn is_ty_stringish(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
-    is_type_lang_item(cx, ty, LangItem::String) || is_type_diagnostic_item(cx, ty, sym::str)
+    is_type_lang_item(cx, ty, LangItem::String) || ty.peel_refs().is_str()
 }
diff --git a/clippy_lints/src/functions/duplicate_underscore_argument.rs b/clippy_lints/src/functions/duplicate_underscore_argument.rs
new file mode 100644
index 0000000000000..b15d1b1bb79ab
--- /dev/null
+++ b/clippy_lints/src/functions/duplicate_underscore_argument.rs
@@ -0,0 +1,34 @@
+use clippy_utils::diagnostics::span_lint;
+use rustc_ast::PatKind;
+use rustc_ast::visit::FnKind;
+use rustc_data_structures::fx::FxHashMap;
+use rustc_lint::EarlyContext;
+use rustc_span::Span;
+
+use super::DUPLICATE_UNDERSCORE_ARGUMENT;
+
+pub(super) fn check(cx: &EarlyContext<'_>, fn_kind: FnKind<'_>) {
+    let mut registered_names: FxHashMap<String, Span> = FxHashMap::default();
+
+    for arg in &fn_kind.decl().inputs {
+        if let PatKind::Ident(_, ident, None) = arg.pat.kind {
+            let arg_name = ident.to_string();
+
+            if let Some(arg_name) = arg_name.strip_prefix('_') {
+                if let Some(correspondence) = registered_names.get(arg_name) {
+                    span_lint(
+                        cx,
+                        DUPLICATE_UNDERSCORE_ARGUMENT,
+                        *correspondence,
+                        format!(
+                            "`{arg_name}` already exists, having another argument having almost the same \
+                                 name makes code comprehension and documentation more difficult"
+                        ),
+                    );
+                }
+            } else {
+                registered_names.insert(arg_name, arg.pat.span);
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index 6051dc9479baf..ca5ea90181493 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -1,3 +1,4 @@
+mod duplicate_underscore_argument;
 mod impl_trait_in_params;
 mod misnamed_getters;
 mod must_use;
@@ -11,14 +12,38 @@ mod too_many_lines;
 use clippy_config::Conf;
 use clippy_utils::msrvs::Msrv;
 use clippy_utils::paths::{PathNS, lookup_path_str};
+use rustc_ast::{self as ast, visit};
 use rustc_hir as hir;
 use rustc_hir::intravisit;
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
 use rustc_middle::ty::TyCtxt;
-use rustc_session::impl_lint_pass;
+use rustc_session::{declare_lint_pass, impl_lint_pass};
 use rustc_span::Span;
 use rustc_span::def_id::{DefIdSet, LocalDefId};
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for function arguments having the similar names
+    /// differing by an underscore.
+    ///
+    /// ### Why is this bad?
+    /// It affects code readability.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// fn foo(a: i32, _a: i32) {}
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// fn bar(a: i32, _b: i32) {}
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub DUPLICATE_UNDERSCORE_ARGUMENT,
+    style,
+    "function arguments having names which only differ by an underscore"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for functions with too many parameters.
@@ -448,6 +473,14 @@ declare_clippy_lint! {
     "function signature uses `&Option<T>` instead of `Option<&T>`"
 }
 
+declare_lint_pass!(EarlyFunctions => [DUPLICATE_UNDERSCORE_ARGUMENT]);
+
+impl EarlyLintPass for EarlyFunctions {
+    fn check_fn(&mut self, cx: &EarlyContext<'_>, fn_kind: visit::FnKind<'_>, _: Span, _: ast::NodeId) {
+        duplicate_underscore_argument::check(cx, fn_kind);
+    }
+}
+
 pub struct Functions {
     too_many_arguments_threshold: u64,
     too_many_lines_threshold: u64,
@@ -503,7 +536,7 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
     ) {
         let hir_id = cx.tcx.local_def_id_to_hir_id(def_id);
         too_many_arguments::check_fn(cx, kind, decl, span, hir_id, self.too_many_arguments_threshold);
-        too_many_lines::check_fn(cx, kind, span, body, self.too_many_lines_threshold);
+        too_many_lines::check_fn(cx, kind, body, span, def_id, self.too_many_lines_threshold);
         not_unsafe_ptr_arg_deref::check_fn(cx, kind, decl, body, def_id);
         misnamed_getters::check_fn(cx, kind, decl, body, span);
         impl_trait_in_params::check_fn(cx, &kind, body, hir_id);
diff --git a/clippy_lints/src/functions/renamed_function_params.rs b/clippy_lints/src/functions/renamed_function_params.rs
index 0a7c6e9d5f8e1..f8e8f5544b993 100644
--- a/clippy_lints/src/functions/renamed_function_params.rs
+++ b/clippy_lints/src/functions/renamed_function_params.rs
@@ -6,6 +6,7 @@ use rustc_hir::{Impl, ImplItem, ImplItemKind, ItemKind, Node, TraitRef};
 use rustc_lint::LateContext;
 use rustc_span::Span;
 use rustc_span::symbol::{Ident, kw};
+use std::iter;
 
 use super::RENAMED_FUNCTION_PARAMS;
 
@@ -58,16 +59,11 @@ impl RenamedFnArgs {
         let mut renamed: Vec<(Span, String)> = vec![];
 
         debug_assert!(default_idents.size_hint() == current_idents.size_hint());
-        while let (Some(default_ident), Some(current_ident)) = (default_idents.next(), current_idents.next()) {
+        for (default_ident, current_ident) in iter::zip(default_idents, current_idents) {
             let has_name_to_check = |ident: Option<Ident>| {
-                if let Some(ident) = ident
-                    && ident.name != kw::Underscore
-                    && !ident.name.as_str().starts_with('_')
-                {
-                    Some(ident)
-                } else {
-                    None
-                }
+                ident
+                    .filter(|ident| ident.name != kw::Underscore)
+                    .filter(|ident| !ident.name.as_str().starts_with('_'))
             };
 
             if let Some(default_ident) = has_name_to_check(default_ident)
@@ -97,8 +93,7 @@ fn trait_item_def_id_of_impl(cx: &LateContext<'_>, target: OwnerId) -> Option<De
 }
 
 fn is_from_ignored_trait(of_trait: &TraitRef<'_>, ignored_traits: &DefIdSet) -> bool {
-    let Some(trait_did) = of_trait.trait_def_id() else {
-        return false;
-    };
-    ignored_traits.contains(&trait_did)
+    of_trait
+        .trait_def_id()
+        .is_some_and(|trait_did| ignored_traits.contains(&trait_did))
 }
diff --git a/clippy_lints/src/functions/result.rs b/clippy_lints/src/functions/result.rs
index bb98ae8261119..1f2fce687ed1b 100644
--- a/clippy_lints/src/functions/result.rs
+++ b/clippy_lints/src/functions/result.rs
@@ -97,11 +97,7 @@ fn check_result_unit_err(cx: &LateContext<'_>, err_ty: Ty<'_>, fn_header_span: S
 
 fn check_result_large_err<'tcx>(cx: &LateContext<'tcx>, err_ty: Ty<'tcx>, hir_ty_span: Span, large_err_threshold: u64) {
     if let ty::Adt(adt, subst) = err_ty.kind()
-        && let Some(local_def_id) = err_ty
-            .ty_adt_def()
-            .expect("already checked this is adt")
-            .did()
-            .as_local()
+        && let Some(local_def_id) = adt.did().as_local()
         && let hir::Node::Item(item) = cx.tcx.hir_node_by_def_id(local_def_id)
         && let hir::ItemKind::Enum(_, _, ref def) = item.kind
     {
diff --git a/clippy_lints/src/functions/too_many_lines.rs b/clippy_lints/src/functions/too_many_lines.rs
index 4f90d9655b445..33eede8e65ac9 100644
--- a/clippy_lints/src/functions/too_many_lines.rs
+++ b/clippy_lints/src/functions/too_many_lines.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::source::SpanRangeExt;
 use rustc_hir as hir;
+use rustc_hir::def_id::LocalDefId;
 use rustc_hir::intravisit::FnKind;
 use rustc_lint::{LateContext, LintContext};
 use rustc_span::Span;
@@ -10,8 +11,9 @@ use super::TOO_MANY_LINES;
 pub(super) fn check_fn(
     cx: &LateContext<'_>,
     kind: FnKind<'_>,
-    span: Span,
     body: &hir::Body<'_>,
+    span: Span,
+    def_id: LocalDefId,
     too_many_lines_threshold: u64,
 ) {
     // Closures must be contained in a parent body, which will be checked for `too_many_lines`.
@@ -74,7 +76,7 @@ pub(super) fn check_fn(
         span_lint(
             cx,
             TOO_MANY_LINES,
-            span,
+            cx.tcx.def_span(def_id),
             format!("this function has too many lines ({line_count}/{too_many_lines_threshold})"),
         );
     }
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 6beddc1be1443..57deb011f2b0e 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -176,12 +176,11 @@ impl<'tcx> LateLintPass<'tcx> for LenZero {
         if let ExprKind::Let(lt) = expr.kind
             && match lt.pat.kind {
                 PatKind::Slice([], None, []) => true,
-                PatKind::Expr(lit) => match lit.kind {
-                    PatExprKind::Lit { lit, .. } => match lit.node {
-                        LitKind::Str(lit, _) => lit.as_str().is_empty(),
-                        _ => false,
-                    },
-                    _ => false,
+                PatKind::Expr(lit)
+                    if let PatExprKind::Lit { lit, .. } = lit.kind
+                        && let LitKind::Str(lit, _) = lit.node =>
+                {
+                    lit.as_str().is_empty()
                 },
                 _ => false,
             }
@@ -336,33 +335,23 @@ fn extract_future_output<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<&
 }
 
 fn is_first_generic_integral<'tcx>(segment: &'tcx PathSegment<'tcx>) -> bool {
-    if let Some(generic_args) = segment.args {
-        if generic_args.args.is_empty() {
-            return false;
-        }
-        let arg = &generic_args.args[0];
-        if let GenericArg::Type(rustc_hir::Ty {
-            kind: TyKind::Path(QPath::Resolved(_, path)),
-            ..
-        }) = arg
-        {
-            let segments = &path.segments;
-            let segment = &segments[0];
-            let res = &segment.res;
-            if matches!(res, Res::PrimTy(PrimTy::Uint(_))) || matches!(res, Res::PrimTy(PrimTy::Int(_))) {
-                return true;
-            }
-        }
+    if let Some(generic_args) = segment.args
+        && let [GenericArg::Type(ty), ..] = &generic_args.args
+        && let TyKind::Path(QPath::Resolved(_, path)) = ty.kind
+        && let [segment, ..] = &path.segments
+        && matches!(segment.res, Res::PrimTy(PrimTy::Uint(_) | PrimTy::Int(_)))
+    {
+        true
+    } else {
+        false
     }
-
-    false
 }
 
 fn parse_len_output<'tcx>(cx: &LateContext<'tcx>, sig: FnSig<'tcx>) -> Option<LenOutput> {
     if let Some(segment) = extract_future_output(cx, sig.output()) {
         let res = segment.res;
 
-        if matches!(res, Res::PrimTy(PrimTy::Uint(_))) || matches!(res, Res::PrimTy(PrimTy::Int(_))) {
+        if matches!(res, Res::PrimTy(PrimTy::Uint(_) | PrimTy::Int(_))) {
             return Some(LenOutput::Integral);
         }
 
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 844bc1b0e3909..d468993e74445 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -556,6 +556,7 @@ pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Co
     store.register_late_pass(|_| Box::new(panicking_overflow_checks::PanickingOverflowChecks));
     store.register_late_pass(|_| Box::<new_without_default::NewWithoutDefault>::default());
     store.register_late_pass(move |_| Box::new(disallowed_names::DisallowedNames::new(conf)));
+    store.register_early_pass(|| Box::new(functions::EarlyFunctions));
     store.register_late_pass(move |tcx| Box::new(functions::Functions::new(tcx, conf)));
     store.register_late_pass(move |_| Box::new(doc::Documentation::new(conf)));
     store.register_early_pass(move || Box::new(doc::Documentation::new(conf)));
@@ -600,7 +601,7 @@ pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Co
     store.register_late_pass(move |_| Box::new(trait_bounds::TraitBounds::new(conf)));
     store.register_late_pass(|_| Box::new(comparison_chain::ComparisonChain));
     store.register_late_pass(move |tcx| Box::new(mut_key::MutableKeyType::new(tcx, conf)));
-    store.register_early_pass(|| Box::new(reference::DerefAddrOf));
+    store.register_late_pass(|_| Box::new(reference::DerefAddrOf));
     store.register_early_pass(|| Box::new(double_parens::DoubleParens));
     let format_args = format_args_storage.clone();
     store.register_late_pass(move |_| Box::new(format_impl::FormatImpl::new(format_args.clone())));
diff --git a/clippy_lints/src/loops/infinite_loop.rs b/clippy_lints/src/loops/infinite_loop.rs
index 797ff1f398668..a71e6963f8ca2 100644
--- a/clippy_lints/src/loops/infinite_loop.rs
+++ b/clippy_lints/src/loops/infinite_loop.rs
@@ -1,10 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::{fn_def_id, is_from_proc_macro, is_lint_allowed};
 use hir::intravisit::{Visitor, walk_expr};
-use hir::{Expr, ExprKind, FnRetTy, FnSig, Node, TyKind};
 use rustc_ast::Label;
 use rustc_errors::Applicability;
-use rustc_hir as hir;
+use rustc_hir::{
+    self as hir, Closure, ClosureKind, CoroutineDesugaring, CoroutineKind, Expr, ExprKind, FnRetTy, FnSig, Node, TyKind,
+};
 use rustc_lint::{LateContext, LintContext};
 use rustc_span::sym;
 
@@ -29,6 +30,10 @@ pub(super) fn check<'tcx>(
         return;
     }
 
+    if is_inside_unawaited_async_block(cx, expr) {
+        return;
+    }
+
     if expr.span.in_external_macro(cx.sess().source_map()) || is_from_proc_macro(cx, expr) {
         return;
     }
@@ -60,6 +65,39 @@ pub(super) fn check<'tcx>(
     }
 }
 
+/// Check if the given expression is inside an async block that is not being awaited.
+/// This helps avoid false positives when async blocks are spawned or assigned to variables.
+fn is_inside_unawaited_async_block(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    let current_hir_id = expr.hir_id;
+    for (_, parent_node) in cx.tcx.hir_parent_iter(current_hir_id) {
+        if let Node::Expr(Expr {
+            kind:
+                ExprKind::Closure(Closure {
+                    kind: ClosureKind::Coroutine(CoroutineKind::Desugared(CoroutineDesugaring::Async, _)),
+                    ..
+                }),
+            ..
+        }) = parent_node
+        {
+            return !is_async_block_awaited(cx, expr);
+        }
+    }
+    false
+}
+
+fn is_async_block_awaited(cx: &LateContext<'_>, async_expr: &Expr<'_>) -> bool {
+    for (_, parent_node) in cx.tcx.hir_parent_iter(async_expr.hir_id) {
+        if let Node::Expr(Expr {
+            kind: ExprKind::Match(_, _, hir::MatchSource::AwaitDesugar),
+            ..
+        }) = parent_node
+        {
+            return true;
+        }
+    }
+    false
+}
+
 fn get_parent_fn_ret_ty<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> Option<FnRetTy<'tcx>> {
     for (_, parent_node) in cx.tcx.hir_parent_iter(expr.hir_id) {
         match parent_node {
@@ -67,8 +105,8 @@ fn get_parent_fn_ret_ty<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> Option
             // This is because we still need to backtrack one parent node to get the `OpaqueDef` ty.
             Node::Expr(Expr {
                 kind:
-                    ExprKind::Closure(hir::Closure {
-                        kind: hir::ClosureKind::Coroutine(_),
+                    ExprKind::Closure(Closure {
+                        kind: ClosureKind::Coroutine(_),
                         ..
                     }),
                 ..
@@ -90,7 +128,7 @@ fn get_parent_fn_ret_ty<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> Option
                 ..
             })
             | Node::Expr(Expr {
-                kind: ExprKind::Closure(hir::Closure { fn_decl: decl, .. }),
+                kind: ExprKind::Closure(Closure { fn_decl: decl, .. }),
                 ..
             }) => return Some(decl.output),
             _ => (),
diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 1f9a943f13dcd..5a7967bbf9468 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -49,7 +49,7 @@ declare_clippy_lint! {
 }
 
 impl<'tcx> QuestionMark {
-    pub(crate) fn check_manual_let_else(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'tcx>) {
+    pub(crate) fn check_manual_let_else(&self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'tcx>) {
         if let StmtKind::Let(local) = stmt.kind
             && let Some(init) = local.init
             && local.els.is_none()
diff --git a/clippy_lints/src/matches/match_bool.rs b/clippy_lints/src/matches/match_bool.rs
index b90cf6357c5c0..a2c8741f4f745 100644
--- a/clippy_lints/src/matches/match_bool.rs
+++ b/clippy_lints/src/matches/match_bool.rs
@@ -12,7 +12,11 @@ use super::MATCH_BOOL;
 
 pub(crate) fn check(cx: &LateContext<'_>, scrutinee: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
     // Type of expression is `bool`.
-    if *cx.typeck_results().expr_ty(scrutinee).kind() == ty::Bool {
+    if *cx.typeck_results().expr_ty(scrutinee).kind() == ty::Bool
+        && arms
+            .iter()
+            .all(|arm| arm.pat.walk_short(|p| !matches!(p.kind, PatKind::Binding(..))))
+    {
         span_lint_and_then(
             cx,
             MATCH_BOOL,
diff --git a/clippy_lints/src/matches/match_ref_pats.rs b/clippy_lints/src/matches/match_ref_pats.rs
index 5445ee1f04296..5934ec409935a 100644
--- a/clippy_lints/src/matches/match_ref_pats.rs
+++ b/clippy_lints/src/matches/match_ref_pats.rs
@@ -17,6 +17,11 @@ where
         return;
     }
 
+    // `!` cannot be deref-ed
+    if cx.typeck_results().expr_ty(scrutinee).is_never() {
+        return;
+    }
+
     let (first_sugg, msg, title);
     let ctxt = expr.span.ctxt();
     let mut app = Applicability::Unspecified;
diff --git a/clippy_lints/src/matches/match_str_case_mismatch.rs b/clippy_lints/src/matches/match_str_case_mismatch.rs
index 8b4c17000519c..eb8b16e1561bd 100644
--- a/clippy_lints/src/matches/match_str_case_mismatch.rs
+++ b/clippy_lints/src/matches/match_str_case_mismatch.rs
@@ -54,7 +54,7 @@ impl<'tcx> Visitor<'tcx> for MatchExprVisitor<'_, 'tcx> {
 }
 
 impl MatchExprVisitor<'_, '_> {
-    fn case_altered(&mut self, segment_ident: Symbol, receiver: &Expr<'_>) -> ControlFlow<CaseMethod> {
+    fn case_altered(&self, segment_ident: Symbol, receiver: &Expr<'_>) -> ControlFlow<CaseMethod> {
         if let Some(case_method) = get_case_method(segment_ident) {
             let ty = self.cx.typeck_results().expr_ty(receiver).peel_refs();
 
diff --git a/clippy_lints/src/methods/double_ended_iterator_last.rs b/clippy_lints/src/methods/double_ended_iterator_last.rs
index 6d841853fbe5f..578865c329180 100644
--- a/clippy_lints/src/methods/double_ended_iterator_last.rs
+++ b/clippy_lints/src/methods/double_ended_iterator_last.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::{has_non_owning_mutable_access, implements_trait};
-use clippy_utils::{is_mutable, is_trait_method, path_to_local, sym};
+use clippy_utils::{is_mutable, is_trait_method, path_to_local_with_projections, sym};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Node, PatKind};
 use rustc_lint::LateContext;
@@ -37,7 +37,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &'_ Expr<'_>, self_expr: &'_ Exp
         // TODO: Change this to lint only when the referred iterator is not used later. If it is used later,
         // changing to `next_back()` may change its behavior.
         if !(is_mutable(cx, self_expr) || self_type.is_ref()) {
-            if let Some(hir_id) = path_to_local(self_expr)
+            if let Some(hir_id) = path_to_local_with_projections(self_expr)
                 && let Node::Pat(pat) = cx.tcx.hir_node(hir_id)
                 && let PatKind::Binding(_, _, ident, _) = pat.kind
             {
diff --git a/clippy_lints/src/methods/expect_fun_call.rs b/clippy_lints/src/methods/expect_fun_call.rs
index 6e5da5bda8c9d..818e26f8aa1df 100644
--- a/clippy_lints/src/methods/expect_fun_call.rs
+++ b/clippy_lints/src/methods/expect_fun_call.rs
@@ -15,7 +15,6 @@ use std::ops::ControlFlow;
 use super::EXPECT_FUN_CALL;
 
 /// Checks for the `EXPECT_FUN_CALL` lint.
-#[allow(clippy::too_many_lines)]
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     format_args_storage: &FormatArgsStorage,
@@ -25,43 +24,6 @@ pub(super) fn check<'tcx>(
     receiver: &'tcx hir::Expr<'tcx>,
     args: &'tcx [hir::Expr<'tcx>],
 ) {
-    // Strip `{}`, `&`, `as_ref()` and `as_str()` off `arg` until we're left with either a `String` or
-    // `&str`
-    fn get_arg_root<'a>(cx: &LateContext<'_>, arg: &'a hir::Expr<'a>) -> &'a hir::Expr<'a> {
-        let mut arg_root = peel_blocks(arg);
-        loop {
-            arg_root = match &arg_root.kind {
-                hir::ExprKind::AddrOf(hir::BorrowKind::Ref, _, expr) => expr,
-                hir::ExprKind::MethodCall(method_name, receiver, [], ..) => {
-                    if (method_name.ident.name == sym::as_str || method_name.ident.name == sym::as_ref) && {
-                        let arg_type = cx.typeck_results().expr_ty(receiver);
-                        let base_type = arg_type.peel_refs();
-                        base_type.is_str() || is_type_lang_item(cx, base_type, hir::LangItem::String)
-                    } {
-                        receiver
-                    } else {
-                        break;
-                    }
-                },
-                _ => break,
-            };
-        }
-        arg_root
-    }
-
-    fn contains_call<'a>(cx: &LateContext<'a>, arg: &'a hir::Expr<'a>) -> bool {
-        for_each_expr(cx, arg, |expr| {
-            if matches!(expr.kind, hir::ExprKind::MethodCall { .. } | hir::ExprKind::Call { .. })
-                && !is_inside_always_const_context(cx.tcx, expr.hir_id)
-            {
-                ControlFlow::Break(())
-            } else {
-                ControlFlow::Continue(())
-            }
-        })
-        .is_some()
-    }
-
     if name == sym::expect
         && let [arg] = args
         && let arg_root = get_arg_root(cx, arg)
@@ -114,3 +76,40 @@ pub(super) fn check<'tcx>(
         );
     }
 }
+
+/// Strip `{}`, `&`, `as_ref()` and `as_str()` off `arg` until we're left with either a `String` or
+/// `&str`
+fn get_arg_root<'a>(cx: &LateContext<'_>, arg: &'a hir::Expr<'a>) -> &'a hir::Expr<'a> {
+    let mut arg_root = peel_blocks(arg);
+    loop {
+        arg_root = match &arg_root.kind {
+            hir::ExprKind::AddrOf(hir::BorrowKind::Ref, _, expr) => expr,
+            hir::ExprKind::MethodCall(method_name, receiver, [], ..) => {
+                if (method_name.ident.name == sym::as_str || method_name.ident.name == sym::as_ref) && {
+                    let arg_type = cx.typeck_results().expr_ty(receiver);
+                    let base_type = arg_type.peel_refs();
+                    base_type.is_str() || is_type_lang_item(cx, base_type, hir::LangItem::String)
+                } {
+                    receiver
+                } else {
+                    break;
+                }
+            },
+            _ => break,
+        };
+    }
+    arg_root
+}
+
+fn contains_call<'a>(cx: &LateContext<'a>, arg: &'a hir::Expr<'a>) -> bool {
+    for_each_expr(cx, arg, |expr| {
+        if matches!(expr.kind, hir::ExprKind::MethodCall { .. } | hir::ExprKind::Call { .. })
+            && !is_inside_always_const_context(cx.tcx, expr.hir_id)
+        {
+            ControlFlow::Break(())
+        } else {
+            ControlFlow::Continue(())
+        }
+    })
+    .is_some()
+}
diff --git a/clippy_lints/src/methods/filter_map.rs b/clippy_lints/src/methods/filter_map.rs
index 4dd54cf197450..5b8457bdd1640 100644
--- a/clippy_lints/src/methods/filter_map.rs
+++ b/clippy_lints/src/methods/filter_map.rs
@@ -106,7 +106,7 @@ enum CheckResult<'tcx> {
 
 impl<'tcx> OffendingFilterExpr<'tcx> {
     pub fn check_map_call(
-        &mut self,
+        &self,
         cx: &LateContext<'tcx>,
         map_body: &'tcx Body<'tcx>,
         map_param_id: HirId,
@@ -413,7 +413,7 @@ fn is_find_or_filter<'a>(
         }
 
         && let PatKind::Binding(_, filter_param_id, _, None) = filter_pat.kind
-        && let Some(mut offending_expr) = OffendingFilterExpr::hir(cx, filter_body.value, filter_param_id)
+        && let Some(offending_expr) = OffendingFilterExpr::hir(cx, filter_body.value, filter_param_id)
 
         && let ExprKind::Closure(&Closure { body: map_body_id, .. }) = map_arg.kind
         && let map_body = cx.tcx.hir_body(map_body_id)
diff --git a/clippy_lints/src/methods/filter_next.rs b/clippy_lints/src/methods/filter_next.rs
index 6c1a14fc88299..72f83b245a0cb 100644
--- a/clippy_lints/src/methods/filter_next.rs
+++ b/clippy_lints/src/methods/filter_next.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
+use clippy_utils::path_to_local_with_projections;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::implements_trait;
 use rustc_ast::{BindingMode, Mutability};
@@ -9,21 +10,6 @@ use rustc_span::sym;
 
 use super::FILTER_NEXT;
 
-fn path_to_local(expr: &hir::Expr<'_>) -> Option<hir::HirId> {
-    match expr.kind {
-        hir::ExprKind::Field(f, _) => path_to_local(f),
-        hir::ExprKind::Index(recv, _, _) => path_to_local(recv),
-        hir::ExprKind::Path(hir::QPath::Resolved(
-            _,
-            hir::Path {
-                res: rustc_hir::def::Res::Local(local),
-                ..
-            },
-        )) => Some(*local),
-        _ => None,
-    }
-}
-
 /// lint use of `filter().next()` for `Iterators`
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
@@ -44,7 +30,7 @@ pub(super) fn check<'tcx>(
             let iter_snippet = snippet(cx, recv.span, "..");
             // add note if not multi-line
             span_lint_and_then(cx, FILTER_NEXT, expr.span, msg, |diag| {
-                let (applicability, pat) = if let Some(id) = path_to_local(recv)
+                let (applicability, pat) = if let Some(id) = path_to_local_with_projections(recv)
                     && let hir::Node::Pat(pat) = cx.tcx.hir_node(id)
                     && let hir::PatKind::Binding(BindingMode(_, Mutability::Not), _, ident, _) = pat.kind
                 {
diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index f880f1f329ff7..f988323a8c134 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -7,12 +7,9 @@ mod unneeded_field_pattern;
 mod unneeded_wildcard_pattern;
 mod zero_prefixed_literal;
 
-use clippy_utils::diagnostics::span_lint;
 use clippy_utils::source::snippet_opt;
-use rustc_ast::ast::{Expr, ExprKind, Generics, LitFloatType, LitIntType, LitKind, NodeId, Pat, PatKind};
+use rustc_ast::ast::{Expr, ExprKind, Generics, LitFloatType, LitIntType, LitKind, Pat};
 use rustc_ast::token;
-use rustc_ast::visit::FnKind;
-use rustc_data_structures::fx::FxHashMap;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_session::declare_lint_pass;
 use rustc_span::Span;
@@ -60,29 +57,6 @@ declare_clippy_lint! {
     "struct fields bound to a wildcard instead of using `..`"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for function arguments having the similar names
-    /// differing by an underscore.
-    ///
-    /// ### Why is this bad?
-    /// It affects code readability.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// fn foo(a: i32, _a: i32) {}
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// fn bar(a: i32, _b: i32) {}
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub DUPLICATE_UNDERSCORE_ARGUMENT,
-    style,
-    "function arguments having names which only differ by an underscore"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Warns on hexadecimal literals with mixed-case letter
@@ -330,7 +304,6 @@ declare_clippy_lint! {
 
 declare_lint_pass!(MiscEarlyLints => [
     UNNEEDED_FIELD_PATTERN,
-    DUPLICATE_UNDERSCORE_ARGUMENT,
     MIXED_CASE_HEX_LITERALS,
     UNSEPARATED_LITERAL_SUFFIX,
     SEPARATED_LITERAL_SUFFIX,
@@ -359,32 +332,6 @@ impl EarlyLintPass for MiscEarlyLints {
         unneeded_wildcard_pattern::check(cx, pat);
     }
 
-    fn check_fn(&mut self, cx: &EarlyContext<'_>, fn_kind: FnKind<'_>, _: Span, _: NodeId) {
-        let mut registered_names: FxHashMap<String, Span> = FxHashMap::default();
-
-        for arg in &fn_kind.decl().inputs {
-            if let PatKind::Ident(_, ident, None) = arg.pat.kind {
-                let arg_name = ident.to_string();
-
-                if let Some(arg_name) = arg_name.strip_prefix('_') {
-                    if let Some(correspondence) = registered_names.get(arg_name) {
-                        span_lint(
-                            cx,
-                            DUPLICATE_UNDERSCORE_ARGUMENT,
-                            *correspondence,
-                            format!(
-                                "`{arg_name}` already exists, having another argument having almost the same \
-                                 name makes code comprehension and documentation more difficult"
-                            ),
-                        );
-                    }
-                } else {
-                    registered_names.insert(arg_name, arg.pat.span);
-                }
-            }
-        }
-    }
-
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
         if expr.span.in_external_macro(cx.sess().source_map()) {
             return;
@@ -404,7 +351,7 @@ impl MiscEarlyLints {
         // See <https://github.com/rust-lang/rust-clippy/issues/4507> for a regression.
         // FIXME: Find a better way to detect those cases.
         let lit_snip = match snippet_opt(cx, span) {
-            Some(snip) if snip.chars().next().is_some_and(|c| c.is_ascii_digit()) => snip,
+            Some(snip) if snip.starts_with(|c: char| c.is_ascii_digit()) => snip,
             _ => return,
         };
 
diff --git a/clippy_lints/src/mixed_read_write_in_expression.rs b/clippy_lints/src/mixed_read_write_in_expression.rs
index a489c0a4a5a18..3b44d4b60d320 100644
--- a/clippy_lints/src/mixed_read_write_in_expression.rs
+++ b/clippy_lints/src/mixed_read_write_in_expression.rs
@@ -134,7 +134,7 @@ impl<'tcx> DivergenceVisitor<'_, 'tcx> {
         }
     }
 
-    fn report_diverging_sub_expr(&mut self, e: &Expr<'_>) {
+    fn report_diverging_sub_expr(&self, e: &Expr<'_>) {
         if let Some(macro_call) = root_macro_call_first_node(self.cx, e)
             && self.cx.tcx.is_diagnostic_item(sym::todo_macro, macro_call.def_id)
         {
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index fa5afcc008741..6ae26156bc44c 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -166,7 +166,9 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBool {
                     applicability,
                 );
             };
-            if let Some((a, b)) = fetch_bool_block(then).and_then(|a| Some((a, fetch_bool_block(else_expr)?))) {
+            if let Some(a) = fetch_bool_block(then)
+                && let Some(b) = fetch_bool_block(else_expr)
+            {
                 match (a, b) {
                     (RetBool(true), RetBool(true)) | (Bool(true), Bool(true)) => {
                         span_lint(
diff --git a/clippy_lints/src/needless_borrows_for_generic_args.rs b/clippy_lints/src/needless_borrows_for_generic_args.rs
index 120a4b98a65ab..c7c4976aeb7b2 100644
--- a/clippy_lints/src/needless_borrows_for_generic_args.rs
+++ b/clippy_lints/src/needless_borrows_for_generic_args.rs
@@ -59,7 +59,7 @@ declare_clippy_lint! {
 
 pub struct NeedlessBorrowsForGenericArgs<'tcx> {
     /// Stack of (body owner, `PossibleBorrowerMap`) pairs. Used by
-    /// `needless_borrow_impl_arg_position` to determine when a borrowed expression can instead
+    /// [`needless_borrow_count`] to determine when a borrowed expression can instead
     /// be moved.
     possible_borrowers: Vec<(LocalDefId, PossibleBorrowerMap<'tcx, 'tcx>)>,
 
diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 72e6503e7e495..0d6666eed455c 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -305,11 +305,12 @@ fn check_unnecessary_operation(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
             for e in reduced {
                 if let Some(snip) = e.span.get_source_text(cx) {
                     snippet.push_str(&snip);
-                    snippet.push(';');
+                    snippet.push_str("; ");
                 } else {
                     return;
                 }
             }
+            snippet.pop(); // remove the last space
             span_lint_hir_and_then(
                 cx,
                 UNNECESSARY_OPERATION,
diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index 8a5a6f4a4dc1e..2fffc4244a736 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -92,7 +92,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub DECLARE_INTERIOR_MUTABLE_CONST,
-    style,
+    suspicious,
     "declaring `const` with interior mutability"
 }
 
diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index c5873589b26f3..1961ac1516dad 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -248,6 +248,11 @@ impl SimilarNamesNameVisitor<'_, '_, '_> {
                 continue;
             }
 
+            // Skip similarity check if both names are exactly 3 characters
+            if count == 3 && existing_name.len == 3 {
+                continue;
+            }
+
             let dissimilar = match existing_name.len.cmp(&count) {
                 Ordering::Greater => existing_name.len - count != 1 || levenstein_not_1(interned_name, existing_str),
                 Ordering::Less => count - existing_name.len != 1 || levenstein_not_1(existing_str, interned_name),
diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index ba8f6354d976a..a42763172f565 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -173,7 +173,7 @@ impl Params {
     }
 
     /// Sets the `apply_lint` flag on each parameter.
-    fn flag_for_linting(&mut self) {
+    fn flag_for_linting(&self) {
         // Stores the list of parameters currently being resolved. Needed to avoid cycles.
         let mut eval_stack = Vec::new();
         for param in &self.params {
diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index 466beb04b0747..ea5b81aec31ea 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -325,7 +325,7 @@ impl ArithmeticSideEffects {
         self.issue_lint(cx, expr);
     }
 
-    fn should_skip_expr<'tcx>(&mut self, cx: &LateContext<'tcx>, expr: &hir::Expr<'tcx>) -> bool {
+    fn should_skip_expr<'tcx>(&self, cx: &LateContext<'tcx>, expr: &hir::Expr<'tcx>) -> bool {
         is_lint_allowed(cx, ARITHMETIC_SIDE_EFFECTS, expr.hir_id)
             || self.expr_span.is_some()
             || self.const_span.is_some_and(|sp| sp.contains(expr.span))
diff --git a/clippy_lints/src/operators/numeric_arithmetic.rs b/clippy_lints/src/operators/numeric_arithmetic.rs
index e6be536ca0f4e..9b1b063c4737d 100644
--- a/clippy_lints/src/operators/numeric_arithmetic.rs
+++ b/clippy_lints/src/operators/numeric_arithmetic.rs
@@ -13,7 +13,7 @@ pub struct Context {
     const_span: Option<Span>,
 }
 impl Context {
-    fn skip_expr(&mut self, e: &hir::Expr<'_>) -> bool {
+    fn skip_expr(&self, e: &hir::Expr<'_>) -> bool {
         self.expr_id.is_some() || self.const_span.is_some_and(|span| span.contains(e.span))
     }
 
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index d7b4a03aa5370..1b1e77bbea8fb 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -120,7 +120,7 @@ impl PassByRefOrValue {
         }
     }
 
-    fn check_poly_fn(&mut self, cx: &LateContext<'_>, def_id: LocalDefId, decl: &FnDecl<'_>, span: Option<Span>) {
+    fn check_poly_fn(&self, cx: &LateContext<'_>, def_id: LocalDefId, decl: &FnDecl<'_>, span: Option<Span>) {
         if self.avoid_breaking_exported_api && cx.effective_visibilities.is_exported(def_id) {
             return;
         }
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index b3058c51afdbe..9eed46460a613 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -237,7 +237,7 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
             .collect();
         let results = check_ptr_arg_usage(cx, body, &lint_args);
 
-        for (result, args) in results.iter().zip(lint_args.iter()).filter(|(r, _)| !r.skip) {
+        for (result, args) in iter::zip(&results, &lint_args).filter(|(r, _)| !r.skip) {
             span_lint_hir_and_then(cx, PTR_ARG, args.emission_id, args.span, args.build_msg(), |diag| {
                 diag.multipart_suggestion(
                     "change this to",
@@ -386,7 +386,6 @@ 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>,
@@ -413,13 +412,13 @@ fn check_fn_args<'cx, 'tcx: 'cx>(
                     Some(sym::Vec) => (
                         [(sym::clone, ".to_owned()")].as_slice(),
                         DerefTy::Slice(
-                            name.args.and_then(|args| args.args.first()).and_then(|arg| {
-                                if let GenericArg::Type(ty) = arg {
-                                    Some(ty.span)
-                                } else {
-                                    None
-                                }
-                            }),
+                            if let Some(name_args) = name.args
+                                && let [GenericArg::Type(ty), ..] = name_args.args
+                            {
+                                Some(ty.span)
+                            } else {
+                                None
+                            },
                             args.type_at(0),
                         ),
                     ),
@@ -432,33 +431,29 @@ fn check_fn_args<'cx, 'tcx: 'cx>(
                         DerefTy::Path,
                     ),
                     Some(sym::Cow) if mutability == Mutability::Not => {
-                        if let Some((lifetime, ty)) = name.args.and_then(|args| {
-                            if let [GenericArg::Lifetime(lifetime), ty] = args.args {
-                                return Some((lifetime, ty));
-                            }
-                            None
-                        }) {
+                        if let Some(name_args) = name.args
+                            && let [GenericArg::Lifetime(lifetime), ty] = name_args.args
+                        {
                             if let LifetimeKind::Param(param_def_id) = lifetime.kind
                                 && !lifetime.is_anonymous()
                                 && fn_sig
                                     .output()
                                     .walk()
-                                    .filter_map(|arg| {
-                                        arg.as_region().and_then(|lifetime| match lifetime.kind() {
-                                            ty::ReEarlyParam(r) => Some(
-                                                cx.tcx
-                                                    .generics_of(cx.tcx.parent(param_def_id.to_def_id()))
-                                                    .region_param(r, cx.tcx)
-                                                    .def_id,
-                                            ),
-                                            ty::ReBound(_, r) => r.kind.get_id(),
-                                            ty::ReLateParam(r) => r.kind.get_id(),
-                                            ty::ReStatic
-                                            | ty::ReVar(_)
-                                            | ty::RePlaceholder(_)
-                                            | ty::ReErased
-                                            | ty::ReError(_) => None,
-                                        })
+                                    .filter_map(ty::GenericArg::as_region)
+                                    .filter_map(|lifetime| match lifetime.kind() {
+                                        ty::ReEarlyParam(r) => Some(
+                                            cx.tcx
+                                                .generics_of(cx.tcx.parent(param_def_id.to_def_id()))
+                                                .region_param(r, cx.tcx)
+                                                .def_id,
+                                        ),
+                                        ty::ReBound(_, r) => r.kind.get_id(),
+                                        ty::ReLateParam(r) => r.kind.get_id(),
+                                        ty::ReStatic
+                                        | ty::ReVar(_)
+                                        | ty::RePlaceholder(_)
+                                        | ty::ReErased
+                                        | ty::ReError(_) => None,
                                     })
                                     .any(|def_id| def_id.as_local().is_some_and(|def_id| def_id == param_def_id))
                             {
@@ -627,12 +622,16 @@ fn check_ptr_arg_usage<'tcx>(cx: &LateContext<'tcx>, body: &Body<'tcx>, args: &[
                         }
                     }
 
+                    // If the expression's type gets adjusted down to the deref type, we might as
+                    // well have started with that deref type -- the lint should fire
                     let deref_ty = args.deref_ty.ty(self.cx);
                     let adjusted_ty = self.cx.typeck_results().expr_ty_adjusted(e).peel_refs();
                     if adjusted_ty == deref_ty {
                         return;
                     }
 
+                    // If the expression's type is constrained by `dyn Trait`, see if the deref
+                    // type implements the trait(s) as well, and if so, the lint should fire
                     if let ty::Dynamic(preds, ..) = adjusted_ty.kind()
                         && matches_preds(self.cx, deref_ty, preds)
                     {
diff --git a/clippy_lints/src/raw_strings.rs b/clippy_lints/src/raw_strings.rs
index 6a79cae32a596..943e662479e9f 100644
--- a/clippy_lints/src/raw_strings.rs
+++ b/clippy_lints/src/raw_strings.rs
@@ -103,15 +103,7 @@ impl EarlyLintPass for RawStrings {
 }
 
 impl RawStrings {
-    fn check_raw_string(
-        &mut self,
-        cx: &EarlyContext<'_>,
-        str: &str,
-        lit_span: Span,
-        prefix: &str,
-        max: u8,
-        descr: &str,
-    ) {
+    fn check_raw_string(&self, cx: &EarlyContext<'_>, str: &str, lit_span: Span, prefix: &str, max: u8, descr: &str) {
         if !str.contains(['\\', '"']) {
             span_lint_and_then(
                 cx,
diff --git a/clippy_lints/src/redundant_pub_crate.rs b/clippy_lints/src/redundant_pub_crate.rs
index 902e8af7ec48d..0c1c664f1117d 100644
--- a/clippy_lints/src/redundant_pub_crate.rs
+++ b/clippy_lints/src/redundant_pub_crate.rs
@@ -88,8 +88,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantPubCrate {
 // We ignore macro exports. And `ListStem` uses, which aren't interesting.
 fn is_ignorable_export<'tcx>(item: &'tcx Item<'tcx>) -> bool {
     if let ItemKind::Use(path, kind) = item.kind {
-        let ignore = matches!(path.res.macro_ns, Some(Res::Def(DefKind::Macro(_), _)))
-            || kind == UseKind::ListStem;
+        let ignore = matches!(path.res.macro_ns, Some(Res::Def(DefKind::Macro(_), _))) || kind == UseKind::ListStem;
         if ignore {
             return true;
         }
diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs
index 4bff37216eda8..3bbcad12a3199 100644
--- a/clippy_lints/src/reference.rs
+++ b/clippy_lints/src/reference.rs
@@ -1,10 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::{SpanRangeExt, snippet_with_applicability};
-use rustc_ast::ast::{Expr, ExprKind, Mutability, UnOp};
+use clippy_utils::source::snippet;
+use clippy_utils::sugg::{Sugg, has_enclosing_paren};
+use clippy_utils::ty::adjust_derefs_manually_drop;
 use rustc_errors::Applicability;
-use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_hir::{Expr, ExprKind, HirId, Node, UnOp};
+use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
-use rustc_span::{BytePos, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -37,17 +38,12 @@ declare_clippy_lint! {
 
 declare_lint_pass!(DerefAddrOf => [DEREF_ADDROF]);
 
-fn without_parens(mut e: &Expr) -> &Expr {
-    while let ExprKind::Paren(ref child_e) = e.kind {
-        e = child_e;
-    }
-    e
-}
-
-impl EarlyLintPass for DerefAddrOf {
-    fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &Expr) {
-        if let ExprKind::Unary(UnOp::Deref, ref deref_target) = e.kind
-            && let ExprKind::AddrOf(_, ref mutability, ref addrof_target) = without_parens(deref_target).kind
+impl LateLintPass<'_> for DerefAddrOf {
+    fn check_expr(&mut self, cx: &LateContext<'_>, e: &Expr<'_>) {
+        if !e.span.from_expansion()
+            && let ExprKind::Unary(UnOp::Deref, deref_target) = e.kind
+            && !deref_target.span.from_expansion()
+            && let ExprKind::AddrOf(_, _, addrof_target) = deref_target.kind
             // NOTE(tesuji): `*&` forces rustc to const-promote the array to `.rodata` section.
             // See #12854 for details.
             && !matches!(addrof_target.kind, ExprKind::Array(_))
@@ -55,57 +51,82 @@ impl EarlyLintPass for DerefAddrOf {
             && !addrof_target.span.from_expansion()
         {
             let mut applicability = Applicability::MachineApplicable;
-            let sugg = if e.span.from_expansion() {
-                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: Span| {
-                        span.get_source_text(cx)
-                            .and_then(|snip| {
-                                #[expect(clippy::cast_possible_truncation)]
-                                snip.find(|c: char| !c.is_whitespace())
-                                    .map(|pos| span.lo() + BytePos(pos as u32))
-                            })
-                            .map_or(span, |start_no_whitespace| e.span.with_lo(start_no_whitespace))
-                    };
+            let mut sugg = || Sugg::hir_with_applicability(cx, addrof_target, "_", &mut applicability);
 
-                    let mut generate_snippet = |pattern: &str| {
-                        #[expect(clippy::cast_possible_truncation)]
-                        macro_source.rfind(pattern).map(|pattern_pos| {
-                            let rpos = pattern_pos + pattern.len();
-                            let span_after_ref = e.span.with_lo(BytePos(e.span.lo().0 + rpos as u32));
-                            let span = trim_leading_whitespaces(span_after_ref);
-                            snippet_with_applicability(cx, span, "_", &mut applicability)
-                        })
-                    };
+            // If this expression is an explicit `DerefMut` of a `ManuallyDrop` reached through a
+            // union, we may remove the reference if we are at the point where the implicit
+            // dereference would take place. Otherwise, we should not lint.
+            let sugg = match is_manually_drop_through_union(cx, e.hir_id, addrof_target) {
+                ManuallyDropThroughUnion::Directly => sugg().deref(),
+                ManuallyDropThroughUnion::Indirect => return,
+                ManuallyDropThroughUnion::No => sugg(),
+            };
+
+            let sugg = if has_enclosing_paren(snippet(cx, e.span, "")) {
+                sugg.maybe_paren()
+            } else {
+                sugg
+            };
+
+            span_lint_and_sugg(
+                cx,
+                DEREF_ADDROF,
+                e.span,
+                "immediately dereferencing a reference",
+                "try",
+                sugg.to_string(),
+                applicability,
+            );
+        }
+    }
+}
+
+/// Is this a `ManuallyDrop` reached through a union, and when is `DerefMut` called on it?
+enum ManuallyDropThroughUnion {
+    /// `ManuallyDrop` reached through a union and immediately explicitely dereferenced
+    Directly,
+    /// `ManuallyDrop` reached through a union, and dereferenced later on
+    Indirect,
+    /// Any other situation
+    No,
+}
 
-                    if *mutability == Mutability::Mut {
-                        generate_snippet("mut")
+/// Check if `addrof_target` is part of an access to a `ManuallyDrop` entity reached through a
+/// union, and when it is dereferenced using `DerefMut` starting from `expr_id` and going up.
+fn is_manually_drop_through_union(
+    cx: &LateContext<'_>,
+    expr_id: HirId,
+    addrof_target: &Expr<'_>,
+) -> ManuallyDropThroughUnion {
+    if is_reached_through_union(cx, addrof_target) {
+        let typeck = cx.typeck_results();
+        for (idx, id) in std::iter::once(expr_id)
+            .chain(cx.tcx.hir_parent_id_iter(expr_id))
+            .enumerate()
+        {
+            if let Node::Expr(expr) = cx.tcx.hir_node(id) {
+                if adjust_derefs_manually_drop(typeck.expr_adjustments(expr), typeck.expr_ty(expr)) {
+                    return if idx == 0 {
+                        ManuallyDropThroughUnion::Directly
                     } else {
-                        generate_snippet("&")
-                    }
-                } else {
-                    Some(snippet_with_applicability(cx, e.span, "_", &mut applicability))
+                        ManuallyDropThroughUnion::Indirect
+                    };
                 }
             } else {
-                Some(snippet_with_applicability(
-                    cx,
-                    addrof_target.span,
-                    "_",
-                    &mut applicability,
-                ))
-            };
-            if let Some(sugg) = sugg {
-                span_lint_and_sugg(
-                    cx,
-                    DEREF_ADDROF,
-                    e.span,
-                    "immediately dereferencing a reference",
-                    "try",
-                    sugg.to_string(),
-                    applicability,
-                );
+                break;
             }
         }
     }
+    ManuallyDropThroughUnion::No
+}
+
+/// Checks whether `expr` denotes an object reached through a union
+fn is_reached_through_union(cx: &LateContext<'_>, mut expr: &Expr<'_>) -> bool {
+    while let ExprKind::Field(parent, _) | ExprKind::Index(parent, _, _) = expr.kind {
+        if cx.typeck_results().expr_ty_adjusted(parent).is_union() {
+            return true;
+        }
+        expr = parent;
+    }
+    false
 }
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 5ecbb56925ec6..76ab3cdae22ef 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -380,7 +380,7 @@ impl<'tcx> IndexBinding<'_, 'tcx> {
         }
     }
 
-    fn is_used_other_than_swapping(&mut self, idx_ident: Ident) -> bool {
+    fn is_used_other_than_swapping(&self, idx_ident: Ident) -> bool {
         if Self::is_used_slice_indexed(self.swap1_idx, idx_ident)
             || Self::is_used_slice_indexed(self.swap2_idx, idx_ident)
         {
@@ -389,7 +389,7 @@ impl<'tcx> IndexBinding<'_, 'tcx> {
         self.is_used_after_swap(idx_ident)
     }
 
-    fn is_used_after_swap(&mut self, idx_ident: Ident) -> bool {
+    fn is_used_after_swap(&self, idx_ident: Ident) -> bool {
         let mut v = IndexBindingVisitor {
             idx: idx_ident,
             suggest_span: self.suggest_span,
diff --git a/clippy_lints/src/transmute/eager_transmute.rs b/clippy_lints/src/transmute/eager_transmute.rs
index 535c044f49e68..97e68b3df94e4 100644
--- a/clippy_lints/src/transmute/eager_transmute.rs
+++ b/clippy_lints/src/transmute/eager_transmute.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{eq_expr_value, path_to_local, sym};
+use clippy_utils::{eq_expr_value, path_to_local_with_projections, sym};
 use rustc_abi::WrappingRange;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, Node};
@@ -63,11 +63,7 @@ fn binops_with_local(cx: &LateContext<'_>, local_expr: &Expr<'_>, expr: &Expr<'_
 /// Checks if an expression is a path to a local variable (with optional projections), e.g.
 /// `x.field[0].field2` would return true.
 fn is_local_with_projections(expr: &Expr<'_>) -> bool {
-    match expr.kind {
-        ExprKind::Path(_) => path_to_local(expr).is_some(),
-        ExprKind::Field(expr, _) | ExprKind::Index(expr, ..) => is_local_with_projections(expr),
-        _ => false,
-    }
+    path_to_local_with_projections(expr).is_some()
 }
 
 pub(super) fn check<'tcx>(
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index d5112e2c3f97a..1c7bb4314ddf5 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -105,7 +105,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub CROSSPOINTER_TRANSMUTE,
-    complexity,
+    suspicious,
     "transmutes that have to or from types that are a pointer to the other"
 }
 
diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index 1c52de52619ef..ba0d4de5f3b3b 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -202,79 +202,41 @@ impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
         };
 
         let item_has_safety_comment = item_has_safety_comment(cx, item);
-        match (&item.kind, item_has_safety_comment) {
-            // lint unsafe impl without safety comment
-            (ItemKind::Impl(Impl { of_trait: Some(of_trait), .. }), HasSafetyComment::No) if of_trait.safety.is_unsafe() => {
-                if !is_lint_allowed(cx, UNDOCUMENTED_UNSAFE_BLOCKS, item.hir_id())
-                    && !is_unsafe_from_proc_macro(cx, item.span)
-                {
-                    let source_map = cx.tcx.sess.source_map();
-                    let span = if source_map.is_multiline(item.span) {
-                        source_map.span_until_char(item.span, '\n')
-                    } else {
-                        item.span
-                    };
-
-                    #[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",
-                        |diag| {
-                            diag.help("consider adding a safety comment on the preceding line");
-                        },
-                    );
-                }
-            },
-            // lint safe impl with unnecessary safety comment
-            (ItemKind::Impl(Impl { of_trait: Some(of_trait), .. }), HasSafetyComment::Yes(pos)) if of_trait.safety.is_safe() => {
-                if !is_lint_allowed(cx, UNNECESSARY_SAFETY_COMMENT, item.hir_id()) {
-                    let (span, help_span) = mk_spans(pos);
-
-                    span_lint_and_then(
-                        cx,
-                        UNNECESSARY_SAFETY_COMMENT,
-                        span,
-                        "impl has unnecessary safety comment",
-                        |diag| {
-                            diag.span_help(help_span, "consider removing the safety comment");
-                        },
-                    );
-                }
-            },
-            (ItemKind::Impl(_), _) => {},
-            // const and static items only need a safety comment if their body is an unsafe block, lint otherwise
-            (&ItemKind::Const(.., body) | &ItemKind::Static(.., body), HasSafetyComment::Yes(pos)) => {
-                if !is_lint_allowed(cx, UNNECESSARY_SAFETY_COMMENT, body.hir_id) {
-                    let body = cx.tcx.hir_body(body);
-                    if !matches!(
-                        body.value.kind, hir::ExprKind::Block(block, _)
-                        if block.rules == BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided)
-                    ) {
-                        let (span, help_span) = mk_spans(pos);
-
-                        span_lint_and_then(
-                            cx,
-                            UNNECESSARY_SAFETY_COMMENT,
-                            span,
-                            format!(
-                                "{} has unnecessary safety comment",
-                                cx.tcx.def_descr(item.owner_id.to_def_id()),
-                            ),
-                            |diag| {
-                                diag.span_help(help_span, "consider removing the safety comment");
-                            },
-                        );
-                    }
-                }
-            },
-            // Aside from unsafe impls and consts/statics with an unsafe block, items in general
-            // do not have safety invariants that need to be documented, so lint those.
-            (_, HasSafetyComment::Yes(pos)) => {
-                if !is_lint_allowed(cx, UNNECESSARY_SAFETY_COMMENT, item.hir_id()) {
-                    let (span, help_span) = mk_spans(pos);
+        match item_has_safety_comment {
+            HasSafetyComment::Yes(pos) => check_has_safety_comment(cx, item, mk_spans(pos)),
+            HasSafetyComment::No => check_has_no_safety_comment(cx, item),
+            HasSafetyComment::Maybe => {},
+        }
+    }
+}
 
+fn check_has_safety_comment(cx: &LateContext<'_>, item: &hir::Item<'_>, (span, help_span): (Span, Span)) {
+    match &item.kind {
+        ItemKind::Impl(Impl {
+            of_trait: Some(of_trait),
+            ..
+        }) if of_trait.safety.is_safe() => {
+            if !is_lint_allowed(cx, UNNECESSARY_SAFETY_COMMENT, item.hir_id()) {
+                span_lint_and_then(
+                    cx,
+                    UNNECESSARY_SAFETY_COMMENT,
+                    span,
+                    "impl has unnecessary safety comment",
+                    |diag| {
+                        diag.span_help(help_span, "consider removing the safety comment");
+                    },
+                );
+            }
+        },
+        ItemKind::Impl(_) => {},
+        // const and static items only need a safety comment if their body is an unsafe block, lint otherwise
+        &ItemKind::Const(.., body) | &ItemKind::Static(.., body) => {
+            if !is_lint_allowed(cx, UNNECESSARY_SAFETY_COMMENT, body.hir_id) {
+                let body = cx.tcx.hir_body(body);
+                if !matches!(
+                    body.value.kind, hir::ExprKind::Block(block, _)
+                    if block.rules == BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided)
+                ) {
                     span_lint_and_then(
                         cx,
                         UNNECESSARY_SAFETY_COMMENT,
@@ -288,12 +250,56 @@ impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
                         },
                     );
                 }
-            },
-            _ => (),
-        }
+            }
+        },
+        // Aside from unsafe impls and consts/statics with an unsafe block, items in general
+        // do not have safety invariants that need to be documented, so lint those.
+        _ => {
+            if !is_lint_allowed(cx, UNNECESSARY_SAFETY_COMMENT, item.hir_id()) {
+                span_lint_and_then(
+                    cx,
+                    UNNECESSARY_SAFETY_COMMENT,
+                    span,
+                    format!(
+                        "{} has unnecessary safety comment",
+                        cx.tcx.def_descr(item.owner_id.to_def_id()),
+                    ),
+                    |diag| {
+                        diag.span_help(help_span, "consider removing the safety comment");
+                    },
+                );
+            }
+        },
     }
 }
+fn check_has_no_safety_comment(cx: &LateContext<'_>, item: &hir::Item<'_>) {
+    if let ItemKind::Impl(Impl {
+        of_trait: Some(of_trait),
+        ..
+    }) = item.kind
+        && of_trait.safety.is_unsafe()
+        && !is_lint_allowed(cx, UNDOCUMENTED_UNSAFE_BLOCKS, item.hir_id())
+        && !is_unsafe_from_proc_macro(cx, item.span)
+    {
+        let source_map = cx.tcx.sess.source_map();
+        let span = if source_map.is_multiline(item.span) {
+            source_map.span_until_char(item.span, '\n')
+        } else {
+            item.span
+        };
 
+        #[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",
+            |diag| {
+                diag.help("consider adding a safety comment on the preceding line");
+            },
+        );
+    }
+}
 fn expr_has_unnecessary_safety_comment<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx hir::Expr<'tcx>,
@@ -505,7 +511,8 @@ fn item_has_safety_comment(cx: &LateContext<'_>, item: &hir::Item<'_>) -> HasSaf
         },
         Node::Stmt(stmt) => {
             if let Node::Block(block) = cx.tcx.parent_hir_node(stmt.hir_id) {
-                walk_span_to_context(block.span, SyntaxContext::root()).map(Span::lo)
+                walk_span_to_context(block.span, SyntaxContext::root())
+                    .map(|sp| CommentStartBeforeItem::Offset(sp.lo()))
             } else {
                 // Problem getting the parent node. Pretend a comment was found.
                 return HasSafetyComment::Maybe;
@@ -518,10 +525,12 @@ fn item_has_safety_comment(cx: &LateContext<'_>, item: &hir::Item<'_>) -> HasSaf
     };
 
     let source_map = cx.sess().source_map();
+    // If the comment is in the first line of the file, there is no preceding line
     if let Some(comment_start) = comment_start
         && let Ok(unsafe_line) = source_map.lookup_line(item.span.lo())
-        && let Ok(comment_start_line) = source_map.lookup_line(comment_start)
-        && Arc::ptr_eq(&unsafe_line.sf, &comment_start_line.sf)
+        && let Ok(comment_start_line) = source_map.lookup_line(comment_start.into())
+        && let include_first_line_of_file = matches!(comment_start, CommentStartBeforeItem::Start)
+        && (include_first_line_of_file || Arc::ptr_eq(&unsafe_line.sf, &comment_start_line.sf))
         && let Some(src) = unsafe_line.sf.src.as_deref()
     {
         return if comment_start_line.line >= unsafe_line.line {
@@ -529,7 +538,8 @@ fn item_has_safety_comment(cx: &LateContext<'_>, item: &hir::Item<'_>) -> HasSaf
         } else {
             match text_has_safety_comment(
                 src,
-                &unsafe_line.sf.lines()[comment_start_line.line + 1..=unsafe_line.line],
+                &unsafe_line.sf.lines()
+                    [(comment_start_line.line + usize::from(!include_first_line_of_file))..=unsafe_line.line],
                 unsafe_line.sf.start_pos,
             ) {
                 Some(b) => HasSafetyComment::Yes(b),
@@ -592,12 +602,27 @@ fn stmt_has_safety_comment(
     HasSafetyComment::Maybe
 }
 
+#[derive(Clone, Copy, Debug)]
+enum CommentStartBeforeItem {
+    Offset(BytePos),
+    Start,
+}
+
+impl From<CommentStartBeforeItem> for BytePos {
+    fn from(value: CommentStartBeforeItem) -> Self {
+        match value {
+            CommentStartBeforeItem::Offset(loc) => loc,
+            CommentStartBeforeItem::Start => BytePos(0),
+        }
+    }
+}
+
 fn comment_start_before_item_in_mod(
     cx: &LateContext<'_>,
     parent_mod: &hir::Mod<'_>,
     parent_mod_span: Span,
     item: &hir::Item<'_>,
-) -> Option<BytePos> {
+) -> Option<CommentStartBeforeItem> {
     parent_mod.item_ids.iter().enumerate().find_map(|(idx, item_id)| {
         if *item_id == item.item_id() {
             if idx == 0 {
@@ -605,15 +630,18 @@ fn comment_start_before_item_in_mod(
                 // ^------------------------------------------^ returns the start of this span
                 // ^---------------------^ finally checks comments in this range
                 if let Some(sp) = walk_span_to_context(parent_mod_span, SyntaxContext::root()) {
-                    return Some(sp.lo());
+                    return Some(CommentStartBeforeItem::Offset(sp.lo()));
                 }
             } else {
                 // some_item /* comment */ unsafe impl T {}
                 // ^-------^ returns the end of this span
                 //         ^---------------^ finally checks comments in this range
                 let prev_item = cx.tcx.hir_item(parent_mod.item_ids[idx - 1]);
+                if prev_item.span.is_dummy() {
+                    return Some(CommentStartBeforeItem::Start);
+                }
                 if let Some(sp) = walk_span_to_context(prev_item.span, SyntaxContext::root()) {
-                    return Some(sp.hi());
+                    return Some(CommentStartBeforeItem::Offset(sp.hi()));
                 }
             }
         }
@@ -668,7 +696,7 @@ fn get_body_search_span(cx: &LateContext<'_>) -> Option<Span> {
             }) => {
                 return maybe_mod_item
                     .and_then(|item| comment_start_before_item_in_mod(cx, mod_, *span, &item))
-                    .map(|comment_start| mod_.spans.inner_span.with_lo(comment_start))
+                    .map(|comment_start| mod_.spans.inner_span.with_lo(comment_start.into()))
                     .or(Some(*span));
             },
             node if let Some((span, _)) = span_and_hid_of_item_alike_node(&node)
diff --git a/clippy_lints/src/unnecessary_box_returns.rs b/clippy_lints/src/unnecessary_box_returns.rs
index 2b7d3dc0c90a9..6e3e41f08ee52 100644
--- a/clippy_lints/src/unnecessary_box_returns.rs
+++ b/clippy_lints/src/unnecessary_box_returns.rs
@@ -55,7 +55,7 @@ impl UnnecessaryBoxReturns {
         }
     }
 
-    fn check_fn_item(&mut self, cx: &LateContext<'_>, decl: &FnDecl<'_>, def_id: LocalDefId, name: Symbol) {
+    fn check_fn_item(&self, cx: &LateContext<'_>, decl: &FnDecl<'_>, def_id: LocalDefId, name: Symbol) {
         // we don't want to tell someone to break an exported function if they ask us not to
         if self.avoid_breaking_exported_api && cx.effective_visibilities.is_exported(def_id) {
             return;
diff --git a/clippy_lints/src/unnecessary_semicolon.rs b/clippy_lints/src/unnecessary_semicolon.rs
index f1d1a76d0c2df..76e24b6bf8058 100644
--- a/clippy_lints/src/unnecessary_semicolon.rs
+++ b/clippy_lints/src/unnecessary_semicolon.rs
@@ -86,7 +86,9 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessarySemicolon {
                 expr.kind,
                 ExprKind::If(..) | ExprKind::Match(_, _, MatchSource::Normal | MatchSource::Postfix)
             )
-            && cx.typeck_results().expr_ty(expr) == cx.tcx.types.unit
+            && cx.typeck_results().expr_ty(expr).is_unit()
+            // if a stmt has attrs, then turning it into an expr will break the code, since attrs aren't allowed on exprs
+            && cx.tcx.hir_attrs(stmt.hir_id).is_empty()
         {
             if let Some(block_is_unit) = self.is_last_in_block(stmt) {
                 if cx.tcx.sess.edition() <= Edition2021 && leaks_droppable_temporary_with_limited_lifetime(cx, expr) {
diff --git a/clippy_lints/src/unnested_or_patterns.rs b/clippy_lints/src/unnested_or_patterns.rs
index e9ad578da2f58..8b278d98a30e0 100644
--- a/clippy_lints/src/unnested_or_patterns.rs
+++ b/clippy_lints/src/unnested_or_patterns.rs
@@ -284,14 +284,14 @@ fn transform_with_focus_on_idx(alternatives: &mut ThinVec<Box<Pat>>, focus_idx:
             |k, ps1, idx| matches!(
                 k,
                 TupleStruct(qself2, path2, ps2)
-                    if eq_maybe_qself(qself1.as_ref(), qself2.as_ref())
+                    if eq_maybe_qself(qself1.as_deref(), qself2.as_deref())
                        && eq_path(path1, path2) && eq_pre_post(ps1, ps2, idx)
             ),
             |k| always_pat!(k, TupleStruct(_, _, ps) => ps),
         ),
         // Transform a record pattern `S { fp_0, ..., fp_n }`.
         Struct(qself1, path1, fps1, rest1) => {
-            extend_with_struct_pat(qself1.as_ref(), path1, fps1, *rest1, start, alternatives)
+            extend_with_struct_pat(qself1.as_deref(), path1, fps1, *rest1, start, alternatives)
         },
     };
 
@@ -304,7 +304,7 @@ fn transform_with_focus_on_idx(alternatives: &mut ThinVec<Box<Pat>>, focus_idx:
 /// So when we fixate on some `ident_k: pat_k`, we try to find `ident_k` in the other pattern
 /// and check that all `fp_i` where `i ∈ ((0...n) \ k)` between two patterns are equal.
 fn extend_with_struct_pat(
-    qself1: Option<&Box<ast::QSelf>>,
+    qself1: Option<&ast::QSelf>,
     path1: &ast::Path,
     fps1: &mut [ast::PatField],
     rest1: ast::PatFieldsRest,
@@ -319,7 +319,7 @@ fn extend_with_struct_pat(
             |k| {
                 matches!(k, Struct(qself2, path2, fps2, rest2)
                 if rest1 == *rest2 // If one struct pattern has `..` so must the other.
-                && eq_maybe_qself(qself1, qself2.as_ref())
+                && eq_maybe_qself(qself1, qself2.as_deref())
                 && eq_path(path1, path2)
                 && fps1.len() == fps2.len()
                 && fps1.iter().enumerate().all(|(idx_1, fp1)| {
diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index c641d4e55b940..490da4f1e037a 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -141,43 +141,45 @@ fn collect_unwrap_info<'tcx>(
         is_type_diagnostic_item(cx, ty, sym::Result) && matches!(method_name, sym::is_err | sym::is_ok)
     }
 
-    if let ExprKind::Binary(op, left, right) = &expr.kind {
-        match (invert, op.node) {
-            (false, BinOpKind::And | BinOpKind::BitAnd) | (true, BinOpKind::Or | BinOpKind::BitOr) => {
-                let mut unwrap_info = collect_unwrap_info(cx, if_expr, left, branch, invert, false);
-                unwrap_info.append(&mut collect_unwrap_info(cx, if_expr, right, branch, invert, false));
-                return unwrap_info;
-            },
-            _ => (),
-        }
-    } else if let ExprKind::Unary(UnOp::Not, expr) = &expr.kind {
-        return collect_unwrap_info(cx, if_expr, expr, branch, !invert, false);
-    } else if let ExprKind::MethodCall(method_name, receiver, [], _) = &expr.kind
-        && let Some(local_id) = path_to_local(receiver)
-        && let ty = cx.typeck_results().expr_ty(receiver)
-        && let name = method_name.ident.name
-        && (is_relevant_option_call(cx, ty, name) || is_relevant_result_call(cx, ty, name))
-    {
-        let unwrappable = matches!(name, sym::is_some | sym::is_ok);
-        let safe_to_unwrap = unwrappable != invert;
-        let kind = if is_type_diagnostic_item(cx, ty, sym::Option) {
-            UnwrappableKind::Option
-        } else {
-            UnwrappableKind::Result
-        };
+    match expr.kind {
+        ExprKind::Binary(op, left, right)
+            if matches!(
+                (invert, op.node),
+                (false, BinOpKind::And | BinOpKind::BitAnd) | (true, BinOpKind::Or | BinOpKind::BitOr)
+            ) =>
+        {
+            let mut unwrap_info = collect_unwrap_info(cx, if_expr, left, branch, invert, false);
+            unwrap_info.extend(collect_unwrap_info(cx, if_expr, right, branch, invert, false));
+            unwrap_info
+        },
+        ExprKind::Unary(UnOp::Not, expr) => collect_unwrap_info(cx, if_expr, expr, branch, !invert, false),
+        ExprKind::MethodCall(method_name, receiver, [], _)
+            if let Some(local_id) = path_to_local(receiver)
+                && let ty = cx.typeck_results().expr_ty(receiver)
+                && let name = method_name.ident.name
+                && (is_relevant_option_call(cx, ty, name) || is_relevant_result_call(cx, ty, name)) =>
+        {
+            let unwrappable = matches!(name, sym::is_some | sym::is_ok);
+            let safe_to_unwrap = unwrappable != invert;
+            let kind = if is_type_diagnostic_item(cx, ty, sym::Option) {
+                UnwrappableKind::Option
+            } else {
+                UnwrappableKind::Result
+            };
 
-        return vec![UnwrapInfo {
-            local_id,
-            if_expr,
-            check: expr,
-            check_name: name,
-            branch,
-            safe_to_unwrap,
-            kind,
-            is_entire_condition,
-        }];
+            vec![UnwrapInfo {
+                local_id,
+                if_expr,
+                check: expr,
+                check_name: name,
+                branch,
+                safe_to_unwrap,
+                kind,
+                is_entire_condition,
+            }]
+        },
+        _ => vec![],
     }
-    Vec::new()
 }
 
 /// A HIR visitor delegate that checks if a local variable of type `Option` or `Result` is mutated,
diff --git a/clippy_lints/src/zero_sized_map_values.rs b/clippy_lints/src/zero_sized_map_values.rs
index 1550872bca2b9..f1572fd65bbff 100644
--- a/clippy_lints/src/zero_sized_map_values.rs
+++ b/clippy_lints/src/zero_sized_map_values.rs
@@ -56,6 +56,9 @@ impl LateLintPass<'_> for ZeroSizedMapValues {
             // cannot check if it is `Sized` or not, such as an incomplete associated type in a
             // type alias. See an example in `issue14822()` of `tests/ui/zero_sized_hashmap_values.rs`.
             && !ty.has_non_region_param()
+            // Ensure that no region escapes to avoid an assertion error when computing the layout.
+            // See an example in `issue15429()` of `tests/ui/zero_sized_hashmap_values.rs`.
+            && !ty.has_escaping_bound_vars()
             && let Ok(layout) = cx.layout_of(ty)
             && layout.is_zst()
         {
diff --git a/clippy_lints_internal/src/derive_deserialize_allowing_unknown.rs b/clippy_lints_internal/src/derive_deserialize_allowing_unknown.rs
index 5e6a40ac2eb61..0fd1e11b03333 100644
--- a/clippy_lints_internal/src/derive_deserialize_allowing_unknown.rs
+++ b/clippy_lints_internal/src/derive_deserialize_allowing_unknown.rs
@@ -6,7 +6,8 @@ use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def::Res;
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::{
-    AttrArgs, AttrItem, AttrPath, Attribute, HirId, Impl, Item, ItemKind, Path, QPath, TraitRef, Ty, TyKind, find_attr,
+    AttrArgs, AttrItem, AttrPath, Attribute, HirId, Impl, Item, ItemKind, Path, QPath, TraitImplHeader, TraitRef, Ty,
+    TyKind, find_attr,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_lint_defs::declare_tool_lint;
@@ -56,10 +57,14 @@ impl<'tcx> LateLintPass<'tcx> for DeriveDeserializeAllowingUnknown {
         // Is this an `impl` (of a certain form)?
         let ItemKind::Impl(Impl {
             of_trait:
-                Some(TraitRef {
-                    path:
-                        Path {
-                            res: Res::Def(_, trait_def_id),
+                Some(TraitImplHeader {
+                    trait_ref:
+                        TraitRef {
+                            path:
+                                Path {
+                                    res: Res::Def(_, trait_def_id),
+                                    ..
+                                },
                             ..
                         },
                     ..
diff --git a/clippy_test_deps/Cargo.lock b/clippy_test_deps/Cargo.lock
index 2f987c0137c90..b22cf9d107d76 100644
--- a/clippy_test_deps/Cargo.lock
+++ b/clippy_test_deps/Cargo.lock
@@ -377,9 +377,9 @@ dependencies = [
 
 [[package]]
 name = "slab"
-version = "0.4.10"
+version = "0.4.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04dc19736151f35336d325007ac991178d504a119863a2fcb3758cdb5e52c50d"
+checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589"
 
 [[package]]
 name = "smallvec"
diff --git a/clippy_utils/README.md b/clippy_utils/README.md
index 6d8dd92d55d65..2dfe28953d0c1 100644
--- a/clippy_utils/README.md
+++ b/clippy_utils/README.md
@@ -8,7 +8,7 @@ This crate is only guaranteed to build with this `nightly` toolchain:
 
 <!-- begin autogenerated nightly -->
 ```
-nightly-2025-08-07
+nightly-2025-08-22
 ```
 <!-- end autogenerated nightly -->
 
diff --git a/clippy_utils/src/ast_utils/mod.rs b/clippy_utils/src/ast_utils/mod.rs
index d80a9d9dd07d8..40c00568a3bde 100644
--- a/clippy_utils/src/ast_utils/mod.rs
+++ b/clippy_utils/src/ast_utils/mod.rs
@@ -41,21 +41,23 @@ pub fn eq_pat(l: &Pat, r: &Pat) -> bool {
             b1 == b2 && eq_id(*i1, *i2) && both(s1.as_deref(), s2.as_deref(), eq_pat)
         },
         (Range(lf, lt, le), Range(rf, rt, re)) => {
-            eq_expr_opt(lf.as_ref(), rf.as_ref())
-                && eq_expr_opt(lt.as_ref(), rt.as_ref())
+            eq_expr_opt(lf.as_deref(), rf.as_deref())
+                && eq_expr_opt(lt.as_deref(), rt.as_deref())
                 && eq_range_end(&le.node, &re.node)
         },
         (Box(l), Box(r))
         | (Ref(l, Mutability::Not), Ref(r, Mutability::Not))
         | (Ref(l, Mutability::Mut), Ref(r, Mutability::Mut)) => eq_pat(l, r),
         (Tuple(l), Tuple(r)) | (Slice(l), Slice(r)) => over(l, r, |l, r| eq_pat(l, r)),
-        (Path(lq, lp), Path(rq, rp)) => both(lq.as_ref(), rq.as_ref(), eq_qself) && eq_path(lp, rp),
+        (Path(lq, lp), Path(rq, rp)) => both(lq.as_deref(), rq.as_deref(), eq_qself) && eq_path(lp, rp),
         (TupleStruct(lqself, lp, lfs), TupleStruct(rqself, rp, rfs)) => {
-            eq_maybe_qself(lqself.as_ref(), rqself.as_ref()) && eq_path(lp, rp) && over(lfs, rfs, |l, r| eq_pat(l, r))
+            eq_maybe_qself(lqself.as_deref(), rqself.as_deref())
+                && eq_path(lp, rp)
+                && over(lfs, rfs, |l, r| eq_pat(l, r))
         },
         (Struct(lqself, lp, lfs, lr), Struct(rqself, rp, rfs, rr)) => {
             lr == rr
-                && eq_maybe_qself(lqself.as_ref(), rqself.as_ref())
+                && eq_maybe_qself(lqself.as_deref(), rqself.as_deref())
                 && eq_path(lp, rp)
                 && unordered_over(lfs, rfs, eq_field_pat)
         },
@@ -82,11 +84,11 @@ pub fn eq_field_pat(l: &PatField, r: &PatField) -> bool {
         && over(&l.attrs, &r.attrs, eq_attr)
 }
 
-pub fn eq_qself(l: &Box<QSelf>, r: &Box<QSelf>) -> bool {
+pub fn eq_qself(l: &QSelf, r: &QSelf) -> bool {
     l.position == r.position && eq_ty(&l.ty, &r.ty)
 }
 
-pub fn eq_maybe_qself(l: Option<&Box<QSelf>>, r: Option<&Box<QSelf>>) -> bool {
+pub fn eq_maybe_qself(l: Option<&QSelf>, r: Option<&QSelf>) -> bool {
     match (l, r) {
         (Some(l), Some(r)) => eq_qself(l, r),
         (None, None) => true,
@@ -129,8 +131,8 @@ pub fn eq_generic_arg(l: &GenericArg, r: &GenericArg) -> bool {
     }
 }
 
-pub fn eq_expr_opt(l: Option<&Box<Expr>>, r: Option<&Box<Expr>>) -> bool {
-    both(l, r, |l, r| eq_expr(l, r))
+pub fn eq_expr_opt(l: Option<&Expr>, r: Option<&Expr>) -> bool {
+    both(l, r, eq_expr)
 }
 
 pub fn eq_struct_rest(l: &StructRest, r: &StructRest) -> bool {
@@ -177,7 +179,7 @@ pub fn eq_expr(l: &Expr, r: &Expr) -> bool {
         (Cast(l, lt), Cast(r, rt)) | (Type(l, lt), Type(r, rt)) => eq_expr(l, r) && eq_ty(lt, rt),
         (Let(lp, le, _, _), Let(rp, re, _, _)) => eq_pat(lp, rp) && eq_expr(le, re),
         (If(lc, lt, le), If(rc, rt, re)) => {
-            eq_expr(lc, rc) && eq_block(lt, rt) && eq_expr_opt(le.as_ref(), re.as_ref())
+            eq_expr(lc, rc) && eq_block(lt, rt) && eq_expr_opt(le.as_deref(), re.as_deref())
         },
         (While(lc, lt, ll), While(rc, rt, rl)) => {
             eq_label(ll.as_ref(), rl.as_ref()) && eq_expr(lc, rc) && eq_block(lt, rt)
@@ -201,9 +203,11 @@ pub fn eq_expr(l: &Expr, r: &Expr) -> bool {
         (Loop(lt, ll, _), Loop(rt, rl, _)) => eq_label(ll.as_ref(), rl.as_ref()) && eq_block(lt, rt),
         (Block(lb, ll), Block(rb, rl)) => eq_label(ll.as_ref(), rl.as_ref()) && eq_block(lb, rb),
         (TryBlock(l), TryBlock(r)) => eq_block(l, r),
-        (Yield(l), Yield(r)) => eq_expr_opt(l.expr(), r.expr()) && l.same_kind(r),
-        (Ret(l), Ret(r)) => eq_expr_opt(l.as_ref(), r.as_ref()),
-        (Break(ll, le), Break(rl, re)) => eq_label(ll.as_ref(), rl.as_ref()) && eq_expr_opt(le.as_ref(), re.as_ref()),
+        (Yield(l), Yield(r)) => eq_expr_opt(l.expr().map(Box::as_ref), r.expr().map(Box::as_ref)) && l.same_kind(r),
+        (Ret(l), Ret(r)) => eq_expr_opt(l.as_deref(), r.as_deref()),
+        (Break(ll, le), Break(rl, re)) => {
+            eq_label(ll.as_ref(), rl.as_ref()) && eq_expr_opt(le.as_deref(), re.as_deref())
+        },
         (Continue(ll), Continue(rl)) => eq_label(ll.as_ref(), rl.as_ref()),
         (Assign(l1, l2, _), Assign(r1, r2, _)) | (Index(l1, l2, _), Index(r1, r2, _)) => {
             eq_expr(l1, r1) && eq_expr(l2, r2)
@@ -240,13 +244,13 @@ pub fn eq_expr(l: &Expr, r: &Expr) -> bool {
         },
         (Gen(lc, lb, lk, _), Gen(rc, rb, rk, _)) => lc == rc && eq_block(lb, rb) && lk == rk,
         (Range(lf, lt, ll), Range(rf, rt, rl)) => {
-            ll == rl && eq_expr_opt(lf.as_ref(), rf.as_ref()) && eq_expr_opt(lt.as_ref(), rt.as_ref())
+            ll == rl && eq_expr_opt(lf.as_deref(), rf.as_deref()) && eq_expr_opt(lt.as_deref(), rt.as_deref())
         },
         (AddrOf(lbk, lm, le), AddrOf(rbk, rm, re)) => lbk == rbk && lm == rm && eq_expr(le, re),
-        (Path(lq, lp), Path(rq, rp)) => both(lq.as_ref(), rq.as_ref(), eq_qself) && eq_path(lp, rp),
+        (Path(lq, lp), Path(rq, rp)) => both(lq.as_deref(), rq.as_deref(), eq_qself) && eq_path(lp, rp),
         (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
         (Struct(lse), Struct(rse)) => {
-            eq_maybe_qself(lse.qself.as_ref(), rse.qself.as_ref())
+            eq_maybe_qself(lse.qself.as_deref(), rse.qself.as_deref())
                 && eq_path(&lse.path, &rse.path)
                 && eq_struct_rest(&lse.rest, &rse.rest)
                 && unordered_over(&lse.fields, &rse.fields, eq_field)
@@ -278,8 +282,8 @@ pub fn eq_field(l: &ExprField, r: &ExprField) -> bool {
 pub fn eq_arm(l: &Arm, r: &Arm) -> bool {
     l.is_placeholder == r.is_placeholder
         && eq_pat(&l.pat, &r.pat)
-        && eq_expr_opt(l.body.as_ref(), r.body.as_ref())
-        && eq_expr_opt(l.guard.as_ref(), r.guard.as_ref())
+        && eq_expr_opt(l.body.as_deref(), r.body.as_deref())
+        && eq_expr_opt(l.guard.as_deref(), r.guard.as_deref())
         && over(&l.attrs, &r.attrs, eq_attr)
 }
 
@@ -324,7 +328,7 @@ pub fn eq_item<K>(l: &Item<K>, r: &Item<K>, mut eq_kind: impl FnMut(&K, &K) -> b
     over(&l.attrs, &r.attrs, eq_attr) && eq_vis(&l.vis, &r.vis) && eq_kind(&l.kind, &r.kind)
 }
 
-#[expect(clippy::similar_names, clippy::too_many_lines)] // Just a big match statement
+#[expect(clippy::too_many_lines)] // Just a big match statement
 pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
     use ItemKind::*;
     match (l, r) {
@@ -347,7 +351,7 @@ pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
                 safety: rs,
                 define_opaque: _,
             }),
-        ) => eq_id(*li, *ri) && lm == rm && ls == rs && eq_ty(lt, rt) && eq_expr_opt(le.as_ref(), re.as_ref()),
+        ) => eq_id(*li, *ri) && lm == rm && ls == rs && eq_ty(lt, rt) && eq_expr_opt(le.as_deref(), re.as_deref()),
         (
             Const(box ConstItem {
                 defaultness: ld,
@@ -370,7 +374,7 @@ pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
                 && eq_id(*li, *ri)
                 && eq_generics(lg, rg)
                 && eq_ty(lt, rt)
-                && eq_expr_opt(le.as_ref(), re.as_ref())
+                && eq_expr_opt(le.as_deref(), re.as_deref())
         },
         (
             Fn(box ast::Fn {
@@ -525,7 +529,7 @@ pub fn eq_foreign_item_kind(l: &ForeignItemKind, r: &ForeignItemKind) -> bool {
                 safety: rs,
                 define_opaque: _,
             }),
-        ) => eq_id(*li, *ri) && eq_ty(lt, rt) && lm == rm && eq_expr_opt(le.as_ref(), re.as_ref()) && ls == rs,
+        ) => eq_id(*li, *ri) && eq_ty(lt, rt) && lm == rm && eq_expr_opt(le.as_deref(), re.as_deref()) && ls == rs,
         (
             Fn(box ast::Fn {
                 defaultness: ld,
@@ -607,7 +611,7 @@ pub fn eq_assoc_item_kind(l: &AssocItemKind, r: &AssocItemKind) -> bool {
                 && eq_id(*li, *ri)
                 && eq_generics(lg, rg)
                 && eq_ty(lt, rt)
-                && eq_expr_opt(le.as_ref(), re.as_ref())
+                && eq_expr_opt(le.as_deref(), re.as_deref())
         },
         (
             Fn(box ast::Fn {
@@ -723,7 +727,8 @@ pub fn eq_fn_header(l: &FnHeader, r: &FnHeader) -> bool {
 pub fn eq_opt_fn_contract(l: &Option<Box<FnContract>>, r: &Option<Box<FnContract>>) -> bool {
     match (l, r) {
         (Some(l), Some(r)) => {
-            eq_expr_opt(l.requires.as_ref(), r.requires.as_ref()) && eq_expr_opt(l.ensures.as_ref(), r.ensures.as_ref())
+            eq_expr_opt(l.requires.as_deref(), r.requires.as_deref())
+                && eq_expr_opt(l.ensures.as_deref(), r.ensures.as_deref())
         },
         (None, None) => true,
         (Some(_), None) | (None, Some(_)) => false,
@@ -841,7 +846,7 @@ pub fn eq_ty(l: &Ty, r: &Ty) -> bool {
                 && eq_fn_decl(&l.decl, &r.decl)
         },
         (Tup(l), Tup(r)) => over(l, r, |l, r| eq_ty(l, r)),
-        (Path(lq, lp), Path(rq, rp)) => both(lq.as_ref(), rq.as_ref(), eq_qself) && eq_path(lp, rp),
+        (Path(lq, lp), Path(rq, rp)) => both(lq.as_deref(), rq.as_deref(), eq_qself) && eq_path(lp, rp),
         (TraitObject(lg, ls), TraitObject(rg, rs)) => ls == rs && over(lg, rg, eq_generic_bound),
         (ImplTrait(_, lg), ImplTrait(_, rg)) => over(lg, rg, eq_generic_bound),
         (Typeof(l), Typeof(r)) => eq_expr(&l.value, &r.value),
diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index e0c1b9d445a2a..c4a759e919b1b 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -19,8 +19,8 @@ use rustc_ast::token::CommentKind;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
     Block, BlockCheckMode, Body, Closure, Destination, Expr, ExprKind, FieldDef, FnHeader, FnRetTy, HirId, Impl,
-    ImplItem, ImplItemKind, TraitImplHeader, IsAuto, Item, ItemKind, Lit, LoopSource, MatchSource, MutTy, Node, Path,
-    QPath, Safety, TraitItem, TraitItemKind, Ty, TyKind, UnOp, UnsafeSource, Variant, VariantData, YieldSource,
+    ImplItem, ImplItemKind, IsAuto, Item, ItemKind, Lit, LoopSource, MatchSource, MutTy, Node, Path, QPath, Safety,
+    TraitImplHeader, TraitItem, TraitItemKind, Ty, TyKind, UnOp, UnsafeSource, Variant, VariantData, YieldSource,
 };
 use rustc_lint::{EarlyContext, LateContext, LintContext};
 use rustc_middle::ty::TyCtxt;
@@ -254,7 +254,10 @@ fn item_search_pat(item: &Item<'_>) -> (Pat, Pat) {
         ItemKind::Union(..) => (Pat::Str("union"), Pat::Str("}")),
         ItemKind::Trait(_, _, Safety::Unsafe, ..)
         | ItemKind::Impl(Impl {
-            of_trait: Some(TraitImplHeader { safety: Safety::Unsafe, .. }), ..
+            of_trait: Some(TraitImplHeader {
+                safety: Safety::Unsafe, ..
+            }),
+            ..
         }) => (Pat::Str("unsafe"), Pat::Str("}")),
         ItemKind::Trait(_, IsAuto::Yes, ..) => (Pat::Str("auto"), Pat::Str("}")),
         ItemKind::Trait(..) => (Pat::Str("trait"), Pat::Str("}")),
diff --git a/clippy_utils/src/diagnostics.rs b/clippy_utils/src/diagnostics.rs
index 625e1eead213d..8a19039a7fe76 100644
--- a/clippy_utils/src/diagnostics.rs
+++ b/clippy_utils/src/diagnostics.rs
@@ -22,13 +22,14 @@ fn docs_link(diag: &mut Diag<'_, ()>, lint: &'static Lint) {
     {
         diag.help(format!(
             "for further information visit https://rust-lang.github.io/rust-clippy/{}/index.html#{lint}",
-            &option_env!("RUST_RELEASE_NUM").map_or_else(
-                || "master".to_string(),
-                |n| {
-                    // extract just major + minor version and ignore patch versions
-                    format!("rust-{}", n.rsplit_once('.').unwrap().1)
-                }
-            )
+            match option_env!("CFG_RELEASE_CHANNEL") {
+                // Clippy version is 0.1.xx
+                //
+                // Always use .0 because we do not generate separate lint doc pages for rust patch releases
+                Some("stable") => concat!("rust-1.", env!("CARGO_PKG_VERSION_PATCH"), ".0"),
+                Some("beta") => "beta",
+                _ => "master",
+            }
         ));
     }
 }
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index f0d7fb89c4463..8160443f4132f 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -258,7 +258,7 @@ impl HirEqInterExpr<'_, '_, '_> {
         })
     }
 
-    fn should_ignore(&mut self, expr: &Expr<'_>) -> bool {
+    fn should_ignore(&self, expr: &Expr<'_>) -> bool {
         macro_backtrace(expr.span).last().is_some_and(|macro_call| {
             matches!(
                 self.inner.cx.tcx.get_diagnostic_name(macro_call.def_id),
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index fcc120656e3e9..8533fa8554199 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -460,6 +460,23 @@ pub fn path_to_local_id(expr: &Expr<'_>, id: HirId) -> bool {
     path_to_local(expr) == Some(id)
 }
 
+/// If the expression is a path to a local (with optional projections),
+/// returns the canonical `HirId` of the local.
+///
+/// For example, `x.field[0].field2` would return the `HirId` of `x`.
+pub fn path_to_local_with_projections(expr: &Expr<'_>) -> Option<HirId> {
+    match expr.kind {
+        ExprKind::Field(recv, _) | ExprKind::Index(recv, _, _) => path_to_local_with_projections(recv),
+        ExprKind::Path(QPath::Resolved(
+            _,
+            Path {
+                res: Res::Local(local), ..
+            },
+        )) => Some(*local),
+        _ => None,
+    }
+}
+
 pub trait MaybePath<'hir> {
     fn hir_id(&self) -> HirId;
     fn qpath_opt(&self) -> Option<&QPath<'hir>>;
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 89a83e2c48f91..896d607fbcdd9 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -189,25 +189,25 @@ impl MsrvStack {
 fn parse_attrs(sess: &Session, attrs: &[impl AttributeExt]) -> Option<RustcVersion> {
     let mut msrv_attrs = attrs.iter().filter(|attr| attr.path_matches(&[sym::clippy, sym::msrv]));
 
-    if let Some(msrv_attr) = msrv_attrs.next() {
-        if let Some(duplicate) = msrv_attrs.next_back() {
-            sess.dcx()
-                .struct_span_err(duplicate.span(), "`clippy::msrv` is defined multiple times")
-                .with_span_note(msrv_attr.span(), "first definition found here")
-                .emit();
-        }
-
-        if let Some(msrv) = msrv_attr.value_str() {
-            if let Some(version) = parse_version(msrv) {
-                return Some(version);
-            }
+    let msrv_attr = msrv_attrs.next()?;
 
-            sess.dcx()
-                .span_err(msrv_attr.span(), format!("`{msrv}` is not a valid Rust version"));
-        } else {
-            sess.dcx().span_err(msrv_attr.span(), "bad clippy attribute");
-        }
+    if let Some(duplicate) = msrv_attrs.next_back() {
+        sess.dcx()
+            .struct_span_err(duplicate.span(), "`clippy::msrv` is defined multiple times")
+            .with_span_note(msrv_attr.span(), "first definition found here")
+            .emit();
     }
 
-    None
+    let Some(msrv) = msrv_attr.value_str() else {
+        sess.dcx().span_err(msrv_attr.span(), "bad clippy attribute");
+        return None;
+    };
+
+    let Some(version) = parse_version(msrv) else {
+        sess.dcx()
+            .span_err(msrv_attr.span(), format!("`{msrv}` is not a valid Rust version"));
+        return None;
+    };
+
+    Some(version)
 }
diff --git a/clippy_utils/src/ty/mod.rs b/clippy_utils/src/ty/mod.rs
index d79773f832115..fafc1d07e51eb 100644
--- a/clippy_utils/src/ty/mod.rs
+++ b/clippy_utils/src/ty/mod.rs
@@ -18,6 +18,7 @@ use rustc_lint::LateContext;
 use rustc_middle::mir::ConstValue;
 use rustc_middle::mir::interpret::Scalar;
 use rustc_middle::traits::EvaluationResult;
+use rustc_middle::ty::adjustment::{Adjust, Adjustment};
 use rustc_middle::ty::layout::ValidityRequirement;
 use rustc_middle::ty::{
     self, AdtDef, AliasTy, AssocItem, AssocTag, Binder, BoundRegion, FnSig, GenericArg, GenericArgKind, GenericArgsRef,
@@ -31,7 +32,7 @@ use rustc_trait_selection::traits::query::normalize::QueryNormalizeExt;
 use rustc_trait_selection::traits::{Obligation, ObligationCause};
 use std::assert_matches::debug_assert_matches;
 use std::collections::hash_map::Entry;
-use std::iter;
+use std::{iter, mem};
 
 use crate::path_res;
 use crate::paths::{PathNS, lookup_path_str};
@@ -1382,7 +1383,6 @@ pub fn is_slice_like<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
         || matches!(ty.kind(), ty::Adt(adt_def, _) if cx.tcx.is_diagnostic_item(sym::Vec, adt_def.did()))
 }
 
-/// Gets the index of a field by name.
 pub fn get_field_idx_by_name(ty: Ty<'_>, name: Symbol) -> Option<usize> {
     match *ty.kind() {
         ty::Adt(def, _) if def.is_union() || def.is_struct() => {
@@ -1392,3 +1392,11 @@ pub fn get_field_idx_by_name(ty: Ty<'_>, name: Symbol) -> Option<usize> {
         _ => None,
     }
 }
+
+/// Checks if the adjustments contain a mutable dereference of a `ManuallyDrop<_>`.
+pub fn adjust_derefs_manually_drop<'tcx>(adjustments: &'tcx [Adjustment<'tcx>], mut ty: Ty<'tcx>) -> bool {
+    adjustments.iter().any(|a| {
+        let ty = mem::replace(&mut ty, a.target);
+        matches!(a.kind, Adjust::Deref(Some(op)) if op.mutbl == Mutability::Mut) && is_manually_drop(ty)
+    })
+}
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index ac51ec2d61b54..5497e77e8ad17 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,6 +1,6 @@
 [toolchain]
 # begin autogenerated nightly
-channel = "nightly-2025-08-07"
+channel = "nightly-2025-08-22"
 # end autogenerated nightly
 components = ["cargo", "llvm-tools", "rust-src", "rust-std", "rustc", "rustc-dev", "rustfmt"]
 profile = "minimal"
diff --git a/tests/ui-cargo/undocumented_unsafe_blocks/fail/Cargo.stderr b/tests/ui-cargo/undocumented_unsafe_blocks/fail/Cargo.stderr
new file mode 100644
index 0000000000000..59a7146ac90fd
--- /dev/null
+++ b/tests/ui-cargo/undocumented_unsafe_blocks/fail/Cargo.stderr
@@ -0,0 +1,26 @@
+error: module has unnecessary safety comment
+ --> src/main.rs:2:1
+  |
+2 | mod x {}
+  | ^^^^^^^^
+  |
+help: consider removing the safety comment
+ --> src/main.rs:1:1
+  |
+1 | // SAFETY: ...
+  | ^^^^^^^^^^^^^^
+  = note: requested on the command line with `-D clippy::unnecessary-safety-comment`
+
+error: module has unnecessary safety comment
+ --> src/main.rs:5:1
+  |
+5 | mod y {}
+  | ^^^^^^^^
+  |
+help: consider removing the safety comment
+ --> src/main.rs:4:1
+  |
+4 | // SAFETY: ...
+  | ^^^^^^^^^^^^^^
+
+error: could not compile `undocumented_unsafe_blocks` (bin "undocumented_unsafe_blocks") due to 2 previous errors
diff --git a/tests/ui-cargo/undocumented_unsafe_blocks/fail/Cargo.toml b/tests/ui-cargo/undocumented_unsafe_blocks/fail/Cargo.toml
new file mode 100644
index 0000000000000..36bb3472df078
--- /dev/null
+++ b/tests/ui-cargo/undocumented_unsafe_blocks/fail/Cargo.toml
@@ -0,0 +1,12 @@
+# Reproducing #14553 requires the `# Safety` comment to be in the first line of 
+# the file. Since `unnecessary_safety_comment` is not enabled by default, we
+# will set it up here.
+
+[package]
+name = "undocumented_unsafe_blocks"
+edition = "2024"
+publish = false
+version = "0.1.0"
+
+[lints.clippy]
+unnecessary_safety_comment = "deny"
diff --git a/tests/ui-cargo/undocumented_unsafe_blocks/fail/src/main.rs b/tests/ui-cargo/undocumented_unsafe_blocks/fail/src/main.rs
new file mode 100644
index 0000000000000..5cafcff99ddc4
--- /dev/null
+++ b/tests/ui-cargo/undocumented_unsafe_blocks/fail/src/main.rs
@@ -0,0 +1,7 @@
+// SAFETY: ...
+mod x {}
+
+// SAFETY: ...
+mod y {}
+
+fn main() {}
diff --git a/tests/ui-toml/functions_maxlines/test.stderr b/tests/ui-toml/functions_maxlines/test.stderr
index 14a49cb76c1ce..e856963c87d18 100644
--- a/tests/ui-toml/functions_maxlines/test.stderr
+++ b/tests/ui-toml/functions_maxlines/test.stderr
@@ -1,12 +1,8 @@
 error: this function has too many lines (2/1)
   --> tests/ui-toml/functions_maxlines/test.rs:19:1
    |
-LL | / fn too_many_lines() {
-LL | |
-LL | |     println!("This is bad.");
-LL | |     println!("This is bad.");
-LL | | }
-   | |_^
+LL | fn too_many_lines() {
+   | ^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::too-many-lines` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::too_many_lines)]`
@@ -14,35 +10,20 @@ LL | | }
 error: this function has too many lines (4/1)
   --> tests/ui-toml/functions_maxlines/test.rs:26:1
    |
-LL | / async fn async_too_many_lines() {
-LL | |
-LL | |     println!("This is bad.");
-LL | |     println!("This is bad.");
-LL | | }
-   | |_^
+LL | async fn async_too_many_lines() {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this function has too many lines (4/1)
   --> tests/ui-toml/functions_maxlines/test.rs:33:1
    |
-LL | / fn closure_too_many_lines() {
-LL | |
-LL | |     let _ = {
-LL | |         println!("This is bad.");
-LL | |         println!("This is bad.");
-LL | |     };
-LL | | }
-   | |_^
+LL | fn closure_too_many_lines() {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this function has too many lines (2/1)
   --> tests/ui-toml/functions_maxlines/test.rs:56:1
    |
-LL | / fn comment_before_code() {
-LL | |
-LL | |     let _ = "test";
-LL | |     /* This comment extends to the front of
-LL | |     the code but this line should still count. */ let _ = 5;
-LL | | }
-   | |_^
+LL | fn comment_before_code() {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/as_ptr_cast_mut.fixed b/tests/ui/as_ptr_cast_mut.fixed
new file mode 100644
index 0000000000000..fe9c5dca5ba50
--- /dev/null
+++ b/tests/ui/as_ptr_cast_mut.fixed
@@ -0,0 +1,38 @@
+#![allow(unused)]
+#![warn(clippy::as_ptr_cast_mut)]
+#![allow(clippy::wrong_self_convention, clippy::unnecessary_cast)]
+
+struct MutPtrWrapper(Vec<u8>);
+impl MutPtrWrapper {
+    fn as_ptr(&mut self) -> *const u8 {
+        self.0.as_mut_ptr() as *const u8
+    }
+}
+
+struct Covariant<T>(*const T);
+impl<T> Covariant<T> {
+    fn as_ptr(self) -> *const T {
+        self.0
+    }
+}
+
+fn main() {
+    let mut string = String::new();
+    let _ = string.as_mut_ptr();
+    //~^ as_ptr_cast_mut
+
+    let _ = string.as_ptr() as *const i8;
+    let _ = string.as_mut_ptr();
+    let _ = string.as_mut_ptr() as *mut u8;
+    let _ = string.as_mut_ptr() as *const u8;
+
+    let nn = std::ptr::NonNull::new(4 as *mut u8).unwrap();
+    let _ = nn.as_ptr() as *mut u8;
+
+    let mut wrap = MutPtrWrapper(Vec::new());
+    let _ = wrap.as_ptr() as *mut u8;
+
+    let mut local = 4;
+    let ref_with_write_perm = Covariant(std::ptr::addr_of_mut!(local) as *const _);
+    let _ = ref_with_write_perm.as_ptr() as *mut u8;
+}
diff --git a/tests/ui/as_ptr_cast_mut.rs b/tests/ui/as_ptr_cast_mut.rs
index baf7279adc4a4..3f22c2058d001 100644
--- a/tests/ui/as_ptr_cast_mut.rs
+++ b/tests/ui/as_ptr_cast_mut.rs
@@ -1,7 +1,6 @@
 #![allow(unused)]
 #![warn(clippy::as_ptr_cast_mut)]
 #![allow(clippy::wrong_self_convention, clippy::unnecessary_cast)]
-//@no-rustfix: incorrect suggestion
 
 struct MutPtrWrapper(Vec<u8>);
 impl MutPtrWrapper {
@@ -22,9 +21,6 @@ fn main() {
     let _ = string.as_ptr() as *mut u8;
     //~^ as_ptr_cast_mut
 
-    let _: *mut i8 = string.as_ptr() as *mut _;
-    //~^ as_ptr_cast_mut
-
     let _ = string.as_ptr() as *const i8;
     let _ = string.as_mut_ptr();
     let _ = string.as_mut_ptr() as *mut u8;
diff --git a/tests/ui/as_ptr_cast_mut.stderr b/tests/ui/as_ptr_cast_mut.stderr
index b3fc223ccdba1..fa9fb23e2d00b 100644
--- a/tests/ui/as_ptr_cast_mut.stderr
+++ b/tests/ui/as_ptr_cast_mut.stderr
@@ -1,5 +1,5 @@
 error: casting the result of `as_ptr` to *mut u8
-  --> tests/ui/as_ptr_cast_mut.rs:22:13
+  --> tests/ui/as_ptr_cast_mut.rs:21:13
    |
 LL |     let _ = string.as_ptr() as *mut u8;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `string.as_mut_ptr()`
@@ -7,11 +7,5 @@ LL |     let _ = string.as_ptr() as *mut u8;
    = note: `-D clippy::as-ptr-cast-mut` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::as_ptr_cast_mut)]`
 
-error: casting the result of `as_ptr` to *mut i8
-  --> tests/ui/as_ptr_cast_mut.rs:25:22
-   |
-LL |     let _: *mut i8 = string.as_ptr() as *mut _;
-   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `string.as_mut_ptr()`
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/as_ptr_cast_mut_unfixable.rs b/tests/ui/as_ptr_cast_mut_unfixable.rs
new file mode 100644
index 0000000000000..a8f6b06bd4fd5
--- /dev/null
+++ b/tests/ui/as_ptr_cast_mut_unfixable.rs
@@ -0,0 +1,16 @@
+//@no-rustfix
+#![allow(unused)]
+#![warn(clippy::as_ptr_cast_mut)]
+
+fn main() {
+    let mut string = String::new();
+
+    // the `*mut _` is actually necessary since it does two things at once:
+    // - changes the mutability (caught by the lint)
+    // - changes the type
+    //
+    // and so replacing this with `as_mut_ptr` removes the second thing,
+    // resulting in a type mismatch
+    let _: *mut i8 = string.as_ptr() as *mut _;
+    //~^ as_ptr_cast_mut
+}
diff --git a/tests/ui/as_ptr_cast_mut_unfixable.stderr b/tests/ui/as_ptr_cast_mut_unfixable.stderr
new file mode 100644
index 0000000000000..c5bcad6f4dfcf
--- /dev/null
+++ b/tests/ui/as_ptr_cast_mut_unfixable.stderr
@@ -0,0 +1,11 @@
+error: casting the result of `as_ptr` to *mut i8
+  --> tests/ui/as_ptr_cast_mut_unfixable.rs:14:22
+   |
+LL |     let _: *mut i8 = string.as_ptr() as *mut _;
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `string.as_mut_ptr()`
+   |
+   = note: `-D clippy::as-ptr-cast-mut` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::as_ptr_cast_mut)]`
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/borrow_as_ptr.fixed b/tests/ui/borrow_as_ptr.fixed
index 3f6e5245b8788..bfe826508f36e 100644
--- a/tests/ui/borrow_as_ptr.fixed
+++ b/tests/ui/borrow_as_ptr.fixed
@@ -1,6 +1,9 @@
+//@aux-build:proc_macros.rs
 #![warn(clippy::borrow_as_ptr)]
 #![allow(clippy::useless_vec)]
 
+extern crate proc_macros;
+
 fn a() -> i32 {
     0
 }
@@ -53,3 +56,12 @@ fn issue_15141() {
     // Don't lint cast to dyn trait pointers
     let b = &a as *const dyn std::any::Any;
 }
+
+fn issue15389() {
+    proc_macros::with_span! {
+        span
+        let var = 0u32;
+        // Don't lint in proc-macros
+        let _ = &var as *const u32;
+    };
+}
diff --git a/tests/ui/borrow_as_ptr.rs b/tests/ui/borrow_as_ptr.rs
index 20f4f40e00197..ce248f157c6ef 100644
--- a/tests/ui/borrow_as_ptr.rs
+++ b/tests/ui/borrow_as_ptr.rs
@@ -1,6 +1,9 @@
+//@aux-build:proc_macros.rs
 #![warn(clippy::borrow_as_ptr)]
 #![allow(clippy::useless_vec)]
 
+extern crate proc_macros;
+
 fn a() -> i32 {
     0
 }
@@ -53,3 +56,12 @@ fn issue_15141() {
     // Don't lint cast to dyn trait pointers
     let b = &a as *const dyn std::any::Any;
 }
+
+fn issue15389() {
+    proc_macros::with_span! {
+        span
+        let var = 0u32;
+        // Don't lint in proc-macros
+        let _ = &var as *const u32;
+    };
+}
diff --git a/tests/ui/borrow_as_ptr.stderr b/tests/ui/borrow_as_ptr.stderr
index b1fcce49403c8..b371b477a50d5 100644
--- a/tests/ui/borrow_as_ptr.stderr
+++ b/tests/ui/borrow_as_ptr.stderr
@@ -1,5 +1,5 @@
 error: borrow as raw pointer
-  --> tests/ui/borrow_as_ptr.rs:11:14
+  --> tests/ui/borrow_as_ptr.rs:14:14
    |
 LL |     let _p = &val as *const i32;
    |              ^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::addr_of!(val)`
@@ -8,25 +8,25 @@ LL |     let _p = &val as *const i32;
    = help: to override `-D warnings` add `#[allow(clippy::borrow_as_ptr)]`
 
 error: borrow as raw pointer
-  --> tests/ui/borrow_as_ptr.rs:19:18
+  --> tests/ui/borrow_as_ptr.rs:22:18
    |
 LL |     let _p_mut = &mut val_mut as *mut i32;
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::addr_of_mut!(val_mut)`
 
 error: borrow as raw pointer
-  --> tests/ui/borrow_as_ptr.rs:23:16
+  --> tests/ui/borrow_as_ptr.rs:26:16
    |
 LL |     let _raw = (&mut x[1] as *mut i32).wrapping_offset(-1);
    |                ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::addr_of_mut!(x[1])`
 
 error: borrow as raw pointer
-  --> tests/ui/borrow_as_ptr.rs:29:17
+  --> tests/ui/borrow_as_ptr.rs:32:17
    |
 LL |     let _raw = (&mut x[1] as *mut i32).wrapping_offset(-1);
    |                 ^^^^^^^^^^^^^^^^^^^^^ help: try: `&raw mut x[1]`
 
 error: implicit borrow as raw pointer
-  --> tests/ui/borrow_as_ptr.rs:35:25
+  --> tests/ui/borrow_as_ptr.rs:38:25
    |
 LL |     let p: *const i32 = &val;
    |                         ^^^^
@@ -37,7 +37,7 @@ LL |     let p: *const i32 = &raw const val;
    |                          +++++++++
 
 error: implicit borrow as raw pointer
-  --> tests/ui/borrow_as_ptr.rs:39:23
+  --> tests/ui/borrow_as_ptr.rs:42:23
    |
 LL |     let p: *mut i32 = &mut val;
    |                       ^^^^^^^^
@@ -48,7 +48,7 @@ LL |     let p: *mut i32 = &raw mut val;
    |                        +++
 
 error: implicit borrow as raw pointer
-  --> tests/ui/borrow_as_ptr.rs:44:19
+  --> tests/ui/borrow_as_ptr.rs:47:19
    |
 LL |     core::ptr::eq(&val, &1);
    |                   ^^^^
diff --git a/tests/ui/char_lit_as_u8_suggestions.fixed b/tests/ui/char_lit_as_u8.fixed
similarity index 100%
rename from tests/ui/char_lit_as_u8_suggestions.fixed
rename to tests/ui/char_lit_as_u8.fixed
diff --git a/tests/ui/char_lit_as_u8.rs b/tests/ui/char_lit_as_u8.rs
index c8774c7f30916..a8f39e27605e5 100644
--- a/tests/ui/char_lit_as_u8.rs
+++ b/tests/ui/char_lit_as_u8.rs
@@ -1,7 +1,12 @@
 #![warn(clippy::char_lit_as_u8)]
 
 fn main() {
-    // no suggestion, since a byte literal won't work.
-    let _ = '❤' as u8;
+    let _ = 'a' as u8;
+    //~^ char_lit_as_u8
+    let _ = '\n' as u8;
+    //~^ char_lit_as_u8
+    let _ = '\0' as u8;
+    //~^ char_lit_as_u8
+    let _ = '\x01' as u8;
     //~^ char_lit_as_u8
 }
diff --git a/tests/ui/char_lit_as_u8.stderr b/tests/ui/char_lit_as_u8.stderr
index ec02f1341c0a3..9bcded7b0ff4e 100644
--- a/tests/ui/char_lit_as_u8.stderr
+++ b/tests/ui/char_lit_as_u8.stderr
@@ -1,12 +1,36 @@
 error: casting a character literal to `u8` truncates
-  --> tests/ui/char_lit_as_u8.rs:5:13
+  --> tests/ui/char_lit_as_u8.rs:4:13
    |
-LL |     let _ = '❤' as u8;
-   |             ^^^^^^^^^
+LL |     let _ = 'a' as u8;
+   |             ^^^^^^^^^ help: use a byte literal instead: `b'a'`
    |
    = note: `char` is four bytes wide, but `u8` is a single byte
    = note: `-D clippy::char-lit-as-u8` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::char_lit_as_u8)]`
 
-error: aborting due to 1 previous error
+error: casting a character literal to `u8` truncates
+  --> tests/ui/char_lit_as_u8.rs:6:13
+   |
+LL |     let _ = '\n' as u8;
+   |             ^^^^^^^^^^ help: use a byte literal instead: `b'\n'`
+   |
+   = note: `char` is four bytes wide, but `u8` is a single byte
+
+error: casting a character literal to `u8` truncates
+  --> tests/ui/char_lit_as_u8.rs:8:13
+   |
+LL |     let _ = '\0' as u8;
+   |             ^^^^^^^^^^ help: use a byte literal instead: `b'\0'`
+   |
+   = note: `char` is four bytes wide, but `u8` is a single byte
+
+error: casting a character literal to `u8` truncates
+  --> tests/ui/char_lit_as_u8.rs:10:13
+   |
+LL |     let _ = '\x01' as u8;
+   |             ^^^^^^^^^^^^ help: use a byte literal instead: `b'\x01'`
+   |
+   = note: `char` is four bytes wide, but `u8` is a single byte
+
+error: aborting due to 4 previous errors
 
diff --git a/tests/ui/char_lit_as_u8_suggestions.rs b/tests/ui/char_lit_as_u8_suggestions.rs
deleted file mode 100644
index a8f39e27605e5..0000000000000
--- a/tests/ui/char_lit_as_u8_suggestions.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-#![warn(clippy::char_lit_as_u8)]
-
-fn main() {
-    let _ = 'a' as u8;
-    //~^ char_lit_as_u8
-    let _ = '\n' as u8;
-    //~^ char_lit_as_u8
-    let _ = '\0' as u8;
-    //~^ char_lit_as_u8
-    let _ = '\x01' as u8;
-    //~^ char_lit_as_u8
-}
diff --git a/tests/ui/char_lit_as_u8_suggestions.stderr b/tests/ui/char_lit_as_u8_suggestions.stderr
deleted file mode 100644
index 158dfd6bed265..0000000000000
--- a/tests/ui/char_lit_as_u8_suggestions.stderr
+++ /dev/null
@@ -1,36 +0,0 @@
-error: casting a character literal to `u8` truncates
-  --> tests/ui/char_lit_as_u8_suggestions.rs:4:13
-   |
-LL |     let _ = 'a' as u8;
-   |             ^^^^^^^^^ help: use a byte literal instead: `b'a'`
-   |
-   = note: `char` is four bytes wide, but `u8` is a single byte
-   = note: `-D clippy::char-lit-as-u8` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::char_lit_as_u8)]`
-
-error: casting a character literal to `u8` truncates
-  --> tests/ui/char_lit_as_u8_suggestions.rs:6:13
-   |
-LL |     let _ = '\n' as u8;
-   |             ^^^^^^^^^^ help: use a byte literal instead: `b'\n'`
-   |
-   = note: `char` is four bytes wide, but `u8` is a single byte
-
-error: casting a character literal to `u8` truncates
-  --> tests/ui/char_lit_as_u8_suggestions.rs:8:13
-   |
-LL |     let _ = '\0' as u8;
-   |             ^^^^^^^^^^ help: use a byte literal instead: `b'\0'`
-   |
-   = note: `char` is four bytes wide, but `u8` is a single byte
-
-error: casting a character literal to `u8` truncates
-  --> tests/ui/char_lit_as_u8_suggestions.rs:10:13
-   |
-LL |     let _ = '\x01' as u8;
-   |             ^^^^^^^^^^^^ help: use a byte literal instead: `b'\x01'`
-   |
-   = note: `char` is four bytes wide, but `u8` is a single byte
-
-error: aborting due to 4 previous errors
-
diff --git a/tests/ui/char_lit_as_u8_unfixable.rs b/tests/ui/char_lit_as_u8_unfixable.rs
new file mode 100644
index 0000000000000..e5c094f158ec7
--- /dev/null
+++ b/tests/ui/char_lit_as_u8_unfixable.rs
@@ -0,0 +1,8 @@
+//@no-rustfix
+#![warn(clippy::char_lit_as_u8)]
+
+fn main() {
+    // no suggestion, since a byte literal won't work.
+    let _ = '❤' as u8;
+    //~^ char_lit_as_u8
+}
diff --git a/tests/ui/char_lit_as_u8_unfixable.stderr b/tests/ui/char_lit_as_u8_unfixable.stderr
new file mode 100644
index 0000000000000..49e555ae638a2
--- /dev/null
+++ b/tests/ui/char_lit_as_u8_unfixable.stderr
@@ -0,0 +1,12 @@
+error: casting a character literal to `u8` truncates
+  --> tests/ui/char_lit_as_u8_unfixable.rs:6:13
+   |
+LL |     let _ = '❤' as u8;
+   |             ^^^^^^^^^
+   |
+   = note: `char` is four bytes wide, but `u8` is a single byte
+   = note: `-D clippy::char-lit-as-u8` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::char_lit_as_u8)]`
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/deref_addrof.fixed b/tests/ui/deref_addrof.fixed
index 35dbd790e890c..ffe7f7d144084 100644
--- a/tests/ui/deref_addrof.fixed
+++ b/tests/ui/deref_addrof.fixed
@@ -1,11 +1,11 @@
-//@aux-build:proc_macros.rs
-
-#![allow(clippy::return_self_not_must_use, clippy::useless_vec)]
+#![allow(
+    dangerous_implicit_autorefs,
+    clippy::explicit_auto_deref,
+    clippy::return_self_not_must_use,
+    clippy::useless_vec
+)]
 #![warn(clippy::deref_addrof)]
 
-extern crate proc_macros;
-use proc_macros::inline_macros;
-
 fn get_number() -> usize {
     10
 }
@@ -56,19 +56,75 @@ fn main() {
     //~^ deref_addrof
     // do NOT lint for array as semantic differences with/out `*&`.
     let _arr = *&[0, 1, 2, 3, 4];
+
+    // Do not lint when text comes from macro
+    macro_rules! mac {
+        (dr) => {
+            *&0
+        };
+        (dr $e:expr) => {
+            *&$e
+        };
+        (r $e:expr) => {
+            &$e
+        };
+    }
+    let b = mac!(dr);
+    let b = mac!(dr a);
+    let b = *mac!(r a);
 }
 
-#[derive(Copy, Clone)]
-pub struct S;
-#[inline_macros]
-impl S {
-    pub fn f(&self) -> &Self {
-        inline!($(@expr self))
-        //~^ deref_addrof
+fn issue14386() {
+    use std::mem::ManuallyDrop;
+
+    #[derive(Copy, Clone)]
+    struct Data {
+        num: u64,
     }
-    #[allow(unused_mut)] // mut will be unused, once the macro is fixed
-    pub fn f_mut(mut self) -> Self {
-        inline!($(@expr self))
+
+    #[derive(Clone, Copy)]
+    struct M {
+        md: ManuallyDrop<[u8; 4]>,
+    }
+
+    union DataWithPadding<'lt> {
+        data: ManuallyDrop<Data>,
+        prim: ManuallyDrop<u64>,
+        padding: [u8; size_of::<Data>()],
+        tup: (ManuallyDrop<Data>, ()),
+        indirect: M,
+        indirect_arr: [M; 2],
+        indirect_ref: &'lt mut M,
+    }
+
+    let mut a = DataWithPadding {
+        padding: [0; size_of::<DataWithPadding>()],
+    };
+    unsafe {
+        a.padding = [1; size_of::<DataWithPadding>()];
         //~^ deref_addrof
+        a.tup.1 = ();
+        //~^ deref_addrof
+        *a.prim = 0;
+        //~^ deref_addrof
+
+        (*a.data).num = 42;
+        //~^ deref_addrof
+        (*a.indirect.md)[3] = 1;
+        //~^ deref_addrof
+        (*a.indirect_arr[1].md)[3] = 1;
+        //~^ deref_addrof
+        (*a.indirect_ref.md)[3] = 1;
+        //~^ deref_addrof
+
+        // Check that raw pointers are properly considered as well
+        *a.prim = 0;
+        //~^ deref_addrof
+        (*a.data).num = 42;
+        //~^ deref_addrof
+
+        // Do not lint, as the dereference happens later, we cannot
+        // just remove `&mut`
+        (*&mut a.tup).0.num = 42;
     }
 }
diff --git a/tests/ui/deref_addrof.rs b/tests/ui/deref_addrof.rs
index 96d1b92ef7be9..bc253716affd6 100644
--- a/tests/ui/deref_addrof.rs
+++ b/tests/ui/deref_addrof.rs
@@ -1,11 +1,11 @@
-//@aux-build:proc_macros.rs
-
-#![allow(clippy::return_self_not_must_use, clippy::useless_vec)]
+#![allow(
+    dangerous_implicit_autorefs,
+    clippy::explicit_auto_deref,
+    clippy::return_self_not_must_use,
+    clippy::useless_vec
+)]
 #![warn(clippy::deref_addrof)]
 
-extern crate proc_macros;
-use proc_macros::inline_macros;
-
 fn get_number() -> usize {
     10
 }
@@ -56,19 +56,75 @@ fn main() {
     //~^ deref_addrof
     // do NOT lint for array as semantic differences with/out `*&`.
     let _arr = *&[0, 1, 2, 3, 4];
+
+    // Do not lint when text comes from macro
+    macro_rules! mac {
+        (dr) => {
+            *&0
+        };
+        (dr $e:expr) => {
+            *&$e
+        };
+        (r $e:expr) => {
+            &$e
+        };
+    }
+    let b = mac!(dr);
+    let b = mac!(dr a);
+    let b = *mac!(r a);
 }
 
-#[derive(Copy, Clone)]
-pub struct S;
-#[inline_macros]
-impl S {
-    pub fn f(&self) -> &Self {
-        inline!(*& $(@expr self))
-        //~^ deref_addrof
+fn issue14386() {
+    use std::mem::ManuallyDrop;
+
+    #[derive(Copy, Clone)]
+    struct Data {
+        num: u64,
     }
-    #[allow(unused_mut)] // mut will be unused, once the macro is fixed
-    pub fn f_mut(mut self) -> Self {
-        inline!(*&mut $(@expr self))
+
+    #[derive(Clone, Copy)]
+    struct M {
+        md: ManuallyDrop<[u8; 4]>,
+    }
+
+    union DataWithPadding<'lt> {
+        data: ManuallyDrop<Data>,
+        prim: ManuallyDrop<u64>,
+        padding: [u8; size_of::<Data>()],
+        tup: (ManuallyDrop<Data>, ()),
+        indirect: M,
+        indirect_arr: [M; 2],
+        indirect_ref: &'lt mut M,
+    }
+
+    let mut a = DataWithPadding {
+        padding: [0; size_of::<DataWithPadding>()],
+    };
+    unsafe {
+        (*&mut a.padding) = [1; size_of::<DataWithPadding>()];
         //~^ deref_addrof
+        (*&mut a.tup).1 = ();
+        //~^ deref_addrof
+        **&mut a.prim = 0;
+        //~^ deref_addrof
+
+        (*&mut a.data).num = 42;
+        //~^ deref_addrof
+        (*&mut a.indirect.md)[3] = 1;
+        //~^ deref_addrof
+        (*&mut a.indirect_arr[1].md)[3] = 1;
+        //~^ deref_addrof
+        (*&mut a.indirect_ref.md)[3] = 1;
+        //~^ deref_addrof
+
+        // Check that raw pointers are properly considered as well
+        **&raw mut a.prim = 0;
+        //~^ deref_addrof
+        (*&raw mut a.data).num = 42;
+        //~^ deref_addrof
+
+        // Do not lint, as the dereference happens later, we cannot
+        // just remove `&mut`
+        (*&mut a.tup).0.num = 42;
     }
 }
diff --git a/tests/ui/deref_addrof.stderr b/tests/ui/deref_addrof.stderr
index 81414b625b2fe..65dd904a8f752 100644
--- a/tests/ui/deref_addrof.stderr
+++ b/tests/ui/deref_addrof.stderr
@@ -56,20 +56,58 @@ LL |     let _repeat = *&[0; 64];
    |                   ^^^^^^^^^ help: try: `[0; 64]`
 
 error: immediately dereferencing a reference
-  --> tests/ui/deref_addrof.rs:66:17
+  --> tests/ui/deref_addrof.rs:104:9
    |
-LL |         inline!(*& $(@expr self))
-   |                 ^^^^^^^^^^^^^^^^ help: try: `$(@expr self)`
+LL |         (*&mut a.padding) = [1; size_of::<DataWithPadding>()];
+   |         ^^^^^^^^^^^^^^^^^ help: try: `a.padding`
+
+error: immediately dereferencing a reference
+  --> tests/ui/deref_addrof.rs:106:9
+   |
+LL |         (*&mut a.tup).1 = ();
+   |         ^^^^^^^^^^^^^ help: try: `a.tup`
+
+error: immediately dereferencing a reference
+  --> tests/ui/deref_addrof.rs:108:10
    |
-   = note: this error originates in the macro `__inline_mac_impl` (in Nightly builds, run with -Z macro-backtrace for more info)
+LL |         **&mut a.prim = 0;
+   |          ^^^^^^^^^^^^ help: try: `a.prim`
 
 error: immediately dereferencing a reference
-  --> tests/ui/deref_addrof.rs:71:17
+  --> tests/ui/deref_addrof.rs:111:9
    |
-LL |         inline!(*&mut $(@expr self))
-   |                 ^^^^^^^^^^^^^^^^^^^ help: try: `$(@expr self)`
+LL |         (*&mut a.data).num = 42;
+   |         ^^^^^^^^^^^^^^ help: try: `(*a.data)`
+
+error: immediately dereferencing a reference
+  --> tests/ui/deref_addrof.rs:113:9
+   |
+LL |         (*&mut a.indirect.md)[3] = 1;
+   |         ^^^^^^^^^^^^^^^^^^^^^ help: try: `(*a.indirect.md)`
+
+error: immediately dereferencing a reference
+  --> tests/ui/deref_addrof.rs:115:9
+   |
+LL |         (*&mut a.indirect_arr[1].md)[3] = 1;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(*a.indirect_arr[1].md)`
+
+error: immediately dereferencing a reference
+  --> tests/ui/deref_addrof.rs:117:9
+   |
+LL |         (*&mut a.indirect_ref.md)[3] = 1;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(*a.indirect_ref.md)`
+
+error: immediately dereferencing a reference
+  --> tests/ui/deref_addrof.rs:121:10
+   |
+LL |         **&raw mut a.prim = 0;
+   |          ^^^^^^^^^^^^^^^^ help: try: `a.prim`
+
+error: immediately dereferencing a reference
+  --> tests/ui/deref_addrof.rs:123:9
    |
-   = note: this error originates in the macro `__inline_mac_impl` (in Nightly builds, run with -Z macro-backtrace for more info)
+LL |         (*&raw mut a.data).num = 42;
+   |         ^^^^^^^^^^^^^^^^^^ help: try: `(*a.data)`
 
-error: aborting due to 11 previous errors
+error: aborting due to 18 previous errors
 
diff --git a/tests/ui/doc/doc-fixable.fixed b/tests/ui/doc/doc-fixable.fixed
index bbbd5973036ec..423a73734daab 100644
--- a/tests/ui/doc/doc-fixable.fixed
+++ b/tests/ui/doc/doc-fixable.fixed
@@ -74,7 +74,7 @@ fn test_units() {
 /// GitHub GitLab
 /// IPv4 IPv6
 /// ClojureScript CoffeeScript JavaScript PostScript PureScript TypeScript
-/// WebAssembly
+/// PowerPC WebAssembly
 /// NaN NaNs
 /// OAuth GraphQL
 /// OCaml
diff --git a/tests/ui/doc/doc-fixable.rs b/tests/ui/doc/doc-fixable.rs
index 1077d3580d3c3..8deffb4210e43 100644
--- a/tests/ui/doc/doc-fixable.rs
+++ b/tests/ui/doc/doc-fixable.rs
@@ -74,7 +74,7 @@ fn test_units() {
 /// GitHub GitLab
 /// IPv4 IPv6
 /// ClojureScript CoffeeScript JavaScript PostScript PureScript TypeScript
-/// WebAssembly
+/// PowerPC WebAssembly
 /// NaN NaNs
 /// OAuth GraphQL
 /// OCaml
diff --git a/tests/ui/double_ended_iterator_last.fixed b/tests/ui/double_ended_iterator_last.fixed
index be31ee5fb4862..180a513d0f8e6 100644
--- a/tests/ui/double_ended_iterator_last.fixed
+++ b/tests/ui/double_ended_iterator_last.fixed
@@ -81,6 +81,11 @@ fn issue_14139() {
     let (subindex, _) = (index.by_ref().take(3), 42);
     let _ = subindex.last();
     let _ = index.next();
+
+    let mut index = [true, true, false, false, false, true].iter();
+    let subindex = (index.by_ref().take(3), 42);
+    let _ = subindex.0.last();
+    let _ = index.next();
 }
 
 fn drop_order() {
@@ -108,6 +113,12 @@ fn drop_order() {
     let mut v = DropDeIterator(v.into_iter());
     println!("Last element is {}", v.next_back().unwrap().0);
     //~^ ERROR: called `Iterator::last` on a `DoubleEndedIterator`
+
+    let v = vec![S("four"), S("five"), S("six")];
+    let mut v = (DropDeIterator(v.into_iter()), 42);
+    println!("Last element is {}", v.0.next_back().unwrap().0);
+    //~^ ERROR: called `Iterator::last` on a `DoubleEndedIterator`
+
     println!("Done");
 }
 
diff --git a/tests/ui/double_ended_iterator_last.rs b/tests/ui/double_ended_iterator_last.rs
index 30864e15bce7e..3dd72cfeaac73 100644
--- a/tests/ui/double_ended_iterator_last.rs
+++ b/tests/ui/double_ended_iterator_last.rs
@@ -81,6 +81,11 @@ fn issue_14139() {
     let (subindex, _) = (index.by_ref().take(3), 42);
     let _ = subindex.last();
     let _ = index.next();
+
+    let mut index = [true, true, false, false, false, true].iter();
+    let subindex = (index.by_ref().take(3), 42);
+    let _ = subindex.0.last();
+    let _ = index.next();
 }
 
 fn drop_order() {
@@ -108,6 +113,12 @@ fn drop_order() {
     let v = DropDeIterator(v.into_iter());
     println!("Last element is {}", v.last().unwrap().0);
     //~^ ERROR: called `Iterator::last` on a `DoubleEndedIterator`
+
+    let v = vec![S("four"), S("five"), S("six")];
+    let v = (DropDeIterator(v.into_iter()), 42);
+    println!("Last element is {}", v.0.last().unwrap().0);
+    //~^ ERROR: called `Iterator::last` on a `DoubleEndedIterator`
+
     println!("Done");
 }
 
diff --git a/tests/ui/double_ended_iterator_last.stderr b/tests/ui/double_ended_iterator_last.stderr
index 72a6ead47a931..0f0056be37695 100644
--- a/tests/ui/double_ended_iterator_last.stderr
+++ b/tests/ui/double_ended_iterator_last.stderr
@@ -18,7 +18,7 @@ LL |     let _ = DeIterator.last();
    |                        help: try: `next_back()`
 
 error: called `Iterator::last` on a `DoubleEndedIterator`; this will needlessly iterate the entire iterator
-  --> tests/ui/double_ended_iterator_last.rs:109:36
+  --> tests/ui/double_ended_iterator_last.rs:114:36
    |
 LL |     println!("Last element is {}", v.last().unwrap().0);
    |                                    ^^^^^^^^
@@ -30,5 +30,18 @@ LL ~     let mut v = DropDeIterator(v.into_iter());
 LL ~     println!("Last element is {}", v.next_back().unwrap().0);
    |
 
-error: aborting due to 3 previous errors
+error: called `Iterator::last` on a `DoubleEndedIterator`; this will needlessly iterate the entire iterator
+  --> tests/ui/double_ended_iterator_last.rs:119:36
+   |
+LL |     println!("Last element is {}", v.0.last().unwrap().0);
+   |                                    ^^^^^^^^^^
+   |
+   = note: this change will alter drop order which may be undesirable
+help: try
+   |
+LL ~     let mut v = (DropDeIterator(v.into_iter()), 42);
+LL ~     println!("Last element is {}", v.0.next_back().unwrap().0);
+   |
+
+error: aborting due to 4 previous errors
 
diff --git a/tests/ui/double_ended_iterator_last_unfixable.rs b/tests/ui/double_ended_iterator_last_unfixable.rs
deleted file mode 100644
index 73f62ac124698..0000000000000
--- a/tests/ui/double_ended_iterator_last_unfixable.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-//@no-rustfix: requires manual changes
-#![warn(clippy::double_ended_iterator_last)]
-
-// Should not be linted because applying the lint would move the original iterator. This can only be
-// linted if the iterator is used thereafter.
-fn main() {
-    let mut index = [true, true, false, false, false, true].iter();
-    let subindex = (index.by_ref().take(3), 42);
-    let _ = subindex.0.last();
-    let _ = index.next();
-}
-
-fn drop_order() {
-    struct DropDeIterator(std::vec::IntoIter<S>);
-    impl Iterator for DropDeIterator {
-        type Item = S;
-        fn next(&mut self) -> Option<Self::Item> {
-            self.0.next()
-        }
-    }
-    impl DoubleEndedIterator for DropDeIterator {
-        fn next_back(&mut self) -> Option<Self::Item> {
-            self.0.next_back()
-        }
-    }
-
-    struct S(&'static str);
-    impl std::ops::Drop for S {
-        fn drop(&mut self) {
-            println!("Dropping {}", self.0);
-        }
-    }
-
-    let v = vec![S("one"), S("two"), S("three")];
-    let v = (DropDeIterator(v.into_iter()), 42);
-    println!("Last element is {}", v.0.last().unwrap().0);
-    //~^ ERROR: called `Iterator::last` on a `DoubleEndedIterator`
-    println!("Done");
-}
diff --git a/tests/ui/double_ended_iterator_last_unfixable.stderr b/tests/ui/double_ended_iterator_last_unfixable.stderr
deleted file mode 100644
index e330a22a35489..0000000000000
--- a/tests/ui/double_ended_iterator_last_unfixable.stderr
+++ /dev/null
@@ -1,19 +0,0 @@
-error: called `Iterator::last` on a `DoubleEndedIterator`; this will needlessly iterate the entire iterator
-  --> tests/ui/double_ended_iterator_last_unfixable.rs:36:36
-   |
-LL |     println!("Last element is {}", v.0.last().unwrap().0);
-   |                                    ^^^^------
-   |                                        |
-   |                                        help: try: `next_back()`
-   |
-   = note: this change will alter drop order which may be undesirable
-note: this must be made mutable to use `.next_back()`
-  --> tests/ui/double_ended_iterator_last_unfixable.rs:36:36
-   |
-LL |     println!("Last element is {}", v.0.last().unwrap().0);
-   |                                    ^^^
-   = note: `-D clippy::double-ended-iterator-last` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::double_ended_iterator_last)]`
-
-error: aborting due to 1 previous error
-
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index c93b83f53ecb6..3d2b41b8fb81c 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -1,3 +1,6 @@
+// we have some HELP annotations -- don't complain about them not being present everywhere
+//@require-annotations-for-level: ERROR
+
 #![warn(clippy::redundant_closure, clippy::redundant_closure_for_method_calls)]
 #![allow(unused)]
 #![allow(
@@ -561,3 +564,29 @@ fn issue_14789() {
         std::convert::identity,
     );
 }
+
+fn issue8817() {
+    fn f(_: u32) -> u32 {
+        todo!()
+    }
+    let g = |_: u32| -> u32 { todo!() };
+    struct S(u32);
+    enum MyError {
+        A(S),
+    }
+
+    Some(5)
+        .map(f)
+        //~^ redundant_closure
+        //~| HELP: replace the closure with the function itself
+        .map(g)
+        //~^ redundant_closure
+        //~| HELP: replace the closure with the function itself
+        .map(S)
+        //~^ redundant_closure
+        //~| HELP: replace the closure with the tuple struct itself
+        .map(MyError::A)
+        //~^ redundant_closure
+        //~| HELP: replace the closure with the tuple variant itself
+        .unwrap(); // just for nicer formatting
+}
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index 273c8b21f4ad8..79d1103410d9d 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -1,3 +1,6 @@
+// we have some HELP annotations -- don't complain about them not being present everywhere
+//@require-annotations-for-level: ERROR
+
 #![warn(clippy::redundant_closure, clippy::redundant_closure_for_method_calls)]
 #![allow(unused)]
 #![allow(
@@ -561,3 +564,29 @@ fn issue_14789() {
         std::convert::identity,
     );
 }
+
+fn issue8817() {
+    fn f(_: u32) -> u32 {
+        todo!()
+    }
+    let g = |_: u32| -> u32 { todo!() };
+    struct S(u32);
+    enum MyError {
+        A(S),
+    }
+
+    Some(5)
+        .map(|n| f(n))
+        //~^ redundant_closure
+        //~| HELP: replace the closure with the function itself
+        .map(|n| g(n))
+        //~^ redundant_closure
+        //~| HELP: replace the closure with the function itself
+        .map(|n| S(n))
+        //~^ redundant_closure
+        //~| HELP: replace the closure with the tuple struct itself
+        .map(|n| MyError::A(n))
+        //~^ redundant_closure
+        //~| HELP: replace the closure with the tuple variant itself
+        .unwrap(); // just for nicer formatting
+}
diff --git a/tests/ui/eta.stderr b/tests/ui/eta.stderr
index 8bc08add2fab3..aa32ed1a38ef6 100644
--- a/tests/ui/eta.stderr
+++ b/tests/ui/eta.stderr
@@ -1,5 +1,5 @@
 error: redundant closure
-  --> tests/ui/eta.rs:31:27
+  --> tests/ui/eta.rs:34: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:36:40
+  --> tests/ui/eta.rs:39: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:39:35
+  --> tests/ui/eta.rs:42: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:42:26
+  --> tests/ui/eta.rs:45: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:51:27
+  --> tests/ui/eta.rs:54: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:104:51
+  --> tests/ui/eta.rs:107:51
    |
 LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
    |                                                   ^^^^^^^^^^^ help: replace the closure with the method itself: `TestStruct::foo`
@@ -41,178 +41,202 @@ 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:106:51
+  --> tests/ui/eta.rs:109: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:109:42
+  --> tests/ui/eta.rs:112: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:114:29
+  --> tests/ui/eta.rs:117: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:116:27
+  --> tests/ui/eta.rs:119: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:119:65
+  --> tests/ui/eta.rs:122: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:136:23
+  --> tests/ui/eta.rs:139:23
    |
 LL |         let _ = x.map(|x| x.parse::<i16>());
    |                       ^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `str::parse::<i16>`
 
 error: redundant closure
-  --> tests/ui/eta.rs:189:22
+  --> tests/ui/eta.rs:192:22
    |
 LL |     requires_fn_once(|| x());
    |                      ^^^^^^ help: replace the closure with the function itself: `x`
 
 error: redundant closure
-  --> tests/ui/eta.rs:197:27
+  --> tests/ui/eta.rs:200: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:203:27
+  --> tests/ui/eta.rs:206: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:236:28
+  --> tests/ui/eta.rs:239: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:238:28
+  --> tests/ui/eta.rs:241: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:240:28
+  --> tests/ui/eta.rs:243: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:248:21
+  --> tests/ui/eta.rs:251: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:253:21
+  --> tests/ui/eta.rs:256: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:347:18
+  --> tests/ui/eta.rs:350:18
    |
 LL |     takes_fn_mut(|| f());
    |                  ^^^^^^ help: replace the closure with the function itself: `&mut f`
 
 error: redundant closure
-  --> tests/ui/eta.rs:351:19
+  --> tests/ui/eta.rs:354:19
    |
 LL |     takes_fn_once(|| f());
    |                   ^^^^^^ help: replace the closure with the function itself: `&mut f`
 
 error: redundant closure
-  --> tests/ui/eta.rs:356:26
+  --> tests/ui/eta.rs:359: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:369:19
+  --> tests/ui/eta.rs:372: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:373:19
+  --> tests/ui/eta.rs:376: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:377:17
+  --> tests/ui/eta.rs:380: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:382:17
+  --> tests/ui/eta.rs:385: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:443:19
+  --> tests/ui/eta.rs:446: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:472:22
+  --> tests/ui/eta.rs:475:22
    |
 LL |             test.map(|t| t.method())
    |                      ^^^^^^^^^^^^^^ help: replace the closure with the method itself: `Test::method`
 
 error: redundant closure
-  --> tests/ui/eta.rs:477:22
+  --> tests/ui/eta.rs:480: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:491:18
+  --> tests/ui/eta.rs:494: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:499:30
+  --> tests/ui/eta.rs:502: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:519:38
+  --> tests/ui/eta.rs:522: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:524:38
+  --> tests/ui/eta.rs:527: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:542:35
+  --> tests/ui/eta.rs:545:35
    |
 LL |         let _field = bind.or_else(|| get_default()).unwrap();
    |                                   ^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `get_default`
 
-error: aborting due to 35 previous errors
+error: redundant closure
+  --> tests/ui/eta.rs:588:14
+   |
+LL |         .map(|n| MyError::A(n))
+   |              ^^^^^^^^^^^^^^^^^ help: replace the closure with the tuple variant itself: `MyError::A`
+
+error: redundant closure
+  --> tests/ui/eta.rs:585:14
+   |
+LL |         .map(|n| S(n))
+   |              ^^^^^^^^ help: replace the closure with the tuple struct itself: `S`
+
+error: redundant closure
+  --> tests/ui/eta.rs:582:14
+   |
+LL |         .map(|n| g(n))
+   |              ^^^^^^^^ help: replace the closure with the function itself: `g`
+
+error: redundant closure
+  --> tests/ui/eta.rs:579:14
+   |
+LL |         .map(|n| f(n))
+   |              ^^^^^^^^ help: replace the closure with the function itself: `f`
+
+error: aborting due to 39 previous errors
 
diff --git a/tests/ui/from_str_radix_10.fixed b/tests/ui/from_str_radix_10.fixed
index 4b8fd778685e0..47d24167e56c8 100644
--- a/tests/ui/from_str_radix_10.fixed
+++ b/tests/ui/from_str_radix_10.fixed
@@ -74,3 +74,13 @@ fn issue_12731() {
         let _ = u32::from_str_radix("123", 10);
     }
 }
+
+fn fix_str_ref_check() {
+    #![allow(clippy::needless_borrow)]
+    let s = "1";
+    let _ = s.parse::<u32>().unwrap();
+    //~^ from_str_radix_10
+    let s_ref = &s;
+    let _ = s_ref.parse::<u32>().unwrap();
+    //~^ from_str_radix_10
+}
diff --git a/tests/ui/from_str_radix_10.rs b/tests/ui/from_str_radix_10.rs
index 89002b11a9950..952e19b57a002 100644
--- a/tests/ui/from_str_radix_10.rs
+++ b/tests/ui/from_str_radix_10.rs
@@ -74,3 +74,13 @@ fn issue_12731() {
         let _ = u32::from_str_radix("123", 10);
     }
 }
+
+fn fix_str_ref_check() {
+    #![allow(clippy::needless_borrow)]
+    let s = "1";
+    let _ = u32::from_str_radix(&s, 10).unwrap();
+    //~^ from_str_radix_10
+    let s_ref = &s;
+    let _ = u32::from_str_radix(&s_ref, 10).unwrap();
+    //~^ from_str_radix_10
+}
diff --git a/tests/ui/from_str_radix_10.stderr b/tests/ui/from_str_radix_10.stderr
index c693e8f50ff68..d4e6c3657f207 100644
--- a/tests/ui/from_str_radix_10.stderr
+++ b/tests/ui/from_str_radix_10.stderr
@@ -49,5 +49,17 @@ error: this call to `from_str_radix` can be replaced with a call to `str::parse`
 LL |     i32::from_str_radix(&stringier, 10)?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `stringier.parse::<i32>()`
 
-error: aborting due to 8 previous errors
+error: this call to `from_str_radix` can be replaced with a call to `str::parse`
+  --> tests/ui/from_str_radix_10.rs:81:13
+   |
+LL |     let _ = u32::from_str_radix(&s, 10).unwrap();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `s.parse::<u32>()`
+
+error: this call to `from_str_radix` can be replaced with a call to `str::parse`
+  --> tests/ui/from_str_radix_10.rs:84:13
+   |
+LL |     let _ = u32::from_str_radix(&s_ref, 10).unwrap();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `s_ref.parse::<u32>()`
+
+error: aborting due to 10 previous errors
 
diff --git a/tests/ui/functions_maxlines.rs b/tests/ui/functions_maxlines.rs
index e0990dadaaa91..b071455246180 100644
--- a/tests/ui/functions_maxlines.rs
+++ b/tests/ui/functions_maxlines.rs
@@ -1,3 +1,4 @@
+#![allow(clippy::unused_unit, clippy::missing_safety_doc)]
 #![warn(clippy::too_many_lines)]
 
 fn good_lines() {
@@ -55,7 +56,8 @@ fn good_lines() {
     println!("This is good.");
 }
 
-fn bad_lines() {
+#[allow(unused)] // the attr shouldn't get included in the highlight
+pub async unsafe extern "Rust" fn bad_lines() -> () {
     //~^ too_many_lines
 
     println!("Dont get confused by braces: {{}}");
@@ -162,4 +164,115 @@ fn bad_lines() {
     println!("This is bad.");
 }
 
+struct Foo;
+impl Foo {
+    #[allow(unused)] // the attr shouldn't get included in the highlight
+    pub async unsafe extern "Rust" fn bad_lines() -> () {
+        //~^ too_many_lines
+
+        println!("Dont get confused by braces: {{}}");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+        println!("This is bad.");
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/functions_maxlines.stderr b/tests/ui/functions_maxlines.stderr
index f42a2b2a22a2f..4c3faf45c4722 100644
--- a/tests/ui/functions_maxlines.stderr
+++ b/tests/ui/functions_maxlines.stderr
@@ -1,17 +1,17 @@
-error: this function has too many lines (102/100)
-  --> tests/ui/functions_maxlines.rs:58:1
+error: this function has too many lines (104/100)
+  --> tests/ui/functions_maxlines.rs:60:1
    |
-LL | / fn bad_lines() {
-LL | |
-LL | |
-LL | |     println!("Dont get confused by braces: {{}}");
-...  |
-LL | |     println!("This is bad.");
-LL | | }
-   | |_^
+LL | pub async unsafe extern "Rust" fn bad_lines() -> () {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::too-many-lines` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::too_many_lines)]`
 
-error: aborting due to 1 previous error
+error: this function has too many lines (104/100)
+  --> tests/ui/functions_maxlines.rs:170:5
+   |
+LL |     pub async unsafe extern "Rust" fn bad_lines() -> () {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
 
diff --git a/tests/ui/infinite_loops.rs b/tests/ui/infinite_loops.rs
index fcd1f795fff09..9b8c39331970c 100644
--- a/tests/ui/infinite_loops.rs
+++ b/tests/ui/infinite_loops.rs
@@ -450,4 +450,75 @@ mod issue_12338 {
     }
 }
 
+#[allow(clippy::let_underscore_future, clippy::empty_loop)]
+mod issue_14000 {
+    use super::do_something;
+
+    async fn foo() {
+        let _ = async move {
+            loop {
+                //~^ infinite_loop
+                do_something();
+            }
+        }
+        .await;
+        let _ = async move {
+            loop {
+                //~^ infinite_loop
+                continue;
+            }
+        }
+        .await;
+    }
+
+    fn bar() {
+        let _ = async move {
+            loop {
+                do_something();
+            }
+        };
+
+        let _ = async move {
+            loop {
+                continue;
+            }
+        };
+    }
+}
+
+#[allow(clippy::let_underscore_future)]
+mod tokio_spawn_test {
+    use super::do_something;
+
+    fn install_ticker() {
+        // This should NOT trigger the lint because the async block is spawned, not awaited
+        std::thread::spawn(move || {
+            async move {
+                loop {
+                    // This loop should not trigger infinite_loop lint
+                    do_something();
+                }
+            }
+        });
+    }
+
+    fn spawn_async_block() {
+        // This should NOT trigger the lint because the async block is not awaited
+        let _handle = async move {
+            loop {
+                do_something();
+            }
+        };
+    }
+
+    fn await_async_block() {
+        // This SHOULD trigger the lint because the async block is awaited
+        let _ = async move {
+            loop {
+                do_something();
+            }
+        };
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/infinite_loops.stderr b/tests/ui/infinite_loops.stderr
index 4d02636ef4aef..4c6b6f725f130 100644
--- a/tests/ui/infinite_loops.stderr
+++ b/tests/ui/infinite_loops.stderr
@@ -311,5 +311,27 @@ help: if this is intentional, consider specifying `!` as function return
 LL | fn continue_outer() -> ! {
    |                     ++++
 
-error: aborting due to 21 previous errors
+error: infinite loop detected
+  --> tests/ui/infinite_loops.rs:459:13
+   |
+LL | /             loop {
+LL | |
+LL | |                 do_something();
+LL | |             }
+   | |_____________^
+   |
+   = help: if this is not intended, try adding a `break` or `return` condition in the loop
+
+error: infinite loop detected
+  --> tests/ui/infinite_loops.rs:466:13
+   |
+LL | /             loop {
+LL | |
+LL | |                 continue;
+LL | |             }
+   | |_____________^
+   |
+   = help: if this is not intended, try adding a `break` or `return` condition in the loop
+
+error: aborting due to 23 previous errors
 
diff --git a/tests/ui/match_bool.fixed b/tests/ui/match_bool.fixed
index 1dfb82db12061..876ae935afded 100644
--- a/tests/ui/match_bool.fixed
+++ b/tests/ui/match_bool.fixed
@@ -61,4 +61,17 @@ fn issue14099() {
     } }
 }
 
+fn issue15351() {
+    let mut d = false;
+    match d {
+        false => println!("foo"),
+        ref mut d => *d = false,
+    }
+
+    match d {
+        false => println!("foo"),
+        e => println!("{e}"),
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/match_bool.rs b/tests/ui/match_bool.rs
index 719b4e51eb6d9..a134ad8346e27 100644
--- a/tests/ui/match_bool.rs
+++ b/tests/ui/match_bool.rs
@@ -113,4 +113,17 @@ fn issue14099() {
     }
 }
 
+fn issue15351() {
+    let mut d = false;
+    match d {
+        false => println!("foo"),
+        ref mut d => *d = false,
+    }
+
+    match d {
+        false => println!("foo"),
+        e => println!("{e}"),
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/match_ref_pats.fixed b/tests/ui/match_ref_pats.fixed
index 8add3da0c99f0..f727546838b43 100644
--- a/tests/ui/match_ref_pats.fixed
+++ b/tests/ui/match_ref_pats.fixed
@@ -1,6 +1,12 @@
 #![warn(clippy::match_ref_pats)]
 #![allow(dead_code, unused_variables)]
-#![allow(clippy::enum_variant_names, clippy::equatable_if_let, clippy::uninlined_format_args)]
+#![allow(
+    clippy::enum_variant_names,
+    clippy::equatable_if_let,
+    clippy::uninlined_format_args,
+    clippy::empty_loop,
+    clippy::diverging_sub_expression
+)]
 
 fn ref_pats() {
     {
@@ -120,4 +126,32 @@ mod issue_7740 {
     }
 }
 
+mod issue15378 {
+    fn never_in_match() {
+        match unimplemented!() {
+            &_ => {},
+            &&&42 => {
+                todo!()
+            },
+            _ => {},
+        }
+
+        match panic!() {
+            &_ => {},
+            &&&42 => {
+                todo!()
+            },
+            _ => {},
+        }
+
+        match loop {} {
+            &_ => {},
+            &&&42 => {
+                todo!()
+            },
+            _ => {},
+        }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/match_ref_pats.rs b/tests/ui/match_ref_pats.rs
index 07889b0dfc243..eca4d584acd2b 100644
--- a/tests/ui/match_ref_pats.rs
+++ b/tests/ui/match_ref_pats.rs
@@ -1,6 +1,12 @@
 #![warn(clippy::match_ref_pats)]
 #![allow(dead_code, unused_variables)]
-#![allow(clippy::enum_variant_names, clippy::equatable_if_let, clippy::uninlined_format_args)]
+#![allow(
+    clippy::enum_variant_names,
+    clippy::equatable_if_let,
+    clippy::uninlined_format_args,
+    clippy::empty_loop,
+    clippy::diverging_sub_expression
+)]
 
 fn ref_pats() {
     {
@@ -120,4 +126,32 @@ mod issue_7740 {
     }
 }
 
+mod issue15378 {
+    fn never_in_match() {
+        match unimplemented!() {
+            &_ => {},
+            &&&42 => {
+                todo!()
+            },
+            _ => {},
+        }
+
+        match panic!() {
+            &_ => {},
+            &&&42 => {
+                todo!()
+            },
+            _ => {},
+        }
+
+        match loop {} {
+            &_ => {},
+            &&&42 => {
+                todo!()
+            },
+            _ => {},
+        }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/match_ref_pats.stderr b/tests/ui/match_ref_pats.stderr
index f81b290b32cb8..ecb08e6972d9a 100644
--- a/tests/ui/match_ref_pats.stderr
+++ b/tests/ui/match_ref_pats.stderr
@@ -1,5 +1,5 @@
 error: you don't need to add `&` to all patterns
-  --> tests/ui/match_ref_pats.rs:8:9
+  --> tests/ui/match_ref_pats.rs:14:9
    |
 LL | /         match v {
 LL | |
@@ -19,7 +19,7 @@ LL ~             None => println!("none"),
    |
 
 error: you don't need to add `&` to both the expression and the patterns
-  --> tests/ui/match_ref_pats.rs:26:5
+  --> tests/ui/match_ref_pats.rs:32:5
    |
 LL | /     match &w {
 LL | |
@@ -37,7 +37,7 @@ LL ~         None => println!("none"),
    |
 
 error: redundant pattern matching, consider using `is_none()`
-  --> tests/ui/match_ref_pats.rs:39:12
+  --> tests/ui/match_ref_pats.rs:45:12
    |
 LL |     if let &None = a {
    |     -------^^^^^---- help: try: `if a.is_none()`
@@ -46,13 +46,13 @@ LL |     if let &None = a {
    = help: to override `-D warnings` add `#[allow(clippy::redundant_pattern_matching)]`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> tests/ui/match_ref_pats.rs:45:12
+  --> tests/ui/match_ref_pats.rs:51:12
    |
 LL |     if let &None = &b {
    |     -------^^^^^----- help: try: `if b.is_none()`
 
 error: you don't need to add `&` to all patterns
-  --> tests/ui/match_ref_pats.rs:106:9
+  --> tests/ui/match_ref_pats.rs:112:9
    |
 LL | /         match foobar_variant!(0) {
 LL | |
diff --git a/tests/ui/ptr_as_ptr.fixed b/tests/ui/ptr_as_ptr.fixed
index 71fea6144e764..78e1ceb480a5f 100644
--- a/tests/ui/ptr_as_ptr.fixed
+++ b/tests/ui/ptr_as_ptr.fixed
@@ -2,8 +2,8 @@
 
 #![warn(clippy::ptr_as_ptr)]
 
-#[macro_use]
 extern crate proc_macros;
+use proc_macros::{external, inline_macros, with_span};
 
 mod issue_11278_a {
     #[derive(Debug)]
@@ -53,11 +53,13 @@ fn main() {
     //~^ ptr_as_ptr
 
     // Make sure the lint is triggered inside a macro
-    let _ = inline!($ptr.cast::<i32>());
-    //~^ ptr_as_ptr
+    // FIXME: `is_from_proc_macro` incorrectly stops the lint from firing here
+    let _ = inline!($ptr as *const i32);
 
     // Do not lint inside macros from external crates
     let _ = external!($ptr as *const i32);
+
+    let _ = with_span!(expr $ptr as *const i32);
 }
 
 #[clippy::msrv = "1.37"]
diff --git a/tests/ui/ptr_as_ptr.rs b/tests/ui/ptr_as_ptr.rs
index 4d507592a1e3c..70732cf0a6c16 100644
--- a/tests/ui/ptr_as_ptr.rs
+++ b/tests/ui/ptr_as_ptr.rs
@@ -2,8 +2,8 @@
 
 #![warn(clippy::ptr_as_ptr)]
 
-#[macro_use]
 extern crate proc_macros;
+use proc_macros::{external, inline_macros, with_span};
 
 mod issue_11278_a {
     #[derive(Debug)]
@@ -53,11 +53,13 @@ fn main() {
     //~^ ptr_as_ptr
 
     // Make sure the lint is triggered inside a macro
+    // FIXME: `is_from_proc_macro` incorrectly stops the lint from firing here
     let _ = inline!($ptr as *const i32);
-    //~^ ptr_as_ptr
 
     // Do not lint inside macros from external crates
     let _ = external!($ptr as *const i32);
+
+    let _ = with_span!(expr $ptr as *const i32);
 }
 
 #[clippy::msrv = "1.37"]
diff --git a/tests/ui/ptr_as_ptr.stderr b/tests/ui/ptr_as_ptr.stderr
index adad159bb0f27..c0a2a4b6d204d 100644
--- a/tests/ui/ptr_as_ptr.stderr
+++ b/tests/ui/ptr_as_ptr.stderr
@@ -38,174 +38,166 @@ LL |     let _: *mut i32 = mut_ptr as _;
    |                       ^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `mut_ptr.cast()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:56:21
-   |
-LL |     let _ = inline!($ptr as *const i32);
-   |                     ^^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `$ptr.cast::<i32>()`
-   |
-   = note: this error originates in the macro `__inline_mac_fn_main` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:78:13
+  --> tests/ui/ptr_as_ptr.rs:80:13
    |
 LL |     let _ = ptr as *const i32;
    |             ^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `ptr.cast::<i32>()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:80:13
+  --> tests/ui/ptr_as_ptr.rs:82:13
    |
 LL |     let _ = mut_ptr as *mut i32;
    |             ^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `mut_ptr.cast::<i32>()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:88:9
+  --> tests/ui/ptr_as_ptr.rs:90:9
    |
 LL |         ptr::null_mut() as *mut u32
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null_mut::<u32>()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:93:9
+  --> tests/ui/ptr_as_ptr.rs:95:9
    |
 LL |         std::ptr::null_mut() as *mut u32
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `std::ptr::null_mut::<u32>()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:99:9
+  --> tests/ui/ptr_as_ptr.rs:101:9
    |
 LL |         ptr::null_mut() as *mut u32
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null_mut::<u32>()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:104:9
+  --> tests/ui/ptr_as_ptr.rs:106:9
    |
 LL |         core::ptr::null_mut() as *mut u32
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `core::ptr::null_mut::<u32>()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:110:9
+  --> tests/ui/ptr_as_ptr.rs:112:9
    |
 LL |         ptr::null() as *const u32
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null::<u32>()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:115:9
+  --> tests/ui/ptr_as_ptr.rs:117:9
    |
 LL |         std::ptr::null() as *const u32
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `std::ptr::null::<u32>()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:121:9
+  --> tests/ui/ptr_as_ptr.rs:123:9
    |
 LL |         ptr::null() as *const u32
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null::<u32>()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:126:9
+  --> tests/ui/ptr_as_ptr.rs:128:9
    |
 LL |         core::ptr::null() as *const u32
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `core::ptr::null::<u32>()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:134:9
+  --> tests/ui/ptr_as_ptr.rs:136:9
    |
 LL |         ptr::null_mut() as *mut _
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null_mut()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:139:9
+  --> tests/ui/ptr_as_ptr.rs:141:9
    |
 LL |         std::ptr::null_mut() as *mut _
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `std::ptr::null_mut()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:145:9
+  --> tests/ui/ptr_as_ptr.rs:147:9
    |
 LL |         ptr::null_mut() as *mut _
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null_mut()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:150:9
+  --> tests/ui/ptr_as_ptr.rs:152:9
    |
 LL |         core::ptr::null_mut() as *mut _
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `core::ptr::null_mut()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:156:9
+  --> tests/ui/ptr_as_ptr.rs:158:9
    |
 LL |         ptr::null() as *const _
    |         ^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:161:9
+  --> tests/ui/ptr_as_ptr.rs:163:9
    |
 LL |         std::ptr::null() as *const _
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `std::ptr::null()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:167:9
+  --> tests/ui/ptr_as_ptr.rs:169:9
    |
 LL |         ptr::null() as *const _
    |         ^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:172:9
+  --> tests/ui/ptr_as_ptr.rs:174:9
    |
 LL |         core::ptr::null() as *const _
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `core::ptr::null()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:180:9
+  --> tests/ui/ptr_as_ptr.rs:182:9
    |
 LL |         ptr::null_mut() as _
    |         ^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null_mut()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:185:9
+  --> tests/ui/ptr_as_ptr.rs:187:9
    |
 LL |         std::ptr::null_mut() as _
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `std::ptr::null_mut()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:191:9
+  --> tests/ui/ptr_as_ptr.rs:193:9
    |
 LL |         ptr::null_mut() as _
    |         ^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null_mut()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:196:9
+  --> tests/ui/ptr_as_ptr.rs:198:9
    |
 LL |         core::ptr::null_mut() as _
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `core::ptr::null_mut()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:202:9
+  --> tests/ui/ptr_as_ptr.rs:204:9
    |
 LL |         ptr::null() as _
    |         ^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:207:9
+  --> tests/ui/ptr_as_ptr.rs:209:9
    |
 LL |         std::ptr::null() as _
    |         ^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `std::ptr::null()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:213:9
+  --> tests/ui/ptr_as_ptr.rs:215:9
    |
 LL |         ptr::null() as _
    |         ^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:218:9
+  --> tests/ui/ptr_as_ptr.rs:220:9
    |
 LL |         core::ptr::null() as _
    |         ^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `core::ptr::null()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:226:43
+  --> tests/ui/ptr_as_ptr.rs:228:43
    |
 LL |         let _: fn() = std::mem::transmute(std::ptr::null::<()>() as *const u8);
    |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `std::ptr::null::<u8>()`
 
-error: aborting due to 34 previous errors
+error: aborting due to 33 previous errors
 
diff --git a/tests/ui/similar_names.rs b/tests/ui/similar_names.rs
index 69b6ab6220bf2..55a141209f0fc 100644
--- a/tests/ui/similar_names.rs
+++ b/tests/ui/similar_names.rs
@@ -89,6 +89,10 @@ fn main() {
 
     let iter: i32;
     let item: i32;
+
+    // 3 letter names are allowed to be similar
+    let kta: i32;
+    let ktv: i32;
 }
 
 fn foo() {
diff --git a/tests/ui/similar_names.stderr b/tests/ui/similar_names.stderr
index 8d722fb8b564e..c226f73d4db16 100644
--- a/tests/ui/similar_names.stderr
+++ b/tests/ui/similar_names.stderr
@@ -49,13 +49,13 @@ LL |     let parser: i32;
    |         ^^^^^^
 
 error: binding's name is too similar to existing binding
-  --> tests/ui/similar_names.rs:98:16
+  --> tests/ui/similar_names.rs:102:16
    |
 LL |         bpple: sprang,
    |                ^^^^^^
    |
 note: existing binding defined here
-  --> tests/ui/similar_names.rs:97:16
+  --> tests/ui/similar_names.rs:101:16
    |
 LL |         apple: spring,
    |                ^^^^^^
diff --git a/tests/ui/unnecessary_operation.fixed b/tests/ui/unnecessary_operation.fixed
index ac9fa4de20a60..db5409bc491e3 100644
--- a/tests/ui/unnecessary_operation.fixed
+++ b/tests/ui/unnecessary_operation.fixed
@@ -78,25 +78,25 @@ fn main() {
     //~^ unnecessary_operation
     get_number();
     //~^ unnecessary_operation
-    5;get_number();
+    5; get_number();
     //~^ unnecessary_operation
     get_number();
     //~^ unnecessary_operation
     get_number();
     //~^ unnecessary_operation
-    5;6;get_number();
+    5; 6; get_number();
     //~^ unnecessary_operation
     get_number();
     //~^ unnecessary_operation
     get_number();
     //~^ unnecessary_operation
-    5;get_number();
+    5; get_number();
     //~^ unnecessary_operation
-    42;get_number();
+    42; get_number();
     //~^ unnecessary_operation
     assert!([42, 55].len() > get_usize());
     //~^ unnecessary_operation
-    42;get_number();
+    42; get_number();
     //~^ unnecessary_operation
     get_number();
     //~^ unnecessary_operation
diff --git a/tests/ui/unnecessary_operation.stderr b/tests/ui/unnecessary_operation.stderr
index 0fda1dfde1903..3439ba2e33e55 100644
--- a/tests/ui/unnecessary_operation.stderr
+++ b/tests/ui/unnecessary_operation.stderr
@@ -35,7 +35,7 @@ error: unnecessary operation
   --> tests/ui/unnecessary_operation.rs:81:5
    |
 LL |     5 + get_number();
-   |     ^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `5;get_number();`
+   |     ^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `5; get_number();`
 
 error: unnecessary operation
   --> tests/ui/unnecessary_operation.rs:83:5
@@ -53,7 +53,7 @@ error: unnecessary operation
   --> tests/ui/unnecessary_operation.rs:87:5
    |
 LL |     (5, 6, get_number());
-   |     ^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `5;6;get_number();`
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `5; 6; get_number();`
 
 error: unnecessary operation
   --> tests/ui/unnecessary_operation.rs:89:5
@@ -71,13 +71,13 @@ error: unnecessary operation
   --> tests/ui/unnecessary_operation.rs:93:5
    |
 LL |     5..get_number();
-   |     ^^^^^^^^^^^^^^^^ help: statement can be reduced to: `5;get_number();`
+   |     ^^^^^^^^^^^^^^^^ help: statement can be reduced to: `5; get_number();`
 
 error: unnecessary operation
   --> tests/ui/unnecessary_operation.rs:95:5
    |
 LL |     [42, get_number()];
-   |     ^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `42;get_number();`
+   |     ^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `42; get_number();`
 
 error: unnecessary operation
   --> tests/ui/unnecessary_operation.rs:97:5
@@ -89,7 +89,7 @@ error: unnecessary operation
   --> tests/ui/unnecessary_operation.rs:99:5
    |
 LL |     (42, get_number()).1;
-   |     ^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `42;get_number();`
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `42; get_number();`
 
 error: unnecessary operation
   --> tests/ui/unnecessary_operation.rs:101:5
diff --git a/tests/ui/unnecessary_semicolon.edition2021.fixed b/tests/ui/unnecessary_semicolon.edition2021.fixed
index f10d804c8ccc4..797f1505f4992 100644
--- a/tests/ui/unnecessary_semicolon.edition2021.fixed
+++ b/tests/ui/unnecessary_semicolon.edition2021.fixed
@@ -63,3 +63,12 @@ fn issue14100() -> bool {
     // cast into the `bool` function return type.
     if return true {};
 }
+
+fn issue15426(x: u32) {
+    // removing the `;` would turn the stmt into an expr, but attrs aren't allowed on exprs
+    #[rustfmt::skip]
+    match x {
+        0b00 => {}  0b01 => {}
+        0b11 => {}  _    => {}
+    };
+}
diff --git a/tests/ui/unnecessary_semicolon.edition2024.fixed b/tests/ui/unnecessary_semicolon.edition2024.fixed
index 32a3bb9b40819..d2609cea00027 100644
--- a/tests/ui/unnecessary_semicolon.edition2024.fixed
+++ b/tests/ui/unnecessary_semicolon.edition2024.fixed
@@ -63,3 +63,12 @@ fn issue14100() -> bool {
     // cast into the `bool` function return type.
     if return true {};
 }
+
+fn issue15426(x: u32) {
+    // removing the `;` would turn the stmt into an expr, but attrs aren't allowed on exprs
+    #[rustfmt::skip]
+    match x {
+        0b00 => {}  0b01 => {}
+        0b11 => {}  _    => {}
+    };
+}
diff --git a/tests/ui/unnecessary_semicolon.rs b/tests/ui/unnecessary_semicolon.rs
index 91b2821802249..55f1ec84cb0ea 100644
--- a/tests/ui/unnecessary_semicolon.rs
+++ b/tests/ui/unnecessary_semicolon.rs
@@ -63,3 +63,12 @@ fn issue14100() -> bool {
     // cast into the `bool` function return type.
     if return true {};
 }
+
+fn issue15426(x: u32) {
+    // removing the `;` would turn the stmt into an expr, but attrs aren't allowed on exprs
+    #[rustfmt::skip]
+    match x {
+        0b00 => {}  0b01 => {}
+        0b11 => {}  _    => {}
+    };
+}
diff --git a/tests/ui/zero_sized_hashmap_values.rs b/tests/ui/zero_sized_hashmap_values.rs
index dcbfd16843de4..ee2fd19b5ee5a 100644
--- a/tests/ui/zero_sized_hashmap_values.rs
+++ b/tests/ui/zero_sized_hashmap_values.rs
@@ -92,6 +92,14 @@ fn issue14822() {
     //~^ zero_sized_map_values
 }
 
+fn issue15429() {
+    struct E<'a>(&'a [E<'a>]);
+
+    // The assertion error happens when the type being evaluated has escaping bound vars
+    // as it cannot be wrapped in a dummy binder during size computation.
+    type F = dyn for<'a> FnOnce(HashMap<u32, E<'a>>) -> u32;
+}
+
 fn main() {
     let _: HashMap<String, ()> = HashMap::new();
     //~^ zero_sized_map_values
diff --git a/tests/ui/zero_sized_hashmap_values.stderr b/tests/ui/zero_sized_hashmap_values.stderr
index d29491fa05c76..52ffef280c1df 100644
--- a/tests/ui/zero_sized_hashmap_values.stderr
+++ b/tests/ui/zero_sized_hashmap_values.stderr
@@ -89,7 +89,7 @@ LL |     type D = HashMap<u32, S<E>>;
    = help: consider using a set instead
 
 error: map with zero-sized value type
-  --> tests/ui/zero_sized_hashmap_values.rs:96:34
+  --> tests/ui/zero_sized_hashmap_values.rs:104:34
    |
 LL |     let _: HashMap<String, ()> = HashMap::new();
    |                                  ^^^^^^^
@@ -97,7 +97,7 @@ LL |     let _: HashMap<String, ()> = HashMap::new();
    = help: consider using a set instead
 
 error: map with zero-sized value type
-  --> tests/ui/zero_sized_hashmap_values.rs:96:12
+  --> tests/ui/zero_sized_hashmap_values.rs:104:12
    |
 LL |     let _: HashMap<String, ()> = HashMap::new();
    |            ^^^^^^^^^^^^^^^^^^^
@@ -105,7 +105,7 @@ LL |     let _: HashMap<String, ()> = HashMap::new();
    = help: consider using a set instead
 
 error: map with zero-sized value type
-  --> tests/ui/zero_sized_hashmap_values.rs:102:12
+  --> tests/ui/zero_sized_hashmap_values.rs:110:12
    |
 LL |     let _: HashMap<_, _> = std::iter::empty::<(String, ())>().collect();
    |            ^^^^^^^^^^^^^

From 02bc3c94d2489cf7f8a77fb0a5ac2e5c89f0ed0b Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Tue, 19 Aug 2025 23:44:02 +0200
Subject: [PATCH 0161/1889] `get_diagnostic_name` in other places

---
 clippy_lints/src/casts/ptr_as_ptr.rs          | 10 ++---
 clippy_lints/src/large_include_file.rs        |  4 +-
 clippy_lints/src/manual_retain.rs             | 10 ++---
 clippy_lints/src/manual_strip.rs              | 10 ++---
 .../src/methods/iter_out_of_bounds.rs         | 45 +++++++++----------
 .../src/methods/option_as_ref_deref.rs        | 28 +++++-------
 .../src/methods/unnecessary_min_or_max.rs     |  3 +-
 clippy_lints/src/operators/cmp_owned.rs       | 12 ++---
 clippy_lints/src/redundant_clone.rs           | 11 +++--
 clippy_lints/src/strings.rs                   |  7 +--
 clippy_lints/src/types/rc_buffer.rs           |  5 ++-
 .../src/types/redundant_allocation.rs         | 13 +++---
 .../src/unnecessary_owned_empty_strings.rs    |  5 ++-
 clippy_lints/src/unnecessary_wraps.rs         | 10 ++---
 clippy_lints/src/zombie_processes.rs          | 15 ++++---
 15 files changed, 87 insertions(+), 101 deletions(-)

diff --git a/clippy_lints/src/casts/ptr_as_ptr.rs b/clippy_lints/src/casts/ptr_as_ptr.rs
index 890754090989f..c5be504543c24 100644
--- a/clippy_lints/src/casts/ptr_as_ptr.rs
+++ b/clippy_lints/src/casts/ptr_as_ptr.rs
@@ -62,12 +62,10 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, msrv: Msrv)
             && let ExprKind::Path(ref qpath @ QPath::Resolved(None, path)) = func.kind
             && let Some(method_defid) = path.res.opt_def_id()
         {
-            if cx.tcx.is_diagnostic_item(sym::ptr_null, method_defid) {
-                OmitFollowedCastReason::Null(qpath)
-            } else if cx.tcx.is_diagnostic_item(sym::ptr_null_mut, method_defid) {
-                OmitFollowedCastReason::NullMut(qpath)
-            } else {
-                OmitFollowedCastReason::None
+            match cx.tcx.get_diagnostic_name(method_defid) {
+                Some(sym::ptr_null) => OmitFollowedCastReason::Null(qpath),
+                Some(sym::ptr_null_mut) => OmitFollowedCastReason::NullMut(qpath),
+                _ => OmitFollowedCastReason::None,
             }
         } else {
             OmitFollowedCastReason::None
diff --git a/clippy_lints/src/large_include_file.rs b/clippy_lints/src/large_include_file.rs
index 8707612fbdd0a..48ce1afc6e69b 100644
--- a/clippy_lints/src/large_include_file.rs
+++ b/clippy_lints/src/large_include_file.rs
@@ -64,8 +64,8 @@ impl LateLintPass<'_> for LargeIncludeFile {
             }
             && len as u64 > self.max_file_size
             && let Some(macro_call) = root_macro_call_first_node(cx, expr)
-            && (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))
+            && let Some(macro_name) = cx.tcx.get_diagnostic_name(macro_call.def_id)
+            && matches!(macro_name, sym::include_bytes_macro | sym::include_str_macro)
         {
             #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
             span_lint_and_then(
diff --git a/clippy_lints/src/manual_retain.rs b/clippy_lints/src/manual_retain.rs
index 98e8b1f5cf92c..7fb88763e640f 100644
--- a/clippy_lints/src/manual_retain.rs
+++ b/clippy_lints/src/manual_retain.rs
@@ -123,8 +123,8 @@ fn check_iter(
 ) {
     if let hir::ExprKind::MethodCall(_, filter_expr, [], _) = &target_expr.kind
         && let Some(copied_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id)
-        && (cx.tcx.is_diagnostic_item(sym::iter_copied, copied_def_id)
-            || cx.tcx.is_diagnostic_item(sym::iter_cloned, copied_def_id))
+        && let Some(copied_name) = cx.tcx.get_diagnostic_name(copied_def_id)
+        && matches!(copied_name, sym::iter_copied | sym::iter_cloned)
         && let hir::ExprKind::MethodCall(_, iter_expr, [_], _) = &filter_expr.kind
         && let Some(filter_def_id) = cx.typeck_results().type_dependent_def_id(filter_expr.hir_id)
         && cx.tcx.is_diagnostic_item(sym::iter_filter, filter_def_id)
@@ -243,9 +243,9 @@ fn make_sugg(
 }
 
 fn match_acceptable_sym(cx: &LateContext<'_>, collect_def_id: DefId) -> bool {
-    ACCEPTABLE_METHODS
-        .iter()
-        .any(|&method| cx.tcx.is_diagnostic_item(method, collect_def_id))
+    cx.tcx
+        .get_diagnostic_name(collect_def_id)
+        .is_some_and(|collect_name| ACCEPTABLE_METHODS.contains(&collect_name))
 }
 
 fn match_acceptable_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>, msrv: Msrv) -> bool {
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index 6bf43a1c6d47c..07cce4046ca4f 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -75,12 +75,10 @@ impl<'tcx> LateLintPass<'tcx> for ManualStrip {
             && let ExprKind::Path(target_path) = &target_arg.kind
             && let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(cond.hir_id)
         {
-            let strip_kind = if cx.tcx.is_diagnostic_item(sym::str_starts_with, method_def_id) {
-                StripKind::Prefix
-            } else if cx.tcx.is_diagnostic_item(sym::str_ends_with, method_def_id) {
-                StripKind::Suffix
-            } else {
-                return;
+            let strip_kind = match cx.tcx.get_diagnostic_name(method_def_id) {
+                Some(sym::str_starts_with) => StripKind::Prefix,
+                Some(sym::str_ends_with) => StripKind::Suffix,
+                _ => return,
             };
             let target_res = cx.qpath_res(target_path, target_arg.hir_id);
             if target_res == Res::Err {
diff --git a/clippy_lints/src/methods/iter_out_of_bounds.rs b/clippy_lints/src/methods/iter_out_of_bounds.rs
index 9a62b719a8fb8..fa8f9d640ee6e 100644
--- a/clippy_lints/src/methods/iter_out_of_bounds.rs
+++ b/clippy_lints/src/methods/iter_out_of_bounds.rs
@@ -24,32 +24,29 @@ fn get_iterator_length<'tcx>(cx: &LateContext<'tcx>, iter: &'tcx Expr<'tcx>) ->
     let ty::Adt(adt, substs) = cx.typeck_results().expr_ty(iter).kind() else {
         return None;
     };
-    let did = adt.did();
 
-    if cx.tcx.is_diagnostic_item(sym::ArrayIntoIter, did) {
-        // For array::IntoIter<T, const N: usize>, the length is the second generic
-        // parameter.
-        substs.const_at(1).try_to_target_usize(cx.tcx).map(u128::from)
-    } else if cx.tcx.is_diagnostic_item(sym::SliceIter, did)
-        && let ExprKind::MethodCall(_, recv, ..) = iter.kind
-    {
-        if let ty::Array(_, len) = cx.typeck_results().expr_ty(recv).peel_refs().kind() {
-            // For slice::Iter<'_, T>, the receiver might be an array literal: [1,2,3].iter().skip(..)
-            len.try_to_target_usize(cx.tcx).map(u128::from)
-        } else if let Some(args) = VecArgs::hir(cx, expr_or_init(cx, recv)) {
-            match args {
-                VecArgs::Vec(vec) => vec.len().try_into().ok(),
-                VecArgs::Repeat(_, len) => expr_as_u128(cx, len),
+    match cx.tcx.get_diagnostic_name(adt.did()) {
+        Some(sym::ArrayIntoIter) => {
+            // For array::IntoIter<T, const N: usize>, the length is the second generic
+            // parameter.
+            substs.const_at(1).try_to_target_usize(cx.tcx).map(u128::from)
+        },
+        Some(sym::SliceIter) if let ExprKind::MethodCall(_, recv, ..) = iter.kind => {
+            if let ty::Array(_, len) = cx.typeck_results().expr_ty(recv).peel_refs().kind() {
+                // For slice::Iter<'_, T>, the receiver might be an array literal: [1,2,3].iter().skip(..)
+                len.try_to_target_usize(cx.tcx).map(u128::from)
+            } else if let Some(args) = VecArgs::hir(cx, expr_or_init(cx, recv)) {
+                match args {
+                    VecArgs::Vec(vec) => vec.len().try_into().ok(),
+                    VecArgs::Repeat(_, len) => expr_as_u128(cx, len),
+                }
+            } else {
+                None
             }
-        } else {
-            None
-        }
-    } else if cx.tcx.is_diagnostic_item(sym::IterEmpty, did) {
-        Some(0)
-    } else if cx.tcx.is_diagnostic_item(sym::IterOnce, did) {
-        Some(1)
-    } else {
-        None
+        },
+        Some(sym::IterEmpty) => Some(0),
+        Some(sym::IterOnce) => Some(1),
+        _ => None,
     }
 }
 
diff --git a/clippy_lints/src/methods/option_as_ref_deref.rs b/clippy_lints/src/methods/option_as_ref_deref.rs
index 63ee922acfa0d..906ead16fd0d1 100644
--- a/clippy_lints/src/methods/option_as_ref_deref.rs
+++ b/clippy_lints/src/methods/option_as_ref_deref.rs
@@ -38,17 +38,13 @@ pub(super) fn check(
     ];
 
     let is_deref = match map_arg.kind {
-        hir::ExprKind::Path(ref expr_qpath) => {
-            cx.qpath_res(expr_qpath, map_arg.hir_id)
-                .opt_def_id()
-                .is_some_and(|fun_def_id| {
-                    cx.tcx.is_diagnostic_item(sym::deref_method, fun_def_id)
-                        || cx.tcx.is_diagnostic_item(sym::deref_mut_method, fun_def_id)
-                        || deref_aliases
-                            .iter()
-                            .any(|&sym| cx.tcx.is_diagnostic_item(sym, fun_def_id))
-                })
-        },
+        hir::ExprKind::Path(ref expr_qpath) => cx
+            .qpath_res(expr_qpath, map_arg.hir_id)
+            .opt_def_id()
+            .and_then(|fun_def_id| cx.tcx.get_diagnostic_name(fun_def_id))
+            .is_some_and(|fun_name| {
+                matches!(fun_name, sym::deref_method | sym::deref_mut_method) || deref_aliases.contains(&fun_name)
+            }),
         hir::ExprKind::Closure(&hir::Closure { body, .. }) => {
             let closure_body = cx.tcx.hir_body(body);
             let closure_expr = peel_blocks(closure_body.value);
@@ -63,13 +59,11 @@ pub(super) fn check(
                             .map(|x| &x.kind)
                             .collect::<Box<[_]>>()
                         && let [ty::adjustment::Adjust::Deref(None), ty::adjustment::Adjust::Borrow(_)] = *adj
+                        && let method_did = cx.typeck_results().type_dependent_def_id(closure_expr.hir_id).unwrap()
+                        && let Some(method_name) = cx.tcx.get_diagnostic_name(method_did)
                     {
-                        let method_did = cx.typeck_results().type_dependent_def_id(closure_expr.hir_id).unwrap();
-                        cx.tcx.is_diagnostic_item(sym::deref_method, method_did)
-                            || cx.tcx.is_diagnostic_item(sym::deref_mut_method, method_did)
-                            || deref_aliases
-                                .iter()
-                                .any(|&sym| cx.tcx.is_diagnostic_item(sym, method_did))
+                        matches!(method_name, sym::deref_method | sym::deref_mut_method)
+                            || deref_aliases.contains(&method_name)
                     } else {
                         false
                     }
diff --git a/clippy_lints/src/methods/unnecessary_min_or_max.rs b/clippy_lints/src/methods/unnecessary_min_or_max.rs
index 413881d5ec99e..b87d81b710269 100644
--- a/clippy_lints/src/methods/unnecessary_min_or_max.rs
+++ b/clippy_lints/src/methods/unnecessary_min_or_max.rs
@@ -22,7 +22,8 @@ pub(super) fn check<'tcx>(
     let typeck_results = cx.typeck_results();
     let ecx = ConstEvalCtxt::with_env(cx.tcx, cx.typing_env(), typeck_results);
     if let Some(id) = typeck_results.type_dependent_def_id(expr.hir_id)
-        && (cx.tcx.is_diagnostic_item(sym::cmp_ord_min, id) || cx.tcx.is_diagnostic_item(sym::cmp_ord_max, id))
+        && let Some(fn_name) = cx.tcx.get_diagnostic_name(id)
+        && matches!(fn_name, sym::cmp_ord_min | sym::cmp_ord_max)
     {
         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)
diff --git a/clippy_lints/src/operators/cmp_owned.rs b/clippy_lints/src/operators/cmp_owned.rs
index 22ec4fe60fb02..604f8f5da0b86 100644
--- a/clippy_lints/src/operators/cmp_owned.rs
+++ b/clippy_lints/src/operators/cmp_owned.rs
@@ -47,14 +47,10 @@ fn check_op(cx: &LateContext<'_>, expr: &Expr<'_>, other: &Expr<'_>, left: bool)
             (arg, arg.span)
         },
         ExprKind::Call(path, [arg])
-            if path_def_id(cx, path).is_some_and(|did| {
-                if cx.tcx.is_diagnostic_item(sym::from_str_method, did) {
-                    true
-                } else if cx.tcx.is_diagnostic_item(sym::from_fn, did) {
-                    !is_copy(cx, typeck.expr_ty(expr))
-                } else {
-                    false
-                }
+            if path_def_id(cx, path).is_some_and(|did| match cx.tcx.get_diagnostic_name(did) {
+                Some(sym::from_str_method) => true,
+                Some(sym::from_fn) => !is_copy(cx, typeck.expr_ty(expr)),
+                _ => false,
             }) =>
         {
             (arg, arg.span)
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index e57b8cc2d84e3..193d9dda88456 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -96,14 +96,13 @@ 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 fn_name = cx.tcx.get_diagnostic_name(fn_def_id);
+
             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));
+                || fn_name == Some(sym::to_owned_method)
+                || (fn_name == Some(sym::to_string_method) && is_type_lang_item(cx, arg_ty, LangItem::String));
 
-            let from_deref = !from_borrow
-                && (cx.tcx.is_diagnostic_item(sym::path_to_pathbuf, fn_def_id)
-                    || cx.tcx.is_diagnostic_item(sym::os_str_to_os_string, fn_def_id));
+            let from_deref = !from_borrow && matches!(fn_name, Some(sym::path_to_pathbuf | sym::os_str_to_os_string));
 
             if !from_borrow && !from_deref {
                 continue;
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 490e6c974ae10..57d5900b045ea 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -457,7 +457,8 @@ impl<'tcx> LateLintPass<'tcx> for TrimSplitWhitespace {
 }
 
 fn is_one_of_trim_diagnostic_items(cx: &LateContext<'_>, trim_def_id: DefId) -> bool {
-    cx.tcx.is_diagnostic_item(sym::str_trim, trim_def_id)
-        || cx.tcx.is_diagnostic_item(sym::str_trim_start, trim_def_id)
-        || cx.tcx.is_diagnostic_item(sym::str_trim_end, trim_def_id)
+    matches!(
+        cx.tcx.get_diagnostic_name(trim_def_id),
+        Some(sym::str_trim | sym::str_trim_start | sym::str_trim_end)
+    )
 }
diff --git a/clippy_lints/src/types/rc_buffer.rs b/clippy_lints/src/types/rc_buffer.rs
index d691f1878b11b..c4fd0fbf87a90 100644
--- a/clippy_lints/src/types/rc_buffer.rs
+++ b/clippy_lints/src/types/rc_buffer.rs
@@ -11,7 +11,8 @@ use super::RC_BUFFER;
 
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
     let app = Applicability::Unspecified;
-    if cx.tcx.is_diagnostic_item(sym::Rc, def_id) {
+    let name = cx.tcx.get_diagnostic_name(def_id);
+    if name == Some(sym::Rc) {
         if let Some(alternate) = match_buffer_type(cx, qpath) {
             #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
             span_lint_and_then(
@@ -56,7 +57,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
             );
             return true;
         }
-    } else if cx.tcx.is_diagnostic_item(sym::Arc, def_id) {
+    } else if name == Some(sym::Arc) {
         if let Some(alternate) = match_buffer_type(cx, qpath) {
             #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
             span_lint_and_then(
diff --git a/clippy_lints/src/types/redundant_allocation.rs b/clippy_lints/src/types/redundant_allocation.rs
index de3456a8ba5fc..0ba51daf027d1 100644
--- a/clippy_lints/src/types/redundant_allocation.rs
+++ b/clippy_lints/src/types/redundant_allocation.rs
@@ -13,14 +13,11 @@ use super::{REDUNDANT_ALLOCATION, utils};
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, hir_ty: &hir::Ty<'tcx>, qpath: &QPath<'tcx>, def_id: DefId) -> bool {
     let mut applicability = Applicability::MaybeIncorrect;
-    let outer_sym = if Some(def_id) == cx.tcx.lang_items().owned_box() {
-        "Box"
-    } else if cx.tcx.is_diagnostic_item(sym::Rc, def_id) {
-        "Rc"
-    } else if cx.tcx.is_diagnostic_item(sym::Arc, def_id) {
-        "Arc"
-    } else {
-        return false;
+    let outer_sym = match cx.tcx.get_diagnostic_name(def_id) {
+        _ if Some(def_id) == cx.tcx.lang_items().owned_box() => "Box",
+        Some(sym::Rc) => "Rc",
+        Some(sym::Arc) => "Arc",
+        _ => return false,
     };
 
     if let Some(span) = utils::match_borrows_parameter(cx, qpath) {
diff --git a/clippy_lints/src/unnecessary_owned_empty_strings.rs b/clippy_lints/src/unnecessary_owned_empty_strings.rs
index 7d996775a58c8..28f4884fa3110 100644
--- a/clippy_lints/src/unnecessary_owned_empty_strings.rs
+++ b/clippy_lints/src/unnecessary_owned_empty_strings.rs
@@ -41,7 +41,8 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryOwnedEmptyStrings {
             && let ty::Ref(_, inner_str, _) = cx.typeck_results().expr_ty_adjusted(expr).kind()
             && inner_str.is_str()
         {
-            if cx.tcx.is_diagnostic_item(sym::string_new, fun_def_id) {
+            let fun_name = cx.tcx.get_diagnostic_name(fun_def_id);
+            if fun_name == Some(sym::string_new) {
                 span_lint_and_sugg(
                     cx,
                     UNNECESSARY_OWNED_EMPTY_STRINGS,
@@ -51,7 +52,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryOwnedEmptyStrings {
                     "\"\"".to_owned(),
                     Applicability::MachineApplicable,
                 );
-            } else if cx.tcx.is_diagnostic_item(sym::from_fn, fun_def_id)
+            } else if fun_name == Some(sym::from_fn)
                 && let [arg] = args
                 && let ExprKind::Lit(spanned) = &arg.kind
                 && let LitKind::Str(symbol, _) = spanned.node
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index 54a7efc090ade..849c0b438a5a0 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -107,12 +107,10 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
         // Get the wrapper and inner types, if can't, abort.
         let (return_type_label, lang_item, inner_type) =
             if let ty::Adt(adt_def, subst) = return_ty(cx, hir_id.expect_owner()).kind() {
-                if cx.tcx.is_diagnostic_item(sym::Option, adt_def.did()) {
-                    ("Option", OptionSome, subst.type_at(0))
-                } else if cx.tcx.is_diagnostic_item(sym::Result, adt_def.did()) {
-                    ("Result", ResultOk, subst.type_at(0))
-                } else {
-                    return;
+                match cx.tcx.get_diagnostic_name(adt_def.did()) {
+                    Some(sym::Option) => ("Option", OptionSome, subst.type_at(0)),
+                    Some(sym::Result) => ("Result", ResultOk, subst.type_at(0)),
+                    _ => return,
                 }
             } else {
                 return;
diff --git a/clippy_lints/src/zombie_processes.rs b/clippy_lints/src/zombie_processes.rs
index 6ab94a5221092..06d36276dfc01 100644
--- a/clippy_lints/src/zombie_processes.rs
+++ b/clippy_lints/src/zombie_processes.rs
@@ -177,8 +177,8 @@ impl<'tcx> Visitor<'tcx> for WaitFinder<'_, 'tcx> {
                 Node::Expr(expr) if let ExprKind::AddrOf(_, Mutability::Not, _) = expr.kind => {},
                 Node::Expr(expr)
                     if let Some(fn_did) = fn_def_id(self.cx, expr)
-                        && (self.cx.tcx.is_diagnostic_item(sym::child_id, fn_did)
-                            || self.cx.tcx.is_diagnostic_item(sym::child_kill, fn_did)) => {},
+                        && let Some(fn_name) = self.cx.tcx.get_diagnostic_name(fn_did)
+                        && matches!(fn_name, sym::child_id | sym::child_kill) => {},
 
                 // Conservatively assume that all other kinds of nodes call `.wait()` somehow.
                 _ => return Break(MaybeWait(ex.span)),
@@ -351,9 +351,14 @@ fn check<'tcx>(cx: &LateContext<'tcx>, spawn_expr: &'tcx Expr<'tcx>, cause: Caus
 
 /// Checks if the given expression exits the process.
 fn is_exit_expression(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    fn_def_id(cx, expr).is_some_and(|fn_did| {
-        cx.tcx.is_diagnostic_item(sym::process_exit, fn_did) || cx.tcx.is_diagnostic_item(sym::process_abort, fn_did)
-    })
+    if let Some(fn_did) = fn_def_id(cx, expr)
+        && let Some(fn_name) = cx.tcx.get_diagnostic_name(fn_did)
+        && matches!(fn_name, sym::process_exit | sym::process_abort)
+    {
+        true
+    } else {
+        false
+    }
 }
 
 #[derive(Debug)]

From abb89608af8e5eae6f89a9b06bd9b5a10ca2afe9 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 20 Aug 2025 10:59:02 +0200
Subject: [PATCH 0162/1889] higher: use `get_diagnostic_name`

---
 clippy_utils/src/higher.rs | 33 +++++++++++++++++----------------
 1 file changed, 17 insertions(+), 16 deletions(-)

diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 4e0b00df9508d..9db18f66e9a24 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -288,22 +288,23 @@ impl<'a> VecArgs<'a> {
             && is_expn_of(fun.span, sym::vec).is_some()
             && let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id()
         {
-            return if cx.tcx.is_diagnostic_item(sym::vec_from_elem, fun_def_id) && args.len() == 2 {
-                // `vec![elem; size]` case
-                Some(VecArgs::Repeat(&args[0], &args[1]))
-            } else if cx.tcx.is_diagnostic_item(sym::slice_into_vec, fun_def_id) && args.len() == 1 {
-                // `vec![a, b, c]` case
-                if let ExprKind::Call(_, [arg]) = &args[0].kind
-                    && let ExprKind::Array(args) = arg.kind
-                {
-                    Some(VecArgs::Vec(args))
-                } else {
-                    None
-                }
-            } else if cx.tcx.is_diagnostic_item(sym::vec_new, fun_def_id) && args.is_empty() {
-                Some(VecArgs::Vec(&[]))
-            } else {
-                None
+            return match (cx.tcx.get_diagnostic_name(fun_def_id), args.len()) {
+                (Some(sym::vec_from_elem), 2) => {
+                    // `vec![elem; size]` case
+                    Some(VecArgs::Repeat(&args[0], &args[1]))
+                },
+                (Some(sym::slice_into_vec), 1) => {
+                    // `vec![a, b, c]` case
+                    if let ExprKind::Call(_, [arg]) = &args[0].kind
+                        && let ExprKind::Array(args) = arg.kind
+                    {
+                        Some(VecArgs::Vec(args))
+                    } else {
+                        None
+                    }
+                },
+                (Some(sym::vec_new), 0) => Some(VecArgs::Vec(&[])),
+                _ => None,
             };
         }
 

From e6833462eb00a5aaa60c9be3472448cba600b404 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Tue, 19 Aug 2025 23:46:47 +0200
Subject: [PATCH 0163/1889] misc: destruct `args` directly

avoids bounds checks
---
 clippy_utils/src/higher.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 9db18f66e9a24..425de63ae198a 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -288,14 +288,14 @@ impl<'a> VecArgs<'a> {
             && is_expn_of(fun.span, sym::vec).is_some()
             && let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id()
         {
-            return match (cx.tcx.get_diagnostic_name(fun_def_id), args.len()) {
-                (Some(sym::vec_from_elem), 2) => {
+            return match (cx.tcx.get_diagnostic_name(fun_def_id), args) {
+                (Some(sym::vec_from_elem), [elem, size]) => {
                     // `vec![elem; size]` case
-                    Some(VecArgs::Repeat(&args[0], &args[1]))
+                    Some(VecArgs::Repeat(elem, size))
                 },
-                (Some(sym::slice_into_vec), 1) => {
+                (Some(sym::slice_into_vec), [slice]) => {
                     // `vec![a, b, c]` case
-                    if let ExprKind::Call(_, [arg]) = &args[0].kind
+                    if let ExprKind::Call(_, [arg]) = slice.kind
                         && let ExprKind::Array(args) = arg.kind
                     {
                         Some(VecArgs::Vec(args))
@@ -303,7 +303,7 @@ impl<'a> VecArgs<'a> {
                         None
                     }
                 },
-                (Some(sym::vec_new), 0) => Some(VecArgs::Vec(&[])),
+                (Some(sym::vec_new), []) => Some(VecArgs::Vec(&[])),
                 _ => None,
             };
         }

From 34f96a20827a26420878791d9a02a1d244937f2b Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Tue, 19 Aug 2025 23:47:38 +0200
Subject: [PATCH 0164/1889] misc: pull condition into guard

`None` is the fallback case anyway
---
 clippy_utils/src/higher.rs | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 425de63ae198a..0caeddd9f088f 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -293,15 +293,12 @@ impl<'a> VecArgs<'a> {
                     // `vec![elem; size]` case
                     Some(VecArgs::Repeat(elem, size))
                 },
-                (Some(sym::slice_into_vec), [slice]) => {
-                    // `vec![a, b, c]` case
+                (Some(sym::slice_into_vec), [slice])
                     if let ExprKind::Call(_, [arg]) = slice.kind
-                        && let ExprKind::Array(args) = arg.kind
-                    {
-                        Some(VecArgs::Vec(args))
-                    } else {
-                        None
-                    }
+                        && let ExprKind::Array(args) = arg.kind =>
+                {
+                    // `vec![a, b, c]` case
+                    Some(VecArgs::Vec(args))
                 },
                 (Some(sym::vec_new), []) => Some(VecArgs::Vec(&[])),
                 _ => None,

From e243f89e3ae2257419699daf9dad6bf5b8a255cd Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Tue, 19 Aug 2025 23:56:00 +0200
Subject: [PATCH 0165/1889] misc: return earlier on `name = None`

---
 clippy_utils/src/higher.rs | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 0caeddd9f088f..bda28a663fb07 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -287,20 +287,21 @@ impl<'a> VecArgs<'a> {
             && let ExprKind::Path(ref qpath) = fun.kind
             && is_expn_of(fun.span, sym::vec).is_some()
             && let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id()
+            && let Some(name) = cx.tcx.get_diagnostic_name(fun_def_id)
         {
-            return match (cx.tcx.get_diagnostic_name(fun_def_id), args) {
-                (Some(sym::vec_from_elem), [elem, size]) => {
+            return match (name, args) {
+                (sym::vec_from_elem, [elem, size]) => {
                     // `vec![elem; size]` case
                     Some(VecArgs::Repeat(elem, size))
                 },
-                (Some(sym::slice_into_vec), [slice])
+                (sym::slice_into_vec, [slice])
                     if let ExprKind::Call(_, [arg]) = slice.kind
                         && let ExprKind::Array(args) = arg.kind =>
                 {
                     // `vec![a, b, c]` case
                     Some(VecArgs::Vec(args))
                 },
-                (Some(sym::vec_new), []) => Some(VecArgs::Vec(&[])),
+                (sym::vec_new, []) => Some(VecArgs::Vec(&[])),
                 _ => None,
             };
         }

From d32796da852940f5e9ba60990dfb662ce00dddf7 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 20 Aug 2025 11:04:20 +0200
Subject: [PATCH 0166/1889] non_octal_unix_permissions: `get_diagnostic_name`
 once

---
 clippy_lints/src/non_octal_unix_permissions.rs | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/clippy_lints/src/non_octal_unix_permissions.rs b/clippy_lints/src/non_octal_unix_permissions.rs
index 23a1622f30fff..1aec5412cda7e 100644
--- a/clippy_lints/src/non_octal_unix_permissions.rs
+++ b/clippy_lints/src/non_octal_unix_permissions.rs
@@ -43,13 +43,11 @@ impl<'tcx> LateLintPass<'tcx> for NonOctalUnixPermissions {
         match &expr.kind {
             ExprKind::MethodCall(path, func, [param], _) => {
                 if let Some(adt) = cx.typeck_results().expr_ty(func).peel_refs().ty_adt_def()
-                    && ((path.ident.name == sym::mode
-                        && matches!(
-                            cx.tcx.get_diagnostic_name(adt.did()),
-                            Some(sym::FsOpenOptions | sym::DirBuilder)
-                        ))
-                        || (path.ident.name == sym::set_mode
-                            && cx.tcx.is_diagnostic_item(sym::FsPermissions, adt.did())))
+                    && matches!(
+                        (path.ident.name, cx.tcx.get_diagnostic_name(adt.did())),
+                        (sym::mode, Some(sym::FsOpenOptions | sym::DirBuilder))
+                            | (sym::set_mode, Some(sym::FsPermissions))
+                    )
                     && let ExprKind::Lit(_) = param.kind
                     && param.span.eq_ctxt(expr.span)
                     && param

From f0daf23b28d72557cf8d5a859ec3e32c9dee9fb4 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 20 Aug 2025 00:41:05 +0200
Subject: [PATCH 0167/1889] misc: reorder to have struct first, then its method

---
 clippy_lints/src/non_octal_unix_permissions.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/clippy_lints/src/non_octal_unix_permissions.rs b/clippy_lints/src/non_octal_unix_permissions.rs
index 1aec5412cda7e..cb934466bd890 100644
--- a/clippy_lints/src/non_octal_unix_permissions.rs
+++ b/clippy_lints/src/non_octal_unix_permissions.rs
@@ -44,9 +44,9 @@ impl<'tcx> LateLintPass<'tcx> for NonOctalUnixPermissions {
             ExprKind::MethodCall(path, func, [param], _) => {
                 if let Some(adt) = cx.typeck_results().expr_ty(func).peel_refs().ty_adt_def()
                     && matches!(
-                        (path.ident.name, cx.tcx.get_diagnostic_name(adt.did())),
-                        (sym::mode, Some(sym::FsOpenOptions | sym::DirBuilder))
-                            | (sym::set_mode, Some(sym::FsPermissions))
+                        (cx.tcx.get_diagnostic_name(adt.did()), path.ident.name),
+                        (Some(sym::FsOpenOptions | sym::DirBuilder), sym::mode)
+                            | (Some(sym::FsPermissions), sym::set_mode)
                     )
                     && let ExprKind::Lit(_) = param.kind
                     && param.span.eq_ctxt(expr.span)

From ff831ed40eaab37a13cb5f9a90b80ec97d74299c Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 20 Aug 2025 00:49:30 +0200
Subject: [PATCH 0168/1889] redundant_clone: partially inline
 `is_type_diagnostic_item`

to be able to reuse `did`
---
 clippy_lints/src/redundant_clone.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 193d9dda88456..1d58cdd26d88d 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::{span_lint_hir, span_lint_hir_and_then};
 use clippy_utils::fn_has_unsatisfiable_preds;
 use clippy_utils::mir::{LocalUsage, PossibleBorrowerMap, visit_local_usage};
 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::ty::{has_drop, is_copy, is_type_lang_item, walk_ptrs_ty_depth};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, FnDecl, LangItem, def_id};
@@ -147,8 +147,9 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
                     is_call_with_ref_arg(cx, mir, &pred_terminator.kind)
                     && res == cloned
                     && cx.tcx.is_diagnostic_item(sym::deref_method, pred_fn_def_id)
-                    && (is_type_diagnostic_item(cx, pred_arg_ty, sym::PathBuf)
-                        || is_type_diagnostic_item(cx, pred_arg_ty, sym::OsString))
+                    && let ty::Adt(pred_arg_def, _) = pred_arg_ty.kind()
+                    && let Some(pred_arg_name) = cx.tcx.get_diagnostic_name(pred_arg_def.did())
+                    && matches!(pred_arg_name, sym::PathBuf | sym::OsString)
                 {
                     (pred_arg, res)
                 } else {

From 40e67abb64a561f1e6a6fb4fbe0588b00a0da553 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 20 Aug 2025 01:01:09 +0200
Subject: [PATCH 0169/1889] len_zero: use `get_diagnostic_name`

---
 clippy_lints/src/len_zero.rs | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 57deb011f2b0e..28a0fbc051158 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -355,12 +355,15 @@ fn parse_len_output<'tcx>(cx: &LateContext<'tcx>, sig: FnSig<'tcx>) -> Option<Le
             return Some(LenOutput::Integral);
         }
 
-        if let Res::Def(_, def_id) = res {
-            if cx.tcx.is_diagnostic_item(sym::Option, def_id) && is_first_generic_integral(segment) {
-                return Some(LenOutput::Option(def_id));
-            } else if cx.tcx.is_diagnostic_item(sym::Result, def_id) && is_first_generic_integral(segment) {
-                return Some(LenOutput::Result(def_id));
+        if let Res::Def(_, def_id) = res
+            && let Some(res) = match cx.tcx.get_diagnostic_name(def_id) {
+                Some(sym::Option) => Some(LenOutput::Option(def_id)),
+                Some(sym::Result) => Some(LenOutput::Result(def_id)),
+                _ => None,
             }
+            && is_first_generic_integral(segment)
+        {
+            return Some(res);
         }
 
         return None;
@@ -368,11 +371,10 @@ fn parse_len_output<'tcx>(cx: &LateContext<'tcx>, sig: FnSig<'tcx>) -> Option<Le
 
     match *sig.output().kind() {
         ty::Int(_) | ty::Uint(_) => Some(LenOutput::Integral),
-        ty::Adt(adt, subs) if cx.tcx.is_diagnostic_item(sym::Option, adt.did()) => {
-            subs.type_at(0).is_integral().then(|| LenOutput::Option(adt.did()))
-        },
-        ty::Adt(adt, subs) if cx.tcx.is_diagnostic_item(sym::Result, adt.did()) => {
-            subs.type_at(0).is_integral().then(|| LenOutput::Result(adt.did()))
+        ty::Adt(adt, subs) => match cx.tcx.get_diagnostic_name(adt.did()) {
+            Some(sym::Option) => subs.type_at(0).is_integral().then(|| LenOutput::Option(adt.did())),
+            Some(sym::Result) => subs.type_at(0).is_integral().then(|| LenOutput::Result(adt.did())),
+            _ => None,
         },
         _ => None,
     }

From ff5f09512021e8956a79871bb0e0f33ddab0e453 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 20 Aug 2025 01:02:07 +0200
Subject: [PATCH 0170/1889] misc: pull another condition into match arm

---
 clippy_lints/src/len_zero.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 28a0fbc051158..f44a5fdf715e5 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -371,9 +371,9 @@ fn parse_len_output<'tcx>(cx: &LateContext<'tcx>, sig: FnSig<'tcx>) -> Option<Le
 
     match *sig.output().kind() {
         ty::Int(_) | ty::Uint(_) => Some(LenOutput::Integral),
-        ty::Adt(adt, subs) => match cx.tcx.get_diagnostic_name(adt.did()) {
-            Some(sym::Option) => subs.type_at(0).is_integral().then(|| LenOutput::Option(adt.did())),
-            Some(sym::Result) => subs.type_at(0).is_integral().then(|| LenOutput::Result(adt.did())),
+        ty::Adt(adt, subs) if subs.type_at(0).is_integral() => match cx.tcx.get_diagnostic_name(adt.did()) {
+            Some(sym::Option) => Some(LenOutput::Option(adt.did())),
+            Some(sym::Result) => Some(LenOutput::Result(adt.did())),
             _ => None,
         },
         _ => None,

From 0a8a7f92e8c3c5d6326d006deef36af158e6cbd0 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 20 Aug 2025 10:57:23 +0200
Subject: [PATCH 0171/1889] non_canonical_impls: save diagnostic name to a
 variable

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

diff --git a/clippy_lints/src/non_canonical_impls.rs b/clippy_lints/src/non_canonical_impls.rs
index 04b092769666c..19fd1925e9082 100644
--- a/clippy_lints/src/non_canonical_impls.rs
+++ b/clippy_lints/src/non_canonical_impls.rs
@@ -134,7 +134,8 @@ impl LateLintPass<'_> for NonCanonicalImpls {
             return;
         }
 
-        if cx.tcx.is_diagnostic_item(sym::Clone, trait_impl.def_id)
+        let trait_name = cx.tcx.get_diagnostic_name(trait_impl.def_id);
+        if trait_name == Some(sym::Clone)
             && let Some(copy_def_id) = cx.tcx.get_diagnostic_item(sym::Copy)
             && implements_trait(cx, trait_impl.self_ty(), copy_def_id, &[])
         {
@@ -175,7 +176,7 @@ impl LateLintPass<'_> for NonCanonicalImpls {
             }
         }
 
-        if cx.tcx.is_diagnostic_item(sym::PartialOrd, trait_impl.def_id)
+        if trait_name == Some(sym::PartialOrd)
             && impl_item.ident.name == sym::partial_cmp
             && let Some(ord_def_id) = cx.tcx.get_diagnostic_item(sym::Ord)
             && implements_trait(cx, trait_impl.self_ty(), ord_def_id, &[])

From 29f19a9013d0e2d770ec95f32bbd5b76265db7e9 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 20 Aug 2025 01:16:23 +0200
Subject: [PATCH 0172/1889] misc: don't bother checking the other case

`trait_name` can only be _one_ of those at the same time
---
 clippy_lints/src/non_canonical_impls.rs | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/clippy_lints/src/non_canonical_impls.rs b/clippy_lints/src/non_canonical_impls.rs
index 19fd1925e9082..ba67dc62abbda 100644
--- a/clippy_lints/src/non_canonical_impls.rs
+++ b/clippy_lints/src/non_canonical_impls.rs
@@ -171,12 +171,8 @@ impl LateLintPass<'_> for NonCanonicalImpls {
                     String::new(),
                     Applicability::MaybeIncorrect,
                 );
-
-                return;
             }
-        }
-
-        if trait_name == Some(sym::PartialOrd)
+        } else if trait_name == Some(sym::PartialOrd)
             && impl_item.ident.name == sym::partial_cmp
             && let Some(ord_def_id) = cx.tcx.get_diagnostic_item(sym::Ord)
             && implements_trait(cx, trait_impl.self_ty(), ord_def_id, &[])

From 1be146f64310f062e6c322acaf9bc2a8bcd79acb Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 20 Aug 2025 20:56:39 +0200
Subject: [PATCH 0173/1889] entry: use `get_diagnostic_item`

---
 clippy_lints/src/entry.rs | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index 182cb4e46d2bd..4e24f69357db8 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -274,12 +274,10 @@ fn try_parse_contains<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Optio
                 key,
                 call_ctxt: expr.span.ctxt(),
             };
-            if cx.tcx.is_diagnostic_item(sym::btreemap_contains_key, id) {
-                Some((MapType::BTree, expr))
-            } else if cx.tcx.is_diagnostic_item(sym::hashmap_contains_key, id) {
-                Some((MapType::Hash, expr))
-            } else {
-                None
+            match cx.tcx.get_diagnostic_name(id) {
+                Some(sym::btreemap_contains_key) => Some((MapType::BTree, expr)),
+                Some(sym::hashmap_contains_key) => Some((MapType::Hash, expr)),
+                _ => None,
             }
         },
         _ => None,

From b987e0178e3b17d7d7d1f39308c44b93668a100b Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 20 Aug 2025 01:39:23 +0200
Subject: [PATCH 0174/1889] misc: rewrite as `if let`

---
 clippy_lints/src/entry.rs | 53 ++++++++++++++++++++-------------------
 1 file changed, 27 insertions(+), 26 deletions(-)

diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index 4e24f69357db8..dd38aab6e3fb4 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -254,33 +254,34 @@ fn try_parse_contains<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Optio
         _ => None,
     });
 
-    match expr.kind {
-        ExprKind::MethodCall(
-            _,
+    if let ExprKind::MethodCall(
+        _,
+        map,
+        [
+            Expr {
+                kind: ExprKind::AddrOf(_, _, key),
+                span: key_span,
+                ..
+            },
+        ],
+        _,
+    ) = expr.kind
+        && key_span.eq_ctxt(expr.span)
+    {
+        let id = cx.typeck_results().type_dependent_def_id(expr.hir_id)?;
+        let expr = ContainsExpr {
+            negated,
             map,
-            [
-                Expr {
-                    kind: ExprKind::AddrOf(_, _, key),
-                    span: key_span,
-                    ..
-                },
-            ],
-            _,
-        ) if key_span.eq_ctxt(expr.span) => {
-            let id = cx.typeck_results().type_dependent_def_id(expr.hir_id)?;
-            let expr = ContainsExpr {
-                negated,
-                map,
-                key,
-                call_ctxt: expr.span.ctxt(),
-            };
-            match cx.tcx.get_diagnostic_name(id) {
-                Some(sym::btreemap_contains_key) => Some((MapType::BTree, expr)),
-                Some(sym::hashmap_contains_key) => Some((MapType::Hash, expr)),
-                _ => None,
-            }
-        },
-        _ => None,
+            key,
+            call_ctxt: expr.span.ctxt(),
+        };
+        match cx.tcx.get_diagnostic_name(id) {
+            Some(sym::btreemap_contains_key) => Some((MapType::BTree, expr)),
+            Some(sym::hashmap_contains_key) => Some((MapType::Hash, expr)),
+            _ => None,
+        }
+    } else {
+        None
     }
 }
 

From 804c9ac52a9329a4a5bcf53ef6d4326d72d34e25 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 20 Aug 2025 01:41:58 +0200
Subject: [PATCH 0175/1889] misc: match in multiple steps

---
 clippy_lints/src/entry.rs | 18 ++++++------------
 1 file changed, 6 insertions(+), 12 deletions(-)

diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index dd38aab6e3fb4..53dc2c05add22 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -254,18 +254,12 @@ fn try_parse_contains<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Optio
         _ => None,
     });
 
-    if let ExprKind::MethodCall(
-        _,
-        map,
-        [
-            Expr {
-                kind: ExprKind::AddrOf(_, _, key),
-                span: key_span,
-                ..
-            },
-        ],
-        _,
-    ) = expr.kind
+    if let ExprKind::MethodCall(_, map, [arg], _) = expr.kind
+        && let Expr {
+            kind: ExprKind::AddrOf(_, _, key),
+            span: key_span,
+            ..
+        } = arg
         && key_span.eq_ctxt(expr.span)
     {
         let id = cx.typeck_results().type_dependent_def_id(expr.hir_id)?;

From 5abee438bcd8bb2882464aeaf7afe7dd4f9d4426 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Thu, 21 Aug 2025 00:40:21 +0200
Subject: [PATCH 0176/1889] other uses of `get_diagnostic_name`

---
 clippy_lints/src/entry.rs                          |  4 +++-
 clippy_lints/src/mem_replace.rs                    |  7 +++----
 clippy_lints/src/methods/filter_map.rs             | 14 ++++++--------
 clippy_lints/src/methods/map_flatten.rs            |  8 ++++----
 clippy_lints/src/methods/single_char_add_str.rs    |  8 ++++----
 .../src/operators/float_equality_without_abs.rs    |  3 ++-
 clippy_lints/src/unused_io_amount.rs               |  4 +++-
 clippy_utils/src/usage.rs                          |  8 +++-----
 8 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index 53dc2c05add22..bac5e22a9cebb 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -304,7 +304,9 @@ struct InsertExpr<'tcx> {
 fn try_parse_insert<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<InsertExpr<'tcx>> {
     if let ExprKind::MethodCall(_, map, [key, value], _) = expr.kind {
         let id = cx.typeck_results().type_dependent_def_id(expr.hir_id)?;
-        if cx.tcx.is_diagnostic_item(sym::btreemap_insert, id) || cx.tcx.is_diagnostic_item(sym::hashmap_insert, id) {
+        if let Some(insert) = cx.tcx.get_diagnostic_name(id)
+            && matches!(insert, sym::btreemap_insert | sym::hashmap_insert)
+        {
             Some(InsertExpr { map, key, value })
         } else {
             None
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index 28efd2038b387..e39916f733d59 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -215,7 +215,8 @@ fn check_replace_with_uninit(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'
         && let ExprKind::Path(ref repl_func_qpath) = repl_func.kind
         && let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id()
     {
-        if cx.tcx.is_diagnostic_item(sym::mem_uninitialized, repl_def_id) {
+        let repl_name = cx.tcx.get_diagnostic_name(repl_def_id);
+        if repl_name == Some(sym::mem_uninitialized) {
             let Some(top_crate) = std_or_core(cx) else { return };
             let mut applicability = Applicability::MachineApplicable;
             span_lint_and_sugg(
@@ -230,9 +231,7 @@ fn check_replace_with_uninit(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'
                 ),
                 applicability,
             );
-        } else if cx.tcx.is_diagnostic_item(sym::mem_zeroed, repl_def_id)
-            && !cx.typeck_results().expr_ty(src).is_primitive()
-        {
+        } else if repl_name == Some(sym::mem_zeroed) && !cx.typeck_results().expr_ty(src).is_primitive() {
             span_lint_and_help(
                 cx,
                 MEM_REPLACE_WITH_UNINIT,
diff --git a/clippy_lints/src/methods/filter_map.rs b/clippy_lints/src/methods/filter_map.rs
index 5b8457bdd1640..2da0f8341b17b 100644
--- a/clippy_lints/src/methods/filter_map.rs
+++ b/clippy_lints/src/methods/filter_map.rs
@@ -233,18 +233,16 @@ impl<'tcx> OffendingFilterExpr<'tcx> {
             // the latter only calls `effect` once
             let side_effect_expr_span = receiver.can_have_side_effects().then_some(receiver.span);
 
-            if cx.tcx.is_diagnostic_item(sym::Option, recv_ty.did()) && path.ident.name == sym::is_some {
-                Some(Self::IsSome {
+            match (cx.tcx.get_diagnostic_name(recv_ty.did()), path.ident.name) {
+                (Some(sym::Option), sym::is_some) => Some(Self::IsSome {
                     receiver,
                     side_effect_expr_span,
-                })
-            } else if cx.tcx.is_diagnostic_item(sym::Result, recv_ty.did()) && path.ident.name == sym::is_ok {
-                Some(Self::IsOk {
+                }),
+                (Some(sym::Result), sym::is_ok) => Some(Self::IsOk {
                     receiver,
                     side_effect_expr_span,
-                })
-            } else {
-                None
+                }),
+                _ => None,
             }
         } else if matching_root_macro_call(cx, expr.span, sym::matches_macro).is_some()
             // we know for a fact that the wildcard pattern is the second arm
diff --git a/clippy_lints/src/methods/map_flatten.rs b/clippy_lints/src/methods/map_flatten.rs
index f7bb8c1d696de..750f933330a25 100644
--- a/clippy_lints/src/methods/map_flatten.rs
+++ b/clippy_lints/src/methods/map_flatten.rs
@@ -50,10 +50,10 @@ fn try_get_caller_ty_name_and_method_name(
         }
     } else {
         if let ty::Adt(adt, _) = cx.typeck_results().expr_ty(caller_expr).kind() {
-            if cx.tcx.is_diagnostic_item(sym::Option, adt.did()) {
-                return Some(("Option", "and_then"));
-            } else if cx.tcx.is_diagnostic_item(sym::Result, adt.did()) {
-                return Some(("Result", "and_then"));
+            match cx.tcx.get_diagnostic_name(adt.did()) {
+                Some(sym::Option) => return Some(("Option", "and_then")),
+                Some(sym::Result) => return Some(("Result", "and_then")),
+                _ => {},
             }
         }
         None
diff --git a/clippy_lints/src/methods/single_char_add_str.rs b/clippy_lints/src/methods/single_char_add_str.rs
index ccdf5529d537a..ef3d7acdc01ef 100644
--- a/clippy_lints/src/methods/single_char_add_str.rs
+++ b/clippy_lints/src/methods/single_char_add_str.rs
@@ -5,10 +5,10 @@ use rustc_span::sym;
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, receiver: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
     if let Some(fn_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) {
-        if cx.tcx.is_diagnostic_item(sym::string_push_str, fn_def_id) {
-            single_char_push_string::check(cx, expr, receiver, args);
-        } else if cx.tcx.is_diagnostic_item(sym::string_insert_str, fn_def_id) {
-            single_char_insert_string::check(cx, expr, receiver, args);
+        match cx.tcx.get_diagnostic_name(fn_def_id) {
+            Some(sym::string_push_str) => single_char_push_string::check(cx, expr, receiver, args),
+            Some(sym::string_insert_str) => single_char_insert_string::check(cx, expr, receiver, args),
+            _ => {},
         }
     }
 }
diff --git a/clippy_lints/src/operators/float_equality_without_abs.rs b/clippy_lints/src/operators/float_equality_without_abs.rs
index 047a5a0159cb0..b5f0d7197bbcc 100644
--- a/clippy_lints/src/operators/float_equality_without_abs.rs
+++ b/clippy_lints/src/operators/float_equality_without_abs.rs
@@ -37,7 +37,8 @@ pub(crate) fn check<'tcx>(
         // right hand side matches either f32::EPSILON or f64::EPSILON
         && let ExprKind::Path(ref epsilon_path) = rhs.kind
         && let Res::Def(DefKind::AssocConst, def_id) = cx.qpath_res(epsilon_path, rhs.hir_id)
-        && ([sym::f32_epsilon, sym::f64_epsilon].into_iter().any(|sym| cx.tcx.is_diagnostic_item(sym, def_id)))
+        && let Some(epsilon) = cx.tcx.get_diagnostic_name(def_id)
+        && matches!(epsilon, sym::f32_epsilon| sym::f64_epsilon)
 
         // values of the subtractions on the left hand side are of the type float
         && let t_val_l = cx.typeck_results().expr_ty(val_l)
diff --git a/clippy_lints/src/unused_io_amount.rs b/clippy_lints/src/unused_io_amount.rs
index f3cd3f1bb286f..af3ad4566c46a 100644
--- a/clippy_lints/src/unused_io_amount.rs
+++ b/clippy_lints/src/unused_io_amount.rs
@@ -89,7 +89,9 @@ impl<'tcx> LateLintPass<'tcx> for UnusedIoAmount {
         {
             // We don't want to lint inside io::Read or io::Write implementations, as the author has more
             // information about their trait implementation than our lint, see https://github.com/rust-lang/rust-clippy/issues/4836
-            if cx.tcx.is_diagnostic_item(sym::IoRead, trait_id) || cx.tcx.is_diagnostic_item(sym::IoWrite, trait_id) {
+            if let Some(trait_name) = cx.tcx.get_diagnostic_name(trait_id)
+                && matches!(trait_name, sym::IoRead | sym::IoWrite)
+            {
                 return;
             }
 
diff --git a/clippy_utils/src/usage.rs b/clippy_utils/src/usage.rs
index 76d43feee12ea..6eccbcdb12281 100644
--- a/clippy_utils/src/usage.rs
+++ b/clippy_utils/src/usage.rs
@@ -144,11 +144,9 @@ impl<'tcx> Visitor<'tcx> for BindingUsageFinder<'_, 'tcx> {
 
 /// Checks if the given expression is a macro call to `todo!()` or `unimplemented!()`.
 pub fn is_todo_unimplemented_macro(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    root_macro_call_first_node(cx, expr).is_some_and(|macro_call| {
-        [sym::todo_macro, sym::unimplemented_macro]
-            .iter()
-            .any(|&sym| cx.tcx.is_diagnostic_item(sym, macro_call.def_id))
-    })
+    root_macro_call_first_node(cx, expr)
+        .and_then(|macro_call| cx.tcx.get_diagnostic_name(macro_call.def_id))
+        .is_some_and(|macro_name| matches!(macro_name, sym::todo_macro | sym::unimplemented_macro))
 }
 
 /// Checks if the given expression is a stub, i.e., a `todo!()` or `unimplemented!()` expression,

From f51b5afd5043c5514c0eccd9e8083694bfea967b Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Thu, 21 Aug 2025 00:00:25 +0200
Subject: [PATCH 0177/1889] is_default_equivalent_ctor: check for String once

---
 clippy_utils/src/lib.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 8533fa8554199..7a2c1bf40d9cc 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -640,9 +640,10 @@ fn is_default_equivalent_ctor(cx: &LateContext<'_>, def_id: DefId, path: &QPath<
         && let Some(impl_did) = cx.tcx.impl_of_assoc(def_id)
         && let Some(adt) = cx.tcx.type_of(impl_did).instantiate_identity().ty_adt_def()
     {
-        return std_types_symbols.iter().any(|&symbol| {
-            cx.tcx.is_diagnostic_item(symbol, adt.did()) || Some(adt.did()) == cx.tcx.lang_items().string()
-        });
+        return Some(adt.did()) == cx.tcx.lang_items().string()
+            || std_types_symbols
+                .iter()
+                .any(|&symbol| cx.tcx.is_diagnostic_item(symbol, adt.did()));
     }
     false
 }

From 81b4de649fd7795b99cdf6a77f0b5c49cfc778b3 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Thu, 21 Aug 2025 00:01:10 +0200
Subject: [PATCH 0178/1889] is_default_equivalent_ctor: store name in a var

---
 clippy_utils/src/lib.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 7a2c1bf40d9cc..3776a34ce33af 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -641,9 +641,7 @@ fn is_default_equivalent_ctor(cx: &LateContext<'_>, def_id: DefId, path: &QPath<
         && let Some(adt) = cx.tcx.type_of(impl_did).instantiate_identity().ty_adt_def()
     {
         return Some(adt.did()) == cx.tcx.lang_items().string()
-            || std_types_symbols
-                .iter()
-                .any(|&symbol| cx.tcx.is_diagnostic_item(symbol, adt.did()));
+            || (cx.tcx.get_diagnostic_name(adt.did())).is_some_and(|adt_name| std_types_symbols.contains(&adt_name));
     }
     false
 }

From 79a95eee88fd17cea24a8ee9835baf3873b18fac Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Thu, 21 Aug 2025 23:48:09 +0200
Subject: [PATCH 0179/1889] use `option_arg_ty`

---
 clippy_lints/src/matches/try_err.rs | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/clippy_lints/src/matches/try_err.rs b/clippy_lints/src/matches/try_err.rs
index ff7769af1df41..c133ed084241b 100644
--- a/clippy_lints/src/matches/try_err.rs
+++ b/clippy_lints/src/matches/try_err.rs
@@ -1,6 +1,6 @@
 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::ty::{is_type_diagnostic_item, option_arg_ty};
 use clippy_utils::{get_parent_expr, is_res_lang_ctor, path_res};
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::ResultErr;
@@ -116,9 +116,7 @@ fn poll_option_result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) ->
     if let ty::Adt(def, subst) = ty.kind()
         && cx.tcx.lang_items().get(LangItem::Poll) == Some(def.did())
         && let ready_ty = subst.type_at(0)
-        && let ty::Adt(ready_def, ready_subst) = ready_ty.kind()
-        && cx.tcx.is_diagnostic_item(sym::Option, ready_def.did())
-        && let some_ty = ready_subst.type_at(0)
+        && let Some(some_ty) = option_arg_ty(cx, ready_ty)
         && let ty::Adt(some_def, some_subst) = some_ty.kind()
         && cx.tcx.is_diagnostic_item(sym::Result, some_def.did())
     {

From 575b613650aeb40d5fb7262fb35f4b36c8c30bd6 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Thu, 21 Aug 2025 01:12:57 +0200
Subject: [PATCH 0180/1889] use `is_type_diagnostic_item`

---
 clippy_lints/src/loops/missing_spin_loop.rs        | 6 +++---
 clippy_lints/src/loops/unused_enumerate_index.rs   | 5 ++---
 clippy_lints/src/methods/read_line_without_trim.rs | 4 ++--
 clippy_lints/src/methods/suspicious_to_owned.rs    | 5 ++---
 clippy_lints/src/methods/unused_enumerate_index.rs | 7 +++----
 clippy_lints/src/zombie_processes.rs               | 5 +++--
 clippy_utils/src/ty/mod.rs                         | 9 ++-------
 7 files changed, 17 insertions(+), 24 deletions(-)

diff --git a/clippy_lints/src/loops/missing_spin_loop.rs b/clippy_lints/src/loops/missing_spin_loop.rs
index a9944d64ce2dd..8a2d0036203a2 100644
--- a/clippy_lints/src/loops/missing_spin_loop.rs
+++ b/clippy_lints/src/loops/missing_spin_loop.rs
@@ -1,10 +1,10 @@
 use super::MISSING_SPIN_LOOP;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::std_or_core;
+use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
 use rustc_hir::{Block, Expr, ExprKind};
 use rustc_lint::LateContext;
-use rustc_middle::ty;
 use rustc_span::sym;
 
 fn unpack_cond<'tcx>(cond: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
@@ -39,8 +39,8 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, body: &'
     ) = body.kind
         && let ExprKind::MethodCall(method, callee, ..) = unpack_cond(cond).kind
         && [sym::load, sym::compare_exchange, sym::compare_exchange_weak].contains(&method.ident.name)
-        && let ty::Adt(def, _args) = cx.typeck_results().expr_ty(callee).kind()
-        && cx.tcx.is_diagnostic_item(sym::AtomicBool, def.did())
+        && let callee_ty = cx.typeck_results().expr_ty(callee)
+        && is_type_diagnostic_item(cx, callee_ty, sym::AtomicBool)
         && let Some(std_or_core) = std_or_core(cx)
     {
         span_lint_and_sugg(
diff --git a/clippy_lints/src/loops/unused_enumerate_index.rs b/clippy_lints/src/loops/unused_enumerate_index.rs
index 51e21aa9734ed..13b93d2c0097b 100644
--- a/clippy_lints/src/loops/unused_enumerate_index.rs
+++ b/clippy_lints/src/loops/unused_enumerate_index.rs
@@ -1,12 +1,12 @@
 use super::UNUSED_ENUMERATE_INDEX;
 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::def::DefKind;
 use rustc_hir::{Expr, ExprKind, Pat, PatKind};
 use rustc_lint::LateContext;
-use rustc_middle::ty;
 use rustc_span::sym;
 
 /// Checks for the `UNUSED_ENUMERATE_INDEX` lint.
@@ -17,8 +17,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, pat: &Pat<'tcx>, arg: &Expr<'_
         && let ExprKind::MethodCall(_method, self_arg, [], _) = arg.kind
         && let ty = cx.typeck_results().expr_ty(arg)
         && pat_is_wild(cx, &index.kind, body)
-        && let ty::Adt(base, _) = *ty.kind()
-        && cx.tcx.is_diagnostic_item(sym::Enumerate, base.did())
+        && is_type_diagnostic_item(cx, ty, sym::Enumerate)
         && let Some((DefKind::AssocFn, call_id)) = cx.typeck_results().type_dependent_def(arg.hir_id)
         && cx.tcx.is_diagnostic_item(sym::enumerate_method, call_id)
     {
diff --git a/clippy_lints/src/methods/read_line_without_trim.rs b/clippy_lints/src/methods/read_line_without_trim.rs
index 407f2e80aff25..6738bbf0a12b9 100644
--- a/clippy_lints/src/methods/read_line_without_trim.rs
+++ b/clippy_lints/src/methods/read_line_without_trim.rs
@@ -31,8 +31,8 @@ fn parse_fails_on_trailing_newline(ty: Ty<'_>) -> bool {
 }
 
 pub fn check(cx: &LateContext<'_>, call: &Expr<'_>, recv: &Expr<'_>, arg: &Expr<'_>) {
-    if let Some(recv_adt) = cx.typeck_results().expr_ty(recv).ty_adt_def()
-        && cx.tcx.is_diagnostic_item(sym::Stdin, recv_adt.did())
+    let recv_ty = cx.typeck_results().expr_ty(recv);
+    if is_type_diagnostic_item(cx, recv_ty, sym::Stdin)
         && let ExprKind::Path(QPath::Resolved(_, path)) = arg.peel_borrows().kind
         && let Res::Local(local_id) = path.res
     {
diff --git a/clippy_lints/src/methods/suspicious_to_owned.rs b/clippy_lints/src/methods/suspicious_to_owned.rs
index ce7aefed01f49..ffc237e3c24cc 100644
--- a/clippy_lints/src/methods/suspicious_to_owned.rs
+++ b/clippy_lints/src/methods/suspicious_to_owned.rs
@@ -1,11 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_diag_trait_item;
 use clippy_utils::source::snippet_with_context;
+use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_middle::ty::print::with_forced_trimmed_paths;
-use rustc_middle::ty::{self};
 use rustc_span::sym;
 
 use super::SUSPICIOUS_TO_OWNED;
@@ -14,8 +14,7 @@ pub fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) -
     if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
         && is_diag_trait_item(cx, method_def_id, sym::ToOwned)
         && let input_type = cx.typeck_results().expr_ty(expr)
-        && let ty::Adt(adt, _) = cx.typeck_results().expr_ty(expr).kind()
-        && cx.tcx.is_diagnostic_item(sym::Cow, adt.did())
+        && is_type_diagnostic_item(cx, input_type, sym::Cow)
     {
         let mut app = Applicability::MaybeIncorrect;
         let recv_snip = snippet_with_context(cx, recv.span, expr.span.ctxt(), "..", &mut app).0;
diff --git a/clippy_lints/src/methods/unused_enumerate_index.rs b/clippy_lints/src/methods/unused_enumerate_index.rs
index af466fe091c21..af4ade3cc0f7d 100644
--- a/clippy_lints/src/methods/unused_enumerate_index.rs
+++ b/clippy_lints/src/methods/unused_enumerate_index.rs
@@ -1,10 +1,10 @@
 use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::source::{SpanRangeExt, snippet};
+use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{expr_or_init, is_trait_method, pat_is_wild};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, FnDecl, PatKind, TyKind};
 use rustc_lint::LateContext;
-use rustc_middle::ty::AdtDef;
 use rustc_span::{Span, sym};
 
 use crate::loops::UNUSED_ENUMERATE_INDEX;
@@ -39,9 +39,8 @@ use crate::loops::UNUSED_ENUMERATE_INDEX;
 /// * `closure_arg`: The argument to the map function call containing the closure/function to apply
 pub(super) fn check(cx: &LateContext<'_>, call_expr: &Expr<'_>, recv: &Expr<'_>, closure_arg: &Expr<'_>) {
     let recv_ty = cx.typeck_results().expr_ty(recv);
-    if let Some(recv_ty_defid) = recv_ty.ty_adt_def().map(AdtDef::did)
-        // If we call a method on a `std::iter::Enumerate` instance
-        && cx.tcx.is_diagnostic_item(sym::Enumerate, recv_ty_defid)
+    // If we call a method on a `std::iter::Enumerate` instance
+    if is_type_diagnostic_item(cx, recv_ty, sym::Enumerate)
         // If we are calling a method of the `Iterator` trait
         && is_trait_method(cx, call_expr, sym::Iterator)
         // And the map argument is a closure
diff --git a/clippy_lints/src/zombie_processes.rs b/clippy_lints/src/zombie_processes.rs
index 6ab94a5221092..ceb7609cf4b54 100644
--- a/clippy_lints/src/zombie_processes.rs
+++ b/clippy_lints/src/zombie_processes.rs
@@ -1,5 +1,6 @@
 use ControlFlow::{Break, Continue};
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{fn_def_id, get_enclosing_block, path_to_local_id};
 use rustc_ast::Mutability;
 use rustc_ast::visit::visit_opt;
@@ -58,8 +59,8 @@ declare_lint_pass!(ZombieProcesses => [ZOMBIE_PROCESSES]);
 impl<'tcx> LateLintPass<'tcx> for ZombieProcesses {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         if let ExprKind::Call(..) | ExprKind::MethodCall(..) = expr.kind
-            && let Some(child_adt) = cx.typeck_results().expr_ty(expr).ty_adt_def()
-            && cx.tcx.is_diagnostic_item(sym::Child, child_adt.did())
+            && let child_ty = cx.typeck_results().expr_ty(expr)
+            && is_type_diagnostic_item(cx, child_ty, sym::Child)
         {
             match cx.tcx.parent_hir_node(expr.hir_id) {
                 Node::LetStmt(local)
diff --git a/clippy_utils/src/ty/mod.rs b/clippy_utils/src/ty/mod.rs
index fafc1d07e51eb..8e302f9d2ad12 100644
--- a/clippy_utils/src/ty/mod.rs
+++ b/clippy_utils/src/ty/mod.rs
@@ -387,10 +387,7 @@ pub fn is_recursively_primitive_type(ty: Ty<'_>) -> bool {
 /// Checks if the type is a reference equals to a diagnostic item
 pub fn is_type_ref_to_diagnostic_item(cx: &LateContext<'_>, ty: Ty<'_>, diag_item: Symbol) -> bool {
     match ty.kind() {
-        ty::Ref(_, ref_ty, _) => match ref_ty.kind() {
-            ty::Adt(adt, _) => cx.tcx.is_diagnostic_item(diag_item, adt.did()),
-            _ => false,
-        },
+        ty::Ref(_, ref_ty, _) => is_type_diagnostic_item(cx, *ref_ty, diag_item),
         _ => false,
     }
 }
@@ -1378,9 +1375,7 @@ pub fn has_non_owning_mutable_access<'tcx>(cx: &LateContext<'tcx>, iter_ty: Ty<'
 
 /// Check if `ty` is slice-like, i.e., `&[T]`, `[T; N]`, or `Vec<T>`.
 pub fn is_slice_like<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-    ty.is_slice()
-        || ty.is_array()
-        || matches!(ty.kind(), ty::Adt(adt_def, _) if cx.tcx.is_diagnostic_item(sym::Vec, adt_def.did()))
+    ty.is_slice() || ty.is_array() || is_type_diagnostic_item(cx, ty, sym::Vec)
 }
 
 pub fn get_field_idx_by_name(ty: Ty<'_>, name: Symbol) -> Option<usize> {

From f0420110fedcbc5a34ec2ffeab6ef1238e171b88 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Thu, 21 Aug 2025 23:34:48 +0200
Subject: [PATCH 0181/1889] useless_conversion: store name in a var

---
 clippy_lints/src/useless_conversion.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index e5b20c0e0a133..df0789db559a5 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -386,12 +386,13 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
 
             ExprKind::Call(path, [arg]) => {
                 if let ExprKind::Path(ref qpath) = path.kind
-                    && let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id()
                     && !is_ty_alias(qpath)
+                    && let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id()
+                    && let Some(name) = cx.tcx.get_diagnostic_name(def_id)
                 {
                     let a = cx.typeck_results().expr_ty(e);
                     let b = cx.typeck_results().expr_ty(arg);
-                    if cx.tcx.is_diagnostic_item(sym::try_from_fn, def_id)
+                    if name == sym::try_from_fn
                         && is_type_diagnostic_item(cx, a, sym::Result)
                         && let ty::Adt(_, args) = a.kind()
                         && let Some(a_type) = args.types().next()
@@ -408,7 +409,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                         );
                     }
 
-                    if cx.tcx.is_diagnostic_item(sym::from_fn, def_id) && same_type_and_consts(a, b) {
+                    if name == sym::from_fn && same_type_and_consts(a, b) {
                         let mut app = Applicability::MachineApplicable;
                         let sugg = Sugg::hir_with_context(cx, arg, e.span.ctxt(), "<expr>", &mut app).maybe_paren();
                         let sugg_msg = format!("consider removing `{}()`", snippet(cx, path.span, "From::from"));

From d0de0ec4143cf7c486c02efea0d6f8879cada356 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Thu, 21 Aug 2025 23:51:26 +0200
Subject: [PATCH 0182/1889] use `result_error_type`

---
 clippy_lints/src/matches/try_err.rs | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/clippy_lints/src/matches/try_err.rs b/clippy_lints/src/matches/try_err.rs
index c133ed084241b..f6c319b753cd4 100644
--- a/clippy_lints/src/matches/try_err.rs
+++ b/clippy_lints/src/matches/try_err.rs
@@ -101,11 +101,9 @@ fn result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'t
 fn poll_result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
     if let ty::Adt(def, subst) = ty.kind()
         && cx.tcx.lang_items().get(LangItem::Poll) == Some(def.did())
-        && let ready_ty = subst.type_at(0)
-        && let ty::Adt(ready_def, ready_subst) = ready_ty.kind()
-        && cx.tcx.is_diagnostic_item(sym::Result, ready_def.did())
     {
-        Some(ready_subst.type_at(1))
+        let ready_ty = subst.type_at(0);
+        result_error_type(cx, ready_ty)
     } else {
         None
     }
@@ -117,10 +115,8 @@ fn poll_option_result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) ->
         && cx.tcx.lang_items().get(LangItem::Poll) == Some(def.did())
         && let ready_ty = subst.type_at(0)
         && let Some(some_ty) = option_arg_ty(cx, ready_ty)
-        && let ty::Adt(some_def, some_subst) = some_ty.kind()
-        && cx.tcx.is_diagnostic_item(sym::Result, some_def.did())
     {
-        Some(some_subst.type_at(1))
+        result_error_type(cx, some_ty)
     } else {
         None
     }

From a5745a732de52067892e1474ec63b5edd7c28903 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Thu, 21 Aug 2025 18:42:37 +0200
Subject: [PATCH 0183/1889] use `is_path_diagnostic_item`

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

diff --git a/clippy_lints/src/instant_subtraction.rs b/clippy_lints/src/instant_subtraction.rs
index 91f65d0b79ca0..13117f60abd52 100644
--- a/clippy_lints/src/instant_subtraction.rs
+++ b/clippy_lints/src/instant_subtraction.rs
@@ -3,7 +3,7 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::sugg::Sugg;
-use clippy_utils::ty;
+use clippy_utils::{is_path_diagnostic_item, ty};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -107,8 +107,7 @@ impl LateLintPass<'_> for InstantSubtraction {
 
 fn is_instant_now_call(cx: &LateContext<'_>, expr_block: &'_ Expr<'_>) -> bool {
     if let ExprKind::Call(fn_expr, []) = expr_block.kind
-        && let Some(fn_id) = clippy_utils::path_def_id(cx, fn_expr)
-        && cx.tcx.is_diagnostic_item(sym::instant_now, fn_id)
+        && is_path_diagnostic_item(cx, fn_expr, sym::instant_now)
     {
         true
     } else {

From 3c3dc6da6fb49e7126fb84317dc2fb62bb869f19 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Thu, 21 Aug 2025 23:35:49 +0200
Subject: [PATCH 0184/1889] misc: don't bother checking the other branch

---
 clippy_lints/src/useless_conversion.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index df0789db559a5..70ae982a4458b 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -407,9 +407,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                             None,
                             hint,
                         );
-                    }
-
-                    if name == sym::from_fn && same_type_and_consts(a, b) {
+                    } else if name == sym::from_fn && same_type_and_consts(a, b) {
                         let mut app = Applicability::MachineApplicable;
                         let sugg = Sugg::hir_with_context(cx, arg, e.span.ctxt(), "<expr>", &mut app).maybe_paren();
                         let sugg_msg = format!("consider removing `{}()`", snippet(cx, path.span, "From::from"));

From 043346b6ddaaf685a8374a4c6026ddc6d2220efd Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Thu, 21 Aug 2025 00:41:01 +0200
Subject: [PATCH 0185/1889] use a let-chain

---
 .../transmute/transmute_int_to_non_zero.rs    | 54 +++++++++----------
 1 file changed, 24 insertions(+), 30 deletions(-)

diff --git a/clippy_lints/src/transmute/transmute_int_to_non_zero.rs b/clippy_lints/src/transmute/transmute_int_to_non_zero.rs
index f27aaa2fa77aa..24489ee2e7a0c 100644
--- a/clippy_lints/src/transmute/transmute_int_to_non_zero.rs
+++ b/clippy_lints/src/transmute/transmute_int_to_non_zero.rs
@@ -16,35 +16,29 @@ pub(super) fn check<'tcx>(
     to_ty: Ty<'tcx>,
     arg: &'tcx Expr<'_>,
 ) -> bool {
-    let tcx = cx.tcx;
-
-    let (ty::Int(_) | ty::Uint(_), ty::Adt(adt, substs)) = (&from_ty.kind(), to_ty.kind()) else {
-        return false;
-    };
-
-    if !tcx.is_diagnostic_item(sym::NonZero, adt.did()) {
-        return false;
+    if let ty::Int(_) | ty::Uint(_) = from_ty.kind()
+        && let ty::Adt(adt, substs) = to_ty.kind()
+        && cx.tcx.is_diagnostic_item(sym::NonZero, adt.did())
+        && let int_ty = substs.type_at(0)
+        && from_ty == int_ty
+    {
+        span_lint_and_then(
+            cx,
+            TRANSMUTE_INT_TO_NON_ZERO,
+            e.span,
+            format!("transmute from a `{from_ty}` to a `{}<{int_ty}>`", sym::NonZero),
+            |diag| {
+                let arg = sugg::Sugg::hir(cx, arg, "..");
+                diag.span_suggestion(
+                    e.span,
+                    "consider using",
+                    format!("{}::{}({arg})", sym::NonZero, sym::new_unchecked),
+                    Applicability::Unspecified,
+                );
+            },
+        );
+        true
+    } else {
+        false
     }
-
-    let int_ty = substs.type_at(0);
-    if from_ty != int_ty {
-        return false;
-    }
-
-    span_lint_and_then(
-        cx,
-        TRANSMUTE_INT_TO_NON_ZERO,
-        e.span,
-        format!("transmute from a `{from_ty}` to a `{}<{int_ty}>`", sym::NonZero),
-        |diag| {
-            let arg = sugg::Sugg::hir(cx, arg, "..");
-            diag.span_suggestion(
-                e.span,
-                "consider using",
-                format!("{}::{}({arg})", sym::NonZero, sym::new_unchecked),
-                Applicability::Unspecified,
-            );
-        },
-    );
-    true
 }

From cb3e5af74658fefa55b513a55d2789c84ef4bfd5 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Thu, 21 Aug 2025 23:52:20 +0200
Subject: [PATCH 0186/1889] don't repeat the `ty::Adt` check

is done already inside `is_type_diagnostic_item`
---
 clippy_lints/src/matches/try_err.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/clippy_lints/src/matches/try_err.rs b/clippy_lints/src/matches/try_err.rs
index f6c319b753cd4..d595f21aa629e 100644
--- a/clippy_lints/src/matches/try_err.rs
+++ b/clippy_lints/src/matches/try_err.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::{is_type_diagnostic_item, option_arg_ty};
+use clippy_utils::ty::option_arg_ty;
 use clippy_utils::{get_parent_expr, is_res_lang_ctor, path_res};
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::ResultErr;
@@ -88,8 +88,8 @@ fn find_return_type<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx ExprKind<'_>) -> O
 
 /// Extracts the error type from Result<T, E>.
 fn result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
-    if let ty::Adt(_, subst) = ty.kind()
-        && is_type_diagnostic_item(cx, ty, sym::Result)
+    if let ty::Adt(def, subst) = ty.kind()
+        && cx.tcx.is_diagnostic_item(sym::Result, def.did())
     {
         Some(subst.type_at(1))
     } else {

From ea7672a1fbdc890ed25b45cdbc95e13919cdc6c7 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Thu, 21 Aug 2025 00:42:39 +0200
Subject: [PATCH 0187/1889] use `span_lint_and_sugg`

---
 .../src/transmute/transmute_int_to_non_zero.rs  | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

diff --git a/clippy_lints/src/transmute/transmute_int_to_non_zero.rs b/clippy_lints/src/transmute/transmute_int_to_non_zero.rs
index 24489ee2e7a0c..d1085d7c59fa2 100644
--- a/clippy_lints/src/transmute/transmute_int_to_non_zero.rs
+++ b/clippy_lints/src/transmute/transmute_int_to_non_zero.rs
@@ -1,5 +1,5 @@
 use super::TRANSMUTE_INT_TO_NON_ZERO;
-use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::sugg;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
@@ -22,20 +22,15 @@ pub(super) fn check<'tcx>(
         && let int_ty = substs.type_at(0)
         && from_ty == int_ty
     {
-        span_lint_and_then(
+        let arg = sugg::Sugg::hir(cx, arg, "..");
+        span_lint_and_sugg(
             cx,
             TRANSMUTE_INT_TO_NON_ZERO,
             e.span,
             format!("transmute from a `{from_ty}` to a `{}<{int_ty}>`", sym::NonZero),
-            |diag| {
-                let arg = sugg::Sugg::hir(cx, arg, "..");
-                diag.span_suggestion(
-                    e.span,
-                    "consider using",
-                    format!("{}::{}({arg})", sym::NonZero, sym::new_unchecked),
-                    Applicability::Unspecified,
-                );
-            },
+            "consider using",
+            format!("{}::{}({arg})", sym::NonZero, sym::new_unchecked),
+            Applicability::Unspecified,
         );
         true
     } else {

From ed69835374e72a2c08f8bad0959b212d35cc267c Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Fri, 22 Aug 2025 00:00:23 +0200
Subject: [PATCH 0188/1889] basically `clippy::let_if_seq`

---
 clippy_lints/src/matches/try_err.rs | 20 +++++---------------
 1 file changed, 5 insertions(+), 15 deletions(-)

diff --git a/clippy_lints/src/matches/try_err.rs b/clippy_lints/src/matches/try_err.rs
index d595f21aa629e..af90cb5e67334 100644
--- a/clippy_lints/src/matches/try_err.rs
+++ b/clippy_lints/src/matches/try_err.rs
@@ -28,25 +28,15 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, scrutine
         && is_res_lang_ctor(cx, path_res(cx, err_fun), ResultErr)
         && let Some(return_ty) = find_return_type(cx, &expr.kind)
     {
-        let prefix;
-        let suffix;
-        let err_ty;
-
-        if let Some(ty) = result_error_type(cx, return_ty) {
-            prefix = "Err(";
-            suffix = ")";
-            err_ty = ty;
+        let (prefix, suffix, err_ty) = if let Some(ty) = result_error_type(cx, return_ty) {
+            ("Err(", ")", ty)
         } else if let Some(ty) = poll_result_error_type(cx, return_ty) {
-            prefix = "Poll::Ready(Err(";
-            suffix = "))";
-            err_ty = ty;
+            ("Poll::Ready(Err(", "))", ty)
         } else if let Some(ty) = poll_option_result_error_type(cx, return_ty) {
-            prefix = "Poll::Ready(Some(Err(";
-            suffix = ")))";
-            err_ty = ty;
+            ("Poll::Ready(Some(Err(", ")))", ty)
         } else {
             return;
-        }
+        };
 
         span_lint_and_then(
             cx,

From a50c339fb1ff320412896eeb28371b1af49c65b0 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Thu, 21 Aug 2025 00:46:48 +0200
Subject: [PATCH 0189/1889] replace qualified path with `use`

---
 clippy_lints/src/transmute/transmute_int_to_non_zero.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/clippy_lints/src/transmute/transmute_int_to_non_zero.rs b/clippy_lints/src/transmute/transmute_int_to_non_zero.rs
index d1085d7c59fa2..2257aa1b73c87 100644
--- a/clippy_lints/src/transmute/transmute_int_to_non_zero.rs
+++ b/clippy_lints/src/transmute/transmute_int_to_non_zero.rs
@@ -1,6 +1,6 @@
 use super::TRANSMUTE_INT_TO_NON_ZERO;
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::sugg;
+use clippy_utils::sugg::Sugg;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
@@ -22,7 +22,7 @@ pub(super) fn check<'tcx>(
         && let int_ty = substs.type_at(0)
         && from_ty == int_ty
     {
-        let arg = sugg::Sugg::hir(cx, arg, "..");
+        let arg = Sugg::hir(cx, arg, "..");
         span_lint_and_sugg(
             cx,
             TRANSMUTE_INT_TO_NON_ZERO,

From 4ac5e9c027550bed984973f0bd655939eaacf30a Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Tue, 19 Aug 2025 23:44:02 +0200
Subject: [PATCH 0190/1889] `get_diagnostic_name` in other places

---
 clippy_lints/src/casts/ptr_as_ptr.rs          | 10 ++---
 clippy_lints/src/large_include_file.rs        |  4 +-
 clippy_lints/src/manual_retain.rs             | 10 ++---
 clippy_lints/src/manual_strip.rs              | 10 ++---
 .../src/methods/iter_out_of_bounds.rs         | 45 +++++++++----------
 .../src/methods/option_as_ref_deref.rs        | 28 +++++-------
 .../src/methods/unnecessary_min_or_max.rs     |  3 +-
 clippy_lints/src/operators/cmp_owned.rs       | 12 ++---
 clippy_lints/src/redundant_clone.rs           | 11 +++--
 clippy_lints/src/strings.rs                   |  7 +--
 clippy_lints/src/types/rc_buffer.rs           |  5 ++-
 .../src/types/redundant_allocation.rs         | 13 +++---
 .../src/unnecessary_owned_empty_strings.rs    |  5 ++-
 clippy_lints/src/unnecessary_wraps.rs         | 10 ++---
 clippy_lints/src/zombie_processes.rs          | 15 ++++---
 15 files changed, 87 insertions(+), 101 deletions(-)

diff --git a/clippy_lints/src/casts/ptr_as_ptr.rs b/clippy_lints/src/casts/ptr_as_ptr.rs
index 890754090989f..c5be504543c24 100644
--- a/clippy_lints/src/casts/ptr_as_ptr.rs
+++ b/clippy_lints/src/casts/ptr_as_ptr.rs
@@ -62,12 +62,10 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, msrv: Msrv)
             && let ExprKind::Path(ref qpath @ QPath::Resolved(None, path)) = func.kind
             && let Some(method_defid) = path.res.opt_def_id()
         {
-            if cx.tcx.is_diagnostic_item(sym::ptr_null, method_defid) {
-                OmitFollowedCastReason::Null(qpath)
-            } else if cx.tcx.is_diagnostic_item(sym::ptr_null_mut, method_defid) {
-                OmitFollowedCastReason::NullMut(qpath)
-            } else {
-                OmitFollowedCastReason::None
+            match cx.tcx.get_diagnostic_name(method_defid) {
+                Some(sym::ptr_null) => OmitFollowedCastReason::Null(qpath),
+                Some(sym::ptr_null_mut) => OmitFollowedCastReason::NullMut(qpath),
+                _ => OmitFollowedCastReason::None,
             }
         } else {
             OmitFollowedCastReason::None
diff --git a/clippy_lints/src/large_include_file.rs b/clippy_lints/src/large_include_file.rs
index 8707612fbdd0a..48ce1afc6e69b 100644
--- a/clippy_lints/src/large_include_file.rs
+++ b/clippy_lints/src/large_include_file.rs
@@ -64,8 +64,8 @@ impl LateLintPass<'_> for LargeIncludeFile {
             }
             && len as u64 > self.max_file_size
             && let Some(macro_call) = root_macro_call_first_node(cx, expr)
-            && (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))
+            && let Some(macro_name) = cx.tcx.get_diagnostic_name(macro_call.def_id)
+            && matches!(macro_name, sym::include_bytes_macro | sym::include_str_macro)
         {
             #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
             span_lint_and_then(
diff --git a/clippy_lints/src/manual_retain.rs b/clippy_lints/src/manual_retain.rs
index 98e8b1f5cf92c..7fb88763e640f 100644
--- a/clippy_lints/src/manual_retain.rs
+++ b/clippy_lints/src/manual_retain.rs
@@ -123,8 +123,8 @@ fn check_iter(
 ) {
     if let hir::ExprKind::MethodCall(_, filter_expr, [], _) = &target_expr.kind
         && let Some(copied_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id)
-        && (cx.tcx.is_diagnostic_item(sym::iter_copied, copied_def_id)
-            || cx.tcx.is_diagnostic_item(sym::iter_cloned, copied_def_id))
+        && let Some(copied_name) = cx.tcx.get_diagnostic_name(copied_def_id)
+        && matches!(copied_name, sym::iter_copied | sym::iter_cloned)
         && let hir::ExprKind::MethodCall(_, iter_expr, [_], _) = &filter_expr.kind
         && let Some(filter_def_id) = cx.typeck_results().type_dependent_def_id(filter_expr.hir_id)
         && cx.tcx.is_diagnostic_item(sym::iter_filter, filter_def_id)
@@ -243,9 +243,9 @@ fn make_sugg(
 }
 
 fn match_acceptable_sym(cx: &LateContext<'_>, collect_def_id: DefId) -> bool {
-    ACCEPTABLE_METHODS
-        .iter()
-        .any(|&method| cx.tcx.is_diagnostic_item(method, collect_def_id))
+    cx.tcx
+        .get_diagnostic_name(collect_def_id)
+        .is_some_and(|collect_name| ACCEPTABLE_METHODS.contains(&collect_name))
 }
 
 fn match_acceptable_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>, msrv: Msrv) -> bool {
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index 6bf43a1c6d47c..07cce4046ca4f 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -75,12 +75,10 @@ impl<'tcx> LateLintPass<'tcx> for ManualStrip {
             && let ExprKind::Path(target_path) = &target_arg.kind
             && let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(cond.hir_id)
         {
-            let strip_kind = if cx.tcx.is_diagnostic_item(sym::str_starts_with, method_def_id) {
-                StripKind::Prefix
-            } else if cx.tcx.is_diagnostic_item(sym::str_ends_with, method_def_id) {
-                StripKind::Suffix
-            } else {
-                return;
+            let strip_kind = match cx.tcx.get_diagnostic_name(method_def_id) {
+                Some(sym::str_starts_with) => StripKind::Prefix,
+                Some(sym::str_ends_with) => StripKind::Suffix,
+                _ => return,
             };
             let target_res = cx.qpath_res(target_path, target_arg.hir_id);
             if target_res == Res::Err {
diff --git a/clippy_lints/src/methods/iter_out_of_bounds.rs b/clippy_lints/src/methods/iter_out_of_bounds.rs
index 9a62b719a8fb8..fa8f9d640ee6e 100644
--- a/clippy_lints/src/methods/iter_out_of_bounds.rs
+++ b/clippy_lints/src/methods/iter_out_of_bounds.rs
@@ -24,32 +24,29 @@ fn get_iterator_length<'tcx>(cx: &LateContext<'tcx>, iter: &'tcx Expr<'tcx>) ->
     let ty::Adt(adt, substs) = cx.typeck_results().expr_ty(iter).kind() else {
         return None;
     };
-    let did = adt.did();
 
-    if cx.tcx.is_diagnostic_item(sym::ArrayIntoIter, did) {
-        // For array::IntoIter<T, const N: usize>, the length is the second generic
-        // parameter.
-        substs.const_at(1).try_to_target_usize(cx.tcx).map(u128::from)
-    } else if cx.tcx.is_diagnostic_item(sym::SliceIter, did)
-        && let ExprKind::MethodCall(_, recv, ..) = iter.kind
-    {
-        if let ty::Array(_, len) = cx.typeck_results().expr_ty(recv).peel_refs().kind() {
-            // For slice::Iter<'_, T>, the receiver might be an array literal: [1,2,3].iter().skip(..)
-            len.try_to_target_usize(cx.tcx).map(u128::from)
-        } else if let Some(args) = VecArgs::hir(cx, expr_or_init(cx, recv)) {
-            match args {
-                VecArgs::Vec(vec) => vec.len().try_into().ok(),
-                VecArgs::Repeat(_, len) => expr_as_u128(cx, len),
+    match cx.tcx.get_diagnostic_name(adt.did()) {
+        Some(sym::ArrayIntoIter) => {
+            // For array::IntoIter<T, const N: usize>, the length is the second generic
+            // parameter.
+            substs.const_at(1).try_to_target_usize(cx.tcx).map(u128::from)
+        },
+        Some(sym::SliceIter) if let ExprKind::MethodCall(_, recv, ..) = iter.kind => {
+            if let ty::Array(_, len) = cx.typeck_results().expr_ty(recv).peel_refs().kind() {
+                // For slice::Iter<'_, T>, the receiver might be an array literal: [1,2,3].iter().skip(..)
+                len.try_to_target_usize(cx.tcx).map(u128::from)
+            } else if let Some(args) = VecArgs::hir(cx, expr_or_init(cx, recv)) {
+                match args {
+                    VecArgs::Vec(vec) => vec.len().try_into().ok(),
+                    VecArgs::Repeat(_, len) => expr_as_u128(cx, len),
+                }
+            } else {
+                None
             }
-        } else {
-            None
-        }
-    } else if cx.tcx.is_diagnostic_item(sym::IterEmpty, did) {
-        Some(0)
-    } else if cx.tcx.is_diagnostic_item(sym::IterOnce, did) {
-        Some(1)
-    } else {
-        None
+        },
+        Some(sym::IterEmpty) => Some(0),
+        Some(sym::IterOnce) => Some(1),
+        _ => None,
     }
 }
 
diff --git a/clippy_lints/src/methods/option_as_ref_deref.rs b/clippy_lints/src/methods/option_as_ref_deref.rs
index 63ee922acfa0d..906ead16fd0d1 100644
--- a/clippy_lints/src/methods/option_as_ref_deref.rs
+++ b/clippy_lints/src/methods/option_as_ref_deref.rs
@@ -38,17 +38,13 @@ pub(super) fn check(
     ];
 
     let is_deref = match map_arg.kind {
-        hir::ExprKind::Path(ref expr_qpath) => {
-            cx.qpath_res(expr_qpath, map_arg.hir_id)
-                .opt_def_id()
-                .is_some_and(|fun_def_id| {
-                    cx.tcx.is_diagnostic_item(sym::deref_method, fun_def_id)
-                        || cx.tcx.is_diagnostic_item(sym::deref_mut_method, fun_def_id)
-                        || deref_aliases
-                            .iter()
-                            .any(|&sym| cx.tcx.is_diagnostic_item(sym, fun_def_id))
-                })
-        },
+        hir::ExprKind::Path(ref expr_qpath) => cx
+            .qpath_res(expr_qpath, map_arg.hir_id)
+            .opt_def_id()
+            .and_then(|fun_def_id| cx.tcx.get_diagnostic_name(fun_def_id))
+            .is_some_and(|fun_name| {
+                matches!(fun_name, sym::deref_method | sym::deref_mut_method) || deref_aliases.contains(&fun_name)
+            }),
         hir::ExprKind::Closure(&hir::Closure { body, .. }) => {
             let closure_body = cx.tcx.hir_body(body);
             let closure_expr = peel_blocks(closure_body.value);
@@ -63,13 +59,11 @@ pub(super) fn check(
                             .map(|x| &x.kind)
                             .collect::<Box<[_]>>()
                         && let [ty::adjustment::Adjust::Deref(None), ty::adjustment::Adjust::Borrow(_)] = *adj
+                        && let method_did = cx.typeck_results().type_dependent_def_id(closure_expr.hir_id).unwrap()
+                        && let Some(method_name) = cx.tcx.get_diagnostic_name(method_did)
                     {
-                        let method_did = cx.typeck_results().type_dependent_def_id(closure_expr.hir_id).unwrap();
-                        cx.tcx.is_diagnostic_item(sym::deref_method, method_did)
-                            || cx.tcx.is_diagnostic_item(sym::deref_mut_method, method_did)
-                            || deref_aliases
-                                .iter()
-                                .any(|&sym| cx.tcx.is_diagnostic_item(sym, method_did))
+                        matches!(method_name, sym::deref_method | sym::deref_mut_method)
+                            || deref_aliases.contains(&method_name)
                     } else {
                         false
                     }
diff --git a/clippy_lints/src/methods/unnecessary_min_or_max.rs b/clippy_lints/src/methods/unnecessary_min_or_max.rs
index 413881d5ec99e..b87d81b710269 100644
--- a/clippy_lints/src/methods/unnecessary_min_or_max.rs
+++ b/clippy_lints/src/methods/unnecessary_min_or_max.rs
@@ -22,7 +22,8 @@ pub(super) fn check<'tcx>(
     let typeck_results = cx.typeck_results();
     let ecx = ConstEvalCtxt::with_env(cx.tcx, cx.typing_env(), typeck_results);
     if let Some(id) = typeck_results.type_dependent_def_id(expr.hir_id)
-        && (cx.tcx.is_diagnostic_item(sym::cmp_ord_min, id) || cx.tcx.is_diagnostic_item(sym::cmp_ord_max, id))
+        && let Some(fn_name) = cx.tcx.get_diagnostic_name(id)
+        && matches!(fn_name, sym::cmp_ord_min | sym::cmp_ord_max)
     {
         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)
diff --git a/clippy_lints/src/operators/cmp_owned.rs b/clippy_lints/src/operators/cmp_owned.rs
index 22ec4fe60fb02..604f8f5da0b86 100644
--- a/clippy_lints/src/operators/cmp_owned.rs
+++ b/clippy_lints/src/operators/cmp_owned.rs
@@ -47,14 +47,10 @@ fn check_op(cx: &LateContext<'_>, expr: &Expr<'_>, other: &Expr<'_>, left: bool)
             (arg, arg.span)
         },
         ExprKind::Call(path, [arg])
-            if path_def_id(cx, path).is_some_and(|did| {
-                if cx.tcx.is_diagnostic_item(sym::from_str_method, did) {
-                    true
-                } else if cx.tcx.is_diagnostic_item(sym::from_fn, did) {
-                    !is_copy(cx, typeck.expr_ty(expr))
-                } else {
-                    false
-                }
+            if path_def_id(cx, path).is_some_and(|did| match cx.tcx.get_diagnostic_name(did) {
+                Some(sym::from_str_method) => true,
+                Some(sym::from_fn) => !is_copy(cx, typeck.expr_ty(expr)),
+                _ => false,
             }) =>
         {
             (arg, arg.span)
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index e57b8cc2d84e3..193d9dda88456 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -96,14 +96,13 @@ 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 fn_name = cx.tcx.get_diagnostic_name(fn_def_id);
+
             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));
+                || fn_name == Some(sym::to_owned_method)
+                || (fn_name == Some(sym::to_string_method) && is_type_lang_item(cx, arg_ty, LangItem::String));
 
-            let from_deref = !from_borrow
-                && (cx.tcx.is_diagnostic_item(sym::path_to_pathbuf, fn_def_id)
-                    || cx.tcx.is_diagnostic_item(sym::os_str_to_os_string, fn_def_id));
+            let from_deref = !from_borrow && matches!(fn_name, Some(sym::path_to_pathbuf | sym::os_str_to_os_string));
 
             if !from_borrow && !from_deref {
                 continue;
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 490e6c974ae10..57d5900b045ea 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -457,7 +457,8 @@ impl<'tcx> LateLintPass<'tcx> for TrimSplitWhitespace {
 }
 
 fn is_one_of_trim_diagnostic_items(cx: &LateContext<'_>, trim_def_id: DefId) -> bool {
-    cx.tcx.is_diagnostic_item(sym::str_trim, trim_def_id)
-        || cx.tcx.is_diagnostic_item(sym::str_trim_start, trim_def_id)
-        || cx.tcx.is_diagnostic_item(sym::str_trim_end, trim_def_id)
+    matches!(
+        cx.tcx.get_diagnostic_name(trim_def_id),
+        Some(sym::str_trim | sym::str_trim_start | sym::str_trim_end)
+    )
 }
diff --git a/clippy_lints/src/types/rc_buffer.rs b/clippy_lints/src/types/rc_buffer.rs
index d691f1878b11b..c4fd0fbf87a90 100644
--- a/clippy_lints/src/types/rc_buffer.rs
+++ b/clippy_lints/src/types/rc_buffer.rs
@@ -11,7 +11,8 @@ use super::RC_BUFFER;
 
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
     let app = Applicability::Unspecified;
-    if cx.tcx.is_diagnostic_item(sym::Rc, def_id) {
+    let name = cx.tcx.get_diagnostic_name(def_id);
+    if name == Some(sym::Rc) {
         if let Some(alternate) = match_buffer_type(cx, qpath) {
             #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
             span_lint_and_then(
@@ -56,7 +57,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
             );
             return true;
         }
-    } else if cx.tcx.is_diagnostic_item(sym::Arc, def_id) {
+    } else if name == Some(sym::Arc) {
         if let Some(alternate) = match_buffer_type(cx, qpath) {
             #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
             span_lint_and_then(
diff --git a/clippy_lints/src/types/redundant_allocation.rs b/clippy_lints/src/types/redundant_allocation.rs
index de3456a8ba5fc..0ba51daf027d1 100644
--- a/clippy_lints/src/types/redundant_allocation.rs
+++ b/clippy_lints/src/types/redundant_allocation.rs
@@ -13,14 +13,11 @@ use super::{REDUNDANT_ALLOCATION, utils};
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, hir_ty: &hir::Ty<'tcx>, qpath: &QPath<'tcx>, def_id: DefId) -> bool {
     let mut applicability = Applicability::MaybeIncorrect;
-    let outer_sym = if Some(def_id) == cx.tcx.lang_items().owned_box() {
-        "Box"
-    } else if cx.tcx.is_diagnostic_item(sym::Rc, def_id) {
-        "Rc"
-    } else if cx.tcx.is_diagnostic_item(sym::Arc, def_id) {
-        "Arc"
-    } else {
-        return false;
+    let outer_sym = match cx.tcx.get_diagnostic_name(def_id) {
+        _ if Some(def_id) == cx.tcx.lang_items().owned_box() => "Box",
+        Some(sym::Rc) => "Rc",
+        Some(sym::Arc) => "Arc",
+        _ => return false,
     };
 
     if let Some(span) = utils::match_borrows_parameter(cx, qpath) {
diff --git a/clippy_lints/src/unnecessary_owned_empty_strings.rs b/clippy_lints/src/unnecessary_owned_empty_strings.rs
index 7d996775a58c8..28f4884fa3110 100644
--- a/clippy_lints/src/unnecessary_owned_empty_strings.rs
+++ b/clippy_lints/src/unnecessary_owned_empty_strings.rs
@@ -41,7 +41,8 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryOwnedEmptyStrings {
             && let ty::Ref(_, inner_str, _) = cx.typeck_results().expr_ty_adjusted(expr).kind()
             && inner_str.is_str()
         {
-            if cx.tcx.is_diagnostic_item(sym::string_new, fun_def_id) {
+            let fun_name = cx.tcx.get_diagnostic_name(fun_def_id);
+            if fun_name == Some(sym::string_new) {
                 span_lint_and_sugg(
                     cx,
                     UNNECESSARY_OWNED_EMPTY_STRINGS,
@@ -51,7 +52,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryOwnedEmptyStrings {
                     "\"\"".to_owned(),
                     Applicability::MachineApplicable,
                 );
-            } else if cx.tcx.is_diagnostic_item(sym::from_fn, fun_def_id)
+            } else if fun_name == Some(sym::from_fn)
                 && let [arg] = args
                 && let ExprKind::Lit(spanned) = &arg.kind
                 && let LitKind::Str(symbol, _) = spanned.node
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index 54a7efc090ade..849c0b438a5a0 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -107,12 +107,10 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
         // Get the wrapper and inner types, if can't, abort.
         let (return_type_label, lang_item, inner_type) =
             if let ty::Adt(adt_def, subst) = return_ty(cx, hir_id.expect_owner()).kind() {
-                if cx.tcx.is_diagnostic_item(sym::Option, adt_def.did()) {
-                    ("Option", OptionSome, subst.type_at(0))
-                } else if cx.tcx.is_diagnostic_item(sym::Result, adt_def.did()) {
-                    ("Result", ResultOk, subst.type_at(0))
-                } else {
-                    return;
+                match cx.tcx.get_diagnostic_name(adt_def.did()) {
+                    Some(sym::Option) => ("Option", OptionSome, subst.type_at(0)),
+                    Some(sym::Result) => ("Result", ResultOk, subst.type_at(0)),
+                    _ => return,
                 }
             } else {
                 return;
diff --git a/clippy_lints/src/zombie_processes.rs b/clippy_lints/src/zombie_processes.rs
index 6ab94a5221092..06d36276dfc01 100644
--- a/clippy_lints/src/zombie_processes.rs
+++ b/clippy_lints/src/zombie_processes.rs
@@ -177,8 +177,8 @@ impl<'tcx> Visitor<'tcx> for WaitFinder<'_, 'tcx> {
                 Node::Expr(expr) if let ExprKind::AddrOf(_, Mutability::Not, _) = expr.kind => {},
                 Node::Expr(expr)
                     if let Some(fn_did) = fn_def_id(self.cx, expr)
-                        && (self.cx.tcx.is_diagnostic_item(sym::child_id, fn_did)
-                            || self.cx.tcx.is_diagnostic_item(sym::child_kill, fn_did)) => {},
+                        && let Some(fn_name) = self.cx.tcx.get_diagnostic_name(fn_did)
+                        && matches!(fn_name, sym::child_id | sym::child_kill) => {},
 
                 // Conservatively assume that all other kinds of nodes call `.wait()` somehow.
                 _ => return Break(MaybeWait(ex.span)),
@@ -351,9 +351,14 @@ fn check<'tcx>(cx: &LateContext<'tcx>, spawn_expr: &'tcx Expr<'tcx>, cause: Caus
 
 /// Checks if the given expression exits the process.
 fn is_exit_expression(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    fn_def_id(cx, expr).is_some_and(|fn_did| {
-        cx.tcx.is_diagnostic_item(sym::process_exit, fn_did) || cx.tcx.is_diagnostic_item(sym::process_abort, fn_did)
-    })
+    if let Some(fn_did) = fn_def_id(cx, expr)
+        && let Some(fn_name) = cx.tcx.get_diagnostic_name(fn_did)
+        && matches!(fn_name, sym::process_exit | sym::process_abort)
+    {
+        true
+    } else {
+        false
+    }
 }
 
 #[derive(Debug)]

From 246f9bde06d7b040993ff7885a2dd75d68313cd3 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 20 Aug 2025 10:59:02 +0200
Subject: [PATCH 0191/1889] higher: use `get_diagnostic_name`

---
 clippy_utils/src/higher.rs | 33 +++++++++++++++++----------------
 1 file changed, 17 insertions(+), 16 deletions(-)

diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 4e0b00df9508d..9db18f66e9a24 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -288,22 +288,23 @@ impl<'a> VecArgs<'a> {
             && is_expn_of(fun.span, sym::vec).is_some()
             && let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id()
         {
-            return if cx.tcx.is_diagnostic_item(sym::vec_from_elem, fun_def_id) && args.len() == 2 {
-                // `vec![elem; size]` case
-                Some(VecArgs::Repeat(&args[0], &args[1]))
-            } else if cx.tcx.is_diagnostic_item(sym::slice_into_vec, fun_def_id) && args.len() == 1 {
-                // `vec![a, b, c]` case
-                if let ExprKind::Call(_, [arg]) = &args[0].kind
-                    && let ExprKind::Array(args) = arg.kind
-                {
-                    Some(VecArgs::Vec(args))
-                } else {
-                    None
-                }
-            } else if cx.tcx.is_diagnostic_item(sym::vec_new, fun_def_id) && args.is_empty() {
-                Some(VecArgs::Vec(&[]))
-            } else {
-                None
+            return match (cx.tcx.get_diagnostic_name(fun_def_id), args.len()) {
+                (Some(sym::vec_from_elem), 2) => {
+                    // `vec![elem; size]` case
+                    Some(VecArgs::Repeat(&args[0], &args[1]))
+                },
+                (Some(sym::slice_into_vec), 1) => {
+                    // `vec![a, b, c]` case
+                    if let ExprKind::Call(_, [arg]) = &args[0].kind
+                        && let ExprKind::Array(args) = arg.kind
+                    {
+                        Some(VecArgs::Vec(args))
+                    } else {
+                        None
+                    }
+                },
+                (Some(sym::vec_new), 0) => Some(VecArgs::Vec(&[])),
+                _ => None,
             };
         }
 

From 30743966c0f1ffe817fba44e5f91d2fbd340906f Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Tue, 19 Aug 2025 23:46:47 +0200
Subject: [PATCH 0192/1889] misc: destruct `args` directly

avoids bounds checks
---
 clippy_utils/src/higher.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 9db18f66e9a24..425de63ae198a 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -288,14 +288,14 @@ impl<'a> VecArgs<'a> {
             && is_expn_of(fun.span, sym::vec).is_some()
             && let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id()
         {
-            return match (cx.tcx.get_diagnostic_name(fun_def_id), args.len()) {
-                (Some(sym::vec_from_elem), 2) => {
+            return match (cx.tcx.get_diagnostic_name(fun_def_id), args) {
+                (Some(sym::vec_from_elem), [elem, size]) => {
                     // `vec![elem; size]` case
-                    Some(VecArgs::Repeat(&args[0], &args[1]))
+                    Some(VecArgs::Repeat(elem, size))
                 },
-                (Some(sym::slice_into_vec), 1) => {
+                (Some(sym::slice_into_vec), [slice]) => {
                     // `vec![a, b, c]` case
-                    if let ExprKind::Call(_, [arg]) = &args[0].kind
+                    if let ExprKind::Call(_, [arg]) = slice.kind
                         && let ExprKind::Array(args) = arg.kind
                     {
                         Some(VecArgs::Vec(args))
@@ -303,7 +303,7 @@ impl<'a> VecArgs<'a> {
                         None
                     }
                 },
-                (Some(sym::vec_new), 0) => Some(VecArgs::Vec(&[])),
+                (Some(sym::vec_new), []) => Some(VecArgs::Vec(&[])),
                 _ => None,
             };
         }

From 5420d07d0768a81655e269d005fedc739511b22e Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Tue, 19 Aug 2025 23:47:38 +0200
Subject: [PATCH 0193/1889] misc: pull condition into guard

`None` is the fallback case anyway
---
 clippy_utils/src/higher.rs | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 425de63ae198a..0caeddd9f088f 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -293,15 +293,12 @@ impl<'a> VecArgs<'a> {
                     // `vec![elem; size]` case
                     Some(VecArgs::Repeat(elem, size))
                 },
-                (Some(sym::slice_into_vec), [slice]) => {
-                    // `vec![a, b, c]` case
+                (Some(sym::slice_into_vec), [slice])
                     if let ExprKind::Call(_, [arg]) = slice.kind
-                        && let ExprKind::Array(args) = arg.kind
-                    {
-                        Some(VecArgs::Vec(args))
-                    } else {
-                        None
-                    }
+                        && let ExprKind::Array(args) = arg.kind =>
+                {
+                    // `vec![a, b, c]` case
+                    Some(VecArgs::Vec(args))
                 },
                 (Some(sym::vec_new), []) => Some(VecArgs::Vec(&[])),
                 _ => None,

From d7458294a1ea4f4d76f5fab602fe5fc84f9c8c3a Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Tue, 19 Aug 2025 23:56:00 +0200
Subject: [PATCH 0194/1889] misc: return earlier on `name = None`

---
 clippy_utils/src/higher.rs | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 0caeddd9f088f..bda28a663fb07 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -287,20 +287,21 @@ impl<'a> VecArgs<'a> {
             && let ExprKind::Path(ref qpath) = fun.kind
             && is_expn_of(fun.span, sym::vec).is_some()
             && let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id()
+            && let Some(name) = cx.tcx.get_diagnostic_name(fun_def_id)
         {
-            return match (cx.tcx.get_diagnostic_name(fun_def_id), args) {
-                (Some(sym::vec_from_elem), [elem, size]) => {
+            return match (name, args) {
+                (sym::vec_from_elem, [elem, size]) => {
                     // `vec![elem; size]` case
                     Some(VecArgs::Repeat(elem, size))
                 },
-                (Some(sym::slice_into_vec), [slice])
+                (sym::slice_into_vec, [slice])
                     if let ExprKind::Call(_, [arg]) = slice.kind
                         && let ExprKind::Array(args) = arg.kind =>
                 {
                     // `vec![a, b, c]` case
                     Some(VecArgs::Vec(args))
                 },
-                (Some(sym::vec_new), []) => Some(VecArgs::Vec(&[])),
+                (sym::vec_new, []) => Some(VecArgs::Vec(&[])),
                 _ => None,
             };
         }

From 0938652791822c64de8366d84ac06710b509314f Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 20 Aug 2025 11:04:20 +0200
Subject: [PATCH 0195/1889] non_octal_unix_permissions: `get_diagnostic_name`
 once

---
 clippy_lints/src/non_octal_unix_permissions.rs | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/clippy_lints/src/non_octal_unix_permissions.rs b/clippy_lints/src/non_octal_unix_permissions.rs
index 23a1622f30fff..1aec5412cda7e 100644
--- a/clippy_lints/src/non_octal_unix_permissions.rs
+++ b/clippy_lints/src/non_octal_unix_permissions.rs
@@ -43,13 +43,11 @@ impl<'tcx> LateLintPass<'tcx> for NonOctalUnixPermissions {
         match &expr.kind {
             ExprKind::MethodCall(path, func, [param], _) => {
                 if let Some(adt) = cx.typeck_results().expr_ty(func).peel_refs().ty_adt_def()
-                    && ((path.ident.name == sym::mode
-                        && matches!(
-                            cx.tcx.get_diagnostic_name(adt.did()),
-                            Some(sym::FsOpenOptions | sym::DirBuilder)
-                        ))
-                        || (path.ident.name == sym::set_mode
-                            && cx.tcx.is_diagnostic_item(sym::FsPermissions, adt.did())))
+                    && matches!(
+                        (path.ident.name, cx.tcx.get_diagnostic_name(adt.did())),
+                        (sym::mode, Some(sym::FsOpenOptions | sym::DirBuilder))
+                            | (sym::set_mode, Some(sym::FsPermissions))
+                    )
                     && let ExprKind::Lit(_) = param.kind
                     && param.span.eq_ctxt(expr.span)
                     && param

From c4e905cf93b3628fab6544fe31c077af8a14ca3d Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 20 Aug 2025 00:41:05 +0200
Subject: [PATCH 0196/1889] misc: reorder to have struct first, then its method

---
 clippy_lints/src/non_octal_unix_permissions.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/clippy_lints/src/non_octal_unix_permissions.rs b/clippy_lints/src/non_octal_unix_permissions.rs
index 1aec5412cda7e..cb934466bd890 100644
--- a/clippy_lints/src/non_octal_unix_permissions.rs
+++ b/clippy_lints/src/non_octal_unix_permissions.rs
@@ -44,9 +44,9 @@ impl<'tcx> LateLintPass<'tcx> for NonOctalUnixPermissions {
             ExprKind::MethodCall(path, func, [param], _) => {
                 if let Some(adt) = cx.typeck_results().expr_ty(func).peel_refs().ty_adt_def()
                     && matches!(
-                        (path.ident.name, cx.tcx.get_diagnostic_name(adt.did())),
-                        (sym::mode, Some(sym::FsOpenOptions | sym::DirBuilder))
-                            | (sym::set_mode, Some(sym::FsPermissions))
+                        (cx.tcx.get_diagnostic_name(adt.did()), path.ident.name),
+                        (Some(sym::FsOpenOptions | sym::DirBuilder), sym::mode)
+                            | (Some(sym::FsPermissions), sym::set_mode)
                     )
                     && let ExprKind::Lit(_) = param.kind
                     && param.span.eq_ctxt(expr.span)

From dc94cbeb2a7aefabd1601f2dfc9226a68e682792 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 20 Aug 2025 00:49:30 +0200
Subject: [PATCH 0197/1889] redundant_clone: partially inline
 `is_type_diagnostic_item`

to be able to reuse `did`
---
 clippy_lints/src/redundant_clone.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 193d9dda88456..1d58cdd26d88d 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::{span_lint_hir, span_lint_hir_and_then};
 use clippy_utils::fn_has_unsatisfiable_preds;
 use clippy_utils::mir::{LocalUsage, PossibleBorrowerMap, visit_local_usage};
 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::ty::{has_drop, is_copy, is_type_lang_item, walk_ptrs_ty_depth};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, FnDecl, LangItem, def_id};
@@ -147,8 +147,9 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
                     is_call_with_ref_arg(cx, mir, &pred_terminator.kind)
                     && res == cloned
                     && cx.tcx.is_diagnostic_item(sym::deref_method, pred_fn_def_id)
-                    && (is_type_diagnostic_item(cx, pred_arg_ty, sym::PathBuf)
-                        || is_type_diagnostic_item(cx, pred_arg_ty, sym::OsString))
+                    && let ty::Adt(pred_arg_def, _) = pred_arg_ty.kind()
+                    && let Some(pred_arg_name) = cx.tcx.get_diagnostic_name(pred_arg_def.did())
+                    && matches!(pred_arg_name, sym::PathBuf | sym::OsString)
                 {
                     (pred_arg, res)
                 } else {

From 74731748cd6f9ca6538ce20c59859aaf2b0a93ba Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 20 Aug 2025 01:01:09 +0200
Subject: [PATCH 0198/1889] len_zero: use `get_diagnostic_name`

---
 clippy_lints/src/len_zero.rs | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 57deb011f2b0e..28a0fbc051158 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -355,12 +355,15 @@ fn parse_len_output<'tcx>(cx: &LateContext<'tcx>, sig: FnSig<'tcx>) -> Option<Le
             return Some(LenOutput::Integral);
         }
 
-        if let Res::Def(_, def_id) = res {
-            if cx.tcx.is_diagnostic_item(sym::Option, def_id) && is_first_generic_integral(segment) {
-                return Some(LenOutput::Option(def_id));
-            } else if cx.tcx.is_diagnostic_item(sym::Result, def_id) && is_first_generic_integral(segment) {
-                return Some(LenOutput::Result(def_id));
+        if let Res::Def(_, def_id) = res
+            && let Some(res) = match cx.tcx.get_diagnostic_name(def_id) {
+                Some(sym::Option) => Some(LenOutput::Option(def_id)),
+                Some(sym::Result) => Some(LenOutput::Result(def_id)),
+                _ => None,
             }
+            && is_first_generic_integral(segment)
+        {
+            return Some(res);
         }
 
         return None;
@@ -368,11 +371,10 @@ fn parse_len_output<'tcx>(cx: &LateContext<'tcx>, sig: FnSig<'tcx>) -> Option<Le
 
     match *sig.output().kind() {
         ty::Int(_) | ty::Uint(_) => Some(LenOutput::Integral),
-        ty::Adt(adt, subs) if cx.tcx.is_diagnostic_item(sym::Option, adt.did()) => {
-            subs.type_at(0).is_integral().then(|| LenOutput::Option(adt.did()))
-        },
-        ty::Adt(adt, subs) if cx.tcx.is_diagnostic_item(sym::Result, adt.did()) => {
-            subs.type_at(0).is_integral().then(|| LenOutput::Result(adt.did()))
+        ty::Adt(adt, subs) => match cx.tcx.get_diagnostic_name(adt.did()) {
+            Some(sym::Option) => subs.type_at(0).is_integral().then(|| LenOutput::Option(adt.did())),
+            Some(sym::Result) => subs.type_at(0).is_integral().then(|| LenOutput::Result(adt.did())),
+            _ => None,
         },
         _ => None,
     }

From 37b6237cd31798037cfdf5556ce44ab8fabd7883 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 20 Aug 2025 01:02:07 +0200
Subject: [PATCH 0199/1889] misc: pull another condition into match arm

---
 clippy_lints/src/len_zero.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 28a0fbc051158..f44a5fdf715e5 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -371,9 +371,9 @@ fn parse_len_output<'tcx>(cx: &LateContext<'tcx>, sig: FnSig<'tcx>) -> Option<Le
 
     match *sig.output().kind() {
         ty::Int(_) | ty::Uint(_) => Some(LenOutput::Integral),
-        ty::Adt(adt, subs) => match cx.tcx.get_diagnostic_name(adt.did()) {
-            Some(sym::Option) => subs.type_at(0).is_integral().then(|| LenOutput::Option(adt.did())),
-            Some(sym::Result) => subs.type_at(0).is_integral().then(|| LenOutput::Result(adt.did())),
+        ty::Adt(adt, subs) if subs.type_at(0).is_integral() => match cx.tcx.get_diagnostic_name(adt.did()) {
+            Some(sym::Option) => Some(LenOutput::Option(adt.did())),
+            Some(sym::Result) => Some(LenOutput::Result(adt.did())),
             _ => None,
         },
         _ => None,

From 6cf7634323374cfbd618c5bd3ca7040cfdf96f55 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 20 Aug 2025 10:57:23 +0200
Subject: [PATCH 0200/1889] non_canonical_impls: save diagnostic name to a
 variable

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

diff --git a/clippy_lints/src/non_canonical_impls.rs b/clippy_lints/src/non_canonical_impls.rs
index 04b092769666c..19fd1925e9082 100644
--- a/clippy_lints/src/non_canonical_impls.rs
+++ b/clippy_lints/src/non_canonical_impls.rs
@@ -134,7 +134,8 @@ impl LateLintPass<'_> for NonCanonicalImpls {
             return;
         }
 
-        if cx.tcx.is_diagnostic_item(sym::Clone, trait_impl.def_id)
+        let trait_name = cx.tcx.get_diagnostic_name(trait_impl.def_id);
+        if trait_name == Some(sym::Clone)
             && let Some(copy_def_id) = cx.tcx.get_diagnostic_item(sym::Copy)
             && implements_trait(cx, trait_impl.self_ty(), copy_def_id, &[])
         {
@@ -175,7 +176,7 @@ impl LateLintPass<'_> for NonCanonicalImpls {
             }
         }
 
-        if cx.tcx.is_diagnostic_item(sym::PartialOrd, trait_impl.def_id)
+        if trait_name == Some(sym::PartialOrd)
             && impl_item.ident.name == sym::partial_cmp
             && let Some(ord_def_id) = cx.tcx.get_diagnostic_item(sym::Ord)
             && implements_trait(cx, trait_impl.self_ty(), ord_def_id, &[])

From 58b646239d2ad0f757eb6930e0bb42ad69bcac15 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 20 Aug 2025 01:16:23 +0200
Subject: [PATCH 0201/1889] misc: don't bother checking the other case

`trait_name` can only be _one_ of those at the same time
---
 clippy_lints/src/non_canonical_impls.rs | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/clippy_lints/src/non_canonical_impls.rs b/clippy_lints/src/non_canonical_impls.rs
index 19fd1925e9082..ba67dc62abbda 100644
--- a/clippy_lints/src/non_canonical_impls.rs
+++ b/clippy_lints/src/non_canonical_impls.rs
@@ -171,12 +171,8 @@ impl LateLintPass<'_> for NonCanonicalImpls {
                     String::new(),
                     Applicability::MaybeIncorrect,
                 );
-
-                return;
             }
-        }
-
-        if trait_name == Some(sym::PartialOrd)
+        } else if trait_name == Some(sym::PartialOrd)
             && impl_item.ident.name == sym::partial_cmp
             && let Some(ord_def_id) = cx.tcx.get_diagnostic_item(sym::Ord)
             && implements_trait(cx, trait_impl.self_ty(), ord_def_id, &[])

From 8a969f709034375eed5d13dee6b44b31fcef2cf5 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 20 Aug 2025 20:56:39 +0200
Subject: [PATCH 0202/1889] entry: use `get_diagnostic_item`

---
 clippy_lints/src/entry.rs | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index 182cb4e46d2bd..4e24f69357db8 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -274,12 +274,10 @@ fn try_parse_contains<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Optio
                 key,
                 call_ctxt: expr.span.ctxt(),
             };
-            if cx.tcx.is_diagnostic_item(sym::btreemap_contains_key, id) {
-                Some((MapType::BTree, expr))
-            } else if cx.tcx.is_diagnostic_item(sym::hashmap_contains_key, id) {
-                Some((MapType::Hash, expr))
-            } else {
-                None
+            match cx.tcx.get_diagnostic_name(id) {
+                Some(sym::btreemap_contains_key) => Some((MapType::BTree, expr)),
+                Some(sym::hashmap_contains_key) => Some((MapType::Hash, expr)),
+                _ => None,
             }
         },
         _ => None,

From 51426954182661dbe82424f790cb2b53b6a720d2 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 20 Aug 2025 01:39:23 +0200
Subject: [PATCH 0203/1889] misc: rewrite as `if let`

---
 clippy_lints/src/entry.rs | 53 ++++++++++++++++++++-------------------
 1 file changed, 27 insertions(+), 26 deletions(-)

diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index 4e24f69357db8..dd38aab6e3fb4 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -254,33 +254,34 @@ fn try_parse_contains<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Optio
         _ => None,
     });
 
-    match expr.kind {
-        ExprKind::MethodCall(
-            _,
+    if let ExprKind::MethodCall(
+        _,
+        map,
+        [
+            Expr {
+                kind: ExprKind::AddrOf(_, _, key),
+                span: key_span,
+                ..
+            },
+        ],
+        _,
+    ) = expr.kind
+        && key_span.eq_ctxt(expr.span)
+    {
+        let id = cx.typeck_results().type_dependent_def_id(expr.hir_id)?;
+        let expr = ContainsExpr {
+            negated,
             map,
-            [
-                Expr {
-                    kind: ExprKind::AddrOf(_, _, key),
-                    span: key_span,
-                    ..
-                },
-            ],
-            _,
-        ) if key_span.eq_ctxt(expr.span) => {
-            let id = cx.typeck_results().type_dependent_def_id(expr.hir_id)?;
-            let expr = ContainsExpr {
-                negated,
-                map,
-                key,
-                call_ctxt: expr.span.ctxt(),
-            };
-            match cx.tcx.get_diagnostic_name(id) {
-                Some(sym::btreemap_contains_key) => Some((MapType::BTree, expr)),
-                Some(sym::hashmap_contains_key) => Some((MapType::Hash, expr)),
-                _ => None,
-            }
-        },
-        _ => None,
+            key,
+            call_ctxt: expr.span.ctxt(),
+        };
+        match cx.tcx.get_diagnostic_name(id) {
+            Some(sym::btreemap_contains_key) => Some((MapType::BTree, expr)),
+            Some(sym::hashmap_contains_key) => Some((MapType::Hash, expr)),
+            _ => None,
+        }
+    } else {
+        None
     }
 }
 

From c9878185a87826b632920a4b1cb44a30685f81a9 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 20 Aug 2025 01:41:58 +0200
Subject: [PATCH 0204/1889] misc: match in multiple steps

---
 clippy_lints/src/entry.rs | 18 ++++++------------
 1 file changed, 6 insertions(+), 12 deletions(-)

diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index dd38aab6e3fb4..53dc2c05add22 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -254,18 +254,12 @@ fn try_parse_contains<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Optio
         _ => None,
     });
 
-    if let ExprKind::MethodCall(
-        _,
-        map,
-        [
-            Expr {
-                kind: ExprKind::AddrOf(_, _, key),
-                span: key_span,
-                ..
-            },
-        ],
-        _,
-    ) = expr.kind
+    if let ExprKind::MethodCall(_, map, [arg], _) = expr.kind
+        && let Expr {
+            kind: ExprKind::AddrOf(_, _, key),
+            span: key_span,
+            ..
+        } = arg
         && key_span.eq_ctxt(expr.span)
     {
         let id = cx.typeck_results().type_dependent_def_id(expr.hir_id)?;

From cd2d2a034d4e88ac6a3635c6a0cf2079eedecc21 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 6 Aug 2025 23:03:55 +0200
Subject: [PATCH 0205/1889] init by copying `ty_search_pat`

---
 clippy_utils/src/check_proc_macro.rs | 42 ++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index c4a759e919b1b..d569865553aa5 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -13,6 +13,7 @@
 //! if the span is not from a `macro_rules` based macro.
 
 use rustc_abi::ExternAbi;
+use rustc_ast as ast;
 use rustc_ast::AttrStyle;
 use rustc_ast::ast::{AttrKind, Attribute, IntTy, LitIntType, LitKind, StrStyle, TraitObjectSyntax, UintTy};
 use rustc_ast::token::CommentKind;
@@ -411,6 +412,47 @@ fn ty_search_pat(ty: &Ty<'_>) -> (Pat, Pat) {
     }
 }
 
+fn ast_ty_search_pat(ty: &ast::Ty) -> (Pat, Pat) {
+    match ty.kind {
+        TyKind::Slice(..) | TyKind::Array(..) => (Pat::Str("["), Pat::Str("]")),
+        TyKind::Ptr(MutTy { ty, .. }) => (Pat::Str("*"), ty_search_pat(ty).1),
+        TyKind::Ref(_, MutTy { ty, .. }) => (Pat::Str("&"), ty_search_pat(ty).1),
+        TyKind::FnPtr(fn_ptr) => (
+            if fn_ptr.safety.is_unsafe() {
+                Pat::Str("unsafe")
+            } else if fn_ptr.abi != ExternAbi::Rust {
+                Pat::Str("extern")
+            } else {
+                Pat::MultiStr(&["fn", "extern"])
+            },
+            match fn_ptr.decl.output {
+                FnRetTy::DefaultReturn(_) => {
+                    if let [.., ty] = fn_ptr.decl.inputs {
+                        ty_search_pat(ty).1
+                    } else {
+                        Pat::Str("(")
+                    }
+                },
+                FnRetTy::Return(ty) => ty_search_pat(ty).1,
+            },
+        ),
+        TyKind::Never => (Pat::Str("!"), Pat::Str("!")),
+        // Parenthesis are trimmed from the text before the search patterns are matched.
+        // See: `span_matches_pat`
+        TyKind::Tup([]) => (Pat::Str(")"), Pat::Str("(")),
+        TyKind::Tup([ty]) => ty_search_pat(ty),
+        TyKind::Tup([head, .., tail]) => (ty_search_pat(head).0, ty_search_pat(tail).1),
+        TyKind::OpaqueDef(..) => (Pat::Str("impl"), Pat::Str("")),
+        TyKind::Path(qpath) => qpath_search_pat(&qpath),
+        TyKind::Infer(()) => (Pat::Str("_"), Pat::Str("_")),
+        TyKind::TraitObject(_, tagged_ptr) if let TraitObjectSyntax::Dyn = tagged_ptr.tag() => {
+            (Pat::Str("dyn"), Pat::Str(""))
+        },
+        // NOTE: `TraitObject` is incomplete. It will always return true then.
+        _ => (Pat::Str(""), Pat::Str("")),
+    }
+}
+
 fn ident_search_pat(ident: Ident) -> (Pat, Pat) {
     (Pat::Sym(ident.name), Pat::Sym(ident.name))
 }

From a4dbbc9bf1cea10b396eec28e052a5096dc7da29 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 6 Aug 2025 23:04:49 +0200
Subject: [PATCH 0206/1889] rename recursive function call

---
 clippy_utils/src/check_proc_macro.rs | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index d569865553aa5..1ea68c1c22129 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -413,10 +413,12 @@ fn ty_search_pat(ty: &Ty<'_>) -> (Pat, Pat) {
 }
 
 fn ast_ty_search_pat(ty: &ast::Ty) -> (Pat, Pat) {
-    match ty.kind {
+    use ast::{FnRetTy, MutTy, TyKind};
+
+    match &ty.kind {
         TyKind::Slice(..) | TyKind::Array(..) => (Pat::Str("["), Pat::Str("]")),
-        TyKind::Ptr(MutTy { ty, .. }) => (Pat::Str("*"), ty_search_pat(ty).1),
-        TyKind::Ref(_, MutTy { ty, .. }) => (Pat::Str("&"), ty_search_pat(ty).1),
+        TyKind::Ptr(MutTy { ty, .. }) => (Pat::Str("*"), ast_ty_search_pat(ty).1),
+        TyKind::Ref(_, MutTy { ty, .. }) => (Pat::Str("&"), ast_ty_search_pat(ty).1),
         TyKind::FnPtr(fn_ptr) => (
             if fn_ptr.safety.is_unsafe() {
                 Pat::Str("unsafe")
@@ -428,20 +430,20 @@ fn ast_ty_search_pat(ty: &ast::Ty) -> (Pat, Pat) {
             match fn_ptr.decl.output {
                 FnRetTy::DefaultReturn(_) => {
                     if let [.., ty] = fn_ptr.decl.inputs {
-                        ty_search_pat(ty).1
+                        ast_ty_search_pat(ty).1
                     } else {
                         Pat::Str("(")
                     }
                 },
-                FnRetTy::Return(ty) => ty_search_pat(ty).1,
+                FnRetTy::Return(ty) => ast_ty_search_pat(ty).1,
             },
         ),
         TyKind::Never => (Pat::Str("!"), Pat::Str("!")),
         // Parenthesis are trimmed from the text before the search patterns are matched.
         // See: `span_matches_pat`
         TyKind::Tup([]) => (Pat::Str(")"), Pat::Str("(")),
-        TyKind::Tup([ty]) => ty_search_pat(ty),
-        TyKind::Tup([head, .., tail]) => (ty_search_pat(head).0, ty_search_pat(tail).1),
+        TyKind::Tup([ty]) => ast_ty_search_pat(ty),
+        TyKind::Tup([head, .., tail]) => (ast_ty_search_pat(head).0, ast_ty_search_pat(tail).1),
         TyKind::OpaqueDef(..) => (Pat::Str("impl"), Pat::Str("")),
         TyKind::Path(qpath) => qpath_search_pat(&qpath),
         TyKind::Infer(()) => (Pat::Str("_"), Pat::Str("_")),

From 2de81f56ec835d45858d0b2d80e8f1d7e1f1d1e3 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 6 Aug 2025 23:06:06 +0200
Subject: [PATCH 0207/1889] Infer is a unit variant

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

diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index 1ea68c1c22129..792c546e8ffc0 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -446,7 +446,7 @@ fn ast_ty_search_pat(ty: &ast::Ty) -> (Pat, Pat) {
         TyKind::Tup([head, .., tail]) => (ast_ty_search_pat(head).0, ast_ty_search_pat(tail).1),
         TyKind::OpaqueDef(..) => (Pat::Str("impl"), Pat::Str("")),
         TyKind::Path(qpath) => qpath_search_pat(&qpath),
-        TyKind::Infer(()) => (Pat::Str("_"), Pat::Str("_")),
+        TyKind::Infer => (Pat::Str("_"), Pat::Str("_")),
         TyKind::TraitObject(_, tagged_ptr) if let TraitObjectSyntax::Dyn = tagged_ptr.tag() => {
             (Pat::Str("dyn"), Pat::Str(""))
         },

From 73d04ba29f2db9073cc37bb43e9d0faf921344b2 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 6 Aug 2025 23:06:19 +0200
Subject: [PATCH 0208/1889] fix Path

---
 clippy_utils/src/check_proc_macro.rs | 51 ++++++++++++++++++++++++++--
 1 file changed, 49 insertions(+), 2 deletions(-)

diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index 792c546e8ffc0..d0a769e96b726 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -15,7 +15,9 @@
 use rustc_abi::ExternAbi;
 use rustc_ast as ast;
 use rustc_ast::AttrStyle;
-use rustc_ast::ast::{AttrKind, Attribute, IntTy, LitIntType, LitKind, StrStyle, TraitObjectSyntax, UintTy};
+use rustc_ast::ast::{
+    AttrKind, Attribute, GenericArgs, IntTy, LitIntType, LitKind, StrStyle, TraitObjectSyntax, UintTy,
+};
 use rustc_ast::token::CommentKind;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
@@ -445,7 +447,52 @@ fn ast_ty_search_pat(ty: &ast::Ty) -> (Pat, Pat) {
         TyKind::Tup([ty]) => ast_ty_search_pat(ty),
         TyKind::Tup([head, .., tail]) => (ast_ty_search_pat(head).0, ast_ty_search_pat(tail).1),
         TyKind::OpaqueDef(..) => (Pat::Str("impl"), Pat::Str("")),
-        TyKind::Path(qpath) => qpath_search_pat(&qpath),
+        TyKind::Path(qself_path, path) => {
+            let start = if qself_path.is_some() {
+                Pat::Str("<")
+            } else if let Some(first) = path.segments.first() {
+                ident_search_pat(first.ident).0
+            } else {
+                // this shouldn't be possible, but sure
+                Pat::Str("")
+            };
+            let end = if let Some(last) = path.segments.last() {
+                match last.args.as_deref() {
+                    // last `>` in `std::foo::Bar<T>`
+                    Some(GenericArgs::AngleBracketed(_)) => Pat::Str(">"),
+                    Some(GenericArgs::Parenthesized(par_args)) => match &par_args.output {
+                        FnRetTy::Default(_) => {
+                            if let Some(last) = par_args.inputs.last() {
+                                // `B` in `(A, B)` -- `)` gets stripped
+                                ast_ty_search_pat(last).1
+                            } else {
+                                // `(` in `()` -- `)` gets stripped
+                                Pat::Str("(")
+                            }
+                        },
+                        // `C` in `(A, B) -> C`
+                        FnRetTy::Ty(ty) => ast_ty_search_pat(ty).1,
+                    },
+                    // last `..` in `(..)` -- `)` gets stripped
+                    Some(GenericArgs::ParenthesizedElided(_)) => Pat::Str(".."),
+                    // `bar` in `std::foo::bar`
+                    None => ident_search_pat(last.ident).1,
+                }
+            } else {
+                // this shouldn't be possible, but sure
+                #[allow(
+                    clippy::collapsible_else_if,
+                    reason = "we want to keep these cases together, since they are both impossible"
+                )]
+                if qself_path.is_some() {
+                    // last `>` in `<Vec as IntoIterator>`
+                    Pat::Str(">")
+                } else {
+                    Pat::Str("")
+                }
+            };
+            (start, end)
+        },
         TyKind::Infer => (Pat::Str("_"), Pat::Str("_")),
         TyKind::TraitObject(_, tagged_ptr) if let TraitObjectSyntax::Dyn = tagged_ptr.tag() => {
             (Pat::Str("dyn"), Pat::Str(""))

From baf09e2fa2d6ea3a45b4b03ddbd10566c13f3c4b Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 6 Aug 2025 23:07:19 +0200
Subject: [PATCH 0209/1889] OpaqueDef is called ImplTrait

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

diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index d0a769e96b726..a57c7c60cdaed 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -446,7 +446,7 @@ fn ast_ty_search_pat(ty: &ast::Ty) -> (Pat, Pat) {
         TyKind::Tup([]) => (Pat::Str(")"), Pat::Str("(")),
         TyKind::Tup([ty]) => ast_ty_search_pat(ty),
         TyKind::Tup([head, .., tail]) => (ast_ty_search_pat(head).0, ast_ty_search_pat(tail).1),
-        TyKind::OpaqueDef(..) => (Pat::Str("impl"), Pat::Str("")),
+        TyKind::ImplTrait(..) => (Pat::Str("impl"), Pat::Str("")),
         TyKind::Path(qself_path, path) => {
             let start = if qself_path.is_some() {
                 Pat::Str("<")

From f5292331c3f6c631b0c5544f8c4401c50d032fb7 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 6 Aug 2025 23:09:26 +0200
Subject: [PATCH 0210/1889] fix Tup

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

diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index a57c7c60cdaed..c34d6c72f4ca5 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -443,9 +443,11 @@ fn ast_ty_search_pat(ty: &ast::Ty) -> (Pat, Pat) {
         TyKind::Never => (Pat::Str("!"), Pat::Str("!")),
         // Parenthesis are trimmed from the text before the search patterns are matched.
         // See: `span_matches_pat`
-        TyKind::Tup([]) => (Pat::Str(")"), Pat::Str("(")),
-        TyKind::Tup([ty]) => ast_ty_search_pat(ty),
-        TyKind::Tup([head, .., tail]) => (ast_ty_search_pat(head).0, ast_ty_search_pat(tail).1),
+        TyKind::Tup(tup) => match &**tup {
+            [] => (Pat::Str(")"), Pat::Str("(")),
+            [ty] => ast_ty_search_pat(ty),
+            [head, .., tail] => (ast_ty_search_pat(head).0, ast_ty_search_pat(tail).1),
+        },
         TyKind::ImplTrait(..) => (Pat::Str("impl"), Pat::Str("")),
         TyKind::Path(qself_path, path) => {
             let start = if qself_path.is_some() {

From c7b75880dc541b298918928a55e56aec2359f4a5 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 6 Aug 2025 23:09:38 +0200
Subject: [PATCH 0211/1889] fix TraitObject

---
 clippy_utils/src/check_proc_macro.rs | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index c34d6c72f4ca5..2de131f05c26f 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -415,7 +415,7 @@ fn ty_search_pat(ty: &Ty<'_>) -> (Pat, Pat) {
 }
 
 fn ast_ty_search_pat(ty: &ast::Ty) -> (Pat, Pat) {
-    use ast::{FnRetTy, MutTy, TyKind};
+    use ast::{FnRetTy, MutTy, TraitObjectSyntax, TyKind};
 
     match &ty.kind {
         TyKind::Slice(..) | TyKind::Array(..) => (Pat::Str("["), Pat::Str("]")),
@@ -496,10 +496,14 @@ fn ast_ty_search_pat(ty: &ast::Ty) -> (Pat, Pat) {
             (start, end)
         },
         TyKind::Infer => (Pat::Str("_"), Pat::Str("_")),
-        TyKind::TraitObject(_, tagged_ptr) if let TraitObjectSyntax::Dyn = tagged_ptr.tag() => {
-            (Pat::Str("dyn"), Pat::Str(""))
+        TyKind::TraitObject(_, trait_obj_syntax) => {
+            if let TraitObjectSyntax::Dyn = trait_obj_syntax {
+                (Pat::Str("dyn"), Pat::Str(""))
+            } else {
+                // NOTE: `TraitObject` is incomplete. It will always return true then.
+                (Pat::Str(""), Pat::Str(""))
+            }
         },
-        // NOTE: `TraitObject` is incomplete. It will always return true then.
         _ => (Pat::Str(""), Pat::Str("")),
     }
 }

From 742cba339a572a77809dd15bda0714e46b1e64ca Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Thu, 7 Aug 2025 00:21:06 +0200
Subject: [PATCH 0212/1889] fix FnPtr

---
 clippy_utils/src/check_proc_macro.rs | 24 +++++++++++++-----------
 1 file changed, 13 insertions(+), 11 deletions(-)

diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index 2de131f05c26f..00583d6766e04 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -29,7 +29,7 @@ use rustc_lint::{EarlyContext, LateContext, LintContext};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Session;
 use rustc_span::symbol::{Ident, kw};
-use rustc_span::{Span, Symbol};
+use rustc_span::{Span, Symbol, sym};
 
 /// The search pattern to look for. Used by `span_matches_pat`
 #[derive(Clone)]
@@ -415,29 +415,31 @@ fn ty_search_pat(ty: &Ty<'_>) -> (Pat, Pat) {
 }
 
 fn ast_ty_search_pat(ty: &ast::Ty) -> (Pat, Pat) {
-    use ast::{FnRetTy, MutTy, TraitObjectSyntax, TyKind};
+    use ast::{Extern, FnRetTy, MutTy, Safety, TraitObjectSyntax, TyKind};
 
     match &ty.kind {
         TyKind::Slice(..) | TyKind::Array(..) => (Pat::Str("["), Pat::Str("]")),
         TyKind::Ptr(MutTy { ty, .. }) => (Pat::Str("*"), ast_ty_search_pat(ty).1),
         TyKind::Ref(_, MutTy { ty, .. }) => (Pat::Str("&"), ast_ty_search_pat(ty).1),
         TyKind::FnPtr(fn_ptr) => (
-            if fn_ptr.safety.is_unsafe() {
+            if let Safety::Unsafe(_) = fn_ptr.safety {
                 Pat::Str("unsafe")
-            } else if fn_ptr.abi != ExternAbi::Rust {
-                Pat::Str("extern")
-            } else {
+            } else if let Extern::Explicit(strlit, _) = fn_ptr.ext
+                && strlit.symbol == sym::rust
+            {
                 Pat::MultiStr(&["fn", "extern"])
+            } else {
+                Pat::Str("extern")
             },
-            match fn_ptr.decl.output {
-                FnRetTy::DefaultReturn(_) => {
-                    if let [.., ty] = fn_ptr.decl.inputs {
-                        ast_ty_search_pat(ty).1
+            match &fn_ptr.decl.output {
+                FnRetTy::Default(_) => {
+                    if let [.., param] = &*fn_ptr.decl.inputs {
+                        ast_ty_search_pat(&param.ty).1
                     } else {
                         Pat::Str("(")
                     }
                 },
-                FnRetTy::Return(ty) => ast_ty_search_pat(ty).1,
+                FnRetTy::Ty(ty) => ast_ty_search_pat(ty).1,
             },
         ),
         TyKind::Never => (Pat::Str("!"), Pat::Str("!")),

From 41614fcc88d3e11d61f94172537b9c9840a2a970 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Thu, 7 Aug 2025 00:29:36 +0200
Subject: [PATCH 0213/1889] add Paren

---
 clippy_utils/src/check_proc_macro.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index 00583d6766e04..10f7fe6494365 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -498,6 +498,7 @@ fn ast_ty_search_pat(ty: &ast::Ty) -> (Pat, Pat) {
             (start, end)
         },
         TyKind::Infer => (Pat::Str("_"), Pat::Str("_")),
+        TyKind::Paren(ty) => ast_ty_search_pat(ty),
         TyKind::TraitObject(_, trait_obj_syntax) => {
             if let TraitObjectSyntax::Dyn = trait_obj_syntax {
                 (Pat::Str("dyn"), Pat::Str(""))

From 2bd9f98928e051dbb6e065c64410599de6e7f93c Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Thu, 7 Aug 2025 00:34:50 +0200
Subject: [PATCH 0214/1889] add UnsafeBinder

to the existing function as well
---
 clippy_utils/src/check_proc_macro.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index 10f7fe6494365..f82c643151e82 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -406,6 +406,7 @@ fn ty_search_pat(ty: &Ty<'_>) -> (Pat, Pat) {
         TyKind::OpaqueDef(..) => (Pat::Str("impl"), Pat::Str("")),
         TyKind::Path(qpath) => qpath_search_pat(&qpath),
         TyKind::Infer(()) => (Pat::Str("_"), Pat::Str("_")),
+        TyKind::UnsafeBinder(binder_ty) => (Pat::Str("unsafe"), ty_search_pat(binder_ty.inner_ty).1),
         TyKind::TraitObject(_, tagged_ptr) if let TraitObjectSyntax::Dyn = tagged_ptr.tag() => {
             (Pat::Str("dyn"), Pat::Str(""))
         },
@@ -499,6 +500,7 @@ fn ast_ty_search_pat(ty: &ast::Ty) -> (Pat, Pat) {
         },
         TyKind::Infer => (Pat::Str("_"), Pat::Str("_")),
         TyKind::Paren(ty) => ast_ty_search_pat(ty),
+        TyKind::UnsafeBinder(binder_ty) => (Pat::Str("unsafe"), ast_ty_search_pat(&binder_ty.inner_ty).1),
         TyKind::TraitObject(_, trait_obj_syntax) => {
             if let TraitObjectSyntax::Dyn = trait_obj_syntax {
                 (Pat::Str("dyn"), Pat::Str(""))

From 0512002f12f3321526237e9026fafd56c2c99a3a Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Mon, 11 Aug 2025 15:21:04 +0200
Subject: [PATCH 0215/1889] add PinnedRef

---
 clippy_utils/src/check_proc_macro.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index f82c643151e82..ac4164943b40c 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -421,7 +421,9 @@ fn ast_ty_search_pat(ty: &ast::Ty) -> (Pat, Pat) {
     match &ty.kind {
         TyKind::Slice(..) | TyKind::Array(..) => (Pat::Str("["), Pat::Str("]")),
         TyKind::Ptr(MutTy { ty, .. }) => (Pat::Str("*"), ast_ty_search_pat(ty).1),
-        TyKind::Ref(_, MutTy { ty, .. }) => (Pat::Str("&"), ast_ty_search_pat(ty).1),
+        TyKind::Ref(_, MutTy { ty, .. }) | TyKind::PinnedRef(_, MutTy { ty, .. }) => {
+            (Pat::Str("&"), ast_ty_search_pat(ty).1)
+        },
         TyKind::FnPtr(fn_ptr) => (
             if let Safety::Unsafe(_) = fn_ptr.safety {
                 Pat::Str("unsafe")

From bbd0d46e1995354517f15baafccc84269e9f5476 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Mon, 11 Aug 2025 15:35:09 +0200
Subject: [PATCH 0216/1889] add MacCall

---
 clippy_utils/src/check_proc_macro.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index ac4164943b40c..d4335689c1ea1 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -511,6 +511,14 @@ fn ast_ty_search_pat(ty: &ast::Ty) -> (Pat, Pat) {
                 (Pat::Str(""), Pat::Str(""))
             }
         },
+        TyKind::MacCall(mac_call) => {
+            let start = if let Some(first) = mac_call.path.segments.first() {
+                ident_search_pat(first.ident).0
+            } else {
+                Pat::Str("")
+            };
+            (start, Pat::Str(""))
+        },
         _ => (Pat::Str(""), Pat::Str("")),
     }
 }

From 17c0cabf988a0a68808b5e78d9c3bd0c2ed3d1cb Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Tue, 12 Aug 2025 15:54:39 +0200
Subject: [PATCH 0217/1889] add ImplicitSelf

---
 clippy_utils/src/check_proc_macro.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index d4335689c1ea1..2f1d380be5669 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -519,7 +519,9 @@ fn ast_ty_search_pat(ty: &ast::Ty) -> (Pat, Pat) {
             };
             (start, Pat::Str(""))
         },
-        _ => (Pat::Str(""), Pat::Str("")),
+
+        // implicit, so has no contents to match against
+        TyKind::ImplicitSelf | _ => (Pat::Str(""), Pat::Str("")),
     }
 }
 

From 457e0208dfbe916ed441586943195c294cd14162 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Tue, 12 Aug 2025 15:55:20 +0200
Subject: [PATCH 0218/1889] add misc kinds: Pat, CVarArgs, Typeof, Dummy, Err

---
 clippy_utils/src/check_proc_macro.rs | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index 2f1d380be5669..649460dd87506 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -521,7 +521,18 @@ fn ast_ty_search_pat(ty: &ast::Ty) -> (Pat, Pat) {
         },
 
         // implicit, so has no contents to match against
-        TyKind::ImplicitSelf | _ => (Pat::Str(""), Pat::Str("")),
+        TyKind::ImplicitSelf
+
+        // experimental
+        |TyKind::Pat(..)
+
+        // unused
+        | TyKind::CVarArgs
+        | TyKind::Typeof(_)
+
+        // placeholder
+        | TyKind::Dummy
+        | TyKind::Err(_) => (Pat::Str(""), Pat::Str("")),
     }
 }
 

From 217fc30fb65bdbdc46f17ab1eee9bbd6d9286d21 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Mon, 11 Aug 2025 16:04:45 +0200
Subject: [PATCH 0219/1889] (finally) implement `WithSearchPat`

---
 clippy_utils/src/check_proc_macro.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index 649460dd87506..47f9d0591e929 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -570,6 +570,7 @@ impl_with_search_pat!((_cx: LateContext<'tcx>, self: Lit) => lit_search_pat(&sel
 impl_with_search_pat!((_cx: LateContext<'tcx>, self: Path<'_>) => path_search_pat(self));
 
 impl_with_search_pat!((_cx: EarlyContext<'tcx>, self: Attribute) => attr_search_pat(self));
+impl_with_search_pat!((_cx: EarlyContext<'tcx>, self: ast::Ty) => ast_ty_search_pat(self));
 
 impl<'cx> WithSearchPat<'cx> for (&FnKind<'cx>, &Body<'cx>, HirId, Span) {
     type Context = LateContext<'cx>;

From 2459ad66a48d2d693f4f30a599c28bfc36603333 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Thu, 7 Aug 2025 00:38:50 +0200
Subject: [PATCH 0220/1889] make the lint early-pass

---
 clippy_lints/src/let_with_type_underscore.rs | 16 ++++++++--------
 clippy_lints/src/lib.rs                      |  2 +-
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/clippy_lints/src/let_with_type_underscore.rs b/clippy_lints/src/let_with_type_underscore.rs
index 5b0f95ffc377f..24a4c321bdabd 100644
--- a/clippy_lints/src/let_with_type_underscore.rs
+++ b/clippy_lints/src/let_with_type_underscore.rs
@@ -1,9 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_from_proc_macro;
 use clippy_utils::source::{IntoSpan, SpanRangeExt};
+use rustc_ast::{Local, TyKind};
 use rustc_errors::Applicability;
-use rustc_hir::{LetStmt, TyKind};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
@@ -26,14 +26,14 @@ declare_clippy_lint! {
 }
 declare_lint_pass!(UnderscoreTyped => [LET_WITH_TYPE_UNDERSCORE]);
 
-impl<'tcx> LateLintPass<'tcx> for UnderscoreTyped {
-    fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx LetStmt<'_>) {
-        if let Some(ty) = local.ty // Ensure that it has a type defined
-            && let TyKind::Infer(()) = &ty.kind // that type is '_'
+impl EarlyLintPass for UnderscoreTyped {
+    fn check_local(&mut self, cx: &EarlyContext<'_>, local: &Local) {
+        if let Some(ty) = &local.ty // Ensure that it has a type defined
+            && let TyKind::Infer = ty.kind // that type is '_'
             && local.span.eq_ctxt(ty.span)
-            && let sm = cx.tcx.sess.source_map()
+            && let sm = cx.sess().source_map()
             && !local.span.in_external_macro(sm)
-            && !is_from_proc_macro(cx, ty)
+            && !is_from_proc_macro(cx, &**ty)
         {
             let span_to_remove = sm
                 .span_extend_to_prev_char_before(ty.span, ':', true)
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d468993e74445..10f0faa44088d 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -743,7 +743,7 @@ pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Co
     store.register_late_pass(|_| Box::new(missing_assert_message::MissingAssertMessage));
     store.register_late_pass(|_| Box::new(needless_maybe_sized::NeedlessMaybeSized));
     store.register_late_pass(|_| Box::new(redundant_async_block::RedundantAsyncBlock));
-    store.register_late_pass(|_| Box::new(let_with_type_underscore::UnderscoreTyped));
+    store.register_early_pass(|| Box::new(let_with_type_underscore::UnderscoreTyped));
     store.register_late_pass(move |_| Box::new(manual_main_separator_str::ManualMainSeparatorStr::new(conf)));
     store.register_late_pass(|_| Box::new(unnecessary_struct_initialization::UnnecessaryStruct));
     store.register_late_pass(move |_| Box::new(unnecessary_box_returns::UnnecessaryBoxReturns::new(conf)));

From ebbea345726e04cd26b69b8334169ba0571b2d34 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sun, 10 Aug 2025 14:09:49 +0200
Subject: [PATCH 0221/1889] `is_expr_identity_of_pat`: simplify using
 `(unordered_)over`

---
 clippy_utils/src/ast_utils/mod.rs |  2 +-
 clippy_utils/src/hir_utils.rs     |  2 +-
 clippy_utils/src/lib.rs           | 11 +++++------
 3 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/clippy_utils/src/ast_utils/mod.rs b/clippy_utils/src/ast_utils/mod.rs
index 40c00568a3bde..ad69e6eb184e1 100644
--- a/clippy_utils/src/ast_utils/mod.rs
+++ b/clippy_utils/src/ast_utils/mod.rs
@@ -21,7 +21,7 @@ pub fn is_useless_with_eq_exprs(kind: BinOpKind) -> bool {
 }
 
 /// Checks if each element in the first slice is contained within the latter as per `eq_fn`.
-pub fn unordered_over<X>(left: &[X], right: &[X], mut eq_fn: impl FnMut(&X, &X) -> bool) -> bool {
+pub fn unordered_over<X, Y>(left: &[X], right: &[Y], mut eq_fn: impl FnMut(&X, &Y) -> bool) -> bool {
     left.len() == right.len() && left.iter().all(|l| right.iter().any(|r| eq_fn(l, r)))
 }
 
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index 8160443f4132f..b79e15cd7170b 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -757,7 +757,7 @@ pub fn both_some_and<X, Y>(l: Option<X>, r: Option<Y>, mut pred: impl FnMut(X, Y
 }
 
 /// Checks if two slices are equal as per `eq_fn`.
-pub fn over<X>(left: &[X], right: &[X], mut eq_fn: impl FnMut(&X, &X) -> bool) -> bool {
+pub fn over<X, Y>(left: &[X], right: &[Y], mut eq_fn: impl FnMut(&X, &Y) -> bool) -> bool {
     left.len() == right.len() && left.iter().zip(right).all(|(x, y)| eq_fn(x, y))
 }
 
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 8533fa8554199..1e0833001cf71 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -126,6 +126,7 @@ use rustc_span::{InnerSpan, Span};
 use source::{SpanRangeExt, walk_span_to_context};
 use visitors::{Visitable, for_each_unconsumed_temporary};
 
+use crate::ast_utils::unordered_over;
 use crate::consts::{ConstEvalCtxt, Constant, mir_to_const};
 use crate::higher::Range;
 use crate::ty::{adt_and_variant_of_res, can_partially_move_ty, expr_sig, is_copy, is_recursively_primitive_type};
@@ -1992,7 +1993,7 @@ pub fn is_expr_identity_of_pat(cx: &LateContext<'_>, pat: &Pat<'_>, expr: &Expr<
         (PatKind::Tuple(pats, dotdot), ExprKind::Tup(tup))
             if dotdot.as_opt_usize().is_none() && pats.len() == tup.len() =>
         {
-            zip(pats, tup).all(|(pat, expr)| is_expr_identity_of_pat(cx, pat, expr, by_hir))
+            over(pats, tup, |pat, expr| is_expr_identity_of_pat(cx, pat, expr, by_hir))
         },
         (PatKind::Slice(before, None, after), ExprKind::Array(arr)) if before.len() + after.len() == arr.len() => {
             zip(before.iter().chain(after), arr).all(|(pat, expr)| is_expr_identity_of_pat(cx, pat, expr, by_hir))
@@ -2004,7 +2005,7 @@ pub fn is_expr_identity_of_pat(cx: &LateContext<'_>, pat: &Pat<'_>, expr: &Expr<
             if let ExprKind::Path(ident) = &ident.kind
                 && qpath_res(&pat_ident, pat.hir_id) == qpath_res(ident, expr.hir_id)
                 // check fields
-                && zip(field_pats, fields).all(|(pat, expr)| is_expr_identity_of_pat(cx, pat, expr,by_hir))
+                && over(field_pats, fields, |pat, expr| is_expr_identity_of_pat(cx, pat, expr,by_hir))
             {
                 true
             } else {
@@ -2017,10 +2018,8 @@ pub fn is_expr_identity_of_pat(cx: &LateContext<'_>, pat: &Pat<'_>, expr: &Expr<
             // check ident
             qpath_res(&pat_ident, pat.hir_id) == qpath_res(ident, expr.hir_id)
                 // check fields
-                && field_pats.iter().all(|field_pat| {
-                    fields.iter().any(|field| {
-                        field_pat.ident == field.ident && is_expr_identity_of_pat(cx, field_pat.pat, field.expr, by_hir)
-                    })
+                && unordered_over(field_pats, fields, |field_pat, field| {
+                    field_pat.ident == field.ident && is_expr_identity_of_pat(cx, field_pat.pat, field.expr, by_hir)
                 })
         },
         _ => false,

From 0d479c19e875918a6c5248f031fa50cf0997af85 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Fri, 25 Jul 2025 08:50:20 +0200
Subject: [PATCH 0222/1889] fix: `unnested_or_patterns` FP on structs with only
 shorthand field pats

---
 clippy_lints/src/unnested_or_patterns.rs |  6 ++-
 tests/ui/unnested_or_patterns.fixed      | 25 +++++++++--
 tests/ui/unnested_or_patterns.rs         | 25 +++++++++--
 tests/ui/unnested_or_patterns.stderr     | 54 +++++++++++++++---------
 4 files changed, 80 insertions(+), 30 deletions(-)

diff --git a/clippy_lints/src/unnested_or_patterns.rs b/clippy_lints/src/unnested_or_patterns.rs
index 8b278d98a30e0..f3410c98973f5 100644
--- a/clippy_lints/src/unnested_or_patterns.rs
+++ b/clippy_lints/src/unnested_or_patterns.rs
@@ -326,7 +326,11 @@ fn extend_with_struct_pat(
                     if idx_1 == idx {
                         // In the case of `k`, we merely require identical field names
                         // so that we will transform into `ident_k: p1_k | p2_k`.
-                        let pos = fps2.iter().position(|fp2| eq_id(fp1.ident, fp2.ident));
+                        let pos = fps2.iter().position(|fp2| {
+                            // Avoid `Foo { bar } | Foo { bar }` => `Foo { bar | bar }`
+                            !(fp1.is_shorthand && fp2.is_shorthand)
+                                && eq_id(fp1.ident, fp2.ident)
+                        });
                         pos_in_2.set(pos);
                         pos.is_some()
                     } else {
diff --git a/tests/ui/unnested_or_patterns.fixed b/tests/ui/unnested_or_patterns.fixed
index 2081772d06b36..339d4a95084ae 100644
--- a/tests/ui/unnested_or_patterns.fixed
+++ b/tests/ui/unnested_or_patterns.fixed
@@ -9,6 +9,11 @@
 )]
 #![allow(unreachable_patterns, irrefutable_let_patterns, unused)]
 
+struct S {
+    x: u8,
+    y: u8,
+}
+
 fn main() {
     // Should be ignored by this lint, as nesting requires more characters.
     if let &0 | &2 = &0 {}
@@ -45,10 +50,6 @@ fn main() {
     //~^ unnested_or_patterns
     if let TS(x, ..) | TS(x, 1 | 2) = TS(0, 0) {}
     //~^ unnested_or_patterns
-    struct S {
-        x: u8,
-        y: u8,
-    }
     if let S { x: 0 | 1, y } = (S { x: 0, y: 1 }) {}
     //~^ unnested_or_patterns
     if let S { x: 0, y, .. } | S { y, x: 1 } = (S { x: 0, y: 1 }) {}
@@ -77,3 +78,19 @@ mod issue9952 {
     fn or_in_param((x | x | x): i32) {}
     //~^ unnested_or_patterns
 }
+
+fn issue15219() {
+    struct Foo {
+        x: u8,
+    }
+
+    // the original repro
+    if let Foo { x } | Foo { x } = (Foo { x: 0 }) {}
+
+    // also works with more fields
+    if let S { x, y } | S { x, y } = (S { x: 0, y: 0 }) {}
+
+    // `y` not triggering the lint doesn't stop the `x` from getting flagged
+    if let S { y, x: 0 | 1 } = (S { x: 0, y: 1 }) {}
+    //~^ unnested_or_patterns
+}
diff --git a/tests/ui/unnested_or_patterns.rs b/tests/ui/unnested_or_patterns.rs
index 6bf8fce36616c..f5c99183b0c51 100644
--- a/tests/ui/unnested_or_patterns.rs
+++ b/tests/ui/unnested_or_patterns.rs
@@ -9,6 +9,11 @@
 )]
 #![allow(unreachable_patterns, irrefutable_let_patterns, unused)]
 
+struct S {
+    x: u8,
+    y: u8,
+}
+
 fn main() {
     // Should be ignored by this lint, as nesting requires more characters.
     if let &0 | &2 = &0 {}
@@ -45,10 +50,6 @@ fn main() {
     //~^ unnested_or_patterns
     if let TS(x, ..) | TS(x, 1) | TS(x, 2) = TS(0, 0) {}
     //~^ unnested_or_patterns
-    struct S {
-        x: u8,
-        y: u8,
-    }
     if let S { x: 0, y } | S { y, x: 1 } = (S { x: 0, y: 1 }) {}
     //~^ unnested_or_patterns
     if let S { x: 0, y, .. } | S { y, x: 1 } = (S { x: 0, y: 1 }) {}
@@ -77,3 +78,19 @@ mod issue9952 {
     fn or_in_param((x | (x | x)): i32) {}
     //~^ unnested_or_patterns
 }
+
+fn issue15219() {
+    struct Foo {
+        x: u8,
+    }
+
+    // the original repro
+    if let Foo { x } | Foo { x } = (Foo { x: 0 }) {}
+
+    // also works with more fields
+    if let S { x, y } | S { x, y } = (S { x: 0, y: 0 }) {}
+
+    // `y` not triggering the lint doesn't stop the `x` from getting flagged
+    if let S { y, x: 0 } | S { y, x: 1 } = (S { x: 0, y: 1 }) {}
+    //~^ unnested_or_patterns
+}
diff --git a/tests/ui/unnested_or_patterns.stderr b/tests/ui/unnested_or_patterns.stderr
index c805dc992b1c2..d2b617c322c46 100644
--- a/tests/ui/unnested_or_patterns.stderr
+++ b/tests/ui/unnested_or_patterns.stderr
@@ -1,5 +1,5 @@
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:16:12
+  --> tests/ui/unnested_or_patterns.rs:21:12
    |
 LL |     if let box 0 | box 2 = Box::new(0) {}
    |            ^^^^^^^^^^^^^
@@ -13,7 +13,7 @@ LL +     if let box (0 | 2) = Box::new(0) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:18:12
+  --> tests/ui/unnested_or_patterns.rs:23:12
    |
 LL |     if let box ((0 | 1)) | box (2 | 3) | box 4 = Box::new(0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     if let box (0 | 1 | 2 | 3 | 4) = Box::new(0) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:21:12
+  --> tests/ui/unnested_or_patterns.rs:26:12
    |
 LL |     if let Some(1) | C0 | Some(2) = None {}
    |            ^^^^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     if let Some(1 | 2) | C0 = None {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:23:12
+  --> tests/ui/unnested_or_patterns.rs:28:12
    |
 LL |     if let &mut 0 | &mut 2 = &mut 0 {}
    |            ^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +     if let &mut (0 | 2) = &mut 0 {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:25:12
+  --> tests/ui/unnested_or_patterns.rs:30:12
    |
 LL |     if let x @ 0 | x @ 2 = 0 {}
    |            ^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL +     if let x @ (0 | 2) = 0 {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:27:12
+  --> tests/ui/unnested_or_patterns.rs:32:12
    |
 LL |     if let (0, 1) | (0, 2) | (0, 3) = (0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL +     if let (0, 1 | 2 | 3) = (0, 0) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:29:12
+  --> tests/ui/unnested_or_patterns.rs:34:12
    |
 LL |     if let (1, 0) | (2, 0) | (3, 0) = (0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL +     if let (1 | 2 | 3, 0) = (0, 0) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:31:12
+  --> tests/ui/unnested_or_patterns.rs:36:12
    |
 LL |     if let (x, ..) | (x, 1) | (x, 2) = (0, 1) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL +     if let (x, ..) | (x, 1 | 2) = (0, 1) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:33:12
+  --> tests/ui/unnested_or_patterns.rs:38:12
    |
 LL |     if let [0] | [1] = [0] {}
    |            ^^^^^^^^^
@@ -109,7 +109,7 @@ LL +     if let [0 | 1] = [0] {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:35:12
+  --> tests/ui/unnested_or_patterns.rs:40:12
    |
 LL |     if let [x, 0] | [x, 1] = [0, 1] {}
    |            ^^^^^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL +     if let [x, 0 | 1] = [0, 1] {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:37:12
+  --> tests/ui/unnested_or_patterns.rs:42:12
    |
 LL |     if let [x, 0] | [x, 1] | [x, 2] = [0, 1] {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -133,7 +133,7 @@ LL +     if let [x, 0 | 1 | 2] = [0, 1] {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:39:12
+  --> tests/ui/unnested_or_patterns.rs:44:12
    |
 LL |     if let [x, ..] | [x, 1] | [x, 2] = [0, 1] {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -145,7 +145,7 @@ LL +     if let [x, ..] | [x, 1 | 2] = [0, 1] {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:42:12
+  --> tests/ui/unnested_or_patterns.rs:47:12
    |
 LL |     if let TS(0, x) | TS(1, x) = TS(0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^
@@ -157,7 +157,7 @@ LL +     if let TS(0 | 1, x) = TS(0, 0) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:44:12
+  --> tests/ui/unnested_or_patterns.rs:49:12
    |
 LL |     if let TS(1, 0) | TS(2, 0) | TS(3, 0) = TS(0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -169,7 +169,7 @@ LL +     if let TS(1 | 2 | 3, 0) = TS(0, 0) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:46:12
+  --> tests/ui/unnested_or_patterns.rs:51:12
    |
 LL |     if let TS(x, ..) | TS(x, 1) | TS(x, 2) = TS(0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -181,7 +181,7 @@ LL +     if let TS(x, ..) | TS(x, 1 | 2) = TS(0, 0) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:52:12
+  --> tests/ui/unnested_or_patterns.rs:53:12
    |
 LL |     if let S { x: 0, y } | S { y, x: 1 } = (S { x: 0, y: 1 }) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -193,7 +193,7 @@ LL +     if let S { x: 0 | 1, y } = (S { x: 0, y: 1 }) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:64:12
+  --> tests/ui/unnested_or_patterns.rs:65:12
    |
 LL |     if let [1] | [53] = [0] {}
    |            ^^^^^^^^^^
@@ -205,7 +205,7 @@ LL +     if let [1 | 53] = [0] {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:70:13
+  --> tests/ui/unnested_or_patterns.rs:71:13
    |
 LL |         let (0 | (1 | _)) = 0;
    |             ^^^^^^^^^^^^^
@@ -217,7 +217,7 @@ LL +         let (0 | 1 | _) = 0;
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:73:16
+  --> tests/ui/unnested_or_patterns.rs:74:16
    |
 LL |         if let (0 | (1 | _)) = 0 {}
    |                ^^^^^^^^^^^^^
@@ -229,7 +229,7 @@ LL +         if let (0 | 1 | _) = 0 {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:77:20
+  --> tests/ui/unnested_or_patterns.rs:78:20
    |
 LL |     fn or_in_param((x | (x | x)): i32) {}
    |                    ^^^^^^^^^^^^^
@@ -240,5 +240,17 @@ LL -     fn or_in_param((x | (x | x)): i32) {}
 LL +     fn or_in_param((x | x | x): i32) {}
    |
 
-error: aborting due to 20 previous errors
+error: unnested or-patterns
+  --> tests/ui/unnested_or_patterns.rs:94:12
+   |
+LL |     if let S { y, x: 0 } | S { y, x: 1 } = (S { x: 0, y: 1 }) {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: nest the patterns
+   |
+LL -     if let S { y, x: 0 } | S { y, x: 1 } = (S { x: 0, y: 1 }) {}
+LL +     if let S { y, x: 0 | 1 } = (S { x: 0, y: 1 }) {}
+   |
+
+error: aborting due to 21 previous errors
 

From 86beeccb6519032d1bc067a05f87d797162d137d Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Wed, 16 Jul 2025 15:37:55 +0200
Subject: [PATCH 0223/1889] Better check for `assign_op_pattern` in `const`
 context

`assign_op_pattern` can be used in a `const` context if the
trait definition as well as the implementation of the corresponding
`Assign` pattern is `const` as well.
---
 .../src/operators/assign_op_pattern.rs        | 27 ++++++++--
 tests/ui/assign_ops.fixed                     | 39 +++++++++++++--
 tests/ui/assign_ops.rs                        | 41 +++++++++++++--
 tests/ui/assign_ops.stderr                    | 50 ++++++++++++++-----
 4 files changed, 133 insertions(+), 24 deletions(-)

diff --git a/clippy_lints/src/operators/assign_op_pattern.rs b/clippy_lints/src/operators/assign_op_pattern.rs
index 7317c62df7fe8..2d303e40bd1c8 100644
--- a/clippy_lints/src/operators/assign_op_pattern.rs
+++ b/clippy_lints/src/operators/assign_op_pattern.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::msrvs::Msrv;
+use clippy_utils::qualify_min_const_fn::is_stable_const_fn;
 use clippy_utils::source::SpanRangeExt;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::visitors::for_each_expr_without_closures;
@@ -20,7 +21,7 @@ pub(super) fn check<'tcx>(
     expr: &'tcx hir::Expr<'_>,
     assignee: &'tcx hir::Expr<'_>,
     e: &'tcx hir::Expr<'_>,
-    _msrv: Msrv,
+    msrv: Msrv,
 ) {
     if let hir::ExprKind::Binary(op, l, r) = &e.kind {
         let lint = |assignee: &hir::Expr<'_>, rhs: &hir::Expr<'_>| {
@@ -43,10 +44,28 @@ pub(super) fn check<'tcx>(
                     }
                 }
 
-                // Skip if the trait is not stable in const contexts
-                // FIXME: reintroduce a better check after this is merged back into Clippy
+                // Skip if the trait or the implementation is not stable in const contexts
                 if is_in_const_context(cx) {
-                    return;
+                    if cx
+                        .tcx
+                        .associated_item_def_ids(trait_id)
+                        .first()
+                        .is_none_or(|binop_id| !is_stable_const_fn(cx, *binop_id, msrv))
+                    {
+                        return;
+                    }
+
+                    let impls = cx.tcx.non_blanket_impls_for_ty(trait_id, rty).collect::<Vec<_>>();
+                    if impls.is_empty()
+                        || impls.into_iter().any(|impl_id| {
+                            cx.tcx
+                                .associated_item_def_ids(impl_id)
+                                .first()
+                                .is_none_or(|fn_id| !is_stable_const_fn(cx, *fn_id, msrv))
+                        })
+                    {
+                        return;
+                    }
                 }
 
                 span_lint_and_then(
diff --git a/tests/ui/assign_ops.fixed b/tests/ui/assign_ops.fixed
index 3754b9dfe7443..2046d089d6a6c 100644
--- a/tests/ui/assign_ops.fixed
+++ b/tests/ui/assign_ops.fixed
@@ -1,8 +1,9 @@
 #![allow(clippy::useless_vec)]
 #![warn(clippy::assign_op_pattern)]
-#![feature(const_trait_impl, const_ops)]
+#![feature(const_ops)]
+#![feature(const_trait_impl)]
 
-use core::num::Wrapping;
+use std::num::Wrapping;
 use std::ops::{Mul, MulAssign};
 
 fn main() {
@@ -82,6 +83,18 @@ mod issue14871 {
     pub trait Number: Copy + Add<Self, Output = Self> + AddAssign {
         const ZERO: Self;
         const ONE: Self;
+
+        fn non_constant(value: usize) -> Self {
+            let mut res = Self::ZERO;
+            let mut count = 0;
+            while count < value {
+                res += Self::ONE;
+                //~^ assign_op_pattern
+                count += 1;
+                //~^ assign_op_pattern
+            }
+            res
+        }
     }
 
     #[rustfmt::skip] // rustfmt doesn't understand the order of pub const on traits (yet)
@@ -91,7 +104,7 @@ mod issue14871 {
 
     impl<T> const NumberConstants for T
     where
-        T: Number + [const] core::ops::Add,
+        T: Number + [const] std::ops::Add,
     {
         fn constant(value: usize) -> Self {
             let mut res = Self::ZERO;
@@ -99,8 +112,28 @@ mod issue14871 {
             while count < value {
                 res = res + Self::ONE;
                 count += 1;
+                //~^ assign_op_pattern
             }
             res
         }
     }
+
+    pub struct S;
+
+    impl const std::ops::Add for S {
+        type Output = S;
+        fn add(self, _rhs: S) -> S {
+            S
+        }
+    }
+
+    impl const std::ops::AddAssign for S {
+        fn add_assign(&mut self, rhs: S) {}
+    }
+
+    const fn do_add() {
+        let mut s = S;
+        s += S;
+        //~^ assign_op_pattern
+    }
 }
diff --git a/tests/ui/assign_ops.rs b/tests/ui/assign_ops.rs
index 0b878d4f490b8..f83a40f554730 100644
--- a/tests/ui/assign_ops.rs
+++ b/tests/ui/assign_ops.rs
@@ -1,8 +1,9 @@
 #![allow(clippy::useless_vec)]
 #![warn(clippy::assign_op_pattern)]
-#![feature(const_trait_impl, const_ops)]
+#![feature(const_ops)]
+#![feature(const_trait_impl)]
 
-use core::num::Wrapping;
+use std::num::Wrapping;
 use std::ops::{Mul, MulAssign};
 
 fn main() {
@@ -82,6 +83,18 @@ mod issue14871 {
     pub trait Number: Copy + Add<Self, Output = Self> + AddAssign {
         const ZERO: Self;
         const ONE: Self;
+
+        fn non_constant(value: usize) -> Self {
+            let mut res = Self::ZERO;
+            let mut count = 0;
+            while count < value {
+                res = res + Self::ONE;
+                //~^ assign_op_pattern
+                count = count + 1;
+                //~^ assign_op_pattern
+            }
+            res
+        }
     }
 
     #[rustfmt::skip] // rustfmt doesn't understand the order of pub const on traits (yet)
@@ -91,16 +104,36 @@ mod issue14871 {
 
     impl<T> const NumberConstants for T
     where
-        T: Number + [const] core::ops::Add,
+        T: Number + [const] std::ops::Add,
     {
         fn constant(value: usize) -> Self {
             let mut res = Self::ZERO;
             let mut count = 0;
             while count < value {
                 res = res + Self::ONE;
-                count += 1;
+                count = count + 1;
+                //~^ assign_op_pattern
             }
             res
         }
     }
+
+    pub struct S;
+
+    impl const std::ops::Add for S {
+        type Output = S;
+        fn add(self, _rhs: S) -> S {
+            S
+        }
+    }
+
+    impl const std::ops::AddAssign for S {
+        fn add_assign(&mut self, rhs: S) {}
+    }
+
+    const fn do_add() {
+        let mut s = S;
+        s = s + S;
+        //~^ assign_op_pattern
+    }
 }
diff --git a/tests/ui/assign_ops.stderr b/tests/ui/assign_ops.stderr
index c5e698b3ee118..a4fca04893c46 100644
--- a/tests/ui/assign_ops.stderr
+++ b/tests/ui/assign_ops.stderr
@@ -1,5 +1,5 @@
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:10:5
+  --> tests/ui/assign_ops.rs:11:5
    |
 LL |     a = a + 1;
    |     ^^^^^^^^^ help: replace it with: `a += 1`
@@ -8,70 +8,94 @@ LL |     a = a + 1;
    = help: to override `-D warnings` add `#[allow(clippy::assign_op_pattern)]`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:12:5
+  --> tests/ui/assign_ops.rs:13:5
    |
 LL |     a = 1 + a;
    |     ^^^^^^^^^ help: replace it with: `a += 1`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:14:5
+  --> tests/ui/assign_ops.rs:15:5
    |
 LL |     a = a - 1;
    |     ^^^^^^^^^ help: replace it with: `a -= 1`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:16:5
+  --> tests/ui/assign_ops.rs:17:5
    |
 LL |     a = a * 99;
    |     ^^^^^^^^^^ help: replace it with: `a *= 99`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:18:5
+  --> tests/ui/assign_ops.rs:19:5
    |
 LL |     a = 42 * a;
    |     ^^^^^^^^^^ help: replace it with: `a *= 42`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:20:5
+  --> tests/ui/assign_ops.rs:21:5
    |
 LL |     a = a / 2;
    |     ^^^^^^^^^ help: replace it with: `a /= 2`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:22:5
+  --> tests/ui/assign_ops.rs:23:5
    |
 LL |     a = a % 5;
    |     ^^^^^^^^^ help: replace it with: `a %= 5`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:24:5
+  --> tests/ui/assign_ops.rs:25:5
    |
 LL |     a = a & 1;
    |     ^^^^^^^^^ help: replace it with: `a &= 1`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:31:5
+  --> tests/ui/assign_ops.rs:32:5
    |
 LL |     s = s + "bla";
    |     ^^^^^^^^^^^^^ help: replace it with: `s += "bla"`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:36:5
+  --> tests/ui/assign_ops.rs:37:5
    |
 LL |     a = a + Wrapping(1u32);
    |     ^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `a += Wrapping(1u32)`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:39:5
+  --> tests/ui/assign_ops.rs:40:5
    |
 LL |     v[0] = v[0] + v[1];
    |     ^^^^^^^^^^^^^^^^^^ help: replace it with: `v[0] += v[1]`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:52:5
+  --> tests/ui/assign_ops.rs:53:5
    |
 LL |     buf = buf + cows.clone();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `buf += cows.clone()`
 
-error: aborting due to 12 previous errors
+error: manual implementation of an assign operation
+  --> tests/ui/assign_ops.rs:91:17
+   |
+LL |                 res = res + Self::ONE;
+   |                 ^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `res += Self::ONE`
+
+error: manual implementation of an assign operation
+  --> tests/ui/assign_ops.rs:93:17
+   |
+LL |                 count = count + 1;
+   |                 ^^^^^^^^^^^^^^^^^ help: replace it with: `count += 1`
+
+error: manual implementation of an assign operation
+  --> tests/ui/assign_ops.rs:114:17
+   |
+LL |                 count = count + 1;
+   |                 ^^^^^^^^^^^^^^^^^ help: replace it with: `count += 1`
+
+error: manual implementation of an assign operation
+  --> tests/ui/assign_ops.rs:136:9
+   |
+LL |         s = s + S;
+   |         ^^^^^^^^^ help: replace it with: `s += S`
+
+error: aborting due to 16 previous errors
 

From c9fbcdcfcdc5290639c2a76929bec1ed07c08f8e Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Fri, 22 Aug 2025 21:58:49 +0800
Subject: [PATCH 0224/1889] Add let in let-chain completion support

Example
---
```rust
fn f() {
    if true && $0 {}
}
```
->
```rust
fn f() {
    if true && let $1 = $0 {}
}
```
---
 .../crates/ide-completion/src/context/analysis.rs      | 10 +++++++---
 .../crates/ide-completion/src/tests/expression.rs      | 10 ++++++++++
 2 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
index 6eb1727b3319e..7d6fa553001cd 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
@@ -1171,19 +1171,23 @@ fn classify_name_ref<'db>(
         Some(res)
     };
 
-    let is_in_condition = |it: &ast::Expr| {
+    fn is_in_condition(it: &ast::Expr) -> bool {
         (|| {
             let parent = it.syntax().parent()?;
             if let Some(expr) = ast::WhileExpr::cast(parent.clone()) {
                 Some(expr.condition()? == *it)
-            } else if let Some(expr) = ast::IfExpr::cast(parent) {
+            } else if let Some(expr) = ast::IfExpr::cast(parent.clone()) {
                 Some(expr.condition()? == *it)
+            } else if let Some(expr) = ast::BinExpr::cast(parent)
+                && expr.op_token()?.kind() == T![&&]
+            {
+                Some(is_in_condition(&expr.into()))
             } else {
                 None
             }
         })()
         .unwrap_or(false)
-    };
+    }
 
     let make_path_kind_expr = |expr: ast::Expr| {
         let it = expr.syntax();
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs b/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
index 33f729f016645..07eaeea97e553 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
@@ -2275,3 +2275,13 @@ fn foo() {
         "#]],
     );
 }
+
+#[test]
+fn let_in_condition() {
+    check_edit("let", r#"fn f() { if $0 {} }"#, r#"fn f() { if let $1 = $0 {} }"#);
+}
+
+#[test]
+fn let_in_let_chain() {
+    check_edit("let", r#"fn f() { if true && $0 {} }"#, r#"fn f() { if true && let $1 = $0 {} }"#);
+}

From 2143a3f0c21554ad70e8c72199869afadc2c0e93 Mon Sep 17 00:00:00 2001
From: "Pascal S. de Kloe" <pascal@quies.net>
Date: Fri, 22 Aug 2025 17:40:48 +0200
Subject: [PATCH 0225/1889] benchmarks for exponent fmt of integers

---
 library/coretests/benches/fmt.rs | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/library/coretests/benches/fmt.rs b/library/coretests/benches/fmt.rs
index f45b921b93933..17549ab0f1c2a 100644
--- a/library/coretests/benches/fmt.rs
+++ b/library/coretests/benches/fmt.rs
@@ -342,3 +342,27 @@ fn write_i128_hex(bh: &mut Bencher) {
         black_box(&mut buf).clear();
     });
 }
+
+#[bench]
+fn write_i64_exp(bh: &mut Bencher) {
+    let mut buf = String::with_capacity(1024);
+    bh.iter(|| {
+        write!(black_box(&mut buf), "{:e}", black_box(0_i64)).unwrap();
+        write!(black_box(&mut buf), "{:e}", black_box(100_i64)).unwrap();
+        write!(black_box(&mut buf), "{:e}", black_box(-100_i64)).unwrap();
+        write!(black_box(&mut buf), "{:e}", black_box(1_i64 << 32)).unwrap();
+        black_box(&mut buf).clear();
+    });
+}
+
+#[bench]
+fn write_i128_exp(bh: &mut Bencher) {
+    let mut buf = String::with_capacity(1024);
+    bh.iter(|| {
+        write!(black_box(&mut buf), "{:e}", black_box(0_i128)).unwrap();
+        write!(black_box(&mut buf), "{:e}", black_box(100_i128)).unwrap();
+        write!(black_box(&mut buf), "{:e}", black_box(-100_i128)).unwrap();
+        write!(black_box(&mut buf), "{:e}", black_box(1_i128 << 64)).unwrap();
+        black_box(&mut buf).clear();
+    });
+}

From 008b8a546a619da3333629b9418fbb4d5b44f6ae Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Fri, 22 Aug 2025 17:45:53 +0200
Subject: [PATCH 0226/1889] Add 1.89 beta-accepted changes to changelog

---
 CHANGELOG.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index bc60b1c57f7d1..874002237d0c8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -30,6 +30,8 @@ Current stable, released 2025-08-07
 * Removed superseded lints: `transmute_float_to_int`, `transmute_int_to_char`,
   `transmute_int_to_float`, `transmute_num_to_bytes` (now in rustc)
   [#14703](https://github.com/rust-lang/rust-clippy/pull/14703)
+* Move [`uninlined_format_args`] to `pedantic` (from `style`, now allow-by-default)
+  [#15287](https://github.com/rust-lang/rust-clippy/pull/15287)
 
 ### Enhancements
 
@@ -74,6 +76,9 @@ Current stable, released 2025-08-07
   [#14719](https://github.com/rust-lang/rust-clippy/pull/14719)
 * [`unnecessary_to_owned`] fixed FP when map key is a reference
   [#14834](https://github.com/rust-lang/rust-clippy/pull/14834)
+* [`swap_with_temporary`]: fix false positive leading to different semantics
+  being suggested, and use the right number of dereferences in suggestion
+  [#15172](https://github.com/rust-lang/rust-clippy/pull/15172)
 
 ### ICE Fixes
 

From 9e3360f414281019c7836c9e6d2affb1c6cefa9b Mon Sep 17 00:00:00 2001
From: okaneco <47607823+okaneco@users.noreply.github.com>
Date: Fri, 22 Aug 2025 11:58:36 -0400
Subject: [PATCH 0227/1889] Stabilize `round_char_boundary` feature

---
 clippy_lints/src/lib.rs                      |  2 +-
 tests/ui/char_indices_as_byte_indices.fixed  |  1 -
 tests/ui/char_indices_as_byte_indices.rs     |  1 -
 tests/ui/char_indices_as_byte_indices.stderr | 28 ++++++++++----------
 4 files changed, 15 insertions(+), 17 deletions(-)

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 844bc1b0e3909..edc91718263de 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -7,7 +7,7 @@
 #![feature(iter_intersperse)]
 #![feature(iter_partition_in_place)]
 #![feature(never_type)]
-#![feature(round_char_boundary)]
+#![cfg_attr(bootstrap, feature(round_char_boundary))]
 #![feature(rustc_private)]
 #![feature(stmt_expr_attributes)]
 #![feature(unwrap_infallible)]
diff --git a/tests/ui/char_indices_as_byte_indices.fixed b/tests/ui/char_indices_as_byte_indices.fixed
index 04c8f6782c51e..375a101c2e3ac 100644
--- a/tests/ui/char_indices_as_byte_indices.fixed
+++ b/tests/ui/char_indices_as_byte_indices.fixed
@@ -1,4 +1,3 @@
-#![feature(round_char_boundary)]
 #![warn(clippy::char_indices_as_byte_indices)]
 
 trait StrExt {
diff --git a/tests/ui/char_indices_as_byte_indices.rs b/tests/ui/char_indices_as_byte_indices.rs
index 773a4fc65f12f..eebc39962a2db 100644
--- a/tests/ui/char_indices_as_byte_indices.rs
+++ b/tests/ui/char_indices_as_byte_indices.rs
@@ -1,4 +1,3 @@
-#![feature(round_char_boundary)]
 #![warn(clippy::char_indices_as_byte_indices)]
 
 trait StrExt {
diff --git a/tests/ui/char_indices_as_byte_indices.stderr b/tests/ui/char_indices_as_byte_indices.stderr
index e2b4c1db78cf4..fae81fd772db8 100644
--- a/tests/ui/char_indices_as_byte_indices.stderr
+++ b/tests/ui/char_indices_as_byte_indices.stderr
@@ -1,12 +1,12 @@
 error: indexing into a string with a character position where a byte index is expected
-  --> tests/ui/char_indices_as_byte_indices.rs:13:24
+  --> tests/ui/char_indices_as_byte_indices.rs:12:24
    |
 LL |         let _ = prim[..idx];
    |                        ^^^
    |
    = note: a character can take up more than one byte, so they are not interchangeable
 note: position comes from the enumerate iterator
-  --> tests/ui/char_indices_as_byte_indices.rs:12:10
+  --> tests/ui/char_indices_as_byte_indices.rs:11:10
    |
 LL |     for (idx, _) in prim.chars().enumerate() {
    |          ^^^                     ^^^^^^^^^^^
@@ -19,14 +19,14 @@ LL +     for (idx, _) in prim.char_indices() {
    |
 
 error: passing a character position to a method that expects a byte index
-  --> tests/ui/char_indices_as_byte_indices.rs:15:23
+  --> tests/ui/char_indices_as_byte_indices.rs:14:23
    |
 LL |         prim.split_at(idx);
    |                       ^^^
    |
    = note: a character can take up more than one byte, so they are not interchangeable
 note: position comes from the enumerate iterator
-  --> tests/ui/char_indices_as_byte_indices.rs:12:10
+  --> tests/ui/char_indices_as_byte_indices.rs:11:10
    |
 LL |     for (idx, _) in prim.chars().enumerate() {
    |          ^^^                     ^^^^^^^^^^^
@@ -37,14 +37,14 @@ LL +     for (idx, _) in prim.char_indices() {
    |
 
 error: passing a character position to a method that expects a byte index
-  --> tests/ui/char_indices_as_byte_indices.rs:19:49
+  --> tests/ui/char_indices_as_byte_indices.rs:18:49
    |
 LL |         let _ = prim[..prim.floor_char_boundary(idx)];
    |                                                 ^^^
    |
    = note: a character can take up more than one byte, so they are not interchangeable
 note: position comes from the enumerate iterator
-  --> tests/ui/char_indices_as_byte_indices.rs:12:10
+  --> tests/ui/char_indices_as_byte_indices.rs:11:10
    |
 LL |     for (idx, _) in prim.chars().enumerate() {
    |          ^^^                     ^^^^^^^^^^^
@@ -55,14 +55,14 @@ LL +     for (idx, _) in prim.char_indices() {
    |
 
 error: indexing into a string with a character position where a byte index is expected
-  --> tests/ui/char_indices_as_byte_indices.rs:29:24
+  --> tests/ui/char_indices_as_byte_indices.rs:28:24
    |
 LL |         let _ = prim[..c.0];
    |                        ^^^
    |
    = note: a character can take up more than one byte, so they are not interchangeable
 note: position comes from the enumerate iterator
-  --> tests/ui/char_indices_as_byte_indices.rs:28:9
+  --> tests/ui/char_indices_as_byte_indices.rs:27:9
    |
 LL |     for c in prim.chars().enumerate() {
    |         ^                 ^^^^^^^^^^^
@@ -73,14 +73,14 @@ LL +     for c in prim.char_indices() {
    |
 
 error: passing a character position to a method that expects a byte index
-  --> tests/ui/char_indices_as_byte_indices.rs:31:23
+  --> tests/ui/char_indices_as_byte_indices.rs:30:23
    |
 LL |         prim.split_at(c.0);
    |                       ^^^
    |
    = note: a character can take up more than one byte, so they are not interchangeable
 note: position comes from the enumerate iterator
-  --> tests/ui/char_indices_as_byte_indices.rs:28:9
+  --> tests/ui/char_indices_as_byte_indices.rs:27:9
    |
 LL |     for c in prim.chars().enumerate() {
    |         ^                 ^^^^^^^^^^^
@@ -91,14 +91,14 @@ LL +     for c in prim.char_indices() {
    |
 
 error: indexing into a string with a character position where a byte index is expected
-  --> tests/ui/char_indices_as_byte_indices.rs:36:26
+  --> tests/ui/char_indices_as_byte_indices.rs:35:26
    |
 LL |         let _ = string[..idx];
    |                          ^^^
    |
    = note: a character can take up more than one byte, so they are not interchangeable
 note: position comes from the enumerate iterator
-  --> tests/ui/char_indices_as_byte_indices.rs:35:10
+  --> tests/ui/char_indices_as_byte_indices.rs:34:10
    |
 LL |     for (idx, _) in string.chars().enumerate() {
    |          ^^^                       ^^^^^^^^^^^
@@ -109,14 +109,14 @@ LL +     for (idx, _) in string.char_indices() {
    |
 
 error: passing a character position to a method that expects a byte index
-  --> tests/ui/char_indices_as_byte_indices.rs:38:25
+  --> tests/ui/char_indices_as_byte_indices.rs:37:25
    |
 LL |         string.split_at(idx);
    |                         ^^^
    |
    = note: a character can take up more than one byte, so they are not interchangeable
 note: position comes from the enumerate iterator
-  --> tests/ui/char_indices_as_byte_indices.rs:35:10
+  --> tests/ui/char_indices_as_byte_indices.rs:34:10
    |
 LL |     for (idx, _) in string.chars().enumerate() {
    |          ^^^                       ^^^^^^^^^^^

From 450e25b2412f76391260220539c41e4a0aa8530e Mon Sep 17 00:00:00 2001
From: yanglsh <yanglsh@shanghaitech.edu.cn>
Date: Sat, 23 Aug 2025 01:46:24 +0800
Subject: [PATCH 0228/1889] fix: `derivable_impls` suggests wrongly on
 `derive_const`

---
 clippy_lints/src/derivable_impls.rs          | 46 +++++++++++++++++---
 tests/ui/derivable_impls.fixed               | 26 +++++++++++
 tests/ui/derivable_impls.rs                  | 26 +++++++++++
 tests/ui/derivable_impls.stderr              | 22 +++++-----
 tests/ui/derivable_impls_derive_const.fixed  | 25 +++++++++++
 tests/ui/derivable_impls_derive_const.rs     | 32 ++++++++++++++
 tests/ui/derivable_impls_derive_const.stderr | 46 ++++++++++++++++++++
 7 files changed, 207 insertions(+), 16 deletions(-)
 create mode 100644 tests/ui/derivable_impls_derive_const.fixed
 create mode 100644 tests/ui/derivable_impls_derive_const.rs
 create mode 100644 tests/ui/derivable_impls_derive_const.stderr

diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index 7580d6cab66d4..c58aca6a52ba3 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -85,6 +85,17 @@ fn contains_trait_object(ty: Ty<'_>) -> bool {
     }
 }
 
+fn determine_derive_macro(cx: &LateContext<'_>, is_const: bool) -> Option<&'static str> {
+    if is_const {
+        if !cx.tcx.features().enabled(sym::derive_const) {
+            return None;
+        }
+        return Some("derive_const");
+    }
+    Some("derive")
+}
+
+#[expect(clippy::too_many_arguments)]
 fn check_struct<'tcx>(
     cx: &LateContext<'tcx>,
     item: &'tcx Item<'_>,
@@ -93,6 +104,7 @@ fn check_struct<'tcx>(
     adt_def: AdtDef<'_>,
     ty_args: GenericArgsRef<'_>,
     typeck_results: &'tcx TypeckResults<'tcx>,
+    is_const: bool,
 ) {
     if let TyKind::Path(QPath::Resolved(_, p)) = self_ty.kind
         && let Some(PathSegment { args, .. }) = p.segments.last()
@@ -128,11 +140,15 @@ fn check_struct<'tcx>(
         _ => false,
     };
 
+    let Some(derive_snippet) = determine_derive_macro(cx, is_const) else {
+        return;
+    };
+
     if should_emit {
         let struct_span = cx.tcx.def_span(adt_def.did());
         let suggestions = vec![
             (item.span, String::new()), // Remove the manual implementation
-            (struct_span.shrink_to_lo(), "#[derive(Default)]\n".to_string()), // Add the derive attribute
+            (struct_span.shrink_to_lo(), format!("#[{derive_snippet}(Default)]\n")), // Add the derive attribute
         ];
 
         span_lint_and_then(cx, DERIVABLE_IMPLS, item.span, "this `impl` can be derived", |diag| {
@@ -145,7 +161,13 @@ fn check_struct<'tcx>(
     }
 }
 
-fn check_enum<'tcx>(cx: &LateContext<'tcx>, item: &'tcx Item<'_>, func_expr: &Expr<'_>, adt_def: AdtDef<'_>) {
+fn check_enum<'tcx>(
+    cx: &LateContext<'tcx>,
+    item: &'tcx Item<'_>,
+    func_expr: &Expr<'_>,
+    adt_def: AdtDef<'_>,
+    is_const: bool,
+) {
     if let ExprKind::Path(QPath::Resolved(None, p)) = &peel_blocks(func_expr).kind
         && let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Const), id) = p.res
         && let variant_id = cx.tcx.parent(id)
@@ -158,11 +180,15 @@ fn check_enum<'tcx>(cx: &LateContext<'tcx>, item: &'tcx Item<'_>, func_expr: &Ex
         let variant_span = cx.tcx.def_span(variant_def.def_id);
         let indent_variant = indent_of(cx, variant_span).unwrap_or(0);
 
+        let Some(derive_snippet) = determine_derive_macro(cx, is_const) else {
+            return;
+        };
+
         let suggestions = vec![
             (item.span, String::new()), // Remove the manual implementation
             (
                 enum_span.shrink_to_lo(),
-                format!("#[derive(Default)]\n{}", " ".repeat(indent_enum)),
+                format!("#[{derive_snippet}(Default)]\n{}", " ".repeat(indent_enum)),
             ), // Add the derive attribute
             (
                 variant_span.shrink_to_lo(),
@@ -201,10 +227,20 @@ impl<'tcx> LateLintPass<'tcx> for DerivableImpls {
             && !attrs.iter().any(|attr| attr.doc_str().is_some())
             && cx.tcx.hir_attrs(impl_item_hir).is_empty()
         {
+            let is_const = of_trait.constness == hir::Constness::Const;
             if adt_def.is_struct() {
-                check_struct(cx, item, self_ty, func_expr, adt_def, args, cx.tcx.typeck_body(*b));
+                check_struct(
+                    cx,
+                    item,
+                    self_ty,
+                    func_expr,
+                    adt_def,
+                    args,
+                    cx.tcx.typeck_body(*b),
+                    is_const,
+                );
             } else if adt_def.is_enum() && self.msrv.meets(cx, msrvs::DEFAULT_ENUM_ATTRIBUTE) {
-                check_enum(cx, item, func_expr, adt_def);
+                check_enum(cx, item, func_expr, adt_def, is_const);
             }
         }
     }
diff --git a/tests/ui/derivable_impls.fixed b/tests/ui/derivable_impls.fixed
index 65bfded38835e..f549aee9eb1e9 100644
--- a/tests/ui/derivable_impls.fixed
+++ b/tests/ui/derivable_impls.fixed
@@ -1,4 +1,6 @@
 #![allow(dead_code)]
+#![feature(const_trait_impl)]
+#![feature(const_default)]
 
 use std::collections::HashMap;
 
@@ -326,4 +328,28 @@ mod issue11368 {
     }
 }
 
+mod issue15493 {
+    #[derive(Copy, Clone)]
+    #[repr(transparent)]
+    struct Foo(u64);
+
+    impl const Default for Foo {
+        fn default() -> Self {
+            Self(0)
+        }
+    }
+
+    #[derive(Copy, Clone)]
+    enum Bar {
+        A,
+        B,
+    }
+
+    impl const Default for Bar {
+        fn default() -> Self {
+            Bar::A
+        }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/derivable_impls.rs b/tests/ui/derivable_impls.rs
index 4826c5497b4a3..1e06ff6120bd2 100644
--- a/tests/ui/derivable_impls.rs
+++ b/tests/ui/derivable_impls.rs
@@ -1,4 +1,6 @@
 #![allow(dead_code)]
+#![feature(const_trait_impl)]
+#![feature(const_default)]
 
 use std::collections::HashMap;
 
@@ -396,4 +398,28 @@ mod issue11368 {
     }
 }
 
+mod issue15493 {
+    #[derive(Copy, Clone)]
+    #[repr(transparent)]
+    struct Foo(u64);
+
+    impl const Default for Foo {
+        fn default() -> Self {
+            Self(0)
+        }
+    }
+
+    #[derive(Copy, Clone)]
+    enum Bar {
+        A,
+        B,
+    }
+
+    impl const Default for Bar {
+        fn default() -> Self {
+            Bar::A
+        }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/derivable_impls.stderr b/tests/ui/derivable_impls.stderr
index 0f73ad55a85eb..d473f2a379c54 100644
--- a/tests/ui/derivable_impls.stderr
+++ b/tests/ui/derivable_impls.stderr
@@ -1,5 +1,5 @@
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:20:1
+  --> tests/ui/derivable_impls.rs:22:1
    |
 LL | / impl std::default::Default for FooDefault<'_> {
 LL | |
@@ -18,7 +18,7 @@ LL ~ struct FooDefault<'a> {
    |
 
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:42:1
+  --> tests/ui/derivable_impls.rs:44:1
    |
 LL | / impl std::default::Default for TupleDefault {
 LL | |
@@ -35,7 +35,7 @@ LL ~ struct TupleDefault(bool, i32, u64);
    |
 
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:95:1
+  --> tests/ui/derivable_impls.rs:97:1
    |
 LL | / impl Default for StrDefault<'_> {
 LL | |
@@ -52,7 +52,7 @@ LL ~ struct StrDefault<'a>(&'a str);
    |
 
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:122:1
+  --> tests/ui/derivable_impls.rs:124:1
    |
 LL | / impl Default for Y {
 LL | |
@@ -69,7 +69,7 @@ LL ~ struct Y(u32);
    |
 
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:162:1
+  --> tests/ui/derivable_impls.rs:164:1
    |
 LL | / impl Default for WithoutSelfCurly {
 LL | |
@@ -86,7 +86,7 @@ LL ~ struct WithoutSelfCurly {
    |
 
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:171:1
+  --> tests/ui/derivable_impls.rs:173:1
    |
 LL | / impl Default for WithoutSelfParan {
 LL | |
@@ -103,7 +103,7 @@ LL ~ struct WithoutSelfParan(bool);
    |
 
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:194:1
+  --> tests/ui/derivable_impls.rs:196:1
    |
 LL | / impl Default for DirectDefaultDefaultCall {
 LL | |
@@ -119,7 +119,7 @@ LL ~ pub struct DirectDefaultDefaultCall {
    |
 
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:206:1
+  --> tests/ui/derivable_impls.rs:208:1
    |
 LL | / impl Default for EquivalentToDefaultDefaultCallVec {
 LL | |
@@ -135,7 +135,7 @@ LL ~ pub struct EquivalentToDefaultDefaultCallVec {
    |
 
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:234:1
+  --> tests/ui/derivable_impls.rs:236:1
    |
 LL | / impl Default for EquivalentToDefaultDefaultCallLocal {
 LL | |
@@ -151,7 +151,7 @@ LL ~ pub struct EquivalentToDefaultDefaultCallLocal {
    |
 
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:274:1
+  --> tests/ui/derivable_impls.rs:276:1
    |
 LL | / impl Default for RepeatDefault1 {
 LL | |
@@ -168,7 +168,7 @@ LL ~ pub struct RepeatDefault1 {
    |
 
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:309:1
+  --> tests/ui/derivable_impls.rs:311:1
    |
 LL | / impl Default for SimpleEnum {
 LL | |
diff --git a/tests/ui/derivable_impls_derive_const.fixed b/tests/ui/derivable_impls_derive_const.fixed
new file mode 100644
index 0000000000000..6df43f7fb7633
--- /dev/null
+++ b/tests/ui/derivable_impls_derive_const.fixed
@@ -0,0 +1,25 @@
+#![allow(dead_code)]
+#![feature(const_trait_impl)]
+#![feature(const_default)]
+#![feature(derive_const)]
+
+mod issue15493 {
+    #[derive(Copy, Clone)]
+    #[repr(transparent)]
+    #[derive_const(Default)]
+struct Foo(u64);
+
+    
+
+    #[derive(Copy, Clone)]
+    #[derive_const(Default)]
+    enum Bar {
+        #[default]
+        A,
+        B,
+    }
+
+    
+}
+
+fn main() {}
diff --git a/tests/ui/derivable_impls_derive_const.rs b/tests/ui/derivable_impls_derive_const.rs
new file mode 100644
index 0000000000000..7d70db1c097d4
--- /dev/null
+++ b/tests/ui/derivable_impls_derive_const.rs
@@ -0,0 +1,32 @@
+#![allow(dead_code)]
+#![feature(const_trait_impl)]
+#![feature(const_default)]
+#![feature(derive_const)]
+
+mod issue15493 {
+    #[derive(Copy, Clone)]
+    #[repr(transparent)]
+    struct Foo(u64);
+
+    impl const Default for Foo {
+        //~^ derivable_impls
+        fn default() -> Self {
+            Self(0)
+        }
+    }
+
+    #[derive(Copy, Clone)]
+    enum Bar {
+        A,
+        B,
+    }
+
+    impl const Default for Bar {
+        //~^ derivable_impls
+        fn default() -> Self {
+            Bar::A
+        }
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/derivable_impls_derive_const.stderr b/tests/ui/derivable_impls_derive_const.stderr
new file mode 100644
index 0000000000000..dd185676c7709
--- /dev/null
+++ b/tests/ui/derivable_impls_derive_const.stderr
@@ -0,0 +1,46 @@
+error: this `impl` can be derived
+  --> tests/ui/derivable_impls_derive_const.rs:11:5
+   |
+LL | /     impl const Default for Foo {
+LL | |
+LL | |         fn default() -> Self {
+LL | |             Self(0)
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+   = note: `-D clippy::derivable-impls` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::derivable_impls)]`
+help: replace the manual implementation with a derive attribute
+   |
+LL ~     #[derive_const(Default)]
+LL ~ struct Foo(u64);
+LL |
+LL ~     
+   |
+
+error: this `impl` can be derived
+  --> tests/ui/derivable_impls_derive_const.rs:24:5
+   |
+LL | /     impl const Default for Bar {
+LL | |
+LL | |         fn default() -> Self {
+LL | |             Bar::A
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+help: replace the manual implementation with a derive attribute and mark the default variant
+   |
+LL ~     #[derive_const(Default)]
+LL ~     enum Bar {
+LL ~         #[default]
+LL ~         A,
+LL |         B,
+LL |     }
+LL |
+LL ~     
+   |
+
+error: aborting due to 2 previous errors
+

From f64fbe118409e29e2e3000c79d2ad2bbafc09788 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Fri, 15 Aug 2025 09:33:00 +0200
Subject: [PATCH 0229/1889] fix: also get `ty_sugg` in the `matches!` case

---
 clippy_lints/src/manual_is_ascii_check.rs | 26 +++++++++++---------
 tests/ui/manual_is_ascii_check.fixed      |  4 +++
 tests/ui/manual_is_ascii_check.rs         |  4 +++
 tests/ui/manual_is_ascii_check.stderr     | 30 ++++++++++++++++++++---
 4 files changed, 50 insertions(+), 14 deletions(-)

diff --git a/clippy_lints/src/manual_is_ascii_check.rs b/clippy_lints/src/manual_is_ascii_check.rs
index ac8c88f02057b..2eebb2430fd94 100644
--- a/clippy_lints/src/manual_is_ascii_check.rs
+++ b/clippy_lints/src/manual_is_ascii_check.rs
@@ -97,11 +97,12 @@ impl<'tcx> LateLintPass<'tcx> for ManualIsAsciiCheck {
             return;
         }
 
-        if let Some(macro_call) = matching_root_macro_call(cx, expr.span, sym::matches_macro) {
-            if let ExprKind::Match(recv, [arm, ..], _) = expr.kind {
-                let range = check_pat(&arm.pat.kind);
-                check_is_ascii(cx, macro_call.span, recv, &range, None);
-            }
+        let (arg, span, range) = if let Some(macro_call) = matching_root_macro_call(cx, expr.span, sym::matches_macro)
+            && let ExprKind::Match(recv, [arm, ..], _) = expr.kind
+        {
+            let recv = peel_ref_operators(cx, recv);
+            let range = check_pat(&arm.pat.kind);
+            (recv, macro_call.span, range)
         } else if let ExprKind::MethodCall(path, receiver, [arg], ..) = expr.kind
             && path.ident.name == sym::contains
             && let Some(higher::Range {
@@ -112,10 +113,14 @@ impl<'tcx> LateLintPass<'tcx> for ManualIsAsciiCheck {
             && !matches!(cx.typeck_results().expr_ty(arg).peel_refs().kind(), ty::Param(_))
         {
             let arg = peel_ref_operators(cx, arg);
-            let ty_sugg = get_ty_sugg(cx, arg);
             let range = check_expr_range(start, end);
-            check_is_ascii(cx, expr.span, arg, &range, ty_sugg);
-        }
+            (arg, expr.span, range)
+        } else {
+            return;
+        };
+
+        let ty_sugg = get_ty_sugg(cx, arg);
+        check_is_ascii(cx, span, arg, &range, ty_sugg);
     }
 }
 
@@ -146,9 +151,8 @@ fn check_is_ascii(
         CharRange::HexDigit => "is_ascii_hexdigit",
         CharRange::Otherwise | CharRange::LowerHexLetter | CharRange::UpperHexLetter => return,
     };
-    let default_snip = "..";
     let mut app = Applicability::MachineApplicable;
-    let recv = Sugg::hir_with_context(cx, recv, span.ctxt(), default_snip, &mut app).maybe_paren();
+    let recv = Sugg::hir_with_context(cx, recv, span.ctxt(), "_", &mut app).maybe_paren();
     let mut suggestion = vec![(span, format!("{recv}.{sugg}()"))];
     if let Some((ty_span, ty)) = ty_sugg {
         suggestion.push((ty_span, format!("{recv}: {ty}")));
@@ -182,7 +186,7 @@ fn check_pat(pat_kind: &PatKind<'_>) -> CharRange {
                 CharRange::Otherwise
             }
         },
-        PatKind::Range(Some(start), Some(end), kind) if *kind == RangeEnd::Included => check_range(start, end),
+        PatKind::Range(Some(start), Some(end), RangeEnd::Included) => check_range(start, end),
         _ => CharRange::Otherwise,
     }
 }
diff --git a/tests/ui/manual_is_ascii_check.fixed b/tests/ui/manual_is_ascii_check.fixed
index 7b0d190683469..406336dbd095d 100644
--- a/tests/ui/manual_is_ascii_check.fixed
+++ b/tests/ui/manual_is_ascii_check.fixed
@@ -108,6 +108,8 @@ fn generics() {
     //~^ manual_is_ascii_check
     take_while(|c: char| c.is_ascii_uppercase());
     //~^ manual_is_ascii_check
+    take_while(|c: char| c.is_ascii_uppercase());
+    //~^ manual_is_ascii_check
 }
 
 fn adds_type_reference() {
@@ -115,4 +117,6 @@ fn adds_type_reference() {
     //~^ manual_is_ascii_check
     let digits: Vec<&mut char> = ['1', 'A'].iter_mut().take_while(|c: &&mut char| c.is_ascii_digit()).collect();
     //~^ manual_is_ascii_check
+    let digits: Vec<&mut char> = ['1', 'A'].iter_mut().take_while(|c: &&mut char| c.is_ascii_digit()).collect();
+    //~^ manual_is_ascii_check
 }
diff --git a/tests/ui/manual_is_ascii_check.rs b/tests/ui/manual_is_ascii_check.rs
index e4f7fe9f5838a..a624497e75e52 100644
--- a/tests/ui/manual_is_ascii_check.rs
+++ b/tests/ui/manual_is_ascii_check.rs
@@ -108,6 +108,8 @@ fn generics() {
     //~^ manual_is_ascii_check
     take_while(|c: char| ('A'..='Z').contains(&c));
     //~^ manual_is_ascii_check
+    take_while(|c| matches!(c, 'A'..='Z'));
+    //~^ manual_is_ascii_check
 }
 
 fn adds_type_reference() {
@@ -115,4 +117,6 @@ fn adds_type_reference() {
     //~^ manual_is_ascii_check
     let digits: Vec<&mut char> = ['1', 'A'].iter_mut().take_while(|c| ('0'..='9').contains(c)).collect();
     //~^ manual_is_ascii_check
+    let digits: Vec<&mut char> = ['1', 'A'].iter_mut().take_while(|c| matches!(c, '0'..='9')).collect();
+    //~^ manual_is_ascii_check
 }
diff --git a/tests/ui/manual_is_ascii_check.stderr b/tests/ui/manual_is_ascii_check.stderr
index 9fd7f457b4201..cb2548ea73160 100644
--- a/tests/ui/manual_is_ascii_check.stderr
+++ b/tests/ui/manual_is_ascii_check.stderr
@@ -176,7 +176,19 @@ LL |     take_while(|c: char| ('A'..='Z').contains(&c));
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `c.is_ascii_uppercase()`
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:114:63
+  --> tests/ui/manual_is_ascii_check.rs:111:20
+   |
+LL |     take_while(|c| matches!(c, 'A'..='Z'));
+   |                    ^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -     take_while(|c| matches!(c, 'A'..='Z'));
+LL +     take_while(|c: char| c.is_ascii_uppercase());
+   |
+
+error: manual check for common ascii range
+  --> tests/ui/manual_is_ascii_check.rs:116:63
    |
 LL |     let digits: Vec<&char> = ['1', 'A'].iter().take_while(|c| ('0'..='9').contains(c)).collect();
    |                                                               ^^^^^^^^^^^^^^^^^^^^^^^
@@ -188,7 +200,7 @@ LL +     let digits: Vec<&char> = ['1', 'A'].iter().take_while(|c: &&char| c.is_
    |
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:116:71
+  --> tests/ui/manual_is_ascii_check.rs:118:71
    |
 LL |     let digits: Vec<&mut char> = ['1', 'A'].iter_mut().take_while(|c| ('0'..='9').contains(c)).collect();
    |                                                                       ^^^^^^^^^^^^^^^^^^^^^^^
@@ -199,5 +211,17 @@ LL -     let digits: Vec<&mut char> = ['1', 'A'].iter_mut().take_while(|c| ('0'.
 LL +     let digits: Vec<&mut char> = ['1', 'A'].iter_mut().take_while(|c: &&mut char| c.is_ascii_digit()).collect();
    |
 
-error: aborting due to 29 previous errors
+error: manual check for common ascii range
+  --> tests/ui/manual_is_ascii_check.rs:120:71
+   |
+LL |     let digits: Vec<&mut char> = ['1', 'A'].iter_mut().take_while(|c| matches!(c, '0'..='9')).collect();
+   |                                                                       ^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -     let digits: Vec<&mut char> = ['1', 'A'].iter_mut().take_while(|c| matches!(c, '0'..='9')).collect();
+LL +     let digits: Vec<&mut char> = ['1', 'A'].iter_mut().take_while(|c: &&mut char| c.is_ascii_digit()).collect();
+   |
+
+error: aborting due to 31 previous errors
 

From 7697b611543031a83e242dc3904debffb8023829 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Mon, 18 Aug 2025 21:48:21 -0700
Subject: [PATCH 0230/1889] bool_comparison: use correct span context for
 `>`/`<` sugg

---
 clippy_lints/src/needless_bool.rs |  5 +++--
 tests/ui/bool_comparison.fixed    | 19 +++++++++++++---
 tests/ui/bool_comparison.rs       | 19 +++++++++++++---
 tests/ui/bool_comparison.stderr   | 36 ++++++++++++++++++++-----------
 4 files changed, 59 insertions(+), 20 deletions(-)

diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index 6ae26156bc44c..d8d66837405ff 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -381,8 +381,9 @@ fn check_comparison<'a, 'tcx>(
                     suggest_bool_comparison(cx, binop_span, left_side, applicability, m, h);
                 }),
                 (None, None) => no_literal.map_or((), |(h, m)| {
-                    let left_side = Sugg::hir_with_applicability(cx, left_side, "..", &mut applicability);
-                    let right_side = Sugg::hir_with_applicability(cx, right_side, "..", &mut applicability);
+                    let left_side = Sugg::hir_with_context(cx, left_side, binop_span.ctxt(), "..", &mut applicability);
+                    let right_side =
+                        Sugg::hir_with_context(cx, right_side, binop_span.ctxt(), "..", &mut applicability);
                     span_lint_and_sugg(
                         cx,
                         BOOL_COMPARISON,
diff --git a/tests/ui/bool_comparison.fixed b/tests/ui/bool_comparison.fixed
index 166abbe549c3d..e8edc33b56a0d 100644
--- a/tests/ui/bool_comparison.fixed
+++ b/tests/ui/bool_comparison.fixed
@@ -91,7 +91,6 @@ fn main() {
     };
 }
 
-#[allow(dead_code)]
 fn issue3703() {
     struct Foo;
     impl PartialEq<bool> for Foo {
@@ -127,7 +126,6 @@ fn issue3703() {
     if false < Foo {}
 }
 
-#[allow(dead_code)]
 fn issue4983() {
     let a = true;
     let b = false;
@@ -157,7 +155,6 @@ fn func() -> bool {
     true
 }
 
-#[allow(dead_code)]
 fn issue3973() {
     // ok, don't lint on `cfg` invocation
     if false == cfg!(feature = "debugging") {}
@@ -199,3 +196,19 @@ fn issue9907() {
     let _ = ((1 < 2) != m!(func)) as usize;
     //~^ bool_comparison
 }
+
+fn issue15497() {
+    fn func() -> bool {
+        true
+    }
+
+    fn foo(x: bool) -> bool {
+        x & !m!(func)
+        //~^ bool_comparison
+    }
+
+    fn bar(x: bool) -> bool {
+        !x & m!(func)
+        //~^ bool_comparison
+    }
+}
diff --git a/tests/ui/bool_comparison.rs b/tests/ui/bool_comparison.rs
index 7265c2b4c5a6f..18004639029fe 100644
--- a/tests/ui/bool_comparison.rs
+++ b/tests/ui/bool_comparison.rs
@@ -91,7 +91,6 @@ fn main() {
     };
 }
 
-#[allow(dead_code)]
 fn issue3703() {
     struct Foo;
     impl PartialEq<bool> for Foo {
@@ -127,7 +126,6 @@ fn issue3703() {
     if false < Foo {}
 }
 
-#[allow(dead_code)]
 fn issue4983() {
     let a = true;
     let b = false;
@@ -157,7 +155,6 @@ fn func() -> bool {
     true
 }
 
-#[allow(dead_code)]
 fn issue3973() {
     // ok, don't lint on `cfg` invocation
     if false == cfg!(feature = "debugging") {}
@@ -199,3 +196,19 @@ fn issue9907() {
     let _ = ((1 < 2) == !m!(func)) as usize;
     //~^ bool_comparison
 }
+
+fn issue15497() {
+    fn func() -> bool {
+        true
+    }
+
+    fn foo(x: bool) -> bool {
+        x > m!(func)
+        //~^ bool_comparison
+    }
+
+    fn bar(x: bool) -> bool {
+        x < m!(func)
+        //~^ bool_comparison
+    }
+}
diff --git a/tests/ui/bool_comparison.stderr b/tests/ui/bool_comparison.stderr
index ddbb9ff78edb3..a398870e7ee81 100644
--- a/tests/ui/bool_comparison.stderr
+++ b/tests/ui/bool_comparison.stderr
@@ -86,70 +86,82 @@ LL |     if x > y {
    |        ^^^^^ help: try simplifying it as shown: `x & !y`
 
 error: this comparison might be written more concisely
-  --> tests/ui/bool_comparison.rs:135:8
+  --> tests/ui/bool_comparison.rs:133:8
    |
 LL |     if a == !b {};
    |        ^^^^^^^ help: try simplifying it as shown: `a != b`
 
 error: this comparison might be written more concisely
-  --> tests/ui/bool_comparison.rs:137:8
+  --> tests/ui/bool_comparison.rs:135:8
    |
 LL |     if !a == b {};
    |        ^^^^^^^ help: try simplifying it as shown: `a != b`
 
 error: this comparison might be written more concisely
-  --> tests/ui/bool_comparison.rs:142:8
+  --> tests/ui/bool_comparison.rs:140:8
    |
 LL |     if b == !a {};
    |        ^^^^^^^ help: try simplifying it as shown: `b != a`
 
 error: this comparison might be written more concisely
-  --> tests/ui/bool_comparison.rs:144:8
+  --> tests/ui/bool_comparison.rs:142:8
    |
 LL |     if !b == a {};
    |        ^^^^^^^ help: try simplifying it as shown: `b != a`
 
 error: equality checks against false can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:169:8
+  --> tests/ui/bool_comparison.rs:166:8
    |
 LL |     if false == m!(func) {}
    |        ^^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `!m!(func)`
 
 error: equality checks against false can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:171:8
+  --> tests/ui/bool_comparison.rs:168:8
    |
 LL |     if m!(func) == false {}
    |        ^^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `!m!(func)`
 
 error: equality checks against true are unnecessary
-  --> tests/ui/bool_comparison.rs:173:8
+  --> tests/ui/bool_comparison.rs:170:8
    |
 LL |     if true == m!(func) {}
    |        ^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `m!(func)`
 
 error: equality checks against true are unnecessary
-  --> tests/ui/bool_comparison.rs:175:8
+  --> tests/ui/bool_comparison.rs:172:8
    |
 LL |     if m!(func) == true {}
    |        ^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `m!(func)`
 
 error: equality checks against false can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:193:14
+  --> tests/ui/bool_comparison.rs:190:14
    |
 LL |     let _ = ((1 < 2) == false) as usize;
    |              ^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `1 >= 2`
 
 error: equality checks against false can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:195:14
+  --> tests/ui/bool_comparison.rs:192:14
    |
 LL |     let _ = (false == m!(func)) as usize;
    |              ^^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `!m!(func)`
 
 error: this comparison might be written more concisely
-  --> tests/ui/bool_comparison.rs:199:14
+  --> tests/ui/bool_comparison.rs:196:14
    |
 LL |     let _ = ((1 < 2) == !m!(func)) as usize;
    |              ^^^^^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `(1 < 2) != m!(func)`
 
-error: aborting due to 25 previous errors
+error: order comparisons between booleans can be simplified
+  --> tests/ui/bool_comparison.rs:206:9
+   |
+LL |         x > m!(func)
+   |         ^^^^^^^^^^^^ help: try simplifying it as shown: `x & !m!(func)`
+
+error: order comparisons between booleans can be simplified
+  --> tests/ui/bool_comparison.rs:211:9
+   |
+LL |         x < m!(func)
+   |         ^^^^^^^^^^^^ help: try simplifying it as shown: `!x & m!(func)`
+
+error: aborting due to 27 previous errors
 

From c2c3e0990b4430cd2ce9c27b1eb8ff5dd57091cb Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Fri, 15 Aug 2025 12:42:47 +0200
Subject: [PATCH 0231/1889] fix: don't check for `!x = y`/`x = !y`

misc: rm "as shown" from help message - clippy guidelines recommend against this

misc: pull conditions into let-chain

misc: use `Span::to`

misc: inline `{l,r}_ty`

misc: move the type checks out of `check_comparison`

misc: make test cases much less verbose
---
 clippy_lints/src/needless_bool.rs     | 141 +++++++-----------------
 tests/ui/bool_comparison.fixed        | 148 ++++++++-----------------
 tests/ui/bool_comparison.rs           | 148 ++++++++-----------------
 tests/ui/bool_comparison.stderr       | 150 +++++++++++---------------
 tests/ui/needless_bool/fixable.stderr |   8 +-
 tests/ui/nonminimal_bool.rs           |   2 -
 tests/ui/nonminimal_bool.stderr       |  50 ++++-----
 7 files changed, 212 insertions(+), 435 deletions(-)

diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index d8d66837405ff..49d41a3af3ddc 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -7,7 +7,7 @@ use clippy_utils::{
 };
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
+use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
 use rustc_span::Span;
@@ -232,7 +232,12 @@ impl<'tcx> LateLintPass<'tcx> for BoolComparison {
             return;
         }
 
-        if let ExprKind::Binary(Spanned { node, .. }, ..) = e.kind {
+        if let ExprKind::Binary(Spanned { node, .. }, left_side, right_side) = e.kind
+            && is_expn_of(left_side.span, sym::cfg).is_none()
+            && is_expn_of(right_side.span, sym::cfg).is_none()
+            && cx.typeck_results().expr_ty(left_side).is_bool()
+            && cx.typeck_results().expr_ty(right_side).is_bool()
+        {
             let ignore_case = None::<(fn(_) -> _, &str)>;
             let ignore_no_literal = None::<(fn(_, _) -> _, &str)>;
             match node {
@@ -288,30 +293,6 @@ impl<'tcx> LateLintPass<'tcx> for BoolComparison {
     }
 }
 
-struct ExpressionInfoWithSpan {
-    one_side_is_unary_not: bool,
-    left_span: Span,
-    right_span: Span,
-}
-
-fn is_unary_not(e: &Expr<'_>) -> (bool, Span) {
-    if let ExprKind::Unary(UnOp::Not, operand) = e.kind {
-        return (true, operand.span);
-    }
-    (false, e.span)
-}
-
-fn one_side_is_unary_not<'tcx>(left_side: &'tcx Expr<'_>, right_side: &'tcx Expr<'_>) -> ExpressionInfoWithSpan {
-    let left = is_unary_not(left_side);
-    let right = is_unary_not(right_side);
-
-    ExpressionInfoWithSpan {
-        one_side_is_unary_not: left.0 != right.0,
-        left_span: left.1,
-        right_span: right.1,
-    }
-}
-
 fn check_comparison<'a, 'tcx>(
     cx: &LateContext<'tcx>,
     e: &'tcx Expr<'_>,
@@ -321,81 +302,39 @@ fn check_comparison<'a, 'tcx>(
     right_false: Option<(impl FnOnce(Sugg<'a>) -> Sugg<'a>, &'static str)>,
     no_literal: Option<(impl FnOnce(Sugg<'a>, Sugg<'a>) -> Sugg<'a>, &'static str)>,
 ) {
-    if let ExprKind::Binary(op, left_side, right_side) = e.kind {
-        let (l_ty, r_ty) = (
-            cx.typeck_results().expr_ty(left_side),
-            cx.typeck_results().expr_ty(right_side),
-        );
-        if is_expn_of(left_side.span, sym::cfg).is_some() || is_expn_of(right_side.span, sym::cfg).is_some() {
-            return;
-        }
-        if l_ty.is_bool() && r_ty.is_bool() {
-            let mut applicability = Applicability::MachineApplicable;
-            // Eliminate parentheses in `e` by using the lo pos of lhs and hi pos of rhs,
-            // calling `source_callsite` make sure macros are handled correctly, see issue #9907
-            let binop_span = left_side
-                .span
-                .source_callsite()
-                .with_hi(right_side.span.source_callsite().hi());
+    if let ExprKind::Binary(_, left_side, right_side) = e.kind {
+        let mut applicability = Applicability::MachineApplicable;
+        // Eliminate parentheses in `e` by using the lo pos of lhs and hi pos of rhs,
+        // calling `source_callsite` make sure macros are handled correctly, see issue #9907
+        let binop_span = left_side.span.source_callsite().to(right_side.span.source_callsite());
 
-            if op.node == BinOpKind::Eq {
-                let expression_info = one_side_is_unary_not(left_side, right_side);
-                if expression_info.one_side_is_unary_not {
-                    span_lint_and_sugg(
-                        cx,
-                        BOOL_COMPARISON,
-                        binop_span,
-                        "this comparison might be written more concisely",
-                        "try simplifying it as shown",
-                        format!(
-                            "{} != {}",
-                            snippet_with_applicability(
-                                cx,
-                                expression_info.left_span.source_callsite(),
-                                "..",
-                                &mut applicability
-                            ),
-                            snippet_with_applicability(
-                                cx,
-                                expression_info.right_span.source_callsite(),
-                                "..",
-                                &mut applicability
-                            )
-                        ),
-                        applicability,
-                    );
-                }
-            }
-
-            match (fetch_bool_expr(left_side), fetch_bool_expr(right_side)) {
-                (Some(true), None) => left_true.map_or((), |(h, m)| {
-                    suggest_bool_comparison(cx, binop_span, right_side, applicability, m, h);
-                }),
-                (None, Some(true)) => right_true.map_or((), |(h, m)| {
-                    suggest_bool_comparison(cx, binop_span, left_side, applicability, m, h);
-                }),
-                (Some(false), None) => left_false.map_or((), |(h, m)| {
-                    suggest_bool_comparison(cx, binop_span, right_side, applicability, m, h);
-                }),
-                (None, Some(false)) => right_false.map_or((), |(h, m)| {
-                    suggest_bool_comparison(cx, binop_span, left_side, applicability, m, h);
-                }),
-                (None, None) => no_literal.map_or((), |(h, m)| {
-                    let left_side = Sugg::hir_with_context(cx, left_side, binop_span.ctxt(), "..", &mut applicability);
-                    let right_side =
-                        Sugg::hir_with_context(cx, right_side, binop_span.ctxt(), "..", &mut applicability);
-                    span_lint_and_sugg(
-                        cx,
-                        BOOL_COMPARISON,
-                        binop_span,
-                        m,
-                        "try simplifying it as shown",
-                        h(left_side, right_side).into_string(),
-                        applicability,
-                    );
-                }),
-                _ => (),
-            }
+        match (fetch_bool_expr(left_side), fetch_bool_expr(right_side)) {
+            (Some(true), None) => left_true.map_or((), |(h, m)| {
+                suggest_bool_comparison(cx, binop_span, right_side, applicability, m, h);
+            }),
+            (None, Some(true)) => right_true.map_or((), |(h, m)| {
+                suggest_bool_comparison(cx, binop_span, left_side, applicability, m, h);
+            }),
+            (Some(false), None) => left_false.map_or((), |(h, m)| {
+                suggest_bool_comparison(cx, binop_span, right_side, applicability, m, h);
+            }),
+            (None, Some(false)) => right_false.map_or((), |(h, m)| {
+                suggest_bool_comparison(cx, binop_span, left_side, applicability, m, h);
+            }),
+            (None, None) => no_literal.map_or((), |(h, m)| {
+                let left_side = Sugg::hir_with_context(cx, left_side, binop_span.ctxt(), "..", &mut applicability);
+                let right_side = Sugg::hir_with_context(cx, right_side, binop_span.ctxt(), "..", &mut applicability);
+                span_lint_and_sugg(
+                    cx,
+                    BOOL_COMPARISON,
+                    binop_span,
+                    m,
+                    "try",
+                    h(left_side, right_side).into_string(),
+                    applicability,
+                );
+            }),
+            _ => (),
         }
     }
 }
@@ -414,7 +353,7 @@ fn suggest_bool_comparison<'a, 'tcx>(
         BOOL_COMPARISON,
         span,
         message,
-        "try simplifying it as shown",
+        "try",
         conv_hint(hint).into_string(),
         app,
     );
diff --git a/tests/ui/bool_comparison.fixed b/tests/ui/bool_comparison.fixed
index e8edc33b56a0d..b0b60104c0b91 100644
--- a/tests/ui/bool_comparison.fixed
+++ b/tests/ui/bool_comparison.fixed
@@ -1,94 +1,39 @@
 #![allow(non_local_definitions, clippy::needless_if)]
 #![warn(clippy::bool_comparison)]
-#![allow(clippy::non_canonical_partial_ord_impl, clippy::nonminimal_bool)]
+#![allow(clippy::non_canonical_partial_ord_impl)]
 
 fn main() {
     let x = true;
-    if x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if !x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if !x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if !x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if !x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if !x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if !x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
+    let _ = if x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if !x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if !x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if !x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if !x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if !x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if !x { "yes" } else { "no" };
+    //~^ bool_comparison
+
     let y = true;
-    if !x & y {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if x & !y {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
+    let _ = if !x & y { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if x & !y { "yes" } else { "no" };
+    //~^ bool_comparison
 }
 
 fn issue3703() {
@@ -126,25 +71,6 @@ fn issue3703() {
     if false < Foo {}
 }
 
-fn issue4983() {
-    let a = true;
-    let b = false;
-
-    if a != b {};
-    //~^ bool_comparison
-    if a != b {};
-    //~^ bool_comparison
-    if a == b {};
-    if !a == !b {};
-
-    if b != a {};
-    //~^ bool_comparison
-    if b != a {};
-    //~^ bool_comparison
-    if b == a {};
-    if !b == !a {};
-}
-
 macro_rules! m {
     ($func:ident) => {
         $func()
@@ -193,10 +119,22 @@ fn issue9907() {
     //~^ bool_comparison
     // This is not part of the issue, but an unexpected found when fixing the issue,
     // the provided span was inside of macro rather than the macro callsite.
-    let _ = ((1 < 2) != m!(func)) as usize;
+    let _ = ((1 < 2) & !m!(func)) as usize;
     //~^ bool_comparison
 }
 
+#[allow(clippy::nonminimal_bool)]
+fn issue15367() {
+    let a = true;
+    let b = false;
+
+    // these cases are handled by `nonminimal_bool`, so don't double-lint
+    if a == !b {};
+    if !a == b {};
+    if b == !a {};
+    if !b == a {};
+}
+
 fn issue15497() {
     fn func() -> bool {
         true
diff --git a/tests/ui/bool_comparison.rs b/tests/ui/bool_comparison.rs
index 18004639029fe..1b1108d6ce504 100644
--- a/tests/ui/bool_comparison.rs
+++ b/tests/ui/bool_comparison.rs
@@ -1,94 +1,39 @@
 #![allow(non_local_definitions, clippy::needless_if)]
 #![warn(clippy::bool_comparison)]
-#![allow(clippy::non_canonical_partial_ord_impl, clippy::nonminimal_bool)]
+#![allow(clippy::non_canonical_partial_ord_impl)]
 
 fn main() {
     let x = true;
-    if x == true {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if x == false {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if true == x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if false == x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if x != true {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if x != false {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if true != x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if false != x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if x < true {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if false < x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if x > false {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if true > x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
+    let _ = if x == true { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if x == false { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if true == x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if false == x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if x != true { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if x != false { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if true != x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if false != x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if x < true { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if false < x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if x > false { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if true > x { "yes" } else { "no" };
+    //~^ bool_comparison
+
     let y = true;
-    if x < y {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if x > y {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
+    let _ = if x < y { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if x > y { "yes" } else { "no" };
+    //~^ bool_comparison
 }
 
 fn issue3703() {
@@ -126,25 +71,6 @@ fn issue3703() {
     if false < Foo {}
 }
 
-fn issue4983() {
-    let a = true;
-    let b = false;
-
-    if a == !b {};
-    //~^ bool_comparison
-    if !a == b {};
-    //~^ bool_comparison
-    if a == b {};
-    if !a == !b {};
-
-    if b == !a {};
-    //~^ bool_comparison
-    if !b == a {};
-    //~^ bool_comparison
-    if b == a {};
-    if !b == !a {};
-}
-
 macro_rules! m {
     ($func:ident) => {
         $func()
@@ -193,10 +119,22 @@ fn issue9907() {
     //~^ bool_comparison
     // This is not part of the issue, but an unexpected found when fixing the issue,
     // the provided span was inside of macro rather than the macro callsite.
-    let _ = ((1 < 2) == !m!(func)) as usize;
+    let _ = ((1 < 2) > m!(func)) as usize;
     //~^ bool_comparison
 }
 
+#[allow(clippy::nonminimal_bool)]
+fn issue15367() {
+    let a = true;
+    let b = false;
+
+    // these cases are handled by `nonminimal_bool`, so don't double-lint
+    if a == !b {};
+    if !a == b {};
+    if b == !a {};
+    if !b == a {};
+}
+
 fn issue15497() {
     fn func() -> bool {
         true
diff --git a/tests/ui/bool_comparison.stderr b/tests/ui/bool_comparison.stderr
index a398870e7ee81..98881a2d20fd3 100644
--- a/tests/ui/bool_comparison.stderr
+++ b/tests/ui/bool_comparison.stderr
@@ -1,167 +1,143 @@
 error: equality checks against true are unnecessary
-  --> tests/ui/bool_comparison.rs:7:8
+  --> tests/ui/bool_comparison.rs:7:16
    |
-LL |     if x == true {
-   |        ^^^^^^^^^ help: try simplifying it as shown: `x`
+LL |     let _ = if x == true { "yes" } else { "no" };
+   |                ^^^^^^^^^ help: try: `x`
    |
    = note: `-D clippy::bool-comparison` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::bool_comparison)]`
 
 error: equality checks against false can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:13:8
+  --> tests/ui/bool_comparison.rs:9:16
    |
-LL |     if x == false {
-   |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
+LL |     let _ = if x == false { "yes" } else { "no" };
+   |                ^^^^^^^^^^ help: try: `!x`
 
 error: equality checks against true are unnecessary
-  --> tests/ui/bool_comparison.rs:19:8
+  --> tests/ui/bool_comparison.rs:11:16
    |
-LL |     if true == x {
-   |        ^^^^^^^^^ help: try simplifying it as shown: `x`
+LL |     let _ = if true == x { "yes" } else { "no" };
+   |                ^^^^^^^^^ help: try: `x`
 
 error: equality checks against false can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:25:8
+  --> tests/ui/bool_comparison.rs:13:16
    |
-LL |     if false == x {
-   |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
+LL |     let _ = if false == x { "yes" } else { "no" };
+   |                ^^^^^^^^^^ help: try: `!x`
 
 error: inequality checks against true can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:31:8
+  --> tests/ui/bool_comparison.rs:15:16
    |
-LL |     if x != true {
-   |        ^^^^^^^^^ help: try simplifying it as shown: `!x`
+LL |     let _ = if x != true { "yes" } else { "no" };
+   |                ^^^^^^^^^ help: try: `!x`
 
 error: inequality checks against false are unnecessary
-  --> tests/ui/bool_comparison.rs:37:8
+  --> tests/ui/bool_comparison.rs:17:16
    |
-LL |     if x != false {
-   |        ^^^^^^^^^^ help: try simplifying it as shown: `x`
+LL |     let _ = if x != false { "yes" } else { "no" };
+   |                ^^^^^^^^^^ help: try: `x`
 
 error: inequality checks against true can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:43:8
+  --> tests/ui/bool_comparison.rs:19:16
    |
-LL |     if true != x {
-   |        ^^^^^^^^^ help: try simplifying it as shown: `!x`
+LL |     let _ = if true != x { "yes" } else { "no" };
+   |                ^^^^^^^^^ help: try: `!x`
 
 error: inequality checks against false are unnecessary
-  --> tests/ui/bool_comparison.rs:49:8
+  --> tests/ui/bool_comparison.rs:21:16
    |
-LL |     if false != x {
-   |        ^^^^^^^^^^ help: try simplifying it as shown: `x`
+LL |     let _ = if false != x { "yes" } else { "no" };
+   |                ^^^^^^^^^^ help: try: `x`
 
 error: less than comparison against true can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:55:8
+  --> tests/ui/bool_comparison.rs:23:16
    |
-LL |     if x < true {
-   |        ^^^^^^^^ help: try simplifying it as shown: `!x`
+LL |     let _ = if x < true { "yes" } else { "no" };
+   |                ^^^^^^^^ help: try: `!x`
 
 error: greater than checks against false are unnecessary
-  --> tests/ui/bool_comparison.rs:61:8
+  --> tests/ui/bool_comparison.rs:25:16
    |
-LL |     if false < x {
-   |        ^^^^^^^^^ help: try simplifying it as shown: `x`
+LL |     let _ = if false < x { "yes" } else { "no" };
+   |                ^^^^^^^^^ help: try: `x`
 
 error: greater than checks against false are unnecessary
-  --> tests/ui/bool_comparison.rs:67:8
+  --> tests/ui/bool_comparison.rs:27:16
    |
-LL |     if x > false {
-   |        ^^^^^^^^^ help: try simplifying it as shown: `x`
+LL |     let _ = if x > false { "yes" } else { "no" };
+   |                ^^^^^^^^^ help: try: `x`
 
 error: less than comparison against true can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:73:8
+  --> tests/ui/bool_comparison.rs:29:16
    |
-LL |     if true > x {
-   |        ^^^^^^^^ help: try simplifying it as shown: `!x`
+LL |     let _ = if true > x { "yes" } else { "no" };
+   |                ^^^^^^^^ help: try: `!x`
 
 error: order comparisons between booleans can be simplified
-  --> tests/ui/bool_comparison.rs:80:8
+  --> tests/ui/bool_comparison.rs:33:16
    |
-LL |     if x < y {
-   |        ^^^^^ help: try simplifying it as shown: `!x & y`
+LL |     let _ = if x < y { "yes" } else { "no" };
+   |                ^^^^^ help: try: `!x & y`
 
 error: order comparisons between booleans can be simplified
-  --> tests/ui/bool_comparison.rs:86:8
+  --> tests/ui/bool_comparison.rs:35:16
    |
-LL |     if x > y {
-   |        ^^^^^ help: try simplifying it as shown: `x & !y`
-
-error: this comparison might be written more concisely
-  --> tests/ui/bool_comparison.rs:133:8
-   |
-LL |     if a == !b {};
-   |        ^^^^^^^ help: try simplifying it as shown: `a != b`
-
-error: this comparison might be written more concisely
-  --> tests/ui/bool_comparison.rs:135:8
-   |
-LL |     if !a == b {};
-   |        ^^^^^^^ help: try simplifying it as shown: `a != b`
-
-error: this comparison might be written more concisely
-  --> tests/ui/bool_comparison.rs:140:8
-   |
-LL |     if b == !a {};
-   |        ^^^^^^^ help: try simplifying it as shown: `b != a`
-
-error: this comparison might be written more concisely
-  --> tests/ui/bool_comparison.rs:142:8
-   |
-LL |     if !b == a {};
-   |        ^^^^^^^ help: try simplifying it as shown: `b != a`
+LL |     let _ = if x > y { "yes" } else { "no" };
+   |                ^^^^^ help: try: `x & !y`
 
 error: equality checks against false can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:166:8
+  --> tests/ui/bool_comparison.rs:92:8
    |
 LL |     if false == m!(func) {}
-   |        ^^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `!m!(func)`
+   |        ^^^^^^^^^^^^^^^^^ help: try: `!m!(func)`
 
 error: equality checks against false can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:168:8
+  --> tests/ui/bool_comparison.rs:94:8
    |
 LL |     if m!(func) == false {}
-   |        ^^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `!m!(func)`
+   |        ^^^^^^^^^^^^^^^^^ help: try: `!m!(func)`
 
 error: equality checks against true are unnecessary
-  --> tests/ui/bool_comparison.rs:170:8
+  --> tests/ui/bool_comparison.rs:96:8
    |
 LL |     if true == m!(func) {}
-   |        ^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `m!(func)`
+   |        ^^^^^^^^^^^^^^^^ help: try: `m!(func)`
 
 error: equality checks against true are unnecessary
-  --> tests/ui/bool_comparison.rs:172:8
+  --> tests/ui/bool_comparison.rs:98:8
    |
 LL |     if m!(func) == true {}
-   |        ^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `m!(func)`
+   |        ^^^^^^^^^^^^^^^^ help: try: `m!(func)`
 
 error: equality checks against false can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:190:14
+  --> tests/ui/bool_comparison.rs:116:14
    |
 LL |     let _ = ((1 < 2) == false) as usize;
-   |              ^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `1 >= 2`
+   |              ^^^^^^^^^^^^^^^^ help: try: `1 >= 2`
 
 error: equality checks against false can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:192:14
+  --> tests/ui/bool_comparison.rs:118:14
    |
 LL |     let _ = (false == m!(func)) as usize;
-   |              ^^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `!m!(func)`
+   |              ^^^^^^^^^^^^^^^^^ help: try: `!m!(func)`
 
-error: this comparison might be written more concisely
-  --> tests/ui/bool_comparison.rs:196:14
+error: order comparisons between booleans can be simplified
+  --> tests/ui/bool_comparison.rs:122:14
    |
-LL |     let _ = ((1 < 2) == !m!(func)) as usize;
-   |              ^^^^^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `(1 < 2) != m!(func)`
+LL |     let _ = ((1 < 2) > m!(func)) as usize;
+   |              ^^^^^^^^^^^^^^^^^^ help: try: `(1 < 2) & !m!(func)`
 
 error: order comparisons between booleans can be simplified
-  --> tests/ui/bool_comparison.rs:206:9
+  --> tests/ui/bool_comparison.rs:144:9
    |
 LL |         x > m!(func)
-   |         ^^^^^^^^^^^^ help: try simplifying it as shown: `x & !m!(func)`
+   |         ^^^^^^^^^^^^ help: try: `x & !m!(func)`
 
 error: order comparisons between booleans can be simplified
-  --> tests/ui/bool_comparison.rs:211:9
+  --> tests/ui/bool_comparison.rs:149:9
    |
 LL |         x < m!(func)
-   |         ^^^^^^^^^^^^ help: try simplifying it as shown: `!x & m!(func)`
+   |         ^^^^^^^^^^^^ help: try: `!x & m!(func)`
 
-error: aborting due to 27 previous errors
+error: aborting due to 23 previous errors
 
diff --git a/tests/ui/needless_bool/fixable.stderr b/tests/ui/needless_bool/fixable.stderr
index 3f117ee5a5021..9404d07ba0e08 100644
--- a/tests/ui/needless_bool/fixable.stderr
+++ b/tests/ui/needless_bool/fixable.stderr
@@ -135,7 +135,7 @@ error: equality checks against true are unnecessary
   --> tests/ui/needless_bool/fixable.rs:157:8
    |
 LL |     if x == true {};
-   |        ^^^^^^^^^ help: try simplifying it as shown: `x`
+   |        ^^^^^^^^^ help: try: `x`
    |
    = note: `-D clippy::bool-comparison` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::bool_comparison)]`
@@ -144,19 +144,19 @@ error: equality checks against false can be replaced by a negation
   --> tests/ui/needless_bool/fixable.rs:162:8
    |
 LL |     if x == false {};
-   |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
+   |        ^^^^^^^^^^ help: try: `!x`
 
 error: equality checks against true are unnecessary
   --> tests/ui/needless_bool/fixable.rs:173:8
    |
 LL |     if x == true {};
-   |        ^^^^^^^^^ help: try simplifying it as shown: `x`
+   |        ^^^^^^^^^ help: try: `x`
 
 error: equality checks against false can be replaced by a negation
   --> tests/ui/needless_bool/fixable.rs:175:8
    |
 LL |     if x == false {};
-   |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
+   |        ^^^^^^^^^^ help: try: `!x`
 
 error: this if-then-else expression returns a bool literal
   --> tests/ui/needless_bool/fixable.rs:185:12
diff --git a/tests/ui/nonminimal_bool.rs b/tests/ui/nonminimal_bool.rs
index cacce9a7d1cbd..f03f74dfafe21 100644
--- a/tests/ui/nonminimal_bool.rs
+++ b/tests/ui/nonminimal_bool.rs
@@ -182,14 +182,12 @@ fn issue_5794() {
     if !b == true {}
     //~^ nonminimal_bool
     //~| bool_comparison
-    //~| bool_comparison
     if !b != true {}
     //~^ nonminimal_bool
     //~| bool_comparison
     if true == !b {}
     //~^ nonminimal_bool
     //~| bool_comparison
-    //~| bool_comparison
     if true != !b {}
     //~^ nonminimal_bool
     //~| bool_comparison
diff --git a/tests/ui/nonminimal_bool.stderr b/tests/ui/nonminimal_bool.stderr
index c20412974b20f..6a20b9216da52 100644
--- a/tests/ui/nonminimal_bool.stderr
+++ b/tests/ui/nonminimal_bool.stderr
@@ -154,98 +154,86 @@ error: this boolean expression can be simplified
 LL |     if !b == true {}
    |        ^^^^^^^^^^ help: try: `b != true`
 
-error: this comparison might be written more concisely
+error: equality checks against true are unnecessary
   --> tests/ui/nonminimal_bool.rs:182:8
    |
 LL |     if !b == true {}
-   |        ^^^^^^^^^^ help: try simplifying it as shown: `b != true`
+   |        ^^^^^^^^^^ help: try: `!b`
    |
    = note: `-D clippy::bool-comparison` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::bool_comparison)]`
 
-error: equality checks against true are unnecessary
-  --> tests/ui/nonminimal_bool.rs:182:8
-   |
-LL |     if !b == true {}
-   |        ^^^^^^^^^^ help: try simplifying it as shown: `!b`
-
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:186:8
+  --> tests/ui/nonminimal_bool.rs:185:8
    |
 LL |     if !b != true {}
    |        ^^^^^^^^^^ help: try: `b == true`
 
 error: inequality checks against true can be replaced by a negation
-  --> tests/ui/nonminimal_bool.rs:186:8
+  --> tests/ui/nonminimal_bool.rs:185:8
    |
 LL |     if !b != true {}
-   |        ^^^^^^^^^^ help: try simplifying it as shown: `b`
+   |        ^^^^^^^^^^ help: try: `b`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:189:8
+  --> tests/ui/nonminimal_bool.rs:188:8
    |
 LL |     if true == !b {}
    |        ^^^^^^^^^^ help: try: `true != b`
 
-error: this comparison might be written more concisely
-  --> tests/ui/nonminimal_bool.rs:189:8
-   |
-LL |     if true == !b {}
-   |        ^^^^^^^^^^ help: try simplifying it as shown: `true != b`
-
 error: equality checks against true are unnecessary
-  --> tests/ui/nonminimal_bool.rs:189:8
+  --> tests/ui/nonminimal_bool.rs:188:8
    |
 LL |     if true == !b {}
-   |        ^^^^^^^^^^ help: try simplifying it as shown: `!b`
+   |        ^^^^^^^^^^ help: try: `!b`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:193:8
+  --> tests/ui/nonminimal_bool.rs:191:8
    |
 LL |     if true != !b {}
    |        ^^^^^^^^^^ help: try: `true == b`
 
 error: inequality checks against true can be replaced by a negation
-  --> tests/ui/nonminimal_bool.rs:193:8
+  --> tests/ui/nonminimal_bool.rs:191:8
    |
 LL |     if true != !b {}
-   |        ^^^^^^^^^^ help: try simplifying it as shown: `b`
+   |        ^^^^^^^^^^ help: try: `b`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:196:8
+  --> tests/ui/nonminimal_bool.rs:194:8
    |
 LL |     if !b == !c {}
    |        ^^^^^^^^ help: try: `b == c`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:198:8
+  --> tests/ui/nonminimal_bool.rs:196:8
    |
 LL |     if !b != !c {}
    |        ^^^^^^^^ help: try: `b != c`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:214:8
+  --> tests/ui/nonminimal_bool.rs:212:8
    |
 LL |     if !(a < 2.0 && !b) {
    |        ^^^^^^^^^^^^^^^^ help: try: `a >= 2.0 || b`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:233:12
+  --> tests/ui/nonminimal_bool.rs:231:12
    |
 LL |         if !(matches!(ty, TyKind::Ref(_, _, _)) && !is_mutable(&expr)) {
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `!matches!(ty, TyKind::Ref(_, _, _)) || is_mutable(&expr)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:253:8
+  --> tests/ui/nonminimal_bool.rs:251:8
    |
 LL |     if !S != true {}
    |        ^^^^^^^^^^ help: try: `S == true`
 
 error: inequality checks against true can be replaced by a negation
-  --> tests/ui/nonminimal_bool.rs:253:8
+  --> tests/ui/nonminimal_bool.rs:251:8
    |
 LL |     if !S != true {}
-   |        ^^^^^^^^^^ help: try simplifying it as shown: `!!S`
+   |        ^^^^^^^^^^ help: try: `!!S`
 
-error: aborting due to 33 previous errors
+error: aborting due to 31 previous errors
 

From f0563ade3bdbfa86b7d9f48ad371226b97c22189 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Fri, 15 Aug 2025 19:34:12 +0200
Subject: [PATCH 0232/1889] extract `bool_comparison` to a separate file

---
 clippy_lints/src/bool_comparison.rs | 179 ++++++++++++++++++++++++++++
 clippy_lints/src/declared_lints.rs  |   2 +-
 clippy_lints/src/lib.rs             |   3 +-
 clippy_lints/src/needless_bool.rs   | 168 +-------------------------
 4 files changed, 185 insertions(+), 167 deletions(-)
 create mode 100644 clippy_lints/src/bool_comparison.rs

diff --git a/clippy_lints/src/bool_comparison.rs b/clippy_lints/src/bool_comparison.rs
new file mode 100644
index 0000000000000..722095909a6fe
--- /dev/null
+++ b/clippy_lints/src/bool_comparison.rs
@@ -0,0 +1,179 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::sugg::Sugg;
+use clippy_utils::{is_expn_of, peel_blocks, sym};
+use rustc_ast::ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::declare_lint_pass;
+use rustc_span::Span;
+use rustc_span::source_map::Spanned;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for expressions of the form `x == true`,
+    /// `x != true` and order comparisons such as `x < true` (or vice versa) and
+    /// suggest using the variable directly.
+    ///
+    /// ### Why is this bad?
+    /// Unnecessary code.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// if x == true {}
+    /// if y == false {}
+    /// ```
+    /// use `x` directly:
+    /// ```rust,ignore
+    /// if x {}
+    /// if !y {}
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub BOOL_COMPARISON,
+    complexity,
+    "comparing a variable to a boolean, e.g., `if x == true` or `if x != true`"
+}
+
+declare_lint_pass!(BoolComparison => [BOOL_COMPARISON]);
+
+impl<'tcx> LateLintPass<'tcx> for BoolComparison {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
+        if e.span.from_expansion() {
+            return;
+        }
+
+        if let ExprKind::Binary(Spanned { node, .. }, left_side, right_side) = e.kind
+            && is_expn_of(left_side.span, sym::cfg).is_none()
+            && is_expn_of(right_side.span, sym::cfg).is_none()
+            && cx.typeck_results().expr_ty(left_side).is_bool()
+            && cx.typeck_results().expr_ty(right_side).is_bool()
+        {
+            let ignore_case = None::<(fn(_) -> _, &str)>;
+            let ignore_no_literal = None::<(fn(_, _) -> _, &str)>;
+            match node {
+                BinOpKind::Eq => {
+                    let true_case = Some((|h| h, "equality checks against true are unnecessary"));
+                    let false_case = Some((
+                        |h: Sugg<'tcx>| !h,
+                        "equality checks against false can be replaced by a negation",
+                    ));
+                    check_comparison(cx, e, true_case, false_case, true_case, false_case, ignore_no_literal);
+                },
+                BinOpKind::Ne => {
+                    let true_case = Some((
+                        |h: Sugg<'tcx>| !h,
+                        "inequality checks against true can be replaced by a negation",
+                    ));
+                    let false_case = Some((|h| h, "inequality checks against false are unnecessary"));
+                    check_comparison(cx, e, true_case, false_case, true_case, false_case, ignore_no_literal);
+                },
+                BinOpKind::Lt => check_comparison(
+                    cx,
+                    e,
+                    ignore_case,
+                    Some((|h| h, "greater than checks against false are unnecessary")),
+                    Some((
+                        |h: Sugg<'tcx>| !h,
+                        "less than comparison against true can be replaced by a negation",
+                    )),
+                    ignore_case,
+                    Some((
+                        |l: Sugg<'tcx>, r: Sugg<'tcx>| (!l).bit_and(&r),
+                        "order comparisons between booleans can be simplified",
+                    )),
+                ),
+                BinOpKind::Gt => check_comparison(
+                    cx,
+                    e,
+                    Some((
+                        |h: Sugg<'tcx>| !h,
+                        "less than comparison against true can be replaced by a negation",
+                    )),
+                    ignore_case,
+                    ignore_case,
+                    Some((|h| h, "greater than checks against false are unnecessary")),
+                    Some((
+                        |l: Sugg<'tcx>, r: Sugg<'tcx>| l.bit_and(&(!r)),
+                        "order comparisons between booleans can be simplified",
+                    )),
+                ),
+                _ => (),
+            }
+        }
+    }
+}
+
+fn check_comparison<'a, 'tcx>(
+    cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'_>,
+    left_true: Option<(impl FnOnce(Sugg<'a>) -> Sugg<'a>, &'static str)>,
+    left_false: Option<(impl FnOnce(Sugg<'a>) -> Sugg<'a>, &'static str)>,
+    right_true: Option<(impl FnOnce(Sugg<'a>) -> Sugg<'a>, &'static str)>,
+    right_false: Option<(impl FnOnce(Sugg<'a>) -> Sugg<'a>, &'static str)>,
+    no_literal: Option<(impl FnOnce(Sugg<'a>, Sugg<'a>) -> Sugg<'a>, &'static str)>,
+) {
+    if let ExprKind::Binary(_, left_side, right_side) = e.kind {
+        let mut applicability = Applicability::MachineApplicable;
+        // Eliminate parentheses in `e` by using the lo pos of lhs and hi pos of rhs,
+        // calling `source_callsite` make sure macros are handled correctly, see issue #9907
+        let binop_span = left_side.span.source_callsite().to(right_side.span.source_callsite());
+
+        match (fetch_bool_expr(left_side), fetch_bool_expr(right_side)) {
+            (Some(true), None) => left_true.map_or((), |(h, m)| {
+                suggest_bool_comparison(cx, binop_span, right_side, applicability, m, h);
+            }),
+            (None, Some(true)) => right_true.map_or((), |(h, m)| {
+                suggest_bool_comparison(cx, binop_span, left_side, applicability, m, h);
+            }),
+            (Some(false), None) => left_false.map_or((), |(h, m)| {
+                suggest_bool_comparison(cx, binop_span, right_side, applicability, m, h);
+            }),
+            (None, Some(false)) => right_false.map_or((), |(h, m)| {
+                suggest_bool_comparison(cx, binop_span, left_side, applicability, m, h);
+            }),
+            (None, None) => no_literal.map_or((), |(h, m)| {
+                let left_side = Sugg::hir_with_context(cx, left_side, binop_span.ctxt(), "..", &mut applicability);
+                let right_side = Sugg::hir_with_context(cx, right_side, binop_span.ctxt(), "..", &mut applicability);
+                span_lint_and_sugg(
+                    cx,
+                    BOOL_COMPARISON,
+                    binop_span,
+                    m,
+                    "try",
+                    h(left_side, right_side).into_string(),
+                    applicability,
+                );
+            }),
+            _ => (),
+        }
+    }
+}
+
+fn suggest_bool_comparison<'a, 'tcx>(
+    cx: &LateContext<'tcx>,
+    span: Span,
+    expr: &Expr<'_>,
+    mut app: Applicability,
+    message: &'static str,
+    conv_hint: impl FnOnce(Sugg<'a>) -> Sugg<'a>,
+) {
+    let hint = Sugg::hir_with_context(cx, expr, span.ctxt(), "..", &mut app);
+    span_lint_and_sugg(
+        cx,
+        BOOL_COMPARISON,
+        span,
+        message,
+        "try",
+        conv_hint(hint).into_string(),
+        app,
+    );
+}
+
+fn fetch_bool_expr(expr: &Expr<'_>) -> Option<bool> {
+    if let ExprKind::Lit(lit_ptr) = peel_blocks(expr).kind
+        && let LitKind::Bool(value) = lit_ptr.node
+    {
+        return Some(value);
+    }
+    None
+}
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index e67e8d9070f2c..d0c7443a4a4b9 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -35,6 +35,7 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::await_holding_invalid::AWAIT_HOLDING_REFCELL_REF_INFO,
     crate::blocks_in_conditions::BLOCKS_IN_CONDITIONS_INFO,
     crate::bool_assert_comparison::BOOL_ASSERT_COMPARISON_INFO,
+    crate::bool_comparison::BOOL_COMPARISON_INFO,
     crate::bool_to_int_with_if::BOOL_TO_INT_WITH_IF_INFO,
     crate::booleans::NONMINIMAL_BOOL_INFO,
     crate::booleans::OVERLY_COMPLEX_BOOL_EXPR_INFO,
@@ -538,7 +539,6 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::mutex_atomic::MUTEX_ATOMIC_INFO,
     crate::mutex_atomic::MUTEX_INTEGER_INFO,
     crate::needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE_INFO,
-    crate::needless_bool::BOOL_COMPARISON_INFO,
     crate::needless_bool::NEEDLESS_BOOL_INFO,
     crate::needless_bool::NEEDLESS_BOOL_ASSIGN_INFO,
     crate::needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d468993e74445..5960f8e54cd47 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -84,6 +84,7 @@ mod attrs;
 mod await_holding_invalid;
 mod blocks_in_conditions;
 mod bool_assert_comparison;
+mod bool_comparison;
 mod bool_to_int_with_if;
 mod booleans;
 mod borrow_deref_ref;
@@ -477,7 +478,7 @@ pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Co
     store.register_late_pass(|_| Box::new(float_literal::FloatLiteral));
     store.register_late_pass(|_| Box::new(ptr::Ptr));
     store.register_late_pass(|_| Box::new(needless_bool::NeedlessBool));
-    store.register_late_pass(|_| Box::new(needless_bool::BoolComparison));
+    store.register_late_pass(|_| Box::new(bool_comparison::BoolComparison));
     store.register_late_pass(|_| Box::new(needless_for_each::NeedlessForEach));
     store.register_late_pass(|_| Box::new(misc::LintPass));
     store.register_late_pass(|_| Box::new(eta_reduction::EtaReduction));
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index 49d41a3af3ddc..854e927aa2f78 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -2,16 +2,14 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{
-    SpanlessEq, get_parent_expr, higher, is_block_like, is_else_clause, is_expn_of, is_parent_stmt,
-    is_receiver_of_method_call, peel_blocks, peel_blocks_with_stmt, span_contains_comment, sym,
+    SpanlessEq, get_parent_expr, higher, is_block_like, is_else_clause, is_parent_stmt, is_receiver_of_method_call,
+    peel_blocks, peel_blocks_with_stmt, span_contains_comment,
 };
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
-use rustc_span::Span;
-use rustc_span::source_map::Spanned;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -50,31 +48,6 @@ declare_clippy_lint! {
     "if-statements with plain booleans in the then- and else-clause, e.g., `if p { true } else { false }`"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for expressions of the form `x == true`,
-    /// `x != true` and order comparisons such as `x < true` (or vice versa) and
-    /// suggest using the variable directly.
-    ///
-    /// ### Why is this bad?
-    /// Unnecessary code.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// if x == true {}
-    /// if y == false {}
-    /// ```
-    /// use `x` directly:
-    /// ```rust,ignore
-    /// if x {}
-    /// if !y {}
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub BOOL_COMPARISON,
-    complexity,
-    "comparing a variable to a boolean, e.g., `if x == true` or `if x != true`"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for expressions of the form `if c { x = true } else { x = false }`
@@ -224,141 +197,6 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBool {
     }
 }
 
-declare_lint_pass!(BoolComparison => [BOOL_COMPARISON]);
-
-impl<'tcx> LateLintPass<'tcx> for BoolComparison {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        if e.span.from_expansion() {
-            return;
-        }
-
-        if let ExprKind::Binary(Spanned { node, .. }, left_side, right_side) = e.kind
-            && is_expn_of(left_side.span, sym::cfg).is_none()
-            && is_expn_of(right_side.span, sym::cfg).is_none()
-            && cx.typeck_results().expr_ty(left_side).is_bool()
-            && cx.typeck_results().expr_ty(right_side).is_bool()
-        {
-            let ignore_case = None::<(fn(_) -> _, &str)>;
-            let ignore_no_literal = None::<(fn(_, _) -> _, &str)>;
-            match node {
-                BinOpKind::Eq => {
-                    let true_case = Some((|h| h, "equality checks against true are unnecessary"));
-                    let false_case = Some((
-                        |h: Sugg<'tcx>| !h,
-                        "equality checks against false can be replaced by a negation",
-                    ));
-                    check_comparison(cx, e, true_case, false_case, true_case, false_case, ignore_no_literal);
-                },
-                BinOpKind::Ne => {
-                    let true_case = Some((
-                        |h: Sugg<'tcx>| !h,
-                        "inequality checks against true can be replaced by a negation",
-                    ));
-                    let false_case = Some((|h| h, "inequality checks against false are unnecessary"));
-                    check_comparison(cx, e, true_case, false_case, true_case, false_case, ignore_no_literal);
-                },
-                BinOpKind::Lt => check_comparison(
-                    cx,
-                    e,
-                    ignore_case,
-                    Some((|h| h, "greater than checks against false are unnecessary")),
-                    Some((
-                        |h: Sugg<'tcx>| !h,
-                        "less than comparison against true can be replaced by a negation",
-                    )),
-                    ignore_case,
-                    Some((
-                        |l: Sugg<'tcx>, r: Sugg<'tcx>| (!l).bit_and(&r),
-                        "order comparisons between booleans can be simplified",
-                    )),
-                ),
-                BinOpKind::Gt => check_comparison(
-                    cx,
-                    e,
-                    Some((
-                        |h: Sugg<'tcx>| !h,
-                        "less than comparison against true can be replaced by a negation",
-                    )),
-                    ignore_case,
-                    ignore_case,
-                    Some((|h| h, "greater than checks against false are unnecessary")),
-                    Some((
-                        |l: Sugg<'tcx>, r: Sugg<'tcx>| l.bit_and(&(!r)),
-                        "order comparisons between booleans can be simplified",
-                    )),
-                ),
-                _ => (),
-            }
-        }
-    }
-}
-
-fn check_comparison<'a, 'tcx>(
-    cx: &LateContext<'tcx>,
-    e: &'tcx Expr<'_>,
-    left_true: Option<(impl FnOnce(Sugg<'a>) -> Sugg<'a>, &'static str)>,
-    left_false: Option<(impl FnOnce(Sugg<'a>) -> Sugg<'a>, &'static str)>,
-    right_true: Option<(impl FnOnce(Sugg<'a>) -> Sugg<'a>, &'static str)>,
-    right_false: Option<(impl FnOnce(Sugg<'a>) -> Sugg<'a>, &'static str)>,
-    no_literal: Option<(impl FnOnce(Sugg<'a>, Sugg<'a>) -> Sugg<'a>, &'static str)>,
-) {
-    if let ExprKind::Binary(_, left_side, right_side) = e.kind {
-        let mut applicability = Applicability::MachineApplicable;
-        // Eliminate parentheses in `e` by using the lo pos of lhs and hi pos of rhs,
-        // calling `source_callsite` make sure macros are handled correctly, see issue #9907
-        let binop_span = left_side.span.source_callsite().to(right_side.span.source_callsite());
-
-        match (fetch_bool_expr(left_side), fetch_bool_expr(right_side)) {
-            (Some(true), None) => left_true.map_or((), |(h, m)| {
-                suggest_bool_comparison(cx, binop_span, right_side, applicability, m, h);
-            }),
-            (None, Some(true)) => right_true.map_or((), |(h, m)| {
-                suggest_bool_comparison(cx, binop_span, left_side, applicability, m, h);
-            }),
-            (Some(false), None) => left_false.map_or((), |(h, m)| {
-                suggest_bool_comparison(cx, binop_span, right_side, applicability, m, h);
-            }),
-            (None, Some(false)) => right_false.map_or((), |(h, m)| {
-                suggest_bool_comparison(cx, binop_span, left_side, applicability, m, h);
-            }),
-            (None, None) => no_literal.map_or((), |(h, m)| {
-                let left_side = Sugg::hir_with_context(cx, left_side, binop_span.ctxt(), "..", &mut applicability);
-                let right_side = Sugg::hir_with_context(cx, right_side, binop_span.ctxt(), "..", &mut applicability);
-                span_lint_and_sugg(
-                    cx,
-                    BOOL_COMPARISON,
-                    binop_span,
-                    m,
-                    "try",
-                    h(left_side, right_side).into_string(),
-                    applicability,
-                );
-            }),
-            _ => (),
-        }
-    }
-}
-
-fn suggest_bool_comparison<'a, 'tcx>(
-    cx: &LateContext<'tcx>,
-    span: Span,
-    expr: &Expr<'_>,
-    mut app: Applicability,
-    message: &'static str,
-    conv_hint: impl FnOnce(Sugg<'a>) -> Sugg<'a>,
-) {
-    let hint = Sugg::hir_with_context(cx, expr, span.ctxt(), "..", &mut app);
-    span_lint_and_sugg(
-        cx,
-        BOOL_COMPARISON,
-        span,
-        message,
-        "try",
-        conv_hint(hint).into_string(),
-        app,
-    );
-}
-
 enum Expression {
     Bool(bool),
     RetBool(bool),

From eb009082321f15f2a6faed1198d4e31d2d163ff9 Mon Sep 17 00:00:00 2001
From: yanglsh <yanglsh@shanghaitech.edu.cn>
Date: Sat, 23 Aug 2025 02:30:44 +0800
Subject: [PATCH 0233/1889] fix: `derivable_impls` FN when enum is qualified
 with `Self`

---
 clippy_lints/src/derivable_impls.rs          | 64 +++++++++++++-------
 tests/ui/derivable_impls.fixed               | 12 ++++
 tests/ui/derivable_impls.rs                  | 15 +++++
 tests/ui/derivable_impls.stderr              | 25 +++++++-
 tests/ui/derivable_impls_derive_const.fixed  |  2 +-
 tests/ui/derivable_impls_derive_const.stderr |  2 +-
 6 files changed, 95 insertions(+), 25 deletions(-)

diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index c58aca6a52ba3..06c2393e0a39f 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -10,7 +10,7 @@ use rustc_hir::{
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::adjustment::{Adjust, PointerCoercion};
-use rustc_middle::ty::{self, AdtDef, GenericArgsRef, Ty, TypeckResults};
+use rustc_middle::ty::{self, AdtDef, GenericArgsRef, Ty, TypeckResults, VariantDef};
 use rustc_session::impl_lint_pass;
 use rustc_span::sym;
 
@@ -86,13 +86,9 @@ fn contains_trait_object(ty: Ty<'_>) -> bool {
 }
 
 fn determine_derive_macro(cx: &LateContext<'_>, is_const: bool) -> Option<&'static str> {
-    if is_const {
-        if !cx.tcx.features().enabled(sym::derive_const) {
-            return None;
-        }
-        return Some("derive_const");
-    }
-    Some("derive")
+    (!is_const)
+        .then_some("derive")
+        .or_else(|| cx.tcx.features().enabled(sym::derive_const).then_some("derive_const"))
 }
 
 #[expect(clippy::too_many_arguments)]
@@ -137,18 +133,18 @@ fn check_struct<'tcx>(
         ExprKind::Tup(fields) => fields.iter().all(is_default_without_adjusts),
         ExprKind::Call(callee, args) if is_path_self(callee) => args.iter().all(is_default_without_adjusts),
         ExprKind::Struct(_, fields, _) => fields.iter().all(|ef| is_default_without_adjusts(ef.expr)),
-        _ => false,
-    };
-
-    let Some(derive_snippet) = determine_derive_macro(cx, is_const) else {
-        return;
+        _ => return,
     };
 
-    if should_emit {
+    if should_emit && let Some(derive_snippet) = determine_derive_macro(cx, is_const) {
         let struct_span = cx.tcx.def_span(adt_def.did());
+        let indent_enum = indent_of(cx, struct_span).unwrap_or(0);
         let suggestions = vec![
             (item.span, String::new()), // Remove the manual implementation
-            (struct_span.shrink_to_lo(), format!("#[{derive_snippet}(Default)]\n")), // Add the derive attribute
+            (
+                struct_span.shrink_to_lo(),
+                format!("#[{derive_snippet}(Default)]\n{}", " ".repeat(indent_enum)),
+            ), // Add the derive attribute
         ];
 
         span_lint_and_then(cx, DERIVABLE_IMPLS, item.span, "this `impl` can be derived", |diag| {
@@ -161,17 +157,41 @@ fn check_struct<'tcx>(
     }
 }
 
+fn extract_enum_variant<'tcx>(
+    cx: &LateContext<'tcx>,
+    func_expr: &'tcx Expr<'tcx>,
+    adt_def: AdtDef<'tcx>,
+) -> Option<&'tcx VariantDef> {
+    match &peel_blocks(func_expr).kind {
+        ExprKind::Path(QPath::Resolved(None, p))
+            if let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Const), id) = p.res
+                && let variant_id = cx.tcx.parent(id)
+                && let Some(variant_def) = adt_def.variants().iter().find(|v| v.def_id == variant_id) =>
+        {
+            Some(variant_def)
+        },
+        ExprKind::Path(QPath::TypeRelative(ty, segment))
+            if let TyKind::Path(QPath::Resolved(None, p)) = &ty.kind
+                && let Res::SelfTyAlias {
+                    is_trait_impl: true, ..
+                } = p.res
+                && let variant_ident = segment.ident
+                && let Some(variant_def) = adt_def.variants().iter().find(|v| v.ident(cx.tcx) == variant_ident) =>
+        {
+            Some(variant_def)
+        },
+        _ => None,
+    }
+}
+
 fn check_enum<'tcx>(
     cx: &LateContext<'tcx>,
-    item: &'tcx Item<'_>,
-    func_expr: &Expr<'_>,
-    adt_def: AdtDef<'_>,
+    item: &'tcx Item<'tcx>,
+    func_expr: &'tcx Expr<'tcx>,
+    adt_def: AdtDef<'tcx>,
     is_const: bool,
 ) {
-    if let ExprKind::Path(QPath::Resolved(None, p)) = &peel_blocks(func_expr).kind
-        && let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Const), id) = p.res
-        && let variant_id = cx.tcx.parent(id)
-        && let Some(variant_def) = adt_def.variants().iter().find(|v| v.def_id == variant_id)
+    if let Some(variant_def) = extract_enum_variant(cx, func_expr, adt_def)
         && variant_def.fields.is_empty()
         && !variant_def.is_field_list_non_exhaustive()
     {
diff --git a/tests/ui/derivable_impls.fixed b/tests/ui/derivable_impls.fixed
index f549aee9eb1e9..9f9e4e253c3c4 100644
--- a/tests/ui/derivable_impls.fixed
+++ b/tests/ui/derivable_impls.fixed
@@ -352,4 +352,16 @@ mod issue15493 {
     }
 }
 
+mod issue15536 {
+    #[derive(Copy, Clone)]
+    #[derive(Default)]
+    enum Bar {
+        #[default]
+        A,
+        B,
+    }
+
+    
+}
+
 fn main() {}
diff --git a/tests/ui/derivable_impls.rs b/tests/ui/derivable_impls.rs
index 1e06ff6120bd2..74a793b9a70e6 100644
--- a/tests/ui/derivable_impls.rs
+++ b/tests/ui/derivable_impls.rs
@@ -422,4 +422,19 @@ mod issue15493 {
     }
 }
 
+mod issue15536 {
+    #[derive(Copy, Clone)]
+    enum Bar {
+        A,
+        B,
+    }
+
+    impl Default for Bar {
+        //~^ derivable_impls
+        fn default() -> Self {
+            Self::A
+        }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/derivable_impls.stderr b/tests/ui/derivable_impls.stderr
index d473f2a379c54..cd46414cb4a8a 100644
--- a/tests/ui/derivable_impls.stderr
+++ b/tests/ui/derivable_impls.stderr
@@ -187,5 +187,28 @@ LL ~     #[default]
 LL ~     Bar,
    |
 
-error: aborting due to 11 previous errors
+error: this `impl` can be derived
+  --> tests/ui/derivable_impls.rs:432:5
+   |
+LL | /     impl Default for Bar {
+LL | |
+LL | |         fn default() -> Self {
+LL | |             Self::A
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+help: replace the manual implementation with a derive attribute and mark the default variant
+   |
+LL ~     #[derive(Default)]
+LL ~     enum Bar {
+LL ~         #[default]
+LL ~         A,
+LL |         B,
+LL |     }
+LL |
+LL ~     
+   |
+
+error: aborting due to 12 previous errors
 
diff --git a/tests/ui/derivable_impls_derive_const.fixed b/tests/ui/derivable_impls_derive_const.fixed
index 6df43f7fb7633..f0d8d2d240924 100644
--- a/tests/ui/derivable_impls_derive_const.fixed
+++ b/tests/ui/derivable_impls_derive_const.fixed
@@ -7,7 +7,7 @@ mod issue15493 {
     #[derive(Copy, Clone)]
     #[repr(transparent)]
     #[derive_const(Default)]
-struct Foo(u64);
+    struct Foo(u64);
 
     
 
diff --git a/tests/ui/derivable_impls_derive_const.stderr b/tests/ui/derivable_impls_derive_const.stderr
index dd185676c7709..196bac185ddaa 100644
--- a/tests/ui/derivable_impls_derive_const.stderr
+++ b/tests/ui/derivable_impls_derive_const.stderr
@@ -14,7 +14,7 @@ LL | |     }
 help: replace the manual implementation with a derive attribute
    |
 LL ~     #[derive_const(Default)]
-LL ~ struct Foo(u64);
+LL ~     struct Foo(u64);
 LL |
 LL ~     
    |

From e01cf9bd4845cb1b1e3b89e93d6731540bc489b7 Mon Sep 17 00:00:00 2001
From: yanglsh <yanglsh@shanghaitech.edu.cn>
Date: Sat, 23 Aug 2025 06:13:35 +0800
Subject: [PATCH 0234/1889] Apply `derivable_impls` to Clippy itself

---
 .../src/matches/significant_drop_in_scrutinee.rs         | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/clippy_lints/src/matches/significant_drop_in_scrutinee.rs b/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
index 027dd7ce0534a..81fecc87256c4 100644
--- a/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
+++ b/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
@@ -226,11 +226,12 @@ impl<'a, 'tcx> SigDropChecker<'a, 'tcx> {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug, Default)]
 enum SigDropHolder {
     /// No values with significant drop present in this expression.
     ///
     /// Expressions that we've emitted lints do not count.
+    #[default]
     None,
     /// Some field in this expression references to values with significant drop.
     ///
@@ -244,12 +245,6 @@ enum SigDropHolder {
     Moved,
 }
 
-impl Default for SigDropHolder {
-    fn default() -> Self {
-        Self::None
-    }
-}
-
 struct SigDropHelper<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     parent_expr: Option<&'tcx Expr<'tcx>>,

From f794588895972477a2639e7949d5be7d253e30da Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sat, 23 Aug 2025 00:43:00 +0200
Subject: [PATCH 0235/1889] Activate `range-diff` feature of triagebot

This [feature](https://forge.rust-lang.org/triagebot/range-diff.html)
shows the changes when a PR is rebased, while the GitHub UI would mix
the actual changes with the ones coming from the rebase.
---
 triagebot.toml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/triagebot.toml b/triagebot.toml
index 805baf2af6dd0..79b6c2b792ffd 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -49,6 +49,9 @@ new_pr = true
 # These labels are set when there are unresolved concerns, removed otherwise
 labels = ["S-waiting-on-concerns"]
 
+# Show differences when a PR is rebased
+[range-diff]
+
 [assign]
 contributing_url = "https://github.com/rust-lang/rust-clippy/blob/master/CONTRIBUTING.md"
 users_on_vacation = [

From 0c24079986c89c4613f43e31b7098c4ba1096ce3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Sat, 23 Aug 2025 10:14:52 +0200
Subject: [PATCH 0236/1889] Remove profile section from Clippy

To avoid workspace warnings.
---
 Cargo.toml | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 2add525b7e8ae..b3618932ded7d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -65,13 +65,6 @@ harness = false
 name = "dogfood"
 harness = false
 
-# quine-mc_cluskey makes up a significant part of the runtime in dogfood
-# due to the number of conditions in the clippy_lints crate
-# and enabling optimizations for that specific dependency helps a bit
-# without increasing total build times.
-[profile.dev.package.quine-mc_cluskey]
-opt-level = 3
-
 [lints.rust.unexpected_cfgs]
 level = "warn"
 check-cfg = ['cfg(bootstrap)']

From 2c28135116a99f1939ffc7f1bcb3b8580f4153c6 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sat, 23 Aug 2025 10:31:38 +0200
Subject: [PATCH 0237/1889] Use `.cargo/config.toml` for local compilation
 options

This will be ignored when Clippy is part of the compiler workspace.
Using `Cargo.toml` would complain about profiles defined outside the
top-level when run from the compiler repository.
---
 .cargo/config.toml | 7 +++++++
 Cargo.toml         | 7 -------
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/.cargo/config.toml b/.cargo/config.toml
index d9c635df5dc79..a09bf95e87bd6 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -23,3 +23,10 @@ split-debuginfo = "unpacked"
 rustflags = ["--remap-path-prefix", "=clippy_dev"]
 [profile.dev.package.lintcheck]
 rustflags = ["--remap-path-prefix", "=lintcheck"]
+
+# quine-mc_cluskey makes up a significant part of the runtime in dogfood
+# due to the number of conditions in the clippy_lints crate
+# and enabling optimizations for that specific dependency helps a bit
+# without increasing total build times.
+[profile.dev.package.quine-mc_cluskey]
+opt-level = 3
diff --git a/Cargo.toml b/Cargo.toml
index 2add525b7e8ae..b3618932ded7d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -65,13 +65,6 @@ harness = false
 name = "dogfood"
 harness = false
 
-# quine-mc_cluskey makes up a significant part of the runtime in dogfood
-# due to the number of conditions in the clippy_lints crate
-# and enabling optimizations for that specific dependency helps a bit
-# without increasing total build times.
-[profile.dev.package.quine-mc_cluskey]
-opt-level = 3
-
 [lints.rust.unexpected_cfgs]
 level = "warn"
 check-cfg = ['cfg(bootstrap)']

From 183fbdc89b5f7f3944644a5d3d1c762d7ea35f90 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Sat, 23 Aug 2025 15:52:54 +0800
Subject: [PATCH 0238/1889] Fix `else` completion in `let _ = if x {} $0`

---
 .../ide-completion/src/context/analysis.rs    |  11 +-
 .../ide-completion/src/tests/expression.rs    | 347 ++++++++++++++++++
 2 files changed, 355 insertions(+), 3 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
index 6eb1727b3319e..fc2d9e41989b8 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
@@ -943,9 +943,14 @@ fn classify_name_ref<'db>(
             };
             let prev_sibling = non_trivia_sibling(node.into(), Direction::Prev)?.into_node()?;
 
-            ast::ExprStmt::cast(prev_sibling.clone())
-                .and_then(|it| it.expr())
-                .or_else(|| ast::Expr::cast(prev_sibling))
+            match_ast! {
+                match prev_sibling {
+                    ast::ExprStmt(stmt) => stmt.expr().filter(|_| stmt.semicolon_token().is_none()),
+                    ast::LetStmt(stmt) => stmt.initializer().filter(|_| stmt.semicolon_token().is_none()),
+                    ast::Expr(expr) => Some(expr),
+                    _ => None,
+                }
+            }
         })();
         matches!(prev_expr, Some(ast::Expr::IfExpr(_)))
     };
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs b/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
index 33f729f016645..da5dddc6e8d7d 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
@@ -1210,6 +1210,353 @@ fn foo() { if foo {} el$0 { let x = 92; } }
             sn ppd
         "#]],
     );
+    check(
+        r#"
+fn foo() { let x = if foo {} $0 }
+"#,
+        expect![[r#"
+            fn foo()  fn()
+            bt u32     u32
+            kw async
+            kw const
+            kw crate::
+            kw else
+            kw else if
+            kw enum
+            kw extern
+            kw false
+            kw fn
+            kw for
+            kw if
+            kw if let
+            kw impl
+            kw impl for
+            kw let
+            kw letm
+            kw loop
+            kw match
+            kw mod
+            kw return
+            kw self::
+            kw static
+            kw struct
+            kw trait
+            kw true
+            kw type
+            kw union
+            kw unsafe
+            kw use
+            kw while
+            kw while let
+            sn macro_rules
+            sn pd
+            sn ppd
+        "#]],
+    );
+    check(
+        r#"
+fn foo() { let x = if foo {} el$0 }
+"#,
+        expect![[r#"
+            fn foo()  fn()
+            lc x        ()
+            bt u32     u32
+            kw async
+            kw const
+            kw crate::
+            kw else
+            kw else if
+            kw enum
+            kw extern
+            kw false
+            kw fn
+            kw for
+            kw if
+            kw if let
+            kw impl
+            kw impl for
+            kw let
+            kw letm
+            kw loop
+            kw match
+            kw mod
+            kw return
+            kw self::
+            kw static
+            kw struct
+            kw trait
+            kw true
+            kw type
+            kw union
+            kw unsafe
+            kw use
+            kw while
+            kw while let
+            sn macro_rules
+            sn pd
+            sn ppd
+        "#]],
+    );
+    check(
+        r#"
+fn foo() { let x = if foo {} $0 let y = 92; }
+"#,
+        expect![[r#"
+            fn foo()  fn()
+            bt u32     u32
+            kw async
+            kw const
+            kw crate::
+            kw else
+            kw else if
+            kw enum
+            kw extern
+            kw false
+            kw fn
+            kw for
+            kw if
+            kw if let
+            kw impl
+            kw impl for
+            kw let
+            kw letm
+            kw loop
+            kw match
+            kw mod
+            kw return
+            kw self::
+            kw static
+            kw struct
+            kw trait
+            kw true
+            kw type
+            kw union
+            kw unsafe
+            kw use
+            kw while
+            kw while let
+            sn macro_rules
+            sn pd
+            sn ppd
+        "#]],
+    );
+    check(
+        r#"
+fn foo() { let x = if foo {} el$0 let y = 92; }
+"#,
+        expect![[r#"
+            fn foo()  fn()
+            lc x        ()
+            bt u32     u32
+            kw async
+            kw const
+            kw crate::
+            kw else
+            kw else if
+            kw enum
+            kw extern
+            kw false
+            kw fn
+            kw for
+            kw if
+            kw if let
+            kw impl
+            kw impl for
+            kw let
+            kw letm
+            kw loop
+            kw match
+            kw mod
+            kw return
+            kw self::
+            kw static
+            kw struct
+            kw trait
+            kw true
+            kw type
+            kw union
+            kw unsafe
+            kw use
+            kw while
+            kw while let
+            sn macro_rules
+            sn pd
+            sn ppd
+        "#]],
+    );
+    check(
+        r#"
+fn foo() { let x = if foo {} $0; }
+"#,
+        expect![[r#"
+            fn foo()  fn()
+            bt u32     u32
+            kw async
+            kw const
+            kw crate::
+            kw else
+            kw else if
+            kw enum
+            kw extern
+            kw false
+            kw fn
+            kw for
+            kw if
+            kw if let
+            kw impl
+            kw impl for
+            kw let
+            kw letm
+            kw loop
+            kw match
+            kw mod
+            kw return
+            kw self::
+            kw static
+            kw struct
+            kw trait
+            kw true
+            kw type
+            kw union
+            kw unsafe
+            kw use
+            kw while
+            kw while let
+            sn macro_rules
+            sn pd
+            sn ppd
+        "#]],
+    );
+    check(
+        r#"
+fn foo() { let x = if foo {} el$0; }
+"#,
+        expect![[r#"
+            fn foo()  fn()
+            lc x        ()
+            bt u32     u32
+            kw async
+            kw const
+            kw crate::
+            kw else
+            kw else if
+            kw enum
+            kw extern
+            kw false
+            kw fn
+            kw for
+            kw if
+            kw if let
+            kw impl
+            kw impl for
+            kw let
+            kw letm
+            kw loop
+            kw match
+            kw mod
+            kw return
+            kw self::
+            kw static
+            kw struct
+            kw trait
+            kw true
+            kw type
+            kw union
+            kw unsafe
+            kw use
+            kw while
+            kw while let
+            sn macro_rules
+            sn pd
+            sn ppd
+        "#]],
+    );
+    check(
+        r#"
+fn foo() { let x = if foo {} $0; let y = 92; }
+"#,
+        expect![[r#"
+            fn foo()  fn()
+            bt u32     u32
+            kw async
+            kw const
+            kw crate::
+            kw else
+            kw else if
+            kw enum
+            kw extern
+            kw false
+            kw fn
+            kw for
+            kw if
+            kw if let
+            kw impl
+            kw impl for
+            kw let
+            kw letm
+            kw loop
+            kw match
+            kw mod
+            kw return
+            kw self::
+            kw static
+            kw struct
+            kw trait
+            kw true
+            kw type
+            kw union
+            kw unsafe
+            kw use
+            kw while
+            kw while let
+            sn macro_rules
+            sn pd
+            sn ppd
+        "#]],
+    );
+    check(
+        r#"
+fn foo() { let x = if foo {} $0 else {}; }
+"#,
+        expect![[r#"
+            fn foo    fn()
+            bt u32     u32
+            kw async
+            kw const
+            kw crate::
+            kw else
+            kw else if
+            kw enum
+            kw extern
+            kw false
+            kw fn
+            kw for
+            kw if
+            kw if let
+            kw impl
+            kw impl for
+            kw let
+            kw letm
+            kw loop
+            kw match
+            kw mod
+            kw return
+            kw self::
+            kw static
+            kw struct
+            kw trait
+            kw true
+            kw type
+            kw union
+            kw unsafe
+            kw use
+            kw while
+            kw while let
+            sn macro_rules
+            sn pd
+            sn ppd
+        "#]],
+    );
 }
 
 #[test]

From 8a988658a7caba4d7caf6926ba3b78e5f52d54f6 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sat, 23 Aug 2025 11:46:49 +0200
Subject: [PATCH 0239/1889] Detect infinite loop in `async fn` not returning
 `!`

This fixes an overzealous change made to avoid signaling infinite loops
in anonymous blocks that may never be used.
---
 clippy_lints/src/loops/infinite_loop.rs |  9 +++++++--
 tests/ui/infinite_loops.rs              | 15 +++++++++++++++
 tests/ui/infinite_loops.stderr          | 12 +++++++++++-
 3 files changed, 33 insertions(+), 3 deletions(-)

diff --git a/clippy_lints/src/loops/infinite_loop.rs b/clippy_lints/src/loops/infinite_loop.rs
index a71e6963f8ca2..74c0b17801898 100644
--- a/clippy_lints/src/loops/infinite_loop.rs
+++ b/clippy_lints/src/loops/infinite_loop.rs
@@ -4,7 +4,8 @@ use hir::intravisit::{Visitor, walk_expr};
 use rustc_ast::Label;
 use rustc_errors::Applicability;
 use rustc_hir::{
-    self as hir, Closure, ClosureKind, CoroutineDesugaring, CoroutineKind, Expr, ExprKind, FnRetTy, FnSig, Node, TyKind,
+    self as hir, Closure, ClosureKind, CoroutineDesugaring, CoroutineKind, CoroutineSource, Expr, ExprKind, FnRetTy,
+    FnSig, Node, TyKind,
 };
 use rustc_lint::{LateContext, LintContext};
 use rustc_span::sym;
@@ -73,7 +74,11 @@ fn is_inside_unawaited_async_block(cx: &LateContext<'_>, expr: &Expr<'_>) -> boo
         if let Node::Expr(Expr {
             kind:
                 ExprKind::Closure(Closure {
-                    kind: ClosureKind::Coroutine(CoroutineKind::Desugared(CoroutineDesugaring::Async, _)),
+                    kind:
+                        ClosureKind::Coroutine(CoroutineKind::Desugared(
+                            CoroutineDesugaring::Async,
+                            CoroutineSource::Block | CoroutineSource::Closure,
+                        )),
                     ..
                 }),
             ..
diff --git a/tests/ui/infinite_loops.rs b/tests/ui/infinite_loops.rs
index 9b8c39331970c..7d01a7fb61fc1 100644
--- a/tests/ui/infinite_loops.rs
+++ b/tests/ui/infinite_loops.rs
@@ -521,4 +521,19 @@ mod tokio_spawn_test {
     }
 }
 
+mod issue15541 {
+    async fn good() -> ! {
+        loop {
+            std::future::pending().await
+        }
+    }
+
+    async fn bad() {
+        //~v infinite_loop
+        loop {
+            std::future::pending().await
+        }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/infinite_loops.stderr b/tests/ui/infinite_loops.stderr
index 4c6b6f725f130..319f1e5012b64 100644
--- a/tests/ui/infinite_loops.stderr
+++ b/tests/ui/infinite_loops.stderr
@@ -333,5 +333,15 @@ LL | |             }
    |
    = help: if this is not intended, try adding a `break` or `return` condition in the loop
 
-error: aborting due to 23 previous errors
+error: infinite loop detected
+  --> tests/ui/infinite_loops.rs:533:9
+   |
+LL | /         loop {
+LL | |             std::future::pending().await
+LL | |         }
+   | |_________^
+   |
+   = help: if this is not intended, try adding a `break` or `return` condition in the loop
+
+error: aborting due to 24 previous errors
 

From 804b41e949b07e907175b6f0a7f8c74ef5f9f9ee Mon Sep 17 00:00:00 2001
From: Stypox <stypox@pm.me>
Date: Tue, 12 Aug 2025 22:25:54 +0200
Subject: [PATCH 0240/1889] Account for time spent tracing, use RDTSC for
 faster time

---
 src/tools/miri/src/bin/log/mod.rs             |   1 +
 src/tools/miri/src/bin/log/tracing_chrome.rs  | 177 +++++++++--------
 .../src/bin/log/tracing_chrome_instant.rs     | 183 ++++++++++++++++++
 3 files changed, 283 insertions(+), 78 deletions(-)
 create mode 100644 src/tools/miri/src/bin/log/tracing_chrome_instant.rs

diff --git a/src/tools/miri/src/bin/log/mod.rs b/src/tools/miri/src/bin/log/mod.rs
index f3b2fdb5348e0..22f74dd46b540 100644
--- a/src/tools/miri/src/bin/log/mod.rs
+++ b/src/tools/miri/src/bin/log/mod.rs
@@ -1,2 +1,3 @@
 pub mod setup;
 mod tracing_chrome;
+mod tracing_chrome_instant;
diff --git a/src/tools/miri/src/bin/log/tracing_chrome.rs b/src/tools/miri/src/bin/log/tracing_chrome.rs
index 3379816550cfe..310887a13a5ce 100644
--- a/src/tools/miri/src/bin/log/tracing_chrome.rs
+++ b/src/tools/miri/src/bin/log/tracing_chrome.rs
@@ -7,12 +7,15 @@
 //! (`git log -- path/to/tracing_chrome.rs`), but in summary:
 //! - the file attributes were changed and `extern crate` was added at the top
 //! - if a tracing span has a field called "tracing_separate_thread", it will be given a separate
-//! span ID even in [TraceStyle::Threaded] mode, to make it appear on a separate line when viewing
-//! the trace in <https://ui.perfetto.dev>. This is the syntax to trigger this behavior:
+//!   span ID even in [TraceStyle::Threaded] mode, to make it appear on a separate line when viewing
+//!   the trace in <https://ui.perfetto.dev>. This is the syntax to trigger this behavior:
 //!   ```rust
 //!   tracing::info_span!("my_span", tracing_separate_thread = tracing::field::Empty, /* ... */)
 //!   ```
-//! - use i64 instead of u64 for the "id" in [ChromeLayer::get_root_id] to be compatible with Perfetto
+//! - use i64 instead of u64 for the "id" in [ChromeLayer::get_root_id] to be compatible with
+//!   Perfetto
+//! - use [ChromeLayer::with_elapsed_micros_subtracting_tracing] to make time measurements faster on
+//!   Linux x86/x86_64 and to subtract time spent tracing from the timestamps in the trace file
 //!
 //! Depending on the tracing-chrome crate from crates.io is unfortunately not possible, since it
 //! depends on `tracing_core` which conflicts with rustc_private's `tracing_core` (meaning it would
@@ -50,9 +53,22 @@ use std::{
     thread::JoinHandle,
 };
 
+use crate::log::tracing_chrome_instant::TracingChromeInstant;
+
+/// Contains thread-local data for threads that send tracing spans or events.
+struct ThreadData {
+    /// A unique ID for this thread, will populate "tid" field in the output trace file.
+    tid: usize,
+    /// A clone of [ChromeLayer::out] to avoid the expensive operation of accessing a mutex
+    /// every time. This is used to send [Message]s to the thread that saves trace data to file.
+    out: Sender<Message>,
+    /// The instant in time this thread was started. All events happening on this thread will be
+    /// saved to the trace file with a timestamp (the "ts" field) measured relative to this instant.
+    start: TracingChromeInstant,
+}
+
 thread_local! {
-    static OUT: RefCell<Option<Sender<Message>>> = const { RefCell::new(None) };
-    static TID: RefCell<Option<usize>> = const { RefCell::new(None) };
+    static THREAD_DATA: RefCell<Option<ThreadData>> = const { RefCell::new(None) };
 }
 
 type NameFn<S> = Box<dyn Fn(&EventOrSpan<'_, '_, S>) -> String + Send + Sync>;
@@ -64,7 +80,6 @@ where
     S: Subscriber + for<'span> LookupSpan<'span> + Send + Sync,
 {
     out: Arc<Mutex<Sender<Message>>>,
-    start: std::time::Instant,
     max_tid: AtomicUsize,
     include_args: bool,
     include_locations: bool,
@@ -323,7 +338,6 @@ where
 {
     fn new(mut builder: ChromeLayerBuilder<S>) -> (ChromeLayer<S>, FlushGuard) {
         let (tx, rx) = mpsc::channel();
-        OUT.with(|val| val.replace(Some(tx.clone())));
 
         let out_writer = builder
             .out_writer
@@ -443,7 +457,6 @@ where
         };
         let layer = ChromeLayer {
             out: Arc::new(Mutex::new(tx)),
-            start: std::time::Instant::now(),
             max_tid: AtomicUsize::new(0),
             name_fn: builder.name_fn.take(),
             cat_fn: builder.cat_fn.take(),
@@ -456,22 +469,7 @@ where
         (layer, guard)
     }
 
-    fn get_tid(&self) -> (usize, bool) {
-        TID.with(|value| {
-            let tid = *value.borrow();
-            match tid {
-                Some(tid) => (tid, false),
-                None => {
-                    let tid = self.max_tid.fetch_add(1, Ordering::SeqCst);
-                    value.replace(Some(tid));
-                    (tid, true)
-                }
-            }
-        })
-    }
-
-    fn get_callsite(&self, data: EventOrSpan<S>) -> Callsite {
-        let (tid, new_thread) = self.get_tid();
+    fn get_callsite(&self, data: EventOrSpan<S>, tid: usize) -> Callsite {
         let name = self.name_fn.as_ref().map(|name_fn| name_fn(&data));
         let target = self.cat_fn.as_ref().map(|cat_fn| cat_fn(&data));
         let meta = match data {
@@ -502,14 +500,6 @@ where
             (None, None)
         };
 
-        if new_thread {
-            let name = match std::thread::current().name() {
-                Some(name) => name.to_owned(),
-                None => tid.to_string(),
-            };
-            self.send_message(Message::NewThread(tid, name));
-        }
-
         Callsite {
             tid,
             name,
@@ -548,31 +538,55 @@ where
         }
     }
 
-    fn enter_span(&self, span: SpanRef<S>, ts: f64) {
-        let callsite = self.get_callsite(EventOrSpan::Span(&span));
+    fn enter_span(&self, span: SpanRef<S>, ts: f64, tid: usize, out: &Sender<Message>) {
+        let callsite = self.get_callsite(EventOrSpan::Span(&span), tid);
         let root_id = self.get_root_id(span);
-        self.send_message(Message::Enter(ts, callsite, root_id));
+        let _ignored = out.send(Message::Enter(ts, callsite, root_id));
     }
 
-    fn exit_span(&self, span: SpanRef<S>, ts: f64) {
-        let callsite = self.get_callsite(EventOrSpan::Span(&span));
+    fn exit_span(&self, span: SpanRef<S>, ts: f64, tid: usize, out: &Sender<Message>) {
+        let callsite = self.get_callsite(EventOrSpan::Span(&span), tid);
         let root_id = self.get_root_id(span);
-        self.send_message(Message::Exit(ts, callsite, root_id));
+        let _ignored = out.send(Message::Exit(ts, callsite, root_id));
     }
 
-    fn get_ts(&self) -> f64 {
-        self.start.elapsed().as_nanos() as f64 / 1000.0
-    }
+    /// Helper function that measures how much time is spent while executing `f` and accounts for it
+    /// in subsequent calls, with the aim to reduce biases in the data collected by `tracing_chrome`
+    /// by subtracting the time spent inside tracing functions from the timeline. This makes it so
+    /// that the time spent inside the `tracing_chrome` functions does not impact the timestamps
+    /// inside the trace file (i.e. `ts`), even if such functions are slow (e.g. because they need
+    /// to format arguments on the same thread those arguments are collected on, otherwise memory
+    /// safety would be broken).
+    ///
+    /// `f` is called with the microseconds elapsed since the current thread was started (**not**
+    /// since the program start!), with the current thread ID (i.e. `tid`), and with a [Sender] that
+    /// can be used to send a [Message] to the thread that collects [Message]s and saves them to the
+    /// trace file.
+    #[inline(always)]
+    fn with_elapsed_micros_subtracting_tracing(&self, f: impl Fn(f64, usize, &Sender<Message>)) {
+        THREAD_DATA.with(|value| {
+            let mut thread_data = value.borrow_mut();
+            let (ThreadData { tid, out, start }, new_thread) = match thread_data.as_mut() {
+                Some(thread_data) => (thread_data, false),
+                None => {
+                    let tid = self.max_tid.fetch_add(1, Ordering::SeqCst);
+                    let out = self.out.lock().unwrap().clone();
+                    let start = TracingChromeInstant::setup_for_thread_and_start(tid);
+                    *thread_data = Some(ThreadData { tid, out, start });
+                    (thread_data.as_mut().unwrap(), true)
+                }
+            };
 
-    fn send_message(&self, message: Message) {
-        OUT.with(move |val| {
-            if val.borrow().is_some() {
-                let _ignored = val.borrow().as_ref().unwrap().send(message);
-            } else {
-                let out = self.out.lock().unwrap().clone();
-                let _ignored = out.send(message);
-                val.replace(Some(out));
-            }
+            start.with_elapsed_micros_subtracting_tracing(|ts| {
+                if new_thread {
+                    let name = match std::thread::current().name() {
+                        Some(name) => name.to_owned(),
+                        None => tid.to_string(),
+                    };
+                    let _ignored = out.send(Message::NewThread(*tid, name));
+                }
+                f(ts, *tid, out);
+            });
         });
     }
 }
@@ -586,52 +600,58 @@ where
             return;
         }
 
-        let ts = self.get_ts();
-        self.enter_span(ctx.span(id).expect("Span not found."), ts);
+        self.with_elapsed_micros_subtracting_tracing(|ts, tid, out| {
+            self.enter_span(ctx.span(id).expect("Span not found."), ts, tid, out);
+        });
     }
 
     fn on_record(&self, id: &span::Id, values: &span::Record<'_>, ctx: Context<'_, S>) {
         if self.include_args {
-            let span = ctx.span(id).unwrap();
-            let mut exts = span.extensions_mut();
+            self.with_elapsed_micros_subtracting_tracing(|_, _, _| {
+                let span = ctx.span(id).unwrap();
+                let mut exts = span.extensions_mut();
 
-            let args = exts.get_mut::<ArgsWrapper>();
+                let args = exts.get_mut::<ArgsWrapper>();
 
-            if let Some(args) = args {
-                let args = Arc::make_mut(&mut args.args);
-                values.record(&mut JsonVisitor { object: args });
-            }
+                if let Some(args) = args {
+                    let args = Arc::make_mut(&mut args.args);
+                    values.record(&mut JsonVisitor { object: args });
+                }
+            });
         }
     }
 
     fn on_event(&self, event: &Event<'_>, _ctx: Context<'_, S>) {
-        let ts = self.get_ts();
-        let callsite = self.get_callsite(EventOrSpan::Event(event));
-        self.send_message(Message::Event(ts, callsite));
+        self.with_elapsed_micros_subtracting_tracing(|ts, tid, out| {
+            let callsite = self.get_callsite(EventOrSpan::Event(event), tid);
+            let _ignored = out.send(Message::Event(ts, callsite));
+        });
     }
 
     fn on_exit(&self, id: &span::Id, ctx: Context<'_, S>) {
         if let TraceStyle::Async = self.trace_style {
             return;
         }
-        let ts = self.get_ts();
-        self.exit_span(ctx.span(id).expect("Span not found."), ts);
+        self.with_elapsed_micros_subtracting_tracing(|ts, tid, out| {
+            self.exit_span(ctx.span(id).expect("Span not found."), ts, tid, out);
+        });
     }
 
     fn on_new_span(&self, attrs: &span::Attributes<'_>, id: &span::Id, ctx: Context<'_, S>) {
-        if self.include_args {
-            let mut args = Object::new();
-            attrs.record(&mut JsonVisitor { object: &mut args });
-            ctx.span(id).unwrap().extensions_mut().insert(ArgsWrapper {
-                args: Arc::new(args),
-            });
-        }
-        if let TraceStyle::Threaded = self.trace_style {
-            return;
-        }
+        self.with_elapsed_micros_subtracting_tracing(|ts, tid, out| {
+            if self.include_args {
+                let mut args = Object::new();
+                attrs.record(&mut JsonVisitor { object: &mut args });
+                ctx.span(id).unwrap().extensions_mut().insert(ArgsWrapper {
+                    args: Arc::new(args),
+                });
+            }
+            if let TraceStyle::Threaded = self.trace_style {
+                return;
+            }
 
-        let ts = self.get_ts();
-        self.enter_span(ctx.span(id).expect("Span not found."), ts);
+            self.enter_span(ctx.span(id).expect("Span not found."), ts, tid, out);
+        });
     }
 
     fn on_close(&self, id: span::Id, ctx: Context<'_, S>) {
@@ -639,8 +659,9 @@ where
             return;
         }
 
-        let ts = self.get_ts();
-        self.exit_span(ctx.span(&id).expect("Span not found."), ts);
+        self.with_elapsed_micros_subtracting_tracing(|ts, tid, out| {
+            self.exit_span(ctx.span(&id).expect("Span not found."), ts, tid, out);
+        });
     }
 }
 
diff --git a/src/tools/miri/src/bin/log/tracing_chrome_instant.rs b/src/tools/miri/src/bin/log/tracing_chrome_instant.rs
new file mode 100644
index 0000000000000..f400bc20a7b5d
--- /dev/null
+++ b/src/tools/miri/src/bin/log/tracing_chrome_instant.rs
@@ -0,0 +1,183 @@
+//! Code in this class was in part inspired by
+//! <https://github.com/tikv/minstant/blob/27c9ec5ec90b5b67113a748a4defee0d2519518c/src/tsc_now.rs>.
+//! A useful resource is also
+//! <https://www.pingcap.com/blog/how-we-trace-a-kv-database-with-less-than-5-percent-performance-impact/>,
+//! although this file does not implement TSC synchronization but insteads pins threads to CPUs,
+//! since the former is not reliable (i.e. it might lead to non-monotonic time measurements).
+//! Another useful resource for future improvements might be measureme's time measurement utils:
+//! <https://github.com/rust-lang/measureme/blob/master/measureme/src/counters.rs>.
+//! Documentation about how the Linux kernel chooses a clock source can be found here:
+//! <https://btorpey.github.io/blog/2014/02/18/clock-sources-in-linux/>.
+#![cfg(feature = "tracing")]
+
+/// This alternative `TracingChromeInstant` implementation was made entirely to suit the needs of
+/// [crate::log::tracing_chrome], and shouldn't be used for anything else. It featues two functions:
+/// - [TracingChromeInstant::setup_for_thread_and_start], which sets up the current thread to do
+///   proper time tracking and returns a point in time to use as "t=0", and
+/// - [TracingChromeInstant::with_elapsed_micros_subtracting_tracing], which allows
+///   obtaining how much time elapsed since [TracingChromeInstant::setup_for_thread_and_start] was
+///   called while accounting for (and subtracting) the time spent inside tracing-related functions.
+///
+/// This measures time using [std::time::Instant], except for x86/x86_64 Linux machines, where
+/// [std::time::Instant] is too slow (~1.5us) and thus `rdtsc` is used instead (~5ns).
+pub enum TracingChromeInstant {
+    WallTime {
+        /// The time at which this instant was created, shifted forward to account
+        /// for time spent in tracing functions as explained in
+        /// [TracingChromeInstant::with_elapsed_micros_subtracting_tracing]'s comments.
+        start_instant: std::time::Instant,
+    },
+    #[cfg(all(target_os = "linux", any(target_arch = "x86", target_arch = "x86_64")))]
+    Tsc {
+        /// The value in the TSC counter when this instant was created, shifted forward to account
+        /// for time spent in tracing functions as explained in
+        /// [TracingChromeInstant::with_elapsed_micros_subtracting_tracing]'s comments.
+        start_tsc: u64,
+        /// The period of the TSC counter in microseconds.
+        tsc_to_microseconds: f64,
+    },
+}
+
+impl TracingChromeInstant {
+    /// Can be thought of as the same as [std::time::Instant::now()], but also does some setup to
+    /// make TSC stable in case TSC is available. This is supposed to be called (at most) once per
+    /// thread since the thread setup takes a few milliseconds.
+    ///
+    /// WARNING: If TSC is available, `incremental_thread_id` is used to pick to which CPU to pin
+    /// the current thread. Thread IDs should be assigned contiguously starting from 0. Be aware
+    /// that the current thread will be restricted to one CPU for the rest of the execution!
+    pub fn setup_for_thread_and_start(incremental_thread_id: usize) -> TracingChromeInstant {
+        #[cfg(all(target_os = "linux", any(target_arch = "x86", target_arch = "x86_64")))]
+        if *tsc::IS_TSC_AVAILABLE.get_or_init(tsc::is_tsc_available) {
+            // We need to lock this thread to a specific CPU, because CPUs' TSC timers might be out
+            // of sync.
+            tsc::set_cpu_affinity(incremental_thread_id);
+
+            // Can only use tsc_to_microseconds() and rdtsc() after having set the CPU affinity!
+            // We compute tsc_to_microseconds anew for every new thread just in case some CPU core
+            // has a different TSC frequency.
+            let tsc_to_microseconds = tsc::tsc_to_microseconds();
+            let start_tsc = tsc::rdtsc();
+            return TracingChromeInstant::Tsc { start_tsc, tsc_to_microseconds };
+        }
+
+        let _ = incremental_thread_id; // otherwise we get a warning when the TSC branch is disabled
+        TracingChromeInstant::WallTime { start_instant: std::time::Instant::now() }
+    }
+
+    /// Calls `f` with the time elapsed in microseconds since this [TracingChromeInstant] was built
+    /// by [TracingChromeInstant::setup_for_thread_and_start], while subtracting all time previously
+    /// spent executing other `f`s passed to this function. This behavior allows subtracting time
+    /// spent in functions that log tracing data (which `f` is supposed to be) from the tracing time
+    /// measurements.
+    ///
+    /// Note: microseconds are used as the time unit since that's what Chrome trace files should
+    /// contain, see the definition of the "ts" field in
+    /// <https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/preview>.
+    #[inline(always)]
+    pub fn with_elapsed_micros_subtracting_tracing(&mut self, f: impl Fn(f64)) {
+        match self {
+            TracingChromeInstant::WallTime { start_instant } => {
+                // Obtain the current time (before executing `f`).
+                let instant_before_f = std::time::Instant::now();
+
+                // Using the current time (`instant_before_f`) and the `start_instant` stored in
+                // `self`, calculate the elapsed time (in microseconds) since this instant was
+                // instantiated, accounting for any time that was previously spent executing `f`.
+                // The "accounting" part is not computed in this line, but is rather done by
+                // shifting forward the `start_instant` down below.
+                let ts = (instant_before_f - *start_instant).as_nanos() as f64 / 1000.0;
+
+                // Run the function (supposedly a function internal to the tracing infrastructure).
+                f(ts);
+
+                // Measure how much time was spent executing `f` and shift `start_instant` forward
+                // by that amount. This "removes" that time from the trace.
+                *start_instant += std::time::Instant::now() - instant_before_f;
+            }
+
+            #[cfg(all(target_os = "linux", any(target_arch = "x86", target_arch = "x86_64")))]
+            TracingChromeInstant::Tsc { start_tsc, tsc_to_microseconds } => {
+                // the comments above also apply here, since it's the same logic
+                let tsc_before_f = tsc::rdtsc();
+                let ts = ((tsc_before_f - *start_tsc) as f64) * (*tsc_to_microseconds);
+                f(ts);
+                *start_tsc += tsc::rdtsc() - tsc_before_f;
+            }
+        }
+    }
+}
+
+#[cfg(all(target_os = "linux", any(target_arch = "x86", target_arch = "x86_64")))]
+mod tsc {
+
+    pub static IS_TSC_AVAILABLE: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
+
+    /// Reads the timestamp-counter register. Will give monotonic answers only when called from the
+    /// same thread, because the TSC of different CPUs might be out of sync.
+    #[inline(always)]
+    pub(super) fn rdtsc() -> u64 {
+        #[cfg(target_arch = "x86")]
+        use core::arch::x86::_rdtsc;
+        #[cfg(target_arch = "x86_64")]
+        use core::arch::x86_64::_rdtsc;
+
+        unsafe { _rdtsc() }
+    }
+
+    /// Estimates the frequency of the TSC counter by waiting 10ms in a busy loop and
+    /// looking at how much the TSC increased in the meantime.
+    pub(super) fn tsc_to_microseconds() -> f64 {
+        const BUSY_WAIT: std::time::Duration = std::time::Duration::from_millis(10);
+        let tsc_start = rdtsc();
+        let instant_start = std::time::Instant::now();
+        while instant_start.elapsed() < BUSY_WAIT {
+            // `thread::sleep()` is not very precise at waking up the program at the right time,
+            // so use a busy loop instead.
+            core::hint::spin_loop();
+        }
+        let tsc_end = rdtsc();
+        (BUSY_WAIT.as_nanos() as f64) / 1000.0 / ((tsc_end - tsc_start) as f64)
+    }
+
+    /// Checks whether the TSC counter is available and runs at a constant rate independently
+    /// of CPU frequency even across different power states of the CPU (i.e. checks for the
+    /// `invariant_tsc` CPUID flag).
+    pub(super) fn is_tsc_available() -> bool {
+        #[cfg(target_arch = "x86")]
+        use core::arch::x86::__cpuid;
+        #[cfg(target_arch = "x86_64")]
+        use core::arch::x86_64::__cpuid;
+
+        // implemented like https://docs.rs/raw-cpuid/latest/src/raw_cpuid/extended.rs.html#965-967
+        const LEAF: u32 = 0x80000007; // this is the leaf for "advanced power management info"
+        let cpuid = unsafe { __cpuid(LEAF) };
+        (cpuid.edx & (1 << 8)) != 0 // EDX bit 8 indicates invariant TSC
+    }
+
+    /// Forces the current thread to run on a single CPU, which ensures the TSC counter is monotonic
+    /// (since TSCs of different CPUs might be out-of-sync). `incremental_thread_id` is used to pick
+    /// to which CPU to pin the current thread, and should be an incremental number that starts from
+    /// 0.
+    pub(super) fn set_cpu_affinity(incremental_thread_id: usize) {
+        let cpu_id = match std::thread::available_parallelism() {
+            Ok(available_parallelism) => incremental_thread_id % available_parallelism,
+            _ => panic!("Could not determine CPU count to properly set CPU affinity"),
+        };
+
+        let mut set = unsafe { std::mem::zeroed::<libc::cpu_set_t>() };
+        unsafe { libc::CPU_SET(cpu_id, &mut set) };
+
+        // Set the current thread's core affinity.
+        if unsafe {
+            libc::sched_setaffinity(
+                0, // Defaults to current thread
+                size_of::<libc::cpu_set_t>(),
+                &set as *const _,
+            )
+        } != 0
+        {
+            panic!("Could not set CPU affinity")
+        }
+    }
+}

From d32e5633732cfa124240c3ea8abd45d77f46c469 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sat, 23 Aug 2025 10:46:59 +0200
Subject: [PATCH 0241/1889] Check that no profile is present in `Cargo.toml`
 files

---
 tests/no-profile-in-cargo-toml.rs | 34 +++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 tests/no-profile-in-cargo-toml.rs

diff --git a/tests/no-profile-in-cargo-toml.rs b/tests/no-profile-in-cargo-toml.rs
new file mode 100644
index 0000000000000..2ad9bfb75dee8
--- /dev/null
+++ b/tests/no-profile-in-cargo-toml.rs
@@ -0,0 +1,34 @@
+// Check that we do not have `profile.*` sections in our `Cargo.toml` files,
+// as this causes warnings when run from the compiler repository which includes
+// Clippy in a workspace.
+//
+// Those sections can be put into `.cargo/config.toml` which will be read
+// when commands are issued from the top-level Clippy directory, outside of
+// a workspace.
+
+use std::fs::File;
+use std::io::{self, BufRead as _};
+use walkdir::WalkDir;
+
+#[test]
+fn no_profile_in_cargo_toml() {
+    // This check could parse `Cargo.toml` using a TOML deserializer, but in practice
+    // profile sections would be added at the beginning of a line as `[profile.*]`, so
+    // keep it fast and simple.
+    for entry in WalkDir::new(".")
+        .into_iter()
+        .filter_map(Result::ok)
+        .filter(|e| e.file_name().to_str() == Some("Cargo.toml"))
+    {
+        for line in io::BufReader::new(File::open(entry.path()).unwrap())
+            .lines()
+            .map(Result::unwrap)
+        {
+            if line.starts_with("[profile.") {
+                eprintln!("Profile section `{line}` found in file `{}`.", entry.path().display());
+                eprintln!("Use `.cargo/config.toml` for profiles specific to the standalone Clippy repository.");
+                panic!("Profile section found in `Cargo.toml`");
+            }
+        }
+    }
+}

From ac3492af823a0397b832c9868216a25f81700d00 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Tue, 12 Aug 2025 01:01:18 +0200
Subject: [PATCH 0242/1889] simplify `too_many_args`

import `FnKind` completely

save `header` as an intermediate variable

match on `header.abi` directly

use `FnKind::header`

nest `if`s

use `cx.tcx.def_span`, as recommended in https://github.com/rust-lang/rust-clippy/pull/15461#discussion_r2269961969
---
 clippy_lints/src/functions/mod.rs             |  2 +-
 .../src/functions/too_many_arguments.rs       | 37 +++++--------------
 2 files changed, 10 insertions(+), 29 deletions(-)

diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index ca5ea90181493..5a40af4219426 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -535,7 +535,7 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
         def_id: LocalDefId,
     ) {
         let hir_id = cx.tcx.local_def_id_to_hir_id(def_id);
-        too_many_arguments::check_fn(cx, kind, decl, span, hir_id, self.too_many_arguments_threshold);
+        too_many_arguments::check_fn(cx, kind, decl, hir_id, def_id, self.too_many_arguments_threshold);
         too_many_lines::check_fn(cx, kind, body, span, def_id, self.too_many_lines_threshold);
         not_unsafe_ptr_arg_deref::check_fn(cx, kind, decl, body, def_id);
         misnamed_getters::check_fn(cx, kind, decl, body, span);
diff --git a/clippy_lints/src/functions/too_many_arguments.rs b/clippy_lints/src/functions/too_many_arguments.rs
index 48d050aa36aa0..6c3c3d354ecc9 100644
--- a/clippy_lints/src/functions/too_many_arguments.rs
+++ b/clippy_lints/src/functions/too_many_arguments.rs
@@ -1,5 +1,7 @@
 use rustc_abi::ExternAbi;
-use rustc_hir::{self as hir, intravisit};
+use rustc_hir as hir;
+use rustc_hir::def_id::LocalDefId;
+use rustc_hir::intravisit::FnKind;
 use rustc_lint::LateContext;
 use rustc_span::Span;
 
@@ -10,39 +12,18 @@ use super::TOO_MANY_ARGUMENTS;
 
 pub(super) fn check_fn(
     cx: &LateContext<'_>,
-    kind: intravisit::FnKind<'_>,
+    kind: FnKind<'_>,
     decl: &hir::FnDecl<'_>,
-    span: Span,
     hir_id: hir::HirId,
+    def_id: LocalDefId,
     too_many_arguments_threshold: u64,
 ) {
     // don't warn for implementations, it's not their fault
-    if !is_trait_impl_item(cx, hir_id) {
+    if !is_trait_impl_item(cx, hir_id)
         // don't lint extern functions decls, it's not their fault either
-        match kind {
-            intravisit::FnKind::Method(
-                _,
-                &hir::FnSig {
-                    header: hir::FnHeader {
-                        abi: ExternAbi::Rust, ..
-                    },
-                    ..
-                },
-            )
-            | intravisit::FnKind::ItemFn(
-                _,
-                _,
-                hir::FnHeader {
-                    abi: ExternAbi::Rust, ..
-                },
-            ) => check_arg_number(
-                cx,
-                decl,
-                span.with_hi(decl.output.span().hi()),
-                too_many_arguments_threshold,
-            ),
-            _ => {},
-        }
+        && kind.header().is_some_and(|header| header.abi == ExternAbi::Rust)
+    {
+        check_arg_number(cx, decl, cx.tcx.def_span(def_id), too_many_arguments_threshold);
     }
 }
 

From cf3f61ce161e057199c935caeb4ca88063e6bb94 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sat, 9 Aug 2025 14:03:29 +0200
Subject: [PATCH 0243/1889] `entry`: link to `Entry` API if can't make a
 suggestion

---
 clippy_lints/src/entry.rs       | 14 ++++++++++++--
 tests/ui/entry_unfixable.stderr |  5 +++++
 2 files changed, 17 insertions(+), 2 deletions(-)

diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index 182cb4e46d2bd..fd3475243e390 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::source::{reindent_multiline, snippet_indent, snippet_with_applicability, snippet_with_context};
 use clippy_utils::ty::is_copy;
 use clippy_utils::visitors::for_each_expr;
@@ -194,7 +194,17 @@ impl<'tcx> LateLintPass<'tcx> for HashMapPass {
         if let Some(sugg) = sugg {
             span_lint_and_sugg(cx, MAP_ENTRY, expr.span, lint_msg, "try", sugg, app);
         } else {
-            span_lint(cx, MAP_ENTRY, expr.span, lint_msg);
+            span_lint_and_help(
+                cx,
+                MAP_ENTRY,
+                expr.span,
+                lint_msg,
+                None,
+                format!(
+                    "consider using the `Entry` API: https://doc.rust-lang.org/std/collections/struct.{}.html#entry-api",
+                    map_ty.name()
+                ),
+            );
         }
     }
 }
diff --git a/tests/ui/entry_unfixable.stderr b/tests/ui/entry_unfixable.stderr
index 0197d2ab4cf9c..f92f472512f67 100644
--- a/tests/ui/entry_unfixable.stderr
+++ b/tests/ui/entry_unfixable.stderr
@@ -10,6 +10,7 @@ LL | |                 false
 LL | |             }
    | |_____________^
    |
+   = help: consider using the `Entry` API: https://doc.rust-lang.org/std/collections/struct.HashMap.html#entry-api
    = note: `-D clippy::map-entry` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::map_entry)]`
 
@@ -24,6 +25,8 @@ LL | |     } else {
 LL | |         hm.insert(key, true);
 LL | |     }
    | |_____^
+   |
+   = help: consider using the `Entry` API: https://doc.rust-lang.org/std/collections/struct.HashMap.html#entry-api
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
   --> tests/ui/entry_unfixable.rs:80:13
@@ -36,6 +39,8 @@ LL | |                 let interner = INTERNER.lock().unwrap();
 LL | |                 return Err(interner.resolve(name).unwrap().to_owned());
 LL | |             }
    | |_____________^
+   |
+   = help: consider using the `Entry` API: https://doc.rust-lang.org/std/collections/struct.HashMap.html#entry-api
 
 error: aborting due to 3 previous errors
 

From c68450a473e0d6895b8372c38b38591b9baa7472 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 23 Aug 2025 22:00:57 +0200
Subject: [PATCH 0244/1889] tree borrows: refactor new-permission logic

---
 .../src/borrow_tracker/tree_borrows/mod.rs    | 149 +++++++-----------
 .../src/borrow_tracker/tree_borrows/perms.rs  |  17 +-
 .../borrow_tracker/tree_borrows/tree/tests.rs |   2 +-
 .../frozen-lazy-write-to-surrounding.rs       |   9 ++
 .../frozen-lazy-write-to-surrounding.stderr   |  21 +++
 .../cell-lazy-write-to-surrounding.rs         |  10 +-
 6 files changed, 98 insertions(+), 110 deletions(-)
 create mode 100644 src/tools/miri/tests/fail/tree_borrows/frozen-lazy-write-to-surrounding.rs
 create mode 100644 src/tools/miri/tests/fail/tree_borrows/frozen-lazy-write-to-surrounding.stderr

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 ad2a67160f484..a365044862862 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
@@ -125,81 +125,64 @@ pub struct NewPermission {
     /// Whether a read access should be performed on the non-frozen
     /// part on a retag.
     nonfreeze_access: bool,
+    /// Permission for memory outside the range.
+    outside_perm: Permission,
     /// Whether this pointer is part of the arguments of a function call.
     /// `protector` is `Some(_)` for all pointers marked `noalias`.
     protector: Option<ProtectorKind>,
 }
 
 impl<'tcx> NewPermission {
-    /// Determine NewPermission of the reference from the type of the pointee.
-    fn from_ref_ty(
+    /// Determine NewPermission of the reference/Box from the type of the pointee.
+    ///
+    /// A `ref_mutability` of `None` indicates a `Box` type.
+    fn new(
         pointee: Ty<'tcx>,
-        mutability: Mutability,
-        kind: RetagKind,
+        ref_mutability: Option<Mutability>,
+        retag_kind: RetagKind,
         cx: &crate::MiriInterpCx<'tcx>,
     ) -> Option<Self> {
         let ty_is_unpin = pointee.is_unpin(*cx.tcx, cx.typing_env());
-        let is_protected = kind == RetagKind::FnEntry;
-        let protector = is_protected.then_some(ProtectorKind::StrongProtector);
-
-        Some(match mutability {
-            Mutability::Mut if ty_is_unpin =>
-                NewPermission {
-                    freeze_perm: Permission::new_reserved(
-                        /* ty_is_freeze */ true,
-                        is_protected,
-                    ),
-                    freeze_access: true,
-                    nonfreeze_perm: Permission::new_reserved(
-                        /* ty_is_freeze */ false,
-                        is_protected,
-                    ),
-                    // If we have a mutable reference, then the non-frozen part will
-                    // have state `ReservedIM` or `Reserved`, which can have an initial read access
-                    // performed on it because you cannot have multiple mutable borrows.
-                    nonfreeze_access: true,
-                    protector,
-                },
-            Mutability::Not =>
-                NewPermission {
-                    freeze_perm: Permission::new_frozen(),
-                    freeze_access: true,
-                    nonfreeze_perm: Permission::new_cell(),
-                    // If it is a shared reference, then the non-frozen
-                    // part will have state `Cell`, which should not have an initial access,
-                    // as this can cause data races when using thread-safe data types like
-                    // `Mutex<T>`.
-                    nonfreeze_access: false,
-                    protector,
-                },
-            _ => return None,
-        })
-    }
+        let ty_is_freeze = pointee.is_freeze(*cx.tcx, cx.typing_env());
+        let is_protected = retag_kind == RetagKind::FnEntry;
 
-    /// Compute permission for `Box`-like type (`Box` always, and also `Unique` if enabled).
-    /// These pointers allow deallocation so need a different kind of protector not handled
-    /// by `from_ref_ty`.
-    fn from_unique_ty(
-        ty: Ty<'tcx>,
-        kind: RetagKind,
-        cx: &crate::MiriInterpCx<'tcx>,
-    ) -> Option<Self> {
-        let pointee = ty.builtin_deref(true).unwrap();
-        pointee.is_unpin(*cx.tcx, cx.typing_env()).then_some(()).map(|()| {
-            // Regular `Unpin` box, give it `noalias` but only a weak protector
-            // because it is valid to deallocate it within the function.
-            let is_protected = kind == RetagKind::FnEntry;
-            let protector = is_protected.then_some(ProtectorKind::WeakProtector);
-            NewPermission {
-                freeze_perm: Permission::new_reserved(/* ty_is_freeze */ true, is_protected),
-                freeze_access: true,
-                nonfreeze_perm: Permission::new_reserved(
-                    /* ty_is_freeze */ false,
-                    is_protected,
-                ),
-                nonfreeze_access: true,
-                protector,
-            }
+        if matches!(ref_mutability, Some(Mutability::Mut) | None if !ty_is_unpin) {
+            // Mutable reference / Box to pinning type: retagging is a NOP.
+            // FIXME: with `UnsafePinned`, this should do proper per-byte tracking.
+            return None;
+        }
+
+        let freeze_perm = match ref_mutability {
+            // Shared references are frozen.
+            Some(Mutability::Not) => Permission::new_frozen(),
+            // Mutable references and Boxes are reserved.
+            _ => Permission::new_reserved_frz(),
+        };
+        let nonfreeze_perm = match ref_mutability {
+            // Shared references are "transparent".
+            Some(Mutability::Not) => Permission::new_cell(),
+            // *Protected* mutable references and boxes are reserved without regarding for interior mutability.
+            _ if is_protected => Permission::new_reserved_frz(),
+            // Unprotected mutable references and boxes start in `ReservedIm`.
+            _ => Permission::new_reserved_im(),
+        };
+
+        // Everything except for `Cell` gets an initial access.
+        let initial_access = |perm: &Permission| !perm.is_cell();
+
+        Some(NewPermission {
+            freeze_perm,
+            freeze_access: initial_access(&freeze_perm),
+            nonfreeze_perm,
+            nonfreeze_access: initial_access(&nonfreeze_perm),
+            outside_perm: if ty_is_freeze { freeze_perm } else { nonfreeze_perm },
+            protector: is_protected.then_some(if ref_mutability.is_some() {
+                // Strong protector for references
+                ProtectorKind::StrongProtector
+            } else {
+                // Weak protector for boxes
+                ProtectorKind::WeakProtector
+            }),
         })
     }
 }
@@ -313,15 +296,11 @@ trait EvalContextPrivExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         let span = this.machine.current_span();
 
-        // Store initial permissions and their corresponding range.
+        // Store initial permissions for the "inside" part.
         let mut perms_map: DedupRangeMap<LocationState> = DedupRangeMap::new(
             ptr_size,
             LocationState::new_accessed(Permission::new_disabled(), IdempotentForeignAccess::None), // this will be overwritten
         );
-        // Keep track of whether the node has any part that allows for interior mutability.
-        // FIXME: This misses `PhantomData<UnsafeCell<T>>` which could be considered a marker
-        // for requesting interior mutability.
-        let mut has_unsafe_cell = false;
 
         // When adding a new node, the SIFA of its parents needs to be updated, potentially across
         // the entire memory range. For the parts that are being accessed below, the access itself
@@ -350,14 +329,13 @@ trait EvalContextPrivExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             .get_tree_borrows_params()
             .precise_interior_mut;
 
-        let default_perm = if !precise_interior_mut {
-            // NOTE: Using `ty_is_freeze` doesn't give the same result as going through the range
-            // and computing `has_unsafe_cell`.  This is because of zero-sized `UnsafeCell`, for which
-            // `has_unsafe_cell` is false, but `!ty_is_freeze` is true.
+        // Set "inside" permissions.
+        if !precise_interior_mut {
             let ty_is_freeze = place.layout.ty.is_freeze(*this.tcx, this.typing_env());
             let (perm, access) = if ty_is_freeze {
                 (new_perm.freeze_perm, new_perm.freeze_access)
             } else {
+                // Just pretend the entire thing is an `UnsafeCell`.
                 (new_perm.nonfreeze_perm, new_perm.nonfreeze_access)
             };
             let sifa = perm.strongest_idempotent_foreign_access(protected);
@@ -370,12 +348,8 @@ trait EvalContextPrivExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             for (_loc_range, loc) in perms_map.iter_mut_all() {
                 *loc = new_loc;
             }
-
-            perm
         } else {
             this.visit_freeze_sensitive(place, ptr_size, |range, frozen| {
-                has_unsafe_cell = has_unsafe_cell || !frozen;
-
                 // We are only ever `Frozen` inside the frozen bits.
                 let (perm, access) = if frozen {
                     (new_perm.freeze_perm, new_perm.freeze_access)
@@ -401,9 +375,6 @@ trait EvalContextPrivExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
                 interp_ok(())
             })?;
-
-            // Allow lazily writing to surrounding data if we found an `UnsafeCell`.
-            if has_unsafe_cell { new_perm.nonfreeze_perm } else { new_perm.freeze_perm }
         };
 
         let alloc_extra = this.get_alloc_extra(alloc_id)?;
@@ -447,7 +418,7 @@ trait EvalContextPrivExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             orig_tag,
             new_tag,
             perms_map,
-            default_perm,
+            new_perm.outside_perm,
             protected,
             span,
         )?;
@@ -514,7 +485,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let this = self.eval_context_mut();
         let new_perm = match val.layout.ty.kind() {
             &ty::Ref(_, pointee, mutability) =>
-                NewPermission::from_ref_ty(pointee, mutability, kind, this),
+                NewPermission::new(pointee, Some(mutability), kind, this),
             _ => None,
         };
         if let Some(new_perm) = new_perm {
@@ -571,8 +542,9 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             fn visit_box(&mut self, box_ty: Ty<'tcx>, place: &PlaceTy<'tcx>) -> InterpResult<'tcx> {
                 // Only boxes for the global allocator get any special treatment.
                 if box_ty.is_box_global(*self.ecx.tcx) {
+                    let pointee = place.layout.ty.builtin_deref(true).unwrap();
                     let new_perm =
-                        NewPermission::from_unique_ty(place.layout.ty, self.kind, self.ecx);
+                        NewPermission::new(pointee, /* not a ref */ None, self.kind, self.ecx);
                     self.retag_ptr_inplace(place, new_perm)?;
                 }
                 interp_ok(())
@@ -591,7 +563,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 match place.layout.ty.kind() {
                     &ty::Ref(_, pointee, mutability) => {
                         let new_perm =
-                            NewPermission::from_ref_ty(pointee, mutability, self.kind, self.ecx);
+                            NewPermission::new(pointee, Some(mutability), self.kind, self.ecx);
                         self.retag_ptr_inplace(place, new_perm)?;
                     }
                     ty::RawPtr(_, _) => {
@@ -643,14 +615,11 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             // never be ReservedIM, the value of the `ty_is_freeze`
             // argument doesn't matter
             // (`ty_is_freeze || true` in `new_reserved` will always be `true`).
-            freeze_perm: Permission::new_reserved(
-                /* ty_is_freeze */ true, /* protected */ true,
-            ),
+            freeze_perm: Permission::new_reserved_frz(),
             freeze_access: true,
-            nonfreeze_perm: Permission::new_reserved(
-                /* ty_is_freeze */ false, /* protected */ true,
-            ),
+            nonfreeze_perm: Permission::new_reserved_frz(),
             nonfreeze_access: true,
+            outside_perm: Permission::new_reserved_frz(),
             protector: Some(ProtectorKind::StrongProtector),
         };
         this.tb_retag_place(place, new_perm)
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 38863ca0734a1..390435e58d173 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/perms.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/perms.rs
@@ -272,28 +272,15 @@ impl Permission {
 
     /// Default initial permission of a reborrowed mutable reference that is either
     /// protected or not interior mutable.
-    fn new_reserved_frz() -> Self {
+    pub fn new_reserved_frz() -> Self {
         Self { inner: ReservedFrz { conflicted: false } }
     }
 
     /// Default initial permission of an unprotected interior mutable reference.
-    fn new_reserved_im() -> Self {
+    pub 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 {
-        // As demonstrated by `tests/fail/tree_borrows/reservedim_spurious_write.rs`,
-        // 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" in their reservation phase.
-        if ty_is_freeze || protected { Self::new_reserved_frz() } else { Self::new_reserved_im() }
-    }
-
     /// Default initial permission of a reborrowed shared reference.
     pub fn new_frozen() -> Self {
         Self { inner: Frozen }
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 bb3fc2d80b3fa..d9b3696e4f805 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
@@ -610,7 +610,7 @@ mod spurious_read {
             },
             y: LocStateProt {
                 state: LocationState::new_non_accessed(
-                    Permission::new_reserved(/* freeze */ true, /* protected */ true),
+                    Permission::new_reserved_frz(),
                     IdempotentForeignAccess::default(),
                 ),
                 prot: true,
diff --git a/src/tools/miri/tests/fail/tree_borrows/frozen-lazy-write-to-surrounding.rs b/src/tools/miri/tests/fail/tree_borrows/frozen-lazy-write-to-surrounding.rs
new file mode 100644
index 0000000000000..7d51050f32b28
--- /dev/null
+++ b/src/tools/miri/tests/fail/tree_borrows/frozen-lazy-write-to-surrounding.rs
@@ -0,0 +1,9 @@
+//@compile-flags: -Zmiri-tree-borrows
+
+fn main() {
+    // Since the "inside" part is `!Freeze`, the permission to mutate is gone.
+    let pair = ((), 1);
+    let x = &pair.0;
+    let ptr = (&raw const *x).cast::<i32>().cast_mut();
+    unsafe { ptr.write(0) }; //~ERROR: /write access .* forbidden/
+}
diff --git a/src/tools/miri/tests/fail/tree_borrows/frozen-lazy-write-to-surrounding.stderr b/src/tools/miri/tests/fail/tree_borrows/frozen-lazy-write-to-surrounding.stderr
new file mode 100644
index 0000000000000..e9800468c57a5
--- /dev/null
+++ b/src/tools/miri/tests/fail/tree_borrows/frozen-lazy-write-to-surrounding.stderr
@@ -0,0 +1,21 @@
+error: Undefined Behavior: write access through <TAG> at ALLOC[0x0] is forbidden
+  --> tests/fail/tree_borrows/frozen-lazy-write-to-surrounding.rs:LL:CC
+   |
+LL |     unsafe { ptr.write(0) };
+   |              ^^^^^^^^^^^^ Undefined Behavior occurred here
+   |
+   = 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: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/tree-borrows.md for further information
+   = help: the accessed tag <TAG> has state Frozen which forbids this child write access
+help: the accessed tag <TAG> was created here, in the initial state Frozen
+  --> tests/fail/tree_borrows/frozen-lazy-write-to-surrounding.rs:LL:CC
+   |
+LL |     let x = &pair.0;
+   |             ^^^^^^^
+   = note: BACKTRACE (of the first span):
+   = note: inside `main` at tests/fail/tree_borrows/frozen-lazy-write-to-surrounding.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/tree_borrows/cell-lazy-write-to-surrounding.rs b/src/tools/miri/tests/pass/tree_borrows/cell-lazy-write-to-surrounding.rs
index abe08f2cd2261..7352784ac7a5e 100644
--- a/src/tools/miri/tests/pass/tree_borrows/cell-lazy-write-to-surrounding.rs
+++ b/src/tools/miri/tests/pass/tree_borrows/cell-lazy-write-to-surrounding.rs
@@ -14,9 +14,11 @@ fn main() {
     foo(&arr[0]);
 
     let pair = (Cell::new(1), 1);
-    // TODO: Ideally, this would result in UB since the second element
-    // in `pair` is Frozen.  We would need some way to express a
-    // "shared reference with permission to access surrounding
-    // interior mutable data".
     foo(&pair.0);
+
+    // As long as the "inside" part is `!Freeze`, the permission to mutate the "outside" is preserved.
+    let pair = (Cell::new(()), 1);
+    let x = &pair.0;
+    let ptr = (&raw const *x).cast::<i32>().cast_mut();
+    unsafe { ptr.write(0) };
 }

From 416f988fafe11841095aab78c29a4a0101c12c84 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 23 Aug 2025 22:08:41 +0200
Subject: [PATCH 0245/1889] refactor tb_rebor: reduce code duplication

---
 .../src/borrow_tracker/tree_borrows/mod.rs    | 60 +++++++------------
 1 file changed, 22 insertions(+), 38 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 a365044862862..04b951cd77c38 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
@@ -296,12 +296,6 @@ trait EvalContextPrivExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         let span = this.machine.current_span();
 
-        // Store initial permissions for the "inside" part.
-        let mut perms_map: DedupRangeMap<LocationState> = DedupRangeMap::new(
-            ptr_size,
-            LocationState::new_accessed(Permission::new_disabled(), IdempotentForeignAccess::None), // this will be overwritten
-        );
-
         // When adding a new node, the SIFA of its parents needs to be updated, potentially across
         // the entire memory range. For the parts that are being accessed below, the access itself
         // trivially takes care of that. However, we have to do some more work to also deal with
@@ -329,58 +323,48 @@ trait EvalContextPrivExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             .get_tree_borrows_params()
             .precise_interior_mut;
 
-        // Set "inside" permissions.
-        if !precise_interior_mut {
-            let ty_is_freeze = place.layout.ty.is_freeze(*this.tcx, this.typing_env());
-            let (perm, access) = if ty_is_freeze {
+        // Compute initial "inside" permissions.
+        let loc_state = |frozen: bool| -> LocationState {
+            let (perm, access) = if frozen {
                 (new_perm.freeze_perm, new_perm.freeze_access)
             } else {
-                // Just pretend the entire thing is an `UnsafeCell`.
                 (new_perm.nonfreeze_perm, new_perm.nonfreeze_access)
             };
             let sifa = perm.strongest_idempotent_foreign_access(protected);
-            let new_loc = if access {
+            if access {
                 LocationState::new_accessed(perm, sifa)
             } else {
                 LocationState::new_non_accessed(perm, sifa)
-            };
-
-            for (_loc_range, loc) in perms_map.iter_mut_all() {
-                *loc = new_loc;
             }
+        };
+        let perms_map = if !precise_interior_mut {
+            // For `!Freeze` types, just pretend the entire thing is an `UnsafeCell`.
+            let ty_is_freeze = place.layout.ty.is_freeze(*this.tcx, this.typing_env());
+            let state = loc_state(ty_is_freeze);
+            DedupRangeMap::new(ptr_size, state)
         } else {
+            // The initial state will be overwritten by the visitor below.
+            let mut perms_map: DedupRangeMap<LocationState> = DedupRangeMap::new(
+                ptr_size,
+                LocationState::new_accessed(
+                    Permission::new_disabled(),
+                    IdempotentForeignAccess::None,
+                ),
+            );
             this.visit_freeze_sensitive(place, ptr_size, |range, frozen| {
-                // We are only ever `Frozen` inside the frozen bits.
-                let (perm, access) = if frozen {
-                    (new_perm.freeze_perm, new_perm.freeze_access)
-                } else {
-                    (new_perm.nonfreeze_perm, new_perm.nonfreeze_access)
-                };
-                let sifa = perm.strongest_idempotent_foreign_access(protected);
-                // NOTE: Currently, `access` is false if and only if `perm` is Cell, so this `if`
-                // doesn't not change whether any code is UB or not. We could just always use
-                // `new_accessed` and everything would stay the same. But that seems conceptually
-                // odd, so we keep the initial "accessed" bit of the `LocationState` in sync with whether
-                // a read access is performed below.
-                let new_loc = if access {
-                    LocationState::new_accessed(perm, sifa)
-                } else {
-                    LocationState::new_non_accessed(perm, sifa)
-                };
-
-                // Store initial permissions.
+                let state = loc_state(frozen);
                 for (_loc_range, loc) in perms_map.iter_mut(range.start, range.size) {
-                    *loc = new_loc;
+                    *loc = state;
                 }
-
                 interp_ok(())
             })?;
+            perms_map
         };
 
         let alloc_extra = this.get_alloc_extra(alloc_id)?;
         let mut tree_borrows = alloc_extra.borrow_tracker_tb().borrow_mut();
 
-        for (perm_range, perm) in perms_map.iter_mut_all() {
+        for (perm_range, perm) in perms_map.iter_all() {
             if perm.is_accessed() {
                 // Some reborrows incur a read access to the parent.
                 // Adjust range to be relative to allocation start (rather than to `place`).

From 4d8b1aec08fad8a76dd8b6a38e384442f0446405 Mon Sep 17 00:00:00 2001
From: Urgau <urgau@numericable.fr>
Date: Sun, 27 Jul 2025 21:21:49 +0200
Subject: [PATCH 0246/1889] Adjust clippy lints for rustc
 `integer_to_ptr_transmutes` lint

---
 .../src/transmute/useless_transmute.rs        | 12 +----
 tests/ui/transmute.rs                         |  3 +-
 tests/ui/transmute.stderr                     | 46 +++++++------------
 .../transmutes_expressible_as_ptr_casts.fixed |  3 --
 .../ui/transmutes_expressible_as_ptr_casts.rs |  3 --
 ...transmutes_expressible_as_ptr_casts.stderr | 32 ++++++-------
 6 files changed, 32 insertions(+), 67 deletions(-)

diff --git a/clippy_lints/src/transmute/useless_transmute.rs b/clippy_lints/src/transmute/useless_transmute.rs
index ec5fb2793f976..b898920baefc2 100644
--- a/clippy_lints/src/transmute/useless_transmute.rs
+++ b/clippy_lints/src/transmute/useless_transmute.rs
@@ -49,17 +49,7 @@ pub(super) fn check<'tcx>(
             true
         },
         (ty::Int(_) | ty::Uint(_), ty::RawPtr(_, _)) => {
-            span_lint_and_then(
-                cx,
-                USELESS_TRANSMUTE,
-                e.span,
-                "transmute from an integer to a pointer",
-                |diag| {
-                    if let Some(arg) = sugg::Sugg::hir_opt(cx, arg) {
-                        diag.span_suggestion(e.span, "try", arg.as_ty(to_ty.to_string()), Applicability::Unspecified);
-                    }
-                },
-            );
+            // Handled by the upstream rustc `integer_to_ptr_transmutes` lint
             true
         },
         _ => false,
diff --git a/tests/ui/transmute.rs b/tests/ui/transmute.rs
index e968e7a59244d..e7099104f942d 100644
--- a/tests/ui/transmute.rs
+++ b/tests/ui/transmute.rs
@@ -4,6 +4,7 @@
     dead_code,
     clippy::borrow_as_ptr,
     unnecessary_transmutes,
+    integer_to_ptr_transmutes,
     clippy::needless_lifetimes,
     clippy::missing_transmute_annotations
 )]
@@ -60,12 +61,10 @@ fn useless() {
         //~^ useless_transmute
 
         let _: *const usize = std::mem::transmute(5_isize);
-        //~^ useless_transmute
 
         let _ = std::ptr::dangling::<usize>();
 
         let _: *const usize = std::mem::transmute(1 + 1usize);
-        //~^ useless_transmute
 
         let _ = (1 + 1_usize) as *const usize;
     }
diff --git a/tests/ui/transmute.stderr b/tests/ui/transmute.stderr
index 79528ec06f1bf..9478db09481a8 100644
--- a/tests/ui/transmute.stderr
+++ b/tests/ui/transmute.stderr
@@ -1,5 +1,5 @@
 error: transmute from a reference to a pointer
-  --> tests/ui/transmute.rs:33:27
+  --> tests/ui/transmute.rs:34:27
    |
 LL |         let _: *const T = core::mem::transmute(t);
    |                           ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `t as *const T`
@@ -8,61 +8,49 @@ LL |         let _: *const T = core::mem::transmute(t);
    = help: to override `-D warnings` add `#[allow(clippy::useless_transmute)]`
 
 error: transmute from a reference to a pointer
-  --> tests/ui/transmute.rs:36:25
+  --> tests/ui/transmute.rs:37:25
    |
 LL |         let _: *mut T = core::mem::transmute(t);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `t as *const T as *mut T`
 
 error: transmute from a reference to a pointer
-  --> tests/ui/transmute.rs:39:27
+  --> tests/ui/transmute.rs:40:27
    |
 LL |         let _: *const U = core::mem::transmute(t);
    |                           ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `t as *const T as *const U`
 
 error: transmute from a type (`std::vec::Vec<i32>`) to itself
-  --> tests/ui/transmute.rs:47:27
+  --> tests/ui/transmute.rs:48:27
    |
 LL |         let _: Vec<i32> = core::mem::transmute(my_vec());
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a type (`std::vec::Vec<i32>`) to itself
-  --> tests/ui/transmute.rs:50:27
+  --> tests/ui/transmute.rs:51:27
    |
 LL |         let _: Vec<i32> = core::mem::transmute(my_vec());
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a type (`std::vec::Vec<i32>`) to itself
-  --> tests/ui/transmute.rs:53:27
+  --> tests/ui/transmute.rs:54:27
    |
 LL |         let _: Vec<i32> = std::mem::transmute(my_vec());
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a type (`std::vec::Vec<i32>`) to itself
-  --> tests/ui/transmute.rs:56:27
+  --> tests/ui/transmute.rs:57:27
    |
 LL |         let _: Vec<i32> = std::mem::transmute(my_vec());
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a type (`std::vec::Vec<i32>`) to itself
-  --> tests/ui/transmute.rs:59:27
+  --> tests/ui/transmute.rs:60:27
    |
 LL |         let _: Vec<i32> = my_transmute(my_vec());
    |                           ^^^^^^^^^^^^^^^^^^^^^^
 
-error: transmute from an integer to a pointer
-  --> tests/ui/transmute.rs:62:31
-   |
-LL |         let _: *const usize = std::mem::transmute(5_isize);
-   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `5_isize as *const usize`
-
-error: transmute from an integer to a pointer
-  --> tests/ui/transmute.rs:67:31
-   |
-LL |         let _: *const usize = std::mem::transmute(1 + 1usize);
-   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(1 + 1usize) as *const usize`
-
 error: transmute from a type (`*const Usize`) to the type that it points to (`Usize`)
-  --> tests/ui/transmute.rs:99:24
+  --> tests/ui/transmute.rs:98:24
    |
 LL |         let _: Usize = core::mem::transmute(int_const_ptr);
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -71,25 +59,25 @@ LL |         let _: Usize = core::mem::transmute(int_const_ptr);
    = help: to override `-D warnings` add `#[allow(clippy::crosspointer_transmute)]`
 
 error: transmute from a type (`*mut Usize`) to the type that it points to (`Usize`)
-  --> tests/ui/transmute.rs:102:24
+  --> tests/ui/transmute.rs:101:24
    |
 LL |         let _: Usize = core::mem::transmute(int_mut_ptr);
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a type (`Usize`) to a pointer to that type (`*const Usize`)
-  --> tests/ui/transmute.rs:105:31
+  --> tests/ui/transmute.rs:104:31
    |
 LL |         let _: *const Usize = core::mem::transmute(my_int());
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a type (`Usize`) to a pointer to that type (`*mut Usize`)
-  --> tests/ui/transmute.rs:108:29
+  --> tests/ui/transmute.rs:107:29
    |
 LL |         let _: *mut Usize = core::mem::transmute(my_int());
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a `u8` to a `bool`
-  --> tests/ui/transmute.rs:115:28
+  --> tests/ui/transmute.rs:114:28
    |
 LL |     let _: bool = unsafe { std::mem::transmute(0_u8) };
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `0_u8 != 0`
@@ -98,7 +86,7 @@ LL |     let _: bool = unsafe { std::mem::transmute(0_u8) };
    = help: to override `-D warnings` add `#[allow(clippy::transmute_int_to_bool)]`
 
 error: transmute from a `&[u8]` to a `&str`
-  --> tests/ui/transmute.rs:122:28
+  --> tests/ui/transmute.rs:121:28
    |
 LL |     let _: &str = unsafe { std::mem::transmute(B) };
    |                            ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::str::from_utf8(B).unwrap()`
@@ -107,16 +95,16 @@ LL |     let _: &str = unsafe { std::mem::transmute(B) };
    = help: to override `-D warnings` add `#[allow(clippy::transmute_bytes_to_str)]`
 
 error: transmute from a `&mut [u8]` to a `&mut str`
-  --> tests/ui/transmute.rs:125:32
+  --> tests/ui/transmute.rs:124:32
    |
 LL |     let _: &mut str = unsafe { std::mem::transmute(mb) };
    |                                ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::str::from_utf8_mut(mb).unwrap()`
 
 error: transmute from a `&[u8]` to a `&str`
-  --> tests/ui/transmute.rs:128:30
+  --> tests/ui/transmute.rs:127:30
    |
 LL |     const _: &str = unsafe { std::mem::transmute(B) };
    |                              ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::str::from_utf8_unchecked(B)`
 
-error: aborting due to 18 previous errors
+error: aborting due to 16 previous errors
 
diff --git a/tests/ui/transmutes_expressible_as_ptr_casts.fixed b/tests/ui/transmutes_expressible_as_ptr_casts.fixed
index e7ad2a1cbbcb1..02f67f79e2b19 100644
--- a/tests/ui/transmutes_expressible_as_ptr_casts.fixed
+++ b/tests/ui/transmutes_expressible_as_ptr_casts.fixed
@@ -13,9 +13,6 @@ fn main() {
     // We should see an error message for each transmute, and no error messages for
     // the casts, since the casts are the recommended fixes.
 
-    // e is an integer and U is *U_0, while U_0: Sized; addr-ptr-cast
-    let _ptr_i32_transmute = unsafe { usize::MAX as *const i32 };
-    //~^ useless_transmute
     let ptr_i32 = usize::MAX as *const i32;
 
     // e has type *T, U is *U_0, and either U_0: Sized ...
diff --git a/tests/ui/transmutes_expressible_as_ptr_casts.rs b/tests/ui/transmutes_expressible_as_ptr_casts.rs
index 42a81777a8267..c5e156405ebca 100644
--- a/tests/ui/transmutes_expressible_as_ptr_casts.rs
+++ b/tests/ui/transmutes_expressible_as_ptr_casts.rs
@@ -13,9 +13,6 @@ fn main() {
     // We should see an error message for each transmute, and no error messages for
     // the casts, since the casts are the recommended fixes.
 
-    // e is an integer and U is *U_0, while U_0: Sized; addr-ptr-cast
-    let _ptr_i32_transmute = unsafe { transmute::<usize, *const i32>(usize::MAX) };
-    //~^ useless_transmute
     let ptr_i32 = usize::MAX as *const i32;
 
     // e has type *T, U is *U_0, and either U_0: Sized ...
diff --git a/tests/ui/transmutes_expressible_as_ptr_casts.stderr b/tests/ui/transmutes_expressible_as_ptr_casts.stderr
index 7746f087cc714..f39a64d57eb49 100644
--- a/tests/ui/transmutes_expressible_as_ptr_casts.stderr
+++ b/tests/ui/transmutes_expressible_as_ptr_casts.stderr
@@ -1,14 +1,5 @@
-error: transmute from an integer to a pointer
-  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:17:39
-   |
-LL |     let _ptr_i32_transmute = unsafe { transmute::<usize, *const i32>(usize::MAX) };
-   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `usize::MAX as *const i32`
-   |
-   = note: `-D clippy::useless-transmute` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::useless_transmute)]`
-
 error: transmute from a pointer to a pointer
-  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:22:38
+  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:19:38
    |
 LL |     let _ptr_i8_transmute = unsafe { transmute::<*const i32, *const i8>(ptr_i32) };
    |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -22,7 +13,7 @@ LL +     let _ptr_i8_transmute = unsafe { ptr_i32.cast::<i8>() };
    |
 
 error: transmute from a pointer to a pointer
-  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:29:46
+  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:26:46
    |
 LL |     let _ptr_to_unsized_transmute = unsafe { transmute::<*const [i32], *const [u32]>(slice_ptr) };
    |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -34,7 +25,7 @@ LL +     let _ptr_to_unsized_transmute = unsafe { slice_ptr as *const [u32] };
    |
 
 error: transmute from `*const i32` to `usize` which could be expressed as a pointer cast instead
-  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:36:50
+  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:33:50
    |
 LL |     let _usize_from_int_ptr_transmute = unsafe { transmute::<*const i32, usize>(ptr_i32) };
    |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `ptr_i32 as usize`
@@ -43,40 +34,43 @@ LL |     let _usize_from_int_ptr_transmute = unsafe { transmute::<*const i32, us
    = help: to override `-D warnings` add `#[allow(clippy::transmutes_expressible_as_ptr_casts)]`
 
 error: transmute from a reference to a pointer
-  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:43:41
+  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:40:41
    |
 LL |     let _array_ptr_transmute = unsafe { transmute::<&[i32; 4], *const [i32; 4]>(array_ref) };
    |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `array_ref as *const [i32; 4]`
+   |
+   = note: `-D clippy::useless-transmute` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::useless_transmute)]`
 
 error: transmute from `fn(usize) -> u8` to `*const usize` which could be expressed as a pointer cast instead
-  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:52:41
+  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:49:41
    |
 LL |     let _usize_ptr_transmute = unsafe { transmute::<fn(usize) -> u8, *const usize>(foo) };
    |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `foo as *const usize`
 
 error: transmute from `fn(usize) -> u8` to `usize` which could be expressed as a pointer cast instead
-  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:57:49
+  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:54:49
    |
 LL |     let _usize_from_fn_ptr_transmute = unsafe { transmute::<fn(usize) -> u8, usize>(foo) };
    |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `foo as usize`
 
 error: transmute from `*const u32` to `usize` which could be expressed as a pointer cast instead
-  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:61:36
+  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:58:36
    |
 LL |     let _usize_from_ref = unsafe { transmute::<*const u32, usize>(&1u32) };
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&1u32 as *const u32 as usize`
 
 error: transmute from a reference to a pointer
-  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:73:14
+  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:70:14
    |
 LL |     unsafe { transmute::<&[i32; 1], *const u8>(in_param) }
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `in_param as *const [i32; 1] as *const u8`
 
 error: transmute from `fn()` to `*const u8` which could be expressed as a pointer cast instead
-  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:92:28
+  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:89:28
    |
 LL |     let _x: u8 = unsafe { *std::mem::transmute::<fn(), *const u8>(f) };
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(f as *const u8)`
 
-error: aborting due to 10 previous errors
+error: aborting due to 9 previous errors
 

From fdde09b8c3afc7712a511096f37e54fb5efbd78e Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sat, 23 Aug 2025 20:54:02 +0000
Subject: [PATCH 0247/1889] Use unnamed lifetime spans as primary spans for
 MISMATCHED_LIFETIME_SYNTAXES

---
 tests/ui/ptr_arg.stderr | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/ui/ptr_arg.stderr b/tests/ui/ptr_arg.stderr
index 87235057349e3..f32e83d8b8184 100644
--- a/tests/ui/ptr_arg.stderr
+++ b/tests/ui/ptr_arg.stderr
@@ -268,10 +268,10 @@ LL |     fn barbar(_x: &mut Vec<u32>, y: &mut String) {
    |                                     ^^^^^^^^^^^ help: change this to: `&mut str`
 
 error: eliding a lifetime that's named elsewhere is confusing
-  --> tests/ui/ptr_arg.rs:314:36
+  --> tests/ui/ptr_arg.rs:314:56
    |
 LL |     fn cow_good_ret_ty<'a>(input: &'a Cow<'a, str>) -> &str {
-   |                                    ^^     ^^           ---- the same lifetime is elided here
+   |                                    --     --           ^^^^ the same lifetime is elided here
    |                                    |      |
    |                                    |      the lifetime is named here
    |                                    the lifetime is named here

From 02111a4d30fafde6db2a26edc60217a76670a5dc Mon Sep 17 00:00:00 2001
From: Zihan <zihanli0822@gmail.com>
Date: Thu, 7 Aug 2025 18:27:13 -0400
Subject: [PATCH 0248/1889] `cast_slice_from_raw_parts`: check for implicit
 cast to raw slice pointer

changelog: [`cast_slice_from_raw_parts`]: check for implicit cast to raw slice pointer

Signed-off-by: Zihan <zihanli0822@gmail.com>
---
 .../src/casts/cast_slice_from_raw_parts.rs    | 39 ++++++++++++++
 clippy_lints/src/casts/mod.rs                 |  3 ++
 tests/ui/cast_raw_slice_pointer_cast.fixed    | 25 ++++++++-
 tests/ui/cast_raw_slice_pointer_cast.rs       | 25 ++++++++-
 tests/ui/cast_raw_slice_pointer_cast.stderr   | 52 ++++++++++++++++---
 5 files changed, 134 insertions(+), 10 deletions(-)

diff --git a/clippy_lints/src/casts/cast_slice_from_raw_parts.rs b/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
index 46b0c88d3feda..24bfb73556488 100644
--- a/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
+++ b/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
@@ -1,10 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::get_parent_expr;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_context;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
+use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow};
 use rustc_middle::ty::{self, Ty};
 use rustc_span::sym;
 
@@ -53,3 +55,40 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
         );
     }
 }
+
+/// Checks for implicit cast from slice reference to raw slice pointer.
+pub(super) fn check_implicit_cast(cx: &LateContext<'_>, expr: &Expr<'_>) {
+    if let ExprKind::Call(fun, [ptr_arg, len_arg]) = expr.peel_blocks().kind
+        && let ExprKind::Path(ref qpath) = fun.kind
+        && let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id()
+        && let Some(rpk) = raw_parts_kind(cx, fun_def_id)
+        && !matches!(get_parent_expr(cx, expr).map(|e| e.kind), Some(ExprKind::Cast(..)))
+        && let [deref, borrow] = cx.typeck_results().expr_adjustments(expr)
+        && matches!(deref.kind, Adjust::Deref(..))
+        && let Adjustment {
+            kind: Adjust::Borrow(AutoBorrow::RawPtr(..)),
+            target,
+        } = borrow
+        && let ty::RawPtr(pointee_ty, _) = target.kind()
+        && pointee_ty.is_slice()
+        && !expr.span.from_expansion()
+    {
+        let func = match rpk {
+            RawPartsKind::Immutable => "from_raw_parts",
+            RawPartsKind::Mutable => "from_raw_parts_mut",
+        };
+        let mut applicability = Applicability::MachineApplicable;
+        let ctxt = expr.span.ctxt();
+        let ptr = snippet_with_context(cx, ptr_arg.span, ctxt, "ptr", &mut applicability).0;
+        let len = snippet_with_context(cx, len_arg.span, ctxt, "len", &mut applicability).0;
+        span_lint_and_sugg(
+            cx,
+            CAST_SLICE_FROM_RAW_PARTS,
+            expr.span,
+            format!("implicitly casting the result of `{func}` to `{target}`"),
+            "replace_with",
+            format!("core::ptr::slice_{func}({ptr}, {len})"),
+            applicability,
+        );
+    }
+}
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index dcc439a272cf8..bbdb0eabbabd1 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -910,6 +910,9 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
         if self.msrv.meets(cx, msrvs::RAW_REF_OP) {
             borrow_as_ptr::check_implicit_cast(cx, expr);
         }
+        if self.msrv.meets(cx, msrvs::PTR_SLICE_RAW_PARTS) {
+            cast_slice_from_raw_parts::check_implicit_cast(cx, expr);
+        }
         cast_ptr_alignment::check(cx, expr);
         char_lit_as_u8::check(cx, expr);
         ptr_as_ptr::check(cx, expr, self.msrv);
diff --git a/tests/ui/cast_raw_slice_pointer_cast.fixed b/tests/ui/cast_raw_slice_pointer_cast.fixed
index bddcb0ebf64e6..14e232d0d2a62 100644
--- a/tests/ui/cast_raw_slice_pointer_cast.fixed
+++ b/tests/ui/cast_raw_slice_pointer_cast.fixed
@@ -1,6 +1,7 @@
 #![warn(clippy::cast_slice_from_raw_parts)]
 
-#[allow(unused_imports, unused_unsafe)]
+const fn require_raw_slice_ptr<T>(_: *const [T]) {}
+
 fn main() {
     let mut vec = vec![0u8; 1];
     let ptr: *const u8 = vec.as_ptr();
@@ -27,4 +28,26 @@ fn main() {
         let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
         //~^ cast_slice_from_raw_parts
     }
+
+    // implicit cast
+    {
+        let _: *const [u8] = unsafe { core::ptr::slice_from_raw_parts(ptr, 1) };
+        //~^ cast_slice_from_raw_parts
+        let _: *mut [u8] = unsafe { core::ptr::slice_from_raw_parts_mut(mptr, 1) };
+        //~^ cast_slice_from_raw_parts
+        require_raw_slice_ptr(unsafe { core::ptr::slice_from_raw_parts(ptr, 1) });
+        //~^ cast_slice_from_raw_parts
+    }
+
+    // implicit cast in const context
+    const {
+        const PTR: *const u8 = std::ptr::null();
+        const MPTR: *mut u8 = std::ptr::null_mut();
+        let _: *const [u8] = unsafe { std::ptr::slice_from_raw_parts(PTR, 1) };
+        //~^ cast_slice_from_raw_parts
+        let _: *mut [u8] = unsafe { std::ptr::slice_from_raw_parts_mut(MPTR, 1) };
+        //~^ cast_slice_from_raw_parts
+        require_raw_slice_ptr(unsafe { std::ptr::slice_from_raw_parts(PTR, 1) });
+        //~^ cast_slice_from_raw_parts
+    };
 }
diff --git a/tests/ui/cast_raw_slice_pointer_cast.rs b/tests/ui/cast_raw_slice_pointer_cast.rs
index 0a1eb276d5e9e..8f57b1f961928 100644
--- a/tests/ui/cast_raw_slice_pointer_cast.rs
+++ b/tests/ui/cast_raw_slice_pointer_cast.rs
@@ -1,6 +1,7 @@
 #![warn(clippy::cast_slice_from_raw_parts)]
 
-#[allow(unused_imports, unused_unsafe)]
+const fn require_raw_slice_ptr<T>(_: *const [T]) {}
+
 fn main() {
     let mut vec = vec![0u8; 1];
     let ptr: *const u8 = vec.as_ptr();
@@ -27,4 +28,26 @@ fn main() {
         let _: *const [u8] = unsafe { one::from_raw_parts(ptr, 1) } as *const [u8];
         //~^ cast_slice_from_raw_parts
     }
+
+    // implicit cast
+    {
+        let _: *const [u8] = unsafe { std::slice::from_raw_parts(ptr, 1) };
+        //~^ cast_slice_from_raw_parts
+        let _: *mut [u8] = unsafe { std::slice::from_raw_parts_mut(mptr, 1) };
+        //~^ cast_slice_from_raw_parts
+        require_raw_slice_ptr(unsafe { std::slice::from_raw_parts(ptr, 1) });
+        //~^ cast_slice_from_raw_parts
+    }
+
+    // implicit cast in const context
+    const {
+        const PTR: *const u8 = std::ptr::null();
+        const MPTR: *mut u8 = std::ptr::null_mut();
+        let _: *const [u8] = unsafe { std::slice::from_raw_parts(PTR, 1) };
+        //~^ cast_slice_from_raw_parts
+        let _: *mut [u8] = unsafe { std::slice::from_raw_parts_mut(MPTR, 1) };
+        //~^ cast_slice_from_raw_parts
+        require_raw_slice_ptr(unsafe { std::slice::from_raw_parts(PTR, 1) });
+        //~^ cast_slice_from_raw_parts
+    };
 }
diff --git a/tests/ui/cast_raw_slice_pointer_cast.stderr b/tests/ui/cast_raw_slice_pointer_cast.stderr
index 60794a988db7d..e70cc593bb04d 100644
--- a/tests/ui/cast_raw_slice_pointer_cast.stderr
+++ b/tests/ui/cast_raw_slice_pointer_cast.stderr
@@ -1,5 +1,5 @@
 error: casting the result of `from_raw_parts` to *const [u8]
-  --> tests/ui/cast_raw_slice_pointer_cast.rs:8:35
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:9:35
    |
 LL |     let _: *const [u8] = unsafe { std::slice::from_raw_parts(ptr, 1) as *const [u8] };
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
@@ -8,40 +8,76 @@ LL |     let _: *const [u8] = unsafe { std::slice::from_raw_parts(ptr, 1) as *co
    = help: to override `-D warnings` add `#[allow(clippy::cast_slice_from_raw_parts)]`
 
 error: casting the result of `from_raw_parts_mut` to *mut [u8]
-  --> tests/ui/cast_raw_slice_pointer_cast.rs:10:35
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:11:35
    |
 LL |     let _: *const [u8] = unsafe { std::slice::from_raw_parts_mut(mptr, 1) as *mut [u8] };
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts_mut(mptr, 1)`
 
 error: casting the result of `from_raw_parts` to *const [u8]
-  --> tests/ui/cast_raw_slice_pointer_cast.rs:12:26
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:13:26
    |
 LL |     let _: *const [u8] = unsafe { std::slice::from_raw_parts(ptr, 1) } as *const [u8];
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
 
 error: casting the result of `from_raw_parts` to *const [u8]
-  --> tests/ui/cast_raw_slice_pointer_cast.rs:16:30
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:17:30
    |
 LL |         let _: *const [u8] = unsafe { slice::from_raw_parts(ptr, 1) } as *const [u8];
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
 
 error: casting the result of `from_raw_parts` to *const [u8]
-  --> tests/ui/cast_raw_slice_pointer_cast.rs:19:30
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:20:30
    |
 LL |         let _: *const [u8] = unsafe { one::from_raw_parts(ptr, 1) } as *const [u8];
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
 
 error: casting the result of `from_raw_parts` to *const [u8]
-  --> tests/ui/cast_raw_slice_pointer_cast.rs:24:30
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:25:30
    |
 LL |         let _: *const [u8] = unsafe { slice::from_raw_parts(ptr, 1) } as *const [u8];
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
 
 error: casting the result of `from_raw_parts` to *const [u8]
-  --> tests/ui/cast_raw_slice_pointer_cast.rs:27:30
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:28:30
    |
 LL |         let _: *const [u8] = unsafe { one::from_raw_parts(ptr, 1) } as *const [u8];
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
 
-error: aborting due to 7 previous errors
+error: implicitly casting the result of `from_raw_parts` to `*const [u8]`
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:34:39
+   |
+LL |         let _: *const [u8] = unsafe { std::slice::from_raw_parts(ptr, 1) };
+   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+
+error: implicitly casting the result of `from_raw_parts_mut` to `*mut [u8]`
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:36:37
+   |
+LL |         let _: *mut [u8] = unsafe { std::slice::from_raw_parts_mut(mptr, 1) };
+   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `core::ptr::slice_from_raw_parts_mut(mptr, 1)`
+
+error: implicitly casting the result of `from_raw_parts` to `*const [u8]`
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:38:40
+   |
+LL |         require_raw_slice_ptr(unsafe { std::slice::from_raw_parts(ptr, 1) });
+   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+
+error: implicitly casting the result of `from_raw_parts` to `*const [u8]`
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:46:39
+   |
+LL |         let _: *const [u8] = unsafe { std::slice::from_raw_parts(PTR, 1) };
+   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `std::ptr::slice_from_raw_parts(PTR, 1)`
+
+error: implicitly casting the result of `from_raw_parts_mut` to `*mut [u8]`
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:48:37
+   |
+LL |         let _: *mut [u8] = unsafe { std::slice::from_raw_parts_mut(MPTR, 1) };
+   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `std::ptr::slice_from_raw_parts_mut(MPTR, 1)`
+
+error: implicitly casting the result of `from_raw_parts` to `*const [u8]`
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:50:40
+   |
+LL |         require_raw_slice_ptr(unsafe { std::slice::from_raw_parts(PTR, 1) });
+   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `std::ptr::slice_from_raw_parts(PTR, 1)`
+
+error: aborting due to 13 previous errors
 

From 42cc75973fa1713530b588e651d0d9203c226fb2 Mon Sep 17 00:00:00 2001
From: Zihan <zihanli0822@gmail.com>
Date: Thu, 7 Aug 2025 19:29:22 -0400
Subject: [PATCH 0249/1889] changelog: [`cast_slice_from_raw_parts`]: properly
 select std/core

Signed-off-by: Zihan <zihanli0822@gmail.com>
---
 .../src/casts/cast_slice_from_raw_parts.rs    |  8 +-
 tests/ui/cast_raw_slice_pointer_cast.fixed    | 20 ++---
 tests/ui/cast_raw_slice_pointer_cast.stderr   | 20 ++---
 .../cast_raw_slice_pointer_cast_no_std.fixed  | 55 ++++++++++++
 .../ui/cast_raw_slice_pointer_cast_no_std.rs  | 55 ++++++++++++
 .../cast_raw_slice_pointer_cast_no_std.stderr | 83 +++++++++++++++++++
 6 files changed, 218 insertions(+), 23 deletions(-)
 create mode 100644 tests/ui/cast_raw_slice_pointer_cast_no_std.fixed
 create mode 100644 tests/ui/cast_raw_slice_pointer_cast_no_std.rs
 create mode 100644 tests/ui/cast_raw_slice_pointer_cast_no_std.stderr

diff --git a/clippy_lints/src/casts/cast_slice_from_raw_parts.rs b/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
index 24bfb73556488..bce7b4c69cc62 100644
--- a/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
+++ b/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::get_parent_expr;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_context;
+use clippy_utils::{get_parent_expr, is_no_std_crate};
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{Expr, ExprKind};
@@ -44,13 +44,14 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
         let mut applicability = Applicability::MachineApplicable;
         let ptr = snippet_with_context(cx, ptr_arg.span, ctxt, "ptr", &mut applicability).0;
         let len = snippet_with_context(cx, len_arg.span, ctxt, "len", &mut applicability).0;
+        let krate = if is_no_std_crate(cx) { "core" } else { "std" };
         span_lint_and_sugg(
             cx,
             CAST_SLICE_FROM_RAW_PARTS,
             span,
             format!("casting the result of `{func}` to {cast_to}"),
             "replace with",
-            format!("core::ptr::slice_{func}({ptr}, {len})"),
+            format!("{krate}::ptr::slice_{func}({ptr}, {len})"),
             applicability,
         );
     }
@@ -81,13 +82,14 @@ pub(super) fn check_implicit_cast(cx: &LateContext<'_>, expr: &Expr<'_>) {
         let ctxt = expr.span.ctxt();
         let ptr = snippet_with_context(cx, ptr_arg.span, ctxt, "ptr", &mut applicability).0;
         let len = snippet_with_context(cx, len_arg.span, ctxt, "len", &mut applicability).0;
+        let krate = if is_no_std_crate(cx) { "core" } else { "std" };
         span_lint_and_sugg(
             cx,
             CAST_SLICE_FROM_RAW_PARTS,
             expr.span,
             format!("implicitly casting the result of `{func}` to `{target}`"),
             "replace_with",
-            format!("core::ptr::slice_{func}({ptr}, {len})"),
+            format!("{krate}::ptr::slice_{func}({ptr}, {len})"),
             applicability,
         );
     }
diff --git a/tests/ui/cast_raw_slice_pointer_cast.fixed b/tests/ui/cast_raw_slice_pointer_cast.fixed
index 14e232d0d2a62..3c1cf8845957f 100644
--- a/tests/ui/cast_raw_slice_pointer_cast.fixed
+++ b/tests/ui/cast_raw_slice_pointer_cast.fixed
@@ -6,36 +6,36 @@ fn main() {
     let mut vec = vec![0u8; 1];
     let ptr: *const u8 = vec.as_ptr();
     let mptr = vec.as_mut_ptr();
-    let _: *const [u8] = unsafe { core::ptr::slice_from_raw_parts(ptr, 1) };
+    let _: *const [u8] = unsafe { std::ptr::slice_from_raw_parts(ptr, 1) };
     //~^ cast_slice_from_raw_parts
-    let _: *const [u8] = unsafe { core::ptr::slice_from_raw_parts_mut(mptr, 1) };
+    let _: *const [u8] = unsafe { std::ptr::slice_from_raw_parts_mut(mptr, 1) };
     //~^ cast_slice_from_raw_parts
-    let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+    let _: *const [u8] = std::ptr::slice_from_raw_parts(ptr, 1);
     //~^ cast_slice_from_raw_parts
     {
         use core::slice;
-        let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+        let _: *const [u8] = std::ptr::slice_from_raw_parts(ptr, 1);
         //~^ cast_slice_from_raw_parts
         use slice as one;
-        let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+        let _: *const [u8] = std::ptr::slice_from_raw_parts(ptr, 1);
         //~^ cast_slice_from_raw_parts
     }
     {
         use std::slice;
-        let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+        let _: *const [u8] = std::ptr::slice_from_raw_parts(ptr, 1);
         //~^ cast_slice_from_raw_parts
         use slice as one;
-        let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+        let _: *const [u8] = std::ptr::slice_from_raw_parts(ptr, 1);
         //~^ cast_slice_from_raw_parts
     }
 
     // implicit cast
     {
-        let _: *const [u8] = unsafe { core::ptr::slice_from_raw_parts(ptr, 1) };
+        let _: *const [u8] = unsafe { std::ptr::slice_from_raw_parts(ptr, 1) };
         //~^ cast_slice_from_raw_parts
-        let _: *mut [u8] = unsafe { core::ptr::slice_from_raw_parts_mut(mptr, 1) };
+        let _: *mut [u8] = unsafe { std::ptr::slice_from_raw_parts_mut(mptr, 1) };
         //~^ cast_slice_from_raw_parts
-        require_raw_slice_ptr(unsafe { core::ptr::slice_from_raw_parts(ptr, 1) });
+        require_raw_slice_ptr(unsafe { std::ptr::slice_from_raw_parts(ptr, 1) });
         //~^ cast_slice_from_raw_parts
     }
 
diff --git a/tests/ui/cast_raw_slice_pointer_cast.stderr b/tests/ui/cast_raw_slice_pointer_cast.stderr
index e70cc593bb04d..328dbafbafe7a 100644
--- a/tests/ui/cast_raw_slice_pointer_cast.stderr
+++ b/tests/ui/cast_raw_slice_pointer_cast.stderr
@@ -2,7 +2,7 @@ error: casting the result of `from_raw_parts` to *const [u8]
   --> tests/ui/cast_raw_slice_pointer_cast.rs:9:35
    |
 LL |     let _: *const [u8] = unsafe { std::slice::from_raw_parts(ptr, 1) as *const [u8] };
-   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `std::ptr::slice_from_raw_parts(ptr, 1)`
    |
    = note: `-D clippy::cast-slice-from-raw-parts` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::cast_slice_from_raw_parts)]`
@@ -11,55 +11,55 @@ error: casting the result of `from_raw_parts_mut` to *mut [u8]
   --> tests/ui/cast_raw_slice_pointer_cast.rs:11:35
    |
 LL |     let _: *const [u8] = unsafe { std::slice::from_raw_parts_mut(mptr, 1) as *mut [u8] };
-   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts_mut(mptr, 1)`
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `std::ptr::slice_from_raw_parts_mut(mptr, 1)`
 
 error: casting the result of `from_raw_parts` to *const [u8]
   --> tests/ui/cast_raw_slice_pointer_cast.rs:13:26
    |
 LL |     let _: *const [u8] = unsafe { std::slice::from_raw_parts(ptr, 1) } as *const [u8];
-   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `std::ptr::slice_from_raw_parts(ptr, 1)`
 
 error: casting the result of `from_raw_parts` to *const [u8]
   --> tests/ui/cast_raw_slice_pointer_cast.rs:17:30
    |
 LL |         let _: *const [u8] = unsafe { slice::from_raw_parts(ptr, 1) } as *const [u8];
-   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `std::ptr::slice_from_raw_parts(ptr, 1)`
 
 error: casting the result of `from_raw_parts` to *const [u8]
   --> tests/ui/cast_raw_slice_pointer_cast.rs:20:30
    |
 LL |         let _: *const [u8] = unsafe { one::from_raw_parts(ptr, 1) } as *const [u8];
-   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `std::ptr::slice_from_raw_parts(ptr, 1)`
 
 error: casting the result of `from_raw_parts` to *const [u8]
   --> tests/ui/cast_raw_slice_pointer_cast.rs:25:30
    |
 LL |         let _: *const [u8] = unsafe { slice::from_raw_parts(ptr, 1) } as *const [u8];
-   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `std::ptr::slice_from_raw_parts(ptr, 1)`
 
 error: casting the result of `from_raw_parts` to *const [u8]
   --> tests/ui/cast_raw_slice_pointer_cast.rs:28:30
    |
 LL |         let _: *const [u8] = unsafe { one::from_raw_parts(ptr, 1) } as *const [u8];
-   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `std::ptr::slice_from_raw_parts(ptr, 1)`
 
 error: implicitly casting the result of `from_raw_parts` to `*const [u8]`
   --> tests/ui/cast_raw_slice_pointer_cast.rs:34:39
    |
 LL |         let _: *const [u8] = unsafe { std::slice::from_raw_parts(ptr, 1) };
-   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `std::ptr::slice_from_raw_parts(ptr, 1)`
 
 error: implicitly casting the result of `from_raw_parts_mut` to `*mut [u8]`
   --> tests/ui/cast_raw_slice_pointer_cast.rs:36:37
    |
 LL |         let _: *mut [u8] = unsafe { std::slice::from_raw_parts_mut(mptr, 1) };
-   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `core::ptr::slice_from_raw_parts_mut(mptr, 1)`
+   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `std::ptr::slice_from_raw_parts_mut(mptr, 1)`
 
 error: implicitly casting the result of `from_raw_parts` to `*const [u8]`
   --> tests/ui/cast_raw_slice_pointer_cast.rs:38:40
    |
 LL |         require_raw_slice_ptr(unsafe { std::slice::from_raw_parts(ptr, 1) });
-   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `std::ptr::slice_from_raw_parts(ptr, 1)`
 
 error: implicitly casting the result of `from_raw_parts` to `*const [u8]`
   --> tests/ui/cast_raw_slice_pointer_cast.rs:46:39
diff --git a/tests/ui/cast_raw_slice_pointer_cast_no_std.fixed b/tests/ui/cast_raw_slice_pointer_cast_no_std.fixed
new file mode 100644
index 0000000000000..f71fb8d863c6d
--- /dev/null
+++ b/tests/ui/cast_raw_slice_pointer_cast_no_std.fixed
@@ -0,0 +1,55 @@
+#![warn(clippy::cast_slice_from_raw_parts)]
+#![no_std]
+#![crate_type = "lib"]
+
+const fn require_raw_slice_ptr<T>(_: *const [T]) {}
+
+fn main() {
+    let mut arr = [0u8; 1];
+    let ptr: *const u8 = arr.as_ptr();
+    let mptr = arr.as_mut_ptr();
+    let _: *const [u8] = unsafe { core::ptr::slice_from_raw_parts(ptr, 1) };
+    //~^ cast_slice_from_raw_parts
+    let _: *const [u8] = unsafe { core::ptr::slice_from_raw_parts_mut(mptr, 1) };
+    //~^ cast_slice_from_raw_parts
+    let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+    //~^ cast_slice_from_raw_parts
+    {
+        use core::slice;
+        let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+        //~^ cast_slice_from_raw_parts
+        use slice as one;
+        let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+        //~^ cast_slice_from_raw_parts
+    }
+    {
+        use core::slice;
+        let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+        //~^ cast_slice_from_raw_parts
+        use slice as one;
+        let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+        //~^ cast_slice_from_raw_parts
+    }
+
+    // implicit cast
+    {
+        let _: *const [u8] = unsafe { core::ptr::slice_from_raw_parts(ptr, 1) };
+        //~^ cast_slice_from_raw_parts
+        let _: *mut [u8] = unsafe { core::ptr::slice_from_raw_parts_mut(mptr, 1) };
+        //~^ cast_slice_from_raw_parts
+        require_raw_slice_ptr(unsafe { core::ptr::slice_from_raw_parts(ptr, 1) });
+        //~^ cast_slice_from_raw_parts
+    }
+
+    // implicit cast in const context
+    const {
+        const PTR: *const u8 = core::ptr::null();
+        const MPTR: *mut u8 = core::ptr::null_mut();
+        let _: *const [u8] = unsafe { core::ptr::slice_from_raw_parts(PTR, 1) };
+        //~^ cast_slice_from_raw_parts
+        let _: *mut [u8] = unsafe { core::ptr::slice_from_raw_parts_mut(MPTR, 1) };
+        //~^ cast_slice_from_raw_parts
+        require_raw_slice_ptr(unsafe { core::ptr::slice_from_raw_parts(PTR, 1) });
+        //~^ cast_slice_from_raw_parts
+    };
+}
diff --git a/tests/ui/cast_raw_slice_pointer_cast_no_std.rs b/tests/ui/cast_raw_slice_pointer_cast_no_std.rs
new file mode 100644
index 0000000000000..743e44c97dc13
--- /dev/null
+++ b/tests/ui/cast_raw_slice_pointer_cast_no_std.rs
@@ -0,0 +1,55 @@
+#![warn(clippy::cast_slice_from_raw_parts)]
+#![no_std]
+#![crate_type = "lib"]
+
+const fn require_raw_slice_ptr<T>(_: *const [T]) {}
+
+fn main() {
+    let mut arr = [0u8; 1];
+    let ptr: *const u8 = arr.as_ptr();
+    let mptr = arr.as_mut_ptr();
+    let _: *const [u8] = unsafe { core::slice::from_raw_parts(ptr, 1) as *const [u8] };
+    //~^ cast_slice_from_raw_parts
+    let _: *const [u8] = unsafe { core::slice::from_raw_parts_mut(mptr, 1) as *mut [u8] };
+    //~^ cast_slice_from_raw_parts
+    let _: *const [u8] = unsafe { core::slice::from_raw_parts(ptr, 1) } as *const [u8];
+    //~^ cast_slice_from_raw_parts
+    {
+        use core::slice;
+        let _: *const [u8] = unsafe { slice::from_raw_parts(ptr, 1) } as *const [u8];
+        //~^ cast_slice_from_raw_parts
+        use slice as one;
+        let _: *const [u8] = unsafe { one::from_raw_parts(ptr, 1) } as *const [u8];
+        //~^ cast_slice_from_raw_parts
+    }
+    {
+        use core::slice;
+        let _: *const [u8] = unsafe { slice::from_raw_parts(ptr, 1) } as *const [u8];
+        //~^ cast_slice_from_raw_parts
+        use slice as one;
+        let _: *const [u8] = unsafe { one::from_raw_parts(ptr, 1) } as *const [u8];
+        //~^ cast_slice_from_raw_parts
+    }
+
+    // implicit cast
+    {
+        let _: *const [u8] = unsafe { core::slice::from_raw_parts(ptr, 1) };
+        //~^ cast_slice_from_raw_parts
+        let _: *mut [u8] = unsafe { core::slice::from_raw_parts_mut(mptr, 1) };
+        //~^ cast_slice_from_raw_parts
+        require_raw_slice_ptr(unsafe { core::slice::from_raw_parts(ptr, 1) });
+        //~^ cast_slice_from_raw_parts
+    }
+
+    // implicit cast in const context
+    const {
+        const PTR: *const u8 = core::ptr::null();
+        const MPTR: *mut u8 = core::ptr::null_mut();
+        let _: *const [u8] = unsafe { core::slice::from_raw_parts(PTR, 1) };
+        //~^ cast_slice_from_raw_parts
+        let _: *mut [u8] = unsafe { core::slice::from_raw_parts_mut(MPTR, 1) };
+        //~^ cast_slice_from_raw_parts
+        require_raw_slice_ptr(unsafe { core::slice::from_raw_parts(PTR, 1) });
+        //~^ cast_slice_from_raw_parts
+    };
+}
diff --git a/tests/ui/cast_raw_slice_pointer_cast_no_std.stderr b/tests/ui/cast_raw_slice_pointer_cast_no_std.stderr
new file mode 100644
index 0000000000000..5488fbcfa1ce5
--- /dev/null
+++ b/tests/ui/cast_raw_slice_pointer_cast_no_std.stderr
@@ -0,0 +1,83 @@
+error: casting the result of `from_raw_parts` to *const [u8]
+  --> tests/ui/cast_raw_slice_pointer_cast_no_std.rs:11:35
+   |
+LL |     let _: *const [u8] = unsafe { core::slice::from_raw_parts(ptr, 1) as *const [u8] };
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+   |
+   = note: `-D clippy::cast-slice-from-raw-parts` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::cast_slice_from_raw_parts)]`
+
+error: casting the result of `from_raw_parts_mut` to *mut [u8]
+  --> tests/ui/cast_raw_slice_pointer_cast_no_std.rs:13:35
+   |
+LL |     let _: *const [u8] = unsafe { core::slice::from_raw_parts_mut(mptr, 1) as *mut [u8] };
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts_mut(mptr, 1)`
+
+error: casting the result of `from_raw_parts` to *const [u8]
+  --> tests/ui/cast_raw_slice_pointer_cast_no_std.rs:15:26
+   |
+LL |     let _: *const [u8] = unsafe { core::slice::from_raw_parts(ptr, 1) } as *const [u8];
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+
+error: casting the result of `from_raw_parts` to *const [u8]
+  --> tests/ui/cast_raw_slice_pointer_cast_no_std.rs:19:30
+   |
+LL |         let _: *const [u8] = unsafe { slice::from_raw_parts(ptr, 1) } as *const [u8];
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+
+error: casting the result of `from_raw_parts` to *const [u8]
+  --> tests/ui/cast_raw_slice_pointer_cast_no_std.rs:22:30
+   |
+LL |         let _: *const [u8] = unsafe { one::from_raw_parts(ptr, 1) } as *const [u8];
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+
+error: casting the result of `from_raw_parts` to *const [u8]
+  --> tests/ui/cast_raw_slice_pointer_cast_no_std.rs:27:30
+   |
+LL |         let _: *const [u8] = unsafe { slice::from_raw_parts(ptr, 1) } as *const [u8];
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+
+error: casting the result of `from_raw_parts` to *const [u8]
+  --> tests/ui/cast_raw_slice_pointer_cast_no_std.rs:30:30
+   |
+LL |         let _: *const [u8] = unsafe { one::from_raw_parts(ptr, 1) } as *const [u8];
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+
+error: implicitly casting the result of `from_raw_parts` to `*const [u8]`
+  --> tests/ui/cast_raw_slice_pointer_cast_no_std.rs:36:39
+   |
+LL |         let _: *const [u8] = unsafe { core::slice::from_raw_parts(ptr, 1) };
+   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+
+error: implicitly casting the result of `from_raw_parts_mut` to `*mut [u8]`
+  --> tests/ui/cast_raw_slice_pointer_cast_no_std.rs:38:37
+   |
+LL |         let _: *mut [u8] = unsafe { core::slice::from_raw_parts_mut(mptr, 1) };
+   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `core::ptr::slice_from_raw_parts_mut(mptr, 1)`
+
+error: implicitly casting the result of `from_raw_parts` to `*const [u8]`
+  --> tests/ui/cast_raw_slice_pointer_cast_no_std.rs:40:40
+   |
+LL |         require_raw_slice_ptr(unsafe { core::slice::from_raw_parts(ptr, 1) });
+   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+
+error: implicitly casting the result of `from_raw_parts` to `*const [u8]`
+  --> tests/ui/cast_raw_slice_pointer_cast_no_std.rs:48:39
+   |
+LL |         let _: *const [u8] = unsafe { core::slice::from_raw_parts(PTR, 1) };
+   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `core::ptr::slice_from_raw_parts(PTR, 1)`
+
+error: implicitly casting the result of `from_raw_parts_mut` to `*mut [u8]`
+  --> tests/ui/cast_raw_slice_pointer_cast_no_std.rs:50:37
+   |
+LL |         let _: *mut [u8] = unsafe { core::slice::from_raw_parts_mut(MPTR, 1) };
+   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `core::ptr::slice_from_raw_parts_mut(MPTR, 1)`
+
+error: implicitly casting the result of `from_raw_parts` to `*const [u8]`
+  --> tests/ui/cast_raw_slice_pointer_cast_no_std.rs:52:40
+   |
+LL |         require_raw_slice_ptr(unsafe { core::slice::from_raw_parts(PTR, 1) });
+   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `core::ptr::slice_from_raw_parts(PTR, 1)`
+
+error: aborting due to 13 previous errors
+

From 4715c6d41a949358e8dd8dd96de0650939c8bf6b Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Sun, 24 Aug 2025 02:26:37 +0300
Subject: [PATCH 0250/1889] Add an option to remove reborrows from adjustment
 inlay hints

Reborrows are consecutive deref then ref. Make it the default because reborrows are mostly useless to the programmer.

Also rename `rust-analyzer.inlayHints.expressionAdjustmentHints.enable: "reborrow"` to `rust-analyzer.inlayHints.expressionAdjustmentHints.enable: "borrows"`, as it's not about reborrows but about any ref/deref and it's confusing with the new setting.
---
 .../crates/ide/src/inlay_hints.rs             |  4 +-
 .../crates/ide/src/inlay_hints/adjustment.rs  | 49 ++++++++++++++++++-
 .../crates/ide/src/static_index.rs            |  1 +
 .../rust-analyzer/src/cli/analysis_stats.rs   |  1 +
 .../crates/rust-analyzer/src/config.rs        | 17 +++++--
 .../docs/book/src/configuration_generated.md  | 11 +++++
 .../rust-analyzer/editors/code/package.json   | 10 ++++
 7 files changed, 88 insertions(+), 5 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs b/src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs
index d7d3171664945..cc44ae8fc8b9e 100644
--- a/src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs
@@ -306,6 +306,7 @@ pub struct InlayHintsConfig {
     pub generic_parameter_hints: GenericParameterHints,
     pub chaining_hints: bool,
     pub adjustment_hints: AdjustmentHints,
+    pub adjustment_hints_disable_reborrows: bool,
     pub adjustment_hints_mode: AdjustmentHintsMode,
     pub adjustment_hints_hide_outside_unsafe: bool,
     pub closure_return_type_hints: ClosureReturnTypeHints,
@@ -430,7 +431,7 @@ pub enum LifetimeElisionHints {
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum AdjustmentHints {
     Always,
-    ReborrowOnly,
+    BorrowsOnly,
     Never,
 }
 
@@ -886,6 +887,7 @@ mod tests {
         closure_return_type_hints: ClosureReturnTypeHints::Never,
         closure_capture_hints: false,
         adjustment_hints: AdjustmentHints::Never,
+        adjustment_hints_disable_reborrows: false,
         adjustment_hints_mode: AdjustmentHintsMode::Prefix,
         adjustment_hints_hide_outside_unsafe: false,
         binding_mode_hints: false,
diff --git a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/adjustment.rs b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/adjustment.rs
index e39a5f8889a2c..0fd587a728408 100644
--- a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/adjustment.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/adjustment.rs
@@ -47,7 +47,22 @@ pub(super) fn hints(
 
     let descended = sema.descend_node_into_attributes(expr.clone()).pop();
     let desc_expr = descended.as_ref().unwrap_or(expr);
-    let adjustments = sema.expr_adjustments(desc_expr).filter(|it| !it.is_empty())?;
+    let mut adjustments = sema.expr_adjustments(desc_expr).filter(|it| !it.is_empty())?;
+
+    if config.adjustment_hints_disable_reborrows {
+        // Remove consecutive deref-ref, i.e. reborrows.
+        let mut i = 0;
+        while i < adjustments.len().saturating_sub(1) {
+            let [current, next, ..] = &adjustments[i..] else { unreachable!() };
+            if matches!(current.kind, Adjust::Deref(None))
+                && matches!(next.kind, Adjust::Borrow(AutoBorrow::Ref(_)))
+            {
+                adjustments.splice(i..i + 2, []);
+            } else {
+                i += 1;
+            }
+        }
+    }
 
     if let ast::Expr::BlockExpr(_) | ast::Expr::IfExpr(_) | ast::Expr::MatchExpr(_) = desc_expr {
         // Don't show unnecessary reborrows for these, they will just repeat the inner ones again
@@ -716,6 +731,38 @@ fn hello(it: &&[impl T]) {
   //^^(&**
   //^^)
 }
+"#,
+        );
+    }
+
+    #[test]
+    fn disable_reborrows() {
+        check_with_config(
+            InlayHintsConfig {
+                adjustment_hints: AdjustmentHints::Always,
+                adjustment_hints_disable_reborrows: true,
+                ..DISABLED_CONFIG
+            },
+            r#"
+#![rustc_coherence_is_core]
+
+trait ToOwned {
+    type Owned;
+    fn to_owned(&self) -> Self::Owned;
+}
+
+struct String;
+impl ToOwned for str {
+    type Owned = String;
+    fn to_owned(&self) -> Self::Owned { String }
+}
+
+fn a(s: &String) {}
+
+fn main() {
+    let s = "".to_owned();
+    a(&s)
+}
 "#,
         );
     }
diff --git a/src/tools/rust-analyzer/crates/ide/src/static_index.rs b/src/tools/rust-analyzer/crates/ide/src/static_index.rs
index 14b6529c61f8c..8c3275df1baab 100644
--- a/src/tools/rust-analyzer/crates/ide/src/static_index.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/static_index.rs
@@ -169,6 +169,7 @@ impl StaticIndex<'_> {
                     closure_return_type_hints: crate::ClosureReturnTypeHints::WithBlock,
                     lifetime_elision_hints: crate::LifetimeElisionHints::Never,
                     adjustment_hints: crate::AdjustmentHints::Never,
+                    adjustment_hints_disable_reborrows: true,
                     adjustment_hints_mode: AdjustmentHintsMode::Prefix,
                     adjustment_hints_hide_outside_unsafe: false,
                     implicit_drop_hints: false,
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
index 6c0aa19f57482..b17186f8d7b1e 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -1137,6 +1137,7 @@ impl flags::AnalysisStats {
                     },
                     chaining_hints: true,
                     adjustment_hints: ide::AdjustmentHints::Always,
+                    adjustment_hints_disable_reborrows: true,
                     adjustment_hints_mode: ide::AdjustmentHintsMode::Postfix,
                     adjustment_hints_hide_outside_unsafe: false,
                     closure_return_type_hints: ide::ClosureReturnTypeHints::Always,
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
index d4cd56dc55bf6..c2252185a3aa3 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
@@ -226,6 +226,14 @@ config_data! {
         inlayHints_discriminantHints_enable: DiscriminantHintsDef =
             DiscriminantHintsDef::Never,
 
+        /// Disable reborrows in expression adjustments inlay hints.
+        ///
+        /// Reborrows are a pair of a builtin deref then borrow, i.e. `&*`. They are inserted by the compiler but are mostly useless to the programmer.
+        ///
+        /// Note: if the deref is not builtin (an overloaded deref), or the borrow is `&raw const`/`&raw mut`, they are not removed.
+        inlayHints_expressionAdjustmentHints_disableReborrows: bool =
+            true,
+
         /// Show inlay hints for type adjustments.
         inlayHints_expressionAdjustmentHints_enable: AdjustmentHintsDef =
             AdjustmentHintsDef::Never,
@@ -1888,12 +1896,14 @@ impl Config {
                 AdjustmentHintsDef::Always => ide::AdjustmentHints::Always,
                 AdjustmentHintsDef::Never => match self.inlayHints_reborrowHints_enable() {
                     ReborrowHintsDef::Always | ReborrowHintsDef::Mutable => {
-                        ide::AdjustmentHints::ReborrowOnly
+                        ide::AdjustmentHints::BorrowsOnly
                     }
                     ReborrowHintsDef::Never => ide::AdjustmentHints::Never,
                 },
-                AdjustmentHintsDef::Reborrow => ide::AdjustmentHints::ReborrowOnly,
+                AdjustmentHintsDef::Borrows => ide::AdjustmentHints::BorrowsOnly,
             },
+            adjustment_hints_disable_reborrows: *self
+                .inlayHints_expressionAdjustmentHints_disableReborrows(),
             adjustment_hints_mode: match self.inlayHints_expressionAdjustmentHints_mode() {
                 AdjustmentHintsModeDef::Prefix => ide::AdjustmentHintsMode::Prefix,
                 AdjustmentHintsModeDef::Postfix => ide::AdjustmentHintsMode::Postfix,
@@ -2822,7 +2832,8 @@ enum ReborrowHintsDef {
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(rename_all = "snake_case")]
 enum AdjustmentHintsDef {
-    Reborrow,
+    #[serde(alias = "Reborrow")]
+    Borrows,
     #[serde(with = "true_or_always")]
     #[serde(untagged)]
     Always,
diff --git a/src/tools/rust-analyzer/docs/book/src/configuration_generated.md b/src/tools/rust-analyzer/docs/book/src/configuration_generated.md
index 6ee956fe0dbf4..9a51212462db5 100644
--- a/src/tools/rust-analyzer/docs/book/src/configuration_generated.md
+++ b/src/tools/rust-analyzer/docs/book/src/configuration_generated.md
@@ -959,6 +959,17 @@ Default: `"never"`
 Show enum variant discriminant hints.
 
 
+## rust-analyzer.inlayHints.expressionAdjustmentHints.disableReborrows {#inlayHints.expressionAdjustmentHints.disableReborrows}
+
+Default: `true`
+
+Disable reborrows in expression adjustments inlay hints.
+
+Reborrows are a pair of a builtin deref then borrow, i.e. `&*`. They are inserted by the compiler but are mostly useless to the programmer.
+
+Note: if the deref is not builtin (an overloaded deref), or the borrow is `&raw const`/`&raw mut`, they are not removed.
+
+
 ## rust-analyzer.inlayHints.expressionAdjustmentHints.enable {#inlayHints.expressionAdjustmentHints.enable}
 
 Default: `"never"`
diff --git a/src/tools/rust-analyzer/editors/code/package.json b/src/tools/rust-analyzer/editors/code/package.json
index 4975ca858671b..2b2e25e11c88a 100644
--- a/src/tools/rust-analyzer/editors/code/package.json
+++ b/src/tools/rust-analyzer/editors/code/package.json
@@ -2209,6 +2209,16 @@
                     }
                 }
             },
+            {
+                "title": "Inlay Hints",
+                "properties": {
+                    "rust-analyzer.inlayHints.expressionAdjustmentHints.disableReborrows": {
+                        "markdownDescription": "Disable reborrows in expression adjustments inlay hints.\n\nReborrows are a pair of a builtin deref then borrow, i.e. `&*`. They are inserted by the compiler but are mostly useless to the programmer.\n\nNote: if the deref is not builtin (an overloaded deref), or the borrow is `&raw const`/`&raw mut`, they are not removed.",
+                        "default": true,
+                        "type": "boolean"
+                    }
+                }
+            },
             {
                 "title": "Inlay Hints",
                 "properties": {

From 5e81912dae790647395834a027263a8c6160fd0b Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Fri, 22 Aug 2025 17:31:55 +0800
Subject: [PATCH 0251/1889] replace_arith_op not applicable on selected

---
 .../src/handlers/replace_arith_op.rs            | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_arith_op.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_arith_op.rs
index 6b385a03625b7..440ab4d4604f2 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_arith_op.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_arith_op.rs
@@ -102,6 +102,9 @@ fn is_primitive_int(ctx: &AssistContext<'_>, expr: &ast::Expr) -> bool {
 
 /// Extract the operands of an arithmetic expression (e.g. `1 + 2` or `1.checked_add(2)`)
 fn parse_binary_op(ctx: &AssistContext<'_>) -> Option<(ast::Expr, ArithOp, ast::Expr)> {
+    if !ctx.has_empty_selection() {
+        return None;
+    }
     let expr = ctx.find_node_at_offset::<ast::BinExpr>()?;
 
     let op = match expr.op_kind() {
@@ -163,7 +166,7 @@ impl ArithKind {
 
 #[cfg(test)]
 mod tests {
-    use crate::tests::check_assist;
+    use crate::tests::{check_assist, check_assist_not_applicable};
 
     use super::*;
 
@@ -220,6 +223,18 @@ fn main() {
 fn main() {
     let x = 1.wrapping_add(2);
 }
+"#,
+        )
+    }
+
+    #[test]
+    fn replace_arith_not_applicable_with_non_empty_selection() {
+        check_assist_not_applicable(
+            replace_arith_with_checked,
+            r#"
+fn main() {
+    let x = 1 $0+$0 2;
+}
 "#,
         )
     }

From c92af4d23285428c92e67fedb6d73a9a86a90cff Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Fri, 22 Aug 2025 14:21:52 +0800
Subject: [PATCH 0252/1889] Add ReturnExpr completion suggest

---
 .../ide-completion/src/context/analysis.rs    | 21 +++++++++--
 .../ide-completion/src/context/tests.rs       | 36 +++++++++++++++++++
 2 files changed, 54 insertions(+), 3 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
index 6eb1727b3319e..19f3d157beb7c 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
@@ -559,7 +559,7 @@ fn expected_type_and_name<'db>(
     token: &SyntaxToken,
     name_like: &ast::NameLike,
 ) -> (Option<Type<'db>>, Option<NameOrNameRef>) {
-    let token = prev_assign_token_at_trivia(token.clone());
+    let token = prev_special_biased_token_at_trivia(token.clone());
     let mut node = match token.parent() {
         Some(it) => it,
         None => return (None, None),
@@ -724,6 +724,18 @@ fn expected_type_and_name<'db>(
                     let def = sema.to_def(&it);
                     (def.map(|def| def.ret_type(sema.db)), None)
                 },
+                ast::ReturnExpr(it) => {
+                    let fn_ = sema.ancestors_with_macros(it.syntax().clone())
+                        .find_map(Either::<ast::Fn, ast::ClosureExpr>::cast);
+                    let ty = fn_.and_then(|f| match f {
+                        Either::Left(f) => Some(sema.to_def(&f)?.ret_type(sema.db)),
+                        Either::Right(f) => {
+                            let ty = sema.type_of_expr(&f.into())?.original.as_callable(sema.db)?;
+                            Some(ty.return_type())
+                        },
+                    });
+                    (ty, None)
+                },
                 ast::ClosureExpr(it) => {
                     let ty = sema.type_of_expr(&it.into());
                     ty.and_then(|ty| ty.original.as_callable(sema.db))
@@ -1868,7 +1880,7 @@ fn next_non_trivia_sibling(ele: SyntaxElement) -> Option<SyntaxElement> {
     None
 }
 
-fn prev_assign_token_at_trivia(mut token: SyntaxToken) -> SyntaxToken {
+fn prev_special_biased_token_at_trivia(mut token: SyntaxToken) -> SyntaxToken {
     while token.kind().is_trivia()
         && let Some(prev) = token.prev_token()
         && let T![=]
@@ -1881,7 +1893,10 @@ fn prev_assign_token_at_trivia(mut token: SyntaxToken) -> SyntaxToken {
         | T![-=]
         | T![|=]
         | T![&=]
-        | T![^=] = prev.kind()
+        | T![^=]
+        | T![return]
+        | T![break]
+        | T![continue] = prev.kind()
     {
         token = prev
     }
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context/tests.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context/tests.rs
index 7a8c70f190efc..9b1e086b666bc 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context/tests.rs
@@ -484,3 +484,39 @@ fn foo() {
         expect![[r#"ty: State, name: ?"#]],
     );
 }
+
+#[test]
+fn expected_type_return_expr() {
+    check_expected_type_and_name(
+        r#"
+enum State { Stop }
+fn foo() -> State {
+    let _: i32 = if true {
+        8
+    } else {
+        return $0;
+    };
+}
+"#,
+        expect![[r#"ty: State, name: ?"#]],
+    );
+}
+
+#[test]
+fn expected_type_return_expr_in_closure() {
+    check_expected_type_and_name(
+        r#"
+enum State { Stop }
+fn foo() {
+    let _f: fn() -> State = || {
+        let _: i32 = if true {
+            8
+        } else {
+            return $0;
+        };
+    };
+}
+"#,
+        expect![[r#"ty: State, name: ?"#]],
+    );
+}

From 8c2d2c07ff7af6e9d10e00833d8e82a483f2acae Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Sun, 24 Aug 2025 04:54:24 +0000
Subject: [PATCH 0253/1889] Prepare for merging from rust-lang/rust

This updates the rust-version file to f6d23413c399fb530be362ebcf25a4e788e16137.
---
 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 d0757e58bf909..3450f18334a75 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-8e3710ef31a0b2cdf5a1c2f3929b7735d1e28c20
+f6d23413c399fb530be362ebcf25a4e788e16137

From 9e18b7b0e1b014833ec49a10fc3544d400ca1acc Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Sun, 24 Aug 2025 05:02:39 +0000
Subject: [PATCH 0254/1889] fmt

---
 src/tools/miri/src/machine.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index 0b2ce90041477..0136de5521634 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -1077,7 +1077,8 @@ impl<'tcx> Machine<'tcx> for MiriMachine<'tcx> {
                 .target_features
                 .iter()
                 .filter(|&feature| {
-                    feature.kind != TargetFeatureKind::Implied && !ecx.tcx.sess.target_features.contains(&feature.name)
+                    feature.kind != TargetFeatureKind::Implied
+                        && !ecx.tcx.sess.target_features.contains(&feature.name)
                 })
                 .fold(String::new(), |mut s, feature| {
                     if !s.is_empty() {

From 31245cabecfc21c837745ec6253d63d5fc9ac75f Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Sun, 24 Aug 2025 08:49:40 +0300
Subject: [PATCH 0255/1889] Fix opaque generics

The parent generics were incorrectly not considered for TAIT.

I'm not convinced we should follow rustc here, also there are items (opaques) with more than 1 parent (opaque -> fn/type alias -> impl/trait) and I'm not sure we properly account for that in all places, but for now I left it as-is.

Also fix a bug where lifetimes' indices were incorrect when there is a self param (they started from 0 instead of 1).
---
 .../crates/hir-ty/src/next_solver/generics.rs | 68 +++++++------------
 .../crates/hir-ty/src/next_solver/util.rs     |  1 -
 .../crates/hir-ty/src/tests/regression.rs     |  2 +
 .../hir-ty/src/tests/regression/new_solver.rs | 26 +++++++
 4 files changed, 54 insertions(+), 43 deletions(-)
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generics.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generics.rs
index 48f5e73f2562d..a3ba8eb83453e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generics.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generics.rs
@@ -12,7 +12,7 @@ use hir_def::{
     },
 };
 use hir_expand::name::Name;
-use intern::Symbol;
+use intern::{Symbol, sym};
 use la_arena::Arena;
 use rustc_type_ir::inherent::Ty as _;
 use triomphe::Arc;
@@ -24,18 +24,13 @@ use super::{Const, EarlyParamRegion, ErrorGuaranteed, ParamConst, Region, Solver
 use super::{DbInterner, GenericArg};
 
 pub(crate) fn generics(db: &dyn HirDatabase, def: SolverDefId) -> Generics {
-    let mk_lt = |(index, (_, lt)): (usize, (_, &LifetimeParamData))| {
+    let mk_lt = |index, lt: &LifetimeParamData| {
         let name = lt.name.symbol().clone();
-        let index = index as u32;
         let kind = GenericParamDefKind::Lifetime;
         GenericParamDef { name, index, kind }
     };
-    let mk_ty = |len_lt, (index, p): (usize, &TypeOrConstParamData)| {
-        let name = p
-            .name()
-            .map(|n| n.symbol().clone())
-            .unwrap_or_else(|| Name::missing().symbol().clone());
-        let index = (len_lt + index) as u32;
+    let mk_ty = |index, p: &TypeOrConstParamData| {
+        let name = p.name().map(|n| n.symbol().clone()).unwrap_or_else(|| sym::MISSING_NAME);
         let kind = match p {
             TypeOrConstParamData::TypeParamData(_) => GenericParamDefKind::Type,
             TypeOrConstParamData::ConstParamData(_) => GenericParamDefKind::Const,
@@ -43,33 +38,25 @@ pub(crate) fn generics(db: &dyn HirDatabase, def: SolverDefId) -> Generics {
         GenericParamDef { name, index, kind }
     };
     let own_params_for_generic_params = |params: &GenericParams| {
-        if params.trait_self_param().is_some() {
-            let len_lt = params.len_lifetimes() + 1;
-            params
-                .iter_type_or_consts()
-                .take(1)
-                .enumerate()
-                .map(|t| mk_ty(0, (t.0, t.1.1)))
-                .chain(params.iter_lt().enumerate().map(mk_lt))
-                .chain(
-                    params
-                        .iter_type_or_consts()
-                        .skip(1)
-                        .enumerate()
-                        .map(|t| mk_ty(len_lt, (t.0, t.1.1))),
-                )
-                .collect()
-        } else {
-            let len_lt = params.len_lifetimes();
-            params
-                .iter_lt()
-                .enumerate()
-                .map(mk_lt)
-                .chain(
-                    params.iter_type_or_consts().enumerate().map(|t| mk_ty(len_lt, (t.0, t.1.1))),
-                )
-                .collect()
+        let mut result = Vec::with_capacity(params.len());
+        let mut type_and_consts = params.iter_type_or_consts();
+        let mut index = 0;
+        if let Some(self_param) = params.trait_self_param() {
+            result.push(mk_ty(0, &params[self_param]));
+            type_and_consts.next();
+            index += 1;
         }
+        result.extend(params.iter_lt().map(|(_, data)| {
+            let lt = mk_lt(index, data);
+            index += 1;
+            lt
+        }));
+        result.extend(type_and_consts.map(|(_, data)| {
+            let ty = mk_ty(index, data);
+            index += 1;
+            ty
+        }));
+        result
     };
 
     let (parent, own_params) = match (def.try_into(), def) {
@@ -82,12 +69,9 @@ pub(crate) fn generics(db: &dyn HirDatabase, def: SolverDefId) -> Generics {
                     // The opaque type itself does not have generics - only the parent function
                     (Some(GenericDefId::FunctionId(function_id)), vec![])
                 }
-                crate::ImplTraitId::TypeAliasImplTrait(type_alias_id, _) => (
-                    None,
-                    own_params_for_generic_params(
-                        &db.generic_params(GenericDefId::TypeAliasId(type_alias_id)),
-                    ),
-                ),
+                crate::ImplTraitId::TypeAliasImplTrait(type_alias_id, _) => {
+                    (Some(type_alias_id.into()), Vec::new())
+                }
                 crate::ImplTraitId::AsyncBlockTypeImplTrait(def, _) => {
                     let param = TypeOrConstParamData::TypeParamData(TypeParamData {
                         name: None,
@@ -95,7 +79,7 @@ pub(crate) fn generics(db: &dyn HirDatabase, def: SolverDefId) -> Generics {
                         provenance: TypeParamProvenance::TypeParamList,
                     });
                     // Yes, there is a parent but we don't include it in the generics
-                    (None, vec![mk_ty(0, (0, &param))])
+                    (None, vec![mk_ty(0, &param)])
                 }
             }
         }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/util.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/util.rs
index cedc203f7f5aa..1db02e9eb611c 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/util.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/util.rs
@@ -685,7 +685,6 @@ pub fn explicit_item_bounds<'db>(
                 LifetimeElisionKind::AnonymousReportError,
             );
 
-            let trait_args = GenericArgs::identity_for_item(interner, trait_.into());
             let item_args = GenericArgs::identity_for_item(interner, def_id);
             let interner_ty = Ty::new_projection_from_args(interner, def_id, item_args);
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
index 966433369aa88..6a3f2286215f4 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
@@ -1,3 +1,5 @@
+mod new_solver;
+
 use expect_test::expect;
 
 use super::{check_infer, check_no_mismatches, check_types};
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
new file mode 100644
index 0000000000000..059f4ad32a53b
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
@@ -0,0 +1,26 @@
+use expect_test::expect;
+
+use super::check_infer;
+
+#[test]
+fn opaque_generics() {
+    check_infer(
+        r#"
+//- minicore: iterator
+pub struct Grid {}
+
+impl<'a> IntoIterator for &'a Grid {
+    type Item = &'a ();
+
+    type IntoIter = impl Iterator<Item = &'a ()>;
+
+    fn into_iter(self) -> Self::IntoIter {
+    }
+}
+    "#,
+        expect![[r#"
+            150..154 'self': &'a Grid
+            174..181 '{     }': impl Iterator<Item = &'a ()>
+        "#]],
+    );
+}

From 2427ec250a0a6b3c9d03bd45b1a71e62a6a6b060 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 13 Aug 2025 14:32:31 +0200
Subject: [PATCH 0256/1889] misc: remove one level of nesting

---
 clippy_lints/src/casts/cast_ptr_alignment.rs | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/clippy_lints/src/casts/cast_ptr_alignment.rs b/clippy_lints/src/casts/cast_ptr_alignment.rs
index a1543cabd2f9d..5e206165842ad 100644
--- a/clippy_lints/src/casts/cast_ptr_alignment.rs
+++ b/clippy_lints/src/casts/cast_ptr_alignment.rs
@@ -74,14 +74,13 @@ fn is_used_as_unaligned(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
         ExprKind::Call(func, [arg, ..]) if arg.hir_id == e.hir_id => {
             if let ExprKind::Path(path) = &func.kind
                 && let Some(def_id) = cx.qpath_res(path, func.hir_id).opt_def_id()
+                && let Some(name) = cx.tcx.get_diagnostic_name(def_id)
                 && matches!(
-                    cx.tcx.get_diagnostic_name(def_id),
-                    Some(
-                        sym::ptr_write_unaligned
-                            | sym::ptr_read_unaligned
-                            | sym::intrinsics_unaligned_volatile_load
-                            | sym::intrinsics_unaligned_volatile_store
-                    )
+                    name,
+                    sym::ptr_write_unaligned
+                        | sym::ptr_read_unaligned
+                        | sym::intrinsics_unaligned_volatile_load
+                        | sym::intrinsics_unaligned_volatile_store
                 )
             {
                 true

From 9acb48dbbe4bdb5ab7049e99a2b13c4aebc45981 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 13 Aug 2025 14:42:42 +0200
Subject: [PATCH 0257/1889] `cast_ptr_alignment`: move the `.cast()` check into
 a separate fn

---
 clippy_lints/src/casts/cast_ptr_alignment.rs | 6 +++++-
 clippy_lints/src/casts/mod.rs                | 1 +
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/clippy_lints/src/casts/cast_ptr_alignment.rs b/clippy_lints/src/casts/cast_ptr_alignment.rs
index 5e206165842ad..fd8302e4417fd 100644
--- a/clippy_lints/src/casts/cast_ptr_alignment.rs
+++ b/clippy_lints/src/casts/cast_ptr_alignment.rs
@@ -18,7 +18,11 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
             cx.typeck_results().expr_ty(expr),
         );
         lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
-    } else if let ExprKind::MethodCall(method_path, self_arg, [], _) = &expr.kind
+    }
+}
+
+pub(super) fn check_cast_method(cx: &LateContext<'_>, expr: &Expr<'_>) {
+    if let ExprKind::MethodCall(method_path, self_arg, [], _) = &expr.kind
         && method_path.ident.name == sym::cast
         && let Some(generic_args) = method_path.args
         && let [GenericArg::Type(cast_to)] = generic_args.args
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 58de51a322910..976e0d1965755 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -915,6 +915,7 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             cast_slice_from_raw_parts::check_implicit_cast(cx, expr);
         }
         cast_ptr_alignment::check(cx, expr);
+        cast_ptr_alignment::check_cast_method(cx, expr);
         ptr_as_ptr::check(cx, expr, self.msrv);
         cast_slice_different_sizes::check(cx, expr, self.msrv);
         ptr_cast_constness::check_null_ptr_cast_method(cx, expr);

From 74be6f769ab3a503ed01dee59b459027dbced016 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 13 Aug 2025 14:47:29 +0200
Subject: [PATCH 0258/1889] `cast_ptr_alignment`: move the regular check into
 the `if`

this allows reusing `cast_from` and `cast_to`

one possible problem is that the `if` has an additional
`is_hir_ty_cfg_dependant` check which the let-chain of the  original
`check` didn't have.. but maybe this is actually more correct
---
 clippy_lints/src/casts/cast_ptr_alignment.rs | 13 ++-----------
 clippy_lints/src/casts/mod.rs                |  2 +-
 2 files changed, 3 insertions(+), 12 deletions(-)

diff --git a/clippy_lints/src/casts/cast_ptr_alignment.rs b/clippy_lints/src/casts/cast_ptr_alignment.rs
index fd8302e4417fd..d78da9396faf3 100644
--- a/clippy_lints/src/casts/cast_ptr_alignment.rs
+++ b/clippy_lints/src/casts/cast_ptr_alignment.rs
@@ -8,17 +8,8 @@ use rustc_middle::ty::{self, Ty};
 
 use super::CAST_PTR_ALIGNMENT;
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
-    if let ExprKind::Cast(cast_expr, cast_to) = expr.kind {
-        if is_hir_ty_cfg_dependant(cx, cast_to) {
-            return;
-        }
-        let (cast_from, cast_to) = (
-            cx.typeck_results().expr_ty(cast_expr),
-            cx.typeck_results().expr_ty(expr),
-        );
-        lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
-    }
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, cast_from: Ty<'tcx>, cast_to: Ty<'tcx>) {
+    lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
 }
 
 pub(super) fn check_cast_method(cx: &LateContext<'_>, expr: &Expr<'_>) {
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 976e0d1965755..94940b32f27ff 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -873,6 +873,7 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             }
             char_lit_as_u8::check(cx, expr, cast_from_expr, cast_to);
             cast_slice_from_raw_parts::check(cx, expr, cast_from_expr, cast_to, self.msrv);
+            cast_ptr_alignment::check(cx, expr, cast_from, cast_to);
             ptr_cast_constness::check(cx, expr, cast_from_expr, cast_from, cast_to, self.msrv);
             as_ptr_cast_mut::check(cx, expr, cast_from_expr, cast_to);
             fn_to_numeric_cast_any::check(cx, expr, cast_from_expr, cast_from, cast_to);
@@ -914,7 +915,6 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
         if self.msrv.meets(cx, msrvs::PTR_SLICE_RAW_PARTS) {
             cast_slice_from_raw_parts::check_implicit_cast(cx, expr);
         }
-        cast_ptr_alignment::check(cx, expr);
         cast_ptr_alignment::check_cast_method(cx, expr);
         ptr_as_ptr::check(cx, expr, self.msrv);
         cast_slice_different_sizes::check(cx, expr, self.msrv);

From 0e5b1b19f540936fa12f89ae307ab129485a3d86 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 13 Aug 2025 17:12:33 +0200
Subject: [PATCH 0259/1889] clean-up `ptr_cast_constness`

use `Mutability::ptr_str`

replace `matches!` with an equality check

avoid always allocating a `String`

s/cast_expr/cast_from_expr -- for more consistency with the naming in `mod.rs`
---
 clippy_lints/src/casts/ptr_cast_constness.rs | 27 ++++++++------------
 1 file changed, 11 insertions(+), 16 deletions(-)

diff --git a/clippy_lints/src/casts/ptr_cast_constness.rs b/clippy_lints/src/casts/ptr_cast_constness.rs
index c0c0a47f85515..5ab3991525199 100644
--- a/clippy_lints/src/casts/ptr_cast_constness.rs
+++ b/clippy_lints/src/casts/ptr_cast_constness.rs
@@ -1,9 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{std_or_core, sym};
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, Mutability, QPath};
+use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty, TypeVisitableExt};
 
@@ -12,26 +13,23 @@ use super::PTR_CAST_CONSTNESS;
 pub(super) fn check<'tcx>(
     cx: &LateContext<'_>,
     expr: &Expr<'_>,
-    cast_expr: &Expr<'_>,
+    cast_from_expr: &Expr<'_>,
     cast_from: Ty<'tcx>,
     cast_to: Ty<'tcx>,
     msrv: Msrv,
 ) {
     if let ty::RawPtr(from_ty, from_mutbl) = cast_from.kind()
         && let ty::RawPtr(to_ty, to_mutbl) = cast_to.kind()
-        && matches!(
-            (from_mutbl, to_mutbl),
-            (Mutability::Not, Mutability::Mut) | (Mutability::Mut, Mutability::Not)
-        )
+        && from_mutbl != to_mutbl
         && from_ty == to_ty
         && !from_ty.has_erased_regions()
     {
-        if let ExprKind::Call(func, []) = cast_expr.kind
+        if let ExprKind::Call(func, []) = cast_from_expr.kind
             && let ExprKind::Path(QPath::Resolved(None, path)) = func.kind
             && let Some(defid) = path.res.opt_def_id()
             && let Some(prefix) = std_or_core(cx)
             && let mut app = Applicability::MachineApplicable
-            && let sugg = format!("{}", Sugg::hir_with_applicability(cx, cast_expr, "_", &mut app))
+            && let sugg = snippet_with_applicability(cx, cast_from_expr.span, "_", &mut app)
             && let Some((_, after_lt)) = sugg.split_once("::<")
             && let Some((source, target, target_func)) = match cx.tcx.get_diagnostic_name(defid) {
                 Some(sym::ptr_null) => Some(("const", "mutable", "null_mut")),
@@ -53,11 +51,8 @@ pub(super) fn check<'tcx>(
 
         if msrv.meets(cx, msrvs::POINTER_CAST_CONSTNESS) {
             let mut app = Applicability::MachineApplicable;
-            let sugg = Sugg::hir_with_context(cx, cast_expr, expr.span.ctxt(), "_", &mut app);
-            let constness = match *to_mutbl {
-                Mutability::Not => "const",
-                Mutability::Mut => "mut",
-            };
+            let sugg = Sugg::hir_with_context(cx, cast_from_expr, expr.span.ctxt(), "_", &mut app);
+            let constness = to_mutbl.ptr_str();
 
             span_lint_and_sugg(
                 cx,
@@ -73,8 +68,8 @@ pub(super) fn check<'tcx>(
 }
 
 pub(super) fn check_null_ptr_cast_method(cx: &LateContext<'_>, expr: &Expr<'_>) {
-    if let ExprKind::MethodCall(method, cast_expr, [], _) = expr.kind
-        && let ExprKind::Call(func, []) = cast_expr.kind
+    if let ExprKind::MethodCall(method, cast_from_expr, [], _) = expr.kind
+        && let ExprKind::Call(func, []) = cast_from_expr.kind
         && let ExprKind::Path(QPath::Resolved(None, path)) = func.kind
         && let Some(defid) = path.res.opt_def_id()
         && let method = match (cx.tcx.get_diagnostic_name(defid), method.ident.name) {
@@ -84,7 +79,7 @@ pub(super) fn check_null_ptr_cast_method(cx: &LateContext<'_>, expr: &Expr<'_>)
         }
         && let Some(prefix) = std_or_core(cx)
         && let mut app = Applicability::MachineApplicable
-        && let sugg = format!("{}", Sugg::hir_with_applicability(cx, cast_expr, "_", &mut app))
+        && let sugg = snippet_with_applicability(cx, cast_from_expr.span, "_", &mut app)
         && let Some((_, after_lt)) = sugg.split_once("::<")
     {
         span_lint_and_sugg(

From 9d05ac43969dec9ee26f507e6c9390c26d95a8bf Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Fri, 8 Aug 2025 22:00:50 +0200
Subject: [PATCH 0260/1889] Rewrite `unwrap_in_result` lint
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Lint non-`impl` functions as well.
- Lint function calls in addition to method calls (such as
  `Option::unwrap(…)`).
- Put the lint on the `unwrap` and `expect` node instead of the function
  signature. This lets the user `#[allow]` specific `unwrap()` or
  `expect()` calls.
- Do not lint inside closures, `const` and `static`.
- Do not mix warnings about `Option` and `Result`.
---
 clippy_lints/src/lib.rs              |   2 +-
 clippy_lints/src/unwrap_in_result.rs | 206 ++++++++++++++++++++-------
 tests/ui/unwrap_in_result.rs         |  70 +++++++--
 tests/ui/unwrap_in_result.stderr     | 132 +++++++++++------
 4 files changed, 308 insertions(+), 102 deletions(-)

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 844bc1b0e3909..df2cb50d6478f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -654,7 +654,7 @@ pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Co
     store.register_early_pass(move || Box::new(nonstandard_macro_braces::MacroBraces::new(conf)));
     store.register_late_pass(|_| Box::<macro_use::MacroUseImports>::default());
     store.register_late_pass(|_| Box::new(pattern_type_mismatch::PatternTypeMismatch));
-    store.register_late_pass(|_| Box::new(unwrap_in_result::UnwrapInResult));
+    store.register_late_pass(|_| Box::<unwrap_in_result::UnwrapInResult>::default());
     store.register_late_pass(|_| Box::new(semicolon_if_nothing_returned::SemicolonIfNothingReturned));
     store.register_late_pass(|_| Box::new(async_yields_async::AsyncYieldsAsync));
     let attrs = attr_storage.clone();
diff --git a/clippy_lints/src/unwrap_in_result.rs b/clippy_lints/src/unwrap_in_result.rs
index 7bec212a23ca0..f26647fa34854 100644
--- a/clippy_lints/src/unwrap_in_result.rs
+++ b/clippy_lints/src/unwrap_in_result.rs
@@ -1,13 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::visitors::for_each_expr;
-use clippy_utils::{method_chain_args, return_ty};
-use core::ops::ControlFlow;
-use rustc_hir as hir;
-use rustc_hir::ImplItemKind;
+use clippy_utils::{return_ty, sym};
+use rustc_hir::{
+    Body, BodyOwnerKind, Expr, ExprKind, FnSig, ImplItem, ImplItemKind, Item, ItemKind, OwnerId, PathSegment, QPath,
+};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::declare_lint_pass;
-use rustc_span::{Span, sym};
+use rustc_middle::ty::Ty;
+use rustc_session::impl_lint_pass;
+use rustc_span::{Ident, Span, Symbol};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -57,62 +56,165 @@ declare_clippy_lint! {
     "functions of type `Result<..>` or `Option`<...> that contain `expect()` or `unwrap()`"
 }
 
-declare_lint_pass!(UnwrapInResult=> [UNWRAP_IN_RESULT]);
+impl_lint_pass!(UnwrapInResult=> [UNWRAP_IN_RESULT]);
 
-impl<'tcx> LateLintPass<'tcx> for UnwrapInResult {
-    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx hir::ImplItem<'_>) {
-        if let ImplItemKind::Fn(ref _signature, _) = impl_item.kind
-            // first check if it's a method or function
-            // checking if its return type is `result` or `option`
-            && (is_type_diagnostic_item(cx, return_ty(cx, impl_item.owner_id), sym::Result)
-                || is_type_diagnostic_item(cx, return_ty(cx, impl_item.owner_id), sym::Option))
-        {
-            lint_impl_body(cx, impl_item.span, impl_item);
+#[derive(Clone, Copy, Eq, PartialEq)]
+enum OptionOrResult {
+    Option,
+    Result,
+}
+
+impl OptionOrResult {
+    fn with_article(self) -> &'static str {
+        match self {
+            Self::Option => "an `Option`",
+            Self::Result => "a `Result`",
         }
     }
 }
 
-fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, impl_item: &'tcx hir::ImplItem<'_>) {
-    if let ImplItemKind::Fn(_, body_id) = impl_item.kind {
-        let body = cx.tcx.hir_body(body_id);
-        let typeck = cx.tcx.typeck(impl_item.owner_id.def_id);
-        let mut result = Vec::new();
-        let _: Option<!> = for_each_expr(cx, body.value, |e| {
-            // check for `expect`
-            if let Some(arglists) = method_chain_args(e, &[sym::expect]) {
-                let receiver_ty = typeck.expr_ty(arglists[0].0).peel_refs();
-                if is_type_diagnostic_item(cx, receiver_ty, sym::Option)
-                    || is_type_diagnostic_item(cx, receiver_ty, sym::Result)
-                {
-                    result.push(e.span);
-                }
-            }
-
-            // check for `unwrap`
-            if let Some(arglists) = method_chain_args(e, &[sym::unwrap]) {
-                let receiver_ty = typeck.expr_ty(arglists[0].0).peel_refs();
-                if is_type_diagnostic_item(cx, receiver_ty, sym::Option)
-                    || is_type_diagnostic_item(cx, receiver_ty, sym::Result)
-                {
-                    result.push(e.span);
-                }
-            }
-
-            ControlFlow::Continue(())
+struct OptionOrResultFn {
+    kind: OptionOrResult,
+    return_ty_span: Option<Span>,
+}
+
+#[derive(Default)]
+pub struct UnwrapInResult {
+    fn_stack: Vec<Option<OptionOrResultFn>>,
+    current_fn: Option<OptionOrResultFn>,
+}
+
+impl UnwrapInResult {
+    fn enter_item(&mut self, cx: &LateContext<'_>, fn_def_id: OwnerId, sig: &FnSig<'_>) {
+        self.fn_stack.push(self.current_fn.take());
+        self.current_fn = is_option_or_result(cx, return_ty(cx, fn_def_id)).map(|kind| OptionOrResultFn {
+            kind,
+            return_ty_span: Some(sig.decl.output.span()),
         });
+    }
 
-        // if we've found one, lint
-        if !result.is_empty() {
+    fn leave_item(&mut self) {
+        self.current_fn = self.fn_stack.pop().unwrap();
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for UnwrapInResult {
+    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx ImplItem<'_>) {
+        if let ImplItemKind::Fn(sig, _) = &impl_item.kind {
+            self.enter_item(cx, impl_item.owner_id, sig);
+        }
+    }
+
+    fn check_impl_item_post(&mut self, _: &LateContext<'tcx>, impl_item: &'tcx ImplItem<'tcx>) {
+        if let ImplItemKind::Fn(..) = impl_item.kind {
+            self.leave_item();
+        }
+    }
+
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
+        if let ItemKind::Fn {
+            has_body: true, sig, ..
+        } = &item.kind
+        {
+            self.enter_item(cx, item.owner_id, sig);
+        }
+    }
+
+    fn check_item_post(&mut self, _: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
+        if let ItemKind::Fn { has_body: true, .. } = item.kind {
+            self.leave_item();
+        }
+    }
+
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) {
+        if expr.span.from_expansion() {
+            return;
+        }
+
+        if let Some(OptionOrResultFn {
+            kind,
+            ref mut return_ty_span,
+        }) = self.current_fn
+            && let Some((oor, fn_name)) = is_unwrap_or_expect_call(cx, expr)
+            && oor == kind
+        {
             span_lint_and_then(
                 cx,
                 UNWRAP_IN_RESULT,
-                impl_span,
-                "used unwrap or expect in a function that returns result or option",
-                move |diag| {
-                    diag.help("unwrap and expect should not be used in a function that returns result or option");
-                    diag.span_note(result, "potential non-recoverable error(s)");
+                expr.span,
+                format!("`{fn_name}` used in a function that returns {}", kind.with_article()),
+                |diag| {
+                    // Issue the note and help only once per function
+                    if let Some(span) = return_ty_span.take() {
+                        diag.span_note(span, "in this function signature");
+                        let complement = if kind == OptionOrResult::Result {
+                            " or calling the `.map_err()` method"
+                        } else {
+                            ""
+                        };
+                        diag.help(format!("consider using the `?` operator{complement}"));
+                    }
                 },
             );
         }
     }
+
+    fn check_body(&mut self, cx: &LateContext<'tcx>, body: &Body<'tcx>) {
+        let body_def_id = cx.tcx.hir_body_owner_def_id(body.id());
+        if !matches!(cx.tcx.hir_body_owner_kind(body_def_id), BodyOwnerKind::Fn) {
+            // When entering a body which is not a function, mask the potential surrounding
+            // function to not apply the lint.
+            self.fn_stack.push(self.current_fn.take());
+        }
+    }
+
+    fn check_body_post(&mut self, cx: &LateContext<'tcx>, body: &Body<'tcx>) {
+        let body_def_id = cx.tcx.hir_body_owner_def_id(body.id());
+        if !matches!(cx.tcx.hir_body_owner_kind(body_def_id), BodyOwnerKind::Fn) {
+            // Unmask the potential surrounding function.
+            self.current_fn = self.fn_stack.pop().unwrap();
+        }
+    }
+}
+
+fn is_option_or_result(cx: &LateContext<'_>, ty: Ty<'_>) -> Option<OptionOrResult> {
+    match ty.ty_adt_def().and_then(|def| cx.tcx.get_diagnostic_name(def.did())) {
+        Some(sym::Option) => Some(OptionOrResult::Option),
+        Some(sym::Result) => Some(OptionOrResult::Result),
+        _ => None,
+    }
+}
+
+fn is_unwrap_or_expect_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<(OptionOrResult, Symbol)> {
+    if let ExprKind::Call(func, _) = expr.kind
+        && let ExprKind::Path(QPath::TypeRelative(
+            hir_ty,
+            PathSegment {
+                ident:
+                    Ident {
+                        name: name @ (sym::unwrap | sym::expect),
+                        ..
+                    },
+                ..
+            },
+        )) = func.kind
+    {
+        is_option_or_result(cx, cx.typeck_results().node_type(hir_ty.hir_id)).map(|oor| (oor, *name))
+    } else if let ExprKind::MethodCall(
+        PathSegment {
+            ident: Ident {
+                name: name @ (sym::unwrap | sym::expect),
+                ..
+            },
+            ..
+        },
+        recv,
+        _,
+        _,
+    ) = expr.kind
+    {
+        is_option_or_result(cx, cx.typeck_results().expr_ty_adjusted(recv)).map(|oor| (oor, *name))
+    } else {
+        None
+    }
 }
diff --git a/tests/ui/unwrap_in_result.rs b/tests/ui/unwrap_in_result.rs
index 4e872c67b423e..70c28fe54f37d 100644
--- a/tests/ui/unwrap_in_result.rs
+++ b/tests/ui/unwrap_in_result.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::unwrap_in_result)]
+#![allow(clippy::ok_expect)]
 
 struct A;
 
@@ -20,10 +21,9 @@ impl A {
 
     // should be detected
     fn bad_divisible_by_3(i_str: String) -> Result<bool, String> {
-        //~^ unwrap_in_result
-
         // checks whether a string represents a number divisible by 3
         let i = i_str.parse::<i32>().unwrap();
+        //~^ unwrap_in_result
         if i % 3 == 0 {
             Ok(true)
         } else {
@@ -32,9 +32,8 @@ impl A {
     }
 
     fn example_option_expect(i_str: String) -> Option<bool> {
+        let i = i_str.parse::<i32>().ok().expect("not a number");
         //~^ unwrap_in_result
-
-        let i = i_str.parse::<i32>().expect("not a number");
         if i % 3 == 0 {
             return Some(true);
         }
@@ -42,13 +41,66 @@ impl A {
     }
 
     fn in_closure(a: Option<bool>) -> Option<bool> {
-        //~^ unwrap_in_result
+        // No lint inside a closure
         let c = || a.unwrap();
-        Some(c())
+
+        // But lint outside
+        let a = c().then_some(true);
+        let _ = a.unwrap();
+        //~^ unwrap_in_result
+
+        None
     }
+
+    const fn in_const_inside_fn() -> bool {
+        const A: bool = {
+            const fn inner(b: Option<bool>) -> Option<bool> {
+                Some(b.unwrap())
+                //~^ unwrap_in_result
+            }
+
+            // No lint inside `const`
+            inner(Some(true)).unwrap()
+        };
+        A
+    }
+
+    fn in_static_inside_fn() -> bool {
+        static A: bool = {
+            const fn inner(b: Option<bool>) -> Option<bool> {
+                Some(b.unwrap())
+                //~^ unwrap_in_result
+            }
+
+            // No lint inside `static`
+            inner(Some(true)).unwrap()
+        };
+        A
+    }
+}
+
+macro_rules! mac {
+    () => {
+        Option::unwrap(Some(3))
+    };
+}
+
+fn type_relative_unwrap() -> Option<()> {
+    _ = Option::unwrap(Some(3));
+    //~^ unwrap_in_result
+
+    // Do not lint macro output
+    _ = mac!();
+
+    None
 }
 
-fn main() {
-    A::bad_divisible_by_3("3".to_string());
-    A::good_divisible_by_3("3".to_string());
+fn main() -> Result<(), ()> {
+    A::bad_divisible_by_3("3".to_string()).unwrap();
+    //~^ unwrap_in_result
+    A::good_divisible_by_3("3".to_string()).unwrap();
+    //~^ unwrap_in_result
+    Result::unwrap(A::good_divisible_by_3("3".to_string()));
+    //~^ unwrap_in_result
+    Ok(())
 }
diff --git a/tests/ui/unwrap_in_result.stderr b/tests/ui/unwrap_in_result.stderr
index 5e3eab813e075..804b44246dc70 100644
--- a/tests/ui/unwrap_in_result.stderr
+++ b/tests/ui/unwrap_in_result.stderr
@@ -1,55 +1,107 @@
-error: used unwrap or expect in a function that returns result or option
-  --> tests/ui/unwrap_in_result.rs:22:5
-   |
-LL | /     fn bad_divisible_by_3(i_str: String) -> Result<bool, String> {
-...  |
-LL | |     }
-   | |_____^
-   |
-   = help: unwrap and expect should not be used in a function that returns result or option
-note: potential non-recoverable error(s)
-  --> tests/ui/unwrap_in_result.rs:26:17
+error: `unwrap` used in a function that returns a `Result`
+  --> tests/ui/unwrap_in_result.rs:25:17
    |
 LL |         let i = i_str.parse::<i32>().unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: in this function signature
+  --> tests/ui/unwrap_in_result.rs:23:45
+   |
+LL |     fn bad_divisible_by_3(i_str: String) -> Result<bool, String> {
+   |                                             ^^^^^^^^^^^^^^^^^^^^
+   = help: consider using the `?` operator or calling the `.map_err()` method
    = note: `-D clippy::unwrap-in-result` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::unwrap_in_result)]`
 
-error: used unwrap or expect in a function that returns result or option
-  --> tests/ui/unwrap_in_result.rs:34:5
+error: `expect` used in a function that returns an `Option`
+  --> tests/ui/unwrap_in_result.rs:35:17
+   |
+LL |         let i = i_str.parse::<i32>().ok().expect("not a number");
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: in this function signature
+  --> tests/ui/unwrap_in_result.rs:34:48
+   |
+LL |     fn example_option_expect(i_str: String) -> Option<bool> {
+   |                                                ^^^^^^^^^^^^
+   = help: consider using the `?` operator
+
+error: `unwrap` used in a function that returns an `Option`
+  --> tests/ui/unwrap_in_result.rs:49:17
+   |
+LL |         let _ = a.unwrap();
+   |                 ^^^^^^^^^^
+   |
+note: in this function signature
+  --> tests/ui/unwrap_in_result.rs:43:39
+   |
+LL |     fn in_closure(a: Option<bool>) -> Option<bool> {
+   |                                       ^^^^^^^^^^^^
+   = help: consider using the `?` operator
+
+error: `unwrap` used in a function that returns an `Option`
+  --> tests/ui/unwrap_in_result.rs:58:22
    |
-LL | /     fn example_option_expect(i_str: String) -> Option<bool> {
-LL | |
-LL | |
-LL | |         let i = i_str.parse::<i32>().expect("not a number");
-...  |
-LL | |         None
-LL | |     }
-   | |_____^
+LL |                 Some(b.unwrap())
+   |                      ^^^^^^^^^^
    |
-   = help: unwrap and expect should not be used in a function that returns result or option
-note: potential non-recoverable error(s)
-  --> tests/ui/unwrap_in_result.rs:37:17
+note: in this function signature
+  --> tests/ui/unwrap_in_result.rs:57:48
    |
-LL |         let i = i_str.parse::<i32>().expect("not a number");
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |             const fn inner(b: Option<bool>) -> Option<bool> {
+   |                                                ^^^^^^^^^^^^
+   = help: consider using the `?` operator
 
-error: used unwrap or expect in a function that returns result or option
-  --> tests/ui/unwrap_in_result.rs:44:5
+error: `unwrap` used in a function that returns an `Option`
+  --> tests/ui/unwrap_in_result.rs:71:22
    |
-LL | /     fn in_closure(a: Option<bool>) -> Option<bool> {
-LL | |
-LL | |         let c = || a.unwrap();
-LL | |         Some(c())
-LL | |     }
-   | |_____^
+LL |                 Some(b.unwrap())
+   |                      ^^^^^^^^^^
    |
-   = help: unwrap and expect should not be used in a function that returns result or option
-note: potential non-recoverable error(s)
-  --> tests/ui/unwrap_in_result.rs:46:20
+note: in this function signature
+  --> tests/ui/unwrap_in_result.rs:70:48
+   |
+LL |             const fn inner(b: Option<bool>) -> Option<bool> {
+   |                                                ^^^^^^^^^^^^
+   = help: consider using the `?` operator
+
+error: `unwrap` used in a function that returns an `Option`
+  --> tests/ui/unwrap_in_result.rs:89:9
+   |
+LL |     _ = Option::unwrap(Some(3));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: in this function signature
+  --> tests/ui/unwrap_in_result.rs:88:30
+   |
+LL | fn type_relative_unwrap() -> Option<()> {
+   |                              ^^^^^^^^^^
+   = help: consider using the `?` operator
+
+error: `unwrap` used in a function that returns a `Result`
+  --> tests/ui/unwrap_in_result.rs:99:5
+   |
+LL |     A::bad_divisible_by_3("3".to_string()).unwrap();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: in this function signature
+  --> tests/ui/unwrap_in_result.rs:98:14
+   |
+LL | fn main() -> Result<(), ()> {
+   |              ^^^^^^^^^^^^^^
+   = help: consider using the `?` operator or calling the `.map_err()` method
+
+error: `unwrap` used in a function that returns a `Result`
+  --> tests/ui/unwrap_in_result.rs:101:5
+   |
+LL |     A::good_divisible_by_3("3".to_string()).unwrap();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: `unwrap` used in a function that returns a `Result`
+  --> tests/ui/unwrap_in_result.rs:103:5
    |
-LL |         let c = || a.unwrap();
-   |                    ^^^^^^^^^^
+LL |     Result::unwrap(A::good_divisible_by_3("3".to_string()));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 3 previous errors
+error: aborting due to 9 previous errors
 

From 6a4ab6837790ac8fe74cbd269c3644b9ec83245b Mon Sep 17 00:00:00 2001
From: usamoi <usamoi@outlook.com>
Date: Sat, 14 Jun 2025 18:45:05 +0800
Subject: [PATCH 0261/1889] check f16 and f128 in float_equality_without_abs

---
 .../operators/float_equality_without_abs.rs    |  6 +++---
 tests/ui/float_equality_without_abs.rs         | 14 ++++++++++++--
 tests/ui/float_equality_without_abs.stderr     | 18 +++++++++++++++++-
 3 files changed, 32 insertions(+), 6 deletions(-)

diff --git a/clippy_lints/src/operators/float_equality_without_abs.rs b/clippy_lints/src/operators/float_equality_without_abs.rs
index b5f0d7197bbcc..17fa8017c9788 100644
--- a/clippy_lints/src/operators/float_equality_without_abs.rs
+++ b/clippy_lints/src/operators/float_equality_without_abs.rs
@@ -34,11 +34,11 @@ pub(crate) fn check<'tcx>(
             val_r,
         ) = lhs.kind
 
-        // right hand side matches either f32::EPSILON or f64::EPSILON
+        // right hand side matches _::EPSILON
         && let ExprKind::Path(ref epsilon_path) = rhs.kind
         && let Res::Def(DefKind::AssocConst, def_id) = cx.qpath_res(epsilon_path, rhs.hir_id)
-        && let Some(epsilon) = cx.tcx.get_diagnostic_name(def_id)
-        && matches!(epsilon, sym::f32_epsilon| sym::f64_epsilon)
+        && let Some(sym) = cx.tcx.get_diagnostic_name(def_id)
+        && matches!(sym, sym::f16_epsilon | sym::f32_epsilon | sym::f64_epsilon | sym::f128_epsilon)
 
         // values of the subtractions on the left hand side are of the type float
         && let t_val_l = cx.typeck_results().expr_ty(val_l)
diff --git a/tests/ui/float_equality_without_abs.rs b/tests/ui/float_equality_without_abs.rs
index a1548db6710d1..e1dd79026839b 100644
--- a/tests/ui/float_equality_without_abs.rs
+++ b/tests/ui/float_equality_without_abs.rs
@@ -1,8 +1,8 @@
+#![feature(f128)]
+#![feature(f16)]
 #![warn(clippy::float_equality_without_abs)]
 //@no-rustfix: suggestions cause type ambiguity
 
-// FIXME(f16_f128): add tests for these types when abs is available
-
 pub fn is_roughly_equal(a: f32, b: f32) -> bool {
     (a - b) < f32::EPSILON
     //~^ float_equality_without_abs
@@ -44,10 +44,20 @@ pub fn main() {
     let _ = f32::EPSILON > 1.0 - 2.0;
     //~^ float_equality_without_abs
 
+    let _ = (a as f16 - b as f16) < f16::EPSILON;
+    //~^ float_equality_without_abs
+
+    let _ = (a as f128 - b as f128) < f128::EPSILON;
+    //~^ float_equality_without_abs
+
     // those are correct
+    let _ = (a as f16 - b as f16).abs() < f16::EPSILON;
     let _ = (a - b).abs() < f32::EPSILON;
     let _ = (a as f64 - b as f64).abs() < f64::EPSILON;
+    let _ = (a as f128 - b as f128).abs() < f128::EPSILON;
 
+    let _ = f16::EPSILON > (a as f16 - b as f16).abs();
     let _ = f32::EPSILON > (a - b).abs();
     let _ = f64::EPSILON > (a as f64 - b as f64).abs();
+    let _ = f128::EPSILON > (a as f128 - b as f128).abs();
 }
diff --git a/tests/ui/float_equality_without_abs.stderr b/tests/ui/float_equality_without_abs.stderr
index d4c89ce72ba9b..55a150dead5a4 100644
--- a/tests/ui/float_equality_without_abs.stderr
+++ b/tests/ui/float_equality_without_abs.stderr
@@ -89,5 +89,21 @@ LL |     let _ = f32::EPSILON > 1.0 - 2.0;
    |                            |
    |                            help: add `.abs()`: `(1.0 - 2.0).abs()`
 
-error: aborting due to 11 previous errors
+error: float equality check without `.abs()`
+  --> tests/ui/float_equality_without_abs.rs:47:13
+   |
+LL |     let _ = (a as f16 - b as f16) < f16::EPSILON;
+   |             ---------------------^^^^^^^^^^^^^^^
+   |             |
+   |             help: add `.abs()`: `(a as f16 - b as f16).abs()`
+
+error: float equality check without `.abs()`
+  --> tests/ui/float_equality_without_abs.rs:50:13
+   |
+LL |     let _ = (a as f128 - b as f128) < f128::EPSILON;
+   |             -----------------------^^^^^^^^^^^^^^^^
+   |             |
+   |             help: add `.abs()`: `(a as f128 - b as f128).abs()`
+
+error: aborting due to 13 previous errors
 

From 852e552be4753043644294ed5cc71daec0f8eedd Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sat, 23 Aug 2025 13:54:22 +0200
Subject: [PATCH 0262/1889] get rid of confusing nested `map_or`s

Their default branches are even the same, which means that one of the
`map_or`s could've been replaced with an `and_then`, but since we have
access to let-chains, why not use that

Additionally:
- use `with_source_text` to avoid constructing a `SourceText` object
- use `BytePos::from_usize` to avoid `allow`ing the lint
---
 clippy_lints/src/unused_unit.rs | 22 ++++++++++------------
 1 file changed, 10 insertions(+), 12 deletions(-)

diff --git a/clippy_lints/src/unused_unit.rs b/clippy_lints/src/unused_unit.rs
index 3811f0fe6b558..68d1bbe6b8509 100644
--- a/clippy_lints/src/unused_unit.rs
+++ b/clippy_lints/src/unused_unit.rs
@@ -12,7 +12,7 @@ use rustc_hir::{
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
 use rustc_span::edition::Edition;
-use rustc_span::{BytePos, Span, sym};
+use rustc_span::{BytePos, Pos as _, Span, sym};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -160,17 +160,15 @@ fn get_def(span: Span) -> Option<Span> {
 
 fn lint_unneeded_unit_return(cx: &LateContext<'_>, ty_span: Span, span: Span) {
     let (ret_span, appl) =
-        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,
-                    )
-                })
-            });
+        if let Some(Some(rpos)) = span.with_hi(ty_span.hi()).with_source_text(cx, position_before_rarrow) {
+            (
+                ty_span.with_lo(span.lo() + BytePos::from_usize(rpos)),
+                Applicability::MachineApplicable,
+            )
+        } else {
+            (ty_span, Applicability::MaybeIncorrect)
+        };
+
     span_lint_and_sugg(
         cx,
         UNUSED_UNIT,

From e185efe1315b897d21977e4dfbe4da5a63b569a2 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sat, 23 Aug 2025 13:57:35 +0200
Subject: [PATCH 0263/1889] pattern-match on slices

Avoids needless bounds checks (which almost definitely get optimized
away, but still). And saves some characters
---
 clippy_lints/src/unused_unit.rs | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/clippy_lints/src/unused_unit.rs b/clippy_lints/src/unused_unit.rs
index 68d1bbe6b8509..3652bb68dea9e 100644
--- a/clippy_lints/src/unused_unit.rs
+++ b/clippy_lints/src/unused_unit.rs
@@ -97,16 +97,13 @@ impl<'tcx> LateLintPass<'tcx> for UnusedUnit {
     }
 
     fn check_poly_trait_ref(&mut self, cx: &LateContext<'tcx>, poly: &'tcx PolyTraitRef<'tcx>) {
-        let segments = &poly.trait_ref.path.segments;
-
-        if segments.len() == 1
-            && matches!(segments[0].ident.name, sym::Fn | sym::FnMut | sym::FnOnce)
-            && let Some(args) = segments[0].args
+        if let [segment] = &poly.trait_ref.path.segments
+            && matches!(segment.ident.name, sym::Fn | sym::FnMut | sym::FnOnce)
+            && let Some(args) = segment.args
             && args.parenthesized == GenericArgsParentheses::ParenSugar
-            && let constraints = &args.constraints
-            && constraints.len() == 1
-            && constraints[0].ident.name == sym::Output
-            && let AssocItemConstraintKind::Equality { term: Term::Ty(hir_ty) } = constraints[0].kind
+            && let [constraint] = &args.constraints
+            && constraint.ident.name == sym::Output
+            && let AssocItemConstraintKind::Equality { term: Term::Ty(hir_ty) } = constraint.kind
             && args.span_ext.hi() != poly.span.hi()
             && !hir_ty.span.from_expansion()
             && args.span_ext.hi() != hir_ty.span.hi()

From 94d3352c082ea0a48ee07db8205753407102ec3f Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sat, 23 Aug 2025 14:28:08 +0200
Subject: [PATCH 0264/1889] `unused_unit`: don't lint on closure return types

---
 clippy_lints/src/unused_unit.rs         | 21 ++++++++++--------
 tests/ui/unused_unit.edition2021.fixed  | 27 ++++++++++++++++++-----
 tests/ui/unused_unit.edition2021.stderr |  6 ++---
 tests/ui/unused_unit.edition2024.fixed  | 29 ++++++++++++++++++++-----
 tests/ui/unused_unit.rs                 | 29 ++++++++++++++++++++-----
 5 files changed, 83 insertions(+), 29 deletions(-)

diff --git a/clippy_lints/src/unused_unit.rs b/clippy_lints/src/unused_unit.rs
index 3652bb68dea9e..d503bd3379b08 100644
--- a/clippy_lints/src/unused_unit.rs
+++ b/clippy_lints/src/unused_unit.rs
@@ -6,8 +6,8 @@ use rustc_errors::Applicability;
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
-    AssocItemConstraintKind, Body, Expr, ExprKind, FnDecl, FnRetTy, GenericArgsParentheses, Node, PolyTraitRef, Term,
-    Ty, TyKind,
+    AssocItemConstraintKind, Body, Expr, ExprKind, FnDecl, FnRetTy, GenericArgsParentheses, PolyTraitRef, Term, Ty,
+    TyKind,
 };
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
@@ -49,19 +49,22 @@ impl<'tcx> LateLintPass<'tcx> for UnusedUnit {
         decl: &'tcx FnDecl<'tcx>,
         body: &'tcx Body<'tcx>,
         span: Span,
-        def_id: LocalDefId,
+        _def_id: LocalDefId,
     ) {
         if let FnRetTy::Return(hir_ty) = decl.output
             && is_unit_ty(hir_ty)
             && !hir_ty.span.from_expansion()
             && get_def(span) == get_def(hir_ty.span)
         {
-            // implicit types in closure signatures are forbidden when `for<...>` is present
-            if let FnKind::Closure = kind
-                && let Node::Expr(expr) = cx.tcx.hir_node_by_def_id(def_id)
-                && let ExprKind::Closure(closure) = expr.kind
-                && !closure.bound_generic_params.is_empty()
-            {
+            // The explicit `-> ()` in the closure signature might be necessary for multiple reasons:
+            // - Implicit types in closure signatures are forbidden when `for<...>` is present
+            // - If the closure body ends with a function call, and that function's return type is generic, the
+            //   `-> ()` could be required for it to be inferred
+            //
+            // There could be more reasons to have it, and, in general, we shouldn't discourage the users from
+            // writing more type annotations than strictly necessary, because it can help readability and
+            // maintainability
+            if let FnKind::Closure = kind {
                 return;
             }
 
diff --git a/tests/ui/unused_unit.edition2021.fixed b/tests/ui/unused_unit.edition2021.fixed
index def8ef86e3c57..8e12bd2c8c7b9 100644
--- a/tests/ui/unused_unit.edition2021.fixed
+++ b/tests/ui/unused_unit.edition2021.fixed
@@ -127,14 +127,10 @@ mod issue14577 {
     trait Unit {}
     impl Unit for () {}
 
-    fn run<R: Unit>(f: impl FnOnce() -> R) {
-        f();
-    }
-
     #[allow(dependency_on_unit_never_type_fallback)]
     fn bar() {
-        run(|| { todo!() }); 
         //~[edition2021]^ unused_unit
+        panic!()
     }
 
     struct UnitStruct;
@@ -150,3 +146,24 @@ mod pr14962 {
     type UnusedParensButNoUnit = Box<dyn (Fn())>;
 }
 
+
+mod issue15035 {
+
+    trait Convert<T> {
+        fn from(value: T) -> Self;
+    }
+
+    impl Convert<u64> for () {
+        fn from(_value: u64) -> Self {}
+    }
+
+    fn handle<T: Convert<u64>>(value: u64) -> T {
+        Convert::from(value)
+    }
+
+    pub fn f() -> Option<bool> {
+        let result: Result<bool, u64> = Err(42);
+        // the `-> ()` is required for the inference of `handle`'s return type
+        result.map_err(|err| -> () { handle(err) }).ok()
+    }
+}
diff --git a/tests/ui/unused_unit.edition2021.stderr b/tests/ui/unused_unit.edition2021.stderr
index 13cc20d4d7adc..9ad3c2df915ec 100644
--- a/tests/ui/unused_unit.edition2021.stderr
+++ b/tests/ui/unused_unit.edition2021.stderr
@@ -119,10 +119,10 @@ LL | fn test3()-> (){}
    |           ^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> tests/ui/unused_unit.rs:136:15
+  --> tests/ui/unused_unit.rs:131:13
    |
-LL |         run(|| -> () { todo!() }); 
-   |               ^^^^^^ help: remove the `-> ()`
+LL |     fn bar() -> () {
+   |             ^^^^^^ help: remove the `-> ()`
 
 error: aborting due to 20 previous errors
 
diff --git a/tests/ui/unused_unit.edition2024.fixed b/tests/ui/unused_unit.edition2024.fixed
index f908b958b191e..688d2fe9afa28 100644
--- a/tests/ui/unused_unit.edition2024.fixed
+++ b/tests/ui/unused_unit.edition2024.fixed
@@ -127,14 +127,10 @@ mod issue14577 {
     trait Unit {}
     impl Unit for () {}
 
-    fn run<R: Unit>(f: impl FnOnce() -> R) {
-        f();
-    }
-
     #[allow(dependency_on_unit_never_type_fallback)]
-    fn bar() {
-        run(|| -> () { todo!() }); 
+    fn bar() -> () {
         //~[edition2021]^ unused_unit
+        panic!()
     }
 
     struct UnitStruct;
@@ -150,3 +146,24 @@ mod pr14962 {
     type UnusedParensButNoUnit = Box<dyn (Fn())>;
 }
 
+
+mod issue15035 {
+
+    trait Convert<T> {
+        fn from(value: T) -> Self;
+    }
+
+    impl Convert<u64> for () {
+        fn from(_value: u64) -> Self {}
+    }
+
+    fn handle<T: Convert<u64>>(value: u64) -> T {
+        Convert::from(value)
+    }
+
+    pub fn f() -> Option<bool> {
+        let result: Result<bool, u64> = Err(42);
+        // the `-> ()` is required for the inference of `handle`'s return type
+        result.map_err(|err| -> () { handle(err) }).ok()
+    }
+}
diff --git a/tests/ui/unused_unit.rs b/tests/ui/unused_unit.rs
index 7298ec40cc28b..31e980f2655c6 100644
--- a/tests/ui/unused_unit.rs
+++ b/tests/ui/unused_unit.rs
@@ -127,14 +127,10 @@ mod issue14577 {
     trait Unit {}
     impl Unit for () {}
 
-    fn run<R: Unit>(f: impl FnOnce() -> R) {
-        f();
-    }
-
     #[allow(dependency_on_unit_never_type_fallback)]
-    fn bar() {
-        run(|| -> () { todo!() }); 
+    fn bar() -> () {
         //~[edition2021]^ unused_unit
+        panic!()
     }
 
     struct UnitStruct;
@@ -150,3 +146,24 @@ mod pr14962 {
     type UnusedParensButNoUnit = Box<dyn (Fn())>;
 }
 
+
+mod issue15035 {
+
+    trait Convert<T> {
+        fn from(value: T) -> Self;
+    }
+
+    impl Convert<u64> for () {
+        fn from(_value: u64) -> Self {}
+    }
+
+    fn handle<T: Convert<u64>>(value: u64) -> T {
+        Convert::from(value)
+    }
+
+    pub fn f() -> Option<bool> {
+        let result: Result<bool, u64> = Err(42);
+        // the `-> ()` is required for the inference of `handle`'s return type
+        result.map_err(|err| -> () { handle(err) }).ok()
+    }
+}

From 5ddf6846d5659ed28e1ea25e273e4c84082cf730 Mon Sep 17 00:00:00 2001
From: Shoyu Vanilla <modulo641@gmail.com>
Date: Sun, 24 Aug 2025 23:17:23 +0900
Subject: [PATCH 0265/1889] fix: Masquerade as nightly cargo when invoking
 flycheck with `-Zscript`

---
 src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs
index 233bedec6900a..01ac75c09aee6 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs
@@ -588,6 +588,7 @@ impl FlycheckActor {
                     cmd.arg("--manifest-path");
                     cmd.arg(manifest_path);
                     if manifest_path.extension() == Some("rs") {
+                        cmd.env("__CARGO_TEST_CHANNEL_OVERRIDE_DO_NOT_USE_THIS", "nightly");
                         cmd.arg("-Zscript");
                     }
                 }

From 0cdb47d4b59c5ebaf82e8342f9c67af73e502024 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 13 Aug 2025 17:08:14 +0200
Subject: [PATCH 0266/1889] move `ptr_as_ptr` to under `if`

allows reusing numerous variables
---
 clippy_lints/src/casts/mod.rs        |  2 +-
 clippy_lints/src/casts/ptr_as_ptr.rs | 24 +++++++++++++++---------
 2 files changed, 16 insertions(+), 10 deletions(-)

diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 94940b32f27ff..d2e62ee56e43b 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -875,6 +875,7 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             cast_slice_from_raw_parts::check(cx, expr, cast_from_expr, cast_to, self.msrv);
             cast_ptr_alignment::check(cx, expr, cast_from, cast_to);
             ptr_cast_constness::check(cx, expr, cast_from_expr, cast_from, cast_to, self.msrv);
+            ptr_as_ptr::check(cx, expr, cast_from_expr, cast_from, cast_to_hir, cast_to, self.msrv);
             as_ptr_cast_mut::check(cx, expr, cast_from_expr, cast_to);
             fn_to_numeric_cast_any::check(cx, expr, cast_from_expr, cast_from, cast_to);
             confusing_method_to_numeric_cast::check(cx, expr, cast_from_expr, cast_from, cast_to);
@@ -916,7 +917,6 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             cast_slice_from_raw_parts::check_implicit_cast(cx, expr);
         }
         cast_ptr_alignment::check_cast_method(cx, expr);
-        ptr_as_ptr::check(cx, expr, self.msrv);
         cast_slice_different_sizes::check(cx, expr, self.msrv);
         ptr_cast_constness::check_null_ptr_cast_method(cx, expr);
     }
diff --git a/clippy_lints/src/casts/ptr_as_ptr.rs b/clippy_lints/src/casts/ptr_as_ptr.rs
index 863a0278bf38e..fda849135d3d1 100644
--- a/clippy_lints/src/casts/ptr_as_ptr.rs
+++ b/clippy_lints/src/casts/ptr_as_ptr.rs
@@ -4,9 +4,9 @@ use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, Mutability, QPath, TyKind};
+use rustc_hir::{self as hir, Expr, ExprKind, Mutability, QPath, TyKind};
 use rustc_lint::LateContext;
-use rustc_middle::ty;
+use rustc_middle::ty::{self, Ty};
 use rustc_span::{Span, sym};
 
 use super::PTR_AS_PTR;
@@ -26,10 +26,16 @@ impl OmitFollowedCastReason<'_> {
     }
 }
 
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, msrv: Msrv) {
-    if let ExprKind::Cast(cast_expr, cast_to_hir_ty) = expr.kind
-        && let (cast_from, cast_to) = (cx.typeck_results().expr_ty(cast_expr), cx.typeck_results().expr_ty(expr))
-        && let ty::RawPtr(_, from_mutbl) = cast_from.kind()
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &Expr<'tcx>,
+    cast_from_expr: &Expr<'_>,
+    cast_from: Ty<'_>,
+    cast_to_hir: &hir::Ty<'_>,
+    cast_to: Ty<'tcx>,
+    msrv: Msrv,
+) {
+    if let ty::RawPtr(_, from_mutbl) = cast_from.kind()
         && let ty::RawPtr(to_pointee_ty, to_mutbl) = cast_to.kind()
         && matches!((from_mutbl, to_mutbl),
             (Mutability::Not, Mutability::Not) | (Mutability::Mut, Mutability::Mut))
@@ -40,7 +46,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, msrv: Msrv)
         && !is_from_proc_macro(cx, expr)
     {
         let mut app = Applicability::MachineApplicable;
-        let turbofish = match &cast_to_hir_ty.kind {
+        let turbofish = match &cast_to_hir.kind {
             TyKind::Infer(()) => String::new(),
             TyKind::Ptr(mut_ty) => {
                 if matches!(mut_ty.ty.kind, TyKind::Infer(())) {
@@ -58,7 +64,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, msrv: Msrv)
         // following `cast` does not compile because it fails to infer what type is expected
         // as type argument to `std::ptr::ptr_null` or `std::ptr::ptr_null_mut`, so
         // we omit following `cast`:
-        let omit_cast = if let ExprKind::Call(func, []) = cast_expr.kind
+        let omit_cast = if let ExprKind::Call(func, []) = cast_from_expr.kind
             && let ExprKind::Path(ref qpath @ QPath::Resolved(None, path)) = func.kind
             && let Some(method_defid) = path.res.opt_def_id()
         {
@@ -76,7 +82,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, msrv: Msrv)
             let method = snippet_with_applicability(cx, qpath_span_without_turbofish(method), "..", &mut app);
             ("try call directly", format!("{method}{turbofish}()"))
         } else {
-            let cast_expr_sugg = Sugg::hir_with_context(cx, cast_expr, expr.span.ctxt(), "_", &mut app);
+            let cast_expr_sugg = Sugg::hir_with_context(cx, cast_from_expr, expr.span.ctxt(), "_", &mut app);
 
             (
                 "try `pointer::cast`, a safer alternative",

From d4a60619ac4b3f63147ed95d39f8c41bd982b86b Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 13 Aug 2025 17:09:29 +0200
Subject: [PATCH 0267/1889] misc: replace `match` with an equality check

that's all it was doing
---
 clippy_lints/src/casts/ptr_as_ptr.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/clippy_lints/src/casts/ptr_as_ptr.rs b/clippy_lints/src/casts/ptr_as_ptr.rs
index fda849135d3d1..d012380cb762f 100644
--- a/clippy_lints/src/casts/ptr_as_ptr.rs
+++ b/clippy_lints/src/casts/ptr_as_ptr.rs
@@ -4,7 +4,7 @@ use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
 use rustc_errors::Applicability;
-use rustc_hir::{self as hir, Expr, ExprKind, Mutability, QPath, TyKind};
+use rustc_hir::{self as hir, Expr, ExprKind, QPath, TyKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
 use rustc_span::{Span, sym};
@@ -37,8 +37,7 @@ pub(super) fn check<'tcx>(
 ) {
     if let ty::RawPtr(_, from_mutbl) = cast_from.kind()
         && let ty::RawPtr(to_pointee_ty, to_mutbl) = cast_to.kind()
-        && matches!((from_mutbl, to_mutbl),
-            (Mutability::Not, Mutability::Not) | (Mutability::Mut, Mutability::Mut))
+        && from_mutbl == to_mutbl
         // The `U` in `pointer::cast` have to be `Sized`
         // as explained here: https://github.com/rust-lang/rust/issues/60602.
         && to_pointee_ty.is_sized(cx.tcx, cx.typing_env())

From ca42d0775a33ae6f977e4cd42fab17f9aced6a59 Mon Sep 17 00:00:00 2001
From: Emmanuel Ferdman <emmanuelferdman@gmail.com>
Date: Sun, 24 Aug 2025 08:03:02 -0700
Subject: [PATCH 0268/1889] Fix rust-analyzer-contributors reference

Signed-off-by: Emmanuel Ferdman <emmanuelferdman@gmail.com>
---
 src/tools/rust-analyzer/docs/book/src/contributing/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/docs/book/src/contributing/README.md b/src/tools/rust-analyzer/docs/book/src/contributing/README.md
index 57c7a9c5996d1..ad2816b18ac14 100644
--- a/src/tools/rust-analyzer/docs/book/src/contributing/README.md
+++ b/src/tools/rust-analyzer/docs/book/src/contributing/README.md
@@ -276,7 +276,7 @@ There are two sets of people with extra permissions:
   Feel free to request a review or assign any PR to a reviewer with the relevant expertise to bring the work to their attention.
   Don't feel pressured to review assigned PRs though.
   If you don't feel like reviewing for whatever reason, someone else will pick the review up (but please speak up if you don't feel like it)!
-* The [rust-lang](https://github.com/rust-lang) team [t-rust-analyzer-contributors]([https://github.com/orgs/rust-analyzer/teams/triage](https://github.com/rust-lang/team/blob/master/teams/rust-analyzer-contributors.toml)).
+* The [rust-lang](https://github.com/rust-lang) team [t-rust-analyzer-contributors](https://github.com/rust-lang/team/blob/master/teams/rust-analyzer-contributors.toml).
   This team has general triaging permissions allowing to label, close and re-open issues.
 
 ## Synchronizing subtree changes

From 3b627b5a4909bf17ab55ceeb0b31e70280b49189 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Sun, 24 Aug 2025 10:37:19 -0500
Subject: [PATCH 0269/1889] editorconfig: don't use nonexistant syntax

reading through the editorconfig spec, using `!` to negate
an entire glob is simply not a feature.

you can use `!` to negate a charachter class, but that's not
what was going on here.
---
 .editorconfig | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/.editorconfig b/.editorconfig
index 1b137cf4ebefd..6c8560aa1f543 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -8,10 +8,13 @@ root = true
 end_of_line = lf
 charset = utf-8
 insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 4
 
 # some tests need trailing whitespace in output snapshots
-[!tests/]
-trim_trailing_whitespace = true
+[tests/**]
+trim_trailing_whitespace = false
 # for actual source code files of test, we still don't want trailing whitespace
 [tests/**.{rs,js}]
 trim_trailing_whitespace = true
@@ -19,9 +22,9 @@ trim_trailing_whitespace = true
 [tests/ui/{frontmatter/frontmatter-whitespace-3.rs,parser/shebang/shebang-space.rs}]
 trim_trailing_whitespace = false
 
-[!src/llvm-project]
-indent_style = space
-indent_size = 4
+[src/llvm-project]
+indent_style = unset
+indent_size = unset
 
 [*.rs]
 max_line_length = 100

From a7ff2b012698235f14841e0f47c965a3fe75a501 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Fri, 6 Jun 2025 11:43:28 +0200
Subject: [PATCH 0270/1889] Suggest naming types before using explicit type
 names
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`missing_transmute_annotations` will suggest naming the origin and
destination types if they do not have explicit names already.

Co-authored-by: Alejandra González <blyxyas@gmail.com>
---
 .../missing_transmute_annotations.rs          | 55 ++++++++++++++++---
 clippy_lints/src/transmute/mod.rs             |  2 +-
 ...missing_transmute_annotations_unfixable.rs | 29 ++++++++++
 ...ing_transmute_annotations_unfixable.stderr | 36 ++++++++++++
 4 files changed, 113 insertions(+), 9 deletions(-)
 create mode 100644 tests/ui/missing_transmute_annotations_unfixable.rs
 create mode 100644 tests/ui/missing_transmute_annotations_unfixable.stderr

diff --git a/clippy_lints/src/transmute/missing_transmute_annotations.rs b/clippy_lints/src/transmute/missing_transmute_annotations.rs
index 08f36a2ed5d2e..543f3c45e1461 100644
--- a/clippy_lints/src/transmute/missing_transmute_annotations.rs
+++ b/clippy_lints/src/transmute/missing_transmute_annotations.rs
@@ -1,8 +1,12 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use std::borrow::Cow;
+
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::{HasSession, SpanRangeExt as _};
 use rustc_errors::Applicability;
-use rustc_hir::{GenericArg, HirId, LetStmt, Node, Path, TyKind};
+use rustc_hir::{Expr, GenericArg, HirId, LetStmt, Node, Path, TyKind};
 use rustc_lint::LateContext;
-use rustc_middle::ty::Ty;
+use rustc_middle::ty::{self, Ty};
+use rustc_span::Span;
 
 use crate::transmute::MISSING_TRANSMUTE_ANNOTATIONS;
 
@@ -38,6 +42,7 @@ fn is_function_block(cx: &LateContext<'_>, expr_hir_id: HirId) -> bool {
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     path: &Path<'tcx>,
+    arg: &Expr<'tcx>,
     from_ty: Ty<'tcx>,
     to_ty: Ty<'tcx>,
     expr_hir_id: HirId,
@@ -68,14 +73,48 @@ pub(super) fn check<'tcx>(
     } else if is_function_block(cx, expr_hir_id) {
         return false;
     }
-    span_lint_and_sugg(
+    let span = last.ident.span.with_hi(path.span.hi());
+    span_lint_and_then(
         cx,
         MISSING_TRANSMUTE_ANNOTATIONS,
-        last.ident.span.with_hi(path.span.hi()),
+        span,
         "transmute used without annotations",
-        "consider adding missing annotations",
-        format!("{}::<{from_ty}, {to_ty}>", last.ident),
-        Applicability::MaybeIncorrect,
+        |diag| {
+            let from_ty_no_name = ty_cannot_be_named(from_ty);
+            let to_ty_no_name = ty_cannot_be_named(to_ty);
+            if from_ty_no_name || to_ty_no_name {
+                let to_name = match (from_ty_no_name, to_ty_no_name) {
+                    (true, false) => maybe_name_by_expr(cx, arg.span, "the origin type"),
+                    (false, true) => "the destination type".into(),
+                    _ => "the source and destination types".into(),
+                };
+                diag.help(format!(
+                    "consider giving {to_name} a name, and adding missing type annotations"
+                ));
+            } else {
+                diag.span_suggestion(
+                    span,
+                    "consider adding missing annotations",
+                    format!("{}::<{from_ty}, {to_ty}>", last.ident),
+                    Applicability::MaybeIncorrect,
+                );
+            }
+        },
     );
     true
 }
+
+fn ty_cannot_be_named(ty: Ty<'_>) -> bool {
+    matches!(
+        ty.kind(),
+        ty::Alias(ty::AliasTyKind::Opaque | ty::AliasTyKind::Inherent, _)
+    )
+}
+
+fn maybe_name_by_expr<'a>(sess: &impl HasSession, span: Span, default: &'a str) -> Cow<'a, str> {
+    span.with_source_text(sess, |name| {
+        (name.len() + 9 < default.len()).then_some(format!("`{name}`'s type").into())
+    })
+    .flatten()
+    .unwrap_or(default.into())
+}
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index d5112e2c3f97a..284728b8ebbd6 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -520,7 +520,7 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                 | transmuting_null::check(cx, e, arg, to_ty)
                 | transmute_null_to_fn::check(cx, e, arg, to_ty)
                 | transmute_ptr_to_ref::check(cx, e, from_ty, to_ty, arg, path, self.msrv)
-                | missing_transmute_annotations::check(cx, path, from_ty, to_ty, e.hir_id)
+                | missing_transmute_annotations::check(cx, path, arg, from_ty, to_ty, e.hir_id)
                 | transmute_ref_to_ref::check(cx, e, from_ty, to_ty, arg, const_context)
                 | transmute_ptr_to_ptr::check(cx, e, from_ty, to_ty, arg, self.msrv)
                 | transmute_int_to_bool::check(cx, e, from_ty, to_ty, arg)
diff --git a/tests/ui/missing_transmute_annotations_unfixable.rs b/tests/ui/missing_transmute_annotations_unfixable.rs
new file mode 100644
index 0000000000000..08ba3b791ee76
--- /dev/null
+++ b/tests/ui/missing_transmute_annotations_unfixable.rs
@@ -0,0 +1,29 @@
+//@no-rustfix
+
+fn issue14984() {
+    async fn e() {}
+    async fn x() -> u32 {
+        0
+    }
+    async fn y() -> f32 {
+        0.0
+    };
+    let mut yy = unsafe { std::ptr::read(&y()) };
+    yy = unsafe { std::mem::transmute(std::ptr::read(&x())) };
+    //~^ missing_transmute_annotations
+
+    let mut zz = 0u8;
+    zz = unsafe { std::mem::transmute(std::ptr::read(&x())) };
+    //~^ missing_transmute_annotations
+
+    yy = unsafe { std::mem::transmute(zz) };
+    //~^ missing_transmute_annotations
+
+    fn a() -> impl Sized {
+        0u32
+    }
+
+    let mut b: f32 = 0.0;
+    b = unsafe { std::mem::transmute(a()) };
+    //~^ missing_transmute_annotations
+}
diff --git a/tests/ui/missing_transmute_annotations_unfixable.stderr b/tests/ui/missing_transmute_annotations_unfixable.stderr
new file mode 100644
index 0000000000000..83efdce13f7e7
--- /dev/null
+++ b/tests/ui/missing_transmute_annotations_unfixable.stderr
@@ -0,0 +1,36 @@
+error: transmute used without annotations
+  --> tests/ui/missing_transmute_annotations_unfixable.rs:12:29
+   |
+LL |     yy = unsafe { std::mem::transmute(std::ptr::read(&x())) };
+   |                             ^^^^^^^^^
+   |
+   = help: consider giving the source and destination types a name, and adding missing type annotations
+   = note: `-D clippy::missing-transmute-annotations` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::missing_transmute_annotations)]`
+
+error: transmute used without annotations
+  --> tests/ui/missing_transmute_annotations_unfixable.rs:16:29
+   |
+LL |     zz = unsafe { std::mem::transmute(std::ptr::read(&x())) };
+   |                             ^^^^^^^^^
+   |
+   = help: consider giving the origin type a name, and adding missing type annotations
+
+error: transmute used without annotations
+  --> tests/ui/missing_transmute_annotations_unfixable.rs:19:29
+   |
+LL |     yy = unsafe { std::mem::transmute(zz) };
+   |                             ^^^^^^^^^
+   |
+   = help: consider giving the destination type a name, and adding missing type annotations
+
+error: transmute used without annotations
+  --> tests/ui/missing_transmute_annotations_unfixable.rs:27:28
+   |
+LL |     b = unsafe { std::mem::transmute(a()) };
+   |                            ^^^^^^^^^
+   |
+   = help: consider giving `a()`'s type a name, and adding missing type annotations
+
+error: aborting due to 4 previous errors
+

From 597d5a58ce0a3bf84f79f89ea2cdd4f09b11177a Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Fri, 8 Aug 2025 10:08:35 +0200
Subject: [PATCH 0271/1889] `unnecessary_mut_passed`: add structured suggestion

---
 clippy_lints/src/mut_reference.rs |  13 ++-
 tests/ui/mut_reference.fixed      | 170 ++++++++++++++++++++++++++++++
 tests/ui/mut_reference.rs         | 152 ++++++++++++++++++++++----
 tests/ui/mut_reference.stderr     |  76 +++++++++++--
 4 files changed, 376 insertions(+), 35 deletions(-)
 create mode 100644 tests/ui/mut_reference.fixed

diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs
index 31f51b4575405..ec93ef97cfaf7 100644
--- a/clippy_lints/src/mut_reference.rs
+++ b/clippy_lints/src/mut_reference.rs
@@ -1,4 +1,6 @@
-use clippy_utils::diagnostics::span_lint;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::sugg::Sugg;
+use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty};
@@ -83,13 +85,18 @@ fn check_arguments<'tcx>(
         let parameters = type_definition.fn_sig(cx.tcx).skip_binder().inputs();
         for (argument, parameter) in iter::zip(arguments, parameters) {
             if let ty::Ref(_, _, Mutability::Not) | ty::RawPtr(_, Mutability::Not) = parameter.kind()
-                && let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, _) = argument.kind
+                && let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, arg) = argument.kind
             {
-                span_lint(
+                let mut applicability = Applicability::MachineApplicable;
+                let sugg = Sugg::hir_with_applicability(cx, arg, "_", &mut applicability).addr();
+                span_lint_and_sugg(
                     cx,
                     UNNECESSARY_MUT_PASSED,
                     argument.span,
                     format!("the {fn_kind} `{name}` doesn't need a mutable reference"),
+                    "remove this `mut`",
+                    sugg.to_string(),
+                    applicability,
                 );
             }
         }
diff --git a/tests/ui/mut_reference.fixed b/tests/ui/mut_reference.fixed
new file mode 100644
index 0000000000000..03d854099e644
--- /dev/null
+++ b/tests/ui/mut_reference.fixed
@@ -0,0 +1,170 @@
+#![allow(clippy::mut_mut)]
+
+fn takes_ref(a: &i32) {}
+fn takes_refmut(a: &mut i32) {}
+fn takes_ref_ref(a: &&i32) {}
+fn takes_refmut_ref(a: &mut &i32) {}
+fn takes_ref_refmut(a: &&mut i32) {}
+fn takes_refmut_refmut(a: &mut &mut i32) {}
+fn takes_raw_const(a: *const i32) {}
+fn takes_raw_mut(a: *mut i32) {}
+
+mod issue11268 {
+    macro_rules! x {
+        (1 $f:expr) => {
+            $f(&mut 1);
+        };
+        (2 $f:expr) => {
+            $f(&mut &1)
+        };
+        (3 $f:expr) => {
+            $f(&mut &mut 1)
+        };
+        (4 $f:expr) => {
+            let mut a = 1;
+            $f(&raw mut a)
+        };
+    }
+
+    fn f() {
+        x!(1 super::takes_ref);
+        x!(1 super::takes_refmut);
+        x!(2 super::takes_refmut_ref);
+        x!(3 super::takes_ref_refmut);
+        x!(3 super::takes_refmut_refmut);
+        x!(4 super::takes_raw_const);
+        x!(4 super::takes_raw_mut);
+    }
+}
+
+struct MyStruct;
+
+impl MyStruct {
+    fn takes_ref(&self, a: &i32) {}
+    fn takes_refmut(&self, a: &mut i32) {}
+    fn takes_ref_ref(&self, a: &&i32) {}
+    fn takes_refmut_ref(&self, a: &mut &i32) {}
+    fn takes_ref_refmut(&self, a: &&mut i32) {}
+    fn takes_refmut_refmut(&self, a: &mut &mut i32) {}
+    fn takes_raw_const(&self, a: *const i32) {}
+    fn takes_raw_mut(&self, a: *mut i32) {}
+}
+
+#[warn(clippy::unnecessary_mut_passed)]
+fn main() {
+    // Functions
+    takes_ref(&42);
+    //~^ unnecessary_mut_passed
+    takes_ref_ref(&&42);
+    //~^ unnecessary_mut_passed
+    takes_ref_refmut(&&mut 42);
+    //~^ unnecessary_mut_passed
+    takes_raw_const(&42);
+    //~^ unnecessary_mut_passed
+
+    let as_ptr: fn(&i32) = takes_ref;
+    as_ptr(&42);
+    //~^ unnecessary_mut_passed
+    let as_ptr: fn(&&i32) = takes_ref_ref;
+    as_ptr(&&42);
+    //~^ unnecessary_mut_passed
+    let as_ptr: fn(&&mut i32) = takes_ref_refmut;
+    as_ptr(&&mut 42);
+    //~^ unnecessary_mut_passed
+    let as_ptr: fn(*const i32) = takes_raw_const;
+    as_ptr(&42);
+    //~^ unnecessary_mut_passed
+
+    // Methods
+    let my_struct = MyStruct;
+    my_struct.takes_ref(&42);
+    //~^ unnecessary_mut_passed
+    my_struct.takes_ref_ref(&&42);
+    //~^ unnecessary_mut_passed
+    my_struct.takes_ref_refmut(&&mut 42);
+    //~^ unnecessary_mut_passed
+    my_struct.takes_raw_const(&42);
+    //~^ unnecessary_mut_passed
+
+    // No error
+
+    // Functions
+    takes_ref(&42);
+    let as_ptr: fn(&i32) = takes_ref;
+    as_ptr(&42);
+
+    takes_refmut(&mut 42);
+    let as_ptr: fn(&mut i32) = takes_refmut;
+    as_ptr(&mut 42);
+
+    takes_ref_ref(&&42);
+    let as_ptr: fn(&&i32) = takes_ref_ref;
+    as_ptr(&&42);
+
+    takes_refmut_ref(&mut &42);
+    let as_ptr: fn(&mut &i32) = takes_refmut_ref;
+    as_ptr(&mut &42);
+
+    takes_ref_refmut(&&mut 42);
+    let as_ptr: fn(&&mut i32) = takes_ref_refmut;
+    as_ptr(&&mut 42);
+
+    takes_refmut_refmut(&mut &mut 42);
+    let as_ptr: fn(&mut &mut i32) = takes_refmut_refmut;
+    as_ptr(&mut &mut 42);
+
+    takes_raw_const(&42);
+    let as_ptr: fn(*const i32) = takes_raw_const;
+    as_ptr(&42);
+
+    takes_raw_mut(&mut 42);
+    let as_ptr: fn(*mut i32) = takes_raw_mut;
+    as_ptr(&mut 42);
+
+    let a = &mut 42;
+    let b = &mut &42;
+    let c = &mut &mut 42;
+    takes_ref(a);
+    takes_ref_ref(b);
+    takes_ref_refmut(c);
+    takes_raw_const(a);
+
+    // Methods
+    my_struct.takes_ref(&42);
+    my_struct.takes_refmut(&mut 42);
+    my_struct.takes_ref_ref(&&42);
+    my_struct.takes_refmut_ref(&mut &42);
+    my_struct.takes_ref_refmut(&&mut 42);
+    my_struct.takes_refmut_refmut(&mut &mut 42);
+    my_struct.takes_raw_const(&42);
+    my_struct.takes_raw_mut(&mut 42);
+    my_struct.takes_ref(a);
+    my_struct.takes_ref_ref(b);
+    my_struct.takes_ref_refmut(c);
+    my_struct.takes_raw_const(a);
+    my_struct.takes_raw_mut(a);
+}
+
+// not supported currently
+fn raw_ptrs(my_struct: MyStruct) {
+    let mut n = 42;
+
+    takes_raw_const(&raw mut n);
+
+    let as_ptr: fn(*const i32) = takes_raw_const;
+    as_ptr(&raw mut n);
+
+    my_struct.takes_raw_const(&raw mut n);
+
+    // No error
+
+    takes_raw_const(&raw const n);
+    takes_raw_mut(&raw mut n);
+
+    let a = &raw mut n;
+    takes_raw_const(a);
+
+    my_struct.takes_raw_const(&raw const n);
+    my_struct.takes_raw_mut(&raw mut n);
+    my_struct.takes_raw_const(a);
+}
diff --git a/tests/ui/mut_reference.rs b/tests/ui/mut_reference.rs
index f664c373cdc3a..80e3f50692770 100644
--- a/tests/ui/mut_reference.rs
+++ b/tests/ui/mut_reference.rs
@@ -1,60 +1,170 @@
-#![allow(unused_variables, dead_code)]
-//@no-rustfix
-fn takes_an_immutable_reference(a: &i32) {}
-fn takes_a_mutable_reference(a: &mut i32) {}
+#![allow(clippy::mut_mut)]
+
+fn takes_ref(a: &i32) {}
+fn takes_refmut(a: &mut i32) {}
+fn takes_ref_ref(a: &&i32) {}
+fn takes_refmut_ref(a: &mut &i32) {}
+fn takes_ref_refmut(a: &&mut i32) {}
+fn takes_refmut_refmut(a: &mut &mut i32) {}
+fn takes_raw_const(a: *const i32) {}
+fn takes_raw_mut(a: *mut i32) {}
 
 mod issue11268 {
     macro_rules! x {
-        ($f:expr) => {
+        (1 $f:expr) => {
             $f(&mut 1);
         };
+        (2 $f:expr) => {
+            $f(&mut &1)
+        };
+        (3 $f:expr) => {
+            $f(&mut &mut 1)
+        };
+        (4 $f:expr) => {
+            let mut a = 1;
+            $f(&raw mut a)
+        };
     }
 
     fn f() {
-        x!(super::takes_an_immutable_reference);
-        x!(super::takes_a_mutable_reference);
+        x!(1 super::takes_ref);
+        x!(1 super::takes_refmut);
+        x!(2 super::takes_refmut_ref);
+        x!(3 super::takes_ref_refmut);
+        x!(3 super::takes_refmut_refmut);
+        x!(4 super::takes_raw_const);
+        x!(4 super::takes_raw_mut);
     }
 }
 
 struct MyStruct;
 
 impl MyStruct {
-    fn takes_an_immutable_reference(&self, a: &i32) {}
-
-    fn takes_a_mutable_reference(&self, a: &mut i32) {}
+    fn takes_ref(&self, a: &i32) {}
+    fn takes_refmut(&self, a: &mut i32) {}
+    fn takes_ref_ref(&self, a: &&i32) {}
+    fn takes_refmut_ref(&self, a: &mut &i32) {}
+    fn takes_ref_refmut(&self, a: &&mut i32) {}
+    fn takes_refmut_refmut(&self, a: &mut &mut i32) {}
+    fn takes_raw_const(&self, a: *const i32) {}
+    fn takes_raw_mut(&self, a: *mut i32) {}
 }
 
 #[warn(clippy::unnecessary_mut_passed)]
 fn main() {
     // Functions
-    takes_an_immutable_reference(&mut 42);
+    takes_ref(&mut 42);
+    //~^ unnecessary_mut_passed
+    takes_ref_ref(&mut &42);
+    //~^ unnecessary_mut_passed
+    takes_ref_refmut(&mut &mut 42);
+    //~^ unnecessary_mut_passed
+    takes_raw_const(&mut 42);
     //~^ unnecessary_mut_passed
 
-    let as_ptr: fn(&i32) = takes_an_immutable_reference;
+    let as_ptr: fn(&i32) = takes_ref;
+    as_ptr(&mut 42);
+    //~^ unnecessary_mut_passed
+    let as_ptr: fn(&&i32) = takes_ref_ref;
+    as_ptr(&mut &42);
+    //~^ unnecessary_mut_passed
+    let as_ptr: fn(&&mut i32) = takes_ref_refmut;
+    as_ptr(&mut &mut 42);
+    //~^ unnecessary_mut_passed
+    let as_ptr: fn(*const i32) = takes_raw_const;
     as_ptr(&mut 42);
     //~^ unnecessary_mut_passed
 
     // Methods
     let my_struct = MyStruct;
-    my_struct.takes_an_immutable_reference(&mut 42);
+    my_struct.takes_ref(&mut 42);
+    //~^ unnecessary_mut_passed
+    my_struct.takes_ref_ref(&mut &42);
+    //~^ unnecessary_mut_passed
+    my_struct.takes_ref_refmut(&mut &mut 42);
+    //~^ unnecessary_mut_passed
+    my_struct.takes_raw_const(&mut 42);
     //~^ unnecessary_mut_passed
 
     // No error
 
     // Functions
-    takes_an_immutable_reference(&42);
-    let as_ptr: fn(&i32) = takes_an_immutable_reference;
+    takes_ref(&42);
+    let as_ptr: fn(&i32) = takes_ref;
     as_ptr(&42);
 
-    takes_a_mutable_reference(&mut 42);
-    let as_ptr: fn(&mut i32) = takes_a_mutable_reference;
+    takes_refmut(&mut 42);
+    let as_ptr: fn(&mut i32) = takes_refmut;
+    as_ptr(&mut 42);
+
+    takes_ref_ref(&&42);
+    let as_ptr: fn(&&i32) = takes_ref_ref;
+    as_ptr(&&42);
+
+    takes_refmut_ref(&mut &42);
+    let as_ptr: fn(&mut &i32) = takes_refmut_ref;
+    as_ptr(&mut &42);
+
+    takes_ref_refmut(&&mut 42);
+    let as_ptr: fn(&&mut i32) = takes_ref_refmut;
+    as_ptr(&&mut 42);
+
+    takes_refmut_refmut(&mut &mut 42);
+    let as_ptr: fn(&mut &mut i32) = takes_refmut_refmut;
+    as_ptr(&mut &mut 42);
+
+    takes_raw_const(&42);
+    let as_ptr: fn(*const i32) = takes_raw_const;
+    as_ptr(&42);
+
+    takes_raw_mut(&mut 42);
+    let as_ptr: fn(*mut i32) = takes_raw_mut;
     as_ptr(&mut 42);
 
     let a = &mut 42;
-    takes_an_immutable_reference(a);
+    let b = &mut &42;
+    let c = &mut &mut 42;
+    takes_ref(a);
+    takes_ref_ref(b);
+    takes_ref_refmut(c);
+    takes_raw_const(a);
 
     // Methods
-    my_struct.takes_an_immutable_reference(&42);
-    my_struct.takes_a_mutable_reference(&mut 42);
-    my_struct.takes_an_immutable_reference(a);
+    my_struct.takes_ref(&42);
+    my_struct.takes_refmut(&mut 42);
+    my_struct.takes_ref_ref(&&42);
+    my_struct.takes_refmut_ref(&mut &42);
+    my_struct.takes_ref_refmut(&&mut 42);
+    my_struct.takes_refmut_refmut(&mut &mut 42);
+    my_struct.takes_raw_const(&42);
+    my_struct.takes_raw_mut(&mut 42);
+    my_struct.takes_ref(a);
+    my_struct.takes_ref_ref(b);
+    my_struct.takes_ref_refmut(c);
+    my_struct.takes_raw_const(a);
+    my_struct.takes_raw_mut(a);
+}
+
+// not supported currently
+fn raw_ptrs(my_struct: MyStruct) {
+    let mut n = 42;
+
+    takes_raw_const(&raw mut n);
+
+    let as_ptr: fn(*const i32) = takes_raw_const;
+    as_ptr(&raw mut n);
+
+    my_struct.takes_raw_const(&raw mut n);
+
+    // No error
+
+    takes_raw_const(&raw const n);
+    takes_raw_mut(&raw mut n);
+
+    let a = &raw mut n;
+    takes_raw_const(a);
+
+    my_struct.takes_raw_const(&raw const n);
+    my_struct.takes_raw_mut(&raw mut n);
+    my_struct.takes_raw_const(a);
 }
diff --git a/tests/ui/mut_reference.stderr b/tests/ui/mut_reference.stderr
index 474221329c258..5ecfaa37416ba 100644
--- a/tests/ui/mut_reference.stderr
+++ b/tests/ui/mut_reference.stderr
@@ -1,23 +1,77 @@
-error: the function `takes_an_immutable_reference` doesn't need a mutable reference
-  --> tests/ui/mut_reference.rs:30:34
+error: the function `takes_ref` doesn't need a mutable reference
+  --> tests/ui/mut_reference.rs:56:15
    |
-LL |     takes_an_immutable_reference(&mut 42);
-   |                                  ^^^^^^^
+LL |     takes_ref(&mut 42);
+   |               ^^^^^^^ help: remove this `mut`: `&42`
    |
    = note: `-D clippy::unnecessary-mut-passed` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_mut_passed)]`
 
+error: the function `takes_ref_ref` doesn't need a mutable reference
+  --> tests/ui/mut_reference.rs:58:19
+   |
+LL |     takes_ref_ref(&mut &42);
+   |                   ^^^^^^^^ help: remove this `mut`: `&&42`
+
+error: the function `takes_ref_refmut` doesn't need a mutable reference
+  --> tests/ui/mut_reference.rs:60:22
+   |
+LL |     takes_ref_refmut(&mut &mut 42);
+   |                      ^^^^^^^^^^^^ help: remove this `mut`: `&&mut 42`
+
+error: the function `takes_raw_const` doesn't need a mutable reference
+  --> tests/ui/mut_reference.rs:62:21
+   |
+LL |     takes_raw_const(&mut 42);
+   |                     ^^^^^^^ help: remove this `mut`: `&42`
+
+error: the function `as_ptr` doesn't need a mutable reference
+  --> tests/ui/mut_reference.rs:66:12
+   |
+LL |     as_ptr(&mut 42);
+   |            ^^^^^^^ help: remove this `mut`: `&42`
+
+error: the function `as_ptr` doesn't need a mutable reference
+  --> tests/ui/mut_reference.rs:69:12
+   |
+LL |     as_ptr(&mut &42);
+   |            ^^^^^^^^ help: remove this `mut`: `&&42`
+
+error: the function `as_ptr` doesn't need a mutable reference
+  --> tests/ui/mut_reference.rs:72:12
+   |
+LL |     as_ptr(&mut &mut 42);
+   |            ^^^^^^^^^^^^ help: remove this `mut`: `&&mut 42`
+
 error: the function `as_ptr` doesn't need a mutable reference
-  --> tests/ui/mut_reference.rs:34:12
+  --> tests/ui/mut_reference.rs:75:12
    |
 LL |     as_ptr(&mut 42);
-   |            ^^^^^^^
+   |            ^^^^^^^ help: remove this `mut`: `&42`
+
+error: the method `takes_ref` doesn't need a mutable reference
+  --> tests/ui/mut_reference.rs:80:25
+   |
+LL |     my_struct.takes_ref(&mut 42);
+   |                         ^^^^^^^ help: remove this `mut`: `&42`
+
+error: the method `takes_ref_ref` doesn't need a mutable reference
+  --> tests/ui/mut_reference.rs:82:29
+   |
+LL |     my_struct.takes_ref_ref(&mut &42);
+   |                             ^^^^^^^^ help: remove this `mut`: `&&42`
+
+error: the method `takes_ref_refmut` doesn't need a mutable reference
+  --> tests/ui/mut_reference.rs:84:32
+   |
+LL |     my_struct.takes_ref_refmut(&mut &mut 42);
+   |                                ^^^^^^^^^^^^ help: remove this `mut`: `&&mut 42`
 
-error: the method `takes_an_immutable_reference` doesn't need a mutable reference
-  --> tests/ui/mut_reference.rs:39:44
+error: the method `takes_raw_const` doesn't need a mutable reference
+  --> tests/ui/mut_reference.rs:86:31
    |
-LL |     my_struct.takes_an_immutable_reference(&mut 42);
-   |                                            ^^^^^^^
+LL |     my_struct.takes_raw_const(&mut 42);
+   |                               ^^^^^^^ help: remove this `mut`: `&42`
 
-error: aborting due to 3 previous errors
+error: aborting due to 12 previous errors
 

From 40ff07622e5122aecc2cc03a61152782bc2a0568 Mon Sep 17 00:00:00 2001
From: yanglsh <yanglsh@shanghaitech.edu.cn>
Date: Sun, 27 Jul 2025 18:06:59 +0800
Subject: [PATCH 0272/1889] fix: `never_loop` forget to remove break in nested
 loop

---
 clippy_lints/src/loops/never_loop.rs | 59 +++++++++++++----
 tests/ui/never_loop.rs               | 24 +++++++
 tests/ui/never_loop.stderr           | 97 +++++++++++++++++++++++++++-
 tests/ui/never_loop_fixable.fixed    |  2 +-
 tests/ui/never_loop_fixable.rs       |  2 +-
 5 files changed, 170 insertions(+), 14 deletions(-)

diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index 8a253ae5810f6..0ac66fa98650a 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -22,7 +22,10 @@ pub(super) fn check<'tcx>(
     for_loop: Option<&ForLoop<'_>>,
 ) {
     match never_loop_block(cx, block, &mut Vec::new(), loop_id) {
-        NeverLoopResult::Diverging { ref break_spans } => {
+        NeverLoopResult::Diverging {
+            ref break_spans,
+            ref never_spans,
+        } => {
             span_lint_and_then(cx, NEVER_LOOP, span, "this loop never actually loops", |diag| {
                 if let Some(ForLoop {
                     arg: iterator,
@@ -34,12 +37,16 @@ pub(super) fn check<'tcx>(
                 {
                     // If the block contains a break or continue, or if the loop has a label, `MachineApplicable` is not
                     // appropriate.
-                    let app = if !contains_any_break_or_continue(block) && label.is_none() {
+                    let mut app = if !contains_any_break_or_continue(block) && label.is_none() {
                         Applicability::MachineApplicable
                     } else {
                         Applicability::Unspecified
                     };
 
+                    if !never_spans.is_empty() {
+                        app = Applicability::HasPlaceholders;
+                    }
+
                     let mut suggestions = vec![(
                         for_span.with_hi(iterator.span.hi()),
                         for_to_if_let_sugg(cx, iterator, pat),
@@ -51,6 +58,13 @@ pub(super) fn check<'tcx>(
                         suggestions,
                         app,
                     );
+
+                    for span in never_spans {
+                        diag.span_help(
+                            *span,
+                            "this code is unreachable. Consider moving the reachable parts out",
+                        );
+                    }
                 }
             });
         },
@@ -77,13 +91,16 @@ fn contains_any_break_or_continue(block: &Block<'_>) -> bool {
 /// The first two bits of information are in this enum, and the last part is in the
 /// `local_labels` variable, which contains a list of `(block_id, reachable)` pairs ordered by
 /// scope.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 enum NeverLoopResult {
     /// A continue may occur for the main loop.
     MayContinueMainLoop,
     /// We have not encountered any main loop continue,
     /// but we are diverging (subsequent control flow is not reachable)
-    Diverging { break_spans: Vec<Span> },
+    Diverging {
+        break_spans: Vec<Span>,
+        never_spans: Vec<Span>,
+    },
     /// We have not encountered any main loop continue,
     /// and subsequent control flow is (possibly) reachable
     Normal,
@@ -128,14 +145,18 @@ fn combine_branches(b1: NeverLoopResult, b2: NeverLoopResult) -> NeverLoopResult
         (
             NeverLoopResult::Diverging {
                 break_spans: mut break_spans1,
+                never_spans: mut never_spans1,
             },
             NeverLoopResult::Diverging {
                 break_spans: mut break_spans2,
+                never_spans: mut never_spans2,
             },
         ) => {
             break_spans1.append(&mut break_spans2);
+            never_spans1.append(&mut never_spans2);
             NeverLoopResult::Diverging {
                 break_spans: break_spans1,
+                never_spans: never_spans1,
             }
         },
     }
@@ -207,6 +228,8 @@ fn all_spans_after_expr(cx: &LateContext<'_>, expr: &Expr<'_>) -> Vec<Span> {
         }
 
         return vec![stmt.span];
+    } else if let Node::Block(_) = cx.tcx.parent_hir_node(expr.hir_id) {
+        return vec![expr.span];
     }
 
     vec![]
@@ -270,10 +293,13 @@ fn never_loop_expr<'tcx>(
         ExprKind::Match(e, arms, _) => {
             let e = never_loop_expr(cx, e, local_labels, main_loop_id);
             combine_seq(e, || {
-                arms.iter()
-                    .fold(NeverLoopResult::Diverging { break_spans: vec![] }, |a, b| {
-                        combine_branches(a, never_loop_expr(cx, b.body, local_labels, main_loop_id))
-                    })
+                arms.iter().fold(
+                    NeverLoopResult::Diverging {
+                        break_spans: vec![],
+                        never_spans: vec![],
+                    },
+                    |a, b| combine_branches(a, never_loop_expr(cx, b.body, local_labels, main_loop_id)),
+                )
             })
         },
         ExprKind::Block(b, _) => {
@@ -296,6 +322,7 @@ fn never_loop_expr<'tcx>(
             } else {
                 NeverLoopResult::Diverging {
                     break_spans: all_spans_after_expr(cx, expr),
+                    never_spans: vec![],
                 }
             }
         },
@@ -306,7 +333,10 @@ fn never_loop_expr<'tcx>(
             combine_seq(first, || {
                 // checks if break targets a block instead of a loop
                 mark_block_as_reachable(expr, local_labels);
-                NeverLoopResult::Diverging { break_spans: vec![] }
+                NeverLoopResult::Diverging {
+                    break_spans: vec![],
+                    never_spans: vec![],
+                }
             })
         },
         ExprKind::Break(dest, e) => {
@@ -322,11 +352,15 @@ fn never_loop_expr<'tcx>(
                     } else {
                         all_spans_after_expr(cx, expr)
                     },
+                    never_spans: vec![],
                 }
             })
         },
         ExprKind::Become(e) => combine_seq(never_loop_expr(cx, e, local_labels, main_loop_id), || {
-            NeverLoopResult::Diverging { break_spans: vec![] }
+            NeverLoopResult::Diverging {
+                break_spans: vec![],
+                never_spans: vec![],
+            }
         }),
         ExprKind::InlineAsm(asm) => combine_seq_many(asm.operands.iter().map(|(o, _)| match o {
             InlineAsmOperand::In { expr, .. } | InlineAsmOperand::InOut { expr, .. } => {
@@ -356,7 +390,10 @@ fn never_loop_expr<'tcx>(
     };
     let result = combine_seq(result, || {
         if cx.typeck_results().expr_ty(expr).is_never() {
-            NeverLoopResult::Diverging { break_spans: vec![] }
+            NeverLoopResult::Diverging {
+                break_spans: vec![],
+                never_spans: all_spans_after_expr(cx, expr),
+            }
         } else {
             NeverLoopResult::Normal
         }
diff --git a/tests/ui/never_loop.rs b/tests/ui/never_loop.rs
index 48d4b8ad15196..01db64a446c0f 100644
--- a/tests/ui/never_loop.rs
+++ b/tests/ui/never_loop.rs
@@ -498,3 +498,27 @@ fn issue15059() {
         ()
     }
 }
+
+fn issue15350() {
+    'bar: for _ in 0..100 {
+        //~^ never_loop
+        loop {
+            //~^ never_loop
+            println!("This will still run");
+            break 'bar;
+        }
+    }
+
+    'foo: for _ in 0..100 {
+        //~^ never_loop
+        loop {
+            //~^ never_loop
+            println!("This will still run");
+            loop {
+                //~^ never_loop
+                println!("This will still run");
+                break 'foo;
+            }
+        }
+    }
+}
diff --git a/tests/ui/never_loop.stderr b/tests/ui/never_loop.stderr
index 54b463266a3a5..4fda06cff4ab9 100644
--- a/tests/ui/never_loop.stderr
+++ b/tests/ui/never_loop.stderr
@@ -193,6 +193,19 @@ LL | |         return;
 LL | |     }
    | |_____^
    |
+help: this code is unreachable. Consider moving the reachable parts out
+  --> tests/ui/never_loop.rs:436:9
+   |
+LL | /         loop {
+LL | |
+LL | |             break 'outer;
+LL | |         }
+   | |_________^
+help: this code is unreachable. Consider moving the reachable parts out
+  --> tests/ui/never_loop.rs:440:9
+   |
+LL |         return;
+   |         ^^^^^^^
 help: if you need the first element of the iterator, try writing
    |
 LL -     'outer: for v in 0..10 {
@@ -297,5 +310,87 @@ LL ~
 LL ~         
    |
 
-error: aborting due to 24 previous errors
+error: this loop never actually loops
+  --> tests/ui/never_loop.rs:503:5
+   |
+LL | /     'bar: for _ in 0..100 {
+LL | |
+LL | |         loop {
+...  |
+LL | |     }
+   | |_____^
+   |
+help: this code is unreachable. Consider moving the reachable parts out
+  --> tests/ui/never_loop.rs:505:9
+   |
+LL | /         loop {
+LL | |
+LL | |             println!("This will still run");
+LL | |             break 'bar;
+LL | |         }
+   | |_________^
+help: if you need the first element of the iterator, try writing
+   |
+LL -     'bar: for _ in 0..100 {
+LL +     if let Some(_) = (0..100).next() {
+   |
+
+error: this loop never actually loops
+  --> tests/ui/never_loop.rs:505:9
+   |
+LL | /         loop {
+LL | |
+LL | |             println!("This will still run");
+LL | |             break 'bar;
+LL | |         }
+   | |_________^
+
+error: this loop never actually loops
+  --> tests/ui/never_loop.rs:512:5
+   |
+LL | /     'foo: for _ in 0..100 {
+LL | |
+LL | |         loop {
+...  |
+LL | |     }
+   | |_____^
+   |
+help: this code is unreachable. Consider moving the reachable parts out
+  --> tests/ui/never_loop.rs:514:9
+   |
+LL | /         loop {
+LL | |
+LL | |             println!("This will still run");
+LL | |             loop {
+...  |
+LL | |         }
+   | |_________^
+help: if you need the first element of the iterator, try writing
+   |
+LL -     'foo: for _ in 0..100 {
+LL +     if let Some(_) = (0..100).next() {
+   |
+
+error: this loop never actually loops
+  --> tests/ui/never_loop.rs:514:9
+   |
+LL | /         loop {
+LL | |
+LL | |             println!("This will still run");
+LL | |             loop {
+...  |
+LL | |         }
+   | |_________^
+
+error: this loop never actually loops
+  --> tests/ui/never_loop.rs:517:13
+   |
+LL | /             loop {
+LL | |
+LL | |                 println!("This will still run");
+LL | |                 break 'foo;
+LL | |             }
+   | |_____________^
+
+error: aborting due to 29 previous errors
 
diff --git a/tests/ui/never_loop_fixable.fixed b/tests/ui/never_loop_fixable.fixed
index 5bc9ff1bb4df0..00c2af93a28ff 100644
--- a/tests/ui/never_loop_fixable.fixed
+++ b/tests/ui/never_loop_fixable.fixed
@@ -1,4 +1,4 @@
-#![allow(clippy::iter_next_slice, clippy::needless_return)]
+#![allow(clippy::iter_next_slice, clippy::needless_return, clippy::redundant_pattern_matching)]
 
 fn no_break_or_continue_loop() {
     if let Some(i) = [1, 2, 3].iter().next() {
diff --git a/tests/ui/never_loop_fixable.rs b/tests/ui/never_loop_fixable.rs
index 9782bc107e9a6..de85599f094d6 100644
--- a/tests/ui/never_loop_fixable.rs
+++ b/tests/ui/never_loop_fixable.rs
@@ -1,4 +1,4 @@
-#![allow(clippy::iter_next_slice, clippy::needless_return)]
+#![allow(clippy::iter_next_slice, clippy::needless_return, clippy::redundant_pattern_matching)]
 
 fn no_break_or_continue_loop() {
     for i in [1, 2, 3].iter() {

From 22ef90c8049cf8f07ce42e09f01ca791b829594e Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Mon, 25 Aug 2025 04:55:35 +0000
Subject: [PATCH 0273/1889] Prepare for merging from rust-lang/rust

This updates the rust-version file to a1dbb443527bd126452875eb5d5860c1d001d761.
---
 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 3450f18334a75..f412399cc8c39 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-f6d23413c399fb530be362ebcf25a4e788e16137
+a1dbb443527bd126452875eb5d5860c1d001d761

From 75d8687f2b6ac1e73071450cb57c4157fcba53b4 Mon Sep 17 00:00:00 2001
From: Valdemar Erk <valdemar@erk.dev>
Date: Sat, 23 Aug 2025 11:37:53 +0200
Subject: [PATCH 0274/1889] add span to struct pattern rest (..)

---
 compiler/rustc_ast/src/ast.rs                 |  6 +++---
 compiler/rustc_ast_lowering/src/expr.rs       |  6 +++---
 compiler/rustc_ast_lowering/src/lib.rs        |  2 +-
 compiler/rustc_ast_lowering/src/pat.rs        |  9 +++++----
 compiler/rustc_ast_pretty/src/pprust/state.rs |  2 +-
 compiler/rustc_hir/src/hir.rs                 |  8 ++++----
 compiler/rustc_hir_pretty/src/lib.rs          |  4 ++--
 compiler/rustc_hir_typeck/src/pat.rs          | 12 +++++++++--
 compiler/rustc_parse/src/parser/pat.rs        |  2 +-
 compiler/rustc_passes/src/liveness.rs         |  2 +-
 compiler/rustc_resolve/src/late.rs            |  2 +-
 .../clippy_lints/src/equatable_if_let.rs      |  2 +-
 .../clippy_lints/src/manual_let_else.rs       |  4 ++--
 .../matches/rest_pat_in_fully_bound_struct.rs |  2 +-
 .../clippy/clippy_lints/src/utils/author.rs   |  3 ++-
 src/tools/clippy/clippy_utils/src/lib.rs      |  2 +-
 src/tools/rustfmt/src/patterns.rs             |  2 +-
 tests/ui/stats/input-stats.stderr             | 20 +++++++++----------
 18 files changed, 50 insertions(+), 40 deletions(-)

diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index de3e0e0c87f5a..802a6fa324984 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -937,7 +937,7 @@ pub enum PatKind {
 #[derive(Clone, Copy, Encodable, Decodable, Debug, PartialEq, Walkable)]
 pub enum PatFieldsRest {
     /// `module::StructName { field, ..}`
-    Rest,
+    Rest(Span),
     /// `module::StructName { field, syntax error }`
     Recovered(ErrorGuaranteed),
     /// `module::StructName { field }`
@@ -4051,8 +4051,8 @@ mod size_asserts {
     static_assert_size!(Local, 96);
     static_assert_size!(MetaItemLit, 40);
     static_assert_size!(Param, 40);
-    static_assert_size!(Pat, 72);
-    static_assert_size!(PatKind, 48);
+    static_assert_size!(Pat, 80);
+    static_assert_size!(PatKind, 56);
     static_assert_size!(Path, 24);
     static_assert_size!(PathSegment, 24);
     static_assert_size!(Stmt, 32);
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index cbd17d66b7548..3674814b796c2 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -1434,10 +1434,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         self.dcx().emit_err(FunctionalRecordUpdateDestructuringAssignment {
                             span: e.span,
                         });
-                        true
+                        Some(self.lower_span(e.span))
                     }
-                    StructRest::Rest(_) => true,
-                    StructRest::None => false,
+                    StructRest::Rest(span) => Some(self.lower_span(*span)),
+                    StructRest::None => None,
                 };
                 let struct_pat = hir::PatKind::Struct(qpath, field_pats, fields_omitted);
                 return self.pat_without_dbm(lhs.span, struct_pat);
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index 70595391b85bc..137207bde1f12 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -2508,7 +2508,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         fields: &'hir [hir::PatField<'hir>],
     ) -> &'hir hir::Pat<'hir> {
         let qpath = hir::QPath::LangItem(lang_item, self.lower_span(span));
-        self.pat(span, hir::PatKind::Struct(qpath, fields, false))
+        self.pat(span, hir::PatKind::Struct(qpath, fields, None))
     }
 
     fn pat_ident(&mut self, span: Span, ident: Ident) -> (&'hir hir::Pat<'hir>, HirId) {
diff --git a/compiler/rustc_ast_lowering/src/pat.rs b/compiler/rustc_ast_lowering/src/pat.rs
index b8f8624787565..ed159f37051c1 100644
--- a/compiler/rustc_ast_lowering/src/pat.rs
+++ b/compiler/rustc_ast_lowering/src/pat.rs
@@ -106,10 +106,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         break hir::PatKind::Struct(
                             qpath,
                             fs,
-                            matches!(
-                                etc,
-                                ast::PatFieldsRest::Rest | ast::PatFieldsRest::Recovered(_)
-                            ),
+                            match etc {
+                                ast::PatFieldsRest::Rest(sp) => Some(self.lower_span(*sp)),
+                                ast::PatFieldsRest::Recovered(_) => Some(Span::default()),
+                                _ => None,
+                            },
                         );
                     }
                     PatKind::Tuple(pats) => {
diff --git a/compiler/rustc_ast_pretty/src/pprust/state.rs b/compiler/rustc_ast_pretty/src/pprust/state.rs
index a056ce3e29d28..41b520b04c993 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state.rs
@@ -1769,7 +1769,7 @@ impl<'a> State<'a> {
                     },
                     |f| f.pat.span,
                 );
-                if let ast::PatFieldsRest::Rest | ast::PatFieldsRest::Recovered(_) = etc {
+                if let ast::PatFieldsRest::Rest(_) | ast::PatFieldsRest::Recovered(_) = etc {
                     if !fields.is_empty() {
                         self.word_space(",");
                     }
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index e397c286de289..e3c27c73638c1 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -1884,8 +1884,8 @@ pub enum PatKind<'hir> {
     Binding(BindingMode, HirId, Ident, Option<&'hir Pat<'hir>>),
 
     /// A struct or struct variant pattern (e.g., `Variant {x, y, ..}`).
-    /// The `bool` is `true` in the presence of a `..`.
-    Struct(QPath<'hir>, &'hir [PatField<'hir>], bool),
+    /// The `Option` contains the span of a possible `..`.
+    Struct(QPath<'hir>, &'hir [PatField<'hir>], Option<Span>),
 
     /// A tuple struct/variant pattern `Variant(x, y, .., z)`.
     /// If the `..` pattern fragment is present, then `DotDotPos` denotes its position.
@@ -4979,8 +4979,8 @@ mod size_asserts {
     static_assert_size!(ItemKind<'_>, 64);
     static_assert_size!(LetStmt<'_>, 72);
     static_assert_size!(Param<'_>, 32);
-    static_assert_size!(Pat<'_>, 72);
-    static_assert_size!(PatKind<'_>, 48);
+    static_assert_size!(Pat<'_>, 80);
+    static_assert_size!(PatKind<'_>, 56);
     static_assert_size!(Path<'_>, 40);
     static_assert_size!(PathSegment<'_>, 48);
     static_assert_size!(QPath<'_>, 24);
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
index be5859b57c5e0..52b29e05dcb0e 100644
--- a/compiler/rustc_hir_pretty/src/lib.rs
+++ b/compiler/rustc_hir_pretty/src/lib.rs
@@ -1958,12 +1958,12 @@ impl<'a> State<'a> {
                 self.print_qpath(qpath, true);
                 self.nbsp();
                 self.word("{");
-                let empty = fields.is_empty() && !etc;
+                let empty = fields.is_empty() && etc.is_none();
                 if !empty {
                     self.space();
                 }
                 self.commasep_cmnt(Consistent, fields, |s, f| s.print_patfield(f), |f| f.pat.span);
-                if etc {
+                if etc.is_some() {
                     if !fields.is_empty() {
                         self.word_space(",");
                     }
diff --git a/compiler/rustc_hir_typeck/src/pat.rs b/compiler/rustc_hir_typeck/src/pat.rs
index 7dc736e5e6b14..f735c0a416099 100644
--- a/compiler/rustc_hir_typeck/src/pat.rs
+++ b/compiler/rustc_hir_typeck/src/pat.rs
@@ -605,7 +605,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             },
             PatKind::Struct(_, fields, has_rest_pat) => match opt_path_res.unwrap() {
                 Ok(ResolvedPat { ty, kind: ResolvedPatKind::Struct { variant } }) => self
-                    .check_pat_struct(pat, fields, has_rest_pat, ty, variant, expected, pat_info),
+                    .check_pat_struct(
+                        pat,
+                        fields,
+                        has_rest_pat.is_some(),
+                        ty,
+                        variant,
+                        expected,
+                        pat_info,
+                    ),
                 Err(guar) => {
                     let ty_err = Ty::new_error(self.tcx, guar);
                     for field in fields {
@@ -2428,7 +2436,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         let len = unmentioned_fields.len();
         let (prefix, postfix, sp) = match fields {
             [] => match &pat.kind {
-                PatKind::Struct(path, [], false) => {
+                PatKind::Struct(path, [], None) => {
                     (" { ", " }", path.span().shrink_to_hi().until(pat.span.shrink_to_hi()))
                 }
                 _ => return err,
diff --git a/compiler/rustc_parse/src/parser/pat.rs b/compiler/rustc_parse/src/parser/pat.rs
index 9754691a0b9ca..c4d30b3d32832 100644
--- a/compiler/rustc_parse/src/parser/pat.rs
+++ b/compiler/rustc_parse/src/parser/pat.rs
@@ -1516,7 +1516,7 @@ impl<'a> Parser<'a> {
                 || self.check_noexpect(&token::DotDotDot)
                 || self.check_keyword(exp!(Underscore))
             {
-                etc = PatFieldsRest::Rest;
+                etc = PatFieldsRest::Rest(self.token.span);
                 let mut etc_sp = self.token.span;
                 if first_etc_and_maybe_comma_span.is_none() {
                     if let Some(comma_tok) =
diff --git a/compiler/rustc_passes/src/liveness.rs b/compiler/rustc_passes/src/liveness.rs
index 801a533c94338..ae16a51bc693c 100644
--- a/compiler/rustc_passes/src/liveness.rs
+++ b/compiler/rustc_passes/src/liveness.rs
@@ -1583,7 +1583,7 @@ impl<'tcx> Liveness<'_, 'tcx> {
         });
 
         let can_remove = match pat.kind {
-            hir::PatKind::Struct(_, fields, true) => {
+            hir::PatKind::Struct(_, fields, Some(_)) => {
                 // if all fields are shorthand, remove the struct field, otherwise, mark with _ as prefix
                 fields.iter().all(|f| f.is_shorthand)
             }
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
index 679e663f88614..84108f0b8663d 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/compiler/rustc_resolve/src/late.rs
@@ -3922,7 +3922,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
 
     fn record_patterns_with_skipped_bindings(&mut self, pat: &Pat, rest: &ast::PatFieldsRest) {
         match rest {
-            ast::PatFieldsRest::Rest | ast::PatFieldsRest::Recovered(_) => {
+            ast::PatFieldsRest::Rest(_) | ast::PatFieldsRest::Recovered(_) => {
                 // Record that the pattern doesn't introduce all the bindings it could.
                 if let Some(partial_res) = self.r.partial_res_map.get(&pat.id)
                     && let Some(res) = partial_res.full_res()
diff --git a/src/tools/clippy/clippy_lints/src/equatable_if_let.rs b/src/tools/clippy/clippy_lints/src/equatable_if_let.rs
index 72f5eaf8a4bcc..c3fc09343dbfe 100644
--- a/src/tools/clippy/clippy_lints/src/equatable_if_let.rs
+++ b/src/tools/clippy/clippy_lints/src/equatable_if_let.rs
@@ -53,7 +53,7 @@ fn unary_pattern(pat: &Pat<'_>) -> bool {
         | PatKind::Never
         | PatKind::Or(_)
         | PatKind::Err(_) => false,
-        PatKind::Struct(_, a, etc) => !etc && a.iter().all(|x| unary_pattern(x.pat)),
+        PatKind::Struct(_, a, etc) => etc.is_none() && a.iter().all(|x| unary_pattern(x.pat)),
         PatKind::Tuple(a, etc) | PatKind::TupleStruct(_, a, etc) => etc.as_opt_usize().is_none() && array_rec(a),
         PatKind::Ref(x, _) | PatKind::Box(x) | PatKind::Deref(x) | PatKind::Guard(x, _) => unary_pattern(x),
         PatKind::Expr(_) => true,
diff --git a/src/tools/clippy/clippy_lints/src/manual_let_else.rs b/src/tools/clippy/clippy_lints/src/manual_let_else.rs
index 5a7967bbf9468..2705ef20b795d 100644
--- a/src/tools/clippy/clippy_lints/src/manual_let_else.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_let_else.rs
@@ -287,7 +287,7 @@ fn replace_in_pattern(
                 }
                 return or_pat;
             },
-            PatKind::Struct(path, fields, has_dot_dot) => {
+            PatKind::Struct(path, fields, dot_dot) => {
                 let fields = fields
                     .iter()
                     .map(|fld| {
@@ -311,7 +311,7 @@ fn replace_in_pattern(
                     .collect::<Vec<_>>();
                 let fields_string = fields.join(", ");
 
-                let dot_dot_str = if has_dot_dot { " .." } else { "" };
+                let dot_dot_str = if dot_dot.is_some() { " .." } else { "" };
                 let (sn_pth, _) = snippet_with_context(cx, path.span(), span.ctxt(), "", app);
                 return format!("{sn_pth} {{ {fields_string}{dot_dot_str} }}");
             },
diff --git a/src/tools/clippy/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs b/src/tools/clippy/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs
index 2154cd5b24a54..ae09c2e87d6b7 100644
--- a/src/tools/clippy/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs
@@ -7,7 +7,7 @@ use super::REST_PAT_IN_FULLY_BOUND_STRUCTS;
 
 pub(crate) fn check(cx: &LateContext<'_>, pat: &Pat<'_>) {
     if !pat.span.from_expansion()
-        && let PatKind::Struct(QPath::Resolved(_, path), fields, true) = pat.kind
+        && let PatKind::Struct(QPath::Resolved(_, path), fields, Some(_)) = pat.kind
         && let Some(def_id) = path.res.opt_def_id()
         && let ty = cx.tcx.type_of(def_id).instantiate_identity()
         && let ty::Adt(def, _) = ty.kind()
diff --git a/src/tools/clippy/clippy_lints/src/utils/author.rs b/src/tools/clippy/clippy_lints/src/utils/author.rs
index 2113cb92137eb..ece29362a39f9 100644
--- a/src/tools/clippy/clippy_lints/src/utils/author.rs
+++ b/src/tools/clippy/clippy_lints/src/utils/author.rs
@@ -754,7 +754,8 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
                 self.ident(name);
                 sub.if_some(|p| self.pat(p));
             },
-            PatKind::Struct(ref qpath, fields, ignore) => {
+            PatKind::Struct(ref qpath, fields, etc) => {
+                let ignore = etc.is_some();
                 bind!(self, qpath, fields);
                 kind!("Struct(ref {qpath}, {fields}, {ignore})");
                 self.qpath(qpath, pat);
diff --git a/src/tools/clippy/clippy_utils/src/lib.rs b/src/tools/clippy/clippy_utils/src/lib.rs
index 8533fa8554199..011c9b2f931ae 100644
--- a/src/tools/clippy/clippy_utils/src/lib.rs
+++ b/src/tools/clippy/clippy_utils/src/lib.rs
@@ -2011,7 +2011,7 @@ pub fn is_expr_identity_of_pat(cx: &LateContext<'_>, pat: &Pat<'_>, expr: &Expr<
                 false
             }
         },
-        (PatKind::Struct(pat_ident, field_pats, false), ExprKind::Struct(ident, fields, hir::StructTailExpr::None))
+        (PatKind::Struct(pat_ident, field_pats, None), ExprKind::Struct(ident, fields, hir::StructTailExpr::None))
             if field_pats.len() == fields.len() =>
         {
             // check ident
diff --git a/src/tools/rustfmt/src/patterns.rs b/src/tools/rustfmt/src/patterns.rs
index d212ecf392a7f..848bd0766e786 100644
--- a/src/tools/rustfmt/src/patterns.rs
+++ b/src/tools/rustfmt/src/patterns.rs
@@ -303,7 +303,7 @@ impl Rewrite for Pat {
                 qself,
                 path,
                 fields,
-                rest == ast::PatFieldsRest::Rest,
+                matches!(rest, ast::PatFieldsRest::Rest(_)),
                 self.span,
                 context,
                 shape,
diff --git a/tests/ui/stats/input-stats.stderr b/tests/ui/stats/input-stats.stderr
index 72a9820bb6431..4a73a4747ad0c 100644
--- a/tests/ui/stats/input-stats.stderr
+++ b/tests/ui/stats/input-stats.stderr
@@ -23,10 +23,10 @@ ast-stats - Path                      72 (NN.N%)             1
 ast-stats - Struct                    72 (NN.N%)             1
 ast-stats - Lit                      144 (NN.N%)             2
 ast-stats - Block                    216 (NN.N%)             3
-ast-stats Pat                      504 (NN.N%)             7            72
-ast-stats - Struct                    72 (NN.N%)             1
-ast-stats - Wild                      72 (NN.N%)             1
-ast-stats - Ident                    360 (NN.N%)             5
+ast-stats Pat                      560 (NN.N%)             7            80
+ast-stats - Struct                    80 (NN.N%)             1
+ast-stats - Wild                      80 (NN.N%)             1
+ast-stats - Ident                    400 (NN.N%)             5
 ast-stats GenericParam             480 (NN.N%)             5            96
 ast-stats GenericBound             352 (NN.N%)             4            88
 ast-stats - Trait                    352 (NN.N%)             4
@@ -57,7 +57,7 @@ ast-stats GenericArgs               40 (NN.N%)             1            40
 ast-stats - AngleBracketed            40 (NN.N%)             1
 ast-stats Crate                     40 (NN.N%)             1            40
 ast-stats ----------------------------------------------------------------
-ast-stats Total                  7_472                   129
+ast-stats Total                  7_528                   129
 ast-stats ================================================================
 hir-stats ================================================================
 hir-stats HIR STATS: input_stats
@@ -85,11 +85,11 @@ hir-stats - Ptr                       48 (NN.N%)             1
 hir-stats - Ref                       48 (NN.N%)             1
 hir-stats - Path                     624 (NN.N%)            13
 hir-stats Generics                 560 (NN.N%)            10            56
+hir-stats Pat                      400 (NN.N%)             5            80
+hir-stats - Struct                    80 (NN.N%)             1
+hir-stats - Wild                      80 (NN.N%)             1
+hir-stats - Binding                  240 (NN.N%)             3
 hir-stats GenericParam             400 (NN.N%)             5            80
-hir-stats Pat                      360 (NN.N%)             5            72
-hir-stats - Struct                    72 (NN.N%)             1
-hir-stats - Wild                      72 (NN.N%)             1
-hir-stats - Binding                  216 (NN.N%)             3
 hir-stats Block                    288 (NN.N%)             6            48
 hir-stats GenericBound             256 (NN.N%)             4            64
 hir-stats - Trait                    256 (NN.N%)             4
@@ -119,5 +119,5 @@ hir-stats TraitItemId                8 (NN.N%)             2             4
 hir-stats ImplItemId                 8 (NN.N%)             2             4
 hir-stats ForeignItemId              4 (NN.N%)             1             4
 hir-stats ----------------------------------------------------------------
-hir-stats Total                  8_584                   173
+hir-stats Total                  8_624                   173
 hir-stats ================================================================

From 01fefaad0294493380c25a304e38003ca50d0b05 Mon Sep 17 00:00:00 2001
From: Valdemar Erk <valdemar@erk.dev>
Date: Sat, 23 Aug 2025 11:37:53 +0200
Subject: [PATCH 0275/1889] add span to struct pattern rest (..)

---
 clippy_lints/src/equatable_if_let.rs                       | 2 +-
 clippy_lints/src/manual_let_else.rs                        | 4 ++--
 clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs | 2 +-
 clippy_lints/src/utils/author.rs                           | 3 ++-
 clippy_utils/src/lib.rs                                    | 2 +-
 5 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/clippy_lints/src/equatable_if_let.rs b/clippy_lints/src/equatable_if_let.rs
index 72f5eaf8a4bcc..c3fc09343dbfe 100644
--- a/clippy_lints/src/equatable_if_let.rs
+++ b/clippy_lints/src/equatable_if_let.rs
@@ -53,7 +53,7 @@ fn unary_pattern(pat: &Pat<'_>) -> bool {
         | PatKind::Never
         | PatKind::Or(_)
         | PatKind::Err(_) => false,
-        PatKind::Struct(_, a, etc) => !etc && a.iter().all(|x| unary_pattern(x.pat)),
+        PatKind::Struct(_, a, etc) => etc.is_none() && a.iter().all(|x| unary_pattern(x.pat)),
         PatKind::Tuple(a, etc) | PatKind::TupleStruct(_, a, etc) => etc.as_opt_usize().is_none() && array_rec(a),
         PatKind::Ref(x, _) | PatKind::Box(x) | PatKind::Deref(x) | PatKind::Guard(x, _) => unary_pattern(x),
         PatKind::Expr(_) => true,
diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 5a7967bbf9468..2705ef20b795d 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -287,7 +287,7 @@ fn replace_in_pattern(
                 }
                 return or_pat;
             },
-            PatKind::Struct(path, fields, has_dot_dot) => {
+            PatKind::Struct(path, fields, dot_dot) => {
                 let fields = fields
                     .iter()
                     .map(|fld| {
@@ -311,7 +311,7 @@ fn replace_in_pattern(
                     .collect::<Vec<_>>();
                 let fields_string = fields.join(", ");
 
-                let dot_dot_str = if has_dot_dot { " .." } else { "" };
+                let dot_dot_str = if dot_dot.is_some() { " .." } else { "" };
                 let (sn_pth, _) = snippet_with_context(cx, path.span(), span.ctxt(), "", app);
                 return format!("{sn_pth} {{ {fields_string}{dot_dot_str} }}");
             },
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 2154cd5b24a54..ae09c2e87d6b7 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
@@ -7,7 +7,7 @@ use super::REST_PAT_IN_FULLY_BOUND_STRUCTS;
 
 pub(crate) fn check(cx: &LateContext<'_>, pat: &Pat<'_>) {
     if !pat.span.from_expansion()
-        && let PatKind::Struct(QPath::Resolved(_, path), fields, true) = pat.kind
+        && let PatKind::Struct(QPath::Resolved(_, path), fields, Some(_)) = pat.kind
         && let Some(def_id) = path.res.opt_def_id()
         && let ty = cx.tcx.type_of(def_id).instantiate_identity()
         && let ty::Adt(def, _) = ty.kind()
diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
index 2113cb92137eb..ece29362a39f9 100644
--- a/clippy_lints/src/utils/author.rs
+++ b/clippy_lints/src/utils/author.rs
@@ -754,7 +754,8 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
                 self.ident(name);
                 sub.if_some(|p| self.pat(p));
             },
-            PatKind::Struct(ref qpath, fields, ignore) => {
+            PatKind::Struct(ref qpath, fields, etc) => {
+                let ignore = etc.is_some();
                 bind!(self, qpath, fields);
                 kind!("Struct(ref {qpath}, {fields}, {ignore})");
                 self.qpath(qpath, pat);
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 8533fa8554199..011c9b2f931ae 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -2011,7 +2011,7 @@ pub fn is_expr_identity_of_pat(cx: &LateContext<'_>, pat: &Pat<'_>, expr: &Expr<
                 false
             }
         },
-        (PatKind::Struct(pat_ident, field_pats, false), ExprKind::Struct(ident, fields, hir::StructTailExpr::None))
+        (PatKind::Struct(pat_ident, field_pats, None), ExprKind::Struct(ident, fields, hir::StructTailExpr::None))
             if field_pats.len() == fields.len() =>
         {
             // check ident

From 56bc9c35b9f625154f42f53f4b1e7843f02533ad Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Mon, 25 Aug 2025 16:44:42 +0800
Subject: [PATCH 0276/1889] Fix ExprStmt delete semicolon for
 toggle_macro_delimiter

---
 .../src/handlers/toggle_macro_delimiter.rs    | 36 +++++++++++++++++--
 1 file changed, 33 insertions(+), 3 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/toggle_macro_delimiter.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/toggle_macro_delimiter.rs
index 504e12f93df61..bf1546986ed27 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/toggle_macro_delimiter.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/toggle_macro_delimiter.rs
@@ -1,6 +1,6 @@
 use ide_db::assists::AssistId;
 use syntax::{
-    AstNode, T,
+    AstNode, SyntaxToken, T,
     ast::{self, syntax_factory::SyntaxFactory},
 };
 
@@ -39,7 +39,7 @@ pub(crate) fn toggle_macro_delimiter(acc: &mut Assists, ctx: &AssistContext<'_>)
     let makro = ctx.find_node_at_offset::<ast::MacroCall>()?;
 
     let cursor_offset = ctx.offset();
-    let semicolon = makro.semicolon_token();
+    let semicolon = macro_semicolon(&makro);
     let token_tree = makro.token_tree()?;
 
     let ltoken = token_tree.left_delimiter_token()?;
@@ -95,6 +95,14 @@ pub(crate) fn toggle_macro_delimiter(acc: &mut Assists, ctx: &AssistContext<'_>)
     )
 }
 
+fn macro_semicolon(makro: &ast::MacroCall) -> Option<SyntaxToken> {
+    makro.semicolon_token().or_else(|| {
+        let macro_expr = ast::MacroExpr::cast(makro.syntax().parent()?)?;
+        let expr_stmt = ast::ExprStmt::cast(macro_expr.syntax().parent()?)?;
+        expr_stmt.semicolon_token()
+    })
+}
+
 #[cfg(test)]
 mod tests {
     use crate::tests::{check_assist, check_assist_not_applicable};
@@ -119,7 +127,29 @@ macro_rules! sth {
 
 sth!{ }
             "#,
-        )
+        );
+
+        check_assist(
+            toggle_macro_delimiter,
+            r#"
+macro_rules! sth {
+    () => {};
+}
+
+fn foo() {
+    sth!$0( );
+}
+            "#,
+            r#"
+macro_rules! sth {
+    () => {};
+}
+
+fn foo() {
+    sth!{ }
+}
+            "#,
+        );
     }
 
     #[test]

From b08ebc5b204af82c1687f27047370209653c7983 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 25 Aug 2025 12:47:29 +0200
Subject: [PATCH 0277/1889] TB: fix SIFA comment

---
 .../src/borrow_tracker/tree_borrows/mod.rs    | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 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 04b951cd77c38..bed65440dc9aa 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
@@ -298,18 +298,18 @@ trait EvalContextPrivExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         // When adding a new node, the SIFA of its parents needs to be updated, potentially across
         // the entire memory range. For the parts that are being accessed below, the access itself
-        // trivially takes care of that. However, we have to do some more work to also deal with
-        // the parts that are not being accessed. Specifically what we do is that we
-        // call `update_last_accessed_after_retag` on the SIFA of the permission set for the part of
-        // memory outside `perm_map` -- so that part is definitely taken care of. The remaining concern
-        // is the part of memory that is in the range of `perms_map`, but not accessed below.
-        // There we have two cases:
-        // * If we do have an `UnsafeCell` (`has_unsafe_cell` becomes true), then the non-accessed part
-        //   uses `nonfreeze_perm`, so the `nonfreeze_perm` initialized parts are also fine. We enforce
-        //   the `freeze_perm` parts to be accessed, and thus everything is taken care of.
-        // * If there is no `UnsafeCell`, then `freeze_perm` is used everywhere (both inside and outside the initial range),
-        //   and we update everything to have the `freeze_perm`'s SIFA, so there are no issues. (And this assert below is not
-        //   actually needed in this case).
+        // trivially takes care of that. However, we have to do some more work to also deal with the
+        // parts that are not being accessed. Specifically what we do is that we call
+        // `update_last_accessed_after_retag` on the SIFA of the permission set for the part of
+        // memory outside `perm_map` -- so that part is definitely taken care of. The remaining
+        // concern is the part of memory that is in the range of `perms_map`, but not accessed
+        // below. There we have two cases:
+        // * If the type is `!Freeze`, then the non-accessed part uses `nonfreeze_perm`, so the
+        //   `nonfreeze_perm` initialized parts are also fine. We enforce the `freeze_perm` parts to
+        //   be accessed via the assert below, and thus everything is taken care of.
+        // * If the type is `Freeze`, then `freeze_perm` is used everywhere (both inside and outside
+        //   the initial range), and we update everything to have the `freeze_perm`'s SIFA, so there
+        //   are no issues. (And this assert below is not actually needed in this case).
         assert!(new_perm.freeze_access);
 
         let protected = new_perm.protector.is_some();

From a0aa1c1360916590f9a10d1b3d8586771c839d38 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Sun, 24 Aug 2025 16:44:28 +0300
Subject: [PATCH 0278/1889] Cache trait solving across queries in the same
 revision

Caching trait solving can do a lot to speed. Unfortunately it also consume a huge amount of memory. Therefore, as part of the migration to the new solver Jack Huey disabled caching of trait solving (he made the query transparent).

The PR proposes a middle ground: do cache trait solving, but only for the same revision. This allows us to be safe because during a revision the inputs cannot change.

The result is hopefully much better performance to features that tend to do a bulk of trait solving, and also repeat the same query (e.g. inference then IDE features).

There is another limitation: results are only cached in the same thread, to remove the need for synchronization which will be expensive. More measurements are required to check whether it's better to use a synchronized global cache, or maybe stay with a thread-local cache but batch multiple feature requests (highlighting, inlay hints etc.) of the same file to the same thread.

Alongside the actual cache we store the revision, because we need to verify it (we can't eagerly clear caches when incrementing the revision), and also the address of the db to prevent multiple dbs from interleaving (this is mostly relevant in tests, although injected highlighting also uses a new db, therefore maybe it's better to move it to a separate thread).

This "games" analysis-stats to both be way faster and use way more memory; the former is because analysis-stats doesn't increment revisions, therefore all queries share the cache and hit ratio is way too good, the latter is because analysis-stats doesn't increment revisions and therefore the cache isn't cleared. Both are not representative of a typical IDE scenario.
---
 .../rust-analyzer/crates/base-db/src/lib.rs   | 28 ++++++-
 .../crates/hir-def/src/test_db.rs             | 21 ++++-
 .../rust-analyzer/crates/hir-ty/src/infer.rs  | 82 +++++++++----------
 .../crates/hir-ty/src/mir/lower.rs            |  4 +-
 .../crates/hir-ty/src/next_solver/interner.rs | 39 +++++----
 .../crates/hir-ty/src/test_db.rs              | 23 +++++-
 .../rust-analyzer/crates/ide-db/src/lib.rs    |  9 +-
 7 files changed, 140 insertions(+), 66 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/base-db/src/lib.rs b/src/tools/rust-analyzer/crates/base-db/src/lib.rs
index dbf949c470c4d..14544acc11bdf 100644
--- a/src/tools/rust-analyzer/crates/base-db/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/base-db/src/lib.rs
@@ -7,7 +7,12 @@ pub use salsa_macros;
 mod change;
 mod input;
 
-use std::{cell::RefCell, hash::BuildHasherDefault, panic, sync::Once};
+use std::{
+    cell::RefCell,
+    hash::BuildHasherDefault,
+    panic,
+    sync::{Once, atomic::AtomicUsize},
+};
 
 pub use crate::{
     change::FileChange,
@@ -328,6 +333,27 @@ pub trait SourceDatabase: salsa::Database {
 
     #[doc(hidden)]
     fn crates_map(&self) -> Arc<CratesMap>;
+
+    fn nonce_and_revision(&self) -> (Nonce, salsa::Revision);
+}
+
+static NEXT_NONCE: AtomicUsize = AtomicUsize::new(0);
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct Nonce(usize);
+
+impl Default for Nonce {
+    #[inline]
+    fn default() -> Self {
+        Nonce::new()
+    }
+}
+
+impl Nonce {
+    #[inline]
+    pub fn new() -> Nonce {
+        Nonce(NEXT_NONCE.fetch_add(1, std::sync::atomic::Ordering::SeqCst))
+    }
 }
 
 /// Crate related data shared by the whole workspace.
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/test_db.rs b/src/tools/rust-analyzer/crates/hir-def/src/test_db.rs
index e30a5b65a1f79..1e2f354f975cb 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/test_db.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/test_db.rs
@@ -3,7 +3,7 @@
 use std::{fmt, panic, sync::Mutex};
 
 use base_db::{
-    Crate, CrateGraphBuilder, CratesMap, FileSourceRootInput, FileText, RootQueryDb,
+    Crate, CrateGraphBuilder, CratesMap, FileSourceRootInput, FileText, Nonce, RootQueryDb,
     SourceDatabase, SourceRoot, SourceRootId, SourceRootInput,
 };
 use hir_expand::{InFile, files::FilePosition};
@@ -20,12 +20,12 @@ use crate::{
 };
 
 #[salsa_macros::db]
-#[derive(Clone)]
 pub(crate) struct TestDB {
     storage: salsa::Storage<Self>,
     files: Arc<base_db::Files>,
     crates_map: Arc<CratesMap>,
     events: Arc<Mutex<Option<Vec<salsa::Event>>>>,
+    nonce: Nonce,
 }
 
 impl Default for TestDB {
@@ -44,6 +44,7 @@ impl Default for TestDB {
             events,
             files: Default::default(),
             crates_map: Default::default(),
+            nonce: Nonce::new(),
         };
         this.set_expand_proc_attr_macros_with_durability(true, Durability::HIGH);
         // This needs to be here otherwise `CrateGraphBuilder` panics.
@@ -53,6 +54,18 @@ impl Default for TestDB {
     }
 }
 
+impl Clone for TestDB {
+    fn clone(&self) -> Self {
+        Self {
+            storage: self.storage.clone(),
+            files: self.files.clone(),
+            crates_map: self.crates_map.clone(),
+            events: self.events.clone(),
+            nonce: Nonce::new(),
+        }
+    }
+}
+
 #[salsa_macros::db]
 impl salsa::Database for TestDB {}
 
@@ -117,6 +130,10 @@ impl SourceDatabase for TestDB {
     fn crates_map(&self) -> Arc<CratesMap> {
         self.crates_map.clone()
     }
+
+    fn nonce_and_revision(&self) -> (Nonce, salsa::Revision) {
+        (self.nonce, salsa::plumbing::ZalsaDatabase::zalsa(self).current_revision())
+    }
 }
 
 impl TestDB {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
index d778cc0e30ed4..71b33a0e9035f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
@@ -88,54 +88,52 @@ pub(crate) use closure::{CaptureKind, CapturedItem, CapturedItemWithoutTy};
 
 /// The entry point of type inference.
 pub(crate) fn infer_query(db: &dyn HirDatabase, def: DefWithBodyId) -> Arc<InferenceResult> {
-    crate::next_solver::with_new_cache(|| {
-        let _p = tracing::info_span!("infer_query").entered();
-        let resolver = def.resolver(db);
-        let body = db.body(def);
-        let mut ctx = InferenceContext::new(db, def, &body, resolver);
-
-        match def {
-            DefWithBodyId::FunctionId(f) => {
-                ctx.collect_fn(f);
-            }
-            DefWithBodyId::ConstId(c) => ctx.collect_const(c, &db.const_signature(c)),
-            DefWithBodyId::StaticId(s) => ctx.collect_static(&db.static_signature(s)),
-            DefWithBodyId::VariantId(v) => {
-                ctx.return_ty = TyBuilder::builtin(
-                    match db.enum_signature(v.lookup(db).parent).variant_body_type() {
-                        hir_def::layout::IntegerType::Pointer(signed) => match signed {
-                            true => BuiltinType::Int(BuiltinInt::Isize),
-                            false => BuiltinType::Uint(BuiltinUint::Usize),
-                        },
-                        hir_def::layout::IntegerType::Fixed(size, signed) => match signed {
-                            true => BuiltinType::Int(match size {
-                                Integer::I8 => BuiltinInt::I8,
-                                Integer::I16 => BuiltinInt::I16,
-                                Integer::I32 => BuiltinInt::I32,
-                                Integer::I64 => BuiltinInt::I64,
-                                Integer::I128 => BuiltinInt::I128,
-                            }),
-                            false => BuiltinType::Uint(match size {
-                                Integer::I8 => BuiltinUint::U8,
-                                Integer::I16 => BuiltinUint::U16,
-                                Integer::I32 => BuiltinUint::U32,
-                                Integer::I64 => BuiltinUint::U64,
-                                Integer::I128 => BuiltinUint::U128,
-                            }),
-                        },
+    let _p = tracing::info_span!("infer_query").entered();
+    let resolver = def.resolver(db);
+    let body = db.body(def);
+    let mut ctx = InferenceContext::new(db, def, &body, resolver);
+
+    match def {
+        DefWithBodyId::FunctionId(f) => {
+            ctx.collect_fn(f);
+        }
+        DefWithBodyId::ConstId(c) => ctx.collect_const(c, &db.const_signature(c)),
+        DefWithBodyId::StaticId(s) => ctx.collect_static(&db.static_signature(s)),
+        DefWithBodyId::VariantId(v) => {
+            ctx.return_ty = TyBuilder::builtin(
+                match db.enum_signature(v.lookup(db).parent).variant_body_type() {
+                    hir_def::layout::IntegerType::Pointer(signed) => match signed {
+                        true => BuiltinType::Int(BuiltinInt::Isize),
+                        false => BuiltinType::Uint(BuiltinUint::Usize),
                     },
-                );
-            }
+                    hir_def::layout::IntegerType::Fixed(size, signed) => match signed {
+                        true => BuiltinType::Int(match size {
+                            Integer::I8 => BuiltinInt::I8,
+                            Integer::I16 => BuiltinInt::I16,
+                            Integer::I32 => BuiltinInt::I32,
+                            Integer::I64 => BuiltinInt::I64,
+                            Integer::I128 => BuiltinInt::I128,
+                        }),
+                        false => BuiltinType::Uint(match size {
+                            Integer::I8 => BuiltinUint::U8,
+                            Integer::I16 => BuiltinUint::U16,
+                            Integer::I32 => BuiltinUint::U32,
+                            Integer::I64 => BuiltinUint::U64,
+                            Integer::I128 => BuiltinUint::U128,
+                        }),
+                    },
+                },
+            );
         }
+    }
 
-        ctx.infer_body();
+    ctx.infer_body();
 
-        ctx.infer_mut_body();
+    ctx.infer_mut_body();
 
-        ctx.infer_closures();
+    ctx.infer_closures();
 
-        Arc::new(ctx.resolve_all())
-    })
+    Arc::new(ctx.resolve_all())
 }
 
 pub(crate) fn infer_cycle_result(_: &dyn HirDatabase, _: DefWithBodyId) -> Arc<InferenceResult> {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
index 052be11e433f3..8c03ca939e370 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
@@ -2168,9 +2168,7 @@ pub fn mir_body_query(db: &dyn HirDatabase, def: DefWithBodyId) -> Result<Arc<Mi
     let _p = tracing::info_span!("mir_body_query", ?detail).entered();
     let body = db.body(def);
     let infer = db.infer(def);
-    let mut result = crate::next_solver::with_new_cache(|| {
-        lower_to_mir(db, def, &body, &infer, body.body_expr)
-    })?;
+    let mut result = lower_to_mir(db, def, &body, &infer, body.body_expr)?;
     result.shrink_to_fit();
     Ok(Arc::new(result))
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
index 4fe0b54d68462..f18e18221ae48 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
@@ -2149,37 +2149,48 @@ TrivialTypeTraversalImpls! {
     Placeholder<BoundVar>,
 }
 
-pub(crate) use tls_cache::with_new_cache;
 mod tls_cache {
     use crate::db::HirDatabase;
 
     use super::DbInterner;
+    use base_db::Nonce;
     use rustc_type_ir::search_graph::GlobalCache;
+    use salsa::Revision;
     use std::cell::RefCell;
 
-    scoped_tls::scoped_thread_local!(static GLOBAL_CACHE: RefCell<rustc_type_ir::search_graph::GlobalCache<DbInterner<'static>>>);
+    struct Cache {
+        cache: GlobalCache<DbInterner<'static>>,
+        revision: Revision,
+        db_nonce: Nonce,
+    }
 
-    pub(crate) fn with_new_cache<T>(f: impl FnOnce() -> T) -> T {
-        GLOBAL_CACHE.set(&RefCell::new(GlobalCache::default()), f)
+    thread_local! {
+        static GLOBAL_CACHE: RefCell<Option<Cache>> = const { RefCell::new(None) };
     }
 
     pub(super) fn with_cache<'db, T>(
-        _db: &'db dyn HirDatabase,
+        db: &'db dyn HirDatabase,
         f: impl FnOnce(&mut GlobalCache<DbInterner<'db>>) -> T,
     ) -> T {
-        // SAFETY: No idea
-        let call = move |slot: &RefCell<_>| {
+        GLOBAL_CACHE.with_borrow_mut(|handle| {
+            let (db_nonce, revision) = db.nonce_and_revision();
+            let handle = match handle {
+                Some(handle) => {
+                    if handle.revision != revision || db_nonce != handle.db_nonce {
+                        *handle = Cache { cache: GlobalCache::default(), revision, db_nonce };
+                    }
+                    handle
+                }
+                None => handle.insert(Cache { cache: GlobalCache::default(), revision, db_nonce }),
+            };
+
+            // SAFETY: No idea
             f(unsafe {
                 std::mem::transmute::<
                     &mut GlobalCache<DbInterner<'static>>,
                     &mut GlobalCache<DbInterner<'db>>,
-                >(&mut *slot.borrow_mut())
+                >(&mut handle.cache)
             })
-        };
-        if GLOBAL_CACHE.is_set() {
-            GLOBAL_CACHE.with(call)
-        } else {
-            GLOBAL_CACHE.set(&RefCell::new(GlobalCache::default()), || GLOBAL_CACHE.with(call))
-        }
+        })
     }
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/test_db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/test_db.rs
index 775136dc0cbf7..2a92aa52e0cd2 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/test_db.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/test_db.rs
@@ -3,8 +3,8 @@
 use std::{fmt, panic, sync::Mutex};
 
 use base_db::{
-    CrateGraphBuilder, CratesMap, FileSourceRootInput, FileText, RootQueryDb, SourceDatabase,
-    SourceRoot, SourceRootId, SourceRootInput,
+    CrateGraphBuilder, CratesMap, FileSourceRootInput, FileText, Nonce, RootQueryDb,
+    SourceDatabase, SourceRoot, SourceRootId, SourceRootInput,
 };
 
 use hir_def::{ModuleId, db::DefDatabase, nameres::crate_def_map};
@@ -17,12 +17,12 @@ use test_utils::extract_annotations;
 use triomphe::Arc;
 
 #[salsa_macros::db]
-#[derive(Clone)]
 pub(crate) struct TestDB {
     storage: salsa::Storage<Self>,
     files: Arc<base_db::Files>,
     crates_map: Arc<CratesMap>,
     events: Arc<Mutex<Option<Vec<salsa::Event>>>>,
+    nonce: Nonce,
 }
 
 impl Default for TestDB {
@@ -41,6 +41,7 @@ impl Default for TestDB {
             events,
             files: Default::default(),
             crates_map: Default::default(),
+            nonce: Nonce::new(),
         };
         this.set_expand_proc_attr_macros_with_durability(true, Durability::HIGH);
         // This needs to be here otherwise `CrateGraphBuilder` panics.
@@ -50,6 +51,18 @@ impl Default for TestDB {
     }
 }
 
+impl Clone for TestDB {
+    fn clone(&self) -> Self {
+        Self {
+            storage: self.storage.clone(),
+            files: self.files.clone(),
+            crates_map: self.crates_map.clone(),
+            events: self.events.clone(),
+            nonce: Nonce::new(),
+        }
+    }
+}
+
 impl fmt::Debug for TestDB {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("TestDB").finish()
@@ -109,6 +122,10 @@ impl SourceDatabase for TestDB {
     fn crates_map(&self) -> Arc<CratesMap> {
         self.crates_map.clone()
     }
+
+    fn nonce_and_revision(&self) -> (Nonce, salsa::Revision) {
+        (self.nonce, salsa::plumbing::ZalsaDatabase::zalsa(self).current_revision())
+    }
 }
 
 #[salsa_macros::db]
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/lib.rs b/src/tools/rust-analyzer/crates/ide-db/src/lib.rs
index 9d2474d91da67..44bccd86d8709 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/lib.rs
@@ -51,7 +51,7 @@ use salsa::Durability;
 use std::{fmt, mem::ManuallyDrop};
 
 use base_db::{
-    CrateGraphBuilder, CratesMap, FileSourceRootInput, FileText, Files, RootQueryDb,
+    CrateGraphBuilder, CratesMap, FileSourceRootInput, FileText, Files, Nonce, RootQueryDb,
     SourceDatabase, SourceRoot, SourceRootId, SourceRootInput, query_group,
 };
 use hir::{
@@ -83,6 +83,7 @@ pub struct RootDatabase {
     storage: ManuallyDrop<salsa::Storage<Self>>,
     files: Arc<Files>,
     crates_map: Arc<CratesMap>,
+    nonce: Nonce,
 }
 
 impl std::panic::RefUnwindSafe for RootDatabase {}
@@ -102,6 +103,7 @@ impl Clone for RootDatabase {
             storage: self.storage.clone(),
             files: self.files.clone(),
             crates_map: self.crates_map.clone(),
+            nonce: Nonce::new(),
         }
     }
 }
@@ -165,6 +167,10 @@ impl SourceDatabase for RootDatabase {
     fn crates_map(&self) -> Arc<CratesMap> {
         self.crates_map.clone()
     }
+
+    fn nonce_and_revision(&self) -> (Nonce, salsa::Revision) {
+        (self.nonce, salsa::plumbing::ZalsaDatabase::zalsa(self).current_revision())
+    }
 }
 
 impl Default for RootDatabase {
@@ -179,6 +185,7 @@ impl RootDatabase {
             storage: ManuallyDrop::new(salsa::Storage::default()),
             files: Default::default(),
             crates_map: Default::default(),
+            nonce: Nonce::new(),
         };
         // This needs to be here otherwise `CrateGraphBuilder` will panic.
         db.set_all_crates(Arc::new(Box::new([])));

From 8dbdb1760b23112f87aedad37e4dad97559bc750 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sun, 24 Aug 2025 19:22:51 +0000
Subject: [PATCH 0279/1889] On binding not present in all patterns, suggest
 potential typo

```
error[E0408]: variable `Ban` is not bound in all patterns
 --> f12.rs:9:9
  |
9 |         (Foo,Bar)|(Ban,Foo) => {}
  |         ^^^^^^^^^  --- variable not in all patterns
  |         |
  |         pattern doesn't bind `Ban`
  |
help: you might have meant to use the similarly named previously used binding `Bar`
  |
9 -         (Foo,Bar)|(Ban,Foo) => {}
9 +         (Foo,Bar)|(Bar,Foo) => {}
  |
```
---
 compiler/rustc_resolve/messages.ftl           |  2 +
 compiler/rustc_resolve/src/diagnostics.rs     | 53 ++++++++++--
 compiler/rustc_resolve/src/errors.rs          | 12 +++
 compiler/rustc_resolve/src/late.rs            | 52 ++++++------
 compiler/rustc_resolve/src/lib.rs             |  4 +-
 .../mismatched-bindings-async-fn.stderr       | 24 ++++++
 tests/ui/or-patterns/missing-bindings.stderr  | 81 +++++++++++++++++++
 .../nested-undelimited-precedence.stderr      |  6 ++
 .../name-resolution.stderr                    | 12 +++
 .../ui/resolve/resolve-inconsistent-names.rs  |  6 +-
 .../resolve/resolve-inconsistent-names.stderr | 46 +++++++----
 tests/ui/span/issue-39698.stderr              | 24 ++++++
 12 files changed, 268 insertions(+), 54 deletions(-)

diff --git a/compiler/rustc_resolve/messages.ftl b/compiler/rustc_resolve/messages.ftl
index 47280a936779f..0e566e20a124d 100644
--- a/compiler/rustc_resolve/messages.ftl
+++ b/compiler/rustc_resolve/messages.ftl
@@ -470,6 +470,8 @@ resolve_variable_bound_with_different_mode =
     .label = bound in different ways
     .first_binding_span = first binding
 
+resolve_variable_is_a_typo = you might have meant to use the similarly named previously used binding `{$typo}`
+
 resolve_variable_is_not_bound_in_all_patterns =
     variable `{$name}` is not bound in all patterns
 
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index 337e7d2dd8639..324310ff48b1d 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -661,8 +661,12 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             ResolutionError::VariableNotBoundInPattern(binding_error, parent_scope) => {
                 let BindingError { name, target, origin, could_be_path } = binding_error;
 
-                let target_sp = target.iter().copied().collect::<Vec<_>>();
-                let origin_sp = origin.iter().copied().collect::<Vec<_>>();
+                let mut target_sp = target.iter().map(|pat| pat.span).collect::<Vec<_>>();
+                target_sp.sort();
+                target_sp.dedup();
+                let mut origin_sp = origin.iter().map(|(span, _)| *span).collect::<Vec<_>>();
+                origin_sp.sort();
+                origin_sp.dedup();
 
                 let msp = MultiSpan::from_spans(target_sp.clone());
                 let mut err = self
@@ -671,8 +675,29 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 for sp in target_sp {
                     err.subdiagnostic(errors::PatternDoesntBindName { span: sp, name });
                 }
-                for sp in origin_sp {
-                    err.subdiagnostic(errors::VariableNotInAllPatterns { span: sp });
+                for sp in &origin_sp {
+                    err.subdiagnostic(errors::VariableNotInAllPatterns { span: *sp });
+                }
+                let mut target_visitor = BindingVisitor::default();
+                for pat in &target {
+                    target_visitor.visit_pat(pat);
+                }
+                target_visitor.identifiers.sort();
+                target_visitor.identifiers.dedup();
+                let mut origin_visitor = BindingVisitor::default();
+                for (_, pat) in &origin {
+                    origin_visitor.visit_pat(pat);
+                }
+                origin_visitor.identifiers.sort();
+                origin_visitor.identifiers.dedup();
+                // Find if the binding could have been a typo
+                let mut suggested_typo = false;
+                if let Some(typo) =
+                    find_best_match_for_name(&target_visitor.identifiers, name.name, None)
+                    && !origin_visitor.identifiers.contains(&typo)
+                {
+                    err.subdiagnostic(errors::PatternBindingTypo { spans: origin_sp, typo });
+                    suggested_typo = true;
                 }
                 if could_be_path {
                     let import_suggestions = self.lookup_import_candidates(
@@ -693,7 +718,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         },
                     );
 
-                    if import_suggestions.is_empty() {
+                    if import_suggestions.is_empty() && !suggested_typo {
                         let help_msg = format!(
                             "if you meant to match on a variant or a `const` item, consider \
                              making the path in the pattern qualified: `path::to::ModOrType::{name}`",
@@ -3395,7 +3420,7 @@ impl UsePlacementFinder {
     }
 }
 
-impl<'tcx> visit::Visitor<'tcx> for UsePlacementFinder {
+impl<'tcx> Visitor<'tcx> for UsePlacementFinder {
     fn visit_crate(&mut self, c: &Crate) {
         if self.target_module == CRATE_NODE_ID {
             let inject = c.spans.inject_use_span;
@@ -3423,6 +3448,22 @@ impl<'tcx> visit::Visitor<'tcx> for UsePlacementFinder {
     }
 }
 
+#[derive(Default)]
+struct BindingVisitor {
+    identifiers: Vec<Symbol>,
+    spans: FxHashMap<Symbol, Vec<Span>>,
+}
+
+impl<'tcx> Visitor<'tcx> for BindingVisitor {
+    fn visit_pat(&mut self, pat: &ast::Pat) {
+        if let ast::PatKind::Ident(_, ident, _) = pat.kind {
+            self.identifiers.push(ident.name);
+            self.spans.entry(ident.name).or_default().push(ident.span);
+        }
+        visit::walk_pat(self, pat);
+    }
+}
+
 fn search_for_any_use_in_items(items: &[Box<ast::Item>]) -> Option<Span> {
     for item in items {
         if let ItemKind::Use(..) = item.kind
diff --git a/compiler/rustc_resolve/src/errors.rs b/compiler/rustc_resolve/src/errors.rs
index 63d6fa23a148d..72be94e58db93 100644
--- a/compiler/rustc_resolve/src/errors.rs
+++ b/compiler/rustc_resolve/src/errors.rs
@@ -986,6 +986,18 @@ pub(crate) struct VariableNotInAllPatterns {
     pub(crate) span: Span,
 }
 
+#[derive(Subdiagnostic)]
+#[multipart_suggestion(
+    resolve_variable_is_a_typo,
+    applicability = "maybe-incorrect",
+    style = "verbose"
+)]
+pub(crate) struct PatternBindingTypo {
+    #[suggestion_part(code = "{typo}")]
+    pub(crate) spans: Vec<Span>,
+    pub(crate) typo: Symbol,
+}
+
 #[derive(Diagnostic)]
 #[diag(resolve_name_defined_multiple_time)]
 #[note]
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
index 679e663f88614..6f1bd4572dd28 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/compiler/rustc_resolve/src/late.rs
@@ -8,7 +8,6 @@
 
 use std::assert_matches::debug_assert_matches;
 use std::borrow::Cow;
-use std::collections::BTreeSet;
 use std::collections::hash_map::Entry;
 use std::mem::{replace, swap, take};
 
@@ -3682,31 +3681,30 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
         // 2) Record any missing bindings or binding mode inconsistencies.
         for (map_outer, pat_outer) in not_never_pats.iter() {
             // Check against all arms except for the same pattern which is always self-consistent.
-            let inners = not_never_pats
-                .iter()
-                .filter(|(_, pat)| pat.id != pat_outer.id)
-                .flat_map(|(map, _)| map);
-
-            for (&name, binding_inner) in inners {
-                match map_outer.get(&name) {
-                    None => {
-                        // The inner binding is missing in the outer.
-                        let binding_error =
-                            missing_vars.entry(name).or_insert_with(|| BindingError {
-                                name,
-                                origin: BTreeSet::new(),
-                                target: BTreeSet::new(),
-                                could_be_path: name.as_str().starts_with(char::is_uppercase),
-                            });
-                        binding_error.origin.insert(binding_inner.span);
-                        binding_error.target.insert(pat_outer.span);
-                    }
-                    Some(binding_outer) => {
-                        if binding_outer.annotation != binding_inner.annotation {
-                            // The binding modes in the outer and inner bindings differ.
-                            inconsistent_vars
-                                .entry(name)
-                                .or_insert((binding_inner.span, binding_outer.span));
+            let inners = not_never_pats.iter().filter(|(_, pat)| pat.id != pat_outer.id);
+
+            for (map, pat) in inners {
+                for (&name, binding_inner) in map {
+                    match map_outer.get(&name) {
+                        None => {
+                            // The inner binding is missing in the outer.
+                            let binding_error =
+                                missing_vars.entry(name).or_insert_with(|| BindingError {
+                                    name,
+                                    origin: Default::default(),
+                                    target: Default::default(),
+                                    could_be_path: name.as_str().starts_with(char::is_uppercase),
+                                });
+                            binding_error.origin.push((binding_inner.span, (***pat).clone()));
+                            binding_error.target.push((***pat_outer).clone());
+                        }
+                        Some(binding_outer) => {
+                            if binding_outer.annotation != binding_inner.annotation {
+                                // The binding modes in the outer and inner bindings differ.
+                                inconsistent_vars
+                                    .entry(name)
+                                    .or_insert((binding_inner.span, binding_outer.span));
+                            }
                         }
                     }
                 }
@@ -3719,7 +3717,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                 v.could_be_path = false;
             }
             self.report_error(
-                *v.origin.iter().next().unwrap(),
+                v.origin.iter().next().unwrap().0,
                 ResolutionError::VariableNotBoundInPattern(v, self.parent_scope),
             );
         }
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index 2afb52ef4d4be..c36a688330097 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -230,8 +230,8 @@ enum Used {
 #[derive(Debug)]
 struct BindingError {
     name: Ident,
-    origin: BTreeSet<Span>,
-    target: BTreeSet<Span>,
+    origin: Vec<(Span, ast::Pat)>,
+    target: Vec<ast::Pat>,
     could_be_path: bool,
 }
 
diff --git a/tests/ui/or-patterns/mismatched-bindings-async-fn.stderr b/tests/ui/or-patterns/mismatched-bindings-async-fn.stderr
index 81602fffa8d07..523cdf959e782 100644
--- a/tests/ui/or-patterns/mismatched-bindings-async-fn.stderr
+++ b/tests/ui/or-patterns/mismatched-bindings-async-fn.stderr
@@ -5,6 +5,12 @@ LL | async fn a((x | s): String) {}
    |             ^   - variable not in all patterns
    |             |
    |             pattern doesn't bind `s`
+   |
+help: you might have meant to use the similarly named previously used binding `x`
+   |
+LL - async fn a((x | s): String) {}
+LL + async fn a((x | x): String) {}
+   |
 
 error[E0408]: variable `x` is not bound in all patterns
   --> $DIR/mismatched-bindings-async-fn.rs:4:17
@@ -13,6 +19,12 @@ LL | async fn a((x | s): String) {}
    |             -   ^ pattern doesn't bind `x`
    |             |
    |             variable not in all patterns
+   |
+help: you might have meant to use the similarly named previously used binding `s`
+   |
+LL - async fn a((x | s): String) {}
+LL + async fn a((s | s): String) {}
+   |
 
 error[E0408]: variable `s` is not bound in all patterns
   --> $DIR/mismatched-bindings-async-fn.rs:9:10
@@ -21,6 +33,12 @@ LL |     let (x | s) = String::new();
    |          ^   - variable not in all patterns
    |          |
    |          pattern doesn't bind `s`
+   |
+help: you might have meant to use the similarly named previously used binding `x`
+   |
+LL -     let (x | s) = String::new();
+LL +     let (x | x) = String::new();
+   |
 
 error[E0408]: variable `x` is not bound in all patterns
   --> $DIR/mismatched-bindings-async-fn.rs:9:14
@@ -29,6 +47,12 @@ LL |     let (x | s) = String::new();
    |          -   ^ pattern doesn't bind `x`
    |          |
    |          variable not in all patterns
+   |
+help: you might have meant to use the similarly named previously used binding `s`
+   |
+LL -     let (x | s) = String::new();
+LL +     let (s | s) = String::new();
+   |
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/or-patterns/missing-bindings.stderr b/tests/ui/or-patterns/missing-bindings.stderr
index 6288cc589131f..636f701664727 100644
--- a/tests/ui/or-patterns/missing-bindings.stderr
+++ b/tests/ui/or-patterns/missing-bindings.stderr
@@ -86,6 +86,12 @@ LL |     let (A(A(a, b) | B(c), d) | B(e)) = Y;
    |            ^^^^^^^     - variable not in all patterns
    |            |
    |            pattern doesn't bind `c`
+   |
+help: you might have meant to use the similarly named previously used binding `a`
+   |
+LL -     let (A(A(a, b) | B(c), d) | B(e)) = Y;
+LL +     let (A(A(a, b) | B(a), d) | B(e)) = Y;
+   |
 
 error[E0408]: variable `a` is not bound in all patterns
   --> $DIR/missing-bindings.rs:47:22
@@ -94,6 +100,12 @@ LL |     let (A(A(a, b) | B(c), d) | B(e)) = Y;
    |              -       ^^^^ pattern doesn't bind `a`
    |              |
    |              variable not in all patterns
+   |
+help: you might have meant to use the similarly named previously used binding `c`
+   |
+LL -     let (A(A(a, b) | B(c), d) | B(e)) = Y;
+LL +     let (A(A(c, b) | B(c), d) | B(e)) = Y;
+   |
 
 error[E0408]: variable `b` is not bound in all patterns
   --> $DIR/missing-bindings.rs:47:22
@@ -102,6 +114,12 @@ LL |     let (A(A(a, b) | B(c), d) | B(e)) = Y;
    |                 -    ^^^^ pattern doesn't bind `b`
    |                 |
    |                 variable not in all patterns
+   |
+help: you might have meant to use the similarly named previously used binding `c`
+   |
+LL -     let (A(A(a, b) | B(c), d) | B(e)) = Y;
+LL +     let (A(A(a, c) | B(c), d) | B(e)) = Y;
+   |
 
 error[E0408]: variable `e` is not bound in all patterns
   --> $DIR/missing-bindings.rs:47:10
@@ -110,6 +128,12 @@ LL |     let (A(A(a, b) | B(c), d) | B(e)) = Y;
    |          ^^^^^^^^^^^^^^^^^^^^     - variable not in all patterns
    |          |
    |          pattern doesn't bind `e`
+   |
+help: you might have meant to use the similarly named previously used binding `c`
+   |
+LL -     let (A(A(a, b) | B(c), d) | B(e)) = Y;
+LL +     let (A(A(a, b) | B(c), d) | B(c)) = Y;
+   |
 
 error[E0408]: variable `a` is not bound in all patterns
   --> $DIR/missing-bindings.rs:47:33
@@ -118,6 +142,12 @@ LL |     let (A(A(a, b) | B(c), d) | B(e)) = Y;
    |              -                  ^^^^ pattern doesn't bind `a`
    |              |
    |              variable not in all patterns
+   |
+help: you might have meant to use the similarly named previously used binding `e`
+   |
+LL -     let (A(A(a, b) | B(c), d) | B(e)) = Y;
+LL +     let (A(A(e, b) | B(c), d) | B(e)) = Y;
+   |
 
 error[E0408]: variable `b` is not bound in all patterns
   --> $DIR/missing-bindings.rs:47:33
@@ -126,6 +156,12 @@ LL |     let (A(A(a, b) | B(c), d) | B(e)) = Y;
    |                 -               ^^^^ pattern doesn't bind `b`
    |                 |
    |                 variable not in all patterns
+   |
+help: you might have meant to use the similarly named previously used binding `e`
+   |
+LL -     let (A(A(a, b) | B(c), d) | B(e)) = Y;
+LL +     let (A(A(a, e) | B(c), d) | B(e)) = Y;
+   |
 
 error[E0408]: variable `c` is not bound in all patterns
   --> $DIR/missing-bindings.rs:47:33
@@ -134,6 +170,12 @@ LL |     let (A(A(a, b) | B(c), d) | B(e)) = Y;
    |                        -        ^^^^ pattern doesn't bind `c`
    |                        |
    |                        variable not in all patterns
+   |
+help: you might have meant to use the similarly named previously used binding `e`
+   |
+LL -     let (A(A(a, b) | B(c), d) | B(e)) = Y;
+LL +     let (A(A(a, b) | B(e), d) | B(e)) = Y;
+   |
 
 error[E0408]: variable `d` is not bound in all patterns
   --> $DIR/missing-bindings.rs:47:33
@@ -142,6 +184,12 @@ LL |     let (A(A(a, b) | B(c), d) | B(e)) = Y;
    |                            -    ^^^^ pattern doesn't bind `d`
    |                            |
    |                            variable not in all patterns
+   |
+help: you might have meant to use the similarly named previously used binding `e`
+   |
+LL -     let (A(A(a, b) | B(c), d) | B(e)) = Y;
+LL +     let (A(A(a, b) | B(c), e) | B(e)) = Y;
+   |
 
 error[E0408]: variable `a` is not bound in all patterns
   --> $DIR/missing-bindings.rs:63:29
@@ -158,6 +206,12 @@ LL |                     A(_, a) |
    |                     ^^^^^^^ pattern doesn't bind `b`
 LL |                     B(b),
    |                       - variable not in all patterns
+   |
+help: you might have meant to use the similarly named previously used binding `a`
+   |
+LL -                     B(b),
+LL +                     B(a),
+   |
 
 error[E0408]: variable `a` is not bound in all patterns
   --> $DIR/missing-bindings.rs:71:21
@@ -166,6 +220,12 @@ LL |                     A(_, a) |
    |                          - variable not in all patterns
 LL |                     B(b),
    |                     ^^^^ pattern doesn't bind `a`
+   |
+help: you might have meant to use the similarly named previously used binding `b`
+   |
+LL -                     A(_, a) |
+LL +                     A(_, b) |
+   |
 
 error[E0408]: variable `a` is not bound in all patterns
   --> $DIR/missing-bindings.rs:74:17
@@ -202,6 +262,12 @@ LL |                       B(b),
 ...
 LL |               V3(c),
    |               ^^^^^ pattern doesn't bind `b`
+   |
+help: you might have meant to use the similarly named previously used binding `c`
+   |
+LL -                     B(b),
+LL +                     B(c),
+   |
 
 error[E0408]: variable `c` is not bound in all patterns
   --> $DIR/missing-bindings.rs:59:13
@@ -223,6 +289,12 @@ LL | |             ) |
    | |_____________^ pattern doesn't bind `c`
 LL |               V3(c),
    |                  - variable not in all patterns
+   |
+help: you might have meant to use the similarly named previously used binding `a`
+   |
+LL -             V3(c),
+LL +             V3(a),
+   |
 
 error[E0408]: variable `a` is not bound in all patterns
   --> $DIR/missing-bindings.rs:78:13
@@ -235,6 +307,15 @@ LL |                     A(_, a) |
 ...
 LL |             V3(c),
    |             ^^^^^ pattern doesn't bind `a`
+   |
+help: you might have meant to use the similarly named previously used binding `c`
+   |
+LL ~                 B(Ok(a) | Err(c))
+LL |             ) |
+LL |             V2(
+LL |                 A(
+LL ~                     A(_, c) |
+   |
 
 error[E0170]: pattern binding `beta` is named the same as one of the variants of the type `check_handling_of_paths::bar::foo`
   --> $DIR/missing-bindings.rs:19:18
diff --git a/tests/ui/or-patterns/nested-undelimited-precedence.stderr b/tests/ui/or-patterns/nested-undelimited-precedence.stderr
index 0835ca1929f15..10dbc9d16c0e2 100644
--- a/tests/ui/or-patterns/nested-undelimited-precedence.stderr
+++ b/tests/ui/or-patterns/nested-undelimited-precedence.stderr
@@ -60,6 +60,12 @@ LL |     let b @ A | B: E = A;
    |         -       ^ pattern doesn't bind `b`
    |         |
    |         variable not in all patterns
+   |
+help: you might have meant to use the similarly named previously used binding `B`
+   |
+LL -     let b @ A | B: E = A;
+LL +     let B @ A | B: E = A;
+   |
 
 error[E0308]: mismatched types
   --> $DIR/nested-undelimited-precedence.rs:34:9
diff --git a/tests/ui/pattern/rfc-3637-guard-patterns/name-resolution.stderr b/tests/ui/pattern/rfc-3637-guard-patterns/name-resolution.stderr
index d76e60478a146..a5d9fd2b1a6ec 100644
--- a/tests/ui/pattern/rfc-3637-guard-patterns/name-resolution.stderr
+++ b/tests/ui/pattern/rfc-3637-guard-patterns/name-resolution.stderr
@@ -5,6 +5,12 @@ LL |         ((Ok(x) if y) | (Err(y) if x),) => x && y,
    |          ^^^^^^^^^^^^        - variable not in all patterns
    |          |
    |          pattern doesn't bind `y`
+   |
+help: you might have meant to use the similarly named previously used binding `x`
+   |
+LL -         ((Ok(x) if y) | (Err(y) if x),) => x && y,
+LL +         ((Ok(x) if y) | (Err(x) if x),) => x && y,
+   |
 
 error[E0408]: variable `x` is not bound in all patterns
   --> $DIR/name-resolution.rs:37:25
@@ -13,6 +19,12 @@ LL |         ((Ok(x) if y) | (Err(y) if x),) => x && y,
    |              -          ^^^^^^^^^^^^^ pattern doesn't bind `x`
    |              |
    |              variable not in all patterns
+   |
+help: you might have meant to use the similarly named previously used binding `y`
+   |
+LL -         ((Ok(x) if y) | (Err(y) if x),) => x && y,
+LL +         ((Ok(y) if y) | (Err(y) if x),) => x && y,
+   |
 
 error[E0408]: variable `x` is not bound in all patterns
   --> $DIR/name-resolution.rs:63:28
diff --git a/tests/ui/resolve/resolve-inconsistent-names.rs b/tests/ui/resolve/resolve-inconsistent-names.rs
index 9a40b20346c95..bf74a4ba0f342 100644
--- a/tests/ui/resolve/resolve-inconsistent-names.rs
+++ b/tests/ui/resolve/resolve-inconsistent-names.rs
@@ -10,8 +10,10 @@ pub mod m {
 fn main() {
     let y = 1;
     match y {
-       a | b => {} //~  ERROR variable `a` is not bound in all patterns
-                   //~| ERROR variable `b` is not bound in all patterns
+        a | b => {} //~  ERROR variable `a` is not bound in all patterns
+        //~| ERROR variable `b` is not bound in all patterns
+        //~| HELP you might have meant to use the similarly named previously used binding `a`
+        //~| HELP you might have meant to use the similarly named previously used binding `b`
     }
 
     let x = (E::A, E::B);
diff --git a/tests/ui/resolve/resolve-inconsistent-names.stderr b/tests/ui/resolve/resolve-inconsistent-names.stderr
index 5fac622eef263..152c16ad404ef 100644
--- a/tests/ui/resolve/resolve-inconsistent-names.stderr
+++ b/tests/ui/resolve/resolve-inconsistent-names.stderr
@@ -1,21 +1,33 @@
 error[E0408]: variable `b` is not bound in all patterns
-  --> $DIR/resolve-inconsistent-names.rs:13:8
+  --> $DIR/resolve-inconsistent-names.rs:13:9
+   |
+LL |         a | b => {}
+   |         ^   - variable not in all patterns
+   |         |
+   |         pattern doesn't bind `b`
+   |
+help: you might have meant to use the similarly named previously used binding `a`
+   |
+LL -         a | b => {}
+LL +         a | a => {}
    |
-LL |        a | b => {}
-   |        ^   - variable not in all patterns
-   |        |
-   |        pattern doesn't bind `b`
 
 error[E0408]: variable `a` is not bound in all patterns
-  --> $DIR/resolve-inconsistent-names.rs:13:12
+  --> $DIR/resolve-inconsistent-names.rs:13:13
+   |
+LL |         a | b => {}
+   |         -   ^ pattern doesn't bind `a`
+   |         |
+   |         variable not in all patterns
+   |
+help: you might have meant to use the similarly named previously used binding `b`
+   |
+LL -         a | b => {}
+LL +         b | b => {}
    |
-LL |        a | b => {}
-   |        -   ^ pattern doesn't bind `a`
-   |        |
-   |        variable not in all patterns
 
 error[E0408]: variable `c` is not bound in all patterns
-  --> $DIR/resolve-inconsistent-names.rs:19:9
+  --> $DIR/resolve-inconsistent-names.rs:21:9
    |
 LL |         (A, B) | (ref B, c) | (c, A) => ()
    |         ^^^^^^           -     - variable not in all patterns
@@ -24,7 +36,7 @@ LL |         (A, B) | (ref B, c) | (c, A) => ()
    |         pattern doesn't bind `c`
 
 error[E0408]: variable `A` is not bound in all patterns
-  --> $DIR/resolve-inconsistent-names.rs:19:18
+  --> $DIR/resolve-inconsistent-names.rs:21:18
    |
 LL |         (A, B) | (ref B, c) | (c, A) => ()
    |          -       ^^^^^^^^^^       - variable not in all patterns
@@ -38,7 +50,7 @@ LL |         (E::A, B) | (ref B, c) | (c, A) => ()
    |          +++
 
 error[E0408]: variable `B` is not bound in all patterns
-  --> $DIR/resolve-inconsistent-names.rs:19:31
+  --> $DIR/resolve-inconsistent-names.rs:21:31
    |
 LL |         (A, B) | (ref B, c) | (c, A) => ()
    |             -         -       ^^^^^^ pattern doesn't bind `B`
@@ -47,7 +59,7 @@ LL |         (A, B) | (ref B, c) | (c, A) => ()
    |             variable not in all patterns
 
 error[E0409]: variable `B` is bound inconsistently across alternatives separated by `|`
-  --> $DIR/resolve-inconsistent-names.rs:19:23
+  --> $DIR/resolve-inconsistent-names.rs:21:23
    |
 LL |         (A, B) | (ref B, c) | (c, A) => ()
    |             -         ^ bound in different ways
@@ -55,7 +67,7 @@ LL |         (A, B) | (ref B, c) | (c, A) => ()
    |             first binding
 
 error[E0408]: variable `Const2` is not bound in all patterns
-  --> $DIR/resolve-inconsistent-names.rs:31:9
+  --> $DIR/resolve-inconsistent-names.rs:33:9
    |
 LL |         (CONST1, _) | (_, Const2) => ()
    |         ^^^^^^^^^^^       ------ variable not in all patterns
@@ -68,7 +80,7 @@ LL |         (CONST1, _) | (_, m::Const2) => ()
    |                           +++
 
 error[E0408]: variable `CONST1` is not bound in all patterns
-  --> $DIR/resolve-inconsistent-names.rs:31:23
+  --> $DIR/resolve-inconsistent-names.rs:33:23
    |
 LL |         (CONST1, _) | (_, Const2) => ()
    |          ------       ^^^^^^^^^^^ pattern doesn't bind `CONST1`
@@ -82,7 +94,7 @@ LL |     const CONST1: usize = 10;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ not accessible
 
 error[E0308]: mismatched types
-  --> $DIR/resolve-inconsistent-names.rs:19:19
+  --> $DIR/resolve-inconsistent-names.rs:21:19
    |
 LL |     match x {
    |           - this expression has type `(E, E)`
diff --git a/tests/ui/span/issue-39698.stderr b/tests/ui/span/issue-39698.stderr
index 73fcc5c847755..eb18969c3c0db 100644
--- a/tests/ui/span/issue-39698.stderr
+++ b/tests/ui/span/issue-39698.stderr
@@ -7,6 +7,12 @@ LL |         T::T1(a, d) | T::T2(d, b) | T::T3(c) | T::T4(a) => { println!("{:?}
    |         |                      |    pattern doesn't bind `b`
    |         |                      variable not in all patterns
    |         pattern doesn't bind `b`
+   |
+help: you might have meant to use the similarly named previously used binding `c`
+   |
+LL -         T::T1(a, d) | T::T2(d, b) | T::T3(c) | T::T4(a) => { println!("{:?}", a); }
+LL +         T::T1(a, d) | T::T2(d, c) | T::T3(c) | T::T4(a) => { println!("{:?}", a); }
+   |
 
 error[E0408]: variable `c` is not bound in all patterns
   --> $DIR/issue-39698.rs:10:9
@@ -17,6 +23,12 @@ LL |         T::T1(a, d) | T::T2(d, b) | T::T3(c) | T::T4(a) => { println!("{:?}
    |         |             |                   variable not in all patterns
    |         |             pattern doesn't bind `c`
    |         pattern doesn't bind `c`
+   |
+help: you might have meant to use the similarly named previously used binding `d`
+   |
+LL -         T::T1(a, d) | T::T2(d, b) | T::T3(c) | T::T4(a) => { println!("{:?}", a); }
+LL +         T::T1(a, d) | T::T2(d, b) | T::T3(d) | T::T4(a) => { println!("{:?}", a); }
+   |
 
 error[E0408]: variable `a` is not bound in all patterns
   --> $DIR/issue-39698.rs:10:23
@@ -27,6 +39,12 @@ LL |         T::T1(a, d) | T::T2(d, b) | T::T3(c) | T::T4(a) => { println!("{:?}
    |               |       |             pattern doesn't bind `a`
    |               |       pattern doesn't bind `a`
    |               variable not in all patterns
+   |
+help: you might have meant to use the similarly named previously used binding `c`
+   |
+LL -         T::T1(a, d) | T::T2(d, b) | T::T3(c) | T::T4(a) => { println!("{:?}", a); }
+LL +         T::T1(c, d) | T::T2(d, b) | T::T3(c) | T::T4(c) => { println!("{:?}", a); }
+   |
 
 error[E0408]: variable `d` is not bound in all patterns
   --> $DIR/issue-39698.rs:10:37
@@ -37,6 +55,12 @@ LL |         T::T1(a, d) | T::T2(d, b) | T::T3(c) | T::T4(a) => { println!("{:?}
    |                  |          |       pattern doesn't bind `d`
    |                  |          variable not in all patterns
    |                  variable not in all patterns
+   |
+help: you might have meant to use the similarly named previously used binding `c`
+   |
+LL -         T::T1(a, d) | T::T2(d, b) | T::T3(c) | T::T4(a) => { println!("{:?}", a); }
+LL +         T::T1(a, c) | T::T2(c, b) | T::T3(c) | T::T4(a) => { println!("{:?}", a); }
+   |
 
 error[E0381]: used binding `a` is possibly-uninitialized
   --> $DIR/issue-39698.rs:10:79

From 137feef30804ae1657de6120ade81c2f70e5d00a Mon Sep 17 00:00:00 2001
From: yanglsh <yanglsh@shanghaitech.edu.cn>
Date: Mon, 25 Aug 2025 08:01:37 +0800
Subject: [PATCH 0280/1889] fix: `async_yields_async` wrongly unmangled macros

---
 clippy_lints/src/async_yields_async.rs | 60 +++++++++++++++-----------
 clippy_utils/src/lib.rs                | 20 +++++++--
 tests/ui/async_yields_async.fixed      | 39 +++++++++++++++++
 tests/ui/async_yields_async.rs         | 39 +++++++++++++++++
 tests/ui/async_yields_async.stderr     | 47 +++++++++++++++++++-
 5 files changed, 176 insertions(+), 29 deletions(-)

diff --git a/clippy_lints/src/async_yields_async.rs b/clippy_lints/src/async_yields_async.rs
index 013819b0da8ae..1a10db291cdea 100644
--- a/clippy_lints/src/async_yields_async.rs
+++ b/clippy_lints/src/async_yields_async.rs
@@ -1,8 +1,12 @@
 use clippy_utils::diagnostics::span_lint_hir_and_then;
-use clippy_utils::source::snippet;
+use clippy_utils::is_expr_async_block;
+use clippy_utils::source::walk_span_to_context;
+use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::implements_trait;
 use rustc_errors::Applicability;
-use rustc_hir::{Closure, ClosureKind, CoroutineDesugaring, CoroutineKind, CoroutineSource, Expr, ExprKind, QPath};
+use rustc_hir::{
+    Block, Closure, ClosureKind, CoroutineDesugaring, CoroutineKind, CoroutineSource, Expr, ExprKind, QPath,
+};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
 
@@ -87,31 +91,37 @@ impl<'tcx> LateLintPass<'tcx> for AsyncYieldsAsync {
         let expr_ty = typeck_results.expr_ty(body_expr);
 
         if implements_trait(cx, expr_ty, future_trait_def_id, &[]) {
-            let return_expr_span = match &body_expr.kind {
-                // XXXkhuey there has to be a better way.
-                ExprKind::Block(block, _) => block.expr.map(|e| e.span),
-                ExprKind::Path(QPath::Resolved(_, path)) => Some(path.span),
-                _ => None,
+            let (return_expr, return_expr_span) = match &body_expr.kind {
+                ExprKind::Block(Block { expr: Some(e), .. }, _) => (*e, e.span),
+                ExprKind::Path(QPath::Resolved(_, path)) => (body_expr, path.span),
+                _ => return,
             };
-            if let Some(return_expr_span) = return_expr_span {
-                span_lint_hir_and_then(
-                    cx,
-                    ASYNC_YIELDS_ASYNC,
-                    body_expr.hir_id,
-                    return_expr_span,
-                    "an async construct yields a type which is itself awaitable",
-                    |db| {
-                        db.span_label(body_expr.span, "outer async construct");
-                        db.span_label(return_expr_span, "awaitable value not awaited");
-                        db.span_suggestion(
-                            return_expr_span,
-                            "consider awaiting this value",
-                            format!("{}.await", snippet(cx, return_expr_span, "..")),
-                            Applicability::MaybeIncorrect,
-                        );
-                    },
-                );
+
+            let return_expr_span = walk_span_to_context(return_expr_span, expr.span.ctxt()).unwrap_or(return_expr_span);
+            let mut applicability = Applicability::MaybeIncorrect;
+            let mut return_expr_snip =
+                Sugg::hir_with_context(cx, return_expr, expr.span.ctxt(), "..", &mut applicability);
+            if !is_expr_async_block(return_expr) {
+                return_expr_snip = return_expr_snip.maybe_paren();
             }
+
+            span_lint_hir_and_then(
+                cx,
+                ASYNC_YIELDS_ASYNC,
+                body_expr.hir_id,
+                return_expr_span,
+                "an async construct yields a type which is itself awaitable",
+                |db| {
+                    db.span_label(body_expr.span, "outer async construct");
+                    db.span_label(return_expr_span, "awaitable value not awaited");
+                    db.span_suggestion(
+                        return_expr_span,
+                        "consider awaiting this value",
+                        format!("{return_expr_snip}.await"),
+                        applicability,
+                    );
+                },
+            );
         }
     }
 }
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 1e0833001cf71..771742aa43d85 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -102,9 +102,9 @@ use rustc_hir::hir_id::{HirIdMap, HirIdSet};
 use rustc_hir::intravisit::{FnKind, Visitor, walk_expr};
 use rustc_hir::{
     self as hir, Arm, BindingMode, Block, BlockCheckMode, Body, ByRef, Closure, ConstArgKind, CoroutineDesugaring,
-    CoroutineKind, Destination, Expr, ExprField, ExprKind, FnDecl, FnRetTy, GenericArg, GenericArgs, HirId, Impl,
-    ImplItem, ImplItemKind, Item, ItemKind, LangItem, LetStmt, MatchSource, Mutability, Node, OwnerId, OwnerNode,
-    Param, Pat, PatExpr, PatExprKind, PatKind, Path, PathSegment, QPath, Stmt, StmtKind, TraitFn, TraitItem,
+    CoroutineKind, CoroutineSource, Destination, Expr, ExprField, ExprKind, FnDecl, FnRetTy, GenericArg, GenericArgs,
+    HirId, Impl, ImplItem, ImplItemKind, Item, ItemKind, LangItem, LetStmt, MatchSource, Mutability, Node, OwnerId,
+    OwnerNode, Param, Pat, PatExpr, PatExprKind, PatKind, Path, PathSegment, QPath, Stmt, StmtKind, TraitFn, TraitItem,
     TraitItemKind, TraitRef, TyKind, UnOp, def, find_attr,
 };
 use rustc_lexer::{FrontmatterAllowed, TokenKind, tokenize};
@@ -3632,3 +3632,17 @@ pub fn expr_adjustment_requires_coercion(cx: &LateContext<'_>, expr: &Expr<'_>)
         )
     })
 }
+
+/// Checks if the expression is an async block (i.e., `async { ... }`).
+pub fn is_expr_async_block(expr: &Expr<'_>) -> bool {
+    matches!(
+        expr.kind,
+        ExprKind::Closure(Closure {
+            kind: hir::ClosureKind::Coroutine(CoroutineKind::Desugared(
+                CoroutineDesugaring::Async,
+                CoroutineSource::Block
+            )),
+            ..
+        })
+    )
+}
diff --git a/tests/ui/async_yields_async.fixed b/tests/ui/async_yields_async.fixed
index 93c573d30863e..bd1b31f74ee95 100644
--- a/tests/ui/async_yields_async.fixed
+++ b/tests/ui/async_yields_async.fixed
@@ -80,3 +80,42 @@ fn check_expect_suppression() {
         }
     };
 }
+
+#[allow(clippy::let_underscore_future)]
+fn issue15552() {
+    async fn bar(i: i32) {}
+
+    macro_rules! call_bar {
+        () => {
+            async { bar(5).await }
+        };
+        ($e:expr) => {
+            bar($e)
+        };
+    }
+    let x = async { call_bar!(5).await };
+    //~^ async_yields_async
+    let y = async { call_bar!().await };
+    //~^ async_yields_async
+    //~| async_yields_async
+
+    use std::future::{Future, Ready};
+    use std::ops::Add;
+    use std::pin::Pin;
+    use std::task::{Context, Poll};
+    struct CustomFutureType;
+    impl Add for CustomFutureType {
+        type Output = Self;
+        fn add(self, other: Self) -> Self {
+            self
+        }
+    }
+    impl Future for CustomFutureType {
+        type Output = ();
+        fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
+            Poll::Ready(())
+        }
+    }
+    let _ = async { (CustomFutureType + CustomFutureType).await };
+    //~^ async_yields_async
+}
diff --git a/tests/ui/async_yields_async.rs b/tests/ui/async_yields_async.rs
index 166d522e1c04c..605d2734157cf 100644
--- a/tests/ui/async_yields_async.rs
+++ b/tests/ui/async_yields_async.rs
@@ -80,3 +80,42 @@ fn check_expect_suppression() {
         }
     };
 }
+
+#[allow(clippy::let_underscore_future)]
+fn issue15552() {
+    async fn bar(i: i32) {}
+
+    macro_rules! call_bar {
+        () => {
+            async { bar(5) }
+        };
+        ($e:expr) => {
+            bar($e)
+        };
+    }
+    let x = async { call_bar!(5) };
+    //~^ async_yields_async
+    let y = async { call_bar!() };
+    //~^ async_yields_async
+    //~| async_yields_async
+
+    use std::future::{Future, Ready};
+    use std::ops::Add;
+    use std::pin::Pin;
+    use std::task::{Context, Poll};
+    struct CustomFutureType;
+    impl Add for CustomFutureType {
+        type Output = Self;
+        fn add(self, other: Self) -> Self {
+            self
+        }
+    }
+    impl Future for CustomFutureType {
+        type Output = ();
+        fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
+            Poll::Ready(())
+        }
+    }
+    let _ = async { CustomFutureType + CustomFutureType };
+    //~^ async_yields_async
+}
diff --git a/tests/ui/async_yields_async.stderr b/tests/ui/async_yields_async.stderr
index 17a35076fa3f1..3041cf6578938 100644
--- a/tests/ui/async_yields_async.stderr
+++ b/tests/ui/async_yields_async.stderr
@@ -89,5 +89,50 @@ LL | |         CustomFutureType
 LL | |     };
    | |_____- outer async construct
 
-error: aborting due to 6 previous errors
+error: an async construct yields a type which is itself awaitable
+  --> tests/ui/async_yields_async.rs:96:21
+   |
+LL |     let x = async { call_bar!(5) };
+   |                   --^^^^^^^^^^^^--
+   |                   | |
+   |                   | awaitable value not awaited
+   |                   | help: consider awaiting this value: `call_bar!(5).await`
+   |                   outer async construct
+
+error: an async construct yields a type which is itself awaitable
+  --> tests/ui/async_yields_async.rs:98:21
+   |
+LL |     let y = async { call_bar!() };
+   |                   --^^^^^^^^^^^--
+   |                   | |
+   |                   | awaitable value not awaited
+   |                   | help: consider awaiting this value: `call_bar!().await`
+   |                   outer async construct
+
+error: an async construct yields a type which is itself awaitable
+  --> tests/ui/async_yields_async.rs:90:21
+   |
+LL |             async { bar(5) }
+   |                   --^^^^^^--
+   |                   | |
+   |                   | awaitable value not awaited
+   |                   | help: consider awaiting this value: `bar(5).await`
+   |                   outer async construct
+...
+LL |     let y = async { call_bar!() };
+   |                     ----------- in this macro invocation
+   |
+   = note: this error originates in the macro `call_bar` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: an async construct yields a type which is itself awaitable
+  --> tests/ui/async_yields_async.rs:119:21
+   |
+LL |     let _ = async { CustomFutureType + CustomFutureType };
+   |                   --^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^--
+   |                   | |
+   |                   | awaitable value not awaited
+   |                   | help: consider awaiting this value: `(CustomFutureType + CustomFutureType).await`
+   |                   outer async construct
+
+error: aborting due to 10 previous errors
 

From aa49c0b8bb27700ab77fd8cb7231d18f4f6d2e97 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Mon, 25 Aug 2025 20:19:33 +0300
Subject: [PATCH 0281/1889] Normalize all types when finishing inference

The new solver does not eagerly normalize, but things after inference expect types to be normalized. rustc does the same.

Also, I'm afraid other things in r-a don't expect results of the solver to be unnormalized. We'll need to handle that.
---
 .../crates/hir-ty/src/infer/unify.rs          |  3 +++
 .../hir-ty/src/tests/regression/new_solver.rs | 26 +++++++++++++++++++
 2 files changed, 29 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
index a709aebfa9c1b..bb4782bd41942 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
@@ -621,6 +621,9 @@ impl<'a> InferenceTable<'a> {
     where
         T: HasInterner<Interner = Interner> + TypeFoldable<Interner>,
     {
+        let t = self.resolve_with_fallback(t, &|_, _, d, _| d);
+        let t = self.normalize_associated_types_in(t);
+        // Resolve again, because maybe normalization inserted infer vars.
         self.resolve_with_fallback(t, &|_, _, d, _| d)
     }
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
index 059f4ad32a53b..20190fbc04564 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
@@ -24,3 +24,29 @@ impl<'a> IntoIterator for &'a Grid {
         "#]],
     );
 }
+
+#[test]
+fn normalization() {
+    check_infer(
+        r#"
+//- minicore: iterator, iterators
+fn main() {
+    _ = [0i32].into_iter().filter_map(|_n| Some(1i32));
+}
+    "#,
+        expect![[r#"
+            10..69 '{     ...2)); }': ()
+            16..17 '_': FilterMap<IntoIter<i32, 1>, impl FnMut(i32) -> Option<i32>>
+            16..66 '_ = [0...1i32))': ()
+            20..26 '[0i32]': [i32; 1]
+            20..38 '[0i32]...iter()': IntoIter<i32, 1>
+            20..66 '[0i32]...1i32))': FilterMap<IntoIter<i32, 1>, impl FnMut(i32) -> Option<i32>>
+            21..25 '0i32': i32
+            50..65 '|_n| Some(1i32)': impl FnMut(i32) -> Option<i32>
+            51..53 '_n': i32
+            55..59 'Some': fn Some<i32>(i32) -> Option<i32>
+            55..65 'Some(1i32)': Option<i32>
+            60..64 '1i32': i32
+        "#]],
+    );
+}

From 4b5bb18c57270a5b823235397067ae82c64bf1f1 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Mon, 25 Aug 2025 20:56:45 +0300
Subject: [PATCH 0282/1889] Don't map Chalk's `Normalize` to next solver's
 `NormalizesTo`

`NormalizesTo` is a private predicate that should not be used outside the solver. For normalization, rustc uses `AliasRelate`, so replace with that.
---
 .../crates/hir-ty/src/next_solver/mapping.rs  | 22 ++++++++++++++-----
 1 file changed, 16 insertions(+), 6 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
index cad51fd85f55a..8f6296b145409 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
@@ -808,14 +808,24 @@ impl<'db> ChalkToNextSolver<'db, PredicateKind<'db>> for chalk_ir::DomainGoal<In
                     _ => unimplemented!(),
                 };
                 let args: GenericArgs<'db> = proj_ty.substitution.to_nextsolver(interner);
-                let alias = rustc_type_ir::AliasTerm::new(
+                let alias = Ty::new(
                     interner,
-                    from_assoc_type_id(proj_ty.associated_ty_id).into(),
-                    args,
-                );
+                    rustc_type_ir::TyKind::Alias(
+                        rustc_type_ir::AliasTyKind::Projection,
+                        rustc_type_ir::AliasTy::new(
+                            interner,
+                            from_assoc_type_id(proj_ty.associated_ty_id).into(),
+                            args,
+                        ),
+                    ),
+                )
+                .into();
                 let term = normalize.ty.to_nextsolver(interner).into();
-                let normalizes_to = rustc_type_ir::NormalizesTo { alias, term };
-                PredicateKind::NormalizesTo(normalizes_to)
+                PredicateKind::AliasRelate(
+                    alias,
+                    term,
+                    rustc_type_ir::AliasRelationDirection::Equate,
+                )
             }
             chalk_ir::DomainGoal::WellFormed(well_formed) => {
                 let term = match well_formed {

From 169eb87d6088d0c63884b9faa0287ee474a4101b Mon Sep 17 00:00:00 2001
From: Alexey Semenyuk <alexsemenyuk88@gmail.com>
Date: Mon, 25 Aug 2025 16:06:32 +0500
Subject: [PATCH 0283/1889] Remove expect collapsible_span_lint_calls from
 span_lint_and_then

---
 clippy_lints/src/uninit_vec.rs | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/clippy_lints/src/uninit_vec.rs b/clippy_lints/src/uninit_vec.rs
index cee4a53f03cbe..51116b5eba9e1 100644
--- a/clippy_lints/src/uninit_vec.rs
+++ b/clippy_lints/src/uninit_vec.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::higher::{VecInitKind, get_vec_init_kind};
 use clippy_utils::ty::{is_type_diagnostic_item, is_uninit_value_valid_for_ty};
 use clippy_utils::{SpanlessEq, is_integer_literal, is_lint_allowed, path_to_local_id, peel_hir_expr_while, sym};
@@ -95,16 +95,13 @@ fn handle_uninit_vec_pair<'tcx>(
 
             // Check T of Vec<T>
             if !is_uninit_value_valid_for_ty(cx, args.type_at(0)) {
-                // FIXME: #7698, false positive of the internal lints
-                #[expect(clippy::collapsible_span_lint_calls)]
-                span_lint_and_then(
+                span_lint_and_help(
                     cx,
                     UNINIT_VEC,
                     vec![call_span, maybe_init_or_reserve.span],
                     "calling `set_len()` immediately after reserving a buffer creates uninitialized values",
-                    |diag| {
-                        diag.help("initialize the buffer or wrap the content in `MaybeUninit`");
-                    },
+                    None,
+                    "initialize the buffer or wrap the content in `MaybeUninit`",
                 );
             }
         } else {

From 54ced9fd1c9a25f00498efd04c7be1e6893e02a9 Mon Sep 17 00:00:00 2001
From: yanglsh <yanglsh@shanghaitech.edu.cn>
Date: Tue, 26 Aug 2025 06:11:54 +0800
Subject: [PATCH 0284/1889] `doc_markdown`: add InfiniBand and RoCE to
 whitelist

---
 book/src/lint_configuration.md  |  2 +-
 clippy_config/src/conf.rs       |  1 +
 tests/ui/doc/doc-fixable.fixed  |  1 +
 tests/ui/doc/doc-fixable.rs     |  1 +
 tests/ui/doc/doc-fixable.stderr | 44 ++++++++++++++++-----------------
 5 files changed, 26 insertions(+), 23 deletions(-)

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 87405f28a6565..d51467cbfae5a 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -555,7 +555,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:** `["KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "MHz", "GHz", "THz", "AccessKit", "CoAP", "CoreFoundation", "CoreGraphics", "CoreText", "DevOps", "Direct2D", "Direct3D", "DirectWrite", "DirectX", "ECMAScript", "GPLv2", "GPLv3", "GitHub", "GitLab", "IPv4", "IPv6", "ClojureScript", "CoffeeScript", "JavaScript", "PostScript", "PureScript", "TypeScript", "PowerPC", "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", "NixOS", "TeX", "LaTeX", "BibTeX", "BibLaTeX", "MinGW", "CamelCase"]`
+**Default Value:** `["KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "MHz", "GHz", "THz", "AccessKit", "CoAP", "CoreFoundation", "CoreGraphics", "CoreText", "DevOps", "Direct2D", "Direct3D", "DirectWrite", "DirectX", "ECMAScript", "GPLv2", "GPLv3", "GitHub", "GitLab", "IPv4", "IPv6", "InfiniBand", "RoCE", "ClojureScript", "CoffeeScript", "JavaScript", "PostScript", "PureScript", "TypeScript", "PowerPC", "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", "NixOS", "TeX", "LaTeX", "BibTeX", "BibLaTeX", "MinGW", "CamelCase"]`
 
 ---
 **Affected lints:**
diff --git a/clippy_config/src/conf.rs b/clippy_config/src/conf.rs
index 8dd27b2265cb4..365d664d75fef 100644
--- a/clippy_config/src/conf.rs
+++ b/clippy_config/src/conf.rs
@@ -33,6 +33,7 @@ const DEFAULT_DOC_VALID_IDENTS: &[&str] = &[
     "GPLv2", "GPLv3",
     "GitHub", "GitLab",
     "IPv4", "IPv6",
+    "InfiniBand", "RoCE",
     "ClojureScript", "CoffeeScript", "JavaScript", "PostScript", "PureScript", "TypeScript",
     "PowerPC", "WebAssembly",
     "NaN", "NaNs",
diff --git a/tests/ui/doc/doc-fixable.fixed b/tests/ui/doc/doc-fixable.fixed
index 423a73734daab..46695dc929ab7 100644
--- a/tests/ui/doc/doc-fixable.fixed
+++ b/tests/ui/doc/doc-fixable.fixed
@@ -73,6 +73,7 @@ fn test_units() {
 /// GPLv2 GPLv3
 /// GitHub GitLab
 /// IPv4 IPv6
+/// InfiniBand RoCE
 /// ClojureScript CoffeeScript JavaScript PostScript PureScript TypeScript
 /// PowerPC WebAssembly
 /// NaN NaNs
diff --git a/tests/ui/doc/doc-fixable.rs b/tests/ui/doc/doc-fixable.rs
index 8deffb4210e43..4082fa5b56f4b 100644
--- a/tests/ui/doc/doc-fixable.rs
+++ b/tests/ui/doc/doc-fixable.rs
@@ -73,6 +73,7 @@ fn test_units() {
 /// GPLv2 GPLv3
 /// GitHub GitLab
 /// IPv4 IPv6
+/// InfiniBand RoCE
 /// ClojureScript CoffeeScript JavaScript PostScript PureScript TypeScript
 /// PowerPC WebAssembly
 /// NaN NaNs
diff --git a/tests/ui/doc/doc-fixable.stderr b/tests/ui/doc/doc-fixable.stderr
index 98c26e6bec2eb..2a94a8f316587 100644
--- a/tests/ui/doc/doc-fixable.stderr
+++ b/tests/ui/doc/doc-fixable.stderr
@@ -145,7 +145,7 @@ LL + /// `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:90:5
+  --> tests/ui/doc/doc-fixable.rs:91:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -157,7 +157,7 @@ LL + /// `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:108:5
+  --> tests/ui/doc/doc-fixable.rs:109:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -169,7 +169,7 @@ LL + /// `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:117:8
+  --> tests/ui/doc/doc-fixable.rs:118:8
    |
 LL | /// ## CamelCaseThing
    |        ^^^^^^^^^^^^^^
@@ -181,7 +181,7 @@ LL + /// ## `CamelCaseThing`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:121:7
+  --> tests/ui/doc/doc-fixable.rs:122:7
    |
 LL | /// # CamelCaseThing
    |       ^^^^^^^^^^^^^^
@@ -193,7 +193,7 @@ LL + /// # `CamelCaseThing`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:124:22
+  --> tests/ui/doc/doc-fixable.rs:125:22
    |
 LL | /// Not a title #897 CamelCaseThing
    |                      ^^^^^^^^^^^^^^
@@ -205,7 +205,7 @@ LL + /// Not a title #897 `CamelCaseThing`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:126:5
+  --> tests/ui/doc/doc-fixable.rs:127:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -217,7 +217,7 @@ LL + /// `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:134:5
+  --> tests/ui/doc/doc-fixable.rs:135:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -229,7 +229,7 @@ LL + /// `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:148:5
+  --> tests/ui/doc/doc-fixable.rs:149:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -241,7 +241,7 @@ LL + /// `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:160:43
+  --> tests/ui/doc/doc-fixable.rs:161:43
    |
 LL | /** E.g., serialization of an empty list: FooBar
    |                                           ^^^^^^
@@ -253,7 +253,7 @@ LL + /** E.g., serialization of an empty list: `FooBar`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:165:5
+  --> tests/ui/doc/doc-fixable.rs:166:5
    |
 LL | And BarQuz too.
    |     ^^^^^^
@@ -265,7 +265,7 @@ LL + And `BarQuz` too.
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:166:1
+  --> tests/ui/doc/doc-fixable.rs:167:1
    |
 LL | be_sure_we_got_to_the_end_of_it
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -277,7 +277,7 @@ LL + `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:174:43
+  --> tests/ui/doc/doc-fixable.rs:175:43
    |
 LL | /** E.g., serialization of an empty list: FooBar
    |                                           ^^^^^^
@@ -289,7 +289,7 @@ LL + /** E.g., serialization of an empty list: `FooBar`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:179:5
+  --> tests/ui/doc/doc-fixable.rs:180:5
    |
 LL | And BarQuz too.
    |     ^^^^^^
@@ -301,7 +301,7 @@ LL + And `BarQuz` too.
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:180:1
+  --> tests/ui/doc/doc-fixable.rs:181:1
    |
 LL | be_sure_we_got_to_the_end_of_it
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -313,7 +313,7 @@ LL + `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:194:5
+  --> tests/ui/doc/doc-fixable.rs:195:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -325,7 +325,7 @@ LL + /// `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:214:22
+  --> tests/ui/doc/doc-fixable.rs:215:22
    |
 LL | /// An iterator over mycrate::Collection's values.
    |                      ^^^^^^^^^^^^^^^^^^^
@@ -337,7 +337,7 @@ LL + /// An iterator over `mycrate::Collection`'s values.
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:239:34
+  --> tests/ui/doc/doc-fixable.rs:240:34
    |
 LL | /// Foo \[bar\] \[baz\] \[qux\]. DocMarkdownLint
    |                                  ^^^^^^^^^^^^^^^
@@ -349,7 +349,7 @@ LL + /// Foo \[bar\] \[baz\] \[qux\]. `DocMarkdownLint`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:263:22
+  --> tests/ui/doc/doc-fixable.rs:264:22
    |
 LL | /// There is no try (do() or do_not()).
    |                      ^^^^
@@ -361,7 +361,7 @@ LL + /// There is no try (`do()` or do_not()).
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:263:30
+  --> tests/ui/doc/doc-fixable.rs:264:30
    |
 LL | /// There is no try (do() or do_not()).
    |                              ^^^^^^^^
@@ -373,7 +373,7 @@ LL + /// There is no try (do() or `do_not()`).
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:268:5
+  --> tests/ui/doc/doc-fixable.rs:269:5
    |
 LL | /// ABes
    |     ^^^^
@@ -385,7 +385,7 @@ LL + /// `ABes`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:275:9
+  --> tests/ui/doc/doc-fixable.rs:276:9
    |
 LL |     /// foo()
    |         ^^^^^
@@ -397,7 +397,7 @@ LL +     /// `foo()`
    |
 
 error: you should put bare URLs between `<`/`>` or make a proper Markdown link
-  --> tests/ui/doc/doc-fixable.rs:280:5
+  --> tests/ui/doc/doc-fixable.rs:281:5
    |
 LL | /// https://github.com/rust-lang/rust-clippy/pull/12836
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `<https://github.com/rust-lang/rust-clippy/pull/12836>`

From 1de71c8086e1a2aac8da1eed15e1152e8dad7c0f Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Fri, 22 Aug 2025 16:57:41 -0700
Subject: [PATCH 0285/1889] ptr_cast_constness: avoid suggesting unresolvable
 method call

---
 clippy_lints/src/casts/ptr_cast_constness.rs | 13 +++++++++++--
 tests/ui/ptr_cast_constness.fixed            |  6 ++++++
 tests/ui/ptr_cast_constness.rs               |  6 ++++++
 tests/ui/ptr_cast_constness.stderr           |  8 +++++++-
 4 files changed, 30 insertions(+), 3 deletions(-)

diff --git a/clippy_lints/src/casts/ptr_cast_constness.rs b/clippy_lints/src/casts/ptr_cast_constness.rs
index 5ab3991525199..c0f13f5e57823 100644
--- a/clippy_lints/src/casts/ptr_cast_constness.rs
+++ b/clippy_lints/src/casts/ptr_cast_constness.rs
@@ -4,7 +4,7 @@ use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{std_or_core, sym};
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, QPath};
+use rustc_hir::{self as hir, Expr, ExprKind, QPath};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty, TypeVisitableExt};
 
@@ -51,7 +51,16 @@ pub(super) fn check<'tcx>(
 
         if msrv.meets(cx, msrvs::POINTER_CAST_CONSTNESS) {
             let mut app = Applicability::MachineApplicable;
-            let sugg = Sugg::hir_with_context(cx, cast_from_expr, expr.span.ctxt(), "_", &mut app);
+            let sugg = if let ExprKind::Cast(nested_from, nested_hir_ty) = cast_from_expr.kind
+                && let hir::TyKind::Ptr(ptr_ty) = nested_hir_ty.kind
+                && let hir::TyKind::Infer(()) = ptr_ty.ty.kind
+            {
+                // `(foo as *const _).cast_mut()` fails method name resolution
+                // avoid this by `as`-ing the full type
+                Sugg::hir_with_context(cx, nested_from, expr.span.ctxt(), "_", &mut app).as_ty(cast_from)
+            } else {
+                Sugg::hir_with_context(cx, cast_from_expr, expr.span.ctxt(), "_", &mut app)
+            };
             let constness = to_mutbl.ptr_str();
 
             span_lint_and_sugg(
diff --git a/tests/ui/ptr_cast_constness.fixed b/tests/ui/ptr_cast_constness.fixed
index 79bfae1f7ebb4..cf57de53d9f3d 100644
--- a/tests/ui/ptr_cast_constness.fixed
+++ b/tests/ui/ptr_cast_constness.fixed
@@ -106,3 +106,9 @@ fn issue14621() {
     let _ = std::ptr::addr_of_mut!(local).cast_const();
     //~^ ptr_cast_constness
 }
+
+fn issue11317() {
+    let r = &0_u32;
+    let _ptr: *mut u32 = (r as *const u32).cast_mut();
+    //~^ ptr_cast_constness
+}
diff --git a/tests/ui/ptr_cast_constness.rs b/tests/ui/ptr_cast_constness.rs
index f6590dabd5b84..ea53a0fa8c50f 100644
--- a/tests/ui/ptr_cast_constness.rs
+++ b/tests/ui/ptr_cast_constness.rs
@@ -106,3 +106,9 @@ fn issue14621() {
     let _ = std::ptr::addr_of_mut!(local) as *const _;
     //~^ ptr_cast_constness
 }
+
+fn issue11317() {
+    let r = &0_u32;
+    let _ptr: *mut u32 = r as *const _ as *mut _;
+    //~^ ptr_cast_constness
+}
diff --git a/tests/ui/ptr_cast_constness.stderr b/tests/ui/ptr_cast_constness.stderr
index 0b1644168ff51..4adb5cc5ad7fe 100644
--- a/tests/ui/ptr_cast_constness.stderr
+++ b/tests/ui/ptr_cast_constness.stderr
@@ -89,5 +89,11 @@ error: `as` casting between raw pointers while changing only its constness
 LL |     let _ = std::ptr::addr_of_mut!(local) as *const _;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast_const`, a safer alternative: `std::ptr::addr_of_mut!(local).cast_const()`
 
-error: aborting due to 14 previous errors
+error: `as` casting between raw pointers while changing only its constness
+  --> tests/ui/ptr_cast_constness.rs:112:26
+   |
+LL |     let _ptr: *mut u32 = r as *const _ as *mut _;
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast_mut`, a safer alternative: `(r as *const u32).cast_mut()`
+
+error: aborting due to 15 previous errors
 

From 9fd57df6397b0e2b0cd4db32884ed5e5443c7906 Mon Sep 17 00:00:00 2001
From: dianne <diannes.gm@gmail.com>
Date: Tue, 12 Aug 2025 23:55:29 -0700
Subject: [PATCH 0286/1889] add tests, some with incorrect lifetime extension
 behavior

---
 .../format-args-temporary-scopes.e2024.stderr |  15 +++
 .../borrowck/format-args-temporary-scopes.rs  |  20 +++
 .../ui/drop/super-let-tail-expr-drop-order.rs | 122 ++++++++++++++++++
 3 files changed, 157 insertions(+)
 create mode 100644 tests/ui/borrowck/format-args-temporary-scopes.e2024.stderr
 create mode 100644 tests/ui/borrowck/format-args-temporary-scopes.rs
 create mode 100644 tests/ui/drop/super-let-tail-expr-drop-order.rs

diff --git a/tests/ui/borrowck/format-args-temporary-scopes.e2024.stderr b/tests/ui/borrowck/format-args-temporary-scopes.e2024.stderr
new file mode 100644
index 0000000000000..923c929a68d60
--- /dev/null
+++ b/tests/ui/borrowck/format-args-temporary-scopes.e2024.stderr
@@ -0,0 +1,15 @@
+error[E0716]: temporary value dropped while borrowed
+  --> $DIR/format-args-temporary-scopes.rs:13:25
+   |
+LL |     println!("{:?}", { &temp() });
+   |                      ---^^^^^---
+   |                      |  |    |
+   |                      |  |    temporary value is freed at the end of this statement
+   |                      |  creates a temporary value which is freed while still in use
+   |                      borrow later used here
+   |
+   = note: consider using a `let` binding to create a longer lived value
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/borrowck/format-args-temporary-scopes.rs b/tests/ui/borrowck/format-args-temporary-scopes.rs
new file mode 100644
index 0000000000000..e6223d7c55183
--- /dev/null
+++ b/tests/ui/borrowck/format-args-temporary-scopes.rs
@@ -0,0 +1,20 @@
+//! Test for #145784 as it relates to format arguments: arguments to macros such as `println!`
+//! should obey normal temporary scoping rules.
+//@ revisions: e2021 e2024
+//@ [e2021] check-pass
+//@ [e2021] edition: 2021
+//@ [e2024] edition: 2024
+
+fn temp() {}
+
+fn main() {
+    // In Rust 2024, block tail expressions are temporary scopes, so the result of `temp()` is
+    // dropped after evaluating `&temp()`.
+    println!("{:?}", { &temp() });
+    //[e2024]~^ ERROR: temporary value dropped while borrowed [E0716]
+
+    // In Rust 1.89, `format_args!` extended the lifetime of all extending expressions in its
+    // arguments when provided with two or more arguments. This caused the result of `temp()` to
+    // outlive the result of the block, making this compile.
+    println!("{:?}{:?}", { &temp() }, ());
+}
diff --git a/tests/ui/drop/super-let-tail-expr-drop-order.rs b/tests/ui/drop/super-let-tail-expr-drop-order.rs
new file mode 100644
index 0000000000000..5aa17bba21f1b
--- /dev/null
+++ b/tests/ui/drop/super-let-tail-expr-drop-order.rs
@@ -0,0 +1,122 @@
+//! Test for #145784: the argument to `pin!` should be treated as an extending expression if and
+//! only if the whole `pin!` invocation is an extending expression. Likewise, since `pin!` is
+//! implemented in terms of `super let`, test the same for `super let` initializers. Since the
+//! argument to `pin!` and the initializer of `super let` are not temporary drop scopes, this only
+//! affects lifetimes in two cases:
+//!
+//! - Block tail expressions in Rust 2024, which are both extending expressions and temporary drop
+//! scopes; treating them as extending expressions within a non-extending `pin!` resulted in borrow
+//! expression operands living past the end of the block.
+//!
+//! - Nested `super let` statements, which can have their binding and temporary lifetimes extended
+//! when the block they're in is an extending expression.
+//!
+//! For more information on extending expressions, see
+//! https://doc.rust-lang.org/reference/destructors.html#extending-based-on-expressions
+//!
+//! For tests that `super let` initializers aren't temporary drop scopes, and tests for
+//! lifetime-extended `super let`, see tests/ui/borrowck/super-let-lifetime-and-drop.rs
+//@ run-pass
+//@ revisions: e2021 e2024
+//@ [e2021] edition: 2021
+//@ [e2024] edition: 2024
+
+#![feature(super_let)]
+
+use std::cell::RefCell;
+use std::pin::pin;
+
+fn main() {
+    // Test block arguments to `pin!` in non-extending expressions.
+    // In Rust 2021, block tail expressions aren't temporary drop scopes, so their temporaries
+    // should outlive the `pin!` invocation.
+    // In Rust 2024, block tail expressions are temporary drop scopes, so their temporaries should
+    // be dropped after evaluating the tail expression within the `pin!` invocation.
+    // By nesting two `pin!` calls, this ensures non-extended `pin!` doesn't extend an inner `pin!`.
+    assert_drop_order(1..=3, |o| {
+        #[cfg(e2021)]
+        (
+            pin!((
+                pin!({ &o.log(3) as *const LogDrop<'_> }),
+                drop(o.log(1)),
+            )),
+            drop(o.log(2)),
+        );
+        #[cfg(e2024)]
+        (
+            pin!((
+                pin!({ &o.log(3) as *const LogDrop<'_> }),
+                drop(o.log(1)),
+            )),
+            drop(o.log(2)),
+        );
+    });
+
+    // The same holds for `super let` initializers in non-extending expressions.
+    assert_drop_order(1..=4, |o| {
+        #[cfg(e2021)]
+        (
+            {
+                super let _ = {
+                    super let _ = { &o.log(4) as *const LogDrop<'_> };
+                    drop(o.log(1))
+                };
+                drop(o.log(2))
+            },
+            drop(o.log(3)),
+        );
+        #[cfg(e2024)]
+        (
+            {
+                super let _ = {
+                    super let _ = { &o.log(4) as *const LogDrop<'_> };
+                    drop(o.log(1))
+                };
+                drop(o.log(2))
+            },
+            drop(o.log(3)),
+        );
+    });
+
+    // Within an extending expression, the argument to `pin!` is also an extending expression,
+    // allowing borrow operands in block tail expressions to have extended lifetimes.
+    assert_drop_order(1..=2, |o| {
+        let _ = pin!({ &o.log(2) as *const LogDrop<'_> });
+        drop(o.log(1));
+    });
+
+    // The same holds for `super let` initializers in extending expressions.
+    assert_drop_order(1..=2, |o| {
+        let _ =  { super let _ = { &o.log(2) as *const LogDrop<'_> }; };
+        drop(o.log(1));
+    });
+}
+
+// # Test scaffolding...
+
+struct DropOrder(RefCell<Vec<u64>>);
+struct LogDrop<'o>(&'o DropOrder, u64);
+
+impl DropOrder {
+    fn log(&self, n: u64) -> LogDrop<'_> {
+        LogDrop(self, n)
+    }
+}
+
+impl<'o> Drop for LogDrop<'o> {
+    fn drop(&mut self) {
+        self.0.0.borrow_mut().push(self.1);
+    }
+}
+
+#[track_caller]
+fn assert_drop_order(
+    ex: impl IntoIterator<Item = u64>,
+    f: impl Fn(&DropOrder),
+) {
+    let order = DropOrder(RefCell::new(Vec::new()));
+    f(&order);
+    let order = order.0.into_inner();
+    let expected: Vec<u64> = ex.into_iter().collect();
+    assert_eq!(order, expected);
+}

From cfc9b8fad0629e3cef6d958bd4cc9f3fe135ce43 Mon Sep 17 00:00:00 2001
From: Boot0x7c00 <irelaxcn@outlook.com>
Date: Tue, 26 Aug 2025 03:15:08 +0000
Subject: [PATCH 0287/1889] using full path in suggestion of

---
 clippy_lints/src/methods/clone_on_ref_ptr.rs |  7 ++++---
 tests/ui/unnecessary_clone.stderr            | 12 ++++++------
 2 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/clippy_lints/src/methods/clone_on_ref_ptr.rs b/clippy_lints/src/methods/clone_on_ref_ptr.rs
index 96e2de0dc1cbd..65583c6a9811e 100644
--- a/clippy_lints/src/methods/clone_on_ref_ptr.rs
+++ b/clippy_lints/src/methods/clone_on_ref_ptr.rs
@@ -24,9 +24,10 @@ pub(super) fn check(
         && let Some(name) = cx.tcx.get_diagnostic_name(adt.did())
     {
         let caller_type = match name {
-            sym::Rc => "Rc",
-            sym::Arc => "Arc",
-            sym::RcWeak | sym::ArcWeak => "Weak",
+            sym::Rc => "std::rc::Rc",
+            sym::Arc => "std::sync::Arc",
+            sym::RcWeak => "std::rc::Weak",
+            sym::ArcWeak => "std::sync::Weak",
             _ => return,
         };
         span_lint_and_then(
diff --git a/tests/ui/unnecessary_clone.stderr b/tests/ui/unnecessary_clone.stderr
index a4fdf09cd5dcb..17518e123d12e 100644
--- a/tests/ui/unnecessary_clone.stderr
+++ b/tests/ui/unnecessary_clone.stderr
@@ -2,7 +2,7 @@ error: using `.clone()` on a ref-counted pointer
   --> tests/ui/unnecessary_clone.rs:23:5
    |
 LL |     rc.clone();
-   |     ^^^^^^^^^^ help: try: `Rc::<bool>::clone(&rc)`
+   |     ^^^^^^^^^^ help: try: `std::rc::Rc::<bool>::clone(&rc)`
    |
    = note: `-D clippy::clone-on-ref-ptr` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::clone_on_ref_ptr)]`
@@ -11,25 +11,25 @@ error: using `.clone()` on a ref-counted pointer
   --> tests/ui/unnecessary_clone.rs:28:5
    |
 LL |     arc.clone();
-   |     ^^^^^^^^^^^ help: try: `Arc::<bool>::clone(&arc)`
+   |     ^^^^^^^^^^^ help: try: `std::sync::Arc::<bool>::clone(&arc)`
 
 error: using `.clone()` on a ref-counted pointer
   --> tests/ui/unnecessary_clone.rs:33:5
    |
 LL |     rcweak.clone();
-   |     ^^^^^^^^^^^^^^ help: try: `Weak::<bool>::clone(&rcweak)`
+   |     ^^^^^^^^^^^^^^ help: try: `std::rc::Weak::<bool>::clone(&rcweak)`
 
 error: using `.clone()` on a ref-counted pointer
   --> tests/ui/unnecessary_clone.rs:38:5
    |
 LL |     arc_weak.clone();
-   |     ^^^^^^^^^^^^^^^^ help: try: `Weak::<bool>::clone(&arc_weak)`
+   |     ^^^^^^^^^^^^^^^^ help: try: `std::sync::Weak::<bool>::clone(&arc_weak)`
 
 error: using `.clone()` on a ref-counted pointer
   --> tests/ui/unnecessary_clone.rs:44:33
    |
 LL |     let _: Arc<dyn SomeTrait> = x.clone();
-   |                                 ^^^^^^^^^ help: try: `Arc::<SomeImpl>::clone(&x)`
+   |                                 ^^^^^^^^^ help: try: `std::sync::Arc::<SomeImpl>::clone(&x)`
 
 error: using `clone` on type `T` which implements the `Copy` trait
   --> tests/ui/unnecessary_clone.rs:49:5
@@ -56,7 +56,7 @@ error: using `.clone()` on a ref-counted pointer
   --> tests/ui/unnecessary_clone.rs:108:14
    |
 LL |         Some(try_opt!(Some(rc)).clone())
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Rc::<u8>::clone(&try_opt!(Some(rc)))`
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::rc::Rc::<u8>::clone(&try_opt!(Some(rc)))`
 
 error: aborting due to 9 previous errors
 

From 4996f53d8d770e8d481d5a59729dd163c5cfae32 Mon Sep 17 00:00:00 2001
From: Ali Nazzal <ali90h7@pm.me>
Date: Tue, 26 Aug 2025 09:35:08 +0300
Subject: [PATCH 0288/1889] stabilization_guide: fix macro name and syntax in
 gating example

---
 src/doc/rustc-dev-guide/src/stabilization_guide.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/src/stabilization_guide.md b/src/doc/rustc-dev-guide/src/stabilization_guide.md
index e399930fc523d..7b9e1eb5629b4 100644
--- a/src/doc/rustc-dev-guide/src/stabilization_guide.md
+++ b/src/doc/rustc-dev-guide/src/stabilization_guide.md
@@ -82,7 +82,7 @@ Most importantly, remove the code which flags an error if the feature-gate is no
 gate_all!(pub_restricted, "`pub(restricted)` syntax is experimental");
 ```
 
-This `gate_feature_post!` macro prints an error if the `pub_restricted` feature is not enabled. It is not needed now that `#[pub_restricted]` is stable.
+The `gate_all!` macro reports an error if the `pub_restricted` feature is not enabled. It is not needed now that `pub(restricted)` is stable.
 
 For more subtle features, you may find code like this:
 

From 79f3ae4b724fe531fb17f440dcca47ccb4e95b09 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Mon, 25 Aug 2025 18:52:57 +0200
Subject: [PATCH 0289/1889] add a flag to codegen fn attrs for foreign items

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

diff --git a/clippy_lints/src/missing_inline.rs b/clippy_lints/src/missing_inline.rs
index b16924babd1c5..d02952eb48702 100644
--- a/clippy_lints/src/missing_inline.rs
+++ b/clippy_lints/src/missing_inline.rs
@@ -190,5 +190,5 @@ impl<'tcx> LateLintPass<'tcx> for MissingInline {
 /// and a rustc warning would be triggered, see #15301
 fn fn_is_externally_exported(cx: &LateContext<'_>, def_id: DefId) -> bool {
     let attrs = cx.tcx.codegen_fn_attrs(def_id);
-    attrs.contains_extern_indicator(cx.tcx, def_id)
+    attrs.contains_extern_indicator()
 }

From 2521a90809e10b5065fce3dc42fe79490120b956 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Tue, 26 Aug 2025 19:28:08 +0800
Subject: [PATCH 0290/1889] Remove myself from adhoc_group

---
 src/doc/rustc-dev-guide/triagebot.toml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/triagebot.toml b/src/doc/rustc-dev-guide/triagebot.toml
index 3ac5d57a52b00..4a88523915209 100644
--- a/src/doc/rustc-dev-guide/triagebot.toml
+++ b/src/doc/rustc-dev-guide/triagebot.toml
@@ -90,7 +90,6 @@ does not need reviews. You can request a review using `r? rustc-dev-guide` or \
 [assign.adhoc_groups]
 rustc-dev-guide = [
     "@BoxyUwU",
-    "@jieyouxu",
     "@jyn514",
     "@tshepang",
 ]

From a55391ce26fc7582f899975cf8ad2eaf7f6f5f36 Mon Sep 17 00:00:00 2001
From: Daniel Szoke <7881302+szokeasaurusrex@users.noreply.github.com>
Date: Tue, 26 Aug 2025 14:22:16 +0200
Subject: [PATCH 0291/1889] docs(cognitive_complexity): Correct lint group

The docs say this lint is included in `nursery`, but it is now in `restriction`.
---
 clippy_lints/src/cognitive_complexity.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/clippy_lints/src/cognitive_complexity.rs b/clippy_lints/src/cognitive_complexity.rs
index 8f95c63a854f5..7646aa48b7726 100644
--- a/clippy_lints/src/cognitive_complexity.rs
+++ b/clippy_lints/src/cognitive_complexity.rs
@@ -23,8 +23,8 @@ declare_clippy_lint! {
     ///
     /// ### Known problems
     /// The true Cognitive Complexity of a method is not something we can
-    /// calculate using modern technology. This lint has been left in the
-    /// `nursery` so as to not mislead users into using this lint as a
+    /// calculate using modern technology. This lint has been left in
+    /// `restriction` so as to not mislead users into using this lint as a
     /// measurement tool.
     ///
     /// For more detailed information, see [rust-clippy#3793](https://github.com/rust-lang/rust-clippy/issues/3793)

From 5fb947f650ef123ab91bb3456161f50f481adf9b Mon Sep 17 00:00:00 2001
From: Mara Bos <m-ou.se@m-ou.se>
Date: Tue, 26 Aug 2025 14:45:16 +0200
Subject: [PATCH 0292/1889] Add test.

---
 library/coretests/tests/fmt/mod.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/library/coretests/tests/fmt/mod.rs b/library/coretests/tests/fmt/mod.rs
index 16f116d25901c..11de632fb70c7 100644
--- a/library/coretests/tests/fmt/mod.rs
+++ b/library/coretests/tests/fmt/mod.rs
@@ -12,6 +12,12 @@ fn test_lifetime() {
     let a = format_args!("hello {a} {a:?}");
     assert_eq!(a.to_string(), "hello hello hello hello hello hello hello");
 
+    // Check that temporaries as arguments are extended.
+    let b = format_args!("{}", String::new());
+    let c = format_args!("{}{}", String::new(), String::new());
+    assert_eq!(b.to_string(), "");
+    assert_eq!(c.to_string(), "");
+
     // Without arguments, it should also work in consts.
     const A: std::fmt::Arguments<'static> = format_args!("hello");
     assert_eq!(A.to_string(), "hello");

From aa9c8ceb73c88674a792719dee8bfbcbee22a360 Mon Sep 17 00:00:00 2001
From: Mara Bos <m-ou.se@m-ou.se>
Date: Tue, 26 Aug 2025 14:44:41 +0200
Subject: [PATCH 0293/1889] Remove 1-argument special case from format_args!().

The argument needs to be lifetime-extended, so this special case isn't
actually perfectly equivalent to the general case.
---
 compiler/rustc_ast_lowering/src/format.rs | 20 --------------------
 1 file changed, 20 deletions(-)

diff --git a/compiler/rustc_ast_lowering/src/format.rs b/compiler/rustc_ast_lowering/src/format.rs
index ec9d26eb33f48..2871430030c45 100644
--- a/compiler/rustc_ast_lowering/src/format.rs
+++ b/compiler/rustc_ast_lowering/src/format.rs
@@ -487,26 +487,6 @@ fn expand_format_args<'hir>(
         // Generate:
         //     []
         (vec![], ctx.arena.alloc(ctx.expr(macsp, hir::ExprKind::Array(&[]))))
-    } else if argmap.len() == 1 && arguments.len() == 1 {
-        // Only one argument, so we don't need to make the `args` tuple.
-        //
-        // Generate:
-        //     super let args = [<core::fmt::Argument>::new_display(&arg)];
-        let args = ctx.arena.alloc_from_iter(argmap.iter().map(
-            |(&(arg_index, ty), &placeholder_span)| {
-                let arg = &arguments[arg_index];
-                let placeholder_span =
-                    placeholder_span.unwrap_or(arg.expr.span).with_ctxt(macsp.ctxt());
-                let arg = ctx.lower_expr(&arg.expr);
-                let ref_arg = ctx.arena.alloc(ctx.expr_ref(arg.span.with_ctxt(macsp.ctxt()), arg));
-                make_argument(ctx, placeholder_span, ref_arg, ty)
-            },
-        ));
-        let args = ctx.arena.alloc(ctx.expr(macsp, hir::ExprKind::Array(args)));
-        let args_ident = Ident::new(sym::args, macsp);
-        let (args_pat, args_hir_id) = ctx.pat_ident(macsp, args_ident);
-        let let_statement = ctx.stmt_super_let_pat(macsp, args_pat, Some(args));
-        (vec![let_statement], ctx.arena.alloc(ctx.expr_ident_mut(macsp, args_ident, args_hir_id)))
     } else {
         // Generate:
         //     super let args = (&arg0, &arg1, &…);

From bc13565de8a16c9ba0c0da51787dc60d254c6dfa Mon Sep 17 00:00:00 2001
From: Mara Bos <m-ou.se@m-ou.se>
Date: Tue, 26 Aug 2025 14:46:03 +0200
Subject: [PATCH 0294/1889] Update tests.

---
 tests/coverage/issue-83601.cov-map            |  34 ++---
 tests/coverage/issue-84561.cov-map            | 136 +++++++++---------
 ...745-avoid-expr-from-macro-expansion.stderr |   6 +-
 tests/ui/issues/issue-27592.stderr            |  12 +-
 tests/ui/suggestions/issue-97760.stderr       |   7 +-
 tests/ui/unpretty/exhaustive.hir.stdout       |   3 +-
 .../ui/unpretty/flattened-format-args.stdout  |   3 +-
 7 files changed, 96 insertions(+), 105 deletions(-)

diff --git a/tests/coverage/issue-83601.cov-map b/tests/coverage/issue-83601.cov-map
index d1d751ff24b86..e42b5591c0fb3 100644
--- a/tests/coverage/issue-83601.cov-map
+++ b/tests/coverage/issue-83601.cov-map
@@ -1,30 +1,22 @@
 Function name: issue_83601::main
-Raw bytes (76): 0x[01, 01, 01, 05, 09, 0e, 01, 06, 01, 00, 0a, 01, 01, 09, 00, 0c, 01, 00, 0f, 00, 15, 01, 01, 05, 00, 0f, 05, 01, 09, 00, 0c, 05, 00, 0f, 00, 15, 05, 01, 05, 00, 0f, 02, 01, 05, 00, 0d, 02, 00, 0e, 00, 14, 02, 01, 05, 00, 0d, 02, 00, 0e, 00, 14, 02, 01, 05, 00, 0d, 02, 00, 0e, 00, 14, 02, 01, 01, 00, 02]
+Raw bytes (74): 0x[01, 01, 00, 0e, 01, 06, 01, 00, 0a, 01, 01, 09, 00, 0c, 01, 00, 0f, 00, 15, 01, 01, 05, 00, 0f, 01, 01, 09, 00, 0c, 01, 00, 0f, 00, 15, 01, 01, 05, 00, 0f, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 14, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 14, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 14, 01, 01, 01, 00, 02]
 Number of files: 1
 - file 0 => $DIR/issue-83601.rs
-Number of expressions: 1
-- expression 0 operands: lhs = Counter(1), rhs = Counter(2)
+Number of expressions: 0
 Number of file 0 mappings: 14
 - Code(Counter(0)) at (prev + 6, 1) to (start + 0, 10)
 - Code(Counter(0)) at (prev + 1, 9) to (start + 0, 12)
 - Code(Counter(0)) at (prev + 0, 15) to (start + 0, 21)
 - Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15)
-- Code(Counter(1)) at (prev + 1, 9) to (start + 0, 12)
-- Code(Counter(1)) at (prev + 0, 15) to (start + 0, 21)
-- Code(Counter(1)) at (prev + 1, 5) to (start + 0, 15)
-- Code(Expression(0, Sub)) at (prev + 1, 5) to (start + 0, 13)
-    = (c1 - c2)
-- Code(Expression(0, Sub)) at (prev + 0, 14) to (start + 0, 20)
-    = (c1 - c2)
-- Code(Expression(0, Sub)) at (prev + 1, 5) to (start + 0, 13)
-    = (c1 - c2)
-- Code(Expression(0, Sub)) at (prev + 0, 14) to (start + 0, 20)
-    = (c1 - c2)
-- Code(Expression(0, Sub)) at (prev + 1, 5) to (start + 0, 13)
-    = (c1 - c2)
-- Code(Expression(0, Sub)) at (prev + 0, 14) to (start + 0, 20)
-    = (c1 - c2)
-- Code(Expression(0, Sub)) at (prev + 1, 1) to (start + 0, 2)
-    = (c1 - c2)
-Highest counter ID seen: c1
+- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 12)
+- Code(Counter(0)) at (prev + 0, 15) to (start + 0, 21)
+- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15)
+- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
+- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 20)
+- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
+- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 20)
+- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
+- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 20)
+- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
+Highest counter ID seen: c0
 
diff --git a/tests/coverage/issue-84561.cov-map b/tests/coverage/issue-84561.cov-map
index 2b643ea599ed0..e5bb1afdcc263 100644
--- a/tests/coverage/issue-84561.cov-map
+++ b/tests/coverage/issue-84561.cov-map
@@ -73,20 +73,20 @@ Number of file 0 mappings: 4
 Highest counter ID seen: c0
 
 Function name: issue_84561::test3
-Raw bytes (409): 0x[01, 01, 0a, 0d, 11, 0d, 15, 0d, 19, 1d, 21, 29, 2d, 25, 29, 25, 29, 25, 29, 27, 31, 29, 2d, 4d, 01, 08, 01, 00, 0b, 01, 01, 09, 00, 10, 01, 00, 13, 00, 2e, 01, 01, 09, 00, 0c, 01, 00, 0f, 00, 15, 01, 01, 05, 00, 0f, 05, 01, 09, 00, 0c, 05, 00, 0f, 00, 15, 05, 01, 05, 00, 0f, 09, 01, 05, 00, 0d, 09, 00, 0e, 00, 14, 09, 01, 05, 00, 0d, 09, 00, 0e, 00, 14, 09, 01, 05, 00, 0d, 09, 00, 0e, 00, 14, 09, 02, 05, 00, 0f, 09, 01, 05, 00, 0f, 09, 01, 05, 00, 0f, 09, 01, 09, 00, 0c, 09, 00, 0f, 00, 15, 09, 01, 05, 00, 0f, 0d, 01, 05, 00, 0f, 0d, 01, 05, 00, 0f, 00, 00, 20, 00, 30, 0d, 01, 05, 00, 0d, 0d, 00, 0e, 00, 14, 0d, 01, 05, 00, 0d, 0d, 00, 0e, 00, 14, 0d, 02, 05, 00, 0f, 00, 00, 20, 00, 24, 00, 00, 29, 00, 30, 00, 00, 33, 00, 41, 00, 00, 4b, 00, 5a, 0d, 01, 05, 00, 0f, 00, 05, 09, 00, 0d, 00, 03, 09, 00, 10, 00, 02, 0d, 00, 1b, 00, 02, 0d, 00, 1c, 0d, 04, 09, 00, 10, 0d, 00, 13, 00, 2e, 0d, 02, 05, 00, 0f, 0d, 04, 05, 00, 0f, 0d, 04, 05, 00, 0f, 0d, 04, 09, 00, 0c, 0d, 00, 0f, 00, 15, 0d, 01, 05, 00, 0f, 0d, 04, 08, 00, 0f, 11, 01, 09, 00, 13, 02, 05, 09, 00, 13, 0d, 05, 08, 00, 0f, 15, 01, 09, 00, 13, 00, 03, 0d, 00, 1d, 06, 03, 09, 00, 13, 00, 03, 0d, 00, 1d, 0d, 03, 05, 00, 0f, 0d, 01, 0c, 00, 13, 19, 01, 0d, 00, 13, 0a, 02, 0d, 00, 13, 1d, 04, 05, 00, 0f, 1d, 02, 0c, 00, 13, 21, 01, 0d, 00, 13, 0e, 02, 0d, 00, 13, 27, 03, 05, 00, 0f, 25, 01, 0c, 00, 13, 29, 01, 0d, 00, 17, 29, 04, 0d, 00, 13, 1e, 02, 0d, 00, 17, 1e, 01, 14, 00, 1b, 00, 01, 15, 00, 1b, 1e, 02, 15, 00, 1b, 2d, 04, 0d, 00, 13, 22, 03, 09, 00, 19, 31, 02, 05, 00, 0f, 31, 03, 09, 00, 22, 00, 02, 05, 00, 0f, 00, 03, 09, 00, 2c, 00, 02, 01, 00, 02]
+Raw bytes (409): 0x[01, 01, 0a, 01, 05, 01, 09, 01, 0d, 11, 15, 1d, 21, 19, 1d, 19, 1d, 19, 1d, 27, 25, 1d, 21, 4d, 01, 08, 01, 00, 0b, 01, 01, 09, 00, 10, 01, 00, 13, 00, 2e, 01, 01, 09, 00, 0c, 01, 00, 0f, 00, 15, 01, 01, 05, 00, 0f, 01, 01, 09, 00, 0c, 01, 00, 0f, 00, 15, 01, 01, 05, 00, 0f, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 14, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 14, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 14, 01, 02, 05, 00, 0f, 01, 01, 05, 00, 0f, 01, 01, 05, 00, 0f, 01, 01, 09, 00, 0c, 01, 00, 0f, 00, 15, 01, 01, 05, 00, 0f, 01, 01, 05, 00, 0f, 01, 01, 05, 00, 0f, 00, 00, 20, 00, 30, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 14, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 14, 01, 02, 05, 00, 0f, 00, 00, 20, 00, 24, 00, 00, 29, 00, 30, 00, 00, 33, 00, 41, 00, 00, 4b, 00, 5a, 01, 01, 05, 00, 0f, 00, 05, 09, 00, 0d, 00, 03, 09, 00, 10, 00, 02, 0d, 00, 1b, 00, 02, 0d, 00, 1c, 01, 04, 09, 00, 10, 01, 00, 13, 00, 2e, 01, 02, 05, 00, 0f, 01, 04, 05, 00, 0f, 01, 04, 05, 00, 0f, 01, 04, 09, 00, 0c, 01, 00, 0f, 00, 15, 01, 01, 05, 00, 0f, 01, 04, 08, 00, 0f, 05, 01, 09, 00, 13, 02, 05, 09, 00, 13, 01, 05, 08, 00, 0f, 09, 01, 09, 00, 13, 00, 03, 0d, 00, 1d, 06, 03, 09, 00, 13, 00, 03, 0d, 00, 1d, 01, 03, 05, 00, 0f, 01, 01, 0c, 00, 13, 0d, 01, 0d, 00, 13, 0a, 02, 0d, 00, 13, 11, 04, 05, 00, 0f, 11, 02, 0c, 00, 13, 15, 01, 0d, 00, 13, 0e, 02, 0d, 00, 13, 27, 03, 05, 00, 0f, 19, 01, 0c, 00, 13, 1d, 01, 0d, 00, 17, 1d, 04, 0d, 00, 13, 1e, 02, 0d, 00, 17, 1e, 01, 14, 00, 1b, 00, 01, 15, 00, 1b, 1e, 02, 15, 00, 1b, 21, 04, 0d, 00, 13, 22, 03, 09, 00, 19, 25, 02, 05, 00, 0f, 25, 03, 09, 00, 22, 00, 02, 05, 00, 0f, 00, 03, 09, 00, 2c, 00, 02, 01, 00, 02]
 Number of files: 1
 - file 0 => $DIR/issue-84561.rs
 Number of expressions: 10
-- expression 0 operands: lhs = Counter(3), rhs = Counter(4)
-- expression 1 operands: lhs = Counter(3), rhs = Counter(5)
-- expression 2 operands: lhs = Counter(3), rhs = Counter(6)
-- expression 3 operands: lhs = Counter(7), rhs = Counter(8)
-- expression 4 operands: lhs = Counter(10), rhs = Counter(11)
-- expression 5 operands: lhs = Counter(9), rhs = Counter(10)
-- expression 6 operands: lhs = Counter(9), rhs = Counter(10)
-- expression 7 operands: lhs = Counter(9), rhs = Counter(10)
-- expression 8 operands: lhs = Expression(9, Add), rhs = Counter(12)
-- expression 9 operands: lhs = Counter(10), rhs = Counter(11)
+- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
+- expression 1 operands: lhs = Counter(0), rhs = Counter(2)
+- expression 2 operands: lhs = Counter(0), rhs = Counter(3)
+- expression 3 operands: lhs = Counter(4), rhs = Counter(5)
+- expression 4 operands: lhs = Counter(7), rhs = Counter(8)
+- expression 5 operands: lhs = Counter(6), rhs = Counter(7)
+- expression 6 operands: lhs = Counter(6), rhs = Counter(7)
+- expression 7 operands: lhs = Counter(6), rhs = Counter(7)
+- expression 8 operands: lhs = Expression(9, Add), rhs = Counter(9)
+- expression 9 operands: lhs = Counter(7), rhs = Counter(8)
 Number of file 0 mappings: 77
 - Code(Counter(0)) at (prev + 8, 1) to (start + 0, 11)
 - Code(Counter(0)) at (prev + 1, 9) to (start + 0, 16)
@@ -94,85 +94,85 @@ Number of file 0 mappings: 77
 - Code(Counter(0)) at (prev + 1, 9) to (start + 0, 12)
 - Code(Counter(0)) at (prev + 0, 15) to (start + 0, 21)
 - Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15)
-- Code(Counter(1)) at (prev + 1, 9) to (start + 0, 12)
-- Code(Counter(1)) at (prev + 0, 15) to (start + 0, 21)
-- Code(Counter(1)) at (prev + 1, 5) to (start + 0, 15)
-- Code(Counter(2)) at (prev + 1, 5) to (start + 0, 13)
-- Code(Counter(2)) at (prev + 0, 14) to (start + 0, 20)
-- Code(Counter(2)) at (prev + 1, 5) to (start + 0, 13)
-- Code(Counter(2)) at (prev + 0, 14) to (start + 0, 20)
-- Code(Counter(2)) at (prev + 1, 5) to (start + 0, 13)
-- Code(Counter(2)) at (prev + 0, 14) to (start + 0, 20)
-- Code(Counter(2)) at (prev + 2, 5) to (start + 0, 15)
-- Code(Counter(2)) at (prev + 1, 5) to (start + 0, 15)
-- Code(Counter(2)) at (prev + 1, 5) to (start + 0, 15)
-- Code(Counter(2)) at (prev + 1, 9) to (start + 0, 12)
-- Code(Counter(2)) at (prev + 0, 15) to (start + 0, 21)
-- Code(Counter(2)) at (prev + 1, 5) to (start + 0, 15)
-- Code(Counter(3)) at (prev + 1, 5) to (start + 0, 15)
-- Code(Counter(3)) at (prev + 1, 5) to (start + 0, 15)
+- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 12)
+- Code(Counter(0)) at (prev + 0, 15) to (start + 0, 21)
+- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15)
+- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
+- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 20)
+- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
+- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 20)
+- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
+- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 20)
+- Code(Counter(0)) at (prev + 2, 5) to (start + 0, 15)
+- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15)
+- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15)
+- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 12)
+- Code(Counter(0)) at (prev + 0, 15) to (start + 0, 21)
+- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15)
+- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15)
+- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15)
 - Code(Zero) at (prev + 0, 32) to (start + 0, 48)
-- Code(Counter(3)) at (prev + 1, 5) to (start + 0, 13)
-- Code(Counter(3)) at (prev + 0, 14) to (start + 0, 20)
-- Code(Counter(3)) at (prev + 1, 5) to (start + 0, 13)
-- Code(Counter(3)) at (prev + 0, 14) to (start + 0, 20)
-- Code(Counter(3)) at (prev + 2, 5) to (start + 0, 15)
+- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
+- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 20)
+- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
+- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 20)
+- Code(Counter(0)) at (prev + 2, 5) to (start + 0, 15)
 - Code(Zero) at (prev + 0, 32) to (start + 0, 36)
 - Code(Zero) at (prev + 0, 41) to (start + 0, 48)
 - Code(Zero) at (prev + 0, 51) to (start + 0, 65)
 - Code(Zero) at (prev + 0, 75) to (start + 0, 90)
-- Code(Counter(3)) at (prev + 1, 5) to (start + 0, 15)
+- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15)
 - Code(Zero) at (prev + 5, 9) to (start + 0, 13)
 - Code(Zero) at (prev + 3, 9) to (start + 0, 16)
 - Code(Zero) at (prev + 2, 13) to (start + 0, 27)
 - Code(Zero) at (prev + 2, 13) to (start + 0, 28)
-- Code(Counter(3)) at (prev + 4, 9) to (start + 0, 16)
-- Code(Counter(3)) at (prev + 0, 19) to (start + 0, 46)
-- Code(Counter(3)) at (prev + 2, 5) to (start + 0, 15)
-- Code(Counter(3)) at (prev + 4, 5) to (start + 0, 15)
-- Code(Counter(3)) at (prev + 4, 5) to (start + 0, 15)
-- Code(Counter(3)) at (prev + 4, 9) to (start + 0, 12)
-- Code(Counter(3)) at (prev + 0, 15) to (start + 0, 21)
-- Code(Counter(3)) at (prev + 1, 5) to (start + 0, 15)
-- Code(Counter(3)) at (prev + 4, 8) to (start + 0, 15)
-- Code(Counter(4)) at (prev + 1, 9) to (start + 0, 19)
+- Code(Counter(0)) at (prev + 4, 9) to (start + 0, 16)
+- Code(Counter(0)) at (prev + 0, 19) to (start + 0, 46)
+- Code(Counter(0)) at (prev + 2, 5) to (start + 0, 15)
+- Code(Counter(0)) at (prev + 4, 5) to (start + 0, 15)
+- Code(Counter(0)) at (prev + 4, 5) to (start + 0, 15)
+- Code(Counter(0)) at (prev + 4, 9) to (start + 0, 12)
+- Code(Counter(0)) at (prev + 0, 15) to (start + 0, 21)
+- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15)
+- Code(Counter(0)) at (prev + 4, 8) to (start + 0, 15)
+- Code(Counter(1)) at (prev + 1, 9) to (start + 0, 19)
 - Code(Expression(0, Sub)) at (prev + 5, 9) to (start + 0, 19)
-    = (c3 - c4)
-- Code(Counter(3)) at (prev + 5, 8) to (start + 0, 15)
-- Code(Counter(5)) at (prev + 1, 9) to (start + 0, 19)
+    = (c0 - c1)
+- Code(Counter(0)) at (prev + 5, 8) to (start + 0, 15)
+- Code(Counter(2)) at (prev + 1, 9) to (start + 0, 19)
 - Code(Zero) at (prev + 3, 13) to (start + 0, 29)
 - Code(Expression(1, Sub)) at (prev + 3, 9) to (start + 0, 19)
-    = (c3 - c5)
+    = (c0 - c2)
 - Code(Zero) at (prev + 3, 13) to (start + 0, 29)
-- Code(Counter(3)) at (prev + 3, 5) to (start + 0, 15)
-- Code(Counter(3)) at (prev + 1, 12) to (start + 0, 19)
-- Code(Counter(6)) at (prev + 1, 13) to (start + 0, 19)
+- Code(Counter(0)) at (prev + 3, 5) to (start + 0, 15)
+- Code(Counter(0)) at (prev + 1, 12) to (start + 0, 19)
+- Code(Counter(3)) at (prev + 1, 13) to (start + 0, 19)
 - Code(Expression(2, Sub)) at (prev + 2, 13) to (start + 0, 19)
-    = (c3 - c6)
-- Code(Counter(7)) at (prev + 4, 5) to (start + 0, 15)
-- Code(Counter(7)) at (prev + 2, 12) to (start + 0, 19)
-- Code(Counter(8)) at (prev + 1, 13) to (start + 0, 19)
+    = (c0 - c3)
+- Code(Counter(4)) at (prev + 4, 5) to (start + 0, 15)
+- Code(Counter(4)) at (prev + 2, 12) to (start + 0, 19)
+- Code(Counter(5)) at (prev + 1, 13) to (start + 0, 19)
 - Code(Expression(3, Sub)) at (prev + 2, 13) to (start + 0, 19)
-    = (c7 - c8)
+    = (c4 - c5)
 - Code(Expression(9, Add)) at (prev + 3, 5) to (start + 0, 15)
-    = (c10 + c11)
-- Code(Counter(9)) at (prev + 1, 12) to (start + 0, 19)
-- Code(Counter(10)) at (prev + 1, 13) to (start + 0, 23)
-- Code(Counter(10)) at (prev + 4, 13) to (start + 0, 19)
+    = (c7 + c8)
+- Code(Counter(6)) at (prev + 1, 12) to (start + 0, 19)
+- Code(Counter(7)) at (prev + 1, 13) to (start + 0, 23)
+- Code(Counter(7)) at (prev + 4, 13) to (start + 0, 19)
 - Code(Expression(7, Sub)) at (prev + 2, 13) to (start + 0, 23)
-    = (c9 - c10)
+    = (c6 - c7)
 - Code(Expression(7, Sub)) at (prev + 1, 20) to (start + 0, 27)
-    = (c9 - c10)
+    = (c6 - c7)
 - Code(Zero) at (prev + 1, 21) to (start + 0, 27)
 - Code(Expression(7, Sub)) at (prev + 2, 21) to (start + 0, 27)
-    = (c9 - c10)
-- Code(Counter(11)) at (prev + 4, 13) to (start + 0, 19)
+    = (c6 - c7)
+- Code(Counter(8)) at (prev + 4, 13) to (start + 0, 19)
 - Code(Expression(8, Sub)) at (prev + 3, 9) to (start + 0, 25)
-    = ((c10 + c11) - c12)
-- Code(Counter(12)) at (prev + 2, 5) to (start + 0, 15)
-- Code(Counter(12)) at (prev + 3, 9) to (start + 0, 34)
+    = ((c7 + c8) - c9)
+- Code(Counter(9)) at (prev + 2, 5) to (start + 0, 15)
+- Code(Counter(9)) at (prev + 3, 9) to (start + 0, 34)
 - Code(Zero) at (prev + 2, 5) to (start + 0, 15)
 - Code(Zero) at (prev + 3, 9) to (start + 0, 44)
 - Code(Zero) at (prev + 2, 1) to (start + 0, 2)
-Highest counter ID seen: c12
+Highest counter ID seen: c9
 
diff --git a/tests/ui/inference/need_type_info/issue-107745-avoid-expr-from-macro-expansion.stderr b/tests/ui/inference/need_type_info/issue-107745-avoid-expr-from-macro-expansion.stderr
index 3de317d2af6d1..a78941f9e11be 100644
--- a/tests/ui/inference/need_type_info/issue-107745-avoid-expr-from-macro-expansion.stderr
+++ b/tests/ui/inference/need_type_info/issue-107745-avoid-expr-from-macro-expansion.stderr
@@ -1,10 +1,10 @@
 error[E0282]: type annotations needed
-  --> $DIR/issue-107745-avoid-expr-from-macro-expansion.rs:17:22
+  --> $DIR/issue-107745-avoid-expr-from-macro-expansion.rs:17:5
    |
 LL |     println!("{:?}", []);
-   |                      ^^ cannot infer type
+   |     ^^^^^^^^^^^^^^^^^^^^ cannot infer type
    |
-   = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-27592.stderr b/tests/ui/issues/issue-27592.stderr
index c8649d82d7451..f1de7b9e569da 100644
--- a/tests/ui/issues/issue-27592.stderr
+++ b/tests/ui/issues/issue-27592.stderr
@@ -1,3 +1,9 @@
+error[E0515]: cannot return reference to temporary value
+  --> $DIR/issue-27592.rs:16:14
+   |
+LL |     write(|| format_args!("{}", String::from("Hello world")));
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ returns a reference to data owned by the current function
+
 error[E0515]: cannot return value referencing temporary value
   --> $DIR/issue-27592.rs:16:14
    |
@@ -7,12 +13,6 @@ LL |     write(|| format_args!("{}", String::from("Hello world")));
    |              |                  temporary value created here
    |              returns a value referencing data owned by the current function
 
-error[E0515]: cannot return reference to temporary value
-  --> $DIR/issue-27592.rs:16:14
-   |
-LL |     write(|| format_args!("{}", String::from("Hello world")));
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ returns a reference to data owned by the current function
-
 error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/suggestions/issue-97760.stderr b/tests/ui/suggestions/issue-97760.stderr
index 1084ea7c9e0e7..c3cf7e13987b6 100644
--- a/tests/ui/suggestions/issue-97760.stderr
+++ b/tests/ui/suggestions/issue-97760.stderr
@@ -1,11 +1,8 @@
 error[E0277]: `<impl IntoIterator as IntoIterator>::Item` doesn't implement `std::fmt::Display`
-  --> $DIR/issue-97760.rs:4:20
+  --> $DIR/issue-97760.rs:4:19
    |
 LL |         println!("{x}");
-   |                   -^-
-   |                   ||
-   |                   |`<impl IntoIterator as IntoIterator>::Item` cannot be formatted with the default formatter
-   |                   required by this formatting parameter
+   |                   ^^^ `<impl IntoIterator as IntoIterator>::Item` cannot be formatted with the default formatter
    |
    = help: the trait `std::fmt::Display` is not implemented for `<impl IntoIterator as IntoIterator>::Item`
    = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead
diff --git a/tests/ui/unpretty/exhaustive.hir.stdout b/tests/ui/unpretty/exhaustive.hir.stdout
index 924fb98ae18a8..48dbb03b82a63 100644
--- a/tests/ui/unpretty/exhaustive.hir.stdout
+++ b/tests/ui/unpretty/exhaustive.hir.stdout
@@ -398,7 +398,8 @@ mod expressions {
         let expr;
         format_arguments::new_const(&[]);
         {
-            super let args = [format_argument::new_display(&expr)];
+            super let args = (&expr,);
+            super let args = [format_argument::new_display(args.0)];
             format_arguments::new_v1(&[""], &args)
         };
     }
diff --git a/tests/ui/unpretty/flattened-format-args.stdout b/tests/ui/unpretty/flattened-format-args.stdout
index 0792dc10e946b..233c9f1c91bd7 100644
--- a/tests/ui/unpretty/flattened-format-args.stdout
+++ b/tests/ui/unpretty/flattened-format-args.stdout
@@ -11,7 +11,8 @@ fn main() {
     // Should flatten to println!("a 123 b {x} xyz\n"):
     {
         ::std::io::_print({
-                super let args = [format_argument::new_display(&x)];
+                super let args = (&x,);
+                super let args = [format_argument::new_display(args.0)];
                 format_arguments::new_v1(&["a 123 b ", " xyz\n"], &args)
             });
     };

From 663ca24879a6ded2bd1dda8c6da916444f78e850 Mon Sep 17 00:00:00 2001
From: Mara Bos <m-ou.se@m-ou.se>
Date: Tue, 26 Aug 2025 15:54:59 +0200
Subject: [PATCH 0295/1889] Bless clippy tests.

---
 .../tests/ui/author/macro_in_closure.stdout   | 32 ++++++++++++-------
 .../tests/ui/author/macro_in_loop.stdout      | 28 ++++++++++------
 2 files changed, 38 insertions(+), 22 deletions(-)

diff --git a/src/tools/clippy/tests/ui/author/macro_in_closure.stdout b/src/tools/clippy/tests/ui/author/macro_in_closure.stdout
index 49595e2fec257..786c61e0c018e 100644
--- a/src/tools/clippy/tests/ui/author/macro_in_closure.stdout
+++ b/src/tools/clippy/tests/ui/author/macro_in_closure.stdout
@@ -10,34 +10,42 @@ if let StmtKind::Let(local) = stmt.kind
     && paths::STD_IO_STDIO__PRINT.matches_path(cx, func) // Add the path to `clippy_utils::paths` if needed
     && args.len() == 1
     && let ExprKind::Block(block1, None) = args[0].kind
-    && block1.stmts.len() == 1
+    && block1.stmts.len() == 2
     && let StmtKind::Let(local1) = block1.stmts[0].kind
     && let Some(init1) = local1.init
-    && let ExprKind::Array(elements) = init1.kind
+    && let ExprKind::Tup(elements) = init1.kind
     && elements.len() == 1
-    && let ExprKind::Call(func1, args1) = elements[0].kind
-    && paths::CORE_FMT_RT_ARGUMENT_NEW_DISPLAY.matches_path(cx, func1) // Add the path to `clippy_utils::paths` if needed
-    && args1.len() == 1
-    && let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner) = args1[0].kind
+    && let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner) = elements[0].kind
     && let PatKind::Binding(BindingMode::NONE, _, name, None) = local1.pat.kind
     && name.as_str() == "args"
+    && let StmtKind::Let(local2) = block1.stmts[1].kind
+    && let Some(init2) = local2.init
+    && let ExprKind::Array(elements1) = init2.kind
+    && elements1.len() == 1
+    && let ExprKind::Call(func1, args1) = elements1[0].kind
+    && paths::CORE_FMT_RT_ARGUMENT_NEW_DISPLAY.matches_path(cx, func1) // Add the path to `clippy_utils::paths` if needed
+    && args1.len() == 1
+    && let ExprKind::Field(object, field_name) = args1[0].kind
+    && field_name.as_str() == "0"
+    && let PatKind::Binding(BindingMode::NONE, _, name1, None) = local2.pat.kind
+    && name1.as_str() == "args"
     && let Some(trailing_expr) = block1.expr
     && let ExprKind::Call(func2, args2) = trailing_expr.kind
     && paths::CORE_FMT_RT_NEW_V1.matches_path(cx, func2) // Add the path to `clippy_utils::paths` if needed
     && args2.len() == 2
     && let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner1) = args2[0].kind
-    && let ExprKind::Array(elements1) = inner1.kind
-    && elements1.len() == 2
-    && let ExprKind::Lit(ref lit) = elements1[0].kind
+    && let ExprKind::Array(elements2) = inner1.kind
+    && elements2.len() == 2
+    && let ExprKind::Lit(ref lit) = elements2[0].kind
     && let LitKind::Str(s, _) = lit.node
     && s.as_str() == ""
-    && let ExprKind::Lit(ref lit1) = elements1[1].kind
+    && let ExprKind::Lit(ref lit1) = elements2[1].kind
     && let LitKind::Str(s1, _) = lit1.node
     && s1.as_str() == "\n"
     && let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner2) = args2[1].kind
     && block.expr.is_none()
-    && let PatKind::Binding(BindingMode::NONE, _, name1, None) = local.pat.kind
-    && name1.as_str() == "print_text"
+    && let PatKind::Binding(BindingMode::NONE, _, name2, None) = local.pat.kind
+    && name2.as_str() == "print_text"
 {
     // report your lint here
 }
diff --git a/src/tools/clippy/tests/ui/author/macro_in_loop.stdout b/src/tools/clippy/tests/ui/author/macro_in_loop.stdout
index 4fc7b49464db3..80717900b5255 100644
--- a/src/tools/clippy/tests/ui/author/macro_in_loop.stdout
+++ b/src/tools/clippy/tests/ui/author/macro_in_loop.stdout
@@ -20,28 +20,36 @@ if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, .. }) = higher::Fo
     && paths::STD_IO_STDIO__PRINT.matches_path(cx, func) // Add the path to `clippy_utils::paths` if needed
     && args.len() == 1
     && let ExprKind::Block(block2, None) = args[0].kind
-    && block2.stmts.len() == 1
+    && block2.stmts.len() == 2
     && let StmtKind::Let(local) = block2.stmts[0].kind
     && let Some(init) = local.init
-    && let ExprKind::Array(elements) = init.kind
+    && let ExprKind::Tup(elements) = init.kind
     && elements.len() == 1
-    && let ExprKind::Call(func1, args1) = elements[0].kind
-    && paths::CORE_FMT_RT_ARGUMENT_NEW_DISPLAY.matches_path(cx, func1) // Add the path to `clippy_utils::paths` if needed
-    && args1.len() == 1
-    && let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner) = args1[0].kind
+    && let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner) = elements[0].kind
     && let PatKind::Binding(BindingMode::NONE, _, name1, None) = local.pat.kind
     && name1.as_str() == "args"
+    && let StmtKind::Let(local1) = block2.stmts[1].kind
+    && let Some(init1) = local1.init
+    && let ExprKind::Array(elements1) = init1.kind
+    && elements1.len() == 1
+    && let ExprKind::Call(func1, args1) = elements1[0].kind
+    && paths::CORE_FMT_RT_ARGUMENT_NEW_DISPLAY.matches_path(cx, func1) // Add the path to `clippy_utils::paths` if needed
+    && args1.len() == 1
+    && let ExprKind::Field(object, field_name) = args1[0].kind
+    && field_name.as_str() == "0"
+    && let PatKind::Binding(BindingMode::NONE, _, name2, None) = local1.pat.kind
+    && name2.as_str() == "args"
     && let Some(trailing_expr) = block2.expr
     && let ExprKind::Call(func2, args2) = trailing_expr.kind
     && paths::CORE_FMT_RT_NEW_V1.matches_path(cx, func2) // Add the path to `clippy_utils::paths` if needed
     && args2.len() == 2
     && let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner1) = args2[0].kind
-    && let ExprKind::Array(elements1) = inner1.kind
-    && elements1.len() == 2
-    && let ExprKind::Lit(ref lit2) = elements1[0].kind
+    && let ExprKind::Array(elements2) = inner1.kind
+    && elements2.len() == 2
+    && let ExprKind::Lit(ref lit2) = elements2[0].kind
     && let LitKind::Str(s, _) = lit2.node
     && s.as_str() == ""
-    && let ExprKind::Lit(ref lit3) = elements1[1].kind
+    && let ExprKind::Lit(ref lit3) = elements2[1].kind
     && let LitKind::Str(s1, _) = lit3.node
     && s1.as_str() == "\n"
     && let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner2) = args2[1].kind

From d43c55be3487277783f9a5445ceeaa01fa558b11 Mon Sep 17 00:00:00 2001
From: Mara Bos <m-ou.se@m-ou.se>
Date: Tue, 26 Aug 2025 15:54:59 +0200
Subject: [PATCH 0296/1889] Bless clippy tests.

---
 tests/ui/author/macro_in_closure.stdout | 32 +++++++++++++++----------
 tests/ui/author/macro_in_loop.stdout    | 28 ++++++++++++++--------
 2 files changed, 38 insertions(+), 22 deletions(-)

diff --git a/tests/ui/author/macro_in_closure.stdout b/tests/ui/author/macro_in_closure.stdout
index 49595e2fec257..786c61e0c018e 100644
--- a/tests/ui/author/macro_in_closure.stdout
+++ b/tests/ui/author/macro_in_closure.stdout
@@ -10,34 +10,42 @@ if let StmtKind::Let(local) = stmt.kind
     && paths::STD_IO_STDIO__PRINT.matches_path(cx, func) // Add the path to `clippy_utils::paths` if needed
     && args.len() == 1
     && let ExprKind::Block(block1, None) = args[0].kind
-    && block1.stmts.len() == 1
+    && block1.stmts.len() == 2
     && let StmtKind::Let(local1) = block1.stmts[0].kind
     && let Some(init1) = local1.init
-    && let ExprKind::Array(elements) = init1.kind
+    && let ExprKind::Tup(elements) = init1.kind
     && elements.len() == 1
-    && let ExprKind::Call(func1, args1) = elements[0].kind
-    && paths::CORE_FMT_RT_ARGUMENT_NEW_DISPLAY.matches_path(cx, func1) // Add the path to `clippy_utils::paths` if needed
-    && args1.len() == 1
-    && let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner) = args1[0].kind
+    && let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner) = elements[0].kind
     && let PatKind::Binding(BindingMode::NONE, _, name, None) = local1.pat.kind
     && name.as_str() == "args"
+    && let StmtKind::Let(local2) = block1.stmts[1].kind
+    && let Some(init2) = local2.init
+    && let ExprKind::Array(elements1) = init2.kind
+    && elements1.len() == 1
+    && let ExprKind::Call(func1, args1) = elements1[0].kind
+    && paths::CORE_FMT_RT_ARGUMENT_NEW_DISPLAY.matches_path(cx, func1) // Add the path to `clippy_utils::paths` if needed
+    && args1.len() == 1
+    && let ExprKind::Field(object, field_name) = args1[0].kind
+    && field_name.as_str() == "0"
+    && let PatKind::Binding(BindingMode::NONE, _, name1, None) = local2.pat.kind
+    && name1.as_str() == "args"
     && let Some(trailing_expr) = block1.expr
     && let ExprKind::Call(func2, args2) = trailing_expr.kind
     && paths::CORE_FMT_RT_NEW_V1.matches_path(cx, func2) // Add the path to `clippy_utils::paths` if needed
     && args2.len() == 2
     && let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner1) = args2[0].kind
-    && let ExprKind::Array(elements1) = inner1.kind
-    && elements1.len() == 2
-    && let ExprKind::Lit(ref lit) = elements1[0].kind
+    && let ExprKind::Array(elements2) = inner1.kind
+    && elements2.len() == 2
+    && let ExprKind::Lit(ref lit) = elements2[0].kind
     && let LitKind::Str(s, _) = lit.node
     && s.as_str() == ""
-    && let ExprKind::Lit(ref lit1) = elements1[1].kind
+    && let ExprKind::Lit(ref lit1) = elements2[1].kind
     && let LitKind::Str(s1, _) = lit1.node
     && s1.as_str() == "\n"
     && let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner2) = args2[1].kind
     && block.expr.is_none()
-    && let PatKind::Binding(BindingMode::NONE, _, name1, None) = local.pat.kind
-    && name1.as_str() == "print_text"
+    && let PatKind::Binding(BindingMode::NONE, _, name2, None) = local.pat.kind
+    && name2.as_str() == "print_text"
 {
     // report your lint here
 }
diff --git a/tests/ui/author/macro_in_loop.stdout b/tests/ui/author/macro_in_loop.stdout
index 4fc7b49464db3..80717900b5255 100644
--- a/tests/ui/author/macro_in_loop.stdout
+++ b/tests/ui/author/macro_in_loop.stdout
@@ -20,28 +20,36 @@ if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, .. }) = higher::Fo
     && paths::STD_IO_STDIO__PRINT.matches_path(cx, func) // Add the path to `clippy_utils::paths` if needed
     && args.len() == 1
     && let ExprKind::Block(block2, None) = args[0].kind
-    && block2.stmts.len() == 1
+    && block2.stmts.len() == 2
     && let StmtKind::Let(local) = block2.stmts[0].kind
     && let Some(init) = local.init
-    && let ExprKind::Array(elements) = init.kind
+    && let ExprKind::Tup(elements) = init.kind
     && elements.len() == 1
-    && let ExprKind::Call(func1, args1) = elements[0].kind
-    && paths::CORE_FMT_RT_ARGUMENT_NEW_DISPLAY.matches_path(cx, func1) // Add the path to `clippy_utils::paths` if needed
-    && args1.len() == 1
-    && let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner) = args1[0].kind
+    && let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner) = elements[0].kind
     && let PatKind::Binding(BindingMode::NONE, _, name1, None) = local.pat.kind
     && name1.as_str() == "args"
+    && let StmtKind::Let(local1) = block2.stmts[1].kind
+    && let Some(init1) = local1.init
+    && let ExprKind::Array(elements1) = init1.kind
+    && elements1.len() == 1
+    && let ExprKind::Call(func1, args1) = elements1[0].kind
+    && paths::CORE_FMT_RT_ARGUMENT_NEW_DISPLAY.matches_path(cx, func1) // Add the path to `clippy_utils::paths` if needed
+    && args1.len() == 1
+    && let ExprKind::Field(object, field_name) = args1[0].kind
+    && field_name.as_str() == "0"
+    && let PatKind::Binding(BindingMode::NONE, _, name2, None) = local1.pat.kind
+    && name2.as_str() == "args"
     && let Some(trailing_expr) = block2.expr
     && let ExprKind::Call(func2, args2) = trailing_expr.kind
     && paths::CORE_FMT_RT_NEW_V1.matches_path(cx, func2) // Add the path to `clippy_utils::paths` if needed
     && args2.len() == 2
     && let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner1) = args2[0].kind
-    && let ExprKind::Array(elements1) = inner1.kind
-    && elements1.len() == 2
-    && let ExprKind::Lit(ref lit2) = elements1[0].kind
+    && let ExprKind::Array(elements2) = inner1.kind
+    && elements2.len() == 2
+    && let ExprKind::Lit(ref lit2) = elements2[0].kind
     && let LitKind::Str(s, _) = lit2.node
     && s.as_str() == ""
-    && let ExprKind::Lit(ref lit3) = elements1[1].kind
+    && let ExprKind::Lit(ref lit3) = elements2[1].kind
     && let LitKind::Str(s1, _) = lit3.node
     && s1.as_str() == "\n"
     && let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner2) = args2[1].kind

From cee25947df4f0d3cb455810b64cd62c16d775109 Mon Sep 17 00:00:00 2001
From: sgasho <SuganoShota1999@gmail.com>
Date: Wed, 27 Aug 2025 00:06:47 +0900
Subject: [PATCH 0297/1889] fix: Prevent invalid transformation in 'Replace
 match with if let' assist

---
 .../src/handlers/replace_if_let_with_match.rs | 24 ++++++++++++++++++-
 1 file changed, 23 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_if_let_with_match.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_if_let_with_match.rs
index dd244375dc91e..3b815a467bc06 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_if_let_with_match.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_if_let_with_match.rs
@@ -328,7 +328,14 @@ fn pick_pattern_and_expr_order(
         (pat, pat2) => match (binds_name(sema, &pat), binds_name(sema, &pat2)) {
             (true, true) => return None,
             (true, false) => (pat, guard, expr, expr2),
-            (false, true) => (pat2, guard2, expr2, expr),
+            (false, true) => {
+                // This pattern triggers an invalid transformation.
+                // See issues #11373, #19443
+                if let ast::Pat::IdentPat(_) = pat2 {
+                    return None;
+                }
+                (pat2, guard2, expr2, expr)
+            }
             _ if is_sad_pat(sema, &pat) => (pat2, guard2, expr2, expr),
             (false, false) => (pat, guard, expr, expr2),
         },
@@ -1892,4 +1899,19 @@ fn main() {
 "#,
         )
     }
+
+    #[test]
+    fn test_replace_match_with_if_let_not_applicable_pat2_is_ident_pat() {
+        check_assist_not_applicable(
+            replace_match_with_if_let,
+            r"
+fn test(a: i32) {
+    match$0 a {
+        1 => code(),
+        other => code(other),
+    }
+}
+",
+        )
+    }
 }

From e54afd3d7dc1f62944e5b6750ceecfdd17e1c3a3 Mon Sep 17 00:00:00 2001
From: Yoh Deadfall <yoh.deadfall@hotmail.com>
Date: Tue, 26 Aug 2025 17:49:15 +0300
Subject: [PATCH 0298/1889] Enable clippy::panic in const contexts

---
 clippy_lints/src/panic_unimplemented.rs |  6 ++--
 tests/ui/panicking_macros.rs            | 15 ++++++++
 tests/ui/panicking_macros.stderr        | 46 +++++++++++++++++--------
 3 files changed, 50 insertions(+), 17 deletions(-)

diff --git a/clippy_lints/src/panic_unimplemented.rs b/clippy_lints/src/panic_unimplemented.rs
index 449d3da763941..43db0085f2e34 100644
--- a/clippy_lints/src/panic_unimplemented.rs
+++ b/clippy_lints/src/panic_unimplemented.rs
@@ -1,7 +1,7 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::is_in_test;
 use clippy_utils::macros::{is_panic, root_macro_call_first_node};
+use clippy_utils::{is_in_test, is_inside_always_const_context};
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
@@ -99,7 +99,7 @@ impl<'tcx> LateLintPass<'tcx> for PanicUnimplemented {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let Some(macro_call) = root_macro_call_first_node(cx, expr) {
             if is_panic(cx, macro_call.def_id) {
-                if cx.tcx.hir_is_inside_const_context(expr.hir_id)
+                if is_inside_always_const_context(cx.tcx, expr.hir_id)
                     || self.allow_panic_in_tests && is_in_test(cx.tcx, expr.hir_id)
                 {
                     return;
@@ -140,7 +140,7 @@ impl<'tcx> LateLintPass<'tcx> for PanicUnimplemented {
             && let Res::Def(DefKind::Fn, def_id) = expr_path.res
             && cx.tcx.is_diagnostic_item(sym::panic_any, def_id)
         {
-            if cx.tcx.hir_is_inside_const_context(expr.hir_id)
+            if is_inside_always_const_context(cx.tcx, expr.hir_id)
                 || self.allow_panic_in_tests && is_in_test(cx.tcx, expr.hir_id)
             {
                 return;
diff --git a/tests/ui/panicking_macros.rs b/tests/ui/panicking_macros.rs
index 65854d7eb4bf9..b044be7d54ac5 100644
--- a/tests/ui/panicking_macros.rs
+++ b/tests/ui/panicking_macros.rs
@@ -31,6 +31,20 @@ fn panic() {
     let b = a + 2;
 }
 
+const fn panic_const() {
+    let a = 2;
+    panic!();
+    //~^ panic
+
+    panic!("message");
+    //~^ panic
+
+    panic!("{} {}", "panic with", "multiple arguments");
+    //~^ panic
+
+    let b = a + 2;
+}
+
 fn todo() {
     let a = 2;
     todo!();
@@ -114,6 +128,7 @@ fn debug_assert_msg() {
 
 fn main() {
     panic();
+    panic_const();
     todo();
     unimplemented();
     unreachable();
diff --git a/tests/ui/panicking_macros.stderr b/tests/ui/panicking_macros.stderr
index 03e459e4ec6ec..7b767ae0f65bf 100644
--- a/tests/ui/panicking_macros.stderr
+++ b/tests/ui/panicking_macros.stderr
@@ -19,9 +19,27 @@ error: `panic` should not be present in production code
 LL |     panic!("{} {}", "panic with", "multiple arguments");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: `todo` should not be present in production code
+error: `panic` should not be present in production code
   --> tests/ui/panicking_macros.rs:36:5
    |
+LL |     panic!();
+   |     ^^^^^^^^
+
+error: `panic` should not be present in production code
+  --> tests/ui/panicking_macros.rs:39:5
+   |
+LL |     panic!("message");
+   |     ^^^^^^^^^^^^^^^^^
+
+error: `panic` should not be present in production code
+  --> tests/ui/panicking_macros.rs:42:5
+   |
+LL |     panic!("{} {}", "panic with", "multiple arguments");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: `todo` should not be present in production code
+  --> tests/ui/panicking_macros.rs:50:5
+   |
 LL |     todo!();
    |     ^^^^^^^
    |
@@ -29,19 +47,19 @@ LL |     todo!();
    = help: to override `-D warnings` add `#[allow(clippy::todo)]`
 
 error: `todo` should not be present in production code
-  --> tests/ui/panicking_macros.rs:39:5
+  --> tests/ui/panicking_macros.rs:53:5
    |
 LL |     todo!("message");
    |     ^^^^^^^^^^^^^^^^
 
 error: `todo` should not be present in production code
-  --> tests/ui/panicking_macros.rs:42:5
+  --> tests/ui/panicking_macros.rs:56:5
    |
 LL |     todo!("{} {}", "panic with", "multiple arguments");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `unimplemented` should not be present in production code
-  --> tests/ui/panicking_macros.rs:50:5
+  --> tests/ui/panicking_macros.rs:64:5
    |
 LL |     unimplemented!();
    |     ^^^^^^^^^^^^^^^^
@@ -50,19 +68,19 @@ LL |     unimplemented!();
    = help: to override `-D warnings` add `#[allow(clippy::unimplemented)]`
 
 error: `unimplemented` should not be present in production code
-  --> tests/ui/panicking_macros.rs:53:5
+  --> tests/ui/panicking_macros.rs:67:5
    |
 LL |     unimplemented!("message");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `unimplemented` should not be present in production code
-  --> tests/ui/panicking_macros.rs:56:5
+  --> tests/ui/panicking_macros.rs:70:5
    |
 LL |     unimplemented!("{} {}", "panic with", "multiple arguments");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: usage of the `unreachable!` macro
-  --> tests/ui/panicking_macros.rs:64:5
+  --> tests/ui/panicking_macros.rs:78:5
    |
 LL |     unreachable!();
    |     ^^^^^^^^^^^^^^
@@ -71,40 +89,40 @@ LL |     unreachable!();
    = help: to override `-D warnings` add `#[allow(clippy::unreachable)]`
 
 error: usage of the `unreachable!` macro
-  --> tests/ui/panicking_macros.rs:67:5
+  --> tests/ui/panicking_macros.rs:81:5
    |
 LL |     unreachable!("message");
    |     ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: usage of the `unreachable!` macro
-  --> tests/ui/panicking_macros.rs:70:5
+  --> tests/ui/panicking_macros.rs:84:5
    |
 LL |     unreachable!("{} {}", "panic with", "multiple arguments");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `panic` should not be present in production code
-  --> tests/ui/panicking_macros.rs:78:5
+  --> tests/ui/panicking_macros.rs:92:5
    |
 LL |     panic!();
    |     ^^^^^^^^
 
 error: `todo` should not be present in production code
-  --> tests/ui/panicking_macros.rs:81:5
+  --> tests/ui/panicking_macros.rs:95:5
    |
 LL |     todo!();
    |     ^^^^^^^
 
 error: `unimplemented` should not be present in production code
-  --> tests/ui/panicking_macros.rs:84:5
+  --> tests/ui/panicking_macros.rs:98:5
    |
 LL |     unimplemented!();
    |     ^^^^^^^^^^^^^^^^
 
 error: usage of the `unreachable!` macro
-  --> tests/ui/panicking_macros.rs:87:5
+  --> tests/ui/panicking_macros.rs:101:5
    |
 LL |     unreachable!();
    |     ^^^^^^^^^^^^^^
 
-error: aborting due to 16 previous errors
+error: aborting due to 19 previous errors
 

From 83f22cc0f87263c0aa3057d55b994d75c6151834 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Tue, 26 Aug 2025 19:33:46 +0300
Subject: [PATCH 0299/1889] Remove `SolverDefId::ForeignId`

Replace it with normal `SolverDefId::TypeAliasId`.

The split caused a very funny bug where code was getting `TypeAliasId` where it expected `ForeignId`, because `TypeAliasId` had a `From` impl from `hir_def::TypeAliasId` and `ForeignId` had not, plus a careless `into()`.

I could've fixed this specific bug but opted to remove the split instead; currently, it just provides more room for bugs, as we don't have typed IDs for the solver anyway, and even when we'll have (hopefully), that doesn't seem like a very useful distinction, for example in hir-def foreign types are just `TypeAliasId` with some flags.

Constructing a test for this isn't trivial; the trivial test (creating a foreign type, even proving a trait bound for it) fails to fail before the change, probably because we don't use the new solver everywhere yet so we don't trigger this specific code path.
---
 src/tools/rust-analyzer/crates/hir-ty/src/display.rs          | 2 +-
 .../rust-analyzer/crates/hir-ty/src/method_resolution.rs      | 2 +-
 .../rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs     | 2 --
 .../rust-analyzer/crates/hir-ty/src/next_solver/interner.rs   | 1 -
 .../rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs    | 4 ++--
 5 files changed, 4 insertions(+), 7 deletions(-)

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 ae0113fcbd7f0..0df727a8e5c04 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
@@ -1473,7 +1473,7 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
             }
             TyKind::Foreign(type_alias) => {
                 let alias = match type_alias {
-                    SolverDefId::ForeignId(id) => id,
+                    SolverDefId::TypeAliasId(id) => id,
                     _ => unreachable!(),
                 };
                 let type_alias = db.type_alias_signature(alias);
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
index 49438151bbff5..8bd71df7c191d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
@@ -155,7 +155,7 @@ impl TyFingerprint {
                 rustc_ast_ir::Mutability::Not => TyFingerprint::RawPtr(Mutability::Not),
             },
             TyKind::Foreign(def) => {
-                let SolverDefId::ForeignId(def) = def else { unreachable!() };
+                let SolverDefId::TypeAliasId(def) = def else { unreachable!() };
                 TyFingerprint::ForeignType(crate::to_foreign_def_id(def))
             }
             TyKind::Dynamic(bounds, _, _) => {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
index 64eab2d6b8185..c9632ddcd4bb5 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
@@ -26,7 +26,6 @@ pub enum SolverDefId {
     StaticId(StaticId),
     TraitId(TraitId),
     TypeAliasId(TypeAliasId),
-    ForeignId(TypeAliasId),
     InternedClosureId(InternedClosureId),
     InternedCoroutineId(InternedCoroutineId),
     InternedOpaqueTyId(InternedOpaqueTyId),
@@ -73,7 +72,6 @@ impl TryFrom<SolverDefId> for GenericDefId {
             SolverDefId::StaticId(static_id) => GenericDefId::StaticId(static_id),
             SolverDefId::TraitId(trait_id) => GenericDefId::TraitId(trait_id),
             SolverDefId::TypeAliasId(type_alias_id) => GenericDefId::TypeAliasId(type_alias_id),
-            SolverDefId::ForeignId(_) => return Err(value),
             SolverDefId::InternedClosureId(_) => return Err(value),
             SolverDefId::InternedCoroutineId(_) => return Err(value),
             SolverDefId::InternedOpaqueTyId(_) => return Err(value),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
index 4fe0b54d68462..11c79ff742d6c 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
@@ -1148,7 +1148,6 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
         let container = match def_id {
             SolverDefId::FunctionId(it) => it.lookup(self.db()).container,
             SolverDefId::TypeAliasId(it) => it.lookup(self.db()).container,
-            SolverDefId::ForeignId(it) => it.lookup(self.db()).container,
             SolverDefId::ConstId(it) => it.lookup(self.db()).container,
             SolverDefId::InternedClosureId(it) => {
                 return self
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
index 8f6296b145409..de2671e28fb5e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
@@ -271,7 +271,7 @@ impl<'db> ChalkToNextSolver<'db, Ty<'db>> for chalk_ir::Ty<Interner> {
                     )
                 }
                 chalk_ir::TyKind::Foreign(foreign_def_id) => rustc_type_ir::TyKind::Foreign(
-                    SolverDefId::ForeignId(crate::from_foreign_def_id(*foreign_def_id)),
+                    SolverDefId::TypeAliasId(crate::from_foreign_def_id(*foreign_def_id)),
                 ),
                 chalk_ir::TyKind::Error => rustc_type_ir::TyKind::Error(ErrorGuaranteed),
                 chalk_ir::TyKind::Placeholder(placeholder_index) => {
@@ -1262,7 +1262,7 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
 
         rustc_type_ir::TyKind::Foreign(foreign) => {
             let def_id = match foreign {
-                SolverDefId::ForeignId(id) => id,
+                SolverDefId::TypeAliasId(id) => id,
                 _ => unreachable!(),
             };
             TyKind::Foreign(to_foreign_def_id(def_id))

From 6b49e11f885dfeab5b701561b79528e95c210a27 Mon Sep 17 00:00:00 2001
From: Ali Nazzal <ali90h7@pm.me>
Date: Tue, 26 Aug 2025 19:36:53 +0300
Subject: [PATCH 0300/1889] contributing: clarify when to update a branch vs
 avoid during review

---
 src/doc/rustc-dev-guide/src/contributing.md | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/contributing.md b/src/doc/rustc-dev-guide/src/contributing.md
index 963bef3af8de3..157dbbc13795b 100644
--- a/src/doc/rustc-dev-guide/src/contributing.md
+++ b/src/doc/rustc-dev-guide/src/contributing.md
@@ -154,13 +154,11 @@ The CI in rust-lang/rust applies your patches directly against the current maste
 not against the commit your branch is based on. This can lead to unexpected failures
 if your branch is outdated, even when there are no explicit merge conflicts.
 
-Before submitting or updating a PR, make sure to update your branch
-as mentioned [here](git.md#keeping-things-up-to-date) if it's significantly
-behind the master branch (e.g., more than 100 commits behind).
-This fetches the latest master branch and rebases your changes on top of it,
-ensuring your PR is tested against the latest code.
+Update your branch only when needed: when you have merge conflicts, upstream CI is broken and blocking your green PR, or a maintainer requests it. Avoid updating an already-green PR under review unless necessary. During review, make incremental commits to address feedback. Prefer to squash or rebase at the end, and do so when a reviewer requests it.
 
-After rebasing, it's recommended to [run the relevant tests locally](tests/intro.md) to catch any issues before CI runs.
+When updating, use `git push --force-with-lease` and leave a brief comment explaining what changed. Some repos prefer merging from `upstream/master` instead of rebasing; follow the project's conventions. See [keeping things up to date](git.md#keeping-things-up-to-date) for detailed instructions.
+
+After updating, run local checks (e.g., `mdbook build` for this repo) to catch issues before CI runs.
 
 ### r?
 

From 65f1a9f26747f3a573c1b1a4f4eea4a412f0ffdc Mon Sep 17 00:00:00 2001
From: Ali Nazzal <ali90h7@pm.me>
Date: Tue, 26 Aug 2025 19:41:08 +0300
Subject: [PATCH 0301/1889] contributing: restore tests/intro.md link; avoid
 'this repo' wording

---
 src/doc/rustc-dev-guide/src/contributing.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/contributing.md b/src/doc/rustc-dev-guide/src/contributing.md
index 157dbbc13795b..d0a32f71a3db0 100644
--- a/src/doc/rustc-dev-guide/src/contributing.md
+++ b/src/doc/rustc-dev-guide/src/contributing.md
@@ -154,11 +154,11 @@ The CI in rust-lang/rust applies your patches directly against the current maste
 not against the commit your branch is based on. This can lead to unexpected failures
 if your branch is outdated, even when there are no explicit merge conflicts.
 
-Update your branch only when needed: when you have merge conflicts, upstream CI is broken and blocking your green PR, or a maintainer requests it. Avoid updating an already-green PR under review unless necessary. During review, make incremental commits to address feedback. Prefer to squash or rebase at the end, and do so when a reviewer requests it.
+Update your branch only when needed: when you have merge conflicts, upstream CI is broken and blocking your green PR, or a maintainer requests it. Avoid updating an already-green PR under review unless necessary. During review, make incremental commits to address feedback. Prefer to squash or rebase only at the end, or when a reviewer requests it.
 
 When updating, use `git push --force-with-lease` and leave a brief comment explaining what changed. Some repos prefer merging from `upstream/master` instead of rebasing; follow the project's conventions. See [keeping things up to date](git.md#keeping-things-up-to-date) for detailed instructions.
 
-After updating, run local checks (e.g., `mdbook build` for this repo) to catch issues before CI runs.
+After rebasing, it's recommended to [run the relevant tests locally](tests/intro.md) to catch any issues before CI runs.
 
 ### r?
 

From a16500853434c8f38c14d6204457dc922a3c77ac Mon Sep 17 00:00:00 2001
From: Lieselotte <52315535+she3py@users.noreply.github.com>
Date: Tue, 26 Aug 2025 18:42:26 +0200
Subject: [PATCH 0302/1889] Allow `--print=crate-root-lint-levels`

---
 src/driver.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/driver.rs b/src/driver.rs
index c4076cbaa77b2..6bddcbfd94ce4 100644
--- a/src/driver.rs
+++ b/src/driver.rs
@@ -330,7 +330,8 @@ pub fn main() {
 
         // Do not run Clippy for Cargo's info queries so that invalid CLIPPY_ARGS are not cached
         // https://github.com/rust-lang/cargo/issues/14385
-        let info_query = has_arg(&orig_args, "-vV") || has_arg(&orig_args, "--print");
+        let info_query = has_arg(&orig_args, "-vV")
+            || arg_value(&orig_args, "--print", |val| val != "crate-root-lint-levels").is_some();
 
         let clippy_enabled = !cap_lints_allow && relevant_package && !info_query;
         if clippy_enabled {

From ff7081e6e25be74671d2fe775fe25a1015e4b32a Mon Sep 17 00:00:00 2001
From: Jeremy Smart <jeremy3141592@gmail.com>
Date: Tue, 26 Aug 2025 17:10:08 +0000
Subject: [PATCH 0303/1889] Update library/proc_macro/src/lib.rs

Co-authored-by: David Tolnay <dtolnay@gmail.com>
---
 library/proc_macro/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/proc_macro/src/lib.rs b/library/proc_macro/src/lib.rs
index 8178af15b7393..97dc482689781 100644
--- a/library/proc_macro/src/lib.rs
+++ b/library/proc_macro/src/lib.rs
@@ -383,7 +383,7 @@ macro_rules! extend_items {
             #[stable(feature = "token_stream_extend_tt_items", since = "CURRENT_RUSTC_VERSION")]
             impl Extend<$item> for TokenStream {
                 fn extend<T: IntoIterator<Item = $item>>(&mut self, iter: T) {
-                    self.extend(iter.into_iter().map(|i| TokenTree::$item(i)));
+                    self.extend(iter.into_iter().map(TokenTree::$item));
                 }
             }
         )*

From 28a248f4f3a2252942b46bcd611cf4c207f10926 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Tue, 26 Aug 2025 21:46:04 +0300
Subject: [PATCH 0304/1889] In highlight_related, when on an unsafe block,
 don't highlight unsafe operations of other unsafe blocks

---
 .../hir-ty/src/diagnostics/unsafe_check.rs    |  6 ++---
 .../rust-analyzer/crates/hir/src/semantics.rs | 23 +++++++++++++++++--
 .../crates/hir/src/source_analyzer.rs         |  2 +-
 .../crates/ide/src/highlight_related.rs       | 23 +++++++++++++++----
 4 files changed, 44 insertions(+), 10 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs
index 827585e50693a..d6d669258cc1f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs
@@ -119,11 +119,11 @@ pub fn unsafe_operations(
     def: DefWithBodyId,
     body: &Body,
     current: ExprId,
-    callback: &mut dyn FnMut(InsideUnsafeBlock),
+    callback: &mut dyn FnMut(ExprOrPatId, InsideUnsafeBlock),
 ) {
     let mut visitor_callback = |diag| {
-        if let UnsafeDiagnostic::UnsafeOperation { inside_unsafe_block, .. } = diag {
-            callback(inside_unsafe_block);
+        if let UnsafeDiagnostic::UnsafeOperation { inside_unsafe_block, node, .. } = diag {
+            callback(node, inside_unsafe_block);
         }
     };
     let mut visitor = UnsafeVisitor::new(db, infer, body, def, &mut visitor_callback);
diff --git a/src/tools/rust-analyzer/crates/hir/src/semantics.rs b/src/tools/rust-analyzer/crates/hir/src/semantics.rs
index 6d6e08100b044..3acbf81ada089 100644
--- a/src/tools/rust-analyzer/crates/hir/src/semantics.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/semantics.rs
@@ -28,13 +28,13 @@ use hir_expand::{
     mod_path::{ModPath, PathKind},
     name::AsName,
 };
-use hir_ty::diagnostics::unsafe_operations_for_body;
+use hir_ty::diagnostics::{unsafe_operations, unsafe_operations_for_body};
 use intern::{Interned, Symbol, sym};
 use itertools::Itertools;
 use rustc_hash::{FxHashMap, FxHashSet};
 use smallvec::{SmallVec, smallvec};
 use span::{Edition, FileId, SyntaxContext};
-use stdx::TupleExt;
+use stdx::{TupleExt, always};
 use syntax::{
     AstNode, AstToken, Direction, SyntaxKind, SyntaxNode, SyntaxNodePtr, SyntaxToken, TextRange,
     TextSize,
@@ -1765,6 +1765,25 @@ impl<'db> SemanticsImpl<'db> {
         res
     }
 
+    pub fn get_unsafe_ops_for_unsafe_block(&self, block: ast::BlockExpr) -> Vec<ExprOrPatSource> {
+        always!(block.unsafe_token().is_some());
+        let block = self.wrap_node_infile(ast::Expr::from(block));
+        let Some(def) = self.body_for(block.syntax()) else { return Vec::new() };
+        let def = def.into();
+        let (body, source_map) = self.db.body_with_source_map(def);
+        let infer = self.db.infer(def);
+        let Some(ExprOrPatId::ExprId(block)) = source_map.node_expr(block.as_ref()) else {
+            return Vec::new();
+        };
+        let mut res = Vec::default();
+        unsafe_operations(self.db, &infer, def, &body, block, &mut |node, _| {
+            if let Ok(node) = source_map.expr_or_pat_syntax(node) {
+                res.push(node);
+            }
+        });
+        res
+    }
+
     pub fn is_unsafe_macro_call(&self, macro_call: &ast::MacroCall) -> bool {
         let Some(mac) = self.resolve_macro_call(macro_call) else { return false };
         if mac.is_asm_like(self.db) {
diff --git a/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs b/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
index e3070c5f74ce2..dbc2539a9b91c 100644
--- a/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
@@ -1283,7 +1283,7 @@ impl<'db> SourceAnalyzer<'db> {
         {
             let mut is_unsafe = false;
             let mut walk_expr = |expr_id| {
-                unsafe_operations(db, infer, def, body, expr_id, &mut |inside_unsafe_block| {
+                unsafe_operations(db, infer, def, body, expr_id, &mut |_, inside_unsafe_block| {
                     is_unsafe |= inside_unsafe_block == InsideUnsafeBlock::No
                 })
             };
diff --git a/src/tools/rust-analyzer/crates/ide/src/highlight_related.rs b/src/tools/rust-analyzer/crates/ide/src/highlight_related.rs
index 9960e79a5380f..af1557f5a9a16 100644
--- a/src/tools/rust-analyzer/crates/ide/src/highlight_related.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/highlight_related.rs
@@ -805,10 +805,8 @@ pub(crate) fn highlight_unsafe_points(
         push_to_highlights(unsafe_token_file_id, Some(unsafe_token.text_range()));
 
         // highlight unsafe operations
-        if let Some(block) = block_expr
-            && let Some(body) = sema.body_for(InFile::new(unsafe_token_file_id, block.syntax()))
-        {
-            let unsafe_ops = sema.get_unsafe_ops(body);
+        if let Some(block) = block_expr {
+            let unsafe_ops = sema.get_unsafe_ops_for_unsafe_block(block);
             for unsafe_op in unsafe_ops {
                 push_to_highlights(unsafe_op.file_id, Some(unsafe_op.value.text_range()));
             }
@@ -2535,4 +2533,21 @@ fn foo() {
 "#,
         );
     }
+
+    #[test]
+    fn different_unsafe_block() {
+        check(
+            r#"
+fn main() {
+    unsafe$0 {
+ // ^^^^^^
+        *(0 as *const u8)
+     // ^^^^^^^^^^^^^^^^^
+    };
+    unsafe { *(1 as *const u8) };
+    unsafe { *(2 as *const u8) };
+}
+        "#,
+        );
+    }
 }

From a527e9f67f4fa9cb0748b7c0073d91a07d392ac6 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Tue, 26 Aug 2025 22:33:18 +0200
Subject: [PATCH 0305/1889] Preserve `unsafe` blocks in `option_map_unit`
 suggestion

---
 clippy_lints/src/map_unit_fn.rs            | 21 +++++++++++++--------
 tests/ui/option_map_unit_fn_fixable.fixed  |  9 +++++++++
 tests/ui/option_map_unit_fn_fixable.rs     |  9 +++++++++
 tests/ui/option_map_unit_fn_fixable.stderr | 18 +++++++++++++++++-
 4 files changed, 48 insertions(+), 9 deletions(-)

diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs
index af6a1b07a4929..39e5289c62ae4 100644
--- a/clippy_lints/src/map_unit_fn.rs
+++ b/clippy_lints/src/map_unit_fn.rs
@@ -116,8 +116,10 @@ fn is_unit_expression(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
 /// The expression inside a closure may or may not have surrounding braces and
 /// semicolons, which causes problems when generating a suggestion. Given an
 /// expression that evaluates to '()' or '!', recursively remove useless braces
-/// and semi-colons until is suitable for including in the suggestion template
-fn reduce_unit_expression(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<Span> {
+/// and semi-colons until is suitable for including in the suggestion template.
+/// The `bool` is `true` when the resulting `span` needs to be enclosed in an
+/// `unsafe` block.
+fn reduce_unit_expression(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<(Span, bool)> {
     if !is_unit_expression(cx, expr) {
         return None;
     }
@@ -125,22 +127,24 @@ fn reduce_unit_expression(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<
     match expr.kind {
         hir::ExprKind::Call(_, _) | hir::ExprKind::MethodCall(..) => {
             // Calls can't be reduced any more
-            Some(expr.span)
+            Some((expr.span, false))
         },
         hir::ExprKind::Block(block, _) => {
+            let is_unsafe = matches!(block.rules, hir::BlockCheckMode::UnsafeBlock(_));
             match (block.stmts, block.expr.as_ref()) {
                 ([], Some(inner_expr)) => {
                     // If block only contains an expression,
                     // reduce `{ X }` to `X`
                     reduce_unit_expression(cx, inner_expr)
+                        .map(|(span, inner_is_unsafe)| (span, inner_is_unsafe || is_unsafe))
                 },
                 ([inner_stmt], None) => {
                     // If block only contains statements,
                     // reduce `{ X; }` to `X` or `X;`
                     match inner_stmt.kind {
-                        hir::StmtKind::Let(local) => Some(local.span),
-                        hir::StmtKind::Expr(e) => Some(e.span),
-                        hir::StmtKind::Semi(..) => Some(inner_stmt.span),
+                        hir::StmtKind::Let(local) => Some((local.span, is_unsafe)),
+                        hir::StmtKind::Expr(e) => Some((e.span, is_unsafe)),
+                        hir::StmtKind::Semi(..) => Some((inner_stmt.span, is_unsafe)),
                         hir::StmtKind::Item(..) => None,
                     }
                 },
@@ -228,10 +232,11 @@ fn lint_map_unit_fn(
         let msg = suggestion_msg("closure", map_type);
 
         span_lint_and_then(cx, lint, expr.span, msg, |diag| {
-            if let Some(reduced_expr_span) = reduce_unit_expression(cx, closure_expr) {
+            if let Some((reduced_expr_span, is_unsafe)) = reduce_unit_expression(cx, closure_expr) {
                 let mut applicability = Applicability::MachineApplicable;
+                let (prefix_is_unsafe, suffix_is_unsafe) = if is_unsafe { ("unsafe { ", " }") } else { ("", "") };
                 let suggestion = format!(
-                    "if let {0}({1}) = {2} {{ {3} }}",
+                    "if let {0}({1}) = {2} {{ {prefix_is_unsafe}{3}{suffix_is_unsafe} }}",
                     variant,
                     snippet_with_applicability(cx, binding.pat.span, "_", &mut applicability),
                     snippet_with_applicability(cx, var_arg.span, "_", &mut applicability),
diff --git a/tests/ui/option_map_unit_fn_fixable.fixed b/tests/ui/option_map_unit_fn_fixable.fixed
index 55c1b8f110ced..340be7c7e932a 100644
--- a/tests/ui/option_map_unit_fn_fixable.fixed
+++ b/tests/ui/option_map_unit_fn_fixable.fixed
@@ -102,4 +102,13 @@ fn option_map_unit_fn() {
     //~^ option_map_unit_fn
 }
 
+fn issue15568() {
+    unsafe fn f(_: u32) {}
+    let x = Some(3);
+    if let Some(x) = x { unsafe { f(x) } }
+    //~^ option_map_unit_fn
+    if let Some(x) = x { unsafe { f(x) } }
+    //~^ option_map_unit_fn
+}
+
 fn main() {}
diff --git a/tests/ui/option_map_unit_fn_fixable.rs b/tests/ui/option_map_unit_fn_fixable.rs
index 5ed47e4c60b51..d902c87379b77 100644
--- a/tests/ui/option_map_unit_fn_fixable.rs
+++ b/tests/ui/option_map_unit_fn_fixable.rs
@@ -102,4 +102,13 @@ fn option_map_unit_fn() {
     //~^ option_map_unit_fn
 }
 
+fn issue15568() {
+    unsafe fn f(_: u32) {}
+    let x = Some(3);
+    x.map(|x| unsafe { f(x) });
+    //~^ option_map_unit_fn
+    x.map(|x| unsafe { { f(x) } });
+    //~^ option_map_unit_fn
+}
+
 fn main() {}
diff --git a/tests/ui/option_map_unit_fn_fixable.stderr b/tests/ui/option_map_unit_fn_fixable.stderr
index 3f7abae34eea7..2405aa9a7ccfa 100644
--- a/tests/ui/option_map_unit_fn_fixable.stderr
+++ b/tests/ui/option_map_unit_fn_fixable.stderr
@@ -153,5 +153,21 @@ LL |     option().map(|value| println!("{:?}", value));
    |     |
    |     help: try: `if let Some(value) = option() { println!("{:?}", value) }`
 
-error: aborting due to 19 previous errors
+error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
+  --> tests/ui/option_map_unit_fn_fixable.rs:108:5
+   |
+LL |     x.map(|x| unsafe { f(x) });
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^-
+   |     |
+   |     help: try: `if let Some(x) = x { unsafe { f(x) } }`
+
+error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
+  --> tests/ui/option_map_unit_fn_fixable.rs:110:5
+   |
+LL |     x.map(|x| unsafe { { f(x) } });
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
+   |     |
+   |     help: try: `if let Some(x) = x { unsafe { f(x) } }`
+
+error: aborting due to 21 previous errors
 

From 27d005a1710e7ccd81020baca635475856485f20 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Wed, 27 Aug 2025 00:34:53 +0200
Subject: [PATCH 0306/1889] Document `is_unit_expr()`

---
 clippy_utils/src/lib.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index e038a33dca39c..df47b9f7e33bb 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -309,6 +309,7 @@ pub fn is_lang_item_or_ctor(cx: &LateContext<'_>, did: DefId, item: LangItem) ->
     cx.tcx.lang_items().get(item) == Some(did)
 }
 
+/// Checks if `expr` is an empty block or an empty tuple.
 pub fn is_unit_expr(expr: &Expr<'_>) -> bool {
     matches!(
         expr.kind,

From bb8ba698f54421b0b1d7bee5b91f48f16182650f Mon Sep 17 00:00:00 2001
From: Zihan <zihanli0822@gmail.com>
Date: Mon, 25 Aug 2025 23:59:17 -0400
Subject: [PATCH 0307/1889] `unit_cmp`: don't lint on explicitly written unit
 expr

changelog: [`unit_cmp`]: don't lint on explicitly written unit expr

Signed-off-by: Zihan <zihanli0822@gmail.com>
---
 clippy_lints/src/unit_types/unit_cmp.rs |  9 ++++++---
 tests/ui/unit_cmp.rs                    | 17 +++++++++++++++++
 tests/ui/unit_cmp.stderr                | 20 +++++++++++++++++++-
 3 files changed, 42 insertions(+), 4 deletions(-)

diff --git a/clippy_lints/src/unit_types/unit_cmp.rs b/clippy_lints/src/unit_types/unit_cmp.rs
index 48b532968cb57..38716519e23b6 100644
--- a/clippy_lints/src/unit_types/unit_cmp.rs
+++ b/clippy_lints/src/unit_types/unit_cmp.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::macros::{find_assert_eq_args, root_macro_call_first_node};
-use clippy_utils::sym;
+use clippy_utils::{is_unit_expr, sym};
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
 
@@ -16,10 +16,13 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
                 sym::assert_ne_macro | sym::debug_assert_ne_macro => "fail",
                 _ => return,
             };
-            let Some((left, _, _)) = find_assert_eq_args(cx, expr, macro_call.expn) else {
+            let Some((lhs, rhs, _)) = find_assert_eq_args(cx, expr, macro_call.expn) else {
                 return;
             };
-            if !cx.typeck_results().expr_ty(left).is_unit() {
+            if is_unit_expr(lhs) || is_unit_expr(rhs) {
+                return;
+            }
+            if !cx.typeck_results().expr_ty(lhs).is_unit() {
                 return;
             }
             span_lint(
diff --git a/tests/ui/unit_cmp.rs b/tests/ui/unit_cmp.rs
index 93f5b87c3d2a7..0a0fe3a1990b0 100644
--- a/tests/ui/unit_cmp.rs
+++ b/tests/ui/unit_cmp.rs
@@ -68,3 +68,20 @@ fn main() {
         }
     );
 }
+
+fn issue15559() {
+    fn foo() {}
+    assert_eq!(
+        //~^ unit_cmp
+        {
+            1;
+        },
+        foo()
+    );
+    assert_eq!(foo(), foo());
+    //~^ unit_cmp
+
+    // don't lint on explicitly written unit expr
+    assert_eq!(foo(), ());
+    assert_ne!((), ContainsUnit(()).0);
+}
diff --git a/tests/ui/unit_cmp.stderr b/tests/ui/unit_cmp.stderr
index 8f26749fd8605..21aa9dce1510f 100644
--- a/tests/ui/unit_cmp.stderr
+++ b/tests/ui/unit_cmp.stderr
@@ -71,5 +71,23 @@ LL | |             true;
 LL | |     );
    | |_____^
 
-error: aborting due to 6 previous errors
+error: `assert_eq` of unit values detected. This will always succeed
+  --> tests/ui/unit_cmp.rs:74:5
+   |
+LL | /     assert_eq!(
+LL | |
+LL | |         {
+LL | |             1;
+LL | |         },
+LL | |         foo()
+LL | |     );
+   | |_____^
+
+error: `assert_eq` of unit values detected. This will always succeed
+  --> tests/ui/unit_cmp.rs:81:5
+   |
+LL |     assert_eq!(foo(), foo());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 8 previous errors
 

From a10bdf93b153211e5daf1b1c147b955e690e30ef Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Wed, 27 Aug 2025 04:53:08 +0000
Subject: [PATCH 0308/1889] Prepare for merging from rust-lang/rust

This updates the rust-version file to 269d5b56bcfdf2be82213e72ef9a2e4c592a8c6b.
---
 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 f412399cc8c39..5e83354000247 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-a1dbb443527bd126452875eb5d5860c1d001d761
+269d5b56bcfdf2be82213e72ef9a2e4c592a8c6b

From bcfc9b5073a92bbb4b1e4db2eab535357d8973ad Mon Sep 17 00:00:00 2001
From: James Barford-Evans <james.barford-evans@arm.com>
Date: Thu, 21 Aug 2025 14:32:10 +0100
Subject: [PATCH 0309/1889] inline at the callsite & warn when target features
 mismatch

Co-authored-by: Jamie Cunliffe <Jamie.Cunliffe@arm.com>
---
 compiler/rustc_codegen_llvm/src/attributes.rs | 31 ++++---
 compiler/rustc_codegen_llvm/src/builder.rs    | 29 +++++-
 .../rustc_codegen_ssa/src/codegen_attrs.rs    |  9 +-
 compiler/rustc_feature/src/unstable.rs        |  2 +
 compiler/rustc_lint_defs/src/builtin.rs       | 54 ++++++++++++
 .../src/middle/codegen_fn_attrs.rs            |  2 +-
 .../check_inline_always_target_features.rs    | 88 +++++++++++++++++++
 compiler/rustc_mir_transform/src/errors.rs    | 41 +++++++++
 compiler/rustc_mir_transform/src/lib.rs       |  4 +
 compiler/rustc_span/src/symbol.rs             |  1 +
 ...ature-gate-target-feature-inline-always.rs |  9 ++
 ...e-gate-target-feature-inline-always.stderr | 13 +++
 .../inline-always.aarch64.stderr              | 60 +++++++++++++
 tests/ui/target-feature/inline-always.rs      | 54 ++++++++++++
 tests/ui/target-feature/invalid-attribute.rs  |  2 +
 .../target-feature/invalid-attribute.stderr   | 28 +++---
 16 files changed, 400 insertions(+), 27 deletions(-)
 create mode 100644 compiler/rustc_mir_transform/src/check_inline_always_target_features.rs
 create mode 100644 tests/ui/feature-gates/feature-gate-target-feature-inline-always.rs
 create mode 100644 tests/ui/feature-gates/feature-gate-target-feature-inline-always.stderr
 create mode 100644 tests/ui/target-feature/inline-always.aarch64.stderr
 create mode 100644 tests/ui/target-feature/inline-always.rs

diff --git a/compiler/rustc_codegen_llvm/src/attributes.rs b/compiler/rustc_codegen_llvm/src/attributes.rs
index 5affb26483aad..9f2d37d39d87a 100644
--- a/compiler/rustc_codegen_llvm/src/attributes.rs
+++ b/compiler/rustc_codegen_llvm/src/attributes.rs
@@ -29,8 +29,18 @@ pub(crate) fn apply_to_callsite(callsite: &Value, idx: AttributePlace, attrs: &[
 }
 
 /// Get LLVM attribute for the provided inline heuristic.
-#[inline]
-fn inline_attr<'ll>(cx: &CodegenCx<'ll, '_>, inline: InlineAttr) -> Option<&'ll Attribute> {
+pub(crate) fn inline_attr<'ll, 'tcx>(
+    cx: &CodegenCx<'ll, 'tcx>,
+    instance: ty::Instance<'tcx>,
+) -> Option<&'ll Attribute> {
+    // `optnone` requires `noinline`
+    let codegen_fn_attrs = cx.tcx.codegen_fn_attrs(instance.def_id());
+    let inline = match (codegen_fn_attrs.inline, &codegen_fn_attrs.optimize) {
+        (_, OptimizeAttr::DoNotOptimize) => InlineAttr::Never,
+        (InlineAttr::None, _) if instance.def.requires_inline(cx.tcx) => InlineAttr::Hint,
+        (inline, _) => inline,
+    };
+
     if !cx.tcx.sess.opts.unstable_opts.inline_llvm {
         // disable LLVM inlining
         return Some(AttributeKind::NoInline.create_attr(cx.llcx));
@@ -346,14 +356,6 @@ pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>(
         OptimizeAttr::Speed => {}
     }
 
-    // `optnone` requires `noinline`
-    let inline = match (codegen_fn_attrs.inline, &codegen_fn_attrs.optimize) {
-        (_, OptimizeAttr::DoNotOptimize) => InlineAttr::Never,
-        (InlineAttr::None, _) if instance.def.requires_inline(cx.tcx) => InlineAttr::Hint,
-        (inline, _) => inline,
-    };
-    to_add.extend(inline_attr(cx, inline));
-
     if cx.sess().must_emit_unwind_tables() {
         to_add.push(uwtable_attr(cx.llcx, cx.sess().opts.unstable_opts.use_sync_unwind));
     }
@@ -488,6 +490,14 @@ pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>(
     let function_features =
         codegen_fn_attrs.target_features.iter().map(|f| f.name.as_str()).collect::<Vec<&str>>();
 
+    // Apply function attributes as per usual if there are no user defined
+    // target features otherwise this will get applied at the callsite.
+    if function_features.is_empty() {
+        if let Some(inline_attr) = inline_attr(cx, instance) {
+            to_add.push(inline_attr);
+        }
+    }
+
     let function_features = function_features
         .iter()
         // Convert to LLVMFeatures and filter out unavailable ones
@@ -517,6 +527,7 @@ pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>(
     let function_features = function_features.iter().map(|s| s.as_str());
     let target_features: String =
         global_features.chain(function_features).intersperse(",").collect();
+
     if !target_features.is_empty() {
         to_add.push(llvm::CreateAttrStringValue(cx.llcx, "target-features", &target_features));
     }
diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
index 37379586d5828..7d0691366e602 100644
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -1392,7 +1392,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
     fn call(
         &mut self,
         llty: &'ll Type,
-        fn_attrs: Option<&CodegenFnAttrs>,
+        fn_call_attrs: Option<&CodegenFnAttrs>,
         fn_abi: Option<&FnAbi<'tcx, Ty<'tcx>>>,
         llfn: &'ll Value,
         args: &[&'ll Value],
@@ -1409,10 +1409,10 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         }
 
         // Emit CFI pointer type membership test
-        self.cfi_type_test(fn_attrs, fn_abi, instance, llfn);
+        self.cfi_type_test(fn_call_attrs, fn_abi, instance, llfn);
 
         // Emit KCFI operand bundle
-        let kcfi_bundle = self.kcfi_operand_bundle(fn_attrs, fn_abi, instance, llfn);
+        let kcfi_bundle = self.kcfi_operand_bundle(fn_call_attrs, fn_abi, instance, llfn);
         if let Some(kcfi_bundle) = kcfi_bundle.as_ref().map(|b| b.as_ref()) {
             bundles.push(kcfi_bundle);
         }
@@ -1429,6 +1429,29 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
                 c"".as_ptr(),
             )
         };
+
+        if let Some(instance) = instance {
+            // Attributes on the function definition being called
+            let fn_defn_attrs = self.cx.tcx.codegen_fn_attrs(instance.def_id());
+            if let Some(fn_call_attrs) = fn_call_attrs
+                && !fn_call_attrs.target_features.is_empty()
+                // If there is an inline attribute and a target feature that matches
+                // we will add the attribute to the callsite otherwise we'll omit
+                // this and not add the attribute to prevent soundness issues.
+                && let Some(inlining_rule) = attributes::inline_attr(&self.cx, instance)
+                && self.cx.tcx.is_target_feature_call_safe(
+                    &fn_call_attrs.target_features,
+                    &fn_defn_attrs.target_features,
+                )
+            {
+                attributes::apply_to_callsite(
+                    call,
+                    llvm::AttributePlace::Function,
+                    &[inlining_rule],
+                );
+            }
+        }
+
         if let Some(fn_abi) = fn_abi {
             fn_abi.apply_attrs_callsite(self, call);
         }
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
index 961bb788149d3..008340e614de4 100644
--- a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
+++ b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -428,9 +428,16 @@ fn check_result(
     // llvm/llvm-project#70563).
     if !codegen_fn_attrs.target_features.is_empty()
         && matches!(codegen_fn_attrs.inline, InlineAttr::Always)
+        && !tcx.features().target_feature_inline_always()
         && let Some(span) = interesting_spans.inline
     {
-        tcx.dcx().span_err(span, "cannot use `#[inline(always)]` with `#[target_feature]`");
+        feature_err(
+            tcx.sess,
+            sym::target_feature_inline_always,
+            span,
+            "cannot use `#[inline(always)]` with `#[target_feature]`",
+        )
+        .emit();
     }
 
     // warn that inline has no effect when no_sanitize is present
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 92b435b4b0178..03ae57c24fad4 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -645,6 +645,8 @@ declare_features! (
     (unstable, super_let, "1.88.0", Some(139076)),
     /// Allows subtrait items to shadow supertrait items.
     (unstable, supertrait_item_shadowing, "1.86.0", Some(89151)),
+    /// Allows the use of target_feature when a function is marked inline(always).
+    (unstable, target_feature_inline_always, "CURRENT_RUSTC_VERSION", Some(145574)),
     /// Allows using `#[thread_local]` on `static` items.
     (unstable, thread_local, "1.0.0", Some(29594)),
     /// Allows defining `trait X = A + B;` alias items.
diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs
index 97aa106596799..ac646aba15695 100644
--- a/compiler/rustc_lint_defs/src/builtin.rs
+++ b/compiler/rustc_lint_defs/src/builtin.rs
@@ -5138,3 +5138,57 @@ declare_lint! {
     "detects tail calls of functions marked with `#[track_caller]`",
     @feature_gate = explicit_tail_calls;
 }
+declare_lint! {
+    /// The `inline_always_mismatching_target_features` lint will trigger when a
+    /// function with the `#[inline(always)]` and `#[target_feature(enable = "...")]`
+    /// attributes is called and cannot be inlined due to missing target features in the caller.
+    ///
+    /// ### Example
+    ///
+    /// ```rust,ignore (fails on x86_64)
+    /// #[inline(always)]
+    /// #[target_feature(enable = "fp16")]
+    /// unsafe fn callee() {
+    ///     // operations using fp16 types
+    /// }
+    ///
+    /// // Caller does not enable the required target feature
+    /// fn caller() {
+    ///     unsafe { callee(); }
+    /// }
+    ///
+    /// fn main() {
+    ///     caller();
+    /// }
+    /// ```
+    ///
+    /// This will produce:
+    ///
+    /// ```text
+    /// warning: call to `#[inline(always)]`-annotated `callee` requires the same target features. Function will not have `alwaysinline` attribute applied
+    ///   --> $DIR/builtin.rs:5192:14
+    ///    |
+    /// 10 |     unsafe { callee(); }
+    ///    |              ^^^^^^^^
+    ///    |
+    /// note: `fp16` target feature enabled in `callee` here but missing from `caller`
+    ///   --> $DIR/builtin.rs:5185:1
+    ///    |
+    /// 3  | #[target_feature(enable = "fp16")]
+    ///    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    /// 4  | unsafe fn callee() {
+    ///    | ------------------
+    ///    = note: `#[warn(inline_always_mismatching_target_features)]` on by default
+    /// warning: 1 warning emitted
+    /// ```
+    ///
+    /// ### Explanation
+    ///
+    /// Inlining a function with a target feature attribute into a caller that
+    /// lacks the corresponding target feature can lead to unsound behavior.
+    /// LLVM may select the wrong instructions or registers, or reorder
+    /// operations, potentially resulting in runtime errors.
+    pub INLINE_ALWAYS_MISMATCHING_TARGET_FEATURES,
+    Warn,
+    r#"detects when a function annotated with `#[inline(always)]` and `#[target_feature(enable = "..")]` is inlined into a caller without the required target feature"#,
+}
diff --git a/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs b/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
index 866736f74a051..8b4503073b0de 100644
--- a/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
+++ b/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
@@ -82,7 +82,7 @@ pub enum TargetFeatureKind {
     Forced,
 }
 
-#[derive(Copy, Clone, Debug, TyEncodable, TyDecodable, HashStable)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, TyEncodable, TyDecodable, HashStable)]
 pub struct TargetFeature {
     /// The name of the target feature (e.g. "avx")
     pub name: Symbol,
diff --git a/compiler/rustc_mir_transform/src/check_inline_always_target_features.rs b/compiler/rustc_mir_transform/src/check_inline_always_target_features.rs
new file mode 100644
index 0000000000000..abad28f0a8f83
--- /dev/null
+++ b/compiler/rustc_mir_transform/src/check_inline_always_target_features.rs
@@ -0,0 +1,88 @@
+use rustc_hir::attrs::InlineAttr;
+use rustc_middle::middle::codegen_fn_attrs::{TargetFeature, TargetFeatureKind};
+use rustc_middle::mir::{Body, TerminatorKind};
+use rustc_middle::ty::{self, TyCtxt};
+
+use crate::pass_manager::MirLint;
+
+pub(super) struct CheckInlineAlwaysTargetFeature;
+
+impl<'tcx> MirLint<'tcx> for CheckInlineAlwaysTargetFeature {
+    fn run_lint(&self, tcx: TyCtxt<'tcx>, body: &Body<'tcx>) {
+        check_inline_always_target_features(tcx, body)
+    }
+}
+
+/// `#[target_feature]`-annotated functions can be marked `#[inline]` and will only be inlined if
+/// the target features match (as well as all of the other inlining heuristics). `#[inline(always)]`
+/// will always inline regardless of matching target features, which can result in errors from LLVM.
+/// However, it is desirable to be able to always annotate certain functions (e.g. SIMD intrinsics)
+/// as `#[inline(always)]` but check the target features match in Rust to avoid the LLVM errors.
+///
+/// We check the caller and callee target features to ensure that this can
+/// be done or emit a lint.
+#[inline]
+fn check_inline_always_target_features<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'tcx>) {
+    let caller_def_id = body.source.def_id().expect_local();
+    if !tcx.def_kind(caller_def_id).has_codegen_attrs() {
+        return;
+    }
+
+    let caller_codegen_fn_attrs = tcx.codegen_fn_attrs(caller_def_id);
+
+    for bb in body.basic_blocks.iter() {
+        let terminator = bb.terminator();
+        match &terminator.kind {
+            TerminatorKind::Call { func, .. } | TerminatorKind::TailCall { func, .. } => {
+                let fn_ty = func.ty(body, tcx);
+                let ty::FnDef(callee_def_id, _) = *fn_ty.kind() else {
+                    continue;
+                };
+
+                if !tcx.def_kind(callee_def_id).has_codegen_attrs() {
+                    continue;
+                }
+                let callee_codegen_fn_attrs = tcx.codegen_fn_attrs(callee_def_id);
+                if callee_codegen_fn_attrs.inline != InlineAttr::Always
+                    || callee_codegen_fn_attrs.target_features.is_empty()
+                {
+                    continue;
+                }
+
+                // Scan the users defined target features and ensure they
+                // match the caller.
+                if tcx.is_target_feature_call_safe(
+                    &callee_codegen_fn_attrs.target_features,
+                    &caller_codegen_fn_attrs
+                        .target_features
+                        .iter()
+                        .cloned()
+                        .chain(tcx.sess.target_features.iter().map(|feat| TargetFeature {
+                            name: *feat,
+                            kind: TargetFeatureKind::Implied,
+                        }))
+                        .collect::<Vec<_>>(),
+                ) {
+                    continue;
+                }
+
+                let callee_only: Vec<_> = callee_codegen_fn_attrs
+                    .target_features
+                    .iter()
+                    .filter(|it| !caller_codegen_fn_attrs.target_features.contains(it))
+                    .filter(|it| !matches!(it.kind, TargetFeatureKind::Implied))
+                    .map(|it| it.name.as_str())
+                    .collect();
+
+                crate::errors::emit_inline_always_target_feature_diagnostic(
+                    tcx,
+                    terminator.source_info.span,
+                    callee_def_id,
+                    caller_def_id.into(),
+                    &callee_only,
+                );
+            }
+            _ => (),
+        }
+    }
+}
diff --git a/compiler/rustc_mir_transform/src/errors.rs b/compiler/rustc_mir_transform/src/errors.rs
index ad9635aae330d..775f5f9a7cf10 100644
--- a/compiler/rustc_mir_transform/src/errors.rs
+++ b/compiler/rustc_mir_transform/src/errors.rs
@@ -2,6 +2,7 @@ use rustc_errors::codes::*;
 use rustc_errors::{Diag, LintDiagnostic};
 use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
 use rustc_middle::mir::AssertKind;
+use rustc_middle::query::Key;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::lint::{self, Lint};
 use rustc_span::def_id::DefId;
@@ -9,6 +10,46 @@ use rustc_span::{Ident, Span, Symbol};
 
 use crate::fluent_generated as fluent;
 
+/// Emit diagnostic for calls to `#[inline(always)]`-annotated functions with a
+/// `#[target_feature]` attribute where the caller enables a different set of target features.
+pub(crate) fn emit_inline_always_target_feature_diagnostic<'a, 'tcx>(
+    tcx: TyCtxt<'tcx>,
+    call_span: Span,
+    callee_def_id: DefId,
+    caller_def_id: DefId,
+    callee_only: &[&'a str],
+) {
+    let callee = tcx.def_path_str(callee_def_id);
+    let caller = tcx.def_path_str(caller_def_id);
+
+    tcx.node_span_lint(
+        lint::builtin::INLINE_ALWAYS_MISMATCHING_TARGET_FEATURES,
+        tcx.local_def_id_to_hir_id(caller_def_id.as_local().unwrap()),
+        call_span,
+        |lint| {
+            lint.primary_message(format!(
+                "call to `#[inline(always)]`-annotated `{callee}` \
+                requires the same target features to be inlined"
+            ));
+            lint.note("function will not be inlined");
+
+            lint.note(format!(
+                "the following target features are on `{callee}` but missing from `{caller}`: {}",
+                callee_only.join(", ")
+            ));
+            lint.span_note(callee_def_id.default_span(tcx), format!("`{callee}` is defined here"));
+
+            let feats = callee_only.join(",");
+            lint.span_suggestion(
+                tcx.def_span(caller_def_id).shrink_to_lo(),
+                format!("add `#[target_feature]` attribute to `{caller}`"),
+                format!("#[target_feature(enable = \"{feats}\")]\n"),
+                lint::Applicability::MaybeIncorrect,
+            );
+        },
+    );
+}
+
 #[derive(LintDiagnostic)]
 #[diag(mir_transform_unconditional_recursion)]
 #[help]
diff --git a/compiler/rustc_mir_transform/src/lib.rs b/compiler/rustc_mir_transform/src/lib.rs
index 08f25276cecc1..d91eedb5960ff 100644
--- a/compiler/rustc_mir_transform/src/lib.rs
+++ b/compiler/rustc_mir_transform/src/lib.rs
@@ -116,6 +116,7 @@ declare_passes! {
     mod add_subtyping_projections : Subtyper;
     mod check_inline : CheckForceInline;
     mod check_call_recursion : CheckCallRecursion, CheckDropRecursion;
+    mod check_inline_always_target_features: CheckInlineAlwaysTargetFeature;
     mod check_alignment : CheckAlignment;
     mod check_enums : CheckEnums;
     mod check_const_item_mutation : CheckConstItemMutation;
@@ -383,6 +384,9 @@ fn mir_built(tcx: TyCtxt<'_>, def: LocalDefId) -> &Steal<Body<'_>> {
             // MIR-level lints.
             &Lint(check_inline::CheckForceInline),
             &Lint(check_call_recursion::CheckCallRecursion),
+            // Check callee's target features match callers target features when
+            // using `#[inline(always)]`
+            &Lint(check_inline_always_target_features::CheckInlineAlwaysTargetFeature),
             &Lint(check_packed_ref::CheckPackedRef),
             &Lint(check_const_item_mutation::CheckConstItemMutation),
             &Lint(function_item_references::FunctionItemReferences),
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 585968044bf24..bb32737a65c0a 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -2154,6 +2154,7 @@ symbols! {
         target_family,
         target_feature,
         target_feature_11,
+        target_feature_inline_always,
         target_has_atomic,
         target_has_atomic_equal_alignment,
         target_has_atomic_load_store,
diff --git a/tests/ui/feature-gates/feature-gate-target-feature-inline-always.rs b/tests/ui/feature-gates/feature-gate-target-feature-inline-always.rs
new file mode 100644
index 0000000000000..181f9a210003f
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-target-feature-inline-always.rs
@@ -0,0 +1,9 @@
+//@ only-aarch64
+#[inline(always)]
+//~^ ERROR cannot use `#[inline(always)]` with `#[target_feature]`
+#[target_feature(enable="fp16")]
+fn test() {
+
+}
+
+fn main() { }
diff --git a/tests/ui/feature-gates/feature-gate-target-feature-inline-always.stderr b/tests/ui/feature-gates/feature-gate-target-feature-inline-always.stderr
new file mode 100644
index 0000000000000..de54844bc291d
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-target-feature-inline-always.stderr
@@ -0,0 +1,13 @@
+error[E0658]: cannot use `#[inline(always)]` with `#[target_feature]`
+  --> $DIR/feature-gate-target-feature-inline-always.rs:2:1
+   |
+LL | #[inline(always)]
+   | ^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #145574 <https://github.com/rust-lang/rust/issues/145574> for more information
+   = help: add `#![feature(target_feature_inline_always)]` 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/target-feature/inline-always.aarch64.stderr b/tests/ui/target-feature/inline-always.aarch64.stderr
new file mode 100644
index 0000000000000..a9ffb425c5237
--- /dev/null
+++ b/tests/ui/target-feature/inline-always.aarch64.stderr
@@ -0,0 +1,60 @@
+warning: call to `#[inline(always)]`-annotated `target_feature_identity` requires the same target features to be inlined
+  --> $DIR/inline-always.rs:19:5
+   |
+LL |     target_feature_identity();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: function will not be inlined
+   = note: the following target features are on `target_feature_identity` but missing from `call_no_target_features`: neon, fp16
+note: `target_feature_identity` is defined here
+  --> $DIR/inline-always.rs:16:1
+   |
+LL | pub unsafe fn target_feature_identity() {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: `#[warn(inline_always_mismatching_target_features)]` on by default
+help: add `#[target_feature]` attribute to `call_no_target_features`
+   |
+LL + #[target_feature(enable = "neon,fp16")]
+LL | unsafe fn call_no_target_features() {
+   |
+
+warning: call to `#[inline(always)]`-annotated `multiple_target_features` requires the same target features to be inlined
+  --> $DIR/inline-always.rs:22:5
+   |
+LL |     multiple_target_features();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: function will not be inlined
+   = note: the following target features are on `multiple_target_features` but missing from `call_no_target_features`: fp16, sve, rdm
+note: `multiple_target_features` is defined here
+  --> $DIR/inline-always.rs:52:1
+   |
+LL | fn multiple_target_features() {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: add `#[target_feature]` attribute to `call_no_target_features`
+   |
+LL + #[target_feature(enable = "fp16,sve,rdm")]
+LL | unsafe fn call_no_target_features() {
+   |
+
+warning: call to `#[inline(always)]`-annotated `multiple_target_features` requires the same target features to be inlined
+  --> $DIR/inline-always.rs:28:5
+   |
+LL |     multiple_target_features();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: function will not be inlined
+   = note: the following target features are on `multiple_target_features` but missing from `call_to_first_set`: rdm
+note: `multiple_target_features` is defined here
+  --> $DIR/inline-always.rs:52:1
+   |
+LL | fn multiple_target_features() {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: add `#[target_feature]` attribute to `call_to_first_set`
+   |
+LL + #[target_feature(enable = "rdm")]
+LL | unsafe fn call_to_first_set() {
+   |
+
+warning: 3 warnings emitted
+
diff --git a/tests/ui/target-feature/inline-always.rs b/tests/ui/target-feature/inline-always.rs
new file mode 100644
index 0000000000000..dbf46537caa13
--- /dev/null
+++ b/tests/ui/target-feature/inline-always.rs
@@ -0,0 +1,54 @@
+//@ add-core-stubs
+//@ build-pass
+//@ compile-flags: --crate-type=lib
+//@ revisions: aarch64
+//@[aarch64] compile-flags: --target aarch64-unknown-linux-gnu
+//@[aarch64] needs-llvm-components: aarch64
+
+#![feature(no_core, target_feature_inline_always)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+#[inline(always)]
+#[target_feature(enable = "neon,fp16")]
+pub unsafe fn target_feature_identity() {}
+
+unsafe fn call_no_target_features() {
+    target_feature_identity();
+    //~^ WARNING call to `#[inline(always)]`-annotated `target_feature_identity` requires the same target features to be inlined [inline_always_mismatching_target_features]
+    global_feature_enabled();
+    multiple_target_features();
+    //~^ WARNING call to `#[inline(always)]`-annotated `multiple_target_features` requires the same target features to be inlined [inline_always_mismatching_target_features]
+}
+
+#[target_feature(enable = "fp16,sve")]
+unsafe fn call_to_first_set() {
+    multiple_target_features();
+    //~^ WARNING call to `#[inline(always)]`-annotated `multiple_target_features` requires the same target features to be inlined [inline_always_mismatching_target_features]
+}
+
+/* You can't have "fhm" without "fp16" */
+#[target_feature(enable = "fhm")]
+unsafe fn mismatching_features() {
+    target_feature_identity()
+}
+
+#[target_feature(enable = "fp16")]
+unsafe fn matching_target_features() {
+    target_feature_identity()
+}
+
+#[inline(always)]
+#[target_feature(enable = "neon")]
+unsafe fn global_feature_enabled() {
+
+}
+
+#[inline(always)]
+#[target_feature(enable = "fp16,sve")]
+#[target_feature(enable="rdm")]
+fn multiple_target_features() {
+
+ }
diff --git a/tests/ui/target-feature/invalid-attribute.rs b/tests/ui/target-feature/invalid-attribute.rs
index b34a48aba2619..a958700231a37 100644
--- a/tests/ui/target-feature/invalid-attribute.rs
+++ b/tests/ui/target-feature/invalid-attribute.rs
@@ -61,6 +61,8 @@ trait Baz {}
 
 #[inline(always)]
 //~^ ERROR: cannot use `#[inline(always)]`
+//~| NOTE: see issue #145574 <https://github.com/rust-lang/rust/issues/145574> for more information
+//~| NOTE: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 #[target_feature(enable = "sse2")]
 unsafe fn test() {}
 
diff --git a/tests/ui/target-feature/invalid-attribute.stderr b/tests/ui/target-feature/invalid-attribute.stderr
index 7b75367b48c24..d85bccce4410a 100644
--- a/tests/ui/target-feature/invalid-attribute.stderr
+++ b/tests/ui/target-feature/invalid-attribute.stderr
@@ -106,7 +106,7 @@ LL | #[target_feature(enable = "sse2")]
    = help: `#[target_feature]` can only be applied to functions
 
 error: `#[target_feature]` attribute cannot be used on statics
-  --> $DIR/invalid-attribute.rs:67:1
+  --> $DIR/invalid-attribute.rs:69:1
    |
 LL | #[target_feature(enable = "sse2")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -114,7 +114,7 @@ LL | #[target_feature(enable = "sse2")]
    = help: `#[target_feature]` can only be applied to functions
 
 error: `#[target_feature]` attribute cannot be used on trait impl blocks
-  --> $DIR/invalid-attribute.rs:71:1
+  --> $DIR/invalid-attribute.rs:73:1
    |
 LL | #[target_feature(enable = "sse2")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -122,7 +122,7 @@ LL | #[target_feature(enable = "sse2")]
    = help: `#[target_feature]` can only be applied to functions
 
 error: `#[target_feature]` attribute cannot be used on inherent impl blocks
-  --> $DIR/invalid-attribute.rs:77:1
+  --> $DIR/invalid-attribute.rs:79:1
    |
 LL | #[target_feature(enable = "sse2")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -130,7 +130,7 @@ LL | #[target_feature(enable = "sse2")]
    = help: `#[target_feature]` can only be applied to functions
 
 error: `#[target_feature]` attribute cannot be used on expressions
-  --> $DIR/invalid-attribute.rs:98:5
+  --> $DIR/invalid-attribute.rs:100:5
    |
 LL |     #[target_feature(enable = "sse2")]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -138,18 +138,22 @@ LL |     #[target_feature(enable = "sse2")]
    = help: `#[target_feature]` can only be applied to functions
 
 error: `#[target_feature]` attribute cannot be used on closures
-  --> $DIR/invalid-attribute.rs:104:5
+  --> $DIR/invalid-attribute.rs:106:5
    |
 LL |     #[target_feature(enable = "sse2")]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: `#[target_feature]` can be applied to methods and functions
 
-error: cannot use `#[inline(always)]` with `#[target_feature]`
+error[E0658]: cannot use `#[inline(always)]` with `#[target_feature]`
   --> $DIR/invalid-attribute.rs:62:1
    |
 LL | #[inline(always)]
    | ^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #145574 <https://github.com/rust-lang/rust/issues/145574> for more information
+   = help: add `#![feature(target_feature_inline_always)]` 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: the feature named `foo` is not valid for this target
   --> $DIR/invalid-attribute.rs:20:18
@@ -158,7 +162,7 @@ LL | #[target_feature(enable = "foo")]
    |                  ^^^^^^^^^^^^^^ `foo` is not valid for this target
 
 error[E0046]: not all trait items implemented, missing: `foo`
-  --> $DIR/invalid-attribute.rs:73:1
+  --> $DIR/invalid-attribute.rs:75:1
    |
 LL | impl Quux for u8 {}
    | ^^^^^^^^^^^^^^^^ missing `foo` in implementation
@@ -167,7 +171,7 @@ LL |     fn foo();
    |     --------- `foo` from trait
 
 error: `#[target_feature(..)]` cannot be applied to safe trait method
-  --> $DIR/invalid-attribute.rs:87:5
+  --> $DIR/invalid-attribute.rs:89:5
    |
 LL |     #[target_feature(enable = "sse2")]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot be applied to safe trait method
@@ -176,13 +180,13 @@ LL |     fn foo() {}
    |     -------- not an `unsafe` function
 
 error[E0053]: method `foo` has an incompatible type for trait
-  --> $DIR/invalid-attribute.rs:90:5
+  --> $DIR/invalid-attribute.rs:92:5
    |
 LL |     fn foo() {}
    |     ^^^^^^^^ expected safe fn, found unsafe fn
    |
 note: type in trait
-  --> $DIR/invalid-attribute.rs:82:5
+  --> $DIR/invalid-attribute.rs:84:5
    |
 LL |     fn foo();
    |     ^^^^^^^^^
@@ -190,7 +194,7 @@ LL |     fn foo();
               found signature `#[target_features] fn()`
 
 error: the feature named `+sse2` is not valid for this target
-  --> $DIR/invalid-attribute.rs:109:18
+  --> $DIR/invalid-attribute.rs:111:18
    |
 LL | #[target_feature(enable = "+sse2")]
    |                  ^^^^^^^^^^^^^^^^ `+sse2` is not valid for this target
@@ -199,5 +203,5 @@ LL | #[target_feature(enable = "+sse2")]
 
 error: aborting due to 24 previous errors
 
-Some errors have detailed explanations: E0046, E0053, E0539.
+Some errors have detailed explanations: E0046, E0053, E0539, E0658.
 For more information about an error, try `rustc --explain E0046`.

From 61ce0c5dc25aeb34cae36d2ea4587d6dbbfb5586 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sun, 13 Jul 2025 16:29:39 +0200
Subject: [PATCH 0310/1889] `map_identity`: suggest making the variable mutable
 when necessary

---
 clippy_lints/src/methods/map_identity.rs | 96 ++++++++++++++++++------
 tests/ui/map_identity.fixed              | 20 ++++-
 tests/ui/map_identity.rs                 | 16 +++-
 tests/ui/map_identity.stderr             | 66 ++++++++++------
 4 files changed, 148 insertions(+), 50 deletions(-)

diff --git a/clippy_lints/src/methods/map_identity.rs b/clippy_lints/src/methods/map_identity.rs
index 98def66ca1499..a98cfff8bfbd1 100644
--- a/clippy_lints/src/methods/map_identity.rs
+++ b/clippy_lints/src/methods/map_identity.rs
@@ -1,14 +1,16 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{is_expr_untyped_identity_function, is_trait_method, path_to_local};
-use rustc_ast::BindingMode;
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::ty::{is_copy, is_type_diagnostic_item};
+use clippy_utils::{is_expr_untyped_identity_function, is_mutable, is_trait_method, path_to_local_with_projections};
 use rustc_errors::Applicability;
-use rustc_hir::{self as hir, Node, PatKind};
-use rustc_lint::LateContext;
+use rustc_hir::{self as hir, ExprKind, Node, PatKind};
+use rustc_lint::{LateContext, LintContext};
 use rustc_span::{Span, Symbol, sym};
 
 use super::MAP_IDENTITY;
 
+const MSG: &str = "unnecessary map of the identity function";
+
 pub(super) fn check(
     cx: &LateContext<'_>,
     expr: &hir::Expr<'_>,
@@ -23,26 +25,70 @@ pub(super) fn check(
         || is_type_diagnostic_item(cx, caller_ty, sym::Result)
         || is_type_diagnostic_item(cx, caller_ty, sym::Option))
         && is_expr_untyped_identity_function(cx, map_arg)
-        && let Some(sugg_span) = expr.span.trim_start(caller.span)
+        && let Some(call_span) = expr.span.trim_start(caller.span)
     {
-        // If the result of `.map(identity)` is used as a mutable reference,
-        // the caller must not be an immutable binding.
-        if cx.typeck_results().expr_ty_adjusted(expr).is_mutable_ptr()
-            && let Some(hir_id) = path_to_local(caller)
-            && let Node::Pat(pat) = cx.tcx.hir_node(hir_id)
-            && !matches!(pat.kind, PatKind::Binding(BindingMode::MUT, ..))
-        {
-            return;
-        }
+        let main_sugg = (call_span, String::new());
+        let mut app = if is_copy(cx, caller_ty) {
+            // there is technically a behavioral change here for `Copy` iterators, where
+            // `iter.map(|x| x).next()` would mutate a temporary copy of the iterator and
+            // changing it to `iter.next()` mutates iter directly
+            Applicability::Unspecified
+        } else {
+            Applicability::MachineApplicable
+        };
+
+        let needs_to_be_mutable = cx.typeck_results().expr_ty_adjusted(expr).is_mutable_ptr();
+        if needs_to_be_mutable && !is_mutable(cx, caller) {
+            if let Some(hir_id) = path_to_local_with_projections(caller)
+                && let Node::Pat(pat) = cx.tcx.hir_node(hir_id)
+                && let PatKind::Binding(_, _, ident, _) = pat.kind
+            {
+                // We can reach the binding -- suggest making it mutable
+                let suggs = vec![main_sugg, (ident.span.shrink_to_lo(), String::from("mut "))];
+
+                let ident = snippet_with_applicability(cx.sess(), ident.span, "_", &mut app);
 
-        span_lint_and_sugg(
-            cx,
-            MAP_IDENTITY,
-            sugg_span,
-            "unnecessary map of the identity function",
-            format!("remove the call to `{name}`"),
-            String::new(),
-            Applicability::MachineApplicable,
-        );
+                span_lint_and_then(cx, MAP_IDENTITY, call_span, MSG, |diag| {
+                    diag.multipart_suggestion(
+                        format!("remove the call to `{name}`, and make `{ident}` mutable"),
+                        suggs,
+                        app,
+                    );
+                });
+            } else {
+                // If we can't make the binding mutable, prevent the suggestion from being automatically applied,
+                // and add a complementary help message.
+                app = Applicability::Unspecified;
+
+                let method_requiring_mut = if let Node::Expr(expr) = cx.tcx.parent_hir_node(expr.hir_id)
+                    && let ExprKind::MethodCall(method, ..) = expr.kind
+                {
+                    Some(method.ident)
+                } else {
+                    None
+                };
+
+                span_lint_and_then(cx, MAP_IDENTITY, call_span, MSG, |diag| {
+                    diag.span_suggestion(main_sugg.0, format!("remove the call to `{name}`"), main_sugg.1, app);
+
+                    let note = if let Some(method_requiring_mut) = method_requiring_mut {
+                        format!("this must be made mutable to use `{method_requiring_mut}`")
+                    } else {
+                        "this must be made mutable".to_string()
+                    };
+                    diag.span_note(caller.span, note);
+                });
+            }
+        } else {
+            span_lint_and_sugg(
+                cx,
+                MAP_IDENTITY,
+                main_sugg.0,
+                MSG,
+                format!("remove the call to `{name}`"),
+                main_sugg.1,
+                app,
+            );
+        }
     }
 }
diff --git a/tests/ui/map_identity.fixed b/tests/ui/map_identity.fixed
index 6c971ba633848..a10aae8cc1217 100644
--- a/tests/ui/map_identity.fixed
+++ b/tests/ui/map_identity.fixed
@@ -1,3 +1,4 @@
+//@require-annotations-for-level: ERROR
 #![warn(clippy::map_identity)]
 #![allow(clippy::needless_return, clippy::disallowed_names)]
 
@@ -72,20 +73,33 @@ fn issue11764() {
 }
 
 fn issue13904() {
-    // don't lint: `it.next()` would not be legal as `it` is immutable
-    let it = [1, 2, 3].into_iter();
-    let _ = it.map(|x| x).next();
+    // lint, but there's a catch:
+    // when we remove the `.map()`, `it.next()` would require `it` to be mutable
+    // therefore, include that in the suggestion as well
+    let mut it = [1, 2, 3].into_iter();
+    let _ = it.next();
+    //~^ map_identity
+    //~| HELP: remove the call to `map`, and make `it` mutable
+
+    // lint
+    let mut index = [1, 2, 3].into_iter();
+    let mut subindex = (index.by_ref().take(3), 42);
+    let _ = subindex.0.next();
+    //~^ map_identity
+    //~| HELP: remove the call to `map`, and make `subindex` mutable
 
     // lint
     #[allow(unused_mut)]
     let mut it = [1, 2, 3].into_iter();
     let _ = it.next();
     //~^ map_identity
+    //~| HELP: remove the call to `map`
 
     // lint
     let it = [1, 2, 3].into_iter();
     let _ = { it }.next();
     //~^ map_identity
+    //~| HELP: remove the call to `map`
 }
 
 // same as `issue11764`, but for arrays
diff --git a/tests/ui/map_identity.rs b/tests/ui/map_identity.rs
index 59dcfcda3b6e6..fc6e018f92484 100644
--- a/tests/ui/map_identity.rs
+++ b/tests/ui/map_identity.rs
@@ -1,3 +1,4 @@
+//@require-annotations-for-level: ERROR
 #![warn(clippy::map_identity)]
 #![allow(clippy::needless_return, clippy::disallowed_names)]
 
@@ -78,20 +79,33 @@ fn issue11764() {
 }
 
 fn issue13904() {
-    // don't lint: `it.next()` would not be legal as `it` is immutable
+    // lint, but there's a catch:
+    // when we remove the `.map()`, `it.next()` would require `it` to be mutable
+    // therefore, include that in the suggestion as well
     let it = [1, 2, 3].into_iter();
     let _ = it.map(|x| x).next();
+    //~^ map_identity
+    //~| HELP: remove the call to `map`, and make `it` mutable
+
+    // lint
+    let mut index = [1, 2, 3].into_iter();
+    let subindex = (index.by_ref().take(3), 42);
+    let _ = subindex.0.map(|n| n).next();
+    //~^ map_identity
+    //~| HELP: remove the call to `map`, and make `subindex` mutable
 
     // lint
     #[allow(unused_mut)]
     let mut it = [1, 2, 3].into_iter();
     let _ = it.map(|x| x).next();
     //~^ map_identity
+    //~| HELP: remove the call to `map`
 
     // lint
     let it = [1, 2, 3].into_iter();
     let _ = { it }.map(|x| x).next();
     //~^ map_identity
+    //~| HELP: remove the call to `map`
 }
 
 // same as `issue11764`, but for arrays
diff --git a/tests/ui/map_identity.stderr b/tests/ui/map_identity.stderr
index a50c0d6b87b53..8d19d62cdc641 100644
--- a/tests/ui/map_identity.stderr
+++ b/tests/ui/map_identity.stderr
@@ -1,5 +1,5 @@
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:7:47
+  --> tests/ui/map_identity.rs:8:47
    |
 LL |     let _: Vec<_> = x.iter().map(not_identity).map(|x| return x).collect();
    |                                               ^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
@@ -8,25 +8,25 @@ LL |     let _: Vec<_> = x.iter().map(not_identity).map(|x| return x).collect();
    = help: to override `-D warnings` add `#[allow(clippy::map_identity)]`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:9:57
+  --> tests/ui/map_identity.rs:10:57
    |
 LL |     let _: Vec<_> = x.iter().map(std::convert::identity).map(|y| y).collect();
    |                                                         ^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:9:29
+  --> tests/ui/map_identity.rs:10:29
    |
 LL |     let _: Vec<_> = x.iter().map(std::convert::identity).map(|y| y).collect();
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:12:32
+  --> tests/ui/map_identity.rs:13:32
    |
 LL |     let _: Option<u8> = Some(3).map(|x| x);
    |                                ^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:14:36
+  --> tests/ui/map_identity.rs:15:36
    |
 LL |       let _: Result<i8, f32> = Ok(-3).map(|x| {
    |  ____________________________________^
@@ -36,19 +36,19 @@ LL | |     });
    | |______^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:25:36
+  --> tests/ui/map_identity.rs:26:36
    |
 LL |     let _: Result<u32, u32> = Ok(1).map_err(|a| a);
    |                                    ^^^^^^^^^^^^^^^ help: remove the call to `map_err`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:36:22
+  --> tests/ui/map_identity.rs:37:22
    |
 LL |     let _ = x.clone().map(|(x, y)| (x, y));
    |                      ^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:38:22
+  --> tests/ui/map_identity.rs:39:22
    |
 LL |       let _ = x.clone().map(|(x, y)| {
    |  ______________________^
@@ -58,76 +58,100 @@ LL | |     });
    | |______^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:42:22
+  --> tests/ui/map_identity.rs:43:22
    |
 LL |     let _ = x.clone().map(|(x, y)| return (x, y));
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:46:22
+  --> tests/ui/map_identity.rs:47:22
    |
 LL |     let _ = y.clone().map(|(x, y, (z, (w,)))| (x, y, (z, (w,))));
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:76:30
+  --> tests/ui/map_identity.rs:77:30
    |
 LL |     let _ = x.iter().copied().map(|(x, y)| (x, y));
    |                              ^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:88:15
+  --> tests/ui/map_identity.rs:86:15
+   |
+LL |     let _ = it.map(|x| x).next();
+   |               ^^^^^^^^^^^
+   |
+help: remove the call to `map`, and make `it` mutable
+   |
+LL ~     let mut it = [1, 2, 3].into_iter();
+LL ~     let _ = it.next();
+   |
+
+error: unnecessary map of the identity function
+  --> tests/ui/map_identity.rs:93:23
+   |
+LL |     let _ = subindex.0.map(|n| n).next();
+   |                       ^^^^^^^^^^^
+   |
+help: remove the call to `map`, and make `subindex` mutable
+   |
+LL ~     let mut subindex = (index.by_ref().take(3), 42);
+LL ~     let _ = subindex.0.next();
+   |
+
+error: unnecessary map of the identity function
+  --> tests/ui/map_identity.rs:100:15
    |
 LL |     let _ = it.map(|x| x).next();
    |               ^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:93:19
+  --> tests/ui/map_identity.rs:106:19
    |
 LL |     let _ = { it }.map(|x| x).next();
    |                   ^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:105:30
+  --> tests/ui/map_identity.rs:119:30
    |
 LL |     let _ = x.iter().copied().map(|[x, y]| [x, y]);
    |                              ^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:131:26
+  --> tests/ui/map_identity.rs:145:26
    |
 LL |     let _ = x.into_iter().map(|Foo { foo, bar }| Foo { foo, bar });
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:135:26
+  --> tests/ui/map_identity.rs:149:26
    |
 LL |     let _ = x.into_iter().map(|Foo { foo, bar }| foo::Foo { foo, bar });
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:143:26
+  --> tests/ui/map_identity.rs:157:26
    |
 LL |     let _ = x.into_iter().map(|Foo { foo, bar }| Foo { foo: foo, bar: bar });
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:147:26
+  --> tests/ui/map_identity.rs:161:26
    |
 LL |     let _ = x.into_iter().map(|Foo { foo, bar }| Foo { bar, foo });
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:157:26
+  --> tests/ui/map_identity.rs:171:26
    |
 LL |     let _ = x.into_iter().map(|Foo2(foo, bar)| Foo2(foo, bar));
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:161:26
+  --> tests/ui/map_identity.rs:175:26
    |
 LL |     let _ = x.into_iter().map(|Foo2(foo, bar)| foo::Foo2(foo, bar));
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
-error: aborting due to 20 previous errors
+error: aborting due to 22 previous errors
 

From 9ddd03ce1f67fa2b73e181f810ebc21d464eb7d9 Mon Sep 17 00:00:00 2001
From: apiraino <apiraino@users.noreply.github.com>
Date: Wed, 6 Aug 2025 11:07:57 +0200
Subject: [PATCH 0311/1889] Mention our policy on typofixes for internal docs

---
 src/doc/rustc-dev-guide/src/contributing.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/doc/rustc-dev-guide/src/contributing.md b/src/doc/rustc-dev-guide/src/contributing.md
index d0a32f71a3db0..1ade4953d2e65 100644
--- a/src/doc/rustc-dev-guide/src/contributing.md
+++ b/src/doc/rustc-dev-guide/src/contributing.md
@@ -370,6 +370,9 @@ You can also use `rustdoc` directly to check small fixes. For example,
 `rustdoc src/doc/reference.md` will render reference to `doc/reference.html`.
 The CSS might be messed up, but you can verify that the HTML is right.
 
+Please notice that at this time we don't accept typography/spellcheck fixes to **internal documentation** (example:
+tests, library or compiler code) as it's usually not worth the churn or the review time.
+
 ### Contributing to rustc-dev-guide
 
 Contributions to the [rustc-dev-guide] are always welcome, and can be made directly at

From f8a7f82bdab57302ca07ea5f3b3fa5173ed9f9ae Mon Sep 17 00:00:00 2001
From: Sidney Cammeresi <sac@readyset.io>
Date: Fri, 15 Aug 2025 08:45:50 -0700
Subject: [PATCH 0312/1889] Stabilize BTree{Map,Set}::extract_if

---
 library/alloc/src/collections/btree/map.rs            | 11 +++++------
 library/alloc/src/collections/btree/set.rs            | 11 +++++------
 library/alloctests/benches/lib.rs                     |  1 -
 library/alloctests/tests/lib.rs                       |  1 -
 src/tools/miri/tests/pass/btreemap.rs                 |  1 -
 .../run_pass/lit-pattern-matching-with-methods.rs     |  1 -
 6 files changed, 10 insertions(+), 16 deletions(-)

diff --git a/library/alloc/src/collections/btree/map.rs b/library/alloc/src/collections/btree/map.rs
index 8b6d86a288866..98f11e2ea57fd 100644
--- a/library/alloc/src/collections/btree/map.rs
+++ b/library/alloc/src/collections/btree/map.rs
@@ -1433,7 +1433,6 @@ impl<K, V, A: Allocator + Clone> BTreeMap<K, V, A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(btree_extract_if)]
     /// use std::collections::BTreeMap;
     ///
     /// // Splitting a map into even and odd keys, reusing the original map:
@@ -1450,7 +1449,7 @@ impl<K, V, A: Allocator + Clone> BTreeMap<K, V, A> {
     /// assert_eq!(low.keys().copied().collect::<Vec<_>>(), [0, 1, 2, 3]);
     /// assert_eq!(high.keys().copied().collect::<Vec<_>>(), [4, 5, 6, 7]);
     /// ```
-    #[unstable(feature = "btree_extract_if", issue = "70530")]
+    #[stable(feature = "btree_extract_if", since = "CURRENT_RUSTC_VERSION")]
     pub fn extract_if<F, R>(&mut self, range: R, pred: F) -> ExtractIf<'_, K, V, R, F, A>
     where
         K: Ord,
@@ -1937,7 +1936,7 @@ impl<K, V> Default for Values<'_, K, V> {
 }
 
 /// An iterator produced by calling `extract_if` on BTreeMap.
-#[unstable(feature = "btree_extract_if", issue = "70530")]
+#[stable(feature = "btree_extract_if", since = "CURRENT_RUSTC_VERSION")]
 #[must_use = "iterators are lazy and do nothing unless consumed"]
 pub struct ExtractIf<
     'a,
@@ -1970,7 +1969,7 @@ pub(super) struct ExtractIfInner<'a, K, V, R> {
     range: R,
 }
 
-#[unstable(feature = "btree_extract_if", issue = "70530")]
+#[stable(feature = "btree_extract_if", since = "CURRENT_RUSTC_VERSION")]
 impl<K, V, R, F, A> fmt::Debug for ExtractIf<'_, K, V, R, F, A>
 where
     K: fmt::Debug,
@@ -1982,7 +1981,7 @@ where
     }
 }
 
-#[unstable(feature = "btree_extract_if", issue = "70530")]
+#[stable(feature = "btree_extract_if", since = "CURRENT_RUSTC_VERSION")]
 impl<K, V, R, F, A: Allocator + Clone> Iterator for ExtractIf<'_, K, V, R, F, A>
 where
     K: PartialOrd,
@@ -2056,7 +2055,7 @@ impl<'a, K, V, R> ExtractIfInner<'a, K, V, R> {
     }
 }
 
-#[unstable(feature = "btree_extract_if", issue = "70530")]
+#[stable(feature = "btree_extract_if", since = "CURRENT_RUSTC_VERSION")]
 impl<K, V, R, F> FusedIterator for ExtractIf<'_, K, V, R, F>
 where
     K: PartialOrd,
diff --git a/library/alloc/src/collections/btree/set.rs b/library/alloc/src/collections/btree/set.rs
index d50ce02bda743..e6b0a1f632321 100644
--- a/library/alloc/src/collections/btree/set.rs
+++ b/library/alloc/src/collections/btree/set.rs
@@ -1202,7 +1202,6 @@ impl<T, A: Allocator + Clone> BTreeSet<T, A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(btree_extract_if)]
     /// use std::collections::BTreeSet;
     ///
     /// // Splitting a set into even and odd values, reusing the original set:
@@ -1219,7 +1218,7 @@ impl<T, A: Allocator + Clone> BTreeSet<T, A> {
     /// assert_eq!(low.into_iter().collect::<Vec<_>>(), [0, 1, 2, 3]);
     /// assert_eq!(high.into_iter().collect::<Vec<_>>(), [4, 5, 6, 7]);
     /// ```
-    #[unstable(feature = "btree_extract_if", issue = "70530")]
+    #[stable(feature = "btree_extract_if", since = "CURRENT_RUSTC_VERSION")]
     pub fn extract_if<F, R>(&mut self, range: R, pred: F) -> ExtractIf<'_, T, R, F, A>
     where
         T: Ord,
@@ -1554,7 +1553,7 @@ impl<'a, T, A: Allocator + Clone> IntoIterator for &'a BTreeSet<T, A> {
 }
 
 /// An iterator produced by calling `extract_if` on BTreeSet.
-#[unstable(feature = "btree_extract_if", issue = "70530")]
+#[stable(feature = "btree_extract_if", since = "CURRENT_RUSTC_VERSION")]
 #[must_use = "iterators are lazy and do nothing unless consumed"]
 pub struct ExtractIf<
     'a,
@@ -1569,7 +1568,7 @@ pub struct ExtractIf<
     alloc: A,
 }
 
-#[unstable(feature = "btree_extract_if", issue = "70530")]
+#[stable(feature = "btree_extract_if", since = "CURRENT_RUSTC_VERSION")]
 impl<T, R, F, A> fmt::Debug for ExtractIf<'_, T, R, F, A>
 where
     T: fmt::Debug,
@@ -1582,7 +1581,7 @@ where
     }
 }
 
-#[unstable(feature = "btree_extract_if", issue = "70530")]
+#[stable(feature = "btree_extract_if", since = "CURRENT_RUSTC_VERSION")]
 impl<T, R, F, A: Allocator + Clone> Iterator for ExtractIf<'_, T, R, F, A>
 where
     T: PartialOrd,
@@ -1602,7 +1601,7 @@ where
     }
 }
 
-#[unstable(feature = "btree_extract_if", issue = "70530")]
+#[stable(feature = "btree_extract_if", since = "CURRENT_RUSTC_VERSION")]
 impl<T, R, F, A: Allocator + Clone> FusedIterator for ExtractIf<'_, T, R, F, A>
 where
     T: PartialOrd,
diff --git a/library/alloctests/benches/lib.rs b/library/alloctests/benches/lib.rs
index 2633154318c13..721d685527fec 100644
--- a/library/alloctests/benches/lib.rs
+++ b/library/alloctests/benches/lib.rs
@@ -1,6 +1,5 @@
 // Disabling in Miri as these would take too long.
 #![cfg(not(miri))]
-#![feature(btree_extract_if)]
 #![feature(iter_next_chunk)]
 #![feature(repr_simd)]
 #![feature(slice_partition_dedup)]
diff --git a/library/alloctests/tests/lib.rs b/library/alloctests/tests/lib.rs
index 447af240a4b9d..c0a0022c00807 100644
--- a/library/alloctests/tests/lib.rs
+++ b/library/alloctests/tests/lib.rs
@@ -2,7 +2,6 @@
 #![feature(alloc_layout_extra)]
 #![feature(iter_array_chunks)]
 #![feature(assert_matches)]
-#![feature(btree_extract_if)]
 #![feature(wtf8_internals)]
 #![feature(char_max_len)]
 #![feature(cow_is_borrowed)]
diff --git a/src/tools/miri/tests/pass/btreemap.rs b/src/tools/miri/tests/pass/btreemap.rs
index 1d65e69bf726f..7af6d7b5551c7 100644
--- a/src/tools/miri/tests/pass/btreemap.rs
+++ b/src/tools/miri/tests/pass/btreemap.rs
@@ -1,7 +1,6 @@
 //@revisions: stack tree
 //@[tree]compile-flags: -Zmiri-tree-borrows
 //@compile-flags: -Zmiri-strict-provenance
-#![feature(btree_extract_if)]
 use std::collections::{BTreeMap, BTreeSet};
 use std::mem;
 
diff --git a/tests/ui/closures/2229_closure_analysis/run_pass/lit-pattern-matching-with-methods.rs b/tests/ui/closures/2229_closure_analysis/run_pass/lit-pattern-matching-with-methods.rs
index afb16cf58e871..4ae77ab643924 100644
--- a/tests/ui/closures/2229_closure_analysis/run_pass/lit-pattern-matching-with-methods.rs
+++ b/tests/ui/closures/2229_closure_analysis/run_pass/lit-pattern-matching-with-methods.rs
@@ -2,7 +2,6 @@
 //@check-pass
 #![warn(unused)]
 #![feature(rustc_attrs)]
-#![feature(btree_extract_if)]
 
 use std::collections::BTreeMap;
 use std::panic::{catch_unwind, AssertUnwindSafe};

From ee9986b4a28313429cc50f91ffd30d7491bd59af Mon Sep 17 00:00:00 2001
From: dianne <diannes.gm@gmail.com>
Date: Wed, 27 Aug 2025 12:06:52 -0700
Subject: [PATCH 0313/1889] document lifetime extension for `format_args!`'s
 arguments

---
 library/core/src/macros/mod.rs | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)

diff --git a/library/core/src/macros/mod.rs b/library/core/src/macros/mod.rs
index ccf41dfb01dd1..c19ce4f90660b 100644
--- a/library/core/src/macros/mod.rs
+++ b/library/core/src/macros/mod.rs
@@ -951,8 +951,9 @@ pub(crate) mod builtin {
     /// format string in `format_args!`.
     ///
     /// ```rust
-    /// let debug = format!("{:?}", format_args!("{} foo {:?}", 1, 2));
-    /// let display = format!("{}", format_args!("{} foo {:?}", 1, 2));
+    /// let args = format_args!("{} foo {:?}", 1, 2);
+    /// let debug = format!("{args:?}");
+    /// let display = format!("{args}");
     /// assert_eq!("1 foo 2", display);
     /// assert_eq!(display, debug);
     /// ```
@@ -976,13 +977,17 @@ pub(crate) mod builtin {
     /// assert_eq!(s, format!("hello {}", "world"));
     /// ```
     ///
-    /// # Lifetime limitation
+    /// # Argument lifetimes
     ///
     /// Except when no formatting arguments are used,
-    /// the produced `fmt::Arguments` value borrows temporary values,
-    /// which means it can only be used within the same expression
-    /// and cannot be stored for later use.
-    /// This is a known limitation, see [#92698](https://github.com/rust-lang/rust/issues/92698).
+    /// the produced `fmt::Arguments` value borrows temporary values.
+    /// To allow it to be stored for later use, the arguments' lifetimes, as well as those of
+    /// temporaries they borrow, may be [extended] when `format_args!` appears in the initializer
+    /// expression of a `let` statement. The syntactic rules used to determine when temporaries'
+    /// lifetimes are extended are documented in the [Reference].
+    ///
+    /// [extended]: ../reference/destructors.html#temporary-lifetime-extension
+    /// [Reference]: ../reference/destructors.html#extending-based-on-expressions
     #[stable(feature = "rust1", since = "1.0.0")]
     #[rustc_diagnostic_item = "format_args_macro"]
     #[allow_internal_unsafe]

From 991021785eae51e4687b368047e50955ee4adab4 Mon Sep 17 00:00:00 2001
From: Vishruth-Thimmaiah <vishruththimmaiah@gmail.com>
Date: Fri, 14 Feb 2025 19:15:38 +0530
Subject: [PATCH 0314/1889] fix: `collapsible_match` suggests ref/derefs when
 needed

---
 clippy_lints/src/matches/collapsible_match.rs | 49 +++++++++++--
 clippy_lints/src/matches/mod.rs               | 11 ++-
 clippy_utils/src/lib.rs                       | 18 +++++
 tests/ui/collapsible_match.rs                 | 41 +++++++++++
 tests/ui/collapsible_match.stderr             | 71 ++++++++++++++++++-
 tests/ui/collapsible_match2.stderr            |  2 +
 6 files changed, 184 insertions(+), 8 deletions(-)

diff --git a/clippy_lints/src/matches/collapsible_match.rs b/clippy_lints/src/matches/collapsible_match.rs
index 5b50efad3e44e..aaf559fc4439e 100644
--- a/clippy_lints/src/matches/collapsible_match.rs
+++ b/clippy_lints/src/matches/collapsible_match.rs
@@ -4,20 +4,22 @@ use clippy_utils::msrvs::Msrv;
 use clippy_utils::source::snippet;
 use clippy_utils::visitors::is_local_used;
 use clippy_utils::{
-    SpanlessEq, is_res_lang_ctor, is_unit_expr, path_to_local, peel_blocks_with_stmt, peel_ref_operators,
+    SpanlessEq, get_ref_operators, is_res_lang_ctor, is_unit_expr, path_to_local, peel_blocks_with_stmt,
+    peel_ref_operators,
 };
+use rustc_ast::BorrowKind;
 use rustc_errors::MultiSpan;
 use rustc_hir::LangItem::OptionNone;
-use rustc_hir::{Arm, Expr, HirId, Pat, PatExpr, PatExprKind, PatKind};
+use rustc_hir::{Arm, Expr, ExprKind, HirId, Pat, PatExpr, PatExprKind, PatKind};
 use rustc_lint::LateContext;
 use rustc_span::Span;
 
 use super::{COLLAPSIBLE_MATCH, pat_contains_disallowed_or};
 
-pub(super) fn check_match<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], msrv: Msrv) {
+pub(super) fn check_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arms: &'tcx [Arm<'_>], msrv: Msrv) {
     if let Some(els_arm) = arms.iter().rfind(|arm| arm_is_wild_like(cx, arm)) {
         for arm in arms {
-            check_arm(cx, true, arm.pat, arm.body, arm.guard, Some(els_arm.body), msrv);
+            check_arm(cx, true, arm.pat, expr, arm.body, arm.guard, Some(els_arm.body), msrv);
         }
     }
 }
@@ -27,15 +29,18 @@ pub(super) fn check_if_let<'tcx>(
     pat: &'tcx Pat<'_>,
     body: &'tcx Expr<'_>,
     else_expr: Option<&'tcx Expr<'_>>,
+    let_expr: &'tcx Expr<'_>,
     msrv: Msrv,
 ) {
-    check_arm(cx, false, pat, body, None, else_expr, msrv);
+    check_arm(cx, false, pat, let_expr, body, None, else_expr, msrv);
 }
 
+#[allow(clippy::too_many_arguments)]
 fn check_arm<'tcx>(
     cx: &LateContext<'tcx>,
     outer_is_match: bool,
     outer_pat: &'tcx Pat<'tcx>,
+    outer_cond: &'tcx Expr<'tcx>,
     outer_then_body: &'tcx Expr<'tcx>,
     outer_guard: Option<&'tcx Expr<'tcx>>,
     outer_else_body: Option<&'tcx Expr<'tcx>>,
@@ -82,6 +87,9 @@ fn check_arm<'tcx>(
             },
             IfLetOrMatch::Match(_, arms, ..) => !arms.iter().any(|arm| is_local_used(cx, arm, binding_id)),
         }
+        // Check if the inner expression contains any borrows/dereferences
+        && let ref_types = get_ref_operators(cx, inner_scrutinee)
+        && let Some(method) = build_ref_method_chain(ref_types)
     {
         let msg = format!(
             "this `{}` can be collapsed into the outer `{}`",
@@ -103,6 +111,10 @@ fn check_arm<'tcx>(
             let mut help_span = MultiSpan::from_spans(vec![binding_span, inner_then_pat.span]);
             help_span.push_span_label(binding_span, "replace this binding");
             help_span.push_span_label(inner_then_pat.span, format!("with this pattern{replace_msg}"));
+            if !method.is_empty() {
+                let outer_cond_msg = format!("use: `{}{}`", snippet(cx, outer_cond.span, ".."), method);
+                help_span.push_span_label(outer_cond.span, outer_cond_msg);
+            }
             diag.span_help(
                 help_span,
                 "the outer pattern can be modified to include the inner pattern",
@@ -148,3 +160,30 @@ fn find_pat_binding_and_is_innermost_parent_pat_struct(pat: &Pat<'_>, hir_id: Hi
     });
     (span, is_innermost_parent_pat_struct)
 }
+
+/// Builds a chain of reference-manipulation method calls (e.g., `.as_ref()`, `.as_mut()`,
+/// `.copied()`) based on reference operators
+fn build_ref_method_chain(expr: Vec<&Expr<'_>>) -> Option<String> {
+    let mut req_method_calls = String::new();
+
+    for ref_operator in expr {
+        match ref_operator.kind {
+            ExprKind::AddrOf(BorrowKind::Raw, _, _) => {
+                return None;
+            },
+            ExprKind::AddrOf(_, m, _) if m.is_mut() => {
+                req_method_calls.push_str(".as_mut()");
+            },
+            ExprKind::AddrOf(_, _, _) => {
+                req_method_calls.push_str(".as_ref()");
+            },
+            // Deref operator is the only operator that this function should have received
+            ExprKind::Unary(_, _) => {
+                req_method_calls.push_str(".copied()");
+            },
+            _ => (),
+        }
+    }
+
+    Some(req_method_calls)
+}
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index c128fc40b7334..6f49c5524118d 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -1073,7 +1073,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                 significant_drop_in_scrutinee::check_match(cx, expr, ex, arms, source);
             }
 
-            collapsible_match::check_match(cx, arms, self.msrv);
+            collapsible_match::check_match(cx, ex, arms, self.msrv);
             if !from_expansion {
                 // These don't depend on a relationship between multiple arms
                 match_wild_err_arm::check(cx, ex, arms);
@@ -1137,7 +1137,14 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                 match_ref_pats::check(cx, ex, arms.iter().map(|el| el.pat), expr);
             }
         } else if let Some(if_let) = higher::IfLet::hir(cx, expr) {
-            collapsible_match::check_if_let(cx, if_let.let_pat, if_let.if_then, if_let.if_else, self.msrv);
+            collapsible_match::check_if_let(
+                cx,
+                if_let.let_pat,
+                if_let.if_then,
+                if_let.if_else,
+                if_let.let_expr,
+                self.msrv,
+            );
             significant_drop_in_scrutinee::check_if_let(cx, expr, if_let.let_expr, if_let.if_then, if_let.if_else);
             if !from_expansion {
                 if let Some(else_expr) = if_let.if_else {
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index df47b9f7e33bb..0bb19dab1f7a4 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -2404,6 +2404,24 @@ pub fn peel_ref_operators<'hir>(cx: &LateContext<'_>, mut expr: &'hir Expr<'hir>
     expr
 }
 
+/// Returns a `Vec` of `Expr`s containing `AddrOf` operators (`&`) or deref operators (`*`) of a
+/// given expression.
+pub fn get_ref_operators<'hir>(cx: &LateContext<'_>, expr: &'hir Expr<'hir>) -> Vec<&'hir Expr<'hir>> {
+    let mut operators = Vec::new();
+    peel_hir_expr_while(expr, |expr| match expr.kind {
+        ExprKind::AddrOf(_, _, e) => {
+            operators.push(expr);
+            Some(e)
+        },
+        ExprKind::Unary(UnOp::Deref, e) if cx.typeck_results().expr_ty(e).is_ref() => {
+            operators.push(expr);
+            Some(e)
+        },
+        _ => None,
+    });
+    operators
+}
+
 pub fn is_hir_ty_cfg_dependant(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> bool {
     if let TyKind::Path(QPath::Resolved(_, path)) = ty.kind
         && let Res::Def(_, def_id) = path.res
diff --git a/tests/ui/collapsible_match.rs b/tests/ui/collapsible_match.rs
index 71b82040ff62a..8931a3aa09c61 100644
--- a/tests/ui/collapsible_match.rs
+++ b/tests/ui/collapsible_match.rs
@@ -316,6 +316,47 @@ fn lint_emitted_at_right_node(opt: Option<Result<u64, String>>) {
     };
 }
 
+pub fn issue_14155() {
+    let mut arr = ["a", "b", "c"];
+    if let Some(last) = arr.last() {
+        match *last {
+            //~^ collapsible_match
+            "a" | "b" => {
+                unimplemented!()
+            },
+            _ => (),
+        }
+    }
+
+    if let Some(last) = arr.last() {
+        match &last {
+            //~^ collapsible_match
+            &&"a" | &&"b" => {
+                unimplemented!()
+            },
+            _ => (),
+        }
+    }
+
+    if let Some(mut last) = arr.last_mut() {
+        match &mut last {
+            //~^ collapsible_match
+            &mut &mut "a" | &mut &mut "b" => {
+                unimplemented!()
+            },
+            _ => (),
+        }
+    }
+
+    const NULL_PTR: *const &'static str = std::ptr::null();
+    if let Some(last) = arr.last() {
+        match &raw const *last {
+            NULL_PTR => unimplemented!(),
+            _ => (),
+        }
+    }
+}
+
 fn make<T>() -> T {
     unimplemented!()
 }
diff --git a/tests/ui/collapsible_match.stderr b/tests/ui/collapsible_match.stderr
index c290d84ec2976..14b1c1b187e4f 100644
--- a/tests/ui/collapsible_match.stderr
+++ b/tests/ui/collapsible_match.stderr
@@ -250,5 +250,74 @@ LL |     if let Issue9647::A { a: Some(a), .. } = x {
 LL |         if let Some(u) = a {
    |                ^^^^^^^ with this pattern
 
-error: aborting due to 13 previous errors
+error: this `match` can be collapsed into the outer `if let`
+  --> tests/ui/collapsible_match.rs:322:9
+   |
+LL | /         match *last {
+LL | |
+LL | |             "a" | "b" => {
+LL | |                 unimplemented!()
+LL | |             },
+LL | |             _ => (),
+LL | |         }
+   | |_________^
+   |
+help: the outer pattern can be modified to include the inner pattern
+  --> tests/ui/collapsible_match.rs:321:17
+   |
+LL |     if let Some(last) = arr.last() {
+   |                 ^^^^    ---------- use: `arr.last().copied()`
+   |                 |
+   |                 replace this binding
+...
+LL |             "a" | "b" => {
+   |             ^^^^^^^^^ with this pattern
+
+error: this `match` can be collapsed into the outer `if let`
+  --> tests/ui/collapsible_match.rs:332:9
+   |
+LL | /         match &last {
+LL | |
+LL | |             &&"a" | &&"b" => {
+LL | |                 unimplemented!()
+LL | |             },
+LL | |             _ => (),
+LL | |         }
+   | |_________^
+   |
+help: the outer pattern can be modified to include the inner pattern
+  --> tests/ui/collapsible_match.rs:331:17
+   |
+LL |     if let Some(last) = arr.last() {
+   |                 ^^^^    ---------- use: `arr.last().as_ref()`
+   |                 |
+   |                 replace this binding
+...
+LL |             &&"a" | &&"b" => {
+   |             ^^^^^^^^^^^^^ with this pattern
+
+error: this `match` can be collapsed into the outer `if let`
+  --> tests/ui/collapsible_match.rs:342:9
+   |
+LL | /         match &mut last {
+LL | |
+LL | |             &mut &mut "a" | &mut &mut "b" => {
+LL | |                 unimplemented!()
+LL | |             },
+LL | |             _ => (),
+LL | |         }
+   | |_________^
+   |
+help: the outer pattern can be modified to include the inner pattern
+  --> tests/ui/collapsible_match.rs:341:17
+   |
+LL |     if let Some(mut last) = arr.last_mut() {
+   |                 ^^^^^^^^    -------------- use: `arr.last_mut().as_mut()`
+   |                 |
+   |                 replace this binding
+...
+LL |             &mut &mut "a" | &mut &mut "b" => {
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ with this pattern
+
+error: aborting due to 16 previous errors
 
diff --git a/tests/ui/collapsible_match2.stderr b/tests/ui/collapsible_match2.stderr
index 7b27306375289..2597067099906 100644
--- a/tests/ui/collapsible_match2.stderr
+++ b/tests/ui/collapsible_match2.stderr
@@ -77,6 +77,8 @@ LL | |         },
 help: the outer pattern can be modified to include the inner pattern
   --> tests/ui/collapsible_match2.rs:54:14
    |
+LL |     match Some(&[1]) {
+   |           ---------- use: `Some(&[1]).copied()`
 LL |         Some(s) => match *s {
    |              ^ replace this binding
 LL |

From 7f1dfe08964b5671d4110efa73833ba40669e935 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Wed, 27 Aug 2025 22:49:45 +0200
Subject: [PATCH 0315/1889] triagebot: Amend a review to include a link to what
 was changed since

---
 triagebot.toml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/triagebot.toml b/triagebot.toml
index 79b6c2b792ffd..b2fb50918f583 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -52,6 +52,9 @@ labels = ["S-waiting-on-concerns"]
 # Show differences when a PR is rebased
 [range-diff]
 
+# Amend a review to include a link to what was changed since the review
+[review-changes-since]
+
 [assign]
 contributing_url = "https://github.com/rust-lang/rust-clippy/blob/master/CONTRIBUTING.md"
 users_on_vacation = [

From f31a378b0a5a612e0d2a91ab1a9ad237d442888c Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Thu, 28 Aug 2025 01:25:09 +0300
Subject: [PATCH 0316/1889] Attach the db in one more place in highlighting

---
 .../rust-analyzer/crates/ide/src/syntax_highlighting/inject.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/inject.rs b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/inject.rs
index 7785891169c64..abe7be8c68881 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/inject.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/inject.rs
@@ -26,7 +26,8 @@ pub(super) fn ra_fixture(
     literal: &ast::String,
     expanded: &ast::String,
 ) -> Option<()> {
-    let active_parameter = ActiveParameter::at_token(sema, expanded.syntax().clone())?;
+    let active_parameter =
+        salsa::attach(sema.db, || ActiveParameter::at_token(sema, expanded.syntax().clone()))?;
     let has_rust_fixture_attr = active_parameter.attrs().is_some_and(|attrs| {
         attrs.filter_map(|attr| attr.as_simple_path()).any(|path| {
             path.segments()

From e2a4fb0bbe0f2a60917f900b8e6c4dc31b01cf64 Mon Sep 17 00:00:00 2001
From: Ali Nazzal <ali90h7@pm.me>
Date: Thu, 28 Aug 2025 11:38:42 +0300
Subject: [PATCH 0317/1889] dates(diagnostics,tests): refresh annotated dates
 to Aug 2025; preserve local style

---
 src/doc/rustc-dev-guide/src/diagnostics/diagnostic-items.md | 2 +-
 src/doc/rustc-dev-guide/src/diagnostics/error-codes.md      | 2 +-
 src/doc/rustc-dev-guide/src/diagnostics/lintstore.md        | 2 +-
 src/doc/rustc-dev-guide/src/diagnostics/translation.md      | 4 ++--
 src/doc/rustc-dev-guide/src/tests/ci.md                     | 2 +-
 src/doc/rustc-dev-guide/src/tests/directives.md             | 4 ++--
 src/doc/rustc-dev-guide/src/tests/misc.md                   | 2 +-
 7 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/diagnostics/diagnostic-items.md b/src/doc/rustc-dev-guide/src/diagnostics/diagnostic-items.md
index 9360427d660e2..4000cbdb8ceae 100644
--- a/src/doc/rustc-dev-guide/src/diagnostics/diagnostic-items.md
+++ b/src/doc/rustc-dev-guide/src/diagnostics/diagnostic-items.md
@@ -48,7 +48,7 @@ A new diagnostic item can be added with these two steps:
     For the naming conventions of diagnostic items, please refer to
     [*Naming Conventions*](#naming-conventions).
 
-2. <!-- date-check: Feb 2023 -->
+2. <!-- date-check: Aug 2025 -->
    Diagnostic items in code are accessed via symbols in
    [`rustc_span::symbol::sym`].
    To add your newly-created diagnostic item,
diff --git a/src/doc/rustc-dev-guide/src/diagnostics/error-codes.md b/src/doc/rustc-dev-guide/src/diagnostics/error-codes.md
index 1693432b90de7..98d9a7ab0a18e 100644
--- a/src/doc/rustc-dev-guide/src/diagnostics/error-codes.md
+++ b/src/doc/rustc-dev-guide/src/diagnostics/error-codes.md
@@ -10,7 +10,7 @@ explanation: new error codes must include them. Note that not all _historical_
 The explanations are written in Markdown (see the [CommonMark Spec] for
 specifics around syntax), and all of them are linked in the [`rustc_error_codes`]
 crate. Please read [RFC 1567] for details on how to format and write long error
-codes. As of <!-- date-check --> February 2023, there is an
+codes. As of <!-- date-check --> August 2025, there is an
 effort[^new-explanations] to replace this largely outdated RFC with a new more
 flexible standard.
 
diff --git a/src/doc/rustc-dev-guide/src/diagnostics/lintstore.md b/src/doc/rustc-dev-guide/src/diagnostics/lintstore.md
index 7b98bc62116b4..f0d349c91b969 100644
--- a/src/doc/rustc-dev-guide/src/diagnostics/lintstore.md
+++ b/src/doc/rustc-dev-guide/src/diagnostics/lintstore.md
@@ -21,7 +21,7 @@ which boils down to a static with type [`&rustc_lint_defs::Lint`]
 as the macro is somewhat unwieldy to add new fields to,
 like all macros).
 
-As of <!-- date-check --> Aug 2022,
+As of <!-- date-check --> Aug 2025,
 we lint against direct declarations without the use of the macro.
 
 Lint declarations don't carry any "state" - they are merely global identifiers
diff --git a/src/doc/rustc-dev-guide/src/diagnostics/translation.md b/src/doc/rustc-dev-guide/src/diagnostics/translation.md
index 58d75f54a005b..5d143da2bad13 100644
--- a/src/doc/rustc-dev-guide/src/diagnostics/translation.md
+++ b/src/doc/rustc-dev-guide/src/diagnostics/translation.md
@@ -2,12 +2,12 @@
 
 <div class="warning">
 rustc's current diagnostics translation infrastructure (as of
-<!-- date-check --> October 2024
+<!-- date-check --> August 2025
 ) unfortunately causes some friction for compiler contributors, and the current
 infrastructure is mostly pending a redesign that better addresses needs of both
 compiler contributors and translation teams. Note that there is no current
 active redesign proposals (as of
-<!-- date-check --> October 2024
+<!-- date-check --> August 2025
 )!
 
 Please see the tracking issue <https://github.com/rust-lang/rust/issues/132181>
diff --git a/src/doc/rustc-dev-guide/src/tests/ci.md b/src/doc/rustc-dev-guide/src/tests/ci.md
index a8cc959124ff6..95850c07cfe46 100644
--- a/src/doc/rustc-dev-guide/src/tests/ci.md
+++ b/src/doc/rustc-dev-guide/src/tests/ci.md
@@ -22,7 +22,7 @@ jobs](#modifying-ci-jobs).
 
 ## CI workflow
 
-<!-- date-check: Oct 2024 -->
+<!-- date-check: Aug 2025 -->
 
 Our CI is primarily executed on [GitHub Actions], with a single workflow defined
 in [`.github/workflows/ci.yml`], which contains a bunch of steps that are
diff --git a/src/doc/rustc-dev-guide/src/tests/directives.md b/src/doc/rustc-dev-guide/src/tests/directives.md
index fbbeb7e97d3b7..6cf73909b11e9 100644
--- a/src/doc/rustc-dev-guide/src/tests/directives.md
+++ b/src/doc/rustc-dev-guide/src/tests/directives.md
@@ -42,7 +42,7 @@ not be exhaustive. Directives can generally be found by browsing the
 
 ### Assembly
 
-<!-- date-check: Oct 2024 -->
+<!-- date-check: Aug 2025 -->
 
 | Directive         | Explanation                   | Supported test suites | Possible values                        |
 |-------------------|-------------------------------|-----------------------|----------------------------------------|
@@ -113,7 +113,7 @@ for more details.
 | `known-bug`                       | No error annotation needed due to known bug                                                                              | `ui`, `crashes`, `incremental`               | Issue number `#123456`                                                                  |
 | `compare-output-by-lines`         | Compare the output by lines, rather than as a single string                                                              | All                                          | N/A                                                                                     |
 
-[^check_stdout]: presently <!-- date-check: Oct 2024 --> this has a weird quirk
+[^check_stdout]: presently <!-- date-check: Aug 2025 --> this has a weird quirk
     where the test binary's stdout and stderr gets concatenated and then
     `error-pattern`s are matched on this combined output, which is ??? slightly
     questionable to say the least.
diff --git a/src/doc/rustc-dev-guide/src/tests/misc.md b/src/doc/rustc-dev-guide/src/tests/misc.md
index 39f881748792f..ed80c6c3479e0 100644
--- a/src/doc/rustc-dev-guide/src/tests/misc.md
+++ b/src/doc/rustc-dev-guide/src/tests/misc.md
@@ -2,7 +2,7 @@
 
 ## `RUSTC_BOOTSTRAP` and stability
 
-<!-- date-check: Nov 2024 -->
+<!-- date-check: Aug 2025 -->
 
 This is a bootstrap/compiler implementation detail, but it can also be useful
 for testing:

From 8743a04b89dde55dd956014a5793f27a801efab5 Mon Sep 17 00:00:00 2001
From: Stypox <stypox@pm.me>
Date: Fri, 22 Aug 2025 21:07:09 +0200
Subject: [PATCH 0318/1889] Add documentation for tracing

---
 .../doc/img/perfetto_aggregate_statistics.png | Bin 0 -> 77886 bytes
 .../img/perfetto_aggregate_statistics_sql.png | Bin 0 -> 181156 bytes
 src/tools/miri/doc/img/perfetto_span.png      | Bin 0 -> 165716 bytes
 .../doc/img/perfetto_subname_statistics.png   | Bin 0 -> 102585 bytes
 src/tools/miri/doc/img/perfetto_timeline.png  | Bin 0 -> 613708 bytes
 .../perfetto_visualize_argument_values.png    | Bin 0 -> 68014 bytes
 ..._visualize_argument_values_misbehaving.png | Bin 0 -> 68856 bytes
 ...perfetto_visualize_argument_values_sql.png | Bin 0 -> 261657 bytes
 src/tools/miri/doc/tracing.md                 | 292 ++++++++++++++++++
 9 files changed, 292 insertions(+)
 create mode 100644 src/tools/miri/doc/img/perfetto_aggregate_statistics.png
 create mode 100644 src/tools/miri/doc/img/perfetto_aggregate_statistics_sql.png
 create mode 100644 src/tools/miri/doc/img/perfetto_span.png
 create mode 100644 src/tools/miri/doc/img/perfetto_subname_statistics.png
 create mode 100644 src/tools/miri/doc/img/perfetto_timeline.png
 create mode 100644 src/tools/miri/doc/img/perfetto_visualize_argument_values.png
 create mode 100644 src/tools/miri/doc/img/perfetto_visualize_argument_values_misbehaving.png
 create mode 100644 src/tools/miri/doc/img/perfetto_visualize_argument_values_sql.png
 create mode 100644 src/tools/miri/doc/tracing.md

diff --git a/src/tools/miri/doc/img/perfetto_aggregate_statistics.png b/src/tools/miri/doc/img/perfetto_aggregate_statistics.png
new file mode 100644
index 0000000000000000000000000000000000000000..d4fd3826f47e37c4f631ad971573256dc1ef2409
GIT binary patch
literal 77886
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

literal 0
HcmV?d00001

diff --git a/src/tools/miri/doc/img/perfetto_aggregate_statistics_sql.png b/src/tools/miri/doc/img/perfetto_aggregate_statistics_sql.png
new file mode 100644
index 0000000000000000000000000000000000000000..bda92d3885a8f72b8e124f1b7d2146c17a3115d6
GIT binary patch
literal 181156
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

literal 0
HcmV?d00001

diff --git a/src/tools/miri/doc/img/perfetto_span.png b/src/tools/miri/doc/img/perfetto_span.png
new file mode 100644
index 0000000000000000000000000000000000000000..1a7184f22ae60bfd2ca8006dae0c2323260847ce
GIT binary patch
literal 165716
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

literal 0
HcmV?d00001

diff --git a/src/tools/miri/doc/img/perfetto_subname_statistics.png b/src/tools/miri/doc/img/perfetto_subname_statistics.png
new file mode 100644
index 0000000000000000000000000000000000000000..8c86b07e9253f7d8fbbb34655b7174e763b595ab
GIT binary patch
literal 102585
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
HPKNw{(XDb9

literal 0
HcmV?d00001

diff --git a/src/tools/miri/doc/img/perfetto_timeline.png b/src/tools/miri/doc/img/perfetto_timeline.png
new file mode 100644
index 0000000000000000000000000000000000000000..49f8a1fac1d2ebfb7ff3070ccf95fee4342f4ad6
GIT binary patch
literal 613708
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%0A-^9DJ63gKJ#Bm3jsqw@Bst$WCF
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
Z2cI`io{KZS|JJc`a&&bl|K{lV{{yu<Pw4;v

literal 0
HcmV?d00001

diff --git a/src/tools/miri/doc/img/perfetto_visualize_argument_values.png b/src/tools/miri/doc/img/perfetto_visualize_argument_values.png
new file mode 100644
index 0000000000000000000000000000000000000000..1dcbacaf9cb25772ebc365aa9537ec05552cc3c2
GIT binary patch
literal 68014
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

literal 0
HcmV?d00001

diff --git a/src/tools/miri/doc/img/perfetto_visualize_argument_values_misbehaving.png b/src/tools/miri/doc/img/perfetto_visualize_argument_values_misbehaving.png
new file mode 100644
index 0000000000000000000000000000000000000000..beeba8a4a3ac98446d9836767a248d089b0baf94
GIT binary patch
literal 68856
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

literal 0
HcmV?d00001

diff --git a/src/tools/miri/doc/img/perfetto_visualize_argument_values_sql.png b/src/tools/miri/doc/img/perfetto_visualize_argument_values_sql.png
new file mode 100644
index 0000000000000000000000000000000000000000..c7b163b0a570bc3c5c93506dd12915de2125a30a
GIT binary patch
literal 261657
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%0Ar&s#{c9UgISvuQi`TCH
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

literal 0
HcmV?d00001

diff --git a/src/tools/miri/doc/tracing.md b/src/tools/miri/doc/tracing.md
new file mode 100644
index 0000000000000..d7114af947dc1
--- /dev/null
+++ b/src/tools/miri/doc/tracing.md
@@ -0,0 +1,292 @@
+# Documentation for the tracing infrastructure in Miri
+
+Miri can be traced to understand how much time is spent in its various components (e.g. borrow tracker, data race checker, etc.). When tracing is enabled, running Miri will create a `.json` trace file that can be opened and analyzed in [Perfetto](https://ui.perfetto.dev/). For any questions regarding this documentation you may contact [Stypox](https://rust-lang.zulipchat.com/#narrow/dm/627563-Stypox) on Zulip.
+
+## Obtaining a trace file
+
+### From the Miri codebase
+
+All of the tracing functionality in Miri is gated by the `"tracing"` feature flag to ensure it does not create any overhead when unneeded. To compile Miri with this feature enabled, you can pass `--features=tracing` to `./miri`. Then, to make running Miri actually produce a trace file, you also need to set the `MIRI_TRACING` environment variable. For example:
+
+```sh
+MIRI_TRACING=1 ./miri run --features=tracing ./tests/pass/hello.rs
+```
+
+### From the rustc codebase
+
+If you are building Miri from within the rustc tree, you need to enable the `"tracing"` feature by adding this line to `bootstrap.toml`:
+
+```toml
+build.tool.miri.features = ["tracing"]
+```
+
+And then you could run the following:
+
+```sh
+MIRI_TRACING=1 ./x.py run miri --stage 1 --args ./src/tools/miri/tests/pass/hello.rs
+```
+
+### The trace file
+
+After running Miri with tracing enabled you will get a `.json` trace file that contains a list of all events and spans that occurred throughout the execution. The file follows [this format](https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/preview).
+
+## Analyzing a trace file
+
+To analyze traces you can use [Perfetto UI](https://ui.perfetto.dev/), a trace analyzer made by Google that was originally a part of the Chrome browser. Just open Perfetto and drag and drop the `.json` file there. Official documentation for the controls in the UI can be found [here](https://perfetto.dev/docs/visualization/perfetto-ui).
+
+### The timeline
+
+You will see the boxes "Global Legacy Events" and "Process 1" on the left of the workspace: after clicking on either of them their timeline will expand and you will be able to zoom in and look at individual spans (and events).
+
+- "Process 1" contains tracing spans for the various components of Miri, all in a single timeline line (e.g. borrow tracker, data race checker, etc.)
+- "Global Legacy Events" contains auxiliary spans on two separate lines that allow understanding what code is being executed at any point in time:
+    - "frame": what is the current stack frame in the interpreted program
+    - "step": what statement/terminator in the MIR of the interpreted program is being executed
+
+Spans are represented as colored boxes in the timeline, while instantaneous events are represented by tiny arrows. (Events exist because rustc and Miri also use the `tracing` crate for debug logging, and those logs turn into events in the trace.)
+
+![](./img/perfetto_timeline.png)
+
+### Span/event data
+
+You can click on a span or an event to get more information about it, including some arguments that were passed when the span/event was entered/fired. In the following screenshot you can see the details of a "layouting" span that was generated by the following line in Miri's code:
+
+```rust
+let _trace = enter_trace_span!(M, layouting::fn_abi_of_instance, ?instance, ?extra_args);
+```
+
+![](./img/perfetto_span.png)
+
+### SQL tables
+
+Perfetto supports querying the span/event database using SQL queries (see the [docs](https://perfetto.dev/docs/analysis/perfetto-sql-syntax)). Just type `:` in the search bar at the top to enter SQL mode, and then you will be able to enter SQL queries there. The relevant SQL tables are:
+- `slices`: contains all spans and events; events can be distinguished from spans since their `dur` is 0. Relevant columns are:
+    - `id`: a unique primary-key ID for the span (assigned by Perfetto, not present in the trace file)
+    - `ts` and `dur`: the beginning and duration of the span, in nanoseconds
+    - `name`: the name of the span
+    - `parent_id`: the parent span ID, or null if there is no parent (assigned by Perfetto based on the timing at which spans occur, i.e. two nested spans must be one the child of the other)
+    - `arg_set_id`: a foreign key into the table of arguments (1-to-N)
+- `args`: contains all of the arguments of the various events/spans. Relevant columns are:
+    - `arg_set_id`: the key used to join the slices and args tables
+    - `key`: the name of the argument prepended with "args."
+    - `display_value`: the value of the argument
+
+Some useful queries are provided in the following sections.
+
+### Enhancing the timeline
+
+On the "Process 1" timeline line there are some spans with the same name, that are actually generated from different places in Miri's code. In those cases the span name indicates the component that was invoked (e.g. the data race checker), but not the specific function that was run. To inspect the specific function, we store a "subname" in an argument with the same name as the span, which unfortunately can be seen only after clicking on the span.
+
+To make it quicker to look at subnames, you can add a new timeline line that specifically shows the subnames for spans with a specific name. To do so:
+1. select any span with the name you care about (call this name `$NAME`)
+2. click on the dropdown highlighted in blue next on the argument with name `$NAME` (or `args.$NAME`)
+3. click on "Visualize argument values"
+4. a new timeline line will appear with only spans originally named `$NAME`, but now with the subname displayed instead
+
+The following screenshot shows the 4 steps for spans named "data_race":
+
+![](./img/perfetto_visualize_argument_values.png)
+
+### Visualizing which "frame" or "step" is being executed
+
+Unfortunately the instructions in [Enhancing the timeline](#enhancing-the-timeline) only work well with spans under "Process 1", but misbehave with spans under "Global Legacy Events" (see the screenshot below). This might be a bug in Perfetto, but nevertheless a workaround is available:
+
+1. click on the search bar at the top and write `:` to enter SQL mode
+2. copy-paste the following SQL, replace "SPAN_NAME" at the end with either "frame" or "step" (i.e. one of the two span names under "Global Legacy Events"), and press Enter to execute it:
+    ```sql
+    select slices.id, ts, dur, track_id, category, args.string_value as name, depth, stack_id, parent_stack_id, parent_id, slices.arg_set_id, thread_ts, thread_instruction_count, thread_instruction_delta, cat, slice_id
+    from slices inner join args using (arg_set_id)
+    where args.key = "args." || name and name = "SPAN_NAME"
+    ```
+3. at the top-right of the box at the bottom, click on "Show debug track"
+4. press on "Show" in the popup that just appeared
+5. a new debug track will appear with the names of steps or frames
+
+What the SQL does is to select only spans with the name "SPAN_NAME" and keep all of the span fields untouched, except for the name which is replaced with the subname. As explained in [Enhancing the timeline](#enhancing-the-timeline), remember that the subname is stored in an argument with the same name as the span.
+
+![](./img/perfetto_visualize_argument_values_sql.png)
+
+<img src="./img/perfetto_visualize_argument_values_misbehaving.png" width="300px">
+
+### Compute aggregate statistics
+
+The simplest way to get aggregate statistics about a time range is to:
+
+1. select a time range by drag-clicking along a trace line
+2. click on the "Current Selection" tab at the bottom if it's not already open
+3. see various tables/visualizations of how much time is spent in each span by clicking on "Slices", "Pivot Table" or "Slice Flamegraph"
+
+Note that the numbers shown in the "Slices" and "Pivot Table" tabs also include nested spans, so they cannot be used to compute statistics such as "X% of time is spent in spans named Y" because two spans named Y might be nested and their duration would be counted twice. For such statistics use the method in [Compute aggregate statistics (enhanced)](#compute-aggregate-statistics-enhanced).
+
+![](./img/perfetto_aggregate_statistics.png)
+
+### Compute aggregate statistics (enhanced)
+
+The following (long but not complicated) query can be used to find out how much time is spent in spans (grouped by their name). Only spans without a parent are considered towards the computations (see `where parent_id is null`): so for example if `validate_operand` in turn calls `layouting` (which generates a nested/child span), only the `validate_operand` statistics are increased. This query also excludes auxiliary spans (see `name != "frame" and name != "step"`).
+
+Note that this query does not allow selecting a time range, but that can be done by adding a condition, e.g. `ts + dur > MIN_T and ts < MAX_T` would match only spans that intersect the range `(MIN_T, MAX_T)`. Remember that the time unit is nanoseconds.
+
+```sql
+select "TOTAL PROGRAM DURATION" as name, count(*), max(ts + dur) as "sum(dur)", 100.0 as "%", null as "min(dur)", null as "max(dur)", null as "avg(dur)", null as "stddev(dur)"
+from slices
+
+union select "TOTAL OVER ALL SPANS (excluding events)" as name, count(*), sum(dur), cast(cast(sum(dur) as float) / (select max(ts + dur) from slices) * 1000 as int) / 10.0 as "%", min(dur), max(dur), cast(avg(dur) as int) as "avg(dur)", cast(sqrt(avg(dur*dur)-avg(dur)*avg(dur)) as int) as "stddev(dur)"
+from slices
+where parent_id is null and name != "frame" and name != "step" and dur > 0
+
+union select name, count(*), sum(dur), cast(cast(sum(dur) as float) / (select max(ts + dur) from slices) * 1000 as int) / 10.0 as "%", min(dur), max(dur), cast(avg(dur) as int) as "avg(dur)", cast(sqrt(avg(dur*dur)-avg(dur)*avg(dur)) as int) as "stddev(dur)"
+from slices
+where parent_id is null and name != "frame" and name != "step"
+group by name
+order by sum(dur) desc, count(*) desc
+```
+
+This is the kind of table you would get out:
+
+![](./img/perfetto_aggregate_statistics_sql.png)
+
+### Statistics about subnames of a span
+
+Use the following SQL to see statistics about the subnames of spans with the same name (replace "SPAN_NAME" with the name of the span you want to see subname statistics of):
+
+```sql
+select args.string_value as name, count(*), sum(dur), min(dur), max(dur), cast(avg(dur) as int) as "avg(dur)", cast(sqrt(avg(dur*dur)-avg(dur)*avg(dur)) as int) as "stddev(dur)"
+from slices inner join args using (arg_set_id)
+where args.key = "args." || name and name = "SPAN_NAME"
+group by args.string_value
+order by count(*) desc
+```
+
+For example, this is the table of how much time is spent in each borrow tracker function: 
+
+![](./img/perfetto_subname_statistics.png)
+
+### Finding long periods of time without any tracing
+
+The following SQL finds the longest periods of time where time is being spent, with the ability to click on IDs in the table of results to quickly reach the corresponding place. This can be useful to spot things that use up a significant amount of time but that are not yet covered by tracing calls.
+
+```sql
+with ordered as (
+    select s1.*, row_number() over (order by s1.ts) as rn
+    from slices as s1
+    where s1.parent_id is null and s1.dur > 0 and s1.name != "frame" and s1.name != "step"
+)
+select a.ts+a.dur as ts, b.ts-a.ts-a.dur as dur, a.id, a.track_id, a.category, a.depth, a.stack_id, a.parent_stack_id, a.parent_id, a.arg_set_id, a.thread_ts, a.thread_instruction_count, a.thread_instruction_delta, a.cat, a.slice_id, "empty" as name
+from ordered as a inner join ordered as b on a.rn=b.rn-1
+order by b.ts-a.ts-a.dur desc
+```
+
+### Saving Perfetto's state as a preset
+
+Unfortunately Perfetto does not seem to support saving the UI state as a preset that can be used to repeat the same analysis on multiple traces. You have to click through the various menus or run the various SQL queries every time to setup the UI as you want.
+
+## Adding new tracing calls to the code
+
+### The "tracing" feature
+
+Miri is highly interconnected with `rustc_const_eval`, and therefore collecting proper trace data about Miri also involves adding some tracing calls within `rustc_const_eval`'s codebase. As explained in [Obtaining a trace file](#obtaining-a-trace-file), tracing calls are disabled (and optimized out) when Miri's "tracing" feature is not enabled. However, while it is possible to check for the feature from Miri's codebase, it's not possible to do so from `rustc_const_eval` (since it's a separate crate, and it's even in a precompiled `.rlib` in case of out-of-tree builds).
+
+The solution to make it possible to check whether tracing is enabled at compile time even in `rustc_const_eval` was to add a function with this signature to the `Machine` trait:
+```rust
+fn enter_trace_span(span: impl FnOnce() -> tracing::Span) -> impl EnteredTraceSpan
+```
+
+where `EnteredTraceSpan` is just a marker trait implemented by `()` and `tracing::span::EnteredSpan`. This function returns `()` by default (without calling the `span` closure), except in `MiriMachine` where if tracing is enabled it will return `span().entered()`.
+
+The code in `rustc_const_eval` calls this function when it wants to do tracing, and the compiler will (hopefully) optimize out tracing calls when tracing is disabled.
+
+### The `enter_trace_span!()` macro
+
+To add tracing to a section of code in Miri or in `rustc_const_eval`, you can use the `enter_trace_span!()` macro, which takes care of the details explained in [The "tracing" feature](#the-tracing-feature).
+
+The `enter_trace_span!()` macro accepts the same syntax as `tracing::span!()` ([documentation](https://docs.rs/tracing/latest/tracing/#using-the-macros)) except for a few customizations, and returns an already entered trace span. The returned value is a drop guard that will exit the span when dropped, so **make sure to give it a proper scope** by storing it in a variable like this:
+
+```rust
+let _trace = enter_trace_span!("My span");
+```
+
+When calling this macro from `rustc_const_eval` you need to pass a type implementing the `Machine` trait as the first argument (since it will be used to call `Machine::enter_trace_span()`). This is usually available in various parts of `rustc_const_eval` under the name `M`, since most of `rustc_const_eval`'s code is `Machine`-agnostic.
+
+```rust
+let _trace = enter_trace_span!("My span");    // from Miri
+let _trace = enter_trace_span!(M, "My span"); // from rustc_const_eval
+```
+
+You can make sense of the syntaxes explained below also by looking at this Perfetto screenshot from [Span/event data](#spanevent-data).
+
+![](./img/perfetto_span.png)
+
+### Syntax accepted by `tracing::span!()`
+
+The full documentation for the `tracing::span!()` syntax can be found [here](https://docs.rs/tracing/latest/tracing/#using-the-macros) under "Using the Macros". A few possibly confusing syntaxes are listed here:
+```rust
+// logs a span named "hello" with a field named "arg" of value 42 (works only because
+// 42 implements the tracing::Value trait, otherwise use one of the options below)
+let _trace = enter_trace_span!(M, "hello", arg = 42);
+// logs a field called "my_display_var" using the Display implementation
+let _trace = enter_trace_span!(M, "hello", %my_display_var);
+// logs a field called "my_debug_var" using the Debug implementation
+let _trace = enter_trace_span!(M, "hello", ?my_debug_var);
+```
+
+### `NAME::SUBNAME` syntax
+
+In addition to the syntax accepted by `tracing::span!()`, the `enter_trace_span!()` macro optionally allows passing the span name (i.e. the first macro argument) in the form `NAME::SUBNAME` (without quotes) to indicate that the span has name "NAME" (usually the name of the component) and has an additional more specific name "SUBNAME" (usually the function name). The latter is passed to the tracing crate as a span field with the name "NAME". This allows not being distracted by subnames when looking at the trace in Perfetto, but when deeper introspection is needed within a component, it's still possible to view the subnames directly with a few steps (see [Enhancing the timeline](#enhancing-the-timeline)).
+```rust
+// for example, the first will expand to the second
+let _trace = enter_trace_span!(M, borrow_tracker::on_stack_pop);
+let _trace = enter_trace_span!(M, "borrow_tracker", borrow_tracker = "on_stack_pop");
+```
+
+### `tracing_separate_thread` parameter
+
+Miri saves traces using the the `tracing_chrome` `tracing::Layer` so that they can be visualized in Perfetto. To instruct `tracing_chrome` to put some spans on a separate trace thread/line than other spans when viewed in Perfetto, you can pass `tracing_separate_thread = tracing::field::Empty` to the tracing macros. This is useful to separate out spans which just indicate the current step or program frame being processed by the interpreter. As explained in [The timeline](#the-timeline), those spans end up under the "Global Legacy Events" track. You should use a value of `tracing::field::Empty` so that other tracing layers (e.g. the logger) will ignore the `tracing_separate_thread` field. For example:
+```rust
+let _trace = enter_trace_span!(M, step::eval_statement, tracing_separate_thread = tracing::field::Empty);
+```
+
+### Executing something else when tracing is disabled
+
+The `EnteredTraceSpan` trait contains a `or_if_tracing_disabled()` function that you can use to e.g. log a line as an alternative to the tracing span for when tracing is disabled. For example:
+```rust
+let _trace = enter_trace_span!(M, step::eval_statement)
+    .or_if_tracing_disabled(|| tracing::info!("eval_statement"));
+```
+
+## Implementation details
+
+Here we explain how tracing is implemented internally.
+
+The events and spans generated throughout the codebase are collected by [the `tracing` crate](https://crates.io/crates/tracing), which then dispatches them to the code that writes to the trace file, but also to the logger if logging is enabled. 
+
+### Choice of tracing library
+
+The crate that was chosen for collecting traces is [tracing](https://crates.io/crates/tracing), since:
+- it is very well maintained
+- it supports various different trace formats through plug-and-play `Layer`s (in Miri we are using `tracing_chrome` to export traces for perfetto, see [The `tracing_chrome` layer](#the-tracing_chrome-layer))
+- spans and events are collected with not just their name, but also file, line, module, and any number of custom arguments
+- it was already used in Miri and rustc as a logging framework 
+
+One major drawback of the tracing crate is, however, its big overhead. Entering and exiting a span takes on the order of 100ns, and many of Miri's spans are shorter than that, so their measurements are completely off and the program execution increases significantly. E.g. at the point of writing this documentation, enabling tracing makes Miri 5x slower. Note that this used to be even worse, see [Time measurements](#time-measurements).
+
+### The `tracing_chrome` layer
+
+Miri uses [tracing-chrome](https://github.com/thoren-d/tracing-chrome) as the `Layer` that collects spans and events from the tracing crate and saves them to a file that can be opened in Perfetto. Although the crate [is published](https://crates.io/crates/tracing-chrome) on crates.io, it was not possible to depend on it from Miri, because it would bring in a separate compilation of the `tracing` crate. This is because Miri does not directly depend on `tracing`, and instead uses rustc's version through rustc-private, and apparently cargo can't realize that the same library is being built again when rustc-private is involved.
+
+So the solution was to copy-paste [the only file](https://github.com/thoren-d/tracing-chrome/blob/develop/src/lib.rs) in tracing-chrome into Miri. Nevertheless, this gave the possibility to make some changes to tracing-chrome, which you can read about in documentation at the top of [the file](https://github.com/rust-lang/miri/blob/master/src/bin/log/tracing_chrome.rs) that was copied to Miri.
+
+### Time measurements
+
+tracing-chrome originally used `std::time::Instant` to measure time, however on some x86/x86_64 Linux systems it might be unbearably slow since the underlying system call (`clock_gettime`) would take ≈1.3µs. Read more [here](https://btorpey.github.io/blog/2014/02/18/clock-sources-in-linux/) about how the Linux kernel chooses the clock source.
+
+Therefore, on x86/x86_64 Linux systems with a CPU that has an invariant TSC counter, we read from that instead to measure time, which takes only ≈13ns. There are unfortunately a lot of caveats to this approach though, as explained [in the code](https://github.com/rust-lang/miri/blob/master/src/bin/log/tracing_chrome_instant.rs) and [in the PR](https://github.com/rust-lang/miri/pull/4524). The most impactful one is that: every thread spawned in Miri that wants to trace something (which requires measuring time) needs to pin itself to a single CPU core (using `sched_setaffinity`).
+
+## Other useful stuff
+
+### Making a flamegraph
+
+After compiling Miri, you can run the following command to make a flamegraph using Linux' `perf`. It can be useful to spot functions that use up a significant amount of time but that are not yet covered by tracing calls.
+
+```sh
+perf record  --call-graph dwarf -F 999 ./miri/target/debug/miri --edition 2021 --sysroot ~/.cache/miri ./tests/pass/hashmap.rs && perf script | inferno-collapse-perf | inferno-flamegraph > flamegraph.svg
+```

From b616ba8496d85b19f47ca98d3f6793326780c1e0 Mon Sep 17 00:00:00 2001
From: yanglsh <yanglsh@shanghaitech.edu.cn>
Date: Thu, 28 Aug 2025 10:15:50 +0800
Subject: [PATCH 0319/1889] fix: `print_literal` suggests wrongly for inline
 literal following a numbered arg

---
 clippy_lints/src/write.rs     | 13 ++++--------
 tests/ui/print_literal.fixed  | 13 ++++++++++++
 tests/ui/print_literal.rs     | 14 +++++++++++++
 tests/ui/print_literal.stderr | 38 ++++++++++++++++++++++++++++++++++-
 4 files changed, 68 insertions(+), 10 deletions(-)

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index a15e4e42e71df..c55c5ec2f51ae 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -537,7 +537,7 @@ fn check_literal(cx: &LateContext<'_>, format_args: &FormatArgs, name: &str) {
 
             sug_span = Some(sug_span.unwrap_or(arg.expr.span).to(arg.expr.span));
 
-            if let Some((_, index)) = positional_arg_piece_span(piece) {
+            if let Some((_, index)) = format_arg_piece_span(piece) {
                 replaced_position.push(index);
             }
 
@@ -569,16 +569,11 @@ fn check_literal(cx: &LateContext<'_>, format_args: &FormatArgs, name: &str) {
     }
 }
 
-/// Extract Span and its index from the given `piece`, if it's positional argument.
-fn positional_arg_piece_span(piece: &FormatArgsPiece) -> Option<(Span, usize)> {
+/// Extract Span and its index from the given `piece`
+fn format_arg_piece_span(piece: &FormatArgsPiece) -> Option<(Span, usize)> {
     match piece {
         FormatArgsPiece::Placeholder(FormatPlaceholder {
-            argument:
-                FormatArgPosition {
-                    index: Ok(index),
-                    kind: FormatArgPositionKind::Number,
-                    ..
-                },
+            argument: FormatArgPosition { index: Ok(index), .. },
             span: Some(span),
             ..
         }) => Some((*span, *index)),
diff --git a/tests/ui/print_literal.fixed b/tests/ui/print_literal.fixed
index ebfe19c700ee6..26139f9b67102 100644
--- a/tests/ui/print_literal.fixed
+++ b/tests/ui/print_literal.fixed
@@ -105,3 +105,16 @@ fn issue_14930() {
     println!("Hello x is {0:2$.1$}", 0.01, 2, 3);
     //~^ print_literal
 }
+
+fn issue_15576() {
+    println!("Hello x is {1:.*}", 5, 0.01);
+    //~^ print_literal
+
+    println!("Hello x is {:.p$}", 0.01, p = 5);
+    //~^ print_literal
+
+    println!(
+        "Hello name: x is {1:.*} (which {1} with {0} places)", 5, 0.01
+    );
+    //~^^ print_literal
+}
diff --git a/tests/ui/print_literal.rs b/tests/ui/print_literal.rs
index 8f3d9be069854..7c4cf028e84cc 100644
--- a/tests/ui/print_literal.rs
+++ b/tests/ui/print_literal.rs
@@ -106,3 +106,17 @@ fn issue_14930() {
     println!("Hello {0} is {1:3$.2$}", "x", 0.01, 2, 3);
     //~^ print_literal
 }
+
+fn issue_15576() {
+    println!("Hello {} is {2:.*}", "x", 5, 0.01);
+    //~^ print_literal
+
+    println!("Hello {} is {:.p$}", "x", 0.01, p = 5);
+    //~^ print_literal
+
+    println!(
+        "Hello {}: {2} is {3:.*} (which {3} with {1} places)",
+        "name", 5, "x", 0.01
+    );
+    //~^^ print_literal
+}
diff --git a/tests/ui/print_literal.stderr b/tests/ui/print_literal.stderr
index 1c378017d151b..c136f52800f69 100644
--- a/tests/ui/print_literal.stderr
+++ b/tests/ui/print_literal.stderr
@@ -277,5 +277,41 @@ LL -     println!("Hello {0} is {1:3$.2$}", "x", 0.01, 2, 3);
 LL +     println!("Hello x is {0:2$.1$}", 0.01, 2, 3);
    |
 
-error: aborting due to 22 previous errors
+error: literal with an empty format string
+  --> tests/ui/print_literal.rs:111:36
+   |
+LL |     println!("Hello {} is {2:.*}", "x", 5, 0.01);
+   |                                    ^^^
+   |
+help: try
+   |
+LL -     println!("Hello {} is {2:.*}", "x", 5, 0.01);
+LL +     println!("Hello x is {1:.*}", 5, 0.01);
+   |
+
+error: literal with an empty format string
+  --> tests/ui/print_literal.rs:114:36
+   |
+LL |     println!("Hello {} is {:.p$}", "x", 0.01, p = 5);
+   |                                    ^^^
+   |
+help: try
+   |
+LL -     println!("Hello {} is {:.p$}", "x", 0.01, p = 5);
+LL +     println!("Hello x is {:.p$}", 0.01, p = 5);
+   |
+
+error: literal with an empty format string
+  --> tests/ui/print_literal.rs:119:9
+   |
+LL |         "name", 5, "x", 0.01
+   |         ^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -         "Hello {}: {2} is {3:.*} (which {3} with {1} places)",
+LL +         "Hello name: x is {1:.*} (which {1} with {0} places)", 5, 0.01
+   |
+
+error: aborting due to 25 previous errors
 

From 0a5502208d7c7625f3a4806c422dfed47cc364ba Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Thu, 28 Aug 2025 18:54:46 +0300
Subject: [PATCH 0320/1889] Add progress bars to more places in analysis-stats

Namely, mir lowering, const eval and IDE things.
---
 .../rust-analyzer/src/cli/analysis_stats.rs   | 55 ++++++++++++++++++-
 1 file changed, 52 insertions(+), 3 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
index b17186f8d7b1e..d685f160ff098 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -333,7 +333,7 @@ impl flags::AnalysisStats {
         }
 
         if self.run_all_ide_things {
-            self.run_ide_things(host.analysis(), file_ids.clone());
+            self.run_ide_things(host.analysis(), file_ids.clone(), db, &vfs, verbosity);
         }
 
         if self.run_term_search {
@@ -393,15 +393,27 @@ impl flags::AnalysisStats {
     }
 
     fn run_const_eval(&self, db: &RootDatabase, bodies: &[DefWithBody], verbosity: Verbosity) {
+        let len = bodies
+            .iter()
+            .filter(|body| matches!(body, DefWithBody::Const(_) | DefWithBody::Static(_)))
+            .count();
+        let mut bar = match verbosity {
+            Verbosity::Quiet | Verbosity::Spammy => ProgressReport::hidden(),
+            _ if self.parallel || self.output.is_some() => ProgressReport::hidden(),
+            _ => ProgressReport::new(len),
+        };
+
         let mut sw = self.stop_watch();
         let mut all = 0;
         let mut fail = 0;
         for &b in bodies {
+            bar.set_message(move || format!("const eval: {}", full_name(db, b, b.module(db))));
             let res = match b {
                 DefWithBody::Const(c) => c.eval(db),
                 DefWithBody::Static(s) => s.eval(db),
                 _ => continue,
             };
+            bar.inc(1);
             all += 1;
             let Err(error) = res else {
                 continue;
@@ -409,10 +421,11 @@ impl flags::AnalysisStats {
             if verbosity.is_spammy() {
                 let full_name =
                     full_name_of_item(db, b.module(db), b.name(db).unwrap_or(Name::missing()));
-                println!("Const eval for {full_name} failed due {error:?}");
+                bar.println(format!("Const eval for {full_name} failed due {error:?}"));
             }
             fail += 1;
         }
+        bar.finish_and_clear();
         let const_eval_time = sw.elapsed();
         eprintln!("{:<20} {}", "Const evaluation:", const_eval_time);
         eprintln!("Failed const evals: {fail} ({}%)", percentage(fail, all));
@@ -662,6 +675,10 @@ impl flags::AnalysisStats {
         let mut all = 0;
         let mut fail = 0;
         for &body_id in bodies {
+            bar.set_message(move || {
+                format!("mir lowering: {}", full_name(db, body_id, body_id.module(db)))
+            });
+            bar.inc(1);
             if matches!(body_id, DefWithBody::Variant(_)) {
                 continue;
             }
@@ -1089,12 +1106,29 @@ impl flags::AnalysisStats {
         report_metric("body lowering time", body_lowering_time.time.as_millis() as u64, "ms");
     }
 
-    fn run_ide_things(&self, analysis: Analysis, mut file_ids: Vec<EditionedFileId>) {
+    fn run_ide_things(
+        &self,
+        analysis: Analysis,
+        mut file_ids: Vec<EditionedFileId>,
+        db: &RootDatabase,
+        vfs: &Vfs,
+        verbosity: Verbosity,
+    ) {
+        let len = file_ids.len();
+        let create_bar = || match verbosity {
+            Verbosity::Quiet | Verbosity::Spammy => ProgressReport::hidden(),
+            _ if self.parallel || self.output.is_some() => ProgressReport::hidden(),
+            _ => ProgressReport::new(len),
+        };
+
         file_ids.sort();
         file_ids.dedup();
         let mut sw = self.stop_watch();
 
+        let mut bar = create_bar();
         for &file_id in &file_ids {
+            let msg = format!("diagnostics: {}", vfs.file_path(file_id.file_id(db)));
+            bar.set_message(move || msg.clone());
             _ = analysis.full_diagnostics(
                 &DiagnosticsConfig {
                     enabled: true,
@@ -1121,8 +1155,14 @@ impl flags::AnalysisStats {
                 ide::AssistResolveStrategy::All,
                 analysis.editioned_file_id_to_vfs(file_id),
             );
+            bar.inc(1);
         }
+        bar.finish_and_clear();
+
+        let mut bar = create_bar();
         for &file_id in &file_ids {
+            let msg = format!("inlay hints: {}", vfs.file_path(file_id.file_id(db)));
+            bar.set_message(move || msg.clone());
             _ = analysis.inlay_hints(
                 &InlayHintsConfig {
                     render_colons: false,
@@ -1158,8 +1198,14 @@ impl flags::AnalysisStats {
                 analysis.editioned_file_id_to_vfs(file_id),
                 None,
             );
+            bar.inc(1);
         }
+        bar.finish_and_clear();
+
+        let mut bar = create_bar();
         for &file_id in &file_ids {
+            let msg = format!("annotations: {}", vfs.file_path(file_id.file_id(db)));
+            bar.set_message(move || msg.clone());
             analysis
                 .annotations(
                     &AnnotationConfig {
@@ -1178,7 +1224,10 @@ impl flags::AnalysisStats {
                 .for_each(|annotation| {
                     _ = analysis.resolve_annotation(annotation);
                 });
+            bar.inc(1);
         }
+        bar.finish_and_clear();
+
         let ide_time = sw.elapsed();
         eprintln!("{:<20} {} ({} files)", "IDE:", ide_time, file_ids.len());
     }

From 8e618a92c122a1546e21d86f7b6ef9cae197ec6f Mon Sep 17 00:00:00 2001
From: Ali Nazzal <ali90h7@pm.me>
Date: Thu, 28 Aug 2025 19:00:47 +0300
Subject: [PATCH 0321/1889] dates(infra): refresh date-check annotations for
 Aug 2025; preserve local style

---
 src/doc/rustc-dev-guide/src/backend/updating-llvm.md | 4 ++--
 src/doc/rustc-dev-guide/src/fuzzing.md               | 2 +-
 src/doc/rustc-dev-guide/src/overview.md              | 2 +-
 src/doc/rustc-dev-guide/src/parallel-rustc.md        | 8 ++++----
 src/doc/rustc-dev-guide/src/profiling.md             | 2 +-
 src/doc/rustc-dev-guide/src/rustdoc-internals.md     | 6 +++---
 6 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/backend/updating-llvm.md b/src/doc/rustc-dev-guide/src/backend/updating-llvm.md
index ebef15d40baf5..a4e22b7398403 100644
--- a/src/doc/rustc-dev-guide/src/backend/updating-llvm.md
+++ b/src/doc/rustc-dev-guide/src/backend/updating-llvm.md
@@ -1,6 +1,6 @@
 # Updating LLVM
 
-<!-- date-check: Aug 2024 -->
+<!-- date-check: Aug 2025 -->
 Rust supports building against multiple LLVM versions:
 
 * Tip-of-tree for the current LLVM development branch is usually supported
@@ -93,7 +93,7 @@ An example PR:
 
 ## New LLVM Release Updates
 
-<!-- date-check: Jul 2023 -->
+<!-- date-check: Aug 2025 -->
 
 Unlike bugfixes,
 updating to a new release of LLVM typically requires a lot more work.
diff --git a/src/doc/rustc-dev-guide/src/fuzzing.md b/src/doc/rustc-dev-guide/src/fuzzing.md
index 3000537861778..540a8c6906150 100644
--- a/src/doc/rustc-dev-guide/src/fuzzing.md
+++ b/src/doc/rustc-dev-guide/src/fuzzing.md
@@ -1,6 +1,6 @@
 # Fuzzing
 
-<!-- date-check: Mar 2023 -->
+<!-- date-check: Aug 2025 -->
 
 For the purposes of this guide, *fuzzing* is any testing methodology that
 involves compiling a wide variety of programs in an attempt to uncover bugs in
diff --git a/src/doc/rustc-dev-guide/src/overview.md b/src/doc/rustc-dev-guide/src/overview.md
index 378d8c4453f89..9f0201942d01d 100644
--- a/src/doc/rustc-dev-guide/src/overview.md
+++ b/src/doc/rustc-dev-guide/src/overview.md
@@ -304,7 +304,7 @@ Moreover, the compiler wasn't originally built to use a query system; the query
 system has been retrofitted into the compiler, so parts of it are not query-fied
 yet. Also, LLVM isn't our code, so that isn't querified either. The plan is to
 eventually query-fy all of the steps listed in the previous section,
-but as of <!-- date-check --> November 2022, only the steps between `HIR` and
+but as of <!-- date-check --> August 2025, only the steps between `HIR` and
 `LLVM-IR` are query-fied. That is, lexing, parsing, name resolution, and macro
 expansion are done all at once for the whole program.
 
diff --git a/src/doc/rustc-dev-guide/src/parallel-rustc.md b/src/doc/rustc-dev-guide/src/parallel-rustc.md
index ce69b66c2daf5..b448243223f2e 100644
--- a/src/doc/rustc-dev-guide/src/parallel-rustc.md
+++ b/src/doc/rustc-dev-guide/src/parallel-rustc.md
@@ -1,14 +1,14 @@
 # Parallel compilation
 
 <div class="warning">
-As of <!-- date-check --> November 2024,
+As of <!-- date-check --> August 2025,
 the parallel front-end is undergoing significant changes,
 so this page contains quite a bit of outdated information.
 
 Tracking issue: <https://github.com/rust-lang/rust/issues/113349>
 </div>
 
-As of <!-- date-check --> November 2024, most of the rust compiler is now
+As of <!-- date-check --> August 2025, most of the rust compiler is now
 parallelized.
 
 - The codegen part is executed concurrently by default. You can use the `-C
@@ -104,7 +104,7 @@ when `parallel-compiler` is true.
 | **ModuleItems::par_foreign_items**(&self, f: impl Fn(ForeignItemId)) | run `f` on all foreign items in the module                   | rustc_middle::hir          |
 
 There are a lot of loops in the compiler which can possibly be parallelized
-using these functions. As of <!-- date-check--> August 2022, scenarios where
+using these functions. As of <!-- date-check--> August 2025, scenarios where
 the parallel iterator function has been used are as follows:
 
 | caller                                                  | scenario                                                     | callee                   |
@@ -155,7 +155,7 @@ open feature tracking issue][tracking].
 
 ## Rustdoc
 
-As of <!-- date-check--> November 2022, there are still a number of steps to
+As of <!-- date-check--> August 2025, there are still a number of steps to
 complete before `rustdoc` rendering can be made parallel (see a open discussion
 of [parallel `rustdoc`][parallel-rustdoc]).
 
diff --git a/src/doc/rustc-dev-guide/src/profiling.md b/src/doc/rustc-dev-guide/src/profiling.md
index de06bd7cda7b3..7dfd74aba3a07 100644
--- a/src/doc/rustc-dev-guide/src/profiling.md
+++ b/src/doc/rustc-dev-guide/src/profiling.md
@@ -108,6 +108,6 @@ The llvm-lines output is affected by several options.
 
 MIR optimizations have little impact. Compared to the default `RUSTFLAGS="-Z
 mir-opt-level=1"`, level 0 adds 0.3GB and level 2 removes 0.2GB.
-As of <!-- date-check --> July 2022,
+As of <!-- date-check --> August 2025,
 inlining happens in LLVM and GCC codegen backends,
 missing only in the Cranelift one.
diff --git a/src/doc/rustc-dev-guide/src/rustdoc-internals.md b/src/doc/rustc-dev-guide/src/rustdoc-internals.md
index 4affbafe4777a..02abce2e63ad1 100644
--- a/src/doc/rustc-dev-guide/src/rustdoc-internals.md
+++ b/src/doc/rustc-dev-guide/src/rustdoc-internals.md
@@ -99,7 +99,7 @@ regarding dropping private/hidden items can be bypassed by passing
 `--document-private-items` to `rustdoc`. Note that unlike the previous set of [`AST`][ast]
 transformations, the passes are run on the _cleaned_ crate.
 
-Here is the list of passes as of <!-- date-check --> March 2023:
+Here is the list of passes as of <!-- date-check --> August 2025:
 
 - `calculate-doc-coverage` calculates information used for the `--show-coverage`
   flag.
@@ -122,7 +122,7 @@ Here is the list of passes as of <!-- date-check --> March 2023:
   - `bare_urls` detects links that are not linkified, e.g., in Markdown such as
     `Go to https://example.com/.` It suggests wrapping the link with angle brackets:
     `Go to <https://example.com/>.` to linkify it. This is the code behind the <!--
-    date-check: may 2022 --> `rustdoc::bare_urls` `lint`.
+    date-check: Aug 2025 --> `rustdoc::bare_urls` `lint`.
 
   - `check_code_block_syntax` validates syntax inside Rust code blocks
     (<code>```rust</code>)
@@ -212,7 +212,7 @@ directly, even during `HTML` generation. This [didn't used to be the case], and
 a lot of `rustdoc`'s architecture was designed around not doing that, but a
 `TyCtxt` is now passed to `formats::renderer::run_format`, which is used to
 run generation for both `HTML` and the
-(unstable as of <!-- date-check --> March 2023) JSON format.
+(unstable as of <!-- date-check --> August 2025) JSON format.
 
 This change has allowed other changes to remove data from the "clean" [`AST`][ast]
 that can be easily derived from `TyCtxt` queries, and we'll usually accept

From c36b75bdc8634f0d9cba824410df7a8c3785bda4 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Thu, 28 Aug 2025 19:24:46 +0300
Subject: [PATCH 0322/1889] Don't require a full `InferenceTable` for `CastTy`

A DB is enough.
---
 .../crates/hir-ty/src/infer/cast.rs           | 100 ++++++++----------
 .../crates/hir-ty/src/mir/lower.rs            |  11 +-
 2 files changed, 52 insertions(+), 59 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs
index 09b983a580d97..43364963eb054 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs
@@ -6,7 +6,9 @@ use stdx::never;
 
 use crate::{
     Adjustment, Binders, DynTy, InferenceDiagnostic, Interner, PlaceholderIndex,
-    QuantifiedWhereClauses, Ty, TyExt, TyKind, TypeFlags, WhereClause, from_chalk_trait_id,
+    QuantifiedWhereClauses, Ty, TyExt, TyKind, TypeFlags, WhereClause,
+    db::HirDatabase,
+    from_chalk_trait_id,
     infer::{coerce::CoerceNever, unify::InferenceTable},
 };
 
@@ -30,7 +32,7 @@ pub(crate) enum CastTy {
 }
 
 impl CastTy {
-    pub(crate) fn from_ty(table: &mut InferenceTable<'_>, t: &Ty) -> Option<Self> {
+    pub(crate) fn from_ty(db: &dyn HirDatabase, t: &Ty) -> Option<Self> {
         match t.kind(Interner) {
             TyKind::Scalar(Scalar::Bool) => Some(Self::Int(Int::Bool)),
             TyKind::Scalar(Scalar::Char) => Some(Self::Int(Int::Char)),
@@ -43,8 +45,8 @@ impl CastTy {
                 let (AdtId::EnumId(id), _) = t.as_adt()? else {
                     return None;
                 };
-                let enum_data = id.enum_variants(table.db);
-                if enum_data.is_payload_free(table.db) { Some(Self::Int(Int::CEnum)) } else { None }
+                let enum_data = id.enum_variants(db);
+                if enum_data.is_payload_free(db) { Some(Self::Int(Int::CEnum)) } else { None }
             }
             TyKind::Raw(m, ty) => Some(Self::Ptr(ty.clone(), *m)),
             TyKind::Function(_) => Some(Self::FnPtr),
@@ -142,58 +144,50 @@ impl CastCheck {
     where
         F: FnMut(ExprId, Vec<Adjustment>),
     {
-        let (t_from, t_cast) =
-            match (CastTy::from_ty(table, &self.expr_ty), CastTy::from_ty(table, &self.cast_ty)) {
-                (Some(t_from), Some(t_cast)) => (t_from, t_cast),
-                (None, Some(t_cast)) => match self.expr_ty.kind(Interner) {
-                    TyKind::FnDef(..) => {
-                        let sig = self.expr_ty.callable_sig(table.db).expect("FnDef had no sig");
-                        let sig = table.eagerly_normalize_and_resolve_shallow_in(sig);
-                        let fn_ptr = TyKind::Function(sig.to_fn_ptr()).intern(Interner);
-                        if let Ok((adj, _)) = table.coerce(&self.expr_ty, &fn_ptr, CoerceNever::Yes)
-                        {
-                            apply_adjustments(self.source_expr, adj);
-                        } else {
-                            return Err(CastError::IllegalCast);
-                        }
-
-                        (CastTy::FnPtr, t_cast)
+        let (t_from, t_cast) = match (
+            CastTy::from_ty(table.db, &self.expr_ty),
+            CastTy::from_ty(table.db, &self.cast_ty),
+        ) {
+            (Some(t_from), Some(t_cast)) => (t_from, t_cast),
+            (None, Some(t_cast)) => match self.expr_ty.kind(Interner) {
+                TyKind::FnDef(..) => {
+                    let sig = self.expr_ty.callable_sig(table.db).expect("FnDef had no sig");
+                    let sig = table.eagerly_normalize_and_resolve_shallow_in(sig);
+                    let fn_ptr = TyKind::Function(sig.to_fn_ptr()).intern(Interner);
+                    if let Ok((adj, _)) = table.coerce(&self.expr_ty, &fn_ptr, CoerceNever::Yes) {
+                        apply_adjustments(self.source_expr, adj);
+                    } else {
+                        return Err(CastError::IllegalCast);
                     }
-                    TyKind::Ref(mutbl, _, inner_ty) => {
-                        return match t_cast {
-                            CastTy::Int(_) | CastTy::Float => match inner_ty.kind(Interner) {
-                                TyKind::Scalar(
-                                    Scalar::Int(_) | Scalar::Uint(_) | Scalar::Float(_),
-                                )
-                                | TyKind::InferenceVar(
-                                    _,
-                                    TyVariableKind::Integer | TyVariableKind::Float,
-                                ) => Err(CastError::NeedDeref),
-
-                                _ => Err(CastError::NeedViaPtr),
-                            },
-                            // array-ptr-cast
-                            CastTy::Ptr(t, m) => {
-                                let t = table.eagerly_normalize_and_resolve_shallow_in(t);
-                                if !table.is_sized(&t) {
-                                    return Err(CastError::IllegalCast);
-                                }
-                                self.check_ref_cast(
-                                    table,
-                                    inner_ty,
-                                    *mutbl,
-                                    &t,
-                                    m,
-                                    apply_adjustments,
-                                )
+
+                    (CastTy::FnPtr, t_cast)
+                }
+                TyKind::Ref(mutbl, _, inner_ty) => {
+                    return match t_cast {
+                        CastTy::Int(_) | CastTy::Float => match inner_ty.kind(Interner) {
+                            TyKind::Scalar(Scalar::Int(_) | Scalar::Uint(_) | Scalar::Float(_))
+                            | TyKind::InferenceVar(
+                                _,
+                                TyVariableKind::Integer | TyVariableKind::Float,
+                            ) => Err(CastError::NeedDeref),
+
+                            _ => Err(CastError::NeedViaPtr),
+                        },
+                        // array-ptr-cast
+                        CastTy::Ptr(t, m) => {
+                            let t = table.eagerly_normalize_and_resolve_shallow_in(t);
+                            if !table.is_sized(&t) {
+                                return Err(CastError::IllegalCast);
                             }
-                            _ => Err(CastError::NonScalar),
-                        };
-                    }
-                    _ => return Err(CastError::NonScalar),
-                },
+                            self.check_ref_cast(table, inner_ty, *mutbl, &t, m, apply_adjustments)
+                        }
+                        _ => Err(CastError::NonScalar),
+                    };
+                }
                 _ => return Err(CastError::NonScalar),
-            };
+            },
+            _ => return Err(CastError::NonScalar),
+        };
 
         // rustc checks whether the `expr_ty` is foreign adt with `non_exhaustive` sym
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
index 8c03ca939e370..2d53d16c57a30 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
@@ -31,7 +31,7 @@ use crate::{
     display::{DisplayTarget, HirDisplay, hir_display_with_store},
     error_lifetime,
     generics::generics,
-    infer::{CaptureKind, CapturedItem, TypeMismatch, cast::CastTy, unify::InferenceTable},
+    infer::{CaptureKind, CapturedItem, TypeMismatch, cast::CastTy},
     inhabitedness::is_ty_uninhabited_from,
     layout::LayoutError,
     mapping::ToChalk,
@@ -948,8 +948,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
                     let cast_kind = if source_ty.as_reference().is_some() {
                         CastKind::PointerCoercion(PointerCast::ArrayToPointer)
                     } else {
-                        let mut table = InferenceTable::new(self.db, self.env.clone());
-                        cast_kind(&mut table, &source_ty, &target_ty)?
+                        cast_kind(self.db, &source_ty, &target_ty)?
                     };
 
                     Rvalue::Cast(cast_kind, it, target_ty)
@@ -2017,9 +2016,9 @@ impl<'ctx> MirLowerCtx<'ctx> {
     }
 }
 
-fn cast_kind(table: &mut InferenceTable<'_>, source_ty: &Ty, target_ty: &Ty) -> Result<CastKind> {
-    let from = CastTy::from_ty(table, source_ty);
-    let cast = CastTy::from_ty(table, target_ty);
+fn cast_kind(db: &dyn HirDatabase, source_ty: &Ty, target_ty: &Ty) -> Result<CastKind> {
+    let from = CastTy::from_ty(db, source_ty);
+    let cast = CastTy::from_ty(db, target_ty);
     Ok(match (from, cast) {
         (Some(CastTy::Ptr(..) | CastTy::FnPtr), Some(CastTy::Int(_))) => {
             CastKind::PointerExposeAddress

From d9022991f0293971262e902388fff1b4fc8fde8b Mon Sep 17 00:00:00 2001
From: Ali Nazzal <ali90h7@pm.me>
Date: Thu, 28 Aug 2025 22:26:42 +0300
Subject: [PATCH 0323/1889] dates(queries): refresh date-check annotations to
 2025-08; preserve local style

---
 .../src/queries/query-evaluation-model-in-detail.md             | 2 +-
 src/doc/rustc-dev-guide/src/queries/salsa.md                    | 2 +-
 src/doc/rustc-dev-guide/src/query.md                            | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/queries/query-evaluation-model-in-detail.md b/src/doc/rustc-dev-guide/src/queries/query-evaluation-model-in-detail.md
index c1a4373f7dac6..f487707cd327e 100644
--- a/src/doc/rustc-dev-guide/src/queries/query-evaluation-model-in-detail.md
+++ b/src/doc/rustc-dev-guide/src/queries/query-evaluation-model-in-detail.md
@@ -74,7 +74,7 @@ executed, no results are cached. But the context already provides access to
 "input" data, i.e. pieces of immutable data that were computed before the
 context was created and that queries can access to do their computations.
 
-As of <!-- date-check --> January 2021, this input data consists mainly of
+As of <!-- date-check --> August 2025, this input data consists mainly of
 the HIR map, upstream crate metadata, and the command-line options the compiler
 was invoked with; but in the future inputs will just consist of command-line
 options and a list of source files -- the HIR map will itself be provided by a
diff --git a/src/doc/rustc-dev-guide/src/queries/salsa.md b/src/doc/rustc-dev-guide/src/queries/salsa.md
index dc7160edc22cd..c0caa201f971b 100644
--- a/src/doc/rustc-dev-guide/src/queries/salsa.md
+++ b/src/doc/rustc-dev-guide/src/queries/salsa.md
@@ -7,7 +7,7 @@ want to watch [Salsa In More
 Depth](https://www.youtube.com/watch?v=i_IhACacPRY), also by Niko
 Matsakis.
 
-> As of <!-- date-check --> November 2022, although Salsa is inspired by (among
+> As of <!-- date-check --> August 2025, although Salsa is inspired by (among
 > other things) rustc's query system, it is not used directly in rustc. It
 > _is_ used in [chalk], an implementation of  Rust's trait system, and
 > extensively in [`rust-analyzer`], the official implementation of the language
diff --git a/src/doc/rustc-dev-guide/src/query.md b/src/doc/rustc-dev-guide/src/query.md
index 8377a7b2f31a7..0a92731947101 100644
--- a/src/doc/rustc-dev-guide/src/query.md
+++ b/src/doc/rustc-dev-guide/src/query.md
@@ -1,7 +1,7 @@
 # Queries: demand-driven compilation
 
 As described in [Overview of the compiler], the Rust compiler
-is still (as of <!-- date-check --> July 2021) transitioning from a
+is still (as of <!-- date-check --> August 2025) transitioning from a
 traditional "pass-based" setup to a "demand-driven" system. The compiler query
 system is the key to rustc's demand-driven organization.
 The idea is pretty simple. Instead of entirely independent passes

From a557aef8813f1d300ba8c21eb4f24f3350a28f7e Mon Sep 17 00:00:00 2001
From: Ali Nazzal <ali90h7@pm.me>
Date: Thu, 28 Aug 2025 22:34:41 +0300
Subject: [PATCH 0324/1889] dates(types,traits): refresh date-check annotations
 for Aug/2025-08; preserve local style

---
 .../src/borrow_check/region_inference/member_constraints.md   | 2 +-
 .../rustc-dev-guide/src/opaque-types-type-alias-impl-trait.md | 2 +-
 src/doc/rustc-dev-guide/src/stability.md                      | 2 +-
 src/doc/rustc-dev-guide/src/thir.md                           | 4 ++--
 src/doc/rustc-dev-guide/src/traits/chalk.md                   | 2 +-
 src/doc/rustc-dev-guide/src/traits/resolution.md              | 2 +-
 src/doc/rustc-dev-guide/src/ty-fold.md                        | 2 +-
 src/doc/rustc-dev-guide/src/type-inference.md                 | 2 +-
 8 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/borrow_check/region_inference/member_constraints.md b/src/doc/rustc-dev-guide/src/borrow_check/region_inference/member_constraints.md
index 2804c97724f5a..52e7400ffde7e 100644
--- a/src/doc/rustc-dev-guide/src/borrow_check/region_inference/member_constraints.md
+++ b/src/doc/rustc-dev-guide/src/borrow_check/region_inference/member_constraints.md
@@ -92,7 +92,7 @@ member constraints come in.
 ## Choices are always lifetime parameters
 
 At present, the "choice" regions from a member constraint are always lifetime
-parameters from the current function. As of <!-- date-check --> October 2021,
+parameters from the current function. As of <!-- date-check --> August 2025,
 this falls out from the placement of impl Trait, though in the future it may not
 be the case. We take some advantage of this fact, as it simplifies the current
 code. In particular, we don't have to consider a case like `'0 member of ['1,
diff --git a/src/doc/rustc-dev-guide/src/opaque-types-type-alias-impl-trait.md b/src/doc/rustc-dev-guide/src/opaque-types-type-alias-impl-trait.md
index 956f568285a02..5a4a31e0a82d6 100644
--- a/src/doc/rustc-dev-guide/src/opaque-types-type-alias-impl-trait.md
+++ b/src/doc/rustc-dev-guide/src/opaque-types-type-alias-impl-trait.md
@@ -15,7 +15,7 @@ it implements `Bar`. Therefore, any of `Bar`'s interface can be used on a `Foo`,
 but nothing else (regardless of whether it implements any other traits).
 
 Since there needs to be a concrete background type,
-you can (as of <!-- date-check --> January 2021) express that type
+you can (as of <!-- date-check --> August 2025) express that type
 by using the opaque type in a "defining use site".
 
 ```rust,ignore
diff --git a/src/doc/rustc-dev-guide/src/stability.md b/src/doc/rustc-dev-guide/src/stability.md
index 3c4c65fdd5a88..665215fda049e 100644
--- a/src/doc/rustc-dev-guide/src/stability.md
+++ b/src/doc/rustc-dev-guide/src/stability.md
@@ -30,7 +30,7 @@ unstable modules or vice versa.
 
 Previously, due to a [rustc bug], stable items inside unstable modules were
 available to stable code in that location.
-As of <!-- date-check --> September 2024, items with [accidentally stabilized
+As of <!-- date-check --> August 2025, items with [accidentally stabilized
 paths] are marked with the `#[rustc_allowed_through_unstable_modules]` attribute
 to prevent code dependent on those paths from breaking. Do *not* add this attribute
 to any more items unless that is needed to avoid breaking changes.
diff --git a/src/doc/rustc-dev-guide/src/thir.md b/src/doc/rustc-dev-guide/src/thir.md
index 3d3dafaef49ba..6a3525d5b8f8c 100644
--- a/src/doc/rustc-dev-guide/src/thir.md
+++ b/src/doc/rustc-dev-guide/src/thir.md
@@ -2,7 +2,7 @@
 
 The THIR ("Typed High-Level Intermediate Representation"), previously called HAIR for
 "High-Level Abstract IR", is another IR used by rustc that is generated after
-[type checking]. It is (as of <!-- date-check --> January 2024) used for
+[type checking]. It is (as of <!-- date-check --> August 2025) used for
 [MIR construction], [exhaustiveness checking], and [unsafety checking].
 
 [type checking]: ./type-checking.md
@@ -52,7 +52,7 @@ fn main() {
 }
 ```
 
-Here is how that gets represented in THIR (as of <!-- date-check --> Aug 2022):
+Here is how that gets represented in THIR (as of <!-- date-check --> August 2025):
 
 ```rust,no_run
 Thir {
diff --git a/src/doc/rustc-dev-guide/src/traits/chalk.md b/src/doc/rustc-dev-guide/src/traits/chalk.md
index 844f42b9879f8..eac8e6b5c2045 100644
--- a/src/doc/rustc-dev-guide/src/traits/chalk.md
+++ b/src/doc/rustc-dev-guide/src/traits/chalk.md
@@ -1,7 +1,7 @@
 # Chalk-based trait solving
 
 [Chalk][chalk] is an experimental trait solver for Rust that is
-(as of <!-- date-check --> May 2022) under development by the [Types team].
+(as of <!-- date-check --> August 2025) under development by the [Types team].
 Its goal is to enable a lot of trait system features and bug fixes
 that are hard to implement (e.g. GATs or specialization). If you would like to
 help in hacking on the new solver, drop by on the rust-lang Zulip in the [`#t-types`]
diff --git a/src/doc/rustc-dev-guide/src/traits/resolution.md b/src/doc/rustc-dev-guide/src/traits/resolution.md
index ccb2b04268e85..711b7ebe65efe 100644
--- a/src/doc/rustc-dev-guide/src/traits/resolution.md
+++ b/src/doc/rustc-dev-guide/src/traits/resolution.md
@@ -120,7 +120,7 @@ the obligation contains unbound inference variables.
 
 The subroutines that decide whether a particular impl/where-clause/etc applies
 to a particular obligation are collectively referred to as the process of
-_matching_. For `impl` candidates <!-- date-check: Oct 2022 -->,
+_matching_. For `impl` candidates <!-- date-check: Aug 2025 -->,
 this amounts to unifying the impl header (the `Self` type and the trait arguments)
 while ignoring  nested obligations. If matching succeeds then we add it
 to a set of candidates. There are other rules when assembling candidates for
diff --git a/src/doc/rustc-dev-guide/src/ty-fold.md b/src/doc/rustc-dev-guide/src/ty-fold.md
index 23253022ffe27..d0fa548a6250e 100644
--- a/src/doc/rustc-dev-guide/src/ty-fold.md
+++ b/src/doc/rustc-dev-guide/src/ty-fold.md
@@ -1,4 +1,4 @@
-<!-- date-check: may 2024 -->
+<!-- date-check: Aug 2025 -->
 # `TypeFoldable` and `TypeFolder`
 
 In [a previous chapter], we discussed instantiating binders.
diff --git a/src/doc/rustc-dev-guide/src/type-inference.md b/src/doc/rustc-dev-guide/src/type-inference.md
index 2243205f129b5..0c7e2839b2895 100644
--- a/src/doc/rustc-dev-guide/src/type-inference.md
+++ b/src/doc/rustc-dev-guide/src/type-inference.md
@@ -66,7 +66,7 @@ inference works, or perhaps this blog post on
 [Unification in the Chalk project]: http://smallcultfollowing.com/babysteps/blog/2017/03/25/unification-in-chalk-part-1/
 
 All told, the inference context stores five kinds of inference variables
-(as of <!-- date-check --> March 2023):
+(as of <!-- date-check --> August 2025):
 
 - Type variables, which come in three varieties:
   - General type variables (the most common). These can be unified with any

From dce4f301042c53f91d85befda03b0405d5922916 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Thu, 28 Aug 2025 23:53:55 +0300
Subject: [PATCH 0325/1889] When mapping next-solver's `dyn` type, add `Self`
 (aka. bound var ^1.0) to auto traits' substitutions

Chalk represents dyn types as a list of predicate, the self type should be there. The next solver represents them quite differently. The `Self` was forgotten for the auto trait case.
---
 .../crates/hir-ty/src/mir/lower.rs            |  2 +
 .../crates/hir-ty/src/mir/lower/tests.rs      | 64 +++++++++++++++++++
 .../crates/hir-ty/src/next_solver/mapping.rs  |  5 +-
 3 files changed, 70 insertions(+), 1 deletion(-)
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/tests.rs

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
index 8c03ca939e370..7fbd496e51f25 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
@@ -53,6 +53,8 @@ use super::OperandKind;
 
 mod as_place;
 mod pattern_matching;
+#[cfg(test)]
+mod tests;
 
 #[derive(Debug, Clone)]
 struct LoopBlocks {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/tests.rs
new file mode 100644
index 0000000000000..1d7a16ed72d07
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower/tests.rs
@@ -0,0 +1,64 @@
+use hir_def::db::DefDatabase;
+use rustc_hash::FxHashMap;
+use span::Edition;
+use test_fixture::WithFixture;
+use triomphe::Arc;
+
+use crate::{
+    db::HirDatabase,
+    mir::{MirBody, MirLowerError},
+    setup_tracing,
+    test_db::TestDB,
+};
+
+fn lower_mir(
+    #[rust_analyzer::rust_fixture] ra_fixture: &str,
+) -> FxHashMap<String, Result<Arc<MirBody>, MirLowerError>> {
+    let _tracing = setup_tracing();
+    let (db, file_ids) = TestDB::with_many_files(ra_fixture);
+    let file_id = *file_ids.last().unwrap();
+    let module_id = db.module_for_file(file_id.file_id(&db));
+    let def_map = module_id.def_map(&db);
+    let scope = &def_map[module_id.local_id].scope;
+    let funcs = scope.declarations().filter_map(|x| match x {
+        hir_def::ModuleDefId::FunctionId(it) => Some(it),
+        _ => None,
+    });
+    funcs
+        .map(|func| {
+            let name = db.function_signature(func).name.display(&db, Edition::CURRENT).to_string();
+            let mir = db.mir_body(func.into());
+            (name, mir)
+        })
+        .collect()
+}
+
+#[test]
+fn dyn_projection_with_auto_traits_regression_next_solver() {
+    lower_mir(
+        r#"
+//- minicore: sized, send
+pub trait Deserializer {}
+
+pub trait Strictest {
+    type Object: ?Sized;
+}
+
+impl Strictest for dyn CustomValue {
+    type Object = dyn CustomValue + Send;
+}
+
+pub trait CustomValue: Send {}
+
+impl CustomValue for () {}
+
+struct Box<T: ?Sized>;
+
+type DeserializeFn<T> = fn(&mut dyn Deserializer) -> Box<T>;
+
+fn foo() {
+    (|deserializer| Box::new(())) as DeserializeFn<<dyn CustomValue as Strictest>::Object>;
+}
+    "#,
+    );
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
index de2671e28fb5e..203f030dfd614 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
@@ -1207,7 +1207,10 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
                                 SolverDefId::TraitId(id) => to_chalk_trait_id(id),
                                 _ => unreachable!(),
                             };
-                            let substitution = chalk_ir::Substitution::empty(Interner);
+                            let substitution = chalk_ir::Substitution::from1(
+                                Interner,
+                                convert_ty_for_result(interner, self_ty),
+                            );
                             let trait_ref = chalk_ir::TraitRef { trait_id, substitution };
                             chalk_ir::WhereClause::Implemented(trait_ref)
                         }

From aa27cca79e7888deff3bafed84ea16a5a89cb7c7 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Tue, 26 Aug 2025 11:34:12 -0700
Subject: [PATCH 0326/1889] Add a sanity check to bootstrap for
 wasm-component-ld

For `wasm32-wasip2`-and-beyond this tool is required, so in case it's
disabled in `config.toml` add a sanity-check that it's present in the
environment.
---
 src/bootstrap/src/core/sanity.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/bootstrap/src/core/sanity.rs b/src/bootstrap/src/core/sanity.rs
index 099ec4883972f..04cf63f1c6d44 100644
--- a/src/bootstrap/src/core/sanity.rs
+++ b/src/bootstrap/src/core/sanity.rs
@@ -397,6 +397,16 @@ $ pacman -R cmake && pacman -S mingw-w64-x86_64-cmake
                 );
             }
         }
+
+        // For testing `wasm32-wasip2`-and-beyond it's required to have
+        // `wasm-component-ld`. This is enabled by default via `tool_enabled`
+        // but if it's disabled then double-check it's present on the system.
+        if target.contains("wasip")
+            && !target.contains("wasip1")
+            && !build.tool_enabled("wasm-component-ld")
+        {
+            cmd_finder.must_have("wasm-component-ld");
+        }
     }
 
     if let Some(ref s) = build.config.ccache {

From 5d81f033a5ab2fce07898a22ad8c607380812cf7 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Tue, 26 Aug 2025 13:53:11 -0700
Subject: [PATCH 0327/1889] std: Start supporting WASIp2 natively

This commit is the start of an effort to support WASIp2 natively in the
standard library. Before this commit the `wasm32-wasip2` target behaved
exactly like `wasm32-wasip1` target by importing APIs from the core wasm
module `wasi_snapshot_preview1`. These APIs are satisfied by the
`wasm-component-ld` target by using an [adapter] which implements WASIp1
in terms of WASIp2. This adapter comes at a cost, however, in terms of
runtime indirection and instantiation cost, so ideally the adapter would
be removed entirely. The purpose of this adapter was to provide a
smoother on-ramp from WASIp1 to WASIp2 when it was originally created.

The `wasm32-wasip2` target has been around for long enough now that it's
much more established. Additionally the only thing historically blocking
using WASIp2 directly was implementation effort. Work is now underway to
migrate wasi-libc itself to using WASIp2 directly and now seems as good
a time as any to migrate the Rust standard library too.

Implementation-wise the milestones here are:

* The `wasm32-wasip2` target now also depends on the `wasi` crate at
  version 0.14.* in addition to the preexisting dependency of 0.11.*.
  The 0.14.* release series binds WASIp2 APIs instead of WASIp1 APIs.
* Some preexisting naming around `mod wasi` or `wasi.rs` was renamed to
  `wasip1` where appropriate. For example `std::sys::pal::wasi` is now
  called `std::sys::pal::wasip1`.
* More platform-specific WASI modules are now split between WASIp1 and
  WASIp2. For example getting the current time, randomness, and
  process arguments now use WASIp2 APIs directly instead of using WASIp1
  APIs that require an adapter.

It's worth pointing out that this PR does not migrate the entire
standard library away from using WASIp1 APIs on the `wasm32-wasip2`
target. Everything related to file descriptors and filesystem APIs is
still using WASIp1. Migrating that is left for a future PR. In the
meantime the goal of this change is to lay the groundwork necessary for
migrating in the future. Eventually the goal is to drop the `wasi`
0.11.* dependency on the `wasm32-wasip2` target (the `wasm32-wasip1`
target will continue to retain this dependency).

[adapter]: https://github.com/bytecodealliance/wasmtime/blob/main/crates/wasi-preview1-component-adapter/README.md
---
 library/Cargo.lock                            | 24 +++++-
 library/std/Cargo.toml                        |  5 ++
 library/std/src/sys/args/mod.rs               | 10 ++-
 .../std/src/sys/args/{wasi.rs => wasip1.rs}   |  0
 library/std/src/sys/args/wasip2.rs            |  6 ++
 library/std/src/sys/pal/mod.rs                |  6 +-
 .../src/sys/pal/{wasi => wasip1}/helpers.rs   |  0
 .../std/src/sys/pal/{wasi => wasip1}/mod.rs   |  0
 .../std/src/sys/pal/{wasi => wasip1}/os.rs    |  0
 .../src/sys/pal/{wasi => wasip1}/thread.rs    |  0
 .../std/src/sys/pal/{wasi => wasip1}/time.rs  |  0
 library/std/src/sys/pal/wasip2/mod.rs         |  6 +-
 library/std/src/sys/pal/wasip2/thread.rs      | 73 +++++++++++++++++++
 library/std/src/sys/pal/wasip2/time.rs        | 69 ++++++++++++++++++
 library/std/src/sys/random/mod.rs             | 11 ++-
 .../std/src/sys/random/{wasi.rs => wasip1.rs} |  0
 library/std/src/sys/random/wasip2.rs          |  9 +++
 src/tools/tidy/src/deps.rs                    |  6 +-
 triagebot.toml                                |  3 +-
 19 files changed, 212 insertions(+), 16 deletions(-)
 rename library/std/src/sys/args/{wasi.rs => wasip1.rs} (100%)
 create mode 100644 library/std/src/sys/args/wasip2.rs
 rename library/std/src/sys/pal/{wasi => wasip1}/helpers.rs (100%)
 rename library/std/src/sys/pal/{wasi => wasip1}/mod.rs (100%)
 rename library/std/src/sys/pal/{wasi => wasip1}/os.rs (100%)
 rename library/std/src/sys/pal/{wasi => wasip1}/thread.rs (100%)
 rename library/std/src/sys/pal/{wasi => wasip1}/time.rs (100%)
 create mode 100644 library/std/src/sys/pal/wasip2/thread.rs
 create mode 100644 library/std/src/sys/pal/wasip2/time.rs
 rename library/std/src/sys/random/{wasi.rs => wasip1.rs} (100%)
 create mode 100644 library/std/src/sys/random/wasip2.rs

diff --git a/library/Cargo.lock b/library/Cargo.lock
index 8b860f6949229..c16bb3eafbdac 100644
--- a/library/Cargo.lock
+++ b/library/Cargo.lock
@@ -327,7 +327,8 @@ dependencies = [
  "rustc-demangle",
  "std_detect",
  "unwind",
- "wasi",
+ "wasi 0.11.1+wasi-snapshot-preview1",
+ "wasi 0.14.3+wasi-0.2.4",
  "windows-targets 0.0.0",
 ]
 
@@ -399,6 +400,17 @@ dependencies = [
  "rustc-std-workspace-core",
 ]
 
+[[package]]
+name = "wasi"
+version = "0.14.3+wasi-0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a51ae83037bdd272a9e28ce236db8c07016dd0d50c27038b3f407533c030c95"
+dependencies = [
+ "rustc-std-workspace-alloc",
+ "rustc-std-workspace-core",
+ "wit-bindgen",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.59.0"
@@ -475,3 +487,13 @@ name = "windows_x86_64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "wit-bindgen"
+version = "0.45.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "052283831dbae3d879dc7f51f3d92703a316ca49f91540417d38591826127814"
+dependencies = [
+ "rustc-std-workspace-alloc",
+ "rustc-std-workspace-core",
+]
diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
index eff2562f03197..8b78fe53a3978 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -80,6 +80,11 @@ wasi = { version = "0.11.0", features = [
     'rustc-dep-of-std',
 ], default-features = false }
 
+[target.'cfg(all(target_os = "wasi", target_env = "p2"))'.dependencies]
+wasip2 = { version = '0.14.3', features = [
+    'rustc-dep-of-std',
+], default-features = false, package = 'wasi' }
+
 [target.'cfg(target_os = "uefi")'.dependencies]
 r-efi = { version = "5.2.0", features = ['rustc-dep-of-std'] }
 r-efi-alloc = { version = "2.0.0", features = ['rustc-dep-of-std'] }
diff --git a/library/std/src/sys/args/mod.rs b/library/std/src/sys/args/mod.rs
index c9627322276d0..e11e8e5430f06 100644
--- a/library/std/src/sys/args/mod.rs
+++ b/library/std/src/sys/args/mod.rs
@@ -32,9 +32,13 @@ cfg_select! {
         mod uefi;
         pub use uefi::*;
     }
-    target_os = "wasi" => {
-        mod wasi;
-        pub use wasi::*;
+    all(target_os = "wasi", target_env = "p1") => {
+        mod wasip1;
+        pub use wasip1::*;
+    }
+    all(target_os = "wasi", target_env = "p2") => {
+        mod wasip2;
+        pub use wasip2::*;
     }
     target_os = "xous" => {
         mod xous;
diff --git a/library/std/src/sys/args/wasi.rs b/library/std/src/sys/args/wasip1.rs
similarity index 100%
rename from library/std/src/sys/args/wasi.rs
rename to library/std/src/sys/args/wasip1.rs
diff --git a/library/std/src/sys/args/wasip2.rs b/library/std/src/sys/args/wasip2.rs
new file mode 100644
index 0000000000000..a57e4b97786d0
--- /dev/null
+++ b/library/std/src/sys/args/wasip2.rs
@@ -0,0 +1,6 @@
+pub use super::common::Args;
+
+/// Returns the command line arguments
+pub fn args() -> Args {
+    Args::new(wasip2::cli::environment::get_arguments().into_iter().map(|arg| arg.into()).collect())
+}
diff --git a/library/std/src/sys/pal/mod.rs b/library/std/src/sys/pal/mod.rs
index 9376f5249f1c2..513121c6d30ee 100644
--- a/library/std/src/sys/pal/mod.rs
+++ b/library/std/src/sys/pal/mod.rs
@@ -49,9 +49,9 @@ cfg_select! {
         mod wasip2;
         pub use self::wasip2::*;
     }
-    target_os = "wasi" => {
-        mod wasi;
-        pub use self::wasi::*;
+    all(target_os = "wasi", target_env = "p1") => {
+        mod wasip1;
+        pub use self::wasip1::*;
     }
     target_family = "wasm" => {
         mod wasm;
diff --git a/library/std/src/sys/pal/wasi/helpers.rs b/library/std/src/sys/pal/wasip1/helpers.rs
similarity index 100%
rename from library/std/src/sys/pal/wasi/helpers.rs
rename to library/std/src/sys/pal/wasip1/helpers.rs
diff --git a/library/std/src/sys/pal/wasi/mod.rs b/library/std/src/sys/pal/wasip1/mod.rs
similarity index 100%
rename from library/std/src/sys/pal/wasi/mod.rs
rename to library/std/src/sys/pal/wasip1/mod.rs
diff --git a/library/std/src/sys/pal/wasi/os.rs b/library/std/src/sys/pal/wasip1/os.rs
similarity index 100%
rename from library/std/src/sys/pal/wasi/os.rs
rename to library/std/src/sys/pal/wasip1/os.rs
diff --git a/library/std/src/sys/pal/wasi/thread.rs b/library/std/src/sys/pal/wasip1/thread.rs
similarity index 100%
rename from library/std/src/sys/pal/wasi/thread.rs
rename to library/std/src/sys/pal/wasip1/thread.rs
diff --git a/library/std/src/sys/pal/wasi/time.rs b/library/std/src/sys/pal/wasip1/time.rs
similarity index 100%
rename from library/std/src/sys/pal/wasi/time.rs
rename to library/std/src/sys/pal/wasip1/time.rs
diff --git a/library/std/src/sys/pal/wasip2/mod.rs b/library/std/src/sys/pal/wasip2/mod.rs
index 47fe3221c9093..5f3fb6d6ddfbf 100644
--- a/library/std/src/sys/pal/wasip2/mod.rs
+++ b/library/std/src/sys/pal/wasip2/mod.rs
@@ -10,13 +10,11 @@
 #[path = "../wasm/atomics/futex.rs"]
 pub mod futex;
 
-#[path = "../wasi/os.rs"]
+#[path = "../wasip1/os.rs"]
 pub mod os;
 #[path = "../unsupported/pipe.rs"]
 pub mod pipe;
-#[path = "../wasi/thread.rs"]
 pub mod thread;
-#[path = "../wasi/time.rs"]
 pub mod time;
 
 #[path = "../unsupported/common.rs"]
@@ -26,7 +24,7 @@ mod common;
 
 pub use common::*;
 
-#[path = "../wasi/helpers.rs"]
+#[path = "../wasip1/helpers.rs"]
 mod helpers;
 
 // The following exports are listed individually to work around Rust's glob
diff --git a/library/std/src/sys/pal/wasip2/thread.rs b/library/std/src/sys/pal/wasip2/thread.rs
new file mode 100644
index 0000000000000..ad52918f15a13
--- /dev/null
+++ b/library/std/src/sys/pal/wasip2/thread.rs
@@ -0,0 +1,73 @@
+use crate::ffi::CStr;
+use crate::io;
+use crate::num::NonZero;
+use crate::time::{Duration, Instant};
+
+pub struct Thread(!);
+
+pub const DEFAULT_MIN_STACK_SIZE: usize = 1024 * 1024;
+
+impl Thread {
+    pub unsafe fn new(
+        _stack: usize,
+        _name: Option<&str>,
+        _p: Box<dyn FnOnce()>,
+    ) -> io::Result<Thread> {
+        // Note that unlike WASIp1 even if the wasm `atomics` feature is enabled
+        // there is no support for threads, not even experimentally, not even in
+        // wasi-libc. Thus this is unconditionally unsupported.
+        crate::sys::unsupported()
+    }
+
+    pub fn yield_now() {
+        // no API for this in WASIp2, but there's also no threads, so that's
+        // sort of expected.
+    }
+
+    pub fn set_name(_name: &CStr) {
+        // nope
+    }
+
+    pub fn sleep(dur: Duration) {
+        // Sleep in increments of `u64::MAX` nanoseconds until the `dur` is
+        // entirely drained.
+        let mut remaining = dur.as_nanos();
+        while remaining > 0 {
+            let amt = u64::try_from(remaining).unwrap_or(u64::MAX);
+            wasip2::clocks::monotonic_clock::subscribe_duration(amt).block();
+            remaining -= u128::from(amt);
+        }
+    }
+
+    pub fn sleep_until(deadline: Instant) {
+        match u64::try_from(deadline.into_inner().as_duration().as_nanos()) {
+            // If the point in time we're sleeping to fits within a 64-bit
+            // number of nanoseconds then directly use `subscribe_instant`.
+            Ok(deadline) => {
+                wasip2::clocks::monotonic_clock::subscribe_instant(deadline).block();
+            }
+            // ... otherwise we're sleeping for 500+ years relative to the
+            // "start" of what the system is using as a clock so speed/accuracy
+            // is not so much of a concern. Use `sleep` instead.
+            Err(_) => {
+                let now = Instant::now();
+
+                if let Some(delay) = deadline.checked_duration_since(now) {
+                    Self::sleep(delay);
+                }
+            }
+        }
+    }
+
+    pub fn join(self) {
+        self.0
+    }
+}
+
+pub(crate) fn current_os_id() -> Option<u64> {
+    None
+}
+
+pub fn available_parallelism() -> io::Result<NonZero<usize>> {
+    crate::sys::unsupported()
+}
diff --git a/library/std/src/sys/pal/wasip2/time.rs b/library/std/src/sys/pal/wasip2/time.rs
new file mode 100644
index 0000000000000..f1f6839774b91
--- /dev/null
+++ b/library/std/src/sys/pal/wasip2/time.rs
@@ -0,0 +1,69 @@
+use crate::time::Duration;
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
+pub struct Instant(Duration);
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
+pub struct SystemTime(Duration);
+
+pub const UNIX_EPOCH: SystemTime = SystemTime(Duration::from_secs(0));
+
+impl Instant {
+    pub fn now() -> Instant {
+        Instant(Duration::from_nanos(wasip2::clocks::monotonic_clock::now()))
+    }
+
+    pub fn checked_sub_instant(&self, other: &Instant) -> Option<Duration> {
+        self.0.checked_sub(other.0)
+    }
+
+    pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> {
+        Some(Instant(self.0.checked_add(*other)?))
+    }
+
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {
+        Some(Instant(self.0.checked_sub(*other)?))
+    }
+
+    pub(super) fn as_duration(&self) -> &Duration {
+        &self.0
+    }
+}
+
+impl SystemTime {
+    pub fn now() -> SystemTime {
+        let now = wasip2::clocks::wall_clock::now();
+        SystemTime(Duration::new(now.seconds, now.nanoseconds))
+    }
+
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn from_wasi_timestamp(ts: wasi::Timestamp) -> SystemTime {
+        SystemTime(Duration::from_nanos(ts))
+    }
+
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn to_wasi_timestamp(&self) -> Option<wasi::Timestamp> {
+        // FIXME: const TryInto
+        let ns = self.0.as_nanos();
+        if ns <= u64::MAX as u128 { Some(ns as u64) } else { None }
+    }
+
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
+        // FIXME: ok_or_else with const closures
+        match self.0.checked_sub(other.0) {
+            Some(duration) => Ok(duration),
+            None => Err(other.0 - self.0),
+        }
+    }
+
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
+        Some(SystemTime(self.0.checked_add(*other)?))
+    }
+
+    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
+    pub const fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+        Some(SystemTime(self.0.checked_sub(*other)?))
+    }
+}
diff --git a/library/std/src/sys/random/mod.rs b/library/std/src/sys/random/mod.rs
index a7fbae8609930..1e0eec07b5006 100644
--- a/library/std/src/sys/random/mod.rs
+++ b/library/std/src/sys/random/mod.rs
@@ -86,9 +86,13 @@ cfg_select! {
         mod vxworks;
         pub use vxworks::fill_bytes;
     }
-    target_os = "wasi" => {
-        mod wasi;
-        pub use wasi::fill_bytes;
+    all(target_os = "wasi", target_env = "p1") => {
+        mod wasip1;
+        pub use wasip1::fill_bytes;
+    }
+    all(target_os = "wasi", target_env = "p2") => {
+        mod wasip2;
+        pub use wasip2::{fill_bytes, hashmap_random_keys};
     }
     target_os = "zkvm" => {
         mod zkvm;
@@ -110,6 +114,7 @@ cfg_select! {
     target_os = "linux",
     target_os = "android",
     all(target_family = "wasm", target_os = "unknown"),
+    all(target_os = "wasi", target_env = "p2"),
     target_os = "xous",
 )))]
 pub fn hashmap_random_keys() -> (u64, u64) {
diff --git a/library/std/src/sys/random/wasi.rs b/library/std/src/sys/random/wasip1.rs
similarity index 100%
rename from library/std/src/sys/random/wasi.rs
rename to library/std/src/sys/random/wasip1.rs
diff --git a/library/std/src/sys/random/wasip2.rs b/library/std/src/sys/random/wasip2.rs
new file mode 100644
index 0000000000000..a67c8a6428d18
--- /dev/null
+++ b/library/std/src/sys/random/wasip2.rs
@@ -0,0 +1,9 @@
+pub fn fill_bytes(bytes: &mut [u8]) {
+    bytes.copy_from_slice(&wasip2::random::random::get_random_bytes(
+        u64::try_from(bytes.len()).unwrap(),
+    ));
+}
+
+pub fn hashmap_random_keys() -> (u64, u64) {
+    wasip2::random::insecure_seed::insecure_seed()
+}
diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs
index 6974ede624a4b..560f11ecf50ec 100644
--- a/src/tools/tidy/src/deps.rs
+++ b/src/tools/tidy/src/deps.rs
@@ -490,6 +490,7 @@ const PERMITTED_STDLIB_DEPENDENCIES: &[&str] = &[
     "windows_x86_64_gnu",
     "windows_x86_64_gnullvm",
     "windows_x86_64_msvc",
+    "wit-bindgen",
     // tidy-alphabetical-end
 ];
 
@@ -798,7 +799,10 @@ fn check_runtime_no_duplicate_dependencies(metadata: &Metadata, bad: &mut bool)
             continue;
         }
 
-        if !seen_pkgs.insert(&*pkg.name) {
+        // Skip the `wasi` crate here which the standard library explicitly
+        // depends on two version of (one for the `wasm32-wasip1` target and
+        // another for the `wasm32-wasip2` target).
+        if pkg.name.to_string() != "wasi" && !seen_pkgs.insert(&*pkg.name) {
             tidy_error!(
                 bad,
                 "duplicate package `{}` is not allowed for the standard library",
diff --git a/triagebot.toml b/triagebot.toml
index 3b7b216c0d24e..cf2e95203fa40 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -450,7 +450,8 @@ trigger_files = [
 
 [autolabel."O-wasi"]
 trigger_files = [
-    "library/std/src/sys/pal/wasi",
+    "library/std/src/sys/pal/wasip1",
+    "library/std/src/sys/pal/wasip2",
     "library/std/src/os/wasi"
 ]
 

From 0edb22cdbf8f25bede8d46e706b181457e27003a Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Thu, 28 Aug 2025 09:57:36 +0200
Subject: [PATCH 0328/1889] cleanup proof tree implementation and add cache

---
 compiler/rustc_interface/src/passes.rs        |   3 +-
 compiler/rustc_middle/src/arena.rs            |   1 +
 compiler/rustc_middle/src/query/erase.rs      |   5 +
 compiler/rustc_middle/src/query/mod.rs        |  10 +-
 compiler/rustc_middle/src/ty/context.rs       |  15 +-
 .../src/solve/eval_ctxt/canonical.rs          |  47 ++-
 .../src/solve/eval_ctxt/mod.rs                | 151 ++++---
 .../src/solve/inspect/build.rs                | 399 +++++-------------
 .../rustc_next_trait_solver/src/solve/mod.rs  |  11 +-
 .../src/solve/search_graph.rs                 |  14 +-
 compiler/rustc_trait_selection/src/solve.rs   |  16 +
 .../src/solve/inspect/analyse.rs              |  18 +-
 compiler/rustc_type_ir/src/interner.rs        |  11 +-
 .../rustc_type_ir/src/search_graph/mod.rs     |  42 +-
 compiler/rustc_type_ir/src/solve/inspect.rs   |  29 +-
 15 files changed, 331 insertions(+), 441 deletions(-)

diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs
index bc5ef04079ed4..ca8c10311fb8f 100644
--- a/compiler/rustc_interface/src/passes.rs
+++ b/compiler/rustc_interface/src/passes.rs
@@ -41,7 +41,7 @@ use rustc_span::{
     Symbol, sym,
 };
 use rustc_target::spec::PanicStrategy;
-use rustc_trait_selection::traits;
+use rustc_trait_selection::{solve, traits};
 use tracing::{info, instrument};
 
 use crate::interface::Compiler;
@@ -895,6 +895,7 @@ pub static DEFAULT_QUERY_PROVIDERS: LazyLock<Providers> = LazyLock::new(|| {
     rustc_hir_typeck::provide(providers);
     ty::provide(providers);
     traits::provide(providers);
+    solve::provide(providers);
     rustc_passes::provide(providers);
     rustc_traits::provide(providers);
     rustc_ty_utils::provide(providers);
diff --git a/compiler/rustc_middle/src/arena.rs b/compiler/rustc_middle/src/arena.rs
index 4b6e38cd52dd3..52fbe19c9f2d7 100644
--- a/compiler/rustc_middle/src/arena.rs
+++ b/compiler/rustc_middle/src/arena.rs
@@ -80,6 +80,7 @@ macro_rules! arena_types {
                 rustc_middle::infer::canonical::Canonical<'tcx,
                     rustc_middle::infer::canonical::QueryResponse<'tcx, rustc_middle::ty::Ty<'tcx>>
                 >,
+            [] inspect_probe: rustc_middle::traits::solve::inspect::Probe<rustc_middle::ty::TyCtxt<'tcx>>,
             [] effective_visibilities: rustc_middle::middle::privacy::EffectiveVisibilities,
             [] upvars_mentioned: rustc_data_structures::fx::FxIndexMap<rustc_hir::HirId, rustc_hir::Upvar>,
             [] dyn_compatibility_violations: rustc_middle::traits::DynCompatibilityViolation,
diff --git a/compiler/rustc_middle/src/query/erase.rs b/compiler/rustc_middle/src/query/erase.rs
index ea62461ebeb60..bea2191c5601c 100644
--- a/compiler/rustc_middle/src/query/erase.rs
+++ b/compiler/rustc_middle/src/query/erase.rs
@@ -6,6 +6,7 @@ use rustc_span::ErrorGuaranteed;
 
 use crate::mir::interpret::EvalToValTreeResult;
 use crate::query::CyclePlaceholder;
+use crate::traits::solve;
 use crate::ty::adjustment::CoerceUnsizedInfo;
 use crate::ty::{self, Ty, TyCtxt};
 use crate::{mir, traits};
@@ -219,6 +220,10 @@ impl<T0, T1> EraseType for (&'_ T0, &'_ T1) {
     type Result = [u8; size_of::<(&'static (), &'static ())>()];
 }
 
+impl<T0> EraseType for (solve::QueryResult<'_>, &'_ T0) {
+    type Result = [u8; size_of::<(solve::QueryResult<'static>, &'static ())>()];
+}
+
 impl<T0, T1> EraseType for (&'_ T0, &'_ [T1]) {
     type Result = [u8; size_of::<(&'static (), &'static [()])>()];
 }
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 7bd8a0525a2cf..1855c0ef6a657 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -131,7 +131,7 @@ use crate::traits::query::{
 };
 use crate::traits::{
     CodegenObligationError, DynCompatibilityViolation, EvaluationResult, ImplSource,
-    ObligationCause, OverflowError, WellFormedLoc, specialization_graph,
+    ObligationCause, OverflowError, WellFormedLoc, solve, specialization_graph,
 };
 use crate::ty::fast_reject::SimplifiedType;
 use crate::ty::layout::ValidityRequirement;
@@ -2561,6 +2561,14 @@ rustc_queries! {
         desc { "computing autoderef types for `{}`", goal.canonical.value.value }
     }
 
+    /// Used by `-Znext-solver` to compute proof trees.
+    query evaluate_root_goal_for_proof_tree_raw(
+        goal: solve::CanonicalInput<'tcx>,
+    ) -> (solve::QueryResult<'tcx>, &'tcx solve::inspect::Probe<TyCtxt<'tcx>>) {
+        no_hash
+        desc { "computing proof tree for `{}`", goal.canonical.value.goal.predicate }
+    }
+
     /// Returns the Rust target features for the current target. These are not always the same as LLVM target features!
     query rust_target_features(_: CrateNum) -> &'tcx UnordMap<String, rustc_target::target_features::Stability> {
         arena_cache
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 5dbbc7297ab6e..72ab6ac612c61 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -72,9 +72,9 @@ use crate::query::plumbing::QuerySystem;
 use crate::query::{IntoQueryParam, LocalCrate, Providers, TyCtxtAt};
 use crate::thir::Thir;
 use crate::traits;
-use crate::traits::solve;
 use crate::traits::solve::{
-    ExternalConstraints, ExternalConstraintsData, PredefinedOpaques, PredefinedOpaquesData,
+    self, CanonicalInput, ExternalConstraints, ExternalConstraintsData, PredefinedOpaques,
+    PredefinedOpaquesData, QueryResult, inspect,
 };
 use crate::ty::predicate::ExistentialPredicateStableCmpExt as _;
 use crate::ty::{
@@ -737,6 +737,17 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
             self.opaque_types_defined_by(defining_anchor).iter().chain(coroutines_defined_by),
         )
     }
+
+    type ProbeRef = &'tcx inspect::Probe<TyCtxt<'tcx>>;
+    fn mk_probe_ref(self, probe: inspect::Probe<Self>) -> &'tcx inspect::Probe<TyCtxt<'tcx>> {
+        self.arena.alloc(probe)
+    }
+    fn evaluate_root_goal_for_proof_tree_raw(
+        self,
+        canonical_goal: CanonicalInput<'tcx>,
+    ) -> (QueryResult<'tcx>, &'tcx inspect::Probe<TyCtxt<'tcx>>) {
+        self.evaluate_root_goal_for_proof_tree_raw(canonical_goal)
+    }
 }
 
 macro_rules! bidirectional_lang_item_map {
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs
index 4644b145b18a3..6f9f40673847c 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs
@@ -56,22 +56,23 @@ where
     ///
     /// This expects `goal` and `opaque_types` to be eager resolved.
     pub(super) fn canonicalize_goal(
-        &self,
+        delegate: &D,
         goal: Goal<I, I::Predicate>,
         opaque_types: Vec<(ty::OpaqueTypeKey<I>, I::Ty)>,
     ) -> (Vec<I::GenericArg>, CanonicalInput<I, I::Predicate>) {
         let mut orig_values = Default::default();
         let canonical = Canonicalizer::canonicalize_input(
-            self.delegate,
+            delegate,
             &mut orig_values,
             QueryInput {
                 goal,
-                predefined_opaques_in_body: self
+                predefined_opaques_in_body: delegate
                     .cx()
                     .mk_predefined_opaques_in_body(PredefinedOpaquesData { opaque_types }),
             },
         );
-        let query_input = ty::CanonicalQueryInput { canonical, typing_mode: self.typing_mode() };
+        let query_input =
+            ty::CanonicalQueryInput { canonical, typing_mode: delegate.typing_mode() };
         (orig_values, query_input)
     }
 
@@ -271,28 +272,23 @@ where
     /// - we apply the `external_constraints` returned by the query, returning
     ///   the `normalization_nested_goals`
     pub(super) fn instantiate_and_apply_query_response(
-        &mut self,
+        delegate: &D,
         param_env: I::ParamEnv,
         original_values: &[I::GenericArg],
         response: CanonicalResponse<I>,
+        span: I::Span,
     ) -> (NestedNormalizationGoals<I>, Certainty) {
         let instantiation = Self::compute_query_response_instantiation_values(
-            self.delegate,
+            delegate,
             &original_values,
             &response,
-            self.origin_span,
+            span,
         );
 
         let Response { var_values, external_constraints, certainty } =
-            self.delegate.instantiate_canonical(response, instantiation);
+            delegate.instantiate_canonical(response, instantiation);
 
-        Self::unify_query_var_values(
-            self.delegate,
-            param_env,
-            &original_values,
-            var_values,
-            self.origin_span,
-        );
+        Self::unify_query_var_values(delegate, param_env, &original_values, var_values, span);
 
         let ExternalConstraintsData {
             region_constraints,
@@ -300,8 +296,8 @@ where
             normalization_nested_goals,
         } = &*external_constraints;
 
-        self.register_region_constraints(region_constraints);
-        self.register_new_opaque_types(opaque_types);
+        Self::register_region_constraints(delegate, region_constraints, span);
+        Self::register_new_opaque_types(delegate, opaque_types, span);
 
         (normalization_nested_goals.clone(), certainty)
     }
@@ -424,21 +420,26 @@ where
     }
 
     fn register_region_constraints(
-        &mut self,
+        delegate: &D,
         outlives: &[ty::OutlivesPredicate<I, I::GenericArg>],
+        span: I::Span,
     ) {
         for &ty::OutlivesPredicate(lhs, rhs) in outlives {
             match lhs.kind() {
-                ty::GenericArgKind::Lifetime(lhs) => self.register_region_outlives(lhs, rhs),
-                ty::GenericArgKind::Type(lhs) => self.register_ty_outlives(lhs, rhs),
+                ty::GenericArgKind::Lifetime(lhs) => delegate.sub_regions(rhs, lhs, span),
+                ty::GenericArgKind::Type(lhs) => delegate.register_ty_outlives(lhs, rhs, span),
                 ty::GenericArgKind::Const(_) => panic!("const outlives: {lhs:?}: {rhs:?}"),
             }
         }
     }
 
-    fn register_new_opaque_types(&mut self, opaque_types: &[(ty::OpaqueTypeKey<I>, I::Ty)]) {
+    fn register_new_opaque_types(
+        delegate: &D,
+        opaque_types: &[(ty::OpaqueTypeKey<I>, I::Ty)],
+        span: I::Span,
+    ) {
         for &(key, ty) in opaque_types {
-            let prev = self.delegate.register_hidden_type_in_storage(key, ty, self.origin_span);
+            let prev = delegate.register_hidden_type_in_storage(key, ty, span);
             // We eagerly resolve inference variables when computing the query response.
             // This can cause previously distinct opaque type keys to now be structurally equal.
             //
@@ -447,7 +448,7 @@ where
             // types here. However, doing so is difficult as it may result in nested goals and
             // any errors may make it harder to track the control flow for diagnostics.
             if let Some(prev) = prev {
-                self.delegate.add_duplicate_opaque_type(key, prev, self.origin_span);
+                delegate.add_duplicate_opaque_type(key, prev, span);
             }
         }
     }
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
index 4f87902e46e95..31106a7452795 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
@@ -20,13 +20,12 @@ use crate::coherence;
 use crate::delegate::SolverDelegate;
 use crate::placeholder::BoundVarReplacer;
 use crate::resolve::eager_resolve_vars;
-use crate::solve::inspect::{self, ProofTreeBuilder};
 use crate::solve::search_graph::SearchGraph;
 use crate::solve::ty::may_use_unstable_feature;
 use crate::solve::{
-    CanonicalInput, Certainty, FIXPOINT_STEP_LIMIT, Goal, GoalEvaluation, GoalEvaluationKind,
-    GoalSource, GoalStalledOn, HasChanged, NestedNormalizationGoals, NoSolution, QueryInput,
-    QueryResult,
+    CanonicalInput, Certainty, FIXPOINT_STEP_LIMIT, Goal, GoalEvaluation, GoalSource,
+    GoalStalledOn, HasChanged, NestedNormalizationGoals, NoSolution, QueryInput, QueryResult,
+    inspect,
 };
 
 pub(super) mod canonical;
@@ -130,7 +129,7 @@ where
     // evaluation code.
     tainted: Result<(), NoSolution>,
 
-    pub(super) inspect: ProofTreeBuilder<D>,
+    pub(super) inspect: inspect::EvaluationStepBuilder<D>,
 }
 
 #[derive(PartialEq, Eq, Debug, Hash, Clone, Copy)]
@@ -172,10 +171,7 @@ pub trait SolverDelegateEvalExt: SolverDelegate {
         goal: Goal<Self::Interner, <Self::Interner as Interner>::Predicate>,
         span: <Self::Interner as Interner>::Span,
     ) -> (
-        Result<
-            (NestedNormalizationGoals<Self::Interner>, GoalEvaluation<Self::Interner>),
-            NoSolution,
-        >,
+        Result<NestedNormalizationGoals<Self::Interner>, NoSolution>,
         inspect::GoalEvaluation<Self::Interner>,
     );
 }
@@ -192,14 +188,9 @@ where
         span: I::Span,
         stalled_on: Option<GoalStalledOn<I>>,
     ) -> Result<GoalEvaluation<I>, NoSolution> {
-        EvalCtxt::enter_root(
-            self,
-            self.cx().recursion_limit(),
-            GenerateProofTree::No,
-            span,
-            |ecx| ecx.evaluate_goal(GoalEvaluationKind::Root, GoalSource::Misc, goal, stalled_on),
-        )
-        .0
+        EvalCtxt::enter_root(self, self.cx().recursion_limit(), span, |ecx| {
+            ecx.evaluate_goal(GoalSource::Misc, goal, stalled_on)
+        })
     }
 
     fn root_goal_may_hold_with_depth(
@@ -208,10 +199,9 @@ where
         goal: Goal<Self::Interner, <Self::Interner as Interner>::Predicate>,
     ) -> bool {
         self.probe(|| {
-            EvalCtxt::enter_root(self, root_depth, GenerateProofTree::No, I::Span::dummy(), |ecx| {
-                ecx.evaluate_goal(GoalEvaluationKind::Root, GoalSource::Misc, goal, None)
+            EvalCtxt::enter_root(self, root_depth, I::Span::dummy(), |ecx| {
+                ecx.evaluate_goal(GoalSource::Misc, goal, None)
             })
-            .0
         })
         .is_ok()
     }
@@ -221,18 +211,8 @@ where
         &self,
         goal: Goal<I, I::Predicate>,
         span: I::Span,
-    ) -> (
-        Result<(NestedNormalizationGoals<I>, GoalEvaluation<I>), NoSolution>,
-        inspect::GoalEvaluation<I>,
-    ) {
-        let (result, proof_tree) = EvalCtxt::enter_root(
-            self,
-            self.cx().recursion_limit(),
-            GenerateProofTree::Yes,
-            span,
-            |ecx| ecx.evaluate_goal_raw(GoalEvaluationKind::Root, GoalSource::Misc, goal, None),
-        );
-        (result, proof_tree.unwrap())
+    ) -> (Result<NestedNormalizationGoals<I>, NoSolution>, inspect::GoalEvaluation<I>) {
+        evaluate_root_goal_for_proof_tree(self, goal, span)
     }
 }
 
@@ -301,17 +281,16 @@ where
     pub(super) fn enter_root<R>(
         delegate: &D,
         root_depth: usize,
-        generate_proof_tree: GenerateProofTree,
         origin_span: I::Span,
         f: impl FnOnce(&mut EvalCtxt<'_, D>) -> R,
-    ) -> (R, Option<inspect::GoalEvaluation<I>>) {
+    ) -> R {
         let mut search_graph = SearchGraph::new(root_depth);
 
         let mut ecx = EvalCtxt {
             delegate,
             search_graph: &mut search_graph,
             nested_goals: Default::default(),
-            inspect: ProofTreeBuilder::new_maybe_root(generate_proof_tree),
+            inspect: inspect::EvaluationStepBuilder::new_noop(),
 
             // Only relevant when canonicalizing the response,
             // which we don't do within this evaluation context.
@@ -324,15 +303,12 @@ where
             tainted: Ok(()),
         };
         let result = f(&mut ecx);
-
-        let proof_tree = ecx.inspect.finalize();
         assert!(
             ecx.nested_goals.is_empty(),
             "root `EvalCtxt` should not have any goals added to it"
         );
-
         assert!(search_graph.is_empty());
-        (result, proof_tree)
+        result
     }
 
     /// Creates a nested evaluation context that shares the same search graph as the
@@ -346,11 +322,10 @@ where
         cx: I,
         search_graph: &'a mut SearchGraph<D>,
         canonical_input: CanonicalInput<I>,
-        canonical_goal_evaluation: &mut ProofTreeBuilder<D>,
+        proof_tree_builder: &mut inspect::ProofTreeBuilder<D>,
         f: impl FnOnce(&mut EvalCtxt<'_, D>, Goal<I, I::Predicate>) -> R,
     ) -> R {
         let (ref delegate, input, var_values) = D::build_with_canonical(cx, &canonical_input);
-
         for &(key, ty) in &input.predefined_opaques_in_body.opaque_types {
             let prev = delegate.register_hidden_type_in_storage(key, ty, I::Span::dummy());
             // It may be possible that two entries in the opaque type storage end up
@@ -381,12 +356,12 @@ where
             nested_goals: Default::default(),
             origin_span: I::Span::dummy(),
             tainted: Ok(()),
-            inspect: canonical_goal_evaluation.new_goal_evaluation_step(var_values),
+            inspect: proof_tree_builder.new_evaluation_step(var_values),
         };
 
         let result = f(&mut ecx, input.goal);
         ecx.inspect.probe_final_state(ecx.delegate, ecx.max_input_universe);
-        canonical_goal_evaluation.goal_evaluation_step(ecx.inspect);
+        proof_tree_builder.finish_evaluation_step(ecx.inspect);
 
         // When creating a query response we clone the opaque type constraints
         // instead of taking them. This would cause an ICE here, since we have
@@ -406,13 +381,12 @@ where
     /// been constrained and the certainty of the result.
     fn evaluate_goal(
         &mut self,
-        goal_evaluation_kind: GoalEvaluationKind,
         source: GoalSource,
         goal: Goal<I, I::Predicate>,
         stalled_on: Option<GoalStalledOn<I>>,
     ) -> Result<GoalEvaluation<I>, NoSolution> {
         let (normalization_nested_goals, goal_evaluation) =
-            self.evaluate_goal_raw(goal_evaluation_kind, source, goal, stalled_on)?;
+            self.evaluate_goal_raw(source, goal, stalled_on)?;
         assert!(normalization_nested_goals.is_empty());
         Ok(goal_evaluation)
     }
@@ -426,7 +400,6 @@ where
     /// storage.
     pub(super) fn evaluate_goal_raw(
         &mut self,
-        goal_evaluation_kind: GoalEvaluationKind,
         source: GoalSource,
         goal: Goal<I, I::Predicate>,
         stalled_on: Option<GoalStalledOn<I>>,
@@ -458,17 +431,14 @@ where
         let opaque_types = self.delegate.clone_opaque_types_lookup_table();
         let (goal, opaque_types) = eager_resolve_vars(self.delegate, (goal, opaque_types));
 
-        let (orig_values, canonical_goal) = self.canonicalize_goal(goal, opaque_types);
-        let mut goal_evaluation =
-            self.inspect.new_goal_evaluation(goal, &orig_values, goal_evaluation_kind);
+        let (orig_values, canonical_goal) =
+            Self::canonicalize_goal(self.delegate, goal, opaque_types);
         let canonical_result = self.search_graph.evaluate_goal(
             self.cx(),
             canonical_goal,
             self.step_kind_for_source(source),
-            &mut goal_evaluation,
+            &mut inspect::ProofTreeBuilder::new_noop(),
         );
-        goal_evaluation.query_result(canonical_result);
-        self.inspect.goal_evaluation(goal_evaluation);
         let response = match canonical_result {
             Err(e) => return Err(e),
             Ok(response) => response,
@@ -477,8 +447,13 @@ where
         let has_changed =
             if !has_only_region_constraints(response) { HasChanged::Yes } else { HasChanged::No };
 
-        let (normalization_nested_goals, certainty) =
-            self.instantiate_and_apply_query_response(goal.param_env, &orig_values, response);
+        let (normalization_nested_goals, certainty) = Self::instantiate_and_apply_query_response(
+            self.delegate,
+            goal.param_env,
+            &orig_values,
+            response,
+            self.origin_span,
+        );
 
         // FIXME: We previously had an assert here that checked that recomputing
         // a goal after applying its constraints did not change its response.
@@ -676,12 +651,7 @@ where
                 let (
                     NestedNormalizationGoals(nested_goals),
                     GoalEvaluation { goal, certainty, stalled_on, has_changed: _ },
-                ) = self.evaluate_goal_raw(
-                    GoalEvaluationKind::Nested,
-                    source,
-                    unconstrained_goal,
-                    stalled_on,
-                )?;
+                ) = self.evaluate_goal_raw(source, unconstrained_goal, stalled_on)?;
                 // Add the nested goals from normalization to our own nested goals.
                 trace!(?nested_goals);
                 self.nested_goals.extend(nested_goals.into_iter().map(|(s, g)| (s, g, None)));
@@ -734,7 +704,7 @@ where
                 }
             } else {
                 let GoalEvaluation { goal, certainty, has_changed, stalled_on } =
-                    self.evaluate_goal(GoalEvaluationKind::Nested, source, goal, stalled_on)?;
+                    self.evaluate_goal(source, goal, stalled_on)?;
                 if has_changed == HasChanged::Yes {
                     unchanged_certainty = None;
                 }
@@ -1297,3 +1267,62 @@ where
         if predicate.allow_normalization() { predicate.super_fold_with(self) } else { predicate }
     }
 }
+
+/// Do not call this directly, use the `tcx` query instead.
+pub fn evaluate_root_goal_for_proof_tree_raw_provider<
+    D: SolverDelegate<Interner = I>,
+    I: Interner,
+>(
+    cx: I,
+    canonical_goal: CanonicalInput<I>,
+) -> (QueryResult<I>, I::ProbeRef) {
+    let mut inspect = inspect::ProofTreeBuilder::new();
+    let canonical_result = SearchGraph::<D>::evaluate_root_goal_for_proof_tree(
+        cx,
+        cx.recursion_limit(),
+        canonical_goal,
+        &mut inspect,
+    );
+    let final_revision = inspect.unwrap();
+    (canonical_result, cx.mk_probe_ref(final_revision))
+}
+
+/// Evaluate a goal to build a proof tree.
+///
+/// This is a copy of [EvalCtxt::evaluate_goal_raw] which avoids relying on the
+/// [EvalCtxt] and uses a separate cache.
+pub(super) fn evaluate_root_goal_for_proof_tree<D: SolverDelegate<Interner = I>, I: Interner>(
+    delegate: &D,
+    goal: Goal<I, I::Predicate>,
+    origin_span: I::Span,
+) -> (Result<NestedNormalizationGoals<I>, NoSolution>, inspect::GoalEvaluation<I>) {
+    let opaque_types = delegate.clone_opaque_types_lookup_table();
+    let (goal, opaque_types) = eager_resolve_vars(delegate, (goal, opaque_types));
+
+    let (orig_values, canonical_goal) = EvalCtxt::canonicalize_goal(delegate, goal, opaque_types);
+
+    let (canonical_result, final_revision) =
+        delegate.cx().evaluate_root_goal_for_proof_tree_raw(canonical_goal);
+
+    let proof_tree = inspect::GoalEvaluation {
+        uncanonicalized_goal: goal,
+        orig_values,
+        final_revision,
+        result: canonical_result,
+    };
+
+    let response = match canonical_result {
+        Err(e) => return (Err(e), proof_tree),
+        Ok(response) => response,
+    };
+
+    let (normalization_nested_goals, _certainty) = EvalCtxt::instantiate_and_apply_query_response(
+        delegate,
+        goal.param_env,
+        &proof_tree.orig_values,
+        response,
+        origin_span,
+    );
+
+    (Ok(normalization_nested_goals), proof_tree)
+}
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 fc56b006d9429..2675ed0d0da65 100644
--- a/compiler/rustc_next_trait_solver/src/solve/inspect/build.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/inspect/build.rs
@@ -12,96 +12,86 @@ use rustc_type_ir::{self as ty, Interner};
 
 use crate::delegate::SolverDelegate;
 use crate::solve::eval_ctxt::canonical;
-use crate::solve::{
-    Certainty, GenerateProofTree, Goal, GoalEvaluationKind, GoalSource, QueryResult, inspect,
-};
+use crate::solve::{Certainty, Goal, GoalSource, QueryResult, inspect};
 
-/// The core data structure when building proof trees.
+/// We need to know whether to build a prove tree while evaluating. We
+/// pass a `ProofTreeBuilder` with `state: Some(None)` into the search
+/// graph which then causes the initial `EvalCtxt::compute_goal` to actually
+/// build a proof tree which then gets written into the `state`.
 ///
-/// In case the current evaluation does not generate a proof
-/// tree, `state` is simply `None` and we avoid any work.
-///
-/// The possible states of the solver are represented via
-/// variants of [DebugSolver]. For any nested computation we call
-/// `ProofTreeBuilder::new_nested_computation_kind` which
-/// creates a new `ProofTreeBuilder` to temporarily replace the
-/// current one. Once that nested computation is done,
-/// `ProofTreeBuilder::nested_computation_kind` is called
-/// to add the finished nested evaluation to the parent.
-///
-/// We provide additional information to the current state
-/// by calling methods such as `ProofTreeBuilder::probe_kind`.
-///
-/// The actual structure closely mirrors the finished proof
-/// trees. At the end of trait solving `ProofTreeBuilder::finalize`
-/// is called to recursively convert the whole structure to a
-/// finished proof tree.
+/// Building the proof tree for a single evaluation step happens via the
+/// [EvaluationStepBuilder] which is updated by the `EvalCtxt` when
+/// appropriate.
 pub(crate) struct ProofTreeBuilder<D, I = <D as SolverDelegate>::Interner>
 where
     D: SolverDelegate<Interner = I>,
     I: Interner,
 {
+    state: Option<Box<Option<inspect::Probe<I>>>>,
     _infcx: PhantomData<D>,
-    state: Option<Box<DebugSolver<I>>>,
 }
 
-/// The current state of the proof tree builder, at most places
-/// in the code, only one or two variants are actually possible.
-///
-/// We simply ICE in case that assumption is broken.
-#[derive_where(Debug; I: Interner)]
-enum DebugSolver<I: Interner> {
-    Root,
-    GoalEvaluation(WipGoalEvaluation<I>),
-    CanonicalGoalEvaluationStep(WipCanonicalGoalEvaluationStep<I>),
-}
+impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
+    pub(crate) fn new() -> ProofTreeBuilder<D> {
+        ProofTreeBuilder { state: Some(Box::new(None)), _infcx: PhantomData }
+    }
 
-impl<I: Interner> From<WipGoalEvaluation<I>> for DebugSolver<I> {
-    fn from(g: WipGoalEvaluation<I>) -> DebugSolver<I> {
-        DebugSolver::GoalEvaluation(g)
+    pub(crate) fn new_noop() -> ProofTreeBuilder<D> {
+        ProofTreeBuilder { state: None, _infcx: PhantomData }
     }
-}
 
-impl<I: Interner> From<WipCanonicalGoalEvaluationStep<I>> for DebugSolver<I> {
-    fn from(g: WipCanonicalGoalEvaluationStep<I>) -> DebugSolver<I> {
-        DebugSolver::CanonicalGoalEvaluationStep(g)
+    pub(crate) fn is_noop(&self) -> bool {
+        self.state.is_none()
     }
-}
 
-#[derive_where(PartialEq, Debug; I: Interner)]
-struct WipGoalEvaluation<I: Interner> {
-    pub uncanonicalized_goal: Goal<I, I::Predicate>,
-    pub orig_values: Vec<I::GenericArg>,
-    pub encountered_overflow: bool,
-    /// After we finished evaluating this is moved into `kind`.
-    pub final_revision: Option<WipCanonicalGoalEvaluationStep<I>>,
-    pub result: Option<QueryResult<I>>,
-}
+    pub(crate) fn new_evaluation_step(
+        &mut self,
+        var_values: ty::CanonicalVarValues<I>,
+    ) -> EvaluationStepBuilder<D> {
+        if self.is_noop() {
+            EvaluationStepBuilder { state: None, _infcx: PhantomData }
+        } else {
+            EvaluationStepBuilder {
+                state: Some(Box::new(WipEvaluationStep {
+                    var_values: var_values.var_values.to_vec(),
+                    evaluation: WipProbe {
+                        initial_num_var_values: var_values.len(),
+                        steps: vec![],
+                        kind: None,
+                        final_state: None,
+                    },
+                    probe_depth: 0,
+                })),
+                _infcx: PhantomData,
+            }
+        }
+    }
 
-impl<I: Interner> Eq for WipGoalEvaluation<I> {}
-
-impl<I: Interner> WipGoalEvaluation<I> {
-    fn finalize(self) -> inspect::GoalEvaluation<I> {
-        inspect::GoalEvaluation {
-            uncanonicalized_goal: self.uncanonicalized_goal,
-            orig_values: self.orig_values,
-            kind: if self.encountered_overflow {
-                assert!(self.final_revision.is_none());
-                inspect::GoalEvaluationKind::Overflow
-            } else {
-                let final_revision = self.final_revision.unwrap().finalize();
-                inspect::GoalEvaluationKind::Evaluation { final_revision }
-            },
-            result: self.result.unwrap(),
+    pub(crate) fn finish_evaluation_step(
+        &mut self,
+        goal_evaluation_step: EvaluationStepBuilder<D>,
+    ) {
+        if let Some(this) = self.state.as_deref_mut() {
+            *this = Some(goal_evaluation_step.state.unwrap().finalize());
         }
     }
+
+    pub(crate) fn unwrap(self) -> inspect::Probe<I> {
+        self.state.unwrap().unwrap()
+    }
 }
 
-/// This only exists during proof tree building and does not have
-/// a corresponding struct in `inspect`. We need this to track a
-/// bunch of metadata about the current evaluation.
-#[derive_where(PartialEq, Debug; I: Interner)]
-struct WipCanonicalGoalEvaluationStep<I: Interner> {
+pub(crate) struct EvaluationStepBuilder<D, I = <D as SolverDelegate>::Interner>
+where
+    D: SolverDelegate<Interner = I>,
+    I: Interner,
+{
+    state: Option<Box<WipEvaluationStep<I>>>,
+    _infcx: PhantomData<D>,
+}
+
+#[derive_where(PartialEq, Eq, Debug; I: Interner)]
+struct WipEvaluationStep<I: Interner> {
     /// Unlike `EvalCtxt::var_values`, we append a new
     /// generic arg here whenever we create a new inference
     /// variable.
@@ -113,9 +103,7 @@ struct WipCanonicalGoalEvaluationStep<I: Interner> {
     evaluation: WipProbe<I>,
 }
 
-impl<I: Interner> Eq for WipCanonicalGoalEvaluationStep<I> {}
-
-impl<I: Interner> WipCanonicalGoalEvaluationStep<I> {
+impl<I: Interner> WipEvaluationStep<I> {
     fn current_evaluation_scope(&mut self) -> &mut WipProbe<I> {
         let mut current = &mut self.evaluation;
         for _ in 0..self.probe_depth {
@@ -181,169 +169,48 @@ impl<I: Interner> WipProbeStep<I> {
     }
 }
 
-impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
-    fn new(state: impl Into<DebugSolver<I>>) -> ProofTreeBuilder<D> {
-        ProofTreeBuilder { state: Some(Box::new(state.into())), _infcx: PhantomData }
-    }
-
-    fn opt_nested<T: Into<DebugSolver<I>>>(&self, state: impl FnOnce() -> Option<T>) -> Self {
-        ProofTreeBuilder {
-            state: self.state.as_ref().and_then(|_| Some(state()?.into())).map(Box::new),
-            _infcx: PhantomData,
-        }
+impl<D: SolverDelegate<Interner = I>, I: Interner> EvaluationStepBuilder<D> {
+    pub(crate) fn new_noop() -> EvaluationStepBuilder<D> {
+        EvaluationStepBuilder { state: None, _infcx: PhantomData }
     }
 
-    fn nested<T: Into<DebugSolver<I>>>(&self, state: impl FnOnce() -> T) -> Self {
-        ProofTreeBuilder {
-            state: self.state.as_ref().map(|_| Box::new(state().into())),
-            _infcx: PhantomData,
-        }
+    pub(crate) fn is_noop(&self) -> bool {
+        self.state.is_none()
     }
 
-    fn as_mut(&mut self) -> Option<&mut DebugSolver<I>> {
+    fn as_mut(&mut self) -> Option<&mut WipEvaluationStep<I>> {
         self.state.as_deref_mut()
     }
 
-    pub(crate) fn take_and_enter_probe(&mut self) -> ProofTreeBuilder<D> {
-        let mut nested = ProofTreeBuilder { state: self.state.take(), _infcx: PhantomData };
+    pub(crate) fn take_and_enter_probe(&mut self) -> EvaluationStepBuilder<D> {
+        let mut nested = EvaluationStepBuilder { state: self.state.take(), _infcx: PhantomData };
         nested.enter_probe();
         nested
     }
 
-    pub(crate) fn finalize(self) -> Option<inspect::GoalEvaluation<I>> {
-        match *self.state? {
-            DebugSolver::GoalEvaluation(wip_goal_evaluation) => {
-                Some(wip_goal_evaluation.finalize())
-            }
-            root => unreachable!("unexpected proof tree builder root node: {:?}", root),
-        }
-    }
-
-    pub(crate) fn new_maybe_root(generate_proof_tree: GenerateProofTree) -> ProofTreeBuilder<D> {
-        match generate_proof_tree {
-            GenerateProofTree::No => ProofTreeBuilder::new_noop(),
-            GenerateProofTree::Yes => ProofTreeBuilder::new_root(),
-        }
-    }
-
-    fn new_root() -> ProofTreeBuilder<D> {
-        ProofTreeBuilder::new(DebugSolver::Root)
-    }
-
-    fn new_noop() -> ProofTreeBuilder<D> {
-        ProofTreeBuilder { state: None, _infcx: PhantomData }
-    }
-
-    pub(crate) fn is_noop(&self) -> bool {
-        self.state.is_none()
-    }
-
-    pub(in crate::solve) fn new_goal_evaluation(
-        &mut self,
-        uncanonicalized_goal: Goal<I, I::Predicate>,
-        orig_values: &[I::GenericArg],
-        kind: GoalEvaluationKind,
-    ) -> ProofTreeBuilder<D> {
-        self.opt_nested(|| match kind {
-            GoalEvaluationKind::Root => Some(WipGoalEvaluation {
-                uncanonicalized_goal,
-                orig_values: orig_values.to_vec(),
-                encountered_overflow: false,
-                final_revision: None,
-                result: None,
-            }),
-            GoalEvaluationKind::Nested => None,
-        })
-    }
-
-    pub(crate) fn canonical_goal_evaluation_overflow(&mut self) {
+    pub(crate) fn add_var_value<T: Into<I::GenericArg>>(&mut self, arg: T) {
         if let Some(this) = self.as_mut() {
-            match this {
-                DebugSolver::GoalEvaluation(goal_evaluation) => {
-                    goal_evaluation.encountered_overflow = true;
-                }
-                _ => unreachable!(),
-            };
+            this.var_values.push(arg.into());
         }
     }
 
-    pub(crate) fn goal_evaluation(&mut self, goal_evaluation: ProofTreeBuilder<D>) {
+    fn enter_probe(&mut self) {
         if let Some(this) = self.as_mut() {
-            match this {
-                DebugSolver::Root => *this = *goal_evaluation.state.unwrap(),
-                DebugSolver::CanonicalGoalEvaluationStep(_) => {
-                    assert!(goal_evaluation.state.is_none())
-                }
-                _ => unreachable!(),
-            }
-        }
-    }
-
-    pub(crate) fn new_goal_evaluation_step(
-        &mut self,
-        var_values: ty::CanonicalVarValues<I>,
-    ) -> ProofTreeBuilder<D> {
-        self.nested(|| WipCanonicalGoalEvaluationStep {
-            var_values: var_values.var_values.to_vec(),
-            evaluation: WipProbe {
-                initial_num_var_values: var_values.len(),
+            let initial_num_var_values = this.var_values.len();
+            this.current_evaluation_scope().steps.push(WipProbeStep::NestedProbe(WipProbe {
+                initial_num_var_values,
                 steps: vec![],
                 kind: None,
                 final_state: None,
-            },
-            probe_depth: 0,
-        })
-    }
-
-    pub(crate) fn goal_evaluation_step(&mut self, goal_evaluation_step: ProofTreeBuilder<D>) {
-        if let Some(this) = self.as_mut() {
-            match (this, *goal_evaluation_step.state.unwrap()) {
-                (
-                    DebugSolver::GoalEvaluation(goal_evaluation),
-                    DebugSolver::CanonicalGoalEvaluationStep(goal_evaluation_step),
-                ) => {
-                    goal_evaluation.final_revision = Some(goal_evaluation_step);
-                }
-                _ => unreachable!(),
-            }
-        }
-    }
-
-    pub(crate) fn add_var_value<T: Into<I::GenericArg>>(&mut self, arg: T) {
-        match self.as_mut() {
-            None => {}
-            Some(DebugSolver::CanonicalGoalEvaluationStep(state)) => {
-                state.var_values.push(arg.into());
-            }
-            Some(s) => panic!("tried to add var values to {s:?}"),
-        }
-    }
-
-    fn enter_probe(&mut self) {
-        match self.as_mut() {
-            None => {}
-            Some(DebugSolver::CanonicalGoalEvaluationStep(state)) => {
-                let initial_num_var_values = state.var_values.len();
-                state.current_evaluation_scope().steps.push(WipProbeStep::NestedProbe(WipProbe {
-                    initial_num_var_values,
-                    steps: vec![],
-                    kind: None,
-                    final_state: None,
-                }));
-                state.probe_depth += 1;
-            }
-            Some(s) => panic!("tried to start probe to {s:?}"),
+            }));
+            this.probe_depth += 1;
         }
     }
 
     pub(crate) fn probe_kind(&mut self, probe_kind: inspect::ProbeKind<I>) {
-        match self.as_mut() {
-            None => {}
-            Some(DebugSolver::CanonicalGoalEvaluationStep(state)) => {
-                let prev = state.current_evaluation_scope().kind.replace(probe_kind);
-                assert_eq!(prev, None);
-            }
-            _ => panic!(),
+        if let Some(this) = self.as_mut() {
+            let prev = this.current_evaluation_scope().kind.replace(probe_kind);
+            assert_eq!(prev, None);
         }
     }
 
@@ -352,19 +219,11 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
         delegate: &D,
         max_input_universe: ty::UniverseIndex,
     ) {
-        match self.as_mut() {
-            None => {}
-            Some(DebugSolver::CanonicalGoalEvaluationStep(state)) => {
-                let final_state = canonical::make_canonical_state(
-                    delegate,
-                    &state.var_values,
-                    max_input_universe,
-                    (),
-                );
-                let prev = state.current_evaluation_scope().final_state.replace(final_state);
-                assert_eq!(prev, None);
-            }
-            _ => panic!(),
+        if let Some(this) = self.as_mut() {
+            let final_state =
+                canonical::make_canonical_state(delegate, &this.var_values, max_input_universe, ());
+            let prev = this.current_evaluation_scope().final_state.replace(final_state);
+            assert_eq!(prev, None);
         }
     }
 
@@ -375,18 +234,14 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
         source: GoalSource,
         goal: Goal<I, I::Predicate>,
     ) {
-        match self.as_mut() {
-            None => {}
-            Some(DebugSolver::CanonicalGoalEvaluationStep(state)) => {
-                let goal = canonical::make_canonical_state(
-                    delegate,
-                    &state.var_values,
-                    max_input_universe,
-                    goal,
-                );
-                state.current_evaluation_scope().steps.push(WipProbeStep::AddGoal(source, goal))
-            }
-            _ => panic!(),
+        if let Some(this) = self.as_mut() {
+            let goal = canonical::make_canonical_state(
+                delegate,
+                &this.var_values,
+                max_input_universe,
+                goal,
+            );
+            this.current_evaluation_scope().steps.push(WipProbeStep::AddGoal(source, goal))
         }
     }
 
@@ -396,47 +251,31 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
         max_input_universe: ty::UniverseIndex,
         impl_args: I::GenericArgs,
     ) {
-        match self.as_mut() {
-            Some(DebugSolver::CanonicalGoalEvaluationStep(state)) => {
-                let impl_args = canonical::make_canonical_state(
-                    delegate,
-                    &state.var_values,
-                    max_input_universe,
-                    impl_args,
-                );
-                state
-                    .current_evaluation_scope()
-                    .steps
-                    .push(WipProbeStep::RecordImplArgs { impl_args });
-            }
-            None => {}
-            _ => panic!(),
+        if let Some(this) = self.as_mut() {
+            let impl_args = canonical::make_canonical_state(
+                delegate,
+                &this.var_values,
+                max_input_universe,
+                impl_args,
+            );
+            this.current_evaluation_scope().steps.push(WipProbeStep::RecordImplArgs { impl_args });
         }
     }
 
     pub(crate) fn make_canonical_response(&mut self, shallow_certainty: Certainty) {
-        match self.as_mut() {
-            Some(DebugSolver::CanonicalGoalEvaluationStep(state)) => {
-                state
-                    .current_evaluation_scope()
-                    .steps
-                    .push(WipProbeStep::MakeCanonicalResponse { shallow_certainty });
-            }
-            None => {}
-            _ => panic!(),
+        if let Some(this) = self.as_mut() {
+            this.current_evaluation_scope()
+                .steps
+                .push(WipProbeStep::MakeCanonicalResponse { shallow_certainty });
         }
     }
 
-    pub(crate) fn finish_probe(mut self) -> ProofTreeBuilder<D> {
-        match self.as_mut() {
-            None => {}
-            Some(DebugSolver::CanonicalGoalEvaluationStep(state)) => {
-                assert_ne!(state.probe_depth, 0);
-                let num_var_values = state.current_evaluation_scope().initial_num_var_values;
-                state.var_values.truncate(num_var_values);
-                state.probe_depth -= 1;
-            }
-            _ => panic!(),
+    pub(crate) fn finish_probe(mut self) -> EvaluationStepBuilder<D> {
+        if let Some(this) = self.as_mut() {
+            assert_ne!(this.probe_depth, 0);
+            let num_var_values = this.current_evaluation_scope().initial_num_var_values;
+            this.var_values.truncate(num_var_values);
+            this.probe_depth -= 1;
         }
 
         self
@@ -444,21 +283,7 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
 
     pub(crate) fn query_result(&mut self, result: QueryResult<I>) {
         if let Some(this) = self.as_mut() {
-            match this {
-                DebugSolver::GoalEvaluation(goal_evaluation) => {
-                    assert_eq!(goal_evaluation.result.replace(result), None);
-                }
-                DebugSolver::CanonicalGoalEvaluationStep(evaluation_step) => {
-                    assert_eq!(
-                        evaluation_step
-                            .evaluation
-                            .kind
-                            .replace(inspect::ProbeKind::Root { result }),
-                        None
-                    );
-                }
-                _ => unreachable!(),
-            }
+            assert_eq!(this.evaluation.kind.replace(inspect::ProbeKind::Root { result }), None);
         }
     }
 }
diff --git a/compiler/rustc_next_trait_solver/src/solve/mod.rs b/compiler/rustc_next_trait_solver/src/solve/mod.rs
index 710b59f662a77..85f9d852d9593 100644
--- a/compiler/rustc_next_trait_solver/src/solve/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/mod.rs
@@ -27,7 +27,10 @@ pub use rustc_type_ir::solve::*;
 use rustc_type_ir::{self as ty, Interner, TypingMode};
 use tracing::instrument;
 
-pub use self::eval_ctxt::{EvalCtxt, GenerateProofTree, SolverDelegateEvalExt};
+pub use self::eval_ctxt::{
+    EvalCtxt, GenerateProofTree, SolverDelegateEvalExt,
+    evaluate_root_goal_for_proof_tree_raw_provider,
+};
 use crate::delegate::SolverDelegate;
 use crate::solve::assembly::Candidate;
 
@@ -42,12 +45,6 @@ use crate::solve::assembly::Candidate;
 /// recursion limit again. However, this feels very unlikely.
 const FIXPOINT_STEP_LIMIT: usize = 8;
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-enum GoalEvaluationKind {
-    Root,
-    Nested,
-}
-
 /// Whether evaluating this goal ended up changing the
 /// inference state.
 #[derive(PartialEq, Eq, Debug, Hash, Clone, Copy)]
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 84f8eda4f8da7..f0342e0523ff4 100644
--- a/compiler/rustc_next_trait_solver/src/solve/search_graph.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/search_graph.rs
@@ -7,8 +7,9 @@ use rustc_type_ir::solve::{CanonicalInput, Certainty, NoSolution, QueryResult};
 use rustc_type_ir::{Interner, TypingMode};
 
 use crate::delegate::SolverDelegate;
-use crate::solve::inspect::ProofTreeBuilder;
-use crate::solve::{EvalCtxt, FIXPOINT_STEP_LIMIT, has_no_inference_or_external_constraints};
+use crate::solve::{
+    EvalCtxt, FIXPOINT_STEP_LIMIT, has_no_inference_or_external_constraints, inspect,
+};
 
 /// This type is never constructed. We only use it to implement `search_graph::Delegate`
 /// for all types which impl `SolverDelegate` and doing it directly fails in coherence.
@@ -34,7 +35,7 @@ where
 
     const FIXPOINT_STEP_LIMIT: usize = FIXPOINT_STEP_LIMIT;
 
-    type ProofTreeBuilder = ProofTreeBuilder<D>;
+    type ProofTreeBuilder = inspect::ProofTreeBuilder<D>;
     fn inspect_is_noop(inspect: &mut Self::ProofTreeBuilder) -> bool {
         inspect.is_noop()
     }
@@ -81,12 +82,7 @@ where
         Self::initial_provisional_result(cx, kind, input) == result
     }
 
-    fn on_stack_overflow(
-        cx: I,
-        input: CanonicalInput<I>,
-        inspect: &mut ProofTreeBuilder<D>,
-    ) -> QueryResult<I> {
-        inspect.canonical_goal_evaluation_overflow();
+    fn on_stack_overflow(cx: I, input: CanonicalInput<I>) -> QueryResult<I> {
         response_no_constraints(cx, input, Certainty::overflow(true))
     }
 
diff --git a/compiler/rustc_trait_selection/src/solve.rs b/compiler/rustc_trait_selection/src/solve.rs
index f58961683a9c1..5d200c4d340ba 100644
--- a/compiler/rustc_trait_selection/src/solve.rs
+++ b/compiler/rustc_trait_selection/src/solve.rs
@@ -13,4 +13,20 @@ pub use normalize::{
     deeply_normalize, deeply_normalize_with_skipped_universes,
     deeply_normalize_with_skipped_universes_and_ambiguous_coroutine_goals,
 };
+use rustc_middle::query::Providers;
+use rustc_middle::ty::TyCtxt;
 pub use select::InferCtxtSelectExt;
+
+fn evaluate_root_goal_for_proof_tree_raw<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    canonical_input: CanonicalInput<TyCtxt<'tcx>>,
+) -> (QueryResult<TyCtxt<'tcx>>, &'tcx inspect::Probe<TyCtxt<'tcx>>) {
+    evaluate_root_goal_for_proof_tree_raw_provider::<SolverDelegate<'tcx>, TyCtxt<'tcx>>(
+        tcx,
+        canonical_input,
+    )
+}
+
+pub fn provide(providers: &mut Providers) {
+    *providers = Providers { evaluate_root_goal_for_proof_tree_raw, ..*providers };
+}
diff --git a/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs b/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs
index 308486811e6e3..342d7121fc373 100644
--- a/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs
+++ b/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs
@@ -37,7 +37,7 @@ pub struct InspectGoal<'a, 'tcx> {
     orig_values: Vec<ty::GenericArg<'tcx>>,
     goal: Goal<'tcx, ty::Predicate<'tcx>>,
     result: Result<Certainty, NoSolution>,
-    evaluation_kind: inspect::GoalEvaluationKind<TyCtxt<'tcx>>,
+    final_revision: &'tcx inspect::Probe<TyCtxt<'tcx>>,
     normalizes_to_term_hack: Option<NormalizesToTermHack<'tcx>>,
     source: GoalSource,
 }
@@ -249,7 +249,7 @@ impl<'a, 'tcx> InspectCandidate<'a, 'tcx> {
                     // `InspectGoal::new` so that the goal has the right result (and maintains
                     // the impression that we don't do this normalizes-to infer hack at all).
                     let (nested, proof_tree) = infcx.evaluate_root_goal_for_proof_tree(goal, span);
-                    let nested_goals_result = nested.and_then(|(nested, _)| {
+                    let nested_goals_result = nested.and_then(|nested| {
                         normalizes_to_term_hack.constrain_and(
                             infcx,
                             span,
@@ -391,15 +391,8 @@ 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 {
-            // An annoying edge case in case the recursion limit is 0.
-            inspect::GoalEvaluationKind::Overflow => return vec![],
-            inspect::GoalEvaluationKind::Evaluation { final_revision } => final_revision,
-        };
-
         let mut nested_goals = vec![];
-        self.candidates_recur(&mut candidates, &mut nested_goals, &last_eval_step);
-
+        self.candidates_recur(&mut candidates, &mut nested_goals, &self.final_revision);
         candidates
     }
 
@@ -426,7 +419,8 @@ impl<'a, 'tcx> InspectGoal<'a, 'tcx> {
     ) -> Self {
         let infcx = <&SolverDelegate<'tcx>>::from(infcx);
 
-        let inspect::GoalEvaluation { uncanonicalized_goal, orig_values, kind, result } = root;
+        let inspect::GoalEvaluation { uncanonicalized_goal, orig_values, final_revision, result } =
+            root;
         // If there's a normalizes-to goal, AND the evaluation result with the result of
         // constraining the normalizes-to RHS and computing the nested goals.
         let result = result.and_then(|ok| {
@@ -441,7 +435,7 @@ impl<'a, 'tcx> InspectGoal<'a, 'tcx> {
             orig_values,
             goal: eager_resolve_vars(infcx, uncanonicalized_goal),
             result,
-            evaluation_kind: kind,
+            final_revision,
             normalizes_to_term_hack: term_hack_and_nested_certainty.map(|(n, _)| n),
             source,
         }
diff --git a/compiler/rustc_type_ir/src/interner.rs b/compiler/rustc_type_ir/src/interner.rs
index 21fe7879b298f..f5448baf8c0b9 100644
--- a/compiler/rustc_type_ir/src/interner.rs
+++ b/compiler/rustc_type_ir/src/interner.rs
@@ -10,7 +10,9 @@ use crate::inherent::*;
 use crate::ir_print::IrPrint;
 use crate::lang_items::{SolverLangItem, SolverTraitLangItem};
 use crate::relate::Relate;
-use crate::solve::{CanonicalInput, ExternalConstraintsData, PredefinedOpaquesData, QueryResult};
+use crate::solve::{
+    CanonicalInput, ExternalConstraintsData, PredefinedOpaquesData, QueryResult, inspect,
+};
 use crate::visit::{Flags, TypeVisitable};
 use crate::{self as ty, CanonicalParamEnvCacheEntry, search_graph};
 
@@ -380,6 +382,13 @@ pub trait Interner:
         self,
         defining_anchor: Self::LocalDefId,
     ) -> Self::LocalDefIds;
+
+    type ProbeRef: Copy + Debug + Hash + Eq + Deref<Target = inspect::Probe<Self>>;
+    fn mk_probe_ref(self, probe: inspect::Probe<Self>) -> Self::ProbeRef;
+    fn evaluate_root_goal_for_proof_tree_raw(
+        self,
+        canonical_goal: CanonicalInput<Self>,
+    ) -> (QueryResult<Self>, Self::ProbeRef);
 }
 
 /// Imagine you have a function `F: FnOnce(&[T]) -> R`, plus an iterator `iter`
diff --git a/compiler/rustc_type_ir/src/search_graph/mod.rs b/compiler/rustc_type_ir/src/search_graph/mod.rs
index 348178a527fbe..dbbc0c217d7d4 100644
--- a/compiler/rustc_type_ir/src/search_graph/mod.rs
+++ b/compiler/rustc_type_ir/src/search_graph/mod.rs
@@ -92,11 +92,7 @@ pub trait Delegate: Sized {
         input: <Self::Cx as Cx>::Input,
         result: <Self::Cx as Cx>::Result,
     ) -> bool;
-    fn on_stack_overflow(
-        cx: Self::Cx,
-        input: <Self::Cx as Cx>::Input,
-        inspect: &mut Self::ProofTreeBuilder,
-    ) -> <Self::Cx as Cx>::Result;
+    fn on_stack_overflow(cx: Self::Cx, input: <Self::Cx as Cx>::Input) -> <Self::Cx as Cx>::Result;
     fn on_fixpoint_overflow(
         cx: Self::Cx,
         input: <Self::Cx as Cx>::Input,
@@ -703,6 +699,31 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         }
     }
 
+    pub fn evaluate_root_goal_for_proof_tree(
+        cx: X,
+        root_depth: usize,
+        input: X::Input,
+        inspect: &mut D::ProofTreeBuilder,
+    ) -> X::Result {
+        let mut this = SearchGraph::<D>::new(root_depth);
+        let available_depth = AvailableDepth(root_depth);
+        let step_kind_from_parent = PathKind::Inductive; // is never used
+        this.stack.push(StackEntry {
+            input,
+            step_kind_from_parent,
+            available_depth,
+            provisional_result: None,
+            required_depth: 0,
+            heads: Default::default(),
+            encountered_overflow: false,
+            usages: None,
+            candidate_usages: None,
+            nested_goals: Default::default(),
+        });
+        let evaluation_result = this.evaluate_goal_in_task(cx, input, inspect);
+        evaluation_result.result
+    }
+
     /// Probably the most involved method of the whole solver.
     ///
     /// While goals get computed via `D::compute_goal`, this function handles
@@ -718,7 +739,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         let Some(available_depth) =
             AvailableDepth::allowed_depth_for_nested::<D>(self.root_depth, &self.stack)
         else {
-            return self.handle_overflow(cx, input, inspect);
+            return self.handle_overflow(cx, input);
         };
 
         // We check the provisional cache before checking the global cache. This simplifies
@@ -833,12 +854,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         result
     }
 
-    fn handle_overflow(
-        &mut self,
-        cx: X,
-        input: X::Input,
-        inspect: &mut D::ProofTreeBuilder,
-    ) -> X::Result {
+    fn handle_overflow(&mut self, cx: X, input: X::Input) -> X::Result {
         if let Some(last) = self.stack.last_mut() {
             last.encountered_overflow = true;
             // If computing a goal `B` depends on another goal `A` and
@@ -853,7 +869,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         }
 
         debug!("encountered stack overflow");
-        D::on_stack_overflow(cx, input, inspect)
+        D::on_stack_overflow(cx, input)
     }
 
     /// When reevaluating a goal with a changed provisional result, all provisional cache entry
diff --git a/compiler/rustc_type_ir/src/solve/inspect.rs b/compiler/rustc_type_ir/src/solve/inspect.rs
index afb4043648f65..5452ac441589d 100644
--- a/compiler/rustc_type_ir/src/solve/inspect.rs
+++ b/compiler/rustc_type_ir/src/solve/inspect.rs
@@ -45,31 +45,18 @@ pub type CanonicalState<I, T> = Canonical<I, State<I, T>>;
 /// for the `CanonicalVarValues` of the canonicalized goal.
 /// We use this to map any [CanonicalState] from the local `InferCtxt`
 /// of the solver query to the `InferCtxt` of the caller.
-#[derive_where(PartialEq, Hash; I: Interner)]
+#[derive_where(PartialEq, Eq, Hash; I: Interner)]
 pub struct GoalEvaluation<I: Interner> {
     pub uncanonicalized_goal: Goal<I, I::Predicate>,
     pub orig_values: Vec<I::GenericArg>,
-    pub kind: GoalEvaluationKind<I>,
+    pub final_revision: I::ProbeRef,
     pub result: QueryResult<I>,
 }
 
-impl<I: Interner> Eq for GoalEvaluation<I> {}
-
-#[derive_where(PartialEq, Hash, Debug; I: Interner)]
-pub enum GoalEvaluationKind<I: Interner> {
-    Overflow,
-    Evaluation {
-        /// This is always `ProbeKind::Root`.
-        final_revision: Probe<I>,
-    },
-}
-
-impl<I: Interner> Eq for GoalEvaluationKind<I> {}
-
 /// A self-contained computation during trait solving. This either
 /// corresponds to a `EvalCtxt::probe(_X)` call or the root evaluation
 /// of a goal.
-#[derive_where(PartialEq, Hash, Debug; I: Interner)]
+#[derive_where(PartialEq, Eq, Hash, Debug; I: Interner)]
 pub struct Probe<I: Interner> {
     /// What happened inside of this probe in chronological order.
     pub steps: Vec<ProbeStep<I>>,
@@ -77,9 +64,7 @@ pub struct Probe<I: Interner> {
     pub final_state: CanonicalState<I, ()>,
 }
 
-impl<I: Interner> Eq for Probe<I> {}
-
-#[derive_where(PartialEq, Hash, Debug; I: Interner)]
+#[derive_where(PartialEq, Eq, Hash, Debug; I: Interner)]
 pub enum ProbeStep<I: Interner> {
     /// We added a goal to the `EvalCtxt` which will get proven
     /// the next time `EvalCtxt::try_evaluate_added_goals` is called.
@@ -98,12 +83,10 @@ pub enum ProbeStep<I: Interner> {
     MakeCanonicalResponse { shallow_certainty: Certainty },
 }
 
-impl<I: Interner> Eq for ProbeStep<I> {}
-
 /// What kind of probe we're in. In case the probe represents a candidate, or
 /// the final result of the current goal - via [ProbeKind::Root] - we also
 /// store the [QueryResult].
-#[derive_where(Clone, Copy, PartialEq, Hash, Debug; I: Interner)]
+#[derive_where(Clone, Copy, PartialEq, Eq, Hash, Debug; I: Interner)]
 #[derive(TypeVisitable_Generic, TypeFoldable_Generic)]
 pub enum ProbeKind<I: Interner> {
     /// The root inference context while proving a goal.
@@ -128,5 +111,3 @@ pub enum ProbeKind<I: Interner> {
     /// Checking that a rigid alias is well-formed.
     RigidAlias { result: QueryResult<I> },
 }
-
-impl<I: Interner> Eq for ProbeKind<I> {}

From 46727f4cb06c3496a541ee8517a24ef5cb77627c Mon Sep 17 00:00:00 2001
From: Alice Ryhl <aliceryhl@google.com>
Date: Wed, 20 Aug 2025 15:04:34 +0000
Subject: [PATCH 0329/1889] Stabilize file_as_c_str

---
 library/core/src/panic/location.rs                            | 3 ++-
 tests/ui/rfcs/rfc-2091-track-caller/file-is-nul-terminated.rs | 1 -
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/library/core/src/panic/location.rs b/library/core/src/panic/location.rs
index 7a68d393906cb..5935849344475 100644
--- a/library/core/src/panic/location.rs
+++ b/library/core/src/panic/location.rs
@@ -193,8 +193,9 @@ impl<'a> Location<'a> {
     /// This is useful for interop with APIs that expect C/C++ `__FILE__` or
     /// `std::source_location::file_name`, both of which return a nul-terminated `const char*`.
     #[must_use]
-    #[unstable(feature = "file_with_nul", issue = "141727")]
     #[inline]
+    #[stable(feature = "file_with_nul", since = "CURRENT_RUSTC_VERSION")]
+    #[rustc_const_stable(feature = "file_with_nul", since = "CURRENT_RUSTC_VERSION")]
     pub const fn file_as_c_str(&self) -> &'a CStr {
         let filename = self.filename.as_ptr();
 
diff --git a/tests/ui/rfcs/rfc-2091-track-caller/file-is-nul-terminated.rs b/tests/ui/rfcs/rfc-2091-track-caller/file-is-nul-terminated.rs
index 7902f40b09bdb..698492966adf3 100644
--- a/tests/ui/rfcs/rfc-2091-track-caller/file-is-nul-terminated.rs
+++ b/tests/ui/rfcs/rfc-2091-track-caller/file-is-nul-terminated.rs
@@ -1,5 +1,4 @@
 //@ run-pass
-#![feature(file_with_nul)]
 
 #[track_caller]
 const fn assert_file_has_trailing_zero() {

From fc7de9979e418b0ea467bb2833b07486d7c54940 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Thu, 28 Aug 2025 13:36:10 +0000
Subject: [PATCH 0330/1889] Ensure we emit an allocator shim when only some
 crate types need one

---
 compiler/rustc_codegen_ssa/src/back/link.rs | 17 ++++++++++---
 compiler/rustc_codegen_ssa/src/base.rs      | 27 +++++++++++++++++----
 tests/ui/linking/mixed-allocator-shim.rs    | 15 ++++++++++++
 3 files changed, 50 insertions(+), 9 deletions(-)
 create mode 100644 tests/ui/linking/mixed-allocator-shim.rs

diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
index 19c919c0e4efe..48b01ea2df197 100644
--- a/compiler/rustc_codegen_ssa/src/back/link.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -58,6 +58,7 @@ use super::linker::{self, Linker};
 use super::metadata::{MetadataPosition, create_wrapper_file};
 use super::rpath::{self, RPathConfig};
 use super::{apple, versioned_llvm_target};
+use crate::base::needs_allocator_shim_for_linking;
 use crate::{
     CodegenResults, CompiledModule, CrateInfo, NativeLib, errors, looks_like_rust_object_file,
 };
@@ -2080,9 +2081,17 @@ fn add_local_crate_regular_objects(cmd: &mut dyn Linker, codegen_results: &Codeg
 }
 
 /// Add object files for allocator code linked once for the whole crate tree.
-fn add_local_crate_allocator_objects(cmd: &mut dyn Linker, codegen_results: &CodegenResults) {
-    if let Some(obj) = codegen_results.allocator_module.as_ref().and_then(|m| m.object.as_ref()) {
-        cmd.add_object(obj);
+fn add_local_crate_allocator_objects(
+    cmd: &mut dyn Linker,
+    codegen_results: &CodegenResults,
+    crate_type: CrateType,
+) {
+    if needs_allocator_shim_for_linking(&codegen_results.crate_info.dependency_formats, crate_type)
+    {
+        if let Some(obj) = codegen_results.allocator_module.as_ref().and_then(|m| m.object.as_ref())
+        {
+            cmd.add_object(obj);
+        }
     }
 }
 
@@ -2281,7 +2290,7 @@ fn linker_with_args(
         codegen_results,
         metadata,
     );
-    add_local_crate_allocator_objects(cmd, codegen_results);
+    add_local_crate_allocator_objects(cmd, codegen_results, crate_type);
 
     // Avoid linking to dynamic libraries unless they satisfy some undefined symbols
     // at the point at which they are specified on the command line.
diff --git a/compiler/rustc_codegen_ssa/src/base.rs b/compiler/rustc_codegen_ssa/src/base.rs
index 8abaf201abae2..97cdf8b697348 100644
--- a/compiler/rustc_codegen_ssa/src/base.rs
+++ b/compiler/rustc_codegen_ssa/src/base.rs
@@ -17,6 +17,7 @@ use rustc_hir::lang_items::LangItem;
 use rustc_hir::{ItemId, Target};
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrs;
 use rustc_middle::middle::debugger_visualizer::{DebuggerVisualizerFile, DebuggerVisualizerType};
+use rustc_middle::middle::dependency_format::Dependencies;
 use rustc_middle::middle::exported_symbols::{self, SymbolExportKind};
 use rustc_middle::middle::lang_items;
 use rustc_middle::mir::BinOp;
@@ -630,14 +631,30 @@ pub fn allocator_kind_for_codegen(tcx: TyCtxt<'_>) -> Option<AllocatorKind> {
     // If the crate doesn't have an `allocator_kind` set then there's definitely
     // no shim to generate. Otherwise we also check our dependency graph for all
     // our output crate types. If anything there looks like its a `Dynamic`
-    // linkage, then it's already got an allocator shim and we'll be using that
-    // one instead. If nothing exists then it's our job to generate the
-    // allocator!
-    let any_dynamic_crate = tcx.dependency_formats(()).iter().any(|(_, list)| {
+    // linkage for all crate types we may link as, then it's already got an
+    // allocator shim and we'll be using that one instead. If nothing exists
+    // then it's our job to generate the allocator! If crate types disagree
+    // about whether an allocator shim is necessary or not, we generate one
+    // and let needs_allocator_shim_for_linking decide at link time whether or
+    // not to use it for any particular linker invocation.
+    let all_crate_types_any_dynamic_crate = tcx.dependency_formats(()).iter().all(|(_, list)| {
         use rustc_middle::middle::dependency_format::Linkage;
         list.iter().any(|&linkage| linkage == Linkage::Dynamic)
     });
-    if any_dynamic_crate { None } else { tcx.allocator_kind(()) }
+    if all_crate_types_any_dynamic_crate { None } else { tcx.allocator_kind(()) }
+}
+
+/// Decide if this particular crate type needs an allocator shim linked in.
+/// This may return true even when allocator_kind_for_codegen returns false. In
+/// this case no allocator shim shall be linked.
+pub(crate) fn needs_allocator_shim_for_linking(
+    dependency_formats: &Dependencies,
+    crate_type: CrateType,
+) -> bool {
+    use rustc_middle::middle::dependency_format::Linkage;
+    let any_dynamic_crate =
+        dependency_formats[&crate_type].iter().any(|&linkage| linkage == Linkage::Dynamic);
+    !any_dynamic_crate
 }
 
 pub fn codegen_crate<B: ExtraBackendMethods>(
diff --git a/tests/ui/linking/mixed-allocator-shim.rs b/tests/ui/linking/mixed-allocator-shim.rs
new file mode 100644
index 0000000000000..b81fbdc5205e7
--- /dev/null
+++ b/tests/ui/linking/mixed-allocator-shim.rs
@@ -0,0 +1,15 @@
+//@ build-pass
+//@ compile-flags: --crate-type staticlib,dylib -Zstaticlib-prefer-dynamic
+//@ no-prefer-dynamic
+
+// Test that compiling for multiple crate types in a single compilation with
+// mismatching allocator shim requirements doesn't result in the allocator shim
+// missing entirely.
+// In this particular test the dylib crate type will statically link libstd and
+// thus need an allocator shim, while the staticlib crate type will dynamically
+// link libstd and thus not need an allocator shim.
+// The -Zstaticlib-prefer-dynamic flag could be avoided by doing it the other
+// way around, but testing that the staticlib correctly has the allocator shim
+// in that case would require a run-make test instead.
+
+pub fn foo() {}

From 1d309008306f6695bdbbd535245067202ab44802 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Thu, 28 Aug 2025 15:16:48 +0000
Subject: [PATCH 0331/1889] Fix typo in comment

---
 compiler/rustc_codegen_ssa/src/back/linker.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/linker.rs b/compiler/rustc_codegen_ssa/src/back/linker.rs
index df1e91b12f904..03c30dc0c5929 100644
--- a/compiler/rustc_codegen_ssa/src/back/linker.rs
+++ b/compiler/rustc_codegen_ssa/src/back/linker.rs
@@ -1827,7 +1827,7 @@ fn exported_symbols_for_non_proc_macro(
     let export_threshold = symbol_export::crates_export_threshold(&[crate_type]);
     for_each_exported_symbols_include_dep(tcx, crate_type, |symbol, info, cnum| {
         // Do not export mangled symbols from cdylibs and don't attempt to export compiler-builtins
-        // from any cdylib. The latter doesn't work anyway as we use hidden visibility for
+        // from any dylib. The latter doesn't work anyway as we use hidden visibility for
         // compiler-builtins. Most linkers silently ignore it, but ld64 gives a warning.
         if info.level.is_below_threshold(export_threshold) && !tcx.is_compiler_builtins(cnum) {
             symbols.push((

From f4888c2a680aff0bd191704a8d44716eee94103e Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Thu, 28 Aug 2025 16:59:22 +0000
Subject: [PATCH 0332/1889] Correctly handle different crate types disagreeing
 if the allocator shim is exported

Previously it would attempt to export the allocator shim even linking
for a crate type which pulls in the allocator shim from a dylib rather
than locally defining it.
---
 compiler/rustc_codegen_ssa/src/back/linker.rs | 15 +++++-
 compiler/rustc_codegen_ssa/src/back/lto.rs    |  8 ++-
 .../src/back/symbol_export.rs                 | 52 +++++++++----------
 3 files changed, 46 insertions(+), 29 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/linker.rs b/compiler/rustc_codegen_ssa/src/back/linker.rs
index 03c30dc0c5929..a2efd420a327a 100644
--- a/compiler/rustc_codegen_ssa/src/back/linker.rs
+++ b/compiler/rustc_codegen_ssa/src/back/linker.rs
@@ -11,8 +11,9 @@ use rustc_metadata::{
 };
 use rustc_middle::bug;
 use rustc_middle::middle::dependency_format::Linkage;
-use rustc_middle::middle::exported_symbols;
-use rustc_middle::middle::exported_symbols::{ExportedSymbol, SymbolExportInfo, SymbolExportKind};
+use rustc_middle::middle::exported_symbols::{
+    self, ExportedSymbol, SymbolExportInfo, SymbolExportKind, SymbolExportLevel,
+};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Session;
 use rustc_session::config::{self, CrateType, DebugInfo, LinkerPluginLto, Lto, OptLevel, Strip};
@@ -22,6 +23,8 @@ use tracing::{debug, warn};
 
 use super::command::Command;
 use super::symbol_export;
+use crate::back::symbol_export::allocator_shim_symbols;
+use crate::base::needs_allocator_shim_for_linking;
 use crate::errors;
 
 #[cfg(test)]
@@ -1838,6 +1841,14 @@ fn exported_symbols_for_non_proc_macro(
         }
     });
 
+    // Mark allocator shim symbols as exported only if they were generated.
+    if export_threshold == SymbolExportLevel::Rust
+        && needs_allocator_shim_for_linking(tcx.dependency_formats(()), crate_type)
+        && tcx.allocator_kind(()).is_some()
+    {
+        symbols.extend(allocator_shim_symbols(tcx));
+    }
+
     symbols
 }
 
diff --git a/compiler/rustc_codegen_ssa/src/back/lto.rs b/compiler/rustc_codegen_ssa/src/back/lto.rs
index c95038375a1bd..e6df6a2469f37 100644
--- a/compiler/rustc_codegen_ssa/src/back/lto.rs
+++ b/compiler/rustc_codegen_ssa/src/back/lto.rs
@@ -8,8 +8,9 @@ use rustc_middle::ty::TyCtxt;
 use rustc_session::config::{CrateType, Lto};
 use tracing::info;
 
-use crate::back::symbol_export::{self, symbol_name_for_instance_in_crate};
+use crate::back::symbol_export::{self, allocator_shim_symbols, symbol_name_for_instance_in_crate};
 use crate::back::write::CodegenContext;
+use crate::base::allocator_kind_for_codegen;
 use crate::errors::{DynamicLinkingWithLTO, LtoDisallowed, LtoDylib, LtoProcMacro};
 use crate::traits::*;
 
@@ -115,6 +116,11 @@ pub(super) fn exported_symbols_for_lto(
         }
     }
 
+    // Mark allocator shim symbols as exported only if they were generated.
+    if export_threshold == SymbolExportLevel::Rust && allocator_kind_for_codegen(tcx).is_some() {
+        symbols_below_threshold.extend(allocator_shim_symbols(tcx).map(|(name, _kind)| name));
+    }
+
     symbols_below_threshold
 }
 
diff --git a/compiler/rustc_codegen_ssa/src/back/symbol_export.rs b/compiler/rustc_codegen_ssa/src/back/symbol_export.rs
index d8a1480e911fe..b49e67217fb01 100644
--- a/compiler/rustc_codegen_ssa/src/back/symbol_export.rs
+++ b/compiler/rustc_codegen_ssa/src/back/symbol_export.rs
@@ -18,7 +18,7 @@ use rustc_symbol_mangling::mangle_internal_symbol;
 use rustc_target::spec::TlsModel;
 use tracing::debug;
 
-use crate::base::allocator_kind_for_codegen;
+use crate::back::symbol_export;
 
 fn threshold(tcx: TyCtxt<'_>) -> SymbolExportLevel {
     crates_export_threshold(tcx.crate_types())
@@ -217,31 +217,6 @@ fn exported_non_generic_symbols_provider_local<'tcx>(
         ));
     }
 
-    // Mark allocator shim symbols as exported only if they were generated.
-    if allocator_kind_for_codegen(tcx).is_some() {
-        for symbol_name in ALLOCATOR_METHODS
-            .iter()
-            .map(|method| mangle_internal_symbol(tcx, global_fn_name(method.name).as_str()))
-            .chain([
-                mangle_internal_symbol(tcx, "__rust_alloc_error_handler"),
-                mangle_internal_symbol(tcx, OomStrategy::SYMBOL),
-                mangle_internal_symbol(tcx, NO_ALLOC_SHIM_IS_UNSTABLE),
-            ])
-        {
-            let exported_symbol = ExportedSymbol::NoDefId(SymbolName::new(tcx, &symbol_name));
-
-            symbols.push((
-                exported_symbol,
-                SymbolExportInfo {
-                    level: SymbolExportLevel::Rust,
-                    kind: SymbolExportKind::Text,
-                    used: false,
-                    rustc_std_internal_symbol: true,
-                },
-            ));
-        }
-    }
-
     // Sort so we get a stable incr. comp. hash.
     symbols.sort_by_cached_key(|s| s.0.symbol_name_for_local_instance(tcx));
 
@@ -516,6 +491,31 @@ pub(crate) fn provide(providers: &mut Providers) {
         upstream_monomorphizations_for_provider;
 }
 
+pub(crate) fn allocator_shim_symbols(
+    tcx: TyCtxt<'_>,
+) -> impl Iterator<Item = (String, SymbolExportKind)> {
+    ALLOCATOR_METHODS
+        .iter()
+        .map(move |method| mangle_internal_symbol(tcx, global_fn_name(method.name).as_str()))
+        .chain([
+            mangle_internal_symbol(tcx, "__rust_alloc_error_handler"),
+            mangle_internal_symbol(tcx, OomStrategy::SYMBOL),
+            mangle_internal_symbol(tcx, NO_ALLOC_SHIM_IS_UNSTABLE),
+        ])
+        .map(move |symbol_name| {
+            let exported_symbol = ExportedSymbol::NoDefId(SymbolName::new(tcx, &symbol_name));
+
+            (
+                symbol_export::exporting_symbol_name_for_instance_in_crate(
+                    tcx,
+                    exported_symbol,
+                    LOCAL_CRATE,
+                ),
+                SymbolExportKind::Text,
+            )
+        })
+}
+
 fn symbol_export_level(tcx: TyCtxt<'_>, sym_def_id: DefId) -> SymbolExportLevel {
     // We export anything that's not mangled at the "C" layer as it probably has
     // to do with ABI concerns. We do not, however, apply such treatment to

From ae648be78350638873248b348f4fca3b9bc916e8 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Fri, 29 Aug 2025 12:15:41 +0200
Subject: [PATCH 0333/1889] use `llvm.roundeven` on arm

---
 .../core_arch/src/arm_shared/neon/generated.rs       | 12 ++++--------
 .../stdarch-gen-arm/spec/neon/arm_shared.spec.yml    |  8 ++------
 2 files changed, 6 insertions(+), 14 deletions(-)

diff --git a/library/stdarch/crates/core_arch/src/arm_shared/neon/generated.rs b/library/stdarch/crates/core_arch/src/arm_shared/neon/generated.rs
index 22d31d4e25682..b5ba792b18aec 100644
--- a/library/stdarch/crates/core_arch/src/arm_shared/neon/generated.rs
+++ b/library/stdarch/crates/core_arch/src/arm_shared/neon/generated.rs
@@ -58256,10 +58256,9 @@ pub fn vrhaddq_u32(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t {
 pub fn vrndn_f16(a: float16x4_t) -> float16x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
+            any(target_arch = "aarch64", target_arch = "arm64ec", target_arch = "arm"),
             link_name = "llvm.roundeven.v4f16"
         )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vrintn.v4f16")]
         fn _vrndn_f16(a: float16x4_t) -> float16x4_t;
     }
     unsafe { _vrndn_f16(a) }
@@ -58279,10 +58278,9 @@ pub fn vrndn_f16(a: float16x4_t) -> float16x4_t {
 pub fn vrndnq_f16(a: float16x8_t) -> float16x8_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
+            any(target_arch = "aarch64", target_arch = "arm64ec", target_arch = "arm"),
             link_name = "llvm.roundeven.v8f16"
         )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vrintn.v8f16")]
         fn _vrndnq_f16(a: float16x8_t) -> float16x8_t;
     }
     unsafe { _vrndnq_f16(a) }
@@ -58308,10 +58306,9 @@ pub fn vrndnq_f16(a: float16x8_t) -> float16x8_t {
 pub fn vrndn_f32(a: float32x2_t) -> float32x2_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
+            any(target_arch = "aarch64", target_arch = "arm64ec", target_arch = "arm"),
             link_name = "llvm.roundeven.v2f32"
         )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vrintn.v2f32")]
         fn _vrndn_f32(a: float32x2_t) -> float32x2_t;
     }
     unsafe { _vrndn_f32(a) }
@@ -58337,10 +58334,9 @@ pub fn vrndn_f32(a: float32x2_t) -> float32x2_t {
 pub fn vrndnq_f32(a: float32x4_t) -> float32x4_t {
     unsafe extern "unadjusted" {
         #[cfg_attr(
-            any(target_arch = "aarch64", target_arch = "arm64ec"),
+            any(target_arch = "aarch64", target_arch = "arm64ec", target_arch = "arm"),
             link_name = "llvm.roundeven.v4f32"
         )]
-        #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vrintn.v4f32")]
         fn _vrndnq_f32(a: float32x4_t) -> float32x4_t;
     }
     unsafe { _vrndnq_f32(a) }
diff --git a/library/stdarch/crates/stdarch-gen-arm/spec/neon/arm_shared.spec.yml b/library/stdarch/crates/stdarch-gen-arm/spec/neon/arm_shared.spec.yml
index 1543ab1f866e8..43dd3b9031507 100644
--- a/library/stdarch/crates/stdarch-gen-arm/spec/neon/arm_shared.spec.yml
+++ b/library/stdarch/crates/stdarch-gen-arm/spec/neon/arm_shared.spec.yml
@@ -2486,9 +2486,7 @@ intrinsics:
           name: "llvm.frinn.{neon_type}"
           links:
             - link: "llvm.roundeven.{neon_type}"
-              arch: aarch64,arm64ec
-            - link: "llvm.arm.neon.vrintn.{neon_type}"
-              arch: arm
+              arch: aarch64,arm64ec,arm
 
   - name: "vrndn{neon_type.no}"
     doc: "Floating-point round to integral, to nearest with ties to even"
@@ -2510,9 +2508,7 @@ intrinsics:
           name: "llvm.frinn.{neon_type}"
           links:
             - link: "llvm.roundeven.{neon_type}"
-              arch: aarch64,arm64ec
-            - link: "llvm.arm.neon.vrintn.{neon_type}"
-              arch: arm
+              arch: aarch64,arm64ec,arm
 
   - name: "vqadd{neon_type.no}"
     doc: Saturating add

From 00b27f49eb8be37424fb5b21ce5aaac842a1d8b4 Mon Sep 17 00:00:00 2001
From: Amanieu d'Antras <amanieu@gmail.com>
Date: Fri, 29 Aug 2025 11:24:34 +0100
Subject: [PATCH 0334/1889] Remove FreeBSD CI

It's historically been flaky and is no longer needed now that std_detect
has been moved out of this repository.
---
 library/stdarch/.cirrus.yml | 16 ----------------
 1 file changed, 16 deletions(-)
 delete mode 100644 library/stdarch/.cirrus.yml

diff --git a/library/stdarch/.cirrus.yml b/library/stdarch/.cirrus.yml
deleted file mode 100644
index a0ecc03b953fd..0000000000000
--- a/library/stdarch/.cirrus.yml
+++ /dev/null
@@ -1,16 +0,0 @@
-task:
-  name: x86_64-unknown-freebsd
-  freebsd_instance:
-    image_family: freebsd-13-4
-  env:
-    # FIXME(freebsd): FreeBSD has a segfault when `RUST_BACKTRACE` is set
-    # https://github.com/rust-lang/rust/issues/132185
-    RUST_BACKTRACE: "0"
-  setup_script:
-    - curl https://sh.rustup.rs -sSf --output rustup.sh
-    - sh rustup.sh --default-toolchain nightly -y
-    - . $HOME/.cargo/env
-    - rustup default nightly
-  test_script:
-    - . $HOME/.cargo/env
-    - cargo build --all

From 01ed1052d8d243b6e022ed9c26c386752b178779 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 28 Aug 2025 14:58:44 +0200
Subject: [PATCH 0335/1889] unix read/write: fix zero-size handling

---
 src/tools/miri/src/shims/unix/fd.rs   | 28 +++++++++++++++++++++++----
 src/tools/miri/tests/pass/shims/fs.rs |  4 +++-
 src/tools/miri/tests/utils/libc.rs    |  5 +----
 3 files changed, 28 insertions(+), 9 deletions(-)

diff --git a/src/tools/miri/src/shims/unix/fd.rs b/src/tools/miri/src/shims/unix/fd.rs
index e226a55d8b1ee..9fbecffc55d9b 100644
--- a/src/tools/miri/src/shims/unix/fd.rs
+++ b/src/tools/miri/src/shims/unix/fd.rs
@@ -264,11 +264,19 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             return this.set_last_error_and_return(LibcError("EBADF"), dest);
         };
 
+        // Handle the zero-sized case. The man page says:
+        // > If count is zero, read() may detect the errors described below.  In the absence of any
+        // > errors, or if read() does not check for errors, a read() with a count of 0 returns zero
+        // > and has no other effects.
+        if count == 0 {
+            this.write_null(dest)?;
+            return interp_ok(());
+        }
         // Non-deterministically decide to further reduce the count, simulating a partial read (but
-        // never to 0, that has different behavior).
+        // never to 0, that would indicate EOF).
         let count =
             if fd.nondet_short_accesses() && count >= 2 && this.machine.rng.get_mut().random() {
-                count / 2
+                count / 2 // since `count` is at least 2, the result is still at least 1
             } else {
                 count
             };
@@ -338,8 +346,20 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             return this.set_last_error_and_return(LibcError("EBADF"), dest);
         };
 
-        // Non-deterministically decide to further reduce the count, simulating a partial write (but
-        // never to 0, that has different behavior).
+        // Handle the zero-sized case. The man page says:
+        // > If count is zero and fd refers to a regular file, then write() may return a failure
+        // > status if one of the errors below is detected.  If no errors are detected, or error
+        // > detection is not performed, 0 is returned without causing any other effect.   If  count
+        // > is  zero  and  fd refers to a file other than a regular file, the results are not
+        // > specified.
+        if count == 0 {
+            // For now let's not open the can of worms of what exactly "not specified" could mean...
+            this.write_null(dest)?;
+            return interp_ok(());
+        }
+        // Non-deterministically decide to further reduce the count, simulating a partial write.
+        // We avoid reducing the write size to 0: the docs seem to be entirely fine with that,
+        // but the standard library is not (https://github.com/rust-lang/rust/issues/145959).
         let count =
             if fd.nondet_short_accesses() && count >= 2 && this.machine.rng.get_mut().random() {
                 count / 2
diff --git a/src/tools/miri/tests/pass/shims/fs.rs b/src/tools/miri/tests/pass/shims/fs.rs
index e7f11c54704d4..022dcc5dcbafa 100644
--- a/src/tools/miri/tests/pass/shims/fs.rs
+++ b/src/tools/miri/tests/pass/shims/fs.rs
@@ -72,7 +72,9 @@ fn test_file() {
 
     // Writing to a file opened for reading should error (and not stop interpretation). std does not
     // categorize the error so we don't check for details.
-    file.write(&[]).unwrap_err();
+    file.write(&[0]).unwrap_err();
+    // However, writing 0 bytes can succeed or fail.
+    let _ignore = file.write(&[]);
 
     // Removing file should succeed.
     remove_file(&path).unwrap();
diff --git a/src/tools/miri/tests/utils/libc.rs b/src/tools/miri/tests/utils/libc.rs
index 1a3cd067c04bf..4757a5a268c65 100644
--- a/src/tools/miri/tests/utils/libc.rs
+++ b/src/tools/miri/tests/utils/libc.rs
@@ -34,10 +34,7 @@ pub unsafe fn write_all(
         if res < 0 {
             return res;
         }
-        if res == 0 {
-            // EOF?
-            break;
-        }
+        // Apparently a return value of 0 is just a short write, nothing special (unlike reads).
         written_so_far += res as libc::size_t;
     }
     return written_so_far as libc::ssize_t;

From 05f62e0210ad9debd64f244b1edc18ed9285664b Mon Sep 17 00:00:00 2001
From: relaxcn <irelaxcn@outlook.com>
Date: Thu, 14 Aug 2025 21:54:56 +0800
Subject: [PATCH 0336/1889] Fix false positive of `needless_range_loop` when
 meeting multidimensional array

---
 clippy_lints/src/loops/needless_range_loop.rs | 33 ++++++++++++++++---
 tests/ui/needless_range_loop.rs               | 32 ++++++++++++++++++
 tests/ui/needless_range_loop.stderr           | 26 ++++++++++++++-
 3 files changed, 86 insertions(+), 5 deletions(-)

diff --git a/clippy_lints/src/loops/needless_range_loop.rs b/clippy_lints/src/loops/needless_range_loop.rs
index 7bb684d65bb42..11edb929d70b2 100644
--- a/clippy_lints/src/loops/needless_range_loop.rs
+++ b/clippy_lints/src/loops/needless_range_loop.rs
@@ -3,7 +3,7 @@ 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::{SpanlessEq, contains_name, higher, is_integer_const, sugg};
+use clippy_utils::{SpanlessEq, contains_name, higher, is_integer_const, peel_hir_expr_while, sugg};
 use rustc_ast::ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
 use rustc_errors::Applicability;
@@ -253,12 +253,38 @@ struct VarVisitor<'a, 'tcx> {
 
 impl<'tcx> VarVisitor<'_, 'tcx> {
     fn check(&mut self, idx: &'tcx Expr<'_>, seqexpr: &'tcx Expr<'_>, expr: &'tcx Expr<'_>) -> bool {
-        let index_used_directly = matches!(idx.kind, ExprKind::Path(_));
+        let mut used_cnt = 0;
+        // It is `true` if all indices are direct
+        let mut index_used_directly = true;
+
+        // Handle initial index
+        if is_local_used(self.cx, idx, self.var) {
+            used_cnt += 1;
+            index_used_directly &= matches!(idx.kind, ExprKind::Path(_));
+        }
+        // Handle nested indices
+        let seqexpr = peel_hir_expr_while(seqexpr, |e| {
+            if let ExprKind::Index(e, idx, _) = e.kind {
+                if is_local_used(self.cx, idx, self.var) {
+                    used_cnt += 1;
+                    index_used_directly &= matches!(idx.kind, ExprKind::Path(_));
+                }
+                Some(e)
+            } else {
+                None
+            }
+        });
+
+        match used_cnt {
+            0 => return true,
+            n if n > 1 => self.nonindex = true, // Optimize code like `a[i][i]`
+            _ => {},
+        }
+
         if let ExprKind::Path(ref seqpath) = seqexpr.kind
             // the indexed container is referenced by a name
             && let QPath::Resolved(None, seqvar) = *seqpath
             && seqvar.segments.len() == 1
-            && is_local_used(self.cx, idx, self.var)
         {
             if self.prefer_mutable {
                 self.indexed_mut.insert(seqvar.segments[0].ident.name);
@@ -312,7 +338,6 @@ impl<'tcx> VarVisitor<'_, 'tcx> {
 impl<'tcx> Visitor<'tcx> for VarVisitor<'_, 'tcx> {
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
         if let ExprKind::MethodCall(meth, args_0, [args_1, ..], _) = &expr.kind
-            // a range index op
             && let Some(trait_id) = self
                 .cx
                 .typeck_results()
diff --git a/tests/ui/needless_range_loop.rs b/tests/ui/needless_range_loop.rs
index 70cf9fa7369ff..ea4591d8b71ac 100644
--- a/tests/ui/needless_range_loop.rs
+++ b/tests/ui/needless_range_loop.rs
@@ -210,3 +210,35 @@ fn needless_loop() {
         black_box([1, 2, 3, 4, 5, 6, 7, 8][i]);
     }
 }
+
+fn issue_15068() {
+    let a = vec![vec![0u8; MAX_LEN]; MAX_LEN];
+    let b = vec![0u8; MAX_LEN];
+
+    for i in 0..MAX_LEN {
+        // no error
+        let _ = a[0][i];
+        let _ = b[i];
+    }
+
+    for i in 0..MAX_LEN {
+        // no error
+        let _ = a[i][0];
+        let _ = b[i];
+    }
+
+    for i in 0..MAX_LEN {
+        // no error
+        let _ = a[i][b[i] as usize];
+    }
+
+    for i in 0..MAX_LEN {
+        //~^ needless_range_loop
+        let _ = a[i][i];
+    }
+
+    for i in 0..MAX_LEN {
+        //~^ needless_range_loop
+        let _ = a[0][i];
+    }
+}
diff --git a/tests/ui/needless_range_loop.stderr b/tests/ui/needless_range_loop.stderr
index 23c085f9d3b21..33a519d8a80d5 100644
--- a/tests/ui/needless_range_loop.stderr
+++ b/tests/ui/needless_range_loop.stderr
@@ -168,5 +168,29 @@ LL -     for i in 0..vec.len() {
 LL +     for (i, <item>) in vec.iter_mut().enumerate() {
    |
 
-error: aborting due to 14 previous errors
+error: the loop variable `i` is used to index `a`
+  --> tests/ui/needless_range_loop.rs:235:14
+   |
+LL |     for i in 0..MAX_LEN {
+   |              ^^^^^^^^^^
+   |
+help: consider using an iterator and enumerate()
+   |
+LL -     for i in 0..MAX_LEN {
+LL +     for (i, <item>) in a.iter().enumerate().take(MAX_LEN) {
+   |
+
+error: the loop variable `i` is only used to index `a`
+  --> tests/ui/needless_range_loop.rs:240:14
+   |
+LL |     for i in 0..MAX_LEN {
+   |              ^^^^^^^^^^
+   |
+help: consider using an iterator
+   |
+LL -     for i in 0..MAX_LEN {
+LL +     for <item> in a.iter().take(MAX_LEN) {
+   |
+
+error: aborting due to 16 previous errors
 

From 8930d3a7504a7bda441782c65a9d6320e7674ba3 Mon Sep 17 00:00:00 2001
From: Vadim Petrochenkov <vadim.petrochenkov@gmail.com>
Date: Thu, 28 Aug 2025 16:52:14 +0300
Subject: [PATCH 0337/1889] resolve: Avoid a regression from splitting prelude
 into two scopes

---
 compiler/rustc_resolve/src/ident.rs           | 23 ++++++++++++++++---
 .../imports/overwritten-extern-flag-ambig.rs  | 13 +++++++++++
 2 files changed, 33 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/imports/overwritten-extern-flag-ambig.rs

diff --git a/compiler/rustc_resolve/src/ident.rs b/compiler/rustc_resolve/src/ident.rs
index dae42645becdd..bc06a22757113 100644
--- a/compiler/rustc_resolve/src/ident.rs
+++ b/compiler/rustc_resolve/src/ident.rs
@@ -422,6 +422,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         // to detect potential ambiguities.
         let mut innermost_result: Option<(NameBinding<'_>, Flags)> = None;
         let mut determinacy = Determinacy::Determined;
+        let mut extern_prelude_item_binding = None;
+        let mut extern_prelude_flag_binding = None;
         // Shadowed bindings don't need to be marked as used or non-speculatively loaded.
         macro finalize_scope() {
             if innermost_result.is_none() { finalize } else { None }
@@ -558,7 +560,10 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     Scope::ExternPreludeItems => {
                         // FIXME: use `finalize_scope` here.
                         match this.reborrow().extern_prelude_get_item(ident, finalize.is_some()) {
-                            Some(binding) => Ok((binding, Flags::empty())),
+                            Some(binding) => {
+                                extern_prelude_item_binding = Some(binding);
+                                Ok((binding, Flags::empty()))
+                            }
                             None => Err(Determinacy::determined(
                                 this.graph_root.unexpanded_invocations.borrow().is_empty(),
                             )),
@@ -566,7 +571,10 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     }
                     Scope::ExternPreludeFlags => {
                         match this.extern_prelude_get_flag(ident, finalize_scope!().is_some()) {
-                            Some(binding) => Ok((binding, Flags::empty())),
+                            Some(binding) => {
+                                extern_prelude_flag_binding = Some(binding);
+                                Ok((binding, Flags::empty()))
+                            }
                             None => Err(Determinacy::Determined),
                         }
                     }
@@ -686,7 +694,16 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                                 } else {
                                     None
                                 };
-                                if let Some(kind) = ambiguity_error_kind {
+                                // Skip ambiguity errors for extern flag bindings "overridden"
+                                // by extern item bindings.
+                                // FIXME: Remove with lang team approval.
+                                let issue_145575_hack = Some(binding)
+                                    == extern_prelude_flag_binding
+                                    && extern_prelude_item_binding.is_some()
+                                    && extern_prelude_item_binding != Some(innermost_binding);
+                                if let Some(kind) = ambiguity_error_kind
+                                    && !issue_145575_hack
+                                {
                                     let misc = |f: Flags| {
                                         if f.contains(Flags::MISC_SUGGEST_CRATE) {
                                             AmbiguityErrorMisc::SuggestCrate
diff --git a/tests/ui/imports/overwritten-extern-flag-ambig.rs b/tests/ui/imports/overwritten-extern-flag-ambig.rs
new file mode 100644
index 0000000000000..80f394d34de02
--- /dev/null
+++ b/tests/ui/imports/overwritten-extern-flag-ambig.rs
@@ -0,0 +1,13 @@
+// Test for issue #145575.
+
+//@ check-pass
+//@ edition: 2018
+
+extern crate core as std;
+
+mod inner {
+    use crate::*;
+    use std::str; // OK for now
+}
+
+fn main() {}

From b0897f31b998472d024a2e00a7b00c5fc875351e Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Fri, 29 Aug 2025 15:06:54 +0000
Subject: [PATCH 0338/1889] Update getopts to remove unicode-width dependency

---
 Cargo.lock                 |  6 +++---
 library/Cargo.lock         | 15 ++-------------
 library/test/Cargo.toml    |  2 +-
 src/tools/tidy/src/deps.rs |  1 -
 4 files changed, 6 insertions(+), 18 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 91528a4135e32..82ba9ce178aad 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -674,7 +674,7 @@ checksum = "fe6d2e5af09e8c8ad56c969f2157a3d4238cebc7c55f0a517728c38f7b200f81"
 dependencies = [
  "serde",
  "termcolor",
- "unicode-width 0.2.1",
+ "unicode-width 0.1.14",
 ]
 
 [[package]]
@@ -1470,9 +1470,9 @@ dependencies = [
 
 [[package]]
 name = "getopts"
-version = "0.2.23"
+version = "0.2.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cba6ae63eb948698e300f645f87c70f76630d505f23b8907cf1e193ee85048c1"
+checksum = "cfe4fbac503b8d1f88e6676011885f34b7174f46e59956bba534ba83abded4df"
 dependencies = [
  "unicode-width 0.2.1",
 ]
diff --git a/library/Cargo.lock b/library/Cargo.lock
index f0ac9d259c0db..3fb6af2c59821 100644
--- a/library/Cargo.lock
+++ b/library/Cargo.lock
@@ -99,13 +99,12 @@ dependencies = [
 
 [[package]]
 name = "getopts"
-version = "0.2.23"
+version = "0.2.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cba6ae63eb948698e300f645f87c70f76630d505f23b8907cf1e193ee85048c1"
+checksum = "cfe4fbac503b8d1f88e6676011885f34b7174f46e59956bba534ba83abded4df"
 dependencies = [
  "rustc-std-workspace-core",
  "rustc-std-workspace-std",
- "unicode-width",
 ]
 
 [[package]]
@@ -360,16 +359,6 @@ dependencies = [
  "std",
 ]
 
-[[package]]
-name = "unicode-width"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a1a07cc7db3810833284e8d372ccdc6da29741639ecc70c9ec107df0fa6154c"
-dependencies = [
- "rustc-std-workspace-core",
- "rustc-std-workspace-std",
-]
-
 [[package]]
 name = "unwind"
 version = "0.0.0"
diff --git a/library/test/Cargo.toml b/library/test/Cargo.toml
index 2a32a7dd76eed..fe749847b7c00 100644
--- a/library/test/Cargo.toml
+++ b/library/test/Cargo.toml
@@ -6,7 +6,7 @@ version = "0.0.0"
 edition = "2024"
 
 [dependencies]
-getopts = { version = "0.2.21", features = ['rustc-dep-of-std'] }
+getopts = { version = "0.2.24", default-features = false, features = ['rustc-dep-of-std'] }
 std = { path = "../std", public = true }
 core = { path = "../core", public = true }
 
diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs
index 80b6d54ce1c80..4efaf1fb77167 100644
--- a/src/tools/tidy/src/deps.rs
+++ b/src/tools/tidy/src/deps.rs
@@ -478,7 +478,6 @@ const PERMITTED_STDLIB_DEPENDENCIES: &[&str] = &[
     "rustc-demangle",
     "rustc-literal-escaper",
     "shlex",
-    "unicode-width",
     "unwinding",
     "wasi",
     "windows-sys",

From 80c1ea31c75199e8f94d5da0f485f065f0729a79 Mon Sep 17 00:00:00 2001
From: Eric Huss <eric@huss.org>
Date: Fri, 29 Aug 2025 09:33:25 -0700
Subject: [PATCH 0339/1889] Update mdbook

This updates mdbook to 0.4.52, which includes a number of fixes and
enhancements since 0.4.48.

Changelog: https://github.com/rust-lang/mdBook/blob/master/CHANGELOG.md#mdbook-0452
---
 src/doc/rustc-dev-guide/.github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/.github/workflows/ci.yml b/src/doc/rustc-dev-guide/.github/workflows/ci.yml
index 6eabb999fb013..2dd695b7a4733 100644
--- a/src/doc/rustc-dev-guide/.github/workflows/ci.yml
+++ b/src/doc/rustc-dev-guide/.github/workflows/ci.yml
@@ -14,7 +14,7 @@ jobs:
     if: github.repository == 'rust-lang/rustc-dev-guide'
     runs-on: ubuntu-latest
     env:
-      MDBOOK_VERSION: 0.4.48
+      MDBOOK_VERSION: 0.4.52
       MDBOOK_LINKCHECK2_VERSION: 0.9.1
       MDBOOK_MERMAID_VERSION: 0.12.6
       MDBOOK_OUTPUT__LINKCHECK__FOLLOW_WEB_LINKS: ${{ github.event_name != 'pull_request' }}

From 497df6006d55b3440220eed50ddccc054b431770 Mon Sep 17 00:00:00 2001
From: Rune Tynan <runetynan@gmail.com>
Date: Mon, 2 Jun 2025 11:02:00 -0700
Subject: [PATCH 0340/1889] Add duplicate handle test + make null
 lpTargetHandle an abort, not an unsupported.

---
 src/tools/miri/src/shims/windows/handle.rs    |  8 ++--
 .../miri/tests/pass-dep/shims/windows-fs.rs   | 47 ++++++++++++++++---
 2 files changed, 46 insertions(+), 9 deletions(-)

diff --git a/src/tools/miri/src/shims/windows/handle.rs b/src/tools/miri/src/shims/windows/handle.rs
index 1e30bf25ed92e..2ef328f7adddf 100644
--- a/src/tools/miri/src/shims/windows/handle.rs
+++ b/src/tools/miri/src/shims/windows/handle.rs
@@ -285,9 +285,11 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         }
 
         if this.ptr_is_null(target_handle_ptr)? {
-            throw_unsup_format!(
-                "`DuplicateHandle` `lpTargetHandle` parameter is null, which is unsupported"
-            );
+            throw_machine_stop!(TerminationInfo::Abort(
+                "`DuplicateHandle` `lpTargetHandle` parameter must not be null, as otherwise the \
+                newly created handle is leaked"
+                    .to_string()
+            ));
         }
 
         if options != this.eval_windows("c", "DUPLICATE_SAME_ACCESS") {
diff --git a/src/tools/miri/tests/pass-dep/shims/windows-fs.rs b/src/tools/miri/tests/pass-dep/shims/windows-fs.rs
index 4ca19046b676b..7b756603d929b 100644
--- a/src/tools/miri/tests/pass-dep/shims/windows-fs.rs
+++ b/src/tools/miri/tests/pass-dep/shims/windows-fs.rs
@@ -2,20 +2,20 @@
 //@compile-flags: -Zmiri-disable-isolation
 #![allow(nonstandard_style)]
 
-use std::io::{ErrorKind, Read, Write};
+use std::io::{ErrorKind, Read, Seek, SeekFrom, Write};
 use std::os::windows::ffi::OsStrExt;
-use std::os::windows::io::AsRawHandle;
+use std::os::windows::io::{AsRawHandle, FromRawHandle};
 use std::path::Path;
-use std::{fs, ptr};
+use std::{fs, mem, ptr};
 
 #[path = "../../utils/mod.rs"]
 mod utils;
 
 use windows_sys::Wdk::Storage::FileSystem::{NtReadFile, NtWriteFile};
 use windows_sys::Win32::Foundation::{
-    CloseHandle, ERROR_ACCESS_DENIED, ERROR_ALREADY_EXISTS, ERROR_IO_DEVICE, GENERIC_READ,
-    GENERIC_WRITE, GetLastError, RtlNtStatusToDosError, STATUS_ACCESS_DENIED,
-    STATUS_IO_DEVICE_ERROR, STATUS_SUCCESS, SetLastError,
+    CloseHandle, DUPLICATE_SAME_ACCESS, DuplicateHandle, ERROR_ACCESS_DENIED, ERROR_ALREADY_EXISTS,
+    ERROR_IO_DEVICE, FALSE, GENERIC_READ, GENERIC_WRITE, GetLastError, RtlNtStatusToDosError,
+    STATUS_ACCESS_DENIED, STATUS_IO_DEVICE_ERROR, STATUS_SUCCESS, SetLastError,
 };
 use windows_sys::Win32::Storage::FileSystem::{
     BY_HANDLE_FILE_INFORMATION, CREATE_ALWAYS, CREATE_NEW, CreateFileW, DeleteFileW,
@@ -24,6 +24,7 @@ use windows_sys::Win32::Storage::FileSystem::{
     FILE_SHARE_WRITE, GetFileInformationByHandle, OPEN_ALWAYS, OPEN_EXISTING, SetFilePointerEx,
 };
 use windows_sys::Win32::System::IO::IO_STATUS_BLOCK;
+use windows_sys::Win32::System::Threading::GetCurrentProcess;
 
 fn main() {
     unsafe {
@@ -36,6 +37,7 @@ fn main() {
         test_ntstatus_to_dos();
         test_file_read_write();
         test_file_seek();
+        test_dup_handle();
     }
 }
 
@@ -273,6 +275,39 @@ unsafe fn test_file_read_write() {
     assert_eq!(GetLastError(), 1234);
 }
 
+unsafe fn test_dup_handle() {
+    let temp = utils::tmp().join("test_dup.txt");
+
+    let mut file1 = fs::File::options().read(true).write(true).create(true).open(&temp).unwrap();
+
+    file1.write_all(b"Hello, World!\n").unwrap();
+    file1.seek(SeekFrom::Start(0)).unwrap();
+
+    let first_handle = file1.as_raw_handle();
+
+    let cur_proc = GetCurrentProcess();
+    let mut second_handle = mem::zeroed();
+    let res = DuplicateHandle(
+        cur_proc,
+        first_handle,
+        cur_proc,
+        &mut second_handle,
+        0,
+        FALSE,
+        DUPLICATE_SAME_ACCESS,
+    );
+    assert!(res != 0);
+
+    let mut buf1 = [0; 5];
+    file1.read(&mut buf1).unwrap();
+    assert_eq!(&buf1, b"Hello");
+
+    let mut file2 = fs::File::from_raw_handle(second_handle);
+    let mut buf2 = [0; 5];
+    file2.read(&mut buf2).unwrap();
+    assert_eq!(&buf2, b", Wor");
+}
+
 unsafe fn test_file_seek() {
     let temp = utils::tmp().join("test_file_seek.txt");
     let mut file = fs::File::options().create(true).write(true).read(true).open(&temp).unwrap();

From bd0ea615f73e433c43457374e76a16793b73bc9c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Fri, 29 Aug 2025 20:39:36 +0000
Subject: [PATCH 0341/1889] Add test for typo in or-pattern binding

---
 tests/ui/or-patterns/binding-typo.fixed  | 26 ++++++++++++++++++++
 tests/ui/or-patterns/binding-typo.rs     | 26 ++++++++++++++++++++
 tests/ui/or-patterns/binding-typo.stderr | 30 ++++++++++++++++++++++++
 3 files changed, 82 insertions(+)
 create mode 100644 tests/ui/or-patterns/binding-typo.fixed
 create mode 100644 tests/ui/or-patterns/binding-typo.rs
 create mode 100644 tests/ui/or-patterns/binding-typo.stderr

diff --git a/tests/ui/or-patterns/binding-typo.fixed b/tests/ui/or-patterns/binding-typo.fixed
new file mode 100644
index 0000000000000..84637862484a0
--- /dev/null
+++ b/tests/ui/or-patterns/binding-typo.fixed
@@ -0,0 +1,26 @@
+// Issue #51976
+//@ run-rustfix
+#![deny(unused_variables)] //~ NOTE: the lint level is defined here
+enum Lol {
+    Foo,
+    Bar,
+}
+
+fn foo(x: (Lol, Lol)) {
+    use Lol::*;
+    match x {
+        (Foo, Bar) | (Bar, Foo) => {}
+        //~^ ERROR: variable `Ban` is not bound in all patterns
+        //~| HELP: you might have meant to use the similarly named previously used binding `Bar`
+        //~| NOTE: pattern doesn't bind `Ban`
+        //~| NOTE: variable not in all patterns
+        //~| ERROR: variable `Ban` is assigned to, but never used
+        //~| NOTE: consider using `_Ban` instead
+        _ => {}
+    }
+}
+
+fn main() {
+    use Lol::*;
+    foo((Foo, Bar));
+}
diff --git a/tests/ui/or-patterns/binding-typo.rs b/tests/ui/or-patterns/binding-typo.rs
new file mode 100644
index 0000000000000..1c5f4d876190b
--- /dev/null
+++ b/tests/ui/or-patterns/binding-typo.rs
@@ -0,0 +1,26 @@
+// Issue #51976
+//@ run-rustfix
+#![deny(unused_variables)] //~ NOTE: the lint level is defined here
+enum Lol {
+    Foo,
+    Bar,
+}
+
+fn foo(x: (Lol, Lol)) {
+    use Lol::*;
+    match x {
+        (Foo, Bar) | (Ban, Foo) => {}
+        //~^ ERROR: variable `Ban` is not bound in all patterns
+        //~| HELP: you might have meant to use the similarly named previously used binding `Bar`
+        //~| NOTE: pattern doesn't bind `Ban`
+        //~| NOTE: variable not in all patterns
+        //~| ERROR: variable `Ban` is assigned to, but never used
+        //~| NOTE: consider using `_Ban` instead
+        _ => {}
+    }
+}
+
+fn main() {
+    use Lol::*;
+    foo((Foo, Bar));
+}
diff --git a/tests/ui/or-patterns/binding-typo.stderr b/tests/ui/or-patterns/binding-typo.stderr
new file mode 100644
index 0000000000000..31a409bbc5c22
--- /dev/null
+++ b/tests/ui/or-patterns/binding-typo.stderr
@@ -0,0 +1,30 @@
+error[E0408]: variable `Ban` is not bound in all patterns
+  --> $DIR/binding-typo.rs:12:9
+   |
+LL |         (Foo, Bar) | (Ban, Foo) => {}
+   |         ^^^^^^^^^^    --- variable not in all patterns
+   |         |
+   |         pattern doesn't bind `Ban`
+   |
+help: you might have meant to use the similarly named previously used binding `Bar`
+   |
+LL -         (Foo, Bar) | (Ban, Foo) => {}
+LL +         (Foo, Bar) | (Bar, Foo) => {}
+   |
+
+error: variable `Ban` is assigned to, but never used
+  --> $DIR/binding-typo.rs:12:23
+   |
+LL |         (Foo, Bar) | (Ban, Foo) => {}
+   |                       ^^^
+   |
+   = note: consider using `_Ban` instead
+note: the lint level is defined here
+  --> $DIR/binding-typo.rs:3:9
+   |
+LL | #![deny(unused_variables)]
+   |         ^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0408`.

From d396d2f79753b7db793a940d8da3ea74d82077d6 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 29 Aug 2025 20:55:43 +0000
Subject: [PATCH 0342/1889] Bump tracing-subscriber from 0.3.19 to 0.3.20

Bumps [tracing-subscriber](https://github.com/tokio-rs/tracing) from 0.3.19 to 0.3.20.
- [Release notes](https://github.com/tokio-rs/tracing/releases)
- [Commits](https://github.com/tokio-rs/tracing/compare/tracing-subscriber-0.3.19...tracing-subscriber-0.3.20)

---
updated-dependencies:
- dependency-name: tracing-subscriber
  dependency-version: 0.3.20
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 src/tools/rust-analyzer/Cargo.lock | 4 ++--
 src/tools/rust-analyzer/Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/tools/rust-analyzer/Cargo.lock b/src/tools/rust-analyzer/Cargo.lock
index f72e698f60631..b008aa1c50f88 100644
--- a/src/tools/rust-analyzer/Cargo.lock
+++ b/src/tools/rust-analyzer/Cargo.lock
@@ -2738,9 +2738,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-subscriber"
-version = "0.3.19"
+version = "0.3.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8189decb5ac0fa7bc8b96b7cb9b2701d60d48805aca84a238004d665fcc4008"
+checksum = "2054a14f5307d601f88daf0553e1cbf472acc4f2c51afab632431cdcd72124d5"
 dependencies = [
  "sharded-slab",
  "thread_local",
diff --git a/src/tools/rust-analyzer/Cargo.toml b/src/tools/rust-analyzer/Cargo.toml
index bb8444ed73422..05ee190480c97 100644
--- a/src/tools/rust-analyzer/Cargo.toml
+++ b/src/tools/rust-analyzer/Cargo.toml
@@ -163,7 +163,7 @@ temp-dir = "0.1.16"
 text-size = "1.1.1"
 tracing = "0.1.41"
 tracing-tree = "0.4.0"
-tracing-subscriber = { version = "0.3.19", default-features = false, features = [
+tracing-subscriber = { version = "0.3.20", default-features = false, features = [
     "registry",
     "fmt",
     "local-time",

From 615450e1ac5b9cbae08e211bc01ca0068648c5ef Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 29 Aug 2025 20:57:03 +0000
Subject: [PATCH 0343/1889] Bump tracing-subscriber from 0.3.19 to 0.3.20

Bumps [tracing-subscriber](https://github.com/tokio-rs/tracing) from 0.3.19 to 0.3.20.
- [Release notes](https://github.com/tokio-rs/tracing/releases)
- [Commits](https://github.com/tokio-rs/tracing/compare/tracing-subscriber-0.3.19...tracing-subscriber-0.3.20)

---
updated-dependencies:
- dependency-name: tracing-subscriber
  dependency-version: 0.3.20
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 src/tools/miri/Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/tools/miri/Cargo.lock b/src/tools/miri/Cargo.lock
index b46f0f8342093..4df17c83c7e48 100644
--- a/src/tools/miri/Cargo.lock
+++ b/src/tools/miri/Cargo.lock
@@ -1569,9 +1569,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-subscriber"
-version = "0.3.19"
+version = "0.3.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8189decb5ac0fa7bc8b96b7cb9b2701d60d48805aca84a238004d665fcc4008"
+checksum = "2054a14f5307d601f88daf0553e1cbf472acc4f2c51afab632431cdcd72124d5"
 dependencies = [
  "sharded-slab",
  "thread_local",

From cb9cd8f8306e6e1b16661704aed8d6f09aa5db73 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sat, 30 Aug 2025 01:44:40 +0000
Subject: [PATCH 0344/1889] On binding not present in all patterns, look at
 consts and unit structs/variants for suggestions

When encountering an or-pattern with a binding not available in all patterns, look for consts and unit struct/variants that have similar names as the binding to detect typos.

```
error[E0408]: variable `Ban` is not bound in all patterns
  --> $DIR/binding-typo.rs:22:9
   |
LL |         (Foo, _) | (Ban, Foo) => {}
   |         ^^^^^^^^    --- variable not in all patterns
   |         |
   |         pattern doesn't bind `Ban`
   |
help: you might have meant to use the similarly named unit variant `Bar`
   |
LL -         (Foo, _) | (Ban, Foo) => {}
LL +         (Foo, _) | (Bar, Foo) => {}
   |
```

For items that are not in the immedate scope, suggest the full path for them:

```
error[E0408]: variable `Non` is not bound in all patterns
  --> $DIR/binding-typo-2.rs:51:16
   |
LL |         (Non | Some(_))=> {}
   |          ---   ^^^^^^^ pattern doesn't bind `Non`
   |          |
   |          variable not in all patterns
   |
help: you might have meant to use the similarly named unit variant `None`
   |
LL -         (Non | Some(_))=> {}
LL +         (core::option::Option::None | Some(_))=> {}
   |
```
---
 compiler/rustc_resolve/src/diagnostics.rs  | 113 ++++++++++++++++++++-
 tests/ui/or-patterns/binding-typo-2.rs     |  98 ++++++++++++++++++
 tests/ui/or-patterns/binding-typo-2.stderr | 107 +++++++++++++++++++
 tests/ui/or-patterns/binding-typo.fixed    |  12 ++-
 tests/ui/or-patterns/binding-typo.rs       |  12 ++-
 tests/ui/or-patterns/binding-typo.stderr   |  24 ++++-
 6 files changed, 361 insertions(+), 5 deletions(-)
 create mode 100644 tests/ui/or-patterns/binding-typo-2.rs
 create mode 100644 tests/ui/or-patterns/binding-typo-2.stderr

diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index 324310ff48b1d..beb882a325f5a 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -718,10 +718,86 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         },
                     );
 
+                    if import_suggestions.is_empty() && !suggested_typo {
+                        let kinds = [
+                            DefKind::Ctor(CtorOf::Variant, CtorKind::Const),
+                            DefKind::Ctor(CtorOf::Struct, CtorKind::Const),
+                            DefKind::Const,
+                            DefKind::AssocConst,
+                        ];
+                        let mut local_names = vec![];
+                        self.add_module_candidates(
+                            parent_scope.module,
+                            &mut local_names,
+                            &|res| matches!(res, Res::Def(_, _)),
+                            None,
+                        );
+                        let local_names: FxHashSet<_> = local_names
+                            .into_iter()
+                            .filter_map(|s| match s.res {
+                                Res::Def(_, def_id) => Some(def_id),
+                                _ => None,
+                            })
+                            .collect();
+
+                        let mut local_suggestions = vec![];
+                        let mut suggestions = vec![];
+                        for kind in kinds {
+                            if let Some(suggestion) = self.early_lookup_typo_candidate(
+                                ScopeSet::All(Namespace::ValueNS),
+                                &parent_scope,
+                                name,
+                                &|res: Res| match res {
+                                    Res::Def(k, _) => k == kind,
+                                    _ => false,
+                                },
+                            ) && let Res::Def(kind, mut def_id) = suggestion.res
+                            {
+                                if let DefKind::Ctor(_, _) = kind {
+                                    def_id = self.tcx.parent(def_id);
+                                }
+                                let kind = kind.descr(def_id);
+                                if local_names.contains(&def_id) {
+                                    // The item is available in the current scope. Very likely to
+                                    // be a typo. Don't use the full path.
+                                    local_suggestions.push((
+                                        suggestion.candidate,
+                                        suggestion.candidate.to_string(),
+                                        kind,
+                                    ));
+                                } else {
+                                    suggestions.push((
+                                        suggestion.candidate,
+                                        self.def_path_str(def_id),
+                                        kind,
+                                    ));
+                                }
+                            }
+                        }
+                        let suggestions = if !local_suggestions.is_empty() {
+                            // There is at least one item available in the current scope that is a
+                            // likely typo. We only show those.
+                            local_suggestions
+                        } else {
+                            suggestions
+                        };
+                        for (name, sugg, kind) in suggestions {
+                            err.span_suggestion_verbose(
+                                span,
+                                format!(
+                                    "you might have meant to use the similarly named {kind} `{name}`",
+                                ),
+                                sugg,
+                                Applicability::MaybeIncorrect,
+                            );
+                            suggested_typo = true;
+                        }
+                    }
                     if import_suggestions.is_empty() && !suggested_typo {
                         let help_msg = format!(
-                            "if you meant to match on a variant or a `const` item, consider \
-                             making the path in the pattern qualified: `path::to::ModOrType::{name}`",
+                            "if you meant to match on a unit struct, unit variant or a `const` \
+                             item, consider making the path in the pattern qualified: \
+                             `path::to::ModOrType::{name}`",
                         );
                         err.span_help(span, help_msg);
                     }
@@ -1041,6 +1117,39 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         .emit()
     }
 
+    fn def_path_str(&self, mut def_id: DefId) -> String {
+        // We can't use `def_path_str` in resolve.
+        let mut path = vec![def_id];
+        while let Some(parent) = self.tcx.opt_parent(def_id) {
+            def_id = parent;
+            path.push(def_id);
+            if def_id.is_top_level_module() {
+                break;
+            }
+        }
+        // We will only suggest importing directly if it is accessible through that path.
+        path.into_iter()
+            .rev()
+            .map(|def_id| {
+                self.tcx
+                    .opt_item_name(def_id)
+                    .map(|name| {
+                        match (
+                            def_id.is_top_level_module(),
+                            def_id.is_local(),
+                            self.tcx.sess.edition(),
+                        ) {
+                            (true, true, Edition::Edition2015) => String::new(),
+                            (true, true, _) => kw::Crate.to_string(),
+                            (true, false, _) | (false, _, _) => name.to_string(),
+                        }
+                    })
+                    .unwrap_or_else(|| "_".to_string())
+            })
+            .collect::<Vec<String>>()
+            .join("::")
+    }
+
     pub(crate) fn add_scope_set_candidates(
         &mut self,
         suggestions: &mut Vec<TypoSuggestion>,
diff --git a/tests/ui/or-patterns/binding-typo-2.rs b/tests/ui/or-patterns/binding-typo-2.rs
new file mode 100644
index 0000000000000..4dfb84d4f0cd3
--- /dev/null
+++ b/tests/ui/or-patterns/binding-typo-2.rs
@@ -0,0 +1,98 @@
+// Issue #51976
+#![deny(unused_variables)] //~ NOTE: the lint level is defined here
+enum Lol {
+    Foo,
+    Bar,
+}
+const Bat: () = ();
+struct Bay;
+
+fn foo(x: (Lol, Lol)) {
+    use Lol::*;
+    match &x {
+        (Foo, Bar) | (Ban, Foo) => {}
+        //~^ ERROR: variable `Ban` is not bound in all patterns
+        //~| HELP: you might have meant to use the similarly named previously used binding `Bar`
+        //~| NOTE: pattern doesn't bind `Ban`
+        //~| NOTE: variable not in all patterns
+        //~| ERROR: variable `Ban` is assigned to, but never used
+        //~| NOTE: consider using `_Ban` instead
+        _ => {}
+    }
+    match &x {
+        (Foo, _) | (Ban, Foo) => {}
+        //~^ ERROR: variable `Ban` is not bound in all patterns
+        //~| HELP: you might have meant to use the similarly named unit variant `Bar`
+        //~| NOTE: pattern doesn't bind `Ban`
+        //~| NOTE: variable not in all patterns
+        //~| ERROR: variable `Ban` is assigned to, but never used
+        //~| NOTE: consider using `_Ban` instead
+        _ => {}
+    }
+    match Some(42) {
+        Non => {}
+        //~^ ERROR: unused variable: `Non`
+        //~| HELP: if this is intentional, prefix it with an underscore
+        _ => {}
+    }
+    match Some(42) {
+        Non | None => {}
+        //~^ ERROR: unused variable: `Non`
+        //~| HELP: if this is intentional, prefix it with an underscore
+        //~| ERROR: variable `Non` is not bound in all patterns [E0408]
+        //~| NOTE: pattern doesn't bind `Non`
+        //~| NOTE: variable not in all patterns
+        //~| HELP: you might have meant to use the similarly named previously used binding `None`
+        _ => {}
+    }
+    match Some(42) {
+        Non | Some(_) => {}
+        //~^ ERROR: unused variable: `Non`
+        //~| HELP: if this is intentional, prefix it with an underscore
+        //~| ERROR: variable `Non` is not bound in all patterns [E0408]
+        //~| NOTE: pattern doesn't bind `Non`
+        //~| NOTE: variable not in all patterns
+        //~| HELP: you might have meant to use the similarly named unit variant `None`
+        _ => {}
+    }
+}
+fn bar(x: (Lol, Lol)) {
+    use Lol::*;
+    use Bat;
+    use Bay;
+    use std::option::Option::None;
+    match &x {
+        (Foo, _) | (Ban, Foo) => {}
+        //~^ ERROR: variable `Ban` is not bound in all patterns
+        //~| HELP: you might have meant to use the similarly named unit variant `Bar`
+        //~| HELP: you might have meant to use the similarly named unit struct `Bay`
+        //~| HELP: you might have meant to use the similarly named constant `Bat`
+        //~| NOTE: pattern doesn't bind `Ban`
+        //~| NOTE: variable not in all patterns
+        //~| ERROR: variable `Ban` is assigned to, but never used
+        //~| NOTE: consider using `_Ban` instead
+        _ => {}
+    }
+}
+fn baz(x: (Lol, Lol)) {
+    use Lol::*;
+    use Bat;
+    match &x {
+        (Foo, _) | (Ban, Foo) => {}
+        //~^ ERROR: variable `Ban` is not bound in all patterns
+        //~| HELP: you might have meant to use the similarly named unit variant `Bar`
+        //~| HELP: you might have meant to use the similarly named constant `Bat`
+        //~| NOTE: pattern doesn't bind `Ban`
+        //~| NOTE: variable not in all patterns
+        //~| ERROR: variable `Ban` is assigned to, but never used
+        //~| NOTE: consider using `_Ban` instead
+        _ => {}
+    }
+}
+
+fn main() {
+    use Lol::*;
+    foo((Foo, Bar));
+    bar((Foo, Bar));
+    baz((Foo, Bar));
+}
diff --git a/tests/ui/or-patterns/binding-typo-2.stderr b/tests/ui/or-patterns/binding-typo-2.stderr
new file mode 100644
index 0000000000000..a2099572485b7
--- /dev/null
+++ b/tests/ui/or-patterns/binding-typo-2.stderr
@@ -0,0 +1,107 @@
+error[E0408]: variable `Ban` is not bound in all patterns
+  --> $DIR/binding-typo-2.rs:13:9
+   |
+LL |         (Foo, Bar) | (Ban, Foo) => {}
+   |         ^^^^^^^^^^    --- variable not in all patterns
+   |         |
+   |         pattern doesn't bind `Ban`
+   |
+help: you might have meant to use the similarly named previously used binding `Bar`
+   |
+LL -         (Foo, Bar) | (Ban, Foo) => {}
+LL +         (Foo, Bar) | (Bar, Foo) => {}
+   |
+
+error[E0408]: variable `Ban` is not bound in all patterns
+  --> $DIR/binding-typo-2.rs:23:9
+   |
+LL |         (Foo, _) | (Ban, Foo) => {}
+   |         ^^^^^^^^    --- variable not in all patterns
+   |         |
+   |         pattern doesn't bind `Ban`
+   |
+help: you might have meant to use the similarly named unit variant `Bar`
+   |
+LL -         (Foo, _) | (Ban, Foo) => {}
+LL +         (Foo, _) | (Bar, Foo) => {}
+   |
+help: you might have meant to use the similarly named unit struct `Bay`
+   |
+LL -         (Foo, _) | (Ban, Foo) => {}
+LL +         (Foo, _) | (::Bay, Foo) => {}
+   |
+help: you might have meant to use the similarly named constant `Bat`
+   |
+LL -         (Foo, _) | (Ban, Foo) => {}
+LL +         (Foo, _) | (::Bat, Foo) => {}
+   |
+
+error[E0408]: variable `Non` is not bound in all patterns
+  --> $DIR/binding-typo-2.rs:41:16
+   |
+LL |         (Non | None)=> {}
+   |          ---   ^^^^ pattern doesn't bind `Non`
+   |          |
+   |          variable not in all patterns
+   |
+help: you might have meant to use the similarly named previously used binding `None`
+   |
+LL |         (None | None)=> {}
+   |             +
+
+error[E0408]: variable `Non` is not bound in all patterns
+  --> $DIR/binding-typo-2.rs:51:16
+   |
+LL |         (Non | Some(_))=> {}
+   |          ---   ^^^^^^^ pattern doesn't bind `Non`
+   |          |
+   |          variable not in all patterns
+   |
+help: you might have meant to use the similarly named unit variant `None`
+   |
+LL -         (Non | Some(_))=> {}
+LL +         (core::option::Option::None | Some(_))=> {}
+   |
+
+error: variable `Ban` is assigned to, but never used
+  --> $DIR/binding-typo-2.rs:13:23
+   |
+LL |         (Foo, Bar) | (Ban, Foo) => {}
+   |                       ^^^
+   |
+   = note: consider using `_Ban` instead
+note: the lint level is defined here
+  --> $DIR/binding-typo-2.rs:2:9
+   |
+LL | #![deny(unused_variables)]
+   |         ^^^^^^^^^^^^^^^^
+
+error: variable `Ban` is assigned to, but never used
+  --> $DIR/binding-typo-2.rs:23:21
+   |
+LL |         (Foo, _) | (Ban, Foo) => {}
+   |                     ^^^
+   |
+   = note: consider using `_Ban` instead
+
+error: unused variable: `Non`
+  --> $DIR/binding-typo-2.rs:35:9
+   |
+LL |         Non => {}
+   |         ^^^ help: if this is intentional, prefix it with an underscore: `_Non`
+
+error: unused variable: `Non`
+  --> $DIR/binding-typo-2.rs:41:10
+   |
+LL |         (Non | None)=> {}
+   |          ^^^ help: if this is intentional, prefix it with an underscore: `_Non`
+
+error: unused variable: `Non`
+  --> $DIR/binding-typo-2.rs:51:10
+   |
+LL |         (Non | Some(_))=> {}
+   |          ^^^ help: if this is intentional, prefix it with an underscore: `_Non`
+
+error: aborting due to 9 previous errors
+
+For more information about this error, try `rustc --explain E0408`.
diff --git a/tests/ui/or-patterns/binding-typo.fixed b/tests/ui/or-patterns/binding-typo.fixed
index 84637862484a0..2902ca303931b 100644
--- a/tests/ui/or-patterns/binding-typo.fixed
+++ b/tests/ui/or-patterns/binding-typo.fixed
@@ -8,7 +8,7 @@ enum Lol {
 
 fn foo(x: (Lol, Lol)) {
     use Lol::*;
-    match x {
+    match &x {
         (Foo, Bar) | (Bar, Foo) => {}
         //~^ ERROR: variable `Ban` is not bound in all patterns
         //~| HELP: you might have meant to use the similarly named previously used binding `Bar`
@@ -18,6 +18,16 @@ fn foo(x: (Lol, Lol)) {
         //~| NOTE: consider using `_Ban` instead
         _ => {}
     }
+    match &x {
+        (Foo, _) | (Bar, Foo) => {}
+        //~^ ERROR: variable `Ban` is not bound in all patterns
+        //~| HELP: you might have meant to use the similarly named unit variant `Bar`
+        //~| NOTE: pattern doesn't bind `Ban`
+        //~| NOTE: variable not in all patterns
+        //~| ERROR: variable `Ban` is assigned to, but never used
+        //~| NOTE: consider using `_Ban` instead
+        _ => {}
+    }
 }
 
 fn main() {
diff --git a/tests/ui/or-patterns/binding-typo.rs b/tests/ui/or-patterns/binding-typo.rs
index 1c5f4d876190b..2ffe0e45c83b7 100644
--- a/tests/ui/or-patterns/binding-typo.rs
+++ b/tests/ui/or-patterns/binding-typo.rs
@@ -8,7 +8,7 @@ enum Lol {
 
 fn foo(x: (Lol, Lol)) {
     use Lol::*;
-    match x {
+    match &x {
         (Foo, Bar) | (Ban, Foo) => {}
         //~^ ERROR: variable `Ban` is not bound in all patterns
         //~| HELP: you might have meant to use the similarly named previously used binding `Bar`
@@ -18,6 +18,16 @@ fn foo(x: (Lol, Lol)) {
         //~| NOTE: consider using `_Ban` instead
         _ => {}
     }
+    match &x {
+        (Foo, _) | (Ban, Foo) => {}
+        //~^ ERROR: variable `Ban` is not bound in all patterns
+        //~| HELP: you might have meant to use the similarly named unit variant `Bar`
+        //~| NOTE: pattern doesn't bind `Ban`
+        //~| NOTE: variable not in all patterns
+        //~| ERROR: variable `Ban` is assigned to, but never used
+        //~| NOTE: consider using `_Ban` instead
+        _ => {}
+    }
 }
 
 fn main() {
diff --git a/tests/ui/or-patterns/binding-typo.stderr b/tests/ui/or-patterns/binding-typo.stderr
index 31a409bbc5c22..f90301d2ceee1 100644
--- a/tests/ui/or-patterns/binding-typo.stderr
+++ b/tests/ui/or-patterns/binding-typo.stderr
@@ -12,6 +12,20 @@ LL -         (Foo, Bar) | (Ban, Foo) => {}
 LL +         (Foo, Bar) | (Bar, Foo) => {}
    |
 
+error[E0408]: variable `Ban` is not bound in all patterns
+  --> $DIR/binding-typo.rs:22:9
+   |
+LL |         (Foo, _) | (Ban, Foo) => {}
+   |         ^^^^^^^^    --- variable not in all patterns
+   |         |
+   |         pattern doesn't bind `Ban`
+   |
+help: you might have meant to use the similarly named unit variant `Bar`
+   |
+LL -         (Foo, _) | (Ban, Foo) => {}
+LL +         (Foo, _) | (Bar, Foo) => {}
+   |
+
 error: variable `Ban` is assigned to, but never used
   --> $DIR/binding-typo.rs:12:23
    |
@@ -25,6 +39,14 @@ note: the lint level is defined here
 LL | #![deny(unused_variables)]
    |         ^^^^^^^^^^^^^^^^
 
-error: aborting due to 2 previous errors
+error: variable `Ban` is assigned to, but never used
+  --> $DIR/binding-typo.rs:22:21
+   |
+LL |         (Foo, _) | (Ban, Foo) => {}
+   |                     ^^^
+   |
+   = note: consider using `_Ban` instead
+
+error: aborting due to 4 previous errors
 
 For more information about this error, try `rustc --explain E0408`.

From 435de36225382f763cc7ce6d744365c75c318596 Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Sat, 30 Aug 2025 04:52:26 +0000
Subject: [PATCH 0345/1889] Prepare for merging from rust-lang/rust

This updates the rust-version file to e004014d1bf4c29928a0f0f9f7d0964d43606cbd.
---
 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 5e83354000247..695959e2e68a6 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-269d5b56bcfdf2be82213e72ef9a2e4c592a8c6b
+e004014d1bf4c29928a0f0f9f7d0964d43606cbd

From 2ce6154b32c50b3588e0c58b6f106647a8831de8 Mon Sep 17 00:00:00 2001
From: Martin Nordholts <martin.nordholts@codetale.se>
Date: Sat, 30 Aug 2025 10:38:23 +0200
Subject: [PATCH 0346/1889] compiler: Include span of too huge array with
 `-Cdebuginfo=2`

We have a few ui tests to ensure we emit an error if we encounter too
big arrays. Before this fix, compiling the tests with `-Cdebuginfo=2`
would not include the spans of the instantiation sites, because the
error is then emitted from a different code path that does not include
the span.

Propagate the span to the error also in the debuginfo case, so the tests
passes regardless of debuginfo level.
---
 compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs     | 7 ++++---
 compiler/rustc_codegen_llvm/src/type_of.rs                | 7 ++++++-
 ....stderr => huge-array-simple-64.full-debuginfo.stderr} | 2 +-
 tests/ui/limits/huge-array-simple-64.no-debuginfo.stderr  | 8 ++++++++
 tests/ui/limits/huge-array-simple-64.rs                   | 5 +++++
 ...huge-array.stderr => huge-array.full-debuginfo.stderr} | 2 +-
 tests/ui/limits/huge-array.no-debuginfo.stderr            | 8 ++++++++
 tests/ui/limits/huge-array.rs                             | 5 +++++
 ...919-64.stderr => issue-15919-64.full-debuginfo.stderr} | 2 +-
 tests/ui/limits/issue-15919-64.no-debuginfo.stderr        | 8 ++++++++
 tests/ui/limits/issue-15919-64.rs                         | 5 +++++
 11 files changed, 52 insertions(+), 7 deletions(-)
 rename tests/ui/limits/{huge-array-simple-64.stderr => huge-array-simple-64.full-debuginfo.stderr} (83%)
 create mode 100644 tests/ui/limits/huge-array-simple-64.no-debuginfo.stderr
 rename tests/ui/limits/{huge-array.stderr => huge-array.full-debuginfo.stderr} (87%)
 create mode 100644 tests/ui/limits/huge-array.no-debuginfo.stderr
 rename tests/ui/limits/{issue-15919-64.stderr => issue-15919-64.full-debuginfo.stderr} (85%)
 create mode 100644 tests/ui/limits/issue-15919-64.no-debuginfo.stderr

diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
index caa3369f413a8..1790e21225269 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
@@ -103,16 +103,17 @@ fn build_fixed_size_array_di_node<'ll, 'tcx>(
     cx: &CodegenCx<'ll, 'tcx>,
     unique_type_id: UniqueTypeId<'tcx>,
     array_type: Ty<'tcx>,
+    span: Span,
 ) -> DINodeCreationResult<'ll> {
     let ty::Array(element_type, len) = array_type.kind() else {
         bug!("build_fixed_size_array_di_node() called with non-ty::Array type `{:?}`", array_type)
     };
 
-    let element_type_di_node = type_di_node(cx, *element_type);
+    let element_type_di_node = spanned_type_di_node(cx, *element_type, span);
 
     return_if_di_node_created_in_meantime!(cx, unique_type_id);
 
-    let (size, align) = cx.size_and_align_of(array_type);
+    let (size, align) = cx.spanned_size_and_align_of(array_type, span);
 
     let upper_bound = len
         .try_to_target_usize(cx.tcx)
@@ -447,7 +448,7 @@ pub(crate) fn spanned_type_di_node<'ll, 'tcx>(
             build_basic_type_di_node(cx, t)
         }
         ty::Tuple(elements) if elements.is_empty() => build_basic_type_di_node(cx, t),
-        ty::Array(..) => build_fixed_size_array_di_node(cx, unique_type_id, t),
+        ty::Array(..) => build_fixed_size_array_di_node(cx, unique_type_id, t, span),
         ty::Slice(_) | ty::Str => build_slice_type_di_node(cx, t, unique_type_id),
         ty::Dynamic(..) => build_dyn_type_di_node(cx, t, unique_type_id),
         ty::Foreign(..) => build_foreign_type_di_node(cx, t, unique_type_id),
diff --git a/compiler/rustc_codegen_llvm/src/type_of.rs b/compiler/rustc_codegen_llvm/src/type_of.rs
index 4e7096da502d0..53218340414e5 100644
--- a/compiler/rustc_codegen_llvm/src/type_of.rs
+++ b/compiler/rustc_codegen_llvm/src/type_of.rs
@@ -7,6 +7,7 @@ use rustc_middle::bug;
 use rustc_middle::ty::layout::{LayoutOf, TyAndLayout};
 use rustc_middle::ty::print::{with_no_trimmed_paths, with_no_visible_paths};
 use rustc_middle::ty::{self, CoroutineArgsExt, Ty, TypeVisitableExt};
+use rustc_span::{DUMMY_SP, Span};
 use tracing::debug;
 
 use crate::common::*;
@@ -149,7 +150,11 @@ impl<'a, 'tcx> CodegenCx<'a, 'tcx> {
     }
 
     pub(crate) fn size_and_align_of(&self, ty: Ty<'tcx>) -> (Size, Align) {
-        let layout = self.layout_of(ty);
+        self.spanned_size_and_align_of(ty, DUMMY_SP)
+    }
+
+    pub(crate) fn spanned_size_and_align_of(&self, ty: Ty<'tcx>, span: Span) -> (Size, Align) {
+        let layout = self.spanned_layout_of(ty, span);
         (layout.size, layout.align.abi)
     }
 }
diff --git a/tests/ui/limits/huge-array-simple-64.stderr b/tests/ui/limits/huge-array-simple-64.full-debuginfo.stderr
similarity index 83%
rename from tests/ui/limits/huge-array-simple-64.stderr
rename to tests/ui/limits/huge-array-simple-64.full-debuginfo.stderr
index 46df288d4f78a..8ce93ab1884ea 100644
--- a/tests/ui/limits/huge-array-simple-64.stderr
+++ b/tests/ui/limits/huge-array-simple-64.full-debuginfo.stderr
@@ -1,5 +1,5 @@
 error: values of the type `[u8; 2305843011361177600]` are too big for the target architecture
-  --> $DIR/huge-array-simple-64.rs:7:9
+  --> $DIR/huge-array-simple-64.rs:12:9
    |
 LL |     let _fat: [u8; (1<<61)+(1<<31)] =
    |         ^^^^
diff --git a/tests/ui/limits/huge-array-simple-64.no-debuginfo.stderr b/tests/ui/limits/huge-array-simple-64.no-debuginfo.stderr
new file mode 100644
index 0000000000000..8ce93ab1884ea
--- /dev/null
+++ b/tests/ui/limits/huge-array-simple-64.no-debuginfo.stderr
@@ -0,0 +1,8 @@
+error: values of the type `[u8; 2305843011361177600]` are too big for the target architecture
+  --> $DIR/huge-array-simple-64.rs:12:9
+   |
+LL |     let _fat: [u8; (1<<61)+(1<<31)] =
+   |         ^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/limits/huge-array-simple-64.rs b/tests/ui/limits/huge-array-simple-64.rs
index d2838e0d41e70..0c000940062fc 100644
--- a/tests/ui/limits/huge-array-simple-64.rs
+++ b/tests/ui/limits/huge-array-simple-64.rs
@@ -1,3 +1,8 @@
+// FIXME(#61117): Remove revisions once x86_64-gnu-debug CI job sets rust.debuginfo-level-tests=2
+// NOTE: The .stderr for both revisions shall be identical.
+//@ revisions: no-debuginfo full-debuginfo
+//@[no-debuginfo] compile-flags: -Cdebuginfo=0
+//@[full-debuginfo] compile-flags: -Cdebuginfo=2
 //@ build-fail
 //@ ignore-32bit
 
diff --git a/tests/ui/limits/huge-array.stderr b/tests/ui/limits/huge-array.full-debuginfo.stderr
similarity index 87%
rename from tests/ui/limits/huge-array.stderr
rename to tests/ui/limits/huge-array.full-debuginfo.stderr
index ce0c0d650c2f8..0a9c8c67ce9a4 100644
--- a/tests/ui/limits/huge-array.stderr
+++ b/tests/ui/limits/huge-array.full-debuginfo.stderr
@@ -1,5 +1,5 @@
 error: values of the type `[[u8; 1518599999]; 1518600000]` are too big for the target architecture
-  --> $DIR/huge-array.rs:4:9
+  --> $DIR/huge-array.rs:9:9
    |
 LL |     let s: [T; 1518600000] = [t; 1518600000];
    |         ^
diff --git a/tests/ui/limits/huge-array.no-debuginfo.stderr b/tests/ui/limits/huge-array.no-debuginfo.stderr
new file mode 100644
index 0000000000000..0a9c8c67ce9a4
--- /dev/null
+++ b/tests/ui/limits/huge-array.no-debuginfo.stderr
@@ -0,0 +1,8 @@
+error: values of the type `[[u8; 1518599999]; 1518600000]` are too big for the target architecture
+  --> $DIR/huge-array.rs:9:9
+   |
+LL |     let s: [T; 1518600000] = [t; 1518600000];
+   |         ^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/limits/huge-array.rs b/tests/ui/limits/huge-array.rs
index 97cfd1ff8fb2c..0cf5902769472 100644
--- a/tests/ui/limits/huge-array.rs
+++ b/tests/ui/limits/huge-array.rs
@@ -1,3 +1,8 @@
+// FIXME(#61117): Remove revisions once x86_64-gnu-debug CI job sets rust.debuginfo-level-tests=2
+// NOTE: The .stderr for both revisions shall be identical.
+//@ revisions: no-debuginfo full-debuginfo
+//@[no-debuginfo] compile-flags: -Cdebuginfo=0
+//@[full-debuginfo] compile-flags: -Cdebuginfo=2
 //@ build-fail
 
 fn generic<T: Copy>(t: T) {
diff --git a/tests/ui/limits/issue-15919-64.stderr b/tests/ui/limits/issue-15919-64.full-debuginfo.stderr
similarity index 85%
rename from tests/ui/limits/issue-15919-64.stderr
rename to tests/ui/limits/issue-15919-64.full-debuginfo.stderr
index cd443f2065bbd..54434675d2506 100644
--- a/tests/ui/limits/issue-15919-64.stderr
+++ b/tests/ui/limits/issue-15919-64.full-debuginfo.stderr
@@ -1,5 +1,5 @@
 error: values of the type `[usize; usize::MAX]` are too big for the target architecture
-  --> $DIR/issue-15919-64.rs:5:9
+  --> $DIR/issue-15919-64.rs:10:9
    |
 LL |     let x = [0usize; 0xffff_ffff_ffff_ffff];
    |         ^
diff --git a/tests/ui/limits/issue-15919-64.no-debuginfo.stderr b/tests/ui/limits/issue-15919-64.no-debuginfo.stderr
new file mode 100644
index 0000000000000..54434675d2506
--- /dev/null
+++ b/tests/ui/limits/issue-15919-64.no-debuginfo.stderr
@@ -0,0 +1,8 @@
+error: values of the type `[usize; usize::MAX]` are too big for the target architecture
+  --> $DIR/issue-15919-64.rs:10:9
+   |
+LL |     let x = [0usize; 0xffff_ffff_ffff_ffff];
+   |         ^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/limits/issue-15919-64.rs b/tests/ui/limits/issue-15919-64.rs
index 7e6200882a966..c1eee1d95ba17 100644
--- a/tests/ui/limits/issue-15919-64.rs
+++ b/tests/ui/limits/issue-15919-64.rs
@@ -1,3 +1,8 @@
+// FIXME(#61117): Remove revisions once x86_64-gnu-debug CI job sets rust.debuginfo-level-tests=2
+// NOTE: The .stderr for both revisions shall be identical.
+//@ revisions: no-debuginfo full-debuginfo
+//@[no-debuginfo] compile-flags: -Cdebuginfo=0
+//@[full-debuginfo] compile-flags: -Cdebuginfo=2
 //@ build-fail
 //@ ignore-32bit
 

From f2ff4c2598609992d476e3d937233534fd137571 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 30 Aug 2025 14:29:17 +0200
Subject: [PATCH 0347/1889] native-lib mode: avoid unsoundness due to mrpotect

---
 .../miri/src/shims/native_lib/trace/child.rs  | 30 ++++++++-----------
 1 file changed, 13 insertions(+), 17 deletions(-)

diff --git a/src/tools/miri/src/shims/native_lib/trace/child.rs b/src/tools/miri/src/shims/native_lib/trace/child.rs
index b998ba822dde4..95b0617a0261b 100644
--- a/src/tools/miri/src/shims/native_lib/trace/child.rs
+++ b/src/tools/miri/src/shims/native_lib/trace/child.rs
@@ -90,14 +90,6 @@ impl Supervisor {
         // Unwinding might be messed up due to partly protected memory, so let's abort if something
         // breaks inside here.
         let res = std::panic::abort_unwind(|| {
-            // SAFETY: We do not access machine memory past this point until the
-            // supervisor is ready to allow it.
-            // FIXME: this is sketchy, as technically the memory is still in the Rust Abstract Machine,
-            // and the compiler would be allowed to reorder accesses below this block...
-            unsafe {
-                Self::protect_pages(alloc.pages(), mman::ProtFlags::PROT_NONE).unwrap();
-            }
-
             // Send over the info.
             // NB: if we do not wait to receive a blank confirmation response, it is
             // possible that the supervisor is alerted of the SIGSTOP *before* it has
@@ -110,16 +102,14 @@ impl Supervisor {
             // count.
             signal::raise(signal::SIGSTOP).unwrap();
 
-            let res = f();
+            // SAFETY: We have coordinated with the supervisor to ensure that this memory will keep
+            // working as normal, just with extra tracing. So even if the compiler moves memory
+            // accesses down to after the `mprotect`, they won't actually segfault.
+            unsafe {
+                Self::protect_pages(alloc.pages(), mman::ProtFlags::PROT_NONE).unwrap();
+            }
 
-            // We can't use IPC channels here to signal that FFI mode has ended,
-            // since they might allocate memory which could get us stuck in a SIGTRAP
-            // with no easy way out! While this could be worked around, it is much
-            // simpler and more robust to simply use the signals which are left for
-            // arbitrary usage. Since this will block until we are continued by the
-            // supervisor, we can assume past this point that everything is back to
-            // normal.
-            signal::raise(signal::SIGUSR1).unwrap();
+            let res = f();
 
             // SAFETY: We set memory back to normal, so this is safe.
             unsafe {
@@ -130,6 +120,12 @@ impl Supervisor {
                 .unwrap();
             }
 
+            // Signal the supervisor that we are done. Will block until the supervisor continues us.
+            // This will also shut down the segfault handler, so it's important that all memory is
+            // reset back to normal above. There must not be a window in time where accessing the
+            // pages we protected above actually causes the program to abort.
+            signal::raise(signal::SIGUSR1).unwrap();
+
             res
         });
 

From 0308a15f64ffd03510a1456c6e492b87fef2097e Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 30 Aug 2025 14:50:53 +0200
Subject: [PATCH 0348/1889] reduce some code duplication and update some
 comments

---
 .../miri/src/shims/native_lib/trace/parent.rs | 30 +++++--------------
 1 file changed, 8 insertions(+), 22 deletions(-)

diff --git a/src/tools/miri/src/shims/native_lib/trace/parent.rs b/src/tools/miri/src/shims/native_lib/trace/parent.rs
index 83f6c7a13fcfe..acb94395b57a7 100644
--- a/src/tools/miri/src/shims/native_lib/trace/parent.rs
+++ b/src/tools/miri/src/shims/native_lib/trace/parent.rs
@@ -132,10 +132,10 @@ impl Iterator for ChildListener {
                                 return Some(ExecEvent::Syscall(pid));
                             },
                         // Child with the given pid was stopped by the given signal.
-                        // It's somewhat dubious when this is returned instead of
-                        // WaitStatus::Stopped, but for our purposes they are the
-                        // same thing.
-                        wait::WaitStatus::PtraceEvent(pid, signal, _) =>
+                        // It's somewhat unclear when which of these two is returned;
+                        // we just treat them the same.
+                        wait::WaitStatus::Stopped(pid, signal)
+                        | wait::WaitStatus::PtraceEvent(pid, signal, _) =>
                             if self.attached {
                                 // This is our end-of-FFI signal!
                                 if signal == signal::SIGUSR1 {
@@ -148,19 +148,6 @@ impl Iterator for ChildListener {
                                 // Just pass along the signal.
                                 ptrace::cont(pid, signal).unwrap();
                             },
-                        // Child was stopped at the given signal. Same logic as for
-                        // WaitStatus::PtraceEvent.
-                        wait::WaitStatus::Stopped(pid, signal) =>
-                            if self.attached {
-                                if signal == signal::SIGUSR1 {
-                                    self.attached = false;
-                                    return Some(ExecEvent::End);
-                                } else {
-                                    return Some(ExecEvent::Status(pid, signal));
-                                }
-                            } else {
-                                ptrace::cont(pid, signal).unwrap();
-                            },
                         _ => (),
                     },
                 // This case should only trigger when all children died.
@@ -250,7 +237,7 @@ pub fn sv_loop(
                 // We can't trust simply calling `Pid::this()` in the child process to give the right
                 // PID for us, so we get it this way.
                 curr_pid = wait_for_signal(None, signal::SIGSTOP, InitialCont::No).unwrap();
-
+                // Continue until next syscall.
                 ptrace::syscall(curr_pid, None).unwrap();
             }
             // Child wants to end tracing.
@@ -289,8 +276,7 @@ pub fn sv_loop(
                         }
                     }
                 },
-            // Child entered a syscall; we wait for exits inside of this, so it
-            // should never trigger on return from a syscall we care about.
+            // Child entered or exited a syscall. For now we ignore this and just continue.
             ExecEvent::Syscall(pid) => {
                 ptrace::syscall(pid, None).unwrap();
             }
@@ -344,8 +330,8 @@ fn wait_for_signal(
                 return Err(ExecEnd(Some(code)));
             }
             wait::WaitStatus::Signaled(_, _, _) => return Err(ExecEnd(None)),
-            wait::WaitStatus::Stopped(pid, signal) => (signal, pid),
-            wait::WaitStatus::PtraceEvent(pid, signal, _) => (signal, pid),
+            wait::WaitStatus::Stopped(pid, signal)
+            | wait::WaitStatus::PtraceEvent(pid, signal, _) => (signal, pid),
             // This covers PtraceSyscall and variants that are impossible with
             // the flags set (e.g. WaitStatus::StillAlive).
             _ => {

From 0b1bc65002371c36b6e796f8933f8cb96e5d31d8 Mon Sep 17 00:00:00 2001
From: WANG Rui <wangrui@loongson.cn>
Date: Sat, 30 Aug 2025 21:31:16 +0800
Subject: [PATCH 0349/1889] Explicity disable LSX feature for
 `loongarch64-unknown-none` target

The `loongarch64-unknown-none` target is a bare-metal target with
hardware floating-point support and should not enable SIMD extensions
by default. However, LLVM's LoongArch64 backend enables LSX implicitly,
inadvertently activating SIMD instructions for this target. This patch
explicitly disable LSX feature to prevent unintended SIMD usage.
---
 .../rustc_target/src/spec/targets/loongarch64_unknown_none.rs   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none.rs b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none.rs
index 91e3064aaede3..b6a08958284fa 100644
--- a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none.rs
+++ b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none.rs
@@ -17,7 +17,7 @@ pub(crate) fn target() -> Target {
         arch: "loongarch64".into(),
         options: TargetOptions {
             cpu: "generic".into(),
-            features: "+f,+d".into(),
+            features: "+f,+d,-lsx".into(),
             linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
             linker: Some("rust-lld".into()),
             llvm_abiname: "lp64d".into(),

From ddf1b3e7d4f7a538cdc57d92c8d50458be57bde0 Mon Sep 17 00:00:00 2001
From: Taiki Endo <te316e89@gmail.com>
Date: Sat, 30 Aug 2025 23:35:39 +0900
Subject: [PATCH 0350/1889] Update target spec metadata of Arm64EC Windows and
 Trusty targets

---
 .../rustc_target/src/spec/targets/aarch64_unknown_trusty.rs   | 2 +-
 .../rustc_target/src/spec/targets/arm64ec_pc_windows_msvc.rs  | 4 ++--
 .../rustc_target/src/spec/targets/armv7_unknown_trusty.rs     | 2 +-
 .../rustc_target/src/spec/targets/x86_64_unknown_trusty.rs    | 2 +-
 4 files changed, 5 insertions(+), 5 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 126f025123917..05783fde1adf8 100644
--- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_trusty.rs
+++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_trusty.rs
@@ -11,7 +11,7 @@ pub(crate) fn target() -> Target {
             description: Some("ARM64 Trusty".into()),
             tier: Some(3),
             host_tools: Some(false),
-            std: Some(false),
+            std: Some(true),
         },
         pointer_width: 64,
         data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(),
diff --git a/compiler/rustc_target/src/spec/targets/arm64ec_pc_windows_msvc.rs b/compiler/rustc_target/src/spec/targets/arm64ec_pc_windows_msvc.rs
index 8f93523909e37..7292412a18d86 100644
--- a/compiler/rustc_target/src/spec/targets/arm64ec_pc_windows_msvc.rs
+++ b/compiler/rustc_target/src/spec/targets/arm64ec_pc_windows_msvc.rs
@@ -20,9 +20,9 @@ pub(crate) fn target() -> Target {
         llvm_target: "arm64ec-pc-windows-msvc".into(),
         metadata: TargetMetadata {
             description: Some("Arm64EC Windows MSVC".into()),
-            tier: Some(3),
+            tier: Some(2),
             host_tools: Some(false),
-            std: None, // ?
+            std: Some(true),
         },
         pointer_width: 64,
         data_layout:
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 31d492e83cda3..2b0b0e1d1170d 100644
--- a/compiler/rustc_target/src/spec/targets/armv7_unknown_trusty.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7_unknown_trusty.rs
@@ -13,7 +13,7 @@ pub(crate) fn target() -> Target {
             description: Some("Armv7-A Trusty".into()),
             tier: Some(3),
             host_tools: Some(false),
-            std: Some(false),
+            std: Some(true),
         },
         pointer_width: 32,
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_trusty.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_trusty.rs
index c7b002bc9bbaa..dbcb5fd4e11e2 100644
--- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_trusty.rs
+++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_trusty.rs
@@ -12,7 +12,7 @@ pub(crate) fn target() -> Target {
             description: Some("x86_64 Trusty".into()),
             tier: Some(3),
             host_tools: Some(false),
-            std: Some(false),
+            std: Some(true),
         },
         pointer_width: 64,
         data_layout:

From f4e68b25f9c53d4968edfccf7a975135adb8cbcf Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sat, 30 Aug 2025 16:50:43 +0200
Subject: [PATCH 0351/1889] fix: `assertions_on_result_states` avoid changing
 return type in more cases

previously, we added a trailing semicolon only if the expr was a
trailing expr of a block
---
 .../src/assertions_on_result_states.rs        | 27 ++++++++++---------
 tests/ui/assertions_on_result_states.fixed    | 11 +++++++-
 tests/ui/assertions_on_result_states.rs       | 11 +++++++-
 tests/ui/assertions_on_result_states.stderr   | 10 +++++--
 4 files changed, 43 insertions(+), 16 deletions(-)

diff --git a/clippy_lints/src/assertions_on_result_states.rs b/clippy_lints/src/assertions_on_result_states.rs
index 6f2a6a36a38b7..08253b0c4995e 100644
--- a/clippy_lints/src/assertions_on_result_states.rs
+++ b/clippy_lints/src/assertions_on_result_states.rs
@@ -3,10 +3,10 @@ use clippy_utils::macros::{PanicExpn, find_assert_args, root_macro_call_first_no
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::{has_debug_impl, is_copy, is_type_diagnostic_item};
 use clippy_utils::usage::local_used_after_expr;
-use clippy_utils::{is_expr_final_block_expr, path_res, sym};
+use clippy_utils::{path_res, sym};
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
-use rustc_hir::{Expr, ExprKind};
+use rustc_hir::{Expr, ExprKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty};
 use rustc_session::declare_lint_pass;
@@ -77,17 +77,20 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnResultStates {
                 _ => 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,
-                );
+                let recv = snippet_with_context(cx, recv.span, condition.span.ctxt(), "..", &mut app).0;
+
+                // `assert!` doesn't return anything, but `Result::unwrap(_err)` does, so we might need to add a
+                // semicolon to the suggestion to avoid leaking the type
+                let sugg = match cx.tcx.parent_hir_node(e.hir_id) {
+                    // trailing expr of a block
+                    Node::Block(..) => format!("{recv}.{replacement}();"),
+                    // already has a trailing semicolon
+                    Node::Stmt(..) => format!("{recv}.{replacement}()"),
+                    // this is the last-resort option, because it's rather verbose
+                    _ => format!("{{ {recv}.{replacement}(); }}"),
+                };
+                diag.span_suggestion(macro_call.span, "replace with", sugg, app);
             });
         }
     }
diff --git a/tests/ui/assertions_on_result_states.fixed b/tests/ui/assertions_on_result_states.fixed
index 09c1a8d0ed1d5..b2b7318c113f7 100644
--- a/tests/ui/assertions_on_result_states.fixed
+++ b/tests/ui/assertions_on_result_states.fixed
@@ -82,9 +82,18 @@ fn main() {
     assert!(r.is_err());
 }
 
-#[allow(dead_code)]
 fn issue9450() {
     let res: Result<i32, i32> = Ok(1);
     res.unwrap_err();
     //~^ assertions_on_result_states
 }
+
+fn issue9916(res: Result<u32, u32>) {
+    let a = 0;
+    match a {
+        0 => {},
+        1 => { res.unwrap(); },
+        //~^ assertions_on_result_states
+        _ => todo!(),
+    }
+}
diff --git a/tests/ui/assertions_on_result_states.rs b/tests/ui/assertions_on_result_states.rs
index c63c2502b5377..33f1485326b38 100644
--- a/tests/ui/assertions_on_result_states.rs
+++ b/tests/ui/assertions_on_result_states.rs
@@ -82,9 +82,18 @@ fn main() {
     assert!(r.is_err());
 }
 
-#[allow(dead_code)]
 fn issue9450() {
     let res: Result<i32, i32> = Ok(1);
     assert!(res.is_err())
     //~^ assertions_on_result_states
 }
+
+fn issue9916(res: Result<u32, u32>) {
+    let a = 0;
+    match a {
+        0 => {},
+        1 => assert!(res.is_ok()),
+        //~^ assertions_on_result_states
+        _ => todo!(),
+    }
+}
diff --git a/tests/ui/assertions_on_result_states.stderr b/tests/ui/assertions_on_result_states.stderr
index 3bf811588c696..826f049555cae 100644
--- a/tests/ui/assertions_on_result_states.stderr
+++ b/tests/ui/assertions_on_result_states.stderr
@@ -38,10 +38,16 @@ LL |     assert!(r.is_err());
    |     ^^^^^^^^^^^^^^^^^^^ help: replace with: `r.unwrap_err()`
 
 error: called `assert!` with `Result::is_err`
-  --> tests/ui/assertions_on_result_states.rs:88:5
+  --> tests/ui/assertions_on_result_states.rs:87:5
    |
 LL |     assert!(res.is_err())
    |     ^^^^^^^^^^^^^^^^^^^^^ help: replace with: `res.unwrap_err();`
 
-error: aborting due to 7 previous errors
+error: called `assert!` with `Result::is_ok`
+  --> tests/ui/assertions_on_result_states.rs:95:14
+   |
+LL |         1 => assert!(res.is_ok()),
+   |              ^^^^^^^^^^^^^^^^^^^^ help: replace with: `{ res.unwrap(); }`
+
+error: aborting due to 8 previous errors
 

From 7f125af963ed5b44b6d7e47be62ed5026b96c6e6 Mon Sep 17 00:00:00 2001
From: Samuel Moelius <sam@moeli.us>
Date: Sat, 30 Aug 2025 12:13:04 -0400
Subject: [PATCH 0352/1889] Commas to semicolons in clippy.toml reasons

---
 clippy.toml                                 | 6 +++---
 tests/ui-internal/disallow_span_lint.stderr | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/clippy.toml b/clippy.toml
index 77573105d86a3..d9bcfd17606e4 100644
--- a/clippy.toml
+++ b/clippy.toml
@@ -6,12 +6,12 @@ lint-commented-code = true
 
 [[disallowed-methods]]
 path = "rustc_lint::context::LintContext::lint"
-reason = "this function does not add a link to our documentation, please use the `clippy_utils::diagnostics::span_lint*` functions instead"
+reason = "this function does not add a link to our documentation; please use the `clippy_utils::diagnostics::span_lint*` functions instead"
 
 [[disallowed-methods]]
 path = "rustc_lint::context::LintContext::span_lint"
-reason = "this function does not add a link to our documentation, please use the `clippy_utils::diagnostics::span_lint*` functions instead"
+reason = "this function does not add a link to our documentation; please use the `clippy_utils::diagnostics::span_lint*` functions instead"
 
 [[disallowed-methods]]
 path = "rustc_middle::ty::context::TyCtxt::node_span_lint"
-reason = "this function does not add a link to our documentation, please use the `clippy_utils::diagnostics::span_lint_hir*` functions instead"
+reason = "this function does not add a link to our documentation; please use the `clippy_utils::diagnostics::span_lint_hir*` functions instead"
diff --git a/tests/ui-internal/disallow_span_lint.stderr b/tests/ui-internal/disallow_span_lint.stderr
index f03a745963e00..e9d53c64dd9b5 100644
--- a/tests/ui-internal/disallow_span_lint.stderr
+++ b/tests/ui-internal/disallow_span_lint.stderr
@@ -4,7 +4,7 @@ error: use of a disallowed method `rustc_lint::context::LintContext::span_lint`
 LL |     cx.span_lint(lint, span, |lint| {
    |        ^^^^^^^^^
    |
-   = note: this function does not add a link to our documentation, please use the `clippy_utils::diagnostics::span_lint*` functions instead
+   = note: this function does not add a link to our documentation; please use the `clippy_utils::diagnostics::span_lint*` functions instead
 note: the lint level is defined here
   --> tests/ui-internal/disallow_span_lint.rs:2:9
    |
@@ -17,7 +17,7 @@ error: use of a disallowed method `rustc_middle::ty::context::TyCtxt::node_span_
 LL |     tcx.node_span_lint(lint, hir_id, span, |lint| {
    |         ^^^^^^^^^^^^^^
    |
-   = note: this function does not add a link to our documentation, please use the `clippy_utils::diagnostics::span_lint_hir*` functions instead
+   = note: this function does not add a link to our documentation; please use the `clippy_utils::diagnostics::span_lint_hir*` functions instead
 
 error: aborting due to 2 previous errors
 

From 00f6fe1b6cbb211c4396b306566816f91a4ed371 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sat, 30 Aug 2025 16:24:26 +0000
Subject: [PATCH 0353/1889] On unused binding in pattern, suggest unit
 struct/variant with similar name

When encountering a typo in a pattern that gets interpreted as an unused binding, look for unit struct/variant of the same type as the binding:

```
error: unused variable: `Non`
  --> $DIR/binding-typo-2.rs:36:9
   |
LL |         Non => {}
   |         ^^^
   |
help: if this is intentional, prefix it with an underscore
   |
LL |         _Non => {}
   |         +
help: you might have meant to pattern match on the similarly named variant `None`
   |
LL -         Non => {}
LL +         std::prelude::v1::None => {}
   |
```
---
 compiler/rustc_passes/messages.ftl            |   1 +
 compiler/rustc_passes/src/errors.rs           |  18 ++
 compiler/rustc_passes/src/liveness.rs         |  33 ++-
 ...d-type-meant-to-be-arg-of-mut-borrow.fixed |   8 +-
 ...owed-type-meant-to-be-arg-of-mut-borrow.rs |   8 +-
 ...-type-meant-to-be-arg-of-mut-borrow.stderr |  25 +--
 .../lint-uppercase-variables.stderr           |  32 ++-
 tests/ui/or-patterns/binding-typo-2.rs        |  25 ++-
 tests/ui/or-patterns/binding-typo-2.stderr    | 197 +++++++++++++++---
 tests/ui/or-patterns/binding-typo.fixed       |   6 +-
 tests/ui/or-patterns/binding-typo.rs          |   6 +-
 tests/ui/or-patterns/binding-typo.stderr      |  25 +--
 12 files changed, 279 insertions(+), 105 deletions(-)

diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index 00a41e31a0234..99b1aae8b74ca 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -681,6 +681,7 @@ passes_unused_var_maybe_capture_ref = unused variable: `{$name}`
 
 passes_unused_var_remove_field = unused variable: `{$name}`
 passes_unused_var_remove_field_suggestion = try removing the field
+passes_unused_var_typo = you might have meant to pattern match on the similarly named {$kind} `{$item_name}`
 
 passes_unused_variable_args_in_macro = `{$name}` is captured in macro and introduced a unused variable
 
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index 4fec6b0798a55..ebd8f6fc8202d 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -1346,6 +1346,22 @@ pub(crate) struct UnusedVarRemoveFieldSugg {
 #[note]
 pub(crate) struct UnusedVarAssignedOnly {
     pub name: String,
+    #[subdiagnostic]
+    pub typo: Option<PatternTypo>,
+}
+
+#[derive(Subdiagnostic)]
+#[multipart_suggestion(
+    passes_unused_var_typo,
+    style = "verbose",
+    applicability = "machine-applicable"
+)]
+pub(crate) struct PatternTypo {
+    #[suggestion_part(code = "{code}")]
+    pub span: Span,
+    pub code: String,
+    pub item_name: String,
+    pub kind: String,
 }
 
 #[derive(LintDiagnostic)]
@@ -1413,6 +1429,8 @@ pub(crate) struct UnusedVariableTryPrefix {
     #[subdiagnostic]
     pub sugg: UnusedVariableSugg,
     pub name: String,
+    #[subdiagnostic]
+    pub typo: Option<PatternTypo>,
 }
 
 #[derive(Subdiagnostic)]
diff --git a/compiler/rustc_passes/src/liveness.rs b/compiler/rustc_passes/src/liveness.rs
index 801a533c94338..2ae68c445f8e8 100644
--- a/compiler/rustc_passes/src/liveness.rs
+++ b/compiler/rustc_passes/src/liveness.rs
@@ -95,8 +95,10 @@ use rustc_hir::{Expr, HirId, HirIdMap, HirIdSet, find_attr};
 use rustc_index::IndexVec;
 use rustc_middle::query::Providers;
 use rustc_middle::span_bug;
+use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_middle::ty::{self, RootVariableMinCaptureList, Ty, TyCtxt};
 use rustc_session::lint;
+use rustc_span::edit_distance::find_best_match_for_name;
 use rustc_span::{BytePos, Span, Symbol};
 use tracing::{debug, instrument};
 
@@ -1688,6 +1690,34 @@ impl<'tcx> Liveness<'_, 'tcx> {
             let is_assigned =
                 if ln == self.exit_ln { false } else { self.assigned_on_exit(ln, var) };
 
+            let mut typo = None;
+            for (hir_id, _, span) in &hir_ids_and_spans {
+                let ty = self.typeck_results.node_type(*hir_id);
+                if let ty::Adt(adt, _) = ty.peel_refs().kind() {
+                    let name = Symbol::intern(&name);
+                    let adt_def = self.ir.tcx.adt_def(adt.did());
+                    let variant_names: Vec<_> = adt_def
+                        .variants()
+                        .iter()
+                        .filter(|v| matches!(v.ctor, Some((CtorKind::Const, _))))
+                        .map(|v| v.name)
+                        .collect();
+                    if let Some(name) = find_best_match_for_name(&variant_names, name, None)
+                        && let Some(variant) = adt_def.variants().iter().find(|v| {
+                            v.name == name && matches!(v.ctor, Some((CtorKind::Const, _)))
+                        })
+                    {
+                        typo = Some(errors::PatternTypo {
+                            span: *span,
+                            code: with_no_trimmed_paths!(self.ir.tcx.def_path_str(variant.def_id)),
+                            kind: self.ir.tcx.def_descr(variant.def_id).to_string(),
+                            item_name: variant.name.to_string(),
+                        });
+                    }
+                }
+            }
+            // FIXME(estebank): look for consts of the same type with similar names as well, not
+            // just unit structs and variants.
             if is_assigned {
                 self.ir.tcx.emit_node_span_lint(
                     lint::builtin::UNUSED_VARIABLES,
@@ -1696,7 +1726,7 @@ impl<'tcx> Liveness<'_, 'tcx> {
                         .into_iter()
                         .map(|(_, _, ident_span)| ident_span)
                         .collect::<Vec<_>>(),
-                    errors::UnusedVarAssignedOnly { name },
+                    errors::UnusedVarAssignedOnly { name, typo },
                 )
             } else if can_remove {
                 let spans = hir_ids_and_spans
@@ -1788,6 +1818,7 @@ impl<'tcx> Liveness<'_, 'tcx> {
                             name,
                             sugg,
                             string_interp: suggestions,
+                            typo,
                         },
                     );
                 }
diff --git a/tests/ui/fn/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.fixed b/tests/ui/fn/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.fixed
index b58c3a6720d00..14d5de0261d1e 100644
--- a/tests/ui/fn/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.fixed
+++ b/tests/ui/fn/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.fixed
@@ -1,5 +1,5 @@
 //@ run-rustfix
-#![deny(unused_assignments, unused_variables)]
+#![deny(unused_assignments)]
 #![allow(unused_mut)]
 struct Object;
 
@@ -8,15 +8,15 @@ fn change_object(object: &mut Object) { //~ HELP you might have meant to mutate
    *object = object2; //~ ERROR mismatched types
 }
 
-fn change_object2(object: &mut Object) { //~ ERROR variable `object` is assigned to, but never used
-   //~^ HELP you might have meant to mutate
+fn change_object2(object: &mut Object) {
+    //~^ HELP you might have meant to mutate
    let object2 = Object;
    *object = object2;
    //~^ ERROR `object2` does not live long enough
    //~| ERROR value assigned to `object` is never read
 }
 
-fn change_object3(object: &mut Object) { //~ ERROR variable `object` is assigned to, but never used
+fn change_object3(object: &mut Object) {
     //~^ HELP you might have meant to mutate
     let mut object2 = Object; //~ HELP consider changing this to be mutable
     *object = object2;
diff --git a/tests/ui/fn/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.rs b/tests/ui/fn/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.rs
index 1fd222e0db17f..5805afb3369b1 100644
--- a/tests/ui/fn/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.rs
+++ b/tests/ui/fn/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.rs
@@ -1,5 +1,5 @@
 //@ run-rustfix
-#![deny(unused_assignments, unused_variables)]
+#![deny(unused_assignments)]
 #![allow(unused_mut)]
 struct Object;
 
@@ -8,15 +8,15 @@ fn change_object(mut object: &Object) { //~ HELP you might have meant to mutate
    object = object2; //~ ERROR mismatched types
 }
 
-fn change_object2(mut object: &Object) { //~ ERROR variable `object` is assigned to, but never used
-   //~^ HELP you might have meant to mutate
+fn change_object2(mut object: &Object) {
+    //~^ HELP you might have meant to mutate
    let object2 = Object;
    object = &object2;
    //~^ ERROR `object2` does not live long enough
    //~| ERROR value assigned to `object` is never read
 }
 
-fn change_object3(mut object: &mut Object) { //~ ERROR variable `object` is assigned to, but never used
+fn change_object3(mut object: &mut Object) {
     //~^ HELP you might have meant to mutate
     let object2 = Object; //~ HELP consider changing this to be mutable
     object = &mut object2;
diff --git a/tests/ui/fn/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.stderr b/tests/ui/fn/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.stderr
index 0330853d922fe..c2c7378f07a20 100644
--- a/tests/ui/fn/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.stderr
+++ b/tests/ui/fn/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.stderr
@@ -23,7 +23,7 @@ LL |    object = &object2;
 note: the lint level is defined here
   --> $DIR/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.rs:2:9
    |
-LL | #![deny(unused_assignments, unused_variables)]
+LL | #![deny(unused_assignments)]
    |         ^^^^^^^^^^^^^^^^^^
 help: you might have meant to mutate the pointed at value being passed in, instead of changing the reference in the local binding
    |
@@ -33,19 +33,6 @@ LL |    let object2 = Object;
 LL ~    *object = object2;
    |
 
-error: variable `object` is assigned to, but never used
-  --> $DIR/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.rs:11:23
-   |
-LL | fn change_object2(mut object: &Object) {
-   |                       ^^^^^^
-   |
-   = note: consider using `_object` instead
-note: the lint level is defined here
-  --> $DIR/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.rs:2:29
-   |
-LL | #![deny(unused_assignments, unused_variables)]
-   |                             ^^^^^^^^^^^^^^^^
-
 error[E0597]: `object2` does not live long enough
   --> $DIR/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.rs:14:13
    |
@@ -77,14 +64,6 @@ LL |     let object2 = Object;
 LL ~     *object = object2;
    |
 
-error: variable `object` is assigned to, but never used
-  --> $DIR/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.rs:19:23
-   |
-LL | fn change_object3(mut object: &mut Object) {
-   |                       ^^^^^^
-   |
-   = note: consider using `_object` instead
-
 error[E0596]: cannot borrow `object2` as mutable, as it is not declared as mutable
   --> $DIR/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.rs:22:14
    |
@@ -96,7 +75,7 @@ help: consider changing this to be mutable
 LL |     let mut object2 = Object;
    |         +++
 
-error: aborting due to 7 previous errors
+error: aborting due to 5 previous errors
 
 Some errors have detailed explanations: E0308, E0596, E0597.
 For more information about an error, try `rustc --explain E0308`.
diff --git a/tests/ui/lint/non-snake-case/lint-uppercase-variables.stderr b/tests/ui/lint/non-snake-case/lint-uppercase-variables.stderr
index b0c56003957c9..e5f2e65fd91d3 100644
--- a/tests/ui/lint/non-snake-case/lint-uppercase-variables.stderr
+++ b/tests/ui/lint/non-snake-case/lint-uppercase-variables.stderr
@@ -16,7 +16,7 @@ warning: unused variable: `Foo`
   --> $DIR/lint-uppercase-variables.rs:22:9
    |
 LL |         Foo => {}
-   |         ^^^ help: if this is intentional, prefix it with an underscore: `_Foo`
+   |         ^^^
    |
 note: the lint level is defined here
   --> $DIR/lint-uppercase-variables.rs:1:9
@@ -24,12 +24,29 @@ note: the lint level is defined here
 LL | #![warn(unused)]
    |         ^^^^^^
    = note: `#[warn(unused_variables)]` implied by `#[warn(unused)]`
+help: if this is intentional, prefix it with an underscore
+   |
+LL |         _Foo => {}
+   |         +
+help: you might have meant to pattern match on the similarly named variant `Foo`
+   |
+LL |         foo::Foo::Foo => {}
+   |         ++++++++++
 
 warning: unused variable: `Foo`
   --> $DIR/lint-uppercase-variables.rs:28:9
    |
 LL |     let Foo = foo::Foo::Foo;
-   |         ^^^ help: if this is intentional, prefix it with an underscore: `_Foo`
+   |         ^^^
+   |
+help: if this is intentional, prefix it with an underscore
+   |
+LL |     let _Foo = foo::Foo::Foo;
+   |         +
+help: you might have meant to pattern match on the similarly named variant `Foo`
+   |
+LL |     let foo::Foo::Foo = foo::Foo::Foo;
+   |         ++++++++++
 
 error[E0170]: pattern binding `Foo` is named the same as one of the variants of the type `foo::Foo`
   --> $DIR/lint-uppercase-variables.rs:33:17
@@ -41,7 +58,16 @@ warning: unused variable: `Foo`
   --> $DIR/lint-uppercase-variables.rs:33:17
    |
 LL |     fn in_param(Foo: foo::Foo) {}
-   |                 ^^^ help: if this is intentional, prefix it with an underscore: `_Foo`
+   |                 ^^^
+   |
+help: if this is intentional, prefix it with an underscore
+   |
+LL |     fn in_param(_Foo: foo::Foo) {}
+   |                 +
+help: you might have meant to pattern match on the similarly named variant `Foo`
+   |
+LL |     fn in_param(foo::Foo::Foo: foo::Foo) {}
+   |                 ++++++++++
 
 error: structure field `X` should have a snake case name
   --> $DIR/lint-uppercase-variables.rs:10:5
diff --git a/tests/ui/or-patterns/binding-typo-2.rs b/tests/ui/or-patterns/binding-typo-2.rs
index 4dfb84d4f0cd3..d763ce60ce967 100644
--- a/tests/ui/or-patterns/binding-typo-2.rs
+++ b/tests/ui/or-patterns/binding-typo-2.rs
@@ -17,6 +17,7 @@ fn foo(x: (Lol, Lol)) {
         //~| NOTE: variable not in all patterns
         //~| ERROR: variable `Ban` is assigned to, but never used
         //~| NOTE: consider using `_Ban` instead
+        //~| HELP: you might have meant to pattern match on the similarly named
         _ => {}
     }
     match &x {
@@ -27,15 +28,18 @@ fn foo(x: (Lol, Lol)) {
         //~| NOTE: variable not in all patterns
         //~| ERROR: variable `Ban` is assigned to, but never used
         //~| NOTE: consider using `_Ban` instead
+        //~| HELP: you might have meant to pattern match on the similarly named
         _ => {}
     }
     match Some(42) {
+        Some(_) => {}
         Non => {}
         //~^ ERROR: unused variable: `Non`
         //~| HELP: if this is intentional, prefix it with an underscore
-        _ => {}
+        //~| HELP: you might have meant to pattern match on the similarly named
     }
     match Some(42) {
+        Some(_) => {}
         Non | None => {}
         //~^ ERROR: unused variable: `Non`
         //~| HELP: if this is intentional, prefix it with an underscore
@@ -43,7 +47,7 @@ fn foo(x: (Lol, Lol)) {
         //~| NOTE: pattern doesn't bind `Non`
         //~| NOTE: variable not in all patterns
         //~| HELP: you might have meant to use the similarly named previously used binding `None`
-        _ => {}
+        //~| HELP: you might have meant to pattern match on the similarly named
     }
     match Some(42) {
         Non | Some(_) => {}
@@ -53,14 +57,13 @@ fn foo(x: (Lol, Lol)) {
         //~| NOTE: pattern doesn't bind `Non`
         //~| NOTE: variable not in all patterns
         //~| HELP: you might have meant to use the similarly named unit variant `None`
-        _ => {}
+        //~| HELP: you might have meant to pattern match on the similarly named
     }
 }
 fn bar(x: (Lol, Lol)) {
     use Lol::*;
     use Bat;
     use Bay;
-    use std::option::Option::None;
     match &x {
         (Foo, _) | (Ban, Foo) => {}
         //~^ ERROR: variable `Ban` is not bound in all patterns
@@ -71,6 +74,7 @@ fn bar(x: (Lol, Lol)) {
         //~| NOTE: variable not in all patterns
         //~| ERROR: variable `Ban` is assigned to, but never used
         //~| NOTE: consider using `_Ban` instead
+        //~| HELP: you might have meant to pattern match on the similarly named
         _ => {}
     }
 }
@@ -86,8 +90,21 @@ fn baz(x: (Lol, Lol)) {
         //~| NOTE: variable not in all patterns
         //~| ERROR: variable `Ban` is assigned to, but never used
         //~| NOTE: consider using `_Ban` instead
+        //~| HELP: you might have meant to pattern match on the similarly named
         _ => {}
     }
+    match &x {
+        (Ban, _) => {}
+        //~^ ERROR: unused variable: `Ban`
+        //~| HELP: if this is intentional, prefix it with an underscore
+        //~| HELP: you might have meant to pattern match on the similarly named
+    }
+    match Bay {
+        Ban => {}
+        //~^ ERROR: unused variable: `Ban`
+        //~| HELP: if this is intentional, prefix it with an underscore
+        //~| HELP: you might have meant to pattern match on the similarly named
+    }
 }
 
 fn main() {
diff --git a/tests/ui/or-patterns/binding-typo-2.stderr b/tests/ui/or-patterns/binding-typo-2.stderr
index a2099572485b7..d683cb2b121cc 100644
--- a/tests/ui/or-patterns/binding-typo-2.stderr
+++ b/tests/ui/or-patterns/binding-typo-2.stderr
@@ -13,7 +13,48 @@ LL +         (Foo, Bar) | (Bar, Foo) => {}
    |
 
 error[E0408]: variable `Ban` is not bound in all patterns
-  --> $DIR/binding-typo-2.rs:23:9
+  --> $DIR/binding-typo-2.rs:24:9
+   |
+LL |         (Foo, _) | (Ban, Foo) => {}
+   |         ^^^^^^^^    --- variable not in all patterns
+   |         |
+   |         pattern doesn't bind `Ban`
+   |
+help: you might have meant to use the similarly named unit variant `Bar`
+   |
+LL -         (Foo, _) | (Ban, Foo) => {}
+LL +         (Foo, _) | (Bar, Foo) => {}
+   |
+
+error[E0408]: variable `Non` is not bound in all patterns
+  --> $DIR/binding-typo-2.rs:43:15
+   |
+LL |         Non | None => {}
+   |         ---   ^^^^ pattern doesn't bind `Non`
+   |         |
+   |         variable not in all patterns
+   |
+help: you might have meant to use the similarly named previously used binding `None`
+   |
+LL |         None | None => {}
+   |            +
+
+error[E0408]: variable `Non` is not bound in all patterns
+  --> $DIR/binding-typo-2.rs:53:15
+   |
+LL |         Non | Some(_) => {}
+   |         ---   ^^^^^^^ pattern doesn't bind `Non`
+   |         |
+   |         variable not in all patterns
+   |
+help: you might have meant to use the similarly named unit variant `None`
+   |
+LL -         Non | Some(_) => {}
+LL +         core::option::Option::None | Some(_) => {}
+   |
+
+error[E0408]: variable `Ban` is not bound in all patterns
+  --> $DIR/binding-typo-2.rs:68:9
    |
 LL |         (Foo, _) | (Ban, Foo) => {}
    |         ^^^^^^^^    --- variable not in all patterns
@@ -28,39 +69,31 @@ LL +         (Foo, _) | (Bar, Foo) => {}
 help: you might have meant to use the similarly named unit struct `Bay`
    |
 LL -         (Foo, _) | (Ban, Foo) => {}
-LL +         (Foo, _) | (::Bay, Foo) => {}
+LL +         (Foo, _) | (Bay, Foo) => {}
    |
 help: you might have meant to use the similarly named constant `Bat`
    |
 LL -         (Foo, _) | (Ban, Foo) => {}
-LL +         (Foo, _) | (::Bat, Foo) => {}
+LL +         (Foo, _) | (Bat, Foo) => {}
    |
 
-error[E0408]: variable `Non` is not bound in all patterns
-  --> $DIR/binding-typo-2.rs:41:16
-   |
-LL |         (Non | None)=> {}
-   |          ---   ^^^^ pattern doesn't bind `Non`
-   |          |
-   |          variable not in all patterns
+error[E0408]: variable `Ban` is not bound in all patterns
+  --> $DIR/binding-typo-2.rs:85:9
    |
-help: you might have meant to use the similarly named previously used binding `None`
+LL |         (Foo, _) | (Ban, Foo) => {}
+   |         ^^^^^^^^    --- variable not in all patterns
+   |         |
+   |         pattern doesn't bind `Ban`
    |
-LL |         (None | None)=> {}
-   |             +
-
-error[E0408]: variable `Non` is not bound in all patterns
-  --> $DIR/binding-typo-2.rs:51:16
+help: you might have meant to use the similarly named unit variant `Bar`
    |
-LL |         (Non | Some(_))=> {}
-   |          ---   ^^^^^^^ pattern doesn't bind `Non`
-   |          |
-   |          variable not in all patterns
+LL -         (Foo, _) | (Ban, Foo) => {}
+LL +         (Foo, _) | (Bar, Foo) => {}
    |
-help: you might have meant to use the similarly named unit variant `None`
+help: you might have meant to use the similarly named constant `Bat`
    |
-LL -         (Non | Some(_))=> {}
-LL +         (core::option::Option::None | Some(_))=> {}
+LL -         (Foo, _) | (Ban, Foo) => {}
+LL +         (Foo, _) | (Bat, Foo) => {}
    |
 
 error: variable `Ban` is assigned to, but never used
@@ -75,33 +108,131 @@ note: the lint level is defined here
    |
 LL | #![deny(unused_variables)]
    |         ^^^^^^^^^^^^^^^^
+help: you might have meant to pattern match on the similarly named variant `Bar`
+   |
+LL -         (Foo, Bar) | (Ban, Foo) => {}
+LL +         (Foo, Bar) | (Lol::Bar, Foo) => {}
+   |
 
 error: variable `Ban` is assigned to, but never used
-  --> $DIR/binding-typo-2.rs:23:21
+  --> $DIR/binding-typo-2.rs:24:21
    |
 LL |         (Foo, _) | (Ban, Foo) => {}
    |                     ^^^
    |
    = note: consider using `_Ban` instead
+help: you might have meant to pattern match on the similarly named variant `Bar`
+   |
+LL -         (Foo, _) | (Ban, Foo) => {}
+LL +         (Foo, _) | (Lol::Bar, Foo) => {}
+   |
 
 error: unused variable: `Non`
-  --> $DIR/binding-typo-2.rs:35:9
+  --> $DIR/binding-typo-2.rs:36:9
    |
 LL |         Non => {}
-   |         ^^^ help: if this is intentional, prefix it with an underscore: `_Non`
+   |         ^^^
+   |
+help: if this is intentional, prefix it with an underscore
+   |
+LL |         _Non => {}
+   |         +
+help: you might have meant to pattern match on the similarly named variant `None`
+   |
+LL -         Non => {}
+LL +         std::prelude::v1::None => {}
+   |
 
 error: unused variable: `Non`
-  --> $DIR/binding-typo-2.rs:41:10
+  --> $DIR/binding-typo-2.rs:43:9
+   |
+LL |         Non | None => {}
+   |         ^^^
+   |
+help: if this is intentional, prefix it with an underscore
+   |
+LL |         _Non | None => {}
+   |         +
+help: you might have meant to pattern match on the similarly named variant `None`
+   |
+LL -         Non | None => {}
+LL +         std::prelude::v1::None | None => {}
    |
-LL |         (Non | None)=> {}
-   |          ^^^ help: if this is intentional, prefix it with an underscore: `_Non`
 
 error: unused variable: `Non`
-  --> $DIR/binding-typo-2.rs:51:10
+  --> $DIR/binding-typo-2.rs:53:9
+   |
+LL |         Non | Some(_) => {}
+   |         ^^^
+   |
+help: if this is intentional, prefix it with an underscore
+   |
+LL |         _Non | Some(_) => {}
+   |         +
+help: you might have meant to pattern match on the similarly named variant `None`
+   |
+LL -         Non | Some(_) => {}
+LL +         std::prelude::v1::None | Some(_) => {}
+   |
+
+error: variable `Ban` is assigned to, but never used
+  --> $DIR/binding-typo-2.rs:68:21
+   |
+LL |         (Foo, _) | (Ban, Foo) => {}
+   |                     ^^^
+   |
+   = note: consider using `_Ban` instead
+help: you might have meant to pattern match on the similarly named variant `Bar`
+   |
+LL -         (Foo, _) | (Ban, Foo) => {}
+LL +         (Foo, _) | (Lol::Bar, Foo) => {}
+   |
+
+error: variable `Ban` is assigned to, but never used
+  --> $DIR/binding-typo-2.rs:85:21
+   |
+LL |         (Foo, _) | (Ban, Foo) => {}
+   |                     ^^^
+   |
+   = note: consider using `_Ban` instead
+help: you might have meant to pattern match on the similarly named variant `Bar`
+   |
+LL -         (Foo, _) | (Ban, Foo) => {}
+LL +         (Foo, _) | (Lol::Bar, Foo) => {}
+   |
+
+error: unused variable: `Ban`
+  --> $DIR/binding-typo-2.rs:97:10
+   |
+LL |         (Ban, _) => {}
+   |          ^^^
+   |
+help: if this is intentional, prefix it with an underscore
+   |
+LL |         (_Ban, _) => {}
+   |          +
+help: you might have meant to pattern match on the similarly named variant `Bar`
+   |
+LL -         (Ban, _) => {}
+LL +         (Lol::Bar, _) => {}
+   |
+
+error: unused variable: `Ban`
+  --> $DIR/binding-typo-2.rs:103:9
+   |
+LL |         Ban => {}
+   |         ^^^
+   |
+help: if this is intentional, prefix it with an underscore
+   |
+LL |         _Ban => {}
+   |         +
+help: you might have meant to pattern match on the similarly named struct `Bay`
+   |
+LL -         Ban => {}
+LL +         Bay => {}
    |
-LL |         (Non | Some(_))=> {}
-   |          ^^^ help: if this is intentional, prefix it with an underscore: `_Non`
 
-error: aborting due to 9 previous errors
+error: aborting due to 15 previous errors
 
 For more information about this error, try `rustc --explain E0408`.
diff --git a/tests/ui/or-patterns/binding-typo.fixed b/tests/ui/or-patterns/binding-typo.fixed
index 2902ca303931b..f209ad644db97 100644
--- a/tests/ui/or-patterns/binding-typo.fixed
+++ b/tests/ui/or-patterns/binding-typo.fixed
@@ -1,6 +1,6 @@
 // Issue #51976
 //@ run-rustfix
-#![deny(unused_variables)] //~ NOTE: the lint level is defined here
+#![allow(unused_variables)] // allowed so we don't get overlapping suggestions
 enum Lol {
     Foo,
     Bar,
@@ -14,8 +14,6 @@ fn foo(x: (Lol, Lol)) {
         //~| HELP: you might have meant to use the similarly named previously used binding `Bar`
         //~| NOTE: pattern doesn't bind `Ban`
         //~| NOTE: variable not in all patterns
-        //~| ERROR: variable `Ban` is assigned to, but never used
-        //~| NOTE: consider using `_Ban` instead
         _ => {}
     }
     match &x {
@@ -24,8 +22,6 @@ fn foo(x: (Lol, Lol)) {
         //~| HELP: you might have meant to use the similarly named unit variant `Bar`
         //~| NOTE: pattern doesn't bind `Ban`
         //~| NOTE: variable not in all patterns
-        //~| ERROR: variable `Ban` is assigned to, but never used
-        //~| NOTE: consider using `_Ban` instead
         _ => {}
     }
 }
diff --git a/tests/ui/or-patterns/binding-typo.rs b/tests/ui/or-patterns/binding-typo.rs
index 2ffe0e45c83b7..6be9b801a0d79 100644
--- a/tests/ui/or-patterns/binding-typo.rs
+++ b/tests/ui/or-patterns/binding-typo.rs
@@ -1,6 +1,6 @@
 // Issue #51976
 //@ run-rustfix
-#![deny(unused_variables)] //~ NOTE: the lint level is defined here
+#![allow(unused_variables)] // allowed so we don't get overlapping suggestions
 enum Lol {
     Foo,
     Bar,
@@ -14,8 +14,6 @@ fn foo(x: (Lol, Lol)) {
         //~| HELP: you might have meant to use the similarly named previously used binding `Bar`
         //~| NOTE: pattern doesn't bind `Ban`
         //~| NOTE: variable not in all patterns
-        //~| ERROR: variable `Ban` is assigned to, but never used
-        //~| NOTE: consider using `_Ban` instead
         _ => {}
     }
     match &x {
@@ -24,8 +22,6 @@ fn foo(x: (Lol, Lol)) {
         //~| HELP: you might have meant to use the similarly named unit variant `Bar`
         //~| NOTE: pattern doesn't bind `Ban`
         //~| NOTE: variable not in all patterns
-        //~| ERROR: variable `Ban` is assigned to, but never used
-        //~| NOTE: consider using `_Ban` instead
         _ => {}
     }
 }
diff --git a/tests/ui/or-patterns/binding-typo.stderr b/tests/ui/or-patterns/binding-typo.stderr
index f90301d2ceee1..fb6d5f71209a6 100644
--- a/tests/ui/or-patterns/binding-typo.stderr
+++ b/tests/ui/or-patterns/binding-typo.stderr
@@ -13,7 +13,7 @@ LL +         (Foo, Bar) | (Bar, Foo) => {}
    |
 
 error[E0408]: variable `Ban` is not bound in all patterns
-  --> $DIR/binding-typo.rs:22:9
+  --> $DIR/binding-typo.rs:20:9
    |
 LL |         (Foo, _) | (Ban, Foo) => {}
    |         ^^^^^^^^    --- variable not in all patterns
@@ -26,27 +26,6 @@ LL -         (Foo, _) | (Ban, Foo) => {}
 LL +         (Foo, _) | (Bar, Foo) => {}
    |
 
-error: variable `Ban` is assigned to, but never used
-  --> $DIR/binding-typo.rs:12:23
-   |
-LL |         (Foo, Bar) | (Ban, Foo) => {}
-   |                       ^^^
-   |
-   = note: consider using `_Ban` instead
-note: the lint level is defined here
-  --> $DIR/binding-typo.rs:3:9
-   |
-LL | #![deny(unused_variables)]
-   |         ^^^^^^^^^^^^^^^^
-
-error: variable `Ban` is assigned to, but never used
-  --> $DIR/binding-typo.rs:22:21
-   |
-LL |         (Foo, _) | (Ban, Foo) => {}
-   |                     ^^^
-   |
-   = note: consider using `_Ban` instead
-
-error: aborting due to 4 previous errors
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0408`.

From 3355f4bced511aba46c5a92ea82241b6713331ba Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sat, 30 Aug 2025 17:02:44 +0000
Subject: [PATCH 0354/1889] Suggest constant on unused binding in a pattern

```
error: unused variable: `Batery`
  --> $DIR/binding-typo-2.rs:110:9
   |
LL |         Batery => {}
   |         ^^^^^^
   |
help: if this is intentional, prefix it with an underscore
   |
LL |         _Batery => {}
   |         +
help: you might have meant to pattern match on the similarly named constant `Battery`
   |
LL |         Battery => {}
   |            +
```
---
 compiler/rustc_passes/src/liveness.rs      | 21 +++++++++-
 tests/ui/or-patterns/binding-typo-2.rs     | 11 ++++-
 tests/ui/or-patterns/binding-typo-2.stderr | 47 ++++++++++++++--------
 3 files changed, 59 insertions(+), 20 deletions(-)

diff --git a/compiler/rustc_passes/src/liveness.rs b/compiler/rustc_passes/src/liveness.rs
index 2ae68c445f8e8..b14482f65dc4f 100644
--- a/compiler/rustc_passes/src/liveness.rs
+++ b/compiler/rustc_passes/src/liveness.rs
@@ -1716,8 +1716,25 @@ impl<'tcx> Liveness<'_, 'tcx> {
                     }
                 }
             }
-            // FIXME(estebank): look for consts of the same type with similar names as well, not
-            // just unit structs and variants.
+            if typo.is_none() {
+                for (hir_id, _, span) in &hir_ids_and_spans {
+                    let ty = self.typeck_results.node_type(*hir_id);
+                    // Look for consts of the same type with similar names as well, not just unit
+                    // structs and variants.
+                    for def_id in self.ir.tcx.hir_body_owners() {
+                        if let DefKind::Const = self.ir.tcx.def_kind(def_id)
+                            && self.ir.tcx.type_of(def_id).instantiate_identity() == ty
+                        {
+                            typo = Some(errors::PatternTypo {
+                                span: *span,
+                                code: with_no_trimmed_paths!(self.ir.tcx.def_path_str(def_id)),
+                                kind: "constant".to_string(),
+                                item_name: self.ir.tcx.item_name(def_id).to_string(),
+                            });
+                        }
+                    }
+                }
+            }
             if is_assigned {
                 self.ir.tcx.emit_node_span_lint(
                     lint::builtin::UNUSED_VARIABLES,
diff --git a/tests/ui/or-patterns/binding-typo-2.rs b/tests/ui/or-patterns/binding-typo-2.rs
index d763ce60ce967..fe4a20536d790 100644
--- a/tests/ui/or-patterns/binding-typo-2.rs
+++ b/tests/ui/or-patterns/binding-typo-2.rs
@@ -5,6 +5,7 @@ enum Lol {
     Bar,
 }
 const Bat: () = ();
+const Battery: () = ();
 struct Bay;
 
 fn foo(x: (Lol, Lol)) {
@@ -62,8 +63,8 @@ fn foo(x: (Lol, Lol)) {
 }
 fn bar(x: (Lol, Lol)) {
     use Lol::*;
-    use Bat;
-    use Bay;
+    use ::Bat;
+    use ::Bay;
     match &x {
         (Foo, _) | (Ban, Foo) => {}
         //~^ ERROR: variable `Ban` is not bound in all patterns
@@ -105,6 +106,12 @@ fn baz(x: (Lol, Lol)) {
         //~| HELP: if this is intentional, prefix it with an underscore
         //~| HELP: you might have meant to pattern match on the similarly named
     }
+    match () {
+        Batery => {}
+        //~^ ERROR: unused variable: `Batery`
+        //~| HELP: if this is intentional, prefix it with an underscore
+        //~| HELP: you might have meant to pattern match on the similarly named constant
+    }
 }
 
 fn main() {
diff --git a/tests/ui/or-patterns/binding-typo-2.stderr b/tests/ui/or-patterns/binding-typo-2.stderr
index d683cb2b121cc..fc6d02d65a4e9 100644
--- a/tests/ui/or-patterns/binding-typo-2.stderr
+++ b/tests/ui/or-patterns/binding-typo-2.stderr
@@ -1,5 +1,5 @@
 error[E0408]: variable `Ban` is not bound in all patterns
-  --> $DIR/binding-typo-2.rs:13:9
+  --> $DIR/binding-typo-2.rs:14:9
    |
 LL |         (Foo, Bar) | (Ban, Foo) => {}
    |         ^^^^^^^^^^    --- variable not in all patterns
@@ -13,7 +13,7 @@ LL +         (Foo, Bar) | (Bar, Foo) => {}
    |
 
 error[E0408]: variable `Ban` is not bound in all patterns
-  --> $DIR/binding-typo-2.rs:24:9
+  --> $DIR/binding-typo-2.rs:25:9
    |
 LL |         (Foo, _) | (Ban, Foo) => {}
    |         ^^^^^^^^    --- variable not in all patterns
@@ -27,7 +27,7 @@ LL +         (Foo, _) | (Bar, Foo) => {}
    |
 
 error[E0408]: variable `Non` is not bound in all patterns
-  --> $DIR/binding-typo-2.rs:43:15
+  --> $DIR/binding-typo-2.rs:44:15
    |
 LL |         Non | None => {}
    |         ---   ^^^^ pattern doesn't bind `Non`
@@ -40,7 +40,7 @@ LL |         None | None => {}
    |            +
 
 error[E0408]: variable `Non` is not bound in all patterns
-  --> $DIR/binding-typo-2.rs:53:15
+  --> $DIR/binding-typo-2.rs:54:15
    |
 LL |         Non | Some(_) => {}
    |         ---   ^^^^^^^ pattern doesn't bind `Non`
@@ -54,7 +54,7 @@ LL +         core::option::Option::None | Some(_) => {}
    |
 
 error[E0408]: variable `Ban` is not bound in all patterns
-  --> $DIR/binding-typo-2.rs:68:9
+  --> $DIR/binding-typo-2.rs:69:9
    |
 LL |         (Foo, _) | (Ban, Foo) => {}
    |         ^^^^^^^^    --- variable not in all patterns
@@ -78,7 +78,7 @@ LL +         (Foo, _) | (Bat, Foo) => {}
    |
 
 error[E0408]: variable `Ban` is not bound in all patterns
-  --> $DIR/binding-typo-2.rs:85:9
+  --> $DIR/binding-typo-2.rs:86:9
    |
 LL |         (Foo, _) | (Ban, Foo) => {}
    |         ^^^^^^^^    --- variable not in all patterns
@@ -97,7 +97,7 @@ LL +         (Foo, _) | (Bat, Foo) => {}
    |
 
 error: variable `Ban` is assigned to, but never used
-  --> $DIR/binding-typo-2.rs:13:23
+  --> $DIR/binding-typo-2.rs:14:23
    |
 LL |         (Foo, Bar) | (Ban, Foo) => {}
    |                       ^^^
@@ -115,7 +115,7 @@ LL +         (Foo, Bar) | (Lol::Bar, Foo) => {}
    |
 
 error: variable `Ban` is assigned to, but never used
-  --> $DIR/binding-typo-2.rs:24:21
+  --> $DIR/binding-typo-2.rs:25:21
    |
 LL |         (Foo, _) | (Ban, Foo) => {}
    |                     ^^^
@@ -128,7 +128,7 @@ LL +         (Foo, _) | (Lol::Bar, Foo) => {}
    |
 
 error: unused variable: `Non`
-  --> $DIR/binding-typo-2.rs:36:9
+  --> $DIR/binding-typo-2.rs:37:9
    |
 LL |         Non => {}
    |         ^^^
@@ -144,7 +144,7 @@ LL +         std::prelude::v1::None => {}
    |
 
 error: unused variable: `Non`
-  --> $DIR/binding-typo-2.rs:43:9
+  --> $DIR/binding-typo-2.rs:44:9
    |
 LL |         Non | None => {}
    |         ^^^
@@ -160,7 +160,7 @@ LL +         std::prelude::v1::None | None => {}
    |
 
 error: unused variable: `Non`
-  --> $DIR/binding-typo-2.rs:53:9
+  --> $DIR/binding-typo-2.rs:54:9
    |
 LL |         Non | Some(_) => {}
    |         ^^^
@@ -176,7 +176,7 @@ LL +         std::prelude::v1::None | Some(_) => {}
    |
 
 error: variable `Ban` is assigned to, but never used
-  --> $DIR/binding-typo-2.rs:68:21
+  --> $DIR/binding-typo-2.rs:69:21
    |
 LL |         (Foo, _) | (Ban, Foo) => {}
    |                     ^^^
@@ -189,7 +189,7 @@ LL +         (Foo, _) | (Lol::Bar, Foo) => {}
    |
 
 error: variable `Ban` is assigned to, but never used
-  --> $DIR/binding-typo-2.rs:85:21
+  --> $DIR/binding-typo-2.rs:86:21
    |
 LL |         (Foo, _) | (Ban, Foo) => {}
    |                     ^^^
@@ -202,7 +202,7 @@ LL +         (Foo, _) | (Lol::Bar, Foo) => {}
    |
 
 error: unused variable: `Ban`
-  --> $DIR/binding-typo-2.rs:97:10
+  --> $DIR/binding-typo-2.rs:98:10
    |
 LL |         (Ban, _) => {}
    |          ^^^
@@ -218,7 +218,7 @@ LL +         (Lol::Bar, _) => {}
    |
 
 error: unused variable: `Ban`
-  --> $DIR/binding-typo-2.rs:103:9
+  --> $DIR/binding-typo-2.rs:104:9
    |
 LL |         Ban => {}
    |         ^^^
@@ -233,6 +233,21 @@ LL -         Ban => {}
 LL +         Bay => {}
    |
 
-error: aborting due to 15 previous errors
+error: unused variable: `Batery`
+  --> $DIR/binding-typo-2.rs:110:9
+   |
+LL |         Batery => {}
+   |         ^^^^^^
+   |
+help: if this is intentional, prefix it with an underscore
+   |
+LL |         _Batery => {}
+   |         +
+help: you might have meant to pattern match on the similarly named constant `Battery`
+   |
+LL |         Battery => {}
+   |            +
+
+error: aborting due to 16 previous errors
 
 For more information about this error, try `rustc --explain E0408`.

From 86085b4f65fae0ebc456202584e7e04b58a871f3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sat, 30 Aug 2025 17:44:23 +0000
Subject: [PATCH 0355/1889] Avoid unnecessary suggestion in or-pattern

---
 compiler/rustc_resolve/src/diagnostics.rs     | 42 +++++++++++--------
 tests/ui/or-patterns/binding-typo-2.rs        |  2 +-
 tests/ui/or-patterns/binding-typo-2.stderr    |  7 ++--
 .../mismatched-bindings-async-fn.stderr       | 24 -----------
 .../nested-undelimited-precedence.stderr      |  6 ---
 .../ui/resolve/resolve-inconsistent-names.rs  |  2 -
 .../resolve/resolve-inconsistent-names.stderr | 26 ++++--------
 7 files changed, 36 insertions(+), 73 deletions(-)

diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index beb882a325f5a..b7042045242f7 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -678,26 +678,32 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 for sp in &origin_sp {
                     err.subdiagnostic(errors::VariableNotInAllPatterns { span: *sp });
                 }
-                let mut target_visitor = BindingVisitor::default();
-                for pat in &target {
-                    target_visitor.visit_pat(pat);
-                }
-                target_visitor.identifiers.sort();
-                target_visitor.identifiers.dedup();
-                let mut origin_visitor = BindingVisitor::default();
-                for (_, pat) in &origin {
-                    origin_visitor.visit_pat(pat);
-                }
-                origin_visitor.identifiers.sort();
-                origin_visitor.identifiers.dedup();
-                // Find if the binding could have been a typo
                 let mut suggested_typo = false;
-                if let Some(typo) =
-                    find_best_match_for_name(&target_visitor.identifiers, name.name, None)
-                    && !origin_visitor.identifiers.contains(&typo)
+                if !target.iter().all(|pat| matches!(pat.kind, ast::PatKind::Ident(..)))
+                    && !origin.iter().all(|(_, pat)| matches!(pat.kind, ast::PatKind::Ident(..)))
                 {
-                    err.subdiagnostic(errors::PatternBindingTypo { spans: origin_sp, typo });
-                    suggested_typo = true;
+                    // The check above is so that when we encounter `match foo { (a | b) => {} }`,
+                    // we don't suggest `(a | a) => {}`, which would never be what the user wants.
+                    let mut target_visitor = BindingVisitor::default();
+                    for pat in &target {
+                        target_visitor.visit_pat(pat);
+                    }
+                    target_visitor.identifiers.sort();
+                    target_visitor.identifiers.dedup();
+                    let mut origin_visitor = BindingVisitor::default();
+                    for (_, pat) in &origin {
+                        origin_visitor.visit_pat(pat);
+                    }
+                    origin_visitor.identifiers.sort();
+                    origin_visitor.identifiers.dedup();
+                    // Find if the binding could have been a typo
+                    if let Some(typo) =
+                        find_best_match_for_name(&target_visitor.identifiers, name.name, None)
+                        && !origin_visitor.identifiers.contains(&typo)
+                    {
+                        err.subdiagnostic(errors::PatternBindingTypo { spans: origin_sp, typo });
+                        suggested_typo = true;
+                    }
                 }
                 if could_be_path {
                     let import_suggestions = self.lookup_import_candidates(
diff --git a/tests/ui/or-patterns/binding-typo-2.rs b/tests/ui/or-patterns/binding-typo-2.rs
index fe4a20536d790..275b68a22e22f 100644
--- a/tests/ui/or-patterns/binding-typo-2.rs
+++ b/tests/ui/or-patterns/binding-typo-2.rs
@@ -47,7 +47,7 @@ fn foo(x: (Lol, Lol)) {
         //~| ERROR: variable `Non` is not bound in all patterns [E0408]
         //~| NOTE: pattern doesn't bind `Non`
         //~| NOTE: variable not in all patterns
-        //~| HELP: you might have meant to use the similarly named previously used binding `None`
+        //~| HELP: you might have meant to use the similarly named unit variant `None`
         //~| HELP: you might have meant to pattern match on the similarly named
     }
     match Some(42) {
diff --git a/tests/ui/or-patterns/binding-typo-2.stderr b/tests/ui/or-patterns/binding-typo-2.stderr
index fc6d02d65a4e9..81ea6e6b1bc08 100644
--- a/tests/ui/or-patterns/binding-typo-2.stderr
+++ b/tests/ui/or-patterns/binding-typo-2.stderr
@@ -34,10 +34,11 @@ LL |         Non | None => {}
    |         |
    |         variable not in all patterns
    |
-help: you might have meant to use the similarly named previously used binding `None`
+help: you might have meant to use the similarly named unit variant `None`
+   |
+LL -         Non | None => {}
+LL +         core::option::Option::None | None => {}
    |
-LL |         None | None => {}
-   |            +
 
 error[E0408]: variable `Non` is not bound in all patterns
   --> $DIR/binding-typo-2.rs:54:15
diff --git a/tests/ui/or-patterns/mismatched-bindings-async-fn.stderr b/tests/ui/or-patterns/mismatched-bindings-async-fn.stderr
index 523cdf959e782..81602fffa8d07 100644
--- a/tests/ui/or-patterns/mismatched-bindings-async-fn.stderr
+++ b/tests/ui/or-patterns/mismatched-bindings-async-fn.stderr
@@ -5,12 +5,6 @@ LL | async fn a((x | s): String) {}
    |             ^   - variable not in all patterns
    |             |
    |             pattern doesn't bind `s`
-   |
-help: you might have meant to use the similarly named previously used binding `x`
-   |
-LL - async fn a((x | s): String) {}
-LL + async fn a((x | x): String) {}
-   |
 
 error[E0408]: variable `x` is not bound in all patterns
   --> $DIR/mismatched-bindings-async-fn.rs:4:17
@@ -19,12 +13,6 @@ LL | async fn a((x | s): String) {}
    |             -   ^ pattern doesn't bind `x`
    |             |
    |             variable not in all patterns
-   |
-help: you might have meant to use the similarly named previously used binding `s`
-   |
-LL - async fn a((x | s): String) {}
-LL + async fn a((s | s): String) {}
-   |
 
 error[E0408]: variable `s` is not bound in all patterns
   --> $DIR/mismatched-bindings-async-fn.rs:9:10
@@ -33,12 +21,6 @@ LL |     let (x | s) = String::new();
    |          ^   - variable not in all patterns
    |          |
    |          pattern doesn't bind `s`
-   |
-help: you might have meant to use the similarly named previously used binding `x`
-   |
-LL -     let (x | s) = String::new();
-LL +     let (x | x) = String::new();
-   |
 
 error[E0408]: variable `x` is not bound in all patterns
   --> $DIR/mismatched-bindings-async-fn.rs:9:14
@@ -47,12 +29,6 @@ LL |     let (x | s) = String::new();
    |          -   ^ pattern doesn't bind `x`
    |          |
    |          variable not in all patterns
-   |
-help: you might have meant to use the similarly named previously used binding `s`
-   |
-LL -     let (x | s) = String::new();
-LL +     let (s | s) = String::new();
-   |
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/or-patterns/nested-undelimited-precedence.stderr b/tests/ui/or-patterns/nested-undelimited-precedence.stderr
index 10dbc9d16c0e2..0835ca1929f15 100644
--- a/tests/ui/or-patterns/nested-undelimited-precedence.stderr
+++ b/tests/ui/or-patterns/nested-undelimited-precedence.stderr
@@ -60,12 +60,6 @@ LL |     let b @ A | B: E = A;
    |         -       ^ pattern doesn't bind `b`
    |         |
    |         variable not in all patterns
-   |
-help: you might have meant to use the similarly named previously used binding `B`
-   |
-LL -     let b @ A | B: E = A;
-LL +     let B @ A | B: E = A;
-   |
 
 error[E0308]: mismatched types
   --> $DIR/nested-undelimited-precedence.rs:34:9
diff --git a/tests/ui/resolve/resolve-inconsistent-names.rs b/tests/ui/resolve/resolve-inconsistent-names.rs
index bf74a4ba0f342..96504720e8395 100644
--- a/tests/ui/resolve/resolve-inconsistent-names.rs
+++ b/tests/ui/resolve/resolve-inconsistent-names.rs
@@ -12,8 +12,6 @@ fn main() {
     match y {
         a | b => {} //~  ERROR variable `a` is not bound in all patterns
         //~| ERROR variable `b` is not bound in all patterns
-        //~| HELP you might have meant to use the similarly named previously used binding `a`
-        //~| HELP you might have meant to use the similarly named previously used binding `b`
     }
 
     let x = (E::A, E::B);
diff --git a/tests/ui/resolve/resolve-inconsistent-names.stderr b/tests/ui/resolve/resolve-inconsistent-names.stderr
index 152c16ad404ef..d2333150961ac 100644
--- a/tests/ui/resolve/resolve-inconsistent-names.stderr
+++ b/tests/ui/resolve/resolve-inconsistent-names.stderr
@@ -5,12 +5,6 @@ LL |         a | b => {}
    |         ^   - variable not in all patterns
    |         |
    |         pattern doesn't bind `b`
-   |
-help: you might have meant to use the similarly named previously used binding `a`
-   |
-LL -         a | b => {}
-LL +         a | a => {}
-   |
 
 error[E0408]: variable `a` is not bound in all patterns
   --> $DIR/resolve-inconsistent-names.rs:13:13
@@ -19,15 +13,9 @@ LL |         a | b => {}
    |         -   ^ pattern doesn't bind `a`
    |         |
    |         variable not in all patterns
-   |
-help: you might have meant to use the similarly named previously used binding `b`
-   |
-LL -         a | b => {}
-LL +         b | b => {}
-   |
 
 error[E0408]: variable `c` is not bound in all patterns
-  --> $DIR/resolve-inconsistent-names.rs:21:9
+  --> $DIR/resolve-inconsistent-names.rs:19:9
    |
 LL |         (A, B) | (ref B, c) | (c, A) => ()
    |         ^^^^^^           -     - variable not in all patterns
@@ -36,7 +24,7 @@ LL |         (A, B) | (ref B, c) | (c, A) => ()
    |         pattern doesn't bind `c`
 
 error[E0408]: variable `A` is not bound in all patterns
-  --> $DIR/resolve-inconsistent-names.rs:21:18
+  --> $DIR/resolve-inconsistent-names.rs:19:18
    |
 LL |         (A, B) | (ref B, c) | (c, A) => ()
    |          -       ^^^^^^^^^^       - variable not in all patterns
@@ -50,7 +38,7 @@ LL |         (E::A, B) | (ref B, c) | (c, A) => ()
    |          +++
 
 error[E0408]: variable `B` is not bound in all patterns
-  --> $DIR/resolve-inconsistent-names.rs:21:31
+  --> $DIR/resolve-inconsistent-names.rs:19:31
    |
 LL |         (A, B) | (ref B, c) | (c, A) => ()
    |             -         -       ^^^^^^ pattern doesn't bind `B`
@@ -59,7 +47,7 @@ LL |         (A, B) | (ref B, c) | (c, A) => ()
    |             variable not in all patterns
 
 error[E0409]: variable `B` is bound inconsistently across alternatives separated by `|`
-  --> $DIR/resolve-inconsistent-names.rs:21:23
+  --> $DIR/resolve-inconsistent-names.rs:19:23
    |
 LL |         (A, B) | (ref B, c) | (c, A) => ()
    |             -         ^ bound in different ways
@@ -67,7 +55,7 @@ LL |         (A, B) | (ref B, c) | (c, A) => ()
    |             first binding
 
 error[E0408]: variable `Const2` is not bound in all patterns
-  --> $DIR/resolve-inconsistent-names.rs:33:9
+  --> $DIR/resolve-inconsistent-names.rs:31:9
    |
 LL |         (CONST1, _) | (_, Const2) => ()
    |         ^^^^^^^^^^^       ------ variable not in all patterns
@@ -80,7 +68,7 @@ LL |         (CONST1, _) | (_, m::Const2) => ()
    |                           +++
 
 error[E0408]: variable `CONST1` is not bound in all patterns
-  --> $DIR/resolve-inconsistent-names.rs:33:23
+  --> $DIR/resolve-inconsistent-names.rs:31:23
    |
 LL |         (CONST1, _) | (_, Const2) => ()
    |          ------       ^^^^^^^^^^^ pattern doesn't bind `CONST1`
@@ -94,7 +82,7 @@ LL |     const CONST1: usize = 10;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ not accessible
 
 error[E0308]: mismatched types
-  --> $DIR/resolve-inconsistent-names.rs:21:19
+  --> $DIR/resolve-inconsistent-names.rs:19:19
    |
 LL |     match x {
    |           - this expression has type `(E, E)`

From 04c6fb7a96f07d455c28be39a4854953a0c1ce6e Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sat, 30 Aug 2025 19:47:00 +0200
Subject: [PATCH 0356/1889] fix: `needless_for_each` suggests wrongly with
 explicit closure input types

---
 clippy_lints/src/needless_for_each.rs       | 36 ++++++++++++-------
 tests/ui/needless_for_each_unfixable.rs     | 19 +++++++++--
 tests/ui/needless_for_each_unfixable.stderr | 38 +++++++++++++++++++--
 3 files changed, 76 insertions(+), 17 deletions(-)

diff --git a/clippy_lints/src/needless_for_each.rs b/clippy_lints/src/needless_for_each.rs
index a67545e419ce7..3a6ccc2bca998 100644
--- a/clippy_lints/src/needless_for_each.rs
+++ b/clippy_lints/src/needless_for_each.rs
@@ -1,6 +1,6 @@
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{Visitor, walk_expr};
-use rustc_hir::{Block, BlockCheckMode, Closure, Expr, ExprKind, Stmt, StmtKind};
+use rustc_hir::{Block, BlockCheckMode, Closure, Expr, ExprKind, Stmt, StmtKind, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
 use rustc_span::Span;
@@ -70,12 +70,24 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessForEach {
             && has_iter_method(cx, cx.typeck_results().expr_ty(iter_recv)).is_some()
             // Skip the lint if the body is not block because this is simpler than `for` loop.
             // e.g. `v.iter().for_each(f)` is simpler and clearer than using `for` loop.
-            && let ExprKind::Closure(&Closure { body, .. }) = for_each_arg.kind
+            && let ExprKind::Closure(&Closure { body, fn_decl, .. }) = for_each_arg.kind
             && let body = cx.tcx.hir_body(body)
             // Skip the lint if the body is not safe, so as not to suggest `for … in … unsafe {}`
             // and suggesting `for … in … { unsafe { } }` is a little ugly.
             && !matches!(body.value.kind, ExprKind::Block(Block { rules: BlockCheckMode::UnsafeBlock(_), .. }, ..))
         {
+            let mut applicability = Applicability::MachineApplicable;
+
+            // If any closure parameter has an explicit type specified, applying the lint would necessarily
+            // remove that specification, possibly breaking type inference
+            if fn_decl
+                .inputs
+                .iter()
+                .any(|input| matches!(input.kind, TyKind::Infer(..)))
+            {
+                applicability = Applicability::MaybeIncorrect;
+            }
+
             let mut ret_collector = RetCollector::default();
             ret_collector.visit_expr(body.value);
 
@@ -84,18 +96,16 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessForEach {
                 return;
             }
 
-            let (mut applicability, ret_suggs) = if ret_collector.spans.is_empty() {
-                (Applicability::MachineApplicable, None)
+            let ret_suggs = if ret_collector.spans.is_empty() {
+                None
             } else {
-                (
-                    Applicability::MaybeIncorrect,
-                    Some(
-                        ret_collector
-                            .spans
-                            .into_iter()
-                            .map(|span| (span, "continue".to_string()))
-                            .collect(),
-                    ),
+                applicability = Applicability::MaybeIncorrect;
+                Some(
+                    ret_collector
+                        .spans
+                        .into_iter()
+                        .map(|span| (span, "continue".to_string()))
+                        .collect(),
                 )
             };
 
diff --git a/tests/ui/needless_for_each_unfixable.rs b/tests/ui/needless_for_each_unfixable.rs
index 159cbe49828f6..24ce5786b9104 100644
--- a/tests/ui/needless_for_each_unfixable.rs
+++ b/tests/ui/needless_for_each_unfixable.rs
@@ -1,6 +1,6 @@
 //@no-rustfix: overlapping suggestions
 #![warn(clippy::needless_for_each)]
-#![allow(clippy::needless_return, clippy::uninlined_format_args)]
+#![allow(clippy::needless_return)]
 
 fn main() {
     let v: Vec<i32> = Vec::new();
@@ -11,7 +11,22 @@ fn main() {
         if *v == 10 {
             return;
         } else {
-            println!("{}", v);
+            println!("{v}");
         }
     });
 }
+
+fn issue9912() {
+    let mut i = 0;
+    // Changing this to a `for` loop would break type inference
+    [].iter().for_each(move |_: &i32| {
+        //~^ needless_for_each
+        i += 1;
+    });
+
+    // Changing this would actually be okay, but we still suggest `MaybeIncorrect`ly
+    [1i32].iter().for_each(move |_: &i32| {
+        //~^ needless_for_each
+        i += 1;
+    });
+}
diff --git a/tests/ui/needless_for_each_unfixable.stderr b/tests/ui/needless_for_each_unfixable.stderr
index 3a3a240c5a3ab..6bc56db68a0ec 100644
--- a/tests/ui/needless_for_each_unfixable.stderr
+++ b/tests/ui/needless_for_each_unfixable.stderr
@@ -19,7 +19,7 @@ LL +
 LL +         if *v == 10 {
 LL +             return;
 LL +         } else {
-LL +             println!("{}", v);
+LL +             println!("{v}");
 LL +         }
 LL +     }
    |
@@ -29,5 +29,39 @@ LL -             return;
 LL +             continue;
    |
 
-error: aborting due to 1 previous error
+error: needless use of `for_each`
+  --> tests/ui/needless_for_each_unfixable.rs:22:5
+   |
+LL | /     [].iter().for_each(move |_: &i32| {
+LL | |
+LL | |         i += 1;
+LL | |     });
+   | |_______^
+   |
+help: try
+   |
+LL ~     for _ in [].iter() {
+LL +
+LL +         i += 1;
+LL +     }
+   |
+
+error: needless use of `for_each`
+  --> tests/ui/needless_for_each_unfixable.rs:28:5
+   |
+LL | /     [1i32].iter().for_each(move |_: &i32| {
+LL | |
+LL | |         i += 1;
+LL | |     });
+   | |_______^
+   |
+help: try
+   |
+LL ~     for _ in [1i32].iter() {
+LL +
+LL +         i += 1;
+LL +     }
+   |
+
+error: aborting due to 3 previous errors
 

From 823101e0895d4ce17576a2aa487ba6fe3e38ea69 Mon Sep 17 00:00:00 2001
From: Elliot Roberts <elliot0000101@gmail.com>
Date: Sat, 30 Aug 2025 13:36:29 -0700
Subject: [PATCH 0357/1889] Pass `--target` before `--` for `cargo rustc`

---
 .../project-model/src/toolchain_info/target_data_layout.rs | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/target_data_layout.rs b/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/target_data_layout.rs
index a28f468e692d0..f1d99cb8b002c 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/target_data_layout.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/target_data_layout.rs
@@ -23,14 +23,11 @@ pub fn get(
         QueryConfig::Cargo(sysroot, cargo_toml, _) => {
             let mut cmd = sysroot.tool(Tool::Cargo, cargo_toml.parent(), extra_env);
             cmd.env("RUSTC_BOOTSTRAP", "1");
-            cmd.args(["rustc", "-Z", "unstable-options"]).args(RUSTC_ARGS).args([
-                "--",
-                "-Z",
-                "unstable-options",
-            ]);
+            cmd.args(["rustc", "-Z", "unstable-options"]).args(RUSTC_ARGS);
             if let Some(target) = target {
                 cmd.args(["--target", target]);
             }
+            cmd.args(["--", "-Z", "unstable-options"]);
             match utf8_stdout(&mut cmd) {
                 Ok(output) => return process(output),
                 Err(e) => {

From ef94abd84d5140aeff1511f1303c80c8afd57332 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Sat, 30 Aug 2025 15:47:18 -0500
Subject: [PATCH 0358/1889] tidy: --bless now makes escheck run with --fix

---
 src/tools/tidy/src/extra_checks/mod.rs        |  2 +-
 src/tools/tidy/src/extra_checks/rustdoc_js.rs | 30 +++++++++++++------
 2 files changed, 22 insertions(+), 10 deletions(-)

diff --git a/src/tools/tidy/src/extra_checks/mod.rs b/src/tools/tidy/src/extra_checks/mod.rs
index 31169ec596775..7e0311e120694 100644
--- a/src/tools/tidy/src/extra_checks/mod.rs
+++ b/src/tools/tidy/src/extra_checks/mod.rs
@@ -303,7 +303,7 @@ fn check_impl(
     }
 
     if js_lint {
-        rustdoc_js::lint(outdir, librustdoc_path, tools_path)?;
+        rustdoc_js::lint(outdir, librustdoc_path, tools_path, bless)?;
         rustdoc_js::es_check(outdir, librustdoc_path)?;
     }
 
diff --git a/src/tools/tidy/src/extra_checks/rustdoc_js.rs b/src/tools/tidy/src/extra_checks/rustdoc_js.rs
index 7708b128e23d8..2e6821a41c707 100644
--- a/src/tools/tidy/src/extra_checks/rustdoc_js.rs
+++ b/src/tools/tidy/src/extra_checks/rustdoc_js.rs
@@ -40,13 +40,18 @@ fn rustdoc_js_files(librustdoc_path: &Path) -> Vec<PathBuf> {
     return files;
 }
 
-fn run_eslint(outdir: &Path, args: &[PathBuf], config_folder: PathBuf) -> Result<(), super::Error> {
-    let mut child = spawn_cmd(
-        Command::new(node_module_bin(outdir, "eslint"))
-            .arg("-c")
-            .arg(config_folder.join(".eslintrc.js"))
-            .args(args),
-    )?;
+fn run_eslint(
+    outdir: &Path,
+    args: &[PathBuf],
+    config_folder: PathBuf,
+    bless: bool,
+) -> Result<(), super::Error> {
+    let mut cmd = Command::new(node_module_bin(outdir, "eslint"));
+    if bless {
+        cmd.arg("--fix");
+    }
+    cmd.arg("-c").arg(config_folder.join(".eslintrc.js")).args(args);
+    let mut child = spawn_cmd(&mut cmd)?;
     match child.wait() {
         Ok(exit_status) => {
             if exit_status.success() {
@@ -62,16 +67,23 @@ pub(super) fn lint(
     outdir: &Path,
     librustdoc_path: &Path,
     tools_path: &Path,
+    bless: bool,
 ) -> Result<(), super::Error> {
     let files_to_check = rustdoc_js_files(librustdoc_path);
     println!("Running eslint on rustdoc JS files");
-    run_eslint(outdir, &files_to_check, librustdoc_path.join("html/static"))?;
+    run_eslint(outdir, &files_to_check, librustdoc_path.join("html/static"), bless)?;
 
-    run_eslint(outdir, &[tools_path.join("rustdoc-js/tester.js")], tools_path.join("rustdoc-js"))?;
+    run_eslint(
+        outdir,
+        &[tools_path.join("rustdoc-js/tester.js")],
+        tools_path.join("rustdoc-js"),
+        bless,
+    )?;
     run_eslint(
         outdir,
         &[tools_path.join("rustdoc-gui/tester.js")],
         tools_path.join("rustdoc-gui"),
+        bless,
     )?;
     Ok(())
 }

From f9a596795ad127f14ecf94d5a03481b495cc4f1c Mon Sep 17 00:00:00 2001
From: Alona Enraght-Moony <code@alona.page>
Date: Wed, 28 May 2025 21:20:41 +0100
Subject: [PATCH 0359/1889] Start documenting tests/rustdoc-json

---
 src/doc/rustc-dev-guide/src/compiler-src.md   |  4 +-
 .../rustdoc-json-test-suite.md                | 46 ++++++++++++++++++-
 2 files changed, 48 insertions(+), 2 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/compiler-src.md b/src/doc/rustc-dev-guide/src/compiler-src.md
index d67bacb1b3395..11b7e15e30d18 100644
--- a/src/doc/rustc-dev-guide/src/compiler-src.md
+++ b/src/doc/rustc-dev-guide/src/compiler-src.md
@@ -153,7 +153,8 @@ The bulk of [`rustdoc`] is in [`librustdoc`]. However, the [`rustdoc`] binary
 itself is [`src/tools/rustdoc`], which does nothing except call [`rustdoc::main`].
 
 There is also `JavaScript` and `CSS` for the docs in [`src/tools/rustdoc-js`]
-and [`src/tools/rustdoc-themes`].
+and [`src/tools/rustdoc-themes`]. The type definitions for `--output-format=json`
+are in a seperate crate in [`src/rustdoc-json-types`].
 
 You can read more about [`rustdoc`] in [this chapter][rustdoc-chapter].
 
@@ -162,6 +163,7 @@ You can read more about [`rustdoc`] in [this chapter][rustdoc-chapter].
 [`src/tools/rustdoc-js`]: https://github.com/rust-lang/rust/tree/master/src/tools/rustdoc-js
 [`src/tools/rustdoc-themes`]: https://github.com/rust-lang/rust/tree/master/src/tools/rustdoc-themes
 [`src/tools/rustdoc`]:  https://github.com/rust-lang/rust/tree/master/src/tools/rustdoc
+[`src/rustdoc-json-types`]: https://github.com/rust-lang/rust/tree/master/src/rustdoc-json-types
 [rustdoc-chapter]: ./rustdoc.md
 
 ## Tests
diff --git a/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-json-test-suite.md b/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-json-test-suite.md
index e08f77095069b..79b2ede61da6d 100644
--- a/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-json-test-suite.md
+++ b/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-json-test-suite.md
@@ -1,3 +1,47 @@
 # The `rustdoc-json` test suite
 
-> **FIXME**: This section is a stub. It will be populated by [PR #2422](https://github.com/rust-lang/rustc-dev-guide/pull/2422/).
+This page is specifically about the test suite named `rustdoc-json`, which tests rustdoc's [json output].
+For other test suites used for testing rustdoc, see [Rustdoc tests](../rustdoc.md#tests).
+
+Tests are run with compiletest, and have access to the usuall set of [directives](../tests/directives.md).
+Frequenly used directives here are:
+
+- [`//@ aux-build`][aux-build] to have dependencies.
+- `//@ edition: 2021` (or some other edition).
+- `//@ compile-flags: --document-hidden-items` to enable [document private items].
+
+Each crate's json output is checked by 2 programs: [jsondoclint] and [jsondocck].
+
+## jsondoclint
+
+[jsondoclint] checks that all [`Id`]s exist in the `index` (or `paths`).
+This makes sure their are no dangling [`Id`]s.
+
+<!-- TODO: It does some more things too?
+Also, talk about how it works
+ -->
+
+## jsondocck
+
+<!-- TODO: shlex, jsonpath, values, variables -->
+
+### Directives
+
+- `//@ has <path>`:: Checks `<path>` exists, i.e. matches at least 1 value.
+- `//@ !has <path>`:: Checks `<path>` doesn't exist, i.e. matches 0 values.
+- `//@ has <path> <value>`: Check `<path>` exists, and 1 of the matches is equal to the given `<value>` 
+- `//@ !has <path> <value>`: Checks `<path>` exists, but none of the matches equal the given `<value>`.
+- `//@ is <path> <value>`: Check `<path>` matches exacly one value, and it's equal to the given `<value>`.
+- `//@ is <path> <value> <value>...`: Check that `<path>` matches to exactly every given `<value>`. 
+   Ordering doesn't matter here.
+- `//@ !is <path> <value>`: Check `<path>` matches exactly one value, and that value is not equal to the given `<value>`.
+- `//@ count <path> <number>` Check that `<path>` matches to `<number>` of values.
+
+
+
+[json output]: https://doc.rust-lang.org/nightly/rustdoc/unstable-features.html#json-output
+[jsondocck]: https://github.com/rust-lang/rust/tree/master/src/tools/jsondocck
+[jsondoclint]: https://github.com/rust-lang/rust/tree/master/src/tools/jsondoclint
+[aux-build]: ../tests/compiletest.md#building-auxiliary-crates
+[`Id`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustdoc_json_types/struct.Id.html
+[document private items]: https://doc.rust-lang.org/nightly/rustdoc/command-line-arguments.html#--document-private-items-show-items-that-are-not-public

From 93e65927f483c6cb2a76eb5294b0014e6866b7a0 Mon Sep 17 00:00:00 2001
From: Alona Enraght-Moony <code@alona.page>
Date: Sat, 30 Aug 2025 23:50:23 +0100
Subject: [PATCH 0360/1889] More docs

---
 src/doc/rustc-dev-guide/src/compiler-src.md   |  2 +-
 .../rustdoc-json-test-suite.md                | 48 ++++++++++++++++---
 2 files changed, 43 insertions(+), 7 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/compiler-src.md b/src/doc/rustc-dev-guide/src/compiler-src.md
index 11b7e15e30d18..27b40f1fe0178 100644
--- a/src/doc/rustc-dev-guide/src/compiler-src.md
+++ b/src/doc/rustc-dev-guide/src/compiler-src.md
@@ -154,7 +154,7 @@ itself is [`src/tools/rustdoc`], which does nothing except call [`rustdoc::main`
 
 There is also `JavaScript` and `CSS` for the docs in [`src/tools/rustdoc-js`]
 and [`src/tools/rustdoc-themes`]. The type definitions for `--output-format=json`
-are in a seperate crate in [`src/rustdoc-json-types`].
+are in a separate crate in [`src/rustdoc-json-types`].
 
 You can read more about [`rustdoc`] in [this chapter][rustdoc-chapter].
 
diff --git a/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-json-test-suite.md b/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-json-test-suite.md
index 79b2ede61da6d..efc576cc90070 100644
--- a/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-json-test-suite.md
+++ b/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-json-test-suite.md
@@ -3,19 +3,19 @@
 This page is specifically about the test suite named `rustdoc-json`, which tests rustdoc's [json output].
 For other test suites used for testing rustdoc, see [Rustdoc tests](../rustdoc.md#tests).
 
-Tests are run with compiletest, and have access to the usuall set of [directives](../tests/directives.md).
+Tests are run with compiletest, and have access to the usual set of [directives](../tests/directives.md).
 Frequenly used directives here are:
 
 - [`//@ aux-build`][aux-build] to have dependencies.
 - `//@ edition: 2021` (or some other edition).
 - `//@ compile-flags: --document-hidden-items` to enable [document private items].
 
-Each crate's json output is checked by 2 programs: [jsondoclint] and [jsondocck].
+Each crate's json output is checked by 2 programs: [jsondoclint](#jsondocck) and [jsondocck](#jsondocck).
 
 ## jsondoclint
 
 [jsondoclint] checks that all [`Id`]s exist in the `index` (or `paths`).
-This makes sure their are no dangling [`Id`]s.
+This makes sure there are no dangling [`Id`]s.
 
 <!-- TODO: It does some more things too?
 Also, talk about how it works
@@ -23,21 +23,54 @@ Also, talk about how it works
 
 ## jsondocck
 
-<!-- TODO: shlex, jsonpath, values, variables -->
+[jsondocck] processes direcives given in comments, to assert that the values in the output are expected.
+It's alot like [htmldocck](./rustdoc-test-suite.md) in that way.
+
+It uses [JSONPath] as a query language, which takes a path, and returns a *list* of values that that path is said to match to.
 
 ### Directives
 
 - `//@ has <path>`:: Checks `<path>` exists, i.e. matches at least 1 value.
 - `//@ !has <path>`:: Checks `<path>` doesn't exist, i.e. matches 0 values.
-- `//@ has <path> <value>`: Check `<path>` exists, and 1 of the matches is equal to the given `<value>` 
+- `//@ has <path> <value>`: Check `<path>` exists, and at least 1 of the matches is equal to the given `<value>` 
 - `//@ !has <path> <value>`: Checks `<path>` exists, but none of the matches equal the given `<value>`.
-- `//@ is <path> <value>`: Check `<path>` matches exacly one value, and it's equal to the given `<value>`.
+- `//@ is <path> <value>`: Check `<path>` matches exactly one value, and it's equal to the given `<value>`.
 - `//@ is <path> <value> <value>...`: Check that `<path>` matches to exactly every given `<value>`. 
    Ordering doesn't matter here.
 - `//@ !is <path> <value>`: Check `<path>` matches exactly one value, and that value is not equal to the given `<value>`.
 - `//@ count <path> <number>` Check that `<path>` matches to `<number>` of values.
+- `//@ set <name> = <path>`, Check that `<path>` matches exactly one value, and store that value to the variable called `<name>`
+
+These are defined in [`directive.rs`].
+
+### Values
+
+Values can be either JSON values, or variables.
+
+- JSON values are JSON literals, e.g. `true`, `"string"`, `{"key": "value"}`. 
+  These often need to be quoted using `'`, to be processed as 1 value. See [§Argument spliting](#argument-spliting)
+- Variables can be used to store the value in one path, and use it in later queries.
+  They are set with the `//@ set <name> = <path>` directive, and accessed with `$<name>`
+
+  ```rust
+  //@ set foo = $some.path
+  //@ is $.some.other.path $foo
+  ```
+
+### Argument spliting
+
+Arguments to directives are split using the [shlex] crate, which implements POSIX shell escaping.
+This is because both `<path>` and `<value>` arguments to [directives](#directives) frequently have both
+whitespace and quote marks.
+
+To use the `@ is` with a `<path>` of `$.index[?(@.docs == "foo")].some.field` and a value of `"bar"` [^why quote], you'd write:
 
+```rust
+//@ is '$.is[?(@.docs == "foo")].some.field' '"bar"'
+```
 
+[^why quote]: The value needs to be `"bar"` *after* shlex splitting, because we
+    it needs to be a JSON string value.
 
 [json output]: https://doc.rust-lang.org/nightly/rustdoc/unstable-features.html#json-output
 [jsondocck]: https://github.com/rust-lang/rust/tree/master/src/tools/jsondocck
@@ -45,3 +78,6 @@ Also, talk about how it works
 [aux-build]: ../tests/compiletest.md#building-auxiliary-crates
 [`Id`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustdoc_json_types/struct.Id.html
 [document private items]: https://doc.rust-lang.org/nightly/rustdoc/command-line-arguments.html#--document-private-items-show-items-that-are-not-public
+[`directive.rs`]: https://github.com/rust-lang/rust/blob/master/src/tools/jsondocck/src/directive.rs
+[shlex]: https://docs.rs/shlex/1.3.0/shlex/index.html
+[JSONPath]: https://www.rfc-editor.org/rfc/rfc9535.html

From a7e32a5319f82c19f7c8024efd3afcc1825fa5e2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sun, 31 Aug 2025 00:42:58 +0000
Subject: [PATCH 0361/1889] Provide suggestion when encountering `match () { ()
 => 1 } + match () { () => 1 }`

```
error[E0308]: mismatched types
  --> $DIR/expr-as-stmt.rs:69:5
   |
LL |     match () { () => 1 } + match () { () => 1 }
   |     ^^^^^^^^^^^^^^^^^^^^ expected `()`, found integer
   |
help: consider using a semicolon here
   |
LL |     match () { () => 1 }; + match () { () => 1 }
   |                         +
help: alternatively, parentheses are required to parse this as an expression
   |
LL |     (match () { () => 1 }) + match () { () => 1 }
   |     +                    +
```

Parentheses are needed for the `match` to be unambiguously parsed as an expression and not a statement when chaining with binops that are also unops.
---
 compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs | 11 +++++++++++
 tests/ui/parser/expr-as-stmt.stderr             | 13 ++++++++++---
 tests/ui/suggestions/match-needing-semi.stderr  | 17 ++++++++++++++---
 3 files changed, 35 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
index 5aec50c8b5383..e70e444a53d91 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -1914,6 +1914,17 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 self.check_expr_has_type_or_error(expr, self.tcx.types.unit, |err| {
                     if expr.can_have_side_effects() {
                         self.suggest_semicolon_at_end(expr.span, err);
+                        if let hir::ExprKind::Match(..) = expr.kind {
+                            err.multipart_suggestion(
+                                "alternatively, parentheses are required to parse this as an \
+                                 expression",
+                                vec![
+                                    (expr.span.shrink_to_lo(), "(".to_string()),
+                                    (expr.span.shrink_to_hi(), ")".to_string()),
+                                ],
+                                Applicability::MaybeIncorrect,
+                            );
+                        }
                     }
                 });
             }
diff --git a/tests/ui/parser/expr-as-stmt.stderr b/tests/ui/parser/expr-as-stmt.stderr
index 577c3455a7180..562162ef3946d 100644
--- a/tests/ui/parser/expr-as-stmt.stderr
+++ b/tests/ui/parser/expr-as-stmt.stderr
@@ -227,9 +227,16 @@ error[E0308]: mismatched types
   --> $DIR/expr-as-stmt.rs:69:5
    |
 LL |     match () { () => 1 } + match () { () => 1 }
-   |     ^^^^^^^^^^^^^^^^^^^^- help: consider using a semicolon here
-   |     |
-   |     expected `()`, found integer
+   |     ^^^^^^^^^^^^^^^^^^^^ expected `()`, found integer
+   |
+help: consider using a semicolon here
+   |
+LL |     match () { () => 1 }; + match () { () => 1 }
+   |                         +
+help: alternatively, parentheses are required to parse this as an expression
+   |
+LL |     (match () { () => 1 }) + match () { () => 1 }
+   |     +                    +
 
 error[E0308]: mismatched types
   --> $DIR/expr-as-stmt.rs:75:14
diff --git a/tests/ui/suggestions/match-needing-semi.stderr b/tests/ui/suggestions/match-needing-semi.stderr
index b5f01d7038c0d..8f74997fdbee0 100644
--- a/tests/ui/suggestions/match-needing-semi.stderr
+++ b/tests/ui/suggestions/match-needing-semi.stderr
@@ -28,9 +28,20 @@ LL | |         4 => 1,
 LL | |         3 => 2,
 LL | |         _ => 2
 LL | |     }
-   | |     ^- help: consider using a semicolon here
-   | |_____|
-   |       expected `()`, found integer
+   | |_____^ expected `()`, found integer
+   |
+help: consider using a semicolon here
+   |
+LL |     };
+   |      +
+help: alternatively, parentheses are required to parse this as an expression
+   |
+LL ~     (match 3 {
+LL |         4 => 1,
+LL |         3 => 2,
+LL |         _ => 2
+LL ~     })
+   |
 
 error: aborting due to 2 previous errors
 

From f5b5e67f0f512d30cc6a5dab0ed6cf55c3905db5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sun, 31 Aug 2025 01:43:57 +0000
Subject: [PATCH 0362/1889] More targeted parentheses suggestion for match
 statement intended as expression

```
error[E0308]: mismatched types
  --> $DIR/expr-as-stmt.rs:69:5
   |
LL |     match () { () => 1 } + match () { () => 1 }
   |     ^^^^^^^^^^^^^^^^^^^^ expected `()`, found integer
   |
help: parentheses are required to parse this as an expression
   |
LL |     (match () { () => 1 }) + match () { () => 1 }
   |     +                    +
```
---
 .../rustc_hir_typeck/src/fn_ctxt/checks.rs    | 30 ++++++--
 tests/ui/parser/expr-as-stmt.fixed            | 11 ++-
 tests/ui/parser/expr-as-stmt.rs               |  9 +++
 tests/ui/parser/expr-as-stmt.stderr           | 75 +++++++++++++++++--
 .../ui/suggestions/match-needing-semi.stderr  | 17 +----
 5 files changed, 116 insertions(+), 26 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
index e70e444a53d91..33dc56d49b499 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -1913,17 +1913,37 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 // Check with expected type of `()`.
                 self.check_expr_has_type_or_error(expr, self.tcx.types.unit, |err| {
                     if expr.can_have_side_effects() {
-                        self.suggest_semicolon_at_end(expr.span, err);
-                        if let hir::ExprKind::Match(..) = expr.kind {
+                        let hir_id = stmt.hir_id;
+                        if let hir::ExprKind::Match(..) = expr.kind
+                            && let hir::Node::Block(b) = self.tcx.parent_hir_node(hir_id)
+                            && let mut stmts = b.stmts.iter().skip_while(|s| s.hir_id != hir_id)
+                            && let Some(_) = stmts.next() // The statement from the `match`
+                            && let Some(next) = match (stmts.next(), b.expr) {
+                                (Some(next), _) => match next.kind {
+                                    hir::StmtKind::Expr(next) | hir::StmtKind::Semi(next) => Some(next),
+                                    _ => None,
+                                },
+                                (None, Some(next)) => Some(next),
+                                _ => None,
+                            }
+                            && let hir::ExprKind::AddrOf(..)
+                                | hir::ExprKind::Unary(..)
+                                | hir::ExprKind::Err(_) = next.kind
+                        {
+                            // We have something like `match () { _ => true } && true`. Suggest
+                            // wrapping in parentheses. We find the statement or expression
+                            // following the `match` (`&& true`) and see if it is something that
+                            // can reasonably be interpreted as a binop following an expression.
                             err.multipart_suggestion(
-                                "alternatively, parentheses are required to parse this as an \
-                                 expression",
+                                "parentheses are required to parse this as an expression",
                                 vec![
                                     (expr.span.shrink_to_lo(), "(".to_string()),
                                     (expr.span.shrink_to_hi(), ")".to_string()),
                                 ],
-                                Applicability::MaybeIncorrect,
+                                Applicability::MachineApplicable,
                             );
+                        } else {
+                            self.suggest_semicolon_at_end(expr.span, err);
                         }
                     }
                 });
diff --git a/tests/ui/parser/expr-as-stmt.fixed b/tests/ui/parser/expr-as-stmt.fixed
index 0a4d62a4a0c8e..bfae55047ed1b 100644
--- a/tests/ui/parser/expr-as-stmt.fixed
+++ b/tests/ui/parser/expr-as-stmt.fixed
@@ -66,7 +66,7 @@ fn asteroids() -> impl FnOnce() -> bool {
 
 // https://github.com/rust-lang/rust/issues/105179
 fn r#match() -> i32 {
-    (match () { () => 1 }) + match () { () => 1 } //~ ERROR expected expression, found `+`
+    ((match () { () => 1 })) + match () { () => 1 } //~ ERROR expected expression, found `+`
     //~^ ERROR mismatched types
 }
 
@@ -76,4 +76,13 @@ fn r#unsafe() -> i32 {
     //~^ ERROR mismatched types
 }
 
+// https://github.com/rust-lang/rust/issues/88727
+fn matches() -> bool {
+    (match () { _ => true }) && match () { _ => true }; //~ ERROR mismatched types
+    (match () { _ => true }) && match () { _ => true }; //~ ERROR mismatched types
+    //~^ ERROR expected `;`, found keyword `match`
+    (match () { _ => true }) && true; //~ ERROR mismatched types
+    ((match () { _ => true })) && true //~ ERROR mismatched types
+    //~^ ERROR mismatched types
+}
 fn main() {}
diff --git a/tests/ui/parser/expr-as-stmt.rs b/tests/ui/parser/expr-as-stmt.rs
index 99c85e65baa55..94917432cb03a 100644
--- a/tests/ui/parser/expr-as-stmt.rs
+++ b/tests/ui/parser/expr-as-stmt.rs
@@ -76,4 +76,13 @@ fn r#unsafe() -> i32 {
     //~^ ERROR mismatched types
 }
 
+// https://github.com/rust-lang/rust/issues/88727
+fn matches() -> bool {
+    match () { _ => true } && match () { _ => true }; //~ ERROR mismatched types
+    match () { _ => true } && match () { _ => true } //~ ERROR mismatched types
+    //~^ ERROR expected `;`, found keyword `match`
+    match () { _ => true } && true; //~ ERROR mismatched types
+    match () { _ => true } && true //~ ERROR mismatched types
+    //~^ ERROR mismatched types
+}
 fn main() {}
diff --git a/tests/ui/parser/expr-as-stmt.stderr b/tests/ui/parser/expr-as-stmt.stderr
index 562162ef3946d..4681129babab0 100644
--- a/tests/ui/parser/expr-as-stmt.stderr
+++ b/tests/ui/parser/expr-as-stmt.stderr
@@ -77,6 +77,15 @@ help: parentheses are required to parse this as an expression
 LL |     (unsafe { 1 }) + unsafe { 1 }
    |     +            +
 
+error: expected `;`, found keyword `match`
+  --> $DIR/expr-as-stmt.rs:82:53
+   |
+LL |     match () { _ => true } && match () { _ => true }
+   |                                                     ^ help: add `;` here
+LL |
+LL |     match () { _ => true } && true;
+   |     ----- unexpected token
+
 error[E0308]: mismatched types
   --> $DIR/expr-as-stmt.rs:64:7
    |
@@ -229,11 +238,7 @@ error[E0308]: mismatched types
 LL |     match () { () => 1 } + match () { () => 1 }
    |     ^^^^^^^^^^^^^^^^^^^^ expected `()`, found integer
    |
-help: consider using a semicolon here
-   |
-LL |     match () { () => 1 }; + match () { () => 1 }
-   |                         +
-help: alternatively, parentheses are required to parse this as an expression
+help: parentheses are required to parse this as an expression
    |
 LL |     (match () { () => 1 }) + match () { () => 1 }
    |     +                    +
@@ -249,7 +254,65 @@ help: you might have meant to return this value
 LL |     unsafe { return 1; } + unsafe { 1 }
    |              ++++++  +
 
-error: aborting due to 22 previous errors
+error[E0308]: mismatched types
+  --> $DIR/expr-as-stmt.rs:81:5
+   |
+LL |     match () { _ => true } && match () { _ => true };
+   |     ^^^^^^^^^^^^^^^^^^^^^^ expected `()`, found `bool`
+   |
+help: parentheses are required to parse this as an expression
+   |
+LL |     (match () { _ => true }) && match () { _ => true };
+   |     +                      +
+
+error[E0308]: mismatched types
+  --> $DIR/expr-as-stmt.rs:82:5
+   |
+LL |     match () { _ => true } && match () { _ => true }
+   |     ^^^^^^^^^^^^^^^^^^^^^^ expected `()`, found `bool`
+   |
+help: parentheses are required to parse this as an expression
+   |
+LL |     (match () { _ => true }) && match () { _ => true }
+   |     +                      +
+
+error[E0308]: mismatched types
+  --> $DIR/expr-as-stmt.rs:84:5
+   |
+LL |     match () { _ => true } && true;
+   |     ^^^^^^^^^^^^^^^^^^^^^^ expected `()`, found `bool`
+   |
+help: parentheses are required to parse this as an expression
+   |
+LL |     (match () { _ => true }) && true;
+   |     +                      +
+
+error[E0308]: mismatched types
+  --> $DIR/expr-as-stmt.rs:85:5
+   |
+LL |     match () { _ => true } && true
+   |     ^^^^^^^^^^^^^^^^^^^^^^ expected `()`, found `bool`
+   |
+help: parentheses are required to parse this as an expression
+   |
+LL |     (match () { _ => true }) && true
+   |     +                      +
+
+error[E0308]: mismatched types
+  --> $DIR/expr-as-stmt.rs:85:28
+   |
+LL | fn matches() -> bool {
+   |                 ---- expected `bool` because of return type
+...
+LL |     match () { _ => true } && true
+   |                            ^^^^^^^ expected `bool`, found `&&bool`
+   |
+help: parentheses are required to parse this as an expression
+   |
+LL |     (match () { _ => true }) && true
+   |     +                      +
+
+error: aborting due to 28 previous errors
 
 Some errors have detailed explanations: E0308, E0600, E0614.
 For more information about an error, try `rustc --explain E0308`.
diff --git a/tests/ui/suggestions/match-needing-semi.stderr b/tests/ui/suggestions/match-needing-semi.stderr
index 8f74997fdbee0..b5f01d7038c0d 100644
--- a/tests/ui/suggestions/match-needing-semi.stderr
+++ b/tests/ui/suggestions/match-needing-semi.stderr
@@ -28,20 +28,9 @@ LL | |         4 => 1,
 LL | |         3 => 2,
 LL | |         _ => 2
 LL | |     }
-   | |_____^ expected `()`, found integer
-   |
-help: consider using a semicolon here
-   |
-LL |     };
-   |      +
-help: alternatively, parentheses are required to parse this as an expression
-   |
-LL ~     (match 3 {
-LL |         4 => 1,
-LL |         3 => 2,
-LL |         _ => 2
-LL ~     })
-   |
+   | |     ^- help: consider using a semicolon here
+   | |_____|
+   |       expected `()`, found integer
 
 error: aborting due to 2 previous errors
 

From de47decebbbd8645708a47a2a7c11c58a268ac87 Mon Sep 17 00:00:00 2001
From: Ali Nazzal <ali90h7@pm.me>
Date: Sun, 31 Aug 2025 09:51:47 +0300
Subject: [PATCH 0363/1889] docs(rustdoc): document that JS/TS checks run under
 tidy (eslint, es-check, tsc)

---
 src/doc/rustc-dev-guide/src/rustdoc.md | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/src/doc/rustc-dev-guide/src/rustdoc.md b/src/doc/rustc-dev-guide/src/rustdoc.md
index 9290fcd3b41cb..4181c2f7f170f 100644
--- a/src/doc/rustc-dev-guide/src/rustdoc.md
+++ b/src/doc/rustc-dev-guide/src/rustdoc.md
@@ -60,6 +60,18 @@ does is call the `main()` that's in this crate's `lib.rs`, though.)
 * Use `./x test tests/rustdoc*` to run the tests using a stage1
   rustdoc.
   * See [Rustdoc internals] for more information about tests.
+* Use `./x.py test tidy --extra-checks=js` to run rustdoc’s JavaScript checks (`eslint`, `es-check`, and `tsc`).
+> **Note:** `./x.py test tidy` already runs these checks automatically when JS/TS sources changed; `--extra-checks=js` forces them explicitly.
+
+### JavaScript CI checks
+
+Rustdoc’s JavaScript and TypeScript are checked during CI by `eslint`, `es-check`, and `tsc` (not by compiletest). These run as part of the `tidy` job.
+
+```bash
+./x.py test tidy --extra-checks=js
+```
+
+The `--extra-checks=js` flag enables the frontend linting that runs in CI.
 
 [`bootstrap.toml`]: ./building/how-to-build-and-run.md
 

From a44b180178b5d7787291df29f18d2495c0cad35b Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Sun, 31 Aug 2025 13:52:06 +0200
Subject: [PATCH 0364/1889] add `#[must_use]` to `array::repeat`

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

diff --git a/library/core/src/array/mod.rs b/library/core/src/array/mod.rs
index c4bb5ab7b219d..452ec95266fe3 100644
--- a/library/core/src/array/mod.rs
+++ b/library/core/src/array/mod.rs
@@ -48,6 +48,7 @@ pub use iter::IntoIter;
 /// assert_eq!(strings, ["Hello there!", "Hello there!"]);
 /// ```
 #[inline]
+#[must_use = "cloning is often expensive and is not expected to have side effects"]
 #[stable(feature = "array_repeat", since = "CURRENT_RUSTC_VERSION")]
 pub fn repeat<T: Clone, const N: usize>(val: T) -> [T; N] {
     from_trusted_iterator(repeat_n(val, N))

From fc3959044f628745e4c6899cb0fed6452e63905c Mon Sep 17 00:00:00 2001
From: Teodoro Freund <tfreund95@gmail.com>
Date: Tue, 1 Jul 2025 11:15:17 +0100
Subject: [PATCH 0365/1889] Supress excessive_precision when constants are
 overly precise

Added const associated items matching and static

Added configurable threshold

Addressed comments

Renamed lint config field
---
 CHANGELOG.md                                  |  1 +
 book/src/lint_configuration.md                | 10 +++
 clippy_config/src/conf.rs                     |  3 +
 clippy_lints/src/float_literal.rs             | 45 +++++++++-
 clippy_lints/src/lib.rs                       |  2 +-
 tests/ui-toml/excessive_precision/clippy.toml |  1 +
 .../excessive_precision.fixed                 | 38 +++++++++
 .../excessive_precision.rs                    | 38 +++++++++
 .../excessive_precision.stderr                | 38 +++++++++
 .../toml_unknown_key/conf_unknown_key.stderr  |  3 +
 tests/ui/excessive_precision.fixed            | 45 +++++++++-
 tests/ui/excessive_precision.rs               | 45 +++++++++-
 tests/ui/excessive_precision.stderr           | 85 +++++++++++++++----
 13 files changed, 330 insertions(+), 24 deletions(-)
 create mode 100644 tests/ui-toml/excessive_precision/clippy.toml
 create mode 100644 tests/ui-toml/excessive_precision/excessive_precision.fixed
 create mode 100644 tests/ui-toml/excessive_precision/excessive_precision.rs
 create mode 100644 tests/ui-toml/excessive_precision/excessive_precision.stderr

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 874002237d0c8..eb2a76a818369 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6712,6 +6712,7 @@ Released 2018-09-13
 [`check-inconsistent-struct-field-initializers`]: https://doc.rust-lang.org/clippy/lint_configuration.html#check-inconsistent-struct-field-initializers
 [`check-private-items`]: https://doc.rust-lang.org/clippy/lint_configuration.html#check-private-items
 [`cognitive-complexity-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#cognitive-complexity-threshold
+[`const-literal-digits-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#const-literal-digits-threshold
 [`disallowed-macros`]: https://doc.rust-lang.org/clippy/lint_configuration.html#disallowed-macros
 [`disallowed-methods`]: https://doc.rust-lang.org/clippy/lint_configuration.html#disallowed-methods
 [`disallowed-names`]: https://doc.rust-lang.org/clippy/lint_configuration.html#disallowed-names
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index d51467cbfae5a..c2d080cd96a1d 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -485,6 +485,16 @@ The maximum cognitive complexity a function can have
 * [`cognitive_complexity`](https://rust-lang.github.io/rust-clippy/master/index.html#cognitive_complexity)
 
 
+## `const-literal-digits-threshold`
+The minimum digits a const float literal must have to supress the `excessive_precicion` lint
+
+**Default Value:** `30`
+
+---
+**Affected lints:**
+* [`excessive_precision`](https://rust-lang.github.io/rust-clippy/master/index.html#excessive_precision)
+
+
 ## `disallowed-macros`
 The list of disallowed macros, written as fully qualified paths.
 
diff --git a/clippy_config/src/conf.rs b/clippy_config/src/conf.rs
index 365d664d75fef..2f28f6175ad82 100644
--- a/clippy_config/src/conf.rs
+++ b/clippy_config/src/conf.rs
@@ -570,6 +570,9 @@ define_Conf! {
     /// The maximum cognitive complexity a function can have
     #[lints(cognitive_complexity)]
     cognitive_complexity_threshold: u64 = 25,
+    /// The minimum digits a const float literal must have to supress the `excessive_precicion` lint
+    #[lints(excessive_precision)]
+    const_literal_digits_threshold: usize = 30,
     /// DEPRECATED LINT: CYCLOMATIC_COMPLEXITY.
     ///
     /// Use the Cognitive Complexity lint instead.
diff --git a/clippy_lints/src/float_literal.rs b/clippy_lints/src/float_literal.rs
index ccaf38aee4d88..6178addfff127 100644
--- a/clippy_lints/src/float_literal.rs
+++ b/clippy_lints/src/float_literal.rs
@@ -1,11 +1,12 @@
+use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::numeric_literal;
+use clippy_utils::{ExprUseNode, expr_use_ctxt, numeric_literal};
 use rustc_ast::ast::{LitFloatType, LitKind};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, FloatTy};
-use rustc_session::declare_lint_pass;
+use rustc_session::impl_lint_pass;
 use std::fmt;
 
 declare_clippy_lint! {
@@ -13,6 +14,8 @@ declare_clippy_lint! {
     /// Checks for float literals with a precision greater
     /// than that supported by the underlying type.
     ///
+    /// The lint is suppressed for literals with over `const_literal_digits_threshold` digits.
+    ///
     /// ### Why is this bad?
     /// Rust will truncate the literal silently.
     ///
@@ -58,7 +61,21 @@ declare_clippy_lint! {
     "lossy whole number float literals"
 }
 
-declare_lint_pass!(FloatLiteral => [EXCESSIVE_PRECISION, LOSSY_FLOAT_LITERAL]);
+pub struct FloatLiteral {
+    const_literal_digits_threshold: usize,
+}
+
+impl_lint_pass!(FloatLiteral => [
+    EXCESSIVE_PRECISION, LOSSY_FLOAT_LITERAL
+]);
+
+impl FloatLiteral {
+    pub fn new(conf: &'static Conf) -> Self {
+        Self {
+            const_literal_digits_threshold: conf.const_literal_digits_threshold,
+        }
+    }
+}
 
 impl<'tcx> LateLintPass<'tcx> for FloatLiteral {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
@@ -126,13 +143,25 @@ impl<'tcx> LateLintPass<'tcx> for FloatLiteral {
                         },
                     );
                 }
-            } else if digits > max as usize && count_digits(&float_str) < count_digits(sym_str) {
+            } else if digits > max as usize && count_digits(&float_str) < digits {
+                if digits >= self.const_literal_digits_threshold
+                    && matches!(expr_use_ctxt(cx, expr).use_node(cx), ExprUseNode::ConstStatic(_))
+                {
+                    // If a big enough number of digits is specified and it's a constant
+                    // we assume the user is definining a constant, and excessive precision is ok
+                    return;
+                }
                 span_lint_and_then(
                     cx,
                     EXCESSIVE_PRECISION,
                     expr.span,
                     "float has excessive precision",
                     |diag| {
+                        if digits >= self.const_literal_digits_threshold
+                            && let Some(let_stmt) = maybe_let_stmt(cx, expr)
+                        {
+                            diag.span_note(let_stmt.span, "consider making it a `const` item");
+                        }
                         diag.span_suggestion_verbose(
                             expr.span,
                             "consider changing the type or truncating it to",
@@ -196,3 +225,11 @@ impl FloatFormat {
         }
     }
 }
+
+fn maybe_let_stmt<'a>(cx: &LateContext<'a>, expr: &hir::Expr<'_>) -> Option<&'a hir::LetStmt<'a>> {
+    let parent = cx.tcx.parent_hir_node(expr.hir_id);
+    match parent {
+        hir::Node::LetStmt(let_stmt) => Some(let_stmt),
+        _ => None,
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 08b224367d752..0d7931aae765c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -475,7 +475,7 @@ pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Co
     store.register_late_pass(move |_| Box::new(types::Types::new(conf)));
     store.register_late_pass(move |_| Box::new(booleans::NonminimalBool::new(conf)));
     store.register_late_pass(|_| Box::new(enum_clike::UnportableVariant));
-    store.register_late_pass(|_| Box::new(float_literal::FloatLiteral));
+    store.register_late_pass(move |_| Box::new(float_literal::FloatLiteral::new(conf)));
     store.register_late_pass(|_| Box::new(ptr::Ptr));
     store.register_late_pass(|_| Box::new(needless_bool::NeedlessBool));
     store.register_late_pass(|_| Box::new(bool_comparison::BoolComparison));
diff --git a/tests/ui-toml/excessive_precision/clippy.toml b/tests/ui-toml/excessive_precision/clippy.toml
new file mode 100644
index 0000000000000..c7fc230dcb31c
--- /dev/null
+++ b/tests/ui-toml/excessive_precision/clippy.toml
@@ -0,0 +1 @@
+const-literal-digits-threshold = 20
diff --git a/tests/ui-toml/excessive_precision/excessive_precision.fixed b/tests/ui-toml/excessive_precision/excessive_precision.fixed
new file mode 100644
index 0000000000000..577bbff2957fb
--- /dev/null
+++ b/tests/ui-toml/excessive_precision/excessive_precision.fixed
@@ -0,0 +1,38 @@
+#![warn(clippy::excessive_precision)]
+#![allow(
+    dead_code,
+    overflowing_literals,
+    unused_variables,
+    clippy::print_literal,
+    clippy::useless_vec
+)]
+
+fn main() {
+    // Overly specified constants
+    let _: f32 = 1.012_345_7;
+    //~^ excessive_precision
+    let _: f64 = 1.012_345_678_901_234_6;
+    //~^ excessive_precision
+    const _: f32 = 1.012345678901234567890;
+    const _: f64 = 1.012345678901234567890;
+
+    static STATIC1: f32 = 1.012345678901234567890;
+    static STATIC2: f64 = 1.012345678901234567890;
+
+    static mut STATIC_MUT1: f32 = 1.012345678901234567890;
+    static mut STATIC_MUT2: f64 = 1.012345678901234567890;
+}
+
+trait ExcessivelyPreciseTrait {
+    // Overly specified constants
+    const GOOD1: f32 = 1.012345678901234567890;
+    const GOOD2: f64 = 1.012345678901234567890;
+}
+
+struct ExcessivelyPreciseStruct;
+
+impl ExcessivelyPreciseStruct {
+    // Overly specified constants
+    const GOOD1: f32 = 1.012345678901234567890;
+    const GOOD2: f64 = 1.012345678901234567890;
+}
diff --git a/tests/ui-toml/excessive_precision/excessive_precision.rs b/tests/ui-toml/excessive_precision/excessive_precision.rs
new file mode 100644
index 0000000000000..121448ed540dc
--- /dev/null
+++ b/tests/ui-toml/excessive_precision/excessive_precision.rs
@@ -0,0 +1,38 @@
+#![warn(clippy::excessive_precision)]
+#![allow(
+    dead_code,
+    overflowing_literals,
+    unused_variables,
+    clippy::print_literal,
+    clippy::useless_vec
+)]
+
+fn main() {
+    // Overly specified constants
+    let _: f32 = 1.012345678901234567890;
+    //~^ excessive_precision
+    let _: f64 = 1.012345678901234567890;
+    //~^ excessive_precision
+    const _: f32 = 1.012345678901234567890;
+    const _: f64 = 1.012345678901234567890;
+
+    static STATIC1: f32 = 1.012345678901234567890;
+    static STATIC2: f64 = 1.012345678901234567890;
+
+    static mut STATIC_MUT1: f32 = 1.012345678901234567890;
+    static mut STATIC_MUT2: f64 = 1.012345678901234567890;
+}
+
+trait ExcessivelyPreciseTrait {
+    // Overly specified constants
+    const GOOD1: f32 = 1.012345678901234567890;
+    const GOOD2: f64 = 1.012345678901234567890;
+}
+
+struct ExcessivelyPreciseStruct;
+
+impl ExcessivelyPreciseStruct {
+    // Overly specified constants
+    const GOOD1: f32 = 1.012345678901234567890;
+    const GOOD2: f64 = 1.012345678901234567890;
+}
diff --git a/tests/ui-toml/excessive_precision/excessive_precision.stderr b/tests/ui-toml/excessive_precision/excessive_precision.stderr
new file mode 100644
index 0000000000000..65d33eddef172
--- /dev/null
+++ b/tests/ui-toml/excessive_precision/excessive_precision.stderr
@@ -0,0 +1,38 @@
+error: float has excessive precision
+  --> tests/ui-toml/excessive_precision/excessive_precision.rs:12:18
+   |
+LL |     let _: f32 = 1.012345678901234567890;
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: consider making it a `const` item
+  --> tests/ui-toml/excessive_precision/excessive_precision.rs:12:5
+   |
+LL |     let _: f32 = 1.012345678901234567890;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = 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 -     let _: f32 = 1.012345678901234567890;
+LL +     let _: f32 = 1.012_345_7;
+   |
+
+error: float has excessive precision
+  --> tests/ui-toml/excessive_precision/excessive_precision.rs:14:18
+   |
+LL |     let _: f64 = 1.012345678901234567890;
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: consider making it a `const` item
+  --> tests/ui-toml/excessive_precision/excessive_precision.rs:14:5
+   |
+LL |     let _: f64 = 1.012345678901234567890;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: consider changing the type or truncating it to
+   |
+LL -     let _: f64 = 1.012345678901234567890;
+LL +     let _: f64 = 1.012_345_678_901_234_6;
+   |
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 6ee77ebd8ece2..20aeb4bb8498e 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -35,6 +35,7 @@ error: error reading Clippy's configuration file: unknown field `foobar`, expect
            check-inconsistent-struct-field-initializers
            check-private-items
            cognitive-complexity-threshold
+           const-literal-digits-threshold
            disallowed-macros
            disallowed-methods
            disallowed-names
@@ -129,6 +130,7 @@ error: error reading Clippy's configuration file: unknown field `barfoo`, expect
            check-inconsistent-struct-field-initializers
            check-private-items
            cognitive-complexity-threshold
+           const-literal-digits-threshold
            disallowed-macros
            disallowed-methods
            disallowed-names
@@ -223,6 +225,7 @@ error: error reading Clippy's configuration file: unknown field `allow_mixed_uni
            check-inconsistent-struct-field-initializers
            check-private-items
            cognitive-complexity-threshold
+           const-literal-digits-threshold
            disallowed-macros
            disallowed-methods
            disallowed-names
diff --git a/tests/ui/excessive_precision.fixed b/tests/ui/excessive_precision.fixed
index 8a8c2e1939c83..8158d4b332acd 100644
--- a/tests/ui/excessive_precision.fixed
+++ b/tests/ui/excessive_precision.fixed
@@ -4,9 +4,16 @@
     overflowing_literals,
     unused_variables,
     clippy::print_literal,
-    clippy::useless_vec
+    clippy::useless_vec,
+    clippy::approx_constant
 )]
 
+macro_rules! make_pi {
+    ($i:ident : $t:ty) => {
+        const $i: $t = 3.14159265358979323846264338327950288419716939937510582097494459230781640628;
+    };
+}
+
 fn main() {
     // Consts
     const GOOD32: f32 = 0.123_456;
@@ -101,4 +108,40 @@ fn main() {
     const _: f64 = 3.0;
     //~^ excessive_precision
     const _: f64 = 3.0000000000000000;
+
+    // Overly specified constants
+    let _: f32 = 1.012_345_7;
+    //~^ excessive_precision
+    let _: f64 = 1.012_345_678_901_234_6;
+    //~^ excessive_precision
+    const _: f32 = 1.01234567890123456789012345678901234567890;
+    const _: f64 = 1.01234567890123456789012345678901234567890;
+
+    static STATIC1: f32 = 1.01234567890123456789012345678901234567890;
+    static STATIC2: f64 = 1.01234567890123456789012345678901234567890;
+
+    static mut STATIC_MUT1: f32 = 1.01234567890123456789012345678901234567890;
+    static mut STATIC_MUT2: f64 = 1.01234567890123456789012345678901234567890;
+
+    // From issue #13855
+    let gamma = 0.577_215_664_901_532_9;
+    //~^ excessive_precision
+    const GAMMA: f64 = 0.5772156649015328606065120900824024310421;
+
+    make_pi!(P32: f32);
+    make_pi!(P64: f64);
+}
+
+trait ExcessivelyPreciseTrait {
+    // Overly specified constants
+    const GOOD1: f32 = 1.01234567890123456789012345678901234567890;
+    const GOOD2: f64 = 1.01234567890123456789012345678901234567890;
+}
+
+struct ExcessivelyPreciseStruct;
+
+impl ExcessivelyPreciseStruct {
+    // Overly specified constants
+    const GOOD1: f32 = 1.01234567890123456789012345678901234567890;
+    const GOOD2: f64 = 1.01234567890123456789012345678901234567890;
 }
diff --git a/tests/ui/excessive_precision.rs b/tests/ui/excessive_precision.rs
index 5dcf55cb92735..7ee6247ee5ac9 100644
--- a/tests/ui/excessive_precision.rs
+++ b/tests/ui/excessive_precision.rs
@@ -4,9 +4,16 @@
     overflowing_literals,
     unused_variables,
     clippy::print_literal,
-    clippy::useless_vec
+    clippy::useless_vec,
+    clippy::approx_constant
 )]
 
+macro_rules! make_pi {
+    ($i:ident : $t:ty) => {
+        const $i: $t = 3.14159265358979323846264338327950288419716939937510582097494459230781640628;
+    };
+}
+
 fn main() {
     // Consts
     const GOOD32: f32 = 0.123_456;
@@ -101,4 +108,40 @@ fn main() {
     const _: f64 = 3.0000000000000000e+00;
     //~^ excessive_precision
     const _: f64 = 3.0000000000000000;
+
+    // Overly specified constants
+    let _: f32 = 1.01234567890123456789012345678901234567890;
+    //~^ excessive_precision
+    let _: f64 = 1.01234567890123456789012345678901234567890;
+    //~^ excessive_precision
+    const _: f32 = 1.01234567890123456789012345678901234567890;
+    const _: f64 = 1.01234567890123456789012345678901234567890;
+
+    static STATIC1: f32 = 1.01234567890123456789012345678901234567890;
+    static STATIC2: f64 = 1.01234567890123456789012345678901234567890;
+
+    static mut STATIC_MUT1: f32 = 1.01234567890123456789012345678901234567890;
+    static mut STATIC_MUT2: f64 = 1.01234567890123456789012345678901234567890;
+
+    // From issue #13855
+    let gamma = 0.5772156649015328606065120900824024310421;
+    //~^ excessive_precision
+    const GAMMA: f64 = 0.5772156649015328606065120900824024310421;
+
+    make_pi!(P32: f32);
+    make_pi!(P64: f64);
+}
+
+trait ExcessivelyPreciseTrait {
+    // Overly specified constants
+    const GOOD1: f32 = 1.01234567890123456789012345678901234567890;
+    const GOOD2: f64 = 1.01234567890123456789012345678901234567890;
+}
+
+struct ExcessivelyPreciseStruct;
+
+impl ExcessivelyPreciseStruct {
+    // Overly specified constants
+    const GOOD1: f32 = 1.01234567890123456789012345678901234567890;
+    const GOOD2: f64 = 1.01234567890123456789012345678901234567890;
 }
diff --git a/tests/ui/excessive_precision.stderr b/tests/ui/excessive_precision.stderr
index f5eeadf0c8cb0..40806d67487fd 100644
--- a/tests/ui/excessive_precision.stderr
+++ b/tests/ui/excessive_precision.stderr
@@ -1,5 +1,5 @@
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:20:26
+  --> tests/ui/excessive_precision.rs:27:26
    |
 LL |     const BAD32_1: f32 = 0.123_456_789_f32;
    |                          ^^^^^^^^^^^^^^^^^
@@ -13,7 +13,7 @@ LL +     const BAD32_1: f32 = 0.123_456_79_f32;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:22:26
+  --> tests/ui/excessive_precision.rs:29:26
    |
 LL |     const BAD32_2: f32 = 0.123_456_789;
    |                          ^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     const BAD32_2: f32 = 0.123_456_79;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:24:26
+  --> tests/ui/excessive_precision.rs:31:26
    |
 LL |     const BAD32_3: f32 = 0.100_000_000_000_1;
    |                          ^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     const BAD32_3: f32 = 0.1;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:26:29
+  --> tests/ui/excessive_precision.rs:33:29
    |
 LL |     const BAD32_EDGE: f32 = 1.000_000_9;
    |                             ^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +     const BAD32_EDGE: f32 = 1.000_001;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:31:26
+  --> tests/ui/excessive_precision.rs:38:26
    |
 LL |     const BAD64_3: f64 = 0.100_000_000_000_000_000_1;
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL +     const BAD64_3: f64 = 0.1;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:35:22
+  --> tests/ui/excessive_precision.rs:42:22
    |
 LL |     println!("{:?}", 8.888_888_888_888_888_888_888);
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL +     println!("{:?}", 8.888_888_888_888_89);
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:47:22
+  --> tests/ui/excessive_precision.rs:54:22
    |
 LL |     let bad32: f32 = 1.123_456_789;
    |                      ^^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL +     let bad32: f32 = 1.123_456_8;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:49:26
+  --> tests/ui/excessive_precision.rs:56:26
    |
 LL |     let bad32_suf: f32 = 1.123_456_789_f32;
    |                          ^^^^^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL +     let bad32_suf: f32 = 1.123_456_8_f32;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:51:21
+  --> tests/ui/excessive_precision.rs:58:21
    |
 LL |     let bad32_inf = 1.123_456_789_f32;
    |                     ^^^^^^^^^^^^^^^^^
@@ -109,7 +109,7 @@ LL +     let bad32_inf = 1.123_456_8_f32;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:62:36
+  --> tests/ui/excessive_precision.rs:69:36
    |
 LL |     let bad_vec32: Vec<f32> = vec![0.123_456_789];
    |                                    ^^^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL +     let bad_vec32: Vec<f32> = vec![0.123_456_79];
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:64:36
+  --> tests/ui/excessive_precision.rs:71:36
    |
 LL |     let bad_vec64: Vec<f64> = vec![0.123_456_789_123_456_789];
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -133,7 +133,7 @@ LL +     let bad_vec64: Vec<f64> = vec![0.123_456_789_123_456_78];
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:69:24
+  --> tests/ui/excessive_precision.rs:76:24
    |
 LL |     let bad_e32: f32 = 1.123_456_788_888e-10;
    |                        ^^^^^^^^^^^^^^^^^^^^^
@@ -145,7 +145,7 @@ LL +     let bad_e32: f32 = 1.123_456_8e-10;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:73:27
+  --> tests/ui/excessive_precision.rs:80:27
    |
 LL |     let bad_bige32: f32 = 1.123_456_788_888E-10;
    |                           ^^^^^^^^^^^^^^^^^^^^^
@@ -157,7 +157,7 @@ LL +     let bad_bige32: f32 = 1.123_456_8E-10;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:86:13
+  --> tests/ui/excessive_precision.rs:93:13
    |
 LL |     let _ = 2.225_073_858_507_201_1e-308_f64;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -169,7 +169,7 @@ LL +     let _ = 2.225_073_858_507_201e-308_f64;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:90:13
+  --> tests/ui/excessive_precision.rs:97:13
    |
 LL |     let _ = 1.000_000_000_000_001e-324_f64;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -181,7 +181,7 @@ LL +     let _ = 0_f64;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:101:20
+  --> tests/ui/excessive_precision.rs:108:20
    |
 LL |     const _: f64 = 3.0000000000000000e+00;
    |                    ^^^^^^^^^^^^^^^^^^^^^^
@@ -192,5 +192,56 @@ LL -     const _: f64 = 3.0000000000000000e+00;
 LL +     const _: f64 = 3.0;
    |
 
-error: aborting due to 16 previous errors
+error: float has excessive precision
+  --> tests/ui/excessive_precision.rs:113:18
+   |
+LL |     let _: f32 = 1.01234567890123456789012345678901234567890;
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: consider making it a `const` item
+  --> tests/ui/excessive_precision.rs:113:5
+   |
+LL |     let _: f32 = 1.01234567890123456789012345678901234567890;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: consider changing the type or truncating it to
+   |
+LL -     let _: f32 = 1.01234567890123456789012345678901234567890;
+LL +     let _: f32 = 1.012_345_7;
+   |
+
+error: float has excessive precision
+  --> tests/ui/excessive_precision.rs:115:18
+   |
+LL |     let _: f64 = 1.01234567890123456789012345678901234567890;
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: consider making it a `const` item
+  --> tests/ui/excessive_precision.rs:115:5
+   |
+LL |     let _: f64 = 1.01234567890123456789012345678901234567890;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: consider changing the type or truncating it to
+   |
+LL -     let _: f64 = 1.01234567890123456789012345678901234567890;
+LL +     let _: f64 = 1.012_345_678_901_234_6;
+   |
+
+error: float has excessive precision
+  --> tests/ui/excessive_precision.rs:127:17
+   |
+LL |     let gamma = 0.5772156649015328606065120900824024310421;
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: consider making it a `const` item
+  --> tests/ui/excessive_precision.rs:127:5
+   |
+LL |     let gamma = 0.5772156649015328606065120900824024310421;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: consider changing the type or truncating it to
+   |
+LL -     let gamma = 0.5772156649015328606065120900824024310421;
+LL +     let gamma = 0.577_215_664_901_532_9;
+   |
+
+error: aborting due to 19 previous errors
 

From 23f1767c808d759ff683812581ca0e954d72c463 Mon Sep 17 00:00:00 2001
From: Kivooeo <Kivooeo123@gmail.com>
Date: Sun, 31 Aug 2025 17:03:46 +0000
Subject: [PATCH 0366/1889] allow taking address to union field

---
 .../rustc_mir_build/src/check_unsafety.rs     | 15 ++++
 .../miri/tests/pass/both_borrows/smallvec.rs  |  2 +-
 tests/ui/union/union-unsafe.rs                | 73 +++++++++++++++++++
 tests/ui/union/union-unsafe.stderr            | 54 +++++++++++---
 4 files changed, 132 insertions(+), 12 deletions(-)

diff --git a/compiler/rustc_mir_build/src/check_unsafety.rs b/compiler/rustc_mir_build/src/check_unsafety.rs
index b5e165c75170a..195d45c2c4c49 100644
--- a/compiler/rustc_mir_build/src/check_unsafety.rs
+++ b/compiler/rustc_mir_build/src/check_unsafety.rs
@@ -554,6 +554,21 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
                     visit::walk_expr(self, &self.thir[arg]);
                     return;
                 }
+
+                // Secondly, we allow raw borrows of union field accesses. Peel
+                // any of those off, and recurse normally on the LHS, which should
+                // reject any unsafe operations within.
+                let mut peeled = arg;
+                while let ExprKind::Scope { value: arg, .. } = self.thir[peeled].kind
+                    && let ExprKind::Field { lhs, name: _, variant_index: _ } = self.thir[arg].kind
+                    && let ty::Adt(def, _) = &self.thir[lhs].ty.kind()
+                    && def.is_union()
+                {
+                    peeled = lhs;
+                }
+                visit::walk_expr(self, &self.thir[peeled]);
+                // And return so we don't recurse directly onto the union field access(es).
+                return;
             }
             ExprKind::Deref { arg } => {
                 if let ExprKind::StaticRef { def_id, .. } | ExprKind::ThreadLocalRef(def_id) =
diff --git a/src/tools/miri/tests/pass/both_borrows/smallvec.rs b/src/tools/miri/tests/pass/both_borrows/smallvec.rs
index f48815e37be34..fa5cfb03de2a9 100644
--- a/src/tools/miri/tests/pass/both_borrows/smallvec.rs
+++ b/src/tools/miri/tests/pass/both_borrows/smallvec.rs
@@ -25,7 +25,7 @@ impl<T, const N: usize> RawSmallVec<T, N> {
     }
 
     const fn as_mut_ptr_inline(&mut self) -> *mut T {
-        (unsafe { &raw mut self.inline }) as *mut T
+        &raw mut self.inline as *mut T
     }
 
     const unsafe fn as_mut_ptr_heap(&mut self) -> *mut T {
diff --git a/tests/ui/union/union-unsafe.rs b/tests/ui/union/union-unsafe.rs
index bd3946686be36..beb074f4e8ebc 100644
--- a/tests/ui/union/union-unsafe.rs
+++ b/tests/ui/union/union-unsafe.rs
@@ -1,5 +1,6 @@
 use std::cell::RefCell;
 use std::mem::ManuallyDrop;
+use std::ops::Deref;
 
 union U1 {
     a: u8,
@@ -17,6 +18,10 @@ union U4<T: Copy> {
     a: T,
 }
 
+union U5 {
+    a: usize,
+}
+
 union URef {
     p: &'static mut i32,
 }
@@ -31,6 +36,20 @@ fn deref_union_field(mut u: URef) {
     *(u.p) = 13; //~ ERROR access to union field is unsafe
 }
 
+union A {
+    a: usize,
+    b: &'static &'static B,
+}
+
+union B {
+    c: usize,
+}
+
+fn raw_deref_union_field(mut u: URef) {
+    // This is unsafe because we first dereference u.p (reading uninitialized memory)
+    let _p = &raw const *(u.p); //~ ERROR access to union field is unsafe
+}
+
 fn assign_noncopy_union_field(mut u: URefCell) {
     u.a = (ManuallyDrop::new(RefCell::new(0)), 1); // OK (assignment does not drop)
     u.a.0 = ManuallyDrop::new(RefCell::new(0)); // OK (assignment does not drop)
@@ -57,6 +76,20 @@ fn main() {
     let a = u1.a; //~ ERROR access to union field is unsafe
     u1.a = 11; // OK
 
+    let mut u2 = U1 { a: 10 };
+    let a = &raw mut u2.a; // OK
+    unsafe { *a = 3 };
+
+    let mut u3 = U1 { a: 10 };
+    let a = std::ptr::addr_of_mut!(u3.a); // OK
+    unsafe { *a = 14 };
+
+    let u4 = U5 { a: 2 };
+    let vec = vec![1, 2, 3];
+    // This is unsafe because we read u4.a (potentially uninitialized memory)
+    // to use as an array index
+    let _a = &raw const vec[u4.a]; //~ ERROR access to union field is unsafe
+
     let U1 { a } = u1; //~ ERROR access to union field is unsafe
     if let U1 { a: 12 } = u1 {} //~ ERROR access to union field is unsafe
     if let Some(U1 { a: 13 }) = Some(u1) {} //~ ERROR access to union field is unsafe
@@ -73,4 +106,44 @@ fn main() {
     let mut u3 = U3 { a: ManuallyDrop::new(String::from("old")) }; // OK
     u3.a = ManuallyDrop::new(String::from("new")); // OK (assignment does not drop)
     *u3.a = String::from("new"); //~ ERROR access to union field is unsafe
+
+    let mut unions = [U1 { a: 1 }, U1 { a: 2 }];
+
+    // Array indexing + union field raw borrow - should be OK
+    let ptr = &raw mut unions[0].a; // OK
+    let ptr2 = &raw const unions[1].a; // OK
+
+    let a = A { a: 0 };
+    let _p = &raw const (**a.b).c; //~ ERROR access to union field is unsafe
+
+    arbitrary_deref();
+}
+
+// regression test for https://github.com/rust-lang/rust/pull/141469#discussion_r2312546218
+fn arbitrary_deref() {
+    use std::ops::Deref;
+
+    union A {
+        a: usize,
+        b: B,
+    }
+
+    #[derive(Copy, Clone)]
+    struct B(&'static str);
+
+    impl Deref for B {
+        type Target = C;
+
+        fn deref(&self) -> &C {
+            println!("{:?}", self.0);
+            &C { c: 0 }
+        }
+    }
+
+    union C {
+        c: usize,
+    }
+
+    let a = A { a: 0 };
+    let _p = &raw const (*a.b).c; //~ ERROR access to union field is unsafe
 }
diff --git a/tests/ui/union/union-unsafe.stderr b/tests/ui/union/union-unsafe.stderr
index 82b3f897167c7..01f4d95eb649d 100644
--- a/tests/ui/union/union-unsafe.stderr
+++ b/tests/ui/union/union-unsafe.stderr
@@ -1,5 +1,5 @@
 error[E0133]: access to union field is unsafe and requires unsafe function or block
-  --> $DIR/union-unsafe.rs:31:6
+  --> $DIR/union-unsafe.rs:36:6
    |
 LL |     *(u.p) = 13;
    |      ^^^^^ access to union field
@@ -7,7 +7,15 @@ LL |     *(u.p) = 13;
    = note: the field may not be properly initialized: using uninitialized data will cause undefined behavior
 
 error[E0133]: access to union field is unsafe and requires unsafe function or block
-  --> $DIR/union-unsafe.rs:43:6
+  --> $DIR/union-unsafe.rs:50:26
+   |
+LL |     let _p = &raw const *(u.p);
+   |                          ^^^^^ access to union field
+   |
+   = note: the field may not be properly initialized: using uninitialized data will cause undefined behavior
+
+error[E0133]: access to union field is unsafe and requires unsafe function or block
+  --> $DIR/union-unsafe.rs:62:6
    |
 LL |     *u3.a = T::default();
    |      ^^^^ access to union field
@@ -15,7 +23,7 @@ LL |     *u3.a = T::default();
    = note: the field may not be properly initialized: using uninitialized data will cause undefined behavior
 
 error[E0133]: access to union field is unsafe and requires unsafe function or block
-  --> $DIR/union-unsafe.rs:49:6
+  --> $DIR/union-unsafe.rs:68:6
    |
 LL |     *u3.a = T::default();
    |      ^^^^ access to union field
@@ -23,7 +31,7 @@ LL |     *u3.a = T::default();
    = note: the field may not be properly initialized: using uninitialized data will cause undefined behavior
 
 error[E0133]: access to union field is unsafe and requires unsafe function or block
-  --> $DIR/union-unsafe.rs:57:13
+  --> $DIR/union-unsafe.rs:76:13
    |
 LL |     let a = u1.a;
    |             ^^^^ access to union field
@@ -31,7 +39,15 @@ LL |     let a = u1.a;
    = note: the field may not be properly initialized: using uninitialized data will cause undefined behavior
 
 error[E0133]: access to union field is unsafe and requires unsafe function or block
-  --> $DIR/union-unsafe.rs:60:14
+  --> $DIR/union-unsafe.rs:91:29
+   |
+LL |     let _a = &raw const vec[u4.a];
+   |                             ^^^^ access to union field
+   |
+   = note: the field may not be properly initialized: using uninitialized data will cause undefined behavior
+
+error[E0133]: access to union field is unsafe and requires unsafe function or block
+  --> $DIR/union-unsafe.rs:93:14
    |
 LL |     let U1 { a } = u1;
    |              ^ access to union field
@@ -39,7 +55,7 @@ LL |     let U1 { a } = u1;
    = note: the field may not be properly initialized: using uninitialized data will cause undefined behavior
 
 error[E0133]: access to union field is unsafe and requires unsafe function or block
-  --> $DIR/union-unsafe.rs:61:20
+  --> $DIR/union-unsafe.rs:94:20
    |
 LL |     if let U1 { a: 12 } = u1 {}
    |                    ^^ access to union field
@@ -47,7 +63,7 @@ LL |     if let U1 { a: 12 } = u1 {}
    = note: the field may not be properly initialized: using uninitialized data will cause undefined behavior
 
 error[E0133]: access to union field is unsafe and requires unsafe function or block
-  --> $DIR/union-unsafe.rs:62:25
+  --> $DIR/union-unsafe.rs:95:25
    |
 LL |     if let Some(U1 { a: 13 }) = Some(u1) {}
    |                         ^^ access to union field
@@ -55,7 +71,7 @@ LL |     if let Some(U1 { a: 13 }) = Some(u1) {}
    = note: the field may not be properly initialized: using uninitialized data will cause undefined behavior
 
 error[E0133]: access to union field is unsafe and requires unsafe function or block
-  --> $DIR/union-unsafe.rs:67:6
+  --> $DIR/union-unsafe.rs:100:6
    |
 LL |     *u2.a = String::from("new");
    |      ^^^^ access to union field
@@ -63,7 +79,7 @@ LL |     *u2.a = String::from("new");
    = note: the field may not be properly initialized: using uninitialized data will cause undefined behavior
 
 error[E0133]: access to union field is unsafe and requires unsafe function or block
-  --> $DIR/union-unsafe.rs:71:6
+  --> $DIR/union-unsafe.rs:104:6
    |
 LL |     *u3.a = 1;
    |      ^^^^ access to union field
@@ -71,13 +87,29 @@ LL |     *u3.a = 1;
    = note: the field may not be properly initialized: using uninitialized data will cause undefined behavior
 
 error[E0133]: access to union field is unsafe and requires unsafe function or block
-  --> $DIR/union-unsafe.rs:75:6
+  --> $DIR/union-unsafe.rs:108:6
    |
 LL |     *u3.a = String::from("new");
    |      ^^^^ access to union field
    |
    = note: the field may not be properly initialized: using uninitialized data will cause undefined behavior
 
-error: aborting due to 10 previous errors
+error[E0133]: access to union field is unsafe and requires unsafe function or block
+  --> $DIR/union-unsafe.rs:117:28
+   |
+LL |     let _p = &raw const (**a.b).c;
+   |                            ^^^ access to union field
+   |
+   = note: the field may not be properly initialized: using uninitialized data will cause undefined behavior
+
+error[E0133]: access to union field is unsafe and requires unsafe function or block
+  --> $DIR/union-unsafe.rs:148:27
+   |
+LL |     let _p = &raw const (*a.b).c;
+   |                           ^^^ access to union field
+   |
+   = note: the field may not be properly initialized: using uninitialized data will cause undefined behavior
+
+error: aborting due to 14 previous errors
 
 For more information about this error, try `rustc --explain E0133`.

From fbd8b96a1264cbb4eed65f2c2e8b86c882f4305e Mon Sep 17 00:00:00 2001
From: Nia Espera <nia-e@haecceity.cc>
Date: Sun, 31 Aug 2025 14:00:13 +0200
Subject: [PATCH 0367/1889] native-lib: more resilient grabbing of instruction
 bytes

Co-authored-by: Ralf Jung <post@ralfj.de>
---
 .../miri/src/shims/native_lib/trace/parent.rs | 52 +++++++++----------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/src/tools/miri/src/shims/native_lib/trace/parent.rs b/src/tools/miri/src/shims/native_lib/trace/parent.rs
index acb94395b57a7..3ae98259ab35b 100644
--- a/src/tools/miri/src/shims/native_lib/trace/parent.rs
+++ b/src/tools/miri/src/shims/native_lib/trace/parent.rs
@@ -18,6 +18,11 @@ const ARCH_WORD_SIZE: usize = 4;
 #[cfg(target_arch = "x86_64")]
 const ARCH_WORD_SIZE: usize = 8;
 
+// x86 max instruction length is 15 bytes:
+// https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html
+// See vol. 3B section 24.25.
+const ARCH_MAX_INSTR_SIZE: usize = 15;
+
 /// The address of the page set to be edited, initialised to a sentinel null
 /// pointer.
 static PAGE_ADDR: AtomicPtr<u8> = AtomicPtr::new(std::ptr::null_mut());
@@ -472,7 +477,27 @@ fn handle_segfault(
     let stack_ptr = ch_stack.strict_add(CALLBACK_STACK_SIZE / 2);
     let regs_bak = ptrace::getregs(pid).unwrap();
     let mut new_regs = regs_bak;
-    let ip_prestep = regs_bak.ip();
+
+    // Read at least one instruction from the ip. It's possible that the instruction
+    // that triggered the segfault was short and at the end of the mapped text area,
+    // so some of these reads may fail; in that case, just write empty bytes. If all
+    // reads failed, the disassembler will report an error.
+    let instr = (0..(ARCH_MAX_INSTR_SIZE.div_ceil(ARCH_WORD_SIZE)))
+        .flat_map(|ofs| {
+            // This reads one word of memory; we divided by `ARCH_WORD_SIZE` above to compensate for that.
+            ptrace::read(
+                pid,
+                std::ptr::without_provenance_mut(
+                    regs_bak.ip().strict_add(ARCH_WORD_SIZE.strict_mul(ofs)),
+                ),
+            )
+            .unwrap_or_default()
+            .to_ne_bytes()
+        })
+        .collect::<Vec<_>>();
+
+    // Now figure out the size + type of access and log it down.
+    capstone_disassemble(&instr, addr, cs, acc_events).expect("Failed to disassemble instruction");
 
     // Move the instr ptr into the deprotection code.
     #[expect(clippy::as_conversions)]
@@ -512,33 +537,8 @@ fn handle_segfault(
         ptrace::write(pid, std::ptr::with_exposed_provenance_mut(a), 0).unwrap();
     }
 
-    // Save registers and grab the bytes that were executed. This would
-    // be really nasty if it was a jump or similar but those thankfully
-    // won't do memory accesses and so can't trigger this!
     let regs_bak = ptrace::getregs(pid).unwrap();
     new_regs = regs_bak;
-    let ip_poststep = regs_bak.ip();
-
-    // Ensure that we've actually gone forwards.
-    assert!(ip_poststep > ip_prestep);
-    // But not by too much. 64 bytes should be "big enough" on ~any architecture.
-    assert!(ip_prestep.strict_add(64) > ip_poststep);
-
-    // We need to do reads/writes in word-sized chunks.
-    let diff = (ip_poststep.strict_sub(ip_prestep)).div_ceil(ARCH_WORD_SIZE);
-    let instr = (ip_prestep..ip_prestep.strict_add(diff)).fold(vec![], |mut ret, ip| {
-        // This only needs to be a valid pointer in the child process, not ours.
-        ret.append(
-            &mut ptrace::read(pid, std::ptr::without_provenance_mut(ip))
-                .unwrap()
-                .to_ne_bytes()
-                .to_vec(),
-        );
-        ret
-    });
-
-    // Now figure out the size + type of access and log it down.
-    capstone_disassemble(&instr, addr, cs, acc_events).expect("Failed to disassemble instruction");
 
     // Reprotect everything and continue.
     #[expect(clippy::as_conversions)]

From 4dbadd05f853414501401984e7888564df7291d4 Mon Sep 17 00:00:00 2001
From: Nia Espera <a5b6@riseup.net>
Date: Sun, 13 Jul 2025 18:40:27 +0200
Subject: [PATCH 0368/1889] native-lib: pass structs to native code

---
 src/tools/miri/Cargo.toml                     |   2 +-
 src/tools/miri/src/shims/native_lib/ffi.rs    |  54 ++++
 src/tools/miri/src/shims/native_lib/mod.rs    | 305 ++++++++++--------
 .../tests/native-lib/aggregate_arguments.c    |  42 +++
 .../native-lib/fail/multi_struct_alloc.rs     |  21 ++
 .../native-lib/fail/multi_struct_alloc.stderr |  15 +
 .../native-lib/fail/struct_not_extern_c.rs    |  19 ++
 .../fail/struct_not_extern_c.stderr           |  14 +
 .../tests/native-lib/fail/uninit_struct.rs    |  27 ++
 .../native-lib/fail/uninit_struct.stderr      |  15 +
 .../native-lib/pass/aggregate_arguments.rs    |  51 +++
 .../tests/native-lib/pass/ptr_read_access.rs  |  20 ++
 .../miri/tests/native-lib/ptr_read_access.c   |  10 +
 src/tools/miri/tests/ui.rs                    |   1 +
 14 files changed, 467 insertions(+), 129 deletions(-)
 create mode 100644 src/tools/miri/src/shims/native_lib/ffi.rs
 create mode 100644 src/tools/miri/tests/native-lib/aggregate_arguments.c
 create mode 100644 src/tools/miri/tests/native-lib/fail/multi_struct_alloc.rs
 create mode 100644 src/tools/miri/tests/native-lib/fail/multi_struct_alloc.stderr
 create mode 100644 src/tools/miri/tests/native-lib/fail/struct_not_extern_c.rs
 create mode 100644 src/tools/miri/tests/native-lib/fail/struct_not_extern_c.stderr
 create mode 100644 src/tools/miri/tests/native-lib/fail/uninit_struct.rs
 create mode 100644 src/tools/miri/tests/native-lib/fail/uninit_struct.stderr
 create mode 100644 src/tools/miri/tests/native-lib/pass/aggregate_arguments.rs

diff --git a/src/tools/miri/Cargo.toml b/src/tools/miri/Cargo.toml
index 99111092d39e7..924dfed2bcab4 100644
--- a/src/tools/miri/Cargo.toml
+++ b/src/tools/miri/Cargo.toml
@@ -39,7 +39,7 @@ features = ['unprefixed_malloc_on_supported_platforms']
 [target.'cfg(unix)'.dependencies]
 libc = "0.2"
 # native-lib dependencies
-libffi = { version = "4.0.0", optional = true }
+libffi = { version = "4.1.1", optional = true }
 libloading = { version = "0.8", optional = true }
 serde = { version = "1.0.219", features = ["derive"], optional = true }
 
diff --git a/src/tools/miri/src/shims/native_lib/ffi.rs b/src/tools/miri/src/shims/native_lib/ffi.rs
new file mode 100644
index 0000000000000..b2615cedaeab5
--- /dev/null
+++ b/src/tools/miri/src/shims/native_lib/ffi.rs
@@ -0,0 +1,54 @@
+use libffi::low::CodePtr;
+use libffi::middle::{Arg as ArgPtr, Cif, Type as FfiType};
+
+/// Perform the actual FFI call.
+///
+/// SAFETY: The safety invariants of the foreign function being called must be
+/// upheld (if any).
+pub unsafe fn call<R: libffi::high::CType>(fun: CodePtr, args: &mut [OwnedArg]) -> R {
+    let mut arg_tys = vec![];
+    let mut arg_ptrs = vec![];
+    for arg in args {
+        arg_tys.push(arg.take_ty());
+        arg_ptrs.push(arg.ptr())
+    }
+    let cif = Cif::new(arg_tys, R::reify().into_middle());
+    // SAFETY: Caller upholds that the function is safe to call, and since we
+    // were passed a slice reference we know the `OwnedArg`s won't have been
+    // dropped by this point.
+    unsafe { cif.call(fun, &arg_ptrs) }
+}
+
+/// An argument for an FFI call.
+#[derive(Debug, Clone)]
+pub struct OwnedArg {
+    /// The type descriptor for this argument.
+    ty: Option<FfiType>,
+    /// Corresponding bytes for the value.
+    bytes: Box<[u8]>,
+}
+
+impl OwnedArg {
+    /// Instantiates an argument from a type descriptor and bytes.
+    pub fn new(ty: FfiType, bytes: Box<[u8]>) -> Self {
+        Self { ty: Some(ty), bytes }
+    }
+
+    /// Gets the libffi type descriptor for this argument. Should only be
+    /// called once on a given `OwnedArg`.
+    fn take_ty(&mut self) -> FfiType {
+        self.ty.take().unwrap()
+    }
+
+    /// Instantiates a libffi argument pointer pointing to this argument's bytes.
+    /// NB: Since `libffi::middle::Arg` ignores the lifetime of the reference
+    /// it's derived from, it is up to the caller to ensure the `OwnedArg` is
+    /// not dropped before unsafely calling `libffi::middle::Cif::call()`!
+    fn ptr(&self) -> ArgPtr {
+        // FIXME: Using `&self.bytes[0]` to reference the whole array is
+        // definitely unsound under SB, but we're waiting on
+        // https://github.com/libffi-rs/libffi-rs/commit/112a37b3b6ffb35bd75241fbcc580de40ba74a73
+        // to land in a release so that we don't need to do this.
+        ArgPtr::new(&self.bytes[0])
+    }
+}
diff --git a/src/tools/miri/src/shims/native_lib/mod.rs b/src/tools/miri/src/shims/native_lib/mod.rs
index 74b9b704fea5e..156d6171c73c8 100644
--- a/src/tools/miri/src/shims/native_lib/mod.rs
+++ b/src/tools/miri/src/shims/native_lib/mod.rs
@@ -2,14 +2,15 @@
 
 use std::ops::Deref;
 
-use libffi::high::call as ffi;
 use libffi::low::CodePtr;
-use rustc_abi::{BackendRepr, HasDataLayout, Size};
-use rustc_middle::mir::interpret::Pointer;
-use rustc_middle::ty::{self as ty, IntTy, UintTy};
+use libffi::middle::Type as FfiType;
+use rustc_abi::{HasDataLayout, Size};
+use rustc_middle::ty::{self as ty, IntTy, Ty, UintTy};
 use rustc_span::Symbol;
 use serde::{Deserialize, Serialize};
 
+mod ffi;
+
 #[cfg_attr(
     not(all(
         target_os = "linux",
@@ -20,6 +21,7 @@ use serde::{Deserialize, Serialize};
 )]
 pub mod trace;
 
+use self::ffi::OwnedArg;
 use crate::*;
 
 /// The final results of an FFI trace, containing every relevant event detected
@@ -70,12 +72,12 @@ impl AccessRange {
 impl<'tcx> EvalContextExtPriv<'tcx> for crate::MiriInterpCx<'tcx> {}
 trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
     /// Call native host function and return the output as an immediate.
-    fn call_native_with_args<'a>(
+    fn call_native_with_args(
         &mut self,
         link_name: Symbol,
         dest: &MPlaceTy<'tcx>,
         ptr: CodePtr,
-        libffi_args: Vec<libffi::high::Arg<'a>>,
+        libffi_args: &mut [OwnedArg],
     ) -> InterpResult<'tcx, (crate::ImmTy<'tcx>, Option<MemEvents>)> {
         let this = self.eval_context_mut();
         #[cfg(target_os = "linux")]
@@ -93,55 +95,55 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     // Unsafe because of the call to native code.
                     // Because this is calling a C function it is not necessarily sound,
                     // but there is no way around this and we've checked as much as we can.
-                    let x = unsafe { ffi::call::<i8>(ptr, libffi_args.as_slice()) };
+                    let x = unsafe { ffi::call::<i8>(ptr, libffi_args) };
                     Scalar::from_i8(x)
                 }
                 ty::Int(IntTy::I16) => {
-                    let x = unsafe { ffi::call::<i16>(ptr, libffi_args.as_slice()) };
+                    let x = unsafe { ffi::call::<i16>(ptr, libffi_args) };
                     Scalar::from_i16(x)
                 }
                 ty::Int(IntTy::I32) => {
-                    let x = unsafe { ffi::call::<i32>(ptr, libffi_args.as_slice()) };
+                    let x = unsafe { ffi::call::<i32>(ptr, libffi_args) };
                     Scalar::from_i32(x)
                 }
                 ty::Int(IntTy::I64) => {
-                    let x = unsafe { ffi::call::<i64>(ptr, libffi_args.as_slice()) };
+                    let x = unsafe { ffi::call::<i64>(ptr, libffi_args) };
                     Scalar::from_i64(x)
                 }
                 ty::Int(IntTy::Isize) => {
-                    let x = unsafe { ffi::call::<isize>(ptr, libffi_args.as_slice()) };
+                    let x = unsafe { ffi::call::<isize>(ptr, libffi_args) };
                     Scalar::from_target_isize(x.try_into().unwrap(), this)
                 }
                 // uints
                 ty::Uint(UintTy::U8) => {
-                    let x = unsafe { ffi::call::<u8>(ptr, libffi_args.as_slice()) };
+                    let x = unsafe { ffi::call::<u8>(ptr, libffi_args) };
                     Scalar::from_u8(x)
                 }
                 ty::Uint(UintTy::U16) => {
-                    let x = unsafe { ffi::call::<u16>(ptr, libffi_args.as_slice()) };
+                    let x = unsafe { ffi::call::<u16>(ptr, libffi_args) };
                     Scalar::from_u16(x)
                 }
                 ty::Uint(UintTy::U32) => {
-                    let x = unsafe { ffi::call::<u32>(ptr, libffi_args.as_slice()) };
+                    let x = unsafe { ffi::call::<u32>(ptr, libffi_args) };
                     Scalar::from_u32(x)
                 }
                 ty::Uint(UintTy::U64) => {
-                    let x = unsafe { ffi::call::<u64>(ptr, libffi_args.as_slice()) };
+                    let x = unsafe { ffi::call::<u64>(ptr, libffi_args) };
                     Scalar::from_u64(x)
                 }
                 ty::Uint(UintTy::Usize) => {
-                    let x = unsafe { ffi::call::<usize>(ptr, libffi_args.as_slice()) };
+                    let x = unsafe { ffi::call::<usize>(ptr, libffi_args) };
                     Scalar::from_target_usize(x.try_into().unwrap(), this)
                 }
                 // Functions with no declared return type (i.e., the default return)
                 // have the output_type `Tuple([])`.
                 ty::Tuple(t_list) if (*t_list).deref().is_empty() => {
-                    unsafe { ffi::call::<()>(ptr, libffi_args.as_slice()) };
+                    unsafe { ffi::call::<()>(ptr, libffi_args) };
                     return interp_ok(ImmTy::uninit(dest.layout));
                 }
                 ty::RawPtr(..) => {
-                    let x = unsafe { ffi::call::<*const ()>(ptr, libffi_args.as_slice()) };
-                    let ptr = Pointer::new(Provenance::Wildcard, Size::from_bytes(x.addr()));
+                    let x = unsafe { ffi::call::<*const ()>(ptr, libffi_args) };
+                    let ptr = StrictPointer::new(Provenance::Wildcard, Size::from_bytes(x.addr()));
                     Scalar::from_pointer(ptr, this)
                 }
                 _ =>
@@ -267,6 +269,158 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         interp_ok(())
     }
+
+    /// Extract the value from the result of reading an operand from the machine
+    /// and convert it to a `OwnedArg`.
+    fn op_to_ffi_arg(&self, v: &OpTy<'tcx>, tracing: bool) -> InterpResult<'tcx, OwnedArg> {
+        let this = self.eval_context_ref();
+
+        // This should go first so that we emit unsupported before doing a bunch
+        // of extra work for types that aren't supported yet.
+        let ty = this.ty_to_ffitype(v.layout.ty)?;
+
+        // Now grab the bytes of the argument.
+        let bytes = match v.as_mplace_or_imm() {
+            either::Either::Left(mplace) => {
+                // Get the alloc id corresponding to this mplace, alongside
+                // a pointer that's offset to point to this particular
+                // mplace (not one at the base addr of the allocation).
+                let mplace_ptr = mplace.ptr();
+                let sz = mplace.layout.size.bytes_usize();
+                if sz == 0 {
+                    throw_unsup_format!("attempting to pass a ZST over FFI");
+                }
+                let (id, ofs, _) = this.ptr_get_alloc_id(mplace_ptr, sz.try_into().unwrap())?;
+                let ofs = ofs.bytes_usize();
+                // Expose all provenances in the allocation within the byte
+                // range of the struct, if any.
+                let alloc = this.get_alloc_raw(id)?;
+                let alloc_ptr = this.get_alloc_bytes_unchecked_raw(id)?;
+                for prov in alloc.provenance().get_range(this, (ofs..ofs.strict_add(sz)).into()) {
+                    this.expose_provenance(prov)?;
+                }
+                // SAFETY: We know for sure that at alloc_ptr + ofs the next layout.size
+                // bytes are part of this allocation and initialised. They might be marked
+                // as uninit in Miri, but all bytes returned by `MiriAllocBytes` are
+                // initialised.
+                unsafe {
+                    Box::from(std::slice::from_raw_parts(
+                        alloc_ptr.add(ofs),
+                        mplace.layout.size.bytes_usize(),
+                    ))
+                }
+            }
+            either::Either::Right(imm) => {
+                // A little helper to write scalars to our byte array.
+                let write_scalar = |this: &MiriInterpCx<'tcx>, sc: Scalar, bytes: &mut [u8]| {
+                    // If a scalar is a pointer, then expose its provenance.
+                    if let interpret::Scalar::Ptr(p, _) = sc {
+                        // This relies on the `expose_provenance` in the `visit_reachable_allocs` callback
+                        // below to expose the actual interpreter-level allocation.
+                        this.expose_and_warn(Some(p.provenance), tracing)?;
+                    }
+                    // `bytes[0]` should be the first byte we want to write to.
+                    write_target_uint(
+                        this.data_layout().endian,
+                        &mut bytes[..sc.size().bytes_usize()],
+                        sc.to_scalar_int()?.to_bits_unchecked(),
+                    )
+                    .unwrap();
+                    interp_ok(())
+                };
+
+                let mut bytes: Box<[u8]> =
+                    (0..imm.layout.size.bytes_usize()).map(|_| 0u8).collect();
+
+                match *imm {
+                    Immediate::Scalar(sc) => write_scalar(this, sc, &mut bytes)?,
+                    Immediate::ScalarPair(sc_first, sc_second) => {
+                        // The first scalar has an offset of zero.
+                        let ofs_second = {
+                            let rustc_abi::BackendRepr::ScalarPair(a, b) = imm.layout.backend_repr
+                            else {
+                                span_bug!(
+                                    this.cur_span(),
+                                    "op_to_ffi_arg: invalid scalar pair layout: {:#?}",
+                                    imm.layout
+                                )
+                            };
+                            a.size(this).align_to(b.align(this).abi).bytes_usize()
+                        };
+
+                        write_scalar(this, sc_first, &mut bytes)?;
+                        write_scalar(this, sc_second, &mut bytes[ofs_second..])?;
+                    }
+                    Immediate::Uninit =>
+                        span_bug!(this.cur_span(), "op_to_ffi_arg: argument is uninit: {:#?}", imm),
+                }
+
+                bytes
+            }
+        };
+        interp_ok(OwnedArg::new(ty, bytes))
+    }
+
+    /// Parses an ADT to construct the matching libffi type.
+    fn adt_to_ffitype(
+        &self,
+        orig_ty: Ty<'_>,
+        adt_def: ty::AdtDef<'tcx>,
+        args: &'tcx ty::List<ty::GenericArg<'tcx>>,
+    ) -> InterpResult<'tcx, FfiType> {
+        // TODO: Certain non-C reprs should be okay also.
+        if !adt_def.repr().c() {
+            throw_unsup_format!("passing a non-#[repr(C)] struct over FFI: {orig_ty}")
+        }
+        // TODO: unions, etc.
+        if !adt_def.is_struct() {
+            throw_unsup_format!(
+                "unsupported argument type for native call: {orig_ty} is an enum or union"
+            );
+        }
+
+        let this = self.eval_context_ref();
+        let mut fields = vec![];
+        for field in adt_def.all_fields() {
+            fields.push(this.ty_to_ffitype(field.ty(*this.tcx, args))?);
+        }
+
+        interp_ok(FfiType::structure(fields))
+    }
+
+    /// Gets the matching libffi type for a given Ty.
+    fn ty_to_ffitype(&self, ty: Ty<'tcx>) -> InterpResult<'tcx, FfiType> {
+        interp_ok(match ty.kind() {
+            ty::Int(IntTy::I8) => FfiType::i8(),
+            ty::Int(IntTy::I16) => FfiType::i16(),
+            ty::Int(IntTy::I32) => FfiType::i32(),
+            ty::Int(IntTy::I64) => FfiType::i64(),
+            ty::Int(IntTy::Isize) => FfiType::isize(),
+            // the uints
+            ty::Uint(UintTy::U8) => FfiType::u8(),
+            ty::Uint(UintTy::U16) => FfiType::u16(),
+            ty::Uint(UintTy::U32) => FfiType::u32(),
+            ty::Uint(UintTy::U64) => FfiType::u64(),
+            ty::Uint(UintTy::Usize) => FfiType::usize(),
+            ty::RawPtr(..) => FfiType::pointer(),
+            ty::Adt(adt_def, args) => self.adt_to_ffitype(ty, *adt_def, args)?,
+            _ => throw_unsup_format!("unsupported argument type for native call: {}", ty),
+        })
+    }
+
+    fn expose_and_warn(&self, prov: Option<Provenance>, tracing: bool) -> InterpResult<'tcx> {
+        let this = self.eval_context_ref();
+        if let Some(prov) = prov {
+            // The first time this happens, print a warning.
+            if !this.machine.native_call_mem_warned.replace(true) {
+                // Newly set, so first time we get here.
+                this.emit_diagnostic(NonHaltingDiagnostic::NativeCallSharedMem { tracing });
+            }
+
+            this.expose_provenance(prov)?;
+        };
+        interp_ok(())
+    }
 }
 
 impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
@@ -295,36 +449,11 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         // Do we have ptrace?
         let tracing = trace::Supervisor::is_enabled();
 
-        // Get the function arguments, and convert them to `libffi`-compatible form.
-        let mut libffi_args = Vec::<CArg>::with_capacity(args.len());
+        // Get the function arguments, copy them, and prepare the type descriptions.
+        let mut libffi_args = Vec::<OwnedArg>::with_capacity(args.len());
         for arg in args.iter() {
-            if !matches!(arg.layout.backend_repr, BackendRepr::Scalar(_)) {
-                throw_unsup_format!("only scalar argument types are supported for native calls")
-            }
-            let imm = this.read_immediate(arg)?;
-            libffi_args.push(imm_to_carg(&imm, this)?);
-            // If we are passing a pointer, expose its provenance. Below, all exposed memory
-            // (previously exposed and new exposed) will then be properly prepared.
-            if matches!(arg.layout.ty.kind(), ty::RawPtr(..)) {
-                let ptr = imm.to_scalar().to_pointer(this)?;
-                let Some(prov) = ptr.provenance else {
-                    // Pointer without provenance may not access any memory anyway, skip.
-                    continue;
-                };
-                // The first time this happens, print a warning.
-                if !this.machine.native_call_mem_warned.replace(true) {
-                    // Newly set, so first time we get here.
-                    this.emit_diagnostic(NonHaltingDiagnostic::NativeCallSharedMem { tracing });
-                }
-
-                this.expose_provenance(prov)?;
-            }
+            libffi_args.push(this.op_to_ffi_arg(arg, tracing)?);
         }
-        // Convert arguments to `libffi::high::Arg` type.
-        let libffi_args = libffi_args
-            .iter()
-            .map(|arg| arg.arg_downcast())
-            .collect::<Vec<libffi::high::Arg<'_>>>();
 
         // Prepare all exposed memory (both previously exposed, and just newly exposed since a
         // pointer was passed as argument). Uninitialised memory is left as-is, but any data
@@ -367,7 +496,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         // Call the function and store output, depending on return type in the function signature.
         let (ret, maybe_memevents) =
-            this.call_native_with_args(link_name, dest, code_ptr, libffi_args)?;
+            this.call_native_with_args(link_name, dest, code_ptr, &mut libffi_args)?;
 
         if tracing {
             this.tracing_apply_accesses(maybe_memevents.unwrap())?;
@@ -377,83 +506,3 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         interp_ok(true)
     }
 }
-
-#[derive(Debug, Clone)]
-/// Enum of supported arguments to external C functions.
-// We introduce this enum instead of just calling `ffi::arg` and storing a list
-// of `libffi::high::Arg` directly, because the `libffi::high::Arg` just wraps a reference
-// to the value it represents: https://docs.rs/libffi/latest/libffi/high/call/struct.Arg.html
-// and we need to store a copy of the value, and pass a reference to this copy to C instead.
-enum CArg {
-    /// 8-bit signed integer.
-    Int8(i8),
-    /// 16-bit signed integer.
-    Int16(i16),
-    /// 32-bit signed integer.
-    Int32(i32),
-    /// 64-bit signed integer.
-    Int64(i64),
-    /// isize.
-    ISize(isize),
-    /// 8-bit unsigned integer.
-    UInt8(u8),
-    /// 16-bit unsigned integer.
-    UInt16(u16),
-    /// 32-bit unsigned integer.
-    UInt32(u32),
-    /// 64-bit unsigned integer.
-    UInt64(u64),
-    /// usize.
-    USize(usize),
-    /// Raw pointer, stored as C's `void*`.
-    RawPtr(*mut std::ffi::c_void),
-}
-
-impl<'a> CArg {
-    /// Convert a `CArg` to a `libffi` argument type.
-    fn arg_downcast(&'a self) -> libffi::high::Arg<'a> {
-        match self {
-            CArg::Int8(i) => ffi::arg(i),
-            CArg::Int16(i) => ffi::arg(i),
-            CArg::Int32(i) => ffi::arg(i),
-            CArg::Int64(i) => ffi::arg(i),
-            CArg::ISize(i) => ffi::arg(i),
-            CArg::UInt8(i) => ffi::arg(i),
-            CArg::UInt16(i) => ffi::arg(i),
-            CArg::UInt32(i) => ffi::arg(i),
-            CArg::UInt64(i) => ffi::arg(i),
-            CArg::USize(i) => ffi::arg(i),
-            CArg::RawPtr(i) => ffi::arg(i),
-        }
-    }
-}
-
-/// Extract the scalar value from the result of reading a scalar from the machine,
-/// and convert it to a `CArg`.
-fn imm_to_carg<'tcx>(v: &ImmTy<'tcx>, cx: &impl HasDataLayout) -> InterpResult<'tcx, CArg> {
-    interp_ok(match v.layout.ty.kind() {
-        // If the primitive provided can be converted to a type matching the type pattern
-        // then create a `CArg` of this primitive value with the corresponding `CArg` constructor.
-        // the ints
-        ty::Int(IntTy::I8) => CArg::Int8(v.to_scalar().to_i8()?),
-        ty::Int(IntTy::I16) => CArg::Int16(v.to_scalar().to_i16()?),
-        ty::Int(IntTy::I32) => CArg::Int32(v.to_scalar().to_i32()?),
-        ty::Int(IntTy::I64) => CArg::Int64(v.to_scalar().to_i64()?),
-        ty::Int(IntTy::Isize) =>
-            CArg::ISize(v.to_scalar().to_target_isize(cx)?.try_into().unwrap()),
-        // the uints
-        ty::Uint(UintTy::U8) => CArg::UInt8(v.to_scalar().to_u8()?),
-        ty::Uint(UintTy::U16) => CArg::UInt16(v.to_scalar().to_u16()?),
-        ty::Uint(UintTy::U32) => CArg::UInt32(v.to_scalar().to_u32()?),
-        ty::Uint(UintTy::U64) => CArg::UInt64(v.to_scalar().to_u64()?),
-        ty::Uint(UintTy::Usize) =>
-            CArg::USize(v.to_scalar().to_target_usize(cx)?.try_into().unwrap()),
-        ty::RawPtr(..) => {
-            let s = v.to_scalar().to_pointer(cx)?.addr();
-            // This relies on the `expose_provenance` in the `visit_reachable_allocs` callback
-            // above.
-            CArg::RawPtr(std::ptr::with_exposed_provenance_mut(s.bytes_usize()))
-        }
-        _ => throw_unsup_format!("unsupported argument type for native call: {}", v.layout.ty),
-    })
-}
diff --git a/src/tools/miri/tests/native-lib/aggregate_arguments.c b/src/tools/miri/tests/native-lib/aggregate_arguments.c
new file mode 100644
index 0000000000000..9c29485e799bf
--- /dev/null
+++ b/src/tools/miri/tests/native-lib/aggregate_arguments.c
@@ -0,0 +1,42 @@
+#include <stdint.h>
+
+// See comments in build_native_lib()
+#define EXPORT __attribute__((visibility("default")))
+
+/* Test: test_pass_struct */
+
+typedef struct PassMe {
+    int32_t value;
+    int64_t other_value;
+} PassMe;
+
+EXPORT int64_t pass_struct(const PassMe pass_me) {
+  return pass_me.value + pass_me.other_value;
+}
+
+/* Test: test_pass_struct_complex */
+
+typedef struct Part1 {
+    uint16_t high;
+    uint16_t low;
+} Part1;
+
+typedef struct Part2 {
+    uint32_t bits;
+} Part2;
+
+typedef struct ComplexStruct {
+    Part1 part_1;
+    Part2 part_2;
+    uint32_t part_3;
+} ComplexStruct;
+
+EXPORT int32_t pass_struct_complex(const ComplexStruct complex, uint16_t high, uint16_t low, uint32_t bits) {
+  if (complex.part_1.high == high && complex.part_1.low == low
+      && complex.part_2.bits == bits
+      && complex.part_3 == bits)
+    return 0;
+  else {
+    return 1;
+  }
+}
diff --git a/src/tools/miri/tests/native-lib/fail/multi_struct_alloc.rs b/src/tools/miri/tests/native-lib/fail/multi_struct_alloc.rs
new file mode 100644
index 0000000000000..058beab0594ec
--- /dev/null
+++ b/src/tools/miri/tests/native-lib/fail/multi_struct_alloc.rs
@@ -0,0 +1,21 @@
+//@compile-flags: -Zmiri-permissive-provenance
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+struct HasPointer {
+    ptr: *const u8,
+}
+
+extern "C" {
+    fn access_struct_ptr(s: HasPointer) -> u8;
+}
+
+fn main() {
+    let vals = [10u8, 20u8];
+    let structs =
+        vec![HasPointer { ptr: &raw const vals[0] }, HasPointer { ptr: &raw const vals[1] }];
+    unsafe {
+        access_struct_ptr(structs[1]);
+        let _val = *std::ptr::with_exposed_provenance::<u8>(structs[0].ptr.addr()); //~ ERROR: Undefined Behavior: attempting a read access using <wildcard>
+    };
+}
diff --git a/src/tools/miri/tests/native-lib/fail/multi_struct_alloc.stderr b/src/tools/miri/tests/native-lib/fail/multi_struct_alloc.stderr
new file mode 100644
index 0000000000000..44656f9ee503a
--- /dev/null
+++ b/src/tools/miri/tests/native-lib/fail/multi_struct_alloc.stderr
@@ -0,0 +1,15 @@
+error: Undefined Behavior: attempting a read access using <wildcard> at ALLOC[0x0], but no exposed tags have suitable permission in the borrow stack for this location
+  --> tests/native-lib/fail/multi_struct_alloc.rs:LL:CC
+   |
+LL | ...al = *std::ptr::with_exposed_provenance::<u8>(structs[0].ptr.addr());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this error occurs as part of an access at ALLOC[0x0..0x1]
+   |
+   = 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
+   = note: BACKTRACE:
+   = note: inside `main` at tests/native-lib/fail/multi_struct_alloc.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/native-lib/fail/struct_not_extern_c.rs b/src/tools/miri/tests/native-lib/fail/struct_not_extern_c.rs
new file mode 100644
index 0000000000000..cf8315e0fd9d1
--- /dev/null
+++ b/src/tools/miri/tests/native-lib/fail/struct_not_extern_c.rs
@@ -0,0 +1,19 @@
+// Only works on Unix targets
+//@ignore-target: windows wasm
+//@only-on-host
+
+#![allow(improper_ctypes)]
+
+pub struct PassMe {
+    pub value: i32,
+    pub other_value: i64,
+}
+
+extern "C" {
+    fn pass_struct(s: PassMe) -> i64;
+}
+
+fn main() {
+    let pass_me = PassMe { value: 42, other_value: 1337 };
+    unsafe { pass_struct(pass_me) }; //~ ERROR: unsupported operation: passing a non-#[repr(C)] struct over FFI
+}
diff --git a/src/tools/miri/tests/native-lib/fail/struct_not_extern_c.stderr b/src/tools/miri/tests/native-lib/fail/struct_not_extern_c.stderr
new file mode 100644
index 0000000000000..90e59a31da429
--- /dev/null
+++ b/src/tools/miri/tests/native-lib/fail/struct_not_extern_c.stderr
@@ -0,0 +1,14 @@
+error: unsupported operation: passing a non-#[repr(C)] struct over FFI: PassMe
+  --> tests/native-lib/fail/struct_not_extern_c.rs:LL:CC
+   |
+LL |     unsafe { pass_struct(pass_me) };
+   |              ^^^^^^^^^^^^^^^^^^^^ unsupported operation occurred here
+   |
+   = 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 tests/native-lib/fail/struct_not_extern_c.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/native-lib/fail/uninit_struct.rs b/src/tools/miri/tests/native-lib/fail/uninit_struct.rs
new file mode 100644
index 0000000000000..cf61c7f3915a6
--- /dev/null
+++ b/src/tools/miri/tests/native-lib/fail/uninit_struct.rs
@@ -0,0 +1,27 @@
+#[repr(C)]
+#[derive(Copy, Clone)]
+struct ComplexStruct {
+    part_1: Part1,
+    part_2: Part2,
+    part_3: u32,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+struct Part1 {
+    high: u16,
+    low: u16,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+struct Part2 {
+    bits: u32,
+}
+
+extern "C" {
+    fn pass_struct_complex(s: ComplexStruct, high: u16, low: u16, bits: u32) -> i32;
+}
+
+fn main() {
+    let arg = std::mem::MaybeUninit::<ComplexStruct>::uninit();
+    unsafe { pass_struct_complex(*arg.as_ptr(), 0, 0, 0) }; //~ ERROR: Undefined Behavior: constructing invalid value
+}
diff --git a/src/tools/miri/tests/native-lib/fail/uninit_struct.stderr b/src/tools/miri/tests/native-lib/fail/uninit_struct.stderr
new file mode 100644
index 0000000000000..0fe6ad9c77bbc
--- /dev/null
+++ b/src/tools/miri/tests/native-lib/fail/uninit_struct.stderr
@@ -0,0 +1,15 @@
+error: Undefined Behavior: constructing invalid value at .part_1.high: encountered uninitialized memory, but expected an integer
+  --> tests/native-lib/fail/uninit_struct.rs:LL:CC
+   |
+LL |     unsafe { pass_struct_complex(*arg.as_ptr(), 0, 0, 0) };
+   |                                  ^^^^^^^^^^^^^ Undefined Behavior occurred here
+   |
+   = 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 tests/native-lib/fail/uninit_struct.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/native-lib/pass/aggregate_arguments.rs b/src/tools/miri/tests/native-lib/pass/aggregate_arguments.rs
new file mode 100644
index 0000000000000..15137c37d7cf5
--- /dev/null
+++ b/src/tools/miri/tests/native-lib/pass/aggregate_arguments.rs
@@ -0,0 +1,51 @@
+fn main() {
+    test_pass_struct();
+    test_pass_struct_complex();
+}
+
+/// Test passing a basic struct as an argument.
+fn test_pass_struct() {
+    #[repr(C)]
+    struct PassMe {
+        value: i32,
+        other_value: i64,
+    }
+
+    extern "C" {
+        fn pass_struct(s: PassMe) -> i64;
+    }
+
+    let pass_me = PassMe { value: 42, other_value: 1337 };
+    assert_eq!(unsafe { pass_struct(pass_me) }, 42 + 1337);
+}
+
+/// Test passing a more complex struct as an argument.
+fn test_pass_struct_complex() {
+    #[repr(C)]
+    struct ComplexStruct {
+        part_1: Part1,
+        part_2: Part2,
+        part_3: u32,
+    }
+    #[repr(C)]
+    struct Part1 {
+        high: u16,
+        low: u16,
+    }
+    #[repr(C)]
+    struct Part2 {
+        bits: u32,
+    }
+
+    extern "C" {
+        fn pass_struct_complex(s: ComplexStruct, high: u16, low: u16, bits: u32) -> i32;
+    }
+
+    let high = 0xabcd;
+    let low = 0xef01;
+    let bits = 0xabcdef01;
+
+    let complex =
+        ComplexStruct { part_1: Part1 { high, low }, part_2: Part2 { bits }, part_3: bits };
+    assert_eq!(unsafe { pass_struct_complex(complex, high, low, bits) }, 0);
+}
diff --git a/src/tools/miri/tests/native-lib/pass/ptr_read_access.rs b/src/tools/miri/tests/native-lib/pass/ptr_read_access.rs
index 4f3c37f00c1d7..49750a734d6eb 100644
--- a/src/tools/miri/tests/native-lib/pass/ptr_read_access.rs
+++ b/src/tools/miri/tests/native-lib/pass/ptr_read_access.rs
@@ -1,12 +1,14 @@
 //@revisions: trace notrace
 //@[trace] only-target: x86_64-unknown-linux-gnu i686-unknown-linux-gnu
 //@[trace] compile-flags: -Zmiri-native-lib-enable-tracing
+//@compile-flags: -Zmiri-permissive-provenance
 
 fn main() {
     test_access_pointer();
     test_access_simple();
     test_access_nested();
     test_access_static();
+    test_access_struct_ptr();
 }
 
 /// Test function that dereferences an int pointer and prints its contents from C.
@@ -74,3 +76,21 @@ fn test_access_static() {
 
     assert_eq!(unsafe { access_static(&STATIC) }, 9001);
 }
+
+/// Test exposing provenance from a field within a struct.
+fn test_access_struct_ptr() {
+    #[repr(C)]
+    struct HasPointer {
+        ptr: *const u8,
+    }
+
+    extern "C" {
+        // Return value exists only so the access isn't optimised away.
+        fn access_struct_ptr(s: HasPointer) -> u8;
+    }
+
+    let some_val = 42u8;
+    let ptr = &raw const some_val;
+    unsafe { access_struct_ptr(HasPointer { ptr }) };
+    assert_eq!(some_val, unsafe { *std::ptr::with_exposed_provenance::<u8>(ptr.addr()) })
+}
diff --git a/src/tools/miri/tests/native-lib/ptr_read_access.c b/src/tools/miri/tests/native-lib/ptr_read_access.c
index 021eb6adca4f6..2107d2bc21f5e 100644
--- a/src/tools/miri/tests/native-lib/ptr_read_access.c
+++ b/src/tools/miri/tests/native-lib/ptr_read_access.c
@@ -55,3 +55,13 @@ EXPORT int32_t access_static(const Static *s_ptr) {
 EXPORT uintptr_t do_one_deref(const int32_t ***ptr) {
   return (uintptr_t)*ptr;
 }
+
+/* Test: test_access_struct_ptr */
+
+typedef struct HasPointer {
+  uint8_t *ptr;
+} HasPointer;
+
+EXPORT uint8_t access_struct_ptr(const HasPointer s) {
+  return *s.ptr;
+}
diff --git a/src/tools/miri/tests/ui.rs b/src/tools/miri/tests/ui.rs
index f021d5194cd93..b7286d9a3673a 100644
--- a/src/tools/miri/tests/ui.rs
+++ b/src/tools/miri/tests/ui.rs
@@ -60,6 +60,7 @@ fn build_native_lib(target: &str) -> PathBuf {
             native_lib_path.to_str().unwrap(),
             // FIXME: Automate gathering of all relevant C source files in the directory.
             "tests/native-lib/scalar_arguments.c",
+            "tests/native-lib/aggregate_arguments.c",
             "tests/native-lib/ptr_read_access.c",
             "tests/native-lib/ptr_write_access.c",
             // Ensure we notice serious problems in the C code.

From c1d16779d57b12cda18c4b8df36de98745ac10e9 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 31 Aug 2025 20:49:15 +0200
Subject: [PATCH 0369/1889] some refactoring and cleanup

---
 src/tools/miri/src/shims/native_lib/ffi.rs    |  24 ++--
 src/tools/miri/src/shims/native_lib/mod.rs    | 122 +++++++++---------
 .../tests/native-lib/aggregate_arguments.c    |  10 ++
 .../native-lib/fail/multi_struct_alloc.rs     |  21 ---
 .../native-lib/fail/multi_struct_alloc.stderr |  15 ---
 .../fail/pass_struct_expose_only_range.rs     |  23 ++++
 .../fail/pass_struct_expose_only_range.stderr |  28 ++++
 .../native-lib/pass/aggregate_arguments.rs    |   1 +
 .../tests/native-lib/pass/ptr_read_access.rs  |  19 ---
 .../miri/tests/native-lib/ptr_read_access.c   |  10 --
 10 files changed, 128 insertions(+), 145 deletions(-)
 delete mode 100644 src/tools/miri/tests/native-lib/fail/multi_struct_alloc.rs
 delete mode 100644 src/tools/miri/tests/native-lib/fail/multi_struct_alloc.stderr
 create mode 100644 src/tools/miri/tests/native-lib/fail/pass_struct_expose_only_range.rs
 create mode 100644 src/tools/miri/tests/native-lib/fail/pass_struct_expose_only_range.stderr

diff --git a/src/tools/miri/src/shims/native_lib/ffi.rs b/src/tools/miri/src/shims/native_lib/ffi.rs
index b2615cedaeab5..0badf22bb7651 100644
--- a/src/tools/miri/src/shims/native_lib/ffi.rs
+++ b/src/tools/miri/src/shims/native_lib/ffi.rs
@@ -1,18 +1,16 @@
+//! Support code for dealing with libffi.
+
 use libffi::low::CodePtr;
 use libffi::middle::{Arg as ArgPtr, Cif, Type as FfiType};
 
 /// Perform the actual FFI call.
 ///
-/// SAFETY: The safety invariants of the foreign function being called must be
-/// upheld (if any).
+/// # Safety
+///
+/// The safety invariants of the foreign function being called must be upheld (if any).
 pub unsafe fn call<R: libffi::high::CType>(fun: CodePtr, args: &mut [OwnedArg]) -> R {
-    let mut arg_tys = vec![];
-    let mut arg_ptrs = vec![];
-    for arg in args {
-        arg_tys.push(arg.take_ty());
-        arg_ptrs.push(arg.ptr())
-    }
-    let cif = Cif::new(arg_tys, R::reify().into_middle());
+    let arg_ptrs: Vec<_> = args.iter().map(|arg| arg.ptr()).collect();
+    let cif = Cif::new(args.iter_mut().map(|arg| arg.ty.take().unwrap()), R::reify().into_middle());
     // SAFETY: Caller upholds that the function is safe to call, and since we
     // were passed a slice reference we know the `OwnedArg`s won't have been
     // dropped by this point.
@@ -34,13 +32,7 @@ impl OwnedArg {
         Self { ty: Some(ty), bytes }
     }
 
-    /// Gets the libffi type descriptor for this argument. Should only be
-    /// called once on a given `OwnedArg`.
-    fn take_ty(&mut self) -> FfiType {
-        self.ty.take().unwrap()
-    }
-
-    /// Instantiates a libffi argument pointer pointing to this argument's bytes.
+    /// Creates a libffi argument pointer pointing to this argument's bytes.
     /// NB: Since `libffi::middle::Arg` ignores the lifetime of the reference
     /// it's derived from, it is up to the caller to ensure the `OwnedArg` is
     /// not dropped before unsafely calling `libffi::middle::Cif::call()`!
diff --git a/src/tools/miri/src/shims/native_lib/mod.rs b/src/tools/miri/src/shims/native_lib/mod.rs
index 156d6171c73c8..da8f785e37345 100644
--- a/src/tools/miri/src/shims/native_lib/mod.rs
+++ b/src/tools/miri/src/shims/native_lib/mod.rs
@@ -76,7 +76,7 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
         &mut self,
         link_name: Symbol,
         dest: &MPlaceTy<'tcx>,
-        ptr: CodePtr,
+        fun: CodePtr,
         libffi_args: &mut [OwnedArg],
     ) -> InterpResult<'tcx, (crate::ImmTy<'tcx>, Option<MemEvents>)> {
         let this = self.eval_context_mut();
@@ -95,54 +95,54 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     // Unsafe because of the call to native code.
                     // Because this is calling a C function it is not necessarily sound,
                     // but there is no way around this and we've checked as much as we can.
-                    let x = unsafe { ffi::call::<i8>(ptr, libffi_args) };
+                    let x = unsafe { ffi::call::<i8>(fun, libffi_args) };
                     Scalar::from_i8(x)
                 }
                 ty::Int(IntTy::I16) => {
-                    let x = unsafe { ffi::call::<i16>(ptr, libffi_args) };
+                    let x = unsafe { ffi::call::<i16>(fun, libffi_args) };
                     Scalar::from_i16(x)
                 }
                 ty::Int(IntTy::I32) => {
-                    let x = unsafe { ffi::call::<i32>(ptr, libffi_args) };
+                    let x = unsafe { ffi::call::<i32>(fun, libffi_args) };
                     Scalar::from_i32(x)
                 }
                 ty::Int(IntTy::I64) => {
-                    let x = unsafe { ffi::call::<i64>(ptr, libffi_args) };
+                    let x = unsafe { ffi::call::<i64>(fun, libffi_args) };
                     Scalar::from_i64(x)
                 }
                 ty::Int(IntTy::Isize) => {
-                    let x = unsafe { ffi::call::<isize>(ptr, libffi_args) };
+                    let x = unsafe { ffi::call::<isize>(fun, libffi_args) };
                     Scalar::from_target_isize(x.try_into().unwrap(), this)
                 }
                 // uints
                 ty::Uint(UintTy::U8) => {
-                    let x = unsafe { ffi::call::<u8>(ptr, libffi_args) };
+                    let x = unsafe { ffi::call::<u8>(fun, libffi_args) };
                     Scalar::from_u8(x)
                 }
                 ty::Uint(UintTy::U16) => {
-                    let x = unsafe { ffi::call::<u16>(ptr, libffi_args) };
+                    let x = unsafe { ffi::call::<u16>(fun, libffi_args) };
                     Scalar::from_u16(x)
                 }
                 ty::Uint(UintTy::U32) => {
-                    let x = unsafe { ffi::call::<u32>(ptr, libffi_args) };
+                    let x = unsafe { ffi::call::<u32>(fun, libffi_args) };
                     Scalar::from_u32(x)
                 }
                 ty::Uint(UintTy::U64) => {
-                    let x = unsafe { ffi::call::<u64>(ptr, libffi_args) };
+                    let x = unsafe { ffi::call::<u64>(fun, libffi_args) };
                     Scalar::from_u64(x)
                 }
                 ty::Uint(UintTy::Usize) => {
-                    let x = unsafe { ffi::call::<usize>(ptr, libffi_args) };
+                    let x = unsafe { ffi::call::<usize>(fun, libffi_args) };
                     Scalar::from_target_usize(x.try_into().unwrap(), this)
                 }
                 // Functions with no declared return type (i.e., the default return)
                 // have the output_type `Tuple([])`.
                 ty::Tuple(t_list) if (*t_list).deref().is_empty() => {
-                    unsafe { ffi::call::<()>(ptr, libffi_args) };
+                    unsafe { ffi::call::<()>(fun, libffi_args) };
                     return interp_ok(ImmTy::uninit(dest.layout));
                 }
                 ty::RawPtr(..) => {
-                    let x = unsafe { ffi::call::<*const ()>(ptr, libffi_args) };
+                    let x = unsafe { ffi::call::<*const ()>(fun, libffi_args) };
                     let ptr = StrictPointer::new(Provenance::Wildcard, Size::from_bytes(x.addr()));
                     Scalar::from_pointer(ptr, this)
                 }
@@ -279,63 +279,68 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
         // of extra work for types that aren't supported yet.
         let ty = this.ty_to_ffitype(v.layout.ty)?;
 
-        // Now grab the bytes of the argument.
+        // Helper to print a warning when a pointer is shared with the native code.
+        let expose = |prov: Provenance| -> InterpResult<'tcx> {
+            // The first time this happens, print a warning.
+            if !this.machine.native_call_mem_warned.replace(true) {
+                // Newly set, so first time we get here.
+                this.emit_diagnostic(NonHaltingDiagnostic::NativeCallSharedMem { tracing });
+            }
+
+            this.expose_provenance(prov)?;
+            interp_ok(())
+        };
+
+        // Compute the byte-level representation of the argument. If there's a pointer in there, we
+        // expose it inside the AM. Later in `visit_reachable_allocs`, the "meta"-level provenance
+        // for accessing the pointee gets exposed; this is crucial to justify the C code effectively
+        // casting the integer in `byte` to a pointer and using that.
         let bytes = match v.as_mplace_or_imm() {
             either::Either::Left(mplace) => {
                 // Get the alloc id corresponding to this mplace, alongside
                 // a pointer that's offset to point to this particular
                 // mplace (not one at the base addr of the allocation).
-                let mplace_ptr = mplace.ptr();
                 let sz = mplace.layout.size.bytes_usize();
                 if sz == 0 {
                     throw_unsup_format!("attempting to pass a ZST over FFI");
                 }
-                let (id, ofs, _) = this.ptr_get_alloc_id(mplace_ptr, sz.try_into().unwrap())?;
+                let (id, ofs, _) = this.ptr_get_alloc_id(mplace.ptr(), sz.try_into().unwrap())?;
                 let ofs = ofs.bytes_usize();
-                // Expose all provenances in the allocation within the byte
-                // range of the struct, if any.
+                let range = ofs..ofs.strict_add(sz);
+                // Expose all provenances in the allocation within the byte range of the struct, if
+                // any. These pointers are being directly passed to native code by-value.
                 let alloc = this.get_alloc_raw(id)?;
-                let alloc_ptr = this.get_alloc_bytes_unchecked_raw(id)?;
-                for prov in alloc.provenance().get_range(this, (ofs..ofs.strict_add(sz)).into()) {
-                    this.expose_provenance(prov)?;
-                }
-                // SAFETY: We know for sure that at alloc_ptr + ofs the next layout.size
-                // bytes are part of this allocation and initialised. They might be marked
-                // as uninit in Miri, but all bytes returned by `MiriAllocBytes` are
-                // initialised.
-                unsafe {
-                    Box::from(std::slice::from_raw_parts(
-                        alloc_ptr.add(ofs),
-                        mplace.layout.size.bytes_usize(),
-                    ))
+                for prov in alloc.provenance().get_range(this, range.clone().into()) {
+                    expose(prov)?;
                 }
+                // Read the bytes that make up this argument. We cannot use the normal getter as
+                // those would fail if any part of the argument is uninitialized. Native code
+                // is kind of outside the interpreter, after all...
+                Box::from(alloc.inspect_with_uninit_and_ptr_outside_interpreter(range))
             }
             either::Either::Right(imm) => {
+                let mut bytes: Box<[u8]> = vec![0; imm.layout.size.bytes_usize()].into();
+
                 // A little helper to write scalars to our byte array.
-                let write_scalar = |this: &MiriInterpCx<'tcx>, sc: Scalar, bytes: &mut [u8]| {
+                let mut write_scalar = |this: &MiriInterpCx<'tcx>, sc: Scalar, pos: usize| {
                     // If a scalar is a pointer, then expose its provenance.
                     if let interpret::Scalar::Ptr(p, _) = sc {
-                        // This relies on the `expose_provenance` in the `visit_reachable_allocs` callback
-                        // below to expose the actual interpreter-level allocation.
-                        this.expose_and_warn(Some(p.provenance), tracing)?;
+                        expose(p.provenance)?;
                     }
-                    // `bytes[0]` should be the first byte we want to write to.
                     write_target_uint(
                         this.data_layout().endian,
-                        &mut bytes[..sc.size().bytes_usize()],
+                        &mut bytes[pos..][..sc.size().bytes_usize()],
                         sc.to_scalar_int()?.to_bits_unchecked(),
                     )
                     .unwrap();
                     interp_ok(())
                 };
 
-                let mut bytes: Box<[u8]> =
-                    (0..imm.layout.size.bytes_usize()).map(|_| 0u8).collect();
-
+                // Write the scalar into the `bytes` buffer.
                 match *imm {
-                    Immediate::Scalar(sc) => write_scalar(this, sc, &mut bytes)?,
+                    Immediate::Scalar(sc) => write_scalar(this, sc, 0)?,
                     Immediate::ScalarPair(sc_first, sc_second) => {
-                        // The first scalar has an offset of zero.
+                        // The first scalar has an offset of zero; compute the offset of the 2nd.
                         let ofs_second = {
                             let rustc_abi::BackendRepr::ScalarPair(a, b) = imm.layout.backend_repr
                             else {
@@ -348,11 +353,12 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                             a.size(this).align_to(b.align(this).abi).bytes_usize()
                         };
 
-                        write_scalar(this, sc_first, &mut bytes)?;
-                        write_scalar(this, sc_second, &mut bytes[ofs_second..])?;
+                        write_scalar(this, sc_first, 0)?;
+                        write_scalar(this, sc_second, ofs_second)?;
+                    }
+                    Immediate::Uninit => {
+                        // Nothing to write.
                     }
-                    Immediate::Uninit =>
-                        span_bug!(this.cur_span(), "op_to_ffi_arg: argument is uninit: {:#?}", imm),
                 }
 
                 bytes
@@ -381,7 +387,7 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         let this = self.eval_context_ref();
         let mut fields = vec![];
-        for field in adt_def.all_fields() {
+        for field in &adt_def.non_enum_variant().fields {
             fields.push(this.ty_to_ffitype(field.ty(*this.tcx, args))?);
         }
 
@@ -407,20 +413,6 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
             _ => throw_unsup_format!("unsupported argument type for native call: {}", ty),
         })
     }
-
-    fn expose_and_warn(&self, prov: Option<Provenance>, tracing: bool) -> InterpResult<'tcx> {
-        let this = self.eval_context_ref();
-        if let Some(prov) = prov {
-            // The first time this happens, print a warning.
-            if !this.machine.native_call_mem_warned.replace(true) {
-                // Newly set, so first time we get here.
-                this.emit_diagnostic(NonHaltingDiagnostic::NativeCallSharedMem { tracing });
-            }
-
-            this.expose_provenance(prov)?;
-        };
-        interp_ok(())
-    }
 }
 
 impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
@@ -472,8 +464,9 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             std::hint::black_box(alloc.get_bytes_unchecked_raw().expose_provenance());
 
             if !tracing {
-                // Expose all provenances in this allocation, since the native code can do $whatever.
-                // Can be skipped when tracing; in that case we'll expose just the actually-read parts later.
+                // Expose all provenances in this allocation, since the native code can do
+                // $whatever. Can be skipped when tracing; in that case we'll expose just the
+                // actually-read parts later.
                 for prov in alloc.provenance().provenances() {
                     this.expose_provenance(prov)?;
                 }
@@ -483,7 +476,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             if info.mutbl.is_mut() {
                 let (alloc, cx) = this.get_alloc_raw_mut(alloc_id)?;
                 // These writes could initialize everything and wreck havoc with the pointers.
-                // We can skip that when tracing; in that case we'll later do that only for the memory that got actually written.
+                // We can skip that when tracing; in that case we'll later do that only for the
+                // memory that got actually written.
                 if !tracing {
                     alloc.process_native_write(&cx.tcx, None);
                 }
diff --git a/src/tools/miri/tests/native-lib/aggregate_arguments.c b/src/tools/miri/tests/native-lib/aggregate_arguments.c
index 9c29485e799bf..8ad687f2aec9f 100644
--- a/src/tools/miri/tests/native-lib/aggregate_arguments.c
+++ b/src/tools/miri/tests/native-lib/aggregate_arguments.c
@@ -3,6 +3,16 @@
 // See comments in build_native_lib()
 #define EXPORT __attribute__((visibility("default")))
 
+/* Test: fail/pass_struct_expose_only_range */
+
+typedef struct HasPointer {
+  uint8_t *ptr;
+} HasPointer;
+
+EXPORT uint8_t access_struct_ptr(const HasPointer s) {
+  return *s.ptr;
+}
+
 /* Test: test_pass_struct */
 
 typedef struct PassMe {
diff --git a/src/tools/miri/tests/native-lib/fail/multi_struct_alloc.rs b/src/tools/miri/tests/native-lib/fail/multi_struct_alloc.rs
deleted file mode 100644
index 058beab0594ec..0000000000000
--- a/src/tools/miri/tests/native-lib/fail/multi_struct_alloc.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//@compile-flags: -Zmiri-permissive-provenance
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-struct HasPointer {
-    ptr: *const u8,
-}
-
-extern "C" {
-    fn access_struct_ptr(s: HasPointer) -> u8;
-}
-
-fn main() {
-    let vals = [10u8, 20u8];
-    let structs =
-        vec![HasPointer { ptr: &raw const vals[0] }, HasPointer { ptr: &raw const vals[1] }];
-    unsafe {
-        access_struct_ptr(structs[1]);
-        let _val = *std::ptr::with_exposed_provenance::<u8>(structs[0].ptr.addr()); //~ ERROR: Undefined Behavior: attempting a read access using <wildcard>
-    };
-}
diff --git a/src/tools/miri/tests/native-lib/fail/multi_struct_alloc.stderr b/src/tools/miri/tests/native-lib/fail/multi_struct_alloc.stderr
deleted file mode 100644
index 44656f9ee503a..0000000000000
--- a/src/tools/miri/tests/native-lib/fail/multi_struct_alloc.stderr
+++ /dev/null
@@ -1,15 +0,0 @@
-error: Undefined Behavior: attempting a read access using <wildcard> at ALLOC[0x0], but no exposed tags have suitable permission in the borrow stack for this location
-  --> tests/native-lib/fail/multi_struct_alloc.rs:LL:CC
-   |
-LL | ...al = *std::ptr::with_exposed_provenance::<u8>(structs[0].ptr.addr());
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this error occurs as part of an access at ALLOC[0x0..0x1]
-   |
-   = 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
-   = note: BACKTRACE:
-   = note: inside `main` at tests/native-lib/fail/multi_struct_alloc.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/native-lib/fail/pass_struct_expose_only_range.rs b/src/tools/miri/tests/native-lib/fail/pass_struct_expose_only_range.rs
new file mode 100644
index 0000000000000..a2b43031a2959
--- /dev/null
+++ b/src/tools/miri/tests/native-lib/fail/pass_struct_expose_only_range.rs
@@ -0,0 +1,23 @@
+//@compile-flags: -Zmiri-permissive-provenance
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+struct HasPointer {
+    ptr: *const u8,
+}
+
+extern "C" {
+    fn access_struct_ptr(s: HasPointer) -> u8;
+}
+
+fn main() {
+    let structs = vec![HasPointer { ptr: &0 }, HasPointer { ptr: &1 }];
+    unsafe {
+        let r = access_struct_ptr(structs[1]);
+        assert_eq!(r, 1);
+        // There are two pointers stored in the allocation backing `structs`; ensure
+        // we only exposed the one that was actually passed to C.
+        let _val = *std::ptr::with_exposed_provenance::<u8>(structs[1].ptr.addr()); // fine, ptr got sent to C
+        let _val = *std::ptr::with_exposed_provenance::<u8>(structs[0].ptr.addr()); //~ ERROR: memory access failed
+    };
+}
diff --git a/src/tools/miri/tests/native-lib/fail/pass_struct_expose_only_range.stderr b/src/tools/miri/tests/native-lib/fail/pass_struct_expose_only_range.stderr
new file mode 100644
index 0000000000000..a8f85001c233a
--- /dev/null
+++ b/src/tools/miri/tests/native-lib/fail/pass_struct_expose_only_range.stderr
@@ -0,0 +1,28 @@
+warning: sharing memory with a native function called via FFI
+  --> tests/native-lib/fail/pass_struct_expose_only_range.rs:LL:CC
+   |
+LL |         let r = access_struct_ptr(structs[1]);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ sharing memory with a native function
+   |
+   = help: when memory is shared with a native function call, Miri stops tracking initialization and provenance for that memory
+   = help: in particular, Miri assumes that the native call initializes all memory it has access to
+   = help: Miri also assumes that any part of this memory may be a pointer that is permitted to point to arbitrary exposed memory
+   = help: what this means is that Miri will easily miss Undefined Behavior related to incorrect usage of this shared memory, so you should not take a clean Miri run as a signal that your FFI code is UB-free
+   = note: BACKTRACE:
+   = note: inside `main` at tests/native-lib/fail/pass_struct_expose_only_range.rs:LL:CC
+
+error: Undefined Behavior: memory access failed: attempting to access 1 byte, but got $HEX[noalloc] which is a dangling pointer (it has no provenance)
+  --> tests/native-lib/fail/pass_struct_expose_only_range.rs:LL:CC
+   |
+LL |         let _val = *std::ptr::with_exposed_provenance::<u8>(structs[0].ptr.addr());
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
+   |
+   = 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 tests/native-lib/fail/pass_struct_expose_only_range.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; 1 warning emitted
+
diff --git a/src/tools/miri/tests/native-lib/pass/aggregate_arguments.rs b/src/tools/miri/tests/native-lib/pass/aggregate_arguments.rs
index 15137c37d7cf5..55acb240612f8 100644
--- a/src/tools/miri/tests/native-lib/pass/aggregate_arguments.rs
+++ b/src/tools/miri/tests/native-lib/pass/aggregate_arguments.rs
@@ -5,6 +5,7 @@ fn main() {
 
 /// Test passing a basic struct as an argument.
 fn test_pass_struct() {
+    // Exactly two fields, so that we hit the ScalarPair case.
     #[repr(C)]
     struct PassMe {
         value: i32,
diff --git a/src/tools/miri/tests/native-lib/pass/ptr_read_access.rs b/src/tools/miri/tests/native-lib/pass/ptr_read_access.rs
index 49750a734d6eb..bab73f7cf1782 100644
--- a/src/tools/miri/tests/native-lib/pass/ptr_read_access.rs
+++ b/src/tools/miri/tests/native-lib/pass/ptr_read_access.rs
@@ -8,7 +8,6 @@ fn main() {
     test_access_simple();
     test_access_nested();
     test_access_static();
-    test_access_struct_ptr();
 }
 
 /// Test function that dereferences an int pointer and prints its contents from C.
@@ -76,21 +75,3 @@ fn test_access_static() {
 
     assert_eq!(unsafe { access_static(&STATIC) }, 9001);
 }
-
-/// Test exposing provenance from a field within a struct.
-fn test_access_struct_ptr() {
-    #[repr(C)]
-    struct HasPointer {
-        ptr: *const u8,
-    }
-
-    extern "C" {
-        // Return value exists only so the access isn't optimised away.
-        fn access_struct_ptr(s: HasPointer) -> u8;
-    }
-
-    let some_val = 42u8;
-    let ptr = &raw const some_val;
-    unsafe { access_struct_ptr(HasPointer { ptr }) };
-    assert_eq!(some_val, unsafe { *std::ptr::with_exposed_provenance::<u8>(ptr.addr()) })
-}
diff --git a/src/tools/miri/tests/native-lib/ptr_read_access.c b/src/tools/miri/tests/native-lib/ptr_read_access.c
index 2107d2bc21f5e..021eb6adca4f6 100644
--- a/src/tools/miri/tests/native-lib/ptr_read_access.c
+++ b/src/tools/miri/tests/native-lib/ptr_read_access.c
@@ -55,13 +55,3 @@ EXPORT int32_t access_static(const Static *s_ptr) {
 EXPORT uintptr_t do_one_deref(const int32_t ***ptr) {
   return (uintptr_t)*ptr;
 }
-
-/* Test: test_access_struct_ptr */
-
-typedef struct HasPointer {
-  uint8_t *ptr;
-} HasPointer;
-
-EXPORT uint8_t access_struct_ptr(const HasPointer s) {
-  return *s.ptr;
-}

From 0711bba9ea368204b1a7f833e0e44c529ce140c8 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Sun, 31 Aug 2025 20:43:44 +0000
Subject: [PATCH 0370/1889] Ignore test when dylibs are not supported

---
 tests/ui/linking/mixed-allocator-shim.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/ui/linking/mixed-allocator-shim.rs b/tests/ui/linking/mixed-allocator-shim.rs
index b81fbdc5205e7..e4f20a11ebb37 100644
--- a/tests/ui/linking/mixed-allocator-shim.rs
+++ b/tests/ui/linking/mixed-allocator-shim.rs
@@ -1,6 +1,7 @@
 //@ build-pass
 //@ compile-flags: --crate-type staticlib,dylib -Zstaticlib-prefer-dynamic
 //@ no-prefer-dynamic
+//@ needs-crate-type: dylib
 
 // Test that compiling for multiple crate types in a single compilation with
 // mismatching allocator shim requirements doesn't result in the allocator shim

From ac89fcbc55181754dd58b90ed31175f72ed93589 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Sun, 31 Aug 2025 18:31:59 -0700
Subject: [PATCH 0371/1889] rustdoc-search: skip loading unneeded fnData

---
 src/librustdoc/html/static/js/rustdoc.d.ts |  2 +-
 src/librustdoc/html/static/js/search.js    | 23 +++++++++++-----------
 2 files changed, 13 insertions(+), 12 deletions(-)

diff --git a/src/librustdoc/html/static/js/rustdoc.d.ts b/src/librustdoc/html/static/js/rustdoc.d.ts
index 74f646008ebd7..938ccc7d2c32e 100644
--- a/src/librustdoc/html/static/js/rustdoc.d.ts
+++ b/src/librustdoc/html/static/js/rustdoc.d.ts
@@ -289,7 +289,7 @@ declare namespace rustdoc {
         exactModulePath: string,
         entry: EntryData?,
         path: PathData?,
-        type: FunctionData?,
+        functionData: FunctionData?,
         deprecated: boolean,
         parent: { path: PathData, name: string}?,
     }
diff --git a/src/librustdoc/html/static/js/search.js b/src/librustdoc/html/static/js/search.js
index fa812a2b67b5a..5da37c97c6a73 100644
--- a/src/librustdoc/html/static/js/search.js
+++ b/src/librustdoc/html/static/js/search.js
@@ -1802,14 +1802,15 @@ class DocSearch {
 
     /**
      * @param {number} id
+     * @param {boolean} loadFunctionData
      * @returns {Promise<rustdoc.Row?>}
      */
-    async getRow(id) {
-        const [name_, entry, path, type] = await Promise.all([
+    async getRow(id, loadFunctionData) {
+        const [name_, entry, path, functionData] = await Promise.all([
             this.getName(id),
             this.getEntryData(id),
             this.getPathData(id),
-            this.getFunctionData(id),
+            loadFunctionData ? this.getFunctionData(id) : null,
         ]);
         if (!entry && !path) {
             return null;
@@ -1853,7 +1854,7 @@ class DocSearch {
                     `${exactModulePathData.exactModulePath}::${exactModuleName}`),
             entry,
             path,
-            type,
+            functionData,
             deprecated: entry ? entry.deprecated : false,
             parent: parentName !== null && parentPath !== null ?
                 { name: parentName, path: parentPath } :
@@ -2563,11 +2564,11 @@ class DocSearch {
                             name: item.parent.name,
                             ty: item.parent.path.ty,
                         } : undefined,
-                        type: item.type && item.type.functionSignature ?
-                            item.type.functionSignature :
+                        type: item.functionData && item.functionData.functionSignature ?
+                            item.functionData.functionSignature :
                             undefined,
-                        paramNames: item.type && item.type.paramNames ?
-                            item.type.paramNames :
+                        paramNames: item.functionData && item.functionData.paramNames ?
+                            item.functionData.paramNames :
                             undefined,
                         dist: result.dist,
                         path_dist: result.path_dist,
@@ -2642,7 +2643,7 @@ class DocSearch {
                     /**
                      * @type {rustdoc.Row?}
                      */
-                    const item = await this.getRow(result.id);
+                    const item = await this.getRow(result.id, typeInfo !== null);
                     if (!item) {
                         continue;
                     }
@@ -3749,7 +3750,7 @@ class DocSearch {
                         is_alias: true,
                         elems: [], // only used in type-based queries
                         returned: [], // only used in type-based queries
-                        original: await this.getRow(alias),
+                        original: await this.getRow(alias, false),
                     };
                 };
                 /**
@@ -3804,7 +3805,7 @@ class DocSearch {
                  * @returns {Promise<rustdoc.PlainResultObject?>}
                  */
                 const handleNameSearch = async id => {
-                    const row = await this.getRow(id);
+                    const row = await this.getRow(id, false);
                     if (!row || !row.entry) {
                         return null;
                     }

From 988c077b068b9e6fb4e58650d7e921993a650983 Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Mon, 1 Sep 2025 04:55:23 +0000
Subject: [PATCH 0372/1889] Prepare for merging from rust-lang/rust

This updates the rust-version file to 828e45ad11ce4ab56dd64e93f1fb5dd8f0c0ae93.
---
 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 695959e2e68a6..594b47b888f9a 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-e004014d1bf4c29928a0f0f9f7d0964d43606cbd
+828e45ad11ce4ab56dd64e93f1fb5dd8f0c0ae93

From f6e7c81061c24a2210149ff94670d8672bd0224a Mon Sep 17 00:00:00 2001
From: jullang <jullanggit@proton.me>
Date: Sun, 31 Aug 2025 19:27:03 +0000
Subject: [PATCH 0373/1889] Add compiler error when trying to use concat
 metavar expr in repetitions

Replace unimplemented()! with a more helpful compiler error.
---
 compiler/rustc_expand/src/mbe/transcribe.rs   |  7 ++++++-
 tests/crashes/140479.rs                       |  5 -----
 .../in-repetition.rs                          | 21 +++++++++++++++++++
 .../in-repetition.stderr                      |  8 +++++++
 4 files changed, 35 insertions(+), 6 deletions(-)
 delete mode 100644 tests/crashes/140479.rs
 create mode 100644 tests/ui/macros/macro-metavar-expr-concat/in-repetition.rs
 create mode 100644 tests/ui/macros/macro-metavar-expr-concat/in-repetition.stderr

diff --git a/compiler/rustc_expand/src/mbe/transcribe.rs b/compiler/rustc_expand/src/mbe/transcribe.rs
index 174844d6ad639..e4e4866b64cdf 100644
--- a/compiler/rustc_expand/src/mbe/transcribe.rs
+++ b/compiler/rustc_expand/src/mbe/transcribe.rs
@@ -556,7 +556,12 @@ fn metavar_expr_concat<'tx>(
                         };
                         match &named_matches[*curr_idx] {
                             // FIXME(c410-f3r) Nested repetitions are unimplemented
-                            MatchedSeq(_) => unimplemented!(),
+                            MatchedSeq(_) => {
+                                return Err(dcx.struct_span_err(
+                                    ident.span,
+                                    "nested repetitions with `${concat(...)}` metavariable expressions are not yet supported",
+                                ));
+                            }
                             MatchedSingle(pnr) => extract_symbol_from_pnr(dcx, pnr, ident.span)?,
                         }
                     }
diff --git a/tests/crashes/140479.rs b/tests/crashes/140479.rs
deleted file mode 100644
index ed3ca887546f9..0000000000000
--- a/tests/crashes/140479.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-//@ known-bug: #140479
-macro_rules! a { ( $( { $ [ $b:c ] } )) => ( $(${ concat(d, $b)} ))}
-fn e() {
-    a!({})
-}
diff --git a/tests/ui/macros/macro-metavar-expr-concat/in-repetition.rs b/tests/ui/macros/macro-metavar-expr-concat/in-repetition.rs
new file mode 100644
index 0000000000000..d2bd31b06d606
--- /dev/null
+++ b/tests/ui/macros/macro-metavar-expr-concat/in-repetition.rs
@@ -0,0 +1,21 @@
+// issue: <https://github.com/rust-lang/rust/issues/140479>
+// Ensure a proper compiler error, instead of an ICE occurs.
+// FIXME(macro_metavar_expr_concat): this error message could be improved
+#![feature(macro_metavar_expr_concat)]
+
+macro_rules! InRepetition {
+    (
+        $(
+            $($arg:ident),+
+        )+
+     ) => {
+        $(
+            $(
+                ${concat(_, $arg)} //~ ERROR nested repetitions with `${concat(...)}` metavariable expressions are not yet supported
+            )*
+        )*
+    };
+}
+InRepetition!(other);
+
+fn main() {}
diff --git a/tests/ui/macros/macro-metavar-expr-concat/in-repetition.stderr b/tests/ui/macros/macro-metavar-expr-concat/in-repetition.stderr
new file mode 100644
index 0000000000000..ec39ca799e198
--- /dev/null
+++ b/tests/ui/macros/macro-metavar-expr-concat/in-repetition.stderr
@@ -0,0 +1,8 @@
+error: nested repetitions with `${concat(...)}` metavariable expressions are not yet supported
+  --> $DIR/in-repetition.rs:14:30
+   |
+LL |                 ${concat(_, $arg)}
+   |                              ^^^
+
+error: aborting due to 1 previous error
+

From 20a3256bc3b726f5cdc43bd16e6068e4c6fec98a Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 1 Sep 2025 08:45:45 +0200
Subject: [PATCH 0374/1889] improve output for 'cargo miri test --help'

---
 src/tools/miri/cargo-miri/src/phases.rs | 39 +++++++++++++++++--------
 1 file changed, 27 insertions(+), 12 deletions(-)

diff --git a/src/tools/miri/cargo-miri/src/phases.rs b/src/tools/miri/cargo-miri/src/phases.rs
index efb9053f69a5a..0716f4add9d0d 100644
--- a/src/tools/miri/cargo-miri/src/phases.rs
+++ b/src/tools/miri/cargo-miri/src/phases.rs
@@ -65,16 +65,6 @@ fn forward_patched_extern_arg(args: &mut impl Iterator<Item = String>, cmd: &mut
 }
 
 pub fn phase_cargo_miri(mut args: impl Iterator<Item = String>) {
-    // Check for version and help flags even when invoked as `cargo-miri`.
-    if has_arg_flag("--help") || has_arg_flag("-h") {
-        show_help();
-        return;
-    }
-    if has_arg_flag("--version") || has_arg_flag("-V") {
-        show_version();
-        return;
-    }
-
     // Require a subcommand before any flags.
     // We cannot know which of those flags take arguments and which do not,
     // so we cannot detect subcommands later.
@@ -85,11 +75,36 @@ pub fn phase_cargo_miri(mut args: impl Iterator<Item = String>) {
         "setup" => MiriCommand::Setup,
         "test" | "t" | "run" | "r" | "nextest" => MiriCommand::Forward(subcommand),
         "clean" => MiriCommand::Clean,
-        _ =>
+        _ => {
+            // Check for version and help flags.
+            if has_arg_flag("--help") || has_arg_flag("-h") {
+                show_help();
+                return;
+            }
+            if has_arg_flag("--version") || has_arg_flag("-V") {
+                show_version();
+                return;
+            }
             show_error!(
                 "`cargo miri` supports the following subcommands: `run`, `test`, `nextest`, `clean`, and `setup`."
-            ),
+            )
+        }
     };
+    if has_arg_flag("--help") || has_arg_flag("-h") {
+        match subcommand {
+            MiriCommand::Forward(verb) => {
+                println!("`cargo miri {verb}` supports the same flags as `cargo {verb}`:\n");
+                let mut cmd = cargo();
+                cmd.arg(verb);
+                cmd.arg("--help");
+                exec(cmd);
+            }
+            _ => {
+                show_help();
+                return;
+            }
+        }
+    }
     let verbose = num_arg_flag("-v") + num_arg_flag("--verbose");
     let quiet = has_arg_flag("-q") || has_arg_flag("--quiet");
 

From 99583d1aeca1bdc8630e75e2cf6475b8386c711d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Wed, 20 Aug 2025 16:30:02 +0200
Subject: [PATCH 0375/1889] Remove outdated comment

---
 src/bootstrap/src/core/build_steps/test.rs | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index 95be5360b0bb8..f6a912f31900d 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -3246,9 +3246,6 @@ impl Step for Distcheck {
             .map(|args| args.split(" ").map(|s| s.to_string()).collect::<Vec<String>>())
             .unwrap_or_default();
 
-        // FIXME: unpack the source tarballs into a directory outside the source checkout, to
-        // ensure that it cannot access any local state
-        // Also ensure that it doesn't use download-ci-llvm
         command("tar")
             .arg("-xf")
             .arg(plain_src_tarball.tarball())

From 2bfff320bd7e0714fd70a7d8e4c2081a697180d5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Wed, 20 Aug 2025 20:46:54 +0200
Subject: [PATCH 0376/1889] Add some compiletest suites snapshot tests

---
 src/bootstrap/src/core/build_steps/test.rs |  13 +-
 src/bootstrap/src/core/builder/tests.rs    | 155 +++++++++++++++++----
 2 files changed, 133 insertions(+), 35 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index f6a912f31900d..e61be236c021e 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -1476,12 +1476,6 @@ macro_rules! test {
                     }),
                 })
             }
-
-            fn metadata(&self) -> Option<StepMetadata> {
-                Some(
-                    StepMetadata::test(stringify!($name), self.target)
-                )
-            }
         }
     };
 }
@@ -2362,6 +2356,13 @@ HELP: You can add it into `bootstrap.toml` in `rust.codegen-backends = [{name:?}
             try_run_tests(builder, &mut cmd, false);
         }
     }
+
+    fn metadata(&self) -> Option<StepMetadata> {
+        Some(
+            StepMetadata::test(&format!("compiletest-{}", self.suite), self.target)
+                .stage(self.compiler.stage),
+        )
+    }
 }
 
 /// Runs the documentation tests for a book in `src/doc` using the `rustdoc` of `test_compiler`.
diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index 43e67756e7427..e6cf34ed499f1 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -2062,20 +2062,23 @@ mod snapshot {
         [build] rustc 0 <host> -> rustc 1 <host>
         [build] rustc 1 <host> -> std 1 <host>
         [build] rustc 0 <host> -> Compiletest 1 <host>
-        [test] Ui <host>
-        [test] Crashes <host>
+        [test] compiletest-ui 1 <host>
+        [test] compiletest-crashes 1 <host>
         [build] rustc 0 <host> -> CoverageDump 1 <host>
+        [test] compiletest-coverage 1 <host>
+        [test] compiletest-coverage 1 <host>
         [build] rustc 1 <host> -> std 1 <host>
-        [test] CodegenLlvm <host>
-        [test] CodegenUnits <host>
-        [test] AssemblyLlvm <host>
-        [test] Incremental <host>
-        [test] Debuginfo <host>
-        [test] UiFullDeps <host>
+        [test] compiletest-mir-opt 1 <host>
+        [test] compiletest-codegen-llvm 1 <host>
+        [test] compiletest-codegen-units 1 <host>
+        [test] compiletest-assembly-llvm 1 <host>
+        [test] compiletest-incremental 1 <host>
+        [test] compiletest-debuginfo 1 <host>
+        [test] compiletest-ui-fulldeps 1 <host>
         [build] rustdoc 1 <host>
-        [test] Rustdoc <host>
-        [test] CoverageRunRustdoc <host>
-        [test] Pretty <host>
+        [test] compiletest-rustdoc 1 <host>
+        [test] compiletest-coverage-run-rustdoc 1 <host>
+        [test] compiletest-pretty 1 <host>
         [build] rustc 1 <host> -> std 1 <host>
         [build] rustc 0 <host> -> std 0 <host>
         [test] rustc 0 <host> -> CrateLibrustc 1 <host>
@@ -2113,16 +2116,107 @@ mod snapshot {
         [test] rustc 0 <host> -> rust-analyzer 1 <host>
         [build] rustc 0 <host> -> RustdocTheme 1 <host>
         [test] rustdoc-theme 1 <host>
-        [test] RustdocUi <host>
+        [test] compiletest-rustdoc-ui 1 <host>
         [build] rustc 0 <host> -> JsonDocCk 1 <host>
         [build] rustc 0 <host> -> JsonDocLint 1 <host>
-        [test] RustdocJson <host>
+        [test] compiletest-rustdoc-json 1 <host>
         [doc] rustc 0 <host> -> rustc 1 <host>
         [build] rustc 0 <host> -> HtmlChecker 1 <host>
         [test] html-check <host>
         [build] rustc 0 <host> -> RunMakeSupport 1 <host>
         [build] rustc 1 <host> -> cargo 2 <host>
-        [test] RunMake <host>
+        [test] compiletest-run-make 1 <host>
+        ");
+    }
+
+    #[test]
+    fn test_compiletest_suites_stage1() {
+        let ctx = TestCtx::new();
+        insta::assert_snapshot!(
+            ctx.config("test")
+                .args(&["ui", "ui-fulldeps", "run-make", "rustdoc", "rustdoc-gui", "incremental"])
+                .render_steps(), @r"
+        [build] llvm <host>
+        [build] rustc 0 <host> -> rustc 1 <host>
+        [build] rustc 1 <host> -> std 1 <host>
+        [build] rustc 0 <host> -> Compiletest 1 <host>
+        [test] compiletest-ui 1 <host>
+        [test] compiletest-ui-fulldeps 1 <host>
+        [build] rustc 0 <host> -> RunMakeSupport 1 <host>
+        [build] rustc 1 <host> -> cargo 2 <host>
+        [build] rustdoc 1 <host>
+        [test] compiletest-run-make 1 <host>
+        [test] compiletest-rustdoc 1 <host>
+        [build] rustc 0 <host> -> RustdocGUITest 1 <host>
+        [test] rustdoc-gui 1 <host>
+        [test] compiletest-incremental 1 <host>
+        [build] rustc 1 <host> -> rustc 2 <host>
+        ");
+    }
+
+    #[test]
+    fn test_compiletest_suites_stage2() {
+        let ctx = TestCtx::new();
+        insta::assert_snapshot!(
+            ctx.config("test")
+                .args(&["ui", "ui-fulldeps", "run-make", "rustdoc", "rustdoc-gui", "incremental"])
+                .stage(2)
+                .render_steps(), @r"
+        [build] llvm <host>
+        [build] rustc 0 <host> -> rustc 1 <host>
+        [build] rustc 1 <host> -> std 1 <host>
+        [build] rustc 1 <host> -> rustc 2 <host>
+        [build] rustc 2 <host> -> std 2 <host>
+        [build] rustc 0 <host> -> Compiletest 1 <host>
+        [test] compiletest-ui 2 <host>
+        [build] rustc 2 <host> -> rustc 3 <host>
+        [test] compiletest-ui-fulldeps 2 <host>
+        [build] rustc 0 <host> -> RunMakeSupport 1 <host>
+        [build] rustc 2 <host> -> cargo 3 <host>
+        [build] rustdoc 2 <host>
+        [test] compiletest-run-make 2 <host>
+        [test] compiletest-rustdoc 2 <host>
+        [build] rustc 0 <host> -> RustdocGUITest 1 <host>
+        [test] rustdoc-gui 2 <host>
+        [test] compiletest-incremental 2 <host>
+        [build] rustdoc 1 <host>
+        ");
+    }
+
+    #[test]
+    fn test_compiletest_suites_stage2_cross() {
+        let ctx = TestCtx::new();
+        insta::assert_snapshot!(
+            ctx.config("test")
+                .hosts(&[TEST_TRIPLE_1])
+                .targets(&[TEST_TRIPLE_1])
+                .args(&["ui", "ui-fulldeps", "run-make", "rustdoc", "rustdoc-gui", "incremental"])
+                .stage(2)
+                .render_steps(), @r"
+        [build] llvm <host>
+        [build] rustc 0 <host> -> rustc 1 <host>
+        [build] rustc 1 <host> -> std 1 <host>
+        [build] rustc 1 <host> -> rustc 2 <host>
+        [build] rustc 2 <host> -> std 2 <host>
+        [build] rustc 0 <host> -> Compiletest 1 <host>
+        [build] rustc 1 <host> -> std 1 <target1>
+        [build] rustc 2 <host> -> std 2 <target1>
+        [test] compiletest-ui 2 <target1>
+        [build] llvm <target1>
+        [build] rustc 2 <host> -> rustc 3 <target1>
+        [test] compiletest-ui-fulldeps 2 <target1>
+        [build] rustc 0 <host> -> RunMakeSupport 1 <host>
+        [build] rustc 2 <host> -> cargo 3 <host>
+        [build] rustdoc 2 <host>
+        [test] compiletest-run-make 2 <target1>
+        [test] compiletest-rustdoc 2 <target1>
+        [build] rustc 0 <host> -> RustdocGUITest 1 <host>
+        [test] rustdoc-gui 2 <target1>
+        [test] compiletest-incremental 2 <target1>
+        [build] rustc 1 <host> -> rustc 2 <target1>
+        [build] rustdoc 1 <host>
+        [build] rustc 2 <target1> -> std 2 <target1>
+        [build] rustdoc 2 <target1>
         ");
     }
 
@@ -2142,21 +2236,24 @@ mod snapshot {
         [build] rustc 1 <host> -> rustc 2 <host>
         [build] rustc 2 <host> -> std 2 <host>
         [build] rustc 0 <host> -> Compiletest 1 <host>
-        [test] Ui <host>
-        [test] Crashes <host>
+        [test] compiletest-ui 2 <host>
+        [test] compiletest-crashes 2 <host>
         [build] rustc 0 <host> -> CoverageDump 1 <host>
+        [test] compiletest-coverage 2 <host>
+        [test] compiletest-coverage 2 <host>
         [build] rustc 2 <host> -> std 2 <host>
-        [test] CodegenLlvm <host>
-        [test] CodegenUnits <host>
-        [test] AssemblyLlvm <host>
-        [test] Incremental <host>
-        [test] Debuginfo <host>
+        [test] compiletest-mir-opt 2 <host>
+        [test] compiletest-codegen-llvm 2 <host>
+        [test] compiletest-codegen-units 2 <host>
+        [test] compiletest-assembly-llvm 2 <host>
+        [test] compiletest-incremental 2 <host>
+        [test] compiletest-debuginfo 2 <host>
         [build] rustc 2 <host> -> rustc 3 <host>
-        [test] UiFullDeps <host>
+        [test] compiletest-ui-fulldeps 2 <host>
         [build] rustdoc 2 <host>
-        [test] Rustdoc <host>
-        [test] CoverageRunRustdoc <host>
-        [test] Pretty <host>
+        [test] compiletest-rustdoc 2 <host>
+        [test] compiletest-coverage-run-rustdoc 2 <host>
+        [test] compiletest-pretty 2 <host>
         [build] rustc 2 <host> -> std 2 <host>
         [build] rustc 1 <host> -> std 1 <host>
         [build] rustdoc 1 <host>
@@ -2196,16 +2293,16 @@ mod snapshot {
         [test] rustc 1 <host> -> lint-docs 2 <host>
         [build] rustc 0 <host> -> RustdocTheme 1 <host>
         [test] rustdoc-theme 2 <host>
-        [test] RustdocUi <host>
+        [test] compiletest-rustdoc-ui 2 <host>
         [build] rustc 0 <host> -> JsonDocCk 1 <host>
         [build] rustc 0 <host> -> JsonDocLint 1 <host>
-        [test] RustdocJson <host>
+        [test] compiletest-rustdoc-json 2 <host>
         [doc] rustc 1 <host> -> rustc 2 <host>
         [build] rustc 0 <host> -> HtmlChecker 1 <host>
         [test] html-check <host>
         [build] rustc 0 <host> -> RunMakeSupport 1 <host>
         [build] rustc 2 <host> -> cargo 3 <host>
-        [test] RunMake <host>
+        [test] compiletest-run-make 2 <host>
         ");
     }
 
@@ -2249,7 +2346,7 @@ mod snapshot {
         let steps = ctx.config("test").args(&["--skip", "src/tools/tidy"]).get_steps();
 
         let host = TargetSelection::from_user(&host_target());
-        steps.assert_contains(StepMetadata::test("RustdocUi", host));
+        steps.assert_contains(StepMetadata::test("compiletest-rustdoc-ui", host).stage(1));
         steps.assert_not_contains(test::Tidy);
     }
 

From 72167b726c49776b01cd84552ed90761a839ee7b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Wed, 20 Aug 2025 20:39:08 +0200
Subject: [PATCH 0377/1889] Rename `compiler` to `test_compiler`

---
 src/bootstrap/src/core/build_steps/test.rs | 101 +++++++++++----------
 1 file changed, 54 insertions(+), 47 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index e61be236c021e..295ebfc3638db 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -1079,7 +1079,7 @@ impl Step for RustdocJSNotStd {
 
     fn run(self, builder: &Builder<'_>) {
         builder.ensure(Compiletest {
-            compiler: self.compiler,
+            test_compiler: self.compiler,
             target: self.target,
             mode: "rustdoc-js",
             suite: "rustdoc-js",
@@ -1437,8 +1437,8 @@ macro_rules! test {
         $( #[$attr] )*
         #[derive(Debug, Clone, PartialEq, Eq, Hash)]
         pub struct $name {
-            pub compiler: Compiler,
-            pub target: TargetSelection,
+            test_compiler: Compiler,
+            target: TargetSelection,
         }
 
         impl Step for $name {
@@ -1456,14 +1456,14 @@ macro_rules! test {
             }
 
             fn make_run(run: RunConfig<'_>) {
-                let compiler = run.builder.compiler(run.builder.top_stage, run.build_triple());
+                let test_compiler = run.builder.compiler(run.builder.top_stage, run.build_triple());
 
-                run.builder.ensure($name { compiler, target: run.target });
+                run.builder.ensure($name { test_compiler, target: run.target });
             }
 
             fn run(self, builder: &Builder<'_>) {
                 builder.ensure(Compiletest {
-                    compiler: self.compiler,
+                    test_compiler: self.test_compiler,
                     target: self.target,
                     mode: $mode,
                     suite: $suite,
@@ -1644,7 +1644,7 @@ impl Step for Coverage {
         // Like other compiletest suite test steps, delegate to an internal
         // compiletest task to actually run the tests.
         builder.ensure(Compiletest {
-            compiler,
+            test_compiler: compiler,
             target,
             mode,
             suite: Self::SUITE,
@@ -1685,7 +1685,7 @@ impl Step for MirOpt {
     fn run(self, builder: &Builder<'_>) {
         let run = |target| {
             builder.ensure(Compiletest {
-                compiler: self.compiler,
+                test_compiler: self.compiler,
                 target,
                 mode: "mir-opt",
                 suite: "mir-opt",
@@ -1720,9 +1720,15 @@ impl Step for MirOpt {
     }
 }
 
+/// Executes the `compiletest` tool to run a suite of tests.
+///
+/// Compiles all tests with `test_compiler` for `target` with the specified
+/// compiletest `mode` and `suite` arguments. For example `mode` can be
+/// "run-pass" or `suite` can be something like `debuginfo`.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 struct Compiletest {
-    compiler: Compiler,
+    /// The compiler that we're testing.
+    test_compiler: Compiler,
     target: TargetSelection,
     mode: &'static str,
     suite: &'static str,
@@ -1737,11 +1743,6 @@ impl Step for Compiletest {
         run.never()
     }
 
-    /// Executes the `compiletest` tool to run a suite of tests.
-    ///
-    /// Compiles all tests with `compiler` for `target` with the specified
-    /// compiletest `mode` and `suite` arguments. For example `mode` can be
-    /// "run-pass" or `suite` can be something like `debuginfo`.
     fn run(self, builder: &Builder<'_>) {
         if builder.doc_tests == DocTests::Only {
             return;
@@ -1756,7 +1757,7 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
             crate::exit!(1);
         }
 
-        let mut compiler = self.compiler;
+        let mut test_compiler = self.test_compiler;
         let target = self.target;
         let mode = self.mode;
         let suite = self.suite;
@@ -1776,30 +1777,30 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
         // NOTE: Only stage 1 is special cased because we need the rustc_private artifacts to match the
         // running compiler in stage 2 when plugins run.
         let query_compiler;
-        let (stage, stage_id) = if suite == "ui-fulldeps" && compiler.stage == 1 {
+        let (stage, stage_id) = if suite == "ui-fulldeps" && test_compiler.stage == 1 {
             // Even when using the stage 0 compiler, we also need to provide the stage 1 compiler
             // so that compiletest can query it for target information.
-            query_compiler = Some(compiler);
+            query_compiler = Some(test_compiler);
             // At stage 0 (stage - 1) we are using the stage0 compiler. Using `self.target` can lead
             // finding an incorrect compiler path on cross-targets, as the stage 0 is always equal to
             // `build.build` in the configuration.
             let build = builder.build.host_target;
-            compiler = builder.compiler(compiler.stage - 1, build);
-            let test_stage = compiler.stage + 1;
+            test_compiler = builder.compiler(test_compiler.stage - 1, build);
+            let test_stage = test_compiler.stage + 1;
             (test_stage, format!("stage{test_stage}-{build}"))
         } else {
             query_compiler = None;
-            let stage = compiler.stage;
+            let stage = test_compiler.stage;
             (stage, format!("stage{stage}-{target}"))
         };
 
         if suite.ends_with("fulldeps") {
-            builder.ensure(compile::Rustc::new(compiler, target));
+            builder.ensure(compile::Rustc::new(test_compiler, target));
         }
 
         if suite == "debuginfo" {
             builder.ensure(dist::DebuggerScripts {
-                sysroot: builder.sysroot(compiler).to_path_buf(),
+                sysroot: builder.sysroot(test_compiler).to_path_buf(),
                 target,
             });
         }
@@ -1809,20 +1810,22 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
 
         // ensure that `libproc_macro` is available on the host.
         if suite == "mir-opt" {
-            builder.ensure(compile::Std::new(compiler, compiler.host).is_for_mir_opt_tests(true));
+            builder.ensure(
+                compile::Std::new(test_compiler, test_compiler.host).is_for_mir_opt_tests(true),
+            );
         } else {
-            builder.std(compiler, compiler.host);
+            builder.std(test_compiler, test_compiler.host);
         }
 
         let mut cmd = builder.tool_cmd(Tool::Compiletest);
 
         if suite == "mir-opt" {
-            builder.ensure(compile::Std::new(compiler, target).is_for_mir_opt_tests(true));
+            builder.ensure(compile::Std::new(test_compiler, target).is_for_mir_opt_tests(true));
         } else {
-            builder.std(compiler, target);
+            builder.std(test_compiler, target);
         }
 
-        builder.ensure(RemoteCopyLibs { build_compiler: compiler, target });
+        builder.ensure(RemoteCopyLibs { build_compiler: test_compiler, target });
 
         // compiletest currently has... a lot of arguments, so let's just pass all
         // of them!
@@ -1830,9 +1833,9 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
         cmd.arg("--stage").arg(stage.to_string());
         cmd.arg("--stage-id").arg(stage_id);
 
-        cmd.arg("--compile-lib-path").arg(builder.rustc_libdir(compiler));
-        cmd.arg("--run-lib-path").arg(builder.sysroot_target_libdir(compiler, target));
-        cmd.arg("--rustc-path").arg(builder.rustc(compiler));
+        cmd.arg("--compile-lib-path").arg(builder.rustc_libdir(test_compiler));
+        cmd.arg("--run-lib-path").arg(builder.sysroot_target_libdir(test_compiler, target));
+        cmd.arg("--rustc-path").arg(builder.rustc(test_compiler));
         if let Some(query_compiler) = query_compiler {
             cmd.arg("--query-rustc-path").arg(builder.rustc(query_compiler));
         }
@@ -1849,14 +1852,16 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
                 // If we're using `--stage 0`, we should provide the bootstrap cargo.
                 builder.initial_cargo.clone()
             } else {
-                builder.ensure(tool::Cargo::from_build_compiler(compiler, compiler.host)).tool_path
+                builder
+                    .ensure(tool::Cargo::from_build_compiler(test_compiler, test_compiler.host))
+                    .tool_path
             };
 
             cmd.arg("--cargo-path").arg(cargo_path);
 
             // We need to pass the compiler that was used to compile run-make-support,
             // because we have to use the same compiler to compile rmake.rs recipes.
-            let stage0_rustc_path = builder.compiler(0, compiler.host);
+            let stage0_rustc_path = builder.compiler(0, test_compiler.host);
             cmd.arg("--stage0-rustc-path").arg(builder.rustc(stage0_rustc_path));
         }
 
@@ -1868,7 +1873,7 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
             || mode == "rustdoc-json"
             || suite == "coverage-run-rustdoc"
         {
-            cmd.arg("--rustdoc-path").arg(builder.rustdoc_for_compiler(compiler));
+            cmd.arg("--rustdoc-path").arg(builder.rustdoc_for_compiler(test_compiler));
         }
 
         if mode == "rustdoc-json" {
@@ -1893,14 +1898,14 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
         // directory immediately under the root build directory, and the test-suite-specific build
         // directory.
         cmd.arg("--build-root").arg(&builder.out);
-        cmd.arg("--build-test-suite-root").arg(testdir(builder, compiler.host).join(suite));
+        cmd.arg("--build-test-suite-root").arg(testdir(builder, test_compiler.host).join(suite));
 
         // When top stage is 0, that means that we're testing an externally provided compiler.
         // In that case we need to use its specific sysroot for tests to pass.
         let sysroot = if builder.top_stage == 0 {
             builder.initial_sysroot.clone()
         } else {
-            builder.sysroot(compiler)
+            builder.sysroot(test_compiler)
         };
 
         cmd.arg("--sysroot-base").arg(sysroot);
@@ -1908,11 +1913,11 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
         cmd.arg("--suite").arg(suite);
         cmd.arg("--mode").arg(mode);
         cmd.arg("--target").arg(target.rustc_target_arg());
-        cmd.arg("--host").arg(&*compiler.host.triple);
+        cmd.arg("--host").arg(&*test_compiler.host.triple);
         cmd.arg("--llvm-filecheck").arg(builder.llvm_filecheck(builder.config.host_target));
 
         if let Some(codegen_backend) = builder.config.cmd.test_codegen_backend() {
-            if !builder.config.enabled_codegen_backends(compiler.host).contains(codegen_backend) {
+            if !builder.config.enabled_codegen_backends(test_compiler.host).contains(codegen_backend) {
                 eprintln!(
                     "\
 ERROR: No configured backend named `{name}`
@@ -1931,7 +1936,7 @@ HELP: You can add it into `bootstrap.toml` in `rust.codegen-backends = [{name:?}
             // Tells compiletest which codegen backend to use.
             // It is used to e.g. ignore tests that don't support that codegen backend.
             cmd.arg("--default-codegen-backend")
-                .arg(builder.config.default_codegen_backend(compiler.host).name());
+                .arg(builder.config.default_codegen_backend(test_compiler.host).name());
         }
 
         if builder.build.config.llvm_enzyme {
@@ -2011,7 +2016,7 @@ HELP: You can add it into `bootstrap.toml` in `rust.codegen-backends = [{name:?}
             if let Some(linker) = builder.linker(target) {
                 cmd.arg("--target-linker").arg(linker);
             }
-            if let Some(linker) = builder.linker(compiler.host) {
+            if let Some(linker) = builder.linker(test_compiler.host) {
                 cmd.arg("--host-linker").arg(linker);
             }
         }
@@ -2022,16 +2027,18 @@ HELP: You can add it into `bootstrap.toml` in `rust.codegen-backends = [{name:?}
         }
 
         let mut hostflags = flags.clone();
-        hostflags.extend(linker_flags(builder, compiler.host, LldThreads::No));
+        hostflags.extend(linker_flags(builder, test_compiler.host, LldThreads::No));
 
         let mut targetflags = flags;
 
         // Provide `rust_test_helpers` for both host and target.
         if suite == "ui" || suite == "incremental" {
-            builder.ensure(TestHelpers { target: compiler.host });
+            builder.ensure(TestHelpers { target: test_compiler.host });
             builder.ensure(TestHelpers { target });
-            hostflags
-                .push(format!("-Lnative={}", builder.test_helpers_out(compiler.host).display()));
+            hostflags.push(format!(
+                "-Lnative={}",
+                builder.test_helpers_out(test_compiler.host).display()
+            ));
             targetflags.push(format!("-Lnative={}", builder.test_helpers_out(target).display()));
         }
 
@@ -2116,7 +2123,7 @@ HELP: You can add it into `bootstrap.toml` in `rust.codegen-backends = [{name:?}
 
         let mut llvm_components_passed = false;
         let mut copts_passed = false;
-        if builder.config.llvm_enabled(compiler.host) {
+        if builder.config.llvm_enabled(test_compiler.host) {
             let llvm::LlvmResult { host_llvm_config, .. } =
                 builder.ensure(llvm::Llvm { target: builder.config.host_target });
             if !builder.config.dry_run() {
@@ -2327,7 +2334,7 @@ HELP: You can add it into `bootstrap.toml` in `rust.codegen-backends = [{name:?}
             format!("compiletest suite={suite} mode={mode}"),
             // FIXME: compiletest sometimes behaves as ToolStd, we could expose that difference here
             Mode::ToolBootstrap,
-            compiler,
+            test_compiler,
             target,
         );
         try_run_tests(builder, &mut cmd, false);
@@ -2350,7 +2357,7 @@ HELP: You can add it into `bootstrap.toml` in `rust.codegen-backends = [{name:?}
 
             builder.info(&format!(
                 "Check compiletest suite={} mode={} compare_mode={} ({} -> {})",
-                suite, mode, compare_mode, &compiler.host, target
+                suite, mode, compare_mode, &test_compiler.host, target
             ));
             let _time = helpers::timeit(builder);
             try_run_tests(builder, &mut cmd, false);
@@ -2360,7 +2367,7 @@ HELP: You can add it into `bootstrap.toml` in `rust.codegen-backends = [{name:?}
     fn metadata(&self) -> Option<StepMetadata> {
         Some(
             StepMetadata::test(&format!("compiletest-{}", self.suite), self.target)
-                .stage(self.compiler.stage),
+                .stage(self.test_compiler.stage),
         )
     }
 }

From 8e97112ba83c97891bcaafa13f099bd22ccd29f8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Wed, 20 Aug 2025 20:39:15 +0200
Subject: [PATCH 0378/1889] Remove `Compiler::with_stage`

---
 src/bootstrap/src/core/build_steps/test.rs | 2 +-
 src/bootstrap/src/lib.rs                   | 5 -----
 2 files changed, 1 insertion(+), 6 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index 295ebfc3638db..3938c64032133 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -1878,7 +1878,7 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
 
         if mode == "rustdoc-json" {
             // Use the stage0 compiler for jsondocck
-            let json_compiler = compiler.with_stage(0);
+            let json_compiler = builder.compiler(0, builder.host_target);
             cmd.arg("--jsondocck-path")
                 .arg(builder.ensure(tool::JsonDocCk { compiler: json_compiler, target }).tool_path);
             cmd.arg("--jsondoclint-path").arg(
diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs
index 9a882eae08edf..2108f3b8cf5dc 100644
--- a/src/bootstrap/src/lib.rs
+++ b/src/bootstrap/src/lib.rs
@@ -2109,11 +2109,6 @@ impl Compiler {
         self.forced_compiler = forced_compiler;
     }
 
-    pub fn with_stage(mut self, stage: u32) -> Compiler {
-        self.stage = stage;
-        self
-    }
-
     /// Returns `true` if this is a snapshot compiler for `build`'s configuration
     pub fn is_snapshot(&self, build: &Build) -> bool {
         self.stage == 0 && self.host == build.host_target

From 6c3a86b73b6ce93f392768f5cdc9da9bd6283b32 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Wed, 20 Aug 2025 20:42:08 +0200
Subject: [PATCH 0379/1889] Do not run `lint-docs` tests in stage 1 `x test` by
 default

---
 src/bootstrap/src/core/build_steps/test.rs |  9 ++++++---
 src/bootstrap/src/core/builder/tests.rs    | 10 +++++-----
 2 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index 3938c64032133..97db9bf536fdf 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -1848,12 +1848,15 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
         let is_rustdoc = suite == "rustdoc-ui" || suite == "rustdoc-js";
 
         if mode == "run-make" {
-            let cargo_path = if builder.top_stage == 0 {
+            let cargo_path = if test_compiler.stage == 0 {
                 // If we're using `--stage 0`, we should provide the bootstrap cargo.
                 builder.initial_cargo.clone()
             } else {
                 builder
-                    .ensure(tool::Cargo::from_build_compiler(test_compiler, test_compiler.host))
+                    .ensure(tool::Cargo::from_build_compiler(
+                        builder.compiler(test_compiler.stage - 1, test_compiler.host),
+                        test_compiler.host,
+                    ))
                     .tool_path
             };
 
@@ -1902,7 +1905,7 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
 
         // When top stage is 0, that means that we're testing an externally provided compiler.
         // In that case we need to use its specific sysroot for tests to pass.
-        let sysroot = if builder.top_stage == 0 {
+        let sysroot = if test_compiler.stage == 0 {
             builder.initial_sysroot.clone()
         } else {
             builder.sysroot(test_compiler)
diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index e6cf34ed499f1..ef01f14f5e9a5 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -2124,7 +2124,7 @@ mod snapshot {
         [build] rustc 0 <host> -> HtmlChecker 1 <host>
         [test] html-check <host>
         [build] rustc 0 <host> -> RunMakeSupport 1 <host>
-        [build] rustc 1 <host> -> cargo 2 <host>
+        [build] rustc 0 <host> -> cargo 1 <host>
         [test] compiletest-run-make 1 <host>
         ");
     }
@@ -2143,7 +2143,7 @@ mod snapshot {
         [test] compiletest-ui 1 <host>
         [test] compiletest-ui-fulldeps 1 <host>
         [build] rustc 0 <host> -> RunMakeSupport 1 <host>
-        [build] rustc 1 <host> -> cargo 2 <host>
+        [build] rustc 0 <host> -> cargo 1 <host>
         [build] rustdoc 1 <host>
         [test] compiletest-run-make 1 <host>
         [test] compiletest-rustdoc 1 <host>
@@ -2172,7 +2172,7 @@ mod snapshot {
         [build] rustc 2 <host> -> rustc 3 <host>
         [test] compiletest-ui-fulldeps 2 <host>
         [build] rustc 0 <host> -> RunMakeSupport 1 <host>
-        [build] rustc 2 <host> -> cargo 3 <host>
+        [build] rustc 1 <host> -> cargo 2 <host>
         [build] rustdoc 2 <host>
         [test] compiletest-run-make 2 <host>
         [test] compiletest-rustdoc 2 <host>
@@ -2206,7 +2206,7 @@ mod snapshot {
         [build] rustc 2 <host> -> rustc 3 <target1>
         [test] compiletest-ui-fulldeps 2 <target1>
         [build] rustc 0 <host> -> RunMakeSupport 1 <host>
-        [build] rustc 2 <host> -> cargo 3 <host>
+        [build] rustc 1 <host> -> cargo 2 <host>
         [build] rustdoc 2 <host>
         [test] compiletest-run-make 2 <target1>
         [test] compiletest-rustdoc 2 <target1>
@@ -2301,7 +2301,7 @@ mod snapshot {
         [build] rustc 0 <host> -> HtmlChecker 1 <host>
         [test] html-check <host>
         [build] rustc 0 <host> -> RunMakeSupport 1 <host>
-        [build] rustc 2 <host> -> cargo 3 <host>
+        [build] rustc 1 <host> -> cargo 2 <host>
         [test] compiletest-run-make 2 <host>
         ");
     }

From c206945328050c45704f64e77ac88a19b5bac4a4 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Mon, 1 Sep 2025 11:10:19 +0200
Subject: [PATCH 0380/1889] Revert "dates: refresh type system & traits date
 annotations to Aug/2025"

---
 .../src/borrow_check/region_inference/member_constraints.md   | 2 +-
 .../rustc-dev-guide/src/opaque-types-type-alias-impl-trait.md | 2 +-
 src/doc/rustc-dev-guide/src/stability.md                      | 2 +-
 src/doc/rustc-dev-guide/src/thir.md                           | 4 ++--
 src/doc/rustc-dev-guide/src/traits/chalk.md                   | 2 +-
 src/doc/rustc-dev-guide/src/traits/resolution.md              | 2 +-
 src/doc/rustc-dev-guide/src/ty-fold.md                        | 2 +-
 src/doc/rustc-dev-guide/src/type-inference.md                 | 2 +-
 8 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/borrow_check/region_inference/member_constraints.md b/src/doc/rustc-dev-guide/src/borrow_check/region_inference/member_constraints.md
index 52e7400ffde7e..2804c97724f5a 100644
--- a/src/doc/rustc-dev-guide/src/borrow_check/region_inference/member_constraints.md
+++ b/src/doc/rustc-dev-guide/src/borrow_check/region_inference/member_constraints.md
@@ -92,7 +92,7 @@ member constraints come in.
 ## Choices are always lifetime parameters
 
 At present, the "choice" regions from a member constraint are always lifetime
-parameters from the current function. As of <!-- date-check --> August 2025,
+parameters from the current function. As of <!-- date-check --> October 2021,
 this falls out from the placement of impl Trait, though in the future it may not
 be the case. We take some advantage of this fact, as it simplifies the current
 code. In particular, we don't have to consider a case like `'0 member of ['1,
diff --git a/src/doc/rustc-dev-guide/src/opaque-types-type-alias-impl-trait.md b/src/doc/rustc-dev-guide/src/opaque-types-type-alias-impl-trait.md
index 5a4a31e0a82d6..956f568285a02 100644
--- a/src/doc/rustc-dev-guide/src/opaque-types-type-alias-impl-trait.md
+++ b/src/doc/rustc-dev-guide/src/opaque-types-type-alias-impl-trait.md
@@ -15,7 +15,7 @@ it implements `Bar`. Therefore, any of `Bar`'s interface can be used on a `Foo`,
 but nothing else (regardless of whether it implements any other traits).
 
 Since there needs to be a concrete background type,
-you can (as of <!-- date-check --> August 2025) express that type
+you can (as of <!-- date-check --> January 2021) express that type
 by using the opaque type in a "defining use site".
 
 ```rust,ignore
diff --git a/src/doc/rustc-dev-guide/src/stability.md b/src/doc/rustc-dev-guide/src/stability.md
index 665215fda049e..3c4c65fdd5a88 100644
--- a/src/doc/rustc-dev-guide/src/stability.md
+++ b/src/doc/rustc-dev-guide/src/stability.md
@@ -30,7 +30,7 @@ unstable modules or vice versa.
 
 Previously, due to a [rustc bug], stable items inside unstable modules were
 available to stable code in that location.
-As of <!-- date-check --> August 2025, items with [accidentally stabilized
+As of <!-- date-check --> September 2024, items with [accidentally stabilized
 paths] are marked with the `#[rustc_allowed_through_unstable_modules]` attribute
 to prevent code dependent on those paths from breaking. Do *not* add this attribute
 to any more items unless that is needed to avoid breaking changes.
diff --git a/src/doc/rustc-dev-guide/src/thir.md b/src/doc/rustc-dev-guide/src/thir.md
index 6a3525d5b8f8c..3d3dafaef49ba 100644
--- a/src/doc/rustc-dev-guide/src/thir.md
+++ b/src/doc/rustc-dev-guide/src/thir.md
@@ -2,7 +2,7 @@
 
 The THIR ("Typed High-Level Intermediate Representation"), previously called HAIR for
 "High-Level Abstract IR", is another IR used by rustc that is generated after
-[type checking]. It is (as of <!-- date-check --> August 2025) used for
+[type checking]. It is (as of <!-- date-check --> January 2024) used for
 [MIR construction], [exhaustiveness checking], and [unsafety checking].
 
 [type checking]: ./type-checking.md
@@ -52,7 +52,7 @@ fn main() {
 }
 ```
 
-Here is how that gets represented in THIR (as of <!-- date-check --> August 2025):
+Here is how that gets represented in THIR (as of <!-- date-check --> Aug 2022):
 
 ```rust,no_run
 Thir {
diff --git a/src/doc/rustc-dev-guide/src/traits/chalk.md b/src/doc/rustc-dev-guide/src/traits/chalk.md
index eac8e6b5c2045..844f42b9879f8 100644
--- a/src/doc/rustc-dev-guide/src/traits/chalk.md
+++ b/src/doc/rustc-dev-guide/src/traits/chalk.md
@@ -1,7 +1,7 @@
 # Chalk-based trait solving
 
 [Chalk][chalk] is an experimental trait solver for Rust that is
-(as of <!-- date-check --> August 2025) under development by the [Types team].
+(as of <!-- date-check --> May 2022) under development by the [Types team].
 Its goal is to enable a lot of trait system features and bug fixes
 that are hard to implement (e.g. GATs or specialization). If you would like to
 help in hacking on the new solver, drop by on the rust-lang Zulip in the [`#t-types`]
diff --git a/src/doc/rustc-dev-guide/src/traits/resolution.md b/src/doc/rustc-dev-guide/src/traits/resolution.md
index 711b7ebe65efe..ccb2b04268e85 100644
--- a/src/doc/rustc-dev-guide/src/traits/resolution.md
+++ b/src/doc/rustc-dev-guide/src/traits/resolution.md
@@ -120,7 +120,7 @@ the obligation contains unbound inference variables.
 
 The subroutines that decide whether a particular impl/where-clause/etc applies
 to a particular obligation are collectively referred to as the process of
-_matching_. For `impl` candidates <!-- date-check: Aug 2025 -->,
+_matching_. For `impl` candidates <!-- date-check: Oct 2022 -->,
 this amounts to unifying the impl header (the `Self` type and the trait arguments)
 while ignoring  nested obligations. If matching succeeds then we add it
 to a set of candidates. There are other rules when assembling candidates for
diff --git a/src/doc/rustc-dev-guide/src/ty-fold.md b/src/doc/rustc-dev-guide/src/ty-fold.md
index d0fa548a6250e..23253022ffe27 100644
--- a/src/doc/rustc-dev-guide/src/ty-fold.md
+++ b/src/doc/rustc-dev-guide/src/ty-fold.md
@@ -1,4 +1,4 @@
-<!-- date-check: Aug 2025 -->
+<!-- date-check: may 2024 -->
 # `TypeFoldable` and `TypeFolder`
 
 In [a previous chapter], we discussed instantiating binders.
diff --git a/src/doc/rustc-dev-guide/src/type-inference.md b/src/doc/rustc-dev-guide/src/type-inference.md
index 0c7e2839b2895..2243205f129b5 100644
--- a/src/doc/rustc-dev-guide/src/type-inference.md
+++ b/src/doc/rustc-dev-guide/src/type-inference.md
@@ -66,7 +66,7 @@ inference works, or perhaps this blog post on
 [Unification in the Chalk project]: http://smallcultfollowing.com/babysteps/blog/2017/03/25/unification-in-chalk-part-1/
 
 All told, the inference context stores five kinds of inference variables
-(as of <!-- date-check --> August 2025):
+(as of <!-- date-check --> March 2023):
 
 - Type variables, which come in three varieties:
   - General type variables (the most common). These can be unified with any

From eab1ffd520f375a58b19810d94205ef04ca361e0 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Mon, 1 Sep 2025 11:13:46 +0200
Subject: [PATCH 0381/1889] Revert "dates: refresh query-system date
 annotations to 2025-08 (preserve style)"

---
 .../src/queries/query-evaluation-model-in-detail.md             | 2 +-
 src/doc/rustc-dev-guide/src/queries/salsa.md                    | 2 +-
 src/doc/rustc-dev-guide/src/query.md                            | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/queries/query-evaluation-model-in-detail.md b/src/doc/rustc-dev-guide/src/queries/query-evaluation-model-in-detail.md
index f487707cd327e..c1a4373f7dac6 100644
--- a/src/doc/rustc-dev-guide/src/queries/query-evaluation-model-in-detail.md
+++ b/src/doc/rustc-dev-guide/src/queries/query-evaluation-model-in-detail.md
@@ -74,7 +74,7 @@ executed, no results are cached. But the context already provides access to
 "input" data, i.e. pieces of immutable data that were computed before the
 context was created and that queries can access to do their computations.
 
-As of <!-- date-check --> August 2025, this input data consists mainly of
+As of <!-- date-check --> January 2021, this input data consists mainly of
 the HIR map, upstream crate metadata, and the command-line options the compiler
 was invoked with; but in the future inputs will just consist of command-line
 options and a list of source files -- the HIR map will itself be provided by a
diff --git a/src/doc/rustc-dev-guide/src/queries/salsa.md b/src/doc/rustc-dev-guide/src/queries/salsa.md
index c0caa201f971b..dc7160edc22cd 100644
--- a/src/doc/rustc-dev-guide/src/queries/salsa.md
+++ b/src/doc/rustc-dev-guide/src/queries/salsa.md
@@ -7,7 +7,7 @@ want to watch [Salsa In More
 Depth](https://www.youtube.com/watch?v=i_IhACacPRY), also by Niko
 Matsakis.
 
-> As of <!-- date-check --> August 2025, although Salsa is inspired by (among
+> As of <!-- date-check --> November 2022, although Salsa is inspired by (among
 > other things) rustc's query system, it is not used directly in rustc. It
 > _is_ used in [chalk], an implementation of  Rust's trait system, and
 > extensively in [`rust-analyzer`], the official implementation of the language
diff --git a/src/doc/rustc-dev-guide/src/query.md b/src/doc/rustc-dev-guide/src/query.md
index 0a92731947101..8377a7b2f31a7 100644
--- a/src/doc/rustc-dev-guide/src/query.md
+++ b/src/doc/rustc-dev-guide/src/query.md
@@ -1,7 +1,7 @@
 # Queries: demand-driven compilation
 
 As described in [Overview of the compiler], the Rust compiler
-is still (as of <!-- date-check --> August 2025) transitioning from a
+is still (as of <!-- date-check --> July 2021) transitioning from a
 traditional "pass-based" setup to a "demand-driven" system. The compiler query
 system is the key to rustc's demand-driven organization.
 The idea is pretty simple. Instead of entirely independent passes

From 4ed4837c2bc21ecfc768d1addd9ec7434bdc600e Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Mon, 1 Sep 2025 11:19:14 +0200
Subject: [PATCH 0382/1889] Revert "dates: refresh infra/tooling date
 annotations to Aug 2025"

---
 src/doc/rustc-dev-guide/src/backend/updating-llvm.md | 4 ++--
 src/doc/rustc-dev-guide/src/fuzzing.md               | 2 +-
 src/doc/rustc-dev-guide/src/overview.md              | 2 +-
 src/doc/rustc-dev-guide/src/parallel-rustc.md        | 8 ++++----
 src/doc/rustc-dev-guide/src/profiling.md             | 2 +-
 src/doc/rustc-dev-guide/src/rustdoc-internals.md     | 6 +++---
 6 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/backend/updating-llvm.md b/src/doc/rustc-dev-guide/src/backend/updating-llvm.md
index a4e22b7398403..ebef15d40baf5 100644
--- a/src/doc/rustc-dev-guide/src/backend/updating-llvm.md
+++ b/src/doc/rustc-dev-guide/src/backend/updating-llvm.md
@@ -1,6 +1,6 @@
 # Updating LLVM
 
-<!-- date-check: Aug 2025 -->
+<!-- date-check: Aug 2024 -->
 Rust supports building against multiple LLVM versions:
 
 * Tip-of-tree for the current LLVM development branch is usually supported
@@ -93,7 +93,7 @@ An example PR:
 
 ## New LLVM Release Updates
 
-<!-- date-check: Aug 2025 -->
+<!-- date-check: Jul 2023 -->
 
 Unlike bugfixes,
 updating to a new release of LLVM typically requires a lot more work.
diff --git a/src/doc/rustc-dev-guide/src/fuzzing.md b/src/doc/rustc-dev-guide/src/fuzzing.md
index 540a8c6906150..3000537861778 100644
--- a/src/doc/rustc-dev-guide/src/fuzzing.md
+++ b/src/doc/rustc-dev-guide/src/fuzzing.md
@@ -1,6 +1,6 @@
 # Fuzzing
 
-<!-- date-check: Aug 2025 -->
+<!-- date-check: Mar 2023 -->
 
 For the purposes of this guide, *fuzzing* is any testing methodology that
 involves compiling a wide variety of programs in an attempt to uncover bugs in
diff --git a/src/doc/rustc-dev-guide/src/overview.md b/src/doc/rustc-dev-guide/src/overview.md
index 9f0201942d01d..378d8c4453f89 100644
--- a/src/doc/rustc-dev-guide/src/overview.md
+++ b/src/doc/rustc-dev-guide/src/overview.md
@@ -304,7 +304,7 @@ Moreover, the compiler wasn't originally built to use a query system; the query
 system has been retrofitted into the compiler, so parts of it are not query-fied
 yet. Also, LLVM isn't our code, so that isn't querified either. The plan is to
 eventually query-fy all of the steps listed in the previous section,
-but as of <!-- date-check --> August 2025, only the steps between `HIR` and
+but as of <!-- date-check --> November 2022, only the steps between `HIR` and
 `LLVM-IR` are query-fied. That is, lexing, parsing, name resolution, and macro
 expansion are done all at once for the whole program.
 
diff --git a/src/doc/rustc-dev-guide/src/parallel-rustc.md b/src/doc/rustc-dev-guide/src/parallel-rustc.md
index b448243223f2e..ce69b66c2daf5 100644
--- a/src/doc/rustc-dev-guide/src/parallel-rustc.md
+++ b/src/doc/rustc-dev-guide/src/parallel-rustc.md
@@ -1,14 +1,14 @@
 # Parallel compilation
 
 <div class="warning">
-As of <!-- date-check --> August 2025,
+As of <!-- date-check --> November 2024,
 the parallel front-end is undergoing significant changes,
 so this page contains quite a bit of outdated information.
 
 Tracking issue: <https://github.com/rust-lang/rust/issues/113349>
 </div>
 
-As of <!-- date-check --> August 2025, most of the rust compiler is now
+As of <!-- date-check --> November 2024, most of the rust compiler is now
 parallelized.
 
 - The codegen part is executed concurrently by default. You can use the `-C
@@ -104,7 +104,7 @@ when `parallel-compiler` is true.
 | **ModuleItems::par_foreign_items**(&self, f: impl Fn(ForeignItemId)) | run `f` on all foreign items in the module                   | rustc_middle::hir          |
 
 There are a lot of loops in the compiler which can possibly be parallelized
-using these functions. As of <!-- date-check--> August 2025, scenarios where
+using these functions. As of <!-- date-check--> August 2022, scenarios where
 the parallel iterator function has been used are as follows:
 
 | caller                                                  | scenario                                                     | callee                   |
@@ -155,7 +155,7 @@ open feature tracking issue][tracking].
 
 ## Rustdoc
 
-As of <!-- date-check--> August 2025, there are still a number of steps to
+As of <!-- date-check--> November 2022, there are still a number of steps to
 complete before `rustdoc` rendering can be made parallel (see a open discussion
 of [parallel `rustdoc`][parallel-rustdoc]).
 
diff --git a/src/doc/rustc-dev-guide/src/profiling.md b/src/doc/rustc-dev-guide/src/profiling.md
index 7dfd74aba3a07..de06bd7cda7b3 100644
--- a/src/doc/rustc-dev-guide/src/profiling.md
+++ b/src/doc/rustc-dev-guide/src/profiling.md
@@ -108,6 +108,6 @@ The llvm-lines output is affected by several options.
 
 MIR optimizations have little impact. Compared to the default `RUSTFLAGS="-Z
 mir-opt-level=1"`, level 0 adds 0.3GB and level 2 removes 0.2GB.
-As of <!-- date-check --> August 2025,
+As of <!-- date-check --> July 2022,
 inlining happens in LLVM and GCC codegen backends,
 missing only in the Cranelift one.
diff --git a/src/doc/rustc-dev-guide/src/rustdoc-internals.md b/src/doc/rustc-dev-guide/src/rustdoc-internals.md
index 02abce2e63ad1..4affbafe4777a 100644
--- a/src/doc/rustc-dev-guide/src/rustdoc-internals.md
+++ b/src/doc/rustc-dev-guide/src/rustdoc-internals.md
@@ -99,7 +99,7 @@ regarding dropping private/hidden items can be bypassed by passing
 `--document-private-items` to `rustdoc`. Note that unlike the previous set of [`AST`][ast]
 transformations, the passes are run on the _cleaned_ crate.
 
-Here is the list of passes as of <!-- date-check --> August 2025:
+Here is the list of passes as of <!-- date-check --> March 2023:
 
 - `calculate-doc-coverage` calculates information used for the `--show-coverage`
   flag.
@@ -122,7 +122,7 @@ Here is the list of passes as of <!-- date-check --> August 2025:
   - `bare_urls` detects links that are not linkified, e.g., in Markdown such as
     `Go to https://example.com/.` It suggests wrapping the link with angle brackets:
     `Go to <https://example.com/>.` to linkify it. This is the code behind the <!--
-    date-check: Aug 2025 --> `rustdoc::bare_urls` `lint`.
+    date-check: may 2022 --> `rustdoc::bare_urls` `lint`.
 
   - `check_code_block_syntax` validates syntax inside Rust code blocks
     (<code>```rust</code>)
@@ -212,7 +212,7 @@ directly, even during `HTML` generation. This [didn't used to be the case], and
 a lot of `rustdoc`'s architecture was designed around not doing that, but a
 `TyCtxt` is now passed to `formats::renderer::run_format`, which is used to
 run generation for both `HTML` and the
-(unstable as of <!-- date-check --> August 2025) JSON format.
+(unstable as of <!-- date-check --> March 2023) JSON format.
 
 This change has allowed other changes to remove data from the "clean" [`AST`][ast]
 that can be easily derived from `TyCtxt` queries, and we'll usually accept

From 2453e05b1d4f0a62b3c2aa85a8ee72b900159127 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Mon, 1 Sep 2025 11:21:20 +0200
Subject: [PATCH 0383/1889] Revert "dates: refresh diagnostics/ and tests/
 annotated dates to August 2025"

---
 src/doc/rustc-dev-guide/src/diagnostics/diagnostic-items.md | 2 +-
 src/doc/rustc-dev-guide/src/diagnostics/error-codes.md      | 2 +-
 src/doc/rustc-dev-guide/src/diagnostics/lintstore.md        | 2 +-
 src/doc/rustc-dev-guide/src/diagnostics/translation.md      | 4 ++--
 src/doc/rustc-dev-guide/src/tests/ci.md                     | 2 +-
 src/doc/rustc-dev-guide/src/tests/directives.md             | 4 ++--
 src/doc/rustc-dev-guide/src/tests/misc.md                   | 2 +-
 7 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/diagnostics/diagnostic-items.md b/src/doc/rustc-dev-guide/src/diagnostics/diagnostic-items.md
index 4000cbdb8ceae..9360427d660e2 100644
--- a/src/doc/rustc-dev-guide/src/diagnostics/diagnostic-items.md
+++ b/src/doc/rustc-dev-guide/src/diagnostics/diagnostic-items.md
@@ -48,7 +48,7 @@ A new diagnostic item can be added with these two steps:
     For the naming conventions of diagnostic items, please refer to
     [*Naming Conventions*](#naming-conventions).
 
-2. <!-- date-check: Aug 2025 -->
+2. <!-- date-check: Feb 2023 -->
    Diagnostic items in code are accessed via symbols in
    [`rustc_span::symbol::sym`].
    To add your newly-created diagnostic item,
diff --git a/src/doc/rustc-dev-guide/src/diagnostics/error-codes.md b/src/doc/rustc-dev-guide/src/diagnostics/error-codes.md
index 98d9a7ab0a18e..1693432b90de7 100644
--- a/src/doc/rustc-dev-guide/src/diagnostics/error-codes.md
+++ b/src/doc/rustc-dev-guide/src/diagnostics/error-codes.md
@@ -10,7 +10,7 @@ explanation: new error codes must include them. Note that not all _historical_
 The explanations are written in Markdown (see the [CommonMark Spec] for
 specifics around syntax), and all of them are linked in the [`rustc_error_codes`]
 crate. Please read [RFC 1567] for details on how to format and write long error
-codes. As of <!-- date-check --> August 2025, there is an
+codes. As of <!-- date-check --> February 2023, there is an
 effort[^new-explanations] to replace this largely outdated RFC with a new more
 flexible standard.
 
diff --git a/src/doc/rustc-dev-guide/src/diagnostics/lintstore.md b/src/doc/rustc-dev-guide/src/diagnostics/lintstore.md
index f0d349c91b969..7b98bc62116b4 100644
--- a/src/doc/rustc-dev-guide/src/diagnostics/lintstore.md
+++ b/src/doc/rustc-dev-guide/src/diagnostics/lintstore.md
@@ -21,7 +21,7 @@ which boils down to a static with type [`&rustc_lint_defs::Lint`]
 as the macro is somewhat unwieldy to add new fields to,
 like all macros).
 
-As of <!-- date-check --> Aug 2025,
+As of <!-- date-check --> Aug 2022,
 we lint against direct declarations without the use of the macro.
 
 Lint declarations don't carry any "state" - they are merely global identifiers
diff --git a/src/doc/rustc-dev-guide/src/diagnostics/translation.md b/src/doc/rustc-dev-guide/src/diagnostics/translation.md
index 5d143da2bad13..58d75f54a005b 100644
--- a/src/doc/rustc-dev-guide/src/diagnostics/translation.md
+++ b/src/doc/rustc-dev-guide/src/diagnostics/translation.md
@@ -2,12 +2,12 @@
 
 <div class="warning">
 rustc's current diagnostics translation infrastructure (as of
-<!-- date-check --> August 2025
+<!-- date-check --> October 2024
 ) unfortunately causes some friction for compiler contributors, and the current
 infrastructure is mostly pending a redesign that better addresses needs of both
 compiler contributors and translation teams. Note that there is no current
 active redesign proposals (as of
-<!-- date-check --> August 2025
+<!-- date-check --> October 2024
 )!
 
 Please see the tracking issue <https://github.com/rust-lang/rust/issues/132181>
diff --git a/src/doc/rustc-dev-guide/src/tests/ci.md b/src/doc/rustc-dev-guide/src/tests/ci.md
index 95850c07cfe46..a8cc959124ff6 100644
--- a/src/doc/rustc-dev-guide/src/tests/ci.md
+++ b/src/doc/rustc-dev-guide/src/tests/ci.md
@@ -22,7 +22,7 @@ jobs](#modifying-ci-jobs).
 
 ## CI workflow
 
-<!-- date-check: Aug 2025 -->
+<!-- date-check: Oct 2024 -->
 
 Our CI is primarily executed on [GitHub Actions], with a single workflow defined
 in [`.github/workflows/ci.yml`], which contains a bunch of steps that are
diff --git a/src/doc/rustc-dev-guide/src/tests/directives.md b/src/doc/rustc-dev-guide/src/tests/directives.md
index 6cf73909b11e9..fbbeb7e97d3b7 100644
--- a/src/doc/rustc-dev-guide/src/tests/directives.md
+++ b/src/doc/rustc-dev-guide/src/tests/directives.md
@@ -42,7 +42,7 @@ not be exhaustive. Directives can generally be found by browsing the
 
 ### Assembly
 
-<!-- date-check: Aug 2025 -->
+<!-- date-check: Oct 2024 -->
 
 | Directive         | Explanation                   | Supported test suites | Possible values                        |
 |-------------------|-------------------------------|-----------------------|----------------------------------------|
@@ -113,7 +113,7 @@ for more details.
 | `known-bug`                       | No error annotation needed due to known bug                                                                              | `ui`, `crashes`, `incremental`               | Issue number `#123456`                                                                  |
 | `compare-output-by-lines`         | Compare the output by lines, rather than as a single string                                                              | All                                          | N/A                                                                                     |
 
-[^check_stdout]: presently <!-- date-check: Aug 2025 --> this has a weird quirk
+[^check_stdout]: presently <!-- date-check: Oct 2024 --> this has a weird quirk
     where the test binary's stdout and stderr gets concatenated and then
     `error-pattern`s are matched on this combined output, which is ??? slightly
     questionable to say the least.
diff --git a/src/doc/rustc-dev-guide/src/tests/misc.md b/src/doc/rustc-dev-guide/src/tests/misc.md
index ed80c6c3479e0..39f881748792f 100644
--- a/src/doc/rustc-dev-guide/src/tests/misc.md
+++ b/src/doc/rustc-dev-guide/src/tests/misc.md
@@ -2,7 +2,7 @@
 
 ## `RUSTC_BOOTSTRAP` and stability
 
-<!-- date-check: Aug 2025 -->
+<!-- date-check: Nov 2024 -->
 
 This is a bootstrap/compiler implementation detail, but it can also be useful
 for testing:

From 6f5fc69c7ebca3e48073ba81fdd3c3ccfe1f2bf5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Mon, 1 Sep 2025 09:14:27 +0200
Subject: [PATCH 0384/1889] Consolidate staging of test steps in message groups

---
 src/bootstrap/src/core/build_steps/test.rs | 163 +++++++--------------
 src/bootstrap/src/lib.rs                   |  58 ++++----
 2 files changed, 88 insertions(+), 133 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index 97db9bf536fdf..cdcbe29795df4 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -96,7 +96,7 @@ impl Step for CrateBootstrap {
         );
 
         let crate_name = path.rsplit_once('/').unwrap().1;
-        run_cargo_test(cargo, &[], &[], crate_name, bootstrap_host, builder, Mode::ToolBootstrap);
+        run_cargo_test(cargo, &[], &[], crate_name, bootstrap_host, builder);
     }
 
     fn metadata(&self) -> Option<StepMetadata> {
@@ -153,15 +153,7 @@ You can skip linkcheck with --skip src/tools/linkchecker"
             SourceType::InTree,
             &[],
         );
-        run_cargo_test(
-            cargo,
-            &[],
-            &[],
-            "linkchecker self tests",
-            bootstrap_host,
-            builder,
-            Mode::ToolBootstrap,
-        );
+        run_cargo_test(cargo, &[], &[], "linkchecker self tests", bootstrap_host, builder);
 
         if builder.doc_tests == DocTests::No {
             return;
@@ -174,7 +166,7 @@ You can skip linkcheck with --skip src/tools/linkchecker"
         let linkchecker = builder.tool_cmd(Tool::Linkchecker);
 
         // Run the linkchecker.
-        let _guard = builder.msg(Kind::Test, "Linkcheck", None, compiler, bootstrap_host);
+        let _guard = builder.msg_test("Linkcheck", bootstrap_host, 1);
         let _time = helpers::timeit(builder);
         linkchecker.delay_failure().arg(builder.out.join(host).join("doc")).run(builder);
     }
@@ -482,7 +474,7 @@ impl Step for RustAnalyzer {
         cargo.env("SKIP_SLOW_TESTS", "1");
 
         cargo.add_rustc_lib_path(builder);
-        run_cargo_test(cargo, &[], &[], "rust-analyzer", host, builder, Mode::ToolRustc);
+        run_cargo_test(cargo, &[], &[], "rust-analyzer", host, builder);
     }
 
     fn metadata(&self) -> Option<StepMetadata> {
@@ -540,7 +532,7 @@ impl Step for Rustfmt {
 
         cargo.add_rustc_lib_path(builder);
 
-        run_cargo_test(cargo, &[], &[], "rustfmt", target, builder, Mode::ToolRustc);
+        run_cargo_test(cargo, &[], &[], "rustfmt", target, builder);
     }
 
     fn metadata(&self) -> Option<StepMetadata> {
@@ -679,8 +671,7 @@ impl Step for Miri {
         cargo.env("MIRI_TEST_TARGET", target.rustc_target_arg());
 
         {
-            let _guard =
-                builder.msg(Kind::Test, "miri", Mode::ToolRustc, miri.build_compiler, target);
+            let _guard = builder.msg_test("miri", target, target_compiler.stage);
             let _time = helpers::timeit(builder);
             cargo.run(builder);
         }
@@ -696,13 +687,8 @@ impl Step for Miri {
             cargo.args(["tests/pass", "tests/panic"]);
 
             {
-                let _guard = builder.msg(
-                    Kind::Test,
-                    "miri (mir-opt-level 4)",
-                    Mode::ToolRustc,
-                    miri.build_compiler,
-                    target,
-                );
+                let _guard =
+                    builder.msg_test("miri (mir-opt-level 4)", target, target_compiler.stage);
                 let _time = helpers::timeit(builder);
                 cargo.run(builder);
             }
@@ -772,8 +758,7 @@ impl Step for CargoMiri {
         // Finally, run everything.
         let mut cargo = BootstrapCommand::from(cargo);
         {
-            let _guard =
-                builder.msg(Kind::Test, "cargo-miri", Mode::ToolRustc, (host, stage), target);
+            let _guard = builder.msg_test("cargo-miri", target, stage);
             let _time = helpers::timeit(builder);
             cargo.run(builder);
         }
@@ -833,7 +818,7 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
         cargo.env("TEST_RUSTC", builder.rustc(compiler));
 
         cargo.allow_features(COMPILETEST_ALLOW_FEATURES);
-        run_cargo_test(cargo, &[], &[], "compiletest self test", host, builder, Mode::ToolStd);
+        run_cargo_test(cargo, &[], &[], "compiletest self test", host, builder);
     }
 }
 
@@ -916,7 +901,7 @@ impl Step for Clippy {
         cargo.add_rustc_lib_path(builder);
         let cargo = prepare_cargo_test(cargo, &[], &[], target, builder);
 
-        let _guard = builder.msg(Kind::Test, "clippy", Mode::ToolRustc, build_compiler, target);
+        let _guard = builder.msg_test("clippy", target, target_compiler.stage);
 
         // Clippy reports errors if it blessed the outputs
         if cargo.allow_failure().run(builder) {
@@ -1046,8 +1031,7 @@ impl Step for RustdocJSStd {
             self.target,
             DocumentationFormat::Html,
         ));
-        let _guard =
-            builder.msg(Kind::Test, "rustdoc-js-std", None, self.build_compiler, self.target);
+        let _guard = builder.msg_test("rustdoc-js-std", self.target, self.build_compiler.stage);
         command.run(builder);
     }
 
@@ -1200,7 +1184,7 @@ impl Step for RustdocGUI {
         }
 
         let _time = helpers::timeit(builder);
-        let _guard = builder.msg_test("rustdoc-gui", (self.target, self.test_compiler.stage));
+        let _guard = builder.msg_test("rustdoc-gui", self.target, self.test_compiler.stage);
         try_run_tests(builder, &mut cmd, true);
     }
 
@@ -1359,15 +1343,7 @@ impl Step for CrateRunMakeSupport {
             &[],
         );
         cargo.allow_features("test");
-        run_cargo_test(
-            cargo,
-            &[],
-            &[],
-            "run-make-support self test",
-            host,
-            builder,
-            Mode::ToolBootstrap,
-        );
+        run_cargo_test(cargo, &[], &[], "run-make-support self test", host, builder);
     }
 }
 
@@ -1404,15 +1380,7 @@ impl Step for CrateBuildHelper {
             &[],
         );
         cargo.allow_features("test");
-        run_cargo_test(
-            cargo,
-            &[],
-            &[],
-            "build_helper self test",
-            host,
-            builder,
-            Mode::ToolBootstrap,
-        );
+        run_cargo_test(cargo, &[], &[], "build_helper self test", host, builder);
     }
 }
 
@@ -1724,7 +1692,7 @@ impl Step for MirOpt {
 ///
 /// Compiles all tests with `test_compiler` for `target` with the specified
 /// compiletest `mode` and `suite` arguments. For example `mode` can be
-/// "run-pass" or `suite` can be something like `debuginfo`.
+/// "mir-opt" and `suite` can be something like "debuginfo".
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 struct Compiletest {
     /// The compiler that we're testing.
@@ -1920,7 +1888,11 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
         cmd.arg("--llvm-filecheck").arg(builder.llvm_filecheck(builder.config.host_target));
 
         if let Some(codegen_backend) = builder.config.cmd.test_codegen_backend() {
-            if !builder.config.enabled_codegen_backends(test_compiler.host).contains(codegen_backend) {
+            if !builder
+                .config
+                .enabled_codegen_backends(test_compiler.host)
+                .contains(codegen_backend)
+            {
                 eprintln!(
                     "\
 ERROR: No configured backend named `{name}`
@@ -2326,19 +2298,16 @@ HELP: You can add it into `bootstrap.toml` in `rust.codegen-backends = [{name:?}
                 mode: mode.into(),
                 compare_mode: None,
                 target: self.target.triple.to_string(),
-                host: self.compiler.host.triple.to_string(),
-                stage: self.compiler.stage,
+                host: self.test_compiler.host.triple.to_string(),
+                stage: self.test_compiler.stage,
             },
             builder,
         );
 
-        let _group = builder.msg(
-            Kind::Test,
-            format!("compiletest suite={suite} mode={mode}"),
-            // FIXME: compiletest sometimes behaves as ToolStd, we could expose that difference here
-            Mode::ToolBootstrap,
-            test_compiler,
+        let _group = builder.msg_test(
+            format!("with compiletest suite={suite} mode={mode}"),
             target,
+            test_compiler.stage,
         );
         try_run_tests(builder, &mut cmd, false);
 
@@ -2352,8 +2321,8 @@ HELP: You can add it into `bootstrap.toml` in `rust.codegen-backends = [{name:?}
                     mode: mode.into(),
                     compare_mode: Some(compare_mode.into()),
                     target: self.target.triple.to_string(),
-                    host: self.compiler.host.triple.to_string(),
-                    stage: self.compiler.stage,
+                    host: self.test_compiler.host.triple.to_string(),
+                    stage: self.test_compiler.stage,
                 },
                 builder,
             );
@@ -2482,12 +2451,10 @@ impl BookTest {
         }
 
         builder.add_rust_test_threads(&mut rustbook_cmd);
-        let _guard = builder.msg(
-            Kind::Test,
+        let _guard = builder.msg_test(
             format_args!("mdbook {}", self.path.display()),
-            None,
-            test_compiler,
             test_compiler.host,
+            test_compiler.stage,
         );
         let _time = helpers::timeit(builder);
         let toolstate = if rustbook_cmd.delay_failure().run(builder) {
@@ -2505,12 +2472,10 @@ impl BookTest {
 
         builder.std(test_compiler, host);
 
-        let _guard = builder.msg(
-            Kind::Test,
+        let _guard = builder.msg_test(
             format!("book {}", self.name),
-            None,
-            (test_compiler.host, test_compiler.stage - 1),
-            host,
+            test_compiler.host,
+            test_compiler.stage,
         );
 
         // Do a breadth-first traversal of the `src/doc` directory and just run
@@ -2653,13 +2618,7 @@ impl Step for ErrorIndex {
         let mut tool = tool::ErrorIndex::command(builder, self.compilers);
         tool.arg("markdown").arg(&output);
 
-        let guard = builder.msg(
-            Kind::Test,
-            "error-index",
-            None,
-            self.compilers.build_compiler(),
-            target_compiler.host,
-        );
+        let guard = builder.msg_test("error-index", target_compiler.host, target_compiler.stage);
         let _time = helpers::timeit(builder);
         tool.run_capture(builder);
         drop(guard);
@@ -2755,14 +2714,12 @@ fn run_cargo_test<'a>(
     description: impl Into<Option<&'a str>>,
     target: TargetSelection,
     builder: &Builder<'_>,
-    mode: impl Into<Option<Mode>>,
 ) -> bool {
-    let mode = mode.into();
     let compiler = cargo.compiler();
     let mut cargo = prepare_cargo_test(cargo, libtest_args, crates, target, builder);
     let _time = helpers::timeit(builder);
     let _group =
-        description.into().and_then(|what| builder.msg(Kind::Test, what, mode, compiler, target));
+        description.into().and_then(|what| builder.msg_test(what, target, compiler.stage + 1));
 
     #[cfg(feature = "build-metrics")]
     builder.metrics.begin_test_suite(
@@ -2989,15 +2946,7 @@ impl Step for Crate {
             crates.push("alloctests".to_owned());
         }
 
-        run_cargo_test(
-            cargo,
-            &[],
-            &crates,
-            &*crate_description(&self.crates),
-            target,
-            builder,
-            mode,
-        );
+        run_cargo_test(cargo, &[], &crates, &*crate_description(&self.crates), target, builder);
     }
 }
 
@@ -3091,15 +3040,7 @@ impl Step for CrateRustdoc {
         dylib_path.insert(0, PathBuf::from(&*libdir));
         cargo.env(dylib_path_var(), env::join_paths(&dylib_path).unwrap());
 
-        run_cargo_test(
-            cargo,
-            &[],
-            &["rustdoc:0.0.0".to_string()],
-            "rustdoc",
-            target,
-            builder,
-            Mode::ToolRustc,
-        );
+        run_cargo_test(cargo, &[], &["rustdoc:0.0.0".to_string()], "rustdoc", target, builder);
     }
 }
 
@@ -3158,7 +3099,6 @@ impl Step for CrateRustdocJsonTypes {
             "rustdoc-json-types",
             target,
             builder,
-            Mode::ToolTarget,
         );
     }
 }
@@ -3316,8 +3256,6 @@ impl Step for Bootstrap {
     fn run(self, builder: &Builder<'_>) {
         let host = builder.config.host_target;
         let build_compiler = builder.compiler(0, host);
-        let _guard =
-            builder.msg(Kind::Test, "bootstrap", Mode::ToolBootstrap, build_compiler, host);
 
         // Some tests require cargo submodule to be present.
         builder.build.require_submodule("src/tools/cargo", None);
@@ -3356,7 +3294,7 @@ impl Step for Bootstrap {
 
         // bootstrap tests are racy on directory creation so just run them one at a time.
         // Since there's not many this shouldn't be a problem.
-        run_cargo_test(cargo, &["--test-threads=1"], &[], None, host, builder, Mode::ToolBootstrap);
+        run_cargo_test(cargo, &["--test-threads=1"], &[], None, host, builder);
     }
 
     fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
@@ -3416,7 +3354,11 @@ impl Step for TierCheck {
             cargo.arg("--verbose");
         }
 
-        let _guard = builder.msg_test("platform support check", self.test_compiler);
+        let _guard = builder.msg_test(
+            "platform support check",
+            self.test_compiler.host,
+            self.test_compiler.stage,
+        );
         BootstrapCommand::from(cargo).delay_failure().run(builder);
     }
 
@@ -3495,9 +3437,8 @@ impl Step for RustInstaller {
             &[],
         );
 
-        let _guard =
-            builder.msg(Kind::Test, "rust-installer", None, build_compiler, bootstrap_host);
-        run_cargo_test(cargo, &[], &[], None, bootstrap_host, builder, Mode::ToolBootstrap);
+        let _guard = builder.msg_test("rust-installer", bootstrap_host, 1);
+        run_cargo_test(cargo, &[], &[], None, bootstrap_host, builder);
 
         // We currently don't support running the test.sh script outside linux(?) environments.
         // Eventually this should likely migrate to #[test]s in rust-installer proper rather than a
@@ -3668,7 +3609,11 @@ impl Step for CodegenCranelift {
         // Avoid incremental cache issues when changing rustc
         cargo.env("CARGO_BUILD_INCREMENTAL", "false");
 
-        let _guard = builder.msg_test("rustc_codegen_cranelift", target_compiler);
+        let _guard = builder.msg_test(
+            "rustc_codegen_cranelift",
+            target_compiler.host,
+            target_compiler.stage,
+        );
 
         // FIXME handle vendoring for source tarballs before removing the --skip-test below
         let download_dir = builder.out.join("cg_clif_download");
@@ -3763,7 +3708,11 @@ impl Step for CodegenGCC {
                 .extra_rust_args(&["-Csymbol-mangling-version=v0", "-Cpanic=abort"]),
         );
 
-        let _guard = builder.msg_test("rustc_codegen_gcc", compilers.build_compiler());
+        let _guard = builder.msg_test(
+            "rustc_codegen_gcc",
+            compilers.target(),
+            compilers.target_compiler().stage,
+        );
 
         let mut cargo = builder::Cargo::new(
             builder,
@@ -3868,7 +3817,7 @@ impl Step for TestFloatParse {
         );
         cargo_test.allow_features(TEST_FLOAT_PARSE_ALLOW_FEATURES);
 
-        run_cargo_test(cargo_test, &[], &[], "test-float-parse", target, builder, Mode::ToolStd);
+        run_cargo_test(cargo_test, &[], &[], "test-float-parse", target, builder);
 
         // Run the actual parse tests.
         let mut cargo_run = tool::prepare_tool_cargo(
diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs
index 2108f3b8cf5dc..59c0f9faacac9 100644
--- a/src/bootstrap/src/lib.rs
+++ b/src/bootstrap/src/lib.rs
@@ -426,22 +426,22 @@ forward! {
     download_rustc() -> bool,
 }
 
-/// A mostly temporary helper struct before we can migrate everything in bootstrap to use
-/// the concept of a build compiler.
-struct HostAndStage {
-    host: TargetSelection,
+/// An alternative way of specifying what target and stage is involved in some bootstrap activity.
+/// Ideally using a `Compiler` directly should be preferred.
+struct TargetAndStage {
+    target: TargetSelection,
     stage: u32,
 }
 
-impl From<(TargetSelection, u32)> for HostAndStage {
-    fn from((host, stage): (TargetSelection, u32)) -> Self {
-        Self { host, stage }
+impl From<(TargetSelection, u32)> for TargetAndStage {
+    fn from((target, stage): (TargetSelection, u32)) -> Self {
+        Self { target, stage }
     }
 }
 
-impl From<Compiler> for HostAndStage {
+impl From<Compiler> for TargetAndStage {
     fn from(compiler: Compiler) -> Self {
-        Self { host: compiler.host, stage: compiler.stage }
+        Self { target: compiler.host, stage: compiler.stage }
     }
 }
 
@@ -1109,11 +1109,12 @@ impl Build {
 
     /// Return a `Group` guard for a [`Step`] that:
     /// - Performs `action`
+    ///   - If the action is `Kind::Test`, use [`Build::msg_test`] instead.
     /// - On `what`
     ///   - Where `what` possibly corresponds to a `mode`
-    /// - `action` is performed using the given build compiler (`host_and_stage`).
-    ///   - Since some steps do not use the concept of a build compiler yet, it is also possible
-    ///     to pass the host and stage explicitly.
+    /// - `action` is performed with/on the given compiler (`target_and_stage`).
+    ///   - Since for some steps it is not possible to pass a single compiler here, it is also
+    ///     possible to pass the host and stage explicitly.
     /// - With a given `target`.
     ///
     /// [`Step`]: crate::core::builder::Step
@@ -1124,13 +1125,19 @@ impl Build {
         action: impl Into<Kind>,
         what: impl Display,
         mode: impl Into<Option<Mode>>,
-        host_and_stage: impl Into<HostAndStage>,
+        target_and_stage: impl Into<TargetAndStage>,
         target: impl Into<Option<TargetSelection>>,
     ) -> Option<gha::Group> {
-        let host_and_stage = host_and_stage.into();
+        let target_and_stage = target_and_stage.into();
+        let action = action.into();
+        assert!(
+            action != Kind::Test,
+            "Please use `Build::msg_test` instead of `Build::msg(Kind::Test)`"
+        );
+
         let actual_stage = match mode.into() {
             // Std has the same stage as the compiler that builds it
-            Some(Mode::Std) => host_and_stage.stage,
+            Some(Mode::Std) => target_and_stage.stage,
             // Other things have stage corresponding to their build compiler + 1
             Some(
                 Mode::Rustc
@@ -1140,18 +1147,18 @@ impl Build {
                 | Mode::ToolStd
                 | Mode::ToolRustc,
             )
-            | None => host_and_stage.stage + 1,
+            | None => target_and_stage.stage + 1,
         };
 
-        let action = action.into().description();
+        let action = action.description();
         let what = what.to_string();
         let msg = |fmt| {
             let space = if !what.is_empty() { " " } else { "" };
             format!("{action} stage{actual_stage} {what}{space}{fmt}")
         };
         let msg = if let Some(target) = target.into() {
-            let build_stage = host_and_stage.stage;
-            let host = host_and_stage.host;
+            let build_stage = target_and_stage.stage;
+            let host = target_and_stage.target;
             if host == target {
                 msg(format_args!("(stage{build_stage} -> stage{actual_stage}, {target})"))
             } else {
@@ -1163,10 +1170,9 @@ impl Build {
         self.group(&msg)
     }
 
-    /// Return a `Group` guard for a [`Step`] that tests `what` with the given `stage` and `target`
-    /// (determined by `host_and_stage`).
-    /// Use this instead of [`Build::msg`] when there is no clear `build_compiler` to be
-    /// determined.
+    /// Return a `Group` guard for a [`Step`] that tests `what` with the given `stage` and `target`.
+    /// Use this instead of [`Build::msg`] for test steps, because for them it is not always clear
+    /// what exactly is a build compiler.
     ///
     /// [`Step`]: crate::core::builder::Step
     #[must_use = "Groups should not be dropped until the Step finishes running"]
@@ -1174,11 +1180,11 @@ impl Build {
     fn msg_test(
         &self,
         what: impl Display,
-        host_and_stage: impl Into<HostAndStage>,
+        target: TargetSelection,
+        stage: u32,
     ) -> Option<gha::Group> {
-        let HostAndStage { host, stage } = host_and_stage.into();
         let action = Kind::Test.description();
-        let msg = format!("{action} stage{stage} {what} ({host})");
+        let msg = format!("{action} stage{stage} {what} ({target})");
         self.group(&msg)
     }
 

From 6be234074e454756d13cd3f969f427f94a5f4950 Mon Sep 17 00:00:00 2001
From: Nathaniel McCallum <nathaniel@mccallum.life>
Date: Mon, 1 Sep 2025 02:40:52 -0400
Subject: [PATCH 0385/1889] constify impl Try for ControlFlow

---
 library/core/src/ops/control_flow.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/library/core/src/ops/control_flow.rs b/library/core/src/ops/control_flow.rs
index 7489a8bb6e74b..73b74d53323fa 100644
--- a/library/core/src/ops/control_flow.rs
+++ b/library/core/src/ops/control_flow.rs
@@ -99,7 +99,8 @@ pub enum ControlFlow<B, C = ()> {
 }
 
 #[unstable(feature = "try_trait_v2", issue = "84277", old_name = "try_trait")]
-impl<B, C> ops::Try for ControlFlow<B, C> {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl<B, C> const ops::Try for ControlFlow<B, C> {
     type Output = C;
     type Residual = ControlFlow<B, convert::Infallible>;
 
@@ -118,9 +119,10 @@ impl<B, C> ops::Try for ControlFlow<B, C> {
 }
 
 #[unstable(feature = "try_trait_v2", issue = "84277", old_name = "try_trait")]
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
 // 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> {
+impl<B, C> const ops::FromResidual<ControlFlow<B, convert::Infallible>> for ControlFlow<B, C> {
     #[inline]
     fn from_residual(residual: ControlFlow<B, convert::Infallible>) -> Self {
         match residual {

From 8dfd6b8ec208f4f31dd0e41c32e9239bf262068c Mon Sep 17 00:00:00 2001
From: Nathaniel McCallum <nathaniel@mccallum.life>
Date: Mon, 1 Sep 2025 08:55:25 -0400
Subject: [PATCH 0386/1889] fix a constness ordering bug in rustfmt

Normally, changes to rustfmt go into the separate repo. But, in
this case, the bug is introduced in a local change and therefore
isn't present in the rustfmt repo.
---
 src/tools/rustfmt/src/items.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/rustfmt/src/items.rs b/src/tools/rustfmt/src/items.rs
index 6555679c39448..75e468b35256c 100644
--- a/src/tools/rustfmt/src/items.rs
+++ b/src/tools/rustfmt/src/items.rs
@@ -1175,8 +1175,8 @@ pub(crate) fn format_trait(
     let mut result = String::with_capacity(128);
     let header = format!(
         "{}{}{}{}trait ",
-        format_constness(constness),
         format_visibility(context, &item.vis),
+        format_constness(constness),
         format_safety(safety),
         format_auto(is_auto),
     );

From 8f3c6acb228f40c4bb81b75e90bb84d7579432ad Mon Sep 17 00:00:00 2001
From: yanglsh <yanglsh@shanghaitech.edu.cn>
Date: Thu, 28 Aug 2025 05:59:36 +0800
Subject: [PATCH 0387/1889] fix: `alloc_instead_of_core` FP when `alloc` is an
 alias

---
 clippy_lints/src/std_instead_of_core.rs | 2 ++
 tests/ui/std_instead_of_core.fixed      | 7 +++++++
 tests/ui/std_instead_of_core.rs         | 7 +++++++
 3 files changed, 16 insertions(+)

diff --git a/clippy_lints/src/std_instead_of_core.rs b/clippy_lints/src/std_instead_of_core.rs
index e9534bc63a691..8c4a50041e67d 100644
--- a/clippy_lints/src/std_instead_of_core.rs
+++ b/clippy_lints/src/std_instead_of_core.rs
@@ -126,6 +126,8 @@ impl<'tcx> LateLintPass<'tcx> for StdReexports {
             && !is_from_proc_macro(cx, &first_segment.ident)
             && !matches!(def_kind, DefKind::Macro(_))
             && let Some(last_segment) = path.segments.last()
+            && let Res::Def(DefKind::Mod, crate_def_id) = first_segment.res
+            && crate_def_id.is_crate_root()
         {
             let (lint, used_mod, replace_with) = match first_segment.ident.name {
                 sym::std => match cx.tcx.crate_name(def_id.krate) {
diff --git a/tests/ui/std_instead_of_core.fixed b/tests/ui/std_instead_of_core.fixed
index 603ab0accb0b6..c27cec558242d 100644
--- a/tests/ui/std_instead_of_core.fixed
+++ b/tests/ui/std_instead_of_core.fixed
@@ -89,3 +89,10 @@ fn msrv_1_76(_: std::net::IpAddr) {}
 #[clippy::msrv = "1.77"]
 fn msrv_1_77(_: core::net::IpAddr) {}
 //~^ std_instead_of_core
+
+#[warn(clippy::alloc_instead_of_core)]
+fn issue15579() {
+    use std::alloc;
+
+    let layout = alloc::Layout::new::<u8>();
+}
diff --git a/tests/ui/std_instead_of_core.rs b/tests/ui/std_instead_of_core.rs
index b6d4abad9f8fe..7d53f7fc3072b 100644
--- a/tests/ui/std_instead_of_core.rs
+++ b/tests/ui/std_instead_of_core.rs
@@ -89,3 +89,10 @@ fn msrv_1_76(_: std::net::IpAddr) {}
 #[clippy::msrv = "1.77"]
 fn msrv_1_77(_: std::net::IpAddr) {}
 //~^ std_instead_of_core
+
+#[warn(clippy::alloc_instead_of_core)]
+fn issue15579() {
+    use std::alloc;
+
+    let layout = alloc::Layout::new::<u8>();
+}

From d8df6312d5b3290c6976e5b55f5ae8344cab1bb4 Mon Sep 17 00:00:00 2001
From: Moritz Hedtke <Moritz.Hedtke@t-online.de>
Date: Mon, 1 Sep 2025 17:26:20 +0200
Subject: [PATCH 0388/1889] Make `Parser::parse_for_head` public for rustfmt
 usage

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

diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index 7de4f6efd0b0f..9b09cbba7afcc 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -2910,7 +2910,8 @@ impl<'a> Parser<'a> {
         }
     }
 
-    fn parse_for_head(&mut self) -> PResult<'a, (Box<Pat>, Box<Expr>)> {
+    // Public to use it for custom `for` expressions in rustfmt forks like https://github.com/tucant/rustfmt
+    pub fn parse_for_head(&mut self) -> PResult<'a, (Box<Pat>, Box<Expr>)> {
         let begin_paren = if self.token == token::OpenParen {
             // Record whether we are about to parse `for (`.
             // This is used below for recovery in case of `for ( $stuff ) $block`

From af627f557ad4806e1de1b4800fd1a7e5a42420a8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Mon, 1 Sep 2025 18:39:44 +0200
Subject: [PATCH 0389/1889] Fix ui-fulldeps

---
 src/bootstrap/src/core/build_steps/test.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index cdcbe29795df4..ee2cbe9385e48 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -1873,7 +1873,9 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
 
         // When top stage is 0, that means that we're testing an externally provided compiler.
         // In that case we need to use its specific sysroot for tests to pass.
-        let sysroot = if test_compiler.stage == 0 {
+        // Note: DO NOT check if test_compiler.stage is 0, because the test compiler can be stage 0
+        // even if the top stage is 1 (when we run the ui-fulldeps suite).
+        let sysroot = if builder.top_stage == 0 {
             builder.initial_sysroot.clone()
         } else {
             builder.sysroot(test_compiler)

From 6fc0cf428885a4939fc3b6f60f638ce09e48339f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Mon, 1 Sep 2025 21:39:01 +0200
Subject: [PATCH 0390/1889] Remove dead code stemming from an old effects
 desugaring

---
 compiler/rustc_ast_lowering/src/lib.rs                   | 2 +-
 compiler/rustc_hir/src/hir.rs                            | 1 -
 compiler/rustc_hir/src/intravisit.rs                     | 2 +-
 compiler/rustc_hir_analysis/src/collect/generics_of.rs   | 6 +++---
 .../rustc_hir_analysis/src/hir_ty_lowering/generics.rs   | 9 +--------
 compiler/rustc_hir_pretty/src/lib.rs                     | 2 +-
 compiler/rustc_middle/src/ty/generics.rs                 | 2 +-
 compiler/rustc_public/src/unstable/convert/stable/ty.rs  | 8 ++++----
 src/librustdoc/clean/mod.rs                              | 6 ++----
 src/librustdoc/clean/types.rs                            | 2 +-
 src/librustdoc/json/conversions.rs                       | 2 +-
 11 files changed, 16 insertions(+), 26 deletions(-)

diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index 70595391b85bc..a6a4cc842f0e0 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -2028,7 +2028,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
                 (
                     hir::ParamName::Plain(self.lower_ident(param.ident)),
-                    hir::GenericParamKind::Const { ty, default, synthetic: false },
+                    hir::GenericParamKind::Const { ty, default },
                 )
             }
         }
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index e397c286de289..cdade500a268e 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -784,7 +784,6 @@ pub enum GenericParamKind<'hir> {
         ty: &'hir Ty<'hir>,
         /// Optional default value for the const generic param
         default: Option<&'hir ConstArg<'hir>>,
-        synthetic: bool,
     },
 }
 
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
index 9b2f8ae75fa70..25a7ae239f312 100644
--- a/compiler/rustc_hir/src/intravisit.rs
+++ b/compiler/rustc_hir/src/intravisit.rs
@@ -1085,7 +1085,7 @@ pub fn walk_generic_param<'v, V: Visitor<'v>>(
         GenericParamKind::Type { ref default, .. } => {
             visit_opt!(visitor, visit_ty_unambig, default)
         }
-        GenericParamKind::Const { ref ty, ref default, synthetic: _ } => {
+        GenericParamKind::Const { ref ty, ref default } => {
             try_visit!(visitor.visit_ty_unambig(ty));
             if let Some(default) = default {
                 try_visit!(visitor.visit_const_param_default(*hir_id, default));
diff --git a/compiler/rustc_hir_analysis/src/collect/generics_of.rs b/compiler/rustc_hir_analysis/src/collect/generics_of.rs
index ce0e51f106f59..333cea23c4148 100644
--- a/compiler/rustc_hir_analysis/src/collect/generics_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/generics_of.rs
@@ -305,7 +305,7 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
 
                 ty::GenericParamDefKind::Type { has_default: default.is_some(), synthetic }
             }
-            GenericParamKind::Const { ty: _, default, synthetic } => {
+            GenericParamKind::Const { ty: _, default } => {
                 if default.is_some() {
                     match param_default_policy.expect("no policy for generic param default") {
                         ParamDefaultPolicy::Allowed => {}
@@ -316,7 +316,7 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
                     }
                 }
 
-                ty::GenericParamDefKind::Const { has_default: default.is_some(), synthetic }
+                ty::GenericParamDefKind::Const { has_default: default.is_some() }
             }
         };
         Some(ty::GenericParamDef {
@@ -523,7 +523,7 @@ impl<'v> Visitor<'v> for AnonConstInParamTyDetector {
     type Result = ControlFlow<()>;
 
     fn visit_generic_param(&mut self, p: &'v hir::GenericParam<'v>) -> Self::Result {
-        if let GenericParamKind::Const { ty, default: _, synthetic: _ } = p.kind {
+        if let GenericParamKind::Const { ty, default: _ } = p.kind {
             let prev = self.in_param_ty;
             self.in_param_ty = true;
             let res = self.visit_ty_unambig(ty);
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/generics.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/generics.rs
index fc519c194bb9d..f5a64ede398ea 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/generics.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/generics.rs
@@ -419,14 +419,7 @@ pub(crate) fn check_generic_arg_count(
         .filter(|param| matches!(param.kind, ty::GenericParamDefKind::Type { synthetic: true, .. }))
         .count();
     let named_type_param_count = param_counts.types - has_self as usize - synth_type_param_count;
-    let synth_const_param_count = gen_params
-        .own_params
-        .iter()
-        .filter(|param| {
-            matches!(param.kind, ty::GenericParamDefKind::Const { synthetic: true, .. })
-        })
-        .count();
-    let named_const_param_count = param_counts.consts - synth_const_param_count;
+    let named_const_param_count = param_counts.consts;
     let infer_lifetimes =
         (gen_pos != GenericArgPosition::Type || seg.infer_args) && !gen_args.has_lifetime_params();
 
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
index be5859b57c5e0..a89f059bb351f 100644
--- a/compiler/rustc_hir_pretty/src/lib.rs
+++ b/compiler/rustc_hir_pretty/src/lib.rs
@@ -2379,7 +2379,7 @@ impl<'a> State<'a> {
                     self.print_type(default);
                 }
             }
-            GenericParamKind::Const { ty, ref default, synthetic: _ } => {
+            GenericParamKind::Const { ty, ref default } => {
                 self.word_space(":");
                 self.print_type(ty);
                 if let Some(default) = default {
diff --git a/compiler/rustc_middle/src/ty/generics.rs b/compiler/rustc_middle/src/ty/generics.rs
index c7b3b5415492b..b6b10e2458575 100644
--- a/compiler/rustc_middle/src/ty/generics.rs
+++ b/compiler/rustc_middle/src/ty/generics.rs
@@ -13,7 +13,7 @@ use crate::ty::{EarlyBinder, GenericArgsRef};
 pub enum GenericParamDefKind {
     Lifetime,
     Type { has_default: bool, synthetic: bool },
-    Const { has_default: bool, synthetic: bool },
+    Const { has_default: bool },
 }
 
 impl GenericParamDefKind {
diff --git a/compiler/rustc_public/src/unstable/convert/stable/ty.rs b/compiler/rustc_public/src/unstable/convert/stable/ty.rs
index 5a661072bc7ee..207038db40d6e 100644
--- a/compiler/rustc_public/src/unstable/convert/stable/ty.rs
+++ b/compiler/rustc_public/src/unstable/convert/stable/ty.rs
@@ -656,13 +656,13 @@ impl<'tcx> Stable<'tcx> for rustc_middle::ty::GenericParamDefKind {
 
     fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         use crate::ty::GenericParamDefKind;
-        match self {
+        match *self {
             ty::GenericParamDefKind::Lifetime => GenericParamDefKind::Lifetime,
             ty::GenericParamDefKind::Type { has_default, synthetic } => {
-                GenericParamDefKind::Type { has_default: *has_default, synthetic: *synthetic }
+                GenericParamDefKind::Type { has_default, synthetic }
             }
-            ty::GenericParamDefKind::Const { has_default, synthetic: _ } => {
-                GenericParamDefKind::Const { has_default: *has_default }
+            ty::GenericParamDefKind::Const { has_default } => {
+                GenericParamDefKind::Const { has_default }
             }
         }
     }
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 4ff94cc6f3b64..93932936a2e0e 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -557,7 +557,7 @@ fn clean_generic_param_def(
                 },
             )
         }
-        ty::GenericParamDefKind::Const { has_default, synthetic } => (
+        ty::GenericParamDefKind::Const { has_default } => (
             def.name,
             GenericParamDefKind::Const {
                 ty: Box::new(clean_middle_ty(
@@ -580,7 +580,6 @@ fn clean_generic_param_def(
                 } else {
                     None
                 },
-                synthetic,
             },
         ),
     };
@@ -636,14 +635,13 @@ fn clean_generic_param<'tcx>(
                 },
             )
         }
-        hir::GenericParamKind::Const { ty, default, synthetic } => (
+        hir::GenericParamKind::Const { ty, default } => (
             param.name.ident().name,
             GenericParamDefKind::Const {
                 ty: Box::new(clean_ty(ty, cx)),
                 default: default.map(|ct| {
                     Box::new(lower_const_arg_for_rustdoc(cx.tcx, ct, FeedConstTy::No).to_string())
                 }),
-                synthetic,
             },
         ),
     };
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index fcff15650ce2e..dcd67cb7ebc77 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -1396,7 +1396,7 @@ pub(crate) enum GenericParamDefKind {
     Lifetime { outlives: ThinVec<Lifetime> },
     Type { bounds: ThinVec<GenericBound>, default: Option<Box<Type>>, synthetic: bool },
     // Option<Box<String>> makes this type smaller than `Option<String>` would.
-    Const { ty: Box<Type>, default: Option<Box<String>>, synthetic: bool },
+    Const { ty: Box<Type>, default: Option<Box<String>> },
 }
 
 impl GenericParamDefKind {
diff --git a/src/librustdoc/json/conversions.rs b/src/librustdoc/json/conversions.rs
index f0520716228a5..6fe94f9d291b4 100644
--- a/src/librustdoc/json/conversions.rs
+++ b/src/librustdoc/json/conversions.rs
@@ -466,7 +466,7 @@ impl FromClean<clean::GenericParamDefKind> for GenericParamDefKind {
                 default: default.into_json(renderer),
                 is_synthetic: *synthetic,
             },
-            Const { ty, default, synthetic: _ } => GenericParamDefKind::Const {
+            Const { ty, default } => GenericParamDefKind::Const {
                 type_: ty.into_json(renderer),
                 default: default.as_ref().map(|x| x.as_ref().clone()),
             },

From f67e29e5a82d5272a03028c5e4a91fbe2bbab81f Mon Sep 17 00:00:00 2001
From: Janis <janis@nirgendwo.xyz>
Date: Mon, 1 Sep 2025 14:09:14 +0200
Subject: [PATCH 0391/1889] squash fix `render_call_locations` panic when
 default span points at file outside of local_sources

add test against crashing with --html-after-content file

correctly add --html-after-content to env not args

formatting fix for rustdoc-call-locations-after-content/rmake.rs

Use local crate source file as default span in `render_call_locations`

- avoids unwrapping the first file added to the source map as a local file in
`href_from_span`

move test to tests/rustdoc-gui, rename to scrape_examples_ice

test link is correct

use rustdocflags, rename path in example, track lock file

factor out duplicate function calls

use compile-flags to make sure the after.html file is actually included in the rustdoc call

fix goml go-to path

increment assert-count in sidebar-source-code.goml

adjust crate-search width in search-result-display.goml

renamed Bar in scrape_examples_ice test

make crate name shorter ..
---
 src/librustdoc/html/render/mod.rs             | 52 +++++++++++++------
 .../scrape-examples-ice-links.goml            |  6 +++
 tests/rustdoc-gui/sidebar-source-code.goml    |  2 +-
 .../src/scrape_examples_ice/Cargo.lock        |  7 +++
 .../src/scrape_examples_ice/Cargo.toml        |  9 ++++
 .../src/scrape_examples_ice/empty.html        |  1 +
 .../src/scrape_examples_ice/examples/bar.rs   |  3 ++
 .../src/scrape_examples_ice/src/lib.rs        |  9 ++++
 8 files changed, 73 insertions(+), 16 deletions(-)
 create mode 100644 tests/rustdoc-gui/scrape-examples-ice-links.goml
 create mode 100644 tests/rustdoc-gui/src/scrape_examples_ice/Cargo.lock
 create mode 100644 tests/rustdoc-gui/src/scrape_examples_ice/Cargo.toml
 create mode 100644 tests/rustdoc-gui/src/scrape_examples_ice/empty.html
 create mode 100644 tests/rustdoc-gui/src/scrape_examples_ice/examples/bar.rs
 create mode 100644 tests/rustdoc-gui/src/scrape_examples_ice/src/lib.rs

diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index 6db90c9bf2a45..b4ef47d1e2694 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -2812,24 +2812,46 @@ fn render_call_locations<W: fmt::Write>(
         let needs_expansion = line_max - line_min > NUM_VISIBLE_LINES;
         let locations_encoded = serde_json::to_string(&line_ranges).unwrap();
 
-        // Look for the example file in the source map if it exists, otherwise return a dummy span
-        let file_span = (|| {
-            let source_map = tcx.sess.source_map();
-            let crate_src = tcx.sess.local_crate_source_file()?.into_local_path()?;
+        let source_map = tcx.sess.source_map();
+        let files = source_map.files();
+        let local = tcx.sess.local_crate_source_file().unwrap();
+
+        let get_file_start_pos = || {
+            let crate_src = local.clone().into_local_path()?;
             let abs_crate_src = crate_src.canonicalize().ok()?;
             let crate_root = abs_crate_src.parent()?.parent()?;
             let rel_path = path.strip_prefix(crate_root).ok()?;
-            let files = source_map.files();
-            let file = files.iter().find(|file| match &file.name {
-                FileName::Real(RealFileName::LocalPath(other_path)) => rel_path == other_path,
-                _ => false,
-            })?;
-            Some(rustc_span::Span::with_root_ctxt(
-                file.start_pos + BytePos(byte_min),
-                file.start_pos + BytePos(byte_max),
-            ))
-        })()
-        .unwrap_or(DUMMY_SP);
+            files
+                .iter()
+                .find(|file| match &file.name {
+                    FileName::Real(RealFileName::LocalPath(other_path)) => rel_path == other_path,
+                    _ => false,
+                })
+                .map(|file| file.start_pos)
+        };
+
+        // Look for the example file in the source map if it exists, otherwise
+        // return a span to the local crate's source file
+        let Some(file_span) = get_file_start_pos()
+            .or_else(|| {
+                files
+                    .iter()
+                    .find(|file| match &file.name {
+                        FileName::Real(file_name) => file_name == &local,
+                        _ => false,
+                    })
+                    .map(|file| file.start_pos)
+            })
+            .map(|start_pos| {
+                rustc_span::Span::with_root_ctxt(
+                    start_pos + BytePos(byte_min),
+                    start_pos + BytePos(byte_max),
+                )
+            })
+        else {
+            // if the fallback span can't be built, don't render the code for this example
+            return false;
+        };
 
         let mut decoration_info = FxIndexMap::default();
         decoration_info.insert("highlight focus", vec![byte_ranges.remove(0)]);
diff --git a/tests/rustdoc-gui/scrape-examples-ice-links.goml b/tests/rustdoc-gui/scrape-examples-ice-links.goml
new file mode 100644
index 0000000000000..1db220e1a3223
--- /dev/null
+++ b/tests/rustdoc-gui/scrape-examples-ice-links.goml
@@ -0,0 +1,6 @@
+// Check that the line number column has the correct layout.
+go-to: "file://" + |DOC_PATH| + "/scrape_ice/struct.ObscurelyNamedType1.html"
+wait-for: ".scraped-example-title"
+assert-attribute: (".scraped-example-title a", {"href": "../src/bar/bar.rs.html#2"})
+click: ".scraped-example-title a"
+wait-for-property: ("h1", {"innerText": "bar/\nbar.rs"})
diff --git a/tests/rustdoc-gui/sidebar-source-code.goml b/tests/rustdoc-gui/sidebar-source-code.goml
index 3f6914a89d63a..a3c19d8c6d013 100644
--- a/tests/rustdoc-gui/sidebar-source-code.goml
+++ b/tests/rustdoc-gui/sidebar-source-code.goml
@@ -71,7 +71,7 @@ assert: "//*[@class='dir-entry' and @open]/*[normalize-space()='sub_mod']"
 // Only "another_folder" should be "open" in "lib2".
 assert: "//*[@class='dir-entry' and not(@open)]/*[normalize-space()='another_mod']"
 // All other trees should be collapsed.
-assert-count: ("//*[@id='src-sidebar']/details[not(normalize-space()='lib2') and not(@open)]", 12)
+assert-count: ("//*[@id='src-sidebar']/details[not(normalize-space()='lib2') and not(@open)]", 13)
 
 // We now switch to mobile mode.
 set-window-size: (600, 600)
diff --git a/tests/rustdoc-gui/src/scrape_examples_ice/Cargo.lock b/tests/rustdoc-gui/src/scrape_examples_ice/Cargo.lock
new file mode 100644
index 0000000000000..03410a0da12cb
--- /dev/null
+++ b/tests/rustdoc-gui/src/scrape_examples_ice/Cargo.lock
@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "scrape_ice"
+version = "0.1.0"
diff --git a/tests/rustdoc-gui/src/scrape_examples_ice/Cargo.toml b/tests/rustdoc-gui/src/scrape_examples_ice/Cargo.toml
new file mode 100644
index 0000000000000..076ff38ad2316
--- /dev/null
+++ b/tests/rustdoc-gui/src/scrape_examples_ice/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "scrape_ice"
+version = "0.1.0"
+edition = "2024"
+
+[[example]]
+name = "bar"
+path = "examples/bar.rs"
+doc-scrape-examples = true
diff --git a/tests/rustdoc-gui/src/scrape_examples_ice/empty.html b/tests/rustdoc-gui/src/scrape_examples_ice/empty.html
new file mode 100644
index 0000000000000..8b137891791fe
--- /dev/null
+++ b/tests/rustdoc-gui/src/scrape_examples_ice/empty.html
@@ -0,0 +1 @@
+
diff --git a/tests/rustdoc-gui/src/scrape_examples_ice/examples/bar.rs b/tests/rustdoc-gui/src/scrape_examples_ice/examples/bar.rs
new file mode 100644
index 0000000000000..9f05f9e46e870
--- /dev/null
+++ b/tests/rustdoc-gui/src/scrape_examples_ice/examples/bar.rs
@@ -0,0 +1,3 @@
+fn main() {
+    let mut bar = scrape_ice::ObscurelyNamedType1::new();
+}
diff --git a/tests/rustdoc-gui/src/scrape_examples_ice/src/lib.rs b/tests/rustdoc-gui/src/scrape_examples_ice/src/lib.rs
new file mode 100644
index 0000000000000..b854c7722c9a0
--- /dev/null
+++ b/tests/rustdoc-gui/src/scrape_examples_ice/src/lib.rs
@@ -0,0 +1,9 @@
+//@ run-flags:-Zrustdoc-scrape-examples
+//@ compile-flags: --html-after-content empty.html
+pub struct ObscurelyNamedType1;
+
+impl ObscurelyNamedType1 {
+    pub fn new() -> Self {
+        ObscurelyNamedType1
+    }
+}

From ff60e5c3f3a00fcf03fc4d50432cd76f2a890a9f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Tue, 2 Sep 2025 00:02:16 +0000
Subject: [PATCH 0392/1889] Suggest parentheses around if-expressions

```
error[E0308]: mismatched types
  --> $DIR/expr-as-stmt-2.rs:15:15
   |
LL |     if true { true } else { false } && true;
   |     ----------^^^^-----------------
   |     |         |
   |     |         expected `()`, found `bool`
   |     expected this to be `()`
   |
help: parentheses are required to parse this as an expression
   |
LL |     (if true { true } else { false }) && true;
   |     +                               +
```
---
 compiler/rustc_hir_typeck/src/coercion.rs     |   2 +-
 .../rustc_hir_typeck/src/fn_ctxt/checks.rs    |  50 ++----
 .../src/fn_ctxt/suggestions.rs                | 146 +++++++++++-----
 tests/ui/parser/expr-as-stmt-2.rs             |  23 ++-
 tests/ui/parser/expr-as-stmt-2.stderr         | 156 +++++++++++++++++-
 5 files changed, 301 insertions(+), 76 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/coercion.rs b/compiler/rustc_hir_typeck/src/coercion.rs
index e66601631fcc8..b99f811db1a14 100644
--- a/compiler/rustc_hir_typeck/src/coercion.rs
+++ b/compiler/rustc_hir_typeck/src/coercion.rs
@@ -1897,7 +1897,7 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
                     fcx.suggest_semicolon_at_end(cond_expr.span, &mut err);
                 }
             }
-        };
+        }
 
         // If this is due to an explicit `return`, suggest adding a return type.
         if let Some((fn_id, fn_decl)) = fcx.get_fn_decl(block_or_return_id)
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
index 33dc56d49b499..94b635c41b4b2 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -1912,39 +1912,23 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             hir::StmtKind::Expr(ref expr) => {
                 // Check with expected type of `()`.
                 self.check_expr_has_type_or_error(expr, self.tcx.types.unit, |err| {
-                    if expr.can_have_side_effects() {
-                        let hir_id = stmt.hir_id;
-                        if let hir::ExprKind::Match(..) = expr.kind
-                            && let hir::Node::Block(b) = self.tcx.parent_hir_node(hir_id)
-                            && let mut stmts = b.stmts.iter().skip_while(|s| s.hir_id != hir_id)
-                            && let Some(_) = stmts.next() // The statement from the `match`
-                            && let Some(next) = match (stmts.next(), b.expr) {
-                                (Some(next), _) => match next.kind {
-                                    hir::StmtKind::Expr(next) | hir::StmtKind::Semi(next) => Some(next),
-                                    _ => None,
-                                },
-                                (None, Some(next)) => Some(next),
-                                _ => None,
-                            }
-                            && let hir::ExprKind::AddrOf(..)
-                                | hir::ExprKind::Unary(..)
-                                | hir::ExprKind::Err(_) = next.kind
-                        {
-                            // We have something like `match () { _ => true } && true`. Suggest
-                            // wrapping in parentheses. We find the statement or expression
-                            // following the `match` (`&& true`) and see if it is something that
-                            // can reasonably be interpreted as a binop following an expression.
-                            err.multipart_suggestion(
-                                "parentheses are required to parse this as an expression",
-                                vec![
-                                    (expr.span.shrink_to_lo(), "(".to_string()),
-                                    (expr.span.shrink_to_hi(), ")".to_string()),
-                                ],
-                                Applicability::MachineApplicable,
-                            );
-                        } else {
-                            self.suggest_semicolon_at_end(expr.span, err);
-                        }
+                    if self.is_next_stmt_expr_continuation(stmt.hir_id)
+                        && let hir::ExprKind::Match(..) | hir::ExprKind::If(..) = expr.kind
+                    {
+                        // We have something like `match () { _ => true } && true`. Suggest
+                        // wrapping in parentheses. We find the statement or expression
+                        // following the `match` (`&& true`) and see if it is something that
+                        // can reasonably be interpreted as a binop following an expression.
+                        err.multipart_suggestion(
+                            "parentheses are required to parse this as an expression",
+                            vec![
+                                (expr.span.shrink_to_lo(), "(".to_string()),
+                                (expr.span.shrink_to_hi(), ")".to_string()),
+                            ],
+                            Applicability::MachineApplicable,
+                        );
+                    } else if expr.can_have_side_effects() {
+                        self.suggest_semicolon_at_end(expr.span, err);
                     }
                 });
             }
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
index aca3840712e79..84ea2ec0f8a43 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
@@ -1,3 +1,4 @@
+// ignore-tidy-filelength
 use core::cmp::min;
 use core::iter;
 
@@ -766,56 +767,121 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         needs_block: bool,
         parent_is_closure: bool,
     ) {
-        if expected.is_unit() {
-            // `BlockTailExpression` only relevant if the tail expr would be
-            // useful on its own.
-            match expression.kind {
-                ExprKind::Call(..)
-                | ExprKind::MethodCall(..)
-                | ExprKind::Loop(..)
-                | ExprKind::If(..)
-                | ExprKind::Match(..)
-                | ExprKind::Block(..)
-                    if expression.can_have_side_effects()
-                        // If the expression is from an external macro, then do not suggest
-                        // adding a semicolon, because there's nowhere to put it.
-                        // See issue #81943.
-                        && !expression.span.in_external_macro(self.tcx.sess.source_map()) =>
+        if !expected.is_unit() {
+            return;
+        }
+        // `BlockTailExpression` only relevant if the tail expr would be
+        // useful on its own.
+        match expression.kind {
+            ExprKind::Call(..)
+            | ExprKind::MethodCall(..)
+            | ExprKind::Loop(..)
+            | ExprKind::If(..)
+            | ExprKind::Match(..)
+            | ExprKind::Block(..)
+                if expression.can_have_side_effects()
+                    // If the expression is from an external macro, then do not suggest
+                    // adding a semicolon, because there's nowhere to put it.
+                    // See issue #81943.
+                    && !expression.span.in_external_macro(self.tcx.sess.source_map()) =>
+            {
+                if needs_block {
+                    err.multipart_suggestion(
+                        "consider using a semicolon here",
+                        vec![
+                            (expression.span.shrink_to_lo(), "{ ".to_owned()),
+                            (expression.span.shrink_to_hi(), "; }".to_owned()),
+                        ],
+                        Applicability::MachineApplicable,
+                    );
+                } else if let hir::Node::Block(block) = self.tcx.parent_hir_node(expression.hir_id)
+                    && let hir::Node::Expr(expr) = self.tcx.parent_hir_node(block.hir_id)
+                    && let hir::Node::Expr(if_expr) = self.tcx.parent_hir_node(expr.hir_id)
+                    && let hir::ExprKind::If(_cond, _then, Some(_else)) = if_expr.kind
+                    && let hir::Node::Stmt(stmt) = self.tcx.parent_hir_node(if_expr.hir_id)
+                    && let hir::StmtKind::Expr(_) = stmt.kind
+                    && self.is_next_stmt_expr_continuation(stmt.hir_id)
                 {
-                    if needs_block {
-                        err.multipart_suggestion(
-                            "consider using a semicolon here",
-                            vec![
-                                (expression.span.shrink_to_lo(), "{ ".to_owned()),
-                                (expression.span.shrink_to_hi(), "; }".to_owned()),
-                            ],
-                            Applicability::MachineApplicable,
-                        );
-                    } else {
-                        err.span_suggestion(
-                            expression.span.shrink_to_hi(),
-                            "consider using a semicolon here",
-                            ";",
-                            Applicability::MachineApplicable,
-                        );
-                    }
+                    err.multipart_suggestion(
+                        "parentheses are required to parse this as an expression",
+                        vec![
+                            (stmt.span.shrink_to_lo(), "(".to_string()),
+                            (stmt.span.shrink_to_hi(), ")".to_string()),
+                        ],
+                        Applicability::MachineApplicable,
+                    );
+                } else {
+                    err.span_suggestion(
+                        expression.span.shrink_to_hi(),
+                        "consider using a semicolon here",
+                        ";",
+                        Applicability::MachineApplicable,
+                    );
                 }
-                ExprKind::Path(..) | ExprKind::Lit(_)
-                    if parent_is_closure
-                        && !expression.span.in_external_macro(self.tcx.sess.source_map()) =>
+            }
+            ExprKind::Path(..) | ExprKind::Lit(_)
+                if parent_is_closure
+                    && !expression.span.in_external_macro(self.tcx.sess.source_map()) =>
+            {
+                err.span_suggestion_verbose(
+                    expression.span.shrink_to_lo(),
+                    "consider ignoring the value",
+                    "_ = ",
+                    Applicability::MachineApplicable,
+                );
+            }
+            _ => {
+                if let hir::Node::Block(block) = self.tcx.parent_hir_node(expression.hir_id)
+                    && let hir::Node::Expr(expr) = self.tcx.parent_hir_node(block.hir_id)
+                    && let hir::Node::Expr(if_expr) = self.tcx.parent_hir_node(expr.hir_id)
+                    && let hir::ExprKind::If(_cond, _then, Some(_else)) = if_expr.kind
+                    && let hir::Node::Stmt(stmt) = self.tcx.parent_hir_node(if_expr.hir_id)
+                    && let hir::StmtKind::Expr(_) = stmt.kind
+                    && self.is_next_stmt_expr_continuation(stmt.hir_id)
                 {
-                    err.span_suggestion_verbose(
-                        expression.span.shrink_to_lo(),
-                        "consider ignoring the value",
-                        "_ = ",
+                    // The error is pointing at an arm of an if-expression, and we want to get the
+                    // `Span` of the whole if-expression for the suggestion. This only works for a
+                    // single level of nesting, which is fine.
+                    // We have something like `if true { false } else { true } && true`. Suggest
+                    // wrapping in parentheses. We find the statement or expression following the
+                    // `if` (`&& true`) and see if it is something that can reasonably be
+                    // interpreted as a binop following an expression.
+                    err.multipart_suggestion(
+                        "parentheses are required to parse this as an expression",
+                        vec![
+                            (stmt.span.shrink_to_lo(), "(".to_string()),
+                            (stmt.span.shrink_to_hi(), ")".to_string()),
+                        ],
                         Applicability::MachineApplicable,
                     );
                 }
-                _ => (),
             }
         }
     }
 
+    pub(crate) fn is_next_stmt_expr_continuation(&self, hir_id: HirId) -> bool {
+        if let hir::Node::Block(b) = self.tcx.parent_hir_node(hir_id)
+            && let mut stmts = b.stmts.iter().skip_while(|s| s.hir_id != hir_id)
+            && let Some(_) = stmts.next() // The statement the statement that was passed in
+            && let Some(next) = match (stmts.next(), b.expr) { // The following statement
+                (Some(next), _) => match next.kind {
+                    hir::StmtKind::Expr(next) | hir::StmtKind::Semi(next) => Some(next),
+                    _ => None,
+                },
+                (None, Some(next)) => Some(next),
+                _ => None,
+            }
+            && let hir::ExprKind::AddrOf(..) // prev_stmt && next
+                | hir::ExprKind::Unary(..) // prev_stmt * next
+                | hir::ExprKind::Err(_) = next.kind
+        // prev_stmt + next
+        {
+            true
+        } else {
+            false
+        }
+    }
+
     /// A possible error is to forget to add a return type that is needed:
     ///
     /// ```compile_fail,E0308
diff --git a/tests/ui/parser/expr-as-stmt-2.rs b/tests/ui/parser/expr-as-stmt-2.rs
index 3a18bdc3b730a..4b1f62d8056df 100644
--- a/tests/ui/parser/expr-as-stmt-2.rs
+++ b/tests/ui/parser/expr-as-stmt-2.rs
@@ -7,4 +7,25 @@ fn foo(a: Option<u32>, b: Option<u32>) -> bool {
     if let Some(y) = a { true } else { false }
 }
 
-fn main() {}
+fn bar() -> bool {
+    false
+}
+
+fn main() {
+    if true { true } else { false } && true;
+    //~^ ERROR mismatched types
+    //~| ERROR mismatched types
+    if true { true } else { false } && if true { true } else { false };
+    //~^ ERROR mismatched types
+    //~| ERROR mismatched types
+    if true { true } else { false } if true { true } else { false };
+    //~^ ERROR mismatched types
+    //~| ERROR mismatched types
+    if true { bar() } else { bar() } && if true { bar() } else { bar() };
+    //~^ ERROR mismatched types
+    //~| ERROR mismatched types
+    if true { bar() } else { bar() } if true { bar() } else { bar() };
+    //~^ ERROR mismatched types
+    //~| ERROR mismatched types
+    let _ = if true { true } else { false } && true; // ok
+}
diff --git a/tests/ui/parser/expr-as-stmt-2.stderr b/tests/ui/parser/expr-as-stmt-2.stderr
index 2b6314c38ceb6..f9838ee0299cf 100644
--- a/tests/ui/parser/expr-as-stmt-2.stderr
+++ b/tests/ui/parser/expr-as-stmt-2.stderr
@@ -7,6 +7,10 @@ LL |     if let Some(x) = a { true } else { false }
    |     |                    expected `()`, found `bool`
    |     expected this to be `()`
    |
+help: parentheses are required to parse this as an expression
+   |
+LL |     (if let Some(x) = a { true } else { false })
+   |     +                                          +
 help: you might have meant to return this value
    |
 LL |     if let Some(x) = a { return true; } else { false }
@@ -21,6 +25,10 @@ LL |     if let Some(x) = a { true } else { false }
    |     |                                  expected `()`, found `bool`
    |     expected this to be `()`
    |
+help: parentheses are required to parse this as an expression
+   |
+LL |     (if let Some(x) = a { true } else { false })
+   |     +                                          +
 help: you might have meant to return this value
    |
 LL |     if let Some(x) = a { true } else { return false; }
@@ -41,6 +49,152 @@ help: parentheses are required to parse this as an expression
 LL |     (if let Some(x) = a { true } else { false })
    |     +                                          +
 
-error: aborting due to 3 previous errors
+error[E0308]: mismatched types
+  --> $DIR/expr-as-stmt-2.rs:15:15
+   |
+LL |     if true { true } else { false } && true;
+   |     ----------^^^^-----------------
+   |     |         |
+   |     |         expected `()`, found `bool`
+   |     expected this to be `()`
+   |
+help: parentheses are required to parse this as an expression
+   |
+LL |     (if true { true } else { false }) && true;
+   |     +                               +
+
+error[E0308]: mismatched types
+  --> $DIR/expr-as-stmt-2.rs:15:29
+   |
+LL |     if true { true } else { false } && true;
+   |     ------------------------^^^^^--
+   |     |                       |
+   |     |                       expected `()`, found `bool`
+   |     expected this to be `()`
+   |
+help: parentheses are required to parse this as an expression
+   |
+LL |     (if true { true } else { false }) && true;
+   |     +                               +
+
+error[E0308]: mismatched types
+  --> $DIR/expr-as-stmt-2.rs:18:15
+   |
+LL |     if true { true } else { false } && if true { true } else { false };
+   |     ----------^^^^-----------------
+   |     |         |
+   |     |         expected `()`, found `bool`
+   |     expected this to be `()`
+   |
+help: parentheses are required to parse this as an expression
+   |
+LL |     (if true { true } else { false }) && if true { true } else { false };
+   |     +                               +
+
+error[E0308]: mismatched types
+  --> $DIR/expr-as-stmt-2.rs:18:29
+   |
+LL |     if true { true } else { false } && if true { true } else { false };
+   |     ------------------------^^^^^--
+   |     |                       |
+   |     |                       expected `()`, found `bool`
+   |     expected this to be `()`
+   |
+help: parentheses are required to parse this as an expression
+   |
+LL |     (if true { true } else { false }) && if true { true } else { false };
+   |     +                               +
+
+error[E0308]: mismatched types
+  --> $DIR/expr-as-stmt-2.rs:21:15
+   |
+LL |     if true { true } else { false } if true { true } else { false };
+   |     ----------^^^^-----------------
+   |     |         |
+   |     |         expected `()`, found `bool`
+   |     expected this to be `()`
+
+error[E0308]: mismatched types
+  --> $DIR/expr-as-stmt-2.rs:21:29
+   |
+LL |     if true { true } else { false } if true { true } else { false };
+   |     ------------------------^^^^^--
+   |     |                       |
+   |     |                       expected `()`, found `bool`
+   |     expected this to be `()`
+
+error[E0308]: mismatched types
+  --> $DIR/expr-as-stmt-2.rs:24:15
+   |
+LL |     if true { bar() } else { bar() } && if true { bar() } else { bar() };
+   |     ----------^^^^^-----------------
+   |     |         |
+   |     |         expected `()`, found `bool`
+   |     expected this to be `()`
+   |
+help: parentheses are required to parse this as an expression
+   |
+LL |     (if true { bar() } else { bar() }) && if true { bar() } else { bar() };
+   |     +                                +
+help: consider using a semicolon here
+   |
+LL |     if true { bar() } else { bar() }; && if true { bar() } else { bar() };
+   |                                     +
+
+error[E0308]: mismatched types
+  --> $DIR/expr-as-stmt-2.rs:24:30
+   |
+LL |     if true { bar() } else { bar() } && if true { bar() } else { bar() };
+   |     -------------------------^^^^^--
+   |     |                        |
+   |     |                        expected `()`, found `bool`
+   |     expected this to be `()`
+   |
+help: parentheses are required to parse this as an expression
+   |
+LL |     (if true { bar() } else { bar() }) && if true { bar() } else { bar() };
+   |     +                                +
+help: consider using a semicolon here
+   |
+LL |     if true { bar() } else { bar() }; && if true { bar() } else { bar() };
+   |                                     +
+
+error[E0308]: mismatched types
+  --> $DIR/expr-as-stmt-2.rs:27:15
+   |
+LL |     if true { bar() } else { bar() } if true { bar() } else { bar() };
+   |     ----------^^^^^-----------------
+   |     |         |
+   |     |         expected `()`, found `bool`
+   |     expected this to be `()`
+   |
+help: consider using a semicolon here
+   |
+LL |     if true { bar(); } else { bar() } if true { bar() } else { bar() };
+   |                    +
+help: consider using a semicolon here
+   |
+LL |     if true { bar() } else { bar() }; if true { bar() } else { bar() };
+   |                                     +
+
+error[E0308]: mismatched types
+  --> $DIR/expr-as-stmt-2.rs:27:30
+   |
+LL |     if true { bar() } else { bar() } if true { bar() } else { bar() };
+   |     -------------------------^^^^^--
+   |     |                        |
+   |     |                        expected `()`, found `bool`
+   |     expected this to be `()`
+   |
+help: consider using a semicolon here
+   |
+LL |     if true { bar() } else { bar(); } if true { bar() } else { bar() };
+   |                                   +
+help: consider using a semicolon here
+   |
+LL |     if true { bar() } else { bar() }; if true { bar() } else { bar() };
+   |                                     +
+
+error: aborting due to 13 previous errors
 
 For more information about this error, try `rustc --explain E0308`.

From 1c64d3e6d1fe6256cb11b8dd455ccad1b5f9848c Mon Sep 17 00:00:00 2001
From: ltdk <usr@ltdk.xyz>
Date: Mon, 11 Aug 2025 19:36:20 -0400
Subject: [PATCH 0393/1889] Constify conversion traits

---
 library/alloc/src/borrow.rs                   | 15 +++++--
 library/alloc/src/collections/mod.rs          |  6 ++-
 library/alloc/src/lib.rs                      |  3 +-
 library/alloctests/lib.rs                     |  1 +
 library/core/src/array/mod.rs                 | 26 +++++++----
 library/core/src/ascii/ascii_char.rs          |  2 +-
 library/core/src/borrow.rs                    | 19 +++++---
 library/core/src/bstr/mod.rs                  | 45 ++++++++++++-------
 library/core/src/cell.rs                      | 18 +++++---
 library/core/src/cell/once.rs                 |  3 +-
 library/core/src/char/convert.rs              | 28 ++++++++----
 library/core/src/convert/mod.rs               | 40 ++++++++---------
 library/core/src/convert/num.rs               | 19 ++++----
 library/core/src/ffi/c_str.rs                 |  3 +-
 library/core/src/mem/manually_drop.rs         |  6 ++-
 library/core/src/net/ip_addr.rs               | 24 +++++-----
 library/core/src/net/socket_addr.rs           |  6 +--
 library/core/src/num/error.rs                 |  4 +-
 library/core/src/num/mod.rs                   |  2 +-
 library/core/src/num/nonzero.rs               |  2 +-
 library/core/src/ops/deref.rs                 | 10 ++---
 library/core/src/option.rs                    | 22 ++++-----
 library/core/src/panic/unwind_safe.rs         |  6 ++-
 library/core/src/pin.rs                       | 24 +++++++---
 library/core/src/pin/unsafe_pinned.rs         |  3 +-
 library/core/src/ptr/alignment.rs             | 10 +++--
 library/core/src/ptr/non_null.rs              |  9 ++--
 library/core/src/ptr/unique.rs                |  6 ++-
 library/core/src/range.rs                     |  9 ++--
 library/core/src/result.rs                    | 18 ++++----
 library/core/src/str/mod.rs                   |  3 +-
 library/core/src/str/traits.rs                |  2 +-
 library/core/src/sync/atomic.rs               |  7 +--
 library/core/src/sync/exclusive.rs            |  3 +-
 library/core/src/task/poll.rs                 |  3 +-
 library/core/src/task/wake.rs                 |  3 +-
 library/core/src/tuple.rs                     |  2 +
 library/coretests/tests/lib.rs                |  3 +-
 library/std/src/ffi/os_str.rs                 | 12 +++--
 library/std/src/lib.rs                        |  1 +
 library/std/src/path.rs                       | 15 ++++---
 .../const-traits/enforce-deref-on-adjust.rs   |  2 +-
 .../non-const-op-in-closure-in-const.rs       |  2 +-
 .../const-traits/reservation-impl-ice.rs      |  2 +-
 44 files changed, 278 insertions(+), 171 deletions(-)

diff --git a/library/alloc/src/borrow.rs b/library/alloc/src/borrow.rs
index 07f51b7614ff8..cb32896161e5c 100644
--- a/library/alloc/src/borrow.rs
+++ b/library/alloc/src/borrow.rs
@@ -17,9 +17,11 @@ use crate::fmt;
 use crate::string::String;
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, B: ?Sized> Borrow<B> for Cow<'a, B>
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<'a, B: ?Sized> const Borrow<B> for Cow<'a, B>
 where
     B: ToOwned,
+    B::Owned: [const] Borrow<B>,
 {
     fn borrow(&self) -> &B {
         &**self
@@ -326,9 +328,10 @@ impl<B: ?Sized + ToOwned> Cow<'_, B> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<B: ?Sized + ToOwned> Deref for Cow<'_, B>
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<B: ?Sized + ToOwned> const Deref for Cow<'_, B>
 where
-    B::Owned: Borrow<B>,
+    B::Owned: [const] Borrow<B>,
 {
     type Target = B;
 
@@ -439,7 +442,11 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized + ToOwned> AsRef<T> for Cow<'_, T> {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T: ?Sized + ToOwned> const AsRef<T> for Cow<'_, T>
+where
+    T::Owned: [const] Borrow<T>,
+{
     fn as_ref(&self) -> &T {
         self
     }
diff --git a/library/alloc/src/collections/mod.rs b/library/alloc/src/collections/mod.rs
index fac4d1a65abcb..212d7c8465b6e 100644
--- a/library/alloc/src/collections/mod.rs
+++ b/library/alloc/src/collections/mod.rs
@@ -128,8 +128,9 @@ pub use realalloc::collections::TryReserveErrorKind;
     reason = "Uncertain how much info should be exposed",
     issue = "48043"
 )]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 #[cfg(not(test))]
-impl From<TryReserveErrorKind> for TryReserveError {
+impl const From<TryReserveErrorKind> for TryReserveError {
     #[inline]
     fn from(kind: TryReserveErrorKind) -> Self {
         Self { kind }
@@ -137,8 +138,9 @@ impl From<TryReserveErrorKind> for TryReserveError {
 }
 
 #[unstable(feature = "try_reserve_kind", reason = "new API", issue = "48043")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 #[cfg(not(test))]
-impl From<LayoutError> for TryReserveErrorKind {
+impl const From<LayoutError> for TryReserveErrorKind {
     /// Always evaluates to [`TryReserveErrorKind::CapacityOverflow`].
     #[inline]
     fn from(_: LayoutError) -> Self {
diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs
index 711092ae8eb25..cba1ce40f75d5 100644
--- a/library/alloc/src/lib.rs
+++ b/library/alloc/src/lib.rs
@@ -107,10 +107,10 @@
 #![feature(char_max_len)]
 #![feature(clone_to_uninit)]
 #![feature(coerce_unsized)]
+#![feature(const_convert)]
 #![feature(const_default)]
 #![feature(const_eval_select)]
 #![feature(const_heap)]
-#![feature(const_trait_impl)]
 #![feature(core_intrinsics)]
 #![feature(deprecated_suggestion)]
 #![feature(deref_pure_trait)]
@@ -168,6 +168,7 @@
 #![feature(allow_internal_unstable)]
 #![feature(cfg_sanitize)]
 #![feature(const_precise_live_drops)]
+#![feature(const_trait_impl)]
 #![feature(coroutine_trait)]
 #![feature(decl_macro)]
 #![feature(dropck_eyepatch)]
diff --git a/library/alloctests/lib.rs b/library/alloctests/lib.rs
index 97de7d6a701ca..0201c8752210c 100644
--- a/library/alloctests/lib.rs
+++ b/library/alloctests/lib.rs
@@ -49,6 +49,7 @@
 // Language features:
 // tidy-alphabetical-start
 #![feature(cfg_sanitize)]
+#![feature(const_trait_impl)]
 #![feature(dropck_eyepatch)]
 #![feature(lang_items)]
 #![feature(min_specialization)]
diff --git a/library/core/src/array/mod.rs b/library/core/src/array/mod.rs
index 835ee57ce230b..915198e571f90 100644
--- a/library/core/src/array/mod.rs
+++ b/library/core/src/array/mod.rs
@@ -192,7 +192,7 @@ impl fmt::Display for TryFromSliceError {
 impl Error for TryFromSliceError {}
 
 #[stable(feature = "try_from_slice_error", since = "1.36.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl const From<Infallible> for TryFromSliceError {
     fn from(x: Infallible) -> TryFromSliceError {
         match x {}
@@ -200,7 +200,8 @@ impl const From<Infallible> for TryFromSliceError {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, const N: usize> AsRef<[T]> for [T; N] {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T, const N: usize> const AsRef<[T]> for [T; N] {
     #[inline]
     fn as_ref(&self) -> &[T] {
         &self[..]
@@ -208,7 +209,8 @@ impl<T, const N: usize> AsRef<[T]> for [T; N] {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, const N: usize> AsMut<[T]> for [T; N] {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T, const N: usize> const AsMut<[T]> for [T; N] {
     #[inline]
     fn as_mut(&mut self) -> &mut [T] {
         &mut self[..]
@@ -216,14 +218,16 @@ impl<T, const N: usize> AsMut<[T]> for [T; N] {
 }
 
 #[stable(feature = "array_borrow", since = "1.4.0")]
-impl<T, const N: usize> Borrow<[T]> for [T; N] {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T, const N: usize> const Borrow<[T]> for [T; N] {
     fn borrow(&self) -> &[T] {
         self
     }
 }
 
 #[stable(feature = "array_borrow", since = "1.4.0")]
-impl<T, const N: usize> BorrowMut<[T]> for [T; N] {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T, const N: usize> const BorrowMut<[T]> for [T; N] {
     fn borrow_mut(&mut self) -> &mut [T] {
         self
     }
@@ -242,7 +246,8 @@ impl<T, const N: usize> BorrowMut<[T]> for [T; N] {
 /// assert_eq!(512, u16::from_le_bytes(bytes_tail));
 /// ```
 #[stable(feature = "try_from", since = "1.34.0")]
-impl<T, const N: usize> TryFrom<&[T]> for [T; N]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T, const N: usize> const TryFrom<&[T]> for [T; N]
 where
     T: Copy,
 {
@@ -267,7 +272,8 @@ where
 /// assert_eq!(512, u16::from_le_bytes(bytes_tail));
 /// ```
 #[stable(feature = "try_from_mut_slice_to_array", since = "1.59.0")]
-impl<T, const N: usize> TryFrom<&mut [T]> for [T; N]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T, const N: usize> const TryFrom<&mut [T]> for [T; N]
 where
     T: Copy,
 {
@@ -292,7 +298,8 @@ where
 /// assert_eq!(512, u16::from_le_bytes(*bytes_tail));
 /// ```
 #[stable(feature = "try_from", since = "1.34.0")]
-impl<'a, T, const N: usize> TryFrom<&'a [T]> for &'a [T; N] {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<'a, T, const N: usize> const TryFrom<&'a [T]> for &'a [T; N] {
     type Error = TryFromSliceError;
 
     #[inline]
@@ -314,7 +321,8 @@ impl<'a, T, const N: usize> TryFrom<&'a [T]> for &'a [T; N] {
 /// assert_eq!(512, u16::from_le_bytes(*bytes_tail));
 /// ```
 #[stable(feature = "try_from", since = "1.34.0")]
-impl<'a, T, const N: usize> TryFrom<&'a mut [T]> for &'a mut [T; N] {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<'a, T, const N: usize> const TryFrom<&'a mut [T]> for &'a mut [T; N] {
     type Error = TryFromSliceError;
 
     #[inline]
diff --git a/library/core/src/ascii/ascii_char.rs b/library/core/src/ascii/ascii_char.rs
index 419e4694594f0..49d540314a245 100644
--- a/library/core/src/ascii/ascii_char.rs
+++ b/library/core/src/ascii/ascii_char.rs
@@ -1156,7 +1156,7 @@ macro_rules! into_int_impl {
     ($($ty:ty)*) => {
         $(
             #[unstable(feature = "ascii_char", issue = "110998")]
-            #[rustc_const_unstable(feature = "const_try", issue = "74935")]
+            #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
             impl const From<AsciiChar> for $ty {
                 #[inline]
                 fn from(chr: AsciiChar) -> $ty {
diff --git a/library/core/src/borrow.rs b/library/core/src/borrow.rs
index da05f236d2fef..6ce7e4656b99e 100644
--- a/library/core/src/borrow.rs
+++ b/library/core/src/borrow.rs
@@ -154,6 +154,8 @@
 /// [`String`]: ../../std/string/struct.String.html
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_diagnostic_item = "Borrow"]
+#[const_trait]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 pub trait Borrow<Borrowed: ?Sized> {
     /// Immutably borrows from an owned value.
     ///
@@ -185,6 +187,8 @@ pub trait Borrow<Borrowed: ?Sized> {
 /// for more information on borrowing as another type.
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_diagnostic_item = "BorrowMut"]
+#[const_trait]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 pub trait BorrowMut<Borrowed: ?Sized>: Borrow<Borrowed> {
     /// Mutably borrows from an owned value.
     ///
@@ -206,7 +210,8 @@ pub trait BorrowMut<Borrowed: ?Sized>: Borrow<Borrowed> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized> Borrow<T> for T {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T: ?Sized> const Borrow<T> for T {
     #[rustc_diagnostic_item = "noop_method_borrow"]
     fn borrow(&self) -> &T {
         self
@@ -214,28 +219,32 @@ impl<T: ?Sized> Borrow<T> for T {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized> BorrowMut<T> for T {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T: ?Sized> const BorrowMut<T> for T {
     fn borrow_mut(&mut self) -> &mut T {
         self
     }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized> Borrow<T> for &T {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T: ?Sized> const Borrow<T> for &T {
     fn borrow(&self) -> &T {
         self
     }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized> Borrow<T> for &mut T {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T: ?Sized> const Borrow<T> for &mut T {
     fn borrow(&self) -> &T {
         self
     }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized> BorrowMut<T> for &mut T {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T: ?Sized> const BorrowMut<T> for &mut T {
     fn borrow_mut(&mut self) -> &mut T {
         self
     }
diff --git a/library/core/src/bstr/mod.rs b/library/core/src/bstr/mod.rs
index 13127d645a257..e13dc5cd44d5c 100644
--- a/library/core/src/bstr/mod.rs
+++ b/library/core/src/bstr/mod.rs
@@ -63,14 +63,16 @@ impl ByteStr {
     /// ```
     #[inline]
     #[unstable(feature = "bstr", issue = "134915")]
-    pub fn new<B: ?Sized + AsRef<[u8]>>(bytes: &B) -> &Self {
+    #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+    pub const fn new<B: ?Sized + [const] AsRef<[u8]>>(bytes: &B) -> &Self {
         ByteStr::from_bytes(bytes.as_ref())
     }
 
     #[doc(hidden)]
     #[unstable(feature = "bstr_internals", issue = "none")]
     #[inline]
-    pub fn from_bytes(slice: &[u8]) -> &Self {
+    #[rustc_const_unstable(feature = "bstr_internals", issue = "none")]
+    pub const fn from_bytes(slice: &[u8]) -> &Self {
         // SAFETY: `ByteStr` is a transparent wrapper around `[u8]`, so we can turn a reference to
         // the wrapped type into a reference to the wrapper type.
         unsafe { &*(slice as *const [u8] as *const Self) }
@@ -79,7 +81,8 @@ impl ByteStr {
     #[doc(hidden)]
     #[unstable(feature = "bstr_internals", issue = "none")]
     #[inline]
-    pub fn from_bytes_mut(slice: &mut [u8]) -> &mut Self {
+    #[rustc_const_unstable(feature = "bstr_internals", issue = "none")]
+    pub const fn from_bytes_mut(slice: &mut [u8]) -> &mut Self {
         // SAFETY: `ByteStr` is a transparent wrapper around `[u8]`, so we can turn a reference to
         // the wrapped type into a reference to the wrapper type.
         unsafe { &mut *(slice as *mut [u8] as *mut Self) }
@@ -88,20 +91,23 @@ impl ByteStr {
     #[doc(hidden)]
     #[unstable(feature = "bstr_internals", issue = "none")]
     #[inline]
-    pub fn as_bytes(&self) -> &[u8] {
+    #[rustc_const_unstable(feature = "bstr_internals", issue = "none")]
+    pub const fn as_bytes(&self) -> &[u8] {
         &self.0
     }
 
     #[doc(hidden)]
     #[unstable(feature = "bstr_internals", issue = "none")]
     #[inline]
-    pub fn as_bytes_mut(&mut self) -> &mut [u8] {
+    #[rustc_const_unstable(feature = "bstr_internals", issue = "none")]
+    pub const fn as_bytes_mut(&mut self) -> &mut [u8] {
         &mut self.0
     }
 }
 
 #[unstable(feature = "bstr", issue = "134915")]
-impl Deref for ByteStr {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl const Deref for ByteStr {
     type Target = [u8];
 
     #[inline]
@@ -111,7 +117,8 @@ impl Deref for ByteStr {
 }
 
 #[unstable(feature = "bstr", issue = "134915")]
-impl DerefMut for ByteStr {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl const DerefMut for ByteStr {
     #[inline]
     fn deref_mut(&mut self) -> &mut [u8] {
         &mut self.0
@@ -185,7 +192,8 @@ impl fmt::Display for ByteStr {
 }
 
 #[unstable(feature = "bstr", issue = "134915")]
-impl AsRef<[u8]> for ByteStr {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl const AsRef<[u8]> for ByteStr {
     #[inline]
     fn as_ref(&self) -> &[u8] {
         &self.0
@@ -193,7 +201,8 @@ impl AsRef<[u8]> for ByteStr {
 }
 
 #[unstable(feature = "bstr", issue = "134915")]
-impl AsRef<ByteStr> for ByteStr {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl const AsRef<ByteStr> for ByteStr {
     #[inline]
     fn as_ref(&self) -> &ByteStr {
         self
@@ -203,7 +212,8 @@ impl AsRef<ByteStr> for ByteStr {
 // `impl AsRef<ByteStr> for [u8]` omitted to avoid widespread inference failures
 
 #[unstable(feature = "bstr", issue = "134915")]
-impl AsRef<ByteStr> for str {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl const AsRef<ByteStr> for str {
     #[inline]
     fn as_ref(&self) -> &ByteStr {
         ByteStr::new(self)
@@ -211,7 +221,8 @@ impl AsRef<ByteStr> for str {
 }
 
 #[unstable(feature = "bstr", issue = "134915")]
-impl AsMut<[u8]> for ByteStr {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl const AsMut<[u8]> for ByteStr {
     #[inline]
     fn as_mut(&mut self) -> &mut [u8] {
         &mut self.0
@@ -225,7 +236,8 @@ impl AsMut<[u8]> for ByteStr {
 // `impl Borrow<ByteStr> for str` omitted to avoid widespread inference failures
 
 #[unstable(feature = "bstr", issue = "134915")]
-impl Borrow<[u8]> for ByteStr {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl const Borrow<[u8]> for ByteStr {
     #[inline]
     fn borrow(&self) -> &[u8] {
         &self.0
@@ -235,7 +247,8 @@ impl Borrow<[u8]> for ByteStr {
 // `impl BorrowMut<ByteStr> for [u8]` omitted to avoid widespread inference failures
 
 #[unstable(feature = "bstr", issue = "134915")]
-impl BorrowMut<[u8]> for ByteStr {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl const BorrowMut<[u8]> for ByteStr {
     #[inline]
     fn borrow_mut(&mut self) -> &mut [u8] {
         &mut self.0
@@ -303,7 +316,8 @@ impl<'a> Default for &'a mut ByteStr {
 // }
 
 #[unstable(feature = "bstr", issue = "134915")]
-impl<'a> TryFrom<&'a ByteStr> for &'a str {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<'a> const TryFrom<&'a ByteStr> for &'a str {
     type Error = crate::str::Utf8Error;
 
     #[inline]
@@ -313,7 +327,8 @@ impl<'a> TryFrom<&'a ByteStr> for &'a str {
 }
 
 #[unstable(feature = "bstr", issue = "134915")]
-impl<'a> TryFrom<&'a mut ByteStr> for &'a mut str {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<'a> const TryFrom<&'a mut ByteStr> for &'a mut str {
     type Error = crate::str::Utf8Error;
 
     #[inline]
diff --git a/library/core/src/cell.rs b/library/core/src/cell.rs
index 59a6aa7062023..9b53b75ebee80 100644
--- a/library/core/src/cell.rs
+++ b/library/core/src/cell.rs
@@ -390,7 +390,8 @@ impl<T: Ord + Copy> Ord for Cell<T> {
 }
 
 #[stable(feature = "cell_from", since = "1.12.0")]
-impl<T> From<T> for Cell<T> {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T> const From<T> for Cell<T> {
     /// Creates a new `Cell<T>` containing the given value.
     fn from(t: T) -> Cell<T> {
         Cell::new(t)
@@ -1402,7 +1403,8 @@ impl<T: ?Sized + Ord> Ord for RefCell<T> {
 }
 
 #[stable(feature = "cell_from", since = "1.12.0")]
-impl<T> From<T> for RefCell<T> {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T> const From<T> for RefCell<T> {
     /// Creates a new `RefCell<T>` containing the given value.
     fn from(t: T) -> RefCell<T> {
         RefCell::new(t)
@@ -1483,7 +1485,7 @@ pub struct Ref<'b, T: ?Sized + 'b> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_deref", issue = "88955")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl<T: ?Sized> const Deref for Ref<'_, T> {
     type Target = T;
 
@@ -1967,7 +1969,7 @@ pub struct RefMut<'b, T: ?Sized + 'b> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_deref", issue = "88955")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl<T: ?Sized> const Deref for RefMut<'_, T> {
     type Target = T;
 
@@ -1979,7 +1981,7 @@ impl<T: ?Sized> const Deref for RefMut<'_, T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_deref", issue = "88955")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl<T: ?Sized> const DerefMut for RefMut<'_, T> {
     #[inline]
     fn deref_mut(&mut self) -> &mut T {
@@ -2434,7 +2436,8 @@ impl<T: [const] Default> const Default for UnsafeCell<T> {
 }
 
 #[stable(feature = "cell_from", since = "1.12.0")]
-impl<T> From<T> for UnsafeCell<T> {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T> const From<T> for UnsafeCell<T> {
     /// Creates a new `UnsafeCell<T>` containing the given value.
     fn from(t: T) -> UnsafeCell<T> {
         UnsafeCell::new(t)
@@ -2539,7 +2542,8 @@ impl<T: [const] Default> const Default for SyncUnsafeCell<T> {
 }
 
 #[unstable(feature = "sync_unsafe_cell", issue = "95439")]
-impl<T> From<T> for SyncUnsafeCell<T> {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T> const From<T> for SyncUnsafeCell<T> {
     /// Creates a new `SyncUnsafeCell<T>` containing the given value.
     fn from(t: T) -> SyncUnsafeCell<T> {
         SyncUnsafeCell::new(t)
diff --git a/library/core/src/cell/once.rs b/library/core/src/cell/once.rs
index c6c96571d33c9..833be059d75f7 100644
--- a/library/core/src/cell/once.rs
+++ b/library/core/src/cell/once.rs
@@ -395,7 +395,8 @@ impl<T: PartialEq> PartialEq for OnceCell<T> {
 impl<T: Eq> Eq for OnceCell<T> {}
 
 #[stable(feature = "once_cell", since = "1.70.0")]
-impl<T> From<T> for OnceCell<T> {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T> const From<T> for OnceCell<T> {
     /// Creates a new `OnceCell<T>` which already contains the given `value`.
     #[inline]
     fn from(value: T) -> Self {
diff --git a/library/core/src/char/convert.rs b/library/core/src/char/convert.rs
index cf5a91bf8ddb5..6380f42d320c6 100644
--- a/library/core/src/char/convert.rs
+++ b/library/core/src/char/convert.rs
@@ -36,7 +36,7 @@ pub(super) const unsafe fn from_u32_unchecked(i: u32) -> char {
 }
 
 #[stable(feature = "char_convert", since = "1.13.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl const From<char> for u32 {
     /// Converts a [`char`] into a [`u32`].
     ///
@@ -54,7 +54,7 @@ impl const From<char> for u32 {
 }
 
 #[stable(feature = "more_char_conversions", since = "1.51.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl const From<char> for u64 {
     /// Converts a [`char`] into a [`u64`].
     ///
@@ -74,7 +74,7 @@ impl const From<char> for u64 {
 }
 
 #[stable(feature = "more_char_conversions", since = "1.51.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl const From<char> for u128 {
     /// Converts a [`char`] into a [`u128`].
     ///
@@ -98,7 +98,8 @@ impl const From<char> for u128 {
 ///
 /// See [`impl From<u8> for char`](char#impl-From<u8>-for-char) for details on the encoding.
 #[stable(feature = "u8_from_char", since = "1.59.0")]
-impl TryFrom<char> for u8 {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl const TryFrom<char> for u8 {
     type Error = TryFromCharError;
 
     /// Tries to convert a [`char`] into a [`u8`].
@@ -113,7 +114,11 @@ impl TryFrom<char> for u8 {
     /// ```
     #[inline]
     fn try_from(c: char) -> Result<u8, Self::Error> {
-        u8::try_from(u32::from(c)).map_err(|_| TryFromCharError(()))
+        // FIXME(const-hack): this should use map_err instead
+        match u8::try_from(u32::from(c)) {
+            Ok(b) => Ok(b),
+            Err(_) => Err(TryFromCharError(())),
+        }
     }
 }
 
@@ -122,7 +127,8 @@ impl TryFrom<char> for u8 {
 ///
 /// This corresponds to the UCS-2 encoding, as specified in ISO/IEC 10646:2003.
 #[stable(feature = "u16_from_char", since = "1.74.0")]
-impl TryFrom<char> for u16 {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl const TryFrom<char> for u16 {
     type Error = TryFromCharError;
 
     /// Tries to convert a [`char`] into a [`u16`].
@@ -137,7 +143,11 @@ impl TryFrom<char> for u16 {
     /// ```
     #[inline]
     fn try_from(c: char) -> Result<u16, Self::Error> {
-        u16::try_from(u32::from(c)).map_err(|_| TryFromCharError(()))
+        // FIXME(const-hack): this should use map_err instead
+        match u16::try_from(u32::from(c)) {
+            Ok(x) => Ok(x),
+            Err(_) => Err(TryFromCharError(())),
+        }
     }
 }
 
@@ -160,7 +170,7 @@ impl TryFrom<char> for u16 {
 /// for a superset of Windows-1252 that fills the remaining blanks with corresponding
 /// C0 and C1 control codes.
 #[stable(feature = "char_convert", since = "1.13.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl const From<u8> for char {
     /// Converts a [`u8`] into a [`char`].
     ///
@@ -246,7 +256,7 @@ const fn char_try_from_u32(i: u32) -> Result<char, CharTryFromError> {
 }
 
 #[stable(feature = "try_from", since = "1.34.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl const TryFrom<u32> for char {
     type Error = CharTryFromError;
 
diff --git a/library/core/src/convert/mod.rs b/library/core/src/convert/mod.rs
index a0a7b7928d16c..add21b491ad0d 100644
--- a/library/core/src/convert/mod.rs
+++ b/library/core/src/convert/mod.rs
@@ -217,7 +217,7 @@ pub const fn identity<T>(x: T) -> T {
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_diagnostic_item = "AsRef"]
 #[const_trait]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 pub trait AsRef<T: PointeeSized>: PointeeSized {
     /// Converts this type into a shared reference of the (usually inferred) input type.
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -370,7 +370,7 @@ pub trait AsRef<T: PointeeSized>: PointeeSized {
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_diagnostic_item = "AsMut"]
 #[const_trait]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 pub trait AsMut<T: PointeeSized>: PointeeSized {
     /// Converts this type into a mutable reference of the (usually inferred) input type.
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -449,7 +449,7 @@ pub trait AsMut<T: PointeeSized>: PointeeSized {
 #[rustc_diagnostic_item = "Into"]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[doc(search_unbox)]
-#[rustc_const_unstable(feature = "const_from", issue = "143773")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 #[const_trait]
 pub trait Into<T>: Sized {
     /// Converts this type into the (usually inferred) input type.
@@ -586,7 +586,7 @@ pub trait Into<T>: Sized {
     note = "to coerce a `{T}` into a `{Self}`, use `&*` as a prefix",
 ))]
 #[doc(search_unbox)]
-#[rustc_const_unstable(feature = "const_from", issue = "143773")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 #[const_trait]
 pub trait From<T>: Sized {
     /// Converts to this type from the input type.
@@ -615,7 +615,7 @@ pub trait From<T>: Sized {
 /// [`Into`], see there for details.
 #[rustc_diagnostic_item = "TryInto"]
 #[stable(feature = "try_from", since = "1.34.0")]
-#[rustc_const_unstable(feature = "const_from", issue = "143773")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 #[const_trait]
 pub trait TryInto<T>: Sized {
     /// The type returned in the event of a conversion error.
@@ -695,7 +695,7 @@ pub trait TryInto<T>: Sized {
 /// [`try_from`]: TryFrom::try_from
 #[rustc_diagnostic_item = "TryFrom"]
 #[stable(feature = "try_from", since = "1.34.0")]
-#[rustc_const_unstable(feature = "const_from", issue = "143773")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 #[const_trait]
 pub trait TryFrom<T>: Sized {
     /// The type returned in the event of a conversion error.
@@ -714,7 +714,7 @@ pub trait TryFrom<T>: Sized {
 
 // As lifts over &
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl<T: PointeeSized, U: PointeeSized> const AsRef<U> for &T
 where
     T: [const] AsRef<U>,
@@ -727,7 +727,7 @@ where
 
 // As lifts over &mut
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl<T: PointeeSized, U: PointeeSized> const AsRef<U> for &mut T
 where
     T: [const] AsRef<U>,
@@ -748,7 +748,7 @@ where
 
 // AsMut lifts over &mut
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl<T: PointeeSized, U: PointeeSized> const AsMut<U> for &mut T
 where
     T: [const] AsMut<U>,
@@ -769,7 +769,7 @@ where
 
 // From implies Into
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_from", issue = "143773")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl<T, U> const Into<U> for T
 where
     U: [const] From<T>,
@@ -787,7 +787,7 @@ where
 
 // From (and thus Into) is reflexive
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_from", issue = "143773")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl<T> const From<T> for T {
     /// Returns the argument unchanged.
     #[inline(always)]
@@ -804,7 +804,7 @@ impl<T> const From<T> for T {
 #[stable(feature = "convert_infallible", since = "1.34.0")]
 #[rustc_reservation_impl = "permitting this impl would forbid us from adding \
                             `impl<T> From<!> for T` later; see rust-lang/rust#64715 for details"]
-#[rustc_const_unstable(feature = "const_from", issue = "143773")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl<T> const From<!> for T {
     fn from(t: !) -> T {
         t
@@ -813,7 +813,7 @@ impl<T> const From<!> for T {
 
 // TryFrom implies TryInto
 #[stable(feature = "try_from", since = "1.34.0")]
-#[rustc_const_unstable(feature = "const_from", issue = "143773")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl<T, U> const TryInto<U> for T
 where
     U: [const] TryFrom<T>,
@@ -829,7 +829,7 @@ where
 // Infallible conversions are semantically equivalent to fallible conversions
 // with an uninhabited error type.
 #[stable(feature = "try_from", since = "1.34.0")]
-#[rustc_const_unstable(feature = "const_from", issue = "143773")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl<T, U> const TryFrom<U> for T
 where
     U: [const] Into<T>,
@@ -847,7 +847,7 @@ where
 ////////////////////////////////////////////////////////////////////////////////
 
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl<T> const AsRef<[T]> for [T] {
     #[inline(always)]
     fn as_ref(&self) -> &[T] {
@@ -856,7 +856,7 @@ impl<T> const AsRef<[T]> for [T] {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl<T> const AsMut<[T]> for [T] {
     #[inline(always)]
     fn as_mut(&mut self) -> &mut [T] {
@@ -865,7 +865,7 @@ impl<T> const AsMut<[T]> for [T] {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl const AsRef<str> for str {
     #[inline(always)]
     fn as_ref(&self) -> &str {
@@ -874,7 +874,7 @@ impl const AsRef<str> for str {
 }
 
 #[stable(feature = "as_mut_str_for_str", since = "1.51.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl const AsMut<str> for str {
     #[inline(always)]
     fn as_mut(&mut self) -> &mut str {
@@ -936,7 +936,7 @@ impl const AsMut<str> for str {
 pub enum Infallible {}
 
 #[stable(feature = "convert_infallible", since = "1.34.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_clone", issue = "142757")]
 impl const Clone for Infallible {
     fn clone(&self) -> Infallible {
         match *self {}
@@ -986,7 +986,7 @@ impl Ord for Infallible {
 }
 
 #[stable(feature = "convert_infallible", since = "1.34.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl const From<!> for Infallible {
     #[inline]
     fn from(x: !) -> Self {
diff --git a/library/core/src/convert/num.rs b/library/core/src/convert/num.rs
index affb4eb64d39d..6ae588a4e044f 100644
--- a/library/core/src/convert/num.rs
+++ b/library/core/src/convert/num.rs
@@ -69,7 +69,7 @@ macro_rules! impl_from {
     };
     ($Small:ty => $Large:ty, #[$attr:meta], $doc:expr $(,)?) => {
         #[$attr]
-        #[rustc_const_unstable(feature = "const_try", issue = "74935")]
+        #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
         impl const From<$Small> for $Large {
             // Rustdocs on the impl block show a "[+] show undocumented items" toggle.
             // Rustdocs on functions do not.
@@ -201,7 +201,7 @@ macro_rules! impl_float_from_bool {
         )?
     ) => {
         #[stable(feature = "float_from_bool", since = "1.68.0")]
-        #[rustc_const_unstable(feature = "const_try", issue = "74935")]
+        #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
             impl const From<bool> for $float {
             #[doc = concat!("Converts a [`bool`] to [`", stringify!($float),"`] losslessly.")]
             /// The resulting value is positive `0.0` for `false` and `1.0` for `true` values.
@@ -252,7 +252,7 @@ impl_float_from_bool!(
 macro_rules! impl_try_from_unbounded {
     ($source:ty => $($target:ty),+) => {$(
         #[stable(feature = "try_from", since = "1.34.0")]
-        #[rustc_const_unstable(feature = "const_try", issue = "74935")]
+        #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
         impl const TryFrom<$source> for $target {
             type Error = TryFromIntError;
 
@@ -271,7 +271,7 @@ macro_rules! impl_try_from_unbounded {
 macro_rules! impl_try_from_lower_bounded {
     ($source:ty => $($target:ty),+) => {$(
         #[stable(feature = "try_from", since = "1.34.0")]
-        #[rustc_const_unstable(feature = "const_try", issue = "74935")]
+        #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
         impl const TryFrom<$source> for $target {
             type Error = TryFromIntError;
 
@@ -294,7 +294,7 @@ macro_rules! impl_try_from_lower_bounded {
 macro_rules! impl_try_from_upper_bounded {
     ($source:ty => $($target:ty),+) => {$(
         #[stable(feature = "try_from", since = "1.34.0")]
-        #[rustc_const_unstable(feature = "const_try", issue = "74935")]
+        #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
         impl const TryFrom<$source> for $target {
             type Error = TryFromIntError;
 
@@ -317,7 +317,7 @@ macro_rules! impl_try_from_upper_bounded {
 macro_rules! impl_try_from_both_bounded {
     ($source:ty => $($target:ty),+) => {$(
         #[stable(feature = "try_from", since = "1.34.0")]
-        #[rustc_const_unstable(feature = "const_try", issue = "74935")]
+        #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
         impl const TryFrom<$source> for $target {
             type Error = TryFromIntError;
 
@@ -456,7 +456,7 @@ use crate::num::NonZero;
 macro_rules! impl_nonzero_int_from_nonzero_int {
     ($Small:ty => $Large:ty) => {
         #[stable(feature = "nz_int_conv", since = "1.41.0")]
-        #[rustc_const_unstable(feature = "const_try", issue = "74935")]
+        #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
         impl const From<NonZero<$Small>> for NonZero<$Large> {
             // Rustdocs on the impl block show a "[+] show undocumented items" toggle.
             // Rustdocs on functions do not.
@@ -515,7 +515,8 @@ impl_nonzero_int_from_nonzero_int!(u64 => i128);
 macro_rules! impl_nonzero_int_try_from_int {
     ($Int:ty) => {
         #[stable(feature = "nzint_try_from_int_conv", since = "1.46.0")]
-        impl TryFrom<$Int> for NonZero<$Int> {
+        #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+        impl const TryFrom<$Int> for NonZero<$Int> {
             type Error = TryFromIntError;
 
             // Rustdocs on the impl block show a "[+] show undocumented items" toggle.
@@ -547,7 +548,7 @@ impl_nonzero_int_try_from_int!(isize);
 macro_rules! impl_nonzero_int_try_from_nonzero_int {
     ($source:ty => $($target:ty),+) => {$(
         #[stable(feature = "nzint_try_from_nzint_conv", since = "1.49.0")]
-        #[rustc_const_unstable(feature = "const_try", issue = "74935")]
+        #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
         impl const TryFrom<NonZero<$source>> for NonZero<$target> {
             type Error = TryFromIntError;
 
diff --git a/library/core/src/ffi/c_str.rs b/library/core/src/ffi/c_str.rs
index e6b599fafcff8..d0b53e3a237f6 100644
--- a/library/core/src/ffi/c_str.rs
+++ b/library/core/src/ffi/c_str.rs
@@ -708,7 +708,8 @@ impl ops::Index<ops::RangeFrom<usize>> for CStr {
 }
 
 #[stable(feature = "cstring_asref", since = "1.7.0")]
-impl AsRef<CStr> for CStr {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl const AsRef<CStr> for CStr {
     #[inline]
     fn as_ref(&self) -> &CStr {
         self
diff --git a/library/core/src/mem/manually_drop.rs b/library/core/src/mem/manually_drop.rs
index 02bb81792931e..8868f05f1b98f 100644
--- a/library/core/src/mem/manually_drop.rs
+++ b/library/core/src/mem/manually_drop.rs
@@ -258,7 +258,8 @@ impl<T: ?Sized> ManuallyDrop<T> {
 }
 
 #[stable(feature = "manually_drop", since = "1.20.0")]
-impl<T: ?Sized> Deref for ManuallyDrop<T> {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T: ?Sized> const Deref for ManuallyDrop<T> {
     type Target = T;
     #[inline(always)]
     fn deref(&self) -> &T {
@@ -267,7 +268,8 @@ impl<T: ?Sized> Deref for ManuallyDrop<T> {
 }
 
 #[stable(feature = "manually_drop", since = "1.20.0")]
-impl<T: ?Sized> DerefMut for ManuallyDrop<T> {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T: ?Sized> const DerefMut for ManuallyDrop<T> {
     #[inline(always)]
     fn deref_mut(&mut self) -> &mut T {
         &mut self.value
diff --git a/library/core/src/net/ip_addr.rs b/library/core/src/net/ip_addr.rs
index 3bf113d017ca9..9779fb8fe4d5e 100644
--- a/library/core/src/net/ip_addr.rs
+++ b/library/core/src/net/ip_addr.rs
@@ -1087,7 +1087,7 @@ impl fmt::Debug for IpAddr {
 }
 
 #[stable(feature = "ip_from_ip", since = "1.16.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl const From<Ipv4Addr> for IpAddr {
     /// Copies this address to a new `IpAddr::V4`.
     ///
@@ -1110,7 +1110,7 @@ impl const From<Ipv4Addr> for IpAddr {
 }
 
 #[stable(feature = "ip_from_ip", since = "1.16.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl const From<Ipv6Addr> for IpAddr {
     /// Copies this address to a new `IpAddr::V6`.
     ///
@@ -1221,7 +1221,7 @@ impl Ord for Ipv4Addr {
 }
 
 #[stable(feature = "ip_u32", since = "1.1.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl const From<Ipv4Addr> for u32 {
     /// Uses [`Ipv4Addr::to_bits`] to convert an IPv4 address to a host byte order `u32`.
     #[inline]
@@ -1231,7 +1231,7 @@ impl const From<Ipv4Addr> for u32 {
 }
 
 #[stable(feature = "ip_u32", since = "1.1.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl const From<u32> for Ipv4Addr {
     /// Uses [`Ipv4Addr::from_bits`] to convert a host byte order `u32` into an IPv4 address.
     #[inline]
@@ -1241,7 +1241,7 @@ impl const From<u32> for Ipv4Addr {
 }
 
 #[stable(feature = "from_slice_v4", since = "1.9.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl const From<[u8; 4]> for Ipv4Addr {
     /// Creates an `Ipv4Addr` from a four element byte array.
     ///
@@ -1260,7 +1260,7 @@ impl const From<[u8; 4]> for Ipv4Addr {
 }
 
 #[stable(feature = "ip_from_slice", since = "1.17.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl const From<[u8; 4]> for IpAddr {
     /// Creates an `IpAddr::V4` from a four element byte array.
     ///
@@ -2215,7 +2215,7 @@ impl Ord for Ipv6Addr {
 }
 
 #[stable(feature = "i128", since = "1.26.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl const From<Ipv6Addr> for u128 {
     /// Uses [`Ipv6Addr::to_bits`] to convert an IPv6 address to a host byte order `u128`.
     #[inline]
@@ -2224,7 +2224,7 @@ impl const From<Ipv6Addr> for u128 {
     }
 }
 #[stable(feature = "i128", since = "1.26.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl const From<u128> for Ipv6Addr {
     /// Uses [`Ipv6Addr::from_bits`] to convert a host byte order `u128` to an IPv6 address.
     #[inline]
@@ -2234,7 +2234,7 @@ impl const From<u128> for Ipv6Addr {
 }
 
 #[stable(feature = "ipv6_from_octets", since = "1.9.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl const From<[u8; 16]> for Ipv6Addr {
     /// Creates an `Ipv6Addr` from a sixteen element byte array.
     ///
@@ -2262,7 +2262,7 @@ impl const From<[u8; 16]> for Ipv6Addr {
 }
 
 #[stable(feature = "ipv6_from_segments", since = "1.16.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl const From<[u16; 8]> for Ipv6Addr {
     /// Creates an `Ipv6Addr` from an eight element 16-bit array.
     ///
@@ -2291,7 +2291,7 @@ impl const From<[u16; 8]> for Ipv6Addr {
 }
 
 #[stable(feature = "ip_from_slice", since = "1.17.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl const From<[u8; 16]> for IpAddr {
     /// Creates an `IpAddr::V6` from a sixteen element byte array.
     ///
@@ -2319,7 +2319,7 @@ impl const From<[u8; 16]> for IpAddr {
 }
 
 #[stable(feature = "ip_from_slice", since = "1.17.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl const From<[u16; 8]> for IpAddr {
     /// Creates an `IpAddr::V6` from an eight element 16-bit array.
     ///
diff --git a/library/core/src/net/socket_addr.rs b/library/core/src/net/socket_addr.rs
index df99e9b20c2ea..ccc53c156d3a1 100644
--- a/library/core/src/net/socket_addr.rs
+++ b/library/core/src/net/socket_addr.rs
@@ -592,7 +592,7 @@ impl SocketAddrV6 {
 }
 
 #[stable(feature = "ip_from_ip", since = "1.16.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl const From<SocketAddrV4> for SocketAddr {
     /// Converts a [`SocketAddrV4`] into a [`SocketAddr::V4`].
     #[inline]
@@ -602,7 +602,7 @@ impl const From<SocketAddrV4> for SocketAddr {
 }
 
 #[stable(feature = "ip_from_ip", since = "1.16.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl const From<SocketAddrV6> for SocketAddr {
     /// Converts a [`SocketAddrV6`] into a [`SocketAddr::V6`].
     #[inline]
@@ -612,7 +612,7 @@ impl const From<SocketAddrV6> for SocketAddr {
 }
 
 #[stable(feature = "addr_from_into_ip", since = "1.17.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl<I: [const] Into<IpAddr>> const From<(I, u16)> for SocketAddr {
     /// Converts a tuple struct (Into<[`IpAddr`]>, `u16`) into a [`SocketAddr`].
     ///
diff --git a/library/core/src/num/error.rs b/library/core/src/num/error.rs
index faa52329827c1..8a353dc0fbe99 100644
--- a/library/core/src/num/error.rs
+++ b/library/core/src/num/error.rs
@@ -20,7 +20,7 @@ impl fmt::Display for TryFromIntError {
 impl Error for TryFromIntError {}
 
 #[stable(feature = "try_from", since = "1.34.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl const From<Infallible> for TryFromIntError {
     fn from(x: Infallible) -> TryFromIntError {
         match x {}
@@ -28,7 +28,7 @@ impl const From<Infallible> for TryFromIntError {
 }
 
 #[unstable(feature = "never_type", issue = "35121")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl const From<!> for TryFromIntError {
     #[inline]
     fn from(never: !) -> TryFromIntError {
diff --git a/library/core/src/num/mod.rs b/library/core/src/num/mod.rs
index acfe38b7a37b5..69c6a7dbd8976 100644
--- a/library/core/src/num/mod.rs
+++ b/library/core/src/num/mod.rs
@@ -1378,7 +1378,7 @@ const fn from_ascii_radix_panic(radix: u32) -> ! {
 macro_rules! from_str_int_impl {
     ($signedness:ident $($int_ty:ty)+) => {$(
         #[stable(feature = "rust1", since = "1.0.0")]
-        #[rustc_const_unstable(feature = "const_try", issue = "74935")]
+        #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
         impl const FromStr for $int_ty {
             type Err = ParseIntError;
 
diff --git a/library/core/src/num/nonzero.rs b/library/core/src/num/nonzero.rs
index e02d9260a1690..0f38081c355d1 100644
--- a/library/core/src/num/nonzero.rs
+++ b/library/core/src/num/nonzero.rs
@@ -297,7 +297,7 @@ where
 }
 
 #[stable(feature = "from_nonzero", since = "1.31.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl<T> const From<NonZero<T>> for T
 where
     T: ZeroablePrimitive,
diff --git a/library/core/src/ops/deref.rs b/library/core/src/ops/deref.rs
index 5f68c1f55c254..877b83d3a6116 100644
--- a/library/core/src/ops/deref.rs
+++ b/library/core/src/ops/deref.rs
@@ -136,7 +136,7 @@ use crate::marker::PointeeSized;
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_diagnostic_item = "Deref"]
 #[const_trait]
-#[rustc_const_unstable(feature = "const_deref", issue = "88955")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 pub trait Deref: PointeeSized {
     /// The resulting type after dereferencing.
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -152,7 +152,7 @@ pub trait Deref: PointeeSized {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_deref", issue = "88955")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl<T: ?Sized> const Deref for &T {
     type Target = T;
 
@@ -166,7 +166,7 @@ impl<T: ?Sized> const Deref for &T {
 impl<T: ?Sized> !DerefMut for &T {}
 
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_deref", issue = "88955")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl<T: ?Sized> const Deref for &mut T {
     type Target = T;
 
@@ -268,7 +268,7 @@ impl<T: ?Sized> const Deref for &mut T {
 #[doc(alias = "*")]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[const_trait]
-#[rustc_const_unstable(feature = "const_deref", issue = "88955")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 pub trait DerefMut: [const] Deref + PointeeSized {
     /// Mutably dereferences the value.
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -277,7 +277,7 @@ pub trait DerefMut: [const] Deref + PointeeSized {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_deref", issue = "88955")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl<T: ?Sized> const DerefMut for &mut T {
     fn deref_mut(&mut self) -> &mut T {
         self
diff --git a/library/core/src/option.rs b/library/core/src/option.rs
index fa09409b6daab..2a57536500ad0 100644
--- a/library/core/src/option.rs
+++ b/library/core/src/option.rs
@@ -1379,11 +1379,12 @@ impl<T> Option<T> {
     /// ```
     #[inline]
     #[stable(feature = "option_deref", since = "1.40.0")]
-    pub fn as_deref(&self) -> Option<&T::Target>
+    #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+    pub const fn as_deref(&self) -> Option<&T::Target>
     where
-        T: Deref,
+        T: [const] Deref,
     {
-        self.as_ref().map(|t| t.deref())
+        self.as_ref().map(Deref::deref)
     }
 
     /// Converts from `Option<T>` (or `&mut Option<T>`) to `Option<&mut T::Target>`.
@@ -1402,11 +1403,12 @@ impl<T> Option<T> {
     /// ```
     #[inline]
     #[stable(feature = "option_deref", since = "1.40.0")]
-    pub fn as_deref_mut(&mut self) -> Option<&mut T::Target>
+    #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+    pub const fn as_deref_mut(&mut self) -> Option<&mut T::Target>
     where
-        T: DerefMut,
+        T: [const] DerefMut,
     {
-        self.as_mut().map(|t| t.deref_mut())
+        self.as_mut().map(DerefMut::deref_mut)
     }
 
     /////////////////////////////////////////////////////////////////////////
@@ -2180,7 +2182,7 @@ const fn expect_failed(msg: &str) -> ! {
 /////////////////////////////////////////////////////////////////////////////
 
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_clone", issue = "142757")]
 impl<T> const Clone for Option<T>
 where
     // FIXME(const_hack): the T: ~const Destruct should be inferred from the Self: ~const Destruct in clone_from.
@@ -2269,7 +2271,7 @@ impl<'a, T> IntoIterator for &'a mut Option<T> {
 }
 
 #[stable(since = "1.12.0", feature = "option_from")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl<T> const From<T> for Option<T> {
     /// Moves `val` into a new [`Some`].
     ///
@@ -2286,7 +2288,7 @@ impl<T> const From<T> for Option<T> {
 }
 
 #[stable(feature = "option_ref_from_ref_option", since = "1.30.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl<'a, T> const From<&'a Option<T>> for Option<&'a T> {
     /// Converts from `&Option<T>` to `Option<&T>`.
     ///
@@ -2314,7 +2316,7 @@ impl<'a, T> const From<&'a Option<T>> for Option<&'a T> {
 }
 
 #[stable(feature = "option_ref_from_ref_option", since = "1.30.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl<'a, T> const From<&'a mut Option<T>> for Option<&'a mut T> {
     /// Converts from `&mut Option<T>` to `Option<&mut T>`
     ///
diff --git a/library/core/src/panic/unwind_safe.rs b/library/core/src/panic/unwind_safe.rs
index a60f0799c0eae..722af55103839 100644
--- a/library/core/src/panic/unwind_safe.rs
+++ b/library/core/src/panic/unwind_safe.rs
@@ -248,7 +248,8 @@ impl RefUnwindSafe for crate::sync::atomic::AtomicBool {}
 impl<T> RefUnwindSafe for crate::sync::atomic::AtomicPtr<T> {}
 
 #[stable(feature = "catch_unwind", since = "1.9.0")]
-impl<T> Deref for AssertUnwindSafe<T> {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T> const Deref for AssertUnwindSafe<T> {
     type Target = T;
 
     fn deref(&self) -> &T {
@@ -257,7 +258,8 @@ impl<T> Deref for AssertUnwindSafe<T> {
 }
 
 #[stable(feature = "catch_unwind", since = "1.9.0")]
-impl<T> DerefMut for AssertUnwindSafe<T> {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T> const DerefMut for AssertUnwindSafe<T> {
     fn deref_mut(&mut self) -> &mut T {
         &mut self.0
     }
diff --git a/library/core/src/pin.rs b/library/core/src/pin.rs
index 14bf7ba90150e..535830f2e749f 100644
--- a/library/core/src/pin.rs
+++ b/library/core/src/pin.rs
@@ -1359,7 +1359,11 @@ impl<Ptr: Deref> Pin<Ptr> {
     /// 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> {
+    #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+    pub const fn as_ref(&self) -> Pin<&Ptr::Target>
+    where
+        Ptr: [const] Deref,
+    {
         // SAFETY: see documentation on this function
         unsafe { Pin::new_unchecked(&*self.pointer) }
     }
@@ -1403,7 +1407,11 @@ impl<Ptr: DerefMut> Pin<Ptr> {
     /// ```
     #[stable(feature = "pin", since = "1.33.0")]
     #[inline(always)]
-    pub fn as_mut(&mut self) -> Pin<&mut Ptr::Target> {
+    #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+    pub const fn as_mut(&mut self) -> Pin<&mut Ptr::Target>
+    where
+        Ptr: [const] DerefMut,
+    {
         // SAFETY: see documentation on this function
         unsafe { Pin::new_unchecked(&mut *self.pointer) }
     }
@@ -1418,7 +1426,11 @@ impl<Ptr: DerefMut> Pin<Ptr> {
     #[stable(feature = "pin_deref_mut", since = "1.84.0")]
     #[must_use = "`self` will be dropped if the result is not used"]
     #[inline(always)]
-    pub fn as_deref_mut(self: Pin<&mut Self>) -> Pin<&mut Ptr::Target> {
+    #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+    pub const fn as_deref_mut(self: Pin<&mut Self>) -> Pin<&mut Ptr::Target>
+    where
+        Ptr: [const] DerefMut,
+    {
         // SAFETY: What we're asserting here is that going from
         //
         //     Pin<&mut Pin<Ptr>>
@@ -1669,7 +1681,8 @@ impl<T: ?Sized> Pin<&'static mut T> {
 }
 
 #[stable(feature = "pin", since = "1.33.0")]
-impl<Ptr: Deref> Deref for Pin<Ptr> {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<Ptr: [const] Deref> const Deref for Pin<Ptr> {
     type Target = Ptr::Target;
     fn deref(&self) -> &Ptr::Target {
         Pin::get_ref(Pin::as_ref(self))
@@ -1677,7 +1690,8 @@ impl<Ptr: Deref> Deref for Pin<Ptr> {
 }
 
 #[stable(feature = "pin", since = "1.33.0")]
-impl<Ptr: DerefMut<Target: Unpin>> DerefMut for Pin<Ptr> {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<Ptr: [const] DerefMut<Target: Unpin>> const DerefMut for Pin<Ptr> {
     fn deref_mut(&mut self) -> &mut Ptr::Target {
         Pin::get_mut(Pin::as_mut(self))
     }
diff --git a/library/core/src/pin/unsafe_pinned.rs b/library/core/src/pin/unsafe_pinned.rs
index ede6e0d6106bd..ae03809b4581f 100644
--- a/library/core/src/pin/unsafe_pinned.rs
+++ b/library/core/src/pin/unsafe_pinned.rs
@@ -148,7 +148,8 @@ impl<T: Default> Default for UnsafePinned<T> {
 }
 
 #[unstable(feature = "unsafe_pinned", issue = "125735")]
-impl<T> From<T> for UnsafePinned<T> {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T> const From<T> for UnsafePinned<T> {
     /// Creates a new `UnsafePinned<T>` containing the given value.
     fn from(value: T) -> Self {
         UnsafePinned::new(value)
diff --git a/library/core/src/ptr/alignment.rs b/library/core/src/ptr/alignment.rs
index 402634e49b37e..bc7d3a1de7151 100644
--- a/library/core/src/ptr/alignment.rs
+++ b/library/core/src/ptr/alignment.rs
@@ -171,7 +171,8 @@ impl fmt::Debug for Alignment {
 }
 
 #[unstable(feature = "ptr_alignment_type", issue = "102070")]
-impl TryFrom<NonZero<usize>> for Alignment {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl const TryFrom<NonZero<usize>> for Alignment {
     type Error = num::TryFromIntError;
 
     #[inline]
@@ -181,7 +182,8 @@ impl TryFrom<NonZero<usize>> for Alignment {
 }
 
 #[unstable(feature = "ptr_alignment_type", issue = "102070")]
-impl TryFrom<usize> for Alignment {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl const TryFrom<usize> for Alignment {
     type Error = num::TryFromIntError;
 
     #[inline]
@@ -191,7 +193,7 @@ impl TryFrom<usize> for Alignment {
 }
 
 #[unstable(feature = "ptr_alignment_type", issue = "102070")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl const From<Alignment> for NonZero<usize> {
     #[inline]
     fn from(align: Alignment) -> NonZero<usize> {
@@ -200,7 +202,7 @@ impl const From<Alignment> for NonZero<usize> {
 }
 
 #[unstable(feature = "ptr_alignment_type", issue = "102070")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl const From<Alignment> for usize {
     #[inline]
     fn from(align: Alignment) -> usize {
diff --git a/library/core/src/ptr/non_null.rs b/library/core/src/ptr/non_null.rs
index 117eb18826e49..10f83120428b9 100644
--- a/library/core/src/ptr/non_null.rs
+++ b/library/core/src/ptr/non_null.rs
@@ -1711,7 +1711,8 @@ impl<T: PointeeSized> hash::Hash for NonNull<T> {
 }
 
 #[unstable(feature = "ptr_internals", issue = "none")]
-impl<T: PointeeSized> From<Unique<T>> for NonNull<T> {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T: PointeeSized> const From<Unique<T>> for NonNull<T> {
     #[inline]
     fn from(unique: Unique<T>) -> Self {
         unique.as_non_null_ptr()
@@ -1719,7 +1720,8 @@ impl<T: PointeeSized> From<Unique<T>> for NonNull<T> {
 }
 
 #[stable(feature = "nonnull", since = "1.25.0")]
-impl<T: PointeeSized> From<&mut T> for NonNull<T> {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T: PointeeSized> const From<&mut T> for NonNull<T> {
     /// Converts a `&mut T` to a `NonNull<T>`.
     ///
     /// This conversion is safe and infallible since references cannot be null.
@@ -1730,7 +1732,8 @@ impl<T: PointeeSized> From<&mut T> for NonNull<T> {
 }
 
 #[stable(feature = "nonnull", since = "1.25.0")]
-impl<T: PointeeSized> From<&T> for NonNull<T> {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T: PointeeSized> const From<&T> for NonNull<T> {
     /// Converts a `&T` to a `NonNull<T>`.
     ///
     /// This conversion is safe and infallible since references cannot be null.
diff --git a/library/core/src/ptr/unique.rs b/library/core/src/ptr/unique.rs
index 4302c1b1e4451..cdc8b6cc936df 100644
--- a/library/core/src/ptr/unique.rs
+++ b/library/core/src/ptr/unique.rs
@@ -189,7 +189,8 @@ impl<T: PointeeSized> fmt::Pointer for Unique<T> {
 }
 
 #[unstable(feature = "ptr_internals", issue = "none")]
-impl<T: PointeeSized> From<&mut T> for Unique<T> {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T: PointeeSized> const From<&mut T> for Unique<T> {
     /// Converts a `&mut T` to a `Unique<T>`.
     ///
     /// This conversion is infallible since references cannot be null.
@@ -200,7 +201,8 @@ impl<T: PointeeSized> From<&mut T> for Unique<T> {
 }
 
 #[unstable(feature = "ptr_internals", issue = "none")]
-impl<T: PointeeSized> From<NonNull<T>> for Unique<T> {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T: PointeeSized> const From<NonNull<T>> for Unique<T> {
     /// Converts a `NonNull<T>` to a `Unique<T>`.
     ///
     /// This conversion is infallible since `NonNull` cannot be null.
diff --git a/library/core/src/range.rs b/library/core/src/range.rs
index 7158fa0fcf069..332ae51d8484e 100644
--- a/library/core/src/range.rs
+++ b/library/core/src/range.rs
@@ -192,7 +192,7 @@ impl<T> IntoBounds<T> for Range<T> {
 }
 
 #[unstable(feature = "new_range_api", issue = "125687")]
-#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl<T> const From<Range<T>> for legacy::Range<T> {
     #[inline]
     fn from(value: Range<T>) -> Self {
@@ -201,7 +201,7 @@ impl<T> const From<Range<T>> for legacy::Range<T> {
 }
 
 #[unstable(feature = "new_range_api", issue = "125687")]
-#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl<T> const From<legacy::Range<T>> for Range<T> {
     #[inline]
     fn from(value: legacy::Range<T>) -> Self {
@@ -377,7 +377,7 @@ impl<T> IntoBounds<T> for RangeInclusive<T> {
 }
 
 #[unstable(feature = "new_range_api", issue = "125687")]
-#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl<T> const From<RangeInclusive<T>> for legacy::RangeInclusive<T> {
     #[inline]
     fn from(value: RangeInclusive<T>) -> Self {
@@ -385,7 +385,8 @@ impl<T> const From<RangeInclusive<T>> for legacy::RangeInclusive<T> {
     }
 }
 #[unstable(feature = "new_range_api", issue = "125687")]
-impl<T> From<legacy::RangeInclusive<T>> for RangeInclusive<T> {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T> const From<legacy::RangeInclusive<T>> for RangeInclusive<T> {
     #[inline]
     fn from(value: legacy::RangeInclusive<T>) -> Self {
         assert!(
diff --git a/library/core/src/result.rs b/library/core/src/result.rs
index 6148bdb866ad0..7dffab9b316f6 100644
--- a/library/core/src/result.rs
+++ b/library/core/src/result.rs
@@ -1034,11 +1034,12 @@ impl<T, E> Result<T, E> {
     /// ```
     #[inline]
     #[stable(feature = "inner_deref", since = "1.47.0")]
-    pub fn as_deref(&self) -> Result<&T::Target, &E>
+    #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+    pub const fn as_deref(&self) -> Result<&T::Target, &E>
     where
-        T: Deref,
+        T: [const] Deref,
     {
-        self.as_ref().map(|t| t.deref())
+        self.as_ref().map(Deref::deref)
     }
 
     /// Converts from `Result<T, E>` (or `&mut Result<T, E>`) to `Result<&mut <T as DerefMut>::Target, &mut E>`.
@@ -1061,11 +1062,12 @@ impl<T, E> Result<T, E> {
     /// ```
     #[inline]
     #[stable(feature = "inner_deref", since = "1.47.0")]
-    pub fn as_deref_mut(&mut self) -> Result<&mut T::Target, &mut E>
+    #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+    pub const fn as_deref_mut(&mut self) -> Result<&mut T::Target, &mut E>
     where
-        T: DerefMut,
+        T: [const] DerefMut,
     {
-        self.as_mut().map(|t| t.deref_mut())
+        self.as_mut().map(DerefMut::deref_mut)
     }
 
     /////////////////////////////////////////////////////////////////////////
@@ -1347,7 +1349,7 @@ impl<T, E> Result<T, E> {
     #[unstable(feature = "unwrap_infallible", reason = "newly added", issue = "61695")]
     #[inline]
     #[rustc_allow_const_fn_unstable(const_precise_live_drops)]
-    #[rustc_const_unstable(feature = "const_try", issue = "74935")]
+    #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
     pub const fn into_ok(self) -> T
     where
         E: [const] Into<!>,
@@ -1384,7 +1386,7 @@ impl<T, E> Result<T, E> {
     #[unstable(feature = "unwrap_infallible", reason = "newly added", issue = "61695")]
     #[inline]
     #[rustc_allow_const_fn_unstable(const_precise_live_drops)]
-    #[rustc_const_unstable(feature = "const_try", issue = "74935")]
+    #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
     pub const fn into_err(self) -> E
     where
         T: [const] Into<!>,
diff --git a/library/core/src/str/mod.rs b/library/core/src/str/mod.rs
index 1a055a0a5adc8..005793a6635a4 100644
--- a/library/core/src/str/mod.rs
+++ b/library/core/src/str/mod.rs
@@ -3078,7 +3078,8 @@ impl str {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl AsRef<[u8]> for str {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl const AsRef<[u8]> for str {
     #[inline]
     fn as_ref(&self) -> &[u8] {
         self.as_bytes()
diff --git a/library/core/src/str/traits.rs b/library/core/src/str/traits.rs
index dc88f35eca7ea..971c8e829c648 100644
--- a/library/core/src/str/traits.rs
+++ b/library/core/src/str/traits.rs
@@ -826,7 +826,7 @@ unsafe impl const SliceIndex<str> for ops::RangeToInclusive<usize> {
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
 #[const_trait]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 pub trait FromStr: Sized {
     /// The associated error which can be returned from parsing.
     #[stable(feature = "rust1", since = "1.0.0")]
diff --git a/library/core/src/sync/atomic.rs b/library/core/src/sync/atomic.rs
index 44a6895f90ac6..d4d72c111707b 100644
--- a/library/core/src/sync/atomic.rs
+++ b/library/core/src/sync/atomic.rs
@@ -2523,7 +2523,7 @@ impl<T> AtomicPtr<T> {
 
 #[cfg(target_has_atomic_load_store = "8")]
 #[stable(feature = "atomic_bool_from", since = "1.24.0")]
-#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl const From<bool> for AtomicBool {
     /// Converts a `bool` into an `AtomicBool`.
     ///
@@ -2542,7 +2542,8 @@ impl const From<bool> for AtomicBool {
 
 #[cfg(target_has_atomic_load_store = "ptr")]
 #[stable(feature = "atomic_from", since = "1.23.0")]
-impl<T> From<*mut T> for AtomicPtr<T> {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T> const From<*mut T> for AtomicPtr<T> {
     /// Converts a `*mut T` into an `AtomicPtr<T>`.
     #[inline]
     fn from(p: *mut T) -> Self {
@@ -2621,7 +2622,7 @@ macro_rules! atomic_int {
         }
 
         #[$stable_from]
-        #[rustc_const_unstable(feature = "const_try", issue = "74935")]
+        #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
         impl const From<$int_type> for $atomic_type {
             #[doc = concat!("Converts an `", stringify!($int_type), "` into an `", stringify!($atomic_type), "`.")]
             #[inline]
diff --git a/library/core/src/sync/exclusive.rs b/library/core/src/sync/exclusive.rs
index 340b0b79e40a3..cf086bf4f5080 100644
--- a/library/core/src/sync/exclusive.rs
+++ b/library/core/src/sync/exclusive.rs
@@ -163,7 +163,8 @@ impl<T: ?Sized> Exclusive<T> {
 }
 
 #[unstable(feature = "exclusive_wrapper", issue = "98407")]
-impl<T> From<T> for Exclusive<T> {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T> const From<T> for Exclusive<T> {
     #[inline]
     fn from(t: T) -> Self {
         Self::new(t)
diff --git a/library/core/src/task/poll.rs b/library/core/src/task/poll.rs
index 59ffe7ad49c05..380abac0ae95f 100644
--- a/library/core/src/task/poll.rs
+++ b/library/core/src/task/poll.rs
@@ -215,7 +215,8 @@ impl<T, E> Poll<Option<Result<T, E>>> {
 }
 
 #[stable(feature = "futures_api", since = "1.36.0")]
-impl<T> From<T> for Poll<T> {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl<T> const From<T> for Poll<T> {
     /// Moves the value into a [`Poll::Ready`] to make a `Poll<T>`.
     ///
     /// # Example
diff --git a/library/core/src/task/wake.rs b/library/core/src/task/wake.rs
index bb7efe582f7a3..97eb9ec7dc5b0 100644
--- a/library/core/src/task/wake.rs
+++ b/library/core/src/task/wake.rs
@@ -901,7 +901,8 @@ impl Clone for LocalWaker {
 }
 
 #[unstable(feature = "local_waker", issue = "118959")]
-impl AsRef<LocalWaker> for Waker {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl const AsRef<LocalWaker> for Waker {
     fn as_ref(&self) -> &LocalWaker {
         // SAFETY: LocalWaker is just Waker without thread safety
         unsafe { transmute(self) }
diff --git a/library/core/src/tuple.rs b/library/core/src/tuple.rs
index 23a0a6877df77..2cdee1803a9a2 100644
--- a/library/core/src/tuple.rs
+++ b/library/core/src/tuple.rs
@@ -133,6 +133,7 @@ macro_rules! tuple_impls {
         maybe_tuple_doc! {
             $($T)+ @
             #[stable(feature = "array_tuple_conv", since = "1.71.0")]
+            // can't do const From due to https://github.com/rust-lang/rust/issues/144280
             impl<T> From<[T; ${count($T)}]> for ($(${ignore($T)} T,)+) {
                 #[inline]
                 #[allow(non_snake_case)]
@@ -146,6 +147,7 @@ macro_rules! tuple_impls {
         maybe_tuple_doc! {
             $($T)+ @
             #[stable(feature = "array_tuple_conv", since = "1.71.0")]
+            // can't do const From due to https://github.com/rust-lang/rust/issues/144280
             impl<T> From<($(${ignore($T)} T,)+)> for [T; ${count($T)}] {
                 #[inline]
                 #[allow(non_snake_case)]
diff --git a/library/coretests/tests/lib.rs b/library/coretests/tests/lib.rs
index b9b768f29d788..8e197e33ba647 100644
--- a/library/coretests/tests/lib.rs
+++ b/library/coretests/tests/lib.rs
@@ -15,10 +15,9 @@
 #![feature(cfg_target_has_reliable_f16_f128)]
 #![feature(char_max_len)]
 #![feature(clone_to_uninit)]
-#![feature(const_deref)]
+#![feature(const_convert)]
 #![feature(const_destruct)]
 #![feature(const_eval_select)]
-#![feature(const_from)]
 #![feature(const_ops)]
 #![feature(const_option_ops)]
 #![feature(const_ref_cell)]
diff --git a/library/std/src/ffi/os_str.rs b/library/std/src/ffi/os_str.rs
index 1214490caadf3..a39565d215924 100644
--- a/library/std/src/ffi/os_str.rs
+++ b/library/std/src/ffi/os_str.rs
@@ -828,7 +828,8 @@ impl OsStr {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn new<S: AsRef<OsStr> + ?Sized>(s: &S) -> &OsStr {
+    #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+    pub const fn new<S: [const] AsRef<OsStr> + ?Sized>(s: &S) -> &OsStr {
         s.as_ref()
     }
 
@@ -876,14 +877,16 @@ impl OsStr {
     }
 
     #[inline]
-    fn from_inner(inner: &Slice) -> &OsStr {
+    #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+    const fn from_inner(inner: &Slice) -> &OsStr {
         // SAFETY: OsStr is just a wrapper of Slice,
         // therefore converting &Slice to &OsStr is safe.
         unsafe { &*(inner as *const Slice as *const OsStr) }
     }
 
     #[inline]
-    fn from_inner_mut(inner: &mut Slice) -> &mut OsStr {
+    #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+    const fn from_inner_mut(inner: &mut Slice) -> &mut OsStr {
         // SAFETY: OsStr is just a wrapper of Slice,
         // therefore converting &mut Slice to &mut OsStr is safe.
         // Any method that mutates OsStr must be careful not to
@@ -1681,7 +1684,8 @@ impl ToOwned for OsStr {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl AsRef<OsStr> for OsStr {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl const AsRef<OsStr> for OsStr {
     #[inline]
     fn as_ref(&self) -> &OsStr {
         self
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index 30a1b10881784..a2f7701a5b390 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -334,6 +334,7 @@
 #![feature(char_internals)]
 #![feature(clone_to_uninit)]
 #![feature(const_cmp)]
+#![feature(const_convert)]
 #![feature(const_ops)]
 #![feature(const_option_ops)]
 #![feature(const_try)]
diff --git a/library/std/src/path.rs b/library/std/src/path.rs
index 470d300d2d95b..5ccea1c972c16 100644
--- a/library/std/src/path.rs
+++ b/library/std/src/path.rs
@@ -2264,11 +2264,13 @@ impl Path {
     /// assert_eq!(from_string, from_path);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn new<S: AsRef<OsStr> + ?Sized>(s: &S) -> &Path {
+    #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+    pub const fn new<S: [const] AsRef<OsStr> + ?Sized>(s: &S) -> &Path {
         unsafe { &*(s.as_ref() as *const OsStr as *const Path) }
     }
 
-    fn from_inner_mut(inner: &mut OsStr) -> &mut Path {
+    #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+    const fn from_inner_mut(inner: &mut OsStr) -> &mut Path {
         // SAFETY: Path is just a wrapper around OsStr,
         // therefore converting &mut OsStr to &mut Path is safe.
         unsafe { &mut *(inner as *mut OsStr as *mut Path) }
@@ -3337,7 +3339,8 @@ unsafe impl CloneToUninit for Path {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl AsRef<OsStr> for Path {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl const AsRef<OsStr> for Path {
     #[inline]
     fn as_ref(&self) -> &OsStr {
         &self.inner
@@ -3507,7 +3510,8 @@ impl Ord for Path {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl AsRef<Path> for Path {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl const AsRef<Path> for Path {
     #[inline]
     fn as_ref(&self) -> &Path {
         self
@@ -3515,7 +3519,8 @@ impl AsRef<Path> for Path {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl AsRef<Path> for OsStr {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+impl const AsRef<Path> for OsStr {
     #[inline]
     fn as_ref(&self) -> &Path {
         Path::new(self)
diff --git a/tests/ui/traits/const-traits/enforce-deref-on-adjust.rs b/tests/ui/traits/const-traits/enforce-deref-on-adjust.rs
index d5240b7e18ddb..cba207f095309 100644
--- a/tests/ui/traits/const-traits/enforce-deref-on-adjust.rs
+++ b/tests/ui/traits/const-traits/enforce-deref-on-adjust.rs
@@ -1,6 +1,6 @@
 //@ check-pass
 
-#![feature(const_deref)]
+#![feature(const_convert)]
 #![feature(const_trait_impl)]
 
 use std::ops::Deref;
diff --git a/tests/ui/traits/const-traits/non-const-op-in-closure-in-const.rs b/tests/ui/traits/const-traits/non-const-op-in-closure-in-const.rs
index d5f80acc15b54..50c985096d127 100644
--- a/tests/ui/traits/const-traits/non-const-op-in-closure-in-const.rs
+++ b/tests/ui/traits/const-traits/non-const-op-in-closure-in-const.rs
@@ -1,4 +1,4 @@
-#![feature(const_trait_impl, const_from)]
+#![feature(const_trait_impl, const_convert)]
 
 //@ check-pass
 
diff --git a/tests/ui/traits/const-traits/reservation-impl-ice.rs b/tests/ui/traits/const-traits/reservation-impl-ice.rs
index efaea1cc6b2bf..7fefb4ec54399 100644
--- a/tests/ui/traits/const-traits/reservation-impl-ice.rs
+++ b/tests/ui/traits/const-traits/reservation-impl-ice.rs
@@ -1,5 +1,5 @@
 //@ compile-flags: -Znext-solver
-#![feature(const_from, never_type, const_trait_impl)]
+#![feature(const_convert, never_type, const_trait_impl)]
 
 const fn impls_from<T: ~const From<!>>() {}
 

From b2962c367a7f38a8d6fb372ae4744f77f9079619 Mon Sep 17 00:00:00 2001
From: Ed Page <eopage@gmail.com>
Date: Thu, 28 Aug 2025 16:09:54 -0500
Subject: [PATCH 0394/1889] test(lexer): Ensure frontmatter w/ crlf works

---
 tests/ui/.gitattributes                  |  1 +
 tests/ui/frontmatter/frontmatter-crlf.rs | 14 ++++++++++++++
 2 files changed, 15 insertions(+)
 create mode 100644 tests/ui/frontmatter/frontmatter-crlf.rs

diff --git a/tests/ui/.gitattributes b/tests/ui/.gitattributes
index 9ea3d3fb0e1f1..4923ac100e172 100644
--- a/tests/ui/.gitattributes
+++ b/tests/ui/.gitattributes
@@ -3,4 +3,5 @@ json-bom-plus-crlf.rs -text
 json-bom-plus-crlf-multifile.rs -text
 json-bom-plus-crlf-multifile-aux.rs -text
 trailing-carriage-return-in-string.rs -text
+frontmatter-crlf.rs -text
 *.bin -text
diff --git a/tests/ui/frontmatter/frontmatter-crlf.rs b/tests/ui/frontmatter/frontmatter-crlf.rs
new file mode 100644
index 0000000000000..b46cc9ddbb0e0
--- /dev/null
+++ b/tests/ui/frontmatter/frontmatter-crlf.rs
@@ -0,0 +1,14 @@
+#!/usr/bin/env -S cargo -Zscript
+---
+[dependencies]
+clap = "4"
+---
+
+//@ check-pass
+// ignore-tidy-cr
+
+// crlf line endings should be accepted
+
+#![feature(frontmatter)]
+
+fn main() {}

From 159be09c4f70b109cc859a55beeb4150b8e452e6 Mon Sep 17 00:00:00 2001
From: Ed Page <eopage@gmail.com>
Date: Fri, 29 Aug 2025 13:30:48 -0500
Subject: [PATCH 0395/1889] test(lexer): Ensure frontmatter can contain unicode
 whitespace

---
 .../frontmatter-contains-whitespace.rs        | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 tests/ui/frontmatter/frontmatter-contains-whitespace.rs

diff --git a/tests/ui/frontmatter/frontmatter-contains-whitespace.rs b/tests/ui/frontmatter/frontmatter-contains-whitespace.rs
new file mode 100644
index 0000000000000..11df822f793cf
--- /dev/null
+++ b/tests/ui/frontmatter/frontmatter-contains-whitespace.rs
@@ -0,0 +1,22 @@
+#!/usr/bin/env -S cargo -Zscript
+---cargo
+# Beware editing: it has numerous whitespace characters which are important.
+# It contains one ranges from the 'PATTERN_WHITE_SPACE' property outlined in
+# https://unicode.org/Public/UNIDATA/PropList.txt
+#
+# The characters in the first expression of the assertion can be generated
+# from: "4\u{0C}+\n\t\r7\t*\u{20}2\u{85}/\u{200E}3\u{200F}*\u{2028}2\u{2029}"
+package.description = """
+4+
+
+7   * 2…/‎3‏*
2
+"""
+---
+
+//@ check-pass
+
+// Ensure the frontmatter can contain any whitespace
+
+#![feature(frontmatter)]
+
+fn main() {}

From 9304aa19366a51aea23a516ea44e45bc4a3e84e7 Mon Sep 17 00:00:00 2001
From: Ed Page <eopage@gmail.com>
Date: Fri, 29 Aug 2025 13:47:22 -0500
Subject: [PATCH 0396/1889] test(lexer): Ensure tabs are accepted for
 horizontal whitespace

---
 tests/ui/frontmatter/frontmatter-whitespace-3.rs | 5 +++--
 tests/ui/frontmatter/frontmatter-whitespace-4.rs | 3 ++-
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/tests/ui/frontmatter/frontmatter-whitespace-3.rs b/tests/ui/frontmatter/frontmatter-whitespace-3.rs
index 95e0981e2ae8b..6580514fba2d2 100644
--- a/tests/ui/frontmatter/frontmatter-whitespace-3.rs
+++ b/tests/ui/frontmatter/frontmatter-whitespace-3.rs
@@ -1,7 +1,7 @@
 
 
----cargo   
----   
+---cargo   	
+---   	
 
 // please note the whitespace characters after the first four lines.
 // This ensures that we accept whitespaces before the frontmatter, after
@@ -10,6 +10,7 @@
 //@ check-pass
 // ignore-tidy-end-whitespace
 // ignore-tidy-leading-newlines
+// ignore-tidy-tab
 
 #![feature(frontmatter)]
 
diff --git a/tests/ui/frontmatter/frontmatter-whitespace-4.rs b/tests/ui/frontmatter/frontmatter-whitespace-4.rs
index 3bda3227838c7..1e7c5556647b0 100644
--- a/tests/ui/frontmatter/frontmatter-whitespace-4.rs
+++ b/tests/ui/frontmatter/frontmatter-whitespace-4.rs
@@ -1,7 +1,8 @@
---- cargo
+--- 	cargo
 ---
 
 //@ check-pass
+// ignore-tidy-tab
 // A frontmatter infostring can have leading whitespace.
 
 #![feature(frontmatter)]

From 428e413414e0719a7758676ac49e07b85eb86dec Mon Sep 17 00:00:00 2001
From: Ed Page <eopage@gmail.com>
Date: Thu, 28 Aug 2025 14:18:42 -0500
Subject: [PATCH 0397/1889] docs(lexer): Organize and document whitespace by
 Pattern_White_Space

---
 compiler/rustc_lexer/src/lib.rs | 22 ++++++++++------------
 1 file changed, 10 insertions(+), 12 deletions(-)

diff --git a/compiler/rustc_lexer/src/lib.rs b/compiler/rustc_lexer/src/lib.rs
index d10b192034354..e347a76f6a2ae 100644
--- a/compiler/rustc_lexer/src/lib.rs
+++ b/compiler/rustc_lexer/src/lib.rs
@@ -331,24 +331,22 @@ pub fn is_whitespace(c: char) -> bool {
 
     matches!(
         c,
-        // Usual ASCII suspects
-        '\u{0009}'   // \t
-        | '\u{000A}' // \n
+        // End-of-line characters
+        | '\u{000A}' // line feed (\n)
         | '\u{000B}' // vertical tab
         | '\u{000C}' // form feed
-        | '\u{000D}' // \r
-        | '\u{0020}' // space
-
-        // NEXT LINE from latin1
-        | '\u{0085}'
+        | '\u{000D}' // carriage return (\r)
+        | '\u{0085}' // next line (from latin1)
+        | '\u{2028}' // LINE SEPARATOR
+        | '\u{2029}' // PARAGRAPH SEPARATOR
 
-        // Bidi markers
+        // `Default_Ignorable_Code_Point` characters
         | '\u{200E}' // LEFT-TO-RIGHT MARK
         | '\u{200F}' // RIGHT-TO-LEFT MARK
 
-        // Dedicated whitespace characters from Unicode
-        | '\u{2028}' // LINE SEPARATOR
-        | '\u{2029}' // PARAGRAPH SEPARATOR
+        // Horizontal space characters
+        | '\u{0009}'   // tab (\t)
+        | '\u{0020}' // space
     )
 }
 

From 6f0da976c5f422ff5b1124d409e7d7e063fc4225 Mon Sep 17 00:00:00 2001
From: Ed Page <eopage@gmail.com>
Date: Thu, 28 Aug 2025 15:15:41 -0500
Subject: [PATCH 0398/1889] fix(lexer): Only allow horizontal whitespace in
 frontmatter

In writing up the reference for frontmatter, I realized that we probably
shouldn't be accepting Unicode Line Ending characters between the code
fence and infostring or trailing after the infostring or a code fence.

In digging into the unicode specification we use for Whitespace, it
divides it up into categories, so I'm deferring to what it says for
horizontal whitespace for what should be used within a line.

Note, I am leaving out support for Unicde Default Ignorable characters.
I figure that can be discussed outside of this change within the
reference and tracking issue.
---
 compiler/rustc_lexer/src/lib.rs       | 21 ++++++++++++++++++---
 compiler/rustc_parse/src/lexer/mod.rs |  6 +++---
 2 files changed, 21 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_lexer/src/lib.rs b/compiler/rustc_lexer/src/lib.rs
index e347a76f6a2ae..c29ab569f4795 100644
--- a/compiler/rustc_lexer/src/lib.rs
+++ b/compiler/rustc_lexer/src/lib.rs
@@ -350,6 +350,21 @@ pub fn is_whitespace(c: char) -> bool {
     )
 }
 
+/// True if `c` is considered horizontal whitespace according to Rust language definition.
+pub fn is_horizontal_whitespace(c: char) -> bool {
+    // This is Pattern_White_Space.
+    //
+    // Note that this set is stable (ie, it doesn't change with different
+    // Unicode versions), so it's ok to just hard-code the values.
+
+    matches!(
+        c,
+        // Horizontal space characters
+        '\u{0009}'   // tab (\t)
+        | '\u{0020}' // space
+    )
+}
+
 /// True if `c` is valid as a first character of an identifier.
 /// See [Rust language reference](https://doc.rust-lang.org/reference/identifiers.html) for
 /// a formal definition of valid identifier name.
@@ -536,7 +551,7 @@ impl Cursor<'_> {
         debug_assert!(length_opening >= 3);
 
         // whitespace between the opening and the infostring.
-        self.eat_while(|ch| ch != '\n' && is_whitespace(ch));
+        self.eat_while(|ch| ch != '\n' && is_horizontal_whitespace(ch));
 
         // copied from `eat_identifier`, but allows `-` and `.` in infostring to allow something like
         // `---Cargo.toml` as a valid opener
@@ -545,7 +560,7 @@ impl Cursor<'_> {
             self.eat_while(|c| is_id_continue(c) || c == '-' || c == '.');
         }
 
-        self.eat_while(|ch| ch != '\n' && is_whitespace(ch));
+        self.eat_while(|ch| ch != '\n' && is_horizontal_whitespace(ch));
         let invalid_infostring = self.first() != '\n';
 
         let mut found = false;
@@ -586,7 +601,7 @@ impl Cursor<'_> {
                 // on a standalone line. Might be wrong.
                 while let Some(closing) = rest.find("---") {
                     let preceding_chars_start = rest[..closing].rfind("\n").map_or(0, |i| i + 1);
-                    if rest[preceding_chars_start..closing].chars().all(is_whitespace) {
+                    if rest[preceding_chars_start..closing].chars().all(is_horizontal_whitespace) {
                         // candidate found
                         potential_closing = Some(closing);
                         break;
diff --git a/compiler/rustc_parse/src/lexer/mod.rs b/compiler/rustc_parse/src/lexer/mod.rs
index 9792240a54850..e3bd6a9a3270f 100644
--- a/compiler/rustc_parse/src/lexer/mod.rs
+++ b/compiler/rustc_parse/src/lexer/mod.rs
@@ -6,7 +6,7 @@ use rustc_ast::util::unicode::{TEXT_FLOW_CONTROL_CHARS, contains_text_flow_contr
 use rustc_errors::codes::*;
 use rustc_errors::{Applicability, Diag, DiagCtxtHandle, StashKey};
 use rustc_lexer::{
-    Base, Cursor, DocStyle, FrontmatterAllowed, LiteralKind, RawStrError, is_whitespace,
+    Base, Cursor, DocStyle, FrontmatterAllowed, LiteralKind, RawStrError, is_horizontal_whitespace,
 };
 use rustc_literal_escaper::{EscapeError, Mode, check_for_errors};
 use rustc_session::lint::BuiltinLintDiag;
@@ -597,7 +597,7 @@ impl<'psess, 'src> Lexer<'psess, 'src> {
 
         let last_line_start = within.rfind('\n').map_or(0, |i| i + 1);
         let last_line = &within[last_line_start..];
-        let last_line_trimmed = last_line.trim_start_matches(is_whitespace);
+        let last_line_trimmed = last_line.trim_start_matches(is_horizontal_whitespace);
         let last_line_start_pos = frontmatter_opening_end_pos + BytePos(last_line_start as u32);
 
         let frontmatter_span = self.mk_sp(frontmatter_opening_pos, self.pos);
@@ -640,7 +640,7 @@ impl<'psess, 'src> Lexer<'psess, 'src> {
             });
         }
 
-        if !rest.trim_matches(is_whitespace).is_empty() {
+        if !rest.trim_matches(is_horizontal_whitespace).is_empty() {
             let span = self.mk_sp(last_line_start_pos, self.pos);
             self.dcx().emit_err(errors::FrontmatterExtraCharactersAfterClose { span });
         }

From 768dcbecdd17dfb0b4e406c047f380058cff27f5 Mon Sep 17 00:00:00 2001
From: beepster4096 <19316085+beepster4096@users.noreply.github.com>
Date: Thu, 28 Aug 2025 17:41:48 -0700
Subject: [PATCH 0399/1889] add rust.break-on-ice to bootstrap.toml

---
 bootstrap.example.toml                     | 3 +++
 src/bootstrap/src/core/builder/cargo.rs    | 7 +++++--
 src/bootstrap/src/core/config/config.rs    | 3 +++
 src/bootstrap/src/core/config/toml/rust.rs | 2 ++
 src/bootstrap/src/utils/change_tracker.rs  | 5 +++++
 5 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/bootstrap.example.toml b/bootstrap.example.toml
index 16fd9241a172a..eac9395779798 100644
--- a/bootstrap.example.toml
+++ b/bootstrap.example.toml
@@ -856,6 +856,9 @@
 # as libstd features, this option can also be used to configure features such as optimize_for_size.
 #rust.std-features = ["panic_unwind"]
 
+# Trigger a `DebugBreak` after an internal compiler error during bootstrap on Windows
+#rust.break-on-ice = true
+
 # =============================================================================
 # Distribution options
 #
diff --git a/src/bootstrap/src/core/builder/cargo.rs b/src/bootstrap/src/core/builder/cargo.rs
index cdf6fe573e583..c4c23d90ef05c 100644
--- a/src/bootstrap/src/core/builder/cargo.rs
+++ b/src/bootstrap/src/core/builder/cargo.rs
@@ -877,8 +877,11 @@ impl Builder<'_> {
             .env("RUSTC_LIBDIR", libdir)
             .env("RUSTDOC", self.bootstrap_out.join("rustdoc"))
             .env("RUSTDOC_REAL", rustdoc_path)
-            .env("RUSTC_ERROR_METADATA_DST", self.extended_error_dir())
-            .env("RUSTC_BREAK_ON_ICE", "1");
+            .env("RUSTC_ERROR_METADATA_DST", self.extended_error_dir());
+
+        if self.config.rust_break_on_ice {
+            cargo.env("RUSTC_BREAK_ON_ICE", "1");
+        }
 
         // Set RUSTC_WRAPPER to the bootstrap shim, which switches between beta and in-tree
         // sysroot depending on whether we're building build scripts.
diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index d12cc962187f9..678a9b6395228 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -221,6 +221,7 @@ pub struct Config {
     pub rust_lto: RustcLto,
     pub rust_validate_mir_opts: Option<u32>,
     pub rust_std_features: BTreeSet<String>,
+    pub rust_break_on_ice: bool,
     pub llvm_profile_use: Option<String>,
     pub llvm_profile_generate: bool,
     pub llvm_libunwind_default: Option<LlvmLibunwind>,
@@ -550,6 +551,7 @@ impl Config {
             strip: rust_strip,
             lld_mode: rust_lld_mode,
             std_features: rust_std_features,
+            break_on_ice: rust_break_on_ice,
         } = toml.rust.unwrap_or_default();
 
         let Llvm {
@@ -1269,6 +1271,7 @@ impl Config {
             reproducible_artifacts: flags_reproducible_artifact,
             reuse: build_reuse.map(PathBuf::from),
             rust_analyzer_info,
+            rust_break_on_ice: rust_break_on_ice.unwrap_or(true),
             rust_codegen_backends: rust_codegen_backends
                 .map(|backends| parse_codegen_backends(backends, "rust"))
                 .unwrap_or(vec![CodegenBackendKind::Llvm]),
diff --git a/src/bootstrap/src/core/config/toml/rust.rs b/src/bootstrap/src/core/config/toml/rust.rs
index c54df456d52b0..4832a1d37b777 100644
--- a/src/bootstrap/src/core/config/toml/rust.rs
+++ b/src/bootstrap/src/core/config/toml/rust.rs
@@ -65,6 +65,7 @@ define_config! {
         lto: Option<String> = "lto",
         validate_mir_opts: Option<u32> = "validate-mir-opts",
         std_features: Option<BTreeSet<String>> = "std-features",
+        break_on_ice: Option<bool> = "break-on-ice",
     }
 }
 
@@ -355,6 +356,7 @@ pub fn check_incompatible_options_for_ci_rustc(
         download_rustc: _,
         validate_mir_opts: _,
         frame_pointers: _,
+        break_on_ice: _,
     } = ci_rust_config;
 
     // There are two kinds of checks for CI rustc incompatible options:
diff --git a/src/bootstrap/src/utils/change_tracker.rs b/src/bootstrap/src/utils/change_tracker.rs
index 2cc2fb486fad5..01309072927d0 100644
--- a/src/bootstrap/src/utils/change_tracker.rs
+++ b/src/bootstrap/src/utils/change_tracker.rs
@@ -536,4 +536,9 @@ pub const CONFIG_CHANGE_HISTORY: &[ChangeInfo] = &[
         severity: ChangeSeverity::Warning,
         summary: "It is no longer possible to `x test` with stage 0, except for running compiletest and opting into `build.compiletest-allow-stage0`.",
     },
+    ChangeInfo {
+        change_id: 145976,
+        severity: ChangeSeverity::Info,
+        summary: "Added a new option `rust.break-on-ice` to control if internal compiler errors cause a debug break on Windows.",
+    },
 ];

From a324fe956981f4ad736ffc268f222037fd853e83 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Tue, 2 Sep 2025 06:39:32 +0300
Subject: [PATCH 0400/1889] Make sense of the mess that were (are) different
 kind of generics in the solver

To the extent possible.

Previously they were confused. Sometimes generic params were treated as `Param` and sometimes as `Placeholder`. A completely redundant (in the new solver) mapping of salsa::Id to ints to intern some info where we could just store it uninterned (not in Chalk though, for some weird reason).

Plus fix a cute bug in closure substitution that was caught by the assertions of Chalk but the next solver did not have such assertions. Do we need more assertions?
---
 .../crates/hir-ty/src/chalk_ext.rs            |   2 +-
 .../crates/hir-ty/src/consteval.rs            |  29 ++-
 .../crates/hir-ty/src/consteval_nextsolver.rs |   2 +-
 .../rust-analyzer/crates/hir-ty/src/db.rs     |   6 +-
 .../crates/hir-ty/src/display.rs              |  46 ++---
 .../crates/hir-ty/src/dyn_compatibility.rs    |  20 +-
 .../crates/hir-ty/src/generics.rs             |   8 +-
 .../crates/hir-ty/src/infer/closure.rs        |   4 +-
 .../rust-analyzer/crates/hir-ty/src/layout.rs |  17 +-
 .../rust-analyzer/crates/hir-ty/src/lib.rs    |   4 +-
 .../rust-analyzer/crates/hir-ty/src/lower.rs  |  12 +-
 .../crates/hir-ty/src/lower/path.rs           |   8 +-
 .../crates/hir-ty/src/lower_nextsolver.rs     |  13 +-
 .../hir-ty/src/lower_nextsolver/path.rs       |   2 +
 .../crates/hir-ty/src/mapping.rs              |  36 +++-
 .../crates/hir-ty/src/mir/monomorphization.rs |   4 +-
 .../crates/hir-ty/src/next_solver/consts.rs   |   3 +
 .../hir-ty/src/next_solver/generic_arg.rs     |  38 ++--
 .../crates/hir-ty/src/next_solver/generics.rs |  63 +++---
 .../hir-ty/src/next_solver/infer/mod.rs       |  13 +-
 .../crates/hir-ty/src/next_solver/mapping.rs  | 191 ++++++++++--------
 .../crates/hir-ty/src/next_solver/region.rs   |   3 +
 .../crates/hir-ty/src/next_solver/ty.rs       |  12 +-
 .../crates/hir-ty/src/variance.rs             |   4 +-
 .../rust-analyzer/crates/hir/src/display.rs   |  11 +-
 src/tools/rust-analyzer/crates/hir/src/lib.rs |   6 +-
 26 files changed, 324 insertions(+), 233 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/chalk_ext.rs b/src/tools/rust-analyzer/crates/hir-ty/src/chalk_ext.rs
index 8fa1aff0ef636..33ae099c690ea 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/chalk_ext.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/chalk_ext.rs
@@ -306,7 +306,7 @@ impl TyExt for Ty {
                 predicates.map(|it| it.into_value_and_skipped_binders().0)
             }
             TyKind::Placeholder(idx) => {
-                let id = from_placeholder_idx(db, *idx);
+                let id = from_placeholder_idx(db, *idx).0;
                 let generic_params = db.generic_params(id.parent);
                 let param_data = &generic_params[id.local_id];
                 match param_data {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
index abf97f3d0e302..0f2cc17f563dd 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
@@ -107,25 +107,24 @@ pub(crate) fn path_to_const<'g>(
     match resolver.resolve_path_in_value_ns_fully(db, path, HygieneId::ROOT) {
         Some(ValueNs::GenericParam(p)) => {
             let ty = db.const_param_ty(p);
+            let args = args();
             let value = match mode {
                 ParamLoweringMode::Placeholder => {
-                    ConstValue::Placeholder(to_placeholder_idx(db, p.into()))
+                    let idx = args.type_or_const_param_idx(p.into()).unwrap();
+                    ConstValue::Placeholder(to_placeholder_idx(db, p.into(), idx as u32))
                 }
-                ParamLoweringMode::Variable => {
-                    let args = args();
-                    match args.type_or_const_param_idx(p.into()) {
-                        Some(it) => ConstValue::BoundVar(BoundVar::new(debruijn, it)),
-                        None => {
-                            never!(
-                                "Generic list doesn't contain this param: {:?}, {:?}, {:?}",
-                                args,
-                                path,
-                                p
-                            );
-                            return None;
-                        }
+                ParamLoweringMode::Variable => match args.type_or_const_param_idx(p.into()) {
+                    Some(it) => ConstValue::BoundVar(BoundVar::new(debruijn, it)),
+                    None => {
+                        never!(
+                            "Generic list doesn't contain this param: {:?}, {:?}, {:?}",
+                            args,
+                            path,
+                            p
+                        );
+                        return None;
                     }
-                }
+                },
             };
             Some(ConstData { ty, value }.intern(Interner))
         }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs
index 00fc4e5610dce..4f95c9a13acdb 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs
@@ -49,7 +49,7 @@ pub(crate) fn path_to_const<'a, 'g>(
                 .and_then(|(idx, p)| p.const_param().map(|p| (idx, p.clone())))
             {
                 Some((idx, _param)) => {
-                    Some(Const::new_param(interner, ParamConst { index: idx as u32 }))
+                    Some(Const::new_param(interner, ParamConst { index: idx as u32, id: p }))
                 }
                 None => {
                     never!(
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
index 97754f47233b2..0b7213d785c91 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
@@ -410,13 +410,15 @@ fn hir_database_is_dyn_compatible() {
 #[salsa_macros::interned(no_lifetime, debug, revisions = usize::MAX)]
 #[derive(PartialOrd, Ord)]
 pub struct InternedTypeOrConstParamId {
-    pub loc: TypeOrConstParamId,
+    /// This stores the param and its index.
+    pub loc: (TypeOrConstParamId, u32),
 }
 
 #[salsa_macros::interned(no_lifetime, debug, revisions = usize::MAX)]
 #[derive(PartialOrd, Ord)]
 pub struct InternedLifetimeParamId {
-    pub loc: LifetimeParamId,
+    /// This stores the param and its index.
+    pub loc: (LifetimeParamId, u32),
 }
 
 #[salsa_macros::interned(no_lifetime, debug, revisions = usize::MAX)]
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 0df727a8e5c04..5b8093f6b7246 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
@@ -61,9 +61,8 @@ use crate::{
     next_solver::{
         BoundExistentialPredicate, Ctor, DbInterner, GenericArgs, SolverDefId,
         mapping::{
-            ChalkToNextSolver, bound_var_to_lifetime_idx, bound_var_to_type_or_const_param_idx,
-            convert_args_for_result, convert_const_for_result, convert_region_for_result,
-            convert_ty_for_result,
+            ChalkToNextSolver, convert_args_for_result, convert_const_for_result,
+            convert_region_for_result, convert_ty_for_result,
         },
     },
     primitive, to_assoc_type_id,
@@ -641,7 +640,7 @@ impl HirDisplay for ProjectionTy {
             && !f.bounds_formatting_ctx.contains(self)
         {
             let db = f.db;
-            let id = from_placeholder_idx(db, *idx);
+            let id = from_placeholder_idx(db, *idx).0;
             let generics = generics(db, id.parent);
 
             let substs = generics.placeholder_subst(db);
@@ -736,14 +735,14 @@ impl HirDisplay for Const {
 impl<'db> HirDisplay for crate::next_solver::Const<'db> {
     fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
         match self.kind() {
+            rustc_type_ir::ConstKind::Placeholder(_) => write!(f, "<placeholder>"),
             rustc_type_ir::ConstKind::Bound(db, bound_const) => {
                 write!(f, "?{}.{}", db.as_u32(), bound_const.as_u32())
             }
             rustc_type_ir::ConstKind::Infer(..) => write!(f, "#c#"),
-            rustc_type_ir::ConstKind::Placeholder(idx) => {
-                let id = bound_var_to_type_or_const_param_idx(f.db, idx.bound);
-                let generics = generics(f.db, id.parent);
-                let param_data = &generics[id.local_id];
+            rustc_type_ir::ConstKind::Param(param) => {
+                let generics = generics(f.db, param.id.parent());
+                let param_data = &generics[param.id.local_id()];
                 write!(f, "{}", param_data.name().unwrap().display(f.db, f.edition()))?;
                 Ok(())
             }
@@ -765,7 +764,6 @@ impl<'db> HirDisplay for crate::next_solver::Const<'db> {
             }
             rustc_type_ir::ConstKind::Error(..) => f.write_char('_'),
             rustc_type_ir::ConstKind::Expr(..) => write!(f, "<const-expr>"),
-            rustc_type_ir::ConstKind::Param(_) => write!(f, "<param>"),
         }
     }
 }
@@ -1178,7 +1176,7 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                 if let TyKind::Ref(l, _, _) = kind {
                     f.write_char('&')?;
                     if f.render_region(l) {
-                        convert_region_for_result(l).hir_fmt(f)?;
+                        convert_region_for_result(interner, l).hir_fmt(f)?;
                         f.write_char(' ')?;
                     }
                     match m {
@@ -1611,14 +1609,10 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                     write!(f, "{{closure}}")?;
                 }
             }
-            TyKind::Placeholder(idx) => {
-                let placeholder_index = chalk_ir::PlaceholderIndex {
-                    idx: idx.bound.var.as_usize(),
-                    ui: chalk_ir::UniverseIndex { counter: idx.universe.as_usize() },
-                };
-                let id = from_placeholder_idx(db, placeholder_index);
-                let generics = generics(db, id.parent);
-                let param_data = &generics[id.local_id];
+            TyKind::Placeholder(_) => write!(f, "{{placeholder}}")?,
+            TyKind::Param(param) => {
+                let generics = generics(db, param.id.parent());
+                let param_data = &generics[param.id.local_id()];
                 match param_data {
                     TypeOrConstParamData::TypeParamData(p) => match p.provenance {
                         TypeParamProvenance::TypeParamList | TypeParamProvenance::TraitSelf => {
@@ -1634,7 +1628,7 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                         TypeParamProvenance::ArgumentImplTrait => {
                             let substs = generics.placeholder_subst(db);
                             let bounds = db
-                                .generic_predicates(id.parent)
+                                .generic_predicates(param.id.parent())
                                 .iter()
                                 .map(|pred| pred.clone().substitute(Interner, &substs))
                                 .filter(|wc| match wc.skip_binders() {
@@ -1656,7 +1650,7 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                                     WhereClause::LifetimeOutlives(_) => false,
                                 })
                                 .collect::<Vec<_>>();
-                            let krate = id.parent.module(db).krate();
+                            let krate = param.id.parent().module(db).krate();
                             write_bounds_like_dyn_trait_with_prefix(
                                 f,
                                 "impl",
@@ -1671,7 +1665,6 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                     }
                 }
             }
-            TyKind::Param(_) => write!(f, "{{param}}")?,
             TyKind::Bound(debruijn_index, ty) => {
                 let idx = chalk_ir::BoundVar {
                     debruijn: chalk_ir::DebruijnIndex::new(debruijn_index.as_u32()),
@@ -2294,7 +2287,7 @@ impl HirDisplay for LifetimeData {
     fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
         match self {
             LifetimeData::Placeholder(idx) => {
-                let id = lt_from_placeholder_idx(f.db, *idx);
+                let id = lt_from_placeholder_idx(f.db, *idx).0;
                 let generics = generics(f.db, id.parent);
                 let param_data = &generics[id.local_id];
                 write!(f, "{}", param_data.name.display(f.db, f.edition()))?;
@@ -2319,10 +2312,9 @@ impl HirDisplay for LifetimeData {
 impl<'db> HirDisplay for crate::next_solver::Region<'db> {
     fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
         match self.kind() {
-            rustc_type_ir::RegionKind::RePlaceholder(idx) => {
-                let id = bound_var_to_lifetime_idx(f.db, idx.bound.var);
-                let generics = generics(f.db, id.parent);
-                let param_data = &generics[id.local_id];
+            rustc_type_ir::RegionKind::ReEarlyParam(param) => {
+                let generics = generics(f.db, param.id.parent);
+                let param_data = &generics[param.id.local_id];
                 write!(f, "{}", param_data.name.display(f.db, f.edition()))?;
                 Ok(())
             }
@@ -2339,7 +2331,7 @@ impl<'db> HirDisplay for crate::next_solver::Region<'db> {
                 }
             }
             rustc_type_ir::RegionKind::ReErased => write!(f, "'<erased>"),
-            rustc_type_ir::RegionKind::ReEarlyParam(_) => write!(f, "<param>"),
+            rustc_type_ir::RegionKind::RePlaceholder(_) => write!(f, "<placeholder>"),
             rustc_type_ir::RegionKind::ReLateParam(_) => write!(f, "<late-param>"),
         }
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
index b0c61c29db0b5..23280b1f3b42b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
@@ -2,10 +2,12 @@
 
 use std::ops::ControlFlow;
 
+use hir_def::hir::generics::LocalTypeOrConstParamId;
 use hir_def::{
     AssocItemId, ConstId, CrateRootModuleId, FunctionId, GenericDefId, HasModule, TraitId,
     TypeAliasId, lang_item::LangItem, signatures::TraitFlags,
 };
+use hir_def::{TypeOrConstParamId, TypeParamId};
 use intern::Symbol;
 use rustc_hash::FxHashSet;
 use rustc_type_ir::{
@@ -384,7 +386,6 @@ where
         }
 
         // Allow `impl AutoTrait` predicates
-        let interner = DbInterner::new_with(db, Some(trait_.krate(db)), None);
         if let ClauseKind::Trait(TraitPredicate {
             trait_ref: pred_trait_ref,
             polarity: PredicatePolarity::Positive,
@@ -392,11 +393,8 @@ where
             && let SolverDefId::TraitId(trait_id) = pred_trait_ref.def_id
             && let trait_data = db.trait_signature(trait_id)
             && trait_data.flags.contains(TraitFlags::AUTO)
-            && pred_trait_ref.self_ty()
-                == crate::next_solver::Ty::new(
-                    interner,
-                    rustc_type_ir::TyKind::Param(crate::next_solver::ParamTy { index: 0 }),
-                )
+            && let rustc_type_ir::TyKind::Param(crate::next_solver::ParamTy { index: 0, .. }) =
+                pred_trait_ref.self_ty().kind()
         {
             continue;
         }
@@ -422,9 +420,13 @@ fn receiver_is_dispatchable<'db>(
     let sig = sig.instantiate_identity();
 
     let interner: DbInterner<'_> = DbInterner::new_with(db, Some(trait_.krate(db)), None);
+    let self_param_id = TypeParamId::from_unchecked(TypeOrConstParamId {
+        parent: trait_.into(),
+        local_id: LocalTypeOrConstParamId::from_raw(la_arena::RawIdx::from_u32(0)),
+    });
     let self_param_ty = crate::next_solver::Ty::new(
         interner,
-        rustc_type_ir::TyKind::Param(crate::next_solver::ParamTy { index: 0 }),
+        rustc_type_ir::TyKind::Param(crate::next_solver::ParamTy { index: 0, id: self_param_id }),
     );
 
     // `self: Self` can't be dispatched on, but this is already considered dyn-compatible
@@ -452,7 +454,9 @@ fn receiver_is_dispatchable<'db>(
     };
 
     // Type `U`
-    let unsized_self_ty = crate::next_solver::Ty::new_param(interner, u32::MAX, Symbol::empty());
+    // FIXME: That seems problematic to fake a generic param like that?
+    let unsized_self_ty =
+        crate::next_solver::Ty::new_param(interner, self_param_id, u32::MAX, Symbol::empty());
     // `Receiver[Self => U]`
     let unsized_receiver_ty = receiver_for_self_ty(interner, func, receiver_ty, unsized_self_ty);
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/generics.rs b/src/tools/rust-analyzer/crates/hir-ty/src/generics.rs
index 412b3ac425028..e179e41b1cbe2 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/generics.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/generics.rs
@@ -256,15 +256,15 @@ impl Generics {
     pub fn placeholder_subst(&self, db: &dyn HirDatabase) -> Substitution {
         Substitution::from_iter(
             Interner,
-            self.iter_id().map(|id| match id {
+            self.iter_id().enumerate().map(|(index, id)| match id {
                 GenericParamId::TypeParamId(id) => {
-                    to_placeholder_idx(db, id.into()).to_ty(Interner).cast(Interner)
+                    to_placeholder_idx(db, id.into(), index as u32).to_ty(Interner).cast(Interner)
                 }
-                GenericParamId::ConstParamId(id) => to_placeholder_idx(db, id.into())
+                GenericParamId::ConstParamId(id) => to_placeholder_idx(db, id.into(), index as u32)
                     .to_const(Interner, db.const_param_ty(id))
                     .cast(Interner),
                 GenericParamId::LifetimeParamId(id) => {
-                    lt_to_placeholder_idx(db, id).to_lifetime(Interner).cast(Interner)
+                    lt_to_placeholder_idx(db, id, index as u32).to_lifetime(Interner).cast(Interner)
                 }
             }),
         )
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
index 38ac2e1170773..9ef046afdb3d3 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
@@ -866,7 +866,7 @@ impl CapturedItemWithoutTy {
                     idx: chalk_ir::PlaceholderIndex,
                     outer_binder: DebruijnIndex,
                 ) -> Result<chalk_ir::Const<Interner>, Self::Error> {
-                    let x = from_placeholder_idx(self.db, idx);
+                    let x = from_placeholder_idx(self.db, idx).0;
                     let Some(idx) = self.generics.type_or_const_param_idx(x) else {
                         return Err(());
                     };
@@ -878,7 +878,7 @@ impl CapturedItemWithoutTy {
                     idx: chalk_ir::PlaceholderIndex,
                     outer_binder: DebruijnIndex,
                 ) -> std::result::Result<Ty, Self::Error> {
-                    let x = from_placeholder_idx(self.db, idx);
+                    let x = from_placeholder_idx(self.db, idx).0;
                     let Some(idx) = self.generics.type_or_const_param_idx(x) else {
                         return Err(());
                     };
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
index e2ee8935a8855..f8abb3b7f6fef 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
@@ -19,14 +19,15 @@ use rustc_type_ir::{
 };
 use triomphe::Arc;
 
+use crate::utils::ClosureSubst;
 use crate::{
-    TraitEnvironment,
+    Interner, TraitEnvironment,
     consteval_nextsolver::try_const_usize,
     db::HirDatabase,
     next_solver::{
         DbInterner, GenericArgs, ParamEnv, SolverDefId, Ty, TyKind, TypingMode,
         infer::{DbInternerInferExt, traits::ObligationCause},
-        mapping::{ChalkToNextSolver, convert_binder_to_early_binder},
+        mapping::{ChalkToNextSolver, convert_args_for_result},
         project::solve_normalize::deeply_normalize,
     },
 };
@@ -333,9 +334,15 @@ pub fn layout_of_ty_query<'db>(
             let fields = captures
                 .iter()
                 .map(|it| {
-                    let ty =
-                        convert_binder_to_early_binder(interner, it.ty.to_nextsolver(interner))
-                            .instantiate(interner, args);
+                    let ty = it
+                        .ty
+                        .clone()
+                        .substitute(
+                            Interner,
+                            ClosureSubst(&convert_args_for_result(interner, args.inner()))
+                                .parent_subst(),
+                        )
+                        .to_nextsolver(interner);
                     db.layout_of_ty(ty, trait_env.clone())
                 })
                 .collect::<Result<Vec<_>, _>>()?;
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 7fdfb205721ec..c16bbb7b99221 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
@@ -124,7 +124,7 @@ pub use lower_nextsolver::associated_type_shorthand_candidates;
 pub use mapping::{
     ToChalk, from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id, from_placeholder_idx,
     lt_from_placeholder_idx, lt_to_placeholder_idx, to_assoc_type_id, to_chalk_trait_id,
-    to_foreign_def_id, to_placeholder_idx,
+    to_foreign_def_id, to_placeholder_idx, to_placeholder_idx_no_index,
 };
 pub use method_resolution::check_orphan_rules;
 pub use target_feature::TargetFeatures;
@@ -1007,7 +1007,7 @@ struct PlaceholderCollector<'db> {
 
 impl PlaceholderCollector<'_> {
     fn collect(&mut self, idx: PlaceholderIndex) {
-        let id = from_placeholder_idx(self.db, idx);
+        let id = from_placeholder_idx(self.db, idx).0;
         self.placeholders.insert(id);
     }
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
index 098c62ba97a29..79f78c545e595 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
@@ -340,7 +340,13 @@ impl<'a> TyLoweringContext<'a> {
                 res = Some(TypeNs::GenericParam(type_param_id));
                 match self.type_param_mode {
                     ParamLoweringMode::Placeholder => {
-                        TyKind::Placeholder(to_placeholder_idx(self.db, type_param_id.into()))
+                        let generics = self.generics();
+                        let idx = generics.type_or_const_param_idx(type_param_id.into()).unwrap();
+                        TyKind::Placeholder(to_placeholder_idx(
+                            self.db,
+                            type_param_id.into(),
+                            idx as u32,
+                        ))
                     }
                     ParamLoweringMode::Variable => {
                         let idx =
@@ -777,7 +783,9 @@ impl<'a> TyLoweringContext<'a> {
                 LifetimeNs::Static => static_lifetime(),
                 LifetimeNs::LifetimeParam(id) => match self.type_param_mode {
                     ParamLoweringMode::Placeholder => {
-                        LifetimeData::Placeholder(lt_to_placeholder_idx(self.db, id))
+                        let generics = self.generics();
+                        let idx = generics.lifetime_idx(id).unwrap();
+                        LifetimeData::Placeholder(lt_to_placeholder_idx(self.db, id, idx as u32))
                     }
                     ParamLoweringMode::Variable => {
                         let idx = match self.generics().lifetime_idx(id) {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs
index fb85909d7f41e..b0132e4dcbc46 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs
@@ -222,7 +222,13 @@ impl<'a, 'b> PathLoweringContext<'a, 'b> {
             }
             TypeNs::GenericParam(param_id) => match self.ctx.type_param_mode {
                 ParamLoweringMode::Placeholder => {
-                    TyKind::Placeholder(to_placeholder_idx(self.ctx.db, param_id.into()))
+                    let generics = self.ctx.generics();
+                    let idx = generics.type_or_const_param_idx(param_id.into()).unwrap();
+                    TyKind::Placeholder(to_placeholder_idx(
+                        self.ctx.db,
+                        param_id.into(),
+                        idx as u32,
+                    ))
                 }
                 ParamLoweringMode::Variable => {
                     let idx = match self.ctx.generics().type_or_const_param_idx(param_id.into()) {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
index d87181f545d88..4578922ce3219 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
@@ -64,8 +64,7 @@ use crate::{
         AdtDef, AliasTy, Binder, BoundExistentialPredicates, BoundRegionKind, BoundTyKind,
         BoundVarKind, BoundVarKinds, Clause, Clauses, Const, DbInterner, EarlyBinder,
         EarlyParamRegion, ErrorGuaranteed, GenericArgs, PolyFnSig, Predicate, Region, SolverDefId,
-        TraitPredicate, TraitRef, Ty, Tys, abi::Safety, generics::GenericParamDefKind,
-        mapping::ChalkToNextSolver,
+        TraitPredicate, TraitRef, Ty, Tys, abi::Safety, mapping::ChalkToNextSolver,
     },
 };
 
@@ -322,6 +321,7 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
                 };
                 Ty::new_param(
                     self.interner,
+                    type_param_id,
                     idx as u32,
                     type_data
                         .name
@@ -866,7 +866,10 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
                         None => return Region::error(self.interner),
                         Some(idx) => idx,
                     };
-                    Region::new_early_param(self.interner, EarlyParamRegion { index: idx as u32 })
+                    Region::new_early_param(
+                        self.interner,
+                        EarlyParamRegion { index: idx as u32, id },
+                    )
                 }
             },
             None => Region::error(self.interner),
@@ -1344,11 +1347,11 @@ where
                     {
                         continue;
                     }
-                    let GenericParamDefKind::Type = p.kind else {
+                    let GenericParamId::TypeParamId(param_id) = p.id else {
                         continue;
                     };
                     let idx = idx as u32 + generics.parent_count as u32;
-                    let param_ty = Ty::new_param(interner, idx, p.name.clone());
+                    let param_ty = Ty::new_param(interner, param_id, idx, p.name.clone());
                     if explicitly_unsized_tys.contains(&param_ty) {
                         continue;
                     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver/path.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver/path.rs
index e3efb38306408..ccdb5a0bdb4a9 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver/path.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver/path.rs
@@ -281,6 +281,7 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
                         };
                         Ty::new_param(
                             self.ctx.interner,
+                            param_id,
                             idx as u32,
                             p.name
                                 .as_ref()
@@ -758,6 +759,7 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
                     self.ctx.ctx.db.generic_defaults(def).get(preceding_args.len()).map(|default| {
                         convert_binder_to_early_binder(
                             self.ctx.ctx.interner,
+                            def,
                             default.to_nextsolver(self.ctx.ctx.interner),
                         )
                         .instantiate(self.ctx.ctx.interner, preceding_args)
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mapping.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mapping.rs
index 448fbdf673655..5125a38825cb8 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mapping.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mapping.rs
@@ -104,7 +104,10 @@ pub fn from_assoc_type_id(id: AssocTypeId) -> TypeAliasId {
     FromId::from_id(id.0)
 }
 
-pub fn from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> TypeOrConstParamId {
+pub fn from_placeholder_idx(
+    db: &dyn HirDatabase,
+    idx: PlaceholderIndex,
+) -> (TypeOrConstParamId, u32) {
     assert_eq!(idx.ui, chalk_ir::UniverseIndex::ROOT);
     // SAFETY: We cannot really encapsulate this unfortunately, so just hope this is sound.
     let interned_id =
@@ -112,15 +115,32 @@ pub fn from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> Type
     interned_id.loc(db)
 }
 
-pub fn to_placeholder_idx(db: &dyn HirDatabase, id: TypeOrConstParamId) -> PlaceholderIndex {
-    let interned_id = InternedTypeOrConstParamId::new(db, id);
+pub fn to_placeholder_idx(
+    db: &dyn HirDatabase,
+    id: TypeOrConstParamId,
+    idx: u32,
+) -> PlaceholderIndex {
+    let interned_id = InternedTypeOrConstParamId::new(db, (id, idx));
     PlaceholderIndex {
         ui: chalk_ir::UniverseIndex::ROOT,
         idx: interned_id.as_id().index() as usize,
     }
 }
 
-pub fn lt_from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> LifetimeParamId {
+pub fn to_placeholder_idx_no_index(
+    db: &dyn HirDatabase,
+    id: TypeOrConstParamId,
+) -> PlaceholderIndex {
+    let index = crate::generics::generics(db, id.parent)
+        .type_or_const_param_idx(id)
+        .expect("param not found");
+    to_placeholder_idx(db, id, index as u32)
+}
+
+pub fn lt_from_placeholder_idx(
+    db: &dyn HirDatabase,
+    idx: PlaceholderIndex,
+) -> (LifetimeParamId, u32) {
     assert_eq!(idx.ui, chalk_ir::UniverseIndex::ROOT);
     // SAFETY: We cannot really encapsulate this unfortunately, so just hope this is sound.
     let interned_id =
@@ -128,8 +148,12 @@ pub fn lt_from_placeholder_idx(db: &dyn HirDatabase, idx: PlaceholderIndex) -> L
     interned_id.loc(db)
 }
 
-pub fn lt_to_placeholder_idx(db: &dyn HirDatabase, id: LifetimeParamId) -> PlaceholderIndex {
-    let interned_id = InternedLifetimeParamId::new(db, id);
+pub fn lt_to_placeholder_idx(
+    db: &dyn HirDatabase,
+    id: LifetimeParamId,
+    idx: u32,
+) -> PlaceholderIndex {
+    let interned_id = InternedLifetimeParamId::new(db, (id, idx));
     PlaceholderIndex {
         ui: chalk_ir::UniverseIndex::ROOT,
         idx: interned_id.as_id().index() as usize,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/monomorphization.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/monomorphization.rs
index d8f443145ca06..b0b922316914b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/monomorphization.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/monomorphization.rs
@@ -99,7 +99,7 @@ impl FallibleTypeFolder<Interner> for Filler<'_> {
         idx: chalk_ir::PlaceholderIndex,
         _outer_binder: DebruijnIndex,
     ) -> std::result::Result<chalk_ir::Const<Interner>, Self::Error> {
-        let it = from_placeholder_idx(self.db, idx);
+        let it = from_placeholder_idx(self.db, idx).0;
         let Some(idx) = self.generics.as_ref().and_then(|g| g.type_or_const_param_idx(it)) else {
             not_supported!("missing idx in generics");
         };
@@ -117,7 +117,7 @@ impl FallibleTypeFolder<Interner> for Filler<'_> {
         idx: chalk_ir::PlaceholderIndex,
         _outer_binder: DebruijnIndex,
     ) -> std::result::Result<Ty, Self::Error> {
-        let it = from_placeholder_idx(self.db, idx);
+        let it = from_placeholder_idx(self.db, idx).0;
         let Some(idx) = self.generics.as_ref().and_then(|g| g.type_or_const_param_idx(it)) else {
             not_supported!("missing idx in generics");
         };
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs
index ce581cfad4b26..cfafc65d18443 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs
@@ -2,6 +2,7 @@
 
 use std::hash::Hash;
 
+use hir_def::{ConstParamId, TypeOrConstParamId};
 use intern::{Interned, Symbol};
 use rustc_ast_ir::try_visit;
 use rustc_ast_ir::visit::VisitorResult;
@@ -84,6 +85,8 @@ pub type PlaceholderConst = Placeholder<rustc_type_ir::BoundVar>;
 
 #[derive(Copy, Clone, Hash, Eq, PartialEq)]
 pub struct ParamConst {
+    // FIXME: See `ParamTy`.
+    pub id: ConstParamId,
     pub index: u32,
 }
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generic_arg.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generic_arg.rs
index 76186e374608e..d284eb9c6b419 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generic_arg.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generic_arg.rs
@@ -1,5 +1,6 @@
 //! Things related to generic args in the next-trait-solver.
 
+use hir_def::GenericParamId;
 use intern::{Interned, Symbol};
 use rustc_type_ir::{
     ClosureArgs, CollectAndApply, ConstVid, CoroutineArgs, CoroutineClosureArgs, FnSig, FnSigTys,
@@ -14,7 +15,7 @@ use crate::db::HirDatabase;
 
 use super::{
     Const, DbInterner, EarlyParamRegion, ErrorGuaranteed, ParamConst, Region, SolverDefId, Ty, Tys,
-    generics::{GenericParamDef, GenericParamDefKind, Generics},
+    generics::{GenericParamDef, Generics},
     interned_vec_db,
 };
 
@@ -203,7 +204,7 @@ impl<'db> GenericArgs<'db> {
         mut mk_kind: F,
     ) -> GenericArgs<'db>
     where
-        F: FnMut(&Symbol, u32, GenericParamDefKind, &[GenericArg<'db>]) -> GenericArg<'db>,
+        F: FnMut(&Symbol, u32, GenericParamId, &[GenericArg<'db>]) -> GenericArg<'db>,
     {
         let defs = interner.generics_of(def_id);
         let count = defs.count();
@@ -218,7 +219,7 @@ impl<'db> GenericArgs<'db> {
         defs: Generics,
         mk_kind: &mut F,
     ) where
-        F: FnMut(&Symbol, u32, GenericParamDefKind, &[GenericArg<'db>]) -> GenericArg<'db>,
+        F: FnMut(&Symbol, u32, GenericParamId, &[GenericArg<'db>]) -> GenericArg<'db>,
     {
         let self_len = defs.own_params.len() as u32;
         if let Some(def_id) = defs.parent {
@@ -230,12 +231,12 @@ impl<'db> GenericArgs<'db> {
 
     fn fill_single<F>(args: &mut SmallVec<[GenericArg<'db>; 8]>, defs: &Generics, mk_kind: &mut F)
     where
-        F: FnMut(&Symbol, u32, GenericParamDefKind, &[GenericArg<'db>]) -> GenericArg<'db>,
+        F: FnMut(&Symbol, u32, GenericParamId, &[GenericArg<'db>]) -> GenericArg<'db>,
     {
         let start_len = args.len();
         args.reserve(defs.own_params.len());
         for param in &defs.own_params {
-            let kind = mk_kind(&param.name, args.len() as u32, param.kind, args);
+            let kind = mk_kind(&param.name, args.len() as u32, param.id, args);
             args.push(kind);
         }
     }
@@ -412,26 +413,25 @@ pub fn mk_param<'db>(
     interner: DbInterner<'db>,
     index: u32,
     name: &Symbol,
-    kind: GenericParamDefKind,
+    id: GenericParamId,
 ) -> GenericArg<'db> {
     let name = name.clone();
-    match kind {
-        GenericParamDefKind::Lifetime => {
-            Region::new_early_param(interner, EarlyParamRegion { index }).into()
+    match id {
+        GenericParamId::LifetimeParamId(id) => {
+            Region::new_early_param(interner, EarlyParamRegion { index, id }).into()
+        }
+        GenericParamId::TypeParamId(id) => Ty::new_param(interner, id, index, name).into(),
+        GenericParamId::ConstParamId(id) => {
+            Const::new_param(interner, ParamConst { index, id }).into()
         }
-        GenericParamDefKind::Type => Ty::new_param(interner, index, name).into(),
-        GenericParamDefKind::Const => Const::new_param(interner, ParamConst { index }).into(),
     }
 }
 
-pub fn error_for_param_kind<'db>(
-    kind: GenericParamDefKind,
-    interner: DbInterner<'db>,
-) -> GenericArg<'db> {
-    match kind {
-        GenericParamDefKind::Lifetime => Region::error(interner).into(),
-        GenericParamDefKind::Type => Ty::new_error(interner, ErrorGuaranteed).into(),
-        GenericParamDefKind::Const => Const::error(interner).into(),
+pub fn error_for_param_kind<'db>(id: GenericParamId, interner: DbInterner<'db>) -> GenericArg<'db> {
+    match id {
+        GenericParamId::LifetimeParamId(_) => Region::error(interner).into(),
+        GenericParamId::TypeParamId(_) => Ty::new_error(interner, ErrorGuaranteed).into(),
+        GenericParamId::ConstParamId(_) => Const::error(interner).into(),
     }
 }
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generics.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generics.rs
index a3ba8eb83453e..5ec9a18a6c20e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generics.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generics.rs
@@ -24,35 +24,40 @@ use super::{Const, EarlyParamRegion, ErrorGuaranteed, ParamConst, Region, Solver
 use super::{DbInterner, GenericArg};
 
 pub(crate) fn generics(db: &dyn HirDatabase, def: SolverDefId) -> Generics {
-    let mk_lt = |index, lt: &LifetimeParamData| {
+    let mk_lt = |parent, index, local_id, lt: &LifetimeParamData| {
         let name = lt.name.symbol().clone();
-        let kind = GenericParamDefKind::Lifetime;
-        GenericParamDef { name, index, kind }
+        let id = GenericParamId::LifetimeParamId(LifetimeParamId { parent, local_id });
+        GenericParamDef { name, index, id }
     };
-    let mk_ty = |index, p: &TypeOrConstParamData| {
+    let mk_ty = |parent, index, local_id, p: &TypeOrConstParamData| {
         let name = p.name().map(|n| n.symbol().clone()).unwrap_or_else(|| sym::MISSING_NAME);
-        let kind = match p {
-            TypeOrConstParamData::TypeParamData(_) => GenericParamDefKind::Type,
-            TypeOrConstParamData::ConstParamData(_) => GenericParamDefKind::Const,
+        let id = TypeOrConstParamId { parent, local_id };
+        let id = match p {
+            TypeOrConstParamData::TypeParamData(_) => {
+                GenericParamId::TypeParamId(TypeParamId::from_unchecked(id))
+            }
+            TypeOrConstParamData::ConstParamData(_) => {
+                GenericParamId::ConstParamId(ConstParamId::from_unchecked(id))
+            }
         };
-        GenericParamDef { name, index, kind }
+        GenericParamDef { name, index, id }
     };
-    let own_params_for_generic_params = |params: &GenericParams| {
+    let own_params_for_generic_params = |parent, params: &GenericParams| {
         let mut result = Vec::with_capacity(params.len());
         let mut type_and_consts = params.iter_type_or_consts();
         let mut index = 0;
         if let Some(self_param) = params.trait_self_param() {
-            result.push(mk_ty(0, &params[self_param]));
+            result.push(mk_ty(parent, 0, self_param, &params[self_param]));
             type_and_consts.next();
             index += 1;
         }
-        result.extend(params.iter_lt().map(|(_, data)| {
-            let lt = mk_lt(index, data);
+        result.extend(params.iter_lt().map(|(local_id, data)| {
+            let lt = mk_lt(parent, index, local_id, data);
             index += 1;
             lt
         }));
-        result.extend(type_and_consts.map(|(_, data)| {
-            let ty = mk_ty(index, data);
+        result.extend(type_and_consts.map(|(local_id, data)| {
+            let ty = mk_ty(parent, index, local_id, data);
             index += 1;
             ty
         }));
@@ -60,9 +65,10 @@ pub(crate) fn generics(db: &dyn HirDatabase, def: SolverDefId) -> Generics {
     };
 
     let (parent, own_params) = match (def.try_into(), def) {
-        (Ok(def), _) => {
-            (parent_generic_def(db, def), own_params_for_generic_params(&db.generic_params(def)))
-        }
+        (Ok(def), _) => (
+            parent_generic_def(db, def),
+            own_params_for_generic_params(def, &db.generic_params(def)),
+        ),
         (_, SolverDefId::InternedOpaqueTyId(id)) => {
             match db.lookup_intern_impl_trait_id(id) {
                 crate::ImplTraitId::ReturnTypeImplTrait(function_id, _) => {
@@ -79,7 +85,19 @@ pub(crate) fn generics(db: &dyn HirDatabase, def: SolverDefId) -> Generics {
                         provenance: TypeParamProvenance::TypeParamList,
                     });
                     // Yes, there is a parent but we don't include it in the generics
-                    (None, vec![mk_ty(0, &param)])
+                    // FIXME: It seems utterly sensitive to fake a generic param here.
+                    // Also, what a horrible mess!
+                    (
+                        None,
+                        vec![mk_ty(
+                            GenericDefId::FunctionId(salsa::plumbing::FromId::from_id(unsafe {
+                                salsa::Id::from_index(salsa::Id::MAX_U32 - 1)
+                            })),
+                            0,
+                            LocalTypeOrConstParamId::from_raw(la_arena::RawIdx::from_u32(0)),
+                            &param,
+                        )],
+                    )
                 }
             }
         }
@@ -106,7 +124,7 @@ pub struct GenericParamDef {
     pub(crate) name: Symbol,
     //def_id: GenericDefId,
     index: u32,
-    pub(crate) kind: GenericParamDefKind,
+    pub(crate) id: GenericParamId,
 }
 
 impl GenericParamDef {
@@ -117,13 +135,6 @@ impl GenericParamDef {
     }
 }
 
-#[derive(Copy, Clone, Debug)]
-pub enum GenericParamDefKind {
-    Lifetime,
-    Type,
-    Const,
-}
-
 impl<'db> rustc_type_ir::inherent::GenericsOf<DbInterner<'db>> for Generics {
     fn count(&self) -> usize {
         self.parent_count + self.own_params.len()
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs
index 19ae76f7e358f..58832aef89529 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs
@@ -8,6 +8,7 @@ pub use BoundRegionConversionTime::*;
 pub use at::DefineOpaqueTypes;
 use ena::undo_log::UndoLogs;
 use ena::unify as ut;
+use hir_def::GenericParamId;
 use intern::Symbol;
 use opaque_types::{OpaqueHiddenType, OpaqueTypeStorage};
 use region_constraints::{
@@ -38,7 +39,7 @@ use crate::next_solver::fold::BoundVarReplacerDelegate;
 use crate::next_solver::infer::opaque_types::table::OpaqueTypeStorageEntries;
 use crate::next_solver::{BoundRegion, BoundTy, BoundVarKind};
 
-use super::generics::{GenericParamDef, GenericParamDefKind};
+use super::generics::GenericParamDef;
 use super::{
     AliasTerm, Binder, BoundRegionKind, CanonicalQueryInput, CanonicalVarValues, Const, ConstKind,
     DbInterner, ErrorGuaranteed, FxIndexMap, GenericArg, GenericArgs, OpaqueTypeKey, ParamEnv,
@@ -600,14 +601,14 @@ impl<'db> InferCtxt<'db> {
         self.next_region_var_in_universe(universe)
     }
 
-    fn var_for_def(&self, kind: GenericParamDefKind, name: &Symbol) -> GenericArg<'db> {
-        match kind {
-            GenericParamDefKind::Lifetime => {
+    fn var_for_def(&self, id: GenericParamId, name: &Symbol) -> GenericArg<'db> {
+        match id {
+            GenericParamId::LifetimeParamId(_) => {
                 // Create a region inference variable for the given
                 // region parameter definition.
                 self.next_region_var().into()
             }
-            GenericParamDefKind::Type => {
+            GenericParamId::TypeParamId(_) => {
                 // Create a type inference variable for the given
                 // type parameter definition. The generic parameters are
                 // for actual parameters that may be referred to by
@@ -624,7 +625,7 @@ impl<'db> InferCtxt<'db> {
 
                 Ty::new_var(self.interner, ty_var_id).into()
             }
-            GenericParamDefKind::Const => {
+            GenericParamId::ConstParamId(_) => {
                 let origin = ConstVariableOrigin { param_def_id: None };
                 let const_var_id = self
                     .inner
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
index 203f030dfd614..6755d065e10d3 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
@@ -9,6 +9,7 @@ use hir_def::{
     CallableDefId, ConstParamId, FunctionId, GeneralConstId, LifetimeParamId, TypeAliasId,
     TypeOrConstParamId, TypeParamId, signatures::TraitFlags,
 };
+use hir_def::{GenericDefId, GenericParamId};
 use intern::sym;
 use rustc_type_ir::{
     AliasTerm, BoundVar, DebruijnIndex, ExistentialProjection, ExistentialTraitRef, Interner as _,
@@ -35,6 +36,9 @@ use crate::{
     },
     to_assoc_type_id, to_chalk_trait_id, to_foreign_def_id,
 };
+use crate::{
+    from_placeholder_idx, lt_from_placeholder_idx, lt_to_placeholder_idx, to_placeholder_idx,
+};
 
 use super::{
     BoundExistentialPredicate, BoundExistentialPredicates, BoundRegion, BoundRegionKind, BoundTy,
@@ -44,47 +48,24 @@ use super::{
     Region, SolverDefId, SubtypePredicate, Term, TraitRef, Ty, Tys, ValueConst, VariancesOf,
 };
 
-pub fn to_placeholder_idx<T: Clone + std::fmt::Debug>(
-    db: &dyn HirDatabase,
-    id: TypeOrConstParamId,
-    map: impl Fn(BoundVar) -> T,
-) -> Placeholder<T> {
-    let interned_id = InternedTypeOrConstParamId::new(db, id);
-    Placeholder {
-        universe: UniverseIndex::ZERO,
-        bound: map(BoundVar::from_usize(interned_id.as_id().index() as usize)),
-    }
-}
-
-pub fn bound_var_to_type_or_const_param_idx(
-    db: &dyn HirDatabase,
-    var: rustc_type_ir::BoundVar,
-) -> TypeOrConstParamId {
-    // SAFETY: We cannot really encapsulate this unfortunately, so just hope this is sound.
-    let interned_id = InternedTypeOrConstParamId::from_id(unsafe { Id::from_index(var.as_u32()) });
-    interned_id.loc(db)
-}
-
-pub fn bound_var_to_lifetime_idx(
-    db: &dyn HirDatabase,
-    var: rustc_type_ir::BoundVar,
-) -> LifetimeParamId {
-    // SAFETY: We cannot really encapsulate this unfortunately, so just hope this is sound.
-    let interned_id = InternedLifetimeParamId::from_id(unsafe { Id::from_index(var.as_u32()) });
-    interned_id.loc(db)
-}
-
+// FIXME: This should urgently go (as soon as we finish the migration off Chalk, that is).
 pub fn convert_binder_to_early_binder<'db, T: rustc_type_ir::TypeFoldable<DbInterner<'db>>>(
     interner: DbInterner<'db>,
+    def: GenericDefId,
     binder: rustc_type_ir::Binder<DbInterner<'db>, T>,
 ) -> rustc_type_ir::EarlyBinder<DbInterner<'db>, T> {
-    let mut folder = BinderToEarlyBinder { interner, debruijn: rustc_type_ir::DebruijnIndex::ZERO };
+    let mut folder = BinderToEarlyBinder {
+        interner,
+        debruijn: rustc_type_ir::DebruijnIndex::ZERO,
+        params: crate::generics::generics(interner.db, def).iter_id().collect(),
+    };
     rustc_type_ir::EarlyBinder::bind(binder.skip_binder().fold_with(&mut folder))
 }
 
 struct BinderToEarlyBinder<'db> {
     interner: DbInterner<'db>,
     debruijn: rustc_type_ir::DebruijnIndex,
+    params: Vec<GenericParamId>,
 }
 
 impl<'db> rustc_type_ir::TypeFolder<DbInterner<'db>> for BinderToEarlyBinder<'db> {
@@ -109,7 +90,13 @@ impl<'db> rustc_type_ir::TypeFolder<DbInterner<'db>> for BinderToEarlyBinder<'db
         match t.kind() {
             rustc_type_ir::TyKind::Bound(debruijn, bound_ty) if self.debruijn == debruijn => {
                 let var: rustc_type_ir::BoundVar = bound_ty.var();
-                Ty::new(self.cx(), rustc_type_ir::TyKind::Param(ParamTy { index: var.as_u32() }))
+                let GenericParamId::TypeParamId(id) = self.params[bound_ty.var.as_usize()] else {
+                    unreachable!()
+                };
+                Ty::new(
+                    self.cx(),
+                    rustc_type_ir::TyKind::Param(ParamTy { index: var.as_u32(), id }),
+                )
             }
             _ => t.super_fold_with(self),
         }
@@ -119,10 +106,15 @@ impl<'db> rustc_type_ir::TypeFolder<DbInterner<'db>> for BinderToEarlyBinder<'db
         match r.kind() {
             rustc_type_ir::ReBound(debruijn, bound_region) if self.debruijn == debruijn => {
                 let var: rustc_type_ir::BoundVar = bound_region.var();
+                let GenericParamId::LifetimeParamId(id) = self.params[bound_region.var.as_usize()]
+                else {
+                    unreachable!()
+                };
                 Region::new(
                     self.cx(),
                     rustc_type_ir::RegionKind::ReEarlyParam(EarlyParamRegion {
                         index: var.as_u32(),
+                        id,
                     }),
                 )
             }
@@ -133,9 +125,12 @@ impl<'db> rustc_type_ir::TypeFolder<DbInterner<'db>> for BinderToEarlyBinder<'db
     fn fold_const(&mut self, c: Const<'db>) -> Const<'db> {
         match c.kind() {
             rustc_type_ir::ConstKind::Bound(debruijn, var) if self.debruijn == debruijn => {
+                let GenericParamId::ConstParamId(id) = self.params[var.as_usize()] else {
+                    unreachable!()
+                };
                 Const::new(
                     self.cx(),
-                    rustc_type_ir::ConstKind::Param(ParamConst { index: var.as_u32() }),
+                    rustc_type_ir::ConstKind::Param(ParamConst { index: var.as_u32(), id }),
                 )
             }
             _ => c.super_fold_with(self),
@@ -274,12 +269,6 @@ impl<'db> ChalkToNextSolver<'db, Ty<'db>> for chalk_ir::Ty<Interner> {
                     SolverDefId::TypeAliasId(crate::from_foreign_def_id(*foreign_def_id)),
                 ),
                 chalk_ir::TyKind::Error => rustc_type_ir::TyKind::Error(ErrorGuaranteed),
-                chalk_ir::TyKind::Placeholder(placeholder_index) => {
-                    rustc_type_ir::TyKind::Placeholder(PlaceholderTy::new_anon(
-                        placeholder_index.ui.to_nextsolver(interner),
-                        rustc_type_ir::BoundVar::from_usize(placeholder_index.idx),
-                    ))
-                }
                 chalk_ir::TyKind::Dyn(dyn_ty) => {
                     // exists<type> { for<...> ^1.0: ... }
                     let bounds = BoundExistentialPredicates::new_from_iter(
@@ -405,6 +394,26 @@ impl<'db> ChalkToNextSolver<'db, Ty<'db>> for chalk_ir::Ty<Interner> {
 
                     rustc_type_ir::TyKind::FnPtr(sig_tys, header)
                 }
+                // The schema here is quite confusing.
+                // The new solver, like rustc, uses `Param` and `EarlyBinder` for generic params. It uses `BoundVar`
+                // and `Placeholder` together with `Binder` for HRTB, which we mostly don't handle.
+                // Chalk uses `Placeholder` for generic params and `BoundVar` quite liberally, and this is quite a
+                // problem. `chalk_ir::TyKind::BoundVar` can represent either HRTB or generic params, depending on the
+                // context. When returned from signature queries, the outer `Binders` represent the generic params.
+                // But there are also inner `Binders` for HRTB.
+                // AFAIK there is no way to tell which of the meanings is relevant, so we just use `rustc_type_ir::Bound`
+                // here, and hope for the best. If you are working with new solver types, therefore, use the new solver
+                // lower queries.
+                // Hopefully sooner than later Chalk will be ripped from the codebase and we can avoid that problem.
+                // For details about the rustc setup, read: https://rustc-dev-guide.rust-lang.org/generic_parameters_summary.html
+                // and the following chapters.
+                chalk_ir::TyKind::Placeholder(placeholder_index) => {
+                    let (id, index) = from_placeholder_idx(interner.db, *placeholder_index);
+                    rustc_type_ir::TyKind::Param(ParamTy {
+                        id: TypeParamId::from_unchecked(id),
+                        index,
+                    })
+                }
                 chalk_ir::TyKind::BoundVar(bound_var) => rustc_type_ir::TyKind::Bound(
                     bound_var.debruijn.to_nextsolver(interner),
                     BoundTy {
@@ -440,10 +449,8 @@ impl<'db> ChalkToNextSolver<'db, Region<'db>> for chalk_ir::Lifetime<Interner> {
                     ))
                 }
                 chalk_ir::LifetimeData::Placeholder(placeholder_index) => {
-                    rustc_type_ir::RegionKind::RePlaceholder(PlaceholderRegion::new_anon(
-                        rustc_type_ir::UniverseIndex::from_u32(placeholder_index.ui.counter as u32),
-                        rustc_type_ir::BoundVar::from_u32(placeholder_index.idx as u32),
-                    ))
+                    let (id, index) = lt_from_placeholder_idx(interner.db, *placeholder_index);
+                    rustc_type_ir::RegionKind::ReEarlyParam(EarlyParamRegion { id, index })
                 }
                 chalk_ir::LifetimeData::Static => rustc_type_ir::RegionKind::ReStatic,
                 chalk_ir::LifetimeData::Erased => rustc_type_ir::RegionKind::ReErased,
@@ -474,10 +481,11 @@ impl<'db> ChalkToNextSolver<'db, Const<'db>> for chalk_ir::Const<Interner> {
                     ))
                 }
                 chalk_ir::ConstValue::Placeholder(placeholder_index) => {
-                    rustc_type_ir::ConstKind::Placeholder(PlaceholderConst::new(
-                        placeholder_index.ui.to_nextsolver(interner),
-                        rustc_type_ir::BoundVar::from_usize(placeholder_index.idx),
-                    ))
+                    let (id, index) = from_placeholder_idx(interner.db, *placeholder_index);
+                    rustc_type_ir::ConstKind::Param(ParamConst {
+                        id: ConstParamId::from_unchecked(id),
+                        index,
+                    })
                 }
                 chalk_ir::ConstValue::Concrete(concrete_const) => match &concrete_const.interned {
                     ConstScalar::Bytes(bytes, memory) => {
@@ -971,7 +979,7 @@ pub fn convert_args_for_result<'db>(
                 substs.push(chalk_ir::GenericArgData::Ty(ty).intern(Interner));
             }
             rustc_type_ir::GenericArgKind::Lifetime(region) => {
-                let lifetime = convert_region_for_result(region);
+                let lifetime = convert_region_for_result(interner, region);
                 substs.push(chalk_ir::GenericArgData::Lifetime(lifetime).intern(Interner));
             }
             rustc_type_ir::GenericArgKind::Const(const_) => {
@@ -1074,7 +1082,7 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
                 rustc_ast_ir::Mutability::Mut => chalk_ir::Mutability::Mut,
                 rustc_ast_ir::Mutability::Not => chalk_ir::Mutability::Not,
             };
-            let r = convert_region_for_result(r);
+            let r = convert_region_for_result(interner, r);
             let ty = convert_ty_for_result(interner, ty);
             TyKind::Ref(mutability, r, ty)
         }
@@ -1122,17 +1130,23 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
             rustc_type_ir::AliasTyKind::Free => unimplemented!(),
         },
 
+        // For `Placeholder`, `Bound` and `Param`, see the comment on the reverse conversion.
         rustc_type_ir::TyKind::Placeholder(placeholder) => {
-            let ui = chalk_ir::UniverseIndex { counter: placeholder.universe.as_usize() };
-            let placeholder_index =
-                chalk_ir::PlaceholderIndex { idx: placeholder.bound.var.as_usize(), ui };
-            TyKind::Placeholder(placeholder_index)
+            unimplemented!(
+                "A `rustc_type_ir::TyKind::Placeholder` doesn't have a direct \
+                correspondence in Chalk, as it represents a universally instantiated `Bound`.\n\
+                It therefore feels safer to leave it panicking, but if you hit this panic \
+                feel free to do the same as in `rustc_type_ir::TyKind::Bound` here."
+            )
         }
-
         rustc_type_ir::TyKind::Bound(debruijn_index, ty) => TyKind::BoundVar(chalk_ir::BoundVar {
             debruijn: chalk_ir::DebruijnIndex::new(debruijn_index.as_u32()),
             index: ty.var.as_usize(),
         }),
+        rustc_type_ir::TyKind::Param(param) => {
+            let placeholder = to_placeholder_idx(interner.db, param.id.into(), param.index);
+            TyKind::Placeholder(placeholder)
+        }
 
         rustc_type_ir::TyKind::FnPtr(bound_sig, fn_header) => {
             let num_binders = bound_sig.bound_vars().len();
@@ -1254,7 +1268,8 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
                 chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General),
             );
             let bounds = chalk_ir::Binders::new(binders, bounds);
-            let dyn_ty = chalk_ir::DynTy { bounds, lifetime: convert_region_for_result(region) };
+            let dyn_ty =
+                chalk_ir::DynTy { bounds, lifetime: convert_region_for_result(interner, region) };
             TyKind::Dyn(dyn_ty)
         }
 
@@ -1316,7 +1331,6 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
             TyKind::CoroutineWitness(id.into(), subst)
         }
 
-        rustc_type_ir::TyKind::Param(_) => unimplemented!(),
         rustc_type_ir::TyKind::UnsafeBinder(_) => unimplemented!(),
     }
     .intern(Interner)
@@ -1327,13 +1341,16 @@ pub fn convert_const_for_result<'db>(
     const_: Const<'db>,
 ) -> crate::Const {
     let value: chalk_ir::ConstValue<Interner> = match const_.kind() {
-        rustc_type_ir::ConstKind::Param(_) => unimplemented!(),
         rustc_type_ir::ConstKind::Infer(rustc_type_ir::InferConst::Var(var)) => {
             chalk_ir::ConstValue::InferenceVar(chalk_ir::InferenceVar::from(var.as_u32()))
         }
         rustc_type_ir::ConstKind::Infer(rustc_type_ir::InferConst::Fresh(fresh)) => {
             panic!("Vars should not be freshened.")
         }
+        rustc_type_ir::ConstKind::Param(param) => {
+            let placeholder = to_placeholder_idx(interner.db, param.id.into(), param.index);
+            chalk_ir::ConstValue::Placeholder(placeholder)
+        }
         rustc_type_ir::ConstKind::Bound(debruijn_index, var) => {
             chalk_ir::ConstValue::BoundVar(chalk_ir::BoundVar::new(
                 chalk_ir::DebruijnIndex::new(debruijn_index.as_u32()),
@@ -1341,10 +1358,12 @@ pub fn convert_const_for_result<'db>(
             ))
         }
         rustc_type_ir::ConstKind::Placeholder(placeholder_const) => {
-            chalk_ir::ConstValue::Placeholder(chalk_ir::PlaceholderIndex {
-                ui: chalk_ir::UniverseIndex { counter: placeholder_const.universe.as_usize() },
-                idx: placeholder_const.bound.as_usize(),
-            })
+            unimplemented!(
+                "A `rustc_type_ir::ConstKind::Placeholder` doesn't have a direct \
+                correspondence in Chalk, as it represents a universally instantiated `Bound`.\n\
+                It therefore feels safer to leave it panicking, but if you hit this panic \
+                feel free to do the same as in `rustc_type_ir::ConstKind::Bound` here."
+            )
         }
         rustc_type_ir::ConstKind::Unevaluated(unevaluated_const) => {
             let id = match unevaluated_const.def {
@@ -1381,36 +1400,34 @@ pub fn convert_const_for_result<'db>(
     chalk_ir::ConstData { ty: crate::TyKind::Error.intern(Interner), value }.intern(Interner)
 }
 
-pub fn convert_region_for_result<'db>(region: Region<'db>) -> crate::Lifetime {
-    match region.kind() {
-        rustc_type_ir::RegionKind::ReEarlyParam(early) => unimplemented!(),
-        rustc_type_ir::RegionKind::ReBound(db, bound) => chalk_ir::Lifetime::new(
-            Interner,
+pub fn convert_region_for_result<'db>(
+    interner: DbInterner<'db>,
+    region: Region<'db>,
+) -> crate::Lifetime {
+    let lifetime = match region.kind() {
+        rustc_type_ir::RegionKind::ReEarlyParam(early) => {
+            let placeholder = lt_to_placeholder_idx(interner.db, early.id, early.index);
+            chalk_ir::LifetimeData::Placeholder(placeholder)
+        }
+        rustc_type_ir::RegionKind::ReBound(db, bound) => {
             chalk_ir::LifetimeData::BoundVar(chalk_ir::BoundVar::new(
                 chalk_ir::DebruijnIndex::new(db.as_u32()),
                 bound.var.as_usize(),
-            )),
-        ),
-        rustc_type_ir::RegionKind::ReLateParam(_) => unimplemented!(),
-        rustc_type_ir::RegionKind::ReStatic => {
-            chalk_ir::Lifetime::new(Interner, chalk_ir::LifetimeData::Static)
+            ))
         }
-        rustc_type_ir::RegionKind::ReVar(vid) => chalk_ir::Lifetime::new(
-            Interner,
-            chalk_ir::LifetimeData::InferenceVar(chalk_ir::InferenceVar::from(vid.as_u32())),
-        ),
-        rustc_type_ir::RegionKind::RePlaceholder(placeholder) => chalk_ir::Lifetime::new(
-            Interner,
-            chalk_ir::LifetimeData::Placeholder(chalk_ir::PlaceholderIndex {
-                idx: placeholder.bound.var.as_usize(),
-                ui: chalk_ir::UniverseIndex { counter: placeholder.universe.as_usize() },
-            }),
+        rustc_type_ir::RegionKind::RePlaceholder(placeholder) => unimplemented!(
+            "A `rustc_type_ir::RegionKind::RePlaceholder` doesn't have a direct \
+            correspondence in Chalk, as it represents a universally instantiated `Bound`.\n\
+            It therefore feels safer to leave it panicking, but if you hit this panic \
+            feel free to do the same as in `rustc_type_ir::RegionKind::ReBound` here."
         ),
-        rustc_type_ir::RegionKind::ReErased => {
-            chalk_ir::Lifetime::new(Interner, chalk_ir::LifetimeData::Erased)
-        }
-        rustc_type_ir::RegionKind::ReError(_) => {
-            chalk_ir::Lifetime::new(Interner, chalk_ir::LifetimeData::Error)
+        rustc_type_ir::RegionKind::ReLateParam(_) => unimplemented!(),
+        rustc_type_ir::RegionKind::ReStatic => chalk_ir::LifetimeData::Static,
+        rustc_type_ir::RegionKind::ReVar(vid) => {
+            chalk_ir::LifetimeData::InferenceVar(chalk_ir::InferenceVar::from(vid.as_u32()))
         }
-    }
+        rustc_type_ir::RegionKind::ReErased => chalk_ir::LifetimeData::Erased,
+        rustc_type_ir::RegionKind::ReError(_) => chalk_ir::LifetimeData::Error,
+    };
+    chalk_ir::Lifetime::new(Interner, lifetime)
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/region.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/region.rs
index c59cdac5f99f6..d6214d991560a 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/region.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/region.rs
@@ -1,5 +1,6 @@
 //! Things related to regions.
 
+use hir_def::LifetimeParamId;
 use intern::{Interned, Symbol};
 use rustc_type_ir::{
     BoundVar, Flags, INNERMOST, RegionVid, TypeFlags, TypeFoldable, TypeVisitable, VisitorResult,
@@ -110,6 +111,8 @@ pub type PlaceholderRegion = Placeholder<BoundRegion>;
 
 #[derive(Copy, Clone, PartialEq, Eq, Hash)]
 pub struct EarlyParamRegion {
+    // FIXME: See `ParamTy`.
+    pub id: LifetimeParamId,
     pub index: u32,
 }
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
index 5ffae981a6094..92f1076e75eca 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
@@ -1,5 +1,6 @@
 //! Things related to tys in the next-trait-solver.
 
+use hir_def::{GenericDefId, TypeOrConstParamId, TypeParamId};
 use intern::{Interned, Symbol, sym};
 use rustc_abi::{Float, Integer, Size};
 use rustc_ast_ir::{Mutability, try_visit, visit::VisitorResult};
@@ -64,8 +65,8 @@ impl<'db> Ty<'db> {
         .unwrap()
     }
 
-    pub fn new_param(interner: DbInterner<'db>, index: u32, name: Symbol) -> Self {
-        Ty::new(interner, TyKind::Param(ParamTy { index }))
+    pub fn new_param(interner: DbInterner<'db>, id: TypeParamId, index: u32, name: Symbol) -> Self {
+        Ty::new(interner, TyKind::Param(ParamTy { id, index }))
     }
 
     pub fn new_placeholder(interner: DbInterner<'db>, placeholder: PlaceholderTy) -> Self {
@@ -847,12 +848,16 @@ pub type PlaceholderTy = Placeholder<BoundTy>;
 
 #[derive(Copy, Clone, PartialEq, Eq, Hash)]
 pub struct ParamTy {
+    // FIXME: I'm not pleased with this. Ideally a `Param` should only know its index - the defining item
+    // is known from the `EarlyBinder`. This should also be beneficial for memory usage. But code currently
+    // assumes it can get the definition from `Param` alone - so that's what we got.
+    pub id: TypeParamId,
     pub index: u32,
 }
 
 impl ParamTy {
     pub fn to_ty<'db>(self, interner: DbInterner<'db>) -> Ty<'db> {
-        Ty::new_param(interner, self.index, sym::MISSING_NAME.clone())
+        Ty::new_param(interner, self.id, self.index, sym::MISSING_NAME.clone())
     }
 }
 
@@ -865,6 +870,7 @@ impl std::fmt::Debug for ParamTy {
 #[derive(Copy, Clone, PartialEq, Eq, Hash)]
 pub struct BoundTy {
     pub var: BoundVar,
+    // FIXME: This is for diagnostics in rustc, do we really need it?
     pub kind: BoundTyKind,
 }
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/variance.rs b/src/tools/rust-analyzer/crates/hir-ty/src/variance.rs
index d8a058533f761..a1ebff04bbd47 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/variance.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/variance.rs
@@ -344,7 +344,7 @@ impl Context<'_> {
 
             // Chalk has no params, so use placeholders for now?
             TyKind::Placeholder(index) => {
-                let idx = crate::from_placeholder_idx(self.db, *index);
+                let idx = crate::from_placeholder_idx(self.db, *index).0;
                 let index = self.generics.type_or_const_param_idx(idx).unwrap();
                 self.constrain(index, variance);
             }
@@ -445,7 +445,7 @@ impl Context<'_> {
         );
         match region.data(Interner) {
             LifetimeData::Placeholder(index) => {
-                let idx = crate::lt_from_placeholder_idx(self.db, *index);
+                let idx = crate::lt_from_placeholder_idx(self.db, *index).0;
                 let inferred = self.generics.lifetime_idx(idx).unwrap();
                 self.constrain(inferred, variance);
             }
diff --git a/src/tools/rust-analyzer/crates/hir/src/display.rs b/src/tools/rust-analyzer/crates/hir/src/display.rs
index b9c5131ffbb55..833a9ef03065d 100644
--- a/src/tools/rust-analyzer/crates/hir/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/display.rs
@@ -474,8 +474,8 @@ impl HirDisplay for TypeParam {
         let param_data = &params[self.id.local_id()];
         let substs = TyBuilder::placeholder_subst(f.db, self.id.parent());
         let krate = self.id.parent().krate(f.db).id;
-        let ty =
-            TyKind::Placeholder(hir_ty::to_placeholder_idx(f.db, self.id.into())).intern(Interner);
+        let ty = TyKind::Placeholder(hir_ty::to_placeholder_idx_no_index(f.db, self.id.into()))
+            .intern(Interner);
         let predicates = f.db.generic_predicates(self.id.parent());
         let predicates = predicates
             .iter()
@@ -528,8 +528,11 @@ impl HirDisplay for TypeParam {
                 f,
                 ":",
                 Either::Left(
-                    &hir_ty::TyKind::Placeholder(hir_ty::to_placeholder_idx(f.db, self.id.into()))
-                        .intern(Interner),
+                    &hir_ty::TyKind::Placeholder(hir_ty::to_placeholder_idx_no_index(
+                        f.db,
+                        self.id.into(),
+                    ))
+                    .intern(Interner),
                 ),
                 &predicates,
                 default_sized,
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index f03f542e5bce3..46d3a2bcd67ce 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -4239,8 +4239,8 @@ impl TypeParam {
 
     pub fn ty(self, db: &dyn HirDatabase) -> Type<'_> {
         let resolver = self.id.parent().resolver(db);
-        let ty =
-            TyKind::Placeholder(hir_ty::to_placeholder_idx(db, self.id.into())).intern(Interner);
+        let ty = TyKind::Placeholder(hir_ty::to_placeholder_idx_no_index(db, self.id.into()))
+            .intern(Interner);
         Type::new_with_resolver_inner(db, &resolver, ty)
     }
 
@@ -5933,7 +5933,7 @@ impl<'db> Type<'db> {
     pub fn as_type_param(&self, db: &'db dyn HirDatabase) -> Option<TypeParam> {
         match self.ty.kind(Interner) {
             TyKind::Placeholder(p) => Some(TypeParam {
-                id: TypeParamId::from_unchecked(hir_ty::from_placeholder_idx(db, *p)),
+                id: TypeParamId::from_unchecked(hir_ty::from_placeholder_idx(db, *p).0),
             }),
             _ => None,
         }

From dd75ad436927ac30bf204953d24b07bff09225bd Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Tue, 2 Sep 2025 08:15:17 +0300
Subject: [PATCH 0401/1889] Deduplicate methods in completion by function ID
 and not by name

Because duplicates can be found with traits. Worse, the inherent methods could be private, and we'll discover that only later. But even if they're not they're different methods, and its seems worthy to present them all to the user.
---
 .../ide-completion/src/completions/dot.rs     | 15 ++++---
 .../ide-completion/src/tests/expression.rs    | 40 +++++++++++++++++++
 2 files changed, 47 insertions(+), 8 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/dot.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/dot.rs
index 129964f8387a3..b9ef68cc2d2a3 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/dot.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/dot.rs
@@ -2,7 +2,7 @@
 
 use std::ops::ControlFlow;
 
-use hir::{Complete, HasContainer, ItemContainer, MethodCandidateCallback, Name};
+use hir::{Complete, Function, HasContainer, ItemContainer, MethodCandidateCallback};
 use ide_db::FxHashSet;
 use syntax::SmolStr;
 
@@ -237,7 +237,10 @@ fn complete_methods(
     struct Callback<'a, F> {
         ctx: &'a CompletionContext<'a>,
         f: F,
-        seen_methods: FxHashSet<Name>,
+        // We deliberately deduplicate by function ID and not name, because while inherent methods cannot be
+        // duplicated, trait methods can. And it is still useful to show all of them (even when there
+        // is also an inherent method, especially considering that it may be private, and filtered later).
+        seen_methods: FxHashSet<Function>,
     }
 
     impl<F> MethodCandidateCallback for Callback<'_, F>
@@ -247,9 +250,7 @@ fn complete_methods(
         // We don't want to exclude inherent trait methods - that is, methods of traits available from
         // `where` clauses or `dyn Trait`.
         fn on_inherent_method(&mut self, func: hir::Function) -> ControlFlow<()> {
-            if func.self_param(self.ctx.db).is_some()
-                && self.seen_methods.insert(func.name(self.ctx.db))
-            {
+            if func.self_param(self.ctx.db).is_some() && self.seen_methods.insert(func) {
                 (self.f)(func);
             }
             ControlFlow::Continue(())
@@ -265,9 +266,7 @@ fn complete_methods(
                 return ControlFlow::Continue(());
             }
 
-            if func.self_param(self.ctx.db).is_some()
-                && self.seen_methods.insert(func.name(self.ctx.db))
-            {
+            if func.self_param(self.ctx.db).is_some() && self.seen_methods.insert(func) {
                 (self.f)(func);
             }
 
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs b/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
index 7a0d00444129f..af6ef34761ed1 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
@@ -2632,3 +2632,43 @@ fn let_in_condition() {
 fn let_in_let_chain() {
     check_edit("let", r#"fn f() { if true && $0 {} }"#, r#"fn f() { if true && let $1 = $0 {} }"#);
 }
+
+#[test]
+fn private_inherent_and_public_trait() {
+    check(
+        r#"
+struct Foo;
+
+mod private {
+    impl super::Foo {
+        fn method(&self) {}
+    }
+}
+
+trait Trait {
+    fn method(&self) {}
+}
+impl Trait for Foo {}
+
+fn main() {
+    Foo.$0
+}
+    "#,
+        expect![[r#"
+            me method() (as Trait) fn(&self)
+            sn box            Box::new(expr)
+            sn call           function(expr)
+            sn const                const {}
+            sn dbg                dbg!(expr)
+            sn dbgr              dbg!(&expr)
+            sn deref                   *expr
+            sn let                       let
+            sn letm                  let mut
+            sn match           match expr {}
+            sn ref                     &expr
+            sn refm                &mut expr
+            sn return            return expr
+            sn unsafe              unsafe {}
+        "#]],
+    );
+}

From f6d55aea2c2cc014f8bb105325ef4c21d2c3d185 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 28 Aug 2025 12:03:19 +0200
Subject: [PATCH 0402/1889] stabilize extended_varargs_abi_support

---
 compiler/rustc_abi/src/extern_abi.rs          | 25 +++++++-
 compiler/rustc_abi/src/lib.rs                 |  2 +
 compiler/rustc_ast_passes/messages.ftl        |  2 +-
 compiler/rustc_feature/src/accepted.rs        |  3 +
 compiler/rustc_feature/src/unstable.rs        |  3 -
 .../rustc_hir_analysis/src/check/check.rs     |  2 +-
 compiler/rustc_hir_analysis/src/check/mod.rs  |  2 +-
 .../src/hir_ty_lowering/mod.rs                |  4 +-
 compiler/rustc_hir_analysis/src/lib.rs        | 59 ++++++++-----------
 library/std/src/lib.rs                        |  1 -
 .../extended-varargs-abi-support.md           | 10 ----
 tests/codegen-llvm/cffi/c-variadic-ffi.rs     |  2 +-
 tests/ui/abi/unsupported-varargs-fnptr.rs     |  2 -
 tests/ui/abi/unsupported-varargs-fnptr.stderr |  2 +-
 ...ature-gate-extended_varargs_abi_support.rs | 16 -----
 ...e-gate-extended_varargs_abi_support.stderr | 33 -----------
 tests/ui/c-variadic/issue-86053-1.rs          |  2 +-
 tests/ui/c-variadic/issue-86053-1.stderr      |  2 +-
 .../same-program-multiple-abis-arm.rs         |  1 -
 .../same-program-multiple-abis-x86_64.rs      |  1 -
 .../cmse-nonsecure-entry/generics.rs          |  2 +-
 .../cmse-nonsecure-entry/generics.stderr      |  2 +-
 .../feature-gates/feature-gate-c_variadic.rs  |  6 ++
 .../feature-gate-c_variadic.stderr            | 18 +++++-
 .../issue-83499-input-output-iteration-ice.rs |  2 +-
 ...ue-83499-input-output-iteration-ice.stderr |  2 +-
 .../variadic-ffi-semantic-restrictions.rs     | 42 ++++++-------
 .../variadic-ffi-semantic-restrictions.stderr | 42 ++++++-------
 28 files changed, 128 insertions(+), 162 deletions(-)
 delete mode 100644 src/doc/unstable-book/src/language-features/extended-varargs-abi-support.md
 delete mode 100644 tests/ui/c-variadic/feature-gate-extended_varargs_abi_support.rs
 delete mode 100644 tests/ui/c-variadic/feature-gate-extended_varargs_abi_support.stderr

diff --git a/compiler/rustc_abi/src/extern_abi.rs b/compiler/rustc_abi/src/extern_abi.rs
index 41d744e1946ad..e3b2b1eff72d4 100644
--- a/compiler/rustc_abi/src/extern_abi.rs
+++ b/compiler/rustc_abi/src/extern_abi.rs
@@ -6,6 +6,8 @@ use std::hash::{Hash, Hasher};
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher, StableOrd};
 #[cfg(feature = "nightly")]
 use rustc_macros::{Decodable, Encodable};
+#[cfg(feature = "nightly")]
+use rustc_span::Symbol;
 
 use crate::AbiFromStrErr;
 
@@ -226,6 +228,13 @@ impl StableOrd for ExternAbi {
 #[cfg(feature = "nightly")]
 rustc_error_messages::into_diag_arg_using_display!(ExternAbi);
 
+#[cfg(feature = "nightly")]
+pub enum CVariadicStatus {
+    NotSupported,
+    Stable,
+    Unstable { feature: Symbol },
+}
+
 impl ExternAbi {
     /// An ABI "like Rust"
     ///
@@ -238,23 +247,33 @@ impl ExternAbi {
         matches!(self, Rust | RustCall | RustCold)
     }
 
-    pub fn supports_varargs(self) -> bool {
+    /// Returns whether the ABI supports C variadics. This only controls whether we allow *imports*
+    /// of such functions via `extern` blocks; there's a separate check during AST construction
+    /// guarding *definitions* of variadic functions.
+    #[cfg(feature = "nightly")]
+    pub fn supports_c_variadic(self) -> CVariadicStatus {
         // * C and Cdecl obviously support varargs.
         // * C can be based on Aapcs, SysV64 or Win64, so they must support varargs.
         // * EfiApi is based on Win64 or C, so it also supports it.
+        // * System automatically falls back to C when used with variadics, therefore supports it.
         //
         // * Stdcall does not, because it would be impossible for the callee to clean
         //   up the arguments. (callee doesn't know how many arguments are there)
         // * Same for Fastcall, Vectorcall and Thiscall.
         // * Other calling conventions are related to hardware or the compiler itself.
+        //
+        // All of the supported ones must have a test in `tests/codegen/cffi/c-variadic-ffi.rs`.
         match self {
             Self::C { .. }
             | Self::Cdecl { .. }
             | Self::Aapcs { .. }
             | Self::Win64 { .. }
             | Self::SysV64 { .. }
-            | Self::EfiApi => true,
-            _ => false,
+            | Self::EfiApi => CVariadicStatus::Stable,
+            Self::System { .. } => {
+                CVariadicStatus::Unstable { feature: rustc_span::sym::extern_system_varargs }
+            }
+            _ => CVariadicStatus::NotSupported,
         }
     }
 }
diff --git a/compiler/rustc_abi/src/lib.rs b/compiler/rustc_abi/src/lib.rs
index 14e256b8045df..22aba1fac0f8b 100644
--- a/compiler/rustc_abi/src/lib.rs
+++ b/compiler/rustc_abi/src/lib.rs
@@ -63,6 +63,8 @@ mod tests;
 
 pub use callconv::{Heterogeneous, HomogeneousAggregate, Reg, RegKind};
 pub use canon_abi::{ArmCall, CanonAbi, InterruptKind, X86Call};
+#[cfg(feature = "nightly")]
+pub use extern_abi::CVariadicStatus;
 pub use extern_abi::{ExternAbi, all_names};
 #[cfg(feature = "nightly")]
 pub use layout::{FIRST_VARIANT, FieldIdx, Layout, TyAbiInterface, TyAndLayout, VariantIdx};
diff --git a/compiler/rustc_ast_passes/messages.ftl b/compiler/rustc_ast_passes/messages.ftl
index a95f144396844..e5f1fcdc4b40d 100644
--- a/compiler/rustc_ast_passes/messages.ftl
+++ b/compiler/rustc_ast_passes/messages.ftl
@@ -57,7 +57,7 @@ ast_passes_auto_super_lifetime = auto traits cannot have super traits or lifetim
     .label = {ast_passes_auto_super_lifetime}
     .suggestion = remove the super traits or lifetime bounds
 
-ast_passes_bad_c_variadic = only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+ast_passes_bad_c_variadic = defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
 
 ast_passes_body_in_extern = incorrect `{$kind}` inside `extern` block
     .cannot_have = cannot have a body
diff --git a/compiler/rustc_feature/src/accepted.rs b/compiler/rustc_feature/src/accepted.rs
index 9fe55216f9395..6af4cfb0e562e 100644
--- a/compiler/rustc_feature/src/accepted.rs
+++ b/compiler/rustc_feature/src/accepted.rs
@@ -203,6 +203,9 @@ declare_features! (
     (accepted, expr_fragment_specifier_2024, "1.83.0", Some(123742)),
     /// Allows arbitrary expressions in key-value attributes at parse time.
     (accepted, extended_key_value_attributes, "1.54.0", Some(78835)),
+    /// Allows using `aapcs`, `efiapi`, `sysv64` and `win64` as calling conventions
+    /// for functions with varargs.
+    (accepted, extended_varargs_abi_support, "CURRENT_RUSTC_VERSION", Some(100189)),
     /// Allows resolving absolute paths as paths from other crates.
     (accepted, extern_absolute_paths, "1.30.0", Some(44660)),
     /// Allows `extern crate foo as bar;`. This puts `bar` into extern prelude.
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 92b435b4b0178..573e9aab0554a 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -492,9 +492,6 @@ declare_features! (
     (incomplete, explicit_tail_calls, "1.72.0", Some(112788)),
     /// Allows using `#[export_stable]` which indicates that an item is exportable.
     (incomplete, export_stable, "1.88.0", Some(139939)),
-    /// Allows using `aapcs`, `efiapi`, `sysv64` and `win64` as calling conventions
-    /// for functions with varargs.
-    (unstable, extended_varargs_abi_support, "1.65.0", Some(100189)),
     /// Allows using `system` as a calling convention with varargs.
     (unstable, extern_system_varargs, "1.86.0", Some(136946)),
     /// Allows defining `extern type`s.
diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
index eccb88a938fba..08b344638dd59 100644
--- a/compiler/rustc_hir_analysis/src/check/check.rs
+++ b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -978,7 +978,7 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Result<(),
                         tcx.ensure_ok().fn_sig(def_id);
                         let item = tcx.hir_foreign_item(item);
                         let hir::ForeignItemKind::Fn(sig, ..) = item.kind else { bug!() };
-                        require_c_abi_if_c_variadic(tcx, sig.decl, abi, item.span);
+                        check_c_variadic_abi(tcx, sig.decl, abi, item.span);
                     }
                     DefKind::Static { .. } => {
                         tcx.ensure_ok().codegen_fn_attrs(def_id);
diff --git a/compiler/rustc_hir_analysis/src/check/mod.rs b/compiler/rustc_hir_analysis/src/check/mod.rs
index 2e4b151d4dc8c..b5c0ca4727cda 100644
--- a/compiler/rustc_hir_analysis/src/check/mod.rs
+++ b/compiler/rustc_hir_analysis/src/check/mod.rs
@@ -98,7 +98,7 @@ use tracing::debug;
 
 use self::compare_impl_item::collect_return_position_impl_trait_in_trait_tys;
 use self::region::region_scope_tree;
-use crate::{errors, require_c_abi_if_c_variadic};
+use crate::{check_c_variadic_abi, errors};
 
 /// Adds query implementations to the [Providers] vtable, see [`rustc_middle::query`]
 pub(super) fn provide(providers: &mut Providers) {
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 c7b984d9b259c..c5e079fe89ac4 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -52,11 +52,11 @@ use rustc_trait_selection::traits::{self, FulfillmentError};
 use tracing::{debug, instrument};
 
 use crate::check::check_abi;
+use crate::check_c_variadic_abi;
 use crate::errors::{AmbiguousLifetimeBound, BadReturnTypeNotation};
 use crate::hir_ty_lowering::errors::{GenericsArgsErrExtend, prohibit_assoc_item_constraint};
 use crate::hir_ty_lowering::generics::{check_generic_arg_count, lower_generic_args};
 use crate::middle::resolve_bound_vars as rbv;
-use crate::require_c_abi_if_c_variadic;
 
 /// A path segment that is semantically allowed to have generic arguments.
 #[derive(Debug)]
@@ -2412,7 +2412,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 Ty::new_tup_from_iter(tcx, fields.iter().map(|t| self.lower_ty(t)))
             }
             hir::TyKind::FnPtr(bf) => {
-                require_c_abi_if_c_variadic(tcx, bf.decl, bf.abi, hir_ty.span);
+                check_c_variadic_abi(tcx, bf.decl, bf.abi, hir_ty.span);
 
                 Ty::new_fn_ptr(
                     tcx,
diff --git a/compiler/rustc_hir_analysis/src/lib.rs b/compiler/rustc_hir_analysis/src/lib.rs
index 44a5ceed46961..2562ab7542a6a 100644
--- a/compiler/rustc_hir_analysis/src/lib.rs
+++ b/compiler/rustc_hir_analysis/src/lib.rs
@@ -90,7 +90,7 @@ mod outlives;
 mod variance;
 
 pub use errors::NoVariantNamed;
-use rustc_abi::ExternAbi;
+use rustc_abi::{CVariadicStatus, ExternAbi};
 use rustc_hir::def::DefKind;
 use rustc_hir::lints::DelayedLint;
 use rustc_hir::{self as hir};
@@ -99,7 +99,6 @@ use rustc_middle::mir::interpret::GlobalId;
 use rustc_middle::query::Providers;
 use rustc_middle::ty::{self, Const, Ty, TyCtxt};
 use rustc_session::parse::feature_err;
-use rustc_span::symbol::sym;
 use rustc_span::{ErrorGuaranteed, Span};
 use rustc_trait_selection::traits;
 
@@ -108,46 +107,34 @@ use crate::hir_ty_lowering::{FeedConstTy, HirTyLowerer};
 
 rustc_fluent_macro::fluent_messages! { "../messages.ftl" }
 
-fn require_c_abi_if_c_variadic(
-    tcx: TyCtxt<'_>,
-    decl: &hir::FnDecl<'_>,
-    abi: ExternAbi,
-    span: Span,
-) {
-    // ABIs which can stably use varargs
-    if !decl.c_variadic || matches!(abi, ExternAbi::C { .. } | ExternAbi::Cdecl { .. }) {
+fn check_c_variadic_abi(tcx: TyCtxt<'_>, decl: &hir::FnDecl<'_>, abi: ExternAbi, span: Span) {
+    if !decl.c_variadic {
+        // Not even a variadic function.
         return;
     }
 
-    // ABIs with feature-gated stability
-    let extended_abi_support = tcx.features().extended_varargs_abi_support();
-    let extern_system_varargs = tcx.features().extern_system_varargs();
-
-    // If the feature gate has been enabled, we can stop here
-    if extern_system_varargs && let ExternAbi::System { .. } = abi {
-        return;
-    };
-    if extended_abi_support && abi.supports_varargs() {
-        return;
-    };
-
-    // Looks like we need to pick an error to emit.
-    // Is there any feature which we could have enabled to make this work?
-    let unstable_explain =
-        format!("C-variadic functions with the {abi} calling convention are unstable");
-    match abi {
-        ExternAbi::System { .. } => {
-            feature_err(&tcx.sess, sym::extern_system_varargs, span, unstable_explain)
+    match abi.supports_c_variadic() {
+        CVariadicStatus::Stable => {}
+        CVariadicStatus::NotSupported => {
+            tcx.dcx()
+                .create_err(errors::VariadicFunctionCompatibleConvention {
+                    span,
+                    convention: &format!("{abi}"),
+                })
+                .emit();
         }
-        abi if abi.supports_varargs() => {
-            feature_err(&tcx.sess, sym::extended_varargs_abi_support, span, unstable_explain)
+        CVariadicStatus::Unstable { feature } => {
+            if !tcx.features().enabled(feature) {
+                feature_err(
+                    &tcx.sess,
+                    feature,
+                    span,
+                    format!("C-variadic functions with the {abi} calling convention are unstable"),
+                )
+                .emit();
+            }
         }
-        _ => tcx.dcx().create_err(errors::VariadicFunctionCompatibleConvention {
-            span,
-            convention: &format!("{abi}"),
-        }),
     }
-    .emit();
 }
 
 /// Adds query implementations to the [Providers] vtable, see [`rustc_middle::query`]
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index f0de03c9a2806..da8fda42cd143 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -291,7 +291,6 @@
 #![feature(doc_masked)]
 #![feature(doc_notable_trait)]
 #![feature(dropck_eyepatch)]
-#![feature(extended_varargs_abi_support)]
 #![feature(f16)]
 #![feature(f128)]
 #![feature(ffi_const)]
diff --git a/src/doc/unstable-book/src/language-features/extended-varargs-abi-support.md b/src/doc/unstable-book/src/language-features/extended-varargs-abi-support.md
deleted file mode 100644
index b20c30ec8f1c8..0000000000000
--- a/src/doc/unstable-book/src/language-features/extended-varargs-abi-support.md
+++ /dev/null
@@ -1,10 +0,0 @@
-# `extended_varargs_abi_support`
-
-The tracking issue for this feature is: [#100189]
-
-[#100189]: https://github.com/rust-lang/rust/issues/100189
-
-------------------------
-
-This feature adds the possibility of using `sysv64`, `win64` or `efiapi` calling
-conventions on functions with varargs.
diff --git a/tests/codegen-llvm/cffi/c-variadic-ffi.rs b/tests/codegen-llvm/cffi/c-variadic-ffi.rs
index 3e99c9fb84e42..1dee477e9ed7c 100644
--- a/tests/codegen-llvm/cffi/c-variadic-ffi.rs
+++ b/tests/codegen-llvm/cffi/c-variadic-ffi.rs
@@ -14,7 +14,7 @@
 //@[arm32] needs-llvm-components: arm
 #![crate_type = "lib"]
 #![feature(no_core)]
-#![feature(extended_varargs_abi_support, extern_system_varargs)]
+#![feature(extern_system_varargs)]
 #![no_core]
 
 extern crate minicore;
diff --git a/tests/ui/abi/unsupported-varargs-fnptr.rs b/tests/ui/abi/unsupported-varargs-fnptr.rs
index 1d23916d03902..ac3913b3ef88f 100644
--- a/tests/ui/abi/unsupported-varargs-fnptr.rs
+++ b/tests/ui/abi/unsupported-varargs-fnptr.rs
@@ -6,8 +6,6 @@
 // We have to use this flag to force ABI computation of an invalid ABI
 //@ compile-flags: -Clink-dead-code
 
-#![feature(extended_varargs_abi_support)]
-
 // sometimes fn ptrs with varargs make layout and ABI computation ICE
 // as found in https://github.com/rust-lang/rust/issues/142107
 
diff --git a/tests/ui/abi/unsupported-varargs-fnptr.stderr b/tests/ui/abi/unsupported-varargs-fnptr.stderr
index 238f2b3133044..c05c55df82e75 100644
--- a/tests/ui/abi/unsupported-varargs-fnptr.stderr
+++ b/tests/ui/abi/unsupported-varargs-fnptr.stderr
@@ -1,5 +1,5 @@
 error[E0570]: "aapcs" is not a supported ABI for the current target
-  --> $DIR/unsupported-varargs-fnptr.rs:14:20
+  --> $DIR/unsupported-varargs-fnptr.rs:12:20
    |
 LL | fn aapcs(f: extern "aapcs" fn(usize, ...)) {
    |                    ^^^^^^^
diff --git a/tests/ui/c-variadic/feature-gate-extended_varargs_abi_support.rs b/tests/ui/c-variadic/feature-gate-extended_varargs_abi_support.rs
deleted file mode 100644
index 1e0576b21866b..0000000000000
--- a/tests/ui/c-variadic/feature-gate-extended_varargs_abi_support.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//@ only-x86_64
-
-fn efiapi(f: extern "efiapi" fn(usize, ...)) {
-    //~^ ERROR: unstable
-    f(22, 44);
-}
-fn sysv(f: extern "sysv64" fn(usize, ...)) {
-    //~^ ERROR: unstable
-    f(22, 44);
-}
-fn win(f: extern "win64" fn(usize, ...)) {
-    //~^ ERROR: unstable
-    f(22, 44);
-}
-
-fn main() {}
diff --git a/tests/ui/c-variadic/feature-gate-extended_varargs_abi_support.stderr b/tests/ui/c-variadic/feature-gate-extended_varargs_abi_support.stderr
deleted file mode 100644
index 7ef54b639ad2b..0000000000000
--- a/tests/ui/c-variadic/feature-gate-extended_varargs_abi_support.stderr
+++ /dev/null
@@ -1,33 +0,0 @@
-error[E0658]: C-variadic functions with the "efiapi" calling convention are unstable
-  --> $DIR/feature-gate-extended_varargs_abi_support.rs:3:14
-   |
-LL | fn efiapi(f: extern "efiapi" fn(usize, ...)) {
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #100189 <https://github.com/rust-lang/rust/issues/100189> for more information
-   = help: add `#![feature(extended_varargs_abi_support)]` 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]: C-variadic functions with the "sysv64" calling convention are unstable
-  --> $DIR/feature-gate-extended_varargs_abi_support.rs:7:12
-   |
-LL | fn sysv(f: extern "sysv64" fn(usize, ...)) {
-   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #100189 <https://github.com/rust-lang/rust/issues/100189> for more information
-   = help: add `#![feature(extended_varargs_abi_support)]` 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]: C-variadic functions with the "win64" calling convention are unstable
-  --> $DIR/feature-gate-extended_varargs_abi_support.rs:11:11
-   |
-LL | fn win(f: extern "win64" fn(usize, ...)) {
-   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #100189 <https://github.com/rust-lang/rust/issues/100189> for more information
-   = help: add `#![feature(extended_varargs_abi_support)]` 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
-
-For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/c-variadic/issue-86053-1.rs b/tests/ui/c-variadic/issue-86053-1.rs
index 8eeb99a4cc19c..537d0263adf78 100644
--- a/tests/ui/c-variadic/issue-86053-1.rs
+++ b/tests/ui/c-variadic/issue-86053-1.rs
@@ -13,6 +13,6 @@ fn ordering4 < 'a , 'b     > ( a :            ,   self , self ,   self ,
     //~| ERROR unexpected `self` parameter in function
     //~| ERROR unexpected `self` parameter in function
     //~| ERROR `...` must be the last argument of a C-variadic function
-    //~| ERROR only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+    //~| ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
     //~| ERROR cannot find type `F` in this scope
 }
diff --git a/tests/ui/c-variadic/issue-86053-1.stderr b/tests/ui/c-variadic/issue-86053-1.stderr
index dc323f9a234d6..472295c92b972 100644
--- a/tests/ui/c-variadic/issue-86053-1.stderr
+++ b/tests/ui/c-variadic/issue-86053-1.stderr
@@ -46,7 +46,7 @@ error: `...` must be the last argument of a C-variadic function
 LL |     self , ... ,   self ,   self , ... ) where F : FnOnce ( & 'a & 'b usize ) {
    |            ^^^
 
-error: only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
   --> $DIR/issue-86053-1.rs:11:12
    |
 LL |     self , ... ,   self ,   self , ... ) where F : FnOnce ( & 'a & 'b usize ) {
diff --git a/tests/ui/c-variadic/same-program-multiple-abis-arm.rs b/tests/ui/c-variadic/same-program-multiple-abis-arm.rs
index 1b0bdecabfbc8..1445bbb47bbd3 100644
--- a/tests/ui/c-variadic/same-program-multiple-abis-arm.rs
+++ b/tests/ui/c-variadic/same-program-multiple-abis-arm.rs
@@ -1,4 +1,3 @@
-#![feature(extended_varargs_abi_support)]
 //@ run-pass
 //@ only-arm
 //@ ignore-thumb (this test uses arm assembly)
diff --git a/tests/ui/c-variadic/same-program-multiple-abis-x86_64.rs b/tests/ui/c-variadic/same-program-multiple-abis-x86_64.rs
index b21accb999e9b..aff8ab613c431 100644
--- a/tests/ui/c-variadic/same-program-multiple-abis-x86_64.rs
+++ b/tests/ui/c-variadic/same-program-multiple-abis-x86_64.rs
@@ -1,4 +1,3 @@
-#![feature(extended_varargs_abi_support)]
 //@ run-pass
 //@ only-x86_64
 
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs
index 800dd580af290..ad4fca8252d24 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs
@@ -71,6 +71,6 @@ extern "cmse-nonsecure-entry" fn wrapped_trait_object(
 }
 
 extern "cmse-nonsecure-entry" fn c_variadic(_: u32, _: ...) {
-    //~^ ERROR only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+    //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
     //~| ERROR requires `va_list` lang_item
 }
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr
index f0190671b5a17..7aeb6969feb9f 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr
@@ -1,4 +1,4 @@
-error: only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
   --> $DIR/generics.rs:73:53
    |
 LL | extern "cmse-nonsecure-entry" fn c_variadic(_: u32, _: ...) {
diff --git a/tests/ui/feature-gates/feature-gate-c_variadic.rs b/tests/ui/feature-gates/feature-gate-c_variadic.rs
index f189f02a26ddf..45c688420931d 100644
--- a/tests/ui/feature-gates/feature-gate-c_variadic.rs
+++ b/tests/ui/feature-gates/feature-gate-c_variadic.rs
@@ -2,3 +2,9 @@
 
 pub unsafe extern "C" fn test(_: i32, ap: ...) { }
 //~^ ERROR C-variadic functions are unstable
+
+trait Trait {
+    unsafe extern "C" fn trait_test(_: i32, ap: ...) { }
+    //~^ ERROR C-variadic functions are unstable
+    //~| ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+}
diff --git a/tests/ui/feature-gates/feature-gate-c_variadic.stderr b/tests/ui/feature-gates/feature-gate-c_variadic.stderr
index 1b6a8c92af5ed..e30a2f1ede367 100644
--- a/tests/ui/feature-gates/feature-gate-c_variadic.stderr
+++ b/tests/ui/feature-gates/feature-gate-c_variadic.stderr
@@ -1,3 +1,9 @@
+error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+  --> $DIR/feature-gate-c_variadic.rs:7:45
+   |
+LL |     unsafe extern "C" fn trait_test(_: i32, ap: ...) { }
+   |                                             ^^^^^^^
+
 error[E0658]: C-variadic functions are unstable
   --> $DIR/feature-gate-c_variadic.rs:3:1
    |
@@ -8,6 +14,16 @@ LL | pub unsafe extern "C" fn test(_: i32, ap: ...) { }
    = help: add `#![feature(c_variadic)]` 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
+error[E0658]: C-variadic functions are unstable
+  --> $DIR/feature-gate-c_variadic.rs:7:5
+   |
+LL |     unsafe extern "C" fn trait_test(_: i32, ap: ...) { }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #44930 <https://github.com/rust-lang/rust/issues/44930> for more information
+   = help: add `#![feature(c_variadic)]` to the crate attributes to enable
+   = 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
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/mir/issue-83499-input-output-iteration-ice.rs b/tests/ui/mir/issue-83499-input-output-iteration-ice.rs
index 78e5c96180285..9277994d9b30f 100644
--- a/tests/ui/mir/issue-83499-input-output-iteration-ice.rs
+++ b/tests/ui/mir/issue-83499-input-output-iteration-ice.rs
@@ -5,6 +5,6 @@
 fn main() {}
 
 fn foo(_: Bar, ...) -> impl {}
-//~^ ERROR only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+//~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
 //~| ERROR cannot find type `Bar` in this scope
 //~| ERROR at least one trait must be specified
diff --git a/tests/ui/mir/issue-83499-input-output-iteration-ice.stderr b/tests/ui/mir/issue-83499-input-output-iteration-ice.stderr
index 80a8a94aea400..4a1aa49eb6e6f 100644
--- a/tests/ui/mir/issue-83499-input-output-iteration-ice.stderr
+++ b/tests/ui/mir/issue-83499-input-output-iteration-ice.stderr
@@ -1,4 +1,4 @@
-error: only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
   --> $DIR/issue-83499-input-output-iteration-ice.rs:7:16
    |
 LL | fn foo(_: Bar, ...) -> impl {}
diff --git a/tests/ui/parser/variadic-ffi-semantic-restrictions.rs b/tests/ui/parser/variadic-ffi-semantic-restrictions.rs
index 1cd6d13d56b6b..e7a0248cffab9 100644
--- a/tests/ui/parser/variadic-ffi-semantic-restrictions.rs
+++ b/tests/ui/parser/variadic-ffi-semantic-restrictions.rs
@@ -4,29 +4,29 @@
 fn main() {}
 
 fn f1_1(x: isize, ...) {}
-//~^ ERROR only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+//~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
 
 fn f1_2(...) {}
-//~^ ERROR only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+//~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
 
 extern "C" fn f2_1(x: isize, ...) {}
-//~^ ERROR only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+//~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
 
 extern "C" fn f2_2(...) {}
-//~^ ERROR only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+//~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
 
 extern "C" fn f2_3(..., x: isize) {}
-//~^ ERROR only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+//~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
 //~| ERROR `...` must be the last argument of a C-variadic function
 
 extern "C" fn f3_1(x: isize, ...) {}
-//~^ ERROR only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+//~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
 
 extern "C" fn f3_2(...) {}
-//~^ ERROR only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+//~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
 
 extern "C" fn f3_3(..., x: isize) {}
-//~^ ERROR only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+//~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
 //~| ERROR `...` must be the last argument of a C-variadic function
 
 const unsafe extern "C" fn f4_1(x: isize, ...) {}
@@ -35,12 +35,12 @@ const unsafe extern "C" fn f4_1(x: isize, ...) {}
 
 const extern "C" fn f4_2(x: isize, ...) {}
 //~^ ERROR functions cannot be both `const` and C-variadic
-//~| ERROR only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+//~| ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
 //~| ERROR destructor of `VaListImpl<'_>` cannot be evaluated at compile-time
 
 const extern "C" fn f4_3(..., x: isize, ...) {}
 //~^ ERROR functions cannot be both `const` and C-variadic
-//~| ERROR only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+//~| ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
 //~| ERROR `...` must be the last argument of a C-variadic function
 
 extern "C" {
@@ -52,34 +52,34 @@ struct X;
 
 impl X {
     fn i_f1(x: isize, ...) {}
-    //~^ ERROR only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+    //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
     fn i_f2(...) {}
-    //~^ ERROR only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+    //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
     fn i_f3(..., x: isize, ...) {}
-    //~^ ERROR only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+    //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
     //~| ERROR `...` must be the last argument of a C-variadic function
     fn i_f4(..., x: isize, ...) {}
-    //~^ ERROR only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+    //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
     //~| ERROR `...` must be the last argument of a C-variadic function
     const fn i_f5(x: isize, ...) {}
-    //~^ ERROR only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+    //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
     //~| ERROR functions cannot be both `const` and C-variadic
     //~| ERROR destructor of `VaListImpl<'_>` cannot be evaluated at compile-time
 }
 
 trait T {
     fn t_f1(x: isize, ...) {}
-    //~^ ERROR only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+    //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
     fn t_f2(x: isize, ...);
-    //~^ ERROR only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+    //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
     fn t_f3(...) {}
-    //~^ ERROR only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+    //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
     fn t_f4(...);
-    //~^ ERROR only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+    //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
     fn t_f5(..., x: isize) {}
-    //~^ ERROR only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+    //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
     //~| ERROR `...` must be the last argument of a C-variadic function
     fn t_f6(..., x: isize);
-    //~^ ERROR only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+    //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
     //~| ERROR `...` must be the last argument of a C-variadic function
 }
diff --git a/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr b/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr
index b740cef020055..5379045967aa0 100644
--- a/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr
+++ b/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr
@@ -1,22 +1,22 @@
-error: only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
   --> $DIR/variadic-ffi-semantic-restrictions.rs:6:19
    |
 LL | fn f1_1(x: isize, ...) {}
    |                   ^^^
 
-error: only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
   --> $DIR/variadic-ffi-semantic-restrictions.rs:9:9
    |
 LL | fn f1_2(...) {}
    |         ^^^
 
-error: only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
   --> $DIR/variadic-ffi-semantic-restrictions.rs:12:30
    |
 LL | extern "C" fn f2_1(x: isize, ...) {}
    |                              ^^^
 
-error: only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
   --> $DIR/variadic-ffi-semantic-restrictions.rs:15:20
    |
 LL | extern "C" fn f2_2(...) {}
@@ -28,19 +28,19 @@ error: `...` must be the last argument of a C-variadic function
 LL | extern "C" fn f2_3(..., x: isize) {}
    |                    ^^^
 
-error: only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
   --> $DIR/variadic-ffi-semantic-restrictions.rs:18:20
    |
 LL | extern "C" fn f2_3(..., x: isize) {}
    |                    ^^^
 
-error: only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
   --> $DIR/variadic-ffi-semantic-restrictions.rs:22:30
    |
 LL | extern "C" fn f3_1(x: isize, ...) {}
    |                              ^^^
 
-error: only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
   --> $DIR/variadic-ffi-semantic-restrictions.rs:25:20
    |
 LL | extern "C" fn f3_2(...) {}
@@ -52,7 +52,7 @@ error: `...` must be the last argument of a C-variadic function
 LL | extern "C" fn f3_3(..., x: isize) {}
    |                    ^^^
 
-error: only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
   --> $DIR/variadic-ffi-semantic-restrictions.rs:28:20
    |
 LL | extern "C" fn f3_3(..., x: isize) {}
@@ -70,7 +70,7 @@ error: functions cannot be both `const` and C-variadic
 LL | const extern "C" fn f4_2(x: isize, ...) {}
    | ^^^^^ `const` because of this      ^^^ C-variadic because of this
 
-error: only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
   --> $DIR/variadic-ffi-semantic-restrictions.rs:36:36
    |
 LL | const extern "C" fn f4_2(x: isize, ...) {}
@@ -91,7 +91,7 @@ LL | const extern "C" fn f4_3(..., x: isize, ...) {}
    | |                        C-variadic because of this
    | `const` because of this
 
-error: only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
   --> $DIR/variadic-ffi-semantic-restrictions.rs:41:26
    |
 LL | const extern "C" fn f4_3(..., x: isize, ...) {}
@@ -103,13 +103,13 @@ error: `...` must be the last argument of a C-variadic function
 LL |     fn e_f2(..., x: isize);
    |             ^^^
 
-error: only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
   --> $DIR/variadic-ffi-semantic-restrictions.rs:54:23
    |
 LL |     fn i_f1(x: isize, ...) {}
    |                       ^^^
 
-error: only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
   --> $DIR/variadic-ffi-semantic-restrictions.rs:56:13
    |
 LL |     fn i_f2(...) {}
@@ -121,7 +121,7 @@ error: `...` must be the last argument of a C-variadic function
 LL |     fn i_f3(..., x: isize, ...) {}
    |             ^^^
 
-error: only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
   --> $DIR/variadic-ffi-semantic-restrictions.rs:58:13
    |
 LL |     fn i_f3(..., x: isize, ...) {}
@@ -133,7 +133,7 @@ error: `...` must be the last argument of a C-variadic function
 LL |     fn i_f4(..., x: isize, ...) {}
    |             ^^^
 
-error: only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
   --> $DIR/variadic-ffi-semantic-restrictions.rs:61:13
    |
 LL |     fn i_f4(..., x: isize, ...) {}
@@ -147,31 +147,31 @@ LL |     const fn i_f5(x: isize, ...) {}
    |     |
    |     `const` because of this
 
-error: only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
   --> $DIR/variadic-ffi-semantic-restrictions.rs:64:29
    |
 LL |     const fn i_f5(x: isize, ...) {}
    |                             ^^^
 
-error: only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
   --> $DIR/variadic-ffi-semantic-restrictions.rs:71:23
    |
 LL |     fn t_f1(x: isize, ...) {}
    |                       ^^^
 
-error: only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
   --> $DIR/variadic-ffi-semantic-restrictions.rs:73:23
    |
 LL |     fn t_f2(x: isize, ...);
    |                       ^^^
 
-error: only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
   --> $DIR/variadic-ffi-semantic-restrictions.rs:75:13
    |
 LL |     fn t_f3(...) {}
    |             ^^^
 
-error: only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
   --> $DIR/variadic-ffi-semantic-restrictions.rs:77:13
    |
 LL |     fn t_f4(...);
@@ -183,7 +183,7 @@ error: `...` must be the last argument of a C-variadic function
 LL |     fn t_f5(..., x: isize) {}
    |             ^^^
 
-error: only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
   --> $DIR/variadic-ffi-semantic-restrictions.rs:79:13
    |
 LL |     fn t_f5(..., x: isize) {}
@@ -195,7 +195,7 @@ error: `...` must be the last argument of a C-variadic function
 LL |     fn t_f6(..., x: isize);
    |             ^^^
 
-error: only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
+error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
   --> $DIR/variadic-ffi-semantic-restrictions.rs:82:13
    |
 LL |     fn t_f6(..., x: isize);

From 6f0ebdb71a1d4f0fced5b10f1ddbbd227042bd5e Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Tue, 2 Sep 2025 11:35:25 +0300
Subject: [PATCH 0403/1889] Migrate more things in the new solver to specific
 `DefId`s

---
 compiler/rustc_middle/src/ty/context.rs       | 28 +++++++-
 .../rustc_next_trait_solver/src/coherence.rs  | 16 ++++-
 .../rustc_next_trait_solver/src/delegate.rs   |  2 +-
 .../src/solve/assembly/mod.rs                 |  2 +-
 .../src/solve/assembly/structural_traits.rs   |  6 +-
 .../src/solve/effect_goals.rs                 | 10 +--
 .../src/solve/eval_ctxt/mod.rs                |  2 +-
 .../src/solve/normalizes_to/mod.rs            | 21 +++---
 .../src/solve/trait_goals.rs                  |  6 +-
 compiler/rustc_type_ir/src/fast_reject.rs     | 14 ++--
 compiler/rustc_type_ir/src/inherent.rs        | 30 +++++---
 compiler/rustc_type_ir/src/interner.rs        | 70 +++++++++++--------
 compiler/rustc_type_ir/src/lang_items.rs      |  5 ++
 compiler/rustc_type_ir/src/relate.rs          |  4 +-
 compiler/rustc_type_ir/src/solve/mod.rs       |  2 +-
 compiler/rustc_type_ir/src/ty_kind.rs         | 12 ++--
 compiler/rustc_type_ir/src/ty_kind/closure.rs |  4 +-
 17 files changed, 154 insertions(+), 80 deletions(-)

diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 5dbbc7297ab6e..07cfc87250bfc 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -52,7 +52,7 @@ use rustc_session::{Limit, Session};
 use rustc_span::def_id::{CRATE_DEF_ID, DefPathHash, StableCrateId};
 use rustc_span::{DUMMY_SP, Ident, Span, Symbol, kw, sym};
 use rustc_type_ir::TyKind::*;
-use rustc_type_ir::lang_items::{SolverLangItem, SolverTraitLangItem};
+use rustc_type_ir::lang_items::{SolverAdtLangItem, SolverLangItem, SolverTraitLangItem};
 pub use rustc_type_ir::lift::Lift;
 use rustc_type_ir::{
     CollectAndApply, Interner, TypeFlags, TypeFoldable, WithCachedTypeInfo, elaborate, search_graph,
@@ -94,6 +94,13 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
     type DefId = DefId;
     type LocalDefId = LocalDefId;
     type TraitId = DefId;
+    type ForeignId = DefId;
+    type FunctionId = DefId;
+    type ClosureId = DefId;
+    type CoroutineClosureId = DefId;
+    type CoroutineId = DefId;
+    type AdtId = DefId;
+    type ImplId = DefId;
     type Span = Span;
 
     type GenericArgs = ty::GenericArgsRef<'tcx>;
@@ -492,6 +499,10 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
         self.require_lang_item(solver_trait_lang_item_to_lang_item(lang_item), DUMMY_SP)
     }
 
+    fn require_adt_lang_item(self, lang_item: SolverAdtLangItem) -> DefId {
+        self.require_lang_item(solver_adt_lang_item_to_lang_item(lang_item), DUMMY_SP)
+    }
+
     fn is_lang_item(self, def_id: DefId, lang_item: SolverLangItem) -> bool {
         self.is_lang_item(def_id, solver_lang_item_to_lang_item(lang_item))
     }
@@ -500,6 +511,10 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
         self.is_lang_item(def_id, solver_trait_lang_item_to_lang_item(lang_item))
     }
 
+    fn is_adt_lang_item(self, def_id: DefId, lang_item: SolverAdtLangItem) -> bool {
+        self.is_lang_item(def_id, solver_adt_lang_item_to_lang_item(lang_item))
+    }
+
     fn is_default_trait(self, def_id: DefId) -> bool {
         self.is_default_trait(def_id)
     }
@@ -512,6 +527,10 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
         lang_item_to_solver_trait_lang_item(self.lang_items().from_def_id(def_id)?)
     }
 
+    fn as_adt_lang_item(self, def_id: DefId) -> Option<SolverAdtLangItem> {
+        lang_item_to_solver_adt_lang_item(self.lang_items().from_def_id(def_id)?)
+    }
+
     fn associated_type_def_ids(self, def_id: DefId) -> impl IntoIterator<Item = DefId> {
         self.associated_items(def_id)
             .in_definition_order()
@@ -772,6 +791,13 @@ bidirectional_lang_item_map! {
     DynMetadata,
     FutureOutput,
     Metadata,
+// tidy-alphabetical-end
+}
+
+bidirectional_lang_item_map! {
+    SolverAdtLangItem, lang_item_to_solver_adt_lang_item, solver_adt_lang_item_to_lang_item;
+
+// tidy-alphabetical-start
     Option,
     Poll,
 // tidy-alphabetical-end
diff --git a/compiler/rustc_next_trait_solver/src/coherence.rs b/compiler/rustc_next_trait_solver/src/coherence.rs
index 79219b34e2907..b949deb119269 100644
--- a/compiler/rustc_next_trait_solver/src/coherence.rs
+++ b/compiler/rustc_next_trait_solver/src/coherence.rs
@@ -435,7 +435,21 @@ where
                 }
             }
             ty::Error(_) => ControlFlow::Break(OrphanCheckEarlyExit::LocalTy(ty)),
-            ty::Closure(did, ..) | ty::CoroutineClosure(did, ..) | ty::Coroutine(did, ..) => {
+            ty::Closure(did, ..) => {
+                if self.def_id_is_local(did) {
+                    ControlFlow::Break(OrphanCheckEarlyExit::LocalTy(ty))
+                } else {
+                    self.found_non_local_ty(ty)
+                }
+            }
+            ty::CoroutineClosure(did, ..) => {
+                if self.def_id_is_local(did) {
+                    ControlFlow::Break(OrphanCheckEarlyExit::LocalTy(ty))
+                } else {
+                    self.found_non_local_ty(ty)
+                }
+            }
+            ty::Coroutine(did, ..) => {
                 if self.def_id_is_local(did) {
                     ControlFlow::Break(OrphanCheckEarlyExit::LocalTy(ty))
                 } else {
diff --git a/compiler/rustc_next_trait_solver/src/delegate.rs b/compiler/rustc_next_trait_solver/src/delegate.rs
index 7b932010d498a..a7ecbfcb7c4fd 100644
--- a/compiler/rustc_next_trait_solver/src/delegate.rs
+++ b/compiler/rustc_next_trait_solver/src/delegate.rs
@@ -76,7 +76,7 @@ pub trait SolverDelegate: Deref<Target = Self::Infcx> + Sized {
         &self,
         goal_trait_ref: ty::TraitRef<Self::Interner>,
         trait_assoc_def_id: <Self::Interner as Interner>::DefId,
-        impl_def_id: <Self::Interner as Interner>::DefId,
+        impl_def_id: <Self::Interner as Interner>::ImplId,
     ) -> Result<
         Option<<Self::Interner as Interner>::DefId>,
         <Self::Interner as Interner>::ErrorGuaranteed,
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 be7e4dd4cdaf5..e3cf0330b14a0 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
@@ -186,7 +186,7 @@ where
     fn consider_impl_candidate(
         ecx: &mut EvalCtxt<'_, D>,
         goal: Goal<I, Self>,
-        impl_def_id: I::DefId,
+        impl_def_id: I::ImplId,
     ) -> Result<Candidate<I>, NoSolution>;
 
     /// If the predicate contained an error, we want to avoid emitting unnecessary trait
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 7c5940828daa9..f6eab286ba70b 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
@@ -605,7 +605,7 @@ fn coroutine_closure_to_certain_coroutine<I: Interner>(
     cx: I,
     goal_kind: ty::ClosureKind,
     goal_region: I::Region,
-    def_id: I::DefId,
+    def_id: I::CoroutineClosureId,
     args: ty::CoroutineClosureArgs<I>,
     sig: ty::CoroutineClosureSignature<I>,
 ) -> I::Ty {
@@ -629,7 +629,7 @@ fn coroutine_closure_to_ambiguous_coroutine<I: Interner>(
     cx: I,
     goal_kind: ty::ClosureKind,
     goal_region: I::Region,
-    def_id: I::DefId,
+    def_id: I::CoroutineClosureId,
     args: ty::CoroutineClosureArgs<I>,
     sig: ty::CoroutineClosureSignature<I>,
 ) -> I::Ty {
@@ -664,7 +664,7 @@ fn coroutine_closure_to_ambiguous_coroutine<I: Interner>(
 pub(in crate::solve) fn extract_fn_def_from_const_callable<I: Interner>(
     cx: I,
     self_ty: I::Ty,
-) -> Result<(ty::Binder<I, (I::FnInputTys, I::Ty)>, I::DefId, I::GenericArgs), NoSolution> {
+) -> Result<(ty::Binder<I, (I::FnInputTys, I::Ty)>, I::FunctionId, I::GenericArgs), NoSolution> {
     match self_ty.kind() {
         ty::FnDef(def_id, args) => {
             let sig = cx.fn_sig(def_id);
diff --git a/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs b/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
index 229345065b195..6646857a13682 100644
--- a/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
@@ -123,7 +123,7 @@ where
     fn consider_impl_candidate(
         ecx: &mut EvalCtxt<'_, D>,
         goal: Goal<I, Self>,
-        impl_def_id: I::DefId,
+        impl_def_id: I::ImplId,
     ) -> Result<Candidate<I>, NoSolution> {
         let cx = ecx.cx();
 
@@ -152,20 +152,20 @@ where
         }
 
         ecx.probe_trait_candidate(CandidateSource::Impl(impl_def_id)).enter(|ecx| {
-            let impl_args = ecx.fresh_args_for_item(impl_def_id);
+            let impl_args = ecx.fresh_args_for_item(impl_def_id.into());
             ecx.record_impl_args(impl_args);
             let impl_trait_ref = impl_trait_ref.instantiate(cx, impl_args);
 
             ecx.eq(goal.param_env, goal.predicate.trait_ref, impl_trait_ref)?;
             let where_clause_bounds = cx
-                .predicates_of(impl_def_id)
+                .predicates_of(impl_def_id.into())
                 .iter_instantiated(cx, impl_args)
                 .map(|pred| goal.with(cx, pred));
             ecx.add_goals(GoalSource::ImplWhereBound, where_clause_bounds);
 
             // For this impl to be `const`, we need to check its `[const]` bounds too.
             let const_conditions = cx
-                .const_conditions(impl_def_id)
+                .const_conditions(impl_def_id.into())
                 .iter_instantiated(cx, impl_args)
                 .map(|bound_trait_ref| {
                     goal.with(
@@ -240,7 +240,7 @@ where
             ty::TraitRef::new(cx, cx.require_trait_lang_item(SolverTraitLangItem::Sized), [output])
         });
         let requirements = cx
-            .const_conditions(def_id)
+            .const_conditions(def_id.into())
             .iter_instantiated(cx, args)
             .map(|trait_ref| {
                 (
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
index 4f87902e46e95..606fbcab4b3b1 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
@@ -1122,7 +1122,7 @@ where
         &self,
         goal_trait_ref: ty::TraitRef<I>,
         trait_assoc_def_id: I::DefId,
-        impl_def_id: I::DefId,
+        impl_def_id: I::ImplId,
     ) -> Result<Option<I::DefId>, I::ErrorGuaranteed> {
         self.delegate.fetch_eligible_assoc_item(goal_trait_ref, trait_assoc_def_id, impl_def_id)
     }
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 cfdf2007391ab..6e6be829f5212 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
@@ -5,7 +5,7 @@ mod opaque_types;
 
 use rustc_type_ir::fast_reject::DeepRejectCtxt;
 use rustc_type_ir::inherent::*;
-use rustc_type_ir::lang_items::{SolverLangItem, SolverTraitLangItem};
+use rustc_type_ir::lang_items::{SolverAdtLangItem, SolverLangItem, SolverTraitLangItem};
 use rustc_type_ir::solve::SizedTraitKind;
 use rustc_type_ir::{self as ty, Interner, NormalizesTo, PredicateKind, Upcast as _};
 use tracing::instrument;
@@ -193,7 +193,7 @@ where
     fn consider_impl_candidate(
         ecx: &mut EvalCtxt<'_, D>,
         goal: Goal<I, NormalizesTo<I>>,
-        impl_def_id: I::DefId,
+        impl_def_id: I::ImplId,
     ) -> Result<Candidate<I>, NoSolution> {
         let cx = ecx.cx();
 
@@ -217,13 +217,13 @@ where
         };
 
         ecx.probe_trait_candidate(CandidateSource::Impl(impl_def_id)).enter(|ecx| {
-            let impl_args = ecx.fresh_args_for_item(impl_def_id);
+            let impl_args = ecx.fresh_args_for_item(impl_def_id.into());
             let impl_trait_ref = impl_trait_ref.instantiate(cx, impl_args);
 
             ecx.eq(goal.param_env, goal_trait_ref, impl_trait_ref)?;
 
             let where_clause_bounds = cx
-                .predicates_of(impl_def_id)
+                .predicates_of(impl_def_id.into())
                 .iter_instantiated(cx, impl_args)
                 .map(|pred| goal.with(cx, pred));
             ecx.add_goals(GoalSource::ImplWhereBound, where_clause_bounds);
@@ -824,10 +824,10 @@ where
             // coroutine yield ty `Poll<Option<I>>`.
             let wrapped_expected_ty = Ty::new_adt(
                 cx,
-                cx.adt_def(cx.require_lang_item(SolverLangItem::Poll)),
+                cx.adt_def(cx.require_adt_lang_item(SolverAdtLangItem::Poll)),
                 cx.mk_args(&[Ty::new_adt(
                     cx,
-                    cx.adt_def(cx.require_lang_item(SolverLangItem::Option)),
+                    cx.adt_def(cx.require_adt_lang_item(SolverAdtLangItem::Option)),
                     cx.mk_args(&[expected_ty.into()]),
                 )
                 .into()]),
@@ -979,7 +979,7 @@ where
     fn translate_args(
         &mut self,
         goal: Goal<I, ty::NormalizesTo<I>>,
-        impl_def_id: I::DefId,
+        impl_def_id: I::ImplId,
         impl_args: I::GenericArgs,
         impl_trait_ref: rustc_type_ir::TraitRef<I>,
         target_container_def_id: I::DefId,
@@ -988,14 +988,15 @@ where
         Ok(if target_container_def_id == impl_trait_ref.def_id.into() {
             // Default value from the trait definition. No need to rebase.
             goal.predicate.alias.args
-        } else if target_container_def_id == impl_def_id {
+        } else if target_container_def_id == impl_def_id.into() {
             // Same impl, no need to fully translate, just a rebase from
             // the trait is sufficient.
             goal.predicate.alias.args.rebase_onto(cx, impl_trait_ref.def_id.into(), impl_args)
         } else {
             let target_args = self.fresh_args_for_item(target_container_def_id);
-            let target_trait_ref =
-                cx.impl_trait_ref(target_container_def_id).instantiate(cx, target_args);
+            let target_trait_ref = cx
+                .impl_trait_ref(target_container_def_id.try_into().unwrap())
+                .instantiate(cx, target_args);
             // Relate source impl to target impl by equating trait refs.
             self.eq(goal.param_env, impl_trait_ref, target_trait_ref)?;
             // Also add predicates since they may be needed to constrain the
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 cdcfebf29090d..3e720a47f32e7 100644
--- a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
@@ -54,7 +54,7 @@ where
     fn consider_impl_candidate(
         ecx: &mut EvalCtxt<'_, D>,
         goal: Goal<I, TraitPredicate<I>>,
-        impl_def_id: I::DefId,
+        impl_def_id: I::ImplId,
     ) -> Result<Candidate<I>, NoSolution> {
         let cx = ecx.cx();
 
@@ -91,13 +91,13 @@ where
         };
 
         ecx.probe_trait_candidate(CandidateSource::Impl(impl_def_id)).enter(|ecx| {
-            let impl_args = ecx.fresh_args_for_item(impl_def_id);
+            let impl_args = ecx.fresh_args_for_item(impl_def_id.into());
             ecx.record_impl_args(impl_args);
             let impl_trait_ref = impl_trait_ref.instantiate(cx, impl_args);
 
             ecx.eq(goal.param_env, goal.predicate.trait_ref, impl_trait_ref)?;
             let where_clause_bounds = cx
-                .predicates_of(impl_def_id)
+                .predicates_of(impl_def_id.into())
                 .iter_instantiated(cx, impl_args)
                 .map(|pred| goal.with(cx, pred));
             ecx.add_goals(GoalSource::ImplWhereBound, where_clause_bounds);
diff --git a/compiler/rustc_type_ir/src/fast_reject.rs b/compiler/rustc_type_ir/src/fast_reject.rs
index 5a05630e1bd11..ed6416a7f55f2 100644
--- a/compiler/rustc_type_ir/src/fast_reject.rs
+++ b/compiler/rustc_type_ir/src/fast_reject.rs
@@ -122,7 +122,7 @@ pub fn simplify_type<I: Interner>(
         ty::Int(int_type) => Some(SimplifiedType::Int(int_type)),
         ty::Uint(uint_type) => Some(SimplifiedType::Uint(uint_type)),
         ty::Float(float_type) => Some(SimplifiedType::Float(float_type)),
-        ty::Adt(def, _) => Some(SimplifiedType::Adt(def.def_id())),
+        ty::Adt(def, _) => Some(SimplifiedType::Adt(def.def_id().into())),
         ty::Str => Some(SimplifiedType::Str),
         ty::Array(..) => Some(SimplifiedType::Array),
         ty::Slice(..) => Some(SimplifiedType::Slice),
@@ -135,11 +135,11 @@ pub fn simplify_type<I: Interner>(
             _ => Some(SimplifiedType::MarkerTraitObject),
         },
         ty::Ref(_, _, mutbl) => Some(SimplifiedType::Ref(mutbl)),
-        ty::FnDef(def_id, _) | ty::Closure(def_id, _) | ty::CoroutineClosure(def_id, _) => {
-            Some(SimplifiedType::Closure(def_id))
-        }
-        ty::Coroutine(def_id, _) => Some(SimplifiedType::Coroutine(def_id)),
-        ty::CoroutineWitness(def_id, _) => Some(SimplifiedType::CoroutineWitness(def_id)),
+        ty::FnDef(def_id, _) => Some(SimplifiedType::Closure(def_id.into())),
+        ty::Closure(def_id, _) => Some(SimplifiedType::Closure(def_id.into())),
+        ty::CoroutineClosure(def_id, _) => Some(SimplifiedType::Closure(def_id.into())),
+        ty::Coroutine(def_id, _) => Some(SimplifiedType::Coroutine(def_id.into())),
+        ty::CoroutineWitness(def_id, _) => Some(SimplifiedType::CoroutineWitness(def_id.into())),
         ty::Never => Some(SimplifiedType::Never),
         ty::Tuple(tys) => Some(SimplifiedType::Tuple(tys.len())),
         ty::FnPtr(sig_tys, _hdr) => {
@@ -161,7 +161,7 @@ pub fn simplify_type<I: Interner>(
             }
             TreatParams::AsRigid | TreatParams::InstantiateWithInfer => None,
         },
-        ty::Foreign(def_id) => Some(SimplifiedType::Foreign(def_id)),
+        ty::Foreign(def_id) => Some(SimplifiedType::Foreign(def_id.into())),
         ty::Error(_) => Some(SimplifiedType::Error),
         ty::Bound(..) | ty::Infer(_) => None,
     }
diff --git a/compiler/rustc_type_ir/src/inherent.rs b/compiler/rustc_type_ir/src/inherent.rs
index 64063b1a36509..ecfc05a6e20e7 100644
--- a/compiler/rustc_type_ir/src/inherent.rs
+++ b/compiler/rustc_type_ir/src/inherent.rs
@@ -74,7 +74,7 @@ pub trait Ty<I: Interner<Ty = Self>>:
 
     fn new_adt(interner: I, adt_def: I::AdtDef, args: I::GenericArgs) -> Self;
 
-    fn new_foreign(interner: I, def_id: I::DefId) -> Self;
+    fn new_foreign(interner: I, def_id: I::ForeignId) -> Self;
 
     fn new_dynamic(
         interner: I,
@@ -83,17 +83,21 @@ pub trait Ty<I: Interner<Ty = Self>>:
         kind: ty::DynKind,
     ) -> Self;
 
-    fn new_coroutine(interner: I, def_id: I::DefId, args: I::GenericArgs) -> Self;
+    fn new_coroutine(interner: I, def_id: I::CoroutineId, args: I::GenericArgs) -> Self;
 
-    fn new_coroutine_closure(interner: I, def_id: I::DefId, args: I::GenericArgs) -> Self;
+    fn new_coroutine_closure(
+        interner: I,
+        def_id: I::CoroutineClosureId,
+        args: I::GenericArgs,
+    ) -> Self;
 
-    fn new_closure(interner: I, def_id: I::DefId, args: I::GenericArgs) -> Self;
+    fn new_closure(interner: I, def_id: I::ClosureId, args: I::GenericArgs) -> Self;
 
-    fn new_coroutine_witness(interner: I, def_id: I::DefId, args: I::GenericArgs) -> Self;
+    fn new_coroutine_witness(interner: I, def_id: I::CoroutineId, args: I::GenericArgs) -> Self;
 
     fn new_coroutine_witness_for_coroutine(
         interner: I,
-        def_id: I::DefId,
+        def_id: I::CoroutineId,
         coroutine_args: I::GenericArgs,
     ) -> Self;
 
@@ -112,7 +116,7 @@ pub trait Ty<I: Interner<Ty = Self>>:
         It: Iterator<Item = T>,
         T: CollectAndApply<Self, Self>;
 
-    fn new_fn_def(interner: I, def_id: I::DefId, args: I::GenericArgs) -> Self;
+    fn new_fn_def(interner: I, def_id: I::FunctionId, args: I::GenericArgs) -> Self;
 
     fn new_fn_ptr(interner: I, sig: ty::Binder<I, ty::FnSig<I>>) -> Self;
 
@@ -599,7 +603,7 @@ pub trait ParamLike: Copy + Debug + Hash + Eq {
 }
 
 pub trait AdtDef<I: Interner>: Copy + Debug + Hash + Eq {
-    fn def_id(self) -> I::DefId;
+    fn def_id(self) -> I::AdtId;
 
     fn is_struct(self) -> bool;
 
@@ -646,6 +650,16 @@ pub trait DefId<I: Interner>: Copy + Debug + Hash + Eq + TypeFoldable<I> {
     fn as_local(self) -> Option<I::LocalDefId>;
 }
 
+pub trait SpecificDefId<I: Interner>:
+    DefId<I> + Into<I::DefId> + TryFrom<I::DefId, Error: std::fmt::Debug>
+{
+}
+
+impl<I: Interner, T: DefId<I> + Into<I::DefId> + TryFrom<I::DefId, Error: std::fmt::Debug>>
+    SpecificDefId<I> for T
+{
+}
+
 pub trait BoundExistentialPredicates<I: Interner>:
     Copy + Debug + Hash + Eq + Relate<I> + SliceLike<Item = ty::Binder<I, ty::ExistentialPredicate<I>>>
 {
diff --git a/compiler/rustc_type_ir/src/interner.rs b/compiler/rustc_type_ir/src/interner.rs
index 21fe7879b298f..03a8f5e74b4b7 100644
--- a/compiler/rustc_type_ir/src/interner.rs
+++ b/compiler/rustc_type_ir/src/interner.rs
@@ -8,7 +8,7 @@ use rustc_index::bit_set::DenseBitSet;
 use crate::fold::TypeFoldable;
 use crate::inherent::*;
 use crate::ir_print::IrPrint;
-use crate::lang_items::{SolverLangItem, SolverTraitLangItem};
+use crate::lang_items::{SolverAdtLangItem, SolverLangItem, SolverTraitLangItem};
 use crate::relate::Relate;
 use crate::solve::{CanonicalInput, ExternalConstraintsData, PredefinedOpaquesData, QueryResult};
 use crate::visit::{Flags, TypeVisitable};
@@ -38,13 +38,20 @@ pub trait Interner:
 
     type DefId: DefId<Self>;
     type LocalDefId: Copy + Debug + Hash + Eq + Into<Self::DefId> + TypeFoldable<Self>;
-    /// A `DefId` of a trait.
-    ///
-    /// In rustc this is just a `DefId`, but rust-analyzer uses different types for different items.
-    ///
-    /// Note: The `TryFrom<DefId>` always succeeds (in rustc), so don't use it to check if some `DefId`
-    /// is a trait!
-    type TraitId: DefId<Self> + Into<Self::DefId> + TryFrom<Self::DefId, Error: std::fmt::Debug>;
+    // Various more specific `DefId`s.
+    //
+    // rustc just defines them all to be `DefId`, but rust-analyzer uses different types so this is convenient for it.
+    //
+    // Note: The `TryFrom<DefId>` always succeeds (in rustc), so don't use it to check if some `DefId`
+    // is of some specific type!
+    type TraitId: SpecificDefId<Self>;
+    type ForeignId: SpecificDefId<Self>;
+    type FunctionId: SpecificDefId<Self>;
+    type ClosureId: SpecificDefId<Self>;
+    type CoroutineClosureId: SpecificDefId<Self>;
+    type CoroutineId: SpecificDefId<Self>;
+    type AdtId: SpecificDefId<Self>;
+    type ImplId: SpecificDefId<Self>;
     type Span: Span<Self>;
 
     type GenericArgs: GenericArgs<Self>;
@@ -196,7 +203,7 @@ pub trait Interner:
     -> ty::EarlyBinder<Self, Self::Ty>;
 
     type AdtDef: AdtDef<Self>;
-    fn adt_def(self, adt_def_id: Self::DefId) -> Self::AdtDef;
+    fn adt_def(self, adt_def_id: Self::AdtId) -> Self::AdtDef;
 
     fn alias_ty_kind(self, alias: ty::AliasTy<Self>) -> ty::AliasTyKind;
 
@@ -237,17 +244,17 @@ pub trait Interner:
 
     fn coroutine_hidden_types(
         self,
-        def_id: Self::DefId,
+        def_id: Self::CoroutineId,
     ) -> ty::EarlyBinder<Self, ty::Binder<Self, ty::CoroutineWitnessTypes<Self>>>;
 
     fn fn_sig(
         self,
-        def_id: Self::DefId,
+        def_id: Self::FunctionId,
     ) -> ty::EarlyBinder<Self, ty::Binder<Self, ty::FnSig<Self>>>;
 
-    fn coroutine_movability(self, def_id: Self::DefId) -> Movability;
+    fn coroutine_movability(self, def_id: Self::CoroutineId) -> Movability;
 
-    fn coroutine_for_closure(self, def_id: Self::DefId) -> Self::DefId;
+    fn coroutine_for_closure(self, def_id: Self::CoroutineClosureId) -> Self::CoroutineId;
 
     fn generics_require_sized_self(self, def_id: Self::DefId) -> bool;
 
@@ -290,11 +297,11 @@ pub trait Interner:
     /// and filtering them to the outlives predicates. This is purely for performance.
     fn impl_super_outlives(
         self,
-        impl_def_id: Self::DefId,
+        impl_def_id: Self::ImplId,
     ) -> ty::EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>>;
 
-    fn impl_is_const(self, def_id: Self::DefId) -> bool;
-    fn fn_is_const(self, def_id: Self::DefId) -> bool;
+    fn impl_is_const(self, def_id: Self::ImplId) -> bool;
+    fn fn_is_const(self, def_id: Self::FunctionId) -> bool;
     fn alias_has_const_conditions(self, def_id: Self::DefId) -> bool;
     fn const_conditions(
         self,
@@ -305,42 +312,49 @@ pub trait Interner:
         def_id: Self::DefId,
     ) -> ty::EarlyBinder<Self, impl IntoIterator<Item = ty::Binder<Self, ty::TraitRef<Self>>>>;
 
-    fn impl_self_is_guaranteed_unsized(self, def_id: Self::DefId) -> bool;
+    fn impl_self_is_guaranteed_unsized(self, def_id: Self::ImplId) -> bool;
 
-    fn has_target_features(self, def_id: Self::DefId) -> bool;
+    fn has_target_features(self, def_id: Self::FunctionId) -> bool;
 
     fn require_lang_item(self, lang_item: SolverLangItem) -> Self::DefId;
 
     fn require_trait_lang_item(self, lang_item: SolverTraitLangItem) -> Self::TraitId;
 
+    fn require_adt_lang_item(self, lang_item: SolverAdtLangItem) -> Self::AdtId;
+
     fn is_lang_item(self, def_id: Self::DefId, lang_item: SolverLangItem) -> bool;
 
     fn is_trait_lang_item(self, def_id: Self::TraitId, lang_item: SolverTraitLangItem) -> bool;
 
+    fn is_adt_lang_item(self, def_id: Self::AdtId, lang_item: SolverAdtLangItem) -> bool;
+
     fn is_default_trait(self, def_id: Self::TraitId) -> bool;
 
     fn as_lang_item(self, def_id: Self::DefId) -> Option<SolverLangItem>;
 
     fn as_trait_lang_item(self, def_id: Self::TraitId) -> Option<SolverTraitLangItem>;
 
+    fn as_adt_lang_item(self, def_id: Self::AdtId) -> Option<SolverAdtLangItem>;
+
     fn associated_type_def_ids(self, def_id: Self::DefId) -> impl IntoIterator<Item = Self::DefId>;
 
     fn for_each_relevant_impl(
         self,
         trait_def_id: Self::TraitId,
         self_ty: Self::Ty,
-        f: impl FnMut(Self::DefId),
+        f: impl FnMut(Self::ImplId),
     );
 
     fn has_item_definition(self, def_id: Self::DefId) -> bool;
 
-    fn impl_specializes(self, impl_def_id: Self::DefId, victim_def_id: Self::DefId) -> bool;
+    fn impl_specializes(self, impl_def_id: Self::ImplId, victim_def_id: Self::ImplId) -> bool;
 
-    fn impl_is_default(self, impl_def_id: Self::DefId) -> bool;
+    fn impl_is_default(self, impl_def_id: Self::ImplId) -> bool;
 
-    fn impl_trait_ref(self, impl_def_id: Self::DefId) -> ty::EarlyBinder<Self, ty::TraitRef<Self>>;
+    fn impl_trait_ref(self, impl_def_id: Self::ImplId)
+    -> ty::EarlyBinder<Self, ty::TraitRef<Self>>;
 
-    fn impl_polarity(self, impl_def_id: Self::DefId) -> ty::ImplPolarity;
+    fn impl_polarity(self, impl_def_id: Self::ImplId) -> ty::ImplPolarity;
 
     fn trait_is_auto(self, trait_def_id: Self::TraitId) -> bool;
 
@@ -361,13 +375,13 @@ pub trait Interner:
 
     fn delay_bug(self, msg: impl ToString) -> Self::ErrorGuaranteed;
 
-    fn is_general_coroutine(self, coroutine_def_id: Self::DefId) -> bool;
-    fn coroutine_is_async(self, coroutine_def_id: Self::DefId) -> bool;
-    fn coroutine_is_gen(self, coroutine_def_id: Self::DefId) -> bool;
-    fn coroutine_is_async_gen(self, coroutine_def_id: Self::DefId) -> bool;
+    fn is_general_coroutine(self, coroutine_def_id: Self::CoroutineId) -> bool;
+    fn coroutine_is_async(self, coroutine_def_id: Self::CoroutineId) -> bool;
+    fn coroutine_is_gen(self, coroutine_def_id: Self::CoroutineId) -> bool;
+    fn coroutine_is_async_gen(self, coroutine_def_id: Self::CoroutineId) -> bool;
 
     type UnsizingParams: Deref<Target = DenseBitSet<u32>>;
-    fn unsizing_params_for_adt(self, adt_def_id: Self::DefId) -> Self::UnsizingParams;
+    fn unsizing_params_for_adt(self, adt_def_id: Self::AdtId) -> Self::UnsizingParams;
 
     fn anonymize_bound_vars<T: TypeFoldable<Self>>(
         self,
diff --git a/compiler/rustc_type_ir/src/lang_items.rs b/compiler/rustc_type_ir/src/lang_items.rs
index 31f8f5be588f6..5f503d8b912e0 100644
--- a/compiler/rustc_type_ir/src/lang_items.rs
+++ b/compiler/rustc_type_ir/src/lang_items.rs
@@ -11,6 +11,11 @@ pub enum SolverLangItem {
     DynMetadata,
     FutureOutput,
     Metadata,
+    // tidy-alphabetical-end
+}
+
+pub enum SolverAdtLangItem {
+    // tidy-alphabetical-start
     Option,
     Poll,
     // tidy-alphabetical-end
diff --git a/compiler/rustc_type_ir/src/relate.rs b/compiler/rustc_type_ir/src/relate.rs
index 223230fde9e72..690a5f65e0848 100644
--- a/compiler/rustc_type_ir/src/relate.rs
+++ b/compiler/rustc_type_ir/src/relate.rs
@@ -405,7 +405,7 @@ pub fn structurally_relate_tys<I: Interner, R: TypeRelation<I>>(
             Ok(if a_args.is_empty() {
                 a
             } else {
-                let args = relation.relate_item_args(a_def.def_id(), a_args, b_args)?;
+                let args = relation.relate_item_args(a_def.def_id().into(), a_args, b_args)?;
                 if args == a_args { a } else { Ty::new_adt(cx, a_def, args) }
             })
         }
@@ -524,7 +524,7 @@ pub fn structurally_relate_tys<I: Interner, R: TypeRelation<I>>(
             Ok(if a_args.is_empty() {
                 a
             } else {
-                let args = relation.relate_item_args(a_def_id, a_args, b_args)?;
+                let args = relation.relate_item_args(a_def_id.into(), a_args, b_args)?;
                 if args == a_args { a } else { Ty::new_fn_def(cx, a_def_id, args) }
             })
         }
diff --git a/compiler/rustc_type_ir/src/solve/mod.rs b/compiler/rustc_type_ir/src/solve/mod.rs
index b6d362d77c444..b48a8f46ebef7 100644
--- a/compiler/rustc_type_ir/src/solve/mod.rs
+++ b/compiler/rustc_type_ir/src/solve/mod.rs
@@ -136,7 +136,7 @@ pub enum CandidateSource<I: Interner> {
     ///     let y = x.clone();
     /// }
     /// ```
-    Impl(I::DefId),
+    Impl(I::ImplId),
     /// A builtin impl generated by the compiler. When adding a new special
     /// trait, try to use actual impls whenever possible. Builtin impls should
     /// only be used in cases where the impl cannot be manually be written.
diff --git a/compiler/rustc_type_ir/src/ty_kind.rs b/compiler/rustc_type_ir/src/ty_kind.rs
index bde506ffd9385..225d85f79c3d1 100644
--- a/compiler/rustc_type_ir/src/ty_kind.rs
+++ b/compiler/rustc_type_ir/src/ty_kind.rs
@@ -101,7 +101,7 @@ pub enum TyKind<I: Interner> {
     Adt(I::AdtDef, I::GenericArgs),
 
     /// An unsized FFI type that is opaque to Rust. Written as `extern type T`.
-    Foreign(I::DefId),
+    Foreign(I::ForeignId),
 
     /// The pointee of a string slice. Written as `str`.
     Str,
@@ -137,7 +137,7 @@ pub enum TyKind<I: Interner> {
     /// fn foo() -> i32 { 1 }
     /// let bar = foo; // bar: fn() -> i32 {foo}
     /// ```
-    FnDef(I::DefId, I::GenericArgs),
+    FnDef(I::FunctionId, I::GenericArgs),
 
     /// A pointer to a function. Written as `fn() -> i32`.
     ///
@@ -172,21 +172,21 @@ pub enum TyKind<I: Interner> {
     /// Closure args contain both the - potentially instantiated - generic parameters
     /// of its parent and some synthetic parameters. See the documentation for
     /// `ClosureArgs` for more details.
-    Closure(I::DefId, I::GenericArgs),
+    Closure(I::ClosureId, I::GenericArgs),
 
     /// The anonymous type of a closure. Used to represent the type of `async |a| a`.
     ///
     /// Coroutine-closure args contain both the - potentially instantiated - generic
     /// parameters of its parent and some synthetic parameters. See the documentation
     /// for `CoroutineClosureArgs` for more details.
-    CoroutineClosure(I::DefId, I::GenericArgs),
+    CoroutineClosure(I::CoroutineClosureId, I::GenericArgs),
 
     /// The anonymous type of a coroutine. Used to represent the type of
     /// `|a| yield a`.
     ///
     /// For more info about coroutine args, visit the documentation for
     /// `CoroutineArgs`.
-    Coroutine(I::DefId, I::GenericArgs),
+    Coroutine(I::CoroutineId, I::GenericArgs),
 
     /// A type representing the types stored inside a coroutine.
     /// This should only appear as part of the `CoroutineArgs`.
@@ -211,7 +211,7 @@ pub enum TyKind<I: Interner> {
     /// }
     /// # ;
     /// ```
-    CoroutineWitness(I::DefId, I::GenericArgs),
+    CoroutineWitness(I::CoroutineId, I::GenericArgs),
 
     /// The never type `!`.
     Never,
diff --git a/compiler/rustc_type_ir/src/ty_kind/closure.rs b/compiler/rustc_type_ir/src/ty_kind/closure.rs
index a2e16d917a9e9..3a6d1acfa8d93 100644
--- a/compiler/rustc_type_ir/src/ty_kind/closure.rs
+++ b/compiler/rustc_type_ir/src/ty_kind/closure.rs
@@ -391,7 +391,7 @@ impl<I: Interner> CoroutineClosureSignature<I> {
         cx: I,
         parent_args: I::GenericArgsSlice,
         coroutine_kind_ty: I::Ty,
-        coroutine_def_id: I::DefId,
+        coroutine_def_id: I::CoroutineId,
         tupled_upvars_ty: I::Ty,
     ) -> I::Ty {
         let coroutine_args = ty::CoroutineArgs::new(
@@ -418,7 +418,7 @@ impl<I: Interner> CoroutineClosureSignature<I> {
         self,
         cx: I,
         parent_args: I::GenericArgsSlice,
-        coroutine_def_id: I::DefId,
+        coroutine_def_id: I::CoroutineId,
         goal_kind: ty::ClosureKind,
         env_region: I::Region,
         closure_tupled_upvars_ty: I::Ty,

From 18fa6d917cb39758429d47015fc83e72445e2199 Mon Sep 17 00:00:00 2001
From: Nikita Popov <npopov@redhat.com>
Date: Tue, 2 Sep 2025 10:48:42 +0200
Subject: [PATCH 0404/1889] Remove some llvm workarounds

---
 library/stdarch/crates/core_arch/src/x86/avx512f.rs    | 8 ++------
 library/stdarch/crates/core_arch/src/x86_64/avx512f.rs | 8 ++------
 2 files changed, 4 insertions(+), 12 deletions(-)

diff --git a/library/stdarch/crates/core_arch/src/x86/avx512f.rs b/library/stdarch/crates/core_arch/src/x86/avx512f.rs
index 0803f2f81b215..52c6a11a43f0e 100644
--- a/library/stdarch/crates/core_arch/src/x86/avx512f.rs
+++ b/library/stdarch/crates/core_arch/src/x86/avx512f.rs
@@ -49621,9 +49621,7 @@ mod tests {
         assert_eq_m512i(r, e);
     }
 
-    // FIXME(llvm): https://github.com/llvm/llvm-project/issues/154492
-    //#[simd_test(enable = "avx512f")]
-    #[simd_test(enable = "avx512f,avx512vl")]
+    #[simd_test(enable = "avx512f")]
     unsafe fn test_mm512_mask_cvttps_epu32() {
         let a = _mm512_setr_ps(
             0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5,
@@ -49636,9 +49634,7 @@ mod tests {
         assert_eq_m512i(r, e);
     }
 
-    // FIXME(llvm): https://github.com/llvm/llvm-project/issues/154492
-    //#[simd_test(enable = "avx512f")]
-    #[simd_test(enable = "avx512f,avx512vl")]
+    #[simd_test(enable = "avx512f")]
     unsafe fn test_mm512_maskz_cvttps_epu32() {
         let a = _mm512_setr_ps(
             0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5, 8., 9.5, 10., 11.5, 12., 13.5, 14., 15.5,
diff --git a/library/stdarch/crates/core_arch/src/x86_64/avx512f.rs b/library/stdarch/crates/core_arch/src/x86_64/avx512f.rs
index a8dd340bd6605..934c9e2812c42 100644
--- a/library/stdarch/crates/core_arch/src/x86_64/avx512f.rs
+++ b/library/stdarch/crates/core_arch/src/x86_64/avx512f.rs
@@ -5311,9 +5311,7 @@ mod tests {
         assert_eq_m256i(r, e);
     }
 
-    // FIXME(llvm): https://github.com/llvm/llvm-project/issues/154492
-    //#[simd_test(enable = "avx512f")]
-    #[simd_test(enable = "avx512f,avx512vl")]
+    #[simd_test(enable = "avx512f")]
     unsafe fn test_mm512_mask_cvttpd_epu32() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let src = _mm256_set1_epi32(0);
@@ -5324,9 +5322,7 @@ mod tests {
         assert_eq_m256i(r, e);
     }
 
-    // FIXME(llvm): https://github.com/llvm/llvm-project/issues/154492
-    //#[simd_test(enable = "avx512f")]
-    #[simd_test(enable = "avx512f,avx512vl")]
+    #[simd_test(enable = "avx512f")]
     unsafe fn test_mm512_maskz_cvttpd_epu32() {
         let a = _mm512_setr_pd(0., -1.5, 2., -3.5, 4., -5.5, 6., -7.5);
         let r = _mm512_maskz_cvttpd_epu32(0, a);

From bb3598e481a752b85872fcbea9dab805907c2d81 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Tue, 2 Sep 2025 10:52:49 +0200
Subject: [PATCH 0405/1889] use `qemu-user` instead of `qemu-user-static` for
 loongarch CI

---
 .../ci/docker/loongarch64-unknown-linux-gnu/Dockerfile        | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/library/stdarch/ci/docker/loongarch64-unknown-linux-gnu/Dockerfile b/library/stdarch/ci/docker/loongarch64-unknown-linux-gnu/Dockerfile
index b5c6874ca52ed..e803dae1006a0 100644
--- a/library/stdarch/ci/docker/loongarch64-unknown-linux-gnu/Dockerfile
+++ b/library/stdarch/ci/docker/loongarch64-unknown-linux-gnu/Dockerfile
@@ -2,11 +2,11 @@ FROM ubuntu:25.10
 
 RUN apt-get update && \
     apt-get install -y --no-install-recommends \
-    gcc libc6-dev qemu-user-static ca-certificates \
+    gcc libc6-dev qemu-user ca-certificates \
     gcc-loongarch64-linux-gnu libc6-dev-loong64-cross
 
 
 ENV CARGO_TARGET_LOONGARCH64_UNKNOWN_LINUX_GNU_LINKER=loongarch64-linux-gnu-gcc \
-    CARGO_TARGET_LOONGARCH64_UNKNOWN_LINUX_GNU_RUNNER="qemu-loongarch64-static -cpu max -L /usr/loongarch64-linux-gnu" \
+    CARGO_TARGET_LOONGARCH64_UNKNOWN_LINUX_GNU_RUNNER="qemu-loongarch64 -cpu max -L /usr/loongarch64-linux-gnu" \
     OBJDUMP=loongarch64-linux-gnu-objdump \
     STDARCH_TEST_SKIP_FEATURE=frecipe

From 301655eafe56a4b5064adebd412becf94b59221c Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 2 Sep 2025 19:09:13 +1000
Subject: [PATCH 0406/1889] Revert introduction of `[workspace.dependencies]`.

This was done in #145740 and #145947. It is causing problems for people
using r-a on anything that uses the rustc-dev rustup package, e.g. Miri,
clippy.

This repository has lots of submodules and subtrees and various
different projects are carved out of pieces of it. It seems like
`[workspace.dependencies]` will just be more trouble than it's worth.
---
 Cargo.toml                                    | 27 -------------------
 compiler/rustc_abi/Cargo.toml                 |  4 +--
 compiler/rustc_ast/Cargo.toml                 | 10 +++----
 compiler/rustc_ast_lowering/Cargo.toml        |  4 +--
 compiler/rustc_ast_passes/Cargo.toml          |  4 +--
 compiler/rustc_ast_pretty/Cargo.toml          |  4 +--
 compiler/rustc_attr_parsing/Cargo.toml        |  2 +-
 compiler/rustc_borrowck/Cargo.toml            |  8 +++---
 compiler/rustc_builtin_macros/Cargo.toml      |  4 +--
 compiler/rustc_codegen_llvm/Cargo.toml        | 14 +++++-----
 compiler/rustc_codegen_ssa/Cargo.toml         | 14 +++++-----
 compiler/rustc_const_eval/Cargo.toml          |  6 ++---
 compiler/rustc_data_structures/Cargo.toml     | 18 ++++++-------
 compiler/rustc_driver_impl/Cargo.toml         |  6 ++---
 compiler/rustc_error_messages/Cargo.toml      |  2 +-
 compiler/rustc_errors/Cargo.toml              |  4 +--
 compiler/rustc_expand/Cargo.toml              |  4 +--
 compiler/rustc_feature/Cargo.toml             |  2 +-
 compiler/rustc_fluent_macro/Cargo.toml        |  4 +--
 compiler/rustc_fs_util/Cargo.toml             |  2 +-
 compiler/rustc_hir/Cargo.toml                 |  8 +++---
 compiler/rustc_hir_analysis/Cargo.toml        |  4 +--
 compiler/rustc_hir_typeck/Cargo.toml          |  4 +--
 compiler/rustc_incremental/Cargo.toml         |  4 +--
 compiler/rustc_index_macros/Cargo.toml        |  4 +--
 compiler/rustc_infer/Cargo.toml               |  4 +--
 compiler/rustc_interface/Cargo.toml           |  2 +-
 compiler/rustc_lexer/Cargo.toml               |  2 +-
 compiler/rustc_lint/Cargo.toml                |  2 +-
 compiler/rustc_llvm/Cargo.toml                |  2 +-
 compiler/rustc_log/Cargo.toml                 |  2 +-
 compiler/rustc_macros/Cargo.toml              |  4 +--
 compiler/rustc_metadata/Cargo.toml            | 10 +++----
 compiler/rustc_middle/Cargo.toml              | 12 ++++-----
 compiler/rustc_mir_build/Cargo.toml           |  6 ++---
 compiler/rustc_mir_dataflow/Cargo.toml        |  4 +--
 compiler/rustc_mir_transform/Cargo.toml       |  6 ++---
 compiler/rustc_monomorphize/Cargo.toml        |  4 +--
 compiler/rustc_next_trait_solver/Cargo.toml   |  4 +--
 compiler/rustc_parse/Cargo.toml               |  8 +++---
 compiler/rustc_parse_format/Cargo.toml        |  2 +-
 compiler/rustc_passes/Cargo.toml              |  2 +-
 compiler/rustc_pattern_analysis/Cargo.toml    |  6 ++---
 compiler/rustc_privacy/Cargo.toml             |  2 +-
 compiler/rustc_proc_macro/Cargo.toml          |  2 +-
 compiler/rustc_public/Cargo.toml              |  4 +--
 compiler/rustc_query_impl/Cargo.toml          |  4 +--
 compiler/rustc_query_system/Cargo.toml        |  2 +-
 compiler/rustc_resolve/Cargo.toml             | 10 +++----
 compiler/rustc_sanitizers/Cargo.toml          |  4 +--
 compiler/rustc_serialize/Cargo.toml           |  6 ++---
 compiler/rustc_session/Cargo.toml             |  8 +++---
 compiler/rustc_span/Cargo.toml                |  8 +++---
 compiler/rustc_symbol_mangling/Cargo.toml     |  4 +--
 compiler/rustc_target/Cargo.toml              |  6 ++---
 compiler/rustc_thread_pool/Cargo.toml         |  4 +--
 compiler/rustc_trait_selection/Cargo.toml     |  6 ++---
 compiler/rustc_traits/Cargo.toml              |  2 +-
 compiler/rustc_transmute/Cargo.toml           |  4 +--
 compiler/rustc_ty_utils/Cargo.toml            |  4 +--
 compiler/rustc_type_ir/Cargo.toml             | 12 ++++-----
 compiler/rustc_type_ir_macros/Cargo.toml      |  4 +--
 src/librustdoc/Cargo.toml                     | 10 +++----
 src/tools/build-manifest/Cargo.toml           |  2 +-
 src/tools/collect-license-metadata/Cargo.toml |  2 +-
 src/tools/compiletest/Cargo.toml              |  8 +++---
 src/tools/coverage-dump/Cargo.toml            |  4 +--
 src/tools/features-status-dump/Cargo.toml     |  2 +-
 src/tools/generate-copyright/Cargo.toml       |  2 +-
 src/tools/jsondocck/Cargo.toml                |  2 +-
 src/tools/jsondoclint/Cargo.toml              |  4 +--
 src/tools/lint-docs/Cargo.toml                |  4 +--
 src/tools/llvm-bitcode-linker/Cargo.toml      |  4 +--
 src/tools/opt-dist/Cargo.toml                 |  4 +--
 src/tools/run-make-support/Cargo.toml         |  4 +--
 src/tools/tidy/Cargo.toml                     |  2 +-
 76 files changed, 187 insertions(+), 212 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 2c5044f6a3550..67c7a9d67edc8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -59,33 +59,6 @@ exclude = [
   "obj",
 ]
 
-[workspace.dependencies]
-# tidy-alphabetical-start
-bitflags = "2.9.3"
-derive-where = "1.6.0"
-either = "1.15.0"
-indexmap = "2.10.0"
-itertools = "0.12.1"
-# FIXME: Remove this pin once this rustix issue is resolved
-# https://github.com/bytecodealliance/rustix/issues/1496
-libc = "=0.2.174"
-measureme = "12.0.3"
-memchr = "2.7.5"
-odht = { version = "0.3.1", features = ["nightly"] }
-polonius-engine = "0.13.0"
-proc-macro2 = "1.0.101"
-quote = "1.0.40"
-rustc-demangle = "0.1.26"
-rustc-hash = "2.1.1"
-rustc-literal-escaper = "0.0.5"
-rustc_apfloat = "0.2.3"
-scoped-tls = "1.0.1"
-serde_json = "1.0.142"
-tempfile = "3.20.0"
-thin-vec = "0.2.14"
-tracing = "0.1.37"
-# tidy-alphabetical-end
-
 [profile.release.package.rustc_thread_pool]
 # The rustc fork of Rayon has deadlock detection code which intermittently
 # causes overflows in the CI (see https://github.com/rust-lang/rust/issues/90227)
diff --git a/compiler/rustc_abi/Cargo.toml b/compiler/rustc_abi/Cargo.toml
index 3de6d186b8ab0..83d96d8d04daf 100644
--- a/compiler/rustc_abi/Cargo.toml
+++ b/compiler/rustc_abi/Cargo.toml
@@ -5,7 +5,7 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-bitflags.workspace = true
+bitflags = "2.4.1"
 rand = { version = "0.9.0", default-features = false, optional = true }
 rand_xoshiro = { version = "0.7.0", optional = true }
 rustc_data_structures = { path = "../rustc_data_structures", optional = true }
@@ -15,7 +15,7 @@ rustc_index = { path = "../rustc_index", default-features = false }
 rustc_macros = { path = "../rustc_macros", optional = true }
 rustc_serialize = { path = "../rustc_serialize", optional = true }
 rustc_span = { path = "../rustc_span", optional = true }
-tracing.workspace = true
+tracing = "0.1"
 # tidy-alphabetical-end
 
 [features]
diff --git a/compiler/rustc_ast/Cargo.toml b/compiler/rustc_ast/Cargo.toml
index 7f948a652204b..155e14a3796ee 100644
--- a/compiler/rustc_ast/Cargo.toml
+++ b/compiler/rustc_ast/Cargo.toml
@@ -5,9 +5,9 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-bitflags.workspace = true
-memchr.workspace = true
-rustc-literal-escaper.workspace = true
+bitflags = "2.4.1"
+memchr = "2.7.4"
+rustc-literal-escaper = "0.0.5"
 rustc_ast_ir = { path = "../rustc_ast_ir" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_index = { path = "../rustc_index" }
@@ -15,6 +15,6 @@ rustc_macros = { path = "../rustc_macros" }
 rustc_serialize = { path = "../rustc_serialize" }
 rustc_span = { path = "../rustc_span" }
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
-thin-vec.workspace = true
-tracing.workspace = true
+thin-vec = "0.2.12"
+tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_ast_lowering/Cargo.toml b/compiler/rustc_ast_lowering/Cargo.toml
index 317742a3bb825..6ac258155fe94 100644
--- a/compiler/rustc_ast_lowering/Cargo.toml
+++ b/compiler/rustc_ast_lowering/Cargo.toml
@@ -24,6 +24,6 @@ rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
-thin-vec.workspace = true
-tracing.workspace = true
+thin-vec = "0.2.12"
+tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_ast_passes/Cargo.toml b/compiler/rustc_ast_passes/Cargo.toml
index 6d2bcbed22bda..3e04f8b11ec9d 100644
--- a/compiler/rustc_ast_passes/Cargo.toml
+++ b/compiler/rustc_ast_passes/Cargo.toml
@@ -5,7 +5,7 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-itertools.workspace = true
+itertools = "0.12"
 rustc_abi = { path = "../rustc_abi" }
 rustc_ast = { path = "../rustc_ast" }
 rustc_ast_pretty = { path = "../rustc_ast_pretty" }
@@ -18,5 +18,5 @@ rustc_macros = { path = "../rustc_macros" }
 rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
-thin-vec.workspace = true
+thin-vec = "0.2.12"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_ast_pretty/Cargo.toml b/compiler/rustc_ast_pretty/Cargo.toml
index 0c7e55305b485..b704040be9618 100644
--- a/compiler/rustc_ast_pretty/Cargo.toml
+++ b/compiler/rustc_ast_pretty/Cargo.toml
@@ -5,7 +5,7 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-itertools.workspace = true
+itertools = "0.12"
 rustc_ast = { path = "../rustc_ast" }
 rustc_lexer = { path = "../rustc_lexer" }
 rustc_span = { path = "../rustc_span" }
@@ -13,5 +13,5 @@ rustc_span = { path = "../rustc_span" }
 
 [dev-dependencies]
 # tidy-alphabetical-start
-thin-vec.workspace = true
+thin-vec = "0.2.12"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_attr_parsing/Cargo.toml b/compiler/rustc_attr_parsing/Cargo.toml
index 8bfde43fd334f..79193f394fe43 100644
--- a/compiler/rustc_attr_parsing/Cargo.toml
+++ b/compiler/rustc_attr_parsing/Cargo.toml
@@ -18,5 +18,5 @@ rustc_parse = { path = "../rustc_parse" }
 rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
-thin-vec.workspace = true
+thin-vec = "0.2.12"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_borrowck/Cargo.toml b/compiler/rustc_borrowck/Cargo.toml
index 5f9dc41766bc6..9e7d55180a233 100644
--- a/compiler/rustc_borrowck/Cargo.toml
+++ b/compiler/rustc_borrowck/Cargo.toml
@@ -5,9 +5,9 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-either.workspace = true
-itertools.workspace = true
-polonius-engine.workspace = true
+either = "1.5.0"
+itertools = "0.12"
+polonius-engine = "0.13.0"
 rustc_abi = { path = "../rustc_abi" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_errors = { path = "../rustc_errors" }
@@ -25,5 +25,5 @@ rustc_span = { path = "../rustc_span" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }
 rustc_traits = { path = "../rustc_traits" }
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
-tracing.workspace = true
+tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_builtin_macros/Cargo.toml b/compiler/rustc_builtin_macros/Cargo.toml
index 9ca44d671503d..e56b9e641a10b 100644
--- a/compiler/rustc_builtin_macros/Cargo.toml
+++ b/compiler/rustc_builtin_macros/Cargo.toml
@@ -30,6 +30,6 @@ rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
-thin-vec.workspace = true
-tracing.workspace = true
+thin-vec = "0.2.12"
+tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_codegen_llvm/Cargo.toml b/compiler/rustc_codegen_llvm/Cargo.toml
index b04310f3d5449..2d11628250cd2 100644
--- a/compiler/rustc_codegen_llvm/Cargo.toml
+++ b/compiler/rustc_codegen_llvm/Cargo.toml
@@ -8,15 +8,15 @@ test = false
 
 [dependencies]
 # tidy-alphabetical-start
-bitflags.workspace = true
+bitflags = "2.4.1"
 # To avoid duplicate dependencies, this should match the version of gimli used
 # by `rustc_codegen_ssa` via its `thorin-dwp` dependency.
 gimli = "0.31"
-itertools.workspace = true
-libc.workspace = true
-measureme.workspace = true
+itertools = "0.12"
+libc = "0.2"
+measureme = "12.0.1"
 object = { version = "0.37.0", default-features = false, features = ["std", "read"] }
-rustc-demangle.workspace = true
+rustc-demangle = "0.1.21"
 rustc_abi = { path = "../rustc_abi" }
 rustc_ast = { path = "../rustc_ast" }
 rustc_codegen_ssa = { path = "../rustc_codegen_ssa" }
@@ -38,9 +38,9 @@ rustc_span = { path = "../rustc_span" }
 rustc_symbol_mangling = { path = "../rustc_symbol_mangling" }
 rustc_target = { path = "../rustc_target" }
 serde = { version = "1", features = ["derive"] }
-serde_json.workspace = true
+serde_json = "1"
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
-tracing.workspace = true
+tracing = "0.1"
 # tidy-alphabetical-end
 
 [features]
diff --git a/compiler/rustc_codegen_ssa/Cargo.toml b/compiler/rustc_codegen_ssa/Cargo.toml
index 6f87b5749c6d5..2dfbc58164323 100644
--- a/compiler/rustc_codegen_ssa/Cargo.toml
+++ b/compiler/rustc_codegen_ssa/Cargo.toml
@@ -6,12 +6,12 @@ edition = "2024"
 [dependencies]
 # tidy-alphabetical-start
 ar_archive_writer = "0.5"
-bitflags.workspace = true
+bitflags = "2.4.1"
 bstr = "1.11.3"
 # `cc` updates often break things, so we pin it here. Cargo enforces "max 1 semver-compat version
 # per crate", so if you change this, you need to also change it in `rustc_llvm`.
 cc = "=1.2.16"
-itertools.workspace = true
+itertools = "0.12"
 pathdiff = "0.2.0"
 regex = "1.4"
 rustc_abi = { path = "../rustc_abi" }
@@ -37,18 +37,18 @@ rustc_span = { path = "../rustc_span" }
 rustc_symbol_mangling = { path = "../rustc_symbol_mangling" }
 rustc_target = { path = "../rustc_target" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }
-serde_json.workspace = true
+serde_json = "1.0.59"
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
-tempfile.workspace = true
-thin-vec.workspace = true
+tempfile = "3.2"
+thin-vec = "0.2.12"
 thorin-dwp = "0.9"
-tracing.workspace = true
+tracing = "0.1"
 wasm-encoder = "0.219"
 # tidy-alphabetical-end
 
 [target.'cfg(unix)'.dependencies]
 # tidy-alphabetical-start
-libc.workspace = true
+libc = "0.2.50"
 # tidy-alphabetical-end
 
 [dependencies.object]
diff --git a/compiler/rustc_const_eval/Cargo.toml b/compiler/rustc_const_eval/Cargo.toml
index acf19b0f2fcdb..51dcee8d88227 100644
--- a/compiler/rustc_const_eval/Cargo.toml
+++ b/compiler/rustc_const_eval/Cargo.toml
@@ -5,9 +5,9 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-either.workspace = true
+either = "1"
 rustc_abi = { path = "../rustc_abi" }
-rustc_apfloat.workspace = true
+rustc_apfloat = "0.2.0"
 rustc_ast = { path = "../rustc_ast" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_errors = { path = "../rustc_errors" }
@@ -22,5 +22,5 @@ rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }
-tracing.workspace = true
+tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_data_structures/Cargo.toml b/compiler/rustc_data_structures/Cargo.toml
index 852fc11350b19..c8296e05f6bd4 100644
--- a/compiler/rustc_data_structures/Cargo.toml
+++ b/compiler/rustc_data_structures/Cargo.toml
@@ -6,15 +6,15 @@ edition = "2024"
 [dependencies]
 # tidy-alphabetical-start
 arrayvec = { version = "0.7", default-features = false }
-bitflags.workspace = true
-either.workspace = true
+bitflags = "2.4.1"
+either = "1.0"
 elsa = "1.11.0"
 ena = "0.14.3"
-indexmap.workspace = true
+indexmap = "2.4.0"
 jobserver_crate = { version = "0.1.28", package = "jobserver" }
-measureme.workspace = true
+measureme = "12.0.1"
 parking_lot = "0.12"
-rustc-hash.workspace = true
+rustc-hash = "2.0.0"
 rustc-stable-hash = { version = "0.1.0", features = ["nightly"] }
 rustc_arena = { path = "../rustc_arena" }
 rustc_graphviz = { path = "../rustc_graphviz" }
@@ -25,9 +25,9 @@ rustc_serialize = { path = "../rustc_serialize" }
 rustc_thread_pool = { path = "../rustc_thread_pool" }
 smallvec = { version = "1.8.1", features = ["const_generics", "union", "may_dangle"] }
 stacker = "0.1.17"
-tempfile.workspace = true
-thin-vec.workspace = true
-tracing.workspace = true
+tempfile = "3.2"
+thin-vec = "0.2.12"
+tracing = "0.1"
 # tidy-alphabetical-end
 
 [dependencies.hashbrown]
@@ -47,7 +47,7 @@ features = [
 
 [target.'cfg(unix)'.dependencies]
 # tidy-alphabetical-start
-libc.workspace = true
+libc = "0.2"
 # tidy-alphabetical-end
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
diff --git a/compiler/rustc_driver_impl/Cargo.toml b/compiler/rustc_driver_impl/Cargo.toml
index 196c8aa354713..ae1dbd2cf5148 100644
--- a/compiler/rustc_driver_impl/Cargo.toml
+++ b/compiler/rustc_driver_impl/Cargo.toml
@@ -49,14 +49,14 @@ rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }
 rustc_ty_utils = { path = "../rustc_ty_utils" }
-serde_json.workspace = true
+serde_json = "1.0.59"
 shlex = "1.0"
-tracing.workspace = true
+tracing = { version = "0.1.35" }
 # tidy-alphabetical-end
 
 [target.'cfg(all(unix, any(target_env = "gnu", target_os = "macos")))'.dependencies]
 # tidy-alphabetical-start
-libc.workspace = true
+libc = "0.2"
 # tidy-alphabetical-end
 
 [target.'cfg(windows)'.dependencies.windows]
diff --git a/compiler/rustc_error_messages/Cargo.toml b/compiler/rustc_error_messages/Cargo.toml
index 7d2dc20e13662..db22e065907e3 100644
--- a/compiler/rustc_error_messages/Cargo.toml
+++ b/compiler/rustc_error_messages/Cargo.toml
@@ -17,6 +17,6 @@ rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_macros = { path = "../rustc_macros" }
 rustc_serialize = { path = "../rustc_serialize" }
 rustc_span = { path = "../rustc_span" }
-tracing.workspace = true
+tracing = "0.1"
 unic-langid = { version = "0.9.0", features = ["macros"] }
 # tidy-alphabetical-end
diff --git a/compiler/rustc_errors/Cargo.toml b/compiler/rustc_errors/Cargo.toml
index 67a17ce88faa0..7912b8e6098b3 100644
--- a/compiler/rustc_errors/Cargo.toml
+++ b/compiler/rustc_errors/Cargo.toml
@@ -21,10 +21,10 @@ rustc_macros = { path = "../rustc_macros" }
 rustc_serialize = { path = "../rustc_serialize" }
 rustc_span = { path = "../rustc_span" }
 serde = { version = "1.0.125", features = ["derive"] }
-serde_json.workspace = true
+serde_json = "1.0.59"
 termcolor = "1.2.0"
 termize = "0.2"
-tracing.workspace = true
+tracing = "0.1"
 # tidy-alphabetical-end
 
 [target.'cfg(windows)'.dependencies.windows]
diff --git a/compiler/rustc_expand/Cargo.toml b/compiler/rustc_expand/Cargo.toml
index 9bb7143af51ee..f897833d85c00 100644
--- a/compiler/rustc_expand/Cargo.toml
+++ b/compiler/rustc_expand/Cargo.toml
@@ -29,6 +29,6 @@ rustc_serialize = { path = "../rustc_serialize" }
 rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
-thin-vec.workspace = true
-tracing.workspace = true
+thin-vec = "0.2.12"
+tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_feature/Cargo.toml b/compiler/rustc_feature/Cargo.toml
index b58f237585241..a4746ac455c1d 100644
--- a/compiler/rustc_feature/Cargo.toml
+++ b/compiler/rustc_feature/Cargo.toml
@@ -9,5 +9,5 @@ rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_hir = { path = "../rustc_hir" }
 rustc_span = { path = "../rustc_span" }
 serde = { version = "1.0.125", features = ["derive"] }
-serde_json.workspace = true
+serde_json = "1.0.59"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_fluent_macro/Cargo.toml b/compiler/rustc_fluent_macro/Cargo.toml
index 60afd9aca87ee..d7ef4280aef05 100644
--- a/compiler/rustc_fluent_macro/Cargo.toml
+++ b/compiler/rustc_fluent_macro/Cargo.toml
@@ -11,8 +11,8 @@ proc-macro = true
 annotate-snippets = "0.11"
 fluent-bundle = "0.16"
 fluent-syntax = "0.12"
-proc-macro2.workspace = true
-quote.workspace = true
+proc-macro2 = "1"
+quote = "1"
 syn = { version = "2", features = ["full"] }
 unic-langid = { version = "0.9.0", features = ["macros"] }
 # tidy-alphabetical-end
diff --git a/compiler/rustc_fs_util/Cargo.toml b/compiler/rustc_fs_util/Cargo.toml
index 37970e81fead4..90a6acade8b03 100644
--- a/compiler/rustc_fs_util/Cargo.toml
+++ b/compiler/rustc_fs_util/Cargo.toml
@@ -5,5 +5,5 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-tempfile.workspace = true
+tempfile = "3.7.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_hir/Cargo.toml b/compiler/rustc_hir/Cargo.toml
index e74fcfe74559c..1008a3e787d01 100644
--- a/compiler/rustc_hir/Cargo.toml
+++ b/compiler/rustc_hir/Cargo.toml
@@ -5,8 +5,8 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-bitflags.workspace = true
-odht.workspace = true
+bitflags = "2.9.1"
+odht = { version = "0.3.1", features = ["nightly"] }
 rustc_abi = { path = "../rustc_abi" }
 rustc_arena = { path = "../rustc_arena" }
 rustc_ast = { path = "../rustc_ast" }
@@ -21,6 +21,6 @@ rustc_serialize = { path = "../rustc_serialize" }
 rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
-thin-vec.workspace = true
-tracing.workspace = true
+thin-vec = "0.2.12"
+tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_hir_analysis/Cargo.toml b/compiler/rustc_hir_analysis/Cargo.toml
index bb86beb225146..e5017794d8f29 100644
--- a/compiler/rustc_hir_analysis/Cargo.toml
+++ b/compiler/rustc_hir_analysis/Cargo.toml
@@ -9,7 +9,7 @@ doctest = false
 
 [dependencies]
 # tidy-alphabetical-start
-itertools.workspace = true
+itertools = "0.12"
 rustc_abi = { path = "../rustc_abi" }
 rustc_arena = { path = "../rustc_arena" }
 rustc_ast = { path = "../rustc_ast" }
@@ -29,5 +29,5 @@ rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
-tracing.workspace = true
+tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_hir_typeck/Cargo.toml b/compiler/rustc_hir_typeck/Cargo.toml
index 5af0c6134cabb..f00125c3e090a 100644
--- a/compiler/rustc_hir_typeck/Cargo.toml
+++ b/compiler/rustc_hir_typeck/Cargo.toml
@@ -5,7 +5,7 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-itertools.workspace = true
+itertools = "0.12"
 rustc_abi = { path = "../rustc_abi" }
 rustc_ast = { path = "../rustc_ast" }
 rustc_attr_parsing = { path = "../rustc_attr_parsing" }
@@ -25,5 +25,5 @@ rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
-tracing.workspace = true
+tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_incremental/Cargo.toml b/compiler/rustc_incremental/Cargo.toml
index 8d7f2eb841474..db0a584188755 100644
--- a/compiler/rustc_incremental/Cargo.toml
+++ b/compiler/rustc_incremental/Cargo.toml
@@ -19,6 +19,6 @@ rustc_middle = { path = "../rustc_middle" }
 rustc_serialize = { path = "../rustc_serialize" }
 rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
-thin-vec.workspace = true
-tracing.workspace = true
+thin-vec = "0.2.12"
+tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_index_macros/Cargo.toml b/compiler/rustc_index_macros/Cargo.toml
index 8593bde261512..34f3109a526b5 100644
--- a/compiler/rustc_index_macros/Cargo.toml
+++ b/compiler/rustc_index_macros/Cargo.toml
@@ -8,8 +8,8 @@ proc-macro = true
 
 [dependencies]
 # tidy-alphabetical-start
-proc-macro2.workspace = true
-quote.workspace = true
+proc-macro2 = "1"
+quote = "1"
 syn = { version = "2.0.9", features = ["full", "extra-traits"] }
 # tidy-alphabetical-end
 
diff --git a/compiler/rustc_infer/Cargo.toml b/compiler/rustc_infer/Cargo.toml
index 6d97fa6af1f4d..08c0361488493 100644
--- a/compiler/rustc_infer/Cargo.toml
+++ b/compiler/rustc_infer/Cargo.toml
@@ -18,6 +18,6 @@ rustc_middle = { path = "../rustc_middle" }
 rustc_span = { path = "../rustc_span" }
 rustc_type_ir = { path = "../rustc_type_ir" }
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
-thin-vec.workspace = true
-tracing.workspace = true
+thin-vec = "0.2.12"
+tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_interface/Cargo.toml b/compiler/rustc_interface/Cargo.toml
index 40152e78f8aa7..473ac5e0cea4a 100644
--- a/compiler/rustc_interface/Cargo.toml
+++ b/compiler/rustc_interface/Cargo.toml
@@ -46,7 +46,7 @@ rustc_thread_pool = { path = "../rustc_thread_pool" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }
 rustc_traits = { path = "../rustc_traits" }
 rustc_ty_utils = { path = "../rustc_ty_utils" }
-tracing.workspace = true
+tracing = "0.1"
 # tidy-alphabetical-end
 
 [dev-dependencies]
diff --git a/compiler/rustc_lexer/Cargo.toml b/compiler/rustc_lexer/Cargo.toml
index e0019fb182169..343b81bd1717d 100644
--- a/compiler/rustc_lexer/Cargo.toml
+++ b/compiler/rustc_lexer/Cargo.toml
@@ -14,7 +14,7 @@ Rust lexer used by rustc. No stability guarantees are provided.
 
 # Note that this crate purposefully does not depend on other rustc crates
 [dependencies]
-memchr.workspace = true
+memchr = "2.7.4"
 unicode-properties = { version = "0.1.0", default-features = false, features = ["emoji"] }
 unicode-xid = "0.2.0"
 
diff --git a/compiler/rustc_lint/Cargo.toml b/compiler/rustc_lint/Cargo.toml
index 7900e4b9ab220..7718f16984dab 100644
--- a/compiler/rustc_lint/Cargo.toml
+++ b/compiler/rustc_lint/Cargo.toml
@@ -24,6 +24,6 @@ rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
-tracing.workspace = true
+tracing = "0.1"
 unicode-security = "0.1.0"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_llvm/Cargo.toml b/compiler/rustc_llvm/Cargo.toml
index e74de453be216..cd352ce3d0f4f 100644
--- a/compiler/rustc_llvm/Cargo.toml
+++ b/compiler/rustc_llvm/Cargo.toml
@@ -5,7 +5,7 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-libc.workspace = true
+libc = "0.2.73"
 # tidy-alphabetical-end
 
 [build-dependencies]
diff --git a/compiler/rustc_log/Cargo.toml b/compiler/rustc_log/Cargo.toml
index e9d7b4723f82c..c673d51a1d456 100644
--- a/compiler/rustc_log/Cargo.toml
+++ b/compiler/rustc_log/Cargo.toml
@@ -5,10 +5,10 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
+tracing = "0.1.28"
 tracing-core = "=0.1.30" # FIXME(Nilstrieb) tracing has a deadlock: https://github.com/tokio-rs/tracing/issues/2635
 tracing-subscriber = { version = "0.3.3", default-features = false, features = ["fmt", "env-filter", "smallvec", "parking_lot", "ansi"] }
 tracing-tree = "0.3.1"
-tracing.workspace = true
 # tidy-alphabetical-end
 
 [features]
diff --git a/compiler/rustc_macros/Cargo.toml b/compiler/rustc_macros/Cargo.toml
index 5add2691b886e..f9d3b75835907 100644
--- a/compiler/rustc_macros/Cargo.toml
+++ b/compiler/rustc_macros/Cargo.toml
@@ -8,8 +8,8 @@ proc-macro = true
 
 [dependencies]
 # tidy-alphabetical-start
-proc-macro2.workspace = true
-quote.workspace = true
+proc-macro2 = "1"
+quote = "1"
 syn = { version = "2.0.9", features = ["full"] }
 synstructure = "0.13.0"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_metadata/Cargo.toml b/compiler/rustc_metadata/Cargo.toml
index a8f3dd18353c1..1b40d9f684efc 100644
--- a/compiler/rustc_metadata/Cargo.toml
+++ b/compiler/rustc_metadata/Cargo.toml
@@ -5,9 +5,9 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-bitflags.workspace = true
+bitflags = "2.4.1"
 libloading = "0.8.0"
-odht.workspace = true
+odht = { version = "0.3.1", features = ["nightly"] }
 rustc_abi = { path = "../rustc_abi" }
 rustc_ast = { path = "../rustc_ast" }
 rustc_attr_parsing = { path = "../rustc_attr_parsing" }
@@ -30,11 +30,11 @@ rustc_serialize = { path = "../rustc_serialize" }
 rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
-tempfile.workspace = true
-tracing.workspace = true
+tempfile = "3.7.1"
+tracing = "0.1"
 # tidy-alphabetical-end
 
 [target.'cfg(target_os = "aix")'.dependencies]
 # tidy-alphabetical-start
-libc.workspace = true
+libc = "0.2"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_middle/Cargo.toml b/compiler/rustc_middle/Cargo.toml
index f08324055672d..fbcce16cedca8 100644
--- a/compiler/rustc_middle/Cargo.toml
+++ b/compiler/rustc_middle/Cargo.toml
@@ -5,12 +5,12 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-bitflags.workspace = true
-either.workspace = true
+bitflags = "2.4.1"
+either = "1.5.0"
 gsgdt = "0.1.2"
-polonius-engine.workspace = true
+polonius-engine = "0.13.0"
 rustc_abi = { path = "../rustc_abi" }
-rustc_apfloat.workspace = true
+rustc_apfloat = "0.2.0"
 rustc_arena = { path = "../rustc_arena" }
 rustc_ast = { path = "../rustc_ast" }
 rustc_ast_ir = { path = "../rustc_ast_ir" }
@@ -34,8 +34,8 @@ rustc_target = { path = "../rustc_target" }
 rustc_thread_pool = { path = "../rustc_thread_pool" }
 rustc_type_ir = { path = "../rustc_type_ir" }
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
-thin-vec.workspace = true
-tracing.workspace = true
+thin-vec = "0.2.12"
+tracing = "0.1"
 # tidy-alphabetical-end
 
 [features]
diff --git a/compiler/rustc_mir_build/Cargo.toml b/compiler/rustc_mir_build/Cargo.toml
index 440cb0bdbf3eb..f756f0a19ee9b 100644
--- a/compiler/rustc_mir_build/Cargo.toml
+++ b/compiler/rustc_mir_build/Cargo.toml
@@ -5,9 +5,9 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-itertools.workspace = true
+itertools = "0.12"
 rustc_abi = { path = "../rustc_abi" }
-rustc_apfloat.workspace = true
+rustc_apfloat = "0.2.0"
 rustc_arena = { path = "../rustc_arena" }
 rustc_ast = { path = "../rustc_ast" }
 rustc_data_structures = { path = "../rustc_data_structures" }
@@ -23,5 +23,5 @@ rustc_pattern_analysis = { path = "../rustc_pattern_analysis" }
 rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }
-tracing.workspace = true
+tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_mir_dataflow/Cargo.toml b/compiler/rustc_mir_dataflow/Cargo.toml
index 11713bb77f1ee..9621f9f20bdc8 100644
--- a/compiler/rustc_mir_dataflow/Cargo.toml
+++ b/compiler/rustc_mir_dataflow/Cargo.toml
@@ -5,7 +5,7 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-polonius-engine.workspace = true
+polonius-engine = "0.13.0"
 regex = "1"
 rustc_abi = { path = "../rustc_abi" }
 rustc_ast = { path = "../rustc_ast" }
@@ -18,5 +18,5 @@ rustc_macros = { path = "../rustc_macros" }
 rustc_middle = { path = "../rustc_middle" }
 rustc_span = { path = "../rustc_span" }
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
-tracing.workspace = true
+tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_mir_transform/Cargo.toml b/compiler/rustc_mir_transform/Cargo.toml
index 99ef67e2625d2..08c43a4648c67 100644
--- a/compiler/rustc_mir_transform/Cargo.toml
+++ b/compiler/rustc_mir_transform/Cargo.toml
@@ -5,8 +5,8 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-either.workspace = true
-itertools.workspace = true
+either = "1"
+itertools = "0.12"
 rustc_abi = { path = "../rustc_abi" }
 rustc_arena = { path = "../rustc_arena" }
 rustc_ast = { path = "../rustc_ast" }
@@ -26,5 +26,5 @@ rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
-tracing.workspace = true
+tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_monomorphize/Cargo.toml b/compiler/rustc_monomorphize/Cargo.toml
index 78266d3c6d858..09a55f0b5f8da 100644
--- a/compiler/rustc_monomorphize/Cargo.toml
+++ b/compiler/rustc_monomorphize/Cargo.toml
@@ -16,6 +16,6 @@ rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
 serde = "1"
-serde_json.workspace = true
-tracing.workspace = true
+serde_json = "1"
+tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_next_trait_solver/Cargo.toml b/compiler/rustc_next_trait_solver/Cargo.toml
index 43db90c08f3f5..05bcabad02f9b 100644
--- a/compiler/rustc_next_trait_solver/Cargo.toml
+++ b/compiler/rustc_next_trait_solver/Cargo.toml
@@ -5,13 +5,13 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-derive-where.workspace = true
+derive-where = "1.2.7"
 rustc_data_structures = { path = "../rustc_data_structures", optional = true }
 rustc_index = { path = "../rustc_index", default-features = false }
 rustc_macros = { path = "../rustc_macros", optional = true }
 rustc_type_ir = { path = "../rustc_type_ir", default-features = false }
 rustc_type_ir_macros = { path = "../rustc_type_ir_macros" }
-tracing.workspace = true
+tracing = "0.1"
 # tidy-alphabetical-end
 
 [features]
diff --git a/compiler/rustc_parse/Cargo.toml b/compiler/rustc_parse/Cargo.toml
index 7cb4ae7ff5f83..6d738a1037153 100644
--- a/compiler/rustc_parse/Cargo.toml
+++ b/compiler/rustc_parse/Cargo.toml
@@ -5,8 +5,8 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-bitflags.workspace = true
-rustc-literal-escaper.workspace = true
+bitflags = "2.4.1"
+rustc-literal-escaper = "0.0.5"
 rustc_ast = { path = "../rustc_ast" }
 rustc_ast_pretty = { path = "../rustc_ast_pretty" }
 rustc_data_structures = { path = "../rustc_data_structures" }
@@ -18,8 +18,8 @@ rustc_lexer = { path = "../rustc_lexer" }
 rustc_macros = { path = "../rustc_macros" }
 rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
-thin-vec.workspace = true
-tracing.workspace = true
+thin-vec = "0.2.12"
+tracing = "0.1"
 unicode-normalization = "0.1.11"
 unicode-width = "0.2.0"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_parse_format/Cargo.toml b/compiler/rustc_parse_format/Cargo.toml
index 645e34b6e3224..d178fcda1fb9f 100644
--- a/compiler/rustc_parse_format/Cargo.toml
+++ b/compiler/rustc_parse_format/Cargo.toml
@@ -5,7 +5,7 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-rustc-literal-escaper.workspace = true
+rustc-literal-escaper = "0.0.5"
 rustc_lexer = { path = "../rustc_lexer" }
 # tidy-alphabetical-end
 
diff --git a/compiler/rustc_passes/Cargo.toml b/compiler/rustc_passes/Cargo.toml
index c74608a614678..ba81ef3103bd9 100644
--- a/compiler/rustc_passes/Cargo.toml
+++ b/compiler/rustc_passes/Cargo.toml
@@ -24,5 +24,5 @@ rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }
-tracing.workspace = true
+tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_pattern_analysis/Cargo.toml b/compiler/rustc_pattern_analysis/Cargo.toml
index e4909ab6d1628..a59f7bbeb9e5e 100644
--- a/compiler/rustc_pattern_analysis/Cargo.toml
+++ b/compiler/rustc_pattern_analysis/Cargo.toml
@@ -5,9 +5,9 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-rustc-hash.workspace = true
+rustc-hash = "2.0.0"
 rustc_abi = { path = "../rustc_abi", optional = true }
-rustc_apfloat.workspace = true
+rustc_apfloat = "0.2.0"
 rustc_arena = { path = "../rustc_arena", optional = true }
 rustc_data_structures = { path = "../rustc_data_structures", optional = true }
 rustc_errors = { path = "../rustc_errors", optional = true }
@@ -19,7 +19,7 @@ rustc_middle = { path = "../rustc_middle", optional = true }
 rustc_session = { path = "../rustc_session", optional = true }
 rustc_span = { path = "../rustc_span", optional = true }
 smallvec = { version = "1.8.1", features = ["union"] }
-tracing.workspace = true
+tracing = "0.1"
 # tidy-alphabetical-end
 
 [dev-dependencies]
diff --git a/compiler/rustc_privacy/Cargo.toml b/compiler/rustc_privacy/Cargo.toml
index 7de58132e1346..c8bfdb913041c 100644
--- a/compiler/rustc_privacy/Cargo.toml
+++ b/compiler/rustc_privacy/Cargo.toml
@@ -15,5 +15,5 @@ rustc_middle = { path = "../rustc_middle" }
 rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_ty_utils = { path = "../rustc_ty_utils" }
-tracing.workspace = true
+tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_proc_macro/Cargo.toml b/compiler/rustc_proc_macro/Cargo.toml
index 99e7fc7abc6d3..beb95aa3b52f2 100644
--- a/compiler/rustc_proc_macro/Cargo.toml
+++ b/compiler/rustc_proc_macro/Cargo.toml
@@ -16,7 +16,7 @@ doctest = false
 
 [dependencies]
 # tidy-alphabetical-start
-rustc-literal-escaper.workspace = true
+rustc-literal-escaper = "0.0.5"
 # tidy-alphabetical-end
 
 [features]
diff --git a/compiler/rustc_public/Cargo.toml b/compiler/rustc_public/Cargo.toml
index e67e4fe67396e..70af30c1a5f46 100644
--- a/compiler/rustc_public/Cargo.toml
+++ b/compiler/rustc_public/Cargo.toml
@@ -12,9 +12,9 @@ rustc_public_bridge = { path = "../rustc_public_bridge" }
 rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
-scoped-tls.workspace = true
+scoped-tls = "1.0"
 serde = { version = "1.0.125", features = [ "derive" ] }
-tracing.workspace = true
+tracing = "0.1"
 # tidy-alphabetical-end
 
 [features]
diff --git a/compiler/rustc_query_impl/Cargo.toml b/compiler/rustc_query_impl/Cargo.toml
index 3d5cf0eb72df3..e5cceacf15da8 100644
--- a/compiler/rustc_query_impl/Cargo.toml
+++ b/compiler/rustc_query_impl/Cargo.toml
@@ -5,7 +5,7 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-measureme.workspace = true 
+measureme = "12.0.1"
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_hashes = { path = "../rustc_hashes" }
 rustc_hir = { path = "../rustc_hir" }
@@ -15,5 +15,5 @@ rustc_query_system = { path = "../rustc_query_system" }
 rustc_serialize = { path = "../rustc_serialize" }
 rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
-tracing.workspace = true
+tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_query_system/Cargo.toml b/compiler/rustc_query_system/Cargo.toml
index 0df933bc81c0b..7480ba03474f9 100644
--- a/compiler/rustc_query_system/Cargo.toml
+++ b/compiler/rustc_query_system/Cargo.toml
@@ -21,7 +21,7 @@ rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_thread_pool = { path = "../rustc_thread_pool" }
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
-tracing.workspace = true
+tracing = "0.1"
 # tidy-alphabetical-end
 
 [dependencies.hashbrown]
diff --git a/compiler/rustc_resolve/Cargo.toml b/compiler/rustc_resolve/Cargo.toml
index 4da4c0840dfab..eb98a6e85c06b 100644
--- a/compiler/rustc_resolve/Cargo.toml
+++ b/compiler/rustc_resolve/Cargo.toml
@@ -5,9 +5,9 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-bitflags.workspace = true
-indexmap.workspace = true
-itertools.workspace = true
+bitflags = "2.4.1"
+indexmap = "2.4.0"
+itertools = "0.12"
 pulldown-cmark = { version = "0.11", features = ["html"], default-features = false }
 rustc_arena = { path = "../rustc_arena" }
 rustc_ast = { path = "../rustc_ast" }
@@ -27,6 +27,6 @@ rustc_query_system = { path = "../rustc_query_system" }
 rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
-thin-vec.workspace = true
-tracing.workspace = true
+thin-vec = "0.2.12"
+tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_sanitizers/Cargo.toml b/compiler/rustc_sanitizers/Cargo.toml
index 3dbeaa435f307..9069d2c233db7 100644
--- a/compiler/rustc_sanitizers/Cargo.toml
+++ b/compiler/rustc_sanitizers/Cargo.toml
@@ -5,7 +5,7 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-bitflags.workspace = true
+bitflags = "2.5.0"
 rustc_abi = { path = "../rustc_abi" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_hir = { path = "../rustc_hir" }
@@ -13,6 +13,6 @@ rustc_middle = { path = "../rustc_middle" }
 rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }
-tracing.workspace = true
+tracing = "0.1"
 twox-hash = "1.6.3"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_serialize/Cargo.toml b/compiler/rustc_serialize/Cargo.toml
index 853f87ebed96f..948242352e7a8 100644
--- a/compiler/rustc_serialize/Cargo.toml
+++ b/compiler/rustc_serialize/Cargo.toml
@@ -5,14 +5,14 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-indexmap.workspace = true
+indexmap = "2.0.0"
 rustc_hashes = { path = "../rustc_hashes" }
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
-thin-vec.workspace = true
+thin-vec = "0.2.12"
 # tidy-alphabetical-end
 
 [dev-dependencies]
 # tidy-alphabetical-start
 rustc_macros = { path = "../rustc_macros" }
-tempfile.workspace = true
+tempfile = "3.2"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_session/Cargo.toml b/compiler/rustc_session/Cargo.toml
index 5870fb29ae837..60d56b1b808df 100644
--- a/compiler/rustc_session/Cargo.toml
+++ b/compiler/rustc_session/Cargo.toml
@@ -5,7 +5,7 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-bitflags.workspace = true
+bitflags = "2.4.1"
 getopts = "0.2"
 rand = "0.9.0"
 rustc_abi = { path = "../rustc_abi" }
@@ -23,12 +23,14 @@ rustc_serialize = { path = "../rustc_serialize" }
 rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
 termize = "0.2"
-tracing.workspace = true
+tracing = "0.1"
 # tidy-alphabetical-end
 
 [target.'cfg(unix)'.dependencies]
+# FIXME: Remove this pin once this rustix issue is resolved
+# https://github.com/bytecodealliance/rustix/issues/1496
 # tidy-alphabetical-start
-libc.workspace = true
+libc = "=0.2.174"
 # tidy-alphabetical-end
 
 [target.'cfg(windows)'.dependencies.windows]
diff --git a/compiler/rustc_span/Cargo.toml b/compiler/rustc_span/Cargo.toml
index da6f2101d234b..43a2d692577eb 100644
--- a/compiler/rustc_span/Cargo.toml
+++ b/compiler/rustc_span/Cargo.toml
@@ -6,8 +6,8 @@ edition = "2024"
 [dependencies]
 # tidy-alphabetical-start
 blake3 = "1.5.2"
-derive-where.workspace = true
-indexmap.workspace = true
+derive-where = "1.2.7"
+indexmap = { version = "2.0.0" }
 itoa = "1.0"
 md5 = { package = "md-5", version = "0.10.0" }
 rustc_arena = { path = "../rustc_arena" }
@@ -16,9 +16,9 @@ rustc_hashes = { path = "../rustc_hashes" }
 rustc_index = { path = "../rustc_index" }
 rustc_macros = { path = "../rustc_macros" }
 rustc_serialize = { path = "../rustc_serialize" }
-scoped-tls.workspace = true
+scoped-tls = "1.0"
 sha1 = "0.10.0"
 sha2 = "0.10.1"
-tracing.workspace = true
+tracing = "0.1"
 unicode-width = "0.2.0"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_symbol_mangling/Cargo.toml b/compiler/rustc_symbol_mangling/Cargo.toml
index 0ceac4b3e1b3c..0df9c7682bf8a 100644
--- a/compiler/rustc_symbol_mangling/Cargo.toml
+++ b/compiler/rustc_symbol_mangling/Cargo.toml
@@ -6,7 +6,7 @@ edition = "2024"
 [dependencies]
 # tidy-alphabetical-start
 punycode = "0.4.0"
-rustc-demangle.workspace = true
+rustc-demangle = "0.1.21"
 rustc_abi = { path = "../rustc_abi" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_errors = { path = "../rustc_errors" }
@@ -15,5 +15,5 @@ rustc_hir = { path = "../rustc_hir" }
 rustc_middle = { path = "../rustc_middle" }
 rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
-tracing.workspace = true
+tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_target/Cargo.toml b/compiler/rustc_target/Cargo.toml
index ed59ee2a57565..7fabb227d9a59 100644
--- a/compiler/rustc_target/Cargo.toml
+++ b/compiler/rustc_target/Cargo.toml
@@ -5,7 +5,7 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-bitflags.workspace = true
+bitflags = "2.4.1"
 object = { version = "0.37.0", default-features = false, features = ["elf", "macho"] }
 rustc_abi = { path = "../rustc_abi" }
 rustc_data_structures = { path = "../rustc_data_structures" }
@@ -16,8 +16,8 @@ rustc_serialize = { path = "../rustc_serialize" }
 rustc_span = { path = "../rustc_span" }
 serde = "1.0.219"
 serde_derive = "1.0.219"
-serde_json.workspace = true
+serde_json = "1.0.59"
 serde_path_to_error = "0.1.17"
-tracing.workspace = true
+tracing = "0.1"
 # tidy-alphabetical-end
 
diff --git a/compiler/rustc_thread_pool/Cargo.toml b/compiler/rustc_thread_pool/Cargo.toml
index 8e8c6469512bb..c92984470b7ae 100644
--- a/compiler/rustc_thread_pool/Cargo.toml
+++ b/compiler/rustc_thread_pool/Cargo.toml
@@ -20,10 +20,10 @@ smallvec = "1.8.1"
 [dev-dependencies]
 rand = "0.9"
 rand_xorshift = "0.4"
-scoped-tls.workspace = true
+scoped-tls = "1.0"
 
 [target.'cfg(unix)'.dev-dependencies]
-libc.workspace = true
+libc = "0.2"
 
 [[test]]
 name = "stack_overflow_crash"
diff --git a/compiler/rustc_trait_selection/Cargo.toml b/compiler/rustc_trait_selection/Cargo.toml
index 6b79b98d1bf5d..1071105522d11 100644
--- a/compiler/rustc_trait_selection/Cargo.toml
+++ b/compiler/rustc_trait_selection/Cargo.toml
@@ -5,7 +5,7 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-itertools.workspace = true
+itertools = "0.12"
 rustc_abi = { path = "../rustc_abi" }
 rustc_ast = { path = "../rustc_ast" }
 rustc_data_structures = { path = "../rustc_data_structures" }
@@ -21,6 +21,6 @@ rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_transmute = { path = "../rustc_transmute", features = ["rustc"] }
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
-thin-vec.workspace = true
-tracing.workspace = true
+thin-vec = "0.2"
+tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_traits/Cargo.toml b/compiler/rustc_traits/Cargo.toml
index 24360a94cc7f6..9f40f4d5c23ea 100644
--- a/compiler/rustc_traits/Cargo.toml
+++ b/compiler/rustc_traits/Cargo.toml
@@ -10,5 +10,5 @@ rustc_infer = { path = "../rustc_infer" }
 rustc_middle = { path = "../rustc_middle" }
 rustc_span = { path = "../rustc_span" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }
-tracing.workspace = true
+tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_transmute/Cargo.toml b/compiler/rustc_transmute/Cargo.toml
index 2ac2b46cc58f4..e61717e5e9ce2 100644
--- a/compiler/rustc_transmute/Cargo.toml
+++ b/compiler/rustc_transmute/Cargo.toml
@@ -11,12 +11,12 @@ rustc_hir = { path = "../rustc_hir", optional = true }
 rustc_middle = { path = "../rustc_middle", optional = true }
 rustc_span = { path = "../rustc_span", optional = true }
 smallvec = "1.8.1"
-tracing.workspace = true
+tracing = "0.1"
 # tidy-alphabetical-end
 
 [dev-dependencies]
 # tidy-alphabetical-start
-itertools.workspace = true
+itertools = "0.12"
 # tidy-alphabetical-end
 
 [features]
diff --git a/compiler/rustc_ty_utils/Cargo.toml b/compiler/rustc_ty_utils/Cargo.toml
index 394cde5a32342..ce08b300cc800 100644
--- a/compiler/rustc_ty_utils/Cargo.toml
+++ b/compiler/rustc_ty_utils/Cargo.toml
@@ -5,7 +5,7 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-itertools.workspace = true
+itertools = "0.12"
 rustc_abi = { path = "../rustc_abi" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_errors = { path = "../rustc_errors" }
@@ -20,5 +20,5 @@ rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }
-tracing.workspace = true
+tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_type_ir/Cargo.toml b/compiler/rustc_type_ir/Cargo.toml
index 42860fa2d88da..d55e9b3b1be82 100644
--- a/compiler/rustc_type_ir/Cargo.toml
+++ b/compiler/rustc_type_ir/Cargo.toml
@@ -5,11 +5,11 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-bitflags.workspace = true
-derive-where.workspace = true
+bitflags = "2.4.1"
+derive-where = "1.2.7"
 ena = "0.14.3"
-indexmap.workspace = true
-rustc-hash.workspace = true
+indexmap = "2.0.0"
+rustc-hash = "2.0.0"
 rustc_ast_ir = { path = "../rustc_ast_ir", default-features = false }
 rustc_data_structures = { path = "../rustc_data_structures", optional = true }
 rustc_error_messages = { path = "../rustc_error_messages", optional = true }
@@ -19,8 +19,8 @@ rustc_serialize = { path = "../rustc_serialize", optional = true }
 rustc_span = { path = "../rustc_span", optional = true }
 rustc_type_ir_macros = { path = "../rustc_type_ir_macros" }
 smallvec = { version = "1.8.1", default-features = false, features = ["const_generics"] }
-thin-vec.workspace = true
-tracing.workspace = true
+thin-vec = "0.2.12"
+tracing = "0.1"
 # tidy-alphabetical-end
 
 [features]
diff --git a/compiler/rustc_type_ir_macros/Cargo.toml b/compiler/rustc_type_ir_macros/Cargo.toml
index 29a2cc8903354..15a5557509929 100644
--- a/compiler/rustc_type_ir_macros/Cargo.toml
+++ b/compiler/rustc_type_ir_macros/Cargo.toml
@@ -8,8 +8,8 @@ proc-macro = true
 
 [dependencies]
 # tidy-alphabetical-start
-proc-macro2.workspace = true
-quote.workspace = true
+proc-macro2 = "1"
+quote = "1"
 syn = { version = "2.0.9", features = ["full"] }
 synstructure = "0.13.0"
 # tidy-alphabetical-end
diff --git a/src/librustdoc/Cargo.toml b/src/librustdoc/Cargo.toml
index 2985971a053f5..5d36ffc2d3a52 100644
--- a/src/librustdoc/Cargo.toml
+++ b/src/librustdoc/Cargo.toml
@@ -12,20 +12,20 @@ path = "lib.rs"
 arrayvec = { version = "0.7", default-features = false }
 askama = { version = "0.14", default-features = false, features = ["alloc", "config", "derive"] }
 base64 = "0.21.7"
-indexmap.workspace = true
-itertools.workspace = true
+indexmap = "2"
+itertools = "0.12"
 minifier = { version = "0.3.5", default-features = false }
 pulldown-cmark-escape = { version = "0.11.0", features = ["simd"] }
 regex = "1"
 rustdoc-json-types = { path = "../rustdoc-json-types" }
 serde = { version = "1.0", features = ["derive"] }
-serde_json.workspace = true
+serde_json = "1.0"
 smallvec = "1.8.1"
 stringdex = { version = "0.0.1-alpha4" }
-tempfile.workspace = true
+tempfile = "3"
 threadpool = "1.8.1"
+tracing = "0.1"
 tracing-tree = "0.3.0"
-tracing.workspace = true
 unicode-segmentation = "1.9"
 # tidy-alphabetical-end
 
diff --git a/src/tools/build-manifest/Cargo.toml b/src/tools/build-manifest/Cargo.toml
index 05d5f21c12cb4..efa99f181b3a1 100644
--- a/src/tools/build-manifest/Cargo.toml
+++ b/src/tools/build-manifest/Cargo.toml
@@ -6,7 +6,7 @@ edition = "2021"
 [dependencies]
 toml = "0.7"
 serde = { version = "1.0", features = ["derive"] }
-serde_json.workspace = true
+serde_json = "1.0"
 anyhow = "1.0.32"
 flate2 = "1.0.26"
 xz2 = "0.1.7"
diff --git a/src/tools/collect-license-metadata/Cargo.toml b/src/tools/collect-license-metadata/Cargo.toml
index 7f2e57ced05cf..edf9e5c5393ea 100644
--- a/src/tools/collect-license-metadata/Cargo.toml
+++ b/src/tools/collect-license-metadata/Cargo.toml
@@ -8,5 +8,5 @@ license = "MIT OR Apache-2.0"
 [dependencies]
 anyhow = "1.0.65"
 serde = { version = "1.0.147", features = ["derive"] }
-serde_json.workspace = true
+serde_json = "1.0.85"
 spdx-rs = "0.5.1"
diff --git a/src/tools/compiletest/Cargo.toml b/src/tools/compiletest/Cargo.toml
index fb71275b03c71..cdada5a223062 100644
--- a/src/tools/compiletest/Cargo.toml
+++ b/src/tools/compiletest/Cargo.toml
@@ -20,22 +20,22 @@ diff = "0.1.10"
 getopts = "0.2"
 glob = "0.3.0"
 home = "0.5.5"
-indexmap.workspace = true
+indexmap = "2.0.0"
 miropt-test-tools = { path = "../miropt-test-tools" }
 rayon = "1.10.0"
 regex = "1.0"
 rustfix = "0.8.1"
 semver = { version = "1.0.23", features = ["serde"] }
 serde = { version = "1.0", features = ["derive"] }
-serde_json.workspace = true
+serde_json = "1.0"
+tracing = "0.1"
 tracing-subscriber = { version = "0.3.3", default-features = false, features = ["ansi", "env-filter", "fmt", "parking_lot", "smallvec"] }
-tracing.workspace = true
 unified-diff = "0.2.1"
 walkdir = "2"
 # tidy-alphabetical-end
 
 [target.'cfg(unix)'.dependencies]
-libc.workspace = true
+libc = "0.2"
 
 [target.'cfg(windows)'.dependencies]
 miow = "0.6"
diff --git a/src/tools/coverage-dump/Cargo.toml b/src/tools/coverage-dump/Cargo.toml
index e491804c2574f..36a66f16030ec 100644
--- a/src/tools/coverage-dump/Cargo.toml
+++ b/src/tools/coverage-dump/Cargo.toml
@@ -7,9 +7,9 @@ edition = "2021"
 
 [dependencies]
 anyhow = "1.0.71"
-itertools.workspace = true
+itertools = "0.12"
 leb128 = "0.2.5"
 md5 = { package = "md-5" , version = "0.10.5" }
 miniz_oxide = "0.8.8"
 regex = "1.8.4"
-rustc-demangle.workspace = true
+rustc-demangle = "0.1.23"
diff --git a/src/tools/features-status-dump/Cargo.toml b/src/tools/features-status-dump/Cargo.toml
index d72555da48650..b2976f14a01a4 100644
--- a/src/tools/features-status-dump/Cargo.toml
+++ b/src/tools/features-status-dump/Cargo.toml
@@ -8,5 +8,5 @@ edition = "2021"
 anyhow = { version = "1" }
 clap = { version = "4", features = ["derive"] }
 serde = { version = "1.0.125", features = [ "derive" ] }
-serde_json.workspace = true
+serde_json = "1.0.59"
 tidy = { path = "../tidy", features = ["build-metrics"] }
diff --git a/src/tools/generate-copyright/Cargo.toml b/src/tools/generate-copyright/Cargo.toml
index 5edf1f3d88b34..bcb3165de458f 100644
--- a/src/tools/generate-copyright/Cargo.toml
+++ b/src/tools/generate-copyright/Cargo.toml
@@ -11,5 +11,5 @@ anyhow = "1.0.65"
 askama = "0.14.0"
 cargo_metadata = "0.21"
 serde = { version = "1.0.147", features = ["derive"] }
-serde_json.workspace = true
+serde_json = "1.0.85"
 thiserror = "1"
diff --git a/src/tools/jsondocck/Cargo.toml b/src/tools/jsondocck/Cargo.toml
index 92fde36388231..80fc26cbe6680 100644
--- a/src/tools/jsondocck/Cargo.toml
+++ b/src/tools/jsondocck/Cargo.toml
@@ -8,5 +8,5 @@ jsonpath-rust = "1.0.0"
 getopts = "0.2"
 regex = "1.4"
 shlex = "1.0"
-serde_json.workspace = true
+serde_json = "1.0"
 fs-err = "2.5.0"
diff --git a/src/tools/jsondoclint/Cargo.toml b/src/tools/jsondoclint/Cargo.toml
index 44beaf2ddfd23..cc8ecefd530b4 100644
--- a/src/tools/jsondoclint/Cargo.toml
+++ b/src/tools/jsondoclint/Cargo.toml
@@ -9,7 +9,7 @@ edition = "2021"
 anyhow = "1.0.62"
 clap = { version = "4.0.15", features = ["derive"] }
 fs-err = "2.8.1"
-rustc-hash.workspace = true
+rustc-hash = "2.0.0"
 rustdoc-json-types = { version = "0.1.0", path = "../../rustdoc-json-types" }
 serde = { version = "1.0", features = ["derive"] }
-serde_json.workspace = true
+serde_json = "1.0.85"
diff --git a/src/tools/lint-docs/Cargo.toml b/src/tools/lint-docs/Cargo.toml
index acafe17cb0cd1..6e1ab84ed18d9 100644
--- a/src/tools/lint-docs/Cargo.toml
+++ b/src/tools/lint-docs/Cargo.toml
@@ -8,6 +8,6 @@ description = "A script to extract the lint documentation for the rustc book."
 
 [dependencies]
 rustc-literal-escaper = "0.0.5"
-serde_json.workspace = true
-tempfile.workspace = true
+serde_json = "1.0.57"
+tempfile = "3.1.0"
 walkdir = "2.3.1"
diff --git a/src/tools/llvm-bitcode-linker/Cargo.toml b/src/tools/llvm-bitcode-linker/Cargo.toml
index f78f8b618d311..a9210b562f330 100644
--- a/src/tools/llvm-bitcode-linker/Cargo.toml
+++ b/src/tools/llvm-bitcode-linker/Cargo.toml
@@ -8,7 +8,7 @@ publish = false
 
 [dependencies]
 anyhow = "1.0"
-tracing.workspace = true
-tracing-subscriber = { version = "0.3.0", features = ["std"] }
+tracing = "0.1"
+tracing-subscriber = {version = "0.3.0", features = ["std"] }
 clap = { version = "4.3", features = ["derive"] }
 thiserror = "1.0.24"
diff --git a/src/tools/opt-dist/Cargo.toml b/src/tools/opt-dist/Cargo.toml
index b2833a9d7f1a6..f4051ae67d7c0 100644
--- a/src/tools/opt-dist/Cargo.toml
+++ b/src/tools/opt-dist/Cargo.toml
@@ -15,9 +15,9 @@ fs_extra = "1"
 camino = "1"
 tar = "0.4"
 xz = { version = "0.1", package = "xz2" }
-serde_json.workspace = true
+serde_json = "1"
 glob = "0.3"
-tempfile.workspace = true
+tempfile = "3.5"
 derive_builder = "0.20"
 clap = { version = "4", features = ["derive"] }
 tabled = { version = "0.15", default-features = false, features = ["std"] }
diff --git a/src/tools/run-make-support/Cargo.toml b/src/tools/run-make-support/Cargo.toml
index 86ac4b9d7b458..250e0f65a9f44 100644
--- a/src/tools/run-make-support/Cargo.toml
+++ b/src/tools/run-make-support/Cargo.toml
@@ -12,10 +12,10 @@ edition = "2024"
 # tidy-alphabetical-start
 bstr = "1.12"
 gimli = "0.32"
-libc.workspace = true
+libc = "0.2"
 object = "0.37"
 regex = "1.11"
-serde_json.workspace = true
+serde_json = "1.0"
 similar = "2.7"
 wasmparser = { version = "0.236", default-features = false, features = ["std", "features", "validate"] }
 # tidy-alphabetical-end
diff --git a/src/tools/tidy/Cargo.toml b/src/tools/tidy/Cargo.toml
index f43733665edda..c1f27de7ed4a5 100644
--- a/src/tools/tidy/Cargo.toml
+++ b/src/tools/tidy/Cargo.toml
@@ -14,7 +14,7 @@ ignore = "0.4.18"
 semver = "1.0"
 serde = { version = "1.0.125", features = ["derive"], optional = true }
 termcolor = "1.1.3"
-rustc-hash.workspace = true
+rustc-hash = "2.0.0"
 fluent-syntax = "0.12"
 similar = "2.5.0"
 toml = "0.7.8"

From ee87a8b5c72559fb7d1e901026c1d2632904e843 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 2 Sep 2025 15:13:23 +1000
Subject: [PATCH 0407/1889] Encapsulate output-capture mode in a dedicated enum

---
 src/tools/compiletest/src/executor.rs | 50 +++++++++++++++++++++++----
 1 file changed, 43 insertions(+), 7 deletions(-)

diff --git a/src/tools/compiletest/src/executor.rs b/src/tools/compiletest/src/executor.rs
index 5519ef1af1fad..383a0aaefb9d1 100644
--- a/src/tools/compiletest/src/executor.rs
+++ b/src/tools/compiletest/src/executor.rs
@@ -120,16 +120,15 @@ fn run_test_inner(
     runnable_test: RunnableTest,
     completion_sender: mpsc::Sender<TestCompletion>,
 ) {
-    let is_capture = !runnable_test.config.nocapture;
+    let capture = CaptureKind::for_config(&runnable_test.config);
 
     // Install a panic-capture buffer for use by the custom panic hook.
-    if is_capture {
+    if capture.should_set_panic_hook() {
         panic_hook::set_capture_buf(Default::default());
     }
-    let capture_buf = is_capture.then(|| Arc::new(Mutex::new(vec![])));
 
-    if let Some(capture_buf) = &capture_buf {
-        io::set_output_capture(Some(Arc::clone(capture_buf)));
+    if let CaptureKind::Old { ref buf } = capture {
+        io::set_output_capture(Some(Arc::clone(buf)));
     }
 
     let panic_payload = panic::catch_unwind(move || runnable_test.run()).err();
@@ -141,7 +140,7 @@ fn run_test_inner(
         // non-panic output, append the panic message to that buffer instead.
         eprint!("{panic_buf}");
     }
-    if is_capture {
+    if matches!(capture, CaptureKind::Old { .. }) {
         io::set_output_capture(None);
     }
 
@@ -152,11 +151,48 @@ fn run_test_inner(
             TestOutcome::Failed { message: Some("test did not panic as expected") }
         }
     };
-    let stdout = capture_buf.map(|mutex| mutex.lock().unwrap_or_else(|e| e.into_inner()).to_vec());
 
+    let stdout = capture.into_inner();
     completion_sender.send(TestCompletion { id, outcome, stdout }).unwrap();
 }
 
+enum CaptureKind {
+    /// Do not capture test-runner output, for `--no-capture`.
+    ///
+    /// (This does not affect `rustc` and other subprocesses spawned by test
+    /// runners, whose output is always captured.)
+    None,
+
+    /// Use the old output-capture implementation, which relies on the unstable
+    /// library feature `#![feature(internal_output_capture)]`.
+    Old { buf: Arc<Mutex<Vec<u8>>> },
+}
+
+impl CaptureKind {
+    fn for_config(config: &Config) -> Self {
+        if config.nocapture {
+            Self::None
+        } else {
+            // Create a capure buffer for `io::set_output_capture`.
+            Self::Old { buf: Default::default() }
+        }
+    }
+
+    fn should_set_panic_hook(&self) -> bool {
+        match self {
+            Self::None => false,
+            Self::Old { .. } => true,
+        }
+    }
+
+    fn into_inner(self) -> Option<Vec<u8>> {
+        match self {
+            Self::None => None,
+            Self::Old { buf } => Some(buf.lock().unwrap_or_else(|e| e.into_inner()).to_vec()),
+        }
+    }
+}
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 struct TestId(usize);
 

From d89a1a0726f54aa65bc2832bfe10e7ea9c374b4e Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 2 Sep 2025 14:18:56 +1000
Subject: [PATCH 0408/1889] Preliminary plumbing of stdout/stderr as `&dyn
 ConsoleOut`

---
 src/tools/compiletest/src/executor.rs       | 24 +++++++++++++++------
 src/tools/compiletest/src/lib.rs            |  1 +
 src/tools/compiletest/src/output_capture.rs | 24 +++++++++++++++++++++
 src/tools/compiletest/src/runtest.rs        | 19 ++++++++++++++--
 4 files changed, 60 insertions(+), 8 deletions(-)
 create mode 100644 src/tools/compiletest/src/output_capture.rs

diff --git a/src/tools/compiletest/src/executor.rs b/src/tools/compiletest/src/executor.rs
index 383a0aaefb9d1..818d171988556 100644
--- a/src/tools/compiletest/src/executor.rs
+++ b/src/tools/compiletest/src/executor.rs
@@ -13,6 +13,7 @@ use std::sync::{Arc, Mutex, mpsc};
 use std::{env, hint, io, mem, panic, thread};
 
 use crate::common::{Config, TestPaths};
+use crate::output_capture::{self, ConsoleOut};
 use crate::panic_hook;
 
 mod deadline;
@@ -131,14 +132,15 @@ fn run_test_inner(
         io::set_output_capture(Some(Arc::clone(buf)));
     }
 
-    let panic_payload = panic::catch_unwind(move || runnable_test.run()).err();
+    let stdout = capture.stdout();
+    let stderr = capture.stderr();
+
+    let panic_payload = panic::catch_unwind(move || runnable_test.run(stdout, stderr)).err();
 
     if let Some(panic_buf) = panic_hook::take_capture_buf() {
         let panic_buf = panic_buf.lock().unwrap_or_else(|e| e.into_inner());
-        // For now, forward any captured panic message to (captured) stderr.
-        // FIXME(Zalathar): Once we have our own output-capture buffer for
-        // non-panic output, append the panic message to that buffer instead.
-        eprint!("{panic_buf}");
+        // Forward any captured panic message to (captured) stderr.
+        write!(stderr, "{panic_buf}");
     }
     if matches!(capture, CaptureKind::Old { .. }) {
         io::set_output_capture(None);
@@ -185,6 +187,14 @@ impl CaptureKind {
         }
     }
 
+    fn stdout(&self) -> &dyn ConsoleOut {
+        &output_capture::Stdout
+    }
+
+    fn stderr(&self) -> &dyn ConsoleOut {
+        &output_capture::Stderr
+    }
+
     fn into_inner(self) -> Option<Vec<u8>> {
         match self {
             Self::None => None,
@@ -210,10 +220,12 @@ impl RunnableTest {
         Self { config, testpaths, revision }
     }
 
-    fn run(&self) {
+    fn run(&self, stdout: &dyn ConsoleOut, stderr: &dyn ConsoleOut) {
         __rust_begin_short_backtrace(|| {
             crate::runtest::run(
                 Arc::clone(&self.config),
+                stdout,
+                stderr,
                 &self.testpaths,
                 self.revision.as_deref(),
             );
diff --git a/src/tools/compiletest/src/lib.rs b/src/tools/compiletest/src/lib.rs
index fa84691a46f41..875d497af1a68 100644
--- a/src/tools/compiletest/src/lib.rs
+++ b/src/tools/compiletest/src/lib.rs
@@ -15,6 +15,7 @@ pub mod directives;
 pub mod errors;
 mod executor;
 mod json;
+mod output_capture;
 mod panic_hook;
 mod raise_fd_limit;
 mod read2;
diff --git a/src/tools/compiletest/src/output_capture.rs b/src/tools/compiletest/src/output_capture.rs
new file mode 100644
index 0000000000000..e5e3e14f288c0
--- /dev/null
+++ b/src/tools/compiletest/src/output_capture.rs
@@ -0,0 +1,24 @@
+use std::fmt;
+use std::panic::RefUnwindSafe;
+
+pub trait ConsoleOut: fmt::Debug + RefUnwindSafe {
+    fn write_fmt(&self, args: fmt::Arguments<'_>);
+}
+
+#[derive(Debug)]
+pub(crate) struct Stdout;
+
+impl ConsoleOut for Stdout {
+    fn write_fmt(&self, args: fmt::Arguments<'_>) {
+        print!("{args}");
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct Stderr;
+
+impl ConsoleOut for Stderr {
+    fn write_fmt(&self, args: fmt::Arguments<'_>) {
+        eprint!("{args}");
+    }
+}
diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index 867624cc8fa97..4b23e569af328 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -23,6 +23,7 @@ use crate::common::{
 };
 use crate::directives::TestProps;
 use crate::errors::{Error, ErrorKind, load_errors};
+use crate::output_capture::ConsoleOut;
 use crate::read2::{Truncated, read2_abbreviated};
 use crate::runtest::compute_diff::{DiffLine, make_diff, write_diff, write_filtered_diff};
 use crate::util::{Utf8PathBufExt, add_dylib_path, static_regex};
@@ -108,7 +109,13 @@ fn dylib_name(name: &str) -> String {
     format!("{}{name}.{}", std::env::consts::DLL_PREFIX, std::env::consts::DLL_EXTENSION)
 }
 
-pub fn run(config: Arc<Config>, testpaths: &TestPaths, revision: Option<&str>) {
+pub fn run(
+    config: Arc<Config>,
+    stdout: &dyn ConsoleOut,
+    stderr: &dyn ConsoleOut,
+    testpaths: &TestPaths,
+    revision: Option<&str>,
+) {
     match &*config.target {
         "arm-linux-androideabi"
         | "armv7-linux-androideabi"
@@ -143,7 +150,7 @@ pub fn run(config: Arc<Config>, testpaths: &TestPaths, revision: Option<&str>) {
         props.incremental_dir = Some(incremental_dir(&config, testpaths, revision));
     }
 
-    let cx = TestCx { config: &config, props: &props, testpaths, revision };
+    let cx = TestCx { config: &config, stdout, stderr, props: &props, testpaths, revision };
 
     if let Err(e) = create_dir_all(&cx.output_base_dir()) {
         panic!("failed to create output base directory {}: {e}", cx.output_base_dir());
@@ -162,6 +169,8 @@ pub fn run(config: Arc<Config>, testpaths: &TestPaths, revision: Option<&str>) {
             revision_props.incremental_dir = props.incremental_dir.clone();
             let rev_cx = TestCx {
                 config: &config,
+                stdout,
+                stderr,
                 props: &revision_props,
                 testpaths,
                 revision: Some(revision),
@@ -212,6 +221,8 @@ pub fn compute_stamp_hash(config: &Config) -> String {
 #[derive(Copy, Clone, Debug)]
 struct TestCx<'test> {
     config: &'test Config,
+    stdout: &'test dyn ConsoleOut,
+    stderr: &'test dyn ConsoleOut,
     props: &'test TestProps,
     testpaths: &'test TestPaths,
     revision: Option<&'test str>,
@@ -978,6 +989,8 @@ impl<'test> TestCx<'test> {
                     self.props.from_aux_file(&aux_testpaths.file, self.revision, self.config);
                 let aux_cx = TestCx {
                     config: self.config,
+                    stdout: self.stdout,
+                    stderr: self.stderr,
                     props: &props_for_aux,
                     testpaths: &aux_testpaths,
                     revision: self.revision,
@@ -1343,6 +1356,8 @@ impl<'test> TestCx<'test> {
         let aux_output = TargetLocation::ThisDirectory(aux_dir.clone());
         let aux_cx = TestCx {
             config: self.config,
+            stdout: self.stdout,
+            stderr: self.stderr,
             props: &aux_props,
             testpaths: &aux_testpaths,
             revision: self.revision,

From 5d71a8a4564fa300f090552a293d3d5caa55decb Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 2 Sep 2025 14:21:29 +1000
Subject: [PATCH 0409/1889] Replace print statements in runtest with `write!`
 or `writeln!`

---
 src/tools/compiletest/src/runtest.rs          | 77 +++++++++++--------
 .../compiletest/src/runtest/codegen_units.rs  | 30 +++++---
 .../compiletest/src/runtest/compute_diff.rs   |  7 +-
 src/tools/compiletest/src/runtest/crashes.rs  |  8 +-
 .../compiletest/src/runtest/debuginfo.rs      | 20 +++--
 .../compiletest/src/runtest/incremental.rs    |  2 +-
 src/tools/compiletest/src/runtest/mir_opt.rs  |  2 +-
 .../compiletest/src/runtest/rustdoc_json.rs   |  4 +-
 src/tools/compiletest/src/runtest/ui.rs       |  8 +-
 9 files changed, 98 insertions(+), 60 deletions(-)

diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index 4b23e569af328..89fb8eb4357b7 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -138,7 +138,7 @@ pub fn run(
 
     if config.verbose {
         // We're going to be dumping a lot of info. Start on a new line.
-        print!("\n\n");
+        write!(stdout, "\n\n");
     }
     debug!("running {}", testpaths.file);
     let mut props = TestProps::from_file(&testpaths.file, revision, &config);
@@ -614,7 +614,8 @@ impl<'test> TestCx<'test> {
             );
         } else {
             for pattern in missing_patterns {
-                println!(
+                writeln!(
+                    self.stdout,
                     "\n{prefix}: error pattern '{pattern}' not found!",
                     prefix = self.error_prefix()
                 );
@@ -794,7 +795,8 @@ impl<'test> TestCx<'test> {
                 };
                 format!("{file_name}:{line_num}{opt_col_num}")
             };
-            let print_error = |e| println!("{}: {}: {}", line_str(e), e.kind, e.msg.cyan());
+            let print_error =
+                |e| writeln!(self.stdout, "{}: {}: {}", line_str(e), e.kind, e.msg.cyan());
             let push_suggestion =
                 |suggestions: &mut Vec<_>, e: &Error, kind, line, msg, color, rank| {
                     let mut ret = String::new();
@@ -822,7 +824,7 @@ impl<'test> TestCx<'test> {
                 if let Some(&(_, top_rank)) = suggestions.first() {
                     for (suggestion, rank) in suggestions {
                         if rank == top_rank {
-                            println!("  {} {suggestion}", prefix.color(color));
+                            writeln!(self.stdout, "  {} {suggestion}", prefix.color(color));
                         }
                     }
                 }
@@ -835,7 +837,8 @@ impl<'test> TestCx<'test> {
             // - only known line - meh, but suggested
             // - others are not worth suggesting
             if !unexpected.is_empty() {
-                println!(
+                writeln!(
+                    self.stdout,
                     "\n{prefix}: {n} diagnostics reported in JSON output but not expected in test file",
                     prefix = self.error_prefix(),
                     n = unexpected.len(),
@@ -869,7 +872,8 @@ impl<'test> TestCx<'test> {
                 }
             }
             if !not_found.is_empty() {
-                println!(
+                writeln!(
+                    self.stdout,
                     "\n{prefix}: {n} diagnostics expected in test file but not reported in JSON output",
                     prefix = self.error_prefix(),
                     n = not_found.len(),
@@ -1963,11 +1967,11 @@ impl<'test> TestCx<'test> {
         } else {
             path.file_name().unwrap().into()
         };
-        println!("------{proc_name} stdout------------------------------");
-        println!("{}", out);
-        println!("------{proc_name} stderr------------------------------");
-        println!("{}", err);
-        println!("------------------------------------------");
+        writeln!(self.stdout, "------{proc_name} stdout------------------------------");
+        writeln!(self.stdout, "{}", out);
+        writeln!(self.stdout, "------{proc_name} stderr------------------------------");
+        writeln!(self.stdout, "{}", err);
+        writeln!(self.stdout, "------------------------------------------");
     }
 
     fn dump_output_file(&self, out: &str, extension: &str) {
@@ -2029,7 +2033,7 @@ impl<'test> TestCx<'test> {
         debug!("{message}");
         if self.config.verbose {
             // Note: `./x test ... --verbose --no-capture` is needed to see this print.
-            println!("{message}");
+            writeln!(self.stdout, "{message}");
         }
     }
 
@@ -2045,7 +2049,7 @@ impl<'test> TestCx<'test> {
 
     #[track_caller]
     fn fatal(&self, err: &str) -> ! {
-        println!("\n{prefix}: {err}", prefix = self.error_prefix());
+        writeln!(self.stdout, "\n{prefix}: {err}", prefix = self.error_prefix());
         error!("fatal error, panic: {:?}", err);
         panic!("fatal error");
     }
@@ -2063,15 +2067,15 @@ impl<'test> TestCx<'test> {
         proc_res: &ProcRes,
         callback_before_unwind: impl FnOnce(),
     ) -> ! {
-        println!("\n{prefix}: {err}", prefix = self.error_prefix());
+        writeln!(self.stdout, "\n{prefix}: {err}", prefix = self.error_prefix());
 
         // Some callers want to print additional notes after the main error message.
         if let Some(note) = extra_note {
-            println!("{note}");
+            writeln!(self.stdout, "{note}");
         }
 
         // Print the details and output of the subprocess that caused this test to fail.
-        println!("{}", proc_res.format_info());
+        writeln!(self.stdout, "{}", proc_res.format_info());
 
         // Some callers want print more context or show a custom diff before the unwind occurs.
         callback_before_unwind();
@@ -2141,7 +2145,7 @@ impl<'test> TestCx<'test> {
         if !self.config.has_html_tidy {
             return;
         }
-        println!("info: generating a diff against nightly rustdoc");
+        writeln!(self.stdout, "info: generating a diff against nightly rustdoc");
 
         let suffix =
             self.safe_revision().map_or("nightly".into(), |path| path.to_owned() + "-nightly");
@@ -2177,7 +2181,7 @@ impl<'test> TestCx<'test> {
 
         let proc_res = new_rustdoc.document(&compare_dir, &new_rustdoc.testpaths);
         if !proc_res.status.success() {
-            eprintln!("failed to run nightly rustdoc");
+            writeln!(self.stderr, "failed to run nightly rustdoc");
             return;
         }
 
@@ -2222,6 +2226,7 @@ impl<'test> TestCx<'test> {
         let diff_filename = format!("build/tmp/rustdoc-compare-{}.diff", std::process::id());
 
         if !write_filtered_diff(
+            self,
             &diff_filename,
             out_dir,
             &compare_dir,
@@ -2242,7 +2247,7 @@ impl<'test> TestCx<'test> {
         if let Some(pager) = pager {
             let pager = pager.trim();
             if self.config.verbose {
-                eprintln!("using pager {}", pager);
+                writeln!(self.stderr, "using pager {}", pager);
             }
             let output = Command::new(pager)
                 // disable paging; we want this to be non-interactive
@@ -2253,8 +2258,8 @@ impl<'test> TestCx<'test> {
                 .output()
                 .unwrap();
             assert!(output.status.success());
-            println!("{}", String::from_utf8_lossy(&output.stdout));
-            eprintln!("{}", String::from_utf8_lossy(&output.stderr));
+            writeln!(self.stdout, "{}", String::from_utf8_lossy(&output.stdout));
+            writeln!(self.stderr, "{}", String::from_utf8_lossy(&output.stderr));
         } else {
             warning!("no pager configured, falling back to unified diff");
             help!(
@@ -2269,7 +2274,7 @@ impl<'test> TestCx<'test> {
                 match diff.read_until(b'\n', &mut line) {
                     Ok(0) => break,
                     Ok(_) => {}
-                    Err(e) => eprintln!("ERROR: {:?}", e),
+                    Err(e) => writeln!(self.stderr, "ERROR: {:?}", e),
                 }
                 match String::from_utf8(line.clone()) {
                     Ok(line) => {
@@ -2817,11 +2822,11 @@ impl<'test> TestCx<'test> {
         if let Err(err) = fs::write(&actual_path, &actual) {
             self.fatal(&format!("failed to write {stream} to `{actual_path}`: {err}",));
         }
-        println!("Saved the actual {stream} to `{actual_path}`");
+        writeln!(self.stdout, "Saved the actual {stream} to `{actual_path}`");
 
         if !self.config.bless {
             if expected.is_empty() {
-                println!("normalized {}:\n{}\n", stream, actual);
+                writeln!(self.stdout, "normalized {}:\n{}\n", stream, actual);
             } else {
                 self.show_diff(
                     stream,
@@ -2845,14 +2850,15 @@ impl<'test> TestCx<'test> {
                 if let Err(err) = fs::write(&expected_path, &actual) {
                     self.fatal(&format!("failed to write {stream} to `{expected_path}`: {err}"));
                 }
-                println!(
+                writeln!(
+                    self.stdout,
                     "Blessing the {stream} of `{test_name}` as `{expected_path}`",
                     test_name = self.testpaths.file
                 );
             }
         }
 
-        println!("\nThe actual {stream} differed from the expected {stream}");
+        writeln!(self.stdout, "\nThe actual {stream} differed from the expected {stream}");
 
         if self.config.bless { CompareOutcome::Blessed } else { CompareOutcome::Differed }
     }
@@ -2867,7 +2873,7 @@ impl<'test> TestCx<'test> {
         actual: &str,
         actual_unnormalized: &str,
     ) {
-        eprintln!("diff of {stream}:\n");
+        writeln!(self.stderr, "diff of {stream}:\n");
         if let Some(diff_command) = self.config.diff_command.as_deref() {
             let mut args = diff_command.split_whitespace();
             let name = args.next().unwrap();
@@ -2879,11 +2885,11 @@ impl<'test> TestCx<'test> {
                 }
                 Ok(output) => {
                     let output = String::from_utf8_lossy(&output.stdout);
-                    eprint!("{output}");
+                    write!(self.stderr, "{output}");
                 }
             }
         } else {
-            eprint!("{}", write_diff(expected, actual, 3));
+            write!(self.stderr, "{}", write_diff(expected, actual, 3));
         }
 
         // NOTE: argument order is important, we need `actual` to be on the left so the line number match up when we compare it to `actual_unnormalized` below.
@@ -2921,9 +2927,16 @@ impl<'test> TestCx<'test> {
             && !mismatches_unnormalized.is_empty()
             && !mismatches_normalized.is_empty()
         {
-            eprintln!("Note: some mismatched output was normalized before being compared");
+            writeln!(
+                self.stderr,
+                "Note: some mismatched output was normalized before being compared"
+            );
             // FIXME: respect diff_command
-            eprint!("{}", write_diff(&mismatches_unnormalized, &mismatches_normalized, 0));
+            write!(
+                self.stderr,
+                "{}",
+                write_diff(&mismatches_unnormalized, &mismatches_normalized, 0)
+            );
         }
     }
 
@@ -3001,7 +3014,7 @@ impl<'test> TestCx<'test> {
         fs::create_dir_all(&incremental_dir).unwrap();
 
         if self.config.verbose {
-            println!("init_incremental_test: incremental_dir={incremental_dir}");
+            writeln!(self.stdout, "init_incremental_test: incremental_dir={incremental_dir}");
         }
     }
 }
diff --git a/src/tools/compiletest/src/runtest/codegen_units.rs b/src/tools/compiletest/src/runtest/codegen_units.rs
index 44ddcb1d28882..16c251c3c9e24 100644
--- a/src/tools/compiletest/src/runtest/codegen_units.rs
+++ b/src/tools/compiletest/src/runtest/codegen_units.rs
@@ -62,13 +62,13 @@ impl TestCx<'_> {
         if !missing.is_empty() {
             missing.sort();
 
-            println!("\nThese items should have been contained but were not:\n");
+            writeln!(self.stdout, "\nThese items should have been contained but were not:\n");
 
             for item in &missing {
-                println!("{}", item);
+                writeln!(self.stdout, "{}", item);
             }
 
-            println!("\n");
+            writeln!(self.stdout, "\n");
         }
 
         if !unexpected.is_empty() {
@@ -78,24 +78,32 @@ impl TestCx<'_> {
                 sorted
             };
 
-            println!("\nThese items were contained but should not have been:\n");
+            writeln!(self.stdout, "\nThese items were contained but should not have been:\n");
 
             for item in sorted {
-                println!("{}", item);
+                writeln!(self.stdout, "{}", item);
             }
 
-            println!("\n");
+            writeln!(self.stdout, "\n");
         }
 
         if !wrong_cgus.is_empty() {
             wrong_cgus.sort_by_key(|pair| pair.0.name.clone());
-            println!("\nThe following items were assigned to wrong codegen units:\n");
+            writeln!(self.stdout, "\nThe following items were assigned to wrong codegen units:\n");
 
             for &(ref expected_item, ref actual_item) in &wrong_cgus {
-                println!("{}", expected_item.name);
-                println!("  expected: {}", codegen_units_to_str(&expected_item.codegen_units));
-                println!("  actual:   {}", codegen_units_to_str(&actual_item.codegen_units));
-                println!();
+                writeln!(self.stdout, "{}", expected_item.name);
+                writeln!(
+                    self.stdout,
+                    "  expected: {}",
+                    codegen_units_to_str(&expected_item.codegen_units)
+                );
+                writeln!(
+                    self.stdout,
+                    "  actual:   {}",
+                    codegen_units_to_str(&actual_item.codegen_units)
+                );
+                writeln!(self.stdout);
             }
         }
 
diff --git a/src/tools/compiletest/src/runtest/compute_diff.rs b/src/tools/compiletest/src/runtest/compute_diff.rs
index 509e7e117039c..3363127b3ea37 100644
--- a/src/tools/compiletest/src/runtest/compute_diff.rs
+++ b/src/tools/compiletest/src/runtest/compute_diff.rs
@@ -3,6 +3,8 @@ use std::fs::{File, FileType};
 
 use camino::Utf8Path;
 
+use crate::runtest::TestCx;
+
 #[derive(Debug, PartialEq)]
 pub enum DiffLine {
     Context(String),
@@ -112,6 +114,7 @@ pub(crate) fn write_diff(expected: &str, actual: &str, context_size: usize) -> S
 ///
 /// Returns whether any data was actually written.
 pub(crate) fn write_filtered_diff<Filter>(
+    cx: &TestCx<'_>,
     diff_filename: &str,
     out_dir: &Utf8Path,
     compare_dir: &Utf8Path,
@@ -147,11 +150,11 @@ where
     }
 
     if !wrote_data {
-        println!("note: diff is identical to nightly rustdoc");
+        writeln!(cx.stdout, "note: diff is identical to nightly rustdoc");
         assert!(diff_output.metadata().unwrap().len() == 0);
         return false;
     } else if verbose {
-        eprintln!("printing diff:");
+        writeln!(cx.stderr, "printing diff:");
         let mut buf = Vec::new();
         diff_output.read_to_end(&mut buf).unwrap();
         std::io::stderr().lock().write_all(&mut buf).unwrap();
diff --git a/src/tools/compiletest/src/runtest/crashes.rs b/src/tools/compiletest/src/runtest/crashes.rs
index da1e74b4a56bc..0aae7eaa39cd5 100644
--- a/src/tools/compiletest/src/runtest/crashes.rs
+++ b/src/tools/compiletest/src/runtest/crashes.rs
@@ -6,10 +6,10 @@ impl TestCx<'_> {
         let proc_res = self.compile_test(WillExecute::No, self.should_emit_metadata(pm));
 
         if std::env::var("COMPILETEST_VERBOSE_CRASHES").is_ok() {
-            eprintln!("{}", proc_res.status);
-            eprintln!("{}", proc_res.stdout);
-            eprintln!("{}", proc_res.stderr);
-            eprintln!("{}", proc_res.cmdline);
+            writeln!(self.stderr, "{}", proc_res.status);
+            writeln!(self.stderr, "{}", proc_res.stdout);
+            writeln!(self.stderr, "{}", proc_res.stderr);
+            writeln!(self.stderr, "{}", proc_res.cmdline);
         }
 
         // if a test does not crash, consider it an error
diff --git a/src/tools/compiletest/src/runtest/debuginfo.rs b/src/tools/compiletest/src/runtest/debuginfo.rs
index 88d022b8bbaaf..071c0863b7e9f 100644
--- a/src/tools/compiletest/src/runtest/debuginfo.rs
+++ b/src/tools/compiletest/src/runtest/debuginfo.rs
@@ -245,7 +245,7 @@ impl TestCx<'_> {
                 cmdline,
             };
             if adb.kill().is_err() {
-                println!("Adb process is already finished.");
+                writeln!(self.stdout, "Adb process is already finished.");
             }
         } else {
             let rust_pp_module_abs_path = self.config.src_root.join("src").join("etc");
@@ -256,7 +256,11 @@ impl TestCx<'_> {
 
             match self.config.gdb_version {
                 Some(version) => {
-                    println!("NOTE: compiletest thinks it is using GDB version {}", version);
+                    writeln!(
+                        self.stdout,
+                        "NOTE: compiletest thinks it is using GDB version {}",
+                        version
+                    );
 
                     if !self.props.disable_gdb_pretty_printers
                         && version > extract_gdb_version("7.4").unwrap()
@@ -278,7 +282,8 @@ impl TestCx<'_> {
                     }
                 }
                 _ => {
-                    println!(
+                    writeln!(
+                        self.stdout,
                         "NOTE: compiletest does not know which version of \
                          GDB it is using"
                     );
@@ -376,10 +381,15 @@ impl TestCx<'_> {
 
         match self.config.lldb_version {
             Some(ref version) => {
-                println!("NOTE: compiletest thinks it is using LLDB version {}", version);
+                writeln!(
+                    self.stdout,
+                    "NOTE: compiletest thinks it is using LLDB version {}",
+                    version
+                );
             }
             _ => {
-                println!(
+                writeln!(
+                    self.stdout,
                     "NOTE: compiletest does not know which version of \
                      LLDB it is using"
                 );
diff --git a/src/tools/compiletest/src/runtest/incremental.rs b/src/tools/compiletest/src/runtest/incremental.rs
index 90cff6bab4dc6..44eb80300c394 100644
--- a/src/tools/compiletest/src/runtest/incremental.rs
+++ b/src/tools/compiletest/src/runtest/incremental.rs
@@ -30,7 +30,7 @@ impl TestCx<'_> {
         assert!(incremental_dir.exists(), "init_incremental_test failed to create incremental dir");
 
         if self.config.verbose {
-            print!("revision={:?} props={:#?}", revision, self.props);
+            write!(self.stdout, "revision={:?} props={:#?}", revision, self.props);
         }
 
         if revision.starts_with("cpass") {
diff --git a/src/tools/compiletest/src/runtest/mir_opt.rs b/src/tools/compiletest/src/runtest/mir_opt.rs
index 55043bf4bc26d..9448792638346 100644
--- a/src/tools/compiletest/src/runtest/mir_opt.rs
+++ b/src/tools/compiletest/src/runtest/mir_opt.rs
@@ -80,7 +80,7 @@ impl TestCx<'_> {
                 }
                 let expected_string = fs::read_to_string(&expected_file).unwrap();
                 if dumped_string != expected_string {
-                    print!("{}", write_diff(&expected_string, &dumped_string, 3));
+                    write!(self.stdout, "{}", write_diff(&expected_string, &dumped_string, 3));
                     panic!(
                         "Actual MIR output differs from expected MIR output {}",
                         expected_file.display()
diff --git a/src/tools/compiletest/src/runtest/rustdoc_json.rs b/src/tools/compiletest/src/runtest/rustdoc_json.rs
index 083398f927455..b8da6e2ac5280 100644
--- a/src/tools/compiletest/src/runtest/rustdoc_json.rs
+++ b/src/tools/compiletest/src/runtest/rustdoc_json.rs
@@ -30,8 +30,8 @@ impl TestCx<'_> {
 
         if !res.status.success() {
             self.fatal_proc_rec_general("jsondocck failed!", None, &res, || {
-                println!("Rustdoc Output:");
-                println!("{}", proc_res.format_info());
+                writeln!(self.stdout, "Rustdoc Output:");
+                writeln!(self.stdout, "{}", proc_res.format_info());
             })
         }
 
diff --git a/src/tools/compiletest/src/runtest/ui.rs b/src/tools/compiletest/src/runtest/ui.rs
index 40b0ee0a399d4..d683a325c8666 100644
--- a/src/tools/compiletest/src/runtest/ui.rs
+++ b/src/tools/compiletest/src/runtest/ui.rs
@@ -115,10 +115,14 @@ impl TestCx<'_> {
         }
 
         if errors > 0 {
-            println!("To update references, rerun the tests and pass the `--bless` flag");
+            writeln!(
+                self.stdout,
+                "To update references, rerun the tests and pass the `--bless` flag"
+            );
             let relative_path_to_file =
                 self.testpaths.relative_dir.join(self.testpaths.file.file_name().unwrap());
-            println!(
+            writeln!(
+                self.stdout,
                 "To only update this specific test, also pass `--test-args {}`",
                 relative_path_to_file,
             );

From 7b35d8e1ab2d913f4b15d0ee21d5bd8d50798e9c Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 2 Sep 2025 11:57:33 +0200
Subject: [PATCH 0410/1889] Fix `unknown number` error when generating search
 index

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

diff --git a/src/librustdoc/formats/item_type.rs b/src/librustdoc/formats/item_type.rs
index e94ef51730993..b8b00ab582cdb 100644
--- a/src/librustdoc/formats/item_type.rs
+++ b/src/librustdoc/formats/item_type.rs
@@ -78,7 +78,7 @@ impl<'de> Deserialize<'de> for ItemType {
         impl<'de> de::Visitor<'de> for ItemTypeVisitor {
             type Value = ItemType;
             fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                write!(formatter, "an integer between 0 and 25")
+                write!(formatter, "an integer between 0 and 27")
             }
             fn visit_u64<E: de::Error>(self, v: u64) -> Result<ItemType, E> {
                 Ok(match v {
@@ -107,7 +107,8 @@ impl<'de> Deserialize<'de> for ItemType {
                     23 => ItemType::ProcAttribute,
                     24 => ItemType::ProcDerive,
                     25 => ItemType::TraitAlias,
-                    _ => return Err(E::missing_field("unknown number")),
+                    27 => ItemType::Attribute,
+                    _ => return Err(E::missing_field("unknown number for `ItemType` enum")),
                 })
             }
         }

From 4ecca581fad73c51d7c7a78c4b97a3ada2ca5249 Mon Sep 17 00:00:00 2001
From: Hans Wennborg <hans@chromium.org>
Date: Tue, 2 Sep 2025 11:57:58 +0200
Subject: [PATCH 0411/1889] Adjust issue-118306.rs test after LLVM change

This updates tests/codegen-llvm/issues/issue-118306.rs to pass also
after https://github.com/llvm/llvm-project/pull/155415
---
 tests/codegen-llvm/issues/issue-118306.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/codegen-llvm/issues/issue-118306.rs b/tests/codegen-llvm/issues/issue-118306.rs
index f12dc7cdfe2c4..934a7687b6015 100644
--- a/tests/codegen-llvm/issues/issue-118306.rs
+++ b/tests/codegen-llvm/issues/issue-118306.rs
@@ -11,7 +11,7 @@ pub fn branchy(input: u64) -> u64 {
     // CHECK-LABEL: @branchy(
     // CHECK-NEXT:  start:
     // CHECK-NEXT:    [[_2:%.*]] = and i64 [[INPUT:%.*]], 3
-    // CHECK-NEXT:    [[SWITCH_GEP:%.*]] = getelementptr inbounds{{( nuw)?}} [4 x i64], ptr @switch.table.branchy, i64 0, i64 [[_2]]
+    // CHECK-NEXT:    [[SWITCH_GEP:%.*]] = getelementptr inbounds{{( nuw)?}} {{\[4 x i64\]|i64}}, ptr @switch.table.branchy{{(, i64 0)?}}, i64 [[_2]]
     // CHECK-NEXT:    [[SWITCH_LOAD:%.*]] = load i64, ptr [[SWITCH_GEP]]
     // CHECK-NEXT:    ret i64 [[SWITCH_LOAD]]
     match input % 4 {

From ad2e0961366a6bf5e01d6863a459424e78ebcf40 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 2 Sep 2025 12:04:07 +0200
Subject: [PATCH 0412/1889] Make it impossible to forget a conversion for the
 rustdoc `ItemType` enum

---
 src/librustdoc/formats/item_type.rs | 95 ++++++++++++-----------------
 1 file changed, 40 insertions(+), 55 deletions(-)

diff --git a/src/librustdoc/formats/item_type.rs b/src/librustdoc/formats/item_type.rs
index b8b00ab582cdb..ab40c01cb369d 100644
--- a/src/librustdoc/formats/item_type.rs
+++ b/src/librustdoc/formats/item_type.rs
@@ -8,6 +8,9 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer, de};
 
 use crate::clean;
 
+macro_rules! item_type {
+    ($($variant:ident = $number:literal,)+) => {
+
 /// Item type. Corresponds to `clean::ItemEnum` variants.
 ///
 /// The search index uses item types encoded as smaller numbers which equal to
@@ -29,35 +32,7 @@ use crate::clean;
 #[derive(Copy, PartialEq, Eq, Hash, Clone, Debug, PartialOrd, Ord)]
 #[repr(u8)]
 pub(crate) enum ItemType {
-    Keyword = 0,
-    Primitive = 1,
-    Module = 2,
-    ExternCrate = 3,
-    Import = 4,
-    Struct = 5,
-    Enum = 6,
-    Function = 7,
-    TypeAlias = 8,
-    Static = 9,
-    Trait = 10,
-    Impl = 11,
-    TyMethod = 12,
-    Method = 13,
-    StructField = 14,
-    Variant = 15,
-    Macro = 16,
-    AssocType = 17,
-    Constant = 18,
-    AssocConst = 19,
-    Union = 20,
-    ForeignType = 21,
-    // OpaqueTy used to be here, but it was removed in #127276
-    ProcAttribute = 23,
-    ProcDerive = 24,
-    TraitAlias = 25,
-    // This number is reserved for use in JavaScript
-    // Generic = 26,
-    Attribute = 27,
+    $($variant = $number,)+
 }
 
 impl Serialize for ItemType {
@@ -82,32 +57,7 @@ impl<'de> Deserialize<'de> for ItemType {
             }
             fn visit_u64<E: de::Error>(self, v: u64) -> Result<ItemType, E> {
                 Ok(match v {
-                    0 => ItemType::Keyword,
-                    1 => ItemType::Primitive,
-                    2 => ItemType::Module,
-                    3 => ItemType::ExternCrate,
-                    4 => ItemType::Import,
-                    5 => ItemType::Struct,
-                    6 => ItemType::Enum,
-                    7 => ItemType::Function,
-                    8 => ItemType::TypeAlias,
-                    9 => ItemType::Static,
-                    10 => ItemType::Trait,
-                    11 => ItemType::Impl,
-                    12 => ItemType::TyMethod,
-                    13 => ItemType::Method,
-                    14 => ItemType::StructField,
-                    15 => ItemType::Variant,
-                    16 => ItemType::Macro,
-                    17 => ItemType::AssocType,
-                    18 => ItemType::Constant,
-                    19 => ItemType::AssocConst,
-                    20 => ItemType::Union,
-                    21 => ItemType::ForeignType,
-                    23 => ItemType::ProcAttribute,
-                    24 => ItemType::ProcDerive,
-                    25 => ItemType::TraitAlias,
-                    27 => ItemType::Attribute,
+                    $($number => ItemType::$variant,)+
                     _ => return Err(E::missing_field("unknown number for `ItemType` enum")),
                 })
             }
@@ -116,6 +66,41 @@ impl<'de> Deserialize<'de> for ItemType {
     }
 }
 
+    }
+}
+
+item_type! {
+    Keyword = 0,
+    Primitive = 1,
+    Module = 2,
+    ExternCrate = 3,
+    Import = 4,
+    Struct = 5,
+    Enum = 6,
+    Function = 7,
+    TypeAlias = 8,
+    Static = 9,
+    Trait = 10,
+    Impl = 11,
+    TyMethod = 12,
+    Method = 13,
+    StructField = 14,
+    Variant = 15,
+    Macro = 16,
+    AssocType = 17,
+    Constant = 18,
+    AssocConst = 19,
+    Union = 20,
+    ForeignType = 21,
+    // OpaqueTy used to be here, but it was removed in #127276
+    ProcAttribute = 23,
+    ProcDerive = 24,
+    TraitAlias = 25,
+    // This number is reserved for use in JavaScript
+    // Generic = 26,
+    Attribute = 27,
+}
+
 impl<'a> From<&'a clean::Item> for ItemType {
     fn from(item: &'a clean::Item) -> ItemType {
         let kind = match &item.kind {

From 821a44d3efb677e65b392e627f2d6647841db77e Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 1 Sep 2025 09:02:43 +0200
Subject: [PATCH 0413/1889] move some configuration enums to a more logical
 place

---
 src/tools/miri/src/eval.rs    | 59 -----------------------------------
 src/tools/miri/src/lib.rs     | 10 +++---
 src/tools/miri/src/machine.rs | 59 +++++++++++++++++++++++++++++++++++
 3 files changed, 63 insertions(+), 65 deletions(-)

diff --git a/src/tools/miri/src/eval.rs b/src/tools/miri/src/eval.rs
index 4c531a8d1f526..43d251b157ba0 100644
--- a/src/tools/miri/src/eval.rs
+++ b/src/tools/miri/src/eval.rs
@@ -32,65 +32,6 @@ pub enum MiriEntryFnType {
 /// will hang the program.
 const MAIN_THREAD_YIELDS_AT_SHUTDOWN: u32 = 256;
 
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub enum AlignmentCheck {
-    /// Do not check alignment.
-    None,
-    /// Check alignment "symbolically", i.e., using only the requested alignment for an allocation and not its real base address.
-    Symbolic,
-    /// Check alignment on the actual physical integer address.
-    Int,
-}
-
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub enum RejectOpWith {
-    /// Isolated op is rejected with an abort of the machine.
-    Abort,
-
-    /// If not Abort, miri returns an error for an isolated op.
-    /// Following options determine if user should be warned about such error.
-    /// Do not print warning about rejected isolated op.
-    NoWarning,
-
-    /// Print a warning about rejected isolated op, with backtrace.
-    Warning,
-
-    /// Print a warning about rejected isolated op, without backtrace.
-    WarningWithoutBacktrace,
-}
-
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub enum IsolatedOp {
-    /// Reject an op requiring communication with the host. By
-    /// default, miri rejects the op with an abort. If not, it returns
-    /// an error code, and prints a warning about it. Warning levels
-    /// are controlled by `RejectOpWith` enum.
-    Reject(RejectOpWith),
-
-    /// Execute op requiring communication with the host, i.e. disable isolation.
-    Allow,
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum BacktraceStyle {
-    /// Prints a terser backtrace which ideally only contains relevant information.
-    Short,
-    /// Prints a backtrace with all possible information.
-    Full,
-    /// Prints only the frame that the error occurs in.
-    Off,
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum ValidationMode {
-    /// Do not perform any kind of validation.
-    No,
-    /// Validate the interior of the value, but not things behind references.
-    Shallow,
-    /// Fully recursively validate references.
-    Deep,
-}
-
 /// Configuration needed to spawn a Miri instance.
 #[derive(Clone)]
 pub struct MiriConfig {
diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
index 5ed6d6b346c7a..090f10f481332 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -138,15 +138,13 @@ pub use crate::data_structures::mono_hash_map::MonoHashMap;
 pub use crate::diagnostics::{
     EvalContextExt as _, NonHaltingDiagnostic, TerminationInfo, report_error,
 };
-pub use crate::eval::{
-    AlignmentCheck, BacktraceStyle, IsolatedOp, MiriConfig, MiriEntryFnType, RejectOpWith,
-    ValidationMode, create_ecx, eval_entry,
-};
+pub use crate::eval::{MiriConfig, MiriEntryFnType, create_ecx, eval_entry};
 pub use crate::helpers::{AccessKind, EvalContextExt as _, ToU64 as _, ToUsize as _};
 pub use crate::intrinsics::EvalContextExt as _;
 pub use crate::machine::{
-    AllocExtra, DynMachineCallback, FrameExtra, MachineCallback, MemoryKind, MiriInterpCx,
-    MiriInterpCxExt, MiriMachine, MiriMemoryKind, PrimitiveLayouts, Provenance, ProvenanceExtra,
+    AlignmentCheck, AllocExtra, BacktraceStyle, DynMachineCallback, FrameExtra, IsolatedOp,
+    MachineCallback, MemoryKind, MiriInterpCx, MiriInterpCxExt, MiriMachine, MiriMemoryKind,
+    PrimitiveLayouts, Provenance, ProvenanceExtra, RejectOpWith, ValidationMode,
 };
 pub use crate::operator::EvalContextExt as _;
 pub use crate::provenance_gc::{EvalContextExt as _, LiveAllocs, VisitProvenance, VisitWith};
diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index 0136de5521634..e27b2e89b48a9 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -49,6 +49,65 @@ pub const SIGRTMAX: i32 = 42;
 /// base address for each evaluation would produce unbounded memory usage.
 const ADDRS_PER_ANON_GLOBAL: usize = 32;
 
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub enum AlignmentCheck {
+    /// Do not check alignment.
+    None,
+    /// Check alignment "symbolically", i.e., using only the requested alignment for an allocation and not its real base address.
+    Symbolic,
+    /// Check alignment on the actual physical integer address.
+    Int,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub enum RejectOpWith {
+    /// Isolated op is rejected with an abort of the machine.
+    Abort,
+
+    /// If not Abort, miri returns an error for an isolated op.
+    /// Following options determine if user should be warned about such error.
+    /// Do not print warning about rejected isolated op.
+    NoWarning,
+
+    /// Print a warning about rejected isolated op, with backtrace.
+    Warning,
+
+    /// Print a warning about rejected isolated op, without backtrace.
+    WarningWithoutBacktrace,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub enum IsolatedOp {
+    /// Reject an op requiring communication with the host. By
+    /// default, miri rejects the op with an abort. If not, it returns
+    /// an error code, and prints a warning about it. Warning levels
+    /// are controlled by `RejectOpWith` enum.
+    Reject(RejectOpWith),
+
+    /// Execute op requiring communication with the host, i.e. disable isolation.
+    Allow,
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum BacktraceStyle {
+    /// Prints a terser backtrace which ideally only contains relevant information.
+    Short,
+    /// Prints a backtrace with all possible information.
+    Full,
+    /// Prints only the frame that the error occurs in.
+    Off,
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum ValidationMode {
+    /// Do not perform any kind of validation.
+    No,
+    /// Validate the interior of the value, but not things behind references.
+    Shallow,
+    /// Fully recursively validate references.
+    Deep,
+}
+
 /// Extra data stored with each stack frame
 pub struct FrameExtra<'tcx> {
     /// Extra data for the Borrow Tracker.

From a6c0519faef6512aff1ee1a1fe2bf2556fe2d642 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 2 Sep 2025 12:09:05 +0200
Subject: [PATCH 0414/1889] improve process::abort rendering in Miri backtraces

---
 library/std/src/panicking.rs                          |  4 ++--
 library/std/src/process.rs                            |  1 +
 library/std/src/sys/pal/unix/mod.rs                   |  1 +
 library/std/src/sys/pal/windows/mod.rs                |  1 +
 .../miri/tests/fail/alloc/alloc_error_handler.rs      |  2 --
 .../miri/tests/fail/alloc/alloc_error_handler.stderr  | 10 ++++------
 .../exported_symbol_bad_unwind2.both.stderr           |  9 ++++-----
 .../exported_symbol_bad_unwind2.definition.stderr     |  9 ++++-----
 .../exported_symbol_bad_unwind2.extern_block.stderr   |  2 +-
 .../function_calls/exported_symbol_bad_unwind2.rs     |  2 --
 src/tools/miri/tests/fail/panic/abort_unwind.rs       |  2 --
 src/tools/miri/tests/fail/panic/abort_unwind.stderr   |  9 ++++-----
 src/tools/miri/tests/fail/panic/double_panic.rs       |  2 --
 src/tools/miri/tests/fail/panic/double_panic.stderr   |  7 +++----
 src/tools/miri/tests/fail/panic/panic_abort1.rs       |  2 --
 src/tools/miri/tests/fail/panic/panic_abort1.stderr   | 10 ++++------
 src/tools/miri/tests/fail/panic/panic_abort2.rs       |  2 --
 src/tools/miri/tests/fail/panic/panic_abort2.stderr   | 10 ++++------
 src/tools/miri/tests/fail/panic/panic_abort3.rs       |  2 --
 src/tools/miri/tests/fail/panic/panic_abort3.stderr   | 10 ++++------
 src/tools/miri/tests/fail/panic/panic_abort4.rs       |  2 --
 src/tools/miri/tests/fail/panic/panic_abort4.stderr   | 10 ++++------
 src/tools/miri/tests/fail/ptr_swap_nonoverlapping.rs  |  2 --
 .../miri/tests/fail/ptr_swap_nonoverlapping.stderr    |  9 ++++-----
 src/tools/miri/tests/fail/terminate-terminator.rs     |  2 --
 src/tools/miri/tests/fail/terminate-terminator.stderr | 11 +++++------
 src/tools/miri/tests/fail/unwind-action-terminate.rs  |  2 --
 .../miri/tests/fail/unwind-action-terminate.stderr    |  9 ++++-----
 28 files changed, 54 insertions(+), 90 deletions(-)

diff --git a/library/std/src/panicking.rs b/library/std/src/panicking.rs
index 87a3fc80dfab2..8b7282c51d123 100644
--- a/library/std/src/panicking.rs
+++ b/library/std/src/panicking.rs
@@ -819,7 +819,7 @@ fn panic_with_hook(
                 rtprintpanic!("aborting due to panic at {location}:\n{payload}\n");
             }
         }
-        crate::sys::abort_internal();
+        crate::process::abort();
     }
 
     match *HOOK.read().unwrap_or_else(PoisonError::into_inner) {
@@ -853,7 +853,7 @@ fn panic_with_hook(
         // through a nounwind function (e.g. extern "C") then we cannot continue
         // unwinding and have to abort immediately.
         rtprintpanic!("thread caused non-unwinding panic. aborting.\n");
-        crate::sys::abort_internal();
+        crate::process::abort();
     }
 
     rust_panic(payload)
diff --git a/library/std/src/process.rs b/library/std/src/process.rs
index 373584d0117ce..48265de90c4d6 100644
--- a/library/std/src/process.rs
+++ b/library/std/src/process.rs
@@ -2495,6 +2495,7 @@ pub fn exit(code: i32) -> ! {
 #[stable(feature = "process_abort", since = "1.17.0")]
 #[cold]
 #[cfg_attr(not(test), rustc_diagnostic_item = "process_abort")]
+#[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
 pub fn abort() -> ! {
     crate::sys::abort_internal();
 }
diff --git a/library/std/src/sys/pal/unix/mod.rs b/library/std/src/sys/pal/unix/mod.rs
index 400128acf1264..ac5c823a1bf6d 100644
--- a/library/std/src/sys/pal/unix/mod.rs
+++ b/library/std/src/sys/pal/unix/mod.rs
@@ -364,6 +364,7 @@ pub fn cvt_nz(error: libc::c_int) -> crate::io::Result<()> {
 // multithreaded C program.  It is much less severe for Rust, because Rust
 // stdlib doesn't use libc stdio buffering.  In a typical Rust program, which
 // does not use C stdio, even a buggy libc::abort() is, in fact, safe.
+#[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
 pub fn abort_internal() -> ! {
     unsafe { libc::abort() }
 }
diff --git a/library/std/src/sys/pal/windows/mod.rs b/library/std/src/sys/pal/windows/mod.rs
index 10ad4541beda3..3b6a86cbc8f41 100644
--- a/library/std/src/sys/pal/windows/mod.rs
+++ b/library/std/src/sys/pal/windows/mod.rs
@@ -356,6 +356,7 @@ pub fn abort_internal() -> ! {
 }
 
 #[cfg(miri)]
+#[track_caller] // even without panics, this helps for Miri backtraces
 pub fn abort_internal() -> ! {
     crate::intrinsics::abort();
 }
diff --git a/src/tools/miri/tests/fail/alloc/alloc_error_handler.rs b/src/tools/miri/tests/fail/alloc/alloc_error_handler.rs
index 4a87411d755c0..35b8e20e56b3c 100644
--- a/src/tools/miri/tests/fail/alloc/alloc_error_handler.rs
+++ b/src/tools/miri/tests/fail/alloc/alloc_error_handler.rs
@@ -1,6 +1,4 @@
 //@error-in-other-file: aborted
-//@normalize-stderr-test: "\|.*::abort\(\).*" -> "| ABORT()"
-//@normalize-stderr-test: "\| +\^+" -> "| ^"
 #![feature(allocator_api)]
 
 use std::alloc::*;
diff --git a/src/tools/miri/tests/fail/alloc/alloc_error_handler.stderr b/src/tools/miri/tests/fail/alloc/alloc_error_handler.stderr
index d67dabd693543..bbf5d14a98a1e 100644
--- a/src/tools/miri/tests/fail/alloc/alloc_error_handler.stderr
+++ b/src/tools/miri/tests/fail/alloc/alloc_error_handler.stderr
@@ -1,13 +1,11 @@
 memory allocation of 4 bytes failed
 error: abnormal termination: the program aborted execution
-  --> RUSTLIB/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
+  --> RUSTLIB/std/src/alloc.rs:LL:CC
    |
-LL | ABORT()
-   | ^ abnormal termination occurred here
+LL |     crate::process::abort()
+   |     ^^^^^^^^^^^^^^^^^^^^^^^ abnormal termination occurred here
    |
    = note: BACKTRACE:
-   = note: inside `std::sys::pal::PLATFORM::abort_internal` at RUSTLIB/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
-   = note: inside `std::process::abort` at RUSTLIB/std/src/process.rs:LL:CC
    = note: inside `std::alloc::rust_oom` at RUSTLIB/std/src/alloc.rs:LL:CC
    = note: inside `std::alloc::_::__rg_oom` at RUSTLIB/std/src/alloc.rs:LL:CC
    = note: inside `std::alloc::handle_alloc_error::rt_error` at RUSTLIB/alloc/src/alloc.rs:LL:CC
@@ -16,7 +14,7 @@ note: inside `main`
   --> tests/fail/alloc/alloc_error_handler.rs:LL:CC
    |
 LL |     handle_alloc_error(Layout::for_value(&0));
-   | ^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 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/exported_symbol_bad_unwind2.both.stderr b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.both.stderr
index a1571173a53b1..95f79aae6c177 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
@@ -9,13 +9,12 @@ panic in a function that cannot unwind
 stack backtrace:
 thread caused non-unwinding panic. aborting.
 error: abnormal termination: the program aborted execution
-  --> RUSTLIB/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
+  --> RUSTLIB/std/src/panicking.rs:LL:CC
    |
-LL | ABORT()
-   | ^ abnormal termination occurred here
+LL |         crate::process::abort();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^ abnormal termination occurred here
    |
    = note: BACKTRACE:
-   = note: inside `std::sys::pal::PLATFORM::abort_internal` at RUSTLIB/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
    = note: inside `std::panicking::panic_with_hook` at RUSTLIB/std/src/panicking.rs:LL:CC
    = note: inside closure at RUSTLIB/std/src/panicking.rs:LL:CC
    = note: inside `std::sys::backtrace::__rust_end_short_backtrace::<{closure@std::panicking::panic_handler::{closure#0}}, !>` at RUSTLIB/std/src/sys/backtrace.rs:LL:CC
@@ -33,7 +32,7 @@ note: inside `main`
   --> tests/fail/function_calls/exported_symbol_bad_unwind2.rs:LL:CC
    |
 LL |     unsafe { nounwind() }
-   | ^
+   |              ^^^^^^^^^^
 
 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/exported_symbol_bad_unwind2.definition.stderr b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.definition.stderr
index a1571173a53b1..95f79aae6c177 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
@@ -9,13 +9,12 @@ panic in a function that cannot unwind
 stack backtrace:
 thread caused non-unwinding panic. aborting.
 error: abnormal termination: the program aborted execution
-  --> RUSTLIB/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
+  --> RUSTLIB/std/src/panicking.rs:LL:CC
    |
-LL | ABORT()
-   | ^ abnormal termination occurred here
+LL |         crate::process::abort();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^ abnormal termination occurred here
    |
    = note: BACKTRACE:
-   = note: inside `std::sys::pal::PLATFORM::abort_internal` at RUSTLIB/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
    = note: inside `std::panicking::panic_with_hook` at RUSTLIB/std/src/panicking.rs:LL:CC
    = note: inside closure at RUSTLIB/std/src/panicking.rs:LL:CC
    = note: inside `std::sys::backtrace::__rust_end_short_backtrace::<{closure@std::panicking::panic_handler::{closure#0}}, !>` at RUSTLIB/std/src/sys/backtrace.rs:LL:CC
@@ -33,7 +32,7 @@ note: inside `main`
   --> tests/fail/function_calls/exported_symbol_bad_unwind2.rs:LL:CC
    |
 LL |     unsafe { nounwind() }
-   | ^
+   |              ^^^^^^^^^^
 
 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/exported_symbol_bad_unwind2.extern_block.stderr b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.extern_block.stderr
index e755b262474c2..eaca0d3f01222 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
@@ -7,7 +7,7 @@ error: Undefined Behavior: unwinding past a stack frame that does not allow unwi
   --> tests/fail/function_calls/exported_symbol_bad_unwind2.rs:LL:CC
    |
 LL |     unsafe { nounwind() }
-   | ^ Undefined Behavior occurred here
+   |              ^^^^^^^^^^ Undefined Behavior occurred here
    |
    = 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
diff --git a/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.rs b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.rs
index 9d993786d57f9..aa5a185f110d2 100644
--- a/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.rs
+++ b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.rs
@@ -1,6 +1,4 @@
 //@revisions: extern_block definition both
-//@normalize-stderr-test: "\|.*::abort\(\).*" -> "| ABORT()"
-//@normalize-stderr-test: "\| +\^+" -> "| ^"
 //@normalize-stderr-test: "\n +[0-9]+:[^\n]+" -> ""
 //@normalize-stderr-test: "\n +at [^\n]+" -> ""
 //@[definition,both]error-in-other-file: aborted execution
diff --git a/src/tools/miri/tests/fail/panic/abort_unwind.rs b/src/tools/miri/tests/fail/panic/abort_unwind.rs
index bd819362da413..775cbf62229b3 100644
--- a/src/tools/miri/tests/fail/panic/abort_unwind.rs
+++ b/src/tools/miri/tests/fail/panic/abort_unwind.rs
@@ -1,6 +1,4 @@
 //@error-in-other-file: the program aborted execution
-//@normalize-stderr-test: "\|.*::abort\(\).*" -> "| ABORT()"
-//@normalize-stderr-test: "\| +\^+" -> "| ^"
 //@normalize-stderr-test: "\n +[0-9]+:[^\n]+" -> ""
 //@normalize-stderr-test: "\n +at [^\n]+" -> ""
 
diff --git a/src/tools/miri/tests/fail/panic/abort_unwind.stderr b/src/tools/miri/tests/fail/panic/abort_unwind.stderr
index 287f7d5432a66..23dbc2fb8f392 100644
--- a/src/tools/miri/tests/fail/panic/abort_unwind.stderr
+++ b/src/tools/miri/tests/fail/panic/abort_unwind.stderr
@@ -9,13 +9,12 @@ panic in a function that cannot unwind
 stack backtrace:
 thread caused non-unwinding panic. aborting.
 error: abnormal termination: the program aborted execution
-  --> RUSTLIB/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
+  --> RUSTLIB/std/src/panicking.rs:LL:CC
    |
-LL | ABORT()
-   | ^ abnormal termination occurred here
+LL |         crate::process::abort();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^ abnormal termination occurred here
    |
    = note: BACKTRACE:
-   = note: inside `std::sys::pal::PLATFORM::abort_internal` at RUSTLIB/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
    = note: inside `std::panicking::panic_with_hook` at RUSTLIB/std/src/panicking.rs:LL:CC
    = note: inside closure at RUSTLIB/std/src/panicking.rs:LL:CC
    = note: inside `std::sys::backtrace::__rust_end_short_backtrace::<{closure@std::panicking::panic_handler::{closure#0}}, !>` at RUSTLIB/std/src/sys/backtrace.rs:LL:CC
@@ -27,7 +26,7 @@ note: inside `main`
   --> tests/fail/panic/abort_unwind.rs:LL:CC
    |
 LL |     std::panic::abort_unwind(|| panic!("PANIC!!!"));
-   | ^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/panic/double_panic.rs b/src/tools/miri/tests/fail/panic/double_panic.rs
index 4d8f4cb6fb7ba..88421e84529e0 100644
--- a/src/tools/miri/tests/fail/panic/double_panic.rs
+++ b/src/tools/miri/tests/fail/panic/double_panic.rs
@@ -1,5 +1,3 @@
-//@normalize-stderr-test: "\|.*::abort\(\).*" -> "| ABORT()"
-//@normalize-stderr-test: "\| +\^+" -> "| ^"
 //@normalize-stderr-test: "\n +[0-9]+:[^\n]+" -> ""
 //@normalize-stderr-test: "\n +at [^\n]+" -> ""
 //@error-in-other-file: aborted execution
diff --git a/src/tools/miri/tests/fail/panic/double_panic.stderr b/src/tools/miri/tests/fail/panic/double_panic.stderr
index b76ece7f1e5ef..edbc0d8fc571b 100644
--- a/src/tools/miri/tests/fail/panic/double_panic.stderr
+++ b/src/tools/miri/tests/fail/panic/double_panic.stderr
@@ -12,13 +12,12 @@ thread 'main' ($TID) panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
 panic in a destructor during cleanup
 thread caused non-unwinding panic. aborting.
 error: abnormal termination: the program aborted execution
-  --> RUSTLIB/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
+  --> RUSTLIB/std/src/panicking.rs:LL:CC
    |
-LL | ABORT()
-   | ^ abnormal termination occurred here
+LL |         crate::process::abort();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^ abnormal termination occurred here
    |
    = note: BACKTRACE:
-   = note: inside `std::sys::pal::PLATFORM::abort_internal` at RUSTLIB/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
    = note: inside `std::panicking::panic_with_hook` at RUSTLIB/std/src/panicking.rs:LL:CC
    = note: inside closure at RUSTLIB/std/src/panicking.rs:LL:CC
    = note: inside `std::sys::backtrace::__rust_end_short_backtrace::<{closure@std::panicking::panic_handler::{closure#0}}, !>` at RUSTLIB/std/src/sys/backtrace.rs:LL:CC
diff --git a/src/tools/miri/tests/fail/panic/panic_abort1.rs b/src/tools/miri/tests/fail/panic/panic_abort1.rs
index 06cb673778a2b..511b8bddf9702 100644
--- a/src/tools/miri/tests/fail/panic/panic_abort1.rs
+++ b/src/tools/miri/tests/fail/panic/panic_abort1.rs
@@ -1,6 +1,4 @@
 //@error-in-other-file: the program aborted execution
-//@normalize-stderr-test: "\| +\^+" -> "| ^"
-//@normalize-stderr-test: "\|.*::abort\(\).*" -> "| ABORT()"
 //@compile-flags: -C panic=abort
 
 fn main() {
diff --git a/src/tools/miri/tests/fail/panic/panic_abort1.stderr b/src/tools/miri/tests/fail/panic/panic_abort1.stderr
index c469d24287f93..c389a9bc0750b 100644
--- a/src/tools/miri/tests/fail/panic/panic_abort1.stderr
+++ b/src/tools/miri/tests/fail/panic/panic_abort1.stderr
@@ -4,14 +4,12 @@ panicking from libstd
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 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/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
+  --> RUSTLIB/std/src/rt.rs:LL:CC
    |
-LL | ABORT()
-   | ^ abnormal termination occurred here
+LL |     crate::process::abort();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^ abnormal termination occurred here
    |
    = note: BACKTRACE:
-   = note: inside `std::sys::pal::PLATFORM::abort_internal` at RUSTLIB/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
-   = note: inside `std::process::abort` at RUSTLIB/std/src/process.rs:LL:CC
    = note: inside `std::rt::__rust_abort` at RUSTLIB/std/src/rt.rs:LL:CC
    = note: inside `panic_abort::__rust_start_panic` at RUSTLIB/panic_abort/src/lib.rs:LL:CC
    = note: inside `std::panicking::rust_panic` at RUSTLIB/std/src/panicking.rs:LL:CC
@@ -23,7 +21,7 @@ note: inside `main`
   --> tests/fail/panic/panic_abort1.rs:LL:CC
    |
 LL |     std::panic!("panicking from libstd");
-   | ^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/panic/panic_abort2.rs b/src/tools/miri/tests/fail/panic/panic_abort2.rs
index c011b3ee7eb84..e6c1a130ac94d 100644
--- a/src/tools/miri/tests/fail/panic/panic_abort2.rs
+++ b/src/tools/miri/tests/fail/panic/panic_abort2.rs
@@ -1,6 +1,4 @@
 //@error-in-other-file: the program aborted execution
-//@normalize-stderr-test: "\| +\^+" -> "| ^"
-//@normalize-stderr-test: "\|.*::abort\(\).*" -> "| ABORT()"
 //@compile-flags: -C panic=abort
 
 fn main() {
diff --git a/src/tools/miri/tests/fail/panic/panic_abort2.stderr b/src/tools/miri/tests/fail/panic/panic_abort2.stderr
index bc7918f5f86a4..5fe2245cbe009 100644
--- a/src/tools/miri/tests/fail/panic/panic_abort2.stderr
+++ b/src/tools/miri/tests/fail/panic/panic_abort2.stderr
@@ -4,14 +4,12 @@ thread 'main' ($TID) panicked at tests/fail/panic/panic_abort2.rs:LL:CC:
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 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/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
+  --> RUSTLIB/std/src/rt.rs:LL:CC
    |
-LL | ABORT()
-   | ^ abnormal termination occurred here
+LL |     crate::process::abort();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^ abnormal termination occurred here
    |
    = note: BACKTRACE:
-   = note: inside `std::sys::pal::PLATFORM::abort_internal` at RUSTLIB/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
-   = note: inside `std::process::abort` at RUSTLIB/std/src/process.rs:LL:CC
    = note: inside `std::rt::__rust_abort` at RUSTLIB/std/src/rt.rs:LL:CC
    = note: inside `panic_abort::__rust_start_panic` at RUSTLIB/panic_abort/src/lib.rs:LL:CC
    = note: inside `std::panicking::rust_panic` at RUSTLIB/std/src/panicking.rs:LL:CC
@@ -23,7 +21,7 @@ note: inside `main`
   --> tests/fail/panic/panic_abort2.rs:LL:CC
    |
 LL |     std::panic!("{}-panicking from libstd", 42);
-   | ^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/panic/panic_abort3.rs b/src/tools/miri/tests/fail/panic/panic_abort3.rs
index 911dc4a44abda..28a28c923fdff 100644
--- a/src/tools/miri/tests/fail/panic/panic_abort3.rs
+++ b/src/tools/miri/tests/fail/panic/panic_abort3.rs
@@ -1,6 +1,4 @@
 //@error-in-other-file: the program aborted execution
-//@normalize-stderr-test: "\| +\^+" -> "| ^"
-//@normalize-stderr-test: "\|.*::abort\(\).*" -> "| ABORT()"
 //@compile-flags: -C panic=abort
 
 fn main() {
diff --git a/src/tools/miri/tests/fail/panic/panic_abort3.stderr b/src/tools/miri/tests/fail/panic/panic_abort3.stderr
index 553bfa6163514..cac24ca41c715 100644
--- a/src/tools/miri/tests/fail/panic/panic_abort3.stderr
+++ b/src/tools/miri/tests/fail/panic/panic_abort3.stderr
@@ -4,14 +4,12 @@ panicking from libcore
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 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/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
+  --> RUSTLIB/std/src/rt.rs:LL:CC
    |
-LL | ABORT()
-   | ^ abnormal termination occurred here
+LL |     crate::process::abort();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^ abnormal termination occurred here
    |
    = note: BACKTRACE:
-   = note: inside `std::sys::pal::PLATFORM::abort_internal` at RUSTLIB/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
-   = note: inside `std::process::abort` at RUSTLIB/std/src/process.rs:LL:CC
    = note: inside `std::rt::__rust_abort` at RUSTLIB/std/src/rt.rs:LL:CC
    = note: inside `panic_abort::__rust_start_panic` at RUSTLIB/panic_abort/src/lib.rs:LL:CC
    = note: inside `std::panicking::rust_panic` at RUSTLIB/std/src/panicking.rs:LL:CC
@@ -23,7 +21,7 @@ note: inside `main`
   --> tests/fail/panic/panic_abort3.rs:LL:CC
    |
 LL |     core::panic!("panicking from libcore");
-   | ^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/panic/panic_abort4.rs b/src/tools/miri/tests/fail/panic/panic_abort4.rs
index 696fdff742237..248064d14d5d0 100644
--- a/src/tools/miri/tests/fail/panic/panic_abort4.rs
+++ b/src/tools/miri/tests/fail/panic/panic_abort4.rs
@@ -1,6 +1,4 @@
 //@error-in-other-file: the program aborted execution
-//@normalize-stderr-test: "\| +\^+" -> "| ^"
-//@normalize-stderr-test: "\|.*::abort\(\).*" -> "| ABORT()"
 //@compile-flags: -C panic=abort
 
 fn main() {
diff --git a/src/tools/miri/tests/fail/panic/panic_abort4.stderr b/src/tools/miri/tests/fail/panic/panic_abort4.stderr
index 07ecab6661e5b..21195729ae82b 100644
--- a/src/tools/miri/tests/fail/panic/panic_abort4.stderr
+++ b/src/tools/miri/tests/fail/panic/panic_abort4.stderr
@@ -4,14 +4,12 @@ thread 'main' ($TID) panicked at tests/fail/panic/panic_abort4.rs:LL:CC:
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 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/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
+  --> RUSTLIB/std/src/rt.rs:LL:CC
    |
-LL | ABORT()
-   | ^ abnormal termination occurred here
+LL |     crate::process::abort();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^ abnormal termination occurred here
    |
    = note: BACKTRACE:
-   = note: inside `std::sys::pal::PLATFORM::abort_internal` at RUSTLIB/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
-   = note: inside `std::process::abort` at RUSTLIB/std/src/process.rs:LL:CC
    = note: inside `std::rt::__rust_abort` at RUSTLIB/std/src/rt.rs:LL:CC
    = note: inside `panic_abort::__rust_start_panic` at RUSTLIB/panic_abort/src/lib.rs:LL:CC
    = note: inside `std::panicking::rust_panic` at RUSTLIB/std/src/panicking.rs:LL:CC
@@ -23,7 +21,7 @@ note: inside `main`
   --> tests/fail/panic/panic_abort4.rs:LL:CC
    |
 LL |     core::panic!("{}-panicking from libcore", 42);
-   | ^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/ptr_swap_nonoverlapping.rs b/src/tools/miri/tests/fail/ptr_swap_nonoverlapping.rs
index 6119e8604b465..0f7cf189f33fb 100644
--- a/src/tools/miri/tests/fail/ptr_swap_nonoverlapping.rs
+++ b/src/tools/miri/tests/fail/ptr_swap_nonoverlapping.rs
@@ -1,7 +1,5 @@
 //! This is a regression test for <https://github.com/rust-lang/miri/issues/4188>: The precondition
 //! check in `ptr::swap_nonoverlapping` was incorrectly disabled in Miri.
-//@normalize-stderr-test: "\|.*::abort\(\).*" -> "| ABORT()"
-//@normalize-stderr-test: "\| +\^+" -> "| ^"
 //@normalize-stderr-test: "\n +[0-9]+:[^\n]+" -> ""
 //@normalize-stderr-test: "\n +at [^\n]+" -> ""
 //@error-in-other-file: aborted execution
diff --git a/src/tools/miri/tests/fail/ptr_swap_nonoverlapping.stderr b/src/tools/miri/tests/fail/ptr_swap_nonoverlapping.stderr
index 70f5d498da398..c5f6e62b86906 100644
--- a/src/tools/miri/tests/fail/ptr_swap_nonoverlapping.stderr
+++ b/src/tools/miri/tests/fail/ptr_swap_nonoverlapping.stderr
@@ -7,13 +7,12 @@ note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 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
+  --> RUSTLIB/std/src/panicking.rs:LL:CC
    |
-LL | ABORT()
-   | ^ abnormal termination occurred here
+LL |         crate::process::abort();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^ abnormal termination occurred here
    |
    = note: BACKTRACE:
-   = note: inside `std::sys::pal::PLATFORM::abort_internal` at RUSTLIB/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
    = note: inside `std::panicking::panic_with_hook` at RUSTLIB/std/src/panicking.rs:LL:CC
    = note: inside closure at RUSTLIB/std/src/panicking.rs:LL:CC
    = note: inside `std::sys::backtrace::__rust_end_short_backtrace::<{closure@std::panicking::panic_handler::{closure#0}}, !>` at RUSTLIB/std/src/sys/backtrace.rs:LL:CC
@@ -22,7 +21,7 @@ note: inside `main`
   --> tests/fail/ptr_swap_nonoverlapping.rs:LL:CC
    |
 LL |         std::ptr::swap_nonoverlapping(ptr, ptr, 1);
-   | ^
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/terminate-terminator.rs b/src/tools/miri/tests/fail/terminate-terminator.rs
index 31ae829a2de75..421cddca16060 100644
--- a/src/tools/miri/tests/fail/terminate-terminator.rs
+++ b/src/tools/miri/tests/fail/terminate-terminator.rs
@@ -1,6 +1,4 @@
 //@compile-flags: -Zmir-opt-level=3 -Zinline-mir-hint-threshold=1000
-//@normalize-stderr-test: "\|.*::abort\(\).*" -> "| ABORT()"
-//@normalize-stderr-test: "\| +\^+" -> "| ^"
 //@normalize-stderr-test: "\n +[0-9]+:[^\n]+" -> ""
 //@normalize-stderr-test: "\n +at [^\n]+" -> ""
 //@error-in-other-file: aborted execution
diff --git a/src/tools/miri/tests/fail/terminate-terminator.stderr b/src/tools/miri/tests/fail/terminate-terminator.stderr
index 228e2d3de1f39..8ae649a392bda 100644
--- a/src/tools/miri/tests/fail/terminate-terminator.stderr
+++ b/src/tools/miri/tests/fail/terminate-terminator.stderr
@@ -11,13 +11,12 @@ panic in a function that cannot unwind
 stack backtrace:
 thread caused non-unwinding panic. aborting.
 error: abnormal termination: the program aborted execution
-  --> RUSTLIB/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
+  --> RUSTLIB/std/src/panicking.rs:LL:CC
    |
-LL | ABORT()
-   | ^ abnormal termination occurred here
+LL |         crate::process::abort();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^ abnormal termination occurred here
    |
    = note: BACKTRACE:
-   = note: inside `std::sys::pal::PLATFORM::abort_internal` at RUSTLIB/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
    = note: inside `std::panicking::panic_with_hook` at RUSTLIB/std/src/panicking.rs:LL:CC
    = note: inside closure at RUSTLIB/std/src/panicking.rs:LL:CC
    = note: inside `std::sys::backtrace::__rust_end_short_backtrace::<{closure@std::panicking::panic_handler::{closure#0}}, !>` at RUSTLIB/std/src/sys/backtrace.rs:LL:CC
@@ -36,12 +35,12 @@ note: inside `panic_abort`
   --> tests/fail/terminate-terminator.rs:LL:CC
    |
 LL |     has_cleanup();
-   | ^
+   |     ^^^^^^^^^^^^^
 note: inside `main`
   --> tests/fail/terminate-terminator.rs:LL:CC
    |
 LL |     panic_abort();
-   | ^
+   |     ^^^^^^^^^^^^^
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/unwind-action-terminate.rs b/src/tools/miri/tests/fail/unwind-action-terminate.rs
index f0fbcfd88675f..e1c8909fffab1 100644
--- a/src/tools/miri/tests/fail/unwind-action-terminate.rs
+++ b/src/tools/miri/tests/fail/unwind-action-terminate.rs
@@ -1,6 +1,4 @@
 //@error-in-other-file: aborted execution
-//@normalize-stderr-test: "\|.*::abort\(\).*" -> "| ABORT()"
-//@normalize-stderr-test: "\| +\^+" -> "| ^"
 //@normalize-stderr-test: "\n +[0-9]+:[^\n]+" -> ""
 //@normalize-stderr-test: "\n +at [^\n]+" -> ""
 extern "C" fn panic_abort() {
diff --git a/src/tools/miri/tests/fail/unwind-action-terminate.stderr b/src/tools/miri/tests/fail/unwind-action-terminate.stderr
index 1c0f8cb7ec625..cf41c88ce3774 100644
--- a/src/tools/miri/tests/fail/unwind-action-terminate.stderr
+++ b/src/tools/miri/tests/fail/unwind-action-terminate.stderr
@@ -9,13 +9,12 @@ panic in a function that cannot unwind
 stack backtrace:
 thread caused non-unwinding panic. aborting.
 error: abnormal termination: the program aborted execution
-  --> RUSTLIB/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
+  --> RUSTLIB/std/src/panicking.rs:LL:CC
    |
-LL | ABORT()
-   | ^ abnormal termination occurred here
+LL |         crate::process::abort();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^ abnormal termination occurred here
    |
    = note: BACKTRACE:
-   = note: inside `std::sys::pal::PLATFORM::abort_internal` at RUSTLIB/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
    = note: inside `std::panicking::panic_with_hook` at RUSTLIB/std/src/panicking.rs:LL:CC
    = note: inside closure at RUSTLIB/std/src/panicking.rs:LL:CC
    = note: inside `std::sys::backtrace::__rust_end_short_backtrace::<{closure@std::panicking::panic_handler::{closure#0}}, !>` at RUSTLIB/std/src/sys/backtrace.rs:LL:CC
@@ -33,7 +32,7 @@ note: inside `main`
   --> tests/fail/unwind-action-terminate.rs:LL:CC
    |
 LL |     panic_abort();
-   | ^
+   |     ^^^^^^^^^^^^^
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 

From 5e9b655e7094295ba4ce40568d8f182aef3704fc Mon Sep 17 00:00:00 2001
From: Samuel Moelius <35515885+smoelius@users.noreply.github.com>
Date: Tue, 2 Sep 2025 08:43:34 -0400
Subject: [PATCH 0415/1889] Correct typo in `rustc_errors` comment

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

diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
index 71fc54f0d33f0..a56e0f3fae132 100644
--- a/compiler/rustc_errors/src/lib.rs
+++ b/compiler/rustc_errors/src/lib.rs
@@ -1160,7 +1160,7 @@ impl<'a> DiagCtxtHandle<'a> {
         // - It's only produce with JSON output.
         // - It's not emitted the usual way, via `emit_diagnostic`.
         // - The `$message_type` field is "unused_externs" rather than the usual
-        //   "diagnosic".
+        //   "diagnostic".
         //
         // We count it as a lint error because it has a lint level. The value
         // of `loud` (which comes from "unused-externs" or

From 5b43244ac59119870c9e0f6b642340ab88355b23 Mon Sep 17 00:00:00 2001
From: WANG Rui <wangrui@loongson.cn>
Date: Thu, 28 Aug 2025 23:31:46 +0800
Subject: [PATCH 0416/1889] Add LSX accelerated implementation for source file
 analysis

This patch introduces an LSX-optimized version of `analyze_source_file`
for the `loongarch64` target. Similar to existing SSE2 implementation
for x86, this version:

- Processes 16-byte chunks at a time using LSX vector intrinsics.
- Quickly identifies newlines in ASCII-only chunks.
- Falls back to the generic implementation when multi-byte UTF-8
  characters are detected or in the tail portion.
---
 .../rustc_span/src/analyze_source_file.rs     | 109 +++++++++++++++++-
 compiler/rustc_span/src/lib.rs                |   1 +
 2 files changed, 107 insertions(+), 3 deletions(-)

diff --git a/compiler/rustc_span/src/analyze_source_file.rs b/compiler/rustc_span/src/analyze_source_file.rs
index c32593a6d95ab..bb2cda77dffff 100644
--- a/compiler/rustc_span/src/analyze_source_file.rs
+++ b/compiler/rustc_span/src/analyze_source_file.rs
@@ -81,8 +81,8 @@ cfg_select! {
                 // use `loadu`, which supports unaligned loading.
                 let chunk = unsafe { _mm_loadu_si128(chunk.as_ptr() as *const __m128i) };
 
-                // For character in the chunk, see if its byte value is < 0, which
-                // indicates that it's part of a UTF-8 char.
+                // For each character in the chunk, see if its byte value is < 0,
+                // which indicates that it's part of a UTF-8 char.
                 let multibyte_test = _mm_cmplt_epi8(chunk, _mm_set1_epi8(0));
                 // Create a bit mask from the comparison results.
                 let multibyte_mask = _mm_movemask_epi8(multibyte_test);
@@ -132,8 +132,111 @@ cfg_select! {
             }
         }
     }
+    target_arch = "loongarch64" => {
+        fn analyze_source_file_dispatch(
+            src: &str,
+            lines: &mut Vec<RelativeBytePos>,
+            multi_byte_chars: &mut Vec<MultiByteChar>,
+        ) {
+            use std::arch::is_loongarch_feature_detected;
+
+            if is_loongarch_feature_detected!("lsx") {
+                unsafe {
+                    analyze_source_file_lsx(src, lines, multi_byte_chars);
+                }
+            } else {
+                analyze_source_file_generic(
+                    src,
+                    src.len(),
+                    RelativeBytePos::from_u32(0),
+                    lines,
+                    multi_byte_chars,
+                );
+            }
+        }
+
+        /// Checks 16 byte chunks of text at a time. If the chunk contains
+        /// something other than printable ASCII characters and newlines, the
+        /// function falls back to the generic implementation. Otherwise it uses
+        /// LSX intrinsics to quickly find all newlines.
+        #[target_feature(enable = "lsx")]
+        unsafe fn analyze_source_file_lsx(
+            src: &str,
+            lines: &mut Vec<RelativeBytePos>,
+            multi_byte_chars: &mut Vec<MultiByteChar>,
+        ) {
+            use std::arch::loongarch64::*;
+
+            const CHUNK_SIZE: usize = 16;
+
+            let (chunks, tail) = src.as_bytes().as_chunks::<CHUNK_SIZE>();
+
+            // This variable keeps track of where we should start decoding a
+            // chunk. If a multi-byte character spans across chunk boundaries,
+            // we need to skip that part in the next chunk because we already
+            // handled it.
+            let mut intra_chunk_offset = 0;
+
+            for (chunk_index, chunk) in chunks.iter().enumerate() {
+                // All LSX memory instructions support unaligned access, so using
+                // vld is fine.
+                let chunk = unsafe { lsx_vld::<0>(chunk.as_ptr() as *const i8) };
+
+                // For each character in the chunk, see if its byte value is < 0,
+                // which indicates that it's part of a UTF-8 char.
+                let multibyte_mask = lsx_vmskltz_b(chunk);
+                // Create a bit mask from the comparison results.
+                let multibyte_mask = lsx_vpickve2gr_w::<0>(multibyte_mask);
+
+                // If the bit mask is all zero, we only have ASCII chars here:
+                if multibyte_mask == 0 {
+                    assert!(intra_chunk_offset == 0);
+
+                    // Check for newlines in the chunk
+                    let newlines_test = lsx_vseqi_b::<{b'\n' as i32}>(chunk);
+                    let newlines_mask = lsx_vmskltz_b(newlines_test);
+                    let mut newlines_mask = lsx_vpickve2gr_w::<0>(newlines_mask);
+
+                    let output_offset = RelativeBytePos::from_usize(chunk_index * CHUNK_SIZE + 1);
+
+                    while newlines_mask != 0 {
+                        let index = newlines_mask.trailing_zeros();
+
+                        lines.push(RelativeBytePos(index) + output_offset);
+
+                        // Clear the bit, so we can find the next one.
+                        newlines_mask &= newlines_mask - 1;
+                    }
+                } else {
+                    // The slow path.
+                    // There are multibyte chars in here, fallback to generic decoding.
+                    let scan_start = chunk_index * CHUNK_SIZE + intra_chunk_offset;
+                    intra_chunk_offset = analyze_source_file_generic(
+                        &src[scan_start..],
+                        CHUNK_SIZE - intra_chunk_offset,
+                        RelativeBytePos::from_usize(scan_start),
+                        lines,
+                        multi_byte_chars,
+                    );
+                }
+            }
+
+            // There might still be a tail left to analyze
+            let tail_start = src.len() - tail.len() + intra_chunk_offset;
+            if tail_start < src.len() {
+                analyze_source_file_generic(
+                    &src[tail_start..],
+                    src.len() - tail_start,
+                    RelativeBytePos::from_usize(tail_start),
+                    lines,
+                    multi_byte_chars,
+                );
+            }
+        }
+    }
     _ => {
-        // The target (or compiler version) does not support SSE2 ...
+        // The target (or compiler version) does not support vector instructions
+        // our specialized implementations need (x86 SSE2, loongarch64 LSX)...
         fn analyze_source_file_dispatch(
             src: &str,
             lines: &mut Vec<RelativeBytePos>,
diff --git a/compiler/rustc_span/src/lib.rs b/compiler/rustc_span/src/lib.rs
index ae6755f076424..8907c5e4c4aeb 100644
--- a/compiler/rustc_span/src/lib.rs
+++ b/compiler/rustc_span/src/lib.rs
@@ -18,6 +18,7 @@
 // tidy-alphabetical-start
 #![allow(internal_features)]
 #![cfg_attr(bootstrap, feature(round_char_boundary))]
+#![cfg_attr(target_arch = "loongarch64", feature(stdarch_loongarch))]
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
 #![doc(rust_logo)]
 #![feature(array_windows)]

From a3546491021831e17c030c7f8ec82f4715b321de Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 2 Sep 2025 15:02:35 +0200
Subject: [PATCH 0417/1889] add a flag to always apply the maximum float error

---
 src/tools/miri/README.md                      |  2 ++
 src/tools/miri/src/bin/miri.rs                |  4 +++-
 src/tools/miri/src/eval.rs                    |  4 ++--
 src/tools/miri/src/lib.rs                     |  7 +++---
 src/tools/miri/src/machine.rs                 | 12 +++++++++-
 src/tools/miri/src/math.rs                    | 11 +++++++--
 .../tests/pass/float_extra_rounding_error.rs  | 23 +++++++++++++++++++
 7 files changed, 54 insertions(+), 9 deletions(-)
 create mode 100644 src/tools/miri/tests/pass/float_extra_rounding_error.rs

diff --git a/src/tools/miri/README.md b/src/tools/miri/README.md
index 7ccd27d7b83eb..cb4a56b58ac8a 100644
--- a/src/tools/miri/README.md
+++ b/src/tools/miri/README.md
@@ -319,6 +319,8 @@ environment variable. We first document the most relevant and most commonly used
   Can be used without a value; in that case the range defaults to `0..64`.
 * `-Zmiri-many-seeds-keep-going` tells Miri to really try all the seeds in the given range, even if
   a failing seed has already been found. This is useful to determine which fraction of seeds fails.
+* `-Zmiri-max-extra-rounding-error` tells Miri to always apply the maximum error to float operations
+  that do not have a guaranteed precision. The sign of the error is still non-deterministic.
 * `-Zmiri-no-extra-rounding-error` stops Miri from adding extra rounding errors to float operations
   that do not have a guaranteed precision.
 * `-Zmiri-num-cpus` states the number of available CPUs to be reported by miri. By default, the
diff --git a/src/tools/miri/src/bin/miri.rs b/src/tools/miri/src/bin/miri.rs
index ae1b25f8857a0..8fd8d332978d3 100644
--- a/src/tools/miri/src/bin/miri.rs
+++ b/src/tools/miri/src/bin/miri.rs
@@ -556,7 +556,9 @@ fn main() {
         } else if arg == "-Zmiri-deterministic-floats" {
             miri_config.float_nondet = false;
         } else if arg == "-Zmiri-no-extra-rounding-error" {
-            miri_config.float_rounding_error = false;
+            miri_config.float_rounding_error = miri::FloatRoundingErrorMode::None;
+        } else if arg == "-Zmiri-max-extra-rounding-error" {
+            miri_config.float_rounding_error = miri::FloatRoundingErrorMode::Max;
         } else if arg == "-Zmiri-strict-provenance" {
             miri_config.provenance_mode = ProvenanceMode::Strict;
         } else if arg == "-Zmiri-permissive-provenance" {
diff --git a/src/tools/miri/src/eval.rs b/src/tools/miri/src/eval.rs
index 43d251b157ba0..f174a448a8104 100644
--- a/src/tools/miri/src/eval.rs
+++ b/src/tools/miri/src/eval.rs
@@ -112,7 +112,7 @@ pub struct MiriConfig {
     /// Whether floating-point operations can behave non-deterministically.
     pub float_nondet: bool,
     /// Whether floating-point operations can have a non-deterministic rounding error.
-    pub float_rounding_error: bool,
+    pub float_rounding_error: FloatRoundingErrorMode,
 }
 
 impl Default for MiriConfig {
@@ -154,7 +154,7 @@ impl Default for MiriConfig {
             fixed_scheduling: false,
             force_intrinsic_fallback: false,
             float_nondet: true,
-            float_rounding_error: true,
+            float_rounding_error: FloatRoundingErrorMode::Random,
         }
     }
 }
diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
index 090f10f481332..0856411b8e836 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -142,9 +142,10 @@ pub use crate::eval::{MiriConfig, MiriEntryFnType, create_ecx, eval_entry};
 pub use crate::helpers::{AccessKind, EvalContextExt as _, ToU64 as _, ToUsize as _};
 pub use crate::intrinsics::EvalContextExt as _;
 pub use crate::machine::{
-    AlignmentCheck, AllocExtra, BacktraceStyle, DynMachineCallback, FrameExtra, IsolatedOp,
-    MachineCallback, MemoryKind, MiriInterpCx, MiriInterpCxExt, MiriMachine, MiriMemoryKind,
-    PrimitiveLayouts, Provenance, ProvenanceExtra, RejectOpWith, ValidationMode,
+    AlignmentCheck, AllocExtra, BacktraceStyle, DynMachineCallback, FloatRoundingErrorMode,
+    FrameExtra, IsolatedOp, MachineCallback, MemoryKind, MiriInterpCx, MiriInterpCxExt,
+    MiriMachine, MiriMemoryKind, PrimitiveLayouts, Provenance, ProvenanceExtra, RejectOpWith,
+    ValidationMode,
 };
 pub use crate::operator::EvalContextExt as _;
 pub use crate::provenance_gc::{EvalContextExt as _, LiveAllocs, VisitProvenance, VisitWith};
diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index e27b2e89b48a9..7802a58f11236 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -108,6 +108,16 @@ pub enum ValidationMode {
     Deep,
 }
 
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum FloatRoundingErrorMode {
+    /// Apply a random error (the default).
+    Random,
+    /// Don't apply any error.
+    None,
+    /// Always apply the maximum error (with a random sign).
+    Max,
+}
+
 /// Extra data stored with each stack frame
 pub struct FrameExtra<'tcx> {
     /// Extra data for the Borrow Tracker.
@@ -658,7 +668,7 @@ pub struct MiriMachine<'tcx> {
     /// Whether floating-point operations can behave non-deterministically.
     pub float_nondet: bool,
     /// Whether floating-point operations can have a non-deterministic rounding error.
-    pub float_rounding_error: bool,
+    pub float_rounding_error: FloatRoundingErrorMode,
 }
 
 impl<'tcx> MiriMachine<'tcx> {
diff --git a/src/tools/miri/src/math.rs b/src/tools/miri/src/math.rs
index e9e5a1070c9e4..dd994b03f5d17 100644
--- a/src/tools/miri/src/math.rs
+++ b/src/tools/miri/src/math.rs
@@ -15,7 +15,9 @@ pub(crate) fn apply_random_float_error<F: rustc_apfloat::Float>(
     val: F,
     err_scale: i32,
 ) -> F {
-    if !ecx.machine.float_nondet || !ecx.machine.float_rounding_error {
+    if !ecx.machine.float_nondet
+        || matches!(ecx.machine.float_rounding_error, FloatRoundingErrorMode::None)
+    {
         return val;
     }
 
@@ -24,7 +26,12 @@ pub(crate) fn apply_random_float_error<F: rustc_apfloat::Float>(
     // (When read as binary, the position of the first `1` determines the exponent,
     // and the remaining bits fill the mantissa. `PREC` is one plus the size of the mantissa,
     // so this all works out.)
-    let r = F::from_u128(rng.random_range(0..(1 << F::PRECISION))).value;
+    let r = F::from_u128(match ecx.machine.float_rounding_error {
+        FloatRoundingErrorMode::Random => rng.random_range(0..(1 << F::PRECISION)),
+        FloatRoundingErrorMode::Max => (1 << F::PRECISION) - 1, // force max error
+        FloatRoundingErrorMode::None => unreachable!(),
+    })
+    .value;
     // Multiply this with 2^(scale - PREC). The result is between 0 and
     // 2^PREC * 2^(scale - PREC) = 2^scale.
     let err = r.scalbn(err_scale.strict_sub(F::PRECISION.try_into().unwrap()));
diff --git a/src/tools/miri/tests/pass/float_extra_rounding_error.rs b/src/tools/miri/tests/pass/float_extra_rounding_error.rs
new file mode 100644
index 0000000000000..73512399f82c4
--- /dev/null
+++ b/src/tools/miri/tests/pass/float_extra_rounding_error.rs
@@ -0,0 +1,23 @@
+//! Check that the flags to control the extra rounding error work.
+//@revisions: random max none
+//@[max]compile-flags: -Zmiri-max-extra-rounding-error
+//@[none]compile-flags: -Zmiri-no-extra-rounding-error
+#![feature(cfg_select)]
+
+use std::collections::HashSet;
+use std::hint::black_box;
+
+fn main() {
+    let expected = cfg_select! {
+        random => 13, // FIXME: why is it 13?
+        max => 2,
+        none => 1,
+    };
+    // Call `sin(0.5)` a bunch of times and see how many different values we get.
+    let mut values = HashSet::new();
+    for _ in 0..(expected * 16) {
+        let val = black_box(0.5f64).sin();
+        values.insert(val.to_bits());
+    }
+    assert_eq!(values.len(), expected);
+}

From 235dfbab9cb4965a1d23c4d2278923c6ff8e193d Mon Sep 17 00:00:00 2001
From: Vadim Petrochenkov <vadim.petrochenkov@gmail.com>
Date: Tue, 2 Sep 2025 15:03:11 +0300
Subject: [PATCH 0418/1889] resolve: Avoid finalizing extern prelude entries
 more than once

---
 compiler/rustc_resolve/src/diagnostics.rs  |  2 +-
 compiler/rustc_resolve/src/lib.rs          | 12 +++++++-----
 tests/ui/crate-loading/invalid-rlib.rs     |  3 ---
 tests/ui/crate-loading/invalid-rlib.stderr | 11 +----------
 4 files changed, 9 insertions(+), 19 deletions(-)

diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index 5dfc4292a3803..758bb5435e4aa 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -1846,7 +1846,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         let extern_prelude_ambiguity = || {
             self.extern_prelude.get(&Macros20NormalizedIdent::new(ident)).is_some_and(|entry| {
                 entry.item_binding.map(|(b, _)| b) == Some(b1)
-                    && entry.flag_binding.as_ref().and_then(|pb| pb.get().binding()) == Some(b2)
+                    && entry.flag_binding.as_ref().and_then(|pb| pb.get().0.binding()) == Some(b2)
             })
         };
         let (b1, b2, misc1, misc2, swapped) = if b2.span.is_dummy() && !b1.span.is_dummy() {
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index 9674c0356c21f..114d3e0848608 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -1031,7 +1031,7 @@ struct ExternPreludeEntry<'ra> {
     /// `flag_binding` is `None`, or when `extern crate` introducing `item_binding` used renaming.
     item_binding: Option<(NameBinding<'ra>, /* introduced by item */ bool)>,
     /// Binding from an `--extern` flag, lazily populated on first use.
-    flag_binding: Option<Cell<PendingBinding<'ra>>>,
+    flag_binding: Option<Cell<(PendingBinding<'ra>, /* finalized */ bool)>>,
 }
 
 impl ExternPreludeEntry<'_> {
@@ -1042,7 +1042,7 @@ impl ExternPreludeEntry<'_> {
     fn flag() -> Self {
         ExternPreludeEntry {
             item_binding: None,
-            flag_binding: Some(Cell::new(PendingBinding::Pending)),
+            flag_binding: Some(Cell::new((PendingBinding::Pending, false))),
         }
     }
 }
@@ -2245,14 +2245,16 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     fn extern_prelude_get_flag(&self, ident: Ident, finalize: bool) -> Option<NameBinding<'ra>> {
         let entry = self.extern_prelude.get(&Macros20NormalizedIdent::new(ident));
         entry.and_then(|entry| entry.flag_binding.as_ref()).and_then(|flag_binding| {
-            let binding = match flag_binding.get() {
+            let (pending_binding, finalized) = flag_binding.get();
+            let binding = match pending_binding {
                 PendingBinding::Ready(binding) => {
-                    if finalize {
+                    if finalize && !finalized {
                         self.cstore_mut().process_path_extern(self.tcx, ident.name, ident.span);
                     }
                     binding
                 }
                 PendingBinding::Pending => {
+                    debug_assert!(!finalized);
                     let crate_id = if finalize {
                         self.cstore_mut().process_path_extern(self.tcx, ident.name, ident.span)
                     } else {
@@ -2264,7 +2266,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     })
                 }
             };
-            flag_binding.set(PendingBinding::Ready(binding));
+            flag_binding.set((PendingBinding::Ready(binding), finalize || finalized));
             binding.or_else(|| finalize.then_some(self.dummy_binding))
         })
     }
diff --git a/tests/ui/crate-loading/invalid-rlib.rs b/tests/ui/crate-loading/invalid-rlib.rs
index 6b46352624452..24293f88b1cd5 100644
--- a/tests/ui/crate-loading/invalid-rlib.rs
+++ b/tests/ui/crate-loading/invalid-rlib.rs
@@ -6,6 +6,3 @@
 #![no_std]
 use ::foo; //~ ERROR invalid metadata files for crate `foo`
 //~| NOTE failed to mmap file
-//~^^ ERROR invalid metadata files for crate `foo`
-//~| NOTE failed to mmap file
-//~| NOTE duplicate diagnostic
diff --git a/tests/ui/crate-loading/invalid-rlib.stderr b/tests/ui/crate-loading/invalid-rlib.stderr
index 63bb1b95cbb78..ad3ab729a5d21 100644
--- a/tests/ui/crate-loading/invalid-rlib.stderr
+++ b/tests/ui/crate-loading/invalid-rlib.stderr
@@ -6,15 +6,6 @@ LL | use ::foo;
    |
    = note: failed to mmap file 'auxiliary/libfoo.rlib'
 
-error[E0786]: found invalid metadata files for crate `foo`
-  --> $DIR/invalid-rlib.rs:7:7
-   |
-LL | use ::foo;
-   |       ^^^
-   |
-   = note: failed to mmap file 'auxiliary/libfoo.rlib'
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0786`.

From d4f861ecb6319e1db20d20e3cc5ddab84b4aaade Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 2 Sep 2025 16:33:10 +0200
Subject: [PATCH 0419/1889] account for aarch64 windows oversleeping

---
 src/tools/miri/tests/pass/concurrency/sync.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/tools/miri/tests/pass/concurrency/sync.rs b/src/tools/miri/tests/pass/concurrency/sync.rs
index a92359758dadf..142ac9cc8ca49 100644
--- a/src/tools/miri/tests/pass/concurrency/sync.rs
+++ b/src/tools/miri/tests/pass/concurrency/sync.rs
@@ -9,7 +9,8 @@ use std::time::{Duration, Instant};
 
 // We are expecting to sleep for 10ms. How long of a sleep we are accepting?
 // Even with 1000ms we still see this test fail on macOS runners.
-const MAX_SLEEP_TIME_MS: u64 = 2000;
+// On a aarch64-pc-windows-msvc runner, we saw 2.7s!
+const MAX_SLEEP_TIME_MS: u64 = 4000;
 
 // Check if Rust barriers are working.
 

From a8537ab84bf7fd14b2445a058075dac764932e47 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Mon, 1 Sep 2025 15:21:02 +0200
Subject: [PATCH 0420/1889] Remove special implementation of `PartialEq` for
 `InvisibleOrigin` outside macro matching

---
 compiler/rustc_ast/src/token.rs               | 20 +++----------------
 compiler/rustc_expand/src/mbe/macro_parser.rs | 20 +++++++++++++++++--
 2 files changed, 21 insertions(+), 19 deletions(-)

diff --git a/compiler/rustc_ast/src/token.rs b/compiler/rustc_ast/src/token.rs
index ea98bebd30555..6dc6d1026f621 100644
--- a/compiler/rustc_ast/src/token.rs
+++ b/compiler/rustc_ast/src/token.rs
@@ -22,8 +22,7 @@ pub enum CommentKind {
     Block,
 }
 
-// This type must not implement `Hash` due to the unusual `PartialEq` impl below.
-#[derive(Copy, Clone, Debug, Encodable, Decodable, HashStable_Generic)]
+#[derive(Copy, Clone, PartialEq, Debug, Encodable, Decodable, HashStable_Generic)]
 pub enum InvisibleOrigin {
     // From the expansion of a metavariable in a declarative macro.
     MetaVar(MetaVarKind),
@@ -45,20 +44,6 @@ impl InvisibleOrigin {
     }
 }
 
-impl PartialEq for InvisibleOrigin {
-    #[inline]
-    fn eq(&self, _other: &InvisibleOrigin) -> bool {
-        // When we had AST-based nonterminals we couldn't compare them, and the
-        // old `Nonterminal` type had an `eq` that always returned false,
-        // resulting in this restriction:
-        // https://doc.rust-lang.org/nightly/reference/macros-by-example.html#forwarding-a-matched-fragment
-        // This `eq` emulates that behaviour. We could consider lifting this
-        // restriction now but there are still cases involving invisible
-        // delimiters that make it harder than it first appears.
-        false
-    }
-}
-
 /// Annoyingly similar to `NonterminalKind`, but the slight differences are important.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Encodable, Decodable, Hash, HashStable_Generic)]
 pub enum MetaVarKind {
@@ -142,7 +127,8 @@ impl Delimiter {
         }
     }
 
-    // This exists because `InvisibleOrigin`s should be compared. It is only used for assertions.
+    // This exists because `InvisibleOrigin`s should not be compared. It is only used for
+    // assertions.
     pub fn eq_ignoring_invisible_origin(&self, other: &Delimiter) -> bool {
         match (self, other) {
             (Delimiter::Parenthesis, Delimiter::Parenthesis) => true,
diff --git a/compiler/rustc_expand/src/mbe/macro_parser.rs b/compiler/rustc_expand/src/mbe/macro_parser.rs
index 0324057e331a9..ab8e059b7b77f 100644
--- a/compiler/rustc_expand/src/mbe/macro_parser.rs
+++ b/compiler/rustc_expand/src/mbe/macro_parser.rs
@@ -77,7 +77,7 @@ use std::rc::Rc;
 
 pub(crate) use NamedMatch::*;
 pub(crate) use ParseResult::*;
-use rustc_ast::token::{self, DocComment, NonterminalKind, Token};
+use rustc_ast::token::{self, DocComment, NonterminalKind, Token, TokenKind};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::ErrorGuaranteed;
 use rustc_lint_defs::pluralize;
@@ -397,7 +397,23 @@ fn token_name_eq(t1: &Token, t2: &Token) -> bool {
     {
         ident1.name == ident2.name && is_raw1 == is_raw2
     } else {
-        t1.kind == t2.kind
+        // Note: we SHOULD NOT use `t1.kind == t2.kind` here, and we should instead compare the
+        // tokens using the special comparison logic below.
+        // It makes sure that variants containing `InvisibleOrigin` will
+        // never compare equal to one another.
+        //
+        // When we had AST-based nonterminals we couldn't compare them, and the
+        // old `Nonterminal` type had an `eq` that always returned false,
+        // resulting in this restriction:
+        // <https://doc.rust-lang.org/nightly/reference/macros-by-example.html#forwarding-a-matched-fragment>
+        // This comparison logic emulates that behaviour. We could consider lifting this
+        // restriction now but there are still cases involving invisible
+        // delimiters that make it harder than it first appears.
+        match (t1.kind, t2.kind) {
+            (TokenKind::OpenInvisible(_) | TokenKind::CloseInvisible(_), _)
+            | (_, TokenKind::OpenInvisible(_) | TokenKind::CloseInvisible(_)) => false,
+            (a, b) => a == b,
+        }
     }
 }
 

From 4f0e9e29e344975ddf9ebaf5bb8e71a0a433023e Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Wed, 3 Sep 2025 01:18:47 +0800
Subject: [PATCH 0421/1889] Fix closure in match not applicable for add_braces

Example
---

**Not applicable**:

```rust
fn foo() {
    match () {
        () => {
            t(|n|$0 n + 100);
        }
    }
}
```
---
 .../ide-assists/src/handlers/add_braces.rs    | 33 +++++++++++++++++--
 1 file changed, 31 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_braces.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_braces.rs
index 745ae67f30959..5af622eaf28b0 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_braces.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_braces.rs
@@ -1,3 +1,4 @@
+use either::Either;
 use syntax::{
     AstNode,
     ast::{self, edit_in_place::Indent, syntax_factory::SyntaxFactory},
@@ -59,7 +60,8 @@ enum ParentType {
 }
 
 fn get_replacement_node(ctx: &AssistContext<'_>) -> Option<(ParentType, ast::Expr)> {
-    if let Some(match_arm) = ctx.find_node_at_offset::<ast::MatchArm>() {
+    let node = ctx.find_node_at_offset::<Either<ast::MatchArm, ast::ClosureExpr>>()?;
+    if let Either::Left(match_arm) = &node {
         let match_arm_expr = match_arm.expr()?;
 
         if matches!(match_arm_expr, ast::Expr::BlockExpr(_)) {
@@ -67,7 +69,7 @@ fn get_replacement_node(ctx: &AssistContext<'_>) -> Option<(ParentType, ast::Exp
         }
 
         return Some((ParentType::MatchArmExpr, match_arm_expr));
-    } else if let Some(closure_expr) = ctx.find_node_at_offset::<ast::ClosureExpr>() {
+    } else if let Either::Right(closure_expr) = &node {
         let body = closure_expr.body()?;
 
         if matches!(body, ast::Expr::BlockExpr(_)) {
@@ -105,6 +107,33 @@ fn foo() {
         );
     }
 
+    #[test]
+    fn suggest_add_braces_for_closure_in_match() {
+        check_assist(
+            add_braces,
+            r#"
+fn foo() {
+    match () {
+        () => {
+            t(|n|$0 n + 100);
+        }
+    }
+}
+"#,
+            r#"
+fn foo() {
+    match () {
+        () => {
+            t(|n| {
+                n + 100
+            });
+        }
+    }
+}
+"#,
+        );
+    }
+
     #[test]
     fn no_assist_for_closures_with_braces() {
         check_assist_not_applicable(

From 5d9f8fcd3ea44bdd633ecddac2aff471ffcb797f Mon Sep 17 00:00:00 2001
From: Matthew Maurer <mmaurer@google.com>
Date: Tue, 2 Sep 2025 18:43:48 +0000
Subject: [PATCH 0422/1889] llvm: nvptx: Layout update to match LLVM

LLVM upstream switched layouts to support 256-bit vector load/store.
---
 compiler/rustc_codegen_llvm/src/context.rs                    | 4 ++++
 compiler/rustc_target/src/spec/targets/nvptx64_nvidia_cuda.rs | 2 +-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index 4fd6110ac4a11..257c7b95666f7 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -217,6 +217,10 @@ pub(crate) unsafe fn create_module<'ll>(
             // LLVM 22.0 updated the default layout on avr: https://github.com/llvm/llvm-project/pull/153010
             target_data_layout = target_data_layout.replace("n8:16", "n8")
         }
+        if sess.target.arch == "nvptx64" {
+            // LLVM 22 updated the NVPTX layout to indicate 256-bit vector load/store: https://github.com/llvm/llvm-project/pull/155198
+            target_data_layout = target_data_layout.replace("-i256:256", "");
+        }
     }
 
     // Ensure the data-layout values hardcoded remain the defaults.
diff --git a/compiler/rustc_target/src/spec/targets/nvptx64_nvidia_cuda.rs b/compiler/rustc_target/src/spec/targets/nvptx64_nvidia_cuda.rs
index 598f0f19f0def..cada0dd640a49 100644
--- a/compiler/rustc_target/src/spec/targets/nvptx64_nvidia_cuda.rs
+++ b/compiler/rustc_target/src/spec/targets/nvptx64_nvidia_cuda.rs
@@ -6,7 +6,7 @@ use crate::spec::{
 pub(crate) fn target() -> Target {
     Target {
         arch: "nvptx64".into(),
-        data_layout: "e-p6:32:32-i64:64-i128:128-v16:16-v32:32-n16:32:64".into(),
+        data_layout: "e-p6:32:32-i64:64-i128:128-i256:256-v16:16-v32:32-n16:32:64".into(),
         llvm_target: "nvptx64-nvidia-cuda".into(),
         metadata: TargetMetadata {
             description: Some("--emit=asm generates PTX code that runs on NVIDIA GPUs".into()),

From 916b55e08217ca14dabec0169067ed8d6523bf6e Mon Sep 17 00:00:00 2001
From: Ramon de C Valle <rcvalle@users.noreply.github.com>
Date: Tue, 2 Sep 2025 11:23:48 -0700
Subject: [PATCH 0423/1889] Revert "Make `lto` and `linker-plugin-lto` work the
 same for `compiler_builtins`"

This reverts commit cf8753e4f9c3597f04cd5d3aa261e4561d5378a6 and fixes the
regressions reported.
---
 compiler/rustc_codegen_ssa/src/back/write.rs | 13 +++++++++++-
 tests/ui/sanitizer/cfi/no_builtins.rs        | 22 --------------------
 2 files changed, 12 insertions(+), 23 deletions(-)
 delete mode 100644 tests/ui/sanitizer/cfi/no_builtins.rs

diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
index 92582dcc39917..8586615f7c764 100644
--- a/compiler/rustc_codegen_ssa/src/back/write.rs
+++ b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -138,12 +138,23 @@ impl ModuleConfig {
 
         let emit_obj = if !should_emit_obj {
             EmitObj::None
-        } else if sess.target.obj_is_bitcode || sess.opts.cg.linker_plugin_lto.enabled() {
+        } else if sess.target.obj_is_bitcode
+            || (sess.opts.cg.linker_plugin_lto.enabled() && !no_builtins)
+        {
             // This case is selected if the target uses objects as bitcode, or
             // if linker plugin LTO is enabled. In the linker plugin LTO case
             // the assumption is that the final link-step will read the bitcode
             // and convert it to object code. This may be done by either the
             // native linker or rustc itself.
+            //
+            // Note, however, that the linker-plugin-lto requested here is
+            // explicitly ignored for `#![no_builtins]` crates. These crates are
+            // specifically ignored by rustc's LTO passes and wouldn't work if
+            // loaded into the linker. These crates define symbols that LLVM
+            // lowers intrinsics to, and these symbol dependencies aren't known
+            // until after codegen. As a result any crate marked
+            // `#![no_builtins]` is assumed to not participate in LTO and
+            // instead goes on to generate object code.
             EmitObj::Bitcode
         } else if need_bitcode_in_object(tcx) {
             EmitObj::ObjectCode(BitcodeSection::Full)
diff --git a/tests/ui/sanitizer/cfi/no_builtins.rs b/tests/ui/sanitizer/cfi/no_builtins.rs
deleted file mode 100644
index 949057689aba1..0000000000000
--- a/tests/ui/sanitizer/cfi/no_builtins.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-// Verifies that `#![no_builtins]` crates can be built with linker-plugin-lto and CFI.
-// See Issue #142284
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clinker-plugin-lto -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
-//@ compile-flags: --crate-type rlib
-//@ build-pass
-
-#![no_builtins]
-#![no_std]
-
-pub static FUNC: fn() = initializer;
-
-pub fn initializer() {
-    call(fma_with_fma);
-}
-
-pub fn call(fn_ptr: fn()) {
-    fn_ptr();
-}
-
-pub fn fma_with_fma() {}

From 5a9e2e4aa8b388b25d146d86f70e55427bda8dd5 Mon Sep 17 00:00:00 2001
From: AudaciousAxiom <179637270+AudaciousAxiom@users.noreply.github.com>
Date: Tue, 2 Sep 2025 21:34:04 +0200
Subject: [PATCH 0424/1889] docs(std): add missing closing code block fences in
 doc comments

---
 library/core/src/iter/adapters/chain.rs                     | 1 +
 library/core/src/num/int_macros.rs                          | 2 +-
 library/core/src/num/uint_macros.rs                         | 2 +-
 library/core/src/ops/range.rs                               | 1 +
 library/core/src/ptr/mut_ptr.rs                             | 1 +
 library/portable-simd/crates/core_simd/src/simd/num/int.rs  | 1 +
 library/portable-simd/crates/core_simd/src/simd/num/uint.rs | 1 +
 7 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/library/core/src/iter/adapters/chain.rs b/library/core/src/iter/adapters/chain.rs
index 943b88e23305a..3ebdf7b472796 100644
--- a/library/core/src/iter/adapters/chain.rs
+++ b/library/core/src/iter/adapters/chain.rs
@@ -321,6 +321,7 @@ impl<A: Default, B: Default> Default for Chain<A, B> {
     ///
     /// // take requires `Default`
     /// let _: Chain<_, _> = mem::take(&mut foo.0);
+    /// ```
     fn default() -> Self {
         Chain::new(Default::default(), Default::default())
     }
diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs
index 25864db5fea77..db70fb65d444e 100644
--- a/library/core/src/num/int_macros.rs
+++ b/library/core/src/num/int_macros.rs
@@ -1285,7 +1285,7 @@ macro_rules! int_impl {
         ///
         /// ```should_panic
         #[doc = concat!("let _ = ", stringify!($SelfT), "::MIN.strict_neg();")]
-        ///
+        /// ```
         #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
         #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
         #[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 c1e656fdea236..a5c8ae7e26edf 100644
--- a/library/core/src/num/uint_macros.rs
+++ b/library/core/src/num/uint_macros.rs
@@ -1620,7 +1620,7 @@ macro_rules! uint_impl {
         ///
         /// ```should_panic
         #[doc = concat!("let _ = 1", stringify!($SelfT), ".strict_neg();")]
-        ///
+        /// ```
         #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
         #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
         #[must_use = "this returns the result of the operation, \
diff --git a/library/core/src/ops/range.rs b/library/core/src/ops/range.rs
index c0a27775694c3..58a9431bd845d 100644
--- a/library/core/src/ops/range.rs
+++ b/library/core/src/ops/range.rs
@@ -836,6 +836,7 @@ pub trait RangeBounds<T: ?Sized> {
     /// assert!(!(0.0..1.0).contains(&f32::NAN));
     /// assert!(!(0.0..f32::NAN).contains(&0.5));
     /// assert!(!(f32::NAN..1.0).contains(&0.5));
+    /// ```
     #[inline]
     #[stable(feature = "range_contains", since = "1.35.0")]
     fn contains<U>(&self, item: &U) -> bool
diff --git a/library/core/src/ptr/mut_ptr.rs b/library/core/src/ptr/mut_ptr.rs
index 3fe4b08d459e0..ce6eee4f911ed 100644
--- a/library/core/src/ptr/mut_ptr.rs
+++ b/library/core/src/ptr/mut_ptr.rs
@@ -106,6 +106,7 @@ impl<T: PointeeSized> *mut T {
     ///
     /// // This dereference is UB. The pointer only has provenance for `x` but points to `y`.
     /// println!("{:?}", unsafe { &*bad });
+    /// ```
     #[unstable(feature = "set_ptr_value", issue = "75091")]
     #[must_use = "returns a new pointer rather than modifying its argument"]
     #[inline]
diff --git a/library/portable-simd/crates/core_simd/src/simd/num/int.rs b/library/portable-simd/crates/core_simd/src/simd/num/int.rs
index d25050c3e4b47..e7253313f036c 100644
--- a/library/portable-simd/crates/core_simd/src/simd/num/int.rs
+++ b/library/portable-simd/crates/core_simd/src/simd/num/int.rs
@@ -58,6 +58,7 @@ pub trait SimdInt: Copy + Sealed {
     /// let sat = x.saturating_sub(max);
     /// assert_eq!(unsat, Simd::from_array([1, MAX, MIN, 0]));
     /// assert_eq!(sat, Simd::from_array([MIN, MIN, MIN, 0]));
+    /// ```
     fn saturating_sub(self, second: Self) -> Self;
 
     /// Lanewise absolute value, implemented in Rust.
diff --git a/library/portable-simd/crates/core_simd/src/simd/num/uint.rs b/library/portable-simd/crates/core_simd/src/simd/num/uint.rs
index 45d978068b664..e3ba8658bd803 100644
--- a/library/portable-simd/crates/core_simd/src/simd/num/uint.rs
+++ b/library/portable-simd/crates/core_simd/src/simd/num/uint.rs
@@ -55,6 +55,7 @@ pub trait SimdUint: Copy + Sealed {
     /// let sat = x.saturating_sub(max);
     /// assert_eq!(unsat, Simd::from_array([3, 2, 1, 0]));
     /// assert_eq!(sat, Simd::splat(0));
+    /// ```
     fn saturating_sub(self, second: Self) -> Self;
 
     /// Lanewise absolute difference.

From 418900562cb189e68b21acd49116ed8235646578 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Wed, 3 Sep 2025 00:05:50 +0200
Subject: [PATCH 0425/1889] explicitly start `va_list` lifetime

---
 compiler/rustc_codegen_ssa/src/mir/block.rs |  2 +-
 compiler/rustc_codegen_ssa/src/mir/mod.rs   |  4 ++++
 tests/codegen-llvm/c-variadic-lifetime.rs   | 21 +++++++++++++++++++++
 3 files changed, 26 insertions(+), 1 deletion(-)
 create mode 100644 tests/codegen-llvm/c-variadic-lifetime.rs

diff --git a/compiler/rustc_codegen_ssa/src/mir/block.rs b/compiler/rustc_codegen_ssa/src/mir/block.rs
index 5f6976f5d0051..6492ef73956b0 100644
--- a/compiler/rustc_codegen_ssa/src/mir/block.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/block.rs
@@ -520,7 +520,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 LocalRef::Place(va_list) => {
                     bx.va_end(va_list.val.llval);
 
-                    // Explicitly end the lifetime of the `va_list`, this matters for LLVM.
+                    // Explicitly end the lifetime of the `va_list`, improves LLVM codegen.
                     bx.lifetime_end(va_list.val.llval, va_list.layout.size);
                 }
                 _ => bug!("C-variadic function must have a `VaList` place"),
diff --git a/compiler/rustc_codegen_ssa/src/mir/mod.rs b/compiler/rustc_codegen_ssa/src/mir/mod.rs
index 06873313e2ecd..6b109e8b8e2f4 100644
--- a/compiler/rustc_codegen_ssa/src/mir/mod.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/mod.rs
@@ -438,6 +438,10 @@ fn arg_local_refs<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
 
             if fx.fn_abi.c_variadic && arg_index == fx.fn_abi.args.len() {
                 let va_list = PlaceRef::alloca(bx, bx.layout_of(arg_ty));
+
+                // Explicitly start the lifetime of the `va_list`, improves LLVM codegen.
+                bx.lifetime_start(va_list.val.llval, va_list.layout.size);
+
                 bx.va_start(va_list.val.llval);
 
                 return LocalRef::Place(va_list);
diff --git a/tests/codegen-llvm/c-variadic-lifetime.rs b/tests/codegen-llvm/c-variadic-lifetime.rs
new file mode 100644
index 0000000000000..5b2f8af18c817
--- /dev/null
+++ b/tests/codegen-llvm/c-variadic-lifetime.rs
@@ -0,0 +1,21 @@
+//@ add-core-stubs
+//@ compile-flags: -Copt-level=3
+#![feature(c_variadic)]
+#![crate_type = "lib"]
+
+// Check that `%args` explicitly has its lifetime start and end. Being explicit can improve
+// instruction and register selection, see e.g. https://github.com/rust-lang/rust/pull/144549
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn variadic(a: f64, mut args: ...) -> f64 {
+    // CHECK: call void @llvm.lifetime.start.p0(i64 {{[0-9]+}}, ptr nonnull %args)
+    // CHECK: call void @llvm.va_start.p0(ptr nonnull %args)
+
+    let b = args.arg::<f64>();
+    let c = args.arg::<f64>();
+
+    a + b + c
+
+    // CHECK: call void @llvm.va_end.p0(ptr nonnull %args)
+    // CHECK: call void @llvm.lifetime.end.p0(i64 {{[0-9]+}}, ptr nonnull %args)
+}

From 43873db3b31b46280287d0797679f04d1407ddee Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Tue, 2 Sep 2025 18:30:16 -0400
Subject: [PATCH 0426/1889] test(rustdoc): show the wrong `--emit` precedence

It should have the same behavior as rustc, which the last wins.
---
 tests/run-make/rustdoc-dep-info/rmake.rs | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/tests/run-make/rustdoc-dep-info/rmake.rs b/tests/run-make/rustdoc-dep-info/rmake.rs
index 625f81fd428ef..956809909d92f 100644
--- a/tests/run-make/rustdoc-dep-info/rmake.rs
+++ b/tests/run-make/rustdoc-dep-info/rmake.rs
@@ -33,4 +33,17 @@ fn main() {
     // Now we check that we can provide a file name to the `dep-info` argument.
     rustdoc().input("lib.rs").arg("-Zunstable-options").emit("dep-info=bla.d").run();
     assert!(path("bla.d").exists());
+
+    // The last emit-type wins. The same behavior as rustc.
+    // TODO: this shows the wrong behavior as a MRE, which will be fixed in the next commit
+    rustdoc()
+        .input("lib.rs")
+        .arg("-Zunstable-options")
+        .emit("dep-info=precedence1.d")
+        .emit("dep-info=precedence2.d")
+        .emit("dep-info=precedence3.d")
+        .run();
+    assert!(path("precedence1.d").exists());
+    assert!(!path("precedence2.d").exists());
+    assert!(!path("precedence3.d").exists());
 }

From af0d6f129096dabeee42978c84596a3acb43c1b0 Mon Sep 17 00:00:00 2001
From: jeremyd2019 <github@jdrake.com>
Date: Tue, 2 Sep 2025 16:27:45 -0700
Subject: [PATCH 0427/1889] compiletest: cygwin follows windows in using PATH
 for dynamic libraries

---
 src/tools/compiletest/src/util.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/compiletest/src/util.rs b/src/tools/compiletest/src/util.rs
index 1f16a672a98e7..558e9a58697e7 100644
--- a/src/tools/compiletest/src/util.rs
+++ b/src/tools/compiletest/src/util.rs
@@ -45,7 +45,7 @@ impl Utf8PathBufExt for Utf8PathBuf {
 
 /// The name of the environment variable that holds dynamic library locations.
 pub fn dylib_env_var() -> &'static str {
-    if cfg!(windows) {
+    if cfg!(any(windows, target_os = "cygwin")) {
         "PATH"
     } else if cfg!(target_vendor = "apple") {
         "DYLD_LIBRARY_PATH"

From 4daea276ee223c12de884cf6ca8ec323f439dbeb Mon Sep 17 00:00:00 2001
From: Nia Espera <nia-e@haecceity.cc>
Date: Wed, 3 Sep 2025 01:56:03 +0200
Subject: [PATCH 0428/1889] add zed editor config

---
 src/tools/miri/CONTRIBUTING.md            |  6 ++++
 src/tools/miri/etc/rust_analyzer_zed.json | 41 +++++++++++++++++++++++
 2 files changed, 47 insertions(+)
 create mode 100644 src/tools/miri/etc/rust_analyzer_zed.json

diff --git a/src/tools/miri/CONTRIBUTING.md b/src/tools/miri/CONTRIBUTING.md
index 7d78fdddbad3d..073ad267476c4 100644
--- a/src/tools/miri/CONTRIBUTING.md
+++ b/src/tools/miri/CONTRIBUTING.md
@@ -255,6 +255,12 @@ when installing the Miri toolchain. Alternatively, set the `RUSTUP_TOOLCHAIN` en
 
 [`etc/rust_analyzer_helix.toml`]: https://github.com/rust-lang/miri/blob/master/etc/rust_analyzer_helix.toml
 
+### Zed
+
+Copy [`etc/rust_analyzer_zed.json`] to `.zed/settings.json` in the project root directory.
+
+[`etc/rust_analyzer_zed.json`]: https://github.com/rust-lang/miri/blob/master/etc/rust_analyzer_zed.json
+
 ### Advanced configuration
 
 If you are building Miri with a locally built rustc, set
diff --git a/src/tools/miri/etc/rust_analyzer_zed.json b/src/tools/miri/etc/rust_analyzer_zed.json
new file mode 100644
index 0000000000000..839914c8b68ed
--- /dev/null
+++ b/src/tools/miri/etc/rust_analyzer_zed.json
@@ -0,0 +1,41 @@
+{
+    "lsp": {
+        "rust-analyzer": {
+            "initialization_options": {
+                "rustc": {
+                    "source": "discover"
+                },
+                "linkedProjects": [
+                    "./Cargo.toml",
+                    "./cargo-miri/Cargo.toml",
+                    "./genmc-sys/Cargo.toml",
+                    "./miri-script/Cargo.toml"
+                ],
+                "check": {
+                    "invocationStrategy": "once",
+                    "overrideCommand": [
+                        "./miri",
+                        "clippy", // make this `check` when working with a locally built rustc
+                        "--message-format=json"
+                    ]
+                },
+                "cargo": {
+                    "extraEnv": {
+                        "MIRI_AUTO_OPS": "no",
+                        "MIRI_IN_RA": "1"
+                    },
+                    // Contrary to what the name suggests, this also affects proc macros.
+                    "buildScripts": {
+                        "invocationStrategy": "once",
+                        "overrideCommand": [
+                            "./miri",
+                            "check",
+                            "--no-default-features",
+                            "--message-format=json"
+                        ]
+                    }
+                }
+            }
+        }
+    }
+}

From 46795337322b5852438417549a5fe9dce3f75479 Mon Sep 17 00:00:00 2001
From: Tsukasa OI <floss_rust@irq.a4lg.com>
Date: Sat, 30 Aug 2025 05:05:12 +0000
Subject: [PATCH 0429/1889] RISC-V: Lower requirements of `clmul` and `clmulh`

They don't need full "Zbc" extension but only its subset: the "Zbkc"
extension.  Since the compiler implies `zbkc` from `zbc`, it's safe to
use `#[target_feature(enable = "zbkc")]`.
---
 library/stdarch/crates/core_arch/src/riscv_shared/zb.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/library/stdarch/crates/core_arch/src/riscv_shared/zb.rs b/library/stdarch/crates/core_arch/src/riscv_shared/zb.rs
index 9472e3c8be9f6..514afd9080920 100644
--- a/library/stdarch/crates/core_arch/src/riscv_shared/zb.rs
+++ b/library/stdarch/crates/core_arch/src/riscv_shared/zb.rs
@@ -68,7 +68,7 @@ pub fn orc_b(rs: usize) -> usize {
 ///
 /// Section: 2.11
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
-#[target_feature(enable = "zbc")]
+#[target_feature(enable = "zbkc")]
 #[cfg_attr(test, assert_instr(clmul))]
 #[inline]
 pub fn clmul(rs1: usize, rs2: usize) -> usize {
@@ -93,7 +93,7 @@ pub fn clmul(rs1: usize, rs2: usize) -> usize {
 ///
 /// Section: 2.12
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
-#[target_feature(enable = "zbc")]
+#[target_feature(enable = "zbkc")]
 #[cfg_attr(test, assert_instr(clmulh))]
 #[inline]
 pub fn clmulh(rs1: usize, rs2: usize) -> usize {

From cefa74f1f4c940423ba7b31f03f237bbe174823d Mon Sep 17 00:00:00 2001
From: Jeremy Smart <jeremy3141592@gmail.com>
Date: Tue, 2 Sep 2025 23:28:09 -0400
Subject: [PATCH 0430/1889] add exact bitshifts

---
 library/core/src/num/int_macros.rs  | 117 ++++++++++++++++++++++++++++
 library/core/src/num/uint_macros.rs | 114 +++++++++++++++++++++++++++
 2 files changed, 231 insertions(+)

diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs
index 25864db5fea77..4bfff3d559d11 100644
--- a/library/core/src/num/int_macros.rs
+++ b/library/core/src/num/int_macros.rs
@@ -1413,6 +1413,66 @@ macro_rules! int_impl {
             }
         }
 
+        /// Exact shift left. Computes `self << rhs` as long as it can be reversed losslessly.
+        ///
+        /// Returns `None` if any bits that would be shifted out differ from the resulting sign bit
+        /// or if `rhs` >=
+        #[doc = concat!("`", stringify!($SelfT), "::BITS`.")]
+        /// Otherwise, returns `Some(self << rhs)`.
+        ///
+        /// # Examples
+        ///
+        /// ```
+        /// #![feature(exact_bitshifts)]
+        ///
+        #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".exact_shl(4), Some(0x10));")]
+        #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".exact_shl(", stringify!($SelfT), "::BITS - 2), Some(1 << ", stringify!($SelfT), "::BITS - 2));")]
+        #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".exact_shl(", stringify!($SelfT), "::BITS - 1), None);")]
+        #[doc = concat!("assert_eq!((-0x2", stringify!($SelfT), ").exact_shl(", stringify!($SelfT), "::BITS - 2), Some(-0x2 << ", stringify!($SelfT), "::BITS - 2));")]
+        #[doc = concat!("assert_eq!((-0x2", stringify!($SelfT), ").exact_shl(", stringify!($SelfT), "::BITS - 1), None);")]
+        /// ```
+        #[unstable(feature = "exact_bitshifts", issue = "144336")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn exact_shl(self, rhs: u32) -> Option<$SelfT> {
+            if rhs < self.leading_zeros() || rhs < self.leading_ones() {
+                // SAFETY: rhs is checked above
+                Some(unsafe { self.unchecked_shl(rhs) })
+            } else {
+                None
+            }
+        }
+
+        /// Unchecked exact shift left. Computes `self << rhs`, assuming the operation can be
+        /// losslessly reversed and `rhs` cannot be larger than
+        #[doc = concat!("`", stringify!($SelfT), "::BITS`.")]
+        ///
+        /// # Safety
+        ///
+        /// This results in undefined behavior when `rhs >= self.leading_zeros() && rhs >=
+        /// self.leading_ones()` i.e. when
+        #[doc = concat!("[`", stringify!($SelfT), "::exact_shl`]")]
+        /// would return `None`.
+        #[unstable(feature = "exact_bitshifts", issue = "144336")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const unsafe fn unchecked_exact_shl(self, rhs: u32) -> $SelfT {
+            assert_unsafe_precondition!(
+                check_language_ub,
+                concat!(stringify!($SelfT), "::unchecked_exact_shl cannot shift out non-zero bits"),
+                (
+                    zeros: u32 = self.leading_zeros(),
+                    ones: u32 = self.leading_ones(),
+                    rhs: u32 = rhs,
+                ) => rhs < zeros || rhs < ones,
+            );
+
+            // SAFETY: this is guaranteed to be safe by the caller
+            unsafe { self.unchecked_shl(rhs) }
+        }
+
         /// Checked shift right. Computes `self >> rhs`, returning `None` if `rhs` is
         /// larger than or equal to the number of bits in `self`.
         ///
@@ -1534,6 +1594,63 @@ macro_rules! int_impl {
             }
         }
 
+        /// Exact shift right. Computes `self >> rhs` as long as it can be reversed losslessly.
+        ///
+        /// Returns `None` if any non-zero bits would be shifted out or if `rhs` >=
+        #[doc = concat!("`", stringify!($SelfT), "::BITS`.")]
+        /// Otherwise, returns `Some(self >> rhs)`.
+        ///
+        /// # Examples
+        ///
+        /// ```
+        /// #![feature(exact_bitshifts)]
+        ///
+        #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".exact_shr(4), Some(0x1));")]
+        #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".exact_shr(5), None);")]
+        /// ```
+        #[unstable(feature = "exact_bitshifts", issue = "144336")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn exact_shr(self, rhs: u32) -> Option<$SelfT> {
+            if rhs <= self.trailing_zeros() && rhs < <$SelfT>::BITS {
+                // SAFETY: rhs is checked above
+                Some(unsafe { self.unchecked_shr(rhs) })
+            } else {
+                None
+            }
+        }
+
+        /// Unchecked exact shift right. Computes `self >> rhs`, assuming the operation can be
+        /// losslessly reversed and `rhs` cannot be larger than
+        #[doc = concat!("`", stringify!($SelfT), "::BITS`.")]
+        ///
+        /// # Safety
+        ///
+        /// This results in undefined behavior when `rhs > self.trailing_zeros() || rhs >=
+        #[doc = concat!(stringify!($SelfT), "::BITS`")]
+        /// i.e. when
+        #[doc = concat!("[`", stringify!($SelfT), "::exact_shr`]")]
+        /// would return `None`.
+        #[unstable(feature = "exact_bitshifts", issue = "144336")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const unsafe fn unchecked_exact_shr(self, rhs: u32) -> $SelfT {
+            assert_unsafe_precondition!(
+                check_language_ub,
+                concat!(stringify!($SelfT), "::unchecked_exact_shr cannot shift out non-zero bits"),
+                (
+                    zeros: u32 = self.trailing_zeros(),
+                    bits: u32 =  <$SelfT>::BITS,
+                    rhs: u32 = rhs,
+                ) => rhs <= zeros && rhs < bits,
+            );
+
+            // SAFETY: this is guaranteed to be safe by the caller
+            unsafe { self.unchecked_shr(rhs) }
+        }
+
         /// 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 10d9498d15e45..bbb53e3becfed 100644
--- a/library/core/src/num/uint_macros.rs
+++ b/library/core/src/num/uint_macros.rs
@@ -1734,6 +1734,63 @@ macro_rules! uint_impl {
             }
         }
 
+        /// Exact shift left. Computes `self << rhs` as long as it can be reversed losslessly.
+        ///
+        /// Returns `None` if any non-zero bits would be shifted out or if `rhs` >=
+        #[doc = concat!("`", stringify!($SelfT), "::BITS`.")]
+        /// Otherwise, returns `Some(self << rhs)`.
+        ///
+        /// # Examples
+        ///
+        /// ```
+        /// #![feature(exact_bitshifts)]
+        ///
+        #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".exact_shl(4), Some(0x10));")]
+        #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".exact_shl(129), None);")]
+        /// ```
+        #[unstable(feature = "exact_bitshifts", issue = "144336")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn exact_shl(self, rhs: u32) -> Option<$SelfT> {
+            if rhs <= self.leading_zeros() && rhs < <$SelfT>::BITS {
+                // SAFETY: rhs is checked above
+                Some(unsafe { self.unchecked_shl(rhs) })
+            } else {
+                None
+            }
+        }
+
+        /// Unchecked exact shift left. Computes `self << rhs`, assuming the operation can be
+        /// losslessly reversed `rhs` cannot be larger than
+        #[doc = concat!("`", stringify!($SelfT), "::BITS`.")]
+        ///
+        /// # Safety
+        ///
+        /// This results in undefined behavior when `rhs > self.leading_zeros() || rhs >=
+        #[doc = concat!(stringify!($SelfT), "::BITS`")]
+        /// i.e. when
+        #[doc = concat!("[`", stringify!($SelfT), "::exact_shl`]")]
+        /// would return `None`.
+        #[unstable(feature = "exact_bitshifts", issue = "144336")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const unsafe fn unchecked_exact_shl(self, rhs: u32) -> $SelfT {
+            assert_unsafe_precondition!(
+                check_language_ub,
+                concat!(stringify!($SelfT), "::exact_shl_unchecked cannot shift out non-zero bits"),
+                (
+                    zeros: u32 = self.leading_zeros(),
+                    bits: u32 =  <$SelfT>::BITS,
+                    rhs: u32 = rhs,
+                ) => rhs <= zeros && rhs < bits,
+            );
+
+            // SAFETY: this is guaranteed to be safe by the caller
+            unsafe { self.unchecked_shl(rhs) }
+        }
+
         /// Checked shift right. Computes `self >> rhs`, returning `None`
         /// if `rhs` is larger than or equal to the number of bits in `self`.
         ///
@@ -1849,6 +1906,63 @@ macro_rules! uint_impl {
             }
         }
 
+        /// Exact shift right. Computes `self >> rhs` as long as it can be reversed losslessly.
+        ///
+        /// Returns `None` if any non-zero bits would be shifted out or if `rhs` >=
+        #[doc = concat!("`", stringify!($SelfT), "::BITS`.")]
+        /// Otherwise, returns `Some(self >> rhs)`.
+        ///
+        /// # Examples
+        ///
+        /// ```
+        /// #![feature(exact_bitshifts)]
+        ///
+        #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".exact_shr(4), Some(0x1));")]
+        #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".exact_shr(5), None);")]
+        /// ```
+        #[unstable(feature = "exact_bitshifts", issue = "144336")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn exact_shr(self, rhs: u32) -> Option<$SelfT> {
+            if rhs <= self.trailing_zeros() && rhs < <$SelfT>::BITS {
+                // SAFETY: rhs is checked above
+                Some(unsafe { self.unchecked_shr(rhs) })
+            } else {
+                None
+            }
+        }
+
+        /// Unchecked exact shift right. Computes `self >> rhs`, assuming the operation can be
+        /// losslessly reversed and `rhs` cannot be larger than
+        #[doc = concat!("`", stringify!($SelfT), "::BITS`.")]
+        ///
+        /// # Safety
+        ///
+        /// This results in undefined behavior when `rhs > self.trailing_zeros() || rhs >=
+        #[doc = concat!(stringify!($SelfT), "::BITS`")]
+        /// i.e. when
+        #[doc = concat!("[`", stringify!($SelfT), "::exact_shr`]")]
+        /// would return `None`.
+        #[unstable(feature = "exact_bitshifts", issue = "144336")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const unsafe fn unchecked_exact_shr(self, rhs: u32) -> $SelfT {
+            assert_unsafe_precondition!(
+                check_language_ub,
+                concat!(stringify!($SelfT), "::exact_shr_unchecked cannot shift out non-zero bits"),
+                (
+                    zeros: u32 = self.trailing_zeros(),
+                    bits: u32 =  <$SelfT>::BITS,
+                    rhs: u32 = rhs,
+                ) => rhs <= zeros && rhs < bits,
+            );
+
+            // SAFETY: this is guaranteed to be safe by the caller
+            unsafe { self.unchecked_shr(rhs) }
+        }
+
         /// Checked exponentiation. Computes `self.pow(exp)`, returning `None` if
         /// overflow occurred.
         ///

From ef1dab1cb6234bb32a5b82e31b8684be0cabfcd9 Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Wed, 3 Sep 2025 04:53:32 +0000
Subject: [PATCH 0431/1889] Prepare for merging from rust-lang/rust

This updates the rust-version file to 51ff895062ba60a7cba53f57af928c3fb7b0f2f4.
---
 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 594b47b888f9a..d44488399f8b9 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-828e45ad11ce4ab56dd64e93f1fb5dd8f0c0ae93
+51ff895062ba60a7cba53f57af928c3fb7b0f2f4

From d9dc20c7529d93ba4e1f91c9e44fb882c07aa1c0 Mon Sep 17 00:00:00 2001
From: Bart Jacobs <bart.jacobs@cs.kuleuven.be>
Date: Fri, 22 Aug 2025 15:28:37 +0200
Subject: [PATCH 0432/1889] raw_vec.rs: Remove superfluous fn alloc_guard

It checks that its argument is at most isize::MAX, but it is called
only with layout sizes, which are already guaranteed to be at most
isize::MAX.
---
 library/alloc/src/raw_vec/mod.rs | 27 ++-------------------------
 1 file changed, 2 insertions(+), 25 deletions(-)

diff --git a/library/alloc/src/raw_vec/mod.rs b/library/alloc/src/raw_vec/mod.rs
index 40716755aad34..bbad7542089db 100644
--- a/library/alloc/src/raw_vec/mod.rs
+++ b/library/alloc/src/raw_vec/mod.rs
@@ -468,10 +468,6 @@ impl<A: Allocator> RawVecInner<A> {
             return Ok(Self::new_in(alloc, elem_layout.alignment()));
         }
 
-        if let Err(err) = alloc_guard(layout.size()) {
-            return Err(err);
-        }
-
         let result = match init {
             AllocInit::Uninitialized => alloc.allocate(layout),
             #[cfg(not(no_global_oom_handling))]
@@ -662,7 +658,7 @@ impl<A: Allocator> RawVecInner<A> {
         let new_layout = layout_array(cap, elem_layout)?;
 
         let ptr = finish_grow(new_layout, self.current_memory(elem_layout), &mut self.alloc)?;
-        // SAFETY: finish_grow would have resulted in a capacity overflow if we tried to allocate more than `isize::MAX` items
+        // SAFETY: layout_array would have resulted in a capacity overflow if we tried to allocate more than `isize::MAX` items
 
         unsafe { self.set_ptr_and_cap(ptr, cap) };
         Ok(())
@@ -684,7 +680,7 @@ impl<A: Allocator> RawVecInner<A> {
         let new_layout = layout_array(cap, elem_layout)?;
 
         let ptr = finish_grow(new_layout, self.current_memory(elem_layout), &mut self.alloc)?;
-        // SAFETY: finish_grow would have resulted in a capacity overflow if we tried to allocate more than `isize::MAX` items
+        // SAFETY: layout_array would have resulted in a capacity overflow if we tried to allocate more than `isize::MAX` items
         unsafe {
             self.set_ptr_and_cap(ptr, cap);
         }
@@ -771,8 +767,6 @@ fn finish_grow<A>(
 where
     A: Allocator,
 {
-    alloc_guard(new_layout.size())?;
-
     let memory = if let Some((ptr, old_layout)) = current_memory {
         debug_assert_eq!(old_layout.align(), new_layout.align());
         unsafe {
@@ -799,23 +793,6 @@ fn handle_error(e: TryReserveError) -> ! {
     }
 }
 
-// We need to guarantee the following:
-// * We don't ever allocate `> isize::MAX` byte-size objects.
-// * We don't overflow `usize::MAX` and actually allocate too little.
-//
-// On 64-bit we just need to check for overflow since trying to allocate
-// `> isize::MAX` bytes will surely fail. On 32-bit and 16-bit we need to add
-// an extra guard for this in case we're running on a platform which can use
-// all 4GB in user-space, e.g., PAE or x32.
-#[inline]
-fn alloc_guard(alloc_size: usize) -> Result<(), TryReserveError> {
-    if usize::BITS < 64 && alloc_size > isize::MAX as usize {
-        Err(CapacityOverflow.into())
-    } else {
-        Ok(())
-    }
-}
-
 #[inline]
 fn layout_array(cap: usize, elem_layout: Layout) -> Result<Layout, TryReserveError> {
     elem_layout.repeat(cap).map(|(layout, _pad)| layout).map_err(|_| CapacityOverflow.into())

From 0fa93a3434a07cfd5edd0386d3053aced16e4e9e Mon Sep 17 00:00:00 2001
From: Urgau <urgau@numericable.fr>
Date: Tue, 2 Sep 2025 22:58:11 +0200
Subject: [PATCH 0433/1889] Disallow frontmatter in `--cfg` and `--check-cfg`
 arguments

---
 compiler/rustc_interface/src/interface.rs     |  6 ++--
 compiler/rustc_parse/src/lib.rs               | 20 +++++++++--
 .../run-make/multiline-args-value/cfg.stderr  |  4 +++
 .../multiline-args-value/check-cfg.stderr     |  7 ++++
 tests/run-make/multiline-args-value/rmake.rs  | 34 +++++++++++++++++++
 5 files changed, 65 insertions(+), 6 deletions(-)
 create mode 100644 tests/run-make/multiline-args-value/cfg.stderr
 create mode 100644 tests/run-make/multiline-args-value/check-cfg.stderr
 create mode 100644 tests/run-make/multiline-args-value/rmake.rs

diff --git a/compiler/rustc_interface/src/interface.rs b/compiler/rustc_interface/src/interface.rs
index 8f131f45bbddb..4c820b8877b75 100644
--- a/compiler/rustc_interface/src/interface.rs
+++ b/compiler/rustc_interface/src/interface.rs
@@ -13,7 +13,7 @@ use rustc_lint::LintStore;
 use rustc_middle::ty;
 use rustc_middle::ty::CurrentGcx;
 use rustc_middle::util::Providers;
-use rustc_parse::new_parser_from_source_str;
+use rustc_parse::new_parser_from_simple_source_str;
 use rustc_parse::parser::attr::AllowLeadingUnsafe;
 use rustc_query_impl::QueryCtxt;
 use rustc_query_system::query::print_query_stack;
@@ -68,7 +68,7 @@ pub(crate) fn parse_cfg(dcx: DiagCtxtHandle<'_>, cfgs: Vec<String>) -> Cfg {
                 };
             }
 
-            match new_parser_from_source_str(&psess, filename, s.to_string()) {
+            match new_parser_from_simple_source_str(&psess, filename, s.to_string()) {
                 Ok(mut parser) => match parser.parse_meta_item(AllowLeadingUnsafe::No) {
                     Ok(meta_item) if parser.token == token::Eof => {
                         if meta_item.path.segments.len() != 1 {
@@ -166,7 +166,7 @@ pub(crate) fn parse_check_cfg(dcx: DiagCtxtHandle<'_>, specs: Vec<String>) -> Ch
             error!("expected `cfg(name, values(\"value1\", \"value2\", ... \"valueN\"))`")
         };
 
-        let mut parser = match new_parser_from_source_str(&psess, filename, s.to_string()) {
+        let mut parser = match new_parser_from_simple_source_str(&psess, filename, s.to_string()) {
             Ok(parser) => parser,
             Err(errs) => {
                 errs.into_iter().for_each(|err| err.cancel());
diff --git a/compiler/rustc_parse/src/lib.rs b/compiler/rustc_parse/src/lib.rs
index 197333d942d28..b790966acfd92 100644
--- a/compiler/rustc_parse/src/lib.rs
+++ b/compiler/rustc_parse/src/lib.rs
@@ -62,7 +62,20 @@ pub fn new_parser_from_source_str(
     source: String,
 ) -> Result<Parser<'_>, Vec<Diag<'_>>> {
     let source_file = psess.source_map().new_source_file(name, source);
-    new_parser_from_source_file(psess, source_file)
+    new_parser_from_source_file(psess, source_file, FrontmatterAllowed::Yes)
+}
+
+/// Creates a new parser from a simple (no frontmatter) source string.
+///
+/// On failure, the errors must be consumed via `unwrap_or_emit_fatal`, `emit`, `cancel`,
+/// etc., otherwise a panic will occur when they are dropped.
+pub fn new_parser_from_simple_source_str(
+    psess: &ParseSess,
+    name: FileName,
+    source: String,
+) -> Result<Parser<'_>, Vec<Diag<'_>>> {
+    let source_file = psess.source_map().new_source_file(name, source);
+    new_parser_from_source_file(psess, source_file, FrontmatterAllowed::No)
 }
 
 /// Creates a new parser from a filename. On failure, the errors must be consumed via
@@ -96,7 +109,7 @@ pub fn new_parser_from_file<'a>(
         }
         err.emit();
     });
-    new_parser_from_source_file(psess, source_file)
+    new_parser_from_source_file(psess, source_file, FrontmatterAllowed::Yes)
 }
 
 pub fn utf8_error<E: EmissionGuarantee>(
@@ -147,9 +160,10 @@ pub fn utf8_error<E: EmissionGuarantee>(
 fn new_parser_from_source_file(
     psess: &ParseSess,
     source_file: Arc<SourceFile>,
+    frontmatter_allowed: FrontmatterAllowed,
 ) -> Result<Parser<'_>, Vec<Diag<'_>>> {
     let end_pos = source_file.end_position();
-    let stream = source_file_to_stream(psess, source_file, None, FrontmatterAllowed::Yes)?;
+    let stream = source_file_to_stream(psess, source_file, None, frontmatter_allowed)?;
     let mut parser = Parser::new(psess, stream, None);
     if parser.token == token::Eof {
         parser.token.span = Span::new(end_pos, end_pos, parser.token.span.ctxt(), None);
diff --git a/tests/run-make/multiline-args-value/cfg.stderr b/tests/run-make/multiline-args-value/cfg.stderr
new file mode 100644
index 0000000000000..9b06f84be4884
--- /dev/null
+++ b/tests/run-make/multiline-args-value/cfg.stderr
@@ -0,0 +1,4 @@
+error: invalid `--cfg` argument: `---
+       ---
+       key` (expected `key` or `key="value"`)
+
diff --git a/tests/run-make/multiline-args-value/check-cfg.stderr b/tests/run-make/multiline-args-value/check-cfg.stderr
new file mode 100644
index 0000000000000..4a499cc0a1e24
--- /dev/null
+++ b/tests/run-make/multiline-args-value/check-cfg.stderr
@@ -0,0 +1,7 @@
+error: invalid `--check-cfg` argument: `---
+       ---
+       cfg(key)`
+  |
+  = note: expected `cfg(name, values("value1", "value2", ... "valueN"))`
+  = note: visit <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more details
+
diff --git a/tests/run-make/multiline-args-value/rmake.rs b/tests/run-make/multiline-args-value/rmake.rs
new file mode 100644
index 0000000000000..825cbd158c0a3
--- /dev/null
+++ b/tests/run-make/multiline-args-value/rmake.rs
@@ -0,0 +1,34 @@
+use run_make_support::{cwd, diff, rustc};
+
+fn test_and_compare(flag: &str, val: &str) {
+    let mut cmd = rustc();
+
+    let output =
+        cmd.input("").arg("--crate-type=lib").arg(&format!("--{flag}")).arg(val).run_fail();
+
+    assert_eq!(output.stdout_utf8(), "");
+    diff()
+        .expected_file(format!("{flag}.stderr"))
+        .actual_text("output", output.stderr_utf8())
+        .run();
+}
+
+fn main() {
+    // Verify that frontmatter isn't allowed in `--cfg` arguments.
+    // https://github.com/rust-lang/rust/issues/146130
+    test_and_compare(
+        "cfg",
+        r#"---
+---
+key"#,
+    );
+
+    // Verify that frontmatter isn't allowed in `--check-cfg` arguments.
+    // https://github.com/rust-lang/rust/issues/146130
+    test_and_compare(
+        "check-cfg",
+        r#"---
+---
+cfg(key)"#,
+    );
+}

From fee5cd10c2038176b23b92ea252999d340dba20f Mon Sep 17 00:00:00 2001
From: FrancescoV1985 <franci.vi@tiscali.it>
Date: Wed, 3 Sep 2025 08:32:33 +0200
Subject: [PATCH 0434/1889] fixes auto-run js checks in tidy

---
 src/tools/tidy/src/extra_checks/mod.rs | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/tools/tidy/src/extra_checks/mod.rs b/src/tools/tidy/src/extra_checks/mod.rs
index 31169ec596775..0d4cee8d5dba8 100644
--- a/src/tools/tidy/src/extra_checks/mod.rs
+++ b/src/tools/tidy/src/extra_checks/mod.rs
@@ -720,21 +720,21 @@ impl ExtraCheckArg {
         if !self.auto {
             return true;
         }
-        let ext = match self.lang {
-            ExtraCheckLang::Py => ".py",
-            ExtraCheckLang::Cpp => ".cpp",
-            ExtraCheckLang::Shell => ".sh",
-            ExtraCheckLang::Js => ".js",
+        match self.lang {
             ExtraCheckLang::Spellcheck => {
-                for dir in SPELLCHECK_DIRS {
-                    if Path::new(filepath).starts_with(dir) {
-                        return true;
-                    }
-                }
-                return false;
+                SPELLCHECK_DIRS.iter().any(|dir| Path::new(filepath).starts_with(dir))
             }
-        };
-        filepath.ends_with(ext)
+            lang => {
+                let exts: &[&str] = match lang {
+                    ExtraCheckLang::Py => &[".py"],
+                    ExtraCheckLang::Cpp => &[".cpp"],
+                    ExtraCheckLang::Shell => &[".sh"],
+                    ExtraCheckLang::Js => &[".js", ".ts"],
+                    ExtraCheckLang::Spellcheck => unreachable!(),
+                };
+                exts.iter().any(|ext| filepath.ends_with(ext))
+            }
+        }
     }
 
     fn has_supported_kind(&self) -> bool {

From 485bdafdcfb340e74b7342d716b2135d4c6c8ca1 Mon Sep 17 00:00:00 2001
From: Flakebi <flakebi@t-online.de>
Date: Wed, 3 Sep 2025 08:29:52 +0200
Subject: [PATCH 0435/1889] Add test for addrspacecasting global vars

Global variables are casted to the default address space works,
as the amdgpu target is now merged, a test can be added.
---
 tests/auxiliary/minicore.rs                | 9 ++++++++-
 tests/codegen-llvm/amdgpu-addrspacecast.rs | 9 +++++++++
 2 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/tests/auxiliary/minicore.rs b/tests/auxiliary/minicore.rs
index da880100a10cd..4f4c653cb46e7 100644
--- a/tests/auxiliary/minicore.rs
+++ b/tests/auxiliary/minicore.rs
@@ -179,7 +179,14 @@ impl Add<isize> for isize {
 
 #[lang = "sync"]
 trait Sync {}
-impl Sync for u8 {}
+impl_marker_trait!(
+    Sync => [
+        char, bool,
+        isize, i8, i16, i32, i64, i128,
+        usize, u8, u16, u32, u64, u128,
+        f16, f32, f64, f128,
+    ]
+);
 
 #[lang = "drop_in_place"]
 fn drop_in_place<T>(_: *mut T) {}
diff --git a/tests/codegen-llvm/amdgpu-addrspacecast.rs b/tests/codegen-llvm/amdgpu-addrspacecast.rs
index 7fe630a7efa0e..829133de00d8b 100644
--- a/tests/codegen-llvm/amdgpu-addrspacecast.rs
+++ b/tests/codegen-llvm/amdgpu-addrspacecast.rs
@@ -16,3 +16,12 @@ pub fn ref_of_local(f: fn(&i32)) {
     let i = 0;
     f(&i);
 }
+
+// CHECK-LABEL: @ref_of_global
+// CHECK: addrspacecast (ptr addrspace(1) @I to ptr)
+#[no_mangle]
+pub fn ref_of_global(f: fn(&i32)) {
+    #[no_mangle]
+    static I: i32 = 0;
+    f(&I);
+}

From 15c6585e5c5352746302737c0a55de96d9514fd3 Mon Sep 17 00:00:00 2001
From: Flakebi <flakebi@t-online.de>
Date: Tue, 21 Jan 2025 23:21:29 +0100
Subject: [PATCH 0436/1889] Add amdgpu to gpu-kernel test

Check that the gpu-kernel calling convention translates to
`amdgpu_kernel` when compiling for the amdgpu target.
---
 tests/codegen-llvm/gpu-kernel-abi.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/tests/codegen-llvm/gpu-kernel-abi.rs b/tests/codegen-llvm/gpu-kernel-abi.rs
index 8ac376d93381b..d5a357ef65529 100644
--- a/tests/codegen-llvm/gpu-kernel-abi.rs
+++ b/tests/codegen-llvm/gpu-kernel-abi.rs
@@ -1,7 +1,9 @@
 // Checks that the gpu-kernel calling convention correctly translates to LLVM calling conventions.
 
 //@ add-core-stubs
-//@ revisions: nvptx
+//@ revisions: amdgpu nvptx
+//@ [amdgpu] compile-flags: --crate-type=rlib --target=amdgcn-amd-amdhsa -Ctarget-cpu=gfx900
+//@ [amdgpu] needs-llvm-components: amdgpu
 //@ [nvptx] compile-flags: --crate-type=rlib --target=nvptx64-nvidia-cuda
 //@ [nvptx] needs-llvm-components: nvptx
 #![feature(no_core, lang_items, abi_gpu_kernel)]
@@ -10,6 +12,7 @@
 extern crate minicore;
 use minicore::*;
 
+// amdgpu: define amdgpu_kernel void @fun(i32
 // nvptx: define ptx_kernel void @fun(i32
 #[no_mangle]
 pub extern "gpu-kernel" fn fun(_: i32) {}

From 9f0b2a2df41a517412f5e2d404cbabc73be665de Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 2 Sep 2025 17:17:19 +0200
Subject: [PATCH 0437/1889] fix mangitude of applied float error

---
 src/tools/miri/src/intrinsics/mod.rs          | 49 +++-----------
 src/tools/miri/src/machine.rs                 |  2 +-
 src/tools/miri/src/math.rs                    | 67 ++++++++++++-------
 src/tools/miri/tests/pass/float.rs            |  7 +-
 .../tests/pass/float_extra_rounding_error.rs  | 10 ++-
 .../tests/pass/shims/x86/rounding-error.rs    | 37 ++++++++++
 6 files changed, 103 insertions(+), 69 deletions(-)
 create mode 100644 src/tools/miri/tests/pass/shims/x86/rounding-error.rs

diff --git a/src/tools/miri/src/intrinsics/mod.rs b/src/tools/miri/src/intrinsics/mod.rs
index b5e81460773ba..5e46768b0e6cf 100644
--- a/src/tools/miri/src/intrinsics/mod.rs
+++ b/src/tools/miri/src/intrinsics/mod.rs
@@ -10,7 +10,7 @@ use rustc_abi::Size;
 use rustc_apfloat::ieee::{IeeeFloat, Semantics};
 use rustc_apfloat::{self, Float, Round};
 use rustc_middle::mir;
-use rustc_middle::ty::{self, FloatTy, ScalarInt};
+use rustc_middle::ty::{self, FloatTy};
 use rustc_span::{Symbol, sym};
 
 use self::atomic::EvalContextExt as _;
@@ -230,7 +230,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     let res = apply_random_float_error_ulp(
                         this,
                         res,
-                        2, // log2(4)
+                        4,
                     );
 
                     // Clamp the result to the guaranteed range of this function according to the C standard,
@@ -274,7 +274,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     let res = apply_random_float_error_ulp(
                         this,
                         res,
-                        2, // log2(4)
+                        4,
                     );
 
                     // Clamp the result to the guaranteed range of this function according to the C standard,
@@ -336,9 +336,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
                     // Apply a relative error of 4ULP to introduce some non-determinism
                     // simulating imprecise implementations and optimizations.
-                    apply_random_float_error_ulp(
-                        this, res, 2, // log2(4)
-                    )
+                    apply_random_float_error_ulp(this, res, 4)
                 });
                 let res = this.adjust_nan(res, &[f1, f2]);
                 this.write_scalar(res, dest)?;
@@ -354,9 +352,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
                     // Apply a relative error of 4ULP to introduce some non-determinism
                     // simulating imprecise implementations and optimizations.
-                    apply_random_float_error_ulp(
-                        this, res, 2, // log2(4)
-                    )
+                    apply_random_float_error_ulp(this, res, 4)
                 });
                 let res = this.adjust_nan(res, &[f1, f2]);
                 this.write_scalar(res, dest)?;
@@ -373,9 +369,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
                     // Apply a relative error of 4ULP to introduce some non-determinism
                     // simulating imprecise implementations and optimizations.
-                    apply_random_float_error_ulp(
-                        this, res, 2, // log2(4)
-                    )
+                    apply_random_float_error_ulp(this, res, 4)
                 });
                 let res = this.adjust_nan(res, &[f]);
                 this.write_scalar(res, dest)?;
@@ -391,9 +385,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
                     // Apply a relative error of 4ULP to introduce some non-determinism
                     // simulating imprecise implementations and optimizations.
-                    apply_random_float_error_ulp(
-                        this, res, 2, // log2(4)
-                    )
+                    apply_random_float_error_ulp(this, res, 4)
                 });
                 let res = this.adjust_nan(res, &[f]);
                 this.write_scalar(res, dest)?;
@@ -448,7 +440,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 }
                 // Apply a relative error of 4ULP to simulate non-deterministic precision loss
                 // due to optimizations.
-                let res = apply_random_float_error_to_imm(this, res, 2 /* log2(4) */)?;
+                let res = crate::math::apply_random_float_error_to_imm(this, res, 4)?;
                 this.write_immediate(*res, dest)?;
             }
 
@@ -486,31 +478,6 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     }
 }
 
-/// Applies a random ULP floating point error to `val` and returns the new value.
-/// So if you want an X ULP error, `ulp_exponent` should be log2(X).
-///
-/// Will fail if `val` is not a floating point number.
-fn apply_random_float_error_to_imm<'tcx>(
-    ecx: &mut MiriInterpCx<'tcx>,
-    val: ImmTy<'tcx>,
-    ulp_exponent: u32,
-) -> InterpResult<'tcx, ImmTy<'tcx>> {
-    let scalar = val.to_scalar_int()?;
-    let res: ScalarInt = match val.layout.ty.kind() {
-        ty::Float(FloatTy::F16) =>
-            apply_random_float_error_ulp(ecx, scalar.to_f16(), ulp_exponent).into(),
-        ty::Float(FloatTy::F32) =>
-            apply_random_float_error_ulp(ecx, scalar.to_f32(), ulp_exponent).into(),
-        ty::Float(FloatTy::F64) =>
-            apply_random_float_error_ulp(ecx, scalar.to_f64(), ulp_exponent).into(),
-        ty::Float(FloatTy::F128) =>
-            apply_random_float_error_ulp(ecx, scalar.to_f128(), ulp_exponent).into(),
-        _ => bug!("intrinsic called with non-float input type"),
-    };
-
-    interp_ok(ImmTy::from_scalar_int(res, val.layout))
-}
-
 /// For the intrinsics:
 /// - sinf32, sinf64
 /// - cosf32, cosf64
diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index 7802a58f11236..e0ee95419485b 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -1278,7 +1278,7 @@ impl<'tcx> Machine<'tcx> for MiriMachine<'tcx> {
         ecx: &mut InterpCx<'tcx, Self>,
         val: ImmTy<'tcx>,
     ) -> InterpResult<'tcx, ImmTy<'tcx>> {
-        crate::math::apply_random_float_error_to_imm(ecx, val, 2 /* log2(4) */)
+        crate::math::apply_random_float_error_to_imm(ecx, val, 4)
     }
 
     #[inline(always)]
diff --git a/src/tools/miri/src/math.rs b/src/tools/miri/src/math.rs
index dd994b03f5d17..604d6c0fd732b 100644
--- a/src/tools/miri/src/math.rs
+++ b/src/tools/miri/src/math.rs
@@ -6,10 +6,6 @@ use rustc_middle::ty::{self, FloatTy, ScalarInt};
 use crate::*;
 
 /// Disturbes a floating-point result by a relative error in the range (-2^scale, 2^scale).
-///
-/// For a 2^N ULP error, you can use an `err_scale` of `-(F::PRECISION - 1 - N)`.
-/// In other words, a 1 ULP (absolute) error is the same as a `2^-(F::PRECISION-1)` relative error.
-/// (Subtracting 1 compensates for the integer bit.)
 pub(crate) fn apply_random_float_error<F: rustc_apfloat::Float>(
     ecx: &mut crate::MiriInterpCx<'_>,
     val: F,
@@ -17,11 +13,13 @@ pub(crate) fn apply_random_float_error<F: rustc_apfloat::Float>(
 ) -> F {
     if !ecx.machine.float_nondet
         || matches!(ecx.machine.float_rounding_error, FloatRoundingErrorMode::None)
+        // relative errors don't do anything to zeros... avoid messing up the sign
+        || val.is_zero()
     {
         return val;
     }
-
     let rng = ecx.machine.rng.get_mut();
+
     // Generate a random integer in the range [0, 2^PREC).
     // (When read as binary, the position of the first `1` determines the exponent,
     // and the remaining bits fill the mantissa. `PREC` is one plus the size of the mantissa,
@@ -37,43 +35,66 @@ pub(crate) fn apply_random_float_error<F: rustc_apfloat::Float>(
     let err = r.scalbn(err_scale.strict_sub(F::PRECISION.try_into().unwrap()));
     // give it a random sign
     let err = if rng.random() { -err } else { err };
-    // multiple the value with (1+err)
-    (val * (F::from_u128(1).value + err).value).value
+    // Compute `val*(1+err)`, distributed out as `val + val*err` to avoid the imprecise addition
+    // error being amplified by multiplication.
+    (val + (val * err).value).value
 }
 
-/// [`apply_random_float_error`] gives instructions to apply a 2^N ULP error.
-/// This function implements these instructions such that applying a 2^N ULP error is less error prone.
-/// So for a 2^N ULP error, you would pass N as the `ulp_exponent` argument.
+/// Applies an error of `[-N, +N]` ULP to the given value.
 pub(crate) fn apply_random_float_error_ulp<F: rustc_apfloat::Float>(
     ecx: &mut crate::MiriInterpCx<'_>,
     val: F,
-    ulp_exponent: u32,
+    max_error: u32,
 ) -> F {
-    let n = i32::try_from(ulp_exponent)
-        .expect("`err_scale_for_ulp`: exponent is too large to create an error scale");
-    // we know this fits
-    let prec = i32::try_from(F::PRECISION).unwrap();
-    let err_scale = -(prec - n - 1);
-    apply_random_float_error(ecx, val, err_scale)
+    // We could try to be clever and reuse `apply_random_float_error`, but that is hard to get right
+    // (see <https://github.com/rust-lang/miri/pull/4558#discussion_r2316838085> for why) so we
+    // implement the logic directly instead.
+    if !ecx.machine.float_nondet
+        || matches!(ecx.machine.float_rounding_error, FloatRoundingErrorMode::None)
+        // FIXME: also disturb zeros? That requires a lot more cases in `fixed_float_value`
+        // and might make the std test suite quite unhappy.
+        || val.is_zero()
+    {
+        return val;
+    }
+    let rng = ecx.machine.rng.get_mut();
+
+    let max_error = i64::from(max_error);
+    let error = match ecx.machine.float_rounding_error {
+        FloatRoundingErrorMode::Random => rng.random_range(-max_error..=max_error),
+        FloatRoundingErrorMode::Max =>
+            if rng.random() {
+                max_error
+            } else {
+                -max_error
+            },
+        FloatRoundingErrorMode::None => unreachable!(),
+    };
+    // If upwards ULP and downwards ULP differ, we take the average.
+    let ulp = (((val.next_up().value - val).value + (val - val.next_down().value).value).value
+        / F::from_u128(2).value)
+        .value;
+    // Shift the value by N times the ULP
+    (val + (ulp * F::from_i128(error.into()).value).value).value
 }
 
-/// Applies a random 16ULP floating point error to `val` and returns the new value.
+/// Applies an error of `[-N, +N]` ULP to the given value.
 /// Will fail if `val` is not a floating point number.
 pub(crate) fn apply_random_float_error_to_imm<'tcx>(
     ecx: &mut MiriInterpCx<'tcx>,
     val: ImmTy<'tcx>,
-    ulp_exponent: u32,
+    max_error: u32,
 ) -> InterpResult<'tcx, ImmTy<'tcx>> {
     let scalar = val.to_scalar_int()?;
     let res: ScalarInt = match val.layout.ty.kind() {
         ty::Float(FloatTy::F16) =>
-            apply_random_float_error_ulp(ecx, scalar.to_f16(), ulp_exponent).into(),
+            apply_random_float_error_ulp(ecx, scalar.to_f16(), max_error).into(),
         ty::Float(FloatTy::F32) =>
-            apply_random_float_error_ulp(ecx, scalar.to_f32(), ulp_exponent).into(),
+            apply_random_float_error_ulp(ecx, scalar.to_f32(), max_error).into(),
         ty::Float(FloatTy::F64) =>
-            apply_random_float_error_ulp(ecx, scalar.to_f64(), ulp_exponent).into(),
+            apply_random_float_error_ulp(ecx, scalar.to_f64(), max_error).into(),
         ty::Float(FloatTy::F128) =>
-            apply_random_float_error_ulp(ecx, scalar.to_f128(), ulp_exponent).into(),
+            apply_random_float_error_ulp(ecx, scalar.to_f128(), max_error).into(),
         _ => bug!("intrinsic called with non-float input type"),
     };
 
diff --git a/src/tools/miri/tests/pass/float.rs b/src/tools/miri/tests/pass/float.rs
index fe7316c6680df..2be262d76a46e 100644
--- a/src/tools/miri/tests/pass/float.rs
+++ b/src/tools/miri/tests/pass/float.rs
@@ -39,9 +39,8 @@ macro_rules! assert_approx_eq {
     }};
 
     ($a:expr, $b: expr) => {
-        // accept up to 12ULP (4ULP for host floats and 4ULP for miri artificial error and 4 for any additional effects
-        // due to having multiple error sources.
-        assert_approx_eq!($a, $b, 12);
+        // accept up to 8ULP (4ULP for host floats and 4ULP for miri artificial error).
+        assert_approx_eq!($a, $b, 8);
     };
 }
 
@@ -176,6 +175,7 @@ fn assert_eq_msg<T: PartialEq + Debug>(x: T, y: T, msg: impl Display) {
 }
 
 /// Check that floats have bitwise equality
+#[track_caller]
 fn assert_biteq<F: Float>(a: F, b: F, msg: impl Display) {
     let ab = a.to_bits();
     let bb = b.to_bits();
@@ -189,6 +189,7 @@ fn assert_biteq<F: Float>(a: F, b: F, msg: impl Display) {
 }
 
 /// Check that two floats have equality
+#[track_caller]
 fn assert_feq<F: Float>(a: F, b: F, msg: impl Display) {
     let ab = a.to_bits();
     let bb = b.to_bits();
diff --git a/src/tools/miri/tests/pass/float_extra_rounding_error.rs b/src/tools/miri/tests/pass/float_extra_rounding_error.rs
index 73512399f82c4..24d7cf2cceee2 100644
--- a/src/tools/miri/tests/pass/float_extra_rounding_error.rs
+++ b/src/tools/miri/tests/pass/float_extra_rounding_error.rs
@@ -9,7 +9,7 @@ use std::hint::black_box;
 
 fn main() {
     let expected = cfg_select! {
-        random => 13, // FIXME: why is it 13?
+        random => 9, // -4 ..= +4 ULP error
         max => 2,
         none => 1,
     };
@@ -20,4 +20,12 @@ fn main() {
         values.insert(val.to_bits());
     }
     assert_eq!(values.len(), expected);
+
+    if !cfg!(none) {
+        // Ensure the smallest and biggest value are 8 ULP apart.
+        // We can just subtract the raw bit representations for this.
+        let min = *values.iter().min().unwrap();
+        let max = *values.iter().max().unwrap();
+        assert_eq!(min.abs_diff(max), 8);
+    }
 }
diff --git a/src/tools/miri/tests/pass/shims/x86/rounding-error.rs b/src/tools/miri/tests/pass/shims/x86/rounding-error.rs
new file mode 100644
index 0000000000000..bf56111b2e496
--- /dev/null
+++ b/src/tools/miri/tests/pass/shims/x86/rounding-error.rs
@@ -0,0 +1,37 @@
+// We're testing x86 target specific features
+//@only-target: x86_64 i686
+
+//! rsqrt and rcp SSE/AVX operations are approximate. We use that as license to treat them as
+//! non-deterministic. Ensure that we do indeed see random results within the expected error bounds.
+
+#[cfg(target_arch = "x86")]
+use std::arch::x86::*;
+#[cfg(target_arch = "x86_64")]
+use std::arch::x86_64::*;
+use std::collections::HashSet;
+
+fn main() {
+    let mut vals = HashSet::new();
+    for _ in 0..50 {
+        unsafe {
+            // Compute the inverse square root of 4.0, four times.
+            let a = _mm_setr_ps(4.0, 4.0, 4.0, 4.0);
+            let exact = 0.5;
+            let r = _mm_rsqrt_ps(a);
+            let r: [f32; 4] = std::mem::transmute(r);
+            // Check the results.
+            for r in r {
+                vals.insert(r.to_bits());
+                // Ensure the relative error is less than 2^-12.
+                let rel_error = (r - exact) / exact;
+                let log_error = rel_error.abs().log2();
+                assert!(
+                    rel_error == 0.0 || log_error < -12.0,
+                    "got an error of {rel_error} = 2^{log_error}"
+                );
+            }
+        }
+    }
+    // Ensure we saw a bunch of different results.
+    assert!(vals.len() >= 50);
+}

From c5dd32e483593ab9751cfac50b907e4ce06f1249 Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Tue, 2 Sep 2025 19:00:39 -0400
Subject: [PATCH 0438/1889] fix(rustdoc): match rustc `--emit` precedence

Change rustdoc's `--emit` to allow only one instance of each type,
regardless of the actual data that `--emit` carries.
This matches rustc's `--emit` behavior.

As of the writing, only `dep-info` emit type carries extra data.

See <https://github.com/rust-lang/rust/issues/141664>
---
 src/librustdoc/config.rs                 | 11 +++++++++--
 tests/run-make/rustdoc-dep-info/rmake.rs |  5 ++---
 2 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs
index 450ac04b40d91..1220a05e45853 100644
--- a/src/librustdoc/config.rs
+++ b/src/librustdoc/config.rs
@@ -454,15 +454,22 @@ impl Options {
             return None;
         }
 
-        let mut emit = Vec::new();
+        let mut emit = FxIndexMap::<_, EmitType>::default();
         for list in matches.opt_strs("emit") {
             for kind in list.split(',') {
                 match kind.parse() {
-                    Ok(kind) => emit.push(kind),
+                    Ok(kind) => {
+                        // De-duplicate emit types and the last wins.
+                        // Only one instance for each type is allowed
+                        // regardless the actual data it carries.
+                        // This matches rustc's `--emit` behavior.
+                        emit.insert(std::mem::discriminant(&kind), kind);
+                    }
                     Err(()) => dcx.fatal(format!("unrecognized emission type: {kind}")),
                 }
             }
         }
+        let emit = emit.into_values().collect::<Vec<_>>();
 
         let show_coverage = matches.opt_present("show-coverage");
         let output_format_s = matches.opt_str("output-format");
diff --git a/tests/run-make/rustdoc-dep-info/rmake.rs b/tests/run-make/rustdoc-dep-info/rmake.rs
index 956809909d92f..166e8d5702fc3 100644
--- a/tests/run-make/rustdoc-dep-info/rmake.rs
+++ b/tests/run-make/rustdoc-dep-info/rmake.rs
@@ -35,7 +35,6 @@ fn main() {
     assert!(path("bla.d").exists());
 
     // The last emit-type wins. The same behavior as rustc.
-    // TODO: this shows the wrong behavior as a MRE, which will be fixed in the next commit
     rustdoc()
         .input("lib.rs")
         .arg("-Zunstable-options")
@@ -43,7 +42,7 @@ fn main() {
         .emit("dep-info=precedence2.d")
         .emit("dep-info=precedence3.d")
         .run();
-    assert!(path("precedence1.d").exists());
+    assert!(!path("precedence1.d").exists());
     assert!(!path("precedence2.d").exists());
-    assert!(!path("precedence3.d").exists());
+    assert!(path("precedence3.d").exists());
 }

From df5896a8821e5ef0531a986beb346bb0930ce611 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Tue, 2 Sep 2025 18:00:29 +0200
Subject: [PATCH 0439/1889] Rename `ToolRustc` to `ToolRustcPrivate`

---
 src/bootstrap/src/core/build_steps/check.rs   | 19 ++++++++-------
 src/bootstrap/src/core/build_steps/clippy.rs  | 21 ++++++++++-------
 src/bootstrap/src/core/build_steps/doc.rs     |  2 +-
 src/bootstrap/src/core/build_steps/run.rs     |  4 ++--
 src/bootstrap/src/core/build_steps/test.rs    | 17 +++++++-------
 src/bootstrap/src/core/build_steps/tool.rs    | 18 +++++++--------
 src/bootstrap/src/core/builder/cargo.rs       | 23 ++++++++++---------
 src/bootstrap/src/lib.rs                      | 23 ++++++++++---------
 .../writing-tools-in-bootstrap.md             |  7 ++----
 9 files changed, 71 insertions(+), 63 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/check.rs b/src/bootstrap/src/core/build_steps/check.rs
index a604e7c058593..49d12b64da510 100644
--- a/src/bootstrap/src/core/build_steps/check.rs
+++ b/src/bootstrap/src/core/build_steps/check.rs
@@ -389,7 +389,7 @@ impl Step for Rustc {
 
 /// Represents a compiler that can check something.
 ///
-/// If the compiler was created for `Mode::ToolRustc` or `Mode::Codegen`, it will also contain
+/// If the compiler was created for `Mode::ToolRustcPrivate` or `Mode::Codegen`, it will also contain
 /// .rmeta artifacts from rustc that was already checked using `build_compiler`.
 ///
 /// All steps that use this struct in a "general way" (i.e. they don't know exactly what kind of
@@ -469,7 +469,7 @@ pub fn prepare_compiler_for_check(
                 build_compiler
             }
         }
-        Mode::ToolRustc | Mode::Codegen => {
+        Mode::ToolRustcPrivate | Mode::Codegen => {
             // Check Rustc to produce the required rmeta artifacts for rustc_private, and then
             // return the build compiler that was used to check rustc.
             // We do not need to check examples/tests/etc. of Rustc for rustc_private, so we pass
@@ -767,19 +767,22 @@ fn run_tool_check_step(
 tool_check_step!(Rustdoc {
     path: "src/tools/rustdoc",
     alt_path: "src/librustdoc",
-    mode: |_builder| Mode::ToolRustc
+    mode: |_builder| Mode::ToolRustcPrivate
 });
 // Clippy, miri and Rustfmt are hybrids. They are external tools, but use a git subtree instead
 // of a submodule. Since the SourceType only drives the deny-warnings
 // behavior, treat it as in-tree so that any new warnings in clippy will be
 // rejected.
-tool_check_step!(Clippy { path: "src/tools/clippy", mode: |_builder| Mode::ToolRustc });
-tool_check_step!(Miri { path: "src/tools/miri", mode: |_builder| Mode::ToolRustc });
-tool_check_step!(CargoMiri { path: "src/tools/miri/cargo-miri", mode: |_builder| Mode::ToolRustc });
-tool_check_step!(Rustfmt { path: "src/tools/rustfmt", mode: |_builder| Mode::ToolRustc });
+tool_check_step!(Clippy { path: "src/tools/clippy", mode: |_builder| Mode::ToolRustcPrivate });
+tool_check_step!(Miri { path: "src/tools/miri", mode: |_builder| Mode::ToolRustcPrivate });
+tool_check_step!(CargoMiri {
+    path: "src/tools/miri/cargo-miri",
+    mode: |_builder| Mode::ToolRustcPrivate
+});
+tool_check_step!(Rustfmt { path: "src/tools/rustfmt", mode: |_builder| Mode::ToolRustcPrivate });
 tool_check_step!(RustAnalyzer {
     path: "src/tools/rust-analyzer",
-    mode: |_builder| Mode::ToolRustc,
+    mode: |_builder| Mode::ToolRustcPrivate,
     allow_features: tool::RustAnalyzer::ALLOW_FEATURES,
     enable_features: ["in-rust-tree"],
 });
diff --git a/src/bootstrap/src/core/build_steps/clippy.rs b/src/bootstrap/src/core/build_steps/clippy.rs
index 05f8b240291ea..2083c675e1fdd 100644
--- a/src/bootstrap/src/core/build_steps/clippy.rs
+++ b/src/bootstrap/src/core/build_steps/clippy.rs
@@ -366,8 +366,13 @@ impl Step for CodegenGcc {
         );
         self.build_compiler.configure_cargo(&mut cargo);
 
-        let _guard =
-            builder.msg(Kind::Clippy, "rustc_codegen_gcc", Mode::ToolRustc, build_compiler, target);
+        let _guard = builder.msg(
+            Kind::Clippy,
+            "rustc_codegen_gcc",
+            Mode::ToolRustcPrivate,
+            build_compiler,
+            target,
+        );
 
         let stamp = BuildStamp::new(&builder.cargo_out(build_compiler, Mode::Codegen, target))
             .with_prefix("rustc_codegen_gcc-check");
@@ -478,8 +483,8 @@ lint_any!(
     Bootstrap, "src/bootstrap", "bootstrap", Mode::ToolTarget;
     BuildHelper, "src/build_helper", "build_helper", Mode::ToolTarget;
     BuildManifest, "src/tools/build-manifest", "build-manifest", Mode::ToolTarget;
-    CargoMiri, "src/tools/miri/cargo-miri", "cargo-miri", Mode::ToolRustc;
-    Clippy, "src/tools/clippy", "clippy", Mode::ToolRustc;
+    CargoMiri, "src/tools/miri/cargo-miri", "cargo-miri", Mode::ToolRustcPrivate;
+    Clippy, "src/tools/clippy", "clippy", Mode::ToolRustcPrivate;
     CollectLicenseMetadata, "src/tools/collect-license-metadata", "collect-license-metadata", Mode::ToolTarget;
     Compiletest, "src/tools/compiletest", "compiletest", Mode::ToolTarget;
     CoverageDump, "src/tools/coverage-dump", "coverage-dump", Mode::ToolTarget;
@@ -487,14 +492,14 @@ lint_any!(
     Jsondoclint, "src/tools/jsondoclint", "jsondoclint", Mode::ToolTarget;
     LintDocs, "src/tools/lint-docs", "lint-docs", Mode::ToolTarget;
     LlvmBitcodeLinker, "src/tools/llvm-bitcode-linker", "llvm-bitcode-linker", Mode::ToolTarget;
-    Miri, "src/tools/miri", "miri", Mode::ToolRustc;
+    Miri, "src/tools/miri", "miri", Mode::ToolRustcPrivate;
     MiroptTestTools, "src/tools/miropt-test-tools", "miropt-test-tools", Mode::ToolTarget;
     OptDist, "src/tools/opt-dist", "opt-dist", Mode::ToolTarget;
     RemoteTestClient, "src/tools/remote-test-client", "remote-test-client", Mode::ToolTarget;
     RemoteTestServer, "src/tools/remote-test-server", "remote-test-server", Mode::ToolTarget;
-    RustAnalyzer, "src/tools/rust-analyzer", "rust-analyzer", Mode::ToolRustc;
-    Rustdoc, "src/librustdoc", "clippy", Mode::ToolRustc;
-    Rustfmt, "src/tools/rustfmt", "rustfmt", Mode::ToolRustc;
+    RustAnalyzer, "src/tools/rust-analyzer", "rust-analyzer", Mode::ToolRustcPrivate;
+    Rustdoc, "src/librustdoc", "clippy", Mode::ToolRustcPrivate;
+    Rustfmt, "src/tools/rustfmt", "rustfmt", Mode::ToolRustcPrivate;
     RustInstaller, "src/tools/rust-installer", "rust-installer", Mode::ToolTarget;
     Tidy, "src/tools/tidy", "tidy", Mode::ToolTarget;
     TestFloatParse, "src/tools/test-float-parse", "test-float-parse", Mode::ToolStd;
diff --git a/src/bootstrap/src/core/build_steps/doc.rs b/src/bootstrap/src/core/build_steps/doc.rs
index 0789eefa89460..eb198a0051abe 100644
--- a/src/bootstrap/src/core/build_steps/doc.rs
+++ b/src/bootstrap/src/core/build_steps/doc.rs
@@ -995,7 +995,7 @@ macro_rules! tool_doc {
                     // Build rustc docs so that we generate relative links.
                     run.builder.ensure(Rustc::from_build_compiler(run.builder, compilers.build_compiler(), target));
 
-                    (compilers.build_compiler(), Mode::ToolRustc)
+                    (compilers.build_compiler(), Mode::ToolRustcPrivate)
                 } else {
                     // bootstrap/host tools have to be documented with the stage 0 compiler
                     (prepare_doc_compiler(run.builder, run.builder.host_target, 1), Mode::ToolBootstrap)
diff --git a/src/bootstrap/src/core/build_steps/run.rs b/src/bootstrap/src/core/build_steps/run.rs
index d9de6b7ef96bf..9f7248b80f763 100644
--- a/src/bootstrap/src/core/build_steps/run.rs
+++ b/src/bootstrap/src/core/build_steps/run.rs
@@ -161,7 +161,7 @@ impl Step for Miri {
         let mut miri = tool::prepare_tool_cargo(
             builder,
             compilers.build_compiler(),
-            Mode::ToolRustc,
+            Mode::ToolRustcPrivate,
             host,
             Kind::Run,
             "src/tools/miri",
@@ -487,7 +487,7 @@ impl Step for Rustfmt {
         let mut rustfmt = tool::prepare_tool_cargo(
             builder,
             rustfmt_build.build_compiler,
-            Mode::ToolRustc,
+            Mode::ToolRustcPrivate,
             host,
             Kind::Run,
             "src/tools/rustfmt",
diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index ee2cbe9385e48..22800aaa46564 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -455,7 +455,7 @@ impl Step for RustAnalyzer {
         let mut cargo = tool::prepare_tool_cargo(
             builder,
             self.compilers.build_compiler(),
-            Mode::ToolRustc,
+            Mode::ToolRustcPrivate,
             host,
             Kind::Test,
             crate_path,
@@ -518,7 +518,7 @@ impl Step for Rustfmt {
         let mut cargo = tool::prepare_tool_cargo(
             builder,
             build_compiler,
-            Mode::ToolRustc,
+            Mode::ToolRustcPrivate,
             target,
             Kind::Test,
             "src/tools/rustfmt",
@@ -571,7 +571,8 @@ impl Miri {
         cargo.env("MIRI_SYSROOT", &miri_sysroot);
 
         let mut cargo = BootstrapCommand::from(cargo);
-        let _guard = builder.msg(Kind::Build, "miri sysroot", Mode::ToolRustc, compiler, target);
+        let _guard =
+            builder.msg(Kind::Build, "miri sysroot", Mode::ToolRustcPrivate, compiler, target);
         cargo.run(builder);
 
         // # Determine where Miri put its sysroot.
@@ -648,7 +649,7 @@ impl Step for Miri {
         let mut cargo = tool::prepare_tool_cargo(
             builder,
             miri.build_compiler,
-            Mode::ToolRustc,
+            Mode::ToolRustcPrivate,
             host,
             Kind::Test,
             "src/tools/miri",
@@ -861,7 +862,7 @@ impl Step for Clippy {
         let mut cargo = tool::prepare_tool_cargo(
             builder,
             build_compiler,
-            Mode::ToolRustc,
+            Mode::ToolRustcPrivate,
             target,
             Kind::Test,
             "src/tools/clippy",
@@ -872,7 +873,7 @@ impl Step for Clippy {
         cargo.env("RUSTC_TEST_SUITE", builder.rustc(build_compiler));
         cargo.env("RUSTC_LIB_PATH", builder.rustc_libdir(build_compiler));
         let host_libs =
-            builder.stage_out(build_compiler, Mode::ToolRustc).join(builder.cargo_dir());
+            builder.stage_out(build_compiler, Mode::ToolRustcPrivate).join(builder.cargo_dir());
         cargo.env("HOST_LIBS", host_libs);
 
         // Build the standard library that the tests can use.
@@ -2411,7 +2412,7 @@ impl BookTest {
         let libs = if !self.dependencies.is_empty() {
             let mut lib_paths = vec![];
             for dep in self.dependencies {
-                let mode = Mode::ToolRustc;
+                let mode = Mode::ToolRustcPrivate;
                 let target = builder.config.host_target;
                 let cargo = tool::prepare_tool_cargo(
                     builder,
@@ -2996,7 +2997,7 @@ impl Step for CrateRustdoc {
         let mut cargo = tool::prepare_tool_cargo(
             builder,
             compiler,
-            Mode::ToolRustc,
+            Mode::ToolRustcPrivate,
             target,
             builder.kind,
             "src/tools/rustdoc",
diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
index 65c4c49908653..c5308034fe307 100644
--- a/src/bootstrap/src/core/build_steps/tool.rs
+++ b/src/bootstrap/src/core/build_steps/tool.rs
@@ -82,7 +82,7 @@ impl Step for ToolBuild {
         let path = self.path;
 
         match self.mode {
-            Mode::ToolRustc => {
+            Mode::ToolRustcPrivate => {
                 // FIXME: remove this, it's only needed for download-rustc...
                 if !self.build_compiler.is_forced_compiler() && builder.download_rustc() {
                     builder.std(self.build_compiler, self.build_compiler.host);
@@ -123,7 +123,7 @@ impl Step for ToolBuild {
 
         // Rustc tools (miri, clippy, cargo, rustfmt, rust-analyzer)
         // could use the additional optimizations.
-        if self.mode == Mode::ToolRustc && is_lto_stage(&self.build_compiler) {
+        if self.mode == Mode::ToolRustcPrivate && is_lto_stage(&self.build_compiler) {
             let lto = match builder.config.rust_lto {
                 RustcLto::Off => Some("off"),
                 RustcLto::Thin => Some("thin"),
@@ -607,7 +607,7 @@ impl Step for ErrorIndex {
             build_compiler: self.compilers.build_compiler,
             target: self.compilers.target(),
             tool: "error_index_generator",
-            mode: Mode::ToolRustc,
+            mode: Mode::ToolRustcPrivate,
             path: "src/tools/error_index_generator",
             source_type: SourceType::InTree,
             extra_features: Vec::new(),
@@ -671,7 +671,7 @@ impl Step for RemoteTestServer {
 /// Represents `Rustdoc` that either comes from the external stage0 sysroot or that is built
 /// locally.
 /// Rustdoc is special, because it both essentially corresponds to a `Compiler` (that can be
-/// externally provided), but also to a `ToolRustc` tool.
+/// externally provided), but also to a `ToolRustcPrivate` tool.
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub struct Rustdoc {
     /// If the stage of `target_compiler` is `0`, then rustdoc is externally provided.
@@ -759,7 +759,7 @@ impl Step for Rustdoc {
                 // the wrong rustdoc being executed. To avoid the conflicting rustdocs, we name the "tool"
                 // rustdoc a different name.
                 tool: "rustdoc_tool_binary",
-                mode: Mode::ToolRustc,
+                mode: Mode::ToolRustcPrivate,
                 path: "src/tools/rustdoc",
                 source_type: SourceType::InTree,
                 extra_features,
@@ -1048,7 +1048,7 @@ impl Step for RustAnalyzer {
             build_compiler,
             target,
             tool: "rust-analyzer",
-            mode: Mode::ToolRustc,
+            mode: Mode::ToolRustcPrivate,
             path: "src/tools/rust-analyzer",
             extra_features: vec!["in-rust-tree".to_owned()],
             source_type: SourceType::InTree,
@@ -1105,7 +1105,7 @@ impl Step for RustAnalyzerProcMacroSrv {
             build_compiler: self.compilers.build_compiler,
             target: self.compilers.target(),
             tool: "rust-analyzer-proc-macro-srv",
-            mode: Mode::ToolRustc,
+            mode: Mode::ToolRustcPrivate,
             path: "src/tools/rust-analyzer/crates/proc-macro-srv-cli",
             extra_features: vec!["in-rust-tree".to_owned()],
             source_type: SourceType::InTree,
@@ -1352,7 +1352,7 @@ impl RustcPrivateCompilers {
     }
 }
 
-/// Creates a step that builds an extended `Mode::ToolRustc` tool
+/// Creates a step that builds an extended `Mode::ToolRustcPrivate` tool
 /// and installs it into the sysroot of a corresponding compiler.
 macro_rules! tool_rustc_extended {
     (
@@ -1466,7 +1466,7 @@ fn build_extended_rustc_tool(
         build_compiler,
         target,
         tool: tool_name,
-        mode: Mode::ToolRustc,
+        mode: Mode::ToolRustcPrivate,
         path,
         extra_features,
         source_type: SourceType::InTree,
diff --git a/src/bootstrap/src/core/builder/cargo.rs b/src/bootstrap/src/core/builder/cargo.rs
index cdf6fe573e583..a9a74b9bb0731 100644
--- a/src/bootstrap/src/core/builder/cargo.rs
+++ b/src/bootstrap/src/core/builder/cargo.rs
@@ -533,7 +533,7 @@ impl Builder<'_> {
         if cmd_kind == Kind::Doc {
             let my_out = match mode {
                 // This is the intended out directory for compiler documentation.
-                Mode::Rustc | Mode::ToolRustc | Mode::ToolBootstrap => {
+                Mode::Rustc | Mode::ToolRustcPrivate | Mode::ToolBootstrap => {
                     self.compiler_doc_out(target)
                 }
                 Mode::Std => {
@@ -583,7 +583,7 @@ impl Builder<'_> {
 
         // We synthetically interpret a stage0 compiler used to build tools as a
         // "raw" compiler in that it's the exact snapshot we download. For things like
-        // ToolRustc, we would have to use the artificial stage0-sysroot compiler instead.
+        // ToolRustcPrivate, we would have to use the artificial stage0-sysroot compiler instead.
         let use_snapshot =
             mode == Mode::ToolBootstrap || (mode == Mode::ToolTarget && build_compiler_stage == 0);
         assert!(!use_snapshot || build_compiler_stage == 0 || self.local_rebuild);
@@ -643,7 +643,8 @@ impl Builder<'_> {
         // sysroot. Passing this cfg enables raw-dylib support instead, which makes the native
         // library unnecessary. This can be removed when windows-rs enables raw-dylib
         // unconditionally.
-        if let Mode::Rustc | Mode::ToolRustc | Mode::ToolBootstrap | Mode::ToolTarget = mode {
+        if let Mode::Rustc | Mode::ToolRustcPrivate | Mode::ToolBootstrap | Mode::ToolTarget = mode
+        {
             rustflags.arg("--cfg=windows_raw_dylib");
         }
 
@@ -657,7 +658,7 @@ impl Builder<'_> {
         // - rust-analyzer, due to the rowan crate
         // so we exclude an entire category of steps here due to lack of fine-grained control over
         // rustflags.
-        if self.config.rust_randomize_layout && mode != Mode::ToolRustc {
+        if self.config.rust_randomize_layout && mode != Mode::ToolRustcPrivate {
             rustflags.arg("-Zrandomize-layout");
         }
 
@@ -717,7 +718,7 @@ impl Builder<'_> {
 
         match mode {
             Mode::Std | Mode::ToolBootstrap | Mode::ToolStd | Mode::ToolTarget => {}
-            Mode::Rustc | Mode::Codegen | Mode::ToolRustc => {
+            Mode::Rustc | Mode::Codegen | Mode::ToolRustcPrivate => {
                 // Build proc macros both for the host and the target unless proc-macros are not
                 // supported by the target.
                 if target != compiler.host && cmd_kind != Kind::Check {
@@ -778,7 +779,7 @@ impl Builder<'_> {
                 "binary-dep-depinfo,proc_macro_span,proc_macro_span_shrink,proc_macro_diagnostic"
                     .to_string()
             }
-            Mode::Std | Mode::Rustc | Mode::Codegen | Mode::ToolRustc => String::new(),
+            Mode::Std | Mode::Rustc | Mode::Codegen | Mode::ToolRustcPrivate => String::new(),
         };
 
         cargo.arg("-j").arg(self.jobs().to_string());
@@ -825,7 +826,7 @@ impl Builder<'_> {
             // rustc step and one that we just built. This isn't always a
             // problem, somehow -- not really clear why -- but we know that this
             // fixes things.
-            Mode::ToolRustc => metadata.push_str("tool-rustc"),
+            Mode::ToolRustcPrivate => metadata.push_str("tool-rustc"),
             // Same for codegen backends.
             Mode::Codegen => metadata.push_str("codegen"),
             _ => {}
@@ -917,7 +918,7 @@ impl Builder<'_> {
         let debuginfo_level = match mode {
             Mode::Rustc | Mode::Codegen => self.config.rust_debuginfo_level_rustc,
             Mode::Std => self.config.rust_debuginfo_level_std,
-            Mode::ToolBootstrap | Mode::ToolStd | Mode::ToolRustc | Mode::ToolTarget => {
+            Mode::ToolBootstrap | Mode::ToolStd | Mode::ToolRustcPrivate | Mode::ToolTarget => {
                 self.config.rust_debuginfo_level_tools
             }
         };
@@ -930,7 +931,7 @@ impl Builder<'_> {
             match mode {
                 Mode::Std => self.config.std_debug_assertions,
                 Mode::Rustc | Mode::Codegen => self.config.rustc_debug_assertions,
-                Mode::ToolBootstrap | Mode::ToolStd | Mode::ToolRustc | Mode::ToolTarget => {
+                Mode::ToolBootstrap | Mode::ToolStd | Mode::ToolRustcPrivate | Mode::ToolTarget => {
                     self.config.tools_debug_assertions
                 }
             }
@@ -1005,7 +1006,7 @@ impl Builder<'_> {
             }
             Mode::Std
             | Mode::ToolBootstrap
-            | Mode::ToolRustc
+            | Mode::ToolRustcPrivate
             | Mode::ToolStd
             | Mode::ToolTarget => {
                 if let Some(ref map_to) =
@@ -1078,7 +1079,7 @@ impl Builder<'_> {
         // requirement, but the `-L` library path is not propagated across
         // separate Cargo projects. We can add LLVM's library path to the
         // rustc args as a workaround.
-        if (mode == Mode::ToolRustc || mode == Mode::Codegen)
+        if (mode == Mode::ToolRustcPrivate || mode == Mode::Codegen)
             && let Some(llvm_config) = self.llvm_config(target)
         {
             let llvm_libdir =
diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs
index 59c0f9faacac9..a2aeed20948e5 100644
--- a/src/bootstrap/src/lib.rs
+++ b/src/bootstrap/src/lib.rs
@@ -85,12 +85,12 @@ const LLD_FILE_NAMES: &[&str] = &["ld.lld", "ld64.lld", "lld-link", "wasm-ld"];
 const EXTRA_CHECK_CFGS: &[(Option<Mode>, &str, Option<&[&'static str]>)] = &[
     (Some(Mode::Rustc), "bootstrap", None),
     (Some(Mode::Codegen), "bootstrap", None),
-    (Some(Mode::ToolRustc), "bootstrap", None),
+    (Some(Mode::ToolRustcPrivate), "bootstrap", None),
     (Some(Mode::ToolStd), "bootstrap", None),
     (Some(Mode::Rustc), "llvm_enzyme", None),
     (Some(Mode::Codegen), "llvm_enzyme", None),
-    (Some(Mode::ToolRustc), "llvm_enzyme", None),
-    (Some(Mode::ToolRustc), "rust_analyzer", None),
+    (Some(Mode::ToolRustcPrivate), "llvm_enzyme", None),
+    (Some(Mode::ToolRustcPrivate), "rust_analyzer", None),
     (Some(Mode::ToolStd), "rust_analyzer", None),
     // Any library specific cfgs like `target_os`, `target_arch` should be put in
     // priority the `[lints.rust.unexpected_cfgs.check-cfg]` table
@@ -334,17 +334,18 @@ pub enum Mode {
     /// compiletest which needs libtest.
     ToolStd,
 
-    /// Build a tool which uses the locally built rustc and the target std,
+    /// Build a tool which uses the `rustc_private` mechanism, and thus
+    /// the locally built rustc rlib artifacts,
     /// placing the output in the "stageN-tools" directory. This is used for
-    /// anything that needs a fully functional rustc, such as rustdoc, clippy,
-    /// cargo, rustfmt, miri, etc.
-    ToolRustc,
+    /// everything that links to rustc as a library, such as rustdoc, clippy,
+    /// rustfmt, miri, etc.
+    ToolRustcPrivate,
 }
 
 impl Mode {
     pub fn is_tool(&self) -> bool {
         match self {
-            Mode::ToolBootstrap | Mode::ToolRustc | Mode::ToolStd | Mode::ToolTarget => true,
+            Mode::ToolBootstrap | Mode::ToolRustcPrivate | Mode::ToolStd | Mode::ToolTarget => true,
             Mode::Std | Mode::Codegen | Mode::Rustc => false,
         }
     }
@@ -353,7 +354,7 @@ impl Mode {
         match self {
             Mode::Std | Mode::Codegen => true,
             Mode::ToolBootstrap
-            | Mode::ToolRustc
+            | Mode::ToolRustcPrivate
             | Mode::ToolStd
             | Mode::ToolTarget
             | Mode::Rustc => false,
@@ -924,7 +925,7 @@ impl Build {
             Mode::Rustc => (Some(build_compiler.stage + 1), "rustc"),
             Mode::Codegen => (Some(build_compiler.stage + 1), "codegen"),
             Mode::ToolBootstrap => bootstrap_tool(),
-            Mode::ToolStd | Mode::ToolRustc => (Some(build_compiler.stage + 1), "tools"),
+            Mode::ToolStd | Mode::ToolRustcPrivate => (Some(build_compiler.stage + 1), "tools"),
             Mode::ToolTarget => {
                 // If we're not cross-compiling (the common case), share the target directory with
                 // bootstrap tools to reuse the build cache.
@@ -1145,7 +1146,7 @@ impl Build {
                 | Mode::ToolBootstrap
                 | Mode::ToolTarget
                 | Mode::ToolStd
-                | Mode::ToolRustc,
+                | Mode::ToolRustcPrivate,
             )
             | None => target_and_stage.stage + 1,
         };
diff --git a/src/doc/rustc-dev-guide/src/building/bootstrapping/writing-tools-in-bootstrap.md b/src/doc/rustc-dev-guide/src/building/bootstrapping/writing-tools-in-bootstrap.md
index 41d0cf8d9fb3a..c3660e24b1526 100644
--- a/src/doc/rustc-dev-guide/src/building/bootstrapping/writing-tools-in-bootstrap.md
+++ b/src/doc/rustc-dev-guide/src/building/bootstrapping/writing-tools-in-bootstrap.md
@@ -11,11 +11,8 @@ There are three types of tools you can write in bootstrap:
   Use this for tools that rely on the locally built std. The output goes into the "stageN-tools" directory.
   This mode is rarely used, mainly for `compiletest` which requires `libtest`.
 
-- **`Mode::ToolRustc`**
-  Use this for tools that depend on both the locally built `rustc` and the target `std`. This is more complex than
-  the other modes because the tool must be built with the same compiler used for `rustc` and placed in the "stageN-tools"
-  directory. When you choose `Mode::ToolRustc`, `ToolBuild` implementation takes care of this automatically.
-  If you need to use the builder’s compiler for something specific, you can get it from `ToolBuildResult`, which is
+- **`Mode::ToolRustcPrivate`**
+  Use this for tools that use the `rustc_private` mechanism, and thus depend on the locally built `rustc` and its rlib artifacts. This is more complex than the other modes because the tool must be built with the same compiler used for `rustc` and placed in the "stageN-tools" directory. When you choose `Mode::ToolRustcPrivate`, `ToolBuild` implementation takes care of this automatically. If you need to use the builder’s compiler for something specific, you can get it from `ToolBuildResult`, which is
   returned by the tool's [`Step`].
 
 Regardless of the tool type you must return `ToolBuildResult` from the tool’s [`Step`] implementation and use `ToolBuild` inside it.

From 39d51d04e706dee462ac4a17508ed87eb52e7715 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 26 Aug 2025 18:12:36 +0200
Subject: [PATCH 0440/1889] thread parking: fix docs and examples

---
 library/std/src/sys/sync/once/queue.rs |  4 +-
 library/std/src/thread/mod.rs          | 67 ++++++++++++++++++++------
 library/std/src/thread/tests.rs        |  4 ++
 src/tools/miri/README.md               |  1 +
 4 files changed, 60 insertions(+), 16 deletions(-)

diff --git a/library/std/src/sys/sync/once/queue.rs b/library/std/src/sys/sync/once/queue.rs
index 49e15d65f25a2..17d99cdb38595 100644
--- a/library/std/src/sys/sync/once/queue.rs
+++ b/library/std/src/sys/sync/once/queue.rs
@@ -276,7 +276,9 @@ fn wait(
             // If the managing thread happens to signal and unpark us before we
             // can park ourselves, the result could be this thread never gets
             // unparked. Luckily `park` comes with the guarantee that if it got
-            // an `unpark` just before on an unparked thread it does not park.
+            // an `unpark` just before on an unparked thread it does not park. Crucially, we know
+            // the `unpark` must have happened between the `compare_exchange_weak` above and here,
+            // and there's no other `park` in that code that could steal our token.
             // SAFETY: we retrieved this handle on the current thread above.
             unsafe { node.thread.park() }
         }
diff --git a/library/std/src/thread/mod.rs b/library/std/src/thread/mod.rs
index b6059c28cec7d..2847f94f9fd5c 100644
--- a/library/std/src/thread/mod.rs
+++ b/library/std/src/thread/mod.rs
@@ -1021,13 +1021,23 @@ impl Drop for PanicGuard {
 ///   specifying a maximum time to block the thread for.
 ///
 /// * The [`unpark`] method on a [`Thread`] atomically makes the token available
-///   if it wasn't already. Because the token is initially absent, [`unpark`]
-///   followed by [`park`] will result in the second call returning immediately.
-///
-/// The API is typically used by acquiring a handle to the current thread,
-/// placing that handle in a shared data structure so that other threads can
-/// find it, and then `park`ing in a loop. When some desired condition is met, another
-/// thread calls [`unpark`] on the handle.
+///   if it wasn't already. Because the token can be held by a thread even if it is currently not
+///   parked, [`unpark`] followed by [`park`] will result in the second call returning immediately.
+///   However, note that to rely on this guarantee, you need to make sure that your `unpark` happens
+///   after all `park` that may be done by other data structures!
+///
+/// The API is typically used by acquiring a handle to the current thread, placing that handle in a
+/// shared data structure so that other threads can find it, and then `park`ing in a loop. When some
+/// desired condition is met, another thread calls [`unpark`] on the handle. The last bullet point
+/// above guarantees that even if the `unpark` occurs before the thread is finished `park`ing, it
+/// will be woken up properly.
+///
+/// Note that the coordination via the shared data structure is crucial: If you `unpark` a thread
+/// without first establishing that it is about to be `park`ing within your code, that `unpark` may
+/// get consumed by a *different* `park` in the same thread, leading to a deadlock. This also means
+/// you must not call unknown code between setting up for parking and calling `park`; for instance,
+/// if you invoke `println!`, that may itself call `park` and thus consume your `unpark` and cause a
+/// deadlock.
 ///
 /// The motivation for this design is twofold:
 ///
@@ -1058,21 +1068,24 @@ impl Drop for PanicGuard {
 ///
 /// ```
 /// use std::thread;
-/// use std::sync::{Arc, atomic::{Ordering, AtomicBool}};
+/// use std::sync::atomic::{Ordering, AtomicBool};
 /// use std::time::Duration;
 ///
-/// let flag = Arc::new(AtomicBool::new(false));
-/// let flag2 = Arc::clone(&flag);
+/// static QUEUED: AtomicBool = AtomicBool::new(false);
+/// static FLAG: AtomicBool = AtomicBool::new(false);
 ///
 /// let parked_thread = thread::spawn(move || {
+///     println!("Thread spawned");
+///     // Signal that we are going to `park`. Between this store and our `park`, there may
+///     // be no other `park`, or else that `park` could consume our `unpark` token!
+///     QUEUED.store(true, Ordering::Release);
 ///     // We want to wait until the flag is set. We *could* just spin, but using
 ///     // park/unpark is more efficient.
-///     while !flag2.load(Ordering::Relaxed) {
-///         println!("Parking thread");
+///     while !FLAG.load(Ordering::Acquire) {
+///         // We can *not* use `println!` here since that could use thread parking internally.
 ///         thread::park();
 ///         // We *could* get here spuriously, i.e., way before the 10ms below are over!
 ///         // But that is no problem, we are in a loop until the flag is set anyway.
-///         println!("Thread unparked");
 ///     }
 ///     println!("Flag received");
 /// });
@@ -1080,11 +1093,22 @@ impl Drop for PanicGuard {
 /// // Let some time pass for the thread to be spawned.
 /// thread::sleep(Duration::from_millis(10));
 ///
+/// // Ensure the thread is about to park.
+/// // This is crucial! It guarantees that the `unpark` below is not consumed
+/// // by some other code in the parked thread (e.g. inside `println!`).
+/// while !QUEUED.load(Ordering::Acquire) {
+///     // Spinning is of course inefficient; in practice, this would more likely be
+///     // a dequeue where we have no work to do if there's nobody queued.
+///     std::hint::spin_loop();
+/// }
+///
 /// // Set the flag, and let the thread wake up.
-/// // There is no race condition here, if `unpark`
+/// // There is no race condition here: if `unpark`
 /// // happens first, `park` will return immediately.
+/// // There is also no other `park` that could consume this token,
+/// // since we waited until the other thread got queued.
 /// // Hence there is no risk of a deadlock.
-/// flag.store(true, Ordering::Relaxed);
+/// FLAG.store(true, Ordering::Release);
 /// println!("Unpark the thread");
 /// parked_thread.thread().unpark();
 ///
@@ -1494,10 +1518,14 @@ impl Thread {
     /// ```
     /// use std::thread;
     /// use std::time::Duration;
+    /// use std::sync::atomic::{AtomicBool, Ordering};
+    ///
+    /// static QUEUED: AtomicBool = AtomicBool::new(false);
     ///
     /// let parked_thread = thread::Builder::new()
     ///     .spawn(|| {
     ///         println!("Parking thread");
+    ///         QUEUED.store(true, Ordering::Release);
     ///         thread::park();
     ///         println!("Thread unparked");
     ///     })
@@ -1506,6 +1534,15 @@ impl Thread {
     /// // Let some time pass for the thread to be spawned.
     /// thread::sleep(Duration::from_millis(10));
     ///
+    /// // Wait until the other thread is queued.
+    /// // This is crucial! It guarantees that the `unpark` below is not consumed
+    /// // by some other code in the parked thread (e.g. inside `println!`).
+    /// while !QUEUED.load(Ordering::Acquire) {
+    ///     // Spinning is of course inefficient; in practice, this would more likely be
+    ///     // a dequeue where we have no work to do if there's nobody queued.
+    ///     std::hint::spin_loop();
+    /// }
+    ///
     /// println!("Unpark the thread");
     /// parked_thread.thread().unpark();
     ///
diff --git a/library/std/src/thread/tests.rs b/library/std/src/thread/tests.rs
index ae889f1e77828..2117f5f93ce26 100644
--- a/library/std/src/thread/tests.rs
+++ b/library/std/src/thread/tests.rs
@@ -287,6 +287,8 @@ fn test_park_unpark_called_other_thread() {
     for _ in 0..10 {
         let th = thread::current();
 
+        // Here we rely on `thread::spawn` (specifically the part that runs after spawning
+        // the thread) to not consume the parking token.
         let _guard = thread::spawn(move || {
             super::sleep(Duration::from_millis(50));
             th.unpark();
@@ -316,6 +318,8 @@ fn test_park_timeout_unpark_called_other_thread() {
     for _ in 0..10 {
         let th = thread::current();
 
+        // Here we rely on `thread::spawn` (specifically the part that runs after spawning
+        // the thread) to not consume the parking token.
         let _guard = thread::spawn(move || {
             super::sleep(Duration::from_millis(50));
             th.unpark();
diff --git a/src/tools/miri/README.md b/src/tools/miri/README.md
index 7ccd27d7b83eb..2aa56baddf78f 100644
--- a/src/tools/miri/README.md
+++ b/src/tools/miri/README.md
@@ -600,6 +600,7 @@ Definite bugs found:
 * [A bug in the new `RwLock::downgrade` implementation](https://rust-lang.zulipchat.com/#narrow/channel/269128-miri/topic/Miri.20error.20library.20test) (caught by Miri before it landed in the Rust repo)
 * [Mockall reading uninitialized memory when mocking `std::io::Read::read`, even if all expectations are satisfied](https://github.com/asomers/mockall/issues/647) (caught by Miri running Tokio's test suite)
 * [`ReentrantLock` not correctly dealing with reuse of addresses for TLS storage of different threads](https://github.com/rust-lang/rust/pull/141248)
+* [Rare Deadlock in the thread (un)parking example code](https://github.com/rust-lang/rust/issues/145816)
 
 Violations of [Stacked Borrows] found that are likely bugs (but Stacked Borrows is currently just an experiment):
 

From f19c33e4eed884f0199b4e3924a8011a34f5e21c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Tue, 2 Sep 2025 16:44:00 +0200
Subject: [PATCH 0441/1889] Split distcheck logic into functions

---
 src/bootstrap/src/core/build_steps/test.rs | 115 +++++++++++----------
 1 file changed, 60 insertions(+), 55 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index ee2cbe9385e48..f5faa32defd4e 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -3189,61 +3189,66 @@ impl Step for Distcheck {
         // local source code, built artifacts or configuration by accident
         let root_dir = std::env::temp_dir().join("distcheck");
 
-        // Check that we can build some basic things from the plain source tarball
-        builder.info("Distcheck plain source tarball");
-        let plain_src_tarball = builder.ensure(dist::PlainSourceTarball);
-        let plain_src_dir = root_dir.join("distcheck-plain-src");
-        builder.clear_dir(&plain_src_dir);
-
-        let configure_args: Vec<String> = std::env::var("DISTCHECK_CONFIGURE_ARGS")
-            .map(|args| args.split(" ").map(|s| s.to_string()).collect::<Vec<String>>())
-            .unwrap_or_default();
-
-        command("tar")
-            .arg("-xf")
-            .arg(plain_src_tarball.tarball())
-            .arg("--strip-components=1")
-            .current_dir(&plain_src_dir)
-            .run(builder);
-        command("./configure")
-            .arg("--set")
-            .arg("rust.omit-git-hash=false")
-            .args(&configure_args)
-            .arg("--enable-vendor")
-            .current_dir(&plain_src_dir)
-            .run(builder);
-        command(helpers::make(&builder.config.host_target.triple))
-            .arg("check")
-            // Do not run the build as if we were in CI, otherwise git would be assumed to be
-            // present, but we build from a tarball here
-            .env("GITHUB_ACTIONS", "0")
-            .current_dir(&plain_src_dir)
-            .run(builder);
-
-        // Now make sure that rust-src has all of libstd's dependencies
-        builder.info("Distcheck rust-src");
-        let src_tarball = builder.ensure(dist::Src);
-        let src_dir = root_dir.join("distcheck-src");
-        builder.clear_dir(&src_dir);
-
-        command("tar")
-            .arg("-xf")
-            .arg(src_tarball.tarball())
-            .arg("--strip-components=1")
-            .current_dir(&src_dir)
-            .run(builder);
-
-        let toml = src_dir.join("rust-src/lib/rustlib/src/rust/library/std/Cargo.toml");
-        command(&builder.initial_cargo)
-            // Will read the libstd Cargo.toml
-            // which uses the unstable `public-dependency` feature.
-            .env("RUSTC_BOOTSTRAP", "1")
-            .arg("generate-lockfile")
-            .arg("--manifest-path")
-            .arg(&toml)
-            .current_dir(&src_dir)
-            .run(builder);
-    }
+        distcheck_plain_source_tarball(builder, &root_dir.join("distcheck-plain-src"));
+        distcheck_rust_src(builder, &root_dir.join("distcheck-src"));
+    }
+}
+
+fn distcheck_plain_source_tarball(builder: &Builder<'_>, plain_src_dir: &Path) {
+    // Check that we can build some basic things from the plain source tarball
+    builder.info("Distcheck plain source tarball");
+    let plain_src_tarball = builder.ensure(dist::PlainSourceTarball);
+    builder.clear_dir(&plain_src_dir);
+
+    let configure_args: Vec<String> = std::env::var("DISTCHECK_CONFIGURE_ARGS")
+        .map(|args| args.split(" ").map(|s| s.to_string()).collect::<Vec<String>>())
+        .unwrap_or_default();
+
+    command("tar")
+        .arg("-xf")
+        .arg(plain_src_tarball.tarball())
+        .arg("--strip-components=1")
+        .current_dir(&plain_src_dir)
+        .run(builder);
+    command("./configure")
+        .arg("--set")
+        .arg("rust.omit-git-hash=false")
+        .args(&configure_args)
+        .arg("--enable-vendor")
+        .current_dir(&plain_src_dir)
+        .run(builder);
+    command(helpers::make(&builder.config.host_target.triple))
+        .arg("check")
+        // Do not run the build as if we were in CI, otherwise git would be assumed to be
+        // present, but we build from a tarball here
+        .env("GITHUB_ACTIONS", "0")
+        .current_dir(&plain_src_dir)
+        .run(builder);
+}
+
+fn distcheck_rust_src(builder: &Builder<'_>, src_dir: &Path) {
+    // Now make sure that rust-src has all of libstd's dependencies
+    builder.info("Distcheck rust-src");
+    let src_tarball = builder.ensure(dist::Src);
+    builder.clear_dir(&src_dir);
+
+    command("tar")
+        .arg("-xf")
+        .arg(src_tarball.tarball())
+        .arg("--strip-components=1")
+        .current_dir(&src_dir)
+        .run(builder);
+
+    let toml = src_dir.join("rust-src/lib/rustlib/src/rust/library/std/Cargo.toml");
+    command(&builder.initial_cargo)
+        // Will read the libstd Cargo.toml
+        // which uses the unstable `public-dependency` feature.
+        .env("RUSTC_BOOTSTRAP", "1")
+        .arg("generate-lockfile")
+        .arg("--manifest-path")
+        .arg(&toml)
+        .current_dir(&src_dir)
+        .run(builder);
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]

From df2caed2a8f52610f778b396127ee8a5284f71eb Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Wed, 3 Sep 2025 13:33:35 +0530
Subject: [PATCH 0442/1889] refactor tests to use TestCtx

---
 src/bootstrap/src/core/builder/tests.rs    | 45 +++++-----------------
 src/bootstrap/src/utils/cc_detect/tests.rs | 21 ++++++----
 2 files changed, 24 insertions(+), 42 deletions(-)

diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index ef01f14f5e9a5..9e8c13eb4dec7 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -10,8 +10,8 @@ use crate::core::build_steps::doc::DocumentationFormat;
 use crate::core::config::Config;
 use crate::utils::cache::ExecutedStep;
 use crate::utils::helpers::get_host_target;
-use crate::utils::tests::ConfigBuilder;
 use crate::utils::tests::git::{GitCtx, git_test};
+use crate::utils::tests::{ConfigBuilder, TestCtx};
 
 static TEST_TRIPLE_1: &str = "i686-unknown-haiku";
 static TEST_TRIPLE_2: &str = "i686-unknown-hurd-gnu";
@@ -22,38 +22,13 @@ fn configure(cmd: &str, host: &[&str], target: &[&str]) -> Config {
 }
 
 fn configure_with_args(cmd: &[&str], host: &[&str], target: &[&str]) -> Config {
-    let cmd = cmd.iter().copied().map(String::from).collect::<Vec<_>>();
-    let mut config = Config::parse(Flags::parse(&cmd));
-    // don't save toolstates
-    config.save_toolstates = None;
-    config.set_dry_run(DryRun::SelfCheck);
-
-    // Ignore most submodules, since we don't need them for a dry run, and the
-    // tests run much faster without them.
-    //
-    // The src/doc/book submodule is needed because TheBook step tries to
-    // access files even during a dry-run (may want to consider just skipping
-    // that in a dry run).
-    let submodule_build = Build::new(Config {
-        // don't include LLVM, so CI doesn't require ninja/cmake to be installed
-        rust_codegen_backends: vec![],
-        ..Config::parse(Flags::parse(&["check".to_owned()]))
-    });
-    submodule_build.require_submodule("src/doc/book", None);
-    config.submodules = Some(false);
-
-    config.ninja_in_file = false;
-    // try to avoid spurious failures in dist where we create/delete each others file
-    // HACK: rather than pull in `tempdir`, use the one that cargo has conveniently created for us
-    let dir = Path::new(env!("OUT_DIR"))
-        .join("tmp-rustbuild-tests")
-        .join(&thread::current().name().unwrap_or("unknown").replace(":", "-"));
-    t!(fs::create_dir_all(&dir));
-    config.out = dir;
-    config.host_target = TargetSelection::from_user(TEST_TRIPLE_1);
-    config.hosts = host.iter().map(|s| TargetSelection::from_user(s)).collect();
-    config.targets = target.iter().map(|s| TargetSelection::from_user(s)).collect();
-    config
+    TestCtx::new()
+        .config(cmd[0])
+        .args(&cmd[1..])
+        .hosts(host)
+        .targets(target)
+        .args(&["--build", TEST_TRIPLE_1])
+        .create_config()
 }
 
 fn first<A, B>(v: Vec<(A, B)>) -> Vec<A> {
@@ -547,8 +522,8 @@ mod snapshot {
 
     use crate::core::build_steps::{compile, dist, doc, test, tool};
     use crate::core::builder::tests::{
-        RenderConfig, TEST_TRIPLE_1, TEST_TRIPLE_2, TEST_TRIPLE_3, configure, configure_with_args,
-        first, host_target, render_steps, run_build,
+        RenderConfig, TEST_TRIPLE_1, TEST_TRIPLE_2, TEST_TRIPLE_3, configure, first, host_target,
+        render_steps, run_build,
     };
     use crate::core::builder::{Builder, Kind, StepDescription, StepMetadata};
     use crate::core::config::TargetSelection;
diff --git a/src/bootstrap/src/utils/cc_detect/tests.rs b/src/bootstrap/src/utils/cc_detect/tests.rs
index bed03c18aaad4..a6233e6b61c1f 100644
--- a/src/bootstrap/src/utils/cc_detect/tests.rs
+++ b/src/bootstrap/src/utils/cc_detect/tests.rs
@@ -3,7 +3,8 @@ use std::{env, iter};
 
 use super::*;
 use crate::core::config::{Target, TargetSelection};
-use crate::{Build, Config, Flags};
+use crate::utils::tests::TestCtx;
+use crate::{Build, Config, Flags, t};
 
 #[test]
 fn test_ndk_compiler_c() {
@@ -68,7 +69,8 @@ fn test_language_clang() {
 
 #[test]
 fn test_new_cc_build() {
-    let build = Build::new(Config { ..Config::parse(Flags::parse(&["build".to_owned()])) });
+    let config = TestCtx::new().config("build").create_config();
+    let build = Build::new(config);
     let target = TargetSelection::from_user("x86_64-unknown-linux-gnu");
     let cfg = new_cc_build(&build, target.clone());
     let compiler = cfg.get_compiler();
@@ -77,7 +79,8 @@ fn test_new_cc_build() {
 
 #[test]
 fn test_default_compiler_wasi() {
-    let mut build = Build::new(Config { ..Config::parse(Flags::parse(&["build".to_owned()])) });
+    let config = TestCtx::new().config("build").create_config();
+    let mut build = Build::new(config);
     let target = TargetSelection::from_user("wasm32-wasi");
     let wasi_sdk = PathBuf::from("/wasi-sdk");
     build.wasi_sdk_path = Some(wasi_sdk.clone());
@@ -98,7 +101,8 @@ fn test_default_compiler_wasi() {
 
 #[test]
 fn test_default_compiler_fallback() {
-    let build = Build::new(Config { ..Config::parse(Flags::parse(&["build".to_owned()])) });
+    let config = TestCtx::new().config("build").create_config();
+    let build = Build::new(config);
     let target = TargetSelection::from_user("x86_64-unknown-linux-gnu");
     let mut cfg = cc::Build::new();
     let result = default_compiler(&mut cfg, Language::C, target, &build);
@@ -107,7 +111,8 @@ fn test_default_compiler_fallback() {
 
 #[test]
 fn test_find_target_with_config() {
-    let mut build = Build::new(Config { ..Config::parse(Flags::parse(&["build".to_owned()])) });
+    let config = TestCtx::new().config("build").create_config();
+    let mut build = Build::new(config);
     let target = TargetSelection::from_user("x86_64-unknown-linux-gnu");
     let mut target_config = Target::default();
     target_config.cc = Some(PathBuf::from("dummy-cc"));
@@ -128,7 +133,8 @@ fn test_find_target_with_config() {
 
 #[test]
 fn test_find_target_without_config() {
-    let mut build = Build::new(Config { ..Config::parse(Flags::parse(&["build".to_owned()])) });
+    let config = TestCtx::new().config("build").create_config();
+    let mut build = Build::new(config);
     let target = TargetSelection::from_user("x86_64-unknown-linux-gnu");
     build.config.target_config.clear();
     fill_target_compiler(&mut build, target.clone());
@@ -141,7 +147,8 @@ fn test_find_target_without_config() {
 
 #[test]
 fn test_find() {
-    let mut build = Build::new(Config { ..Config::parse(Flags::parse(&["build".to_owned()])) });
+    let config = TestCtx::new().config("build").create_config();
+    let mut build = Build::new(config);
     let target1 = TargetSelection::from_user("x86_64-unknown-linux-gnu");
     let target2 = TargetSelection::from_user("x86_64-unknown-openbsd");
     build.targets.push(target1.clone());

From c4a5408873601612981a963c76b8233c5bc93ed2 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Wed, 3 Sep 2025 13:33:58 +0530
Subject: [PATCH 0443/1889] Make test parallel  Use
 std::thread::available_parallelism() instead of hardcoded   --test-threads=1
 in bootstrap tests.

---
 src/bootstrap/src/core/build_steps/test.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index ee2cbe9385e48..43d47e0f7ddc9 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -3294,9 +3294,8 @@ impl Step for Bootstrap {
             .env("INSTA_WORKSPACE_ROOT", &builder.src)
             .env("RUSTC_BOOTSTRAP", "1");
 
-        // bootstrap tests are racy on directory creation so just run them one at a time.
-        // Since there's not many this shouldn't be a problem.
-        run_cargo_test(cargo, &["--test-threads=1"], &[], None, host, builder);
+        let threads = std::thread::available_parallelism().map(|n| n.get()).unwrap_or(1);
+        run_cargo_test(cargo, &["--test-threads", &threads.to_string()], &[], None, host, builder);
     }
 
     fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {

From 62b4347e80cc86314bd98749e95eff8cdf8ef005 Mon Sep 17 00:00:00 2001
From: sayantn <sayantn05@gmail.com>
Date: Thu, 21 Aug 2025 04:47:05 +0530
Subject: [PATCH 0444/1889] Add `funnel_sh{l,r}` functions and intrinsics

 - Add a fallback implementation for the intrinsics
 - Add LLVM backend support for funnel shifts

Co-Authored-By: folkertdev <folkert@folkertdev.nl>
---
 compiler/rustc_codegen_llvm/src/intrinsic.rs  | 26 +++++--
 .../rustc_hir_analysis/src/check/intrinsic.rs |  3 +
 compiler/rustc_span/src/symbol.rs             |  2 +
 library/core/src/intrinsics/fallback.rs       | 73 +++++++++++++++++++
 library/core/src/intrinsics/mod.rs            | 55 ++++++++++++++
 library/core/src/lib.rs                       |  1 +
 library/core/src/num/mod.rs                   | 24 ++++++
 library/core/src/num/uint_macros.rs           | 73 +++++++++++++++++++
 library/coretests/tests/lib.rs                |  1 +
 library/coretests/tests/num/uint_macros.rs    | 36 +++++++++
 library/std/src/lib.rs                        |  1 +
 .../miri/tests/fail/intrinsics/funnel_shl.rs  |  7 ++
 .../tests/fail/intrinsics/funnel_shl.stderr   | 15 ++++
 .../miri/tests/fail/intrinsics/funnel_shr.rs  |  7 ++
 .../tests/fail/intrinsics/funnel_shr.stderr   | 15 ++++
 .../miri/tests/pass/intrinsics/integer.rs     |  8 +-
 16 files changed, 338 insertions(+), 9 deletions(-)
 create mode 100644 src/tools/miri/tests/fail/intrinsics/funnel_shl.rs
 create mode 100644 src/tools/miri/tests/fail/intrinsics/funnel_shl.stderr
 create mode 100644 src/tools/miri/tests/fail/intrinsics/funnel_shr.rs
 create mode 100644 src/tools/miri/tests/fail/intrinsics/funnel_shr.stderr

diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
index 49d3dedbeabdf..85f71f331a491 100644
--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -383,7 +383,9 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
             | sym::rotate_left
             | sym::rotate_right
             | sym::saturating_add
-            | sym::saturating_sub => {
+            | sym::saturating_sub
+            | sym::unchecked_funnel_shl
+            | sym::unchecked_funnel_shr => {
                 let ty = args[0].layout.ty;
                 if !ty.is_integral() {
                     tcx.dcx().emit_err(InvalidMonomorphization::BasicIntegerType {
@@ -424,18 +426,26 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                     sym::bitreverse => {
                         self.call_intrinsic("llvm.bitreverse", &[llty], &[args[0].immediate()])
                     }
-                    sym::rotate_left | sym::rotate_right => {
-                        let is_left = name == sym::rotate_left;
-                        let val = args[0].immediate();
-                        let raw_shift = args[1].immediate();
-                        // rotate = funnel shift with first two args the same
+                    sym::rotate_left
+                    | sym::rotate_right
+                    | sym::unchecked_funnel_shl
+                    | sym::unchecked_funnel_shr => {
+                        let is_left = name == sym::rotate_left || name == sym::unchecked_funnel_shl;
+                        let lhs = args[0].immediate();
+                        let (rhs, raw_shift) =
+                            if name == sym::rotate_left || name == sym::rotate_right {
+                                // rotate = funnel shift with first two args the same
+                                (lhs, args[1].immediate())
+                            } else {
+                                (args[1].immediate(), args[2].immediate())
+                            };
                         let llvm_name = format!("llvm.fsh{}", if is_left { 'l' } else { 'r' });
 
                         // llvm expects shift to be the same type as the values, but rust
                         // always uses `u32`.
-                        let raw_shift = self.intcast(raw_shift, self.val_ty(val), false);
+                        let raw_shift = self.intcast(raw_shift, self.val_ty(lhs), false);
 
-                        self.call_intrinsic(llvm_name, &[llty], &[val, val, raw_shift])
+                        self.call_intrinsic(llvm_name, &[llty], &[lhs, rhs, raw_shift])
                     }
                     sym::saturating_add | sym::saturating_sub => {
                         let is_add = name == sym::saturating_add;
diff --git a/compiler/rustc_hir_analysis/src/check/intrinsic.rs b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
index cfc6bc2f3a0a9..aa2d27ab80945 100644
--- a/compiler/rustc_hir_analysis/src/check/intrinsic.rs
+++ b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
@@ -449,6 +449,9 @@ pub(crate) fn check_intrinsic_type(
         }
         sym::unchecked_shl | sym::unchecked_shr => (2, 0, vec![param(0), param(1)], param(0)),
         sym::rotate_left | sym::rotate_right => (1, 0, vec![param(0), tcx.types.u32], param(0)),
+        sym::unchecked_funnel_shl | sym::unchecked_funnel_shr => {
+            (1, 0, vec![param(0), param(0), tcx.types.u32], param(0))
+        }
         sym::unchecked_add | sym::unchecked_sub | sym::unchecked_mul => {
             (1, 0, vec![param(0), param(0)], param(0))
         }
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index dcb1becc957db..64662d481371a 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -2269,6 +2269,8 @@ symbols! {
         unboxed_closures,
         unchecked_add,
         unchecked_div,
+        unchecked_funnel_shl,
+        unchecked_funnel_shr,
         unchecked_mul,
         unchecked_rem,
         unchecked_shl,
diff --git a/library/core/src/intrinsics/fallback.rs b/library/core/src/intrinsics/fallback.rs
index eec5c4d646d07..96928325328a9 100644
--- a/library/core/src/intrinsics/fallback.rs
+++ b/library/core/src/intrinsics/fallback.rs
@@ -148,3 +148,76 @@ impl_disjoint_bitor! {
     u8, u16, u32, u64, u128, usize,
     i8, i16, i32, i64, i128, isize,
 }
+
+#[const_trait]
+#[rustc_const_unstable(feature = "core_intrinsics_fallbacks", issue = "none")]
+pub trait FunnelShift: Copy + 'static {
+    /// See [`super::unchecked_funnel_shl`]; we just need the trait indirection to handle
+    /// different types since calling intrinsics with generics doesn't work.
+    unsafe fn unchecked_funnel_shl(self, rhs: Self, shift: u32) -> Self;
+
+    /// See [`super::unchecked_funnel_shr`]; we just need the trait indirection to handle
+    /// different types since calling intrinsics with generics doesn't work.
+    unsafe fn unchecked_funnel_shr(self, rhs: Self, shift: u32) -> Self;
+}
+
+macro_rules! impl_funnel_shifts {
+    ($($type:ident),*) => {$(
+        #[rustc_const_unstable(feature = "core_intrinsics_fallbacks", issue = "none")]
+        impl const FunnelShift for $type {
+            #[cfg_attr(miri, track_caller)]
+            #[inline]
+            unsafe fn unchecked_funnel_shl(self, rhs: Self, shift: u32) -> Self {
+                // This implementation is also used by Miri so we have to check the precondition.
+                // SAFETY: this is guaranteed by the caller
+                unsafe { super::assume(shift < $type::BITS) };
+                if shift == 0 {
+                    self
+                } else {
+                    // SAFETY:
+                    //  - `shift < T::BITS`, which satisfies `unchecked_shl`
+                    //  - this also ensures that `T::BITS - shift < T::BITS` (shift = 0 is checked
+                    //    above), which satisfies `unchecked_shr`
+                    //  - because the types are unsigned, the combination are disjoint bits (this is
+                    //    not true if they're signed, since SHR will fill in the empty space with a
+                    //    sign bit, not zero)
+                    unsafe {
+                        super::disjoint_bitor(
+                            super::unchecked_shl(self, shift),
+                            super::unchecked_shr(rhs, $type::BITS - shift),
+                        )
+                    }
+                }
+            }
+
+            #[cfg_attr(miri, track_caller)]
+            #[inline]
+            unsafe fn unchecked_funnel_shr(self, rhs: Self, shift: u32) -> Self {
+                // This implementation is also used by Miri so we have to check the precondition.
+                // SAFETY: this is guaranteed by the caller
+                unsafe { super::assume(shift < $type::BITS) };
+                if shift == 0 {
+                    rhs
+                } else {
+                    // SAFETY:
+                    //  - `shift < T::BITS`, which satisfies `unchecked_shr`
+                    //  - this also ensures that `T::BITS - shift < T::BITS` (shift = 0 is checked
+                    //    above), which satisfies `unchecked_shl`
+                    //  - because the types are unsigned, the combination are disjoint bits (this is
+                    //    not true if they're signed, since SHR will fill in the empty space with a
+                    //    sign bit, not zero)
+                    unsafe {
+                        super::disjoint_bitor(
+                            super::unchecked_shl(self, $type::BITS - shift),
+                            super::unchecked_shr(rhs, shift),
+                        )
+                    }
+                }
+            }
+        }
+    )*};
+}
+
+impl_funnel_shifts! {
+    u8, u16, u32, u64, u128, usize
+}
diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs
index 904aa52c7845b..bffffbc29c1eb 100644
--- a/library/core/src/intrinsics/mod.rs
+++ b/library/core/src/intrinsics/mod.rs
@@ -2102,6 +2102,61 @@ pub const fn saturating_add<T: Copy>(a: T, b: T) -> T;
 #[rustc_intrinsic]
 pub const fn saturating_sub<T: Copy>(a: T, b: T) -> T;
 
+/// Funnel Shift left.
+///
+/// Concatenates `a` and `b` (with `a` in the most significant half),
+/// creating an integer twice as wide. Then shift this integer left
+/// by `shift`), and extract the most significant half. If `a` and `b`
+/// are the same, this is equivalent to a rotate left operation.
+///
+/// It is undefined behavior if `shift` is greater than or equal to the
+/// bit size of `T`.
+///
+/// Safe versions of this intrinsic are available on the integer primitives
+/// via the `funnel_shl` method. For example, [`u32::funnel_shl`].
+#[rustc_intrinsic]
+#[rustc_nounwind]
+#[rustc_const_unstable(feature = "funnel_shifts", issue = "145686")]
+#[unstable(feature = "funnel_shifts", issue = "145686")]
+#[track_caller]
+#[miri::intrinsic_fallback_is_spec]
+pub const unsafe fn unchecked_funnel_shl<T: [const] fallback::FunnelShift>(
+    a: T,
+    b: T,
+    shift: u32,
+) -> T {
+    // SAFETY: caller ensures that `shift` is in-range
+    unsafe { a.unchecked_funnel_shl(b, shift) }
+}
+
+/// Funnel Shift right.
+///
+/// Concatenates `a` and `b` (with `a` in the most significant half),
+/// creating an integer twice as wide. Then shift this integer right
+/// by `shift` (taken modulo the bit size of `T`), and extract the
+/// least significant half. If `a` and `b` are the same, this is equivalent
+/// to a rotate right operation.
+///
+/// It is undefined behavior if `shift` is greater than or equal to the
+/// bit size of `T`.
+///
+/// Safer versions of this intrinsic are available on the integer primitives
+/// via the `funnel_shr` method. For example, [`u32::funnel_shr`]
+#[rustc_intrinsic]
+#[rustc_nounwind]
+#[rustc_const_unstable(feature = "funnel_shifts", issue = "145686")]
+#[unstable(feature = "funnel_shifts", issue = "145686")]
+#[track_caller]
+#[miri::intrinsic_fallback_is_spec]
+pub const unsafe fn unchecked_funnel_shr<T: [const] fallback::FunnelShift>(
+    a: T,
+    b: T,
+    shift: u32,
+) -> T {
+    // SAFETY: caller ensures that `shift` is in-range
+    unsafe { a.unchecked_funnel_shr(b, shift) }
+}
+
 /// This is an implementation detail of [`crate::ptr::read`] and should
 /// not be used anywhere else.  See its comments for why this exists.
 ///
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 71abd707374cf..fb6cacb0e0076 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -156,6 +156,7 @@
 #![feature(f128)]
 #![feature(freeze_impls)]
 #![feature(fundamental)]
+#![feature(funnel_shifts)]
 #![feature(if_let_guard)]
 #![feature(intra_doc_pointers)]
 #![feature(intrinsics)]
diff --git a/library/core/src/num/mod.rs b/library/core/src/num/mod.rs
index acfe38b7a37b5..e2987b0b7e59d 100644
--- a/library/core/src/num/mod.rs
+++ b/library/core/src/num/mod.rs
@@ -454,6 +454,9 @@ impl u8 {
         rot = 2,
         rot_op = "0x82",
         rot_result = "0xa",
+        fsh_op = "0x36",
+        fshl_result = "0x8",
+        fshr_result = "0x8d",
         swap_op = "0x12",
         swapped = "0x12",
         reversed = "0x48",
@@ -1088,6 +1091,9 @@ impl u16 {
         rot = 4,
         rot_op = "0xa003",
         rot_result = "0x3a",
+        fsh_op = "0x2de",
+        fshl_result = "0x30",
+        fshr_result = "0x302d",
         swap_op = "0x1234",
         swapped = "0x3412",
         reversed = "0x2c48",
@@ -1135,6 +1141,9 @@ impl u32 {
         rot = 8,
         rot_op = "0x10000b3",
         rot_result = "0xb301",
+        fsh_op = "0x2fe78e45",
+        fshl_result = "0xb32f",
+        fshr_result = "0xb32fe78e",
         swap_op = "0x12345678",
         swapped = "0x78563412",
         reversed = "0x1e6a2c48",
@@ -1158,6 +1167,9 @@ impl u64 {
         rot = 12,
         rot_op = "0xaa00000000006e1",
         rot_result = "0x6e10aa",
+        fsh_op = "0x2fe78e45983acd98",
+        fshl_result = "0x6e12fe",
+        fshr_result = "0x6e12fe78e45983ac",
         swap_op = "0x1234567890123456",
         swapped = "0x5634129078563412",
         reversed = "0x6a2c48091e6a2c48",
@@ -1181,6 +1193,9 @@ impl u128 {
         rot = 16,
         rot_op = "0x13f40000000000000000000000004f76",
         rot_result = "0x4f7613f4",
+        fsh_op = "0x2fe78e45983acd98039000008736273",
+        fshl_result = "0x4f7602fe",
+        fshr_result = "0x4f7602fe78e45983acd9803900000873",
         swap_op = "0x12345678901234567890123456789012",
         swapped = "0x12907856341290785634129078563412",
         reversed = "0x48091e6a2c48091e6a2c48091e6a2c48",
@@ -1207,6 +1222,9 @@ impl usize {
         rot = 4,
         rot_op = "0xa003",
         rot_result = "0x3a",
+        fsh_op = "0x2fe78e45983acd98039000008736273",
+        fshl_result = "0x4f7602fe",
+        fshr_result = "0x4f7602fe78e45983acd9803900000873",
         swap_op = "0x1234",
         swapped = "0x3412",
         reversed = "0x2c48",
@@ -1231,6 +1249,9 @@ impl usize {
         rot = 8,
         rot_op = "0x10000b3",
         rot_result = "0xb301",
+        fsh_op = "0x2fe78e45",
+        fshl_result = "0xb32f",
+        fshr_result = "0xb32fe78e",
         swap_op = "0x12345678",
         swapped = "0x78563412",
         reversed = "0x1e6a2c48",
@@ -1255,6 +1276,9 @@ impl usize {
         rot = 12,
         rot_op = "0xaa00000000006e1",
         rot_result = "0x6e10aa",
+        fsh_op = "0x2fe78e45983acd98",
+        fshl_result = "0x6e12fe",
+        fshr_result = "0x6e12fe78e45983ac",
         swap_op = "0x1234567890123456",
         swapped = "0x5634129078563412",
         reversed = "0x6a2c48091e6a2c48",
diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs
index 10d9498d15e45..1fef3c822b720 100644
--- a/library/core/src/num/uint_macros.rs
+++ b/library/core/src/num/uint_macros.rs
@@ -14,6 +14,9 @@ macro_rules! uint_impl {
         rot = $rot:literal,
         rot_op = $rot_op:literal,
         rot_result = $rot_result:literal,
+        fsh_op = $fsh_op:literal,
+        fshl_result = $fshl_result:literal,
+        fshr_result = $fshr_result:literal,
         swap_op = $swap_op:literal,
         swapped = $swapped:literal,
         reversed = $reversed:literal,
@@ -375,6 +378,76 @@ macro_rules! uint_impl {
             return intrinsics::rotate_right(self, n);
         }
 
+        /// Performs a left funnel shift (concatenates `self` with `rhs`, with `self`
+        /// making up the most significant half, then shifts the combined value left
+        /// by `n`, and most significant half is extracted to produce the result).
+        ///
+        /// Please note this isn't the same operation as the `<<` shifting operator or
+        /// [`rotate_left`](Self::rotate_left), although `a.funnel_shl(a, n)` is *equivalent*
+        /// to `a.rotate_left(n)`.
+        ///
+        /// # Panics
+        ///
+        /// If `n` is greater than or equal to the number of bits in `self`
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        /// #![feature(funnel_shifts)]
+        #[doc = concat!("let a = ", $rot_op, stringify!($SelfT), ";")]
+        #[doc = concat!("let b = ", $fsh_op, stringify!($SelfT), ";")]
+        #[doc = concat!("let m = ", $fshl_result, ";")]
+        ///
+        #[doc = concat!("assert_eq!(a.funnel_shl(b, ", $rot, "), m);")]
+        /// ```
+        #[rustc_const_unstable(feature = "funnel_shifts", issue = "145686")]
+        #[unstable(feature = "funnel_shifts", issue = "145686")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline(always)]
+        pub const fn funnel_shl(self, rhs: Self, n: u32) -> Self {
+            assert!(n < Self::BITS, "attempt to funnel shift left with overflow");
+            // SAFETY: just checked that `shift` is in-range
+            unsafe { intrinsics::unchecked_funnel_shl(self, rhs, n) }
+        }
+
+        /// Performs a right funnel shift (concatenates `self` and `rhs`, with `self`
+        /// making up the most significant half, then shifts the combined value right
+        /// by `n`, and least significant half is extracted to produce the result).
+        ///
+        /// Please note this isn't the same operation as the `>>` shifting operator or
+        /// [`rotate_right`](Self::rotate_right), although `a.funnel_shr(a, n)` is *equivalent*
+        /// to `a.rotate_right(n)`.
+        ///
+        /// # Panics
+        ///
+        /// If `n` is greater than or equal to the number of bits in `self`
+        ///
+        /// # Examples
+        ///
+        /// Basic usage:
+        ///
+        /// ```
+        /// #![feature(funnel_shifts)]
+        #[doc = concat!("let a = ", $rot_op, stringify!($SelfT), ";")]
+        #[doc = concat!("let b = ", $fsh_op, stringify!($SelfT), ";")]
+        #[doc = concat!("let m = ", $fshr_result, ";")]
+        ///
+        #[doc = concat!("assert_eq!(a.funnel_shr(b, ", $rot, "), m);")]
+        /// ```
+        #[rustc_const_unstable(feature = "funnel_shifts", issue = "145686")]
+        #[unstable(feature = "funnel_shifts", issue = "145686")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline(always)]
+        pub const fn funnel_shr(self, rhs: Self, n: u32) -> Self {
+            assert!(n < Self::BITS, "attempt to funnel shift right with overflow");
+            // SAFETY: just checked that `shift` is in-range
+            unsafe { intrinsics::unchecked_funnel_shr(self, rhs, n) }
+        }
+
         /// Reverses the byte order of the integer.
         ///
         /// # Examples
diff --git a/library/coretests/tests/lib.rs b/library/coretests/tests/lib.rs
index d2281b1df2ffc..c16c344776dd0 100644
--- a/library/coretests/tests/lib.rs
+++ b/library/coretests/tests/lib.rs
@@ -50,6 +50,7 @@
 #![feature(fmt_internals)]
 #![feature(formatting_options)]
 #![feature(freeze)]
+#![feature(funnel_shifts)]
 #![feature(future_join)]
 #![feature(generic_assert_internals)]
 #![feature(hasher_prefixfree_extras)]
diff --git a/library/coretests/tests/num/uint_macros.rs b/library/coretests/tests/num/uint_macros.rs
index c7d10ea4d880a..63be8a45b5cfd 100644
--- a/library/coretests/tests/num/uint_macros.rs
+++ b/library/coretests/tests/num/uint_macros.rs
@@ -104,6 +104,19 @@ macro_rules! uint_module {
                 assert_eq_const_safe!($T: C.rotate_left(128), C);
             }
 
+            fn test_funnel_shift() {
+                // Shifting by 0 should have no effect
+                assert_eq_const_safe!($T: <$T>::funnel_shl(A, B, 0), A);
+                assert_eq_const_safe!($T: <$T>::funnel_shr(A, B, 0), B);
+
+                assert_eq_const_safe!($T: <$T>::funnel_shl(_0, _1, 4), 0b1111);
+                assert_eq_const_safe!($T: <$T>::funnel_shr(_0, _1, 4), _1 >> 4);
+                assert_eq_const_safe!($T: <$T>::funnel_shl(_1, _0, 4), _1 << 4);
+
+                assert_eq_const_safe!($T: <$T>::funnel_shl(_1, _1, 4), <$T>::rotate_left(_1, 4));
+                assert_eq_const_safe!($T: <$T>::funnel_shr(_1, _1, 4), <$T>::rotate_right(_1, 4));
+            }
+
             fn test_swap_bytes() {
                 assert_eq_const_safe!($T: A.swap_bytes().swap_bytes(), A);
                 assert_eq_const_safe!($T: B.swap_bytes().swap_bytes(), B);
@@ -150,6 +163,29 @@ macro_rules! uint_module {
             }
         }
 
+        #[test]
+        #[should_panic = "attempt to funnel shift left with overflow"]
+        fn test_funnel_shl_overflow() {
+            let _ = <$T>::funnel_shl(A, B, $T::BITS);
+        }
+
+        #[test]
+        #[should_panic = "attempt to funnel shift right with overflow"]
+        fn test_funnel_shr_overflow() {
+            let _ = <$T>::funnel_shr(A, B, $T::BITS);
+        }
+
+        #[test]
+        fn test_funnel_shifts_runtime() {
+            for i in 0..$T::BITS - 1 {
+                assert_eq!(<$T>::funnel_shl(A, 0, i), A << i);
+                assert_eq!(<$T>::funnel_shl(A, A, i), A.rotate_left(i));
+
+                assert_eq!(<$T>::funnel_shr(0, A, i), A >> i);
+                assert_eq!(<$T>::funnel_shr(A, A, i), A.rotate_right(i));
+            }
+        }
+
         #[test]
         fn test_isolate_highest_one() {
             const BITS: $T = <$T>::MAX;
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index ab417b6c72f9b..75018424c4e92 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -296,6 +296,7 @@
 #![feature(f128)]
 #![feature(ffi_const)]
 #![feature(formatting_options)]
+#![feature(funnel_shifts)]
 #![feature(hash_map_internals)]
 #![feature(hash_map_macro)]
 #![feature(if_let_guard)]
diff --git a/src/tools/miri/tests/fail/intrinsics/funnel_shl.rs b/src/tools/miri/tests/fail/intrinsics/funnel_shl.rs
new file mode 100644
index 0000000000000..40b61f65ebe88
--- /dev/null
+++ b/src/tools/miri/tests/fail/intrinsics/funnel_shl.rs
@@ -0,0 +1,7 @@
+#![feature(core_intrinsics, funnel_shifts)]
+
+fn main() {
+    unsafe {
+        std::intrinsics::unchecked_funnel_shl(1_u32, 2, 32); //~ ERROR: Undefined Behavior
+    }
+}
diff --git a/src/tools/miri/tests/fail/intrinsics/funnel_shl.stderr b/src/tools/miri/tests/fail/intrinsics/funnel_shl.stderr
new file mode 100644
index 0000000000000..fc828021b132c
--- /dev/null
+++ b/src/tools/miri/tests/fail/intrinsics/funnel_shl.stderr
@@ -0,0 +1,15 @@
+error: Undefined Behavior: `assume` called with `false`
+  --> tests/fail/intrinsics/funnel_shl.rs:LL:CC
+   |
+LL |         std::intrinsics::unchecked_funnel_shl(1_u32, 2, 32);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
+   |
+   = 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 tests/fail/intrinsics/funnel_shl.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/intrinsics/funnel_shr.rs b/src/tools/miri/tests/fail/intrinsics/funnel_shr.rs
new file mode 100644
index 0000000000000..9582265639716
--- /dev/null
+++ b/src/tools/miri/tests/fail/intrinsics/funnel_shr.rs
@@ -0,0 +1,7 @@
+#![feature(core_intrinsics, funnel_shifts)]
+
+fn main() {
+    unsafe {
+        std::intrinsics::unchecked_funnel_shr(1_u32, 2, 32); //~ ERROR: Undefined Behavior
+    }
+}
diff --git a/src/tools/miri/tests/fail/intrinsics/funnel_shr.stderr b/src/tools/miri/tests/fail/intrinsics/funnel_shr.stderr
new file mode 100644
index 0000000000000..7361df1b4c7aa
--- /dev/null
+++ b/src/tools/miri/tests/fail/intrinsics/funnel_shr.stderr
@@ -0,0 +1,15 @@
+error: Undefined Behavior: `assume` called with `false`
+  --> tests/fail/intrinsics/funnel_shr.rs:LL:CC
+   |
+LL |         std::intrinsics::unchecked_funnel_shr(1_u32, 2, 32);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
+   |
+   = 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 tests/fail/intrinsics/funnel_shr.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/intrinsics/integer.rs b/src/tools/miri/tests/pass/intrinsics/integer.rs
index 13e7bd8e1b944..8727b6d3c87ec 100644
--- a/src/tools/miri/tests/pass/intrinsics/integer.rs
+++ b/src/tools/miri/tests/pass/intrinsics/integer.rs
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 // SPDX-FileCopyrightText: The Rust Project Developers (see https://thanks.rust-lang.org)
 
-#![feature(core_intrinsics)]
+#![feature(core_intrinsics, funnel_shifts)]
 use std::intrinsics::*;
 
 pub fn main() {
@@ -143,5 +143,11 @@ pub fn main() {
 
         assert_eq!(unchecked_mul(6u8, 7), 42);
         assert_eq!(unchecked_mul(13, -5), -65);
+
+        assert_eq!(unchecked_funnel_shl(1_u32, 2, 5), 32);
+        assert_eq!(unchecked_funnel_shl(1_u32, 2, 31), 0x80000001);
+
+        assert_eq!(unchecked_funnel_shr(1_u32, 2, 5), 0x08000000);
+        assert_eq!(unchecked_funnel_shr(1_u32, 2, 31), 2);
     }
 }

From df324fa7c8f96ed064f90c7b24c31d605eedc9b8 Mon Sep 17 00:00:00 2001
From: Josh Triplett <josh@joshtriplett.org>
Date: Wed, 3 Sep 2025 01:56:53 -0700
Subject: [PATCH 0445/1889] Add note about trailing whitespace in string
 literals.

---
 src/doc/style-guide/src/README.md | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/doc/style-guide/src/README.md b/src/doc/style-guide/src/README.md
index a20f62d65a59d..c3788c97ae69a 100644
--- a/src/doc/style-guide/src/README.md
+++ b/src/doc/style-guide/src/README.md
@@ -115,7 +115,10 @@ fn baz() {}
 ### Trailing whitespace
 
 Do not include trailing whitespace on the end of any line. This includes blank
-lines, comment lines, and code lines.
+lines, comment lines, code lines, and string literals.
+
+Note that avoiding trailing whitespace in string literals requires care to
+preserve the value of the literal.
 
 ### Sorting
 

From 03bffa88011c6f59c0b62940aeb98fce212e4e82 Mon Sep 17 00:00:00 2001
From: Miguel Ojeda <ojeda@kernel.org>
Date: Wed, 3 Sep 2025 10:46:34 +0200
Subject: [PATCH 0446/1889] CI: rfl: move job forward to Linux v6.17-rc3 plus 2
 commits

This upgrades the Rust CI from v6.16-rc1 plus a temporary commit for
the >= 1.91 target spec [1] to v6.17-rc3 with two commits pending to
be merged upstream -- one for the same target spec format change [1]
and another for the `file_as_c_str` change [2].

Link: https://github.com/rust-lang/rust/pull/144443 [1]
Link: https://github.com/rust-lang/rust/pull/145928 [2]
Signed-off-by: Miguel Ojeda <ojeda@kernel.org>
---
 src/ci/docker/scripts/rfl-build.sh | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/ci/docker/scripts/rfl-build.sh b/src/ci/docker/scripts/rfl-build.sh
index 70ff5d0d2c722..7e0fb5794f47c 100755
--- a/src/ci/docker/scripts/rfl-build.sh
+++ b/src/ci/docker/scripts/rfl-build.sh
@@ -3,7 +3,8 @@
 set -euo pipefail
 
 # https://github.com/rust-lang/rust/pull/144443
-LINUX_VERSION=7770d51bce622b13195b2d3c85407282fc9c27e5
+# https://github.com/rust-lang/rust/pull/145928
+LINUX_VERSION=8851e27d2cb947ea8bbbe8e812068f7bf5cbd00b
 
 # Build rustc, rustdoc, cargo, clippy-driver and rustfmt
 ../x.py build --stage 2 library rustdoc clippy rustfmt

From 283985393a98761e656c86c5f6f153e9f90eb7e2 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 3 Sep 2025 10:27:20 +0200
Subject: [PATCH 0447/1889] add flag to not shorten FD reads/writes; don't
 shorten pipe operations

---
 src/tools/miri/README.md                      |  4 +++
 src/tools/miri/src/bin/miri.rs                |  2 ++
 src/tools/miri/src/eval.rs                    |  3 ++
 src/tools/miri/src/machine.rs                 |  5 ++++
 src/tools/miri/src/shims/files.rs             | 12 ++++++--
 src/tools/miri/src/shims/unix/fd.rs           | 30 +++++++++++--------
 .../miri/src/shims/unix/linux_like/eventfd.rs |  5 ----
 .../miri/src/shims/unix/unnamed_socket.rs     |  8 +++++
 8 files changed, 50 insertions(+), 19 deletions(-)

diff --git a/src/tools/miri/README.md b/src/tools/miri/README.md
index cb4a56b58ac8a..517aa343a6d4d 100644
--- a/src/tools/miri/README.md
+++ b/src/tools/miri/README.md
@@ -323,6 +323,10 @@ environment variable. We first document the most relevant and most commonly used
   that do not have a guaranteed precision. The sign of the error is still non-deterministic.
 * `-Zmiri-no-extra-rounding-error` stops Miri from adding extra rounding errors to float operations
   that do not have a guaranteed precision.
+* `-Zmiri-no-short-fd-operations` stops Miri from artificially forcing `read`/`write` operations
+  to only process a part of their buffer. Note that whenever Miri uses host operations to
+  implement `read`/`write` (e.g. for file-backed file descriptors), the host system can still
+  introduce short reads/writes.
 * `-Zmiri-num-cpus` states the number of available CPUs to be reported by miri. By default, the
   number of available CPUs is `1`. Note that this flag does not affect how miri handles threads in
   any way.
diff --git a/src/tools/miri/src/bin/miri.rs b/src/tools/miri/src/bin/miri.rs
index 8fd8d332978d3..9b0bee72aeff6 100644
--- a/src/tools/miri/src/bin/miri.rs
+++ b/src/tools/miri/src/bin/miri.rs
@@ -559,6 +559,8 @@ fn main() {
             miri_config.float_rounding_error = miri::FloatRoundingErrorMode::None;
         } else if arg == "-Zmiri-max-extra-rounding-error" {
             miri_config.float_rounding_error = miri::FloatRoundingErrorMode::Max;
+        } else if arg == "-Zmiri-no-short-fd-operations" {
+            miri_config.short_fd_operations = false;
         } else if arg == "-Zmiri-strict-provenance" {
             miri_config.provenance_mode = ProvenanceMode::Strict;
         } else if arg == "-Zmiri-permissive-provenance" {
diff --git a/src/tools/miri/src/eval.rs b/src/tools/miri/src/eval.rs
index f174a448a8104..caed98f04f32e 100644
--- a/src/tools/miri/src/eval.rs
+++ b/src/tools/miri/src/eval.rs
@@ -113,6 +113,8 @@ pub struct MiriConfig {
     pub float_nondet: bool,
     /// Whether floating-point operations can have a non-deterministic rounding error.
     pub float_rounding_error: FloatRoundingErrorMode,
+    /// Whether Miri artifically introduces short reads/writes on file descriptors.
+    pub short_fd_operations: bool,
 }
 
 impl Default for MiriConfig {
@@ -155,6 +157,7 @@ impl Default for MiriConfig {
             force_intrinsic_fallback: false,
             float_nondet: true,
             float_rounding_error: FloatRoundingErrorMode::Random,
+            short_fd_operations: true,
         }
     }
 }
diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index 7802a58f11236..9067c5d33cb66 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -669,6 +669,9 @@ pub struct MiriMachine<'tcx> {
     pub float_nondet: bool,
     /// Whether floating-point operations can have a non-deterministic rounding error.
     pub float_rounding_error: FloatRoundingErrorMode,
+
+    /// Whether Miri artifically introduces short reads/writes on file descriptors.
+    pub short_fd_operations: bool,
 }
 
 impl<'tcx> MiriMachine<'tcx> {
@@ -830,6 +833,7 @@ impl<'tcx> MiriMachine<'tcx> {
             force_intrinsic_fallback: config.force_intrinsic_fallback,
             float_nondet: config.float_nondet,
             float_rounding_error: config.float_rounding_error,
+            short_fd_operations: config.short_fd_operations,
         }
     }
 
@@ -1006,6 +1010,7 @@ impl VisitProvenance for MiriMachine<'_> {
             force_intrinsic_fallback: _,
             float_nondet: _,
             float_rounding_error: _,
+            short_fd_operations: _,
         } = self;
 
         threads.visit_provenance(visit);
diff --git a/src/tools/miri/src/shims/files.rs b/src/tools/miri/src/shims/files.rs
index 0d4642c6ad0ef..8c29cb040b55a 100644
--- a/src/tools/miri/src/shims/files.rs
+++ b/src/tools/miri/src/shims/files.rs
@@ -168,8 +168,9 @@ pub trait FileDescription: std::fmt::Debug + FileDescriptionExt {
     }
 
     /// Determines whether this FD non-deterministically has its reads and writes shortened.
-    fn nondet_short_accesses(&self) -> bool {
-        true
+    fn short_fd_operations(&self) -> bool {
+        // We only enable this for FD kinds where we think short accesses gain useful test coverage.
+        false
     }
 
     /// Seeks to the given offset (which can be relative to the beginning, end, or current position).
@@ -395,6 +396,13 @@ impl FileDescription for FileHandle {
         communicate_allowed && self.file.is_terminal()
     }
 
+    fn short_fd_operations(&self) -> bool {
+        // While short accesses on file-backed FDs are very rare (at least for sufficiently small
+        // accesses), they can realistically happen when a signal interrupts the syscall.
+        // FIXME: we should return `false` if this is a named pipe...
+        true
+    }
+
     fn as_unix<'tcx>(&self, ecx: &MiriInterpCx<'tcx>) -> &dyn UnixFileDescription {
         assert!(
             ecx.target_os_is_unix(),
diff --git a/src/tools/miri/src/shims/unix/fd.rs b/src/tools/miri/src/shims/unix/fd.rs
index 9fbecffc55d9b..95e26ef5d5d83 100644
--- a/src/tools/miri/src/shims/unix/fd.rs
+++ b/src/tools/miri/src/shims/unix/fd.rs
@@ -274,12 +274,15 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         }
         // Non-deterministically decide to further reduce the count, simulating a partial read (but
         // never to 0, that would indicate EOF).
-        let count =
-            if fd.nondet_short_accesses() && count >= 2 && this.machine.rng.get_mut().random() {
-                count / 2 // since `count` is at least 2, the result is still at least 1
-            } else {
-                count
-            };
+        let count = if this.machine.short_fd_operations
+            && fd.short_fd_operations()
+            && count >= 2
+            && this.machine.rng.get_mut().random()
+        {
+            count / 2 // since `count` is at least 2, the result is still at least 1
+        } else {
+            count
+        };
 
         trace!("read: FD mapped to {fd:?}");
         // We want to read at most `count` bytes. We are sure that `count` is not negative
@@ -360,12 +363,15 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         // Non-deterministically decide to further reduce the count, simulating a partial write.
         // We avoid reducing the write size to 0: the docs seem to be entirely fine with that,
         // but the standard library is not (https://github.com/rust-lang/rust/issues/145959).
-        let count =
-            if fd.nondet_short_accesses() && count >= 2 && this.machine.rng.get_mut().random() {
-                count / 2
-            } else {
-                count
-            };
+        let count = if this.machine.short_fd_operations
+            && fd.short_fd_operations()
+            && count >= 2
+            && this.machine.rng.get_mut().random()
+        {
+            count / 2
+        } else {
+            count
+        };
 
         let finish = {
             let dest = dest.clone();
diff --git a/src/tools/miri/src/shims/unix/linux_like/eventfd.rs b/src/tools/miri/src/shims/unix/linux_like/eventfd.rs
index 2d35ef064db8b..ee7deb8d38308 100644
--- a/src/tools/miri/src/shims/unix/linux_like/eventfd.rs
+++ b/src/tools/miri/src/shims/unix/linux_like/eventfd.rs
@@ -37,11 +37,6 @@ impl FileDescription for EventFd {
         "event"
     }
 
-    fn nondet_short_accesses(&self) -> bool {
-        // We always read and write exactly one `u64`.
-        false
-    }
-
     fn close<'tcx>(
         self,
         _communicate_allowed: bool,
diff --git a/src/tools/miri/src/shims/unix/unnamed_socket.rs b/src/tools/miri/src/shims/unix/unnamed_socket.rs
index 817ddd7954df4..7eb82851033d8 100644
--- a/src/tools/miri/src/shims/unix/unnamed_socket.rs
+++ b/src/tools/miri/src/shims/unix/unnamed_socket.rs
@@ -123,6 +123,14 @@ impl FileDescription for AnonSocket {
         anonsocket_write(self, ptr, len, ecx, finish)
     }
 
+    fn short_fd_operations(&self) -> bool {
+        // Pipes guarantee that sufficiently small accesses are not broken apart:
+        // <https://pubs.opengroup.org/onlinepubs/9799919799/functions/write.html#tag_17_699_08>.
+        // For now, we don't bother checking for the size, and just entirely disable
+        // short accesses on pipes.
+        matches!(self.fd_type, AnonSocketType::Socketpair)
+    }
+
     fn as_unix<'tcx>(&self, _ecx: &MiriInterpCx<'tcx>) -> &dyn UnixFileDescription {
         self
     }

From 5b71113a64d576abd6a14c8d7201ff1164a6c44e Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 3 Sep 2025 11:40:46 +0200
Subject: [PATCH 0448/1889] re-balance CI

---
 src/tools/miri/ci/ci.sh | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/tools/miri/ci/ci.sh b/src/tools/miri/ci/ci.sh
index b66530e77b8a8..224ca0ae29948 100755
--- a/src/tools/miri/ci/ci.sh
+++ b/src/tools/miri/ci/ci.sh
@@ -164,12 +164,15 @@ case $HOST_TARGET in
     MANY_SEEDS=16 TEST_TARGET=arm-unknown-linux-gnueabi run_tests # 32bit ARM
     MANY_SEEDS=16 TEST_TARGET=aarch64-pc-windows-gnullvm run_tests # gnullvm ABI
     MANY_SEEDS=16 TEST_TARGET=s390x-unknown-linux-gnu run_tests # big-endian architecture of choice
-    # Custom target JSON file
-    TEST_TARGET=tests/x86_64-unknown-kernel.json MIRI_NO_STD=1 run_tests_minimal no_std
+    # Not officially supported tier 2
+    MANY_SEEDS=16 TEST_TARGET=x86_64-unknown-freebsd run_tests
+    MANY_SEEDS=16 TEST_TARGET=i686-unknown-freebsd run_tests
     ;;
   armv7-unknown-linux-gnueabihf)
     # Host
     GC_STRESS=1 MIR_OPT=1 MANY_SEEDS=64 TEST_BENCH=1 CARGO_MIRI_ENV=1 run_tests
+    # Custom target JSON file
+    TEST_TARGET=tests/x86_64-unknown-kernel.json MIRI_NO_STD=1 run_tests_minimal no_std
     ;;
   aarch64-apple-darwin)
     # Host
@@ -181,8 +184,6 @@ case $HOST_TARGET in
     MANY_SEEDS=16 TEST_TARGET=mips-unknown-linux-gnu run_tests # a 32bit big-endian target, and also a target without 64bit atomics
     MANY_SEEDS=16 TEST_TARGET=x86_64-unknown-illumos run_tests
     MANY_SEEDS=16 TEST_TARGET=x86_64-pc-solaris run_tests
-    MANY_SEEDS=16 TEST_TARGET=x86_64-unknown-freebsd run_tests
-    MANY_SEEDS=16 TEST_TARGET=i686-unknown-freebsd run_tests
     ;;
   i686-pc-windows-msvc)
     # Host

From a880c46f198e9601e70cac9286154286906699ce Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 3 Sep 2025 11:47:30 +0200
Subject: [PATCH 0449/1889] no need to run GC_STRESS more than once for each OS

---
 src/tools/miri/ci/ci.sh | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/tools/miri/ci/ci.sh b/src/tools/miri/ci/ci.sh
index 224ca0ae29948..6356e33f61e84 100755
--- a/src/tools/miri/ci/ci.sh
+++ b/src/tools/miri/ci/ci.sh
@@ -137,6 +137,7 @@ function run_tests_minimal {
 
 # In particular, fully cover all tier 1 targets.
 # We also want to run the many-seeds tests on all tier 1 targets.
+# We run GC_STRESS only once for each tier 1 OS.
 case $HOST_TARGET in
   x86_64-unknown-linux-gnu)
     # Host
@@ -147,7 +148,6 @@ case $HOST_TARGET in
     ;;
   i686-unknown-linux-gnu)
     # Host
-    # Without GC_STRESS as this is a slow runner.
     MIR_OPT=1 MANY_SEEDS=64 TEST_BENCH=1 CARGO_MIRI_ENV=1 run_tests
     # Partially supported targets (tier 2)
     BASIC="empty_main integer heap_alloc libc-mem vec string btreemap" # ensures we have the basics: pre-main code, system allocator
@@ -159,7 +159,7 @@ case $HOST_TARGET in
     ;;
   aarch64-unknown-linux-gnu)
     # Host
-    GC_STRESS=1 MIR_OPT=1 MANY_SEEDS=64 TEST_BENCH=1 CARGO_MIRI_ENV=1 run_tests
+    MIR_OPT=1 MANY_SEEDS=64 TEST_BENCH=1 CARGO_MIRI_ENV=1 run_tests
     # Extra tier 2
     MANY_SEEDS=16 TEST_TARGET=arm-unknown-linux-gnueabi run_tests # 32bit ARM
     MANY_SEEDS=16 TEST_TARGET=aarch64-pc-windows-gnullvm run_tests # gnullvm ABI
@@ -170,7 +170,7 @@ case $HOST_TARGET in
     ;;
   armv7-unknown-linux-gnueabihf)
     # Host
-    GC_STRESS=1 MIR_OPT=1 MANY_SEEDS=64 TEST_BENCH=1 CARGO_MIRI_ENV=1 run_tests
+    MIR_OPT=1 MANY_SEEDS=64 TEST_BENCH=1 CARGO_MIRI_ENV=1 run_tests
     # Custom target JSON file
     TEST_TARGET=tests/x86_64-unknown-kernel.json MIRI_NO_STD=1 run_tests_minimal no_std
     ;;
@@ -187,7 +187,6 @@ case $HOST_TARGET in
     ;;
   i686-pc-windows-msvc)
     # Host
-    # Without GC_STRESS as this is a very slow runner.
     MIR_OPT=1 MANY_SEEDS=64 TEST_BENCH=1 run_tests
     # Extra tier 1
     # We really want to ensure a Linux target works on a Windows host,
@@ -196,8 +195,7 @@ case $HOST_TARGET in
     ;;
   aarch64-pc-windows-msvc)
     # Host
-    # Without GC_STRESS as this is a very slow runner.
-    MIR_OPT=1 MANY_SEEDS=64 TEST_BENCH=1 CARGO_MIRI_ENV=1 run_tests
+    GC_STRESS=1 MIR_OPT=1 MANY_SEEDS=64 TEST_BENCH=1 CARGO_MIRI_ENV=1 run_tests
     # Extra tier 1
     MANY_SEEDS=64 TEST_TARGET=i686-unknown-linux-gnu run_tests
     ;;

From 18683c20aec00908d06255f9688cc1efb6eff10c Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 3 Sep 2025 12:20:44 +0200
Subject: [PATCH 0450/1889] update lockfile

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

diff --git a/Cargo.lock b/Cargo.lock
index a8df53f3a4113..52f5048115753 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3204,9 +3204,9 @@ dependencies = [
 
 [[package]]
 name = "rustc-build-sysroot"
-version = "0.5.9"
+version = "0.5.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdb13874a0e55baf4ac3d49d38206aecb31a55b75d6c4d04fd850b53942c8cc8"
+checksum = "3b881c015c729b43105bbd3702a9bdecee28fafaa21126d1d62e454ec011a4b7"
 dependencies = [
  "anyhow",
  "rustc_version",

From d366f26421125e11bfcec5e4a9f202813cbd3229 Mon Sep 17 00:00:00 2001
From: Patrick-6 <pamu99@gmx.ch>
Date: Mon, 14 Apr 2025 08:53:50 +0200
Subject: [PATCH 0451/1889] Extract address generator struct from memory
 allocator.

---
 .../src/alloc_addresses/address_generator.rs  | 78 +++++++++++++++++++
 src/tools/miri/src/alloc_addresses/mod.rs     | 65 ++++------------
 src/tools/miri/src/machine.rs                 |  4 +-
 3 files changed, 95 insertions(+), 52 deletions(-)
 create mode 100644 src/tools/miri/src/alloc_addresses/address_generator.rs

diff --git a/src/tools/miri/src/alloc_addresses/address_generator.rs b/src/tools/miri/src/alloc_addresses/address_generator.rs
new file mode 100644
index 0000000000000..3764f5dcb8244
--- /dev/null
+++ b/src/tools/miri/src/alloc_addresses/address_generator.rs
@@ -0,0 +1,78 @@
+use std::ops::Range;
+
+use rand::Rng;
+use rustc_abi::{Align, Size};
+use rustc_const_eval::interpret::{InterpResult, interp_ok};
+use rustc_middle::{err_exhaust, throw_exhaust};
+
+/// Shifts `addr` to make it aligned with `align` by rounding `addr` to the smallest multiple
+/// of `align` that is larger or equal to `addr`
+fn align_addr(addr: u64, align: u64) -> u64 {
+    match addr % align {
+        0 => addr,
+        rem => addr.strict_add(align) - rem,
+    }
+}
+
+/// This provides the logic to generate addresses for memory allocations in a given address range.
+#[derive(Debug)]
+pub struct AddressGenerator {
+    /// This is used as a memory address when a new pointer is casted to an integer. It
+    /// is always larger than any address that was previously made part of a block.
+    next_base_addr: u64,
+    /// This is the last address that can be allocated.
+    end: u64,
+}
+
+impl AddressGenerator {
+    pub fn new(addr_range: Range<u64>) -> Self {
+        Self { next_base_addr: addr_range.start, end: addr_range.end }
+    }
+
+    /// Get the remaining range where this `AddressGenerator` can still allocate addresses.
+    pub fn get_remaining(&self) -> Range<u64> {
+        self.next_base_addr..self.end
+    }
+
+    /// Generate a new address with the specified size and alignment, using the given Rng to add some randomness.
+    /// The returned allocation is guaranteed not to overlap with any address ranges given out by the generator before.
+    /// Returns an error if the allocation request cannot be fulfilled.
+    pub fn generate<'tcx, R: Rng>(
+        &mut self,
+        size: Size,
+        align: Align,
+        rng: &mut R,
+    ) -> InterpResult<'tcx, u64> {
+        // Leave some space to the previous allocation, to give it some chance to be less aligned.
+        // We ensure that `(self.next_base_addr + slack) % 16` is uniformly distributed.
+        let slack = rng.random_range(0..16);
+        // From next_base_addr + slack, round up to adjust for alignment.
+        let base_addr =
+            self.next_base_addr.checked_add(slack).ok_or_else(|| err_exhaust!(AddressSpaceFull))?;
+        let base_addr = align_addr(base_addr, align.bytes());
+
+        // Remember next base address.  If this allocation is zero-sized, leave a gap of at
+        // least 1 to avoid two allocations having the same base address. (The logic in
+        // `alloc_id_from_addr` assumes unique addresses, and different function/vtable pointers
+        // need to be distinguishable!)
+        self.next_base_addr = base_addr
+            .checked_add(size.bytes().max(1))
+            .ok_or_else(|| err_exhaust!(AddressSpaceFull))?;
+        // Even if `Size` didn't overflow, we might still have filled up the address space.
+        if self.next_base_addr > self.end {
+            throw_exhaust!(AddressSpaceFull);
+        }
+        interp_ok(base_addr)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_align_addr() {
+        assert_eq!(align_addr(37, 4), 40);
+        assert_eq!(align_addr(44, 4), 44);
+    }
+}
diff --git a/src/tools/miri/src/alloc_addresses/mod.rs b/src/tools/miri/src/alloc_addresses/mod.rs
index 334503d2994b1..afd8afbaeab07 100644
--- a/src/tools/miri/src/alloc_addresses/mod.rs
+++ b/src/tools/miri/src/alloc_addresses/mod.rs
@@ -1,15 +1,16 @@
 //! This module is responsible for managing the absolute addresses that allocations are located at,
 //! and for casting between pointers and integers based on those addresses.
 
+mod address_generator;
 mod reuse_pool;
 
 use std::cell::RefCell;
-use std::cmp::max;
 
-use rand::Rng;
 use rustc_abi::{Align, Size};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_middle::ty::TyCtxt;
 
+pub use self::address_generator::AddressGenerator;
 use self::reuse_pool::ReusePool;
 use crate::concurrency::VClock;
 use crate::*;
@@ -49,9 +50,8 @@ pub struct GlobalStateInner {
     /// Whether an allocation has been exposed or not. This cannot be put
     /// into `AllocExtra` for the same reason as `base_addr`.
     exposed: FxHashSet<AllocId>,
-    /// This is used as a memory address when a new pointer is casted to an integer. It
-    /// is always larger than any address that was previously made part of a block.
-    next_base_addr: u64,
+    /// The generator for new addresses in a given range.
+    address_generator: AddressGenerator,
     /// The provenance to use for int2ptr casts
     provenance_mode: ProvenanceMode,
 }
@@ -64,7 +64,7 @@ impl VisitProvenance for GlobalStateInner {
             prepared_alloc_bytes: _,
             reuse: _,
             exposed: _,
-            next_base_addr: _,
+            address_generator: _,
             provenance_mode: _,
         } = self;
         // Though base_addr, int_to_ptr_map, and exposed contain AllocIds, we do not want to visit them.
@@ -77,14 +77,14 @@ impl VisitProvenance for GlobalStateInner {
 }
 
 impl GlobalStateInner {
-    pub fn new(config: &MiriConfig, stack_addr: u64) -> Self {
+    pub fn new<'tcx>(config: &MiriConfig, stack_addr: u64, tcx: TyCtxt<'tcx>) -> Self {
         GlobalStateInner {
             int_to_ptr_map: Vec::default(),
             base_addr: FxHashMap::default(),
             prepared_alloc_bytes: FxHashMap::default(),
             reuse: ReusePool::new(config),
             exposed: FxHashSet::default(),
-            next_base_addr: stack_addr,
+            address_generator: AddressGenerator::new(stack_addr..tcx.target_usize_max()),
             provenance_mode: config.provenance_mode,
         }
     }
@@ -96,15 +96,6 @@ impl GlobalStateInner {
     }
 }
 
-/// Shifts `addr` to make it aligned with `align` by rounding `addr` to the smallest multiple
-/// of `align` that is larger or equal to `addr`
-fn align_addr(addr: u64, align: u64) -> u64 {
-    match addr % align {
-        0 => addr,
-        rem => addr.strict_add(align) - rem,
-    }
-}
-
 impl<'tcx> EvalContextExtPriv<'tcx> for crate::MiriInterpCx<'tcx> {}
 trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
     fn addr_from_alloc_id_uncached(
@@ -194,34 +185,17 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
             interp_ok(reuse_addr)
         } else {
             // We have to pick a fresh address.
-            // Leave some space to the previous allocation, to give it some chance to be less aligned.
-            // We ensure that `(global_state.next_base_addr + slack) % 16` is uniformly distributed.
-            let slack = rng.random_range(0..16);
-            // From next_base_addr + slack, round up to adjust for alignment.
-            let base_addr = global_state
-                .next_base_addr
-                .checked_add(slack)
-                .ok_or_else(|| err_exhaust!(AddressSpaceFull))?;
-            let base_addr = align_addr(base_addr, info.align.bytes());
-
-            // Remember next base address.  If this allocation is zero-sized, leave a gap of at
-            // least 1 to avoid two allocations having the same base address. (The logic in
-            // `alloc_id_from_addr` assumes unique addresses, and different function/vtable pointers
-            // need to be distinguishable!)
-            global_state.next_base_addr = base_addr
-                .checked_add(max(info.size.bytes(), 1))
-                .ok_or_else(|| err_exhaust!(AddressSpaceFull))?;
-            // Even if `Size` didn't overflow, we might still have filled up the address space.
-            if global_state.next_base_addr > this.target_usize_max() {
-                throw_exhaust!(AddressSpaceFull);
-            }
+            let new_addr =
+                global_state.address_generator.generate(info.size, info.align, &mut rng)?;
+
             // If we filled up more than half the address space, start aggressively reusing
             // addresses to avoid running out.
-            if global_state.next_base_addr > u64::try_from(this.target_isize_max()).unwrap() {
+            let remaining_range = global_state.address_generator.get_remaining();
+            if remaining_range.start > remaining_range.end / 2 {
                 global_state.reuse.address_space_shortage();
             }
 
-            interp_ok(base_addr)
+            interp_ok(new_addr)
         }
     }
 }
@@ -519,14 +493,3 @@ impl<'tcx> MiriMachine<'tcx> {
         })
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_align_addr() {
-        assert_eq!(align_addr(37, 4), 40);
-        assert_eq!(align_addr(44, 4), 44);
-    }
-}
diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index 8f0814a070cbf..9482769a2fc79 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -674,11 +674,13 @@ impl<'tcx> MiriMachine<'tcx> {
             thread_cpu_affinity
                 .insert(threads.active_thread(), CpuAffinityMask::new(&layout_cx, config.num_cpus));
         }
+        let alloc_addresses =
+            RefCell::new(alloc_addresses::GlobalStateInner::new(config, stack_addr, tcx));
         MiriMachine {
             tcx,
             borrow_tracker,
             data_race,
-            alloc_addresses: RefCell::new(alloc_addresses::GlobalStateInner::new(config, stack_addr)),
+            alloc_addresses,
             // `env_vars` depends on a full interpreter so we cannot properly initialize it yet.
             env_vars: EnvVars::default(),
             main_fn_ret_place: None,

From c1be740564dd4a3aaafca93539ca428223226278 Mon Sep 17 00:00:00 2001
From: Patrick-6 <pamu99@gmx.ch>
Date: Mon, 14 Apr 2025 08:53:50 +0200
Subject: [PATCH 0452/1889] Implement basic support for running Miri with
 GenMC. - Implement memory allocation compatible with GenMC.   - Extract
 address generator struct from Miri's allocator. - Support thread creation and
 joining. - Support atomic load and store. - Support scheduling through GenMC.
 - Add tests for GenMC mode. - Add clang-format file for C++ code in Miri. -
 Update genmc-sys crate license to MIT/Apache to match GenMC dependency. - Add
 documentation for GenMC mode.

Note: this commit depends on changes to GenMC not yet upstreamed to its official repository.

Co-authored-by: Ralf Jung <post@ralfj.de>
---
 src/tools/miri/Cargo.lock                     |  24 +-
 src/tools/miri/Cargo.toml                     |   2 +-
 src/tools/miri/doc/genmc.md                   |  28 +-
 src/tools/miri/genmc-sys/.clang-format        |  52 ++
 src/tools/miri/genmc-sys/Cargo.toml           |   8 +-
 src/tools/miri/genmc-sys/build.rs             |  42 +-
 .../genmc-sys/cpp/include/MiriInterface.hpp   | 274 +++++++
 .../genmc-sys/cpp/include/ResultHandling.hpp  |  21 +
 .../cpp/src/MiriInterface/EventHandling.cpp   | 120 +++
 .../cpp/src/MiriInterface/Exploration.cpp     |  42 +
 .../genmc-sys/cpp/src/MiriInterface/Setup.cpp | 185 +++++
 .../src/MiriInterface/ThreadManagement.cpp    |  54 ++
 src/tools/miri/genmc-sys/src/lib.rs           | 297 ++++++-
 .../miri/genmc-sys/src_cpp/MiriInterface.cpp  |  50 --
 .../miri/genmc-sys/src_cpp/MiriInterface.hpp  |  44 -
 src/tools/miri/src/alloc_addresses/mod.rs     |  19 +-
 src/tools/miri/src/bin/miri.rs                |  22 +-
 .../src/borrow_tracker/stacked_borrows/mod.rs |   1 +
 src/tools/miri/src/concurrency/data_race.rs   |  69 +-
 .../miri/src/concurrency/genmc/config.rs      |  19 +-
 src/tools/miri/src/concurrency/genmc/dummy.rs | 120 +--
 .../concurrency/genmc/global_allocations.rs   | 118 +++
 .../miri/src/concurrency/genmc/helper.rs      |  97 +++
 src/tools/miri/src/concurrency/genmc/mod.rs   | 762 ++++++++++++++----
 src/tools/miri/src/concurrency/genmc/run.rs   |  71 ++
 .../miri/src/concurrency/genmc/scheduling.rs  |  69 ++
 .../src/concurrency/genmc/thread_id_map.rs    |  63 ++
 src/tools/miri/src/concurrency/init_once.rs   |   4 +-
 src/tools/miri/src/concurrency/mod.rs         |   2 +-
 src/tools/miri/src/concurrency/thread.rs      |  53 +-
 src/tools/miri/src/diagnostics.rs             |  17 +-
 src/tools/miri/src/eval.rs                    |  30 +-
 src/tools/miri/src/lib.rs                     |   2 +-
 src/tools/miri/src/machine.rs                 |   7 +-
 src/tools/miri/src/shims/foreign_items.rs     |  11 +-
 .../miri/src/shims/unix/linux_like/epoll.rs   |   2 +-
 .../miri/src/shims/unix/linux_like/eventfd.rs |   2 +-
 .../miri/src/shims/unix/unnamed_socket.rs     |   2 +-
 src/tools/miri/src/shims/windows/sync.rs      |   2 +-
 .../data_race/weak_orderings.rel_rlx.stderr   |  19 +
 .../data_race/weak_orderings.rlx_acq.stderr   |  19 +
 .../data_race/weak_orderings.rlx_rlx.stderr   |  19 +
 .../genmc/fail/data_race/weak_orderings.rs    |  40 +
 .../fail/simple/2w2w_weak.relaxed4.stderr     |  15 +
 .../fail/simple/2w2w_weak.release4.stderr     |  15 +
 .../miri/tests/genmc/fail/simple/2w2w_weak.rs |  73 ++
 .../fail/simple/2w2w_weak.sc3_rel1.stderr     |  15 +
 .../miri/tests/genmc/pass/litmus/2cowr.rs     |  51 ++
 .../miri/tests/genmc/pass/litmus/2cowr.stderr |   2 +
 .../pass/litmus/2w2w_3sc_1rel.release1.stderr |   2 +
 .../pass/litmus/2w2w_3sc_1rel.release2.stderr |   2 +
 .../tests/genmc/pass/litmus/2w2w_3sc_1rel.rs  |  54 ++
 .../miri/tests/genmc/pass/litmus/2w2w_4rel.rs |  45 ++
 .../tests/genmc/pass/litmus/2w2w_4rel.stderr  |   2 +
 .../miri/tests/genmc/pass/litmus/2w2w_4sc.rs  |  45 ++
 .../tests/genmc/pass/litmus/2w2w_4sc.stderr   |   2 +
 .../tests/genmc/pass/litmus/IRIW-acq-sc.rs    |  64 ++
 .../genmc/pass/litmus/IRIW-acq-sc.stderr      |   2 +
 src/tools/miri/tests/genmc/pass/litmus/LB.rs  |  47 ++
 .../miri/tests/genmc/pass/litmus/LB.stderr    |   2 +
 src/tools/miri/tests/genmc/pass/litmus/MP.rs  |  47 ++
 .../miri/tests/genmc/pass/litmus/MP.stderr    |   2 +
 src/tools/miri/tests/genmc/pass/litmus/SB.rs  |  47 ++
 .../miri/tests/genmc/pass/litmus/SB.stderr    |   2 +
 .../miri/tests/genmc/pass/litmus/corr.rs      |  45 ++
 .../miri/tests/genmc/pass/litmus/corr.stderr  |   2 +
 .../miri/tests/genmc/pass/litmus/corr0.rs     |  46 ++
 .../miri/tests/genmc/pass/litmus/corr0.stderr |   2 +
 .../miri/tests/genmc/pass/litmus/corr1.rs     |  58 ++
 .../miri/tests/genmc/pass/litmus/corr1.stderr |   2 +
 .../miri/tests/genmc/pass/litmus/corr2.rs     |  70 ++
 .../miri/tests/genmc/pass/litmus/corr2.stderr |   2 +
 .../miri/tests/genmc/pass/litmus/corw.rs      |  43 +
 .../miri/tests/genmc/pass/litmus/corw.stderr  |   2 +
 .../miri/tests/genmc/pass/litmus/cowr.rs      |  40 +
 .../miri/tests/genmc/pass/litmus/cowr.stderr  |   2 +
 .../miri/tests/genmc/pass/litmus/default.rs   |  47 ++
 .../tests/genmc/pass/litmus/default.stderr    |   2 +
 .../genmc/pass/litmus/detour.join.stderr      |   2 +
 .../genmc/pass/litmus/detour.no_join.stderr   |   2 +
 .../miri/tests/genmc/pass/litmus/detour.rs    |  68 ++
 .../tests/genmc/pass/litmus/fr_w_w_w_reads.rs |  54 ++
 .../genmc/pass/litmus/fr_w_w_w_reads.stderr   |   2 +
 .../miri/tests/genmc/pass/test_cxx_build.rs   |   8 -
 .../tests/genmc/pass/test_cxx_build.stderr    |   5 -
 src/tools/miri/tests/utils/genmc.rs           |  57 ++
 86 files changed, 3572 insertions(+), 429 deletions(-)
 create mode 100644 src/tools/miri/genmc-sys/.clang-format
 create mode 100644 src/tools/miri/genmc-sys/cpp/include/MiriInterface.hpp
 create mode 100644 src/tools/miri/genmc-sys/cpp/include/ResultHandling.hpp
 create mode 100644 src/tools/miri/genmc-sys/cpp/src/MiriInterface/EventHandling.cpp
 create mode 100644 src/tools/miri/genmc-sys/cpp/src/MiriInterface/Exploration.cpp
 create mode 100644 src/tools/miri/genmc-sys/cpp/src/MiriInterface/Setup.cpp
 create mode 100644 src/tools/miri/genmc-sys/cpp/src/MiriInterface/ThreadManagement.cpp
 delete mode 100644 src/tools/miri/genmc-sys/src_cpp/MiriInterface.cpp
 delete mode 100644 src/tools/miri/genmc-sys/src_cpp/MiriInterface.hpp
 create mode 100644 src/tools/miri/src/concurrency/genmc/global_allocations.rs
 create mode 100644 src/tools/miri/src/concurrency/genmc/helper.rs
 create mode 100644 src/tools/miri/src/concurrency/genmc/run.rs
 create mode 100644 src/tools/miri/src/concurrency/genmc/scheduling.rs
 create mode 100644 src/tools/miri/src/concurrency/genmc/thread_id_map.rs
 create mode 100644 src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rel_rlx.stderr
 create mode 100644 src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rlx_acq.stderr
 create mode 100644 src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rlx_rlx.stderr
 create mode 100644 src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rs
 create mode 100644 src/tools/miri/tests/genmc/fail/simple/2w2w_weak.relaxed4.stderr
 create mode 100644 src/tools/miri/tests/genmc/fail/simple/2w2w_weak.release4.stderr
 create mode 100644 src/tools/miri/tests/genmc/fail/simple/2w2w_weak.rs
 create mode 100644 src/tools/miri/tests/genmc/fail/simple/2w2w_weak.sc3_rel1.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/2cowr.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/2cowr.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/2w2w_3sc_1rel.release1.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/2w2w_3sc_1rel.release2.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/2w2w_3sc_1rel.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/2w2w_4rel.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/2w2w_4rel.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/2w2w_4sc.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/2w2w_4sc.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/IRIW-acq-sc.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/IRIW-acq-sc.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/LB.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/LB.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/MP.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/MP.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/SB.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/SB.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/corr.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/corr.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/corr0.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/corr0.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/corr1.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/corr1.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/corr2.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/corr2.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/corw.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/corw.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/cowr.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/cowr.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/default.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/default.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/detour.join.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/detour.no_join.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/detour.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/fr_w_w_w_reads.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/fr_w_w_w_reads.stderr
 delete mode 100644 src/tools/miri/tests/genmc/pass/test_cxx_build.rs
 delete mode 100644 src/tools/miri/tests/genmc/pass/test_cxx_build.stderr
 create mode 100644 src/tools/miri/tests/utils/genmc.rs

diff --git a/src/tools/miri/Cargo.lock b/src/tools/miri/Cargo.lock
index ece51f2ba74af..c4280f5e87a6d 100644
--- a/src/tools/miri/Cargo.lock
+++ b/src/tools/miri/Cargo.lock
@@ -363,9 +363,9 @@ dependencies = [
 
 [[package]]
 name = "cxx"
-version = "1.0.161"
+version = "1.0.173"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3523cc02ad831111491dd64b27ad999f1ae189986728e477604e61b81f828df"
+checksum = "6c64ed3da1c337cbaae7223cdcff8b4dddf698d188cd3eaddd1116f6b0295950"
 dependencies = [
  "cc",
  "cxxbridge-cmd",
@@ -377,9 +377,9 @@ dependencies = [
 
 [[package]]
 name = "cxx-build"
-version = "1.0.161"
+version = "1.0.173"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "212b754247a6f07b10fa626628c157593f0abf640a3dd04cce2760eca970f909"
+checksum = "ae0a26a75a05551f5ae3d75b3557543d06682284eaa7419113162d602cb45766"
 dependencies = [
  "cc",
  "codespan-reporting",
@@ -392,9 +392,9 @@ dependencies = [
 
 [[package]]
 name = "cxxbridge-cmd"
-version = "1.0.161"
+version = "1.0.173"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f426a20413ec2e742520ba6837c9324b55ffac24ead47491a6e29f933c5b135a"
+checksum = "952d408b6002b7db4b36da07c682a9cbb34f2db0efa03e976ae50a388414e16c"
 dependencies = [
  "clap",
  "codespan-reporting",
@@ -406,15 +406,15 @@ dependencies = [
 
 [[package]]
 name = "cxxbridge-flags"
-version = "1.0.161"
+version = "1.0.173"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a258b6069020b4e5da6415df94a50ee4f586a6c38b037a180e940a43d06a070d"
+checksum = "ccbd201b471c75c6abb6321cace706d1982d270e308b891c11a3262d320f5265"
 
 [[package]]
 name = "cxxbridge-macro"
-version = "1.0.161"
+version = "1.0.173"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8dec184b52be5008d6eaf7e62fc1802caf1ad1227d11b3b7df2c409c7ffc3f4"
+checksum = "2bea8b915bbc4cb4288f242aa7ca18b23ecc6965e4d6e7c1b07905e3fe2e0c41"
 dependencies = [
  "indexmap",
  "proc-macro2",
@@ -501,9 +501,9 @@ checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
 [[package]]
 name = "foldhash"
-version = "0.1.5"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
 
 [[package]]
 name = "form_urlencoded"
diff --git a/src/tools/miri/Cargo.toml b/src/tools/miri/Cargo.toml
index 91dadf78a2f72..5afde9b23d5cf 100644
--- a/src/tools/miri/Cargo.toml
+++ b/src/tools/miri/Cargo.toml
@@ -70,7 +70,7 @@ harness = false
 
 [features]
 default = ["stack-cache", "native-lib"]
-genmc = ["dep:genmc-sys"] # this enables a GPL dependency!
+genmc = ["dep:genmc-sys"]
 stack-cache = []
 stack-cache-consistency-check = ["stack-cache"]
 tracing = ["serde_json"]
diff --git a/src/tools/miri/doc/genmc.md b/src/tools/miri/doc/genmc.md
index 5aabe90b5dab2..fdbf2defe42dc 100644
--- a/src/tools/miri/doc/genmc.md
+++ b/src/tools/miri/doc/genmc.md
@@ -9,9 +9,7 @@ Miri-GenMC integrates that model checker into Miri.
 
 ## Usage
 
-**IMPORTANT: The license of GenMC and thus the `genmc-sys` crate in the Miri repo is currently "GPL-3.0-or-later", so a binary produced with the `genmc` feature is subject to the requirements of the GPL. As long as that remains the case, the `genmc` feature of Miri is OFF-BY-DEFAULT and must be OFF for all Miri releases.**
-
-For testing/developing Miri-GenMC (while keeping in mind the licensing issues):
+For testing/developing Miri-GenMC:
 - clone the Miri repo.
 - build Miri-GenMC with `./miri build --features=genmc`.
 - OR: install Miri-GenMC in the current system with `./miri install --features=genmc`
@@ -21,6 +19,21 @@ Basic usage:
 MIRIFLAGS="-Zmiri-genmc" cargo miri run
 ```
 
+Note that `cargo miri test` in GenMC mode is currently not supported.
+
+### Supported Parameters
+
+- `-Zmiri-genmc`: Enable GenMC mode (not required if any other GenMC options are used).
+- `-Zmiri-genmc-log=LOG_LEVEL`: Change the log level for GenMC. Default: `warning`.
+  - `quiet`:    Disable logging.
+  - `error`:    Print errors.
+  - `warning`:  Print errors and warnings.
+  - `tip`:      Print errors, warnings and tips.
+  - If Miri is built with debug assertions, there are additional log levels available (downgraded to `tip` without debug assertions):
+    - `debug1`:   Print revisits considered by GenMC.
+    - `debug2`:   Print the execution graph after every memory access.
+    - `debug3`:   Print reads-from values considered by GenMC.
+
 <!-- FIXME(genmc): explain options. -->
 
 <!-- FIXME(genmc): explain Miri-GenMC specific functions. -->
@@ -57,6 +70,15 @@ The process for obtaining them is as follows:
   If you place this directory inside the Miri folder, it is recommended to call it `genmc-src` as that tells `./miri fmt` to avoid
   formatting the Rust files inside that folder.
 
+### Formatting the C++ code
+
+For formatting the C++ code we provide a `.clang-format` file in the `genmc-sys` directory.
+With `clang-format` installed, run this command to format the c++ files (replace the `-i` with `--dry-run` to just see the changes.):
+```
+find ./genmc-sys/cpp/ -name "*.cpp" -o -name "*.hpp" | xargs clang-format --style=file:"./genmc-sys/.clang-format" -i
+```
+NOTE: this is currently not done automatically on pull requests to Miri.
+
 <!-- FIXME(genmc): explain how submitting code to GenMC should be handled. -->
 
 <!-- FIXME(genmc): explain development. -->
diff --git a/src/tools/miri/genmc-sys/.clang-format b/src/tools/miri/genmc-sys/.clang-format
new file mode 100644
index 0000000000000..669d76ea6c9bc
--- /dev/null
+++ b/src/tools/miri/genmc-sys/.clang-format
@@ -0,0 +1,52 @@
+# .clang-format
+
+BasedOnStyle: LLVM
+Standard: c++20
+
+ColumnLimit: 100
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AllowShortBlocksOnASingleLine: Empty
+BreakBeforeBraces: Attach
+
+BinPackArguments: false
+BinPackParameters: false
+AllowAllParametersOfDeclarationOnNextLine: false
+AlwaysBreakAfterReturnType: None
+
+# Force parameters to break and align
+AlignAfterOpenBracket: BlockIndent
+AllowAllArgumentsOnNextLine: false
+
+# Spacing around braces and parentheses
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceInEmptyBlock: false
+SpacesInContainerLiterals: true
+SpacesInParensOptions:
+  InCStyleCasts: false
+  InConditionalStatements: false
+  InEmptyParentheses: false
+  Other: false
+SpacesInSquareBrackets: false
+
+# Brace spacing for initializers
+Cpp11BracedListStyle: false
+SpaceBeforeCpp11BracedList: true
+
+# Import grouping: group standard, external, and project includes.
+IncludeBlocks: Regroup
+SortIncludes: true
+
+# Granularity: sort includes per module/file.
+IncludeIsMainRegex: '([-_](test|unittest))?$'
+
+# Miscellaneous
+SpaceAfterCStyleCast: true
+SpaceBeforeParens: ControlStatements
+PointerAlignment: Left
+IndentCaseLabels: true
+IndentWidth: 4
+TabWidth: 4
+UseTab: Never
\ No newline at end of file
diff --git a/src/tools/miri/genmc-sys/Cargo.toml b/src/tools/miri/genmc-sys/Cargo.toml
index 95aef75afc4f5..aa6374b7b373f 100644
--- a/src/tools/miri/genmc-sys/Cargo.toml
+++ b/src/tools/miri/genmc-sys/Cargo.toml
@@ -1,17 +1,15 @@
 [package]
 authors = ["Miri Team"]
-# The parts in this repo are MIT OR Apache-2.0, but we are linking in
-# code from https://github.com/MPI-SWS/genmc which is GPL-3.0-or-later.
-license = "(MIT OR Apache-2.0) AND GPL-3.0-or-later"
+license = "MIT OR Apache-2.0"
 name = "genmc-sys"
 version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-cxx = { version = "1.0.160", features = ["c++20"] }
+cxx = { version = "1.0.173", features = ["c++20"] }
 
 [build-dependencies]
 cc = "1.2.30"
 cmake = "0.1.54"
 git2 = { version = "0.20.2", default-features = false, features = ["https"] }
-cxx-build = { version = "1.0.160", features = ["parallel"] }
+cxx-build = { version = "1.0.173", features = ["parallel"] }
diff --git a/src/tools/miri/genmc-sys/build.rs b/src/tools/miri/genmc-sys/build.rs
index f20e0e8d525fc..af42c70431bf0 100644
--- a/src/tools/miri/genmc-sys/build.rs
+++ b/src/tools/miri/genmc-sys/build.rs
@@ -26,9 +26,9 @@ mod downloading {
     use super::GENMC_DOWNLOAD_PATH;
 
     /// The GenMC repository the we get our commit from.
-    pub(crate) const GENMC_GITHUB_URL: &str = "https://github.com/MPI-SWS/genmc.git";
+    pub(crate) const GENMC_GITHUB_URL: &str = "https://gitlab.inf.ethz.ch/public-plf/genmc.git";
     /// The GenMC commit we depend on. It must be available on the specified GenMC repository.
-    pub(crate) const GENMC_COMMIT: &str = "3438dd2c1202cd4a47ed7881d099abf23e4167ab";
+    pub(crate) const GENMC_COMMIT: &str = "af9cc9ccd5d412b16defc35dbf36571c63a19c76";
 
     pub(crate) fn download_genmc() -> PathBuf {
         let Ok(genmc_download_path) = PathBuf::from_str(GENMC_DOWNLOAD_PATH);
@@ -176,6 +176,11 @@ fn link_to_llvm(config_file: &Path) -> (String, String) {
 
 /// Build the GenMC model checker library and the Rust-C++ interop library with cxx.rs
 fn compile_cpp_dependencies(genmc_path: &Path) {
+    // Give each step a separate build directory to prevent interference.
+    let out_dir = PathBuf::from(std::env::var("OUT_DIR").as_deref().unwrap());
+    let genmc_build_dir = out_dir.join("genmc");
+    let interface_build_dir = out_dir.join("miri_genmc");
+
     // Part 1:
     // Compile the GenMC library using cmake.
 
@@ -186,8 +191,11 @@ fn compile_cpp_dependencies(genmc_path: &Path) {
     let enable_genmc_debug = matches!(std::env::var("PROFILE").as_deref().unwrap(), "debug");
 
     let mut config = cmake::Config::new(cmakelists_path);
-    config.profile(GENMC_CMAKE_PROFILE);
-    config.define("GENMC_DEBUG", if enable_genmc_debug { "ON" } else { "OFF" });
+    config
+        .always_configure(false) // We don't need to reconfigure on subsequent compilation runs.
+        .out_dir(genmc_build_dir)
+        .profile(GENMC_CMAKE_PROFILE)
+        .define("GENMC_DEBUG", if enable_genmc_debug { "ON" } else { "OFF" });
 
     // The actual compilation happens here:
     let genmc_install_dir = config.build();
@@ -210,6 +218,13 @@ fn compile_cpp_dependencies(genmc_path: &Path) {
     // These definitions are parsed into a cmake list and then printed to the config.h file, so they are ';' separated.
     let definitions = llvm_definitions.split(";");
 
+    let cpp_files = [
+        "./cpp/src/MiriInterface/EventHandling.cpp",
+        "./cpp/src/MiriInterface/Exploration.cpp",
+        "./cpp/src/MiriInterface/Setup.cpp",
+        "./cpp/src/MiriInterface/ThreadManagement.cpp",
+    ];
+
     let mut bridge = cxx_build::bridge("src/lib.rs");
     // FIXME(genmc,cmake): Remove once the GenMC debug setting is available in the config.h file.
     if enable_genmc_debug {
@@ -223,9 +238,9 @@ fn compile_cpp_dependencies(genmc_path: &Path) {
         .std("c++23")
         .include(genmc_include_dir)
         .include(llvm_include_dirs)
-        .include("./src_cpp")
-        .file("./src_cpp/MiriInterface.hpp")
-        .file("./src_cpp/MiriInterface.cpp")
+        .include("./cpp/include")
+        .files(&cpp_files)
+        .out_dir(interface_build_dir)
         .compile("genmc_interop");
 
     // Link the Rust-C++ interface library generated by cxx_build:
@@ -233,15 +248,8 @@ fn compile_cpp_dependencies(genmc_path: &Path) {
 }
 
 fn main() {
-    // Make sure we don't accidentally distribute a binary with GPL code.
-    if option_env!("RUSTC_STAGE").is_some() {
-        panic!(
-            "genmc should not be enabled in the rustc workspace since it includes a GPL dependency"
-        );
-    }
-
     // Select which path to use for the GenMC repo:
-    let genmc_path = if let Ok(genmc_src_path) = std::env::var("GENMC_SRC_PATH") {
+    let genmc_path = if let Some(genmc_src_path) = option_env!("GENMC_SRC_PATH") {
         let genmc_src_path =
             PathBuf::from_str(&genmc_src_path).expect("GENMC_SRC_PATH should contain a valid path");
         assert!(
@@ -249,6 +257,8 @@ fn main() {
             "GENMC_SRC_PATH={} does not exist!",
             genmc_src_path.display()
         );
+        // Rebuild files in the given path change.
+        println!("cargo::rerun-if-changed={}", genmc_src_path.display());
         genmc_src_path
     } else {
         downloading::download_genmc()
@@ -263,5 +273,5 @@ fn main() {
     // cloned (since cargo detects that as a file modification).
     println!("cargo::rerun-if-changed={RUST_CXX_BRIDGE_FILE_PATH}");
     println!("cargo::rerun-if-changed=./src");
-    println!("cargo::rerun-if-changed=./src_cpp");
+    println!("cargo::rerun-if-changed=./cpp");
 }
diff --git a/src/tools/miri/genmc-sys/cpp/include/MiriInterface.hpp b/src/tools/miri/genmc-sys/cpp/include/MiriInterface.hpp
new file mode 100644
index 0000000000000..4484f0b73caec
--- /dev/null
+++ b/src/tools/miri/genmc-sys/cpp/include/MiriInterface.hpp
@@ -0,0 +1,274 @@
+#ifndef GENMC_MIRI_INTERFACE_HPP
+#define GENMC_MIRI_INTERFACE_HPP
+
+// CXX.rs generated headers:
+#include "rust/cxx.h"
+
+// GenMC generated headers:
+#include "config.h"
+
+// Miri `genmc-sys/src_cpp` headers:
+#include "ResultHandling.hpp"
+
+// GenMC headers:
+#include "ExecutionGraph/EventLabel.hpp"
+#include "Static/ModuleID.hpp"
+#include "Support/MemOrdering.hpp"
+#include "Support/RMWOps.hpp"
+#include "Verification/Config.hpp"
+#include "Verification/GenMCDriver.hpp"
+
+// C++ headers:
+#include <cstdint>
+#include <format>
+#include <iomanip>
+#include <memory>
+
+/**** Types available to both Rust and C++ ****/
+
+struct GenmcParams;
+enum class LogLevel : std::uint8_t;
+
+struct GenmcScalar;
+struct SchedulingResult;
+struct LoadResult;
+struct StoreResult;
+
+// GenMC uses `int` for its thread IDs.
+using ThreadId = int;
+
+/// Set the log level for GenMC.
+///
+/// # Safety
+///
+/// This function is not thread safe, since it writes to the global, mutable, non-atomic `logLevel`
+/// variable. Any GenMC function may read from `logLevel` unsynchronized.
+/// The safest way to use this function is to set the log level exactly once before first calling
+/// `create_handle`.
+/// Never calling this function is safe, GenMC will fall back to its default log level.
+/* unsafe */ void set_log_level_raw(LogLevel log_level);
+
+struct MiriGenmcShim : private GenMCDriver {
+
+  public:
+    MiriGenmcShim(std::shared_ptr<const Config> conf, Mode mode /* = VerificationMode{} */)
+        : GenMCDriver(std::move(conf), nullptr, mode) {}
+
+    /// Create a new `MiriGenmcShim`, which wraps a `GenMCDriver`.
+    ///
+    /// # Safety
+    ///
+    /// This function is marked as unsafe since the `logLevel` global variable is non-atomic.
+    /// This function should not be called in an unsynchronized way with `set_log_level_raw`,
+    /// since this function and any methods on the returned `MiriGenmcShim` may read the
+    /// `logLevel`, causing a data race. The safest way to use these functions is to call
+    /// `set_log_level_raw` once, and only then start creating handles. There should not be any
+    /// other (safe) way to create a `MiriGenmcShim`.
+    /* unsafe */ static auto create_handle(const GenmcParams& params)
+        -> std::unique_ptr<MiriGenmcShim>;
+
+    virtual ~MiriGenmcShim() {}
+
+    /**** Execution start/end handling ****/
+
+    // This function must be called at the start of any execution, before any events are
+    // reported to GenMC.
+    void handle_execution_start();
+    // This function must be called at the end of any execution, even if an error was found
+    // during the execution.
+    // Returns `null`, or a string containing an error message if an error occured.
+    std::unique_ptr<std::string> handle_execution_end();
+
+    /***** Functions for handling events encountered during program execution. *****/
+
+    /**** Memory access handling ****/
+
+    [[nodiscard]] LoadResult handle_load(
+        ThreadId thread_id,
+        uint64_t address,
+        uint64_t size,
+        MemOrdering ord,
+        GenmcScalar old_val
+    );
+    [[nodiscard]] StoreResult handle_store(
+        ThreadId thread_id,
+        uint64_t address,
+        uint64_t size,
+        GenmcScalar value,
+        GenmcScalar old_val,
+        MemOrdering ord
+    );
+
+    /**** Memory (de)allocation ****/
+    auto handle_malloc(ThreadId thread_id, uint64_t size, uint64_t alignment) -> uint64_t;
+    void handle_free(ThreadId thread_id, uint64_t address);
+
+    /**** Thread management ****/
+    void handle_thread_create(ThreadId thread_id, ThreadId parent_id);
+    void handle_thread_join(ThreadId thread_id, ThreadId child_id);
+    void handle_thread_finish(ThreadId thread_id, uint64_t ret_val);
+    void handle_thread_kill(ThreadId thread_id);
+
+    /***** Exploration related functionality *****/
+
+    /** Ask the GenMC scheduler for a new thread to schedule and return whether the execution is
+     * finished, blocked, or can continue.
+     * Updates the next instruction kind for the given thread id. */
+    auto schedule_next(const int curr_thread_id, const ActionKind curr_thread_next_instr_kind)
+        -> SchedulingResult;
+
+    /**
+     * Check whether there are more executions to explore.
+     * If there are more executions, this method prepares for the next execution and returns
+     * `true`. Returns true if there are no more executions to explore. */
+    auto is_exploration_done() -> bool {
+        return GenMCDriver::done();
+    }
+
+    /**** Result querying functionality. ****/
+
+    // NOTE: We don't want to share the `VerificationResult` type with the Rust side, since it
+    // is very large, uses features that CXX.rs doesn't support and may change as GenMC changes.
+    // Instead, we only use the result on the C++ side, and only expose these getter function to
+    // the Rust side.
+
+    // Note that CXX.rs doesn't support returning a C++ string to Rust by value,
+    // it must be behind an indirection like a `unique_ptr` (tested with CXX 1.0.170).
+
+    /// Get the number of blocked executions encountered by GenMC (cast into a fixed with
+    /// integer)
+    auto get_blocked_execution_count() const -> uint64_t {
+        return static_cast<uint64_t>(getResult().exploredBlocked);
+    }
+
+    /// Get the number of executions explored by GenMC (cast into a fixed with integer)
+    auto get_explored_execution_count() const -> uint64_t {
+        return static_cast<uint64_t>(getResult().explored);
+    }
+
+    /// Get all messages that GenMC produced (errors, warnings), combined into one string.
+    auto get_result_message() const -> std::unique_ptr<std::string> {
+        return std::make_unique<std::string>(getResult().message);
+    }
+
+    /// If an error occurred, return a string describing the error, otherwise, return `nullptr`.
+    auto get_error_string() const -> std::unique_ptr<std::string> {
+        const auto& result = GenMCDriver::getResult();
+        if (result.status.has_value())
+            return format_error(result.status.value());
+        return nullptr;
+    }
+
+  private:
+    /** Increment the event index in the given thread by 1 and return the new event. */
+    [[nodiscard]] inline auto inc_pos(ThreadId tid) -> Event {
+        ERROR_ON(tid >= threads_action_.size(), "ThreadId out of bounds");
+        return ++threads_action_[tid].event;
+    }
+    /** Decrement the event index in the given thread by 1 and return the new event. */
+    inline auto dec_pos(ThreadId tid) -> Event {
+        ERROR_ON(tid >= threads_action_.size(), "ThreadId out of bounds");
+        return --threads_action_[tid].event;
+    }
+
+    /**
+     * Helper function for loads that need to reset the event counter when no value is returned.
+     * Same syntax as `GenMCDriver::handleLoad`, but this takes a thread id instead of an Event.
+     * Automatically calls `inc_pos` and `dec_pos` where needed for the given thread.
+     */
+    template <EventLabel::EventLabelKind k, typename... Ts>
+    auto handle_load_reset_if_none(ThreadId tid, Ts&&... params) -> HandleResult<SVal> {
+        const auto pos = inc_pos(tid);
+        const auto ret = GenMCDriver::handleLoad<k>(pos, std::forward<Ts>(params)...);
+        // If we didn't get a value, we have to reset the index of the current thread.
+        if (!std::holds_alternative<SVal>(ret)) {
+            dec_pos(tid);
+        }
+        return ret;
+    }
+
+    /**
+     * GenMC uses the term `Action` to refer to a struct of:
+     * - `ActionKind`, storing whether the next instruction in a thread may be a load
+     * - `Event`, storing the most recent event index added for a thread
+     *
+     * Here we store the "action" for each thread. In particular we use this to assign event
+     * indices, since GenMC expects us to do that.
+     */
+    std::vector<Action> threads_action_;
+};
+
+/// Get the bit mask that GenMC expects for global memory allocations.
+/// FIXME(genmc): currently we use `get_global_alloc_static_mask()` to ensure the
+/// `SAddr::staticMask` constant is consistent between Miri and GenMC, but if
+/// https://github.com/dtolnay/cxx/issues/1051 is fixed we could share the constant
+///   directly.
+constexpr auto get_global_alloc_static_mask() -> uint64_t {
+    return SAddr::staticMask;
+}
+
+// CXX.rs generated headers:
+// NOTE: this must be included *after* `MiriGenmcShim` and all the other types we use are defined,
+// otherwise there will be compilation errors due to missing definitions.
+#include "genmc-sys/src/lib.rs.h"
+
+/**** Result handling ****/
+// NOTE: these must come after the cxx_bridge generated code, since that contains the actual
+// definitions of these types.
+
+namespace GenmcScalarExt {
+inline GenmcScalar uninit() {
+    return GenmcScalar {
+        /* value: */ 0,
+        /* is_init: */ false,
+    };
+}
+
+inline GenmcScalar from_sval(SVal sval) {
+    return GenmcScalar {
+        /* value: */ sval.get(),
+        /* is_init: */ true,
+    };
+}
+
+inline SVal to_sval(GenmcScalar scalar) {
+    ERROR_ON(!scalar.is_init, "Cannot convert an uninitialized `GenmcScalar` into an `SVal`\n");
+    return SVal(scalar.value);
+}
+} // namespace GenmcScalarExt
+
+namespace LoadResultExt {
+inline LoadResult no_value() {
+    return LoadResult {
+        /* error: */ std::unique_ptr<std::string>(nullptr),
+        /* has_value: */ false,
+        /* read_value: */ GenmcScalarExt::uninit(),
+    };
+}
+
+inline LoadResult from_value(SVal read_value) {
+    return LoadResult { /* error: */ std::unique_ptr<std::string>(nullptr),
+                        /* has_value: */ true,
+                        /* read_value: */ GenmcScalarExt::from_sval(read_value) };
+}
+
+inline LoadResult from_error(std::unique_ptr<std::string> error) {
+    return LoadResult { /* error: */ std::move(error),
+                        /* has_value: */ false,
+                        /* read_value: */ GenmcScalarExt::uninit() };
+}
+} // namespace LoadResultExt
+
+namespace StoreResultExt {
+inline StoreResult ok(bool is_coherence_order_maximal_write) {
+    return StoreResult { /* error: */ std::unique_ptr<std::string>(nullptr),
+                         is_coherence_order_maximal_write };
+}
+
+inline StoreResult from_error(std::unique_ptr<std::string> error) {
+    return StoreResult { /* error: */ std::move(error),
+                         /* is_coherence_order_maximal_write: */ false };
+}
+} // namespace StoreResultExt
+
+#endif /* GENMC_MIRI_INTERFACE_HPP */
diff --git a/src/tools/miri/genmc-sys/cpp/include/ResultHandling.hpp b/src/tools/miri/genmc-sys/cpp/include/ResultHandling.hpp
new file mode 100644
index 0000000000000..189f32e6f513d
--- /dev/null
+++ b/src/tools/miri/genmc-sys/cpp/include/ResultHandling.hpp
@@ -0,0 +1,21 @@
+#ifndef GENMC_RESULT_HANDLING_HPP
+#define GENMC_RESULT_HANDLING_HPP
+
+// CXX.rs generated headers:
+#include "rust/cxx.h"
+
+// GenMC headers:
+#include "Verification/VerificationError.hpp"
+
+#include <string>
+
+/** Information about an error, formatted as a string to avoid having to share an error enum and
+ * printing functionality with the Rust side. */
+static auto format_error(VerificationError err) -> std::unique_ptr<std::string> {
+    auto buf = std::string();
+    auto s = llvm::raw_string_ostream(buf);
+    s << err;
+    return std::make_unique<std::string>(s.str());
+}
+
+#endif /* GENMC_RESULT_HANDLING_HPP */
diff --git a/src/tools/miri/genmc-sys/cpp/src/MiriInterface/EventHandling.cpp b/src/tools/miri/genmc-sys/cpp/src/MiriInterface/EventHandling.cpp
new file mode 100644
index 0000000000000..7d8f0b16b49ab
--- /dev/null
+++ b/src/tools/miri/genmc-sys/cpp/src/MiriInterface/EventHandling.cpp
@@ -0,0 +1,120 @@
+/** This file contains functionality related to handling events encountered
+ * during an execution, such as loads, stores or memory (de)allocation. */
+
+#include "MiriInterface.hpp"
+
+// CXX.rs generated headers:
+#include "genmc-sys/src/lib.rs.h"
+
+// GenMC headers:
+#include "ADT/value_ptr.hpp"
+#include "ExecutionGraph/EventLabel.hpp"
+#include "ExecutionGraph/LoadAnnotation.hpp"
+#include "Runtime/InterpreterEnumAPI.hpp"
+#include "Static/ModuleID.hpp"
+#include "Support/ASize.hpp"
+#include "Support/Error.hpp"
+#include "Support/Logger.hpp"
+#include "Support/MemAccess.hpp"
+#include "Support/RMWOps.hpp"
+#include "Support/SAddr.hpp"
+#include "Support/SVal.hpp"
+#include "Support/ThreadInfo.hpp"
+#include "Support/Verbosity.hpp"
+#include "Verification/GenMCDriver.hpp"
+#include "Verification/MemoryModel.hpp"
+
+// C++ headers:
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <utility>
+
+/**** Memory access handling ****/
+
+[[nodiscard]] auto MiriGenmcShim::handle_load(
+    ThreadId thread_id,
+    uint64_t address,
+    uint64_t size,
+    MemOrdering ord,
+    GenmcScalar old_val
+) -> LoadResult {
+    // `type` is only used for printing.
+    const auto type = AType::Unsigned;
+    const auto ret = handle_load_reset_if_none<EventLabel::EventLabelKind::Read>(
+        thread_id,
+        ord,
+        SAddr(address),
+        ASize(size),
+        type
+    );
+
+    if (const auto* err = std::get_if<VerificationError>(&ret))
+        return LoadResultExt::from_error(format_error(*err));
+    const auto* ret_val = std::get_if<SVal>(&ret);
+    if (ret_val == nullptr)
+        ERROR("Unimplemented: load returned unexpected result.");
+    return LoadResultExt::from_value(*ret_val);
+}
+
+[[nodiscard]] auto MiriGenmcShim::handle_store(
+    ThreadId thread_id,
+    uint64_t address,
+    uint64_t size,
+    GenmcScalar value,
+    GenmcScalar old_val,
+    MemOrdering ord
+) -> StoreResult {
+    const auto pos = inc_pos(thread_id);
+    const auto ret = GenMCDriver::handleStore<EventLabel::EventLabelKind::Write>(
+        pos,
+        ord,
+        SAddr(address),
+        ASize(size),
+        /* type */ AType::Unsigned, // `type` is only used for printing.
+        GenmcScalarExt::to_sval(value),
+        EventDeps()
+    );
+
+    if (const auto* err = std::get_if<VerificationError>(&ret))
+        return StoreResultExt::from_error(format_error(*err));
+    if (!std::holds_alternative<std::monostate>(ret))
+        ERROR("store returned unexpected result");
+
+    // FIXME(genmc,mixed-accesses): Use the value that GenMC returns from handleStore (once
+    // available).
+    const auto& g = getExec().getGraph();
+    return StoreResultExt::ok(
+        /* is_coherence_order_maximal_write */ g.co_max(SAddr(address))->getPos() == pos
+    );
+}
+
+/**** Memory (de)allocation ****/
+
+auto MiriGenmcShim::handle_malloc(ThreadId thread_id, uint64_t size, uint64_t alignment)
+    -> uint64_t {
+    const auto pos = inc_pos(thread_id);
+
+    // These are only used for printing and features Miri-GenMC doesn't support (yet).
+    const auto storage_duration = StorageDuration::SD_Heap;
+    // Volatile, as opposed to "persistent" (i.e., non-volatile memory that persists over reboots)
+    const auto storage_type = StorageType::ST_Volatile;
+    const auto address_space = AddressSpace::AS_User;
+
+    const SVal ret_val = GenMCDriver::handleMalloc(
+        pos,
+        size,
+        alignment,
+        storage_duration,
+        storage_type,
+        address_space,
+        EventDeps()
+    );
+    return ret_val.get();
+}
+
+void MiriGenmcShim::handle_free(ThreadId thread_id, uint64_t address) {
+    const auto pos = inc_pos(thread_id);
+    GenMCDriver::handleFree(pos, SAddr(address), EventDeps());
+    // FIXME(genmc): add error handling once GenMC returns errors from `handleFree`
+}
diff --git a/src/tools/miri/genmc-sys/cpp/src/MiriInterface/Exploration.cpp b/src/tools/miri/genmc-sys/cpp/src/MiriInterface/Exploration.cpp
new file mode 100644
index 0000000000000..c51b59e865170
--- /dev/null
+++ b/src/tools/miri/genmc-sys/cpp/src/MiriInterface/Exploration.cpp
@@ -0,0 +1,42 @@
+/** This file contains functionality related to exploration, such as scheduling.  */
+
+#include "MiriInterface.hpp"
+
+// CXX.rs generated headers:
+#include "genmc-sys/src/lib.rs.h"
+
+// GenMC headers:
+#include "Support/Error.hpp"
+#include "Support/Verbosity.hpp"
+
+// C++ headers:
+#include <cstdint>
+
+auto MiriGenmcShim::schedule_next(
+    const int curr_thread_id,
+    const ActionKind curr_thread_next_instr_kind
+) -> SchedulingResult {
+    // The current thread is the only one where the `kind` could have changed since we last made
+    // a scheduling decision.
+    threads_action_[curr_thread_id].kind = curr_thread_next_instr_kind;
+
+    if (const auto result = GenMCDriver::scheduleNext(threads_action_))
+        return SchedulingResult { ExecutionState::Ok, static_cast<int32_t>(result.value()) };
+    if (GenMCDriver::isExecutionBlocked())
+        return SchedulingResult { ExecutionState::Blocked, 0 };
+    return SchedulingResult { ExecutionState::Finished, 0 };
+}
+
+/**** Execution start/end handling ****/
+
+void MiriGenmcShim::handle_execution_start() {
+    threads_action_.clear();
+    threads_action_.push_back(Action(ActionKind::Load, Event::getInit()));
+    GenMCDriver::handleExecutionStart();
+}
+
+auto MiriGenmcShim::handle_execution_end() -> std::unique_ptr<std::string> {
+    // FIXME(genmc): add error handling once GenMC returns an error here.
+    GenMCDriver::handleExecutionEnd();
+    return {};
+}
diff --git a/src/tools/miri/genmc-sys/cpp/src/MiriInterface/Setup.cpp b/src/tools/miri/genmc-sys/cpp/src/MiriInterface/Setup.cpp
new file mode 100644
index 0000000000000..7194ed02da432
--- /dev/null
+++ b/src/tools/miri/genmc-sys/cpp/src/MiriInterface/Setup.cpp
@@ -0,0 +1,185 @@
+/** This file contains functionality related to creation of the GenMCDriver,
+ * including translating settings set by Miri.  */
+
+#include "MiriInterface.hpp"
+
+// CXX.rs generated headers:
+#include "genmc-sys/src/lib.rs.h"
+
+// GenMC headers:
+#include "Support/Error.hpp"
+#include "Support/Verbosity.hpp"
+#include "Verification/InterpreterCallbacks.hpp"
+
+// C++ headers:
+#include <cstdint>
+
+/**
+ * Translate the Miri-GenMC `LogLevel` to the GenMC `VerbosityLevel`.
+ * Downgrade any debug options to `Tip` if `ENABLE_GENMC_DEBUG` is not enabled.
+ */
+static auto to_genmc_verbosity_level(const LogLevel log_level) -> VerbosityLevel {
+    switch (log_level) {
+        case LogLevel::Quiet:
+            return VerbosityLevel::Quiet;
+        case LogLevel::Error:
+            return VerbosityLevel::Error;
+        case LogLevel::Warning:
+            return VerbosityLevel::Warning;
+        case LogLevel::Tip:
+            return VerbosityLevel::Tip;
+#ifdef ENABLE_GENMC_DEBUG
+        case LogLevel::Debug1Revisits:
+            return VerbosityLevel::Debug1;
+        case LogLevel::Debug2MemoryAccesses:
+            return VerbosityLevel::Debug2;
+        case LogLevel::Debug3ReadsFrom:
+            return VerbosityLevel::Debug3;
+#else
+        // Downgrade to `Tip` if the debug levels are not available.
+        case LogLevel::Debug1Revisits:
+        case LogLevel::Debug2MemoryAccesses:
+        case LogLevel::Debug3ReadsFrom:
+            return VerbosityLevel::Tip;
+#endif
+        default:
+            WARN_ONCE(
+                "unknown-log-level",
+                "Unknown `LogLevel`, defaulting to `VerbosityLevel::Tip`."
+            );
+            return VerbosityLevel::Tip;
+    }
+}
+
+/* unsafe */ void set_log_level_raw(LogLevel log_level) {
+    // The `logLevel` is a static, non-atomic variable.
+    // It should never be changed if `MiriGenmcShim` still exists, since any of its methods may read
+    // the `logLevel`, otherwise it may cause data races.
+    logLevel = to_genmc_verbosity_level(log_level);
+}
+
+/* unsafe */ auto MiriGenmcShim::create_handle(const GenmcParams& params)
+    -> std::unique_ptr<MiriGenmcShim> {
+    auto conf = std::make_shared<Config>();
+
+    // Set whether GenMC should print execution graphs after every explored/blocked execution.
+    // FIXME(genmc): pass these settings from Miri.
+    conf->printExecGraphs = false;
+    conf->printBlockedExecs = false;
+
+    // `1024` is the default value that GenMC uses.
+    // If any thread has at least this many events, a warning/tip will be printed.
+    //
+    // Miri produces a lot more events than GenMC, so the graph size warning triggers on almost
+    // all programs. The current value is large enough so the warning is not be triggered by any
+    // reasonable programs.
+    // FIXME(genmc): The emitted warning mentions features not supported by Miri ('--unroll'
+    // parameter).
+    // FIXME(genmc): A more appropriate limit should be chosen once the warning is useful for
+    // Miri.
+    conf->warnOnGraphSize = 1024 * 1024;
+
+    // We only support the RC11 memory model for Rust.
+    conf->model = ModelType::RC11;
+
+    // This prints the seed that GenMC picks for randomized scheduling during estimation mode.
+    conf->printRandomScheduleSeed = params.print_random_schedule_seed;
+
+    // FIXME(genmc): supporting IPR requires annotations for `assume` and `spinloops`.
+    conf->ipr = false;
+    // FIXME(genmc): supporting BAM requires `Barrier` support + detecting whether return value
+    // of barriers are used.
+    conf->disableBAM = true;
+
+    // Instruction caching could help speed up verification by filling the graph from cache, if
+    // the list of values read by all load events in a thread have been seen before. Combined
+    // with not replaying completed threads, this can also reducing the amount of Mir
+    // interpretation required by Miri. With the current setup, this would be incorrect, since
+    // Miri doesn't give GenMC the actual values read by non-atomic reads.
+    conf->instructionCaching = false;
+    // Many of Miri's checks work under the assumption that threads are only executed in an
+    // order that could actually happen during a normal execution. Formally, this means that
+    // replaying an execution needs to respect the po-rf-relation of the executiongraph (po ==
+    // program-order, rf == reads-from). This means, any event in the graph, when replayed, must
+    // happen after any events that happen before it in the same graph according to the program
+    // code, and all (non-atomic) reads must happen after the write event they read from.
+    //
+    // Not replaying completed threads means any read event from that thread never happens in
+    // Miri's memory, so this would only work if there are never any non-atomic reads from any
+    // value written by the skipped thread.
+    conf->replayCompletedThreads = true;
+
+    // FIXME(genmc): implement symmetry reduction.
+    ERROR_ON(
+        params.do_symmetry_reduction,
+        "Symmetry reduction is currently unsupported in GenMC mode."
+    );
+    conf->symmetryReduction = params.do_symmetry_reduction;
+
+    // FIXME(genmc): expose this setting to Miri (useful for testing Miri-GenMC).
+    conf->schedulePolicy = SchedulePolicy::WF;
+
+    // Set the mode used for this driver, either estimation or verification.
+    // FIXME(genmc): implement estimation mode.
+    const auto mode = GenMCDriver::Mode(GenMCDriver::VerificationMode {});
+
+    // Running Miri-GenMC without race detection is not supported.
+    // Disabling this option also changes the behavior of the replay scheduler to only schedule
+    // at atomic operations, which is required with Miri. This happens because Miri can generate
+    // multiple GenMC events for a single MIR terminator. Without this option, the scheduler
+    // might incorrectly schedule an atomic MIR terminator because the first event it creates is
+    // a non-atomic (e.g., `StorageLive`).
+    conf->disableRaceDetection = false;
+
+    // Miri can already check for unfreed memory. Also, GenMC cannot distinguish between memory
+    // that is allowed to leak and memory that is not.
+    conf->warnUnfreedMemory = false;
+
+    // FIXME(genmc,error handling): This function currently exits on error, but will return an
+    // error value in the future. The return value should be checked once this change is made.
+    checkConfig(*conf);
+
+    // Create the actual driver and Miri-GenMC communication shim.
+    auto driver = std::make_unique<MiriGenmcShim>(std::move(conf), mode);
+
+    // FIXME(genmc,HACK): Until a proper solution is implemented in GenMC, these callbacks will
+    // allow Miri to return information about global allocations and override uninitialized memory
+    // checks for non-atomic loads (Miri handles those without GenMC, so the error would be wrong).
+    auto interpreter_callbacks = InterpreterCallbacks {
+        // Miri already ensures that memory accesses are valid, so this check doesn't matter.
+        // We check that the address is static, but skip checking if it is part of an actual
+        // allocation.
+        /* isStaticallyAllocated: */ [](SAddr addr) { return addr.isStatic(); },
+        // FIXME(genmc,error reporting): Once a proper a proper API for passing such information is
+        // implemented in GenMC, Miri should use it to improve the produced error messages.
+        /* getStaticName: */ [](SAddr addr) { return "[UNKNOWN STATIC]"; },
+        // This function is called to get the initial value stored at the given address.
+        //
+        // From a Miri perspective, this API doesn't work very well: most memory starts out
+        // "uninitialized";
+        // only statics have an initial value. And their initial value is just a sequence of bytes,
+        // but GenMC
+        // expect this to be already split into separate atomic variables. So we return a dummy
+        // value.
+        // This value should never be visible to the interpreted program.
+        // GenMC does not understand uninitialized memory the same way Miri does, which may cause
+        // this function to be called. The returned value can be visible to Miri or the user:
+        // - Printing the execution graph may contain this value in place of uninitialized values.
+        //   FIXME(genmc): NOTE: printing the execution graph is not yet implemented.
+        // - Non-atomic loads may return this value, but Miri ignores values of non-atomic loads.
+        // - Atomic loads will *not* see this value once mixed atomic-non-atomic support is added.
+        //   Currently, atomic loads can see this value, unless initialized by an *atomic* store.
+        //   FIXME(genmc): update this comment once mixed atomic-non-atomic support is added.
+        //
+        // FIXME(genmc): implement proper support for uninitialized memory in GenMC. Ideally, the
+        // initial value getter would return an `optional<SVal>`, since the memory location may be
+        // uninitialized.
+        /* initValGetter: */ [](const AAccess& a) { return SVal(0xDEAD); },
+        // Miri serves non-atomic loads from its own memory and these GenMC checks are wrong in
+        // that case. This should no longer be required with proper mixed-size access support.
+        /* skipUninitLoadChecks: */ [](MemOrdering ord) { return ord == MemOrdering::NotAtomic; },
+    };
+    driver->setInterpCallbacks(std::move(interpreter_callbacks));
+
+    return driver;
+}
diff --git a/src/tools/miri/genmc-sys/cpp/src/MiriInterface/ThreadManagement.cpp b/src/tools/miri/genmc-sys/cpp/src/MiriInterface/ThreadManagement.cpp
new file mode 100644
index 0000000000000..352d27adc3e8b
--- /dev/null
+++ b/src/tools/miri/genmc-sys/cpp/src/MiriInterface/ThreadManagement.cpp
@@ -0,0 +1,54 @@
+
+/** This file contains functionality related thread management (creation, finishing, join, etc.)  */
+
+#include "MiriInterface.hpp"
+
+// CXX.rs generated headers:
+#include "genmc-sys/src/lib.rs.h"
+
+// GenMC headers:
+#include "Support/Error.hpp"
+#include "Support/Verbosity.hpp"
+
+// C++ headers:
+#include <cstdint>
+
+void MiriGenmcShim::handle_thread_create(ThreadId thread_id, ThreadId parent_id) {
+    // NOTE: The threadCreate event happens in the parent:
+    const auto pos = inc_pos(parent_id);
+    // FIXME(genmc): for supporting symmetry reduction, these will need to be properly set:
+    const unsigned fun_id = 0;
+    const SVal arg = SVal(0);
+    const ThreadInfo child_info = ThreadInfo { thread_id, parent_id, fun_id, arg };
+
+    // NOTE: Default memory ordering (`Release`) used here.
+    const auto child_tid = GenMCDriver::handleThreadCreate(pos, child_info, EventDeps());
+    // Sanity check the thread id, which is the index in the `threads_action_` array.
+    BUG_ON(child_tid != thread_id || child_tid <= 0 || child_tid != threads_action_.size());
+    threads_action_.push_back(Action(ActionKind::Load, Event(child_tid, 0)));
+}
+
+void MiriGenmcShim::handle_thread_join(ThreadId thread_id, ThreadId child_id) {
+    // The thread join event happens in the parent.
+    const auto pos = inc_pos(thread_id);
+
+    // NOTE: Default memory ordering (`Acquire`) used here.
+    const auto ret = GenMCDriver::handleThreadJoin(pos, child_id, EventDeps());
+    // If the join failed, decrease the event index again:
+    if (!std::holds_alternative<SVal>(ret)) {
+        dec_pos(thread_id);
+    }
+
+    // NOTE: Thread return value is ignored, since Miri doesn't need it.
+}
+
+void MiriGenmcShim::handle_thread_finish(ThreadId thread_id, uint64_t ret_val) {
+    const auto pos = inc_pos(thread_id);
+    // NOTE: Default memory ordering (`Release`) used here.
+    GenMCDriver::handleThreadFinish(pos, SVal(ret_val));
+}
+
+void MiriGenmcShim::handle_thread_kill(ThreadId thread_id) {
+    const auto pos = inc_pos(thread_id);
+    GenMCDriver::handleThreadKill(pos);
+}
diff --git a/src/tools/miri/genmc-sys/src/lib.rs b/src/tools/miri/genmc-sys/src/lib.rs
index ab46d729ea167..406c90809fcd5 100644
--- a/src/tools/miri/genmc-sys/src/lib.rs
+++ b/src/tools/miri/genmc-sys/src/lib.rs
@@ -1,17 +1,90 @@
+use std::str::FromStr;
+use std::sync::OnceLock;
+
+pub use cxx::UniquePtr;
+
 pub use self::ffi::*;
 
+/// Defined in "genmc/src/Support/SAddr.hpp".
+/// The first bit of all global addresses must be set to `1`.
+/// This means the mask, interpreted as an address, is the lower bound of where the global address space starts.
+///
+/// FIXME(genmc): rework this if non-64bit support is added to GenMC (the current allocation scheme only allows for 64bit addresses).
+/// FIXME(genmc): currently we use `get_global_alloc_static_mask()` to ensure the constant is consistent between Miri and GenMC,
+///   but if https://github.com/dtolnay/cxx/issues/1051 is fixed we could share the constant directly.
+pub const GENMC_GLOBAL_ADDRESSES_MASK: u64 = 1 << 63;
+
+/// GenMC thread ids are C++ type `int`, which is equivalent to Rust's `i32` on most platforms.
+/// The main thread always has thread id 0.
+pub const GENMC_MAIN_THREAD_ID: i32 = 0;
+
+/// Changing GenMC's log level is not thread safe, so we limit it to only be set once to prevent any data races.
+/// This value will be initialized when the first `MiriGenmcShim` is created.
+static GENMC_LOG_LEVEL: OnceLock<LogLevel> = OnceLock::new();
+
+// Create a new handle to the GenMC model checker.
+// The first call to this function determines the log level of GenMC, any future call with a different log level will panic.
+pub fn create_genmc_driver_handle(
+    params: &GenmcParams,
+    genmc_log_level: LogLevel,
+) -> UniquePtr<MiriGenmcShim> {
+    // SAFETY: Only setting the GenMC log level once is guaranteed by the `OnceLock`.
+    // No other place calls `set_log_level_raw`, so the `logLevel` value in GenMC will not change once we initialize it once.
+    // All functions that use GenMC's `logLevel` can only be accessed in safe Rust through a `MiriGenmcShim`.
+    // There is no way to get `MiriGenmcShim` other than through `create_handle`, and we only call it *after* setting the log level, preventing any possible data races.
+    assert_eq!(
+        &genmc_log_level,
+        GENMC_LOG_LEVEL.get_or_init(|| {
+            unsafe { set_log_level_raw(genmc_log_level) };
+            genmc_log_level
+        }),
+        "Attempt to change the GenMC log level after it was already set"
+    );
+    unsafe { MiriGenmcShim::create_handle(params) }
+}
+
+impl GenmcScalar {
+    pub const UNINIT: Self = Self { value: 0, is_init: false };
+
+    pub const fn from_u64(value: u64) -> Self {
+        Self { value, is_init: true }
+    }
+}
+
 impl Default for GenmcParams {
     fn default() -> Self {
-        Self {
-            print_random_schedule_seed: false,
-            do_symmetry_reduction: false,
-            // FIXME(GenMC): Add defaults for remaining parameters
-        }
+        Self { print_random_schedule_seed: false, do_symmetry_reduction: false }
+    }
+}
+
+impl Default for LogLevel {
+    fn default() -> Self {
+        // FIXME(genmc): set `Tip` by default once the GenMC tips are relevant to Miri.
+        Self::Warning
+    }
+}
+
+impl FromStr for LogLevel {
+    type Err = &'static str;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(match s {
+            "quiet" => LogLevel::Quiet,
+            "error" => LogLevel::Error,
+            "warning" => LogLevel::Warning,
+            "tip" => LogLevel::Tip,
+            "debug1" => LogLevel::Debug1Revisits,
+            "debug2" => LogLevel::Debug2MemoryAccesses,
+            "debug3" => LogLevel::Debug3ReadsFrom,
+            _ => return Err("invalid log level"),
+        })
     }
 }
 
 #[cxx::bridge]
 mod ffi {
+    /**** Types shared between Miri/Rust and Miri/C++ through cxx_bridge: ****/
+
     /// Parameters that will be given to GenMC for setting up the model checker.
     /// (The fields of this struct are visible to both Rust and C++)
     #[derive(Clone, Debug)]
@@ -20,11 +93,221 @@ mod ffi {
         pub do_symmetry_reduction: bool,
         // FIXME(GenMC): Add remaining parameters.
     }
+
+    /// This is mostly equivalent to GenMC `VerbosityLevel`, but the debug log levels are always present (not conditionally compiled based on `ENABLE_GENMC_DEBUG`).
+    /// We add this intermediate type to prevent changes to the GenMC log-level from breaking the Miri
+    /// build, and to have a stable type for the C++-Rust interface, independent of `ENABLE_GENMC_DEBUG`.
+    #[derive(Debug)]
+    enum LogLevel {
+        /// Disable *all* logging (including error messages on a crash).
+        Quiet,
+        /// Log errors.
+        Error,
+        /// Log errors and warnings.
+        Warning,
+        /// Log errors, warnings and tips.
+        Tip,
+        /// Debug print considered revisits.
+        /// Downgraded to `Tip` if `GENMC_DEBUG` is not enabled.
+        Debug1Revisits,
+        /// Print the execution graph after every memory access.
+        /// Also includes the previous debug log level.
+        /// Downgraded to `Tip` if `GENMC_DEBUG` is not enabled.
+        Debug2MemoryAccesses,
+        /// Print reads-from values considered by GenMC.
+        /// Also includes the previous debug log level.
+        /// Downgraded to `Tip` if `GENMC_DEBUG` is not enabled.
+        Debug3ReadsFrom,
+    }
+
+    /// This type corresponds to `Option<SVal>` (or `std::optional<SVal>`), where `SVal` is the type that GenMC uses for storing values.
+    /// CXX doesn't support `std::optional` currently, so we need to use an extra `bool` to define whether this value is initialized or not.
+    #[derive(Debug, Clone, Copy)]
+    struct GenmcScalar {
+        value: u64,
+        is_init: bool,
+    }
+
+    #[must_use]
+    #[derive(Debug, Clone, Copy)]
+    enum ExecutionState {
+        Ok,
+        Blocked,
+        Finished,
+    }
+
+    #[must_use]
+    #[derive(Debug)]
+    struct SchedulingResult {
+        exec_state: ExecutionState,
+        next_thread: i32,
+    }
+
+    #[must_use]
+    #[derive(Debug)]
+    struct LoadResult {
+        /// If not null, contains the error encountered during the handling of the load.
+        error: UniquePtr<CxxString>,
+        /// Indicates whether a value was read or not.
+        has_value: bool,
+        /// The value that was read. Should not be used if `has_value` is `false`.
+        read_value: GenmcScalar,
+    }
+
+    #[must_use]
+    #[derive(Debug)]
+    struct StoreResult {
+        /// If not null, contains the error encountered during the handling of the store.
+        error: UniquePtr<CxxString>,
+        /// `true` if the write should also be reflected in Miri's memory representation.
+        is_coherence_order_maximal_write: bool,
+    }
+
+    /**** Types shared between Miri/Rust and GenMC/C++ through cxx_bridge: ****/
+
+    #[derive(Debug)]
+    /// Corresponds to GenMC's type with the same name.
+    /// Should only be modified if changed by GenMC.
+    enum ActionKind {
+        /// Any Mir terminator that's atomic and has load semantics.
+        Load,
+        /// Anything that's not a `Load`.
+        NonLoad,
+    }
+
+    #[derive(Debug)]
+    /// Corresponds to GenMC's type with the same name.
+    /// Should only be modified if changed by GenMC.
+    enum MemOrdering {
+        NotAtomic = 0,
+        Relaxed = 1,
+        // We skip 2 in case we support consume.
+        Acquire = 3,
+        Release = 4,
+        AcquireRelease = 5,
+        SequentiallyConsistent = 6,
+    }
+
+    // # Safety
+    //
+    // This block is unsafe to allow defining safe methods inside.
+    //
+    // `get_global_alloc_static_mask` is safe since it just returns a constant.
+    // All methods on `MiriGenmcShim` are safe by the correct usage of the two unsafe functions
+    // `set_log_level_raw` and `MiriGenmcShim::create_handle`.
+    // See the doc comment on those two functions for their safety requirements.
     unsafe extern "C++" {
         include!("MiriInterface.hpp");
 
-        type MiriGenMCShim;
+        /**** Types shared between Miri/Rust and Miri/C++: ****/
+        type MiriGenmcShim;
+
+        /**** Types shared between Miri/Rust and GenMC/C++: ****/
+        type ActionKind;
+        type MemOrdering;
+
+        /// Set the log level for GenMC.
+        ///
+        /// # Safety
+        ///
+        /// This function is not thread safe, since it writes to the global, mutable, non-atomic `logLevel` variable.
+        /// Any GenMC function may read from `logLevel` unsynchronized.
+        /// The safest way to use this function is to set the log level exactly once before first calling `create_handle`.
+        /// Never calling this function is safe, GenMC will fall back to its default log level.
+        unsafe fn set_log_level_raw(log_level: LogLevel);
+
+        /// Create a new `MiriGenmcShim`, which wraps a `GenMCDriver`.
+        ///
+        /// # Safety
+        ///
+        /// This function is marked as unsafe since the `logLevel` global variable is non-atomic.
+        /// This function should not be called in an unsynchronized way with `set_log_level_raw`, since
+        /// this function and any methods on the returned `MiriGenmcShim` may read the `logLevel`,
+        /// causing a data race.
+        /// The safest way to use these functions is to call `set_log_level_raw` once, and only then
+        /// start creating handles.
+        /// There should not be any other (safe) way to create a `MiriGenmcShim`.
+        #[Self = "MiriGenmcShim"]
+        unsafe fn create_handle(params: &GenmcParams) -> UniquePtr<MiriGenmcShim>;
+        /// Get the bit mask that GenMC expects for global memory allocations.
+        fn get_global_alloc_static_mask() -> u64;
+
+        /// This function must be called at the start of any execution, before any events are reported to GenMC.
+        fn handle_execution_start(self: Pin<&mut MiriGenmcShim>);
+        /// This function must be called at the end of any execution, even if an error was found during the execution.
+        /// Returns `null`, or a string containing an error message if an error occured.
+        fn handle_execution_end(self: Pin<&mut MiriGenmcShim>) -> UniquePtr<CxxString>;
+
+        /***** Functions for handling events encountered during program execution. *****/
+
+        /**** Memory access handling ****/
+        fn handle_load(
+            self: Pin<&mut MiriGenmcShim>,
+            thread_id: i32,
+            address: u64,
+            size: u64,
+            memory_ordering: MemOrdering,
+            old_value: GenmcScalar,
+        ) -> LoadResult;
+        fn handle_store(
+            self: Pin<&mut MiriGenmcShim>,
+            thread_id: i32,
+            address: u64,
+            size: u64,
+            value: GenmcScalar,
+            old_value: GenmcScalar,
+            memory_ordering: MemOrdering,
+        ) -> StoreResult;
+
+        /**** Memory (de)allocation ****/
+        fn handle_malloc(
+            self: Pin<&mut MiriGenmcShim>,
+            thread_id: i32,
+            size: u64,
+            alignment: u64,
+        ) -> u64;
+        fn handle_free(self: Pin<&mut MiriGenmcShim>, thread_id: i32, address: u64);
+
+        /**** Thread management ****/
+        fn handle_thread_create(self: Pin<&mut MiriGenmcShim>, thread_id: i32, parent_id: i32);
+        fn handle_thread_join(self: Pin<&mut MiriGenmcShim>, thread_id: i32, child_id: i32);
+        fn handle_thread_finish(self: Pin<&mut MiriGenmcShim>, thread_id: i32, ret_val: u64);
+        fn handle_thread_kill(self: Pin<&mut MiriGenmcShim>, thread_id: i32);
+
+        /***** Exploration related functionality *****/
+
+        /// Ask the GenMC scheduler for a new thread to schedule and
+        /// return whether the execution is finished, blocked, or can continue.
+        /// Updates the next instruction kind for the given thread id.
+        fn schedule_next(
+            self: Pin<&mut MiriGenmcShim>,
+            curr_thread_id: i32,
+            curr_thread_next_instr_kind: ActionKind,
+        ) -> SchedulingResult;
+
+        /// Check whether there are more executions to explore.
+        /// If there are more executions, this method prepares for the next execution and returns `true`.
+        fn is_exploration_done(self: Pin<&mut MiriGenmcShim>) -> bool;
+
+        /**** Result querying functionality. ****/
+
+        // NOTE: We don't want to share the `VerificationResult` type with the Rust side, since it
+        // is very large, uses features that CXX.rs doesn't support and may change as GenMC changes.
+        // Instead, we only use the result on the C++ side, and only expose these getter function to
+        // the Rust side.
+        // Each `GenMCDriver` contains one `VerificationResult`, and each `MiriGenmcShim` contains on `GenMCDriver`.
+        // GenMC builds up the content of the `struct VerificationResult` over the course of an exploration,
+        // but it's safe to look at it at any point, since it is only accessible through exactly one `MiriGenmcShim`.
+        // All these functions for querying the result can be safely called repeatedly and at any time,
+        // though the results may be incomplete if called before `handle_execution_end`.
 
-        fn createGenmcHandle(config: &GenmcParams) -> UniquePtr<MiriGenMCShim>;
+        /// Get the number of blocked executions encountered by GenMC (cast into a fixed with integer)
+        fn get_blocked_execution_count(self: &MiriGenmcShim) -> u64;
+        /// Get the number of executions explored by GenMC (cast into a fixed with integer)
+        fn get_explored_execution_count(self: &MiriGenmcShim) -> u64;
+        /// Get all messages that GenMC produced (errors, warnings), combined into one string.
+        fn get_result_message(self: &MiriGenmcShim) -> UniquePtr<CxxString>;
+        /// If an error occurred, return a string describing the error, otherwise, return `nullptr`.
+        fn get_error_string(self: &MiriGenmcShim) -> UniquePtr<CxxString>;
     }
 }
diff --git a/src/tools/miri/genmc-sys/src_cpp/MiriInterface.cpp b/src/tools/miri/genmc-sys/src_cpp/MiriInterface.cpp
deleted file mode 100644
index 0827bb3d40746..0000000000000
--- a/src/tools/miri/genmc-sys/src_cpp/MiriInterface.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#include "MiriInterface.hpp"
-
-#include "genmc-sys/src/lib.rs.h"
-
-auto MiriGenMCShim::createHandle(const GenmcParams &config)
-	-> std::unique_ptr<MiriGenMCShim>
-{
-	auto conf = std::make_shared<Config>();
-
-	// Miri needs all threads to be replayed, even fully completed ones.
-	conf->replayCompletedThreads = true;
-
-	// We only support the RC11 memory model for Rust.
-	conf->model = ModelType::RC11;
-
-	conf->printRandomScheduleSeed = config.print_random_schedule_seed;
-
-	// FIXME(genmc): disable any options we don't support currently:
-	conf->ipr = false;
-	conf->disableBAM = true;
-	conf->instructionCaching = false;
-
-	ERROR_ON(config.do_symmetry_reduction, "Symmetry reduction is currently unsupported in GenMC mode.");
-	conf->symmetryReduction = config.do_symmetry_reduction;
-
-	// FIXME(genmc): Should there be a way to change this option from Miri?
-	conf->schedulePolicy = SchedulePolicy::WF;
-
-	// FIXME(genmc): implement estimation mode:
-	conf->estimate = false;
-	conf->estimationMax = 1000;
-	const auto mode = conf->estimate ? GenMCDriver::Mode(GenMCDriver::EstimationMode{})
-									  : GenMCDriver::Mode(GenMCDriver::VerificationMode{});
-
-	// Running Miri-GenMC without race detection is not supported.
-	// Disabling this option also changes the behavior of the replay scheduler to only schedule at atomic operations, which is required with Miri.
-	// This happens because Miri can generate multiple GenMC events for a single MIR terminator. Without this option,
-	// the scheduler might incorrectly schedule an atomic MIR terminator because the first event it creates is a non-atomic (e.g., `StorageLive`).
-	conf->disableRaceDetection = false;
-
-	// Miri can already check for unfreed memory. Also, GenMC cannot distinguish between memory
-	// that is allowed to leak and memory that is not.
-	conf->warnUnfreedMemory = false;
-
-	// FIXME(genmc): check config:
-	// checkConfigOptions(*conf);
-
-	auto driver = std::make_unique<MiriGenMCShim>(std::move(conf), mode);
-	return driver;
-}
diff --git a/src/tools/miri/genmc-sys/src_cpp/MiriInterface.hpp b/src/tools/miri/genmc-sys/src_cpp/MiriInterface.hpp
deleted file mode 100644
index e55522ef41897..0000000000000
--- a/src/tools/miri/genmc-sys/src_cpp/MiriInterface.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#ifndef GENMC_MIRI_INTERFACE_HPP
-#define GENMC_MIRI_INTERFACE_HPP
-
-#include "rust/cxx.h"
-
-#include "config.h"
-
-#include "Config/Config.hpp"
-#include "Verification/GenMCDriver.hpp"
-
-#include <iostream>
-
-/**** Types available to Miri ****/
-
-// Config struct defined on the Rust side and translated to C++ by cxx.rs:
-struct GenmcParams;
-
-struct MiriGenMCShim : private GenMCDriver
-{
-
-public:
-	MiriGenMCShim(std::shared_ptr<const Config> conf, Mode mode /* = VerificationMode{} */)
-		: GenMCDriver(std::move(conf), nullptr, mode)
-	{
-		std::cerr << "C++: GenMC handle created!" << std::endl;
-	}
-
-	virtual ~MiriGenMCShim()
-	{
-		std::cerr << "C++: GenMC handle destroyed!" << std::endl;
-	}
-
-	static std::unique_ptr<MiriGenMCShim> createHandle(const GenmcParams &config);
-};
-
-/**** Functions available to Miri ****/
-
-// NOTE: CXX doesn't support exposing static methods to Rust currently, so we expose this function instead.
-static inline auto createGenmcHandle(const GenmcParams &config) -> std::unique_ptr<MiriGenMCShim>
-{
-	return MiriGenMCShim::createHandle(config);
-}
-
-#endif /* GENMC_MIRI_INTERFACE_HPP */
diff --git a/src/tools/miri/src/alloc_addresses/mod.rs b/src/tools/miri/src/alloc_addresses/mod.rs
index afd8afbaeab07..5d94a1f4138a6 100644
--- a/src/tools/miri/src/alloc_addresses/mod.rs
+++ b/src/tools/miri/src/alloc_addresses/mod.rs
@@ -34,6 +34,8 @@ pub struct GlobalStateInner {
     /// sorted by address. We cannot use a `HashMap` since we can be given an address that is offset
     /// from the base address, and we need to find the `AllocId` it belongs to. This is not the
     /// *full* inverse of `base_addr`; dead allocations have been removed.
+    /// Note that in GenMC mode, dead allocations are *not* removed -- and also, addresses are never
+    /// reused. This lets us use the address as a cross-execution-stable identifier for an allocation.
     int_to_ptr_map: Vec<(u64, AllocId)>,
     /// The base address for each allocation.  We cannot put that into
     /// `AllocExtra` because function pointers also have a base address, and
@@ -123,7 +125,8 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
         // Miri's address assignment leaks state across thread boundaries, which is incompatible
         // with GenMC execution. So we instead let GenMC assign addresses to allocations.
         if let Some(genmc_ctx) = this.machine.data_race.as_genmc_ref() {
-            let addr = genmc_ctx.handle_alloc(&this.machine, info.size, info.align, memory_kind)?;
+            let addr =
+                genmc_ctx.handle_alloc(this, alloc_id, info.size, info.align, memory_kind)?;
             return interp_ok(addr);
         }
 
@@ -180,7 +183,7 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
             this.active_thread(),
         ) {
             if let Some(clock) = clock {
-                this.acquire_clock(&clock);
+                this.acquire_clock(&clock)?;
             }
             interp_ok(reuse_addr)
         } else {
@@ -242,7 +245,10 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         // We only use this provenance if it has been exposed, or if the caller requested also non-exposed allocations
         if !only_exposed_allocations || global_state.exposed.contains(&alloc_id) {
             // This must still be live, since we remove allocations from `int_to_ptr_map` when they get freed.
-            debug_assert!(this.is_alloc_live(alloc_id));
+            // In GenMC mode, we keep all allocations, so this check doesn't apply there.
+            if this.machine.data_race.as_genmc_ref().is_none() {
+                debug_assert!(this.is_alloc_live(alloc_id));
+            }
             Some(alloc_id)
         } else {
             None
@@ -459,6 +465,13 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
 impl<'tcx> MiriMachine<'tcx> {
     pub fn free_alloc_id(&mut self, dead_id: AllocId, size: Size, align: Align, kind: MemoryKind) {
+        // In GenMC mode, we can't remove dead allocation info since such pointers can
+        // still be stored in atomics and we need this info to convert GenMC pointers to Miri pointers.
+        // `global_state.reuse` is also unused so we can just skip this entire function.
+        if self.data_race.as_genmc_ref().is_some() {
+            return;
+        }
+
         let global_state = self.alloc_addresses.get_mut();
         let rng = self.rng.get_mut();
 
diff --git a/src/tools/miri/src/bin/miri.rs b/src/tools/miri/src/bin/miri.rs
index ae1b25f8857a0..b96359316b921 100644
--- a/src/tools/miri/src/bin/miri.rs
+++ b/src/tools/miri/src/bin/miri.rs
@@ -39,7 +39,7 @@ use std::sync::atomic::{AtomicI32, AtomicU32, Ordering};
 
 use miri::{
     BacktraceStyle, BorrowTrackerMethod, GenmcConfig, GenmcCtx, MiriConfig, MiriEntryFnType,
-    ProvenanceMode, RetagFields, TreeBorrowsParams, ValidationMode,
+    ProvenanceMode, RetagFields, TreeBorrowsParams, ValidationMode, run_genmc_mode,
 };
 use rustc_abi::ExternAbi;
 use rustc_data_structures::sync;
@@ -187,9 +187,18 @@ impl rustc_driver::Callbacks for MiriCompilerCalls {
         }
 
         if let Some(_genmc_config) = &config.genmc_config {
-            let _genmc_ctx = Rc::new(GenmcCtx::new(&config));
+            let eval_entry_once = |genmc_ctx: Rc<GenmcCtx>| {
+                miri::eval_entry(tcx, entry_def_id, entry_type, &config, Some(genmc_ctx))
+            };
+
+            // FIXME(genmc): add estimation mode here.
 
-            todo!("GenMC mode not yet implemented");
+            let return_code = run_genmc_mode(&config, eval_entry_once, tcx).unwrap_or_else(|| {
+                tcx.dcx().abort_if_errors();
+                rustc_driver::EXIT_FAILURE
+            });
+
+            exit(return_code);
         };
 
         if let Some(many_seeds) = self.many_seeds.take() {
@@ -735,9 +744,11 @@ fn main() {
     // Validate settings for data race detection and GenMC mode.
     if miri_config.genmc_config.is_some() {
         if !miri_config.data_race_detector {
-            fatal_error!("Cannot disable data race detection in GenMC mode (currently)");
+            fatal_error!("Cannot disable data race detection in GenMC mode");
         } else if !miri_config.weak_memory_emulation {
             fatal_error!("Cannot disable weak memory emulation in GenMC mode");
+        } else if !miri_config.native_lib.is_empty() {
+            fatal_error!("native-lib not supported in GenMC mode.");
         }
         if miri_config.borrow_tracker.is_some() {
             eprintln!(
@@ -745,6 +756,9 @@ fn main() {
             );
             miri_config.borrow_tracker = None;
         }
+        // We enable fixed scheduling so Miri doesn't randomly yield before a terminator, which anyway
+        // would be a NOP in GenMC mode.
+        miri_config.fixed_scheduling = true;
     } else if miri_config.weak_memory_emulation && !miri_config.data_race_detector {
         fatal_error!(
             "Weak memory emulation cannot be enabled when the data race detector is disabled"
diff --git a/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs b/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs
index 2977efaae04ac..5fe00ab02c4b9 100644
--- a/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs
@@ -740,6 +740,7 @@ trait EvalContextPrivExt<'tcx, 'ecx>: crate::MiriInterpCxExt<'tcx> {
                 if let Some(access) = access {
                     assert_eq!(access, AccessKind::Write);
                     // Make sure the data race model also knows about this.
+                    // FIXME(genmc): Ensure this is still done in GenMC mode. Check for other places where GenMC may need to be informed.
                     if let Some(data_race) = alloc_extra.data_race.as_vclocks_mut() {
                         data_race.write(
                             alloc_id,
diff --git a/src/tools/miri/src/concurrency/data_race.rs b/src/tools/miri/src/concurrency/data_race.rs
index 38d76f5cf73b7..19d37a691d90c 100644
--- a/src/tools/miri/src/concurrency/data_race.rs
+++ b/src/tools/miri/src/concurrency/data_race.rs
@@ -719,8 +719,7 @@ pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
         // Only metadata on the location itself is used.
 
         if let Some(genmc_ctx) = this.machine.data_race.as_genmc_ref() {
-            // FIXME(GenMC): Inform GenMC what a non-atomic read here would return, to support mixed atomics/non-atomics
-            let old_val = None;
+            let old_val = this.run_for_validation_ref(|this| this.read_scalar(place)).discard_err();
             return genmc_ctx.atomic_load(
                 this,
                 place.ptr().addr(),
@@ -751,11 +750,22 @@ pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
         // 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_mut(|this| this.read_scalar(dest)).discard_err();
+        let old_val = this.run_for_validation_ref(|this| this.read_scalar(dest)).discard_err();
+
         // Inform GenMC about the atomic store.
         if let Some(genmc_ctx) = this.machine.data_race.as_genmc_ref() {
-            // FIXME(GenMC): Inform GenMC what a non-atomic read here would return, to support mixed atomics/non-atomics
-            genmc_ctx.atomic_store(this, dest.ptr().addr(), dest.layout.size, val, atomic)?;
+            if genmc_ctx.atomic_store(
+                this,
+                dest.ptr().addr(),
+                dest.layout.size,
+                val,
+                old_val,
+                atomic,
+            )? {
+                // The store might be the latest store in coherence order (determined by GenMC).
+                // If it is, we need to update the value in Miri's memory:
+                this.allow_data_races_mut(|this| this.write_scalar(val, dest))?;
+            }
             return interp_ok(());
         }
         this.allow_data_races_mut(move |this| this.write_scalar(val, dest))?;
@@ -779,7 +789,6 @@ pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
 
         // Inform GenMC about the atomic rmw operation.
         if let Some(genmc_ctx) = this.machine.data_race.as_genmc_ref() {
-            // FIXME(GenMC): Inform GenMC what a non-atomic read here would return, to support mixed atomics/non-atomics
             let (old_val, new_val) = genmc_ctx.atomic_rmw_op(
                 this,
                 place.ptr().addr(),
@@ -787,8 +796,11 @@ pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
                 atomic,
                 (op, not),
                 rhs.to_scalar(),
+                old.to_scalar(),
             )?;
-            this.allow_data_races_mut(|this| this.write_scalar(new_val, place))?;
+            if let Some(new_val) = new_val {
+                this.allow_data_races_mut(|this| this.write_scalar(new_val, place))?;
+            }
             return interp_ok(ImmTy::from_scalar(old_val, old.layout));
         }
 
@@ -818,14 +830,19 @@ pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
 
         // Inform GenMC about the atomic atomic exchange.
         if let Some(genmc_ctx) = this.machine.data_race.as_genmc_ref() {
-            // FIXME(GenMC): Inform GenMC what a non-atomic read here would return, to support mixed atomics/non-atomics
-            let (old_val, _is_success) = genmc_ctx.atomic_exchange(
+            let (old_val, new_val) = genmc_ctx.atomic_exchange(
                 this,
                 place.ptr().addr(),
                 place.layout.size,
                 new,
                 atomic,
+                old,
             )?;
+            // The store might be the latest store in coherence order (determined by GenMC).
+            // If it is, we need to update the value in Miri's memory:
+            if let Some(new_val) = new_val {
+                this.allow_data_races_mut(|this| this.write_scalar(new_val, place))?;
+            }
             return interp_ok(old_val);
         }
 
@@ -851,7 +868,6 @@ pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
 
         // Inform GenMC about the atomic min/max operation.
         if let Some(genmc_ctx) = this.machine.data_race.as_genmc_ref() {
-            // FIXME(GenMC): Inform GenMC what a non-atomic read here would return, to support mixed atomics/non-atomics
             let (old_val, new_val) = genmc_ctx.atomic_min_max_op(
                 this,
                 place.ptr().addr(),
@@ -860,8 +876,13 @@ pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
                 min,
                 old.layout.backend_repr.is_signed(),
                 rhs.to_scalar(),
+                old.to_scalar(),
             )?;
-            this.allow_data_races_mut(|this| this.write_scalar(new_val, place))?;
+            // The store might be the latest store in coherence order (determined by GenMC).
+            // If it is, we need to update the value in Miri's memory:
+            if let Some(new_val) = new_val {
+                this.allow_data_races_mut(|this| this.write_scalar(new_val, place))?;
+            }
             return interp_ok(ImmTy::from_scalar(old_val, old.layout));
         }
 
@@ -903,15 +924,12 @@ pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
         let this = self.eval_context_mut();
         this.atomic_access_check(place, AtomicAccessType::Rmw)?;
 
-        // Failure ordering cannot be stronger than success ordering, therefore first attempt
-        // to read with the failure ordering and if successful then try again with the success
-        // read ordering and write in the success case.
         // Read as immediate for the sake of `binary_op()`
         let old = this.allow_data_races_mut(|this| this.read_immediate(place))?;
 
         // Inform GenMC about the atomic atomic compare exchange.
         if let Some(genmc_ctx) = this.machine.data_race.as_genmc_ref() {
-            let (old, cmpxchg_success) = genmc_ctx.atomic_compare_exchange(
+            let (old_value, new_value, cmpxchg_success) = genmc_ctx.atomic_compare_exchange(
                 this,
                 place.ptr().addr(),
                 place.layout.size,
@@ -920,11 +938,15 @@ pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
                 success,
                 fail,
                 can_fail_spuriously,
+                old.to_scalar(),
             )?;
-            if cmpxchg_success {
-                this.allow_data_races_mut(|this| this.write_scalar(new, place))?;
+
+            // The store might be the latest store in coherence order (determined by GenMC).
+            // If it is, we need to update the value in Miri's memory:
+            if let Some(new_value) = new_value {
+                this.allow_data_races_mut(|this| this.write_scalar(new_value, place))?;
             }
-            return interp_ok(Immediate::ScalarPair(old, Scalar::from_bool(cmpxchg_success)));
+            return interp_ok(Immediate::ScalarPair(old_value, Scalar::from_bool(cmpxchg_success)));
         }
 
         // `binary_op` will bail if either of them is not a scalar.
@@ -985,11 +1007,16 @@ pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
 
     /// Acquire the given clock into the current thread, establishing synchronization with
     /// the moment when that clock snapshot was taken via `release_clock`.
-    fn acquire_clock(&self, clock: &VClock) {
+    fn acquire_clock(&self, clock: &VClock) -> InterpResult<'tcx> {
         let this = self.eval_context_ref();
-        if let Some(data_race) = this.machine.data_race.as_vclocks_ref() {
-            data_race.acquire_clock(clock, &this.machine.threads);
+        match &this.machine.data_race {
+            GlobalDataRaceHandler::None => {}
+            GlobalDataRaceHandler::Genmc(_genmc_ctx) =>
+                throw_unsup_format!("acquire_clock is not (yet) supported in GenMC mode."),
+            GlobalDataRaceHandler::Vclocks(data_race) =>
+                data_race.acquire_clock(clock, &this.machine.threads),
         }
+        interp_ok(())
     }
 }
 
diff --git a/src/tools/miri/src/concurrency/genmc/config.rs b/src/tools/miri/src/concurrency/genmc/config.rs
index c56adab90fe2b..66116d5cf23c7 100644
--- a/src/tools/miri/src/concurrency/genmc/config.rs
+++ b/src/tools/miri/src/concurrency/genmc/config.rs
@@ -1,13 +1,14 @@
-use super::GenmcParams;
+use genmc_sys::{GenmcParams, LogLevel};
 
 /// Configuration for GenMC mode.
 /// The `params` field is shared with the C++ side.
 /// The remaining options are kept on the Rust side.
 #[derive(Debug, Default, Clone)]
 pub struct GenmcConfig {
+    /// Parameters sent to the C++ side to create a new handle to the GenMC model checker.
     pub(super) params: GenmcParams,
-    do_estimation: bool,
-    // FIXME(GenMC): add remaining options.
+    /// The log level for GenMC.
+    pub(super) log_level: LogLevel,
 }
 
 impl GenmcConfig {
@@ -29,7 +30,15 @@ impl GenmcConfig {
         if trimmed_arg.is_empty() {
             return Ok(()); // this corresponds to "-Zmiri-genmc"
         }
-        // FIXME(GenMC): implement remaining parameters.
-        todo!();
+        let genmc_config = genmc_config.as_mut().unwrap();
+        let Some(trimmed_arg) = trimmed_arg.strip_prefix("-") else {
+            return Err(format!("Invalid GenMC argument \"-Zmiri-genmc{trimmed_arg}\""));
+        };
+        if let Some(log_level) = trimmed_arg.strip_prefix("log=") {
+            genmc_config.log_level = log_level.parse()?;
+        } else {
+            return Err(format!("Invalid GenMC argument: \"-Zmiri-genmc-{trimmed_arg}\""));
+        }
+        Ok(())
     }
 }
diff --git a/src/tools/miri/src/concurrency/genmc/dummy.rs b/src/tools/miri/src/concurrency/genmc/dummy.rs
index 79d27c4be1591..1960ef37cc9f3 100644
--- a/src/tools/miri/src/concurrency/genmc/dummy.rs
+++ b/src/tools/miri/src/concurrency/genmc/dummy.rs
@@ -1,30 +1,49 @@
-#![allow(unused)]
-
 use rustc_abi::{Align, Size};
-use rustc_const_eval::interpret::{InterpCx, InterpResult};
+use rustc_const_eval::interpret::{AllocId, InterpCx, InterpResult};
 use rustc_middle::mir;
 
+pub use self::run::run_genmc_mode;
 use crate::{
-    AtomicFenceOrd, AtomicReadOrd, AtomicRwOrd, AtomicWriteOrd, MemoryKind, MiriConfig,
-    MiriMachine, Scalar, ThreadId, ThreadManager, VisitProvenance, VisitWith,
+    AtomicFenceOrd, AtomicReadOrd, AtomicRwOrd, AtomicWriteOrd, MemoryKind, MiriMachine, Scalar,
+    ThreadId, ThreadManager, VisitProvenance, VisitWith,
 };
 
+#[derive(Clone, Copy, Debug)]
+pub enum ExitType {
+    MainThreadFinish,
+    ExitCalled,
+}
+
 #[derive(Debug)]
 pub struct GenmcCtx {}
 
 #[derive(Debug, Default, Clone)]
 pub struct GenmcConfig {}
 
-impl GenmcCtx {
-    pub fn new(_miri_config: &MiriConfig) -> Self {
-        unreachable!()
+mod run {
+    use std::rc::Rc;
+
+    use rustc_middle::ty::TyCtxt;
+
+    use crate::{GenmcCtx, MiriConfig};
+
+    pub fn run_genmc_mode<'tcx>(
+        _config: &MiriConfig,
+        _eval_entry: impl Fn(Rc<GenmcCtx>) -> Option<i32>,
+        _tcx: TyCtxt<'tcx>,
+    ) -> Option<i32> {
+        unreachable!();
     }
+}
+
+impl GenmcCtx {
+    // We don't provide the `new` function in the dummy module.
 
-    pub fn get_stuck_execution_count(&self) -> usize {
+    pub fn get_blocked_execution_count(&self) -> usize {
         unreachable!()
     }
 
-    pub fn print_genmc_graph(&self) {
+    pub fn get_explored_execution_count(&self) -> usize {
         unreachable!()
     }
 
@@ -34,17 +53,6 @@ impl GenmcCtx {
 
     /**** Memory access handling ****/
 
-    pub(crate) fn handle_execution_start(&self) {
-        unreachable!()
-    }
-
-    pub(crate) fn handle_execution_end<'tcx>(
-        &self,
-        _ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
-    ) -> Result<(), String> {
-        unreachable!()
-    }
-
     pub(super) fn set_ongoing_action_data_race_free(&self, _enable: bool) {
         unreachable!()
     }
@@ -67,8 +75,9 @@ impl GenmcCtx {
         _address: Size,
         _size: Size,
         _value: Scalar,
+        _old_value: Option<Scalar>,
         _ordering: AtomicWriteOrd,
-    ) -> InterpResult<'tcx, ()> {
+    ) -> InterpResult<'tcx, bool> {
         unreachable!()
     }
 
@@ -76,7 +85,7 @@ impl GenmcCtx {
         &self,
         _machine: &MiriMachine<'tcx>,
         _ordering: AtomicFenceOrd,
-    ) -> InterpResult<'tcx, ()> {
+    ) -> InterpResult<'tcx> {
         unreachable!()
     }
 
@@ -86,22 +95,24 @@ impl GenmcCtx {
         _address: Size,
         _size: Size,
         _ordering: AtomicRwOrd,
-        (rmw_op, not): (mir::BinOp, bool),
+        (_rmw_op, _not): (mir::BinOp, bool),
         _rhs_scalar: Scalar,
-    ) -> InterpResult<'tcx, (Scalar, Scalar)> {
+        _old_value: Scalar,
+    ) -> InterpResult<'tcx, (Scalar, Option<Scalar>)> {
         unreachable!()
     }
 
     pub(crate) fn atomic_min_max_op<'tcx>(
         &self,
-        ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
-        address: Size,
-        size: Size,
-        ordering: AtomicRwOrd,
-        min: bool,
-        is_signed: bool,
-        rhs_scalar: Scalar,
-    ) -> InterpResult<'tcx, (Scalar, Scalar)> {
+        _ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
+        _address: Size,
+        _size: Size,
+        _ordering: AtomicRwOrd,
+        _min: bool,
+        _is_signed: bool,
+        _rhs_scalar: Scalar,
+        _old_value: Scalar,
+    ) -> InterpResult<'tcx, (Scalar, Option<Scalar>)> {
         unreachable!()
     }
 
@@ -112,7 +123,8 @@ impl GenmcCtx {
         _size: Size,
         _rhs_scalar: Scalar,
         _ordering: AtomicRwOrd,
-    ) -> InterpResult<'tcx, (Scalar, bool)> {
+        _old_value: Scalar,
+    ) -> InterpResult<'tcx, (Scalar, Option<Scalar>)> {
         unreachable!()
     }
 
@@ -126,7 +138,8 @@ impl GenmcCtx {
         _success: AtomicRwOrd,
         _fail: AtomicReadOrd,
         _can_fail_spuriously: bool,
-    ) -> InterpResult<'tcx, (Scalar, bool)> {
+        _old_value: Scalar,
+    ) -> InterpResult<'tcx, (Scalar, Option<Scalar>, bool)> {
         unreachable!()
     }
 
@@ -135,7 +148,7 @@ impl GenmcCtx {
         _machine: &MiriMachine<'tcx>,
         _address: Size,
         _size: Size,
-    ) -> InterpResult<'tcx, ()> {
+    ) -> InterpResult<'tcx> {
         unreachable!()
     }
 
@@ -144,7 +157,7 @@ impl GenmcCtx {
         _machine: &MiriMachine<'tcx>,
         _address: Size,
         _size: Size,
-    ) -> InterpResult<'tcx, ()> {
+    ) -> InterpResult<'tcx> {
         unreachable!()
     }
 
@@ -152,7 +165,8 @@ impl GenmcCtx {
 
     pub(crate) fn handle_alloc<'tcx>(
         &self,
-        _machine: &MiriMachine<'tcx>,
+        _ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
+        _alloc_id: AllocId,
         _size: Size,
         _alignment: Align,
         _memory_kind: MemoryKind,
@@ -163,11 +177,10 @@ impl GenmcCtx {
     pub(crate) fn handle_dealloc<'tcx>(
         &self,
         _machine: &MiriMachine<'tcx>,
+        _alloc_id: AllocId,
         _address: Size,
-        _size: Size,
-        _align: Align,
         _kind: MemoryKind,
-    ) -> InterpResult<'tcx, ()> {
+    ) -> InterpResult<'tcx> {
         unreachable!()
     }
 
@@ -176,8 +189,10 @@ impl GenmcCtx {
     pub(crate) fn handle_thread_create<'tcx>(
         &self,
         _threads: &ThreadManager<'tcx>,
+        _start_routine: crate::Pointer,
+        _func_arg: &crate::ImmTy<'tcx>,
         _new_thread_id: ThreadId,
-    ) -> InterpResult<'tcx, ()> {
+    ) -> InterpResult<'tcx> {
         unreachable!()
     }
 
@@ -185,24 +200,26 @@ impl GenmcCtx {
         &self,
         _active_thread_id: ThreadId,
         _child_thread_id: ThreadId,
-    ) -> InterpResult<'tcx, ()> {
+    ) -> InterpResult<'tcx> {
         unreachable!()
     }
 
-    pub(crate) fn handle_thread_stack_empty(&self, _thread_id: ThreadId) {
+    pub(crate) fn handle_thread_finish<'tcx>(&self, _threads: &ThreadManager<'tcx>) {
         unreachable!()
     }
 
-    pub(crate) fn handle_thread_finish<'tcx>(
+    pub(crate) fn handle_exit<'tcx>(
         &self,
-        _threads: &ThreadManager<'tcx>,
-    ) -> InterpResult<'tcx, ()> {
+        _thread: ThreadId,
+        _exit_code: i32,
+        _exit_type: ExitType,
+    ) -> InterpResult<'tcx> {
         unreachable!()
     }
 
     /**** Scheduling functionality ****/
 
-    pub(crate) fn schedule_thread<'tcx>(
+    pub fn schedule_thread<'tcx>(
         &self,
         _ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
     ) -> InterpResult<'tcx, ThreadId> {
@@ -211,6 +228,7 @@ impl GenmcCtx {
 
     /**** Blocking instructions ****/
 
+    #[allow(unused)]
     pub(crate) fn handle_verifier_assume<'tcx>(
         &self,
         _machine: &MiriMachine<'tcx>,
@@ -229,7 +247,7 @@ impl VisitProvenance for GenmcCtx {
 impl GenmcConfig {
     pub fn parse_arg(
         _genmc_config: &mut Option<GenmcConfig>,
-        trimmed_arg: &str,
+        _trimmed_arg: &str,
     ) -> Result<(), String> {
         if cfg!(feature = "genmc") {
             Err(format!("GenMC is disabled in this build of Miri"))
@@ -237,8 +255,4 @@ impl GenmcConfig {
             Err(format!("GenMC is not supported on this target"))
         }
     }
-
-    pub fn should_print_graph(&self, _rep: usize) -> bool {
-        unreachable!()
-    }
 }
diff --git a/src/tools/miri/src/concurrency/genmc/global_allocations.rs b/src/tools/miri/src/concurrency/genmc/global_allocations.rs
new file mode 100644
index 0000000000000..272f8d2484038
--- /dev/null
+++ b/src/tools/miri/src/concurrency/genmc/global_allocations.rs
@@ -0,0 +1,118 @@
+use std::collections::hash_map::Entry;
+use std::sync::RwLock;
+
+use genmc_sys::{GENMC_GLOBAL_ADDRESSES_MASK, get_global_alloc_static_mask};
+use rand::SeedableRng;
+use rand::rngs::StdRng;
+use rustc_const_eval::interpret::{AllocId, AllocInfo, InterpResult, interp_ok};
+use rustc_data_structures::fx::FxHashMap;
+use tracing::debug;
+
+use crate::alloc_addresses::AddressGenerator;
+
+#[derive(Debug)]
+struct GlobalStateInner {
+    /// The base address for each *global* allocation.
+    base_addr: FxHashMap<AllocId, u64>,
+    /// We use the same address generator that Miri uses in normal operation.
+    address_generator: AddressGenerator,
+    /// The address generator needs an Rng to randomize the offsets between allocations.
+    /// We don't use the `MiriMachine` Rng since this is global, cross-machine state.
+    rng: StdRng,
+}
+
+/// Allocator for global memory in GenMC mode.
+/// Miri doesn't discover all global allocations statically like LLI does for GenMC.
+/// The existing global memory allocator in GenMC doesn't support this, so we take over these allocations.
+/// Global allocations need to be in a specific address range, with the lower limit given by the `GENMC_GLOBAL_ADDRESSES_MASK` constant.
+///
+/// Every global allocation must have the same addresses across all executions of a single program.
+/// Therefore there is only 1 global allocator, and it syncs new globals across executions, even if they are explored in parallel.
+#[derive(Debug)]
+pub struct GlobalAllocationHandler(RwLock<GlobalStateInner>);
+
+impl GlobalAllocationHandler {
+    /// Create a new global address generator with a given max address `last_addr`
+    /// (corresponding to the highest address available on the target platform, unless another limit exists).
+    /// No addresses higher than this will be allocated.
+    /// Will panic if the given address limit is too small to allocate any addresses.
+    pub fn new(last_addr: u64) -> GlobalAllocationHandler {
+        assert_eq!(GENMC_GLOBAL_ADDRESSES_MASK, get_global_alloc_static_mask());
+        assert_ne!(GENMC_GLOBAL_ADDRESSES_MASK, 0);
+        // FIXME(genmc): Remove if non-64bit targets are supported.
+        assert!(
+            GENMC_GLOBAL_ADDRESSES_MASK < last_addr,
+            "only 64bit platforms are currently supported (highest address {last_addr:#x} <= minimum global address {GENMC_GLOBAL_ADDRESSES_MASK:#x})."
+        );
+        Self(RwLock::new(GlobalStateInner {
+            base_addr: FxHashMap::default(),
+            address_generator: AddressGenerator::new(GENMC_GLOBAL_ADDRESSES_MASK..last_addr),
+            // FIXME(genmc): We could provide a way to changes this seed, to allow for different global addresses.
+            rng: StdRng::seed_from_u64(0),
+        }))
+    }
+}
+
+impl GlobalStateInner {
+    fn global_allocate_addr<'tcx>(
+        &mut self,
+        alloc_id: AllocId,
+        info: AllocInfo,
+    ) -> InterpResult<'tcx, u64> {
+        let entry = match self.base_addr.entry(alloc_id) {
+            Entry::Occupied(occupied_entry) => {
+                // Looks like some other thread allocated this for us
+                // between when we released the read lock and aquired the write lock,
+                // so we just return that value.
+                return interp_ok(*occupied_entry.get());
+            }
+            Entry::Vacant(vacant_entry) => vacant_entry,
+        };
+
+        // This allocation does not have a base address yet, pick or reuse one.
+        // We are not in native lib mode (incompatible with GenMC mode), so we control the addresses ourselves.
+        let new_addr = self.address_generator.generate(info.size, info.align, &mut self.rng)?;
+
+        // Cache the address for future use.
+        entry.insert(new_addr);
+
+        interp_ok(new_addr)
+    }
+}
+
+impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
+pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
+    /// Allocate a new address for the given alloc id, or return the cached address.
+    /// Each alloc id is assigned one unique allocation which will not change if this function is called again with the same alloc id.
+    fn get_global_allocation_address(
+        &self,
+        global_allocation_handler: &GlobalAllocationHandler,
+        alloc_id: AllocId,
+    ) -> InterpResult<'tcx, u64> {
+        let this = self.eval_context_ref();
+        let info = this.get_alloc_info(alloc_id);
+
+        let global_state = global_allocation_handler.0.read().unwrap();
+        if let Some(base_addr) = global_state.base_addr.get(&alloc_id) {
+            debug!(
+                "GenMC: address for global with alloc id {alloc_id:?} was cached: {base_addr} == {base_addr:#x}"
+            );
+            return interp_ok(*base_addr);
+        }
+
+        // We need to upgrade to a write lock. `std::sync::RwLock` doesn't support this, so we drop the guard and lock again
+        // Note that another thread might allocate the address while the `RwLock` is unlocked, but we handle this case in the allocation function.
+        drop(global_state);
+        let mut global_state = global_allocation_handler.0.write().unwrap();
+        // With the write lock, we can safely allocate an address only once per `alloc_id`.
+        let new_addr = global_state.global_allocate_addr(alloc_id, info)?;
+        debug!("GenMC: global with alloc id {alloc_id:?} got address: {new_addr} == {new_addr:#x}");
+        assert_eq!(
+            GENMC_GLOBAL_ADDRESSES_MASK,
+            new_addr & GENMC_GLOBAL_ADDRESSES_MASK,
+            "Global address allocated outside global address space."
+        );
+
+        interp_ok(new_addr)
+    }
+}
diff --git a/src/tools/miri/src/concurrency/genmc/helper.rs b/src/tools/miri/src/concurrency/genmc/helper.rs
new file mode 100644
index 0000000000000..b70ca8faadfed
--- /dev/null
+++ b/src/tools/miri/src/concurrency/genmc/helper.rs
@@ -0,0 +1,97 @@
+use genmc_sys::MemOrdering;
+use rustc_abi::Size;
+use rustc_const_eval::interpret::{InterpResult, interp_ok};
+use rustc_middle::ty::ScalarInt;
+use tracing::debug;
+
+use super::GenmcScalar;
+use crate::{AtomicReadOrd, AtomicWriteOrd, MiriInterpCx, Scalar, throw_unsup_format};
+
+/// Maximum size memory access in bytes that GenMC supports.
+pub(super) const MAX_ACCESS_SIZE: u64 = 8;
+
+/// This function is used to split up a large memory access into aligned, non-overlapping chunks of a limited size.
+/// Returns an iterator over the chunks, yielding `(base address, size)` of each chunk, ordered by address.
+pub fn split_access(address: Size, size: Size) -> impl Iterator<Item = (u64, u64)> {
+    let start_address = address.bytes();
+    let end_address = start_address + size.bytes();
+
+    let start_address_aligned = start_address.next_multiple_of(MAX_ACCESS_SIZE);
+    let end_address_aligned = (end_address / MAX_ACCESS_SIZE) * MAX_ACCESS_SIZE; // prev_multiple_of
+
+    debug!(
+        "GenMC: splitting NA memory access into {MAX_ACCESS_SIZE} byte chunks: {}B + {} * {MAX_ACCESS_SIZE}B + {}B = {size:?}",
+        start_address_aligned - start_address,
+        (end_address_aligned - start_address_aligned) / MAX_ACCESS_SIZE,
+        end_address - end_address_aligned,
+    );
+
+    // FIXME(genmc): could make remaining accesses powers-of-2, instead of 1 byte.
+    let start_chunks = (start_address..start_address_aligned).map(|address| (address, 1));
+    let aligned_chunks = (start_address_aligned..end_address_aligned)
+        .step_by(MAX_ACCESS_SIZE.try_into().unwrap())
+        .map(|address| (address, MAX_ACCESS_SIZE));
+    let end_chunks = (end_address_aligned..end_address).map(|address| (address, 1));
+
+    start_chunks.chain(aligned_chunks).chain(end_chunks)
+}
+
+/// Inverse function to `scalar_to_genmc_scalar`.
+///
+/// Convert a Miri `Scalar` to a `GenmcScalar`.
+/// To be able to restore pointer provenance from a `GenmcScalar`, the base address of the allocation of the pointer is also stored in the `GenmcScalar`.
+/// We cannot use the `AllocId` instead of the base address, since Miri has no control over the `AllocId`, and it may change across executions.
+/// Pointers with `Wildcard` provenance are not supported.
+pub fn scalar_to_genmc_scalar<'tcx>(
+    _ecx: &MiriInterpCx<'tcx>,
+    scalar: Scalar,
+) -> InterpResult<'tcx, GenmcScalar> {
+    interp_ok(match scalar {
+        rustc_const_eval::interpret::Scalar::Int(scalar_int) => {
+            // FIXME(genmc): Add u128 support once GenMC supports it.
+            let value: u64 = scalar_int.to_uint(scalar_int.size()).try_into().unwrap();
+            GenmcScalar { value, is_init: true }
+        }
+        rustc_const_eval::interpret::Scalar::Ptr(_pointer, _size) =>
+            throw_unsup_format!(
+                "FIXME(genmc): Implement sending pointers (with provenance) to GenMC."
+            ),
+    })
+}
+
+/// Inverse function to `scalar_to_genmc_scalar`.
+///
+/// Convert a `GenmcScalar` back into a Miri `Scalar`.
+/// For pointers, attempt to convert the stored base address of their allocation back into an `AllocId`.
+pub fn genmc_scalar_to_scalar<'tcx>(
+    _ecx: &MiriInterpCx<'tcx>,
+    scalar: GenmcScalar,
+    size: Size,
+) -> InterpResult<'tcx, Scalar> {
+    // FIXME(genmc): Add GenmcScalar to Miri Pointer conversion.
+
+    // NOTE: GenMC always returns 64 bit values, and the upper bits are not yet truncated.
+    // FIXME(genmc): GenMC should be doing the truncation, not Miri.
+    let (value_scalar_int, _got_truncated) = ScalarInt::truncate_from_uint(scalar.value, size);
+    interp_ok(Scalar::Int(value_scalar_int))
+}
+
+impl AtomicReadOrd {
+    pub(super) fn to_genmc(self) -> MemOrdering {
+        match self {
+            AtomicReadOrd::Relaxed => MemOrdering::Relaxed,
+            AtomicReadOrd::Acquire => MemOrdering::Acquire,
+            AtomicReadOrd::SeqCst => MemOrdering::SequentiallyConsistent,
+        }
+    }
+}
+
+impl AtomicWriteOrd {
+    pub(super) fn to_genmc(self) -> MemOrdering {
+        match self {
+            AtomicWriteOrd::Relaxed => MemOrdering::Relaxed,
+            AtomicWriteOrd::Release => MemOrdering::Release,
+            AtomicWriteOrd::SeqCst => MemOrdering::SequentiallyConsistent,
+        }
+    }
+}
diff --git a/src/tools/miri/src/concurrency/genmc/mod.rs b/src/tools/miri/src/concurrency/genmc/mod.rs
index 3617775e27eaf..b5d20a439c01c 100644
--- a/src/tools/miri/src/concurrency/genmc/mod.rs
+++ b/src/tools/miri/src/concurrency/genmc/mod.rs
@@ -1,78 +1,171 @@
-#![allow(unused)] // FIXME(GenMC): remove this
+use std::cell::{Cell, RefCell};
+use std::sync::Arc;
 
-use std::cell::Cell;
-
-use genmc_sys::{GenmcParams, createGenmcHandle};
+use genmc_sys::{
+    GENMC_GLOBAL_ADDRESSES_MASK, GenmcScalar, MemOrdering, MiriGenmcShim, UniquePtr,
+    create_genmc_driver_handle,
+};
 use rustc_abi::{Align, Size};
-use rustc_const_eval::interpret::{InterpCx, InterpResult, interp_ok};
-use rustc_middle::mir;
-
+use rustc_const_eval::interpret::{AllocId, InterpCx, InterpResult, interp_ok};
+use rustc_middle::{mir, throw_machine_stop, throw_ub_format, throw_unsup_format};
+// FIXME(genmc,tracing): Implement some work-around for enabling debug/trace level logging (currently disabled statically in rustc).
+use tracing::{debug, info};
+
+use self::global_allocations::{EvalContextExt as _, GlobalAllocationHandler};
+use self::helper::{MAX_ACCESS_SIZE, genmc_scalar_to_scalar, scalar_to_genmc_scalar};
+use self::thread_id_map::ThreadIdMap;
+use crate::concurrency::genmc::helper::split_access;
 use crate::{
     AtomicFenceOrd, AtomicReadOrd, AtomicRwOrd, AtomicWriteOrd, MemoryKind, MiriConfig,
-    MiriMachine, Scalar, ThreadId, ThreadManager, VisitProvenance, VisitWith,
+    MiriMachine, MiriMemoryKind, Scalar, TerminationInfo, ThreadId, ThreadManager, VisitProvenance,
+    VisitWith,
 };
 
 mod config;
+mod global_allocations;
+mod helper;
+mod run;
+pub(crate) mod scheduling;
+mod thread_id_map;
 
 pub use self::config::GenmcConfig;
+pub use self::run::run_genmc_mode;
 
-// FIXME(GenMC): add fields
-pub struct GenmcCtx {
-    /// Some actions Miri does are allowed to cause data races.
-    /// GenMC will not be informed about certain actions (e.g. non-atomic loads) when this flag is set.
+#[derive(Clone, Copy, Debug)]
+pub enum ExitType {
+    MainThreadFinish,
+    ExitCalled,
+}
+
+/// The exit status of a program.
+/// GenMC must store this if a thread exits while any others can still run.
+/// The other threads must also be explored before the program is terminated.
+#[derive(Clone, Copy, Debug)]
+struct ExitStatus {
+    exit_code: i32,
+    exit_type: ExitType,
+}
+
+impl ExitStatus {
+    fn do_leak_check(self) -> bool {
+        matches!(self.exit_type, ExitType::MainThreadFinish)
+    }
+}
+
+/// State that is reset at the start of every execution.
+#[derive(Debug, Default)]
+struct PerExecutionState {
+    /// Thread id management, such as mapping between Miri `ThreadId` and GenMC's thread ids, or selecting GenMC thread ids.
+    thread_id_manager: RefCell<ThreadIdMap>,
+
+    /// A flag to indicate that we should not forward non-atomic accesses to genmc, e.g. because we
+    /// are executing an atomic operation.
     allow_data_races: Cell<bool>,
+
+    /// The exit status of the program. We keep running other threads even after `exit` to ensure
+    /// we cover all possible executions.
+    /// `None` if no thread has called `exit` and the main thread isn't finished yet.
+    exit_status: Cell<Option<ExitStatus>>,
 }
 
-impl GenmcCtx {
-    /// Create a new `GenmcCtx` from a given config.
-    pub fn new(miri_config: &MiriConfig) -> Self {
-        let genmc_config = miri_config.genmc_config.as_ref().unwrap();
+impl PerExecutionState {
+    fn reset(&self) {
+        self.allow_data_races.replace(false);
+        self.thread_id_manager.borrow_mut().reset();
+        self.exit_status.set(None);
+    }
+}
 
-        let handle = createGenmcHandle(&genmc_config.params);
-        assert!(!handle.is_null());
+#[derive(Debug)]
+struct GlobalState {
+    /// Keep track of global allocations, to ensure they keep the same address across different executions, even if the order of allocations changes.
+    /// The `AllocId` for globals is stable across executions, so we can use it as an identifier.
+    global_allocations: GlobalAllocationHandler,
+}
 
-        eprintln!("Miri: GenMC handle creation successful!");
+impl GlobalState {
+    fn new(target_usize_max: u64) -> Self {
+        Self { global_allocations: GlobalAllocationHandler::new(target_usize_max) }
+    }
+}
 
-        drop(handle);
-        eprintln!("Miri: Dropping GenMC handle successful!");
+/// The main interface with GenMC.
+/// Each `GenmcCtx` owns one `MiriGenmcShim`, which owns one `GenMCDriver` (the GenMC model checker).
+/// For each GenMC run (estimation or verification), one or more `GenmcCtx` can be created (one per Miri thread).
+/// However, for now, we only ever have one `GenmcCtx` per run.
+///
+/// In multithreading, each worker thread has its own `GenmcCtx`, which will have their results combined in the end.
+/// FIXME(genmc): implement multithreading.
+///
+/// Some data is shared across all `GenmcCtx` in the same run, namely data for global allocation handling.
+/// Globals must be allocated in a consistent manner, i.e., each global allocation must have the same address in each execution.
+///
+/// Some state is reset between each execution in the same run.
+pub struct GenmcCtx {
+    /// Handle to the GenMC model checker.
+    handle: RefCell<UniquePtr<MiriGenmcShim>>,
 
-        // FIXME(GenMC): implement
-        std::process::exit(0);
+    /// State that is reset at the start of every execution.
+    exec_state: PerExecutionState,
+
+    /// State that persists across executions.
+    /// All `GenmcCtx` in one verification step share this state.
+    global_state: Arc<GlobalState>,
+}
+
+/// GenMC Context creation and administrative / query actions
+impl GenmcCtx {
+    /// Create a new `GenmcCtx` from a given config.
+    fn new(miri_config: &MiriConfig, global_state: Arc<GlobalState>) -> Self {
+        let genmc_config = miri_config.genmc_config.as_ref().unwrap();
+        let handle =
+            RefCell::new(create_genmc_driver_handle(&genmc_config.params, genmc_config.log_level));
+        Self { handle, exec_state: Default::default(), global_state }
     }
 
-    pub fn get_stuck_execution_count(&self) -> usize {
-        todo!()
+    /// Get the number of blocked executions encountered by GenMC.
+    pub fn get_blocked_execution_count(&self) -> u64 {
+        let mc = self.handle.borrow();
+        mc.as_ref().unwrap().get_blocked_execution_count()
     }
 
-    pub fn print_genmc_graph(&self) {
-        todo!()
+    /// Get the number of explored executions encountered by GenMC.
+    pub fn get_explored_execution_count(&self) -> u64 {
+        let mc = self.handle.borrow();
+        mc.as_ref().unwrap().get_explored_execution_count()
     }
 
-    /// This function determines if we should continue exploring executions or if we are done.
-    ///
-    /// In GenMC mode, the input program should be repeatedly executed until this function returns `true` or an error is found.
-    pub fn is_exploration_done(&self) -> bool {
-        todo!()
+    /// Check if GenMC encountered an error that wasn't immediately returned during execution.
+    /// Returns a string representation of the error if one occurred.
+    pub fn try_get_error(&self) -> Option<String> {
+        let mc = self.handle.borrow();
+        mc.as_ref()
+            .unwrap()
+            .get_error_string()
+            .as_ref()
+            .map(|error| error.to_string_lossy().to_string())
     }
 
-    /// Inform GenMC that a new program execution has started.
-    /// This function should be called at the start of every execution.
-    pub(crate) fn handle_execution_start(&self) {
-        todo!()
+    /// Check if GenMC encountered an error that wasn't immediately returned during execution.
+    /// Returns a string representation of the error if one occurred.
+    pub fn get_result_message(&self) -> String {
+        let mc = self.handle.borrow();
+        mc.as_ref()
+            .unwrap()
+            .get_result_message()
+            .as_ref()
+            .map(|error| error.to_string_lossy().to_string())
+            .expect("there should always be a message")
     }
 
-    /// Inform GenMC that the program's execution has ended.
+    /// This function determines if we should continue exploring executions or if we are done.
     ///
-    /// This function must be called even when the execution got stuck (i.e., it returned a `InterpErrorKind::MachineStop` with error kind `TerminationInfo::GenmcStuckExecution`).
-    pub(crate) fn handle_execution_end<'tcx>(
-        &self,
-        ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
-    ) -> Result<(), String> {
-        todo!()
+    /// In GenMC mode, the input program should be repeatedly executed until this function returns `true` or an error is found.
+    pub fn is_exploration_done(&self) -> bool {
+        let mut mc = self.handle.borrow_mut();
+        mc.as_mut().unwrap().is_exploration_done()
     }
 
-    /**** Memory access handling ****/
-
     /// Select whether data race free actions should be allowed. This function should be used carefully!
     ///
     /// If `true` is passed, allow for data races to happen without triggering an error, until this function is called again with argument `false`.
@@ -83,10 +176,59 @@ impl GenmcCtx {
     /// # Panics
     /// If data race free is attempted to be set more than once (i.e., no nesting allowed).
     pub(super) fn set_ongoing_action_data_race_free(&self, enable: bool) {
-        let old = self.allow_data_races.replace(enable);
+        debug!("GenMC: set_ongoing_action_data_race_free ({enable})");
+        let old = self.exec_state.allow_data_races.replace(enable);
         assert_ne!(old, enable, "cannot nest allow_data_races");
     }
 
+    /// Check whether data races are currently allowed (e.g., for loading values for validation which are not actually loaded by the program).
+    fn get_alloc_data_races(&self) -> bool {
+        self.exec_state.allow_data_races.get()
+    }
+}
+
+/// GenMC event handling. These methods are used to inform GenMC about events happening in the program, and to handle scheduling decisions.
+impl GenmcCtx {
+    /// Prepare for the next execution and inform GenMC about it.
+    /// Must be called before at the start of every execution.
+    fn prepare_next_execution(&self) {
+        // Reset per-execution state.
+        self.exec_state.reset();
+        // Inform GenMC about the new execution.
+        let mut mc = self.handle.borrow_mut();
+        mc.as_mut().unwrap().handle_execution_start();
+    }
+
+    /// Inform GenMC that the program's execution has ended.
+    ///
+    /// This function must be called even when the execution is blocked
+    /// (i.e., it returned a `InterpErrorKind::MachineStop` with error kind `TerminationInfo::GenmcBlockedExecution`).
+    /// Don't call this function if an error was found.
+    ///
+    /// GenMC detects certain errors only when the execution ends.
+    /// If an error occured, a string containing a short error description is returned.
+    ///
+    /// GenMC currently doesn't return an error in all cases immediately when one happens.
+    /// This function will also check for those, and return their error description.
+    ///
+    /// To get the all messages (warnings, errors) that GenMC produces, use the `get_result_message` method.
+    fn handle_execution_end(&self) -> Option<String> {
+        let mut mc = self.handle.borrow_mut();
+        let result = mc.as_mut().unwrap().handle_execution_end();
+        result.as_ref().map(|msg| msg.to_string_lossy().to_string())?;
+
+        // GenMC currently does not return an error value immediately in all cases.
+        // We manually query for any errors here to ensure we don't miss any.
+        drop(mc); // `try_get_error` needs access to the `RefCell`.
+        self.try_get_error()
+    }
+
+    /**** Memory access handling ****/
+
+    /// Inform GenMC about an atomic load.
+    /// Returns that value that the load should read.
+    ///
+    /// `old_value` is the value that a non-atomic load would read here, or `None` if the memory is uninitalized.
     pub(crate) fn atomic_load<'tcx>(
         &self,
         ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
@@ -95,89 +237,143 @@ impl GenmcCtx {
         ordering: AtomicReadOrd,
         old_val: Option<Scalar>,
     ) -> InterpResult<'tcx, Scalar> {
-        assert!(!self.allow_data_races.get());
-        todo!()
+        assert!(!self.get_alloc_data_races(), "atomic load with data race checking disabled.");
+        let genmc_old_value = if let Some(scalar) = old_val {
+            scalar_to_genmc_scalar(ecx, scalar)?
+        } else {
+            GenmcScalar::UNINIT
+        };
+        let read_value =
+            self.handle_load(&ecx.machine, address, size, ordering.to_genmc(), genmc_old_value)?;
+        genmc_scalar_to_scalar(ecx, read_value, size)
     }
 
+    /// Inform GenMC about an atomic store.
+    /// Returns `true` if the stored value should be reflected in Miri's memory.
+    ///
+    /// `old_value` is the value that a non-atomic load would read here, or `None` if the memory is uninitalized.
     pub(crate) fn atomic_store<'tcx>(
         &self,
         ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
         address: Size,
         size: Size,
         value: Scalar,
+        old_value: Option<Scalar>,
         ordering: AtomicWriteOrd,
-    ) -> InterpResult<'tcx, ()> {
-        assert!(!self.allow_data_races.get());
-        todo!()
+    ) -> InterpResult<'tcx, bool> {
+        assert!(!self.get_alloc_data_races(), "atomic store with data race checking disabled.");
+        let genmc_value = scalar_to_genmc_scalar(ecx, value)?;
+        let genmc_old_value = if let Some(scalar) = old_value {
+            scalar_to_genmc_scalar(ecx, scalar)?
+        } else {
+            GenmcScalar::UNINIT
+        };
+        self.handle_store(
+            &ecx.machine,
+            address,
+            size,
+            genmc_value,
+            genmc_old_value,
+            ordering.to_genmc(),
+        )
     }
 
+    /// Inform GenMC about an atomic fence.
     pub(crate) fn atomic_fence<'tcx>(
         &self,
-        machine: &MiriMachine<'tcx>,
-        ordering: AtomicFenceOrd,
-    ) -> InterpResult<'tcx, ()> {
-        assert!(!self.allow_data_races.get());
-        todo!()
+        _machine: &MiriMachine<'tcx>,
+        _ordering: AtomicFenceOrd,
+    ) -> InterpResult<'tcx> {
+        assert!(!self.get_alloc_data_races(), "atomic fence with data race checking disabled.");
+        throw_unsup_format!("FIXME(genmc): Add support for atomic fences.")
     }
 
     /// Inform GenMC about an atomic read-modify-write operation.
     ///
-    /// Returns `(old_val, new_val)`.
+    /// Returns `(old_val, Option<new_val>)`. `new_val` might not be the latest write in coherence order, which is indicated by `None`.
+    ///
+    /// `old_value` is the value that a non-atomic load would read here, or `None` if the memory is uninitalized.
     pub(crate) fn atomic_rmw_op<'tcx>(
         &self,
-        ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
-        address: Size,
-        size: Size,
-        ordering: AtomicRwOrd,
-        (rmw_op, not): (mir::BinOp, bool),
-        rhs_scalar: Scalar,
-    ) -> InterpResult<'tcx, (Scalar, Scalar)> {
-        assert!(!self.allow_data_races.get());
-        todo!()
+        _ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
+        _address: Size,
+        _size: Size,
+        _ordering: AtomicRwOrd,
+        (_rmw_op, _not): (mir::BinOp, bool),
+        _rhs_scalar: Scalar,
+        _old_value: Scalar,
+    ) -> InterpResult<'tcx, (Scalar, Option<Scalar>)> {
+        assert!(
+            !self.get_alloc_data_races(),
+            "atomic read-modify-write operation with data race checking disabled."
+        );
+        throw_unsup_format!("FIXME(genmc): Add support for atomic RMW.")
     }
 
     /// Inform GenMC about an atomic `min` or `max` operation.
     ///
-    /// Returns `(old_val, new_val)`.
+    /// Returns `(old_val, Option<new_val>)`. `new_val` might not be the latest write in coherence order, which is indicated by `None`.
+    ///
+    /// `old_value` is the value that a non-atomic load would read here, or `None` if the memory is uninitalized.
     pub(crate) fn atomic_min_max_op<'tcx>(
         &self,
-        ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
-        address: Size,
-        size: Size,
-        ordering: AtomicRwOrd,
-        min: bool,
-        is_signed: bool,
-        rhs_scalar: Scalar,
-    ) -> InterpResult<'tcx, (Scalar, Scalar)> {
-        assert!(!self.allow_data_races.get());
-        todo!()
+        _ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
+        _address: Size,
+        _size: Size,
+        _ordering: AtomicRwOrd,
+        _min: bool,
+        _is_signed: bool,
+        _rhs_scalar: Scalar,
+        _old_value: Scalar,
+    ) -> InterpResult<'tcx, (Scalar, Option<Scalar>)> {
+        assert!(
+            !self.get_alloc_data_races(),
+            "atomic min/max operation with data race checking disabled."
+        );
+        throw_unsup_format!("FIXME(genmc): Add support for atomic min/max.")
     }
 
+    /// Returns `(old_val, Option<new_val>)`. `new_val` might not be the latest write in coherence order, which is indicated by `None`.
+    ///
+    /// `old_value` is the value that a non-atomic load would read here, or `None` if the memory is uninitalized.
     pub(crate) fn atomic_exchange<'tcx>(
         &self,
-        ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
-        address: Size,
-        size: Size,
-        rhs_scalar: Scalar,
-        ordering: AtomicRwOrd,
-    ) -> InterpResult<'tcx, (Scalar, bool)> {
-        assert!(!self.allow_data_races.get());
-        todo!()
+        _ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
+        _address: Size,
+        _size: Size,
+        _rhs_scalar: Scalar,
+        _ordering: AtomicRwOrd,
+        _old_value: Scalar,
+    ) -> InterpResult<'tcx, (Scalar, Option<Scalar>)> {
+        assert!(
+            !self.get_alloc_data_races(),
+            "atomic swap operation with data race checking disabled."
+        );
+        throw_unsup_format!("FIXME(genmc): Add support for atomic swap.")
     }
 
+    /// Inform GenMC about an atomic compare-exchange operation.
+    ///
+    /// Returns the old value read by the compare exchange, optionally the value that Miri should write back to its memory, and whether the compare-exchange was a success or not.
+    ///
+    /// `old_value` is the value that a non-atomic load would read here, or `None` if the memory is uninitalized.
     pub(crate) fn atomic_compare_exchange<'tcx>(
         &self,
-        ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
-        address: Size,
-        size: Size,
-        expected_old_value: Scalar,
-        new_value: Scalar,
-        success: AtomicRwOrd,
-        fail: AtomicReadOrd,
-        can_fail_spuriously: bool,
-    ) -> InterpResult<'tcx, (Scalar, bool)> {
-        assert!(!self.allow_data_races.get());
-        todo!()
+        _ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
+        _address: Size,
+        _size: Size,
+        _expected_old_value: Scalar,
+        _new_value: Scalar,
+        _success: AtomicRwOrd,
+        _fail: AtomicReadOrd,
+        _can_fail_spuriously: bool,
+        _old_value: Scalar,
+    ) -> InterpResult<'tcx, (Scalar, Option<Scalar>, bool)> {
+        assert!(
+            !self.get_alloc_data_races(),
+            "atomic compare-exchange with data race checking disabled."
+        );
+        throw_unsup_format!("FIXME(genmc): Add support for atomic compare_exchange.")
     }
 
     /// Inform GenMC about a non-atomic memory load
@@ -188,40 +384,178 @@ impl GenmcCtx {
         machine: &MiriMachine<'tcx>,
         address: Size,
         size: Size,
-    ) -> InterpResult<'tcx, ()> {
-        todo!()
+    ) -> InterpResult<'tcx> {
+        debug!(
+            "GenMC: received memory_load (non-atomic): address: {:#x}, size: {}",
+            address.bytes(),
+            size.bytes()
+        );
+        if self.get_alloc_data_races() {
+            debug!("GenMC: data race checking disabled, ignoring non-atomic load.");
+            return interp_ok(());
+        }
+        // GenMC doesn't like ZSTs, and they can't have any data races, so we skip them
+        if size.bytes() == 0 {
+            return interp_ok(());
+        }
+
+        let handle_load = |address, size| {
+            // NOTE: Values loaded non-atomically are still handled by Miri, so we discard whatever we get from GenMC
+            let _read_value = self.handle_load(
+                machine,
+                address,
+                size,
+                MemOrdering::NotAtomic,
+                // This value is used to update the co-maximal store event to the same location.
+                // We don't need to update that store, since if it is ever read by any atomic loads, the value will be updated then.
+                // We use uninit for lack of a better value, since we don't know whether the location we currently load from is initialized or not.
+                GenmcScalar::UNINIT,
+            )?;
+            interp_ok(())
+        };
+
+        // This load is small enough so GenMC can handle it.
+        if size.bytes() <= MAX_ACCESS_SIZE {
+            return handle_load(address, size);
+        }
+
+        // This load is too big to be a single GenMC access, we have to split it.
+        // FIXME(genmc): This will misbehave if there are non-64bit-atomics in there.
+        // Needs proper support on the GenMC side for large and mixed atomic accesses.
+        for (address, size) in split_access(address, size) {
+            handle_load(Size::from_bytes(address), Size::from_bytes(size))?;
+        }
+        interp_ok(())
     }
 
+    /// Inform GenMC about a non-atomic memory store
+    ///
+    /// NOTE: Unlike for *atomic* stores, we don't provide the actual stored values to GenMC here.
     pub(crate) fn memory_store<'tcx>(
         &self,
         machine: &MiriMachine<'tcx>,
         address: Size,
         size: Size,
-    ) -> InterpResult<'tcx, ()> {
-        todo!()
+    ) -> InterpResult<'tcx> {
+        debug!(
+            "GenMC: received memory_store (non-atomic): address: {:#x}, size: {}",
+            address.bytes(),
+            size.bytes()
+        );
+        if self.get_alloc_data_races() {
+            debug!("GenMC: data race checking disabled, ignoring non-atomic store.");
+            return interp_ok(());
+        }
+        // GenMC doesn't like ZSTs, and they can't have any data races, so we skip them
+        if size.bytes() == 0 {
+            return interp_ok(());
+        }
+
+        let handle_store = |address, size| {
+            // We always write the the stored values to Miri's memory, whether GenMC says the write is co-maximal or not.
+            // The GenMC scheduler ensures that replaying an execution happens in porf-respecting order (po := program order, rf: reads-from order).
+            // This means that for any non-atomic read Miri performs, the corresponding write has already been replayed.
+            let _is_co_max_write = self.handle_store(
+                machine,
+                address,
+                size,
+                // We don't know the value that this store will write, but GenMC expects that we give it an actual value.
+                // Unfortunately, there are situations where this value can actually become visible
+                // to the program: when there is an atomic load reading from a non-atomic store.
+                // FIXME(genmc): update once mixed atomic-non-atomic support is added. Afterwards, this value should never be readable.
+                GenmcScalar::from_u64(0xDEADBEEF),
+                // This value is used to update the co-maximal store event to the same location.
+                // This old value cannot be read anymore by any future loads, since we are doing another non-atomic store to the same location.
+                // Any future load will either see the store we are adding now, or we have a data race (there can only be one possible non-atomic value to read from at any time).
+                // We use uninit for lack of a better value, since we don't know whether the location we currently write to is initialized or not.
+                GenmcScalar::UNINIT,
+                MemOrdering::NotAtomic,
+            )?;
+            interp_ok(())
+        };
+
+        // This store is small enough so GenMC can handle it.
+        if size.bytes() <= MAX_ACCESS_SIZE {
+            return handle_store(address, size);
+        }
+
+        // This store is too big to be a single GenMC access, we have to split it.
+        // FIXME(genmc): This will misbehave if there are non-64bit-atomics in there.
+        // Needs proper support on the GenMC side for large and mixed atomic accesses.
+        for (address, size) in split_access(address, size) {
+            handle_store(Size::from_bytes(address), Size::from_bytes(size))?;
+        }
+        interp_ok(())
     }
 
     /**** Memory (de)allocation ****/
 
+    /// This is also responsible for determining the address of the new allocation.
     pub(crate) fn handle_alloc<'tcx>(
         &self,
-        machine: &MiriMachine<'tcx>,
+        ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
+        alloc_id: AllocId,
         size: Size,
         alignment: Align,
         memory_kind: MemoryKind,
     ) -> InterpResult<'tcx, u64> {
-        todo!()
+        assert!(
+            !self.get_alloc_data_races(),
+            "memory allocation with data race checking disabled."
+        );
+        let machine = &ecx.machine;
+        if memory_kind == MiriMemoryKind::Global.into() {
+            return ecx
+                .get_global_allocation_address(&self.global_state.global_allocations, alloc_id);
+        }
+        let thread_infos = self.exec_state.thread_id_manager.borrow();
+        let curr_thread = machine.threads.active_thread();
+        let genmc_tid = thread_infos.get_genmc_tid(curr_thread);
+        // GenMC doesn't support ZSTs, so we set the minimum size to 1 byte
+        let genmc_size = size.bytes().max(1);
+
+        let mut mc = self.handle.borrow_mut();
+        let pinned_mc = mc.as_mut().unwrap();
+        let chosen_address = pinned_mc.handle_malloc(genmc_tid, genmc_size, alignment.bytes());
+
+        // Non-global addresses should not be in the global address space or null.
+        assert_ne!(0, chosen_address, "GenMC malloc returned nullptr.");
+        assert_eq!(0, chosen_address & GENMC_GLOBAL_ADDRESSES_MASK);
+        // Sanity check the address alignment:
+        assert!(
+            chosen_address.is_multiple_of(alignment.bytes()),
+            "GenMC returned address {chosen_address:#x} with lower alignment than requested ({}).",
+            alignment.bytes()
+        );
+
+        interp_ok(chosen_address)
     }
 
     pub(crate) fn handle_dealloc<'tcx>(
         &self,
         machine: &MiriMachine<'tcx>,
+        alloc_id: AllocId,
         address: Size,
-        size: Size,
-        align: Align,
         kind: MemoryKind,
-    ) -> InterpResult<'tcx, ()> {
-        todo!()
+    ) -> InterpResult<'tcx> {
+        assert_ne!(
+            kind,
+            MiriMemoryKind::Global.into(),
+            "we probably shouldn't try to deallocate global allocations (alloc_id: {alloc_id:?})"
+        );
+        assert!(
+            !self.get_alloc_data_races(),
+            "memory deallocation with data race checking disabled."
+        );
+        let thread_infos = self.exec_state.thread_id_manager.borrow();
+        let curr_thread = machine.threads.active_thread();
+        let genmc_tid = thread_infos.get_genmc_tid(curr_thread);
+
+        let mut mc = self.handle.borrow_mut();
+        let pinned_mc = mc.as_mut().unwrap();
+        pinned_mc.handle_free(genmc_tid, address.bytes());
+
+        interp_ok(())
     }
 
     /**** Thread management ****/
@@ -229,50 +563,95 @@ impl GenmcCtx {
     pub(crate) fn handle_thread_create<'tcx>(
         &self,
         threads: &ThreadManager<'tcx>,
+        // FIXME(genmc,symmetry reduction): pass info to GenMC
+        _start_routine: crate::Pointer,
+        _func_arg: &crate::ImmTy<'tcx>,
         new_thread_id: ThreadId,
-    ) -> InterpResult<'tcx, ()> {
-        assert!(!self.allow_data_races.get());
-        todo!()
+    ) -> InterpResult<'tcx> {
+        assert!(!self.get_alloc_data_races(), "thread creation with data race checking disabled.");
+        let mut thread_infos = self.exec_state.thread_id_manager.borrow_mut();
+
+        let curr_thread_id = threads.active_thread();
+        let genmc_parent_tid = thread_infos.get_genmc_tid(curr_thread_id);
+        let genmc_new_tid = thread_infos.add_thread(new_thread_id);
+
+        let mut mc = self.handle.borrow_mut();
+        mc.as_mut().unwrap().handle_thread_create(genmc_new_tid, genmc_parent_tid);
+
+        interp_ok(())
     }
 
     pub(crate) fn handle_thread_join<'tcx>(
         &self,
         active_thread_id: ThreadId,
         child_thread_id: ThreadId,
-    ) -> InterpResult<'tcx, ()> {
-        assert!(!self.allow_data_races.get());
-        todo!()
-    }
+    ) -> InterpResult<'tcx> {
+        assert!(!self.get_alloc_data_races(), "thread join with data race checking disabled.");
+        let thread_infos = self.exec_state.thread_id_manager.borrow();
 
-    pub(crate) fn handle_thread_stack_empty(&self, thread_id: ThreadId) {
-        todo!()
-    }
+        let genmc_curr_tid = thread_infos.get_genmc_tid(active_thread_id);
+        let genmc_child_tid = thread_infos.get_genmc_tid(child_thread_id);
 
-    pub(crate) fn handle_thread_finish<'tcx>(
-        &self,
-        threads: &ThreadManager<'tcx>,
-    ) -> InterpResult<'tcx, ()> {
-        assert!(!self.allow_data_races.get());
-        todo!()
+        let mut mc = self.handle.borrow_mut();
+        mc.as_mut().unwrap().handle_thread_join(genmc_curr_tid, genmc_child_tid);
+
+        interp_ok(())
     }
 
-    /**** Scheduling functionality ****/
+    pub(crate) fn handle_thread_finish<'tcx>(&self, threads: &ThreadManager<'tcx>) {
+        assert!(!self.get_alloc_data_races(), "thread finish with data race checking disabled.");
+        let curr_thread_id = threads.active_thread();
 
-    /// Ask for a scheduling decision. This should be called before every MIR instruction.
-    ///
-    /// GenMC may realize that the execution got stuck, then this function will return a `InterpErrorKind::MachineStop` with error kind `TerminationInfo::GenmcStuckExecution`).
-    ///
-    /// This is **not** an error by iself! Treat this as if the program ended normally: `handle_execution_end` should be called next, which will determine if were are any actual errors.
-    pub(crate) fn schedule_thread<'tcx>(
+        let thread_infos = self.exec_state.thread_id_manager.borrow();
+        let genmc_tid = thread_infos.get_genmc_tid(curr_thread_id);
+
+        debug!("GenMC: thread {curr_thread_id:?} ({genmc_tid:?}) finished.");
+        let mut mc = self.handle.borrow_mut();
+        // NOTE: Miri doesn't support return values for threads, but GenMC expects one, so we return 0
+        mc.as_mut().unwrap().handle_thread_finish(genmc_tid, /* ret_val */ 0);
+    }
+
+    /// Handle a call to `libc::exit` or the exit of the main thread.
+    /// Unless an error is returned, the program should continue executing (in a different thread, chosen by the next scheduling call).
+    pub(crate) fn handle_exit<'tcx>(
         &self,
-        ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
-    ) -> InterpResult<'tcx, ThreadId> {
-        assert!(!self.allow_data_races.get());
-        todo!()
+        thread: ThreadId,
+        exit_code: i32,
+        exit_type: ExitType,
+    ) -> InterpResult<'tcx> {
+        // Calling `libc::exit` doesn't do cleanup, so we skip the leak check in that case.
+        let exit_status = ExitStatus { exit_code, exit_type };
+
+        if let Some(old_exit_status) = self.exec_state.exit_status.get() {
+            throw_ub_format!(
+                "`exit` called twice, first with status {old_exit_status:?}, now with status {exit_status:?}",
+            );
+        }
+
+        // FIXME(genmc): Add a flag to continue exploration even when the program exits with a non-zero exit code.
+        if exit_code != 0 {
+            info!("GenMC: 'exit' called with non-zero argument, aborting execution.");
+            let leak_check = exit_status.do_leak_check();
+            throw_machine_stop!(TerminationInfo::Exit { code: exit_code, leak_check });
+        }
+
+        if matches!(exit_type, ExitType::ExitCalled) {
+            let thread_infos = self.exec_state.thread_id_manager.borrow();
+            let genmc_tid = thread_infos.get_genmc_tid(thread);
+
+            let mut mc = self.handle.borrow_mut();
+            mc.as_mut().unwrap().handle_thread_kill(genmc_tid);
+        } else {
+            assert_eq!(thread, ThreadId::MAIN_THREAD);
+        }
+        // We continue executing now, so we store the exit status.
+        self.exec_state.exit_status.set(Some(exit_status));
+        interp_ok(())
     }
 
     /**** Blocking instructions ****/
 
+    #[allow(unused)]
     pub(crate) fn handle_verifier_assume<'tcx>(
         &self,
         machine: &MiriMachine<'tcx>,
@@ -282,14 +661,119 @@ impl GenmcCtx {
     }
 }
 
-impl VisitProvenance for GenmcCtx {
-    fn visit_provenance(&self, _visit: &mut VisitWith<'_>) {
-        // We don't have any tags.
+impl GenmcCtx {
+    /// Inform GenMC about a load (atomic or non-atomic).
+    /// Returns the value that GenMC wants this load to read.
+    fn handle_load<'tcx>(
+        &self,
+        machine: &MiriMachine<'tcx>,
+        address: Size,
+        size: Size,
+        memory_ordering: MemOrdering,
+        genmc_old_value: GenmcScalar,
+    ) -> InterpResult<'tcx, GenmcScalar> {
+        assert!(
+            size.bytes() != 0
+                && (memory_ordering == MemOrdering::NotAtomic || size.bytes().is_power_of_two())
+        );
+        if size.bytes() > MAX_ACCESS_SIZE {
+            throw_unsup_format!(
+                "GenMC mode currently does not support atomics larger than {MAX_ACCESS_SIZE} bytes.",
+            );
+        }
+        let thread_infos = self.exec_state.thread_id_manager.borrow();
+        let curr_thread_id = machine.threads.active_thread();
+        let genmc_tid = thread_infos.get_genmc_tid(curr_thread_id);
+
+        debug!(
+            "GenMC: load, thread: {curr_thread_id:?} ({genmc_tid:?}), address: {addr} == {addr:#x}, size: {size:?}, ordering: {memory_ordering:?}, old_value: {genmc_old_value:x?}",
+            addr = address.bytes()
+        );
+
+        let mut mc = self.handle.borrow_mut();
+        let pinned_mc = mc.as_mut().unwrap();
+        let load_result = pinned_mc.handle_load(
+            genmc_tid,
+            address.bytes(),
+            size.bytes(),
+            memory_ordering,
+            genmc_old_value,
+        );
+
+        if let Some(error) = load_result.error.as_ref() {
+            // FIXME(genmc): error handling
+            throw_ub_format!("{}", error.to_string_lossy());
+        }
+
+        if !load_result.has_value {
+            // FIXME(GenMC): Implementing certain GenMC optimizations will lead to this.
+            unimplemented!("GenMC: load returned no value.");
+        }
+
+        debug!("GenMC: load returned value: {:?}", load_result.read_value);
+        interp_ok(load_result.read_value)
     }
-}
 
-impl GenmcCtx {
-    fn handle_user_block<'tcx>(&self, machine: &MiriMachine<'tcx>) -> InterpResult<'tcx, ()> {
+    /// Inform GenMC about a store (atomic or non-atomic).
+    /// Returns true if the store is co-maximal, i.e., it should be written to Miri's memory too.
+    fn handle_store<'tcx>(
+        &self,
+        machine: &MiriMachine<'tcx>,
+        address: Size,
+        size: Size,
+        genmc_value: GenmcScalar,
+        genmc_old_value: GenmcScalar,
+        memory_ordering: MemOrdering,
+    ) -> InterpResult<'tcx, bool> {
+        assert!(
+            size.bytes() != 0
+                && (memory_ordering == MemOrdering::NotAtomic || size.bytes().is_power_of_two())
+        );
+        if size.bytes() > MAX_ACCESS_SIZE {
+            throw_unsup_format!(
+                "GenMC mode currently does not support atomics larger than {MAX_ACCESS_SIZE} bytes."
+            );
+        }
+        let thread_infos = self.exec_state.thread_id_manager.borrow();
+        let curr_thread_id = machine.threads.active_thread();
+        let genmc_tid = thread_infos.get_genmc_tid(curr_thread_id);
+
+        debug!(
+            "GenMC: store, thread: {curr_thread_id:?} ({genmc_tid:?}), address: {addr} = {addr:#x}, size: {size:?}, ordering {memory_ordering:?}, value: {genmc_value:?}",
+            addr = address.bytes()
+        );
+
+        let mut mc = self.handle.borrow_mut();
+        let pinned_mc = mc.as_mut().unwrap();
+        let store_result = pinned_mc.handle_store(
+            genmc_tid,
+            address.bytes(),
+            size.bytes(),
+            genmc_value,
+            genmc_old_value,
+            memory_ordering,
+        );
+
+        if let Some(error) = store_result.error.as_ref() {
+            // FIXME(genmc): error handling
+            throw_ub_format!("{}", error.to_string_lossy());
+        }
+
+        interp_ok(store_result.is_coherence_order_maximal_write)
+    }
+
+    /**** Blocking functionality ****/
+
+    /// Handle a user thread getting blocked.
+    /// This may happen due to an manual `assume` statement added by a user
+    /// or added by some automated program transformation, e.g., for spinloops.
+    fn handle_user_block<'tcx>(&self, _machine: &MiriMachine<'tcx>) -> InterpResult<'tcx> {
         todo!()
     }
 }
+
+impl VisitProvenance for GenmcCtx {
+    fn visit_provenance(&self, _visit: &mut VisitWith<'_>) {
+        // We don't have any tags.
+    }
+}
diff --git a/src/tools/miri/src/concurrency/genmc/run.rs b/src/tools/miri/src/concurrency/genmc/run.rs
new file mode 100644
index 0000000000000..62553297a2024
--- /dev/null
+++ b/src/tools/miri/src/concurrency/genmc/run.rs
@@ -0,0 +1,71 @@
+use std::rc::Rc;
+use std::sync::Arc;
+
+use rustc_middle::ty::TyCtxt;
+
+use super::GlobalState;
+use crate::rustc_const_eval::interpret::PointerArithmetic;
+use crate::{GenmcCtx, MiriConfig};
+
+/// Do a complete run of the program in GenMC mode.
+/// This will call `eval_entry` multiple times, until either:
+/// - An error is detected (indicated by a `None` return value)
+/// - All possible executions are explored.
+///
+/// FIXME(genmc): add estimation mode setting.
+pub fn run_genmc_mode<'tcx>(
+    config: &MiriConfig,
+    eval_entry: impl Fn(Rc<GenmcCtx>) -> Option<i32>,
+    tcx: TyCtxt<'tcx>,
+) -> Option<i32> {
+    // There exists only one `global_state` per full run in GenMC mode.
+    // It is shared by all `GenmcCtx` in this run.
+    // FIXME(genmc): implement multithreading once GenMC supports it.
+    let global_state = Arc::new(GlobalState::new(tcx.target_usize_max()));
+    let genmc_ctx = Rc::new(GenmcCtx::new(config, global_state));
+
+    // `rep` is used to report the progress, Miri will panic on wrap-around.
+    for rep in 0u64.. {
+        tracing::info!("Miri-GenMC loop {}", rep + 1);
+
+        // Prepare for the next execution and inform GenMC about it.
+        genmc_ctx.prepare_next_execution();
+
+        // Execute the program until completion to get the return value, or return if an error happens:
+        // FIXME(genmc): add an option to allow the user to see the GenMC output message when the verification is done.
+        let return_code = eval_entry(genmc_ctx.clone())?;
+
+        // We inform GenMC that the execution is complete. If there was an error, we print it.
+        if let Some(error) = genmc_ctx.handle_execution_end() {
+            // This can be reached for errors that affect the entire execution, not just a specific event.
+            // For instance, linearizability checking and liveness checking report their errors this way.
+            // Neither are supported by Miri-GenMC at the moment though. However, GenMC also
+            // treats races on deallocation as global errors, so this code path is still reachable.
+            // Since we don't have any span information for the error at this point,
+            // we just print GenMC's error message.
+            eprintln!("(GenMC) Error detected: {error}");
+            eprintln!();
+            eprintln!("{}", genmc_ctx.get_result_message());
+            return None;
+        }
+
+        // Check if we've explored enough executions:
+        if !genmc_ctx.is_exploration_done() {
+            continue;
+        }
+
+        eprintln!("(GenMC) Verification complete. No errors were detected.");
+
+        let explored_execution_count = genmc_ctx.get_explored_execution_count();
+        let blocked_execution_count = genmc_ctx.get_blocked_execution_count();
+
+        eprintln!("Number of complete executions explored: {explored_execution_count}");
+        if blocked_execution_count > 0 {
+            eprintln!("Number of blocked executions seen: {blocked_execution_count}");
+        }
+
+        // Return the return code of the last execution.
+        return Some(return_code);
+    }
+    unreachable!()
+}
diff --git a/src/tools/miri/src/concurrency/genmc/scheduling.rs b/src/tools/miri/src/concurrency/genmc/scheduling.rs
new file mode 100644
index 0000000000000..b5c23f2d0845f
--- /dev/null
+++ b/src/tools/miri/src/concurrency/genmc/scheduling.rs
@@ -0,0 +1,69 @@
+use genmc_sys::{ActionKind, ExecutionState};
+
+use super::GenmcCtx;
+use crate::{
+    InterpCx, InterpResult, MiriMachine, TerminationInfo, ThreadId, interp_ok, throw_machine_stop,
+};
+
+impl GenmcCtx {
+    pub(crate) fn schedule_thread<'tcx>(
+        &self,
+        ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
+    ) -> InterpResult<'tcx, ThreadId> {
+        let thread_manager = &ecx.machine.threads;
+        let active_thread_id = thread_manager.active_thread();
+
+        // Determine whether the next instruction in the current thread might be a load.
+        // This is used for the "writes-first" scheduling in GenMC.
+        // Scheduling writes before reads can be beneficial for verification performance.
+        // `Load` is a safe default for the next instruction type if we cannot guarantee that it isn't a load.
+        let curr_thread_next_instr_kind = if !thread_manager.active_thread_ref().is_enabled() {
+            // The current thread can get blocked (e.g., due to a thread join, `Mutex::lock`, assume statement, ...), then we need to ask GenMC for another thread to schedule.
+            // Most to all blocking operations have load semantics, since they wait on something to change in another thread,
+            // e.g., a thread join waiting on another thread to finish (join loads the return value(s) of the other thread),
+            // or a thread waiting for another thread to unlock a `Mutex`, which loads the mutex state (Locked, Unlocked).
+            ActionKind::Load
+        } else {
+            // This thread is still enabled. If it executes a terminator next, we consider yielding,
+            // but in all other cases we just keep running this thread since it never makes sense
+            // to yield before a non-atomic operation.
+            let Some(frame) = thread_manager.active_thread_stack().last() else {
+                return interp_ok(active_thread_id);
+            };
+            let either::Either::Left(loc) = frame.current_loc() else {
+                // We are unwinding, so the next step is definitely not atomic.
+                return interp_ok(active_thread_id);
+            };
+            let basic_block = &frame.body().basic_blocks[loc.block];
+            if let Some(_statement) = basic_block.statements.get(loc.statement_index) {
+                // Statements can't be atomic.
+                return interp_ok(active_thread_id);
+            }
+
+            // FIXME(genmc): determine terminator kind.
+            ActionKind::Load
+        };
+
+        let thread_infos = self.exec_state.thread_id_manager.borrow();
+        let genmc_tid = thread_infos.get_genmc_tid(active_thread_id);
+
+        let mut mc = self.handle.borrow_mut();
+        let pinned_mc = mc.as_mut().unwrap();
+        let result = pinned_mc.schedule_next(genmc_tid, curr_thread_next_instr_kind);
+        // Depending on the exec_state, we either schedule the given thread, or we are finished with this execution.
+        match result.exec_state {
+            ExecutionState::Ok => interp_ok(thread_infos.get_miri_tid(result.next_thread)),
+            ExecutionState::Blocked => throw_machine_stop!(TerminationInfo::GenmcBlockedExecution),
+            ExecutionState::Finished => {
+                let exit_status = self.exec_state.exit_status.get().expect(
+                    "If the execution is finished, we should have a return value from the program.",
+                );
+                throw_machine_stop!(TerminationInfo::Exit {
+                    code: exit_status.exit_code,
+                    leak_check: exit_status.do_leak_check()
+                });
+            }
+            _ => unreachable!(),
+        }
+    }
+}
diff --git a/src/tools/miri/src/concurrency/genmc/thread_id_map.rs b/src/tools/miri/src/concurrency/genmc/thread_id_map.rs
new file mode 100644
index 0000000000000..9676496fe7fea
--- /dev/null
+++ b/src/tools/miri/src/concurrency/genmc/thread_id_map.rs
@@ -0,0 +1,63 @@
+use genmc_sys::GENMC_MAIN_THREAD_ID;
+use rustc_data_structures::fx::FxHashMap;
+
+use crate::ThreadId;
+
+#[derive(Debug)]
+pub struct ThreadIdMap {
+    /// Map from Miri thread IDs to GenMC thread IDs.
+    /// We assume as little as possible about Miri thread IDs, so we use a map.
+    miri_to_genmc: FxHashMap<ThreadId, i32>,
+    /// Map from GenMC thread IDs to Miri thread IDs.
+    /// We control which thread IDs are used, so we choose them in as an incrementing counter.
+    genmc_to_miri: Vec<ThreadId>, // FIXME(genmc): check if this assumption is (and will stay) correct.
+}
+
+impl Default for ThreadIdMap {
+    fn default() -> Self {
+        let miri_to_genmc = [(ThreadId::MAIN_THREAD, GENMC_MAIN_THREAD_ID)].into_iter().collect();
+        let genmc_to_miri = vec![ThreadId::MAIN_THREAD];
+        Self { miri_to_genmc, genmc_to_miri }
+    }
+}
+
+impl ThreadIdMap {
+    pub fn reset(&mut self) {
+        self.miri_to_genmc.clear();
+        self.miri_to_genmc.insert(ThreadId::MAIN_THREAD, GENMC_MAIN_THREAD_ID);
+        self.genmc_to_miri.clear();
+        self.genmc_to_miri.push(ThreadId::MAIN_THREAD);
+    }
+
+    #[must_use]
+    /// Add a new Miri thread to the mapping and dispense a new thread ID for GenMC to use.
+    pub fn add_thread(&mut self, thread_id: ThreadId) -> i32 {
+        // NOTE: We select the new thread ids as integers incremented by one (we use the length as the counter).
+        let next_thread_id = self.genmc_to_miri.len();
+        let genmc_tid = next_thread_id.try_into().unwrap();
+        // If there is already an entry, we override it.
+        // This could happen if Miri were to reuse `ThreadId`s, but we assume that if this happens, the previous thread with that id doesn't exist anymore.
+        self.miri_to_genmc.insert(thread_id, genmc_tid);
+        self.genmc_to_miri.push(thread_id);
+
+        genmc_tid
+    }
+
+    #[must_use]
+    /// Try to get the GenMC thread ID corresponding to a given Miri `ThreadId`.
+    /// Panics if there is no mapping for the given `ThreadId`.
+    pub fn get_genmc_tid(&self, thread_id: ThreadId) -> i32 {
+        *self.miri_to_genmc.get(&thread_id).unwrap()
+    }
+
+    #[must_use]
+    /// Get the Miri `ThreadId` corresponding to a given GenMC thread id.
+    /// Panics if the given thread id isn't valid.
+    pub fn get_miri_tid(&self, genmc_tid: i32) -> ThreadId {
+        let index: usize = genmc_tid.try_into().unwrap();
+        self.genmc_to_miri
+            .get(index)
+            .copied()
+            .expect("A thread id returned from GenMC should exist.")
+    }
+}
diff --git a/src/tools/miri/src/concurrency/init_once.rs b/src/tools/miri/src/concurrency/init_once.rs
index 165215f9270ce..3fb3d890419f7 100644
--- a/src/tools/miri/src/concurrency/init_once.rs
+++ b/src/tools/miri/src/concurrency/init_once.rs
@@ -142,7 +142,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     /// Synchronize with the previous completion of an InitOnce.
     /// Must only be called after checking that it is complete.
     #[inline]
-    fn init_once_observe_completed(&mut self, init_once_ref: &InitOnceRef) {
+    fn init_once_observe_completed(&mut self, init_once_ref: &InitOnceRef) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
         let init_once = init_once_ref.0.borrow();
 
@@ -152,6 +152,6 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             "observing the completion of incomplete init once"
         );
 
-        this.acquire_clock(&init_once.clock);
+        this.acquire_clock(&init_once.clock)
     }
 }
diff --git a/src/tools/miri/src/concurrency/mod.rs b/src/tools/miri/src/concurrency/mod.rs
index 435615efd9fa7..9dae858592f1f 100644
--- a/src/tools/miri/src/concurrency/mod.rs
+++ b/src/tools/miri/src/concurrency/mod.rs
@@ -22,5 +22,5 @@ pub mod weak_memory;
 mod genmc;
 
 pub use self::data_race_handler::{AllocDataRaceHandler, GlobalDataRaceHandler};
-pub use self::genmc::{GenmcConfig, GenmcCtx};
+pub use self::genmc::{ExitType, GenmcConfig, GenmcCtx, run_genmc_mode};
 pub use self::vector_clock::VClock;
diff --git a/src/tools/miri/src/concurrency/thread.rs b/src/tools/miri/src/concurrency/thread.rs
index fe1ef86ccd31e..00c5e337b1e9e 100644
--- a/src/tools/miri/src/concurrency/thread.rs
+++ b/src/tools/miri/src/concurrency/thread.rs
@@ -209,6 +209,11 @@ impl<'tcx> Thread<'tcx> {
         self.thread_name.as_deref()
     }
 
+    /// Return whether this thread is enabled or not.
+    pub fn is_enabled(&self) -> bool {
+        self.state.is_enabled()
+    }
+
     /// Get the name of the current thread for display purposes; will include thread ID if not set.
     fn thread_display_name(&self, id: ThreadId) -> String {
         if let Some(ref thread_name) = self.thread_name {
@@ -404,6 +409,7 @@ pub struct ThreadManager<'tcx> {
     /// A mapping from a thread-local static to the thread specific allocation.
     thread_local_allocs: FxHashMap<(DefId, ThreadId), StrictPointer>,
     /// A flag that indicates that we should change the active thread.
+    /// Completely ignored in GenMC mode.
     yield_active_thread: bool,
     /// A flag that indicates that we should do round robin scheduling of threads else randomized scheduling is used.
     fixed_scheduling: bool,
@@ -676,13 +682,6 @@ trait EvalContextPrivExt<'tcx>: MiriInterpCxExt<'tcx> {
     #[inline]
     fn run_on_stack_empty(&mut self) -> InterpResult<'tcx, Poll<()>> {
         let this = self.eval_context_mut();
-        // Inform GenMC that a thread has finished all user code. GenMC needs to know this for scheduling.
-        // FIXME(GenMC): Thread-local destructors *are* user code, so this is odd. Also now that we
-        // support pre-main constructors, it can get called there as well.
-        if let Some(genmc_ctx) = this.machine.data_race.as_genmc_ref() {
-            let thread_id = this.active_thread();
-            genmc_ctx.handle_thread_stack_empty(thread_id);
-        }
         let mut callback = this
             .active_thread_mut()
             .on_stack_empty
@@ -703,19 +702,19 @@ trait EvalContextPrivExt<'tcx>: MiriInterpCxExt<'tcx> {
     /// If GenMC mode is active, the scheduling is instead handled by GenMC.
     fn schedule(&mut self) -> InterpResult<'tcx, SchedulingAction> {
         let this = self.eval_context_mut();
-        // In GenMC mode, we let GenMC do the scheduling
+
+        // In GenMC mode, we let GenMC do the scheduling.
         if let Some(genmc_ctx) = this.machine.data_race.as_genmc_ref() {
             let next_thread_id = genmc_ctx.schedule_thread(this)?;
 
             let thread_manager = &mut this.machine.threads;
             thread_manager.active_thread = next_thread_id;
-            thread_manager.yield_active_thread = false;
 
             assert!(thread_manager.threads[thread_manager.active_thread].state.is_enabled());
             return interp_ok(SchedulingAction::ExecuteStep);
         }
 
-        // We are not in GenMC mode, so we control the schedule
+        // We are not in GenMC mode, so we control the scheduling.
         let thread_manager = &mut this.machine.threads;
         let clock = &this.machine.monotonic_clock;
         let rng = this.machine.rng.get_mut();
@@ -863,7 +862,12 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             GlobalDataRaceHandler::Vclocks(data_race) =>
                 data_race.thread_created(&this.machine.threads, new_thread_id, current_span),
             GlobalDataRaceHandler::Genmc(genmc_ctx) =>
-                genmc_ctx.handle_thread_create(&this.machine.threads, new_thread_id)?,
+                genmc_ctx.handle_thread_create(
+                    &this.machine.threads,
+                    start_routine,
+                    &func_arg,
+                    new_thread_id,
+                )?,
         }
         // Write the current thread-id, switch to the next thread later
         // to treat this write operation as occurring on the current thread.
@@ -916,13 +920,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let thread = this.active_thread_mut();
         assert!(thread.stack.is_empty(), "only threads with an empty stack can be terminated");
         thread.state = ThreadState::Terminated;
-        match &mut this.machine.data_race {
-            GlobalDataRaceHandler::None => {}
-            GlobalDataRaceHandler::Vclocks(data_race) =>
-                data_race.thread_terminated(&this.machine.threads),
-            GlobalDataRaceHandler::Genmc(genmc_ctx) =>
-                genmc_ctx.handle_thread_finish(&this.machine.threads)?,
-        }
+
         // Deallocate TLS.
         let gone_thread = this.active_thread();
         {
@@ -953,6 +951,18 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 }
             }
         }
+
+        match &mut this.machine.data_race {
+            GlobalDataRaceHandler::None => {}
+            GlobalDataRaceHandler::Vclocks(data_race) =>
+                data_race.thread_terminated(&this.machine.threads),
+            GlobalDataRaceHandler::Genmc(genmc_ctx) => {
+                // Inform GenMC that the thread finished.
+                // This needs to happen once all accesses to the thread are done, including freeing any TLS statics.
+                genmc_ctx.handle_thread_finish(&this.machine.threads)
+            }
+        }
+
         // Unblock joining threads.
         let unblock_reason = BlockReason::Join(gone_thread);
         let threads = &this.machine.threads.threads;
@@ -978,6 +988,9 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         callback: DynUnblockCallback<'tcx>,
     ) {
         let this = self.eval_context_mut();
+        if timeout.is_some() && this.machine.data_race.as_genmc_ref().is_some() {
+            panic!("Unimplemented: Timeouts not yet supported in GenMC mode.");
+        }
         let timeout = timeout.map(|(clock, anchor, duration)| {
             let anchor = match clock {
                 TimeoutClock::RealTime => {
@@ -1076,6 +1089,10 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 "{:?} blocked on {:?} when trying to join",
                 thread_mgr.active_thread, joined_thread_id
             );
+            if let Some(genmc_ctx) = this.machine.data_race.as_genmc_ref() {
+                genmc_ctx.handle_thread_join(thread_mgr.active_thread, joined_thread_id)?;
+            }
+
             // The joined thread is still running, we need to wait for it.
             // Once we get unblocked, perform the appropriate synchronization and write the return value.
             let dest = return_dest.clone();
diff --git a/src/tools/miri/src/diagnostics.rs b/src/tools/miri/src/diagnostics.rs
index 9ecbd31c5b9f9..34f560962e662 100644
--- a/src/tools/miri/src/diagnostics.rs
+++ b/src/tools/miri/src/diagnostics.rs
@@ -31,8 +31,9 @@ pub enum TerminationInfo {
     },
     Int2PtrWithStrictProvenance,
     Deadlock,
-    /// In GenMC mode, an execution can get stuck in certain cases. This is not an error.
-    GenmcStuckExecution,
+    /// In GenMC mode, executions can get blocked, which stops the current execution without running any cleanup.
+    /// No leak checks should be performed if this happens, since they would give false positives.
+    GenmcBlockedExecution,
     MultipleSymbolDefinitions {
         link_name: Symbol,
         first: SpanData,
@@ -77,7 +78,8 @@ impl fmt::Display for TerminationInfo {
             StackedBorrowsUb { msg, .. } => write!(f, "{msg}"),
             TreeBorrowsUb { title, .. } => write!(f, "{title}"),
             Deadlock => write!(f, "the evaluated program deadlocked"),
-            GenmcStuckExecution => write!(f, "GenMC determined that the execution got stuck"),
+            GenmcBlockedExecution =>
+                write!(f, "GenMC determined that the execution got blocked (this is not an error)"),
             MultipleSymbolDefinitions { link_name, .. } =>
                 write!(f, "multiple definitions of symbol `{link_name}`"),
             SymbolShimClashing { link_name, .. } =>
@@ -243,11 +245,12 @@ pub fn report_error<'tcx>(
                 labels.push(format!("this thread got stuck here"));
                 None
             }
-            GenmcStuckExecution => {
-                // This case should only happen in GenMC mode. We treat it like a normal program exit.
+            GenmcBlockedExecution => {
+                // This case should only happen in GenMC mode.
                 assert!(ecx.machine.data_race.as_genmc_ref().is_some());
-                tracing::info!("GenMC: found stuck execution");
-                return Some((0, true));
+                // The program got blocked by GenMC without finishing the execution.
+                // No cleanup code was executed, so we don't do any leak checks.
+                return Some((0, false));
             }
             MultipleSymbolDefinitions { .. } | SymbolShimClashing { .. } => None,
         };
diff --git a/src/tools/miri/src/eval.rs b/src/tools/miri/src/eval.rs
index 4c531a8d1f526..e6c2163105ad1 100644
--- a/src/tools/miri/src/eval.rs
+++ b/src/tools/miri/src/eval.rs
@@ -303,8 +303,21 @@ impl<'tcx> MainThreadState<'tcx> {
                 // to be like a global `static`, so that all memory reached by it is considered to "not leak".
                 this.terminate_active_thread(TlsAllocAction::Leak)?;
 
-                // Stop interpreter loop.
-                throw_machine_stop!(TerminationInfo::Exit { code: exit_code, leak_check: true });
+                // In GenMC mode, we do not immediately stop execution on main thread exit.
+                if let Some(genmc_ctx) = this.machine.data_race.as_genmc_ref() {
+                    // If there's no error, execution will continue (on another thread).
+                    genmc_ctx.handle_exit(
+                        ThreadId::MAIN_THREAD,
+                        exit_code,
+                        crate::concurrency::ExitType::MainThreadFinish,
+                    )?;
+                } else {
+                    // Stop interpreter loop.
+                    throw_machine_stop!(TerminationInfo::Exit {
+                        code: exit_code,
+                        leak_check: true
+                    });
+                }
             }
         }
         interp_ok(Poll::Pending)
@@ -505,10 +518,6 @@ pub fn eval_entry<'tcx>(
     // Copy setting before we move `config`.
     let ignore_leaks = config.ignore_leaks;
 
-    if let Some(genmc_ctx) = &genmc_ctx {
-        genmc_ctx.handle_execution_start();
-    }
-
     let mut ecx = match create_ecx(tcx, entry_id, entry_type, config, genmc_ctx).report_err() {
         Ok(v) => v,
         Err(err) => {
@@ -532,15 +541,6 @@ pub fn eval_entry<'tcx>(
     // Show diagnostic, if any.
     let (return_code, leak_check) = report_error(&ecx, err)?;
 
-    // We inform GenMC that the execution is complete.
-    if let Some(genmc_ctx) = ecx.machine.data_race.as_genmc_ref()
-        && let Err(error) = genmc_ctx.handle_execution_end(&ecx)
-    {
-        // FIXME(GenMC): Improve error reporting.
-        tcx.dcx().err(format!("GenMC returned an error: \"{error}\""));
-        return None;
-    }
-
     // If we get here there was no fatal error.
 
     // Possibly check for memory leaks.
diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
index 507d4f7b42896..a9279bbefd8fd 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -133,7 +133,7 @@ pub use crate::concurrency::thread::{
     BlockReason, DynUnblockCallback, EvalContextExt as _, StackEmptyCallback, ThreadId,
     ThreadManager, TimeoutAnchor, TimeoutClock, UnblockKind,
 };
-pub use crate::concurrency::{GenmcConfig, GenmcCtx};
+pub use crate::concurrency::{GenmcConfig, GenmcCtx, run_genmc_mode};
 pub use crate::data_structures::dedup_range_map::DedupRangeMap;
 pub use crate::data_structures::mono_hash_map::MonoHashMap;
 pub use crate::diagnostics::{
diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index 9482769a2fc79..4bb6dd2aafe02 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -1427,9 +1427,8 @@ impl<'tcx> Machine<'tcx> for MiriMachine<'tcx> {
         }
         match &machine.data_race {
             GlobalDataRaceHandler::None => {}
-            GlobalDataRaceHandler::Genmc(genmc_ctx) => {
-                genmc_ctx.memory_store(machine, ptr.addr(), range.size)?;
-            }
+            GlobalDataRaceHandler::Genmc(genmc_ctx) =>
+                genmc_ctx.memory_store(machine, ptr.addr(), range.size)?,
             GlobalDataRaceHandler::Vclocks(_global_state) => {
                 let AllocDataRaceHandler::Vclocks(data_race, weak_memory) =
                     &mut alloc_extra.data_race
@@ -1465,7 +1464,7 @@ impl<'tcx> Machine<'tcx> for MiriMachine<'tcx> {
         match &machine.data_race {
             GlobalDataRaceHandler::None => {}
             GlobalDataRaceHandler::Genmc(genmc_ctx) =>
-                genmc_ctx.handle_dealloc(machine, ptr.addr(), size, align, kind)?,
+                genmc_ctx.handle_dealloc(machine, alloc_id, ptr.addr(), kind)?,
             GlobalDataRaceHandler::Vclocks(_global_state) => {
                 let data_race = alloc_extra.data_race.as_vclocks_mut().unwrap();
                 data_race.write(
diff --git a/src/tools/miri/src/shims/foreign_items.rs b/src/tools/miri/src/shims/foreign_items.rs
index 21545b680299c..c6bc29cb8cb47 100644
--- a/src/tools/miri/src/shims/foreign_items.rs
+++ b/src/tools/miri/src/shims/foreign_items.rs
@@ -443,13 +443,22 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
             "exit" => {
                 let [code] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
                 let code = this.read_scalar(code)?.to_i32()?;
+                if let Some(genmc_ctx) = this.machine.data_race.as_genmc_ref() {
+                    // If there is no error, execution should continue (on a different thread).
+                    genmc_ctx.handle_exit(
+                        this.machine.threads.active_thread(),
+                        code,
+                        crate::concurrency::ExitType::ExitCalled,
+                    )?;
+                    todo!(); // FIXME(genmc): Add a way to return here that is allowed to not do progress (can't use existing EmulateItemResult variants).
+                }
                 throw_machine_stop!(TerminationInfo::Exit { code, leak_check: false });
             }
             "abort" => {
                 let [] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
                 throw_machine_stop!(TerminationInfo::Abort(
                     "the program aborted execution".to_owned()
-                ))
+                ));
             }
 
             // Standard C allocation
diff --git a/src/tools/miri/src/shims/unix/linux_like/epoll.rs b/src/tools/miri/src/shims/unix/linux_like/epoll.rs
index d460abc783dd5..aac880feda40e 100644
--- a/src/tools/miri/src/shims/unix/linux_like/epoll.rs
+++ b/src/tools/miri/src/shims/unix/linux_like/epoll.rs
@@ -639,7 +639,7 @@ fn return_ready_list<'tcx>(
                 &des.1,
             )?;
             // Synchronize waking thread with the event of interest.
-            ecx.acquire_clock(&epoll_event_instance.clock);
+            ecx.acquire_clock(&epoll_event_instance.clock)?;
 
             num_of_events = num_of_events.strict_add(1);
         } else {
diff --git a/src/tools/miri/src/shims/unix/linux_like/eventfd.rs b/src/tools/miri/src/shims/unix/linux_like/eventfd.rs
index 2d35ef064db8b..ad8ea6410264f 100644
--- a/src/tools/miri/src/shims/unix/linux_like/eventfd.rs
+++ b/src/tools/miri/src/shims/unix/linux_like/eventfd.rs
@@ -299,7 +299,7 @@ fn eventfd_read<'tcx>(
         );
     } else {
         // Synchronize with all prior `write` calls to this FD.
-        ecx.acquire_clock(&eventfd.clock.borrow());
+        ecx.acquire_clock(&eventfd.clock.borrow())?;
 
         // Return old counter value into user-space buffer.
         ecx.write_int(counter, &buf_place)?;
diff --git a/src/tools/miri/src/shims/unix/unnamed_socket.rs b/src/tools/miri/src/shims/unix/unnamed_socket.rs
index 817ddd7954df4..52073b58e70de 100644
--- a/src/tools/miri/src/shims/unix/unnamed_socket.rs
+++ b/src/tools/miri/src/shims/unix/unnamed_socket.rs
@@ -337,7 +337,7 @@ fn anonsocket_read<'tcx>(
         // Synchronize with all previous writes to this buffer.
         // 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);
+        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.
diff --git a/src/tools/miri/src/shims/windows/sync.rs b/src/tools/miri/src/shims/windows/sync.rs
index 9165e76b63d14..a893999ef8e52 100644
--- a/src/tools/miri/src/shims/windows/sync.rs
+++ b/src/tools/miri/src/shims/windows/sync.rs
@@ -60,7 +60,7 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 true
             }
             InitOnceStatus::Complete => {
-                this.init_once_observe_completed(init_once_ref);
+                this.init_once_observe_completed(init_once_ref)?;
                 this.write_scalar(this.eval_windows("c", "FALSE"), pending_place)?;
                 this.write_scalar(this.eval_windows("c", "TRUE"), dest)?;
                 true
diff --git a/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rel_rlx.stderr b/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rel_rlx.stderr
new file mode 100644
index 0000000000000..121ded2a181ca
--- /dev/null
+++ b/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rel_rlx.stderr
@@ -0,0 +1,19 @@
+error: Undefined Behavior: Non-atomic race
+  --> tests/genmc/fail/data_race/weak_orderings.rs:LL:CC
+   |
+LL |                 X = 2;
+   |                 ^^^^^ Undefined Behavior occurred here
+   |
+   = 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 tests/genmc/fail/data_race/weak_orderings.rs:LL:CC
+   = note: inside `<std::boxed::Box<{closure@tests/genmc/fail/data_race/weak_orderings.rs:LL:CC}> as std::ops::FnOnce<()>>::call_once` at RUSTLIB/alloc/src/boxed.rs:LL:CC
+note: inside `genmc::spawn_pthread_closure::thread_func::<{closure@tests/genmc/fail/data_race/weak_orderings.rs:LL:CC}>`
+  --> tests/genmc/fail/data_race/../../../utils/genmc.rs:LL:CC
+   |
+LL |         f();
+   |         ^^^
+
+error: aborting due to 1 previous error
+
diff --git a/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rlx_acq.stderr b/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rlx_acq.stderr
new file mode 100644
index 0000000000000..121ded2a181ca
--- /dev/null
+++ b/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rlx_acq.stderr
@@ -0,0 +1,19 @@
+error: Undefined Behavior: Non-atomic race
+  --> tests/genmc/fail/data_race/weak_orderings.rs:LL:CC
+   |
+LL |                 X = 2;
+   |                 ^^^^^ Undefined Behavior occurred here
+   |
+   = 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 tests/genmc/fail/data_race/weak_orderings.rs:LL:CC
+   = note: inside `<std::boxed::Box<{closure@tests/genmc/fail/data_race/weak_orderings.rs:LL:CC}> as std::ops::FnOnce<()>>::call_once` at RUSTLIB/alloc/src/boxed.rs:LL:CC
+note: inside `genmc::spawn_pthread_closure::thread_func::<{closure@tests/genmc/fail/data_race/weak_orderings.rs:LL:CC}>`
+  --> tests/genmc/fail/data_race/../../../utils/genmc.rs:LL:CC
+   |
+LL |         f();
+   |         ^^^
+
+error: aborting due to 1 previous error
+
diff --git a/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rlx_rlx.stderr b/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rlx_rlx.stderr
new file mode 100644
index 0000000000000..121ded2a181ca
--- /dev/null
+++ b/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rlx_rlx.stderr
@@ -0,0 +1,19 @@
+error: Undefined Behavior: Non-atomic race
+  --> tests/genmc/fail/data_race/weak_orderings.rs:LL:CC
+   |
+LL |                 X = 2;
+   |                 ^^^^^ Undefined Behavior occurred here
+   |
+   = 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 tests/genmc/fail/data_race/weak_orderings.rs:LL:CC
+   = note: inside `<std::boxed::Box<{closure@tests/genmc/fail/data_race/weak_orderings.rs:LL:CC}> as std::ops::FnOnce<()>>::call_once` at RUSTLIB/alloc/src/boxed.rs:LL:CC
+note: inside `genmc::spawn_pthread_closure::thread_func::<{closure@tests/genmc/fail/data_race/weak_orderings.rs:LL:CC}>`
+  --> tests/genmc/fail/data_race/../../../utils/genmc.rs:LL:CC
+   |
+LL |         f();
+   |         ^^^
+
+error: aborting due to 1 previous error
+
diff --git a/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rs b/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rs
new file mode 100644
index 0000000000000..1568a302f85ad
--- /dev/null
+++ b/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rs
@@ -0,0 +1,40 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+//@revisions: rlx_rlx rlx_acq rel_rlx
+
+// Translated from GenMC's test `wrong/racy/MP+rel+rlx`, `MP+rlx+acq` and `MP+rlx+rlx`.
+// Test if Miri with GenMC can detect the data race on `X`.
+// Relaxed orderings on an atomic store-load pair should not synchronize the non-atomic write to X, leading to a data race.
+
+// FIXME(genmc): once Miri-GenMC error reporting is improved, ensure that it correctly points to the two spans involved in the data race.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering::{self, *};
+
+use genmc::spawn_pthread_closure;
+
+static mut X: u64 = 0;
+static Y: AtomicUsize = AtomicUsize::new(0);
+
+const STORE_ORD: Ordering = if cfg!(rel_rlx) { Release } else { Relaxed };
+const LOAD_ORD: Ordering = if cfg!(rlx_acq) { Acquire } else { Relaxed };
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    unsafe {
+        spawn_pthread_closure(|| {
+            X = 1;
+            Y.store(1, STORE_ORD);
+        });
+        spawn_pthread_closure(|| {
+            if Y.load(LOAD_ORD) != 0 {
+                X = 2; //~ ERROR: Undefined Behavior: Non-atomic race
+            }
+        });
+    }
+    0
+}
diff --git a/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.relaxed4.stderr b/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.relaxed4.stderr
new file mode 100644
index 0000000000000..e2b114df652f8
--- /dev/null
+++ b/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.relaxed4.stderr
@@ -0,0 +1,15 @@
+error: Undefined Behavior: entering unreachable code
+  --> tests/genmc/fail/simple/2w2w_weak.rs:LL:CC
+   |
+LL |             std::hint::unreachable_unchecked();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
+   |
+   = 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 `miri_start` at tests/genmc/fail/simple/2w2w_weak.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/genmc/fail/simple/2w2w_weak.release4.stderr b/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.release4.stderr
new file mode 100644
index 0000000000000..e2b114df652f8
--- /dev/null
+++ b/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.release4.stderr
@@ -0,0 +1,15 @@
+error: Undefined Behavior: entering unreachable code
+  --> tests/genmc/fail/simple/2w2w_weak.rs:LL:CC
+   |
+LL |             std::hint::unreachable_unchecked();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
+   |
+   = 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 `miri_start` at tests/genmc/fail/simple/2w2w_weak.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/genmc/fail/simple/2w2w_weak.rs b/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.rs
new file mode 100644
index 0000000000000..dea2b5f952e7e
--- /dev/null
+++ b/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.rs
@@ -0,0 +1,73 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+//@revisions: sc3_rel1 release4 relaxed4
+
+// The pass tests "2w2w_3sc_1rel.rs", "2w2w_4rel" and "2w2w_4sc" and the fail test "2w2w_weak.rs" are related.
+//
+// This test has multiple variants using different memory orderings.
+// When using any combination of orderings except using all 4 `SeqCst`, the memory model allows the program to result in (X, Y) == (1, 1).
+// The "pass" variants only check that we get the expected number of executions (3 for all SC, 4 otherwise),
+// and a valid outcome every execution, but do not check that we get all allowed results.
+// This "fail" variant ensures we can explore the execution resulting in (1, 1), an incorrect unsafe assumption that the result (1, 1) is impossible.
+//
+// Miri without GenMC is unable to produce this program execution and thus detect the incorrect assumption, even with `-Zmiri-many-seeds`.
+//
+// To get good coverage, we test the combination with the strongest orderings allowing this result (3 `SeqCst`, 1 `Release`),
+// the weakest orderings (4 `Relaxed`), and one in between (4 `Release`).
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::{self, *};
+
+use crate::genmc::{join_pthreads, spawn_pthread_closure};
+
+static X: AtomicU64 = AtomicU64::new(0);
+static Y: AtomicU64 = AtomicU64::new(0);
+
+// Strongest orderings allowing result (1, 1).
+#[cfg(seqcst_rel)]
+const STORE_ORD_3: Ordering = SeqCst;
+#[cfg(seqcst_rel)]
+const STORE_ORD_1: Ordering = Release;
+
+// 4 * `Release`.
+#[cfg(acqrel)]
+const STORE_ORD_3: Ordering = Release;
+#[cfg(acqrel)]
+const STORE_ORD_1: Ordering = Release;
+
+// Weakest orderings (4 * `Relaxed`).
+#[cfg(not(any(acqrel, seqcst_rel)))]
+const STORE_ORD_3: Ordering = Relaxed;
+#[cfg(not(any(acqrel, seqcst_rel)))]
+const STORE_ORD_1: Ordering = Relaxed;
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    unsafe {
+        let ids = [
+            spawn_pthread_closure(|| {
+                X.store(1, STORE_ORD_3);
+                Y.store(2, STORE_ORD_3);
+            }),
+            spawn_pthread_closure(|| {
+                Y.store(1, STORE_ORD_1);
+                X.store(2, STORE_ORD_3);
+            }),
+        ];
+        // Join so we can read the final values.
+        join_pthreads(ids);
+
+        // We mark the result (1, 1) as unreachable, which is incorrect.
+        let result = (X.load(Relaxed), Y.load(Relaxed));
+        if result == (1, 1) {
+            // FIXME(genmc): Use `std::process::abort()` once backtraces for that are improved (https://github.com/rust-lang/rust/pull/146118)
+            std::hint::unreachable_unchecked(); //~ ERROR: entering unreachable code
+        }
+
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.sc3_rel1.stderr b/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.sc3_rel1.stderr
new file mode 100644
index 0000000000000..e2b114df652f8
--- /dev/null
+++ b/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.sc3_rel1.stderr
@@ -0,0 +1,15 @@
+error: Undefined Behavior: entering unreachable code
+  --> tests/genmc/fail/simple/2w2w_weak.rs:LL:CC
+   |
+LL |             std::hint::unreachable_unchecked();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
+   |
+   = 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 `miri_start` at tests/genmc/fail/simple/2w2w_weak.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/genmc/pass/litmus/2cowr.rs b/src/tools/miri/tests/genmc/pass/litmus/2cowr.rs
new file mode 100644
index 0000000000000..d3fdb470ed367
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/2cowr.rs
@@ -0,0 +1,51 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's test "2CoWR".
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+static Y: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    // FIXME(genmc,HACK): remove these initializing writes once Miri-GenMC supports mixed atomic-non-atomic accesses.
+    X.store(0, Relaxed);
+    Y.store(0, Relaxed);
+
+    unsafe {
+        let mut a = 1234;
+        let mut b = 1234;
+        let ids = [
+            spawn_pthread_closure(|| {
+                a = Y.load(Acquire);
+            }),
+            spawn_pthread_closure(|| {
+                b = X.load(Acquire);
+            }),
+            spawn_pthread_closure(|| {
+                X.store(1, Release);
+            }),
+            spawn_pthread_closure(|| {
+                Y.store(1, Release);
+            }),
+        ];
+        // Join so we can read the final values.
+        join_pthreads(ids);
+
+        // Check that we don't get any unexpected values:
+        if !matches!((a, b), (0, 0) | (0, 1) | (1, 0) | (1, 1)) {
+            std::process::abort();
+        }
+
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/2cowr.stderr b/src/tools/miri/tests/genmc/pass/litmus/2cowr.stderr
new file mode 100644
index 0000000000000..0667962f99c88
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/2cowr.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 4
diff --git a/src/tools/miri/tests/genmc/pass/litmus/2w2w_3sc_1rel.release1.stderr b/src/tools/miri/tests/genmc/pass/litmus/2w2w_3sc_1rel.release1.stderr
new file mode 100644
index 0000000000000..0667962f99c88
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/2w2w_3sc_1rel.release1.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 4
diff --git a/src/tools/miri/tests/genmc/pass/litmus/2w2w_3sc_1rel.release2.stderr b/src/tools/miri/tests/genmc/pass/litmus/2w2w_3sc_1rel.release2.stderr
new file mode 100644
index 0000000000000..0667962f99c88
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/2w2w_3sc_1rel.release2.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 4
diff --git a/src/tools/miri/tests/genmc/pass/litmus/2w2w_3sc_1rel.rs b/src/tools/miri/tests/genmc/pass/litmus/2w2w_3sc_1rel.rs
new file mode 100644
index 0000000000000..22fe9524c37f5
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/2w2w_3sc_1rel.rs
@@ -0,0 +1,54 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+//@revisions: release1 release2
+
+// Translated from GenMC's test "2+2W+3sc+rel1" and "2+2W+3sc+rel2" (two variants that swap which store is `Release`).
+//
+// The pass tests "2w2w_3sc_1rel.rs", "2w2w_4rel" and "2w2w_4sc" and the fail test "2w2w_weak.rs" are related.
+// Check "2w2w_weak.rs" for a more detailed description.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+static Y: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    unsafe {
+        let ids = [
+            spawn_pthread_closure(|| {
+                X.store(1, SeqCst);
+                Y.store(2, SeqCst);
+            }),
+            // Variant 1: `Release` goes first.
+            #[cfg(release1)]
+            spawn_pthread_closure(|| {
+                Y.store(1, Release);
+                X.store(2, SeqCst);
+            }),
+            // Variant 2: `Release` goes second.
+            #[cfg(not(release1))]
+            spawn_pthread_closure(|| {
+                Y.store(1, SeqCst);
+                X.store(2, Release);
+            }),
+        ];
+        // Join so we can read the final values.
+        join_pthreads(ids);
+
+        // Check that we don't get any unexpected values:
+        let result = (X.load(Relaxed), Y.load(Relaxed));
+        if !matches!(result, (1, 2) | (1, 1) | (2, 2) | (2, 1)) {
+            std::process::abort();
+        }
+
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/2w2w_4rel.rs b/src/tools/miri/tests/genmc/pass/litmus/2w2w_4rel.rs
new file mode 100644
index 0000000000000..bbe9995dea0b2
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/2w2w_4rel.rs
@@ -0,0 +1,45 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's test "2+2W".
+//
+// The pass tests "2w2w_3sc_1rel.rs", "2w2w_4rel" and "2w2w_4sc" and the fail test "2w2w_weak.rs" are related.
+// Check "2w2w_weak.rs" for a more detailed description.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+static Y: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    unsafe {
+        let ids = [
+            spawn_pthread_closure(|| {
+                Y.store(1, Release);
+                X.store(2, Release);
+            }),
+            spawn_pthread_closure(|| {
+                X.store(1, Release);
+                Y.store(2, Release);
+            }),
+        ];
+        // Join so we can read the final values.
+        join_pthreads(ids);
+
+        // Check that we don't get any unexpected values:
+        let result = (X.load(Relaxed), Y.load(Relaxed));
+        if !matches!(result, (1, 2) | (1, 1) | (2, 2) | (2, 1)) {
+            std::process::abort();
+        }
+
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/2w2w_4rel.stderr b/src/tools/miri/tests/genmc/pass/litmus/2w2w_4rel.stderr
new file mode 100644
index 0000000000000..0667962f99c88
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/2w2w_4rel.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 4
diff --git a/src/tools/miri/tests/genmc/pass/litmus/2w2w_4sc.rs b/src/tools/miri/tests/genmc/pass/litmus/2w2w_4sc.rs
new file mode 100644
index 0000000000000..c5711ba04fce2
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/2w2w_4sc.rs
@@ -0,0 +1,45 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's test "2+2W+4c".
+//
+// The pass tests "2w2w_3sc_1rel.rs", "2w2w_4rel" and "2w2w_4sc" and the fail test "2w2w_weak.rs" are related.
+// Check "2w2w_weak.rs" for a more detailed description.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+static Y: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    unsafe {
+        let ids = [
+            spawn_pthread_closure(|| {
+                X.store(1, SeqCst);
+                Y.store(2, SeqCst);
+            }),
+            spawn_pthread_closure(|| {
+                Y.store(1, SeqCst);
+                X.store(2, SeqCst);
+            }),
+        ];
+        // Join so we can read the final values.
+        join_pthreads(ids);
+
+        // Check that we don't get any unexpected values:
+        let result = (X.load(Relaxed), Y.load(Relaxed));
+        if !matches!(result, (2, 1) | (2, 2) | (1, 2)) {
+            std::process::abort();
+        }
+
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/2w2w_4sc.stderr b/src/tools/miri/tests/genmc/pass/litmus/2w2w_4sc.stderr
new file mode 100644
index 0000000000000..115b1986ce557
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/2w2w_4sc.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 3
diff --git a/src/tools/miri/tests/genmc/pass/litmus/IRIW-acq-sc.rs b/src/tools/miri/tests/genmc/pass/litmus/IRIW-acq-sc.rs
new file mode 100644
index 0000000000000..79e7c7feb7aac
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/IRIW-acq-sc.rs
@@ -0,0 +1,64 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's "IRIW-acq-sc" test.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+static Y: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    // FIXME(genmc,HACK): remove these initializing writes once Miri-GenMC supports mixed atomic-non-atomic accesses.
+    X.store(0, Relaxed);
+    Y.store(0, Relaxed);
+
+    unsafe {
+        let mut a = 1234;
+        let mut b = 1234;
+        let mut c = 1234;
+        let ids = [
+            spawn_pthread_closure(|| {
+                X.store(1, SeqCst);
+            }),
+            spawn_pthread_closure(|| {
+                a = X.load(Acquire);
+                Y.load(SeqCst);
+            }),
+            spawn_pthread_closure(|| {
+                b = Y.load(Acquire);
+                c = X.load(SeqCst);
+            }),
+            spawn_pthread_closure(|| {
+                Y.store(1, SeqCst);
+            }),
+        ];
+        // Join so we can read the final values.
+        join_pthreads(ids);
+
+        // Check that we don't get any unexpected values:
+        if !matches!(
+            (a, b, c),
+            (0, 0, 0)
+                | (0, 0, 1)
+                | (0, 1, 0)
+                | (0, 1, 1)
+                | (1, 0, 0)
+                | (1, 0, 1)
+                | (1, 1, 0)
+                | (1, 1, 1)
+        ) {
+            std::process::abort();
+        }
+
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/IRIW-acq-sc.stderr b/src/tools/miri/tests/genmc/pass/litmus/IRIW-acq-sc.stderr
new file mode 100644
index 0000000000000..c760b44605112
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/IRIW-acq-sc.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 16
diff --git a/src/tools/miri/tests/genmc/pass/litmus/LB.rs b/src/tools/miri/tests/genmc/pass/litmus/LB.rs
new file mode 100644
index 0000000000000..1cee3230b127c
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/LB.rs
@@ -0,0 +1,47 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's "litmus/LB" test.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+static Y: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    // FIXME(genmc,HACK): remove these initializing writes once Miri-GenMC supports mixed atomic-non-atomic accesses.
+    X.store(0, Relaxed);
+    Y.store(0, Relaxed);
+
+    unsafe {
+        let mut a = 1234;
+        let mut b = 1234;
+        let ids = [
+            spawn_pthread_closure(|| {
+                a = Y.load(Acquire);
+                X.store(2, Release);
+            }),
+            spawn_pthread_closure(|| {
+                b = X.load(Acquire);
+                Y.store(1, Release);
+            }),
+        ];
+        // Join so we can read the final values.
+        join_pthreads(ids);
+
+        // Check that we don't get any unexpected values:
+        if !matches!((a, b), (0, 0) | (0, 2) | (1, 0)) {
+            std::process::abort();
+        }
+
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/LB.stderr b/src/tools/miri/tests/genmc/pass/litmus/LB.stderr
new file mode 100644
index 0000000000000..115b1986ce557
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/LB.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 3
diff --git a/src/tools/miri/tests/genmc/pass/litmus/MP.rs b/src/tools/miri/tests/genmc/pass/litmus/MP.rs
new file mode 100644
index 0000000000000..e245cdd15eef2
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/MP.rs
@@ -0,0 +1,47 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's "litmus/MP" test.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+static Y: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    // FIXME(genmc,HACK): remove these initializing writes once Miri-GenMC supports mixed atomic-non-atomic accesses.
+    X.store(0, Relaxed);
+    Y.store(0, Relaxed);
+
+    unsafe {
+        let mut a = 1234;
+        let mut b = 1234;
+        let ids = [
+            spawn_pthread_closure(|| {
+                X.store(1, Release);
+                Y.store(1, Release);
+            }),
+            spawn_pthread_closure(|| {
+                a = Y.load(Acquire);
+                b = X.load(Acquire);
+            }),
+        ];
+        // Join so we can read the final values.
+        join_pthreads(ids);
+
+        // Check that we don't get any unexpected values:
+        if !matches!((a, b), (0, 0) | (0, 1) | (1, 1)) {
+            std::process::abort();
+        }
+
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/MP.stderr b/src/tools/miri/tests/genmc/pass/litmus/MP.stderr
new file mode 100644
index 0000000000000..115b1986ce557
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/MP.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 3
diff --git a/src/tools/miri/tests/genmc/pass/litmus/SB.rs b/src/tools/miri/tests/genmc/pass/litmus/SB.rs
new file mode 100644
index 0000000000000..e592fe05c4e49
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/SB.rs
@@ -0,0 +1,47 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's "litmus/SB" test.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+static Y: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    // FIXME(genmc,HACK): remove these initializing writes once Miri-GenMC supports mixed atomic-non-atomic accesses.
+    X.store(0, Relaxed);
+    Y.store(0, Relaxed);
+
+    unsafe {
+        let mut a = 1234;
+        let mut b = 1234;
+        let ids = [
+            spawn_pthread_closure(|| {
+                X.store(1, Release);
+                a = Y.load(Acquire);
+            }),
+            spawn_pthread_closure(|| {
+                Y.store(1, Release);
+                b = X.load(Acquire);
+            }),
+        ];
+        // Join so we can read the final values.
+        join_pthreads(ids);
+
+        // Check that we don't get any unexpected values:
+        if !matches!((a, b), (0, 0) | (0, 1) | (1, 0) | (1, 1)) {
+            std::process::abort();
+        }
+
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/SB.stderr b/src/tools/miri/tests/genmc/pass/litmus/SB.stderr
new file mode 100644
index 0000000000000..0667962f99c88
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/SB.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 4
diff --git a/src/tools/miri/tests/genmc/pass/litmus/corr.rs b/src/tools/miri/tests/genmc/pass/litmus/corr.rs
new file mode 100644
index 0000000000000..d6c95100fc241
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/corr.rs
@@ -0,0 +1,45 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's "CoRR" test.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    // FIXME(genmc,HACK): remove this initializing write once Miri-GenMC supports mixed atomic-non-atomic accesses.
+    X.store(0, Relaxed);
+
+    unsafe {
+        let mut a = 1234;
+        let mut b = 1234;
+        let ids = [
+            spawn_pthread_closure(|| {
+                X.store(1, Release);
+                X.store(2, Release);
+            }),
+            spawn_pthread_closure(|| {
+                a = X.load(Acquire);
+                b = X.load(Acquire);
+            }),
+        ];
+        // Join so we can read the final values.
+        join_pthreads(ids);
+
+        // Check that we don't get any unexpected values:
+        if !matches!((a, b), (0, 0) | (0, 1) | (0, 2) | (1, 1) | (1, 2) | (2, 2)) {
+            std::process::abort();
+        }
+
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/corr.stderr b/src/tools/miri/tests/genmc/pass/litmus/corr.stderr
new file mode 100644
index 0000000000000..be75e68fde77d
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/corr.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 6
diff --git a/src/tools/miri/tests/genmc/pass/litmus/corr0.rs b/src/tools/miri/tests/genmc/pass/litmus/corr0.rs
new file mode 100644
index 0000000000000..f722131fda846
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/corr0.rs
@@ -0,0 +1,46 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's "CoRR0" test.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    // FIXME(genmc,HACK): remove this initializing write once Miri-GenMC supports mixed atomic-non-atomic accesses.
+    X.store(0, Relaxed);
+
+    unsafe {
+        let mut a = 1234;
+        let mut b = 1234;
+        let ids = [
+            spawn_pthread_closure(|| {
+                X.store(1, Release);
+            }),
+            spawn_pthread_closure(|| {
+                a = X.load(Acquire);
+            }),
+            spawn_pthread_closure(|| {
+                b = X.load(Acquire);
+            }),
+        ];
+        // Join so we can read the final values.
+        join_pthreads(ids);
+
+        // Check that we don't get any unexpected values:
+        if !matches!((a, b), (0, 0) | (0, 1) | (1, 0) | (1, 1)) {
+            std::process::abort();
+        }
+
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/corr0.stderr b/src/tools/miri/tests/genmc/pass/litmus/corr0.stderr
new file mode 100644
index 0000000000000..0667962f99c88
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/corr0.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 4
diff --git a/src/tools/miri/tests/genmc/pass/litmus/corr1.rs b/src/tools/miri/tests/genmc/pass/litmus/corr1.rs
new file mode 100644
index 0000000000000..a4e8249bac309
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/corr1.rs
@@ -0,0 +1,58 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's "CoRR1" test.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    // FIXME(genmc,HACK): remove this initializing write once Miri-GenMC supports mixed atomic-non-atomic accesses.
+    X.store(0, Relaxed);
+
+    unsafe {
+        let mut a = 1234;
+        let mut b = 1234;
+        let mut c = 1234;
+        let ids = [
+            spawn_pthread_closure(|| {
+                X.store(1, Release);
+            }),
+            spawn_pthread_closure(|| {
+                X.store(2, Release);
+            }),
+            spawn_pthread_closure(|| {
+                a = X.load(Acquire);
+                b = X.load(Acquire);
+            }),
+            spawn_pthread_closure(|| {
+                c = X.load(Acquire);
+            }),
+        ];
+        // Join so we can read the final values.
+        join_pthreads(ids);
+
+        // Check that we don't get any unexpected values (only 0, 1, 2 are allowed):
+        if !(matches!(a, 0..=2) && matches!(b, 0..=2) && matches!(c, 0..=2)) {
+            std::process::abort();
+        }
+        // The 36 possible program executions can have 21 different results for (a, b, c).
+        // Of the 27 = 3*3*3 total results for (a, b, c),
+        // those where `a != 0` and `b == 0` are not allowed by the memory model.
+        // Once the load for `a` reads either 1 or 2, the load for `b` must see that store too, so it cannot read 0.
+        if a != 0 && b == 0 {
+            std::process::abort();
+        }
+
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/corr1.stderr b/src/tools/miri/tests/genmc/pass/litmus/corr1.stderr
new file mode 100644
index 0000000000000..f6d07e9c77b2b
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/corr1.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 36
diff --git a/src/tools/miri/tests/genmc/pass/litmus/corr2.rs b/src/tools/miri/tests/genmc/pass/litmus/corr2.rs
new file mode 100644
index 0000000000000..2f490d3637797
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/corr2.rs
@@ -0,0 +1,70 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's "CoRR2" test.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    // FIXME(genmc,HACK): remove this initializing write once Miri-GenMC supports mixed atomic-non-atomic accesses.
+    X.store(0, Relaxed);
+
+    unsafe {
+        let mut a = 1234;
+        let mut b = 1234;
+        let mut c = 1234;
+        let mut d = 1234;
+        let ids = [
+            spawn_pthread_closure(|| {
+                X.store(1, Release);
+            }),
+            spawn_pthread_closure(|| {
+                X.store(2, Release);
+            }),
+            spawn_pthread_closure(|| {
+                a = X.load(Acquire);
+                b = X.load(Acquire);
+            }),
+            spawn_pthread_closure(|| {
+                c = X.load(Acquire);
+                d = X.load(Acquire);
+            }),
+        ];
+        // Join so we can read the final values.
+        join_pthreads(ids);
+
+        // Check that we don't get any unexpected values (only 0, 1, 2 are allowed):
+        if !(matches!(a, 0..=2) && matches!(b, 0..=2) && matches!(c, 0..=2) && matches!(d, 0..=2)) {
+            std::process::abort();
+        }
+
+        // The 72 possible program executions can have 47 different results for (a, b, c, d).
+        // Of the 81 = 3*3*3*3 total results for (a, b, c, d),
+        // those where `a != 0` and `b == 0` are not allowed by the memory model.
+        // Once the load for `a` reads either 1 or 2, the load for `b` must see that store too, so it cannot read 0.
+        // The same applies to `c, d` in the other thread.
+        //
+        // Additionally, if one thread reads `1, 2` or `2, 1`, the other thread cannot see the opposite order.
+        if a != 0 && b == 0 {
+            std::process::abort();
+        } else if c != 0 && d == 0 {
+            std::process::abort();
+        } else if (a, b) == (1, 2) && (c, d) == (2, 1) {
+            std::process::abort();
+        } else if (a, b) == (2, 1) && (c, d) == (1, 2) {
+            std::process::abort();
+        }
+
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/corr2.stderr b/src/tools/miri/tests/genmc/pass/litmus/corr2.stderr
new file mode 100644
index 0000000000000..78a90b63feab6
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/corr2.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 72
diff --git a/src/tools/miri/tests/genmc/pass/litmus/corw.rs b/src/tools/miri/tests/genmc/pass/litmus/corw.rs
new file mode 100644
index 0000000000000..7acc20822a4f4
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/corw.rs
@@ -0,0 +1,43 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's "CoRW" test.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    // FIXME(genmc,HACK): remove this initializing write once Miri-GenMC supports mixed atomic-non-atomic accesses.
+    X.store(0, Relaxed);
+
+    unsafe {
+        let mut a = 1234;
+        let ids = [
+            spawn_pthread_closure(|| {
+                a = X.load(Acquire);
+                X.store(1, Release);
+            }),
+            spawn_pthread_closure(|| {
+                X.store(2, Release);
+            }),
+        ];
+        // Join so we can read the final values.
+        join_pthreads(ids);
+
+        // Check that we don't get any unexpected values (the load cannot read `1`):
+        if !matches!(a, 0 | 2) {
+            std::process::abort();
+        }
+
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/corw.stderr b/src/tools/miri/tests/genmc/pass/litmus/corw.stderr
new file mode 100644
index 0000000000000..115b1986ce557
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/corw.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 3
diff --git a/src/tools/miri/tests/genmc/pass/litmus/cowr.rs b/src/tools/miri/tests/genmc/pass/litmus/cowr.rs
new file mode 100644
index 0000000000000..1c51f23a09c66
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/cowr.rs
@@ -0,0 +1,40 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's "CoWR" test.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    unsafe {
+        let mut a = 1234;
+        let ids = [
+            spawn_pthread_closure(|| {
+                X.store(1, Release);
+                a = X.load(Acquire);
+            }),
+            spawn_pthread_closure(|| {
+                X.store(2, Release);
+            }),
+        ];
+        // Join so we can read the final values.
+        join_pthreads(ids);
+
+        // Check that we don't get any unexpected values (the load cannot read `0`):
+        if !matches!(a, 1 | 2) {
+            std::process::abort();
+        }
+
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/cowr.stderr b/src/tools/miri/tests/genmc/pass/litmus/cowr.stderr
new file mode 100644
index 0000000000000..115b1986ce557
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/cowr.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 3
diff --git a/src/tools/miri/tests/genmc/pass/litmus/default.rs b/src/tools/miri/tests/genmc/pass/litmus/default.rs
new file mode 100644
index 0000000000000..55fb1ac34acb4
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/default.rs
@@ -0,0 +1,47 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's "litmus/default" test.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    // FIXME(genmc,HACK): remove this initializing write once Miri-GenMC supports mixed atomic-non-atomic accesses.
+    X.store(0, Relaxed);
+
+    unsafe {
+        let mut a = 1234;
+        let mut b = 1234;
+        let ids = [
+            spawn_pthread_closure(|| {
+                a = X.load(Acquire);
+                b = X.load(Acquire);
+            }),
+            spawn_pthread_closure(|| {
+                X.store(1, Release);
+            }),
+            spawn_pthread_closure(|| {
+                X.store(2, Release);
+            }),
+        ];
+        // Join so we can read the final values.
+        join_pthreads(ids);
+
+        // Check that we don't get any unexpected values:
+        if !matches!((a, b), (0, 0) | (0, 1) | (0, 2) | (1, 1) | (1, 2) | (2, 1) | (2, 2)) {
+            std::process::abort();
+        }
+
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/default.stderr b/src/tools/miri/tests/genmc/pass/litmus/default.stderr
new file mode 100644
index 0000000000000..e0313930282ea
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/default.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 12
diff --git a/src/tools/miri/tests/genmc/pass/litmus/detour.join.stderr b/src/tools/miri/tests/genmc/pass/litmus/detour.join.stderr
new file mode 100644
index 0000000000000..15017249dc3a7
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/detour.join.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 9
diff --git a/src/tools/miri/tests/genmc/pass/litmus/detour.no_join.stderr b/src/tools/miri/tests/genmc/pass/litmus/detour.no_join.stderr
new file mode 100644
index 0000000000000..15017249dc3a7
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/detour.no_join.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 9
diff --git a/src/tools/miri/tests/genmc/pass/litmus/detour.rs b/src/tools/miri/tests/genmc/pass/litmus/detour.rs
new file mode 100644
index 0000000000000..7136c029bbb54
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/detour.rs
@@ -0,0 +1,68 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+//@revisions: join no_join
+
+// Translated from GenMC's "litmus/detour" test.
+
+// This test has two revisitions to test whether we get the same result
+// independent of whether we join the spawned threads or not.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicI64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicI64 = AtomicI64::new(0);
+static Y: AtomicI64 = AtomicI64::new(0);
+static Z: AtomicI64 = AtomicI64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    // FIXME(genmc,HACK): remove these initializing writes once Miri-GenMC supports mixed atomic-non-atomic accesses.
+    X.store(0, Relaxed);
+    Y.store(0, Relaxed);
+    Z.store(0, Relaxed);
+
+    unsafe {
+        // Make these static so we can exit the main thread while the other threads still run.
+        // If these are `let mut` like the other tests, this will cause a use-after-free bug.
+        static mut A: i64 = 1234;
+        static mut B: i64 = 1234;
+        static mut C: i64 = 1234;
+        let ids = [
+            spawn_pthread_closure(|| {
+                X.store(1, Relaxed);
+            }),
+            spawn_pthread_closure(|| {
+                A = Z.load(Relaxed);
+                X.store(A.wrapping_sub(1), Relaxed);
+                B = X.load(Relaxed);
+                Y.store(B, Relaxed);
+            }),
+            spawn_pthread_closure(|| {
+                C = Y.load(Relaxed);
+                Z.store(C, Relaxed);
+            }),
+        ];
+
+        // The `no_join` revision doesn't join any of the running threads to test that
+        // we still explore the same number of executions in that case.
+        if cfg!(no_join) {
+            return 0;
+        }
+
+        // Join so we can read the final values.
+        join_pthreads(ids);
+
+        // Check that we don't get any unexpected values:
+        if !matches!((A, B, C), (0, 1, 0) | (0, -1, 0) | (0, 1, 1) | (0, -1, -1)) {
+            std::process::abort();
+        }
+
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/fr_w_w_w_reads.rs b/src/tools/miri/tests/genmc/pass/litmus/fr_w_w_w_reads.rs
new file mode 100644
index 0000000000000..9a08d517b7c60
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/fr_w_w_w_reads.rs
@@ -0,0 +1,54 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's "fr+w+w+w+reads" test.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    // FIXME(genmc,HACK): remove this initializing write once Miri-GenMC supports mixed atomic-non-atomic accesses.
+    X.store(0, Relaxed);
+
+    unsafe {
+        let mut result = [1234; 4];
+        let ids = [
+            spawn_pthread_closure(|| {
+                X.store(1, Relaxed);
+            }),
+            spawn_pthread_closure(|| {
+                X.store(2, Relaxed);
+            }),
+            spawn_pthread_closure(|| {
+                X.store(3, Relaxed);
+            }),
+            spawn_pthread_closure(|| {
+                result[0] = X.load(Relaxed);
+                result[1] = X.load(Relaxed);
+                result[2] = X.load(Relaxed);
+                result[3] = X.load(Relaxed);
+            }),
+        ];
+
+        // Join so we can read the final values.
+        join_pthreads(ids);
+
+        // Check that we don't get any unexpected values:
+        for val in result {
+            if !matches!(val, 0..=3) {
+                std::process::abort();
+            }
+        }
+
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/fr_w_w_w_reads.stderr b/src/tools/miri/tests/genmc/pass/litmus/fr_w_w_w_reads.stderr
new file mode 100644
index 0000000000000..3b6ba238f5342
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/fr_w_w_w_reads.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 210
diff --git a/src/tools/miri/tests/genmc/pass/test_cxx_build.rs b/src/tools/miri/tests/genmc/pass/test_cxx_build.rs
deleted file mode 100644
index f621bd9114fa4..0000000000000
--- a/src/tools/miri/tests/genmc/pass/test_cxx_build.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-//@compile-flags: -Zmiri-genmc
-
-#![no_main]
-
-#[unsafe(no_mangle)]
-fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
-    0
-}
diff --git a/src/tools/miri/tests/genmc/pass/test_cxx_build.stderr b/src/tools/miri/tests/genmc/pass/test_cxx_build.stderr
deleted file mode 100644
index 4b7aa824bd122..0000000000000
--- a/src/tools/miri/tests/genmc/pass/test_cxx_build.stderr
+++ /dev/null
@@ -1,5 +0,0 @@
-warning: borrow tracking has been disabled, it is not (yet) supported in GenMC mode.
-C++: GenMC handle created!
-Miri: GenMC handle creation successful!
-C++: GenMC handle destroyed!
-Miri: Dropping GenMC handle successful!
diff --git a/src/tools/miri/tests/utils/genmc.rs b/src/tools/miri/tests/utils/genmc.rs
new file mode 100644
index 0000000000000..fb6334bd06086
--- /dev/null
+++ b/src/tools/miri/tests/utils/genmc.rs
@@ -0,0 +1,57 @@
+#![allow(unused)]
+
+use std::ffi::c_void;
+
+use libc::{self, pthread_attr_t, pthread_t};
+
+/// Spawn a thread using `pthread_create`, abort the process on any errors.
+pub unsafe fn spawn_pthread(
+    f: extern "C" fn(*mut c_void) -> *mut c_void,
+    value: *mut c_void,
+) -> pthread_t {
+    let mut thread_id: pthread_t = 0;
+
+    let attr: *const pthread_attr_t = std::ptr::null();
+
+    if unsafe { libc::pthread_create(&raw mut thread_id, attr, f, value) } != 0 {
+        std::process::abort();
+    }
+    thread_id
+}
+
+/// Unsafe because we do *not* check that `F` is `Send + 'static`.
+/// That makes it much easier to write tests...
+pub unsafe fn spawn_pthread_closure<F: FnOnce()>(f: F) -> pthread_t {
+    let mut thread_id: pthread_t = 0;
+    let attr: *const pthread_attr_t = std::ptr::null();
+    let f = Box::new(f);
+    extern "C" fn thread_func<F: FnOnce()>(f: *mut c_void) -> *mut c_void {
+        let f = unsafe { Box::from_raw(f as *mut F) };
+        f();
+        std::ptr::null_mut()
+    }
+    if unsafe {
+        libc::pthread_create(
+            &raw mut thread_id,
+            attr,
+            thread_func::<F>,
+            Box::into_raw(f) as *mut c_void,
+        )
+    } != 0
+    {
+        std::process::abort();
+    }
+    thread_id
+}
+
+// Join the given pthread, abort the process on any errors.
+pub unsafe fn join_pthread(thread_id: pthread_t) {
+    if unsafe { libc::pthread_join(thread_id, std::ptr::null_mut()) } != 0 {
+        std::process::abort();
+    }
+}
+
+// Join the `N` given pthreads, abort the process on any errors.
+pub unsafe fn join_pthreads<const N: usize>(thread_ids: [pthread_t; N]) {
+    let _ = thread_ids.map(|id| join_pthread(id));
+}

From b301e3aed4975d6431cdc963a85b33ca7157757c Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sat, 29 Mar 2025 17:50:20 +0100
Subject: [PATCH 0453/1889] unstable book: in a sanitizer example, check the
 code

this uses some # directives to make sure the code works on x86_64, and does not produce errors on other platforms
---
 .../src/compiler-flags/sanitizer.md           | 32 +++++++++----------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/doc/unstable-book/src/compiler-flags/sanitizer.md b/src/doc/unstable-book/src/compiler-flags/sanitizer.md
index 2f9d4d22e5a85..493256de99d52 100644
--- a/src/doc/unstable-book/src/compiler-flags/sanitizer.md
+++ b/src/doc/unstable-book/src/compiler-flags/sanitizer.md
@@ -244,18 +244,16 @@ See the [Clang ControlFlowIntegrity documentation][clang-cfi] for more details.
 
 ## Example 1: Redirecting control flow using an indirect branch/call to an invalid destination
 
-```rust,ignore (making doc tests pass cross-platform is hard)
-use std::arch::naked_asm;
-use std::mem;
-
+```rust
 fn add_one(x: i32) -> i32 {
     x + 1
 }
 
 #[unsafe(naked)]
-pub extern "C" fn add_two(x: i32) {
+# #[cfg(all(target_os = "linux", target_arch = "x86_64"))]
+pub extern "sysv64" fn add_two(x: i32) {
     // x + 2 preceded by a landing pad/nop block
-    naked_asm!(
+    std::arch::naked_asm!(
         "
          nop
          nop
@@ -281,16 +279,18 @@ fn main() {
 
     println!("The answer is: {}", answer);
 
-    println!("With CFI enabled, you should not see the next answer");
-    let f: fn(i32) -> i32 = unsafe {
-        // Offset 0 is a valid branch/call destination (i.e., the function entry
-        // point), but offsets 1-8 within the landing pad/nop block are invalid
-        // branch/call destinations (i.e., within the body of the function).
-        mem::transmute::<*const u8, fn(i32) -> i32>((add_two as *const u8).offset(5))
-    };
-    let next_answer = do_twice(f, 5);
-
-    println!("The next answer is: {}", next_answer);
+#   #[cfg(all(target_os = "linux", target_arch = "x86_64"))] {
+        println!("With CFI enabled, you should not see the next answer");
+        let f: fn(i32) -> i32 = unsafe {
+            // Offset 0 is a valid branch/call destination (i.e., the function entry
+            // point), but offsets 1-8 within the landing pad/nop block are invalid
+            // branch/call destinations (i.e., within the body of the function).
+            std::mem::transmute::<*const u8, fn(i32) -> i32>((add_two as *const u8).offset(5))
+        };
+        let next_answer = do_twice(f, 5);
+
+        println!("The next answer is: {}", next_answer);
+#   }
 }
 ```
 Fig. 1. Redirecting control flow using an indirect branch/call to an invalid

From 9f3fe4084ab3012e6a4e3ca74228a2194ed863cc Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Wed, 3 Sep 2025 17:15:58 +0530
Subject: [PATCH 0454/1889] remove thread option from self-test invocation

---
 src/bootstrap/src/core/build_steps/test.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index 43d47e0f7ddc9..7175a6492de04 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -3294,8 +3294,7 @@ impl Step for Bootstrap {
             .env("INSTA_WORKSPACE_ROOT", &builder.src)
             .env("RUSTC_BOOTSTRAP", "1");
 
-        let threads = std::thread::available_parallelism().map(|n| n.get()).unwrap_or(1);
-        run_cargo_test(cargo, &["--test-threads", &threads.to_string()], &[], None, host, builder);
+        run_cargo_test(cargo, &[], &[], None, host, builder);
     }
 
     fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {

From 4e872375d4d18e0e44a6657bc4661b0e9b0c99be Mon Sep 17 00:00:00 2001
From: Romain Perier <romain.perier@gmail.com>
Date: Wed, 3 Sep 2025 09:48:30 +0200
Subject: [PATCH 0455/1889] Unify and deduplicate algebraic float tests

---
 library/coretests/tests/floats/f128.rs | 23 ++-------------
 library/coretests/tests/floats/f16.rs  | 21 --------------
 library/coretests/tests/floats/f32.rs  | 23 +--------------
 library/coretests/tests/floats/f64.rs  | 21 +-------------
 library/coretests/tests/floats/mod.rs  | 39 ++++++++++++++++++++++++++
 5 files changed, 44 insertions(+), 83 deletions(-)

diff --git a/library/coretests/tests/floats/f128.rs b/library/coretests/tests/floats/f128.rs
index c173d7f0ae01f..4267fef50f83c 100644
--- a/library/coretests/tests/floats/f128.rs
+++ b/library/coretests/tests/floats/f128.rs
@@ -1,7 +1,9 @@
 // FIXME(f16_f128): only tested on platforms that have symbols and aren't buggy
 #![cfg(target_has_reliable_f128)]
 
-use super::{assert_approx_eq, assert_biteq};
+#[cfg(any(miri, target_has_reliable_f128_math))]
+use super::assert_approx_eq;
+use super::assert_biteq;
 
 // Note these tolerances make sense around zero, but not for more extreme exponents.
 
@@ -74,25 +76,6 @@ fn test_float_bits_conv() {
     assert_eq!(f128::from_bits(masked_nan2).to_bits(), masked_nan2);
 }
 
-#[test]
-fn test_algebraic() {
-    let a: f128 = 123.0;
-    let b: f128 = 456.0;
-
-    // Check that individual operations match their primitive counterparts.
-    //
-    // This is a check of current implementations and does NOT imply any form of
-    // guarantee about future behavior. The compiler reserves the right to make
-    // these operations inexact matches in the future.
-    let eps = if cfg!(miri) { 1e-6 } else { 0.0 };
-
-    assert_approx_eq!(a.algebraic_add(b), a + b, eps);
-    assert_approx_eq!(a.algebraic_sub(b), a - b, eps);
-    assert_approx_eq!(a.algebraic_mul(b), a * b, eps);
-    assert_approx_eq!(a.algebraic_div(b), a / b, eps);
-    assert_approx_eq!(a.algebraic_rem(b), a % b, eps);
-}
-
 #[test]
 fn test_from() {
     assert_biteq!(f128::from(false), 0.0);
diff --git a/library/coretests/tests/floats/f16.rs b/library/coretests/tests/floats/f16.rs
index c12de7221baa7..d2818a6d76897 100644
--- a/library/coretests/tests/floats/f16.rs
+++ b/library/coretests/tests/floats/f16.rs
@@ -73,27 +73,6 @@ fn test_float_bits_conv() {
     assert_eq!(f16::from_bits(masked_nan2).to_bits(), masked_nan2);
 }
 
-#[test]
-fn test_algebraic() {
-    let a: f16 = 123.0;
-    let b: f16 = 456.0;
-
-    // Check that individual operations match their primitive counterparts.
-    //
-    // This is a check of current implementations and does NOT imply any form of
-    // guarantee about future behavior. The compiler reserves the right to make
-    // these operations inexact matches in the future.
-    let eps_add = if cfg!(miri) { 1e1 } else { 0.0 };
-    let eps_mul = if cfg!(miri) { 1e3 } else { 0.0 };
-    let eps_div = if cfg!(miri) { 1e0 } else { 0.0 };
-
-    assert_approx_eq!(a.algebraic_add(b), a + b, eps_add);
-    assert_approx_eq!(a.algebraic_sub(b), a - b, eps_add);
-    assert_approx_eq!(a.algebraic_mul(b), a * b, eps_mul);
-    assert_approx_eq!(a.algebraic_div(b), a / b, eps_div);
-    assert_approx_eq!(a.algebraic_rem(b), a % b, eps_div);
-}
-
 #[test]
 fn test_from() {
     assert_biteq!(f16::from(false), 0.0);
diff --git a/library/coretests/tests/floats/f32.rs b/library/coretests/tests/floats/f32.rs
index b79295f470def..7b25f354da428 100644
--- a/library/coretests/tests/floats/f32.rs
+++ b/library/coretests/tests/floats/f32.rs
@@ -1,6 +1,6 @@
 use core::f32;
 
-use super::{assert_approx_eq, assert_biteq};
+use super::assert_biteq;
 
 /// First pattern over the mantissa
 const NAN_MASK1: u32 = 0x002a_aaaa;
@@ -47,24 +47,3 @@ fn test_float_bits_conv() {
     assert_eq!(f32::from_bits(masked_nan1).to_bits(), masked_nan1);
     assert_eq!(f32::from_bits(masked_nan2).to_bits(), masked_nan2);
 }
-
-#[test]
-fn test_algebraic() {
-    let a: f32 = 123.0;
-    let b: f32 = 456.0;
-
-    // Check that individual operations match their primitive counterparts.
-    //
-    // This is a check of current implementations and does NOT imply any form of
-    // guarantee about future behavior. The compiler reserves the right to make
-    // these operations inexact matches in the future.
-    let eps_add = if cfg!(miri) { 1e-3 } else { 0.0 };
-    let eps_mul = if cfg!(miri) { 1e-1 } else { 0.0 };
-    let eps_div = if cfg!(miri) { 1e-4 } else { 0.0 };
-
-    assert_approx_eq!(a.algebraic_add(b), a + b, eps_add);
-    assert_approx_eq!(a.algebraic_sub(b), a - b, eps_add);
-    assert_approx_eq!(a.algebraic_mul(b), a * b, eps_mul);
-    assert_approx_eq!(a.algebraic_div(b), a / b, eps_div);
-    assert_approx_eq!(a.algebraic_rem(b), a % b, eps_div);
-}
diff --git a/library/coretests/tests/floats/f64.rs b/library/coretests/tests/floats/f64.rs
index a254058632867..099d85627a346 100644
--- a/library/coretests/tests/floats/f64.rs
+++ b/library/coretests/tests/floats/f64.rs
@@ -1,6 +1,6 @@
 use core::f64;
 
-use super::{assert_approx_eq, assert_biteq};
+use super::assert_biteq;
 
 /// First pattern over the mantissa
 const NAN_MASK1: u64 = 0x000a_aaaa_aaaa_aaaa;
@@ -46,22 +46,3 @@ fn test_float_bits_conv() {
     assert_eq!(f64::from_bits(masked_nan1).to_bits(), masked_nan1);
     assert_eq!(f64::from_bits(masked_nan2).to_bits(), masked_nan2);
 }
-
-#[test]
-fn test_algebraic() {
-    let a: f64 = 123.0;
-    let b: f64 = 456.0;
-
-    // Check that individual operations match their primitive counterparts.
-    //
-    // This is a check of current implementations and does NOT imply any form of
-    // guarantee about future behavior. The compiler reserves the right to make
-    // these operations inexact matches in the future.
-    let eps = if cfg!(miri) { 1e-6 } else { 0.0 };
-
-    assert_approx_eq!(a.algebraic_add(b), a + b, eps);
-    assert_approx_eq!(a.algebraic_sub(b), a - b, eps);
-    assert_approx_eq!(a.algebraic_mul(b), a * b, eps);
-    assert_approx_eq!(a.algebraic_div(b), a / b, eps);
-    assert_approx_eq!(a.algebraic_rem(b), a % b, eps);
-}
diff --git a/library/coretests/tests/floats/mod.rs b/library/coretests/tests/floats/mod.rs
index 5f59cb9cce379..c0439845a4a48 100644
--- a/library/coretests/tests/floats/mod.rs
+++ b/library/coretests/tests/floats/mod.rs
@@ -27,6 +27,9 @@ trait TestableFloat: Sized {
     const NAN_MASK1: Self::Int;
     /// Second pattern over the mantissa
     const NAN_MASK2: Self::Int;
+    const EPS_ADD: Self;
+    const EPS_MUL: Self;
+    const EPS_DIV: Self;
 }
 
 impl TestableFloat for f16 {
@@ -44,6 +47,9 @@ impl TestableFloat for f16 {
     const MAX_DOWN: Self = Self::from_bits(0x7bfe);
     const NAN_MASK1: Self::Int = 0x02aa;
     const NAN_MASK2: Self::Int = 0x0155;
+    const EPS_ADD: Self = if cfg!(miri) { 1e1 } else { 0.0 };
+    const EPS_MUL: Self = if cfg!(miri) { 1e3 } else { 0.0 };
+    const EPS_DIV: Self = if cfg!(miri) { 1e0 } else { 0.0 };
 }
 
 impl TestableFloat for f32 {
@@ -63,6 +69,9 @@ impl TestableFloat for f32 {
     const MAX_DOWN: Self = Self::from_bits(0x7f7f_fffe);
     const NAN_MASK1: Self::Int = 0x002a_aaaa;
     const NAN_MASK2: Self::Int = 0x0055_5555;
+    const EPS_ADD: Self = if cfg!(miri) { 1e-3 } else { 0.0 };
+    const EPS_MUL: Self = if cfg!(miri) { 1e-1 } else { 0.0 };
+    const EPS_DIV: Self = if cfg!(miri) { 1e-4 } else { 0.0 };
 }
 
 impl TestableFloat for f64 {
@@ -78,6 +87,9 @@ impl TestableFloat for f64 {
     const MAX_DOWN: Self = Self::from_bits(0x7fef_ffff_ffff_fffe);
     const NAN_MASK1: Self::Int = 0x000a_aaaa_aaaa_aaaa;
     const NAN_MASK2: Self::Int = 0x0005_5555_5555_5555;
+    const EPS_ADD: Self = if cfg!(miri) { 1e-6 } else { 0.0 };
+    const EPS_MUL: Self = if cfg!(miri) { 1e-6 } else { 0.0 };
+    const EPS_DIV: Self = if cfg!(miri) { 1e-6 } else { 0.0 };
 }
 
 impl TestableFloat for f128 {
@@ -93,6 +105,9 @@ impl TestableFloat for f128 {
     const MAX_DOWN: Self = Self::from_bits(0x7ffefffffffffffffffffffffffffffe);
     const NAN_MASK1: Self::Int = 0x0000aaaaaaaaaaaaaaaaaaaaaaaaaaaa;
     const NAN_MASK2: Self::Int = 0x00005555555555555555555555555555;
+    const EPS_ADD: Self = if cfg!(miri) { 1e-6 } else { 0.0 };
+    const EPS_MUL: Self = if cfg!(miri) { 1e-6 } else { 0.0 };
+    const EPS_DIV: Self = if cfg!(miri) { 1e-6 } else { 0.0 };
 }
 
 /// Determine the tolerance for values of the argument type.
@@ -1440,3 +1455,27 @@ float_test! {
         assert_biteq!(neg_inf.to_radians(), neg_inf);
     }
 }
+
+float_test! {
+    name: to_algebraic,
+    attrs: {
+        f16: #[cfg(target_has_reliable_f16)],
+        f128: #[cfg(target_has_reliable_f128)],
+    },
+    test<Float> {
+        let a: Float = 123.0;
+        let b: Float = 456.0;
+
+        // Check that individual operations match their primitive counterparts.
+        //
+        // This is a check of current implementations and does NOT imply any form of
+        // guarantee about future behavior. The compiler reserves the right to make
+        // these operations inexact matches in the future.
+
+        assert_approx_eq!(a.algebraic_add(b), a + b, Float::EPS_ADD);
+        assert_approx_eq!(a.algebraic_sub(b), a - b, Float::EPS_ADD);
+        assert_approx_eq!(a.algebraic_mul(b), a * b, Float::EPS_MUL);
+        assert_approx_eq!(a.algebraic_div(b), a / b, Float::EPS_DIV);
+        assert_approx_eq!(a.algebraic_rem(b), a % b, Float::EPS_DIV);
+    }
+}

From 1bf57df7d72333bb4289d8f7072e8e170ad54ce2 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Wed, 3 Sep 2025 21:14:19 +0800
Subject: [PATCH 0456/1889] Add applicable on bang `!` for apply_demorgan

Example
---
```rust
fn f() { $0!(1 || 3 && 4 || 5) }
```
->
```rust
fn f() { !1 && !(3 && 4) && !5 }
```
---
 .../src/handlers/apply_demorgan.rs            | 35 +++++++++++++++----
 1 file changed, 28 insertions(+), 7 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/apply_demorgan.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/apply_demorgan.rs
index 753a9e56c35ac..53a0a11998a0f 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/apply_demorgan.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/apply_demorgan.rs
@@ -6,7 +6,7 @@ use ide_db::{
     syntax_helpers::node_ext::{for_each_tail_expr, walk_expr},
 };
 use syntax::{
-    SyntaxKind, T,
+    NodeOrToken, SyntaxKind, T,
     ast::{
         self, AstNode,
         Expr::BinExpr,
@@ -38,15 +38,27 @@ use crate::{AssistContext, AssistId, Assists, utils::invert_boolean_expression};
 // }
 // ```
 pub(crate) fn apply_demorgan(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {
-    let mut bin_expr = ctx.find_node_at_offset::<ast::BinExpr>()?;
+    let mut bin_expr = if let Some(not) = ctx.find_token_syntax_at_offset(T![!])
+        && let Some(NodeOrToken::Node(next)) = not.next_sibling_or_token()
+        && let Some(paren) = ast::ParenExpr::cast(next)
+        && let Some(ast::Expr::BinExpr(bin_expr)) = paren.expr()
+    {
+        bin_expr
+    } else {
+        let bin_expr = ctx.find_node_at_offset::<ast::BinExpr>()?;
+        let op_range = bin_expr.op_token()?.text_range();
+
+        // Is the cursor on the expression's logical operator?
+        if !op_range.contains_range(ctx.selection_trimmed()) {
+            return None;
+        }
+
+        bin_expr
+    };
+
     let op = bin_expr.op_kind()?;
     let op_range = bin_expr.op_token()?.text_range();
 
-    // Is the cursor on the expression's logical operator?
-    if !op_range.contains_range(ctx.selection_trimmed()) {
-        return None;
-    }
-
     // Walk up the tree while we have the same binary operator
     while let Some(parent_expr) = bin_expr.syntax().parent().and_then(ast::BinExpr::cast) {
         match parent_expr.op_kind() {
@@ -366,6 +378,15 @@ fn f() { !(S <= S || S < S) }
         )
     }
 
+    #[test]
+    fn demorgan_on_not() {
+        check_assist(
+            apply_demorgan,
+            "fn f() { $0!(1 || 3 && 4 || 5) }",
+            "fn f() { !1 && !(3 && 4) && !5 }",
+        )
+    }
+
     #[test]
     fn demorgan_keep_pars_for_op_precedence() {
         check_assist(

From 5c4b61b4b4b13e408b28ecc91f4f517e78e6b5e7 Mon Sep 17 00:00:00 2001
From: Sasha Pourcelot <sasha.pourcelot@protonmail.com>
Date: Mon, 1 Sep 2025 16:47:55 +0200
Subject: [PATCH 0457/1889] don't uppercase error messages

a more general version of https://github.com/rust-lang/rust/pull/146080.

after a bit of hacking in [`fluent.rs`](https://github.com/rust-lang/rust/blob/master/compiler/rustc_fluent_macro/src/fluent.rs), i discovered that i'm not the only one that is bad at following guidelines :sweat_smile:. this pr lowercases the first letter of all the error messages in the codebase.

(i did not change things that are traditionally uppercased such as _MIR_, _ABI_ or _C_)

i think it's reasonable to run a `@bors try` so all the test suite is checked, as i cannot run some of the tests on my machine. i double checked (and replaced manually) all the old error messages, but better be safe than sorry.

in the future i will try to add a check in `x test tidy` that errors if an error message starts with an uppercase letter.
---
 compiler/rustc_attr_parsing/messages.ftl      |   2 +-
 compiler/rustc_codegen_ssa/messages.ftl       |  14 +--
 compiler/rustc_const_eval/messages.ftl        |   2 +-
 compiler/rustc_driver_impl/messages.ftl       |   4 +-
 compiler/rustc_parse/messages.ftl             |   2 +-
 compiler/rustc_query_system/messages.ftl      |   4 +-
 .../command-line-arguments/print-options.md   |   2 +-
 tests/run-make/separate-link-fail/rmake.rs    |   2 +-
 .../codegen/empty-static-libs-issue-108825.rs |   2 +-
 .../invalid-patterns.32bit.stderr             |   4 +-
 .../invalid-patterns.64bit.stderr             |   4 +-
 tests/ui/const-ptr/forbidden_slices.stderr    |  26 ++---
 .../heap/alloc_intrinsic_uninit.32bit.stderr  |   2 +-
 .../heap/alloc_intrinsic_uninit.64bit.stderr  |   2 +-
 .../heap/dealloc_intrinsic_dangling.stderr    |   2 +-
 .../consts/const-eval/raw-bytes.32bit.stderr  | 100 +++++++++---------
 .../consts/const-eval/raw-bytes.64bit.stderr  | 100 +++++++++---------
 .../consts/const-eval/transmute-const.stderr  |   2 +-
 tests/ui/consts/const-eval/ub-enum.stderr     |  10 +-
 .../ub-incorrect-vtable.32bit.stderr          |  12 +--
 .../ub-incorrect-vtable.64bit.stderr          |  12 +--
 .../ui/consts/const-eval/ub-int-array.stderr  |   6 +-
 tests/ui/consts/const-eval/ub-nonnull.stderr  |  12 +--
 tests/ui/consts/const-eval/ub-ref-ptr.stderr  |  18 ++--
 .../ui/consts/const-eval/ub-uninhabit.stderr  |   2 +-
 .../consts/const-eval/ub-upvars.32bit.stderr  |   2 +-
 .../consts/const-eval/ub-upvars.64bit.stderr  |   2 +-
 tests/ui/consts/const-eval/ub-wide-ptr.stderr |  46 ++++----
 .../consts/const-eval/union-ub.32bit.stderr   |   2 +-
 .../consts/const-eval/union-ub.64bit.stderr   |   2 +-
 .../const-mut-refs/mut_ref_in_final.stderr    |   4 +-
 .../mut_ref_in_final_dynamic_check.stderr     |  10 +-
 .../const_refs_to_static_fail_invalid.stderr  |   2 +-
 tests/ui/consts/dangling-alloc-id-ice.stderr  |   2 +-
 .../dangling-zst-ice-issue-126393.stderr      |   2 +-
 .../interior-mut-const-via-union.32bit.stderr |   2 +-
 .../interior-mut-const-via-union.64bit.stderr |   2 +-
 .../issue-17718-const-bad-values.stderr       |   2 +-
 tests/ui/consts/issue-63952.32bit.stderr      |   2 +-
 tests/ui/consts/issue-63952.64bit.stderr      |   2 +-
 tests/ui/consts/issue-79690.64bit.stderr      |   2 +-
 .../miri_unleashed/mutable_references.stderr  |  16 +--
 .../static-no-inner-mut.32bit.stderr          |   8 +-
 .../static-no-inner-mut.64bit.stderr          |   8 +-
 tests/ui/consts/validate_never_arrays.stderr  |   6 +-
 .../raw-dylib/windows/invalid-dlltool.rs      |   2 +-
 .../raw-dylib/windows/invalid-dlltool.stderr  |   2 +-
 tests/ui/pattern/at-in-struct-patterns.rs     |   2 +-
 tests/ui/pattern/at-in-struct-patterns.stderr |   2 +-
 .../statics/mutable_memory_validation.stderr  |   2 +-
 tests/ui/type/pattern_types/validity.stderr   |  10 +-
 ...le_feature_bound_incompatible_stability.rs |   2 +-
 ...eature_bound_incompatible_stability.stderr |   2 +-
 53 files changed, 248 insertions(+), 248 deletions(-)

diff --git a/compiler/rustc_attr_parsing/messages.ftl b/compiler/rustc_attr_parsing/messages.ftl
index b8a748563d520..7fa1293463cc5 100644
--- a/compiler/rustc_attr_parsing/messages.ftl
+++ b/compiler/rustc_attr_parsing/messages.ftl
@@ -151,7 +151,7 @@ attr_parsing_unrecognized_repr_hint =
 attr_parsing_unstable_cfg_target_compact =
     compact `cfg(target(..))` is experimental and subject to change
 
-attr_parsing_unstable_feature_bound_incompatible_stability = Item annotated with `#[unstable_feature_bound]` should not be stable
+attr_parsing_unstable_feature_bound_incompatible_stability = item annotated with `#[unstable_feature_bound]` should not be stable
     .help = If this item is meant to be stable, do not use any functions annotated with `#[unstable_feature_bound]`. Otherwise, mark this item as unstable with `#[unstable]`
 
 attr_parsing_unsupported_literal_cfg_boolean =
diff --git a/compiler/rustc_codegen_ssa/messages.ftl b/compiler/rustc_codegen_ssa/messages.ftl
index 44b9941691a6b..dd688b8b34541 100644
--- a/compiler/rustc_codegen_ssa/messages.ftl
+++ b/compiler/rustc_codegen_ssa/messages.ftl
@@ -40,15 +40,15 @@ codegen_ssa_dynamic_linking_with_lto =
     .note = only 'staticlib', 'bin', and 'cdylib' outputs are supported with LTO
 
 codegen_ssa_error_calling_dlltool =
-    Error calling dlltool '{$dlltool_path}': {$error}
+    error calling dlltool '{$dlltool_path}': {$error}
 
 codegen_ssa_error_creating_import_library =
-    Error creating import library for {$lib_name}: {$error}
+    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 =
-    Error writing .DEF file: {$error}
+    error writing .DEF file: {$error}
 
 codegen_ssa_expected_name_value_pair = expected name value pair
 
@@ -264,9 +264,9 @@ codegen_ssa_shuffle_indices_evaluation = could not evaluate shuffle_indices at c
 
 codegen_ssa_specify_libraries_to_link = use the `-l` flag to specify native libraries to link
 
-codegen_ssa_static_library_native_artifacts = Link against the following native artifacts when linking against this static library. The order and any duplication can be significant on some platforms.
+codegen_ssa_static_library_native_artifacts = link against the following native artifacts when linking against this static library. The order and any duplication can be significant on some platforms.
 
-codegen_ssa_static_library_native_artifacts_to_file = Native artifacts to link against have been written to {$path}. The order and any duplication can be significant on some platforms.
+codegen_ssa_static_library_native_artifacts_to_file = native artifacts to link against have been written to {$path}. The order and any duplication can be significant on some platforms.
 
 codegen_ssa_stripping_debug_info_failed = stripping debug info with `{$util}` failed: {$status}
     .note = {$output}
@@ -364,13 +364,13 @@ codegen_ssa_unable_to_run = unable to run `{$util}`: {$error}
 
 codegen_ssa_unable_to_run_dsymutil = unable to run `dsymutil`: {$error}
 
-codegen_ssa_unable_to_write_debugger_visualizer = Unable to write debugger visualizer file `{$path}`: {$error}
+codegen_ssa_unable_to_write_debugger_visualizer = unable to write debugger visualizer file `{$path}`: {$error}
 
 codegen_ssa_unexpected_parameter_name = unexpected parameter name
     .label = expected `{$prefix_nops}` or `{$entry_nops}`
 
 codegen_ssa_unknown_archive_kind =
-    Don't know how to build archive of type: {$kind}
+    don't know how to build archive of type: {$kind}
 
 codegen_ssa_unknown_ctarget_feature =
     unknown and unstable feature specified for `-Ctarget-feature`: `{$feature}`
diff --git a/compiler/rustc_const_eval/messages.ftl b/compiler/rustc_const_eval/messages.ftl
index 60518dafbf2b4..700d7c26752b6 100644
--- a/compiler/rustc_const_eval/messages.ftl
+++ b/compiler/rustc_const_eval/messages.ftl
@@ -457,7 +457,7 @@ const_eval_validation_failure =
     it is undefined behavior to use this value
 
 const_eval_validation_failure_note =
-    The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+    the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
 
 const_eval_validation_front_matter_invalid_value = constructing invalid value
 const_eval_validation_front_matter_invalid_value_with_path = constructing invalid value at {$path}
diff --git a/compiler/rustc_driver_impl/messages.ftl b/compiler/rustc_driver_impl/messages.ftl
index 2c6a0291ac29b..b62cdc35f5130 100644
--- a/compiler/rustc_driver_impl/messages.ftl
+++ b/compiler/rustc_driver_impl/messages.ftl
@@ -14,7 +14,7 @@ driver_impl_ice_version = rustc {$version} running on {$triple}
 
 driver_impl_rlink_corrupt_file = corrupt metadata encountered in `{$file}`
 
-driver_impl_rlink_empty_version_number = The input does not contain version number
+driver_impl_rlink_empty_version_number = the input does not contain version number
 
 driver_impl_rlink_encoding_version_mismatch = .rlink file was produced with encoding version `{$version_array}`, but the current version is `{$rlink_version}`
 
@@ -24,6 +24,6 @@ driver_impl_rlink_rustc_version_mismatch = .rlink file was produced by rustc ver
 
 driver_impl_rlink_unable_to_read = failed to read rlink file: `{$err}`
 
-driver_impl_rlink_wrong_file_type = The input does not look like a .rlink file
+driver_impl_rlink_wrong_file_type = the input does not look like a .rlink file
 
 driver_impl_unstable_feature_usage = cannot dump feature usage metrics: {$error}
diff --git a/compiler/rustc_parse/messages.ftl b/compiler/rustc_parse/messages.ftl
index 4ca2f57bd875e..77dd313d9b8eb 100644
--- a/compiler/rustc_parse/messages.ftl
+++ b/compiler/rustc_parse/messages.ftl
@@ -58,7 +58,7 @@ parse_async_use_order_incorrect = the order of `use` and `async` is incorrect
 parse_at_dot_dot_in_struct_pattern = `@ ..` is not supported in struct patterns
     .suggestion = bind to each field separately or, if you don't need them, just remove `{$ident} @`
 
-parse_at_in_struct_pattern = Unexpected `@` in struct pattern
+parse_at_in_struct_pattern = unexpected `@` in struct pattern
     .note = struct patterns use `field: pattern` syntax to bind to fields
     .help = consider replacing `new_name @ field_name` with `field_name: new_name` if that is what you intended
 
diff --git a/compiler/rustc_query_system/messages.ftl b/compiler/rustc_query_system/messages.ftl
index f48dc60afa0e7..f686608034cba 100644
--- a/compiler/rustc_query_system/messages.ftl
+++ b/compiler/rustc_query_system/messages.ftl
@@ -18,8 +18,8 @@ query_system_cycle_usage = cycle used when {$usage}
 query_system_increment_compilation = internal compiler error: encountered incremental compilation error with {$dep_node}
     .help = This is a known issue with the compiler. Run {$run_cmd} to allow your project to compile
 
-query_system_increment_compilation_note1 = Please follow the instructions below to create a bug report with the provided information
-query_system_increment_compilation_note2 = See <https://github.com/rust-lang/rust/issues/84970> for more information
+query_system_increment_compilation_note1 = please follow the instructions below to create a bug report with the provided information
+query_system_increment_compilation_note2 = see <https://github.com/rust-lang/rust/issues/84970> for more information
 
 query_system_overflow_note = query depth increased by {$depth} when {$desc}
 
diff --git a/src/doc/rustc/src/command-line-arguments/print-options.md b/src/doc/rustc/src/command-line-arguments/print-options.md
index fed19d6b667e9..f37b27d88c385 100644
--- a/src/doc/rustc/src/command-line-arguments/print-options.md
+++ b/src/doc/rustc/src/command-line-arguments/print-options.md
@@ -184,7 +184,7 @@ Example:
 
 ```bash
 $ rustc --print native-static-libs --crate-type staticlib a.rs
-note: Link against the following native artifacts when linking against this static library. The order and any duplication can be significant on some platforms.
+note: link against the following native artifacts when linking against this static library. The order and any duplication can be significant on some platforms.
 
 note: native-static-libs: -lgcc_s -lutil [REDACTED] -lpthread -lm -ldl -lc
 ```
diff --git a/tests/run-make/separate-link-fail/rmake.rs b/tests/run-make/separate-link-fail/rmake.rs
index b5d5300de68f7..ba24f7773953f 100644
--- a/tests/run-make/separate-link-fail/rmake.rs
+++ b/tests/run-make/separate-link-fail/rmake.rs
@@ -11,5 +11,5 @@ fn main() {
         .arg("-Zlink-only")
         .input("foo.rs")
         .run_fail()
-        .assert_stderr_contains("The input does not look like a .rlink file");
+        .assert_stderr_contains("the input does not look like a .rlink file");
 }
diff --git a/tests/ui/codegen/empty-static-libs-issue-108825.rs b/tests/ui/codegen/empty-static-libs-issue-108825.rs
index 4c644be0954e3..4f8e4420f7245 100644
--- a/tests/ui/codegen/empty-static-libs-issue-108825.rs
+++ b/tests/ui/codegen/empty-static-libs-issue-108825.rs
@@ -15,4 +15,4 @@ fn panic(_info: &core::panic::PanicInfo) -> ! {
 }
 
 //~? NOTE native-static-libs:
-//~? NOTE Link against the following native artifacts when linking against this static library
+//~? NOTE link against the following native artifacts when linking against this static library
diff --git a/tests/ui/const-generics/min_const_generics/invalid-patterns.32bit.stderr b/tests/ui/const-generics/min_const_generics/invalid-patterns.32bit.stderr
index 0c57eddbe937f..cc6a813b747d9 100644
--- a/tests/ui/const-generics/min_const_generics/invalid-patterns.32bit.stderr
+++ b/tests/ui/const-generics/min_const_generics/invalid-patterns.32bit.stderr
@@ -14,7 +14,7 @@ error[E0080]: constructing invalid value: encountered 0x42, but expected a boole
 LL |   get_flag::<{ unsafe { bool_raw.boolean } }, 'z'>();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 1, align: 1) {
                42                                              │ B
            }
@@ -25,7 +25,7 @@ error[E0080]: constructing invalid value: encountered 0x42, but expected a boole
 LL |   get_flag::<{ unsafe { bool_raw.boolean } }, { unsafe { char_raw.character } }>();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 1, align: 1) {
                42                                              │ B
            }
diff --git a/tests/ui/const-generics/min_const_generics/invalid-patterns.64bit.stderr b/tests/ui/const-generics/min_const_generics/invalid-patterns.64bit.stderr
index 0c57eddbe937f..cc6a813b747d9 100644
--- a/tests/ui/const-generics/min_const_generics/invalid-patterns.64bit.stderr
+++ b/tests/ui/const-generics/min_const_generics/invalid-patterns.64bit.stderr
@@ -14,7 +14,7 @@ error[E0080]: constructing invalid value: encountered 0x42, but expected a boole
 LL |   get_flag::<{ unsafe { bool_raw.boolean } }, 'z'>();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 1, align: 1) {
                42                                              │ B
            }
@@ -25,7 +25,7 @@ error[E0080]: constructing invalid value: encountered 0x42, but expected a boole
 LL |   get_flag::<{ unsafe { bool_raw.boolean } }, { unsafe { char_raw.character } }>();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 1, align: 1) {
                42                                              │ B
            }
diff --git a/tests/ui/const-ptr/forbidden_slices.stderr b/tests/ui/const-ptr/forbidden_slices.stderr
index 25d6f0461a9ac..70ae00af23f53 100644
--- a/tests/ui/const-ptr/forbidden_slices.stderr
+++ b/tests/ui/const-ptr/forbidden_slices.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value: encountered a null reference
 LL | pub static S0: &[u32] = unsafe { from_raw_parts(ptr::null(), 0) };
    | ^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -15,7 +15,7 @@ error[E0080]: constructing invalid value: encountered a null reference
 LL | pub static S1: &[()] = unsafe { from_raw_parts(ptr::null(), 0) };
    | ^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -26,7 +26,7 @@ error[E0080]: constructing invalid value: encountered a dangling reference (goin
 LL | pub static S2: &[u32] = unsafe { from_raw_parts(&D0, 2) };
    | ^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -37,7 +37,7 @@ error[E0080]: constructing invalid value at .<deref>[0]: encountered uninitializ
 LL | pub static S4: &[u8] = unsafe { from_raw_parts((&D1) as *const _ as _, 1) };
    | ^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -50,7 +50,7 @@ LL | pub static S5: &[u8] = unsafe { from_raw_parts((&D3) as *const _ as _, size
    |
    = 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
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -61,7 +61,7 @@ error[E0080]: constructing invalid value at .<deref>[0]: encountered 0x11, but e
 LL | pub static S6: &[bool] = unsafe { from_raw_parts((&D0) as *const _ as _, 4) };
    | ^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -72,7 +72,7 @@ error[E0080]: constructing invalid value at .<deref>[1]: encountered uninitializ
 LL | pub static S7: &[u16] = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -83,7 +83,7 @@ error[E0080]: constructing invalid value: encountered a dangling reference (goin
 LL | pub static S8: &[u64] = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -94,7 +94,7 @@ error[E0080]: constructing invalid value: encountered a null reference
 LL | pub static R0: &[u32] = unsafe { from_ptr_range(ptr::null()..ptr::null()) };
    | ^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -117,7 +117,7 @@ error[E0080]: constructing invalid value at .<deref>[0]: encountered uninitializ
 LL | pub static R4: &[u8] = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -130,7 +130,7 @@ LL | pub static R5: &[u8] = unsafe {
    |
    = 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
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -141,7 +141,7 @@ error[E0080]: constructing invalid value at .<deref>[0]: encountered 0x11, but e
 LL | pub static R6: &[bool] = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -152,7 +152,7 @@ error[E0080]: constructing invalid value: encountered an unaligned reference (re
 LL | pub static R7: &[u16] = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
diff --git a/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.32bit.stderr b/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.32bit.stderr
index a8c7ee93971ec..239bca51fc96f 100644
--- a/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.32bit.stderr
+++ b/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.32bit.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value at .<deref>: encountered uninitialized
 LL | const BAR: &i32 = unsafe {
    | ^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                ╾ALLOC0<imm>╼                                     │ ╾──╼
            }
diff --git a/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.64bit.stderr b/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.64bit.stderr
index 47e1c22cc2c12..3c6d66ac5b673 100644
--- a/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.64bit.stderr
+++ b/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.64bit.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value at .<deref>: encountered uninitialized
 LL | const BAR: &i32 = unsafe {
    | ^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 8) {
                ╾ALLOC0<imm>╼                         │ ╾──────╼
            }
diff --git a/tests/ui/consts/const-eval/heap/dealloc_intrinsic_dangling.stderr b/tests/ui/consts/const-eval/heap/dealloc_intrinsic_dangling.stderr
index d4039e1952c35..152eeababc51a 100644
--- a/tests/ui/consts/const-eval/heap/dealloc_intrinsic_dangling.stderr
+++ b/tests/ui/consts/const-eval/heap/dealloc_intrinsic_dangling.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value: encountered a dangling reference (use-
 LL | const _X: &'static u8 = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
diff --git a/tests/ui/consts/const-eval/raw-bytes.32bit.stderr b/tests/ui/consts/const-eval/raw-bytes.32bit.stderr
index 36183e2892101..2861f82ec53b1 100644
--- a/tests/ui/consts/const-eval/raw-bytes.32bit.stderr
+++ b/tests/ui/consts/const-eval/raw-bytes.32bit.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value at .<enum-tag>: encountered 0x00000001,
 LL | const BAD_ENUM: Enum = unsafe { mem::transmute(1usize) };
    | ^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                01 00 00 00                                     │ ....
            }
@@ -15,7 +15,7 @@ error[E0080]: constructing invalid value at .<enum-tag>: encountered 0x00000000,
 LL | const BAD_ENUM2: Enum2 = unsafe { mem::transmute(0usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                00 00 00 00                                     │ ....
            }
@@ -26,7 +26,7 @@ error[E0080]: constructing invalid value at .<enum-tag>: encountered an uninhabi
 LL | const BAD_UNINHABITED_VARIANT1: UninhDiscriminant = unsafe { mem::transmute(1u8) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 1, align: 1) {
                01                                              │ .
            }
@@ -37,7 +37,7 @@ error[E0080]: constructing invalid value at .<enum-tag>: encountered an uninhabi
 LL | const BAD_UNINHABITED_VARIANT2: UninhDiscriminant = unsafe { mem::transmute(3u8) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 1, align: 1) {
                03                                              │ .
            }
@@ -48,7 +48,7 @@ error[E0080]: constructing invalid value at .<enum-variant(Some)>.0.1: encounter
 LL | const BAD_OPTION_CHAR: Option<(char, char)> = Some(('x', unsafe { mem::transmute(!0u32) }));
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                78 00 00 00 ff ff ff ff                         │ x.......
            }
@@ -59,7 +59,7 @@ error[E0080]: constructing invalid value: encountered 0, but expected something
 LL | const NULL_PTR: NonNull<u8> = unsafe { mem::transmute(0usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                00 00 00 00                                     │ ....
            }
@@ -70,7 +70,7 @@ error[E0080]: constructing invalid value at .0: encountered 0, but expected some
 LL | const NULL_U8: NonZero<u8> = unsafe { mem::transmute(0u8) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 1, align: 1) {
                00                                              │ .
            }
@@ -81,7 +81,7 @@ error[E0080]: constructing invalid value at .0: encountered 0, but expected some
 LL | const NULL_USIZE: NonZero<usize> = unsafe { mem::transmute(0usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                00 00 00 00                                     │ ....
            }
@@ -92,7 +92,7 @@ error[E0080]: constructing invalid value: encountered 42, but expected something
 LL | const BAD_RANGE1: RestrictedRange1 = unsafe { RestrictedRange1(42) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                2a 00 00 00                                     │ *...
            }
@@ -103,7 +103,7 @@ error[E0080]: constructing invalid value: encountered 20, but expected something
 LL | const BAD_RANGE2: RestrictedRange2 = unsafe { RestrictedRange2(20) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                14 00 00 00                                     │ ....
            }
@@ -114,7 +114,7 @@ error[E0080]: constructing invalid value: encountered 0, but expected something
 LL | const NULL_FAT_PTR: NonNull<dyn Send> = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                00 00 00 00 ╾ALLOC_ID╼                         │ ....╾──╼
            }
@@ -125,7 +125,7 @@ error[E0080]: constructing invalid value: encountered an unaligned reference (re
 LL | const UNALIGNED: &u16 = unsafe { mem::transmute(&[0u8; 4]) };
    | ^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                ╾ALLOC_ID╼                                     │ ╾──╼
            }
@@ -136,7 +136,7 @@ error[E0080]: constructing invalid value: encountered an unaligned box (required
 LL | const UNALIGNED_BOX: Box<u16> = unsafe { mem::transmute(&[0u8; 4]) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                ╾ALLOC_ID╼                                     │ ╾──╼
            }
@@ -147,7 +147,7 @@ error[E0080]: constructing invalid value: encountered a null reference
 LL | const NULL: &u16 = unsafe { mem::transmute(0usize) };
    | ^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                00 00 00 00                                     │ ....
            }
@@ -158,7 +158,7 @@ error[E0080]: constructing invalid value: encountered a null box
 LL | const NULL_BOX: Box<u16> = unsafe { mem::transmute(0usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                00 00 00 00                                     │ ....
            }
@@ -169,7 +169,7 @@ error[E0080]: constructing invalid value: encountered a dangling reference (0x53
 LL | const USIZE_AS_REF: &'static u8 = unsafe { mem::transmute(1337usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                39 05 00 00                                     │ 9...
            }
@@ -180,7 +180,7 @@ error[E0080]: constructing invalid value: encountered a dangling box (0x539[noal
 LL | const USIZE_AS_BOX: Box<u8> = unsafe { mem::transmute(1337usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                39 05 00 00                                     │ 9...
            }
@@ -191,7 +191,7 @@ error[E0080]: constructing invalid value: encountered null pointer, but expected
 LL | const NULL_FN_PTR: fn() = unsafe { mem::transmute(0usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                00 00 00 00                                     │ ....
            }
@@ -202,7 +202,7 @@ error[E0080]: constructing invalid value: encountered 0xd[noalloc], but expected
 LL | const DANGLING_FN_PTR: fn() = unsafe { mem::transmute(13usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                0d 00 00 00                                     │ ....
            }
@@ -213,7 +213,7 @@ error[E0080]: constructing invalid value: encountered ALLOC3<imm>, but expected
 LL | const DATA_FN_PTR: fn() = unsafe { mem::transmute(&13) };
    | ^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                ╾ALLOC_ID╼                                     │ ╾──╼
            }
@@ -224,7 +224,7 @@ error[E0080]: constructing invalid value: encountered a reference pointing to un
 LL | const BAD_BAD_REF: &Bar = unsafe { mem::transmute(1usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                01 00 00 00                                     │ ....
            }
@@ -235,7 +235,7 @@ error[E0080]: constructing invalid value: encountered a dangling reference (goin
 LL | const STR_TOO_LONG: &str = unsafe { mem::transmute((&42u8, 999usize)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC_ID╼ e7 03 00 00                         │ ╾──╼....
            }
@@ -246,7 +246,7 @@ error[E0080]: constructing invalid value at .0: encountered invalid reference me
 LL | const NESTED_STR_MUCH_TOO_LONG: (&str,) = (unsafe { mem::transmute((&42, usize::MAX)) },);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC_ID╼ ff ff ff ff                         │ ╾──╼....
            }
@@ -257,7 +257,7 @@ error[E0080]: constructing invalid value: encountered invalid reference metadata
 LL | const MY_STR_MUCH_TOO_LONG: &MyStr = unsafe { mem::transmute((&42u8, usize::MAX)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC_ID╼ ff ff ff ff                         │ ╾──╼....
            }
@@ -268,7 +268,7 @@ error[E0080]: constructing invalid value at .<deref>: encountered uninitialized
 LL | const STR_NO_INIT: &str = unsafe { mem::transmute::<&[_], _>(&[MaybeUninit::<u8> { uninit: () }]) };
    | ^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC_ID╼ 01 00 00 00                         │ ╾──╼....
            }
@@ -279,7 +279,7 @@ error[E0080]: constructing invalid value at .<deref>.0: encountered uninitialize
 LL | const MYSTR_NO_INIT: &MyStr = unsafe { mem::transmute::<&[_], _>(&[MaybeUninit::<u8> { uninit: () }]) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC_ID╼ 01 00 00 00                         │ ╾──╼....
            }
@@ -292,7 +292,7 @@ LL | const MYSTR_NO_INIT_ISSUE83182: &MyStr = unsafe { mem::transmute::<&[_], _>
    |
    = 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
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC_ID╼ 01 00 00 00                         │ ╾──╼....
            }
@@ -303,7 +303,7 @@ error[E0080]: constructing invalid value: encountered a dangling reference (goin
 LL | const SLICE_TOO_LONG: &[u8] = unsafe { mem::transmute((&42u8, 999usize)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC_ID╼ e7 03 00 00                         │ ╾──╼....
            }
@@ -314,7 +314,7 @@ error[E0080]: constructing invalid value: encountered invalid reference metadata
 LL | const SLICE_TOO_LONG_OVERFLOW: &[u32] = unsafe { mem::transmute((&42u32, isize::MAX)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC_ID╼ ff ff ff 7f                         │ ╾──╼....
            }
@@ -325,7 +325,7 @@ error[E0080]: constructing invalid value: encountered a dangling box (going beyo
 LL | const SLICE_TOO_LONG_BOX: Box<[u8]> = unsafe { mem::transmute((&42u8, 999usize)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC_ID╼ e7 03 00 00                         │ ╾──╼....
            }
@@ -336,7 +336,7 @@ error[E0080]: constructing invalid value at .<deref>[0]: encountered 0x03, but e
 LL | const SLICE_CONTENT_INVALID: &[bool] = &[unsafe { mem::transmute(3u8) }];
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                ╾ALLOC_ID╼                                     │ ╾──╼
            }
@@ -353,7 +353,7 @@ error[E0080]: constructing invalid value at .<deref>.0: encountered 0x03, but ex
 LL | const MYSLICE_PREFIX_BAD: &MySliceBool = &MySlice(unsafe { mem::transmute(3u8) }, [false]);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                ╾ALLOC_ID╼                                     │ ╾──╼
            }
@@ -370,7 +370,7 @@ error[E0080]: constructing invalid value at .<deref>.1[0]: encountered 0x03, but
 LL | const MYSLICE_SUFFIX_BAD: &MySliceBool = &MySlice(true, [unsafe { mem::transmute(3u8) }]);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                ╾ALLOC_ID╼                                     │ ╾──╼
            }
@@ -387,7 +387,7 @@ error[E0080]: constructing invalid value at .0: encountered ALLOC17<imm>, but ex
 LL | const TRAIT_OBJ_SHORT_VTABLE_1: W<&dyn Trait> = unsafe { mem::transmute(W((&92u8, &3u8))) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC_ID╼ ╾ALLOC_ID╼                         │ ╾──╼╾──╼
            }
@@ -398,7 +398,7 @@ error[E0080]: constructing invalid value at .0: encountered ALLOC19<imm>, but ex
 LL | const TRAIT_OBJ_SHORT_VTABLE_2: W<&dyn Trait> = unsafe { mem::transmute(W((&92u8, &3u64))) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC_ID╼ ╾ALLOC_ID╼                         │ ╾──╼╾──╼
            }
@@ -409,7 +409,7 @@ error[E0080]: constructing invalid value at .0: encountered 0x4[noalloc], but ex
 LL | const TRAIT_OBJ_INT_VTABLE: W<&dyn Trait> = unsafe { mem::transmute(W((&92u8, 4usize))) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC_ID╼ 04 00 00 00                         │ ╾──╼....
            }
@@ -420,7 +420,7 @@ error[E0080]: constructing invalid value at .0: encountered ALLOC22<imm>, but ex
 LL | const TRAIT_OBJ_BAD_DROP_FN_NOT_FN_PTR: W<&dyn Trait> = unsafe { mem::transmute(W((&92u8, &[&42u8; 8]))) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC_ID╼ ╾ALLOC_ID╼                         │ ╾──╼╾──╼
            }
@@ -431,7 +431,7 @@ error[E0080]: constructing invalid value at .<deref>.<dyn-downcast>: encountered
 LL | const TRAIT_OBJ_CONTENT_INVALID: &dyn Trait = unsafe { mem::transmute::<_, &bool>(&3u8) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC_ID╼ ╾ALLOC_ID╼                         │ ╾──╼╾──╼
            }
@@ -442,7 +442,7 @@ error[E0080]: constructing invalid value: encountered null pointer, but expected
 LL | const RAW_TRAIT_OBJ_VTABLE_NULL: *const dyn Trait = unsafe { mem::transmute((&92u8, 0usize)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC_ID╼ 00 00 00 00                         │ ╾──╼....
            }
@@ -453,7 +453,7 @@ error[E0080]: constructing invalid value: encountered ALLOC27<imm>, but expected
 LL | const RAW_TRAIT_OBJ_VTABLE_INVALID: *const dyn Trait = unsafe { mem::transmute((&92u8, &3u64)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC_ID╼ ╾ALLOC_ID╼                         │ ╾──╼╾──╼
            }
@@ -464,7 +464,7 @@ error[E0080]: constructing invalid value: encountered a reference pointing to un
 LL | const _: &[!; 1] = unsafe { &*(1_usize as *const [!; 1]) };
    | ^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                01 00 00 00                                     │ ....
            }
@@ -475,7 +475,7 @@ error[E0080]: constructing invalid value at .<deref>[0]: encountered a value of
 LL | const _: &[!] = unsafe { &*(1_usize as *const [!; 1]) };
    | ^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                01 00 00 00 01 00 00 00                         │ ........
            }
@@ -486,7 +486,7 @@ error[E0080]: constructing invalid value at .<deref>[0]: encountered a value of
 LL | const _: &[!] = unsafe { &*(1_usize as *const [!; 42]) };
    | ^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                01 00 00 00 2a 00 00 00                         │ ....*...
            }
@@ -497,7 +497,7 @@ error[E0080]: constructing invalid value at .<deref>[0]: encountered uninitializ
 LL | pub static S4: &[u8] = unsafe { from_raw_parts((&D1) as *const _ as _, 1) };
    | ^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC_ID╼ 01 00 00 00                         │ ╾──╼....
            }
@@ -510,7 +510,7 @@ LL | pub static S5: &[u8] = unsafe { from_raw_parts((&D3) as *const _ as _, mem:
    |
    = 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
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC_ID╼ 04 00 00 00                         │ ╾──╼....
            }
@@ -521,7 +521,7 @@ error[E0080]: constructing invalid value at .<deref>[0]: encountered 0x11, but e
 LL | pub static S6: &[bool] = unsafe { from_raw_parts((&D0) as *const _ as _, 4) };
    | ^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC_ID╼ 04 00 00 00                         │ ╾──╼....
            }
@@ -532,7 +532,7 @@ error[E0080]: constructing invalid value at .<deref>[1]: encountered uninitializ
 LL | pub static S7: &[u16] = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC_ID+0x2╼ 04 00 00 00                         │ ╾──╼....
            }
@@ -543,7 +543,7 @@ error[E0080]: constructing invalid value at .<deref>[0]: encountered uninitializ
 LL | pub static R4: &[u8] = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC_ID╼ 01 00 00 00                         │ ╾──╼....
            }
@@ -556,7 +556,7 @@ LL | pub static R5: &[u8] = unsafe {
    |
    = 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
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC_ID╼ 04 00 00 00                         │ ╾──╼....
            }
@@ -567,7 +567,7 @@ error[E0080]: constructing invalid value at .<deref>[0]: encountered 0x11, but e
 LL | pub static R6: &[bool] = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC_ID╼ 04 00 00 00                         │ ╾──╼....
            }
diff --git a/tests/ui/consts/const-eval/raw-bytes.64bit.stderr b/tests/ui/consts/const-eval/raw-bytes.64bit.stderr
index c53326534fdc5..8e6dc66a40ee1 100644
--- a/tests/ui/consts/const-eval/raw-bytes.64bit.stderr
+++ b/tests/ui/consts/const-eval/raw-bytes.64bit.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value at .<enum-tag>: encountered 0x000000000
 LL | const BAD_ENUM: Enum = unsafe { mem::transmute(1usize) };
    | ^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 8) {
                01 00 00 00 00 00 00 00                         │ ........
            }
@@ -15,7 +15,7 @@ error[E0080]: constructing invalid value at .<enum-tag>: encountered 0x000000000
 LL | const BAD_ENUM2: Enum2 = unsafe { mem::transmute(0usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 8) {
                00 00 00 00 00 00 00 00                         │ ........
            }
@@ -26,7 +26,7 @@ error[E0080]: constructing invalid value at .<enum-tag>: encountered an uninhabi
 LL | const BAD_UNINHABITED_VARIANT1: UninhDiscriminant = unsafe { mem::transmute(1u8) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 1, align: 1) {
                01                                              │ .
            }
@@ -37,7 +37,7 @@ error[E0080]: constructing invalid value at .<enum-tag>: encountered an uninhabi
 LL | const BAD_UNINHABITED_VARIANT2: UninhDiscriminant = unsafe { mem::transmute(3u8) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 1, align: 1) {
                03                                              │ .
            }
@@ -48,7 +48,7 @@ error[E0080]: constructing invalid value at .<enum-variant(Some)>.0.1: encounter
 LL | const BAD_OPTION_CHAR: Option<(char, char)> = Some(('x', unsafe { mem::transmute(!0u32) }));
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                78 00 00 00 ff ff ff ff                         │ x.......
            }
@@ -59,7 +59,7 @@ error[E0080]: constructing invalid value: encountered 0, but expected something
 LL | const NULL_PTR: NonNull<u8> = unsafe { mem::transmute(0usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 8) {
                00 00 00 00 00 00 00 00                         │ ........
            }
@@ -70,7 +70,7 @@ error[E0080]: constructing invalid value at .0: encountered 0, but expected some
 LL | const NULL_U8: NonZero<u8> = unsafe { mem::transmute(0u8) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 1, align: 1) {
                00                                              │ .
            }
@@ -81,7 +81,7 @@ error[E0080]: constructing invalid value at .0: encountered 0, but expected some
 LL | const NULL_USIZE: NonZero<usize> = unsafe { mem::transmute(0usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 8) {
                00 00 00 00 00 00 00 00                         │ ........
            }
@@ -92,7 +92,7 @@ error[E0080]: constructing invalid value: encountered 42, but expected something
 LL | const BAD_RANGE1: RestrictedRange1 = unsafe { RestrictedRange1(42) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                2a 00 00 00                                     │ *...
            }
@@ -103,7 +103,7 @@ error[E0080]: constructing invalid value: encountered 20, but expected something
 LL | const BAD_RANGE2: RestrictedRange2 = unsafe { RestrictedRange2(20) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                14 00 00 00                                     │ ....
            }
@@ -114,7 +114,7 @@ error[E0080]: constructing invalid value: encountered 0, but expected something
 LL | const NULL_FAT_PTR: NonNull<dyn Send> = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                00 00 00 00 00 00 00 00 ╾ALLOC_ID╼ │ ........╾──────╼
            }
@@ -125,7 +125,7 @@ error[E0080]: constructing invalid value: encountered an unaligned reference (re
 LL | const UNALIGNED: &u16 = unsafe { mem::transmute(&[0u8; 4]) };
    | ^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 8) {
                ╾ALLOC_ID╼                         │ ╾──────╼
            }
@@ -136,7 +136,7 @@ error[E0080]: constructing invalid value: encountered an unaligned box (required
 LL | const UNALIGNED_BOX: Box<u16> = unsafe { mem::transmute(&[0u8; 4]) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 8) {
                ╾ALLOC_ID╼                         │ ╾──────╼
            }
@@ -147,7 +147,7 @@ error[E0080]: constructing invalid value: encountered a null reference
 LL | const NULL: &u16 = unsafe { mem::transmute(0usize) };
    | ^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 8) {
                00 00 00 00 00 00 00 00                         │ ........
            }
@@ -158,7 +158,7 @@ error[E0080]: constructing invalid value: encountered a null box
 LL | const NULL_BOX: Box<u16> = unsafe { mem::transmute(0usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 8) {
                00 00 00 00 00 00 00 00                         │ ........
            }
@@ -169,7 +169,7 @@ error[E0080]: constructing invalid value: encountered a dangling reference (0x53
 LL | const USIZE_AS_REF: &'static u8 = unsafe { mem::transmute(1337usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 8) {
                39 05 00 00 00 00 00 00                         │ 9.......
            }
@@ -180,7 +180,7 @@ error[E0080]: constructing invalid value: encountered a dangling box (0x539[noal
 LL | const USIZE_AS_BOX: Box<u8> = unsafe { mem::transmute(1337usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 8) {
                39 05 00 00 00 00 00 00                         │ 9.......
            }
@@ -191,7 +191,7 @@ error[E0080]: constructing invalid value: encountered null pointer, but expected
 LL | const NULL_FN_PTR: fn() = unsafe { mem::transmute(0usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 8) {
                00 00 00 00 00 00 00 00                         │ ........
            }
@@ -202,7 +202,7 @@ error[E0080]: constructing invalid value: encountered 0xd[noalloc], but expected
 LL | const DANGLING_FN_PTR: fn() = unsafe { mem::transmute(13usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 8) {
                0d 00 00 00 00 00 00 00                         │ ........
            }
@@ -213,7 +213,7 @@ error[E0080]: constructing invalid value: encountered ALLOC3<imm>, but expected
 LL | const DATA_FN_PTR: fn() = unsafe { mem::transmute(&13) };
    | ^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 8) {
                ╾ALLOC_ID╼                         │ ╾──────╼
            }
@@ -224,7 +224,7 @@ error[E0080]: constructing invalid value: encountered a reference pointing to un
 LL | const BAD_BAD_REF: &Bar = unsafe { mem::transmute(1usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 8) {
                01 00 00 00 00 00 00 00                         │ ........
            }
@@ -235,7 +235,7 @@ error[E0080]: constructing invalid value: encountered a dangling reference (goin
 LL | const STR_TOO_LONG: &str = unsafe { mem::transmute((&42u8, 999usize)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC_ID╼ e7 03 00 00 00 00 00 00 │ ╾──────╼........
            }
@@ -246,7 +246,7 @@ error[E0080]: constructing invalid value at .0: encountered invalid reference me
 LL | const NESTED_STR_MUCH_TOO_LONG: (&str,) = (unsafe { mem::transmute((&42, usize::MAX)) },);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC_ID╼ ff ff ff ff ff ff ff ff │ ╾──────╼........
            }
@@ -257,7 +257,7 @@ error[E0080]: constructing invalid value: encountered invalid reference metadata
 LL | const MY_STR_MUCH_TOO_LONG: &MyStr = unsafe { mem::transmute((&42u8, usize::MAX)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC_ID╼ ff ff ff ff ff ff ff ff │ ╾──────╼........
            }
@@ -268,7 +268,7 @@ error[E0080]: constructing invalid value at .<deref>: encountered uninitialized
 LL | const STR_NO_INIT: &str = unsafe { mem::transmute::<&[_], _>(&[MaybeUninit::<u8> { uninit: () }]) };
    | ^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC_ID╼ 01 00 00 00 00 00 00 00 │ ╾──────╼........
            }
@@ -279,7 +279,7 @@ error[E0080]: constructing invalid value at .<deref>.0: encountered uninitialize
 LL | const MYSTR_NO_INIT: &MyStr = unsafe { mem::transmute::<&[_], _>(&[MaybeUninit::<u8> { uninit: () }]) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC_ID╼ 01 00 00 00 00 00 00 00 │ ╾──────╼........
            }
@@ -292,7 +292,7 @@ LL | const MYSTR_NO_INIT_ISSUE83182: &MyStr = unsafe { mem::transmute::<&[_], _>
    |
    = 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
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC_ID╼ 01 00 00 00 00 00 00 00 │ ╾──────╼........
            }
@@ -303,7 +303,7 @@ error[E0080]: constructing invalid value: encountered a dangling reference (goin
 LL | const SLICE_TOO_LONG: &[u8] = unsafe { mem::transmute((&42u8, 999usize)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC_ID╼ e7 03 00 00 00 00 00 00 │ ╾──────╼........
            }
@@ -314,7 +314,7 @@ error[E0080]: constructing invalid value: encountered invalid reference metadata
 LL | const SLICE_TOO_LONG_OVERFLOW: &[u32] = unsafe { mem::transmute((&42u32, isize::MAX)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC_ID╼ ff ff ff ff ff ff ff 7f │ ╾──────╼........
            }
@@ -325,7 +325,7 @@ error[E0080]: constructing invalid value: encountered a dangling box (going beyo
 LL | const SLICE_TOO_LONG_BOX: Box<[u8]> = unsafe { mem::transmute((&42u8, 999usize)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC_ID╼ e7 03 00 00 00 00 00 00 │ ╾──────╼........
            }
@@ -336,7 +336,7 @@ error[E0080]: constructing invalid value at .<deref>[0]: encountered 0x03, but e
 LL | const SLICE_CONTENT_INVALID: &[bool] = &[unsafe { mem::transmute(3u8) }];
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 8) {
                ╾ALLOC_ID╼                         │ ╾──────╼
            }
@@ -353,7 +353,7 @@ error[E0080]: constructing invalid value at .<deref>.0: encountered 0x03, but ex
 LL | const MYSLICE_PREFIX_BAD: &MySliceBool = &MySlice(unsafe { mem::transmute(3u8) }, [false]);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 8) {
                ╾ALLOC_ID╼                         │ ╾──────╼
            }
@@ -370,7 +370,7 @@ error[E0080]: constructing invalid value at .<deref>.1[0]: encountered 0x03, but
 LL | const MYSLICE_SUFFIX_BAD: &MySliceBool = &MySlice(true, [unsafe { mem::transmute(3u8) }]);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 8) {
                ╾ALLOC_ID╼                         │ ╾──────╼
            }
@@ -387,7 +387,7 @@ error[E0080]: constructing invalid value at .0: encountered ALLOC17<imm>, but ex
 LL | const TRAIT_OBJ_SHORT_VTABLE_1: W<&dyn Trait> = unsafe { mem::transmute(W((&92u8, &3u8))) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC_ID╼ ╾ALLOC_ID╼ │ ╾──────╼╾──────╼
            }
@@ -398,7 +398,7 @@ error[E0080]: constructing invalid value at .0: encountered ALLOC19<imm>, but ex
 LL | const TRAIT_OBJ_SHORT_VTABLE_2: W<&dyn Trait> = unsafe { mem::transmute(W((&92u8, &3u64))) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC_ID╼ ╾ALLOC_ID╼ │ ╾──────╼╾──────╼
            }
@@ -409,7 +409,7 @@ error[E0080]: constructing invalid value at .0: encountered 0x4[noalloc], but ex
 LL | const TRAIT_OBJ_INT_VTABLE: W<&dyn Trait> = unsafe { mem::transmute(W((&92u8, 4usize))) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC_ID╼ 04 00 00 00 00 00 00 00 │ ╾──────╼........
            }
@@ -420,7 +420,7 @@ error[E0080]: constructing invalid value at .0: encountered ALLOC22<imm>, but ex
 LL | const TRAIT_OBJ_BAD_DROP_FN_NOT_FN_PTR: W<&dyn Trait> = unsafe { mem::transmute(W((&92u8, &[&42u8; 8]))) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC_ID╼ ╾ALLOC_ID╼ │ ╾──────╼╾──────╼
            }
@@ -431,7 +431,7 @@ error[E0080]: constructing invalid value at .<deref>.<dyn-downcast>: encountered
 LL | const TRAIT_OBJ_CONTENT_INVALID: &dyn Trait = unsafe { mem::transmute::<_, &bool>(&3u8) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC_ID╼ ╾ALLOC_ID╼ │ ╾──────╼╾──────╼
            }
@@ -442,7 +442,7 @@ error[E0080]: constructing invalid value: encountered null pointer, but expected
 LL | const RAW_TRAIT_OBJ_VTABLE_NULL: *const dyn Trait = unsafe { mem::transmute((&92u8, 0usize)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC_ID╼ 00 00 00 00 00 00 00 00 │ ╾──────╼........
            }
@@ -453,7 +453,7 @@ error[E0080]: constructing invalid value: encountered ALLOC27<imm>, but expected
 LL | const RAW_TRAIT_OBJ_VTABLE_INVALID: *const dyn Trait = unsafe { mem::transmute((&92u8, &3u64)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC_ID╼ ╾ALLOC_ID╼ │ ╾──────╼╾──────╼
            }
@@ -464,7 +464,7 @@ error[E0080]: constructing invalid value: encountered a reference pointing to un
 LL | const _: &[!; 1] = unsafe { &*(1_usize as *const [!; 1]) };
    | ^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 8) {
                01 00 00 00 00 00 00 00                         │ ........
            }
@@ -475,7 +475,7 @@ error[E0080]: constructing invalid value at .<deref>[0]: encountered a value of
 LL | const _: &[!] = unsafe { &*(1_usize as *const [!; 1]) };
    | ^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                01 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00 │ ................
            }
@@ -486,7 +486,7 @@ error[E0080]: constructing invalid value at .<deref>[0]: encountered a value of
 LL | const _: &[!] = unsafe { &*(1_usize as *const [!; 42]) };
    | ^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                01 00 00 00 00 00 00 00 2a 00 00 00 00 00 00 00 │ ........*.......
            }
@@ -497,7 +497,7 @@ error[E0080]: constructing invalid value at .<deref>[0]: encountered uninitializ
 LL | pub static S4: &[u8] = unsafe { from_raw_parts((&D1) as *const _ as _, 1) };
    | ^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC_ID╼ 01 00 00 00 00 00 00 00 │ ╾──────╼........
            }
@@ -510,7 +510,7 @@ LL | pub static S5: &[u8] = unsafe { from_raw_parts((&D3) as *const _ as _, mem:
    |
    = 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
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC_ID╼ 08 00 00 00 00 00 00 00 │ ╾──────╼........
            }
@@ -521,7 +521,7 @@ error[E0080]: constructing invalid value at .<deref>[0]: encountered 0x11, but e
 LL | pub static S6: &[bool] = unsafe { from_raw_parts((&D0) as *const _ as _, 4) };
    | ^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC_ID╼ 04 00 00 00 00 00 00 00 │ ╾──────╼........
            }
@@ -532,7 +532,7 @@ error[E0080]: constructing invalid value at .<deref>[1]: encountered uninitializ
 LL | pub static S7: &[u16] = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC_ID+0x2╼ 04 00 00 00 00 00 00 00 │ ╾──────╼........
            }
@@ -543,7 +543,7 @@ error[E0080]: constructing invalid value at .<deref>[0]: encountered uninitializ
 LL | pub static R4: &[u8] = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC_ID╼ 01 00 00 00 00 00 00 00 │ ╾──────╼........
            }
@@ -556,7 +556,7 @@ LL | pub static R5: &[u8] = unsafe {
    |
    = 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
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC_ID╼ 08 00 00 00 00 00 00 00 │ ╾──────╼........
            }
@@ -567,7 +567,7 @@ error[E0080]: constructing invalid value at .<deref>[0]: encountered 0x11, but e
 LL | pub static R6: &[bool] = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC_ID╼ 04 00 00 00 00 00 00 00 │ ╾──────╼........
            }
diff --git a/tests/ui/consts/const-eval/transmute-const.stderr b/tests/ui/consts/const-eval/transmute-const.stderr
index ed3b3df70dd5d..53665c176a762 100644
--- a/tests/ui/consts/const-eval/transmute-const.stderr
+++ b/tests/ui/consts/const-eval/transmute-const.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value: encountered 0x03, but expected a boole
 LL | static FOO: bool = unsafe { mem::transmute(3u8) };
    | ^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 1, align: 1) {
                03                                              │ .
            }
diff --git a/tests/ui/consts/const-eval/ub-enum.stderr b/tests/ui/consts/const-eval/ub-enum.stderr
index 5cbd6176c92d1..1efd93832291e 100644
--- a/tests/ui/consts/const-eval/ub-enum.stderr
+++ b/tests/ui/consts/const-eval/ub-enum.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value at .<enum-tag>: encountered 0x01, but e
 LL | const BAD_ENUM: Enum = unsafe { mem::transmute(1usize) };
    | ^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -33,7 +33,7 @@ error[E0080]: constructing invalid value at .<enum-tag>: encountered 0x0, but ex
 LL | const BAD_ENUM2: Enum2 = unsafe { mem::transmute(0usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -81,7 +81,7 @@ error[E0080]: constructing invalid value at .<enum-tag>: encountered an uninhabi
 LL | const BAD_UNINHABITED_VARIANT1: UninhDiscriminant = unsafe { mem::transmute(1u8) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -92,7 +92,7 @@ error[E0080]: constructing invalid value at .<enum-tag>: encountered an uninhabi
 LL | const BAD_UNINHABITED_VARIANT2: UninhDiscriminant = unsafe { mem::transmute(3u8) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -103,7 +103,7 @@ error[E0080]: constructing invalid value at .<enum-variant(Some)>.0.1: encounter
 LL | const BAD_OPTION_CHAR: Option<(char, char)> = Some(('x', unsafe { mem::transmute(!0u32) }));
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
diff --git a/tests/ui/consts/const-eval/ub-incorrect-vtable.32bit.stderr b/tests/ui/consts/const-eval/ub-incorrect-vtable.32bit.stderr
index 86d6f8c52bc70..1e4d425d78ec6 100644
--- a/tests/ui/consts/const-eval/ub-incorrect-vtable.32bit.stderr
+++ b/tests/ui/consts/const-eval/ub-incorrect-vtable.32bit.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value: encountered ALLOC1<imm>, but expected
 LL | const INVALID_VTABLE_ALIGNMENT: &dyn Trait =
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC0<imm>╼ ╾ALLOC1<imm>╼                         │ ╾──╼╾──╼
            }
@@ -15,7 +15,7 @@ error[E0080]: constructing invalid value: encountered ALLOC3<imm>, but expected
 LL | const INVALID_VTABLE_SIZE: &dyn Trait =
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC2<imm>╼ ╾ALLOC3<imm>╼                         │ ╾──╼╾──╼
            }
@@ -26,7 +26,7 @@ error[E0080]: constructing invalid value at .0: encountered ALLOC5<imm>, but exp
 LL | const INVALID_VTABLE_ALIGNMENT_UB: W<&dyn Trait> =
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC4<imm>╼ ╾ALLOC5<imm>╼                         │ ╾──╼╾──╼
            }
@@ -37,7 +37,7 @@ error[E0080]: constructing invalid value at .0: encountered ALLOC7<imm>, but exp
 LL | const INVALID_VTABLE_SIZE_UB: W<&dyn Trait> =
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC6<imm>╼ ╾ALLOC7<imm>╼                         │ ╾──╼╾──╼
            }
@@ -48,7 +48,7 @@ error[E0080]: constructing invalid value at .0: encountered ALLOC9<imm>, but exp
 LL | const INVALID_VTABLE_UB: W<&dyn Trait> =
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC8<imm>╼ ╾ALLOC9<imm>╼                         │ ╾──╼╾──╼
            }
@@ -59,7 +59,7 @@ error[E0080]: constructing invalid value at .1: encountered a dangling reference
 LL | const G: Wide = unsafe { Transmute { t: FOO }.u };
    | ^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC10<imm>╼ ╾ALLOC11╼                         │ ╾──╼╾──╼
            }
diff --git a/tests/ui/consts/const-eval/ub-incorrect-vtable.64bit.stderr b/tests/ui/consts/const-eval/ub-incorrect-vtable.64bit.stderr
index a9518216dbdb7..a068991f3242d 100644
--- a/tests/ui/consts/const-eval/ub-incorrect-vtable.64bit.stderr
+++ b/tests/ui/consts/const-eval/ub-incorrect-vtable.64bit.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value: encountered ALLOC1<imm>, but expected
 LL | const INVALID_VTABLE_ALIGNMENT: &dyn Trait =
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC0<imm>╼ ╾ALLOC1<imm>╼ │ ╾──────╼╾──────╼
            }
@@ -15,7 +15,7 @@ error[E0080]: constructing invalid value: encountered ALLOC3<imm>, but expected
 LL | const INVALID_VTABLE_SIZE: &dyn Trait =
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC2<imm>╼ ╾ALLOC3<imm>╼ │ ╾──────╼╾──────╼
            }
@@ -26,7 +26,7 @@ error[E0080]: constructing invalid value at .0: encountered ALLOC5<imm>, but exp
 LL | const INVALID_VTABLE_ALIGNMENT_UB: W<&dyn Trait> =
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC4<imm>╼ ╾ALLOC5<imm>╼ │ ╾──────╼╾──────╼
            }
@@ -37,7 +37,7 @@ error[E0080]: constructing invalid value at .0: encountered ALLOC7<imm>, but exp
 LL | const INVALID_VTABLE_SIZE_UB: W<&dyn Trait> =
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC6<imm>╼ ╾ALLOC7<imm>╼ │ ╾──────╼╾──────╼
            }
@@ -48,7 +48,7 @@ error[E0080]: constructing invalid value at .0: encountered ALLOC9<imm>, but exp
 LL | const INVALID_VTABLE_UB: W<&dyn Trait> =
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC8<imm>╼ ╾ALLOC9<imm>╼ │ ╾──────╼╾──────╼
            }
@@ -59,7 +59,7 @@ error[E0080]: constructing invalid value at .1: encountered a dangling reference
 LL | const G: Wide = unsafe { Transmute { t: FOO }.u };
    | ^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC10<imm>╼ ╾ALLOC11╼ │ ╾──────╼╾──────╼
            }
diff --git a/tests/ui/consts/const-eval/ub-int-array.stderr b/tests/ui/consts/const-eval/ub-int-array.stderr
index 10eb7c46c928c..065bfd2c304ad 100644
--- a/tests/ui/consts/const-eval/ub-int-array.stderr
+++ b/tests/ui/consts/const-eval/ub-int-array.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value at [0]: encountered uninitialized memor
 LL | const UNINIT_INT_0: [u32; 3] = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 12, align: 4) {
                __ __ __ __ 11 11 11 11 22 22 22 22             │ ░░░░....""""
            }
@@ -15,7 +15,7 @@ error[E0080]: constructing invalid value at [1]: encountered uninitialized memor
 LL | const UNINIT_INT_1: [u32; 3] = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 12, align: 4) {
                00 00 00 00 01 __ 01 01 02 02 __ 02             │ .....░....░.
            }
@@ -26,7 +26,7 @@ error[E0080]: constructing invalid value at [2]: encountered uninitialized memor
 LL | const UNINIT_INT_2: [u32; 3] = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 12, align: 4) {
                00 00 00 00 01 01 01 01 02 02 02 __             │ ...........░
            }
diff --git a/tests/ui/consts/const-eval/ub-nonnull.stderr b/tests/ui/consts/const-eval/ub-nonnull.stderr
index 19ae66cf3c633..91c82efbc5ed1 100644
--- a/tests/ui/consts/const-eval/ub-nonnull.stderr
+++ b/tests/ui/consts/const-eval/ub-nonnull.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value: encountered 0, but expected something
 LL | const NULL_PTR: NonNull<u8> = unsafe { mem::transmute(0usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -21,7 +21,7 @@ error[E0080]: constructing invalid value at .0: encountered 0, but expected some
 LL | const NULL_U8: NonZero<u8> = unsafe { mem::transmute(0u8) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -32,7 +32,7 @@ error[E0080]: constructing invalid value at .0: encountered 0, but expected some
 LL | const NULL_USIZE: NonZero<usize> = unsafe { mem::transmute(0usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -53,7 +53,7 @@ error[E0080]: constructing invalid value: encountered 42, but expected something
 LL | const BAD_RANGE1: RestrictedRange1 = unsafe { RestrictedRange1(42) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -64,7 +64,7 @@ error[E0080]: constructing invalid value: encountered 20, but expected something
 LL | const BAD_RANGE2: RestrictedRange2 = unsafe { RestrictedRange2(20) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -75,7 +75,7 @@ error[E0080]: constructing invalid value: encountered 0, but expected something
 LL | const NULL_FAT_PTR: NonNull<dyn Send> = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
diff --git a/tests/ui/consts/const-eval/ub-ref-ptr.stderr b/tests/ui/consts/const-eval/ub-ref-ptr.stderr
index 451ebb6eba1a6..c45f66c29259c 100644
--- a/tests/ui/consts/const-eval/ub-ref-ptr.stderr
+++ b/tests/ui/consts/const-eval/ub-ref-ptr.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value: encountered an unaligned reference (re
 LL | const UNALIGNED: &u16 = unsafe { mem::transmute(&[0u8; 4]) };
    | ^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -15,7 +15,7 @@ error[E0080]: constructing invalid value: encountered an unaligned box (required
 LL | const UNALIGNED_BOX: Box<u16> = unsafe { mem::transmute(&[0u8; 4]) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -26,7 +26,7 @@ error[E0080]: constructing invalid value: encountered a null reference
 LL | const NULL: &u16 = unsafe { mem::transmute(0usize) };
    | ^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -37,7 +37,7 @@ error[E0080]: constructing invalid value: encountered a null box
 LL | const NULL_BOX: Box<u16> = unsafe { mem::transmute(0usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -87,7 +87,7 @@ error[E0080]: constructing invalid value: encountered a dangling reference (0x53
 LL | const USIZE_AS_REF: &'static u8 = unsafe { mem::transmute(1337usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -98,7 +98,7 @@ error[E0080]: constructing invalid value: encountered a dangling box (0x539[noal
 LL | const USIZE_AS_BOX: Box<u8> = unsafe { mem::transmute(1337usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -119,7 +119,7 @@ error[E0080]: constructing invalid value: encountered null pointer, but expected
 LL | const NULL_FN_PTR: fn() = unsafe { mem::transmute(0usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -140,7 +140,7 @@ error[E0080]: constructing invalid value: encountered 0xd[noalloc], but expected
 LL | const DANGLING_FN_PTR: fn() = unsafe { mem::transmute(13usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -151,7 +151,7 @@ error[E0080]: constructing invalid value: encountered ALLOC2<imm>, but expected
 LL | const DATA_FN_PTR: fn() = unsafe { mem::transmute(&13) };
    | ^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
diff --git a/tests/ui/consts/const-eval/ub-uninhabit.stderr b/tests/ui/consts/const-eval/ub-uninhabit.stderr
index b0f475fe93867..aca0b13bb9070 100644
--- a/tests/ui/consts/const-eval/ub-uninhabit.stderr
+++ b/tests/ui/consts/const-eval/ub-uninhabit.stderr
@@ -10,7 +10,7 @@ error[E0080]: constructing invalid value: encountered a reference pointing to un
 LL | const BAD_BAD_REF: &Bar = unsafe { mem::transmute(1usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
diff --git a/tests/ui/consts/const-eval/ub-upvars.32bit.stderr b/tests/ui/consts/const-eval/ub-upvars.32bit.stderr
index ecd1c768c287f..b434970b67757 100644
--- a/tests/ui/consts/const-eval/ub-upvars.32bit.stderr
+++ b/tests/ui/consts/const-eval/ub-upvars.32bit.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value at .<deref>.<dyn-downcast>.<captured-va
 LL | const BAD_UPVAR: &dyn FnOnce() = &{
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC0<imm>╼ ╾ALLOC1╼                         │ ╾──╼╾──╼
            }
diff --git a/tests/ui/consts/const-eval/ub-upvars.64bit.stderr b/tests/ui/consts/const-eval/ub-upvars.64bit.stderr
index 108dfe6b27be3..de1e1f8a2bea6 100644
--- a/tests/ui/consts/const-eval/ub-upvars.64bit.stderr
+++ b/tests/ui/consts/const-eval/ub-upvars.64bit.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value at .<deref>.<dyn-downcast>.<captured-va
 LL | const BAD_UPVAR: &dyn FnOnce() = &{
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC0<imm>╼ ╾ALLOC1╼ │ ╾──────╼╾──────╼
            }
diff --git a/tests/ui/consts/const-eval/ub-wide-ptr.stderr b/tests/ui/consts/const-eval/ub-wide-ptr.stderr
index ab15ba826a5fe..c505e5cc8a244 100644
--- a/tests/ui/consts/const-eval/ub-wide-ptr.stderr
+++ b/tests/ui/consts/const-eval/ub-wide-ptr.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value: encountered a dangling reference (goin
 LL | const STR_TOO_LONG: &str = unsafe { mem::transmute((&42u8, 999usize)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -15,7 +15,7 @@ error[E0080]: constructing invalid value at .0: encountered invalid reference me
 LL | const NESTED_STR_MUCH_TOO_LONG: (&str,) = (unsafe { mem::transmute((&42, usize::MAX)) },);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -44,7 +44,7 @@ error[E0080]: constructing invalid value: encountered invalid reference metadata
 LL | const MY_STR_MUCH_TOO_LONG: &MyStr = unsafe { mem::transmute((&42u8, usize::MAX)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -55,7 +55,7 @@ error[E0080]: constructing invalid value at .<deref>: encountered uninitialized
 LL | const STR_NO_INIT: &str = unsafe { mem::transmute::<&[_], _>(&[MaybeUninit::<u8> { uninit: () }]) };
    | ^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -66,7 +66,7 @@ error[E0080]: constructing invalid value at .<deref>.0: encountered uninitialize
 LL | const MYSTR_NO_INIT: &MyStr = unsafe { mem::transmute::<&[_], _>(&[MaybeUninit::<u8> { uninit: () }]) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -87,7 +87,7 @@ error[E0080]: constructing invalid value: encountered a dangling reference (goin
 LL | const SLICE_TOO_LONG: &[u8] = unsafe { mem::transmute((&42u8, 999usize)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -98,7 +98,7 @@ error[E0080]: constructing invalid value: encountered invalid reference metadata
 LL | const SLICE_TOO_LONG_OVERFLOW: &[u32] = unsafe { mem::transmute((&42u32, isize::MAX)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -118,7 +118,7 @@ error[E0080]: constructing invalid value: encountered a dangling box (going beyo
 LL | const SLICE_TOO_LONG_BOX: Box<[u8]> = unsafe { mem::transmute((&42u8, 999usize)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -138,7 +138,7 @@ error[E0080]: constructing invalid value at .<deref>[0]: encountered 0x03, but e
 LL | const SLICE_CONTENT_INVALID: &[bool] = &[unsafe { mem::transmute(3u8) }];
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -155,7 +155,7 @@ error[E0080]: constructing invalid value at .<deref>.0: encountered 0x03, but ex
 LL | const MYSLICE_PREFIX_BAD: &MySliceBool = &MySlice(unsafe { mem::transmute(3u8) }, [false]);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -172,7 +172,7 @@ error[E0080]: constructing invalid value at .<deref>.1[0]: encountered 0x03, but
 LL | const MYSLICE_SUFFIX_BAD: &MySliceBool = &MySlice(true, [unsafe { mem::transmute(3u8) }]);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -199,7 +199,7 @@ error[E0080]: constructing invalid value at .0: encountered ALLOC12<imm>, but ex
 LL | const TRAIT_OBJ_SHORT_VTABLE_1: W<&dyn Trait> = unsafe { mem::transmute(W((&92u8, &3u8))) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -210,7 +210,7 @@ error[E0080]: constructing invalid value at .0: encountered ALLOC14<imm>, but ex
 LL | const TRAIT_OBJ_SHORT_VTABLE_2: W<&dyn Trait> = unsafe { mem::transmute(W((&92u8, &3u64))) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -221,7 +221,7 @@ error[E0080]: constructing invalid value at .0: encountered 0x4[noalloc], but ex
 LL | const TRAIT_OBJ_INT_VTABLE: W<&dyn Trait> = unsafe { mem::transmute(W((&92u8, 4usize))) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -232,7 +232,7 @@ error[E0080]: constructing invalid value: encountered ALLOC17<imm>, but expected
 LL | const TRAIT_OBJ_UNALIGNED_VTABLE: &dyn Trait = unsafe { mem::transmute((&92u8, &[0u8; 128])) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -243,7 +243,7 @@ error[E0080]: constructing invalid value: encountered ALLOC19<imm>, but expected
 LL | const TRAIT_OBJ_BAD_DROP_FN_NULL: &dyn Trait = unsafe { mem::transmute((&92u8, &[0usize; 8])) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -254,7 +254,7 @@ error[E0080]: constructing invalid value: encountered ALLOC21<imm>, but expected
 LL | const TRAIT_OBJ_BAD_DROP_FN_INT: &dyn Trait = unsafe { mem::transmute((&92u8, &[1usize; 8])) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -265,7 +265,7 @@ error[E0080]: constructing invalid value at .0: encountered ALLOC23<imm>, but ex
 LL | const TRAIT_OBJ_BAD_DROP_FN_NOT_FN_PTR: W<&dyn Trait> = unsafe { mem::transmute(W((&92u8, &[&42u8; 8]))) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -276,7 +276,7 @@ error[E0080]: constructing invalid value at .<deref>.<dyn-downcast>: encountered
 LL | const TRAIT_OBJ_CONTENT_INVALID: &dyn Trait = unsafe { mem::transmute::<_, &bool>(&3u8) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -287,7 +287,7 @@ error[E0080]: constructing invalid value: encountered null pointer, but expected
 LL | const RAW_TRAIT_OBJ_VTABLE_NULL: *const dyn Trait = unsafe { mem::transmute((&92u8, 0usize)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -298,7 +298,7 @@ error[E0080]: constructing invalid value: encountered ALLOC28<imm>, but expected
 LL | const RAW_TRAIT_OBJ_VTABLE_INVALID: *const dyn Trait = unsafe { mem::transmute((&92u8, &3u64)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -309,7 +309,7 @@ error[E0080]: constructing invalid value: encountered null pointer, but expected
 LL | static mut RAW_TRAIT_OBJ_VTABLE_NULL_THROUGH_REF: *const dyn Trait = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -320,7 +320,7 @@ error[E0080]: constructing invalid value: encountered ALLOC31<imm>, but expected
 LL | static mut RAW_TRAIT_OBJ_VTABLE_INVALID_THROUGH_REF: *const dyn Trait = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
diff --git a/tests/ui/consts/const-eval/union-ub.32bit.stderr b/tests/ui/consts/const-eval/union-ub.32bit.stderr
index 757bcea91c3ca..fb2311b9921d8 100644
--- a/tests/ui/consts/const-eval/union-ub.32bit.stderr
+++ b/tests/ui/consts/const-eval/union-ub.32bit.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value: encountered 0x2a, but expected a boole
 LL | const BAD_BOOL: bool = unsafe { DummyUnion { u8: 42 }.bool };
    | ^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 1, align: 1) {
                2a                                              │ *
            }
diff --git a/tests/ui/consts/const-eval/union-ub.64bit.stderr b/tests/ui/consts/const-eval/union-ub.64bit.stderr
index 757bcea91c3ca..fb2311b9921d8 100644
--- a/tests/ui/consts/const-eval/union-ub.64bit.stderr
+++ b/tests/ui/consts/const-eval/union-ub.64bit.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value: encountered 0x2a, but expected a boole
 LL | const BAD_BOOL: bool = unsafe { DummyUnion { u8: 42 }.bool };
    | ^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 1, align: 1) {
                2a                                              │ *
            }
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 16dee44d8006f..08656776468f1 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
@@ -34,7 +34,7 @@ error[E0080]: constructing invalid value: encountered mutable reference or box p
 LL | const IMMUT_MUT_REF: &mut u16 = unsafe { mem::transmute(&13) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -45,7 +45,7 @@ error[E0080]: constructing invalid value: encountered mutable reference or box p
 LL | static IMMUT_MUT_REF_STATIC: &mut u16 = unsafe { mem::transmute(&13) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
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 302e342bce61a..96263998ad42c 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
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value at .<enum-variant(Some)>.0: encountered
 LL | const MUT: Option<&mut i32> = helper();
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -15,7 +15,7 @@ error[E0080]: constructing invalid value at .<enum-variant(Some)>.0: encountered
 LL | const INT2PTR: Option<&mut i32> = helper_int2ptr();
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -26,7 +26,7 @@ error[E0080]: constructing invalid value at .<enum-variant(Some)>.0: encountered
 LL | static INT2PTR_STATIC: Option<&mut i32> = helper_int2ptr();
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -37,7 +37,7 @@ error[E0080]: constructing invalid value at .<enum-variant(Some)>.0: encountered
 LL | const DANGLING: Option<&mut i32> = helper_dangling();
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -48,7 +48,7 @@ error[E0080]: constructing invalid value at .<enum-variant(Some)>.0: encountered
 LL | static DANGLING_STATIC: Option<&mut i32> = helper_dangling();
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
diff --git a/tests/ui/consts/const_refs_to_static_fail_invalid.stderr b/tests/ui/consts/const_refs_to_static_fail_invalid.stderr
index 8be8b4bc50f50..f9088c318a621 100644
--- a/tests/ui/consts/const_refs_to_static_fail_invalid.stderr
+++ b/tests/ui/consts/const_refs_to_static_fail_invalid.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value at .<deref>: encountered 0x0a, but expe
 LL |     const C: &bool = unsafe { std::mem::transmute(&S) };
    |     ^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
diff --git a/tests/ui/consts/dangling-alloc-id-ice.stderr b/tests/ui/consts/dangling-alloc-id-ice.stderr
index 65a46b62daed8..4b034c81a61dc 100644
--- a/tests/ui/consts/dangling-alloc-id-ice.stderr
+++ b/tests/ui/consts/dangling-alloc-id-ice.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value: encountered a dangling reference (use-
 LL | const FOO: &() = {
    | ^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
diff --git a/tests/ui/consts/dangling-zst-ice-issue-126393.stderr b/tests/ui/consts/dangling-zst-ice-issue-126393.stderr
index 2f600e494c46c..248db694d5250 100644
--- a/tests/ui/consts/dangling-zst-ice-issue-126393.stderr
+++ b/tests/ui/consts/dangling-zst-ice-issue-126393.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value: encountered a dangling reference (use-
 LL | pub static MAGIC_FFI_REF: &'static Wrapper = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
diff --git a/tests/ui/consts/interior-mut-const-via-union.32bit.stderr b/tests/ui/consts/interior-mut-const-via-union.32bit.stderr
index 47bb2e5e879b2..17b32383912a2 100644
--- a/tests/ui/consts/interior-mut-const-via-union.32bit.stderr
+++ b/tests/ui/consts/interior-mut-const-via-union.32bit.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value at .<deref>.y.<enum-variant(B)>.0: enco
 LL | fn main() {
    | ^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                ╾ALLOC0╼                                     │ ╾──╼
            }
diff --git a/tests/ui/consts/interior-mut-const-via-union.64bit.stderr b/tests/ui/consts/interior-mut-const-via-union.64bit.stderr
index b4c9a4bd47e27..c4f78e7bf9eab 100644
--- a/tests/ui/consts/interior-mut-const-via-union.64bit.stderr
+++ b/tests/ui/consts/interior-mut-const-via-union.64bit.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value at .<deref>.y.<enum-variant(B)>.0: enco
 LL | fn main() {
    | ^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 8) {
                ╾ALLOC0╼                         │ ╾──────╼
            }
diff --git a/tests/ui/consts/issue-17718-const-bad-values.stderr b/tests/ui/consts/issue-17718-const-bad-values.stderr
index 68d1a72b71e62..2c54200c8a2f2 100644
--- a/tests/ui/consts/issue-17718-const-bad-values.stderr
+++ b/tests/ui/consts/issue-17718-const-bad-values.stderr
@@ -14,7 +14,7 @@ error[E0080]: constructing invalid value: encountered mutable reference in `cons
 LL | const C2: &'static mut i32 = unsafe { &mut S };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $PTR, align: $PTR) {
                HEX_DUMP
            }
diff --git a/tests/ui/consts/issue-63952.32bit.stderr b/tests/ui/consts/issue-63952.32bit.stderr
index e53407881671a..cf97ed6e48744 100644
--- a/tests/ui/consts/issue-63952.32bit.stderr
+++ b/tests/ui/consts/issue-63952.32bit.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value: encountered invalid reference metadata
 LL | const SLICE_WAY_TOO_LONG: &[u8] = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                ╾ALLOC0<imm>╼ ff ff ff ff                         │ ╾──╼....
            }
diff --git a/tests/ui/consts/issue-63952.64bit.stderr b/tests/ui/consts/issue-63952.64bit.stderr
index 27e74833fc569..4cea967314c06 100644
--- a/tests/ui/consts/issue-63952.64bit.stderr
+++ b/tests/ui/consts/issue-63952.64bit.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value: encountered invalid reference metadata
 LL | const SLICE_WAY_TOO_LONG: &[u8] = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC0<imm>╼ ff ff ff ff ff ff ff ff │ ╾──────╼........
            }
diff --git a/tests/ui/consts/issue-79690.64bit.stderr b/tests/ui/consts/issue-79690.64bit.stderr
index 7488f7b7752a6..2653ff22f1205 100644
--- a/tests/ui/consts/issue-79690.64bit.stderr
+++ b/tests/ui/consts/issue-79690.64bit.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value at .1: encountered a dangling reference
 LL | const G: Fat = unsafe { Transmute { t: FOO }.u };
    | ^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 16, align: 8) {
                ╾ALLOC0<imm>╼ ╾ALLOC1╼ │ ╾──────╼╾──────╼
            }
diff --git a/tests/ui/consts/miri_unleashed/mutable_references.stderr b/tests/ui/consts/miri_unleashed/mutable_references.stderr
index 137efde44b312..b35076b669e29 100644
--- a/tests/ui/consts/miri_unleashed/mutable_references.stderr
+++ b/tests/ui/consts/miri_unleashed/mutable_references.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value at .<deref>: encountered mutable refere
 LL | static FOO: &&mut u32 = &&mut 42;
    | ^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -15,7 +15,7 @@ error[E0080]: constructing invalid value: encountered mutable reference or box p
 LL | static OH_YES: &mut i32 = &mut 42;
    | ^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -38,7 +38,7 @@ error[E0080]: constructing invalid value: encountered mutable reference or box p
 LL | const BLUNT: &mut i32 = &mut 42;
    | ^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -49,7 +49,7 @@ error[E0080]: constructing invalid value: encountered mutable reference in `cons
 LL | const SUBTLE: &mut i32 = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -60,7 +60,7 @@ error[E0080]: constructing invalid value at .x.<deref>: encountered `UnsafeCell`
 LL | static MEH: Meh = Meh { x: &UnsafeCell::new(42) };
    | ^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -71,7 +71,7 @@ error[E0080]: constructing invalid value at .x.<deref>: encountered `UnsafeCell`
 LL | const MUH: Meh = Meh {
    | ^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -82,7 +82,7 @@ error[E0080]: constructing invalid value at .<deref>.<dyn-downcast>.x: encounter
 LL | const SNEAKY: &dyn Sync = &Synced { x: UnsafeCell::new(42) };
    | ^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -93,7 +93,7 @@ error[E0080]: constructing invalid value: encountered mutable reference or box p
 LL | static mut MUT_TO_READONLY: &mut i32 = unsafe { &mut *(&READONLY as *const _ as *mut _) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
diff --git a/tests/ui/consts/miri_unleashed/static-no-inner-mut.32bit.stderr b/tests/ui/consts/miri_unleashed/static-no-inner-mut.32bit.stderr
index 1ef20689985c1..d7c668a98121f 100644
--- a/tests/ui/consts/miri_unleashed/static-no-inner-mut.32bit.stderr
+++ b/tests/ui/consts/miri_unleashed/static-no-inner-mut.32bit.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value at .<deref>.v: encountered `UnsafeCell`
 LL | static REF: &AtomicI32 = &AtomicI32::new(42);
    | ^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                ╾ALLOC0╼                                     │ ╾──╼
            }
@@ -15,7 +15,7 @@ error[E0080]: constructing invalid value: encountered mutable reference or box p
 LL | static REFMUT: &mut i32 = &mut 0;
    | ^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                ╾ALLOC1╼                                     │ ╾──╼
            }
@@ -26,7 +26,7 @@ error[E0080]: constructing invalid value at .<deref>.v: encountered `UnsafeCell`
 LL | static REF2: &AtomicI32 = {let x = AtomicI32::new(42); &{x}};
    | ^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                ╾ALLOC2╼                                     │ ╾──╼
            }
@@ -37,7 +37,7 @@ error[E0080]: constructing invalid value: encountered mutable reference or box p
 LL | static REFMUT2: &mut i32 = {let mut x = 0; &mut {x}};
    | ^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                ╾ALLOC3╼                                     │ ╾──╼
            }
diff --git a/tests/ui/consts/miri_unleashed/static-no-inner-mut.64bit.stderr b/tests/ui/consts/miri_unleashed/static-no-inner-mut.64bit.stderr
index 06f78e679b190..f3bb49900b59e 100644
--- a/tests/ui/consts/miri_unleashed/static-no-inner-mut.64bit.stderr
+++ b/tests/ui/consts/miri_unleashed/static-no-inner-mut.64bit.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value at .<deref>.v: encountered `UnsafeCell`
 LL | static REF: &AtomicI32 = &AtomicI32::new(42);
    | ^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 8) {
                ╾ALLOC0╼                         │ ╾──────╼
            }
@@ -15,7 +15,7 @@ error[E0080]: constructing invalid value: encountered mutable reference or box p
 LL | static REFMUT: &mut i32 = &mut 0;
    | ^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 8) {
                ╾ALLOC1╼                         │ ╾──────╼
            }
@@ -26,7 +26,7 @@ error[E0080]: constructing invalid value at .<deref>.v: encountered `UnsafeCell`
 LL | static REF2: &AtomicI32 = {let x = AtomicI32::new(42); &{x}};
    | ^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 8) {
                ╾ALLOC2╼                         │ ╾──────╼
            }
@@ -37,7 +37,7 @@ error[E0080]: constructing invalid value: encountered mutable reference or box p
 LL | static REFMUT2: &mut i32 = {let mut x = 0; &mut {x}};
    | ^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 8) {
                ╾ALLOC3╼                         │ ╾──────╼
            }
diff --git a/tests/ui/consts/validate_never_arrays.stderr b/tests/ui/consts/validate_never_arrays.stderr
index 0f503df406093..3c405e8d3cd0f 100644
--- a/tests/ui/consts/validate_never_arrays.stderr
+++ b/tests/ui/consts/validate_never_arrays.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value: encountered a reference pointing to un
 LL | const _: &[!; 1] = unsafe { &*(1_usize as *const [!; 1]) };
    | ^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -15,7 +15,7 @@ error[E0080]: constructing invalid value at .<deref>[0]: encountered a value of
 LL | const _: &[!] = unsafe { &*(1_usize as *const [!; 1]) };
    | ^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
@@ -26,7 +26,7 @@ error[E0080]: constructing invalid value at .<deref>[0]: encountered a value of
 LL | const _: &[!] = unsafe { &*(1_usize as *const [!; 42]) };
    | ^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
diff --git a/tests/ui/linkage-attr/raw-dylib/windows/invalid-dlltool.rs b/tests/ui/linkage-attr/raw-dylib/windows/invalid-dlltool.rs
index 0c78d799bad2d..f5f92db3b501a 100644
--- a/tests/ui/linkage-attr/raw-dylib/windows/invalid-dlltool.rs
+++ b/tests/ui/linkage-attr/raw-dylib/windows/invalid-dlltool.rs
@@ -11,4 +11,4 @@ pub fn lib_main() {
     unsafe { f(42); }
 }
 
-//~? ERROR Error calling dlltool 'does_not_exist.exe': program not found
+//~? ERROR error calling dlltool 'does_not_exist.exe': program not found
diff --git a/tests/ui/linkage-attr/raw-dylib/windows/invalid-dlltool.stderr b/tests/ui/linkage-attr/raw-dylib/windows/invalid-dlltool.stderr
index 4bbad9b30a79a..311d8c61589a4 100644
--- a/tests/ui/linkage-attr/raw-dylib/windows/invalid-dlltool.stderr
+++ b/tests/ui/linkage-attr/raw-dylib/windows/invalid-dlltool.stderr
@@ -1,4 +1,4 @@
-error: Error calling dlltool 'does_not_exist.exe': program not found
+error: error calling dlltool 'does_not_exist.exe': program not found
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/pattern/at-in-struct-patterns.rs b/tests/ui/pattern/at-in-struct-patterns.rs
index e8fad61f31784..b0557220d05a4 100644
--- a/tests/ui/pattern/at-in-struct-patterns.rs
+++ b/tests/ui/pattern/at-in-struct-patterns.rs
@@ -5,7 +5,7 @@ struct Foo {
 
 fn main() {
     let foo = Foo { field1: 1, field2: 2 };
-    let Foo { var @ field1, .. } = foo; //~ ERROR Unexpected `@` in struct pattern
+    let Foo { var @ field1, .. } = foo; //~ ERROR unexpected `@` in struct pattern
     dbg!(var); //~ ERROR cannot find value `var` in this scope
     let Foo { field1: _, bar @ .. } = foo; //~ ERROR `@ ..` is not supported in struct patterns
     let Foo { bar @ .. } = foo; //~ ERROR `@ ..` is not supported in struct patterns
diff --git a/tests/ui/pattern/at-in-struct-patterns.stderr b/tests/ui/pattern/at-in-struct-patterns.stderr
index ff75edfe6811f..20832897ca5ef 100644
--- a/tests/ui/pattern/at-in-struct-patterns.stderr
+++ b/tests/ui/pattern/at-in-struct-patterns.stderr
@@ -1,4 +1,4 @@
-error: Unexpected `@` in struct pattern
+error: unexpected `@` in struct pattern
   --> $DIR/at-in-struct-patterns.rs:8:15
    |
 LL |     let Foo { var @ field1, .. } = foo;
diff --git a/tests/ui/statics/mutable_memory_validation.stderr b/tests/ui/statics/mutable_memory_validation.stderr
index df36287cc69e6..1d6ba195fa283 100644
--- a/tests/ui/statics/mutable_memory_validation.stderr
+++ b/tests/ui/statics/mutable_memory_validation.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value at .x.<deref>: encountered `UnsafeCell`
 LL | const MUH: Meh = Meh { x: unsafe { &mut *(&READONLY as *const _ as *mut _) } };
    | ^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
                HEX_DUMP
            }
diff --git a/tests/ui/type/pattern_types/validity.stderr b/tests/ui/type/pattern_types/validity.stderr
index b545cd75ddb57..e19915a58a322 100644
--- a/tests/ui/type/pattern_types/validity.stderr
+++ b/tests/ui/type/pattern_types/validity.stderr
@@ -4,7 +4,7 @@ error[E0080]: constructing invalid value: encountered 0, but expected something
 LL | const BAD: pattern_type!(u32 is 1..) = unsafe { std::mem::transmute(0) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                HEX_DUMP
            }
@@ -34,7 +34,7 @@ error[E0080]: constructing invalid value at .0: encountered 0, but expected some
 LL | const BAD_AGGREGATE: (pattern_type!(u32 is 1..), u32) = (unsafe { std::mem::transmute(0) }, 0);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 4) {
                HEX_DUMP
            }
@@ -45,7 +45,7 @@ error[E0080]: constructing invalid value at .0.0: encountered 0, but expected so
 LL | const BAD_FOO: Foo = Foo(Bar(unsafe { std::mem::transmute(0) }));
    | ^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                HEX_DUMP
            }
@@ -66,7 +66,7 @@ error[E0080]: constructing invalid value: encountered 97, but expected something
 LL | const CHAR_OOB_PAT: pattern_type!(char is 'A'..'Z') = unsafe { std::mem::transmute('a') };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                HEX_DUMP
            }
@@ -77,7 +77,7 @@ error[E0080]: constructing invalid value: encountered 0xffffffff, but expected a
 LL | const CHAR_OOB: pattern_type!(char is 'A'..'Z') = unsafe { std::mem::transmute(u32::MAX) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
-   = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 4, align: 4) {
                HEX_DUMP
            }
diff --git a/tests/ui/unstable-feature-bound/unstable_feature_bound_incompatible_stability.rs b/tests/ui/unstable-feature-bound/unstable_feature_bound_incompatible_stability.rs
index 1a9652c102309..5a683884238ad 100644
--- a/tests/ui/unstable-feature-bound/unstable_feature_bound_incompatible_stability.rs
+++ b/tests/ui/unstable-feature-bound/unstable_feature_bound_incompatible_stability.rs
@@ -9,6 +9,6 @@
 #[stable(feature = "a", since = "1.1.1")]
 #[unstable_feature_bound(feat_bar)]
 fn bar() {}
-//~^ ERROR Item annotated with `#[unstable_feature_bound]` should not be stable
+//~^ ERROR item annotated with `#[unstable_feature_bound]` should not be stable
 
 fn main() {}
diff --git a/tests/ui/unstable-feature-bound/unstable_feature_bound_incompatible_stability.stderr b/tests/ui/unstable-feature-bound/unstable_feature_bound_incompatible_stability.stderr
index 9cb6a181beffc..9f07e63e4544f 100644
--- a/tests/ui/unstable-feature-bound/unstable_feature_bound_incompatible_stability.stderr
+++ b/tests/ui/unstable-feature-bound/unstable_feature_bound_incompatible_stability.stderr
@@ -1,4 +1,4 @@
-error: Item annotated with `#[unstable_feature_bound]` should not be stable
+error: item annotated with `#[unstable_feature_bound]` should not be stable
   --> $DIR/unstable_feature_bound_incompatible_stability.rs:11:1
    |
 LL | fn bar() {}

From fe90610e1a3dc3b85894f9fd2f567ad3b3376c85 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Tue, 2 Sep 2025 17:02:48 +0200
Subject: [PATCH 0458/1889] Check `rustc-dev` in `distcheck`

---
 src/bootstrap/src/core/build_steps/dist.rs | 20 +++++----
 src/bootstrap/src/core/build_steps/test.rs | 48 +++++++++++++++++-----
 2 files changed, 50 insertions(+), 18 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/dist.rs b/src/bootstrap/src/core/build_steps/dist.rs
index f113dd7683d87..820dda5a6524c 100644
--- a/src/bootstrap/src/core/build_steps/dist.rs
+++ b/src/bootstrap/src/core/build_steps/dist.rs
@@ -823,6 +823,18 @@ pub struct RustcDev {
     target: TargetSelection,
 }
 
+impl RustcDev {
+    pub fn new(builder: &Builder<'_>, target: TargetSelection) -> Self {
+        Self {
+            // We currently always ship a stage 2 rustc-dev component, so we build it with the
+            // stage 1 compiler. This might change in the future.
+            // The precise stage used here is important, so we hard-code it.
+            build_compiler: builder.compiler(1, builder.config.host_target),
+            target,
+        }
+    }
+}
+
 impl Step for RustcDev {
     type Output = Option<GeneratedTarball>;
     const DEFAULT: bool = true;
@@ -833,13 +845,7 @@ impl Step for RustcDev {
     }
 
     fn make_run(run: RunConfig<'_>) {
-        run.builder.ensure(RustcDev {
-            // We currently always ship a stage 2 rustc-dev component, so we build it with the
-            // stage 1 compiler. This might change in the future.
-            // The precise stage used here is important, so we hard-code it.
-            build_compiler: run.builder.compiler(1, run.builder.config.host_target),
-            target: run.target,
-        });
+        run.builder.ensure(RustcDev::new(run.builder, run.target));
     }
 
     fn run(self, builder: &Builder<'_>) -> Option<GeneratedTarball> {
diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index f5faa32defd4e..403d537278367 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -3182,6 +3182,7 @@ impl Step for Distcheck {
     ///   check steps from those sources.
     /// - Check that selected dist components (`rust-src` only at the moment) at least have expected
     ///   directory shape and crate manifests that cargo can generate a lockfile from.
+    /// - Check that we can run `cargo metadata` on the workspace in the `rustc-dev` component
     ///
     /// FIXME(#136822): dist components are under-tested.
     fn run(self, builder: &Builder<'_>) {
@@ -3189,16 +3190,17 @@ impl Step for Distcheck {
         // local source code, built artifacts or configuration by accident
         let root_dir = std::env::temp_dir().join("distcheck");
 
-        distcheck_plain_source_tarball(builder, &root_dir.join("distcheck-plain-src"));
-        distcheck_rust_src(builder, &root_dir.join("distcheck-src"));
+        distcheck_plain_source_tarball(builder, &root_dir.join("distcheck-rustc-src"));
+        distcheck_rust_src(builder, &root_dir.join("distcheck-rust-src"));
+        distcheck_rustc_dev(builder, &root_dir.join("distcheck-rustc-dev"));
     }
 }
 
+/// Check that we can build some basic things from the plain source tarball
 fn distcheck_plain_source_tarball(builder: &Builder<'_>, plain_src_dir: &Path) {
-    // Check that we can build some basic things from the plain source tarball
     builder.info("Distcheck plain source tarball");
     let plain_src_tarball = builder.ensure(dist::PlainSourceTarball);
-    builder.clear_dir(&plain_src_dir);
+    builder.clear_dir(plain_src_dir);
 
     let configure_args: Vec<String> = std::env::var("DISTCHECK_CONFIGURE_ARGS")
         .map(|args| args.split(" ").map(|s| s.to_string()).collect::<Vec<String>>())
@@ -3208,35 +3210,35 @@ fn distcheck_plain_source_tarball(builder: &Builder<'_>, plain_src_dir: &Path) {
         .arg("-xf")
         .arg(plain_src_tarball.tarball())
         .arg("--strip-components=1")
-        .current_dir(&plain_src_dir)
+        .current_dir(plain_src_dir)
         .run(builder);
     command("./configure")
         .arg("--set")
         .arg("rust.omit-git-hash=false")
         .args(&configure_args)
         .arg("--enable-vendor")
-        .current_dir(&plain_src_dir)
+        .current_dir(plain_src_dir)
         .run(builder);
     command(helpers::make(&builder.config.host_target.triple))
         .arg("check")
         // Do not run the build as if we were in CI, otherwise git would be assumed to be
         // present, but we build from a tarball here
         .env("GITHUB_ACTIONS", "0")
-        .current_dir(&plain_src_dir)
+        .current_dir(plain_src_dir)
         .run(builder);
 }
 
+/// Check that rust-src has all of libstd's dependencies
 fn distcheck_rust_src(builder: &Builder<'_>, src_dir: &Path) {
-    // Now make sure that rust-src has all of libstd's dependencies
     builder.info("Distcheck rust-src");
     let src_tarball = builder.ensure(dist::Src);
-    builder.clear_dir(&src_dir);
+    builder.clear_dir(src_dir);
 
     command("tar")
         .arg("-xf")
         .arg(src_tarball.tarball())
         .arg("--strip-components=1")
-        .current_dir(&src_dir)
+        .current_dir(src_dir)
         .run(builder);
 
     let toml = src_dir.join("rust-src/lib/rustlib/src/rust/library/std/Cargo.toml");
@@ -3247,7 +3249,31 @@ fn distcheck_rust_src(builder: &Builder<'_>, src_dir: &Path) {
         .arg("generate-lockfile")
         .arg("--manifest-path")
         .arg(&toml)
-        .current_dir(&src_dir)
+        .current_dir(src_dir)
+        .run(builder);
+}
+
+/// Check that rustc-dev's compiler crate source code can be loaded with `cargo metadata`
+fn distcheck_rustc_dev(builder: &Builder<'_>, dir: &Path) {
+    builder.info("Distcheck rustc-dev");
+    let tarball = builder.ensure(dist::RustcDev::new(builder, builder.host_target)).unwrap();
+    builder.clear_dir(dir);
+
+    command("tar")
+        .arg("-xf")
+        .arg(tarball.tarball())
+        .arg("--strip-components=1")
+        .current_dir(dir)
+        .run(builder);
+
+    command(&builder.initial_cargo)
+        .arg("metadata")
+        .arg("--manifest-path")
+        .arg("rustc-dev/lib/rustlib/rustc-src/rust/compiler/rustc/Cargo.toml")
+        .env("RUSTC_BOOTSTRAP", "1")
+        // We might not have a globally available `rustc` binary on CI
+        .env("RUSTC", &builder.initial_rustc)
+        .current_dir(dir)
         .run(builder);
 }
 

From a5f52a9a90c97cf7e0c1b5f4777eb33df159a75f Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Wed, 3 Sep 2025 16:34:57 +0200
Subject: [PATCH 0459/1889] Uncomment code to add scraped rustdoc examples in
 loaded paths

---
 src/librustdoc/config.rs          | 3 ++-
 src/librustdoc/scrape_examples.rs | 7 ++-----
 2 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs
index 450ac04b40d91..03059cd6d64f4 100644
--- a/src/librustdoc/config.rs
+++ b/src/librustdoc/config.rs
@@ -814,7 +814,8 @@ impl Options {
 
         let scrape_examples_options = ScrapeExamplesOptions::new(matches, dcx);
         let with_examples = matches.opt_strs("with-examples");
-        let call_locations = crate::scrape_examples::load_call_locations(with_examples, dcx);
+        let call_locations =
+            crate::scrape_examples::load_call_locations(with_examples, dcx, &mut loaded_paths);
         let doctest_build_args = matches.opt_strs("doctest-build-arg");
 
         let unstable_features =
diff --git a/src/librustdoc/scrape_examples.rs b/src/librustdoc/scrape_examples.rs
index 16034c1182723..471e966e2c24b 100644
--- a/src/librustdoc/scrape_examples.rs
+++ b/src/librustdoc/scrape_examples.rs
@@ -333,14 +333,11 @@ pub(crate) fn run(
 pub(crate) fn load_call_locations(
     with_examples: Vec<String>,
     dcx: DiagCtxtHandle<'_>,
+    loaded_paths: &mut Vec<PathBuf>,
 ) -> AllCallLocations {
     let mut all_calls: AllCallLocations = FxIndexMap::default();
     for path in with_examples {
-        // FIXME: Figure out why this line is causing this feature to crash in specific contexts.
-        // Full issue backlog is available here: <https://github.com/rust-lang/rust/pull/144600>.
-        //
-        // Can be checked with `tests/run-make/rustdoc-scrape-examples-paths`.
-        // loaded_paths.push(path.clone().into());
+        loaded_paths.push(path.clone().into());
         let bytes = match fs::read(&path) {
             Ok(bytes) => bytes,
             Err(e) => dcx.fatal(format!("failed to load examples: {e}")),

From 82f5cdf33e15bf08548ec8b9f13bb4cad8ac5ae4 Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Sat, 30 Aug 2025 00:21:38 +0200
Subject: [PATCH 0460/1889] std: improve the `dlsym!` macro and add a test for
 it

* Ensure nul-termination of the symbol name at compile-time
* Use an acquire load instead of a relaxed load and acquire fence
* Properly use `unsafe` and add safety comments
* Add tests
---
 library/std/src/lib.rs                     |   1 +
 library/std/src/sys/pal/unix/weak.rs       | 120 ++++++++++++---------
 library/std/src/sys/pal/unix/weak/tests.rs |  32 ++++++
 3 files changed, 102 insertions(+), 51 deletions(-)
 create mode 100644 library/std/src/sys/pal/unix/weak/tests.rs

diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index 30a1b10881784..69f640a68551f 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -350,6 +350,7 @@
 #![feature(float_gamma)]
 #![feature(float_minimum_maximum)]
 #![feature(fmt_internals)]
+#![feature(fn_ptr_trait)]
 #![feature(generic_atomic)]
 #![feature(hasher_prefixfree_extras)]
 #![feature(hashmap_internals)]
diff --git a/library/std/src/sys/pal/unix/weak.rs b/library/std/src/sys/pal/unix/weak.rs
index c8cf75b876c26..ad649fdbab6c6 100644
--- a/library/std/src/sys/pal/unix/weak.rs
+++ b/library/std/src/sys/pal/unix/weak.rs
@@ -22,11 +22,14 @@
 #![allow(dead_code, unused_macros)]
 #![forbid(unsafe_op_in_unsafe_fn)]
 
-use crate::ffi::CStr;
-use crate::marker::PhantomData;
-use crate::sync::atomic::{self, Atomic, AtomicPtr, Ordering};
+use crate::ffi::{CStr, c_char, c_void};
+use crate::marker::{FnPtr, PhantomData};
+use crate::sync::atomic::{Atomic, AtomicPtr, Ordering};
 use crate::{mem, ptr};
 
+#[cfg(test)]
+mod tests;
+
 // We can use true weak linkage on ELF targets.
 #[cfg(all(unix, not(target_vendor = "apple")))]
 pub(crate) macro weak {
@@ -64,7 +67,7 @@ impl<F: Copy> ExternWeak<F> {
 
 pub(crate) macro dlsym {
     (fn $name:ident($($param:ident : $t:ty),* $(,)?) -> $ret:ty;) => (
-         dlsym!(
+        dlsym!(
             #[link_name = stringify!($name)]
             fn $name($($param : $t),*) -> $ret;
         );
@@ -73,21 +76,39 @@ pub(crate) macro dlsym {
         #[link_name = $sym:expr]
         fn $name:ident($($param:ident : $t:ty),* $(,)?) -> $ret:ty;
     ) => (
-        static DLSYM: DlsymWeak<unsafe extern "C" fn($($t),*) -> $ret> =
-            DlsymWeak::new(concat!($sym, '\0'));
+        static DLSYM: DlsymWeak<unsafe extern "C" fn($($t),*) -> $ret> = {
+            let Ok(name) = CStr::from_bytes_with_nul(concat!($sym, '\0').as_bytes()) else {
+                panic!("symbol name may not contain NUL")
+            };
+
+            // SAFETY: Whoever calls the function pointer returned by `get()`
+            // is responsible for ensuring that the signature is correct. Just
+            // like with extern blocks, this is syntactically enforced by making
+            // the function pointer be unsafe.
+            unsafe { DlsymWeak::new(name) }
+        };
+
         let $name = &DLSYM;
     )
 }
+
 pub(crate) struct DlsymWeak<F> {
-    name: &'static str,
+    /// A pointer to the nul-terminated name of the symbol.
+    // Use a pointer instead of `&'static CStr` to save space.
+    name: *const c_char,
     func: Atomic<*mut libc::c_void>,
     _marker: PhantomData<F>,
 }
 
-impl<F> DlsymWeak<F> {
-    pub(crate) const fn new(name: &'static str) -> Self {
+impl<F: FnPtr> DlsymWeak<F> {
+    /// # Safety
+    ///
+    /// If the signature of `F` does not match the signature of the symbol (if
+    /// it exists), calling the function pointer returned by `get()` is
+    /// undefined behaviour.
+    pub(crate) const unsafe fn new(name: &'static CStr) -> Self {
         DlsymWeak {
-            name,
+            name: name.as_ptr(),
             func: AtomicPtr::new(ptr::without_provenance_mut(1)),
             _marker: PhantomData,
         }
@@ -95,62 +116,59 @@ impl<F> DlsymWeak<F> {
 
     #[inline]
     pub(crate) fn get(&self) -> Option<F> {
-        unsafe {
-            // Relaxed is fine here because we fence before reading through the
-            // pointer (see the comment below).
-            match self.func.load(Ordering::Relaxed) {
-                func if func.addr() == 1 => self.initialize(),
-                func if func.is_null() => None,
-                func => {
-                    let func = mem::transmute_copy::<*mut libc::c_void, F>(&func);
-                    // The caller is presumably going to read through this value
-                    // (by calling the function we've dlsymed). This means we'd
-                    // need to have loaded it with at least C11's consume
-                    // ordering in order to be guaranteed that the data we read
-                    // from the pointer isn't from before the pointer was
-                    // stored. Rust has no equivalent to memory_order_consume,
-                    // so we use an acquire fence (sorry, ARM).
-                    //
-                    // Now, in practice this likely isn't needed even on CPUs
-                    // where relaxed and consume mean different things. The
-                    // symbols we're loading are probably present (or not) at
-                    // init, and even if they aren't the runtime dynamic loader
-                    // is extremely likely have sufficient barriers internally
-                    // (possibly implicitly, for example the ones provided by
-                    // invoking `mprotect`).
-                    //
-                    // That said, none of that's *guaranteed*, and so we fence.
-                    atomic::fence(Ordering::Acquire);
-                    Some(func)
-                }
-            }
+        // The caller is presumably going to read through this value
+        // (by calling the function we've dlsymed). This means we'd
+        // need to have loaded it with at least C11's consume
+        // ordering in order to be guaranteed that the data we read
+        // from the pointer isn't from before the pointer was
+        // stored. Rust has no equivalent to memory_order_consume,
+        // so we use an acquire load (sorry, ARM).
+        //
+        // Now, in practice this likely isn't needed even on CPUs
+        // where relaxed and consume mean different things. The
+        // symbols we're loading are probably present (or not) at
+        // init, and even if they aren't the runtime dynamic loader
+        // is extremely likely have sufficient barriers internally
+        // (possibly implicitly, for example the ones provided by
+        // invoking `mprotect`).
+        //
+        // That said, none of that's *guaranteed*, so we use acquire.
+        match self.func.load(Ordering::Acquire) {
+            func if func.addr() == 1 => self.initialize(),
+            func if func.is_null() => None,
+            // SAFETY:
+            // `func` is not null and `F` implements `FnPtr`, thus this
+            // transmutation is well-defined. It is the responsibility of the
+            // creator of this `DlsymWeak` to ensure that calling the resulting
+            // function pointer does not result in undefined behaviour (though
+            // the `dlsym!` macro delegates this responsibility to the caller
+            // of the function by using `unsafe` function pointers).
+            // FIXME: use `transmute` once it stops complaining about generics.
+            func => Some(unsafe { mem::transmute_copy::<*mut c_void, F>(&func) }),
         }
     }
 
     // Cold because it should only happen during first-time initialization.
     #[cold]
-    unsafe fn initialize(&self) -> Option<F> {
-        assert_eq!(size_of::<F>(), size_of::<*mut libc::c_void>());
-
-        let val = unsafe { fetch(self.name) };
-        // This synchronizes with the acquire fence in `get`.
+    fn initialize(&self) -> Option<F> {
+        // SAFETY: `self.name` was created from a `&'static CStr` and is
+        // therefore a valid C string pointer.
+        let val = unsafe { libc::dlsym(libc::RTLD_DEFAULT, self.name) };
+        // This synchronizes with the acquire load in `get`.
         self.func.store(val, Ordering::Release);
 
         if val.is_null() {
             None
         } else {
+            // SAFETY: see the comment in `get`.
+            // FIXME: use `transmute` once it stops complaining about generics.
             Some(unsafe { mem::transmute_copy::<*mut libc::c_void, F>(&val) })
         }
     }
 }
 
-unsafe fn fetch(name: &str) -> *mut libc::c_void {
-    let name = match CStr::from_bytes_with_nul(name.as_bytes()) {
-        Ok(cstr) => cstr,
-        Err(..) => return ptr::null_mut(),
-    };
-    unsafe { libc::dlsym(libc::RTLD_DEFAULT, name.as_ptr()) }
-}
+unsafe impl<F> Send for DlsymWeak<F> {}
+unsafe impl<F> Sync for DlsymWeak<F> {}
 
 #[cfg(not(any(target_os = "linux", target_os = "android")))]
 pub(crate) macro syscall {
diff --git a/library/std/src/sys/pal/unix/weak/tests.rs b/library/std/src/sys/pal/unix/weak/tests.rs
new file mode 100644
index 0000000000000..d807ba64e3577
--- /dev/null
+++ b/library/std/src/sys/pal/unix/weak/tests.rs
@@ -0,0 +1,32 @@
+use super::*;
+
+#[test]
+fn dlsym_existing() {
+    const TEST_STRING: &'static CStr = c"Ferris!";
+
+    // Try to find a symbol that definitely exists.
+    dlsym! {
+        fn strlen(cs: *const c_char) -> usize;
+    }
+
+    dlsym! {
+        #[link_name = "strlen"]
+        fn custom_name(cs: *const c_char) -> usize;
+    }
+
+    let strlen = strlen.get().unwrap();
+    assert_eq!(unsafe { strlen(TEST_STRING.as_ptr()) }, TEST_STRING.count_bytes());
+
+    let custom_name = custom_name.get().unwrap();
+    assert_eq!(unsafe { custom_name(TEST_STRING.as_ptr()) }, TEST_STRING.count_bytes());
+}
+
+#[test]
+fn dlsym_missing() {
+    // Try to find a symbol that definitely does not exist.
+    dlsym! {
+        fn test_symbol_that_does_not_exist() -> i32;
+    }
+
+    assert!(test_symbol_that_does_not_exist.get().is_none());
+}

From e7674cb1e69d3b8a863017aa4f91a268c81c8419 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Tue, 2 Sep 2025 10:59:40 -0700
Subject: [PATCH 0461/1889] rustdoc-search: add test case for indexing every
 item type

Test case for 7b35d8e1ab2d913f4b15d0ee21d5bd8d50798e9c
and ad2e0961366a6bf5e01d6863a459424e78ebcf40
---
 .../rustdoc-search-load-itemtype/bar.rs       |  27 ++++
 .../rustdoc-search-load-itemtype/baz.rs       |   3 +
 .../rustdoc-search-load-itemtype/foo.rs       | 119 ++++++++++++++++++
 .../rustdoc-search-load-itemtype/rmake.rs     |  21 ++++
 4 files changed, 170 insertions(+)
 create mode 100644 tests/run-make/rustdoc-search-load-itemtype/bar.rs
 create mode 100644 tests/run-make/rustdoc-search-load-itemtype/baz.rs
 create mode 100644 tests/run-make/rustdoc-search-load-itemtype/foo.rs
 create mode 100644 tests/run-make/rustdoc-search-load-itemtype/rmake.rs

diff --git a/tests/run-make/rustdoc-search-load-itemtype/bar.rs b/tests/run-make/rustdoc-search-load-itemtype/bar.rs
new file mode 100644
index 0000000000000..0416b1b75b594
--- /dev/null
+++ b/tests/run-make/rustdoc-search-load-itemtype/bar.rs
@@ -0,0 +1,27 @@
+#![crate_type = "proc-macro"]
+
+extern crate proc_macro;
+use proc_macro::*;
+
+//@ has bar/macro.a_procmacro.html
+//@ hasraw search.index/name/*.js a_procmacro
+#[proc_macro]
+pub fn a_procmacro(_: TokenStream) -> TokenStream {
+    unimplemented!()
+}
+
+//@ has bar/attr.a_procattribute.html
+//@ hasraw search.index/name/*.js a_procattribute
+#[proc_macro_attribute]
+pub fn a_procattribute(_: TokenStream, _: TokenStream) -> TokenStream {
+    unimplemented!()
+}
+
+//@ has bar/derive.AProcDerive.html
+//@ !has bar/derive.a_procderive.html
+//@ hasraw search.index/name/*.js AProcDerive
+//@ !hasraw search.index/name/*.js a_procderive
+#[proc_macro_derive(AProcDerive)]
+pub fn a_procderive(_: TokenStream) -> TokenStream {
+    unimplemented!()
+}
diff --git a/tests/run-make/rustdoc-search-load-itemtype/baz.rs b/tests/run-make/rustdoc-search-load-itemtype/baz.rs
new file mode 100644
index 0000000000000..4d1f5430fc630
--- /dev/null
+++ b/tests/run-make/rustdoc-search-load-itemtype/baz.rs
@@ -0,0 +1,3 @@
+//@ has baz/struct.Baz.html
+//@ hasraw search.index/name/*.js Baz
+pub struct Baz;
diff --git a/tests/run-make/rustdoc-search-load-itemtype/foo.rs b/tests/run-make/rustdoc-search-load-itemtype/foo.rs
new file mode 100644
index 0000000000000..93b372d10cbf9
--- /dev/null
+++ b/tests/run-make/rustdoc-search-load-itemtype/foo.rs
@@ -0,0 +1,119 @@
+#![feature(extern_types, rustc_attrs, rustdoc_internals, trait_alias)]
+#![allow(internal_features)]
+#![no_std]
+
+//@ has foo/keyword.while.html
+//@ hasraw search.index/name/*.js while
+//@ !hasraw search.index/name/*.js w_keyword
+#[doc(keyword = "while")]
+mod w_keyword {}
+
+//@ has foo/primitive.u32.html
+//@ hasraw search.index/name/*.js u32
+//@ !hasraw search.index/name/*.js u_primitive
+#[rustc_doc_primitive = "u32"]
+mod u_primitive {}
+
+//@ has foo/x_mod/index.html
+//@ hasraw search.index/name/*.js x_mod
+pub mod x_mod {}
+
+//@ hasraw foo/index.html y_crate
+//@ hasraw search.index/name/*.js y_crate
+#[doc(no_inline)]
+pub extern crate core as y_crate;
+
+//@ hasraw foo/index.html z_import
+//@ hasraw search.index/name/*.js z_import
+#[doc(no_inline)]
+pub use core::option as z_import;
+
+//@ has foo/struct.AStruct.html
+//@ hasraw search.index/name/*.js AStruct
+pub struct AStruct {
+    //@ hasraw foo/struct.AStruct.html a_structfield
+    //@ hasraw search.index/name/*.js a_structfield
+    pub a_structfield: i32,
+}
+
+//@ has foo/enum.AEnum.html
+//@ hasraw search.index/name/*.js AEnum
+pub enum AEnum {
+    //@ hasraw foo/enum.AEnum.html AVariant
+    //@ hasraw search.index/name/*.js AVariant
+    AVariant,
+}
+
+//@ has foo/fn.a_fn.html
+//@ hasraw search.index/name/*.js a_fn
+pub fn a_fn() {}
+
+//@ has foo/type.AType.html
+//@ hasraw search.index/name/*.js AType
+pub type AType = AStruct;
+
+//@ has foo/static.a_static.html
+//@ hasraw search.index/name/*.js a_static
+pub static a_static: i32 = 1;
+
+//@ has foo/trait.ATrait.html
+//@ hasraw search.index/name/*.js ATrait
+pub trait ATrait {
+    //@ hasraw foo/trait.ATrait.html a_tymethod
+    //@ hasraw search.index/name/*.js a_tymethod
+    fn a_tymethod();
+    //@ hasraw foo/trait.ATrait.html AAssocType
+    //@ hasraw search.index/name/*.js AAssocType
+    type AAssocType;
+    //@ hasraw foo/trait.ATrait.html AAssocConst
+    //@ hasraw search.index/name/*.js AAssocConst
+    const AAssocConst: bool;
+}
+
+// skip ItemType::Impl, since impls are anonymous
+// and have no search entry
+
+impl AStruct {
+    //@ hasraw foo/struct.AStruct.html a_method
+    //@ hasraw search.index/name/*.js a_method
+    pub fn a_method() {}
+}
+
+//@ has foo/macro.a_macro.html
+//@ hasraw search.index/name/*.js a_macro
+#[macro_export]
+macro_rules! a_macro {
+    () => {};
+}
+
+//@ has foo/constant.A_CONSTANT.html
+//@ hasraw search.index/name/*.js A_CONSTANT
+pub const A_CONSTANT: i32 = 1;
+
+//@ has foo/union.AUnion.html
+//@ hasraw search.index/name/*.js AUnion
+pub union AUnion {
+    //@ hasraw foo/union.AUnion.html a_unionfield
+    //@ hasraw search.index/name/*.js a_unionfield
+    pub a_unionfield: i32,
+}
+
+extern "C" {
+    //@ has foo/foreigntype.AForeignType.html
+    //@ hasraw search.index/name/*.js AForeignType
+    pub type AForeignType;
+}
+
+// procattribute and procderive are defined in
+// bar.rs, because they only work with proc_macro
+// crate type.
+
+//@ has foo/traitalias.ATraitAlias.html
+//@ hasraw search.index/name/*.js ATraitAlias
+pub trait ATraitAlias = ATrait;
+
+//@ has foo/attribute.doc.html
+//@ hasraw search.index/name/*.js doc
+//@ !hasraw search.index/name/*.js aa_mod
+#[doc(attribute = "doc")]
+mod aa_mod {}
diff --git a/tests/run-make/rustdoc-search-load-itemtype/rmake.rs b/tests/run-make/rustdoc-search-load-itemtype/rmake.rs
new file mode 100644
index 0000000000000..803eb8a61dad7
--- /dev/null
+++ b/tests/run-make/rustdoc-search-load-itemtype/rmake.rs
@@ -0,0 +1,21 @@
+//@ ignore-cross-compile
+//@ needs-crate-type: proc-macro
+
+// Test that rustdoc can deserialize a search index with every itemtype.
+// https://github.com/rust-lang/rust/pull/146117
+
+use std::path::Path;
+
+use run_make_support::{htmldocck, rfs, rustdoc, source_root};
+
+fn main() {
+    let out_dir = Path::new("rustdoc-search-load-itemtype");
+
+    rfs::create_dir_all(&out_dir);
+    rustdoc().out_dir(&out_dir).input("foo.rs").run();
+    rustdoc().out_dir(&out_dir).input("bar.rs").arg("--crate-type=proc-macro").run();
+    rustdoc().out_dir(&out_dir).input("baz.rs").run();
+    htmldocck().arg(out_dir).arg("foo.rs").run();
+    htmldocck().arg(out_dir).arg("bar.rs").run();
+    htmldocck().arg(out_dir).arg("baz.rs").run();
+}

From fcc413f049555053b4494d8f5faca7bc5647e232 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Tue, 2 Sep 2025 14:23:42 -0700
Subject: [PATCH 0462/1889] htmldocck: fix a bug in relative paths / globs

This bug only shows up when you run htmldocck in a directory other
than outdir, and also use globs. Never happened before, which is
why we're only seeing it now.
---
 src/etc/htmldocck.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/etc/htmldocck.py b/src/etc/htmldocck.py
index 8d7f7341c2e65..46a3a1602ac71 100755
--- a/src/etc/htmldocck.py
+++ b/src/etc/htmldocck.py
@@ -247,7 +247,7 @@ def get_absolute_path(self, path):
             paths = list(Path(self.root).glob(path))
             if len(paths) != 1:
                 raise FailedCheck("glob path does not resolve to one file")
-            path = str(paths[0])
+            return str(paths[0])
         return os.path.join(self.root, path)
 
     def get_file(self, path):

From 48c15bd58c5f0c0105894a2b660845037937cfbd Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Wed, 3 Sep 2025 17:26:02 +0200
Subject: [PATCH 0463/1889] test valid cases of c-variadic function definitions

---
 tests/ui/c-variadic/valid.rs | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 tests/ui/c-variadic/valid.rs

diff --git a/tests/ui/c-variadic/valid.rs b/tests/ui/c-variadic/valid.rs
new file mode 100644
index 0000000000000..5a0b32026dc7a
--- /dev/null
+++ b/tests/ui/c-variadic/valid.rs
@@ -0,0 +1,29 @@
+//@ run-pass
+#![feature(c_variadic)]
+
+// In rust (and C23 and above) `...` can be the only argument.
+unsafe extern "C" fn only_dot_dot_dot(mut ap: ...) -> i32 {
+    unsafe { ap.arg() }
+}
+
+unsafe extern "C-unwind" fn abi_c_unwind(mut ap: ...) -> i32 {
+    unsafe { ap.arg() }
+}
+
+#[allow(improper_ctypes_definitions)]
+unsafe extern "C" fn mix_int_float(mut ap: ...) -> (i64, f64, *const i32, f64) {
+    (ap.arg(), ap.arg(), ap.arg(), ap.arg())
+}
+
+fn main() {
+    unsafe {
+        assert_eq!(only_dot_dot_dot(32), 32);
+        assert_eq!(abi_c_unwind(32), 32);
+
+        // Passing more arguments than expected is allowed.
+        assert_eq!(only_dot_dot_dot(32, 1i64, core::ptr::null::<i32>(), 3.14f64), 32);
+
+        let ptr = &14i32 as *const i32;
+        assert_eq!(mix_int_float(12i64, 13.0f64, ptr, 15.0f64), (12, 13.0, ptr, 15.0));
+    }
+}

From 8d11719e6c980232b9e9657a356d3c3c1a35c6da Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Wed, 3 Sep 2025 16:56:13 +0200
Subject: [PATCH 0464/1889] simplify `check_c_variadic_type`

---
 .../rustc_ast_passes/src/ast_validation.rs    | 42 ++++-----
 compiler/rustc_ast_passes/src/errors.rs       |  4 +-
 tests/ui/c-variadic/issue-86053-1.stderr      |  4 +-
 tests/ui/c-variadic/no-closure.rs             | 17 ++++
 tests/ui/c-variadic/no-closure.stderr         | 35 +++++++
 .../variadic-ffi-semantic-restrictions.rs     | 12 +--
 .../variadic-ffi-semantic-restrictions.stderr | 91 +++++++------------
 7 files changed, 111 insertions(+), 94 deletions(-)
 create mode 100644 tests/ui/c-variadic/no-closure.rs
 create mode 100644 tests/ui/c-variadic/no-closure.stderr

diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index 6133cc3548b5f..538918a890d52 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -665,46 +665,42 @@ impl<'a> AstValidator<'a> {
     /// - Non-const
     /// - Either foreign, or free and `unsafe extern "C"` semantically
     fn check_c_variadic_type(&self, fk: FnKind<'a>) {
-        let variadic_spans: Vec<_> = fk
-            .decl()
-            .inputs
-            .iter()
-            .filter(|arg| matches!(arg.ty.kind, TyKind::CVarArgs))
-            .map(|arg| arg.span)
-            .collect();
+        // `...` is already rejected when it is not the final parameter.
+        let variadic_param = match fk.decl().inputs.last() {
+            Some(param) if matches!(param.ty.kind, TyKind::CVarArgs) => param,
+            _ => return,
+        };
 
-        if variadic_spans.is_empty() {
-            return;
-        }
+        let FnKind::Fn(fn_ctxt, _, Fn { sig, .. }) = fk else {
+            // Unreachable because the parser already rejects `...` in closures.
+            unreachable!("C variable argument list cannot be used in closures")
+        };
 
-        if let Some(header) = fk.header()
-            && let Const::Yes(const_span) = header.constness
-        {
-            let mut spans = variadic_spans.clone();
-            spans.push(const_span);
+        // C-variadics are not yet implemented in const evaluation.
+        if let Const::Yes(const_span) = sig.header.constness {
             self.dcx().emit_err(errors::ConstAndCVariadic {
-                spans,
+                spans: vec![const_span, variadic_param.span],
                 const_span,
-                variadic_spans: variadic_spans.clone(),
+                variadic_span: variadic_param.span,
             });
         }
 
-        match (fk.ctxt(), fk.header()) {
-            (Some(FnCtxt::Foreign), _) => return,
-            (Some(FnCtxt::Free), Some(header)) => match header.ext {
+        match fn_ctxt {
+            FnCtxt::Foreign => return,
+            FnCtxt::Free => match sig.header.ext {
                 Extern::Explicit(StrLit { symbol_unescaped: sym::C, .. }, _)
                 | Extern::Explicit(StrLit { symbol_unescaped: sym::C_dash_unwind, .. }, _)
                 | Extern::Implicit(_)
-                    if matches!(header.safety, Safety::Unsafe(_)) =>
+                    if matches!(sig.header.safety, Safety::Unsafe(_)) =>
                 {
                     return;
                 }
                 _ => {}
             },
-            _ => {}
+            FnCtxt::Assoc(_) => {}
         };
 
-        self.dcx().emit_err(errors::BadCVariadic { span: variadic_spans });
+        self.dcx().emit_err(errors::BadCVariadic { span: variadic_param.span });
     }
 
     fn check_item_named(&self, ident: Ident, kind: &str) {
diff --git a/compiler/rustc_ast_passes/src/errors.rs b/compiler/rustc_ast_passes/src/errors.rs
index ae8f056cb4e65..476ed27a10e3c 100644
--- a/compiler/rustc_ast_passes/src/errors.rs
+++ b/compiler/rustc_ast_passes/src/errors.rs
@@ -322,7 +322,7 @@ pub(crate) struct ExternItemAscii {
 #[diag(ast_passes_bad_c_variadic)]
 pub(crate) struct BadCVariadic {
     #[primary_span]
-    pub span: Vec<Span>,
+    pub span: Span,
 }
 
 #[derive(Diagnostic)]
@@ -656,7 +656,7 @@ pub(crate) struct ConstAndCVariadic {
     #[label(ast_passes_const)]
     pub const_span: Span,
     #[label(ast_passes_variadic)]
-    pub variadic_spans: Vec<Span>,
+    pub variadic_span: Span,
 }
 
 #[derive(Diagnostic)]
diff --git a/tests/ui/c-variadic/issue-86053-1.stderr b/tests/ui/c-variadic/issue-86053-1.stderr
index 675dfd335c42e..b58016b5a8165 100644
--- a/tests/ui/c-variadic/issue-86053-1.stderr
+++ b/tests/ui/c-variadic/issue-86053-1.stderr
@@ -47,10 +47,10 @@ LL |     self , ... ,   self ,   self , ... ) where F : FnOnce ( & 'a & 'b usize
    |            ^^^
 
 error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
-  --> $DIR/issue-86053-1.rs:11:12
+  --> $DIR/issue-86053-1.rs:11:36
    |
 LL |     self , ... ,   self ,   self , ... ) where F : FnOnce ( & 'a & 'b usize ) {
-   |            ^^^                     ^^^
+   |                                    ^^^
 
 error[E0412]: cannot find type `F` in this scope
   --> $DIR/issue-86053-1.rs:11:48
diff --git a/tests/ui/c-variadic/no-closure.rs b/tests/ui/c-variadic/no-closure.rs
new file mode 100644
index 0000000000000..c0b77786e8b4a
--- /dev/null
+++ b/tests/ui/c-variadic/no-closure.rs
@@ -0,0 +1,17 @@
+#![feature(c_variadic)]
+#![crate_type = "lib"]
+
+// Check that `...` in closures is rejected.
+
+const F: extern "C" fn(...) = |_: ...| {};
+//~^ ERROR C-variadic type `...` may not be nested inside another type
+
+fn foo() {
+    let f = |...| {};
+    //~^ ERROR: `..` patterns are not allowed here
+    //~| ERROR: unexpected `...`
+
+    let f = |_: ...| {};
+    //~^ ERROR C-variadic type `...` may not be nested inside another type
+    f(1i64)
+}
diff --git a/tests/ui/c-variadic/no-closure.stderr b/tests/ui/c-variadic/no-closure.stderr
new file mode 100644
index 0000000000000..77bd106bb9519
--- /dev/null
+++ b/tests/ui/c-variadic/no-closure.stderr
@@ -0,0 +1,35 @@
+error[E0743]: C-variadic type `...` may not be nested inside another type
+  --> $DIR/no-closure.rs:6:35
+   |
+LL | const F: extern "C" fn(...) = |_: ...| {};
+   |                                   ^^^
+
+error: unexpected `...`
+  --> $DIR/no-closure.rs:10:14
+   |
+LL |     let f = |...| {};
+   |              ^^^ not a valid pattern
+   |
+help: for a rest pattern, use `..` instead of `...`
+   |
+LL -     let f = |...| {};
+LL +     let f = |..| {};
+   |
+
+error[E0743]: C-variadic type `...` may not be nested inside another type
+  --> $DIR/no-closure.rs:14:17
+   |
+LL |     let f = |_: ...| {};
+   |                 ^^^
+
+error: `..` patterns are not allowed here
+  --> $DIR/no-closure.rs:10:14
+   |
+LL |     let f = |...| {};
+   |              ^^^
+   |
+   = note: only allowed in tuple, tuple struct, and slice patterns
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0743`.
diff --git a/tests/ui/parser/variadic-ffi-semantic-restrictions.rs b/tests/ui/parser/variadic-ffi-semantic-restrictions.rs
index e7a0248cffab9..243924e6c53ee 100644
--- a/tests/ui/parser/variadic-ffi-semantic-restrictions.rs
+++ b/tests/ui/parser/variadic-ffi-semantic-restrictions.rs
@@ -16,8 +16,7 @@ extern "C" fn f2_2(...) {}
 //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
 
 extern "C" fn f2_3(..., x: isize) {}
-//~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
-//~| ERROR `...` must be the last argument of a C-variadic function
+//~^ ERROR `...` must be the last argument of a C-variadic function
 
 extern "C" fn f3_1(x: isize, ...) {}
 //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
@@ -26,8 +25,7 @@ extern "C" fn f3_2(...) {}
 //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
 
 extern "C" fn f3_3(..., x: isize) {}
-//~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
-//~| ERROR `...` must be the last argument of a C-variadic function
+//~^ ERROR `...` must be the last argument of a C-variadic function
 
 const unsafe extern "C" fn f4_1(x: isize, ...) {}
 //~^ ERROR functions cannot be both `const` and C-variadic
@@ -77,9 +75,7 @@ trait T {
     fn t_f4(...);
     //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
     fn t_f5(..., x: isize) {}
-    //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
-    //~| ERROR `...` must be the last argument of a C-variadic function
+    //~^ ERROR `...` must be the last argument of a C-variadic function
     fn t_f6(..., x: isize);
-    //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
-    //~| ERROR `...` must be the last argument of a C-variadic function
+    //~^ ERROR `...` must be the last argument of a C-variadic function
 }
diff --git a/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr b/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr
index 5379045967aa0..5c55cc38b5682 100644
--- a/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr
+++ b/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr
@@ -29,118 +29,103 @@ LL | extern "C" fn f2_3(..., x: isize) {}
    |                    ^^^
 
 error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:18:20
-   |
-LL | extern "C" fn f2_3(..., x: isize) {}
-   |                    ^^^
-
-error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:22:30
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:21:30
    |
 LL | extern "C" fn f3_1(x: isize, ...) {}
    |                              ^^^
 
 error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:25:20
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:24:20
    |
 LL | extern "C" fn f3_2(...) {}
    |                    ^^^
 
 error: `...` must be the last argument of a C-variadic function
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:28:20
-   |
-LL | extern "C" fn f3_3(..., x: isize) {}
-   |                    ^^^
-
-error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:28:20
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:27:20
    |
 LL | extern "C" fn f3_3(..., x: isize) {}
    |                    ^^^
 
 error: functions cannot be both `const` and C-variadic
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:32:1
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:30:1
    |
 LL | const unsafe extern "C" fn f4_1(x: isize, ...) {}
    | ^^^^^ `const` because of this             ^^^ C-variadic because of this
 
 error: functions cannot be both `const` and C-variadic
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:36:1
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:34:1
    |
 LL | const extern "C" fn f4_2(x: isize, ...) {}
    | ^^^^^ `const` because of this      ^^^ C-variadic because of this
 
 error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:36:36
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:34:36
    |
 LL | const extern "C" fn f4_2(x: isize, ...) {}
    |                                    ^^^
 
 error: `...` must be the last argument of a C-variadic function
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:41:26
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:39:26
    |
 LL | const extern "C" fn f4_3(..., x: isize, ...) {}
    |                          ^^^
 
 error: functions cannot be both `const` and C-variadic
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:41:1
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:39:1
    |
 LL | const extern "C" fn f4_3(..., x: isize, ...) {}
-   | ^^^^^                    ^^^            ^^^ C-variadic because of this
-   | |                        |
-   | |                        C-variadic because of this
-   | `const` because of this
+   | ^^^^^ `const` because of this           ^^^ C-variadic because of this
 
 error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:41:26
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:39:41
    |
 LL | const extern "C" fn f4_3(..., x: isize, ...) {}
-   |                          ^^^            ^^^
+   |                                         ^^^
 
 error: `...` must be the last argument of a C-variadic function
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:47:13
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:45:13
    |
 LL |     fn e_f2(..., x: isize);
    |             ^^^
 
 error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:54:23
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:52:23
    |
 LL |     fn i_f1(x: isize, ...) {}
    |                       ^^^
 
 error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:56:13
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:54:13
    |
 LL |     fn i_f2(...) {}
    |             ^^^
 
 error: `...` must be the last argument of a C-variadic function
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:58:13
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:56:13
    |
 LL |     fn i_f3(..., x: isize, ...) {}
    |             ^^^
 
 error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:58:13
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:56:28
    |
 LL |     fn i_f3(..., x: isize, ...) {}
-   |             ^^^            ^^^
+   |                            ^^^
 
 error: `...` must be the last argument of a C-variadic function
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:61:13
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:59:13
    |
 LL |     fn i_f4(..., x: isize, ...) {}
    |             ^^^
 
 error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:61:13
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:59:28
    |
 LL |     fn i_f4(..., x: isize, ...) {}
-   |             ^^^            ^^^
+   |                            ^^^
 
 error: functions cannot be both `const` and C-variadic
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:64:5
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:62:5
    |
 LL |     const fn i_f5(x: isize, ...) {}
    |     ^^^^^                   ^^^ C-variadic because of this
@@ -148,61 +133,49 @@ LL |     const fn i_f5(x: isize, ...) {}
    |     `const` because of this
 
 error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:64:29
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:62:29
    |
 LL |     const fn i_f5(x: isize, ...) {}
    |                             ^^^
 
 error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:71:23
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:69:23
    |
 LL |     fn t_f1(x: isize, ...) {}
    |                       ^^^
 
 error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:73:23
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:71:23
    |
 LL |     fn t_f2(x: isize, ...);
    |                       ^^^
 
 error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:75:13
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:73:13
    |
 LL |     fn t_f3(...) {}
    |             ^^^
 
 error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:77:13
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:75:13
    |
 LL |     fn t_f4(...);
    |             ^^^
 
 error: `...` must be the last argument of a C-variadic function
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:79:13
-   |
-LL |     fn t_f5(..., x: isize) {}
-   |             ^^^
-
-error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:79:13
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:77:13
    |
 LL |     fn t_f5(..., x: isize) {}
    |             ^^^
 
 error: `...` must be the last argument of a C-variadic function
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:82:13
-   |
-LL |     fn t_f6(..., x: isize);
-   |             ^^^
-
-error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:82:13
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:79:13
    |
 LL |     fn t_f6(..., x: isize);
    |             ^^^
 
 error[E0493]: destructor of `VaListImpl<'_>` cannot be evaluated at compile-time
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:32:43
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:30:43
    |
 LL | const unsafe extern "C" fn f4_1(x: isize, ...) {}
    |                                           ^^^   - value is dropped here
@@ -210,7 +183,7 @@ LL | const unsafe extern "C" fn f4_1(x: isize, ...) {}
    |                                           the destructor for this type cannot be evaluated in constant functions
 
 error[E0493]: destructor of `VaListImpl<'_>` cannot be evaluated at compile-time
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:36:36
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:34:36
    |
 LL | const extern "C" fn f4_2(x: isize, ...) {}
    |                                    ^^^   - value is dropped here
@@ -218,13 +191,13 @@ LL | const extern "C" fn f4_2(x: isize, ...) {}
    |                                    the destructor for this type cannot be evaluated in constant functions
 
 error[E0493]: destructor of `VaListImpl<'_>` cannot be evaluated at compile-time
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:64:29
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:62:29
    |
 LL |     const fn i_f5(x: isize, ...) {}
    |                             ^^^   - value is dropped here
    |                             |
    |                             the destructor for this type cannot be evaluated in constant functions
 
-error: aborting due to 36 previous errors
+error: aborting due to 32 previous errors
 
 For more information about this error, try `rustc --explain E0493`.

From 31d1d82cce95b8031f771430e748f722cf6e18de Mon Sep 17 00:00:00 2001
From: Daniel Paoliello <danpao@microsoft.com>
Date: Fri, 29 Aug 2025 12:16:40 -0700
Subject: [PATCH 0465/1889] Reduce bootstrap's dependencies

---
 src/bootstrap/Cargo.lock | 138 ++++++++++++++++++++++++++++++---------
 src/bootstrap/Cargo.toml |   4 +-
 2 files changed, 108 insertions(+), 34 deletions(-)

diff --git a/src/bootstrap/Cargo.lock b/src/bootstrap/Cargo.lock
index 1535d08703335..fe832652d25ce 100644
--- a/src/bootstrap/Cargo.lock
+++ b/src/bootstrap/Cargo.lock
@@ -269,14 +269,14 @@ checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
 
 [[package]]
 name = "filetime"
-version = "0.2.25"
+version = "0.2.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "35c0522e981e68cbfa8c3f978441a5f34b30b96e146b33cd3359176b50fe8586"
+checksum = "bc0505cd1b6fa6580283f6bdf70a73fcf4aba1184038c90902b92b3dd0df63ed"
 dependencies = [
  "cfg-if",
  "libc",
  "libredox",
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -322,11 +322,11 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "home"
-version = "0.5.9"
+version = "0.5.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3d1354bf6b7235cb4a0576c2619fd4ed18183f689b12b006a0ee7329eeff9a5"
+checksum = "589533453244b0995c858700322199b2becb13b627df2851f64a2775d024abcf"
 dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -364,12 +364,12 @@ checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
 [[package]]
 name = "junction"
-version = "1.2.0"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72bbdfd737a243da3dfc1f99ee8d6e166480f17ab4ac84d7c34aacd73fc7bd16"
+checksum = "c52f6e1bf39a7894f618c9d378904a11dbd7e10fe3ec20d1173600e79b1408d8"
 dependencies = [
  "scopeguard",
- "windows-sys 0.52.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -433,6 +433,15 @@ version = "2.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 
+[[package]]
+name = "normpath"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8911957c4b1549ac0dc74e30db9c8b0e66ddcd6d7acc33098f4c63a64a6d7ed"
+dependencies = [
+ "windows-sys 0.59.0",
+]
+
 [[package]]
 name = "ntapi"
 version = "0.4.1"
@@ -497,12 +506,13 @@ checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775"
 
 [[package]]
 name = "opener"
-version = "0.5.2"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "293c15678e37254c15bd2f092314abb4e51d7fdde05c2021279c12631b54f005"
+checksum = "771b9704f8cd8b424ec747a320b30b47517a6966ba2c7da90047c16f4a962223"
 dependencies = [
  "bstr",
- "winapi",
+ "normpath",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -757,15 +767,15 @@ dependencies = [
 
 [[package]]
 name = "tempfile"
-version = "3.19.0"
+version = "3.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "488960f40a3fd53d72c2a29a58722561dee8afdd175bd88e3db4677d7b2ba600"
+checksum = "15b61f8f20e3a6f7e0649d825294eaf317edce30f82cf6026e7e4cb9222a7d1e"
 dependencies = [
  "fastrand",
  "getrandom",
  "once_cell",
  "rustix",
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -929,11 +939,11 @@ checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
 [[package]]
 name = "winapi-util"
-version = "0.1.9"
+version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
+checksum = "0978bf7171b3d90bac376700cb56d606feb40f251a475a5d6634613564460b22"
 dependencies = [
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -1045,20 +1055,20 @@ dependencies = [
 
 [[package]]
 name = "windows-sys"
-version = "0.52.0"
+version = "0.59.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
 dependencies = [
- "windows-targets",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
 name = "windows-sys"
-version = "0.59.0"
+version = "0.60.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
 dependencies = [
- "windows-targets",
+ "windows-targets 0.53.2",
 ]
 
 [[package]]
@@ -1067,14 +1077,30 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
 dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_gnullvm",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm 0.52.6",
+ "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]]
+name = "windows-targets"
+version = "0.53.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c66f69fcc9ce11da9966ddb31a40968cad001c5bedeb5c2b82ede4253ab48aef"
+dependencies = [
+ "windows_aarch64_gnullvm 0.53.0",
+ "windows_aarch64_msvc 0.53.0",
+ "windows_i686_gnu 0.53.0",
+ "windows_i686_gnullvm 0.53.0",
+ "windows_i686_msvc 0.53.0",
+ "windows_x86_64_gnu 0.53.0",
+ "windows_x86_64_gnullvm 0.53.0",
+ "windows_x86_64_msvc 0.53.0",
 ]
 
 [[package]]
@@ -1083,48 +1109,96 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764"
+
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c"
+
 [[package]]
 name = "windows_i686_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3"
+
 [[package]]
 name = "windows_i686_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11"
+
 [[package]]
 name = "windows_i686_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d"
+
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba"
+
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57"
+
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
+
 [[package]]
 name = "wit-bindgen-rt"
 version = "0.39.0"
diff --git a/src/bootstrap/Cargo.toml b/src/bootstrap/Cargo.toml
index c717558446544..9a76a7dda2ac3 100644
--- a/src/bootstrap/Cargo.toml
+++ b/src/bootstrap/Cargo.toml
@@ -42,7 +42,7 @@ home = "0.5"
 ignore = "0.4"
 libc = "0.2"
 object = { version = "0.36.3", default-features = false, features = ["archive", "coff", "read_core", "std", "unaligned"] }
-opener = "0.5"
+opener = "0.8"
 semver = "1.0"
 serde = "1.0"
 # Directly use serde_derive rather than through the derive feature of serde to allow building both
@@ -67,7 +67,7 @@ tracing-subscriber = { version = "0.3", optional = true, features = ["env-filter
 tempfile = { version = "3.15.0", optional = true }
 
 [target.'cfg(windows)'.dependencies.junction]
-version = "1.0.0"
+version = "1.3.0"
 
 [target.'cfg(windows)'.dependencies.windows]
 version = "0.61"

From f3650b8b92b612d9ba8fcb6d7b16fd7ed424842f Mon Sep 17 00:00:00 2001
From: Kumar Ujjawal <ujjawalpathak6@gmail.com>
Date: Thu, 4 Sep 2025 00:03:54 +0530
Subject: [PATCH 0466/1889] fix: offline rustdoc html missing favicon

---
 src/bootstrap/src/core/build_steps/doc.rs | 25 +++++++++++++++++++++++
 src/doc/favicon.inc                       |  3 ++-
 src/doc/redirect.inc                      |  3 ++-
 3 files changed, 29 insertions(+), 2 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/doc.rs b/src/bootstrap/src/core/build_steps/doc.rs
index 0789eefa89460..645bd06679ac1 100644
--- a/src/bootstrap/src/core/build_steps/doc.rs
+++ b/src/bootstrap/src/core/build_steps/doc.rs
@@ -575,6 +575,31 @@ impl Step for SharedAssets {
             FileType::Regular,
         );
 
+        builder.copy_link(
+            &builder
+                .src
+                .join("src")
+                .join("librustdoc")
+                .join("html")
+                .join("static")
+                .join("images")
+                .join("favicon.svg"),
+            &out.join("favicon.svg"),
+            FileType::Regular,
+        );
+        builder.copy_link(
+            &builder
+                .src
+                .join("src")
+                .join("librustdoc")
+                .join("html")
+                .join("static")
+                .join("images")
+                .join("favicon-32x32.png"),
+            &out.join("favicon-32x32.png"),
+            FileType::Regular,
+        );
+
         SharedAssetsPaths { version_info }
     }
 }
diff --git a/src/doc/favicon.inc b/src/doc/favicon.inc
index 9c330685209be..f09498cc09583 100644
--- a/src/doc/favicon.inc
+++ b/src/doc/favicon.inc
@@ -1 +1,2 @@
-<link rel="icon" href="https://www.rust-lang.org/favicon.ico">
+<link rel="alternate icon" type="image/png" href="favicon-32x32.png">
+<link rel="icon" type="image/svg+xml" href="favicon.svg">
diff --git a/src/doc/redirect.inc b/src/doc/redirect.inc
index 2fb44be014515..1b7d3744b1fdc 100644
--- a/src/doc/redirect.inc
+++ b/src/doc/redirect.inc
@@ -1,2 +1,3 @@
 <meta name="robots" content="noindex,follow">
-<link rel="icon" href="https://www.rust-lang.org/favicon.ico">
+<link rel="alternate icon" type="image/png" href="../favicon-32x32.png">
+<link rel="icon" type="image/svg+xml" href="../favicon.svg">

From c914c471b9d83f9e6c74b0e6c2c8044efd3a57dd Mon Sep 17 00:00:00 2001
From: Niklas Fiekas <niklas.fiekas@backscattering.de>
Date: Tue, 29 Apr 2025 14:30:53 +0200
Subject: [PATCH 0467/1889] Add `read_buf` equivalents for positioned reads

Adds the following items under the `read_buf_at` feature:

 - `std::os::unix::fs::FileExt::read_buf_at`
 - `std::os::unix::fs::FileExt::read_buf_exact_at`
 - `std::os::windows::fs::FileExt::seek_read_buf`
---
 library/std/src/fs/tests.rs               | 112 ++++++++++++++++++++++
 library/std/src/lib.rs                    |   1 +
 library/std/src/os/unix/fs.rs             |  89 +++++++++++++++++
 library/std/src/os/windows/fs.rs          |  43 +++++++++
 library/std/src/sys/fd/unix.rs            |  65 ++++++++-----
 library/std/src/sys/fs/unix.rs            |   4 +
 library/std/src/sys/fs/windows.rs         |   4 +
 library/std/src/sys/pal/windows/handle.rs |  13 +++
 8 files changed, 308 insertions(+), 23 deletions(-)

diff --git a/library/std/src/fs/tests.rs b/library/std/src/fs/tests.rs
index c81e3af2f0d4c..1f5f848b9d406 100644
--- a/library/std/src/fs/tests.rs
+++ b/library/std/src/fs/tests.rs
@@ -490,6 +490,85 @@ fn file_test_io_read_write_at() {
     check!(fs::remove_file(&filename));
 }
 
+#[test]
+#[cfg(unix)]
+fn test_read_buf_at() {
+    use crate::os::unix::fs::FileExt;
+
+    let tmpdir = tmpdir();
+    let filename = tmpdir.join("file_rt_io_file_test_read_buf_at.txt");
+    {
+        let oo = OpenOptions::new().create_new(true).write(true).read(true).clone();
+        let mut file = check!(oo.open(&filename));
+        check!(file.write_all(b"0123456789"));
+    }
+    {
+        let mut file = check!(File::open(&filename));
+        let mut buf: [MaybeUninit<u8>; 5] = [MaybeUninit::uninit(); 5];
+        let mut buf = BorrowedBuf::from(buf.as_mut_slice());
+
+        // Fill entire buffer with potentially short reads
+        while buf.unfilled().capacity() > 0 {
+            let len = buf.len();
+            check!(file.read_buf_at(buf.unfilled(), 2 + len as u64));
+            assert!(!buf.filled().is_empty());
+            assert!(b"23456".starts_with(buf.filled()));
+            assert_eq!(check!(file.stream_position()), 0);
+        }
+        assert_eq!(buf.filled(), b"23456");
+
+        // Already full
+        check!(file.read_buf_at(buf.unfilled(), 3));
+        check!(file.read_buf_at(buf.unfilled(), 10));
+        assert_eq!(buf.filled(), b"23456");
+        assert_eq!(check!(file.stream_position()), 0);
+
+        // Read past eof is noop
+        check!(file.read_buf_at(buf.clear().unfilled(), 10));
+        assert_eq!(buf.filled(), b"");
+        check!(file.read_buf_at(buf.clear().unfilled(), 11));
+        assert_eq!(buf.filled(), b"");
+        assert_eq!(check!(file.stream_position()), 0);
+    }
+    check!(fs::remove_file(&filename));
+}
+
+#[test]
+#[cfg(unix)]
+fn test_read_buf_exact_at() {
+    use crate::os::unix::fs::FileExt;
+
+    let tmpdir = tmpdir();
+    let filename = tmpdir.join("file_rt_io_file_test_read_buf_exact_at.txt");
+    {
+        let oo = OpenOptions::new().create_new(true).write(true).read(true).clone();
+        let mut file = check!(oo.open(&filename));
+        check!(file.write_all(b"0123456789"));
+    }
+    {
+        let mut file = check!(File::open(&filename));
+        let mut buf: [MaybeUninit<u8>; 5] = [MaybeUninit::uninit(); 5];
+        let mut buf = BorrowedBuf::from(buf.as_mut_slice());
+
+        // Exact read
+        check!(file.read_buf_exact_at(buf.unfilled(), 2));
+        assert_eq!(buf.filled(), b"23456");
+        assert_eq!(check!(file.stream_position()), 0);
+
+        // Already full
+        check!(file.read_buf_exact_at(buf.unfilled(), 3));
+        check!(file.read_buf_exact_at(buf.unfilled(), 10));
+        assert_eq!(buf.filled(), b"23456");
+        assert_eq!(check!(file.stream_position()), 0);
+
+        // Non-empty exact read past eof fails
+        let err = file.read_buf_exact_at(buf.clear().unfilled(), 6).unwrap_err();
+        assert_eq!(err.kind(), ErrorKind::UnexpectedEof);
+        assert_eq!(check!(file.stream_position()), 0);
+    }
+    check!(fs::remove_file(&filename));
+}
+
 #[test]
 #[cfg(unix)]
 fn set_get_unix_permissions() {
@@ -566,6 +645,39 @@ fn file_test_io_seek_read_write() {
     check!(fs::remove_file(&filename));
 }
 
+#[test]
+#[cfg(windows)]
+fn test_seek_read_buf() {
+    use crate::os::windows::fs::FileExt;
+
+    let tmpdir = tmpdir();
+    let filename = tmpdir.join("file_rt_io_file_test_seek_read_buf.txt");
+    {
+        let oo = OpenOptions::new().create_new(true).write(true).read(true).clone();
+        let mut file = check!(oo.open(&filename));
+        check!(file.write_all(b"0123456789"));
+    }
+    {
+        let mut file = check!(File::open(&filename));
+        let mut buf: [MaybeUninit<u8>; 1] = [MaybeUninit::uninit()];
+        let mut buf = BorrowedBuf::from(buf.as_mut_slice());
+
+        // Seek read
+        check!(file.seek_read_buf(buf.unfilled(), 8));
+        assert_eq!(buf.filled(), b"8");
+        assert_eq!(check!(file.stream_position()), 9);
+
+        // Empty seek read
+        check!(file.seek_read_buf(buf.unfilled(), 0));
+        assert_eq!(buf.filled(), b"8");
+
+        // Seek read past eof
+        check!(file.seek_read_buf(buf.clear().unfilled(), 10));
+        assert_eq!(buf.filled(), b"");
+    }
+    check!(fs::remove_file(&filename));
+}
+
 #[test]
 fn file_test_read_buf() {
     let tmpdir = tmpdir();
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index f111fcb4a4712..c27167767a224 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -330,6 +330,7 @@
 #![feature(bstr)]
 #![feature(bstr_internals)]
 #![feature(cast_maybe_uninit)]
+#![feature(cfg_select)]
 #![feature(char_internals)]
 #![feature(clone_to_uninit)]
 #![feature(const_cmp)]
diff --git a/library/std/src/os/unix/fs.rs b/library/std/src/os/unix/fs.rs
index b776df3dde1da..1d1a138b30250 100644
--- a/library/std/src/os/unix/fs.rs
+++ b/library/std/src/os/unix/fs.rs
@@ -11,6 +11,7 @@ use super::platform::fs::MetadataExt as _;
 // Used for `File::read` on intra-doc links
 use crate::ffi::OsStr;
 use crate::fs::{self, OpenOptions, Permissions};
+use crate::io::BorrowedCursor;
 use crate::os::unix::io::{AsFd, AsRawFd};
 use crate::path::Path;
 use crate::sealed::Sealed;
@@ -130,6 +131,91 @@ pub trait FileExt {
         if !buf.is_empty() { Err(io::Error::READ_EXACT_EOF) } else { Ok(()) }
     }
 
+    /// Reads some bytes starting from a given offset into the buffer.
+    ///
+    /// This equivalent to the [`read_at`](FileExt::read_at) method, except that it is passed a
+    /// [`BorrowedCursor`] rather than `&mut [u8]` to allow use with uninitialized buffers. The new
+    /// data will be appended to any existing contents of `buf`.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// #![feature(core_io_borrowed_buf)]
+    /// #![feature(read_buf_at)]
+    ///
+    /// use std::io;
+    /// use std::io::BorrowedBuf;
+    /// use std::fs::File;
+    /// use std::mem::MaybeUninit;
+    /// use std::os::unix::prelude::*;
+    ///
+    /// fn main() -> io::Result<()> {
+    ///     let mut file = File::open("pi.txt")?;
+    ///
+    ///     // Read some bytes starting from offset 2
+    ///     let mut buf: [MaybeUninit<u8>; 10] = [MaybeUninit::uninit(); 10];
+    ///     let mut buf = BorrowedBuf::from(buf.as_mut_slice());
+    ///     file.read_buf_at(buf.unfilled(), 2)?;
+    ///
+    ///     assert!(buf.filled().starts_with(b"1"));
+    ///
+    ///     Ok(())
+    /// }
+    /// ```
+    #[unstable(feature = "read_buf_at", issue = "140771")]
+    fn read_buf_at(&self, buf: BorrowedCursor<'_>, offset: u64) -> io::Result<()> {
+        io::default_read_buf(|b| self.read_at(b, offset), buf)
+    }
+
+    /// Reads the exact number of bytes required to fill the buffer from a given offset.
+    ///
+    /// This is equivalent to the [`read_exact_at`](FileExt::read_exact_at) method, except that it
+    /// is passed a [`BorrowedCursor`] rather than `&mut [u8]` to allow use with uninitialized
+    /// buffers. The new data will be appended to any existing contents of `buf`.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// #![feature(core_io_borrowed_buf)]
+    /// #![feature(read_buf_at)]
+    ///
+    /// use std::io;
+    /// use std::io::BorrowedBuf;
+    /// use std::fs::File;
+    /// use std::mem::MaybeUninit;
+    /// use std::os::unix::prelude::*;
+    ///
+    /// fn main() -> io::Result<()> {
+    ///     let mut file = File::open("pi.txt")?;
+    ///
+    ///     // Read exactly 10 bytes starting from offset 2
+    ///     let mut buf: [MaybeUninit<u8>; 10] = [MaybeUninit::uninit(); 10];
+    ///     let mut buf = BorrowedBuf::from(buf.as_mut_slice());
+    ///     file.read_buf_exact_at(buf.unfilled(), 2)?;
+    ///
+    ///     assert_eq!(buf.filled(), b"1415926535");
+    ///
+    ///     Ok(())
+    /// }
+    /// ```
+    #[unstable(feature = "read_buf_at", issue = "140771")]
+    fn read_buf_exact_at(&self, mut buf: BorrowedCursor<'_>, mut offset: u64) -> io::Result<()> {
+        while buf.capacity() > 0 {
+            let prev_written = buf.written();
+            match self.read_buf_at(buf.reborrow(), offset) {
+                Ok(()) => {}
+                Err(e) if e.is_interrupted() => {}
+                Err(e) => return Err(e),
+            }
+            let n = buf.written() - prev_written;
+            offset += n as u64;
+            if n == 0 {
+                return Err(io::Error::READ_EXACT_EOF);
+            }
+        }
+        Ok(())
+    }
+
     /// Writes a number of bytes starting from a given offset.
     ///
     /// Returns the number of bytes written.
@@ -264,6 +350,9 @@ impl FileExt for fs::File {
     fn read_at(&self, buf: &mut [u8], offset: u64) -> io::Result<usize> {
         self.as_inner().read_at(buf, offset)
     }
+    fn read_buf_at(&self, buf: BorrowedCursor<'_>, offset: u64) -> io::Result<()> {
+        self.as_inner().read_buf_at(buf, offset)
+    }
     fn read_vectored_at(&self, bufs: &mut [io::IoSliceMut<'_>], offset: u64) -> io::Result<usize> {
         self.as_inner().read_vectored_at(bufs, offset)
     }
diff --git a/library/std/src/os/windows/fs.rs b/library/std/src/os/windows/fs.rs
index ddb8dbd8feea2..b445f368aeb12 100644
--- a/library/std/src/os/windows/fs.rs
+++ b/library/std/src/os/windows/fs.rs
@@ -5,6 +5,7 @@
 #![stable(feature = "rust1", since = "1.0.0")]
 
 use crate::fs::{self, Metadata, OpenOptions};
+use crate::io::BorrowedCursor;
 use crate::path::Path;
 use crate::sealed::Sealed;
 use crate::sys_common::{AsInner, AsInnerMut, IntoInner};
@@ -49,6 +50,44 @@ pub trait FileExt {
     #[stable(feature = "file_offset", since = "1.15.0")]
     fn seek_read(&self, buf: &mut [u8], offset: u64) -> io::Result<usize>;
 
+    /// Seeks to a given position and reads some bytes into the buffer.
+    ///
+    /// This is equivalent to the [`seek_read`](FileExt::seek_read) method, except that it is passed
+    /// a [`BorrowedCursor`] rather than `&mut [u8]` to allow use with uninitialized buffers. The
+    /// new data will be appended to any existing contents of `buf`.
+    ///
+    /// Reading beyond the end of the file will always succeed without reading any bytes.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// #![feature(core_io_borrowed_buf)]
+    /// #![feature(read_buf_at)]
+    ///
+    /// use std::io;
+    /// use std::io::BorrowedBuf;
+    /// use std::fs::File;
+    /// use std::mem::MaybeUninit;
+    /// use std::os::windows::prelude::*;
+    ///
+    /// fn main() -> io::Result<()> {
+    ///     let mut file = File::open("pi.txt")?;
+    ///
+    ///     // Read some bytes starting from offset 2
+    ///     let mut buf: [MaybeUninit<u8>; 10] = [MaybeUninit::uninit(); 10];
+    ///     let mut buf = BorrowedBuf::from(buf.as_mut_slice());
+    ///     file.seek_read_buf(buf.unfilled(), 2)?;
+    ///
+    ///     assert!(buf.filled().starts_with(b"1"));
+    ///
+    ///     Ok(())
+    /// }
+    /// ```
+    #[unstable(feature = "read_buf_at", issue = "140771")]
+    fn seek_read_buf(&self, buf: BorrowedCursor<'_>, offset: u64) -> io::Result<()> {
+        io::default_read_buf(|b| self.seek_read(b, offset), buf)
+    }
+
     /// Seeks to a given position and writes a number of bytes.
     ///
     /// Returns the number of bytes written.
@@ -89,6 +128,10 @@ impl FileExt for fs::File {
         self.as_inner().read_at(buf, offset)
     }
 
+    fn seek_read_buf(&self, buf: BorrowedCursor<'_>, offset: u64) -> io::Result<()> {
+        self.as_inner().read_buf_at(buf, offset)
+    }
+
     fn seek_write(&self, buf: &[u8], offset: u64) -> io::Result<usize> {
         self.as_inner().write_at(buf, offset)
     }
diff --git a/library/std/src/sys/fd/unix.rs b/library/std/src/sys/fd/unix.rs
index cdca73cdca11e..1701bac31133b 100644
--- a/library/std/src/sys/fd/unix.rs
+++ b/library/std/src/sys/fd/unix.rs
@@ -18,6 +18,21 @@ use libc::off_t as off64_t;
 ))]
 use libc::off64_t;
 
+cfg_select! {
+    any(
+        all(target_os = "linux", not(target_env = "musl")),
+        target_os = "android",
+        target_os = "hurd",
+    ) => {
+        // Prefer explicit pread64 for 64-bit offset independently of libc
+        // #[cfg(gnu_file_offset_bits64)].
+        use libc::pread64;
+    }
+    _ => {
+        use libc::pread as pread64;
+    }
+}
+
 use crate::cmp;
 use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut, Read};
 use crate::os::unix::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd};
@@ -146,42 +161,47 @@ impl FileDesc {
         (&mut me).read_to_end(buf)
     }
 
-    #[cfg_attr(target_os = "vxworks", allow(unused_unsafe))]
     pub fn read_at(&self, buf: &mut [u8], offset: u64) -> io::Result<usize> {
-        #[cfg(not(any(
-            all(target_os = "linux", not(target_env = "musl")),
-            target_os = "android",
-            target_os = "hurd"
-        )))]
-        use libc::pread as pread64;
-        #[cfg(any(
-            all(target_os = "linux", not(target_env = "musl")),
-            target_os = "android",
-            target_os = "hurd"
-        ))]
-        use libc::pread64;
-
-        unsafe {
-            cvt(pread64(
+        cvt(unsafe {
+            pread64(
                 self.as_raw_fd(),
                 buf.as_mut_ptr() as *mut libc::c_void,
                 cmp::min(buf.len(), READ_LIMIT),
-                offset as off64_t,
-            ))
-            .map(|n| n as usize)
-        }
+                offset as off64_t, // EINVAL if offset + count overflows
+            )
+        })
+        .map(|n| n as usize)
     }
 
     pub fn read_buf(&self, mut cursor: BorrowedCursor<'_>) -> io::Result<()> {
+        // SAFETY: `cursor.as_mut()` starts with `cursor.capacity()` writable bytes
         let ret = cvt(unsafe {
             libc::read(
                 self.as_raw_fd(),
-                cursor.as_mut().as_mut_ptr() as *mut libc::c_void,
+                cursor.as_mut().as_mut_ptr().cast::<libc::c_void>(),
+                cmp::min(cursor.capacity(), READ_LIMIT),
+            )
+        })?;
+
+        // SAFETY: `ret` bytes were written to the initialized portion of the buffer
+        unsafe {
+            cursor.advance_unchecked(ret as usize);
+        }
+        Ok(())
+    }
+
+    pub fn read_buf_at(&self, mut cursor: BorrowedCursor<'_>, offset: u64) -> io::Result<()> {
+        // SAFETY: `cursor.as_mut()` starts with `cursor.capacity()` writable bytes
+        let ret = cvt(unsafe {
+            pread64(
+                self.as_raw_fd(),
+                cursor.as_mut().as_mut_ptr().cast::<libc::c_void>(),
                 cmp::min(cursor.capacity(), READ_LIMIT),
+                offset as off64_t, // EINVAL if offset + count overflows
             )
         })?;
 
-        // Safety: `ret` bytes were written to the initialized portion of the buffer
+        // SAFETY: `ret` bytes were written to the initialized portion of the buffer
         unsafe {
             cursor.advance_unchecked(ret as usize);
         }
@@ -369,7 +389,6 @@ impl FileDesc {
         )))
     }
 
-    #[cfg_attr(target_os = "vxworks", allow(unused_unsafe))]
     pub fn write_at(&self, buf: &[u8], offset: u64) -> io::Result<usize> {
         #[cfg(not(any(
             all(target_os = "linux", not(target_env = "musl")),
diff --git a/library/std/src/sys/fs/unix.rs b/library/std/src/sys/fs/unix.rs
index b310db2dac485..30be6d445ff77 100644
--- a/library/std/src/sys/fs/unix.rs
+++ b/library/std/src/sys/fs/unix.rs
@@ -1422,6 +1422,10 @@ impl File {
         self.0.read_buf(cursor)
     }
 
+    pub fn read_buf_at(&self, cursor: BorrowedCursor<'_>, offset: u64) -> io::Result<()> {
+        self.0.read_buf_at(cursor, offset)
+    }
+
     pub fn read_vectored_at(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::Result<usize> {
         self.0.read_vectored_at(bufs, offset)
     }
diff --git a/library/std/src/sys/fs/windows.rs b/library/std/src/sys/fs/windows.rs
index bb3e4bc30ca95..c39571af693c0 100644
--- a/library/std/src/sys/fs/windows.rs
+++ b/library/std/src/sys/fs/windows.rs
@@ -587,6 +587,10 @@ impl File {
         self.handle.read_buf(cursor)
     }
 
+    pub fn read_buf_at(&self, cursor: BorrowedCursor<'_>, offset: u64) -> io::Result<()> {
+        self.handle.read_buf_at(cursor, offset)
+    }
+
     pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
         self.handle.write(buf)
     }
diff --git a/library/std/src/sys/pal/windows/handle.rs b/library/std/src/sys/pal/windows/handle.rs
index 82a880faf5fa7..76c8aa939d3b2 100644
--- a/library/std/src/sys/pal/windows/handle.rs
+++ b/library/std/src/sys/pal/windows/handle.rs
@@ -136,6 +136,19 @@ impl Handle {
         }
     }
 
+    pub fn read_buf_at(&self, mut cursor: BorrowedCursor<'_>, offset: u64) -> io::Result<()> {
+        // SAFETY: `cursor.as_mut()` starts with `cursor.capacity()` writable bytes
+        let read = unsafe {
+            self.synchronous_read(cursor.as_mut().as_mut_ptr(), cursor.capacity(), Some(offset))
+        }?;
+
+        // SAFETY: `read` bytes were written to the initialized portion of the buffer
+        unsafe {
+            cursor.advance_unchecked(read);
+        }
+        Ok(())
+    }
+
     pub fn read_to_end(&self, buf: &mut Vec<u8>) -> io::Result<usize> {
         let mut me = self;
 

From 86670347189962f15061404526acab2a6bb0da8f Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 3 Sep 2025 21:22:43 +0200
Subject: [PATCH 0468/1889] fix applying an error to infinities

---
 src/tools/miri/src/math.rs         | 4 ++++
 src/tools/miri/tests/pass/float.rs | 4 ++++
 2 files changed, 8 insertions(+)

diff --git a/src/tools/miri/src/math.rs b/src/tools/miri/src/math.rs
index 604d6c0fd732b..6427f3ca6e9b0 100644
--- a/src/tools/miri/src/math.rs
+++ b/src/tools/miri/src/math.rs
@@ -15,6 +15,8 @@ pub(crate) fn apply_random_float_error<F: rustc_apfloat::Float>(
         || matches!(ecx.machine.float_rounding_error, FloatRoundingErrorMode::None)
         // relative errors don't do anything to zeros... avoid messing up the sign
         || val.is_zero()
+        // The logic below makes no sense if the input is already non-finite.
+        || !val.is_finite()
     {
         return val;
     }
@@ -54,6 +56,8 @@ pub(crate) fn apply_random_float_error_ulp<F: rustc_apfloat::Float>(
         // FIXME: also disturb zeros? That requires a lot more cases in `fixed_float_value`
         // and might make the std test suite quite unhappy.
         || val.is_zero()
+        // The logic below makes no sense if the input is already non-finite.
+        || !val.is_finite()
     {
         return val;
     }
diff --git a/src/tools/miri/tests/pass/float.rs b/src/tools/miri/tests/pass/float.rs
index 2be262d76a46e..1b1163c77978e 100644
--- a/src/tools/miri/tests/pass/float.rs
+++ b/src/tools/miri/tests/pass/float.rs
@@ -1052,6 +1052,10 @@ pub fn libm() {
     assert_eq!(42f64.powf(0.0), 1.0);
     assert_eq!(f32::INFINITY.powf(0.0), 1.0);
     assert_eq!(f64::INFINITY.powf(0.0), 1.0);
+    assert_eq!(f32::NEG_INFINITY.powi(3), f32::NEG_INFINITY);
+    assert_eq!(f32::NEG_INFINITY.powi(2), f32::INFINITY);
+    assert_eq!(f64::INFINITY.powi(3), f64::INFINITY);
+    assert_eq!(f64::INFINITY.powi(2), f64::INFINITY);
 
     // f*::NAN is a quiet NAN and should return 1 as well.
     assert_eq!(f32::NAN.powi(0), 1.0);

From fea27a665c76996a90d5e19e38c9ddabd11a6512 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 3 Sep 2025 21:33:31 +0200
Subject: [PATCH 0469/1889] triagebot: configure some pings when certain
 attributes are used

---
 triagebot.toml | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/triagebot.toml b/triagebot.toml
index cf2e95203fa40..fd6329de923b6 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -1306,6 +1306,21 @@ cc = ["@m-ou-se"]
 [mentions."compiler/rustc_ast_lowering/src/format.rs"]
 cc = ["@m-ou-se"]
 
+[mentions."#[miri::intrinsic_fallback_is_spec]"]
+type = "content"
+message = """
+`#[miri::intrinsic_fallback_is_spec]` must only be used if the function actively checks for all UB cases,
+and explores the possible non-determinism of the intrinsic.
+"""
+cc = ["@rust-lang/miri"]
+[mentions."#[rustc_allow_const_fn_unstable]"]
+type = "content"
+message = """
+`#[rustc_allow_const_fn_unstable]` needs careful audit to avoid accidentally exposing unstable
+implementation details on stable.
+"""
+cc = ["@rust-lang/wg-const-eval"]
+
 
 # ------------------------------------------------------------------------------
 # PR assignments

From 9adc741bc4216d9f7c99ba25946372b7124db8b1 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Wed, 3 Sep 2025 21:46:06 +0200
Subject: [PATCH 0470/1889] rename primary git branch

---
 src/doc/rustc-dev-guide/.github/workflows/ci.yml         | 2 +-
 src/doc/rustc-dev-guide/.github/workflows/rustc-pull.yml | 2 +-
 src/doc/rustc-dev-guide/book.toml                        | 2 +-
 src/doc/rustc-dev-guide/ci/linkcheck.sh                  | 2 +-
 src/doc/rustc-dev-guide/src/rustc-driver/intro.md        | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/doc/rustc-dev-guide/.github/workflows/ci.yml b/src/doc/rustc-dev-guide/.github/workflows/ci.yml
index 2dd695b7a4733..79d03080dce38 100644
--- a/src/doc/rustc-dev-guide/.github/workflows/ci.yml
+++ b/src/doc/rustc-dev-guide/.github/workflows/ci.yml
@@ -3,7 +3,7 @@ name: CI
 on:
   push:
     branches:
-      - master
+      - main
   pull_request:
   schedule:
     # Run multiple times a day as the successfull cached links are not checked every time.
diff --git a/src/doc/rustc-dev-guide/.github/workflows/rustc-pull.yml b/src/doc/rustc-dev-guide/.github/workflows/rustc-pull.yml
index 5ff3118960da6..fd21b149db8f1 100644
--- a/src/doc/rustc-dev-guide/.github/workflows/rustc-pull.yml
+++ b/src/doc/rustc-dev-guide/.github/workflows/rustc-pull.yml
@@ -14,7 +14,7 @@ jobs:
       github-app-id: ${{ vars.APP_CLIENT_ID }}
       zulip-stream-id: 196385
       zulip-bot-email:  "rustc-dev-guide-gha-notif-bot@rust-lang.zulipchat.com"
-      pr-base-branch: master
+      pr-base-branch: main
       branch-name: rustc-pull
     secrets:
       zulip-api-token: ${{ secrets.ZULIP_API_TOKEN }}
diff --git a/src/doc/rustc-dev-guide/book.toml b/src/doc/rustc-dev-guide/book.toml
index daf237ed9081b..efb13101c8de2 100644
--- a/src/doc/rustc-dev-guide/book.toml
+++ b/src/doc/rustc-dev-guide/book.toml
@@ -11,7 +11,7 @@ command = "mdbook-mermaid"
 
 [output.html]
 git-repository-url = "https://github.com/rust-lang/rustc-dev-guide"
-edit-url-template = "https://github.com/rust-lang/rustc-dev-guide/edit/master/{path}"
+edit-url-template = "https://github.com/rust-lang/rustc-dev-guide/edit/main/{path}"
 additional-js = [
   "mermaid.min.js",
   "mermaid-init.js",
diff --git a/src/doc/rustc-dev-guide/ci/linkcheck.sh b/src/doc/rustc-dev-guide/ci/linkcheck.sh
index e5184839be02f..867b427eafbbe 100755
--- a/src/doc/rustc-dev-guide/ci/linkcheck.sh
+++ b/src/doc/rustc-dev-guide/ci/linkcheck.sh
@@ -32,7 +32,7 @@ elif [ "$GITHUB_EVENT_NAME" = "pull_request" ] ; then # running in PR CI build
 
   echo "Checking files changed since $BASE_SHA: $CHANGED_FILES"
 else # running locally
-  COMMIT_RANGE=master...
+  COMMIT_RANGE=main...
   CHANGED_FILES=$(git diff --name-only $COMMIT_RANGE | sed 's#^src/##' | tr '\n' ' ')
   FLAGS="-f $CHANGED_FILES"
 
diff --git a/src/doc/rustc-dev-guide/src/rustc-driver/intro.md b/src/doc/rustc-dev-guide/src/rustc-driver/intro.md
index a3684397b2995..32d27d218197d 100644
--- a/src/doc/rustc-dev-guide/src/rustc-driver/intro.md
+++ b/src/doc/rustc-dev-guide/src/rustc-driver/intro.md
@@ -34,7 +34,7 @@ specifically [`rustc_driver_impl::run_compiler`][rdi_rc]
 [`rustc_driver`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_driver/
 [`rustc_interface`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_interface/index.html
 [`Callbacks`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_driver/trait.Callbacks.html
-[example]: https://github.com/rust-lang/rustc-dev-guide/blob/master/examples/rustc-interface-example.rs
+[example]: https://github.com/rust-lang/rustc-dev-guide/blob/main/examples/rustc-interface-example.rs
 [i_rc]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_interface/interface/fn.run_compiler.html
 [rd_rc]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_driver/fn.run_compiler.html
 [rdi_rc]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_driver_impl/fn.run_compiler.html

From 2d20ee73a84c03907610f652d7f9d5454b070c33 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 3 Sep 2025 21:55:24 +0200
Subject: [PATCH 0471/1889] support keyword-based mentions in tidy

---
 src/tools/tidy/src/triagebot.rs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/tools/tidy/src/triagebot.rs b/src/tools/tidy/src/triagebot.rs
index 305a0b4d26433..6f25ed616fac7 100644
--- a/src/tools/tidy/src/triagebot.rs
+++ b/src/tools/tidy/src/triagebot.rs
@@ -19,7 +19,12 @@ pub fn check(path: &Path, bad: &mut bool) {
 
     // Check [mentions."*"] sections, i.e. [mentions."compiler/rustc_const_eval/src/"]
     if let Some(Value::Table(mentions)) = config.get("mentions") {
-        for path_str in mentions.keys() {
+        for (entry_key, entry_val) in mentions.iter() {
+            // If the type is set to something other than "filename", then this is not a path.
+            if entry_val.get("type").is_some_and(|t| t.as_str().unwrap_or_default() != "filename") {
+                continue;
+            }
+            let path_str = entry_key;
             // Remove quotes from the path
             let clean_path = path_str.trim_matches('"');
             let full_path = path.join(clean_path);

From b7f3606a183bcf865dce31bbd76ce6171b062d68 Mon Sep 17 00:00:00 2001
From: Emmet Horgan <horgan098@gmail.com>
Date: Wed, 3 Sep 2025 23:29:54 +0100
Subject: [PATCH 0472/1889] Fix some broken links

Signed-off-by: Emmet Horgan <horgan098@gmail.com>
---
 src/doc/rustc-dev-guide/src/appendix/code-index.md |  2 +-
 src/doc/rustc-dev-guide/src/compiler-debugging.md  |  2 +-
 src/doc/rustc-dev-guide/src/hir.md                 |  2 +-
 src/doc/rustc-dev-guide/src/serialization.md       |  2 +-
 src/doc/rustc-dev-guide/src/tests/directives.md    | 10 +++++-----
 5 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/appendix/code-index.md b/src/doc/rustc-dev-guide/src/appendix/code-index.md
index 65fbf752d7921..0ad7244393523 100644
--- a/src/doc/rustc-dev-guide/src/appendix/code-index.md
+++ b/src/doc/rustc-dev-guide/src/appendix/code-index.md
@@ -13,7 +13,7 @@ Item            |  Kind    | Short description           | Chapter            |
 `DefId` | struct | One of four types of HIR node identifiers | [Identifiers in the HIR] | [compiler/rustc_hir/src/def_id.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/def_id/struct.DefId.html)
 `Diag` | struct | A struct for a compiler diagnostic, such as an error or lint | [Emitting Diagnostics] | [compiler/rustc_errors/src/diagnostic.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_errors/struct.Diag.html)
 `DocContext` | struct | A state container used by rustdoc when crawling through a crate to gather its documentation | [Rustdoc] | [src/librustdoc/core.rs](https://github.com/rust-lang/rust/blob/master/src/librustdoc/core.rs)
-`HirId` | struct | One of four types of HIR node identifiers | [Identifiers in the HIR] | [compiler/rustc_hir/src/hir_id.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/hir_id/struct.HirId.html)
+`HirId` | struct | One of four types of HIR node identifiers | [Identifiers in the HIR] | [compiler/rustc_hir/src/hir_id.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/struct.HirId.html)
 `Lexer` | struct | This is the lexer used during parsing. It consumes characters from the raw source code being compiled and produces a series of tokens for use by the rest of the parser | [The parser] |  [compiler/rustc_parse/src/lexer/mod.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_parse/lexer/struct.Lexer.html)
 `NodeId` | struct | One of four types of HIR node identifiers. Being phased out | [Identifiers in the HIR] | [compiler/rustc_ast/src/ast.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/node_id/struct.NodeId.html)
 `P` | struct | An owned immutable smart pointer. By contrast, `&T` is not owned, and `Box<T>` is not immutable. | None | [compiler/rustc_ast/src/ptr.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/ptr/struct.P.html)
diff --git a/src/doc/rustc-dev-guide/src/compiler-debugging.md b/src/doc/rustc-dev-guide/src/compiler-debugging.md
index edd2aa6c5f64b..5ceb5dfe811cc 100644
--- a/src/doc/rustc-dev-guide/src/compiler-debugging.md
+++ b/src/doc/rustc-dev-guide/src/compiler-debugging.md
@@ -367,7 +367,7 @@ error: layout_of(&'a u32) = Layout {
 error: aborting due to previous error
 ```
 
-[`Layout`]: https://doc.rust-lang.org/nightly/nightly-rustc/stable_mir/abi/struct.Layout.html
+[`Layout`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_abi/struct.Layout.html
 
 
 ## Configuring CodeLLDB for debugging `rustc`
diff --git a/src/doc/rustc-dev-guide/src/hir.md b/src/doc/rustc-dev-guide/src/hir.md
index 38ba33112f2ec..0b341a40f1ddb 100644
--- a/src/doc/rustc-dev-guide/src/hir.md
+++ b/src/doc/rustc-dev-guide/src/hir.md
@@ -102,7 +102,7 @@ These identifiers can be converted into one another through the `TyCtxt`.
 
 [`DefId`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/def_id/struct.DefId.html
 [`LocalDefId`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/def_id/struct.LocalDefId.html
-[`HirId`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/hir_id/struct.HirId.html
+[`HirId`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/struct.HirId.html
 [`BodyId`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/hir/struct.BodyId.html
 [Node]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/hir/enum.Node.html
 [`CrateNum`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/def_id/struct.CrateNum.html
diff --git a/src/doc/rustc-dev-guide/src/serialization.md b/src/doc/rustc-dev-guide/src/serialization.md
index 8eb37bbe20beb..702d3cfa6d5ee 100644
--- a/src/doc/rustc-dev-guide/src/serialization.md
+++ b/src/doc/rustc-dev-guide/src/serialization.md
@@ -106,7 +106,7 @@ type wrapper, like [`ty::Predicate`] and manually implementing `Encodable` and
 [`Encodable`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_serialize/trait.Encodable.html
 [`Encoder`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_serialize/trait.Encoder.html
 [`RefDecodable`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/codec/trait.RefDecodable.html
-[`rustc_middle`]: https://doc.rust-lang.org/nightly/nightly-rustc/src/rustc_type_ir/codec.rs.html#21
+[`rustc_middle`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/index.html
 [`ty::Predicate`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/predicate/struct.Predicate.html
 [`TyCtxt`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TyCtxt.html
 [`TyDecodable`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_macros/derive.TyDecodable.html
diff --git a/src/doc/rustc-dev-guide/src/tests/directives.md b/src/doc/rustc-dev-guide/src/tests/directives.md
index fbbeb7e97d3b7..c6d83e82ab196 100644
--- a/src/doc/rustc-dev-guide/src/tests/directives.md
+++ b/src/doc/rustc-dev-guide/src/tests/directives.md
@@ -38,7 +38,7 @@ sections that describe the command in more detail if available. This list may
 not be exhaustive. Directives can generally be found by browsing the
 `TestProps` structure found in [`header.rs`] from the compiletest source.
 
-[`header.rs`]: https://github.com/rust-lang/rust/tree/master/src/tools/compiletest/src/header.rs
+[`header.rs`]: https://github.com/rust-lang/rust/tree/master/src/tools/compiletest/src/directives.rs
 
 ### Assembly
 
@@ -374,7 +374,7 @@ the directive's backing store (holds the command's current value) at runtime.
 To add a new directive property:
 
 1. Look for the `pub struct TestProps` declaration in
-   [`src/tools/compiletest/src/header.rs`] and add the new public property to
+   [`src/tools/compiletest/src/directives.rs`] and add the new public property to
    the end of the declaration.
 2. Look for the `impl TestProps` implementation block immediately following the
    struct declaration and initialize the new property to its default value.
@@ -383,7 +383,7 @@ To add a new directive property:
 
 When `compiletest` encounters a test file, it parses the file a line at a time
 by calling every parser defined in the `Config` struct's implementation block,
-also in [`src/tools/compiletest/src/header.rs`] (note that the `Config` struct's
+also in [`src/tools/compiletest/src/directives.rs`] (note that the `Config` struct's
 declaration block is found in [`src/tools/compiletest/src/common.rs`]).
 `TestProps`'s `load_from()` method will try passing the current line of text to
 each parser, which, in turn typically checks to see if the line begins with a
@@ -406,7 +406,7 @@ and their associated parsers immediately above to see how they are used to avoid
 writing additional parsing code unnecessarily.
 
 As a concrete example, here is the implementation for the
-`parse_failure_status()` parser, in [`src/tools/compiletest/src/header.rs`]:
+`parse_failure_status()` parser, in [`src/tools/compiletest/src/directives.rs`]:
 
 ```diff
 @@ -232,6 +232,7 @@ pub struct TestProps {
@@ -508,6 +508,6 @@ example, `//@ failure-status: 1`, `self.props.failure_status` will evaluate to
 1, as `parse_failure_status()` will have overridden the `TestProps` default
 value, for that test specifically.
 
-[`src/tools/compiletest/src/header.rs`]: https://github.com/rust-lang/rust/tree/master/src/tools/compiletest/src/header.rs
+[`src/tools/compiletest/src/directives.rs`]: https://github.com/rust-lang/rust/tree/master/src/tools/compiletest/src/directives.rs
 [`src/tools/compiletest/src/common.rs`]: https://github.com/rust-lang/rust/tree/master/src/tools/compiletest/src/common.rs
 [`src/tools/compiletest/src/runtest.rs`]: https://github.com/rust-lang/rust/tree/master/src/tools/compiletest/src/runtest.rs

From 891523d0de6792c132e83c4833b678543ecf5d19 Mon Sep 17 00:00:00 2001
From: yanglsh <yanglsh@shanghaitech.edu.cn>
Date: Thu, 28 Aug 2025 07:17:06 +0800
Subject: [PATCH 0473/1889] fix: `read_zero_byte_vec` suggests wrongly inside
 `let` stmt

---
 clippy_lints/src/read_zero_byte_vec.rs | 27 ++++++++---
 tests/ui/read_zero_byte_vec.rs         | 27 +++++++++++
 tests/ui/read_zero_byte_vec.stderr     | 65 ++++++++++++++++++++++++--
 3 files changed, 109 insertions(+), 10 deletions(-)

diff --git a/clippy_lints/src/read_zero_byte_vec.rs b/clippy_lints/src/read_zero_byte_vec.rs
index acd840401c6bb..b8d4e7c4651d2 100644
--- a/clippy_lints/src/read_zero_byte_vec.rs
+++ b/clippy_lints/src/read_zero_byte_vec.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::{span_lint_hir, span_lint_hir_and_then};
 use clippy_utils::higher::{VecInitKind, get_vec_init_kind};
-use clippy_utils::source::snippet;
+use clippy_utils::source::{indent_of, snippet};
 use clippy_utils::{get_enclosing_block, sym};
 
 use rustc_errors::Applicability;
@@ -83,10 +83,12 @@ impl<'tcx> LateLintPass<'tcx> for ReadZeroByteVec {
                             expr.span,
                             "reading zero byte data to `Vec`",
                             |diag| {
+                                let span = first_stmt_containing_expr(cx, expr).map_or(expr.span, |stmt| stmt.span);
+                                let indent = indent_of(cx, span).unwrap_or(0);
                                 diag.span_suggestion(
-                                    expr.span,
+                                    span.shrink_to_lo(),
                                     "try",
-                                    format!("{}.resize({len}, 0); {}", ident, snippet(cx, expr.span, "..")),
+                                    format!("{ident}.resize({len}, 0);\n{}", " ".repeat(indent)),
                                     applicability,
                                 );
                             },
@@ -100,14 +102,15 @@ impl<'tcx> LateLintPass<'tcx> for ReadZeroByteVec {
                                 expr.span,
                                 "reading zero byte data to `Vec`",
                                 |diag| {
+                                    let span = first_stmt_containing_expr(cx, expr).map_or(expr.span, |stmt| stmt.span);
+                                    let indent = indent_of(cx, span).unwrap_or(0);
                                     diag.span_suggestion(
-                                        expr.span,
+                                        span.shrink_to_lo(),
                                         "try",
                                         format!(
-                                            "{}.resize({}, 0); {}",
-                                            ident,
+                                            "{ident}.resize({}, 0);\n{}",
                                             snippet(cx, e.span, ".."),
-                                            snippet(cx, expr.span, "..")
+                                            " ".repeat(indent)
                                         ),
                                         applicability,
                                     );
@@ -130,6 +133,16 @@ impl<'tcx> LateLintPass<'tcx> for ReadZeroByteVec {
     }
 }
 
+fn first_stmt_containing_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<&'tcx hir::Stmt<'tcx>> {
+    cx.tcx.hir_parent_iter(expr.hir_id).find_map(|(_, node)| {
+        if let hir::Node::Stmt(stmt) = node {
+            Some(stmt)
+        } else {
+            None
+        }
+    })
+}
+
 struct ReadVecVisitor<'tcx> {
     local_id: HirId,
     read_zero_expr: Option<&'tcx Expr<'tcx>>,
diff --git a/tests/ui/read_zero_byte_vec.rs b/tests/ui/read_zero_byte_vec.rs
index 938d61b68607c..720276cb55488 100644
--- a/tests/ui/read_zero_byte_vec.rs
+++ b/tests/ui/read_zero_byte_vec.rs
@@ -120,3 +120,30 @@ fn allow_works<F: std::io::Read>(mut f: F) {
 }
 
 fn main() {}
+
+fn issue15575() -> usize {
+    use std::io::Read;
+    use std::net::TcpListener;
+
+    let listener = TcpListener::bind("127.0.0.1:9010").unwrap();
+    let mut stream_and_addr = listener.accept().unwrap();
+    let mut buf = Vec::with_capacity(32);
+    let num_bytes_received = stream_and_addr.0.read(&mut buf).unwrap();
+    //~^ read_zero_byte_vec
+
+    let cap = 1000;
+    let mut buf = Vec::with_capacity(cap);
+    let num_bytes_received = stream_and_addr.0.read(&mut buf).unwrap();
+    //~^ read_zero_byte_vec
+
+    let cap = 1000;
+    let mut buf = Vec::with_capacity(cap);
+    let num_bytes_received = { stream_and_addr.0.read(&mut buf) }.unwrap();
+    //~^ read_zero_byte_vec
+
+    use std::fs::File;
+    let mut f = File::open("foo.txt").unwrap();
+    let mut data = Vec::with_capacity(100);
+    f.read(&mut data).unwrap()
+    //~^ read_zero_byte_vec
+}
diff --git a/tests/ui/read_zero_byte_vec.stderr b/tests/ui/read_zero_byte_vec.stderr
index 8f255bc87ab82..8dd74592e4c15 100644
--- a/tests/ui/read_zero_byte_vec.stderr
+++ b/tests/ui/read_zero_byte_vec.stderr
@@ -2,16 +2,27 @@ error: reading zero byte data to `Vec`
   --> tests/ui/read_zero_byte_vec.rs:22:5
    |
 LL |     f.read_exact(&mut data).unwrap();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `data.resize(20, 0); f.read_exact(&mut data)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::read-zero-byte-vec` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::read_zero_byte_vec)]`
+help: try
+   |
+LL ~     data.resize(20, 0);
+LL ~     f.read_exact(&mut data).unwrap();
+   |
 
 error: reading zero byte data to `Vec`
   --> tests/ui/read_zero_byte_vec.rs:28:5
    |
 LL |     f.read_exact(&mut data2)?;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `data2.resize(cap, 0); f.read_exact(&mut data2)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL ~     data2.resize(cap, 0);
+LL ~     f.read_exact(&mut data2)?;
+   |
 
 error: reading zero byte data to `Vec`
   --> tests/ui/read_zero_byte_vec.rs:33:5
@@ -67,5 +78,53 @@ error: reading zero byte data to `Vec`
 LL |     r.read_exact(&mut data2).await.unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 11 previous errors
+error: reading zero byte data to `Vec`
+  --> tests/ui/read_zero_byte_vec.rs:131:30
+   |
+LL |     let num_bytes_received = stream_and_addr.0.read(&mut buf).unwrap();
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL ~     buf.resize(32, 0);
+LL ~     let num_bytes_received = stream_and_addr.0.read(&mut buf).unwrap();
+   |
+
+error: reading zero byte data to `Vec`
+  --> tests/ui/read_zero_byte_vec.rs:136:30
+   |
+LL |     let num_bytes_received = stream_and_addr.0.read(&mut buf).unwrap();
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL ~     buf.resize(cap, 0);
+LL ~     let num_bytes_received = stream_and_addr.0.read(&mut buf).unwrap();
+   |
+
+error: reading zero byte data to `Vec`
+  --> tests/ui/read_zero_byte_vec.rs:141:32
+   |
+LL |     let num_bytes_received = { stream_and_addr.0.read(&mut buf) }.unwrap();
+   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL ~     buf.resize(cap, 0);
+LL ~     let num_bytes_received = { stream_and_addr.0.read(&mut buf) }.unwrap();
+   |
+
+error: reading zero byte data to `Vec`
+  --> tests/ui/read_zero_byte_vec.rs:147:5
+   |
+LL |     f.read(&mut data).unwrap()
+   |     ^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL ~     data.resize(100, 0);
+LL ~     f.read(&mut data).unwrap()
+   |
+
+error: aborting due to 15 previous errors
 

From 5d13845e5be03ec3cbe0da3ce67b8272bc4c2e69 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Thu, 4 Sep 2025 02:09:59 +0300
Subject: [PATCH 0474/1889] Don't require next-solver `ProbeRef` to be `Copy`

rust-analyzer would like to use a non-interned `Probe` there.

Also rename it to `Probe` for this reason.
---
 compiler/rustc_middle/src/ty/context.rs                    | 4 ++--
 .../rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs     | 4 ++--
 compiler/rustc_type_ir/src/interner.rs                     | 7 ++++---
 compiler/rustc_type_ir/src/solve/inspect.rs                | 2 +-
 4 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 72ab6ac612c61..97c8a0336c21a 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -738,8 +738,8 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
         )
     }
 
-    type ProbeRef = &'tcx inspect::Probe<TyCtxt<'tcx>>;
-    fn mk_probe_ref(self, probe: inspect::Probe<Self>) -> &'tcx inspect::Probe<TyCtxt<'tcx>> {
+    type Probe = &'tcx inspect::Probe<TyCtxt<'tcx>>;
+    fn mk_probe(self, probe: inspect::Probe<Self>) -> &'tcx inspect::Probe<TyCtxt<'tcx>> {
         self.arena.alloc(probe)
     }
     fn evaluate_root_goal_for_proof_tree_raw(
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
index 31106a7452795..443aebbdb4d69 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
@@ -1275,7 +1275,7 @@ pub fn evaluate_root_goal_for_proof_tree_raw_provider<
 >(
     cx: I,
     canonical_goal: CanonicalInput<I>,
-) -> (QueryResult<I>, I::ProbeRef) {
+) -> (QueryResult<I>, I::Probe) {
     let mut inspect = inspect::ProofTreeBuilder::new();
     let canonical_result = SearchGraph::<D>::evaluate_root_goal_for_proof_tree(
         cx,
@@ -1284,7 +1284,7 @@ pub fn evaluate_root_goal_for_proof_tree_raw_provider<
         &mut inspect,
     );
     let final_revision = inspect.unwrap();
-    (canonical_result, cx.mk_probe_ref(final_revision))
+    (canonical_result, cx.mk_probe(final_revision))
 }
 
 /// Evaluate a goal to build a proof tree.
diff --git a/compiler/rustc_type_ir/src/interner.rs b/compiler/rustc_type_ir/src/interner.rs
index f5448baf8c0b9..3355c0c2104da 100644
--- a/compiler/rustc_type_ir/src/interner.rs
+++ b/compiler/rustc_type_ir/src/interner.rs
@@ -1,3 +1,4 @@
+use std::borrow::Borrow;
 use std::fmt::Debug;
 use std::hash::Hash;
 use std::ops::Deref;
@@ -383,12 +384,12 @@ pub trait Interner:
         defining_anchor: Self::LocalDefId,
     ) -> Self::LocalDefIds;
 
-    type ProbeRef: Copy + Debug + Hash + Eq + Deref<Target = inspect::Probe<Self>>;
-    fn mk_probe_ref(self, probe: inspect::Probe<Self>) -> Self::ProbeRef;
+    type Probe: Debug + Hash + Eq + Borrow<inspect::Probe<Self>>;
+    fn mk_probe(self, probe: inspect::Probe<Self>) -> Self::Probe;
     fn evaluate_root_goal_for_proof_tree_raw(
         self,
         canonical_goal: CanonicalInput<Self>,
-    ) -> (QueryResult<Self>, Self::ProbeRef);
+    ) -> (QueryResult<Self>, Self::Probe);
 }
 
 /// Imagine you have a function `F: FnOnce(&[T]) -> R`, plus an iterator `iter`
diff --git a/compiler/rustc_type_ir/src/solve/inspect.rs b/compiler/rustc_type_ir/src/solve/inspect.rs
index 5452ac441589d..3af2f8dbaf27d 100644
--- a/compiler/rustc_type_ir/src/solve/inspect.rs
+++ b/compiler/rustc_type_ir/src/solve/inspect.rs
@@ -49,7 +49,7 @@ pub type CanonicalState<I, T> = Canonical<I, State<I, T>>;
 pub struct GoalEvaluation<I: Interner> {
     pub uncanonicalized_goal: Goal<I, I::Predicate>,
     pub orig_values: Vec<I::GenericArg>,
-    pub final_revision: I::ProbeRef,
+    pub final_revision: I::Probe,
     pub result: QueryResult<I>,
 }
 

From 4fec3aa2a4e087c981a083dca59e7434cac52625 Mon Sep 17 00:00:00 2001
From: Daniel Paoliello <danpao@microsoft.com>
Date: Wed, 3 Sep 2025 16:59:03 -0700
Subject: [PATCH 0475/1889] In the rustc_llvm build script, don't consider
 arm64* to be 32-bit

---
 compiler/rustc_llvm/build.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_llvm/build.rs b/compiler/rustc_llvm/build.rs
index d01f79dcade0b..804f46374d570 100644
--- a/compiler/rustc_llvm/build.rs
+++ b/compiler/rustc_llvm/build.rs
@@ -254,7 +254,10 @@ fn main() {
         println!("cargo:rustc-link-lib=kstat");
     }
 
-    if (target.starts_with("arm") && !target.contains("freebsd") && !target.contains("ohos"))
+    if (target.starts_with("arm")
+        && !target.starts_with("arm64")
+        && !target.contains("freebsd")
+        && !target.contains("ohos"))
         || target.starts_with("mips-")
         || target.starts_with("mipsel-")
         || target.starts_with("powerpc-")

From 80e18051cb9e4f4ed2e6c1927b598367788d5f2a Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Tue, 26 Aug 2025 19:46:50 -0700
Subject: [PATCH 0476/1889] rustdoc-search: yet another stringdex optimization
 attempt

This one's uses a different tactic. It shouldn't significantly
increase the amount of downloaded index data, but still reduces
the amount of disk usage.

This one works by changing the suffix-only node representation
to omit some data that's needed for checking. Since those nodes
make up the bulk of the tree, it reduces the data they store,
but also requires validating the match by fetching the name
itself (but the names list is pretty small, and when I tried
it with wordnet "indexing" it was about the same).
---
 Cargo.lock                                   |   4 +-
 src/librustdoc/Cargo.toml                    |   2 +-
 src/librustdoc/html/static/js/search.js      |   9 +-
 src/librustdoc/html/static/js/stringdex.d.ts |  13 +-
 src/librustdoc/html/static/js/stringdex.js   | 783 +++++++++++++++----
 5 files changed, 647 insertions(+), 164 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index af7c24abd132c..6866c1359b8c5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5225,9 +5225,9 @@ dependencies = [
 
 [[package]]
 name = "stringdex"
-version = "0.0.1-alpha4"
+version = "0.0.1-alpha9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2841fd43df5b1ff1b042e167068a1fe9b163dc93041eae56ab2296859013a9a0"
+checksum = "7081029913fd7d591c0112182aba8c98ae886b4f12edb208130496cd17dc3c15"
 dependencies = [
  "stacker",
 ]
diff --git a/src/librustdoc/Cargo.toml b/src/librustdoc/Cargo.toml
index 5d36ffc2d3a52..f37a8d85361f2 100644
--- a/src/librustdoc/Cargo.toml
+++ b/src/librustdoc/Cargo.toml
@@ -21,7 +21,7 @@ rustdoc-json-types = { path = "../rustdoc-json-types" }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 smallvec = "1.8.1"
-stringdex = { version = "0.0.1-alpha4" }
+stringdex = { version = "0.0.1-alpha9" }
 tempfile = "3"
 threadpool = "1.8.1"
 tracing = "0.1"
diff --git a/src/librustdoc/html/static/js/search.js b/src/librustdoc/html/static/js/search.js
index 3fb4db3a89c5c..2c9004bc8ec1f 100644
--- a/src/librustdoc/html/static/js/search.js
+++ b/src/librustdoc/html/static/js/search.js
@@ -1211,7 +1211,7 @@ class DocSearch {
      * will never fulfill.
      */
     async buildIndex() {
-        const nn = this.database.getIndex("normalizedName");
+        const nn = this.database.getData("normalizedName");
         if (!nn) {
             return;
         }
@@ -3706,7 +3706,7 @@ class DocSearch {
              * @returns {AsyncGenerator<rustdoc.ResultObject>}
              */
             async function*(currentCrate) {
-                const index = this.database.getIndex("normalizedName");
+                const index = this.database.getData("normalizedName");
                 if (!index) {
                     return;
                 }
@@ -3835,8 +3835,7 @@ class DocSearch {
                 };
                 if (elem.normalizedPathLast === "") {
                     // faster full-table scan for this specific case.
-                    const nameData = this.database.getData("name");
-                    const l = nameData ? nameData.length : 0;
+                    const l = index.length;
                     for (let id = 0; id < l; ++id) {
                         if (!idDuplicates.has(id)) {
                             idDuplicates.add(id);
@@ -3938,7 +3937,7 @@ class DocSearch {
              * @returns {AsyncGenerator<rustdoc.ResultObject>}
              */
             async function*(inputs, output, typeInfo, currentCrate) {
-                const index = this.database.getIndex("normalizedName");
+                const index = this.database.getData("normalizedName");
                 if (!index) {
                     return;
                 }
diff --git a/src/librustdoc/html/static/js/stringdex.d.ts b/src/librustdoc/html/static/js/stringdex.d.ts
index cf9a8b6b5648d..2eb1fdf95d845 100644
--- a/src/librustdoc/html/static/js/stringdex.d.ts
+++ b/src/librustdoc/html/static/js/stringdex.d.ts
@@ -5,17 +5,8 @@ declare namespace stringdex {
      * The client interface to Stringdex.
      */
     interface Database {
-        getIndex(colname: string): SearchTree|undefined;
         getData(colname: string): DataColumn|undefined;
     }
-    /**
-     * A search index file.
-     */
-    interface SearchTree {
-        trie(): Trie;
-        search(name: Uint8Array|string): Promise<Trie?>;
-        searchLev(name: Uint8Array|string): AsyncGenerator<Trie>;
-    }
     /**
      * A compressed node in the search tree.
      *
@@ -29,9 +20,7 @@ declare namespace stringdex {
         matches(): RoaringBitmap;
         substringMatches(): AsyncGenerator<RoaringBitmap>;
         prefixMatches(): AsyncGenerator<RoaringBitmap>;
-        keys(): Uint8Array;
         keysExcludeSuffixOnly(): Uint8Array;
-        children(): [number, Promise<Trie>][];
         childrenExcludeSuffixOnly(): [number, Promise<Trie>][];
         child(id: number): Promise<Trie>?;
     }
@@ -41,6 +30,8 @@ declare namespace stringdex {
     interface DataColumn {
         isEmpty(id: number): boolean;
         at(id: number): Promise<Uint8Array|undefined>;
+        search(name: Uint8Array|string): Promise<Trie?>;
+        searchLev(name: Uint8Array|string): AsyncGenerator<Trie>;
         length: number,
     }
     /**
diff --git a/src/librustdoc/html/static/js/stringdex.js b/src/librustdoc/html/static/js/stringdex.js
index cb956d926db97..b7f605a10351d 100644
--- a/src/librustdoc/html/static/js/stringdex.js
+++ b/src/librustdoc/html/static/js/stringdex.js
@@ -1,3 +1,4 @@
+// ignore-tidy-filelength
 /**
  * @import * as stringdex from "./stringdex.d.ts"
  */
@@ -485,6 +486,63 @@ class RoaringBitmap {
         const mid = this.getContainerId(key);
         return mid === -1 ? false : this.containers[mid].contains(value);
     }
+    /**
+     * @param {number} keyvalue
+     * @returns {RoaringBitmap}
+     */
+    remove(keyvalue) {
+        const key = keyvalue >> 16;
+        const value = keyvalue & 0xFFFF;
+        const mid = this.getContainerId(key);
+        if (mid === -1) {
+            return this;
+        }
+        const container = this.containers[mid];
+        if (!container.contains(value)) {
+            return this;
+        }
+        const newCardinality = (this.keysAndCardinalities[(mid * 4) + 2] |
+            (this.keysAndCardinalities[(mid * 4) + 3] << 8));
+        const l = this.containers.length;
+        const m = l - (newCardinality === 0 ? 1 : 0);
+        const result = new RoaringBitmap(null, 0);
+        result.keysAndCardinalities = new Uint8Array(m * 4);
+        let j = 0;
+        for (let i = 0; i < l; i += 1) {
+            if (i === mid) {
+                if (newCardinality !== 0) {
+                    result.keysAndCardinalities[(j * 4) + 0] = key;
+                    result.keysAndCardinalities[(j * 4) + 1] = key >> 8;
+                    const card = newCardinality - 1;
+                    result.keysAndCardinalities[(j * 4) + 2] = card;
+                    result.keysAndCardinalities[(j * 4) + 3] = card >> 8;
+                    const newContainer = new RoaringBitmapArray(
+                        newCardinality,
+                        new Uint8Array(newCardinality * 2),
+                    );
+                    let newContainerSlot = 0;
+                    for (const containerValue of container.values()) {
+                        if (containerValue !== value) {
+                            newContainer.array[newContainerSlot] = value & 0xFF;
+                            newContainerSlot += 1;
+                            newContainer.array[newContainerSlot] = value >> 8;
+                            newContainerSlot += 1;
+                        }
+                    }
+                    result.containers.push(newContainer);
+                    j += 1;
+                }
+            } else {
+                result.keysAndCardinalities[(j * 4) + 0] = this.keysAndCardinalities[(i * 4) + 0];
+                result.keysAndCardinalities[(j * 4) + 1] = this.keysAndCardinalities[(i * 4) + 1];
+                result.keysAndCardinalities[(j * 4) + 2] = this.keysAndCardinalities[(i * 4) + 2];
+                result.keysAndCardinalities[(j * 4) + 3] = this.keysAndCardinalities[(i * 4) + 3];
+                result.containers.push(this.containers[i]);
+                j += 1;
+            }
+        }
+        return result;
+    }
     /**
      * @param {number} key
      * @returns {number}
@@ -877,6 +935,46 @@ function bitCount(n) {
 }
 /*eslint-enable */
 
+/**
+ * https://en.wikipedia.org/wiki/Boyer%E2%80%93Moore%E2%80%93Horspool_algorithm
+ */
+class Uint8ArraySearchPattern {
+    /** @param {Uint8Array} needle */
+    constructor(needle) {
+        this.needle = needle;
+        this.skipTable = [];
+        const m = needle.length;
+        for (let i = 0; i < 256; i += 1) {
+            this.skipTable.push(m);
+        }
+        for (let i = 0; i < m - 1; i += 1) {
+            this.skipTable[needle[i]] = m - 1 - i;
+        }
+    }
+    /**
+     * @param {Uint8Array} haystack
+     * @returns {boolean}
+     */
+    matches(haystack) {
+        const needle = this.needle;
+        const skipTable = this.skipTable;
+        const m = needle.length;
+        const n = haystack.length;
+
+        let skip = 0;
+        search: while (n - skip >= m) {
+            for (let i = m - 1; i >= 0; i -= 1) {
+                if (haystack[skip + i] !== needle[i]) {
+                    skip += skipTable[haystack[skip + m  - 1]];
+                    continue search;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+}
+
 /**
  * @param {stringdex.Hooks} hooks
  * @returns {Promise<stringdex.Database>}
@@ -887,12 +985,6 @@ function loadDatabase(hooks) {
         rr_: function(data) {
             const dataObj = JSON.parse(data);
             for (const colName of Object.keys(dataObj)) {
-                if (Object.hasOwn(dataObj[colName], "I")) {
-                    registry.searchTreeRoots.set(
-                        colName,
-                        makeSearchTreeFromBase64(dataObj[colName].I)[1],
-                    );
-                }
                 if (Object.hasOwn(dataObj[colName], "N")) {
                     const counts = [];
                     const countsstring = dataObj[colName]["N"];
@@ -915,6 +1007,9 @@ function loadDatabase(hooks) {
                         makeUint8ArrayFromBase64(dataObj[colName]["H"]),
                         new RoaringBitmap(makeUint8ArrayFromBase64(dataObj[colName]["E"]), 0),
                         colName,
+                        Object.hasOwn(dataObj[colName], "I") ?
+                            makeSearchTreeFromBase64(dataObj[colName].I)[1] :
+                            null,
                     ));
                 }
             }
@@ -978,7 +1073,7 @@ function loadDatabase(hooks) {
      *      searchTreePromises: HashTable<Promise<SearchTree>>;
      *      dataColumnLoadPromiseCallbacks: HashTable<function(any, Uint8Array[]?): any>;
      *      dataColumns: Map<string, DataColumn>;
-     *      dataColumnsBuckets: Map<string, HashTable<Promise<Uint8Array[]>>>;
+     *      dataColumnsBuckets: HashTable<Promise<Uint8Array[]>>;
      *      searchTreeLoadByNodeID: function(Uint8Array): Promise<SearchTree>;
      *      searchTreeRootCallback?: function(any, Database?): any;
      *      dataLoadByNameAndHash: function(string, Uint8Array): Promise<Uint8Array[]>;
@@ -990,7 +1085,7 @@ function loadDatabase(hooks) {
         searchTreePromises: new HashTable(),
         dataColumnLoadPromiseCallbacks: new HashTable(),
         dataColumns: new Map(),
-        dataColumnsBuckets: new Map(),
+        dataColumnsBuckets: new HashTable(),
         searchTreeLoadByNodeID: function(nodeid) {
             const existingPromise = registry.searchTreePromises.get(nodeid);
             if (existingPromise) {
@@ -1022,7 +1117,7 @@ function loadDatabase(hooks) {
                 const data = (nodeid[0] & 0x20) !== 0 ?
                     Uint8Array.of(((nodeid[0] & 0x0f) << 4) | (nodeid[1] >> 4)) :
                     EMPTY_UINT8;
-                newPromise = Promise.resolve(new SearchTree(
+                newPromise = Promise.resolve(new PrefixSearchTree(
                     EMPTY_SEARCH_TREE_BRANCHES,
                     EMPTY_SEARCH_TREE_BRANCHES,
                     data,
@@ -1058,12 +1153,7 @@ function loadDatabase(hooks) {
             return newPromise;
         },
         dataLoadByNameAndHash: function(name, hash) {
-            let dataColumnBuckets = registry.dataColumnsBuckets.get(name);
-            if (dataColumnBuckets === undefined) {
-                dataColumnBuckets = new HashTable();
-                registry.dataColumnsBuckets.set(name, dataColumnBuckets);
-            }
-            const existingBucket = dataColumnBuckets.get(hash);
+            const existingBucket = registry.dataColumnsBuckets.get(hash);
             if (existingBucket) {
                 return existingBucket;
             }
@@ -1091,16 +1181,17 @@ function loadDatabase(hooks) {
                     hooks.loadDataByNameAndHash(name, hashHex);
                 }
             });
-            dataColumnBuckets.set(hash, newBucket);
+            registry.dataColumnsBuckets.set(hash, newBucket);
             return newBucket;
         },
     };
 
     /**
      * The set of child subtrees.
+     * @template ST
      * @type {{
      *    nodeids: Uint8Array,
-     *    subtrees: Array<Promise<SearchTree>|null>,
+     *    subtrees: Array<Promise<ST>|null>,
      * }}
      */
     class SearchTreeBranches {
@@ -1128,7 +1219,7 @@ function loadDatabase(hooks) {
             );
         }
         // https://github.com/microsoft/TypeScript/issues/17227
-        /** @returns {Generator<[number, Promise<SearchTree>|null]>} */
+        /** @returns {Generator<[number, Promise<ST>|null]>} */
         entries() {
             throw new Error();
         }
@@ -1157,10 +1248,12 @@ function loadDatabase(hooks) {
     /**
      * A sorted array of search tree branches.
      *
+     * @template ST
+     * @extends SearchTreeBranches<ST>
      * @type {{
      *    keys: Uint8Array,
      *    nodeids: Uint8Array,
-     *    subtrees: Array<Promise<SearchTree>|null>,
+     *    subtrees: Array<Promise<ST>|null>,
      * }}
      */
     class SearchTreeBranchesArray extends SearchTreeBranches {
@@ -1179,7 +1272,7 @@ function loadDatabase(hooks) {
                 i += 1;
             }
         }
-        /** @returns {Generator<[number, Promise<SearchTree>|null]>} */
+        /** @returns {Generator<[number, Promise<ST>|null]>} */
         * entries() {
             let i = 0;
             const l = this.keys.length;
@@ -1246,12 +1339,16 @@ function loadDatabase(hooks) {
     }
 
     /**
+     * @template ST
      * @param {number[]} alphabitmap_chars
      * @param {number} width
-     * @return {(typeof SearchTreeBranches)&{"ALPHABITMAP_CHARS": number[], "width": number}}
+     * @return {(typeof SearchTreeBranches<ST>)&{"ALPHABITMAP_CHARS": number[], "width": number}}
      */
     function makeSearchTreeBranchesAlphaBitmapClass(alphabitmap_chars, width) {
         const bitwidth = width * 8;
+        /**
+         * @extends SearchTreeBranches<ST>
+         */
         const cls = class SearchTreeBranchesAlphaBitmap extends SearchTreeBranches {
             /**
              * @param {number} bitmap
@@ -1265,7 +1362,7 @@ function loadDatabase(hooks) {
                 this.bitmap = bitmap;
                 this.nodeids = nodeids;
             }
-            /** @returns {Generator<[number, Promise<SearchTree>|null]>} */
+            /** @returns {Generator<[number, Promise<ST>|null]>} */
             * entries() {
                 let i = 0;
                 let j = 0;
@@ -1295,15 +1392,7 @@ function loadDatabase(hooks) {
              * @returns {number}
              */
             getKey(branch_index) {
-                //return this.getKeys()[branch_index];
-                let alpha_index = 0;
-                while (branch_index >= 0) {
-                    if (this.bitmap & (1 << alpha_index)) {
-                        branch_index -= 1;
-                    }
-                    alpha_index += 1;
-                }
-                return alphabitmap_chars[alpha_index];
+                return this.getKeys()[branch_index];
             }
             /**
              * @returns {Uint8Array}
@@ -1326,20 +1415,35 @@ function loadDatabase(hooks) {
         return cls;
     }
 
+    /**
+     * @template ST
+     * @type {(typeof SearchTreeBranches<any>)&{"ALPHABITMAP_CHARS": number[], "width": number}}
+     */
     const SearchTreeBranchesShortAlphaBitmap =
         makeSearchTreeBranchesAlphaBitmapClass(SHORT_ALPHABITMAP_CHARS, 3);
 
+    /**
+     * @template ST
+     * @type {(typeof SearchTreeBranches<any>)&{"ALPHABITMAP_CHARS": number[], "width": number}}
+     */
     const SearchTreeBranchesLongAlphaBitmap =
         makeSearchTreeBranchesAlphaBitmapClass(LONG_ALPHABITMAP_CHARS, 4);
 
     /**
-     * A [suffix tree], used for name-based search.
+     * @typedef {PrefixSearchTree|SuffixSearchTree} SearchTree
+     * @typedef {PrefixTrie|SuffixTrie} Trie
+     */
+
+    /**
+     * An interleaved [prefix] and [suffix tree],
+     * used for name-based search.
      *
-     * This data structure is used to drive substring matches,
+     * This data structure is used to drive prefix matches,
      * such as matching the query "link" to `LinkedList`,
      * and Lev-distance matches, such as matching the
      * query "hahsmap" to `HashMap`.
      *
+     * [prefix tree]: https://en.wikipedia.org/wiki/Prefix_tree
      * [suffix tree]: https://en.wikipedia.org/wiki/Suffix_tree
      *
      * branches
@@ -1358,17 +1462,17 @@ function loadDatabase(hooks) {
      *   will include these.
      *
      * @type {{
-     *     might_have_prefix_branches: SearchTreeBranches,
-     *     branches: SearchTreeBranches,
+     *     might_have_prefix_branches: SearchTreeBranches<SearchTree>,
+     *     branches: SearchTreeBranches<SearchTree>,
      *     data: Uint8Array,
      *     leaves_suffix: RoaringBitmap,
      *     leaves_whole: RoaringBitmap,
      * }}
      */
-    class SearchTree {
+    class PrefixSearchTree {
         /**
-         * @param {SearchTreeBranches} branches
-         * @param {SearchTreeBranches} might_have_prefix_branches
+         * @param {SearchTreeBranches<SearchTree>} branches
+         * @param {SearchTreeBranches<SearchTree>} might_have_prefix_branches
          * @param {Uint8Array} data
          * @param {RoaringBitmap} leaves_whole
          * @param {RoaringBitmap} leaves_suffix
@@ -1392,25 +1496,31 @@ function loadDatabase(hooks) {
          * A Trie pointer refers to a single node in a logical decompressed search tree
          * (the real search tree is compressed).
          *
-         * @return {Trie}
+         * @param {DataColumn} dataColumn
+         * @param {Uint8ArraySearchPattern} searchPattern
+         * @return {PrefixTrie}
          */
-        trie() {
-            return new Trie(this, 0);
+        trie(dataColumn, searchPattern) {
+            return new PrefixTrie(this, 0, dataColumn, searchPattern);
         }
 
         /**
          * Return the trie representing `name`
          * @param {Uint8Array|string} name
+         * @param {DataColumn} dataColumn
          * @returns {Promise<Trie?>}
          */
-        async search(name) {
+        async search(name, dataColumn) {
             if (typeof name === "string") {
                 const utf8encoder = new TextEncoder();
                 name = utf8encoder.encode(name);
             }
-            let trie = this.trie();
+            const searchPattern = new Uint8ArraySearchPattern(name);
+            /** @type {Trie} */
+            let trie = this.trie(dataColumn, searchPattern);
             for (const datum of name) {
                 // code point definitely exists
+                /** @type {Promise<Trie>?} */
                 const newTrie = trie.child(datum);
                 if (newTrie) {
                     trie = await newTrie;
@@ -1423,26 +1533,28 @@ function loadDatabase(hooks) {
 
         /**
          * @param {Uint8Array|string} name
+         * @param {DataColumn} dataColumn
          * @returns {AsyncGenerator<Trie>}
          */
-        async* searchLev(name) {
+        async* searchLev(name, dataColumn) {
             if (typeof name === "string") {
                 const utf8encoder = new TextEncoder();
                 name = utf8encoder.encode(name);
             }
             const w = name.length;
             if (w < 3) {
-                const trie = await this.search(name);
+                const trie = await this.search(name, dataColumn);
                 if (trie !== null) {
                     yield trie;
                 }
                 return;
             }
+            const searchPattern = new Uint8ArraySearchPattern(name);
             const levParams = w >= 6 ?
                 new Lev2TParametricDescription(w) :
                 new Lev1TParametricDescription(w);
             /** @type {Array<[Promise<Trie>, number]>} */
-            const stack = [[Promise.resolve(this.trie()), 0]];
+            const stack = [[Promise.resolve(this.trie(dataColumn, searchPattern)), 0]];
             const n = levParams.n;
             while (stack.length !== 0) {
                 // It's not empty
@@ -1475,20 +1587,29 @@ function loadDatabase(hooks) {
                 }
             }
         }
+
+        /** @returns {RoaringBitmap} */
+        getCurrentLeaves() {
+            return this.leaves_whole.union(this.leaves_suffix);
+        }
     }
 
     /**
      * A representation of a set of strings in the search index,
      * as a subset of the entire tree.
      */
-    class Trie {
+    class PrefixTrie {
         /**
-         * @param {SearchTree} tree
+         * @param {PrefixSearchTree} tree
          * @param {number} offset
+         * @param {DataColumn} dataColumn
+         * @param {Uint8ArraySearchPattern} searchPattern
          */
-        constructor(tree, offset) {
+        constructor(tree, offset, dataColumn, searchPattern) {
             this.tree = tree;
             this.offset = offset;
+            this.dataColumn = dataColumn;
+            this.searchPattern = searchPattern;
         }
 
         /**
@@ -1514,7 +1635,28 @@ function loadDatabase(hooks) {
                 const current_layer = layer;
                 layer = [];
                 for await (const tree of current_layer) {
-                    yield tree.leaves_whole.union(tree.leaves_suffix);
+                    /** @type {number[]?} */
+                    let rejected = null;
+                    let leaves = tree.getCurrentLeaves();
+                    for (const leaf of leaves.entries()) {
+                        const haystack = await this.dataColumn.at(leaf);
+                        if (haystack === undefined || !this.searchPattern.matches(haystack)) {
+                            if (!rejected) {
+                                rejected = [];
+                            }
+                            rejected.push(leaf);
+                        }
+                    }
+                    if (rejected) {
+                        if (leaves.cardinality() !== rejected.length) {
+                            for (const rej of rejected) {
+                                leaves = leaves.remove(rej);
+                            }
+                            yield leaves;
+                        }
+                    } else {
+                        yield leaves;
+                    }
                 }
                 /** @type {HashTable<[number, SearchTree][]>} */
                 const subnodes = new HashTable();
@@ -1548,12 +1690,14 @@ function loadDatabase(hooks) {
                     const res = registry.searchTreeLoadByNodeID(newnode);
                     for (const [byte, node] of subnode_list) {
                         const branches = node.branches;
-                        const might_have_prefix_branches = node.might_have_prefix_branches;
                         const i = branches.getIndex(byte);
                         branches.subtrees[i] = res;
-                        const mhpI = might_have_prefix_branches.getIndex(byte);
-                        if (mhpI !== -1) {
-                            might_have_prefix_branches.subtrees[mhpI] = res;
+                        if (node instanceof PrefixSearchTree) {
+                            const might_have_prefix_branches = node.might_have_prefix_branches;
+                            const mhpI = might_have_prefix_branches.getIndex(byte);
+                            if (mhpI !== -1) {
+                                might_have_prefix_branches.subtrees[mhpI] = res;
+                            }
                         }
                     }
                     layer.push(res);
@@ -1581,6 +1725,9 @@ function loadDatabase(hooks) {
                 // if we want to do them in order)
                 for (const {node, len} of current_layer) {
                     const tree = await node;
+                    if (!(tree instanceof PrefixSearchTree)) {
+                        continue;
+                    }
                     const length = len + tree.data.length;
                     if (minLength === null || length < minLength) {
                         minLength = length;
@@ -1637,10 +1784,13 @@ function loadDatabase(hooks) {
                     }
                 }
                 // if we still have more subtrees to walk, then keep going
-                /** @type {HashTable<{byte: number, tree: SearchTree, len: number}[]>} */
+                /** @type {HashTable<{byte: number, tree: PrefixSearchTree, len: number}[]>} */
                 const subnodes = new HashTable();
                 for await (const {node, len} of current_layer) {
                     const tree = await node;
+                    if (!(tree instanceof PrefixSearchTree)) {
+                        continue;
+                    }
                     const length = len + tree.data.length;
                     const mhp_branches = tree.might_have_prefix_branches;
                     const l = mhp_branches.subtrees.length;
@@ -1663,8 +1813,6 @@ function loadDatabase(hooks) {
                                     subnode_list.push({byte, tree, len});
                                 }
                             }
-                        } else {
-                            throw new Error(`malformed tree; index ${i} does not exist`);
                         }
                     }
                 }
@@ -1728,14 +1876,21 @@ function loadDatabase(hooks) {
                             this.tree.might_have_prefix_branches.subtrees[mhpI] = node;
                         }
                     }
-                    nodes.push([k, node.then(node => node.trie())]);
+                    nodes.push([k, node.then(node => {
+                        return node.trie(this.dataColumn, this.searchPattern);
+                    })]);
                     i += 1;
                 }
                 return nodes;
             } else {
                 /** @type {number} */
                 const codePoint = data[this.offset];
-                const trie = new Trie(this.tree, this.offset + 1);
+                const trie = new PrefixTrie(
+                    this.tree,
+                    this.offset + 1,
+                    this.dataColumn,
+                    this.searchPattern,
+                );
                 return [[codePoint, Promise.resolve(trie)]];
             }
         }
@@ -1777,14 +1932,21 @@ function loadDatabase(hooks) {
                         this.tree.might_have_prefix_branches.subtrees[i] = node;
                         this.tree.branches.subtrees[this.tree.branches.getIndex(k)] = node;
                     }
-                    nodes.push([k, node.then(node => node.trie())]);
+                    nodes.push([k, node.then(node => {
+                        return node.trie(this.dataColumn, this.searchPattern);
+                    })]);
                     i += 1;
                 }
                 return nodes;
             } else {
                 /** @type {number} */
                 const codePoint = data[this.offset];
-                const trie = new Trie(this.tree, this.offset + 1);
+                const trie = new PrefixTrie(
+                    this.tree,
+                    this.offset + 1,
+                    this.dataColumn,
+                    this.searchPattern,
+                );
                 return [[codePoint, Promise.resolve(trie)]];
             }
         }
@@ -1811,10 +1973,275 @@ function loadDatabase(hooks) {
                             this.tree.might_have_prefix_branches.subtrees[mhpI] = branch;
                         }
                     }
-                    return branch.then(branch => branch.trie());
+                    return branch.then(branch => branch.trie(this.dataColumn, this.searchPattern));
                 }
             } else if (this.tree.data[this.offset] === byte) {
-                return Promise.resolve(new Trie(this.tree, this.offset + 1));
+                return Promise.resolve(new PrefixTrie(
+                    this.tree,
+                    this.offset + 1,
+                    this.dataColumn,
+                    this.searchPattern,
+                ));
+            }
+            return null;
+        }
+    }
+    /**
+     * A [suffix tree], used for name-based search.
+     *
+     * This data structure is used to drive substring matches,
+     * such as matching the query "inked" to `LinkedList`.
+     *
+     * [suffix tree]: https://en.wikipedia.org/wiki/Suffix_tree
+     *
+     * Suffix trees do not actually carry the intermediate data
+     * between branches, so, in order to validate the results,
+     * they must go through a filtering step at the end.
+     * Suffix trees also cannot match lev and exact matches,
+     * so those just return empty sets.
+     *
+     * branches
+     * : A sorted-array map of subtrees.
+     *
+     * dataLen
+     * : The length of the substring used by this node.
+     *
+     * leaves_suffix
+     * : The IDs of every entry that matches. Levenshtein matches
+     *   won't include these.
+     *
+     * @type {{
+     *     branches: SearchTreeBranches<SearchTree>,
+     *     dataLen: number,
+     *     leaves_suffix: RoaringBitmap,
+     * }}
+     */
+    class SuffixSearchTree {
+        /**
+         * @param {SearchTreeBranches<SearchTree>} branches
+         * @param {number} dataLen
+         * @param {RoaringBitmap} leaves_suffix
+         */
+        constructor(
+            branches,
+            dataLen,
+            leaves_suffix,
+        ) {
+            this.branches = branches;
+            this.dataLen = dataLen;
+            this.leaves_suffix = leaves_suffix;
+        }
+        /**
+         * Returns the Trie for the root node.
+         *
+         * A Trie pointer refers to a single node in a logical decompressed search tree
+         * (the real search tree is compressed).
+         *
+         * @param {DataColumn} dataColumn
+         * @param {Uint8ArraySearchPattern} searchPattern
+         * @return {Trie}
+         */
+        trie(dataColumn, searchPattern) {
+            return new SuffixTrie(this, 0, dataColumn, searchPattern);
+        }
+
+        /**
+         * Return the trie representing `name`
+         * @param {Uint8Array|string} name
+         * @param {DataColumn} dataColumn
+         * @returns {Promise<Trie?>}
+         */
+        async search(name, dataColumn) {
+            if (typeof name === "string") {
+                const utf8encoder = new TextEncoder();
+                name = utf8encoder.encode(name);
+            }
+            const searchPattern = new Uint8ArraySearchPattern(name);
+            let trie = this.trie(dataColumn, searchPattern);
+            for (const datum of name) {
+                // code point definitely exists
+                const newTrie = trie.child(datum);
+                if (newTrie) {
+                    trie = await newTrie;
+                } else {
+                    return null;
+                }
+            }
+            return trie;
+        }
+
+        /**
+         * @param {Uint8Array|string} _name
+         * @param {DataColumn} _dataColumn
+         * @returns {AsyncGenerator<Trie>}
+         */
+        async* searchLev(_name, _dataColumn) {
+            // this function only returns whole-string matches,
+            // which pure-suffix nodes don't have, so is
+            // intentionally blank
+        }
+
+        /** @returns {RoaringBitmap} */
+        getCurrentLeaves() {
+            return this.leaves_suffix;
+        }
+    }
+
+    /**
+     * A representation of a set of strings in the search index,
+     * as a subset of the entire tree (suffix-only).
+     */
+    class SuffixTrie {
+        /**
+         * @param {SuffixSearchTree} tree
+         * @param {number} offset
+         * @param {DataColumn} dataColumn
+         * @param {Uint8ArraySearchPattern} searchPattern
+         */
+        constructor(tree, offset, dataColumn, searchPattern) {
+            this.tree = tree;
+            this.offset = offset;
+            this.dataColumn = dataColumn;
+            this.searchPattern = searchPattern;
+        }
+
+        /**
+         * All exact matches for the string represented by this node.
+         * Since pure-suffix nodes have no exactly-matching children,
+         * this function returns the empty bitmap.
+         * @returns {RoaringBitmap}
+         */
+        matches() {
+            return EMPTY_BITMAP;
+        }
+
+        /**
+         * All matches for strings that contain the string represented by this node.
+         * @returns {AsyncGenerator<RoaringBitmap>}
+         */
+        async* substringMatches() {
+            /** @type {Promise<SearchTree>[]} */
+            let layer = [Promise.resolve(this.tree)];
+            while (layer.length) {
+                const current_layer = layer;
+                layer = [];
+                for await (const tree of current_layer) {
+                    /** @type {number[]?} */
+                    let rejected = null;
+                    let leaves = tree.getCurrentLeaves();
+                    for (const leaf of leaves.entries()) {
+                        const haystack = await this.dataColumn.at(leaf);
+                        if (haystack === undefined || !this.searchPattern.matches(haystack)) {
+                            if (!rejected) {
+                                rejected = [];
+                            }
+                            rejected.push(leaf);
+                        }
+                    }
+                    if (rejected) {
+                        if (leaves.cardinality() !== rejected.length) {
+                            for (const rej of rejected) {
+                                leaves = leaves.remove(rej);
+                            }
+                            yield leaves;
+                        }
+                    } else {
+                        yield leaves;
+                    }
+                }
+                /** @type {HashTable<[number, SearchTree][]>} */
+                const subnodes = new HashTable();
+                for await (const node of current_layer) {
+                    const branches = node.branches;
+                    const l = branches.subtrees.length;
+                    for (let i = 0; i < l; ++i) {
+                        const subtree = branches.subtrees[i];
+                        if (subtree) {
+                            layer.push(subtree);
+                        } else if (subtree === null) {
+                            const newnode = branches.getNodeID(i);
+                            if (!newnode) {
+                                throw new Error(`malformed tree; no node for index ${i}`);
+                            } else {
+                                let subnode_list = subnodes.get(newnode);
+                                if (!subnode_list) {
+                                    subnode_list = [[i, node]];
+                                    subnodes.set(newnode, subnode_list);
+                                } else {
+                                    subnode_list.push([i, node]);
+                                }
+                            }
+                        } else {
+                            throw new Error(`malformed tree; index ${i} does not exist`);
+                        }
+                    }
+                }
+                for (const [newnode, subnode_list] of subnodes.entries()) {
+                    const res = registry.searchTreeLoadByNodeID(newnode);
+                    for (const [i, node] of subnode_list) {
+                        const branches = node.branches;
+                        branches.subtrees[i] = res;
+                    }
+                    layer.push(res);
+                }
+            }
+        }
+
+        /**
+         * All matches for strings that start with the string represented by this node.
+         * Since this is a pure-suffix node, there aren't any.
+         * @returns {AsyncGenerator<RoaringBitmap>}
+         */
+        async* prefixMatches() {
+            // this function only returns prefix matches,
+            // which pure-suffix nodes don't have, so is
+            // intentionally blank
+        }
+
+        /**
+         * Returns all keys that are children of this node.
+         * @returns {Uint8Array}
+         */
+        keysExcludeSuffixOnly() {
+            return EMPTY_UINT8;
+        }
+
+        /**
+         * Returns all nodes that are direct children of this node.
+         * @returns {[number, Promise<Trie>][]}
+         */
+        childrenExcludeSuffixOnly() {
+            return [];
+        }
+
+        /**
+         * Returns a single node that is a direct child of this node.
+         * @param {number} byte
+         * @returns {Promise<Trie>?}
+         */
+        child(byte) {
+            if (this.offset === this.tree.dataLen) {
+                const i = this.tree.branches.getIndex(byte);
+                if (i !== -1) {
+                    /** @type {Promise<SearchTree>?} */
+                    let branch = this.tree.branches.subtrees[i];
+                    if (branch === null) {
+                        const newnode = this.tree.branches.getNodeID(i);
+                        if (!newnode) {
+                            throw new Error(`malformed tree; no node for key ${byte}`);
+                        }
+                        branch = registry.searchTreeLoadByNodeID(newnode);
+                        this.tree.branches.subtrees[i] = branch;
+                    }
+                    return branch.then(branch => branch.trie(this.dataColumn, this.searchPattern));
+                }
+            } else {
+                return Promise.resolve(new SuffixTrie(
+                    this.tree,
+                    this.offset + 1,
+                    this.dataColumn,
+                    this.searchPattern,
+                ));
             }
             return null;
         }
@@ -1827,8 +2254,10 @@ function loadDatabase(hooks) {
          * @param {Uint8Array} hashes
          * @param {RoaringBitmap} emptyset
          * @param {string} name
+         * @param {SearchTree?} searchTree
          */
-        constructor(counts, hashes, emptyset, name) {
+        constructor(counts, hashes, emptyset, name, searchTree) {
+            this.searchTree = searchTree;
             this.hashes = hashes;
             this.emptyset = emptyset;
             this.name = name;
@@ -1883,7 +2312,7 @@ function loadDatabase(hooks) {
                     const {hash, end} = this.buckets[idx];
                     let data = this.buckets[idx].data;
                     if (data === null) {
-                        const dataSansEmptyset = await registry.dataLoadByNameAndHash(
+                        const dataSansEmptysetOrig = await registry.dataLoadByNameAndHash(
                             this.name,
                             hash,
                         );
@@ -1893,6 +2322,7 @@ function loadDatabase(hooks) {
                         if (data !== null) {
                             return (await data)[id - start];
                         }
+                        const dataSansEmptyset = [...dataSansEmptysetOrig];
                         /** @type {(Uint8Array[])|null} */
                         let dataWithEmptyset = null;
                         let pos = start;
@@ -1924,6 +2354,24 @@ function loadDatabase(hooks) {
                 }
             }
         }
+        /**
+         * Search by exact substring
+         * @param {Uint8Array|string} name
+         * @returns {Promise<Trie?>}
+         */
+        async search(name) {
+            return await (this.searchTree ? this.searchTree.search(name, this) : null);
+        }
+        /**
+         * Search by whole, inexact match
+         * @param {Uint8Array|string} name
+         * @returns {AsyncGenerator<Trie>}
+         */
+        async *searchLev(name) {
+            if (this.searchTree) {
+                yield* this.searchTree.searchLev(name, this);
+            }
+        }
     }
 
     class Database {
@@ -2015,7 +2463,7 @@ function loadDatabase(hooks) {
         const data_history = [];
         let canonical = EMPTY_UINT8;
         /** @type {SearchTree} */
-        let tree = new SearchTree(
+        let tree = new PrefixSearchTree(
             EMPTY_SEARCH_TREE_BRANCHES,
             EMPTY_SEARCH_TREE_BRANCHES,
             EMPTY_UINT8,
@@ -2029,8 +2477,8 @@ function loadDatabase(hooks) {
          * @returns {{
          *     "cpbranches": Uint8Array,
          *     "csbranches": Uint8Array,
-         *     "might_have_prefix_branches": SearchTreeBranches,
-         *     "branches": SearchTreeBranches,
+         *     "might_have_prefix_branches": SearchTreeBranches<SearchTree>,
+         *     "branches": SearchTreeBranches<SearchTree>,
          *     "cpnodes": Uint8Array,
          *     "csnodes": Uint8Array,
          *     "consumed_len_bytes": number,
@@ -2051,6 +2499,12 @@ function loadDatabase(hooks) {
             const start_point = i;
             let cplen;
             let cslen;
+            /**
+             * @type {(
+             *   typeof SearchTreeBranches<SearchTree> &
+             *   {"ALPHABITMAP_CHARS": number[], "width": number}
+             * )?}
+             */
             let alphabitmap = null;
             if (is_pure_suffixes_only_node) {
                 cplen = 0;
@@ -2299,6 +2753,8 @@ function loadDatabase(hooks) {
                 if (is_data_compressed) {
                     data = data_history[data_history.length - dlen - 1];
                     dlen = data.length;
+                } else if (is_pure_suffixes_only_node) {
+                    data = EMPTY_UINT8;
                 } else {
                     data = dlen === 0 ?
                         EMPTY_UINT8 :
@@ -2319,80 +2775,109 @@ function loadDatabase(hooks) {
                 let whole;
                 let suffix;
                 if (is_pure_suffixes_only_node) {
-                    whole = EMPTY_BITMAP;
                     suffix = input[i] === 0 ?
                         EMPTY_BITMAP1 :
                         new RoaringBitmap(input, i);
                     i += suffix.consumed_len_bytes;
-                } else if (input[i] === 0xff) {
-                    whole = EMPTY_BITMAP;
-                    suffix = EMPTY_BITMAP1;
-                    i += 1;
+                    tree = new SuffixSearchTree(
+                        branches,
+                        dlen,
+                        suffix,
+                    );
+                    const clen = (
+                        3 + // lengths of children and data
+                        csnodes.length +
+                        csbranches.length +
+                        suffix.consumed_len_bytes
+                    );
+                    if (canonical.length < clen) {
+                        canonical = new Uint8Array(clen);
+                    }
+                    let ci = 0;
+                    canonical[ci] = 1;
+                    ci += 1;
+                    canonical[ci] = dlen;
+                    ci += 1;
+                    canonical[ci] = input[coffset]; // suffix child count
+                    ci += 1;
+                    canonical.set(csnodes, ci);
+                    ci += csnodes.length;
+                    canonical.set(csbranches, ci);
+                    ci += csbranches.length;
+                    const leavesOffset = i - suffix.consumed_len_bytes;
+                    for (let j = leavesOffset; j < i; j += 1) {
+                        canonical[ci + j - leavesOffset] = input[j];
+                    }
+                    siphashOfBytes(canonical.subarray(0, clen), 0, 0, 0, 0, hash);
                 } else {
-                    whole = input[i] === 0 ?
-                        EMPTY_BITMAP1 :
-                        new RoaringBitmap(input, i);
-                    i += whole.consumed_len_bytes;
-                    suffix = input[i] === 0 ?
-                        EMPTY_BITMAP1 :
-                        new RoaringBitmap(input, i);
-                    i += suffix.consumed_len_bytes;
-                }
-                tree = new SearchTree(
-                    branches,
-                    might_have_prefix_branches,
-                    data,
-                    whole,
-                    suffix,
-                );
-                const clen = (
-                    (is_pure_suffixes_only_node ? 3 : 4) + // lengths of children and data
-                    dlen +
-                    cpnodes.length + csnodes.length +
-                    cpbranches.length + csbranches.length +
-                    whole.consumed_len_bytes +
-                    suffix.consumed_len_bytes
-                );
-                if (canonical.length < clen) {
-                    canonical = new Uint8Array(clen);
-                }
-                let ci = 0;
-                canonical[ci] = is_pure_suffixes_only_node ? 1 : 0;
-                ci += 1;
-                canonical[ci] = dlen;
-                ci += 1;
-                canonical.set(data, ci);
-                ci += dlen;
-                canonical[ci] = input[coffset];
-                ci += 1;
-                if (!is_pure_suffixes_only_node) {
-                    canonical[ci] = input[coffset + 1];
+                    if (input[i] === 0xff) {
+                        whole = EMPTY_BITMAP;
+                        suffix = EMPTY_BITMAP1;
+                        i += 1;
+                    } else {
+                        whole = input[i] === 0 ?
+                            EMPTY_BITMAP1 :
+                            new RoaringBitmap(input, i);
+                        i += whole.consumed_len_bytes;
+                        suffix = input[i] === 0 ?
+                            EMPTY_BITMAP1 :
+                            new RoaringBitmap(input, i);
+                        i += suffix.consumed_len_bytes;
+                    }
+                    tree = new PrefixSearchTree(
+                        branches,
+                        might_have_prefix_branches,
+                        data,
+                        whole,
+                        suffix,
+                    );
+                    const clen = (
+                        4 + // lengths of children and data
+                        dlen +
+                        cpnodes.length + csnodes.length +
+                        cpbranches.length + csbranches.length +
+                        whole.consumed_len_bytes +
+                        suffix.consumed_len_bytes
+                    );
+                    if (canonical.length < clen) {
+                        canonical = new Uint8Array(clen);
+                    }
+                    let ci = 0;
+                    canonical[ci] = 0;
                     ci += 1;
+                    canonical[ci] = dlen;
+                    ci += 1;
+                    canonical.set(data, ci);
+                    ci += data.length;
+                    canonical[ci] = input[coffset]; // prefix child count
+                    ci += 1;
+                    canonical[ci] = input[coffset + 1]; // suffix child count
+                    ci += 1;
+                    canonical.set(cpnodes, ci);
+                    ci += cpnodes.length;
+                    canonical.set(csnodes, ci);
+                    ci += csnodes.length;
+                    canonical.set(cpbranches, ci);
+                    ci += cpbranches.length;
+                    canonical.set(csbranches, ci);
+                    ci += csbranches.length;
+                    const leavesOffset = i - whole.consumed_len_bytes - suffix.consumed_len_bytes;
+                    for (let j = leavesOffset; j < i; j += 1) {
+                        canonical[ci + j - leavesOffset] = input[j];
+                    }
+                    siphashOfBytes(canonical.subarray(0, clen), 0, 0, 0, 0, hash);
                 }
-                canonical.set(cpnodes, ci);
-                ci += cpnodes.length;
-                canonical.set(csnodes, ci);
-                ci += csnodes.length;
-                canonical.set(cpbranches, ci);
-                ci += cpbranches.length;
-                canonical.set(csbranches, ci);
-                ci += csbranches.length;
-                const leavesOffset = i - whole.consumed_len_bytes - suffix.consumed_len_bytes;
-                for (let j = leavesOffset; j < i; j += 1) {
-                    canonical[ci + j - leavesOffset] = input[j];
-                }
-                siphashOfBytes(canonical.subarray(0, clen), 0, 0, 0, 0, hash);
                 hash[2] &= 0x7f;
             } else {
                 // uncompressed node
                 const dlen = input [i + 1];
                 i += 2;
-                if (dlen === 0) {
+                if (dlen === 0 || is_pure_suffixes_only_node) {
                     data = EMPTY_UINT8;
                 } else {
                     data = new Uint8Array(input.buffer, i + input.byteOffset, dlen);
+                    i += dlen;
                 }
-                i += dlen;
                 const {
                     consumed_len_bytes: branches_consumed_len_bytes,
                     branches,
@@ -2427,13 +2912,19 @@ function loadDatabase(hooks) {
                     i - start,
                 ), 0, 0, 0, 0, hash);
                 hash[2] &= 0x7f;
-                tree = new SearchTree(
-                    branches,
-                    might_have_prefix_branches,
-                    data,
-                    whole,
-                    suffix,
-                );
+                tree = is_pure_suffixes_only_node ?
+                    new SuffixSearchTree(
+                        branches,
+                        dlen,
+                        suffix,
+                    ) :
+                    new PrefixSearchTree(
+                        branches,
+                        might_have_prefix_branches,
+                        data,
+                        whole,
+                        suffix,
+                    );
             }
             hash_history.push({hash: truncatedHash.slice(), used: false});
             if (data.length !== 0) {
@@ -2454,20 +2945,22 @@ function loadDatabase(hooks) {
                 }
                 j += 1;
             }
-            const tree_mhp_branch_nodeids = tree.might_have_prefix_branches.nodeids;
-            const tree_mhp_branch_subtrees = tree.might_have_prefix_branches.subtrees;
-            j = 0;
-            lb = tree.might_have_prefix_branches.subtrees.length;
-            while (j < lb) {
-                // node id with a 1 in its most significant bit is inlined, and, so
-                // it won't be in the stash
-                if ((tree_mhp_branch_nodeids[j * 6] & 0x80) === 0) {
-                    const subtree = stash.getWithOffsetKey(tree_mhp_branch_nodeids, j * 6);
-                    if (subtree !== undefined) {
-                        tree_mhp_branch_subtrees[j] = Promise.resolve(subtree);
+            if (tree instanceof PrefixSearchTree) {
+                const tree_mhp_branch_nodeids = tree.might_have_prefix_branches.nodeids;
+                const tree_mhp_branch_subtrees = tree.might_have_prefix_branches.subtrees;
+                j = 0;
+                lb = tree.might_have_prefix_branches.subtrees.length;
+                while (j < lb) {
+                    // node id with a 1 in its most significant bit is inlined, and, so
+                    // it won't be in the stash
+                    if ((tree_mhp_branch_nodeids[j * 6] & 0x80) === 0) {
+                        const subtree = stash.getWithOffsetKey(tree_mhp_branch_nodeids, j * 6);
+                        if (subtree !== undefined) {
+                            tree_mhp_branch_subtrees[j] = Promise.resolve(subtree);
+                        }
                     }
+                    j += 1;
                 }
-                j += 1;
             }
             if (i !== l) {
                 stash.set(truncatedHash, tree);

From c2ae2e03d2ab371adab0b16d0c2dba1b5f51e17c Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 27 Aug 2025 12:43:28 +1000
Subject: [PATCH 0477/1889] Implement compiletest `--new-output-capture`, in
 stable Rust

---
 src/tools/compiletest/src/common.rs         |  5 ++++
 src/tools/compiletest/src/executor.rs       | 18 +++++++++++--
 src/tools/compiletest/src/lib.rs            | 27 ++++++++++++++++++++
 src/tools/compiletest/src/output_capture.rs | 28 +++++++++++++++++++++
 4 files changed, 76 insertions(+), 2 deletions(-)

diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
index 89b1b4f84b6b6..62fdee987355a 100644
--- a/src/tools/compiletest/src/common.rs
+++ b/src/tools/compiletest/src/common.rs
@@ -667,6 +667,10 @@ pub struct Config {
     /// to avoid `!nocapture` double-negatives.
     pub nocapture: bool,
 
+    /// True if the experimental new output-capture implementation should be
+    /// used, avoiding the need for `#![feature(internal_output_capture)]`.
+    pub new_output_capture: bool,
+
     /// Needed both to construct [`build_helper::git::GitConfig`].
     pub nightly_branch: String,
     pub git_merge_commit_email: String,
@@ -784,6 +788,7 @@ impl Config {
             builtin_cfg_names: Default::default(),
             supported_crate_types: Default::default(),
             nocapture: Default::default(),
+            new_output_capture: Default::default(),
             nightly_branch: Default::default(),
             git_merge_commit_email: Default::default(),
             profiler_runtime: Default::default(),
diff --git a/src/tools/compiletest/src/executor.rs b/src/tools/compiletest/src/executor.rs
index 818d171988556..b0dc24798b6cd 100644
--- a/src/tools/compiletest/src/executor.rs
+++ b/src/tools/compiletest/src/executor.rs
@@ -168,12 +168,17 @@ enum CaptureKind {
     /// Use the old output-capture implementation, which relies on the unstable
     /// library feature `#![feature(internal_output_capture)]`.
     Old { buf: Arc<Mutex<Vec<u8>>> },
+
+    /// Use the new output-capture implementation, which only uses stable Rust.
+    New { buf: output_capture::CaptureBuf },
 }
 
 impl CaptureKind {
     fn for_config(config: &Config) -> Self {
         if config.nocapture {
             Self::None
+        } else if config.new_output_capture {
+            Self::New { buf: output_capture::CaptureBuf::new() }
         } else {
             // Create a capure buffer for `io::set_output_capture`.
             Self::Old { buf: Default::default() }
@@ -184,21 +189,30 @@ impl CaptureKind {
         match self {
             Self::None => false,
             Self::Old { .. } => true,
+            Self::New { .. } => true,
         }
     }
 
     fn stdout(&self) -> &dyn ConsoleOut {
-        &output_capture::Stdout
+        self.capture_buf_or(&output_capture::Stdout)
     }
 
     fn stderr(&self) -> &dyn ConsoleOut {
-        &output_capture::Stderr
+        self.capture_buf_or(&output_capture::Stderr)
+    }
+
+    fn capture_buf_or<'a>(&'a self, fallback: &'a dyn ConsoleOut) -> &'a dyn ConsoleOut {
+        match self {
+            Self::None | Self::Old { .. } => fallback,
+            Self::New { buf } => buf,
+        }
     }
 
     fn into_inner(self) -> Option<Vec<u8>> {
         match self {
             Self::None => None,
             Self::Old { buf } => Some(buf.lock().unwrap_or_else(|e| e.into_inner()).to_vec()),
+            Self::New { buf } => Some(buf.into_inner().into()),
         }
     }
 }
diff --git a/src/tools/compiletest/src/lib.rs b/src/tools/compiletest/src/lib.rs
index 875d497af1a68..f647f96a9bf34 100644
--- a/src/tools/compiletest/src/lib.rs
+++ b/src/tools/compiletest/src/lib.rs
@@ -178,6 +178,12 @@ pub fn parse_config(args: Vec<String>) -> Config {
         // FIXME: Temporarily retained so we can point users to `--no-capture`
         .optflag("", "nocapture", "")
         .optflag("", "no-capture", "don't capture stdout/stderr of tests")
+        .optopt(
+            "N",
+            "new-output-capture",
+            "enables or disables the new output-capture implementation",
+            "off|on",
+        )
         .optflag("", "profiler-runtime", "is the profiler runtime enabled for this target")
         .optflag("h", "help", "show this message")
         .reqopt("", "channel", "current Rust channel", "CHANNEL")
@@ -462,6 +468,14 @@ pub fn parse_config(args: Vec<String>) -> Config {
         supported_crate_types: OnceLock::new(),
 
         nocapture: matches.opt_present("no-capture"),
+        new_output_capture: {
+            let value = matches
+                .opt_str("new-output-capture")
+                .or_else(|| env::var("COMPILETEST_NEW_OUTPUT_CAPTURE").ok())
+                .unwrap_or_else(|| "off".to_owned());
+            parse_bool_option(&value)
+                .unwrap_or_else(|| panic!("unknown `--new-output-capture` value `{value}` given"))
+        },
 
         nightly_branch: matches.opt_str("nightly-branch").unwrap(),
         git_merge_commit_email: matches.opt_str("git-merge-commit-email").unwrap(),
@@ -477,6 +491,19 @@ pub fn parse_config(args: Vec<String>) -> Config {
     }
 }
 
+/// Parses the same set of boolean values accepted by rustc command-line arguments.
+///
+/// Accepting all of these values is more complicated than just picking one
+/// pair, but has the advantage that contributors who are used to rustc
+/// shouldn't have to think about which values are legal.
+fn parse_bool_option(value: &str) -> Option<bool> {
+    match value {
+        "off" | "no" | "n" | "false" => Some(false),
+        "on" | "yes" | "y" | "true" => Some(true),
+        _ => None,
+    }
+}
+
 pub fn opt_str(maybestr: &Option<String>) -> &str {
     match *maybestr {
         None => "(none)",
diff --git a/src/tools/compiletest/src/output_capture.rs b/src/tools/compiletest/src/output_capture.rs
index e5e3e14f288c0..de1aea11ade9b 100644
--- a/src/tools/compiletest/src/output_capture.rs
+++ b/src/tools/compiletest/src/output_capture.rs
@@ -1,5 +1,6 @@
 use std::fmt;
 use std::panic::RefUnwindSafe;
+use std::sync::Mutex;
 
 pub trait ConsoleOut: fmt::Debug + RefUnwindSafe {
     fn write_fmt(&self, args: fmt::Arguments<'_>);
@@ -22,3 +23,30 @@ impl ConsoleOut for Stderr {
         eprint!("{args}");
     }
 }
+
+pub(crate) struct CaptureBuf {
+    inner: Mutex<String>,
+}
+
+impl CaptureBuf {
+    pub(crate) fn new() -> Self {
+        Self { inner: Mutex::new(String::new()) }
+    }
+
+    pub(crate) fn into_inner(self) -> String {
+        self.inner.into_inner().unwrap_or_else(|e| e.into_inner())
+    }
+}
+
+impl fmt::Debug for CaptureBuf {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("CaptureBuf").finish_non_exhaustive()
+    }
+}
+
+impl ConsoleOut for CaptureBuf {
+    fn write_fmt(&self, args: fmt::Arguments<'_>) {
+        let mut s = self.inner.lock().unwrap_or_else(|e| e.into_inner());
+        <String as fmt::Write>::write_fmt(&mut s, args).unwrap();
+    }
+}

From d9619ed1c54f7c20b74913982cf0715002380e10 Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Thu, 4 Sep 2025 04:52:52 +0000
Subject: [PATCH 0478/1889] Prepare for merging from rust-lang/rust

This updates the rust-version file to 9385c64c95d971329e62917adc4349c8ccdbafe0.
---
 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 d44488399f8b9..7420b6200967c 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-51ff895062ba60a7cba53f57af928c3fb7b0f2f4
+9385c64c95d971329e62917adc4349c8ccdbafe0

From 94fd69aa283064d438bde01357856f5905073591 Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Wed, 3 Sep 2025 13:27:08 -0700
Subject: [PATCH 0479/1889] Update cargo submodule

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

diff --git a/src/tools/cargo b/src/tools/cargo
index a6c58d43051d0..761c4658d0079 160000
--- a/src/tools/cargo
+++ b/src/tools/cargo
@@ -1 +1 @@
-Subproject commit a6c58d43051d01d83f55a3e61ef5f5b2b0dd6bd9
+Subproject commit 761c4658d0079d607e6d33cf0c060e61a617cad3

From 858414b6bb223b4f22c2c9748a7ef05a000c3bad Mon Sep 17 00:00:00 2001
From: FrancescoV1985 <franci.vi@tiscali.it>
Date: Thu, 4 Sep 2025 08:55:02 +0200
Subject: [PATCH 0480/1889] improved solution for function
 is_non_auto_or_matches

---
 src/tools/tidy/src/extra_checks/mod.rs | 24 +++++++++++-------------
 1 file changed, 11 insertions(+), 13 deletions(-)

diff --git a/src/tools/tidy/src/extra_checks/mod.rs b/src/tools/tidy/src/extra_checks/mod.rs
index 0d4cee8d5dba8..34d9ea92629b3 100644
--- a/src/tools/tidy/src/extra_checks/mod.rs
+++ b/src/tools/tidy/src/extra_checks/mod.rs
@@ -720,21 +720,19 @@ impl ExtraCheckArg {
         if !self.auto {
             return true;
         }
-        match self.lang {
+        let exts: &[&str] = match self.lang {
+            ExtraCheckLang::Py => &[".py"],
+            ExtraCheckLang::Cpp => &[".cpp"],
+            ExtraCheckLang::Shell => &[".sh"],
+            ExtraCheckLang::Js => &[".js", ".ts"],
             ExtraCheckLang::Spellcheck => {
-                SPELLCHECK_DIRS.iter().any(|dir| Path::new(filepath).starts_with(dir))
-            }
-            lang => {
-                let exts: &[&str] = match lang {
-                    ExtraCheckLang::Py => &[".py"],
-                    ExtraCheckLang::Cpp => &[".cpp"],
-                    ExtraCheckLang::Shell => &[".sh"],
-                    ExtraCheckLang::Js => &[".js", ".ts"],
-                    ExtraCheckLang::Spellcheck => unreachable!(),
-                };
-                exts.iter().any(|ext| filepath.ends_with(ext))
+                if SPELLCHECK_DIRS.iter().any(|dir| Path::new(filepath).starts_with(dir)) {
+                    return true;
+                }
+                &[]
             }
-        }
+        };
+        exts.iter().any(|ext| filepath.ends_with(ext))
     }
 
     fn has_supported_kind(&self) -> bool {

From 78e096015deaf67999aafd1df88f3b08fdce4e4a Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Thu, 4 Sep 2025 14:57:41 +0800
Subject: [PATCH 0481/1889] Add cfg_attr predicate completion

Example
---
```rust
#[cfg_attr($0, must_use)]
struct Foo;
```
---
 .../src/completions/attribute.rs              |  2 +-
 .../ide-completion/src/tests/attribute.rs     | 52 +++++++++++++++++++
 2 files changed, 53 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/attribute.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/attribute.rs
index c542e140df541..e174b0c8922ab 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/attribute.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/attribute.rs
@@ -70,7 +70,7 @@ pub(crate) fn complete_known_attribute_input(
 
             lint::complete_lint(acc, ctx, colon_prefix, &existing_lints, &lints);
         }
-        ["cfg"] => cfg::complete_cfg(acc, ctx),
+        ["cfg"] | ["cfg_attr"] => cfg::complete_cfg(acc, ctx),
         ["macro_use"] => macro_use::complete_macro_use(
             acc,
             ctx,
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/tests/attribute.rs b/src/tools/rust-analyzer/crates/ide-completion/src/tests/attribute.rs
index 46a36300459d5..30e1e108c6c40 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/tests/attribute.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/tests/attribute.rs
@@ -835,6 +835,58 @@ mod cfg {
         );
     }
 
+    #[test]
+    fn inside_cfg_attr() {
+        check(
+            r#"
+//- /main.rs cfg:test,dbg=false,opt_level=2
+#[cfg_attr($0)]
+"#,
+            expect![[r#"
+                ba dbg
+                ba opt_level
+                ba test
+                ba true
+            "#]],
+        );
+        check(
+            r#"
+//- /main.rs cfg:test,dbg=false,opt_level=2
+#[cfg_attr(b$0)]
+"#,
+            expect![[r#"
+                ba dbg
+                ba opt_level
+                ba test
+                ba true
+            "#]],
+        );
+        check(
+            r#"
+//- /main.rs cfg:test,dbg=false,opt_level=2
+#[cfg_attr($0, allow(deprecated))]
+"#,
+            expect![[r#"
+                ba dbg
+                ba opt_level
+                ba test
+                ba true
+            "#]],
+        );
+        check(
+            r#"
+//- /main.rs cfg:test,dbg=false,opt_level=2
+#[cfg_attr(b$0, allow(deprecated))]
+"#,
+            expect![[r#"
+                ba dbg
+                ba opt_level
+                ba test
+                ba true
+            "#]],
+        );
+    }
+
     #[test]
     fn cfg_target_endian() {
         check(

From f19da67ed75468a2cb90572c065d1c3e2a8cadec Mon Sep 17 00:00:00 2001
From: bendn <bend.n@outlook.com>
Date: Thu, 4 Sep 2025 14:06:31 +0700
Subject: [PATCH 0482/1889] add test

---
 library/std/tests/path.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/library/std/tests/path.rs b/library/std/tests/path.rs
index 3577f0d9c7bb6..fa76c50597b05 100644
--- a/library/std/tests/path.rs
+++ b/library/std/tests/path.rs
@@ -2526,3 +2526,9 @@ fn normalize_lexically() {
         check_err(r"\\?\UNC\server\share\a\..\..");
     }
 }
+
+#[test]
+/// See issue#146183
+fn compare_path_to_str() {
+    assert!(&PathBuf::from("x") == "x");
+}

From 7a01c7f676cbffba4f14540ae90e4fd82f7b0af1 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Thu, 28 Aug 2025 13:01:40 +0000
Subject: [PATCH 0483/1889] Export __rdl_* symbols to the allocator shim when
 doing LTO

---
 compiler/rustc_codegen_ssa/src/back/lto.rs | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/compiler/rustc_codegen_ssa/src/back/lto.rs b/compiler/rustc_codegen_ssa/src/back/lto.rs
index e6df6a2469f37..f4a9037940a67 100644
--- a/compiler/rustc_codegen_ssa/src/back/lto.rs
+++ b/compiler/rustc_codegen_ssa/src/back/lto.rs
@@ -1,6 +1,7 @@
 use std::ffi::CString;
 use std::sync::Arc;
 
+use rustc_ast::expand::allocator::AllocatorKind;
 use rustc_data_structures::memmap::Mmap;
 use rustc_hir::def_id::{CrateNum, LOCAL_CRATE};
 use rustc_middle::middle::exported_symbols::{ExportedSymbol, SymbolExportInfo, SymbolExportLevel};
@@ -95,6 +96,19 @@ pub(super) fn exported_symbols_for_lto(
             .filter_map(|&(s, info): &(ExportedSymbol<'_>, SymbolExportInfo)| {
                 if info.level.is_below_threshold(export_threshold) || info.used {
                     Some(symbol_name_for_instance_in_crate(tcx, s, cnum))
+                } else if export_threshold == SymbolExportLevel::C
+                    && info.rustc_std_internal_symbol
+                    && let Some(AllocatorKind::Default) = allocator_kind_for_codegen(tcx)
+                {
+                    // Export the __rdl_* exports for usage by the allocator shim when not using
+                    // #[global_allocator]. Most of the conditions above are only used to avoid
+                    // unnecessary expensive symbol_name_for_instance_in_crate calls.
+                    let sym = symbol_name_for_instance_in_crate(tcx, s, cnum);
+                    if sym.contains("__rdl_") || sym.contains("__rg_oom") {
+                        Some(sym)
+                    } else {
+                        None
+                    }
                 } else {
                     None
                 }

From eea81b5d752f5310fcbd5ddae722afc7de0b8fa1 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Thu, 28 Aug 2025 09:54:42 +0000
Subject: [PATCH 0484/1889] Ensure the allocator shim never participates in LTO

Making it participate in LTO would be incorrect if you compile a crate
as both a dylib (which needs it) and rlib (which must not include it) in
the same rustc invocation. With linker plugin LTO, the allocator shim
will still participate in LTO as it is safe to do so in that case.
---
 compiler/rustc_codegen_ssa/src/back/write.rs | 20 +++++++++++---------
 compiler/rustc_codegen_ssa/src/base.rs       | 11 ++---------
 2 files changed, 13 insertions(+), 18 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
index 8586615f7c764..d6f289b3eee71 100644
--- a/compiler/rustc_codegen_ssa/src/back/write.rs
+++ b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -809,19 +809,12 @@ pub(crate) fn compute_per_cgu_lto_type(
     sess_lto: &Lto,
     opts: &config::Options,
     sess_crate_types: &[CrateType],
-    module_kind: ModuleKind,
 ) -> ComputedLtoType {
     // If the linker does LTO, we don't have to do it. Note that we
     // keep doing full LTO, if it is requested, as not to break the
     // assumption that the output will be a single module.
     let linker_does_lto = opts.cg.linker_plugin_lto.enabled();
 
-    // When we're automatically doing ThinLTO for multi-codegen-unit
-    // builds we don't actually want to LTO the allocator modules if
-    // it shows up. This is due to various linker shenanigans that
-    // we'll encounter later.
-    let is_allocator = module_kind == ModuleKind::Allocator;
-
     // We ignore a request for full crate graph LTO if the crate type
     // is only an rlib, as there is no full crate graph to process,
     // that'll happen later.
@@ -833,7 +826,7 @@ pub(crate) fn compute_per_cgu_lto_type(
     let is_rlib = matches!(sess_crate_types, [CrateType::Rlib]);
 
     match sess_lto {
-        Lto::ThinLocal if !linker_does_lto && !is_allocator => ComputedLtoType::Thin,
+        Lto::ThinLocal if !linker_does_lto => ComputedLtoType::Thin,
         Lto::Thin if !linker_does_lto && !is_rlib => ComputedLtoType::Thin,
         Lto::Fat if !is_rlib => ComputedLtoType::Fat,
         _ => ComputedLtoType::No,
@@ -855,7 +848,16 @@ fn execute_optimize_work_item<B: ExtraBackendMethods>(
     // back to the coordinator thread for further LTO processing (which
     // has to wait for all the initial modules to be optimized).
 
-    let lto_type = compute_per_cgu_lto_type(&cgcx.lto, &cgcx.opts, &cgcx.crate_types, module.kind);
+    // When we're automatically doing ThinLTO for multi-codegen-unit
+    // builds we don't actually want to LTO the allocator modules if
+    // it shows up. This is due to various linker shenanigans that
+    // we'll encounter later.
+    if module.kind == ModuleKind::Allocator {
+        let module = B::codegen(cgcx, module, module_config);
+        return WorkItemResult::Finished(module);
+    }
+
+    let lto_type = compute_per_cgu_lto_type(&cgcx.lto, &cgcx.opts, &cgcx.crate_types);
 
     // If we're doing some form of incremental LTO then we need to be sure to
     // save our module to disk first.
diff --git a/compiler/rustc_codegen_ssa/src/base.rs b/compiler/rustc_codegen_ssa/src/base.rs
index 97cdf8b697348..071bd09249ae3 100644
--- a/compiler/rustc_codegen_ssa/src/base.rs
+++ b/compiler/rustc_codegen_ssa/src/base.rs
@@ -46,9 +46,7 @@ use crate::meth::load_vtable;
 use crate::mir::operand::OperandValue;
 use crate::mir::place::PlaceRef;
 use crate::traits::*;
-use crate::{
-    CachedModuleCodegen, CodegenLintLevels, CrateInfo, ModuleCodegen, ModuleKind, errors, meth, mir,
-};
+use crate::{CachedModuleCodegen, CodegenLintLevels, CrateInfo, ModuleCodegen, errors, meth, mir};
 
 pub(crate) fn bin_op_to_icmp_predicate(op: BinOp, signed: bool) -> IntPredicate {
     match (op, signed) {
@@ -1135,12 +1133,7 @@ pub fn determine_cgu_reuse<'tcx>(tcx: TyCtxt<'tcx>, cgu: &CodegenUnit<'tcx>) ->
         // We can re-use either the pre- or the post-thinlto state. If no LTO is
         // being performed then we can use post-LTO artifacts, otherwise we must
         // reuse pre-LTO artifacts
-        match compute_per_cgu_lto_type(
-            &tcx.sess.lto(),
-            &tcx.sess.opts,
-            tcx.crate_types(),
-            ModuleKind::Regular,
-        ) {
+        match compute_per_cgu_lto_type(&tcx.sess.lto(), &tcx.sess.opts, tcx.crate_types()) {
             ComputedLtoType::No => CguReuse::PostLto,
             _ => CguReuse::PreLto,
         }

From 319fe230f0d960b343be31a1182dc0f10753156c Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Thu, 28 Aug 2025 10:26:29 +0000
Subject: [PATCH 0485/1889] Special case allocator module submission to avoid
 special casing it elsewhere

A lot of places had special handling just in case they would get an
allocator module even though most of these places could never get one or
would have a trivial implementation for the allocator module. Moving all
handling of the allocator module to a single place simplifies things a
fair bit.
---
 .../rustc_codegen_cranelift/src/driver/aot.rs |  11 +-
 compiler/rustc_codegen_gcc/src/back/lto.rs    |   2 +-
 compiler/rustc_codegen_llvm/src/back/lto.rs   |  22 +--
 compiler/rustc_codegen_ssa/src/back/write.rs  | 135 +++++++-----------
 compiler/rustc_codegen_ssa/src/base.rs        |  53 +++----
 compiler/rustc_codegen_ssa/src/lib.rs         |   2 -
 6 files changed, 79 insertions(+), 146 deletions(-)

diff --git a/compiler/rustc_codegen_cranelift/src/driver/aot.rs b/compiler/rustc_codegen_cranelift/src/driver/aot.rs
index 7e77781dc2fc1..c3adb5e767e25 100644
--- a/compiler/rustc_codegen_cranelift/src/driver/aot.rs
+++ b/compiler/rustc_codegen_cranelift/src/driver/aot.rs
@@ -12,9 +12,7 @@ use cranelift_object::{ObjectBuilder, ObjectModule};
 use rustc_codegen_ssa::assert_module_sources::CguReuse;
 use rustc_codegen_ssa::back::link::ensure_removed;
 use rustc_codegen_ssa::base::determine_cgu_reuse;
-use rustc_codegen_ssa::{
-    CodegenResults, CompiledModule, CrateInfo, ModuleKind, errors as ssa_errors,
-};
+use rustc_codegen_ssa::{CodegenResults, CompiledModule, CrateInfo, errors as ssa_errors};
 use rustc_data_structures::profiling::SelfProfilerRef;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_data_structures::sync::{IntoDynSyncSend, par_map};
@@ -363,7 +361,6 @@ fn emit_cgu(
         invocation_temp,
         prof,
         product.object,
-        ModuleKind::Regular,
         name.clone(),
         producer,
     )?;
@@ -372,7 +369,6 @@ fn emit_cgu(
         module_regular,
         module_global_asm: global_asm_object_file.map(|global_asm_object_file| CompiledModule {
             name: format!("{name}.asm"),
-            kind: ModuleKind::Regular,
             object: Some(global_asm_object_file),
             dwarf_object: None,
             bytecode: None,
@@ -389,7 +385,6 @@ fn emit_module(
     invocation_temp: Option<&str>,
     prof: &SelfProfilerRef,
     mut object: cranelift_object::object::write::Object<'_>,
-    kind: ModuleKind,
     name: String,
     producer_str: &str,
 ) -> Result<CompiledModule, String> {
@@ -430,7 +425,6 @@ fn emit_module(
 
     Ok(CompiledModule {
         name,
-        kind,
         object: Some(tmp_file),
         dwarf_object: None,
         bytecode: None,
@@ -485,7 +479,6 @@ fn reuse_workproduct_for_cgu(
     Ok(ModuleCodegenResult {
         module_regular: CompiledModule {
             name: cgu.name().to_string(),
-            kind: ModuleKind::Regular,
             object: Some(obj_out_regular),
             dwarf_object: None,
             bytecode: None,
@@ -495,7 +488,6 @@ fn reuse_workproduct_for_cgu(
         },
         module_global_asm: source_file_global_asm.map(|source_file| CompiledModule {
             name: cgu.name().to_string(),
-            kind: ModuleKind::Regular,
             object: Some(obj_out_global_asm),
             dwarf_object: None,
             bytecode: None,
@@ -651,7 +643,6 @@ fn emit_allocator_module(tcx: TyCtxt<'_>) -> Option<CompiledModule> {
             tcx.sess.invocation_temp.as_deref(),
             &tcx.sess.prof,
             product.object,
-            ModuleKind::Allocator,
             "allocator_shim".to_owned(),
             &crate::debuginfo::producer(tcx.sess),
         ) {
diff --git a/compiler/rustc_codegen_gcc/src/back/lto.rs b/compiler/rustc_codegen_gcc/src/back/lto.rs
index fcee6b6df6234..9d8ce2383f2b1 100644
--- a/compiler/rustc_codegen_gcc/src/back/lto.rs
+++ b/compiler/rustc_codegen_gcc/src/back/lto.rs
@@ -204,7 +204,7 @@ fn fat_lto(
             let path = tmp_path.path().to_path_buf().join(&module.name);
             let path = path.to_str().expect("path");
             let context = &module.module_llvm.context;
-            let config = cgcx.config(module.kind);
+            let config = &cgcx.module_config;
             // NOTE: we need to set the optimization level here in order for LTO to do its job.
             context.set_optimization_level(to_gcc_opt_level(config.opt_level));
             context.add_command_line_option("-flto=auto");
diff --git a/compiler/rustc_codegen_llvm/src/back/lto.rs b/compiler/rustc_codegen_llvm/src/back/lto.rs
index fc38c4f3e5138..326b876e7e689 100644
--- a/compiler/rustc_codegen_llvm/src/back/lto.rs
+++ b/compiler/rustc_codegen_llvm/src/back/lto.rs
@@ -11,7 +11,7 @@ use object::{Object, ObjectSection};
 use rustc_codegen_ssa::back::lto::{SerializedModule, ThinModule, ThinShared};
 use rustc_codegen_ssa::back::write::{CodegenContext, FatLtoInput};
 use rustc_codegen_ssa::traits::*;
-use rustc_codegen_ssa::{ModuleCodegen, ModuleKind, looks_like_rust_object_file};
+use rustc_codegen_ssa::{ModuleCodegen, looks_like_rust_object_file};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::memmap::Mmap;
 use rustc_errors::DiagCtxtHandle;
@@ -43,9 +43,7 @@ fn prepare_lto(
         .map(|symbol| CString::new(symbol.to_owned()).unwrap())
         .collect::<Vec<CString>>();
 
-    if cgcx.regular_module_config.instrument_coverage
-        || cgcx.regular_module_config.pgo_gen.enabled()
-    {
+    if cgcx.module_config.instrument_coverage || cgcx.module_config.pgo_gen.enabled() {
         // These are weak symbols that point to the profile version and the
         // profile name, which need to be treated as exported so LTO doesn't nix
         // them.
@@ -55,15 +53,15 @@ fn prepare_lto(
         symbols_below_threshold.extend(PROFILER_WEAK_SYMBOLS.iter().map(|&sym| sym.to_owned()));
     }
 
-    if cgcx.regular_module_config.sanitizer.contains(SanitizerSet::MEMORY) {
+    if cgcx.module_config.sanitizer.contains(SanitizerSet::MEMORY) {
         let mut msan_weak_symbols = Vec::new();
 
         // Similar to profiling, preserve weak msan symbol during LTO.
-        if cgcx.regular_module_config.sanitizer_recover.contains(SanitizerSet::MEMORY) {
+        if cgcx.module_config.sanitizer_recover.contains(SanitizerSet::MEMORY) {
             msan_weak_symbols.push(c"__msan_keep_going");
         }
 
-        if cgcx.regular_module_config.sanitizer_memory_track_origins != 0 {
+        if cgcx.module_config.sanitizer_memory_track_origins != 0 {
             msan_weak_symbols.push(c"__msan_track_origins");
         }
 
@@ -227,15 +225,9 @@ fn fat_lto(
     // All the other modules will be serialized and reparsed into the new
     // context, so this hopefully avoids serializing and parsing the largest
     // codegen unit.
-    //
-    // Additionally use a regular module as the base here to ensure that various
-    // file copy operations in the backend work correctly. The only other kind
-    // of module here should be an allocator one, and if your crate is smaller
-    // than the allocator module then the size doesn't really matter anyway.
     let costliest_module = in_memory
         .iter()
         .enumerate()
-        .filter(|&(_, module)| module.kind == ModuleKind::Regular)
         .map(|(i, module)| {
             let cost = unsafe { llvm::LLVMRustModuleCost(module.module_llvm.llmod()) };
             (cost, i)
@@ -583,7 +575,7 @@ pub(crate) fn run_pass_manager(
     thin: bool,
 ) {
     let _timer = cgcx.prof.generic_activity_with_arg("LLVM_lto_optimize", &*module.name);
-    let config = cgcx.config(module.kind);
+    let config = &cgcx.module_config;
 
     // Now we have one massive module inside of llmod. Time to run the
     // LTO-specific optimization passes that LLVM provides.
@@ -745,7 +737,7 @@ pub(crate) fn optimize_thin_module(
     let module_llvm = ModuleLlvm::parse(cgcx, module_name, thin_module.data(), dcx);
     let mut module = ModuleCodegen::new_regular(thin_module.name(), module_llvm);
     // Given that the newly created module lacks a thinlto buffer for embedding, we need to re-add it here.
-    if cgcx.config(ModuleKind::Regular).embed_bitcode() {
+    if cgcx.module_config.embed_bitcode() {
         module.thin_lto_buffer = Some(thin_module.data().to_vec());
     }
     {
diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
index d6f289b3eee71..f637e7f58dbf7 100644
--- a/compiler/rustc_codegen_ssa/src/back/write.rs
+++ b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -333,8 +333,7 @@ pub struct CodegenContext<B: WriteBackendMethods> {
     pub crate_types: Vec<CrateType>,
     pub output_filenames: Arc<OutputFilenames>,
     pub invocation_temp: Option<String>,
-    pub regular_module_config: Arc<ModuleConfig>,
-    pub allocator_module_config: Arc<ModuleConfig>,
+    pub module_config: Arc<ModuleConfig>,
     pub tm_factory: TargetMachineFactoryFn<B>,
     pub msvc_imps_needed: bool,
     pub is_pe_coff: bool,
@@ -372,13 +371,6 @@ impl<B: WriteBackendMethods> CodegenContext<B> {
     pub fn create_dcx(&self) -> DiagCtxt {
         DiagCtxt::new(Box::new(self.diag_emitter.clone()))
     }
-
-    pub fn config(&self, kind: ModuleKind) -> &ModuleConfig {
-        match kind {
-            ModuleKind::Regular => &self.regular_module_config,
-            ModuleKind::Allocator => &self.allocator_module_config,
-        }
-    }
 }
 
 fn generate_thin_lto_work<B: ExtraBackendMethods>(
@@ -442,6 +434,7 @@ pub(crate) fn start_async_codegen<B: ExtraBackendMethods>(
     backend: B,
     tcx: TyCtxt<'_>,
     target_cpu: String,
+    allocator_module: Option<ModuleCodegen<B::Module>>,
 ) -> OngoingCodegen<B> {
     let (coordinator_send, coordinator_receive) = channel();
 
@@ -465,6 +458,7 @@ pub(crate) fn start_async_codegen<B: ExtraBackendMethods>(
         coordinator_receive,
         Arc::new(regular_config),
         Arc::new(allocator_config),
+        allocator_module,
         coordinator_send.clone(),
     );
 
@@ -495,7 +489,7 @@ fn copy_all_cgu_workproducts_to_incr_comp_cache_dir(
 
     let _timer = sess.timer("copy_all_cgu_workproducts_to_incr_comp_cache_dir");
 
-    for module in compiled_modules.modules.iter().filter(|m| m.kind == ModuleKind::Regular) {
+    for module in &compiled_modules.modules {
         let mut files = Vec::new();
         if let Some(object_file_path) = &module.object {
             files.push((OutputType::Object.extension(), object_file_path.as_path()));
@@ -720,15 +714,6 @@ pub(crate) enum WorkItem<B: WriteBackendMethods> {
 }
 
 impl<B: WriteBackendMethods> WorkItem<B> {
-    fn module_kind(&self) -> ModuleKind {
-        match *self {
-            WorkItem::Optimize(ref m) => m.kind,
-            WorkItem::CopyPostLtoArtifacts(_) | WorkItem::FatLto { .. } | WorkItem::ThinLto(_) => {
-                ModuleKind::Regular
-            }
-        }
-    }
-
     /// Generate a short description of this work item suitable for use as a thread name.
     fn short_description(&self) -> String {
         // `pthread_setname()` on *nix ignores anything beyond the first 15
@@ -836,32 +821,22 @@ pub(crate) fn compute_per_cgu_lto_type(
 fn execute_optimize_work_item<B: ExtraBackendMethods>(
     cgcx: &CodegenContext<B>,
     mut module: ModuleCodegen<B::Module>,
-    module_config: &ModuleConfig,
 ) -> WorkItemResult<B> {
     let dcx = cgcx.create_dcx();
     let dcx = dcx.handle();
 
-    B::optimize(cgcx, dcx, &mut module, module_config);
+    B::optimize(cgcx, dcx, &mut module, &cgcx.module_config);
 
     // After we've done the initial round of optimizations we need to
     // decide whether to synchronously codegen this module or ship it
     // back to the coordinator thread for further LTO processing (which
     // has to wait for all the initial modules to be optimized).
 
-    // When we're automatically doing ThinLTO for multi-codegen-unit
-    // builds we don't actually want to LTO the allocator modules if
-    // it shows up. This is due to various linker shenanigans that
-    // we'll encounter later.
-    if module.kind == ModuleKind::Allocator {
-        let module = B::codegen(cgcx, module, module_config);
-        return WorkItemResult::Finished(module);
-    }
-
     let lto_type = compute_per_cgu_lto_type(&cgcx.lto, &cgcx.opts, &cgcx.crate_types);
 
     // If we're doing some form of incremental LTO then we need to be sure to
     // save our module to disk first.
-    let bitcode = if cgcx.config(module.kind).emit_pre_lto_bc {
+    let bitcode = if cgcx.module_config.emit_pre_lto_bc {
         let filename = pre_lto_bitcode_filename(&module.name);
         cgcx.incr_comp_session_dir.as_ref().map(|path| path.join(&filename))
     } else {
@@ -870,7 +845,7 @@ fn execute_optimize_work_item<B: ExtraBackendMethods>(
 
     match lto_type {
         ComputedLtoType::No => {
-            let module = B::codegen(cgcx, module, module_config);
+            let module = B::codegen(cgcx, module, &cgcx.module_config);
             WorkItemResult::Finished(module)
         }
         ComputedLtoType::Thin => {
@@ -901,7 +876,6 @@ fn execute_optimize_work_item<B: ExtraBackendMethods>(
 fn execute_copy_from_cache_work_item<B: ExtraBackendMethods>(
     cgcx: &CodegenContext<B>,
     module: CachedModuleCodegen,
-    module_config: &ModuleConfig,
 ) -> WorkItemResult<B> {
     let incr_comp_session_dir = cgcx.incr_comp_session_dir.as_ref().unwrap();
 
@@ -961,6 +935,7 @@ fn execute_copy_from_cache_work_item<B: ExtraBackendMethods>(
         }
     };
 
+    let module_config = &cgcx.module_config;
     let should_emit_obj = module_config.emit_obj != EmitObj::None;
     let assembly = load_from_incr_cache(module_config.emit_asm, OutputType::Assembly);
     let llvm_ir = load_from_incr_cache(module_config.emit_ir, OutputType::LlvmAssembly);
@@ -973,7 +948,6 @@ fn execute_copy_from_cache_work_item<B: ExtraBackendMethods>(
     WorkItemResult::Finished(CompiledModule {
         links_from_incr_cache,
         name: module.name,
-        kind: ModuleKind::Regular,
         object,
         dwarf_object,
         bytecode,
@@ -988,7 +962,6 @@ fn execute_fat_lto_work_item<B: ExtraBackendMethods>(
     each_linked_rlib_for_lto: &[PathBuf],
     mut needs_fat_lto: Vec<FatLtoInput<B>>,
     import_only_modules: Vec<(SerializedModule<B::ModuleBuffer>, WorkProduct)>,
-    module_config: &ModuleConfig,
 ) -> WorkItemResult<B> {
     for (module, wp) in import_only_modules {
         needs_fat_lto.push(FatLtoInput::Serialized { name: wp.cgu_name, buffer: module })
@@ -1000,17 +973,16 @@ fn execute_fat_lto_work_item<B: ExtraBackendMethods>(
         each_linked_rlib_for_lto,
         needs_fat_lto,
     );
-    let module = B::codegen(cgcx, module, module_config);
+    let module = B::codegen(cgcx, module, &cgcx.module_config);
     WorkItemResult::Finished(module)
 }
 
 fn execute_thin_lto_work_item<B: ExtraBackendMethods>(
     cgcx: &CodegenContext<B>,
     module: lto::ThinModule<B>,
-    module_config: &ModuleConfig,
 ) -> WorkItemResult<B> {
     let module = B::optimize_thin(cgcx, module);
-    let module = B::codegen(cgcx, module, module_config);
+    let module = B::codegen(cgcx, module, &cgcx.module_config);
     WorkItemResult::Finished(module)
 }
 
@@ -1095,6 +1067,7 @@ fn start_executing_work<B: ExtraBackendMethods>(
     coordinator_receive: Receiver<Message<B>>,
     regular_config: Arc<ModuleConfig>,
     allocator_config: Arc<ModuleConfig>,
+    allocator_module: Option<ModuleCodegen<B::Module>>,
     tx_to_llvm_workers: Sender<Message<B>>,
 ) -> thread::JoinHandle<Result<CompiledModules, ()>> {
     let coordinator_send = tx_to_llvm_workers;
@@ -1159,8 +1132,7 @@ fn start_executing_work<B: ExtraBackendMethods>(
         expanded_args: tcx.sess.expanded_args.clone(),
         diag_emitter: shared_emitter.clone(),
         output_filenames: Arc::clone(tcx.output_filenames(())),
-        regular_module_config: regular_config,
-        allocator_module_config: allocator_config,
+        module_config: regular_config,
         tm_factory: backend.target_machine_factory(tcx.sess, ol, backend_features),
         msvc_imps_needed: msvc_imps_needed(tcx),
         is_pe_coff: tcx.sess.target.is_like_windows,
@@ -1175,6 +1147,11 @@ fn start_executing_work<B: ExtraBackendMethods>(
         invocation_temp: sess.invocation_temp.clone(),
     };
 
+    let compiled_allocator_module = allocator_module.map(|mut allocator_module| {
+        B::optimize(&cgcx, tcx.sess.dcx(), &mut allocator_module, &allocator_config);
+        B::codegen(&cgcx, allocator_module, &allocator_config)
+    });
+
     // This is the "main loop" of parallel work happening for parallel codegen.
     // It's here that we manage parallelism, schedule work, and work with
     // messages coming from clients.
@@ -1314,7 +1291,6 @@ fn start_executing_work<B: ExtraBackendMethods>(
         // This is where we collect codegen units that have gone all the way
         // through codegen and LLVM.
         let mut compiled_modules = vec![];
-        let mut compiled_allocator_module = None;
         let mut needs_fat_lto = Vec::new();
         let mut needs_thin_lto = Vec::new();
         let mut lto_import_only_modules = Vec::new();
@@ -1588,15 +1564,7 @@ fn start_executing_work<B: ExtraBackendMethods>(
 
                     match result {
                         Ok(WorkItemResult::Finished(compiled_module)) => {
-                            match compiled_module.kind {
-                                ModuleKind::Regular => {
-                                    compiled_modules.push(compiled_module);
-                                }
-                                ModuleKind::Allocator => {
-                                    assert!(compiled_allocator_module.is_none());
-                                    compiled_allocator_module = Some(compiled_module);
-                                }
-                            }
+                            compiled_modules.push(compiled_module);
                         }
                         Ok(WorkItemResult::NeedsFatLto(fat_lto_input)) => {
                             assert!(!started_lto);
@@ -1724,45 +1692,38 @@ fn spawn_work<'a, B: ExtraBackendMethods>(
     let cgcx = cgcx.clone();
 
     B::spawn_named_thread(cgcx.time_trace, work.short_description(), move || {
-        let result = std::panic::catch_unwind(AssertUnwindSafe(|| {
-            let module_config = cgcx.config(work.module_kind());
-
-            match work {
-                WorkItem::Optimize(m) => {
-                    let _timer =
-                        cgcx.prof.generic_activity_with_arg("codegen_module_optimize", &*m.name);
-                    execute_optimize_work_item(&cgcx, m, module_config)
-                }
-                WorkItem::CopyPostLtoArtifacts(m) => {
-                    let _timer = cgcx.prof.generic_activity_with_arg(
-                        "codegen_copy_artifacts_from_incr_cache",
-                        &*m.name,
-                    );
-                    execute_copy_from_cache_work_item(&cgcx, m, module_config)
-                }
-                WorkItem::FatLto {
-                    exported_symbols_for_lto,
-                    each_linked_rlib_for_lto,
+        let result = std::panic::catch_unwind(AssertUnwindSafe(|| match work {
+            WorkItem::Optimize(m) => {
+                let _timer =
+                    cgcx.prof.generic_activity_with_arg("codegen_module_optimize", &*m.name);
+                execute_optimize_work_item(&cgcx, m)
+            }
+            WorkItem::CopyPostLtoArtifacts(m) => {
+                let _timer = cgcx
+                    .prof
+                    .generic_activity_with_arg("codegen_copy_artifacts_from_incr_cache", &*m.name);
+                execute_copy_from_cache_work_item(&cgcx, m)
+            }
+            WorkItem::FatLto {
+                exported_symbols_for_lto,
+                each_linked_rlib_for_lto,
+                needs_fat_lto,
+                import_only_modules,
+            } => {
+                let _timer =
+                    cgcx.prof.generic_activity_with_arg("codegen_module_perform_lto", "everything");
+                execute_fat_lto_work_item(
+                    &cgcx,
+                    &exported_symbols_for_lto,
+                    &each_linked_rlib_for_lto,
                     needs_fat_lto,
                     import_only_modules,
-                } => {
-                    let _timer = cgcx
-                        .prof
-                        .generic_activity_with_arg("codegen_module_perform_lto", "everything");
-                    execute_fat_lto_work_item(
-                        &cgcx,
-                        &exported_symbols_for_lto,
-                        &each_linked_rlib_for_lto,
-                        needs_fat_lto,
-                        import_only_modules,
-                        module_config,
-                    )
-                }
-                WorkItem::ThinLto(m) => {
-                    let _timer =
-                        cgcx.prof.generic_activity_with_arg("codegen_module_perform_lto", m.name());
-                    execute_thin_lto_work_item(&cgcx, m, module_config)
-                }
+                )
+            }
+            WorkItem::ThinLto(m) => {
+                let _timer =
+                    cgcx.prof.generic_activity_with_arg("codegen_module_perform_lto", m.name());
+                execute_thin_lto_work_item(&cgcx, m)
             }
         }));
 
diff --git a/compiler/rustc_codegen_ssa/src/base.rs b/compiler/rustc_codegen_ssa/src/base.rs
index 071bd09249ae3..a9a2ae1b3dbca 100644
--- a/compiler/rustc_codegen_ssa/src/base.rs
+++ b/compiler/rustc_codegen_ssa/src/base.rs
@@ -662,7 +662,7 @@ pub fn codegen_crate<B: ExtraBackendMethods>(
 ) -> OngoingCodegen<B> {
     // Skip crate items and just output metadata in -Z no-codegen mode.
     if tcx.sess.opts.unstable_opts.no_codegen || !tcx.sess.opts.output_types.should_codegen() {
-        let ongoing_codegen = start_async_codegen(backend, tcx, target_cpu);
+        let ongoing_codegen = start_async_codegen(backend, tcx, target_cpu, None);
 
         ongoing_codegen.codegen_finished(tcx);
 
@@ -693,7 +693,27 @@ pub fn codegen_crate<B: ExtraBackendMethods>(
         }
     }
 
-    let ongoing_codegen = start_async_codegen(backend.clone(), tcx, target_cpu);
+    // Codegen an allocator shim, if necessary.
+    let allocator_module = if let Some(kind) = allocator_kind_for_codegen(tcx) {
+        let llmod_id =
+            cgu_name_builder.build_cgu_name(LOCAL_CRATE, &["crate"], Some("allocator")).to_string();
+
+        tcx.sess.time("write_allocator_module", || {
+            let module = backend.codegen_allocator(
+                tcx,
+                &llmod_id,
+                kind,
+                // If allocator_kind is Some then alloc_error_handler_kind must
+                // also be Some.
+                tcx.alloc_error_handler_kind(()).unwrap(),
+            );
+            Some(ModuleCodegen::new_allocator(llmod_id, module))
+        })
+    } else {
+        None
+    };
+
+    let ongoing_codegen = start_async_codegen(backend.clone(), tcx, target_cpu, allocator_module);
 
     // For better throughput during parallel processing by LLVM, we used to sort
     // CGUs largest to smallest. This would lead to better thread utilization
@@ -810,35 +830,6 @@ pub fn codegen_crate<B: ExtraBackendMethods>(
         }
     }
 
-    // Codegen an allocator shim, if necessary.
-    // Do this last to ensure the LLVM_passes timer doesn't start while no CGUs have been codegened
-    // yet for the backend to optimize.
-    if let Some(kind) = allocator_kind_for_codegen(tcx) {
-        let llmod_id =
-            cgu_name_builder.build_cgu_name(LOCAL_CRATE, &["crate"], Some("allocator")).to_string();
-        let module_llvm = tcx.sess.time("write_allocator_module", || {
-            backend.codegen_allocator(
-                tcx,
-                &llmod_id,
-                kind,
-                // If allocator_kind is Some then alloc_error_handler_kind must
-                // also be Some.
-                tcx.alloc_error_handler_kind(()).unwrap(),
-            )
-        });
-
-        ongoing_codegen.wait_for_signal_to_codegen_item();
-        ongoing_codegen.check_for_errors(tcx.sess);
-
-        // These modules are generally cheap and won't throw off scheduling.
-        let cost = 0;
-        submit_codegened_module_to_llvm(
-            &ongoing_codegen.coordinator,
-            ModuleCodegen::new_allocator(llmod_id, module_llvm),
-            cost,
-        );
-    }
-
     ongoing_codegen.codegen_finished(tcx);
 
     // Since the main thread is sometimes blocked during codegen, we keep track
diff --git a/compiler/rustc_codegen_ssa/src/lib.rs b/compiler/rustc_codegen_ssa/src/lib.rs
index fe0500a5d4cf7..5b90ffaa05666 100644
--- a/compiler/rustc_codegen_ssa/src/lib.rs
+++ b/compiler/rustc_codegen_ssa/src/lib.rs
@@ -120,7 +120,6 @@ impl<M> ModuleCodegen<M> {
 
         CompiledModule {
             name: self.name.clone(),
-            kind: self.kind,
             object,
             dwarf_object,
             bytecode,
@@ -134,7 +133,6 @@ impl<M> ModuleCodegen<M> {
 #[derive(Debug, Encodable, Decodable)]
 pub struct CompiledModule {
     pub name: String,
-    pub kind: ModuleKind,
     pub object: Option<PathBuf>,
     pub dwarf_object: Option<PathBuf>,
     pub bytecode: Option<PathBuf>,

From 169013d9eaae1d0b3d4d07058017698837ee09ff Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Thu, 4 Sep 2025 12:10:39 +0300
Subject: [PATCH 0486/1889] Fix typo in config

To make it backwards-compatible.
---
 src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
index c2252185a3aa3..84f158cdea69f 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
@@ -2832,7 +2832,7 @@ enum ReborrowHintsDef {
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(rename_all = "snake_case")]
 enum AdjustmentHintsDef {
-    #[serde(alias = "Reborrow")]
+    #[serde(alias = "reborrow")]
     Borrows,
     #[serde(with = "true_or_always")]
     #[serde(untagged)]

From d5cb7e7c7c0f77c7a7b064584ae44e74acc155ca Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Thu, 4 Sep 2025 12:18:22 +0300
Subject: [PATCH 0487/1889] Add a regression test for a fixed new trait solver
 bug

Not sure what exactly fixed it, but why not.
---
 .../hir-ty/src/tests/regression/new_solver.rs | 23 ++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
index 20190fbc04564..e4ee52f45eb75 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
@@ -1,6 +1,6 @@
 use expect_test::expect;
 
-use super::check_infer;
+use crate::tests::{check_infer, check_no_mismatches};
 
 #[test]
 fn opaque_generics() {
@@ -50,3 +50,24 @@ fn main() {
         "#]],
     );
 }
+
+#[test]
+fn regression_20487() {
+    check_no_mismatches(
+        r#"
+//- minicore: coerce_unsized, dispatch_from_dyn
+trait Foo {
+    fn bar(&self) -> u32 {
+        0xCAFE
+    }
+}
+
+fn debug(_: &dyn Foo) {}
+
+impl Foo for i32 {}
+
+fn main() {
+    debug(&1);
+}"#,
+    );
+}

From 07ae014a929344156e0fc4abbe7841fb770a71e4 Mon Sep 17 00:00:00 2001
From: emmet-horgan <80120110+emmet-horgan@users.noreply.github.com>
Date: Thu, 4 Sep 2025 10:56:58 +0100
Subject: [PATCH 0488/1889] Update src/appendix/code-index.md

Fix display string

Co-authored-by: Tshepang Mbambo <hopsi@tuta.io>
---
 src/doc/rustc-dev-guide/src/appendix/code-index.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/src/appendix/code-index.md b/src/doc/rustc-dev-guide/src/appendix/code-index.md
index 0ad7244393523..4ddb58b0c39ba 100644
--- a/src/doc/rustc-dev-guide/src/appendix/code-index.md
+++ b/src/doc/rustc-dev-guide/src/appendix/code-index.md
@@ -13,7 +13,7 @@ Item            |  Kind    | Short description           | Chapter            |
 `DefId` | struct | One of four types of HIR node identifiers | [Identifiers in the HIR] | [compiler/rustc_hir/src/def_id.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/def_id/struct.DefId.html)
 `Diag` | struct | A struct for a compiler diagnostic, such as an error or lint | [Emitting Diagnostics] | [compiler/rustc_errors/src/diagnostic.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_errors/struct.Diag.html)
 `DocContext` | struct | A state container used by rustdoc when crawling through a crate to gather its documentation | [Rustdoc] | [src/librustdoc/core.rs](https://github.com/rust-lang/rust/blob/master/src/librustdoc/core.rs)
-`HirId` | struct | One of four types of HIR node identifiers | [Identifiers in the HIR] | [compiler/rustc_hir/src/hir_id.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/struct.HirId.html)
+`HirId` | struct | One of four types of HIR node identifiers | [Identifiers in the HIR] | [compiler/rustc_hir_id/src/lib.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/struct.HirId.html)
 `Lexer` | struct | This is the lexer used during parsing. It consumes characters from the raw source code being compiled and produces a series of tokens for use by the rest of the parser | [The parser] |  [compiler/rustc_parse/src/lexer/mod.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_parse/lexer/struct.Lexer.html)
 `NodeId` | struct | One of four types of HIR node identifiers. Being phased out | [Identifiers in the HIR] | [compiler/rustc_ast/src/ast.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/node_id/struct.NodeId.html)
 `P` | struct | An owned immutable smart pointer. By contrast, `&T` is not owned, and `Box<T>` is not immutable. | None | [compiler/rustc_ast/src/ptr.rs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/ptr/struct.P.html)

From 7ad4c6ac02e9bbb93f7c89809be37f7e7d684b9c Mon Sep 17 00:00:00 2001
From: emmet-horgan <80120110+emmet-horgan@users.noreply.github.com>
Date: Thu, 4 Sep 2025 11:00:25 +0100
Subject: [PATCH 0489/1889] Update src/compiler-debugging.md

Change to public abi

Co-authored-by: Tshepang Mbambo <hopsi@tuta.io>
---
 src/doc/rustc-dev-guide/src/compiler-debugging.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/src/compiler-debugging.md b/src/doc/rustc-dev-guide/src/compiler-debugging.md
index 5ceb5dfe811cc..f451447041802 100644
--- a/src/doc/rustc-dev-guide/src/compiler-debugging.md
+++ b/src/doc/rustc-dev-guide/src/compiler-debugging.md
@@ -367,7 +367,7 @@ error: layout_of(&'a u32) = Layout {
 error: aborting due to previous error
 ```
 
-[`Layout`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_abi/struct.Layout.html
+[`Layout`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_public/abi/struct.Layout.html
 
 
 ## Configuring CodeLLDB for debugging `rustc`

From 17b27d8e6c7ecce909d3b0bd072378c7a0854d78 Mon Sep 17 00:00:00 2001
From: klensy <klensy@users.noreply.github.com>
Date: Thu, 4 Jul 2024 14:43:27 +0300
Subject: [PATCH 0490/1889] unpin tracing_core

---
 Cargo.lock                    | 4 ++--
 compiler/rustc_log/Cargo.toml | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a8df53f3a4113..d9a09e5b2304b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5541,9 +5541,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-core"
-version = "0.1.30"
+version = "0.1.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24eb03ba0eab1fd845050058ce5e616558e8f8d8fca633e6b163fe25c797213a"
+checksum = "b9d12581f227e93f094d3af2ae690a574abb8a2b9b7a96e7cfe9647b2b617678"
 dependencies = [
  "once_cell",
  "valuable",
diff --git a/compiler/rustc_log/Cargo.toml b/compiler/rustc_log/Cargo.toml
index c673d51a1d456..2332ff9b323b2 100644
--- a/compiler/rustc_log/Cargo.toml
+++ b/compiler/rustc_log/Cargo.toml
@@ -5,8 +5,8 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-tracing = "0.1.28"
-tracing-core = "=0.1.30" # FIXME(Nilstrieb) tracing has a deadlock: https://github.com/tokio-rs/tracing/issues/2635
+# tracing > 0.1.37 have huge binary size / instructions regression
+tracing = "=0.1.37"
 tracing-subscriber = { version = "0.3.3", default-features = false, features = ["fmt", "env-filter", "smallvec", "parking_lot", "ansi"] }
 tracing-tree = "0.3.1"
 # tidy-alphabetical-end

From 267d3c85088ebea128ef4b88435ceda937f306cd Mon Sep 17 00:00:00 2001
From: klensy <klensy@users.noreply.github.com>
Date: Thu, 4 Jul 2024 14:47:37 +0300
Subject: [PATCH 0491/1889] rustc_log: remove direct dep on tracing_core

required features reexported from tracing
---
 Cargo.lock                    | 1 -
 compiler/rustc_log/src/lib.rs | 2 +-
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d9a09e5b2304b..e5bae301d6286 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4072,7 +4072,6 @@ name = "rustc_log"
 version = "0.0.0"
 dependencies = [
  "tracing",
- "tracing-core",
  "tracing-subscriber",
  "tracing-tree",
 ]
diff --git a/compiler/rustc_log/src/lib.rs b/compiler/rustc_log/src/lib.rs
index df648bbd48951..26475eec1c102 100644
--- a/compiler/rustc_log/src/lib.rs
+++ b/compiler/rustc_log/src/lib.rs
@@ -38,7 +38,7 @@ use std::fmt::{self, Display};
 use std::io::{self, IsTerminal};
 
 use tracing::dispatcher::SetGlobalDefaultError;
-use tracing_core::{Event, Subscriber};
+use tracing::{Event, Subscriber};
 use tracing_subscriber::filter::{Directive, EnvFilter, LevelFilter};
 use tracing_subscriber::fmt::FmtContext;
 use tracing_subscriber::fmt::format::{self, FormatEvent, FormatFields};

From 9c6c5df2c47a2f93bc159427e109adb26a3b7f6d Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 4 Sep 2025 12:29:52 +0200
Subject: [PATCH 0492/1889] triagebot: fix rustc_allow_const_fn_unstable
 matcher

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

diff --git a/triagebot.toml b/triagebot.toml
index fd6329de923b6..b957c6465e602 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -1313,7 +1313,7 @@ message = """
 and explores the possible non-determinism of the intrinsic.
 """
 cc = ["@rust-lang/miri"]
-[mentions."#[rustc_allow_const_fn_unstable]"]
+[mentions."#[rustc_allow_const_fn_unstable"]
 type = "content"
 message = """
 `#[rustc_allow_const_fn_unstable]` needs careful audit to avoid accidentally exposing unstable

From 1e37c1fe2e29d88d4843e7c0ce46e50edd9f7251 Mon Sep 17 00:00:00 2001
From: bendn <bend.n@outlook.com>
Date: Thu, 4 Sep 2025 14:06:44 +0700
Subject: [PATCH 0493/1889] fix

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

diff --git a/library/std/src/path.rs b/library/std/src/path.rs
index 531a1aa421536..19663e4a9df62 100644
--- a/library/std/src/path.rs
+++ b/library/std/src/path.rs
@@ -2107,7 +2107,7 @@ impl PartialEq for PathBuf {
 impl cmp::PartialEq<str> for PathBuf {
     #[inline]
     fn eq(&self, other: &str) -> bool {
-        &*self == other
+        Path::eq(self, other)
     }
 }
 

From 2a7331a80d1d4b312fec16e6f1d186f77259c6db Mon Sep 17 00:00:00 2001
From: Emmet Horgan <emmet.horgan@analog.com>
Date: Thu, 4 Sep 2025 12:46:12 +0100
Subject: [PATCH 0494/1889] Fix user facing string

Signed-off-by: Emmet Horgan <emmet.horgan@analog.com>
---
 src/doc/rustc-dev-guide/src/tests/directives.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/tests/directives.md b/src/doc/rustc-dev-guide/src/tests/directives.md
index c6d83e82ab196..f58ee669a25dd 100644
--- a/src/doc/rustc-dev-guide/src/tests/directives.md
+++ b/src/doc/rustc-dev-guide/src/tests/directives.md
@@ -36,9 +36,9 @@ directive.
 The following is a list of compiletest directives. Directives are linked to
 sections that describe the command in more detail if available. This list may
 not be exhaustive. Directives can generally be found by browsing the
-`TestProps` structure found in [`header.rs`] from the compiletest source.
+`TestProps` structure found in [`directives.rs`] from the compiletest source.
 
-[`header.rs`]: https://github.com/rust-lang/rust/tree/master/src/tools/compiletest/src/directives.rs
+[`directives.rs`]: https://github.com/rust-lang/rust/tree/master/src/tools/compiletest/src/directives.rs
 
 ### Assembly
 

From b5f2a71f55efefcd2560f774b5f157e626630180 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Thu, 4 Sep 2025 14:17:55 +0200
Subject: [PATCH 0495/1889] Document Cargo with in-tree rustdoc

---
 src/bootstrap/src/core/build_steps/doc.rs | 70 +++++++++++++++--------
 src/bootstrap/src/core/builder/cargo.rs   |  2 +-
 src/bootstrap/src/core/builder/tests.rs   | 15 +++++
 3 files changed, 63 insertions(+), 24 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/doc.rs b/src/bootstrap/src/core/build_steps/doc.rs
index eb198a0051abe..33a0f617b4a6a 100644
--- a/src/bootstrap/src/core/build_steps/doc.rs
+++ b/src/bootstrap/src/core/build_steps/doc.rs
@@ -965,7 +965,7 @@ macro_rules! tool_doc {
     (
         $tool: ident,
         $path: literal,
-        $(rustc_private_tool = $rustc_private_tool:literal, )?
+        mode = $mode:expr,
         $(is_library = $is_library:expr,)?
         $(crates = $crates:expr)?
        ) => {
@@ -988,20 +988,29 @@ macro_rules! tool_doc {
 
             fn make_run(run: RunConfig<'_>) {
                 let target = run.target;
-                let (build_compiler, mode) = if true $(&& $rustc_private_tool)? {
-                    // Rustdoc needs the rustc sysroot available to build.
-                    let compilers = RustcPrivateCompilers::new(run.builder, run.builder.top_stage, target);
-
-                    // Build rustc docs so that we generate relative links.
-                    run.builder.ensure(Rustc::from_build_compiler(run.builder, compilers.build_compiler(), target));
-
-                    (compilers.build_compiler(), Mode::ToolRustcPrivate)
-                } else {
-                    // bootstrap/host tools have to be documented with the stage 0 compiler
-                    (prepare_doc_compiler(run.builder, run.builder.host_target, 1), Mode::ToolBootstrap)
+                let build_compiler = match $mode {
+                    Mode::ToolRustcPrivate => {
+                        // Rustdoc needs the rustc sysroot available to build.
+                        let compilers = RustcPrivateCompilers::new(run.builder, run.builder.top_stage, target);
+
+                        // Build rustc docs so that we generate relative links.
+                        run.builder.ensure(Rustc::from_build_compiler(run.builder, compilers.build_compiler(), target));
+                        compilers.build_compiler()
+                    }
+                    Mode::ToolBootstrap => {
+                        // bootstrap/host tools should be documented with the stage 0 compiler
+                        prepare_doc_compiler(run.builder, run.builder.host_target, 1)
+                    }
+                    Mode::ToolTarget => {
+                        // target tools should be documented with the in-tree compiler
+                        prepare_doc_compiler(run.builder, run.builder.host_target, 2)
+                    }
+                    _ => {
+                        panic!("Unexpected tool mode for documenting: {:?}", $mode);
+                    }
                 };
 
-                run.builder.ensure($tool { build_compiler, mode, target });
+                run.builder.ensure($tool { build_compiler, mode: $mode, target });
             }
 
             /// Generates documentation for a tool.
@@ -1087,18 +1096,33 @@ macro_rules! tool_doc {
 tool_doc!(
     BuildHelper,
     "src/build_helper",
-    rustc_private_tool = false,
+    mode = Mode::ToolBootstrap,
     is_library = true,
     crates = ["build_helper"]
 );
-tool_doc!(Rustdoc, "src/tools/rustdoc", crates = ["rustdoc", "rustdoc-json-types"]);
-tool_doc!(Rustfmt, "src/tools/rustfmt", crates = ["rustfmt-nightly", "rustfmt-config_proc_macro"]);
-tool_doc!(Clippy, "src/tools/clippy", crates = ["clippy_config", "clippy_utils"]);
-tool_doc!(Miri, "src/tools/miri", crates = ["miri"]);
+tool_doc!(
+    Rustdoc,
+    "src/tools/rustdoc",
+    mode = Mode::ToolRustcPrivate,
+    crates = ["rustdoc", "rustdoc-json-types"]
+);
+tool_doc!(
+    Rustfmt,
+    "src/tools/rustfmt",
+    mode = Mode::ToolRustcPrivate,
+    crates = ["rustfmt-nightly", "rustfmt-config_proc_macro"]
+);
+tool_doc!(
+    Clippy,
+    "src/tools/clippy",
+    mode = Mode::ToolRustcPrivate,
+    crates = ["clippy_config", "clippy_utils"]
+);
+tool_doc!(Miri, "src/tools/miri", mode = Mode::ToolRustcPrivate, crates = ["miri"]);
 tool_doc!(
     Cargo,
     "src/tools/cargo",
-    rustc_private_tool = false,
+    mode = Mode::ToolTarget,
     crates = [
         "cargo",
         "cargo-credential",
@@ -1112,25 +1136,25 @@ tool_doc!(
         "rustfix",
     ]
 );
-tool_doc!(Tidy, "src/tools/tidy", rustc_private_tool = false, crates = ["tidy"]);
+tool_doc!(Tidy, "src/tools/tidy", mode = Mode::ToolBootstrap, crates = ["tidy"]);
 tool_doc!(
     Bootstrap,
     "src/bootstrap",
-    rustc_private_tool = false,
+    mode = Mode::ToolBootstrap,
     is_library = true,
     crates = ["bootstrap"]
 );
 tool_doc!(
     RunMakeSupport,
     "src/tools/run-make-support",
-    rustc_private_tool = false,
+    mode = Mode::ToolBootstrap,
     is_library = true,
     crates = ["run_make_support"]
 );
 tool_doc!(
     Compiletest,
     "src/tools/compiletest",
-    rustc_private_tool = false,
+    mode = Mode::ToolBootstrap,
     is_library = true,
     crates = ["compiletest"]
 );
diff --git a/src/bootstrap/src/core/builder/cargo.rs b/src/bootstrap/src/core/builder/cargo.rs
index a9a74b9bb0731..947147cdcbf21 100644
--- a/src/bootstrap/src/core/builder/cargo.rs
+++ b/src/bootstrap/src/core/builder/cargo.rs
@@ -533,7 +533,7 @@ impl Builder<'_> {
         if cmd_kind == Kind::Doc {
             let my_out = match mode {
                 // This is the intended out directory for compiler documentation.
-                Mode::Rustc | Mode::ToolRustcPrivate | Mode::ToolBootstrap => {
+                Mode::Rustc | Mode::ToolRustcPrivate | Mode::ToolBootstrap | Mode::ToolTarget => {
                     self.compiler_doc_out(target)
                 }
                 Mode::Std => {
diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index 9e8c13eb4dec7..da9e1ecad7b98 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -2462,6 +2462,21 @@ mod snapshot {
         ");
     }
 
+    #[test]
+    fn doc_cargo() {
+        let ctx = TestCtx::new();
+        insta::assert_snapshot!(
+            ctx.config("doc")
+                .path("cargo")
+                .render_steps(), @r"
+        [build] llvm <host>
+        [build] rustc 0 <host> -> rustc 1 <host>
+        [build] rustc 1 <host> -> std 1 <host>
+        [build] rustdoc 1 <host>
+        [doc] rustc 1 <host> -> Cargo 2 <host>
+        ");
+    }
+
     #[test]
     fn doc_core() {
         let ctx = TestCtx::new();

From 923b892b67e76ca93bbb118ff7a442fce531f773 Mon Sep 17 00:00:00 2001
From: WANG Rui <wangrui@loongson.cn>
Date: Wed, 3 Sep 2025 11:34:15 +0800
Subject: [PATCH 0496/1889] compiler: Apply target features to the entry
 function

---
 compiler/rustc_codegen_llvm/src/attributes.rs | 22 ++++++++++++-------
 compiler/rustc_codegen_llvm/src/context.rs    | 10 +++++++--
 2 files changed, 22 insertions(+), 10 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/attributes.rs b/compiler/rustc_codegen_llvm/src/attributes.rs
index 9f2d37d39d87a..573c51a95398b 100644
--- a/compiler/rustc_codegen_llvm/src/attributes.rs
+++ b/compiler/rustc_codegen_llvm/src/attributes.rs
@@ -296,6 +296,19 @@ pub(crate) fn tune_cpu_attr<'ll>(cx: &CodegenCx<'ll, '_>) -> Option<&'ll Attribu
         .map(|tune_cpu| llvm::CreateAttrStringValue(cx.llcx, "tune-cpu", tune_cpu))
 }
 
+/// Get the `target-features` LLVM attribute.
+pub(crate) fn target_features_attr<'ll>(
+    cx: &CodegenCx<'ll, '_>,
+    function_features: Vec<String>,
+) -> Option<&'ll Attribute> {
+    let global_features = cx.tcx.global_backend_features(()).iter().map(String::as_str);
+    let function_features = function_features.iter().map(String::as_str);
+    let target_features =
+        global_features.chain(function_features).intersperse(",").collect::<String>();
+    (!target_features.is_empty())
+        .then(|| llvm::CreateAttrStringValue(cx.llcx, "target-features", &target_features))
+}
+
 /// Get the `NonLazyBind` LLVM attribute,
 /// if the codegen options allow skipping the PLT.
 pub(crate) fn non_lazy_bind_attr<'ll>(cx: &CodegenCx<'ll, '_>) -> Option<&'ll Attribute> {
@@ -523,14 +536,7 @@ pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>(
         }
     }
 
-    let global_features = cx.tcx.global_backend_features(()).iter().map(|s| s.as_str());
-    let function_features = function_features.iter().map(|s| s.as_str());
-    let target_features: String =
-        global_features.chain(function_features).intersperse(",").collect();
-
-    if !target_features.is_empty() {
-        to_add.push(llvm::CreateAttrStringValue(cx.llcx, "target-features", &target_features));
-    }
+    to_add.extend(target_features_attr(cx, function_features));
 
     attributes::apply_to_llfn(llfn, Function, &to_add);
 }
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index 257c7b95666f7..a69fa54a54a4d 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -853,7 +853,7 @@ impl<'ll, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
     fn declare_c_main(&self, fn_type: Self::Type) -> Option<Self::Function> {
         let entry_name = self.sess().target.entry_name.as_ref();
         if self.get_declared_value(entry_name).is_none() {
-            Some(self.declare_entry_fn(
+            let llfn = self.declare_entry_fn(
                 entry_name,
                 llvm::CallConv::from_conv(
                     self.sess().target.entry_abi,
@@ -861,7 +861,13 @@ impl<'ll, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
                 ),
                 llvm::UnnamedAddr::Global,
                 fn_type,
-            ))
+            );
+            attributes::apply_to_llfn(
+                llfn,
+                llvm::AttributePlace::Function,
+                attributes::target_features_attr(self, vec![]).as_slice(),
+            );
+            Some(llfn)
         } else {
             // If the symbol already exists, it is an error: for example, the user wrote
             // #[no_mangle] extern "C" fn main(..) {..}

From d8ca776f6de1d484afc9f847f558bd32b94ceced Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Wed, 3 Sep 2025 21:49:50 -0700
Subject: [PATCH 0497/1889] std: Implement WASIp2-specific stdio routines

This commit is an extension of previous libstd support but applied to stdio
specifically. The stdio routines are updated away from WASIp1 APIs to using
WASIp2 APIs natively. The end goal is to eventually drop the dependency on
WASIp1 APIs in the standard library entirely in favor of exclusively depending
on WASIp2.
---
 library/std/src/sys/stdio/mod.rs              |  10 +-
 .../std/src/sys/stdio/{wasi.rs => wasip1.rs}  |   0
 library/std/src/sys/stdio/wasip2.rs           | 120 ++++++++++++++++++
 3 files changed, 127 insertions(+), 3 deletions(-)
 rename library/std/src/sys/stdio/{wasi.rs => wasip1.rs} (100%)
 create mode 100644 library/std/src/sys/stdio/wasip2.rs

diff --git a/library/std/src/sys/stdio/mod.rs b/library/std/src/sys/stdio/mod.rs
index 314f226f07beb..7436e4d9de4da 100644
--- a/library/std/src/sys/stdio/mod.rs
+++ b/library/std/src/sys/stdio/mod.rs
@@ -29,9 +29,13 @@ cfg_select! {
         mod uefi;
         pub use uefi::*;
     }
-    target_os = "wasi" => {
-        mod wasi;
-        pub use wasi::*;
+    all(target_os = "wasi", target_env = "p1") => {
+        mod wasip1;
+        pub use wasip1::*;
+    }
+    all(target_os = "wasi", target_env = "p2") => {
+        mod wasip2;
+        pub use wasip2::*;
     }
     target_os = "xous" => {
         mod xous;
diff --git a/library/std/src/sys/stdio/wasi.rs b/library/std/src/sys/stdio/wasip1.rs
similarity index 100%
rename from library/std/src/sys/stdio/wasi.rs
rename to library/std/src/sys/stdio/wasip1.rs
diff --git a/library/std/src/sys/stdio/wasip2.rs b/library/std/src/sys/stdio/wasip2.rs
new file mode 100644
index 0000000000000..1fcb49a083dd0
--- /dev/null
+++ b/library/std/src/sys/stdio/wasip2.rs
@@ -0,0 +1,120 @@
+use wasip2::cli;
+use wasip2::io::streams::{Error, InputStream, OutputStream, StreamError};
+
+use crate::io::{self, BorrowedBuf, BorrowedCursor};
+
+pub struct Stdin(Option<InputStream>);
+pub struct Stdout(Option<OutputStream>);
+pub struct Stderr(Option<OutputStream>);
+
+fn error_to_io(err: Error) -> io::Error {
+    // There exists a function in `wasi:filesystem` to optionally acquire an
+    // error code from an error, but the streams in use in this module are
+    // exclusively used with stdio meaning that a filesystem error is not
+    // possible here.
+    //
+    // In lieu of an error code, which WASIp2 does not specify, this instead
+    // carries along the `to_debug_string` implementation that the host
+    // supplies. If this becomes too expensive in the future this could also
+    // become `io::Error::from_raw_os_error(libc::EIO)` or similar.
+    io::Error::new(io::ErrorKind::Other, err.to_debug_string())
+}
+
+impl Stdin {
+    pub const fn new() -> Stdin {
+        Stdin(None)
+    }
+
+    fn stream(&mut self) -> &InputStream {
+        self.0.get_or_insert_with(cli::stdin::get_stdin)
+    }
+}
+
+impl io::Read for Stdin {
+    fn read(&mut self, data: &mut [u8]) -> io::Result<usize> {
+        let mut buf = BorrowedBuf::from(data);
+        self.read_buf(buf.unfilled())?;
+        Ok(buf.len())
+    }
+
+    fn read_buf(&mut self, mut buf: BorrowedCursor<'_>) -> io::Result<()> {
+        match self.stream().blocking_read(u64::try_from(buf.capacity()).unwrap()) {
+            Ok(result) => {
+                buf.append(&result);
+                Ok(())
+            }
+            Err(StreamError::Closed) => Ok(()),
+            Err(StreamError::LastOperationFailed(e)) => Err(error_to_io(e)),
+        }
+    }
+}
+
+impl Stdout {
+    pub const fn new() -> Stdout {
+        Stdout(None)
+    }
+
+    fn stream(&mut self) -> &OutputStream {
+        self.0.get_or_insert_with(cli::stdout::get_stdout)
+    }
+}
+
+fn write(stream: &OutputStream, buf: &[u8]) -> io::Result<usize> {
+    // WASIp2's `blocking_write_and_flush` function is defined as accepting no
+    // more than 4096 bytes. Larger writes can be issued by manually using
+    // `check_write`, `write`, and `blocking_flush`, but for now just go ahead
+    // and use `blocking_write_and_flush` and report a short write and let a
+    // higher level loop over the result.
+    const MAX: usize = 4096;
+    let buf = &buf[..buf.len().min(MAX)];
+    match stream.blocking_write_and_flush(buf) {
+        Ok(()) => Ok(buf.len()),
+        Err(StreamError::Closed) => Ok(0),
+        Err(StreamError::LastOperationFailed(e)) => Err(error_to_io(e)),
+    }
+}
+
+impl io::Write for Stdout {
+    fn write(&mut self, data: &[u8]) -> io::Result<usize> {
+        write(self.stream(), data)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        // Note that `OutputStream` has a `flush` function but for stdio all
+        // writes are accompanied with a flush which means that this flush
+        // doesn't need to do anything.
+        Ok(())
+    }
+}
+
+impl Stderr {
+    pub const fn new() -> Stderr {
+        Stderr(None)
+    }
+
+    fn stream(&mut self) -> &OutputStream {
+        self.0.get_or_insert_with(cli::stderr::get_stderr)
+    }
+}
+
+impl io::Write for Stderr {
+    fn write(&mut self, data: &[u8]) -> io::Result<usize> {
+        write(self.stream(), data)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        // See `Stdout::flush` for why this is a noop.
+        Ok(())
+    }
+}
+
+pub const STDIN_BUF_SIZE: usize = crate::sys::io::DEFAULT_BUF_SIZE;
+
+pub fn is_ebadf(_err: &io::Error) -> bool {
+    // WASIp2 stdio streams are always available so ebadf never shows up.
+    false
+}
+
+pub fn panic_output() -> Option<impl io::Write> {
+    Some(Stderr::new())
+}

From 0976d6ccac3d71befb58ceefd3109864f0eb210d Mon Sep 17 00:00:00 2001
From: dianne <diannes.gm@gmail.com>
Date: Sun, 24 Aug 2025 22:48:00 -0700
Subject: [PATCH 0498/1889] don't extend non-extended `super let` initializers'
 block tail temps

---
 .../rustc_hir_analysis/src/check/region.rs    | 24 +++++++++++++++----
 .../format-args-temporary-scopes.e2024.stderr | 14 ++++++++++-
 .../borrowck/format-args-temporary-scopes.rs  |  1 +
 .../ui/drop/super-let-tail-expr-drop-order.rs | 14 +++++------
 4 files changed, 40 insertions(+), 13 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/check/region.rs b/compiler/rustc_hir_analysis/src/check/region.rs
index f5770b7312ddf..58521697b387f 100644
--- a/compiler/rustc_hir_analysis/src/check/region.rs
+++ b/compiler/rustc_hir_analysis/src/check/region.rs
@@ -467,8 +467,12 @@ fn resolve_local<'tcx>(
     // A, but the inner rvalues `a()` and `b()` have an extended lifetime
     // due to rule C.
 
-    if let_kind == LetKind::Super {
-        if let Some(scope) = visitor.extended_super_lets.remove(&pat.unwrap().hir_id.local_id) {
+    let extend_initializer = match let_kind {
+        LetKind::Regular => true,
+        LetKind::Super
+            if let Some(scope) =
+                visitor.extended_super_lets.remove(&pat.unwrap().hir_id.local_id) =>
+        {
             // This expression was lifetime-extended by a parent let binding. E.g.
             //
             //     let a = {
@@ -481,7 +485,10 @@ fn resolve_local<'tcx>(
             // Processing of `let a` will have already decided to extend the lifetime of this
             // `super let` to its own var_scope. We use that scope.
             visitor.cx.var_parent = scope;
-        } else {
+            // Extend temporaries to live in the same scope as the parent `let`'s bindings.
+            true
+        }
+        LetKind::Super => {
             // This `super let` is not subject to lifetime extension from a parent let binding. E.g.
             //
             //     identity({ super let x = temp(); &x }).method();
@@ -497,10 +504,17 @@ fn resolve_local<'tcx>(
                 }
                 visitor.cx.var_parent = parent;
             }
+            // Don't lifetime-extend child `super let`s or block tail expressions' temporaries in
+            // the initializer when this `super let` is not itself extended by a parent `let`
+            // (#145784). Block tail expressions are temporary drop scopes in Editions 2024 and
+            // later, their temps shouldn't outlive the block in e.g. `f(pin!({ &temp() }))`.
+            false
         }
-    }
+    };
 
-    if let Some(expr) = init {
+    if let Some(expr) = init
+        && extend_initializer
+    {
         record_rvalue_scope_if_borrow_expr(visitor, expr, visitor.cx.var_parent);
 
         if let Some(pat) = pat {
diff --git a/tests/ui/borrowck/format-args-temporary-scopes.e2024.stderr b/tests/ui/borrowck/format-args-temporary-scopes.e2024.stderr
index 923c929a68d60..506fc6e0965f7 100644
--- a/tests/ui/borrowck/format-args-temporary-scopes.e2024.stderr
+++ b/tests/ui/borrowck/format-args-temporary-scopes.e2024.stderr
@@ -10,6 +10,18 @@ LL |     println!("{:?}", { &temp() });
    |
    = note: consider using a `let` binding to create a longer lived value
 
-error: aborting due to 1 previous error
+error[E0716]: temporary value dropped while borrowed
+  --> $DIR/format-args-temporary-scopes.rs:19:29
+   |
+LL |     println!("{:?}{:?}", { &temp() }, ());
+   |                          ---^^^^^---
+   |                          |  |    |
+   |                          |  |    temporary value is freed at the end of this statement
+   |                          |  creates a temporary value which is freed while still in use
+   |                          borrow later used here
+   |
+   = note: consider using a `let` binding to create a longer lived value
+
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/ui/borrowck/format-args-temporary-scopes.rs b/tests/ui/borrowck/format-args-temporary-scopes.rs
index e6223d7c55183..2641058accb31 100644
--- a/tests/ui/borrowck/format-args-temporary-scopes.rs
+++ b/tests/ui/borrowck/format-args-temporary-scopes.rs
@@ -17,4 +17,5 @@ fn main() {
     // arguments when provided with two or more arguments. This caused the result of `temp()` to
     // outlive the result of the block, making this compile.
     println!("{:?}{:?}", { &temp() }, ());
+    //[e2024]~^ ERROR: temporary value dropped while borrowed [E0716]
 }
diff --git a/tests/ui/drop/super-let-tail-expr-drop-order.rs b/tests/ui/drop/super-let-tail-expr-drop-order.rs
index 5aa17bba21f1b..8ec9296ed4f1d 100644
--- a/tests/ui/drop/super-let-tail-expr-drop-order.rs
+++ b/tests/ui/drop/super-let-tail-expr-drop-order.rs
@@ -45,10 +45,10 @@ fn main() {
         #[cfg(e2024)]
         (
             pin!((
-                pin!({ &o.log(3) as *const LogDrop<'_> }),
-                drop(o.log(1)),
+                pin!({ &o.log(1) as *const LogDrop<'_> }),
+                drop(o.log(2)),
             )),
-            drop(o.log(2)),
+            drop(o.log(3)),
         );
     });
 
@@ -69,12 +69,12 @@ fn main() {
         (
             {
                 super let _ = {
-                    super let _ = { &o.log(4) as *const LogDrop<'_> };
-                    drop(o.log(1))
+                    super let _ = { &o.log(1) as *const LogDrop<'_> };
+                    drop(o.log(2))
                 };
-                drop(o.log(2))
+                drop(o.log(3))
             },
-            drop(o.log(3)),
+            drop(o.log(4)),
         );
     });
 

From d5b5a4a0e11d92a963578d15a9f693e1538caf3f Mon Sep 17 00:00:00 2001
From: dianne <diannes.gm@gmail.com>
Date: Mon, 25 Aug 2025 04:52:52 -0700
Subject: [PATCH 0499/1889] additional tests

Co-authored-by: Travis Cross <tc@traviscross.com>
---
 .../ui/drop/super-let-tail-expr-drop-order.rs | 70 +++++++++++++++++++
 1 file changed, 70 insertions(+)

diff --git a/tests/ui/drop/super-let-tail-expr-drop-order.rs b/tests/ui/drop/super-let-tail-expr-drop-order.rs
index 8ec9296ed4f1d..5b2ecfbb3200c 100644
--- a/tests/ui/drop/super-let-tail-expr-drop-order.rs
+++ b/tests/ui/drop/super-let-tail-expr-drop-order.rs
@@ -22,10 +22,13 @@
 //@ [e2024] edition: 2024
 
 #![feature(super_let)]
+#![allow(unused_braces)]
 
 use std::cell::RefCell;
 use std::pin::pin;
 
+fn f<T>(_: LogDrop<'_>, x: T) -> T { x }
+
 fn main() {
     // Test block arguments to `pin!` in non-extending expressions.
     // In Rust 2021, block tail expressions aren't temporary drop scopes, so their temporaries
@@ -90,6 +93,73 @@ fn main() {
         let _ =  { super let _ = { &o.log(2) as *const LogDrop<'_> }; };
         drop(o.log(1));
     });
+
+    // We have extending borrow expressions within an extending block
+    // expression (within an extending borrow expression) within a
+    // non-extending expresion within the initializer expression.
+    #[cfg(e2021)]
+    {
+        // These two should be the same.
+        assert_drop_order(1..=3, |e| {
+            let _v = f(e.log(1), &{ &raw const *&e.log(2) });
+            drop(e.log(3));
+        });
+        assert_drop_order(1..=3, |e| {
+            let _v = f(e.log(1), {
+                super let v = &{ &raw const *&e.log(2) };
+                v
+            });
+            drop(e.log(3));
+        });
+    }
+    #[cfg(e2024)]
+    {
+        // These two should be the same.
+        assert_drop_order(1..=3, |e| {
+            let _v = f(e.log(2), &{ &raw const *&e.log(1) });
+            drop(e.log(3));
+        });
+        assert_drop_order(1..=3, |e| {
+            let _v = f(e.log(2), {
+                super let v = &{ &raw const *&e.log(1) };
+                v
+            });
+            drop(e.log(3));
+        });
+    }
+
+    // We have extending borrow expressions within a non-extending
+    // expression within the initializer expression.
+    //
+    // These two should be the same.
+    assert_drop_order(1..=3, |e| {
+        let _v = f(e.log(1), &&raw const *&e.log(2));
+        drop(e.log(3));
+    });
+    assert_drop_order(1..=3, |e| {
+        let _v = f(e.log(1), {
+            super let v = &&raw const *&e.log(2);
+            v
+        });
+        drop(e.log(3));
+    });
+
+    // We have extending borrow expressions within an extending block
+    // expression (within an extending borrow expression) within the
+    // initializer expression.
+    //
+    // These two should be the same.
+    assert_drop_order(1..=2, |e| {
+        let _v = &{ &raw const *&e.log(2) };
+        drop(e.log(1));
+    });
+    assert_drop_order(1..=2, |e| {
+        let _v = {
+            super let v = &{ &raw const *&e.log(2) };
+            v
+        };
+        drop(e.log(1));
+    });
 }
 
 // # Test scaffolding...

From fd479ca23cc7d4e0288496150304bfab913dbda5 Mon Sep 17 00:00:00 2001
From: LorrensP-2158466 <lorrens.pantelis@student.uhasselt.be>
Date: Mon, 7 Jul 2025 12:44:48 +0200
Subject: [PATCH 0500/1889] Move float non determinism helpers to math.rs

---
 src/tools/miri/src/intrinsics/mod.rs | 160 +++++----------------------
 src/tools/miri/src/math.rs           | 114 ++++++++++++++++++-
 2 files changed, 140 insertions(+), 134 deletions(-)

diff --git a/src/tools/miri/src/intrinsics/mod.rs b/src/tools/miri/src/intrinsics/mod.rs
index 5e46768b0e6cf..8bcec4e7cbe30 100644
--- a/src/tools/miri/src/intrinsics/mod.rs
+++ b/src/tools/miri/src/intrinsics/mod.rs
@@ -3,11 +3,8 @@
 mod atomic;
 mod simd;
 
-use std::ops::Neg;
-
 use rand::Rng;
 use rustc_abi::Size;
-use rustc_apfloat::ieee::{IeeeFloat, Semantics};
 use rustc_apfloat::{self, Float, Round};
 use rustc_middle::mir;
 use rustc_middle::ty::{self, FloatTy};
@@ -16,7 +13,7 @@ use rustc_span::{Symbol, sym};
 use self::atomic::EvalContextExt as _;
 use self::helpers::{ToHost, ToSoft};
 use self::simd::EvalContextExt as _;
-use crate::math::{IeeeExt, apply_random_float_error_ulp};
+use crate::math::apply_random_float_error_ulp;
 use crate::*;
 
 /// Check that the number of args is what we expect.
@@ -209,7 +206,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 let [f] = check_intrinsic_arg_count(args)?;
                 let f = this.read_scalar(f)?.to_f32()?;
 
-                let res = fixed_float_value(this, intrinsic_name, &[f]).unwrap_or_else(|| {
+                let res = math::fixed_float_value(this, intrinsic_name, &[f]).unwrap_or_else(|| {
                     // Using host floats (but it's fine, these operations do not have
                     // guaranteed precision).
                     let host = f.to_host();
@@ -227,7 +224,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
                     // Apply a relative error of 4ULP to introduce some non-determinism
                     // simulating imprecise implementations and optimizations.
-                    let res = apply_random_float_error_ulp(
+                    let res = math::apply_random_float_error_ulp(
                         this,
                         res,
                         4,
@@ -235,7 +232,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
                     // Clamp the result to the guaranteed range of this function according to the C standard,
                     // if any.
-                    clamp_float_value(intrinsic_name, res)
+                    math::clamp_float_value(intrinsic_name, res)
                 });
                 let res = this.adjust_nan(res, &[f]);
                 this.write_scalar(res, dest)?;
@@ -253,7 +250,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 let [f] = check_intrinsic_arg_count(args)?;
                 let f = this.read_scalar(f)?.to_f64()?;
 
-                let res = fixed_float_value(this, intrinsic_name, &[f]).unwrap_or_else(|| {
+                let res = math::fixed_float_value(this, intrinsic_name, &[f]).unwrap_or_else(|| {
                     // Using host floats (but it's fine, these operations do not have
                     // guaranteed precision).
                     let host = f.to_host();
@@ -271,7 +268,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
                     // Apply a relative error of 4ULP to introduce some non-determinism
                     // simulating imprecise implementations and optimizations.
-                    let res = apply_random_float_error_ulp(
+                    let res = math::apply_random_float_error_ulp(
                         this,
                         res,
                         4,
@@ -279,7 +276,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
                     // Clamp the result to the guaranteed range of this function according to the C standard,
                     // if any.
-                    clamp_float_value(intrinsic_name, res)
+                    math::clamp_float_value(intrinsic_name, res)
                 });
                 let res = this.adjust_nan(res, &[f]);
                 this.write_scalar(res, dest)?;
@@ -330,14 +327,15 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 let f1 = this.read_scalar(f1)?.to_f32()?;
                 let f2 = this.read_scalar(f2)?.to_f32()?;
 
-                let res = fixed_float_value(this, intrinsic_name, &[f1, f2]).unwrap_or_else(|| {
-                    // Using host floats (but it's fine, this operation does not have guaranteed precision).
-                    let res = f1.to_host().powf(f2.to_host()).to_soft();
+                let res =
+                    math::fixed_float_value(this, intrinsic_name, &[f1, f2]).unwrap_or_else(|| {
+                        // Using host floats (but it's fine, this operation does not have guaranteed precision).
+                        let res = f1.to_host().powf(f2.to_host()).to_soft();
 
-                    // Apply a relative error of 4ULP to introduce some non-determinism
-                    // simulating imprecise implementations and optimizations.
-                    apply_random_float_error_ulp(this, res, 4)
-                });
+                        // Apply a relative error of 4ULP to introduce some non-determinism
+                        // simulating imprecise implementations and optimizations.
+                        math::apply_random_float_error_ulp(this, res, 4)
+                    });
                 let res = this.adjust_nan(res, &[f1, f2]);
                 this.write_scalar(res, dest)?;
             }
@@ -346,14 +344,15 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 let f1 = this.read_scalar(f1)?.to_f64()?;
                 let f2 = this.read_scalar(f2)?.to_f64()?;
 
-                let res = fixed_float_value(this, intrinsic_name, &[f1, f2]).unwrap_or_else(|| {
-                    // Using host floats (but it's fine, this operation does not have guaranteed precision).
-                    let res = f1.to_host().powf(f2.to_host()).to_soft();
+                let res =
+                    math::fixed_float_value(this, intrinsic_name, &[f1, f2]).unwrap_or_else(|| {
+                        // Using host floats (but it's fine, this operation does not have guaranteed precision).
+                        let res = f1.to_host().powf(f2.to_host()).to_soft();
 
-                    // Apply a relative error of 4ULP to introduce some non-determinism
-                    // simulating imprecise implementations and optimizations.
-                    apply_random_float_error_ulp(this, res, 4)
-                });
+                        // Apply a relative error of 4ULP to introduce some non-determinism
+                        // simulating imprecise implementations and optimizations.
+                        math::apply_random_float_error_ulp(this, res, 4)
+                    });
                 let res = this.adjust_nan(res, &[f1, f2]);
                 this.write_scalar(res, dest)?;
             }
@@ -363,7 +362,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 let f = this.read_scalar(f)?.to_f32()?;
                 let i = this.read_scalar(i)?.to_i32()?;
 
-                let res = fixed_powi_float_value(this, f, i).unwrap_or_else(|| {
+                let res = math::fixed_powi_float_value(this, f, i).unwrap_or_else(|| {
                     // Using host floats (but it's fine, this operation does not have guaranteed precision).
                     let res = f.to_host().powi(i).to_soft();
 
@@ -379,13 +378,13 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 let f = this.read_scalar(f)?.to_f64()?;
                 let i = this.read_scalar(i)?.to_i32()?;
 
-                let res = fixed_powi_float_value(this, f, i).unwrap_or_else(|| {
+                let res = math::fixed_powi_float_value(this, f, i).unwrap_or_else(|| {
                     // Using host floats (but it's fine, this operation does not have guaranteed precision).
                     let res = f.to_host().powi(i).to_soft();
 
                     // Apply a relative error of 4ULP to introduce some non-determinism
                     // simulating imprecise implementations and optimizations.
-                    apply_random_float_error_ulp(this, res, 4)
+                    math::apply_random_float_error_ulp(this, res, 4)
                 });
                 let res = this.adjust_nan(res, &[f]);
                 this.write_scalar(res, dest)?;
@@ -440,7 +439,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 }
                 // Apply a relative error of 4ULP to simulate non-deterministic precision loss
                 // due to optimizations.
-                let res = crate::math::apply_random_float_error_to_imm(this, res, 4)?;
+                let res = math::apply_random_float_error_to_imm(this, res, 4)?;
                 this.write_immediate(*res, dest)?;
             }
 
@@ -477,108 +476,3 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         interp_ok(EmulateItemResult::NeedsReturn)
     }
 }
-
-/// For the intrinsics:
-/// - sinf32, sinf64
-/// - cosf32, cosf64
-/// - expf32, expf64, exp2f32, exp2f64
-/// - logf32, logf64, log2f32, log2f64, log10f32, log10f64
-/// - powf32, powf64
-///
-/// # Return
-///
-/// Returns `Some(output)` if the `intrinsic` results in a defined fixed `output` specified in the C standard
-/// (specifically, C23 annex F.10)  when given `args` as arguments. Outputs that are unaffected by a relative error
-/// (such as INF and zero) are not handled here, they are assumed to be handled by the underlying
-/// implementation. Returns `None` if no specific value is guaranteed.
-///
-/// # Note
-///
-/// For `powf*` operations of the form:
-///
-/// - `(SNaN)^(±0)`
-/// - `1^(SNaN)`
-///
-/// The result is implementation-defined:
-/// - musl returns for both `1.0`
-/// - glibc returns for both `NaN`
-///
-/// This discrepancy exists because SNaN handling is not consistently defined across platforms,
-/// and the C standard leaves behavior for SNaNs unspecified.
-///
-/// Miri chooses to adhere to both implementations and returns either one of them non-deterministically.
-fn fixed_float_value<S: Semantics>(
-    ecx: &mut MiriInterpCx<'_>,
-    intrinsic_name: &str,
-    args: &[IeeeFloat<S>],
-) -> Option<IeeeFloat<S>> {
-    let one = IeeeFloat::<S>::one();
-    Some(match (intrinsic_name, args) {
-        // cos(+- 0) = 1
-        ("cosf32" | "cosf64", [input]) if input.is_zero() => one,
-
-        // e^0 = 1
-        ("expf32" | "expf64" | "exp2f32" | "exp2f64", [input]) if input.is_zero() => one,
-
-        // (-1)^(±INF) = 1
-        ("powf32" | "powf64", [base, exp]) if *base == -one && exp.is_infinite() => one,
-
-        // 1^y = 1 for any y, even a NaN
-        ("powf32" | "powf64", [base, exp]) if *base == one => {
-            let rng = ecx.machine.rng.get_mut();
-            // SNaN exponents get special treatment: they might return 1, or a NaN.
-            let return_nan = exp.is_signaling() && ecx.machine.float_nondet && rng.random();
-            // Handle both the musl and glibc cases non-deterministically.
-            if return_nan { ecx.generate_nan(args) } else { one }
-        }
-
-        // x^(±0) = 1 for any x, even a NaN
-        ("powf32" | "powf64", [base, exp]) if exp.is_zero() => {
-            let rng = ecx.machine.rng.get_mut();
-            // SNaN bases get special treatment: they might return 1, or a NaN.
-            let return_nan = base.is_signaling() && ecx.machine.float_nondet && rng.random();
-            // Handle both the musl and glibc cases non-deterministically.
-            if return_nan { ecx.generate_nan(args) } else { one }
-        }
-
-        // There are a lot of cases for fixed outputs according to the C Standard, but these are
-        // mainly INF or zero which are not affected by the applied error.
-        _ => return None,
-    })
-}
-
-/// Returns `Some(output)` if `powi` (called `pown` in C) results in a fixed value specified in the
-/// C standard (specifically, C23 annex F.10.4.6) when doing `base^exp`. Otherwise, returns `None`.
-fn fixed_powi_float_value<S: Semantics>(
-    ecx: &mut MiriInterpCx<'_>,
-    base: IeeeFloat<S>,
-    exp: i32,
-) -> Option<IeeeFloat<S>> {
-    Some(match exp {
-        0 => {
-            let one = IeeeFloat::<S>::one();
-            let rng = ecx.machine.rng.get_mut();
-            let return_nan = ecx.machine.float_nondet && rng.random() && base.is_signaling();
-            // For SNaN treatment, we are consistent with `powf`above.
-            // (We wouldn't have two, unlike powf all implementations seem to agree for powi,
-            // but for now we are maximally conservative.)
-            if return_nan { ecx.generate_nan(&[base]) } else { one }
-        }
-
-        _ => return None,
-    })
-}
-
-/// Given an floating-point operation and a floating-point value, clamps the result to the output
-/// range of the given operation.
-fn clamp_float_value<S: Semantics>(intrinsic_name: &str, val: IeeeFloat<S>) -> IeeeFloat<S> {
-    match intrinsic_name {
-        // sin and cos: [-1, 1]
-        "sinf32" | "cosf32" | "sinf64" | "cosf64" =>
-            val.clamp(IeeeFloat::<S>::one().neg(), IeeeFloat::<S>::one()),
-        // exp: [0, +INF]
-        "expf32" | "exp2f32" | "expf64" | "exp2f64" =>
-            IeeeFloat::<S>::maximum(val, IeeeFloat::<S>::ZERO),
-        _ => val,
-    }
-}
diff --git a/src/tools/miri/src/math.rs b/src/tools/miri/src/math.rs
index 6427f3ca6e9b0..dc1541b43dfc6 100644
--- a/src/tools/miri/src/math.rs
+++ b/src/tools/miri/src/math.rs
@@ -1,6 +1,8 @@
+use std::ops::Neg;
+
 use rand::Rng as _;
 use rustc_apfloat::Float as _;
-use rustc_apfloat::ieee::IeeeFloat;
+use rustc_apfloat::ieee::{IeeeFloat, Semantics};
 use rustc_middle::ty::{self, FloatTy, ScalarInt};
 
 use crate::*;
@@ -105,6 +107,116 @@ pub(crate) fn apply_random_float_error_to_imm<'tcx>(
     interp_ok(ImmTy::from_scalar_int(res, val.layout))
 }
 
+/// Given an floating-point operation and a floating-point value, clamps the result to the output
+/// range of the given operation.
+pub(crate) fn clamp_float_value<S: Semantics>(
+    intrinsic_name: &str,
+    val: IeeeFloat<S>,
+) -> IeeeFloat<S> {
+    match intrinsic_name {
+        // sin and cos: [-1, 1]
+        "sinf32" | "cosf32" | "sinf64" | "cosf64" =>
+            val.clamp(IeeeFloat::<S>::one().neg(), IeeeFloat::<S>::one()),
+        // exp: [0, +INF]
+        "expf32" | "exp2f32" | "expf64" | "exp2f64" =>
+            IeeeFloat::<S>::maximum(val, IeeeFloat::<S>::ZERO),
+        _ => val,
+    }
+}
+
+/// For the intrinsics:
+/// - sinf32, sinf64
+/// - cosf32, cosf64
+/// - expf32, expf64, exp2f32, exp2f64
+/// - logf32, logf64, log2f32, log2f64, log10f32, log10f64
+/// - powf32, powf64
+///
+/// # Return
+///
+/// Returns `Some(output)` if the `intrinsic` results in a defined fixed `output` specified in the C standard
+/// (specifically, C23 annex F.10)  when given `args` as arguments. Outputs that are unaffected by a relative error
+/// (such as INF and zero) are not handled here, they are assumed to be handled by the underlying
+/// implementation. Returns `None` if no specific value is guaranteed.
+///
+/// # Note
+///
+/// For `powf*` operations of the form:
+///
+/// - `(SNaN)^(±0)`
+/// - `1^(SNaN)`
+///
+/// The result is implementation-defined:
+/// - musl returns for both `1.0`
+/// - glibc returns for both `NaN`
+///
+/// This discrepancy exists because SNaN handling is not consistently defined across platforms,
+/// and the C standard leaves behavior for SNaNs unspecified.
+///
+/// Miri chooses to adhere to both implementations and returns either one of them non-deterministically.
+pub(crate) fn fixed_float_value<S: Semantics>(
+    ecx: &mut MiriInterpCx<'_>,
+    intrinsic_name: &str,
+    args: &[IeeeFloat<S>],
+) -> Option<IeeeFloat<S>> {
+    let this = ecx.eval_context_mut();
+    let one = IeeeFloat::<S>::one();
+    Some(match (intrinsic_name, args) {
+        // cos(+- 0) = 1
+        ("cosf32" | "cosf64", [input]) if input.is_zero() => one,
+
+        // e^0 = 1
+        ("expf32" | "expf64" | "exp2f32" | "exp2f64", [input]) if input.is_zero() => one,
+
+        // (-1)^(±INF) = 1
+        ("powf32" | "powf64", [base, exp]) if *base == -one && exp.is_infinite() => one,
+
+        // 1^y = 1 for any y, even a NaN
+        ("powf32" | "powf64", [base, exp]) if *base == one => {
+            let rng = this.machine.rng.get_mut();
+            // SNaN exponents get special treatment: they might return 1, or a NaN.
+            let return_nan = exp.is_signaling() && this.machine.float_nondet && rng.random();
+            // Handle both the musl and glibc cases non-deterministically.
+            if return_nan { this.generate_nan(args) } else { one }
+        }
+
+        // x^(±0) = 1 for any x, even a NaN
+        ("powf32" | "powf64", [base, exp]) if exp.is_zero() => {
+            let rng = this.machine.rng.get_mut();
+            // SNaN bases get special treatment: they might return 1, or a NaN.
+            let return_nan = base.is_signaling() && this.machine.float_nondet && rng.random();
+            // Handle both the musl and glibc cases non-deterministically.
+            if return_nan { this.generate_nan(args) } else { one }
+        }
+
+        // There are a lot of cases for fixed outputs according to the C Standard, but these are
+        // mainly INF or zero which are not affected by the applied error.
+        _ => return None,
+    })
+}
+
+/// Returns `Some(output)` if `powi` (called `pown` in C) results in a fixed value specified in the
+/// C standard (specifically, C23 annex F.10.4.6) when doing `base^exp`. Otherwise, returns `None`.
+pub(crate) fn fixed_powi_float_value<S: Semantics>(
+    ecx: &mut MiriInterpCx<'_>,
+    base: IeeeFloat<S>,
+    exp: i32,
+) -> Option<IeeeFloat<S>> {
+    let this = ecx.eval_context_mut();
+    Some(match exp {
+        0 => {
+            let one = IeeeFloat::<S>::one();
+            let rng = this.machine.rng.get_mut();
+            let return_nan = this.machine.float_nondet && rng.random() && base.is_signaling();
+            // For SNaN treatment, we are consistent with `powf`above.
+            // (We wouldn't have two, unlike powf all implementations seem to agree for powi,
+            // but for now we are maximally conservative.)
+            if return_nan { this.generate_nan(&[base]) } else { one }
+        }
+
+        _ => return None,
+    })
+}
+
 pub(crate) fn sqrt<S: rustc_apfloat::ieee::Semantics>(x: IeeeFloat<S>) -> IeeeFloat<S> {
     match x.category() {
         // preserve zero sign

From 7ff5a3d277939c9a3648f2dc270ff2e9166bcf70 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Thu, 4 Sep 2025 22:36:31 +0300
Subject: [PATCH 0501/1889] Upgrade rustc crates

The main changes are (there are some other small changes):

 - Using a specific type for trait IDs in the new solver, allowing us to simplify a lot of code.
 - Add `BoundConst` similar to `BoundTy` and `BoundRegion` (previously consts used `BoundVar` directly), due to a new trait requirement.
---
 src/tools/rust-analyzer/Cargo.lock            |  77 ++-
 src/tools/rust-analyzer/Cargo.toml            |  16 +-
 .../crates/hir-ty/src/display.rs              |  12 +-
 .../crates/hir-ty/src/dyn_compatibility.rs    |  72 +--
 .../crates/hir-ty/src/lower_nextsolver.rs     |  64 +--
 .../hir-ty/src/lower_nextsolver/path.rs       |   5 +-
 .../crates/hir-ty/src/method_resolution.rs    |   6 +-
 .../crates/hir-ty/src/next_solver/consts.rs   |  29 +-
 .../crates/hir-ty/src/next_solver/def_id.rs   |  57 ++
 .../crates/hir-ty/src/next_solver/fold.rs     |   8 +-
 .../crates/hir-ty/src/next_solver/fulfill.rs  |   2 +-
 .../hir-ty/src/next_solver/generic_arg.rs     |   2 -
 .../infer/canonical/instantiate.rs            |   3 +-
 .../hir-ty/src/next_solver/infer/mod.rs       |   6 +-
 .../next_solver/infer/relate/higher_ranked.rs |   8 +-
 .../crates/hir-ty/src/next_solver/interner.rs | 511 +++++++-----------
 .../crates/hir-ty/src/next_solver/ir_print.rs |  10 +-
 .../crates/hir-ty/src/next_solver/mapping.rs  |  32 +-
 .../hir-ty/src/next_solver/predicate.rs       |   8 +-
 .../crates/hir-ty/src/next_solver/solver.rs   |   8 +-
 .../crates/hir-ty/src/next_solver/ty.rs       |  27 +
 .../crates/hir-ty/src/next_solver/util.rs     |  28 +-
 .../rust-analyzer/crates/hir-ty/src/utils.rs  |   5 +-
 src/tools/rust-analyzer/crates/hir/src/lib.rs |  29 +-
 24 files changed, 446 insertions(+), 579 deletions(-)

diff --git a/src/tools/rust-analyzer/Cargo.lock b/src/tools/rust-analyzer/Cargo.lock
index b008aa1c50f88..344e6d101fe35 100644
--- a/src/tools/rust-analyzer/Cargo.lock
+++ b/src/tools/rust-analyzer/Cargo.lock
@@ -1360,7 +1360,7 @@ dependencies = [
  "expect-test",
  "intern",
  "parser",
- "ra-ap-rustc_lexer 0.123.0",
+ "ra-ap-rustc_lexer",
  "rustc-hash 2.1.1",
  "smallvec",
  "span",
@@ -1596,8 +1596,8 @@ dependencies = [
  "drop_bomb",
  "edition",
  "expect-test",
- "ra-ap-rustc_lexer 0.123.0",
- "rustc-literal-escaper",
+ "ra-ap-rustc_lexer",
+ "rustc-literal-escaper 0.0.4",
  "stdx",
  "tracing",
 ]
@@ -1717,7 +1717,7 @@ dependencies = [
  "object",
  "paths",
  "proc-macro-test",
- "ra-ap-rustc_lexer 0.123.0",
+ "ra-ap-rustc_lexer",
  "span",
  "syntax-bridge",
  "temp-dir",
@@ -1863,9 +1863,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_abi"
-version = "0.123.0"
+version = "0.126.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f18c877575c259d127072e9bfc41d985202262fb4d6bfdae3d1252147c2562c2"
+checksum = "0c6789d94fb3e6e30d62f55e99a321ba63484a8bb3b4ead338687c9ddc282d28"
 dependencies = [
  "bitflags 2.9.1",
  "ra-ap-rustc_hashes",
@@ -1875,24 +1875,24 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_ast_ir"
-version = "0.123.0"
+version = "0.126.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87cc17e8ce797f2a8d03b838fbf166749b876164432ce81e37d283bf69e3cf80"
+checksum = "aaab80bda0f05e9842e3afb7779b0bad0a4b54e0f7ba6deb5705dcf86482811d"
 
 [[package]]
 name = "ra-ap-rustc_hashes"
-version = "0.123.0"
+version = "0.126.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2439ed1df3472443133b66949f81080dff88089b42f825761455463709ee1cad"
+checksum = "64bd405e538102b5f699241794b2eefee39d5414c0e4bc72435e91430c51f905"
 dependencies = [
  "rustc-stable-hash",
 ]
 
 [[package]]
 name = "ra-ap-rustc_index"
-version = "0.123.0"
+version = "0.126.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57a24fe0be21be1f8ebc21dcb40129214fb4cefb0f2753f3d46b6dbe656a1a45"
+checksum = "521621e271aa03b8433dad5981838278d6cfd7d2d8c9f4eb6d427f1d671f90fc"
 dependencies = [
  "ra-ap-rustc_index_macros",
  "smallvec",
@@ -1900,9 +1900,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_index_macros"
-version = "0.123.0"
+version = "0.126.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "844a27ddcad0116facae2df8e741fd788662cf93dc13029cd864f2b8013b81f9"
+checksum = "245e30f2e1fef258913cc548b36f575549c8af31cbc4649929d21deda96ceeb7"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1911,20 +1911,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_lexer"
-version = "0.121.0"
+version = "0.126.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22944e31fb91e9b3e75bcbc91e37d958b8c0825a6160927f2856831d2ce83b36"
-dependencies = [
- "memchr",
- "unicode-properties",
- "unicode-xid",
-]
-
-[[package]]
-name = "ra-ap-rustc_lexer"
-version = "0.123.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b734cfcb577d09877799a22742f1bd398be6c00bc428d9de56d48d11ece5771"
+checksum = "a82681f924500e888c860e60ed99e9bf702a219a69374f59116c4261525a2157"
 dependencies = [
  "memchr",
  "unicode-properties",
@@ -1933,9 +1922,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_next_trait_solver"
-version = "0.123.0"
+version = "0.126.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14f7dfbdf1d045ff4e385e1efdfc3799379895e9c3f3b9b379a0bef4cb238441"
+checksum = "0c9ce51f2431fbdc7fabd2d957522b6e27f41f68ec2af74b52a6f4116352ce1a"
 dependencies = [
  "derive-where",
  "ra-ap-rustc_index",
@@ -1946,19 +1935,19 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_parse_format"
-version = "0.121.0"
+version = "0.126.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81057891bc2063ad9e353f29462fbc47a0f5072560af34428ae9313aaa5e9d97"
+checksum = "adc85ef3fdb6c084bde84857d8948dc66b752129dc8417a8614ce490e99a143f"
 dependencies = [
- "ra-ap-rustc_lexer 0.121.0",
- "rustc-literal-escaper",
+ "ra-ap-rustc_lexer",
+ "rustc-literal-escaper 0.0.5",
 ]
 
 [[package]]
 name = "ra-ap-rustc_pattern_analysis"
-version = "0.123.0"
+version = "0.126.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75b0ee1f059b9dea0818c6c7267478926eee95ba4c7dcf89c8db32fa165d3904"
+checksum = "3cd81eccf33d9528905d4e5abaa254b3129a6405d6c5f123fed9b73a3d217f35"
 dependencies = [
  "ra-ap-rustc_index",
  "rustc-hash 2.1.1",
@@ -1969,9 +1958,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_type_ir"
-version = "0.123.0"
+version = "0.126.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0bc59fb10a922c38a24cb8a1494f799b0af30bd041acbea689378d3bf330534b"
+checksum = "11cb0da02853698d9c89e1d1c01657b9969752befd56365e8899d4310e52b373"
 dependencies = [
  "bitflags 2.9.1",
  "derive-where",
@@ -1988,9 +1977,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_type_ir_macros"
-version = "0.123.0"
+version = "0.126.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58878914b6dac7499baeecc8dbb4b9d9dda88030e4ab90cd3b4e87523fbedafe"
+checksum = "ffc93adeb52c483ede13bee6680466458218243ab479c04fb71bb53925a6e0ff"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2140,6 +2129,12 @@ version = "0.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ab03008eb631b703dd16978282ae36c73282e7922fe101a4bd072a40ecea7b8b"
 
+[[package]]
+name = "rustc-literal-escaper"
+version = "0.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4ee29da77c5a54f42697493cd4c9b9f31b74df666a6c04dfc4fde77abe0438b"
+
 [[package]]
 name = "rustc-stable-hash"
 version = "0.1.2"
@@ -2445,7 +2440,7 @@ dependencies = [
  "rayon",
  "rowan",
  "rustc-hash 2.1.1",
- "rustc-literal-escaper",
+ "rustc-literal-escaper 0.0.4",
  "rustc_apfloat",
  "smol_str",
  "stdx",
@@ -2773,7 +2768,7 @@ version = "0.0.0"
 dependencies = [
  "arrayvec",
  "intern",
- "ra-ap-rustc_lexer 0.123.0",
+ "ra-ap-rustc_lexer",
  "stdx",
  "text-size",
 ]
diff --git a/src/tools/rust-analyzer/Cargo.toml b/src/tools/rust-analyzer/Cargo.toml
index 05ee190480c97..f325027ee5871 100644
--- a/src/tools/rust-analyzer/Cargo.toml
+++ b/src/tools/rust-analyzer/Cargo.toml
@@ -89,14 +89,14 @@ vfs-notify = { path = "./crates/vfs-notify", version = "0.0.0" }
 vfs = { path = "./crates/vfs", version = "0.0.0" }
 edition = { path = "./crates/edition", version = "0.0.0" }
 
-ra-ap-rustc_lexer = { version = "0.123", default-features = false }
-ra-ap-rustc_parse_format = { version = "0.121", default-features = false }
-ra-ap-rustc_index = { version = "0.123", default-features = false }
-ra-ap-rustc_abi = { version = "0.123", default-features = false }
-ra-ap-rustc_pattern_analysis = { version = "0.123", default-features = false }
-ra-ap-rustc_ast_ir = { version = "0.123", default-features = false }
-ra-ap-rustc_type_ir = { version = "0.123", default-features = false }
-ra-ap-rustc_next_trait_solver = { version = "0.123", default-features = false }
+ra-ap-rustc_lexer = { version = "0.126", default-features = false }
+ra-ap-rustc_parse_format = { version = "0.126", default-features = false }
+ra-ap-rustc_index = { version = "0.126", default-features = false }
+ra-ap-rustc_abi = { version = "0.126", default-features = false }
+ra-ap-rustc_pattern_analysis = { version = "0.126", default-features = false }
+ra-ap-rustc_ast_ir = { version = "0.126", default-features = false }
+ra-ap-rustc_type_ir = { version = "0.126", default-features = false }
+ra-ap-rustc_next_trait_solver = { version = "0.126", default-features = false }
 
 # local crates that aren't published to crates.io. These should not have versions.
 
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 5b8093f6b7246..fcb79e9ffb579 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
@@ -737,7 +737,7 @@ impl<'db> HirDisplay for crate::next_solver::Const<'db> {
         match self.kind() {
             rustc_type_ir::ConstKind::Placeholder(_) => write!(f, "<placeholder>"),
             rustc_type_ir::ConstKind::Bound(db, bound_const) => {
-                write!(f, "?{}.{}", db.as_u32(), bound_const.as_u32())
+                write!(f, "?{}.{}", db.as_u32(), bound_const.var.as_u32())
             }
             rustc_type_ir::ConstKind::Infer(..) => write!(f, "#c#"),
             rustc_type_ir::ConstKind::Param(param) => {
@@ -1208,10 +1208,7 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                 let contains_impl_fn_ns = |bounds: &[BoundExistentialPredicate<'_>]| {
                     bounds.iter().any(|bound| match bound.skip_binder() {
                         rustc_type_ir::ExistentialPredicate::Trait(trait_ref) => {
-                            let trait_ = match trait_ref.def_id {
-                                SolverDefId::TraitId(id) => id,
-                                _ => unreachable!(),
-                            };
+                            let trait_ = trait_ref.def_id.0;
                             fn_traits(db, trait_).any(|it| it == trait_)
                         }
                         _ => false,
@@ -2217,10 +2214,7 @@ impl HirDisplay for TraitRef {
 
 impl<'db> HirDisplay for crate::next_solver::TraitRef<'db> {
     fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
-        let trait_ = match self.def_id {
-            SolverDefId::TraitId(id) => id,
-            _ => unreachable!(),
-        };
+        let trait_ = self.def_id.0;
         f.start_location_link(trait_.into());
         write!(f, "{}", f.db.trait_signature(trait_).name.display(f.db, f.edition()))?;
         f.end_location_link();
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
index 23280b1f3b42b..d4b3751cf5666 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
@@ -2,12 +2,11 @@
 
 use std::ops::ControlFlow;
 
-use hir_def::hir::generics::LocalTypeOrConstParamId;
 use hir_def::{
     AssocItemId, ConstId, CrateRootModuleId, FunctionId, GenericDefId, HasModule, TraitId,
-    TypeAliasId, lang_item::LangItem, signatures::TraitFlags,
+    TypeAliasId, TypeOrConstParamId, TypeParamId, hir::generics::LocalTypeOrConstParamId,
+    lang_item::LangItem, signatures::TraitFlags,
 };
-use hir_def::{TypeOrConstParamId, TypeParamId};
 use intern::Symbol;
 use rustc_hash::FxHashSet;
 use rustc_type_ir::{
@@ -22,7 +21,7 @@ use crate::{
     db::{HirDatabase, InternedOpaqueTyId},
     lower_nextsolver::associated_ty_item_bounds,
     next_solver::{
-        Clause, Clauses, DbInterner, GenericArgs, ParamEnv, SolverDefId, TraitPredicate,
+        Clause, Clauses, DbInterner, GenericArgs, ParamEnv, SolverDefId, TraitPredicate, TraitRef,
         TypingMode, infer::DbInternerInferExt, mk_param,
     },
     traits::next_trait_solve_in_ctxt,
@@ -56,16 +55,12 @@ pub fn dyn_compatibility(
     trait_: TraitId,
 ) -> Option<DynCompatibilityViolation> {
     let interner = DbInterner::new_with(db, Some(trait_.krate(db)), None);
-    for super_trait in elaborate::supertrait_def_ids(interner, SolverDefId::TraitId(trait_)) {
-        let super_trait = match super_trait {
-            SolverDefId::TraitId(id) => id,
-            _ => unreachable!(),
-        };
-        if let Some(v) = db.dyn_compatibility_of_trait(super_trait) {
-            return if super_trait == trait_ {
+    for super_trait in elaborate::supertrait_def_ids(interner, trait_.into()) {
+        if let Some(v) = db.dyn_compatibility_of_trait(super_trait.0) {
+            return if super_trait.0 == trait_ {
                 Some(v)
             } else {
-                Some(DynCompatibilityViolation::HasNonCompatibleSuperTrait(super_trait))
+                Some(DynCompatibilityViolation::HasNonCompatibleSuperTrait(super_trait.0))
             };
         }
     }
@@ -82,13 +77,8 @@ where
     F: FnMut(DynCompatibilityViolation) -> ControlFlow<()>,
 {
     let interner = DbInterner::new_with(db, Some(trait_.krate(db)), None);
-    for super_trait in elaborate::supertrait_def_ids(interner, SolverDefId::TraitId(trait_)).skip(1)
-    {
-        let super_trait = match super_trait {
-            SolverDefId::TraitId(id) => id,
-            _ => unreachable!(),
-        };
-        if db.dyn_compatibility_of_trait(super_trait).is_some() {
+    for super_trait in elaborate::supertrait_def_ids(interner, trait_.into()).skip(1) {
+        if db.dyn_compatibility_of_trait(super_trait.0).is_some() {
             cb(DynCompatibilityViolation::HasNonCompatibleSuperTrait(trait_))?;
         }
     }
@@ -151,7 +141,7 @@ pub fn generics_require_sized_self(db: &dyn HirDatabase, def: GenericDefId) -> b
     elaborate::elaborate(interner, predicates.iter().copied()).any(|pred| {
         match pred.kind().skip_binder() {
             ClauseKind::Trait(trait_pred) => {
-                if SolverDefId::TraitId(sized) == trait_pred.def_id()
+                if sized == trait_pred.def_id().0
                     && let rustc_type_ir::TyKind::Param(param_ty) =
                         trait_pred.trait_ref.self_ty().kind()
                     && param_ty.index == 0
@@ -257,15 +247,9 @@ fn contains_illegal_self_type_reference<'db, T: rustc_type_ir::TypeVisitable<DbI
                         };
                         if self.super_traits.is_none() {
                             self.super_traits = Some(
-                                elaborate::supertrait_def_ids(
-                                    interner,
-                                    SolverDefId::TraitId(self.trait_),
-                                )
-                                .map(|super_trait| match super_trait {
-                                    SolverDefId::TraitId(id) => id,
-                                    _ => unreachable!(),
-                                })
-                                .collect(),
+                                elaborate::supertrait_def_ids(interner, self.trait_.into())
+                                    .map(|super_trait| super_trait.0)
+                                    .collect(),
                             )
                         }
                         if self.super_traits.as_ref().is_some_and(|s| s.contains(&trait_)) {
@@ -390,8 +374,7 @@ where
             trait_ref: pred_trait_ref,
             polarity: PredicatePolarity::Positive,
         }) = pred
-            && let SolverDefId::TraitId(trait_id) = pred_trait_ref.def_id
-            && let trait_data = db.trait_signature(trait_id)
+            && let trait_data = db.trait_signature(pred_trait_ref.def_id.0)
             && trait_data.flags.contains(TraitFlags::AUTO)
             && let rustc_type_ir::TyKind::Param(crate::next_solver::ParamTy { index: 0, .. }) =
                 pred_trait_ref.self_ty().kind()
@@ -464,25 +447,17 @@ fn receiver_is_dispatchable<'db>(
         let generic_predicates = &*db.generic_predicates_ns(func.into());
 
         // Self: Unsize<U>
-        let unsize_predicate = crate::next_solver::TraitRef::new(
-            interner,
-            SolverDefId::TraitId(unsize_did),
-            [self_param_ty, unsized_self_ty],
-        );
+        let unsize_predicate =
+            TraitRef::new(interner, unsize_did.into(), [self_param_ty, unsized_self_ty]);
 
         // U: Trait<Arg1, ..., ArgN>
-        let trait_def_id = SolverDefId::TraitId(trait_);
-        let args = GenericArgs::for_item(interner, trait_def_id, |name, index, kind, _| {
+        let args = GenericArgs::for_item(interner, trait_.into(), |name, index, kind, _| {
             if index == 0 { unsized_self_ty.into() } else { mk_param(interner, index, name, kind) }
         });
-        let trait_predicate =
-            crate::next_solver::TraitRef::new_from_args(interner, trait_def_id, args);
+        let trait_predicate = TraitRef::new_from_args(interner, trait_.into(), args);
 
-        let meta_sized_predicate = crate::next_solver::TraitRef::new(
-            interner,
-            SolverDefId::TraitId(meta_sized_did),
-            [unsized_self_ty],
-        );
+        let meta_sized_predicate =
+            TraitRef::new(interner, meta_sized_did.into(), [unsized_self_ty]);
 
         ParamEnv {
             clauses: Clauses::new_from_iter(
@@ -497,11 +472,8 @@ fn receiver_is_dispatchable<'db>(
     };
 
     // Receiver: DispatchFromDyn<Receiver[Self => U]>
-    let predicate = crate::next_solver::TraitRef::new(
-        interner,
-        SolverDefId::TraitId(dispatch_from_dyn_did),
-        [receiver_ty, unsized_receiver_ty],
-    );
+    let predicate =
+        TraitRef::new(interner, dispatch_from_dyn_did.into(), [receiver_ty, unsized_receiver_ty]);
     let goal = crate::next_solver::Goal::new(interner, param_env, predicate);
 
     let infcx = interner.infer_ctxt().build(TypingMode::non_body_analysis());
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
index 4578922ce3219..c6a8fa81edff5 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
@@ -590,11 +590,9 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
                         .resolve_trait(ctx.ty_ctx().db, ctx.ty_ctx().resolver.krate());
                     let pointee_sized = LangItem::PointeeSized
                         .resolve_trait(ctx.ty_ctx().db, ctx.ty_ctx().resolver.krate());
-                    if meta_sized.is_some_and(|it| SolverDefId::TraitId(it) == trait_ref.def_id) {
+                    if meta_sized.is_some_and(|it| it == trait_ref.def_id.0) {
                         // Ignore this bound
-                    } else if pointee_sized
-                        .is_some_and(|it| SolverDefId::TraitId(it) == trait_ref.def_id)
-                    {
+                    } else if pointee_sized.is_some_and(|it| it == trait_ref.def_id.0) {
                         // Regard this as `?Sized` bound
                         ctx.ty_ctx().unsized_types.insert(self_ty);
                     } else {
@@ -618,13 +616,9 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
                 // Don't lower associated type bindings as the only possible relaxed trait bound
                 // `?Sized` has no of them.
                 // If we got another trait here ignore the bound completely.
-                let trait_id =
-                    self.lower_trait_ref_from_path(path, self_ty).map(|(trait_ref, _)| {
-                        match trait_ref.def_id {
-                            SolverDefId::TraitId(id) => id,
-                            _ => unreachable!(),
-                        }
-                    });
+                let trait_id = self
+                    .lower_trait_ref_from_path(path, self_ty)
+                    .map(|(trait_ref, _)| trait_ref.def_id.0);
                 if trait_id == sized_trait {
                     self.unsized_types.insert(self_ty);
                 }
@@ -668,12 +662,8 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
                         .map_bound(|c| match c {
                             rustc_type_ir::ClauseKind::Trait(t) => {
                                 let id = t.def_id();
-                                let id = match id {
-                                    SolverDefId::TraitId(id) => id,
-                                    _ => unreachable!(),
-                                };
                                 let is_auto =
-                                    db.trait_signature(id).flags.contains(TraitFlags::AUTO);
+                                    db.trait_signature(id.0).flags.contains(TraitFlags::AUTO);
                                 if is_auto {
                                     Some(ExistentialPredicate::AutoTrait(t.def_id()))
                                 } else {
@@ -733,17 +723,7 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
                     (
                         ExistentialPredicate::AutoTrait(lhs_id),
                         ExistentialPredicate::AutoTrait(rhs_id),
-                    ) => {
-                        let lhs_id = match lhs_id {
-                            SolverDefId::TraitId(id) => id,
-                            _ => unreachable!(),
-                        };
-                        let rhs_id = match rhs_id {
-                            SolverDefId::TraitId(id) => id,
-                            _ => unreachable!(),
-                        };
-                        lhs_id.cmp(&rhs_id)
-                    }
+                    ) => lhs_id.0.cmp(&rhs_id.0),
                     (ExistentialPredicate::Trait(_), _) => Ordering::Less,
                     (_, ExistentialPredicate::Trait(_)) => Ordering::Greater,
                     (ExistentialPredicate::AutoTrait(_), _) => Ordering::Less,
@@ -1195,11 +1175,7 @@ pub(crate) fn generic_predicates_for_param_query<'db>(
                     };
 
                     rustc_type_ir::elaborate::supertrait_def_ids(interner, tr.into()).any(|tr| {
-                        let tr = match tr {
-                            SolverDefId::TraitId(id) => id,
-                            _ => unreachable!(),
-                        };
-                        tr.trait_items(db).items.iter().any(|(name, item)| {
+                        tr.0.trait_items(db).items.iter().any(|(name, item)| {
                             matches!(item, AssocItemId::TypeAliasId(_)) && name == assoc_name
                         })
                     })
@@ -1629,11 +1605,7 @@ pub(crate) fn associated_ty_item_bounds<'db>(
                 .map_bound(|c| match c {
                     rustc_type_ir::ClauseKind::Trait(t) => {
                         let id = t.def_id();
-                        let id = match id {
-                            SolverDefId::TraitId(id) => id,
-                            _ => unreachable!(),
-                        };
-                        let is_auto = db.trait_signature(id).flags.contains(TraitFlags::AUTO);
+                        let is_auto = db.trait_signature(id.0).flags.contains(TraitFlags::AUTO);
                         if is_auto {
                             Some(ExistentialPredicate::AutoTrait(t.def_id()))
                         } else {
@@ -1677,7 +1649,7 @@ pub(crate) fn associated_ty_item_bounds<'db>(
         let sized_trait = LangItem::Sized.resolve_trait(db, resolver.krate());
         let sized_clause = Binder::dummy(ExistentialPredicate::Trait(ExistentialTraitRef::new(
             interner,
-            SolverDefId::TraitId(trait_),
+            trait_.into(),
             [] as [crate::next_solver::GenericArg<'_>; 0],
         )));
         bounds.push(sized_clause);
@@ -1694,10 +1666,7 @@ pub(crate) fn associated_type_by_name_including_super_traits<'db>(
 ) -> Option<(TraitRef<'db>, TypeAliasId)> {
     let interner = DbInterner::new_with(db, None, None);
     rustc_type_ir::elaborate::supertraits(interner, Binder::dummy(trait_ref)).find_map(|t| {
-        let trait_id = match t.as_ref().skip_binder().def_id {
-            SolverDefId::TraitId(id) => id,
-            _ => unreachable!(),
-        };
+        let trait_id = t.as_ref().skip_binder().def_id.0;
         let assoc_type = trait_id.trait_items(db).associated_type_by_name(name)?;
         Some((t.skip_binder(), assoc_type))
     })
@@ -1727,10 +1696,7 @@ fn named_associated_type_shorthand_candidates<'db, R>(
 ) -> Option<R> {
     let db = interner.db;
     let mut search = |t: TraitRef<'db>| -> Option<R> {
-        let trait_id = match t.def_id {
-            SolverDefId::TraitId(id) => id,
-            _ => unreachable!(),
-        };
+        let trait_id = t.def_id.0;
         let mut checked_traits = FxHashSet::default();
         let mut check_trait = |trait_id: TraitId| {
             let name = &db.trait_signature(trait_id).name;
@@ -1773,11 +1739,7 @@ fn named_associated_type_shorthand_candidates<'db, R>(
                     rustc_type_ir::ClauseKind::Trait(pred) => pred.def_id(),
                     _ => continue,
                 };
-                let trait_id = match trait_id {
-                    SolverDefId::TraitId(trait_id) => trait_id,
-                    _ => continue,
-                };
-                stack.push(trait_id);
+                stack.push(trait_id.0);
             }
             tracing::debug!(?stack);
         }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver/path.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver/path.rs
index ccdb5a0bdb4a9..7d6734303c48b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver/path.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver/path.rs
@@ -208,10 +208,7 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
                         tracing::debug!(?trait_ref);
                         self.skip_resolved_segment();
                         let segment = self.current_or_prev_segment;
-                        let trait_id = match trait_ref.def_id {
-                            SolverDefId::TraitId(id) => id,
-                            _ => unreachable!(),
-                        };
+                        let trait_id = trait_ref.def_id.0;
                         let found =
                             trait_id.trait_items(self.ctx.db).associated_type_by_name(segment.name);
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
index 8bd71df7c191d..f0be352fdd151 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
@@ -168,11 +168,7 @@ impl TyFingerprint {
                         _ => None,
                     })
                     .next()?;
-                let trait_id = match trait_ref {
-                    SolverDefId::TraitId(id) => id,
-                    _ => panic!("Bad GenericDefId in trait ref"),
-                };
-                TyFingerprint::Dyn(trait_id)
+                TyFingerprint::Dyn(trait_ref.0)
             }
             TyKind::Ref(_, _, mutability) => match mutability {
                 rustc_ast_ir::Mutability::Mut => TyFingerprint::Ref(Mutability::Mut),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs
index cfafc65d18443..23789b06e828b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs
@@ -81,7 +81,7 @@ impl<'db> std::fmt::Debug for InternedWrapperNoDebug<WithCachedTypeInfo<ConstKin
     }
 }
 
-pub type PlaceholderConst = Placeholder<rustc_type_ir::BoundVar>;
+pub type PlaceholderConst = Placeholder<BoundConst>;
 
 #[derive(Copy, Clone, Hash, Eq, PartialEq)]
 pub struct ParamConst {
@@ -304,7 +304,7 @@ impl<'db> rustc_type_ir::inherent::Const<DbInterner<'db>> for Const<'db> {
     fn new_bound(
         interner: DbInterner<'db>,
         debruijn: rustc_type_ir::DebruijnIndex,
-        var: BoundVar,
+        var: BoundConst,
     ) -> Self {
         Const::new(interner, ConstKind::Bound(debruijn, var))
     }
@@ -314,7 +314,7 @@ impl<'db> rustc_type_ir::inherent::Const<DbInterner<'db>> for Const<'db> {
         debruijn: rustc_type_ir::DebruijnIndex,
         var: rustc_type_ir::BoundVar,
     ) -> Self {
-        Const::new(interner, ConstKind::Bound(debruijn, var))
+        Const::new(interner, ConstKind::Bound(debruijn, BoundConst { var }))
     }
 
     fn new_unevaluated(
@@ -340,26 +340,41 @@ impl<'db> rustc_type_ir::inherent::Const<DbInterner<'db>> for Const<'db> {
     }
 }
 
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct BoundConst {
+    pub var: BoundVar,
+}
+
+impl<'db> rustc_type_ir::inherent::BoundVarLike<DbInterner<'db>> for BoundConst {
+    fn var(self) -> BoundVar {
+        self.var
+    }
+
+    fn assert_eq(self, var: BoundVarKind) {
+        var.expect_const()
+    }
+}
+
 impl<'db> PlaceholderLike<DbInterner<'db>> for PlaceholderConst {
-    type Bound = rustc_type_ir::BoundVar;
+    type Bound = BoundConst;
 
     fn universe(self) -> rustc_type_ir::UniverseIndex {
         self.universe
     }
 
     fn var(self) -> rustc_type_ir::BoundVar {
-        self.bound
+        self.bound.var
     }
 
     fn with_updated_universe(self, ui: rustc_type_ir::UniverseIndex) -> Self {
         Placeholder { universe: ui, bound: self.bound }
     }
 
-    fn new(ui: rustc_type_ir::UniverseIndex, var: rustc_type_ir::BoundVar) -> Self {
+    fn new(ui: rustc_type_ir::UniverseIndex, var: BoundConst) -> Self {
         Placeholder { universe: ui, bound: var }
     }
     fn new_anon(ui: rustc_type_ir::UniverseIndex, var: rustc_type_ir::BoundVar) -> Self {
-        Placeholder { universe: ui, bound: var }
+        Placeholder { universe: ui, bound: BoundConst { var } }
     }
 }
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
index c9632ddcd4bb5..8bbc6e3370399 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
@@ -88,3 +88,60 @@ impl<'db> inherent::DefId<DbInterner<'db>> for SolverDefId {
         true
     }
 }
+
+macro_rules! declare_id_wrapper {
+    ($name:ident, $wraps:ident) => {
+        #[derive(Clone, Copy, PartialEq, Eq, Hash)]
+        pub struct $name(pub $wraps);
+
+        impl std::fmt::Debug for $name {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                std::fmt::Debug::fmt(&self.0, f)
+            }
+        }
+
+        impl From<$name> for $wraps {
+            #[inline]
+            fn from(value: $name) -> $wraps {
+                value.0
+            }
+        }
+
+        impl From<$wraps> for $name {
+            #[inline]
+            fn from(value: $wraps) -> $name {
+                Self(value)
+            }
+        }
+
+        impl From<$name> for SolverDefId {
+            #[inline]
+            fn from(value: $name) -> SolverDefId {
+                value.0.into()
+            }
+        }
+
+        impl TryFrom<SolverDefId> for $name {
+            type Error = ();
+
+            #[inline]
+            fn try_from(value: SolverDefId) -> Result<Self, Self::Error> {
+                match value {
+                    SolverDefId::$wraps(it) => Ok(Self(it)),
+                    _ => Err(()),
+                }
+            }
+        }
+
+        impl<'db> inherent::DefId<DbInterner<'db>> for $name {
+            fn as_local(self) -> Option<SolverDefId> {
+                Some(self.into())
+            }
+            fn is_local(self) -> bool {
+                true
+            }
+        }
+    };
+}
+
+declare_id_wrapper!(TraitIdWrapper, TraitId);
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fold.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fold.rs
index 3cc1e64b6add0..405a57d9e898c 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fold.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fold.rs
@@ -6,6 +6,8 @@ use rustc_type_ir::{
     inherent::{IntoKind, Region as _},
 };
 
+use crate::next_solver::BoundConst;
+
 use super::{
     Binder, BoundRegion, BoundTy, Const, ConstKind, DbInterner, Predicate, Region, Ty, TyKind,
 };
@@ -18,7 +20,7 @@ use super::{
 pub trait BoundVarReplacerDelegate<'db> {
     fn replace_region(&mut self, br: BoundRegion) -> Region<'db>;
     fn replace_ty(&mut self, bt: BoundTy) -> Ty<'db>;
-    fn replace_const(&mut self, bv: BoundVar) -> Const<'db>;
+    fn replace_const(&mut self, bv: BoundConst) -> Const<'db>;
 }
 
 /// A simple delegate taking 3 mutable functions. The used functions must
@@ -27,7 +29,7 @@ pub trait BoundVarReplacerDelegate<'db> {
 pub struct FnMutDelegate<'db, 'a> {
     pub regions: &'a mut (dyn FnMut(BoundRegion) -> Region<'db> + 'a),
     pub types: &'a mut (dyn FnMut(BoundTy) -> Ty<'db> + 'a),
-    pub consts: &'a mut (dyn FnMut(BoundVar) -> Const<'db> + 'a),
+    pub consts: &'a mut (dyn FnMut(BoundConst) -> Const<'db> + 'a),
 }
 
 impl<'db, 'a> BoundVarReplacerDelegate<'db> for FnMutDelegate<'db, 'a> {
@@ -37,7 +39,7 @@ impl<'db, 'a> BoundVarReplacerDelegate<'db> for FnMutDelegate<'db, 'a> {
     fn replace_ty(&mut self, bt: BoundTy) -> Ty<'db> {
         (self.types)(bt)
     }
-    fn replace_const(&mut self, bv: BoundVar) -> Const<'db> {
+    fn replace_const(&mut self, bv: BoundConst) -> Const<'db> {
         (self.consts)(bv)
     }
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill.rs
index 007a674ad399a..4258f4c7ac68b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill.rs
@@ -167,7 +167,7 @@ impl<'db> FulfillmentCtxt<'db> {
                 }
 
                 let result = delegate.evaluate_root_goal(goal, Span::dummy(), stalled_on);
-                let GoalEvaluation { certainty, has_changed, stalled_on } = match result {
+                let GoalEvaluation { goal: _, certainty, has_changed, stalled_on } = match result {
                     Ok(result) => result,
                     Err(NoSolution) => {
                         errors.push(NextSolverError::TrueError(obligation));
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generic_arg.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generic_arg.rs
index d284eb9c6b419..4e124d07d2b38 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generic_arg.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generic_arg.rs
@@ -384,7 +384,6 @@ impl<'db> rustc_type_ir::inherent::GenericArgs<DbInterner<'db>> for GenericArgs<
                 signature_parts_ty: signature_parts_ty.expect_ty(),
                 tupled_upvars_ty: tupled_upvars_ty.expect_ty(),
                 coroutine_captures_by_ref_ty: coroutine_captures_by_ref_ty.expect_ty(),
-                coroutine_witness_ty: coroutine_witness_ty.expect_ty(),
             },
             _ => panic!("GenericArgs were likely not for a CoroutineClosure."),
         }
@@ -400,7 +399,6 @@ impl<'db> rustc_type_ir::inherent::GenericArgs<DbInterner<'db>> for GenericArgs<
                     resume_ty: resume_ty.expect_ty(),
                     yield_ty: yield_ty.expect_ty(),
                     return_ty: return_ty.expect_ty(),
-                    witness: Ty::new_unit(interner),
                     tupled_upvars_ty: Ty::new_unit(interner),
                 }
             }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/instantiate.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/instantiate.rs
index 0448f03463e4b..6c7a87ef52494 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/instantiate.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/instantiate.rs
@@ -6,6 +6,7 @@
 //!
 //! [c]: https://rust-lang.github.io/chalk/book/canonical_queries/canonicalization.html
 
+use crate::next_solver::BoundConst;
 use crate::next_solver::{
     AliasTy, Binder, BoundRegion, BoundTy, Canonical, CanonicalVarValues, Const, DbInterner, Goal,
     ParamEnv, Predicate, PredicateKind, Region, Ty, TyKind,
@@ -95,7 +96,7 @@ where
                 GenericArgKind::Type(ty) => ty,
                 r => panic!("{bound_ty:?} is a type but value is {r:?}"),
             },
-            consts: &mut |bound_ct: BoundVar| match var_values[bound_ct].kind() {
+            consts: &mut |bound_ct: BoundConst| match var_values[bound_ct.var].kind() {
                 GenericArgKind::Const(ct) => ct,
                 c => panic!("{bound_ct:?} is a const but value is {c:?}"),
             },
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs
index 58832aef89529..585719144ef42 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs
@@ -37,7 +37,7 @@ use unify_key::{ConstVariableOrigin, ConstVariableValue, ConstVidKey};
 
 use crate::next_solver::fold::BoundVarReplacerDelegate;
 use crate::next_solver::infer::opaque_types::table::OpaqueTypeStorageEntries;
-use crate::next_solver::{BoundRegion, BoundTy, BoundVarKind};
+use crate::next_solver::{BoundConst, BoundRegion, BoundTy, BoundVarKind};
 
 use super::generics::GenericParamDef;
 use super::{
@@ -864,8 +864,8 @@ impl<'db> InferCtxt<'db> {
             fn replace_ty(&mut self, bt: BoundTy) -> Ty<'db> {
                 self.args[bt.var.index()].expect_ty()
             }
-            fn replace_const(&mut self, bv: BoundVar) -> Const<'db> {
-                self.args[bv.index()].expect_const()
+            fn replace_const(&mut self, bv: BoundConst) -> Const<'db> {
+                self.args[bv.var.index()].expect_const()
             }
         }
         let delegate = ToFreshVars { args };
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/relate/higher_ranked.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/relate/higher_ranked.rs
index bb80c5157109c..62028e0e70399 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/relate/higher_ranked.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/relate/higher_ranked.rs
@@ -10,8 +10,8 @@ use crate::next_solver::fold::FnMutDelegate;
 use crate::next_solver::infer::InferCtxt;
 use crate::next_solver::infer::snapshot::CombinedSnapshot;
 use crate::next_solver::{
-    Binder, BoundRegion, BoundTy, Const, DbInterner, PlaceholderConst, PlaceholderRegion,
-    PlaceholderTy, Region, Ty,
+    Binder, BoundConst, BoundRegion, BoundTy, Const, DbInterner, PlaceholderConst,
+    PlaceholderRegion, PlaceholderTy, Region, Ty,
 };
 
 impl<'db> InferCtxt<'db> {
@@ -50,10 +50,10 @@ impl<'db> InferCtxt<'db> {
                     PlaceholderTy { universe: next_universe, bound: bound_ty },
                 )
             },
-            consts: &mut |bound_var: BoundVar| {
+            consts: &mut |bound: BoundConst| {
                 Const::new_placeholder(
                     self.interner,
-                    PlaceholderConst { universe: next_universe, bound: bound_var },
+                    PlaceholderConst { universe: next_universe, bound },
                 )
             },
         };
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
index 6e1a5e9645573..5709beaefc292 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
@@ -19,7 +19,7 @@ use rustc_type_ir::error::TypeError;
 use rustc_type_ir::inherent::{
     AdtDef as _, GenericArgs as _, GenericsOf, IntoKind, SliceLike as _, Span as _,
 };
-use rustc_type_ir::lang_items::TraitSolverLangItem;
+use rustc_type_ir::lang_items::{SolverLangItem, SolverTraitLangItem};
 use rustc_type_ir::solve::SizedTraitKind;
 use rustc_type_ir::{
     AliasTerm, AliasTermKind, AliasTy, AliasTyKind, EarlyBinder, FlagComputation, Flags,
@@ -44,9 +44,11 @@ use rustc_type_ir::{
 
 use crate::lower_nextsolver::{self, TyLoweringContext};
 use crate::method_resolution::{ALL_FLOAT_FPS, ALL_INT_FPS, TyFingerprint};
+use crate::next_solver::infer::InferCtxt;
 use crate::next_solver::util::{ContainsTypeErrors, explicit_item_bounds, for_trait_impls};
 use crate::next_solver::{
-    CanonicalVarKind, FxIndexMap, InternedWrapperNoDebug, RegionAssumptions, SolverDefIds,
+    BoundConst, CanonicalVarKind, FxIndexMap, InternedWrapperNoDebug, RegionAssumptions,
+    SolverContext, SolverDefIds, TraitIdWrapper,
 };
 use crate::{ConstScalar, FnAbi, Interner, db::HirDatabase};
 
@@ -858,10 +860,35 @@ impl<'db> rustc_type_ir::relate::Relate<DbInterner<'db>> for Pattern<'db> {
 
 interned_vec_db!(PatList, Pattern);
 
+macro_rules! as_lang_item {
+    (
+        $solver_enum:ident, $var:ident;
+
+        ignore = {
+            $( $ignore:ident ),* $(,)?
+        }
+
+        $( $variant:ident ),* $(,)?
+    ) => {{
+        // Ensure exhaustiveness.
+        if let Some(it) = None::<$solver_enum> {
+            match it {
+                $( $solver_enum::$variant => {} )*
+                $( $solver_enum::$ignore => {} )*
+            }
+        }
+        match $var {
+            $( LangItem::$variant => Some($solver_enum::$variant), )*
+            _ => None
+        }
+    }};
+}
+
 impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
     type DefId = SolverDefId;
     type LocalDefId = SolverDefId;
     type LocalDefIds = SolverDefIds;
+    type TraitId = TraitIdWrapper;
     type Span = Span;
 
     type GenericArgs = GenericArgs<'db>;
@@ -923,7 +950,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
     type Const = Const<'db>;
     type PlaceholderConst = PlaceholderConst;
     type ParamConst = ParamConst;
-    type BoundConst = rustc_type_ir::BoundVar;
+    type BoundConst = BoundConst;
     type ValueConst = ValueConst<'db>;
     type ValTree = Valtree<'db>;
     type ExprConst = ExprConst;
@@ -1117,7 +1144,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
         );
         let alias_args =
             GenericArgs::new_from_iter(self, args.iter().skip(trait_generics.own_params.len()));
-        (TraitRef::new_from_args(self, trait_def_id, trait_args), alias_args)
+        (TraitRef::new_from_args(self, trait_def_id.try_into().unwrap(), trait_args), alias_args)
     }
 
     fn check_args_compatible(self, def_id: Self::DefId, args: Self::GenericArgs) -> bool {
@@ -1305,11 +1332,11 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
     #[tracing::instrument(skip(self), ret)]
     fn explicit_super_predicates_of(
         self,
-        def_id: Self::DefId,
+        def_id: Self::TraitId,
     ) -> EarlyBinder<Self, impl IntoIterator<Item = (Self::Clause, Self::Span)>> {
         let predicates: Vec<(Clause<'db>, Span)> = self
             .db()
-            .generic_predicates_ns(def_id.try_into().unwrap())
+            .generic_predicates_ns(def_id.0.into())
             .iter()
             .cloned()
             .map(|p| (p, Span::dummy()))
@@ -1369,65 +1396,19 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
         false
     }
 
-    fn require_lang_item(
-        self,
-        lang_item: rustc_type_ir::lang_items::TraitSolverLangItem,
-    ) -> Self::DefId {
+    fn require_lang_item(self, lang_item: SolverLangItem) -> Self::DefId {
         let lang_item = match lang_item {
-            rustc_type_ir::lang_items::TraitSolverLangItem::AsyncFn => LangItem::AsyncFn,
-            rustc_type_ir::lang_items::TraitSolverLangItem::AsyncFnKindHelper => unimplemented!(),
-            rustc_type_ir::lang_items::TraitSolverLangItem::AsyncFnKindUpvars => unimplemented!(),
-            rustc_type_ir::lang_items::TraitSolverLangItem::AsyncFnMut => LangItem::AsyncFnMut,
-            rustc_type_ir::lang_items::TraitSolverLangItem::AsyncFnOnce => LangItem::AsyncFnOnce,
-            rustc_type_ir::lang_items::TraitSolverLangItem::AsyncFnOnceOutput => {
-                LangItem::AsyncFnOnceOutput
-            }
-            rustc_type_ir::lang_items::TraitSolverLangItem::AsyncIterator => unimplemented!(),
-            rustc_type_ir::lang_items::TraitSolverLangItem::CallOnceFuture => {
-                LangItem::CallOnceFuture
-            }
-            rustc_type_ir::lang_items::TraitSolverLangItem::CallRefFuture => {
-                LangItem::CallRefFuture
-            }
-            rustc_type_ir::lang_items::TraitSolverLangItem::Clone => LangItem::Clone,
-            rustc_type_ir::lang_items::TraitSolverLangItem::Copy => LangItem::Copy,
-            rustc_type_ir::lang_items::TraitSolverLangItem::Coroutine => LangItem::Coroutine,
-            rustc_type_ir::lang_items::TraitSolverLangItem::CoroutineReturn => {
-                LangItem::CoroutineReturn
-            }
-            rustc_type_ir::lang_items::TraitSolverLangItem::CoroutineYield => {
-                LangItem::CoroutineYield
-            }
-            rustc_type_ir::lang_items::TraitSolverLangItem::Destruct => LangItem::Destruct,
-            rustc_type_ir::lang_items::TraitSolverLangItem::DiscriminantKind => {
-                LangItem::DiscriminantKind
-            }
-            rustc_type_ir::lang_items::TraitSolverLangItem::Drop => LangItem::Drop,
-            rustc_type_ir::lang_items::TraitSolverLangItem::DynMetadata => LangItem::DynMetadata,
-            rustc_type_ir::lang_items::TraitSolverLangItem::Fn => LangItem::Fn,
-            rustc_type_ir::lang_items::TraitSolverLangItem::FnMut => LangItem::FnMut,
-            rustc_type_ir::lang_items::TraitSolverLangItem::FnOnce => LangItem::FnOnce,
-            rustc_type_ir::lang_items::TraitSolverLangItem::FnPtrTrait => LangItem::FnPtrTrait,
-            rustc_type_ir::lang_items::TraitSolverLangItem::FusedIterator => unimplemented!(),
-            rustc_type_ir::lang_items::TraitSolverLangItem::Future => LangItem::Future,
-            rustc_type_ir::lang_items::TraitSolverLangItem::FutureOutput => LangItem::FutureOutput,
-            rustc_type_ir::lang_items::TraitSolverLangItem::Iterator => LangItem::Iterator,
-            rustc_type_ir::lang_items::TraitSolverLangItem::Metadata => LangItem::Metadata,
-            rustc_type_ir::lang_items::TraitSolverLangItem::Option => LangItem::Option,
-            rustc_type_ir::lang_items::TraitSolverLangItem::PointeeTrait => LangItem::PointeeTrait,
-            rustc_type_ir::lang_items::TraitSolverLangItem::Poll => LangItem::Poll,
-            rustc_type_ir::lang_items::TraitSolverLangItem::Sized => LangItem::Sized,
-            rustc_type_ir::lang_items::TraitSolverLangItem::MetaSized => LangItem::MetaSized,
-            rustc_type_ir::lang_items::TraitSolverLangItem::PointeeSized => LangItem::PointeeSized,
-            rustc_type_ir::lang_items::TraitSolverLangItem::TransmuteTrait => {
-                LangItem::TransmuteTrait
-            }
-            rustc_type_ir::lang_items::TraitSolverLangItem::Tuple => LangItem::Tuple,
-            rustc_type_ir::lang_items::TraitSolverLangItem::Unpin => LangItem::Unpin,
-            rustc_type_ir::lang_items::TraitSolverLangItem::Unsize => LangItem::Unsize,
-            rustc_type_ir::lang_items::TraitSolverLangItem::BikeshedGuaranteedNoDrop => {
-                unimplemented!()
-            }
+            SolverLangItem::AsyncFnKindUpvars => unimplemented!(),
+            SolverLangItem::AsyncFnOnceOutput => LangItem::AsyncFnOnceOutput,
+            SolverLangItem::CallOnceFuture => LangItem::CallOnceFuture,
+            SolverLangItem::CallRefFuture => LangItem::CallRefFuture,
+            SolverLangItem::CoroutineReturn => LangItem::CoroutineReturn,
+            SolverLangItem::CoroutineYield => LangItem::CoroutineYield,
+            SolverLangItem::DynMetadata => LangItem::DynMetadata,
+            SolverLangItem::FutureOutput => LangItem::FutureOutput,
+            SolverLangItem::Metadata => LangItem::Metadata,
+            SolverLangItem::Option => LangItem::Option,
+            SolverLangItem::Poll => LangItem::Poll,
         };
         let target = hir_def::lang_item::lang_item(
             self.db(),
@@ -1448,216 +1429,131 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
         }
     }
 
+    fn require_trait_lang_item(self, lang_item: SolverTraitLangItem) -> TraitIdWrapper {
+        let lang_item = match lang_item {
+            SolverTraitLangItem::AsyncFn => LangItem::AsyncFn,
+            SolverTraitLangItem::AsyncFnKindHelper => unimplemented!(),
+            SolverTraitLangItem::AsyncFnMut => LangItem::AsyncFnMut,
+            SolverTraitLangItem::AsyncFnOnce => LangItem::AsyncFnOnce,
+            SolverTraitLangItem::AsyncFnOnceOutput => LangItem::AsyncFnOnceOutput,
+            SolverTraitLangItem::AsyncIterator => unimplemented!(),
+            SolverTraitLangItem::Clone => LangItem::Clone,
+            SolverTraitLangItem::Copy => LangItem::Copy,
+            SolverTraitLangItem::Coroutine => LangItem::Coroutine,
+            SolverTraitLangItem::Destruct => LangItem::Destruct,
+            SolverTraitLangItem::DiscriminantKind => LangItem::DiscriminantKind,
+            SolverTraitLangItem::Drop => LangItem::Drop,
+            SolverTraitLangItem::Fn => LangItem::Fn,
+            SolverTraitLangItem::FnMut => LangItem::FnMut,
+            SolverTraitLangItem::FnOnce => LangItem::FnOnce,
+            SolverTraitLangItem::FnPtrTrait => LangItem::FnPtrTrait,
+            SolverTraitLangItem::FusedIterator => unimplemented!(),
+            SolverTraitLangItem::Future => LangItem::Future,
+            SolverTraitLangItem::Iterator => LangItem::Iterator,
+            SolverTraitLangItem::PointeeTrait => LangItem::PointeeTrait,
+            SolverTraitLangItem::Sized => LangItem::Sized,
+            SolverTraitLangItem::MetaSized => LangItem::MetaSized,
+            SolverTraitLangItem::PointeeSized => LangItem::PointeeSized,
+            SolverTraitLangItem::TransmuteTrait => LangItem::TransmuteTrait,
+            SolverTraitLangItem::Tuple => LangItem::Tuple,
+            SolverTraitLangItem::Unpin => LangItem::Unpin,
+            SolverTraitLangItem::Unsize => LangItem::Unsize,
+            SolverTraitLangItem::BikeshedGuaranteedNoDrop => {
+                unimplemented!()
+            }
+        };
+        lang_item
+            .resolve_trait(self.db(), self.krate.expect("Must have self.krate"))
+            .unwrap_or_else(|| panic!("Lang item {lang_item:?} required but not found."))
+            .into()
+    }
+
     #[allow(clippy::match_like_matches_macro)]
-    fn is_lang_item(
-        self,
-        def_id: Self::DefId,
-        lang_item: rustc_type_ir::lang_items::TraitSolverLangItem,
-    ) -> bool {
-        use rustc_type_ir::lang_items::TraitSolverLangItem::*;
-
-        // FIXME: derive PartialEq on TraitSolverLangItem
-        self.as_lang_item(def_id).map_or(false, |l| match (l, lang_item) {
-            (AsyncFn, AsyncFn) => true,
-            (AsyncFnKindHelper, AsyncFnKindHelper) => true,
-            (AsyncFnKindUpvars, AsyncFnKindUpvars) => true,
-            (AsyncFnMut, AsyncFnMut) => true,
-            (AsyncFnOnce, AsyncFnOnce) => true,
-            (AsyncFnOnceOutput, AsyncFnOnceOutput) => true,
-            (AsyncIterator, AsyncIterator) => true,
-            (CallOnceFuture, CallOnceFuture) => true,
-            (CallRefFuture, CallRefFuture) => true,
-            (Clone, Clone) => true,
-            (Copy, Copy) => true,
-            (Coroutine, Coroutine) => true,
-            (CoroutineReturn, CoroutineReturn) => true,
-            (CoroutineYield, CoroutineYield) => true,
-            (Destruct, Destruct) => true,
-            (DiscriminantKind, DiscriminantKind) => true,
-            (Drop, Drop) => true,
-            (DynMetadata, DynMetadata) => true,
-            (Fn, Fn) => true,
-            (FnMut, FnMut) => true,
-            (FnOnce, FnOnce) => true,
-            (FnPtrTrait, FnPtrTrait) => true,
-            (FusedIterator, FusedIterator) => true,
-            (Future, Future) => true,
-            (FutureOutput, FutureOutput) => true,
-            (Iterator, Iterator) => true,
-            (Metadata, Metadata) => true,
-            (Option, Option) => true,
-            (PointeeTrait, PointeeTrait) => true,
-            (Poll, Poll) => true,
-            (Sized, Sized) => true,
-            (TransmuteTrait, TransmuteTrait) => true,
-            (Tuple, Tuple) => true,
-            (Unpin, Unpin) => true,
-            (Unsize, Unsize) => true,
-            _ => false,
-        })
+    fn is_lang_item(self, def_id: Self::DefId, lang_item: SolverLangItem) -> bool {
+        use SolverLangItem::*;
+
+        // FIXME: derive PartialEq on SolverLangItem
+        self.as_lang_item(def_id)
+            .map_or(false, |l| std::mem::discriminant(&l) == std::mem::discriminant(&lang_item))
     }
 
-    fn as_lang_item(
-        self,
-        def_id: Self::DefId,
-    ) -> Option<rustc_type_ir::lang_items::TraitSolverLangItem> {
-        use rustc_type_ir::lang_items::TraitSolverLangItem;
+    #[allow(clippy::match_like_matches_macro)]
+    fn is_trait_lang_item(self, def_id: Self::TraitId, lang_item: SolverTraitLangItem) -> bool {
+        use SolverTraitLangItem::*;
+
+        // FIXME: derive PartialEq on SolverTraitLangItem
+        self.as_trait_lang_item(def_id)
+            .map_or(false, |l| std::mem::discriminant(&l) == std::mem::discriminant(&lang_item))
+    }
 
+    fn as_lang_item(self, def_id: Self::DefId) -> Option<SolverLangItem> {
         let def_id: AttrDefId = match def_id {
             SolverDefId::TraitId(id) => id.into(),
             SolverDefId::TypeAliasId(id) => id.into(),
+            SolverDefId::AdtId(id) => id.into(),
             _ => panic!("Unexpected SolverDefId in as_lang_item"),
         };
         let lang_item = self.db().lang_attr(def_id)?;
-        Some(match lang_item {
-            LangItem::Sized => TraitSolverLangItem::Sized,
-            LangItem::MetaSized => TraitSolverLangItem::MetaSized,
-            LangItem::PointeeSized => TraitSolverLangItem::PointeeSized,
-            LangItem::Unsize => TraitSolverLangItem::Unsize,
-            LangItem::StructuralPeq => return None,
-            LangItem::StructuralTeq => return None,
-            LangItem::Copy => TraitSolverLangItem::Copy,
-            LangItem::Clone => TraitSolverLangItem::Clone,
-            LangItem::Sync => return None,
-            LangItem::DiscriminantKind => TraitSolverLangItem::DiscriminantKind,
-            LangItem::Discriminant => return None,
-            LangItem::PointeeTrait => TraitSolverLangItem::PointeeTrait,
-            LangItem::Metadata => TraitSolverLangItem::Metadata,
-            LangItem::DynMetadata => TraitSolverLangItem::DynMetadata,
-            LangItem::Freeze => return None,
-            LangItem::FnPtrTrait => TraitSolverLangItem::FnPtrTrait,
-            LangItem::FnPtrAddr => return None,
-            LangItem::Drop => TraitSolverLangItem::Drop,
-            LangItem::Destruct => TraitSolverLangItem::Destruct,
-            LangItem::CoerceUnsized => return None,
-            LangItem::DispatchFromDyn => return None,
-            LangItem::TransmuteOpts => return None,
-            LangItem::TransmuteTrait => TraitSolverLangItem::TransmuteTrait,
-            LangItem::Add => return None,
-            LangItem::Sub => return None,
-            LangItem::Mul => return None,
-            LangItem::Div => return None,
-            LangItem::Rem => return None,
-            LangItem::Neg => return None,
-            LangItem::Not => return None,
-            LangItem::BitXor => return None,
-            LangItem::BitAnd => return None,
-            LangItem::BitOr => return None,
-            LangItem::Shl => return None,
-            LangItem::Shr => return None,
-            LangItem::AddAssign => return None,
-            LangItem::SubAssign => return None,
-            LangItem::MulAssign => return None,
-            LangItem::DivAssign => return None,
-            LangItem::RemAssign => return None,
-            LangItem::BitXorAssign => return None,
-            LangItem::BitAndAssign => return None,
-            LangItem::BitOrAssign => return None,
-            LangItem::ShlAssign => return None,
-            LangItem::ShrAssign => return None,
-            LangItem::Index => return None,
-            LangItem::IndexMut => return None,
-            LangItem::UnsafeCell => return None,
-            LangItem::VaList => return None,
-            LangItem::Deref => return None,
-            LangItem::DerefMut => return None,
-            LangItem::DerefTarget => return None,
-            LangItem::Receiver => return None,
-            LangItem::Fn => TraitSolverLangItem::Fn,
-            LangItem::FnMut => TraitSolverLangItem::FnMut,
-            LangItem::FnOnce => TraitSolverLangItem::FnOnce,
-            LangItem::FnOnceOutput => return None,
-            LangItem::Future => TraitSolverLangItem::Future,
-            LangItem::CoroutineState => return None,
-            LangItem::Coroutine => TraitSolverLangItem::Coroutine,
-            LangItem::CoroutineReturn => TraitSolverLangItem::CoroutineReturn,
-            LangItem::CoroutineYield => TraitSolverLangItem::CoroutineYield,
-            LangItem::Unpin => TraitSolverLangItem::Unpin,
-            LangItem::Pin => return None,
-            LangItem::PartialEq => return None,
-            LangItem::PartialOrd => return None,
-            LangItem::CVoid => return None,
-            LangItem::Panic => return None,
-            LangItem::PanicNounwind => return None,
-            LangItem::PanicFmt => return None,
-            LangItem::PanicDisplay => return None,
-            LangItem::ConstPanicFmt => return None,
-            LangItem::PanicBoundsCheck => return None,
-            LangItem::PanicMisalignedPointerDereference => return None,
-            LangItem::PanicInfo => return None,
-            LangItem::PanicLocation => return None,
-            LangItem::PanicImpl => return None,
-            LangItem::PanicCannotUnwind => return None,
-            LangItem::BeginPanic => return None,
-            LangItem::FormatAlignment => return None,
-            LangItem::FormatArgument => return None,
-            LangItem::FormatArguments => return None,
-            LangItem::FormatCount => return None,
-            LangItem::FormatPlaceholder => return None,
-            LangItem::FormatUnsafeArg => return None,
-            LangItem::ExchangeMalloc => return None,
-            LangItem::BoxFree => return None,
-            LangItem::DropInPlace => return None,
-            LangItem::AllocLayout => return None,
-            LangItem::Start => return None,
-            LangItem::EhPersonality => return None,
-            LangItem::EhCatchTypeinfo => return None,
-            LangItem::OwnedBox => return None,
-            LangItem::PhantomData => return None,
-            LangItem::ManuallyDrop => return None,
-            LangItem::MaybeUninit => return None,
-            LangItem::AlignOffset => return None,
-            LangItem::Termination => return None,
-            LangItem::Try => return None,
-            LangItem::Tuple => TraitSolverLangItem::Tuple,
-            LangItem::SliceLen => return None,
-            LangItem::TryTraitFromResidual => return None,
-            LangItem::TryTraitFromOutput => return None,
-            LangItem::TryTraitBranch => return None,
-            LangItem::TryTraitFromYeet => return None,
-            LangItem::PointerLike => return None,
-            LangItem::ConstParamTy => return None,
-            LangItem::Poll => TraitSolverLangItem::Poll,
-            LangItem::PollReady => return None,
-            LangItem::PollPending => return None,
-            LangItem::ResumeTy => return None,
-            LangItem::GetContext => return None,
-            LangItem::Context => return None,
-            LangItem::FuturePoll => return None,
-            LangItem::FutureOutput => TraitSolverLangItem::FutureOutput,
-            LangItem::Option => TraitSolverLangItem::Option,
-            LangItem::OptionSome => return None,
-            LangItem::OptionNone => return None,
-            LangItem::ResultOk => return None,
-            LangItem::ResultErr => return None,
-            LangItem::ControlFlowContinue => return None,
-            LangItem::ControlFlowBreak => return None,
-            LangItem::IntoFutureIntoFuture => return None,
-            LangItem::IntoIterIntoIter => return None,
-            LangItem::IteratorNext => return None,
-            LangItem::Iterator => TraitSolverLangItem::Iterator,
-            LangItem::PinNewUnchecked => return None,
-            LangItem::RangeFrom => return None,
-            LangItem::RangeFull => return None,
-            LangItem::RangeInclusiveStruct => return None,
-            LangItem::RangeInclusiveNew => return None,
-            LangItem::Range => return None,
-            LangItem::RangeToInclusive => return None,
-            LangItem::RangeTo => return None,
-            LangItem::String => return None,
-            LangItem::CStr => return None,
-            LangItem::AsyncFn => TraitSolverLangItem::AsyncFn,
-            LangItem::AsyncFnMut => TraitSolverLangItem::AsyncFnMut,
-            LangItem::AsyncFnOnce => TraitSolverLangItem::AsyncFnOnce,
-            LangItem::AsyncFnOnceOutput => TraitSolverLangItem::AsyncFnOnceOutput,
-            LangItem::CallRefFuture => TraitSolverLangItem::CallRefFuture,
-            LangItem::CallOnceFuture => TraitSolverLangItem::CallOnceFuture,
-            LangItem::Ordering => return None,
-            LangItem::PanicNullPointerDereference => return None,
-            LangItem::ReceiverTarget => return None,
-            LangItem::UnsafePinned => return None,
-            LangItem::AsyncFnOnceOutput => TraitSolverLangItem::AsyncFnOnceOutput,
-        })
+        as_lang_item!(
+            SolverLangItem, lang_item;
+
+            ignore = {
+                AsyncFnKindUpvars,
+            }
+
+            Metadata,
+            DynMetadata,
+            CoroutineReturn,
+            CoroutineYield,
+            Poll,
+            FutureOutput,
+            Option,
+            AsyncFnOnceOutput,
+            CallRefFuture,
+            CallOnceFuture,
+            AsyncFnOnceOutput,
+        )
+    }
+
+    fn as_trait_lang_item(self, def_id: Self::TraitId) -> Option<SolverTraitLangItem> {
+        let def_id: AttrDefId = def_id.0.into();
+        let lang_item = self.db().lang_attr(def_id)?;
+        as_lang_item!(
+            SolverTraitLangItem, lang_item;
+
+            ignore = {
+                AsyncFnKindHelper,
+                AsyncIterator,
+                BikeshedGuaranteedNoDrop,
+                FusedIterator,
+            }
+
+            Sized,
+            MetaSized,
+            PointeeSized,
+            Unsize,
+            Copy,
+            Clone,
+            DiscriminantKind,
+            PointeeTrait,
+            FnPtrTrait,
+            Drop,
+            Destruct,
+            TransmuteTrait,
+            Fn,
+            FnMut,
+            FnOnce,
+            Future,
+            Coroutine,
+            Unpin,
+            Tuple,
+            Iterator,
+            AsyncFn,
+            AsyncFnMut,
+            AsyncFnOnce,
+            AsyncFnOnceOutput,
+            AsyncFnOnceOutput,
+        )
     }
 
     fn associated_type_def_ids(self, def_id: Self::DefId) -> impl IntoIterator<Item = Self::DefId> {
@@ -1670,15 +1566,11 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
 
     fn for_each_relevant_impl(
         self,
-        trait_def_id: Self::DefId,
+        trait_: Self::TraitId,
         self_ty: Self::Ty,
         mut f: impl FnMut(Self::DefId),
     ) {
-        let trait_ = match trait_def_id {
-            SolverDefId::TraitId(id) => id,
-            _ => panic!("for_each_relevant_impl called for non-trait"),
-        };
-
+        let trait_ = trait_.0;
         let self_ty_fp = TyFingerprint::for_trait_impl_ns(&self_ty);
         let fps: &[TyFingerprint] = match self_ty.kind() {
             TyKind::Infer(InferTy::IntVar(..)) => &ALL_INT_FPS,
@@ -1775,42 +1667,26 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
         }
     }
 
-    fn trait_is_auto(self, trait_def_id: Self::DefId) -> bool {
-        let trait_ = match trait_def_id {
-            SolverDefId::TraitId(id) => id,
-            _ => panic!("Unexpected SolverDefId in trait_is_auto"),
-        };
-        let trait_data = self.db().trait_signature(trait_);
+    fn trait_is_auto(self, trait_: Self::TraitId) -> bool {
+        let trait_data = self.db().trait_signature(trait_.0);
         trait_data.flags.contains(TraitFlags::AUTO)
     }
 
-    fn trait_is_alias(self, trait_def_id: Self::DefId) -> bool {
-        let trait_ = match trait_def_id {
-            SolverDefId::TraitId(id) => id,
-            _ => panic!("Unexpected SolverDefId in trait_is_alias"),
-        };
-        let trait_data = self.db().trait_signature(trait_);
+    fn trait_is_alias(self, trait_: Self::TraitId) -> bool {
+        let trait_data = self.db().trait_signature(trait_.0);
         trait_data.flags.contains(TraitFlags::ALIAS)
     }
 
-    fn trait_is_dyn_compatible(self, trait_def_id: Self::DefId) -> bool {
-        let trait_ = match trait_def_id {
-            SolverDefId::TraitId(id) => id,
-            _ => unreachable!(),
-        };
-        crate::dyn_compatibility::dyn_compatibility(self.db(), trait_).is_none()
+    fn trait_is_dyn_compatible(self, trait_: Self::TraitId) -> bool {
+        crate::dyn_compatibility::dyn_compatibility(self.db(), trait_.0).is_none()
     }
 
-    fn trait_is_fundamental(self, def_id: Self::DefId) -> bool {
-        let trait_ = match def_id {
-            SolverDefId::TraitId(id) => id,
-            _ => panic!("Unexpected SolverDefId in trait_is_fundamental"),
-        };
-        let trait_data = self.db().trait_signature(trait_);
+    fn trait_is_fundamental(self, trait_: Self::TraitId) -> bool {
+        let trait_data = self.db().trait_signature(trait_.0);
         trait_data.flags.contains(TraitFlags::FUNDAMENTAL)
     }
 
-    fn trait_may_be_implemented_via_object(self, trait_def_id: Self::DefId) -> bool {
+    fn trait_may_be_implemented_via_object(self, trait_def_id: Self::TraitId) -> bool {
         // FIXME(next-solver): should check the `TraitFlags` for
         // the `#[rustc_do_not_implement_via_object]` flag
         true
@@ -1920,12 +1796,12 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
                     (*entry.or_insert_with(|| BoundVarKind::Ty(BoundTyKind::Anon))).expect_ty();
                 Ty::new_bound(self.interner, DebruijnIndex::ZERO, BoundTy { var, kind })
             }
-            fn replace_const(&mut self, bv: BoundVar) -> Const<'db> {
-                let entry = self.map.entry(bv);
+            fn replace_const(&mut self, bv: BoundConst) -> Const<'db> {
+                let entry = self.map.entry(bv.var);
                 let index = entry.index();
                 let var = BoundVar::from_usize(index);
                 let () = (*entry.or_insert_with(|| BoundVarKind::Const)).expect_const();
-                Const::new_bound(self.interner, DebruijnIndex::ZERO, var)
+                Const::new_bound(self.interner, DebruijnIndex::ZERO, BoundConst { var })
             }
         }
 
@@ -2008,24 +1884,16 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
         unimplemented!()
     }
 
-    fn is_default_trait(self, def_id: Self::DefId) -> bool {
-        self.as_lang_item(def_id).map_or(false, |l| matches!(l, TraitSolverLangItem::Sized))
+    fn is_default_trait(self, def_id: Self::TraitId) -> bool {
+        self.as_trait_lang_item(def_id).map_or(false, |l| matches!(l, SolverTraitLangItem::Sized))
     }
 
-    fn trait_is_coinductive(self, trait_def_id: Self::DefId) -> bool {
-        let id = match trait_def_id {
-            SolverDefId::TraitId(id) => id,
-            _ => unreachable!(),
-        };
-        self.db().trait_signature(id).flags.contains(TraitFlags::COINDUCTIVE)
+    fn trait_is_coinductive(self, trait_: Self::TraitId) -> bool {
+        self.db().trait_signature(trait_.0).flags.contains(TraitFlags::COINDUCTIVE)
     }
 
-    fn trait_is_unsafe(self, trait_def_id: Self::DefId) -> bool {
-        let id = match trait_def_id {
-            SolverDefId::TraitId(id) => id,
-            _ => unreachable!(),
-        };
-        self.db().trait_signature(id).flags.contains(TraitFlags::UNSAFE)
+    fn trait_is_unsafe(self, trait_: Self::TraitId) -> bool {
+        self.db().trait_signature(trait_.0).flags.contains(TraitFlags::UNSAFE)
     }
 
     fn impl_self_is_guaranteed_unsized(self, def_id: Self::DefId) -> bool {
@@ -2047,6 +1915,20 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
         // FIXME(next-solver)
         unimplemented!()
     }
+
+    type Probe = rustc_type_ir::solve::inspect::Probe<DbInterner<'db>>;
+    fn mk_probe(self, probe: rustc_type_ir::solve::inspect::Probe<Self>) -> Self::Probe {
+        probe
+    }
+    fn evaluate_root_goal_for_proof_tree_raw(
+        self,
+        canonical_goal: rustc_type_ir::solve::CanonicalInput<Self>,
+    ) -> (rustc_type_ir::solve::QueryResult<Self>, Self::Probe) {
+        rustc_next_trait_solver::solve::evaluate_root_goal_for_proof_tree_raw_provider::<
+            SolverContext<'db>,
+            Self,
+        >(self, canonical_goal)
+    }
 }
 
 impl<'db> DbInterner<'db> {
@@ -2072,7 +1954,9 @@ impl<'db> DbInterner<'db> {
                         BoundTy { var: shift_bv(t.var), kind: t.kind },
                     )
                 },
-                consts: &mut |c| Const::new_bound(self, DebruijnIndex::ZERO, shift_bv(c)),
+                consts: &mut |c| {
+                    Const::new_bound(self, DebruijnIndex::ZERO, BoundConst { var: shift_bv(c.var) })
+                },
             },
         )
     }
@@ -2135,6 +2019,7 @@ macro_rules! TrivialTypeTraversalImpls {
 
 TrivialTypeTraversalImpls! {
     SolverDefId,
+    TraitIdWrapper,
     Pattern<'db>,
     Safety,
     FnAbi,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ir_print.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ir_print.rs
index 4d32b27132357..407e157564397 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ir_print.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ir_print.rs
@@ -58,10 +58,7 @@ impl<'db> IrPrint<ty::TraitRef<Self>> for DbInterner<'db> {
 
     fn print_debug(t: &ty::TraitRef<Self>, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         salsa::with_attached_database(|db| {
-            let trait_ = match t.def_id {
-                SolverDefId::TraitId(id) => id,
-                _ => panic!("Expected trait."),
-            };
+            let trait_ = t.def_id.0;
             let self_ty = &t.args.as_slice()[0];
             let trait_args = &t.args.as_slice()[1..];
             if trait_args.is_empty() {
@@ -122,10 +119,7 @@ impl<'db> IrPrint<ty::ExistentialTraitRef<Self>> for DbInterner<'db> {
         fmt: &mut std::fmt::Formatter<'_>,
     ) -> std::fmt::Result {
         salsa::with_attached_database(|db| {
-            let trait_ = match t.def_id {
-                SolverDefId::TraitId(id) => id,
-                _ => panic!("Expected trait."),
-            };
+            let trait_ = t.def_id.0;
             fmt.write_str(&format!(
                 "ExistentialTraitRef({:?}[{:?}])",
                 db.as_view::<dyn HirDatabase>().trait_signature(trait_).name.as_str(),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
index 6755d065e10d3..dc54ee7d58785 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
@@ -22,6 +22,7 @@ use rustc_type_ir::{
 use salsa::plumbing::FromId;
 use salsa::{Id, plumbing::AsId};
 
+use crate::next_solver::BoundConst;
 use crate::{
     ConcreteConst, ConstScalar, ImplTraitId, Interner, MemoryMap,
     db::{
@@ -125,12 +126,12 @@ impl<'db> rustc_type_ir::TypeFolder<DbInterner<'db>> for BinderToEarlyBinder<'db
     fn fold_const(&mut self, c: Const<'db>) -> Const<'db> {
         match c.kind() {
             rustc_type_ir::ConstKind::Bound(debruijn, var) if self.debruijn == debruijn => {
-                let GenericParamId::ConstParamId(id) = self.params[var.as_usize()] else {
+                let GenericParamId::ConstParamId(id) = self.params[var.var.as_usize()] else {
                     unreachable!()
                 };
                 Const::new(
                     self.cx(),
-                    rustc_type_ir::ConstKind::Param(ParamConst { index: var.as_u32(), id }),
+                    rustc_type_ir::ConstKind::Param(ParamConst { index: var.var.as_u32(), id }),
                 )
             }
             _ => c.super_fold_with(self),
@@ -286,11 +287,8 @@ impl<'db> ChalkToNextSolver<'db, Ty<'db>> for chalk_ir::Ty<Interner> {
                                         .flags
                                         .contains(TraitFlags::AUTO)
                                     {
-                                        ExistentialPredicate::AutoTrait(SolverDefId::TraitId(
-                                            trait_id,
-                                        ))
+                                        ExistentialPredicate::AutoTrait(trait_id.into())
                                     } else {
-                                        let def_id = SolverDefId::TraitId(trait_id);
                                         let args = GenericArgs::new_from_iter(
                                             interner,
                                             trait_ref
@@ -301,7 +299,7 @@ impl<'db> ChalkToNextSolver<'db, Ty<'db>> for chalk_ir::Ty<Interner> {
                                                 .map(|a| a.to_nextsolver(interner)),
                                         );
                                         let trait_ref = ExistentialTraitRef::new_from_args(
-                                            interner, def_id, args,
+                                            interner, trait_id.into(), args,
                                         );
                                         ExistentialPredicate::Trait(trait_ref)
                                     }
@@ -473,7 +471,7 @@ impl<'db> ChalkToNextSolver<'db, Const<'db>> for chalk_ir::Const<Interner> {
             match &data.value {
                 chalk_ir::ConstValue::BoundVar(bound_var) => rustc_type_ir::ConstKind::Bound(
                     bound_var.debruijn.to_nextsolver(interner),
-                    rustc_type_ir::BoundVar::from_usize(bound_var.index),
+                    BoundConst { var: rustc_type_ir::BoundVar::from_usize(bound_var.index) },
                 ),
                 chalk_ir::ConstValue::InferenceVar(inference_var) => {
                     rustc_type_ir::ConstKind::Infer(rustc_type_ir::InferConst::Var(
@@ -871,11 +869,7 @@ impl<'db> ChalkToNextSolver<'db, PredicateKind<'db>> for chalk_ir::DomainGoal<In
 impl<'db> ChalkToNextSolver<'db, TraitRef<'db>> for chalk_ir::TraitRef<Interner> {
     fn to_nextsolver(&self, interner: DbInterner<'db>) -> TraitRef<'db> {
         let args = self.substitution.to_nextsolver(interner);
-        TraitRef::new_from_args(
-            interner,
-            SolverDefId::TraitId(from_chalk_trait_id(self.trait_id)),
-            args,
-        )
+        TraitRef::new_from_args(interner, from_chalk_trait_id(self.trait_id).into(), args)
     }
 }
 
@@ -1207,20 +1201,14 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
                                 trait_ref.def_id,
                                 [self_ty.into()].into_iter().chain(trait_ref.args.iter()),
                             );
-                            let trait_id = match trait_ref.def_id {
-                                SolverDefId::TraitId(id) => to_chalk_trait_id(id),
-                                _ => unreachable!(),
-                            };
+                            let trait_id = to_chalk_trait_id(trait_ref.def_id.0);
                             let substitution =
                                 convert_args_for_result(interner, trait_ref.args.as_slice());
                             let trait_ref = chalk_ir::TraitRef { trait_id, substitution };
                             chalk_ir::WhereClause::Implemented(trait_ref)
                         }
                         rustc_type_ir::ExistentialPredicate::AutoTrait(trait_) => {
-                            let trait_id = match trait_ {
-                                SolverDefId::TraitId(id) => to_chalk_trait_id(id),
-                                _ => unreachable!(),
-                            };
+                            let trait_id = to_chalk_trait_id(trait_.0);
                             let substitution = chalk_ir::Substitution::from1(
                                 Interner,
                                 convert_ty_for_result(interner, self_ty),
@@ -1354,7 +1342,7 @@ pub fn convert_const_for_result<'db>(
         rustc_type_ir::ConstKind::Bound(debruijn_index, var) => {
             chalk_ir::ConstValue::BoundVar(chalk_ir::BoundVar::new(
                 chalk_ir::DebruijnIndex::new(debruijn_index.as_u32()),
-                var.index(),
+                var.var.index(),
             ))
         }
         rustc_type_ir::ConstKind::Placeholder(placeholder_const) => {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/predicate.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/predicate.rs
index 50261bb5e3816..c86d3a4aadb22 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/predicate.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/predicate.rs
@@ -15,6 +15,8 @@ use rustc_type_ir::{
 };
 use smallvec::{SmallVec, smallvec};
 
+use crate::next_solver::TraitIdWrapper;
+
 use super::{Binder, BoundVarKinds, DbInterner, Region, Ty, interned_vec_db};
 
 pub type BoundExistentialPredicate<'db> = Binder<'db, ExistentialPredicate<'db>>;
@@ -72,7 +74,7 @@ interned_vec_db!(BoundExistentialPredicates, BoundExistentialPredicate);
 impl<'db> rustc_type_ir::inherent::BoundExistentialPredicates<DbInterner<'db>>
     for BoundExistentialPredicates<'db>
 {
-    fn principal_def_id(self) -> Option<<DbInterner<'db> as rustc_type_ir::Interner>::DefId> {
+    fn principal_def_id(self) -> Option<TraitIdWrapper> {
         self.principal().map(|trait_ref| trait_ref.skip_binder().def_id)
     }
 
@@ -89,9 +91,7 @@ impl<'db> rustc_type_ir::inherent::BoundExistentialPredicates<DbInterner<'db>>
             .transpose()
     }
 
-    fn auto_traits(
-        self,
-    ) -> impl IntoIterator<Item = <DbInterner<'db> as rustc_type_ir::Interner>::DefId> {
+    fn auto_traits(self) -> impl IntoIterator<Item = TraitIdWrapper> {
         self.iter().filter_map(|predicate| match predicate.skip_binder() {
             ExistentialPredicate::AutoTrait(did) => Some(did),
             _ => None,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
index 45888ac4d2352..1d0ee0e488dcf 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
@@ -2,10 +2,10 @@
 
 use hir_def::{AssocItemId, GeneralConstId, TypeAliasId};
 use rustc_next_trait_solver::delegate::SolverDelegate;
+use rustc_type_ir::lang_items::SolverTraitLangItem;
 use rustc_type_ir::{
     InferCtxtLike, Interner, PredicatePolarity, TypeFlags, TypeVisitableExt, UniverseIndex,
     inherent::{IntoKind, SliceLike, Span as _, Term as _, Ty as _},
-    lang_items::TraitSolverLangItem,
     solve::{Certainty, NoSolution},
 };
 
@@ -225,14 +225,14 @@ impl<'db> SolverDelegate for SolverContext<'db> {
             }
 
             if trait_pred.polarity() == PredicatePolarity::Positive {
-                match self.0.cx().as_lang_item(trait_pred.def_id()) {
-                    Some(TraitSolverLangItem::Sized) | Some(TraitSolverLangItem::MetaSized) => {
+                match self.0.cx().as_trait_lang_item(trait_pred.def_id()) {
+                    Some(SolverTraitLangItem::Sized) | Some(SolverTraitLangItem::MetaSized) => {
                         let predicate = self.resolve_vars_if_possible(goal.predicate);
                         if sizedness_fast_path(self.cx(), predicate, goal.param_env) {
                             return Some(Certainty::Yes);
                         }
                     }
-                    Some(TraitSolverLangItem::Copy | TraitSolverLangItem::Clone) => {
+                    Some(SolverTraitLangItem::Copy | SolverTraitLangItem::Clone) => {
                         let self_ty =
                             self.resolve_vars_if_possible(trait_pred.self_ty().skip_binder());
                         // Unlike `Sized` traits, which always prefer the built-in impl,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
index 92f1076e75eca..4794e2d604509 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
@@ -4,6 +4,7 @@ use hir_def::{GenericDefId, TypeOrConstParamId, TypeParamId};
 use intern::{Interned, Symbol, sym};
 use rustc_abi::{Float, Integer, Size};
 use rustc_ast_ir::{Mutability, try_visit, visit::VisitorResult};
+use rustc_type_ir::Interner;
 use rustc_type_ir::{
     BoundVar, ClosureKind, FlagComputation, Flags, FloatTy, FloatVid, InferTy, IntTy, IntVid,
     TypeFoldable, TypeSuperFoldable, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, UintTy,
@@ -19,6 +20,7 @@ use rustc_type_ir::{
 use salsa::plumbing::{AsId, FromId};
 use smallvec::SmallVec;
 
+use crate::next_solver::GenericArg;
 use crate::{
     db::HirDatabase,
     interner::InternedWrapperNoDebug,
@@ -645,6 +647,31 @@ impl<'db> rustc_type_ir::inherent::Ty<DbInterner<'db>> for Ty<'db> {
         Ty::new(interner, TyKind::CoroutineWitness(def_id, args))
     }
 
+    fn new_coroutine_witness_for_coroutine(
+        interner: DbInterner<'db>,
+        def_id: <DbInterner<'db> as rustc_type_ir::Interner>::DefId,
+        coroutine_args: <DbInterner<'db> as rustc_type_ir::Interner>::GenericArgs,
+    ) -> Self {
+        // HACK: Coroutine witness types are lifetime erased, so they
+        // never reference any lifetime args from the coroutine. We erase
+        // the regions here since we may get into situations where a
+        // coroutine is recursively contained within itself, leading to
+        // witness types that differ by region args. This means that
+        // cycle detection in fulfillment will not kick in, which leads
+        // to unnecessary overflows in async code. See the issue:
+        // <https://github.com/rust-lang/rust/issues/145151>.
+        let coroutine_args = interner.mk_args_from_iter(coroutine_args.iter().map(|arg| {
+            match arg {
+                GenericArg::Ty(_) | GenericArg::Const(_) => arg,
+                GenericArg::Lifetime(_) => {
+                    crate::next_solver::Region::new(interner, rustc_type_ir::RegionKind::ReErased)
+                        .into()
+                }
+            }
+        }));
+        Ty::new_coroutine_witness(interner, def_id, coroutine_args)
+    }
+
     fn new_ptr(interner: DbInterner<'db>, ty: Self, mutbl: rustc_ast_ir::Mutability) -> Self {
         Ty::new(interner, TyKind::RawPtr(ty, mutbl))
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/util.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/util.rs
index 1db02e9eb611c..50b96a160ed10 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/util.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/util.rs
@@ -14,7 +14,7 @@ use rustc_type_ir::inherent::{
     AdtDef, Const as _, GenericArg as _, GenericArgs as _, ParamEnv as _, Region as _, SliceLike,
     Ty as _,
 };
-use rustc_type_ir::lang_items::TraitSolverLangItem;
+use rustc_type_ir::lang_items::SolverTraitLangItem;
 use rustc_type_ir::solve::SizedTraitKind;
 use rustc_type_ir::{
     BoundVar, Canonical, DebruijnIndex, GenericArgKind, INNERMOST, Interner, PredicatePolarity,
@@ -29,8 +29,8 @@ use rustc_type_ir::{InferCtxtLike, TypeFoldable};
 use crate::lower_nextsolver::{LifetimeElisionKind, TyLoweringContext};
 use crate::next_solver::infer::InferCtxt;
 use crate::next_solver::{
-    CanonicalVarKind, FxIndexMap, ParamEnv, Placeholder, PlaceholderConst, PlaceholderRegion,
-    TypingMode,
+    BoundConst, CanonicalVarKind, FxIndexMap, ParamEnv, Placeholder, PlaceholderConst,
+    PlaceholderRegion, TypingMode,
 };
 use crate::{
     db::HirDatabase,
@@ -511,7 +511,7 @@ pub fn apply_args_to_binder<'db, T: TypeFoldable<DbInterner<'db>>>(
 ) -> T {
     let types = &mut |ty: BoundTy| args.as_slice()[ty.var.index()].expect_ty();
     let regions = &mut |region: BoundRegion| args.as_slice()[region.var.index()].expect_region();
-    let consts = &mut |const_: BoundVar| args.as_slice()[const_.index()].expect_const();
+    let consts = &mut |const_: BoundConst| args.as_slice()[const_.var.index()].expect_const();
     let mut instantiate = BoundVarReplacer::new(interner, FnMutDelegate { types, regions, consts });
     b.skip_binder().fold_with(&mut instantiate)
 }
@@ -654,7 +654,10 @@ impl<'db> TypeFolder<DbInterner<'db>> for MiniCanonicalizer<'_, 'db> {
             ConstKind::Infer(infer) => {
                 let len = self.vars.len();
                 let var = *self.vars.entry(c.into()).or_insert(len);
-                Const::new(self.cx(), ConstKind::Bound(self.db, BoundVar::from_usize(var)))
+                Const::new(
+                    self.cx(),
+                    ConstKind::Bound(self.db, BoundConst { var: BoundVar::from_usize(var) }),
+                )
             }
             _ => c.super_fold_with(self),
         }
@@ -852,7 +855,7 @@ pub struct PlaceholderReplacer<'a, 'db> {
     infcx: &'a InferCtxt<'db>,
     mapped_regions: FxIndexMap<PlaceholderRegion, BoundRegion>,
     mapped_types: FxIndexMap<Placeholder<BoundTy>, BoundTy>,
-    mapped_consts: FxIndexMap<PlaceholderConst, BoundVar>,
+    mapped_consts: FxIndexMap<PlaceholderConst, BoundConst>,
     universe_indices: &'a [Option<UniverseIndex>],
     current_index: DebruijnIndex,
 }
@@ -862,7 +865,7 @@ impl<'a, 'db> PlaceholderReplacer<'a, 'db> {
         infcx: &'a InferCtxt<'db>,
         mapped_regions: FxIndexMap<PlaceholderRegion, BoundRegion>,
         mapped_types: FxIndexMap<Placeholder<BoundTy>, BoundTy>,
-        mapped_consts: FxIndexMap<PlaceholderConst, BoundVar>,
+        mapped_consts: FxIndexMap<PlaceholderConst, BoundConst>,
         universe_indices: &'a [Option<UniverseIndex>],
         value: T,
     ) -> T {
@@ -1026,9 +1029,9 @@ pub fn sizedness_fast_path<'db>(
     if let PredicateKind::Clause(ClauseKind::Trait(trait_pred)) = predicate.kind().skip_binder()
         && trait_pred.polarity == PredicatePolarity::Positive
     {
-        let sizedness = match tcx.as_lang_item(trait_pred.def_id()) {
-            Some(TraitSolverLangItem::Sized) => SizedTraitKind::Sized,
-            Some(TraitSolverLangItem::MetaSized) => SizedTraitKind::MetaSized,
+        let sizedness = match tcx.as_trait_lang_item(trait_pred.def_id()) {
+            Some(SolverTraitLangItem::Sized) => SizedTraitKind::Sized,
+            Some(SolverTraitLangItem::MetaSized) => SizedTraitKind::MetaSized,
             _ => return false,
         };
 
@@ -1051,7 +1054,10 @@ pub fn sizedness_fast_path<'db>(
                     && clause_pred.self_ty() == trait_pred.self_ty()
                     && (clause_pred.def_id() == trait_pred.def_id()
                         || (sizedness == SizedTraitKind::MetaSized
-                            && tcx.is_lang_item(clause_pred.def_id(), TraitSolverLangItem::Sized)))
+                            && tcx.is_trait_lang_item(
+                                clause_pred.def_id(),
+                                SolverTraitLangItem::Sized,
+                            )))
                 {
                     return true;
                 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/utils.rs b/src/tools/rust-analyzer/crates/hir-ty/src/utils.rs
index 092d4e3a8d9e9..881b1c1a9db26 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/utils.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/utils.rs
@@ -212,10 +212,7 @@ fn direct_super_trait_refs(db: &dyn HirDatabase, trait_ref: &TraitRef, cb: impl
                 rustc_type_ir::ClauseKind::Trait(t) => {
                     let t =
                         rustc_type_ir::EarlyBinder::bind(t).instantiate(interner, trait_ref_args);
-                    let trait_id = match t.def_id() {
-                        crate::next_solver::SolverDefId::TraitId(id) => to_chalk_trait_id(id),
-                        _ => unreachable!(),
-                    };
+                    let trait_id = to_chalk_trait_id(t.def_id().0);
 
                     let substitution =
                         convert_args_for_result(interner, t.trait_ref.args.as_slice());
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index 46d3a2bcd67ce..6610375451dd0 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -86,8 +86,7 @@ use hir_ty::{
     method_resolution,
     mir::{MutBorrowKind, interpret_mir},
     next_solver::{
-        ClauseKind, DbInterner, GenericArgs, SolverDefId, infer::InferCtxt,
-        mapping::ChalkToNextSolver,
+        ClauseKind, DbInterner, GenericArgs, infer::InferCtxt, mapping::ChalkToNextSolver,
     },
     primitive::UintTy,
     traits::FnTrait,
@@ -4251,13 +4250,7 @@ impl TypeParam {
         db.generic_predicates_for_param_ns(self.id.parent(), self.id.into(), None)
             .iter()
             .filter_map(|pred| match &pred.kind().skip_binder() {
-                ClauseKind::Trait(trait_ref) => {
-                    let trait_ = match trait_ref.def_id() {
-                        SolverDefId::TraitId(t) => t,
-                        _ => unreachable!(),
-                    };
-                    Some(Trait::from(trait_))
-                }
+                ClauseKind::Trait(trait_ref) => Some(Trait::from(trait_ref.def_id().0)),
                 _ => None,
             })
             .collect()
@@ -4515,11 +4508,7 @@ impl Impl {
     pub fn trait_(self, db: &dyn HirDatabase) -> Option<Trait> {
         let trait_ref = db.impl_trait_ns(self.id)?;
         let id = trait_ref.skip_binder().def_id;
-        let id = match id {
-            SolverDefId::TraitId(id) => id,
-            _ => unreachable!(),
-        };
-        Some(Trait { id })
+        Some(Trait { id: id.0 })
     }
 
     pub fn trait_ref(self, db: &dyn HirDatabase) -> Option<TraitRef<'_>> {
@@ -4609,11 +4598,7 @@ impl<'db> TraitRef<'db> {
     }
 
     pub fn trait_(&self) -> Trait {
-        let id = match self.trait_ref.def_id {
-            SolverDefId::TraitId(id) => id,
-            _ => unreachable!(),
-        };
-        Trait { id }
+        Trait { id: self.trait_ref.def_id.0 }
     }
 
     pub fn self_ty(&self) -> TypeNs<'_> {
@@ -5984,11 +5969,7 @@ impl<'db> TypeNs<'db> {
             infcx.interner,
             [self.ty].into_iter().chain(args.iter().map(|t| t.ty)).map(|t| t.into()),
         );
-        let trait_ref = hir_ty::next_solver::TraitRef::new(
-            infcx.interner,
-            SolverDefId::TraitId(trait_.id),
-            args,
-        );
+        let trait_ref = hir_ty::next_solver::TraitRef::new(infcx.interner, trait_.id.into(), args);
 
         let pred_kind = rustc_type_ir::Binder::dummy(rustc_type_ir::PredicateKind::Clause(
             rustc_type_ir::ClauseKind::Trait(rustc_type_ir::TraitPredicate {

From 4ca8078d37c53ee4ff8fb32b4453b915116f25b8 Mon Sep 17 00:00:00 2001
From: Lukas Markeffsky <@>
Date: Thu, 4 Sep 2025 22:39:15 +0200
Subject: [PATCH 0502/1889] fix ICE when suggesting `::new`

---
 compiler/rustc_hir_typeck/src/expr.rs         | 11 +++----
 tests/ui/privacy/suggest-box-new.rs           |  3 ++
 tests/ui/privacy/suggest-box-new.stderr       | 32 +++++++++++++++++--
 .../ui/privacy/suggest-new-projection-ice.rs  | 19 +++++++++++
 .../privacy/suggest-new-projection-ice.stderr | 10 ++++++
 .../suggestions/multi-suggestion.ascii.stderr |  2 +-
 .../multi-suggestion.unicode.stderr           |  2 +-
 7 files changed, 69 insertions(+), 10 deletions(-)
 create mode 100644 tests/ui/privacy/suggest-new-projection-ice.rs
 create mode 100644 tests/ui/privacy/suggest-new-projection-ice.stderr

diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index a652e08905a55..7adbee7ff2855 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -2585,12 +2585,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 .filter(|item| item.is_fn() && !item.is_method())
                 .filter_map(|item| {
                     // Only assoc fns that return `Self`
-                    let fn_sig = self.tcx.fn_sig(item.def_id).skip_binder();
-                    let ret_ty = fn_sig.output();
-                    let ret_ty = self.tcx.normalize_erasing_late_bound_regions(
-                        self.typing_env(self.param_env),
-                        ret_ty,
-                    );
+                    let fn_sig = self
+                        .tcx
+                        .fn_sig(item.def_id)
+                        .instantiate(self.tcx, self.fresh_args_for_item(span, item.def_id));
+                    let ret_ty = self.tcx.instantiate_bound_regions_with_erased(fn_sig.output());
                     if !self.can_eq(self.param_env, ret_ty, adt_ty) {
                         return None;
                     }
diff --git a/tests/ui/privacy/suggest-box-new.rs b/tests/ui/privacy/suggest-box-new.rs
index 7125285fc7764..ff585387020e4 100644
--- a/tests/ui/privacy/suggest-box-new.rs
+++ b/tests/ui/privacy/suggest-box-new.rs
@@ -16,4 +16,7 @@ fn main() {
     let _ = std::collections::HashMap {};
     //~^ ERROR cannot construct `HashMap<_, _, _>` with struct literal syntax due to private fields
     let _ = Box {}; //~ ERROR cannot construct `Box<_, _>` with struct literal syntax due to private fields
+
+    // test that we properly instantiate the parameter of `Box::<T>::new` with an inference variable
+    let _ = Box::<i32> {}; //~ ERROR cannot construct `Box<i32>` with struct literal syntax due to private fields
 }
diff --git a/tests/ui/privacy/suggest-box-new.stderr b/tests/ui/privacy/suggest-box-new.stderr
index 2b48e9046bf03..37b2989dcc148 100644
--- a/tests/ui/privacy/suggest-box-new.stderr
+++ b/tests/ui/privacy/suggest-box-new.stderr
@@ -118,13 +118,41 @@ LL +     let _ = Box::new_zeroed();
 LL -     let _ = Box {};
 LL +     let _ = Box::new_in(_, _);
    |
-   = and 12 other candidates
+   = and 13 other candidates
 help: consider using the `Default` trait
    |
 LL -     let _ = Box {};
 LL +     let _ = <Box as std::default::Default>::default();
    |
 
-error: aborting due to 4 previous errors
+error: cannot construct `Box<i32>` with struct literal syntax due to private fields
+  --> $DIR/suggest-box-new.rs:21:13
+   |
+LL |     let _ = Box::<i32> {};
+   |             ^^^^^^^^^^
+   |
+   = note: private fields `0` and `1` that were not provided
+help: you might have meant to use an associated function to build this type
+   |
+LL -     let _ = Box::<i32> {};
+LL +     let _ = Box::<i32>::new(_);
+   |
+LL -     let _ = Box::<i32> {};
+LL +     let _ = Box::<i32>::new_in(_, _);
+   |
+LL -     let _ = Box::<i32> {};
+LL +     let _ = Box::<i32>::into_inner(_);
+   |
+LL -     let _ = Box::<i32> {};
+LL +     let _ = Box::<i32>::write(_, _);
+   |
+   = and 4 other candidates
+help: consider using the `Default` trait
+   |
+LL -     let _ = Box::<i32> {};
+LL +     let _ = <Box::<i32> as std::default::Default>::default();
+   |
+
+error: aborting due to 5 previous errors
 
 For more information about this error, try `rustc --explain E0423`.
diff --git a/tests/ui/privacy/suggest-new-projection-ice.rs b/tests/ui/privacy/suggest-new-projection-ice.rs
new file mode 100644
index 0000000000000..41ac27508e8ac
--- /dev/null
+++ b/tests/ui/privacy/suggest-new-projection-ice.rs
@@ -0,0 +1,19 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/146174>.
+//! Ensure that we don't ICE when an associated function returns an associated type.
+
+mod m {
+    pub trait Project {
+        type Assoc;
+    }
+    pub struct Foo {
+        _priv: (),
+    }
+    impl Foo {
+        fn new<T: Project>() -> T::Assoc {
+            todo!()
+        }
+    }
+}
+fn main() {
+    let _ = m::Foo {}; //~ ERROR: cannot construct `Foo`
+}
diff --git a/tests/ui/privacy/suggest-new-projection-ice.stderr b/tests/ui/privacy/suggest-new-projection-ice.stderr
new file mode 100644
index 0000000000000..4700772096b93
--- /dev/null
+++ b/tests/ui/privacy/suggest-new-projection-ice.stderr
@@ -0,0 +1,10 @@
+error: cannot construct `Foo` with struct literal syntax due to private fields
+  --> $DIR/suggest-new-projection-ice.rs:18:13
+   |
+LL |     let _ = m::Foo {};
+   |             ^^^^^^
+   |
+   = note: private field `_priv` that was not provided
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/suggestions/multi-suggestion.ascii.stderr b/tests/ui/suggestions/multi-suggestion.ascii.stderr
index 1744162e6cec6..9c8867a17711e 100644
--- a/tests/ui/suggestions/multi-suggestion.ascii.stderr
+++ b/tests/ui/suggestions/multi-suggestion.ascii.stderr
@@ -118,7 +118,7 @@ LL +     let _ = Box::new_zeroed();
 LL -     let _ = Box {};
 LL +     let _ = Box::new_in(_, _);
    |
-   = and 12 other candidates
+   = and 13 other candidates
 help: consider using the `Default` trait
    |
 LL -     let _ = Box {};
diff --git a/tests/ui/suggestions/multi-suggestion.unicode.stderr b/tests/ui/suggestions/multi-suggestion.unicode.stderr
index 4835c263f1901..4fdab51493e26 100644
--- a/tests/ui/suggestions/multi-suggestion.unicode.stderr
+++ b/tests/ui/suggestions/multi-suggestion.unicode.stderr
@@ -118,7 +118,7 @@ LL +     let _ = Box::new_zeroed();
 LL -     let _ = Box {};
 LL +     let _ = Box::new_in(_, _);
    │
-   ╰ and 12 other candidates
+   ╰ and 13 other candidates
 help: consider using the `Default` trait
    ╭╴
 LL -     let _ = Box {};

From 06e4ed62db6ebaaa394624f868e76e1bd8b42b5c Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Thu, 4 Sep 2025 18:01:10 -0400
Subject: [PATCH 0503/1889] Set flip1995 to on-vacation

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

diff --git a/triagebot.toml b/triagebot.toml
index b2fb50918f583..7b19f8658c088 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -60,6 +60,7 @@ contributing_url = "https://github.com/rust-lang/rust-clippy/blob/master/CONTRIB
 users_on_vacation = [
     "matthiaskrgr",
     "Manishearth",
+    "flip1995",
 ]
 
 [assign.owners]

From e9810e578a187537d02e33121f004ed5face3375 Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Thu, 4 Sep 2025 18:18:39 -0400
Subject: [PATCH 0504/1889] Bump nightly version -> 2025-09-04

---
 clippy_utils/README.md | 2 +-
 rust-toolchain.toml    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/clippy_utils/README.md b/clippy_utils/README.md
index 2dfe28953d0c1..e01f563c49e73 100644
--- a/clippy_utils/README.md
+++ b/clippy_utils/README.md
@@ -8,7 +8,7 @@ This crate is only guaranteed to build with this `nightly` toolchain:
 
 <!-- begin autogenerated nightly -->
 ```
-nightly-2025-08-22
+nightly-2025-09-04
 ```
 <!-- end autogenerated nightly -->
 
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index 5497e77e8ad17..ec2f24a0a6d84 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,6 +1,6 @@
 [toolchain]
 # begin autogenerated nightly
-channel = "nightly-2025-08-22"
+channel = "nightly-2025-09-04"
 # end autogenerated nightly
 components = ["cargo", "llvm-tools", "rust-src", "rust-std", "rustc", "rustc-dev", "rustfmt"]
 profile = "minimal"

From 9b0611ff7aeb28bd3fcd3117256a1d9d9c2f1921 Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Thu, 4 Sep 2025 18:27:27 -0400
Subject: [PATCH 0505/1889] Merge commit
 'e9b70454e4c9584be3b22ddabd26b741aeb06c10' into clippy-subtree-update

---
 .cargo/config.toml                            |   7 +
 CHANGELOG.md                                  |   6 +
 book/src/lint_configuration.md                |  14 +-
 clippy.toml                                   |   6 +-
 clippy_config/src/conf.rs                     |   6 +-
 clippy_lints/Cargo.toml                       |   4 +
 .../src/assertions_on_result_states.rs        |  27 +-
 clippy_lints/src/async_yields_async.rs        |  60 +++--
 clippy_lints/src/bool_comparison.rs           | 179 ++++++++++++++
 clippy_lints/src/casts/cast_ptr_alignment.rs  |  30 +--
 .../src/casts/cast_slice_from_raw_parts.rs    |  43 +++-
 clippy_lints/src/casts/mod.rs                 |   8 +-
 clippy_lints/src/casts/ptr_as_ptr.rs          |  37 +--
 clippy_lints/src/casts/ptr_cast_constness.rs  |  34 +--
 clippy_lints/src/cognitive_complexity.rs      |   4 +-
 clippy_lints/src/declared_lints.rs            |   2 +-
 clippy_lints/src/derivable_impls.rs           |  80 +++++-
 clippy_lints/src/entry.rs                     |  67 ++---
 clippy_lints/src/eta_reduction.rs             |  21 +-
 clippy_lints/src/float_literal.rs             |  45 +++-
 clippy_lints/src/functions/mod.rs             |   2 +-
 .../src/functions/too_many_arguments.rs       |  37 +--
 clippy_lints/src/if_then_some_else_none.rs    |  32 +--
 clippy_lints/src/instant_subtraction.rs       |   5 +-
 clippy_lints/src/large_include_file.rs        |   4 +-
 clippy_lints/src/len_zero.rs                  |  22 +-
 clippy_lints/src/lib.rs                       |   7 +-
 clippy_lints/src/loops/infinite_loop.rs       |   9 +-
 clippy_lints/src/loops/missing_spin_loop.rs   |   6 +-
 clippy_lints/src/loops/needless_range_loop.rs |  33 ++-
 .../src/loops/unused_enumerate_index.rs       |   5 +-
 clippy_lints/src/manual_is_ascii_check.rs     |  26 +-
 clippy_lints/src/manual_retain.rs             |  10 +-
 clippy_lints/src/manual_strip.rs              |  10 +-
 clippy_lints/src/map_unit_fn.rs               |  21 +-
 clippy_lints/src/matches/collapsible_match.rs |  49 +++-
 clippy_lints/src/matches/mod.rs               |  11 +-
 .../matches/significant_drop_in_scrutinee.rs  |   9 +-
 clippy_lints/src/matches/try_err.rs           |  40 +--
 clippy_lints/src/mem_replace.rs               |   7 +-
 clippy_lints/src/methods/clone_on_ref_ptr.rs  |   7 +-
 clippy_lints/src/methods/filter_map.rs        |  14 +-
 .../src/methods/iter_out_of_bounds.rs         |  45 ++--
 clippy_lints/src/methods/map_flatten.rs       |   8 +-
 clippy_lints/src/methods/map_identity.rs      |  96 ++++++--
 .../src/methods/option_as_ref_deref.rs        |  28 +--
 clippy_lints/src/methods/or_then_unwrap.rs    |   2 +-
 .../src/methods/read_line_without_trim.rs     |   4 +-
 .../src/methods/single_char_add_str.rs        |   8 +-
 .../src/methods/suspicious_to_owned.rs        |   5 +-
 .../src/methods/unnecessary_min_or_max.rs     |   3 +-
 .../src/methods/unused_enumerate_index.rs     |   7 +-
 clippy_lints/src/missing_inline.rs            |  38 ++-
 clippy_lints/src/mut_reference.rs             |  13 +-
 clippy_lints/src/needless_bool.rs             | 228 +----------------
 clippy_lints/src/needless_for_each.rs         |  36 ++-
 clippy_lints/src/non_canonical_impls.rs       |   9 +-
 .../src/non_octal_unix_permissions.rs         |  12 +-
 .../src/operators/assign_op_pattern.rs        |  27 +-
 clippy_lints/src/operators/cmp_owned.rs       |  12 +-
 .../operators/float_equality_without_abs.rs   |   5 +-
 clippy_lints/src/panic_unimplemented.rs       |   6 +-
 clippy_lints/src/redundant_clone.rs           |  18 +-
 clippy_lints/src/semicolon_block.rs           |   5 +
 clippy_lints/src/std_instead_of_core.rs       |   2 +
 clippy_lints/src/strings.rs                   |   7 +-
 .../missing_transmute_annotations.rs          |  55 ++++-
 clippy_lints/src/transmute/mod.rs             |   2 +-
 .../transmute/transmute_int_to_non_zero.rs    |  53 ++--
 clippy_lints/src/types/rc_buffer.rs           |   5 +-
 .../src/types/redundant_allocation.rs         |  13 +-
 clippy_lints/src/unit_types/unit_cmp.rs       |   9 +-
 .../src/unnecessary_owned_empty_strings.rs    |   5 +-
 clippy_lints/src/unnecessary_wraps.rs         |  10 +-
 clippy_lints/src/unnested_or_patterns.rs      |   6 +-
 clippy_lints/src/unused_io_amount.rs          |   4 +-
 clippy_lints/src/unused_unit.rs               |  58 +++--
 clippy_lints/src/unwrap_in_result.rs          | 206 ++++++++++++----
 clippy_lints/src/useless_conversion.rs        |   9 +-
 clippy_lints/src/vec.rs                       | 232 +++++++++++-------
 clippy_lints/src/write.rs                     |  13 +-
 clippy_lints/src/zombie_processes.rs          |  20 +-
 clippy_utils/README.md                        |   2 +-
 clippy_utils/src/ast_utils/mod.rs             |   2 +-
 clippy_utils/src/higher.rs                    |  27 +-
 clippy_utils/src/hir_utils.rs                 |   2 +-
 clippy_utils/src/lib.rs                       |  55 ++++-
 clippy_utils/src/ty/mod.rs                    |   9 +-
 clippy_utils/src/usage.rs                     |   8 +-
 rust-toolchain.toml                           |   2 +-
 src/driver.rs                                 |   3 +-
 tests/config-consistency.rs                   |  30 +++
 tests/no-profile-in-cargo-toml.rs             |  34 +++
 tests/ui-internal/disallow_span_lint.stderr   |   4 +-
 tests/ui-toml/excessive_precision/clippy.toml |   1 +
 .../excessive_precision.fixed                 |  38 +++
 .../excessive_precision.rs                    |  38 +++
 .../excessive_precision.stderr                |  38 +++
 .../toml_unknown_key/conf_unknown_key.stderr  |   3 +
 tests/ui/assertions_on_result_states.fixed    |  11 +-
 tests/ui/assertions_on_result_states.rs       |  11 +-
 tests/ui/assertions_on_result_states.stderr   |  10 +-
 tests/ui/assign_ops.fixed                     |  39 ++-
 tests/ui/assign_ops.rs                        |  41 +++-
 tests/ui/assign_ops.stderr                    |  50 +++-
 tests/ui/async_yields_async.fixed             |  39 +++
 tests/ui/async_yields_async.rs                |  39 +++
 tests/ui/async_yields_async.stderr            |  47 +++-
 tests/ui/bool_comparison.fixed                | 167 +++++--------
 tests/ui/bool_comparison.rs                   | 167 +++++--------
 tests/ui/bool_comparison.stderr               | 154 ++++++------
 tests/ui/cast_raw_slice_pointer_cast.fixed    |  39 ++-
 tests/ui/cast_raw_slice_pointer_cast.rs       |  25 +-
 tests/ui/cast_raw_slice_pointer_cast.stderr   |  66 +++--
 .../cast_raw_slice_pointer_cast_no_std.fixed  |  55 +++++
 .../ui/cast_raw_slice_pointer_cast_no_std.rs  |  55 +++++
 .../cast_raw_slice_pointer_cast_no_std.stderr |  83 +++++++
 tests/ui/collapsible_match.rs                 |  41 ++++
 tests/ui/collapsible_match.stderr             |  71 +++++-
 tests/ui/collapsible_match2.stderr            |   2 +
 tests/ui/derivable_impls.fixed                |  38 +++
 tests/ui/derivable_impls.rs                   |  41 ++++
 tests/ui/derivable_impls.stderr               |  47 +++-
 tests/ui/derivable_impls_derive_const.fixed   |  25 ++
 tests/ui/derivable_impls_derive_const.rs      |  32 +++
 tests/ui/derivable_impls_derive_const.stderr  |  46 ++++
 tests/ui/doc/doc-fixable.fixed                |   1 +
 tests/ui/doc/doc-fixable.rs                   |   1 +
 tests/ui/doc/doc-fixable.stderr               |  44 ++--
 tests/ui/entry_unfixable.stderr               |   5 +
 tests/ui/eta.fixed                            |  45 ++++
 tests/ui/eta.rs                               |  45 ++++
 tests/ui/eta.stderr                           |  28 ++-
 tests/ui/excessive_precision.fixed            |  45 +++-
 tests/ui/excessive_precision.rs               |  45 +++-
 tests/ui/excessive_precision.stderr           |  85 +++++--
 tests/ui/float_equality_without_abs.rs        |  14 +-
 tests/ui/float_equality_without_abs.stderr    |  18 +-
 tests/ui/if_then_some_else_none.fixed         |  41 ++++
 tests/ui/if_then_some_else_none.rs            |  51 ++++
 tests/ui/if_then_some_else_none.stderr        |  25 +-
 tests/ui/infinite_loops.rs                    |  15 ++
 tests/ui/infinite_loops.stderr                |  12 +-
 tests/ui/manual_is_ascii_check.fixed          |   4 +
 tests/ui/manual_is_ascii_check.rs             |   4 +
 tests/ui/manual_is_ascii_check.stderr         |  30 ++-
 tests/ui/map_identity.fixed                   |  20 +-
 tests/ui/map_identity.rs                      |  16 +-
 tests/ui/map_identity.stderr                  |  66 +++--
 tests/ui/missing_inline.rs                    |   7 +
 ...missing_transmute_annotations_unfixable.rs |  29 +++
 ...ing_transmute_annotations_unfixable.stderr |  36 +++
 tests/ui/mut_reference.fixed                  | 170 +++++++++++++
 tests/ui/mut_reference.rs                     | 152 ++++++++++--
 tests/ui/mut_reference.stderr                 |  76 +++++-
 tests/ui/needless_bool/fixable.stderr         |   8 +-
 tests/ui/needless_for_each_unfixable.rs       |  19 +-
 tests/ui/needless_for_each_unfixable.stderr   |  38 ++-
 tests/ui/needless_range_loop.rs               |  32 +++
 tests/ui/needless_range_loop.stderr           |  26 +-
 tests/ui/nonminimal_bool.rs                   |   2 -
 tests/ui/nonminimal_bool.stderr               |  50 ++--
 tests/ui/option_map_unit_fn_fixable.fixed     |   9 +
 tests/ui/option_map_unit_fn_fixable.rs        |   9 +
 tests/ui/option_map_unit_fn_fixable.stderr    |  18 +-
 tests/ui/or_then_unwrap.fixed                 |   6 +
 tests/ui/or_then_unwrap.rs                    |   6 +
 tests/ui/or_then_unwrap.stderr                |  10 +-
 tests/ui/panicking_macros.rs                  |  15 ++
 tests/ui/panicking_macros.stderr              |  46 ++--
 tests/ui/print_literal.fixed                  |  13 +
 tests/ui/print_literal.rs                     |  14 ++
 tests/ui/print_literal.stderr                 |  38 ++-
 tests/ui/ptr_as_ptr.fixed                     |   6 +
 tests/ui/ptr_as_ptr.rs                        |   6 +
 tests/ui/ptr_as_ptr.stderr                    |   8 +-
 tests/ui/ptr_cast_constness.fixed             |   6 +
 tests/ui/ptr_cast_constness.rs                |   6 +
 tests/ui/ptr_cast_constness.stderr            |   8 +-
 tests/ui/semicolon_inside_block.fixed         |   5 +
 tests/ui/semicolon_inside_block.rs            |   5 +
 ...micolon_inside_block_stmt_expr_attrs.fixed |  11 +
 .../semicolon_inside_block_stmt_expr_attrs.rs |  11 +
 ...icolon_inside_block_stmt_expr_attrs.stderr |  16 ++
 tests/ui/std_instead_of_core.fixed            |   7 +
 tests/ui/std_instead_of_core.rs               |   7 +
 tests/ui/unit_cmp.rs                          |  17 ++
 tests/ui/unit_cmp.stderr                      |  20 +-
 tests/ui/unnecessary_clone.stderr             |  12 +-
 tests/ui/unnested_or_patterns.fixed           |  25 +-
 tests/ui/unnested_or_patterns.rs              |  25 +-
 tests/ui/unnested_or_patterns.stderr          |  54 ++--
 tests/ui/unused_unit.edition2021.fixed        |  27 +-
 tests/ui/unused_unit.edition2021.stderr       |   6 +-
 tests/ui/unused_unit.edition2024.fixed        |  29 ++-
 tests/ui/unused_unit.rs                       |  29 ++-
 tests/ui/unwrap_in_result.rs                  |  70 +++++-
 tests/ui/unwrap_in_result.stderr              | 132 +++++++---
 tests/ui/vec.fixed                            |   9 +
 tests/ui/vec.rs                               |   9 +
 tests/ui/vec.stderr                           |   8 +-
 triagebot.toml                                |   7 +
 202 files changed, 4536 insertions(+), 1641 deletions(-)
 create mode 100644 clippy_lints/src/bool_comparison.rs
 create mode 100644 tests/config-consistency.rs
 create mode 100644 tests/no-profile-in-cargo-toml.rs
 create mode 100644 tests/ui-toml/excessive_precision/clippy.toml
 create mode 100644 tests/ui-toml/excessive_precision/excessive_precision.fixed
 create mode 100644 tests/ui-toml/excessive_precision/excessive_precision.rs
 create mode 100644 tests/ui-toml/excessive_precision/excessive_precision.stderr
 create mode 100644 tests/ui/cast_raw_slice_pointer_cast_no_std.fixed
 create mode 100644 tests/ui/cast_raw_slice_pointer_cast_no_std.rs
 create mode 100644 tests/ui/cast_raw_slice_pointer_cast_no_std.stderr
 create mode 100644 tests/ui/derivable_impls_derive_const.fixed
 create mode 100644 tests/ui/derivable_impls_derive_const.rs
 create mode 100644 tests/ui/derivable_impls_derive_const.stderr
 create mode 100644 tests/ui/missing_transmute_annotations_unfixable.rs
 create mode 100644 tests/ui/missing_transmute_annotations_unfixable.stderr
 create mode 100644 tests/ui/mut_reference.fixed
 create mode 100644 tests/ui/semicolon_inside_block_stmt_expr_attrs.fixed
 create mode 100644 tests/ui/semicolon_inside_block_stmt_expr_attrs.rs
 create mode 100644 tests/ui/semicolon_inside_block_stmt_expr_attrs.stderr

diff --git a/.cargo/config.toml b/.cargo/config.toml
index d9c635df5dc79..a09bf95e87bd6 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -23,3 +23,10 @@ split-debuginfo = "unpacked"
 rustflags = ["--remap-path-prefix", "=clippy_dev"]
 [profile.dev.package.lintcheck]
 rustflags = ["--remap-path-prefix", "=lintcheck"]
+
+# quine-mc_cluskey makes up a significant part of the runtime in dogfood
+# due to the number of conditions in the clippy_lints crate
+# and enabling optimizations for that specific dependency helps a bit
+# without increasing total build times.
+[profile.dev.package.quine-mc_cluskey]
+opt-level = 3
diff --git a/CHANGELOG.md b/CHANGELOG.md
index bc60b1c57f7d1..eb2a76a818369 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -30,6 +30,8 @@ Current stable, released 2025-08-07
 * Removed superseded lints: `transmute_float_to_int`, `transmute_int_to_char`,
   `transmute_int_to_float`, `transmute_num_to_bytes` (now in rustc)
   [#14703](https://github.com/rust-lang/rust-clippy/pull/14703)
+* Move [`uninlined_format_args`] to `pedantic` (from `style`, now allow-by-default)
+  [#15287](https://github.com/rust-lang/rust-clippy/pull/15287)
 
 ### Enhancements
 
@@ -74,6 +76,9 @@ Current stable, released 2025-08-07
   [#14719](https://github.com/rust-lang/rust-clippy/pull/14719)
 * [`unnecessary_to_owned`] fixed FP when map key is a reference
   [#14834](https://github.com/rust-lang/rust-clippy/pull/14834)
+* [`swap_with_temporary`]: fix false positive leading to different semantics
+  being suggested, and use the right number of dereferences in suggestion
+  [#15172](https://github.com/rust-lang/rust-clippy/pull/15172)
 
 ### ICE Fixes
 
@@ -6707,6 +6712,7 @@ Released 2018-09-13
 [`check-inconsistent-struct-field-initializers`]: https://doc.rust-lang.org/clippy/lint_configuration.html#check-inconsistent-struct-field-initializers
 [`check-private-items`]: https://doc.rust-lang.org/clippy/lint_configuration.html#check-private-items
 [`cognitive-complexity-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#cognitive-complexity-threshold
+[`const-literal-digits-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#const-literal-digits-threshold
 [`disallowed-macros`]: https://doc.rust-lang.org/clippy/lint_configuration.html#disallowed-macros
 [`disallowed-methods`]: https://doc.rust-lang.org/clippy/lint_configuration.html#disallowed-methods
 [`disallowed-names`]: https://doc.rust-lang.org/clippy/lint_configuration.html#disallowed-names
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 05590ff7b1c9b..c2d080cd96a1d 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -485,6 +485,16 @@ The maximum cognitive complexity a function can have
 * [`cognitive_complexity`](https://rust-lang.github.io/rust-clippy/master/index.html#cognitive_complexity)
 
 
+## `const-literal-digits-threshold`
+The minimum digits a const float literal must have to supress the `excessive_precicion` lint
+
+**Default Value:** `30`
+
+---
+**Affected lints:**
+* [`excessive_precision`](https://rust-lang.github.io/rust-clippy/master/index.html#excessive_precision)
+
+
 ## `disallowed-macros`
 The list of disallowed macros, written as fully qualified paths.
 
@@ -555,7 +565,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:** `["KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "MHz", "GHz", "THz", "AccessKit", "CoAP", "CoreFoundation", "CoreGraphics", "CoreText", "DevOps", "Direct2D", "Direct3D", "DirectWrite", "DirectX", "ECMAScript", "GPLv2", "GPLv3", "GitHub", "GitLab", "IPv4", "IPv6", "ClojureScript", "CoffeeScript", "JavaScript", "PostScript", "PureScript", "TypeScript", "PowerPC", "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", "NixOS", "TeX", "LaTeX", "BibTeX", "BibLaTeX", "MinGW", "CamelCase"]`
+**Default Value:** `["KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "MHz", "GHz", "THz", "AccessKit", "CoAP", "CoreFoundation", "CoreGraphics", "CoreText", "DevOps", "Direct2D", "Direct3D", "DirectWrite", "DirectX", "ECMAScript", "GPLv2", "GPLv3", "GitHub", "GitLab", "IPv4", "IPv6", "InfiniBand", "RoCE", "ClojureScript", "CoffeeScript", "JavaScript", "PostScript", "PureScript", "TypeScript", "PowerPC", "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", "NixOS", "TeX", "LaTeX", "BibTeX", "BibLaTeX", "MinGW", "CamelCase"]`
 
 ---
 **Affected lints:**
@@ -873,7 +883,6 @@ The minimum rust version that the project supports. Defaults to the `rust-versio
 * [`needless_borrow`](https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow)
 * [`non_std_lazy_statics`](https://rust-lang.github.io/rust-clippy/master/index.html#non_std_lazy_statics)
 * [`option_as_ref_deref`](https://rust-lang.github.io/rust-clippy/master/index.html#option_as_ref_deref)
-* [`option_map_unwrap_or`](https://rust-lang.github.io/rust-clippy/master/index.html#option_map_unwrap_or)
 * [`ptr_as_ptr`](https://rust-lang.github.io/rust-clippy/master/index.html#ptr_as_ptr)
 * [`question_mark`](https://rust-lang.github.io/rust-clippy/master/index.html#question_mark)
 * [`redundant_field_names`](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_field_names)
@@ -881,7 +890,6 @@ The minimum rust version that the project supports. Defaults to the `rust-versio
 * [`repeat_vec_with_capacity`](https://rust-lang.github.io/rust-clippy/master/index.html#repeat_vec_with_capacity)
 * [`same_item_push`](https://rust-lang.github.io/rust-clippy/master/index.html#same_item_push)
 * [`seek_from_current`](https://rust-lang.github.io/rust-clippy/master/index.html#seek_from_current)
-* [`seek_rewind`](https://rust-lang.github.io/rust-clippy/master/index.html#seek_rewind)
 * [`to_digit_is_some`](https://rust-lang.github.io/rust-clippy/master/index.html#to_digit_is_some)
 * [`transmute_ptr_to_ref`](https://rust-lang.github.io/rust-clippy/master/index.html#transmute_ptr_to_ref)
 * [`tuple_array_conversions`](https://rust-lang.github.io/rust-clippy/master/index.html#tuple_array_conversions)
diff --git a/clippy.toml b/clippy.toml
index 77573105d86a3..d9bcfd17606e4 100644
--- a/clippy.toml
+++ b/clippy.toml
@@ -6,12 +6,12 @@ lint-commented-code = true
 
 [[disallowed-methods]]
 path = "rustc_lint::context::LintContext::lint"
-reason = "this function does not add a link to our documentation, please use the `clippy_utils::diagnostics::span_lint*` functions instead"
+reason = "this function does not add a link to our documentation; please use the `clippy_utils::diagnostics::span_lint*` functions instead"
 
 [[disallowed-methods]]
 path = "rustc_lint::context::LintContext::span_lint"
-reason = "this function does not add a link to our documentation, please use the `clippy_utils::diagnostics::span_lint*` functions instead"
+reason = "this function does not add a link to our documentation; please use the `clippy_utils::diagnostics::span_lint*` functions instead"
 
 [[disallowed-methods]]
 path = "rustc_middle::ty::context::TyCtxt::node_span_lint"
-reason = "this function does not add a link to our documentation, please use the `clippy_utils::diagnostics::span_lint_hir*` functions instead"
+reason = "this function does not add a link to our documentation; please use the `clippy_utils::diagnostics::span_lint_hir*` functions instead"
diff --git a/clippy_config/src/conf.rs b/clippy_config/src/conf.rs
index 2ad3f2efcdd7a..2f28f6175ad82 100644
--- a/clippy_config/src/conf.rs
+++ b/clippy_config/src/conf.rs
@@ -33,6 +33,7 @@ const DEFAULT_DOC_VALID_IDENTS: &[&str] = &[
     "GPLv2", "GPLv3",
     "GitHub", "GitLab",
     "IPv4", "IPv6",
+    "InfiniBand", "RoCE",
     "ClojureScript", "CoffeeScript", "JavaScript", "PostScript", "PureScript", "TypeScript",
     "PowerPC", "WebAssembly",
     "NaN", "NaNs",
@@ -569,6 +570,9 @@ define_Conf! {
     /// The maximum cognitive complexity a function can have
     #[lints(cognitive_complexity)]
     cognitive_complexity_threshold: u64 = 25,
+    /// The minimum digits a const float literal must have to supress the `excessive_precicion` lint
+    #[lints(excessive_precision)]
+    const_literal_digits_threshold: usize = 30,
     /// DEPRECATED LINT: CYCLOMATIC_COMPLEXITY.
     ///
     /// Use the Cognitive Complexity lint instead.
@@ -775,7 +779,6 @@ define_Conf! {
         needless_borrow,
         non_std_lazy_statics,
         option_as_ref_deref,
-        option_map_unwrap_or,
         ptr_as_ptr,
         question_mark,
         redundant_field_names,
@@ -783,7 +786,6 @@ define_Conf! {
         repeat_vec_with_capacity,
         same_item_push,
         seek_from_current,
-        seek_rewind,
         to_digit_is_some,
         transmute_ptr_to_ref,
         tuple_array_conversions,
diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index b9e6de79cc05c..70184ee2ca596 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -27,6 +27,10 @@ url = "2.2"
 [dev-dependencies]
 walkdir = "2.3"
 
+[lints.rust.unexpected_cfgs]
+level = "warn"
+check-cfg = ['cfg(bootstrap)']
+
 [package.metadata.rust-analyzer]
 # This crate uses #[feature(rustc_private)]
 rustc_private = true
diff --git a/clippy_lints/src/assertions_on_result_states.rs b/clippy_lints/src/assertions_on_result_states.rs
index 6f2a6a36a38b7..08253b0c4995e 100644
--- a/clippy_lints/src/assertions_on_result_states.rs
+++ b/clippy_lints/src/assertions_on_result_states.rs
@@ -3,10 +3,10 @@ use clippy_utils::macros::{PanicExpn, find_assert_args, root_macro_call_first_no
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::{has_debug_impl, is_copy, is_type_diagnostic_item};
 use clippy_utils::usage::local_used_after_expr;
-use clippy_utils::{is_expr_final_block_expr, path_res, sym};
+use clippy_utils::{path_res, sym};
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
-use rustc_hir::{Expr, ExprKind};
+use rustc_hir::{Expr, ExprKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty};
 use rustc_session::declare_lint_pass;
@@ -77,17 +77,20 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnResultStates {
                 _ => 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,
-                );
+                let recv = snippet_with_context(cx, recv.span, condition.span.ctxt(), "..", &mut app).0;
+
+                // `assert!` doesn't return anything, but `Result::unwrap(_err)` does, so we might need to add a
+                // semicolon to the suggestion to avoid leaking the type
+                let sugg = match cx.tcx.parent_hir_node(e.hir_id) {
+                    // trailing expr of a block
+                    Node::Block(..) => format!("{recv}.{replacement}();"),
+                    // already has a trailing semicolon
+                    Node::Stmt(..) => format!("{recv}.{replacement}()"),
+                    // this is the last-resort option, because it's rather verbose
+                    _ => format!("{{ {recv}.{replacement}(); }}"),
+                };
+                diag.span_suggestion(macro_call.span, "replace with", sugg, app);
             });
         }
     }
diff --git a/clippy_lints/src/async_yields_async.rs b/clippy_lints/src/async_yields_async.rs
index 013819b0da8ae..1a10db291cdea 100644
--- a/clippy_lints/src/async_yields_async.rs
+++ b/clippy_lints/src/async_yields_async.rs
@@ -1,8 +1,12 @@
 use clippy_utils::diagnostics::span_lint_hir_and_then;
-use clippy_utils::source::snippet;
+use clippy_utils::is_expr_async_block;
+use clippy_utils::source::walk_span_to_context;
+use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::implements_trait;
 use rustc_errors::Applicability;
-use rustc_hir::{Closure, ClosureKind, CoroutineDesugaring, CoroutineKind, CoroutineSource, Expr, ExprKind, QPath};
+use rustc_hir::{
+    Block, Closure, ClosureKind, CoroutineDesugaring, CoroutineKind, CoroutineSource, Expr, ExprKind, QPath,
+};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
 
@@ -87,31 +91,37 @@ impl<'tcx> LateLintPass<'tcx> for AsyncYieldsAsync {
         let expr_ty = typeck_results.expr_ty(body_expr);
 
         if implements_trait(cx, expr_ty, future_trait_def_id, &[]) {
-            let return_expr_span = match &body_expr.kind {
-                // XXXkhuey there has to be a better way.
-                ExprKind::Block(block, _) => block.expr.map(|e| e.span),
-                ExprKind::Path(QPath::Resolved(_, path)) => Some(path.span),
-                _ => None,
+            let (return_expr, return_expr_span) = match &body_expr.kind {
+                ExprKind::Block(Block { expr: Some(e), .. }, _) => (*e, e.span),
+                ExprKind::Path(QPath::Resolved(_, path)) => (body_expr, path.span),
+                _ => return,
             };
-            if let Some(return_expr_span) = return_expr_span {
-                span_lint_hir_and_then(
-                    cx,
-                    ASYNC_YIELDS_ASYNC,
-                    body_expr.hir_id,
-                    return_expr_span,
-                    "an async construct yields a type which is itself awaitable",
-                    |db| {
-                        db.span_label(body_expr.span, "outer async construct");
-                        db.span_label(return_expr_span, "awaitable value not awaited");
-                        db.span_suggestion(
-                            return_expr_span,
-                            "consider awaiting this value",
-                            format!("{}.await", snippet(cx, return_expr_span, "..")),
-                            Applicability::MaybeIncorrect,
-                        );
-                    },
-                );
+
+            let return_expr_span = walk_span_to_context(return_expr_span, expr.span.ctxt()).unwrap_or(return_expr_span);
+            let mut applicability = Applicability::MaybeIncorrect;
+            let mut return_expr_snip =
+                Sugg::hir_with_context(cx, return_expr, expr.span.ctxt(), "..", &mut applicability);
+            if !is_expr_async_block(return_expr) {
+                return_expr_snip = return_expr_snip.maybe_paren();
             }
+
+            span_lint_hir_and_then(
+                cx,
+                ASYNC_YIELDS_ASYNC,
+                body_expr.hir_id,
+                return_expr_span,
+                "an async construct yields a type which is itself awaitable",
+                |db| {
+                    db.span_label(body_expr.span, "outer async construct");
+                    db.span_label(return_expr_span, "awaitable value not awaited");
+                    db.span_suggestion(
+                        return_expr_span,
+                        "consider awaiting this value",
+                        format!("{return_expr_snip}.await"),
+                        applicability,
+                    );
+                },
+            );
         }
     }
 }
diff --git a/clippy_lints/src/bool_comparison.rs b/clippy_lints/src/bool_comparison.rs
new file mode 100644
index 0000000000000..722095909a6fe
--- /dev/null
+++ b/clippy_lints/src/bool_comparison.rs
@@ -0,0 +1,179 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::sugg::Sugg;
+use clippy_utils::{is_expn_of, peel_blocks, sym};
+use rustc_ast::ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::declare_lint_pass;
+use rustc_span::Span;
+use rustc_span::source_map::Spanned;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for expressions of the form `x == true`,
+    /// `x != true` and order comparisons such as `x < true` (or vice versa) and
+    /// suggest using the variable directly.
+    ///
+    /// ### Why is this bad?
+    /// Unnecessary code.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// if x == true {}
+    /// if y == false {}
+    /// ```
+    /// use `x` directly:
+    /// ```rust,ignore
+    /// if x {}
+    /// if !y {}
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub BOOL_COMPARISON,
+    complexity,
+    "comparing a variable to a boolean, e.g., `if x == true` or `if x != true`"
+}
+
+declare_lint_pass!(BoolComparison => [BOOL_COMPARISON]);
+
+impl<'tcx> LateLintPass<'tcx> for BoolComparison {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
+        if e.span.from_expansion() {
+            return;
+        }
+
+        if let ExprKind::Binary(Spanned { node, .. }, left_side, right_side) = e.kind
+            && is_expn_of(left_side.span, sym::cfg).is_none()
+            && is_expn_of(right_side.span, sym::cfg).is_none()
+            && cx.typeck_results().expr_ty(left_side).is_bool()
+            && cx.typeck_results().expr_ty(right_side).is_bool()
+        {
+            let ignore_case = None::<(fn(_) -> _, &str)>;
+            let ignore_no_literal = None::<(fn(_, _) -> _, &str)>;
+            match node {
+                BinOpKind::Eq => {
+                    let true_case = Some((|h| h, "equality checks against true are unnecessary"));
+                    let false_case = Some((
+                        |h: Sugg<'tcx>| !h,
+                        "equality checks against false can be replaced by a negation",
+                    ));
+                    check_comparison(cx, e, true_case, false_case, true_case, false_case, ignore_no_literal);
+                },
+                BinOpKind::Ne => {
+                    let true_case = Some((
+                        |h: Sugg<'tcx>| !h,
+                        "inequality checks against true can be replaced by a negation",
+                    ));
+                    let false_case = Some((|h| h, "inequality checks against false are unnecessary"));
+                    check_comparison(cx, e, true_case, false_case, true_case, false_case, ignore_no_literal);
+                },
+                BinOpKind::Lt => check_comparison(
+                    cx,
+                    e,
+                    ignore_case,
+                    Some((|h| h, "greater than checks against false are unnecessary")),
+                    Some((
+                        |h: Sugg<'tcx>| !h,
+                        "less than comparison against true can be replaced by a negation",
+                    )),
+                    ignore_case,
+                    Some((
+                        |l: Sugg<'tcx>, r: Sugg<'tcx>| (!l).bit_and(&r),
+                        "order comparisons between booleans can be simplified",
+                    )),
+                ),
+                BinOpKind::Gt => check_comparison(
+                    cx,
+                    e,
+                    Some((
+                        |h: Sugg<'tcx>| !h,
+                        "less than comparison against true can be replaced by a negation",
+                    )),
+                    ignore_case,
+                    ignore_case,
+                    Some((|h| h, "greater than checks against false are unnecessary")),
+                    Some((
+                        |l: Sugg<'tcx>, r: Sugg<'tcx>| l.bit_and(&(!r)),
+                        "order comparisons between booleans can be simplified",
+                    )),
+                ),
+                _ => (),
+            }
+        }
+    }
+}
+
+fn check_comparison<'a, 'tcx>(
+    cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'_>,
+    left_true: Option<(impl FnOnce(Sugg<'a>) -> Sugg<'a>, &'static str)>,
+    left_false: Option<(impl FnOnce(Sugg<'a>) -> Sugg<'a>, &'static str)>,
+    right_true: Option<(impl FnOnce(Sugg<'a>) -> Sugg<'a>, &'static str)>,
+    right_false: Option<(impl FnOnce(Sugg<'a>) -> Sugg<'a>, &'static str)>,
+    no_literal: Option<(impl FnOnce(Sugg<'a>, Sugg<'a>) -> Sugg<'a>, &'static str)>,
+) {
+    if let ExprKind::Binary(_, left_side, right_side) = e.kind {
+        let mut applicability = Applicability::MachineApplicable;
+        // Eliminate parentheses in `e` by using the lo pos of lhs and hi pos of rhs,
+        // calling `source_callsite` make sure macros are handled correctly, see issue #9907
+        let binop_span = left_side.span.source_callsite().to(right_side.span.source_callsite());
+
+        match (fetch_bool_expr(left_side), fetch_bool_expr(right_side)) {
+            (Some(true), None) => left_true.map_or((), |(h, m)| {
+                suggest_bool_comparison(cx, binop_span, right_side, applicability, m, h);
+            }),
+            (None, Some(true)) => right_true.map_or((), |(h, m)| {
+                suggest_bool_comparison(cx, binop_span, left_side, applicability, m, h);
+            }),
+            (Some(false), None) => left_false.map_or((), |(h, m)| {
+                suggest_bool_comparison(cx, binop_span, right_side, applicability, m, h);
+            }),
+            (None, Some(false)) => right_false.map_or((), |(h, m)| {
+                suggest_bool_comparison(cx, binop_span, left_side, applicability, m, h);
+            }),
+            (None, None) => no_literal.map_or((), |(h, m)| {
+                let left_side = Sugg::hir_with_context(cx, left_side, binop_span.ctxt(), "..", &mut applicability);
+                let right_side = Sugg::hir_with_context(cx, right_side, binop_span.ctxt(), "..", &mut applicability);
+                span_lint_and_sugg(
+                    cx,
+                    BOOL_COMPARISON,
+                    binop_span,
+                    m,
+                    "try",
+                    h(left_side, right_side).into_string(),
+                    applicability,
+                );
+            }),
+            _ => (),
+        }
+    }
+}
+
+fn suggest_bool_comparison<'a, 'tcx>(
+    cx: &LateContext<'tcx>,
+    span: Span,
+    expr: &Expr<'_>,
+    mut app: Applicability,
+    message: &'static str,
+    conv_hint: impl FnOnce(Sugg<'a>) -> Sugg<'a>,
+) {
+    let hint = Sugg::hir_with_context(cx, expr, span.ctxt(), "..", &mut app);
+    span_lint_and_sugg(
+        cx,
+        BOOL_COMPARISON,
+        span,
+        message,
+        "try",
+        conv_hint(hint).into_string(),
+        app,
+    );
+}
+
+fn fetch_bool_expr(expr: &Expr<'_>) -> Option<bool> {
+    if let ExprKind::Lit(lit_ptr) = peel_blocks(expr).kind
+        && let LitKind::Bool(value) = lit_ptr.node
+    {
+        return Some(value);
+    }
+    None
+}
diff --git a/clippy_lints/src/casts/cast_ptr_alignment.rs b/clippy_lints/src/casts/cast_ptr_alignment.rs
index a1543cabd2f9d..d78da9396faf3 100644
--- a/clippy_lints/src/casts/cast_ptr_alignment.rs
+++ b/clippy_lints/src/casts/cast_ptr_alignment.rs
@@ -8,17 +8,12 @@ use rustc_middle::ty::{self, Ty};
 
 use super::CAST_PTR_ALIGNMENT;
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
-    if let ExprKind::Cast(cast_expr, cast_to) = expr.kind {
-        if is_hir_ty_cfg_dependant(cx, cast_to) {
-            return;
-        }
-        let (cast_from, cast_to) = (
-            cx.typeck_results().expr_ty(cast_expr),
-            cx.typeck_results().expr_ty(expr),
-        );
-        lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
-    } else if let ExprKind::MethodCall(method_path, self_arg, [], _) = &expr.kind
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, cast_from: Ty<'tcx>, cast_to: Ty<'tcx>) {
+    lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
+}
+
+pub(super) fn check_cast_method(cx: &LateContext<'_>, expr: &Expr<'_>) {
+    if let ExprKind::MethodCall(method_path, self_arg, [], _) = &expr.kind
         && method_path.ident.name == sym::cast
         && let Some(generic_args) = method_path.args
         && let [GenericArg::Type(cast_to)] = generic_args.args
@@ -74,14 +69,13 @@ fn is_used_as_unaligned(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
         ExprKind::Call(func, [arg, ..]) if arg.hir_id == e.hir_id => {
             if let ExprKind::Path(path) = &func.kind
                 && let Some(def_id) = cx.qpath_res(path, func.hir_id).opt_def_id()
+                && let Some(name) = cx.tcx.get_diagnostic_name(def_id)
                 && matches!(
-                    cx.tcx.get_diagnostic_name(def_id),
-                    Some(
-                        sym::ptr_write_unaligned
-                            | sym::ptr_read_unaligned
-                            | sym::intrinsics_unaligned_volatile_load
-                            | sym::intrinsics_unaligned_volatile_store
-                    )
+                    name,
+                    sym::ptr_write_unaligned
+                        | sym::ptr_read_unaligned
+                        | sym::intrinsics_unaligned_volatile_load
+                        | sym::intrinsics_unaligned_volatile_store
                 )
             {
                 true
diff --git a/clippy_lints/src/casts/cast_slice_from_raw_parts.rs b/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
index 46b0c88d3feda..bce7b4c69cc62 100644
--- a/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
+++ b/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
@@ -1,10 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_context;
+use clippy_utils::{get_parent_expr, is_no_std_crate};
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
+use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow};
 use rustc_middle::ty::{self, Ty};
 use rustc_span::sym;
 
@@ -42,13 +44,52 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
         let mut applicability = Applicability::MachineApplicable;
         let ptr = snippet_with_context(cx, ptr_arg.span, ctxt, "ptr", &mut applicability).0;
         let len = snippet_with_context(cx, len_arg.span, ctxt, "len", &mut applicability).0;
+        let krate = if is_no_std_crate(cx) { "core" } else { "std" };
         span_lint_and_sugg(
             cx,
             CAST_SLICE_FROM_RAW_PARTS,
             span,
             format!("casting the result of `{func}` to {cast_to}"),
             "replace with",
-            format!("core::ptr::slice_{func}({ptr}, {len})"),
+            format!("{krate}::ptr::slice_{func}({ptr}, {len})"),
+            applicability,
+        );
+    }
+}
+
+/// Checks for implicit cast from slice reference to raw slice pointer.
+pub(super) fn check_implicit_cast(cx: &LateContext<'_>, expr: &Expr<'_>) {
+    if let ExprKind::Call(fun, [ptr_arg, len_arg]) = expr.peel_blocks().kind
+        && let ExprKind::Path(ref qpath) = fun.kind
+        && let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id()
+        && let Some(rpk) = raw_parts_kind(cx, fun_def_id)
+        && !matches!(get_parent_expr(cx, expr).map(|e| e.kind), Some(ExprKind::Cast(..)))
+        && let [deref, borrow] = cx.typeck_results().expr_adjustments(expr)
+        && matches!(deref.kind, Adjust::Deref(..))
+        && let Adjustment {
+            kind: Adjust::Borrow(AutoBorrow::RawPtr(..)),
+            target,
+        } = borrow
+        && let ty::RawPtr(pointee_ty, _) = target.kind()
+        && pointee_ty.is_slice()
+        && !expr.span.from_expansion()
+    {
+        let func = match rpk {
+            RawPartsKind::Immutable => "from_raw_parts",
+            RawPartsKind::Mutable => "from_raw_parts_mut",
+        };
+        let mut applicability = Applicability::MachineApplicable;
+        let ctxt = expr.span.ctxt();
+        let ptr = snippet_with_context(cx, ptr_arg.span, ctxt, "ptr", &mut applicability).0;
+        let len = snippet_with_context(cx, len_arg.span, ctxt, "len", &mut applicability).0;
+        let krate = if is_no_std_crate(cx) { "core" } else { "std" };
+        span_lint_and_sugg(
+            cx,
+            CAST_SLICE_FROM_RAW_PARTS,
+            expr.span,
+            format!("implicitly casting the result of `{func}` to `{target}`"),
+            "replace_with",
+            format!("{krate}::ptr::slice_{func}({ptr}, {len})"),
             applicability,
         );
     }
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index e25df9dd249a6..d2e62ee56e43b 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -873,7 +873,9 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             }
             char_lit_as_u8::check(cx, expr, cast_from_expr, cast_to);
             cast_slice_from_raw_parts::check(cx, expr, cast_from_expr, cast_to, self.msrv);
+            cast_ptr_alignment::check(cx, expr, cast_from, cast_to);
             ptr_cast_constness::check(cx, expr, cast_from_expr, cast_from, cast_to, self.msrv);
+            ptr_as_ptr::check(cx, expr, cast_from_expr, cast_from, cast_to_hir, cast_to, self.msrv);
             as_ptr_cast_mut::check(cx, expr, cast_from_expr, cast_to);
             fn_to_numeric_cast_any::check(cx, expr, cast_from_expr, cast_from, cast_to);
             confusing_method_to_numeric_cast::check(cx, expr, cast_from_expr, cast_from, cast_to);
@@ -911,8 +913,10 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
         if self.msrv.meets(cx, msrvs::RAW_REF_OP) {
             borrow_as_ptr::check_implicit_cast(cx, expr);
         }
-        cast_ptr_alignment::check(cx, expr);
-        ptr_as_ptr::check(cx, expr, self.msrv);
+        if self.msrv.meets(cx, msrvs::PTR_SLICE_RAW_PARTS) {
+            cast_slice_from_raw_parts::check_implicit_cast(cx, expr);
+        }
+        cast_ptr_alignment::check_cast_method(cx, expr);
         cast_slice_different_sizes::check(cx, expr, self.msrv);
         ptr_cast_constness::check_null_ptr_cast_method(cx, expr);
     }
diff --git a/clippy_lints/src/casts/ptr_as_ptr.rs b/clippy_lints/src/casts/ptr_as_ptr.rs
index 890754090989f..d012380cb762f 100644
--- a/clippy_lints/src/casts/ptr_as_ptr.rs
+++ b/clippy_lints/src/casts/ptr_as_ptr.rs
@@ -4,9 +4,9 @@ use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, Mutability, QPath, TyKind};
+use rustc_hir::{self as hir, Expr, ExprKind, QPath, TyKind};
 use rustc_lint::LateContext;
-use rustc_middle::ty;
+use rustc_middle::ty::{self, Ty};
 use rustc_span::{Span, sym};
 
 use super::PTR_AS_PTR;
@@ -26,13 +26,18 @@ impl OmitFollowedCastReason<'_> {
     }
 }
 
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, msrv: Msrv) {
-    if let ExprKind::Cast(cast_expr, cast_to_hir_ty) = expr.kind
-        && let (cast_from, cast_to) = (cx.typeck_results().expr_ty(cast_expr), cx.typeck_results().expr_ty(expr))
-        && let ty::RawPtr(_, from_mutbl) = cast_from.kind()
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &Expr<'tcx>,
+    cast_from_expr: &Expr<'_>,
+    cast_from: Ty<'_>,
+    cast_to_hir: &hir::Ty<'_>,
+    cast_to: Ty<'tcx>,
+    msrv: Msrv,
+) {
+    if let ty::RawPtr(_, from_mutbl) = cast_from.kind()
         && let ty::RawPtr(to_pointee_ty, to_mutbl) = cast_to.kind()
-        && matches!((from_mutbl, to_mutbl),
-            (Mutability::Not, Mutability::Not) | (Mutability::Mut, Mutability::Mut))
+        && from_mutbl == to_mutbl
         // The `U` in `pointer::cast` have to be `Sized`
         // as explained here: https://github.com/rust-lang/rust/issues/60602.
         && to_pointee_ty.is_sized(cx.tcx, cx.typing_env())
@@ -40,7 +45,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, msrv: Msrv)
         && !is_from_proc_macro(cx, expr)
     {
         let mut app = Applicability::MachineApplicable;
-        let turbofish = match &cast_to_hir_ty.kind {
+        let turbofish = match &cast_to_hir.kind {
             TyKind::Infer(()) => String::new(),
             TyKind::Ptr(mut_ty) => {
                 if matches!(mut_ty.ty.kind, TyKind::Infer(())) {
@@ -58,16 +63,14 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, msrv: Msrv)
         // following `cast` does not compile because it fails to infer what type is expected
         // as type argument to `std::ptr::ptr_null` or `std::ptr::ptr_null_mut`, so
         // we omit following `cast`:
-        let omit_cast = if let ExprKind::Call(func, []) = cast_expr.kind
+        let omit_cast = if let ExprKind::Call(func, []) = cast_from_expr.kind
             && let ExprKind::Path(ref qpath @ QPath::Resolved(None, path)) = func.kind
             && let Some(method_defid) = path.res.opt_def_id()
         {
-            if cx.tcx.is_diagnostic_item(sym::ptr_null, method_defid) {
-                OmitFollowedCastReason::Null(qpath)
-            } else if cx.tcx.is_diagnostic_item(sym::ptr_null_mut, method_defid) {
-                OmitFollowedCastReason::NullMut(qpath)
-            } else {
-                OmitFollowedCastReason::None
+            match cx.tcx.get_diagnostic_name(method_defid) {
+                Some(sym::ptr_null) => OmitFollowedCastReason::Null(qpath),
+                Some(sym::ptr_null_mut) => OmitFollowedCastReason::NullMut(qpath),
+                _ => OmitFollowedCastReason::None,
             }
         } else {
             OmitFollowedCastReason::None
@@ -78,7 +81,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, msrv: Msrv)
             let method = snippet_with_applicability(cx, qpath_span_without_turbofish(method), "..", &mut app);
             ("try call directly", format!("{method}{turbofish}()"))
         } else {
-            let cast_expr_sugg = Sugg::hir_with_applicability(cx, cast_expr, "_", &mut app);
+            let cast_expr_sugg = Sugg::hir_with_context(cx, cast_from_expr, expr.span.ctxt(), "_", &mut app);
 
             (
                 "try `pointer::cast`, a safer alternative",
diff --git a/clippy_lints/src/casts/ptr_cast_constness.rs b/clippy_lints/src/casts/ptr_cast_constness.rs
index c0c0a47f85515..c0f13f5e57823 100644
--- a/clippy_lints/src/casts/ptr_cast_constness.rs
+++ b/clippy_lints/src/casts/ptr_cast_constness.rs
@@ -1,9 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{std_or_core, sym};
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, Mutability, QPath};
+use rustc_hir::{self as hir, Expr, ExprKind, QPath};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty, TypeVisitableExt};
 
@@ -12,26 +13,23 @@ use super::PTR_CAST_CONSTNESS;
 pub(super) fn check<'tcx>(
     cx: &LateContext<'_>,
     expr: &Expr<'_>,
-    cast_expr: &Expr<'_>,
+    cast_from_expr: &Expr<'_>,
     cast_from: Ty<'tcx>,
     cast_to: Ty<'tcx>,
     msrv: Msrv,
 ) {
     if let ty::RawPtr(from_ty, from_mutbl) = cast_from.kind()
         && let ty::RawPtr(to_ty, to_mutbl) = cast_to.kind()
-        && matches!(
-            (from_mutbl, to_mutbl),
-            (Mutability::Not, Mutability::Mut) | (Mutability::Mut, Mutability::Not)
-        )
+        && from_mutbl != to_mutbl
         && from_ty == to_ty
         && !from_ty.has_erased_regions()
     {
-        if let ExprKind::Call(func, []) = cast_expr.kind
+        if let ExprKind::Call(func, []) = cast_from_expr.kind
             && let ExprKind::Path(QPath::Resolved(None, path)) = func.kind
             && let Some(defid) = path.res.opt_def_id()
             && let Some(prefix) = std_or_core(cx)
             && let mut app = Applicability::MachineApplicable
-            && let sugg = format!("{}", Sugg::hir_with_applicability(cx, cast_expr, "_", &mut app))
+            && let sugg = snippet_with_applicability(cx, cast_from_expr.span, "_", &mut app)
             && let Some((_, after_lt)) = sugg.split_once("::<")
             && let Some((source, target, target_func)) = match cx.tcx.get_diagnostic_name(defid) {
                 Some(sym::ptr_null) => Some(("const", "mutable", "null_mut")),
@@ -53,11 +51,17 @@ pub(super) fn check<'tcx>(
 
         if msrv.meets(cx, msrvs::POINTER_CAST_CONSTNESS) {
             let mut app = Applicability::MachineApplicable;
-            let sugg = Sugg::hir_with_context(cx, cast_expr, expr.span.ctxt(), "_", &mut app);
-            let constness = match *to_mutbl {
-                Mutability::Not => "const",
-                Mutability::Mut => "mut",
+            let sugg = if let ExprKind::Cast(nested_from, nested_hir_ty) = cast_from_expr.kind
+                && let hir::TyKind::Ptr(ptr_ty) = nested_hir_ty.kind
+                && let hir::TyKind::Infer(()) = ptr_ty.ty.kind
+            {
+                // `(foo as *const _).cast_mut()` fails method name resolution
+                // avoid this by `as`-ing the full type
+                Sugg::hir_with_context(cx, nested_from, expr.span.ctxt(), "_", &mut app).as_ty(cast_from)
+            } else {
+                Sugg::hir_with_context(cx, cast_from_expr, expr.span.ctxt(), "_", &mut app)
             };
+            let constness = to_mutbl.ptr_str();
 
             span_lint_and_sugg(
                 cx,
@@ -73,8 +77,8 @@ pub(super) fn check<'tcx>(
 }
 
 pub(super) fn check_null_ptr_cast_method(cx: &LateContext<'_>, expr: &Expr<'_>) {
-    if let ExprKind::MethodCall(method, cast_expr, [], _) = expr.kind
-        && let ExprKind::Call(func, []) = cast_expr.kind
+    if let ExprKind::MethodCall(method, cast_from_expr, [], _) = expr.kind
+        && let ExprKind::Call(func, []) = cast_from_expr.kind
         && let ExprKind::Path(QPath::Resolved(None, path)) = func.kind
         && let Some(defid) = path.res.opt_def_id()
         && let method = match (cx.tcx.get_diagnostic_name(defid), method.ident.name) {
@@ -84,7 +88,7 @@ pub(super) fn check_null_ptr_cast_method(cx: &LateContext<'_>, expr: &Expr<'_>)
         }
         && let Some(prefix) = std_or_core(cx)
         && let mut app = Applicability::MachineApplicable
-        && let sugg = format!("{}", Sugg::hir_with_applicability(cx, cast_expr, "_", &mut app))
+        && let sugg = snippet_with_applicability(cx, cast_from_expr.span, "_", &mut app)
         && let Some((_, after_lt)) = sugg.split_once("::<")
     {
         span_lint_and_sugg(
diff --git a/clippy_lints/src/cognitive_complexity.rs b/clippy_lints/src/cognitive_complexity.rs
index 8f95c63a854f5..7646aa48b7726 100644
--- a/clippy_lints/src/cognitive_complexity.rs
+++ b/clippy_lints/src/cognitive_complexity.rs
@@ -23,8 +23,8 @@ declare_clippy_lint! {
     ///
     /// ### Known problems
     /// The true Cognitive Complexity of a method is not something we can
-    /// calculate using modern technology. This lint has been left in the
-    /// `nursery` so as to not mislead users into using this lint as a
+    /// calculate using modern technology. This lint has been left in
+    /// `restriction` so as to not mislead users into using this lint as a
     /// measurement tool.
     ///
     /// For more detailed information, see [rust-clippy#3793](https://github.com/rust-lang/rust-clippy/issues/3793)
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index e67e8d9070f2c..d0c7443a4a4b9 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -35,6 +35,7 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::await_holding_invalid::AWAIT_HOLDING_REFCELL_REF_INFO,
     crate::blocks_in_conditions::BLOCKS_IN_CONDITIONS_INFO,
     crate::bool_assert_comparison::BOOL_ASSERT_COMPARISON_INFO,
+    crate::bool_comparison::BOOL_COMPARISON_INFO,
     crate::bool_to_int_with_if::BOOL_TO_INT_WITH_IF_INFO,
     crate::booleans::NONMINIMAL_BOOL_INFO,
     crate::booleans::OVERLY_COMPLEX_BOOL_EXPR_INFO,
@@ -538,7 +539,6 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::mutex_atomic::MUTEX_ATOMIC_INFO,
     crate::mutex_atomic::MUTEX_INTEGER_INFO,
     crate::needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE_INFO,
-    crate::needless_bool::BOOL_COMPARISON_INFO,
     crate::needless_bool::NEEDLESS_BOOL_INFO,
     crate::needless_bool::NEEDLESS_BOOL_ASSIGN_INFO,
     crate::needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE_INFO,
diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index 7580d6cab66d4..06c2393e0a39f 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -10,7 +10,7 @@ use rustc_hir::{
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::adjustment::{Adjust, PointerCoercion};
-use rustc_middle::ty::{self, AdtDef, GenericArgsRef, Ty, TypeckResults};
+use rustc_middle::ty::{self, AdtDef, GenericArgsRef, Ty, TypeckResults, VariantDef};
 use rustc_session::impl_lint_pass;
 use rustc_span::sym;
 
@@ -85,6 +85,13 @@ fn contains_trait_object(ty: Ty<'_>) -> bool {
     }
 }
 
+fn determine_derive_macro(cx: &LateContext<'_>, is_const: bool) -> Option<&'static str> {
+    (!is_const)
+        .then_some("derive")
+        .or_else(|| cx.tcx.features().enabled(sym::derive_const).then_some("derive_const"))
+}
+
+#[expect(clippy::too_many_arguments)]
 fn check_struct<'tcx>(
     cx: &LateContext<'tcx>,
     item: &'tcx Item<'_>,
@@ -93,6 +100,7 @@ fn check_struct<'tcx>(
     adt_def: AdtDef<'_>,
     ty_args: GenericArgsRef<'_>,
     typeck_results: &'tcx TypeckResults<'tcx>,
+    is_const: bool,
 ) {
     if let TyKind::Path(QPath::Resolved(_, p)) = self_ty.kind
         && let Some(PathSegment { args, .. }) = p.segments.last()
@@ -125,14 +133,18 @@ fn check_struct<'tcx>(
         ExprKind::Tup(fields) => fields.iter().all(is_default_without_adjusts),
         ExprKind::Call(callee, args) if is_path_self(callee) => args.iter().all(is_default_without_adjusts),
         ExprKind::Struct(_, fields, _) => fields.iter().all(|ef| is_default_without_adjusts(ef.expr)),
-        _ => false,
+        _ => return,
     };
 
-    if should_emit {
+    if should_emit && let Some(derive_snippet) = determine_derive_macro(cx, is_const) {
         let struct_span = cx.tcx.def_span(adt_def.did());
+        let indent_enum = indent_of(cx, struct_span).unwrap_or(0);
         let suggestions = vec![
             (item.span, String::new()), // Remove the manual implementation
-            (struct_span.shrink_to_lo(), "#[derive(Default)]\n".to_string()), // Add the derive attribute
+            (
+                struct_span.shrink_to_lo(),
+                format!("#[{derive_snippet}(Default)]\n{}", " ".repeat(indent_enum)),
+            ), // Add the derive attribute
         ];
 
         span_lint_and_then(cx, DERIVABLE_IMPLS, item.span, "this `impl` can be derived", |diag| {
@@ -145,11 +157,41 @@ fn check_struct<'tcx>(
     }
 }
 
-fn check_enum<'tcx>(cx: &LateContext<'tcx>, item: &'tcx Item<'_>, func_expr: &Expr<'_>, adt_def: AdtDef<'_>) {
-    if let ExprKind::Path(QPath::Resolved(None, p)) = &peel_blocks(func_expr).kind
-        && let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Const), id) = p.res
-        && let variant_id = cx.tcx.parent(id)
-        && let Some(variant_def) = adt_def.variants().iter().find(|v| v.def_id == variant_id)
+fn extract_enum_variant<'tcx>(
+    cx: &LateContext<'tcx>,
+    func_expr: &'tcx Expr<'tcx>,
+    adt_def: AdtDef<'tcx>,
+) -> Option<&'tcx VariantDef> {
+    match &peel_blocks(func_expr).kind {
+        ExprKind::Path(QPath::Resolved(None, p))
+            if let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Const), id) = p.res
+                && let variant_id = cx.tcx.parent(id)
+                && let Some(variant_def) = adt_def.variants().iter().find(|v| v.def_id == variant_id) =>
+        {
+            Some(variant_def)
+        },
+        ExprKind::Path(QPath::TypeRelative(ty, segment))
+            if let TyKind::Path(QPath::Resolved(None, p)) = &ty.kind
+                && let Res::SelfTyAlias {
+                    is_trait_impl: true, ..
+                } = p.res
+                && let variant_ident = segment.ident
+                && let Some(variant_def) = adt_def.variants().iter().find(|v| v.ident(cx.tcx) == variant_ident) =>
+        {
+            Some(variant_def)
+        },
+        _ => None,
+    }
+}
+
+fn check_enum<'tcx>(
+    cx: &LateContext<'tcx>,
+    item: &'tcx Item<'tcx>,
+    func_expr: &'tcx Expr<'tcx>,
+    adt_def: AdtDef<'tcx>,
+    is_const: bool,
+) {
+    if let Some(variant_def) = extract_enum_variant(cx, func_expr, adt_def)
         && variant_def.fields.is_empty()
         && !variant_def.is_field_list_non_exhaustive()
     {
@@ -158,11 +200,15 @@ fn check_enum<'tcx>(cx: &LateContext<'tcx>, item: &'tcx Item<'_>, func_expr: &Ex
         let variant_span = cx.tcx.def_span(variant_def.def_id);
         let indent_variant = indent_of(cx, variant_span).unwrap_or(0);
 
+        let Some(derive_snippet) = determine_derive_macro(cx, is_const) else {
+            return;
+        };
+
         let suggestions = vec![
             (item.span, String::new()), // Remove the manual implementation
             (
                 enum_span.shrink_to_lo(),
-                format!("#[derive(Default)]\n{}", " ".repeat(indent_enum)),
+                format!("#[{derive_snippet}(Default)]\n{}", " ".repeat(indent_enum)),
             ), // Add the derive attribute
             (
                 variant_span.shrink_to_lo(),
@@ -201,10 +247,20 @@ impl<'tcx> LateLintPass<'tcx> for DerivableImpls {
             && !attrs.iter().any(|attr| attr.doc_str().is_some())
             && cx.tcx.hir_attrs(impl_item_hir).is_empty()
         {
+            let is_const = of_trait.constness == hir::Constness::Const;
             if adt_def.is_struct() {
-                check_struct(cx, item, self_ty, func_expr, adt_def, args, cx.tcx.typeck_body(*b));
+                check_struct(
+                    cx,
+                    item,
+                    self_ty,
+                    func_expr,
+                    adt_def,
+                    args,
+                    cx.tcx.typeck_body(*b),
+                    is_const,
+                );
             } else if adt_def.is_enum() && self.msrv.meets(cx, msrvs::DEFAULT_ENUM_ATTRIBUTE) {
-                check_enum(cx, item, func_expr, adt_def);
+                check_enum(cx, item, func_expr, adt_def, is_const);
             }
         }
     }
diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index 182cb4e46d2bd..a5ec6777b4344 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::source::{reindent_multiline, snippet_indent, snippet_with_applicability, snippet_with_context};
 use clippy_utils::ty::is_copy;
 use clippy_utils::visitors::for_each_expr;
@@ -194,7 +194,17 @@ impl<'tcx> LateLintPass<'tcx> for HashMapPass {
         if let Some(sugg) = sugg {
             span_lint_and_sugg(cx, MAP_ENTRY, expr.span, lint_msg, "try", sugg, app);
         } else {
-            span_lint(cx, MAP_ENTRY, expr.span, lint_msg);
+            span_lint_and_help(
+                cx,
+                MAP_ENTRY,
+                expr.span,
+                lint_msg,
+                None,
+                format!(
+                    "consider using the `Entry` API: https://doc.rust-lang.org/std/collections/struct.{}.html#entry-api",
+                    map_ty.name()
+                ),
+            );
         }
     }
 }
@@ -254,35 +264,28 @@ fn try_parse_contains<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Optio
         _ => None,
     });
 
-    match expr.kind {
-        ExprKind::MethodCall(
-            _,
+    if let ExprKind::MethodCall(_, map, [arg], _) = expr.kind
+        && let Expr {
+            kind: ExprKind::AddrOf(_, _, key),
+            span: key_span,
+            ..
+        } = arg
+        && key_span.eq_ctxt(expr.span)
+    {
+        let id = cx.typeck_results().type_dependent_def_id(expr.hir_id)?;
+        let expr = ContainsExpr {
+            negated,
             map,
-            [
-                Expr {
-                    kind: ExprKind::AddrOf(_, _, key),
-                    span: key_span,
-                    ..
-                },
-            ],
-            _,
-        ) if key_span.eq_ctxt(expr.span) => {
-            let id = cx.typeck_results().type_dependent_def_id(expr.hir_id)?;
-            let expr = ContainsExpr {
-                negated,
-                map,
-                key,
-                call_ctxt: expr.span.ctxt(),
-            };
-            if cx.tcx.is_diagnostic_item(sym::btreemap_contains_key, id) {
-                Some((MapType::BTree, expr))
-            } else if cx.tcx.is_diagnostic_item(sym::hashmap_contains_key, id) {
-                Some((MapType::Hash, expr))
-            } else {
-                None
-            }
-        },
-        _ => None,
+            key,
+            call_ctxt: expr.span.ctxt(),
+        };
+        match cx.tcx.get_diagnostic_name(id) {
+            Some(sym::btreemap_contains_key) => Some((MapType::BTree, expr)),
+            Some(sym::hashmap_contains_key) => Some((MapType::Hash, expr)),
+            _ => None,
+        }
+    } else {
+        None
     }
 }
 
@@ -311,7 +314,9 @@ struct InsertExpr<'tcx> {
 fn try_parse_insert<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<InsertExpr<'tcx>> {
     if let ExprKind::MethodCall(_, map, [key, value], _) = expr.kind {
         let id = cx.typeck_results().type_dependent_def_id(expr.hir_id)?;
-        if cx.tcx.is_diagnostic_item(sym::btreemap_insert, id) || cx.tcx.is_diagnostic_item(sym::hashmap_insert, id) {
+        if let Some(insert) = cx.tcx.get_diagnostic_name(id)
+            && matches!(insert, sym::btreemap_insert | sym::hashmap_insert)
+        {
             Some(InsertExpr { map, key, value })
         } else {
             None
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 0eefc2f610969..2da1c2bad1174 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -12,6 +12,7 @@ use rustc_hir::attrs::AttributeKind;
 use rustc_hir::{BindingMode, Expr, ExprKind, FnRetTy, GenericArgs, Param, PatKind, QPath, Safety, TyKind, find_attr};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::adjustment::Adjust;
 use rustc_middle::ty::{
     self, Binder, ClosureKind, FnSig, GenericArg, GenericArgKind, List, Region, Ty, TypeVisitableExt, TypeckResults,
 };
@@ -148,10 +149,9 @@ fn check_closure<'tcx>(cx: &LateContext<'tcx>, outer_receiver: Option<&Expr<'tcx
             {
                 return;
             }
-            let callee_ty_adjusted = typeck
-                .expr_adjustments(callee)
-                .last()
-                .map_or(callee_ty, |a| a.target.peel_refs());
+
+            let callee_ty_adjustments = typeck.expr_adjustments(callee);
+            let callee_ty_adjusted = callee_ty_adjustments.last().map_or(callee_ty, |a| a.target);
 
             let sig = match callee_ty_adjusted.kind() {
                 ty::FnDef(def, _) => {
@@ -230,7 +230,20 @@ fn check_closure<'tcx>(cx: &LateContext<'tcx>, outer_receiver: Option<&Expr<'tcx
                                     },
                                     _ => (),
                                 }
+                            } else if let n_refs =
+                                callee_ty_adjustments
+                                    .iter()
+                                    .rev()
+                                    .fold(0, |acc, adjustment| match adjustment.kind {
+                                        Adjust::Deref(Some(_)) => acc + 1,
+                                        Adjust::Deref(_) if acc > 0 => acc + 1,
+                                        _ => acc,
+                                    })
+                                && n_refs > 0
+                            {
+                                snippet = format!("{}{snippet}", "*".repeat(n_refs));
                             }
+
                             let replace_with = match callee_ty_adjusted.kind() {
                                 ty::FnDef(def, _) => cx.tcx.def_descr(*def),
                                 _ => "function",
diff --git a/clippy_lints/src/float_literal.rs b/clippy_lints/src/float_literal.rs
index ccaf38aee4d88..6178addfff127 100644
--- a/clippy_lints/src/float_literal.rs
+++ b/clippy_lints/src/float_literal.rs
@@ -1,11 +1,12 @@
+use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::numeric_literal;
+use clippy_utils::{ExprUseNode, expr_use_ctxt, numeric_literal};
 use rustc_ast::ast::{LitFloatType, LitKind};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, FloatTy};
-use rustc_session::declare_lint_pass;
+use rustc_session::impl_lint_pass;
 use std::fmt;
 
 declare_clippy_lint! {
@@ -13,6 +14,8 @@ declare_clippy_lint! {
     /// Checks for float literals with a precision greater
     /// than that supported by the underlying type.
     ///
+    /// The lint is suppressed for literals with over `const_literal_digits_threshold` digits.
+    ///
     /// ### Why is this bad?
     /// Rust will truncate the literal silently.
     ///
@@ -58,7 +61,21 @@ declare_clippy_lint! {
     "lossy whole number float literals"
 }
 
-declare_lint_pass!(FloatLiteral => [EXCESSIVE_PRECISION, LOSSY_FLOAT_LITERAL]);
+pub struct FloatLiteral {
+    const_literal_digits_threshold: usize,
+}
+
+impl_lint_pass!(FloatLiteral => [
+    EXCESSIVE_PRECISION, LOSSY_FLOAT_LITERAL
+]);
+
+impl FloatLiteral {
+    pub fn new(conf: &'static Conf) -> Self {
+        Self {
+            const_literal_digits_threshold: conf.const_literal_digits_threshold,
+        }
+    }
+}
 
 impl<'tcx> LateLintPass<'tcx> for FloatLiteral {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
@@ -126,13 +143,25 @@ impl<'tcx> LateLintPass<'tcx> for FloatLiteral {
                         },
                     );
                 }
-            } else if digits > max as usize && count_digits(&float_str) < count_digits(sym_str) {
+            } else if digits > max as usize && count_digits(&float_str) < digits {
+                if digits >= self.const_literal_digits_threshold
+                    && matches!(expr_use_ctxt(cx, expr).use_node(cx), ExprUseNode::ConstStatic(_))
+                {
+                    // If a big enough number of digits is specified and it's a constant
+                    // we assume the user is definining a constant, and excessive precision is ok
+                    return;
+                }
                 span_lint_and_then(
                     cx,
                     EXCESSIVE_PRECISION,
                     expr.span,
                     "float has excessive precision",
                     |diag| {
+                        if digits >= self.const_literal_digits_threshold
+                            && let Some(let_stmt) = maybe_let_stmt(cx, expr)
+                        {
+                            diag.span_note(let_stmt.span, "consider making it a `const` item");
+                        }
                         diag.span_suggestion_verbose(
                             expr.span,
                             "consider changing the type or truncating it to",
@@ -196,3 +225,11 @@ impl FloatFormat {
         }
     }
 }
+
+fn maybe_let_stmt<'a>(cx: &LateContext<'a>, expr: &hir::Expr<'_>) -> Option<&'a hir::LetStmt<'a>> {
+    let parent = cx.tcx.parent_hir_node(expr.hir_id);
+    match parent {
+        hir::Node::LetStmt(let_stmt) => Some(let_stmt),
+        _ => None,
+    }
+}
diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index ca5ea90181493..5a40af4219426 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -535,7 +535,7 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
         def_id: LocalDefId,
     ) {
         let hir_id = cx.tcx.local_def_id_to_hir_id(def_id);
-        too_many_arguments::check_fn(cx, kind, decl, span, hir_id, self.too_many_arguments_threshold);
+        too_many_arguments::check_fn(cx, kind, decl, hir_id, def_id, self.too_many_arguments_threshold);
         too_many_lines::check_fn(cx, kind, body, span, def_id, self.too_many_lines_threshold);
         not_unsafe_ptr_arg_deref::check_fn(cx, kind, decl, body, def_id);
         misnamed_getters::check_fn(cx, kind, decl, body, span);
diff --git a/clippy_lints/src/functions/too_many_arguments.rs b/clippy_lints/src/functions/too_many_arguments.rs
index 48d050aa36aa0..6c3c3d354ecc9 100644
--- a/clippy_lints/src/functions/too_many_arguments.rs
+++ b/clippy_lints/src/functions/too_many_arguments.rs
@@ -1,5 +1,7 @@
 use rustc_abi::ExternAbi;
-use rustc_hir::{self as hir, intravisit};
+use rustc_hir as hir;
+use rustc_hir::def_id::LocalDefId;
+use rustc_hir::intravisit::FnKind;
 use rustc_lint::LateContext;
 use rustc_span::Span;
 
@@ -10,39 +12,18 @@ use super::TOO_MANY_ARGUMENTS;
 
 pub(super) fn check_fn(
     cx: &LateContext<'_>,
-    kind: intravisit::FnKind<'_>,
+    kind: FnKind<'_>,
     decl: &hir::FnDecl<'_>,
-    span: Span,
     hir_id: hir::HirId,
+    def_id: LocalDefId,
     too_many_arguments_threshold: u64,
 ) {
     // don't warn for implementations, it's not their fault
-    if !is_trait_impl_item(cx, hir_id) {
+    if !is_trait_impl_item(cx, hir_id)
         // don't lint extern functions decls, it's not their fault either
-        match kind {
-            intravisit::FnKind::Method(
-                _,
-                &hir::FnSig {
-                    header: hir::FnHeader {
-                        abi: ExternAbi::Rust, ..
-                    },
-                    ..
-                },
-            )
-            | intravisit::FnKind::ItemFn(
-                _,
-                _,
-                hir::FnHeader {
-                    abi: ExternAbi::Rust, ..
-                },
-            ) => check_arg_number(
-                cx,
-                decl,
-                span.with_hi(decl.output.span().hi()),
-                too_many_arguments_threshold,
-            ),
-            _ => {},
-        }
+        && kind.header().is_some_and(|header| header.abi == ExternAbi::Rust)
+    {
+        check_arg_number(cx, decl, cx.tcx.def_span(def_id), too_many_arguments_threshold);
     }
 }
 
diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index 7158f9419c1cc..b50d91f101463 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -2,16 +2,16 @@ use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::eager_or_lazy::switch_to_eager_eval;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::source::snippet_with_context;
+use clippy_utils::source::{snippet_with_applicability, snippet_with_context, walk_span_to_context};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{
     contains_return, expr_adjustment_requires_coercion, higher, is_else_clause, is_in_const_context, is_res_lang_ctor,
-    path_res, peel_blocks,
+    path_res, peel_blocks, sym,
 };
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::impl_lint_pass;
 
 declare_clippy_lint! {
@@ -71,21 +71,21 @@ impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
             && let ExprKind::Block(then_block, _) = then.kind
             && let Some(then_expr) = then_block.expr
             && let ExprKind::Call(then_call, [then_arg]) = then_expr.kind
-            && let ctxt = expr.span.ctxt()
-            && then_expr.span.ctxt() == ctxt
+            && !expr.span.from_expansion()
+            && !then_expr.span.from_expansion()
             && 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)
             && !is_in_const_context(cx)
-            && !expr.span.in_external_macro(cx.sess().source_map())
             && self.msrv.meets(cx, msrvs::BOOL_THEN)
             && !contains_return(then_block.stmts)
         {
             let method_name = if switch_to_eager_eval(cx, expr) && self.msrv.meets(cx, msrvs::BOOL_THEN_SOME) {
-                "then_some"
+                sym::then_some
             } else {
-                "then"
+                sym::then
             };
+            let ctxt = expr.span.ctxt();
 
             span_lint_and_then(
                 cx,
@@ -98,16 +98,18 @@ impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
                     }
 
                     let mut app = Applicability::MachineApplicable;
-                    let cond_snip = Sugg::hir_with_context(cx, cond, expr.span.ctxt(), "[condition]", &mut app)
+                    let cond_snip = Sugg::hir_with_context(cx, cond, ctxt, "[condition]", &mut app)
                         .maybe_paren()
                         .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 if method_name == "then" {
+                    let method_body = if let Some(first_stmt) = then_block.stmts.first()
+                        && let Some(first_stmt_span) = walk_span_to_context(first_stmt.span, ctxt)
+                    {
+                        let block_snippet =
+                            snippet_with_applicability(cx, first_stmt_span.until(then_expr.span), "..", &mut app);
+                        let closure = if method_name == sym::then { "|| " } else { "" };
+                        format!("{closure} {{ {} {arg_snip} }}", block_snippet.trim_end())
+                    } else if method_name == sym::then {
                         (std::borrow::Cow::Borrowed("|| ") + arg_snip).into_owned()
                     } else {
                         arg_snip.into_owned()
diff --git a/clippy_lints/src/instant_subtraction.rs b/clippy_lints/src/instant_subtraction.rs
index 91f65d0b79ca0..13117f60abd52 100644
--- a/clippy_lints/src/instant_subtraction.rs
+++ b/clippy_lints/src/instant_subtraction.rs
@@ -3,7 +3,7 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::sugg::Sugg;
-use clippy_utils::ty;
+use clippy_utils::{is_path_diagnostic_item, ty};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -107,8 +107,7 @@ impl LateLintPass<'_> for InstantSubtraction {
 
 fn is_instant_now_call(cx: &LateContext<'_>, expr_block: &'_ Expr<'_>) -> bool {
     if let ExprKind::Call(fn_expr, []) = expr_block.kind
-        && let Some(fn_id) = clippy_utils::path_def_id(cx, fn_expr)
-        && cx.tcx.is_diagnostic_item(sym::instant_now, fn_id)
+        && is_path_diagnostic_item(cx, fn_expr, sym::instant_now)
     {
         true
     } else {
diff --git a/clippy_lints/src/large_include_file.rs b/clippy_lints/src/large_include_file.rs
index 8707612fbdd0a..48ce1afc6e69b 100644
--- a/clippy_lints/src/large_include_file.rs
+++ b/clippy_lints/src/large_include_file.rs
@@ -64,8 +64,8 @@ impl LateLintPass<'_> for LargeIncludeFile {
             }
             && len as u64 > self.max_file_size
             && let Some(macro_call) = root_macro_call_first_node(cx, expr)
-            && (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))
+            && let Some(macro_name) = cx.tcx.get_diagnostic_name(macro_call.def_id)
+            && matches!(macro_name, sym::include_bytes_macro | sym::include_str_macro)
         {
             #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
             span_lint_and_then(
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 57deb011f2b0e..f44a5fdf715e5 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -355,12 +355,15 @@ fn parse_len_output<'tcx>(cx: &LateContext<'tcx>, sig: FnSig<'tcx>) -> Option<Le
             return Some(LenOutput::Integral);
         }
 
-        if let Res::Def(_, def_id) = res {
-            if cx.tcx.is_diagnostic_item(sym::Option, def_id) && is_first_generic_integral(segment) {
-                return Some(LenOutput::Option(def_id));
-            } else if cx.tcx.is_diagnostic_item(sym::Result, def_id) && is_first_generic_integral(segment) {
-                return Some(LenOutput::Result(def_id));
+        if let Res::Def(_, def_id) = res
+            && let Some(res) = match cx.tcx.get_diagnostic_name(def_id) {
+                Some(sym::Option) => Some(LenOutput::Option(def_id)),
+                Some(sym::Result) => Some(LenOutput::Result(def_id)),
+                _ => None,
             }
+            && is_first_generic_integral(segment)
+        {
+            return Some(res);
         }
 
         return None;
@@ -368,11 +371,10 @@ fn parse_len_output<'tcx>(cx: &LateContext<'tcx>, sig: FnSig<'tcx>) -> Option<Le
 
     match *sig.output().kind() {
         ty::Int(_) | ty::Uint(_) => Some(LenOutput::Integral),
-        ty::Adt(adt, subs) if cx.tcx.is_diagnostic_item(sym::Option, adt.did()) => {
-            subs.type_at(0).is_integral().then(|| LenOutput::Option(adt.did()))
-        },
-        ty::Adt(adt, subs) if cx.tcx.is_diagnostic_item(sym::Result, adt.did()) => {
-            subs.type_at(0).is_integral().then(|| LenOutput::Result(adt.did()))
+        ty::Adt(adt, subs) if subs.type_at(0).is_integral() => match cx.tcx.get_diagnostic_name(adt.did()) {
+            Some(sym::Option) => Some(LenOutput::Option(adt.did())),
+            Some(sym::Result) => Some(LenOutput::Result(adt.did())),
+            _ => None,
         },
         _ => None,
     }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c8594cf35e23e..a89cf3fdc1eee 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -84,6 +84,7 @@ mod attrs;
 mod await_holding_invalid;
 mod blocks_in_conditions;
 mod bool_assert_comparison;
+mod bool_comparison;
 mod bool_to_int_with_if;
 mod booleans;
 mod borrow_deref_ref;
@@ -474,10 +475,10 @@ pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Co
     store.register_late_pass(move |_| Box::new(types::Types::new(conf)));
     store.register_late_pass(move |_| Box::new(booleans::NonminimalBool::new(conf)));
     store.register_late_pass(|_| Box::new(enum_clike::UnportableVariant));
-    store.register_late_pass(|_| Box::new(float_literal::FloatLiteral));
+    store.register_late_pass(move |_| Box::new(float_literal::FloatLiteral::new(conf)));
     store.register_late_pass(|_| Box::new(ptr::Ptr));
     store.register_late_pass(|_| Box::new(needless_bool::NeedlessBool));
-    store.register_late_pass(|_| Box::new(needless_bool::BoolComparison));
+    store.register_late_pass(|_| Box::new(bool_comparison::BoolComparison));
     store.register_late_pass(|_| Box::new(needless_for_each::NeedlessForEach));
     store.register_late_pass(|_| Box::new(misc::LintPass));
     store.register_late_pass(|_| Box::new(eta_reduction::EtaReduction));
@@ -655,7 +656,7 @@ pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Co
     store.register_early_pass(move || Box::new(nonstandard_macro_braces::MacroBraces::new(conf)));
     store.register_late_pass(|_| Box::<macro_use::MacroUseImports>::default());
     store.register_late_pass(|_| Box::new(pattern_type_mismatch::PatternTypeMismatch));
-    store.register_late_pass(|_| Box::new(unwrap_in_result::UnwrapInResult));
+    store.register_late_pass(|_| Box::<unwrap_in_result::UnwrapInResult>::default());
     store.register_late_pass(|_| Box::new(semicolon_if_nothing_returned::SemicolonIfNothingReturned));
     store.register_late_pass(|_| Box::new(async_yields_async::AsyncYieldsAsync));
     let attrs = attr_storage.clone();
diff --git a/clippy_lints/src/loops/infinite_loop.rs b/clippy_lints/src/loops/infinite_loop.rs
index a71e6963f8ca2..74c0b17801898 100644
--- a/clippy_lints/src/loops/infinite_loop.rs
+++ b/clippy_lints/src/loops/infinite_loop.rs
@@ -4,7 +4,8 @@ use hir::intravisit::{Visitor, walk_expr};
 use rustc_ast::Label;
 use rustc_errors::Applicability;
 use rustc_hir::{
-    self as hir, Closure, ClosureKind, CoroutineDesugaring, CoroutineKind, Expr, ExprKind, FnRetTy, FnSig, Node, TyKind,
+    self as hir, Closure, ClosureKind, CoroutineDesugaring, CoroutineKind, CoroutineSource, Expr, ExprKind, FnRetTy,
+    FnSig, Node, TyKind,
 };
 use rustc_lint::{LateContext, LintContext};
 use rustc_span::sym;
@@ -73,7 +74,11 @@ fn is_inside_unawaited_async_block(cx: &LateContext<'_>, expr: &Expr<'_>) -> boo
         if let Node::Expr(Expr {
             kind:
                 ExprKind::Closure(Closure {
-                    kind: ClosureKind::Coroutine(CoroutineKind::Desugared(CoroutineDesugaring::Async, _)),
+                    kind:
+                        ClosureKind::Coroutine(CoroutineKind::Desugared(
+                            CoroutineDesugaring::Async,
+                            CoroutineSource::Block | CoroutineSource::Closure,
+                        )),
                     ..
                 }),
             ..
diff --git a/clippy_lints/src/loops/missing_spin_loop.rs b/clippy_lints/src/loops/missing_spin_loop.rs
index a9944d64ce2dd..8a2d0036203a2 100644
--- a/clippy_lints/src/loops/missing_spin_loop.rs
+++ b/clippy_lints/src/loops/missing_spin_loop.rs
@@ -1,10 +1,10 @@
 use super::MISSING_SPIN_LOOP;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::std_or_core;
+use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
 use rustc_hir::{Block, Expr, ExprKind};
 use rustc_lint::LateContext;
-use rustc_middle::ty;
 use rustc_span::sym;
 
 fn unpack_cond<'tcx>(cond: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
@@ -39,8 +39,8 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, body: &'
     ) = body.kind
         && let ExprKind::MethodCall(method, callee, ..) = unpack_cond(cond).kind
         && [sym::load, sym::compare_exchange, sym::compare_exchange_weak].contains(&method.ident.name)
-        && let ty::Adt(def, _args) = cx.typeck_results().expr_ty(callee).kind()
-        && cx.tcx.is_diagnostic_item(sym::AtomicBool, def.did())
+        && let callee_ty = cx.typeck_results().expr_ty(callee)
+        && is_type_diagnostic_item(cx, callee_ty, sym::AtomicBool)
         && let Some(std_or_core) = std_or_core(cx)
     {
         span_lint_and_sugg(
diff --git a/clippy_lints/src/loops/needless_range_loop.rs b/clippy_lints/src/loops/needless_range_loop.rs
index 7bb684d65bb42..11edb929d70b2 100644
--- a/clippy_lints/src/loops/needless_range_loop.rs
+++ b/clippy_lints/src/loops/needless_range_loop.rs
@@ -3,7 +3,7 @@ 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::{SpanlessEq, contains_name, higher, is_integer_const, sugg};
+use clippy_utils::{SpanlessEq, contains_name, higher, is_integer_const, peel_hir_expr_while, sugg};
 use rustc_ast::ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
 use rustc_errors::Applicability;
@@ -253,12 +253,38 @@ struct VarVisitor<'a, 'tcx> {
 
 impl<'tcx> VarVisitor<'_, 'tcx> {
     fn check(&mut self, idx: &'tcx Expr<'_>, seqexpr: &'tcx Expr<'_>, expr: &'tcx Expr<'_>) -> bool {
-        let index_used_directly = matches!(idx.kind, ExprKind::Path(_));
+        let mut used_cnt = 0;
+        // It is `true` if all indices are direct
+        let mut index_used_directly = true;
+
+        // Handle initial index
+        if is_local_used(self.cx, idx, self.var) {
+            used_cnt += 1;
+            index_used_directly &= matches!(idx.kind, ExprKind::Path(_));
+        }
+        // Handle nested indices
+        let seqexpr = peel_hir_expr_while(seqexpr, |e| {
+            if let ExprKind::Index(e, idx, _) = e.kind {
+                if is_local_used(self.cx, idx, self.var) {
+                    used_cnt += 1;
+                    index_used_directly &= matches!(idx.kind, ExprKind::Path(_));
+                }
+                Some(e)
+            } else {
+                None
+            }
+        });
+
+        match used_cnt {
+            0 => return true,
+            n if n > 1 => self.nonindex = true, // Optimize code like `a[i][i]`
+            _ => {},
+        }
+
         if let ExprKind::Path(ref seqpath) = seqexpr.kind
             // the indexed container is referenced by a name
             && let QPath::Resolved(None, seqvar) = *seqpath
             && seqvar.segments.len() == 1
-            && is_local_used(self.cx, idx, self.var)
         {
             if self.prefer_mutable {
                 self.indexed_mut.insert(seqvar.segments[0].ident.name);
@@ -312,7 +338,6 @@ impl<'tcx> VarVisitor<'_, 'tcx> {
 impl<'tcx> Visitor<'tcx> for VarVisitor<'_, 'tcx> {
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
         if let ExprKind::MethodCall(meth, args_0, [args_1, ..], _) = &expr.kind
-            // a range index op
             && let Some(trait_id) = self
                 .cx
                 .typeck_results()
diff --git a/clippy_lints/src/loops/unused_enumerate_index.rs b/clippy_lints/src/loops/unused_enumerate_index.rs
index 51e21aa9734ed..13b93d2c0097b 100644
--- a/clippy_lints/src/loops/unused_enumerate_index.rs
+++ b/clippy_lints/src/loops/unused_enumerate_index.rs
@@ -1,12 +1,12 @@
 use super::UNUSED_ENUMERATE_INDEX;
 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::def::DefKind;
 use rustc_hir::{Expr, ExprKind, Pat, PatKind};
 use rustc_lint::LateContext;
-use rustc_middle::ty;
 use rustc_span::sym;
 
 /// Checks for the `UNUSED_ENUMERATE_INDEX` lint.
@@ -17,8 +17,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, pat: &Pat<'tcx>, arg: &Expr<'_
         && let ExprKind::MethodCall(_method, self_arg, [], _) = arg.kind
         && let ty = cx.typeck_results().expr_ty(arg)
         && pat_is_wild(cx, &index.kind, body)
-        && let ty::Adt(base, _) = *ty.kind()
-        && cx.tcx.is_diagnostic_item(sym::Enumerate, base.did())
+        && is_type_diagnostic_item(cx, ty, sym::Enumerate)
         && let Some((DefKind::AssocFn, call_id)) = cx.typeck_results().type_dependent_def(arg.hir_id)
         && cx.tcx.is_diagnostic_item(sym::enumerate_method, call_id)
     {
diff --git a/clippy_lints/src/manual_is_ascii_check.rs b/clippy_lints/src/manual_is_ascii_check.rs
index ac8c88f02057b..2eebb2430fd94 100644
--- a/clippy_lints/src/manual_is_ascii_check.rs
+++ b/clippy_lints/src/manual_is_ascii_check.rs
@@ -97,11 +97,12 @@ impl<'tcx> LateLintPass<'tcx> for ManualIsAsciiCheck {
             return;
         }
 
-        if let Some(macro_call) = matching_root_macro_call(cx, expr.span, sym::matches_macro) {
-            if let ExprKind::Match(recv, [arm, ..], _) = expr.kind {
-                let range = check_pat(&arm.pat.kind);
-                check_is_ascii(cx, macro_call.span, recv, &range, None);
-            }
+        let (arg, span, range) = if let Some(macro_call) = matching_root_macro_call(cx, expr.span, sym::matches_macro)
+            && let ExprKind::Match(recv, [arm, ..], _) = expr.kind
+        {
+            let recv = peel_ref_operators(cx, recv);
+            let range = check_pat(&arm.pat.kind);
+            (recv, macro_call.span, range)
         } else if let ExprKind::MethodCall(path, receiver, [arg], ..) = expr.kind
             && path.ident.name == sym::contains
             && let Some(higher::Range {
@@ -112,10 +113,14 @@ impl<'tcx> LateLintPass<'tcx> for ManualIsAsciiCheck {
             && !matches!(cx.typeck_results().expr_ty(arg).peel_refs().kind(), ty::Param(_))
         {
             let arg = peel_ref_operators(cx, arg);
-            let ty_sugg = get_ty_sugg(cx, arg);
             let range = check_expr_range(start, end);
-            check_is_ascii(cx, expr.span, arg, &range, ty_sugg);
-        }
+            (arg, expr.span, range)
+        } else {
+            return;
+        };
+
+        let ty_sugg = get_ty_sugg(cx, arg);
+        check_is_ascii(cx, span, arg, &range, ty_sugg);
     }
 }
 
@@ -146,9 +151,8 @@ fn check_is_ascii(
         CharRange::HexDigit => "is_ascii_hexdigit",
         CharRange::Otherwise | CharRange::LowerHexLetter | CharRange::UpperHexLetter => return,
     };
-    let default_snip = "..";
     let mut app = Applicability::MachineApplicable;
-    let recv = Sugg::hir_with_context(cx, recv, span.ctxt(), default_snip, &mut app).maybe_paren();
+    let recv = Sugg::hir_with_context(cx, recv, span.ctxt(), "_", &mut app).maybe_paren();
     let mut suggestion = vec![(span, format!("{recv}.{sugg}()"))];
     if let Some((ty_span, ty)) = ty_sugg {
         suggestion.push((ty_span, format!("{recv}: {ty}")));
@@ -182,7 +186,7 @@ fn check_pat(pat_kind: &PatKind<'_>) -> CharRange {
                 CharRange::Otherwise
             }
         },
-        PatKind::Range(Some(start), Some(end), kind) if *kind == RangeEnd::Included => check_range(start, end),
+        PatKind::Range(Some(start), Some(end), RangeEnd::Included) => check_range(start, end),
         _ => CharRange::Otherwise,
     }
 }
diff --git a/clippy_lints/src/manual_retain.rs b/clippy_lints/src/manual_retain.rs
index 98e8b1f5cf92c..7fb88763e640f 100644
--- a/clippy_lints/src/manual_retain.rs
+++ b/clippy_lints/src/manual_retain.rs
@@ -123,8 +123,8 @@ fn check_iter(
 ) {
     if let hir::ExprKind::MethodCall(_, filter_expr, [], _) = &target_expr.kind
         && let Some(copied_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id)
-        && (cx.tcx.is_diagnostic_item(sym::iter_copied, copied_def_id)
-            || cx.tcx.is_diagnostic_item(sym::iter_cloned, copied_def_id))
+        && let Some(copied_name) = cx.tcx.get_diagnostic_name(copied_def_id)
+        && matches!(copied_name, sym::iter_copied | sym::iter_cloned)
         && let hir::ExprKind::MethodCall(_, iter_expr, [_], _) = &filter_expr.kind
         && let Some(filter_def_id) = cx.typeck_results().type_dependent_def_id(filter_expr.hir_id)
         && cx.tcx.is_diagnostic_item(sym::iter_filter, filter_def_id)
@@ -243,9 +243,9 @@ fn make_sugg(
 }
 
 fn match_acceptable_sym(cx: &LateContext<'_>, collect_def_id: DefId) -> bool {
-    ACCEPTABLE_METHODS
-        .iter()
-        .any(|&method| cx.tcx.is_diagnostic_item(method, collect_def_id))
+    cx.tcx
+        .get_diagnostic_name(collect_def_id)
+        .is_some_and(|collect_name| ACCEPTABLE_METHODS.contains(&collect_name))
 }
 
 fn match_acceptable_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>, msrv: Msrv) -> bool {
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index 6bf43a1c6d47c..07cce4046ca4f 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -75,12 +75,10 @@ impl<'tcx> LateLintPass<'tcx> for ManualStrip {
             && let ExprKind::Path(target_path) = &target_arg.kind
             && let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(cond.hir_id)
         {
-            let strip_kind = if cx.tcx.is_diagnostic_item(sym::str_starts_with, method_def_id) {
-                StripKind::Prefix
-            } else if cx.tcx.is_diagnostic_item(sym::str_ends_with, method_def_id) {
-                StripKind::Suffix
-            } else {
-                return;
+            let strip_kind = match cx.tcx.get_diagnostic_name(method_def_id) {
+                Some(sym::str_starts_with) => StripKind::Prefix,
+                Some(sym::str_ends_with) => StripKind::Suffix,
+                _ => return,
             };
             let target_res = cx.qpath_res(target_path, target_arg.hir_id);
             if target_res == Res::Err {
diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs
index af6a1b07a4929..39e5289c62ae4 100644
--- a/clippy_lints/src/map_unit_fn.rs
+++ b/clippy_lints/src/map_unit_fn.rs
@@ -116,8 +116,10 @@ fn is_unit_expression(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
 /// The expression inside a closure may or may not have surrounding braces and
 /// semicolons, which causes problems when generating a suggestion. Given an
 /// expression that evaluates to '()' or '!', recursively remove useless braces
-/// and semi-colons until is suitable for including in the suggestion template
-fn reduce_unit_expression(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<Span> {
+/// and semi-colons until is suitable for including in the suggestion template.
+/// The `bool` is `true` when the resulting `span` needs to be enclosed in an
+/// `unsafe` block.
+fn reduce_unit_expression(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<(Span, bool)> {
     if !is_unit_expression(cx, expr) {
         return None;
     }
@@ -125,22 +127,24 @@ fn reduce_unit_expression(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<
     match expr.kind {
         hir::ExprKind::Call(_, _) | hir::ExprKind::MethodCall(..) => {
             // Calls can't be reduced any more
-            Some(expr.span)
+            Some((expr.span, false))
         },
         hir::ExprKind::Block(block, _) => {
+            let is_unsafe = matches!(block.rules, hir::BlockCheckMode::UnsafeBlock(_));
             match (block.stmts, block.expr.as_ref()) {
                 ([], Some(inner_expr)) => {
                     // If block only contains an expression,
                     // reduce `{ X }` to `X`
                     reduce_unit_expression(cx, inner_expr)
+                        .map(|(span, inner_is_unsafe)| (span, inner_is_unsafe || is_unsafe))
                 },
                 ([inner_stmt], None) => {
                     // If block only contains statements,
                     // reduce `{ X; }` to `X` or `X;`
                     match inner_stmt.kind {
-                        hir::StmtKind::Let(local) => Some(local.span),
-                        hir::StmtKind::Expr(e) => Some(e.span),
-                        hir::StmtKind::Semi(..) => Some(inner_stmt.span),
+                        hir::StmtKind::Let(local) => Some((local.span, is_unsafe)),
+                        hir::StmtKind::Expr(e) => Some((e.span, is_unsafe)),
+                        hir::StmtKind::Semi(..) => Some((inner_stmt.span, is_unsafe)),
                         hir::StmtKind::Item(..) => None,
                     }
                 },
@@ -228,10 +232,11 @@ fn lint_map_unit_fn(
         let msg = suggestion_msg("closure", map_type);
 
         span_lint_and_then(cx, lint, expr.span, msg, |diag| {
-            if let Some(reduced_expr_span) = reduce_unit_expression(cx, closure_expr) {
+            if let Some((reduced_expr_span, is_unsafe)) = reduce_unit_expression(cx, closure_expr) {
                 let mut applicability = Applicability::MachineApplicable;
+                let (prefix_is_unsafe, suffix_is_unsafe) = if is_unsafe { ("unsafe { ", " }") } else { ("", "") };
                 let suggestion = format!(
-                    "if let {0}({1}) = {2} {{ {3} }}",
+                    "if let {0}({1}) = {2} {{ {prefix_is_unsafe}{3}{suffix_is_unsafe} }}",
                     variant,
                     snippet_with_applicability(cx, binding.pat.span, "_", &mut applicability),
                     snippet_with_applicability(cx, var_arg.span, "_", &mut applicability),
diff --git a/clippy_lints/src/matches/collapsible_match.rs b/clippy_lints/src/matches/collapsible_match.rs
index 5b50efad3e44e..aaf559fc4439e 100644
--- a/clippy_lints/src/matches/collapsible_match.rs
+++ b/clippy_lints/src/matches/collapsible_match.rs
@@ -4,20 +4,22 @@ use clippy_utils::msrvs::Msrv;
 use clippy_utils::source::snippet;
 use clippy_utils::visitors::is_local_used;
 use clippy_utils::{
-    SpanlessEq, is_res_lang_ctor, is_unit_expr, path_to_local, peel_blocks_with_stmt, peel_ref_operators,
+    SpanlessEq, get_ref_operators, is_res_lang_ctor, is_unit_expr, path_to_local, peel_blocks_with_stmt,
+    peel_ref_operators,
 };
+use rustc_ast::BorrowKind;
 use rustc_errors::MultiSpan;
 use rustc_hir::LangItem::OptionNone;
-use rustc_hir::{Arm, Expr, HirId, Pat, PatExpr, PatExprKind, PatKind};
+use rustc_hir::{Arm, Expr, ExprKind, HirId, Pat, PatExpr, PatExprKind, PatKind};
 use rustc_lint::LateContext;
 use rustc_span::Span;
 
 use super::{COLLAPSIBLE_MATCH, pat_contains_disallowed_or};
 
-pub(super) fn check_match<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], msrv: Msrv) {
+pub(super) fn check_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arms: &'tcx [Arm<'_>], msrv: Msrv) {
     if let Some(els_arm) = arms.iter().rfind(|arm| arm_is_wild_like(cx, arm)) {
         for arm in arms {
-            check_arm(cx, true, arm.pat, arm.body, arm.guard, Some(els_arm.body), msrv);
+            check_arm(cx, true, arm.pat, expr, arm.body, arm.guard, Some(els_arm.body), msrv);
         }
     }
 }
@@ -27,15 +29,18 @@ pub(super) fn check_if_let<'tcx>(
     pat: &'tcx Pat<'_>,
     body: &'tcx Expr<'_>,
     else_expr: Option<&'tcx Expr<'_>>,
+    let_expr: &'tcx Expr<'_>,
     msrv: Msrv,
 ) {
-    check_arm(cx, false, pat, body, None, else_expr, msrv);
+    check_arm(cx, false, pat, let_expr, body, None, else_expr, msrv);
 }
 
+#[allow(clippy::too_many_arguments)]
 fn check_arm<'tcx>(
     cx: &LateContext<'tcx>,
     outer_is_match: bool,
     outer_pat: &'tcx Pat<'tcx>,
+    outer_cond: &'tcx Expr<'tcx>,
     outer_then_body: &'tcx Expr<'tcx>,
     outer_guard: Option<&'tcx Expr<'tcx>>,
     outer_else_body: Option<&'tcx Expr<'tcx>>,
@@ -82,6 +87,9 @@ fn check_arm<'tcx>(
             },
             IfLetOrMatch::Match(_, arms, ..) => !arms.iter().any(|arm| is_local_used(cx, arm, binding_id)),
         }
+        // Check if the inner expression contains any borrows/dereferences
+        && let ref_types = get_ref_operators(cx, inner_scrutinee)
+        && let Some(method) = build_ref_method_chain(ref_types)
     {
         let msg = format!(
             "this `{}` can be collapsed into the outer `{}`",
@@ -103,6 +111,10 @@ fn check_arm<'tcx>(
             let mut help_span = MultiSpan::from_spans(vec![binding_span, inner_then_pat.span]);
             help_span.push_span_label(binding_span, "replace this binding");
             help_span.push_span_label(inner_then_pat.span, format!("with this pattern{replace_msg}"));
+            if !method.is_empty() {
+                let outer_cond_msg = format!("use: `{}{}`", snippet(cx, outer_cond.span, ".."), method);
+                help_span.push_span_label(outer_cond.span, outer_cond_msg);
+            }
             diag.span_help(
                 help_span,
                 "the outer pattern can be modified to include the inner pattern",
@@ -148,3 +160,30 @@ fn find_pat_binding_and_is_innermost_parent_pat_struct(pat: &Pat<'_>, hir_id: Hi
     });
     (span, is_innermost_parent_pat_struct)
 }
+
+/// Builds a chain of reference-manipulation method calls (e.g., `.as_ref()`, `.as_mut()`,
+/// `.copied()`) based on reference operators
+fn build_ref_method_chain(expr: Vec<&Expr<'_>>) -> Option<String> {
+    let mut req_method_calls = String::new();
+
+    for ref_operator in expr {
+        match ref_operator.kind {
+            ExprKind::AddrOf(BorrowKind::Raw, _, _) => {
+                return None;
+            },
+            ExprKind::AddrOf(_, m, _) if m.is_mut() => {
+                req_method_calls.push_str(".as_mut()");
+            },
+            ExprKind::AddrOf(_, _, _) => {
+                req_method_calls.push_str(".as_ref()");
+            },
+            // Deref operator is the only operator that this function should have received
+            ExprKind::Unary(_, _) => {
+                req_method_calls.push_str(".copied()");
+            },
+            _ => (),
+        }
+    }
+
+    Some(req_method_calls)
+}
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index c128fc40b7334..6f49c5524118d 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -1073,7 +1073,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                 significant_drop_in_scrutinee::check_match(cx, expr, ex, arms, source);
             }
 
-            collapsible_match::check_match(cx, arms, self.msrv);
+            collapsible_match::check_match(cx, ex, arms, self.msrv);
             if !from_expansion {
                 // These don't depend on a relationship between multiple arms
                 match_wild_err_arm::check(cx, ex, arms);
@@ -1137,7 +1137,14 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                 match_ref_pats::check(cx, ex, arms.iter().map(|el| el.pat), expr);
             }
         } else if let Some(if_let) = higher::IfLet::hir(cx, expr) {
-            collapsible_match::check_if_let(cx, if_let.let_pat, if_let.if_then, if_let.if_else, self.msrv);
+            collapsible_match::check_if_let(
+                cx,
+                if_let.let_pat,
+                if_let.if_then,
+                if_let.if_else,
+                if_let.let_expr,
+                self.msrv,
+            );
             significant_drop_in_scrutinee::check_if_let(cx, expr, if_let.let_expr, if_let.if_then, if_let.if_else);
             if !from_expansion {
                 if let Some(else_expr) = if_let.if_else {
diff --git a/clippy_lints/src/matches/significant_drop_in_scrutinee.rs b/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
index 027dd7ce0534a..81fecc87256c4 100644
--- a/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
+++ b/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
@@ -226,11 +226,12 @@ impl<'a, 'tcx> SigDropChecker<'a, 'tcx> {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug, Default)]
 enum SigDropHolder {
     /// No values with significant drop present in this expression.
     ///
     /// Expressions that we've emitted lints do not count.
+    #[default]
     None,
     /// Some field in this expression references to values with significant drop.
     ///
@@ -244,12 +245,6 @@ enum SigDropHolder {
     Moved,
 }
 
-impl Default for SigDropHolder {
-    fn default() -> Self {
-        Self::None
-    }
-}
-
 struct SigDropHelper<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     parent_expr: Option<&'tcx Expr<'tcx>>,
diff --git a/clippy_lints/src/matches/try_err.rs b/clippy_lints/src/matches/try_err.rs
index ff7769af1df41..af90cb5e67334 100644
--- a/clippy_lints/src/matches/try_err.rs
+++ b/clippy_lints/src/matches/try_err.rs
@@ -1,6 +1,6 @@
 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::ty::option_arg_ty;
 use clippy_utils::{get_parent_expr, is_res_lang_ctor, path_res};
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::ResultErr;
@@ -28,25 +28,15 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, scrutine
         && is_res_lang_ctor(cx, path_res(cx, err_fun), ResultErr)
         && let Some(return_ty) = find_return_type(cx, &expr.kind)
     {
-        let prefix;
-        let suffix;
-        let err_ty;
-
-        if let Some(ty) = result_error_type(cx, return_ty) {
-            prefix = "Err(";
-            suffix = ")";
-            err_ty = ty;
+        let (prefix, suffix, err_ty) = if let Some(ty) = result_error_type(cx, return_ty) {
+            ("Err(", ")", ty)
         } else if let Some(ty) = poll_result_error_type(cx, return_ty) {
-            prefix = "Poll::Ready(Err(";
-            suffix = "))";
-            err_ty = ty;
+            ("Poll::Ready(Err(", "))", ty)
         } else if let Some(ty) = poll_option_result_error_type(cx, return_ty) {
-            prefix = "Poll::Ready(Some(Err(";
-            suffix = ")))";
-            err_ty = ty;
+            ("Poll::Ready(Some(Err(", ")))", ty)
         } else {
             return;
-        }
+        };
 
         span_lint_and_then(
             cx,
@@ -88,8 +78,8 @@ fn find_return_type<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx ExprKind<'_>) -> O
 
 /// Extracts the error type from Result<T, E>.
 fn result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
-    if let ty::Adt(_, subst) = ty.kind()
-        && is_type_diagnostic_item(cx, ty, sym::Result)
+    if let ty::Adt(def, subst) = ty.kind()
+        && cx.tcx.is_diagnostic_item(sym::Result, def.did())
     {
         Some(subst.type_at(1))
     } else {
@@ -101,11 +91,9 @@ fn result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'t
 fn poll_result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
     if let ty::Adt(def, subst) = ty.kind()
         && cx.tcx.lang_items().get(LangItem::Poll) == Some(def.did())
-        && let ready_ty = subst.type_at(0)
-        && let ty::Adt(ready_def, ready_subst) = ready_ty.kind()
-        && cx.tcx.is_diagnostic_item(sym::Result, ready_def.did())
     {
-        Some(ready_subst.type_at(1))
+        let ready_ty = subst.type_at(0);
+        result_error_type(cx, ready_ty)
     } else {
         None
     }
@@ -116,13 +104,9 @@ fn poll_option_result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) ->
     if let ty::Adt(def, subst) = ty.kind()
         && cx.tcx.lang_items().get(LangItem::Poll) == Some(def.did())
         && let ready_ty = subst.type_at(0)
-        && let ty::Adt(ready_def, ready_subst) = ready_ty.kind()
-        && cx.tcx.is_diagnostic_item(sym::Option, ready_def.did())
-        && let some_ty = ready_subst.type_at(0)
-        && let ty::Adt(some_def, some_subst) = some_ty.kind()
-        && cx.tcx.is_diagnostic_item(sym::Result, some_def.did())
+        && let Some(some_ty) = option_arg_ty(cx, ready_ty)
     {
-        Some(some_subst.type_at(1))
+        result_error_type(cx, some_ty)
     } else {
         None
     }
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index 28efd2038b387..e39916f733d59 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -215,7 +215,8 @@ fn check_replace_with_uninit(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'
         && let ExprKind::Path(ref repl_func_qpath) = repl_func.kind
         && let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id()
     {
-        if cx.tcx.is_diagnostic_item(sym::mem_uninitialized, repl_def_id) {
+        let repl_name = cx.tcx.get_diagnostic_name(repl_def_id);
+        if repl_name == Some(sym::mem_uninitialized) {
             let Some(top_crate) = std_or_core(cx) else { return };
             let mut applicability = Applicability::MachineApplicable;
             span_lint_and_sugg(
@@ -230,9 +231,7 @@ fn check_replace_with_uninit(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'
                 ),
                 applicability,
             );
-        } else if cx.tcx.is_diagnostic_item(sym::mem_zeroed, repl_def_id)
-            && !cx.typeck_results().expr_ty(src).is_primitive()
-        {
+        } else if repl_name == Some(sym::mem_zeroed) && !cx.typeck_results().expr_ty(src).is_primitive() {
             span_lint_and_help(
                 cx,
                 MEM_REPLACE_WITH_UNINIT,
diff --git a/clippy_lints/src/methods/clone_on_ref_ptr.rs b/clippy_lints/src/methods/clone_on_ref_ptr.rs
index 96e2de0dc1cbd..65583c6a9811e 100644
--- a/clippy_lints/src/methods/clone_on_ref_ptr.rs
+++ b/clippy_lints/src/methods/clone_on_ref_ptr.rs
@@ -24,9 +24,10 @@ pub(super) fn check(
         && let Some(name) = cx.tcx.get_diagnostic_name(adt.did())
     {
         let caller_type = match name {
-            sym::Rc => "Rc",
-            sym::Arc => "Arc",
-            sym::RcWeak | sym::ArcWeak => "Weak",
+            sym::Rc => "std::rc::Rc",
+            sym::Arc => "std::sync::Arc",
+            sym::RcWeak => "std::rc::Weak",
+            sym::ArcWeak => "std::sync::Weak",
             _ => return,
         };
         span_lint_and_then(
diff --git a/clippy_lints/src/methods/filter_map.rs b/clippy_lints/src/methods/filter_map.rs
index 5b8457bdd1640..2da0f8341b17b 100644
--- a/clippy_lints/src/methods/filter_map.rs
+++ b/clippy_lints/src/methods/filter_map.rs
@@ -233,18 +233,16 @@ impl<'tcx> OffendingFilterExpr<'tcx> {
             // the latter only calls `effect` once
             let side_effect_expr_span = receiver.can_have_side_effects().then_some(receiver.span);
 
-            if cx.tcx.is_diagnostic_item(sym::Option, recv_ty.did()) && path.ident.name == sym::is_some {
-                Some(Self::IsSome {
+            match (cx.tcx.get_diagnostic_name(recv_ty.did()), path.ident.name) {
+                (Some(sym::Option), sym::is_some) => Some(Self::IsSome {
                     receiver,
                     side_effect_expr_span,
-                })
-            } else if cx.tcx.is_diagnostic_item(sym::Result, recv_ty.did()) && path.ident.name == sym::is_ok {
-                Some(Self::IsOk {
+                }),
+                (Some(sym::Result), sym::is_ok) => Some(Self::IsOk {
                     receiver,
                     side_effect_expr_span,
-                })
-            } else {
-                None
+                }),
+                _ => None,
             }
         } else if matching_root_macro_call(cx, expr.span, sym::matches_macro).is_some()
             // we know for a fact that the wildcard pattern is the second arm
diff --git a/clippy_lints/src/methods/iter_out_of_bounds.rs b/clippy_lints/src/methods/iter_out_of_bounds.rs
index 9a62b719a8fb8..fa8f9d640ee6e 100644
--- a/clippy_lints/src/methods/iter_out_of_bounds.rs
+++ b/clippy_lints/src/methods/iter_out_of_bounds.rs
@@ -24,32 +24,29 @@ fn get_iterator_length<'tcx>(cx: &LateContext<'tcx>, iter: &'tcx Expr<'tcx>) ->
     let ty::Adt(adt, substs) = cx.typeck_results().expr_ty(iter).kind() else {
         return None;
     };
-    let did = adt.did();
 
-    if cx.tcx.is_diagnostic_item(sym::ArrayIntoIter, did) {
-        // For array::IntoIter<T, const N: usize>, the length is the second generic
-        // parameter.
-        substs.const_at(1).try_to_target_usize(cx.tcx).map(u128::from)
-    } else if cx.tcx.is_diagnostic_item(sym::SliceIter, did)
-        && let ExprKind::MethodCall(_, recv, ..) = iter.kind
-    {
-        if let ty::Array(_, len) = cx.typeck_results().expr_ty(recv).peel_refs().kind() {
-            // For slice::Iter<'_, T>, the receiver might be an array literal: [1,2,3].iter().skip(..)
-            len.try_to_target_usize(cx.tcx).map(u128::from)
-        } else if let Some(args) = VecArgs::hir(cx, expr_or_init(cx, recv)) {
-            match args {
-                VecArgs::Vec(vec) => vec.len().try_into().ok(),
-                VecArgs::Repeat(_, len) => expr_as_u128(cx, len),
+    match cx.tcx.get_diagnostic_name(adt.did()) {
+        Some(sym::ArrayIntoIter) => {
+            // For array::IntoIter<T, const N: usize>, the length is the second generic
+            // parameter.
+            substs.const_at(1).try_to_target_usize(cx.tcx).map(u128::from)
+        },
+        Some(sym::SliceIter) if let ExprKind::MethodCall(_, recv, ..) = iter.kind => {
+            if let ty::Array(_, len) = cx.typeck_results().expr_ty(recv).peel_refs().kind() {
+                // For slice::Iter<'_, T>, the receiver might be an array literal: [1,2,3].iter().skip(..)
+                len.try_to_target_usize(cx.tcx).map(u128::from)
+            } else if let Some(args) = VecArgs::hir(cx, expr_or_init(cx, recv)) {
+                match args {
+                    VecArgs::Vec(vec) => vec.len().try_into().ok(),
+                    VecArgs::Repeat(_, len) => expr_as_u128(cx, len),
+                }
+            } else {
+                None
             }
-        } else {
-            None
-        }
-    } else if cx.tcx.is_diagnostic_item(sym::IterEmpty, did) {
-        Some(0)
-    } else if cx.tcx.is_diagnostic_item(sym::IterOnce, did) {
-        Some(1)
-    } else {
-        None
+        },
+        Some(sym::IterEmpty) => Some(0),
+        Some(sym::IterOnce) => Some(1),
+        _ => None,
     }
 }
 
diff --git a/clippy_lints/src/methods/map_flatten.rs b/clippy_lints/src/methods/map_flatten.rs
index f7bb8c1d696de..750f933330a25 100644
--- a/clippy_lints/src/methods/map_flatten.rs
+++ b/clippy_lints/src/methods/map_flatten.rs
@@ -50,10 +50,10 @@ fn try_get_caller_ty_name_and_method_name(
         }
     } else {
         if let ty::Adt(adt, _) = cx.typeck_results().expr_ty(caller_expr).kind() {
-            if cx.tcx.is_diagnostic_item(sym::Option, adt.did()) {
-                return Some(("Option", "and_then"));
-            } else if cx.tcx.is_diagnostic_item(sym::Result, adt.did()) {
-                return Some(("Result", "and_then"));
+            match cx.tcx.get_diagnostic_name(adt.did()) {
+                Some(sym::Option) => return Some(("Option", "and_then")),
+                Some(sym::Result) => return Some(("Result", "and_then")),
+                _ => {},
             }
         }
         None
diff --git a/clippy_lints/src/methods/map_identity.rs b/clippy_lints/src/methods/map_identity.rs
index 98def66ca1499..a98cfff8bfbd1 100644
--- a/clippy_lints/src/methods/map_identity.rs
+++ b/clippy_lints/src/methods/map_identity.rs
@@ -1,14 +1,16 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{is_expr_untyped_identity_function, is_trait_method, path_to_local};
-use rustc_ast::BindingMode;
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::ty::{is_copy, is_type_diagnostic_item};
+use clippy_utils::{is_expr_untyped_identity_function, is_mutable, is_trait_method, path_to_local_with_projections};
 use rustc_errors::Applicability;
-use rustc_hir::{self as hir, Node, PatKind};
-use rustc_lint::LateContext;
+use rustc_hir::{self as hir, ExprKind, Node, PatKind};
+use rustc_lint::{LateContext, LintContext};
 use rustc_span::{Span, Symbol, sym};
 
 use super::MAP_IDENTITY;
 
+const MSG: &str = "unnecessary map of the identity function";
+
 pub(super) fn check(
     cx: &LateContext<'_>,
     expr: &hir::Expr<'_>,
@@ -23,26 +25,70 @@ pub(super) fn check(
         || is_type_diagnostic_item(cx, caller_ty, sym::Result)
         || is_type_diagnostic_item(cx, caller_ty, sym::Option))
         && is_expr_untyped_identity_function(cx, map_arg)
-        && let Some(sugg_span) = expr.span.trim_start(caller.span)
+        && let Some(call_span) = expr.span.trim_start(caller.span)
     {
-        // If the result of `.map(identity)` is used as a mutable reference,
-        // the caller must not be an immutable binding.
-        if cx.typeck_results().expr_ty_adjusted(expr).is_mutable_ptr()
-            && let Some(hir_id) = path_to_local(caller)
-            && let Node::Pat(pat) = cx.tcx.hir_node(hir_id)
-            && !matches!(pat.kind, PatKind::Binding(BindingMode::MUT, ..))
-        {
-            return;
-        }
+        let main_sugg = (call_span, String::new());
+        let mut app = if is_copy(cx, caller_ty) {
+            // there is technically a behavioral change here for `Copy` iterators, where
+            // `iter.map(|x| x).next()` would mutate a temporary copy of the iterator and
+            // changing it to `iter.next()` mutates iter directly
+            Applicability::Unspecified
+        } else {
+            Applicability::MachineApplicable
+        };
+
+        let needs_to_be_mutable = cx.typeck_results().expr_ty_adjusted(expr).is_mutable_ptr();
+        if needs_to_be_mutable && !is_mutable(cx, caller) {
+            if let Some(hir_id) = path_to_local_with_projections(caller)
+                && let Node::Pat(pat) = cx.tcx.hir_node(hir_id)
+                && let PatKind::Binding(_, _, ident, _) = pat.kind
+            {
+                // We can reach the binding -- suggest making it mutable
+                let suggs = vec![main_sugg, (ident.span.shrink_to_lo(), String::from("mut "))];
+
+                let ident = snippet_with_applicability(cx.sess(), ident.span, "_", &mut app);
 
-        span_lint_and_sugg(
-            cx,
-            MAP_IDENTITY,
-            sugg_span,
-            "unnecessary map of the identity function",
-            format!("remove the call to `{name}`"),
-            String::new(),
-            Applicability::MachineApplicable,
-        );
+                span_lint_and_then(cx, MAP_IDENTITY, call_span, MSG, |diag| {
+                    diag.multipart_suggestion(
+                        format!("remove the call to `{name}`, and make `{ident}` mutable"),
+                        suggs,
+                        app,
+                    );
+                });
+            } else {
+                // If we can't make the binding mutable, prevent the suggestion from being automatically applied,
+                // and add a complementary help message.
+                app = Applicability::Unspecified;
+
+                let method_requiring_mut = if let Node::Expr(expr) = cx.tcx.parent_hir_node(expr.hir_id)
+                    && let ExprKind::MethodCall(method, ..) = expr.kind
+                {
+                    Some(method.ident)
+                } else {
+                    None
+                };
+
+                span_lint_and_then(cx, MAP_IDENTITY, call_span, MSG, |diag| {
+                    diag.span_suggestion(main_sugg.0, format!("remove the call to `{name}`"), main_sugg.1, app);
+
+                    let note = if let Some(method_requiring_mut) = method_requiring_mut {
+                        format!("this must be made mutable to use `{method_requiring_mut}`")
+                    } else {
+                        "this must be made mutable".to_string()
+                    };
+                    diag.span_note(caller.span, note);
+                });
+            }
+        } else {
+            span_lint_and_sugg(
+                cx,
+                MAP_IDENTITY,
+                main_sugg.0,
+                MSG,
+                format!("remove the call to `{name}`"),
+                main_sugg.1,
+                app,
+            );
+        }
     }
 }
diff --git a/clippy_lints/src/methods/option_as_ref_deref.rs b/clippy_lints/src/methods/option_as_ref_deref.rs
index 63ee922acfa0d..906ead16fd0d1 100644
--- a/clippy_lints/src/methods/option_as_ref_deref.rs
+++ b/clippy_lints/src/methods/option_as_ref_deref.rs
@@ -38,17 +38,13 @@ pub(super) fn check(
     ];
 
     let is_deref = match map_arg.kind {
-        hir::ExprKind::Path(ref expr_qpath) => {
-            cx.qpath_res(expr_qpath, map_arg.hir_id)
-                .opt_def_id()
-                .is_some_and(|fun_def_id| {
-                    cx.tcx.is_diagnostic_item(sym::deref_method, fun_def_id)
-                        || cx.tcx.is_diagnostic_item(sym::deref_mut_method, fun_def_id)
-                        || deref_aliases
-                            .iter()
-                            .any(|&sym| cx.tcx.is_diagnostic_item(sym, fun_def_id))
-                })
-        },
+        hir::ExprKind::Path(ref expr_qpath) => cx
+            .qpath_res(expr_qpath, map_arg.hir_id)
+            .opt_def_id()
+            .and_then(|fun_def_id| cx.tcx.get_diagnostic_name(fun_def_id))
+            .is_some_and(|fun_name| {
+                matches!(fun_name, sym::deref_method | sym::deref_mut_method) || deref_aliases.contains(&fun_name)
+            }),
         hir::ExprKind::Closure(&hir::Closure { body, .. }) => {
             let closure_body = cx.tcx.hir_body(body);
             let closure_expr = peel_blocks(closure_body.value);
@@ -63,13 +59,11 @@ pub(super) fn check(
                             .map(|x| &x.kind)
                             .collect::<Box<[_]>>()
                         && let [ty::adjustment::Adjust::Deref(None), ty::adjustment::Adjust::Borrow(_)] = *adj
+                        && let method_did = cx.typeck_results().type_dependent_def_id(closure_expr.hir_id).unwrap()
+                        && let Some(method_name) = cx.tcx.get_diagnostic_name(method_did)
                     {
-                        let method_did = cx.typeck_results().type_dependent_def_id(closure_expr.hir_id).unwrap();
-                        cx.tcx.is_diagnostic_item(sym::deref_method, method_did)
-                            || cx.tcx.is_diagnostic_item(sym::deref_mut_method, method_did)
-                            || deref_aliases
-                                .iter()
-                                .any(|&sym| cx.tcx.is_diagnostic_item(sym, method_did))
+                        matches!(method_name, sym::deref_method | sym::deref_mut_method)
+                            || deref_aliases.contains(&method_name)
                     } else {
                         false
                     }
diff --git a/clippy_lints/src/methods/or_then_unwrap.rs b/clippy_lints/src/methods/or_then_unwrap.rs
index 3e64e15dc8602..1a760ea733d7f 100644
--- a/clippy_lints/src/methods/or_then_unwrap.rs
+++ b/clippy_lints/src/methods/or_then_unwrap.rs
@@ -62,7 +62,7 @@ fn get_content_if_ctor_matches(cx: &LateContext<'_>, expr: &Expr<'_>, item: Lang
     if let ExprKind::Call(some_expr, [arg]) = expr.kind
         && is_res_lang_ctor(cx, path_res(cx, some_expr), item)
     {
-        Some(arg.span)
+        Some(arg.span.source_callsite())
     } else {
         None
     }
diff --git a/clippy_lints/src/methods/read_line_without_trim.rs b/clippy_lints/src/methods/read_line_without_trim.rs
index 407f2e80aff25..6738bbf0a12b9 100644
--- a/clippy_lints/src/methods/read_line_without_trim.rs
+++ b/clippy_lints/src/methods/read_line_without_trim.rs
@@ -31,8 +31,8 @@ fn parse_fails_on_trailing_newline(ty: Ty<'_>) -> bool {
 }
 
 pub fn check(cx: &LateContext<'_>, call: &Expr<'_>, recv: &Expr<'_>, arg: &Expr<'_>) {
-    if let Some(recv_adt) = cx.typeck_results().expr_ty(recv).ty_adt_def()
-        && cx.tcx.is_diagnostic_item(sym::Stdin, recv_adt.did())
+    let recv_ty = cx.typeck_results().expr_ty(recv);
+    if is_type_diagnostic_item(cx, recv_ty, sym::Stdin)
         && let ExprKind::Path(QPath::Resolved(_, path)) = arg.peel_borrows().kind
         && let Res::Local(local_id) = path.res
     {
diff --git a/clippy_lints/src/methods/single_char_add_str.rs b/clippy_lints/src/methods/single_char_add_str.rs
index ccdf5529d537a..ef3d7acdc01ef 100644
--- a/clippy_lints/src/methods/single_char_add_str.rs
+++ b/clippy_lints/src/methods/single_char_add_str.rs
@@ -5,10 +5,10 @@ use rustc_span::sym;
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, receiver: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
     if let Some(fn_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) {
-        if cx.tcx.is_diagnostic_item(sym::string_push_str, fn_def_id) {
-            single_char_push_string::check(cx, expr, receiver, args);
-        } else if cx.tcx.is_diagnostic_item(sym::string_insert_str, fn_def_id) {
-            single_char_insert_string::check(cx, expr, receiver, args);
+        match cx.tcx.get_diagnostic_name(fn_def_id) {
+            Some(sym::string_push_str) => single_char_push_string::check(cx, expr, receiver, args),
+            Some(sym::string_insert_str) => single_char_insert_string::check(cx, expr, receiver, args),
+            _ => {},
         }
     }
 }
diff --git a/clippy_lints/src/methods/suspicious_to_owned.rs b/clippy_lints/src/methods/suspicious_to_owned.rs
index ce7aefed01f49..ffc237e3c24cc 100644
--- a/clippy_lints/src/methods/suspicious_to_owned.rs
+++ b/clippy_lints/src/methods/suspicious_to_owned.rs
@@ -1,11 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_diag_trait_item;
 use clippy_utils::source::snippet_with_context;
+use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_middle::ty::print::with_forced_trimmed_paths;
-use rustc_middle::ty::{self};
 use rustc_span::sym;
 
 use super::SUSPICIOUS_TO_OWNED;
@@ -14,8 +14,7 @@ pub fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) -
     if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
         && is_diag_trait_item(cx, method_def_id, sym::ToOwned)
         && let input_type = cx.typeck_results().expr_ty(expr)
-        && let ty::Adt(adt, _) = cx.typeck_results().expr_ty(expr).kind()
-        && cx.tcx.is_diagnostic_item(sym::Cow, adt.did())
+        && is_type_diagnostic_item(cx, input_type, sym::Cow)
     {
         let mut app = Applicability::MaybeIncorrect;
         let recv_snip = snippet_with_context(cx, recv.span, expr.span.ctxt(), "..", &mut app).0;
diff --git a/clippy_lints/src/methods/unnecessary_min_or_max.rs b/clippy_lints/src/methods/unnecessary_min_or_max.rs
index 413881d5ec99e..b87d81b710269 100644
--- a/clippy_lints/src/methods/unnecessary_min_or_max.rs
+++ b/clippy_lints/src/methods/unnecessary_min_or_max.rs
@@ -22,7 +22,8 @@ pub(super) fn check<'tcx>(
     let typeck_results = cx.typeck_results();
     let ecx = ConstEvalCtxt::with_env(cx.tcx, cx.typing_env(), typeck_results);
     if let Some(id) = typeck_results.type_dependent_def_id(expr.hir_id)
-        && (cx.tcx.is_diagnostic_item(sym::cmp_ord_min, id) || cx.tcx.is_diagnostic_item(sym::cmp_ord_max, id))
+        && let Some(fn_name) = cx.tcx.get_diagnostic_name(id)
+        && matches!(fn_name, sym::cmp_ord_min | sym::cmp_ord_max)
     {
         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)
diff --git a/clippy_lints/src/methods/unused_enumerate_index.rs b/clippy_lints/src/methods/unused_enumerate_index.rs
index af466fe091c21..af4ade3cc0f7d 100644
--- a/clippy_lints/src/methods/unused_enumerate_index.rs
+++ b/clippy_lints/src/methods/unused_enumerate_index.rs
@@ -1,10 +1,10 @@
 use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::source::{SpanRangeExt, snippet};
+use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{expr_or_init, is_trait_method, pat_is_wild};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, FnDecl, PatKind, TyKind};
 use rustc_lint::LateContext;
-use rustc_middle::ty::AdtDef;
 use rustc_span::{Span, sym};
 
 use crate::loops::UNUSED_ENUMERATE_INDEX;
@@ -39,9 +39,8 @@ use crate::loops::UNUSED_ENUMERATE_INDEX;
 /// * `closure_arg`: The argument to the map function call containing the closure/function to apply
 pub(super) fn check(cx: &LateContext<'_>, call_expr: &Expr<'_>, recv: &Expr<'_>, closure_arg: &Expr<'_>) {
     let recv_ty = cx.typeck_results().expr_ty(recv);
-    if let Some(recv_ty_defid) = recv_ty.ty_adt_def().map(AdtDef::did)
-        // If we call a method on a `std::iter::Enumerate` instance
-        && cx.tcx.is_diagnostic_item(sym::Enumerate, recv_ty_defid)
+    // If we call a method on a `std::iter::Enumerate` instance
+    if is_type_diagnostic_item(cx, recv_ty, sym::Enumerate)
         // If we are calling a method of the `Iterator` trait
         && is_trait_method(cx, call_expr, sym::Iterator)
         // And the map argument is a closure
diff --git a/clippy_lints/src/missing_inline.rs b/clippy_lints/src/missing_inline.rs
index d02952eb48702..28555a6109001 100644
--- a/clippy_lints/src/missing_inline.rs
+++ b/clippy_lints/src/missing_inline.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint;
+use clippy_utils::diagnostics::{span_lint, span_lint_hir};
 use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{self as hir, Attribute, find_attr};
@@ -64,14 +64,20 @@ declare_clippy_lint! {
     "detects missing `#[inline]` attribute for public callables (functions, trait methods, methods...)"
 }
 
-fn check_missing_inline_attrs(cx: &LateContext<'_>, attrs: &[Attribute], sp: Span, desc: &'static str) {
+fn check_missing_inline_attrs(
+    cx: &LateContext<'_>,
+    attrs: &[Attribute],
+    sp: Span,
+    desc: &'static str,
+    hir_id: Option<hir::HirId>,
+) {
     if !find_attr!(attrs, AttributeKind::Inline(..)) {
-        span_lint(
-            cx,
-            MISSING_INLINE_IN_PUBLIC_ITEMS,
-            sp,
-            format!("missing `#[inline]` for {desc}"),
-        );
+        let msg = format!("missing `#[inline]` for {desc}");
+        if let Some(hir_id) = hir_id {
+            span_lint_hir(cx, MISSING_INLINE_IN_PUBLIC_ITEMS, hir_id, sp, msg);
+        } else {
+            span_lint(cx, MISSING_INLINE_IN_PUBLIC_ITEMS, sp, msg);
+        }
     }
 }
 
@@ -103,17 +109,9 @@ impl<'tcx> LateLintPass<'tcx> for MissingInline {
 
                 let desc = "a function";
                 let attrs = cx.tcx.hir_attrs(it.hir_id());
-                check_missing_inline_attrs(cx, attrs, it.span, desc);
+                check_missing_inline_attrs(cx, attrs, it.span, desc, None);
             },
-            hir::ItemKind::Trait(
-                ref _constness,
-                ref _is_auto,
-                ref _unsafe,
-                _ident,
-                _generics,
-                _bounds,
-                trait_items,
-            ) => {
+            hir::ItemKind::Trait(.., trait_items) => {
                 // note: we need to check if the trait is exported so we can't use
                 // `LateLintPass::check_trait_item` here.
                 for &tit in trait_items {
@@ -127,7 +125,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingInline {
                                 let desc = "a default trait method";
                                 let item = cx.tcx.hir_trait_item(tit);
                                 let attrs = cx.tcx.hir_attrs(item.hir_id());
-                                check_missing_inline_attrs(cx, attrs, item.span, desc);
+                                check_missing_inline_attrs(cx, attrs, item.span, desc, Some(tit.hir_id()));
                             }
                         },
                     }
@@ -182,7 +180,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingInline {
         }
 
         let attrs = cx.tcx.hir_attrs(impl_item.hir_id());
-        check_missing_inline_attrs(cx, attrs, impl_item.span, desc);
+        check_missing_inline_attrs(cx, attrs, impl_item.span, desc, None);
     }
 }
 
diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs
index 31f51b4575405..ec93ef97cfaf7 100644
--- a/clippy_lints/src/mut_reference.rs
+++ b/clippy_lints/src/mut_reference.rs
@@ -1,4 +1,6 @@
-use clippy_utils::diagnostics::span_lint;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::sugg::Sugg;
+use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty};
@@ -83,13 +85,18 @@ fn check_arguments<'tcx>(
         let parameters = type_definition.fn_sig(cx.tcx).skip_binder().inputs();
         for (argument, parameter) in iter::zip(arguments, parameters) {
             if let ty::Ref(_, _, Mutability::Not) | ty::RawPtr(_, Mutability::Not) = parameter.kind()
-                && let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, _) = argument.kind
+                && let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, arg) = argument.kind
             {
-                span_lint(
+                let mut applicability = Applicability::MachineApplicable;
+                let sugg = Sugg::hir_with_applicability(cx, arg, "_", &mut applicability).addr();
+                span_lint_and_sugg(
                     cx,
                     UNNECESSARY_MUT_PASSED,
                     argument.span,
                     format!("the {fn_kind} `{name}` doesn't need a mutable reference"),
+                    "remove this `mut`",
+                    sugg.to_string(),
+                    applicability,
                 );
             }
         }
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index 6ae26156bc44c..854e927aa2f78 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -2,16 +2,14 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{
-    SpanlessEq, get_parent_expr, higher, is_block_like, is_else_clause, is_expn_of, is_parent_stmt,
-    is_receiver_of_method_call, peel_blocks, peel_blocks_with_stmt, span_contains_comment, sym,
+    SpanlessEq, get_parent_expr, higher, is_block_like, is_else_clause, is_parent_stmt, is_receiver_of_method_call,
+    peel_blocks, peel_blocks_with_stmt, span_contains_comment,
 };
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
+use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
-use rustc_span::Span;
-use rustc_span::source_map::Spanned;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -50,31 +48,6 @@ declare_clippy_lint! {
     "if-statements with plain booleans in the then- and else-clause, e.g., `if p { true } else { false }`"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for expressions of the form `x == true`,
-    /// `x != true` and order comparisons such as `x < true` (or vice versa) and
-    /// suggest using the variable directly.
-    ///
-    /// ### Why is this bad?
-    /// Unnecessary code.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// if x == true {}
-    /// if y == false {}
-    /// ```
-    /// use `x` directly:
-    /// ```rust,ignore
-    /// if x {}
-    /// if !y {}
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub BOOL_COMPARISON,
-    complexity,
-    "comparing a variable to a boolean, e.g., `if x == true` or `if x != true`"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for expressions of the form `if c { x = true } else { x = false }`
@@ -224,201 +197,6 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBool {
     }
 }
 
-declare_lint_pass!(BoolComparison => [BOOL_COMPARISON]);
-
-impl<'tcx> LateLintPass<'tcx> for BoolComparison {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        if e.span.from_expansion() {
-            return;
-        }
-
-        if let ExprKind::Binary(Spanned { node, .. }, ..) = e.kind {
-            let ignore_case = None::<(fn(_) -> _, &str)>;
-            let ignore_no_literal = None::<(fn(_, _) -> _, &str)>;
-            match node {
-                BinOpKind::Eq => {
-                    let true_case = Some((|h| h, "equality checks against true are unnecessary"));
-                    let false_case = Some((
-                        |h: Sugg<'tcx>| !h,
-                        "equality checks against false can be replaced by a negation",
-                    ));
-                    check_comparison(cx, e, true_case, false_case, true_case, false_case, ignore_no_literal);
-                },
-                BinOpKind::Ne => {
-                    let true_case = Some((
-                        |h: Sugg<'tcx>| !h,
-                        "inequality checks against true can be replaced by a negation",
-                    ));
-                    let false_case = Some((|h| h, "inequality checks against false are unnecessary"));
-                    check_comparison(cx, e, true_case, false_case, true_case, false_case, ignore_no_literal);
-                },
-                BinOpKind::Lt => check_comparison(
-                    cx,
-                    e,
-                    ignore_case,
-                    Some((|h| h, "greater than checks against false are unnecessary")),
-                    Some((
-                        |h: Sugg<'tcx>| !h,
-                        "less than comparison against true can be replaced by a negation",
-                    )),
-                    ignore_case,
-                    Some((
-                        |l: Sugg<'tcx>, r: Sugg<'tcx>| (!l).bit_and(&r),
-                        "order comparisons between booleans can be simplified",
-                    )),
-                ),
-                BinOpKind::Gt => check_comparison(
-                    cx,
-                    e,
-                    Some((
-                        |h: Sugg<'tcx>| !h,
-                        "less than comparison against true can be replaced by a negation",
-                    )),
-                    ignore_case,
-                    ignore_case,
-                    Some((|h| h, "greater than checks against false are unnecessary")),
-                    Some((
-                        |l: Sugg<'tcx>, r: Sugg<'tcx>| l.bit_and(&(!r)),
-                        "order comparisons between booleans can be simplified",
-                    )),
-                ),
-                _ => (),
-            }
-        }
-    }
-}
-
-struct ExpressionInfoWithSpan {
-    one_side_is_unary_not: bool,
-    left_span: Span,
-    right_span: Span,
-}
-
-fn is_unary_not(e: &Expr<'_>) -> (bool, Span) {
-    if let ExprKind::Unary(UnOp::Not, operand) = e.kind {
-        return (true, operand.span);
-    }
-    (false, e.span)
-}
-
-fn one_side_is_unary_not<'tcx>(left_side: &'tcx Expr<'_>, right_side: &'tcx Expr<'_>) -> ExpressionInfoWithSpan {
-    let left = is_unary_not(left_side);
-    let right = is_unary_not(right_side);
-
-    ExpressionInfoWithSpan {
-        one_side_is_unary_not: left.0 != right.0,
-        left_span: left.1,
-        right_span: right.1,
-    }
-}
-
-fn check_comparison<'a, 'tcx>(
-    cx: &LateContext<'tcx>,
-    e: &'tcx Expr<'_>,
-    left_true: Option<(impl FnOnce(Sugg<'a>) -> Sugg<'a>, &'static str)>,
-    left_false: Option<(impl FnOnce(Sugg<'a>) -> Sugg<'a>, &'static str)>,
-    right_true: Option<(impl FnOnce(Sugg<'a>) -> Sugg<'a>, &'static str)>,
-    right_false: Option<(impl FnOnce(Sugg<'a>) -> Sugg<'a>, &'static str)>,
-    no_literal: Option<(impl FnOnce(Sugg<'a>, Sugg<'a>) -> Sugg<'a>, &'static str)>,
-) {
-    if let ExprKind::Binary(op, left_side, right_side) = e.kind {
-        let (l_ty, r_ty) = (
-            cx.typeck_results().expr_ty(left_side),
-            cx.typeck_results().expr_ty(right_side),
-        );
-        if is_expn_of(left_side.span, sym::cfg).is_some() || is_expn_of(right_side.span, sym::cfg).is_some() {
-            return;
-        }
-        if l_ty.is_bool() && r_ty.is_bool() {
-            let mut applicability = Applicability::MachineApplicable;
-            // Eliminate parentheses in `e` by using the lo pos of lhs and hi pos of rhs,
-            // calling `source_callsite` make sure macros are handled correctly, see issue #9907
-            let binop_span = left_side
-                .span
-                .source_callsite()
-                .with_hi(right_side.span.source_callsite().hi());
-
-            if op.node == BinOpKind::Eq {
-                let expression_info = one_side_is_unary_not(left_side, right_side);
-                if expression_info.one_side_is_unary_not {
-                    span_lint_and_sugg(
-                        cx,
-                        BOOL_COMPARISON,
-                        binop_span,
-                        "this comparison might be written more concisely",
-                        "try simplifying it as shown",
-                        format!(
-                            "{} != {}",
-                            snippet_with_applicability(
-                                cx,
-                                expression_info.left_span.source_callsite(),
-                                "..",
-                                &mut applicability
-                            ),
-                            snippet_with_applicability(
-                                cx,
-                                expression_info.right_span.source_callsite(),
-                                "..",
-                                &mut applicability
-                            )
-                        ),
-                        applicability,
-                    );
-                }
-            }
-
-            match (fetch_bool_expr(left_side), fetch_bool_expr(right_side)) {
-                (Some(true), None) => left_true.map_or((), |(h, m)| {
-                    suggest_bool_comparison(cx, binop_span, right_side, applicability, m, h);
-                }),
-                (None, Some(true)) => right_true.map_or((), |(h, m)| {
-                    suggest_bool_comparison(cx, binop_span, left_side, applicability, m, h);
-                }),
-                (Some(false), None) => left_false.map_or((), |(h, m)| {
-                    suggest_bool_comparison(cx, binop_span, right_side, applicability, m, h);
-                }),
-                (None, Some(false)) => right_false.map_or((), |(h, m)| {
-                    suggest_bool_comparison(cx, binop_span, left_side, applicability, m, h);
-                }),
-                (None, None) => no_literal.map_or((), |(h, m)| {
-                    let left_side = Sugg::hir_with_applicability(cx, left_side, "..", &mut applicability);
-                    let right_side = Sugg::hir_with_applicability(cx, right_side, "..", &mut applicability);
-                    span_lint_and_sugg(
-                        cx,
-                        BOOL_COMPARISON,
-                        binop_span,
-                        m,
-                        "try simplifying it as shown",
-                        h(left_side, right_side).into_string(),
-                        applicability,
-                    );
-                }),
-                _ => (),
-            }
-        }
-    }
-}
-
-fn suggest_bool_comparison<'a, 'tcx>(
-    cx: &LateContext<'tcx>,
-    span: Span,
-    expr: &Expr<'_>,
-    mut app: Applicability,
-    message: &'static str,
-    conv_hint: impl FnOnce(Sugg<'a>) -> Sugg<'a>,
-) {
-    let hint = Sugg::hir_with_context(cx, expr, span.ctxt(), "..", &mut app);
-    span_lint_and_sugg(
-        cx,
-        BOOL_COMPARISON,
-        span,
-        message,
-        "try simplifying it as shown",
-        conv_hint(hint).into_string(),
-        app,
-    );
-}
-
 enum Expression {
     Bool(bool),
     RetBool(bool),
diff --git a/clippy_lints/src/needless_for_each.rs b/clippy_lints/src/needless_for_each.rs
index a67545e419ce7..3a6ccc2bca998 100644
--- a/clippy_lints/src/needless_for_each.rs
+++ b/clippy_lints/src/needless_for_each.rs
@@ -1,6 +1,6 @@
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{Visitor, walk_expr};
-use rustc_hir::{Block, BlockCheckMode, Closure, Expr, ExprKind, Stmt, StmtKind};
+use rustc_hir::{Block, BlockCheckMode, Closure, Expr, ExprKind, Stmt, StmtKind, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
 use rustc_span::Span;
@@ -70,12 +70,24 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessForEach {
             && has_iter_method(cx, cx.typeck_results().expr_ty(iter_recv)).is_some()
             // Skip the lint if the body is not block because this is simpler than `for` loop.
             // e.g. `v.iter().for_each(f)` is simpler and clearer than using `for` loop.
-            && let ExprKind::Closure(&Closure { body, .. }) = for_each_arg.kind
+            && let ExprKind::Closure(&Closure { body, fn_decl, .. }) = for_each_arg.kind
             && let body = cx.tcx.hir_body(body)
             // Skip the lint if the body is not safe, so as not to suggest `for … in … unsafe {}`
             // and suggesting `for … in … { unsafe { } }` is a little ugly.
             && !matches!(body.value.kind, ExprKind::Block(Block { rules: BlockCheckMode::UnsafeBlock(_), .. }, ..))
         {
+            let mut applicability = Applicability::MachineApplicable;
+
+            // If any closure parameter has an explicit type specified, applying the lint would necessarily
+            // remove that specification, possibly breaking type inference
+            if fn_decl
+                .inputs
+                .iter()
+                .any(|input| matches!(input.kind, TyKind::Infer(..)))
+            {
+                applicability = Applicability::MaybeIncorrect;
+            }
+
             let mut ret_collector = RetCollector::default();
             ret_collector.visit_expr(body.value);
 
@@ -84,18 +96,16 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessForEach {
                 return;
             }
 
-            let (mut applicability, ret_suggs) = if ret_collector.spans.is_empty() {
-                (Applicability::MachineApplicable, None)
+            let ret_suggs = if ret_collector.spans.is_empty() {
+                None
             } else {
-                (
-                    Applicability::MaybeIncorrect,
-                    Some(
-                        ret_collector
-                            .spans
-                            .into_iter()
-                            .map(|span| (span, "continue".to_string()))
-                            .collect(),
-                    ),
+                applicability = Applicability::MaybeIncorrect;
+                Some(
+                    ret_collector
+                        .spans
+                        .into_iter()
+                        .map(|span| (span, "continue".to_string()))
+                        .collect(),
                 )
             };
 
diff --git a/clippy_lints/src/non_canonical_impls.rs b/clippy_lints/src/non_canonical_impls.rs
index 04b092769666c..ba67dc62abbda 100644
--- a/clippy_lints/src/non_canonical_impls.rs
+++ b/clippy_lints/src/non_canonical_impls.rs
@@ -134,7 +134,8 @@ impl LateLintPass<'_> for NonCanonicalImpls {
             return;
         }
 
-        if cx.tcx.is_diagnostic_item(sym::Clone, trait_impl.def_id)
+        let trait_name = cx.tcx.get_diagnostic_name(trait_impl.def_id);
+        if trait_name == Some(sym::Clone)
             && let Some(copy_def_id) = cx.tcx.get_diagnostic_item(sym::Copy)
             && implements_trait(cx, trait_impl.self_ty(), copy_def_id, &[])
         {
@@ -170,12 +171,8 @@ impl LateLintPass<'_> for NonCanonicalImpls {
                     String::new(),
                     Applicability::MaybeIncorrect,
                 );
-
-                return;
             }
-        }
-
-        if cx.tcx.is_diagnostic_item(sym::PartialOrd, trait_impl.def_id)
+        } else if trait_name == Some(sym::PartialOrd)
             && impl_item.ident.name == sym::partial_cmp
             && let Some(ord_def_id) = cx.tcx.get_diagnostic_item(sym::Ord)
             && implements_trait(cx, trait_impl.self_ty(), ord_def_id, &[])
diff --git a/clippy_lints/src/non_octal_unix_permissions.rs b/clippy_lints/src/non_octal_unix_permissions.rs
index 23a1622f30fff..cb934466bd890 100644
--- a/clippy_lints/src/non_octal_unix_permissions.rs
+++ b/clippy_lints/src/non_octal_unix_permissions.rs
@@ -43,13 +43,11 @@ impl<'tcx> LateLintPass<'tcx> for NonOctalUnixPermissions {
         match &expr.kind {
             ExprKind::MethodCall(path, func, [param], _) => {
                 if let Some(adt) = cx.typeck_results().expr_ty(func).peel_refs().ty_adt_def()
-                    && ((path.ident.name == sym::mode
-                        && matches!(
-                            cx.tcx.get_diagnostic_name(adt.did()),
-                            Some(sym::FsOpenOptions | sym::DirBuilder)
-                        ))
-                        || (path.ident.name == sym::set_mode
-                            && cx.tcx.is_diagnostic_item(sym::FsPermissions, adt.did())))
+                    && matches!(
+                        (cx.tcx.get_diagnostic_name(adt.did()), path.ident.name),
+                        (Some(sym::FsOpenOptions | sym::DirBuilder), sym::mode)
+                            | (Some(sym::FsPermissions), sym::set_mode)
+                    )
                     && let ExprKind::Lit(_) = param.kind
                     && param.span.eq_ctxt(expr.span)
                     && param
diff --git a/clippy_lints/src/operators/assign_op_pattern.rs b/clippy_lints/src/operators/assign_op_pattern.rs
index 7317c62df7fe8..2d303e40bd1c8 100644
--- a/clippy_lints/src/operators/assign_op_pattern.rs
+++ b/clippy_lints/src/operators/assign_op_pattern.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::msrvs::Msrv;
+use clippy_utils::qualify_min_const_fn::is_stable_const_fn;
 use clippy_utils::source::SpanRangeExt;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::visitors::for_each_expr_without_closures;
@@ -20,7 +21,7 @@ pub(super) fn check<'tcx>(
     expr: &'tcx hir::Expr<'_>,
     assignee: &'tcx hir::Expr<'_>,
     e: &'tcx hir::Expr<'_>,
-    _msrv: Msrv,
+    msrv: Msrv,
 ) {
     if let hir::ExprKind::Binary(op, l, r) = &e.kind {
         let lint = |assignee: &hir::Expr<'_>, rhs: &hir::Expr<'_>| {
@@ -43,10 +44,28 @@ pub(super) fn check<'tcx>(
                     }
                 }
 
-                // Skip if the trait is not stable in const contexts
-                // FIXME: reintroduce a better check after this is merged back into Clippy
+                // Skip if the trait or the implementation is not stable in const contexts
                 if is_in_const_context(cx) {
-                    return;
+                    if cx
+                        .tcx
+                        .associated_item_def_ids(trait_id)
+                        .first()
+                        .is_none_or(|binop_id| !is_stable_const_fn(cx, *binop_id, msrv))
+                    {
+                        return;
+                    }
+
+                    let impls = cx.tcx.non_blanket_impls_for_ty(trait_id, rty).collect::<Vec<_>>();
+                    if impls.is_empty()
+                        || impls.into_iter().any(|impl_id| {
+                            cx.tcx
+                                .associated_item_def_ids(impl_id)
+                                .first()
+                                .is_none_or(|fn_id| !is_stable_const_fn(cx, *fn_id, msrv))
+                        })
+                    {
+                        return;
+                    }
                 }
 
                 span_lint_and_then(
diff --git a/clippy_lints/src/operators/cmp_owned.rs b/clippy_lints/src/operators/cmp_owned.rs
index 22ec4fe60fb02..604f8f5da0b86 100644
--- a/clippy_lints/src/operators/cmp_owned.rs
+++ b/clippy_lints/src/operators/cmp_owned.rs
@@ -47,14 +47,10 @@ fn check_op(cx: &LateContext<'_>, expr: &Expr<'_>, other: &Expr<'_>, left: bool)
             (arg, arg.span)
         },
         ExprKind::Call(path, [arg])
-            if path_def_id(cx, path).is_some_and(|did| {
-                if cx.tcx.is_diagnostic_item(sym::from_str_method, did) {
-                    true
-                } else if cx.tcx.is_diagnostic_item(sym::from_fn, did) {
-                    !is_copy(cx, typeck.expr_ty(expr))
-                } else {
-                    false
-                }
+            if path_def_id(cx, path).is_some_and(|did| match cx.tcx.get_diagnostic_name(did) {
+                Some(sym::from_str_method) => true,
+                Some(sym::from_fn) => !is_copy(cx, typeck.expr_ty(expr)),
+                _ => false,
             }) =>
         {
             (arg, arg.span)
diff --git a/clippy_lints/src/operators/float_equality_without_abs.rs b/clippy_lints/src/operators/float_equality_without_abs.rs
index 047a5a0159cb0..17fa8017c9788 100644
--- a/clippy_lints/src/operators/float_equality_without_abs.rs
+++ b/clippy_lints/src/operators/float_equality_without_abs.rs
@@ -34,10 +34,11 @@ pub(crate) fn check<'tcx>(
             val_r,
         ) = lhs.kind
 
-        // right hand side matches either f32::EPSILON or f64::EPSILON
+        // right hand side matches _::EPSILON
         && let ExprKind::Path(ref epsilon_path) = rhs.kind
         && let Res::Def(DefKind::AssocConst, def_id) = cx.qpath_res(epsilon_path, rhs.hir_id)
-        && ([sym::f32_epsilon, sym::f64_epsilon].into_iter().any(|sym| cx.tcx.is_diagnostic_item(sym, def_id)))
+        && let Some(sym) = cx.tcx.get_diagnostic_name(def_id)
+        && matches!(sym, sym::f16_epsilon | sym::f32_epsilon | sym::f64_epsilon | sym::f128_epsilon)
 
         // values of the subtractions on the left hand side are of the type float
         && let t_val_l = cx.typeck_results().expr_ty(val_l)
diff --git a/clippy_lints/src/panic_unimplemented.rs b/clippy_lints/src/panic_unimplemented.rs
index 449d3da763941..43db0085f2e34 100644
--- a/clippy_lints/src/panic_unimplemented.rs
+++ b/clippy_lints/src/panic_unimplemented.rs
@@ -1,7 +1,7 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::is_in_test;
 use clippy_utils::macros::{is_panic, root_macro_call_first_node};
+use clippy_utils::{is_in_test, is_inside_always_const_context};
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
@@ -99,7 +99,7 @@ impl<'tcx> LateLintPass<'tcx> for PanicUnimplemented {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let Some(macro_call) = root_macro_call_first_node(cx, expr) {
             if is_panic(cx, macro_call.def_id) {
-                if cx.tcx.hir_is_inside_const_context(expr.hir_id)
+                if is_inside_always_const_context(cx.tcx, expr.hir_id)
                     || self.allow_panic_in_tests && is_in_test(cx.tcx, expr.hir_id)
                 {
                     return;
@@ -140,7 +140,7 @@ impl<'tcx> LateLintPass<'tcx> for PanicUnimplemented {
             && let Res::Def(DefKind::Fn, def_id) = expr_path.res
             && cx.tcx.is_diagnostic_item(sym::panic_any, def_id)
         {
-            if cx.tcx.hir_is_inside_const_context(expr.hir_id)
+            if is_inside_always_const_context(cx.tcx, expr.hir_id)
                 || self.allow_panic_in_tests && is_in_test(cx.tcx, expr.hir_id)
             {
                 return;
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index e57b8cc2d84e3..1d58cdd26d88d 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::{span_lint_hir, span_lint_hir_and_then};
 use clippy_utils::fn_has_unsatisfiable_preds;
 use clippy_utils::mir::{LocalUsage, PossibleBorrowerMap, visit_local_usage};
 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::ty::{has_drop, is_copy, is_type_lang_item, walk_ptrs_ty_depth};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, FnDecl, LangItem, def_id};
@@ -96,14 +96,13 @@ 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 fn_name = cx.tcx.get_diagnostic_name(fn_def_id);
+
             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));
+                || fn_name == Some(sym::to_owned_method)
+                || (fn_name == Some(sym::to_string_method) && is_type_lang_item(cx, arg_ty, LangItem::String));
 
-            let from_deref = !from_borrow
-                && (cx.tcx.is_diagnostic_item(sym::path_to_pathbuf, fn_def_id)
-                    || cx.tcx.is_diagnostic_item(sym::os_str_to_os_string, fn_def_id));
+            let from_deref = !from_borrow && matches!(fn_name, Some(sym::path_to_pathbuf | sym::os_str_to_os_string));
 
             if !from_borrow && !from_deref {
                 continue;
@@ -148,8 +147,9 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
                     is_call_with_ref_arg(cx, mir, &pred_terminator.kind)
                     && res == cloned
                     && cx.tcx.is_diagnostic_item(sym::deref_method, pred_fn_def_id)
-                    && (is_type_diagnostic_item(cx, pred_arg_ty, sym::PathBuf)
-                        || is_type_diagnostic_item(cx, pred_arg_ty, sym::OsString))
+                    && let ty::Adt(pred_arg_def, _) = pred_arg_ty.kind()
+                    && let Some(pred_arg_name) = cx.tcx.get_diagnostic_name(pred_arg_def.did())
+                    && matches!(pred_arg_name, sym::PathBuf | sym::OsString)
                 {
                     (pred_arg, res)
                 } else {
diff --git a/clippy_lints/src/semicolon_block.rs b/clippy_lints/src/semicolon_block.rs
index db91c57b18160..1dea8f17c34be 100644
--- a/clippy_lints/src/semicolon_block.rs
+++ b/clippy_lints/src/semicolon_block.rs
@@ -155,6 +155,11 @@ impl LateLintPass<'_> for SemicolonBlock {
                 kind: ExprKind::Block(block, _),
                 ..
             }) if !block.span.from_expansion() => {
+                let attrs = cx.tcx.hir_attrs(stmt.hir_id);
+                if !attrs.is_empty() && !cx.tcx.features().stmt_expr_attributes() {
+                    return;
+                }
+
                 if let Some(tail) = block.expr {
                     self.semicolon_inside_block(cx, block, tail, stmt.span);
                 }
diff --git a/clippy_lints/src/std_instead_of_core.rs b/clippy_lints/src/std_instead_of_core.rs
index e9534bc63a691..8c4a50041e67d 100644
--- a/clippy_lints/src/std_instead_of_core.rs
+++ b/clippy_lints/src/std_instead_of_core.rs
@@ -126,6 +126,8 @@ impl<'tcx> LateLintPass<'tcx> for StdReexports {
             && !is_from_proc_macro(cx, &first_segment.ident)
             && !matches!(def_kind, DefKind::Macro(_))
             && let Some(last_segment) = path.segments.last()
+            && let Res::Def(DefKind::Mod, crate_def_id) = first_segment.res
+            && crate_def_id.is_crate_root()
         {
             let (lint, used_mod, replace_with) = match first_segment.ident.name {
                 sym::std => match cx.tcx.crate_name(def_id.krate) {
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 490e6c974ae10..57d5900b045ea 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -457,7 +457,8 @@ impl<'tcx> LateLintPass<'tcx> for TrimSplitWhitespace {
 }
 
 fn is_one_of_trim_diagnostic_items(cx: &LateContext<'_>, trim_def_id: DefId) -> bool {
-    cx.tcx.is_diagnostic_item(sym::str_trim, trim_def_id)
-        || cx.tcx.is_diagnostic_item(sym::str_trim_start, trim_def_id)
-        || cx.tcx.is_diagnostic_item(sym::str_trim_end, trim_def_id)
+    matches!(
+        cx.tcx.get_diagnostic_name(trim_def_id),
+        Some(sym::str_trim | sym::str_trim_start | sym::str_trim_end)
+    )
 }
diff --git a/clippy_lints/src/transmute/missing_transmute_annotations.rs b/clippy_lints/src/transmute/missing_transmute_annotations.rs
index 08f36a2ed5d2e..543f3c45e1461 100644
--- a/clippy_lints/src/transmute/missing_transmute_annotations.rs
+++ b/clippy_lints/src/transmute/missing_transmute_annotations.rs
@@ -1,8 +1,12 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use std::borrow::Cow;
+
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::{HasSession, SpanRangeExt as _};
 use rustc_errors::Applicability;
-use rustc_hir::{GenericArg, HirId, LetStmt, Node, Path, TyKind};
+use rustc_hir::{Expr, GenericArg, HirId, LetStmt, Node, Path, TyKind};
 use rustc_lint::LateContext;
-use rustc_middle::ty::Ty;
+use rustc_middle::ty::{self, Ty};
+use rustc_span::Span;
 
 use crate::transmute::MISSING_TRANSMUTE_ANNOTATIONS;
 
@@ -38,6 +42,7 @@ fn is_function_block(cx: &LateContext<'_>, expr_hir_id: HirId) -> bool {
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     path: &Path<'tcx>,
+    arg: &Expr<'tcx>,
     from_ty: Ty<'tcx>,
     to_ty: Ty<'tcx>,
     expr_hir_id: HirId,
@@ -68,14 +73,48 @@ pub(super) fn check<'tcx>(
     } else if is_function_block(cx, expr_hir_id) {
         return false;
     }
-    span_lint_and_sugg(
+    let span = last.ident.span.with_hi(path.span.hi());
+    span_lint_and_then(
         cx,
         MISSING_TRANSMUTE_ANNOTATIONS,
-        last.ident.span.with_hi(path.span.hi()),
+        span,
         "transmute used without annotations",
-        "consider adding missing annotations",
-        format!("{}::<{from_ty}, {to_ty}>", last.ident),
-        Applicability::MaybeIncorrect,
+        |diag| {
+            let from_ty_no_name = ty_cannot_be_named(from_ty);
+            let to_ty_no_name = ty_cannot_be_named(to_ty);
+            if from_ty_no_name || to_ty_no_name {
+                let to_name = match (from_ty_no_name, to_ty_no_name) {
+                    (true, false) => maybe_name_by_expr(cx, arg.span, "the origin type"),
+                    (false, true) => "the destination type".into(),
+                    _ => "the source and destination types".into(),
+                };
+                diag.help(format!(
+                    "consider giving {to_name} a name, and adding missing type annotations"
+                ));
+            } else {
+                diag.span_suggestion(
+                    span,
+                    "consider adding missing annotations",
+                    format!("{}::<{from_ty}, {to_ty}>", last.ident),
+                    Applicability::MaybeIncorrect,
+                );
+            }
+        },
     );
     true
 }
+
+fn ty_cannot_be_named(ty: Ty<'_>) -> bool {
+    matches!(
+        ty.kind(),
+        ty::Alias(ty::AliasTyKind::Opaque | ty::AliasTyKind::Inherent, _)
+    )
+}
+
+fn maybe_name_by_expr<'a>(sess: &impl HasSession, span: Span, default: &'a str) -> Cow<'a, str> {
+    span.with_source_text(sess, |name| {
+        (name.len() + 9 < default.len()).then_some(format!("`{name}`'s type").into())
+    })
+    .flatten()
+    .unwrap_or(default.into())
+}
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 1c7bb4314ddf5..5fda388259a61 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -520,7 +520,7 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                 | transmuting_null::check(cx, e, arg, to_ty)
                 | transmute_null_to_fn::check(cx, e, arg, to_ty)
                 | transmute_ptr_to_ref::check(cx, e, from_ty, to_ty, arg, path, self.msrv)
-                | missing_transmute_annotations::check(cx, path, from_ty, to_ty, e.hir_id)
+                | missing_transmute_annotations::check(cx, path, arg, from_ty, to_ty, e.hir_id)
                 | transmute_ref_to_ref::check(cx, e, from_ty, to_ty, arg, const_context)
                 | transmute_ptr_to_ptr::check(cx, e, from_ty, to_ty, arg, self.msrv)
                 | transmute_int_to_bool::check(cx, e, from_ty, to_ty, arg)
diff --git a/clippy_lints/src/transmute/transmute_int_to_non_zero.rs b/clippy_lints/src/transmute/transmute_int_to_non_zero.rs
index f27aaa2fa77aa..2257aa1b73c87 100644
--- a/clippy_lints/src/transmute/transmute_int_to_non_zero.rs
+++ b/clippy_lints/src/transmute/transmute_int_to_non_zero.rs
@@ -1,6 +1,6 @@
 use super::TRANSMUTE_INT_TO_NON_ZERO;
-use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::sugg;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::sugg::Sugg;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
@@ -16,35 +16,24 @@ pub(super) fn check<'tcx>(
     to_ty: Ty<'tcx>,
     arg: &'tcx Expr<'_>,
 ) -> bool {
-    let tcx = cx.tcx;
-
-    let (ty::Int(_) | ty::Uint(_), ty::Adt(adt, substs)) = (&from_ty.kind(), to_ty.kind()) else {
-        return false;
-    };
-
-    if !tcx.is_diagnostic_item(sym::NonZero, adt.did()) {
-        return false;
+    if let ty::Int(_) | ty::Uint(_) = from_ty.kind()
+        && let ty::Adt(adt, substs) = to_ty.kind()
+        && cx.tcx.is_diagnostic_item(sym::NonZero, adt.did())
+        && let int_ty = substs.type_at(0)
+        && from_ty == int_ty
+    {
+        let arg = Sugg::hir(cx, arg, "..");
+        span_lint_and_sugg(
+            cx,
+            TRANSMUTE_INT_TO_NON_ZERO,
+            e.span,
+            format!("transmute from a `{from_ty}` to a `{}<{int_ty}>`", sym::NonZero),
+            "consider using",
+            format!("{}::{}({arg})", sym::NonZero, sym::new_unchecked),
+            Applicability::Unspecified,
+        );
+        true
+    } else {
+        false
     }
-
-    let int_ty = substs.type_at(0);
-    if from_ty != int_ty {
-        return false;
-    }
-
-    span_lint_and_then(
-        cx,
-        TRANSMUTE_INT_TO_NON_ZERO,
-        e.span,
-        format!("transmute from a `{from_ty}` to a `{}<{int_ty}>`", sym::NonZero),
-        |diag| {
-            let arg = sugg::Sugg::hir(cx, arg, "..");
-            diag.span_suggestion(
-                e.span,
-                "consider using",
-                format!("{}::{}({arg})", sym::NonZero, sym::new_unchecked),
-                Applicability::Unspecified,
-            );
-        },
-    );
-    true
 }
diff --git a/clippy_lints/src/types/rc_buffer.rs b/clippy_lints/src/types/rc_buffer.rs
index d691f1878b11b..c4fd0fbf87a90 100644
--- a/clippy_lints/src/types/rc_buffer.rs
+++ b/clippy_lints/src/types/rc_buffer.rs
@@ -11,7 +11,8 @@ use super::RC_BUFFER;
 
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
     let app = Applicability::Unspecified;
-    if cx.tcx.is_diagnostic_item(sym::Rc, def_id) {
+    let name = cx.tcx.get_diagnostic_name(def_id);
+    if name == Some(sym::Rc) {
         if let Some(alternate) = match_buffer_type(cx, qpath) {
             #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
             span_lint_and_then(
@@ -56,7 +57,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
             );
             return true;
         }
-    } else if cx.tcx.is_diagnostic_item(sym::Arc, def_id) {
+    } else if name == Some(sym::Arc) {
         if let Some(alternate) = match_buffer_type(cx, qpath) {
             #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
             span_lint_and_then(
diff --git a/clippy_lints/src/types/redundant_allocation.rs b/clippy_lints/src/types/redundant_allocation.rs
index de3456a8ba5fc..0ba51daf027d1 100644
--- a/clippy_lints/src/types/redundant_allocation.rs
+++ b/clippy_lints/src/types/redundant_allocation.rs
@@ -13,14 +13,11 @@ use super::{REDUNDANT_ALLOCATION, utils};
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, hir_ty: &hir::Ty<'tcx>, qpath: &QPath<'tcx>, def_id: DefId) -> bool {
     let mut applicability = Applicability::MaybeIncorrect;
-    let outer_sym = if Some(def_id) == cx.tcx.lang_items().owned_box() {
-        "Box"
-    } else if cx.tcx.is_diagnostic_item(sym::Rc, def_id) {
-        "Rc"
-    } else if cx.tcx.is_diagnostic_item(sym::Arc, def_id) {
-        "Arc"
-    } else {
-        return false;
+    let outer_sym = match cx.tcx.get_diagnostic_name(def_id) {
+        _ if Some(def_id) == cx.tcx.lang_items().owned_box() => "Box",
+        Some(sym::Rc) => "Rc",
+        Some(sym::Arc) => "Arc",
+        _ => return false,
     };
 
     if let Some(span) = utils::match_borrows_parameter(cx, qpath) {
diff --git a/clippy_lints/src/unit_types/unit_cmp.rs b/clippy_lints/src/unit_types/unit_cmp.rs
index 48b532968cb57..38716519e23b6 100644
--- a/clippy_lints/src/unit_types/unit_cmp.rs
+++ b/clippy_lints/src/unit_types/unit_cmp.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::macros::{find_assert_eq_args, root_macro_call_first_node};
-use clippy_utils::sym;
+use clippy_utils::{is_unit_expr, sym};
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
 
@@ -16,10 +16,13 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
                 sym::assert_ne_macro | sym::debug_assert_ne_macro => "fail",
                 _ => return,
             };
-            let Some((left, _, _)) = find_assert_eq_args(cx, expr, macro_call.expn) else {
+            let Some((lhs, rhs, _)) = find_assert_eq_args(cx, expr, macro_call.expn) else {
                 return;
             };
-            if !cx.typeck_results().expr_ty(left).is_unit() {
+            if is_unit_expr(lhs) || is_unit_expr(rhs) {
+                return;
+            }
+            if !cx.typeck_results().expr_ty(lhs).is_unit() {
                 return;
             }
             span_lint(
diff --git a/clippy_lints/src/unnecessary_owned_empty_strings.rs b/clippy_lints/src/unnecessary_owned_empty_strings.rs
index 7d996775a58c8..28f4884fa3110 100644
--- a/clippy_lints/src/unnecessary_owned_empty_strings.rs
+++ b/clippy_lints/src/unnecessary_owned_empty_strings.rs
@@ -41,7 +41,8 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryOwnedEmptyStrings {
             && let ty::Ref(_, inner_str, _) = cx.typeck_results().expr_ty_adjusted(expr).kind()
             && inner_str.is_str()
         {
-            if cx.tcx.is_diagnostic_item(sym::string_new, fun_def_id) {
+            let fun_name = cx.tcx.get_diagnostic_name(fun_def_id);
+            if fun_name == Some(sym::string_new) {
                 span_lint_and_sugg(
                     cx,
                     UNNECESSARY_OWNED_EMPTY_STRINGS,
@@ -51,7 +52,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryOwnedEmptyStrings {
                     "\"\"".to_owned(),
                     Applicability::MachineApplicable,
                 );
-            } else if cx.tcx.is_diagnostic_item(sym::from_fn, fun_def_id)
+            } else if fun_name == Some(sym::from_fn)
                 && let [arg] = args
                 && let ExprKind::Lit(spanned) = &arg.kind
                 && let LitKind::Str(symbol, _) = spanned.node
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index 54a7efc090ade..849c0b438a5a0 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -107,12 +107,10 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
         // Get the wrapper and inner types, if can't, abort.
         let (return_type_label, lang_item, inner_type) =
             if let ty::Adt(adt_def, subst) = return_ty(cx, hir_id.expect_owner()).kind() {
-                if cx.tcx.is_diagnostic_item(sym::Option, adt_def.did()) {
-                    ("Option", OptionSome, subst.type_at(0))
-                } else if cx.tcx.is_diagnostic_item(sym::Result, adt_def.did()) {
-                    ("Result", ResultOk, subst.type_at(0))
-                } else {
-                    return;
+                match cx.tcx.get_diagnostic_name(adt_def.did()) {
+                    Some(sym::Option) => ("Option", OptionSome, subst.type_at(0)),
+                    Some(sym::Result) => ("Result", ResultOk, subst.type_at(0)),
+                    _ => return,
                 }
             } else {
                 return;
diff --git a/clippy_lints/src/unnested_or_patterns.rs b/clippy_lints/src/unnested_or_patterns.rs
index 8b278d98a30e0..f3410c98973f5 100644
--- a/clippy_lints/src/unnested_or_patterns.rs
+++ b/clippy_lints/src/unnested_or_patterns.rs
@@ -326,7 +326,11 @@ fn extend_with_struct_pat(
                     if idx_1 == idx {
                         // In the case of `k`, we merely require identical field names
                         // so that we will transform into `ident_k: p1_k | p2_k`.
-                        let pos = fps2.iter().position(|fp2| eq_id(fp1.ident, fp2.ident));
+                        let pos = fps2.iter().position(|fp2| {
+                            // Avoid `Foo { bar } | Foo { bar }` => `Foo { bar | bar }`
+                            !(fp1.is_shorthand && fp2.is_shorthand)
+                                && eq_id(fp1.ident, fp2.ident)
+                        });
                         pos_in_2.set(pos);
                         pos.is_some()
                     } else {
diff --git a/clippy_lints/src/unused_io_amount.rs b/clippy_lints/src/unused_io_amount.rs
index f3cd3f1bb286f..af3ad4566c46a 100644
--- a/clippy_lints/src/unused_io_amount.rs
+++ b/clippy_lints/src/unused_io_amount.rs
@@ -89,7 +89,9 @@ impl<'tcx> LateLintPass<'tcx> for UnusedIoAmount {
         {
             // We don't want to lint inside io::Read or io::Write implementations, as the author has more
             // information about their trait implementation than our lint, see https://github.com/rust-lang/rust-clippy/issues/4836
-            if cx.tcx.is_diagnostic_item(sym::IoRead, trait_id) || cx.tcx.is_diagnostic_item(sym::IoWrite, trait_id) {
+            if let Some(trait_name) = cx.tcx.get_diagnostic_name(trait_id)
+                && matches!(trait_name, sym::IoRead | sym::IoWrite)
+            {
                 return;
             }
 
diff --git a/clippy_lints/src/unused_unit.rs b/clippy_lints/src/unused_unit.rs
index 3811f0fe6b558..d503bd3379b08 100644
--- a/clippy_lints/src/unused_unit.rs
+++ b/clippy_lints/src/unused_unit.rs
@@ -6,13 +6,13 @@ use rustc_errors::Applicability;
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
-    AssocItemConstraintKind, Body, Expr, ExprKind, FnDecl, FnRetTy, GenericArgsParentheses, Node, PolyTraitRef, Term,
-    Ty, TyKind,
+    AssocItemConstraintKind, Body, Expr, ExprKind, FnDecl, FnRetTy, GenericArgsParentheses, PolyTraitRef, Term, Ty,
+    TyKind,
 };
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
 use rustc_span::edition::Edition;
-use rustc_span::{BytePos, Span, sym};
+use rustc_span::{BytePos, Pos as _, Span, sym};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -49,19 +49,22 @@ impl<'tcx> LateLintPass<'tcx> for UnusedUnit {
         decl: &'tcx FnDecl<'tcx>,
         body: &'tcx Body<'tcx>,
         span: Span,
-        def_id: LocalDefId,
+        _def_id: LocalDefId,
     ) {
         if let FnRetTy::Return(hir_ty) = decl.output
             && is_unit_ty(hir_ty)
             && !hir_ty.span.from_expansion()
             && get_def(span) == get_def(hir_ty.span)
         {
-            // implicit types in closure signatures are forbidden when `for<...>` is present
-            if let FnKind::Closure = kind
-                && let Node::Expr(expr) = cx.tcx.hir_node_by_def_id(def_id)
-                && let ExprKind::Closure(closure) = expr.kind
-                && !closure.bound_generic_params.is_empty()
-            {
+            // The explicit `-> ()` in the closure signature might be necessary for multiple reasons:
+            // - Implicit types in closure signatures are forbidden when `for<...>` is present
+            // - If the closure body ends with a function call, and that function's return type is generic, the
+            //   `-> ()` could be required for it to be inferred
+            //
+            // There could be more reasons to have it, and, in general, we shouldn't discourage the users from
+            // writing more type annotations than strictly necessary, because it can help readability and
+            // maintainability
+            if let FnKind::Closure = kind {
                 return;
             }
 
@@ -97,16 +100,13 @@ impl<'tcx> LateLintPass<'tcx> for UnusedUnit {
     }
 
     fn check_poly_trait_ref(&mut self, cx: &LateContext<'tcx>, poly: &'tcx PolyTraitRef<'tcx>) {
-        let segments = &poly.trait_ref.path.segments;
-
-        if segments.len() == 1
-            && matches!(segments[0].ident.name, sym::Fn | sym::FnMut | sym::FnOnce)
-            && let Some(args) = segments[0].args
+        if let [segment] = &poly.trait_ref.path.segments
+            && matches!(segment.ident.name, sym::Fn | sym::FnMut | sym::FnOnce)
+            && let Some(args) = segment.args
             && args.parenthesized == GenericArgsParentheses::ParenSugar
-            && let constraints = &args.constraints
-            && constraints.len() == 1
-            && constraints[0].ident.name == sym::Output
-            && let AssocItemConstraintKind::Equality { term: Term::Ty(hir_ty) } = constraints[0].kind
+            && let [constraint] = &args.constraints
+            && constraint.ident.name == sym::Output
+            && let AssocItemConstraintKind::Equality { term: Term::Ty(hir_ty) } = constraint.kind
             && args.span_ext.hi() != poly.span.hi()
             && !hir_ty.span.from_expansion()
             && args.span_ext.hi() != hir_ty.span.hi()
@@ -160,17 +160,15 @@ fn get_def(span: Span) -> Option<Span> {
 
 fn lint_unneeded_unit_return(cx: &LateContext<'_>, ty_span: Span, span: Span) {
     let (ret_span, appl) =
-        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,
-                    )
-                })
-            });
+        if let Some(Some(rpos)) = span.with_hi(ty_span.hi()).with_source_text(cx, position_before_rarrow) {
+            (
+                ty_span.with_lo(span.lo() + BytePos::from_usize(rpos)),
+                Applicability::MachineApplicable,
+            )
+        } else {
+            (ty_span, Applicability::MaybeIncorrect)
+        };
+
     span_lint_and_sugg(
         cx,
         UNUSED_UNIT,
diff --git a/clippy_lints/src/unwrap_in_result.rs b/clippy_lints/src/unwrap_in_result.rs
index 7bec212a23ca0..f26647fa34854 100644
--- a/clippy_lints/src/unwrap_in_result.rs
+++ b/clippy_lints/src/unwrap_in_result.rs
@@ -1,13 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::visitors::for_each_expr;
-use clippy_utils::{method_chain_args, return_ty};
-use core::ops::ControlFlow;
-use rustc_hir as hir;
-use rustc_hir::ImplItemKind;
+use clippy_utils::{return_ty, sym};
+use rustc_hir::{
+    Body, BodyOwnerKind, Expr, ExprKind, FnSig, ImplItem, ImplItemKind, Item, ItemKind, OwnerId, PathSegment, QPath,
+};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::declare_lint_pass;
-use rustc_span::{Span, sym};
+use rustc_middle::ty::Ty;
+use rustc_session::impl_lint_pass;
+use rustc_span::{Ident, Span, Symbol};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -57,62 +56,165 @@ declare_clippy_lint! {
     "functions of type `Result<..>` or `Option`<...> that contain `expect()` or `unwrap()`"
 }
 
-declare_lint_pass!(UnwrapInResult=> [UNWRAP_IN_RESULT]);
+impl_lint_pass!(UnwrapInResult=> [UNWRAP_IN_RESULT]);
 
-impl<'tcx> LateLintPass<'tcx> for UnwrapInResult {
-    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx hir::ImplItem<'_>) {
-        if let ImplItemKind::Fn(ref _signature, _) = impl_item.kind
-            // first check if it's a method or function
-            // checking if its return type is `result` or `option`
-            && (is_type_diagnostic_item(cx, return_ty(cx, impl_item.owner_id), sym::Result)
-                || is_type_diagnostic_item(cx, return_ty(cx, impl_item.owner_id), sym::Option))
-        {
-            lint_impl_body(cx, impl_item.span, impl_item);
+#[derive(Clone, Copy, Eq, PartialEq)]
+enum OptionOrResult {
+    Option,
+    Result,
+}
+
+impl OptionOrResult {
+    fn with_article(self) -> &'static str {
+        match self {
+            Self::Option => "an `Option`",
+            Self::Result => "a `Result`",
         }
     }
 }
 
-fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, impl_item: &'tcx hir::ImplItem<'_>) {
-    if let ImplItemKind::Fn(_, body_id) = impl_item.kind {
-        let body = cx.tcx.hir_body(body_id);
-        let typeck = cx.tcx.typeck(impl_item.owner_id.def_id);
-        let mut result = Vec::new();
-        let _: Option<!> = for_each_expr(cx, body.value, |e| {
-            // check for `expect`
-            if let Some(arglists) = method_chain_args(e, &[sym::expect]) {
-                let receiver_ty = typeck.expr_ty(arglists[0].0).peel_refs();
-                if is_type_diagnostic_item(cx, receiver_ty, sym::Option)
-                    || is_type_diagnostic_item(cx, receiver_ty, sym::Result)
-                {
-                    result.push(e.span);
-                }
-            }
-
-            // check for `unwrap`
-            if let Some(arglists) = method_chain_args(e, &[sym::unwrap]) {
-                let receiver_ty = typeck.expr_ty(arglists[0].0).peel_refs();
-                if is_type_diagnostic_item(cx, receiver_ty, sym::Option)
-                    || is_type_diagnostic_item(cx, receiver_ty, sym::Result)
-                {
-                    result.push(e.span);
-                }
-            }
-
-            ControlFlow::Continue(())
+struct OptionOrResultFn {
+    kind: OptionOrResult,
+    return_ty_span: Option<Span>,
+}
+
+#[derive(Default)]
+pub struct UnwrapInResult {
+    fn_stack: Vec<Option<OptionOrResultFn>>,
+    current_fn: Option<OptionOrResultFn>,
+}
+
+impl UnwrapInResult {
+    fn enter_item(&mut self, cx: &LateContext<'_>, fn_def_id: OwnerId, sig: &FnSig<'_>) {
+        self.fn_stack.push(self.current_fn.take());
+        self.current_fn = is_option_or_result(cx, return_ty(cx, fn_def_id)).map(|kind| OptionOrResultFn {
+            kind,
+            return_ty_span: Some(sig.decl.output.span()),
         });
+    }
 
-        // if we've found one, lint
-        if !result.is_empty() {
+    fn leave_item(&mut self) {
+        self.current_fn = self.fn_stack.pop().unwrap();
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for UnwrapInResult {
+    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx ImplItem<'_>) {
+        if let ImplItemKind::Fn(sig, _) = &impl_item.kind {
+            self.enter_item(cx, impl_item.owner_id, sig);
+        }
+    }
+
+    fn check_impl_item_post(&mut self, _: &LateContext<'tcx>, impl_item: &'tcx ImplItem<'tcx>) {
+        if let ImplItemKind::Fn(..) = impl_item.kind {
+            self.leave_item();
+        }
+    }
+
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
+        if let ItemKind::Fn {
+            has_body: true, sig, ..
+        } = &item.kind
+        {
+            self.enter_item(cx, item.owner_id, sig);
+        }
+    }
+
+    fn check_item_post(&mut self, _: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
+        if let ItemKind::Fn { has_body: true, .. } = item.kind {
+            self.leave_item();
+        }
+    }
+
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) {
+        if expr.span.from_expansion() {
+            return;
+        }
+
+        if let Some(OptionOrResultFn {
+            kind,
+            ref mut return_ty_span,
+        }) = self.current_fn
+            && let Some((oor, fn_name)) = is_unwrap_or_expect_call(cx, expr)
+            && oor == kind
+        {
             span_lint_and_then(
                 cx,
                 UNWRAP_IN_RESULT,
-                impl_span,
-                "used unwrap or expect in a function that returns result or option",
-                move |diag| {
-                    diag.help("unwrap and expect should not be used in a function that returns result or option");
-                    diag.span_note(result, "potential non-recoverable error(s)");
+                expr.span,
+                format!("`{fn_name}` used in a function that returns {}", kind.with_article()),
+                |diag| {
+                    // Issue the note and help only once per function
+                    if let Some(span) = return_ty_span.take() {
+                        diag.span_note(span, "in this function signature");
+                        let complement = if kind == OptionOrResult::Result {
+                            " or calling the `.map_err()` method"
+                        } else {
+                            ""
+                        };
+                        diag.help(format!("consider using the `?` operator{complement}"));
+                    }
                 },
             );
         }
     }
+
+    fn check_body(&mut self, cx: &LateContext<'tcx>, body: &Body<'tcx>) {
+        let body_def_id = cx.tcx.hir_body_owner_def_id(body.id());
+        if !matches!(cx.tcx.hir_body_owner_kind(body_def_id), BodyOwnerKind::Fn) {
+            // When entering a body which is not a function, mask the potential surrounding
+            // function to not apply the lint.
+            self.fn_stack.push(self.current_fn.take());
+        }
+    }
+
+    fn check_body_post(&mut self, cx: &LateContext<'tcx>, body: &Body<'tcx>) {
+        let body_def_id = cx.tcx.hir_body_owner_def_id(body.id());
+        if !matches!(cx.tcx.hir_body_owner_kind(body_def_id), BodyOwnerKind::Fn) {
+            // Unmask the potential surrounding function.
+            self.current_fn = self.fn_stack.pop().unwrap();
+        }
+    }
+}
+
+fn is_option_or_result(cx: &LateContext<'_>, ty: Ty<'_>) -> Option<OptionOrResult> {
+    match ty.ty_adt_def().and_then(|def| cx.tcx.get_diagnostic_name(def.did())) {
+        Some(sym::Option) => Some(OptionOrResult::Option),
+        Some(sym::Result) => Some(OptionOrResult::Result),
+        _ => None,
+    }
+}
+
+fn is_unwrap_or_expect_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<(OptionOrResult, Symbol)> {
+    if let ExprKind::Call(func, _) = expr.kind
+        && let ExprKind::Path(QPath::TypeRelative(
+            hir_ty,
+            PathSegment {
+                ident:
+                    Ident {
+                        name: name @ (sym::unwrap | sym::expect),
+                        ..
+                    },
+                ..
+            },
+        )) = func.kind
+    {
+        is_option_or_result(cx, cx.typeck_results().node_type(hir_ty.hir_id)).map(|oor| (oor, *name))
+    } else if let ExprKind::MethodCall(
+        PathSegment {
+            ident: Ident {
+                name: name @ (sym::unwrap | sym::expect),
+                ..
+            },
+            ..
+        },
+        recv,
+        _,
+        _,
+    ) = expr.kind
+    {
+        is_option_or_result(cx, cx.typeck_results().expr_ty_adjusted(recv)).map(|oor| (oor, *name))
+    } else {
+        None
+    }
 }
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index e5b20c0e0a133..70ae982a4458b 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -386,12 +386,13 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
 
             ExprKind::Call(path, [arg]) => {
                 if let ExprKind::Path(ref qpath) = path.kind
-                    && let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id()
                     && !is_ty_alias(qpath)
+                    && let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id()
+                    && let Some(name) = cx.tcx.get_diagnostic_name(def_id)
                 {
                     let a = cx.typeck_results().expr_ty(e);
                     let b = cx.typeck_results().expr_ty(arg);
-                    if cx.tcx.is_diagnostic_item(sym::try_from_fn, def_id)
+                    if name == sym::try_from_fn
                         && is_type_diagnostic_item(cx, a, sym::Result)
                         && let ty::Adt(_, args) = a.kind()
                         && let Some(a_type) = args.types().next()
@@ -406,9 +407,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                             None,
                             hint,
                         );
-                    }
-
-                    if cx.tcx.is_diagnostic_item(sym::from_fn, def_id) && same_type_and_consts(a, b) {
+                    } else if name == sym::from_fn && same_type_and_consts(a, b) {
                         let mut app = Applicability::MachineApplicable;
                         let sugg = Sugg::hir_with_context(cx, arg, e.span.ctxt(), "<expr>", &mut app).maybe_paren();
                         let sugg_msg = format!("consider removing `{}()`", snippet(cx, path.span, "From::from"));
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index 7b6a25123e85e..52b30ddce12b8 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -1,4 +1,6 @@
 use std::collections::BTreeMap;
+use std::collections::btree_map::Entry;
+use std::mem;
 use std::ops::ControlFlow;
 
 use clippy_config::Conf;
@@ -20,15 +22,36 @@ use rustc_span::{DesugaringKind, Span};
 pub struct UselessVec {
     too_large_for_stack: u64,
     msrv: Msrv,
-    span_to_lint_map: BTreeMap<Span, Option<(HirId, SuggestedType, String, Applicability)>>,
+    /// Maps from a `vec![]` source callsite invocation span to the "state" (i.e., whether we can
+    /// emit a warning there or not).
+    ///
+    /// The purpose of this is to buffer lints up until `check_crate_post` so that we can cancel a
+    /// lint while visiting, because a `vec![]` invocation span can appear multiple times when
+    /// it is passed as a macro argument, once in a context that doesn't require a `Vec<_>` and
+    /// another time that does. Consider:
+    /// ```
+    /// macro_rules! m {
+    ///     ($v:expr) => {
+    ///         let a = $v;
+    ///         $v.push(3);
+    ///     }
+    /// }
+    /// m!(vec![1, 2]);
+    /// ```
+    /// The macro invocation expands to two `vec![1, 2]` invocations. If we eagerly suggest changing
+    /// the first `vec![1, 2]` (which is shared with the other expn) to an array which indeed would
+    /// work, we get a false positive warning on the `$v.push(3)` which really requires `$v` to
+    /// be a vector.
+    span_to_state: BTreeMap<Span, VecState>,
     allow_in_test: bool,
 }
+
 impl UselessVec {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
             too_large_for_stack: conf.too_large_for_stack,
             msrv: conf.msrv,
-            span_to_lint_map: BTreeMap::new(),
+            span_to_state: BTreeMap::new(),
             allow_in_test: conf.allow_useless_vec_in_tests,
         }
     }
@@ -62,17 +85,28 @@ declare_clippy_lint! {
 
 impl_lint_pass!(UselessVec => [USELESS_VEC]);
 
-impl<'tcx> LateLintPass<'tcx> for UselessVec {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        let Some(vec_args) = higher::VecArgs::hir(cx, expr.peel_borrows()) else {
-            return;
-        };
-        if self.allow_in_test && is_in_test(cx.tcx, expr.hir_id) {
-            return;
-        }
-        // the parent callsite of this `vec!` expression, or span to the borrowed one such as `&vec!`
-        let callsite = expr.span.parent_callsite().unwrap_or(expr.span);
+/// The "state" of a `vec![]` invocation, indicating whether it can or cannot be changed.
+enum VecState {
+    Change {
+        suggest_ty: SuggestedType,
+        vec_snippet: String,
+        expr_hir_id: HirId,
+    },
+    NoChange,
+}
+
+enum VecToArray {
+    /// Expression does not need to be a `Vec<_>` and its type can be changed to an array (or
+    /// slice).
+    Possible,
+    /// Expression must be a `Vec<_>`. Type cannot change.
+    Impossible,
+}
 
+impl UselessVec {
+    /// Checks if the surrounding environment requires this expression to actually be of type
+    /// `Vec<_>`, or if it can be changed to `&[]`/`[]` without causing type errors.
+    fn expr_usage_requires_vec(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) -> VecToArray {
         match cx.tcx.parent_hir_node(expr.hir_id) {
             // search for `let foo = vec![_]` expressions where all uses of `foo`
             // adjust to slices or call a method that exist on slices (e.g. len)
@@ -100,110 +134,126 @@ impl<'tcx> LateLintPass<'tcx> for UselessVec {
                 .is_continue();
 
                 if only_slice_uses {
-                    self.check_vec_macro(cx, &vec_args, callsite, expr.hir_id, SuggestedType::Array);
+                    VecToArray::Possible
                 } else {
-                    self.span_to_lint_map.insert(callsite, None);
+                    VecToArray::Impossible
                 }
             },
             // if the local pattern has a specified type, do not lint.
             Node::LetStmt(LetStmt { ty: Some(_), .. }) if higher::VecArgs::hir(cx, expr).is_some() => {
-                self.span_to_lint_map.insert(callsite, None);
+                VecToArray::Impossible
             },
             // search for `for _ in vec![...]`
             Node::Expr(Expr { span, .. })
                 if span.is_desugaring(DesugaringKind::ForLoop) && self.msrv.meets(cx, msrvs::ARRAY_INTO_ITERATOR) =>
             {
-                let suggest_slice = suggest_type(expr);
-                self.check_vec_macro(cx, &vec_args, callsite, expr.hir_id, suggest_slice);
+                VecToArray::Possible
             },
             // search for `&vec![_]` or `vec![_]` expressions where the adjusted type is `&[_]`
             _ => {
-                let suggest_slice = suggest_type(expr);
-
                 if adjusts_to_slice(cx, expr) {
-                    self.check_vec_macro(cx, &vec_args, callsite, expr.hir_id, suggest_slice);
+                    VecToArray::Possible
                 } else {
-                    self.span_to_lint_map.insert(callsite, None);
+                    VecToArray::Impossible
                 }
             },
         }
     }
+}
+
+impl<'tcx> LateLintPass<'tcx> for UselessVec {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if let Some(vec_args) = higher::VecArgs::hir(cx, expr.peel_borrows())
+            // The `vec![]` or `&vec![]` invocation span.
+            && let vec_span = expr.span.parent_callsite().unwrap_or(expr.span)
+            && !vec_span.from_expansion()
+        {
+            if self.allow_in_test && is_in_test(cx.tcx, expr.hir_id) {
+                return;
+            }
+
+            match self.expr_usage_requires_vec(cx, expr) {
+                VecToArray::Possible => {
+                    let suggest_ty = suggest_type(expr);
+
+                    // Size and `Copy` checks don't depend on the enclosing usage of the expression
+                    // and don't need to be inserted into the state map.
+                    let vec_snippet = match vec_args {
+                        higher::VecArgs::Repeat(expr, len) => {
+                            if is_copy(cx, cx.typeck_results().expr_ty(expr))
+                                && let Some(Constant::Int(length)) = ConstEvalCtxt::new(cx).eval(len)
+                                && let Ok(length) = u64::try_from(length)
+                                && size_of(cx, expr)
+                                    .checked_mul(length)
+                                    .is_some_and(|size| size <= self.too_large_for_stack)
+                            {
+                                suggest_ty.snippet(
+                                    cx,
+                                    Some(expr.span.source_callsite()),
+                                    Some(len.span.source_callsite()),
+                                )
+                            } else {
+                                return;
+                            }
+                        },
+                        higher::VecArgs::Vec(args) => {
+                            if let Ok(length) = u64::try_from(args.len())
+                                && size_of(cx, expr)
+                                    .checked_mul(length)
+                                    .is_some_and(|size| size <= self.too_large_for_stack)
+                            {
+                                suggest_ty.snippet(
+                                    cx,
+                                    args.first().zip(args.last()).map(|(first, last)| {
+                                        first.span.source_callsite().to(last.span.source_callsite())
+                                    }),
+                                    None,
+                                )
+                            } else {
+                                return;
+                            }
+                        },
+                    };
+
+                    if let Entry::Vacant(entry) = self.span_to_state.entry(vec_span) {
+                        entry.insert(VecState::Change {
+                            suggest_ty,
+                            vec_snippet,
+                            expr_hir_id: expr.hir_id,
+                        });
+                    }
+                },
+                VecToArray::Impossible => {
+                    self.span_to_state.insert(vec_span, VecState::NoChange);
+                },
+            }
+        }
+    }
 
     fn check_crate_post(&mut self, cx: &LateContext<'tcx>) {
-        for (span, lint_opt) in &self.span_to_lint_map {
-            if let Some((hir_id, suggest_slice, snippet, applicability)) = lint_opt {
-                let help_msg = format!("you can use {} directly", suggest_slice.desc());
-                span_lint_hir_and_then(cx, USELESS_VEC, *hir_id, *span, "useless use of `vec!`", |diag| {
-                    // If the `vec!` macro contains comment, better not make the suggestion machine
-                    // applicable as it would remove them.
-                    let applicability = if *applicability != Applicability::Unspecified
-                        && let source_map = cx.tcx.sess.source_map()
-                        && span_contains_comment(source_map, *span)
-                    {
+        for (span, state) in mem::take(&mut self.span_to_state) {
+            if let VecState::Change {
+                suggest_ty,
+                vec_snippet,
+                expr_hir_id,
+            } = state
+            {
+                span_lint_hir_and_then(cx, USELESS_VEC, expr_hir_id, span, "useless use of `vec!`", |diag| {
+                    let help_msg = format!("you can use {} directly", suggest_ty.desc());
+                    // If the `vec!` macro contains comment, better not make the suggestion machine applicable as it
+                    // would remove them.
+                    let applicability = if span_contains_comment(cx.tcx.sess.source_map(), span) {
                         Applicability::Unspecified
                     } else {
-                        *applicability
+                        Applicability::MachineApplicable
                     };
-                    diag.span_suggestion(*span, help_msg, snippet, applicability);
+                    diag.span_suggestion(span, help_msg, vec_snippet, applicability);
                 });
             }
         }
     }
 }
 
-impl UselessVec {
-    fn check_vec_macro<'tcx>(
-        &mut self,
-        cx: &LateContext<'tcx>,
-        vec_args: &higher::VecArgs<'tcx>,
-        span: Span,
-        hir_id: HirId,
-        suggest_slice: SuggestedType,
-    ) {
-        if span.from_expansion() {
-            return;
-        }
-
-        let snippet = match *vec_args {
-            higher::VecArgs::Repeat(elem, 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;
-                    }
-
-                    #[expect(clippy::cast_possible_truncation)]
-                    if len_constant as u64 * size_of(cx, elem) > self.too_large_for_stack {
-                        return;
-                    }
-
-                    suggest_slice.snippet(cx, Some(elem.span), Some(len.span))
-                } else {
-                    return;
-                }
-            },
-            higher::VecArgs::Vec(args) => {
-                let args_span = if let Some(last) = args.iter().last() {
-                    if args.len() as u64 * size_of(cx, last) > self.too_large_for_stack {
-                        return;
-                    }
-                    Some(args[0].span.source_callsite().to(last.span.source_callsite()))
-                } else {
-                    None
-                };
-                suggest_slice.snippet(cx, args_span, None)
-            },
-        };
-
-        self.span_to_lint_map.entry(span).or_insert(Some((
-            hir_id,
-            suggest_slice,
-            snippet,
-            Applicability::MachineApplicable,
-        )));
-    }
-}
-
 #[derive(Copy, Clone)]
 pub(crate) enum SuggestedType {
     /// Suggest using a slice `&[..]` / `&mut [..]`
@@ -221,11 +271,17 @@ impl SuggestedType {
     }
 
     fn snippet(self, cx: &LateContext<'_>, args_span: Option<Span>, len_span: Option<Span>) -> String {
+        // Invariant of the lint as implemented: all spans are from the root context (and as a result,
+        // always trivially crate-local).
+        assert!(args_span.is_none_or(|s| !s.from_expansion()));
+        assert!(len_span.is_none_or(|s| !s.from_expansion()));
+
         let maybe_args = args_span
-            .and_then(|sp| sp.get_source_text(cx))
+            .map(|sp| sp.get_source_text(cx).expect("spans are always crate-local"))
             .map_or(String::new(), |x| x.to_owned());
         let maybe_len = len_span
-            .and_then(|sp| sp.get_source_text(cx).map(|s| format!("; {s}")))
+            .map(|sp| sp.get_source_text(cx).expect("spans are always crate-local"))
+            .map(|st| format!("; {st}"))
             .unwrap_or_default();
 
         match self {
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index a15e4e42e71df..c55c5ec2f51ae 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -537,7 +537,7 @@ fn check_literal(cx: &LateContext<'_>, format_args: &FormatArgs, name: &str) {
 
             sug_span = Some(sug_span.unwrap_or(arg.expr.span).to(arg.expr.span));
 
-            if let Some((_, index)) = positional_arg_piece_span(piece) {
+            if let Some((_, index)) = format_arg_piece_span(piece) {
                 replaced_position.push(index);
             }
 
@@ -569,16 +569,11 @@ fn check_literal(cx: &LateContext<'_>, format_args: &FormatArgs, name: &str) {
     }
 }
 
-/// Extract Span and its index from the given `piece`, if it's positional argument.
-fn positional_arg_piece_span(piece: &FormatArgsPiece) -> Option<(Span, usize)> {
+/// Extract Span and its index from the given `piece`
+fn format_arg_piece_span(piece: &FormatArgsPiece) -> Option<(Span, usize)> {
     match piece {
         FormatArgsPiece::Placeholder(FormatPlaceholder {
-            argument:
-                FormatArgPosition {
-                    index: Ok(index),
-                    kind: FormatArgPositionKind::Number,
-                    ..
-                },
+            argument: FormatArgPosition { index: Ok(index), .. },
             span: Some(span),
             ..
         }) => Some((*span, *index)),
diff --git a/clippy_lints/src/zombie_processes.rs b/clippy_lints/src/zombie_processes.rs
index 6ab94a5221092..a934d2094e004 100644
--- a/clippy_lints/src/zombie_processes.rs
+++ b/clippy_lints/src/zombie_processes.rs
@@ -1,5 +1,6 @@
 use ControlFlow::{Break, Continue};
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{fn_def_id, get_enclosing_block, path_to_local_id};
 use rustc_ast::Mutability;
 use rustc_ast::visit::visit_opt;
@@ -58,8 +59,8 @@ declare_lint_pass!(ZombieProcesses => [ZOMBIE_PROCESSES]);
 impl<'tcx> LateLintPass<'tcx> for ZombieProcesses {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         if let ExprKind::Call(..) | ExprKind::MethodCall(..) = expr.kind
-            && let Some(child_adt) = cx.typeck_results().expr_ty(expr).ty_adt_def()
-            && cx.tcx.is_diagnostic_item(sym::Child, child_adt.did())
+            && let child_ty = cx.typeck_results().expr_ty(expr)
+            && is_type_diagnostic_item(cx, child_ty, sym::Child)
         {
             match cx.tcx.parent_hir_node(expr.hir_id) {
                 Node::LetStmt(local)
@@ -177,8 +178,8 @@ impl<'tcx> Visitor<'tcx> for WaitFinder<'_, 'tcx> {
                 Node::Expr(expr) if let ExprKind::AddrOf(_, Mutability::Not, _) = expr.kind => {},
                 Node::Expr(expr)
                     if let Some(fn_did) = fn_def_id(self.cx, expr)
-                        && (self.cx.tcx.is_diagnostic_item(sym::child_id, fn_did)
-                            || self.cx.tcx.is_diagnostic_item(sym::child_kill, fn_did)) => {},
+                        && let Some(fn_name) = self.cx.tcx.get_diagnostic_name(fn_did)
+                        && matches!(fn_name, sym::child_id | sym::child_kill) => {},
 
                 // Conservatively assume that all other kinds of nodes call `.wait()` somehow.
                 _ => return Break(MaybeWait(ex.span)),
@@ -351,9 +352,14 @@ fn check<'tcx>(cx: &LateContext<'tcx>, spawn_expr: &'tcx Expr<'tcx>, cause: Caus
 
 /// Checks if the given expression exits the process.
 fn is_exit_expression(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    fn_def_id(cx, expr).is_some_and(|fn_did| {
-        cx.tcx.is_diagnostic_item(sym::process_exit, fn_did) || cx.tcx.is_diagnostic_item(sym::process_abort, fn_did)
-    })
+    if let Some(fn_did) = fn_def_id(cx, expr)
+        && let Some(fn_name) = cx.tcx.get_diagnostic_name(fn_did)
+        && matches!(fn_name, sym::process_exit | sym::process_abort)
+    {
+        true
+    } else {
+        false
+    }
 }
 
 #[derive(Debug)]
diff --git a/clippy_utils/README.md b/clippy_utils/README.md
index 2dfe28953d0c1..e01f563c49e73 100644
--- a/clippy_utils/README.md
+++ b/clippy_utils/README.md
@@ -8,7 +8,7 @@ This crate is only guaranteed to build with this `nightly` toolchain:
 
 <!-- begin autogenerated nightly -->
 ```
-nightly-2025-08-22
+nightly-2025-09-04
 ```
 <!-- end autogenerated nightly -->
 
diff --git a/clippy_utils/src/ast_utils/mod.rs b/clippy_utils/src/ast_utils/mod.rs
index 40c00568a3bde..ad69e6eb184e1 100644
--- a/clippy_utils/src/ast_utils/mod.rs
+++ b/clippy_utils/src/ast_utils/mod.rs
@@ -21,7 +21,7 @@ pub fn is_useless_with_eq_exprs(kind: BinOpKind) -> bool {
 }
 
 /// Checks if each element in the first slice is contained within the latter as per `eq_fn`.
-pub fn unordered_over<X>(left: &[X], right: &[X], mut eq_fn: impl FnMut(&X, &X) -> bool) -> bool {
+pub fn unordered_over<X, Y>(left: &[X], right: &[Y], mut eq_fn: impl FnMut(&X, &Y) -> bool) -> bool {
     left.len() == right.len() && left.iter().all(|l| right.iter().any(|r| eq_fn(l, r)))
 }
 
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 4e0b00df9508d..bda28a663fb07 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -287,23 +287,22 @@ impl<'a> VecArgs<'a> {
             && let ExprKind::Path(ref qpath) = fun.kind
             && is_expn_of(fun.span, sym::vec).is_some()
             && let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id()
+            && let Some(name) = cx.tcx.get_diagnostic_name(fun_def_id)
         {
-            return if cx.tcx.is_diagnostic_item(sym::vec_from_elem, fun_def_id) && args.len() == 2 {
-                // `vec![elem; size]` case
-                Some(VecArgs::Repeat(&args[0], &args[1]))
-            } else if cx.tcx.is_diagnostic_item(sym::slice_into_vec, fun_def_id) && args.len() == 1 {
-                // `vec![a, b, c]` case
-                if let ExprKind::Call(_, [arg]) = &args[0].kind
-                    && let ExprKind::Array(args) = arg.kind
+            return match (name, args) {
+                (sym::vec_from_elem, [elem, size]) => {
+                    // `vec![elem; size]` case
+                    Some(VecArgs::Repeat(elem, size))
+                },
+                (sym::slice_into_vec, [slice])
+                    if let ExprKind::Call(_, [arg]) = slice.kind
+                        && let ExprKind::Array(args) = arg.kind =>
                 {
+                    // `vec![a, b, c]` case
                     Some(VecArgs::Vec(args))
-                } else {
-                    None
-                }
-            } else if cx.tcx.is_diagnostic_item(sym::vec_new, fun_def_id) && args.is_empty() {
-                Some(VecArgs::Vec(&[]))
-            } else {
-                None
+                },
+                (sym::vec_new, []) => Some(VecArgs::Vec(&[])),
+                _ => None,
             };
         }
 
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index 8160443f4132f..b79e15cd7170b 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -757,7 +757,7 @@ pub fn both_some_and<X, Y>(l: Option<X>, r: Option<Y>, mut pred: impl FnMut(X, Y
 }
 
 /// Checks if two slices are equal as per `eq_fn`.
-pub fn over<X>(left: &[X], right: &[X], mut eq_fn: impl FnMut(&X, &X) -> bool) -> bool {
+pub fn over<X, Y>(left: &[X], right: &[Y], mut eq_fn: impl FnMut(&X, &Y) -> bool) -> bool {
     left.len() == right.len() && left.iter().zip(right).all(|(x, y)| eq_fn(x, y))
 }
 
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 011c9b2f931ae..14b64eb4d54e8 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -102,9 +102,9 @@ use rustc_hir::hir_id::{HirIdMap, HirIdSet};
 use rustc_hir::intravisit::{FnKind, Visitor, walk_expr};
 use rustc_hir::{
     self as hir, Arm, BindingMode, Block, BlockCheckMode, Body, ByRef, Closure, ConstArgKind, CoroutineDesugaring,
-    CoroutineKind, Destination, Expr, ExprField, ExprKind, FnDecl, FnRetTy, GenericArg, GenericArgs, HirId, Impl,
-    ImplItem, ImplItemKind, Item, ItemKind, LangItem, LetStmt, MatchSource, Mutability, Node, OwnerId, OwnerNode,
-    Param, Pat, PatExpr, PatExprKind, PatKind, Path, PathSegment, QPath, Stmt, StmtKind, TraitFn, TraitItem,
+    CoroutineKind, CoroutineSource, Destination, Expr, ExprField, ExprKind, FnDecl, FnRetTy, GenericArg, GenericArgs,
+    HirId, Impl, ImplItem, ImplItemKind, Item, ItemKind, LangItem, LetStmt, MatchSource, Mutability, Node, OwnerId,
+    OwnerNode, Param, Pat, PatExpr, PatExprKind, PatKind, Path, PathSegment, QPath, Stmt, StmtKind, TraitFn, TraitItem,
     TraitItemKind, TraitRef, TyKind, UnOp, def, find_attr,
 };
 use rustc_lexer::{FrontmatterAllowed, TokenKind, tokenize};
@@ -126,6 +126,7 @@ use rustc_span::{InnerSpan, Span};
 use source::{SpanRangeExt, walk_span_to_context};
 use visitors::{Visitable, for_each_unconsumed_temporary};
 
+use crate::ast_utils::unordered_over;
 use crate::consts::{ConstEvalCtxt, Constant, mir_to_const};
 use crate::higher::Range;
 use crate::ty::{adt_and_variant_of_res, can_partially_move_ty, expr_sig, is_copy, is_recursively_primitive_type};
@@ -308,6 +309,7 @@ pub fn is_lang_item_or_ctor(cx: &LateContext<'_>, did: DefId, item: LangItem) ->
     cx.tcx.lang_items().get(item) == Some(did)
 }
 
+/// Checks if `expr` is an empty block or an empty tuple.
 pub fn is_unit_expr(expr: &Expr<'_>) -> bool {
     matches!(
         expr.kind,
@@ -640,9 +642,8 @@ fn is_default_equivalent_ctor(cx: &LateContext<'_>, def_id: DefId, path: &QPath<
         && let Some(impl_did) = cx.tcx.impl_of_assoc(def_id)
         && let Some(adt) = cx.tcx.type_of(impl_did).instantiate_identity().ty_adt_def()
     {
-        return std_types_symbols.iter().any(|&symbol| {
-            cx.tcx.is_diagnostic_item(symbol, adt.did()) || Some(adt.did()) == cx.tcx.lang_items().string()
-        });
+        return Some(adt.did()) == cx.tcx.lang_items().string()
+            || (cx.tcx.get_diagnostic_name(adt.did())).is_some_and(|adt_name| std_types_symbols.contains(&adt_name));
     }
     false
 }
@@ -1992,7 +1993,7 @@ pub fn is_expr_identity_of_pat(cx: &LateContext<'_>, pat: &Pat<'_>, expr: &Expr<
         (PatKind::Tuple(pats, dotdot), ExprKind::Tup(tup))
             if dotdot.as_opt_usize().is_none() && pats.len() == tup.len() =>
         {
-            zip(pats, tup).all(|(pat, expr)| is_expr_identity_of_pat(cx, pat, expr, by_hir))
+            over(pats, tup, |pat, expr| is_expr_identity_of_pat(cx, pat, expr, by_hir))
         },
         (PatKind::Slice(before, None, after), ExprKind::Array(arr)) if before.len() + after.len() == arr.len() => {
             zip(before.iter().chain(after), arr).all(|(pat, expr)| is_expr_identity_of_pat(cx, pat, expr, by_hir))
@@ -2004,7 +2005,7 @@ pub fn is_expr_identity_of_pat(cx: &LateContext<'_>, pat: &Pat<'_>, expr: &Expr<
             if let ExprKind::Path(ident) = &ident.kind
                 && qpath_res(&pat_ident, pat.hir_id) == qpath_res(ident, expr.hir_id)
                 // check fields
-                && zip(field_pats, fields).all(|(pat, expr)| is_expr_identity_of_pat(cx, pat, expr,by_hir))
+                && over(field_pats, fields, |pat, expr| is_expr_identity_of_pat(cx, pat, expr,by_hir))
             {
                 true
             } else {
@@ -2017,10 +2018,8 @@ pub fn is_expr_identity_of_pat(cx: &LateContext<'_>, pat: &Pat<'_>, expr: &Expr<
             // check ident
             qpath_res(&pat_ident, pat.hir_id) == qpath_res(ident, expr.hir_id)
                 // check fields
-                && field_pats.iter().all(|field_pat| {
-                    fields.iter().any(|field| {
-                        field_pat.ident == field.ident && is_expr_identity_of_pat(cx, field_pat.pat, field.expr, by_hir)
-                    })
+                && unordered_over(field_pats, fields, |field_pat, field| {
+                    field_pat.ident == field.ident && is_expr_identity_of_pat(cx, field_pat.pat, field.expr, by_hir)
                 })
         },
         _ => false,
@@ -2405,6 +2404,24 @@ pub fn peel_ref_operators<'hir>(cx: &LateContext<'_>, mut expr: &'hir Expr<'hir>
     expr
 }
 
+/// Returns a `Vec` of `Expr`s containing `AddrOf` operators (`&`) or deref operators (`*`) of a
+/// given expression.
+pub fn get_ref_operators<'hir>(cx: &LateContext<'_>, expr: &'hir Expr<'hir>) -> Vec<&'hir Expr<'hir>> {
+    let mut operators = Vec::new();
+    peel_hir_expr_while(expr, |expr| match expr.kind {
+        ExprKind::AddrOf(_, _, e) => {
+            operators.push(expr);
+            Some(e)
+        },
+        ExprKind::Unary(UnOp::Deref, e) if cx.typeck_results().expr_ty(e).is_ref() => {
+            operators.push(expr);
+            Some(e)
+        },
+        _ => None,
+    });
+    operators
+}
+
 pub fn is_hir_ty_cfg_dependant(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> bool {
     if let TyKind::Path(QPath::Resolved(_, path)) = ty.kind
         && let Res::Def(_, def_id) = path.res
@@ -3633,3 +3650,17 @@ pub fn expr_adjustment_requires_coercion(cx: &LateContext<'_>, expr: &Expr<'_>)
         )
     })
 }
+
+/// Checks if the expression is an async block (i.e., `async { ... }`).
+pub fn is_expr_async_block(expr: &Expr<'_>) -> bool {
+    matches!(
+        expr.kind,
+        ExprKind::Closure(Closure {
+            kind: hir::ClosureKind::Coroutine(CoroutineKind::Desugared(
+                CoroutineDesugaring::Async,
+                CoroutineSource::Block
+            )),
+            ..
+        })
+    )
+}
diff --git a/clippy_utils/src/ty/mod.rs b/clippy_utils/src/ty/mod.rs
index fafc1d07e51eb..8e302f9d2ad12 100644
--- a/clippy_utils/src/ty/mod.rs
+++ b/clippy_utils/src/ty/mod.rs
@@ -387,10 +387,7 @@ pub fn is_recursively_primitive_type(ty: Ty<'_>) -> bool {
 /// Checks if the type is a reference equals to a diagnostic item
 pub fn is_type_ref_to_diagnostic_item(cx: &LateContext<'_>, ty: Ty<'_>, diag_item: Symbol) -> bool {
     match ty.kind() {
-        ty::Ref(_, ref_ty, _) => match ref_ty.kind() {
-            ty::Adt(adt, _) => cx.tcx.is_diagnostic_item(diag_item, adt.did()),
-            _ => false,
-        },
+        ty::Ref(_, ref_ty, _) => is_type_diagnostic_item(cx, *ref_ty, diag_item),
         _ => false,
     }
 }
@@ -1378,9 +1375,7 @@ pub fn has_non_owning_mutable_access<'tcx>(cx: &LateContext<'tcx>, iter_ty: Ty<'
 
 /// Check if `ty` is slice-like, i.e., `&[T]`, `[T; N]`, or `Vec<T>`.
 pub fn is_slice_like<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-    ty.is_slice()
-        || ty.is_array()
-        || matches!(ty.kind(), ty::Adt(adt_def, _) if cx.tcx.is_diagnostic_item(sym::Vec, adt_def.did()))
+    ty.is_slice() || ty.is_array() || is_type_diagnostic_item(cx, ty, sym::Vec)
 }
 
 pub fn get_field_idx_by_name(ty: Ty<'_>, name: Symbol) -> Option<usize> {
diff --git a/clippy_utils/src/usage.rs b/clippy_utils/src/usage.rs
index 76d43feee12ea..6eccbcdb12281 100644
--- a/clippy_utils/src/usage.rs
+++ b/clippy_utils/src/usage.rs
@@ -144,11 +144,9 @@ impl<'tcx> Visitor<'tcx> for BindingUsageFinder<'_, 'tcx> {
 
 /// Checks if the given expression is a macro call to `todo!()` or `unimplemented!()`.
 pub fn is_todo_unimplemented_macro(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    root_macro_call_first_node(cx, expr).is_some_and(|macro_call| {
-        [sym::todo_macro, sym::unimplemented_macro]
-            .iter()
-            .any(|&sym| cx.tcx.is_diagnostic_item(sym, macro_call.def_id))
-    })
+    root_macro_call_first_node(cx, expr)
+        .and_then(|macro_call| cx.tcx.get_diagnostic_name(macro_call.def_id))
+        .is_some_and(|macro_name| matches!(macro_name, sym::todo_macro | sym::unimplemented_macro))
 }
 
 /// Checks if the given expression is a stub, i.e., a `todo!()` or `unimplemented!()` expression,
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index 5497e77e8ad17..ec2f24a0a6d84 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,6 +1,6 @@
 [toolchain]
 # begin autogenerated nightly
-channel = "nightly-2025-08-22"
+channel = "nightly-2025-09-04"
 # end autogenerated nightly
 components = ["cargo", "llvm-tools", "rust-src", "rust-std", "rustc", "rustc-dev", "rustfmt"]
 profile = "minimal"
diff --git a/src/driver.rs b/src/driver.rs
index c4076cbaa77b2..6bddcbfd94ce4 100644
--- a/src/driver.rs
+++ b/src/driver.rs
@@ -330,7 +330,8 @@ pub fn main() {
 
         // Do not run Clippy for Cargo's info queries so that invalid CLIPPY_ARGS are not cached
         // https://github.com/rust-lang/cargo/issues/14385
-        let info_query = has_arg(&orig_args, "-vV") || has_arg(&orig_args, "--print");
+        let info_query = has_arg(&orig_args, "-vV")
+            || arg_value(&orig_args, "--print", |val| val != "crate-root-lint-levels").is_some();
 
         let clippy_enabled = !cap_lints_allow && relevant_package && !info_query;
         if clippy_enabled {
diff --git a/tests/config-consistency.rs b/tests/config-consistency.rs
new file mode 100644
index 0000000000000..9e7ca26c7d400
--- /dev/null
+++ b/tests/config-consistency.rs
@@ -0,0 +1,30 @@
+#![feature(rustc_private)]
+
+// This test checks that all lints defined in `clippy_config::conf` in `#[lints]`
+// attributes exist as Clippy lints.
+//
+// This test is a no-op if run as part of the compiler test suite
+// and will always succeed.
+
+use std::collections::HashSet;
+
+#[test]
+fn config_consistency() {
+    if option_env!("RUSTC_TEST_SUITE").is_some() {
+        return;
+    }
+
+    let lint_names: HashSet<String> = clippy_lints::declared_lints::LINTS
+        .iter()
+        .map(|lint_info| lint_info.lint.name.strip_prefix("clippy::").unwrap().to_lowercase())
+        .collect();
+    for conf in clippy_config::get_configuration_metadata() {
+        for lint in conf.lints {
+            assert!(
+                lint_names.contains(*lint),
+                "Configuration option {} references lint `{lint}` which does not exist",
+                conf.name
+            );
+        }
+    }
+}
diff --git a/tests/no-profile-in-cargo-toml.rs b/tests/no-profile-in-cargo-toml.rs
new file mode 100644
index 0000000000000..2ad9bfb75dee8
--- /dev/null
+++ b/tests/no-profile-in-cargo-toml.rs
@@ -0,0 +1,34 @@
+// Check that we do not have `profile.*` sections in our `Cargo.toml` files,
+// as this causes warnings when run from the compiler repository which includes
+// Clippy in a workspace.
+//
+// Those sections can be put into `.cargo/config.toml` which will be read
+// when commands are issued from the top-level Clippy directory, outside of
+// a workspace.
+
+use std::fs::File;
+use std::io::{self, BufRead as _};
+use walkdir::WalkDir;
+
+#[test]
+fn no_profile_in_cargo_toml() {
+    // This check could parse `Cargo.toml` using a TOML deserializer, but in practice
+    // profile sections would be added at the beginning of a line as `[profile.*]`, so
+    // keep it fast and simple.
+    for entry in WalkDir::new(".")
+        .into_iter()
+        .filter_map(Result::ok)
+        .filter(|e| e.file_name().to_str() == Some("Cargo.toml"))
+    {
+        for line in io::BufReader::new(File::open(entry.path()).unwrap())
+            .lines()
+            .map(Result::unwrap)
+        {
+            if line.starts_with("[profile.") {
+                eprintln!("Profile section `{line}` found in file `{}`.", entry.path().display());
+                eprintln!("Use `.cargo/config.toml` for profiles specific to the standalone Clippy repository.");
+                panic!("Profile section found in `Cargo.toml`");
+            }
+        }
+    }
+}
diff --git a/tests/ui-internal/disallow_span_lint.stderr b/tests/ui-internal/disallow_span_lint.stderr
index f03a745963e00..e9d53c64dd9b5 100644
--- a/tests/ui-internal/disallow_span_lint.stderr
+++ b/tests/ui-internal/disallow_span_lint.stderr
@@ -4,7 +4,7 @@ error: use of a disallowed method `rustc_lint::context::LintContext::span_lint`
 LL |     cx.span_lint(lint, span, |lint| {
    |        ^^^^^^^^^
    |
-   = note: this function does not add a link to our documentation, please use the `clippy_utils::diagnostics::span_lint*` functions instead
+   = note: this function does not add a link to our documentation; please use the `clippy_utils::diagnostics::span_lint*` functions instead
 note: the lint level is defined here
   --> tests/ui-internal/disallow_span_lint.rs:2:9
    |
@@ -17,7 +17,7 @@ error: use of a disallowed method `rustc_middle::ty::context::TyCtxt::node_span_
 LL |     tcx.node_span_lint(lint, hir_id, span, |lint| {
    |         ^^^^^^^^^^^^^^
    |
-   = note: this function does not add a link to our documentation, please use the `clippy_utils::diagnostics::span_lint_hir*` functions instead
+   = note: this function does not add a link to our documentation; please use the `clippy_utils::diagnostics::span_lint_hir*` functions instead
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui-toml/excessive_precision/clippy.toml b/tests/ui-toml/excessive_precision/clippy.toml
new file mode 100644
index 0000000000000..c7fc230dcb31c
--- /dev/null
+++ b/tests/ui-toml/excessive_precision/clippy.toml
@@ -0,0 +1 @@
+const-literal-digits-threshold = 20
diff --git a/tests/ui-toml/excessive_precision/excessive_precision.fixed b/tests/ui-toml/excessive_precision/excessive_precision.fixed
new file mode 100644
index 0000000000000..577bbff2957fb
--- /dev/null
+++ b/tests/ui-toml/excessive_precision/excessive_precision.fixed
@@ -0,0 +1,38 @@
+#![warn(clippy::excessive_precision)]
+#![allow(
+    dead_code,
+    overflowing_literals,
+    unused_variables,
+    clippy::print_literal,
+    clippy::useless_vec
+)]
+
+fn main() {
+    // Overly specified constants
+    let _: f32 = 1.012_345_7;
+    //~^ excessive_precision
+    let _: f64 = 1.012_345_678_901_234_6;
+    //~^ excessive_precision
+    const _: f32 = 1.012345678901234567890;
+    const _: f64 = 1.012345678901234567890;
+
+    static STATIC1: f32 = 1.012345678901234567890;
+    static STATIC2: f64 = 1.012345678901234567890;
+
+    static mut STATIC_MUT1: f32 = 1.012345678901234567890;
+    static mut STATIC_MUT2: f64 = 1.012345678901234567890;
+}
+
+trait ExcessivelyPreciseTrait {
+    // Overly specified constants
+    const GOOD1: f32 = 1.012345678901234567890;
+    const GOOD2: f64 = 1.012345678901234567890;
+}
+
+struct ExcessivelyPreciseStruct;
+
+impl ExcessivelyPreciseStruct {
+    // Overly specified constants
+    const GOOD1: f32 = 1.012345678901234567890;
+    const GOOD2: f64 = 1.012345678901234567890;
+}
diff --git a/tests/ui-toml/excessive_precision/excessive_precision.rs b/tests/ui-toml/excessive_precision/excessive_precision.rs
new file mode 100644
index 0000000000000..121448ed540dc
--- /dev/null
+++ b/tests/ui-toml/excessive_precision/excessive_precision.rs
@@ -0,0 +1,38 @@
+#![warn(clippy::excessive_precision)]
+#![allow(
+    dead_code,
+    overflowing_literals,
+    unused_variables,
+    clippy::print_literal,
+    clippy::useless_vec
+)]
+
+fn main() {
+    // Overly specified constants
+    let _: f32 = 1.012345678901234567890;
+    //~^ excessive_precision
+    let _: f64 = 1.012345678901234567890;
+    //~^ excessive_precision
+    const _: f32 = 1.012345678901234567890;
+    const _: f64 = 1.012345678901234567890;
+
+    static STATIC1: f32 = 1.012345678901234567890;
+    static STATIC2: f64 = 1.012345678901234567890;
+
+    static mut STATIC_MUT1: f32 = 1.012345678901234567890;
+    static mut STATIC_MUT2: f64 = 1.012345678901234567890;
+}
+
+trait ExcessivelyPreciseTrait {
+    // Overly specified constants
+    const GOOD1: f32 = 1.012345678901234567890;
+    const GOOD2: f64 = 1.012345678901234567890;
+}
+
+struct ExcessivelyPreciseStruct;
+
+impl ExcessivelyPreciseStruct {
+    // Overly specified constants
+    const GOOD1: f32 = 1.012345678901234567890;
+    const GOOD2: f64 = 1.012345678901234567890;
+}
diff --git a/tests/ui-toml/excessive_precision/excessive_precision.stderr b/tests/ui-toml/excessive_precision/excessive_precision.stderr
new file mode 100644
index 0000000000000..65d33eddef172
--- /dev/null
+++ b/tests/ui-toml/excessive_precision/excessive_precision.stderr
@@ -0,0 +1,38 @@
+error: float has excessive precision
+  --> tests/ui-toml/excessive_precision/excessive_precision.rs:12:18
+   |
+LL |     let _: f32 = 1.012345678901234567890;
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: consider making it a `const` item
+  --> tests/ui-toml/excessive_precision/excessive_precision.rs:12:5
+   |
+LL |     let _: f32 = 1.012345678901234567890;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = 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 -     let _: f32 = 1.012345678901234567890;
+LL +     let _: f32 = 1.012_345_7;
+   |
+
+error: float has excessive precision
+  --> tests/ui-toml/excessive_precision/excessive_precision.rs:14:18
+   |
+LL |     let _: f64 = 1.012345678901234567890;
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: consider making it a `const` item
+  --> tests/ui-toml/excessive_precision/excessive_precision.rs:14:5
+   |
+LL |     let _: f64 = 1.012345678901234567890;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: consider changing the type or truncating it to
+   |
+LL -     let _: f64 = 1.012345678901234567890;
+LL +     let _: f64 = 1.012_345_678_901_234_6;
+   |
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 6ee77ebd8ece2..20aeb4bb8498e 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -35,6 +35,7 @@ error: error reading Clippy's configuration file: unknown field `foobar`, expect
            check-inconsistent-struct-field-initializers
            check-private-items
            cognitive-complexity-threshold
+           const-literal-digits-threshold
            disallowed-macros
            disallowed-methods
            disallowed-names
@@ -129,6 +130,7 @@ error: error reading Clippy's configuration file: unknown field `barfoo`, expect
            check-inconsistent-struct-field-initializers
            check-private-items
            cognitive-complexity-threshold
+           const-literal-digits-threshold
            disallowed-macros
            disallowed-methods
            disallowed-names
@@ -223,6 +225,7 @@ error: error reading Clippy's configuration file: unknown field `allow_mixed_uni
            check-inconsistent-struct-field-initializers
            check-private-items
            cognitive-complexity-threshold
+           const-literal-digits-threshold
            disallowed-macros
            disallowed-methods
            disallowed-names
diff --git a/tests/ui/assertions_on_result_states.fixed b/tests/ui/assertions_on_result_states.fixed
index 09c1a8d0ed1d5..b2b7318c113f7 100644
--- a/tests/ui/assertions_on_result_states.fixed
+++ b/tests/ui/assertions_on_result_states.fixed
@@ -82,9 +82,18 @@ fn main() {
     assert!(r.is_err());
 }
 
-#[allow(dead_code)]
 fn issue9450() {
     let res: Result<i32, i32> = Ok(1);
     res.unwrap_err();
     //~^ assertions_on_result_states
 }
+
+fn issue9916(res: Result<u32, u32>) {
+    let a = 0;
+    match a {
+        0 => {},
+        1 => { res.unwrap(); },
+        //~^ assertions_on_result_states
+        _ => todo!(),
+    }
+}
diff --git a/tests/ui/assertions_on_result_states.rs b/tests/ui/assertions_on_result_states.rs
index c63c2502b5377..33f1485326b38 100644
--- a/tests/ui/assertions_on_result_states.rs
+++ b/tests/ui/assertions_on_result_states.rs
@@ -82,9 +82,18 @@ fn main() {
     assert!(r.is_err());
 }
 
-#[allow(dead_code)]
 fn issue9450() {
     let res: Result<i32, i32> = Ok(1);
     assert!(res.is_err())
     //~^ assertions_on_result_states
 }
+
+fn issue9916(res: Result<u32, u32>) {
+    let a = 0;
+    match a {
+        0 => {},
+        1 => assert!(res.is_ok()),
+        //~^ assertions_on_result_states
+        _ => todo!(),
+    }
+}
diff --git a/tests/ui/assertions_on_result_states.stderr b/tests/ui/assertions_on_result_states.stderr
index 3bf811588c696..826f049555cae 100644
--- a/tests/ui/assertions_on_result_states.stderr
+++ b/tests/ui/assertions_on_result_states.stderr
@@ -38,10 +38,16 @@ LL |     assert!(r.is_err());
    |     ^^^^^^^^^^^^^^^^^^^ help: replace with: `r.unwrap_err()`
 
 error: called `assert!` with `Result::is_err`
-  --> tests/ui/assertions_on_result_states.rs:88:5
+  --> tests/ui/assertions_on_result_states.rs:87:5
    |
 LL |     assert!(res.is_err())
    |     ^^^^^^^^^^^^^^^^^^^^^ help: replace with: `res.unwrap_err();`
 
-error: aborting due to 7 previous errors
+error: called `assert!` with `Result::is_ok`
+  --> tests/ui/assertions_on_result_states.rs:95:14
+   |
+LL |         1 => assert!(res.is_ok()),
+   |              ^^^^^^^^^^^^^^^^^^^^ help: replace with: `{ res.unwrap(); }`
+
+error: aborting due to 8 previous errors
 
diff --git a/tests/ui/assign_ops.fixed b/tests/ui/assign_ops.fixed
index 3754b9dfe7443..2046d089d6a6c 100644
--- a/tests/ui/assign_ops.fixed
+++ b/tests/ui/assign_ops.fixed
@@ -1,8 +1,9 @@
 #![allow(clippy::useless_vec)]
 #![warn(clippy::assign_op_pattern)]
-#![feature(const_trait_impl, const_ops)]
+#![feature(const_ops)]
+#![feature(const_trait_impl)]
 
-use core::num::Wrapping;
+use std::num::Wrapping;
 use std::ops::{Mul, MulAssign};
 
 fn main() {
@@ -82,6 +83,18 @@ mod issue14871 {
     pub trait Number: Copy + Add<Self, Output = Self> + AddAssign {
         const ZERO: Self;
         const ONE: Self;
+
+        fn non_constant(value: usize) -> Self {
+            let mut res = Self::ZERO;
+            let mut count = 0;
+            while count < value {
+                res += Self::ONE;
+                //~^ assign_op_pattern
+                count += 1;
+                //~^ assign_op_pattern
+            }
+            res
+        }
     }
 
     #[rustfmt::skip] // rustfmt doesn't understand the order of pub const on traits (yet)
@@ -91,7 +104,7 @@ mod issue14871 {
 
     impl<T> const NumberConstants for T
     where
-        T: Number + [const] core::ops::Add,
+        T: Number + [const] std::ops::Add,
     {
         fn constant(value: usize) -> Self {
             let mut res = Self::ZERO;
@@ -99,8 +112,28 @@ mod issue14871 {
             while count < value {
                 res = res + Self::ONE;
                 count += 1;
+                //~^ assign_op_pattern
             }
             res
         }
     }
+
+    pub struct S;
+
+    impl const std::ops::Add for S {
+        type Output = S;
+        fn add(self, _rhs: S) -> S {
+            S
+        }
+    }
+
+    impl const std::ops::AddAssign for S {
+        fn add_assign(&mut self, rhs: S) {}
+    }
+
+    const fn do_add() {
+        let mut s = S;
+        s += S;
+        //~^ assign_op_pattern
+    }
 }
diff --git a/tests/ui/assign_ops.rs b/tests/ui/assign_ops.rs
index 0b878d4f490b8..f83a40f554730 100644
--- a/tests/ui/assign_ops.rs
+++ b/tests/ui/assign_ops.rs
@@ -1,8 +1,9 @@
 #![allow(clippy::useless_vec)]
 #![warn(clippy::assign_op_pattern)]
-#![feature(const_trait_impl, const_ops)]
+#![feature(const_ops)]
+#![feature(const_trait_impl)]
 
-use core::num::Wrapping;
+use std::num::Wrapping;
 use std::ops::{Mul, MulAssign};
 
 fn main() {
@@ -82,6 +83,18 @@ mod issue14871 {
     pub trait Number: Copy + Add<Self, Output = Self> + AddAssign {
         const ZERO: Self;
         const ONE: Self;
+
+        fn non_constant(value: usize) -> Self {
+            let mut res = Self::ZERO;
+            let mut count = 0;
+            while count < value {
+                res = res + Self::ONE;
+                //~^ assign_op_pattern
+                count = count + 1;
+                //~^ assign_op_pattern
+            }
+            res
+        }
     }
 
     #[rustfmt::skip] // rustfmt doesn't understand the order of pub const on traits (yet)
@@ -91,16 +104,36 @@ mod issue14871 {
 
     impl<T> const NumberConstants for T
     where
-        T: Number + [const] core::ops::Add,
+        T: Number + [const] std::ops::Add,
     {
         fn constant(value: usize) -> Self {
             let mut res = Self::ZERO;
             let mut count = 0;
             while count < value {
                 res = res + Self::ONE;
-                count += 1;
+                count = count + 1;
+                //~^ assign_op_pattern
             }
             res
         }
     }
+
+    pub struct S;
+
+    impl const std::ops::Add for S {
+        type Output = S;
+        fn add(self, _rhs: S) -> S {
+            S
+        }
+    }
+
+    impl const std::ops::AddAssign for S {
+        fn add_assign(&mut self, rhs: S) {}
+    }
+
+    const fn do_add() {
+        let mut s = S;
+        s = s + S;
+        //~^ assign_op_pattern
+    }
 }
diff --git a/tests/ui/assign_ops.stderr b/tests/ui/assign_ops.stderr
index c5e698b3ee118..a4fca04893c46 100644
--- a/tests/ui/assign_ops.stderr
+++ b/tests/ui/assign_ops.stderr
@@ -1,5 +1,5 @@
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:10:5
+  --> tests/ui/assign_ops.rs:11:5
    |
 LL |     a = a + 1;
    |     ^^^^^^^^^ help: replace it with: `a += 1`
@@ -8,70 +8,94 @@ LL |     a = a + 1;
    = help: to override `-D warnings` add `#[allow(clippy::assign_op_pattern)]`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:12:5
+  --> tests/ui/assign_ops.rs:13:5
    |
 LL |     a = 1 + a;
    |     ^^^^^^^^^ help: replace it with: `a += 1`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:14:5
+  --> tests/ui/assign_ops.rs:15:5
    |
 LL |     a = a - 1;
    |     ^^^^^^^^^ help: replace it with: `a -= 1`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:16:5
+  --> tests/ui/assign_ops.rs:17:5
    |
 LL |     a = a * 99;
    |     ^^^^^^^^^^ help: replace it with: `a *= 99`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:18:5
+  --> tests/ui/assign_ops.rs:19:5
    |
 LL |     a = 42 * a;
    |     ^^^^^^^^^^ help: replace it with: `a *= 42`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:20:5
+  --> tests/ui/assign_ops.rs:21:5
    |
 LL |     a = a / 2;
    |     ^^^^^^^^^ help: replace it with: `a /= 2`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:22:5
+  --> tests/ui/assign_ops.rs:23:5
    |
 LL |     a = a % 5;
    |     ^^^^^^^^^ help: replace it with: `a %= 5`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:24:5
+  --> tests/ui/assign_ops.rs:25:5
    |
 LL |     a = a & 1;
    |     ^^^^^^^^^ help: replace it with: `a &= 1`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:31:5
+  --> tests/ui/assign_ops.rs:32:5
    |
 LL |     s = s + "bla";
    |     ^^^^^^^^^^^^^ help: replace it with: `s += "bla"`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:36:5
+  --> tests/ui/assign_ops.rs:37:5
    |
 LL |     a = a + Wrapping(1u32);
    |     ^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `a += Wrapping(1u32)`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:39:5
+  --> tests/ui/assign_ops.rs:40:5
    |
 LL |     v[0] = v[0] + v[1];
    |     ^^^^^^^^^^^^^^^^^^ help: replace it with: `v[0] += v[1]`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:52:5
+  --> tests/ui/assign_ops.rs:53:5
    |
 LL |     buf = buf + cows.clone();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `buf += cows.clone()`
 
-error: aborting due to 12 previous errors
+error: manual implementation of an assign operation
+  --> tests/ui/assign_ops.rs:91:17
+   |
+LL |                 res = res + Self::ONE;
+   |                 ^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `res += Self::ONE`
+
+error: manual implementation of an assign operation
+  --> tests/ui/assign_ops.rs:93:17
+   |
+LL |                 count = count + 1;
+   |                 ^^^^^^^^^^^^^^^^^ help: replace it with: `count += 1`
+
+error: manual implementation of an assign operation
+  --> tests/ui/assign_ops.rs:114:17
+   |
+LL |                 count = count + 1;
+   |                 ^^^^^^^^^^^^^^^^^ help: replace it with: `count += 1`
+
+error: manual implementation of an assign operation
+  --> tests/ui/assign_ops.rs:136:9
+   |
+LL |         s = s + S;
+   |         ^^^^^^^^^ help: replace it with: `s += S`
+
+error: aborting due to 16 previous errors
 
diff --git a/tests/ui/async_yields_async.fixed b/tests/ui/async_yields_async.fixed
index 93c573d30863e..bd1b31f74ee95 100644
--- a/tests/ui/async_yields_async.fixed
+++ b/tests/ui/async_yields_async.fixed
@@ -80,3 +80,42 @@ fn check_expect_suppression() {
         }
     };
 }
+
+#[allow(clippy::let_underscore_future)]
+fn issue15552() {
+    async fn bar(i: i32) {}
+
+    macro_rules! call_bar {
+        () => {
+            async { bar(5).await }
+        };
+        ($e:expr) => {
+            bar($e)
+        };
+    }
+    let x = async { call_bar!(5).await };
+    //~^ async_yields_async
+    let y = async { call_bar!().await };
+    //~^ async_yields_async
+    //~| async_yields_async
+
+    use std::future::{Future, Ready};
+    use std::ops::Add;
+    use std::pin::Pin;
+    use std::task::{Context, Poll};
+    struct CustomFutureType;
+    impl Add for CustomFutureType {
+        type Output = Self;
+        fn add(self, other: Self) -> Self {
+            self
+        }
+    }
+    impl Future for CustomFutureType {
+        type Output = ();
+        fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
+            Poll::Ready(())
+        }
+    }
+    let _ = async { (CustomFutureType + CustomFutureType).await };
+    //~^ async_yields_async
+}
diff --git a/tests/ui/async_yields_async.rs b/tests/ui/async_yields_async.rs
index 166d522e1c04c..605d2734157cf 100644
--- a/tests/ui/async_yields_async.rs
+++ b/tests/ui/async_yields_async.rs
@@ -80,3 +80,42 @@ fn check_expect_suppression() {
         }
     };
 }
+
+#[allow(clippy::let_underscore_future)]
+fn issue15552() {
+    async fn bar(i: i32) {}
+
+    macro_rules! call_bar {
+        () => {
+            async { bar(5) }
+        };
+        ($e:expr) => {
+            bar($e)
+        };
+    }
+    let x = async { call_bar!(5) };
+    //~^ async_yields_async
+    let y = async { call_bar!() };
+    //~^ async_yields_async
+    //~| async_yields_async
+
+    use std::future::{Future, Ready};
+    use std::ops::Add;
+    use std::pin::Pin;
+    use std::task::{Context, Poll};
+    struct CustomFutureType;
+    impl Add for CustomFutureType {
+        type Output = Self;
+        fn add(self, other: Self) -> Self {
+            self
+        }
+    }
+    impl Future for CustomFutureType {
+        type Output = ();
+        fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
+            Poll::Ready(())
+        }
+    }
+    let _ = async { CustomFutureType + CustomFutureType };
+    //~^ async_yields_async
+}
diff --git a/tests/ui/async_yields_async.stderr b/tests/ui/async_yields_async.stderr
index 17a35076fa3f1..3041cf6578938 100644
--- a/tests/ui/async_yields_async.stderr
+++ b/tests/ui/async_yields_async.stderr
@@ -89,5 +89,50 @@ LL | |         CustomFutureType
 LL | |     };
    | |_____- outer async construct
 
-error: aborting due to 6 previous errors
+error: an async construct yields a type which is itself awaitable
+  --> tests/ui/async_yields_async.rs:96:21
+   |
+LL |     let x = async { call_bar!(5) };
+   |                   --^^^^^^^^^^^^--
+   |                   | |
+   |                   | awaitable value not awaited
+   |                   | help: consider awaiting this value: `call_bar!(5).await`
+   |                   outer async construct
+
+error: an async construct yields a type which is itself awaitable
+  --> tests/ui/async_yields_async.rs:98:21
+   |
+LL |     let y = async { call_bar!() };
+   |                   --^^^^^^^^^^^--
+   |                   | |
+   |                   | awaitable value not awaited
+   |                   | help: consider awaiting this value: `call_bar!().await`
+   |                   outer async construct
+
+error: an async construct yields a type which is itself awaitable
+  --> tests/ui/async_yields_async.rs:90:21
+   |
+LL |             async { bar(5) }
+   |                   --^^^^^^--
+   |                   | |
+   |                   | awaitable value not awaited
+   |                   | help: consider awaiting this value: `bar(5).await`
+   |                   outer async construct
+...
+LL |     let y = async { call_bar!() };
+   |                     ----------- in this macro invocation
+   |
+   = note: this error originates in the macro `call_bar` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: an async construct yields a type which is itself awaitable
+  --> tests/ui/async_yields_async.rs:119:21
+   |
+LL |     let _ = async { CustomFutureType + CustomFutureType };
+   |                   --^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^--
+   |                   | |
+   |                   | awaitable value not awaited
+   |                   | help: consider awaiting this value: `(CustomFutureType + CustomFutureType).await`
+   |                   outer async construct
+
+error: aborting due to 10 previous errors
 
diff --git a/tests/ui/bool_comparison.fixed b/tests/ui/bool_comparison.fixed
index 166abbe549c3d..b0b60104c0b91 100644
--- a/tests/ui/bool_comparison.fixed
+++ b/tests/ui/bool_comparison.fixed
@@ -1,97 +1,41 @@
 #![allow(non_local_definitions, clippy::needless_if)]
 #![warn(clippy::bool_comparison)]
-#![allow(clippy::non_canonical_partial_ord_impl, clippy::nonminimal_bool)]
+#![allow(clippy::non_canonical_partial_ord_impl)]
 
 fn main() {
     let x = true;
-    if x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if !x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if !x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if !x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if !x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if !x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if !x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
+    let _ = if x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if !x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if !x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if !x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if !x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if !x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if !x { "yes" } else { "no" };
+    //~^ bool_comparison
+
     let y = true;
-    if !x & y {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if x & !y {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
+    let _ = if !x & y { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if x & !y { "yes" } else { "no" };
+    //~^ bool_comparison
 }
 
-#[allow(dead_code)]
 fn issue3703() {
     struct Foo;
     impl PartialEq<bool> for Foo {
@@ -127,26 +71,6 @@ fn issue3703() {
     if false < Foo {}
 }
 
-#[allow(dead_code)]
-fn issue4983() {
-    let a = true;
-    let b = false;
-
-    if a != b {};
-    //~^ bool_comparison
-    if a != b {};
-    //~^ bool_comparison
-    if a == b {};
-    if !a == !b {};
-
-    if b != a {};
-    //~^ bool_comparison
-    if b != a {};
-    //~^ bool_comparison
-    if b == a {};
-    if !b == !a {};
-}
-
 macro_rules! m {
     ($func:ident) => {
         $func()
@@ -157,7 +81,6 @@ fn func() -> bool {
     true
 }
 
-#[allow(dead_code)]
 fn issue3973() {
     // ok, don't lint on `cfg` invocation
     if false == cfg!(feature = "debugging") {}
@@ -196,6 +119,34 @@ fn issue9907() {
     //~^ bool_comparison
     // This is not part of the issue, but an unexpected found when fixing the issue,
     // the provided span was inside of macro rather than the macro callsite.
-    let _ = ((1 < 2) != m!(func)) as usize;
+    let _ = ((1 < 2) & !m!(func)) as usize;
     //~^ bool_comparison
 }
+
+#[allow(clippy::nonminimal_bool)]
+fn issue15367() {
+    let a = true;
+    let b = false;
+
+    // these cases are handled by `nonminimal_bool`, so don't double-lint
+    if a == !b {};
+    if !a == b {};
+    if b == !a {};
+    if !b == a {};
+}
+
+fn issue15497() {
+    fn func() -> bool {
+        true
+    }
+
+    fn foo(x: bool) -> bool {
+        x & !m!(func)
+        //~^ bool_comparison
+    }
+
+    fn bar(x: bool) -> bool {
+        !x & m!(func)
+        //~^ bool_comparison
+    }
+}
diff --git a/tests/ui/bool_comparison.rs b/tests/ui/bool_comparison.rs
index 7265c2b4c5a6f..1b1108d6ce504 100644
--- a/tests/ui/bool_comparison.rs
+++ b/tests/ui/bool_comparison.rs
@@ -1,97 +1,41 @@
 #![allow(non_local_definitions, clippy::needless_if)]
 #![warn(clippy::bool_comparison)]
-#![allow(clippy::non_canonical_partial_ord_impl, clippy::nonminimal_bool)]
+#![allow(clippy::non_canonical_partial_ord_impl)]
 
 fn main() {
     let x = true;
-    if x == true {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if x == false {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if true == x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if false == x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if x != true {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if x != false {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if true != x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if false != x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if x < true {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if false < x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if x > false {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if true > x {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
+    let _ = if x == true { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if x == false { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if true == x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if false == x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if x != true { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if x != false { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if true != x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if false != x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if x < true { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if false < x { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if x > false { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if true > x { "yes" } else { "no" };
+    //~^ bool_comparison
+
     let y = true;
-    if x < y {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
-    if x > y {
-        //~^ bool_comparison
-        "yes"
-    } else {
-        "no"
-    };
+    let _ = if x < y { "yes" } else { "no" };
+    //~^ bool_comparison
+    let _ = if x > y { "yes" } else { "no" };
+    //~^ bool_comparison
 }
 
-#[allow(dead_code)]
 fn issue3703() {
     struct Foo;
     impl PartialEq<bool> for Foo {
@@ -127,26 +71,6 @@ fn issue3703() {
     if false < Foo {}
 }
 
-#[allow(dead_code)]
-fn issue4983() {
-    let a = true;
-    let b = false;
-
-    if a == !b {};
-    //~^ bool_comparison
-    if !a == b {};
-    //~^ bool_comparison
-    if a == b {};
-    if !a == !b {};
-
-    if b == !a {};
-    //~^ bool_comparison
-    if !b == a {};
-    //~^ bool_comparison
-    if b == a {};
-    if !b == !a {};
-}
-
 macro_rules! m {
     ($func:ident) => {
         $func()
@@ -157,7 +81,6 @@ fn func() -> bool {
     true
 }
 
-#[allow(dead_code)]
 fn issue3973() {
     // ok, don't lint on `cfg` invocation
     if false == cfg!(feature = "debugging") {}
@@ -196,6 +119,34 @@ fn issue9907() {
     //~^ bool_comparison
     // This is not part of the issue, but an unexpected found when fixing the issue,
     // the provided span was inside of macro rather than the macro callsite.
-    let _ = ((1 < 2) == !m!(func)) as usize;
+    let _ = ((1 < 2) > m!(func)) as usize;
     //~^ bool_comparison
 }
+
+#[allow(clippy::nonminimal_bool)]
+fn issue15367() {
+    let a = true;
+    let b = false;
+
+    // these cases are handled by `nonminimal_bool`, so don't double-lint
+    if a == !b {};
+    if !a == b {};
+    if b == !a {};
+    if !b == a {};
+}
+
+fn issue15497() {
+    fn func() -> bool {
+        true
+    }
+
+    fn foo(x: bool) -> bool {
+        x > m!(func)
+        //~^ bool_comparison
+    }
+
+    fn bar(x: bool) -> bool {
+        x < m!(func)
+        //~^ bool_comparison
+    }
+}
diff --git a/tests/ui/bool_comparison.stderr b/tests/ui/bool_comparison.stderr
index ddbb9ff78edb3..98881a2d20fd3 100644
--- a/tests/ui/bool_comparison.stderr
+++ b/tests/ui/bool_comparison.stderr
@@ -1,155 +1,143 @@
 error: equality checks against true are unnecessary
-  --> tests/ui/bool_comparison.rs:7:8
+  --> tests/ui/bool_comparison.rs:7:16
    |
-LL |     if x == true {
-   |        ^^^^^^^^^ help: try simplifying it as shown: `x`
+LL |     let _ = if x == true { "yes" } else { "no" };
+   |                ^^^^^^^^^ help: try: `x`
    |
    = note: `-D clippy::bool-comparison` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::bool_comparison)]`
 
 error: equality checks against false can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:13:8
+  --> tests/ui/bool_comparison.rs:9:16
    |
-LL |     if x == false {
-   |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
+LL |     let _ = if x == false { "yes" } else { "no" };
+   |                ^^^^^^^^^^ help: try: `!x`
 
 error: equality checks against true are unnecessary
-  --> tests/ui/bool_comparison.rs:19:8
+  --> tests/ui/bool_comparison.rs:11:16
    |
-LL |     if true == x {
-   |        ^^^^^^^^^ help: try simplifying it as shown: `x`
+LL |     let _ = if true == x { "yes" } else { "no" };
+   |                ^^^^^^^^^ help: try: `x`
 
 error: equality checks against false can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:25:8
+  --> tests/ui/bool_comparison.rs:13:16
    |
-LL |     if false == x {
-   |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
+LL |     let _ = if false == x { "yes" } else { "no" };
+   |                ^^^^^^^^^^ help: try: `!x`
 
 error: inequality checks against true can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:31:8
+  --> tests/ui/bool_comparison.rs:15:16
    |
-LL |     if x != true {
-   |        ^^^^^^^^^ help: try simplifying it as shown: `!x`
+LL |     let _ = if x != true { "yes" } else { "no" };
+   |                ^^^^^^^^^ help: try: `!x`
 
 error: inequality checks against false are unnecessary
-  --> tests/ui/bool_comparison.rs:37:8
+  --> tests/ui/bool_comparison.rs:17:16
    |
-LL |     if x != false {
-   |        ^^^^^^^^^^ help: try simplifying it as shown: `x`
+LL |     let _ = if x != false { "yes" } else { "no" };
+   |                ^^^^^^^^^^ help: try: `x`
 
 error: inequality checks against true can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:43:8
+  --> tests/ui/bool_comparison.rs:19:16
    |
-LL |     if true != x {
-   |        ^^^^^^^^^ help: try simplifying it as shown: `!x`
+LL |     let _ = if true != x { "yes" } else { "no" };
+   |                ^^^^^^^^^ help: try: `!x`
 
 error: inequality checks against false are unnecessary
-  --> tests/ui/bool_comparison.rs:49:8
+  --> tests/ui/bool_comparison.rs:21:16
    |
-LL |     if false != x {
-   |        ^^^^^^^^^^ help: try simplifying it as shown: `x`
+LL |     let _ = if false != x { "yes" } else { "no" };
+   |                ^^^^^^^^^^ help: try: `x`
 
 error: less than comparison against true can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:55:8
+  --> tests/ui/bool_comparison.rs:23:16
    |
-LL |     if x < true {
-   |        ^^^^^^^^ help: try simplifying it as shown: `!x`
+LL |     let _ = if x < true { "yes" } else { "no" };
+   |                ^^^^^^^^ help: try: `!x`
 
 error: greater than checks against false are unnecessary
-  --> tests/ui/bool_comparison.rs:61:8
+  --> tests/ui/bool_comparison.rs:25:16
    |
-LL |     if false < x {
-   |        ^^^^^^^^^ help: try simplifying it as shown: `x`
+LL |     let _ = if false < x { "yes" } else { "no" };
+   |                ^^^^^^^^^ help: try: `x`
 
 error: greater than checks against false are unnecessary
-  --> tests/ui/bool_comparison.rs:67:8
+  --> tests/ui/bool_comparison.rs:27:16
    |
-LL |     if x > false {
-   |        ^^^^^^^^^ help: try simplifying it as shown: `x`
+LL |     let _ = if x > false { "yes" } else { "no" };
+   |                ^^^^^^^^^ help: try: `x`
 
 error: less than comparison against true can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:73:8
+  --> tests/ui/bool_comparison.rs:29:16
    |
-LL |     if true > x {
-   |        ^^^^^^^^ help: try simplifying it as shown: `!x`
+LL |     let _ = if true > x { "yes" } else { "no" };
+   |                ^^^^^^^^ help: try: `!x`
 
 error: order comparisons between booleans can be simplified
-  --> tests/ui/bool_comparison.rs:80:8
+  --> tests/ui/bool_comparison.rs:33:16
    |
-LL |     if x < y {
-   |        ^^^^^ help: try simplifying it as shown: `!x & y`
+LL |     let _ = if x < y { "yes" } else { "no" };
+   |                ^^^^^ help: try: `!x & y`
 
 error: order comparisons between booleans can be simplified
-  --> tests/ui/bool_comparison.rs:86:8
+  --> tests/ui/bool_comparison.rs:35:16
    |
-LL |     if x > y {
-   |        ^^^^^ help: try simplifying it as shown: `x & !y`
-
-error: this comparison might be written more concisely
-  --> tests/ui/bool_comparison.rs:135:8
-   |
-LL |     if a == !b {};
-   |        ^^^^^^^ help: try simplifying it as shown: `a != b`
-
-error: this comparison might be written more concisely
-  --> tests/ui/bool_comparison.rs:137:8
-   |
-LL |     if !a == b {};
-   |        ^^^^^^^ help: try simplifying it as shown: `a != b`
-
-error: this comparison might be written more concisely
-  --> tests/ui/bool_comparison.rs:142:8
-   |
-LL |     if b == !a {};
-   |        ^^^^^^^ help: try simplifying it as shown: `b != a`
-
-error: this comparison might be written more concisely
-  --> tests/ui/bool_comparison.rs:144:8
-   |
-LL |     if !b == a {};
-   |        ^^^^^^^ help: try simplifying it as shown: `b != a`
+LL |     let _ = if x > y { "yes" } else { "no" };
+   |                ^^^^^ help: try: `x & !y`
 
 error: equality checks against false can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:169:8
+  --> tests/ui/bool_comparison.rs:92:8
    |
 LL |     if false == m!(func) {}
-   |        ^^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `!m!(func)`
+   |        ^^^^^^^^^^^^^^^^^ help: try: `!m!(func)`
 
 error: equality checks against false can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:171:8
+  --> tests/ui/bool_comparison.rs:94:8
    |
 LL |     if m!(func) == false {}
-   |        ^^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `!m!(func)`
+   |        ^^^^^^^^^^^^^^^^^ help: try: `!m!(func)`
 
 error: equality checks against true are unnecessary
-  --> tests/ui/bool_comparison.rs:173:8
+  --> tests/ui/bool_comparison.rs:96:8
    |
 LL |     if true == m!(func) {}
-   |        ^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `m!(func)`
+   |        ^^^^^^^^^^^^^^^^ help: try: `m!(func)`
 
 error: equality checks against true are unnecessary
-  --> tests/ui/bool_comparison.rs:175:8
+  --> tests/ui/bool_comparison.rs:98:8
    |
 LL |     if m!(func) == true {}
-   |        ^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `m!(func)`
+   |        ^^^^^^^^^^^^^^^^ help: try: `m!(func)`
 
 error: equality checks against false can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:193:14
+  --> tests/ui/bool_comparison.rs:116:14
    |
 LL |     let _ = ((1 < 2) == false) as usize;
-   |              ^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `1 >= 2`
+   |              ^^^^^^^^^^^^^^^^ help: try: `1 >= 2`
 
 error: equality checks against false can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:195:14
+  --> tests/ui/bool_comparison.rs:118:14
    |
 LL |     let _ = (false == m!(func)) as usize;
-   |              ^^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `!m!(func)`
+   |              ^^^^^^^^^^^^^^^^^ help: try: `!m!(func)`
 
-error: this comparison might be written more concisely
-  --> tests/ui/bool_comparison.rs:199:14
+error: order comparisons between booleans can be simplified
+  --> tests/ui/bool_comparison.rs:122:14
+   |
+LL |     let _ = ((1 < 2) > m!(func)) as usize;
+   |              ^^^^^^^^^^^^^^^^^^ help: try: `(1 < 2) & !m!(func)`
+
+error: order comparisons between booleans can be simplified
+  --> tests/ui/bool_comparison.rs:144:9
+   |
+LL |         x > m!(func)
+   |         ^^^^^^^^^^^^ help: try: `x & !m!(func)`
+
+error: order comparisons between booleans can be simplified
+  --> tests/ui/bool_comparison.rs:149:9
    |
-LL |     let _ = ((1 < 2) == !m!(func)) as usize;
-   |              ^^^^^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `(1 < 2) != m!(func)`
+LL |         x < m!(func)
+   |         ^^^^^^^^^^^^ help: try: `!x & m!(func)`
 
-error: aborting due to 25 previous errors
+error: aborting due to 23 previous errors
 
diff --git a/tests/ui/cast_raw_slice_pointer_cast.fixed b/tests/ui/cast_raw_slice_pointer_cast.fixed
index bddcb0ebf64e6..3c1cf8845957f 100644
--- a/tests/ui/cast_raw_slice_pointer_cast.fixed
+++ b/tests/ui/cast_raw_slice_pointer_cast.fixed
@@ -1,30 +1,53 @@
 #![warn(clippy::cast_slice_from_raw_parts)]
 
-#[allow(unused_imports, unused_unsafe)]
+const fn require_raw_slice_ptr<T>(_: *const [T]) {}
+
 fn main() {
     let mut vec = vec![0u8; 1];
     let ptr: *const u8 = vec.as_ptr();
     let mptr = vec.as_mut_ptr();
-    let _: *const [u8] = unsafe { core::ptr::slice_from_raw_parts(ptr, 1) };
+    let _: *const [u8] = unsafe { std::ptr::slice_from_raw_parts(ptr, 1) };
     //~^ cast_slice_from_raw_parts
-    let _: *const [u8] = unsafe { core::ptr::slice_from_raw_parts_mut(mptr, 1) };
+    let _: *const [u8] = unsafe { std::ptr::slice_from_raw_parts_mut(mptr, 1) };
     //~^ cast_slice_from_raw_parts
-    let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+    let _: *const [u8] = std::ptr::slice_from_raw_parts(ptr, 1);
     //~^ cast_slice_from_raw_parts
     {
         use core::slice;
-        let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+        let _: *const [u8] = std::ptr::slice_from_raw_parts(ptr, 1);
         //~^ cast_slice_from_raw_parts
         use slice as one;
-        let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+        let _: *const [u8] = std::ptr::slice_from_raw_parts(ptr, 1);
         //~^ cast_slice_from_raw_parts
     }
     {
         use std::slice;
-        let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+        let _: *const [u8] = std::ptr::slice_from_raw_parts(ptr, 1);
         //~^ cast_slice_from_raw_parts
         use slice as one;
-        let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+        let _: *const [u8] = std::ptr::slice_from_raw_parts(ptr, 1);
         //~^ cast_slice_from_raw_parts
     }
+
+    // implicit cast
+    {
+        let _: *const [u8] = unsafe { std::ptr::slice_from_raw_parts(ptr, 1) };
+        //~^ cast_slice_from_raw_parts
+        let _: *mut [u8] = unsafe { std::ptr::slice_from_raw_parts_mut(mptr, 1) };
+        //~^ cast_slice_from_raw_parts
+        require_raw_slice_ptr(unsafe { std::ptr::slice_from_raw_parts(ptr, 1) });
+        //~^ cast_slice_from_raw_parts
+    }
+
+    // implicit cast in const context
+    const {
+        const PTR: *const u8 = std::ptr::null();
+        const MPTR: *mut u8 = std::ptr::null_mut();
+        let _: *const [u8] = unsafe { std::ptr::slice_from_raw_parts(PTR, 1) };
+        //~^ cast_slice_from_raw_parts
+        let _: *mut [u8] = unsafe { std::ptr::slice_from_raw_parts_mut(MPTR, 1) };
+        //~^ cast_slice_from_raw_parts
+        require_raw_slice_ptr(unsafe { std::ptr::slice_from_raw_parts(PTR, 1) });
+        //~^ cast_slice_from_raw_parts
+    };
 }
diff --git a/tests/ui/cast_raw_slice_pointer_cast.rs b/tests/ui/cast_raw_slice_pointer_cast.rs
index 0a1eb276d5e9e..8f57b1f961928 100644
--- a/tests/ui/cast_raw_slice_pointer_cast.rs
+++ b/tests/ui/cast_raw_slice_pointer_cast.rs
@@ -1,6 +1,7 @@
 #![warn(clippy::cast_slice_from_raw_parts)]
 
-#[allow(unused_imports, unused_unsafe)]
+const fn require_raw_slice_ptr<T>(_: *const [T]) {}
+
 fn main() {
     let mut vec = vec![0u8; 1];
     let ptr: *const u8 = vec.as_ptr();
@@ -27,4 +28,26 @@ fn main() {
         let _: *const [u8] = unsafe { one::from_raw_parts(ptr, 1) } as *const [u8];
         //~^ cast_slice_from_raw_parts
     }
+
+    // implicit cast
+    {
+        let _: *const [u8] = unsafe { std::slice::from_raw_parts(ptr, 1) };
+        //~^ cast_slice_from_raw_parts
+        let _: *mut [u8] = unsafe { std::slice::from_raw_parts_mut(mptr, 1) };
+        //~^ cast_slice_from_raw_parts
+        require_raw_slice_ptr(unsafe { std::slice::from_raw_parts(ptr, 1) });
+        //~^ cast_slice_from_raw_parts
+    }
+
+    // implicit cast in const context
+    const {
+        const PTR: *const u8 = std::ptr::null();
+        const MPTR: *mut u8 = std::ptr::null_mut();
+        let _: *const [u8] = unsafe { std::slice::from_raw_parts(PTR, 1) };
+        //~^ cast_slice_from_raw_parts
+        let _: *mut [u8] = unsafe { std::slice::from_raw_parts_mut(MPTR, 1) };
+        //~^ cast_slice_from_raw_parts
+        require_raw_slice_ptr(unsafe { std::slice::from_raw_parts(PTR, 1) });
+        //~^ cast_slice_from_raw_parts
+    };
 }
diff --git a/tests/ui/cast_raw_slice_pointer_cast.stderr b/tests/ui/cast_raw_slice_pointer_cast.stderr
index 60794a988db7d..328dbafbafe7a 100644
--- a/tests/ui/cast_raw_slice_pointer_cast.stderr
+++ b/tests/ui/cast_raw_slice_pointer_cast.stderr
@@ -1,47 +1,83 @@
 error: casting the result of `from_raw_parts` to *const [u8]
-  --> tests/ui/cast_raw_slice_pointer_cast.rs:8:35
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:9:35
    |
 LL |     let _: *const [u8] = unsafe { std::slice::from_raw_parts(ptr, 1) as *const [u8] };
-   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `std::ptr::slice_from_raw_parts(ptr, 1)`
    |
    = note: `-D clippy::cast-slice-from-raw-parts` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::cast_slice_from_raw_parts)]`
 
 error: casting the result of `from_raw_parts_mut` to *mut [u8]
-  --> tests/ui/cast_raw_slice_pointer_cast.rs:10:35
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:11:35
    |
 LL |     let _: *const [u8] = unsafe { std::slice::from_raw_parts_mut(mptr, 1) as *mut [u8] };
-   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts_mut(mptr, 1)`
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `std::ptr::slice_from_raw_parts_mut(mptr, 1)`
 
 error: casting the result of `from_raw_parts` to *const [u8]
-  --> tests/ui/cast_raw_slice_pointer_cast.rs:12:26
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:13:26
    |
 LL |     let _: *const [u8] = unsafe { std::slice::from_raw_parts(ptr, 1) } as *const [u8];
-   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `std::ptr::slice_from_raw_parts(ptr, 1)`
 
 error: casting the result of `from_raw_parts` to *const [u8]
-  --> tests/ui/cast_raw_slice_pointer_cast.rs:16:30
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:17:30
    |
 LL |         let _: *const [u8] = unsafe { slice::from_raw_parts(ptr, 1) } as *const [u8];
-   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `std::ptr::slice_from_raw_parts(ptr, 1)`
 
 error: casting the result of `from_raw_parts` to *const [u8]
-  --> tests/ui/cast_raw_slice_pointer_cast.rs:19:30
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:20:30
    |
 LL |         let _: *const [u8] = unsafe { one::from_raw_parts(ptr, 1) } as *const [u8];
-   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `std::ptr::slice_from_raw_parts(ptr, 1)`
 
 error: casting the result of `from_raw_parts` to *const [u8]
-  --> tests/ui/cast_raw_slice_pointer_cast.rs:24:30
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:25:30
    |
 LL |         let _: *const [u8] = unsafe { slice::from_raw_parts(ptr, 1) } as *const [u8];
-   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `std::ptr::slice_from_raw_parts(ptr, 1)`
 
 error: casting the result of `from_raw_parts` to *const [u8]
-  --> tests/ui/cast_raw_slice_pointer_cast.rs:27:30
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:28:30
    |
 LL |         let _: *const [u8] = unsafe { one::from_raw_parts(ptr, 1) } as *const [u8];
-   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `std::ptr::slice_from_raw_parts(ptr, 1)`
 
-error: aborting due to 7 previous errors
+error: implicitly casting the result of `from_raw_parts` to `*const [u8]`
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:34:39
+   |
+LL |         let _: *const [u8] = unsafe { std::slice::from_raw_parts(ptr, 1) };
+   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `std::ptr::slice_from_raw_parts(ptr, 1)`
+
+error: implicitly casting the result of `from_raw_parts_mut` to `*mut [u8]`
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:36:37
+   |
+LL |         let _: *mut [u8] = unsafe { std::slice::from_raw_parts_mut(mptr, 1) };
+   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `std::ptr::slice_from_raw_parts_mut(mptr, 1)`
+
+error: implicitly casting the result of `from_raw_parts` to `*const [u8]`
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:38:40
+   |
+LL |         require_raw_slice_ptr(unsafe { std::slice::from_raw_parts(ptr, 1) });
+   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `std::ptr::slice_from_raw_parts(ptr, 1)`
+
+error: implicitly casting the result of `from_raw_parts` to `*const [u8]`
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:46:39
+   |
+LL |         let _: *const [u8] = unsafe { std::slice::from_raw_parts(PTR, 1) };
+   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `std::ptr::slice_from_raw_parts(PTR, 1)`
+
+error: implicitly casting the result of `from_raw_parts_mut` to `*mut [u8]`
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:48:37
+   |
+LL |         let _: *mut [u8] = unsafe { std::slice::from_raw_parts_mut(MPTR, 1) };
+   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `std::ptr::slice_from_raw_parts_mut(MPTR, 1)`
+
+error: implicitly casting the result of `from_raw_parts` to `*const [u8]`
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:50:40
+   |
+LL |         require_raw_slice_ptr(unsafe { std::slice::from_raw_parts(PTR, 1) });
+   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `std::ptr::slice_from_raw_parts(PTR, 1)`
+
+error: aborting due to 13 previous errors
 
diff --git a/tests/ui/cast_raw_slice_pointer_cast_no_std.fixed b/tests/ui/cast_raw_slice_pointer_cast_no_std.fixed
new file mode 100644
index 0000000000000..f71fb8d863c6d
--- /dev/null
+++ b/tests/ui/cast_raw_slice_pointer_cast_no_std.fixed
@@ -0,0 +1,55 @@
+#![warn(clippy::cast_slice_from_raw_parts)]
+#![no_std]
+#![crate_type = "lib"]
+
+const fn require_raw_slice_ptr<T>(_: *const [T]) {}
+
+fn main() {
+    let mut arr = [0u8; 1];
+    let ptr: *const u8 = arr.as_ptr();
+    let mptr = arr.as_mut_ptr();
+    let _: *const [u8] = unsafe { core::ptr::slice_from_raw_parts(ptr, 1) };
+    //~^ cast_slice_from_raw_parts
+    let _: *const [u8] = unsafe { core::ptr::slice_from_raw_parts_mut(mptr, 1) };
+    //~^ cast_slice_from_raw_parts
+    let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+    //~^ cast_slice_from_raw_parts
+    {
+        use core::slice;
+        let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+        //~^ cast_slice_from_raw_parts
+        use slice as one;
+        let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+        //~^ cast_slice_from_raw_parts
+    }
+    {
+        use core::slice;
+        let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+        //~^ cast_slice_from_raw_parts
+        use slice as one;
+        let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+        //~^ cast_slice_from_raw_parts
+    }
+
+    // implicit cast
+    {
+        let _: *const [u8] = unsafe { core::ptr::slice_from_raw_parts(ptr, 1) };
+        //~^ cast_slice_from_raw_parts
+        let _: *mut [u8] = unsafe { core::ptr::slice_from_raw_parts_mut(mptr, 1) };
+        //~^ cast_slice_from_raw_parts
+        require_raw_slice_ptr(unsafe { core::ptr::slice_from_raw_parts(ptr, 1) });
+        //~^ cast_slice_from_raw_parts
+    }
+
+    // implicit cast in const context
+    const {
+        const PTR: *const u8 = core::ptr::null();
+        const MPTR: *mut u8 = core::ptr::null_mut();
+        let _: *const [u8] = unsafe { core::ptr::slice_from_raw_parts(PTR, 1) };
+        //~^ cast_slice_from_raw_parts
+        let _: *mut [u8] = unsafe { core::ptr::slice_from_raw_parts_mut(MPTR, 1) };
+        //~^ cast_slice_from_raw_parts
+        require_raw_slice_ptr(unsafe { core::ptr::slice_from_raw_parts(PTR, 1) });
+        //~^ cast_slice_from_raw_parts
+    };
+}
diff --git a/tests/ui/cast_raw_slice_pointer_cast_no_std.rs b/tests/ui/cast_raw_slice_pointer_cast_no_std.rs
new file mode 100644
index 0000000000000..743e44c97dc13
--- /dev/null
+++ b/tests/ui/cast_raw_slice_pointer_cast_no_std.rs
@@ -0,0 +1,55 @@
+#![warn(clippy::cast_slice_from_raw_parts)]
+#![no_std]
+#![crate_type = "lib"]
+
+const fn require_raw_slice_ptr<T>(_: *const [T]) {}
+
+fn main() {
+    let mut arr = [0u8; 1];
+    let ptr: *const u8 = arr.as_ptr();
+    let mptr = arr.as_mut_ptr();
+    let _: *const [u8] = unsafe { core::slice::from_raw_parts(ptr, 1) as *const [u8] };
+    //~^ cast_slice_from_raw_parts
+    let _: *const [u8] = unsafe { core::slice::from_raw_parts_mut(mptr, 1) as *mut [u8] };
+    //~^ cast_slice_from_raw_parts
+    let _: *const [u8] = unsafe { core::slice::from_raw_parts(ptr, 1) } as *const [u8];
+    //~^ cast_slice_from_raw_parts
+    {
+        use core::slice;
+        let _: *const [u8] = unsafe { slice::from_raw_parts(ptr, 1) } as *const [u8];
+        //~^ cast_slice_from_raw_parts
+        use slice as one;
+        let _: *const [u8] = unsafe { one::from_raw_parts(ptr, 1) } as *const [u8];
+        //~^ cast_slice_from_raw_parts
+    }
+    {
+        use core::slice;
+        let _: *const [u8] = unsafe { slice::from_raw_parts(ptr, 1) } as *const [u8];
+        //~^ cast_slice_from_raw_parts
+        use slice as one;
+        let _: *const [u8] = unsafe { one::from_raw_parts(ptr, 1) } as *const [u8];
+        //~^ cast_slice_from_raw_parts
+    }
+
+    // implicit cast
+    {
+        let _: *const [u8] = unsafe { core::slice::from_raw_parts(ptr, 1) };
+        //~^ cast_slice_from_raw_parts
+        let _: *mut [u8] = unsafe { core::slice::from_raw_parts_mut(mptr, 1) };
+        //~^ cast_slice_from_raw_parts
+        require_raw_slice_ptr(unsafe { core::slice::from_raw_parts(ptr, 1) });
+        //~^ cast_slice_from_raw_parts
+    }
+
+    // implicit cast in const context
+    const {
+        const PTR: *const u8 = core::ptr::null();
+        const MPTR: *mut u8 = core::ptr::null_mut();
+        let _: *const [u8] = unsafe { core::slice::from_raw_parts(PTR, 1) };
+        //~^ cast_slice_from_raw_parts
+        let _: *mut [u8] = unsafe { core::slice::from_raw_parts_mut(MPTR, 1) };
+        //~^ cast_slice_from_raw_parts
+        require_raw_slice_ptr(unsafe { core::slice::from_raw_parts(PTR, 1) });
+        //~^ cast_slice_from_raw_parts
+    };
+}
diff --git a/tests/ui/cast_raw_slice_pointer_cast_no_std.stderr b/tests/ui/cast_raw_slice_pointer_cast_no_std.stderr
new file mode 100644
index 0000000000000..5488fbcfa1ce5
--- /dev/null
+++ b/tests/ui/cast_raw_slice_pointer_cast_no_std.stderr
@@ -0,0 +1,83 @@
+error: casting the result of `from_raw_parts` to *const [u8]
+  --> tests/ui/cast_raw_slice_pointer_cast_no_std.rs:11:35
+   |
+LL |     let _: *const [u8] = unsafe { core::slice::from_raw_parts(ptr, 1) as *const [u8] };
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+   |
+   = note: `-D clippy::cast-slice-from-raw-parts` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::cast_slice_from_raw_parts)]`
+
+error: casting the result of `from_raw_parts_mut` to *mut [u8]
+  --> tests/ui/cast_raw_slice_pointer_cast_no_std.rs:13:35
+   |
+LL |     let _: *const [u8] = unsafe { core::slice::from_raw_parts_mut(mptr, 1) as *mut [u8] };
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts_mut(mptr, 1)`
+
+error: casting the result of `from_raw_parts` to *const [u8]
+  --> tests/ui/cast_raw_slice_pointer_cast_no_std.rs:15:26
+   |
+LL |     let _: *const [u8] = unsafe { core::slice::from_raw_parts(ptr, 1) } as *const [u8];
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+
+error: casting the result of `from_raw_parts` to *const [u8]
+  --> tests/ui/cast_raw_slice_pointer_cast_no_std.rs:19:30
+   |
+LL |         let _: *const [u8] = unsafe { slice::from_raw_parts(ptr, 1) } as *const [u8];
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+
+error: casting the result of `from_raw_parts` to *const [u8]
+  --> tests/ui/cast_raw_slice_pointer_cast_no_std.rs:22:30
+   |
+LL |         let _: *const [u8] = unsafe { one::from_raw_parts(ptr, 1) } as *const [u8];
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+
+error: casting the result of `from_raw_parts` to *const [u8]
+  --> tests/ui/cast_raw_slice_pointer_cast_no_std.rs:27:30
+   |
+LL |         let _: *const [u8] = unsafe { slice::from_raw_parts(ptr, 1) } as *const [u8];
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+
+error: casting the result of `from_raw_parts` to *const [u8]
+  --> tests/ui/cast_raw_slice_pointer_cast_no_std.rs:30:30
+   |
+LL |         let _: *const [u8] = unsafe { one::from_raw_parts(ptr, 1) } as *const [u8];
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+
+error: implicitly casting the result of `from_raw_parts` to `*const [u8]`
+  --> tests/ui/cast_raw_slice_pointer_cast_no_std.rs:36:39
+   |
+LL |         let _: *const [u8] = unsafe { core::slice::from_raw_parts(ptr, 1) };
+   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+
+error: implicitly casting the result of `from_raw_parts_mut` to `*mut [u8]`
+  --> tests/ui/cast_raw_slice_pointer_cast_no_std.rs:38:37
+   |
+LL |         let _: *mut [u8] = unsafe { core::slice::from_raw_parts_mut(mptr, 1) };
+   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `core::ptr::slice_from_raw_parts_mut(mptr, 1)`
+
+error: implicitly casting the result of `from_raw_parts` to `*const [u8]`
+  --> tests/ui/cast_raw_slice_pointer_cast_no_std.rs:40:40
+   |
+LL |         require_raw_slice_ptr(unsafe { core::slice::from_raw_parts(ptr, 1) });
+   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+
+error: implicitly casting the result of `from_raw_parts` to `*const [u8]`
+  --> tests/ui/cast_raw_slice_pointer_cast_no_std.rs:48:39
+   |
+LL |         let _: *const [u8] = unsafe { core::slice::from_raw_parts(PTR, 1) };
+   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `core::ptr::slice_from_raw_parts(PTR, 1)`
+
+error: implicitly casting the result of `from_raw_parts_mut` to `*mut [u8]`
+  --> tests/ui/cast_raw_slice_pointer_cast_no_std.rs:50:37
+   |
+LL |         let _: *mut [u8] = unsafe { core::slice::from_raw_parts_mut(MPTR, 1) };
+   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `core::ptr::slice_from_raw_parts_mut(MPTR, 1)`
+
+error: implicitly casting the result of `from_raw_parts` to `*const [u8]`
+  --> tests/ui/cast_raw_slice_pointer_cast_no_std.rs:52:40
+   |
+LL |         require_raw_slice_ptr(unsafe { core::slice::from_raw_parts(PTR, 1) });
+   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace_with: `core::ptr::slice_from_raw_parts(PTR, 1)`
+
+error: aborting due to 13 previous errors
+
diff --git a/tests/ui/collapsible_match.rs b/tests/ui/collapsible_match.rs
index 71b82040ff62a..8931a3aa09c61 100644
--- a/tests/ui/collapsible_match.rs
+++ b/tests/ui/collapsible_match.rs
@@ -316,6 +316,47 @@ fn lint_emitted_at_right_node(opt: Option<Result<u64, String>>) {
     };
 }
 
+pub fn issue_14155() {
+    let mut arr = ["a", "b", "c"];
+    if let Some(last) = arr.last() {
+        match *last {
+            //~^ collapsible_match
+            "a" | "b" => {
+                unimplemented!()
+            },
+            _ => (),
+        }
+    }
+
+    if let Some(last) = arr.last() {
+        match &last {
+            //~^ collapsible_match
+            &&"a" | &&"b" => {
+                unimplemented!()
+            },
+            _ => (),
+        }
+    }
+
+    if let Some(mut last) = arr.last_mut() {
+        match &mut last {
+            //~^ collapsible_match
+            &mut &mut "a" | &mut &mut "b" => {
+                unimplemented!()
+            },
+            _ => (),
+        }
+    }
+
+    const NULL_PTR: *const &'static str = std::ptr::null();
+    if let Some(last) = arr.last() {
+        match &raw const *last {
+            NULL_PTR => unimplemented!(),
+            _ => (),
+        }
+    }
+}
+
 fn make<T>() -> T {
     unimplemented!()
 }
diff --git a/tests/ui/collapsible_match.stderr b/tests/ui/collapsible_match.stderr
index c290d84ec2976..14b1c1b187e4f 100644
--- a/tests/ui/collapsible_match.stderr
+++ b/tests/ui/collapsible_match.stderr
@@ -250,5 +250,74 @@ LL |     if let Issue9647::A { a: Some(a), .. } = x {
 LL |         if let Some(u) = a {
    |                ^^^^^^^ with this pattern
 
-error: aborting due to 13 previous errors
+error: this `match` can be collapsed into the outer `if let`
+  --> tests/ui/collapsible_match.rs:322:9
+   |
+LL | /         match *last {
+LL | |
+LL | |             "a" | "b" => {
+LL | |                 unimplemented!()
+LL | |             },
+LL | |             _ => (),
+LL | |         }
+   | |_________^
+   |
+help: the outer pattern can be modified to include the inner pattern
+  --> tests/ui/collapsible_match.rs:321:17
+   |
+LL |     if let Some(last) = arr.last() {
+   |                 ^^^^    ---------- use: `arr.last().copied()`
+   |                 |
+   |                 replace this binding
+...
+LL |             "a" | "b" => {
+   |             ^^^^^^^^^ with this pattern
+
+error: this `match` can be collapsed into the outer `if let`
+  --> tests/ui/collapsible_match.rs:332:9
+   |
+LL | /         match &last {
+LL | |
+LL | |             &&"a" | &&"b" => {
+LL | |                 unimplemented!()
+LL | |             },
+LL | |             _ => (),
+LL | |         }
+   | |_________^
+   |
+help: the outer pattern can be modified to include the inner pattern
+  --> tests/ui/collapsible_match.rs:331:17
+   |
+LL |     if let Some(last) = arr.last() {
+   |                 ^^^^    ---------- use: `arr.last().as_ref()`
+   |                 |
+   |                 replace this binding
+...
+LL |             &&"a" | &&"b" => {
+   |             ^^^^^^^^^^^^^ with this pattern
+
+error: this `match` can be collapsed into the outer `if let`
+  --> tests/ui/collapsible_match.rs:342:9
+   |
+LL | /         match &mut last {
+LL | |
+LL | |             &mut &mut "a" | &mut &mut "b" => {
+LL | |                 unimplemented!()
+LL | |             },
+LL | |             _ => (),
+LL | |         }
+   | |_________^
+   |
+help: the outer pattern can be modified to include the inner pattern
+  --> tests/ui/collapsible_match.rs:341:17
+   |
+LL |     if let Some(mut last) = arr.last_mut() {
+   |                 ^^^^^^^^    -------------- use: `arr.last_mut().as_mut()`
+   |                 |
+   |                 replace this binding
+...
+LL |             &mut &mut "a" | &mut &mut "b" => {
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ with this pattern
+
+error: aborting due to 16 previous errors
 
diff --git a/tests/ui/collapsible_match2.stderr b/tests/ui/collapsible_match2.stderr
index 7b27306375289..2597067099906 100644
--- a/tests/ui/collapsible_match2.stderr
+++ b/tests/ui/collapsible_match2.stderr
@@ -77,6 +77,8 @@ LL | |         },
 help: the outer pattern can be modified to include the inner pattern
   --> tests/ui/collapsible_match2.rs:54:14
    |
+LL |     match Some(&[1]) {
+   |           ---------- use: `Some(&[1]).copied()`
 LL |         Some(s) => match *s {
    |              ^ replace this binding
 LL |
diff --git a/tests/ui/derivable_impls.fixed b/tests/ui/derivable_impls.fixed
index 65bfded38835e..9f9e4e253c3c4 100644
--- a/tests/ui/derivable_impls.fixed
+++ b/tests/ui/derivable_impls.fixed
@@ -1,4 +1,6 @@
 #![allow(dead_code)]
+#![feature(const_trait_impl)]
+#![feature(const_default)]
 
 use std::collections::HashMap;
 
@@ -326,4 +328,40 @@ mod issue11368 {
     }
 }
 
+mod issue15493 {
+    #[derive(Copy, Clone)]
+    #[repr(transparent)]
+    struct Foo(u64);
+
+    impl const Default for Foo {
+        fn default() -> Self {
+            Self(0)
+        }
+    }
+
+    #[derive(Copy, Clone)]
+    enum Bar {
+        A,
+        B,
+    }
+
+    impl const Default for Bar {
+        fn default() -> Self {
+            Bar::A
+        }
+    }
+}
+
+mod issue15536 {
+    #[derive(Copy, Clone)]
+    #[derive(Default)]
+    enum Bar {
+        #[default]
+        A,
+        B,
+    }
+
+    
+}
+
 fn main() {}
diff --git a/tests/ui/derivable_impls.rs b/tests/ui/derivable_impls.rs
index 4826c5497b4a3..74a793b9a70e6 100644
--- a/tests/ui/derivable_impls.rs
+++ b/tests/ui/derivable_impls.rs
@@ -1,4 +1,6 @@
 #![allow(dead_code)]
+#![feature(const_trait_impl)]
+#![feature(const_default)]
 
 use std::collections::HashMap;
 
@@ -396,4 +398,43 @@ mod issue11368 {
     }
 }
 
+mod issue15493 {
+    #[derive(Copy, Clone)]
+    #[repr(transparent)]
+    struct Foo(u64);
+
+    impl const Default for Foo {
+        fn default() -> Self {
+            Self(0)
+        }
+    }
+
+    #[derive(Copy, Clone)]
+    enum Bar {
+        A,
+        B,
+    }
+
+    impl const Default for Bar {
+        fn default() -> Self {
+            Bar::A
+        }
+    }
+}
+
+mod issue15536 {
+    #[derive(Copy, Clone)]
+    enum Bar {
+        A,
+        B,
+    }
+
+    impl Default for Bar {
+        //~^ derivable_impls
+        fn default() -> Self {
+            Self::A
+        }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/derivable_impls.stderr b/tests/ui/derivable_impls.stderr
index 0f73ad55a85eb..cd46414cb4a8a 100644
--- a/tests/ui/derivable_impls.stderr
+++ b/tests/ui/derivable_impls.stderr
@@ -1,5 +1,5 @@
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:20:1
+  --> tests/ui/derivable_impls.rs:22:1
    |
 LL | / impl std::default::Default for FooDefault<'_> {
 LL | |
@@ -18,7 +18,7 @@ LL ~ struct FooDefault<'a> {
    |
 
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:42:1
+  --> tests/ui/derivable_impls.rs:44:1
    |
 LL | / impl std::default::Default for TupleDefault {
 LL | |
@@ -35,7 +35,7 @@ LL ~ struct TupleDefault(bool, i32, u64);
    |
 
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:95:1
+  --> tests/ui/derivable_impls.rs:97:1
    |
 LL | / impl Default for StrDefault<'_> {
 LL | |
@@ -52,7 +52,7 @@ LL ~ struct StrDefault<'a>(&'a str);
    |
 
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:122:1
+  --> tests/ui/derivable_impls.rs:124:1
    |
 LL | / impl Default for Y {
 LL | |
@@ -69,7 +69,7 @@ LL ~ struct Y(u32);
    |
 
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:162:1
+  --> tests/ui/derivable_impls.rs:164:1
    |
 LL | / impl Default for WithoutSelfCurly {
 LL | |
@@ -86,7 +86,7 @@ LL ~ struct WithoutSelfCurly {
    |
 
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:171:1
+  --> tests/ui/derivable_impls.rs:173:1
    |
 LL | / impl Default for WithoutSelfParan {
 LL | |
@@ -103,7 +103,7 @@ LL ~ struct WithoutSelfParan(bool);
    |
 
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:194:1
+  --> tests/ui/derivable_impls.rs:196:1
    |
 LL | / impl Default for DirectDefaultDefaultCall {
 LL | |
@@ -119,7 +119,7 @@ LL ~ pub struct DirectDefaultDefaultCall {
    |
 
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:206:1
+  --> tests/ui/derivable_impls.rs:208:1
    |
 LL | / impl Default for EquivalentToDefaultDefaultCallVec {
 LL | |
@@ -135,7 +135,7 @@ LL ~ pub struct EquivalentToDefaultDefaultCallVec {
    |
 
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:234:1
+  --> tests/ui/derivable_impls.rs:236:1
    |
 LL | / impl Default for EquivalentToDefaultDefaultCallLocal {
 LL | |
@@ -151,7 +151,7 @@ LL ~ pub struct EquivalentToDefaultDefaultCallLocal {
    |
 
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:274:1
+  --> tests/ui/derivable_impls.rs:276:1
    |
 LL | / impl Default for RepeatDefault1 {
 LL | |
@@ -168,7 +168,7 @@ LL ~ pub struct RepeatDefault1 {
    |
 
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:309:1
+  --> tests/ui/derivable_impls.rs:311:1
    |
 LL | / impl Default for SimpleEnum {
 LL | |
@@ -187,5 +187,28 @@ LL ~     #[default]
 LL ~     Bar,
    |
 
-error: aborting due to 11 previous errors
+error: this `impl` can be derived
+  --> tests/ui/derivable_impls.rs:432:5
+   |
+LL | /     impl Default for Bar {
+LL | |
+LL | |         fn default() -> Self {
+LL | |             Self::A
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+help: replace the manual implementation with a derive attribute and mark the default variant
+   |
+LL ~     #[derive(Default)]
+LL ~     enum Bar {
+LL ~         #[default]
+LL ~         A,
+LL |         B,
+LL |     }
+LL |
+LL ~     
+   |
+
+error: aborting due to 12 previous errors
 
diff --git a/tests/ui/derivable_impls_derive_const.fixed b/tests/ui/derivable_impls_derive_const.fixed
new file mode 100644
index 0000000000000..f0d8d2d240924
--- /dev/null
+++ b/tests/ui/derivable_impls_derive_const.fixed
@@ -0,0 +1,25 @@
+#![allow(dead_code)]
+#![feature(const_trait_impl)]
+#![feature(const_default)]
+#![feature(derive_const)]
+
+mod issue15493 {
+    #[derive(Copy, Clone)]
+    #[repr(transparent)]
+    #[derive_const(Default)]
+    struct Foo(u64);
+
+    
+
+    #[derive(Copy, Clone)]
+    #[derive_const(Default)]
+    enum Bar {
+        #[default]
+        A,
+        B,
+    }
+
+    
+}
+
+fn main() {}
diff --git a/tests/ui/derivable_impls_derive_const.rs b/tests/ui/derivable_impls_derive_const.rs
new file mode 100644
index 0000000000000..7d70db1c097d4
--- /dev/null
+++ b/tests/ui/derivable_impls_derive_const.rs
@@ -0,0 +1,32 @@
+#![allow(dead_code)]
+#![feature(const_trait_impl)]
+#![feature(const_default)]
+#![feature(derive_const)]
+
+mod issue15493 {
+    #[derive(Copy, Clone)]
+    #[repr(transparent)]
+    struct Foo(u64);
+
+    impl const Default for Foo {
+        //~^ derivable_impls
+        fn default() -> Self {
+            Self(0)
+        }
+    }
+
+    #[derive(Copy, Clone)]
+    enum Bar {
+        A,
+        B,
+    }
+
+    impl const Default for Bar {
+        //~^ derivable_impls
+        fn default() -> Self {
+            Bar::A
+        }
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/derivable_impls_derive_const.stderr b/tests/ui/derivable_impls_derive_const.stderr
new file mode 100644
index 0000000000000..196bac185ddaa
--- /dev/null
+++ b/tests/ui/derivable_impls_derive_const.stderr
@@ -0,0 +1,46 @@
+error: this `impl` can be derived
+  --> tests/ui/derivable_impls_derive_const.rs:11:5
+   |
+LL | /     impl const Default for Foo {
+LL | |
+LL | |         fn default() -> Self {
+LL | |             Self(0)
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+   = note: `-D clippy::derivable-impls` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::derivable_impls)]`
+help: replace the manual implementation with a derive attribute
+   |
+LL ~     #[derive_const(Default)]
+LL ~     struct Foo(u64);
+LL |
+LL ~     
+   |
+
+error: this `impl` can be derived
+  --> tests/ui/derivable_impls_derive_const.rs:24:5
+   |
+LL | /     impl const Default for Bar {
+LL | |
+LL | |         fn default() -> Self {
+LL | |             Bar::A
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+help: replace the manual implementation with a derive attribute and mark the default variant
+   |
+LL ~     #[derive_const(Default)]
+LL ~     enum Bar {
+LL ~         #[default]
+LL ~         A,
+LL |         B,
+LL |     }
+LL |
+LL ~     
+   |
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/doc/doc-fixable.fixed b/tests/ui/doc/doc-fixable.fixed
index 423a73734daab..46695dc929ab7 100644
--- a/tests/ui/doc/doc-fixable.fixed
+++ b/tests/ui/doc/doc-fixable.fixed
@@ -73,6 +73,7 @@ fn test_units() {
 /// GPLv2 GPLv3
 /// GitHub GitLab
 /// IPv4 IPv6
+/// InfiniBand RoCE
 /// ClojureScript CoffeeScript JavaScript PostScript PureScript TypeScript
 /// PowerPC WebAssembly
 /// NaN NaNs
diff --git a/tests/ui/doc/doc-fixable.rs b/tests/ui/doc/doc-fixable.rs
index 8deffb4210e43..4082fa5b56f4b 100644
--- a/tests/ui/doc/doc-fixable.rs
+++ b/tests/ui/doc/doc-fixable.rs
@@ -73,6 +73,7 @@ fn test_units() {
 /// GPLv2 GPLv3
 /// GitHub GitLab
 /// IPv4 IPv6
+/// InfiniBand RoCE
 /// ClojureScript CoffeeScript JavaScript PostScript PureScript TypeScript
 /// PowerPC WebAssembly
 /// NaN NaNs
diff --git a/tests/ui/doc/doc-fixable.stderr b/tests/ui/doc/doc-fixable.stderr
index 98c26e6bec2eb..2a94a8f316587 100644
--- a/tests/ui/doc/doc-fixable.stderr
+++ b/tests/ui/doc/doc-fixable.stderr
@@ -145,7 +145,7 @@ LL + /// `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:90:5
+  --> tests/ui/doc/doc-fixable.rs:91:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -157,7 +157,7 @@ LL + /// `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:108:5
+  --> tests/ui/doc/doc-fixable.rs:109:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -169,7 +169,7 @@ LL + /// `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:117:8
+  --> tests/ui/doc/doc-fixable.rs:118:8
    |
 LL | /// ## CamelCaseThing
    |        ^^^^^^^^^^^^^^
@@ -181,7 +181,7 @@ LL + /// ## `CamelCaseThing`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:121:7
+  --> tests/ui/doc/doc-fixable.rs:122:7
    |
 LL | /// # CamelCaseThing
    |       ^^^^^^^^^^^^^^
@@ -193,7 +193,7 @@ LL + /// # `CamelCaseThing`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:124:22
+  --> tests/ui/doc/doc-fixable.rs:125:22
    |
 LL | /// Not a title #897 CamelCaseThing
    |                      ^^^^^^^^^^^^^^
@@ -205,7 +205,7 @@ LL + /// Not a title #897 `CamelCaseThing`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:126:5
+  --> tests/ui/doc/doc-fixable.rs:127:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -217,7 +217,7 @@ LL + /// `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:134:5
+  --> tests/ui/doc/doc-fixable.rs:135:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -229,7 +229,7 @@ LL + /// `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:148:5
+  --> tests/ui/doc/doc-fixable.rs:149:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -241,7 +241,7 @@ LL + /// `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:160:43
+  --> tests/ui/doc/doc-fixable.rs:161:43
    |
 LL | /** E.g., serialization of an empty list: FooBar
    |                                           ^^^^^^
@@ -253,7 +253,7 @@ LL + /** E.g., serialization of an empty list: `FooBar`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:165:5
+  --> tests/ui/doc/doc-fixable.rs:166:5
    |
 LL | And BarQuz too.
    |     ^^^^^^
@@ -265,7 +265,7 @@ LL + And `BarQuz` too.
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:166:1
+  --> tests/ui/doc/doc-fixable.rs:167:1
    |
 LL | be_sure_we_got_to_the_end_of_it
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -277,7 +277,7 @@ LL + `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:174:43
+  --> tests/ui/doc/doc-fixable.rs:175:43
    |
 LL | /** E.g., serialization of an empty list: FooBar
    |                                           ^^^^^^
@@ -289,7 +289,7 @@ LL + /** E.g., serialization of an empty list: `FooBar`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:179:5
+  --> tests/ui/doc/doc-fixable.rs:180:5
    |
 LL | And BarQuz too.
    |     ^^^^^^
@@ -301,7 +301,7 @@ LL + And `BarQuz` too.
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:180:1
+  --> tests/ui/doc/doc-fixable.rs:181:1
    |
 LL | be_sure_we_got_to_the_end_of_it
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -313,7 +313,7 @@ LL + `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:194:5
+  --> tests/ui/doc/doc-fixable.rs:195:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -325,7 +325,7 @@ LL + /// `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:214:22
+  --> tests/ui/doc/doc-fixable.rs:215:22
    |
 LL | /// An iterator over mycrate::Collection's values.
    |                      ^^^^^^^^^^^^^^^^^^^
@@ -337,7 +337,7 @@ LL + /// An iterator over `mycrate::Collection`'s values.
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:239:34
+  --> tests/ui/doc/doc-fixable.rs:240:34
    |
 LL | /// Foo \[bar\] \[baz\] \[qux\]. DocMarkdownLint
    |                                  ^^^^^^^^^^^^^^^
@@ -349,7 +349,7 @@ LL + /// Foo \[bar\] \[baz\] \[qux\]. `DocMarkdownLint`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:263:22
+  --> tests/ui/doc/doc-fixable.rs:264:22
    |
 LL | /// There is no try (do() or do_not()).
    |                      ^^^^
@@ -361,7 +361,7 @@ LL + /// There is no try (`do()` or do_not()).
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:263:30
+  --> tests/ui/doc/doc-fixable.rs:264:30
    |
 LL | /// There is no try (do() or do_not()).
    |                              ^^^^^^^^
@@ -373,7 +373,7 @@ LL + /// There is no try (do() or `do_not()`).
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:268:5
+  --> tests/ui/doc/doc-fixable.rs:269:5
    |
 LL | /// ABes
    |     ^^^^
@@ -385,7 +385,7 @@ LL + /// `ABes`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:275:9
+  --> tests/ui/doc/doc-fixable.rs:276:9
    |
 LL |     /// foo()
    |         ^^^^^
@@ -397,7 +397,7 @@ LL +     /// `foo()`
    |
 
 error: you should put bare URLs between `<`/`>` or make a proper Markdown link
-  --> tests/ui/doc/doc-fixable.rs:280:5
+  --> tests/ui/doc/doc-fixable.rs:281:5
    |
 LL | /// https://github.com/rust-lang/rust-clippy/pull/12836
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `<https://github.com/rust-lang/rust-clippy/pull/12836>`
diff --git a/tests/ui/entry_unfixable.stderr b/tests/ui/entry_unfixable.stderr
index 0197d2ab4cf9c..f92f472512f67 100644
--- a/tests/ui/entry_unfixable.stderr
+++ b/tests/ui/entry_unfixable.stderr
@@ -10,6 +10,7 @@ LL | |                 false
 LL | |             }
    | |_____________^
    |
+   = help: consider using the `Entry` API: https://doc.rust-lang.org/std/collections/struct.HashMap.html#entry-api
    = note: `-D clippy::map-entry` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::map_entry)]`
 
@@ -24,6 +25,8 @@ LL | |     } else {
 LL | |         hm.insert(key, true);
 LL | |     }
    | |_____^
+   |
+   = help: consider using the `Entry` API: https://doc.rust-lang.org/std/collections/struct.HashMap.html#entry-api
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
   --> tests/ui/entry_unfixable.rs:80:13
@@ -36,6 +39,8 @@ LL | |                 let interner = INTERNER.lock().unwrap();
 LL | |                 return Err(interner.resolve(name).unwrap().to_owned());
 LL | |             }
    | |_____________^
+   |
+   = help: consider using the `Entry` API: https://doc.rust-lang.org/std/collections/struct.HashMap.html#entry-api
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index 3d2b41b8fb81c..6944a979c05e6 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -565,6 +565,51 @@ fn issue_14789() {
     );
 }
 
+fn issue_15072() {
+    use std::ops::Deref;
+
+    struct Foo;
+    impl Deref for Foo {
+        type Target = fn() -> &'static str;
+
+        fn deref(&self) -> &Self::Target {
+            fn hello() -> &'static str {
+                "Hello, world!"
+            }
+            &(hello as fn() -> &'static str)
+        }
+    }
+
+    fn accepts_fn(f: impl Fn() -> &'static str) {
+        println!("{}", f());
+    }
+
+    fn some_fn() -> &'static str {
+        todo!()
+    }
+
+    let f = &Foo;
+    accepts_fn(**f);
+    //~^ redundant_closure
+
+    let g = &some_fn;
+    accepts_fn(g);
+    //~^ redundant_closure
+
+    struct Bar(Foo);
+    impl Deref for Bar {
+        type Target = Foo;
+
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    let b = &Bar(Foo);
+    accepts_fn(***b);
+    //~^ redundant_closure
+}
+
 fn issue8817() {
     fn f(_: u32) -> u32 {
         todo!()
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index 79d1103410d9d..5bcc1cb26fd78 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -565,6 +565,51 @@ fn issue_14789() {
     );
 }
 
+fn issue_15072() {
+    use std::ops::Deref;
+
+    struct Foo;
+    impl Deref for Foo {
+        type Target = fn() -> &'static str;
+
+        fn deref(&self) -> &Self::Target {
+            fn hello() -> &'static str {
+                "Hello, world!"
+            }
+            &(hello as fn() -> &'static str)
+        }
+    }
+
+    fn accepts_fn(f: impl Fn() -> &'static str) {
+        println!("{}", f());
+    }
+
+    fn some_fn() -> &'static str {
+        todo!()
+    }
+
+    let f = &Foo;
+    accepts_fn(|| f());
+    //~^ redundant_closure
+
+    let g = &some_fn;
+    accepts_fn(|| g());
+    //~^ redundant_closure
+
+    struct Bar(Foo);
+    impl Deref for Bar {
+        type Target = Foo;
+
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    let b = &Bar(Foo);
+    accepts_fn(|| b());
+    //~^ redundant_closure
+}
+
 fn issue8817() {
     fn f(_: u32) -> u32 {
         todo!()
diff --git a/tests/ui/eta.stderr b/tests/ui/eta.stderr
index aa32ed1a38ef6..0b401cdea9875 100644
--- a/tests/ui/eta.stderr
+++ b/tests/ui/eta.stderr
@@ -215,28 +215,46 @@ LL |         let _field = bind.or_else(|| get_default()).unwrap();
    |                                   ^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `get_default`
 
 error: redundant closure
-  --> tests/ui/eta.rs:588:14
+  --> tests/ui/eta.rs:592:16
+   |
+LL |     accepts_fn(|| f());
+   |                ^^^^^^ help: replace the closure with the function itself: `**f`
+
+error: redundant closure
+  --> tests/ui/eta.rs:596:16
+   |
+LL |     accepts_fn(|| g());
+   |                ^^^^^^ help: replace the closure with the function itself: `g`
+
+error: redundant closure
+  --> tests/ui/eta.rs:609:16
+   |
+LL |     accepts_fn(|| b());
+   |                ^^^^^^ help: replace the closure with the function itself: `***b`
+
+error: redundant closure
+  --> tests/ui/eta.rs:633:14
    |
 LL |         .map(|n| MyError::A(n))
    |              ^^^^^^^^^^^^^^^^^ help: replace the closure with the tuple variant itself: `MyError::A`
 
 error: redundant closure
-  --> tests/ui/eta.rs:585:14
+  --> tests/ui/eta.rs:630:14
    |
 LL |         .map(|n| S(n))
    |              ^^^^^^^^ help: replace the closure with the tuple struct itself: `S`
 
 error: redundant closure
-  --> tests/ui/eta.rs:582:14
+  --> tests/ui/eta.rs:627:14
    |
 LL |         .map(|n| g(n))
    |              ^^^^^^^^ help: replace the closure with the function itself: `g`
 
 error: redundant closure
-  --> tests/ui/eta.rs:579:14
+  --> tests/ui/eta.rs:624:14
    |
 LL |         .map(|n| f(n))
    |              ^^^^^^^^ help: replace the closure with the function itself: `f`
 
-error: aborting due to 39 previous errors
+error: aborting due to 42 previous errors
 
diff --git a/tests/ui/excessive_precision.fixed b/tests/ui/excessive_precision.fixed
index 8a8c2e1939c83..8158d4b332acd 100644
--- a/tests/ui/excessive_precision.fixed
+++ b/tests/ui/excessive_precision.fixed
@@ -4,9 +4,16 @@
     overflowing_literals,
     unused_variables,
     clippy::print_literal,
-    clippy::useless_vec
+    clippy::useless_vec,
+    clippy::approx_constant
 )]
 
+macro_rules! make_pi {
+    ($i:ident : $t:ty) => {
+        const $i: $t = 3.14159265358979323846264338327950288419716939937510582097494459230781640628;
+    };
+}
+
 fn main() {
     // Consts
     const GOOD32: f32 = 0.123_456;
@@ -101,4 +108,40 @@ fn main() {
     const _: f64 = 3.0;
     //~^ excessive_precision
     const _: f64 = 3.0000000000000000;
+
+    // Overly specified constants
+    let _: f32 = 1.012_345_7;
+    //~^ excessive_precision
+    let _: f64 = 1.012_345_678_901_234_6;
+    //~^ excessive_precision
+    const _: f32 = 1.01234567890123456789012345678901234567890;
+    const _: f64 = 1.01234567890123456789012345678901234567890;
+
+    static STATIC1: f32 = 1.01234567890123456789012345678901234567890;
+    static STATIC2: f64 = 1.01234567890123456789012345678901234567890;
+
+    static mut STATIC_MUT1: f32 = 1.01234567890123456789012345678901234567890;
+    static mut STATIC_MUT2: f64 = 1.01234567890123456789012345678901234567890;
+
+    // From issue #13855
+    let gamma = 0.577_215_664_901_532_9;
+    //~^ excessive_precision
+    const GAMMA: f64 = 0.5772156649015328606065120900824024310421;
+
+    make_pi!(P32: f32);
+    make_pi!(P64: f64);
+}
+
+trait ExcessivelyPreciseTrait {
+    // Overly specified constants
+    const GOOD1: f32 = 1.01234567890123456789012345678901234567890;
+    const GOOD2: f64 = 1.01234567890123456789012345678901234567890;
+}
+
+struct ExcessivelyPreciseStruct;
+
+impl ExcessivelyPreciseStruct {
+    // Overly specified constants
+    const GOOD1: f32 = 1.01234567890123456789012345678901234567890;
+    const GOOD2: f64 = 1.01234567890123456789012345678901234567890;
 }
diff --git a/tests/ui/excessive_precision.rs b/tests/ui/excessive_precision.rs
index 5dcf55cb92735..7ee6247ee5ac9 100644
--- a/tests/ui/excessive_precision.rs
+++ b/tests/ui/excessive_precision.rs
@@ -4,9 +4,16 @@
     overflowing_literals,
     unused_variables,
     clippy::print_literal,
-    clippy::useless_vec
+    clippy::useless_vec,
+    clippy::approx_constant
 )]
 
+macro_rules! make_pi {
+    ($i:ident : $t:ty) => {
+        const $i: $t = 3.14159265358979323846264338327950288419716939937510582097494459230781640628;
+    };
+}
+
 fn main() {
     // Consts
     const GOOD32: f32 = 0.123_456;
@@ -101,4 +108,40 @@ fn main() {
     const _: f64 = 3.0000000000000000e+00;
     //~^ excessive_precision
     const _: f64 = 3.0000000000000000;
+
+    // Overly specified constants
+    let _: f32 = 1.01234567890123456789012345678901234567890;
+    //~^ excessive_precision
+    let _: f64 = 1.01234567890123456789012345678901234567890;
+    //~^ excessive_precision
+    const _: f32 = 1.01234567890123456789012345678901234567890;
+    const _: f64 = 1.01234567890123456789012345678901234567890;
+
+    static STATIC1: f32 = 1.01234567890123456789012345678901234567890;
+    static STATIC2: f64 = 1.01234567890123456789012345678901234567890;
+
+    static mut STATIC_MUT1: f32 = 1.01234567890123456789012345678901234567890;
+    static mut STATIC_MUT2: f64 = 1.01234567890123456789012345678901234567890;
+
+    // From issue #13855
+    let gamma = 0.5772156649015328606065120900824024310421;
+    //~^ excessive_precision
+    const GAMMA: f64 = 0.5772156649015328606065120900824024310421;
+
+    make_pi!(P32: f32);
+    make_pi!(P64: f64);
+}
+
+trait ExcessivelyPreciseTrait {
+    // Overly specified constants
+    const GOOD1: f32 = 1.01234567890123456789012345678901234567890;
+    const GOOD2: f64 = 1.01234567890123456789012345678901234567890;
+}
+
+struct ExcessivelyPreciseStruct;
+
+impl ExcessivelyPreciseStruct {
+    // Overly specified constants
+    const GOOD1: f32 = 1.01234567890123456789012345678901234567890;
+    const GOOD2: f64 = 1.01234567890123456789012345678901234567890;
 }
diff --git a/tests/ui/excessive_precision.stderr b/tests/ui/excessive_precision.stderr
index f5eeadf0c8cb0..40806d67487fd 100644
--- a/tests/ui/excessive_precision.stderr
+++ b/tests/ui/excessive_precision.stderr
@@ -1,5 +1,5 @@
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:20:26
+  --> tests/ui/excessive_precision.rs:27:26
    |
 LL |     const BAD32_1: f32 = 0.123_456_789_f32;
    |                          ^^^^^^^^^^^^^^^^^
@@ -13,7 +13,7 @@ LL +     const BAD32_1: f32 = 0.123_456_79_f32;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:22:26
+  --> tests/ui/excessive_precision.rs:29:26
    |
 LL |     const BAD32_2: f32 = 0.123_456_789;
    |                          ^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     const BAD32_2: f32 = 0.123_456_79;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:24:26
+  --> tests/ui/excessive_precision.rs:31:26
    |
 LL |     const BAD32_3: f32 = 0.100_000_000_000_1;
    |                          ^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     const BAD32_3: f32 = 0.1;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:26:29
+  --> tests/ui/excessive_precision.rs:33:29
    |
 LL |     const BAD32_EDGE: f32 = 1.000_000_9;
    |                             ^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +     const BAD32_EDGE: f32 = 1.000_001;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:31:26
+  --> tests/ui/excessive_precision.rs:38:26
    |
 LL |     const BAD64_3: f64 = 0.100_000_000_000_000_000_1;
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL +     const BAD64_3: f64 = 0.1;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:35:22
+  --> tests/ui/excessive_precision.rs:42:22
    |
 LL |     println!("{:?}", 8.888_888_888_888_888_888_888);
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL +     println!("{:?}", 8.888_888_888_888_89);
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:47:22
+  --> tests/ui/excessive_precision.rs:54:22
    |
 LL |     let bad32: f32 = 1.123_456_789;
    |                      ^^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL +     let bad32: f32 = 1.123_456_8;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:49:26
+  --> tests/ui/excessive_precision.rs:56:26
    |
 LL |     let bad32_suf: f32 = 1.123_456_789_f32;
    |                          ^^^^^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL +     let bad32_suf: f32 = 1.123_456_8_f32;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:51:21
+  --> tests/ui/excessive_precision.rs:58:21
    |
 LL |     let bad32_inf = 1.123_456_789_f32;
    |                     ^^^^^^^^^^^^^^^^^
@@ -109,7 +109,7 @@ LL +     let bad32_inf = 1.123_456_8_f32;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:62:36
+  --> tests/ui/excessive_precision.rs:69:36
    |
 LL |     let bad_vec32: Vec<f32> = vec![0.123_456_789];
    |                                    ^^^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL +     let bad_vec32: Vec<f32> = vec![0.123_456_79];
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:64:36
+  --> tests/ui/excessive_precision.rs:71:36
    |
 LL |     let bad_vec64: Vec<f64> = vec![0.123_456_789_123_456_789];
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -133,7 +133,7 @@ LL +     let bad_vec64: Vec<f64> = vec![0.123_456_789_123_456_78];
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:69:24
+  --> tests/ui/excessive_precision.rs:76:24
    |
 LL |     let bad_e32: f32 = 1.123_456_788_888e-10;
    |                        ^^^^^^^^^^^^^^^^^^^^^
@@ -145,7 +145,7 @@ LL +     let bad_e32: f32 = 1.123_456_8e-10;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:73:27
+  --> tests/ui/excessive_precision.rs:80:27
    |
 LL |     let bad_bige32: f32 = 1.123_456_788_888E-10;
    |                           ^^^^^^^^^^^^^^^^^^^^^
@@ -157,7 +157,7 @@ LL +     let bad_bige32: f32 = 1.123_456_8E-10;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:86:13
+  --> tests/ui/excessive_precision.rs:93:13
    |
 LL |     let _ = 2.225_073_858_507_201_1e-308_f64;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -169,7 +169,7 @@ LL +     let _ = 2.225_073_858_507_201e-308_f64;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:90:13
+  --> tests/ui/excessive_precision.rs:97:13
    |
 LL |     let _ = 1.000_000_000_000_001e-324_f64;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -181,7 +181,7 @@ LL +     let _ = 0_f64;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:101:20
+  --> tests/ui/excessive_precision.rs:108:20
    |
 LL |     const _: f64 = 3.0000000000000000e+00;
    |                    ^^^^^^^^^^^^^^^^^^^^^^
@@ -192,5 +192,56 @@ LL -     const _: f64 = 3.0000000000000000e+00;
 LL +     const _: f64 = 3.0;
    |
 
-error: aborting due to 16 previous errors
+error: float has excessive precision
+  --> tests/ui/excessive_precision.rs:113:18
+   |
+LL |     let _: f32 = 1.01234567890123456789012345678901234567890;
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: consider making it a `const` item
+  --> tests/ui/excessive_precision.rs:113:5
+   |
+LL |     let _: f32 = 1.01234567890123456789012345678901234567890;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: consider changing the type or truncating it to
+   |
+LL -     let _: f32 = 1.01234567890123456789012345678901234567890;
+LL +     let _: f32 = 1.012_345_7;
+   |
+
+error: float has excessive precision
+  --> tests/ui/excessive_precision.rs:115:18
+   |
+LL |     let _: f64 = 1.01234567890123456789012345678901234567890;
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: consider making it a `const` item
+  --> tests/ui/excessive_precision.rs:115:5
+   |
+LL |     let _: f64 = 1.01234567890123456789012345678901234567890;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: consider changing the type or truncating it to
+   |
+LL -     let _: f64 = 1.01234567890123456789012345678901234567890;
+LL +     let _: f64 = 1.012_345_678_901_234_6;
+   |
+
+error: float has excessive precision
+  --> tests/ui/excessive_precision.rs:127:17
+   |
+LL |     let gamma = 0.5772156649015328606065120900824024310421;
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: consider making it a `const` item
+  --> tests/ui/excessive_precision.rs:127:5
+   |
+LL |     let gamma = 0.5772156649015328606065120900824024310421;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: consider changing the type or truncating it to
+   |
+LL -     let gamma = 0.5772156649015328606065120900824024310421;
+LL +     let gamma = 0.577_215_664_901_532_9;
+   |
+
+error: aborting due to 19 previous errors
 
diff --git a/tests/ui/float_equality_without_abs.rs b/tests/ui/float_equality_without_abs.rs
index a1548db6710d1..e1dd79026839b 100644
--- a/tests/ui/float_equality_without_abs.rs
+++ b/tests/ui/float_equality_without_abs.rs
@@ -1,8 +1,8 @@
+#![feature(f128)]
+#![feature(f16)]
 #![warn(clippy::float_equality_without_abs)]
 //@no-rustfix: suggestions cause type ambiguity
 
-// FIXME(f16_f128): add tests for these types when abs is available
-
 pub fn is_roughly_equal(a: f32, b: f32) -> bool {
     (a - b) < f32::EPSILON
     //~^ float_equality_without_abs
@@ -44,10 +44,20 @@ pub fn main() {
     let _ = f32::EPSILON > 1.0 - 2.0;
     //~^ float_equality_without_abs
 
+    let _ = (a as f16 - b as f16) < f16::EPSILON;
+    //~^ float_equality_without_abs
+
+    let _ = (a as f128 - b as f128) < f128::EPSILON;
+    //~^ float_equality_without_abs
+
     // those are correct
+    let _ = (a as f16 - b as f16).abs() < f16::EPSILON;
     let _ = (a - b).abs() < f32::EPSILON;
     let _ = (a as f64 - b as f64).abs() < f64::EPSILON;
+    let _ = (a as f128 - b as f128).abs() < f128::EPSILON;
 
+    let _ = f16::EPSILON > (a as f16 - b as f16).abs();
     let _ = f32::EPSILON > (a - b).abs();
     let _ = f64::EPSILON > (a as f64 - b as f64).abs();
+    let _ = f128::EPSILON > (a as f128 - b as f128).abs();
 }
diff --git a/tests/ui/float_equality_without_abs.stderr b/tests/ui/float_equality_without_abs.stderr
index d4c89ce72ba9b..55a150dead5a4 100644
--- a/tests/ui/float_equality_without_abs.stderr
+++ b/tests/ui/float_equality_without_abs.stderr
@@ -89,5 +89,21 @@ LL |     let _ = f32::EPSILON > 1.0 - 2.0;
    |                            |
    |                            help: add `.abs()`: `(1.0 - 2.0).abs()`
 
-error: aborting due to 11 previous errors
+error: float equality check without `.abs()`
+  --> tests/ui/float_equality_without_abs.rs:47:13
+   |
+LL |     let _ = (a as f16 - b as f16) < f16::EPSILON;
+   |             ---------------------^^^^^^^^^^^^^^^
+   |             |
+   |             help: add `.abs()`: `(a as f16 - b as f16).abs()`
+
+error: float equality check without `.abs()`
+  --> tests/ui/float_equality_without_abs.rs:50:13
+   |
+LL |     let _ = (a as f128 - b as f128) < f128::EPSILON;
+   |             -----------------------^^^^^^^^^^^^^^^^
+   |             |
+   |             help: add `.abs()`: `(a as f128 - b as f128).abs()`
+
+error: aborting due to 13 previous errors
 
diff --git a/tests/ui/if_then_some_else_none.fixed b/tests/ui/if_then_some_else_none.fixed
index d14a805b66679..0fd130609aee2 100644
--- a/tests/ui/if_then_some_else_none.fixed
+++ b/tests/ui/if_then_some_else_none.fixed
@@ -165,3 +165,44 @@ mod issue15257 {
         do_something((i % 2 == 0).then_some(closure_fn));
     }
 }
+
+fn issue15005() {
+    struct Counter {
+        count: u32,
+    }
+
+    impl Counter {
+        fn new() -> Counter {
+            Counter { count: 0 }
+        }
+    }
+
+    impl Iterator for Counter {
+        type Item = u32;
+
+        fn next(&mut self) -> Option<Self::Item> {
+            //~v if_then_some_else_none
+            (self.count < 5).then(||  { self.count += 1; self.count })
+        }
+    }
+}
+
+fn statements_from_macro() {
+    macro_rules! mac {
+        () => {
+            println!("foo");
+            println!("bar");
+        };
+    }
+    //~v if_then_some_else_none
+    let _ = true.then(||  { mac!(); 42 });
+}
+
+fn dont_lint_inside_macros() {
+    macro_rules! mac {
+        ($cond:expr, $res:expr) => {
+            if $cond { Some($res) } else { None }
+        };
+    }
+    let _: Option<u32> = mac!(true, 42);
+}
diff --git a/tests/ui/if_then_some_else_none.rs b/tests/ui/if_then_some_else_none.rs
index bb0072f31573f..640828aa9bf6b 100644
--- a/tests/ui/if_then_some_else_none.rs
+++ b/tests/ui/if_then_some_else_none.rs
@@ -211,3 +211,54 @@ mod issue15257 {
         });
     }
 }
+
+fn issue15005() {
+    struct Counter {
+        count: u32,
+    }
+
+    impl Counter {
+        fn new() -> Counter {
+            Counter { count: 0 }
+        }
+    }
+
+    impl Iterator for Counter {
+        type Item = u32;
+
+        fn next(&mut self) -> Option<Self::Item> {
+            //~v if_then_some_else_none
+            if self.count < 5 {
+                self.count += 1;
+                Some(self.count)
+            } else {
+                None
+            }
+        }
+    }
+}
+
+fn statements_from_macro() {
+    macro_rules! mac {
+        () => {
+            println!("foo");
+            println!("bar");
+        };
+    }
+    //~v if_then_some_else_none
+    let _ = if true {
+        mac!();
+        Some(42)
+    } else {
+        None
+    };
+}
+
+fn dont_lint_inside_macros() {
+    macro_rules! mac {
+        ($cond:expr, $res:expr) => {
+            if $cond { Some($res) } else { None }
+        };
+    }
+    let _: Option<u32> = mac!(true, 42);
+}
diff --git a/tests/ui/if_then_some_else_none.stderr b/tests/ui/if_then_some_else_none.stderr
index c2e624a0a73b4..58651a0559424 100644
--- a/tests/ui/if_then_some_else_none.stderr
+++ b/tests/ui/if_then_some_else_none.stderr
@@ -116,5 +116,28 @@ LL | |             None
 LL | |         });
    | |_________^ help: try: `(i % 2 == 0).then_some(closure_fn)`
 
-error: aborting due to 11 previous errors
+error: this could be simplified with `bool::then`
+  --> tests/ui/if_then_some_else_none.rs:231:13
+   |
+LL | /             if self.count < 5 {
+LL | |                 self.count += 1;
+LL | |                 Some(self.count)
+LL | |             } else {
+LL | |                 None
+LL | |             }
+   | |_____________^ help: try: `(self.count < 5).then(||  { self.count += 1; self.count })`
+
+error: this could be simplified with `bool::then`
+  --> tests/ui/if_then_some_else_none.rs:249:13
+   |
+LL |       let _ = if true {
+   |  _____________^
+LL | |         mac!();
+LL | |         Some(42)
+LL | |     } else {
+LL | |         None
+LL | |     };
+   | |_____^ help: try: `true.then(||  { mac!(); 42 })`
+
+error: aborting due to 13 previous errors
 
diff --git a/tests/ui/infinite_loops.rs b/tests/ui/infinite_loops.rs
index 9b8c39331970c..7d01a7fb61fc1 100644
--- a/tests/ui/infinite_loops.rs
+++ b/tests/ui/infinite_loops.rs
@@ -521,4 +521,19 @@ mod tokio_spawn_test {
     }
 }
 
+mod issue15541 {
+    async fn good() -> ! {
+        loop {
+            std::future::pending().await
+        }
+    }
+
+    async fn bad() {
+        //~v infinite_loop
+        loop {
+            std::future::pending().await
+        }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/infinite_loops.stderr b/tests/ui/infinite_loops.stderr
index 4c6b6f725f130..319f1e5012b64 100644
--- a/tests/ui/infinite_loops.stderr
+++ b/tests/ui/infinite_loops.stderr
@@ -333,5 +333,15 @@ LL | |             }
    |
    = help: if this is not intended, try adding a `break` or `return` condition in the loop
 
-error: aborting due to 23 previous errors
+error: infinite loop detected
+  --> tests/ui/infinite_loops.rs:533:9
+   |
+LL | /         loop {
+LL | |             std::future::pending().await
+LL | |         }
+   | |_________^
+   |
+   = help: if this is not intended, try adding a `break` or `return` condition in the loop
+
+error: aborting due to 24 previous errors
 
diff --git a/tests/ui/manual_is_ascii_check.fixed b/tests/ui/manual_is_ascii_check.fixed
index 7b0d190683469..406336dbd095d 100644
--- a/tests/ui/manual_is_ascii_check.fixed
+++ b/tests/ui/manual_is_ascii_check.fixed
@@ -108,6 +108,8 @@ fn generics() {
     //~^ manual_is_ascii_check
     take_while(|c: char| c.is_ascii_uppercase());
     //~^ manual_is_ascii_check
+    take_while(|c: char| c.is_ascii_uppercase());
+    //~^ manual_is_ascii_check
 }
 
 fn adds_type_reference() {
@@ -115,4 +117,6 @@ fn adds_type_reference() {
     //~^ manual_is_ascii_check
     let digits: Vec<&mut char> = ['1', 'A'].iter_mut().take_while(|c: &&mut char| c.is_ascii_digit()).collect();
     //~^ manual_is_ascii_check
+    let digits: Vec<&mut char> = ['1', 'A'].iter_mut().take_while(|c: &&mut char| c.is_ascii_digit()).collect();
+    //~^ manual_is_ascii_check
 }
diff --git a/tests/ui/manual_is_ascii_check.rs b/tests/ui/manual_is_ascii_check.rs
index e4f7fe9f5838a..a624497e75e52 100644
--- a/tests/ui/manual_is_ascii_check.rs
+++ b/tests/ui/manual_is_ascii_check.rs
@@ -108,6 +108,8 @@ fn generics() {
     //~^ manual_is_ascii_check
     take_while(|c: char| ('A'..='Z').contains(&c));
     //~^ manual_is_ascii_check
+    take_while(|c| matches!(c, 'A'..='Z'));
+    //~^ manual_is_ascii_check
 }
 
 fn adds_type_reference() {
@@ -115,4 +117,6 @@ fn adds_type_reference() {
     //~^ manual_is_ascii_check
     let digits: Vec<&mut char> = ['1', 'A'].iter_mut().take_while(|c| ('0'..='9').contains(c)).collect();
     //~^ manual_is_ascii_check
+    let digits: Vec<&mut char> = ['1', 'A'].iter_mut().take_while(|c| matches!(c, '0'..='9')).collect();
+    //~^ manual_is_ascii_check
 }
diff --git a/tests/ui/manual_is_ascii_check.stderr b/tests/ui/manual_is_ascii_check.stderr
index 9fd7f457b4201..cb2548ea73160 100644
--- a/tests/ui/manual_is_ascii_check.stderr
+++ b/tests/ui/manual_is_ascii_check.stderr
@@ -176,7 +176,19 @@ LL |     take_while(|c: char| ('A'..='Z').contains(&c));
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `c.is_ascii_uppercase()`
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:114:63
+  --> tests/ui/manual_is_ascii_check.rs:111:20
+   |
+LL |     take_while(|c| matches!(c, 'A'..='Z'));
+   |                    ^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -     take_while(|c| matches!(c, 'A'..='Z'));
+LL +     take_while(|c: char| c.is_ascii_uppercase());
+   |
+
+error: manual check for common ascii range
+  --> tests/ui/manual_is_ascii_check.rs:116:63
    |
 LL |     let digits: Vec<&char> = ['1', 'A'].iter().take_while(|c| ('0'..='9').contains(c)).collect();
    |                                                               ^^^^^^^^^^^^^^^^^^^^^^^
@@ -188,7 +200,7 @@ LL +     let digits: Vec<&char> = ['1', 'A'].iter().take_while(|c: &&char| c.is_
    |
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:116:71
+  --> tests/ui/manual_is_ascii_check.rs:118:71
    |
 LL |     let digits: Vec<&mut char> = ['1', 'A'].iter_mut().take_while(|c| ('0'..='9').contains(c)).collect();
    |                                                                       ^^^^^^^^^^^^^^^^^^^^^^^
@@ -199,5 +211,17 @@ LL -     let digits: Vec<&mut char> = ['1', 'A'].iter_mut().take_while(|c| ('0'.
 LL +     let digits: Vec<&mut char> = ['1', 'A'].iter_mut().take_while(|c: &&mut char| c.is_ascii_digit()).collect();
    |
 
-error: aborting due to 29 previous errors
+error: manual check for common ascii range
+  --> tests/ui/manual_is_ascii_check.rs:120:71
+   |
+LL |     let digits: Vec<&mut char> = ['1', 'A'].iter_mut().take_while(|c| matches!(c, '0'..='9')).collect();
+   |                                                                       ^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -     let digits: Vec<&mut char> = ['1', 'A'].iter_mut().take_while(|c| matches!(c, '0'..='9')).collect();
+LL +     let digits: Vec<&mut char> = ['1', 'A'].iter_mut().take_while(|c: &&mut char| c.is_ascii_digit()).collect();
+   |
+
+error: aborting due to 31 previous errors
 
diff --git a/tests/ui/map_identity.fixed b/tests/ui/map_identity.fixed
index 6c971ba633848..a10aae8cc1217 100644
--- a/tests/ui/map_identity.fixed
+++ b/tests/ui/map_identity.fixed
@@ -1,3 +1,4 @@
+//@require-annotations-for-level: ERROR
 #![warn(clippy::map_identity)]
 #![allow(clippy::needless_return, clippy::disallowed_names)]
 
@@ -72,20 +73,33 @@ fn issue11764() {
 }
 
 fn issue13904() {
-    // don't lint: `it.next()` would not be legal as `it` is immutable
-    let it = [1, 2, 3].into_iter();
-    let _ = it.map(|x| x).next();
+    // lint, but there's a catch:
+    // when we remove the `.map()`, `it.next()` would require `it` to be mutable
+    // therefore, include that in the suggestion as well
+    let mut it = [1, 2, 3].into_iter();
+    let _ = it.next();
+    //~^ map_identity
+    //~| HELP: remove the call to `map`, and make `it` mutable
+
+    // lint
+    let mut index = [1, 2, 3].into_iter();
+    let mut subindex = (index.by_ref().take(3), 42);
+    let _ = subindex.0.next();
+    //~^ map_identity
+    //~| HELP: remove the call to `map`, and make `subindex` mutable
 
     // lint
     #[allow(unused_mut)]
     let mut it = [1, 2, 3].into_iter();
     let _ = it.next();
     //~^ map_identity
+    //~| HELP: remove the call to `map`
 
     // lint
     let it = [1, 2, 3].into_iter();
     let _ = { it }.next();
     //~^ map_identity
+    //~| HELP: remove the call to `map`
 }
 
 // same as `issue11764`, but for arrays
diff --git a/tests/ui/map_identity.rs b/tests/ui/map_identity.rs
index 59dcfcda3b6e6..fc6e018f92484 100644
--- a/tests/ui/map_identity.rs
+++ b/tests/ui/map_identity.rs
@@ -1,3 +1,4 @@
+//@require-annotations-for-level: ERROR
 #![warn(clippy::map_identity)]
 #![allow(clippy::needless_return, clippy::disallowed_names)]
 
@@ -78,20 +79,33 @@ fn issue11764() {
 }
 
 fn issue13904() {
-    // don't lint: `it.next()` would not be legal as `it` is immutable
+    // lint, but there's a catch:
+    // when we remove the `.map()`, `it.next()` would require `it` to be mutable
+    // therefore, include that in the suggestion as well
     let it = [1, 2, 3].into_iter();
     let _ = it.map(|x| x).next();
+    //~^ map_identity
+    //~| HELP: remove the call to `map`, and make `it` mutable
+
+    // lint
+    let mut index = [1, 2, 3].into_iter();
+    let subindex = (index.by_ref().take(3), 42);
+    let _ = subindex.0.map(|n| n).next();
+    //~^ map_identity
+    //~| HELP: remove the call to `map`, and make `subindex` mutable
 
     // lint
     #[allow(unused_mut)]
     let mut it = [1, 2, 3].into_iter();
     let _ = it.map(|x| x).next();
     //~^ map_identity
+    //~| HELP: remove the call to `map`
 
     // lint
     let it = [1, 2, 3].into_iter();
     let _ = { it }.map(|x| x).next();
     //~^ map_identity
+    //~| HELP: remove the call to `map`
 }
 
 // same as `issue11764`, but for arrays
diff --git a/tests/ui/map_identity.stderr b/tests/ui/map_identity.stderr
index a50c0d6b87b53..8d19d62cdc641 100644
--- a/tests/ui/map_identity.stderr
+++ b/tests/ui/map_identity.stderr
@@ -1,5 +1,5 @@
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:7:47
+  --> tests/ui/map_identity.rs:8:47
    |
 LL |     let _: Vec<_> = x.iter().map(not_identity).map(|x| return x).collect();
    |                                               ^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
@@ -8,25 +8,25 @@ LL |     let _: Vec<_> = x.iter().map(not_identity).map(|x| return x).collect();
    = help: to override `-D warnings` add `#[allow(clippy::map_identity)]`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:9:57
+  --> tests/ui/map_identity.rs:10:57
    |
 LL |     let _: Vec<_> = x.iter().map(std::convert::identity).map(|y| y).collect();
    |                                                         ^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:9:29
+  --> tests/ui/map_identity.rs:10:29
    |
 LL |     let _: Vec<_> = x.iter().map(std::convert::identity).map(|y| y).collect();
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:12:32
+  --> tests/ui/map_identity.rs:13:32
    |
 LL |     let _: Option<u8> = Some(3).map(|x| x);
    |                                ^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:14:36
+  --> tests/ui/map_identity.rs:15:36
    |
 LL |       let _: Result<i8, f32> = Ok(-3).map(|x| {
    |  ____________________________________^
@@ -36,19 +36,19 @@ LL | |     });
    | |______^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:25:36
+  --> tests/ui/map_identity.rs:26:36
    |
 LL |     let _: Result<u32, u32> = Ok(1).map_err(|a| a);
    |                                    ^^^^^^^^^^^^^^^ help: remove the call to `map_err`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:36:22
+  --> tests/ui/map_identity.rs:37:22
    |
 LL |     let _ = x.clone().map(|(x, y)| (x, y));
    |                      ^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:38:22
+  --> tests/ui/map_identity.rs:39:22
    |
 LL |       let _ = x.clone().map(|(x, y)| {
    |  ______________________^
@@ -58,76 +58,100 @@ LL | |     });
    | |______^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:42:22
+  --> tests/ui/map_identity.rs:43:22
    |
 LL |     let _ = x.clone().map(|(x, y)| return (x, y));
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:46:22
+  --> tests/ui/map_identity.rs:47:22
    |
 LL |     let _ = y.clone().map(|(x, y, (z, (w,)))| (x, y, (z, (w,))));
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:76:30
+  --> tests/ui/map_identity.rs:77:30
    |
 LL |     let _ = x.iter().copied().map(|(x, y)| (x, y));
    |                              ^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:88:15
+  --> tests/ui/map_identity.rs:86:15
+   |
+LL |     let _ = it.map(|x| x).next();
+   |               ^^^^^^^^^^^
+   |
+help: remove the call to `map`, and make `it` mutable
+   |
+LL ~     let mut it = [1, 2, 3].into_iter();
+LL ~     let _ = it.next();
+   |
+
+error: unnecessary map of the identity function
+  --> tests/ui/map_identity.rs:93:23
+   |
+LL |     let _ = subindex.0.map(|n| n).next();
+   |                       ^^^^^^^^^^^
+   |
+help: remove the call to `map`, and make `subindex` mutable
+   |
+LL ~     let mut subindex = (index.by_ref().take(3), 42);
+LL ~     let _ = subindex.0.next();
+   |
+
+error: unnecessary map of the identity function
+  --> tests/ui/map_identity.rs:100:15
    |
 LL |     let _ = it.map(|x| x).next();
    |               ^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:93:19
+  --> tests/ui/map_identity.rs:106:19
    |
 LL |     let _ = { it }.map(|x| x).next();
    |                   ^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:105:30
+  --> tests/ui/map_identity.rs:119:30
    |
 LL |     let _ = x.iter().copied().map(|[x, y]| [x, y]);
    |                              ^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:131:26
+  --> tests/ui/map_identity.rs:145:26
    |
 LL |     let _ = x.into_iter().map(|Foo { foo, bar }| Foo { foo, bar });
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:135:26
+  --> tests/ui/map_identity.rs:149:26
    |
 LL |     let _ = x.into_iter().map(|Foo { foo, bar }| foo::Foo { foo, bar });
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:143:26
+  --> tests/ui/map_identity.rs:157:26
    |
 LL |     let _ = x.into_iter().map(|Foo { foo, bar }| Foo { foo: foo, bar: bar });
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:147:26
+  --> tests/ui/map_identity.rs:161:26
    |
 LL |     let _ = x.into_iter().map(|Foo { foo, bar }| Foo { bar, foo });
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:157:26
+  --> tests/ui/map_identity.rs:171:26
    |
 LL |     let _ = x.into_iter().map(|Foo2(foo, bar)| Foo2(foo, bar));
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:161:26
+  --> tests/ui/map_identity.rs:175:26
    |
 LL |     let _ = x.into_iter().map(|Foo2(foo, bar)| foo::Foo2(foo, bar));
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
-error: aborting due to 20 previous errors
+error: aborting due to 22 previous errors
 
diff --git a/tests/ui/missing_inline.rs b/tests/ui/missing_inline.rs
index 223c7447975aa..8e937d609512a 100644
--- a/tests/ui/missing_inline.rs
+++ b/tests/ui/missing_inline.rs
@@ -97,3 +97,10 @@ pub mod issue15301 {
         println!("Just called a Rust function from Rust!");
     }
 }
+
+pub mod issue15491 {
+    pub trait Foo {
+        #[allow(clippy::missing_inline_in_public_items)]
+        fn foo(&self) {}
+    }
+}
diff --git a/tests/ui/missing_transmute_annotations_unfixable.rs b/tests/ui/missing_transmute_annotations_unfixable.rs
new file mode 100644
index 0000000000000..08ba3b791ee76
--- /dev/null
+++ b/tests/ui/missing_transmute_annotations_unfixable.rs
@@ -0,0 +1,29 @@
+//@no-rustfix
+
+fn issue14984() {
+    async fn e() {}
+    async fn x() -> u32 {
+        0
+    }
+    async fn y() -> f32 {
+        0.0
+    };
+    let mut yy = unsafe { std::ptr::read(&y()) };
+    yy = unsafe { std::mem::transmute(std::ptr::read(&x())) };
+    //~^ missing_transmute_annotations
+
+    let mut zz = 0u8;
+    zz = unsafe { std::mem::transmute(std::ptr::read(&x())) };
+    //~^ missing_transmute_annotations
+
+    yy = unsafe { std::mem::transmute(zz) };
+    //~^ missing_transmute_annotations
+
+    fn a() -> impl Sized {
+        0u32
+    }
+
+    let mut b: f32 = 0.0;
+    b = unsafe { std::mem::transmute(a()) };
+    //~^ missing_transmute_annotations
+}
diff --git a/tests/ui/missing_transmute_annotations_unfixable.stderr b/tests/ui/missing_transmute_annotations_unfixable.stderr
new file mode 100644
index 0000000000000..83efdce13f7e7
--- /dev/null
+++ b/tests/ui/missing_transmute_annotations_unfixable.stderr
@@ -0,0 +1,36 @@
+error: transmute used without annotations
+  --> tests/ui/missing_transmute_annotations_unfixable.rs:12:29
+   |
+LL |     yy = unsafe { std::mem::transmute(std::ptr::read(&x())) };
+   |                             ^^^^^^^^^
+   |
+   = help: consider giving the source and destination types a name, and adding missing type annotations
+   = note: `-D clippy::missing-transmute-annotations` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::missing_transmute_annotations)]`
+
+error: transmute used without annotations
+  --> tests/ui/missing_transmute_annotations_unfixable.rs:16:29
+   |
+LL |     zz = unsafe { std::mem::transmute(std::ptr::read(&x())) };
+   |                             ^^^^^^^^^
+   |
+   = help: consider giving the origin type a name, and adding missing type annotations
+
+error: transmute used without annotations
+  --> tests/ui/missing_transmute_annotations_unfixable.rs:19:29
+   |
+LL |     yy = unsafe { std::mem::transmute(zz) };
+   |                             ^^^^^^^^^
+   |
+   = help: consider giving the destination type a name, and adding missing type annotations
+
+error: transmute used without annotations
+  --> tests/ui/missing_transmute_annotations_unfixable.rs:27:28
+   |
+LL |     b = unsafe { std::mem::transmute(a()) };
+   |                            ^^^^^^^^^
+   |
+   = help: consider giving `a()`'s type a name, and adding missing type annotations
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/mut_reference.fixed b/tests/ui/mut_reference.fixed
new file mode 100644
index 0000000000000..03d854099e644
--- /dev/null
+++ b/tests/ui/mut_reference.fixed
@@ -0,0 +1,170 @@
+#![allow(clippy::mut_mut)]
+
+fn takes_ref(a: &i32) {}
+fn takes_refmut(a: &mut i32) {}
+fn takes_ref_ref(a: &&i32) {}
+fn takes_refmut_ref(a: &mut &i32) {}
+fn takes_ref_refmut(a: &&mut i32) {}
+fn takes_refmut_refmut(a: &mut &mut i32) {}
+fn takes_raw_const(a: *const i32) {}
+fn takes_raw_mut(a: *mut i32) {}
+
+mod issue11268 {
+    macro_rules! x {
+        (1 $f:expr) => {
+            $f(&mut 1);
+        };
+        (2 $f:expr) => {
+            $f(&mut &1)
+        };
+        (3 $f:expr) => {
+            $f(&mut &mut 1)
+        };
+        (4 $f:expr) => {
+            let mut a = 1;
+            $f(&raw mut a)
+        };
+    }
+
+    fn f() {
+        x!(1 super::takes_ref);
+        x!(1 super::takes_refmut);
+        x!(2 super::takes_refmut_ref);
+        x!(3 super::takes_ref_refmut);
+        x!(3 super::takes_refmut_refmut);
+        x!(4 super::takes_raw_const);
+        x!(4 super::takes_raw_mut);
+    }
+}
+
+struct MyStruct;
+
+impl MyStruct {
+    fn takes_ref(&self, a: &i32) {}
+    fn takes_refmut(&self, a: &mut i32) {}
+    fn takes_ref_ref(&self, a: &&i32) {}
+    fn takes_refmut_ref(&self, a: &mut &i32) {}
+    fn takes_ref_refmut(&self, a: &&mut i32) {}
+    fn takes_refmut_refmut(&self, a: &mut &mut i32) {}
+    fn takes_raw_const(&self, a: *const i32) {}
+    fn takes_raw_mut(&self, a: *mut i32) {}
+}
+
+#[warn(clippy::unnecessary_mut_passed)]
+fn main() {
+    // Functions
+    takes_ref(&42);
+    //~^ unnecessary_mut_passed
+    takes_ref_ref(&&42);
+    //~^ unnecessary_mut_passed
+    takes_ref_refmut(&&mut 42);
+    //~^ unnecessary_mut_passed
+    takes_raw_const(&42);
+    //~^ unnecessary_mut_passed
+
+    let as_ptr: fn(&i32) = takes_ref;
+    as_ptr(&42);
+    //~^ unnecessary_mut_passed
+    let as_ptr: fn(&&i32) = takes_ref_ref;
+    as_ptr(&&42);
+    //~^ unnecessary_mut_passed
+    let as_ptr: fn(&&mut i32) = takes_ref_refmut;
+    as_ptr(&&mut 42);
+    //~^ unnecessary_mut_passed
+    let as_ptr: fn(*const i32) = takes_raw_const;
+    as_ptr(&42);
+    //~^ unnecessary_mut_passed
+
+    // Methods
+    let my_struct = MyStruct;
+    my_struct.takes_ref(&42);
+    //~^ unnecessary_mut_passed
+    my_struct.takes_ref_ref(&&42);
+    //~^ unnecessary_mut_passed
+    my_struct.takes_ref_refmut(&&mut 42);
+    //~^ unnecessary_mut_passed
+    my_struct.takes_raw_const(&42);
+    //~^ unnecessary_mut_passed
+
+    // No error
+
+    // Functions
+    takes_ref(&42);
+    let as_ptr: fn(&i32) = takes_ref;
+    as_ptr(&42);
+
+    takes_refmut(&mut 42);
+    let as_ptr: fn(&mut i32) = takes_refmut;
+    as_ptr(&mut 42);
+
+    takes_ref_ref(&&42);
+    let as_ptr: fn(&&i32) = takes_ref_ref;
+    as_ptr(&&42);
+
+    takes_refmut_ref(&mut &42);
+    let as_ptr: fn(&mut &i32) = takes_refmut_ref;
+    as_ptr(&mut &42);
+
+    takes_ref_refmut(&&mut 42);
+    let as_ptr: fn(&&mut i32) = takes_ref_refmut;
+    as_ptr(&&mut 42);
+
+    takes_refmut_refmut(&mut &mut 42);
+    let as_ptr: fn(&mut &mut i32) = takes_refmut_refmut;
+    as_ptr(&mut &mut 42);
+
+    takes_raw_const(&42);
+    let as_ptr: fn(*const i32) = takes_raw_const;
+    as_ptr(&42);
+
+    takes_raw_mut(&mut 42);
+    let as_ptr: fn(*mut i32) = takes_raw_mut;
+    as_ptr(&mut 42);
+
+    let a = &mut 42;
+    let b = &mut &42;
+    let c = &mut &mut 42;
+    takes_ref(a);
+    takes_ref_ref(b);
+    takes_ref_refmut(c);
+    takes_raw_const(a);
+
+    // Methods
+    my_struct.takes_ref(&42);
+    my_struct.takes_refmut(&mut 42);
+    my_struct.takes_ref_ref(&&42);
+    my_struct.takes_refmut_ref(&mut &42);
+    my_struct.takes_ref_refmut(&&mut 42);
+    my_struct.takes_refmut_refmut(&mut &mut 42);
+    my_struct.takes_raw_const(&42);
+    my_struct.takes_raw_mut(&mut 42);
+    my_struct.takes_ref(a);
+    my_struct.takes_ref_ref(b);
+    my_struct.takes_ref_refmut(c);
+    my_struct.takes_raw_const(a);
+    my_struct.takes_raw_mut(a);
+}
+
+// not supported currently
+fn raw_ptrs(my_struct: MyStruct) {
+    let mut n = 42;
+
+    takes_raw_const(&raw mut n);
+
+    let as_ptr: fn(*const i32) = takes_raw_const;
+    as_ptr(&raw mut n);
+
+    my_struct.takes_raw_const(&raw mut n);
+
+    // No error
+
+    takes_raw_const(&raw const n);
+    takes_raw_mut(&raw mut n);
+
+    let a = &raw mut n;
+    takes_raw_const(a);
+
+    my_struct.takes_raw_const(&raw const n);
+    my_struct.takes_raw_mut(&raw mut n);
+    my_struct.takes_raw_const(a);
+}
diff --git a/tests/ui/mut_reference.rs b/tests/ui/mut_reference.rs
index f664c373cdc3a..80e3f50692770 100644
--- a/tests/ui/mut_reference.rs
+++ b/tests/ui/mut_reference.rs
@@ -1,60 +1,170 @@
-#![allow(unused_variables, dead_code)]
-//@no-rustfix
-fn takes_an_immutable_reference(a: &i32) {}
-fn takes_a_mutable_reference(a: &mut i32) {}
+#![allow(clippy::mut_mut)]
+
+fn takes_ref(a: &i32) {}
+fn takes_refmut(a: &mut i32) {}
+fn takes_ref_ref(a: &&i32) {}
+fn takes_refmut_ref(a: &mut &i32) {}
+fn takes_ref_refmut(a: &&mut i32) {}
+fn takes_refmut_refmut(a: &mut &mut i32) {}
+fn takes_raw_const(a: *const i32) {}
+fn takes_raw_mut(a: *mut i32) {}
 
 mod issue11268 {
     macro_rules! x {
-        ($f:expr) => {
+        (1 $f:expr) => {
             $f(&mut 1);
         };
+        (2 $f:expr) => {
+            $f(&mut &1)
+        };
+        (3 $f:expr) => {
+            $f(&mut &mut 1)
+        };
+        (4 $f:expr) => {
+            let mut a = 1;
+            $f(&raw mut a)
+        };
     }
 
     fn f() {
-        x!(super::takes_an_immutable_reference);
-        x!(super::takes_a_mutable_reference);
+        x!(1 super::takes_ref);
+        x!(1 super::takes_refmut);
+        x!(2 super::takes_refmut_ref);
+        x!(3 super::takes_ref_refmut);
+        x!(3 super::takes_refmut_refmut);
+        x!(4 super::takes_raw_const);
+        x!(4 super::takes_raw_mut);
     }
 }
 
 struct MyStruct;
 
 impl MyStruct {
-    fn takes_an_immutable_reference(&self, a: &i32) {}
-
-    fn takes_a_mutable_reference(&self, a: &mut i32) {}
+    fn takes_ref(&self, a: &i32) {}
+    fn takes_refmut(&self, a: &mut i32) {}
+    fn takes_ref_ref(&self, a: &&i32) {}
+    fn takes_refmut_ref(&self, a: &mut &i32) {}
+    fn takes_ref_refmut(&self, a: &&mut i32) {}
+    fn takes_refmut_refmut(&self, a: &mut &mut i32) {}
+    fn takes_raw_const(&self, a: *const i32) {}
+    fn takes_raw_mut(&self, a: *mut i32) {}
 }
 
 #[warn(clippy::unnecessary_mut_passed)]
 fn main() {
     // Functions
-    takes_an_immutable_reference(&mut 42);
+    takes_ref(&mut 42);
+    //~^ unnecessary_mut_passed
+    takes_ref_ref(&mut &42);
+    //~^ unnecessary_mut_passed
+    takes_ref_refmut(&mut &mut 42);
+    //~^ unnecessary_mut_passed
+    takes_raw_const(&mut 42);
     //~^ unnecessary_mut_passed
 
-    let as_ptr: fn(&i32) = takes_an_immutable_reference;
+    let as_ptr: fn(&i32) = takes_ref;
+    as_ptr(&mut 42);
+    //~^ unnecessary_mut_passed
+    let as_ptr: fn(&&i32) = takes_ref_ref;
+    as_ptr(&mut &42);
+    //~^ unnecessary_mut_passed
+    let as_ptr: fn(&&mut i32) = takes_ref_refmut;
+    as_ptr(&mut &mut 42);
+    //~^ unnecessary_mut_passed
+    let as_ptr: fn(*const i32) = takes_raw_const;
     as_ptr(&mut 42);
     //~^ unnecessary_mut_passed
 
     // Methods
     let my_struct = MyStruct;
-    my_struct.takes_an_immutable_reference(&mut 42);
+    my_struct.takes_ref(&mut 42);
+    //~^ unnecessary_mut_passed
+    my_struct.takes_ref_ref(&mut &42);
+    //~^ unnecessary_mut_passed
+    my_struct.takes_ref_refmut(&mut &mut 42);
+    //~^ unnecessary_mut_passed
+    my_struct.takes_raw_const(&mut 42);
     //~^ unnecessary_mut_passed
 
     // No error
 
     // Functions
-    takes_an_immutable_reference(&42);
-    let as_ptr: fn(&i32) = takes_an_immutable_reference;
+    takes_ref(&42);
+    let as_ptr: fn(&i32) = takes_ref;
     as_ptr(&42);
 
-    takes_a_mutable_reference(&mut 42);
-    let as_ptr: fn(&mut i32) = takes_a_mutable_reference;
+    takes_refmut(&mut 42);
+    let as_ptr: fn(&mut i32) = takes_refmut;
+    as_ptr(&mut 42);
+
+    takes_ref_ref(&&42);
+    let as_ptr: fn(&&i32) = takes_ref_ref;
+    as_ptr(&&42);
+
+    takes_refmut_ref(&mut &42);
+    let as_ptr: fn(&mut &i32) = takes_refmut_ref;
+    as_ptr(&mut &42);
+
+    takes_ref_refmut(&&mut 42);
+    let as_ptr: fn(&&mut i32) = takes_ref_refmut;
+    as_ptr(&&mut 42);
+
+    takes_refmut_refmut(&mut &mut 42);
+    let as_ptr: fn(&mut &mut i32) = takes_refmut_refmut;
+    as_ptr(&mut &mut 42);
+
+    takes_raw_const(&42);
+    let as_ptr: fn(*const i32) = takes_raw_const;
+    as_ptr(&42);
+
+    takes_raw_mut(&mut 42);
+    let as_ptr: fn(*mut i32) = takes_raw_mut;
     as_ptr(&mut 42);
 
     let a = &mut 42;
-    takes_an_immutable_reference(a);
+    let b = &mut &42;
+    let c = &mut &mut 42;
+    takes_ref(a);
+    takes_ref_ref(b);
+    takes_ref_refmut(c);
+    takes_raw_const(a);
 
     // Methods
-    my_struct.takes_an_immutable_reference(&42);
-    my_struct.takes_a_mutable_reference(&mut 42);
-    my_struct.takes_an_immutable_reference(a);
+    my_struct.takes_ref(&42);
+    my_struct.takes_refmut(&mut 42);
+    my_struct.takes_ref_ref(&&42);
+    my_struct.takes_refmut_ref(&mut &42);
+    my_struct.takes_ref_refmut(&&mut 42);
+    my_struct.takes_refmut_refmut(&mut &mut 42);
+    my_struct.takes_raw_const(&42);
+    my_struct.takes_raw_mut(&mut 42);
+    my_struct.takes_ref(a);
+    my_struct.takes_ref_ref(b);
+    my_struct.takes_ref_refmut(c);
+    my_struct.takes_raw_const(a);
+    my_struct.takes_raw_mut(a);
+}
+
+// not supported currently
+fn raw_ptrs(my_struct: MyStruct) {
+    let mut n = 42;
+
+    takes_raw_const(&raw mut n);
+
+    let as_ptr: fn(*const i32) = takes_raw_const;
+    as_ptr(&raw mut n);
+
+    my_struct.takes_raw_const(&raw mut n);
+
+    // No error
+
+    takes_raw_const(&raw const n);
+    takes_raw_mut(&raw mut n);
+
+    let a = &raw mut n;
+    takes_raw_const(a);
+
+    my_struct.takes_raw_const(&raw const n);
+    my_struct.takes_raw_mut(&raw mut n);
+    my_struct.takes_raw_const(a);
 }
diff --git a/tests/ui/mut_reference.stderr b/tests/ui/mut_reference.stderr
index 474221329c258..5ecfaa37416ba 100644
--- a/tests/ui/mut_reference.stderr
+++ b/tests/ui/mut_reference.stderr
@@ -1,23 +1,77 @@
-error: the function `takes_an_immutable_reference` doesn't need a mutable reference
-  --> tests/ui/mut_reference.rs:30:34
+error: the function `takes_ref` doesn't need a mutable reference
+  --> tests/ui/mut_reference.rs:56:15
    |
-LL |     takes_an_immutable_reference(&mut 42);
-   |                                  ^^^^^^^
+LL |     takes_ref(&mut 42);
+   |               ^^^^^^^ help: remove this `mut`: `&42`
    |
    = note: `-D clippy::unnecessary-mut-passed` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_mut_passed)]`
 
+error: the function `takes_ref_ref` doesn't need a mutable reference
+  --> tests/ui/mut_reference.rs:58:19
+   |
+LL |     takes_ref_ref(&mut &42);
+   |                   ^^^^^^^^ help: remove this `mut`: `&&42`
+
+error: the function `takes_ref_refmut` doesn't need a mutable reference
+  --> tests/ui/mut_reference.rs:60:22
+   |
+LL |     takes_ref_refmut(&mut &mut 42);
+   |                      ^^^^^^^^^^^^ help: remove this `mut`: `&&mut 42`
+
+error: the function `takes_raw_const` doesn't need a mutable reference
+  --> tests/ui/mut_reference.rs:62:21
+   |
+LL |     takes_raw_const(&mut 42);
+   |                     ^^^^^^^ help: remove this `mut`: `&42`
+
+error: the function `as_ptr` doesn't need a mutable reference
+  --> tests/ui/mut_reference.rs:66:12
+   |
+LL |     as_ptr(&mut 42);
+   |            ^^^^^^^ help: remove this `mut`: `&42`
+
+error: the function `as_ptr` doesn't need a mutable reference
+  --> tests/ui/mut_reference.rs:69:12
+   |
+LL |     as_ptr(&mut &42);
+   |            ^^^^^^^^ help: remove this `mut`: `&&42`
+
+error: the function `as_ptr` doesn't need a mutable reference
+  --> tests/ui/mut_reference.rs:72:12
+   |
+LL |     as_ptr(&mut &mut 42);
+   |            ^^^^^^^^^^^^ help: remove this `mut`: `&&mut 42`
+
 error: the function `as_ptr` doesn't need a mutable reference
-  --> tests/ui/mut_reference.rs:34:12
+  --> tests/ui/mut_reference.rs:75:12
    |
 LL |     as_ptr(&mut 42);
-   |            ^^^^^^^
+   |            ^^^^^^^ help: remove this `mut`: `&42`
+
+error: the method `takes_ref` doesn't need a mutable reference
+  --> tests/ui/mut_reference.rs:80:25
+   |
+LL |     my_struct.takes_ref(&mut 42);
+   |                         ^^^^^^^ help: remove this `mut`: `&42`
+
+error: the method `takes_ref_ref` doesn't need a mutable reference
+  --> tests/ui/mut_reference.rs:82:29
+   |
+LL |     my_struct.takes_ref_ref(&mut &42);
+   |                             ^^^^^^^^ help: remove this `mut`: `&&42`
+
+error: the method `takes_ref_refmut` doesn't need a mutable reference
+  --> tests/ui/mut_reference.rs:84:32
+   |
+LL |     my_struct.takes_ref_refmut(&mut &mut 42);
+   |                                ^^^^^^^^^^^^ help: remove this `mut`: `&&mut 42`
 
-error: the method `takes_an_immutable_reference` doesn't need a mutable reference
-  --> tests/ui/mut_reference.rs:39:44
+error: the method `takes_raw_const` doesn't need a mutable reference
+  --> tests/ui/mut_reference.rs:86:31
    |
-LL |     my_struct.takes_an_immutable_reference(&mut 42);
-   |                                            ^^^^^^^
+LL |     my_struct.takes_raw_const(&mut 42);
+   |                               ^^^^^^^ help: remove this `mut`: `&42`
 
-error: aborting due to 3 previous errors
+error: aborting due to 12 previous errors
 
diff --git a/tests/ui/needless_bool/fixable.stderr b/tests/ui/needless_bool/fixable.stderr
index 3f117ee5a5021..9404d07ba0e08 100644
--- a/tests/ui/needless_bool/fixable.stderr
+++ b/tests/ui/needless_bool/fixable.stderr
@@ -135,7 +135,7 @@ error: equality checks against true are unnecessary
   --> tests/ui/needless_bool/fixable.rs:157:8
    |
 LL |     if x == true {};
-   |        ^^^^^^^^^ help: try simplifying it as shown: `x`
+   |        ^^^^^^^^^ help: try: `x`
    |
    = note: `-D clippy::bool-comparison` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::bool_comparison)]`
@@ -144,19 +144,19 @@ error: equality checks against false can be replaced by a negation
   --> tests/ui/needless_bool/fixable.rs:162:8
    |
 LL |     if x == false {};
-   |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
+   |        ^^^^^^^^^^ help: try: `!x`
 
 error: equality checks against true are unnecessary
   --> tests/ui/needless_bool/fixable.rs:173:8
    |
 LL |     if x == true {};
-   |        ^^^^^^^^^ help: try simplifying it as shown: `x`
+   |        ^^^^^^^^^ help: try: `x`
 
 error: equality checks against false can be replaced by a negation
   --> tests/ui/needless_bool/fixable.rs:175:8
    |
 LL |     if x == false {};
-   |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
+   |        ^^^^^^^^^^ help: try: `!x`
 
 error: this if-then-else expression returns a bool literal
   --> tests/ui/needless_bool/fixable.rs:185:12
diff --git a/tests/ui/needless_for_each_unfixable.rs b/tests/ui/needless_for_each_unfixable.rs
index 159cbe49828f6..24ce5786b9104 100644
--- a/tests/ui/needless_for_each_unfixable.rs
+++ b/tests/ui/needless_for_each_unfixable.rs
@@ -1,6 +1,6 @@
 //@no-rustfix: overlapping suggestions
 #![warn(clippy::needless_for_each)]
-#![allow(clippy::needless_return, clippy::uninlined_format_args)]
+#![allow(clippy::needless_return)]
 
 fn main() {
     let v: Vec<i32> = Vec::new();
@@ -11,7 +11,22 @@ fn main() {
         if *v == 10 {
             return;
         } else {
-            println!("{}", v);
+            println!("{v}");
         }
     });
 }
+
+fn issue9912() {
+    let mut i = 0;
+    // Changing this to a `for` loop would break type inference
+    [].iter().for_each(move |_: &i32| {
+        //~^ needless_for_each
+        i += 1;
+    });
+
+    // Changing this would actually be okay, but we still suggest `MaybeIncorrect`ly
+    [1i32].iter().for_each(move |_: &i32| {
+        //~^ needless_for_each
+        i += 1;
+    });
+}
diff --git a/tests/ui/needless_for_each_unfixable.stderr b/tests/ui/needless_for_each_unfixable.stderr
index 3a3a240c5a3ab..6bc56db68a0ec 100644
--- a/tests/ui/needless_for_each_unfixable.stderr
+++ b/tests/ui/needless_for_each_unfixable.stderr
@@ -19,7 +19,7 @@ LL +
 LL +         if *v == 10 {
 LL +             return;
 LL +         } else {
-LL +             println!("{}", v);
+LL +             println!("{v}");
 LL +         }
 LL +     }
    |
@@ -29,5 +29,39 @@ LL -             return;
 LL +             continue;
    |
 
-error: aborting due to 1 previous error
+error: needless use of `for_each`
+  --> tests/ui/needless_for_each_unfixable.rs:22:5
+   |
+LL | /     [].iter().for_each(move |_: &i32| {
+LL | |
+LL | |         i += 1;
+LL | |     });
+   | |_______^
+   |
+help: try
+   |
+LL ~     for _ in [].iter() {
+LL +
+LL +         i += 1;
+LL +     }
+   |
+
+error: needless use of `for_each`
+  --> tests/ui/needless_for_each_unfixable.rs:28:5
+   |
+LL | /     [1i32].iter().for_each(move |_: &i32| {
+LL | |
+LL | |         i += 1;
+LL | |     });
+   | |_______^
+   |
+help: try
+   |
+LL ~     for _ in [1i32].iter() {
+LL +
+LL +         i += 1;
+LL +     }
+   |
+
+error: aborting due to 3 previous errors
 
diff --git a/tests/ui/needless_range_loop.rs b/tests/ui/needless_range_loop.rs
index 70cf9fa7369ff..ea4591d8b71ac 100644
--- a/tests/ui/needless_range_loop.rs
+++ b/tests/ui/needless_range_loop.rs
@@ -210,3 +210,35 @@ fn needless_loop() {
         black_box([1, 2, 3, 4, 5, 6, 7, 8][i]);
     }
 }
+
+fn issue_15068() {
+    let a = vec![vec![0u8; MAX_LEN]; MAX_LEN];
+    let b = vec![0u8; MAX_LEN];
+
+    for i in 0..MAX_LEN {
+        // no error
+        let _ = a[0][i];
+        let _ = b[i];
+    }
+
+    for i in 0..MAX_LEN {
+        // no error
+        let _ = a[i][0];
+        let _ = b[i];
+    }
+
+    for i in 0..MAX_LEN {
+        // no error
+        let _ = a[i][b[i] as usize];
+    }
+
+    for i in 0..MAX_LEN {
+        //~^ needless_range_loop
+        let _ = a[i][i];
+    }
+
+    for i in 0..MAX_LEN {
+        //~^ needless_range_loop
+        let _ = a[0][i];
+    }
+}
diff --git a/tests/ui/needless_range_loop.stderr b/tests/ui/needless_range_loop.stderr
index 23c085f9d3b21..33a519d8a80d5 100644
--- a/tests/ui/needless_range_loop.stderr
+++ b/tests/ui/needless_range_loop.stderr
@@ -168,5 +168,29 @@ LL -     for i in 0..vec.len() {
 LL +     for (i, <item>) in vec.iter_mut().enumerate() {
    |
 
-error: aborting due to 14 previous errors
+error: the loop variable `i` is used to index `a`
+  --> tests/ui/needless_range_loop.rs:235:14
+   |
+LL |     for i in 0..MAX_LEN {
+   |              ^^^^^^^^^^
+   |
+help: consider using an iterator and enumerate()
+   |
+LL -     for i in 0..MAX_LEN {
+LL +     for (i, <item>) in a.iter().enumerate().take(MAX_LEN) {
+   |
+
+error: the loop variable `i` is only used to index `a`
+  --> tests/ui/needless_range_loop.rs:240:14
+   |
+LL |     for i in 0..MAX_LEN {
+   |              ^^^^^^^^^^
+   |
+help: consider using an iterator
+   |
+LL -     for i in 0..MAX_LEN {
+LL +     for <item> in a.iter().take(MAX_LEN) {
+   |
+
+error: aborting due to 16 previous errors
 
diff --git a/tests/ui/nonminimal_bool.rs b/tests/ui/nonminimal_bool.rs
index cacce9a7d1cbd..f03f74dfafe21 100644
--- a/tests/ui/nonminimal_bool.rs
+++ b/tests/ui/nonminimal_bool.rs
@@ -182,14 +182,12 @@ fn issue_5794() {
     if !b == true {}
     //~^ nonminimal_bool
     //~| bool_comparison
-    //~| bool_comparison
     if !b != true {}
     //~^ nonminimal_bool
     //~| bool_comparison
     if true == !b {}
     //~^ nonminimal_bool
     //~| bool_comparison
-    //~| bool_comparison
     if true != !b {}
     //~^ nonminimal_bool
     //~| bool_comparison
diff --git a/tests/ui/nonminimal_bool.stderr b/tests/ui/nonminimal_bool.stderr
index c20412974b20f..6a20b9216da52 100644
--- a/tests/ui/nonminimal_bool.stderr
+++ b/tests/ui/nonminimal_bool.stderr
@@ -154,98 +154,86 @@ error: this boolean expression can be simplified
 LL |     if !b == true {}
    |        ^^^^^^^^^^ help: try: `b != true`
 
-error: this comparison might be written more concisely
+error: equality checks against true are unnecessary
   --> tests/ui/nonminimal_bool.rs:182:8
    |
 LL |     if !b == true {}
-   |        ^^^^^^^^^^ help: try simplifying it as shown: `b != true`
+   |        ^^^^^^^^^^ help: try: `!b`
    |
    = note: `-D clippy::bool-comparison` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::bool_comparison)]`
 
-error: equality checks against true are unnecessary
-  --> tests/ui/nonminimal_bool.rs:182:8
-   |
-LL |     if !b == true {}
-   |        ^^^^^^^^^^ help: try simplifying it as shown: `!b`
-
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:186:8
+  --> tests/ui/nonminimal_bool.rs:185:8
    |
 LL |     if !b != true {}
    |        ^^^^^^^^^^ help: try: `b == true`
 
 error: inequality checks against true can be replaced by a negation
-  --> tests/ui/nonminimal_bool.rs:186:8
+  --> tests/ui/nonminimal_bool.rs:185:8
    |
 LL |     if !b != true {}
-   |        ^^^^^^^^^^ help: try simplifying it as shown: `b`
+   |        ^^^^^^^^^^ help: try: `b`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:189:8
+  --> tests/ui/nonminimal_bool.rs:188:8
    |
 LL |     if true == !b {}
    |        ^^^^^^^^^^ help: try: `true != b`
 
-error: this comparison might be written more concisely
-  --> tests/ui/nonminimal_bool.rs:189:8
-   |
-LL |     if true == !b {}
-   |        ^^^^^^^^^^ help: try simplifying it as shown: `true != b`
-
 error: equality checks against true are unnecessary
-  --> tests/ui/nonminimal_bool.rs:189:8
+  --> tests/ui/nonminimal_bool.rs:188:8
    |
 LL |     if true == !b {}
-   |        ^^^^^^^^^^ help: try simplifying it as shown: `!b`
+   |        ^^^^^^^^^^ help: try: `!b`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:193:8
+  --> tests/ui/nonminimal_bool.rs:191:8
    |
 LL |     if true != !b {}
    |        ^^^^^^^^^^ help: try: `true == b`
 
 error: inequality checks against true can be replaced by a negation
-  --> tests/ui/nonminimal_bool.rs:193:8
+  --> tests/ui/nonminimal_bool.rs:191:8
    |
 LL |     if true != !b {}
-   |        ^^^^^^^^^^ help: try simplifying it as shown: `b`
+   |        ^^^^^^^^^^ help: try: `b`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:196:8
+  --> tests/ui/nonminimal_bool.rs:194:8
    |
 LL |     if !b == !c {}
    |        ^^^^^^^^ help: try: `b == c`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:198:8
+  --> tests/ui/nonminimal_bool.rs:196:8
    |
 LL |     if !b != !c {}
    |        ^^^^^^^^ help: try: `b != c`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:214:8
+  --> tests/ui/nonminimal_bool.rs:212:8
    |
 LL |     if !(a < 2.0 && !b) {
    |        ^^^^^^^^^^^^^^^^ help: try: `a >= 2.0 || b`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:233:12
+  --> tests/ui/nonminimal_bool.rs:231:12
    |
 LL |         if !(matches!(ty, TyKind::Ref(_, _, _)) && !is_mutable(&expr)) {
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `!matches!(ty, TyKind::Ref(_, _, _)) || is_mutable(&expr)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:253:8
+  --> tests/ui/nonminimal_bool.rs:251:8
    |
 LL |     if !S != true {}
    |        ^^^^^^^^^^ help: try: `S == true`
 
 error: inequality checks against true can be replaced by a negation
-  --> tests/ui/nonminimal_bool.rs:253:8
+  --> tests/ui/nonminimal_bool.rs:251:8
    |
 LL |     if !S != true {}
-   |        ^^^^^^^^^^ help: try simplifying it as shown: `!!S`
+   |        ^^^^^^^^^^ help: try: `!!S`
 
-error: aborting due to 33 previous errors
+error: aborting due to 31 previous errors
 
diff --git a/tests/ui/option_map_unit_fn_fixable.fixed b/tests/ui/option_map_unit_fn_fixable.fixed
index 55c1b8f110ced..340be7c7e932a 100644
--- a/tests/ui/option_map_unit_fn_fixable.fixed
+++ b/tests/ui/option_map_unit_fn_fixable.fixed
@@ -102,4 +102,13 @@ fn option_map_unit_fn() {
     //~^ option_map_unit_fn
 }
 
+fn issue15568() {
+    unsafe fn f(_: u32) {}
+    let x = Some(3);
+    if let Some(x) = x { unsafe { f(x) } }
+    //~^ option_map_unit_fn
+    if let Some(x) = x { unsafe { f(x) } }
+    //~^ option_map_unit_fn
+}
+
 fn main() {}
diff --git a/tests/ui/option_map_unit_fn_fixable.rs b/tests/ui/option_map_unit_fn_fixable.rs
index 5ed47e4c60b51..d902c87379b77 100644
--- a/tests/ui/option_map_unit_fn_fixable.rs
+++ b/tests/ui/option_map_unit_fn_fixable.rs
@@ -102,4 +102,13 @@ fn option_map_unit_fn() {
     //~^ option_map_unit_fn
 }
 
+fn issue15568() {
+    unsafe fn f(_: u32) {}
+    let x = Some(3);
+    x.map(|x| unsafe { f(x) });
+    //~^ option_map_unit_fn
+    x.map(|x| unsafe { { f(x) } });
+    //~^ option_map_unit_fn
+}
+
 fn main() {}
diff --git a/tests/ui/option_map_unit_fn_fixable.stderr b/tests/ui/option_map_unit_fn_fixable.stderr
index 3f7abae34eea7..2405aa9a7ccfa 100644
--- a/tests/ui/option_map_unit_fn_fixable.stderr
+++ b/tests/ui/option_map_unit_fn_fixable.stderr
@@ -153,5 +153,21 @@ LL |     option().map(|value| println!("{:?}", value));
    |     |
    |     help: try: `if let Some(value) = option() { println!("{:?}", value) }`
 
-error: aborting due to 19 previous errors
+error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
+  --> tests/ui/option_map_unit_fn_fixable.rs:108:5
+   |
+LL |     x.map(|x| unsafe { f(x) });
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^-
+   |     |
+   |     help: try: `if let Some(x) = x { unsafe { f(x) } }`
+
+error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
+  --> tests/ui/option_map_unit_fn_fixable.rs:110:5
+   |
+LL |     x.map(|x| unsafe { { f(x) } });
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
+   |     |
+   |     help: try: `if let Some(x) = x { unsafe { f(x) } }`
+
+error: aborting due to 21 previous errors
 
diff --git a/tests/ui/or_then_unwrap.fixed b/tests/ui/or_then_unwrap.fixed
index ba9beef57afaa..9660b82fe7d61 100644
--- a/tests/ui/or_then_unwrap.fixed
+++ b/tests/ui/or_then_unwrap.fixed
@@ -28,6 +28,12 @@ fn main() {
     //
     //~^^ or_then_unwrap
 
+    // Call with macro should preserve the macro call rather than expand it
+    let option: Option<Vec<&str>> = None;
+    let _ = option.unwrap_or(vec!["fallback"]); // should trigger lint
+    //
+    //~^^ or_then_unwrap
+
     // as part of a method chain
     let option: Option<&str> = None;
     let _ = option.map(|v| v).unwrap_or("fallback").to_string().chars(); // should trigger lint
diff --git a/tests/ui/or_then_unwrap.rs b/tests/ui/or_then_unwrap.rs
index fac90249a243c..c387335211643 100644
--- a/tests/ui/or_then_unwrap.rs
+++ b/tests/ui/or_then_unwrap.rs
@@ -28,6 +28,12 @@ fn main() {
     //
     //~^^ or_then_unwrap
 
+    // Call with macro should preserve the macro call rather than expand it
+    let option: Option<Vec<&str>> = None;
+    let _ = option.or(Some(vec!["fallback"])).unwrap(); // should trigger lint
+    //
+    //~^^ or_then_unwrap
+
     // as part of a method chain
     let option: Option<&str> = None;
     let _ = option.map(|v| v).or(Some("fallback")).unwrap().to_string().chars(); // should trigger lint
diff --git a/tests/ui/or_then_unwrap.stderr b/tests/ui/or_then_unwrap.stderr
index 1160498c6053b..3e66b15edbd65 100644
--- a/tests/ui/or_then_unwrap.stderr
+++ b/tests/ui/or_then_unwrap.stderr
@@ -14,10 +14,16 @@ LL |     let _ = result.or::<&str>(Ok("fallback")).unwrap(); // should trigger l
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or("fallback")`
 
 error: found `.or(Some(…)).unwrap()`
-  --> tests/ui/or_then_unwrap.rs:33:31
+  --> tests/ui/or_then_unwrap.rs:33:20
+   |
+LL |     let _ = option.or(Some(vec!["fallback"])).unwrap(); // should trigger lint
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or(vec!["fallback"])`
+
+error: found `.or(Some(…)).unwrap()`
+  --> tests/ui/or_then_unwrap.rs:39:31
    |
 LL |     let _ = option.map(|v| v).or(Some("fallback")).unwrap().to_string().chars(); // should trigger lint
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or("fallback")`
 
-error: aborting due to 3 previous errors
+error: aborting due to 4 previous errors
 
diff --git a/tests/ui/panicking_macros.rs b/tests/ui/panicking_macros.rs
index 65854d7eb4bf9..b044be7d54ac5 100644
--- a/tests/ui/panicking_macros.rs
+++ b/tests/ui/panicking_macros.rs
@@ -31,6 +31,20 @@ fn panic() {
     let b = a + 2;
 }
 
+const fn panic_const() {
+    let a = 2;
+    panic!();
+    //~^ panic
+
+    panic!("message");
+    //~^ panic
+
+    panic!("{} {}", "panic with", "multiple arguments");
+    //~^ panic
+
+    let b = a + 2;
+}
+
 fn todo() {
     let a = 2;
     todo!();
@@ -114,6 +128,7 @@ fn debug_assert_msg() {
 
 fn main() {
     panic();
+    panic_const();
     todo();
     unimplemented();
     unreachable();
diff --git a/tests/ui/panicking_macros.stderr b/tests/ui/panicking_macros.stderr
index 03e459e4ec6ec..7b767ae0f65bf 100644
--- a/tests/ui/panicking_macros.stderr
+++ b/tests/ui/panicking_macros.stderr
@@ -19,9 +19,27 @@ error: `panic` should not be present in production code
 LL |     panic!("{} {}", "panic with", "multiple arguments");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: `todo` should not be present in production code
+error: `panic` should not be present in production code
   --> tests/ui/panicking_macros.rs:36:5
    |
+LL |     panic!();
+   |     ^^^^^^^^
+
+error: `panic` should not be present in production code
+  --> tests/ui/panicking_macros.rs:39:5
+   |
+LL |     panic!("message");
+   |     ^^^^^^^^^^^^^^^^^
+
+error: `panic` should not be present in production code
+  --> tests/ui/panicking_macros.rs:42:5
+   |
+LL |     panic!("{} {}", "panic with", "multiple arguments");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: `todo` should not be present in production code
+  --> tests/ui/panicking_macros.rs:50:5
+   |
 LL |     todo!();
    |     ^^^^^^^
    |
@@ -29,19 +47,19 @@ LL |     todo!();
    = help: to override `-D warnings` add `#[allow(clippy::todo)]`
 
 error: `todo` should not be present in production code
-  --> tests/ui/panicking_macros.rs:39:5
+  --> tests/ui/panicking_macros.rs:53:5
    |
 LL |     todo!("message");
    |     ^^^^^^^^^^^^^^^^
 
 error: `todo` should not be present in production code
-  --> tests/ui/panicking_macros.rs:42:5
+  --> tests/ui/panicking_macros.rs:56:5
    |
 LL |     todo!("{} {}", "panic with", "multiple arguments");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `unimplemented` should not be present in production code
-  --> tests/ui/panicking_macros.rs:50:5
+  --> tests/ui/panicking_macros.rs:64:5
    |
 LL |     unimplemented!();
    |     ^^^^^^^^^^^^^^^^
@@ -50,19 +68,19 @@ LL |     unimplemented!();
    = help: to override `-D warnings` add `#[allow(clippy::unimplemented)]`
 
 error: `unimplemented` should not be present in production code
-  --> tests/ui/panicking_macros.rs:53:5
+  --> tests/ui/panicking_macros.rs:67:5
    |
 LL |     unimplemented!("message");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `unimplemented` should not be present in production code
-  --> tests/ui/panicking_macros.rs:56:5
+  --> tests/ui/panicking_macros.rs:70:5
    |
 LL |     unimplemented!("{} {}", "panic with", "multiple arguments");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: usage of the `unreachable!` macro
-  --> tests/ui/panicking_macros.rs:64:5
+  --> tests/ui/panicking_macros.rs:78:5
    |
 LL |     unreachable!();
    |     ^^^^^^^^^^^^^^
@@ -71,40 +89,40 @@ LL |     unreachable!();
    = help: to override `-D warnings` add `#[allow(clippy::unreachable)]`
 
 error: usage of the `unreachable!` macro
-  --> tests/ui/panicking_macros.rs:67:5
+  --> tests/ui/panicking_macros.rs:81:5
    |
 LL |     unreachable!("message");
    |     ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: usage of the `unreachable!` macro
-  --> tests/ui/panicking_macros.rs:70:5
+  --> tests/ui/panicking_macros.rs:84:5
    |
 LL |     unreachable!("{} {}", "panic with", "multiple arguments");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `panic` should not be present in production code
-  --> tests/ui/panicking_macros.rs:78:5
+  --> tests/ui/panicking_macros.rs:92:5
    |
 LL |     panic!();
    |     ^^^^^^^^
 
 error: `todo` should not be present in production code
-  --> tests/ui/panicking_macros.rs:81:5
+  --> tests/ui/panicking_macros.rs:95:5
    |
 LL |     todo!();
    |     ^^^^^^^
 
 error: `unimplemented` should not be present in production code
-  --> tests/ui/panicking_macros.rs:84:5
+  --> tests/ui/panicking_macros.rs:98:5
    |
 LL |     unimplemented!();
    |     ^^^^^^^^^^^^^^^^
 
 error: usage of the `unreachable!` macro
-  --> tests/ui/panicking_macros.rs:87:5
+  --> tests/ui/panicking_macros.rs:101:5
    |
 LL |     unreachable!();
    |     ^^^^^^^^^^^^^^
 
-error: aborting due to 16 previous errors
+error: aborting due to 19 previous errors
 
diff --git a/tests/ui/print_literal.fixed b/tests/ui/print_literal.fixed
index ebfe19c700ee6..26139f9b67102 100644
--- a/tests/ui/print_literal.fixed
+++ b/tests/ui/print_literal.fixed
@@ -105,3 +105,16 @@ fn issue_14930() {
     println!("Hello x is {0:2$.1$}", 0.01, 2, 3);
     //~^ print_literal
 }
+
+fn issue_15576() {
+    println!("Hello x is {1:.*}", 5, 0.01);
+    //~^ print_literal
+
+    println!("Hello x is {:.p$}", 0.01, p = 5);
+    //~^ print_literal
+
+    println!(
+        "Hello name: x is {1:.*} (which {1} with {0} places)", 5, 0.01
+    );
+    //~^^ print_literal
+}
diff --git a/tests/ui/print_literal.rs b/tests/ui/print_literal.rs
index 8f3d9be069854..7c4cf028e84cc 100644
--- a/tests/ui/print_literal.rs
+++ b/tests/ui/print_literal.rs
@@ -106,3 +106,17 @@ fn issue_14930() {
     println!("Hello {0} is {1:3$.2$}", "x", 0.01, 2, 3);
     //~^ print_literal
 }
+
+fn issue_15576() {
+    println!("Hello {} is {2:.*}", "x", 5, 0.01);
+    //~^ print_literal
+
+    println!("Hello {} is {:.p$}", "x", 0.01, p = 5);
+    //~^ print_literal
+
+    println!(
+        "Hello {}: {2} is {3:.*} (which {3} with {1} places)",
+        "name", 5, "x", 0.01
+    );
+    //~^^ print_literal
+}
diff --git a/tests/ui/print_literal.stderr b/tests/ui/print_literal.stderr
index 1c378017d151b..c136f52800f69 100644
--- a/tests/ui/print_literal.stderr
+++ b/tests/ui/print_literal.stderr
@@ -277,5 +277,41 @@ LL -     println!("Hello {0} is {1:3$.2$}", "x", 0.01, 2, 3);
 LL +     println!("Hello x is {0:2$.1$}", 0.01, 2, 3);
    |
 
-error: aborting due to 22 previous errors
+error: literal with an empty format string
+  --> tests/ui/print_literal.rs:111:36
+   |
+LL |     println!("Hello {} is {2:.*}", "x", 5, 0.01);
+   |                                    ^^^
+   |
+help: try
+   |
+LL -     println!("Hello {} is {2:.*}", "x", 5, 0.01);
+LL +     println!("Hello x is {1:.*}", 5, 0.01);
+   |
+
+error: literal with an empty format string
+  --> tests/ui/print_literal.rs:114:36
+   |
+LL |     println!("Hello {} is {:.p$}", "x", 0.01, p = 5);
+   |                                    ^^^
+   |
+help: try
+   |
+LL -     println!("Hello {} is {:.p$}", "x", 0.01, p = 5);
+LL +     println!("Hello x is {:.p$}", 0.01, p = 5);
+   |
+
+error: literal with an empty format string
+  --> tests/ui/print_literal.rs:119:9
+   |
+LL |         "name", 5, "x", 0.01
+   |         ^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -         "Hello {}: {2} is {3:.*} (which {3} with {1} places)",
+LL +         "Hello name: x is {1:.*} (which {1} with {0} places)", 5, 0.01
+   |
+
+error: aborting due to 25 previous errors
 
diff --git a/tests/ui/ptr_as_ptr.fixed b/tests/ui/ptr_as_ptr.fixed
index 78e1ceb480a5f..4457878b6faf1 100644
--- a/tests/ui/ptr_as_ptr.fixed
+++ b/tests/ui/ptr_as_ptr.fixed
@@ -229,3 +229,9 @@ fn issue15283() {
         //~^ ptr_as_ptr
     }
 }
+
+fn issue15232() {
+    let mut b = Box::new(0i32);
+    let _ptr = std::ptr::addr_of_mut!(*b).cast::<()>();
+    //~^ ptr_as_ptr
+}
diff --git a/tests/ui/ptr_as_ptr.rs b/tests/ui/ptr_as_ptr.rs
index 70732cf0a6c16..9124fc912d2c6 100644
--- a/tests/ui/ptr_as_ptr.rs
+++ b/tests/ui/ptr_as_ptr.rs
@@ -229,3 +229,9 @@ fn issue15283() {
         //~^ ptr_as_ptr
     }
 }
+
+fn issue15232() {
+    let mut b = Box::new(0i32);
+    let _ptr = std::ptr::addr_of_mut!(*b) as *mut ();
+    //~^ ptr_as_ptr
+}
diff --git a/tests/ui/ptr_as_ptr.stderr b/tests/ui/ptr_as_ptr.stderr
index c0a2a4b6d204d..af21c1e35f52a 100644
--- a/tests/ui/ptr_as_ptr.stderr
+++ b/tests/ui/ptr_as_ptr.stderr
@@ -199,5 +199,11 @@ error: `as` casting between raw pointers without changing their constness
 LL |         let _: fn() = std::mem::transmute(std::ptr::null::<()>() as *const u8);
    |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `std::ptr::null::<u8>()`
 
-error: aborting due to 33 previous errors
+error: `as` casting between raw pointers without changing their constness
+  --> tests/ui/ptr_as_ptr.rs:235:16
+   |
+LL |     let _ptr = std::ptr::addr_of_mut!(*b) as *mut ();
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `std::ptr::addr_of_mut!(*b).cast::<()>()`
+
+error: aborting due to 34 previous errors
 
diff --git a/tests/ui/ptr_cast_constness.fixed b/tests/ui/ptr_cast_constness.fixed
index 79bfae1f7ebb4..cf57de53d9f3d 100644
--- a/tests/ui/ptr_cast_constness.fixed
+++ b/tests/ui/ptr_cast_constness.fixed
@@ -106,3 +106,9 @@ fn issue14621() {
     let _ = std::ptr::addr_of_mut!(local).cast_const();
     //~^ ptr_cast_constness
 }
+
+fn issue11317() {
+    let r = &0_u32;
+    let _ptr: *mut u32 = (r as *const u32).cast_mut();
+    //~^ ptr_cast_constness
+}
diff --git a/tests/ui/ptr_cast_constness.rs b/tests/ui/ptr_cast_constness.rs
index f6590dabd5b84..ea53a0fa8c50f 100644
--- a/tests/ui/ptr_cast_constness.rs
+++ b/tests/ui/ptr_cast_constness.rs
@@ -106,3 +106,9 @@ fn issue14621() {
     let _ = std::ptr::addr_of_mut!(local) as *const _;
     //~^ ptr_cast_constness
 }
+
+fn issue11317() {
+    let r = &0_u32;
+    let _ptr: *mut u32 = r as *const _ as *mut _;
+    //~^ ptr_cast_constness
+}
diff --git a/tests/ui/ptr_cast_constness.stderr b/tests/ui/ptr_cast_constness.stderr
index 0b1644168ff51..4adb5cc5ad7fe 100644
--- a/tests/ui/ptr_cast_constness.stderr
+++ b/tests/ui/ptr_cast_constness.stderr
@@ -89,5 +89,11 @@ error: `as` casting between raw pointers while changing only its constness
 LL |     let _ = std::ptr::addr_of_mut!(local) as *const _;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast_const`, a safer alternative: `std::ptr::addr_of_mut!(local).cast_const()`
 
-error: aborting due to 14 previous errors
+error: `as` casting between raw pointers while changing only its constness
+  --> tests/ui/ptr_cast_constness.rs:112:26
+   |
+LL |     let _ptr: *mut u32 = r as *const _ as *mut _;
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast_mut`, a safer alternative: `(r as *const u32).cast_mut()`
+
+error: aborting due to 15 previous errors
 
diff --git a/tests/ui/semicolon_inside_block.fixed b/tests/ui/semicolon_inside_block.fixed
index 7eb53e733ad50..7308e78aae263 100644
--- a/tests/ui/semicolon_inside_block.fixed
+++ b/tests/ui/semicolon_inside_block.fixed
@@ -86,3 +86,8 @@ fn main() {
 
     unit_fn_block()
 }
+
+pub fn issue15388() {
+    #[rustfmt::skip]
+    {0; 0};
+}
diff --git a/tests/ui/semicolon_inside_block.rs b/tests/ui/semicolon_inside_block.rs
index 9fa5b117194d7..467bf4d779f2a 100644
--- a/tests/ui/semicolon_inside_block.rs
+++ b/tests/ui/semicolon_inside_block.rs
@@ -86,3 +86,8 @@ fn main() {
 
     unit_fn_block()
 }
+
+pub fn issue15388() {
+    #[rustfmt::skip]
+    {0; 0};
+}
diff --git a/tests/ui/semicolon_inside_block_stmt_expr_attrs.fixed b/tests/ui/semicolon_inside_block_stmt_expr_attrs.fixed
new file mode 100644
index 0000000000000..5b93a91da003a
--- /dev/null
+++ b/tests/ui/semicolon_inside_block_stmt_expr_attrs.fixed
@@ -0,0 +1,11 @@
+// Test when the feature `stmt_expr_attributes` is enabled
+
+#![feature(stmt_expr_attributes)]
+#![allow(clippy::no_effect)]
+#![warn(clippy::semicolon_inside_block)]
+
+pub fn issue15388() {
+    #[rustfmt::skip]
+    {0; 0;}
+    //~^ semicolon_inside_block
+}
diff --git a/tests/ui/semicolon_inside_block_stmt_expr_attrs.rs b/tests/ui/semicolon_inside_block_stmt_expr_attrs.rs
new file mode 100644
index 0000000000000..aa2c0cb50299c
--- /dev/null
+++ b/tests/ui/semicolon_inside_block_stmt_expr_attrs.rs
@@ -0,0 +1,11 @@
+// Test when the feature `stmt_expr_attributes` is enabled
+
+#![feature(stmt_expr_attributes)]
+#![allow(clippy::no_effect)]
+#![warn(clippy::semicolon_inside_block)]
+
+pub fn issue15388() {
+    #[rustfmt::skip]
+    {0; 0};
+    //~^ semicolon_inside_block
+}
diff --git a/tests/ui/semicolon_inside_block_stmt_expr_attrs.stderr b/tests/ui/semicolon_inside_block_stmt_expr_attrs.stderr
new file mode 100644
index 0000000000000..5bb91915a5fd8
--- /dev/null
+++ b/tests/ui/semicolon_inside_block_stmt_expr_attrs.stderr
@@ -0,0 +1,16 @@
+error: consider moving the `;` inside the block for consistent formatting
+  --> tests/ui/semicolon_inside_block_stmt_expr_attrs.rs:9:5
+   |
+LL |     {0; 0};
+   |     ^^^^^^^
+   |
+   = note: `-D clippy::semicolon-inside-block` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::semicolon_inside_block)]`
+help: put the `;` here
+   |
+LL -     {0; 0};
+LL +     {0; 0;}
+   |
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/std_instead_of_core.fixed b/tests/ui/std_instead_of_core.fixed
index 603ab0accb0b6..c27cec558242d 100644
--- a/tests/ui/std_instead_of_core.fixed
+++ b/tests/ui/std_instead_of_core.fixed
@@ -89,3 +89,10 @@ fn msrv_1_76(_: std::net::IpAddr) {}
 #[clippy::msrv = "1.77"]
 fn msrv_1_77(_: core::net::IpAddr) {}
 //~^ std_instead_of_core
+
+#[warn(clippy::alloc_instead_of_core)]
+fn issue15579() {
+    use std::alloc;
+
+    let layout = alloc::Layout::new::<u8>();
+}
diff --git a/tests/ui/std_instead_of_core.rs b/tests/ui/std_instead_of_core.rs
index b6d4abad9f8fe..7d53f7fc3072b 100644
--- a/tests/ui/std_instead_of_core.rs
+++ b/tests/ui/std_instead_of_core.rs
@@ -89,3 +89,10 @@ fn msrv_1_76(_: std::net::IpAddr) {}
 #[clippy::msrv = "1.77"]
 fn msrv_1_77(_: std::net::IpAddr) {}
 //~^ std_instead_of_core
+
+#[warn(clippy::alloc_instead_of_core)]
+fn issue15579() {
+    use std::alloc;
+
+    let layout = alloc::Layout::new::<u8>();
+}
diff --git a/tests/ui/unit_cmp.rs b/tests/ui/unit_cmp.rs
index 93f5b87c3d2a7..0a0fe3a1990b0 100644
--- a/tests/ui/unit_cmp.rs
+++ b/tests/ui/unit_cmp.rs
@@ -68,3 +68,20 @@ fn main() {
         }
     );
 }
+
+fn issue15559() {
+    fn foo() {}
+    assert_eq!(
+        //~^ unit_cmp
+        {
+            1;
+        },
+        foo()
+    );
+    assert_eq!(foo(), foo());
+    //~^ unit_cmp
+
+    // don't lint on explicitly written unit expr
+    assert_eq!(foo(), ());
+    assert_ne!((), ContainsUnit(()).0);
+}
diff --git a/tests/ui/unit_cmp.stderr b/tests/ui/unit_cmp.stderr
index 8f26749fd8605..21aa9dce1510f 100644
--- a/tests/ui/unit_cmp.stderr
+++ b/tests/ui/unit_cmp.stderr
@@ -71,5 +71,23 @@ LL | |             true;
 LL | |     );
    | |_____^
 
-error: aborting due to 6 previous errors
+error: `assert_eq` of unit values detected. This will always succeed
+  --> tests/ui/unit_cmp.rs:74:5
+   |
+LL | /     assert_eq!(
+LL | |
+LL | |         {
+LL | |             1;
+LL | |         },
+LL | |         foo()
+LL | |     );
+   | |_____^
+
+error: `assert_eq` of unit values detected. This will always succeed
+  --> tests/ui/unit_cmp.rs:81:5
+   |
+LL |     assert_eq!(foo(), foo());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 8 previous errors
 
diff --git a/tests/ui/unnecessary_clone.stderr b/tests/ui/unnecessary_clone.stderr
index a4fdf09cd5dcb..17518e123d12e 100644
--- a/tests/ui/unnecessary_clone.stderr
+++ b/tests/ui/unnecessary_clone.stderr
@@ -2,7 +2,7 @@ error: using `.clone()` on a ref-counted pointer
   --> tests/ui/unnecessary_clone.rs:23:5
    |
 LL |     rc.clone();
-   |     ^^^^^^^^^^ help: try: `Rc::<bool>::clone(&rc)`
+   |     ^^^^^^^^^^ help: try: `std::rc::Rc::<bool>::clone(&rc)`
    |
    = note: `-D clippy::clone-on-ref-ptr` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::clone_on_ref_ptr)]`
@@ -11,25 +11,25 @@ error: using `.clone()` on a ref-counted pointer
   --> tests/ui/unnecessary_clone.rs:28:5
    |
 LL |     arc.clone();
-   |     ^^^^^^^^^^^ help: try: `Arc::<bool>::clone(&arc)`
+   |     ^^^^^^^^^^^ help: try: `std::sync::Arc::<bool>::clone(&arc)`
 
 error: using `.clone()` on a ref-counted pointer
   --> tests/ui/unnecessary_clone.rs:33:5
    |
 LL |     rcweak.clone();
-   |     ^^^^^^^^^^^^^^ help: try: `Weak::<bool>::clone(&rcweak)`
+   |     ^^^^^^^^^^^^^^ help: try: `std::rc::Weak::<bool>::clone(&rcweak)`
 
 error: using `.clone()` on a ref-counted pointer
   --> tests/ui/unnecessary_clone.rs:38:5
    |
 LL |     arc_weak.clone();
-   |     ^^^^^^^^^^^^^^^^ help: try: `Weak::<bool>::clone(&arc_weak)`
+   |     ^^^^^^^^^^^^^^^^ help: try: `std::sync::Weak::<bool>::clone(&arc_weak)`
 
 error: using `.clone()` on a ref-counted pointer
   --> tests/ui/unnecessary_clone.rs:44:33
    |
 LL |     let _: Arc<dyn SomeTrait> = x.clone();
-   |                                 ^^^^^^^^^ help: try: `Arc::<SomeImpl>::clone(&x)`
+   |                                 ^^^^^^^^^ help: try: `std::sync::Arc::<SomeImpl>::clone(&x)`
 
 error: using `clone` on type `T` which implements the `Copy` trait
   --> tests/ui/unnecessary_clone.rs:49:5
@@ -56,7 +56,7 @@ error: using `.clone()` on a ref-counted pointer
   --> tests/ui/unnecessary_clone.rs:108:14
    |
 LL |         Some(try_opt!(Some(rc)).clone())
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Rc::<u8>::clone(&try_opt!(Some(rc)))`
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::rc::Rc::<u8>::clone(&try_opt!(Some(rc)))`
 
 error: aborting due to 9 previous errors
 
diff --git a/tests/ui/unnested_or_patterns.fixed b/tests/ui/unnested_or_patterns.fixed
index 2081772d06b36..339d4a95084ae 100644
--- a/tests/ui/unnested_or_patterns.fixed
+++ b/tests/ui/unnested_or_patterns.fixed
@@ -9,6 +9,11 @@
 )]
 #![allow(unreachable_patterns, irrefutable_let_patterns, unused)]
 
+struct S {
+    x: u8,
+    y: u8,
+}
+
 fn main() {
     // Should be ignored by this lint, as nesting requires more characters.
     if let &0 | &2 = &0 {}
@@ -45,10 +50,6 @@ fn main() {
     //~^ unnested_or_patterns
     if let TS(x, ..) | TS(x, 1 | 2) = TS(0, 0) {}
     //~^ unnested_or_patterns
-    struct S {
-        x: u8,
-        y: u8,
-    }
     if let S { x: 0 | 1, y } = (S { x: 0, y: 1 }) {}
     //~^ unnested_or_patterns
     if let S { x: 0, y, .. } | S { y, x: 1 } = (S { x: 0, y: 1 }) {}
@@ -77,3 +78,19 @@ mod issue9952 {
     fn or_in_param((x | x | x): i32) {}
     //~^ unnested_or_patterns
 }
+
+fn issue15219() {
+    struct Foo {
+        x: u8,
+    }
+
+    // the original repro
+    if let Foo { x } | Foo { x } = (Foo { x: 0 }) {}
+
+    // also works with more fields
+    if let S { x, y } | S { x, y } = (S { x: 0, y: 0 }) {}
+
+    // `y` not triggering the lint doesn't stop the `x` from getting flagged
+    if let S { y, x: 0 | 1 } = (S { x: 0, y: 1 }) {}
+    //~^ unnested_or_patterns
+}
diff --git a/tests/ui/unnested_or_patterns.rs b/tests/ui/unnested_or_patterns.rs
index 6bf8fce36616c..f5c99183b0c51 100644
--- a/tests/ui/unnested_or_patterns.rs
+++ b/tests/ui/unnested_or_patterns.rs
@@ -9,6 +9,11 @@
 )]
 #![allow(unreachable_patterns, irrefutable_let_patterns, unused)]
 
+struct S {
+    x: u8,
+    y: u8,
+}
+
 fn main() {
     // Should be ignored by this lint, as nesting requires more characters.
     if let &0 | &2 = &0 {}
@@ -45,10 +50,6 @@ fn main() {
     //~^ unnested_or_patterns
     if let TS(x, ..) | TS(x, 1) | TS(x, 2) = TS(0, 0) {}
     //~^ unnested_or_patterns
-    struct S {
-        x: u8,
-        y: u8,
-    }
     if let S { x: 0, y } | S { y, x: 1 } = (S { x: 0, y: 1 }) {}
     //~^ unnested_or_patterns
     if let S { x: 0, y, .. } | S { y, x: 1 } = (S { x: 0, y: 1 }) {}
@@ -77,3 +78,19 @@ mod issue9952 {
     fn or_in_param((x | (x | x)): i32) {}
     //~^ unnested_or_patterns
 }
+
+fn issue15219() {
+    struct Foo {
+        x: u8,
+    }
+
+    // the original repro
+    if let Foo { x } | Foo { x } = (Foo { x: 0 }) {}
+
+    // also works with more fields
+    if let S { x, y } | S { x, y } = (S { x: 0, y: 0 }) {}
+
+    // `y` not triggering the lint doesn't stop the `x` from getting flagged
+    if let S { y, x: 0 } | S { y, x: 1 } = (S { x: 0, y: 1 }) {}
+    //~^ unnested_or_patterns
+}
diff --git a/tests/ui/unnested_or_patterns.stderr b/tests/ui/unnested_or_patterns.stderr
index c805dc992b1c2..d2b617c322c46 100644
--- a/tests/ui/unnested_or_patterns.stderr
+++ b/tests/ui/unnested_or_patterns.stderr
@@ -1,5 +1,5 @@
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:16:12
+  --> tests/ui/unnested_or_patterns.rs:21:12
    |
 LL |     if let box 0 | box 2 = Box::new(0) {}
    |            ^^^^^^^^^^^^^
@@ -13,7 +13,7 @@ LL +     if let box (0 | 2) = Box::new(0) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:18:12
+  --> tests/ui/unnested_or_patterns.rs:23:12
    |
 LL |     if let box ((0 | 1)) | box (2 | 3) | box 4 = Box::new(0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     if let box (0 | 1 | 2 | 3 | 4) = Box::new(0) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:21:12
+  --> tests/ui/unnested_or_patterns.rs:26:12
    |
 LL |     if let Some(1) | C0 | Some(2) = None {}
    |            ^^^^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     if let Some(1 | 2) | C0 = None {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:23:12
+  --> tests/ui/unnested_or_patterns.rs:28:12
    |
 LL |     if let &mut 0 | &mut 2 = &mut 0 {}
    |            ^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +     if let &mut (0 | 2) = &mut 0 {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:25:12
+  --> tests/ui/unnested_or_patterns.rs:30:12
    |
 LL |     if let x @ 0 | x @ 2 = 0 {}
    |            ^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL +     if let x @ (0 | 2) = 0 {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:27:12
+  --> tests/ui/unnested_or_patterns.rs:32:12
    |
 LL |     if let (0, 1) | (0, 2) | (0, 3) = (0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL +     if let (0, 1 | 2 | 3) = (0, 0) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:29:12
+  --> tests/ui/unnested_or_patterns.rs:34:12
    |
 LL |     if let (1, 0) | (2, 0) | (3, 0) = (0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL +     if let (1 | 2 | 3, 0) = (0, 0) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:31:12
+  --> tests/ui/unnested_or_patterns.rs:36:12
    |
 LL |     if let (x, ..) | (x, 1) | (x, 2) = (0, 1) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL +     if let (x, ..) | (x, 1 | 2) = (0, 1) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:33:12
+  --> tests/ui/unnested_or_patterns.rs:38:12
    |
 LL |     if let [0] | [1] = [0] {}
    |            ^^^^^^^^^
@@ -109,7 +109,7 @@ LL +     if let [0 | 1] = [0] {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:35:12
+  --> tests/ui/unnested_or_patterns.rs:40:12
    |
 LL |     if let [x, 0] | [x, 1] = [0, 1] {}
    |            ^^^^^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL +     if let [x, 0 | 1] = [0, 1] {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:37:12
+  --> tests/ui/unnested_or_patterns.rs:42:12
    |
 LL |     if let [x, 0] | [x, 1] | [x, 2] = [0, 1] {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -133,7 +133,7 @@ LL +     if let [x, 0 | 1 | 2] = [0, 1] {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:39:12
+  --> tests/ui/unnested_or_patterns.rs:44:12
    |
 LL |     if let [x, ..] | [x, 1] | [x, 2] = [0, 1] {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -145,7 +145,7 @@ LL +     if let [x, ..] | [x, 1 | 2] = [0, 1] {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:42:12
+  --> tests/ui/unnested_or_patterns.rs:47:12
    |
 LL |     if let TS(0, x) | TS(1, x) = TS(0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^
@@ -157,7 +157,7 @@ LL +     if let TS(0 | 1, x) = TS(0, 0) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:44:12
+  --> tests/ui/unnested_or_patterns.rs:49:12
    |
 LL |     if let TS(1, 0) | TS(2, 0) | TS(3, 0) = TS(0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -169,7 +169,7 @@ LL +     if let TS(1 | 2 | 3, 0) = TS(0, 0) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:46:12
+  --> tests/ui/unnested_or_patterns.rs:51:12
    |
 LL |     if let TS(x, ..) | TS(x, 1) | TS(x, 2) = TS(0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -181,7 +181,7 @@ LL +     if let TS(x, ..) | TS(x, 1 | 2) = TS(0, 0) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:52:12
+  --> tests/ui/unnested_or_patterns.rs:53:12
    |
 LL |     if let S { x: 0, y } | S { y, x: 1 } = (S { x: 0, y: 1 }) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -193,7 +193,7 @@ LL +     if let S { x: 0 | 1, y } = (S { x: 0, y: 1 }) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:64:12
+  --> tests/ui/unnested_or_patterns.rs:65:12
    |
 LL |     if let [1] | [53] = [0] {}
    |            ^^^^^^^^^^
@@ -205,7 +205,7 @@ LL +     if let [1 | 53] = [0] {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:70:13
+  --> tests/ui/unnested_or_patterns.rs:71:13
    |
 LL |         let (0 | (1 | _)) = 0;
    |             ^^^^^^^^^^^^^
@@ -217,7 +217,7 @@ LL +         let (0 | 1 | _) = 0;
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:73:16
+  --> tests/ui/unnested_or_patterns.rs:74:16
    |
 LL |         if let (0 | (1 | _)) = 0 {}
    |                ^^^^^^^^^^^^^
@@ -229,7 +229,7 @@ LL +         if let (0 | 1 | _) = 0 {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:77:20
+  --> tests/ui/unnested_or_patterns.rs:78:20
    |
 LL |     fn or_in_param((x | (x | x)): i32) {}
    |                    ^^^^^^^^^^^^^
@@ -240,5 +240,17 @@ LL -     fn or_in_param((x | (x | x)): i32) {}
 LL +     fn or_in_param((x | x | x): i32) {}
    |
 
-error: aborting due to 20 previous errors
+error: unnested or-patterns
+  --> tests/ui/unnested_or_patterns.rs:94:12
+   |
+LL |     if let S { y, x: 0 } | S { y, x: 1 } = (S { x: 0, y: 1 }) {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: nest the patterns
+   |
+LL -     if let S { y, x: 0 } | S { y, x: 1 } = (S { x: 0, y: 1 }) {}
+LL +     if let S { y, x: 0 | 1 } = (S { x: 0, y: 1 }) {}
+   |
+
+error: aborting due to 21 previous errors
 
diff --git a/tests/ui/unused_unit.edition2021.fixed b/tests/ui/unused_unit.edition2021.fixed
index def8ef86e3c57..8e12bd2c8c7b9 100644
--- a/tests/ui/unused_unit.edition2021.fixed
+++ b/tests/ui/unused_unit.edition2021.fixed
@@ -127,14 +127,10 @@ mod issue14577 {
     trait Unit {}
     impl Unit for () {}
 
-    fn run<R: Unit>(f: impl FnOnce() -> R) {
-        f();
-    }
-
     #[allow(dependency_on_unit_never_type_fallback)]
     fn bar() {
-        run(|| { todo!() }); 
         //~[edition2021]^ unused_unit
+        panic!()
     }
 
     struct UnitStruct;
@@ -150,3 +146,24 @@ mod pr14962 {
     type UnusedParensButNoUnit = Box<dyn (Fn())>;
 }
 
+
+mod issue15035 {
+
+    trait Convert<T> {
+        fn from(value: T) -> Self;
+    }
+
+    impl Convert<u64> for () {
+        fn from(_value: u64) -> Self {}
+    }
+
+    fn handle<T: Convert<u64>>(value: u64) -> T {
+        Convert::from(value)
+    }
+
+    pub fn f() -> Option<bool> {
+        let result: Result<bool, u64> = Err(42);
+        // the `-> ()` is required for the inference of `handle`'s return type
+        result.map_err(|err| -> () { handle(err) }).ok()
+    }
+}
diff --git a/tests/ui/unused_unit.edition2021.stderr b/tests/ui/unused_unit.edition2021.stderr
index 13cc20d4d7adc..9ad3c2df915ec 100644
--- a/tests/ui/unused_unit.edition2021.stderr
+++ b/tests/ui/unused_unit.edition2021.stderr
@@ -119,10 +119,10 @@ LL | fn test3()-> (){}
    |           ^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> tests/ui/unused_unit.rs:136:15
+  --> tests/ui/unused_unit.rs:131:13
    |
-LL |         run(|| -> () { todo!() }); 
-   |               ^^^^^^ help: remove the `-> ()`
+LL |     fn bar() -> () {
+   |             ^^^^^^ help: remove the `-> ()`
 
 error: aborting due to 20 previous errors
 
diff --git a/tests/ui/unused_unit.edition2024.fixed b/tests/ui/unused_unit.edition2024.fixed
index f908b958b191e..688d2fe9afa28 100644
--- a/tests/ui/unused_unit.edition2024.fixed
+++ b/tests/ui/unused_unit.edition2024.fixed
@@ -127,14 +127,10 @@ mod issue14577 {
     trait Unit {}
     impl Unit for () {}
 
-    fn run<R: Unit>(f: impl FnOnce() -> R) {
-        f();
-    }
-
     #[allow(dependency_on_unit_never_type_fallback)]
-    fn bar() {
-        run(|| -> () { todo!() }); 
+    fn bar() -> () {
         //~[edition2021]^ unused_unit
+        panic!()
     }
 
     struct UnitStruct;
@@ -150,3 +146,24 @@ mod pr14962 {
     type UnusedParensButNoUnit = Box<dyn (Fn())>;
 }
 
+
+mod issue15035 {
+
+    trait Convert<T> {
+        fn from(value: T) -> Self;
+    }
+
+    impl Convert<u64> for () {
+        fn from(_value: u64) -> Self {}
+    }
+
+    fn handle<T: Convert<u64>>(value: u64) -> T {
+        Convert::from(value)
+    }
+
+    pub fn f() -> Option<bool> {
+        let result: Result<bool, u64> = Err(42);
+        // the `-> ()` is required for the inference of `handle`'s return type
+        result.map_err(|err| -> () { handle(err) }).ok()
+    }
+}
diff --git a/tests/ui/unused_unit.rs b/tests/ui/unused_unit.rs
index 7298ec40cc28b..31e980f2655c6 100644
--- a/tests/ui/unused_unit.rs
+++ b/tests/ui/unused_unit.rs
@@ -127,14 +127,10 @@ mod issue14577 {
     trait Unit {}
     impl Unit for () {}
 
-    fn run<R: Unit>(f: impl FnOnce() -> R) {
-        f();
-    }
-
     #[allow(dependency_on_unit_never_type_fallback)]
-    fn bar() {
-        run(|| -> () { todo!() }); 
+    fn bar() -> () {
         //~[edition2021]^ unused_unit
+        panic!()
     }
 
     struct UnitStruct;
@@ -150,3 +146,24 @@ mod pr14962 {
     type UnusedParensButNoUnit = Box<dyn (Fn())>;
 }
 
+
+mod issue15035 {
+
+    trait Convert<T> {
+        fn from(value: T) -> Self;
+    }
+
+    impl Convert<u64> for () {
+        fn from(_value: u64) -> Self {}
+    }
+
+    fn handle<T: Convert<u64>>(value: u64) -> T {
+        Convert::from(value)
+    }
+
+    pub fn f() -> Option<bool> {
+        let result: Result<bool, u64> = Err(42);
+        // the `-> ()` is required for the inference of `handle`'s return type
+        result.map_err(|err| -> () { handle(err) }).ok()
+    }
+}
diff --git a/tests/ui/unwrap_in_result.rs b/tests/ui/unwrap_in_result.rs
index 4e872c67b423e..70c28fe54f37d 100644
--- a/tests/ui/unwrap_in_result.rs
+++ b/tests/ui/unwrap_in_result.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::unwrap_in_result)]
+#![allow(clippy::ok_expect)]
 
 struct A;
 
@@ -20,10 +21,9 @@ impl A {
 
     // should be detected
     fn bad_divisible_by_3(i_str: String) -> Result<bool, String> {
-        //~^ unwrap_in_result
-
         // checks whether a string represents a number divisible by 3
         let i = i_str.parse::<i32>().unwrap();
+        //~^ unwrap_in_result
         if i % 3 == 0 {
             Ok(true)
         } else {
@@ -32,9 +32,8 @@ impl A {
     }
 
     fn example_option_expect(i_str: String) -> Option<bool> {
+        let i = i_str.parse::<i32>().ok().expect("not a number");
         //~^ unwrap_in_result
-
-        let i = i_str.parse::<i32>().expect("not a number");
         if i % 3 == 0 {
             return Some(true);
         }
@@ -42,13 +41,66 @@ impl A {
     }
 
     fn in_closure(a: Option<bool>) -> Option<bool> {
-        //~^ unwrap_in_result
+        // No lint inside a closure
         let c = || a.unwrap();
-        Some(c())
+
+        // But lint outside
+        let a = c().then_some(true);
+        let _ = a.unwrap();
+        //~^ unwrap_in_result
+
+        None
     }
+
+    const fn in_const_inside_fn() -> bool {
+        const A: bool = {
+            const fn inner(b: Option<bool>) -> Option<bool> {
+                Some(b.unwrap())
+                //~^ unwrap_in_result
+            }
+
+            // No lint inside `const`
+            inner(Some(true)).unwrap()
+        };
+        A
+    }
+
+    fn in_static_inside_fn() -> bool {
+        static A: bool = {
+            const fn inner(b: Option<bool>) -> Option<bool> {
+                Some(b.unwrap())
+                //~^ unwrap_in_result
+            }
+
+            // No lint inside `static`
+            inner(Some(true)).unwrap()
+        };
+        A
+    }
+}
+
+macro_rules! mac {
+    () => {
+        Option::unwrap(Some(3))
+    };
+}
+
+fn type_relative_unwrap() -> Option<()> {
+    _ = Option::unwrap(Some(3));
+    //~^ unwrap_in_result
+
+    // Do not lint macro output
+    _ = mac!();
+
+    None
 }
 
-fn main() {
-    A::bad_divisible_by_3("3".to_string());
-    A::good_divisible_by_3("3".to_string());
+fn main() -> Result<(), ()> {
+    A::bad_divisible_by_3("3".to_string()).unwrap();
+    //~^ unwrap_in_result
+    A::good_divisible_by_3("3".to_string()).unwrap();
+    //~^ unwrap_in_result
+    Result::unwrap(A::good_divisible_by_3("3".to_string()));
+    //~^ unwrap_in_result
+    Ok(())
 }
diff --git a/tests/ui/unwrap_in_result.stderr b/tests/ui/unwrap_in_result.stderr
index 5e3eab813e075..804b44246dc70 100644
--- a/tests/ui/unwrap_in_result.stderr
+++ b/tests/ui/unwrap_in_result.stderr
@@ -1,55 +1,107 @@
-error: used unwrap or expect in a function that returns result or option
-  --> tests/ui/unwrap_in_result.rs:22:5
-   |
-LL | /     fn bad_divisible_by_3(i_str: String) -> Result<bool, String> {
-...  |
-LL | |     }
-   | |_____^
-   |
-   = help: unwrap and expect should not be used in a function that returns result or option
-note: potential non-recoverable error(s)
-  --> tests/ui/unwrap_in_result.rs:26:17
+error: `unwrap` used in a function that returns a `Result`
+  --> tests/ui/unwrap_in_result.rs:25:17
    |
 LL |         let i = i_str.parse::<i32>().unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: in this function signature
+  --> tests/ui/unwrap_in_result.rs:23:45
+   |
+LL |     fn bad_divisible_by_3(i_str: String) -> Result<bool, String> {
+   |                                             ^^^^^^^^^^^^^^^^^^^^
+   = help: consider using the `?` operator or calling the `.map_err()` method
    = note: `-D clippy::unwrap-in-result` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::unwrap_in_result)]`
 
-error: used unwrap or expect in a function that returns result or option
-  --> tests/ui/unwrap_in_result.rs:34:5
+error: `expect` used in a function that returns an `Option`
+  --> tests/ui/unwrap_in_result.rs:35:17
+   |
+LL |         let i = i_str.parse::<i32>().ok().expect("not a number");
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: in this function signature
+  --> tests/ui/unwrap_in_result.rs:34:48
+   |
+LL |     fn example_option_expect(i_str: String) -> Option<bool> {
+   |                                                ^^^^^^^^^^^^
+   = help: consider using the `?` operator
+
+error: `unwrap` used in a function that returns an `Option`
+  --> tests/ui/unwrap_in_result.rs:49:17
+   |
+LL |         let _ = a.unwrap();
+   |                 ^^^^^^^^^^
+   |
+note: in this function signature
+  --> tests/ui/unwrap_in_result.rs:43:39
+   |
+LL |     fn in_closure(a: Option<bool>) -> Option<bool> {
+   |                                       ^^^^^^^^^^^^
+   = help: consider using the `?` operator
+
+error: `unwrap` used in a function that returns an `Option`
+  --> tests/ui/unwrap_in_result.rs:58:22
    |
-LL | /     fn example_option_expect(i_str: String) -> Option<bool> {
-LL | |
-LL | |
-LL | |         let i = i_str.parse::<i32>().expect("not a number");
-...  |
-LL | |         None
-LL | |     }
-   | |_____^
+LL |                 Some(b.unwrap())
+   |                      ^^^^^^^^^^
    |
-   = help: unwrap and expect should not be used in a function that returns result or option
-note: potential non-recoverable error(s)
-  --> tests/ui/unwrap_in_result.rs:37:17
+note: in this function signature
+  --> tests/ui/unwrap_in_result.rs:57:48
    |
-LL |         let i = i_str.parse::<i32>().expect("not a number");
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |             const fn inner(b: Option<bool>) -> Option<bool> {
+   |                                                ^^^^^^^^^^^^
+   = help: consider using the `?` operator
 
-error: used unwrap or expect in a function that returns result or option
-  --> tests/ui/unwrap_in_result.rs:44:5
+error: `unwrap` used in a function that returns an `Option`
+  --> tests/ui/unwrap_in_result.rs:71:22
    |
-LL | /     fn in_closure(a: Option<bool>) -> Option<bool> {
-LL | |
-LL | |         let c = || a.unwrap();
-LL | |         Some(c())
-LL | |     }
-   | |_____^
+LL |                 Some(b.unwrap())
+   |                      ^^^^^^^^^^
    |
-   = help: unwrap and expect should not be used in a function that returns result or option
-note: potential non-recoverable error(s)
-  --> tests/ui/unwrap_in_result.rs:46:20
+note: in this function signature
+  --> tests/ui/unwrap_in_result.rs:70:48
+   |
+LL |             const fn inner(b: Option<bool>) -> Option<bool> {
+   |                                                ^^^^^^^^^^^^
+   = help: consider using the `?` operator
+
+error: `unwrap` used in a function that returns an `Option`
+  --> tests/ui/unwrap_in_result.rs:89:9
+   |
+LL |     _ = Option::unwrap(Some(3));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: in this function signature
+  --> tests/ui/unwrap_in_result.rs:88:30
+   |
+LL | fn type_relative_unwrap() -> Option<()> {
+   |                              ^^^^^^^^^^
+   = help: consider using the `?` operator
+
+error: `unwrap` used in a function that returns a `Result`
+  --> tests/ui/unwrap_in_result.rs:99:5
+   |
+LL |     A::bad_divisible_by_3("3".to_string()).unwrap();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: in this function signature
+  --> tests/ui/unwrap_in_result.rs:98:14
+   |
+LL | fn main() -> Result<(), ()> {
+   |              ^^^^^^^^^^^^^^
+   = help: consider using the `?` operator or calling the `.map_err()` method
+
+error: `unwrap` used in a function that returns a `Result`
+  --> tests/ui/unwrap_in_result.rs:101:5
+   |
+LL |     A::good_divisible_by_3("3".to_string()).unwrap();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: `unwrap` used in a function that returns a `Result`
+  --> tests/ui/unwrap_in_result.rs:103:5
    |
-LL |         let c = || a.unwrap();
-   |                    ^^^^^^^^^^
+LL |     Result::unwrap(A::good_divisible_by_3("3".to_string()));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 3 previous errors
+error: aborting due to 9 previous errors
 
diff --git a/tests/ui/vec.fixed b/tests/ui/vec.fixed
index f360a8afadf61..55742459c92cf 100644
--- a/tests/ui/vec.fixed
+++ b/tests/ui/vec.fixed
@@ -242,3 +242,12 @@ fn issue_12101() {
     for a in &[1, 2] {}
     //~^ useless_vec
 }
+
+fn issue_14531() {
+    // The lint used to suggest using an array rather than a reference to a slice.
+
+    fn requires_ref_slice(v: &[()]) {}
+    let v = &[];
+    //~^ useless_vec
+    requires_ref_slice(v);
+}
diff --git a/tests/ui/vec.rs b/tests/ui/vec.rs
index a779d33557cb4..fbf7131323c3b 100644
--- a/tests/ui/vec.rs
+++ b/tests/ui/vec.rs
@@ -242,3 +242,12 @@ fn issue_12101() {
     for a in &(vec![1, 2]) {}
     //~^ useless_vec
 }
+
+fn issue_14531() {
+    // The lint used to suggest using an array rather than a reference to a slice.
+
+    fn requires_ref_slice(v: &[()]) {}
+    let v = &vec![];
+    //~^ useless_vec
+    requires_ref_slice(v);
+}
diff --git a/tests/ui/vec.stderr b/tests/ui/vec.stderr
index 806d6617200ff..d16c8a8944a24 100644
--- a/tests/ui/vec.stderr
+++ b/tests/ui/vec.stderr
@@ -127,5 +127,11 @@ error: useless use of `vec!`
 LL |     for a in &(vec![1, 2]) {}
    |              ^^^^^^^^^^^^^ help: you can use a slice directly: `&[1, 2]`
 
-error: aborting due to 21 previous errors
+error: useless use of `vec!`
+  --> tests/ui/vec.rs:250:13
+   |
+LL |     let v = &vec![];
+   |             ^^^^^^^ help: you can use a slice directly: `&[]`
+
+error: aborting due to 22 previous errors
 
diff --git a/triagebot.toml b/triagebot.toml
index 805baf2af6dd0..7b19f8658c088 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -49,11 +49,18 @@ new_pr = true
 # These labels are set when there are unresolved concerns, removed otherwise
 labels = ["S-waiting-on-concerns"]
 
+# Show differences when a PR is rebased
+[range-diff]
+
+# Amend a review to include a link to what was changed since the review
+[review-changes-since]
+
 [assign]
 contributing_url = "https://github.com/rust-lang/rust-clippy/blob/master/CONTRIBUTING.md"
 users_on_vacation = [
     "matthiaskrgr",
     "Manishearth",
+    "flip1995",
 ]
 
 [assign.owners]

From ec34e8e69fb2e133e6ec0ebc87443f6fa8bda092 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Fri, 5 Sep 2025 06:30:28 +0800
Subject: [PATCH 0506/1889] Fix precedence parenthesis for replace_arith_op

Example
---
```rust
fn main() {
    let x = 1*x $0+ 2;
}
```

**Before this PR**:

```rust
fn main() {
    let x = 1*x.wrapping_add(2);
}
```

**After this PR**:

```rust
fn main() {
    let x = (1*x).wrapping_add(2);
}
```
---
 .../src/handlers/replace_arith_op.rs          | 23 ++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_arith_op.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_arith_op.rs
index 440ab4d4604f2..94ac1c342d302 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_arith_op.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_arith_op.rs
@@ -88,7 +88,11 @@ fn replace_arith(acc: &mut Assists, ctx: &AssistContext<'_>, kind: ArithKind) ->
         |builder| {
             let method_name = kind.method_name(op);
 
-            builder.replace(range, format!("{lhs}.{method_name}({rhs})"))
+            if lhs.precedence().needs_parentheses_in(ast::prec::ExprPrecedence::Postfix) {
+                builder.replace(range, format!("({lhs}).{method_name}({rhs})"))
+            } else {
+                builder.replace(range, format!("{lhs}.{method_name}({rhs})"))
+            }
         },
     )
 }
@@ -227,6 +231,23 @@ fn main() {
         )
     }
 
+    #[test]
+    fn replace_arith_with_wrapping_add_add_parenthesis() {
+        check_assist(
+            replace_arith_with_wrapping,
+            r#"
+fn main() {
+    let x = 1*x $0+ 2;
+}
+"#,
+            r#"
+fn main() {
+    let x = (1*x).wrapping_add(2);
+}
+"#,
+        )
+    }
+
     #[test]
     fn replace_arith_not_applicable_with_non_empty_selection() {
         check_assist_not_applicable(

From 81557349be64db933c5060a6e1d7398bef32e0d7 Mon Sep 17 00:00:00 2001
From: Scott Schafer <schaferjscott@gmail.com>
Date: Wed, 27 Aug 2025 20:33:50 -0600
Subject: [PATCH 0507/1889] refactor: Move assert for disjoint substitution
 spans

---
 compiler/rustc_errors/src/emitter.rs | 1 -
 compiler/rustc_errors/src/lib.rs     | 6 ++++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_errors/src/emitter.rs b/compiler/rustc_errors/src/emitter.rs
index b94370e8e9b40..93b1e6b761520 100644
--- a/compiler/rustc_errors/src/emitter.rs
+++ b/compiler/rustc_errors/src/emitter.rs
@@ -2354,7 +2354,6 @@ impl HumanEmitter {
                         .sum();
                     let underline_start = (span_start_pos + start) as isize + offset;
                     let underline_end = (span_start_pos + start + sub_len) as isize + offset;
-                    assert!(underline_start >= 0 && underline_end >= 0);
                     let padding: usize = max_line_num_len + 3;
                     for p in underline_start..underline_end {
                         if let DisplaySuggestion::Underline = show_code_change
diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
index a56e0f3fae132..7d8577ac2c268 100644
--- a/compiler/rustc_errors/src/lib.rs
+++ b/compiler/rustc_errors/src/lib.rs
@@ -381,6 +381,12 @@ impl CodeSuggestion {
                 // Assumption: all spans are in the same file, and all spans
                 // are disjoint. Sort in ascending order.
                 substitution.parts.sort_by_key(|part| part.span.lo());
+                // Verify the assumption that all spans are disjoint
+                assert_eq!(
+                    substitution.parts.array_windows().find(|[a, b]| a.span.overlaps(b.span)),
+                    None,
+                    "all spans must be disjoint",
+                );
 
                 // Find the bounding span.
                 let lo = substitution.parts.iter().map(|part| part.span.lo()).min()?;

From f196f50d6609eecfe94989a317a8779637288d94 Mon Sep 17 00:00:00 2001
From: Scott Schafer <schaferjscott@gmail.com>
Date: Thu, 4 Sep 2025 16:21:44 -0600
Subject: [PATCH 0508/1889] chore: Remove redundant disjoint spans assert

---
 compiler/rustc_errors/src/diagnostic.rs | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/compiler/rustc_errors/src/diagnostic.rs b/compiler/rustc_errors/src/diagnostic.rs
index 96a4ed3218fbf..ae23ef1e25536 100644
--- a/compiler/rustc_errors/src/diagnostic.rs
+++ b/compiler/rustc_errors/src/diagnostic.rs
@@ -945,11 +945,6 @@ impl<'a, G: EmissionGuarantee> Diag<'a, G> {
             None,
             "Span must not be empty and have no suggestion",
         );
-        debug_assert_eq!(
-            parts.array_windows().find(|[a, b]| a.span.overlaps(b.span)),
-            None,
-            "suggestion must not have overlapping parts",
-        );
 
         self.push_suggestion(CodeSuggestion {
             substitutions: vec![Substitution { parts }],

From b307a1146b4af3b5808510e44a13f56f2b0252e9 Mon Sep 17 00:00:00 2001
From: Scott Schafer <schaferjscott@gmail.com>
Date: Wed, 27 Aug 2025 20:33:50 -0600
Subject: [PATCH 0509/1889] fix: Filter suggestion parts that match existing
 code

---
 compiler/rustc_errors/src/lib.rs              | 21 ++++++++++---------
 .../tests/ui/bool_assert_comparison.stderr    | 12 ++++-------
 2 files changed, 15 insertions(+), 18 deletions(-)

diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
index 7d8577ac2c268..8869799ce90d9 100644
--- a/compiler/rustc_errors/src/lib.rs
+++ b/compiler/rustc_errors/src/lib.rs
@@ -388,6 +388,11 @@ impl CodeSuggestion {
                     "all spans must be disjoint",
                 );
 
+                // Account for cases where we are suggesting the same code that's already
+                // there. This shouldn't happen often, but in some cases for multipart
+                // suggestions it's much easier to handle it here than in the origin.
+                substitution.parts.retain(|p| is_different(sm, &p.snippet, p.span));
+
                 // Find the bounding span.
                 let lo = substitution.parts.iter().map(|part| part.span.lo()).min()?;
                 let hi = substitution.parts.iter().map(|part| part.span.hi()).max()?;
@@ -476,16 +481,12 @@ impl CodeSuggestion {
                             _ => 1,
                         })
                         .sum();
-                    if !is_different(sm, &part.snippet, part.span) {
-                        // Account for cases where we are suggesting the same code that's already
-                        // there. This shouldn't happen often, but in some cases for multipart
-                        // suggestions it's much easier to handle it here than in the origin.
-                    } else {
-                        line_highlight.push(SubstitutionHighlight {
-                            start: (cur_lo.col.0 as isize + acc) as usize,
-                            end: (cur_lo.col.0 as isize + acc + len) as usize,
-                        });
-                    }
+
+                    line_highlight.push(SubstitutionHighlight {
+                        start: (cur_lo.col.0 as isize + acc) as usize,
+                        end: (cur_lo.col.0 as isize + acc + len) as usize,
+                    });
+
                     buf.push_str(&part.snippet);
                     let cur_hi = sm.lookup_char_pos(part.span.hi());
                     // Account for the difference between the width of the current code and the
diff --git a/src/tools/clippy/tests/ui/bool_assert_comparison.stderr b/src/tools/clippy/tests/ui/bool_assert_comparison.stderr
index f823f08f31dca..72aa6303a2026 100644
--- a/src/tools/clippy/tests/ui/bool_assert_comparison.stderr
+++ b/src/tools/clippy/tests/ui/bool_assert_comparison.stderr
@@ -272,10 +272,8 @@ LL |     assert_eq!(a!(), true);
    |
 help: replace it with `assert!(..)`
    |
-LL |         true
-...
-LL |
-LL ~     assert!(a!());
+LL -     assert_eq!(a!(), true);
+LL +     assert!(a!());
    |
 
 error: used `assert_eq!` with a literal bool
@@ -286,10 +284,8 @@ LL |     assert_eq!(true, b!());
    |
 help: replace it with `assert!(..)`
    |
-LL |         true
-...
-LL |
-LL ~     assert!(b!());
+LL -     assert_eq!(true, b!());
+LL +     assert!(b!());
    |
 
 error: used `debug_assert_eq!` with a literal bool

From b2eb28da2342e60779a6d78d19c991c99e1b5c37 Mon Sep 17 00:00:00 2001
From: Scott Schafer <schaferjscott@gmail.com>
Date: Wed, 27 Aug 2025 20:33:50 -0600
Subject: [PATCH 0510/1889] fix: Filter suggestion parts that match existing
 code

---
 tests/ui/bool_assert_comparison.stderr | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/tests/ui/bool_assert_comparison.stderr b/tests/ui/bool_assert_comparison.stderr
index f823f08f31dca..72aa6303a2026 100644
--- a/tests/ui/bool_assert_comparison.stderr
+++ b/tests/ui/bool_assert_comparison.stderr
@@ -272,10 +272,8 @@ LL |     assert_eq!(a!(), true);
    |
 help: replace it with `assert!(..)`
    |
-LL |         true
-...
-LL |
-LL ~     assert!(a!());
+LL -     assert_eq!(a!(), true);
+LL +     assert!(a!());
    |
 
 error: used `assert_eq!` with a literal bool
@@ -286,10 +284,8 @@ LL |     assert_eq!(true, b!());
    |
 help: replace it with `assert!(..)`
    |
-LL |         true
-...
-LL |
-LL ~     assert!(b!());
+LL -     assert_eq!(true, b!());
+LL +     assert!(b!());
    |
 
 error: used `debug_assert_eq!` with a literal bool

From 7ce8e289db72471c41b53664a214ed0e00458f07 Mon Sep 17 00:00:00 2001
From: ltdk <usr@ltdk.xyz>
Date: Wed, 13 Aug 2025 12:38:11 -0400
Subject: [PATCH 0511/1889] Add `Path::has_trailing_sep` and related methods

---
 library/std/src/path.rs   | 187 +++++++++++++++++++++++++++++++++++++-
 library/std/tests/path.rs |  38 +++++++-
 2 files changed, 221 insertions(+), 4 deletions(-)

diff --git a/library/std/src/path.rs b/library/std/src/path.rs
index 19663e4a9df62..943c40220b848 100644
--- a/library/std/src/path.rs
+++ b/library/std/src/path.rs
@@ -1412,6 +1412,99 @@ impl PathBuf {
         }
     }
 
+    /// Sets whether the path has a trailing [separator](MAIN_SEPARATOR).
+    ///
+    /// The value returned by [`has_trailing_sep`](Path::has_trailing_sep) will be equivalent to
+    /// the provided value if possible.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(path_trailing_sep)]
+    /// use std::path::PathBuf;
+    ///
+    /// let mut p = PathBuf::from("dir");
+    ///
+    /// assert!(!p.has_trailing_sep());
+    /// p.set_trailing_sep(false);
+    /// assert!(!p.has_trailing_sep());
+    /// p.set_trailing_sep(true);
+    /// assert!(p.has_trailing_sep());
+    /// p.set_trailing_sep(false);
+    /// assert!(!p.has_trailing_sep());
+    ///
+    /// p = PathBuf::from("/");
+    /// assert!(p.has_trailing_sep());
+    /// p.set_trailing_sep(false);
+    /// assert!(p.has_trailing_sep());
+    /// ```
+    #[unstable(feature = "path_trailing_sep", issue = "142503")]
+    pub fn set_trailing_sep(&mut self, trailing_sep: bool) {
+        if trailing_sep { self.push_trailing_sep() } else { self.pop_trailing_sep() }
+    }
+
+    /// Adds a trailing [separator](MAIN_SEPARATOR) to the path.
+    ///
+    /// This acts similarly to [`Path::with_trailing_sep`], but mutates the underlying `PathBuf`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(path_trailing_sep)]
+    /// use std::ffi::OsStr;
+    /// use std::path::PathBuf;
+    ///
+    /// let mut p = PathBuf::from("dir");
+    ///
+    /// assert!(!p.has_trailing_sep());
+    /// p.push_trailing_sep();
+    /// assert!(p.has_trailing_sep());
+    /// p.push_trailing_sep();
+    /// assert!(p.has_trailing_sep());
+    ///
+    /// p = PathBuf::from("dir/");
+    /// p.push_trailing_sep();
+    /// assert_eq!(p.as_os_str(), OsStr::new("dir/"));
+    /// ```
+    #[unstable(feature = "path_trailing_sep", issue = "142503")]
+    pub fn push_trailing_sep(&mut self) {
+        if !self.has_trailing_sep() {
+            self.push("");
+        }
+    }
+
+    /// Removes a trailing [separator](MAIN_SEPARATOR) from the path, if possible.
+    ///
+    /// This acts similarly to [`Path::trim_trailing_sep`], but mutates the underlying `PathBuf`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(path_trailing_sep)]
+    /// use std::ffi::OsStr;
+    /// use std::path::PathBuf;
+    ///
+    /// let mut p = PathBuf::from("dir//");
+    ///
+    /// assert!(p.has_trailing_sep());
+    /// assert_eq!(p.as_os_str(), OsStr::new("dir//"));
+    /// p.pop_trailing_sep();
+    /// assert!(!p.has_trailing_sep());
+    /// assert_eq!(p.as_os_str(), OsStr::new("dir"));
+    /// p.pop_trailing_sep();
+    /// assert!(!p.has_trailing_sep());
+    /// assert_eq!(p.as_os_str(), OsStr::new("dir"));
+    ///
+    /// p = PathBuf::from("/");
+    /// assert!(p.has_trailing_sep());
+    /// p.pop_trailing_sep();
+    /// assert!(p.has_trailing_sep());
+    /// ```
+    #[unstable(feature = "path_trailing_sep", issue = "142503")]
+    pub fn pop_trailing_sep(&mut self) {
+        self.inner.truncate(self.trim_trailing_sep().as_os_str().len());
+    }
+
     /// Updates [`self.file_name`] to `file_name`.
     ///
     /// If [`self.file_name`] was [`None`], this is equivalent to pushing
@@ -1610,7 +1703,7 @@ impl PathBuf {
         let new = extension.as_encoded_bytes();
         if !new.is_empty() {
             // truncate until right after the file name
-            // this is necessary for trimming the trailing slash
+            // this is necessary for trimming the trailing separator
             let end_file_name = file_name[file_name.len()..].as_ptr().addr();
             let start = self.inner.as_encoded_bytes().as_ptr().addr();
             self.inner.truncate(end_file_name.wrapping_sub(start));
@@ -2755,6 +2848,94 @@ impl Path {
         self.file_name().map(rsplit_file_at_dot).and_then(|(before, after)| before.and(after))
     }
 
+    /// Checks whether the path ends in a trailing [separator](MAIN_SEPARATOR).
+    ///
+    /// This is generally done to ensure that a path is treated as a directory, not a file,
+    /// although it does not actually guarantee that such a path is a directory on the underlying
+    /// file system.
+    ///
+    /// Despite this behavior, two paths are still considered the same in Rust whether they have a
+    /// trailing separator or not.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(path_trailing_sep)]
+    /// use std::path::Path;
+    ///
+    /// assert!(Path::new("dir/").has_trailing_sep());
+    /// assert!(!Path::new("file.rs").has_trailing_sep());
+    /// ```
+    #[unstable(feature = "path_trailing_sep", issue = "142503")]
+    #[must_use]
+    #[inline]
+    pub fn has_trailing_sep(&self) -> bool {
+        self.as_os_str().as_encoded_bytes().last().copied().is_some_and(is_sep_byte)
+    }
+
+    /// Ensures that a path has a trailing [separator](MAIN_SEPARATOR),
+    /// allocating a [`PathBuf`] if necessary.
+    ///
+    /// The resulting path will return true for [`has_trailing_sep`](Self::has_trailing_sep).
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(path_trailing_sep)]
+    /// use std::ffi::OsStr;
+    /// use std::path::Path;
+    ///
+    /// assert_eq!(Path::new("dir//").with_trailing_sep().as_os_str(), OsStr::new("dir//"));
+    /// assert_eq!(Path::new("dir/").with_trailing_sep().as_os_str(), OsStr::new("dir/"));
+    /// assert!(!Path::new("dir").has_trailing_sep());
+    /// assert!(Path::new("dir").with_trailing_sep().has_trailing_sep());
+    /// ```
+    #[unstable(feature = "path_trailing_sep", issue = "142503")]
+    #[must_use]
+    #[inline]
+    pub fn with_trailing_sep(&self) -> Cow<'_, Path> {
+        if self.has_trailing_sep() { Cow::Borrowed(self) } else { Cow::Owned(self.join("")) }
+    }
+
+    /// Trims a trailing [separator](MAIN_SEPARATOR) from a path, if possible.
+    ///
+    /// The resulting path will return false for [`has_trailing_sep`](Self::has_trailing_sep) for
+    /// most paths.
+    ///
+    /// Some paths, like `/`, cannot be trimmed in this way.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(path_trailing_sep)]
+    /// use std::ffi::OsStr;
+    /// use std::path::Path;
+    ///
+    /// assert_eq!(Path::new("dir//").trim_trailing_sep().as_os_str(), OsStr::new("dir"));
+    /// assert_eq!(Path::new("dir/").trim_trailing_sep().as_os_str(), OsStr::new("dir"));
+    /// assert_eq!(Path::new("dir").trim_trailing_sep().as_os_str(), OsStr::new("dir"));
+    /// assert_eq!(Path::new("/").trim_trailing_sep().as_os_str(), OsStr::new("/"));
+    /// assert_eq!(Path::new("//").trim_trailing_sep().as_os_str(), OsStr::new("//"));
+    /// ```
+    #[unstable(feature = "path_trailing_sep", issue = "142503")]
+    #[must_use]
+    #[inline]
+    pub fn trim_trailing_sep(&self) -> &Path {
+        if self.has_trailing_sep() && (!self.has_root() || self.parent().is_some()) {
+            let mut bytes = self.inner.as_encoded_bytes();
+            while let Some((last, init)) = bytes.split_last()
+                && is_sep_byte(*last)
+            {
+                bytes = init;
+            }
+
+            // SAFETY: Trimming trailing ASCII bytes will retain the validity of the string.
+            Path::new(unsafe { OsStr::from_encoded_bytes_unchecked(bytes) })
+        } else {
+            self
+        }
+    }
+
     /// Creates an owned [`PathBuf`] with `path` adjoined to `self`.
     ///
     /// If `path` is absolute, it replaces the current path.
@@ -2907,7 +3088,7 @@ impl Path {
     ///   `a/b` all have `a` and `b` as components, but `./a/b` starts with
     ///   an additional [`CurDir`] component.
     ///
-    /// * A trailing slash is normalized away, `/a/b` and `/a/b/` are equivalent.
+    /// * Trailing separators are normalized away, so `/a/b` and `/a/b/` are equivalent.
     ///
     /// Note that no other normalization takes place; in particular, `a/c`
     /// and `a/b/../c` are distinct, to account for the possibility that `b`
@@ -3710,7 +3891,7 @@ impl Error for NormalizeError {}
 ///
 /// On POSIX platforms, the path is resolved using [POSIX semantics][posix-semantics],
 /// except that it stops short of resolving symlinks. This means it will keep `..`
-/// components and trailing slashes.
+/// components and trailing separators.
 ///
 /// On Windows, for verbatim paths, this will simply return the path as given. For other
 /// paths, this is currently equivalent to calling
diff --git a/library/std/tests/path.rs b/library/std/tests/path.rs
index fa76c50597b05..1d3337ff935a8 100644
--- a/library/std/tests/path.rs
+++ b/library/std/tests/path.rs
@@ -1,4 +1,9 @@
-#![feature(clone_to_uninit, maybe_uninit_slice, normalize_lexically)]
+// tidy-alphabetical-start
+#![feature(clone_to_uninit)]
+#![feature(maybe_uninit_slice)]
+#![feature(normalize_lexically)]
+#![feature(path_trailing_sep)]
+// tidy-alphabetical-end
 
 use std::clone::CloneToUninit;
 use std::ffi::OsStr;
@@ -2532,3 +2537,34 @@ fn normalize_lexically() {
 fn compare_path_to_str() {
     assert!(&PathBuf::from("x") == "x");
 }
+
+#[test]
+fn test_trim_trailing_sep() {
+    assert_eq!(Path::new("/").trim_trailing_sep().as_os_str(), OsStr::new("/"));
+    assert_eq!(Path::new("//").trim_trailing_sep().as_os_str(), OsStr::new("//"));
+    assert_eq!(Path::new("").trim_trailing_sep().as_os_str(), OsStr::new(""));
+    assert_eq!(Path::new(".").trim_trailing_sep().as_os_str(), OsStr::new("."));
+    assert_eq!(Path::new("./").trim_trailing_sep().as_os_str(), OsStr::new("."));
+    assert_eq!(Path::new(".//").trim_trailing_sep().as_os_str(), OsStr::new("."));
+    assert_eq!(Path::new("..").trim_trailing_sep().as_os_str(), OsStr::new(".."));
+    assert_eq!(Path::new("../").trim_trailing_sep().as_os_str(), OsStr::new(".."));
+    assert_eq!(Path::new("..//").trim_trailing_sep().as_os_str(), OsStr::new(".."));
+
+    #[cfg(any(windows, target_os = "cygwin"))]
+    {
+        assert_eq!(Path::new("\\").trim_trailing_sep().as_os_str(), OsStr::new("\\"));
+        assert_eq!(Path::new("\\\\").trim_trailing_sep().as_os_str(), OsStr::new("\\\\"));
+        assert_eq!(Path::new("c:/").trim_trailing_sep().as_os_str(), OsStr::new("c:/"));
+        assert_eq!(Path::new("c://").trim_trailing_sep().as_os_str(), OsStr::new("c://"));
+        assert_eq!(Path::new("c:./").trim_trailing_sep().as_os_str(), OsStr::new("c:."));
+        assert_eq!(Path::new("c:.//").trim_trailing_sep().as_os_str(), OsStr::new("c:."));
+        assert_eq!(Path::new("c:../").trim_trailing_sep().as_os_str(), OsStr::new("c:.."));
+        assert_eq!(Path::new("c:..//").trim_trailing_sep().as_os_str(), OsStr::new("c:.."));
+        assert_eq!(Path::new("c:\\").trim_trailing_sep().as_os_str(), OsStr::new("c:\\"));
+        assert_eq!(Path::new("c:\\\\").trim_trailing_sep().as_os_str(), OsStr::new("c:\\\\"));
+        assert_eq!(Path::new("c:.\\").trim_trailing_sep().as_os_str(), OsStr::new("c:."));
+        assert_eq!(Path::new("c:.\\\\").trim_trailing_sep().as_os_str(), OsStr::new("c:."));
+        assert_eq!(Path::new("c:..\\").trim_trailing_sep().as_os_str(), OsStr::new("c:.."));
+        assert_eq!(Path::new("c:..\\\\").trim_trailing_sep().as_os_str(), OsStr::new("c:.."));
+    }
+}

From 9a1eb85394e3612213e829ed871eb281079a2364 Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Fri, 5 Sep 2025 04:53:05 +0000
Subject: [PATCH 0512/1889] Prepare for merging from rust-lang/rust

This updates the rust-version file to b3cfb8faf84c5f3b7909479a9f9b6a3290d5f4d7.
---
 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 7420b6200967c..a51d86c3d6f15 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-9385c64c95d971329e62917adc4349c8ccdbafe0
+b3cfb8faf84c5f3b7909479a9f9b6a3290d5f4d7

From bc17bcdef005f427c74a39161dcfd1cd5d3b1a3c Mon Sep 17 00:00:00 2001
From: Jules Bertholet <julesbertholet@quoi.xyz>
Date: Fri, 5 Sep 2025 02:01:18 -0400
Subject: [PATCH 0513/1889] Simplify `{f16, f32, f54, f128}::midpoint()`

`(float_ty::MAX / 2) - (float_ty::MIN_POSITIVE * 2)` equals
`(float_ty::MAX / 2) + (float_ty::MIN_POSITIVE * 2)` equals
`(float_ty::MAX / 2)`. So these branches are pointless
---
 library/core/src/num/f128.rs | 8 --------
 library/core/src/num/f16.rs  | 8 --------
 library/core/src/num/f32.rs  | 8 --------
 library/core/src/num/f64.rs  | 8 --------
 4 files changed, 32 deletions(-)

diff --git a/library/core/src/num/f128.rs b/library/core/src/num/f128.rs
index 4282b1af9f206..66c892aadd083 100644
--- a/library/core/src/num/f128.rs
+++ b/library/core/src/num/f128.rs
@@ -832,7 +832,6 @@ impl f128 {
     #[unstable(feature = "f128", issue = "116909")]
     #[rustc_const_unstable(feature = "f128", issue = "116909")]
     pub const fn midpoint(self, other: f128) -> f128 {
-        const LO: f128 = f128::MIN_POSITIVE * 2.;
         const HI: f128 = f128::MAX / 2.;
 
         let (a, b) = (self, other);
@@ -842,14 +841,7 @@ impl f128 {
         if abs_a <= HI && abs_b <= HI {
             // Overflow is impossible
             (a + b) / 2.
-        } else if abs_a < LO {
-            // Not safe to halve `a` (would underflow)
-            a + (b / 2.)
-        } else if abs_b < LO {
-            // Not safe to halve `b` (would underflow)
-            (a / 2.) + b
         } else {
-            // Safe to halve `a` and `b`
             (a / 2.) + (b / 2.)
         }
     }
diff --git a/library/core/src/num/f16.rs b/library/core/src/num/f16.rs
index 23a8661c14b7a..81220065e72a6 100644
--- a/library/core/src/num/f16.rs
+++ b/library/core/src/num/f16.rs
@@ -820,7 +820,6 @@ impl f16 {
     #[unstable(feature = "f16", issue = "116909")]
     #[rustc_const_unstable(feature = "f16", issue = "116909")]
     pub const fn midpoint(self, other: f16) -> f16 {
-        const LO: f16 = f16::MIN_POSITIVE * 2.;
         const HI: f16 = f16::MAX / 2.;
 
         let (a, b) = (self, other);
@@ -830,14 +829,7 @@ impl f16 {
         if abs_a <= HI && abs_b <= HI {
             // Overflow is impossible
             (a + b) / 2.
-        } else if abs_a < LO {
-            // Not safe to halve `a` (would underflow)
-            a + (b / 2.)
-        } else if abs_b < LO {
-            // Not safe to halve `b` (would underflow)
-            (a / 2.) + b
         } else {
-            // Safe to halve `a` and `b`
             (a / 2.) + (b / 2.)
         }
     }
diff --git a/library/core/src/num/f32.rs b/library/core/src/num/f32.rs
index da08bfc595059..4bb0db58fa585 100644
--- a/library/core/src/num/f32.rs
+++ b/library/core/src/num/f32.rs
@@ -1025,7 +1025,6 @@ impl f32 {
                 ((self as f64 + other as f64) / 2.0) as f32
             }
             _ => {
-                const LO: f32 = f32::MIN_POSITIVE * 2.;
                 const HI: f32 = f32::MAX / 2.;
 
                 let (a, b) = (self, other);
@@ -1035,14 +1034,7 @@ impl f32 {
                 if abs_a <= HI && abs_b <= HI {
                     // Overflow is impossible
                     (a + b) / 2.
-                } else if abs_a < LO {
-                    // Not safe to halve `a` (would underflow)
-                    a + (b / 2.)
-                } else if abs_b < LO {
-                    // Not safe to halve `b` (would underflow)
-                    (a / 2.) + b
                 } else {
-                    // Safe to halve `a` and `b`
                     (a / 2.) + (b / 2.)
                 }
             }
diff --git a/library/core/src/num/f64.rs b/library/core/src/num/f64.rs
index dc0977cb1474c..9dd1141e70331 100644
--- a/library/core/src/num/f64.rs
+++ b/library/core/src/num/f64.rs
@@ -1026,7 +1026,6 @@ impl f64 {
     #[stable(feature = "num_midpoint", since = "1.85.0")]
     #[rustc_const_stable(feature = "num_midpoint", since = "1.85.0")]
     pub const fn midpoint(self, other: f64) -> f64 {
-        const LO: f64 = f64::MIN_POSITIVE * 2.;
         const HI: f64 = f64::MAX / 2.;
 
         let (a, b) = (self, other);
@@ -1036,14 +1035,7 @@ impl f64 {
         if abs_a <= HI && abs_b <= HI {
             // Overflow is impossible
             (a + b) / 2.
-        } else if abs_a < LO {
-            // Not safe to halve `a` (would underflow)
-            a + (b / 2.)
-        } else if abs_b < LO {
-            // Not safe to halve `b` (would underflow)
-            (a / 2.) + b
         } else {
-            // Safe to halve `a` and `b`
             (a / 2.) + (b / 2.)
         }
     }

From 5cadd4541c96edf0caaf1847b3c13b1ced4d5121 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 5 Sep 2025 09:07:08 +0200
Subject: [PATCH 0514/1889] make use of Duration::from_nanos_u128

---
 src/tools/miri/src/clock.rs | 9 +--------
 src/tools/miri/src/lib.rs   | 1 +
 2 files changed, 2 insertions(+), 8 deletions(-)

diff --git a/src/tools/miri/src/clock.rs b/src/tools/miri/src/clock.rs
index 34465e9cac60d..47608f873a481 100644
--- a/src/tools/miri/src/clock.rs
+++ b/src/tools/miri/src/clock.rs
@@ -46,14 +46,7 @@ impl Instant {
                 InstantKind::Virtual { nanoseconds: earlier },
             ) => {
                 let duration = nanoseconds.saturating_sub(earlier);
-                // `Duration` does not provide a nice constructor from a `u128` of nanoseconds,
-                // so we have to implement this ourselves.
-                // It is possible for second to overflow because u64::MAX < (u128::MAX / 1e9).
-                // It will be saturated to u64::MAX seconds if the value after division exceeds u64::MAX.
-                let seconds = u64::try_from(duration / 1_000_000_000).unwrap_or(u64::MAX);
-                // It is impossible for nanosecond to overflow because u32::MAX > 1e9.
-                let nanosecond = u32::try_from(duration.wrapping_rem(1_000_000_000)).unwrap();
-                Duration::new(seconds, nanosecond)
+                Duration::from_nanos_u128(duration)
             }
             _ => panic!("all `Instant` must be of the same kind"),
         }
diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
index 0856411b8e836..a00d9525fab54 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -18,6 +18,7 @@
 #![feature(derive_coerce_pointee)]
 #![feature(arbitrary_self_types)]
 #![feature(iter_advance_by)]
+#![feature(duration_from_nanos_u128)]
 // Configure clippy and other lints
 #![allow(
     clippy::collapsible_else_if,

From b9b235acb088aa88d96890c930e174ab56abbccd Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Fri, 5 Sep 2025 15:34:49 +0800
Subject: [PATCH 0515/1889] Fix indent for unresolved_field fixes

Examples
---
```rust
mod indent {
    struct Foo {}

    fn foo() {
        let foo = Foo{};
        foo.bar$0;
    }
}
```

**Before this PR**:

```rust
mod indent {
    struct Foo {        bar: ()
}

    fn foo() {
        let foo = Foo{};
        foo.bar;
    }
}
```

**After this PR**:

```rust
mod indent {
    struct Foo {
        bar: ()
    }

    fn foo() {
        let foo = Foo{};
        foo.bar;
    }
}
```

---
New field list add newline

```rust
mod indent {
    struct Foo;

    fn foo() {
        Foo.bar$0;
    }
}
```

**Before this PR**:

```rust
mod indent {
    struct Foo{ bar: () }

    fn foo() {
        Foo.bar;
    }
}
```

**After this PR**:

```rust
mod indent {
    struct Foo {
        bar: (),
    }

    fn foo() {
        Foo.bar;
    }
}
```
---
 .../src/handlers/unresolved_field.rs          | 65 +++++++++++++++----
 1 file changed, 52 insertions(+), 13 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/unresolved_field.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/unresolved_field.rs
index 690158989679b..358e0c43c2a93 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/unresolved_field.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/unresolved_field.rs
@@ -1,5 +1,3 @@
-use std::iter;
-
 use either::Either;
 use hir::{Adt, FileRange, HasSource, HirDisplay, InFile, Struct, Union, db::ExpandDatabase};
 use ide_db::text_edit::TextEdit;
@@ -194,17 +192,20 @@ fn add_field_to_struct_fix(
                 Some(make::visibility_pub_crate())
             };
             // FIXME: Allow for choosing a visibility modifier see https://github.com/rust-lang/rust-analyzer/issues/11563
-            let indent = IndentLevel::from_node(struct_syntax.value) + 1;
+            let indent = IndentLevel::from_node(struct_syntax.value);
 
-            let field = make::record_field(visibility, field_name, suggested_type).indent(indent);
-            let record_field_list = make::record_field_list(iter::once(field));
+            let field =
+                make::record_field(visibility, field_name, suggested_type).indent(indent + 1);
             // A Unit Struct with no `;` is invalid syntax. We should not suggest this fix.
             let semi_colon =
                 algo::skip_trivia_token(struct_syntax.value.last_token()?, Direction::Prev)?;
             if semi_colon.kind() != SyntaxKind::SEMICOLON {
                 return None;
             }
-            src_change_builder.replace(semi_colon.text_range(), record_field_list.to_string());
+            src_change_builder.replace(
+                semi_colon.text_range(),
+                format!(" {{\n{}{field},\n{indent}}}", indent + 1),
+            );
 
             Some(Assist {
                 id: AssistId::quick_fix("convert-unit-struct-to-record-struct"),
@@ -230,7 +231,7 @@ fn record_field_layout(
     field_list: ast::RecordFieldList,
     struct_syntax: &SyntaxNode,
 ) -> Option<(TextSize, String)> {
-    let (offset, needs_comma, trailing_new_line, indent) = match field_list.fields().last() {
+    let (offset, needs_comma, indent) = match field_list.fields().last() {
         Some(record_field) => {
             let syntax = algo::skip_trivia_token(field_list.r_curly_token()?, Direction::Prev)?;
 
@@ -239,19 +240,22 @@ fn record_field_layout(
             (
                 last_field_syntax.text_range().end(),
                 syntax.kind() != SyntaxKind::COMMA,
-                false,
                 last_field_indent,
             )
         }
         // Empty Struct. Add a field right before the closing brace
         None => {
             let indent = IndentLevel::from_node(struct_syntax) + 1;
-            let offset = field_list.r_curly_token()?.text_range().start();
-            (offset, false, true, indent)
+            let offset = field_list.l_curly_token()?.text_range().end();
+            (offset, false, indent)
         }
     };
-    let comma = if needs_comma { ",\n" } else { "" };
-    let trailing_new_line = if trailing_new_line { "\n" } else { "" };
+    let trailing_new_line = if !field_list.syntax().text().contains_char('\n') {
+        format!("\n{}", field_list.indent_level())
+    } else {
+        String::new()
+    };
+    let comma = if needs_comma { ",\n" } else { "\n" };
     let record_field = make::record_field(visibility, name, suggested_type);
 
     Some((offset, format!("{comma}{indent}{record_field}{trailing_new_line}")))
@@ -377,18 +381,24 @@ fn foo() {
     fn unresolved_field_fix_on_unit() {
         check_fix(
             r#"
+            mod indent {
                 struct Foo;
 
                 fn foo() {
                     Foo.bar$0;
                 }
+            }
             "#,
             r#"
-                struct Foo{ bar: () }
+            mod indent {
+                struct Foo {
+                    bar: (),
+                }
 
                 fn foo() {
                     Foo.bar;
                 }
+            }
             "#,
         );
     }
@@ -396,6 +406,7 @@ fn foo() {
     fn unresolved_field_fix_on_empty() {
         check_fix(
             r#"
+            mod indent {
                 struct Foo{
                 }
 
@@ -403,8 +414,10 @@ fn foo() {
                     let foo = Foo{};
                     foo.bar$0;
                 }
+            }
             "#,
             r#"
+            mod indent {
                 struct Foo{
                     bar: ()
                 }
@@ -413,6 +426,32 @@ fn foo() {
                     let foo = Foo{};
                     foo.bar;
                 }
+            }
+            "#,
+        );
+
+        check_fix(
+            r#"
+            mod indent {
+                struct Foo {}
+
+                fn foo() {
+                    let foo = Foo{};
+                    foo.bar$0;
+                }
+            }
+            "#,
+            r#"
+            mod indent {
+                struct Foo {
+                    bar: ()
+                }
+
+                fn foo() {
+                    let foo = Foo{};
+                    foo.bar;
+                }
+            }
             "#,
         );
     }

From 96f385b20aa252629570cadeca16a9e159e6810c Mon Sep 17 00:00:00 2001
From: Bart Jacobs <bart.jacobs@cs.kuleuven.be>
Date: Thu, 7 Aug 2025 21:27:12 +0200
Subject: [PATCH 0516/1889] RawVecInner: add missing `unsafe` to unsafe fns

- RawVecInner::grow_exact causes UB if called with len and additional
  arguments such that len + additional is less than the current
  capacity.  Indeed, in that case it calls Allocator::grow with a
  new_layout that is smaller than old_layout, which violates a safety
  precondition.

- All RawVecInner methods for resizing the buffer cause UB
  if called with an elem_layout different from the one used to initially
  allocate the buffer, because in that case Allocator::grow/shrink is called with
  an old_layout that does not fit the allocated block, which violates a
  safety precondition.

- RawVecInner::current_memory might cause UB if called with an elem_layout
  different from the one used to initially allocate the buffer, because
  the unchecked_mul might overflow.

- Furthermore, these methods cause UB if called with an elem_layout
  where the size is not a multiple of the alignment. This is because
  Layout::repeat is used (in layout_array) to compute the allocation's
  layout when allocating, which includes padding to ensure alignment of
  array elements, but simple multiplication is used (in current_memory) to
  compute the old allocation's layout when resizing or deallocating, which
  would cause the layout used to resize or deallocate to not fit the
  allocated block, which violates a safety precondition.
---
 library/alloc/src/raw_vec/mod.rs   | 149 +++++++++++++++++++++++------
 library/alloc/src/raw_vec/tests.rs |  10 +-
 2 files changed, 123 insertions(+), 36 deletions(-)

diff --git a/library/alloc/src/raw_vec/mod.rs b/library/alloc/src/raw_vec/mod.rs
index b0027e964e467..fd8283195a385 100644
--- a/library/alloc/src/raw_vec/mod.rs
+++ b/library/alloc/src/raw_vec/mod.rs
@@ -177,6 +177,8 @@ impl<T, A: Allocator> RawVec<T, A> {
     /// the returned `RawVec`.
     #[inline]
     pub(crate) const fn new_in(alloc: A) -> Self {
+        // Check assumption made in `current_memory`
+        const { assert!(T::LAYOUT.size() % T::LAYOUT.align() == 0) };
         Self { inner: RawVecInner::new_in(alloc, Alignment::of::<T>()), _marker: PhantomData }
     }
 
@@ -328,7 +330,8 @@ impl<T, A: Allocator> RawVec<T, A> {
     #[inline]
     #[track_caller]
     pub(crate) fn reserve(&mut self, len: usize, additional: usize) {
-        self.inner.reserve(len, additional, T::LAYOUT)
+        // SAFETY: All calls on self.inner pass T::LAYOUT as the elem_layout
+        unsafe { self.inner.reserve(len, additional, T::LAYOUT) }
     }
 
     /// A specialized version of `self.reserve(len, 1)` which requires the
@@ -337,7 +340,8 @@ impl<T, A: Allocator> RawVec<T, A> {
     #[inline(never)]
     #[track_caller]
     pub(crate) fn grow_one(&mut self) {
-        self.inner.grow_one(T::LAYOUT)
+        // SAFETY: All calls on self.inner pass T::LAYOUT as the elem_layout
+        unsafe { self.inner.grow_one(T::LAYOUT) }
     }
 
     /// The same as `reserve`, but returns on errors instead of panicking or aborting.
@@ -346,7 +350,8 @@ impl<T, A: Allocator> RawVec<T, A> {
         len: usize,
         additional: usize,
     ) -> Result<(), TryReserveError> {
-        self.inner.try_reserve(len, additional, T::LAYOUT)
+        // SAFETY: All calls on self.inner pass T::LAYOUT as the elem_layout
+        unsafe { self.inner.try_reserve(len, additional, T::LAYOUT) }
     }
 
     /// Ensures that the buffer contains at least enough space to hold `len +
@@ -369,7 +374,8 @@ impl<T, A: Allocator> RawVec<T, A> {
     #[cfg(not(no_global_oom_handling))]
     #[track_caller]
     pub(crate) fn reserve_exact(&mut self, len: usize, additional: usize) {
-        self.inner.reserve_exact(len, additional, T::LAYOUT)
+        // SAFETY: All calls on self.inner pass T::LAYOUT as the elem_layout
+        unsafe { self.inner.reserve_exact(len, additional, T::LAYOUT) }
     }
 
     /// The same as `reserve_exact`, but returns on errors instead of panicking or aborting.
@@ -378,7 +384,8 @@ impl<T, A: Allocator> RawVec<T, A> {
         len: usize,
         additional: usize,
     ) -> Result<(), TryReserveError> {
-        self.inner.try_reserve_exact(len, additional, T::LAYOUT)
+        // SAFETY: All calls on self.inner pass T::LAYOUT as the elem_layout
+        unsafe { self.inner.try_reserve_exact(len, additional, T::LAYOUT) }
     }
 
     /// Shrinks the buffer down to the specified capacity. If the given amount
@@ -395,7 +402,8 @@ impl<T, A: Allocator> RawVec<T, A> {
     #[track_caller]
     #[inline]
     pub(crate) fn shrink_to_fit(&mut self, cap: usize) {
-        self.inner.shrink_to_fit(cap, T::LAYOUT)
+        // SAFETY: All calls on self.inner pass T::LAYOUT as the elem_layout
+        unsafe { self.inner.shrink_to_fit(cap, T::LAYOUT) }
     }
 }
 
@@ -518,8 +526,12 @@ impl<A: Allocator> RawVecInner<A> {
         &self.alloc
     }
 
+    /// # Safety
+    /// - `elem_layout` must be valid for `self`, i.e. it must be the same `elem_layout` used to
+    ///   initially construct `self`
+    /// - `elem_layout`'s size must be a multiple of its alignment
     #[inline]
-    fn current_memory(&self, elem_layout: Layout) -> Option<(NonNull<u8>, Layout)> {
+    unsafe fn current_memory(&self, elem_layout: Layout) -> Option<(NonNull<u8>, Layout)> {
         if elem_layout.size() == 0 || self.cap.as_inner() == 0 {
             None
         } else {
@@ -535,48 +547,67 @@ impl<A: Allocator> RawVecInner<A> {
         }
     }
 
+    /// # Safety
+    /// - `elem_layout` must be valid for `self`, i.e. it must be the same `elem_layout` used to
+    ///   initially construct `self`
+    /// - `elem_layout`'s size must be a multiple of its alignment
     #[cfg(not(no_global_oom_handling))]
     #[inline]
     #[track_caller]
-    fn reserve(&mut self, len: usize, additional: usize, elem_layout: Layout) {
+    unsafe fn reserve(&mut self, len: usize, additional: usize, elem_layout: Layout) {
         // Callers expect this function to be very cheap when there is already sufficient capacity.
         // Therefore, we move all the resizing and error-handling logic from grow_amortized and
         // handle_reserve behind a call, while making sure that this function is likely to be
         // inlined as just a comparison and a call if the comparison fails.
         #[cold]
-        fn do_reserve_and_handle<A: Allocator>(
+        unsafe fn do_reserve_and_handle<A: Allocator>(
             slf: &mut RawVecInner<A>,
             len: usize,
             additional: usize,
             elem_layout: Layout,
         ) {
-            if let Err(err) = slf.grow_amortized(len, additional, elem_layout) {
+            // SAFETY: Precondition passed to caller
+            if let Err(err) = unsafe { slf.grow_amortized(len, additional, elem_layout) } {
                 handle_error(err);
             }
         }
 
         if self.needs_to_grow(len, additional, elem_layout) {
-            do_reserve_and_handle(self, len, additional, elem_layout);
+            unsafe {
+                do_reserve_and_handle(self, len, additional, elem_layout);
+            }
         }
     }
 
+    /// # Safety
+    /// - `elem_layout` must be valid for `self`, i.e. it must be the same `elem_layout` used to
+    ///   initially construct `self`
+    /// - `elem_layout`'s size must be a multiple of its alignment
     #[cfg(not(no_global_oom_handling))]
     #[inline]
     #[track_caller]
-    fn grow_one(&mut self, elem_layout: Layout) {
-        if let Err(err) = self.grow_amortized(self.cap.as_inner(), 1, elem_layout) {
+    unsafe fn grow_one(&mut self, elem_layout: Layout) {
+        // SAFETY: Precondition passed to caller
+        if let Err(err) = unsafe { self.grow_amortized(self.cap.as_inner(), 1, elem_layout) } {
             handle_error(err);
         }
     }
 
-    fn try_reserve(
+    /// # Safety
+    /// - `elem_layout` must be valid for `self`, i.e. it must be the same `elem_layout` used to
+    ///   initially construct `self`
+    /// - `elem_layout`'s size must be a multiple of its alignment
+    unsafe fn try_reserve(
         &mut self,
         len: usize,
         additional: usize,
         elem_layout: Layout,
     ) -> Result<(), TryReserveError> {
         if self.needs_to_grow(len, additional, elem_layout) {
-            self.grow_amortized(len, additional, elem_layout)?;
+            // SAFETY: Precondition passed to caller
+            unsafe {
+                self.grow_amortized(len, additional, elem_layout)?;
+            }
         }
         unsafe {
             // Inform the optimizer that the reservation has succeeded or wasn't needed
@@ -585,22 +616,34 @@ impl<A: Allocator> RawVecInner<A> {
         Ok(())
     }
 
+    /// # Safety
+    /// - `elem_layout` must be valid for `self`, i.e. it must be the same `elem_layout` used to
+    ///   initially construct `self`
+    /// - `elem_layout`'s size must be a multiple of its alignment
     #[cfg(not(no_global_oom_handling))]
     #[track_caller]
-    fn reserve_exact(&mut self, len: usize, additional: usize, elem_layout: Layout) {
-        if let Err(err) = self.try_reserve_exact(len, additional, elem_layout) {
+    unsafe fn reserve_exact(&mut self, len: usize, additional: usize, elem_layout: Layout) {
+        // SAFETY: Precondition passed to caller
+        if let Err(err) = unsafe { self.try_reserve_exact(len, additional, elem_layout) } {
             handle_error(err);
         }
     }
 
-    fn try_reserve_exact(
+    /// # Safety
+    /// - `elem_layout` must be valid for `self`, i.e. it must be the same `elem_layout` used to
+    ///   initially construct `self`
+    /// - `elem_layout`'s size must be a multiple of its alignment
+    unsafe fn try_reserve_exact(
         &mut self,
         len: usize,
         additional: usize,
         elem_layout: Layout,
     ) -> Result<(), TryReserveError> {
         if self.needs_to_grow(len, additional, elem_layout) {
-            self.grow_exact(len, additional, elem_layout)?;
+            // SAFETY: Precondition passed to caller
+            unsafe {
+                self.grow_exact(len, additional, elem_layout)?;
+            }
         }
         unsafe {
             // Inform the optimizer that the reservation has succeeded or wasn't needed
@@ -609,11 +652,16 @@ impl<A: Allocator> RawVecInner<A> {
         Ok(())
     }
 
+    /// # Safety
+    /// - `elem_layout` must be valid for `self`, i.e. it must be the same `elem_layout` used to
+    ///   initially construct `self`
+    /// - `elem_layout`'s size must be a multiple of its alignment
+    /// - `cap` must be less than or equal to `self.capacity(elem_layout.size())`
     #[cfg(not(no_global_oom_handling))]
     #[inline]
     #[track_caller]
-    fn shrink_to_fit(&mut self, cap: usize, elem_layout: Layout) {
-        if let Err(err) = self.shrink(cap, elem_layout) {
+    unsafe fn shrink_to_fit(&mut self, cap: usize, elem_layout: Layout) {
+        if let Err(err) = unsafe { self.shrink(cap, elem_layout) } {
             handle_error(err);
         }
     }
@@ -632,7 +680,13 @@ impl<A: Allocator> RawVecInner<A> {
         self.cap = unsafe { Cap::new_unchecked(cap) };
     }
 
-    fn grow_amortized(
+    /// # Safety
+    /// - `elem_layout` must be valid for `self`, i.e. it must be the same `elem_layout` used to
+    ///   initially construct `self`
+    /// - `elem_layout`'s size must be a multiple of its alignment
+    /// - The sum of `len` and `additional` must be greater than or equal to
+    ///   `self.capacity(elem_layout.size())`
+    unsafe fn grow_amortized(
         &mut self,
         len: usize,
         additional: usize,
@@ -657,14 +711,25 @@ impl<A: Allocator> RawVecInner<A> {
 
         let new_layout = layout_array(cap, elem_layout)?;
 
-        let ptr = finish_grow(new_layout, self.current_memory(elem_layout), &mut self.alloc)?;
-        // SAFETY: layout_array would have resulted in a capacity overflow if we tried to allocate more than `isize::MAX` items
+        // SAFETY:
+        // - For the `current_memory` call: Precondition passed to caller
+        // - For the `finish_grow` call: Precondition passed to caller
+        //   + `current_memory` does the right thing
+        let ptr =
+            unsafe { finish_grow(new_layout, self.current_memory(elem_layout), &mut self.alloc)? };
 
+        // SAFETY: layout_array would have resulted in a capacity overflow if we tried to allocate more than `isize::MAX` items
         unsafe { self.set_ptr_and_cap(ptr, cap) };
         Ok(())
     }
 
-    fn grow_exact(
+    /// # Safety
+    /// - `elem_layout` must be valid for `self`, i.e. it must be the same `elem_layout` used to
+    ///   initially construct `self`
+    /// - `elem_layout`'s size must be a multiple of its alignment
+    /// - The sum of `len` and `additional` must be greater than or equal to
+    ///   `self.capacity(elem_layout.size())`
+    unsafe fn grow_exact(
         &mut self,
         len: usize,
         additional: usize,
@@ -679,7 +744,12 @@ impl<A: Allocator> RawVecInner<A> {
         let cap = len.checked_add(additional).ok_or(CapacityOverflow)?;
         let new_layout = layout_array(cap, elem_layout)?;
 
-        let ptr = finish_grow(new_layout, self.current_memory(elem_layout), &mut self.alloc)?;
+        // SAFETY:
+        // - For the `current_memory` call: Precondition passed to caller
+        // - For the `finish_grow` call: Precondition passed to caller
+        //   + `current_memory` does the right thing
+        let ptr =
+            unsafe { finish_grow(new_layout, self.current_memory(elem_layout), &mut self.alloc)? };
         // SAFETY: layout_array would have resulted in a capacity overflow if we tried to allocate more than `isize::MAX` items
         unsafe {
             self.set_ptr_and_cap(ptr, cap);
@@ -687,9 +757,14 @@ impl<A: Allocator> RawVecInner<A> {
         Ok(())
     }
 
+    /// # Safety
+    /// - `elem_layout` must be valid for `self`, i.e. it must be the same `elem_layout` used to
+    ///   initially construct `self`
+    /// - `elem_layout`'s size must be a multiple of its alignment
+    /// - `cap` must be less than or equal to `self.capacity(elem_layout.size())`
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    fn shrink(&mut self, cap: usize, elem_layout: Layout) -> Result<(), TryReserveError> {
+    unsafe fn shrink(&mut self, cap: usize, elem_layout: Layout) -> Result<(), TryReserveError> {
         assert!(cap <= self.capacity(elem_layout.size()), "Tried to shrink to a larger capacity");
         // SAFETY: Just checked this isn't trying to grow
         unsafe { self.shrink_unchecked(cap, elem_layout) }
@@ -711,8 +786,12 @@ impl<A: Allocator> RawVecInner<A> {
         cap: usize,
         elem_layout: Layout,
     ) -> Result<(), TryReserveError> {
-        let (ptr, layout) =
-            if let Some(mem) = self.current_memory(elem_layout) { mem } else { return Ok(()) };
+        // SAFETY: Precondition passed to caller
+        let (ptr, layout) = if let Some(mem) = unsafe { self.current_memory(elem_layout) } {
+            mem
+        } else {
+            return Ok(());
+        };
 
         // If shrinking to 0, deallocate the buffer. We don't reach this point
         // for the T::IS_ZST case since current_memory() will have returned
@@ -748,7 +827,8 @@ impl<A: Allocator> RawVecInner<A> {
     /// Ideally this function would take `self` by move, but it cannot because it exists to be
     /// called from a `Drop` impl.
     unsafe fn deallocate(&mut self, elem_layout: Layout) {
-        if let Some((ptr, layout)) = self.current_memory(elem_layout) {
+        // SAFETY: Precondition passed to caller
+        if let Some((ptr, layout)) = unsafe { self.current_memory(elem_layout) } {
             unsafe {
                 self.alloc.deallocate(ptr, layout);
             }
@@ -756,10 +836,17 @@ impl<A: Allocator> RawVecInner<A> {
     }
 }
 
+/// # Safety
+/// If `current_memory` matches `Some((ptr, old_layout))`:
+/// - `ptr` must denote a block of memory *currently allocated* via `alloc`
+/// - `old_layout` must *fit* that block of memory
+/// - `new_layout` must have the same alignment as `old_layout`
+/// - `new_layout.size()` must be greater than or equal to `old_layout.size()`
+/// If `current_memory` is `None`, this function is safe.
 // not marked inline(never) since we want optimizers to be able to observe the specifics of this
 // function, see tests/codegen-llvm/vec-reserve-extend.rs.
 #[cold]
-fn finish_grow<A>(
+unsafe fn finish_grow<A>(
     new_layout: Layout,
     current_memory: Option<(NonNull<u8>, Layout)>,
     alloc: &mut A,
diff --git a/library/alloc/src/raw_vec/tests.rs b/library/alloc/src/raw_vec/tests.rs
index 700fa922739d6..15f48c03dc54c 100644
--- a/library/alloc/src/raw_vec/tests.rs
+++ b/library/alloc/src/raw_vec/tests.rs
@@ -85,7 +85,7 @@ struct ZST;
 fn zst_sanity<T>(v: &RawVec<T>) {
     assert_eq!(v.capacity(), usize::MAX);
     assert_eq!(v.ptr(), core::ptr::Unique::<T>::dangling().as_ptr());
-    assert_eq!(v.inner.current_memory(T::LAYOUT), None);
+    assert_eq!(unsafe { v.inner.current_memory(T::LAYOUT) }, None);
 }
 
 #[test]
@@ -126,12 +126,12 @@ fn zst() {
     assert_eq!(v.try_reserve_exact(101, usize::MAX - 100), cap_err);
     zst_sanity(&v);
 
-    assert_eq!(v.inner.grow_amortized(100, usize::MAX - 100, ZST::LAYOUT), cap_err);
-    assert_eq!(v.inner.grow_amortized(101, usize::MAX - 100, ZST::LAYOUT), cap_err);
+    assert_eq!(unsafe { v.inner.grow_amortized(100, usize::MAX - 100, ZST::LAYOUT) }, cap_err);
+    assert_eq!(unsafe { v.inner.grow_amortized(101, usize::MAX - 100, ZST::LAYOUT) }, cap_err);
     zst_sanity(&v);
 
-    assert_eq!(v.inner.grow_exact(100, usize::MAX - 100, ZST::LAYOUT), cap_err);
-    assert_eq!(v.inner.grow_exact(101, usize::MAX - 100, ZST::LAYOUT), cap_err);
+    assert_eq!(unsafe { v.inner.grow_exact(100, usize::MAX - 100, ZST::LAYOUT) }, cap_err);
+    assert_eq!(unsafe { v.inner.grow_exact(101, usize::MAX - 100, ZST::LAYOUT) }, cap_err);
     zst_sanity(&v);
 }
 

From f374dce1d9dad014a79637af20ce551da79fd60d Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Fri, 5 Sep 2025 10:21:25 +0200
Subject: [PATCH 0517/1889] clarify typo pr guidance

---
 src/doc/rustc-dev-guide/src/contributing.md | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/contributing.md b/src/doc/rustc-dev-guide/src/contributing.md
index 1ade4953d2e65..8b1e05e1cf4cf 100644
--- a/src/doc/rustc-dev-guide/src/contributing.md
+++ b/src/doc/rustc-dev-guide/src/contributing.md
@@ -370,8 +370,10 @@ You can also use `rustdoc` directly to check small fixes. For example,
 `rustdoc src/doc/reference.md` will render reference to `doc/reference.html`.
 The CSS might be messed up, but you can verify that the HTML is right.
 
-Please notice that at this time we don't accept typography/spellcheck fixes to **internal documentation** (example:
-tests, library or compiler code) as it's usually not worth the churn or the review time.
+Please notice that we don't accept typography/spellcheck fixes to **internal documentation**
+as it's usually not worth the churn or the review time.
+Examples of internal documentation is code comments and rustc api docs.
+However, feel free to fix those if accompanied by other improvements in the same PR.
 
 ### Contributing to rustc-dev-guide
 

From b76461678a24c6e40effe9b7d6aa0cccca13d09d Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Fri, 5 Sep 2025 10:28:12 +0200
Subject: [PATCH 0518/1889] sembr

---
 src/doc/rustc-dev-guide/src/contributing.md | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/contributing.md b/src/doc/rustc-dev-guide/src/contributing.md
index 1ade4953d2e65..af4de28ab0913 100644
--- a/src/doc/rustc-dev-guide/src/contributing.md
+++ b/src/doc/rustc-dev-guide/src/contributing.md
@@ -154,9 +154,14 @@ The CI in rust-lang/rust applies your patches directly against the current maste
 not against the commit your branch is based on. This can lead to unexpected failures
 if your branch is outdated, even when there are no explicit merge conflicts.
 
-Update your branch only when needed: when you have merge conflicts, upstream CI is broken and blocking your green PR, or a maintainer requests it. Avoid updating an already-green PR under review unless necessary. During review, make incremental commits to address feedback. Prefer to squash or rebase only at the end, or when a reviewer requests it.
+Update your branch only when needed: when you have merge conflicts, upstream CI is broken and blocking your green PR, or a maintainer requests it.
+Avoid updating an already-green PR under review unless necessary.
+During review, make incremental commits to address feedback.
+Prefer to squash or rebase only at the end, or when a reviewer requests it.
 
-When updating, use `git push --force-with-lease` and leave a brief comment explaining what changed. Some repos prefer merging from `upstream/master` instead of rebasing; follow the project's conventions. See [keeping things up to date](git.md#keeping-things-up-to-date) for detailed instructions.
+When updating, use `git push --force-with-lease` and leave a brief comment explaining what changed.
+Some repos prefer merging from `upstream/master` instead of rebasing; follow the project's conventions.
+See [keeping things up to date](git.md#keeping-things-up-to-date) for detailed instructions.
 
 After rebasing, it's recommended to [run the relevant tests locally](tests/intro.md) to catch any issues before CI runs.
 
@@ -435,7 +440,8 @@ Just a few things to keep in mind:
 
 #### ⚠️ Note: Where to contribute `rustc-dev-guide` changes
 
-For detailed information about where to contribute rustc-dev-guide changes and the benefits of doing so, see [the rustc-dev-guide working group documentation](https://forge.rust-lang.org/wg-rustc-dev-guide/index.html#where-to-contribute-rustc-dev-guide-changes).
+For detailed information about where to contribute rustc-dev-guide changes and the benefits of doing so,
+see [the rustc-dev-guide working group documentation](https://forge.rust-lang.org/wg-rustc-dev-guide/index.html#where-to-contribute-rustc-dev-guide-changes).
 
 ## Issue triage
 

From 4d69a29e447059f2477f5976904af69682388603 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Fri, 5 Sep 2025 10:41:14 +0200
Subject: [PATCH 0519/1889] avoid inline external links

---
 src/doc/rustc-dev-guide/src/contributing.md | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/contributing.md b/src/doc/rustc-dev-guide/src/contributing.md
index af4de28ab0913..18f2dcb21ba06 100644
--- a/src/doc/rustc-dev-guide/src/contributing.md
+++ b/src/doc/rustc-dev-guide/src/contributing.md
@@ -26,8 +26,7 @@ conditions that trigger the bug, or part of the error message if there is any.
 An example could be: **"impossible case reached" on lifetime inference for impl
 Trait in return position**.
 
-Opening an issue is as easy as following [this
-link](https://github.com/rust-lang/rust/issues/new/choose) and filling out the fields
+Opening an issue is as easy as following [thi link][create an issue] and filling out the fields
 in the appropriate provided template.
 
 ## Bug fixes or "normal" code changes
@@ -441,7 +440,7 @@ Just a few things to keep in mind:
 #### ⚠️ Note: Where to contribute `rustc-dev-guide` changes
 
 For detailed information about where to contribute rustc-dev-guide changes and the benefits of doing so,
-see [the rustc-dev-guide working group documentation](https://forge.rust-lang.org/wg-rustc-dev-guide/index.html#where-to-contribute-rustc-dev-guide-changes).
+see [the rustc-dev-guide working group documentation].
 
 ## Issue triage
 
@@ -458,6 +457,7 @@ Please see <https://forge.rust-lang.org/release/issue-triaging.html>.
 [regression-]: https://github.com/rust-lang/rust/labels?q=regression
 [relnotes]: https://github.com/rust-lang/rust/labels/relnotes
 [S-tracking-]: https://github.com/rust-lang/rust/labels?q=s-tracking
+[the rustc-dev-guide working group documentation]: https://forge.rust-lang.org/wg-rustc-dev-guide/index.html#where-to-contribute-rustc-dev-guide-changes
 
 ### Rfcbot labels
 
@@ -505,3 +505,4 @@ This section has moved to the ["About this guide"] chapter.
 [RFC 1574]: https://github.com/rust-lang/rfcs/blob/master/text/1574-more-api-documentation-conventions.md#appendix-a-full-conventions-text
 [rustc-dev-guide]: https://rustc-dev-guide.rust-lang.org/
 [rdgrepo]: https://github.com/rust-lang/rustc-dev-guide
+[create an issue]: https://github.com/rust-lang/rust/issues/new/choose

From 98e10290c9a235641912386ba099b2d4215ec002 Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Fri, 5 Sep 2025 09:50:05 +0000
Subject: [PATCH 0520/1889] change file-is-generated doc comment to inner

---
 library/core/src/unicode/unicode_data.rs      | 2 +-
 src/tools/unicode-table-generator/src/main.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/library/core/src/unicode/unicode_data.rs b/library/core/src/unicode/unicode_data.rs
index f78983bc3395d..0bf2f948e85bd 100644
--- a/library/core/src/unicode/unicode_data.rs
+++ b/library/core/src/unicode/unicode_data.rs
@@ -1,4 +1,4 @@
-///! This file is generated by `./x run src/tools/unicode-table-generator`; do not edit manually!
+//! This file is generated by `./x run src/tools/unicode-table-generator`; do not edit manually!
 // Alphabetic      :  1727 bytes, 142759 codepoints in 757 ranges (U+000041 - U+0323B0) using skiplist
 // Case_Ignorable  :  1053 bytes,   2749 codepoints in 452 ranges (U+000027 - U+0E01F0) using skiplist
 // Cased           :   407 bytes,   4578 codepoints in 159 ranges (U+000041 - U+01F18A) using skiplist
diff --git a/src/tools/unicode-table-generator/src/main.rs b/src/tools/unicode-table-generator/src/main.rs
index 9399021df76ae..aa7d97f7f3d7c 100644
--- a/src/tools/unicode-table-generator/src/main.rs
+++ b/src/tools/unicode-table-generator/src/main.rs
@@ -228,7 +228,7 @@ fn main() {
 
     let mut table_file = String::new();
     table_file.push_str(
-        "///! This file is generated by `./x run src/tools/unicode-table-generator`; do not edit manually!\n",
+        "//! This file is generated by `./x run src/tools/unicode-table-generator`; do not edit manually!\n",
     );
 
     let mut total_bytes = 0;

From 1186db896e2f4013b1f15612b31ed18e2b653228 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 5 Sep 2025 10:28:47 +0200
Subject: [PATCH 0521/1889] atomics: unify handling min/max and the other RMWs

---
 src/tools/miri/src/concurrency/data_race.rs   | 85 +++++--------------
 src/tools/miri/src/concurrency/genmc/dummy.rs | 19 +----
 src/tools/miri/src/concurrency/genmc/mod.rs   | 29 +------
 src/tools/miri/src/intrinsics/atomic.rs       | 74 ++++++++++------
 src/tools/miri/src/intrinsics/mod.rs          |  3 +
 5 files changed, 83 insertions(+), 127 deletions(-)

diff --git a/src/tools/miri/src/concurrency/data_race.rs b/src/tools/miri/src/concurrency/data_race.rs
index 19d37a691d90c..a7822d0d6fa31 100644
--- a/src/tools/miri/src/concurrency/data_race.rs
+++ b/src/tools/miri/src/concurrency/data_race.rs
@@ -56,6 +56,7 @@ use super::vector_clock::{VClock, VTimestamp, VectorIdx};
 use super::weak_memory::EvalContextExt as _;
 use crate::concurrency::GlobalDataRaceHandler;
 use crate::diagnostics::RacingOp;
+use crate::intrinsics::AtomicRmwOp;
 use crate::*;
 
 pub type AllocState = VClockAlloc;
@@ -778,9 +779,8 @@ pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
         &mut self,
         place: &MPlaceTy<'tcx>,
         rhs: &ImmTy<'tcx>,
-        op: mir::BinOp,
-        not: bool,
-        atomic: AtomicRwOrd,
+        atomic_op: AtomicRmwOp,
+        ord: AtomicRwOrd,
     ) -> InterpResult<'tcx, ImmTy<'tcx>> {
         let this = self.eval_context_mut();
         this.atomic_access_check(place, AtomicAccessType::Rmw)?;
@@ -793,8 +793,9 @@ pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
                 this,
                 place.ptr().addr(),
                 place.layout.size,
-                atomic,
-                (op, not),
+                place.layout.backend_repr.is_signed(),
+                ord,
+                atomic_op,
                 rhs.to_scalar(),
                 old.to_scalar(),
             )?;
@@ -804,13 +805,26 @@ pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
             return interp_ok(ImmTy::from_scalar(old_val, old.layout));
         }
 
-        let val = this.binary_op(op, &old, rhs)?;
-        let val = if not { this.unary_op(mir::UnOp::Not, &val)? } else { val };
+        let val = match atomic_op {
+            AtomicRmwOp::MirOp { op, neg } => {
+                let val = this.binary_op(op, &old, rhs)?;
+                if neg { this.unary_op(mir::UnOp::Not, &val)? } else { val }
+            }
+            AtomicRmwOp::Max => {
+                let lt = this.binary_op(mir::BinOp::Lt, &old, rhs)?.to_scalar().to_bool()?;
+                if lt { rhs } else { &old }.clone()
+            }
+            AtomicRmwOp::Min => {
+                let lt = this.binary_op(mir::BinOp::Lt, &old, rhs)?.to_scalar().to_bool()?;
+                if lt { &old } else { rhs }.clone()
+            }
+        };
+
         this.allow_data_races_mut(|this| this.write_immediate(*val, place))?;
 
-        this.validate_atomic_rmw(place, atomic)?;
+        this.validate_atomic_rmw(place, ord)?;
 
-        this.buffered_atomic_rmw(val.to_scalar(), place, atomic, old.to_scalar())?;
+        this.buffered_atomic_rmw(val.to_scalar(), place, ord, old.to_scalar())?;
         interp_ok(old)
     }
 
@@ -852,59 +866,6 @@ pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
         interp_ok(old)
     }
 
-    /// Perform an conditional atomic exchange with a memory place and a new
-    /// scalar value, the old value is returned.
-    fn atomic_min_max_scalar(
-        &mut self,
-        place: &MPlaceTy<'tcx>,
-        rhs: ImmTy<'tcx>,
-        min: bool,
-        atomic: AtomicRwOrd,
-    ) -> InterpResult<'tcx, ImmTy<'tcx>> {
-        let this = self.eval_context_mut();
-        this.atomic_access_check(place, AtomicAccessType::Rmw)?;
-
-        let old = this.allow_data_races_mut(|this| this.read_immediate(place))?;
-
-        // Inform GenMC about the atomic min/max operation.
-        if let Some(genmc_ctx) = this.machine.data_race.as_genmc_ref() {
-            let (old_val, new_val) = genmc_ctx.atomic_min_max_op(
-                this,
-                place.ptr().addr(),
-                place.layout.size,
-                atomic,
-                min,
-                old.layout.backend_repr.is_signed(),
-                rhs.to_scalar(),
-                old.to_scalar(),
-            )?;
-            // The store might be the latest store in coherence order (determined by GenMC).
-            // If it is, we need to update the value in Miri's memory:
-            if let Some(new_val) = new_val {
-                this.allow_data_races_mut(|this| this.write_scalar(new_val, place))?;
-            }
-            return interp_ok(ImmTy::from_scalar(old_val, old.layout));
-        }
-
-        let lt = this.binary_op(mir::BinOp::Lt, &old, &rhs)?.to_scalar().to_bool()?;
-
-        #[rustfmt::skip] // rustfmt makes this unreadable
-        let new_val = if min {
-            if lt { &old } else { &rhs }
-        } else {
-            if lt { &rhs } else { &old }
-        };
-
-        this.allow_data_races_mut(|this| this.write_immediate(**new_val, place))?;
-
-        this.validate_atomic_rmw(place, atomic)?;
-
-        this.buffered_atomic_rmw(new_val.to_scalar(), place, atomic, old.to_scalar())?;
-
-        // Return the old value.
-        interp_ok(old)
-    }
-
     /// Perform an atomic compare and exchange at a given memory location.
     /// On success an atomic RMW operation is performed and on failure
     /// only an atomic read occurs. If `can_fail_spuriously` is true,
diff --git a/src/tools/miri/src/concurrency/genmc/dummy.rs b/src/tools/miri/src/concurrency/genmc/dummy.rs
index 1960ef37cc9f3..7c420961ec54a 100644
--- a/src/tools/miri/src/concurrency/genmc/dummy.rs
+++ b/src/tools/miri/src/concurrency/genmc/dummy.rs
@@ -1,8 +1,8 @@
 use rustc_abi::{Align, Size};
 use rustc_const_eval::interpret::{AllocId, InterpCx, InterpResult};
-use rustc_middle::mir;
 
 pub use self::run::run_genmc_mode;
+use crate::intrinsics::AtomicRmwOp;
 use crate::{
     AtomicFenceOrd, AtomicReadOrd, AtomicRwOrd, AtomicWriteOrd, MemoryKind, MiriMachine, Scalar,
     ThreadId, ThreadManager, VisitProvenance, VisitWith,
@@ -94,22 +94,9 @@ impl GenmcCtx {
         _ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
         _address: Size,
         _size: Size,
-        _ordering: AtomicRwOrd,
-        (_rmw_op, _not): (mir::BinOp, bool),
-        _rhs_scalar: Scalar,
-        _old_value: Scalar,
-    ) -> InterpResult<'tcx, (Scalar, Option<Scalar>)> {
-        unreachable!()
-    }
-
-    pub(crate) fn atomic_min_max_op<'tcx>(
-        &self,
-        _ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
-        _address: Size,
-        _size: Size,
-        _ordering: AtomicRwOrd,
-        _min: bool,
         _is_signed: bool,
+        _ordering: AtomicRwOrd,
+        _atomic_op: AtomicRmwOp,
         _rhs_scalar: Scalar,
         _old_value: Scalar,
     ) -> InterpResult<'tcx, (Scalar, Option<Scalar>)> {
diff --git a/src/tools/miri/src/concurrency/genmc/mod.rs b/src/tools/miri/src/concurrency/genmc/mod.rs
index b5d20a439c01c..26ce0b9c43ac7 100644
--- a/src/tools/miri/src/concurrency/genmc/mod.rs
+++ b/src/tools/miri/src/concurrency/genmc/mod.rs
@@ -7,7 +7,7 @@ use genmc_sys::{
 };
 use rustc_abi::{Align, Size};
 use rustc_const_eval::interpret::{AllocId, InterpCx, InterpResult, interp_ok};
-use rustc_middle::{mir, throw_machine_stop, throw_ub_format, throw_unsup_format};
+use rustc_middle::{throw_machine_stop, throw_ub_format, throw_unsup_format};
 // FIXME(genmc,tracing): Implement some work-around for enabling debug/trace level logging (currently disabled statically in rustc).
 use tracing::{debug, info};
 
@@ -15,6 +15,7 @@ use self::global_allocations::{EvalContextExt as _, GlobalAllocationHandler};
 use self::helper::{MAX_ACCESS_SIZE, genmc_scalar_to_scalar, scalar_to_genmc_scalar};
 use self::thread_id_map::ThreadIdMap;
 use crate::concurrency::genmc::helper::split_access;
+use crate::intrinsics::AtomicRmwOp;
 use crate::{
     AtomicFenceOrd, AtomicReadOrd, AtomicRwOrd, AtomicWriteOrd, MemoryKind, MiriConfig,
     MiriMachine, MiriMemoryKind, Scalar, TerminationInfo, ThreadId, ThreadManager, VisitProvenance,
@@ -298,8 +299,9 @@ impl GenmcCtx {
         _ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
         _address: Size,
         _size: Size,
+        _is_signed: bool,
         _ordering: AtomicRwOrd,
-        (_rmw_op, _not): (mir::BinOp, bool),
+        _atomic_op: AtomicRmwOp,
         _rhs_scalar: Scalar,
         _old_value: Scalar,
     ) -> InterpResult<'tcx, (Scalar, Option<Scalar>)> {
@@ -310,29 +312,6 @@ impl GenmcCtx {
         throw_unsup_format!("FIXME(genmc): Add support for atomic RMW.")
     }
 
-    /// Inform GenMC about an atomic `min` or `max` operation.
-    ///
-    /// Returns `(old_val, Option<new_val>)`. `new_val` might not be the latest write in coherence order, which is indicated by `None`.
-    ///
-    /// `old_value` is the value that a non-atomic load would read here, or `None` if the memory is uninitalized.
-    pub(crate) fn atomic_min_max_op<'tcx>(
-        &self,
-        _ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
-        _address: Size,
-        _size: Size,
-        _ordering: AtomicRwOrd,
-        _min: bool,
-        _is_signed: bool,
-        _rhs_scalar: Scalar,
-        _old_value: Scalar,
-    ) -> InterpResult<'tcx, (Scalar, Option<Scalar>)> {
-        assert!(
-            !self.get_alloc_data_races(),
-            "atomic min/max operation with data race checking disabled."
-        );
-        throw_unsup_format!("FIXME(genmc): Add support for atomic min/max.")
-    }
-
     /// Returns `(old_val, Option<new_val>)`. `new_val` might not be the latest write in coherence order, which is indicated by `None`.
     ///
     /// `old_value` is the value that a non-atomic load would read here, or `None` if the memory is uninitalized.
diff --git a/src/tools/miri/src/intrinsics/atomic.rs b/src/tools/miri/src/intrinsics/atomic.rs
index e634125292754..c9f63640b8541 100644
--- a/src/tools/miri/src/intrinsics/atomic.rs
+++ b/src/tools/miri/src/intrinsics/atomic.rs
@@ -5,10 +5,13 @@ use rustc_middle::{mir, ty};
 use super::check_intrinsic_arg_count;
 use crate::*;
 
-pub enum AtomicOp {
-    /// The `bool` indicates whether the result of the operation should be negated (`UnOp::Not`,
-    /// must be a boolean-typed operation).
-    MirOp(mir::BinOp, bool),
+pub enum AtomicRmwOp {
+    MirOp {
+        op: mir::BinOp,
+        /// Indicates whether the result of the operation should be negated (`UnOp::Not`, must be a
+        /// boolean-typed operation).
+        neg: bool,
+    },
     Max,
     Min,
 }
@@ -106,55 +109,85 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
             "or" => {
                 let ord = get_ord_at(2);
-                this.atomic_rmw_op(args, dest, AtomicOp::MirOp(BinOp::BitOr, false), rw_ord(ord))?;
+                this.atomic_rmw_op(
+                    args,
+                    dest,
+                    AtomicRmwOp::MirOp { op: BinOp::BitOr, neg: false },
+                    rw_ord(ord),
+                )?;
             }
             "xor" => {
                 let ord = get_ord_at(2);
-                this.atomic_rmw_op(args, dest, AtomicOp::MirOp(BinOp::BitXor, false), rw_ord(ord))?;
+                this.atomic_rmw_op(
+                    args,
+                    dest,
+                    AtomicRmwOp::MirOp { op: BinOp::BitXor, neg: false },
+                    rw_ord(ord),
+                )?;
             }
             "and" => {
                 let ord = get_ord_at(2);
-                this.atomic_rmw_op(args, dest, AtomicOp::MirOp(BinOp::BitAnd, false), rw_ord(ord))?;
+                this.atomic_rmw_op(
+                    args,
+                    dest,
+                    AtomicRmwOp::MirOp { op: BinOp::BitAnd, neg: false },
+                    rw_ord(ord),
+                )?;
             }
             "nand" => {
                 let ord = get_ord_at(2);
-                this.atomic_rmw_op(args, dest, AtomicOp::MirOp(BinOp::BitAnd, true), rw_ord(ord))?;
+                this.atomic_rmw_op(
+                    args,
+                    dest,
+                    AtomicRmwOp::MirOp { op: BinOp::BitAnd, neg: true },
+                    rw_ord(ord),
+                )?;
             }
             "xadd" => {
                 let ord = get_ord_at(2);
-                this.atomic_rmw_op(args, dest, AtomicOp::MirOp(BinOp::Add, false), rw_ord(ord))?;
+                this.atomic_rmw_op(
+                    args,
+                    dest,
+                    AtomicRmwOp::MirOp { op: BinOp::Add, neg: false },
+                    rw_ord(ord),
+                )?;
             }
             "xsub" => {
                 let ord = get_ord_at(2);
-                this.atomic_rmw_op(args, dest, AtomicOp::MirOp(BinOp::Sub, false), rw_ord(ord))?;
+                this.atomic_rmw_op(
+                    args,
+                    dest,
+                    AtomicRmwOp::MirOp { op: BinOp::Sub, neg: false },
+                    rw_ord(ord),
+                )?;
             }
             "min" => {
                 let ord = get_ord_at(1);
                 // Later we will use the type to indicate signed vs unsigned,
                 // so make sure it matches the intrinsic name.
                 assert!(matches!(args[1].layout.ty.kind(), ty::Int(_)));
-                this.atomic_rmw_op(args, dest, AtomicOp::Min, rw_ord(ord))?;
+                this.atomic_rmw_op(args, dest, AtomicRmwOp::Min, rw_ord(ord))?;
             }
             "umin" => {
                 let ord = get_ord_at(1);
                 // Later we will use the type to indicate signed vs unsigned,
                 // so make sure it matches the intrinsic name.
                 assert!(matches!(args[1].layout.ty.kind(), ty::Uint(_)));
-                this.atomic_rmw_op(args, dest, AtomicOp::Min, rw_ord(ord))?;
+                this.atomic_rmw_op(args, dest, AtomicRmwOp::Min, rw_ord(ord))?;
             }
             "max" => {
                 let ord = get_ord_at(1);
                 // Later we will use the type to indicate signed vs unsigned,
                 // so make sure it matches the intrinsic name.
                 assert!(matches!(args[1].layout.ty.kind(), ty::Int(_)));
-                this.atomic_rmw_op(args, dest, AtomicOp::Max, rw_ord(ord))?;
+                this.atomic_rmw_op(args, dest, AtomicRmwOp::Max, rw_ord(ord))?;
             }
             "umax" => {
                 let ord = get_ord_at(1);
                 // Later we will use the type to indicate signed vs unsigned,
                 // so make sure it matches the intrinsic name.
                 assert!(matches!(args[1].layout.ty.kind(), ty::Uint(_)));
-                this.atomic_rmw_op(args, dest, AtomicOp::Max, rw_ord(ord))?;
+                this.atomic_rmw_op(args, dest, AtomicRmwOp::Max, rw_ord(ord))?;
             }
 
             _ => return interp_ok(EmulateItemResult::NotSupported),
@@ -222,8 +255,8 @@ trait EvalContextPrivExt<'tcx>: MiriInterpCxExt<'tcx> {
         &mut self,
         args: &[OpTy<'tcx>],
         dest: &MPlaceTy<'tcx>,
-        atomic_op: AtomicOp,
-        atomic: AtomicRwOrd,
+        atomic_op: AtomicRmwOp,
+        ord: AtomicRwOrd,
     ) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
 
@@ -240,14 +273,7 @@ trait EvalContextPrivExt<'tcx>: MiriInterpCxExt<'tcx> {
             );
         }
 
-        let old = match atomic_op {
-            AtomicOp::Min =>
-                this.atomic_min_max_scalar(&place, rhs, /* min */ true, atomic)?,
-            AtomicOp::Max =>
-                this.atomic_min_max_scalar(&place, rhs, /* min */ false, atomic)?,
-            AtomicOp::MirOp(op, not) =>
-                this.atomic_rmw_op_immediate(&place, &rhs, op, not, atomic)?,
-        };
+        let old = this.atomic_rmw_op_immediate(&place, &rhs, atomic_op, ord)?;
         this.write_immediate(*old, dest)?; // old value is returned
         interp_ok(())
     }
diff --git a/src/tools/miri/src/intrinsics/mod.rs b/src/tools/miri/src/intrinsics/mod.rs
index 5e46768b0e6cf..f6f9af47d0a74 100644
--- a/src/tools/miri/src/intrinsics/mod.rs
+++ b/src/tools/miri/src/intrinsics/mod.rs
@@ -3,6 +3,9 @@
 mod atomic;
 mod simd;
 
+pub use self::atomic::AtomicRmwOp;
+
+#[rustfmt::skip] // prevent `use` reordering
 use std::ops::Neg;
 
 use rand::Rng;

From 69c7652a01a721be007cb9f7ef56f1e483f39fc8 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 5 Sep 2025 13:31:01 +0200
Subject: [PATCH 0522/1889] atomic rmw intrinsics: RHS must be an integer

---
 src/tools/miri/src/intrinsics/atomic.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/tools/miri/src/intrinsics/atomic.rs b/src/tools/miri/src/intrinsics/atomic.rs
index c9f63640b8541..9bb0ab70de236 100644
--- a/src/tools/miri/src/intrinsics/atomic.rs
+++ b/src/tools/miri/src/intrinsics/atomic.rs
@@ -264,8 +264,9 @@ trait EvalContextPrivExt<'tcx>: MiriInterpCxExt<'tcx> {
         let place = this.deref_pointer(place)?;
         let rhs = this.read_immediate(rhs)?;
 
+        // The LHS can be a pointer, the RHS must be an integer.
         if !(place.layout.ty.is_integral() || place.layout.ty.is_raw_ptr())
-            || !(rhs.layout.ty.is_integral() || rhs.layout.ty.is_raw_ptr())
+            || !rhs.layout.ty.is_integral()
         {
             span_bug!(
                 this.cur_span(),

From 05659c99c9fc76ebd9e314f3e07c85df142e7456 Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Fri, 5 Sep 2025 11:39:17 +0000
Subject: [PATCH 0523/1889] gpu offload: change suspicious map into filter

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

diff --git a/compiler/rustc_codegen_llvm/src/builder/gpu_offload.rs b/compiler/rustc_codegen_llvm/src/builder/gpu_offload.rs
index 1280ab1442a09..0737a18384bd4 100644
--- a/compiler/rustc_codegen_llvm/src/builder/gpu_offload.rs
+++ b/compiler/rustc_codegen_llvm/src/builder/gpu_offload.rs
@@ -193,7 +193,7 @@ fn gen_define_handling<'ll>(
     // reference) types.
     let num_ptr_types = types
         .iter()
-        .map(|&x| matches!(cx.type_kind(x), rustc_codegen_ssa::common::TypeKind::Pointer))
+        .filter(|&x| matches!(cx.type_kind(x), rustc_codegen_ssa::common::TypeKind::Pointer))
         .count();
 
     // We do not know their size anymore at this level, so hardcode a placeholder.

From a641cfc6f37c9f4978b74e416a037c26dc3af7ac Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Fri, 5 Sep 2025 12:31:56 +0000
Subject: [PATCH 0524/1889] DynamicConfig: use canonical clone impl

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

diff --git a/compiler/rustc_query_impl/src/lib.rs b/compiler/rustc_query_impl/src/lib.rs
index 306d4dbc4b487..e499e08c82b9a 100644
--- a/compiler/rustc_query_impl/src/lib.rs
+++ b/compiler/rustc_query_impl/src/lib.rs
@@ -58,7 +58,7 @@ impl<'tcx, C: QueryCache, const ANON: bool, const DEPTH_LIMIT: bool, const FEEDA
     for DynamicConfig<'tcx, C, ANON, DEPTH_LIMIT, FEEDABLE>
 {
     fn clone(&self) -> Self {
-        DynamicConfig { dynamic: self.dynamic }
+        *self
     }
 }
 

From 0e2224b1bfa48b5a1451cad55cb40fc193fb5df3 Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Fri, 5 Sep 2025 12:43:47 +0000
Subject: [PATCH 0525/1889] rustc_infer: change top-level doc comment to inner

---
 compiler/rustc_infer/src/infer/context.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_infer/src/infer/context.rs b/compiler/rustc_infer/src/infer/context.rs
index bb9c88500936f..8265fccabc96f 100644
--- a/compiler/rustc_infer/src/infer/context.rs
+++ b/compiler/rustc_infer/src/infer/context.rs
@@ -1,4 +1,4 @@
-///! Definition of `InferCtxtLike` from the librarified type layer.
+//! Definition of `InferCtxtLike` from the librarified type layer.
 use rustc_hir::def_id::DefId;
 use rustc_middle::traits::ObligationCause;
 use rustc_middle::ty::relate::RelateResult;

From b6f8824315367f73e43efe08f6e5a88cc3f117ce Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 5 Sep 2025 15:13:08 +0200
Subject: [PATCH 0526/1889] Ensure that `--html-after-content` option is used
 to check `scrape_examples_ice` rustdoc GUI test

---
 tests/rustdoc-gui/scrape-examples-ice-links.goml     | 2 ++
 tests/rustdoc-gui/src/scrape_examples_ice/empty.html | 1 -
 tests/rustdoc-gui/src/scrape_examples_ice/extra.html | 1 +
 tests/rustdoc-gui/src/scrape_examples_ice/src/lib.rs | 2 +-
 4 files changed, 4 insertions(+), 2 deletions(-)
 delete mode 100644 tests/rustdoc-gui/src/scrape_examples_ice/empty.html
 create mode 100644 tests/rustdoc-gui/src/scrape_examples_ice/extra.html

diff --git a/tests/rustdoc-gui/scrape-examples-ice-links.goml b/tests/rustdoc-gui/scrape-examples-ice-links.goml
index 1db220e1a3223..0a15962193503 100644
--- a/tests/rustdoc-gui/scrape-examples-ice-links.goml
+++ b/tests/rustdoc-gui/scrape-examples-ice-links.goml
@@ -4,3 +4,5 @@ wait-for: ".scraped-example-title"
 assert-attribute: (".scraped-example-title a", {"href": "../src/bar/bar.rs.html#2"})
 click: ".scraped-example-title a"
 wait-for-property: ("h1", {"innerText": "bar/\nbar.rs"})
+// Ensure that the `--html-after-content` option was correctly handled.
+assert: "#outer-html"
diff --git a/tests/rustdoc-gui/src/scrape_examples_ice/empty.html b/tests/rustdoc-gui/src/scrape_examples_ice/empty.html
deleted file mode 100644
index 8b137891791fe..0000000000000
--- a/tests/rustdoc-gui/src/scrape_examples_ice/empty.html
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/tests/rustdoc-gui/src/scrape_examples_ice/extra.html b/tests/rustdoc-gui/src/scrape_examples_ice/extra.html
new file mode 100644
index 0000000000000..e7a420154a661
--- /dev/null
+++ b/tests/rustdoc-gui/src/scrape_examples_ice/extra.html
@@ -0,0 +1 @@
+<span id="outer-html"></span>
diff --git a/tests/rustdoc-gui/src/scrape_examples_ice/src/lib.rs b/tests/rustdoc-gui/src/scrape_examples_ice/src/lib.rs
index b854c7722c9a0..7d910c6de7dfa 100644
--- a/tests/rustdoc-gui/src/scrape_examples_ice/src/lib.rs
+++ b/tests/rustdoc-gui/src/scrape_examples_ice/src/lib.rs
@@ -1,5 +1,5 @@
 //@ run-flags:-Zrustdoc-scrape-examples
-//@ compile-flags: --html-after-content empty.html
+//@ compile-flags: --html-after-content extra.html
 pub struct ObscurelyNamedType1;
 
 impl ObscurelyNamedType1 {

From 0f76784d72fba47144192a8ebff5745b93ec2876 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Fri, 5 Sep 2025 15:50:39 +0800
Subject: [PATCH 0527/1889] bootstrap: split `run-make` into
 {`run-make`,`run-make-cargo`} test suites

So that contributors who don't need to run `run-make` tests that require
in-tree `cargo` can run the non-cargo `run-make` tests without having to
wait for `cargo` (which would require rebuilding as the build cache
would be invalidated by compiler modifications without some kind of
`--keep-stage-cargo`).
---
 src/bootstrap/src/core/build_steps/test.rs | 52 +++++++++++++++-------
 src/bootstrap/src/core/builder/mod.rs      |  3 +-
 src/bootstrap/src/core/builder/tests.rs    | 46 ++++++++++++++++---
 3 files changed, 80 insertions(+), 21 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index cb81d738666a3..4f839bdf7b83f 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -1522,6 +1522,12 @@ test!(Pretty {
 });
 
 test!(RunMake { path: "tests/run-make", mode: "run-make", suite: "run-make", default: true });
+test!(RunMakeCargo {
+    path: "tests/run-make-cargo",
+    mode: "run-make",
+    suite: "run-make-cargo",
+    default: true
+});
 
 test!(AssemblyLlvm {
     path: "tests/assembly-llvm",
@@ -1773,7 +1779,7 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
                 target,
             });
         }
-        if suite == "run-make" {
+        if mode == "run-make" {
             builder.tool_exe(Tool::RunMakeSupport);
         }
 
@@ -1816,25 +1822,41 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
 
         let is_rustdoc = suite == "rustdoc-ui" || suite == "rustdoc-js";
 
+        // There are (potentially) 2 `cargo`s to consider:
+        //
+        // - A "bootstrap" cargo, which is the same cargo used to build bootstrap itself, and is
+        //   used to build the `run-make` test recipes and the `run-make-support` test library. All
+        //   of these may not use unstable rustc/cargo features.
+        // - An in-tree cargo, which should be considered as under test. The `run-make-cargo` test
+        //   suite is intended to support the use case of testing the "toolchain" (that is, at the
+        //   minimum the interaction between in-tree cargo + rustc) together.
+        //
+        // For build time and iteration purposes, we partition `run-make` tests which needs an
+        // in-tree cargo (a smaller subset) versus `run-make` tests that do not into two test
+        // suites, `run-make` and `run-make-cargo`. That way, contributors who do not need to run
+        // the `run-make` tests that need in-tree cargo do not need to spend time building in-tree
+        // cargo.
         if mode == "run-make" {
-            let cargo_path = if test_compiler.stage == 0 {
-                // If we're using `--stage 0`, we should provide the bootstrap cargo.
-                builder.initial_cargo.clone()
-            } else {
-                builder
-                    .ensure(tool::Cargo::from_build_compiler(
-                        builder.compiler(test_compiler.stage - 1, test_compiler.host),
-                        test_compiler.host,
-                    ))
-                    .tool_path
-            };
-
-            cmd.arg("--cargo-path").arg(cargo_path);
-
             // We need to pass the compiler that was used to compile run-make-support,
             // because we have to use the same compiler to compile rmake.rs recipes.
             let stage0_rustc_path = builder.compiler(0, test_compiler.host);
             cmd.arg("--stage0-rustc-path").arg(builder.rustc(stage0_rustc_path));
+
+            if suite == "run-make-cargo" {
+                let cargo_path = if test_compiler.stage == 0 {
+                    // If we're using `--stage 0`, we should provide the bootstrap cargo.
+                    builder.initial_cargo.clone()
+                } else {
+                    builder
+                        .ensure(tool::Cargo::from_build_compiler(
+                            builder.compiler(test_compiler.stage - 1, test_compiler.host),
+                            test_compiler.host,
+                        ))
+                        .tool_path
+                };
+
+                cmd.arg("--cargo-path").arg(cargo_path);
+            }
         }
 
         // Avoid depending on rustdoc when we don't need it.
diff --git a/src/bootstrap/src/core/builder/mod.rs b/src/bootstrap/src/core/builder/mod.rs
index 627085df812c5..0cbf258f0fd92 100644
--- a/src/bootstrap/src/core/builder/mod.rs
+++ b/src/bootstrap/src/core/builder/mod.rs
@@ -444,6 +444,7 @@ const PATH_REMAP: &[(&str, &[&str])] = &[
             "tests/mir-opt",
             "tests/pretty",
             "tests/run-make",
+            "tests/run-make-cargo",
             "tests/rustdoc",
             "tests/rustdoc-gui",
             "tests/rustdoc-js",
@@ -1127,8 +1128,8 @@ impl<'a> Builder<'a> {
                 test::RustInstaller,
                 test::TestFloatParse,
                 test::CollectLicenseMetadata,
-                // Run run-make last, since these won't pass without make on Windows
                 test::RunMake,
+                test::RunMakeCargo,
             ),
             Kind::Miri => describe!(test::Crate),
             Kind::Bench => describe!(test::Crate, test::CrateLibrustc),
diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index 9e8c13eb4dec7..4dad47daf8888 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -2099,8 +2099,9 @@ mod snapshot {
         [build] rustc 0 <host> -> HtmlChecker 1 <host>
         [test] html-check <host>
         [build] rustc 0 <host> -> RunMakeSupport 1 <host>
-        [build] rustc 0 <host> -> cargo 1 <host>
         [test] compiletest-run-make 1 <host>
+        [build] rustc 0 <host> -> cargo 1 <host>
+        [test] compiletest-run-make-cargo 1 <host>
         ");
     }
 
@@ -2118,7 +2119,6 @@ mod snapshot {
         [test] compiletest-ui 1 <host>
         [test] compiletest-ui-fulldeps 1 <host>
         [build] rustc 0 <host> -> RunMakeSupport 1 <host>
-        [build] rustc 0 <host> -> cargo 1 <host>
         [build] rustdoc 1 <host>
         [test] compiletest-run-make 1 <host>
         [test] compiletest-rustdoc 1 <host>
@@ -2147,7 +2147,6 @@ mod snapshot {
         [build] rustc 2 <host> -> rustc 3 <host>
         [test] compiletest-ui-fulldeps 2 <host>
         [build] rustc 0 <host> -> RunMakeSupport 1 <host>
-        [build] rustc 1 <host> -> cargo 2 <host>
         [build] rustdoc 2 <host>
         [test] compiletest-run-make 2 <host>
         [test] compiletest-rustdoc 2 <host>
@@ -2181,7 +2180,6 @@ mod snapshot {
         [build] rustc 2 <host> -> rustc 3 <target1>
         [test] compiletest-ui-fulldeps 2 <target1>
         [build] rustc 0 <host> -> RunMakeSupport 1 <host>
-        [build] rustc 1 <host> -> cargo 2 <host>
         [build] rustdoc 2 <host>
         [test] compiletest-run-make 2 <target1>
         [test] compiletest-rustdoc 2 <target1>
@@ -2276,8 +2274,9 @@ mod snapshot {
         [build] rustc 0 <host> -> HtmlChecker 1 <host>
         [test] html-check <host>
         [build] rustc 0 <host> -> RunMakeSupport 1 <host>
-        [build] rustc 1 <host> -> cargo 2 <host>
         [test] compiletest-run-make 2 <host>
+        [build] rustc 1 <host> -> cargo 2 <host>
+        [test] compiletest-run-make-cargo 2 <host>
         ");
     }
 
@@ -2411,6 +2410,43 @@ mod snapshot {
         ");
     }
 
+    // Differential snapshots for `./x test run-make` run `./x test run-make-cargo`: only
+    // `run-make-cargo` should build an in-tree cargo, running `./x test run-make` should not.
+    #[test]
+    fn test_run_make_no_cargo() {
+        let ctx = TestCtx::new();
+        insta::assert_snapshot!(
+            ctx.config("test")
+                .path("run-make")
+                .render_steps(), @r"
+        [build] llvm <host>
+        [build] rustc 0 <host> -> rustc 1 <host>
+        [build] rustc 0 <host> -> RunMakeSupport 1 <host>
+        [build] rustc 1 <host> -> std 1 <host>
+        [build] rustc 0 <host> -> Compiletest 1 <host>
+        [build] rustdoc 1 <host>
+        [test] compiletest-run-make 1 <host>
+        ");
+    }
+
+    #[test]
+    fn test_run_make_cargo_builds_cargo() {
+        let ctx = TestCtx::new();
+        insta::assert_snapshot!(
+            ctx.config("test")
+                .path("run-make-cargo")
+                .render_steps(), @r"
+        [build] llvm <host>
+        [build] rustc 0 <host> -> rustc 1 <host>
+        [build] rustc 0 <host> -> RunMakeSupport 1 <host>
+        [build] rustc 1 <host> -> std 1 <host>
+        [build] rustc 0 <host> -> Compiletest 1 <host>
+        [build] rustc 0 <host> -> cargo 1 <host>
+        [build] rustdoc 1 <host>
+        [test] compiletest-run-make-cargo 1 <host>
+        ");
+    }
+
     #[test]
     fn doc_all() {
         let ctx = TestCtx::new();

From f220710ace9d8caf1993d76469490bf60f76356a Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Fri, 5 Sep 2025 16:02:31 +0800
Subject: [PATCH 0528/1889] compiletest: implement
 {`run-make`,`run-make-cargo`} test suite split

- `run-make` test suite will now no longer receive a `cargo`.
    - NOTE: the user could technically still write
      `Command::new("cargo")` which might find *a* cargo from the
      environment, but that is not a supported case.
- `run-make-cargo` will receive a built in-tree `cargo`.
---
 src/tools/compiletest/src/common.rs           |  4 +---
 src/tools/compiletest/src/directives.rs       |  2 +-
 src/tools/compiletest/src/runtest/run_make.rs | 11 ++++++++---
 3 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
index 62fdee987355a..143ccdcb9e520 100644
--- a/src/tools/compiletest/src/common.rs
+++ b/src/tools/compiletest/src/common.rs
@@ -67,6 +67,7 @@ string_enum! {
         MirOpt => "mir-opt",
         Pretty => "pretty",
         RunMake => "run-make",
+        RunMakeCargo => "run-make-cargo",
         Rustdoc => "rustdoc",
         RustdocGui => "rustdoc-gui",
         RustdocJs => "rustdoc-js",
@@ -269,9 +270,6 @@ pub struct Config {
     /// between e.g. beta `cargo` vs in-tree `cargo`.
     ///
     /// FIXME: maybe rename this to reflect that this is a *staged* host cargo.
-    ///
-    /// FIXME(#134109): split `run-make` into two test suites, a test suite *with* staged cargo, and
-    /// another test suite *without*.
     pub cargo_path: Option<Utf8PathBuf>,
 
     /// Path to the stage 0 `rustc` used to build `run-make` recipes. This must not be confused with
diff --git a/src/tools/compiletest/src/directives.rs b/src/tools/compiletest/src/directives.rs
index f2ad049d5265a..857953072c436 100644
--- a/src/tools/compiletest/src/directives.rs
+++ b/src/tools/compiletest/src/directives.rs
@@ -1012,7 +1012,7 @@ impl Config {
         if let Some(raw) = self.parse_name_value_directive(line, "revisions", testfile, line_number)
         {
             if self.mode == TestMode::RunMake {
-                panic!("`run-make` tests do not support revisions: {}", testfile);
+                panic!("`run-make` mode tests do not support revisions: {}", testfile);
             }
 
             let mut duplicates: HashSet<_> = existing.iter().cloned().collect();
diff --git a/src/tools/compiletest/src/runtest/run_make.rs b/src/tools/compiletest/src/runtest/run_make.rs
index 8a0e45cf8ca35..738f504d5c1cf 100644
--- a/src/tools/compiletest/src/runtest/run_make.rs
+++ b/src/tools/compiletest/src/runtest/run_make.rs
@@ -5,11 +5,12 @@ use build_helper::fs::{ignore_not_found, recursive_remove};
 use camino::{Utf8Path, Utf8PathBuf};
 
 use super::{ProcRes, TestCx, disable_error_reporting};
+use crate::common::TestSuite;
 use crate::util::{copy_dir_all, dylib_env_var};
 
 impl TestCx<'_> {
     pub(super) fn run_rmake_test(&self) {
-        // For `run-make` V2, we need to perform 2 steps to build and run a `run-make` V2 recipe
+        // For `run-make`, we need to perform 2 steps to build and run a `run-make` recipe
         // (`rmake.rs`) to run the actual tests. The support library is already built as a tool rust
         // library and is available under
         // `build/$HOST/bootstrap-tools/$TARGET/release/librun_make_support.rlib`.
@@ -189,8 +190,12 @@ impl TestCx<'_> {
             // through a specific CI runner).
             .env("LLVM_COMPONENTS", &self.config.llvm_components);
 
-        if let Some(ref cargo) = self.config.cargo_path {
-            cmd.env("CARGO", cargo);
+        // Only `run-make-cargo` test suite gets an in-tree `cargo`, not `run-make`.
+        if self.config.suite == TestSuite::RunMakeCargo {
+            cmd.env(
+                "CARGO",
+                self.config.cargo_path.as_ref().expect("cargo must be built and made available"),
+            );
         }
 
         if let Some(ref rustdoc) = self.config.rustdoc_path {

From aebcbe0a4b1bb7df327bccf94a82117b4ca99a9f Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Fri, 5 Sep 2025 16:10:36 +0800
Subject: [PATCH 0529/1889] `run-make-support`: handle unavailable in-tree
 cargo under `run-make` test suite

---
 .../run-make-support/src/external_deps/cargo.rs    | 14 ++++++++++----
 src/tools/run-make-support/src/lib.rs              |  5 +++--
 2 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/src/tools/run-make-support/src/external_deps/cargo.rs b/src/tools/run-make-support/src/external_deps/cargo.rs
index 8da9f002c41b3..3f2d0ce14e3bc 100644
--- a/src/tools/run-make-support/src/external_deps/cargo.rs
+++ b/src/tools/run-make-support/src/external_deps/cargo.rs
@@ -1,11 +1,17 @@
 use crate::command::Command;
-use crate::env_var;
 use crate::util::set_host_compiler_dylib_path;
 
-/// Returns a command that can be used to invoke cargo. The cargo is provided by compiletest
-/// through the `CARGO` env var.
+/// Returns a command that can be used to invoke in-tree cargo. The cargo is provided by compiletest
+/// through the `CARGO` env var, and is **only** available for the `run-make-cargo` test suite.
 pub fn cargo() -> Command {
-    let mut cmd = Command::new(env_var("CARGO"));
+    let cargo_path = std::env::var("CARGO").unwrap_or_else(|e| {
+        panic!(
+            "in-tree `cargo` should be available for `run-make-cargo` test suite, but not \
+            `run-make` test suite: {e}"
+        )
+    });
+
+    let mut cmd = Command::new(cargo_path);
     set_host_compiler_dylib_path(&mut cmd);
     cmd
 }
diff --git a/src/tools/run-make-support/src/lib.rs b/src/tools/run-make-support/src/lib.rs
index 191e205f2577f..fef75401d9456 100644
--- a/src/tools/run-make-support/src/lib.rs
+++ b/src/tools/run-make-support/src/lib.rs
@@ -1,7 +1,8 @@
 //! `run-make-support` is a support library for run-make tests. It provides command wrappers and
 //! convenience utility functions to help test writers reduce duplication. The support library
-//! notably is built via cargo: this means that if your test wants some non-trivial utility, such
-//! as `object` or `wasmparser`, they can be re-exported and be made available through this library.
+//! notably is built via bootstrap cargo: this means that if your test wants some non-trivial
+//! utility, such as `object` or `wasmparser`, they can be re-exported and be made available through
+//! this library.
 
 #![warn(unreachable_pub)]
 

From 7154d39231fd8051bc207dda3afba21a11b14fcd Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Fri, 5 Sep 2025 16:28:10 +0800
Subject: [PATCH 0530/1889] tests: move `run-make` tests requiring in-tree
 cargo to `run-make-cargo` test suite

---
 tests/{run-make => run-make-cargo}/apple-slow-tls/rmake.rs        | 0
 .../apple-slow-tls/tls_test/Cargo.toml                            | 0
 .../apple-slow-tls/tls_test/src/main.rs                           | 0
 tests/{run-make => run-make-cargo}/compiler-builtins/Cargo.toml   | 0
 tests/{run-make => run-make-cargo}/compiler-builtins/lib.rs       | 0
 tests/{run-make => run-make-cargo}/compiler-builtins/rmake.rs     | 0
 .../{run-make => run-make-cargo}/rustc-crates-on-stable/rmake.rs  | 0
 .../rustdoc-scrape-examples-paths/foo/Cargo.toml                  | 0
 .../rustdoc-scrape-examples-paths/foo/examples/complex.rs         | 0
 .../rustdoc-scrape-examples-paths/foo/examples/tester.rs          | 0
 .../rustdoc-scrape-examples-paths/foo/src/lib.rs                  | 0
 .../rustdoc-scrape-examples-paths/rmake.rs                        | 0
 tests/{run-make => run-make-cargo}/thumb-none-cortex-m/rmake.rs   | 0
 .../thumb-none-qemu/example/.cargo/config.toml                    | 0
 .../thumb-none-qemu/example/Cargo.lock                            | 0
 .../thumb-none-qemu/example/Cargo.toml                            | 0
 .../{run-make => run-make-cargo}/thumb-none-qemu/example/memory.x | 0
 .../thumb-none-qemu/example/src/main.rs                           | 0
 tests/{run-make => run-make-cargo}/thumb-none-qemu/rmake.rs       | 0
 tests/{run-make => run-make-cargo}/uefi-qemu/rmake.rs             | 0
 .../uefi-qemu/uefi_qemu_test/Cargo.lock                           | 0
 .../uefi-qemu/uefi_qemu_test/Cargo.toml                           | 0
 .../uefi-qemu/uefi_qemu_test/src/main.rs                          | 0
 .../x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_asm.checks        | 0
 .../x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_c.checks          | 0
 .../x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_c_asm.checks      | 0
 .../x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_cxx.checks        | 0
 .../x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_cxx_asm.checks    | 0
 .../x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_asm.checks     | 0
 .../x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_c.checks       | 0
 .../x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_c_asm.checks   | 0
 .../cmake_plus_one_c_global_asm.checks                            | 0
 .../x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_cxx.checks     | 0
 .../x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_cxx_asm.checks | 0
 .../cmake_plus_one_cxx_global_asm.checks                          | 0
 .../x86_64-fortanix-unknown-sgx-lvi/enclave/Cargo.toml            | 0
 .../x86_64-fortanix-unknown-sgx-lvi/enclave/build.rs              | 0
 .../x86_64-fortanix-unknown-sgx-lvi/enclave/foo.c                 | 0
 .../x86_64-fortanix-unknown-sgx-lvi/enclave/foo_asm.s             | 0
 .../x86_64-fortanix-unknown-sgx-lvi/enclave/foo_cxx.cpp           | 0
 .../enclave/libcmake_foo/CMakeLists.txt                           | 0
 .../enclave/libcmake_foo/src/foo.c                                | 0
 .../enclave/libcmake_foo/src/foo_asm.s                            | 0
 .../enclave/libcmake_foo/src/foo_cxx.cpp                          | 0
 .../x86_64-fortanix-unknown-sgx-lvi/enclave/src/main.rs           | 0
 .../x86_64-fortanix-unknown-sgx-lvi/jumpto.checks                 | 0
 .../print.with_frame_pointers.checks                              | 0
 .../print.without_frame_pointers.checks                           | 0
 .../x86_64-fortanix-unknown-sgx-lvi/rmake.rs                      | 0
 .../rust_plus_one_global_asm.checks                               | 0
 .../x86_64-fortanix-unknown-sgx-lvi/unw_getcontext.checks         | 0
 51 files changed, 0 insertions(+), 0 deletions(-)
 rename tests/{run-make => run-make-cargo}/apple-slow-tls/rmake.rs (100%)
 rename tests/{run-make => run-make-cargo}/apple-slow-tls/tls_test/Cargo.toml (100%)
 rename tests/{run-make => run-make-cargo}/apple-slow-tls/tls_test/src/main.rs (100%)
 rename tests/{run-make => run-make-cargo}/compiler-builtins/Cargo.toml (100%)
 rename tests/{run-make => run-make-cargo}/compiler-builtins/lib.rs (100%)
 rename tests/{run-make => run-make-cargo}/compiler-builtins/rmake.rs (100%)
 rename tests/{run-make => run-make-cargo}/rustc-crates-on-stable/rmake.rs (100%)
 rename tests/{run-make => run-make-cargo}/rustdoc-scrape-examples-paths/foo/Cargo.toml (100%)
 rename tests/{run-make => run-make-cargo}/rustdoc-scrape-examples-paths/foo/examples/complex.rs (100%)
 rename tests/{run-make => run-make-cargo}/rustdoc-scrape-examples-paths/foo/examples/tester.rs (100%)
 rename tests/{run-make => run-make-cargo}/rustdoc-scrape-examples-paths/foo/src/lib.rs (100%)
 rename tests/{run-make => run-make-cargo}/rustdoc-scrape-examples-paths/rmake.rs (100%)
 rename tests/{run-make => run-make-cargo}/thumb-none-cortex-m/rmake.rs (100%)
 rename tests/{run-make => run-make-cargo}/thumb-none-qemu/example/.cargo/config.toml (100%)
 rename tests/{run-make => run-make-cargo}/thumb-none-qemu/example/Cargo.lock (100%)
 rename tests/{run-make => run-make-cargo}/thumb-none-qemu/example/Cargo.toml (100%)
 rename tests/{run-make => run-make-cargo}/thumb-none-qemu/example/memory.x (100%)
 rename tests/{run-make => run-make-cargo}/thumb-none-qemu/example/src/main.rs (100%)
 rename tests/{run-make => run-make-cargo}/thumb-none-qemu/rmake.rs (100%)
 rename tests/{run-make => run-make-cargo}/uefi-qemu/rmake.rs (100%)
 rename tests/{run-make => run-make-cargo}/uefi-qemu/uefi_qemu_test/Cargo.lock (100%)
 rename tests/{run-make => run-make-cargo}/uefi-qemu/uefi_qemu_test/Cargo.toml (100%)
 rename tests/{run-make => run-make-cargo}/uefi-qemu/uefi_qemu_test/src/main.rs (100%)
 rename tests/{run-make => run-make-cargo}/x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_asm.checks (100%)
 rename tests/{run-make => run-make-cargo}/x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_c.checks (100%)
 rename tests/{run-make => run-make-cargo}/x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_c_asm.checks (100%)
 rename tests/{run-make => run-make-cargo}/x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_cxx.checks (100%)
 rename tests/{run-make => run-make-cargo}/x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_cxx_asm.checks (100%)
 rename tests/{run-make => run-make-cargo}/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_asm.checks (100%)
 rename tests/{run-make => run-make-cargo}/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_c.checks (100%)
 rename tests/{run-make => run-make-cargo}/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_c_asm.checks (100%)
 rename tests/{run-make => run-make-cargo}/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_c_global_asm.checks (100%)
 rename tests/{run-make => run-make-cargo}/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_cxx.checks (100%)
 rename tests/{run-make => run-make-cargo}/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_cxx_asm.checks (100%)
 rename tests/{run-make => run-make-cargo}/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_cxx_global_asm.checks (100%)
 rename tests/{run-make => run-make-cargo}/x86_64-fortanix-unknown-sgx-lvi/enclave/Cargo.toml (100%)
 rename tests/{run-make => run-make-cargo}/x86_64-fortanix-unknown-sgx-lvi/enclave/build.rs (100%)
 rename tests/{run-make => run-make-cargo}/x86_64-fortanix-unknown-sgx-lvi/enclave/foo.c (100%)
 rename tests/{run-make => run-make-cargo}/x86_64-fortanix-unknown-sgx-lvi/enclave/foo_asm.s (100%)
 rename tests/{run-make => run-make-cargo}/x86_64-fortanix-unknown-sgx-lvi/enclave/foo_cxx.cpp (100%)
 rename tests/{run-make => run-make-cargo}/x86_64-fortanix-unknown-sgx-lvi/enclave/libcmake_foo/CMakeLists.txt (100%)
 rename tests/{run-make => run-make-cargo}/x86_64-fortanix-unknown-sgx-lvi/enclave/libcmake_foo/src/foo.c (100%)
 rename tests/{run-make => run-make-cargo}/x86_64-fortanix-unknown-sgx-lvi/enclave/libcmake_foo/src/foo_asm.s (100%)
 rename tests/{run-make => run-make-cargo}/x86_64-fortanix-unknown-sgx-lvi/enclave/libcmake_foo/src/foo_cxx.cpp (100%)
 rename tests/{run-make => run-make-cargo}/x86_64-fortanix-unknown-sgx-lvi/enclave/src/main.rs (100%)
 rename tests/{run-make => run-make-cargo}/x86_64-fortanix-unknown-sgx-lvi/jumpto.checks (100%)
 rename tests/{run-make => run-make-cargo}/x86_64-fortanix-unknown-sgx-lvi/print.with_frame_pointers.checks (100%)
 rename tests/{run-make => run-make-cargo}/x86_64-fortanix-unknown-sgx-lvi/print.without_frame_pointers.checks (100%)
 rename tests/{run-make => run-make-cargo}/x86_64-fortanix-unknown-sgx-lvi/rmake.rs (100%)
 rename tests/{run-make => run-make-cargo}/x86_64-fortanix-unknown-sgx-lvi/rust_plus_one_global_asm.checks (100%)
 rename tests/{run-make => run-make-cargo}/x86_64-fortanix-unknown-sgx-lvi/unw_getcontext.checks (100%)

diff --git a/tests/run-make/apple-slow-tls/rmake.rs b/tests/run-make-cargo/apple-slow-tls/rmake.rs
similarity index 100%
rename from tests/run-make/apple-slow-tls/rmake.rs
rename to tests/run-make-cargo/apple-slow-tls/rmake.rs
diff --git a/tests/run-make/apple-slow-tls/tls_test/Cargo.toml b/tests/run-make-cargo/apple-slow-tls/tls_test/Cargo.toml
similarity index 100%
rename from tests/run-make/apple-slow-tls/tls_test/Cargo.toml
rename to tests/run-make-cargo/apple-slow-tls/tls_test/Cargo.toml
diff --git a/tests/run-make/apple-slow-tls/tls_test/src/main.rs b/tests/run-make-cargo/apple-slow-tls/tls_test/src/main.rs
similarity index 100%
rename from tests/run-make/apple-slow-tls/tls_test/src/main.rs
rename to tests/run-make-cargo/apple-slow-tls/tls_test/src/main.rs
diff --git a/tests/run-make/compiler-builtins/Cargo.toml b/tests/run-make-cargo/compiler-builtins/Cargo.toml
similarity index 100%
rename from tests/run-make/compiler-builtins/Cargo.toml
rename to tests/run-make-cargo/compiler-builtins/Cargo.toml
diff --git a/tests/run-make/compiler-builtins/lib.rs b/tests/run-make-cargo/compiler-builtins/lib.rs
similarity index 100%
rename from tests/run-make/compiler-builtins/lib.rs
rename to tests/run-make-cargo/compiler-builtins/lib.rs
diff --git a/tests/run-make/compiler-builtins/rmake.rs b/tests/run-make-cargo/compiler-builtins/rmake.rs
similarity index 100%
rename from tests/run-make/compiler-builtins/rmake.rs
rename to tests/run-make-cargo/compiler-builtins/rmake.rs
diff --git a/tests/run-make/rustc-crates-on-stable/rmake.rs b/tests/run-make-cargo/rustc-crates-on-stable/rmake.rs
similarity index 100%
rename from tests/run-make/rustc-crates-on-stable/rmake.rs
rename to tests/run-make-cargo/rustc-crates-on-stable/rmake.rs
diff --git a/tests/run-make/rustdoc-scrape-examples-paths/foo/Cargo.toml b/tests/run-make-cargo/rustdoc-scrape-examples-paths/foo/Cargo.toml
similarity index 100%
rename from tests/run-make/rustdoc-scrape-examples-paths/foo/Cargo.toml
rename to tests/run-make-cargo/rustdoc-scrape-examples-paths/foo/Cargo.toml
diff --git a/tests/run-make/rustdoc-scrape-examples-paths/foo/examples/complex.rs b/tests/run-make-cargo/rustdoc-scrape-examples-paths/foo/examples/complex.rs
similarity index 100%
rename from tests/run-make/rustdoc-scrape-examples-paths/foo/examples/complex.rs
rename to tests/run-make-cargo/rustdoc-scrape-examples-paths/foo/examples/complex.rs
diff --git a/tests/run-make/rustdoc-scrape-examples-paths/foo/examples/tester.rs b/tests/run-make-cargo/rustdoc-scrape-examples-paths/foo/examples/tester.rs
similarity index 100%
rename from tests/run-make/rustdoc-scrape-examples-paths/foo/examples/tester.rs
rename to tests/run-make-cargo/rustdoc-scrape-examples-paths/foo/examples/tester.rs
diff --git a/tests/run-make/rustdoc-scrape-examples-paths/foo/src/lib.rs b/tests/run-make-cargo/rustdoc-scrape-examples-paths/foo/src/lib.rs
similarity index 100%
rename from tests/run-make/rustdoc-scrape-examples-paths/foo/src/lib.rs
rename to tests/run-make-cargo/rustdoc-scrape-examples-paths/foo/src/lib.rs
diff --git a/tests/run-make/rustdoc-scrape-examples-paths/rmake.rs b/tests/run-make-cargo/rustdoc-scrape-examples-paths/rmake.rs
similarity index 100%
rename from tests/run-make/rustdoc-scrape-examples-paths/rmake.rs
rename to tests/run-make-cargo/rustdoc-scrape-examples-paths/rmake.rs
diff --git a/tests/run-make/thumb-none-cortex-m/rmake.rs b/tests/run-make-cargo/thumb-none-cortex-m/rmake.rs
similarity index 100%
rename from tests/run-make/thumb-none-cortex-m/rmake.rs
rename to tests/run-make-cargo/thumb-none-cortex-m/rmake.rs
diff --git a/tests/run-make/thumb-none-qemu/example/.cargo/config.toml b/tests/run-make-cargo/thumb-none-qemu/example/.cargo/config.toml
similarity index 100%
rename from tests/run-make/thumb-none-qemu/example/.cargo/config.toml
rename to tests/run-make-cargo/thumb-none-qemu/example/.cargo/config.toml
diff --git a/tests/run-make/thumb-none-qemu/example/Cargo.lock b/tests/run-make-cargo/thumb-none-qemu/example/Cargo.lock
similarity index 100%
rename from tests/run-make/thumb-none-qemu/example/Cargo.lock
rename to tests/run-make-cargo/thumb-none-qemu/example/Cargo.lock
diff --git a/tests/run-make/thumb-none-qemu/example/Cargo.toml b/tests/run-make-cargo/thumb-none-qemu/example/Cargo.toml
similarity index 100%
rename from tests/run-make/thumb-none-qemu/example/Cargo.toml
rename to tests/run-make-cargo/thumb-none-qemu/example/Cargo.toml
diff --git a/tests/run-make/thumb-none-qemu/example/memory.x b/tests/run-make-cargo/thumb-none-qemu/example/memory.x
similarity index 100%
rename from tests/run-make/thumb-none-qemu/example/memory.x
rename to tests/run-make-cargo/thumb-none-qemu/example/memory.x
diff --git a/tests/run-make/thumb-none-qemu/example/src/main.rs b/tests/run-make-cargo/thumb-none-qemu/example/src/main.rs
similarity index 100%
rename from tests/run-make/thumb-none-qemu/example/src/main.rs
rename to tests/run-make-cargo/thumb-none-qemu/example/src/main.rs
diff --git a/tests/run-make/thumb-none-qemu/rmake.rs b/tests/run-make-cargo/thumb-none-qemu/rmake.rs
similarity index 100%
rename from tests/run-make/thumb-none-qemu/rmake.rs
rename to tests/run-make-cargo/thumb-none-qemu/rmake.rs
diff --git a/tests/run-make/uefi-qemu/rmake.rs b/tests/run-make-cargo/uefi-qemu/rmake.rs
similarity index 100%
rename from tests/run-make/uefi-qemu/rmake.rs
rename to tests/run-make-cargo/uefi-qemu/rmake.rs
diff --git a/tests/run-make/uefi-qemu/uefi_qemu_test/Cargo.lock b/tests/run-make-cargo/uefi-qemu/uefi_qemu_test/Cargo.lock
similarity index 100%
rename from tests/run-make/uefi-qemu/uefi_qemu_test/Cargo.lock
rename to tests/run-make-cargo/uefi-qemu/uefi_qemu_test/Cargo.lock
diff --git a/tests/run-make/uefi-qemu/uefi_qemu_test/Cargo.toml b/tests/run-make-cargo/uefi-qemu/uefi_qemu_test/Cargo.toml
similarity index 100%
rename from tests/run-make/uefi-qemu/uefi_qemu_test/Cargo.toml
rename to tests/run-make-cargo/uefi-qemu/uefi_qemu_test/Cargo.toml
diff --git a/tests/run-make/uefi-qemu/uefi_qemu_test/src/main.rs b/tests/run-make-cargo/uefi-qemu/uefi_qemu_test/src/main.rs
similarity index 100%
rename from tests/run-make/uefi-qemu/uefi_qemu_test/src/main.rs
rename to tests/run-make-cargo/uefi-qemu/uefi_qemu_test/src/main.rs
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_asm.checks b/tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_asm.checks
similarity index 100%
rename from tests/run-make/x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_asm.checks
rename to tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_asm.checks
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_c.checks b/tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_c.checks
similarity index 100%
rename from tests/run-make/x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_c.checks
rename to tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_c.checks
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_c_asm.checks b/tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_c_asm.checks
similarity index 100%
rename from tests/run-make/x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_c_asm.checks
rename to tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_c_asm.checks
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_cxx.checks b/tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_cxx.checks
similarity index 100%
rename from tests/run-make/x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_cxx.checks
rename to tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_cxx.checks
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_cxx_asm.checks b/tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_cxx_asm.checks
similarity index 100%
rename from tests/run-make/x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_cxx_asm.checks
rename to tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/cc_plus_one_cxx_asm.checks
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_asm.checks b/tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_asm.checks
similarity index 100%
rename from tests/run-make/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_asm.checks
rename to tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_asm.checks
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_c.checks b/tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_c.checks
similarity index 100%
rename from tests/run-make/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_c.checks
rename to tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_c.checks
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_c_asm.checks b/tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_c_asm.checks
similarity index 100%
rename from tests/run-make/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_c_asm.checks
rename to tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_c_asm.checks
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_c_global_asm.checks b/tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_c_global_asm.checks
similarity index 100%
rename from tests/run-make/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_c_global_asm.checks
rename to tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_c_global_asm.checks
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_cxx.checks b/tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_cxx.checks
similarity index 100%
rename from tests/run-make/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_cxx.checks
rename to tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_cxx.checks
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_cxx_asm.checks b/tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_cxx_asm.checks
similarity index 100%
rename from tests/run-make/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_cxx_asm.checks
rename to tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_cxx_asm.checks
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_cxx_global_asm.checks b/tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_cxx_global_asm.checks
similarity index 100%
rename from tests/run-make/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_cxx_global_asm.checks
rename to tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/cmake_plus_one_cxx_global_asm.checks
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/enclave/Cargo.toml b/tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/enclave/Cargo.toml
similarity index 100%
rename from tests/run-make/x86_64-fortanix-unknown-sgx-lvi/enclave/Cargo.toml
rename to tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/enclave/Cargo.toml
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/enclave/build.rs b/tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/enclave/build.rs
similarity index 100%
rename from tests/run-make/x86_64-fortanix-unknown-sgx-lvi/enclave/build.rs
rename to tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/enclave/build.rs
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/enclave/foo.c b/tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/enclave/foo.c
similarity index 100%
rename from tests/run-make/x86_64-fortanix-unknown-sgx-lvi/enclave/foo.c
rename to tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/enclave/foo.c
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/enclave/foo_asm.s b/tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/enclave/foo_asm.s
similarity index 100%
rename from tests/run-make/x86_64-fortanix-unknown-sgx-lvi/enclave/foo_asm.s
rename to tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/enclave/foo_asm.s
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/enclave/foo_cxx.cpp b/tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/enclave/foo_cxx.cpp
similarity index 100%
rename from tests/run-make/x86_64-fortanix-unknown-sgx-lvi/enclave/foo_cxx.cpp
rename to tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/enclave/foo_cxx.cpp
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/enclave/libcmake_foo/CMakeLists.txt b/tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/enclave/libcmake_foo/CMakeLists.txt
similarity index 100%
rename from tests/run-make/x86_64-fortanix-unknown-sgx-lvi/enclave/libcmake_foo/CMakeLists.txt
rename to tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/enclave/libcmake_foo/CMakeLists.txt
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/enclave/libcmake_foo/src/foo.c b/tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/enclave/libcmake_foo/src/foo.c
similarity index 100%
rename from tests/run-make/x86_64-fortanix-unknown-sgx-lvi/enclave/libcmake_foo/src/foo.c
rename to tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/enclave/libcmake_foo/src/foo.c
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/enclave/libcmake_foo/src/foo_asm.s b/tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/enclave/libcmake_foo/src/foo_asm.s
similarity index 100%
rename from tests/run-make/x86_64-fortanix-unknown-sgx-lvi/enclave/libcmake_foo/src/foo_asm.s
rename to tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/enclave/libcmake_foo/src/foo_asm.s
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/enclave/libcmake_foo/src/foo_cxx.cpp b/tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/enclave/libcmake_foo/src/foo_cxx.cpp
similarity index 100%
rename from tests/run-make/x86_64-fortanix-unknown-sgx-lvi/enclave/libcmake_foo/src/foo_cxx.cpp
rename to tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/enclave/libcmake_foo/src/foo_cxx.cpp
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/enclave/src/main.rs b/tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/enclave/src/main.rs
similarity index 100%
rename from tests/run-make/x86_64-fortanix-unknown-sgx-lvi/enclave/src/main.rs
rename to tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/enclave/src/main.rs
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/jumpto.checks b/tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/jumpto.checks
similarity index 100%
rename from tests/run-make/x86_64-fortanix-unknown-sgx-lvi/jumpto.checks
rename to tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/jumpto.checks
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/print.with_frame_pointers.checks b/tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/print.with_frame_pointers.checks
similarity index 100%
rename from tests/run-make/x86_64-fortanix-unknown-sgx-lvi/print.with_frame_pointers.checks
rename to tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/print.with_frame_pointers.checks
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/print.without_frame_pointers.checks b/tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/print.without_frame_pointers.checks
similarity index 100%
rename from tests/run-make/x86_64-fortanix-unknown-sgx-lvi/print.without_frame_pointers.checks
rename to tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/print.without_frame_pointers.checks
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/rmake.rs b/tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/rmake.rs
similarity index 100%
rename from tests/run-make/x86_64-fortanix-unknown-sgx-lvi/rmake.rs
rename to tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/rmake.rs
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/rust_plus_one_global_asm.checks b/tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/rust_plus_one_global_asm.checks
similarity index 100%
rename from tests/run-make/x86_64-fortanix-unknown-sgx-lvi/rust_plus_one_global_asm.checks
rename to tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/rust_plus_one_global_asm.checks
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/unw_getcontext.checks b/tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/unw_getcontext.checks
similarity index 100%
rename from tests/run-make/x86_64-fortanix-unknown-sgx-lvi/unw_getcontext.checks
rename to tests/run-make-cargo/x86_64-fortanix-unknown-sgx-lvi/unw_getcontext.checks

From 9504090e7de2651b23ff83aaff7ef6eceab0024c Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Fri, 5 Sep 2025 16:48:11 +0800
Subject: [PATCH 0531/1889] tests: update test instruction in
 `thumb-none-cortex-m`

---
 tests/run-make-cargo/thumb-none-cortex-m/rmake.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/run-make-cargo/thumb-none-cortex-m/rmake.rs b/tests/run-make-cargo/thumb-none-cortex-m/rmake.rs
index 27afef874da64..6158b9c36da24 100644
--- a/tests/run-make-cargo/thumb-none-cortex-m/rmake.rs
+++ b/tests/run-make-cargo/thumb-none-cortex-m/rmake.rs
@@ -4,7 +4,7 @@
 //!
 //! How to run this
 //! $ ./x.py clean
-//! $ ./x.py test --target thumbv6m-none-eabi,thumbv7m-none-eabi tests/run-make
+//! $ ./x.py test --target thumbv6m-none-eabi,thumbv7m-none-eabi tests/run-make-cargo
 //!
 //! Supported targets:
 //! - thumbv6m-none-eabi (Bare Cortex-M0, M0+, M1)

From 81042523c6e1ae50682f46ae3da4ede22bfd596e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Fri, 5 Sep 2025 15:38:01 +0200
Subject: [PATCH 0532/1889] remove couple of clones

---
 compiler/rustc_codegen_ssa/src/lib.rs                           | 2 +-
 compiler/rustc_mir_transform/src/coverage/expansion.rs          | 2 +-
 compiler/rustc_resolve/src/late/diagnostics.rs                  | 2 +-
 compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/lib.rs b/compiler/rustc_codegen_ssa/src/lib.rs
index 5b90ffaa05666..23146661f27c0 100644
--- a/compiler/rustc_codegen_ssa/src/lib.rs
+++ b/compiler/rustc_codegen_ssa/src/lib.rs
@@ -119,7 +119,7 @@ impl<M> ModuleCodegen<M> {
         });
 
         CompiledModule {
-            name: self.name.clone(),
+            name: self.name,
             object,
             dwarf_object,
             bytecode,
diff --git a/compiler/rustc_mir_transform/src/coverage/expansion.rs b/compiler/rustc_mir_transform/src/coverage/expansion.rs
index 91e0528f52f94..851bbaeed48eb 100644
--- a/compiler/rustc_mir_transform/src/coverage/expansion.rs
+++ b/compiler/rustc_mir_transform/src/coverage/expansion.rs
@@ -82,7 +82,7 @@ impl ExpnNode {
         Self {
             expn_id,
 
-            expn_kind: expn_data.kind.clone(),
+            expn_kind: expn_data.kind,
             call_site,
             call_site_expn_id,
 
diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs
index 80b2095d8ccff..9e3c093883661 100644
--- a/compiler/rustc_resolve/src/late/diagnostics.rs
+++ b/compiler/rustc_resolve/src/late/diagnostics.rs
@@ -3099,7 +3099,7 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
                 |err, _, span, message, suggestion, span_suggs| {
                     err.multipart_suggestion_verbose(
                         message,
-                        std::iter::once((span, suggestion)).chain(span_suggs.clone()).collect(),
+                        std::iter::once((span, suggestion)).chain(span_suggs).collect(),
                         Applicability::MaybeIncorrect,
                     );
                     true
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 9447612d026b1..812e20e433822 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
@@ -318,7 +318,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     let (expected, found) = if expected_str == found_str {
                         (join_path_syms(&expected_abs), join_path_syms(&found_abs))
                     } else {
-                        (expected_str.clone(), found_str.clone())
+                        (expected_str, found_str)
                     };
 
                     // We've displayed "expected `a::b`, found `a::b`". We add context to

From c959d3a54156593e58d480f53edafe681c031c19 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Fri, 5 Sep 2025 16:47:35 +0800
Subject: [PATCH 0533/1889] ci: update jobs to also run `tests/run-make-cargo`

For the ones that explicitly picks which test suite to run.
---
 .../docker/host-aarch64/aarch64-gnu-debug/Dockerfile   |  2 +-
 src/ci/docker/host-x86_64/dist-various-1/Dockerfile    |  2 +-
 src/ci/docker/host-x86_64/test-various/Dockerfile      | 10 ++++++----
 src/ci/docker/host-x86_64/x86_64-gnu-debug/Dockerfile  |  2 +-
 4 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/src/ci/docker/host-aarch64/aarch64-gnu-debug/Dockerfile b/src/ci/docker/host-aarch64/aarch64-gnu-debug/Dockerfile
index cf030f6830e5b..71de8f917fa2c 100644
--- a/src/ci/docker/host-aarch64/aarch64-gnu-debug/Dockerfile
+++ b/src/ci/docker/host-aarch64/aarch64-gnu-debug/Dockerfile
@@ -54,4 +54,4 @@ ENV RUST_CONFIGURE_ARGS \
 
 ENV SCRIPT \
   python3 ../x.py --stage 2 build && \
-  python3 ../x.py --stage 2 test tests/run-make
+  python3 ../x.py --stage 2 test tests/run-make tests/run-make-cargo
diff --git a/src/ci/docker/host-x86_64/dist-various-1/Dockerfile b/src/ci/docker/host-x86_64/dist-various-1/Dockerfile
index 4d5980027cac1..e59012ff6afa9 100644
--- a/src/ci/docker/host-x86_64/dist-various-1/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-various-1/Dockerfile
@@ -158,7 +158,7 @@ ENV RUST_CONFIGURE_ARGS \
       --disable-docs
 
 ENV SCRIPT \
-      python3 ../x.py --stage 2 test --host='' --target $RUN_MAKE_TARGETS tests/run-make && \
+      python3 ../x.py --stage 2 test --host='' --target $RUN_MAKE_TARGETS tests/run-make tests/run-make-cargo && \
       python3 ../x.py dist --host='' --target $TARGETS
 
 # sccache
diff --git a/src/ci/docker/host-x86_64/test-various/Dockerfile b/src/ci/docker/host-x86_64/test-various/Dockerfile
index 6ff529c9e718b..e1c882d5b0850 100644
--- a/src/ci/docker/host-x86_64/test-various/Dockerfile
+++ b/src/ci/docker/host-x86_64/test-various/Dockerfile
@@ -60,9 +60,10 @@ RUN curl -L https://github.com/bytecodealliance/wasmtime/releases/download/v19.0
   tar -xJ
 ENV PATH "$PATH:/wasmtime-v19.0.0-x86_64-linux"
 
-ENV WASM_WASIP_TARGET=wasm32-wasip1 
+ENV WASM_WASIP_TARGET=wasm32-wasip1
 ENV WASM_WASIP_SCRIPT python3 /checkout/x.py --stage 2 test --host='' --target $WASM_WASIP_TARGET \
   tests/run-make \
+  tests/run-make-cargo \
   tests/ui \
   tests/mir-opt \
   tests/codegen-units \
@@ -73,6 +74,7 @@ ENV WASM_WASIP_SCRIPT python3 /checkout/x.py --stage 2 test --host='' --target $
 ENV NVPTX_TARGETS=nvptx64-nvidia-cuda
 ENV NVPTX_SCRIPT python3 /checkout/x.py --stage 2 test --host='' --target $NVPTX_TARGETS \
   tests/run-make \
+  tests/run-make-cargo \
   tests/assembly-llvm
 
 ENV MUSL_TARGETS=x86_64-unknown-linux-musl \
@@ -88,8 +90,8 @@ ENV UEFI_TARGETS=aarch64-unknown-uefi,i686-unknown-uefi,x86_64-unknown-uefi \
     CC_x86_64_unknown_uefi=clang-11 \
     CXX_x86_64_unknown_uefi=clang++-11
 ENV UEFI_SCRIPT python3 /checkout/x.py --stage 2 build --host='' --target $UEFI_TARGETS && \
-  python3 /checkout/x.py --stage 2 test tests/run-make/uefi-qemu/rmake.rs --target aarch64-unknown-uefi && \
-  python3 /checkout/x.py --stage 2 test tests/run-make/uefi-qemu/rmake.rs --target i686-unknown-uefi && \
-  python3 /checkout/x.py --stage 2 test tests/run-make/uefi-qemu/rmake.rs --target x86_64-unknown-uefi
+  python3 /checkout/x.py --stage 2 test tests/run-make-cargo/uefi-qemu/rmake.rs --target aarch64-unknown-uefi && \
+  python3 /checkout/x.py --stage 2 test tests/run-make-cargo/uefi-qemu/rmake.rs --target i686-unknown-uefi && \
+  python3 /checkout/x.py --stage 2 test tests/run-make-cargo/uefi-qemu/rmake.rs --target x86_64-unknown-uefi
 
 ENV SCRIPT $WASM_WASIP_SCRIPT && $NVPTX_SCRIPT && $MUSL_SCRIPT && $UEFI_SCRIPT
diff --git a/src/ci/docker/host-x86_64/x86_64-gnu-debug/Dockerfile b/src/ci/docker/host-x86_64/x86_64-gnu-debug/Dockerfile
index 5052d86f0ac74..7e6a59aaf898e 100644
--- a/src/ci/docker/host-x86_64/x86_64-gnu-debug/Dockerfile
+++ b/src/ci/docker/host-x86_64/x86_64-gnu-debug/Dockerfile
@@ -56,4 +56,4 @@ ENV RUST_CONFIGURE_ARGS \
 ENV SCRIPT \
   python3 ../x.py --stage 2 build && \
   python3 ../x.py --stage 2 test tests/ui && \
-  python3 ../x.py --stage 2 test tests/run-make
+  python3 ../x.py --stage 2 test tests/run-make tests/run-make-cargo

From e77a22f3c995e439d79dcf2b2c96835dbd0f2cb8 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Fri, 5 Sep 2025 16:35:36 +0800
Subject: [PATCH 0534/1889] cg_clif: account for moved
 `tests/run-make-cargo/compiler-builtins`

---
 compiler/rustc_codegen_cranelift/scripts/test_rustc_tests.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_codegen_cranelift/scripts/test_rustc_tests.sh b/compiler/rustc_codegen_cranelift/scripts/test_rustc_tests.sh
index 52e02c857c7ad..476a6f311bbf4 100755
--- a/compiler/rustc_codegen_cranelift/scripts/test_rustc_tests.sh
+++ b/compiler/rustc_codegen_cranelift/scripts/test_rustc_tests.sh
@@ -121,7 +121,7 @@ rm tests/ui/abi/large-byval-align.rs # exceeds implementation limit of Cranelift
 # ============================================================
 rm -r tests/run-make/remap-path-prefix-dwarf # requires llvm-dwarfdump
 rm -r tests/run-make/strip # same
-rm -r tests/run-make/compiler-builtins # Expects lib/rustlib/src/rust to contains the standard library source
+rm -r tests/run-make-cargo/compiler-builtins # Expects lib/rustlib/src/rust to contains the standard library source
 rm -r tests/run-make/translation # same
 rm -r tests/run-make/missing-unstable-trait-bound # This disables support for unstable features, but running cg_clif needs some unstable features
 rm -r tests/run-make/const-trait-stable-toolchain # same

From 6543e4d2fa0113fef4177e92b73a5d7c6411a9ad Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Fri, 5 Sep 2025 21:24:45 +0800
Subject: [PATCH 0535/1889] cg_clif: run `run-make-cargo` test suite

---
 compiler/rustc_codegen_cranelift/scripts/test_rustc_tests.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_codegen_cranelift/scripts/test_rustc_tests.sh b/compiler/rustc_codegen_cranelift/scripts/test_rustc_tests.sh
index 476a6f311bbf4..62f1cc6a8933b 100755
--- a/compiler/rustc_codegen_cranelift/scripts/test_rustc_tests.sh
+++ b/compiler/rustc_codegen_cranelift/scripts/test_rustc_tests.sh
@@ -166,5 +166,5 @@ index 073116933bd..c3e4578204d 100644
 EOF
 
 echo "[TEST] rustc test suite"
-./x.py test --stage 0 --test-args=--no-capture tests/{codegen-units,run-make,ui,incremental}
+./x.py test --stage 0 --test-args=--no-capture tests/{codegen-units,run-make,run-make-cargo,ui,incremental}
 popd

From 1a2055a5252054e597655fc42df910f074ab0fbf Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Fri, 5 Sep 2025 21:39:29 +0800
Subject: [PATCH 0536/1889] cg_gcc: run `run-make-cargo` tests

---
 .../build_system/src/test.rs                  | 22 ++++++++++++++++---
 1 file changed, 19 insertions(+), 3 deletions(-)

diff --git a/compiler/rustc_codegen_gcc/build_system/src/test.rs b/compiler/rustc_codegen_gcc/build_system/src/test.rs
index 3dd3fce2eec5d..1823aa71f408e 100644
--- a/compiler/rustc_codegen_gcc/build_system/src/test.rs
+++ b/compiler/rustc_codegen_gcc/build_system/src/test.rs
@@ -1083,11 +1083,12 @@ where
 
 fn test_rustc(env: &Env, args: &TestArg) -> Result<(), String> {
     test_rustc_inner(env, args, |_| Ok(false), false, "run-make")?;
+    test_rustc_inner(env, args, |_| Ok(false), false, "run-make-cargo")?;
     test_rustc_inner(env, args, |_| Ok(false), false, "ui")
 }
 
 fn test_failing_rustc(env: &Env, args: &TestArg) -> Result<(), String> {
-    let result1 = test_rustc_inner(
+    let run_make_result = test_rustc_inner(
         env,
         args,
         retain_files_callback("tests/failing-run-make-tests.txt", "run-make"),
@@ -1095,7 +1096,15 @@ fn test_failing_rustc(env: &Env, args: &TestArg) -> Result<(), String> {
         "run-make",
     );
 
-    let result2 = test_rustc_inner(
+    let run_make_cargo_result = test_rustc_inner(
+        env,
+        args,
+        retain_files_callback("tests/failing-run-make-tests.txt", "run-make-cargo"),
+        false,
+        "run-make",
+    );
+
+    let ui_result = test_rustc_inner(
         env,
         args,
         retain_files_callback("tests/failing-ui-tests.txt", "ui"),
@@ -1103,7 +1112,7 @@ fn test_failing_rustc(env: &Env, args: &TestArg) -> Result<(), String> {
         "ui",
     );
 
-    result1.and(result2)
+    run_make_result.and(run_make_cargo_result).and(ui_result)
 }
 
 fn test_successful_rustc(env: &Env, args: &TestArg) -> Result<(), String> {
@@ -1120,6 +1129,13 @@ fn test_successful_rustc(env: &Env, args: &TestArg) -> Result<(), String> {
         remove_files_callback("tests/failing-run-make-tests.txt", "run-make"),
         false,
         "run-make",
+    )?;
+    test_rustc_inner(
+        env,
+        args,
+        remove_files_callback("tests/failing-run-make-tests.txt", "run-make-cargo"),
+        false,
+        "run-make-cargo",
     )
 }
 

From 34158add05c09a4a60162d5afb09d3c6e607a529 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Fri, 5 Sep 2025 16:38:09 +0800
Subject: [PATCH 0537/1889] tidy: account for moved `tests/run-make/uefi-qemu`

---
 src/tools/tidy/src/deps.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs
index 560f11ecf50ec..fee48bea144de 100644
--- a/src/tools/tidy/src/deps.rs
+++ b/src/tools/tidy/src/deps.rs
@@ -80,7 +80,7 @@ pub(crate) const WORKSPACES: &[(&str, ExceptionList, Option<(&[&str], &[&str])>,
     ("src/tools/rustbook", EXCEPTIONS_RUSTBOOK, None, &["src/doc/book", "src/doc/reference"]),
     ("src/tools/rustc-perf", EXCEPTIONS_RUSTC_PERF, None, &["src/tools/rustc-perf"]),
     ("src/tools/test-float-parse", EXCEPTIONS, None, &[]),
-    ("tests/run-make/uefi-qemu/uefi_qemu_test", EXCEPTIONS_UEFI_QEMU_TEST, None, &[]),
+    ("tests/run-make-cargo/uefi-qemu/uefi_qemu_test", EXCEPTIONS_UEFI_QEMU_TEST, None, &[]),
     // tidy-alphabetical-end
 ];
 

From 8665305f2b4c75b79de950d49002cf29a290f76b Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Fri, 5 Sep 2025 16:33:43 +0800
Subject: [PATCH 0538/1889] triagebot: account for new `tests/run-make-cargo`
 test suite

---
 triagebot.toml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/triagebot.toml b/triagebot.toml
index b957c6465e602..eda48cfefb221 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -336,6 +336,7 @@ trigger_files = [
     "tests/mir-opt",
     "tests/pretty",
     "tests/run-make",
+    "tests/run-make-cargo",
     "tests/ui",
     "tests/ui-fulldeps",
 ]
@@ -592,6 +593,7 @@ trigger_files = [
 [autolabel."A-run-make"]
 trigger_files = [
     "tests/run-make",
+    "tests/run-make-cargo",
     "src/tools/run-make-support"
 ]
 
@@ -1542,6 +1544,7 @@ dep-bumps = [
 "/src/rustdoc-json-types" =                              ["rustdoc"]
 "/src/stage0" =                                          ["bootstrap"]
 "/tests/run-make" =                                      ["@jieyouxu"]
+"/tests/run-make-cargo" =                                ["@jieyouxu"]
 "/tests/rustdoc" =                                       ["rustdoc"]
 "/tests/rustdoc-gui" =                                   ["rustdoc"]
 "/tests/rustdoc-js-std" =                                ["rustdoc"]

From f755e64c36edf552a222a165fca3027f1063c817 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Fri, 5 Sep 2025 17:00:42 +0800
Subject: [PATCH 0539/1889] rustc-dev-guide: update docs for `run-make-cargo`

---
 src/doc/rustc-dev-guide/src/tests/adding.md   |  2 +
 .../src/tests/best-practices.md               |  8 ++--
 .../rustc-dev-guide/src/tests/compiletest.md  | 15 +++++--
 .../rustc-dev-guide/src/tests/directives.md   | 40 +++++++++----------
 src/doc/rustc-dev-guide/src/tests/misc.md     |  4 +-
 5 files changed, 39 insertions(+), 30 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/tests/adding.md b/src/doc/rustc-dev-guide/src/tests/adding.md
index e5c26bef11d0c..46b8a1e4cf4b4 100644
--- a/src/doc/rustc-dev-guide/src/tests/adding.md
+++ b/src/doc/rustc-dev-guide/src/tests/adding.md
@@ -29,6 +29,8 @@ guidelines:
     suites.
   - Need to inspect the resulting binary in some way? Or if all the other test
     suites are too limited for your purposes? Then use `run-make`.
+    - Use `run-make-cargo` if you need to exercise in-tree `cargo` in conjunction
+      with in-tree `rustc`.
   - Check out the [compiletest] chapter for more specialized test suites.
 
 After deciding on which kind of test to add, see [best
diff --git a/src/doc/rustc-dev-guide/src/tests/best-practices.md b/src/doc/rustc-dev-guide/src/tests/best-practices.md
index be00207e3fb93..efc626035b79d 100644
--- a/src/doc/rustc-dev-guide/src/tests/best-practices.md
+++ b/src/doc/rustc-dev-guide/src/tests/best-practices.md
@@ -83,10 +83,10 @@ related tests.
     - E.g. for an implementation of RFC 2093 specifically, we can group a
       collection of tests under `tests/ui/rfc-2093-infer-outlives/`. For the
       directory name, include what the RFC is about.
-- For the [`run-make`] test suite, each `rmake.rs` must be contained within an
-  immediate subdirectory under `tests/run-make/`. Further nesting is not
-  presently supported. Avoid including issue number in the directory name too,
-  include that info in a comment inside `rmake.rs`.
+- For the [`run-make`]/`run-make-support` test suites, each `rmake.rs` must
+  be contained within an immediate subdirectory under `tests/run-make/` or
+  `tests/run-make-cargo/` respectively. Further nesting is not presently
+  supported. Avoid using _only_ an issue number for the test name as well.
 
 ## Test descriptions
 
diff --git a/src/doc/rustc-dev-guide/src/tests/compiletest.md b/src/doc/rustc-dev-guide/src/tests/compiletest.md
index 4980ed845d6dd..a4a729935fa47 100644
--- a/src/doc/rustc-dev-guide/src/tests/compiletest.md
+++ b/src/doc/rustc-dev-guide/src/tests/compiletest.md
@@ -397,13 +397,19 @@ your test, causing separate files to be generated for 32bit and 64bit systems.
 
 ### `run-make` tests
 
-The tests in [`tests/run-make`] are general-purpose tests using Rust *recipes*,
-which are small programs (`rmake.rs`) allowing arbitrary Rust code such as
-`rustc` invocations, and is supported by a [`run_make_support`] library. Using
-Rust recipes provide the ultimate in flexibility.
+The tests in [`tests/run-make`] and [`tests/run-make-cargo`] are general-purpose
+tests using Rust *recipes*, which are small programs (`rmake.rs`) allowing
+arbitrary Rust code such as `rustc` invocations, and is supported by a
+[`run_make_support`] library. Using Rust recipes provide the ultimate in
+flexibility.
 
 `run-make` tests should be used if no other test suites better suit your needs.
 
+The `run-make-cargo` test suite additionally builds an in-tree `cargo` to support
+use cases that require testing in-tree `cargo` in conjunction with in-tree `rustc`.
+The `run-make` test suite does not have access to in-tree `cargo` (so it can be the
+faster-to-iterate test suite).
+
 #### Using Rust recipes
 
 Each test should be in a separate directory with a `rmake.rs` Rust program,
@@ -476,6 +482,7 @@ Then add a corresponding entry to `"rust-analyzer.linkedProjects"`
 ```
 
 [`tests/run-make`]: https://github.com/rust-lang/rust/tree/master/tests/run-make
+[`tests/run-make-cargo`]: https://github.com/rust-lang/rust/tree/master/tests/run-make-cargo
 [`run_make_support`]: https://github.com/rust-lang/rust/tree/master/src/tools/run-make-support
 
 ### Coverage tests
diff --git a/src/doc/rustc-dev-guide/src/tests/directives.md b/src/doc/rustc-dev-guide/src/tests/directives.md
index fbbeb7e97d3b7..4ff6b7cb10f00 100644
--- a/src/doc/rustc-dev-guide/src/tests/directives.md
+++ b/src/doc/rustc-dev-guide/src/tests/directives.md
@@ -52,14 +52,14 @@ not be exhaustive. Directives can generally be found by browsing the
 
 See [Building auxiliary crates](compiletest.html#building-auxiliary-crates)
 
-| Directive             | Explanation                                                                                           | Supported test suites | Possible values                               |
-|-----------------------|-------------------------------------------------------------------------------------------------------|-----------------------|-----------------------------------------------|
-| `aux-bin`             | Build a aux binary, made available in `auxiliary/bin` relative to test directory                      | All except `run-make` | Path to auxiliary `.rs` file                  |
-| `aux-build`           | Build a separate crate from the named source file                                                     | All except `run-make` | Path to auxiliary `.rs` file                  |
-| `aux-crate`           | Like `aux-build` but makes available as extern prelude                                                | All except `run-make` | `<extern_prelude_name>=<path/to/aux/file.rs>` |
-| `aux-codegen-backend` | Similar to `aux-build` but pass the compiled dylib to `-Zcodegen-backend` when building the main file | `ui-fulldeps`         | Path to codegen backend file                  |
-| `proc-macro`          | Similar to `aux-build`, but for aux forces host and don't use `-Cprefer-dynamic`[^pm].                | All except `run-make` | Path to auxiliary proc-macro `.rs` file       |
-| `build-aux-docs`      | Build docs for auxiliaries as well.  Note that this only works with `aux-build`, not `aux-crate`.     | All except `run-make` | N/A                                           |
+| Directive             | Explanation                                                                                           | Supported test suites                  | Possible values                               |
+|-----------------------|-------------------------------------------------------------------------------------------------------|----------------------------------------|-----------------------------------------------|
+| `aux-bin`             | Build a aux binary, made available in `auxiliary/bin` relative to test directory                      | All except `run-make`/`run-make-cargo` | Path to auxiliary `.rs` file                  |
+| `aux-build`           | Build a separate crate from the named source file                                                     | All except `run-make`/`run-make-cargo` | Path to auxiliary `.rs` file                  |
+| `aux-crate`           | Like `aux-build` but makes available as extern prelude                                                | All except `run-make`/`run-make-cargo` | `<extern_prelude_name>=<path/to/aux/file.rs>` |
+| `aux-codegen-backend` | Similar to `aux-build` but pass the compiled dylib to `-Zcodegen-backend` when building the main file | `ui-fulldeps`                          | Path to codegen backend file                  |
+| `proc-macro`          | Similar to `aux-build`, but for aux forces host and don't use `-Cprefer-dynamic`[^pm].                | All except `run-make`/`run-make-cargo` | Path to auxiliary proc-macro `.rs` file       |
+| `build-aux-docs`      | Build docs for auxiliaries as well.  Note that this only works with `aux-build`, not `aux-crate`.     | All except `run-make`/`run-make-cargo` | N/A                                           |
 
 [^pm]: please see the [Auxiliary proc-macro section](compiletest.html#auxiliary-proc-macro) in the compiletest chapter for specifics.
 
@@ -243,18 +243,18 @@ ignoring debuggers.
 
 ### Affecting how tests are built
 
-| Directive           | Explanation                                                                                  | Supported test suites     | Possible values                                                                            |
-|---------------------|----------------------------------------------------------------------------------------------|---------------------------|--------------------------------------------------------------------------------------------|
-| `compile-flags`     | Flags passed to `rustc` when building the test or aux file                                   | All except for `run-make` | Any valid `rustc` flags, e.g. `-Awarnings -Dfoo`. Cannot be `-Cincremental` or `--edition` |
-| `edition`           | The edition used to build the test                                                           | All except for `run-make` | Any valid `--edition` value                                                                |
-| `rustc-env`         | Env var to set when running `rustc`                                                          | All except for `run-make` | `<KEY>=<VALUE>`                                                                            |
-| `unset-rustc-env`   | Env var to unset when running `rustc`                                                        | All except for `run-make` | Any env var name                                                                           |
-| `incremental`       | Proper incremental support for tests outside of incremental test suite                       | `ui`, `crashes`           | N/A                                                                                        |
-| `no-prefer-dynamic` | Don't use `-C prefer-dynamic`, don't build as a dylib via a `--crate-type=dylib` preset flag | `ui`, `crashes`           | N/A                                                                                        |
+| Directive           | Explanation                                                                                  | Supported test suites                      | Possible values                                                                            |
+|---------------------|----------------------------------------------------------------------------------------------|--------------------------------------------|--------------------------------------------------------------------------------------------|
+| `compile-flags`     | Flags passed to `rustc` when building the test or aux file                                   | All except for `run-make`/`run-make-cargo` | Any valid `rustc` flags, e.g. `-Awarnings -Dfoo`. Cannot be `-Cincremental` or `--edition` |
+| `edition`           | The edition used to build the test                                                           | All except for `run-make`/`run-make-cargo` | Any valid `--edition` value                                                                |
+| `rustc-env`         | Env var to set when running `rustc`                                                          | All except for `run-make`/`run-make-cargo` | `<KEY>=<VALUE>`                                                                            |
+| `unset-rustc-env`   | Env var to unset when running `rustc`                                                        | All except for `run-make`/`run-make-cargo` | Any env var name                                                                           |
+| `incremental`       | Proper incremental support for tests outside of incremental test suite                       | `ui`, `crashes`                            | N/A                                                                                        |
+| `no-prefer-dynamic` | Don't use `-C prefer-dynamic`, don't build as a dylib via a `--crate-type=dylib` preset flag | `ui`, `crashes`                            | N/A                                                                                        |
 
 <div class="warning">
 
-Tests (outside of `run-make`) that want to use incremental tests not in the
+Tests (outside of `run-make`/`run-make-cargo`) that want to use incremental tests not in the
 incremental test-suite must not pass `-C incremental` via `compile-flags`, and
 must instead use the `//@ incremental` directive.
 
@@ -264,9 +264,9 @@ Consider writing the test as a proper incremental test instead.
 
 ### Rustdoc
 
-| Directive   | Explanation                                                  | Supported test suites                    | Possible values           |
-|-------------|--------------------------------------------------------------|------------------------------------------|---------------------------|
-| `doc-flags` | Flags passed to `rustdoc` when building the test or aux file | `rustdoc`, `rustdoc-js`, `rustdoc-json`  | Any valid `rustdoc` flags |
+| Directive   | Explanation                                                  | Supported test suites                   | Possible values           |
+|-------------|--------------------------------------------------------------|-----------------------------------------|---------------------------|
+| `doc-flags` | Flags passed to `rustdoc` when building the test or aux file | `rustdoc`, `rustdoc-js`, `rustdoc-json` | Any valid `rustdoc` flags |
 
 <!--
 **FIXME(rustdoc)**: what does `check-test-line-numbers-match` do?
diff --git a/src/doc/rustc-dev-guide/src/tests/misc.md b/src/doc/rustc-dev-guide/src/tests/misc.md
index 39f881748792f..cc8f501224fac 100644
--- a/src/doc/rustc-dev-guide/src/tests/misc.md
+++ b/src/doc/rustc-dev-guide/src/tests/misc.md
@@ -24,8 +24,8 @@ In `ui` tests and other test suites that support `//@ rustc-env`, you can specif
 //@ rustc-env:RUSTC_BOOTSTRAP=-1
 ```
 
-For `run-make` tests, `//@ rustc-env` is not supported. You can do something
-like the following for individual `rustc` invocations.
+For `run-make`/`run-make-cargo` tests, `//@ rustc-env` is not supported. You can do
+something like the following for individual `rustc` invocations.
 
 ```rust,ignore
 use run_make_support::rustc;

From 951733c1b99286fe417f0fbea8cb20c1a97f8b13 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <58857108+ada4a@users.noreply.github.com>
Date: Fri, 5 Sep 2025 16:10:50 +0200
Subject: [PATCH 0540/1889] Update link to `resolve_regions_and_report_errors`

Moved into `ObligationCtxt` in https://github.com/rust-lang/rust/commit/a19adefa0e5aca0aabca2430530577ee140e4efa
---
 src/doc/rustc-dev-guide/src/type-inference.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/src/type-inference.md b/src/doc/rustc-dev-guide/src/type-inference.md
index 2243205f129b5..4c51eed4e8e7f 100644
--- a/src/doc/rustc-dev-guide/src/type-inference.md
+++ b/src/doc/rustc-dev-guide/src/type-inference.md
@@ -242,7 +242,7 @@ as the NLL solver must not only know *what* regions outlive each other,
 but also *where*. Finally, the NLL solver invokes [`take_region_var_origins`],
 providing all region variables to the solver.
 
-[`resolve_regions_and_report_errors`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_infer/infer/struct.InferCtxt.html#method.resolve_regions_and_report_errors
+[`resolve_regions_and_report_errors`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_trait_selection/traits/struct.ObligationCtxt.html#method.resolve_regions_and_report_errors
 [`lexical_region_resolve`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_infer/infer/lexical_region_resolve/index.html
 [`take_and_reset_region_constraints`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_infer/infer/struct.InferCtxt.html#method.take_and_reset_region_constraints
 [`take_region_var_origins`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_infer/infer/struct.InferCtxt.html#method.take_region_var_origins

From 846d6a4466813f3ad12e2bf15db4071f22b8ae0b Mon Sep 17 00:00:00 2001
From: Mads Marquart <mads@marquart.dk>
Date: Tue, 25 Mar 2025 16:12:56 +0100
Subject: [PATCH 0541/1889] Add __isOSVersionAtLeast and
 __isPlatformVersionAtLeast symbols

Allows users to link to Objective-C code using `@available(...)`.
---
 compiler/rustc_symbol_mangling/src/v0.rs      |   8 +-
 library/std/src/lib.rs                        |   2 +
 library/std/src/sys/mod.rs                    |   1 +
 .../darwin/core_foundation.rs                 | 180 +++++++++
 .../src/sys/platform_version/darwin/mod.rs    | 351 ++++++++++++++++
 .../platform_version/darwin/public_extern.rs  | 151 +++++++
 .../src/sys/platform_version/darwin/tests.rs  | 379 ++++++++++++++++++
 library/std/src/sys/platform_version/mod.rs   |  13 +
 tests/run-make/apple-c-available-links/foo.c  |  22 +
 .../run-make/apple-c-available-links/main.rs  |   7 +
 .../run-make/apple-c-available-links/rmake.rs |  14 +
 triagebot.toml                                |   1 +
 12 files changed, 1127 insertions(+), 2 deletions(-)
 create mode 100644 library/std/src/sys/platform_version/darwin/core_foundation.rs
 create mode 100644 library/std/src/sys/platform_version/darwin/mod.rs
 create mode 100644 library/std/src/sys/platform_version/darwin/public_extern.rs
 create mode 100644 library/std/src/sys/platform_version/darwin/tests.rs
 create mode 100644 library/std/src/sys/platform_version/mod.rs
 create mode 100644 tests/run-make/apple-c-available-links/foo.c
 create mode 100644 tests/run-make/apple-c-available-links/main.rs
 create mode 100644 tests/run-make/apple-c-available-links/rmake.rs

diff --git a/compiler/rustc_symbol_mangling/src/v0.rs b/compiler/rustc_symbol_mangling/src/v0.rs
index 0cbd48ba08c4a..0655c2d5e8145 100644
--- a/compiler/rustc_symbol_mangling/src/v0.rs
+++ b/compiler/rustc_symbol_mangling/src/v0.rs
@@ -82,9 +82,13 @@ pub(super) fn mangle<'tcx>(
 }
 
 pub fn mangle_internal_symbol<'tcx>(tcx: TyCtxt<'tcx>, item_name: &str) -> String {
-    if item_name == "rust_eh_personality" {
+    match item_name {
         // rust_eh_personality must not be renamed as LLVM hard-codes the name
-        return "rust_eh_personality".to_owned();
+        "rust_eh_personality" => return item_name.to_owned(),
+        // Apple availability symbols need to not be mangled to be usable by
+        // C/Objective-C code.
+        "__isPlatformVersionAtLeast" | "__isOSVersionAtLeast" => return item_name.to_owned(),
+        _ => {}
     }
 
     let prefix = "_R";
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index 3771699c59fa2..dd7e066377dac 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -353,6 +353,7 @@
 #![feature(hasher_prefixfree_extras)]
 #![feature(hashmap_internals)]
 #![feature(hint_must_use)]
+#![feature(int_from_ascii)]
 #![feature(ip)]
 #![feature(lazy_get)]
 #![feature(maybe_uninit_slice)]
@@ -368,6 +369,7 @@
 #![feature(slice_internals)]
 #![feature(slice_ptr_get)]
 #![feature(slice_range)]
+#![feature(slice_split_once)]
 #![feature(std_internals)]
 #![feature(str_internals)]
 #![feature(sync_unsafe_cell)]
diff --git a/library/std/src/sys/mod.rs b/library/std/src/sys/mod.rs
index 6324c1a232af4..8c11501558069 100644
--- a/library/std/src/sys/mod.rs
+++ b/library/std/src/sys/mod.rs
@@ -26,6 +26,7 @@ pub mod io;
 pub mod net;
 pub mod os_str;
 pub mod path;
+pub mod platform_version;
 pub mod process;
 pub mod random;
 pub mod stdio;
diff --git a/library/std/src/sys/platform_version/darwin/core_foundation.rs b/library/std/src/sys/platform_version/darwin/core_foundation.rs
new file mode 100644
index 0000000000000..1e0d15fcf661d
--- /dev/null
+++ b/library/std/src/sys/platform_version/darwin/core_foundation.rs
@@ -0,0 +1,180 @@
+//! Minimal utilities for interfacing with a dynamically loaded CoreFoundation.
+#![allow(non_snake_case, non_upper_case_globals)]
+use super::root_relative;
+use crate::ffi::{CStr, c_char, c_void};
+use crate::ptr::null_mut;
+use crate::sys::common::small_c_string::run_path_with_cstr;
+
+// MacTypes.h
+pub(super) type Boolean = u8;
+// CoreFoundation/CFBase.h
+pub(super) type CFTypeID = usize;
+pub(super) type CFOptionFlags = usize;
+pub(super) type CFIndex = isize;
+pub(super) type CFTypeRef = *mut c_void;
+pub(super) type CFAllocatorRef = CFTypeRef;
+pub(super) const kCFAllocatorDefault: CFAllocatorRef = null_mut();
+// CoreFoundation/CFError.h
+pub(super) type CFErrorRef = CFTypeRef;
+// CoreFoundation/CFData.h
+pub(super) type CFDataRef = CFTypeRef;
+// CoreFoundation/CFPropertyList.h
+pub(super) const kCFPropertyListImmutable: CFOptionFlags = 0;
+pub(super) type CFPropertyListFormat = CFIndex;
+pub(super) type CFPropertyListRef = CFTypeRef;
+// CoreFoundation/CFString.h
+pub(super) type CFStringRef = CFTypeRef;
+pub(super) type CFStringEncoding = u32;
+pub(super) const kCFStringEncodingUTF8: CFStringEncoding = 0x08000100;
+// CoreFoundation/CFDictionary.h
+pub(super) type CFDictionaryRef = CFTypeRef;
+
+/// An open handle to the dynamically loaded CoreFoundation framework.
+///
+/// This is `dlopen`ed, and later `dlclose`d. This is done to try to avoid
+/// "leaking" the CoreFoundation symbols to the rest of the user's binary if
+/// they decided to not link CoreFoundation themselves.
+///
+/// It is also faster to look up symbols directly via this handle than with
+/// `RTLD_DEFAULT`.
+pub(super) struct CFHandle(*mut c_void);
+
+macro_rules! dlsym_fn {
+    (
+        unsafe fn $name:ident($($param:ident: $param_ty:ty),* $(,)?) $(-> $ret:ty)?;
+    ) => {
+        pub(super) unsafe fn $name(&self, $($param: $param_ty),*) $(-> $ret)? {
+            let ptr = unsafe {
+                libc::dlsym(
+                    self.0,
+                    concat!(stringify!($name), '\0').as_bytes().as_ptr().cast(),
+                )
+            };
+            if ptr.is_null() {
+                let err = unsafe { CStr::from_ptr(libc::dlerror()) };
+                panic!("could not find function {}: {err:?}", stringify!($name));
+            }
+
+            // SAFETY: Just checked that the symbol isn't NULL, and macro invoker verifies that
+            // the signature is correct.
+            let fnptr = unsafe {
+                crate::mem::transmute::<
+                    *mut c_void,
+                    unsafe extern "C" fn($($param_ty),*) $(-> $ret)?,
+                >(ptr)
+            };
+
+            // SAFETY: Upheld by caller.
+            unsafe { fnptr($($param),*) }
+        }
+    };
+}
+
+impl CFHandle {
+    /// Link to the CoreFoundation dylib, and look up symbols from that.
+    pub(super) fn new() -> Self {
+        // We explicitly use non-versioned path here, to allow this to work on older iOS devices.
+        let cf_path =
+            root_relative("/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation");
+
+        let handle = run_path_with_cstr(&cf_path, &|path| unsafe {
+            Ok(libc::dlopen(path.as_ptr(), libc::RTLD_LAZY | libc::RTLD_LOCAL))
+        })
+        .expect("failed allocating string");
+
+        if handle.is_null() {
+            let err = unsafe { CStr::from_ptr(libc::dlerror()) };
+            panic!("could not open CoreFoundation.framework: {err:?}");
+        }
+
+        Self(handle)
+    }
+
+    pub(super) fn kCFAllocatorNull(&self) -> CFAllocatorRef {
+        // Available: in all CF versions.
+        let static_ptr = unsafe { libc::dlsym(self.0, c"kCFAllocatorNull".as_ptr()) };
+        if static_ptr.is_null() {
+            let err = unsafe { CStr::from_ptr(libc::dlerror()) };
+            panic!("could not find kCFAllocatorNull: {err:?}");
+        }
+        unsafe { *static_ptr.cast() }
+    }
+
+    // CoreFoundation/CFBase.h
+    dlsym_fn!(
+        // Available: in all CF versions.
+        unsafe fn CFRelease(cf: CFTypeRef);
+    );
+    dlsym_fn!(
+        // Available: in all CF versions.
+        unsafe fn CFGetTypeID(cf: CFTypeRef) -> CFTypeID;
+    );
+
+    // CoreFoundation/CFData.h
+    dlsym_fn!(
+        // Available: in all CF versions.
+        unsafe fn CFDataCreateWithBytesNoCopy(
+            allocator: CFAllocatorRef,
+            bytes: *const u8,
+            length: CFIndex,
+            bytes_deallocator: CFAllocatorRef,
+        ) -> CFDataRef;
+    );
+
+    // CoreFoundation/CFPropertyList.h
+    dlsym_fn!(
+        // Available: since macOS 10.6.
+        unsafe fn CFPropertyListCreateWithData(
+            allocator: CFAllocatorRef,
+            data: CFDataRef,
+            options: CFOptionFlags,
+            format: *mut CFPropertyListFormat,
+            error: *mut CFErrorRef,
+        ) -> CFPropertyListRef;
+    );
+
+    // CoreFoundation/CFString.h
+    dlsym_fn!(
+        // Available: in all CF versions.
+        unsafe fn CFStringGetTypeID() -> CFTypeID;
+    );
+    dlsym_fn!(
+        // Available: in all CF versions.
+        unsafe fn CFStringCreateWithCStringNoCopy(
+            alloc: CFAllocatorRef,
+            c_str: *const c_char,
+            encoding: CFStringEncoding,
+            contents_deallocator: CFAllocatorRef,
+        ) -> CFStringRef;
+    );
+    dlsym_fn!(
+        // Available: in all CF versions.
+        unsafe fn CFStringGetCString(
+            the_string: CFStringRef,
+            buffer: *mut c_char,
+            buffer_size: CFIndex,
+            encoding: CFStringEncoding,
+        ) -> Boolean;
+    );
+
+    // CoreFoundation/CFDictionary.h
+    dlsym_fn!(
+        // Available: in all CF versions.
+        unsafe fn CFDictionaryGetTypeID() -> CFTypeID;
+    );
+    dlsym_fn!(
+        // Available: in all CF versions.
+        unsafe fn CFDictionaryGetValue(
+            the_dict: CFDictionaryRef,
+            key: *const c_void,
+        ) -> *const c_void;
+    );
+}
+
+impl Drop for CFHandle {
+    fn drop(&mut self) {
+        // Ignore errors when closing. This is also what `libloading` does:
+        // https://docs.rs/libloading/0.8.6/src/libloading/os/unix/mod.rs.html#374
+        let _ = unsafe { libc::dlclose(self.0) };
+    }
+}
diff --git a/library/std/src/sys/platform_version/darwin/mod.rs b/library/std/src/sys/platform_version/darwin/mod.rs
new file mode 100644
index 0000000000000..06b97fcdef4f2
--- /dev/null
+++ b/library/std/src/sys/platform_version/darwin/mod.rs
@@ -0,0 +1,351 @@
+use self::core_foundation::{
+    CFDictionaryRef, CFHandle, CFIndex, CFStringRef, CFTypeRef, kCFAllocatorDefault,
+    kCFPropertyListImmutable, kCFStringEncodingUTF8,
+};
+use crate::borrow::Cow;
+use crate::bstr::ByteStr;
+use crate::ffi::{CStr, c_char};
+use crate::num::{NonZero, ParseIntError};
+use crate::path::{Path, PathBuf};
+use crate::ptr::null_mut;
+use crate::sync::atomic::{AtomicU32, Ordering};
+use crate::{env, fs};
+
+mod core_foundation;
+mod public_extern;
+#[cfg(test)]
+mod tests;
+
+/// The version of the operating system.
+///
+/// We use a packed u32 here to allow for fast comparisons and to match Mach-O's `LC_BUILD_VERSION`.
+type OSVersion = u32;
+
+/// Combine parts of a version into an [`OSVersion`].
+///
+/// The size of the parts are inherently limited by Mach-O's `LC_BUILD_VERSION`.
+#[inline]
+const fn pack_os_version(major: u16, minor: u8, patch: u8) -> OSVersion {
+    let (major, minor, patch) = (major as u32, minor as u32, patch as u32);
+    (major << 16) | (minor << 8) | patch
+}
+
+/// [`pack_os_version`], but takes `i32` and saturates.
+///
+/// Instead of using e.g. `major as u16`, which truncates.
+#[inline]
+fn pack_i32_os_version(major: i32, minor: i32, patch: i32) -> OSVersion {
+    let major: u16 = major.try_into().unwrap_or(u16::MAX);
+    let minor: u8 = minor.try_into().unwrap_or(u8::MAX);
+    let patch: u8 = patch.try_into().unwrap_or(u8::MAX);
+    pack_os_version(major, minor, patch)
+}
+
+/// Get the current OS version, packed according to [`pack_os_version`].
+///
+/// # Semantics
+///
+/// The reported version on macOS might be 10.16 if the SDK version of the binary is less than 11.0.
+/// This is a workaround that Apple implemented to handle applications that assumed that macOS
+/// versions would always start with "10", see:
+/// <https://github.com/apple-oss-distributions/xnu/blob/xnu-11215.81.4/libsyscall/wrappers/system-version-compat.c>
+///
+/// It _is_ possible to get the real version regardless of the SDK version of the binary, this is
+/// what Zig does:
+/// <https://github.com/ziglang/zig/blob/0.13.0/lib/std/zig/system/darwin/macos.zig>
+///
+/// We choose to not do that, and instead follow Apple's behaviour here, and return 10.16 when
+/// compiled with an older SDK; the user should instead upgrade their tooling.
+///
+/// NOTE: `rustc` currently doesn't set the right SDK version when linking with ld64, so this will
+/// have the wrong behaviour with `-Clinker=ld` on x86_64. But that's a `rustc` bug:
+/// <https://github.com/rust-lang/rust/issues/129432>
+#[inline]
+fn current_version() -> OSVersion {
+    // Cache the lookup for performance.
+    //
+    // 0.0.0 is never going to be a valid version ("vtool" reports "n/a" on 0 versions), so we use
+    // that as our sentinel value.
+    static CURRENT_VERSION: AtomicU32 = AtomicU32::new(0);
+
+    // We use relaxed atomics instead of e.g. a `Once`, it doesn't matter if multiple threads end up
+    // racing to read or write the version, `lookup_version` should be idempotent and always return
+    // the same value.
+    //
+    // `compiler-rt` uses `dispatch_once`, but that's overkill for the reasons above.
+    let version = CURRENT_VERSION.load(Ordering::Relaxed);
+    if version == 0 {
+        let version = lookup_version().get();
+        CURRENT_VERSION.store(version, Ordering::Relaxed);
+        version
+    } else {
+        version
+    }
+}
+
+/// Look up the os version.
+///
+/// # Aborts
+///
+/// Aborts if reading or parsing the version fails (or if the system was out of memory).
+///
+/// We deliberately choose to abort, as having this silently return an invalid OS version would be
+/// impossible for a user to debug.
+// The lookup is costly and should be on the cold path because of the cache in `current_version`.
+#[cold]
+// Micro-optimization: We use `extern "C"` to abort on panic, allowing `current_version` (inlined)
+// to be free of unwind handling. Aborting is required for `__isPlatformVersionAtLeast` anyhow.
+extern "C" fn lookup_version() -> NonZero<OSVersion> {
+    // Try to read from `sysctl` first (faster), but if that fails, fall back to reading the
+    // property list (this is roughly what `_availability_version_check` does internally).
+    let version = version_from_sysctl().unwrap_or_else(version_from_plist);
+
+    // Use `NonZero` to try to make it clearer to the optimizer that this will never return 0.
+    NonZero::new(version).expect("version cannot be 0.0.0")
+}
+
+/// Read the version from `kern.osproductversion` or `kern.iossupportversion`.
+///
+/// This is faster than `version_from_plist`, since it doesn't need to invoke `dlsym`.
+fn version_from_sysctl() -> Option<OSVersion> {
+    // This won't work in the simulator, as `kern.osproductversion` returns the host macOS version,
+    // and `kern.iossupportversion` returns the host macOS' iOSSupportVersion (while you can run
+    // simulators with many different iOS versions).
+    if cfg!(target_abi = "sim") {
+        // Fall back to `version_from_plist` on these targets.
+        return None;
+    }
+
+    let sysctl_version = |name: &CStr| {
+        let mut buf: [u8; 32] = [0; 32];
+        let mut size = buf.len();
+        let ptr = buf.as_mut_ptr().cast();
+        let ret = unsafe { libc::sysctlbyname(name.as_ptr(), ptr, &mut size, null_mut(), 0) };
+        if ret != 0 {
+            // This sysctl is not available.
+            return None;
+        }
+        let buf = &buf[..(size - 1)];
+
+        if buf.is_empty() {
+            // The buffer may be empty when using `kern.iossupportversion` on an actual iOS device,
+            // or on visionOS when running under "Designed for iPad".
+            //
+            // In that case, fall back to `kern.osproductversion`.
+            return None;
+        }
+
+        Some(parse_os_version(buf).unwrap_or_else(|err| {
+            panic!("failed parsing version from sysctl ({}): {err}", ByteStr::new(buf))
+        }))
+    };
+
+    // When `target_os = "ios"`, we may be in many different states:
+    // - Native iOS device.
+    // - iOS Simulator.
+    // - Mac Catalyst.
+    // - Mac + "Designed for iPad".
+    // - Native visionOS device + "Designed for iPad".
+    // - visionOS simulator + "Designed for iPad".
+    //
+    // Of these, only native, Mac Catalyst and simulators can be differentiated at compile-time
+    // (with `target_abi = ""`, `target_abi = "macabi"` and `target_abi = "sim"` respectively).
+    //
+    // That is, "Designed for iPad" will act as iOS at compile-time, but the `ProductVersion` will
+    // still be the host macOS or visionOS version.
+    //
+    // Furthermore, we can't even reliably differentiate between these at runtime, since
+    // `dyld_get_active_platform` isn't publicly available.
+    //
+    // Fortunately, we won't need to know any of that; we can simply attempt to get the
+    // `iOSSupportVersion` (which may be set on native iOS too, but then it will be set to the host
+    // iOS version), and if that fails, fall back to the `ProductVersion`.
+    if cfg!(target_os = "ios") {
+        // https://github.com/apple-oss-distributions/xnu/blob/xnu-11215.81.4/bsd/kern/kern_sysctl.c#L2077-L2100
+        if let Some(ios_support_version) = sysctl_version(c"kern.iossupportversion") {
+            return Some(ios_support_version);
+        }
+
+        // On Mac Catalyst, if we failed looking up `iOSSupportVersion`, we don't want to
+        // accidentally fall back to `ProductVersion`.
+        if cfg!(target_abi = "macabi") {
+            return None;
+        }
+    }
+
+    // Introduced in macOS 10.13.4.
+    // https://github.com/apple-oss-distributions/xnu/blob/xnu-11215.81.4/bsd/kern/kern_sysctl.c#L2015-L2051
+    sysctl_version(c"kern.osproductversion")
+}
+
+/// Look up the current OS version(s) from `/System/Library/CoreServices/SystemVersion.plist`.
+///
+/// More specifically, from the `ProductVersion` and `iOSSupportVersion` keys, and from
+/// `$IPHONE_SIMULATOR_ROOT/System/Library/CoreServices/SystemVersion.plist` on the simulator.
+///
+/// This file was introduced in macOS 10.3, which is well below the minimum supported version by
+/// `rustc`, which is (at the time of writing) macOS 10.12.
+///
+/// # Implementation
+///
+/// We do roughly the same thing in here as `compiler-rt`, and dynamically look up CoreFoundation
+/// utilities for parsing PLists (to avoid having to re-implement that in here, as pulling in a full
+/// PList parser into `std` seems costly).
+///
+/// If this is found to be undesirable, we _could_ possibly hack it by parsing the PList manually
+/// (it seems to use the plain-text "xml1" encoding/format in all versions), but that seems brittle.
+fn version_from_plist() -> OSVersion {
+    // Read `SystemVersion.plist`. Always present on Apple platforms, reading it cannot fail.
+    let path = root_relative("/System/Library/CoreServices/SystemVersion.plist");
+    let plist_buffer = fs::read(&path).unwrap_or_else(|e| panic!("failed reading {path:?}: {e}"));
+    let cf_handle = CFHandle::new();
+    parse_version_from_plist(&cf_handle, &plist_buffer)
+}
+
+/// Parse OS version from the given PList.
+///
+/// Split out from [`version_from_plist`] to allow for testing.
+fn parse_version_from_plist(cf_handle: &CFHandle, plist_buffer: &[u8]) -> OSVersion {
+    let plist_data = unsafe {
+        cf_handle.CFDataCreateWithBytesNoCopy(
+            kCFAllocatorDefault,
+            plist_buffer.as_ptr(),
+            plist_buffer.len() as CFIndex,
+            cf_handle.kCFAllocatorNull(),
+        )
+    };
+    assert!(!plist_data.is_null(), "failed creating CFData");
+    let _plist_data_release = Deferred(|| unsafe { cf_handle.CFRelease(plist_data) });
+
+    let plist = unsafe {
+        cf_handle.CFPropertyListCreateWithData(
+            kCFAllocatorDefault,
+            plist_data,
+            kCFPropertyListImmutable,
+            null_mut(), // Don't care about the format of the PList.
+            null_mut(), // Don't care about the error data.
+        )
+    };
+    assert!(!plist.is_null(), "failed reading PList in SystemVersion.plist");
+    let _plist_release = Deferred(|| unsafe { cf_handle.CFRelease(plist) });
+
+    assert_eq!(
+        unsafe { cf_handle.CFGetTypeID(plist) },
+        unsafe { cf_handle.CFDictionaryGetTypeID() },
+        "SystemVersion.plist did not contain a dictionary at the top level"
+    );
+    let plist: CFDictionaryRef = plist.cast();
+
+    // Same logic as in `version_from_sysctl`.
+    if cfg!(target_os = "ios") {
+        if let Some(ios_support_version) =
+            unsafe { string_version_key(cf_handle, plist, c"iOSSupportVersion") }
+        {
+            return ios_support_version;
+        }
+
+        // Force Mac Catalyst to use iOSSupportVersion (do not fall back to ProductVersion).
+        if cfg!(target_abi = "macabi") {
+            panic!("expected iOSSupportVersion in SystemVersion.plist");
+        }
+    }
+
+    // On all other platforms, we can find the OS version by simply looking at `ProductVersion`.
+    unsafe { string_version_key(cf_handle, plist, c"ProductVersion") }
+        .expect("expected ProductVersion in SystemVersion.plist")
+}
+
+/// Look up a string key in a CFDictionary, and convert it to an [`OSVersion`].
+unsafe fn string_version_key(
+    cf_handle: &CFHandle,
+    plist: CFDictionaryRef,
+    lookup_key: &CStr,
+) -> Option<OSVersion> {
+    let cf_lookup_key = unsafe {
+        cf_handle.CFStringCreateWithCStringNoCopy(
+            kCFAllocatorDefault,
+            lookup_key.as_ptr(),
+            kCFStringEncodingUTF8,
+            cf_handle.kCFAllocatorNull(),
+        )
+    };
+    assert!(!cf_lookup_key.is_null(), "failed creating CFString");
+    let _lookup_key_release = Deferred(|| unsafe { cf_handle.CFRelease(cf_lookup_key) });
+
+    let value: CFTypeRef =
+        unsafe { cf_handle.CFDictionaryGetValue(plist, cf_lookup_key) }.cast_mut();
+    // `CFDictionaryGetValue` is a "getter", so we should not release,
+    // the value is held alive internally by the CFDictionary, see:
+    // https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/MemoryMgmt/Articles/mmPractical.html#//apple_ref/doc/uid/TP40004447-SW12
+    if value.is_null() {
+        return None;
+    }
+
+    assert_eq!(
+        unsafe { cf_handle.CFGetTypeID(value) },
+        unsafe { cf_handle.CFStringGetTypeID() },
+        "key in SystemVersion.plist must be a string"
+    );
+    let value: CFStringRef = value.cast();
+
+    let mut version_str = [0u8; 32];
+    let ret = unsafe {
+        cf_handle.CFStringGetCString(
+            value,
+            version_str.as_mut_ptr().cast::<c_char>(),
+            version_str.len() as CFIndex,
+            kCFStringEncodingUTF8,
+        )
+    };
+    assert_ne!(ret, 0, "failed getting string from CFString");
+
+    let version_str =
+        CStr::from_bytes_until_nul(&version_str).expect("failed converting CFString to CStr");
+
+    Some(parse_os_version(version_str.to_bytes()).unwrap_or_else(|err| {
+        panic!(
+            "failed parsing version from PList ({}): {err}",
+            ByteStr::new(version_str.to_bytes())
+        )
+    }))
+}
+
+/// Parse an OS version from a bytestring like b"10.1" or b"14.3.7".
+fn parse_os_version(version: &[u8]) -> Result<OSVersion, ParseIntError> {
+    if let Some((major, minor)) = version.split_once(|&b| b == b'.') {
+        let major = u16::from_ascii(major)?;
+        if let Some((minor, patch)) = minor.split_once(|&b| b == b'.') {
+            let minor = u8::from_ascii(minor)?;
+            let patch = u8::from_ascii(patch)?;
+            Ok(pack_os_version(major, minor, patch))
+        } else {
+            let minor = u8::from_ascii(minor)?;
+            Ok(pack_os_version(major, minor, 0))
+        }
+    } else {
+        let major = u16::from_ascii(version)?;
+        Ok(pack_os_version(major, 0, 0))
+    }
+}
+
+/// Get a path relative to the root directory in which all files for the current env are located.
+fn root_relative(path: &str) -> Cow<'_, Path> {
+    if cfg!(target_abi = "sim") {
+        let mut root = PathBuf::from(env::var_os("IPHONE_SIMULATOR_ROOT").expect(
+            "environment variable `IPHONE_SIMULATOR_ROOT` must be set when executing under simulator",
+        ));
+        // Convert absolute path to relative path, to make the `.push` work as expected.
+        root.push(Path::new(path).strip_prefix("/").unwrap());
+        root.into()
+    } else {
+        Path::new(path).into()
+    }
+}
+
+struct Deferred<F: FnMut()>(F);
+
+impl<F: FnMut()> Drop for Deferred<F> {
+    fn drop(&mut self) {
+        (self.0)();
+    }
+}
diff --git a/library/std/src/sys/platform_version/darwin/public_extern.rs b/library/std/src/sys/platform_version/darwin/public_extern.rs
new file mode 100644
index 0000000000000..967cdb4920fd4
--- /dev/null
+++ b/library/std/src/sys/platform_version/darwin/public_extern.rs
@@ -0,0 +1,151 @@
+//! # Runtime version checking ABI for other compilers.
+//!
+//! The symbols in this file are useful for us to expose to allow linking code written in the
+//! following languages when using their version checking functionality:
+//! - Clang's `__builtin_available` macro.
+//! - Objective-C's `@available`.
+//! - Swift's `#available`,
+//!
+//! Without Rust exposing these symbols, the user would encounter a linker error when linking to
+//! C/Objective-C/Swift libraries using these features.
+//!
+//! The presence of these symbols is mostly considered a quality-of-implementation detail, and
+//! should not be relied upon to be available. The intended effect is that linking with code built
+//! with Clang's `__builtin_available` (or similar) will continue to work. For example, we may
+//! decide to remove `__isOSVersionAtLeast` if support for Clang 11 (Xcode 11) is dropped.
+//!
+//! ## Background
+//!
+//! The original discussion of this feature can be found at:
+//! - <https://lists.llvm.org/pipermail/cfe-dev/2016-July/049851.html>
+//! - <https://reviews.llvm.org/D27827>
+//! - <https://reviews.llvm.org/D30136>
+//!
+//! And the upstream implementation of these can be found in `compiler-rt`:
+//! <https://github.com/llvm/llvm-project/blob/llvmorg-20.1.0/compiler-rt/lib/builtins/os_version_check.c>
+//!
+//! Ideally, these symbols should probably have been a part of Apple's `libSystem.dylib`, both
+//! because their implementation is quite complex, using allocation, environment variables, file
+//! access and dynamic library loading (and emitting all of this into every binary).
+//!
+//! The reason why Apple chose to not do that originally is lost to the sands of time, but a good
+//! reason would be that implementing it as part of `compiler-rt` allowed them to back-deploy this
+//! to older OSes immediately.
+//!
+//! In Rust's case, while we may provide a feature similar to `@available` in the future, we will
+//! probably do so as a macro exposed by `std` (and not as a compiler builtin). So implementing this
+//! in `std` makes sense, since then we can implement it using `std` utilities, and we can avoid
+//! having `compiler-builtins` depend on `libSystem.dylib`.
+//!
+//! This does mean that users that attempt to link C/Objective-C/Swift code _and_ use `#![no_std]`
+//! in all their crates may get a linker error because these symbols are missing. Using `no_std` is
+//! quite uncommon on Apple systems though, so it's probably fine to not support this use-case.
+//!
+//! The workaround would be to link `libclang_rt.osx.a` or otherwise use Clang's `compiler-rt`.
+//!
+//! See also discussion in <https://github.com/rust-lang/compiler-builtins/pull/794>.
+//!
+//! ## Implementation details
+//!
+//! NOTE: Since macOS 10.15, `libSystem.dylib` _has_ actually provided the undocumented
+//! `_availability_version_check` via `libxpc` for doing the version lookup (zippered, which is why
+//! it requires a platform parameter to differentiate between macOS and Mac Catalyst), though its
+//! usage may be a bit dangerous, see:
+//! - <https://reviews.llvm.org/D150397>
+//! - <https://github.com/llvm/llvm-project/issues/64227>
+//!
+//! Besides, we'd need to implement the version lookup via PList to support older versions anyhow,
+//! so we might as well use that everywhere (since it can also be optimized more after inlining).
+
+#![allow(non_snake_case)]
+
+use super::{current_version, pack_i32_os_version};
+
+/// Whether the current platform's OS version is higher than or equal to the given version.
+///
+/// The first argument is the _base_ Mach-O platform (i.e. `PLATFORM_MACOS`, `PLATFORM_IOS`, etc.,
+/// but not `PLATFORM_IOSSIMULATOR` or `PLATFORM_MACCATALYST`) of the invoking binary.
+///
+/// Arguments are specified statically by Clang. Inlining with LTO should allow the versions to be
+/// combined into a single `u32`, which should make comparisons faster, and should make the
+/// `BASE_TARGET_PLATFORM` check a no-op.
+//
+// SAFETY: The signature is the same as what Clang expects, and we export weakly to allow linking
+// both this and `libclang_rt.*.a`, similar to how `compiler-builtins` does it:
+// https://github.com/rust-lang/compiler-builtins/blob/0.1.113/src/macros.rs#L494
+//
+// NOTE: This symbol has a workaround in the compiler's symbol mangling to avoid mangling it, while
+// still not exposing it from non-cdylib (like `#[no_mangle]` would).
+#[rustc_std_internal_symbol]
+// extern "C" is correct, Clang assumes the function cannot unwind:
+// https://github.com/llvm/llvm-project/blob/llvmorg-20.1.0/clang/lib/CodeGen/CGObjC.cpp#L3980
+//
+// If an error happens in this, we instead abort the process.
+pub(super) extern "C" fn __isPlatformVersionAtLeast(
+    platform: i32,
+    major: i32,
+    minor: i32,
+    subminor: i32,
+) -> i32 {
+    let version = pack_i32_os_version(major, minor, subminor);
+
+    // Mac Catalyst is a technology that allows macOS to run in a different "mode" that closely
+    // resembles iOS (and has iOS libraries like UIKit available).
+    //
+    // (Apple has added a "Designed for iPad" mode later on that allows running iOS apps
+    // natively, but we don't need to think too much about those, since they link to
+    // iOS-specific system binaries as well).
+    //
+    // To support Mac Catalyst, Apple added the concept of a "zippered" binary, which is a single
+    // binary that can be run on both macOS and Mac Catalyst (has two `LC_BUILD_VERSION` Mach-O
+    // commands, one set to `PLATFORM_MACOS` and one to `PLATFORM_MACCATALYST`).
+    //
+    // Most system libraries are zippered, which allows re-use across macOS and Mac Catalyst.
+    // This includes the `libclang_rt.osx.a` shipped with Xcode! This means that `compiler-rt`
+    // can't statically know whether it's compiled for macOS or Mac Catalyst, and thus this new
+    // API (which replaces `__isOSVersionAtLeast`) is needed.
+    //
+    // In short:
+    //      normal  binary calls  normal  compiler-rt --> `__isOSVersionAtLeast` was enough
+    //      normal  binary calls zippered compiler-rt --> `__isPlatformVersionAtLeast` required
+    //     zippered binary calls zippered compiler-rt --> `__isPlatformOrVariantPlatformVersionAtLeast` called
+
+    // FIXME(madsmtm): `rustc` doesn't support zippered binaries yet, see rust-lang/rust#131216.
+    // But once it does, we need the pre-compiled `std` shipped with rustup to be zippered, and thus
+    // we also need to handle the `platform` difference here:
+    //
+    // if cfg!(target_os = "macos") && platform == 2 /* PLATFORM_IOS */ && cfg!(zippered) {
+    //     return (version.to_u32() <= current_ios_version()) as i32;
+    // }
+    //
+    // `__isPlatformOrVariantPlatformVersionAtLeast` would also need to be implemented.
+
+    // The base Mach-O platform for the current target.
+    const BASE_TARGET_PLATFORM: i32 = if cfg!(target_os = "macos") {
+        1 // PLATFORM_MACOS
+    } else if cfg!(target_os = "ios") {
+        2 // PLATFORM_IOS
+    } else if cfg!(target_os = "tvos") {
+        3 // PLATFORM_TVOS
+    } else if cfg!(target_os = "watchos") {
+        4 // PLATFORM_WATCHOS
+    } else if cfg!(target_os = "visionos") {
+        11 // PLATFORM_VISIONOS
+    } else {
+        0 // PLATFORM_UNKNOWN
+    };
+    debug_assert_eq!(
+        platform, BASE_TARGET_PLATFORM,
+        "invalid platform provided to __isPlatformVersionAtLeast",
+    );
+
+    (version <= current_version()) as i32
+}
+
+/// Old entry point for availability. Used when compiling with older Clang versions.
+// SAFETY: Same as for `__isPlatformVersionAtLeast`.
+#[rustc_std_internal_symbol]
+pub(super) extern "C" fn __isOSVersionAtLeast(major: i32, minor: i32, subminor: i32) -> i32 {
+    let version = pack_i32_os_version(major, minor, subminor);
+    (version <= current_version()) as i32
+}
diff --git a/library/std/src/sys/platform_version/darwin/tests.rs b/library/std/src/sys/platform_version/darwin/tests.rs
new file mode 100644
index 0000000000000..76dc4482c9835
--- /dev/null
+++ b/library/std/src/sys/platform_version/darwin/tests.rs
@@ -0,0 +1,379 @@
+use super::public_extern::*;
+use super::*;
+use crate::process::Command;
+
+#[test]
+fn test_general_available() {
+    // Lowest version always available.
+    assert_eq!(__isOSVersionAtLeast(0, 0, 0), 1);
+    // This high version never available.
+    assert_eq!(__isOSVersionAtLeast(9999, 99, 99), 0);
+}
+
+#[test]
+fn test_saturating() {
+    // Higher version than supported by OSVersion -> make sure we saturate.
+    assert_eq!(__isOSVersionAtLeast(0x10000, 0, 0), 0);
+}
+
+#[test]
+#[cfg_attr(not(target_os = "macos"), ignore = "`sw_vers` is only available on host macOS")]
+fn compare_against_sw_vers() {
+    let sw_vers = Command::new("sw_vers").arg("-productVersion").output().unwrap().stdout;
+    let sw_vers = String::from_utf8(sw_vers).unwrap();
+    let mut sw_vers = sw_vers.trim().split('.');
+
+    let major: i32 = sw_vers.next().unwrap().parse().unwrap();
+    let minor: i32 = sw_vers.next().unwrap_or("0").parse().unwrap();
+    let subminor: i32 = sw_vers.next().unwrap_or("0").parse().unwrap();
+    assert_eq!(sw_vers.count(), 0);
+
+    // Current version is available
+    assert_eq!(__isOSVersionAtLeast(major, minor, subminor), 1);
+
+    // One lower is available
+    assert_eq!(__isOSVersionAtLeast(major, minor, subminor.saturating_sub(1)), 1);
+    assert_eq!(__isOSVersionAtLeast(major, minor.saturating_sub(1), subminor), 1);
+    assert_eq!(__isOSVersionAtLeast(major.saturating_sub(1), minor, subminor), 1);
+
+    // One higher isn't available
+    assert_eq!(__isOSVersionAtLeast(major, minor, subminor + 1), 0);
+    assert_eq!(__isOSVersionAtLeast(major, minor + 1, subminor), 0);
+    assert_eq!(__isOSVersionAtLeast(major + 1, minor, subminor), 0);
+
+    // Test directly against the lookup
+    assert_eq!(lookup_version().get(), pack_os_version(major as _, minor as _, subminor as _));
+}
+
+#[test]
+fn sysctl_same_as_in_plist() {
+    if let Some(version) = version_from_sysctl() {
+        assert_eq!(version, version_from_plist());
+    }
+}
+
+#[test]
+fn lookup_idempotent() {
+    let version = lookup_version();
+    for _ in 0..10 {
+        assert_eq!(version, lookup_version());
+    }
+}
+
+/// Test parsing a bunch of different PLists found in the wild, to ensure that
+/// if we decide to parse it without CoreFoundation in the future, that it
+/// would continue to work, even on older platforms.
+#[test]
+fn parse_plist() {
+    #[track_caller]
+    fn check(
+        (major, minor, patch): (u16, u8, u8),
+        ios_version: Option<(u16, u8, u8)>,
+        plist: &str,
+    ) {
+        let expected = if cfg!(target_os = "ios") {
+            if let Some((ios_major, ios_minor, ios_patch)) = ios_version {
+                pack_os_version(ios_major, ios_minor, ios_patch)
+            } else if cfg!(target_abi = "macabi") {
+                // Skip checking iOS version on Mac Catalyst.
+                return;
+            } else {
+                // iOS version will be parsed from ProductVersion
+                pack_os_version(major, minor, patch)
+            }
+        } else {
+            pack_os_version(major, minor, patch)
+        };
+        let cf_handle = CFHandle::new();
+        assert_eq!(expected, parse_version_from_plist(&cf_handle, plist.as_bytes()));
+    }
+
+    // macOS 10.3.0
+    let plist = r#"<?xml version="1.0" encoding="UTF-8"?>
+        <!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+        <plist version="1.0">
+        <dict>
+            <key>ProductBuildVersion</key>
+            <string>7B85</string>
+            <key>ProductCopyright</key>
+            <string>Apple Computer, Inc. 1983-2003</string>
+            <key>ProductName</key>
+            <string>Mac OS X</string>
+            <key>ProductUserVisibleVersion</key>
+            <string>10.3</string>
+            <key>ProductVersion</key>
+            <string>10.3</string>
+        </dict>
+        </plist>
+    "#;
+    check((10, 3, 0), None, plist);
+
+    // macOS 10.7.5
+    let plist = r#"<?xml version="1.0" encoding="UTF-8"?>
+        <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+        <plist version="1.0">
+        <dict>
+            <key>ProductBuildVersion</key>
+            <string>11G63</string>
+            <key>ProductCopyright</key>
+            <string>1983-2012 Apple Inc.</string>
+            <key>ProductName</key>
+            <string>Mac OS X</string>
+            <key>ProductUserVisibleVersion</key>
+            <string>10.7.5</string>
+            <key>ProductVersion</key>
+            <string>10.7.5</string>
+        </dict>
+        </plist>
+    "#;
+    check((10, 7, 5), None, plist);
+
+    // macOS 14.7.4
+    let plist = r#"<?xml version="1.0" encoding="UTF-8"?>
+        <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+        <plist version="1.0">
+        <dict>
+            <key>BuildID</key>
+            <string>6A558D8A-E2EA-11EF-A1D3-6222CAA672A8</string>
+            <key>ProductBuildVersion</key>
+            <string>23H420</string>
+            <key>ProductCopyright</key>
+            <string>1983-2025 Apple Inc.</string>
+            <key>ProductName</key>
+            <string>macOS</string>
+            <key>ProductUserVisibleVersion</key>
+            <string>14.7.4</string>
+            <key>ProductVersion</key>
+            <string>14.7.4</string>
+            <key>iOSSupportVersion</key>
+            <string>17.7</string>
+        </dict>
+        </plist>
+    "#;
+    check((14, 7, 4), Some((17, 7, 0)), plist);
+
+    // SystemVersionCompat.plist on macOS 14.7.4
+    let plist = r#"<?xml version="1.0" encoding="UTF-8"?>
+        <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+        <plist version="1.0">
+        <dict>
+            <key>BuildID</key>
+            <string>6A558D8A-E2EA-11EF-A1D3-6222CAA672A8</string>
+            <key>ProductBuildVersion</key>
+            <string>23H420</string>
+            <key>ProductCopyright</key>
+            <string>1983-2025 Apple Inc.</string>
+            <key>ProductName</key>
+            <string>Mac OS X</string>
+            <key>ProductUserVisibleVersion</key>
+            <string>10.16</string>
+            <key>ProductVersion</key>
+            <string>10.16</string>
+            <key>iOSSupportVersion</key>
+            <string>17.7</string>
+        </dict>
+        </plist>
+    "#;
+    check((10, 16, 0), Some((17, 7, 0)), plist);
+
+    // macOS 15.4 Beta 24E5238a
+    let plist = r#"<?xml version="1.0" encoding="UTF-8"?>
+        <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+        <plist version="1.0">
+        <dict>
+            <key>BuildID</key>
+            <string>67A50F62-00DA-11F0-BDB6-F99BB8310D2A</string>
+            <key>ProductBuildVersion</key>
+            <string>24E5238a</string>
+            <key>ProductCopyright</key>
+            <string>1983-2025 Apple Inc.</string>
+            <key>ProductName</key>
+            <string>macOS</string>
+            <key>ProductUserVisibleVersion</key>
+            <string>15.4</string>
+            <key>ProductVersion</key>
+            <string>15.4</string>
+            <key>iOSSupportVersion</key>
+            <string>18.4</string>
+        </dict>
+        </plist>
+    "#;
+    check((15, 4, 0), Some((18, 4, 0)), plist);
+
+    // iOS Simulator 17.5
+    let plist = r#"<?xml version="1.0" encoding="UTF-8"?>
+        <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+        <plist version="1.0">
+        <dict>
+            <key>BuildID</key>
+            <string>210B8A2C-09C3-11EF-9DB8-273A64AEFA1C</string>
+            <key>ProductBuildVersion</key>
+            <string>21F79</string>
+            <key>ProductCopyright</key>
+            <string>1983-2024 Apple Inc.</string>
+            <key>ProductName</key>
+            <string>iPhone OS</string>
+            <key>ProductVersion</key>
+            <string>17.5</string>
+        </dict>
+        </plist>
+    "#;
+    check((17, 5, 0), None, plist);
+
+    // visionOS Simulator 2.3
+    let plist = r#"<?xml version="1.0" encoding="UTF-8"?>
+        <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+        <plist version="1.0">
+        <dict>
+            <key>BuildID</key>
+            <string>57CEFDE6-D079-11EF-837C-8B8C7961D0AC</string>
+            <key>ProductBuildVersion</key>
+            <string>22N895</string>
+            <key>ProductCopyright</key>
+            <string>1983-2025 Apple Inc.</string>
+            <key>ProductName</key>
+            <string>xrOS</string>
+            <key>ProductVersion</key>
+            <string>2.3</string>
+            <key>SystemImageID</key>
+            <string>D332C7F1-08DF-4DD9-8122-94EF39A1FB92</string>
+            <key>iOSSupportVersion</key>
+            <string>18.3</string>
+        </dict>
+        </plist>
+    "#;
+    check((2, 3, 0), Some((18, 3, 0)), plist);
+
+    // tvOS Simulator 18.2
+    let plist = r#"<?xml version="1.0" encoding="UTF-8"?>
+        <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+        <plist version="1.0">
+        <dict>
+            <key>BuildID</key>
+            <string>617587B0-B059-11EF-BE70-4380EDE44645</string>
+            <key>ProductBuildVersion</key>
+            <string>22K154</string>
+            <key>ProductCopyright</key>
+            <string>1983-2024 Apple Inc.</string>
+            <key>ProductName</key>
+            <string>Apple TVOS</string>
+            <key>ProductVersion</key>
+            <string>18.2</string>
+            <key>SystemImageID</key>
+            <string>8BB5A425-33F0-4821-9F93-40E7ED92F4E0</string>
+        </dict>
+        </plist>
+    "#;
+    check((18, 2, 0), None, plist);
+
+    // watchOS Simulator 11.2
+    let plist = r#"<?xml version="1.0" encoding="UTF-8"?>
+        <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+        <plist version="1.0">
+        <dict>
+            <key>BuildID</key>
+            <string>BAAE2D54-B122-11EF-BF78-C6C6836B724A</string>
+            <key>ProductBuildVersion</key>
+            <string>22S99</string>
+            <key>ProductCopyright</key>
+            <string>1983-2024 Apple Inc.</string>
+            <key>ProductName</key>
+            <string>Watch OS</string>
+            <key>ProductVersion</key>
+            <string>11.2</string>
+            <key>SystemImageID</key>
+            <string>79F773E2-2041-43B4-98EE-FAE52402AE95</string>
+        </dict>
+        </plist>
+    "#;
+    check((11, 2, 0), None, plist);
+
+    // iOS 9.3.6
+    let plist = r#"<?xml version="1.0" encoding="UTF-8"?>
+        <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+        <plist version="1.0">
+        <dict>
+            <key>ProductBuildVersion</key>
+            <string>13G37</string>
+            <key>ProductCopyright</key>
+            <string>1983-2019 Apple Inc.</string>
+            <key>ProductName</key>
+            <string>iPhone OS</string>
+            <key>ProductVersion</key>
+            <string>9.3.6</string>
+        </dict>
+        </plist>
+    "#;
+    check((9, 3, 6), None, plist);
+}
+
+#[test]
+#[should_panic = "SystemVersion.plist did not contain a dictionary at the top level"]
+fn invalid_plist() {
+    let cf_handle = CFHandle::new();
+    let _ = parse_version_from_plist(&cf_handle, b"INVALID");
+}
+
+#[test]
+#[cfg_attr(
+    target_abi = "macabi",
+    should_panic = "expected iOSSupportVersion in SystemVersion.plist"
+)]
+#[cfg_attr(
+    not(target_abi = "macabi"),
+    should_panic = "expected ProductVersion in SystemVersion.plist"
+)]
+fn empty_plist() {
+    let plist = r#"<?xml version="1.0" encoding="UTF-8"?>
+        <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+        <plist version="1.0">
+        <dict>
+        </dict>
+        </plist>
+    "#;
+    let cf_handle = CFHandle::new();
+    let _ = parse_version_from_plist(&cf_handle, plist.as_bytes());
+}
+
+#[test]
+fn parse_version() {
+    #[track_caller]
+    fn check(major: u16, minor: u8, patch: u8, version: &str) {
+        assert_eq!(
+            pack_os_version(major, minor, patch),
+            parse_os_version(version.as_bytes()).unwrap()
+        )
+    }
+
+    check(0, 0, 0, "0");
+    check(0, 0, 0, "0.0.0");
+    check(1, 0, 0, "1");
+    check(1, 2, 0, "1.2");
+    check(1, 2, 3, "1.2.3");
+    check(9999, 99, 99, "9999.99.99");
+
+    // Check leading zeroes
+    check(10, 0, 0, "010");
+    check(10, 20, 0, "010.020");
+    check(10, 20, 30, "010.020.030");
+    check(10000, 100, 100, "000010000.00100.00100");
+
+    // Too many parts
+    assert!(parse_os_version(b"1.2.3.4").is_err());
+
+    // Empty
+    assert!(parse_os_version(b"").is_err());
+
+    // Invalid digit
+    assert!(parse_os_version(b"A.B").is_err());
+
+    // Missing digits
+    assert!(parse_os_version(b".").is_err());
+    assert!(parse_os_version(b".1").is_err());
+    assert!(parse_os_version(b"1.").is_err());
+
+    // Too large
+    assert!(parse_os_version(b"100000").is_err());
+    assert!(parse_os_version(b"1.1000").is_err());
+    assert!(parse_os_version(b"1.1.1000").is_err());
+}
diff --git a/library/std/src/sys/platform_version/mod.rs b/library/std/src/sys/platform_version/mod.rs
new file mode 100644
index 0000000000000..88896c97ea3ab
--- /dev/null
+++ b/library/std/src/sys/platform_version/mod.rs
@@ -0,0 +1,13 @@
+//! Runtime lookup of operating system / platform version.
+//!
+//! Related to [RFC 3750](https://github.com/rust-lang/rfcs/pull/3750), which
+//! does version detection at compile-time.
+//!
+//! See also the `os_info` crate.
+
+#[cfg(target_vendor = "apple")]
+mod darwin;
+
+// In the future, we could expand this module with:
+// - `RtlGetVersion` on Windows.
+// - `__system_property_get` on Android.
diff --git a/tests/run-make/apple-c-available-links/foo.c b/tests/run-make/apple-c-available-links/foo.c
new file mode 100644
index 0000000000000..eff99a8b12a7e
--- /dev/null
+++ b/tests/run-make/apple-c-available-links/foo.c
@@ -0,0 +1,22 @@
+int foo(void) {
+    // Act as if using some API that's a lot newer than the deployment target.
+    //
+    // This forces Clang to insert a call to __isPlatformVersionAtLeast,
+    // and linking will fail if that is not present.
+    if (__builtin_available(
+        macos 1000.0,
+        ios 1000.0,
+        tvos 1000.0,
+        watchos 1000.0,
+        // CI runs below Xcode 15, where `visionos` wasn't a valid key in
+        // `__builtin_available`.
+#ifdef TARGET_OS_VISION
+        visionos 1000.0,
+#endif
+        *
+    )) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
diff --git a/tests/run-make/apple-c-available-links/main.rs b/tests/run-make/apple-c-available-links/main.rs
new file mode 100644
index 0000000000000..4ffada43c1b2b
--- /dev/null
+++ b/tests/run-make/apple-c-available-links/main.rs
@@ -0,0 +1,7 @@
+unsafe extern "C" {
+    safe fn foo() -> core::ffi::c_int;
+}
+
+fn main() {
+    assert_eq!(foo(), 0);
+}
diff --git a/tests/run-make/apple-c-available-links/rmake.rs b/tests/run-make/apple-c-available-links/rmake.rs
new file mode 100644
index 0000000000000..44a5ee94d577e
--- /dev/null
+++ b/tests/run-make/apple-c-available-links/rmake.rs
@@ -0,0 +1,14 @@
+//! Test that using `__builtin_available` in C (`@available` in Objective-C)
+//! successfully links (because `std` provides the required symbols).
+
+//@ only-apple __builtin_available is (mostly) specific to Apple platforms.
+
+use run_make_support::{cc, rustc, target};
+
+fn main() {
+    // Invoke the C compiler to generate an object file.
+    cc().arg("-c").input("foo.c").output("foo.o").run();
+
+    // Link the object file together with a Rust program.
+    rustc().target(target()).input("main.rs").link_arg("foo.o").run();
+}
diff --git a/triagebot.toml b/triagebot.toml
index 3b7b216c0d24e..98aee4126fb2f 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -380,6 +380,7 @@ trigger_files = [
 [autolabel."O-apple"]
 trigger_files = [
     "library/std/src/os/darwin",
+    "library/std/src/sys/platform_version/darwin",
     "library/std/src/sys/sync/thread_parking/darwin.rs",
     "compiler/rustc_target/src/spec/base/apple",
 ]

From 9f9473f201e73a74c87ff5532828ad82b42b508e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Fri, 5 Sep 2025 16:20:53 +0200
Subject: [PATCH 0542/1889] Allow `specialization` feature when documenting
 Cargo

---
 src/bootstrap/src/core/build_steps/doc.rs | 20 ++++++++++++++++----
 1 file changed, 16 insertions(+), 4 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/doc.rs b/src/bootstrap/src/core/build_steps/doc.rs
index 33a0f617b4a6a..6aa2b75d5baf9 100644
--- a/src/bootstrap/src/core/build_steps/doc.rs
+++ b/src/bootstrap/src/core/build_steps/doc.rs
@@ -965,9 +965,11 @@ macro_rules! tool_doc {
     (
         $tool: ident,
         $path: literal,
-        mode = $mode:expr,
-        $(is_library = $is_library:expr,)?
-        $(crates = $crates:expr)?
+        mode = $mode:expr
+        $(, is_library = $is_library:expr )?
+        $(, crates = $crates:expr )?
+        // Subset of nightly features that are allowed to be used when documenting
+        $(, allow_features: $allow_features:expr )?
        ) => {
         #[derive(Debug, Clone, Hash, PartialEq, Eq)]
         pub struct $tool {
@@ -1041,6 +1043,15 @@ macro_rules! tool_doc {
                     source_type,
                     &[],
                 );
+                let allow_features = {
+                    let mut _value = "";
+                    $( _value = $allow_features; )?
+                    _value
+                };
+
+                if allow_features.is_empty() {
+                    cargo.allow_features(allow_features);
+                }
 
                 cargo.arg("-Zskip-rustdoc-fingerprint");
                 // Only include compiler crates, no dependencies of those, such as `libc`.
@@ -1134,7 +1145,8 @@ tool_doc!(
         "crates-io",
         "mdman",
         "rustfix",
-    ]
+    ],
+    allow_features: "specialization"
 );
 tool_doc!(Tidy, "src/tools/tidy", mode = Mode::ToolBootstrap, crates = ["tidy"]);
 tool_doc!(

From a6aa509687a125e9a3cac3da229369edb67e3205 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Fri, 5 Sep 2025 16:22:52 +0200
Subject: [PATCH 0543/1889] Respect top stage when documenting Cargo

---
 src/bootstrap/src/core/build_steps/doc.rs |  2 +-
 src/bootstrap/src/core/builder/tests.rs   | 15 ++++++++++++++-
 2 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/doc.rs b/src/bootstrap/src/core/build_steps/doc.rs
index 6aa2b75d5baf9..a1a16980be69e 100644
--- a/src/bootstrap/src/core/build_steps/doc.rs
+++ b/src/bootstrap/src/core/build_steps/doc.rs
@@ -1005,7 +1005,7 @@ macro_rules! tool_doc {
                     }
                     Mode::ToolTarget => {
                         // target tools should be documented with the in-tree compiler
-                        prepare_doc_compiler(run.builder, run.builder.host_target, 2)
+                        prepare_doc_compiler(run.builder, run.builder.host_target, run.builder.top_stage)
                     }
                     _ => {
                         panic!("Unexpected tool mode for documenting: {:?}", $mode);
diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index da9e1ecad7b98..e7b92dbc18f68 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -2463,12 +2463,25 @@ mod snapshot {
     }
 
     #[test]
-    fn doc_cargo() {
+    fn doc_cargo_stage_1() {
         let ctx = TestCtx::new();
         insta::assert_snapshot!(
             ctx.config("doc")
                 .path("cargo")
                 .render_steps(), @r"
+        [build] rustdoc 0 <host>
+        [doc] rustc 0 <host> -> Cargo 1 <host>
+        ");
+    }
+
+    #[test]
+    fn doc_cargo_stage_2() {
+        let ctx = TestCtx::new();
+        insta::assert_snapshot!(
+            ctx.config("doc")
+                .path("cargo")
+                .stage(2)
+                .render_steps(), @r"
         [build] llvm <host>
         [build] rustc 0 <host> -> rustc 1 <host>
         [build] rustc 1 <host> -> std 1 <host>

From 4375e9d313aa3b236c8537e7ceeb89f6415fc05a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Fri, 5 Sep 2025 16:24:43 +0200
Subject: [PATCH 0544/1889] Add snapshot test for disting compiler docs

---
 src/bootstrap/src/core/builder/tests.rs | 54 ++++++++++++++++++++++++-
 1 file changed, 53 insertions(+), 1 deletion(-)

diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index e7b92dbc18f68..19cfe79be5dba 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -1130,6 +1130,59 @@ mod snapshot {
         );
     }
 
+    #[test]
+    fn dist_compiler_docs() {
+        let ctx = TestCtx::new();
+        insta::assert_snapshot!(
+            ctx.config("dist")
+                .path("rustc-docs")
+                .args(&["--set", "build.compiler-docs=true"])
+                .render_steps(), @r"
+        [build] rustc 0 <host> -> UnstableBookGen 1 <host>
+        [build] rustc 0 <host> -> Rustbook 1 <host>
+        [doc] unstable-book (book) <host>
+        [build] llvm <host>
+        [build] rustc 0 <host> -> rustc 1 <host>
+        [build] rustc 1 <host> -> std 1 <host>
+        [doc] book (book) <host>
+        [doc] book/first-edition (book) <host>
+        [doc] book/second-edition (book) <host>
+        [doc] book/2018-edition (book) <host>
+        [build] rustdoc 1 <host>
+        [doc] rustc 1 <host> -> standalone 2 <host>
+        [doc] rustc 1 <host> -> std 1 <host> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,rustc-std-workspace-core,std,std_detect,sysroot,test,unwind]
+        [doc] rustc 1 <host> -> rustc 2 <host>
+        [build] rustc 1 <host> -> rustc 2 <host>
+        [doc] rustc 1 <host> -> Rustdoc 2 <host>
+        [doc] rustc 1 <host> -> Rustfmt 2 <host>
+        [build] rustc 1 <host> -> error-index 2 <host>
+        [doc] rustc 1 <host> -> error-index 2 <host>
+        [doc] nomicon (book) <host>
+        [doc] rustc 1 <host> -> reference (book) 2 <host>
+        [doc] rustdoc (book) <host>
+        [doc] rust-by-example (book) <host>
+        [build] rustc 0 <host> -> LintDocs 1 <host>
+        [doc] rustc (book) <host>
+        [doc] rustc 1 <host> -> Cargo 2 <host>
+        [doc] cargo (book) <host>
+        [doc] rustc 1 <host> -> Clippy 2 <host>
+        [doc] clippy (book) <host>
+        [doc] rustc 1 <host> -> Miri 2 <host>
+        [doc] embedded-book (book) <host>
+        [doc] edition-guide (book) <host>
+        [doc] style-guide (book) <host>
+        [build] rustdoc 0 <host>
+        [doc] rustc 0 <host> -> Tidy 1 <host>
+        [doc] rustc 0 <host> -> Bootstrap 1 <host>
+        [doc] rustc 1 <host> -> releases 2 <host>
+        [doc] rustc 0 <host> -> RunMakeSupport 1 <host>
+        [doc] rustc 0 <host> -> BuildHelper 1 <host>
+        [doc] rustc 0 <host> -> Compiletest 1 <host>
+        [build] rustc 0 <host> -> RustInstaller 1 <host>
+        "
+        );
+    }
+
     #[test]
     fn dist_extended() {
         let ctx = TestCtx::new();
@@ -2473,7 +2526,6 @@ mod snapshot {
         [doc] rustc 0 <host> -> Cargo 1 <host>
         ");
     }
-
     #[test]
     fn doc_cargo_stage_2() {
         let ctx = TestCtx::new();

From 6907e64ffb80b82e519b6bab9da7c1b7941700dd Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <58857108+ada4a@users.noreply.github.com>
Date: Fri, 5 Sep 2025 16:35:10 +0200
Subject: [PATCH 0545/1889] Update renamed `take_region_var_origins`

This was first renamed to `get_region_var_origins` in
https://github.com/rust-lang/rust/pull/109753, and then to
`get_region_var_infos` in
https://github.com/rust-lang/rust/commit/b0fc1d47d5dcffb5d516059d4a5af3b6843132d5
---
 src/doc/rustc-dev-guide/src/type-inference.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/type-inference.md b/src/doc/rustc-dev-guide/src/type-inference.md
index 4c51eed4e8e7f..24982a209fd0d 100644
--- a/src/doc/rustc-dev-guide/src/type-inference.md
+++ b/src/doc/rustc-dev-guide/src/type-inference.md
@@ -239,13 +239,13 @@ differently. It uses canonical queries for trait solving which use
 [`take_and_reset_region_constraints`] at the end. This extracts all of the
 outlives constraints added during the canonical query. This is required
 as the NLL solver must not only know *what* regions outlive each other,
-but also *where*. Finally, the NLL solver invokes [`take_region_var_origins`],
+but also *where*. Finally, the NLL solver invokes [`get_region_var_infos`],
 providing all region variables to the solver.
 
 [`resolve_regions_and_report_errors`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_trait_selection/traits/struct.ObligationCtxt.html#method.resolve_regions_and_report_errors
 [`lexical_region_resolve`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_infer/infer/lexical_region_resolve/index.html
 [`take_and_reset_region_constraints`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_infer/infer/struct.InferCtxt.html#method.take_and_reset_region_constraints
-[`take_region_var_origins`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_infer/infer/struct.InferCtxt.html#method.take_region_var_origins
+[`get_region_var_infos`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_infer/infer/struct.InferCtxt.html#method.get_region_var_infos
 
 ## Lexical region resolution
 

From 8c93cdc8e0ad3c443755a88af3c0367894614178 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Fri, 5 Sep 2025 17:02:12 +0200
Subject: [PATCH 0546/1889] Add a comment about the "specialization" feature
 required because of `im-rc`

---
 src/bootstrap/src/core/build_steps/doc.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/bootstrap/src/core/build_steps/doc.rs b/src/bootstrap/src/core/build_steps/doc.rs
index a1a16980be69e..295d8b55eff71 100644
--- a/src/bootstrap/src/core/build_steps/doc.rs
+++ b/src/bootstrap/src/core/build_steps/doc.rs
@@ -1146,6 +1146,8 @@ tool_doc!(
         "mdman",
         "rustfix",
     ],
+    // Required because of the im-rc dependency of Cargo, which automatically opts into the
+    // "specialization" feature in its build script when it detects a nightly toolchain.
     allow_features: "specialization"
 );
 tool_doc!(Tidy, "src/tools/tidy", mode = Mode::ToolBootstrap, crates = ["tidy"]);

From ad21f439dcfafd456f2bc82865931c865e82636b Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Fri, 5 Sep 2025 17:44:53 +0000
Subject: [PATCH 0547/1889] rustc_middle: clippy fixes

---
 compiler/rustc_middle/src/mir/consts.rs    |  2 +-
 compiler/rustc_middle/src/mir/statement.rs | 22 +++++++++++-----------
 compiler/rustc_middle/src/ty/codec.rs      | 10 ++--------
 3 files changed, 14 insertions(+), 20 deletions(-)

diff --git a/compiler/rustc_middle/src/mir/consts.rs b/compiler/rustc_middle/src/mir/consts.rs
index 164433aede263..5764a9c84eeaf 100644
--- a/compiler/rustc_middle/src/mir/consts.rs
+++ b/compiler/rustc_middle/src/mir/consts.rs
@@ -579,7 +579,7 @@ impl<'tcx> Display for Const<'tcx> {
 }
 
 ///////////////////////////////////////////////////////////////////////////
-/// Const-related utilities
+// Const-related utilities
 
 impl<'tcx> TyCtxt<'tcx> {
     pub fn span_as_caller_location(self, span: Span) -> ConstValue {
diff --git a/compiler/rustc_middle/src/mir/statement.rs b/compiler/rustc_middle/src/mir/statement.rs
index 6e52bc775ef73..ec2a8e86077d0 100644
--- a/compiler/rustc_middle/src/mir/statement.rs
+++ b/compiler/rustc_middle/src/mir/statement.rs
@@ -408,14 +408,14 @@ impl<'tcx> Place<'tcx> {
         self.as_ref().project_deeper(more_projections, tcx)
     }
 
-    pub fn ty_from<D: ?Sized>(
+    pub fn ty_from<D>(
         local: Local,
         projection: &[PlaceElem<'tcx>],
         local_decls: &D,
         tcx: TyCtxt<'tcx>,
     ) -> PlaceTy<'tcx>
     where
-        D: HasLocalDecls<'tcx>,
+        D: ?Sized + HasLocalDecls<'tcx>,
     {
         PlaceTy::from_ty(local_decls.local_decls()[local].ty).multi_projection_ty(tcx, projection)
     }
@@ -529,9 +529,9 @@ impl<'tcx> PlaceRef<'tcx> {
         Place { local: self.local, projection: tcx.mk_place_elems(new_projections) }
     }
 
-    pub fn ty<D: ?Sized>(&self, local_decls: &D, tcx: TyCtxt<'tcx>) -> PlaceTy<'tcx>
+    pub fn ty<D>(&self, local_decls: &D, tcx: TyCtxt<'tcx>) -> PlaceTy<'tcx>
     where
-        D: HasLocalDecls<'tcx>,
+        D: ?Sized + HasLocalDecls<'tcx>,
     {
         Place::ty_from(self.local, self.projection, local_decls, tcx)
     }
@@ -630,9 +630,9 @@ impl<'tcx> Operand<'tcx> {
         if let ty::FnDef(def_id, args) = *const_ty.kind() { Some((def_id, args)) } else { None }
     }
 
-    pub fn ty<D: ?Sized>(&self, local_decls: &D, tcx: TyCtxt<'tcx>) -> Ty<'tcx>
+    pub fn ty<D>(&self, local_decls: &D, tcx: TyCtxt<'tcx>) -> Ty<'tcx>
     where
-        D: HasLocalDecls<'tcx>,
+        D: ?Sized + HasLocalDecls<'tcx>,
     {
         match self {
             &Operand::Copy(ref l) | &Operand::Move(ref l) => l.ty(local_decls, tcx).ty,
@@ -640,9 +640,9 @@ impl<'tcx> Operand<'tcx> {
         }
     }
 
-    pub fn span<D: ?Sized>(&self, local_decls: &D) -> Span
+    pub fn span<D>(&self, local_decls: &D) -> Span
     where
-        D: HasLocalDecls<'tcx>,
+        D: ?Sized + HasLocalDecls<'tcx>,
     {
         match self {
             &Operand::Copy(ref l) | &Operand::Move(ref l) => {
@@ -674,7 +674,7 @@ impl<'tcx> ConstOperand<'tcx> {
 }
 
 ///////////////////////////////////////////////////////////////////////////
-/// Rvalues
+// Rvalues
 
 pub enum RvalueInitializationState {
     Shallow,
@@ -721,9 +721,9 @@ impl<'tcx> Rvalue<'tcx> {
         }
     }
 
-    pub fn ty<D: ?Sized>(&self, local_decls: &D, tcx: TyCtxt<'tcx>) -> Ty<'tcx>
+    pub fn ty<D>(&self, local_decls: &D, tcx: TyCtxt<'tcx>) -> Ty<'tcx>
     where
-        D: HasLocalDecls<'tcx>,
+        D: ?Sized + HasLocalDecls<'tcx>,
     {
         match *self {
             Rvalue::Use(ref operand) => operand.ty(local_decls, tcx),
diff --git a/compiler/rustc_middle/src/ty/codec.rs b/compiler/rustc_middle/src/ty/codec.rs
index 95759d1f31a7f..3f37595d0eef0 100644
--- a/compiler/rustc_middle/src/ty/codec.rs
+++ b/compiler/rustc_middle/src/ty/codec.rs
@@ -216,10 +216,7 @@ impl<'tcx, E: TyEncoder<'tcx>> Encodable<E> for ty::ParamEnv<'tcx> {
 #[inline]
 fn decode_arena_allocable<'tcx, D: TyDecoder<'tcx>, T: ArenaAllocatable<'tcx> + Decodable<D>>(
     decoder: &mut D,
-) -> &'tcx T
-where
-    D: TyDecoder<'tcx>,
-{
+) -> &'tcx T {
     decoder.interner().arena.alloc(Decodable::decode(decoder))
 }
 
@@ -230,10 +227,7 @@ fn decode_arena_allocable_slice<
     T: ArenaAllocatable<'tcx> + Decodable<D>,
 >(
     decoder: &mut D,
-) -> &'tcx [T]
-where
-    D: TyDecoder<'tcx>,
-{
+) -> &'tcx [T] {
     decoder.interner().arena.alloc_from_iter(<Vec<T> as Decodable<D>>::decode(decoder))
 }
 

From 56e95aa6a9cdd5c6873b888cd808a88ffde83809 Mon Sep 17 00:00:00 2001
From: "Pascal S. de Kloe" <pascal@quies.net>
Date: Sun, 24 Aug 2025 14:47:48 +0200
Subject: [PATCH 0548/1889] single buffer for exponent fmt of integers

---
 library/core/src/fmt/num.rs | 389 ++++++++++++++++++++----------------
 1 file changed, 213 insertions(+), 176 deletions(-)

diff --git a/library/core/src/fmt/num.rs b/library/core/src/fmt/num.rs
index 605ba42c541fa..253a7b7587e49 100644
--- a/library/core/src/fmt/num.rs
+++ b/library/core/src/fmt/num.rs
@@ -3,7 +3,7 @@
 use crate::fmt::NumBuffer;
 use crate::mem::MaybeUninit;
 use crate::num::fmt as numfmt;
-use crate::{fmt, ptr, slice, str};
+use crate::{fmt, str};
 
 /// Formatting of integers with a non-decimal radix.
 macro_rules! radix_integer {
@@ -96,8 +96,8 @@ macro_rules! impl_Debug {
     };
 }
 
-// 2 digit decimal look up table
-static DEC_DIGITS_LUT: &[u8; 200] = b"\
+// The string of all two-digit numbers in range 00..99 is used as a lookup table.
+static DECIMAL_PAIRS: &[u8; 200] = b"\
       0001020304050607080910111213141516171819\
       2021222324252627282930313233343536373839\
       4041424344454647484950515253545556575859\
@@ -123,6 +123,9 @@ macro_rules! impl_Display {
 
         $(
         const _: () = {
+            assert!($Signed::MIN < 0, "need signed");
+            assert!($Unsigned::MIN == 0, "need unsigned");
+            assert!($Signed::BITS == $Unsigned::BITS, "need counterparts");
             assert!($Signed::BITS <= $T::BITS, "need lossless conversion");
             assert!($Unsigned::BITS <= $T::BITS, "need lossless conversion");
         };
@@ -207,10 +210,10 @@ macro_rules! impl_Display {
                     remain /= scale;
                     let pair1 = (quad / 100) as usize;
                     let pair2 = (quad % 100) as usize;
-                    buf[offset + 0].write(DEC_DIGITS_LUT[pair1 * 2 + 0]);
-                    buf[offset + 1].write(DEC_DIGITS_LUT[pair1 * 2 + 1]);
-                    buf[offset + 2].write(DEC_DIGITS_LUT[pair2 * 2 + 0]);
-                    buf[offset + 3].write(DEC_DIGITS_LUT[pair2 * 2 + 1]);
+                    buf[offset + 0].write(DECIMAL_PAIRS[pair1 * 2 + 0]);
+                    buf[offset + 1].write(DECIMAL_PAIRS[pair1 * 2 + 1]);
+                    buf[offset + 2].write(DECIMAL_PAIRS[pair2 * 2 + 0]);
+                    buf[offset + 3].write(DECIMAL_PAIRS[pair2 * 2 + 1]);
                 }
 
                 // Format per two digits from the lookup table.
@@ -225,8 +228,8 @@ macro_rules! impl_Display {
 
                     let pair = (remain % 100) as usize;
                     remain /= 100;
-                    buf[offset + 0].write(DEC_DIGITS_LUT[pair * 2 + 0]);
-                    buf[offset + 1].write(DEC_DIGITS_LUT[pair * 2 + 1]);
+                    buf[offset + 0].write(DECIMAL_PAIRS[pair * 2 + 0]);
+                    buf[offset + 1].write(DECIMAL_PAIRS[pair * 2 + 1]);
                 }
 
                 // Format the last remaining digit, if any.
@@ -242,7 +245,7 @@ macro_rules! impl_Display {
                     // Either the compiler sees that remain < 10, or it prevents
                     // a boundary check up next.
                     let last = (remain & 15) as usize;
-                    buf[offset].write(DEC_DIGITS_LUT[last * 2 + 1]);
+                    buf[offset].write(DECIMAL_PAIRS[last * 2 + 1]);
                     // not used: remain = 0;
                 }
 
@@ -335,7 +338,6 @@ macro_rules! impl_Display {
             }
         }
 
-
         )*
 
         #[cfg(feature = "optimize_for_size")]
@@ -374,178 +376,213 @@ macro_rules! impl_Display {
 
 macro_rules! impl_Exp {
     ($($Signed:ident, $Unsigned:ident),* ; as $T:ident into $fmt_fn:ident) => {
+        const _: () = assert!($T::MIN == 0, "need unsigned");
+
         fn $fmt_fn(
-            mut n: $T,
+            f: &mut fmt::Formatter<'_>,
+            n: $T,
             is_nonnegative: bool,
-            upper: bool,
-            f: &mut fmt::Formatter<'_>
+            letter_e: u8
         ) -> fmt::Result {
-            let (mut n, mut exponent, trailing_zeros, added_precision) = {
-                let mut exponent = 0;
-                // count and remove trailing decimal zeroes
-                while n % 10 == 0 && n >= 10 {
-                    n /= 10;
-                    exponent += 1;
-                }
-                let (added_precision, subtracted_precision) = match f.precision() {
-                    Some(fmt_prec) => {
-                        // number of decimal digits minus 1
-                        let mut tmp = n;
-                        let mut prec = 0;
-                        while tmp >= 10 {
-                            tmp /= 10;
-                            prec += 1;
-                        }
-                        (fmt_prec.saturating_sub(prec), prec.saturating_sub(fmt_prec))
+            debug_assert!(letter_e.is_ascii_alphabetic(), "single-byte character");
+
+            // Print the integer as a coefficient in range (-10, 10).
+            let mut exp = n.checked_ilog10().unwrap_or(0) as usize;
+            debug_assert!(n / (10 as $T).pow(exp as u32) < 10);
+
+            // Precisison is counted as the number of digits in the fraction.
+            let mut coef_prec = exp;
+            // Keep the digits as an integer (paired with its coef_prec count).
+            let mut coef = n;
+
+            // A Formatter may set the precision to a fixed number of decimals.
+            let more_prec = match f.precision() {
+                None => {
+                    // Omit any and all trailing zeroes.
+                    while coef_prec != 0 && coef % 10 == 0 {
+                        coef /= 10;
+                        coef_prec -= 1;
                     }
-                    None => (0, 0)
-                };
-                for _ in 1..subtracted_precision {
-                    n /= 10;
-                    exponent += 1;
-                }
-                if subtracted_precision != 0 {
-                    let rem = n % 10;
-                    n /= 10;
-                    exponent += 1;
-                    // round up last digit, round to even on a tie
-                    if rem > 5 || (rem == 5 && (n % 2 != 0 || subtracted_precision > 1 )) {
-                        n += 1;
-                        // if the digit is rounded to the next power
-                        // instead adjust the exponent
-                        if n.ilog10() > (n - 1).ilog10() {
-                            n /= 10;
-                            exponent += 1;
-                        }
+                    0
+                },
+
+                Some(fmt_prec) if fmt_prec >= coef_prec => {
+                    // Count the number of additional zeroes needed.
+                    fmt_prec - coef_prec
+                },
+
+                Some(fmt_prec) => {
+                    // Count the number of digits to drop.
+                    let less_prec = coef_prec - fmt_prec;
+                    assert!(less_prec > 0);
+                    // Scale down the coefficient/precision pair. For example,
+                    // coef 123456 gets coef_prec 5 (to make 1.23456). To format
+                    // the number with 2 decimals, i.e., fmt_prec 2, coef should
+                    // be scaled by 10⁵⁻²=1000 to get coef 123 with coef_prec 2.
+
+                    // SAFETY: Any precision less than coef_prec will cause a
+                    // power of ten below the coef value.
+                    let scale = unsafe {
+                        (10 as $T).checked_pow(less_prec as u32).unwrap_unchecked()
+                    };
+                    let floor = coef / scale;
+                    // Round half to even conform documentation.
+                    let over = coef % scale;
+                    let half = scale / 2;
+                    let round_up = if over < half {
+                        0
+                    } else if over > half {
+                        1
+                    } else {
+                        floor & 1 // round odd up to even
+                    };
+                    // Adding one to a scale down of at least 10 won't overflow.
+                    coef = floor + round_up;
+                    coef_prec = fmt_prec;
+
+                    // The round_up may have caused the coefficient to reach 10
+                    // (which is not permitted). For example, anything in range
+                    // [9.95, 10) becomes 10.0 when adjusted to precision 1.
+                    if round_up != 0 && coef.checked_ilog10().unwrap_or(0) as usize > coef_prec {
+                        debug_assert_eq!(coef, (10 as $T).pow(coef_prec as u32 + 1));
+                        coef /= 10; // drop one trailing zero
+                        exp += 1;   // one power of ten higher
                     }
-                }
-                (n, exponent, exponent, added_precision)
+                    0
+                },
             };
 
-            // Since `curr` always decreases by the number of digits copied, this means
-            // that `curr >= 0`.
-            let mut buf = [MaybeUninit::<u8>::uninit(); 40];
-            let mut curr = buf.len(); //index for buf
-            let buf_ptr = MaybeUninit::slice_as_mut_ptr(&mut buf);
-            let lut_ptr = DEC_DIGITS_LUT.as_ptr();
-
-            // decode 2 chars at a time
-            while n >= 100 {
-                let d1 = ((n % 100) as usize) << 1;
-                curr -= 2;
-                // SAFETY: `d1 <= 198`, so we can copy from `lut_ptr[d1..d1 + 2]` since
-                // `DEC_DIGITS_LUT` has a length of 200.
-                unsafe {
-                    ptr::copy_nonoverlapping(lut_ptr.add(d1), buf_ptr.add(curr), 2);
-                }
-                n /= 100;
-                exponent += 2;
-            }
-            // n is <= 99, so at most 2 chars long
-            let mut n = n as isize; // possibly reduce 64bit math
-            // decode second-to-last character
-            if n >= 10 {
-                curr -= 1;
-                // SAFETY: Safe since `40 > curr >= 0` (see comment)
-                unsafe {
-                    *buf_ptr.add(curr) = (n as u8 % 10_u8) + b'0';
+            // Allocate a text buffer with lazy initialization.
+            const MAX_DEC_N: usize = $T::MAX.ilog10() as usize + 1;
+            const MAX_COEF_LEN: usize = MAX_DEC_N + ".".len();
+            const MAX_TEXT_LEN: usize = MAX_COEF_LEN + "e99".len();
+            let mut buf = [MaybeUninit::<u8>::uninit(); MAX_TEXT_LEN];
+
+            // Encode the coefficient in buf[..coef_len].
+            let (lead_dec, coef_len) = if coef_prec == 0 && more_prec == 0 {
+                (coef, 1_usize) // single digit; no fraction
+            } else {
+                buf[1].write(b'.');
+                let fraction_range = 2..(2 + coef_prec);
+
+                // Consume the least-significant decimals from a working copy.
+                let mut remain = coef;
+                #[cfg(feature = "optimize_for_size")] {
+                    for i in fraction_range.clone().rev() {
+                        let digit = (remain % 10) as usize;
+                        remain /= 10;
+                        buf[i].write(b'0' + digit as u8);
+                    }
                 }
-                n /= 10;
-                exponent += 1;
-            }
-            // add decimal point iff >1 mantissa digit will be printed
-            if exponent != trailing_zeros || added_precision != 0 {
-                curr -= 1;
-                // SAFETY: Safe since `40 > curr >= 0`
-                unsafe {
-                    *buf_ptr.add(curr) = b'.';
+                #[cfg(not(feature = "optimize_for_size"))] {
+                    // Write digits per two at a time with a lookup table.
+                    for i in fraction_range.clone().skip(1).rev().step_by(2) {
+                        let pair = (remain % 100) as usize;
+                        remain /= 100;
+                        buf[i - 1].write(DECIMAL_PAIRS[pair * 2 + 0]);
+                        buf[i - 0].write(DECIMAL_PAIRS[pair * 2 + 1]);
+                    }
+                    // An odd number of digits leave one digit remaining.
+                    if coef_prec & 1 != 0 {
+                        let digit = (remain % 10) as usize;
+                        remain /= 10;
+                        buf[fraction_range.start].write(b'0' + digit as u8);
+                    }
                 }
-            }
 
-            // SAFETY: Safe since `40 > curr >= 0`
-            let buf_slice = unsafe {
-                // decode last character
-                curr -= 1;
-                *buf_ptr.add(curr) = (n as u8) + b'0';
-
-                let len = buf.len() - curr as usize;
-                slice::from_raw_parts(buf_ptr.add(curr), len)
+                (remain, fraction_range.end)
             };
-
-            // stores 'e' (or 'E') and the up to 2-digit exponent
-            let mut exp_buf = [MaybeUninit::<u8>::uninit(); 3];
-            let exp_ptr = MaybeUninit::slice_as_mut_ptr(&mut exp_buf);
-            // SAFETY: In either case, `exp_buf` is written within bounds and `exp_ptr[..len]`
-            // is contained within `exp_buf` since `len <= 3`.
-            let exp_slice = unsafe {
-                *exp_ptr.add(0) = if upper { b'E' } else { b'e' };
-                let len = if exponent < 10 {
-                    *exp_ptr.add(1) = (exponent as u8) + b'0';
-                    2
-                } else {
-                    let off = exponent << 1;
-                    ptr::copy_nonoverlapping(lut_ptr.add(off), exp_ptr.add(1), 2);
-                    3
-                };
-                slice::from_raw_parts(exp_ptr, len)
+            debug_assert!(lead_dec < 10);
+            debug_assert!(lead_dec != 0 || coef == 0, "significant digits only");
+            buf[0].write(b'0' + lead_dec as u8);
+
+            // SAFETY: The number of decimals is limited, captured by MAX.
+            unsafe { core::hint::assert_unchecked(coef_len <= MAX_COEF_LEN) }
+            // Encode the scale factor in buf[coef_len..text_len].
+            buf[coef_len].write(letter_e);
+            let text_len: usize = match exp {
+                ..10 => {
+                    buf[coef_len + 1].write(b'0' + exp as u8);
+                    coef_len + 2
+                },
+                10..100 => {
+                    #[cfg(feature = "optimize_for_size")] {
+                        buf[coef_len + 1].write(b'0' + (exp / 10) as u8);
+                        buf[coef_len + 2].write(b'0' + (exp % 10) as u8);
+                    }
+                    #[cfg(not(feature = "optimize_for_size"))] {
+                        buf[coef_len + 1].write(DECIMAL_PAIRS[exp * 2 + 0]);
+                        buf[coef_len + 2].write(DECIMAL_PAIRS[exp * 2 + 1]);
+                    }
+                    coef_len + 3
+                },
+                _ => {
+                    const { assert!($T::MAX.ilog10() < 100) };
+                    // SAFETY: A `u256::MAX` would get exponent 77.
+                    unsafe { core::hint::unreachable_unchecked() }
+                }
             };
-
-            let parts = &[
-                numfmt::Part::Copy(buf_slice),
-                numfmt::Part::Zero(added_precision),
-                numfmt::Part::Copy(exp_slice),
-            ];
-            let sign = if !is_nonnegative {
-                "-"
-            } else if f.sign_plus() {
-                "+"
+            // SAFETY: All bytes up until text_len have been set.
+            let text = unsafe { buf[..text_len].assume_init_ref() };
+
+            if more_prec == 0 {
+                // SAFETY: Text is set with ASCII exclusively: either a decimal,
+                // or a LETTER_E, or a dot. ASCII implies valid UTF-8.
+                let as_str = unsafe { str::from_utf8_unchecked(text) };
+                f.pad_integral(is_nonnegative, "", as_str)
             } else {
-                ""
-            };
-            let formatted = numfmt::Formatted { sign, parts };
-            // SAFETY: `buf_slice` and `exp_slice` contain only ASCII characters.
-            unsafe { f.pad_formatted_parts(&formatted) }
+                let parts = &[
+                    numfmt::Part::Copy(&text[..coef_len]),
+                    numfmt::Part::Zero(more_prec),
+                    numfmt::Part::Copy(&text[coef_len..]),
+                ];
+                let sign = if !is_nonnegative {
+                    "-"
+                } else if f.sign_plus() {
+                    "+"
+                } else {
+                    ""
+                };
+                // SAFETY: Text is set with ASCII exclusively: either a decimal,
+                // or a LETTER_E, or a dot. ASCII implies valid UTF-8.
+                unsafe { f.pad_formatted_parts(&numfmt::Formatted { sign, parts }) }
+            }
         }
 
         $(
-            #[stable(feature = "integer_exp_format", since = "1.42.0")]
-            impl fmt::LowerExp for $Signed {
-                fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                    let is_nonnegative = *self >= 0;
-                    let n = if is_nonnegative {
-                        *self as $T
-                    } else {
-                        self.unsigned_abs() as $T
-                    };
-                    $fmt_fn(n, is_nonnegative, false, f)
-                }
+        const _: () = {
+            assert!($Signed::MIN < 0, "need signed");
+            assert!($Unsigned::MIN == 0, "need unsigned");
+            assert!($Signed::BITS == $Unsigned::BITS, "need counterparts");
+            assert!($Signed::BITS <= $T::BITS, "need lossless conversion");
+            assert!($Unsigned::BITS <= $T::BITS, "need lossless conversion");
+        };
+        #[stable(feature = "integer_exp_format", since = "1.42.0")]
+        impl fmt::LowerExp for $Signed {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                $fmt_fn(f, self.unsigned_abs() as $T, *self >= 0, b'e')
             }
-            #[stable(feature = "integer_exp_format", since = "1.42.0")]
-            impl fmt::LowerExp for $Unsigned {
-                fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                    $fmt_fn(*self as $T, true, false, f)
-                }
-            })*
-
-        $(
-            #[stable(feature = "integer_exp_format", since = "1.42.0")]
-            impl fmt::UpperExp for $Signed {
-                fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                    let is_nonnegative = *self >= 0;
-                    let n = if is_nonnegative {
-                        *self as $T
-                    } else {
-                        self.unsigned_abs() as $T
-                    };
-                    $fmt_fn(n, is_nonnegative, true, f)
-                }
+        }
+        #[stable(feature = "integer_exp_format", since = "1.42.0")]
+        impl fmt::LowerExp for $Unsigned {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                $fmt_fn(f, *self as $T, true, b'e')
             }
-            #[stable(feature = "integer_exp_format", since = "1.42.0")]
-            impl fmt::UpperExp for $Unsigned {
-                fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                    $fmt_fn(*self as $T, true, true, f)
-                }
-            })*
+        }
+        #[stable(feature = "integer_exp_format", since = "1.42.0")]
+        impl fmt::UpperExp for $Signed {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                $fmt_fn(f, self.unsigned_abs() as $T, *self >= 0, b'E')
+            }
+        }
+        #[stable(feature = "integer_exp_format", since = "1.42.0")]
+        impl fmt::UpperExp for $Unsigned {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                $fmt_fn(f, *self as $T, true, b'E')
+            }
+        }
+        )*
+
     };
 }
 
@@ -658,10 +695,10 @@ impl u128 {
             remain /= 1_00_00;
             let pair1 = (quad / 100) as usize;
             let pair2 = (quad % 100) as usize;
-            buf[offset + 0].write(DEC_DIGITS_LUT[pair1 * 2 + 0]);
-            buf[offset + 1].write(DEC_DIGITS_LUT[pair1 * 2 + 1]);
-            buf[offset + 2].write(DEC_DIGITS_LUT[pair2 * 2 + 0]);
-            buf[offset + 3].write(DEC_DIGITS_LUT[pair2 * 2 + 1]);
+            buf[offset + 0].write(DECIMAL_PAIRS[pair1 * 2 + 0]);
+            buf[offset + 1].write(DECIMAL_PAIRS[pair1 * 2 + 1]);
+            buf[offset + 2].write(DECIMAL_PAIRS[pair2 * 2 + 0]);
+            buf[offset + 3].write(DECIMAL_PAIRS[pair2 * 2 + 1]);
         }
 
         // Format per two digits from the lookup table.
@@ -676,8 +713,8 @@ impl u128 {
 
             let pair = (remain % 100) as usize;
             remain /= 100;
-            buf[offset + 0].write(DEC_DIGITS_LUT[pair * 2 + 0]);
-            buf[offset + 1].write(DEC_DIGITS_LUT[pair * 2 + 1]);
+            buf[offset + 0].write(DECIMAL_PAIRS[pair * 2 + 0]);
+            buf[offset + 1].write(DECIMAL_PAIRS[pair * 2 + 1]);
         }
 
         // Format the last remaining digit, if any.
@@ -693,7 +730,7 @@ impl u128 {
             // Either the compiler sees that remain < 10, or it prevents
             // a boundary check up next.
             let last = (remain & 15) as usize;
-            buf[offset].write(DEC_DIGITS_LUT[last * 2 + 1]);
+            buf[offset].write(DECIMAL_PAIRS[last * 2 + 1]);
             // not used: remain = 0;
         }
         offset
@@ -792,10 +829,10 @@ fn enc_16lsd<const OFFSET: usize>(buf: &mut [MaybeUninit<u8>], n: u64) {
         remain /= 1_00_00;
         let pair1 = (quad / 100) as usize;
         let pair2 = (quad % 100) as usize;
-        buf[quad_index * 4 + OFFSET + 0].write(DEC_DIGITS_LUT[pair1 * 2 + 0]);
-        buf[quad_index * 4 + OFFSET + 1].write(DEC_DIGITS_LUT[pair1 * 2 + 1]);
-        buf[quad_index * 4 + OFFSET + 2].write(DEC_DIGITS_LUT[pair2 * 2 + 0]);
-        buf[quad_index * 4 + OFFSET + 3].write(DEC_DIGITS_LUT[pair2 * 2 + 1]);
+        buf[quad_index * 4 + OFFSET + 0].write(DECIMAL_PAIRS[pair1 * 2 + 0]);
+        buf[quad_index * 4 + OFFSET + 1].write(DECIMAL_PAIRS[pair1 * 2 + 1]);
+        buf[quad_index * 4 + OFFSET + 2].write(DECIMAL_PAIRS[pair2 * 2 + 0]);
+        buf[quad_index * 4 + OFFSET + 3].write(DECIMAL_PAIRS[pair2 * 2 + 1]);
     }
 }
 

From b5c139baed5991870267bfa1d82e980d5051d2ac Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Fri, 5 Sep 2025 19:57:08 +0200
Subject: [PATCH 0549/1889] Fix condition

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

diff --git a/src/bootstrap/src/core/build_steps/doc.rs b/src/bootstrap/src/core/build_steps/doc.rs
index 295d8b55eff71..378c9c19ba5da 100644
--- a/src/bootstrap/src/core/build_steps/doc.rs
+++ b/src/bootstrap/src/core/build_steps/doc.rs
@@ -1049,7 +1049,7 @@ macro_rules! tool_doc {
                     _value
                 };
 
-                if allow_features.is_empty() {
+                if !allow_features.is_empty() {
                     cargo.allow_features(allow_features);
                 }
 

From edb92a33d73852582c76d0ed48d9373c5f709b2e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Fri, 5 Sep 2025 20:03:08 +0200
Subject: [PATCH 0550/1889] Optimize Cargo with LTO

---
 src/bootstrap/src/core/build_steps/tool.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
index c5308034fe307..6870bf3eddcd8 100644
--- a/src/bootstrap/src/core/build_steps/tool.rs
+++ b/src/bootstrap/src/core/build_steps/tool.rs
@@ -121,9 +121,11 @@ impl Step for ToolBuild {
             cargo.env("RUSTC_WRAPPER", ccache);
         }
 
-        // Rustc tools (miri, clippy, cargo, rustfmt, rust-analyzer)
+        // RustcPrivate tools (miri, clippy, rustfmt, rust-analyzer) and cargo
         // could use the additional optimizations.
-        if self.mode == Mode::ToolRustcPrivate && is_lto_stage(&self.build_compiler) {
+        if is_lto_stage(&self.build_compiler)
+            && (self.mode == Mode::ToolRustcPrivate || self.path == "src/tools/cargo")
+        {
             let lto = match builder.config.rust_lto {
                 RustcLto::Off => Some("off"),
                 RustcLto::Thin => Some("thin"),

From 095fa86a3ba30f4198c88ef300354391d3ab97e1 Mon Sep 17 00:00:00 2001
From: Aleksey Kliger <alklig@microsoft.com>
Date: Mon, 18 Aug 2025 16:42:21 -0400
Subject: [PATCH 0551/1889] compiler: Add Windows resources to rustc-main and
 rustc_driver

Adds Windows resources with the rust version information to rustc-main.exe and rustc_driver.dll

Sets the product description to "Rust Compiler" or "Rust Compiler (channel)" for non-stable channels
---
 Cargo.lock                              |   9 ++
 compiler/rustc/Cargo.toml               |   5 +
 compiler/rustc/build.rs                 |  16 ++-
 compiler/rustc_codegen_ssa/Cargo.toml   |   2 +-
 compiler/rustc_driver/Cargo.toml        |   5 +
 compiler/rustc_driver/build.rs          |  21 ++++
 compiler/rustc_llvm/Cargo.toml          |   2 +-
 compiler/rustc_windows_rc/Cargo.toml    |  11 ++
 compiler/rustc_windows_rc/rustc.rc.in   |  40 ++++++
 compiler/rustc_windows_rc/src/lib.rs    | 158 ++++++++++++++++++++++++
 src/bootstrap/src/core/builder/tests.rs |  10 +-
 11 files changed, 271 insertions(+), 8 deletions(-)
 create mode 100644 compiler/rustc_driver/build.rs
 create mode 100644 compiler/rustc_windows_rc/Cargo.toml
 create mode 100644 compiler/rustc_windows_rc/rustc.rc.in
 create mode 100644 compiler/rustc_windows_rc/src/lib.rs

diff --git a/Cargo.lock b/Cargo.lock
index 8b9c243879caf..03bda287c4930 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3248,6 +3248,7 @@ dependencies = [
  "rustc_driver_impl",
  "rustc_public",
  "rustc_public_bridge",
+ "rustc_windows_rc",
  "tikv-jemalloc-sys",
 ]
 
@@ -3623,6 +3624,7 @@ name = "rustc_driver"
 version = "0.0.0"
 dependencies = [
  "rustc_driver_impl",
+ "rustc_windows_rc",
 ]
 
 [[package]]
@@ -4718,6 +4720,13 @@ dependencies = [
  "semver",
 ]
 
+[[package]]
+name = "rustc_windows_rc"
+version = "0.0.0"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "rustdoc"
 version = "0.0.0"
diff --git a/compiler/rustc/Cargo.toml b/compiler/rustc/Cargo.toml
index 3ca752354466f..e3214d1ab9cec 100644
--- a/compiler/rustc/Cargo.toml
+++ b/compiler/rustc/Cargo.toml
@@ -33,3 +33,8 @@ llvm = ['rustc_driver_impl/llvm']
 max_level_info = ['rustc_driver_impl/max_level_info']
 rustc_randomized_layouts = ['rustc_driver_impl/rustc_randomized_layouts']
 # tidy-alphabetical-end
+
+[build-dependencies]
+# tidy-alphabetical-start
+rustc_windows_rc = { path = "../rustc_windows_rc" }
+# tidy-alphabetical-end
diff --git a/compiler/rustc/build.rs b/compiler/rustc/build.rs
index 8b7d28d2b8aa6..9b5def53e3cbf 100644
--- a/compiler/rustc/build.rs
+++ b/compiler/rustc/build.rs
@@ -1,4 +1,6 @@
-use std::env;
+use std::{env, path};
+
+use rustc_windows_rc::{VersionInfoFileType, compile_windows_resource_file};
 
 fn main() {
     let target_os = env::var("CARGO_CFG_TARGET_OS");
@@ -13,6 +15,18 @@ fn main() {
 
 // Add a manifest file to rustc.exe.
 fn set_windows_exe_options() {
+    set_windows_resource();
+    set_windows_manifest();
+}
+
+fn set_windows_resource() {
+    let stem = path::PathBuf::from("rustc_main_resource");
+    let file_description = "rustc";
+    let res_file = compile_windows_resource_file(&stem, file_description, VersionInfoFileType::App);
+    println!("cargo:rustc-link-arg={}", res_file.display());
+}
+
+fn set_windows_manifest() {
     static WINDOWS_MANIFEST_FILE: &str = "Windows Manifest.xml";
 
     let mut manifest = env::current_dir().unwrap();
diff --git a/compiler/rustc_codegen_ssa/Cargo.toml b/compiler/rustc_codegen_ssa/Cargo.toml
index 57e1fee2c0a67..afcfe82d68d26 100644
--- a/compiler/rustc_codegen_ssa/Cargo.toml
+++ b/compiler/rustc_codegen_ssa/Cargo.toml
@@ -9,7 +9,7 @@ ar_archive_writer = "0.4.2"
 bitflags.workspace = true
 bstr = "1.11.3"
 # `cc` updates often break things, so we pin it here. Cargo enforces "max 1 semver-compat version
-# per crate", so if you change this, you need to also change it in `rustc_llvm`.
+# per crate", so if you change this, you need to also change it in `rustc_llvm` and `rustc_windows_rc`.
 cc = "=1.2.16"
 itertools.workspace = true
 pathdiff = "0.2.0"
diff --git a/compiler/rustc_driver/Cargo.toml b/compiler/rustc_driver/Cargo.toml
index e3ee83512952a..5190971982763 100644
--- a/compiler/rustc_driver/Cargo.toml
+++ b/compiler/rustc_driver/Cargo.toml
@@ -10,3 +10,8 @@ crate-type = ["dylib"]
 # tidy-alphabetical-start
 rustc_driver_impl = { path = "../rustc_driver_impl" }
 # tidy-alphabetical-end
+
+[build-dependencies]
+# tidy-alphabetical-start
+rustc_windows_rc = { path = "../rustc_windows_rc" }
+# tidy-alphabetical-end
diff --git a/compiler/rustc_driver/build.rs b/compiler/rustc_driver/build.rs
new file mode 100644
index 0000000000000..ba44fe7a86ed9
--- /dev/null
+++ b/compiler/rustc_driver/build.rs
@@ -0,0 +1,21 @@
+use std::{env, path};
+
+use rustc_windows_rc::{VersionInfoFileType, compile_windows_resource_file};
+
+fn main() {
+    let target_os = env::var("CARGO_CFG_TARGET_OS");
+    let target_env = env::var("CARGO_CFG_TARGET_ENV");
+    if Ok("windows") == target_os.as_deref() && Ok("msvc") == target_env.as_deref() {
+        set_windows_dll_options();
+    } else {
+        // Avoid rerunning the build script every time.
+        println!("cargo:rerun-if-changed=build.rs");
+    }
+}
+
+fn set_windows_dll_options() {
+    let stem = path::PathBuf::from("rustc_driver_resource");
+    let file_description = "rustc_driver";
+    let res_file = compile_windows_resource_file(&stem, file_description, VersionInfoFileType::Dll);
+    println!("cargo:rustc-link-arg={}", res_file.display());
+}
diff --git a/compiler/rustc_llvm/Cargo.toml b/compiler/rustc_llvm/Cargo.toml
index e74de453be216..6321104ee3ef1 100644
--- a/compiler/rustc_llvm/Cargo.toml
+++ b/compiler/rustc_llvm/Cargo.toml
@@ -11,7 +11,7 @@ libc.workspace = true
 [build-dependencies]
 # tidy-alphabetical-start
 # `cc` updates often break things, so we pin it here. Cargo enforces "max 1 semver-compat version
-# per crate", so if you change this, you need to also change it in `rustc_codegen_ssa`.
+# per crate", so if you change this, you need to also change it in `rustc_codegen_ssa` and `rustc_windows_rc`.
 cc = "=1.2.16"
 # tidy-alphabetical-end
 
diff --git a/compiler/rustc_windows_rc/Cargo.toml b/compiler/rustc_windows_rc/Cargo.toml
new file mode 100644
index 0000000000000..080acd35c38cb
--- /dev/null
+++ b/compiler/rustc_windows_rc/Cargo.toml
@@ -0,0 +1,11 @@
+[package]
+name = "rustc_windows_rc"
+version = "0.0.0"
+edition = "2024"
+
+[dependencies]
+#tidy-alphabetical-start
+# `cc` updates often break things, so we pin it here. Cargo enforces "max 1 semver-compat version
+# per crate", so if you change this, you need to also change it in `rustc_llvm` and `rustc_codegen_ssa`.
+cc = "=1.2.16"
+#tidy-alphabetical-end
diff --git a/compiler/rustc_windows_rc/rustc.rc.in b/compiler/rustc_windows_rc/rustc.rc.in
new file mode 100644
index 0000000000000..10a00b9bd4e32
--- /dev/null
+++ b/compiler/rustc_windows_rc/rustc.rc.in
@@ -0,0 +1,40 @@
+// A template for the rustc_driver and rustc Windows resource files.
+// This file is processed by the build script to produce rustc.rc and rustc_driver.rc
+// with the appropriate version information filled in.
+
+// All the strings are in UTF-8
+#pragma code_page(65001)
+
+#define RUSTC_FILEDESCRIPTION_STR "@RUSTC_FILEDESCRIPTION_STR@"
+#define RUSTC_FILETYPE @RUSTC_FILETYPE@
+#define RUSTC_FILEVERSION_QUAD @RUSTC_FILEVERSION_QUAD@
+#define RUSTC_FILEVERSION_STR "@RUSTC_FILEVERSION_STR@"
+
+#define RUSTC_PRODUCTNAME_STR "@RUSTC_PRODUCTNAME_STR@"
+#define RUSTC_PRODUCTVERSION_QUAD @RUSTC_PRODUCTVERSION_QUAD@
+#define RUSTC_PRODUCTVERSION_STR "@RUSTC_PRODUCTVERSION_STR@"
+
+
+1 VERSIONINFO
+FILEVERSION RUSTC_FILEVERSION_QUAD
+PRODUCTVERSION RUSTC_PRODUCTVERSION_QUAD
+FILEOS  0x00040004
+FILETYPE RUSTC_FILETYPE
+FILESUBTYPE 0
+FILEFLAGSMASK 0x3f
+FILEFLAGS 0x0
+{
+    BLOCK "StringFileInfo"
+    {
+        BLOCK "000004b0"
+        {
+            VALUE "FileDescription", RUSTC_FILEDESCRIPTION_STR
+            VALUE "FileVersion", RUSTC_FILEVERSION_STR
+            VALUE "ProductVersion", RUSTC_PRODUCTVERSION_STR
+            VALUE "ProductName", RUSTC_PRODUCTNAME_STR
+        }
+    }
+    BLOCK "VarFileInfo" {
+        VALUE "Translation", 0x0, 0x04b0
+    }
+}
diff --git a/compiler/rustc_windows_rc/src/lib.rs b/compiler/rustc_windows_rc/src/lib.rs
new file mode 100644
index 0000000000000..caa5e5ef27656
--- /dev/null
+++ b/compiler/rustc_windows_rc/src/lib.rs
@@ -0,0 +1,158 @@
+//! A build script dependency to create a Windows resource file for the compiler
+//!
+//! Uses values from the `CFG_VERSION` and `CFG_RELEASE` environment variables
+//! to set the product and file version information in the Windows resource file.
+use std::{env, ffi, fs, path, process};
+
+use cc::windows_registry;
+
+/// The template for the Windows resource file.
+const RESOURCE_TEMPLATE: &str = include_str!("../rustc.rc.in");
+
+/// A subset of the possible values for the `FILETYPE` field in a Windows resource file
+///
+/// See the `dwFileType` member of [VS_FIXEDFILEINFO](https://learn.microsoft.com/en-us/windows/win32/api/verrsrc/ns-verrsrc-vs_fixedfileinfo#members)
+#[derive(Debug, Clone, Copy)]
+#[repr(u32)]
+pub enum VersionInfoFileType {
+    /// `VFT_APP` - The file is an application.
+    App = 0x00000001,
+    /// `VFT_DLL` - The file is a dynamic link library.
+    Dll = 0x00000002,
+}
+
+/// Create and compile a Windows resource file with the product and file version information for the rust compiler.
+///
+/// Returns the path to the compiled resource file
+///
+/// Does not emit any cargo directives, the caller is responsible for that.
+pub fn compile_windows_resource_file(
+    file_stem: &path::Path,
+    file_description: &str,
+    filetype: VersionInfoFileType,
+) -> path::PathBuf {
+    let mut resources_dir = path::PathBuf::from(env::var_os("OUT_DIR").unwrap());
+    resources_dir.push("resources");
+    fs::create_dir_all(&resources_dir).unwrap();
+
+    let resource_compiler =
+        find_resource_compiler(&env::var("CARGO_CFG_TARGET_ARCH").unwrap()).expect("found rc.exe");
+
+    let rc_path = resources_dir.join(file_stem.with_extension("rc"));
+
+    write_resource_script_file(&rc_path, file_description, filetype);
+
+    let res_path = resources_dir.join(file_stem.with_extension("res"));
+
+    let status = process::Command::new(resource_compiler)
+        .arg("/fo")
+        .arg(&res_path)
+        .arg(&rc_path)
+        .status()
+        .expect("can execute resource compiler");
+    assert!(status.success(), "rc.exe failed with status {}", status);
+    assert!(
+        res_path.try_exists().unwrap_or(false),
+        "resource file {} was not created",
+        res_path.display()
+    );
+    res_path
+}
+
+/// Writes a Windows resource script file for the rust compiler with the product and file version information
+/// into `rc_path`
+fn write_resource_script_file(
+    rc_path: &path::Path,
+    file_description: &str,
+    filetype: VersionInfoFileType,
+) {
+    let mut resource_script = RESOURCE_TEMPLATE.to_string();
+
+    // Set the string product and file version to the same thing as `rustc --version`
+    let descriptive_version = env::var("CFG_VERSION").unwrap_or("unknown".to_string());
+
+    // Set the product name to "Rust Compiler" or "Rust Compiler (nightly)" etc
+    let product_name = product_name(env::var("CFG_RELEASE_CHANNEL").unwrap());
+
+    // For the numeric version we need `major,minor,patch,build`.
+    // Extract them from `CFG_RELEASE` which is "major.minor.patch" and a "-dev", "-nightly" or similar suffix
+    let cfg_release = env::var("CFG_RELEASE").unwrap();
+    // remove the suffix, if present and parse into [`ResourceVersion`]
+    let version = parse_version(cfg_release.split("-").next().unwrap_or("0.0.0"))
+        .expect("valid CFG_RELEASE version");
+
+    resource_script = resource_script
+        .replace("@RUSTC_FILEDESCRIPTION_STR@", file_description)
+        .replace("@RUSTC_FILETYPE@", &format!("{}", filetype as u32))
+        .replace("@RUSTC_FILEVERSION_QUAD@", &version.to_quad_string())
+        .replace("@RUSTC_FILEVERSION_STR@", &descriptive_version)
+        .replace("@RUSTC_PRODUCTNAME_STR@", &product_name)
+        .replace("@RUSTC_PRODUCTVERSION_QUAD@", &version.to_quad_string())
+        .replace("@RUSTC_PRODUCTVERSION_STR@", &descriptive_version);
+
+    fs::write(&rc_path, resource_script)
+        .unwrap_or_else(|_| panic!("failed to write resource file {}", rc_path.display()));
+}
+
+fn product_name(channel: String) -> String {
+    format!(
+        "Rust Compiler{}",
+        if channel == "stable" { "".to_string() } else { format!(" ({})", channel) }
+    )
+}
+
+/// Windows resources store versions as four 16-bit integers.
+struct ResourceVersion {
+    major: u16,
+    minor: u16,
+    patch: u16,
+    build: u16,
+}
+
+impl ResourceVersion {
+    /// Format the version as a comma-separated string of four integers
+    /// as expected by Windows resource scripts for the `FILEVERSION` and `PRODUCTVERSION` fields.
+    fn to_quad_string(&self) -> String {
+        format!("{},{},{},{}", self.major, self.minor, self.patch, self.build)
+    }
+}
+
+/// Parse a string in the format "major.minor.patch" into a [`ResourceVersion`].
+/// The build is set to 0.
+/// Returns `None` if the version string is not in the expected format.
+fn parse_version(version: &str) -> Option<ResourceVersion> {
+    let mut parts = version.split('.');
+    let major = parts.next()?.parse::<u16>().ok()?;
+    let minor = parts.next()?.parse::<u16>().ok()?;
+    let patch = parts.next()?.parse::<u16>().ok()?;
+    if parts.next().is_some() {
+        None
+    } else {
+        Some(ResourceVersion { major, minor, patch, build: 0 })
+    }
+}
+
+/// Find the Windows SDK resource compiler `rc.exe` for the given architecture or target triple.
+/// Returns `None` if the tool could not be found.
+fn find_resource_compiler(arch_or_target: &str) -> Option<path::PathBuf> {
+    find_windows_sdk_tool(arch_or_target, "rc.exe")
+}
+
+/// Find a Windows SDK tool for the given architecture or target triple.
+/// Returns `None` if the tool could not be found.
+fn find_windows_sdk_tool(arch_or_target: &str, tool_name: &str) -> Option<path::PathBuf> {
+    // windows_registry::find_tool can only find MSVC tools, not Windows SDK tools, but
+    // cc does include the Windows SDK tools in the PATH environment of MSVC tools.
+
+    let msvc_linker = windows_registry::find_tool(arch_or_target, "link.exe")?;
+    let path = &msvc_linker.env().iter().find(|(k, _)| k == "PATH")?.1;
+    find_tool_in_path(tool_name, path)
+}
+
+/// Find a tool in the directories in a given PATH-like string.
+fn find_tool_in_path<P: AsRef<ffi::OsStr>>(tool_name: &str, path: P) -> Option<path::PathBuf> {
+    env::split_paths(path.as_ref()).find_map(|p| {
+        let tool_path = p.join(tool_name);
+        if tool_path.try_exists().unwrap_or(false) { Some(tool_path) } else { None }
+    })
+}
diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index b079117c5a7d1..9d6382cb4e389 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -1777,7 +1777,7 @@ mod snapshot {
         insta::assert_snapshot!(
             ctx.config("check")
                 .path("compiler")
-                .render_steps(), @"[check] rustc 0 <host> -> rustc 1 <host> (74 crates)");
+                .render_steps(), @"[check] rustc 0 <host> -> rustc 1 <host> (75 crates)");
     }
 
     #[test]
@@ -1803,7 +1803,7 @@ mod snapshot {
             ctx.config("check")
                 .path("compiler")
                 .stage(1)
-                .render_steps(), @"[check] rustc 0 <host> -> rustc 1 <host> (74 crates)");
+                .render_steps(), @"[check] rustc 0 <host> -> rustc 1 <host> (75 crates)");
     }
 
     #[test]
@@ -1817,7 +1817,7 @@ mod snapshot {
         [build] llvm <host>
         [build] rustc 0 <host> -> rustc 1 <host>
         [build] rustc 1 <host> -> std 1 <host>
-        [check] rustc 1 <host> -> rustc 2 <host> (74 crates)
+        [check] rustc 1 <host> -> rustc 2 <host> (75 crates)
         ");
     }
 
@@ -1833,7 +1833,7 @@ mod snapshot {
         [build] rustc 0 <host> -> rustc 1 <host>
         [build] rustc 1 <host> -> std 1 <host>
         [check] rustc 1 <host> -> std 1 <target1>
-        [check] rustc 1 <host> -> rustc 2 <target1> (74 crates)
+        [check] rustc 1 <host> -> rustc 2 <target1> (75 crates)
         [check] rustc 1 <host> -> rustc 2 <target1>
         [check] rustc 1 <host> -> Rustdoc 2 <target1>
         [check] rustc 1 <host> -> rustc_codegen_cranelift 2 <target1>
@@ -1929,7 +1929,7 @@ mod snapshot {
             ctx.config("check")
                 .paths(&["library", "compiler"])
                 .args(&args)
-                .render_steps(), @"[check] rustc 0 <host> -> rustc 1 <host> (74 crates)");
+                .render_steps(), @"[check] rustc 0 <host> -> rustc 1 <host> (75 crates)");
     }
 
     #[test]

From 33baaafa34ad6a6a4f0730cf880106488e391df4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Fri, 5 Sep 2025 20:20:09 +0200
Subject: [PATCH 0552/1889] Bump stage0 rustfmt

---
 src/stage0 | 242 ++++++++++++++++++++++++++---------------------------
 1 file changed, 121 insertions(+), 121 deletions(-)

diff --git a/src/stage0 b/src/stage0
index 73bf5ba4b7814..a705cd1c760d6 100644
--- a/src/stage0
+++ b/src/stage0
@@ -15,7 +15,7 @@ nightly_branch=master
 
 compiler_date=2025-08-05
 compiler_version=beta
-rustfmt_date=2025-08-06
+rustfmt_date=2025-09-05
 rustfmt_version=nightly
 
 dist/2025-08-05/rustc-beta-aarch64-apple-darwin.tar.gz=b9d8f74da46aeadb6c650a4ccfc3c2de08e229e4211a198fa2914103f09f579d
@@ -396,123 +396,123 @@ dist/2025-08-05/clippy-beta-x86_64-unknown-linux-musl.tar.gz=79fd42cffac98024308
 dist/2025-08-05/clippy-beta-x86_64-unknown-linux-musl.tar.xz=a3a616554ed25630df9f8cef37a5d36573e6f722b1f6b4220ff4885e2d3a60de
 dist/2025-08-05/clippy-beta-x86_64-unknown-netbsd.tar.gz=ad1849cb72ccfd52ba17a34d90f65226726e5044f7ffbe975c74f23643d87d98
 dist/2025-08-05/clippy-beta-x86_64-unknown-netbsd.tar.xz=608001728598164e234f176d0c6cfe7317dde27fb4cbb8ad1c2452289e83bf30
-dist/2025-08-06/rustfmt-nightly-aarch64-apple-darwin.tar.gz=b33b3bd26dd4518802b325e7c151ea73fa6844bc710ac2d2c8fb55a27c5d7e2a
-dist/2025-08-06/rustfmt-nightly-aarch64-apple-darwin.tar.xz=c900e816a94a0ddd7701c64051ba0e0244c5799e77189e26df109649b10f636f
-dist/2025-08-06/rustfmt-nightly-aarch64-pc-windows-gnullvm.tar.gz=aa7c344a52c69ee9b9e68007da806f5741688ce3917c377b6563043703e7d867
-dist/2025-08-06/rustfmt-nightly-aarch64-pc-windows-gnullvm.tar.xz=d76d7c6ca6cd5286bee12cabec166a3d8848b28a484a105b56bd5687674bc4c6
-dist/2025-08-06/rustfmt-nightly-aarch64-pc-windows-msvc.tar.gz=ea4d7c94a12485958b15e7a2782f9b8a09e065c021acd2894e7a905cadfa7489
-dist/2025-08-06/rustfmt-nightly-aarch64-pc-windows-msvc.tar.xz=4a85be8477cf4b23971fedf3b06b404cf2231f8fe941630e3e73dc902454b96e
-dist/2025-08-06/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.gz=385625349ab2e79887e2630fc861dcdd039190af36748df27500f7ea45a515f9
-dist/2025-08-06/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.xz=50cec6b681ae63ebcd60ce6cb6d328f49939c3cac1aa6b71ce76a5a3902cb52c
-dist/2025-08-06/rustfmt-nightly-aarch64-unknown-linux-musl.tar.gz=09a141bf2e457e91abf688c8084654e5e0b932418e351da2c0daf6cf89b77e56
-dist/2025-08-06/rustfmt-nightly-aarch64-unknown-linux-musl.tar.xz=7aa6d3bd020e903c842725bb3ec9dba1881f2e9cd748953c23c658ef93d49dce
-dist/2025-08-06/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.gz=c00a4b1ad60af59609e3bc61f042f9c4152de26687dcd120da173d61264b88ab
-dist/2025-08-06/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.xz=fcca5576b2f0bdab5bf7dd7ecb6ea956285aa3c129a1ea9facaf517f09f20c2d
-dist/2025-08-06/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.gz=434d9bff2e5693db416701730af1a71767715e98d674cf7273b32f76128ccab1
-dist/2025-08-06/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.xz=af48289fe813a45eb78373d80f01f060ebd2ce6337763d1ee8ea6f5080cb4eb1
-dist/2025-08-06/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.gz=68b2704b80c8f0706dc4bdba4db3b620afecbe086a7d858749d84d56f130979b
-dist/2025-08-06/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.xz=930b287659104dbf4fe759d450a4126b7a0f855fbe8fd7d3ab11aadb18ceccfa
-dist/2025-08-06/rustfmt-nightly-i686-pc-windows-gnu.tar.gz=7580ce2af926de7e07ad2313ae6397a624b10532556f7f9b9cee8ecd5addc697
-dist/2025-08-06/rustfmt-nightly-i686-pc-windows-gnu.tar.xz=ed19716bdb95eb04e64299c04725c7a0b92c66121856ab891bb67a797c8b1087
-dist/2025-08-06/rustfmt-nightly-i686-pc-windows-msvc.tar.gz=1d4077c7b42aabe2b80a19f3c96b457901f81667d62a5be9df617543245f0d8c
-dist/2025-08-06/rustfmt-nightly-i686-pc-windows-msvc.tar.xz=e0203ce7cea0c2125d8d39d92c5137b2397115c4d99f42d0b23746d0270c78d2
-dist/2025-08-06/rustfmt-nightly-i686-unknown-linux-gnu.tar.gz=0a836d9d2fc5824aeb4afd5eba709c0e3c6d4403ca8815356a0ac8735cbc95dc
-dist/2025-08-06/rustfmt-nightly-i686-unknown-linux-gnu.tar.xz=f656cb9adff0aa53f47f15a937556e9b1a9418f33dff39350e48ab8c02da987a
-dist/2025-08-06/rustfmt-nightly-loongarch64-unknown-linux-gnu.tar.gz=c44a884292ffeba027d3d029d6d53ccaa2bb85787e825c9cc1dca464046a7855
-dist/2025-08-06/rustfmt-nightly-loongarch64-unknown-linux-gnu.tar.xz=6992586e7dc3b95ddaa630cb61f58ec88b5d7c488aed8476be25a92d0fb4a3dd
-dist/2025-08-06/rustfmt-nightly-loongarch64-unknown-linux-musl.tar.gz=6e053aee8964a26385292dc2e9b671995045bb736447059e536b1e7f09c79685
-dist/2025-08-06/rustfmt-nightly-loongarch64-unknown-linux-musl.tar.xz=611d609f23f75a2b7fe304737abaf017fcf4594d9d11cbe014e91a90ee5ab27f
-dist/2025-08-06/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.gz=932f888a1a604358ad40d62bc0ca9a484f47715e8a5306fe77ae610ada4671ce
-dist/2025-08-06/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.xz=4eae3ed539b4ff8b39dae4ea4089081fa49807d31640129eec29b47030e8101e
-dist/2025-08-06/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.gz=13c65d2427c063961c19b20aa4f25bb11b3189084e2f0a798a846b95c630735b
-dist/2025-08-06/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.xz=2f8e8ec9a4c0187174a0d8d3c2addf75e68a2d60920ae100f37efb5e57a45033
-dist/2025-08-06/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.gz=e11b21d9aa403a1202c299390210d11d403501f6f55cc7ec24d6118461545825
-dist/2025-08-06/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.xz=ece7d348df665d6ff6d061e911c6bb4c9d4f161e63e888d3a66f17b533843886
-dist/2025-08-06/rustfmt-nightly-powerpc64le-unknown-linux-musl.tar.gz=d87c2370e2346587d71994ba31a0455932760507fcce680ab39322619179c429
-dist/2025-08-06/rustfmt-nightly-powerpc64le-unknown-linux-musl.tar.xz=030355ceaa2697d8b2d2de41b56cc4ef50124aa81b2f226cf0d56a1e011e0fa6
-dist/2025-08-06/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.gz=d725272b6b92059afd637a3edfc6dc2b22013bf4e70a0ed1f7c5aad3c6a71fca
-dist/2025-08-06/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.xz=f0c3e7de4e92f696585bd6a85c30fab337548e4393c3ec5b52832f3533acb063
-dist/2025-08-06/rustfmt-nightly-s390x-unknown-linux-gnu.tar.gz=79f6a3429c2ee29e1350bfce20f7f5ca1e5ec46720194cf3f34977fe446c79cd
-dist/2025-08-06/rustfmt-nightly-s390x-unknown-linux-gnu.tar.xz=777568cc6df1ce1b96f291027a5024109c189e83e2e2c046a3248e3a1cbedcc6
-dist/2025-08-06/rustfmt-nightly-sparcv9-sun-solaris.tar.gz=2528c1e6256bd9e73174b435802702bbe66eaaa4cff3748d3e5b7580ca7bc789
-dist/2025-08-06/rustfmt-nightly-sparcv9-sun-solaris.tar.xz=2f62d01498b57395e03ddfffc4e0b5cdf78a7fb6f5308440b8eee24637874752
-dist/2025-08-06/rustfmt-nightly-x86_64-apple-darwin.tar.gz=a9b2f612748bc7a88eced4462999c67eeba0ea46f4a73977513c34c09286b0a3
-dist/2025-08-06/rustfmt-nightly-x86_64-apple-darwin.tar.xz=a8137526bc41ab13a624aa5c9895abcc250f38776aeb690a7939baab1093f388
-dist/2025-08-06/rustfmt-nightly-x86_64-pc-solaris.tar.gz=18015624ba6cc1892d944d6f3c82e0b22fc5ff85ac074d25ad80fb4af12f0172
-dist/2025-08-06/rustfmt-nightly-x86_64-pc-solaris.tar.xz=bc0f5d324b4b807b0a378aa0e132a429c57c4773c6d9d30e9215ba835de1a0a5
-dist/2025-08-06/rustfmt-nightly-x86_64-pc-windows-gnu.tar.gz=de159bd0f81d54906d8020b3da80ab3319292907c3f0c9c68654f8e6ed900135
-dist/2025-08-06/rustfmt-nightly-x86_64-pc-windows-gnu.tar.xz=6dd48c3a64fcc0f2f99e4cc643cf82f1a7efab1921918fd37953c64125982606
-dist/2025-08-06/rustfmt-nightly-x86_64-pc-windows-gnullvm.tar.gz=8ba8c7ce8715fb378758ae8bd6c1538e538c2dfe86771db43b7903f18a384ad3
-dist/2025-08-06/rustfmt-nightly-x86_64-pc-windows-gnullvm.tar.xz=4259f65663aea76e1397c677bc286588cd4b6f8694647c738efc55e5616bc084
-dist/2025-08-06/rustfmt-nightly-x86_64-pc-windows-msvc.tar.gz=bfd3e1434e5b816d9d338e6c56203f58b5c1a89499ca03099d4d86b3c665f0d1
-dist/2025-08-06/rustfmt-nightly-x86_64-pc-windows-msvc.tar.xz=6260a7487d7d3759aea9e6691ac77ee38948a538f8b973459f444f98912753e0
-dist/2025-08-06/rustfmt-nightly-x86_64-unknown-freebsd.tar.gz=c10b36a6ac99d8e1de73c3ae0ca74ef10600baf7a3963f6885282b97f703f992
-dist/2025-08-06/rustfmt-nightly-x86_64-unknown-freebsd.tar.xz=b8de069c788f4a6c195d7a429ed656a45ea2a9a5775138de46d79c1c3591e70e
-dist/2025-08-06/rustfmt-nightly-x86_64-unknown-illumos.tar.gz=b0f0d9331d213015493e080f8cd06e6ed955693981241acd692a92dd545df66f
-dist/2025-08-06/rustfmt-nightly-x86_64-unknown-illumos.tar.xz=91ed6b2792622c68a5cc3698650860373305a39162b2b643b1c219cab6debbba
-dist/2025-08-06/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.gz=b1920a45d2532f41956b2c1112cf8c590243b1417bc48f3922056e1d62a27a1d
-dist/2025-08-06/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.xz=1825ed54530deb070d6f894cc12ca157be57a37e6d7ccc6007a51674eae42082
-dist/2025-08-06/rustfmt-nightly-x86_64-unknown-linux-musl.tar.gz=ac01818b1cc9130b4dcdad9db8137382655d21df9d6e7edc5cd0f84c71bbe787
-dist/2025-08-06/rustfmt-nightly-x86_64-unknown-linux-musl.tar.xz=21ee5aeb048e5337b3231b4f3ca8a6bfacc3a1cc23800052093d360ca22b3b78
-dist/2025-08-06/rustfmt-nightly-x86_64-unknown-netbsd.tar.gz=020995d3e24b4e72b0166662fd2e6969f397baa728999bbd09bce76e5381e0b5
-dist/2025-08-06/rustfmt-nightly-x86_64-unknown-netbsd.tar.xz=4a09cad2bd24ae6a15c83fb9098f66208219d3ab14c9fd46a3ce7a3c8efe6119
-dist/2025-08-06/rustc-nightly-aarch64-apple-darwin.tar.gz=25e5461350634cbd4b38dce96bc6ba6a9fbdb87caed51f26dfa058105bbccb4a
-dist/2025-08-06/rustc-nightly-aarch64-apple-darwin.tar.xz=e8774ab1e12ba4d3d088dfb0c6a929b3fb6866db035eb10a60b203a6af59f490
-dist/2025-08-06/rustc-nightly-aarch64-pc-windows-gnullvm.tar.gz=0094366fa4b8f33c7ec5bb75fa5116044c76f3b7bf4a96b5a48b31dbf6f080eb
-dist/2025-08-06/rustc-nightly-aarch64-pc-windows-gnullvm.tar.xz=6686cbf9182560d9b691ac56b3e89ed76c4fe6340dd036820a1a126e2ff41689
-dist/2025-08-06/rustc-nightly-aarch64-pc-windows-msvc.tar.gz=d3e23b1b5ac10b0cc406eb5397da7fff30aa4e558832379debf4410551ebdc4d
-dist/2025-08-06/rustc-nightly-aarch64-pc-windows-msvc.tar.xz=fd2771191a84469c6b1fcef7e90388f4699ef087e082c9838ca2bb2d1d50b399
-dist/2025-08-06/rustc-nightly-aarch64-unknown-linux-gnu.tar.gz=d4848e6a71e9cb6b87e46843f61da911ae81266f5c3aca10f85120d069d304bb
-dist/2025-08-06/rustc-nightly-aarch64-unknown-linux-gnu.tar.xz=b1e9c97f2b1c06ebf1dc00cf5fa23191a86e3ef234ebaeeced2bd41b3e59b656
-dist/2025-08-06/rustc-nightly-aarch64-unknown-linux-musl.tar.gz=4d68bc5ecf31127f67d1bb2359e9ca475ea7a0c396da29b00781929f1f00ba6c
-dist/2025-08-06/rustc-nightly-aarch64-unknown-linux-musl.tar.xz=8588747d7ce6c5a9b68ba6805b63449695e60d2e9ea7f3f0ad5f4e5a04d9062c
-dist/2025-08-06/rustc-nightly-arm-unknown-linux-gnueabi.tar.gz=4ebb3bd5e06737d2b61f249a674cda32a2a58e871039c37d49c2d6c8d2ecd6d9
-dist/2025-08-06/rustc-nightly-arm-unknown-linux-gnueabi.tar.xz=5740de96cfbdcc5261e0df10e9c7ec63e28bd553f9691a8e26e6fe9f76cbbee3
-dist/2025-08-06/rustc-nightly-arm-unknown-linux-gnueabihf.tar.gz=a7f5f4a9b5c0b6d2cf2f86feac062018e044cfbd05c9cc8243e2ff44d8196745
-dist/2025-08-06/rustc-nightly-arm-unknown-linux-gnueabihf.tar.xz=a1f54aab1b4a5ebc09d9b57c892072dfd8d5280fe7a0f3dd3f643ffc72992d34
-dist/2025-08-06/rustc-nightly-armv7-unknown-linux-gnueabihf.tar.gz=cac4ed0ff044997a35471f6c291bb165b48cdcf3f0a0a4df24d7c91cbe121362
-dist/2025-08-06/rustc-nightly-armv7-unknown-linux-gnueabihf.tar.xz=47e6083275169ef75dde6daae2bb9ca599ea03ce56d31945e9e0b42d09ebf364
-dist/2025-08-06/rustc-nightly-i686-pc-windows-gnu.tar.gz=95c87a447d33748fbfa1e9136dfb290814a7dfb1a28efc45f14f0c7830ec49bb
-dist/2025-08-06/rustc-nightly-i686-pc-windows-gnu.tar.xz=52929264f954609165aca5d925d6a1f0e41f78647b45edcd8a7c8c3f872c4bd7
-dist/2025-08-06/rustc-nightly-i686-pc-windows-msvc.tar.gz=f8db463c7c5aeb7fda6d0aa2e4d460d42a7fca5ec8b9b4d8a97e4f988c72a1bd
-dist/2025-08-06/rustc-nightly-i686-pc-windows-msvc.tar.xz=b33e23dfc673dda3eaa81d3c2d690e68cbc95bfb09864c8b2307029b0509c4f0
-dist/2025-08-06/rustc-nightly-i686-unknown-linux-gnu.tar.gz=f4f243206778a3997e3ab63170182a6e210cedd47c2a17358146e3e2cb892912
-dist/2025-08-06/rustc-nightly-i686-unknown-linux-gnu.tar.xz=194cda3450befacd2da23bccf836995f09a85e7e9c6d4ba5613cbb3c1768815f
-dist/2025-08-06/rustc-nightly-loongarch64-unknown-linux-gnu.tar.gz=f189ae4ab931c61eef04b5748b696070b998699315629a3b95d4f0b4cdae9ff9
-dist/2025-08-06/rustc-nightly-loongarch64-unknown-linux-gnu.tar.xz=23c82bf0d9f5532d94a24cfaeec66fc5f02e1b28c854e5689babd41ebcfc0ad2
-dist/2025-08-06/rustc-nightly-loongarch64-unknown-linux-musl.tar.gz=3e76a7201dd24f9d79589445509f0c80e6902864731f71d1da3f5343a75aa5bc
-dist/2025-08-06/rustc-nightly-loongarch64-unknown-linux-musl.tar.xz=3a62df3e5497fee4e56bc428db422990c7df924f72dacb6897b3783560a967c8
-dist/2025-08-06/rustc-nightly-powerpc-unknown-linux-gnu.tar.gz=cc5c126bb1ad662dc78a3b4b039e6cd32445b45b163886180fda199cbfdae9df
-dist/2025-08-06/rustc-nightly-powerpc-unknown-linux-gnu.tar.xz=1c9ecfef304fb901ec6f2cfd4e170d1f02511bb2a84de664718c20c7d154e313
-dist/2025-08-06/rustc-nightly-powerpc64-unknown-linux-gnu.tar.gz=76b6c1025d9dc045bfdfb5e0ca8e9cde674d0c40bb67f600ecb0e765b9f71f03
-dist/2025-08-06/rustc-nightly-powerpc64-unknown-linux-gnu.tar.xz=bf08f2bbd2197919acfcdf8db8130882ec8f77cb41371729072e7e94cc54997b
-dist/2025-08-06/rustc-nightly-powerpc64le-unknown-linux-gnu.tar.gz=7e5e5816a18c3b22a5a5cd0814206c3cb53c7fa2ce3d36c9c045e1fac87b0747
-dist/2025-08-06/rustc-nightly-powerpc64le-unknown-linux-gnu.tar.xz=6470b0bbe1a82064de13bd9540acbd2368421e8b000cfd8af05886a48cf11d2c
-dist/2025-08-06/rustc-nightly-powerpc64le-unknown-linux-musl.tar.gz=1a2cfbf02e55995793bdd9cf3809ace31a3d9900667ec6d5e71c6c63af26f578
-dist/2025-08-06/rustc-nightly-powerpc64le-unknown-linux-musl.tar.xz=7ea6594b669fa77481ff8ec4e8cf447c11e021a412584e1e60f0baed0976316e
-dist/2025-08-06/rustc-nightly-riscv64gc-unknown-linux-gnu.tar.gz=5cbd5821ad528d90f191a17d019b71ac2beea413b00ceec78aef9433832b2469
-dist/2025-08-06/rustc-nightly-riscv64gc-unknown-linux-gnu.tar.xz=86002592eb275d582ec8656d903ddd2247a0fcfdb2c6d90f337735a574debb9a
-dist/2025-08-06/rustc-nightly-s390x-unknown-linux-gnu.tar.gz=1c420af2bb6af11b2a718ff02d96794e9916a7f538d622b418f39ecd451e1fd6
-dist/2025-08-06/rustc-nightly-s390x-unknown-linux-gnu.tar.xz=1c33f80fbc3284d8499ec03bddb5bd9ebbe7e0da1aac6675d8442a3443440c3c
-dist/2025-08-06/rustc-nightly-sparcv9-sun-solaris.tar.gz=366a9097aaf91fd8b2853b2f94d82b8baf162dae5ef1b514072b4da19fec87a5
-dist/2025-08-06/rustc-nightly-sparcv9-sun-solaris.tar.xz=eca0aaa16e5e7006b19e56330157545d0fb56a5e590c92e041afbc8205c35ab0
-dist/2025-08-06/rustc-nightly-x86_64-apple-darwin.tar.gz=f2665645f498cc57e0b6cb052715afd264b7bb3184be58d50f528562a1610111
-dist/2025-08-06/rustc-nightly-x86_64-apple-darwin.tar.xz=2d5dba8ed862c80035ef742d9a45c1e122228219b4e1da8fd8b920eb589bbe71
-dist/2025-08-06/rustc-nightly-x86_64-pc-solaris.tar.gz=6970602ef52246883c2df83795cca94356a1e978265facab3dd3f838707d31d3
-dist/2025-08-06/rustc-nightly-x86_64-pc-solaris.tar.xz=92e7a314326015586054cdd5044c3123f41972432b2167f0dd551ee9380d66ca
-dist/2025-08-06/rustc-nightly-x86_64-pc-windows-gnu.tar.gz=5405ac07a580ba16b0f95ed0fc56a24318e8aab7abfe04c2ed3c87f9d6f1edcb
-dist/2025-08-06/rustc-nightly-x86_64-pc-windows-gnu.tar.xz=10d189c68491e15b6dd34b7f47bf8c72ccb8ab7260c4d815cb51046fd24ad76c
-dist/2025-08-06/rustc-nightly-x86_64-pc-windows-gnullvm.tar.gz=812a29f858412b9c256184e8e2b3d65d0c9912d7f4157a9ba640c8231caa5160
-dist/2025-08-06/rustc-nightly-x86_64-pc-windows-gnullvm.tar.xz=aa22d4547d85669a17c8a475baf533614d8d0547b1e386dc11bde66f215a874c
-dist/2025-08-06/rustc-nightly-x86_64-pc-windows-msvc.tar.gz=5e60c66f60a4358c0f8b2fea5577f71f4c056c7b2d0afefd9289f782004fbc63
-dist/2025-08-06/rustc-nightly-x86_64-pc-windows-msvc.tar.xz=6d975c907e1def685c14fe6e460001af0362824f771585f9b1ccc2cc1ea71fac
-dist/2025-08-06/rustc-nightly-x86_64-unknown-freebsd.tar.gz=465206e95e2c6a7731ca55db9e576f1f78e9d356ba81c6687752793101c80b92
-dist/2025-08-06/rustc-nightly-x86_64-unknown-freebsd.tar.xz=13cd73704262a891ea825201e6583c171f7a920c1be5372b4cccf5cbe3d294fc
-dist/2025-08-06/rustc-nightly-x86_64-unknown-illumos.tar.gz=a7bf182bf19812d41e103a8d89e6c3457c1c9d0ddd800f59fdc3d94df587e3c3
-dist/2025-08-06/rustc-nightly-x86_64-unknown-illumos.tar.xz=43da78e7dca1415ecd756ef13fd08a8358b8deedf406d18801f36e38843a704f
-dist/2025-08-06/rustc-nightly-x86_64-unknown-linux-gnu.tar.gz=ef6381475d22aff666429754e25855e97a4dc39e8d508c02a0e353df58afcaba
-dist/2025-08-06/rustc-nightly-x86_64-unknown-linux-gnu.tar.xz=238910ad25562d4f7fa6c83d92f9cad5ec3817191907958fa646251c9bcdb690
-dist/2025-08-06/rustc-nightly-x86_64-unknown-linux-musl.tar.gz=df2464c2f2c9233f2009ac73924e95b7dd395c8575874a3391fe2f3dfcfda327
-dist/2025-08-06/rustc-nightly-x86_64-unknown-linux-musl.tar.xz=99c5a9d7f0e7f9e3acde96bfd1d23a11100be81a3651e8267e6e0ffca6bc553d
-dist/2025-08-06/rustc-nightly-x86_64-unknown-netbsd.tar.gz=705dd37d72d99694234af13a561dd9995a0e4c2bfd888aa451b666f49a7083a7
-dist/2025-08-06/rustc-nightly-x86_64-unknown-netbsd.tar.xz=0dc9551d63131336cd97b7bfca984970fc8e5c366b39e04a179673f7859f4c1e
+dist/2025-09-05/rustfmt-nightly-aarch64-apple-darwin.tar.gz=6fd7eece7221e76c2596e0472e7311fdced87e9fab26d2a4673a3242fe779bd3
+dist/2025-09-05/rustfmt-nightly-aarch64-apple-darwin.tar.xz=1a662a55931f58be9ac05841360305f277f8b1e36f99bd0a2ee4d2cc92b7ad14
+dist/2025-09-05/rustfmt-nightly-aarch64-pc-windows-gnullvm.tar.gz=d1c3c52cf61522697d726b32ed28d7b8b4cfadf30ec57f242e8c7f9f8e09f692
+dist/2025-09-05/rustfmt-nightly-aarch64-pc-windows-gnullvm.tar.xz=2cc7cbbfa06803a2fe422ed3266f6eb519360b403c83f92259cc1b83f5ddca45
+dist/2025-09-05/rustfmt-nightly-aarch64-pc-windows-msvc.tar.gz=61f525d050d1ff4a29cc7240912d84c9c091f25195b58411af9ef176175a3200
+dist/2025-09-05/rustfmt-nightly-aarch64-pc-windows-msvc.tar.xz=504b8ace2ab7ac13be143d95ed74d94940e8706ef9f53b7778da215840337e20
+dist/2025-09-05/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.gz=ff48bd98d109310638822f5813042583900e2b70edd45fccd871c7c03dd1c2e6
+dist/2025-09-05/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.xz=b3de2bba7858e76cdafd326f3072e4c5b534ca9b679ea62caeffb07722e9a3c9
+dist/2025-09-05/rustfmt-nightly-aarch64-unknown-linux-musl.tar.gz=8ca4caedc50f09995dad7bc6e001cc863c524e28c45c186022ded589f3728709
+dist/2025-09-05/rustfmt-nightly-aarch64-unknown-linux-musl.tar.xz=8f2cfb052f9697052d89bb729d17d74583af3fa0be98f18a3c44ea518a8f4855
+dist/2025-09-05/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.gz=b12ac2a38b379bf0de4a92f29ca40e1955c45273e798edd1a72bd40253de70f1
+dist/2025-09-05/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.xz=87fb7185aa46f3810e09479dc8fafb66d13b41f4f40e9c4e866ea77fa47b1bb6
+dist/2025-09-05/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.gz=be1e8377f3d10f4f8a07ae06ab9f649f9d2fc9cfc395abaa5f0ad10a95c4fe7a
+dist/2025-09-05/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.xz=60646799fdacdafec9e0ed81357b5db70f85bb1241fe775e71b8ad3feb686116
+dist/2025-09-05/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.gz=ed8cade9b846efb5ac121aa70ac188fbd2e61fa9402fe68c80b2cbd3ee32ccbd
+dist/2025-09-05/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.xz=0d0bfbd9cd4123e0404fe476a6f16eec6e435ce28d328dc0dd0aad257b295d64
+dist/2025-09-05/rustfmt-nightly-i686-pc-windows-gnu.tar.gz=bd411db34707c36d5b60f14bba776b0b89b69d4266007a3b591c467a17ef053c
+dist/2025-09-05/rustfmt-nightly-i686-pc-windows-gnu.tar.xz=f0f2a6a81177ae6d06ff9b8f4a5bdf3bc8b26710aaf0f09258b32f7f710722c0
+dist/2025-09-05/rustfmt-nightly-i686-pc-windows-msvc.tar.gz=b49130da444e01fe4ef997b649aada8978b8dcca60dd38cf9e7400a7c7569e1b
+dist/2025-09-05/rustfmt-nightly-i686-pc-windows-msvc.tar.xz=0195cdddc74cba2bf17eaa1d53edb1a2bc0e34cdf13c7b25a34ad9729a2635b8
+dist/2025-09-05/rustfmt-nightly-i686-unknown-linux-gnu.tar.gz=1141897495ddca10fd6d9476a624b6a340fc2bfc619148e183bcf355a0078b18
+dist/2025-09-05/rustfmt-nightly-i686-unknown-linux-gnu.tar.xz=81b31bc8b3d431120005c3c8eeff3ed194dd18e56220c175c3250855cbdcddbe
+dist/2025-09-05/rustfmt-nightly-loongarch64-unknown-linux-gnu.tar.gz=10a27070239e7dfcf701669c8d93ecb2d310b9fde768639a2bf5be62cd13528d
+dist/2025-09-05/rustfmt-nightly-loongarch64-unknown-linux-gnu.tar.xz=0ac4a529f4f62a94d5ae4cc8a4a52f0e7d57296ac0884258dcc5478e6b0b1785
+dist/2025-09-05/rustfmt-nightly-loongarch64-unknown-linux-musl.tar.gz=9d0ed6778fc4f0601be1e317438cf95c414fcab6d3207c635babb4f3a6faf2b0
+dist/2025-09-05/rustfmt-nightly-loongarch64-unknown-linux-musl.tar.xz=e40b607faf2f37c9d654cc0b60c47ea155893a3b62236cd66728f68665becb18
+dist/2025-09-05/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.gz=46c029ebbfa35972b0b9e366d17c41ff8e278e01ce12634d5e3146cbf6d1a32e
+dist/2025-09-05/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.xz=8d1462fd09b04a94bfb1c1841c522430b644961995bf0e19e7c8fa150628e7c7
+dist/2025-09-05/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.gz=5827684ccb4d38956e77858ddeadeaff2d92905c67093207bed0f38202268151
+dist/2025-09-05/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.xz=975c7d7beb5b66caed7d507aaec092fdf33de2308f4dc7de46fe74e5e15b5352
+dist/2025-09-05/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.gz=8829677ab0f898c98badf22dad61094cf53c6d599b2cc76142d3d792a44f3770
+dist/2025-09-05/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.xz=3d961bead4010f8a488a065ac8a4153e3c747dfcd7d5f7eeba1cad00767a7ac5
+dist/2025-09-05/rustfmt-nightly-powerpc64le-unknown-linux-musl.tar.gz=0138c30ebe74e8ee838d9eef31c7882812bb52d2304f2de7c23c47dedd6a5032
+dist/2025-09-05/rustfmt-nightly-powerpc64le-unknown-linux-musl.tar.xz=bdb4b7b3c89a30c79f51b5fa33a2a29fc8313f8193bc43ee611e8ce7d80382d2
+dist/2025-09-05/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.gz=8e440dd400bf3eb4a144318459e111069a64bb309a5a51eeb0f0383dc48ee55f
+dist/2025-09-05/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.xz=f623e1d7d38d94965d7653fdf4a272630b2b6dec81662fbbe5d2573f2f3f3b8f
+dist/2025-09-05/rustfmt-nightly-s390x-unknown-linux-gnu.tar.gz=f46a8278352d5a981c6746b876fe19df3093090a866d20d24cd5cb081136b1c0
+dist/2025-09-05/rustfmt-nightly-s390x-unknown-linux-gnu.tar.xz=fdf8b44c6f110a33ad7f969e651ad396c880a85545aadfee8a24ca3cbed35974
+dist/2025-09-05/rustfmt-nightly-sparcv9-sun-solaris.tar.gz=59d778dea354867d64c809b40443ca0762c685dd0e5361971daab04aa7c5a5ad
+dist/2025-09-05/rustfmt-nightly-sparcv9-sun-solaris.tar.xz=18628b2888d77281fc9b2ac5636ce4ec444ab0e47bbe0e8a08238f90040c20a3
+dist/2025-09-05/rustfmt-nightly-x86_64-apple-darwin.tar.gz=169d9f2ee4a0c726040f4940370d1162502aa6568a0a442c92cad3fbc7bd95c2
+dist/2025-09-05/rustfmt-nightly-x86_64-apple-darwin.tar.xz=7f955cfa1ab07819f31cd904b0a79c67cae70090aabc7dafffdc1f3f67463248
+dist/2025-09-05/rustfmt-nightly-x86_64-pc-solaris.tar.gz=d2cc32d6be1d0f1a8654400f0418d16e789b62db3fbc0cca0d0d492615bcf6e2
+dist/2025-09-05/rustfmt-nightly-x86_64-pc-solaris.tar.xz=3dbc29c923a6a2809a8ef561d2ad375211b09dcb107bceabbf510ab0d7b471f0
+dist/2025-09-05/rustfmt-nightly-x86_64-pc-windows-gnu.tar.gz=d9b4ca2abf1062e888b31f31f517ccc6b451bd2bfdae915ec3984bc88a8be91a
+dist/2025-09-05/rustfmt-nightly-x86_64-pc-windows-gnu.tar.xz=00c6d92b6e82ae58e682e72c974f2dcc865820567ba44ed008e4759dfdbdca87
+dist/2025-09-05/rustfmt-nightly-x86_64-pc-windows-gnullvm.tar.gz=e75424d0aece8d548b2c9d896291288615d08ff2a37f1c4844a70839c612e633
+dist/2025-09-05/rustfmt-nightly-x86_64-pc-windows-gnullvm.tar.xz=cce9578d9b35bd8192a26e2dc7d7f7e7d5b9f08c7d73b3f4dde08208b448b063
+dist/2025-09-05/rustfmt-nightly-x86_64-pc-windows-msvc.tar.gz=ac4282e06b0972033f974c63d2c6cbf194d4e66a1c811f443d3fa0b886868825
+dist/2025-09-05/rustfmt-nightly-x86_64-pc-windows-msvc.tar.xz=a2465b31855861d0e0eea072bb366480acf2bafdd7fdfdab79c809d8bbf8d8e4
+dist/2025-09-05/rustfmt-nightly-x86_64-unknown-freebsd.tar.gz=30c22a97066a5711f207c1919a1d74a328540da0d9d6f85a0cc044174049c927
+dist/2025-09-05/rustfmt-nightly-x86_64-unknown-freebsd.tar.xz=40987da0b665940f9c406cfbb4889dc101d73846730b0bdfa1382d051297ad08
+dist/2025-09-05/rustfmt-nightly-x86_64-unknown-illumos.tar.gz=443ba10092122fbba9854abb4aa9d2e71d8e5e65b99fae6dd572909bf50f28c5
+dist/2025-09-05/rustfmt-nightly-x86_64-unknown-illumos.tar.xz=10285942b9140efc9897965cb3a4204145e774bd1b0c2690d45d8b04498fb917
+dist/2025-09-05/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.gz=b09af4fe367df416bce622654d9e3dfb610c564f5e6d14b200d949340595673c
+dist/2025-09-05/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.xz=1f9a585a017cee5a05190377cab105603f039fbefd9b4934278dc555dfca91b0
+dist/2025-09-05/rustfmt-nightly-x86_64-unknown-linux-musl.tar.gz=24f911745fcc9f120e44acccb98f54dc6406e492915410aae17efdd00e2752c3
+dist/2025-09-05/rustfmt-nightly-x86_64-unknown-linux-musl.tar.xz=48eb58ba1d58701dbff341e19fb6d446ed937cc410207b35297babafa29dd889
+dist/2025-09-05/rustfmt-nightly-x86_64-unknown-netbsd.tar.gz=c2d1cfdcd8a08bde3f9a635eaf2d6d2fbd82e4cabbbd459e3c47e64bf1581f11
+dist/2025-09-05/rustfmt-nightly-x86_64-unknown-netbsd.tar.xz=ed1775b4fd3d7d1203f8749f70328ea4ade802fa0a76c4d7ab3e2d63ca1535af
+dist/2025-09-05/rustc-nightly-aarch64-apple-darwin.tar.gz=4b64c4148e5cdd6585a4200125cc394c6a998da3686ef758f37742ec2d33d573
+dist/2025-09-05/rustc-nightly-aarch64-apple-darwin.tar.xz=fd45182f9db059bdc17f2c465dbaae22589eb8e8d2d88776437a34ddca3b7153
+dist/2025-09-05/rustc-nightly-aarch64-pc-windows-gnullvm.tar.gz=c14f2d7f391492d150f2f2f91af413266649cbdbdb042fc8b660b3cb141b80c7
+dist/2025-09-05/rustc-nightly-aarch64-pc-windows-gnullvm.tar.xz=d72ea1c571fe2376ef05cfd15fb3207ee2d27c3c851f3391dfbb082c06a5bdd0
+dist/2025-09-05/rustc-nightly-aarch64-pc-windows-msvc.tar.gz=3a485d8fd8d58fdfbc1216e51414aa4d90f0c7285a99abea0fa5935d2337251b
+dist/2025-09-05/rustc-nightly-aarch64-pc-windows-msvc.tar.xz=7317060a29eecd2e28d47f0ff8780150059756b07e2bc9137c3877be8af593b7
+dist/2025-09-05/rustc-nightly-aarch64-unknown-linux-gnu.tar.gz=58a53ae147de1beb0a53629898bf7c51097351271be3713a2e2344b86a4080a4
+dist/2025-09-05/rustc-nightly-aarch64-unknown-linux-gnu.tar.xz=f79d2730843dbea9e9588fd1c1b0d854441969d8f93f76021f06af2efe22b845
+dist/2025-09-05/rustc-nightly-aarch64-unknown-linux-musl.tar.gz=eddf23e28b8067021e80883faf2eb1d6d3005a6e8419a1232b84236bea286f78
+dist/2025-09-05/rustc-nightly-aarch64-unknown-linux-musl.tar.xz=4f0af1a66050f5e2d9d48b696349b9ccd420bdcfdb88b251a6655cc22a11949b
+dist/2025-09-05/rustc-nightly-arm-unknown-linux-gnueabi.tar.gz=fd2f0446e3c993d746e8a5f72ccebd8b0a49172316ac1d1c58bad10596becbf3
+dist/2025-09-05/rustc-nightly-arm-unknown-linux-gnueabi.tar.xz=0b06e7ba47621819b4e59e048e5d336b3d6978e906c7363f06bbc804e49f1046
+dist/2025-09-05/rustc-nightly-arm-unknown-linux-gnueabihf.tar.gz=97d7c34b53628f28e6636fae738a18d0f1f4c60a9febddfb7145e6b91fcf3fdc
+dist/2025-09-05/rustc-nightly-arm-unknown-linux-gnueabihf.tar.xz=323025215bf851024a7eb6566ad7dc5719832d81e8d46e70adaece98adc5644b
+dist/2025-09-05/rustc-nightly-armv7-unknown-linux-gnueabihf.tar.gz=3017e03222d030448ffe2805624143540197bd6d3b3e93f9f73469ace25ae4be
+dist/2025-09-05/rustc-nightly-armv7-unknown-linux-gnueabihf.tar.xz=4f6e86b185fb54f7a0b7d09a0faae7daac722351354f6abebd388efb3037dfa0
+dist/2025-09-05/rustc-nightly-i686-pc-windows-gnu.tar.gz=292c3770b96cde97072d70c58234488f955ed5582b7c3044c6de66891e73d639
+dist/2025-09-05/rustc-nightly-i686-pc-windows-gnu.tar.xz=6855d3fd9040fb4da554fd732eaf8a1c723921c35bb8a8efb31c78af69b2e4ec
+dist/2025-09-05/rustc-nightly-i686-pc-windows-msvc.tar.gz=64a86a2971ed9934bbb6aaa0afc2a7f747da463afb55b51a7c5fdbdaa294e437
+dist/2025-09-05/rustc-nightly-i686-pc-windows-msvc.tar.xz=c98f1fc3e077b8c8eb3e526c416a6551c08c62e58be57b4a4c7d59670bc435f9
+dist/2025-09-05/rustc-nightly-i686-unknown-linux-gnu.tar.gz=5481c97d788899f896473380dde0877808489bc4a0ed6d98265558631fa67a57
+dist/2025-09-05/rustc-nightly-i686-unknown-linux-gnu.tar.xz=afadaae945c0b9a8b50dbdee28791e0c03c880cb22d3c20996eeb7fab94df0bf
+dist/2025-09-05/rustc-nightly-loongarch64-unknown-linux-gnu.tar.gz=18b276a2464b6c5a817d72384f25442c7619cac05b2d8d0af212c0dad96ccfc6
+dist/2025-09-05/rustc-nightly-loongarch64-unknown-linux-gnu.tar.xz=b74323cd2dbee966eebe8e63e24fae026ecd900a025e9167cca0341e50333cc3
+dist/2025-09-05/rustc-nightly-loongarch64-unknown-linux-musl.tar.gz=916dc5144107d9173479b320b55b0a95d2d42156c69fbdb0f21377d825fe0892
+dist/2025-09-05/rustc-nightly-loongarch64-unknown-linux-musl.tar.xz=3a83da72aa4a6553ecd957af35a05274528dc79f87d24d8470c20b8b4478b05b
+dist/2025-09-05/rustc-nightly-powerpc-unknown-linux-gnu.tar.gz=59e031b6b79a1f11406c0640e1a357f2941967ea8c034a94148d60928038e58e
+dist/2025-09-05/rustc-nightly-powerpc-unknown-linux-gnu.tar.xz=53f0e33cf2651d5dc8931ec5af8f04994188d8f9a10a5c61bd72cc822df34501
+dist/2025-09-05/rustc-nightly-powerpc64-unknown-linux-gnu.tar.gz=0eec56e3b725d918cb21e494a803b2e38eb6d744f64f1a82481a4c704eb7c1f0
+dist/2025-09-05/rustc-nightly-powerpc64-unknown-linux-gnu.tar.xz=5efc97abb235f349c6cc952b4a1e4dae7d56d70b0f8b8da2a1060b85f9b734fd
+dist/2025-09-05/rustc-nightly-powerpc64le-unknown-linux-gnu.tar.gz=cb45bbcdf8841b1ac184a0aacc909f153c830e8051260e09ca4e32c1f048e2fb
+dist/2025-09-05/rustc-nightly-powerpc64le-unknown-linux-gnu.tar.xz=1c9ddddb90d45612e4fd190fb71e527b523df13146343dde200580fb2b638794
+dist/2025-09-05/rustc-nightly-powerpc64le-unknown-linux-musl.tar.gz=3a9bdd4d14e8f121d3051944ee83a901b5ca4c0921f2d01e34596fb7450b49e3
+dist/2025-09-05/rustc-nightly-powerpc64le-unknown-linux-musl.tar.xz=732b9abb8a80191884fe1ff1d4d923cc1b74c21b81e6327bc5979ae526337400
+dist/2025-09-05/rustc-nightly-riscv64gc-unknown-linux-gnu.tar.gz=1826e74200fe286478e1659ab88ea86b43efa7b023074d00dbc814d80bebc883
+dist/2025-09-05/rustc-nightly-riscv64gc-unknown-linux-gnu.tar.xz=c30b52d0f474fd6193bb1b3e147fb79fa8cc31e5db38444f023d84d1c2d93d12
+dist/2025-09-05/rustc-nightly-s390x-unknown-linux-gnu.tar.gz=c330067621ed25d8383f27e494346eca4d7d4866e48f331f2ec897ff1c386e56
+dist/2025-09-05/rustc-nightly-s390x-unknown-linux-gnu.tar.xz=cb4097ea582a83a94cab80ff2f36b6f7141c140d75c30b1d261a1ddd4ea45bd4
+dist/2025-09-05/rustc-nightly-sparcv9-sun-solaris.tar.gz=0af19e764f10333017a3ab66020b82c7185ad648d1230b68f10977e0affb937f
+dist/2025-09-05/rustc-nightly-sparcv9-sun-solaris.tar.xz=a22cfb55cdd122dd99bf3566eabd781bb2ecded90c71a41fd33b1e0588bcc39c
+dist/2025-09-05/rustc-nightly-x86_64-apple-darwin.tar.gz=163a07b91e36e85c6c41368598793667414cdc6cadc980866811234539f3aec3
+dist/2025-09-05/rustc-nightly-x86_64-apple-darwin.tar.xz=76711800685b39b3b75945395682062c40efe3195f9979784bf318837e21768a
+dist/2025-09-05/rustc-nightly-x86_64-pc-solaris.tar.gz=69142a6c04703c3c8309c6fdf66b25831bf9efa3ee70cc93da4b5b75f901b29a
+dist/2025-09-05/rustc-nightly-x86_64-pc-solaris.tar.xz=7e535f4aa136284e4bdfd4d56891caac6844dab91e1b711fa3914a5974dfcb60
+dist/2025-09-05/rustc-nightly-x86_64-pc-windows-gnu.tar.gz=ff0ea563126ff28df297258001d9fac4dbd85788b5d27a0f5d6be75306f21139
+dist/2025-09-05/rustc-nightly-x86_64-pc-windows-gnu.tar.xz=6b66adcaa9a5332979591464242423897f59276e9e2cbeb9ab038a72e72c3a5c
+dist/2025-09-05/rustc-nightly-x86_64-pc-windows-gnullvm.tar.gz=64cac5e377bc115a8f8176719575903e695337941db43cfb35546d65c0723130
+dist/2025-09-05/rustc-nightly-x86_64-pc-windows-gnullvm.tar.xz=11e2765e4b3e2296ea05ecf735cf7b5f7beb08d76d12449cfae67f88bab02819
+dist/2025-09-05/rustc-nightly-x86_64-pc-windows-msvc.tar.gz=c7d15ae7cd5af774ae70e63fec3ba8723b85fa4c4640917b3960907eedb30b39
+dist/2025-09-05/rustc-nightly-x86_64-pc-windows-msvc.tar.xz=55036567af270cdac046fb4306e515787ca6ef5073617311fac79fb87ffe9366
+dist/2025-09-05/rustc-nightly-x86_64-unknown-freebsd.tar.gz=2d24470d2bb4c4d2605c15f1b2654cc45805384babb73b1960e8aea0b8cc227d
+dist/2025-09-05/rustc-nightly-x86_64-unknown-freebsd.tar.xz=fa41782cb2e22aba30d1619db1f478c0305944ceb4de1d1001f221c5c68c104e
+dist/2025-09-05/rustc-nightly-x86_64-unknown-illumos.tar.gz=d0f9785f76c59f3a67a499cfff4a5639f3ae05cbc76750b867faaa60b7d67f78
+dist/2025-09-05/rustc-nightly-x86_64-unknown-illumos.tar.xz=925e473c6e31d8811879a805358cfd2e5ab8f4de836c270d02dc8403771bed3a
+dist/2025-09-05/rustc-nightly-x86_64-unknown-linux-gnu.tar.gz=ebac845114b89dfe7d0efc0cfe8820902faad617ed21eb2a701d73cf7b544a85
+dist/2025-09-05/rustc-nightly-x86_64-unknown-linux-gnu.tar.xz=2512a5462e3f46c95ed4aba4228282a357b3e0694e9db117a857196448fe7bcc
+dist/2025-09-05/rustc-nightly-x86_64-unknown-linux-musl.tar.gz=b4a5d364b84464e9a92140fff50349d4942b8d970b64150a4bc6d720cc6c4a4e
+dist/2025-09-05/rustc-nightly-x86_64-unknown-linux-musl.tar.xz=6c57c2edc305737530f8551d789ee79ff952f42a0d52d6f8d7d7f1ea2027cfca
+dist/2025-09-05/rustc-nightly-x86_64-unknown-netbsd.tar.gz=f3192ded327875d5a27fb50c690e3fce36669e8f71c47de304dc21edad573ff9
+dist/2025-09-05/rustc-nightly-x86_64-unknown-netbsd.tar.xz=11359e4731866f6a788e5699867e45befdf1ad49ef35c0aba22af76d3f327cc3

From f279ae1b05fe0f12259b3e24d35f5598b18f5ea9 Mon Sep 17 00:00:00 2001
From: Yotam Ofek <yotam.ofek@gmail.com>
Date: Fri, 5 Sep 2025 18:43:43 +0000
Subject: [PATCH 0553/1889] Use `Itertools::all_equal_value()` where applicable

---
 compiler/rustc_codegen_ssa/src/mir/rvalue.rs  | 27 +++++++++----------
 compiler/rustc_mir_transform/src/gvn.rs       | 17 ++++++------
 .../src/lint_tail_expr_drop_order.rs          |  5 ++--
 compiler/rustc_mir_transform/src/simplify.rs  | 18 +++++--------
 compiler/rustc_resolve/src/diagnostics.rs     | 14 ++++------
 5 files changed, 35 insertions(+), 46 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
index 8a67b8d6e5f13..f6f2e3f2a3a3c 100644
--- a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -1,3 +1,4 @@
+use itertools::Itertools as _;
 use rustc_abi::{self as abi, FIRST_VARIANT};
 use rustc_middle::ty::adjustment::PointerCoercion;
 use rustc_middle::ty::layout::{HasTyCtxt, HasTypingEnv, LayoutOf, TyAndLayout};
@@ -111,14 +112,13 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                     let size = bx.const_usize(dest.layout.size.bytes());
 
                     // Use llvm.memset.p0i8.* to initialize all same byte arrays
-                    if let Some(int) = bx.cx().const_to_opt_u128(v, false) {
-                        let bytes = &int.to_le_bytes()[..cg_elem.layout.size.bytes_usize()];
-                        let first = bytes[0];
-                        if bytes[1..].iter().all(|&b| b == first) {
-                            let fill = bx.cx().const_u8(first);
-                            bx.memset(start, fill, size, dest.val.align, MemFlags::empty());
-                            return true;
-                        }
+                    if let Some(int) = bx.cx().const_to_opt_u128(v, false)
+                        && let bytes = &int.to_le_bytes()[..cg_elem.layout.size.bytes_usize()]
+                        && let Ok(&byte) = bytes.iter().all_equal_value()
+                    {
+                        let fill = bx.cx().const_u8(byte);
+                        bx.memset(start, fill, size, dest.val.align, MemFlags::empty());
+                        return true;
                     }
 
                     // Use llvm.memset.p0i8.* to initialize byte arrays
@@ -130,13 +130,10 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                     false
                 };
 
-                match cg_elem.val {
-                    OperandValue::Immediate(v) => {
-                        if try_init_all_same(bx, v) {
-                            return;
-                        }
-                    }
-                    _ => (),
+                if let OperandValue::Immediate(v) = cg_elem.val
+                    && try_init_all_same(bx, v)
+                {
+                    return;
                 }
 
                 let count = self
diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index 5a13394543b4a..9da6e034c3b40 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -87,6 +87,7 @@
 use std::borrow::Cow;
 
 use either::Either;
+use itertools::Itertools as _;
 use rustc_abi::{self as abi, BackendRepr, FIRST_VARIANT, FieldIdx, Primitive, Size, VariantIdx};
 use rustc_const_eval::const_eval::DummyMachine;
 use rustc_const_eval::interpret::{
@@ -1023,15 +1024,15 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             }
         };
 
-        if ty.is_array() && fields.len() > 4 {
-            let first = fields[0];
-            if fields.iter().all(|&v| v == first) {
-                let len = ty::Const::from_target_usize(self.tcx, fields.len().try_into().unwrap());
-                if let Some(op) = self.try_as_operand(first, location) {
-                    *rvalue = Rvalue::Repeat(op, len);
-                }
-                return Some(self.insert(ty, Value::Repeat(first, len)));
+        if ty.is_array()
+            && fields.len() > 4
+            && let Ok(&first) = fields.iter().all_equal_value()
+        {
+            let len = ty::Const::from_target_usize(self.tcx, fields.len().try_into().unwrap());
+            if let Some(op) = self.try_as_operand(first, location) {
+                *rvalue = Rvalue::Repeat(op, len);
             }
+            return Some(self.insert(ty, Value::Repeat(first, len)));
         }
 
         if let Some(value) =
diff --git a/compiler/rustc_mir_transform/src/lint_tail_expr_drop_order.rs b/compiler/rustc_mir_transform/src/lint_tail_expr_drop_order.rs
index 794984d2f3edf..61c9bbe31239e 100644
--- a/compiler/rustc_mir_transform/src/lint_tail_expr_drop_order.rs
+++ b/compiler/rustc_mir_transform/src/lint_tail_expr_drop_order.rs
@@ -2,6 +2,7 @@ use std::cell::RefCell;
 use std::collections::hash_map;
 use std::rc::Rc;
 
+use itertools::Itertools as _;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
 use rustc_data_structures::unord::{UnordMap, UnordSet};
 use rustc_errors::Subdiagnostic;
@@ -339,9 +340,9 @@ pub(crate) fn run_lint<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId, body: &Body<
             // Suppose that all BIDs point into the same local,
             // we can remove the this local from the observed drops,
             // so that we can focus our diagnosis more on the others.
-            if candidates.iter().all(|&(_, place)| candidates[0].1.local == place.local) {
+            if let Ok(local) = candidates.iter().map(|&(_, place)| place.local).all_equal_value() {
                 for path_idx in all_locals_dropped.iter() {
-                    if move_data.move_paths[path_idx].place.local == candidates[0].1.local {
+                    if move_data.move_paths[path_idx].place.local == local {
                         to_exclude.insert(path_idx);
                     }
                 }
diff --git a/compiler/rustc_mir_transform/src/simplify.rs b/compiler/rustc_mir_transform/src/simplify.rs
index 468ef742dfb73..75917d23883be 100644
--- a/compiler/rustc_mir_transform/src/simplify.rs
+++ b/compiler/rustc_mir_transform/src/simplify.rs
@@ -34,6 +34,7 @@
 //! The normal logic that a program with UB can be changed to do anything does not apply to
 //! pre-"runtime" MIR!
 
+use itertools::Itertools as _;
 use rustc_index::{Idx, IndexSlice, IndexVec};
 use rustc_middle::mir::visit::{MutVisitor, MutatingUseContext, PlaceContext, Visitor};
 use rustc_middle::mir::*;
@@ -288,20 +289,13 @@ impl<'a, 'tcx> CfgSimplifier<'a, 'tcx> {
             return false;
         };
 
-        let first_succ = {
-            if let Some(first_succ) = terminator.successors().next() {
-                if terminator.successors().all(|s| s == first_succ) {
-                    let count = terminator.successors().count();
-                    self.pred_count[first_succ] -= (count - 1) as u32;
-                    first_succ
-                } else {
-                    return false;
-                }
-            } else {
-                return false;
-            }
+        let Ok(first_succ) = terminator.successors().all_equal_value() else {
+            return false;
         };
 
+        let count = terminator.successors().count();
+        self.pred_count[first_succ] -= (count - 1) as u32;
+
         debug!("simplifying branch {:?}", terminator);
         terminator.kind = TerminatorKind::Goto { target: first_succ };
         true
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index f458a1f17b99b..689e713ef46dd 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -1,3 +1,4 @@
+use itertools::Itertools as _;
 use rustc_ast::visit::{self, Visitor};
 use rustc_ast::{
     self as ast, CRATE_NODE_ID, Crate, ItemKind, ModKind, NodeId, Path, join_path_idents,
@@ -3469,16 +3470,11 @@ fn show_candidates(
                 err.note(note.to_string());
             }
         } else {
-            let (_, descr_first, _, _, _) = &inaccessible_path_strings[0];
-            let descr = if inaccessible_path_strings
+            let descr = inaccessible_path_strings
                 .iter()
-                .skip(1)
-                .all(|(_, descr, _, _, _)| descr == descr_first)
-            {
-                descr_first
-            } else {
-                "item"
-            };
+                .map(|&(_, descr, _, _, _)| descr)
+                .all_equal_value()
+                .unwrap_or("item");
             let plural_descr =
                 if descr.ends_with('s') { format!("{descr}es") } else { format!("{descr}s") };
 

From cd9917208fc29c4e3f7f174c32443f1875a0173d Mon Sep 17 00:00:00 2001
From: Alona Enraght-Moony <code@alona.page>
Date: Fri, 5 Sep 2025 20:35:51 +0100
Subject: [PATCH 0554/1889] Make footnote render correctly in github

---
 .../src/rustdoc-internals/rustdoc-json-test-suite.md          | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-json-test-suite.md b/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-json-test-suite.md
index efc576cc90070..2d48878b05ad9 100644
--- a/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-json-test-suite.md
+++ b/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-json-test-suite.md
@@ -63,13 +63,13 @@ Arguments to directives are split using the [shlex] crate, which implements POSI
 This is because both `<path>` and `<value>` arguments to [directives](#directives) frequently have both
 whitespace and quote marks.
 
-To use the `@ is` with a `<path>` of `$.index[?(@.docs == "foo")].some.field` and a value of `"bar"` [^why quote], you'd write:
+To use the `@ is` with a `<path>` of `$.index[?(@.docs == "foo")].some.field` and a value of `"bar"` [^why_quote], you'd write:
 
 ```rust
 //@ is '$.is[?(@.docs == "foo")].some.field' '"bar"'
 ```
 
-[^why quote]: The value needs to be `"bar"` *after* shlex splitting, because we
+[^why_quote]: The value needs to be `"bar"` *after* shlex splitting, because we
     it needs to be a JSON string value.
 
 [json output]: https://doc.rust-lang.org/nightly/rustdoc/unstable-features.html#json-output

From 1d2457b04898edb898850e87f4fe57e5598dbdf6 Mon Sep 17 00:00:00 2001
From: Alona Enraght-Moony <code@alona.page>
Date: Fri, 5 Sep 2025 20:39:14 +0100
Subject: [PATCH 0555/1889] Consistent punctuation

---
 .../src/rustdoc-internals/rustdoc-json-test-suite.md      | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-json-test-suite.md b/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-json-test-suite.md
index 2d48878b05ad9..3044136c146c1 100644
--- a/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-json-test-suite.md
+++ b/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-json-test-suite.md
@@ -30,16 +30,16 @@ It uses [JSONPath] as a query language, which takes a path, and returns a *list*
 
 ### Directives
 
-- `//@ has <path>`:: Checks `<path>` exists, i.e. matches at least 1 value.
-- `//@ !has <path>`:: Checks `<path>` doesn't exist, i.e. matches 0 values.
+- `//@ has <path>`: Checks `<path>` exists, i.e. matches at least 1 value.
+- `//@ !has <path>`: Checks `<path>` doesn't exist, i.e. matches 0 values.
 - `//@ has <path> <value>`: Check `<path>` exists, and at least 1 of the matches is equal to the given `<value>` 
 - `//@ !has <path> <value>`: Checks `<path>` exists, but none of the matches equal the given `<value>`.
 - `//@ is <path> <value>`: Check `<path>` matches exactly one value, and it's equal to the given `<value>`.
 - `//@ is <path> <value> <value>...`: Check that `<path>` matches to exactly every given `<value>`. 
    Ordering doesn't matter here.
 - `//@ !is <path> <value>`: Check `<path>` matches exactly one value, and that value is not equal to the given `<value>`.
-- `//@ count <path> <number>` Check that `<path>` matches to `<number>` of values.
-- `//@ set <name> = <path>`, Check that `<path>` matches exactly one value, and store that value to the variable called `<name>`
+- `//@ count <path> <number>`: Check that `<path>` matches to `<number>` of values.
+- `//@ set <name> = <path>`: Check that `<path>` matches exactly one value, and store that value to the variable called `<name>`.
 
 These are defined in [`directive.rs`].
 

From d7f27bf9e03c8fbeb37104be2d99ba5b2397e51e Mon Sep 17 00:00:00 2001
From: Alona Enraght-Moony <code@alona.page>
Date: Fri, 5 Sep 2025 20:41:43 +0100
Subject: [PATCH 0556/1889] Better link

---
 .../src/rustdoc-internals/rustdoc-json-test-suite.md            | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-json-test-suite.md b/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-json-test-suite.md
index 3044136c146c1..10e9452eda3f1 100644
--- a/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-json-test-suite.md
+++ b/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-json-test-suite.md
@@ -1,7 +1,7 @@
 # The `rustdoc-json` test suite
 
 This page is specifically about the test suite named `rustdoc-json`, which tests rustdoc's [json output].
-For other test suites used for testing rustdoc, see [Rustdoc tests](../rustdoc.md#tests).
+For other test suites used for testing rustdoc, see [§Rustdoc test suites](../tests/compiletest.md#rustdoc-test-suites).
 
 Tests are run with compiletest, and have access to the usual set of [directives](../tests/directives.md).
 Frequenly used directives here are:

From d4cb0b475935d29c18f94676c2d0e9793e95b8e3 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Fri, 5 Sep 2025 22:32:11 +0200
Subject: [PATCH 0557/1889] clean-up a bit

- if-else reordering: having one fewer nesting levels makes it easier to
understand imo
---
 .../src/transmute/transmute_ptr_to_ref.rs     | 20 ++++++++-----------
 tests/ui/transmute_ptr_to_ref.fixed           | 10 +++++-----
 tests/ui/transmute_ptr_to_ref.rs              | 10 +++++-----
 tests/ui/transmute_ptr_to_ref.stderr          |  4 ++--
 4 files changed, 20 insertions(+), 24 deletions(-)

diff --git a/clippy_lints/src/transmute/transmute_ptr_to_ref.rs b/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
index e58212fae15cf..44fa2121341dd 100644
--- a/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
+++ b/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
@@ -28,10 +28,9 @@ pub(super) fn check<'tcx>(
                 format!("transmute from a pointer type (`{from_ty}`) to a reference type (`{to_ty}`)"),
                 |diag| {
                     let arg = sugg::Sugg::hir(cx, arg, "..");
-                    let (deref, cast) = if *mutbl == Mutability::Mut {
-                        ("&mut *", "*mut")
-                    } else {
-                        ("&*", "*const")
+                    let (deref, cast) = match mutbl {
+                        Mutability::Mut => ("&mut *", "*mut"),
+                        Mutability::Not => ("&*", "*const"),
                     };
                     let mut app = Applicability::MachineApplicable;
 
@@ -45,15 +44,12 @@ pub(super) fn check<'tcx>(
                             sugg::make_unop(deref, arg.as_ty(format!("{cast} {ty_snip}"))).to_string()
                         }
                     } else if *from_ptr_ty == *to_ref_ty {
-                        if from_ptr_ty.has_erased_regions() {
-                            if msrv.meets(cx, msrvs::POINTER_CAST) {
-                                format!("{deref}{}.cast::<{to_ref_ty}>()", arg.maybe_paren())
-                            } else {
-                                sugg::make_unop(deref, arg.as_ty(format!("{cast} () as {cast} {to_ref_ty}")))
-                                    .to_string()
-                            }
-                        } else {
+                        if !from_ptr_ty.has_erased_regions() {
                             sugg::make_unop(deref, arg).to_string()
+                        } else if msrv.meets(cx, msrvs::POINTER_CAST) {
+                            format!("{deref}{}.cast::<{to_ref_ty}>()", arg.maybe_paren())
+                        } else {
+                            sugg::make_unop(deref, arg.as_ty(format!("{cast} () as {cast} {to_ref_ty}"))).to_string()
                         }
                     } else {
                         sugg::make_unop(deref, arg.as_ty(format!("{cast} {to_ref_ty}"))).to_string()
diff --git a/tests/ui/transmute_ptr_to_ref.fixed b/tests/ui/transmute_ptr_to_ref.fixed
index 61e3ac2fe88e3..68839fd04c56b 100644
--- a/tests/ui/transmute_ptr_to_ref.fixed
+++ b/tests/ui/transmute_ptr_to_ref.fixed
@@ -5,7 +5,7 @@
     clippy::missing_transmute_annotations
 )]
 
-unsafe fn _ptr_to_ref<T, U>(p: *const T, m: *mut T, o: *const U, om: *mut U) {
+fn ptr_to_ref<T, U>(p: *const T, m: *mut T, o: *const U, om: *mut U) {
     unsafe {
         let _: &T = &*p;
         //~^ transmute_ptr_to_ref
@@ -37,7 +37,7 @@ unsafe fn _ptr_to_ref<T, U>(p: *const T, m: *mut T, o: *const U, om: *mut U) {
     }
 }
 
-fn _issue1231() {
+fn issue1231() {
     struct Foo<'a, T> {
         bar: &'a T,
     }
@@ -55,7 +55,7 @@ fn _issue1231() {
     //~^ transmute_ptr_to_ref
 }
 
-unsafe fn _issue8924<'a, 'b, 'c>(x: *const &'a u32, y: *const &'b u32) -> &'c &'b u32 {
+fn issue8924<'a, 'b, 'c>(x: *const &'a u32, y: *const &'b u32) -> &'c &'b u32 {
     unsafe {
         match 0 {
             0 => &*x.cast::<&u32>(),
@@ -71,7 +71,7 @@ unsafe fn _issue8924<'a, 'b, 'c>(x: *const &'a u32, y: *const &'b u32) -> &'c &'
 }
 
 #[clippy::msrv = "1.38"]
-unsafe fn _meets_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
+fn meets_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
     unsafe {
         let a = 0u32;
         let a = &a as *const u32;
@@ -89,7 +89,7 @@ unsafe fn _meets_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
 }
 
 #[clippy::msrv = "1.37"]
-unsafe fn _under_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
+fn under_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
     unsafe {
         let a = 0u32;
         let a = &a as *const u32;
diff --git a/tests/ui/transmute_ptr_to_ref.rs b/tests/ui/transmute_ptr_to_ref.rs
index 48e2f527b554c..b41b7cd217947 100644
--- a/tests/ui/transmute_ptr_to_ref.rs
+++ b/tests/ui/transmute_ptr_to_ref.rs
@@ -5,7 +5,7 @@
     clippy::missing_transmute_annotations
 )]
 
-unsafe fn _ptr_to_ref<T, U>(p: *const T, m: *mut T, o: *const U, om: *mut U) {
+fn ptr_to_ref<T, U>(p: *const T, m: *mut T, o: *const U, om: *mut U) {
     unsafe {
         let _: &T = std::mem::transmute(p);
         //~^ transmute_ptr_to_ref
@@ -37,7 +37,7 @@ unsafe fn _ptr_to_ref<T, U>(p: *const T, m: *mut T, o: *const U, om: *mut U) {
     }
 }
 
-fn _issue1231() {
+fn issue1231() {
     struct Foo<'a, T> {
         bar: &'a T,
     }
@@ -55,7 +55,7 @@ fn _issue1231() {
     //~^ transmute_ptr_to_ref
 }
 
-unsafe fn _issue8924<'a, 'b, 'c>(x: *const &'a u32, y: *const &'b u32) -> &'c &'b u32 {
+fn issue8924<'a, 'b, 'c>(x: *const &'a u32, y: *const &'b u32) -> &'c &'b u32 {
     unsafe {
         match 0 {
             0 => std::mem::transmute(x),
@@ -71,7 +71,7 @@ unsafe fn _issue8924<'a, 'b, 'c>(x: *const &'a u32, y: *const &'b u32) -> &'c &'
 }
 
 #[clippy::msrv = "1.38"]
-unsafe fn _meets_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
+fn meets_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
     unsafe {
         let a = 0u32;
         let a = &a as *const u32;
@@ -89,7 +89,7 @@ unsafe fn _meets_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
 }
 
 #[clippy::msrv = "1.37"]
-unsafe fn _under_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
+fn under_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
     unsafe {
         let a = 0u32;
         let a = &a as *const u32;
diff --git a/tests/ui/transmute_ptr_to_ref.stderr b/tests/ui/transmute_ptr_to_ref.stderr
index 7685c345c8619..520f804d264a2 100644
--- a/tests/ui/transmute_ptr_to_ref.stderr
+++ b/tests/ui/transmute_ptr_to_ref.stderr
@@ -43,13 +43,13 @@ error: transmute from a pointer type (`*mut U`) to a reference type (`&T`)
 LL |         let _: &T = std::mem::transmute(om);
    |                     ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(om as *const T)`
 
-error: transmute from a pointer type (`*const i32`) to a reference type (`&_issue1231::Foo<'_, u8>`)
+error: transmute from a pointer type (`*const i32`) to a reference type (`&issue1231::Foo<'_, u8>`)
   --> tests/ui/transmute_ptr_to_ref.rs:46:32
    |
 LL |     let _: &Foo<u8> = unsafe { std::mem::transmute::<_, &Foo<_>>(raw) };
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*raw.cast::<Foo<_>>()`
 
-error: transmute from a pointer type (`*const i32`) to a reference type (`&_issue1231::Foo<'_, &u8>`)
+error: transmute from a pointer type (`*const i32`) to a reference type (`&issue1231::Foo<'_, &u8>`)
   --> tests/ui/transmute_ptr_to_ref.rs:49:33
    |
 LL |     let _: &Foo<&u8> = unsafe { std::mem::transmute::<_, &Foo<&_>>(raw) };

From d224d3a8fa3c5299892d892664bc128fd3fe6571 Mon Sep 17 00:00:00 2001
From: Urgau <urgau@numericable.fr>
Date: Wed, 3 Sep 2025 18:52:07 +0200
Subject: [PATCH 0558/1889] Disallow shebang in `--cfg` and `--check-cfg`
 arguments

---
 compiler/rustc_parse/src/lexer/mod.rs         | 35 ++++++++++++++++---
 compiler/rustc_parse/src/lib.rs               | 29 +++++++--------
 .../{cfg.stderr => cfg-frontmatter.stderr}    |  0
 .../multiline-args-value/cfg-shebang.stderr   |  3 ++
 ...fg.stderr => check-cfg-frontmatter.stderr} |  0
 .../check-cfg-shebang.stderr                  |  6 ++++
 tests/run-make/multiline-args-value/rmake.rs  | 31 ++++++++++++----
 7 files changed, 75 insertions(+), 29 deletions(-)
 rename tests/run-make/multiline-args-value/{cfg.stderr => cfg-frontmatter.stderr} (100%)
 create mode 100644 tests/run-make/multiline-args-value/cfg-shebang.stderr
 rename tests/run-make/multiline-args-value/{check-cfg.stderr => check-cfg-frontmatter.stderr} (100%)
 create mode 100644 tests/run-make/multiline-args-value/check-cfg-shebang.stderr

diff --git a/compiler/rustc_parse/src/lexer/mod.rs b/compiler/rustc_parse/src/lexer/mod.rs
index e3bd6a9a3270f..f5f081efc4956 100644
--- a/compiler/rustc_parse/src/lexer/mod.rs
+++ b/compiler/rustc_parse/src/lexer/mod.rs
@@ -44,19 +44,44 @@ pub(crate) struct UnmatchedDelim {
     pub candidate_span: Option<Span>,
 }
 
+/// Which tokens should be stripped before lexing the tokens.
+pub(crate) enum StripTokens {
+    /// Strip both shebang and frontmatter.
+    ShebangAndFrontmatter,
+    /// Strip the shebang but not frontmatter.
+    ///
+    /// That means that char sequences looking like frontmatter are simply
+    /// interpreted as regular Rust lexemes.
+    Shebang,
+    /// Strip nothing.
+    ///
+    /// In other words, char sequences looking like a shebang or frontmatter
+    /// are simply interpreted as regular Rust lexemes.
+    Nothing,
+}
+
 pub(crate) fn lex_token_trees<'psess, 'src>(
     psess: &'psess ParseSess,
     mut src: &'src str,
     mut start_pos: BytePos,
     override_span: Option<Span>,
-    frontmatter_allowed: FrontmatterAllowed,
+    strip_tokens: StripTokens,
 ) -> Result<TokenStream, Vec<Diag<'psess>>> {
-    // Skip `#!`, if present.
-    if let Some(shebang_len) = rustc_lexer::strip_shebang(src) {
-        src = &src[shebang_len..];
-        start_pos = start_pos + BytePos::from_usize(shebang_len);
+    match strip_tokens {
+        StripTokens::Shebang | StripTokens::ShebangAndFrontmatter => {
+            if let Some(shebang_len) = rustc_lexer::strip_shebang(src) {
+                src = &src[shebang_len..];
+                start_pos = start_pos + BytePos::from_usize(shebang_len);
+            }
+        }
+        StripTokens::Nothing => {}
     }
 
+    let frontmatter_allowed = match strip_tokens {
+        StripTokens::ShebangAndFrontmatter => FrontmatterAllowed::Yes,
+        StripTokens::Shebang | StripTokens::Nothing => FrontmatterAllowed::No,
+    };
+
     let cursor = Cursor::new(src, frontmatter_allowed);
     let mut lexer = Lexer {
         psess,
diff --git a/compiler/rustc_parse/src/lib.rs b/compiler/rustc_parse/src/lib.rs
index b790966acfd92..d8792d7af4c36 100644
--- a/compiler/rustc_parse/src/lib.rs
+++ b/compiler/rustc_parse/src/lib.rs
@@ -21,7 +21,6 @@ use rustc_ast::tokenstream::{DelimSpan, TokenStream};
 use rustc_ast::{AttrItem, Attribute, MetaItemInner, token};
 use rustc_ast_pretty::pprust;
 use rustc_errors::{Diag, EmissionGuarantee, FatalError, PResult, pluralize};
-use rustc_lexer::FrontmatterAllowed;
 use rustc_session::parse::ParseSess;
 use rustc_span::source_map::SourceMap;
 use rustc_span::{FileName, SourceFile, Span};
@@ -34,6 +33,8 @@ pub mod parser;
 use parser::Parser;
 use rustc_ast::token::Delimiter;
 
+use crate::lexer::StripTokens;
+
 pub mod lexer;
 
 mod errors;
@@ -62,10 +63,10 @@ pub fn new_parser_from_source_str(
     source: String,
 ) -> Result<Parser<'_>, Vec<Diag<'_>>> {
     let source_file = psess.source_map().new_source_file(name, source);
-    new_parser_from_source_file(psess, source_file, FrontmatterAllowed::Yes)
+    new_parser_from_source_file(psess, source_file, StripTokens::ShebangAndFrontmatter)
 }
 
-/// Creates a new parser from a simple (no frontmatter) source string.
+/// Creates a new parser from a simple (no shebang, no frontmatter) source string.
 ///
 /// On failure, the errors must be consumed via `unwrap_or_emit_fatal`, `emit`, `cancel`,
 /// etc., otherwise a panic will occur when they are dropped.
@@ -75,7 +76,7 @@ pub fn new_parser_from_simple_source_str(
     source: String,
 ) -> Result<Parser<'_>, Vec<Diag<'_>>> {
     let source_file = psess.source_map().new_source_file(name, source);
-    new_parser_from_source_file(psess, source_file, FrontmatterAllowed::No)
+    new_parser_from_source_file(psess, source_file, StripTokens::Nothing)
 }
 
 /// Creates a new parser from a filename. On failure, the errors must be consumed via
@@ -109,7 +110,7 @@ pub fn new_parser_from_file<'a>(
         }
         err.emit();
     });
-    new_parser_from_source_file(psess, source_file, FrontmatterAllowed::Yes)
+    new_parser_from_source_file(psess, source_file, StripTokens::ShebangAndFrontmatter)
 }
 
 pub fn utf8_error<E: EmissionGuarantee>(
@@ -160,10 +161,10 @@ pub fn utf8_error<E: EmissionGuarantee>(
 fn new_parser_from_source_file(
     psess: &ParseSess,
     source_file: Arc<SourceFile>,
-    frontmatter_allowed: FrontmatterAllowed,
+    strip_tokens: StripTokens,
 ) -> Result<Parser<'_>, Vec<Diag<'_>>> {
     let end_pos = source_file.end_position();
-    let stream = source_file_to_stream(psess, source_file, None, frontmatter_allowed)?;
+    let stream = source_file_to_stream(psess, source_file, None, strip_tokens)?;
     let mut parser = Parser::new(psess, stream, None);
     if parser.token == token::Eof {
         parser.token.span = Span::new(end_pos, end_pos, parser.token.span.ctxt(), None);
@@ -179,8 +180,8 @@ pub fn source_str_to_stream(
 ) -> Result<TokenStream, Vec<Diag<'_>>> {
     let source_file = psess.source_map().new_source_file(name, source);
     // used mainly for `proc_macro` and the likes, not for our parsing purposes, so don't parse
-    // frontmatters as frontmatters.
-    source_file_to_stream(psess, source_file, override_span, FrontmatterAllowed::No)
+    // frontmatters as frontmatters, but for compatibility reason still strip the shebang
+    source_file_to_stream(psess, source_file, override_span, StripTokens::Shebang)
 }
 
 /// Given a source file, produces a sequence of token trees. Returns any buffered errors from
@@ -189,7 +190,7 @@ fn source_file_to_stream<'psess>(
     psess: &'psess ParseSess,
     source_file: Arc<SourceFile>,
     override_span: Option<Span>,
-    frontmatter_allowed: FrontmatterAllowed,
+    strip_tokens: StripTokens,
 ) -> Result<TokenStream, Vec<Diag<'psess>>> {
     let src = source_file.src.as_ref().unwrap_or_else(|| {
         psess.dcx().bug(format!(
@@ -198,13 +199,7 @@ fn source_file_to_stream<'psess>(
         ));
     });
 
-    lexer::lex_token_trees(
-        psess,
-        src.as_str(),
-        source_file.start_pos,
-        override_span,
-        frontmatter_allowed,
-    )
+    lexer::lex_token_trees(psess, src.as_str(), source_file.start_pos, override_span, strip_tokens)
 }
 
 /// Runs the given subparser `f` on the tokens of the given `attr`'s item.
diff --git a/tests/run-make/multiline-args-value/cfg.stderr b/tests/run-make/multiline-args-value/cfg-frontmatter.stderr
similarity index 100%
rename from tests/run-make/multiline-args-value/cfg.stderr
rename to tests/run-make/multiline-args-value/cfg-frontmatter.stderr
diff --git a/tests/run-make/multiline-args-value/cfg-shebang.stderr b/tests/run-make/multiline-args-value/cfg-shebang.stderr
new file mode 100644
index 0000000000000..09baf3b51239c
--- /dev/null
+++ b/tests/run-make/multiline-args-value/cfg-shebang.stderr
@@ -0,0 +1,3 @@
+error: invalid `--cfg` argument: `#!/usr/bin/shebang
+       key` (expected `key` or `key="value"`)
+
diff --git a/tests/run-make/multiline-args-value/check-cfg.stderr b/tests/run-make/multiline-args-value/check-cfg-frontmatter.stderr
similarity index 100%
rename from tests/run-make/multiline-args-value/check-cfg.stderr
rename to tests/run-make/multiline-args-value/check-cfg-frontmatter.stderr
diff --git a/tests/run-make/multiline-args-value/check-cfg-shebang.stderr b/tests/run-make/multiline-args-value/check-cfg-shebang.stderr
new file mode 100644
index 0000000000000..5bf18dc2b14c4
--- /dev/null
+++ b/tests/run-make/multiline-args-value/check-cfg-shebang.stderr
@@ -0,0 +1,6 @@
+error: invalid `--check-cfg` argument: `#!/usr/bin/shebang
+       cfg(key)`
+  |
+  = note: expected `cfg(name, values("value1", "value2", ... "valueN"))`
+  = note: visit <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more details
+
diff --git a/tests/run-make/multiline-args-value/rmake.rs b/tests/run-make/multiline-args-value/rmake.rs
index 825cbd158c0a3..3964cbbc1e605 100644
--- a/tests/run-make/multiline-args-value/rmake.rs
+++ b/tests/run-make/multiline-args-value/rmake.rs
@@ -1,15 +1,14 @@
 use run_make_support::{cwd, diff, rustc};
 
-fn test_and_compare(flag: &str, val: &str) {
+fn test_and_compare(test_name: &str, flag: &str, val: &str) {
     let mut cmd = rustc();
 
-    let output =
-        cmd.input("").arg("--crate-type=lib").arg(&format!("--{flag}")).arg(val).run_fail();
+    let output = cmd.input("").arg("--crate-type=lib").arg(flag).arg(val).run_fail();
 
     assert_eq!(output.stdout_utf8(), "");
     diff()
-        .expected_file(format!("{flag}.stderr"))
-        .actual_text("output", output.stderr_utf8())
+        .expected_file(format!("{test_name}.stderr"))
+        .actual_text("stderr", output.stderr_utf8())
         .run();
 }
 
@@ -17,7 +16,8 @@ fn main() {
     // Verify that frontmatter isn't allowed in `--cfg` arguments.
     // https://github.com/rust-lang/rust/issues/146130
     test_and_compare(
-        "cfg",
+        "cfg-frontmatter",
+        "--cfg",
         r#"---
 ---
 key"#,
@@ -26,9 +26,26 @@ key"#,
     // Verify that frontmatter isn't allowed in `--check-cfg` arguments.
     // https://github.com/rust-lang/rust/issues/146130
     test_and_compare(
-        "check-cfg",
+        "check-cfg-frontmatter",
+        "--check-cfg",
         r#"---
 ---
+cfg(key)"#,
+    );
+
+    // Verify that shebang isn't allowed in `--cfg` arguments.
+    test_and_compare(
+        "cfg-shebang",
+        "--cfg",
+        r#"#!/usr/bin/shebang
+key"#,
+    );
+
+    // Verify that shebang isn't allowed in `--check-cfg` arguments.
+    test_and_compare(
+        "check-cfg-shebang",
+        "--check-cfg",
+        r#"#!/usr/bin/shebang
 cfg(key)"#,
     );
 }

From 874dbd5d579a5aa9535c322b56b0214712bc39f1 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Fri, 5 Sep 2025 17:01:07 -0700
Subject: [PATCH 0559/1889] std: Update `wasi` crate dependency

The recent work on the WASIp2 target being integrated into the standard
library ended up causing a bug in nightly on the target. This has now
been fixed in the `wasi` crate so this commit pulls in the updated
version to ensure bindings work correctly.
---
 library/Cargo.lock     | 6 +++---
 library/std/Cargo.toml | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/library/Cargo.lock b/library/Cargo.lock
index c16bb3eafbdac..e601137e00573 100644
--- a/library/Cargo.lock
+++ b/library/Cargo.lock
@@ -328,7 +328,7 @@ dependencies = [
  "std_detect",
  "unwind",
  "wasi 0.11.1+wasi-snapshot-preview1",
- "wasi 0.14.3+wasi-0.2.4",
+ "wasi 0.14.4+wasi-0.2.4",
  "windows-targets 0.0.0",
 ]
 
@@ -402,9 +402,9 @@ dependencies = [
 
 [[package]]
 name = "wasi"
-version = "0.14.3+wasi-0.2.4"
+version = "0.14.4+wasi-0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a51ae83037bdd272a9e28ce236db8c07016dd0d50c27038b3f407533c030c95"
+checksum = "88a5f4a424faf49c3c2c344f166f0662341d470ea185e939657aaff130f0ec4a"
 dependencies = [
  "rustc-std-workspace-alloc",
  "rustc-std-workspace-core",
diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
index 8b78fe53a3978..d28a7f0b46022 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -81,7 +81,7 @@ wasi = { version = "0.11.0", features = [
 ], default-features = false }
 
 [target.'cfg(all(target_os = "wasi", target_env = "p2"))'.dependencies]
-wasip2 = { version = '0.14.3', features = [
+wasip2 = { version = '0.14.4', features = [
     'rustc-dep-of-std',
 ], default-features = false, package = 'wasi' }
 

From ab91a63d403b0105cacd72809cd292a72984ed99 Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Tue, 26 Aug 2025 21:08:03 -0400
Subject: [PATCH 0560/1889] Ignore intrinsic calls in cross-crate-inlining cost
 model

---
 .../rustc_mir_transform/src/cross_crate_inline.rs     | 11 ++++++++++-
 tests/assembly-llvm/breakpoint.rs                     |  1 +
 tests/assembly-llvm/simd/reduce-fadd-unordered.rs     |  1 +
 .../cross-crate-inlining/auxiliary/leaf.rs            |  5 +++++
 .../cross-crate-inlining/leaf-inlining.rs             |  7 +++++++
 tests/codegen-llvm/default-visibility.rs              |  1 +
 6 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_mir_transform/src/cross_crate_inline.rs b/compiler/rustc_mir_transform/src/cross_crate_inline.rs
index b186c2bd7758f..df98c07f54958 100644
--- a/compiler/rustc_mir_transform/src/cross_crate_inline.rs
+++ b/compiler/rustc_mir_transform/src/cross_crate_inline.rs
@@ -135,7 +135,16 @@ impl<'tcx> Visitor<'tcx> for CostChecker<'_, 'tcx> {
                     }
                 }
             }
-            TerminatorKind::Call { unwind, .. } => {
+            TerminatorKind::Call { ref func, unwind, .. } => {
+                // We track calls because they make our function not a leaf (and in theory, the
+                // number of calls indicates how likely this function is to perturb other CGUs).
+                // But intrinsics don't have a body that gets assigned to a CGU, so they are
+                // ignored.
+                if let Some((fn_def_id, _)) = func.const_fn_def()
+                    && self.tcx.has_attr(fn_def_id, sym::rustc_intrinsic)
+                {
+                    return;
+                }
                 self.calls += 1;
                 if let UnwindAction::Cleanup(_) = unwind {
                     self.landing_pads += 1;
diff --git a/tests/assembly-llvm/breakpoint.rs b/tests/assembly-llvm/breakpoint.rs
index e0cc2d1eebb74..d119b68e899ba 100644
--- a/tests/assembly-llvm/breakpoint.rs
+++ b/tests/assembly-llvm/breakpoint.rs
@@ -9,6 +9,7 @@
 // CHECK-LABEL: use_bp
 // aarch64: brk #0xf000
 // x86_64: int3
+#[inline(never)]
 pub fn use_bp() {
     core::arch::breakpoint();
 }
diff --git a/tests/assembly-llvm/simd/reduce-fadd-unordered.rs b/tests/assembly-llvm/simd/reduce-fadd-unordered.rs
index e872826f6ef79..fdd03639da0eb 100644
--- a/tests/assembly-llvm/simd/reduce-fadd-unordered.rs
+++ b/tests/assembly-llvm/simd/reduce-fadd-unordered.rs
@@ -16,6 +16,7 @@ use std::simd::*;
 // It would emit about an extra fadd, depending on the architecture.
 
 // CHECK-LABEL: reduce_fadd_negative_zero
+#[inline(never)]
 pub unsafe fn reduce_fadd_negative_zero(v: f32x4) -> f32 {
     // x86_64: addps
     // x86_64-NEXT: movshdup
diff --git a/tests/codegen-llvm/cross-crate-inlining/auxiliary/leaf.rs b/tests/codegen-llvm/cross-crate-inlining/auxiliary/leaf.rs
index d059a3d0a73b8..7b5679c3f4def 100644
--- a/tests/codegen-llvm/cross-crate-inlining/auxiliary/leaf.rs
+++ b/tests/codegen-llvm/cross-crate-inlining/auxiliary/leaf.rs
@@ -18,3 +18,8 @@ pub fn stem_fn() -> String {
 fn inner() -> String {
     String::from("test")
 }
+
+// This function's optimized MIR contains a call, but it is to an intrinsic.
+pub fn leaf_with_intrinsic(a: &[u64; 2], b: &[u64; 2]) -> bool {
+    a == b
+}
diff --git a/tests/codegen-llvm/cross-crate-inlining/leaf-inlining.rs b/tests/codegen-llvm/cross-crate-inlining/leaf-inlining.rs
index 37132312ca94c..5e7912791ad60 100644
--- a/tests/codegen-llvm/cross-crate-inlining/leaf-inlining.rs
+++ b/tests/codegen-llvm/cross-crate-inlining/leaf-inlining.rs
@@ -18,3 +18,10 @@ pub fn stem_outer() -> String {
     // CHECK: call {{.*}}stem_fn
     leaf::stem_fn()
 }
+
+// Check that we inline functions that call intrinsics
+#[no_mangle]
+pub fn leaf_with_intrinsic_outer(a: &[u64; 2], b: &[u64; 2]) -> bool {
+    // CHECK-NOT: call {{.*}}leaf_with_intrinsic
+    leaf::leaf_with_intrinsic(a, b)
+}
diff --git a/tests/codegen-llvm/default-visibility.rs b/tests/codegen-llvm/default-visibility.rs
index 88ff9fee25447..28238e5ef1299 100644
--- a/tests/codegen-llvm/default-visibility.rs
+++ b/tests/codegen-llvm/default-visibility.rs
@@ -32,6 +32,7 @@ pub static tested_symbol: [u8; 6] = *b"foobar";
 // INTERPOSABLE: @{{.*}}default_visibility{{.*}}tested_symbol{{.*}} = constant
 // DEFAULT:      @{{.*}}default_visibility{{.*}}tested_symbol{{.*}} = constant
 
+#[inline(never)]
 pub fn do_memcmp(left: &[u8], right: &[u8]) -> i32 {
     left.cmp(right) as i32
 }

From 31b39150c79e77cbde2d0567120977a014c224f8 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 3 Sep 2025 07:47:32 -0500
Subject: [PATCH 0561/1889] Some hygiene doc improvements

---
 compiler/rustc_span/src/hygiene.rs | 30 ++++++++++++++++++++----------
 compiler/rustc_span/src/lib.rs     |  4 ++--
 2 files changed, 22 insertions(+), 12 deletions(-)

diff --git a/compiler/rustc_span/src/hygiene.rs b/compiler/rustc_span/src/hygiene.rs
index 19494ffc37eaf..633cbc3a4ae2a 100644
--- a/compiler/rustc_span/src/hygiene.rs
+++ b/compiler/rustc_span/src/hygiene.rs
@@ -46,6 +46,8 @@ use crate::symbol::{Symbol, kw, sym};
 use crate::{DUMMY_SP, HashStableContext, Span, SpanDecoder, SpanEncoder, with_session_globals};
 
 /// A `SyntaxContext` represents a chain of pairs `(ExpnId, Transparency)` named "marks".
+///
+/// See <https://rustc-dev-guide.rust-lang.org/macro-expansion.html> for more explanation.
 #[derive(Clone, Copy, PartialEq, Eq, Hash)]
 pub struct SyntaxContext(u32);
 
@@ -61,7 +63,10 @@ pub type SyntaxContextKey = (SyntaxContext, ExpnId, Transparency);
 
 #[derive(Clone, Copy, Debug)]
 struct SyntaxContextData {
+    /// The last macro expansion in the chain.
+    /// (Here we say the most deeply nested macro expansion is the "outermost" expansion.)
     outer_expn: ExpnId,
+    /// Transparency of the last macro expansion
     outer_transparency: Transparency,
     parent: SyntaxContext,
     /// This context, but with all transparent and semi-opaque expansions filtered away.
@@ -450,11 +455,13 @@ impl HygieneData {
         self.syntax_context_data[ctxt.0 as usize].opaque_and_semiopaque
     }
 
+    /// See [`SyntaxContextData::outer_expn`]
     #[inline]
     fn outer_expn(&self, ctxt: SyntaxContext) -> ExpnId {
         self.syntax_context_data[ctxt.0 as usize].outer_expn
     }
 
+    /// The last macro expansion and its Transparency
     #[inline]
     fn outer_mark(&self, ctxt: SyntaxContext) -> (ExpnId, Transparency) {
         let data = &self.syntax_context_data[ctxt.0 as usize];
@@ -900,6 +907,7 @@ impl SyntaxContext {
         HygieneData::with(|data| data.normalize_to_macro_rules(self))
     }
 
+    /// See [`SyntaxContextData::outer_expn`]
     #[inline]
     pub fn outer_expn(self) -> ExpnId {
         HygieneData::with(|data| data.outer_expn(self))
@@ -912,6 +920,7 @@ impl SyntaxContext {
         HygieneData::with(|data| data.expn_data(data.outer_expn(self)).clone())
     }
 
+    /// See [`HygieneData::outer_mark`]
     #[inline]
     fn outer_mark(self) -> (ExpnId, Transparency) {
         HygieneData::with(|data| data.outer_mark(self))
@@ -982,19 +991,20 @@ impl Span {
 #[derive(Clone, Debug, Encodable, Decodable, HashStable_Generic)]
 pub struct ExpnData {
     // --- The part unique to each expansion.
-    /// The kind of this expansion - macro or compiler desugaring.
     pub kind: ExpnKind,
-    /// The expansion that produced this expansion.
+    /// The expansion that contains the definition of the macro for this expansion.
     pub parent: ExpnId,
-    /// The location of the actual macro invocation or syntax sugar , e.g.
-    /// `let x = foo!();` or `if let Some(y) = x {}`
+    /// The span of the macro call which produced this expansion.
+    ///
+    /// This span will typically have a different `ExpnData` and `call_site`.
+    /// This recursively traces back through any macro calls which expanded into further
+    /// macro calls, until the "source call-site" is reached at the root SyntaxContext.
+    /// For example, if `food!()` expands to `fruit!()` which then expands to `grape`,
+    /// then the call-site of `grape` is `fruit!()` and the call-site of `fruit!()`
+    /// is `food!()`.
     ///
-    /// This may recursively refer to other macro invocations, e.g., if
-    /// `foo!()` invoked `bar!()` internally, and there was an
-    /// expression inside `bar!`; the call_site of the expression in
-    /// the expansion would point to the `bar!` invocation; that
-    /// call_site span would have its own ExpnData, with the call_site
-    /// pointing to the `foo!` invocation.
+    /// For a desugaring expansion, this is the span of the expression or node that was
+    /// desugared.
     pub call_site: Span,
     /// Used to force two `ExpnData`s to have different `Fingerprint`s.
     /// Due to macro expansion, it's possible to end up with two `ExpnId`s
diff --git a/compiler/rustc_span/src/lib.rs b/compiler/rustc_span/src/lib.rs
index ae6755f076424..e95b743b1ce29 100644
--- a/compiler/rustc_span/src/lib.rs
+++ b/compiler/rustc_span/src/lib.rs
@@ -710,8 +710,8 @@ impl Span {
         if !ctxt.is_root() { ctxt.outer_expn_data().call_site.source_callsite() } else { self }
     }
 
-    /// The `Span` for the tokens in the previous macro expansion from which `self` was generated,
-    /// if any.
+    /// Returns the call-site span of the last macro expansion which produced this `Span`.
+    /// (see [`ExpnData::call_site`]). Returns `None` if this is not an expansion.
     pub fn parent_callsite(self) -> Option<Span> {
         let ctxt = self.ctxt();
         (!ctxt.is_root()).then(|| ctxt.outer_expn_data().call_site)

From 00fcb14e4e6e4fb28fde6a286fd9ac30a2d457c7 Mon Sep 17 00:00:00 2001
From: Nathaniel McCallum <nathaniel@mccallum.life>
Date: Sun, 31 Aug 2025 22:26:10 -0400
Subject: [PATCH 0562/1889] clean up some old const trait impl syntax

---
 library/core/src/borrow.rs                    |  6 ++--
 library/core/src/clone.rs                     |  3 +-
 library/core/src/cmp.rs                       |  3 +-
 library/core/src/cmp/bytewise.rs              |  2 +-
 library/core/src/convert/mod.rs               | 18 ++++------
 library/core/src/default.rs                   |  3 +-
 library/core/src/intrinsics/fallback.rs       |  9 ++---
 library/core/src/marker.rs                    |  3 +-
 library/core/src/ops/arith.rs                 | 33 +++++++------------
 library/core/src/ops/bit.rs                   | 33 +++++++------------
 library/core/src/ops/deref.rs                 |  6 ++--
 library/core/src/ops/drop.rs                  |  3 +-
 library/core/src/ops/function.rs              |  9 ++---
 library/core/src/ops/index.rs                 |  6 ++--
 library/core/src/ops/try_trait.rs             |  9 ++---
 library/core/src/option.rs                    |  4 +--
 library/core/src/pat.rs                       |  3 +-
 library/core/src/slice/cmp.rs                 |  3 +-
 library/core/src/slice/index.rs               |  2 +-
 library/core/src/str/traits.rs                |  3 +-
 .../const-traits/constructor-const-fn.rs      |  2 +-
 .../const-traits/reservation-impl-ice.rs      |  2 +-
 .../const-traits/reservation-impl-ice.stderr  |  4 +--
 23 files changed, 59 insertions(+), 110 deletions(-)

diff --git a/library/core/src/borrow.rs b/library/core/src/borrow.rs
index 6ce7e4656b99e..78ba69fec1422 100644
--- a/library/core/src/borrow.rs
+++ b/library/core/src/borrow.rs
@@ -154,9 +154,8 @@
 /// [`String`]: ../../std/string/struct.String.html
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_diagnostic_item = "Borrow"]
-#[const_trait]
 #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
-pub trait Borrow<Borrowed: ?Sized> {
+pub const trait Borrow<Borrowed: ?Sized> {
     /// Immutably borrows from an owned value.
     ///
     /// # Examples
@@ -187,9 +186,8 @@ pub trait Borrow<Borrowed: ?Sized> {
 /// for more information on borrowing as another type.
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_diagnostic_item = "BorrowMut"]
-#[const_trait]
 #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
-pub trait BorrowMut<Borrowed: ?Sized>: Borrow<Borrowed> {
+pub const trait BorrowMut<Borrowed: ?Sized>: Borrow<Borrowed> {
     /// Mutably borrows from an owned value.
     ///
     /// # Examples
diff --git a/library/core/src/clone.rs b/library/core/src/clone.rs
index 0add77b2bc89a..7f2a40f753fa6 100644
--- a/library/core/src/clone.rs
+++ b/library/core/src/clone.rs
@@ -191,8 +191,7 @@ mod uninit;
 #[rustc_diagnostic_item = "Clone"]
 #[rustc_trivial_field_reads]
 #[rustc_const_unstable(feature = "const_clone", issue = "142757")]
-#[const_trait]
-pub trait Clone: Sized {
+pub const trait Clone: Sized {
     /// Returns a duplicate of the value.
     ///
     /// Note that what "duplicate" means varies by type:
diff --git a/library/core/src/cmp.rs b/library/core/src/cmp.rs
index ab018fa267502..0812322f3fbb0 100644
--- a/library/core/src/cmp.rs
+++ b/library/core/src/cmp.rs
@@ -247,9 +247,8 @@ use crate::ops::ControlFlow;
     append_const_msg
 )]
 #[rustc_diagnostic_item = "PartialEq"]
-#[const_trait]
 #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
-pub trait PartialEq<Rhs: PointeeSized = Self>: PointeeSized {
+pub const trait PartialEq<Rhs: PointeeSized = Self>: PointeeSized {
     /// Tests for `self` and `other` values to be equal, and is used by `==`.
     #[must_use]
     #[stable(feature = "rust1", since = "1.0.0")]
diff --git a/library/core/src/cmp/bytewise.rs b/library/core/src/cmp/bytewise.rs
index a06a6e8b69a2a..2265fa7a3531c 100644
--- a/library/core/src/cmp/bytewise.rs
+++ b/library/core/src/cmp/bytewise.rs
@@ -17,7 +17,7 @@ use crate::num::NonZero;
 /// - Neither `Self` nor `Rhs` have provenance, so integer comparisons are correct.
 /// - `<Self as PartialEq<Rhs>>::{eq,ne}` are equivalent to comparing the bytes.
 #[rustc_specialization_trait]
-#[const_trait]
+#[const_trait] // FIXME(const_trait_impl): Migrate to `const unsafe trait` once #146122 is fixed.
 pub(crate) unsafe trait BytewiseEq<Rhs = Self>:
     [const] PartialEq<Rhs> + Sized
 {
diff --git a/library/core/src/convert/mod.rs b/library/core/src/convert/mod.rs
index add21b491ad0d..a3cfd85974a4f 100644
--- a/library/core/src/convert/mod.rs
+++ b/library/core/src/convert/mod.rs
@@ -216,9 +216,8 @@ pub const fn identity<T>(x: T) -> T {
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_diagnostic_item = "AsRef"]
-#[const_trait]
 #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
-pub trait AsRef<T: PointeeSized>: PointeeSized {
+pub const trait AsRef<T: PointeeSized>: PointeeSized {
     /// Converts this type into a shared reference of the (usually inferred) input type.
     #[stable(feature = "rust1", since = "1.0.0")]
     fn as_ref(&self) -> &T;
@@ -369,9 +368,8 @@ pub trait AsRef<T: PointeeSized>: PointeeSized {
 /// `&mut Vec<u8>`, for example, is the better choice (callers need to pass the correct type then).
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_diagnostic_item = "AsMut"]
-#[const_trait]
 #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
-pub trait AsMut<T: PointeeSized>: PointeeSized {
+pub const trait AsMut<T: PointeeSized>: PointeeSized {
     /// Converts this type into a mutable reference of the (usually inferred) input type.
     #[stable(feature = "rust1", since = "1.0.0")]
     fn as_mut(&mut self) -> &mut T;
@@ -450,8 +448,7 @@ pub trait AsMut<T: PointeeSized>: PointeeSized {
 #[stable(feature = "rust1", since = "1.0.0")]
 #[doc(search_unbox)]
 #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
-#[const_trait]
-pub trait Into<T>: Sized {
+pub const trait Into<T>: Sized {
     /// Converts this type into the (usually inferred) input type.
     #[must_use]
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -587,8 +584,7 @@ pub trait Into<T>: Sized {
 ))]
 #[doc(search_unbox)]
 #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
-#[const_trait]
-pub trait From<T>: Sized {
+pub const trait From<T>: Sized {
     /// Converts to this type from the input type.
     #[rustc_diagnostic_item = "from_fn"]
     #[must_use]
@@ -616,8 +612,7 @@ pub trait From<T>: Sized {
 #[rustc_diagnostic_item = "TryInto"]
 #[stable(feature = "try_from", since = "1.34.0")]
 #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
-#[const_trait]
-pub trait TryInto<T>: Sized {
+pub const trait TryInto<T>: Sized {
     /// The type returned in the event of a conversion error.
     #[stable(feature = "try_from", since = "1.34.0")]
     type Error;
@@ -696,8 +691,7 @@ pub trait TryInto<T>: Sized {
 #[rustc_diagnostic_item = "TryFrom"]
 #[stable(feature = "try_from", since = "1.34.0")]
 #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
-#[const_trait]
-pub trait TryFrom<T>: Sized {
+pub const trait TryFrom<T>: Sized {
     /// The type returned in the event of a conversion error.
     #[stable(feature = "try_from", since = "1.34.0")]
     type Error;
diff --git a/library/core/src/default.rs b/library/core/src/default.rs
index 897267968aacc..cc9289307c1df 100644
--- a/library/core/src/default.rs
+++ b/library/core/src/default.rs
@@ -103,9 +103,8 @@ use crate::ascii::Char as AsciiChar;
 /// ```
 #[rustc_diagnostic_item = "Default"]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[const_trait]
 #[rustc_const_unstable(feature = "const_default", issue = "143894")]
-pub trait Default: Sized {
+pub const trait Default: Sized {
     /// Returns the "default value" for a type.
     ///
     /// Default values are often some kind of initial value, identity value, or anything else that
diff --git a/library/core/src/intrinsics/fallback.rs b/library/core/src/intrinsics/fallback.rs
index 96928325328a9..932537f2581f8 100644
--- a/library/core/src/intrinsics/fallback.rs
+++ b/library/core/src/intrinsics/fallback.rs
@@ -7,9 +7,8 @@
 )]
 #![allow(missing_docs)]
 
-#[const_trait]
 #[rustc_const_unstable(feature = "core_intrinsics_fallbacks", issue = "none")]
-pub trait CarryingMulAdd: Copy + 'static {
+pub const trait CarryingMulAdd: Copy + 'static {
     type Unsigned: Copy + 'static;
     fn carrying_mul_add(
         self,
@@ -111,9 +110,8 @@ impl const CarryingMulAdd for i128 {
     }
 }
 
-#[const_trait]
 #[rustc_const_unstable(feature = "core_intrinsics_fallbacks", issue = "none")]
-pub trait DisjointBitOr: Copy + 'static {
+pub const trait DisjointBitOr: Copy + 'static {
     /// See [`super::disjoint_bitor`]; we just need the trait indirection to handle
     /// different types since calling intrinsics with generics doesn't work.
     unsafe fn disjoint_bitor(self, other: Self) -> Self;
@@ -149,9 +147,8 @@ impl_disjoint_bitor! {
     i8, i16, i32, i64, i128, isize,
 }
 
-#[const_trait]
 #[rustc_const_unstable(feature = "core_intrinsics_fallbacks", issue = "none")]
-pub trait FunnelShift: Copy + 'static {
+pub const trait FunnelShift: Copy + 'static {
     /// See [`super::unchecked_funnel_shl`]; we just need the trait indirection to handle
     /// different types since calling intrinsics with generics doesn't work.
     unsafe fn unchecked_funnel_shl(self, rhs: Self, shift: u32) -> Self;
diff --git a/library/core/src/marker.rs b/library/core/src/marker.rs
index 73aad27afef6f..d03d7a43469a7 100644
--- a/library/core/src/marker.rs
+++ b/library/core/src/marker.rs
@@ -1057,8 +1057,7 @@ marker_impls! {
 #[rustc_on_unimplemented(message = "can't drop `{Self}`", append_const_msg)]
 #[rustc_deny_explicit_impl]
 #[rustc_do_not_implement_via_object]
-#[const_trait]
-pub trait Destruct {}
+pub const trait Destruct {}
 
 /// A marker for tuple types.
 ///
diff --git a/library/core/src/ops/arith.rs b/library/core/src/ops/arith.rs
index 16c719b0c3946..6c6479c998459 100644
--- a/library/core/src/ops/arith.rs
+++ b/library/core/src/ops/arith.rs
@@ -74,8 +74,7 @@
     append_const_msg
 )]
 #[doc(alias = "+")]
-#[const_trait]
-pub trait Add<Rhs = Self> {
+pub const trait Add<Rhs = Self> {
     /// The resulting type after applying the `+` operator.
     #[stable(feature = "rust1", since = "1.0.0")]
     type Output;
@@ -188,8 +187,7 @@ add_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f16 f32 f64 f128
     append_const_msg
 )]
 #[doc(alias = "-")]
-#[const_trait]
-pub trait Sub<Rhs = Self> {
+pub const trait Sub<Rhs = Self> {
     /// The resulting type after applying the `-` operator.
     #[stable(feature = "rust1", since = "1.0.0")]
     type Output;
@@ -323,8 +321,7 @@ sub_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f16 f32 f64 f128
     label = "no implementation for `{Self} * {Rhs}`"
 )]
 #[doc(alias = "*")]
-#[const_trait]
-pub trait Mul<Rhs = Self> {
+pub const trait Mul<Rhs = Self> {
     /// The resulting type after applying the `*` operator.
     #[stable(feature = "rust1", since = "1.0.0")]
     type Output;
@@ -462,8 +459,7 @@ mul_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f16 f32 f64 f128
     label = "no implementation for `{Self} / {Rhs}`"
 )]
 #[doc(alias = "/")]
-#[const_trait]
-pub trait Div<Rhs = Self> {
+pub const trait Div<Rhs = Self> {
     /// The resulting type after applying the `/` operator.
     #[stable(feature = "rust1", since = "1.0.0")]
     type Output;
@@ -572,8 +568,7 @@ div_impl_float! { f16 f32 f64 f128 }
     label = "no implementation for `{Self} % {Rhs}`"
 )]
 #[doc(alias = "%")]
-#[const_trait]
-pub trait Rem<Rhs = Self> {
+pub const trait Rem<Rhs = Self> {
     /// The resulting type after applying the `%` operator.
     #[stable(feature = "rust1", since = "1.0.0")]
     type Output;
@@ -694,8 +689,7 @@ rem_impl_float! { f16 f32 f64 f128 }
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_const_unstable(feature = "const_ops", issue = "143802")]
 #[doc(alias = "-")]
-#[const_trait]
-pub trait Neg {
+pub const trait Neg {
     /// The resulting type after applying the `-` operator.
     #[stable(feature = "rust1", since = "1.0.0")]
     type Output;
@@ -772,8 +766,7 @@ neg_impl! { isize i8 i16 i32 i64 i128 f16 f32 f64 f128 }
 )]
 #[doc(alias = "+")]
 #[doc(alias = "+=")]
-#[const_trait]
-pub trait AddAssign<Rhs = Self> {
+pub const trait AddAssign<Rhs = Self> {
     /// Performs the `+=` operation.
     ///
     /// # Example
@@ -844,8 +837,7 @@ add_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f16 f32 f
 )]
 #[doc(alias = "-")]
 #[doc(alias = "-=")]
-#[const_trait]
-pub trait SubAssign<Rhs = Self> {
+pub const trait SubAssign<Rhs = Self> {
     /// Performs the `-=` operation.
     ///
     /// # Example
@@ -907,8 +899,7 @@ sub_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f16 f32 f
 )]
 #[doc(alias = "*")]
 #[doc(alias = "*=")]
-#[const_trait]
-pub trait MulAssign<Rhs = Self> {
+pub const trait MulAssign<Rhs = Self> {
     /// Performs the `*=` operation.
     ///
     /// # Example
@@ -970,8 +961,7 @@ mul_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f16 f32 f
 )]
 #[doc(alias = "/")]
 #[doc(alias = "/=")]
-#[const_trait]
-pub trait DivAssign<Rhs = Self> {
+pub const trait DivAssign<Rhs = Self> {
     /// Performs the `/=` operation.
     ///
     /// # Example
@@ -1036,8 +1026,7 @@ div_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f16 f32 f
 )]
 #[doc(alias = "%")]
 #[doc(alias = "%=")]
-#[const_trait]
-pub trait RemAssign<Rhs = Self> {
+pub const trait RemAssign<Rhs = Self> {
     /// Performs the `%=` operation.
     ///
     /// # Example
diff --git a/library/core/src/ops/bit.rs b/library/core/src/ops/bit.rs
index 001967282190f..0cd61b0737381 100644
--- a/library/core/src/ops/bit.rs
+++ b/library/core/src/ops/bit.rs
@@ -32,8 +32,7 @@
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_const_unstable(feature = "const_ops", issue = "143802")]
 #[doc(alias = "!")]
-#[const_trait]
-pub trait Not {
+pub const trait Not {
     /// The resulting type after applying the `!` operator.
     #[stable(feature = "rust1", since = "1.0.0")]
     type Output;
@@ -148,8 +147,7 @@ impl const Not for ! {
     message = "no implementation for `{Self} & {Rhs}`",
     label = "no implementation for `{Self} & {Rhs}`"
 )]
-#[const_trait]
-pub trait BitAnd<Rhs = Self> {
+pub const trait BitAnd<Rhs = Self> {
     /// The resulting type after applying the `&` operator.
     #[stable(feature = "rust1", since = "1.0.0")]
     type Output;
@@ -253,8 +251,7 @@ bitand_impl! { bool usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }
     message = "no implementation for `{Self} | {Rhs}`",
     label = "no implementation for `{Self} | {Rhs}`"
 )]
-#[const_trait]
-pub trait BitOr<Rhs = Self> {
+pub const trait BitOr<Rhs = Self> {
     /// The resulting type after applying the `|` operator.
     #[stable(feature = "rust1", since = "1.0.0")]
     type Output;
@@ -358,8 +355,7 @@ bitor_impl! { bool usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }
     message = "no implementation for `{Self} ^ {Rhs}`",
     label = "no implementation for `{Self} ^ {Rhs}`"
 )]
-#[const_trait]
-pub trait BitXor<Rhs = Self> {
+pub const trait BitXor<Rhs = Self> {
     /// The resulting type after applying the `^` operator.
     #[stable(feature = "rust1", since = "1.0.0")]
     type Output;
@@ -462,8 +458,7 @@ bitxor_impl! { bool usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }
     message = "no implementation for `{Self} << {Rhs}`",
     label = "no implementation for `{Self} << {Rhs}`"
 )]
-#[const_trait]
-pub trait Shl<Rhs = Self> {
+pub const trait Shl<Rhs = Self> {
     /// The resulting type after applying the `<<` operator.
     #[stable(feature = "rust1", since = "1.0.0")]
     type Output;
@@ -585,8 +580,7 @@ shl_impl_all! { u8 u16 u32 u64 u128 usize i8 i16 i32 i64 i128 isize }
     message = "no implementation for `{Self} >> {Rhs}`",
     label = "no implementation for `{Self} >> {Rhs}`"
 )]
-#[const_trait]
-pub trait Shr<Rhs = Self> {
+pub const trait Shr<Rhs = Self> {
     /// The resulting type after applying the `>>` operator.
     #[stable(feature = "rust1", since = "1.0.0")]
     type Output;
@@ -717,8 +711,7 @@ shr_impl_all! { u8 u16 u32 u64 u128 usize i8 i16 i32 i64 i128 isize }
     message = "no implementation for `{Self} &= {Rhs}`",
     label = "no implementation for `{Self} &= {Rhs}`"
 )]
-#[const_trait]
-pub trait BitAndAssign<Rhs = Self> {
+pub const trait BitAndAssign<Rhs = Self> {
     /// Performs the `&=` operation.
     ///
     /// # Examples
@@ -793,8 +786,7 @@ bitand_assign_impl! { bool usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }
     message = "no implementation for `{Self} |= {Rhs}`",
     label = "no implementation for `{Self} |= {Rhs}`"
 )]
-#[const_trait]
-pub trait BitOrAssign<Rhs = Self> {
+pub const trait BitOrAssign<Rhs = Self> {
     /// Performs the `|=` operation.
     ///
     /// # Examples
@@ -869,8 +861,7 @@ bitor_assign_impl! { bool usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }
     message = "no implementation for `{Self} ^= {Rhs}`",
     label = "no implementation for `{Self} ^= {Rhs}`"
 )]
-#[const_trait]
-pub trait BitXorAssign<Rhs = Self> {
+pub const trait BitXorAssign<Rhs = Self> {
     /// Performs the `^=` operation.
     ///
     /// # Examples
@@ -943,8 +934,7 @@ bitxor_assign_impl! { bool usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }
     message = "no implementation for `{Self} <<= {Rhs}`",
     label = "no implementation for `{Self} <<= {Rhs}`"
 )]
-#[const_trait]
-pub trait ShlAssign<Rhs = Self> {
+pub const trait ShlAssign<Rhs = Self> {
     /// Performs the `<<=` operation.
     ///
     /// # Examples
@@ -1030,8 +1020,7 @@ shl_assign_impl_all! { u8 u16 u32 u64 u128 usize i8 i16 i32 i64 i128 isize }
     message = "no implementation for `{Self} >>= {Rhs}`",
     label = "no implementation for `{Self} >>= {Rhs}`"
 )]
-#[const_trait]
-pub trait ShrAssign<Rhs = Self> {
+pub const trait ShrAssign<Rhs = Self> {
     /// Performs the `>>=` operation.
     ///
     /// # Examples
diff --git a/library/core/src/ops/deref.rs b/library/core/src/ops/deref.rs
index 877b83d3a6116..305861ea7b698 100644
--- a/library/core/src/ops/deref.rs
+++ b/library/core/src/ops/deref.rs
@@ -135,9 +135,8 @@ use crate::marker::PointeeSized;
 #[doc(alias = "&*")]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_diagnostic_item = "Deref"]
-#[const_trait]
 #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
-pub trait Deref: PointeeSized {
+pub const trait Deref: PointeeSized {
     /// The resulting type after dereferencing.
     #[stable(feature = "rust1", since = "1.0.0")]
     #[rustc_diagnostic_item = "deref_target"]
@@ -267,9 +266,8 @@ impl<T: ?Sized> const Deref for &mut T {
 #[lang = "deref_mut"]
 #[doc(alias = "*")]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[const_trait]
 #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
-pub trait DerefMut: [const] Deref + PointeeSized {
+pub const trait DerefMut: [const] Deref + PointeeSized {
     /// Mutably dereferences the value.
     #[stable(feature = "rust1", since = "1.0.0")]
     #[rustc_diagnostic_item = "deref_mut_method"]
diff --git a/library/core/src/ops/drop.rs b/library/core/src/ops/drop.rs
index bbef702320715..7125bf54701bb 100644
--- a/library/core/src/ops/drop.rs
+++ b/library/core/src/ops/drop.rs
@@ -203,9 +203,8 @@
 /// [nomicon]: ../../nomicon/phantom-data.html#an-exception-the-special-case-of-the-standard-library-and-its-unstable-may_dangle
 #[lang = "drop"]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[const_trait]
 #[rustc_const_unstable(feature = "const_destruct", issue = "133214")]
-pub trait Drop {
+pub const trait Drop {
     /// Executes the destructor for this type.
     ///
     /// This method is called implicitly when the value goes out of scope,
diff --git a/library/core/src/ops/function.rs b/library/core/src/ops/function.rs
index ad46e52a475db..479368ba8f801 100644
--- a/library/core/src/ops/function.rs
+++ b/library/core/src/ops/function.rs
@@ -72,9 +72,8 @@ use crate::marker::Tuple;
 )]
 #[fundamental] // so that regex can rely that `&str: !FnMut`
 #[must_use = "closures are lazy and do nothing unless called"]
-#[const_trait]
 #[rustc_const_unstable(feature = "const_trait_impl", issue = "143874")]
-pub trait Fn<Args: Tuple>: FnMut<Args> {
+pub const trait Fn<Args: Tuple>: FnMut<Args> {
     /// Performs the call operation.
     #[unstable(feature = "fn_traits", issue = "29625")]
     extern "rust-call" fn call(&self, args: Args) -> Self::Output;
@@ -160,9 +159,8 @@ pub trait Fn<Args: Tuple>: FnMut<Args> {
 )]
 #[fundamental] // so that regex can rely that `&str: !FnMut`
 #[must_use = "closures are lazy and do nothing unless called"]
-#[const_trait]
 #[rustc_const_unstable(feature = "const_trait_impl", issue = "143874")]
-pub trait FnMut<Args: Tuple>: FnOnce<Args> {
+pub const trait FnMut<Args: Tuple>: FnOnce<Args> {
     /// Performs the call operation.
     #[unstable(feature = "fn_traits", issue = "29625")]
     extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output;
@@ -240,9 +238,8 @@ pub trait FnMut<Args: Tuple>: FnOnce<Args> {
 )]
 #[fundamental] // so that regex can rely that `&str: !FnMut`
 #[must_use = "closures are lazy and do nothing unless called"]
-#[const_trait]
 #[rustc_const_unstable(feature = "const_trait_impl", issue = "143874")]
-pub trait FnOnce<Args: Tuple> {
+pub const trait FnOnce<Args: Tuple> {
     /// The returned type after the call operator is used.
     #[lang = "fn_once_output"]
     #[stable(feature = "fn_once_output", since = "1.12.0")]
diff --git a/library/core/src/ops/index.rs b/library/core/src/ops/index.rs
index 1aed2fb4742e6..2c62a3930c281 100644
--- a/library/core/src/ops/index.rs
+++ b/library/core/src/ops/index.rs
@@ -55,9 +55,8 @@
 #[doc(alias = "]")]
 #[doc(alias = "[")]
 #[doc(alias = "[]")]
-#[const_trait]
 #[rustc_const_unstable(feature = "const_index", issue = "143775")]
-pub trait Index<Idx: ?Sized> {
+pub const trait Index<Idx: ?Sized> {
     /// The returned type after indexing.
     #[stable(feature = "rust1", since = "1.0.0")]
     #[rustc_diagnostic_item = "IndexOutput"]
@@ -168,8 +167,7 @@ see chapter in The Book <https://doc.rust-lang.org/book/ch08-02-strings.html#ind
 #[doc(alias = "]")]
 #[doc(alias = "[]")]
 #[rustc_const_unstable(feature = "const_index", issue = "143775")]
-#[const_trait]
-pub trait IndexMut<Idx: ?Sized>: [const] Index<Idx> {
+pub const trait IndexMut<Idx: ?Sized>: [const] Index<Idx> {
     /// Performs the mutable indexing (`container[index]`) operation.
     ///
     /// # Panics
diff --git a/library/core/src/ops/try_trait.rs b/library/core/src/ops/try_trait.rs
index 76bf438878f01..e1f2ebcf4c289 100644
--- a/library/core/src/ops/try_trait.rs
+++ b/library/core/src/ops/try_trait.rs
@@ -128,9 +128,8 @@ use crate::ops::ControlFlow;
 )]
 #[doc(alias = "?")]
 #[lang = "Try"]
-#[const_trait]
 #[rustc_const_unstable(feature = "const_try", issue = "74935")]
-pub trait Try: [const] FromResidual {
+pub const trait Try: [const] FromResidual {
     /// The type of the value produced by `?` when *not* short-circuiting.
     #[unstable(feature = "try_trait_v2", issue = "84277", old_name = "try_trait")]
     type Output;
@@ -306,9 +305,8 @@ pub trait Try: [const] FromResidual {
 )]
 #[rustc_diagnostic_item = "FromResidual"]
 #[unstable(feature = "try_trait_v2", issue = "84277", old_name = "try_trait")]
-#[const_trait]
 #[rustc_const_unstable(feature = "const_try", issue = "74935")]
-pub trait FromResidual<R = <Self as Try>::Residual> {
+pub const trait FromResidual<R = <Self as Try>::Residual> {
     /// Constructs the type from a compatible `Residual` type.
     ///
     /// This should be implemented consistently with the `branch` method such
@@ -361,9 +359,8 @@ where
 /// and in the other direction,
 /// `<Result<Infallible, E> as Residual<T>>::TryType = Result<T, E>`.
 #[unstable(feature = "try_trait_v2_residual", issue = "91285")]
-#[const_trait]
 #[rustc_const_unstable(feature = "const_try", issue = "74935")]
-pub trait Residual<O> {
+pub const trait Residual<O> {
     /// The "return" type of this meta-function.
     #[unstable(feature = "try_trait_v2_residual", issue = "91285")]
     type TryType: Try<Output = O, Residual = Self>;
diff --git a/library/core/src/option.rs b/library/core/src/option.rs
index 2a57536500ad0..198636c67d0b1 100644
--- a/library/core/src/option.rs
+++ b/library/core/src/option.rs
@@ -1640,7 +1640,7 @@ impl<T> Option<T> {
     pub const fn or_else<F>(self, f: F) -> Option<T>
     where
         F: [const] FnOnce() -> Option<T> + [const] Destruct,
-        //FIXME(const_hack): this `T: ~const Destruct` is unnecessary, but even precise live drops can't tell
+        //FIXME(const_hack): this `T: [const] Destruct` is unnecessary, but even precise live drops can't tell
         // no value of type `T` gets dropped here
         T: [const] Destruct,
     {
@@ -2185,7 +2185,7 @@ const fn expect_failed(msg: &str) -> ! {
 #[rustc_const_unstable(feature = "const_clone", issue = "142757")]
 impl<T> const Clone for Option<T>
 where
-    // FIXME(const_hack): the T: ~const Destruct should be inferred from the Self: ~const Destruct in clone_from.
+    // FIXME(const_hack): the T: [const] Destruct should be inferred from the Self: [const] Destruct in clone_from.
     // See https://github.com/rust-lang/rust/issues/144207
     T: [const] Clone + [const] Destruct,
 {
diff --git a/library/core/src/pat.rs b/library/core/src/pat.rs
index 91d015b1bc53f..a13eea3fb585c 100644
--- a/library/core/src/pat.rs
+++ b/library/core/src/pat.rs
@@ -18,12 +18,11 @@ macro_rules! pattern_type {
 /// used right now to simplify ast lowering of pattern type ranges.
 #[unstable(feature = "pattern_type_range_trait", issue = "123646")]
 #[rustc_const_unstable(feature = "pattern_type_range_trait", issue = "123646")]
-#[const_trait]
 #[diagnostic::on_unimplemented(
     message = "`{Self}` is not a valid base type for range patterns",
     label = "only integer types and `char` are supported"
 )]
-pub trait RangePattern {
+pub const trait RangePattern {
     /// Trait version of the inherent `MIN` assoc const.
     #[lang = "RangeMin"]
     const MIN: Self;
diff --git a/library/core/src/slice/cmp.rs b/library/core/src/slice/cmp.rs
index 68bd12aa7bf2f..0d80130698400 100644
--- a/library/core/src/slice/cmp.rs
+++ b/library/core/src/slice/cmp.rs
@@ -95,9 +95,8 @@ impl<T: PartialOrd> PartialOrd for [T] {
 
 #[doc(hidden)]
 // intermediate trait for specialization of slice's PartialEq
-#[const_trait]
 #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
-trait SlicePartialEq<B> {
+const trait SlicePartialEq<B> {
     fn equal(&self, other: &[B]) -> bool;
 
     fn not_equal(&self, other: &[B]) -> bool {
diff --git a/library/core/src/slice/index.rs b/library/core/src/slice/index.rs
index 98091e9fe83fb..8e1bc0bae70a4 100644
--- a/library/core/src/slice/index.rs
+++ b/library/core/src/slice/index.rs
@@ -151,7 +151,7 @@ mod private_slice_index {
     message = "the type `{T}` cannot be indexed by `{Self}`",
     label = "slice indices are of type `usize` or ranges of `usize`"
 )]
-#[const_trait]
+#[const_trait] // FIXME(const_trait_impl): Migrate to `const unsafe trait` once #146122 is fixed.
 #[rustc_const_unstable(feature = "const_index", issue = "143775")]
 pub unsafe trait SliceIndex<T: ?Sized>: private_slice_index::Sealed {
     /// The output type returned by methods.
diff --git a/library/core/src/str/traits.rs b/library/core/src/str/traits.rs
index 971c8e829c648..4f228edf78e46 100644
--- a/library/core/src/str/traits.rs
+++ b/library/core/src/str/traits.rs
@@ -825,9 +825,8 @@ unsafe impl const SliceIndex<str> for ops::RangeToInclusive<usize> {
 /// assert!(Point::from_str("(1 2)").is_err());
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
-#[const_trait]
 #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
-pub trait FromStr: Sized {
+pub const trait FromStr: Sized {
     /// The associated error which can be returned from parsing.
     #[stable(feature = "rust1", since = "1.0.0")]
     type Err;
diff --git a/tests/ui/traits/const-traits/constructor-const-fn.rs b/tests/ui/traits/const-traits/constructor-const-fn.rs
index 4a7bf531df234..af40ad94d1c0b 100644
--- a/tests/ui/traits/const-traits/constructor-const-fn.rs
+++ b/tests/ui/traits/const-traits/constructor-const-fn.rs
@@ -1,7 +1,7 @@
 //@ check-pass
 //@ compile-flags: -Znext-solver
 #![feature(const_trait_impl)]
-const fn impls_fn<F: ~const Fn(u32) -> Foo>(_: &F) {}
+const fn impls_fn<F: [const] Fn(u32) -> Foo>(_: &F) {}
 
 struct Foo(u32);
 
diff --git a/tests/ui/traits/const-traits/reservation-impl-ice.rs b/tests/ui/traits/const-traits/reservation-impl-ice.rs
index 7fefb4ec54399..3fbfe8c950daa 100644
--- a/tests/ui/traits/const-traits/reservation-impl-ice.rs
+++ b/tests/ui/traits/const-traits/reservation-impl-ice.rs
@@ -1,7 +1,7 @@
 //@ compile-flags: -Znext-solver
 #![feature(const_convert, never_type, const_trait_impl)]
 
-const fn impls_from<T: ~const From<!>>() {}
+const fn impls_from<T: [const] From<!>>() {}
 
 const fn foo() {
     // This previously ICE'd when encountering the reservation impl
diff --git a/tests/ui/traits/const-traits/reservation-impl-ice.stderr b/tests/ui/traits/const-traits/reservation-impl-ice.stderr
index a3fdcbac69e39..d30c014d63f11 100644
--- a/tests/ui/traits/const-traits/reservation-impl-ice.stderr
+++ b/tests/ui/traits/const-traits/reservation-impl-ice.stderr
@@ -17,8 +17,8 @@ LL |     impls_from::<()>();
 note: required by a bound in `impls_from`
   --> $DIR/reservation-impl-ice.rs:4:24
    |
-LL | const fn impls_from<T: ~const From<!>>() {}
-   |                        ^^^^^^^^^^^^^^ required by this bound in `impls_from`
+LL | const fn impls_from<T: [const] From<!>>() {}
+   |                        ^^^^^^^^^^^^^^^ required by this bound in `impls_from`
 
 error: aborting due to 1 previous error
 

From 4e18796882880e9465d43f29c697aef311c6bb36 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Sat, 6 Sep 2025 05:11:47 +0200
Subject: [PATCH 0563/1889] Zulip streams have been renamed to channels

https://blog.zulip.com/2024/07/25/zulip-9-0-released
---
 src/doc/rustc-dev-guide/src/backend/debugging.md                | 2 +-
 src/doc/rustc-dev-guide/src/compiler-team.md                    | 2 +-
 src/doc/rustc-dev-guide/src/notification-groups/arm.md          | 2 +-
 src/doc/rustc-dev-guide/src/notification-groups/emscripten.md   | 2 +-
 src/doc/rustc-dev-guide/src/notification-groups/risc-v.md       | 2 +-
 .../rustc-dev-guide/src/notification-groups/rust-for-linux.md   | 2 +-
 src/doc/rustc-dev-guide/src/notification-groups/wasi.md         | 2 +-
 src/doc/rustc-dev-guide/src/notification-groups/wasm.md         | 2 +-
 src/doc/rustc-dev-guide/src/notification-groups/windows.md      | 2 +-
 src/doc/rustc-dev-guide/src/traits/chalk.md                     | 2 +-
 src/doc/rustc-dev-guide/src/typing_parameter_envs.md            | 2 +-
 11 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/backend/debugging.md b/src/doc/rustc-dev-guide/src/backend/debugging.md
index 4f8712dfaf3cc..3dc95f25d4ae9 100644
--- a/src/doc/rustc-dev-guide/src/backend/debugging.md
+++ b/src/doc/rustc-dev-guide/src/backend/debugging.md
@@ -183,7 +183,7 @@ The quick summary is:
 ### Getting help and asking questions
 
 If you have some questions, head over to the [rust-lang Zulip] and
-specifically the `#t-compiler/wg-llvm` stream.
+specifically the `#t-compiler/wg-llvm` channel.
 
 [rust-lang Zulip]: https://rust-lang.zulipchat.com/
 
diff --git a/src/doc/rustc-dev-guide/src/compiler-team.md b/src/doc/rustc-dev-guide/src/compiler-team.md
index 9922ee7ddf23a..6be52833f3964 100644
--- a/src/doc/rustc-dev-guide/src/compiler-team.md
+++ b/src/doc/rustc-dev-guide/src/compiler-team.md
@@ -12,7 +12,7 @@ contributions to rustc and its design.
 Currently the compiler team chats in Zulip:
 
 - Team chat occurs in the [`t-compiler`][zulip-t-compiler] stream on the Zulip instance
-- There are also a number of other associated Zulip streams,
+- There are also a number of other associated Zulip channels,
   such as [`t-compiler/help`][zulip-help], where people can ask for help
   with rustc development, or [`t-compiler/meetings`][zulip-meetings],
   where the team holds their weekly triage and steering meetings.
diff --git a/src/doc/rustc-dev-guide/src/notification-groups/arm.md b/src/doc/rustc-dev-guide/src/notification-groups/arm.md
index 3abc32c688830..5b79030d20de3 100644
--- a/src/doc/rustc-dev-guide/src/notification-groups/arm.md
+++ b/src/doc/rustc-dev-guide/src/notification-groups/arm.md
@@ -9,7 +9,7 @@ This list will be used to ask for help both in diagnosing and testing
 ARM-related issues as well as suggestions on how to resolve
 interesting questions regarding our ARM support.
 
-The group also has an associated Zulip stream ([`#t-compiler/arm`])
+The group also has an associated Zulip channel ([`#t-compiler/arm`])
 where people can go to pose questions and discuss ARM-specific
 topics.
 
diff --git a/src/doc/rustc-dev-guide/src/notification-groups/emscripten.md b/src/doc/rustc-dev-guide/src/notification-groups/emscripten.md
index 100dbdf9f2b37..9e4086c884e0b 100644
--- a/src/doc/rustc-dev-guide/src/notification-groups/emscripten.md
+++ b/src/doc/rustc-dev-guide/src/notification-groups/emscripten.md
@@ -9,7 +9,7 @@ This list will be used to ask for help both in diagnosing and testing
 Emscripten-related issues as well as suggestions on how to resolve
 interesting questions regarding our Emscripten support.
 
-The group also has an associated Zulip stream ([`#t-compiler/wasm`])
+The group also has an associated Zulip channel ([`#t-compiler/wasm`])
 where people can go to pose questions and discuss Emscripten-specific
 topics.
 
diff --git a/src/doc/rustc-dev-guide/src/notification-groups/risc-v.md b/src/doc/rustc-dev-guide/src/notification-groups/risc-v.md
index 1b31297b600e1..7c8a3cdf8a64d 100644
--- a/src/doc/rustc-dev-guide/src/notification-groups/risc-v.md
+++ b/src/doc/rustc-dev-guide/src/notification-groups/risc-v.md
@@ -9,7 +9,7 @@ This list will be used to ask for help both in diagnosing and testing
 RISC-V-related issues as well as suggestions on how to resolve
 interesting questions regarding our RISC-V support.
 
-The group also has an associated Zulip stream ([`#t-compiler/risc-v`])
+The group also has an associated Zulip channel ([`#t-compiler/risc-v`])
 where people can go to pose questions and discuss RISC-V-specific
 topics.
 
diff --git a/src/doc/rustc-dev-guide/src/notification-groups/rust-for-linux.md b/src/doc/rustc-dev-guide/src/notification-groups/rust-for-linux.md
index 696f2038e1a4b..ed1de9196de6f 100644
--- a/src/doc/rustc-dev-guide/src/notification-groups/rust-for-linux.md
+++ b/src/doc/rustc-dev-guide/src/notification-groups/rust-for-linux.md
@@ -12,7 +12,7 @@ and features. The RfL maintainers should then ideally provide support
 for resolving the breakage or decide to temporarily accept the breakage
 and unblock CI by temporarily removing the RfL CI jobs.
 
-The group also has an associated Zulip stream ([`#rust-for-linux`])
+The group also has an associated Zulip channel ([`#rust-for-linux`])
 where people can go to ask questions and discuss topics related to Rust
 for Linux.
 
diff --git a/src/doc/rustc-dev-guide/src/notification-groups/wasi.md b/src/doc/rustc-dev-guide/src/notification-groups/wasi.md
index e438ee4bd090e..88b9465be0180 100644
--- a/src/doc/rustc-dev-guide/src/notification-groups/wasi.md
+++ b/src/doc/rustc-dev-guide/src/notification-groups/wasi.md
@@ -9,7 +9,7 @@ This list will be used to ask for help both in diagnosing and testing
 WASI-related issues as well as suggestions on how to resolve
 interesting questions regarding our WASI support.
 
-The group also has an associated Zulip stream ([`#t-compiler/wasm`])
+The group also has an associated Zulip channel ([`#t-compiler/wasm`])
 where people can go to pose questions and discuss WASI-specific
 topics.
 
diff --git a/src/doc/rustc-dev-guide/src/notification-groups/wasm.md b/src/doc/rustc-dev-guide/src/notification-groups/wasm.md
index c8b674cb93f23..6f52b04251f07 100644
--- a/src/doc/rustc-dev-guide/src/notification-groups/wasm.md
+++ b/src/doc/rustc-dev-guide/src/notification-groups/wasm.md
@@ -9,7 +9,7 @@ This list will be used to ask for help both in diagnosing and testing
 WebAssembly-related issues as well as suggestions on how to resolve
 interesting questions regarding our WASM support.
 
-The group also has an associated Zulip stream ([`#t-compiler/wasm`])
+The group also has an associated Zulip channel ([`#t-compiler/wasm`])
 where people can go to pose questions and discuss WASM-specific
 topics.
 
diff --git a/src/doc/rustc-dev-guide/src/notification-groups/windows.md b/src/doc/rustc-dev-guide/src/notification-groups/windows.md
index e615a2cbd8def..d245208e2abca 100644
--- a/src/doc/rustc-dev-guide/src/notification-groups/windows.md
+++ b/src/doc/rustc-dev-guide/src/notification-groups/windows.md
@@ -9,7 +9,7 @@ This list will be used to ask for help both in diagnosing and testing
 Windows-related issues as well as suggestions on how to resolve
 interesting questions regarding our Windows support.
 
-The group also has an associated Zulip stream ([`#t-compiler/windows`])
+The group also has an associated Zulip channel ([`#t-compiler/windows`])
 where people can go to pose questions and discuss Windows-specific
 topics.
 
diff --git a/src/doc/rustc-dev-guide/src/traits/chalk.md b/src/doc/rustc-dev-guide/src/traits/chalk.md
index 844f42b9879f8..ca5ed52591734 100644
--- a/src/doc/rustc-dev-guide/src/traits/chalk.md
+++ b/src/doc/rustc-dev-guide/src/traits/chalk.md
@@ -5,7 +5,7 @@
 Its goal is to enable a lot of trait system features and bug fixes
 that are hard to implement (e.g. GATs or specialization). If you would like to
 help in hacking on the new solver, drop by on the rust-lang Zulip in the [`#t-types`]
-stream and say hello!
+channel and say hello!
 
 [Types team]: https://github.com/rust-lang/types-team
 [`#t-types`]: https://rust-lang.zulipchat.com/#narrow/stream/144729-t-types
diff --git a/src/doc/rustc-dev-guide/src/typing_parameter_envs.md b/src/doc/rustc-dev-guide/src/typing_parameter_envs.md
index db15467a47a06..fd77f42ba7e42 100644
--- a/src/doc/rustc-dev-guide/src/typing_parameter_envs.md
+++ b/src/doc/rustc-dev-guide/src/typing_parameter_envs.md
@@ -82,7 +82,7 @@ In the large majority of cases, when a `ParamEnv` is required it either already
 - In the next-gen trait solver all `Goal`s have a [`param_env` field][goal_param_env] specifying what environment to prove the goal in
 - When editing an existing [`TypeRelation`][typerelation] if it implements [`PredicateEmittingRelation`][predicate_emitting_relation] then a [`param_env` method][typerelation_param_env] will be available.
 
-If you aren't sure if there's a `ParamEnv` in scope somewhere that can be used it can be worth opening a thread in the [`#t-compiler/help`][compiler_help] zulip stream where someone may be able to point out where a `ParamEnv` can be acquired from.
+If you aren't sure if there's a `ParamEnv` in scope somewhere that can be used it can be worth opening a thread in the [`#t-compiler/help`][compiler_help] zulip channel where someone may be able to point out where a `ParamEnv` can be acquired from.
 
 Manually constructing a `ParamEnv` is typically only needed at the start of some kind of top level analysis (e.g. hir typeck or borrow checking). In such cases there are three ways it can be done:
 - Calling the [`tcx.param_env(def_id)` query][param_env_query] which returns the environment associated with a given definition.

From 55f913cf1b4eb55ab2252421a28100288b8feec8 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Sat, 6 Sep 2025 05:25:38 +0200
Subject: [PATCH 0564/1889] capitalize "zulip"

---
 src/doc/rustc-dev-guide/src/about-this-guide.md      | 2 +-
 src/doc/rustc-dev-guide/src/contributing.md          | 4 ++--
 src/doc/rustc-dev-guide/src/rustdoc.md               | 2 +-
 src/doc/rustc-dev-guide/src/solve/caching.md         | 2 +-
 src/doc/rustc-dev-guide/src/solve/the-solver.md      | 2 +-
 src/doc/rustc-dev-guide/src/typing_parameter_envs.md | 2 +-
 6 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/about-this-guide.md b/src/doc/rustc-dev-guide/src/about-this-guide.md
index f3957724967c3..f1a406a1c29be 100644
--- a/src/doc/rustc-dev-guide/src/about-this-guide.md
+++ b/src/doc/rustc-dev-guide/src/about-this-guide.md
@@ -73,7 +73,7 @@ You might also find the following sites useful:
 - [compiler-team] -- the home-base for the Rust compiler team, with description
   of the team procedures, active working groups, and the team calendar.
 - [std-dev-guide] -- a similar guide for developing the standard library.
-- [The t-compiler zulip][z]
+- [The t-compiler Zulip][z]
 - The [Rust Internals forum][rif], a place to ask questions and
   discuss Rust's internals
 - The [Rust reference][rr], even though it doesn't specifically talk about
diff --git a/src/doc/rustc-dev-guide/src/contributing.md b/src/doc/rustc-dev-guide/src/contributing.md
index 18f2dcb21ba06..347608d305aa9 100644
--- a/src/doc/rustc-dev-guide/src/contributing.md
+++ b/src/doc/rustc-dev-guide/src/contributing.md
@@ -74,7 +74,7 @@ Example of things that might require MCPs include major refactorings, changes
 to important types, or important changes to how the compiler does something, or
 smaller user-facing changes.
 
-**When in doubt, ask on [zulip]. It would be a shame to put a lot of work
+**When in doubt, ask on [Zulip]. It would be a shame to put a lot of work
 into a PR that ends up not getting merged!** [See this document][mcpinfo] for
 more info on MCPs.
 
@@ -126,7 +126,7 @@ when contributing to Rust under [the git section](./git.md).
 > from), and work with the compiler team to see if we can help you **break down a large potentially
 > unreviewable PR into a series of smaller more individually reviewable PRs**.
 >
-> You can communicate with the compiler team by creating a [#t-compiler thread on zulip][t-compiler]
+> You can communicate with the compiler team by creating a [#t-compiler thread on Zulip][t-compiler]
 > to discuss your proposed changes.
 >
 > Communicating with the compiler team beforehand helps in several ways:
diff --git a/src/doc/rustc-dev-guide/src/rustdoc.md b/src/doc/rustc-dev-guide/src/rustdoc.md
index 9290fcd3b41cb..6127a894a0ff5 100644
--- a/src/doc/rustc-dev-guide/src/rustdoc.md
+++ b/src/doc/rustc-dev-guide/src/rustdoc.md
@@ -107,7 +107,7 @@ This comes with several caveats: in particular, rustdoc *cannot* run any parts o
 require type-checking bodies; for example it cannot generate `.rlib` files or run most lints.
 We want to move away from this model eventually, but we need some alternative for
 [the people using it][async-std]; see [various][zulip stop accepting broken code]
-[previous][rustdoc meeting 2024-07-08] [zulip][compiler meeting 2023-01-26] [discussion][notriddle rfc].
+[previous][rustdoc meeting 2024-07-08] [Zulip][compiler meeting 2023-01-26] [discussion][notriddle rfc].
 For examples of code that breaks if this hack is removed, see
 [`tests/rustdoc-ui/error-in-impl-trait`].
 
diff --git a/src/doc/rustc-dev-guide/src/solve/caching.md b/src/doc/rustc-dev-guide/src/solve/caching.md
index e568d47ca252a..cb7403de4e079 100644
--- a/src/doc/rustc-dev-guide/src/solve/caching.md
+++ b/src/doc/rustc-dev-guide/src/solve/caching.md
@@ -106,7 +106,7 @@ We can implement this optimization in the future.
 [`provisional_result`]: https://github.com/rust-lang/rust/blob/7606c13961ddc1174b70638e934df0439b7dc515/compiler/rustc_trait_selection/src/solve/search_graph.rs#L57
 [initial-prov-result]: https://github.com/rust-lang/rust/blob/7606c13961ddc1174b70638e934df0439b7dc515/compiler/rustc_trait_selection/src/solve/search_graph.rs#L366-L370
 [fixpoint]: https://github.com/rust-lang/rust/blob/7606c13961ddc1174b70638e934df0439b7dc515/compiler/rustc_trait_selection/src/solve/search_graph.rs#L425-L446
-[^2]: summarizing the relevant [zulip thread]
+[^2]: summarizing the relevant [Zulip thread]
 
 [zulip thread]: https://rust-lang.zulipchat.com/#narrow/stream/364551-t-types.2Ftrait-system-refactor/topic/global.20cache
 [unstable-result-ex]: https://github.com/rust-lang/rust/blob/7606c13961ddc1174b70638e934df0439b7dc515/tests/ui/traits/next-solver/cycles/coinduction/incompleteness-unstable-result.rs#L4-L16
diff --git a/src/doc/rustc-dev-guide/src/solve/the-solver.md b/src/doc/rustc-dev-guide/src/solve/the-solver.md
index 006fb649d2204..0e095b55437e0 100644
--- a/src/doc/rustc-dev-guide/src/solve/the-solver.md
+++ b/src/doc/rustc-dev-guide/src/solve/the-solver.md
@@ -71,6 +71,6 @@ fails.
 ## Learning more
 
 The solver should be fairly self-contained. I hope that the above information provides a
-good foundation when looking at the code itself. Please reach out on zulip if you get stuck
+good foundation when looking at the code itself. Please reach out on Zulip if you get stuck
 while doing so or there are some quirks and design decisions which were unclear and deserve
 better comments or should be mentioned here.
diff --git a/src/doc/rustc-dev-guide/src/typing_parameter_envs.md b/src/doc/rustc-dev-guide/src/typing_parameter_envs.md
index fd77f42ba7e42..35e62f195f96d 100644
--- a/src/doc/rustc-dev-guide/src/typing_parameter_envs.md
+++ b/src/doc/rustc-dev-guide/src/typing_parameter_envs.md
@@ -82,7 +82,7 @@ In the large majority of cases, when a `ParamEnv` is required it either already
 - In the next-gen trait solver all `Goal`s have a [`param_env` field][goal_param_env] specifying what environment to prove the goal in
 - When editing an existing [`TypeRelation`][typerelation] if it implements [`PredicateEmittingRelation`][predicate_emitting_relation] then a [`param_env` method][typerelation_param_env] will be available.
 
-If you aren't sure if there's a `ParamEnv` in scope somewhere that can be used it can be worth opening a thread in the [`#t-compiler/help`][compiler_help] zulip channel where someone may be able to point out where a `ParamEnv` can be acquired from.
+If you aren't sure if there's a `ParamEnv` in scope somewhere that can be used it can be worth opening a thread in the [`#t-compiler/help`][compiler_help] Zulip channel where someone may be able to point out where a `ParamEnv` can be acquired from.
 
 Manually constructing a `ParamEnv` is typically only needed at the start of some kind of top level analysis (e.g. hir typeck or borrow checking). In such cases there are three ways it can be done:
 - Calling the [`tcx.param_env(def_id)` query][param_env_query] which returns the environment associated with a given definition.

From 4156ed61065205b47680a3650f50995cac3fef8d Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Sat, 6 Sep 2025 05:44:29 +0200
Subject: [PATCH 0565/1889] reduce overlong physical lines (sembr)

---
 .../src/typing_parameter_envs.md              | 71 +++++++++++++------
 1 file changed, 51 insertions(+), 20 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/typing_parameter_envs.md b/src/doc/rustc-dev-guide/src/typing_parameter_envs.md
index 35e62f195f96d..45635ebfa15d6 100644
--- a/src/doc/rustc-dev-guide/src/typing_parameter_envs.md
+++ b/src/doc/rustc-dev-guide/src/typing_parameter_envs.md
@@ -2,11 +2,14 @@
 
 ## Typing Environments
 
-When interacting with the type system there are a few variables to consider that can affect the results of trait solving. The set of in-scope where clauses, and what phase of the compiler type system operations are being performed in (the [`ParamEnv`][penv] and [`TypingMode`][tmode] structs respectively).
+When interacting with the type system there are a few variables to consider that can affect the results of trait solving.
+The set of in-scope where clauses, and what phase of the compiler type system operations are being performed in (the [`ParamEnv`][penv] and [`TypingMode`][tmode] structs respectively).
 
-When an environment to perform type system operations in has not yet been created, the [`TypingEnv`][tenv] can be used to bundle all of the external context required into a single type.
+When an environment to perform type system operations in has not yet been created,
+the [`TypingEnv`][tenv] can be used to bundle all of the external context required into a single type.
 
-Once a context to perform type system operations in has been created (e.g. an [`ObligationCtxt`][ocx] or [`FnCtxt`][fnctxt]) a `TypingEnv` is typically not stored anywhere as only the `TypingMode` is a property of the whole environment, whereas different `ParamEnv`s can be used on a per-goal basis.
+Once a context to perform type system operations in has been created (e.g. an [`ObligationCtxt`][ocx] or [`FnCtxt`][fnctxt]) a `TypingEnv` is typically not stored anywhere as only the `TypingMode` is a property of the whole environment,
+whereas different `ParamEnv`s can be used on a per-goal basis.
 
 [ocx]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_trait_selection/traits/struct.ObligationCtxt.html
 [fnctxt]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir_typeck/fn_ctxt/struct.FnCtxt.html
@@ -15,9 +18,14 @@ Once a context to perform type system operations in has been created (e.g. an [`
 
 ### What is a `ParamEnv`
 
-The [`ParamEnv`][penv] is a list of in-scope where-clauses, it typically corresponds to a specific item's where clauses. Some clauses are not explicitly written but are instead implicitly added in the [`predicates_of`][predicates_of] query, such as `ConstArgHasType` or (some) implied bounds.
+The [`ParamEnv`][penv] is a list of in-scope where-clauses,
+it typically corresponds to a specific item's where clauses.
+Some clauses are not explicitly written but are instead implicitly added in the [`predicates_of`][predicates_of] query,
+such as `ConstArgHasType` or (some) implied bounds.
 
-In most cases `ParamEnv`s are initially created via the [`param_env` query][query] which returns a `ParamEnv` derived from the provided item's where clauses. A `ParamEnv` can also be created with arbitrary sets of clauses that are not derived from a specific item, such as in [`compare_method_predicate_entailment`][method_pred_entailment] where we create a hybrid `ParamEnv` consisting of the impl's where clauses and the trait definition's function's where clauses.
+In most cases `ParamEnv`s are initially created via the [`param_env` query][query] which returns a `ParamEnv` derived from the provided item's where clauses.
+A `ParamEnv` can also be created with arbitrary sets of clauses that are not derived from a specific item,
+such as in [`compare_method_predicate_entailment`][method_pred_entailment] where we create a hybrid `ParamEnv` consisting of the impl's where clauses and the trait definition's function's where clauses.
 
 ---
 
@@ -30,7 +38,9 @@ where
     <T as Trait>::Assoc: Clone,
 {}
 ```
-If we were conceptually inside of `foo` (for example, type-checking or linting it) we would use this `ParamEnv` everywhere that we interact with the type system. This would allow things such as [normalization], evaluating generic constants, and proving where clauses/goals, to rely on `T` being sized, implementing `Trait`, etc.
+If we were conceptually inside of `foo` (for example, type-checking or linting it) we would use this `ParamEnv` everywhere that we interact with the type system.
+This would allow things such as [normalization], evaluating generic constants,
+and proving where clauses/goals, to rely on `T` being sized, implementing `Trait`, etc.
 
 A more concrete example:
 ```rust
@@ -72,9 +82,13 @@ fn foo2<T>(a: T) {
 
 ### Acquiring a `ParamEnv`
 
-Using the wrong [`ParamEnv`][penv] when interacting with the type system can lead to ICEs, illformed programs compiling, or erroring when we shouldn't. See [#82159](https://github.com/rust-lang/rust/pull/82159) and [#82067](https://github.com/rust-lang/rust/pull/82067) as examples of PRs that modified the compiler to use the correct param env and in the process fixed ICEs.
+Using the wrong [`ParamEnv`][penv] when interacting with the type system can lead to ICEs,
+illformed programs compiling, or erroring when we shouldn't.
+See [#82159](https://github.com/rust-lang/rust/pull/82159) and [#82067](https://github.com/rust-lang/rust/pull/82067) as examples of PRs that modified the compiler to use the correct param env and in the process fixed ICEs.
 
-In the large majority of cases, when a `ParamEnv` is required it either already exists somewhere in scope, or above in the call stack and should be passed down. A non exhaustive list of places where you might find an existing `ParamEnv`:
+In the large majority of cases, when a `ParamEnv` is required it either already exists somewhere in scope,
+or above in the call stack and should be passed down.
+A non exhaustive list of places where you might find an existing `ParamEnv`:
 - During typeck `FnCtxt` has a [`param_env` field][fnctxt_param_env]
 - When writing late lints the `LateContext` has a [`param_env` field][latectxt_param_env]
 - During well formedness checking the `WfCheckingCtxt` has a [`param_env` field][wfckctxt_param_env]
@@ -84,14 +98,18 @@ In the large majority of cases, when a `ParamEnv` is required it either already
 
 If you aren't sure if there's a `ParamEnv` in scope somewhere that can be used it can be worth opening a thread in the [`#t-compiler/help`][compiler_help] Zulip channel where someone may be able to point out where a `ParamEnv` can be acquired from.
 
-Manually constructing a `ParamEnv` is typically only needed at the start of some kind of top level analysis (e.g. hir typeck or borrow checking). In such cases there are three ways it can be done:
+Manually constructing a `ParamEnv` is typically only needed at the start of some kind of top level analysis (e.g. hir typeck or borrow checking).
+In such cases there are three ways it can be done:
 - Calling the [`tcx.param_env(def_id)` query][param_env_query] which returns the environment associated with a given definition.
 - Creating an empty environment with [`ParamEnv::empty`][env_empty].
-- Using [`ParamEnv::new`][param_env_new] to construct an env with an arbitrary set of where clauses. Then calling [`traits::normalize_param_env_or_error`][normalize_env_or_error] to handle normalizing and elaborating all the where clauses in the env.
+- Using [`ParamEnv::new`][param_env_new] to construct an env with an arbitrary set of where clauses.
+  Then calling [`traits::normalize_param_env_or_error`][normalize_env_or_error] to handle normalizing and elaborating all the where clauses in the env.
 
 Using the `param_env` query is by far the most common way to construct a `ParamEnv` as most of the time the compiler is performing an analysis as part of some specific definition.
 
-Creating an empty environment with `ParamEnv::empty` is typically only done either in codegen (indirectly via [`TypingEnv::fully_monomorphized`][tenv_mono]), or as part of some analysis that do not expect to ever encounter generic parameters (e.g. various parts of coherence/orphan check).
+Creating an empty environment with `ParamEnv::empty` is typically only done either in codegen (indirectly via [`TypingEnv::fully_monomorphized`][tenv_mono]),
+or as part of some analysis that do not expect to ever encounter generic parameters
+(e.g. various parts of coherence/orphan check).
 
 Creating an env from an arbitrary set of where clauses is usually unnecessary and should only be done if the environment you need does not correspond to an actual item in the source code (e.g. [`compare_method_predicate_entailment`][method_pred_entailment]).
 
@@ -113,11 +131,14 @@ Creating an env from an arbitrary set of where clauses is usually unnecessary an
 
 ### How are `ParamEnv`s constructed
 
-Creating a [`ParamEnv`][pe] is more complicated than simply using the list of where clauses defined on an item as written by the user. We need to both elaborate supertraits into the env and fully normalize all aliases. This logic is handled by [`traits::normalize_param_env_or_error`][normalize_env_or_error] (even though it does not mention anything about elaboration).
+Creating a [`ParamEnv`][pe] is more complicated than simply using the list of where clauses defined on an item as written by the user.
+We need to both elaborate supertraits into the env and fully normalize all aliases.
+This logic is handled by [`traits::normalize_param_env_or_error`][normalize_env_or_error] (even though it does not mention anything about elaboration).
 
 #### Elaborating supertraits
 
-When we have a function such as `fn foo<T: Copy>()` we would like to be able to prove `T: Clone` inside of the function as the `Copy` trait has a `Clone` supertrait. Constructing a `ParamEnv` looks at all of the trait bounds in the env and explicitly adds new where clauses to the `ParamEnv` for any supertraits found on the traits.
+When we have a function such as `fn foo<T: Copy>()` we would like to be able to prove `T: Clone` inside of the function as the `Copy` trait has a `Clone` supertrait.
+Constructing a `ParamEnv` looks at all of the trait bounds in the env and explicitly adds new where clauses to the `ParamEnv` for any supertraits found on the traits.
 
 A concrete example would be the following function:
 ```rust
@@ -133,13 +154,16 @@ fn bar<T: Copy + Trait>(a: T) {
 fn requires_impl<T: Clone + SuperSuperTrait>(a: T) {}
 ```
 
-If we did not elaborate the env then the `requires_impl` call would fail to typecheck as we would not be able to prove `T: Clone` or `T: SuperSuperTrait`. In practice we elaborate the env which means that `bar`'s `ParamEnv` is actually:
+If we did not elaborate the env then the `requires_impl` call would fail to typecheck as we would not be able to prove `T: Clone` or `T: SuperSuperTrait`.
+In practice we elaborate the env which means that `bar`'s `ParamEnv` is actually:
 `[T: Sized, T: Copy, T: Clone, T: Trait, T: SuperTrait, T: SuperSuperTrait]`
 This allows us to prove `T: Clone` and `T: SuperSuperTrait` when type checking `bar`.
 
 The `Clone` trait has a `Sized` supertrait however we do not end up with two `T: Sized` bounds in the env (one for the supertrait and one for the implicitly added `T: Sized` bound) as the elaboration process (implemented via [`util::elaborate`][elaborate]) deduplicates where clauses.
 
-A side effect of this is that even if no actual elaboration of supertraits takes place, the existing where clauses in the env are _also_ deduplicated. See the following example:
+A side effect of this is that even if no actual elaboration of supertraits takes place,
+the existing where clauses in the env are _also_ deduplicated.
+See the following example:
 ```rust
 trait Trait {}
 // The unelaborated `ParamEnv` would be:
@@ -156,7 +180,8 @@ The [next-gen trait solver][next-gen-solver] also requires this elaboration to t
 
 #### Normalizing all bounds
 
-In the old trait solver the where clauses stored in `ParamEnv` are required to be fully normalized as otherwise the trait solver will not function correctly. A concrete example of needing to normalize the `ParamEnv` is the following:
+In the old trait solver the where clauses stored in `ParamEnv` are required to be fully normalized as otherwise the trait solver will not function correctly.
+A concrete example of needing to normalize the `ParamEnv` is the following:
 ```rust
 trait Trait<T> {
     type Assoc;
@@ -182,11 +207,14 @@ where
 fn requires_impl<U: Trait<u32>>(_: U) {}
 ```
 
-As humans we can tell that `<T as Other>::Bar` is equal to `u32` so the trait bound on `U` is equivalent to `U: Trait<u32>`. In practice trying to prove `U: Trait<u32>` in the old solver in this environment would fail as it is unable to determine that `<T as Other>::Bar` is equal to `u32`.
+As humans we can tell that `<T as Other>::Bar` is equal to `u32` so the trait bound on `U` is equivalent to `U: Trait<u32>`.
+In practice trying to prove `U: Trait<u32>` in the old solver in this environment would fail as it is unable to determine that `<T as Other>::Bar` is equal to `u32`.
 
 To work around this we normalize `ParamEnv`'s after constructing them so that `foo`'s `ParamEnv` is actually: `[T: Sized, U: Sized, U: Trait<u32>]` which means the trait solver is now able to use the `U: Trait<u32>` in the `ParamEnv` to determine that the trait bound `U: Trait<u32>` holds.
 
-This workaround does not work in all cases as normalizing associated types requires a `ParamEnv` which introduces a bootstrapping problem. We need a normalized `ParamEnv` in order for normalization to give correct results, but we need to normalize to get that `ParamEnv`. Currently we normalize the `ParamEnv` once using the unnormalized param env and it tends to give okay results in practice even though there are some examples where this breaks ([example]).
+This workaround does not work in all cases as normalizing associated types requires a `ParamEnv` which introduces a bootstrapping problem.
+We need a normalized `ParamEnv` in order for normalization to give correct results, but we need to normalize to get that `ParamEnv`.
+Currently we normalize the `ParamEnv` once using the unnormalized param env and it tends to give okay results in practice even though there are some examples where this breaks ([example]).
 
 In the next-gen trait solver the requirement for all where clauses in the `ParamEnv` to be fully normalized is not present and so we do not normalize when constructing `ParamEnv`s.
 
@@ -196,9 +224,12 @@ In the next-gen trait solver the requirement for all where clauses in the `Param
 
 ## Typing Modes
 
-Depending on what context we are performing type system operations in, different behaviour may be required. For example during coherence there are stronger requirements about when we can consider goals to not hold or when we can consider types to be unequal.
+Depending on what context we are performing type system operations in,
+different behaviour may be required.
+For example during coherence there are stronger requirements about when we can consider goals to not hold or when we can consider types to be unequal.
 
-Tracking which "phase" of the compiler type system operations are being performed in is done by the [`TypingMode`][tmode] enum. The documentation on the `TypingMode` enum is quite good so instead of repeating it here verbatim we would recommend reading the API documentation directly.
+Tracking which "phase" of the compiler type system operations are being performed in is done by the [`TypingMode`][tmode] enum.
+The documentation on the `TypingMode` enum is quite good so instead of repeating it here verbatim we would recommend reading the API documentation directly.
 
 [penv]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.ParamEnv.html
 [tenv]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TypingEnv.html

From 0dc233fc56a1078c3eb57af9cd8460e2b1763f10 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Sat, 6 Sep 2025 06:26:08 +0200
Subject: [PATCH 0566/1889] point to Compiler team docs on Forge

---
 src/doc/rustc-dev-guide/src/compiler-team.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/doc/rustc-dev-guide/src/compiler-team.md b/src/doc/rustc-dev-guide/src/compiler-team.md
index 6be52833f3964..896d9e6f6d94c 100644
--- a/src/doc/rustc-dev-guide/src/compiler-team.md
+++ b/src/doc/rustc-dev-guide/src/compiler-team.md
@@ -1,10 +1,14 @@
 # About the compiler team
 
+> NOTE:
+> There exists much detail about the team [on Forge], making most of the following obsolete.
+
 rustc is maintained by the [Rust compiler team][team]. The people who belong to
 this team collectively work to track regressions and implement new features.
 Members of the Rust compiler team are people who have made significant
 contributions to rustc and its design.
 
+[on Forge]: https://forge.rust-lang.org/compiler
 [team]: https://www.rust-lang.org/governance/teams/compiler
 
 ## Discussion

From a5bb60b19c1113a751c7dac00ea8ae0ac20cd15f Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Sat, 6 Sep 2025 13:07:53 +0800
Subject: [PATCH 0567/1889] Add allow `else` keyword completion in LetStmt

Example
---
```rust
fn foo() {
    let _ = 2 el$0
}
```
->
```rust
fn foo() {
    let _ = 2 else {
        $0
    };
}
```
---
 .../ide-completion/src/completions/expr.rs    |   6 +-
 .../ide-completion/src/completions/keyword.rs |  40 +++++
 .../crates/ide-completion/src/context.rs      |   1 +
 .../ide-completion/src/context/analysis.rs    |  41 +++--
 .../ide-completion/src/tests/expression.rs    | 149 ++++++++++++++++++
 5 files changed, 220 insertions(+), 17 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/expr.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/expr.rs
index 1972f166134a4..2c7d9e97c44e7 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/expr.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/expr.rs
@@ -61,6 +61,7 @@ pub(crate) fn complete_expr_path(
         after_if_expr,
         in_condition,
         incomplete_let,
+        after_incomplete_let,
         in_value,
         ref ref_expr_parent,
         after_amp,
@@ -385,8 +386,11 @@ pub(crate) fn complete_expr_path(
                         add_keyword("let", "let $1 = $0;");
                     }
 
-                    if after_if_expr {
+                    if after_if_expr || after_incomplete_let {
                         add_keyword("else", "else {\n    $0\n}");
+                    }
+
+                    if after_if_expr {
                         add_keyword("else if", "else if $1 {\n    $0\n}");
                     }
 
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/keyword.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/keyword.rs
index aea4e119f2076..b3d770997ab0c 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/keyword.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/keyword.rs
@@ -247,6 +247,46 @@ fn main() {
 "#,
         );
 
+        check_edit(
+            "else",
+            r#"
+fn main() {
+    let x = if true {
+        ()
+    } $0
+    let y = 92;
+}
+"#,
+            r#"
+fn main() {
+    let x = if true {
+        ()
+    } else {
+    $0
+};
+    let y = 92;
+}
+"#,
+        );
+
+        check_edit(
+            "else",
+            r#"
+fn main() {
+    let x = 2 $0
+    let y = 92;
+}
+"#,
+            r#"
+fn main() {
+    let x = 2 else {
+    $0
+};
+    let y = 92;
+}
+"#,
+        );
+
         check_edit(
             "loop",
             r#"
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context.rs
index 265462d220169..007475688d209 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context.rs
@@ -147,6 +147,7 @@ pub(crate) struct PathExprCtx<'db> {
     /// Whether this expression is the direct condition of an if or while expression
     pub(crate) in_condition: bool,
     pub(crate) incomplete_let: bool,
+    pub(crate) after_incomplete_let: bool,
     pub(crate) in_value: bool,
     pub(crate) ref_expr_parent: Option<ast::RefExpr>,
     pub(crate) after_amp: bool,
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
index 17978b4c10798..33b98a33cabf6 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
@@ -947,25 +947,29 @@ fn classify_name_ref<'db>(
             None
         }
     };
-    let after_if_expr = |node: SyntaxNode| {
-        let prev_expr = (|| {
-            let node = match node.parent().and_then(ast::ExprStmt::cast) {
-                Some(stmt) => stmt.syntax().clone(),
-                None => node,
-            };
-            let prev_sibling = non_trivia_sibling(node.into(), Direction::Prev)?.into_node()?;
+    let prev_expr = |node: SyntaxNode| {
+        let node = match node.parent().and_then(ast::ExprStmt::cast) {
+            Some(stmt) => stmt.syntax().clone(),
+            None => node,
+        };
+        let prev_sibling = non_trivia_sibling(node.into(), Direction::Prev)?.into_node()?;
 
-            match_ast! {
-                match prev_sibling {
-                    ast::ExprStmt(stmt) => stmt.expr().filter(|_| stmt.semicolon_token().is_none()),
-                    ast::LetStmt(stmt) => stmt.initializer().filter(|_| stmt.semicolon_token().is_none()),
-                    ast::Expr(expr) => Some(expr),
-                    _ => None,
-                }
+        match_ast! {
+            match prev_sibling {
+                ast::ExprStmt(stmt) => stmt.expr().filter(|_| stmt.semicolon_token().is_none()),
+                ast::LetStmt(stmt) => stmt.initializer().filter(|_| stmt.semicolon_token().is_none()),
+                ast::Expr(expr) => Some(expr),
+                _ => None,
             }
-        })();
+        }
+    };
+    let after_if_expr = |node: SyntaxNode| {
+        let prev_expr = prev_expr(node);
         matches!(prev_expr, Some(ast::Expr::IfExpr(_)))
     };
+    let after_incomplete_let = |node: SyntaxNode| {
+        prev_expr(node).and_then(|it| it.syntax().parent()).and_then(ast::LetStmt::cast)
+    };
 
     // We do not want to generate path completions when we are sandwiched between an item decl signature and its body.
     // ex. trait Foo $0 {}
@@ -1265,10 +1269,14 @@ fn classify_name_ref<'db>(
         };
         let is_func_update = func_update_record(it);
         let in_condition = is_in_condition(&expr);
+        let after_incomplete_let = after_incomplete_let(it.clone()).is_some();
+        let incomplete_expr_stmt =
+            it.parent().and_then(ast::ExprStmt::cast).map(|it| it.semicolon_token().is_none());
         let incomplete_let = it
             .parent()
             .and_then(ast::LetStmt::cast)
-            .is_some_and(|it| it.semicolon_token().is_none());
+            .is_some_and(|it| it.semicolon_token().is_none())
+            || after_incomplete_let && incomplete_expr_stmt.unwrap_or(true);
         let in_value = it.parent().and_then(Either::<ast::LetStmt, ast::ArgList>::cast).is_some();
         let impl_ = fetch_immediate_impl(sema, original_file, expr.syntax());
 
@@ -1292,6 +1300,7 @@ fn classify_name_ref<'db>(
                 self_param,
                 in_value,
                 incomplete_let,
+                after_incomplete_let,
                 impl_,
                 in_match_guard,
             },
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs b/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
index 7a0d00444129f..56fbd91a60fcc 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
@@ -450,6 +450,155 @@ fn completes_in_let_initializer() {
     )
 }
 
+#[test]
+fn completes_let_else() {
+    check(
+        r#"fn main() { let _ = 2 $0 }"#,
+        expect![[r#"
+            fn main() fn()
+            bt u32     u32
+            kw async
+            kw const
+            kw crate::
+            kw else
+            kw enum
+            kw extern
+            kw false
+            kw fn
+            kw for
+            kw if
+            kw if let
+            kw impl
+            kw impl for
+            kw let
+            kw letm
+            kw loop
+            kw match
+            kw mod
+            kw return
+            kw self::
+            kw static
+            kw struct
+            kw trait
+            kw true
+            kw type
+            kw union
+            kw unsafe
+            kw use
+            kw while
+            kw while let
+            sn macro_rules
+            sn pd
+            sn ppd
+        "#]],
+    );
+
+    check(
+        r#"fn main() { let _ = 2 el$0 }"#,
+        expect![[r#"
+            fn main() fn()
+            bt u32     u32
+            kw async
+            kw const
+            kw crate::
+            kw else
+            kw enum
+            kw extern
+            kw false
+            kw fn
+            kw for
+            kw if
+            kw if let
+            kw impl
+            kw impl for
+            kw let
+            kw letm
+            kw loop
+            kw match
+            kw mod
+            kw return
+            kw self::
+            kw static
+            kw struct
+            kw trait
+            kw true
+            kw type
+            kw union
+            kw unsafe
+            kw use
+            kw while
+            kw while let
+            sn macro_rules
+            sn pd
+            sn ppd
+        "#]],
+    );
+
+    check_edit(
+        "else",
+        r#"
+fn main() {
+    let _ = 2 $0
+}
+"#,
+        r#"
+fn main() {
+    let _ = 2 else {
+    $0
+};
+}
+"#,
+    );
+
+    check_edit(
+        "else",
+        r#"
+fn main() {
+    let _ = 2 el$0
+}
+"#,
+        r#"
+fn main() {
+    let _ = 2 else {
+    $0
+};
+}
+"#,
+    );
+
+    check_edit(
+        "else",
+        r#"
+fn main() {
+    let _ = 2 $0;
+}
+"#,
+        r#"
+fn main() {
+    let _ = 2 else {
+    $0
+};
+}
+"#,
+    );
+
+    check_edit(
+        "else",
+        r#"
+fn main() {
+    let _ = 2 el$0;
+}
+"#,
+        r#"
+fn main() {
+    let _ = 2 else {
+    $0
+};
+}
+"#,
+    );
+}
+
 #[test]
 fn completes_after_ref_expr() {
     check(

From 5f372fe7d18efd9770d0f9b23895a049c28dcc41 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Sat, 6 Sep 2025 16:29:26 +0800
Subject: [PATCH 0568/1889] bump-stage0: pick highest common `toml` version,
 add a workaround

- We pick the higest common `toml` version used in the r-l/r workspace
  to avoid introducing Yet Another `toml` `0.x` version, which happens
  to be `0.8.23` as of the time of writing.
- We introduce a byte-buffer-to-string workaround for the `toml 0.8.*`
  series that do not have the `toml 0.9.*` series's `toml::from_slice`
  API yet. Not efficient, but this is not perf-critical so it's fine.
---
 Cargo.lock                        | 2 +-
 src/tools/bump-stage0/Cargo.toml  | 2 +-
 src/tools/bump-stage0/src/main.rs | 6 +++++-
 3 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index c4c96f1569b6f..aa2bdb3853616 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -336,7 +336,7 @@ dependencies = [
  "curl",
  "indexmap",
  "serde",
- "toml 0.7.8",
+ "toml 0.8.23",
 ]
 
 [[package]]
diff --git a/src/tools/bump-stage0/Cargo.toml b/src/tools/bump-stage0/Cargo.toml
index b7f3625da91b7..79097f2c18916 100644
--- a/src/tools/bump-stage0/Cargo.toml
+++ b/src/tools/bump-stage0/Cargo.toml
@@ -11,4 +11,4 @@ build_helper = { path = "../../build_helper" }
 curl = "0.4.38"
 indexmap = { version = "2.0.0", features = ["serde"] }
 serde = { version = "1.0.125", features = ["derive"] }
-toml = "0.7"
+toml = "0.8.23"
diff --git a/src/tools/bump-stage0/src/main.rs b/src/tools/bump-stage0/src/main.rs
index 680437cce4faa..faed748785f46 100644
--- a/src/tools/bump-stage0/src/main.rs
+++ b/src/tools/bump-stage0/src/main.rs
@@ -185,7 +185,11 @@ fn fetch_manifest(
         format!("{}/dist/channel-rust-{}.toml", config.dist_server, channel)
     };
 
-    Ok(toml::from_slice(&http_get(&url)?)?)
+    // FIXME: on newer `toml` (>= `0.9.*`), use `toml::from_slice`. For now, we use the most recent
+    // `toml` available in-tree which is `0.8.*`, so we have to do an additional dance here.
+    let response = http_get(&url)?;
+    let response = String::from_utf8(response)?;
+    Ok(toml::from_str(&response)?)
 }
 
 fn http_get(url: &str) -> Result<Vec<u8>, Error> {

From d5e61216a74efede682f88c65a9fe59769848c76 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Sat, 6 Sep 2025 16:11:26 +0800
Subject: [PATCH 0569/1889] bootstrap: add check step for
 `src/tools/bump-stage0`

---
 src/bootstrap/src/core/build_steps/check.rs | 6 ++++++
 src/bootstrap/src/core/builder/mod.rs       | 1 +
 2 files changed, 7 insertions(+)

diff --git a/src/bootstrap/src/core/build_steps/check.rs b/src/bootstrap/src/core/build_steps/check.rs
index 49d12b64da510..043457f64e57a 100644
--- a/src/bootstrap/src/core/build_steps/check.rs
+++ b/src/bootstrap/src/core/build_steps/check.rs
@@ -839,3 +839,9 @@ tool_check_step!(Linkchecker {
     mode: |_builder| Mode::ToolBootstrap,
     default: false
 });
+
+tool_check_step!(BumpStage0 {
+    path: "src/tools/bump-stage0",
+    mode: |_builder| Mode::ToolBootstrap,
+    default: false
+});
diff --git a/src/bootstrap/src/core/builder/mod.rs b/src/bootstrap/src/core/builder/mod.rs
index 627085df812c5..a818a5c756cd1 100644
--- a/src/bootstrap/src/core/builder/mod.rs
+++ b/src/bootstrap/src/core/builder/mod.rs
@@ -1061,6 +1061,7 @@ impl<'a> Builder<'a> {
                 check::FeaturesStatusDump,
                 check::CoverageDump,
                 check::Linkchecker,
+                check::BumpStage0,
                 // This has special staging logic, it may run on stage 1 while others run on stage 0.
                 // It takes quite some time to build stage 1, so put this at the end.
                 //

From 312a1240a3cde43ca16e5275457688e47d7bccd8 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Sat, 6 Sep 2025 16:12:08 +0800
Subject: [PATCH 0570/1889] ci: check `src/tools/bump-stage0` in `pr-check-2`

To catch obvious build failures of the `src/tools/bump-stage0` early,
before we find out it can't even build when we really need it to work.
---
 src/ci/docker/host-x86_64/pr-check-2/Dockerfile | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/ci/docker/host-x86_64/pr-check-2/Dockerfile b/src/ci/docker/host-x86_64/pr-check-2/Dockerfile
index 8073b8efb46f3..d6470e4deb8d1 100644
--- a/src/ci/docker/host-x86_64/pr-check-2/Dockerfile
+++ b/src/ci/docker/host-x86_64/pr-check-2/Dockerfile
@@ -28,6 +28,7 @@ RUN sh /scripts/sccache.sh
 
 ENV SCRIPT \
         python3 ../x.py check && \
+        python3 ../x.py check src/tools/bump-stage0 && \
         python3 ../x.py clippy ci --stage 2 && \
         python3 ../x.py test --stage 1 core alloc std test proc_macro && \
         python3 ../x.py test --stage 1 src/tools/compiletest && \

From 027135976849da34250d7638502bcc2a24f741d7 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Fri, 5 Sep 2025 09:32:56 +0000
Subject: [PATCH 0571/1889] Make the allocator shim participate in LTO again

---
 compiler/rustc_codegen_ssa/src/back/lto.rs   | 14 -------
 compiler/rustc_codegen_ssa/src/back/write.rs | 40 +++++++++++++++-----
 compiler/rustc_codegen_ssa/src/base.rs       | 11 +++++-
 3 files changed, 39 insertions(+), 26 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/lto.rs b/compiler/rustc_codegen_ssa/src/back/lto.rs
index f4a9037940a67..e6df6a2469f37 100644
--- a/compiler/rustc_codegen_ssa/src/back/lto.rs
+++ b/compiler/rustc_codegen_ssa/src/back/lto.rs
@@ -1,7 +1,6 @@
 use std::ffi::CString;
 use std::sync::Arc;
 
-use rustc_ast::expand::allocator::AllocatorKind;
 use rustc_data_structures::memmap::Mmap;
 use rustc_hir::def_id::{CrateNum, LOCAL_CRATE};
 use rustc_middle::middle::exported_symbols::{ExportedSymbol, SymbolExportInfo, SymbolExportLevel};
@@ -96,19 +95,6 @@ pub(super) fn exported_symbols_for_lto(
             .filter_map(|&(s, info): &(ExportedSymbol<'_>, SymbolExportInfo)| {
                 if info.level.is_below_threshold(export_threshold) || info.used {
                     Some(symbol_name_for_instance_in_crate(tcx, s, cnum))
-                } else if export_threshold == SymbolExportLevel::C
-                    && info.rustc_std_internal_symbol
-                    && let Some(AllocatorKind::Default) = allocator_kind_for_codegen(tcx)
-                {
-                    // Export the __rdl_* exports for usage by the allocator shim when not using
-                    // #[global_allocator]. Most of the conditions above are only used to avoid
-                    // unnecessary expensive symbol_name_for_instance_in_crate calls.
-                    let sym = symbol_name_for_instance_in_crate(tcx, s, cnum);
-                    if sym.contains("__rdl_") || sym.contains("__rg_oom") {
-                        Some(sym)
-                    } else {
-                        None
-                    }
                 } else {
                     None
                 }
diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
index f637e7f58dbf7..afda7226fdd12 100644
--- a/compiler/rustc_codegen_ssa/src/back/write.rs
+++ b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -334,6 +334,7 @@ pub struct CodegenContext<B: WriteBackendMethods> {
     pub output_filenames: Arc<OutputFilenames>,
     pub invocation_temp: Option<String>,
     pub module_config: Arc<ModuleConfig>,
+    pub allocator_config: Arc<ModuleConfig>,
     pub tm_factory: TargetMachineFactoryFn<B>,
     pub msvc_imps_needed: bool,
     pub is_pe_coff: bool,
@@ -794,12 +795,19 @@ pub(crate) fn compute_per_cgu_lto_type(
     sess_lto: &Lto,
     opts: &config::Options,
     sess_crate_types: &[CrateType],
+    module_kind: ModuleKind,
 ) -> ComputedLtoType {
     // If the linker does LTO, we don't have to do it. Note that we
     // keep doing full LTO, if it is requested, as not to break the
     // assumption that the output will be a single module.
     let linker_does_lto = opts.cg.linker_plugin_lto.enabled();
 
+    // When we're automatically doing ThinLTO for multi-codegen-unit
+    // builds we don't actually want to LTO the allocator module if
+    // it shows up. This is due to various linker shenanigans that
+    // we'll encounter later.
+    let is_allocator = module_kind == ModuleKind::Allocator;
+
     // We ignore a request for full crate graph LTO if the crate type
     // is only an rlib, as there is no full crate graph to process,
     // that'll happen later.
@@ -811,7 +819,7 @@ pub(crate) fn compute_per_cgu_lto_type(
     let is_rlib = matches!(sess_crate_types, [CrateType::Rlib]);
 
     match sess_lto {
-        Lto::ThinLocal if !linker_does_lto => ComputedLtoType::Thin,
+        Lto::ThinLocal if !linker_does_lto && !is_allocator => ComputedLtoType::Thin,
         Lto::Thin if !linker_does_lto && !is_rlib => ComputedLtoType::Thin,
         Lto::Fat if !is_rlib => ComputedLtoType::Fat,
         _ => ComputedLtoType::No,
@@ -825,18 +833,23 @@ fn execute_optimize_work_item<B: ExtraBackendMethods>(
     let dcx = cgcx.create_dcx();
     let dcx = dcx.handle();
 
-    B::optimize(cgcx, dcx, &mut module, &cgcx.module_config);
+    let module_config = match module.kind {
+        ModuleKind::Regular => &cgcx.module_config,
+        ModuleKind::Allocator => &cgcx.allocator_config,
+    };
+
+    B::optimize(cgcx, dcx, &mut module, module_config);
 
     // After we've done the initial round of optimizations we need to
     // decide whether to synchronously codegen this module or ship it
     // back to the coordinator thread for further LTO processing (which
     // has to wait for all the initial modules to be optimized).
 
-    let lto_type = compute_per_cgu_lto_type(&cgcx.lto, &cgcx.opts, &cgcx.crate_types);
+    let lto_type = compute_per_cgu_lto_type(&cgcx.lto, &cgcx.opts, &cgcx.crate_types, module.kind);
 
     // If we're doing some form of incremental LTO then we need to be sure to
     // save our module to disk first.
-    let bitcode = if cgcx.module_config.emit_pre_lto_bc {
+    let bitcode = if module_config.emit_pre_lto_bc {
         let filename = pre_lto_bitcode_filename(&module.name);
         cgcx.incr_comp_session_dir.as_ref().map(|path| path.join(&filename))
     } else {
@@ -845,7 +858,7 @@ fn execute_optimize_work_item<B: ExtraBackendMethods>(
 
     match lto_type {
         ComputedLtoType::No => {
-            let module = B::codegen(cgcx, module, &cgcx.module_config);
+            let module = B::codegen(cgcx, module, module_config);
             WorkItemResult::Finished(module)
         }
         ComputedLtoType::Thin => {
@@ -1133,6 +1146,7 @@ fn start_executing_work<B: ExtraBackendMethods>(
         diag_emitter: shared_emitter.clone(),
         output_filenames: Arc::clone(tcx.output_filenames(())),
         module_config: regular_config,
+        allocator_config,
         tm_factory: backend.target_machine_factory(tcx.sess, ol, backend_features),
         msvc_imps_needed: msvc_imps_needed(tcx),
         is_pe_coff: tcx.sess.target.is_like_windows,
@@ -1147,11 +1161,6 @@ fn start_executing_work<B: ExtraBackendMethods>(
         invocation_temp: sess.invocation_temp.clone(),
     };
 
-    let compiled_allocator_module = allocator_module.map(|mut allocator_module| {
-        B::optimize(&cgcx, tcx.sess.dcx(), &mut allocator_module, &allocator_config);
-        B::codegen(&cgcx, allocator_module, &allocator_config)
-    });
-
     // This is the "main loop" of parallel work happening for parallel codegen.
     // It's here that we manage parallelism, schedule work, and work with
     // messages coming from clients.
@@ -1331,6 +1340,17 @@ fn start_executing_work<B: ExtraBackendMethods>(
 
         let mut llvm_start_time: Option<VerboseTimingGuard<'_>> = None;
 
+        let compiled_allocator_module = allocator_module.and_then(|allocator_module| {
+            match execute_optimize_work_item(&cgcx, allocator_module) {
+                WorkItemResult::Finished(compiled_module) => return Some(compiled_module),
+                WorkItemResult::NeedsFatLto(fat_lto_input) => needs_fat_lto.push(fat_lto_input),
+                WorkItemResult::NeedsThinLto(name, thin_buffer) => {
+                    needs_thin_lto.push((name, thin_buffer))
+                }
+            }
+            None
+        });
+
         // Run the message loop while there's still anything that needs message
         // processing. Note that as soon as codegen is aborted we simply want to
         // wait for all existing work to finish, so many of the conditions here
diff --git a/compiler/rustc_codegen_ssa/src/base.rs b/compiler/rustc_codegen_ssa/src/base.rs
index a9a2ae1b3dbca..45b028aa8eff2 100644
--- a/compiler/rustc_codegen_ssa/src/base.rs
+++ b/compiler/rustc_codegen_ssa/src/base.rs
@@ -46,7 +46,9 @@ use crate::meth::load_vtable;
 use crate::mir::operand::OperandValue;
 use crate::mir::place::PlaceRef;
 use crate::traits::*;
-use crate::{CachedModuleCodegen, CodegenLintLevels, CrateInfo, ModuleCodegen, errors, meth, mir};
+use crate::{
+    CachedModuleCodegen, CodegenLintLevels, CrateInfo, ModuleCodegen, ModuleKind, errors, meth, mir,
+};
 
 pub(crate) fn bin_op_to_icmp_predicate(op: BinOp, signed: bool) -> IntPredicate {
     match (op, signed) {
@@ -1124,7 +1126,12 @@ pub fn determine_cgu_reuse<'tcx>(tcx: TyCtxt<'tcx>, cgu: &CodegenUnit<'tcx>) ->
         // We can re-use either the pre- or the post-thinlto state. If no LTO is
         // being performed then we can use post-LTO artifacts, otherwise we must
         // reuse pre-LTO artifacts
-        match compute_per_cgu_lto_type(&tcx.sess.lto(), &tcx.sess.opts, tcx.crate_types()) {
+        match compute_per_cgu_lto_type(
+            &tcx.sess.lto(),
+            &tcx.sess.opts,
+            tcx.crate_types(),
+            ModuleKind::Regular,
+        ) {
             ComputedLtoType::No => CguReuse::PostLto,
             _ => CguReuse::PreLto,
         }

From 9fc8374c2c4b9b04820999153d9b66f7a3df4ce0 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 6 Sep 2025 11:07:19 +0200
Subject: [PATCH 0572/1889] miri std tests: skip all of sys::

---
 src/bootstrap/mk/Makefile.in | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/bootstrap/mk/Makefile.in b/src/bootstrap/mk/Makefile.in
index 82c05092dfa58..03caa764ccf43 100644
--- a/src/bootstrap/mk/Makefile.in
+++ b/src/bootstrap/mk/Makefile.in
@@ -76,7 +76,7 @@ check-aux:
 		library/std \
 		$(BOOTSTRAP_ARGS) \
 		-- \
-		--skip fs:: --skip net:: --skip process:: --skip sys::fd:: --skip sys::pal::
+		--skip fs:: --skip net:: --skip process:: --skip sys::
 	# Also test some very target-specific modules on other targets
 	# (making sure to cover an i686 target as well).
 	$(Q)MIRIFLAGS="-Zmiri-disable-isolation" BOOTSTRAP_SKIP_TARGET_SANITY=1 \

From 1f8667982014babf392f08d45bb6d7bb1bc27d94 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Fri, 5 Sep 2025 23:12:56 +0200
Subject: [PATCH 0573/1889] fix(transmute_ptr_to_ref): don't suggest `.cast`
 when to-type is DST

---
 .../src/transmute/transmute_ptr_to_ref.rs     | 24 ++++++++-
 tests/ui/transmute_ptr_to_ref.fixed           | 29 +++++++++++
 tests/ui/transmute_ptr_to_ref.rs              | 29 +++++++++++
 tests/ui/transmute_ptr_to_ref.stderr          | 50 ++++++++++++++++++-
 4 files changed, 130 insertions(+), 2 deletions(-)

diff --git a/clippy_lints/src/transmute/transmute_ptr_to_ref.rs b/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
index 44fa2121341dd..e67ab6a73d269 100644
--- a/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
+++ b/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
@@ -36,7 +36,19 @@ pub(super) fn check<'tcx>(
 
                     let sugg = if let Some(ty) = get_explicit_type(path) {
                         let ty_snip = snippet_with_applicability(cx, ty.span, "..", &mut app);
-                        if msrv.meets(cx, msrvs::POINTER_CAST) {
+                        if !to_ref_ty.is_sized(cx.tcx, cx.typing_env()) {
+                            // We can't suggest `.cast()`, because that requires `to_ref_ty` to be Sized.
+                            if from_ptr_ty.has_erased_regions() {
+                                // We can't suggest `as *mut/const () as *mut/const to_ref_ty`, because the former is a
+                                // thin pointer, whereas the latter is a wide pointer, due of its pointee, `to_ref_ty`,
+                                // being !Sized.
+                                //
+                                // The only remaining option is be to skip `*mut/const ()`, but that might not be safe
+                                // to do because of the erased regions in `from_ptr_ty`, so reduce the applicability.
+                                app = Applicability::MaybeIncorrect;
+                            }
+                            sugg::make_unop(deref, arg.as_ty(format!("{cast} {ty_snip}"))).to_string()
+                        } else if msrv.meets(cx, msrvs::POINTER_CAST) {
                             format!("{deref}{}.cast::<{ty_snip}>()", arg.maybe_paren())
                         } else if from_ptr_ty.has_erased_regions() {
                             sugg::make_unop(deref, arg.as_ty(format!("{cast} () as {cast} {ty_snip}"))).to_string()
@@ -46,6 +58,16 @@ pub(super) fn check<'tcx>(
                     } else if *from_ptr_ty == *to_ref_ty {
                         if !from_ptr_ty.has_erased_regions() {
                             sugg::make_unop(deref, arg).to_string()
+                        } else if !to_ref_ty.is_sized(cx.tcx, cx.typing_env()) {
+                            // 1. We can't suggest `.cast()`, because that requires `to_ref_ty` to be Sized.
+                            // 2. We can't suggest `as *mut/const () as *mut/const to_ref_ty`, because the former is a
+                            //    thin pointer, whereas the latter is a wide pointer, due of its pointee, `to_ref_ty`,
+                            //    being !Sized.
+                            //
+                            // The only remaining option is be to skip `*mut/const ()`, but that might not be safe to do
+                            // because of the erased regions in `from_ptr_ty`, so reduce the applicability.
+                            app = Applicability::MaybeIncorrect;
+                            sugg::make_unop(deref, arg.as_ty(format!("{cast} {to_ref_ty}"))).to_string()
                         } else if msrv.meets(cx, msrvs::POINTER_CAST) {
                             format!("{deref}{}.cast::<{to_ref_ty}>()", arg.maybe_paren())
                         } else {
diff --git a/tests/ui/transmute_ptr_to_ref.fixed b/tests/ui/transmute_ptr_to_ref.fixed
index 68839fd04c56b..c130575df9607 100644
--- a/tests/ui/transmute_ptr_to_ref.fixed
+++ b/tests/ui/transmute_ptr_to_ref.fixed
@@ -106,4 +106,33 @@ fn under_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
     }
 }
 
+// handle DSTs
+fn issue13357(ptr: *const [i32], s_ptr: *const &str, a_s_ptr: *const [&str]) {
+    unsafe {
+        // different types, without erased regions
+        let _ = &*(ptr as *const [u32]);
+        //~^ transmute_ptr_to_ref
+        let _: &[u32] = &*(ptr as *const [u32]);
+        //~^ transmute_ptr_to_ref
+
+        // different types, with erased regions
+        let _ = &*(a_s_ptr as *const [&[u8]]);
+        //~^ transmute_ptr_to_ref
+        let _: &[&[u8]] = &*(a_s_ptr as *const [&[u8]]);
+        //~^ transmute_ptr_to_ref
+
+        // same type, without erased regions
+        let _ = &*(ptr as *const [i32]);
+        //~^ transmute_ptr_to_ref
+        let _: &[i32] = &*ptr;
+        //~^ transmute_ptr_to_ref
+
+        // same type, with erased regions
+        let _ = &*(a_s_ptr as *const [&str]);
+        //~^ transmute_ptr_to_ref
+        let _: &[&str] = &*(a_s_ptr as *const [&str]);
+        //~^ transmute_ptr_to_ref
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/transmute_ptr_to_ref.rs b/tests/ui/transmute_ptr_to_ref.rs
index b41b7cd217947..f79d54234a2c9 100644
--- a/tests/ui/transmute_ptr_to_ref.rs
+++ b/tests/ui/transmute_ptr_to_ref.rs
@@ -106,4 +106,33 @@ fn under_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
     }
 }
 
+// handle DSTs
+fn issue13357(ptr: *const [i32], s_ptr: *const &str, a_s_ptr: *const [&str]) {
+    unsafe {
+        // different types, without erased regions
+        let _ = core::mem::transmute::<_, &[u32]>(ptr);
+        //~^ transmute_ptr_to_ref
+        let _: &[u32] = core::mem::transmute(ptr);
+        //~^ transmute_ptr_to_ref
+
+        // different types, with erased regions
+        let _ = core::mem::transmute::<_, &[&[u8]]>(a_s_ptr);
+        //~^ transmute_ptr_to_ref
+        let _: &[&[u8]] = core::mem::transmute(a_s_ptr);
+        //~^ transmute_ptr_to_ref
+
+        // same type, without erased regions
+        let _ = core::mem::transmute::<_, &[i32]>(ptr);
+        //~^ transmute_ptr_to_ref
+        let _: &[i32] = core::mem::transmute(ptr);
+        //~^ transmute_ptr_to_ref
+
+        // same type, with erased regions
+        let _ = core::mem::transmute::<_, &[&str]>(a_s_ptr);
+        //~^ transmute_ptr_to_ref
+        let _: &[&str] = core::mem::transmute(a_s_ptr);
+        //~^ transmute_ptr_to_ref
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/transmute_ptr_to_ref.stderr b/tests/ui/transmute_ptr_to_ref.stderr
index 520f804d264a2..3f404d295fef0 100644
--- a/tests/ui/transmute_ptr_to_ref.stderr
+++ b/tests/ui/transmute_ptr_to_ref.stderr
@@ -133,5 +133,53 @@ error: transmute from a pointer type (`*const &u32`) to a reference type (`&&u32
 LL |             _ => std::mem::transmute::<_, &&'b u32>(x),
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(x as *const () as *const &'b u32)`
 
-error: aborting due to 22 previous errors
+error: transmute from a pointer type (`*const [i32]`) to a reference type (`&[u32]`)
+  --> tests/ui/transmute_ptr_to_ref.rs:113:17
+   |
+LL |         let _ = core::mem::transmute::<_, &[u32]>(ptr);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(ptr as *const [u32])`
+
+error: transmute from a pointer type (`*const [i32]`) to a reference type (`&[u32]`)
+  --> tests/ui/transmute_ptr_to_ref.rs:115:25
+   |
+LL |         let _: &[u32] = core::mem::transmute(ptr);
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(ptr as *const [u32])`
+
+error: transmute from a pointer type (`*const [&str]`) to a reference type (`&[&[u8]]`)
+  --> tests/ui/transmute_ptr_to_ref.rs:119:17
+   |
+LL |         let _ = core::mem::transmute::<_, &[&[u8]]>(a_s_ptr);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(a_s_ptr as *const [&[u8]])`
+
+error: transmute from a pointer type (`*const [&str]`) to a reference type (`&[&[u8]]`)
+  --> tests/ui/transmute_ptr_to_ref.rs:121:27
+   |
+LL |         let _: &[&[u8]] = core::mem::transmute(a_s_ptr);
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(a_s_ptr as *const [&[u8]])`
+
+error: transmute from a pointer type (`*const [i32]`) to a reference type (`&[i32]`)
+  --> tests/ui/transmute_ptr_to_ref.rs:125:17
+   |
+LL |         let _ = core::mem::transmute::<_, &[i32]>(ptr);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(ptr as *const [i32])`
+
+error: transmute from a pointer type (`*const [i32]`) to a reference type (`&[i32]`)
+  --> tests/ui/transmute_ptr_to_ref.rs:127:25
+   |
+LL |         let _: &[i32] = core::mem::transmute(ptr);
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*ptr`
+
+error: transmute from a pointer type (`*const [&str]`) to a reference type (`&[&str]`)
+  --> tests/ui/transmute_ptr_to_ref.rs:131:17
+   |
+LL |         let _ = core::mem::transmute::<_, &[&str]>(a_s_ptr);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(a_s_ptr as *const [&str])`
+
+error: transmute from a pointer type (`*const [&str]`) to a reference type (`&[&str]`)
+  --> tests/ui/transmute_ptr_to_ref.rs:133:26
+   |
+LL |         let _: &[&str] = core::mem::transmute(a_s_ptr);
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(a_s_ptr as *const [&str])`
+
+error: aborting due to 30 previous errors
 

From 4ae4f67e8c4c41b1c46d021be63ddc645d36154a Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Thu, 4 Sep 2025 11:24:36 +0200
Subject: [PATCH 0574/1889] clean-up a bit

Notably, rename `same_type_and_consts` to `same_type_modulo_regions` to
be more explicit about the function ignoring lifetimes
---
 clippy_lints/src/matches/needless_match.rs |  6 +-
 clippy_lints/src/operators/erasing_op.rs   |  4 +-
 clippy_lints/src/use_self.rs               | 77 ++++++++++------------
 clippy_lints/src/useless_conversion.rs     | 14 ++--
 clippy_utils/src/ty/mod.rs                 | 32 +++++----
 5 files changed, 64 insertions(+), 69 deletions(-)

diff --git a/clippy_lints/src/matches/needless_match.rs b/clippy_lints/src/matches/needless_match.rs
index b04db03f8d2e7..3a2097c3df261 100644
--- a/clippy_lints/src/matches/needless_match.rs
+++ b/clippy_lints/src/matches/needless_match.rs
@@ -1,7 +1,7 @@
 use super::NEEDLESS_MATCH;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::{is_type_diagnostic_item, same_type_and_consts};
+use clippy_utils::ty::{is_type_diagnostic_item, same_type_modulo_regions};
 use clippy_utils::{
     SpanlessEq, eq_expr_value, get_parent_expr_for_hir, higher, is_else_clause, is_res_lang_ctor, over, path_res,
     peel_blocks_with_stmt,
@@ -122,7 +122,7 @@ fn expr_ty_matches_p_ty(cx: &LateContext<'_>, expr: &Expr<'_>, p_expr: &Expr<'_>
         // Compare match_expr ty with local in `let local = match match_expr {..}`
         Node::LetStmt(local) => {
             let results = cx.typeck_results();
-            return same_type_and_consts(results.node_type(local.hir_id), results.expr_ty(expr));
+            return same_type_modulo_regions(results.node_type(local.hir_id), results.expr_ty(expr));
         },
         // compare match_expr ty with RetTy in `fn foo() -> RetTy`
         Node::Item(item) => {
@@ -133,7 +133,7 @@ fn expr_ty_matches_p_ty(cx: &LateContext<'_>, expr: &Expr<'_>, p_expr: &Expr<'_>
                     .instantiate_identity()
                     .output()
                     .skip_binder();
-                return same_type_and_consts(output, cx.typeck_results().expr_ty(expr));
+                return same_type_modulo_regions(output, cx.typeck_results().expr_ty(expr));
             }
         },
         // check the parent expr for this whole block `{ match match_expr {..} }`
diff --git a/clippy_lints/src/operators/erasing_op.rs b/clippy_lints/src/operators/erasing_op.rs
index e3fc8d8fea7d1..8f5ee390f7222 100644
--- a/clippy_lints/src/operators/erasing_op.rs
+++ b/clippy_lints/src/operators/erasing_op.rs
@@ -1,6 +1,6 @@
 use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::ty::same_type_and_consts;
+use clippy_utils::ty::same_type_modulo_regions;
 
 use rustc_hir::{BinOpKind, Expr};
 use rustc_lint::LateContext;
@@ -29,7 +29,7 @@ pub(super) fn check<'tcx>(
 fn different_types(tck: &TypeckResults<'_>, input: &Expr<'_>, output: &Expr<'_>) -> bool {
     let input_ty = tck.expr_ty(input).peel_refs();
     let output_ty = tck.expr_ty(output).peel_refs();
-    !same_type_and_consts(input_ty, output_ty)
+    !same_type_modulo_regions(input_ty, output_ty)
 }
 
 fn check_op<'tcx>(
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index aeda864b7eb5e..2679eeba87850 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -2,20 +2,21 @@ use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::is_from_proc_macro;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::ty::{same_type_and_consts, ty_from_hir_ty};
+use clippy_utils::ty::{same_type_modulo_regions, ty_from_hir_ty};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir::def::{CtorOf, DefKind, Res};
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::intravisit::{InferKind, Visitor, VisitorExt, walk_ty};
 use rustc_hir::{
-    self as hir, AmbigArg, Expr, ExprKind, FnRetTy, FnSig, GenericArgsParentheses, GenericParam, GenericParamKind,
-    HirId, Impl, ImplItemKind, Item, ItemKind, Pat, PatExpr, PatExprKind, PatKind, Path, QPath, Ty, TyKind,
+    self as hir, AmbigArg, Expr, ExprKind, FnRetTy, FnSig, GenericArgsParentheses, GenericParamKind, HirId, Impl,
+    ImplItemKind, Item, ItemKind, Pat, PatExpr, PatExprKind, PatKind, Path, QPath, Ty, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Ty as MiddleTy;
 use rustc_session::impl_lint_pass;
 use rustc_span::Span;
+use std::iter;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -101,17 +102,11 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
             let types_to_skip = generics
                 .params
                 .iter()
-                .filter_map(|param| match param {
-                    GenericParam {
-                        kind:
-                            GenericParamKind::Const {
-                                ty: Ty { hir_id, .. }, ..
-                            },
-                        ..
-                    } => Some(*hir_id),
+                .filter_map(|param| match param.kind {
+                    GenericParamKind::Const { ty, .. } => Some(ty.hir_id),
                     _ => None,
                 })
-                .chain(std::iter::once(self_ty.hir_id))
+                .chain([self_ty.hir_id])
                 .collect();
             StackItem::Check {
                 impl_id: item.owner_id.def_id,
@@ -210,11 +205,11 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
             && !types_to_skip.contains(&hir_ty.hir_id)
             && let ty = ty_from_hir_ty(cx, hir_ty.as_unambig_ty())
             && let impl_ty = cx.tcx.type_of(impl_id).instantiate_identity()
-            && same_type_and_consts(ty, impl_ty)
+            && same_type_modulo_regions(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 elided (`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))
+            && (!has_lifetime(ty) || same_lifetimes(ty, impl_ty))
             && self.msrv.meets(cx, msrvs::TYPE_ALIAS_ENUM_VARIANTS)
         {
             span_lint(cx, hir_ty.span);
@@ -227,18 +222,16 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
             && cx.typeck_results().expr_ty(expr) == cx.tcx.type_of(impl_id).instantiate_identity()
             && self.msrv.meets(cx, msrvs::TYPE_ALIAS_ENUM_VARIANTS)
         {
-        } else {
-            return;
-        }
-        match expr.kind {
-            ExprKind::Struct(QPath::Resolved(_, path), ..) => check_path(cx, path),
-            ExprKind::Call(fun, _) => {
-                if let ExprKind::Path(QPath::Resolved(_, path)) = fun.kind {
-                    check_path(cx, path);
-                }
-            },
-            ExprKind::Path(QPath::Resolved(_, path)) => check_path(cx, path),
-            _ => (),
+            match expr.kind {
+                ExprKind::Struct(QPath::Resolved(_, path), ..) => check_path(cx, path),
+                ExprKind::Call(fun, _) => {
+                    if let ExprKind::Path(QPath::Resolved(_, path)) = fun.kind {
+                        check_path(cx, path);
+                    }
+                },
+                ExprKind::Path(QPath::Resolved(_, path)) => check_path(cx, path),
+                _ => (),
+            }
         }
     }
 
@@ -308,36 +301,32 @@ fn lint_path_to_variant(cx: &LateContext<'_>, path: &Path<'_>) {
     }
 }
 
-/// Returns `true` if types `a` and `b` have the same lifetime parameters, otherwise returns
-/// `false`.
+/// Checks whether types `a` and `b` have the same lifetime parameters.
 ///
 /// This function does not check that types `a` and `b` are the same types.
 fn same_lifetimes<'tcx>(a: MiddleTy<'tcx>, b: MiddleTy<'tcx>) -> bool {
     use rustc_middle::ty::{Adt, GenericArgKind};
-    match (&a.kind(), &b.kind()) {
-        (&Adt(_, args_a), &Adt(_, args_b)) => {
-            args_a
-                .iter()
-                .zip(args_b.iter())
-                .all(|(arg_a, arg_b)| match (arg_a.kind(), arg_b.kind()) {
-                    // TODO: Handle inferred lifetimes
-                    (GenericArgKind::Lifetime(inner_a), GenericArgKind::Lifetime(inner_b)) => inner_a == inner_b,
-                    (GenericArgKind::Type(type_a), GenericArgKind::Type(type_b)) => same_lifetimes(type_a, type_b),
-                    _ => true,
-                })
+    match (a.kind(), b.kind()) {
+        (Adt(_, args_a), Adt(_, args_b)) => {
+            iter::zip(*args_a, *args_b).all(|(arg_a, arg_b)| match (arg_a.kind(), arg_b.kind()) {
+                // TODO: Handle inferred lifetimes
+                (GenericArgKind::Lifetime(inner_a), GenericArgKind::Lifetime(inner_b)) => inner_a == inner_b,
+                (GenericArgKind::Type(type_a), GenericArgKind::Type(type_b)) => same_lifetimes(type_a, type_b),
+                _ => true,
+            })
         },
         _ => a == b,
     }
 }
 
-/// Returns `true` if `ty` has no lifetime parameter, otherwise returns `false`.
-fn has_no_lifetime(ty: MiddleTy<'_>) -> bool {
+/// Checks whether `ty` has lifetime parameters.
+fn has_lifetime(ty: MiddleTy<'_>) -> bool {
     use rustc_middle::ty::{Adt, GenericArgKind};
     match ty.kind() {
-        &Adt(_, args) => !args
+        Adt(_, args) => args
             .iter()
             // TODO: Handle inferred lifetimes
             .any(|arg| matches!(arg.kind(), GenericArgKind::Lifetime(..))),
-        _ => true,
+        _ => false,
     }
 }
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 70ae982a4458b..5274fdbd1dc21 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_with_context};
 use clippy_utils::sugg::{DiagExt as _, Sugg};
-use clippy_utils::ty::{get_type_diagnostic_name, is_copy, is_type_diagnostic_item, same_type_and_consts};
+use clippy_utils::ty::{get_type_diagnostic_name, is_copy, is_type_diagnostic_item, same_type_modulo_regions};
 use clippy_utils::{
     get_parent_expr, is_inherent_method_call, is_trait_item, is_trait_method, is_ty_alias, path_to_local, sym,
 };
@@ -184,7 +184,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                     && (is_trait_item(cx, arg, sym::Into) || is_trait_item(cx, arg, sym::From))
                     && let ty::FnDef(_, args) = cx.typeck_results().expr_ty(arg).kind()
                     && let &[from_ty, to_ty] = args.into_type_list(cx.tcx).as_slice()
-                    && same_type_and_consts(from_ty, to_ty)
+                    && same_type_modulo_regions(from_ty, to_ty)
                 {
                     span_lint_and_then(
                         cx,
@@ -207,7 +207,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                 if is_trait_method(cx, e, sym::Into) && name.ident.name == sym::into {
                     let a = cx.typeck_results().expr_ty(e);
                     let b = cx.typeck_results().expr_ty(recv);
-                    if same_type_and_consts(a, b) {
+                    if same_type_modulo_regions(a, b) {
                         let mut app = Applicability::MachineApplicable;
                         let sugg = snippet_with_context(cx, recv.span, e.span.ctxt(), "<expr>", &mut app).0;
                         span_lint_and_sugg(
@@ -324,7 +324,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                     // If the types are identical then .into_iter() can be removed, unless the type
                     // implements Copy, in which case .into_iter() returns a copy of the receiver and
                     // cannot be safely omitted.
-                    if same_type_and_consts(a, b) && !is_copy(cx, b) {
+                    if same_type_modulo_regions(a, b) && !is_copy(cx, b) {
                         // Below we check if the parent method call meets the following conditions:
                         // 1. First parameter is `&mut self` (requires mutable reference)
                         // 2. Second parameter implements the `FnMut` trait (e.g., Iterator::any)
@@ -371,7 +371,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                     && is_type_diagnostic_item(cx, a, sym::Result)
                     && let ty::Adt(_, args) = a.kind()
                     && let Some(a_type) = args.types().next()
-                    && same_type_and_consts(a_type, b)
+                    && same_type_modulo_regions(a_type, b)
                 {
                     span_lint_and_help(
                         cx,
@@ -396,7 +396,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                         && is_type_diagnostic_item(cx, a, sym::Result)
                         && let ty::Adt(_, args) = a.kind()
                         && let Some(a_type) = args.types().next()
-                        && same_type_and_consts(a_type, b)
+                        && same_type_modulo_regions(a_type, b)
                     {
                         let hint = format!("consider removing `{}()`", snippet(cx, path.span, "TryFrom::try_from"));
                         span_lint_and_help(
@@ -407,7 +407,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                             None,
                             hint,
                         );
-                    } else if name == sym::from_fn && same_type_and_consts(a, b) {
+                    } else if name == sym::from_fn && same_type_modulo_regions(a, b) {
                         let mut app = Applicability::MachineApplicable;
                         let sugg = Sugg::hir_with_context(cx, arg, e.span.ctxt(), "<expr>", &mut app).maybe_paren();
                         let sugg_msg = format!("consider removing `{}()`", snippet(cx, path.span, "From::from"));
diff --git a/clippy_utils/src/ty/mod.rs b/clippy_utils/src/ty/mod.rs
index 8e302f9d2ad12..8fbaac58288f0 100644
--- a/clippy_utils/src/ty/mod.rs
+++ b/clippy_utils/src/ty/mod.rs
@@ -513,25 +513,31 @@ pub fn walk_ptrs_ty_depth(ty: Ty<'_>) -> (Ty<'_>, usize) {
     inner(ty, 0)
 }
 
-/// Returns `true` if types `a` and `b` are same types having same `Const` generic args,
-/// otherwise returns `false`
-pub fn same_type_and_consts<'tcx>(a: Ty<'tcx>, b: Ty<'tcx>) -> bool {
+/// Checks whether `a` and `b` are same types having same `Const` generic args, but ignores
+/// lifetimes.
+///
+/// For example, the function would return `true` for
+/// - `u32` and `u32`
+/// - `[u8; N]` and `[u8; M]`, if `N=M`
+/// - `Option<T>` and `Option<U>`, if `same_type_modulo_regions(T, U)` holds
+/// - `&'a str` and `&'b str`
+///
+/// and `false` for:
+/// - `Result<u32, String>` and `Result<usize, String>`
+pub fn same_type_modulo_regions<'tcx>(a: Ty<'tcx>, b: Ty<'tcx>) -> bool {
     match (&a.kind(), &b.kind()) {
         (&ty::Adt(did_a, args_a), &ty::Adt(did_b, args_b)) => {
             if did_a != did_b {
                 return false;
             }
 
-            args_a
-                .iter()
-                .zip(args_b.iter())
-                .all(|(arg_a, arg_b)| match (arg_a.kind(), arg_b.kind()) {
-                    (GenericArgKind::Const(inner_a), GenericArgKind::Const(inner_b)) => inner_a == inner_b,
-                    (GenericArgKind::Type(type_a), GenericArgKind::Type(type_b)) => {
-                        same_type_and_consts(type_a, type_b)
-                    },
-                    _ => true,
-                })
+            iter::zip(*args_a, *args_b).all(|(arg_a, arg_b)| match (arg_a.kind(), arg_b.kind()) {
+                (GenericArgKind::Const(inner_a), GenericArgKind::Const(inner_b)) => inner_a == inner_b,
+                (GenericArgKind::Type(type_a), GenericArgKind::Type(type_b)) => {
+                    same_type_modulo_regions(type_a, type_b)
+                },
+                _ => true,
+            })
         },
         _ => a == b,
     }

From 6812aa3403cc6b8c5a229fc36f0022b06c276e3c Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Thu, 4 Sep 2025 12:27:19 +0200
Subject: [PATCH 0575/1889] fix(use_self): descend into type's children when
 looking for lifetimes

This unfortunately breaks another test case -- it had only worked
because when we checked `!has_lifetime` on `S2<S<'a>>`, we only looked
for generic lifetime params on `S2`, forgetting to descend into `S`.

One thing that makes this a bit less sad is that this particular test
case doesn't come from a reported issue, but rather was added as a
miscellaneous check during a kind of unrelated PR.
---
 clippy_lints/src/use_self.rs |  8 +++++---
 tests/ui/use_self.fixed      | 18 ++++++++++++++++--
 tests/ui/use_self.rs         | 16 +++++++++++++++-
 tests/ui/use_self.stderr     |  8 +-------
 4 files changed, 37 insertions(+), 13 deletions(-)

diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 2679eeba87850..e84641d4d1b97 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -323,10 +323,12 @@ fn same_lifetimes<'tcx>(a: MiddleTy<'tcx>, b: MiddleTy<'tcx>) -> bool {
 fn has_lifetime(ty: MiddleTy<'_>) -> bool {
     use rustc_middle::ty::{Adt, GenericArgKind};
     match ty.kind() {
-        Adt(_, args) => args
-            .iter()
+        Adt(_, args) => args.iter().any(|arg| match arg.kind() {
             // TODO: Handle inferred lifetimes
-            .any(|arg| matches!(arg.kind(), GenericArgKind::Lifetime(..))),
+            GenericArgKind::Lifetime(..) => true,
+            GenericArgKind::Type(ty) => has_lifetime(ty),
+            _ => false,
+        }),
         _ => false,
     }
 }
diff --git a/tests/ui/use_self.fixed b/tests/ui/use_self.fixed
index cccb6bffabb71..075e31d202b06 100644
--- a/tests/ui/use_self.fixed
+++ b/tests/ui/use_self.fixed
@@ -530,8 +530,8 @@ mod issue7206 {
 
     impl<'a> S2<S<'a>> {
         fn new_again() -> Self {
-            Self::new()
-            //~^ use_self
+            S2::new()
+            // FIXME: ^Broken by PR #15611
         }
     }
 }
@@ -755,3 +755,17 @@ mod crash_check_13128 {
         }
     }
 }
+
+mod issue_13277 {
+    trait Foo {
+        type Item<'foo>;
+    }
+    struct Bar<'b> {
+        content: &'b str,
+    }
+    impl<'b> Foo for Option<Bar<'b>> {
+        // when checking whether `Option<Bar<'foo>>` has a lifetime, check not only the outer
+        // `Option<T>`, but also the inner `Bar<'foo>`
+        type Item<'foo> = Option<Bar<'foo>>;
+    }
+}
diff --git a/tests/ui/use_self.rs b/tests/ui/use_self.rs
index 09288677aa715..6fbba0bbc550b 100644
--- a/tests/ui/use_self.rs
+++ b/tests/ui/use_self.rs
@@ -531,7 +531,7 @@ mod issue7206 {
     impl<'a> S2<S<'a>> {
         fn new_again() -> Self {
             S2::new()
-            //~^ use_self
+            // FIXME: ^Broken by PR #15611
         }
     }
 }
@@ -755,3 +755,17 @@ mod crash_check_13128 {
         }
     }
 }
+
+mod issue_13277 {
+    trait Foo {
+        type Item<'foo>;
+    }
+    struct Bar<'b> {
+        content: &'b str,
+    }
+    impl<'b> Foo for Option<Bar<'b>> {
+        // when checking whether `Option<Bar<'foo>>` has a lifetime, check not only the outer
+        // `Option<T>`, but also the inner `Bar<'foo>`
+        type Item<'foo> = Option<Bar<'foo>>;
+    }
+}
diff --git a/tests/ui/use_self.stderr b/tests/ui/use_self.stderr
index 781327696ac19..5f65c53ea25c3 100644
--- a/tests/ui/use_self.stderr
+++ b/tests/ui/use_self.stderr
@@ -169,12 +169,6 @@ error: unnecessary structure name repetition
 LL |             A::new::<submod::B>(submod::B {})
    |             ^ help: use the applicable keyword: `Self`
 
-error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:533:13
-   |
-LL |             S2::new()
-   |             ^^ help: use the applicable keyword: `Self`
-
 error: unnecessary structure name repetition
   --> tests/ui/use_self.rs:571:17
    |
@@ -259,5 +253,5 @@ error: unnecessary structure name repetition
 LL |                 E::A => {},
    |                 ^ help: use the applicable keyword: `Self`
 
-error: aborting due to 43 previous errors
+error: aborting due to 42 previous errors
 

From e7c91ab13ad36e3dfefc4f4f92f4c6e5e445c8f6 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Thu, 4 Sep 2025 20:49:26 +0200
Subject: [PATCH 0576/1889] remove `has_lifetime`

It's now redundant to `same_lifetimes`: if `ty` and `impl_ty` are the
same type, and they both have no lifetimes, `same_lifetimes` will return
`true` already
---
 clippy_lints/src/use_self.rs | 16 +---------------
 1 file changed, 1 insertion(+), 15 deletions(-)

diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index e84641d4d1b97..8210320591c62 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -209,7 +209,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
             // 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 elided (`impl<'a> Foo<'a> { fn new() -> Self { Foo{..} } }`), in
             // which case we must still trigger the lint.
-            && (!has_lifetime(ty) || same_lifetimes(ty, impl_ty))
+            && same_lifetimes(ty, impl_ty)
             && self.msrv.meets(cx, msrvs::TYPE_ALIAS_ENUM_VARIANTS)
         {
             span_lint(cx, hir_ty.span);
@@ -318,17 +318,3 @@ fn same_lifetimes<'tcx>(a: MiddleTy<'tcx>, b: MiddleTy<'tcx>) -> bool {
         _ => a == b,
     }
 }
-
-/// Checks whether `ty` has lifetime parameters.
-fn has_lifetime(ty: MiddleTy<'_>) -> bool {
-    use rustc_middle::ty::{Adt, GenericArgKind};
-    match ty.kind() {
-        Adt(_, args) => args.iter().any(|arg| match arg.kind() {
-            // TODO: Handle inferred lifetimes
-            GenericArgKind::Lifetime(..) => true,
-            GenericArgKind::Type(ty) => has_lifetime(ty),
-            _ => false,
-        }),
-        _ => false,
-    }
-}

From 4fd9a063855302cf3276c2f6b9349e41d75adb1c Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sat, 6 Sep 2025 12:50:57 +0200
Subject: [PATCH 0577/1889] Move `derive.rs` to `derive/mod.rs`

Will hopefully make the next commit's diff somewhat easier to understand
---
 clippy_lints/src/{derive.rs => derive/mod.rs} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename clippy_lints/src/{derive.rs => derive/mod.rs} (100%)

diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive/mod.rs
similarity index 100%
rename from clippy_lints/src/derive.rs
rename to clippy_lints/src/derive/mod.rs

From 8a11cf8d3a6366d4d5e2d52e94003018f7ef8181 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sat, 6 Sep 2025 11:43:34 +0200
Subject: [PATCH 0578/1889] Split out each lint into a separate module

Best viewed with `git diff --color-moved`
---
 .../src/derive/derive_ord_xor_partial_ord.rs  |  50 +++
 .../derive/derive_partial_eq_without_eq.rs    |  87 +++++
 .../src/derive/derived_hash_with_manual_eq.rs |  49 +++
 .../src/derive/expl_impl_clone_on_copy.rs     |  65 ++++
 clippy_lints/src/derive/mod.rs                | 336 +-----------------
 .../src/derive/unsafe_derive_deserialize.rs   |  93 +++++
 6 files changed, 356 insertions(+), 324 deletions(-)
 create mode 100644 clippy_lints/src/derive/derive_ord_xor_partial_ord.rs
 create mode 100644 clippy_lints/src/derive/derive_partial_eq_without_eq.rs
 create mode 100644 clippy_lints/src/derive/derived_hash_with_manual_eq.rs
 create mode 100644 clippy_lints/src/derive/expl_impl_clone_on_copy.rs
 create mode 100644 clippy_lints/src/derive/unsafe_derive_deserialize.rs

diff --git a/clippy_lints/src/derive/derive_ord_xor_partial_ord.rs b/clippy_lints/src/derive/derive_ord_xor_partial_ord.rs
new file mode 100644
index 0000000000000..cbbcb2f7a3bab
--- /dev/null
+++ b/clippy_lints/src/derive/derive_ord_xor_partial_ord.rs
@@ -0,0 +1,50 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_middle::ty::Ty;
+use rustc_span::{Span, sym};
+
+use super::DERIVE_ORD_XOR_PARTIAL_ORD;
+
+/// Implementation of the `DERIVE_ORD_XOR_PARTIAL_ORD` lint.
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    span: Span,
+    trait_ref: &hir::TraitRef<'_>,
+    ty: Ty<'tcx>,
+    ord_is_automatically_derived: bool,
+) {
+    if let Some(ord_trait_def_id) = cx.tcx.get_diagnostic_item(sym::Ord)
+        && let Some(partial_ord_trait_def_id) = cx.tcx.lang_items().partial_ord_trait()
+        && let Some(def_id) = &trait_ref.trait_def_id()
+        && *def_id == ord_trait_def_id
+    {
+        // Look for the PartialOrd implementations for `ty`
+        cx.tcx.for_each_relevant_impl(partial_ord_trait_def_id, ty, |impl_id| {
+            let partial_ord_is_automatically_derived = cx.tcx.is_automatically_derived(impl_id);
+
+            if partial_ord_is_automatically_derived == ord_is_automatically_derived {
+                return;
+            }
+
+            let trait_ref = cx.tcx.impl_trait_ref(impl_id).expect("must be a trait implementation");
+
+            // Only care about `impl PartialOrd<Foo> for Foo`
+            // For `impl PartialOrd<B> for A, input_types is [A, B]
+            if trait_ref.instantiate_identity().args.type_at(1) == ty {
+                let mess = if partial_ord_is_automatically_derived {
+                    "you are implementing `Ord` explicitly but have derived `PartialOrd`"
+                } else {
+                    "you are deriving `Ord` but have implemented `PartialOrd` explicitly"
+                };
+
+                span_lint_and_then(cx, DERIVE_ORD_XOR_PARTIAL_ORD, span, mess, |diag| {
+                    if let Some(local_def_id) = impl_id.as_local() {
+                        let hir_id = cx.tcx.local_def_id_to_hir_id(local_def_id);
+                        diag.span_note(cx.tcx.hir_span(hir_id), "`PartialOrd` implemented here");
+                    }
+                });
+            }
+        });
+    }
+}
diff --git a/clippy_lints/src/derive/derive_partial_eq_without_eq.rs b/clippy_lints/src/derive/derive_partial_eq_without_eq.rs
new file mode 100644
index 0000000000000..ed7881c461ffc
--- /dev/null
+++ b/clippy_lints/src/derive/derive_partial_eq_without_eq.rs
@@ -0,0 +1,87 @@
+use clippy_utils::diagnostics::span_lint_hir_and_then;
+use clippy_utils::has_non_exhaustive_attr;
+use clippy_utils::ty::implements_trait_with_env;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, ClauseKind, GenericParamDefKind, ParamEnv, TraitPredicate, Ty, TyCtxt, Upcast};
+use rustc_span::{Span, sym};
+
+use super::DERIVE_PARTIAL_EQ_WITHOUT_EQ;
+
+/// Implementation of the `DERIVE_PARTIAL_EQ_WITHOUT_EQ` lint.
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, span: Span, trait_ref: &hir::TraitRef<'_>, ty: Ty<'tcx>) {
+    if let ty::Adt(adt, args) = ty.kind()
+        && cx.tcx.visibility(adt.did()).is_public()
+        && let Some(eq_trait_def_id) = cx.tcx.get_diagnostic_item(sym::Eq)
+        && let Some(def_id) = trait_ref.trait_def_id()
+        && cx.tcx.is_diagnostic_item(sym::PartialEq, def_id)
+        && !has_non_exhaustive_attr(cx.tcx, *adt)
+        && !ty_implements_eq_trait(cx.tcx, ty, eq_trait_def_id)
+        && let typing_env = typing_env_for_derived_eq(cx.tcx, adt.did(), eq_trait_def_id)
+        && let Some(local_def_id) = adt.did().as_local()
+        // If all of our fields implement `Eq`, we can implement `Eq` too
+        && adt
+            .all_fields()
+            .map(|f| f.ty(cx.tcx, args))
+            .all(|ty| implements_trait_with_env(cx.tcx, typing_env, ty, eq_trait_def_id, None, &[]))
+    {
+        span_lint_hir_and_then(
+            cx,
+            DERIVE_PARTIAL_EQ_WITHOUT_EQ,
+            cx.tcx.local_def_id_to_hir_id(local_def_id),
+            span.ctxt().outer_expn_data().call_site,
+            "you are deriving `PartialEq` and can implement `Eq`",
+            |diag| {
+                diag.span_suggestion(
+                    span.ctxt().outer_expn_data().call_site,
+                    "consider deriving `Eq` as well",
+                    "PartialEq, Eq",
+                    Applicability::MachineApplicable,
+                );
+            },
+        );
+    }
+}
+
+fn ty_implements_eq_trait<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, eq_trait_id: DefId) -> bool {
+    tcx.non_blanket_impls_for_ty(eq_trait_id, ty).next().is_some()
+}
+
+/// Creates the `ParamEnv` used for the given type's derived `Eq` impl.
+fn typing_env_for_derived_eq(tcx: TyCtxt<'_>, did: DefId, eq_trait_id: DefId) -> ty::TypingEnv<'_> {
+    // Initial map from generic index to param def.
+    // Vec<(param_def, needs_eq)>
+    let mut params = tcx
+        .generics_of(did)
+        .own_params
+        .iter()
+        .map(|p| (p, matches!(p.kind, GenericParamDefKind::Type { .. })))
+        .collect::<Vec<_>>();
+
+    let ty_predicates = tcx.predicates_of(did).predicates;
+    for (p, _) in ty_predicates {
+        if let ClauseKind::Trait(p) = p.kind().skip_binder()
+            && p.trait_ref.def_id == eq_trait_id
+            && let ty::Param(self_ty) = p.trait_ref.self_ty().kind()
+        {
+            // Flag types which already have an `Eq` bound.
+            params[self_ty.index as usize].1 = false;
+        }
+    }
+
+    let param_env = ParamEnv::new(tcx.mk_clauses_from_iter(ty_predicates.iter().map(|&(p, _)| p).chain(
+        params.iter().filter(|&&(_, needs_eq)| needs_eq).map(|&(param, _)| {
+            ClauseKind::Trait(TraitPredicate {
+                trait_ref: ty::TraitRef::new(tcx, eq_trait_id, [tcx.mk_param_from_def(param)]),
+                polarity: ty::PredicatePolarity::Positive,
+            })
+            .upcast(tcx)
+        }),
+    )));
+    ty::TypingEnv {
+        typing_mode: ty::TypingMode::non_body_analysis(),
+        param_env,
+    }
+}
diff --git a/clippy_lints/src/derive/derived_hash_with_manual_eq.rs b/clippy_lints/src/derive/derived_hash_with_manual_eq.rs
new file mode 100644
index 0000000000000..6f36a58025a2b
--- /dev/null
+++ b/clippy_lints/src/derive/derived_hash_with_manual_eq.rs
@@ -0,0 +1,49 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_middle::ty::Ty;
+use rustc_span::{Span, sym};
+
+use super::DERIVED_HASH_WITH_MANUAL_EQ;
+
+/// Implementation of the `DERIVED_HASH_WITH_MANUAL_EQ` lint.
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    span: Span,
+    trait_ref: &hir::TraitRef<'_>,
+    ty: Ty<'tcx>,
+    hash_is_automatically_derived: bool,
+) {
+    if let Some(peq_trait_def_id) = cx.tcx.lang_items().eq_trait()
+        && let Some(def_id) = trait_ref.trait_def_id()
+        && cx.tcx.is_diagnostic_item(sym::Hash, def_id)
+    {
+        // Look for the PartialEq implementations for `ty`
+        cx.tcx.for_each_relevant_impl(peq_trait_def_id, ty, |impl_id| {
+            let peq_is_automatically_derived = cx.tcx.is_automatically_derived(impl_id);
+
+            if !hash_is_automatically_derived || peq_is_automatically_derived {
+                return;
+            }
+
+            let trait_ref = cx.tcx.impl_trait_ref(impl_id).expect("must be a trait implementation");
+
+            // Only care about `impl PartialEq<Foo> for Foo`
+            // For `impl PartialEq<B> for A, input_types is [A, B]
+            if trait_ref.instantiate_identity().args.type_at(1) == ty {
+                span_lint_and_then(
+                    cx,
+                    DERIVED_HASH_WITH_MANUAL_EQ,
+                    span,
+                    "you are deriving `Hash` but have implemented `PartialEq` explicitly",
+                    |diag| {
+                        if let Some(local_def_id) = impl_id.as_local() {
+                            let hir_id = cx.tcx.local_def_id_to_hir_id(local_def_id);
+                            diag.span_note(cx.tcx.hir_span(hir_id), "`PartialEq` implemented here");
+                        }
+                    },
+                );
+            }
+        });
+    }
+}
diff --git a/clippy_lints/src/derive/expl_impl_clone_on_copy.rs b/clippy_lints/src/derive/expl_impl_clone_on_copy.rs
new file mode 100644
index 0000000000000..6b97b4bd6b4d3
--- /dev/null
+++ b/clippy_lints/src/derive/expl_impl_clone_on_copy.rs
@@ -0,0 +1,65 @@
+use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::ty::{implements_trait, is_copy};
+use rustc_hir::{self as hir, Item};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, GenericArgKind, Ty};
+
+use super::EXPL_IMPL_CLONE_ON_COPY;
+
+/// Implementation of the `EXPL_IMPL_CLONE_ON_COPY` lint.
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, item: &Item<'_>, trait_ref: &hir::TraitRef<'_>, ty: Ty<'tcx>) {
+    let clone_id = match cx.tcx.lang_items().clone_trait() {
+        Some(id) if trait_ref.trait_def_id() == Some(id) => id,
+        _ => return,
+    };
+    let Some(copy_id) = cx.tcx.lang_items().copy_trait() else {
+        return;
+    };
+    let (ty_adt, ty_subs) = match *ty.kind() {
+        // Unions can't derive clone.
+        ty::Adt(adt, subs) if !adt.is_union() => (adt, subs),
+        _ => return,
+    };
+    // If the current self type doesn't implement Copy (due to generic constraints), search to see if
+    // there's a Copy impl for any instance of the adt.
+    if !is_copy(cx, ty) {
+        if ty_subs.non_erasable_generics().next().is_some() {
+            let has_copy_impl = cx.tcx.local_trait_impls(copy_id).iter().any(|&id| {
+                matches!(cx.tcx.type_of(id).instantiate_identity().kind(), ty::Adt(adt, _)
+                                        if ty_adt.did() == adt.did())
+            });
+            if !has_copy_impl {
+                return;
+            }
+        } else {
+            return;
+        }
+    }
+    // Derive constrains all generic types to requiring Clone. Check if any type is not constrained for
+    // this impl.
+    if ty_subs.types().any(|ty| !implements_trait(cx, ty, clone_id, &[])) {
+        return;
+    }
+    // `#[repr(packed)]` structs with type/const parameters can't derive `Clone`.
+    // https://github.com/rust-lang/rust-clippy/issues/10188
+    if ty_adt.repr().packed()
+        && ty_subs
+            .iter()
+            .any(|arg| matches!(arg.kind(), GenericArgKind::Type(_) | GenericArgKind::Const(_)))
+    {
+        return;
+    }
+    // The presence of `unsafe` fields prevents deriving `Clone` automatically
+    if ty_adt.all_fields().any(|f| f.safety.is_unsafe()) {
+        return;
+    }
+
+    span_lint_and_note(
+        cx,
+        EXPL_IMPL_CLONE_ON_COPY,
+        item.span,
+        "you are implementing `Clone` explicitly on a `Copy` type",
+        Some(item.span),
+        "consider deriving `Clone` or removing `Copy`",
+    );
+}
diff --git a/clippy_lints/src/derive/mod.rs b/clippy_lints/src/derive/mod.rs
index c53a957f6a8b7..1d63394ce37d4 100644
--- a/clippy_lints/src/derive/mod.rs
+++ b/clippy_lints/src/derive/mod.rs
@@ -1,20 +1,12 @@
-use std::ops::ControlFlow;
-
-use clippy_utils::diagnostics::{span_lint_and_note, span_lint_and_then, span_lint_hir_and_then};
-use clippy_utils::ty::{implements_trait, implements_trait_with_env, is_copy};
-use clippy_utils::{has_non_exhaustive_attr, is_lint_allowed, paths};
-use rustc_errors::Applicability;
-use rustc_hir::def_id::DefId;
-use rustc_hir::intravisit::{FnKind, Visitor, walk_expr, walk_fn, walk_item};
-use rustc_hir::{self as hir, BlockCheckMode, BodyId, Expr, ExprKind, FnDecl, Impl, Item, ItemKind, UnsafeSource};
+use rustc_hir::{Impl, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::hir::nested_filter;
-use rustc_middle::ty::{
-    self, ClauseKind, GenericArgKind, GenericParamDefKind, ParamEnv, TraitPredicate, Ty, TyCtxt, Upcast,
-};
 use rustc_session::declare_lint_pass;
-use rustc_span::def_id::LocalDefId;
-use rustc_span::{Span, sym};
+
+mod derive_ord_xor_partial_ord;
+mod derive_partial_eq_without_eq;
+mod derived_hash_with_manual_eq;
+mod expl_impl_clone_on_copy;
+mod unsafe_derive_deserialize;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -209,319 +201,15 @@ impl<'tcx> LateLintPass<'tcx> for Derive {
             let ty = cx.tcx.type_of(item.owner_id).instantiate_identity();
             let is_automatically_derived = cx.tcx.is_automatically_derived(item.owner_id.to_def_id());
 
-            check_hash_peq(cx, item.span, trait_ref, ty, is_automatically_derived);
-            check_ord_partial_ord(cx, item.span, trait_ref, ty, is_automatically_derived);
+            derived_hash_with_manual_eq::check(cx, item.span, trait_ref, ty, is_automatically_derived);
+            derive_ord_xor_partial_ord::check(cx, item.span, trait_ref, ty, is_automatically_derived);
 
             if is_automatically_derived {
-                check_unsafe_derive_deserialize(cx, item, trait_ref, ty);
-                check_partial_eq_without_eq(cx, item.span, trait_ref, ty);
+                unsafe_derive_deserialize::check(cx, item, trait_ref, ty);
+                derive_partial_eq_without_eq::check(cx, item.span, trait_ref, ty);
             } else {
-                check_copy_clone(cx, item, trait_ref, ty);
+                expl_impl_clone_on_copy::check(cx, item, trait_ref, ty);
             }
         }
     }
 }
-
-/// Implementation of the `DERIVED_HASH_WITH_MANUAL_EQ` lint.
-fn check_hash_peq<'tcx>(
-    cx: &LateContext<'tcx>,
-    span: Span,
-    trait_ref: &hir::TraitRef<'_>,
-    ty: Ty<'tcx>,
-    hash_is_automatically_derived: bool,
-) {
-    if let Some(peq_trait_def_id) = cx.tcx.lang_items().eq_trait()
-        && let Some(def_id) = trait_ref.trait_def_id()
-        && cx.tcx.is_diagnostic_item(sym::Hash, def_id)
-    {
-        // Look for the PartialEq implementations for `ty`
-        cx.tcx.for_each_relevant_impl(peq_trait_def_id, ty, |impl_id| {
-            let peq_is_automatically_derived = cx.tcx.is_automatically_derived(impl_id);
-
-            if !hash_is_automatically_derived || peq_is_automatically_derived {
-                return;
-            }
-
-            let trait_ref = cx.tcx.impl_trait_ref(impl_id).expect("must be a trait implementation");
-
-            // Only care about `impl PartialEq<Foo> for Foo`
-            // For `impl PartialEq<B> for A, input_types is [A, B]
-            if trait_ref.instantiate_identity().args.type_at(1) == ty {
-                span_lint_and_then(
-                    cx,
-                    DERIVED_HASH_WITH_MANUAL_EQ,
-                    span,
-                    "you are deriving `Hash` but have implemented `PartialEq` explicitly",
-                    |diag| {
-                        if let Some(local_def_id) = impl_id.as_local() {
-                            let hir_id = cx.tcx.local_def_id_to_hir_id(local_def_id);
-                            diag.span_note(cx.tcx.hir_span(hir_id), "`PartialEq` implemented here");
-                        }
-                    },
-                );
-            }
-        });
-    }
-}
-
-/// Implementation of the `DERIVE_ORD_XOR_PARTIAL_ORD` lint.
-fn check_ord_partial_ord<'tcx>(
-    cx: &LateContext<'tcx>,
-    span: Span,
-    trait_ref: &hir::TraitRef<'_>,
-    ty: Ty<'tcx>,
-    ord_is_automatically_derived: bool,
-) {
-    if let Some(ord_trait_def_id) = cx.tcx.get_diagnostic_item(sym::Ord)
-        && let Some(partial_ord_trait_def_id) = cx.tcx.lang_items().partial_ord_trait()
-        && let Some(def_id) = &trait_ref.trait_def_id()
-        && *def_id == ord_trait_def_id
-    {
-        // Look for the PartialOrd implementations for `ty`
-        cx.tcx.for_each_relevant_impl(partial_ord_trait_def_id, ty, |impl_id| {
-            let partial_ord_is_automatically_derived = cx.tcx.is_automatically_derived(impl_id);
-
-            if partial_ord_is_automatically_derived == ord_is_automatically_derived {
-                return;
-            }
-
-            let trait_ref = cx.tcx.impl_trait_ref(impl_id).expect("must be a trait implementation");
-
-            // Only care about `impl PartialOrd<Foo> for Foo`
-            // For `impl PartialOrd<B> for A, input_types is [A, B]
-            if trait_ref.instantiate_identity().args.type_at(1) == ty {
-                let mess = if partial_ord_is_automatically_derived {
-                    "you are implementing `Ord` explicitly but have derived `PartialOrd`"
-                } else {
-                    "you are deriving `Ord` but have implemented `PartialOrd` explicitly"
-                };
-
-                span_lint_and_then(cx, DERIVE_ORD_XOR_PARTIAL_ORD, span, mess, |diag| {
-                    if let Some(local_def_id) = impl_id.as_local() {
-                        let hir_id = cx.tcx.local_def_id_to_hir_id(local_def_id);
-                        diag.span_note(cx.tcx.hir_span(hir_id), "`PartialOrd` implemented here");
-                    }
-                });
-            }
-        });
-    }
-}
-
-/// Implementation of the `EXPL_IMPL_CLONE_ON_COPY` lint.
-fn check_copy_clone<'tcx>(cx: &LateContext<'tcx>, item: &Item<'_>, trait_ref: &hir::TraitRef<'_>, ty: Ty<'tcx>) {
-    let clone_id = match cx.tcx.lang_items().clone_trait() {
-        Some(id) if trait_ref.trait_def_id() == Some(id) => id,
-        _ => return,
-    };
-    let Some(copy_id) = cx.tcx.lang_items().copy_trait() else {
-        return;
-    };
-    let (ty_adt, ty_subs) = match *ty.kind() {
-        // Unions can't derive clone.
-        ty::Adt(adt, subs) if !adt.is_union() => (adt, subs),
-        _ => return,
-    };
-    // If the current self type doesn't implement Copy (due to generic constraints), search to see if
-    // there's a Copy impl for any instance of the adt.
-    if !is_copy(cx, ty) {
-        if ty_subs.non_erasable_generics().next().is_some() {
-            let has_copy_impl = cx.tcx.local_trait_impls(copy_id).iter().any(|&id| {
-                matches!(cx.tcx.type_of(id).instantiate_identity().kind(), ty::Adt(adt, _)
-                                        if ty_adt.did() == adt.did())
-            });
-            if !has_copy_impl {
-                return;
-            }
-        } else {
-            return;
-        }
-    }
-    // Derive constrains all generic types to requiring Clone. Check if any type is not constrained for
-    // this impl.
-    if ty_subs.types().any(|ty| !implements_trait(cx, ty, clone_id, &[])) {
-        return;
-    }
-    // `#[repr(packed)]` structs with type/const parameters can't derive `Clone`.
-    // https://github.com/rust-lang/rust-clippy/issues/10188
-    if ty_adt.repr().packed()
-        && ty_subs
-            .iter()
-            .any(|arg| matches!(arg.kind(), GenericArgKind::Type(_) | GenericArgKind::Const(_)))
-    {
-        return;
-    }
-    // The presence of `unsafe` fields prevents deriving `Clone` automatically
-    if ty_adt.all_fields().any(|f| f.safety.is_unsafe()) {
-        return;
-    }
-
-    span_lint_and_note(
-        cx,
-        EXPL_IMPL_CLONE_ON_COPY,
-        item.span,
-        "you are implementing `Clone` explicitly on a `Copy` type",
-        Some(item.span),
-        "consider deriving `Clone` or removing `Copy`",
-    );
-}
-
-/// Implementation of the `UNSAFE_DERIVE_DESERIALIZE` lint.
-fn check_unsafe_derive_deserialize<'tcx>(
-    cx: &LateContext<'tcx>,
-    item: &Item<'_>,
-    trait_ref: &hir::TraitRef<'_>,
-    ty: Ty<'tcx>,
-) {
-    fn has_unsafe<'tcx>(cx: &LateContext<'tcx>, item: &'tcx Item<'_>) -> bool {
-        let mut visitor = UnsafeVisitor { cx };
-        walk_item(&mut visitor, item).is_break()
-    }
-
-    if let Some(trait_def_id) = trait_ref.trait_def_id()
-        && paths::SERDE_DESERIALIZE.matches(cx, trait_def_id)
-        && let ty::Adt(def, _) = ty.kind()
-        && let Some(local_def_id) = def.did().as_local()
-        && let adt_hir_id = cx.tcx.local_def_id_to_hir_id(local_def_id)
-        && !is_lint_allowed(cx, UNSAFE_DERIVE_DESERIALIZE, adt_hir_id)
-        && cx
-            .tcx
-            .inherent_impls(def.did())
-            .iter()
-            .map(|imp_did| cx.tcx.hir_expect_item(imp_did.expect_local()))
-            .any(|imp| has_unsafe(cx, imp))
-    {
-        span_lint_hir_and_then(
-            cx,
-            UNSAFE_DERIVE_DESERIALIZE,
-            adt_hir_id,
-            item.span,
-            "you are deriving `serde::Deserialize` on a type that has methods using `unsafe`",
-            |diag| {
-                diag.help(
-                    "consider implementing `serde::Deserialize` manually. See https://serde.rs/impl-deserialize.html",
-                );
-            },
-        );
-    }
-}
-
-struct UnsafeVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-}
-
-impl<'tcx> Visitor<'tcx> for UnsafeVisitor<'_, 'tcx> {
-    type Result = ControlFlow<()>;
-    type NestedFilter = nested_filter::All;
-
-    fn visit_fn(
-        &mut self,
-        kind: FnKind<'tcx>,
-        decl: &'tcx FnDecl<'_>,
-        body_id: BodyId,
-        _: Span,
-        id: LocalDefId,
-    ) -> Self::Result {
-        if let Some(header) = kind.header()
-            && header.is_unsafe()
-        {
-            ControlFlow::Break(())
-        } else {
-            walk_fn(self, kind, decl, body_id, id)
-        }
-    }
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) -> Self::Result {
-        if let ExprKind::Block(block, _) = expr.kind
-            && block.rules == BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided)
-            && block
-                .span
-                .source_callee()
-                .and_then(|expr| expr.macro_def_id)
-                .is_none_or(|did| !self.cx.tcx.is_diagnostic_item(sym::pin_macro, did))
-        {
-            return ControlFlow::Break(());
-        }
-
-        walk_expr(self, expr)
-    }
-
-    fn maybe_tcx(&mut self) -> Self::MaybeTyCtxt {
-        self.cx.tcx
-    }
-}
-
-/// Implementation of the `DERIVE_PARTIAL_EQ_WITHOUT_EQ` lint.
-fn check_partial_eq_without_eq<'tcx>(cx: &LateContext<'tcx>, span: Span, trait_ref: &hir::TraitRef<'_>, ty: Ty<'tcx>) {
-    if let ty::Adt(adt, args) = ty.kind()
-        && cx.tcx.visibility(adt.did()).is_public()
-        && let Some(eq_trait_def_id) = cx.tcx.get_diagnostic_item(sym::Eq)
-        && let Some(def_id) = trait_ref.trait_def_id()
-        && cx.tcx.is_diagnostic_item(sym::PartialEq, def_id)
-        && !has_non_exhaustive_attr(cx.tcx, *adt)
-        && !ty_implements_eq_trait(cx.tcx, ty, eq_trait_def_id)
-        && let typing_env = typing_env_for_derived_eq(cx.tcx, adt.did(), eq_trait_def_id)
-        && let Some(local_def_id) = adt.did().as_local()
-        // If all of our fields implement `Eq`, we can implement `Eq` too
-        && adt
-            .all_fields()
-            .map(|f| f.ty(cx.tcx, args))
-            .all(|ty| implements_trait_with_env(cx.tcx, typing_env, ty, eq_trait_def_id, None, &[]))
-    {
-        span_lint_hir_and_then(
-            cx,
-            DERIVE_PARTIAL_EQ_WITHOUT_EQ,
-            cx.tcx.local_def_id_to_hir_id(local_def_id),
-            span.ctxt().outer_expn_data().call_site,
-            "you are deriving `PartialEq` and can implement `Eq`",
-            |diag| {
-                diag.span_suggestion(
-                    span.ctxt().outer_expn_data().call_site,
-                    "consider deriving `Eq` as well",
-                    "PartialEq, Eq",
-                    Applicability::MachineApplicable,
-                );
-            },
-        );
-    }
-}
-
-fn ty_implements_eq_trait<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, eq_trait_id: DefId) -> bool {
-    tcx.non_blanket_impls_for_ty(eq_trait_id, ty).next().is_some()
-}
-
-/// Creates the `ParamEnv` used for the given type's derived `Eq` impl.
-fn typing_env_for_derived_eq(tcx: TyCtxt<'_>, did: DefId, eq_trait_id: DefId) -> ty::TypingEnv<'_> {
-    // Initial map from generic index to param def.
-    // Vec<(param_def, needs_eq)>
-    let mut params = tcx
-        .generics_of(did)
-        .own_params
-        .iter()
-        .map(|p| (p, matches!(p.kind, GenericParamDefKind::Type { .. })))
-        .collect::<Vec<_>>();
-
-    let ty_predicates = tcx.predicates_of(did).predicates;
-    for (p, _) in ty_predicates {
-        if let ClauseKind::Trait(p) = p.kind().skip_binder()
-            && p.trait_ref.def_id == eq_trait_id
-            && let ty::Param(self_ty) = p.trait_ref.self_ty().kind()
-        {
-            // Flag types which already have an `Eq` bound.
-            params[self_ty.index as usize].1 = false;
-        }
-    }
-
-    let param_env = ParamEnv::new(tcx.mk_clauses_from_iter(ty_predicates.iter().map(|&(p, _)| p).chain(
-        params.iter().filter(|&&(_, needs_eq)| needs_eq).map(|&(param, _)| {
-            ClauseKind::Trait(TraitPredicate {
-                trait_ref: ty::TraitRef::new(tcx, eq_trait_id, [tcx.mk_param_from_def(param)]),
-                polarity: ty::PredicatePolarity::Positive,
-            })
-            .upcast(tcx)
-        }),
-    )));
-    ty::TypingEnv {
-        typing_mode: ty::TypingMode::non_body_analysis(),
-        param_env,
-    }
-}
diff --git a/clippy_lints/src/derive/unsafe_derive_deserialize.rs b/clippy_lints/src/derive/unsafe_derive_deserialize.rs
new file mode 100644
index 0000000000000..c391e7b62289f
--- /dev/null
+++ b/clippy_lints/src/derive/unsafe_derive_deserialize.rs
@@ -0,0 +1,93 @@
+use std::ops::ControlFlow;
+
+use clippy_utils::diagnostics::span_lint_hir_and_then;
+use clippy_utils::{is_lint_allowed, paths};
+use rustc_hir::def_id::LocalDefId;
+use rustc_hir::intravisit::{FnKind, Visitor, walk_expr, walk_fn, walk_item};
+use rustc_hir::{self as hir, BlockCheckMode, BodyId, Expr, ExprKind, FnDecl, Item, UnsafeSource};
+use rustc_lint::LateContext;
+use rustc_middle::hir::nested_filter;
+use rustc_middle::ty::{self, Ty};
+use rustc_span::{Span, sym};
+
+use super::UNSAFE_DERIVE_DESERIALIZE;
+
+/// Implementation of the `UNSAFE_DERIVE_DESERIALIZE` lint.
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, item: &Item<'_>, trait_ref: &hir::TraitRef<'_>, ty: Ty<'tcx>) {
+    fn has_unsafe<'tcx>(cx: &LateContext<'tcx>, item: &'tcx Item<'_>) -> bool {
+        let mut visitor = UnsafeVisitor { cx };
+        walk_item(&mut visitor, item).is_break()
+    }
+
+    if let Some(trait_def_id) = trait_ref.trait_def_id()
+        && paths::SERDE_DESERIALIZE.matches(cx, trait_def_id)
+        && let ty::Adt(def, _) = ty.kind()
+        && let Some(local_def_id) = def.did().as_local()
+        && let adt_hir_id = cx.tcx.local_def_id_to_hir_id(local_def_id)
+        && !is_lint_allowed(cx, UNSAFE_DERIVE_DESERIALIZE, adt_hir_id)
+        && cx
+            .tcx
+            .inherent_impls(def.did())
+            .iter()
+            .map(|imp_did| cx.tcx.hir_expect_item(imp_did.expect_local()))
+            .any(|imp| has_unsafe(cx, imp))
+    {
+        span_lint_hir_and_then(
+            cx,
+            UNSAFE_DERIVE_DESERIALIZE,
+            adt_hir_id,
+            item.span,
+            "you are deriving `serde::Deserialize` on a type that has methods using `unsafe`",
+            |diag| {
+                diag.help(
+                    "consider implementing `serde::Deserialize` manually. See https://serde.rs/impl-deserialize.html",
+                );
+            },
+        );
+    }
+}
+
+struct UnsafeVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+}
+
+impl<'tcx> Visitor<'tcx> for UnsafeVisitor<'_, 'tcx> {
+    type Result = ControlFlow<()>;
+    type NestedFilter = nested_filter::All;
+
+    fn visit_fn(
+        &mut self,
+        kind: FnKind<'tcx>,
+        decl: &'tcx FnDecl<'_>,
+        body_id: BodyId,
+        _: Span,
+        id: LocalDefId,
+    ) -> Self::Result {
+        if let Some(header) = kind.header()
+            && header.is_unsafe()
+        {
+            ControlFlow::Break(())
+        } else {
+            walk_fn(self, kind, decl, body_id, id)
+        }
+    }
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) -> Self::Result {
+        if let ExprKind::Block(block, _) = expr.kind
+            && block.rules == BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided)
+            && block
+                .span
+                .source_callee()
+                .and_then(|expr| expr.macro_def_id)
+                .is_none_or(|did| !self.cx.tcx.is_diagnostic_item(sym::pin_macro, did))
+        {
+            return ControlFlow::Break(());
+        }
+
+        walk_expr(self, expr)
+    }
+
+    fn maybe_tcx(&mut self) -> Self::MaybeTyCtxt {
+        self.cx.tcx
+    }
+}

From 26b157572280d058c8a800e4888f4b37062eb533 Mon Sep 17 00:00:00 2001
From: Berrysoft <Strawberry_Str@hotmail.com>
Date: Tue, 8 Apr 2025 18:07:43 +0800
Subject: [PATCH 0579/1889] Add socket extensions for cygwin

---
 library/std/src/os/cygwin/mod.rs              |  1 +
 library/std/src/os/cygwin/net.rs              | 17 ++++++
 library/std/src/os/mod.rs                     |  2 +-
 library/std/src/os/net/linux_ext/mod.rs       |  4 +-
 library/std/src/os/net/mod.rs                 |  2 +-
 library/std/src/os/unix/net/addr.rs           |  8 +--
 library/std/src/os/unix/net/ancillary.rs      | 31 ++++++-----
 library/std/src/os/unix/net/datagram.rs       | 52 ++++++++++++++-----
 library/std/src/os/unix/net/mod.rs            |  6 +--
 library/std/src/os/unix/net/stream.rs         | 26 +++++++---
 library/std/src/os/unix/net/tests.rs          | 27 +++++++---
 .../std/src/sys/net/connection/socket/unix.rs | 12 ++---
 12 files changed, 131 insertions(+), 57 deletions(-)
 create mode 100644 library/std/src/os/cygwin/net.rs

diff --git a/library/std/src/os/cygwin/mod.rs b/library/std/src/os/cygwin/mod.rs
index 7f6d6a645c855..a295a07caacf4 100644
--- a/library/std/src/os/cygwin/mod.rs
+++ b/library/std/src/os/cygwin/mod.rs
@@ -1,4 +1,5 @@
 //! Cygwin-specific definitions
 #![stable(feature = "raw_ext", since = "1.1.0")]
 pub mod fs;
+pub mod net;
 pub(crate) mod raw;
diff --git a/library/std/src/os/cygwin/net.rs b/library/std/src/os/cygwin/net.rs
new file mode 100644
index 0000000000000..0cccddb85d065
--- /dev/null
+++ b/library/std/src/os/cygwin/net.rs
@@ -0,0 +1,17 @@
+//! Cygwin-specific networking functionality.
+//!
+//! There are some limitations of Unix domain sockets on Cygwin:
+//! * The syscalls `accept` and `connect` need
+//! [handshake](https://inbox.sourceware.org/cygwin/Z_UERXFI1g-1v3p2@calimero.vinschen.de/T/#t).
+//! * Cannot bind to abstract addr.
+//! * Unbounded unix socket has an abstract local addr.
+//! * Doesn't support recvmsg with control data.
+
+#![stable(feature = "unix_socket_abstract", since = "1.70.0")]
+
+#[stable(feature = "unix_socket_abstract", since = "1.70.0")]
+pub use crate::os::net::linux_ext::addr::SocketAddrExt;
+#[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+pub use crate::os::net::linux_ext::socket::UnixSocketExt;
+#[stable(feature = "tcp_quickack", since = "1.89.0")]
+pub use crate::os::net::linux_ext::tcp::TcpStreamExt;
diff --git a/library/std/src/os/mod.rs b/library/std/src/os/mod.rs
index ab7734a795268..96d9bfae8ca32 100644
--- a/library/std/src/os/mod.rs
+++ b/library/std/src/os/mod.rs
@@ -185,5 +185,5 @@ pub mod xous;
 #[cfg(any(unix, target_os = "hermit", target_os = "trusty", target_os = "wasi", doc))]
 pub mod fd;
 
-#[cfg(any(target_os = "linux", target_os = "android", doc))]
+#[cfg(any(target_os = "linux", target_os = "android", target_os = "cygwin", doc))]
 mod net;
diff --git a/library/std/src/os/net/linux_ext/mod.rs b/library/std/src/os/net/linux_ext/mod.rs
index 3c9afe35479df..f3f3fdd258cd6 100644
--- a/library/std/src/os/net/linux_ext/mod.rs
+++ b/library/std/src/os/net/linux_ext/mod.rs
@@ -1,6 +1,6 @@
-//! Linux and Android-specific networking functionality.
+//! Linux, Android and Cygwin-specific networking functionality.
 
-#![doc(cfg(any(target_os = "linux", target_os = "android")))]
+#![doc(cfg(any(target_os = "linux", target_os = "android", target_os = "cygwin")))]
 
 #[stable(feature = "unix_socket_abstract", since = "1.70.0")]
 pub(crate) mod addr;
diff --git a/library/std/src/os/net/mod.rs b/library/std/src/os/net/mod.rs
index b7046dd7c598c..47e69b3a260dc 100644
--- a/library/std/src/os/net/mod.rs
+++ b/library/std/src/os/net/mod.rs
@@ -9,5 +9,5 @@
         all(target_vendor = "fortanix", target_env = "sgx")
     )
 )))]
-#[cfg(any(target_os = "linux", target_os = "android", doc))]
+#[cfg(any(target_os = "linux", target_os = "android", target_os = "cygwin", doc))]
 pub(super) mod linux_ext;
diff --git a/library/std/src/os/unix/net/addr.rs b/library/std/src/os/unix/net/addr.rs
index fd6fe72dd248b..25b95014e08b2 100644
--- a/library/std/src/os/unix/net/addr.rs
+++ b/library/std/src/os/unix/net/addr.rs
@@ -1,6 +1,6 @@
 use crate::bstr::ByteStr;
 use crate::ffi::OsStr;
-#[cfg(any(doc, target_os = "android", target_os = "linux"))]
+#[cfg(any(doc, target_os = "android", target_os = "linux", target_os = "cygwin"))]
 use crate::os::net::linux_ext;
 use crate::os::unix::ffi::OsStrExt;
 use crate::path::Path;
@@ -241,7 +241,7 @@ impl SocketAddr {
 
         // macOS seems to return a len of 16 and a zeroed sun_path for unnamed addresses
         if len == 0
-            || (cfg!(not(any(target_os = "linux", target_os = "android")))
+            || (cfg!(not(any(target_os = "linux", target_os = "android", target_os = "cygwin")))
                 && self.addr.sun_path[0] == 0)
         {
             AddressKind::Unnamed
@@ -256,8 +256,8 @@ impl SocketAddr {
 #[stable(feature = "unix_socket_abstract", since = "1.70.0")]
 impl Sealed for SocketAddr {}
 
-#[doc(cfg(any(target_os = "android", target_os = "linux")))]
-#[cfg(any(doc, target_os = "android", target_os = "linux"))]
+#[doc(cfg(any(target_os = "android", target_os = "linux", target_os = "cygwin")))]
+#[cfg(any(doc, target_os = "android", target_os = "linux", target_os = "cygwin"))]
 #[stable(feature = "unix_socket_abstract", since = "1.70.0")]
 impl linux_ext::addr::SocketAddrExt for SocketAddr {
     fn as_abstract_name(&self) -> Option<&[u8]> {
diff --git a/library/std/src/os/unix/net/ancillary.rs b/library/std/src/os/unix/net/ancillary.rs
index 36967fc3f98b0..d0984bdfb99d1 100644
--- a/library/std/src/os/unix/net/ancillary.rs
+++ b/library/std/src/os/unix/net/ancillary.rs
@@ -16,7 +16,8 @@ use crate::sys::net::Socket;
     not(target_os = "linux"),
     not(target_os = "android"),
     not(target_os = "netbsd"),
-    not(target_os = "freebsd")
+    not(target_os = "freebsd"),
+    not(target_os = "cygwin"),
 ))]
 #[allow(non_camel_case_types)]
 mod libc {
@@ -195,14 +196,15 @@ impl<'a, T> Iterator for AncillaryDataIter<'a, T> {
     not(target_os = "android"),
     not(target_os = "linux"),
     not(target_os = "netbsd"),
-    not(target_os = "freebsd")
+    not(target_os = "freebsd"),
+    not(target_os = "cygwin"),
 ))]
 #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
 #[derive(Clone)]
 pub struct SocketCred(());
 
 /// Unix credential.
-#[cfg(any(target_os = "android", target_os = "linux",))]
+#[cfg(any(target_os = "android", target_os = "linux", target_os = "cygwin"))]
 #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
 #[derive(Clone)]
 pub struct SocketCred(libc::ucred);
@@ -217,8 +219,8 @@ pub struct SocketCred(libc::sockcred);
 #[derive(Clone)]
 pub struct SocketCred(libc::sockcred2);
 
-#[doc(cfg(any(target_os = "android", target_os = "linux")))]
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[doc(cfg(any(target_os = "android", target_os = "linux", target_os = "cygwin")))]
+#[cfg(any(target_os = "android", target_os = "linux", target_os = "cygwin"))]
 impl SocketCred {
     /// Creates a Unix credential struct.
     ///
@@ -407,7 +409,8 @@ impl<'a> Iterator for ScmRights<'a> {
     not(target_os = "android"),
     not(target_os = "linux"),
     not(target_os = "netbsd"),
-    not(target_os = "freebsd")
+    not(target_os = "freebsd"),
+    not(target_os = "cygwin"),
 ))]
 #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
 pub struct ScmCredentials<'a>(AncillaryDataIter<'a, ()>);
@@ -415,7 +418,7 @@ pub struct ScmCredentials<'a>(AncillaryDataIter<'a, ()>);
 /// This control message contains unix credentials.
 ///
 /// The level is equal to `SOL_SOCKET` and the type is equal to `SCM_CREDENTIALS` or `SCM_CREDS`.
-#[cfg(any(target_os = "android", target_os = "linux",))]
+#[cfg(any(target_os = "android", target_os = "linux", target_os = "cygwin"))]
 #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
 pub struct ScmCredentials<'a>(AncillaryDataIter<'a, libc::ucred>);
 
@@ -432,7 +435,8 @@ pub struct ScmCredentials<'a>(AncillaryDataIter<'a, libc::sockcred>);
     target_os = "android",
     target_os = "linux",
     target_os = "netbsd",
-    target_os = "freebsd"
+    target_os = "freebsd",
+    target_os = "cygwin",
 ))]
 #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
 impl<'a> Iterator for ScmCredentials<'a> {
@@ -460,7 +464,8 @@ pub enum AncillaryData<'a> {
         target_os = "android",
         target_os = "linux",
         target_os = "netbsd",
-        target_os = "freebsd"
+        target_os = "freebsd",
+        target_os = "cygwin",
     ))]
     ScmCredentials(ScmCredentials<'a>),
 }
@@ -489,7 +494,8 @@ impl<'a> AncillaryData<'a> {
         target_os = "android",
         target_os = "linux",
         target_os = "netbsd",
-        target_os = "freebsd"
+        target_os = "freebsd",
+        target_os = "cygwin",
     ))]
     unsafe fn as_credentials(data: &'a [u8]) -> Self {
         let ancillary_data_iter = AncillaryDataIter::new(data);
@@ -507,7 +513,7 @@ impl<'a> AncillaryData<'a> {
             match (*cmsg).cmsg_level {
                 libc::SOL_SOCKET => match (*cmsg).cmsg_type {
                     libc::SCM_RIGHTS => Ok(AncillaryData::as_rights(data)),
-                    #[cfg(any(target_os = "android", target_os = "linux",))]
+                    #[cfg(any(target_os = "android", target_os = "linux", target_os = "cygwin"))]
                     libc::SCM_CREDENTIALS => Ok(AncillaryData::as_credentials(data)),
                     #[cfg(target_os = "freebsd")]
                     libc::SCM_CREDS2 => Ok(AncillaryData::as_credentials(data)),
@@ -729,7 +735,8 @@ impl<'a> SocketAncillary<'a> {
         target_os = "android",
         target_os = "linux",
         target_os = "netbsd",
-        target_os = "freebsd"
+        target_os = "freebsd",
+        target_os = "cygwin",
     ))]
     #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
     pub fn add_creds(&mut self, creds: &[SocketCred]) -> bool {
diff --git a/library/std/src/os/unix/net/datagram.rs b/library/std/src/os/unix/net/datagram.rs
index 7735637c84059..469bfbb0d837f 100644
--- a/library/std/src/os/unix/net/datagram.rs
+++ b/library/std/src/os/unix/net/datagram.rs
@@ -14,9 +14,9 @@
 use libc::MSG_NOSIGNAL;
 
 use super::{SocketAddr, sockaddr_un};
-#[cfg(any(doc, target_os = "android", target_os = "linux"))]
+#[cfg(any(doc, target_os = "android", target_os = "linux", target_os = "cygwin"))]
 use super::{SocketAncillary, recv_vectored_with_ancillary_from, send_vectored_with_ancillary_to};
-#[cfg(any(doc, target_os = "android", target_os = "linux"))]
+#[cfg(any(doc, target_os = "android", target_os = "linux", target_os = "cygwin"))]
 use crate::io::{IoSlice, IoSliceMut};
 use crate::net::Shutdown;
 use crate::os::unix::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd};
@@ -397,8 +397,14 @@ impl UnixDatagram {
     ///
     /// # Examples
     ///
-    #[cfg_attr(any(target_os = "android", target_os = "linux"), doc = "```no_run")]
-    #[cfg_attr(not(any(target_os = "android", target_os = "linux")), doc = "```ignore")]
+    #[cfg_attr(
+        any(target_os = "android", target_os = "linux", target_os = "cygwin"),
+        doc = "```no_run"
+    )]
+    #[cfg_attr(
+        not(any(target_os = "android", target_os = "linux", target_os = "cygwin")),
+        doc = "```ignore"
+    )]
     /// #![feature(unix_socket_ancillary_data)]
     /// use std::os::unix::net::{UnixDatagram, SocketAncillary, AncillaryData};
     /// use std::io::IoSliceMut;
@@ -428,7 +434,7 @@ impl UnixDatagram {
     ///     Ok(())
     /// }
     /// ```
-    #[cfg(any(doc, target_os = "android", target_os = "linux"))]
+    #[cfg(any(doc, target_os = "android", target_os = "linux", target_os = "cygwin"))]
     #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
     pub fn recv_vectored_with_ancillary_from(
         &self,
@@ -447,8 +453,14 @@ impl UnixDatagram {
     ///
     /// # Examples
     ///
-    #[cfg_attr(any(target_os = "android", target_os = "linux"), doc = "```no_run")]
-    #[cfg_attr(not(any(target_os = "android", target_os = "linux")), doc = "```ignore")]
+    #[cfg_attr(
+        any(target_os = "android", target_os = "linux", target_os = "cygwin"),
+        doc = "```no_run"
+    )]
+    #[cfg_attr(
+        not(any(target_os = "android", target_os = "linux", target_os = "cygwin")),
+        doc = "```ignore"
+    )]
     /// #![feature(unix_socket_ancillary_data)]
     /// use std::os::unix::net::{UnixDatagram, SocketAncillary, AncillaryData};
     /// use std::io::IoSliceMut;
@@ -478,7 +490,7 @@ impl UnixDatagram {
     ///     Ok(())
     /// }
     /// ```
-    #[cfg(any(doc, target_os = "android", target_os = "linux"))]
+    #[cfg(any(doc, target_os = "android", target_os = "linux", target_os = "cygwin"))]
     #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
     pub fn recv_vectored_with_ancillary(
         &self,
@@ -588,8 +600,14 @@ impl UnixDatagram {
     ///
     /// # Examples
     ///
-    #[cfg_attr(any(target_os = "android", target_os = "linux"), doc = "```no_run")]
-    #[cfg_attr(not(any(target_os = "android", target_os = "linux")), doc = "```ignore")]
+    #[cfg_attr(
+        any(target_os = "android", target_os = "linux", target_os = "cygwin"),
+        doc = "```no_run"
+    )]
+    #[cfg_attr(
+        not(any(target_os = "android", target_os = "linux", target_os = "cygwin")),
+        doc = "```ignore"
+    )]
     /// #![feature(unix_socket_ancillary_data)]
     /// use std::os::unix::net::{UnixDatagram, SocketAncillary};
     /// use std::io::IoSlice;
@@ -613,7 +631,7 @@ impl UnixDatagram {
     ///     Ok(())
     /// }
     /// ```
-    #[cfg(any(doc, target_os = "android", target_os = "linux"))]
+    #[cfg(any(doc, target_os = "android", target_os = "linux", target_os = "cygwin"))]
     #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
     pub fn send_vectored_with_ancillary_to<P: AsRef<Path>>(
         &self,
@@ -630,8 +648,14 @@ impl UnixDatagram {
     ///
     /// # Examples
     ///
-    #[cfg_attr(any(target_os = "android", target_os = "linux"), doc = "```no_run")]
-    #[cfg_attr(not(any(target_os = "android", target_os = "linux")), doc = "```ignore")]
+    #[cfg_attr(
+        any(target_os = "android", target_os = "linux", target_os = "cygwin"),
+        doc = "```no_run"
+    )]
+    #[cfg_attr(
+        not(any(target_os = "android", target_os = "linux", target_os = "cygwin")),
+        doc = "```ignore"
+    )]
     /// #![feature(unix_socket_ancillary_data)]
     /// use std::os::unix::net::{UnixDatagram, SocketAncillary};
     /// use std::io::IoSlice;
@@ -655,7 +679,7 @@ impl UnixDatagram {
     ///     Ok(())
     /// }
     /// ```
-    #[cfg(any(doc, target_os = "android", target_os = "linux"))]
+    #[cfg(any(doc, target_os = "android", target_os = "linux", target_os = "cygwin"))]
     #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
     pub fn send_vectored_with_ancillary(
         &self,
diff --git a/library/std/src/os/unix/net/mod.rs b/library/std/src/os/unix/net/mod.rs
index 6cd62303a5325..94523d7d1e450 100644
--- a/library/std/src/os/unix/net/mod.rs
+++ b/library/std/src/os/unix/net/mod.rs
@@ -4,8 +4,8 @@
 #![stable(feature = "unix_socket", since = "1.10.0")]
 
 mod addr;
-#[doc(cfg(any(target_os = "android", target_os = "linux")))]
-#[cfg(any(doc, target_os = "android", target_os = "linux"))]
+#[doc(cfg(any(target_os = "android", target_os = "linux", target_os = "cygwin")))]
+#[cfg(any(doc, target_os = "android", target_os = "linux", target_os = "cygwin"))]
 mod ancillary;
 mod datagram;
 mod listener;
@@ -27,7 +27,7 @@ mod ucred;
 
 #[stable(feature = "unix_socket", since = "1.10.0")]
 pub use self::addr::*;
-#[cfg(any(doc, target_os = "android", target_os = "linux"))]
+#[cfg(any(doc, target_os = "android", target_os = "linux", target_os = "cygwin"))]
 #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
 pub use self::ancillary::*;
 #[stable(feature = "unix_socket", since = "1.10.0")]
diff --git a/library/std/src/os/unix/net/stream.rs b/library/std/src/os/unix/net/stream.rs
index 035768a6fab7a..e541870d2f5cc 100644
--- a/library/std/src/os/unix/net/stream.rs
+++ b/library/std/src/os/unix/net/stream.rs
@@ -14,7 +14,7 @@ cfg_if::cfg_if! {
 }
 
 use super::{SocketAddr, sockaddr_un};
-#[cfg(any(doc, target_os = "android", target_os = "linux"))]
+#[cfg(any(doc, target_os = "android", target_os = "linux", target_os = "cygwin"))]
 use super::{SocketAncillary, recv_vectored_with_ancillary_from, send_vectored_with_ancillary_to};
 #[cfg(any(
     target_os = "android",
@@ -506,8 +506,14 @@ impl UnixStream {
     ///
     /// # Examples
     ///
-    #[cfg_attr(any(target_os = "android", target_os = "linux"), doc = "```no_run")]
-    #[cfg_attr(not(any(target_os = "android", target_os = "linux")), doc = "```ignore")]
+    #[cfg_attr(
+        any(target_os = "android", target_os = "linux", target_os = "cygwin"),
+        doc = "```no_run"
+    )]
+    #[cfg_attr(
+        not(any(target_os = "android", target_os = "linux", target_os = "cygwin")),
+        doc = "```ignore"
+    )]
     /// #![feature(unix_socket_ancillary_data)]
     /// use std::os::unix::net::{UnixStream, SocketAncillary, AncillaryData};
     /// use std::io::IoSliceMut;
@@ -537,7 +543,7 @@ impl UnixStream {
     ///     Ok(())
     /// }
     /// ```
-    #[cfg(any(doc, target_os = "android", target_os = "linux"))]
+    #[cfg(any(doc, target_os = "android", target_os = "linux", target_os = "cygwin"))]
     #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
     pub fn recv_vectored_with_ancillary(
         &self,
@@ -555,8 +561,14 @@ impl UnixStream {
     ///
     /// # Examples
     ///
-    #[cfg_attr(any(target_os = "android", target_os = "linux"), doc = "```no_run")]
-    #[cfg_attr(not(any(target_os = "android", target_os = "linux")), doc = "```ignore")]
+    #[cfg_attr(
+        any(target_os = "android", target_os = "linux", target_os = "cygwin"),
+        doc = "```no_run"
+    )]
+    #[cfg_attr(
+        not(any(target_os = "android", target_os = "linux", target_os = "cygwin")),
+        doc = "```ignore"
+    )]
     /// #![feature(unix_socket_ancillary_data)]
     /// use std::os::unix::net::{UnixStream, SocketAncillary};
     /// use std::io::IoSlice;
@@ -580,7 +592,7 @@ impl UnixStream {
     ///     Ok(())
     /// }
     /// ```
-    #[cfg(any(doc, target_os = "android", target_os = "linux"))]
+    #[cfg(any(doc, target_os = "android", target_os = "linux", target_os = "cygwin"))]
     #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
     pub fn send_vectored_with_ancillary(
         &self,
diff --git a/library/std/src/os/unix/net/tests.rs b/library/std/src/os/unix/net/tests.rs
index 9a88687b1df0c..4666b5e3c6c18 100644
--- a/library/std/src/os/unix/net/tests.rs
+++ b/library/std/src/os/unix/net/tests.rs
@@ -3,6 +3,8 @@ use crate::io::prelude::*;
 use crate::io::{self, ErrorKind, IoSlice, IoSliceMut};
 #[cfg(target_os = "android")]
 use crate::os::android::net::{SocketAddrExt, UnixSocketExt};
+#[cfg(target_os = "cygwin")]
+use crate::os::cygwin::net::{SocketAddrExt, UnixSocketExt};
 #[cfg(target_os = "linux")]
 use crate::os::linux::net::{SocketAddrExt, UnixSocketExt};
 #[cfg(any(target_os = "android", target_os = "linux"))]
@@ -170,6 +172,7 @@ fn long_path() {
 #[test]
 #[cfg(not(target_os = "nto"))]
 #[cfg_attr(target_os = "android", ignore)] // Android SELinux rules prevent creating Unix sockets
+#[cfg_attr(target_os = "cygwin", ignore)] // Cygwin connect needs handshake
 fn timeouts() {
     let dir = tmpdir();
     let socket_path = dir.path().join("sock");
@@ -198,6 +201,7 @@ fn timeouts() {
 
 #[test]
 #[cfg_attr(target_os = "android", ignore)] // Android SELinux rules prevent creating Unix sockets
+#[cfg_attr(target_os = "cygwin", ignore)] // Cygwin connect needs handshake
 fn test_read_timeout() {
     let dir = tmpdir();
     let socket_path = dir.path().join("sock");
@@ -218,6 +222,7 @@ fn test_read_timeout() {
 
 #[test]
 #[cfg_attr(target_os = "android", ignore)] // Android SELinux rules prevent creating Unix sockets
+#[cfg_attr(target_os = "cygwin", ignore)] // Cygwin connect needs handshake
 fn test_read_with_timeout() {
     let dir = tmpdir();
     let socket_path = dir.path().join("sock");
@@ -246,6 +251,7 @@ fn test_read_with_timeout() {
 // when passed zero Durations
 #[test]
 #[cfg_attr(target_os = "android", ignore)] // Android SELinux rules prevent creating Unix sockets
+#[cfg_attr(target_os = "cygwin", ignore)] // Cygwin connect needs handshake
 fn test_unix_stream_timeout_zero_duration() {
     let dir = tmpdir();
     let socket_path = dir.path().join("sock");
@@ -283,6 +289,7 @@ fn test_unix_datagram() {
 
 #[test]
 #[cfg_attr(target_os = "android", ignore)] // Android SELinux rules prevent creating Unix sockets
+#[cfg_attr(target_os = "cygwin", ignore)] // Cygwin autobinds an address
 fn test_unnamed_unix_datagram() {
     let dir = tmpdir();
     let path1 = dir.path().join("sock1");
@@ -326,6 +333,7 @@ fn test_unix_datagram_connect_to_recv_addr() {
 
 #[test]
 #[cfg_attr(target_os = "android", ignore)] // Android SELinux rules prevent creating Unix sockets
+#[cfg_attr(target_os = "cygwin", ignore)] // Cygwin autobinds an address
 fn test_connect_unix_datagram() {
     let dir = tmpdir();
     let path1 = dir.path().join("sock1");
@@ -425,8 +433,9 @@ fn abstract_namespace_not_allowed_connect() {
     assert!(UnixStream::connect("\0asdf").is_err());
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(any(target_os = "android", target_os = "linux", target_os = "cygwin"))]
 #[test]
+#[cfg_attr(target_os = "cygwin", ignore)] // Cygwin cannot bind to abstract addr
 fn test_abstract_stream_connect() {
     let msg1 = b"hello";
     let msg2 = b"world";
@@ -456,8 +465,9 @@ fn test_abstract_stream_connect() {
     thread.join().unwrap();
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(any(target_os = "android", target_os = "linux", target_os = "cygwin"))]
 #[test]
+#[cfg_attr(target_os = "cygwin", ignore)] // Cygwin cannot bind to abstract addr
 fn test_abstract_stream_iter() {
     let addr = or_panic!(SocketAddr::from_abstract_name(b"hidden"));
     let listener = or_panic!(UnixListener::bind_addr(&addr));
@@ -478,8 +488,9 @@ fn test_abstract_stream_iter() {
     thread.join().unwrap();
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(any(target_os = "android", target_os = "linux", target_os = "cygwin"))]
 #[test]
+#[cfg_attr(target_os = "cygwin", ignore)] // Cygwin cannot bind to abstract addr
 fn test_abstract_datagram_bind_send_to_addr() {
     let addr1 = or_panic!(SocketAddr::from_abstract_name(b"ns1"));
     let sock1 = or_panic!(UnixDatagram::bind_addr(&addr1));
@@ -499,8 +510,9 @@ fn test_abstract_datagram_bind_send_to_addr() {
     assert_eq!(addr.as_abstract_name().unwrap(), b"ns1");
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(any(target_os = "android", target_os = "linux", target_os = "cygwin"))]
 #[test]
+#[cfg_attr(target_os = "cygwin", ignore)] // Cygwin cannot bind to abstract addr
 fn test_abstract_datagram_connect_addr() {
     let addr1 = or_panic!(SocketAddr::from_abstract_name(b"ns3"));
     let bsock1 = or_panic!(UnixDatagram::bind_addr(&addr1));
@@ -524,7 +536,7 @@ fn test_abstract_datagram_connect_addr() {
     or_panic!(bsock2.recv_from(&mut buf));
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(any(target_os = "android", target_os = "linux", target_os = "cygwin"))]
 #[test]
 fn test_abstract_name_too_long() {
     match SocketAddr::from_abstract_name(
@@ -538,7 +550,7 @@ fn test_abstract_name_too_long() {
     }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(any(target_os = "android", target_os = "linux", target_os = "cygwin"))]
 #[test]
 fn test_abstract_no_pathname_and_not_unnamed() {
     let name = b"local";
@@ -669,9 +681,10 @@ fn test_send_vectored_fds_unix_stream() {
     }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(any(target_os = "android", target_os = "linux", target_os = "cygwin"))]
 #[test]
 #[cfg_attr(target_os = "android", ignore)] // Android SELinux rules prevent creating Unix sockets
+#[cfg_attr(target_os = "cygwin", ignore)] // Cygwin recvmsg doesn't support Unix sockets
 fn test_send_vectored_with_ancillary_to_unix_datagram() {
     fn getpid() -> libc::pid_t {
         unsafe { libc::getpid() }
diff --git a/library/std/src/sys/net/connection/socket/unix.rs b/library/std/src/sys/net/connection/socket/unix.rs
index cc111f3521bc1..97e5c4c5d2a72 100644
--- a/library/std/src/sys/net/connection/socket/unix.rs
+++ b/library/std/src/sys/net/connection/socket/unix.rs
@@ -357,7 +357,7 @@ impl Socket {
         self.recv_from_with_flags(buf, 0)
     }
 
-    #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg(any(target_os = "android", target_os = "linux", target_os = "cygwin"))]
     pub fn recv_msg(&self, msg: &mut libc::msghdr) -> io::Result<usize> {
         let n = cvt(unsafe { libc::recvmsg(self.as_raw_fd(), msg, libc::MSG_CMSG_CLOEXEC) })?;
         Ok(n as usize)
@@ -380,7 +380,7 @@ impl Socket {
         self.0.is_write_vectored()
     }
 
-    #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg(any(target_os = "android", target_os = "linux", target_os = "cygwin"))]
     pub fn send_msg(&self, msg: &mut libc::msghdr) -> io::Result<usize> {
         let n = cvt(unsafe { libc::sendmsg(self.as_raw_fd(), msg, 0) })?;
         Ok(n as usize)
@@ -468,12 +468,12 @@ impl Socket {
         Ok(raw != 0)
     }
 
-    #[cfg(any(target_os = "android", target_os = "linux",))]
+    #[cfg(any(target_os = "android", target_os = "linux", target_os = "cygwin"))]
     pub fn set_quickack(&self, quickack: bool) -> io::Result<()> {
         setsockopt(self, libc::IPPROTO_TCP, libc::TCP_QUICKACK, quickack as c_int)
     }
 
-    #[cfg(any(target_os = "android", target_os = "linux",))]
+    #[cfg(any(target_os = "android", target_os = "linux", target_os = "cygwin"))]
     pub fn quickack(&self) -> io::Result<bool> {
         let raw: c_int = getsockopt(self, libc::IPPROTO_TCP, libc::TCP_QUICKACK)?;
         Ok(raw != 0)
@@ -537,12 +537,12 @@ impl Socket {
         Ok(raw != 0)
     }
 
-    #[cfg(any(target_os = "android", target_os = "linux",))]
+    #[cfg(any(target_os = "android", target_os = "linux", target_os = "cygwin"))]
     pub fn set_passcred(&self, passcred: bool) -> io::Result<()> {
         setsockopt(self, libc::SOL_SOCKET, libc::SO_PASSCRED, passcred as libc::c_int)
     }
 
-    #[cfg(any(target_os = "android", target_os = "linux",))]
+    #[cfg(any(target_os = "android", target_os = "linux", target_os = "cygwin"))]
     pub fn passcred(&self) -> io::Result<bool> {
         let passcred: libc::c_int = getsockopt(self, libc::SOL_SOCKET, libc::SO_PASSCRED)?;
         Ok(passcred != 0)

From 93101b5783b522469320b60926918f308ddae6b6 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sat, 6 Sep 2025 14:32:36 +0200
Subject: [PATCH 0580/1889] s390x: use the new `u128::funnel_shl`

---
 library/stdarch/crates/core_arch/src/lib.rs     |  3 ++-
 .../crates/core_arch/src/s390x/vector.rs        | 17 +++--------------
 2 files changed, 5 insertions(+), 15 deletions(-)

diff --git a/library/stdarch/crates/core_arch/src/lib.rs b/library/stdarch/crates/core_arch/src/lib.rs
index 7d3cbd55ad85c..26a9cb5899183 100644
--- a/library/stdarch/crates/core_arch/src/lib.rs
+++ b/library/stdarch/crates/core_arch/src/lib.rs
@@ -33,7 +33,8 @@
     x86_amx_intrinsics,
     f16,
     aarch64_unstable_target_feature,
-    bigint_helper_methods
+    bigint_helper_methods,
+    funnel_shifts
 )]
 #![cfg_attr(test, feature(test, abi_vectorcall, stdarch_internal))]
 #![deny(clippy::missing_inline_in_public_items)]
diff --git a/library/stdarch/crates/core_arch/src/s390x/vector.rs b/library/stdarch/crates/core_arch/src/s390x/vector.rs
index f6d14c45e0d2b..f018344ead12d 100644
--- a/library/stdarch/crates/core_arch/src/s390x/vector.rs
+++ b/library/stdarch/crates/core_arch/src/s390x/vector.rs
@@ -3513,17 +3513,6 @@ mod sealed {
         a.vec_srdb::<7>(b)
     }
 
-    unsafe fn funnel_shl_u128(a: u128, b: u128, c: u128) -> u128 {
-        #[repr(simd)]
-        struct Single([u128; 1]);
-
-        transmute(simd_funnel_shl::<Single>(
-            transmute(a),
-            transmute(b),
-            transmute(c),
-        ))
-    }
-
     macro_rules! impl_vec_sld {
         ($($ty:ident)*) => {
             $(
@@ -3533,21 +3522,21 @@ mod sealed {
                     #[target_feature(enable = "vector")]
                     unsafe fn vec_sld<const C: u32>(self, b: Self) -> Self {
                         static_assert_uimm_bits!(C, 4);
-                        transmute(funnel_shl_u128(transmute(self), transmute(b), const { C as u128 * 8 }))
+                        transmute(u128::funnel_shl(transmute(self), transmute(b), C  * 8))
                     }
 
                     #[inline]
                     #[target_feature(enable = "vector")]
                     unsafe fn vec_sldw<const C: u32>(self, b: Self) -> Self {
                         static_assert_uimm_bits!(C, 2);
-                        transmute(funnel_shl_u128(transmute(self), transmute(b), const { C as u128 * 4 * 8 }))
+                        transmute(u128::funnel_shl(transmute(self), transmute(b), C * 4 * 8))
                     }
 
                     #[inline]
                     #[target_feature(enable = "vector-enhancements-2")]
                     unsafe fn vec_sldb<const C: u32>(self, b: Self) -> Self {
                         static_assert_uimm_bits!(C, 3);
-                        transmute(funnel_shl_u128(transmute(self), transmute(b), const { C as u128 }))
+                        transmute(u128::funnel_shl(transmute(self), transmute(b), C))
                     }
                 }
 

From 9239d141dc4e9435b036d34cf8b2cb1e37b9f454 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Fri, 5 Sep 2025 14:46:46 +0000
Subject: [PATCH 0581/1889] Add test that __rg_oom doesn't get internalized
 during LTO
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-Authored-By: Rémy Rakic <remy.rakic+github@gmail.com>
---
 tests/ui/lto/lto-global-allocator.rs | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 tests/ui/lto/lto-global-allocator.rs

diff --git a/tests/ui/lto/lto-global-allocator.rs b/tests/ui/lto/lto-global-allocator.rs
new file mode 100644
index 0000000000000..03f11709c901a
--- /dev/null
+++ b/tests/ui/lto/lto-global-allocator.rs
@@ -0,0 +1,19 @@
+//@ compile-flags: --crate-type cdylib -C lto
+//@ build-pass
+//@ no-prefer-dynamic
+//@ needs-crate-type: cdylib
+
+use std::alloc::{GlobalAlloc, Layout};
+
+struct MyAllocator;
+
+unsafe impl GlobalAlloc for MyAllocator {
+    unsafe fn alloc(&self, _layout: Layout) -> *mut u8 {
+        todo!()
+    }
+
+    unsafe fn dealloc(&self, _ptr: *mut u8, _layout: Layout) {}
+}
+
+#[global_allocator]
+static GLOBAL: MyAllocator = MyAllocator;

From 2cf94b92ca852924ad90943a0c469f01742216a6 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Fri, 5 Sep 2025 19:09:39 +0000
Subject: [PATCH 0582/1889] Ensure fat LTO doesn't merge everything into the
 allocator module

---
 compiler/rustc_codegen_cranelift/src/driver/aot.rs | 11 ++++++++++-
 compiler/rustc_codegen_llvm/src/back/lto.rs        |  8 +++++++-
 compiler/rustc_codegen_ssa/src/back/write.rs       |  3 ++-
 compiler/rustc_codegen_ssa/src/lib.rs              |  2 ++
 4 files changed, 21 insertions(+), 3 deletions(-)

diff --git a/compiler/rustc_codegen_cranelift/src/driver/aot.rs b/compiler/rustc_codegen_cranelift/src/driver/aot.rs
index c3adb5e767e25..7e77781dc2fc1 100644
--- a/compiler/rustc_codegen_cranelift/src/driver/aot.rs
+++ b/compiler/rustc_codegen_cranelift/src/driver/aot.rs
@@ -12,7 +12,9 @@ use cranelift_object::{ObjectBuilder, ObjectModule};
 use rustc_codegen_ssa::assert_module_sources::CguReuse;
 use rustc_codegen_ssa::back::link::ensure_removed;
 use rustc_codegen_ssa::base::determine_cgu_reuse;
-use rustc_codegen_ssa::{CodegenResults, CompiledModule, CrateInfo, errors as ssa_errors};
+use rustc_codegen_ssa::{
+    CodegenResults, CompiledModule, CrateInfo, ModuleKind, errors as ssa_errors,
+};
 use rustc_data_structures::profiling::SelfProfilerRef;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_data_structures::sync::{IntoDynSyncSend, par_map};
@@ -361,6 +363,7 @@ fn emit_cgu(
         invocation_temp,
         prof,
         product.object,
+        ModuleKind::Regular,
         name.clone(),
         producer,
     )?;
@@ -369,6 +372,7 @@ fn emit_cgu(
         module_regular,
         module_global_asm: global_asm_object_file.map(|global_asm_object_file| CompiledModule {
             name: format!("{name}.asm"),
+            kind: ModuleKind::Regular,
             object: Some(global_asm_object_file),
             dwarf_object: None,
             bytecode: None,
@@ -385,6 +389,7 @@ fn emit_module(
     invocation_temp: Option<&str>,
     prof: &SelfProfilerRef,
     mut object: cranelift_object::object::write::Object<'_>,
+    kind: ModuleKind,
     name: String,
     producer_str: &str,
 ) -> Result<CompiledModule, String> {
@@ -425,6 +430,7 @@ fn emit_module(
 
     Ok(CompiledModule {
         name,
+        kind,
         object: Some(tmp_file),
         dwarf_object: None,
         bytecode: None,
@@ -479,6 +485,7 @@ fn reuse_workproduct_for_cgu(
     Ok(ModuleCodegenResult {
         module_regular: CompiledModule {
             name: cgu.name().to_string(),
+            kind: ModuleKind::Regular,
             object: Some(obj_out_regular),
             dwarf_object: None,
             bytecode: None,
@@ -488,6 +495,7 @@ fn reuse_workproduct_for_cgu(
         },
         module_global_asm: source_file_global_asm.map(|source_file| CompiledModule {
             name: cgu.name().to_string(),
+            kind: ModuleKind::Regular,
             object: Some(obj_out_global_asm),
             dwarf_object: None,
             bytecode: None,
@@ -643,6 +651,7 @@ fn emit_allocator_module(tcx: TyCtxt<'_>) -> Option<CompiledModule> {
             tcx.sess.invocation_temp.as_deref(),
             &tcx.sess.prof,
             product.object,
+            ModuleKind::Allocator,
             "allocator_shim".to_owned(),
             &crate::debuginfo::producer(tcx.sess),
         ) {
diff --git a/compiler/rustc_codegen_llvm/src/back/lto.rs b/compiler/rustc_codegen_llvm/src/back/lto.rs
index 326b876e7e689..ad2e722cfef62 100644
--- a/compiler/rustc_codegen_llvm/src/back/lto.rs
+++ b/compiler/rustc_codegen_llvm/src/back/lto.rs
@@ -11,7 +11,7 @@ use object::{Object, ObjectSection};
 use rustc_codegen_ssa::back::lto::{SerializedModule, ThinModule, ThinShared};
 use rustc_codegen_ssa::back::write::{CodegenContext, FatLtoInput};
 use rustc_codegen_ssa::traits::*;
-use rustc_codegen_ssa::{ModuleCodegen, looks_like_rust_object_file};
+use rustc_codegen_ssa::{ModuleCodegen, ModuleKind, looks_like_rust_object_file};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::memmap::Mmap;
 use rustc_errors::DiagCtxtHandle;
@@ -225,9 +225,15 @@ fn fat_lto(
     // All the other modules will be serialized and reparsed into the new
     // context, so this hopefully avoids serializing and parsing the largest
     // codegen unit.
+    //
+    // Additionally use a regular module as the base here to ensure that various
+    // file copy operations in the backend work correctly. The only other kind
+    // of module here should be an allocator one, and if your crate is smaller
+    // than the allocator module then the size doesn't really matter anyway.
     let costliest_module = in_memory
         .iter()
         .enumerate()
+        .filter(|&(_, module)| module.kind == ModuleKind::Regular)
         .map(|(i, module)| {
             let cost = unsafe { llvm::LLVMRustModuleCost(module.module_llvm.llmod()) };
             (cost, i)
diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
index afda7226fdd12..95e02a7c6dbc8 100644
--- a/compiler/rustc_codegen_ssa/src/back/write.rs
+++ b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -490,7 +490,7 @@ fn copy_all_cgu_workproducts_to_incr_comp_cache_dir(
 
     let _timer = sess.timer("copy_all_cgu_workproducts_to_incr_comp_cache_dir");
 
-    for module in &compiled_modules.modules {
+    for module in compiled_modules.modules.iter().filter(|m| m.kind == ModuleKind::Regular) {
         let mut files = Vec::new();
         if let Some(object_file_path) = &module.object {
             files.push((OutputType::Object.extension(), object_file_path.as_path()));
@@ -960,6 +960,7 @@ fn execute_copy_from_cache_work_item<B: ExtraBackendMethods>(
 
     WorkItemResult::Finished(CompiledModule {
         links_from_incr_cache,
+        kind: ModuleKind::Regular,
         name: module.name,
         object,
         dwarf_object,
diff --git a/compiler/rustc_codegen_ssa/src/lib.rs b/compiler/rustc_codegen_ssa/src/lib.rs
index 23146661f27c0..baba8f9ca3e8b 100644
--- a/compiler/rustc_codegen_ssa/src/lib.rs
+++ b/compiler/rustc_codegen_ssa/src/lib.rs
@@ -120,6 +120,7 @@ impl<M> ModuleCodegen<M> {
 
         CompiledModule {
             name: self.name,
+            kind: self.kind,
             object,
             dwarf_object,
             bytecode,
@@ -133,6 +134,7 @@ impl<M> ModuleCodegen<M> {
 #[derive(Debug, Encodable, Decodable)]
 pub struct CompiledModule {
     pub name: String,
+    pub kind: ModuleKind,
     pub object: Option<PathBuf>,
     pub dwarf_object: Option<PathBuf>,
     pub bytecode: Option<PathBuf>,

From 381b3267aeebf1b3b6d400af6b9b0f2cc62ba390 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Sat, 6 Sep 2025 16:05:31 +0200
Subject: [PATCH 0583/1889] identity uses are ok, even if there are no defining
 uses

---
 .../src/region_infer/opaque_types/mod.rs      | 11 ++++++-
 .../ice-issue-146191.current.stderr           | 29 +++++++++++++++++++
 .../ice-issue-146191.next.stderr              | 17 +++++++++++
 .../non-defining-uses/ice-issue-146191.rs     | 15 ++++++++++
 4 files changed, 71 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/impl-trait/non-defining-uses/ice-issue-146191.current.stderr
 create mode 100644 tests/ui/impl-trait/non-defining-uses/ice-issue-146191.next.stderr
 create mode 100644 tests/ui/impl-trait/non-defining-uses/ice-issue-146191.rs

diff --git a/compiler/rustc_borrowck/src/region_infer/opaque_types/mod.rs b/compiler/rustc_borrowck/src/region_infer/opaque_types/mod.rs
index 72615cb33b37f..95c5366a6c8e1 100644
--- a/compiler/rustc_borrowck/src/region_infer/opaque_types/mod.rs
+++ b/compiler/rustc_borrowck/src/region_infer/opaque_types/mod.rs
@@ -503,7 +503,16 @@ pub(crate) fn apply_computed_concrete_opaque_types<'tcx>(
     let mut errors = Vec::new();
     for &(key, hidden_type) in opaque_types {
         let Some(expected) = get_concrete_opaque_type(concrete_opaque_types, key.def_id) else {
-            assert!(tcx.use_typing_mode_borrowck(), "non-defining use in defining scope");
+            if !tcx.use_typing_mode_borrowck() {
+                if let ty::Alias(ty::Opaque, alias_ty) = hidden_type.ty.kind()
+                    && alias_ty.def_id == key.def_id.to_def_id()
+                    && alias_ty.args == key.args
+                {
+                    continue;
+                } else {
+                    unreachable!("non-defining use in defining scope");
+                }
+            }
             errors.push(DeferredOpaqueTypeError::NonDefiningUseInDefiningScope {
                 span: hidden_type.span,
                 opaque_type_key: key,
diff --git a/tests/ui/impl-trait/non-defining-uses/ice-issue-146191.current.stderr b/tests/ui/impl-trait/non-defining-uses/ice-issue-146191.current.stderr
new file mode 100644
index 0000000000000..ccbe2d3593c66
--- /dev/null
+++ b/tests/ui/impl-trait/non-defining-uses/ice-issue-146191.current.stderr
@@ -0,0 +1,29 @@
+error[E0277]: the trait bound `(): ReturnsSend` is not satisfied
+  --> $DIR/ice-issue-146191.rs:6:52
+   |
+LL | fn create_complex_future() -> impl Future<Output = impl ReturnsSend> {
+   |                                                    ^^^^^^^^^^^^^^^^ the trait `ReturnsSend` is not implemented for `()`
+   |
+help: this trait has no implementations, consider adding one
+  --> $DIR/ice-issue-146191.rs:14:1
+   |
+LL | trait ReturnsSend {}
+   | ^^^^^^^^^^^^^^^^^
+note: required by a bound in an opaque type
+  --> $DIR/ice-issue-146191.rs:6:57
+   |
+LL | fn create_complex_future() -> impl Future<Output = impl ReturnsSend> {
+   |                                                         ^^^^^^^^^^^
+
+error[E0733]: recursion in an async block requires boxing
+  --> $DIR/ice-issue-146191.rs:8:5
+   |
+LL |     async { create_complex_future().await }
+   |     ^^^^^   ----------------------------- recursive call here
+   |
+   = note: a recursive `async fn` call must introduce indirection such as `Box::pin` to avoid an infinitely sized future
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0277, E0733.
+For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/impl-trait/non-defining-uses/ice-issue-146191.next.stderr b/tests/ui/impl-trait/non-defining-uses/ice-issue-146191.next.stderr
new file mode 100644
index 0000000000000..e8b551c65fc0c
--- /dev/null
+++ b/tests/ui/impl-trait/non-defining-uses/ice-issue-146191.next.stderr
@@ -0,0 +1,17 @@
+error[E0282]: type annotations needed
+  --> $DIR/ice-issue-146191.rs:8:5
+   |
+LL |     async { create_complex_future().await }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type
+
+error[E0282]: type annotations needed
+  --> $DIR/ice-issue-146191.rs:8:5
+   |
+LL |     async { create_complex_future().await }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/impl-trait/non-defining-uses/ice-issue-146191.rs b/tests/ui/impl-trait/non-defining-uses/ice-issue-146191.rs
new file mode 100644
index 0000000000000..356f7d01eb9b7
--- /dev/null
+++ b/tests/ui/impl-trait/non-defining-uses/ice-issue-146191.rs
@@ -0,0 +1,15 @@
+//@ edition: 2024
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
+//@ ignore-compare-mode-next-solver (explicit revisions)
+
+fn create_complex_future() -> impl Future<Output = impl ReturnsSend> {
+    //[current]~^ ERROR the trait bound `(): ReturnsSend` is not satisfied
+    async { create_complex_future().await }
+    //[current]~^ ERROR recursion in an async block requires
+    //[next]~^^ ERROR type annotations needed
+    //[next]~| ERROR type annotations needed
+}
+
+trait ReturnsSend {}
+fn main() {}

From 6c4e958fad41710337b9827a0a8cb351e78a838f Mon Sep 17 00:00:00 2001
From: Romain Perier <romain.perier@gmail.com>
Date: Sat, 6 Sep 2025 16:35:11 +0200
Subject: [PATCH 0584/1889] Update comment for werror on rust-lang/rust CI
 explaining why we keep MSVC definitively excluded

---
 compiler/rustc_llvm/build.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_llvm/build.rs b/compiler/rustc_llvm/build.rs
index d01f79dcade0b..225ab8c846d82 100644
--- a/compiler/rustc_llvm/build.rs
+++ b/compiler/rustc_llvm/build.rs
@@ -174,10 +174,10 @@ fn main() {
 
     // Prevent critical warnings when we're compiling from rust-lang/rust CI,
     // except on MSVC, as the compiler throws warnings that are only reported
-    // for this platform. See https://github.com/rust-lang/rust/pull/145031#issuecomment-3162677202
-    // FIXME(llvm22): It looks like the specific problem code has been removed
-    // in https://github.com/llvm/llvm-project/commit/e8fc808bf8e78a3c80d1f8e293a92677b92366dd,
-    // retry msvc once we bump our LLVM version.
+    // for this platform. See https://github.com/rust-lang/rust/pull/145031#issuecomment-3162677202.
+    // Moreover, LLVM generally guarantees warning-freedom only when building with Clang, as other
+    // compilers have too many false positives. This is typically the case for MSVC, which throws
+    // many false-positive warnings. We keep it excluded, for these reasons.
     if std::env::var_os("CI").is_some() && !target.contains("msvc") {
         cfg.warnings_into_errors(true);
     }

From 7fada167f9a3cfcfa35fbfc33a17b926f8ef3352 Mon Sep 17 00:00:00 2001
From: Moritz Hedtke <Moritz.Hedtke@t-online.de>
Date: Sat, 6 Sep 2025 18:01:31 +0200
Subject: [PATCH 0585/1889] Make `LetChainsPolicy` public for rustfmt usage

---
 compiler/rustc_parse/src/parser/expr.rs | 2 +-
 compiler/rustc_parse/src/parser/mod.rs  | 2 ++
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index 9b09cbba7afcc..4c02547357ef7 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -2742,7 +2742,7 @@ impl<'a> Parser<'a> {
     /// The specified `edition` in `let_chains_policy` should be that of the whole `if` construct,
     /// i.e. the same span we use to later decide whether the drop behaviour should be that of
     /// edition `..=2021` or that of `2024..`.
-    // Public because it is used in rustfmt forks such as https://github.com/tucant/rustfmt/blob/30c83df9e1db10007bdd16dafce8a86b404329b2/src/parse/macros/html.rs#L57 for custom if expressions.
+    // Public to use it for custom `if` expressions in rustfmt forks like https://github.com/tucant/rustfmt
     pub fn parse_expr_cond(
         &mut self,
         let_chains_policy: LetChainsPolicy,
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
index 15598f32429e5..3bbca622975c9 100644
--- a/compiler/rustc_parse/src/parser/mod.rs
+++ b/compiler/rustc_parse/src/parser/mod.rs
@@ -22,6 +22,8 @@ use std::{fmt, mem, slice};
 use attr_wrapper::{AttrWrapper, UsePreAttrPos};
 pub use diagnostics::AttemptLocalParseRecovery;
 pub(crate) use expr::ForbiddenLetReason;
+// Public to use it for custom `if` expressions in rustfmt forks like https://github.com/tucant/rustfmt
+pub use expr::LetChainsPolicy;
 pub(crate) use item::{FnContext, FnParseMode};
 pub use pat::{CommaRecoveryMode, RecoverColon, RecoverComma};
 pub use path::PathStyle;

From 90133349eaa928d8ba262cc90b9789b698d5b070 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 4 Sep 2025 15:31:30 +0200
Subject: [PATCH 0586/1889] Update `browser-ui-test` version to `0.22.0`

---
 package-lock.json | 473 +++-------------------------------------------
 package.json      |   2 +-
 2 files changed, 26 insertions(+), 449 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 44e8b65c28d9b..def0cfa86a584 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -5,7 +5,7 @@
   "packages": {
     "": {
       "dependencies": {
-        "browser-ui-test": "^0.21.3",
+        "browser-ui-test": "^0.22.0",
         "es-check": "^6.2.1",
         "eslint": "^8.57.1",
         "eslint-js": "github:eslint/js",
@@ -37,8 +37,6 @@
     },
     "node_modules/@caporal/core": {
       "version": "2.0.7",
-      "resolved": "https://registry.npmjs.org/@caporal/core/-/core-2.0.7.tgz",
-      "integrity": "sha512-OvKBEidoXUGT28RP3USXFdLgiR5kGCHfRXR1uBQznyxBHaWjGcpH+G1chRqyIVT82pQoJiauOZRIGlrpyAbRYQ==",
       "license": "MIT",
       "dependencies": {
         "@types/glob": "^7.1.1",
@@ -61,8 +59,6 @@
     },
     "node_modules/@colors/colors": {
       "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/@colors/colors/-/colors-1.6.0.tgz",
-      "integrity": "sha512-Ir+AOibqzrIsL6ajt3Rz3LskB7OiMVHqltZmspbW/TJuTVuyOMirVqAkjfY6JISiLHgyNqicAC8AyHHGzNd/dA==",
       "license": "MIT",
       "engines": {
         "node": ">=0.1.90"
@@ -70,8 +66,6 @@
     },
     "node_modules/@dabh/diagnostics": {
       "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/@dabh/diagnostics/-/diagnostics-2.0.3.tgz",
-      "integrity": "sha512-hrlQOIi7hAfzsMqlGSFyVucrx38O+j6wiGOf//H2ecvIEqYN4ADBSS2iLMh5UFyDunCNniUIPk/q3riFv45xRA==",
       "license": "MIT",
       "dependencies": {
         "colorspace": "1.1.x",
@@ -81,8 +75,6 @@
     },
     "node_modules/@eslint-community/eslint-utils": {
       "version": "4.7.0",
-      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.7.0.tgz",
-      "integrity": "sha512-dyybb3AcajC7uha6CvhdVRJqaKyn7w2YKqKyAN37NKYgZT36w+iRb0Dymmc5qEJ549c/S31cMMSFd75bteCpCw==",
       "license": "MIT",
       "dependencies": {
         "eslint-visitor-keys": "^3.4.3"
@@ -99,8 +91,6 @@
     },
     "node_modules/@eslint-community/regexpp": {
       "version": "4.12.1",
-      "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.1.tgz",
-      "integrity": "sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==",
       "license": "MIT",
       "engines": {
         "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
@@ -108,8 +98,6 @@
     },
     "node_modules/@eslint/eslintrc": {
       "version": "2.1.4",
-      "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-2.1.4.tgz",
-      "integrity": "sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ==",
       "license": "MIT",
       "dependencies": {
         "ajv": "^6.12.4",
@@ -131,8 +119,6 @@
     },
     "node_modules/@eslint/js": {
       "version": "8.57.1",
-      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-8.57.1.tgz",
-      "integrity": "sha512-d9zaMRSTIKDLhctzH12MtXvJKSSUhaHcjV+2Z+GK+EEY7XKpP5yR4x+N3TAcHTcu963nIr+TMcCb4DBCYX1z6Q==",
       "license": "MIT",
       "engines": {
         "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
@@ -140,9 +126,6 @@
     },
     "node_modules/@humanwhocodes/config-array": {
       "version": "0.13.0",
-      "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.13.0.tgz",
-      "integrity": "sha512-DZLEEqFWQFiyK6h5YIeynKx7JlvCYWL0cImfSRXZ9l4Sg2efkFGTuFf6vzXjK1cq6IYkU+Eg/JizXw+TD2vRNw==",
-      "deprecated": "Use @eslint/config-array instead",
       "license": "Apache-2.0",
       "dependencies": {
         "@humanwhocodes/object-schema": "^2.0.3",
@@ -155,8 +138,6 @@
     },
     "node_modules/@humanwhocodes/module-importer": {
       "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz",
-      "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==",
       "license": "Apache-2.0",
       "engines": {
         "node": ">=12.22"
@@ -168,15 +149,10 @@
     },
     "node_modules/@humanwhocodes/object-schema": {
       "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-2.0.3.tgz",
-      "integrity": "sha512-93zYdMES/c1D69yZiKDBj0V24vqNzB/koF26KPaagAfd3P/4gUlh3Dys5ogAK+Exi9QyzlD8x/08Zt7wIKcDcA==",
-      "deprecated": "Use @eslint/object-schema instead",
       "license": "BSD-3-Clause"
     },
     "node_modules/@nodelib/fs.scandir": {
       "version": "2.1.5",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
-      "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
       "license": "MIT",
       "dependencies": {
         "@nodelib/fs.stat": "2.0.5",
@@ -188,8 +164,6 @@
     },
     "node_modules/@nodelib/fs.stat": {
       "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
-      "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
       "license": "MIT",
       "engines": {
         "node": ">= 8"
@@ -197,8 +171,6 @@
     },
     "node_modules/@nodelib/fs.walk": {
       "version": "1.2.8",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
-      "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
       "license": "MIT",
       "dependencies": {
         "@nodelib/fs.scandir": "2.1.5",
@@ -238,8 +210,6 @@
     },
     "node_modules/@types/glob": {
       "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/@types/glob/-/glob-7.2.0.tgz",
-      "integrity": "sha512-ZUxbzKl0IfJILTS6t7ip5fQQM/J3TJYubDm3nMbgubNNYS62eXeUpoLUC8/7fJNiFYHTrGPQn7hspDUzIHX3UA==",
       "license": "MIT",
       "dependencies": {
         "@types/minimatch": "*",
@@ -248,32 +218,22 @@
     },
     "node_modules/@types/lodash": {
       "version": "4.17.20",
-      "resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.17.20.tgz",
-      "integrity": "sha512-H3MHACvFUEiujabxhaI/ImO6gUrd8oOurg7LQtS7mbwIXA/cUqWrvBsaeJ23aZEPk1TAYkurjfMbSELfoCXlGA==",
       "license": "MIT"
     },
     "node_modules/@types/minimatch": {
       "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/@types/minimatch/-/minimatch-5.1.2.tgz",
-      "integrity": "sha512-K0VQKziLUWkVKiRVrx4a40iPaxTUefQmjtkQofBkYRcoaaL/8rhwDWww9qWbrgicNOgnpIsMxyNIUM4+n6dUIA==",
       "license": "MIT"
     },
     "node_modules/@types/node": {
       "version": "13.9.3",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-13.9.3.tgz",
-      "integrity": "sha512-01s+ac4qerwd6RHD+mVbOEsraDHSgUaefQlEdBbUolnQFjKwCr7luvAlEwW1RFojh67u0z4OUTjPn9LEl4zIkA==",
       "license": "MIT"
     },
     "node_modules/@types/table": {
       "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/@types/table/-/table-5.0.0.tgz",
-      "integrity": "sha512-fQLtGLZXor264zUPWI95WNDsZ3QV43/c0lJpR/h1hhLJumXRmHNsrvBfEzW2YMhb0EWCsn4U6h82IgwsajAuTA==",
       "license": "MIT"
     },
     "node_modules/@types/tabtab": {
       "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/@types/tabtab/-/tabtab-3.0.4.tgz",
-      "integrity": "sha512-gmh8JsmIYPGRqk8Xb4dmulV37TpLwg0Quo3GJ0LgEcl4v0O92F14PGebBd7LHv9GBEw2KbmBSrvU0/NzIy5AoA==",
       "license": "MIT",
       "dependencies": {
         "@types/node": "*"
@@ -281,14 +241,10 @@
     },
     "node_modules/@types/triple-beam": {
       "version": "1.3.5",
-      "resolved": "https://registry.npmjs.org/@types/triple-beam/-/triple-beam-1.3.5.tgz",
-      "integrity": "sha512-6WaYesThRMCl19iryMYP7/x2OVgCtbIVflDGFpWnb9irXI3UjYE4AzmYuiUKY1AJstGijoY+MgUszMgRxIYTYw==",
       "license": "MIT"
     },
     "node_modules/@types/wrap-ansi": {
       "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/@types/wrap-ansi/-/wrap-ansi-3.0.0.tgz",
-      "integrity": "sha512-ltIpx+kM7g/MLRZfkbL7EsCEjfzCcScLpkg37eXEtx5kmrAKBkTJwd1GIAjDSL8wTpM6Hzn5YO4pSb91BEwu1g==",
       "license": "MIT"
     },
     "node_modules/@types/yauzl": {
@@ -303,14 +259,10 @@
     },
     "node_modules/@ungap/structured-clone": {
       "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.3.0.tgz",
-      "integrity": "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==",
       "license": "ISC"
     },
     "node_modules/acorn": {
       "version": "8.15.0",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
-      "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
       "license": "MIT",
       "bin": {
         "acorn": "bin/acorn"
@@ -321,8 +273,6 @@
     },
     "node_modules/acorn-jsx": {
       "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
-      "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
       "license": "MIT",
       "peerDependencies": {
         "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
@@ -339,8 +289,6 @@
     },
     "node_modules/ajv": {
       "version": "6.12.6",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
-      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
       "license": "MIT",
       "dependencies": {
         "fast-deep-equal": "^3.1.1",
@@ -355,8 +303,6 @@
     },
     "node_modules/ansi-escapes": {
       "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-3.2.0.tgz",
-      "integrity": "sha512-cBhpre4ma+U0T1oM5fXg7Dy1Jw7zzwv7lt/GoCpr+hDQJoYnKVPLL4dCvSEFMmQurOQvSrwT7SL/DAlhBI97RQ==",
       "license": "MIT",
       "engines": {
         "node": ">=4"
@@ -364,8 +310,6 @@
     },
     "node_modules/ansi-regex": {
       "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
-      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
       "license": "MIT",
       "engines": {
         "node": ">=8"
@@ -373,8 +317,6 @@
     },
     "node_modules/ansi-styles": {
       "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
       "license": "MIT",
       "dependencies": {
         "color-convert": "^2.0.1"
@@ -388,8 +330,6 @@
     },
     "node_modules/argparse": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
-      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
       "license": "Python-2.0"
     },
     "node_modules/ast-types": {
@@ -406,8 +346,6 @@
     },
     "node_modules/astral-regex": {
       "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/astral-regex/-/astral-regex-1.0.0.tgz",
-      "integrity": "sha512-+Ryf6g3BKoRc7jfp7ad8tM4TtMiaWvbF/1/sQcZPkkS7ag3D5nMBCe2UfOTONtAkaG0tO0ij3C5Lwmf1EiyjHg==",
       "license": "MIT",
       "engines": {
         "node": ">=4"
@@ -415,8 +353,6 @@
     },
     "node_modules/async": {
       "version": "3.2.6",
-      "resolved": "https://registry.npmjs.org/async/-/async-3.2.6.tgz",
-      "integrity": "sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==",
       "license": "MIT"
     },
     "node_modules/b4a": {
@@ -427,21 +363,19 @@
     },
     "node_modules/balanced-match": {
       "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
-      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
       "license": "MIT"
     },
     "node_modules/bare-events": {
-      "version": "2.6.0",
-      "resolved": "https://registry.npmjs.org/bare-events/-/bare-events-2.6.0.tgz",
-      "integrity": "sha512-EKZ5BTXYExaNqi3I3f9RtEsaI/xBSGjE0XZCZilPzFAV/goswFHuPd9jEZlPIZ/iNZJwDSao9qRiScySz7MbQg==",
+      "version": "2.6.1",
+      "resolved": "https://registry.npmjs.org/bare-events/-/bare-events-2.6.1.tgz",
+      "integrity": "sha512-AuTJkq9XmE6Vk0FJVNq5QxETrSA/vKHarWVBG5l/JbdCL1prJemiyJqUS0jrlXO0MftuPq4m3YVYhoNc5+aE/g==",
       "license": "Apache-2.0",
       "optional": true
     },
     "node_modules/bare-fs": {
-      "version": "4.1.6",
-      "resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-4.1.6.tgz",
-      "integrity": "sha512-25RsLF33BqooOEFNdMcEhMpJy8EoR88zSMrnOQOaM3USnOK2VmaJ1uaQEwPA6AQjrv1lXChScosN6CzbwbO9OQ==",
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-4.2.3.tgz",
+      "integrity": "sha512-1aGs5pRVLToMQ79elP+7cc0u0s/wXAzfBv/7hDloT7WFggLqECCas5qqPky7WHCFdsBH5WDq6sD4fAoz5sJbtA==",
       "license": "Apache-2.0",
       "optional": true,
       "dependencies": {
@@ -462,9 +396,9 @@
       }
     },
     "node_modules/bare-os": {
-      "version": "3.6.1",
-      "resolved": "https://registry.npmjs.org/bare-os/-/bare-os-3.6.1.tgz",
-      "integrity": "sha512-uaIjxokhFidJP+bmmvKSgiMzj2sV5GPHaZVAIktcxcpCyBFFWO+YlikVAdhmUo2vYFvFhOXIAlldqV29L8126g==",
+      "version": "3.6.2",
+      "resolved": "https://registry.npmjs.org/bare-os/-/bare-os-3.6.2.tgz",
+      "integrity": "sha512-T+V1+1srU2qYNBmJCXZkUY5vQ0B4FSlL3QDROnKQYOqeiQR8UbjNHlPa+TIbM4cuidiN9GaTaOZgSEgsvPbh5A==",
       "license": "Apache-2.0",
       "optional": true,
       "engines": {
@@ -482,9 +416,9 @@
       }
     },
     "node_modules/bare-stream": {
-      "version": "2.6.5",
-      "resolved": "https://registry.npmjs.org/bare-stream/-/bare-stream-2.6.5.tgz",
-      "integrity": "sha512-jSmxKJNJmHySi6hC42zlZnq00rga4jjxcgNZjY9N5WlOe/iOoGRtdwGsHzQv2RlH2KOYMwGUXhf2zXd32BA9RA==",
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/bare-stream/-/bare-stream-2.7.0.tgz",
+      "integrity": "sha512-oyXQNicV1y8nc2aKffH+BUHFRXmx6VrPzlnaEvMhram0nPBrKcEdcyBg5r08D0i8VxngHFAiVyn1QKXpSG0B8A==",
       "license": "Apache-2.0",
       "optional": true,
       "dependencies": {
@@ -534,8 +468,6 @@
     },
     "node_modules/brace-expansion": {
       "version": "1.1.12",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
-      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
       "license": "MIT",
       "dependencies": {
         "balanced-match": "^1.0.0",
@@ -544,8 +476,6 @@
     },
     "node_modules/braces": {
       "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
-      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
       "license": "MIT",
       "dependencies": {
         "fill-range": "^7.1.1"
@@ -555,9 +485,9 @@
       }
     },
     "node_modules/browser-ui-test": {
-      "version": "0.21.3",
-      "resolved": "https://registry.npmjs.org/browser-ui-test/-/browser-ui-test-0.21.1.tgz",
-      "integrity": "sha512-b3a9mhALAmbP+GifoN/c295RPyuyfIUFMz0DtlBHbeDW5PYQTMHZZJtm7R2UyP6JiIQSkR+7227sS3maMGMUTg==",
+      "version": "0.22.0",
+      "resolved": "https://registry.npmjs.org/browser-ui-test/-/browser-ui-test-0.22.0.tgz",
+      "integrity": "sha512-p/C02TMybTDKsAjpGOdnyNC0Q25KDae/fKMnvHaqcJ0tXRqNKwndW2Ltq7HTmin5xqg8GGOmysEgWTZkXu6pfA==",
       "license": "MIT",
       "dependencies": {
         "css-unit-converter": "^1.1.2",
@@ -604,8 +534,6 @@
     },
     "node_modules/callsites": {
       "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
-      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
       "license": "MIT",
       "engines": {
         "node": ">=6"
@@ -613,8 +541,6 @@
     },
     "node_modules/chalk": {
       "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-3.0.0.tgz",
-      "integrity": "sha512-4D3B6Wf41KOYRFdszmDqMCGq5VV/uMAB273JILmO+3jAlh8X4qDtdtgCR3fxtbLEMzSx22QdhnDcJvu2u1fVwg==",
       "license": "MIT",
       "dependencies": {
         "ansi-styles": "^4.1.0",
@@ -626,8 +552,6 @@
     },
     "node_modules/chardet": {
       "version": "0.7.0",
-      "resolved": "https://registry.npmjs.org/chardet/-/chardet-0.7.0.tgz",
-      "integrity": "sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA==",
       "license": "MIT"
     },
     "node_modules/chromium-bidi": {
@@ -646,8 +570,6 @@
     },
     "node_modules/cli-cursor": {
       "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-2.1.0.tgz",
-      "integrity": "sha512-8lgKz8LmCRYZZQDpRyT2m5rKJ08TnU4tR9FFFW2rxpxR1FzWi4PQ/NfyODchAatHaUgnSPVcx/R5w6NuTBzFiw==",
       "license": "MIT",
       "dependencies": {
         "restore-cursor": "^2.0.0"
@@ -658,8 +580,6 @@
     },
     "node_modules/cli-width": {
       "version": "2.2.1",
-      "resolved": "https://registry.npmjs.org/cli-width/-/cli-width-2.2.1.tgz",
-      "integrity": "sha512-GRMWDxpOB6Dgk2E5Uo+3eEBvtOOlimMmpbFiKuLFnQzYDavtLFY3K5ona41jgN/WdRZtG7utuVSVTL4HbZHGkw==",
       "license": "ISC"
     },
     "node_modules/cliui": {
@@ -724,8 +644,6 @@
     },
     "node_modules/color": {
       "version": "3.2.1",
-      "resolved": "https://registry.npmjs.org/color/-/color-3.2.1.tgz",
-      "integrity": "sha512-aBl7dZI9ENN6fUGC7mWpMTPNHmWUSNan9tuWN6ahh5ZLNk9baLJOnSMlrQkHcrfFgz2/RigjUVAjdx36VcemKA==",
       "license": "MIT",
       "dependencies": {
         "color-convert": "^1.9.3",
@@ -734,8 +652,6 @@
     },
     "node_modules/color-convert": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
-      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
       "license": "MIT",
       "dependencies": {
         "color-name": "~1.1.4"
@@ -746,14 +662,10 @@
     },
     "node_modules/color-name": {
       "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
-      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
       "license": "MIT"
     },
     "node_modules/color-string": {
       "version": "1.9.1",
-      "resolved": "https://registry.npmjs.org/color-string/-/color-string-1.9.1.tgz",
-      "integrity": "sha512-shrVawQFojnZv6xM40anx4CkoDP+fZsw/ZerEMsW/pyzsRbElpsL/DBVW7q3ExxwusdNXI3lXpuhEZkzs8p5Eg==",
       "license": "MIT",
       "dependencies": {
         "color-name": "^1.0.0",
@@ -762,8 +674,6 @@
     },
     "node_modules/color/node_modules/color-convert": {
       "version": "1.9.3",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
-      "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
       "license": "MIT",
       "dependencies": {
         "color-name": "1.1.3"
@@ -771,14 +681,10 @@
     },
     "node_modules/color/node_modules/color-name": {
       "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
-      "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==",
       "license": "MIT"
     },
     "node_modules/colorspace": {
       "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/colorspace/-/colorspace-1.1.4.tgz",
-      "integrity": "sha512-BgvKJiuVu1igBUF2kEjRCZXol6wiiGbY5ipL/oVPwm0BL9sIpMIzM8IK7vwuxIIzOXMV3Ey5w+vxhm0rR/TN8w==",
       "license": "MIT",
       "dependencies": {
         "color": "^3.1.3",
@@ -787,8 +693,6 @@
     },
     "node_modules/concat-map": {
       "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
-      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
       "license": "MIT"
     },
     "node_modules/cosmiconfig": {
@@ -819,8 +723,6 @@
     },
     "node_modules/cross-spawn": {
       "version": "7.0.6",
-      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
-      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
       "license": "MIT",
       "dependencies": {
         "path-key": "^3.1.0",
@@ -848,8 +750,6 @@
     },
     "node_modules/debug": {
       "version": "4.4.1",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
-      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
       "license": "MIT",
       "dependencies": {
         "ms": "^2.1.3"
@@ -865,8 +765,6 @@
     },
     "node_modules/deep-is": {
       "version": "0.1.4",
-      "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
-      "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==",
       "license": "MIT"
     },
     "node_modules/degenerator": {
@@ -891,8 +789,6 @@
     },
     "node_modules/doctrine": {
       "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz",
-      "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==",
       "license": "Apache-2.0",
       "dependencies": {
         "esutils": "^2.0.2"
@@ -903,14 +799,10 @@
     },
     "node_modules/emoji-regex": {
       "version": "7.0.3",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz",
-      "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==",
       "license": "MIT"
     },
     "node_modules/enabled": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/enabled/-/enabled-2.0.0.tgz",
-      "integrity": "sha512-AKrN98kuwOzMIdAizXGI86UFBoo26CL21UM763y1h/GMSJ4/OHU9k2YlsmBpyScFo/wbLzWQJBMCW4+IO3/+OQ==",
       "license": "MIT"
     },
     "node_modules/end-of-stream": {
@@ -942,8 +834,6 @@
     },
     "node_modules/es-check": {
       "version": "6.2.1",
-      "resolved": "https://registry.npmjs.org/es-check/-/es-check-6.2.1.tgz",
-      "integrity": "sha512-IPiRXUlwSTd2yMklIf9yEGe6GK5wCS8Sz1aTNHm1QSiYzI4aiq19giYbLi95tb+e0JJVKmcU0iQXQWW60a8V9A==",
       "license": "MIT",
       "dependencies": {
         "@caporal/core": "^2.0.2",
@@ -959,8 +849,6 @@
     },
     "node_modules/es6-promisify": {
       "version": "6.1.1",
-      "resolved": "https://registry.npmjs.org/es6-promisify/-/es6-promisify-6.1.1.tgz",
-      "integrity": "sha512-HBL8I3mIki5C1Cc9QjKUenHtnG0A5/xA8Q/AllRcfiwl2CZFXGK7ddBiCoRwAix4i2KxcQfjtIVcrVbB3vbmwg==",
       "license": "MIT"
     },
     "node_modules/escalade": {
@@ -974,8 +862,6 @@
     },
     "node_modules/escape-string-regexp": {
       "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
-      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
       "license": "MIT",
       "engines": {
         "node": ">=10"
@@ -1007,9 +893,6 @@
     },
     "node_modules/eslint": {
       "version": "8.57.1",
-      "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.57.1.tgz",
-      "integrity": "sha512-ypowyDxpVSYpkXr9WPv2PAZCtNip1Mv5KTW0SCurXv/9iOpcrH9PaqUElksqEB6pChqHGDRCFTyrZlGhnLNGiA==",
-      "deprecated": "This version is no longer supported. Please see https://eslint.org/version-support for other options.",
       "license": "MIT",
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.2.0",
@@ -1063,15 +946,13 @@
     },
     "node_modules/eslint-js": {
       "version": "1.0.0",
-      "resolved": "git+ssh://git@github.com/eslint/js.git#5bd12e3772d361af2c4bfad774ea7bfd9caae6bc",
+      "resolved": "git+ssh://git@github.com/eslint/js.git#9e5b4fabf073b915abc56d6c14cc24177036d43e",
       "workspaces": [
         "packages/*"
       ]
     },
     "node_modules/eslint-scope": {
       "version": "7.2.2",
-      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.2.2.tgz",
-      "integrity": "sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==",
       "license": "BSD-2-Clause",
       "dependencies": {
         "esrecurse": "^4.3.0",
@@ -1086,8 +967,6 @@
     },
     "node_modules/eslint-visitor-keys": {
       "version": "3.4.3",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
-      "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
       "license": "Apache-2.0",
       "engines": {
         "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
@@ -1098,8 +977,6 @@
     },
     "node_modules/eslint/node_modules/chalk": {
       "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
-      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
       "license": "MIT",
       "dependencies": {
         "ansi-styles": "^4.1.0",
@@ -1114,8 +991,6 @@
     },
     "node_modules/espree": {
       "version": "9.6.1",
-      "resolved": "https://registry.npmjs.org/espree/-/espree-9.6.1.tgz",
-      "integrity": "sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==",
       "license": "BSD-2-Clause",
       "dependencies": {
         "acorn": "^8.9.0",
@@ -1144,8 +1019,6 @@
     },
     "node_modules/esquery": {
       "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.6.0.tgz",
-      "integrity": "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==",
       "license": "BSD-3-Clause",
       "dependencies": {
         "estraverse": "^5.1.0"
@@ -1156,8 +1029,6 @@
     },
     "node_modules/esrecurse": {
       "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
-      "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
       "license": "BSD-2-Clause",
       "dependencies": {
         "estraverse": "^5.2.0"
@@ -1168,8 +1039,6 @@
     },
     "node_modules/estraverse": {
       "version": "5.3.0",
-      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
-      "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
       "license": "BSD-2-Clause",
       "engines": {
         "node": ">=4.0"
@@ -1177,8 +1046,6 @@
     },
     "node_modules/esutils": {
       "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
-      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
       "license": "BSD-2-Clause",
       "engines": {
         "node": ">=0.10.0"
@@ -1186,8 +1053,6 @@
     },
     "node_modules/external-editor": {
       "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/external-editor/-/external-editor-3.1.0.tgz",
-      "integrity": "sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==",
       "license": "MIT",
       "dependencies": {
         "chardet": "^0.7.0",
@@ -1220,8 +1085,6 @@
     },
     "node_modules/fast-deep-equal": {
       "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
-      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
       "license": "MIT"
     },
     "node_modules/fast-fifo": {
@@ -1232,8 +1095,6 @@
     },
     "node_modules/fast-glob": {
       "version": "3.3.3",
-      "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz",
-      "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==",
       "license": "MIT",
       "dependencies": {
         "@nodelib/fs.stat": "^2.0.2",
@@ -1248,8 +1109,6 @@
     },
     "node_modules/fast-glob/node_modules/glob-parent": {
       "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
-      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
       "license": "ISC",
       "dependencies": {
         "is-glob": "^4.0.1"
@@ -1260,20 +1119,14 @@
     },
     "node_modules/fast-json-stable-stringify": {
       "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
-      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
       "license": "MIT"
     },
     "node_modules/fast-levenshtein": {
       "version": "2.0.6",
-      "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
-      "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==",
       "license": "MIT"
     },
     "node_modules/fastq": {
       "version": "1.19.1",
-      "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.19.1.tgz",
-      "integrity": "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==",
       "license": "ISC",
       "dependencies": {
         "reusify": "^1.0.4"
@@ -1290,14 +1143,10 @@
     },
     "node_modules/fecha": {
       "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/fecha/-/fecha-4.2.3.tgz",
-      "integrity": "sha512-OP2IUU6HeYKJi3i0z4A19kHMQoLVs4Hc+DPqqxI2h/DPZHTm/vjsfC6P0b4jCMy14XizLBqvndQ+UilD7707Jw==",
       "license": "MIT"
     },
     "node_modules/figures": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/figures/-/figures-2.0.0.tgz",
-      "integrity": "sha512-Oa2M9atig69ZkfwiApY8F2Yy+tzMbazyvqv21R0NsSC8floSOC09BbT1ITWAdoMGQvJ/aZnR1KMwdx9tvHnTNA==",
       "license": "MIT",
       "dependencies": {
         "escape-string-regexp": "^1.0.5"
@@ -1308,8 +1157,6 @@
     },
     "node_modules/figures/node_modules/escape-string-regexp": {
       "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
-      "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==",
       "license": "MIT",
       "engines": {
         "node": ">=0.8.0"
@@ -1317,8 +1164,6 @@
     },
     "node_modules/file-entry-cache": {
       "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz",
-      "integrity": "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==",
       "license": "MIT",
       "dependencies": {
         "flat-cache": "^3.0.4"
@@ -1329,8 +1174,6 @@
     },
     "node_modules/fill-range": {
       "version": "7.1.1",
-      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
-      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
       "license": "MIT",
       "dependencies": {
         "to-regex-range": "^5.0.1"
@@ -1341,8 +1184,6 @@
     },
     "node_modules/find-up": {
       "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
-      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
       "license": "MIT",
       "dependencies": {
         "locate-path": "^6.0.0",
@@ -1357,8 +1198,6 @@
     },
     "node_modules/flat-cache": {
       "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-3.2.0.tgz",
-      "integrity": "sha512-CYcENa+FtcUKLmhhqyctpclsq7QF38pKjZHsGNiSQF5r4FtoKDWabFDl3hzaEQMvT1LHEysw5twgLvpYYb4vbw==",
       "license": "MIT",
       "dependencies": {
         "flatted": "^3.2.9",
@@ -1371,20 +1210,14 @@
     },
     "node_modules/flatted": {
       "version": "3.3.3",
-      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.3.tgz",
-      "integrity": "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==",
       "license": "ISC"
     },
     "node_modules/fn.name": {
       "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/fn.name/-/fn.name-1.1.0.tgz",
-      "integrity": "sha512-GRnmB5gPyJpAhTQdSZTSp9uaPSvl09KoYcMQtsB9rQoOmzs9dH6ffeccH+Z+cv6P68Hu5bC6JjRh4Ah/mHSNRw==",
       "license": "MIT"
     },
     "node_modules/fs.realpath": {
       "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
-      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
       "license": "ISC"
     },
     "node_modules/get-caller-file": {
@@ -1427,9 +1260,6 @@
     },
     "node_modules/glob": {
       "version": "7.2.3",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
-      "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
-      "deprecated": "Glob versions prior to v9 are no longer supported",
       "license": "ISC",
       "dependencies": {
         "fs.realpath": "^1.0.0",
@@ -1448,8 +1278,6 @@
     },
     "node_modules/glob-parent": {
       "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
-      "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
       "license": "ISC",
       "dependencies": {
         "is-glob": "^4.0.3"
@@ -1460,8 +1288,6 @@
     },
     "node_modules/globals": {
       "version": "13.24.0",
-      "resolved": "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz",
-      "integrity": "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==",
       "license": "MIT",
       "dependencies": {
         "type-fest": "^0.20.2"
@@ -1475,14 +1301,10 @@
     },
     "node_modules/graphemer": {
       "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz",
-      "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==",
       "license": "MIT"
     },
     "node_modules/has-flag": {
       "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
-      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
       "license": "MIT",
       "engines": {
         "node": ">=8"
@@ -1516,8 +1338,6 @@
     },
     "node_modules/iconv-lite": {
       "version": "0.4.24",
-      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
-      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
       "license": "MIT",
       "dependencies": {
         "safer-buffer": ">= 2.1.2 < 3"
@@ -1548,8 +1368,6 @@
     },
     "node_modules/ignore": {
       "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
-      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
       "license": "MIT",
       "engines": {
         "node": ">= 4"
@@ -1557,8 +1375,6 @@
     },
     "node_modules/import-fresh": {
       "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
-      "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
       "license": "MIT",
       "dependencies": {
         "parent-module": "^1.0.0",
@@ -1573,8 +1389,6 @@
     },
     "node_modules/imurmurhash": {
       "version": "0.1.4",
-      "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
-      "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
       "license": "MIT",
       "engines": {
         "node": ">=0.8.19"
@@ -1582,9 +1396,6 @@
     },
     "node_modules/inflight": {
       "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
-      "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
-      "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.",
       "license": "ISC",
       "dependencies": {
         "once": "^1.3.0",
@@ -1593,14 +1404,10 @@
     },
     "node_modules/inherits": {
       "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
-      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
       "license": "ISC"
     },
     "node_modules/inquirer": {
       "version": "6.5.2",
-      "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-6.5.2.tgz",
-      "integrity": "sha512-cntlB5ghuB0iuO65Ovoi8ogLHiWGs/5yNrtUcKjFhSSiVeAIVpD7koaSU9RM8mpXw5YDi9RdYXGQMaOURB7ycQ==",
       "license": "MIT",
       "dependencies": {
         "ansi-escapes": "^3.2.0",
@@ -1623,8 +1430,6 @@
     },
     "node_modules/inquirer/node_modules/ansi-regex": {
       "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.1.tgz",
-      "integrity": "sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==",
       "license": "MIT",
       "engines": {
         "node": ">=6"
@@ -1632,8 +1437,6 @@
     },
     "node_modules/inquirer/node_modules/ansi-styles": {
       "version": "3.2.1",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
-      "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
       "license": "MIT",
       "dependencies": {
         "color-convert": "^1.9.0"
@@ -1644,8 +1447,6 @@
     },
     "node_modules/inquirer/node_modules/chalk": {
       "version": "2.4.2",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
-      "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
       "license": "MIT",
       "dependencies": {
         "ansi-styles": "^3.2.1",
@@ -1658,8 +1459,6 @@
     },
     "node_modules/inquirer/node_modules/color-convert": {
       "version": "1.9.3",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
-      "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
       "license": "MIT",
       "dependencies": {
         "color-name": "1.1.3"
@@ -1667,14 +1466,10 @@
     },
     "node_modules/inquirer/node_modules/color-name": {
       "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
-      "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==",
       "license": "MIT"
     },
     "node_modules/inquirer/node_modules/escape-string-regexp": {
       "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
-      "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==",
       "license": "MIT",
       "engines": {
         "node": ">=0.8.0"
@@ -1682,8 +1477,6 @@
     },
     "node_modules/inquirer/node_modules/has-flag": {
       "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
-      "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==",
       "license": "MIT",
       "engines": {
         "node": ">=4"
@@ -1691,8 +1484,6 @@
     },
     "node_modules/inquirer/node_modules/string-width": {
       "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz",
-      "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==",
       "license": "MIT",
       "dependencies": {
         "is-fullwidth-code-point": "^2.0.0",
@@ -1704,8 +1495,6 @@
     },
     "node_modules/inquirer/node_modules/string-width/node_modules/ansi-regex": {
       "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.1.tgz",
-      "integrity": "sha512-+O9Jct8wf++lXxxFc4hc8LsjaSq0HFzzL7cVsw8pRDIPdjKD2mT4ytDZlLuSBZ4cLKZFXIrMGO7DbQCtMJJMKw==",
       "license": "MIT",
       "engines": {
         "node": ">=4"
@@ -1713,8 +1502,6 @@
     },
     "node_modules/inquirer/node_modules/string-width/node_modules/strip-ansi": {
       "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz",
-      "integrity": "sha512-4XaJ2zQdCzROZDivEVIDPkcQn8LMFSa8kj8Gxb/Lnwzv9A8VctNZ+lfivC/sV3ivW8ElJTERXZoPBRrZKkNKow==",
       "license": "MIT",
       "dependencies": {
         "ansi-regex": "^3.0.0"
@@ -1725,8 +1512,6 @@
     },
     "node_modules/inquirer/node_modules/strip-ansi": {
       "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz",
-      "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==",
       "license": "MIT",
       "dependencies": {
         "ansi-regex": "^4.1.0"
@@ -1737,8 +1522,6 @@
     },
     "node_modules/inquirer/node_modules/supports-color": {
       "version": "5.5.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
-      "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
       "license": "MIT",
       "dependencies": {
         "has-flag": "^3.0.0"
@@ -1748,14 +1531,10 @@
       }
     },
     "node_modules/ip-address": {
-      "version": "9.0.5",
-      "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-9.0.5.tgz",
-      "integrity": "sha512-zHtQzGojZXTwZTHQqra+ETKd4Sn3vgi7uBmlPoXVWZqYvuKmtI0l/VZTjqGmJY9x88GGOaZ9+G9ES8hC4T4X8g==",
+      "version": "10.0.1",
+      "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-10.0.1.tgz",
+      "integrity": "sha512-NWv9YLW4PoW2B7xtzaS3NCot75m6nK7Icdv0o3lfMceJVRfSoQwqD4wEH5rLwoKJwUiZ/rfpiVBhnaF0FK4HoA==",
       "license": "MIT",
-      "dependencies": {
-        "jsbn": "1.1.0",
-        "sprintf-js": "^1.1.3"
-      },
       "engines": {
         "node": ">= 12"
       }
@@ -1768,8 +1547,6 @@
     },
     "node_modules/is-extglob": {
       "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
-      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
       "license": "MIT",
       "engines": {
         "node": ">=0.10.0"
@@ -1777,8 +1554,6 @@
     },
     "node_modules/is-fullwidth-code-point": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
-      "integrity": "sha512-VHskAKYM8RfSFXwee5t5cbN5PZeq1Wrh6qd5bkyiXIf6UQcN6w/A0eXM9r6t8d+GYOh+o6ZhiEnb88LN/Y8m2w==",
       "license": "MIT",
       "engines": {
         "node": ">=4"
@@ -1786,8 +1561,6 @@
     },
     "node_modules/is-glob": {
       "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
-      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
       "license": "MIT",
       "dependencies": {
         "is-extglob": "^2.1.1"
@@ -1798,8 +1571,6 @@
     },
     "node_modules/is-number": {
       "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
-      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
       "license": "MIT",
       "engines": {
         "node": ">=0.12.0"
@@ -1807,8 +1578,6 @@
     },
     "node_modules/is-path-inside": {
       "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz",
-      "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==",
       "license": "MIT",
       "engines": {
         "node": ">=8"
@@ -1816,8 +1585,6 @@
     },
     "node_modules/is-stream": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz",
-      "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==",
       "license": "MIT",
       "engines": {
         "node": ">=8"
@@ -1828,8 +1595,6 @@
     },
     "node_modules/isexe": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
-      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
       "license": "ISC"
     },
     "node_modules/js-tokens": {
@@ -1840,8 +1605,6 @@
     },
     "node_modules/js-yaml": {
       "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
-      "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
       "license": "MIT",
       "dependencies": {
         "argparse": "^2.0.1"
@@ -1850,16 +1613,8 @@
         "js-yaml": "bin/js-yaml.js"
       }
     },
-    "node_modules/jsbn": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-1.1.0.tgz",
-      "integrity": "sha512-4bYVV3aAMtDTTu4+xsDYa6sy9GyJ69/amsu9sYF2zqjiEoZA5xJi3BrfX3uY+/IekIu7MwdObdbDWpoZdBv3/A==",
-      "license": "MIT"
-    },
     "node_modules/json-buffer": {
       "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
-      "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
       "license": "MIT"
     },
     "node_modules/json-parse-even-better-errors": {
@@ -1870,20 +1625,14 @@
     },
     "node_modules/json-schema-traverse": {
       "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
-      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
       "license": "MIT"
     },
     "node_modules/json-stable-stringify-without-jsonify": {
       "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
-      "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==",
       "license": "MIT"
     },
     "node_modules/keyv": {
       "version": "4.5.4",
-      "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
-      "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
       "license": "MIT",
       "dependencies": {
         "json-buffer": "3.0.1"
@@ -1891,14 +1640,10 @@
     },
     "node_modules/kuler": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/kuler/-/kuler-2.0.0.tgz",
-      "integrity": "sha512-Xq9nH7KlWZmXAtodXDDRE7vs6DU1gTU8zYDHDiWLSip45Egwq3plLHzPn27NgvzL2r1LMPC1vdqh98sQxtqj4A==",
       "license": "MIT"
     },
     "node_modules/levn": {
       "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
-      "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
       "license": "MIT",
       "dependencies": {
         "prelude-ls": "^1.2.1",
@@ -1916,8 +1661,6 @@
     },
     "node_modules/locate-path": {
       "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
-      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
       "license": "MIT",
       "dependencies": {
         "p-locate": "^5.0.0"
@@ -1931,20 +1674,14 @@
     },
     "node_modules/lodash": {
       "version": "4.17.21",
-      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
-      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==",
       "license": "MIT"
     },
     "node_modules/lodash.merge": {
       "version": "4.6.2",
-      "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
-      "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==",
       "license": "MIT"
     },
     "node_modules/logform": {
       "version": "2.7.0",
-      "resolved": "https://registry.npmjs.org/logform/-/logform-2.7.0.tgz",
-      "integrity": "sha512-TFYA4jnP7PVbmlBIfhlSe+WKxs9dklXMTEGcBCIvLhE/Tn3H6Gk1norupVW7m5Cnd4bLcr08AytbyV/xj7f/kQ==",
       "license": "MIT",
       "dependencies": {
         "@colors/colors": "1.6.0",
@@ -1969,8 +1706,6 @@
     },
     "node_modules/merge2": {
       "version": "1.4.1",
-      "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
-      "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
       "license": "MIT",
       "engines": {
         "node": ">= 8"
@@ -1978,8 +1713,6 @@
     },
     "node_modules/micromatch": {
       "version": "4.0.8",
-      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
-      "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
       "license": "MIT",
       "dependencies": {
         "braces": "^3.0.3",
@@ -1991,8 +1724,6 @@
     },
     "node_modules/mimic-fn": {
       "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-1.2.0.tgz",
-      "integrity": "sha512-jf84uxzwiuiIVKiOLpfYk7N46TSy8ubTonmneY9vrpHNAnp0QBt2BxWV9dO3/j+BoVAb+a5G6YDPW3M5HOdMWQ==",
       "license": "MIT",
       "engines": {
         "node": ">=4"
@@ -2000,8 +1731,6 @@
     },
     "node_modules/minimatch": {
       "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
       "license": "ISC",
       "dependencies": {
         "brace-expansion": "^1.1.7"
@@ -2012,8 +1741,6 @@
     },
     "node_modules/minimist": {
       "version": "1.2.8",
-      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
-      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
       "license": "MIT",
       "funding": {
         "url": "https://github.com/sponsors/ljharb"
@@ -2027,8 +1754,6 @@
     },
     "node_modules/mkdirp": {
       "version": "0.5.6",
-      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.6.tgz",
-      "integrity": "sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==",
       "license": "MIT",
       "dependencies": {
         "minimist": "^1.2.6"
@@ -2039,20 +1764,14 @@
     },
     "node_modules/ms": {
       "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
       "license": "MIT"
     },
     "node_modules/mute-stream": {
       "version": "0.0.7",
-      "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.7.tgz",
-      "integrity": "sha512-r65nCZhrbXXb6dXOACihYApHw2Q6pV0M3V0PSxd74N0+D8nzAdEAITq2oAjA1jVnKI+tGvEBUpqiMh0+rW6zDQ==",
       "license": "ISC"
     },
     "node_modules/natural-compare": {
       "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
-      "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==",
       "license": "MIT"
     },
     "node_modules/netmask": {
@@ -2066,8 +1785,6 @@
     },
     "node_modules/once": {
       "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
-      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
       "license": "ISC",
       "dependencies": {
         "wrappy": "1"
@@ -2075,8 +1792,6 @@
     },
     "node_modules/one-time": {
       "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/one-time/-/one-time-1.0.0.tgz",
-      "integrity": "sha512-5DXOiRKwuSEcQ/l0kGCF6Q3jcADFv5tSmRaJck/OqkVFcOzutB134KRSfF0xDrL39MNnqxbHBbUUcjZIhTgb2g==",
       "license": "MIT",
       "dependencies": {
         "fn.name": "1.x.x"
@@ -2084,8 +1799,6 @@
     },
     "node_modules/onetime": {
       "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/onetime/-/onetime-2.0.1.tgz",
-      "integrity": "sha512-oyyPpiMaKARvvcgip+JV+7zci5L8D1W9RZIz2l1o08AM3pfspitVWnPt3mzHcBPp12oYMTy0pqrFs/C+m3EwsQ==",
       "license": "MIT",
       "dependencies": {
         "mimic-fn": "^1.0.0"
@@ -2096,8 +1809,6 @@
     },
     "node_modules/optionator": {
       "version": "0.9.4",
-      "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
-      "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==",
       "license": "MIT",
       "dependencies": {
         "deep-is": "^0.1.3",
@@ -2113,8 +1824,6 @@
     },
     "node_modules/os-tmpdir": {
       "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz",
-      "integrity": "sha512-D2FR03Vir7FIu45XBY20mTb+/ZSWB00sjU9jdQXt83gDrI4Ztz5Fs7/yy74g2N5SVQY4xY1qDr4rNddwYRVX0g==",
       "license": "MIT",
       "engines": {
         "node": ">=0.10.0"
@@ -2122,8 +1831,6 @@
     },
     "node_modules/p-limit": {
       "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
-      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
       "license": "MIT",
       "dependencies": {
         "yocto-queue": "^0.1.0"
@@ -2137,8 +1844,6 @@
     },
     "node_modules/p-locate": {
       "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
-      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
       "license": "MIT",
       "dependencies": {
         "p-limit": "^3.0.2"
@@ -2184,8 +1889,6 @@
     },
     "node_modules/parent-module": {
       "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
-      "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
       "license": "MIT",
       "dependencies": {
         "callsites": "^3.0.0"
@@ -2214,8 +1917,6 @@
     },
     "node_modules/path-exists": {
       "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
-      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
       "license": "MIT",
       "engines": {
         "node": ">=8"
@@ -2223,8 +1924,6 @@
     },
     "node_modules/path-is-absolute": {
       "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
-      "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",
       "license": "MIT",
       "engines": {
         "node": ">=0.10.0"
@@ -2232,8 +1931,6 @@
     },
     "node_modules/path-key": {
       "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
-      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
       "license": "MIT",
       "engines": {
         "node": ">=8"
@@ -2253,8 +1950,6 @@
     },
     "node_modules/picomatch": {
       "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
-      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
       "license": "MIT",
       "engines": {
         "node": ">=8.6"
@@ -2274,8 +1969,6 @@
     },
     "node_modules/prelude-ls": {
       "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
-      "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
       "license": "MIT",
       "engines": {
         "node": ">= 0.8.0"
@@ -2327,8 +2020,6 @@
     },
     "node_modules/punycode": {
       "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
-      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
       "license": "MIT",
       "engines": {
         "node": ">=6"
@@ -2338,6 +2029,7 @@
       "version": "22.15.0",
       "resolved": "https://registry.npmjs.org/puppeteer/-/puppeteer-22.15.0.tgz",
       "integrity": "sha512-XjCY1SiSEi1T7iSYuxS82ft85kwDJUS7wj1Z0eGVXKdtr5g4xnVcbjwxhq5xBnpK/E7x1VZZoJDxpjAOasHT4Q==",
+      "deprecated": "< 24.10.2 is no longer supported",
       "hasInstallScript": true,
       "license": "Apache-2.0",
       "dependencies": {
@@ -2371,8 +2063,6 @@
     },
     "node_modules/queue-microtask": {
       "version": "1.2.3",
-      "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
-      "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==",
       "funding": [
         {
           "type": "github",
@@ -2391,8 +2081,6 @@
     },
     "node_modules/readable-stream": {
       "version": "3.6.2",
-      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",
-      "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==",
       "license": "MIT",
       "dependencies": {
         "inherits": "^2.0.3",
@@ -2423,8 +2111,6 @@
     },
     "node_modules/resolve-from": {
       "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
-      "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
       "license": "MIT",
       "engines": {
         "node": ">=4"
@@ -2432,8 +2118,6 @@
     },
     "node_modules/restore-cursor": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-2.0.0.tgz",
-      "integrity": "sha512-6IzJLuGi4+R14vwagDHX+JrXmPVtPpn4mffDJ1UdR7/Edm87fl6yi8mMBIVvFtJaNTUvjughmW4hwLhRG7gC1Q==",
       "license": "MIT",
       "dependencies": {
         "onetime": "^2.0.0",
@@ -2445,8 +2129,6 @@
     },
     "node_modules/reusify": {
       "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz",
-      "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==",
       "license": "MIT",
       "engines": {
         "iojs": ">=1.0.0",
@@ -2455,9 +2137,6 @@
     },
     "node_modules/rimraf": {
       "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz",
-      "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==",
-      "deprecated": "Rimraf versions prior to v4 are no longer supported",
       "license": "ISC",
       "dependencies": {
         "glob": "^7.1.3"
@@ -2471,8 +2150,6 @@
     },
     "node_modules/run-async": {
       "version": "2.4.1",
-      "resolved": "https://registry.npmjs.org/run-async/-/run-async-2.4.1.tgz",
-      "integrity": "sha512-tvVnVv01b8c1RrA6Ep7JkStj85Guv/YrMcwqYQnwjsAS2cTmmPGBBjAjpCW7RrSodNSoE2/qg9O4bceNvUuDgQ==",
       "license": "MIT",
       "engines": {
         "node": ">=0.12.0"
@@ -2480,8 +2157,6 @@
     },
     "node_modules/run-parallel": {
       "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
-      "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==",
       "funding": [
         {
           "type": "github",
@@ -2503,8 +2178,6 @@
     },
     "node_modules/rxjs": {
       "version": "6.6.7",
-      "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-6.6.7.tgz",
-      "integrity": "sha512-hTdwr+7yYNIT5n4AMYp85KA6yw2Va0FLa3Rguvbpa4W3I5xynaBZo41cM3XM+4Q6fRMj3sBYIR1VAmZMXYJvRQ==",
       "license": "Apache-2.0",
       "dependencies": {
         "tslib": "^1.9.0"
@@ -2515,14 +2188,10 @@
     },
     "node_modules/rxjs/node_modules/tslib": {
       "version": "1.14.1",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz",
-      "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==",
       "license": "0BSD"
     },
     "node_modules/safe-buffer": {
       "version": "5.2.1",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
-      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
       "funding": [
         {
           "type": "github",
@@ -2541,8 +2210,6 @@
     },
     "node_modules/safe-stable-stringify": {
       "version": "2.5.0",
-      "resolved": "https://registry.npmjs.org/safe-stable-stringify/-/safe-stable-stringify-2.5.0.tgz",
-      "integrity": "sha512-b3rppTKm9T+PsVCBEOUR46GWI7fdOs00VKZ1+9c1EWDaDMvjQc6tUwuFyIprgGgTcWoVHSKrU8H31ZHA2e0RHA==",
       "license": "MIT",
       "engines": {
         "node": ">=10"
@@ -2550,8 +2217,6 @@
     },
     "node_modules/safer-buffer": {
       "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
-      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
       "license": "MIT"
     },
     "node_modules/semver": {
@@ -2568,8 +2233,6 @@
     },
     "node_modules/shebang-command": {
       "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
-      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
       "license": "MIT",
       "dependencies": {
         "shebang-regex": "^3.0.0"
@@ -2580,8 +2243,6 @@
     },
     "node_modules/shebang-regex": {
       "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
-      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
       "license": "MIT",
       "engines": {
         "node": ">=8"
@@ -2589,14 +2250,10 @@
     },
     "node_modules/signal-exit": {
       "version": "3.0.7",
-      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
-      "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
       "license": "ISC"
     },
     "node_modules/simple-swizzle": {
       "version": "0.2.2",
-      "resolved": "https://registry.npmjs.org/simple-swizzle/-/simple-swizzle-0.2.2.tgz",
-      "integrity": "sha512-JA//kQgZtbuY83m+xT+tXJkmJncGMTFT+C+g2h2R9uxkYIrE2yy9sgmcLhCnw57/WSD+Eh3J97FPEDFnbXnDUg==",
       "license": "MIT",
       "dependencies": {
         "is-arrayish": "^0.3.1"
@@ -2604,14 +2261,10 @@
     },
     "node_modules/simple-swizzle/node_modules/is-arrayish": {
       "version": "0.3.2",
-      "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.3.2.tgz",
-      "integrity": "sha512-eVRqCvVlZbuw3GrM63ovNSNAeA1K16kaR/LRY/92w0zxQ5/1YzwblUX652i4Xs9RwAGjW9d9y6X88t8OaAJfWQ==",
       "license": "MIT"
     },
     "node_modules/slice-ansi": {
       "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-2.1.0.tgz",
-      "integrity": "sha512-Qu+VC3EwYLldKa1fCxuuvULvSJOKEgk9pi8dZeCVK7TqBfUNTH4sFkk4joj8afVSfAYgJoSOetjx9QWOJ5mYoQ==",
       "license": "MIT",
       "dependencies": {
         "ansi-styles": "^3.2.0",
@@ -2624,8 +2277,6 @@
     },
     "node_modules/slice-ansi/node_modules/ansi-styles": {
       "version": "3.2.1",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
-      "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
       "license": "MIT",
       "dependencies": {
         "color-convert": "^1.9.0"
@@ -2636,8 +2287,6 @@
     },
     "node_modules/slice-ansi/node_modules/color-convert": {
       "version": "1.9.3",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
-      "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
       "license": "MIT",
       "dependencies": {
         "color-name": "1.1.3"
@@ -2645,8 +2294,6 @@
     },
     "node_modules/slice-ansi/node_modules/color-name": {
       "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
-      "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==",
       "license": "MIT"
     },
     "node_modules/smart-buffer": {
@@ -2660,12 +2307,12 @@
       }
     },
     "node_modules/socks": {
-      "version": "2.8.6",
-      "resolved": "https://registry.npmjs.org/socks/-/socks-2.8.6.tgz",
-      "integrity": "sha512-pe4Y2yzru68lXCb38aAqRf5gvN8YdjP1lok5o0J7BOHljkyCGKVz7H3vpVIXKD27rj2giOJ7DwVyk/GWrPHDWA==",
+      "version": "2.8.7",
+      "resolved": "https://registry.npmjs.org/socks/-/socks-2.8.7.tgz",
+      "integrity": "sha512-HLpt+uLy/pxB+bum/9DzAgiKS8CX1EvbWxI4zlmgGCExImLdiad2iCwXT5Z4c9c3Eq8rP2318mPW2c+QbtjK8A==",
       "license": "MIT",
       "dependencies": {
-        "ip-address": "^9.0.5",
+        "ip-address": "^10.0.1",
         "smart-buffer": "^4.2.0"
       },
       "engines": {
@@ -2697,16 +2344,8 @@
         "node": ">=0.10.0"
       }
     },
-    "node_modules/sprintf-js": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.3.tgz",
-      "integrity": "sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==",
-      "license": "BSD-3-Clause"
-    },
     "node_modules/stack-trace": {
       "version": "0.0.10",
-      "resolved": "https://registry.npmjs.org/stack-trace/-/stack-trace-0.0.10.tgz",
-      "integrity": "sha512-KGzahc7puUKkzyMt+IqAep+TVNbKP+k2Lmwhub39m1AsTSkaDutx56aDCo+HLDzf/D26BIHTJWNiTG1KAJiQCg==",
       "license": "MIT",
       "engines": {
         "node": "*"
@@ -2727,8 +2366,6 @@
     },
     "node_modules/string_decoder": {
       "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
-      "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
       "license": "MIT",
       "dependencies": {
         "safe-buffer": "~5.2.0"
@@ -2736,8 +2373,6 @@
     },
     "node_modules/string-width": {
       "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz",
-      "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==",
       "license": "MIT",
       "dependencies": {
         "emoji-regex": "^7.0.1",
@@ -2750,8 +2385,6 @@
     },
     "node_modules/string-width/node_modules/ansi-regex": {
       "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.1.tgz",
-      "integrity": "sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==",
       "license": "MIT",
       "engines": {
         "node": ">=6"
@@ -2759,8 +2392,6 @@
     },
     "node_modules/string-width/node_modules/strip-ansi": {
       "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz",
-      "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==",
       "license": "MIT",
       "dependencies": {
         "ansi-regex": "^4.1.0"
@@ -2771,8 +2402,6 @@
     },
     "node_modules/strip-ansi": {
       "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
-      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
       "license": "MIT",
       "dependencies": {
         "ansi-regex": "^5.0.1"
@@ -2783,8 +2412,6 @@
     },
     "node_modules/strip-json-comments": {
       "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
-      "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
       "license": "MIT",
       "engines": {
         "node": ">=8"
@@ -2795,8 +2422,6 @@
     },
     "node_modules/supports-color": {
       "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
-      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
       "license": "MIT",
       "dependencies": {
         "has-flag": "^4.0.0"
@@ -2807,8 +2432,6 @@
     },
     "node_modules/table": {
       "version": "5.4.6",
-      "resolved": "https://registry.npmjs.org/table/-/table-5.4.6.tgz",
-      "integrity": "sha512-wmEc8m4fjnob4gt5riFRtTu/6+4rSe12TpAELNSqHMfF3IqnA+CH37USM6/YR3qRZv7e56kAEAtd6nKZaxe0Ug==",
       "license": "BSD-3-Clause",
       "dependencies": {
         "ajv": "^6.10.2",
@@ -2822,8 +2445,6 @@
     },
     "node_modules/tabtab": {
       "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/tabtab/-/tabtab-3.0.2.tgz",
-      "integrity": "sha512-jANKmUe0sIQc/zTALTBy186PoM/k6aPrh3A7p6AaAfF6WPSbTx1JYeGIGH162btpH+mmVEXln+UxwViZHO2Jhg==",
       "license": "MIT",
       "dependencies": {
         "debug": "^4.0.1",
@@ -2870,26 +2491,18 @@
     },
     "node_modules/text-hex": {
       "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/text-hex/-/text-hex-1.0.0.tgz",
-      "integrity": "sha512-uuVGNWzgJ4yhRaNSiubPY7OjISw4sw4E5Uv0wbjp+OzcbmVU/rsT8ujgcXJhn9ypzsgr5vlzpPqP+MBBKcGvbg==",
       "license": "MIT"
     },
     "node_modules/text-table": {
       "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz",
-      "integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==",
       "license": "MIT"
     },
     "node_modules/through": {
       "version": "2.3.8",
-      "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz",
-      "integrity": "sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==",
       "license": "MIT"
     },
     "node_modules/tmp": {
       "version": "0.0.33",
-      "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.0.33.tgz",
-      "integrity": "sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==",
       "license": "MIT",
       "dependencies": {
         "os-tmpdir": "~1.0.2"
@@ -2900,8 +2513,6 @@
     },
     "node_modules/to-regex-range": {
       "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
-      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
       "license": "MIT",
       "dependencies": {
         "is-number": "^7.0.0"
@@ -2912,8 +2523,6 @@
     },
     "node_modules/triple-beam": {
       "version": "1.4.1",
-      "resolved": "https://registry.npmjs.org/triple-beam/-/triple-beam-1.4.1.tgz",
-      "integrity": "sha512-aZbgViZrg1QNcG+LULa7nhZpJTZSLm/mXnHXnbAbjmN5aSa0y7V+wvv6+4WaBtpISJzThKy+PIPxc1Nq1EJ9mg==",
       "license": "MIT",
       "engines": {
         "node": ">= 14.0.0"
@@ -2927,8 +2536,6 @@
     },
     "node_modules/type-check": {
       "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
-      "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==",
       "license": "MIT",
       "dependencies": {
         "prelude-ls": "^1.2.1"
@@ -2939,8 +2546,6 @@
     },
     "node_modules/type-fest": {
       "version": "0.20.2",
-      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz",
-      "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==",
       "license": "(MIT OR CC0-1.0)",
       "engines": {
         "node": ">=10"
@@ -2951,8 +2556,6 @@
     },
     "node_modules/typescript": {
       "version": "5.8.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz",
-      "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==",
       "license": "Apache-2.0",
       "bin": {
         "tsc": "bin/tsc",
@@ -2974,8 +2577,6 @@
     },
     "node_modules/untildify": {
       "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/untildify/-/untildify-3.0.3.tgz",
-      "integrity": "sha512-iSk/J8efr8uPT/Z4eSUywnqyrQU7DSdMfdqK4iWEaUVVmcP5JcnpRqmVMwcwcnmI1ATFNgC5V90u09tBynNFKA==",
       "license": "MIT",
       "engines": {
         "node": ">=4"
@@ -2983,8 +2584,6 @@
     },
     "node_modules/uri-js": {
       "version": "4.4.1",
-      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
-      "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
       "license": "BSD-2-Clause",
       "dependencies": {
         "punycode": "^2.1.0"
@@ -2998,14 +2597,10 @@
     },
     "node_modules/util-deprecate": {
       "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
-      "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
       "license": "MIT"
     },
     "node_modules/which": {
       "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
-      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
       "license": "ISC",
       "dependencies": {
         "isexe": "^2.0.0"
@@ -3019,8 +2614,6 @@
     },
     "node_modules/winston": {
       "version": "3.17.0",
-      "resolved": "https://registry.npmjs.org/winston/-/winston-3.17.0.tgz",
-      "integrity": "sha512-DLiFIXYC5fMPxaRg832S6F5mJYvePtmO5G9v9IgUFPhXm9/GkXarH/TUrBAVzhTCzAj9anE/+GjrgXp/54nOgw==",
       "license": "MIT",
       "dependencies": {
         "@colors/colors": "^1.6.0",
@@ -3041,8 +2634,6 @@
     },
     "node_modules/winston-transport": {
       "version": "4.9.0",
-      "resolved": "https://registry.npmjs.org/winston-transport/-/winston-transport-4.9.0.tgz",
-      "integrity": "sha512-8drMJ4rkgaPo1Me4zD/3WLfI/zPdA9o2IipKODunnGDcuqbHwjsbB79ylv04LCGGzU0xQ6vTznOMpQGaLhhm6A==",
       "license": "MIT",
       "dependencies": {
         "logform": "^2.7.0",
@@ -3055,8 +2646,6 @@
     },
     "node_modules/word-wrap": {
       "version": "1.2.5",
-      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
-      "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==",
       "license": "MIT",
       "engines": {
         "node": ">=0.10.0"
@@ -3064,8 +2653,6 @@
     },
     "node_modules/wrap-ansi": {
       "version": "6.2.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-6.2.0.tgz",
-      "integrity": "sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==",
       "license": "MIT",
       "dependencies": {
         "ansi-styles": "^4.0.0",
@@ -3078,14 +2665,10 @@
     },
     "node_modules/wrap-ansi/node_modules/emoji-regex": {
       "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
-      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
       "license": "MIT"
     },
     "node_modules/wrap-ansi/node_modules/is-fullwidth-code-point": {
       "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
-      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
       "license": "MIT",
       "engines": {
         "node": ">=8"
@@ -3093,8 +2676,6 @@
     },
     "node_modules/wrap-ansi/node_modules/string-width": {
       "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
-      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
       "license": "MIT",
       "dependencies": {
         "emoji-regex": "^8.0.0",
@@ -3107,8 +2688,6 @@
     },
     "node_modules/wrappy": {
       "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
-      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
       "license": "ISC"
     },
     "node_modules/ws": {
@@ -3209,8 +2788,6 @@
     },
     "node_modules/yocto-queue": {
       "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
-      "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
       "license": "MIT",
       "engines": {
         "node": ">=10"
diff --git a/package.json b/package.json
index 04f4c501d1fb2..976d630363413 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "browser-ui-test": "^0.21.3",
+    "browser-ui-test": "^0.22.0",
     "es-check": "^6.2.1",
     "eslint": "^8.57.1",
     "eslint-js": "github:eslint/js",

From b0a8e3c767c200a33a27e2924daf8fe2eadc0742 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 4 Sep 2025 15:32:00 +0200
Subject: [PATCH 0587/1889] Simplify rustdoc-gui tester by calling directly
 `browser-ui-test`

---
 src/tools/rustdoc-gui-test/src/main.rs        |  20 +-
 src/tools/rustdoc-gui/.eslintrc.js            |  96 ------
 src/tools/rustdoc-gui/tester.js               | 309 ------------------
 src/tools/tidy/src/extra_checks/rustdoc_js.rs |   6 -
 triagebot.toml                                |   1 -
 5 files changed, 13 insertions(+), 419 deletions(-)
 delete mode 100644 src/tools/rustdoc-gui/.eslintrc.js
 delete mode 100644 src/tools/rustdoc-gui/tester.js

diff --git a/src/tools/rustdoc-gui-test/src/main.rs b/src/tools/rustdoc-gui-test/src/main.rs
index 42feae8c2080a..5062c2597f15e 100644
--- a/src/tools/rustdoc-gui-test/src/main.rs
+++ b/src/tools/rustdoc-gui-test/src/main.rs
@@ -71,22 +71,28 @@ fn main() -> Result<(), ()> {
     let mut command = Command::new(&config.nodejs);
 
     command
-        .arg(config.rust_src.join("src/tools/rustdoc-gui/tester.js"))
+        .arg(local_node_modules.join(".bin/browser-ui-test"))
         .arg("--jobs")
         .arg(&config.jobs)
-        .arg("--doc-folder")
+        .arg("--variable")
+        .arg("DOC_PATH")
         .arg(config.out_dir.join("doc"))
-        .arg("--tests-folder")
-        .arg(config.rust_src.join("tests/rustdoc-gui"));
+        .arg("--allow-file-access-from-files")
+        .arg("--display-format")
+        .arg("compact");
 
     if local_node_modules.exists() {
-        // Link the local node_modules if exists.
+        // Link the local node_modules if it exists.
         // This is useful when we run rustdoc-gui-test from outside of the source root.
         command.env("NODE_PATH", local_node_modules);
     }
 
-    for file in &config.goml_files {
-        command.arg("--file").arg(file);
+    if config.goml_files.is_empty() {
+        command.arg("--test-folder").arg(config.rust_src.join("tests/rustdoc-gui"));
+    } else {
+        for file in &config.goml_files {
+            command.arg("--test-file").arg(config.rust_src.join("tests/rustdoc-gui").join(file));
+        }
     }
 
     command.args(&config.test_args);
diff --git a/src/tools/rustdoc-gui/.eslintrc.js b/src/tools/rustdoc-gui/.eslintrc.js
deleted file mode 100644
index 3eccbc74cb95e..0000000000000
--- a/src/tools/rustdoc-gui/.eslintrc.js
+++ /dev/null
@@ -1,96 +0,0 @@
-module.exports = {
-    "env": {
-        "browser": true,
-        "node": true,
-        "es6": true
-    },
-    "extends": "eslint:recommended",
-    "parserOptions": {
-        "ecmaVersion": 2019,
-        "sourceType": "module"
-    },
-    "rules": {
-        "linebreak-style": [
-            "error",
-            "unix"
-        ],
-        "semi": [
-            "error",
-            "always"
-        ],
-        "quotes": [
-            "error",
-            "double"
-        ],
-        "linebreak-style": [
-            "error",
-            "unix"
-        ],
-        "no-trailing-spaces": "error",
-        "no-var": ["error"],
-        "prefer-const": ["error"],
-        "prefer-arrow-callback": ["error"],
-        "brace-style": [
-            "error",
-            "1tbs",
-            { "allowSingleLine": false }
-        ],
-        "keyword-spacing": [
-            "error",
-            { "before": true, "after": true }
-        ],
-        "arrow-spacing": [
-            "error",
-            { "before": true, "after": true }
-        ],
-        "key-spacing": [
-            "error",
-            { "beforeColon": false, "afterColon": true, "mode": "strict" }
-        ],
-        "func-call-spacing": ["error", "never"],
-        "space-infix-ops": "error",
-        "space-before-function-paren": ["error", "never"],
-        "space-before-blocks": "error",
-        "comma-dangle": ["error", "always-multiline"],
-        "comma-style": ["error", "last"],
-        "max-len": ["error", { "code": 100, "tabWidth": 4 }],
-        "eol-last": ["error", "always"],
-        "arrow-parens": ["error", "as-needed"],
-        "no-unused-vars": [
-            "error",
-            {
-                "argsIgnorePattern": "^_",
-                "varsIgnorePattern": "^_"
-            }
-        ],
-        "eqeqeq": "error",
-        "no-const-assign": "error",
-        "no-debugger": "error",
-        "no-dupe-args": "error",
-        "no-dupe-else-if": "error",
-        "no-dupe-keys": "error",
-        "no-duplicate-case": "error",
-        "no-ex-assign": "error",
-        "no-fallthrough": "error",
-        "no-invalid-regexp": "error",
-        "no-import-assign": "error",
-        "no-self-compare": "error",
-        "no-template-curly-in-string": "error",
-        "block-scoped-var": "error",
-        "guard-for-in": "error",
-        "no-alert": "error",
-        "no-confusing-arrow": "error",
-        "no-div-regex": "error",
-        "no-floating-decimal": "error",
-        "no-implicit-globals": "error",
-        "no-implied-eval": "error",
-        "no-label-var": "error",
-        "no-lonely-if": "error",
-        "no-mixed-operators": "error",
-        "no-multi-assign": "error",
-        "no-return-assign": "error",
-        "no-script-url": "error",
-        "no-sequences": "error",
-        "no-div-regex": "error",
-    }
-};
diff --git a/src/tools/rustdoc-gui/tester.js b/src/tools/rustdoc-gui/tester.js
deleted file mode 100644
index 9dc32f335a895..0000000000000
--- a/src/tools/rustdoc-gui/tester.js
+++ /dev/null
@@ -1,309 +0,0 @@
-// This package needs to be install:
-//
-// ```
-// npm install browser-ui-test
-// ```
-
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-const {Options, runTest} = require("browser-ui-test");
-
-// If a test fails or errors, we will retry it two more times in case it was a flaky failure.
-const NB_RETRY = 3;
-
-function showHelp() {
-    console.log("rustdoc-js options:");
-    console.log("  --doc-folder [PATH]        : location of the generated doc folder");
-    console.log("  --file [PATH]              : file to run (can be repeated)");
-    console.log("  --debug                    : show extra information about script run");
-    console.log("  --show-text                : render font in pages");
-    console.log("  --no-headless              : disable headless mode");
-    console.log("  --help                     : show this message then quit");
-    console.log("  --tests-folder [PATH]      : location of the .GOML tests folder");
-    console.log("  --jobs [NUMBER]            : number of threads to run tests on");
-    console.log("  --executable-path [PATH]   : path of the browser's executable to be used");
-}
-
-function isNumeric(s) {
-    return /^\d+$/.test(s);
-}
-
-function parseOptions(args) {
-    const opts = {
-        "doc_folder": "",
-        "tests_folder": "",
-        "files": [],
-        "debug": false,
-        "show_text": false,
-        "no_headless": false,
-        "jobs": -1,
-        "executable_path": null,
-    };
-    const correspondences = {
-        "--doc-folder": "doc_folder",
-        "--tests-folder": "tests_folder",
-        "--debug": "debug",
-        "--show-text": "show_text",
-        "--no-headless": "no_headless",
-        "--executable-path": "executable_path",
-    };
-
-    for (let i = 0; i < args.length; ++i) {
-        const arg = args[i];
-        if (arg === "--doc-folder"
-            || arg === "--tests-folder"
-            || arg === "--file"
-            || arg === "--jobs"
-            || arg === "--executable-path") {
-            i += 1;
-            if (i >= args.length) {
-                console.log("Missing argument after `" + arg + "` option.");
-                return null;
-            }
-            const arg_value = args[i];
-            if (arg === "--jobs") {
-                if (!isNumeric(arg_value)) {
-                    console.log(
-                        "`--jobs` option expects a positive number, found `" + arg_value + "`");
-                    return null;
-                }
-                opts["jobs"] = parseInt(arg_value);
-            } else if (arg !== "--file") {
-                opts[correspondences[arg]] = arg_value;
-            } else {
-                opts["files"].push(arg_value);
-            }
-        } else if (arg === "--help") {
-            showHelp();
-            process.exit(0);
-        } else if (correspondences[arg]) {
-            opts[correspondences[arg]] = true;
-        } else {
-            console.log("Unknown option `" + arg + "`.");
-            console.log("Use `--help` to see the list of options");
-            return null;
-        }
-    }
-    if (opts["tests_folder"].length < 1) {
-        console.log("Missing `--tests-folder` option.");
-    } else if (opts["doc_folder"].length < 1) {
-        console.log("Missing `--doc-folder` option.");
-    } else {
-        return opts;
-    }
-    return null;
-}
-
-/// Print single char status information without \n
-function char_printer(n_tests) {
-    const max_per_line = 10;
-    let current = 0;
-    return {
-        successful: function() {
-            current += 1;
-            if (current % max_per_line === 0) {
-                process.stdout.write(`. (${current}/${n_tests})${os.EOL}`);
-            } else {
-                process.stdout.write(".");
-            }
-        },
-        erroneous: function() {
-            current += 1;
-            if (current % max_per_line === 0) {
-                process.stderr.write(`F (${current}/${n_tests})${os.EOL}`);
-            } else {
-                process.stderr.write("F");
-            }
-        },
-        finish: function() {
-            if (current % max_per_line === 0) {
-                // Don't output if we are already at a matching line end
-                console.log("");
-            } else {
-                const spaces = " ".repeat(max_per_line - (current % max_per_line));
-                process.stdout.write(`${spaces} (${current}/${n_tests})${os.EOL}${os.EOL}`);
-            }
-        },
-    };
-}
-
-// Sort array by .file_name property
-function by_filename(a, b) {
-    return a.file_name - b.file_name;
-}
-
-async function runTests(opts, framework_options, files, results, status_bar, showTestFailures) {
-    const tests_queue = [];
-
-    for (const testPath of files) {
-        const callback = runTest(testPath, {"options": framework_options})
-            .then(out => {
-                const [output, nb_failures] = out;
-                results[nb_failures === 0 ? "successful" : "failed"].push({
-                    file_name: testPath,
-                    output: output,
-                });
-                if (nb_failures === 0) {
-                    status_bar.successful();
-                } else if (showTestFailures) {
-                    status_bar.erroneous();
-                }
-            })
-            .catch(err => {
-                results.errored.push({
-                    file_name: testPath,
-                    output: err,
-                });
-                if (showTestFailures) {
-                    status_bar.erroneous();
-                }
-            })
-            .finally(() => {
-                // We now remove the promise from the tests_queue.
-                tests_queue.splice(tests_queue.indexOf(callback), 1);
-            });
-        tests_queue.push(callback);
-        if (opts["jobs"] > 0 && tests_queue.length >= opts["jobs"]) {
-            await Promise.race(tests_queue);
-        }
-    }
-    if (tests_queue.length > 0) {
-        await Promise.all(tests_queue);
-    }
-}
-
-function createEmptyResults() {
-    return {
-        successful: [],
-        failed: [],
-        errored: [],
-    };
-}
-
-async function main(argv) {
-    const opts = parseOptions(argv.slice(2));
-    if (opts === null) {
-        process.exit(1);
-    }
-
-    // Print successful tests too
-    let debug = false;
-    // Run tests in sequentially
-    let headless = true;
-    const framework_options = new Options();
-    try {
-        // This is more convenient that setting fields one by one.
-        const args = [
-            "--variable", "DOC_PATH", opts["doc_folder"].split("\\").join("/"),
-            "--allow-file-access-from-files",
-        ];
-        if (opts["debug"]) {
-            debug = true;
-            args.push("--debug");
-        }
-        if (opts["show_text"]) {
-            args.push("--show-text");
-        }
-        if (opts["no_headless"]) {
-            args.push("--no-headless");
-            headless = false;
-        }
-        if (opts["executable_path"] !== null) {
-            args.push("--executable-path");
-            args.push(opts["executable_path"]);
-        }
-        framework_options.parseArguments(args);
-    } catch (error) {
-        console.error(`invalid argument: ${error}`);
-        process.exit(1);
-    }
-
-    let files;
-    if (opts["files"].length === 0) {
-        files = fs.readdirSync(opts["tests_folder"]);
-    } else {
-        files = opts["files"];
-    }
-    files = files.filter(file => path.extname(file) === ".goml");
-    if (files.length === 0) {
-        console.error("rustdoc-gui: No test selected");
-        process.exit(2);
-    }
-    files.forEach((file_name, index) => {
-        files[index] = path.join(opts["tests_folder"], file_name);
-    });
-    files.sort();
-
-    if (!headless) {
-        opts["jobs"] = 1;
-        console.log("`--no-headless` option is active, disabling concurrency for running tests.");
-    }
-
-    if (opts["jobs"] < 1) {
-        const len = files.length;
-        console.log(
-            `Running ${len} rustdoc-gui (UNBOUNDED concurrency; use "-j#" for a limit) ...`,
-        );
-        process.setMaxListeners(files.length + 1);
-    } else if (headless) {
-        console.log(`Running ${files.length} rustdoc-gui (${opts["jobs"]} concurrently) ...`);
-        process.setMaxListeners(opts["jobs"] + 1);
-    } else {
-        console.log(`Running ${files.length} rustdoc-gui ...`);
-    }
-
-    const originalFilesLen = files.length;
-    const results = createEmptyResults();
-    const status_bar = char_printer(files.length);
-
-    let new_results;
-    for (let it = 0; it < NB_RETRY && files.length > 0; ++it) {
-        new_results = createEmptyResults();
-        await runTests(opts, framework_options, files, new_results, status_bar, it + 1 >= NB_RETRY);
-        Array.prototype.push.apply(results.successful, new_results.successful);
-        // We generate the new list of files with the previously failing tests.
-        files = Array.prototype.concat(new_results.failed, new_results.errored).map(
-            f => f["file_name"]);
-        if (files.length > originalFilesLen / 2) {
-            // If we have too many failing tests, it's very likely not flaky failures anymore so
-            // no need to retry.
-            break;
-        }
-    }
-
-    status_bar.finish();
-
-    Array.prototype.push.apply(results.failed, new_results.failed);
-    Array.prototype.push.apply(results.errored, new_results.errored);
-
-    if (debug) {
-        results.successful.sort(by_filename);
-        results.successful.forEach(r => {
-            console.log(r.output);
-        });
-    }
-
-    if (results.failed.length > 0) {
-        console.log("");
-        results.failed.sort(by_filename);
-        results.failed.forEach(r => {
-            console.log(r.file_name, r.output);
-        });
-    }
-    if (results.errored.length > 0) {
-        console.log(os.EOL);
-        // print run errors on the bottom so developers see them better
-        results.errored.sort(by_filename);
-        results.errored.forEach(r => {
-            console.error(r.file_name, r.output);
-        });
-    }
-
-    if (results.failed.length > 0 || results.errored.length > 0) {
-        process.exit(1);
-    }
-    process.exit(0);
-}
-
-main(process.argv);
diff --git a/src/tools/tidy/src/extra_checks/rustdoc_js.rs b/src/tools/tidy/src/extra_checks/rustdoc_js.rs
index 2e6821a41c707..a6c66b8be8029 100644
--- a/src/tools/tidy/src/extra_checks/rustdoc_js.rs
+++ b/src/tools/tidy/src/extra_checks/rustdoc_js.rs
@@ -79,12 +79,6 @@ pub(super) fn lint(
         tools_path.join("rustdoc-js"),
         bless,
     )?;
-    run_eslint(
-        outdir,
-        &[tools_path.join("rustdoc-gui/tester.js")],
-        tools_path.join("rustdoc-gui"),
-        bless,
-    )?;
     Ok(())
 }
 
diff --git a/triagebot.toml b/triagebot.toml
index 6924ed4a0d951..50534011f915e 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -235,7 +235,6 @@ trigger_files = [
     "src/etc/htmldocck.py",
     "src/tools/jsondocck",
     "src/tools/jsondoclint",
-    "src/tools/rustdoc-gui",
     "src/tools/rustdoc-js",
     "src/tools/rustdoc-themes",
 

From e3d0b7d6480d7e4dbbbea24635f56e28dfe735b3 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Fri, 15 Aug 2025 13:12:19 +0000
Subject: [PATCH 0588/1889] Remove thin_link_data method from ThinBufferMethods

It is only used within cg_llvm.
---
 compiler/rustc_codegen_gcc/src/back/lto.rs     |  4 ----
 compiler/rustc_codegen_llvm/src/back/lto.rs    | 16 ++++++++--------
 compiler/rustc_codegen_ssa/src/traits/write.rs |  1 -
 3 files changed, 8 insertions(+), 13 deletions(-)

diff --git a/compiler/rustc_codegen_gcc/src/back/lto.rs b/compiler/rustc_codegen_gcc/src/back/lto.rs
index 9d8ce2383f2b1..d475d2c7da996 100644
--- a/compiler/rustc_codegen_gcc/src/back/lto.rs
+++ b/compiler/rustc_codegen_gcc/src/back/lto.rs
@@ -650,10 +650,6 @@ impl ThinBufferMethods for ThinBuffer {
     fn data(&self) -> &[u8] {
         &[]
     }
-
-    fn thin_link_data(&self) -> &[u8] {
-        unimplemented!();
-    }
 }
 
 pub struct ThinData; //(Arc<TempDir>);
diff --git a/compiler/rustc_codegen_llvm/src/back/lto.rs b/compiler/rustc_codegen_llvm/src/back/lto.rs
index ad2e722cfef62..319f80beb0654 100644
--- a/compiler/rustc_codegen_llvm/src/back/lto.rs
+++ b/compiler/rustc_codegen_llvm/src/back/lto.rs
@@ -698,21 +698,21 @@ impl ThinBuffer {
         let mut ptr = NonNull::new(ptr).unwrap();
         ThinBuffer(unsafe { ptr.as_mut() })
     }
-}
 
-impl ThinBufferMethods for ThinBuffer {
-    fn data(&self) -> &[u8] {
+    pub(crate) fn thin_link_data(&self) -> &[u8] {
         unsafe {
-            let ptr = llvm::LLVMRustThinLTOBufferPtr(self.0) as *const _;
-            let len = llvm::LLVMRustThinLTOBufferLen(self.0);
+            let ptr = llvm::LLVMRustThinLTOBufferThinLinkDataPtr(self.0) as *const _;
+            let len = llvm::LLVMRustThinLTOBufferThinLinkDataLen(self.0);
             slice::from_raw_parts(ptr, len)
         }
     }
+}
 
-    fn thin_link_data(&self) -> &[u8] {
+impl ThinBufferMethods for ThinBuffer {
+    fn data(&self) -> &[u8] {
         unsafe {
-            let ptr = llvm::LLVMRustThinLTOBufferThinLinkDataPtr(self.0) as *const _;
-            let len = llvm::LLVMRustThinLTOBufferThinLinkDataLen(self.0);
+            let ptr = llvm::LLVMRustThinLTOBufferPtr(self.0) as *const _;
+            let len = llvm::LLVMRustThinLTOBufferLen(self.0);
             slice::from_raw_parts(ptr, len)
         }
     }
diff --git a/compiler/rustc_codegen_ssa/src/traits/write.rs b/compiler/rustc_codegen_ssa/src/traits/write.rs
index cc7c4e46d7bba..40f546ebc92fd 100644
--- a/compiler/rustc_codegen_ssa/src/traits/write.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/write.rs
@@ -59,7 +59,6 @@ pub trait WriteBackendMethods: Clone + 'static {
 
 pub trait ThinBufferMethods: Send + Sync {
     fn data(&self) -> &[u8];
-    fn thin_link_data(&self) -> &[u8];
 }
 
 pub trait ModuleBufferMethods: Send + Sync {

From f2933b34a8331204270fa2bdbdcfd79fcffbb302 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Thu, 4 Sep 2025 15:16:55 +0000
Subject: [PATCH 0589/1889] Remove want_summary argument from prepare_thin

It is always false nowadays. ThinLTO summary writing is instead done by
llvm_optimize.
---
 compiler/rustc_codegen_gcc/src/back/lto.rs       |  7 ++-----
 compiler/rustc_codegen_gcc/src/lib.rs            |  7 ++-----
 compiler/rustc_codegen_llvm/src/back/lto.rs      | 11 ++++-------
 compiler/rustc_codegen_llvm/src/back/write.rs    |  2 +-
 compiler/rustc_codegen_llvm/src/lib.rs           |  7 ++-----
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs      |  1 -
 compiler/rustc_codegen_ssa/src/back/write.rs     |  2 +-
 compiler/rustc_codegen_ssa/src/traits/write.rs   |  5 +----
 compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp | 11 +++--------
 9 files changed, 16 insertions(+), 37 deletions(-)

diff --git a/compiler/rustc_codegen_gcc/src/back/lto.rs b/compiler/rustc_codegen_gcc/src/back/lto.rs
index d475d2c7da996..d29bba2570f67 100644
--- a/compiler/rustc_codegen_gcc/src/back/lto.rs
+++ b/compiler/rustc_codegen_gcc/src/back/lto.rs
@@ -305,12 +305,9 @@ pub(crate) fn run_thin(
     )
 }
 
-pub(crate) fn prepare_thin(
-    module: ModuleCodegen<GccContext>,
-    _emit_summary: bool,
-) -> (String, ThinBuffer) {
+pub(crate) fn prepare_thin(module: ModuleCodegen<GccContext>) -> (String, ThinBuffer) {
     let name = module.name;
-    //let buffer = ThinBuffer::new(module.module_llvm.context, true, emit_summary);
+    //let buffer = ThinBuffer::new(module.module_llvm.context, true);
     let buffer = ThinBuffer::new(&module.module_llvm.context);
     (name, buffer)
 }
diff --git a/compiler/rustc_codegen_gcc/src/lib.rs b/compiler/rustc_codegen_gcc/src/lib.rs
index 2d7df79ba95fa..f76f933cad4a5 100644
--- a/compiler/rustc_codegen_gcc/src/lib.rs
+++ b/compiler/rustc_codegen_gcc/src/lib.rs
@@ -408,11 +408,8 @@ impl WriteBackendMethods for GccCodegenBackend {
         back::write::codegen(cgcx, module, config)
     }
 
-    fn prepare_thin(
-        module: ModuleCodegen<Self::Module>,
-        emit_summary: bool,
-    ) -> (String, Self::ThinBuffer) {
-        back::lto::prepare_thin(module, emit_summary)
+    fn prepare_thin(module: ModuleCodegen<Self::Module>) -> (String, Self::ThinBuffer) {
+        back::lto::prepare_thin(module)
     }
 
     fn serialize_module(_module: ModuleCodegen<Self::Module>) -> (String, Self::ModuleBuffer) {
diff --git a/compiler/rustc_codegen_llvm/src/back/lto.rs b/compiler/rustc_codegen_llvm/src/back/lto.rs
index 319f80beb0654..f571716d9dd9f 100644
--- a/compiler/rustc_codegen_llvm/src/back/lto.rs
+++ b/compiler/rustc_codegen_llvm/src/back/lto.rs
@@ -185,12 +185,9 @@ pub(crate) fn run_thin(
     thin_lto(cgcx, dcx, modules, upstream_modules, cached_modules, &symbols_below_threshold)
 }
 
-pub(crate) fn prepare_thin(
-    module: ModuleCodegen<ModuleLlvm>,
-    emit_summary: bool,
-) -> (String, ThinBuffer) {
+pub(crate) fn prepare_thin(module: ModuleCodegen<ModuleLlvm>) -> (String, ThinBuffer) {
     let name = module.name;
-    let buffer = ThinBuffer::new(module.module_llvm.llmod(), true, emit_summary);
+    let buffer = ThinBuffer::new(module.module_llvm.llmod(), true);
     (name, buffer)
 }
 
@@ -687,9 +684,9 @@ unsafe impl Send for ThinBuffer {}
 unsafe impl Sync for ThinBuffer {}
 
 impl ThinBuffer {
-    pub(crate) fn new(m: &llvm::Module, is_thin: bool, emit_summary: bool) -> ThinBuffer {
+    pub(crate) fn new(m: &llvm::Module, is_thin: bool) -> ThinBuffer {
         unsafe {
-            let buffer = llvm::LLVMRustThinLTOBufferCreate(m, is_thin, emit_summary);
+            let buffer = llvm::LLVMRustThinLTOBufferCreate(m, is_thin);
             ThinBuffer(buffer)
         }
     }
diff --git a/compiler/rustc_codegen_llvm/src/back/write.rs b/compiler/rustc_codegen_llvm/src/back/write.rs
index 7ea2ae6673b0f..423f0da48781a 100644
--- a/compiler/rustc_codegen_llvm/src/back/write.rs
+++ b/compiler/rustc_codegen_llvm/src/back/write.rs
@@ -837,7 +837,7 @@ pub(crate) fn codegen(
                         "LLVM_module_codegen_make_bitcode",
                         &*module.name,
                     );
-                    ThinBuffer::new(llmod, config.emit_thin_lto, false)
+                    ThinBuffer::new(llmod, config.emit_thin_lto)
                 };
                 let data = thin.data();
                 let _timer = cgcx
diff --git a/compiler/rustc_codegen_llvm/src/lib.rs b/compiler/rustc_codegen_llvm/src/lib.rs
index 628cb34fd9e46..6fb23d0984335 100644
--- a/compiler/rustc_codegen_llvm/src/lib.rs
+++ b/compiler/rustc_codegen_llvm/src/lib.rs
@@ -211,11 +211,8 @@ impl WriteBackendMethods for LlvmCodegenBackend {
     ) -> CompiledModule {
         back::write::codegen(cgcx, module, config)
     }
-    fn prepare_thin(
-        module: ModuleCodegen<Self::Module>,
-        emit_summary: bool,
-    ) -> (String, Self::ThinBuffer) {
-        back::lto::prepare_thin(module, emit_summary)
+    fn prepare_thin(module: ModuleCodegen<Self::Module>) -> (String, Self::ThinBuffer) {
+        back::lto::prepare_thin(module)
     }
     fn serialize_module(module: ModuleCodegen<Self::Module>) -> (String, Self::ModuleBuffer) {
         (module.name, back::lto::ModuleBuffer::new(module.module_llvm.llmod()))
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index b66fc157b3cb2..0679f55ab7f08 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -2602,7 +2602,6 @@ unsafe extern "C" {
     pub(crate) fn LLVMRustThinLTOBufferCreate(
         M: &Module,
         is_thin: bool,
-        emit_summary: bool,
     ) -> &'static mut ThinLTOBuffer;
     pub(crate) fn LLVMRustThinLTOBufferFree(M: &'static mut ThinLTOBuffer);
     pub(crate) fn LLVMRustThinLTOBufferPtr(M: &ThinLTOBuffer) -> *const c_char;
diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
index 95e02a7c6dbc8..365c2a0898095 100644
--- a/compiler/rustc_codegen_ssa/src/back/write.rs
+++ b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -862,7 +862,7 @@ fn execute_optimize_work_item<B: ExtraBackendMethods>(
             WorkItemResult::Finished(module)
         }
         ComputedLtoType::Thin => {
-            let (name, thin_buffer) = B::prepare_thin(module, false);
+            let (name, thin_buffer) = B::prepare_thin(module);
             if let Some(path) = bitcode {
                 fs::write(&path, thin_buffer.data()).unwrap_or_else(|e| {
                     panic!("Error writing pre-lto-bitcode file `{}`: {}", path.display(), e);
diff --git a/compiler/rustc_codegen_ssa/src/traits/write.rs b/compiler/rustc_codegen_ssa/src/traits/write.rs
index 40f546ebc92fd..1ac1d7ef2e2eb 100644
--- a/compiler/rustc_codegen_ssa/src/traits/write.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/write.rs
@@ -50,10 +50,7 @@ pub trait WriteBackendMethods: Clone + 'static {
         module: ModuleCodegen<Self::Module>,
         config: &ModuleConfig,
     ) -> CompiledModule;
-    fn prepare_thin(
-        module: ModuleCodegen<Self::Module>,
-        want_summary: bool,
-    ) -> (String, Self::ThinBuffer);
+    fn prepare_thin(module: ModuleCodegen<Self::Module>) -> (String, Self::ThinBuffer);
     fn serialize_module(module: ModuleCodegen<Self::Module>) -> (String, Self::ModuleBuffer);
 }
 
diff --git a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
index dd49232581497..3bb1533c2fe25 100644
--- a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
@@ -1568,12 +1568,11 @@ extern "C" bool LLVMRustPrepareThinLTOImport(const LLVMRustThinLTOData *Data,
   return true;
 }
 
-extern "C" LLVMRustThinLTOBuffer *
-LLVMRustThinLTOBufferCreate(LLVMModuleRef M, bool is_thin, bool emit_summary) {
+extern "C" LLVMRustThinLTOBuffer *LLVMRustThinLTOBufferCreate(LLVMModuleRef M,
+                                                              bool is_thin) {
   auto Ret = std::make_unique<LLVMRustThinLTOBuffer>();
   {
     auto OS = raw_string_ostream(Ret->data);
-    auto ThinLinkOS = raw_string_ostream(Ret->thin_link_data);
     {
       if (is_thin) {
         PassBuilder PB;
@@ -1587,11 +1586,7 @@ LLVMRustThinLTOBufferCreate(LLVMModuleRef M, bool is_thin, bool emit_summary) {
         PB.registerLoopAnalyses(LAM);
         PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
         ModulePassManager MPM;
-        // We only pass ThinLinkOS to be filled in if we want the summary,
-        // because otherwise LLVM does extra work and may double-emit some
-        // errors or warnings.
-        MPM.addPass(
-            ThinLTOBitcodeWriterPass(OS, emit_summary ? &ThinLinkOS : nullptr));
+        MPM.addPass(ThinLTOBitcodeWriterPass(OS, nullptr));
         MPM.run(*unwrap(M), MAM);
       } else {
         WriteBitcodeToFile(*unwrap(M), OS);

From 3a1ae064a71f7e265e1e24c75b26fe3cd7edd3b1 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Thu, 4 Sep 2025 09:27:12 +0000
Subject: [PATCH 0590/1889] Move timers into execute_*_work_item

---
 compiler/rustc_codegen_ssa/src/back/write.rs | 47 +++++++++-----------
 1 file changed, 20 insertions(+), 27 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
index 365c2a0898095..cbaf67d734547 100644
--- a/compiler/rustc_codegen_ssa/src/back/write.rs
+++ b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -830,6 +830,8 @@ fn execute_optimize_work_item<B: ExtraBackendMethods>(
     cgcx: &CodegenContext<B>,
     mut module: ModuleCodegen<B::Module>,
 ) -> WorkItemResult<B> {
+    let _timer = cgcx.prof.generic_activity_with_arg("codegen_module_optimize", &*module.name);
+
     let dcx = cgcx.create_dcx();
     let dcx = dcx.handle();
 
@@ -890,6 +892,10 @@ fn execute_copy_from_cache_work_item<B: ExtraBackendMethods>(
     cgcx: &CodegenContext<B>,
     module: CachedModuleCodegen,
 ) -> WorkItemResult<B> {
+    let _timer = cgcx
+        .prof
+        .generic_activity_with_arg("codegen_copy_artifacts_from_incr_cache", &*module.name);
+
     let incr_comp_session_dir = cgcx.incr_comp_session_dir.as_ref().unwrap();
 
     let mut links_from_incr_cache = Vec::new();
@@ -977,6 +983,8 @@ fn execute_fat_lto_work_item<B: ExtraBackendMethods>(
     mut needs_fat_lto: Vec<FatLtoInput<B>>,
     import_only_modules: Vec<(SerializedModule<B::ModuleBuffer>, WorkProduct)>,
 ) -> WorkItemResult<B> {
+    let _timer = cgcx.prof.generic_activity_with_arg("codegen_module_perform_lto", "everything");
+
     for (module, wp) in import_only_modules {
         needs_fat_lto.push(FatLtoInput::Serialized { name: wp.cgu_name, buffer: module })
     }
@@ -995,6 +1003,8 @@ fn execute_thin_lto_work_item<B: ExtraBackendMethods>(
     cgcx: &CodegenContext<B>,
     module: lto::ThinModule<B>,
 ) -> WorkItemResult<B> {
+    let _timer = cgcx.prof.generic_activity_with_arg("codegen_module_perform_lto", module.name());
+
     let module = B::optimize_thin(cgcx, module);
     let module = B::codegen(cgcx, module, &cgcx.module_config);
     WorkItemResult::Finished(module)
@@ -1714,38 +1724,21 @@ fn spawn_work<'a, B: ExtraBackendMethods>(
 
     B::spawn_named_thread(cgcx.time_trace, work.short_description(), move || {
         let result = std::panic::catch_unwind(AssertUnwindSafe(|| match work {
-            WorkItem::Optimize(m) => {
-                let _timer =
-                    cgcx.prof.generic_activity_with_arg("codegen_module_optimize", &*m.name);
-                execute_optimize_work_item(&cgcx, m)
-            }
-            WorkItem::CopyPostLtoArtifacts(m) => {
-                let _timer = cgcx
-                    .prof
-                    .generic_activity_with_arg("codegen_copy_artifacts_from_incr_cache", &*m.name);
-                execute_copy_from_cache_work_item(&cgcx, m)
-            }
+            WorkItem::Optimize(m) => execute_optimize_work_item(&cgcx, m),
+            WorkItem::CopyPostLtoArtifacts(m) => execute_copy_from_cache_work_item(&cgcx, m),
             WorkItem::FatLto {
                 exported_symbols_for_lto,
                 each_linked_rlib_for_lto,
                 needs_fat_lto,
                 import_only_modules,
-            } => {
-                let _timer =
-                    cgcx.prof.generic_activity_with_arg("codegen_module_perform_lto", "everything");
-                execute_fat_lto_work_item(
-                    &cgcx,
-                    &exported_symbols_for_lto,
-                    &each_linked_rlib_for_lto,
-                    needs_fat_lto,
-                    import_only_modules,
-                )
-            }
-            WorkItem::ThinLto(m) => {
-                let _timer =
-                    cgcx.prof.generic_activity_with_arg("codegen_module_perform_lto", m.name());
-                execute_thin_lto_work_item(&cgcx, m)
-            }
+            } => execute_fat_lto_work_item(
+                &cgcx,
+                &exported_symbols_for_lto,
+                &each_linked_rlib_for_lto,
+                needs_fat_lto,
+                import_only_modules,
+            ),
+            WorkItem::ThinLto(m) => execute_thin_lto_work_item(&cgcx, m),
         }));
 
         let msg = match result {

From dcc342f449da8d0f2899ef6b6435ace57658e709 Mon Sep 17 00:00:00 2001
From: LorrensP-2158466 <lorrens.pantelis@student.uhasselt.be>
Date: Mon, 7 Jul 2025 15:16:59 +0200
Subject: [PATCH 0591/1889] Implement nondet behaviour and change/add tests.

---
 src/tools/miri/src/intrinsics/mod.rs      |   7 +-
 src/tools/miri/src/math.rs                | 173 +++++++++++++++---
 src/tools/miri/src/shims/foreign_items.rs | 210 ++++++++++++----------
 src/tools/miri/tests/pass/float.rs        | 154 +++++++++++-----
 4 files changed, 375 insertions(+), 169 deletions(-)

diff --git a/src/tools/miri/src/intrinsics/mod.rs b/src/tools/miri/src/intrinsics/mod.rs
index 8bcec4e7cbe30..4628c30e2dfbe 100644
--- a/src/tools/miri/src/intrinsics/mod.rs
+++ b/src/tools/miri/src/intrinsics/mod.rs
@@ -13,7 +13,6 @@ use rustc_span::{Symbol, sym};
 use self::atomic::EvalContextExt as _;
 use self::helpers::{ToHost, ToSoft};
 use self::simd::EvalContextExt as _;
-use crate::math::apply_random_float_error_ulp;
 use crate::*;
 
 /// Check that the number of args is what we expect.
@@ -362,13 +361,13 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 let f = this.read_scalar(f)?.to_f32()?;
                 let i = this.read_scalar(i)?.to_i32()?;
 
-                let res = math::fixed_powi_float_value(this, f, i).unwrap_or_else(|| {
+                let res = math::fixed_powi_value(this, f, i).unwrap_or_else(|| {
                     // Using host floats (but it's fine, this operation does not have guaranteed precision).
                     let res = f.to_host().powi(i).to_soft();
 
                     // Apply a relative error of 4ULP to introduce some non-determinism
                     // simulating imprecise implementations and optimizations.
-                    apply_random_float_error_ulp(this, res, 4)
+                    math::apply_random_float_error_ulp(this, res, 4)
                 });
                 let res = this.adjust_nan(res, &[f]);
                 this.write_scalar(res, dest)?;
@@ -378,7 +377,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 let f = this.read_scalar(f)?.to_f64()?;
                 let i = this.read_scalar(i)?.to_i32()?;
 
-                let res = math::fixed_powi_float_value(this, f, i).unwrap_or_else(|| {
+                let res = math::fixed_powi_value(this, f, i).unwrap_or_else(|| {
                     // Using host floats (but it's fine, this operation does not have guaranteed precision).
                     let res = f.to_host().powi(i).to_soft();
 
diff --git a/src/tools/miri/src/math.rs b/src/tools/miri/src/math.rs
index dc1541b43dfc6..7d2f1c083687c 100644
--- a/src/tools/miri/src/math.rs
+++ b/src/tools/miri/src/math.rs
@@ -1,8 +1,9 @@
 use std::ops::Neg;
+use std::{f32, f64};
 
 use rand::Rng as _;
 use rustc_apfloat::Float as _;
-use rustc_apfloat::ieee::{IeeeFloat, Semantics};
+use rustc_apfloat::ieee::{DoubleS, IeeeFloat, Semantics, SingleS};
 use rustc_middle::ty::{self, FloatTy, ScalarInt};
 
 use crate::*;
@@ -107,29 +108,69 @@ pub(crate) fn apply_random_float_error_to_imm<'tcx>(
     interp_ok(ImmTy::from_scalar_int(res, val.layout))
 }
 
-/// Given an floating-point operation and a floating-point value, clamps the result to the output
-/// range of the given operation.
+/// Given a floating-point operation and a floating-point value, clamps the result to the output
+/// range of the given operation according to the C standard, if any.
 pub(crate) fn clamp_float_value<S: Semantics>(
     intrinsic_name: &str,
     val: IeeeFloat<S>,
-) -> IeeeFloat<S> {
+) -> IeeeFloat<S>
+where
+    IeeeFloat<S>: IeeeExt,
+{
+    let zero = IeeeFloat::<S>::ZERO;
+    let one = IeeeFloat::<S>::one();
+    let two = IeeeFloat::<S>::two();
+    let pi = IeeeFloat::<S>::pi();
+    let pi_over_2 = (pi / two).value;
+
     match intrinsic_name {
-        // sin and cos: [-1, 1]
-        "sinf32" | "cosf32" | "sinf64" | "cosf64" =>
-            val.clamp(IeeeFloat::<S>::one().neg(), IeeeFloat::<S>::one()),
-        // exp: [0, +INF]
-        "expf32" | "exp2f32" | "expf64" | "exp2f64" =>
-            IeeeFloat::<S>::maximum(val, IeeeFloat::<S>::ZERO),
+        // sin, cos, tanh: [-1, 1]
+        #[rustfmt::skip]
+        | "sinf32"
+        | "sinf64"
+        | "cosf32"
+        | "cosf64"
+        | "tanhf"
+        | "tanh"
+         => val.clamp(one.neg(), one),
+
+        // exp: [0, +INF)
+        "expf32" | "exp2f32" | "expf64" | "exp2f64" => val.maximum(zero),
+
+        // cosh: [1, +INF)
+        "coshf" | "cosh" => val.maximum(one),
+
+        // acos: [0, π]
+        "acosf" | "acos" => val.clamp(zero, pi),
+
+        // asin: [-π, +π]
+        "asinf" | "asin" => val.clamp(pi.neg(), pi),
+
+        // atan: (-π/2, +π/2)
+        "atanf" | "atan" => val.clamp(pi_over_2.neg(), pi_over_2),
+
+        // erfc: (-1, 1)
+        "erff" | "erf" => val.clamp(one.neg(), one),
+
+        // erfc: (0, 2)
+        "erfcf" | "erfc" => val.clamp(zero, two),
+
+        // atan2(y, x): arctan(y/x) in [−π, +π]
+        "atan2f" | "atan2" => val.clamp(pi.neg(), pi),
+
         _ => val,
     }
 }
 
 /// For the intrinsics:
-/// - sinf32, sinf64
-/// - cosf32, cosf64
+/// - sinf32, sinf64, sinhf, sinh
+/// - cosf32, cosf64, coshf, cosh
+/// - tanhf, tanh, atanf, atan, atan2f, atan2
 /// - expf32, expf64, exp2f32, exp2f64
 /// - logf32, logf64, log2f32, log2f64, log10f32, log10f64
 /// - powf32, powf64
+/// - erff, erf, erfcf, erfc
+/// - hypotf, hypot
 ///
 /// # Return
 ///
@@ -157,16 +198,68 @@ pub(crate) fn fixed_float_value<S: Semantics>(
     ecx: &mut MiriInterpCx<'_>,
     intrinsic_name: &str,
     args: &[IeeeFloat<S>],
-) -> Option<IeeeFloat<S>> {
+) -> Option<IeeeFloat<S>>
+where
+    IeeeFloat<S>: IeeeExt,
+{
     let this = ecx.eval_context_mut();
     let one = IeeeFloat::<S>::one();
+    let two = IeeeFloat::<S>::two();
+    let three = IeeeFloat::<S>::three();
+    let pi = IeeeFloat::<S>::pi();
+    let pi_over_2 = (pi / two).value;
+    let pi_over_4 = (pi_over_2 / two).value;
+
     Some(match (intrinsic_name, args) {
-        // cos(+- 0) = 1
-        ("cosf32" | "cosf64", [input]) if input.is_zero() => one,
+        // cos(±0) and cosh(±0)= 1
+        ("cosf32" | "cosf64" | "coshf" | "cosh", [input]) if input.is_zero() => one,
 
         // e^0 = 1
         ("expf32" | "expf64" | "exp2f32" | "exp2f64", [input]) if input.is_zero() => one,
 
+        // tanh(±INF) = ±1
+        ("tanhf" | "tanh", [input]) if input.is_infinite() => one.copy_sign(*input),
+
+        // atan(±INF) = ±π/2
+        ("atanf" | "atan", [input]) if input.is_infinite() => pi_over_2.copy_sign(*input),
+
+        // erf(±INF) = ±1
+        ("erff" | "erf", [input]) if input.is_infinite() => one.copy_sign(*input),
+
+        // erfc(-INF) = 2
+        ("erfcf" | "erfc", [input]) if input.is_neg_infinity() => (one + one).value,
+
+        // hypot(x, ±0) = abs(x), if x is not a NaN.
+        ("_hypotf" | "hypotf" | "_hypot" | "hypot", [x, y]) if !x.is_nan() && y.is_zero() =>
+            x.abs(),
+
+        // atan2(±0,−0) = ±π.
+        // atan2(±0, y) = ±π for y < 0.
+        // Must check for non NaN because `y.is_negative()` also applies to NaN.
+        ("atan2f" | "atan2", [x, y]) if (x.is_zero() && (y.is_negative() && !y.is_nan())) =>
+            pi.copy_sign(*x),
+
+        // atan2(±x,−∞) = ±π for finite x > 0.
+        ("atan2f" | "atan2", [x, y])
+            if (!x.is_zero() && !x.is_infinite()) && y.is_neg_infinity() =>
+            pi.copy_sign(*x),
+
+        // atan2(x, ±0) = −π/2 for x < 0.
+        // atan2(x, ±0) =  π/2 for x > 0.
+        ("atan2f" | "atan2", [x, y]) if !x.is_zero() && y.is_zero() => pi_over_2.copy_sign(*x),
+
+        //atan2(±∞, −∞) = ±3π/4
+        ("atan2f" | "atan2", [x, y]) if x.is_infinite() && y.is_neg_infinity() =>
+            (pi_over_4 * three).value.copy_sign(*x),
+
+        //atan2(±∞, +∞) = ±π/4
+        ("atan2f" | "atan2", [x, y]) if x.is_infinite() && y.is_pos_infinity() =>
+            pi_over_4.copy_sign(*x),
+
+        // atan2(±∞, y) returns ±π/2 for finite y.
+        ("atan2f" | "atan2", [x, y]) if x.is_infinite() && (!y.is_infinite() && !y.is_nan()) =>
+            pi_over_2.copy_sign(*x),
+
         // (-1)^(±INF) = 1
         ("powf32" | "powf64", [base, exp]) if *base == -one && exp.is_infinite() => one,
 
@@ -196,25 +289,27 @@ pub(crate) fn fixed_float_value<S: Semantics>(
 
 /// Returns `Some(output)` if `powi` (called `pown` in C) results in a fixed value specified in the
 /// C standard (specifically, C23 annex F.10.4.6) when doing `base^exp`. Otherwise, returns `None`.
-pub(crate) fn fixed_powi_float_value<S: Semantics>(
+pub(crate) fn fixed_powi_value<S: Semantics>(
     ecx: &mut MiriInterpCx<'_>,
     base: IeeeFloat<S>,
     exp: i32,
-) -> Option<IeeeFloat<S>> {
-    let this = ecx.eval_context_mut();
-    Some(match exp {
+) -> Option<IeeeFloat<S>>
+where
+    IeeeFloat<S>: IeeeExt,
+{
+    match exp {
         0 => {
             let one = IeeeFloat::<S>::one();
-            let rng = this.machine.rng.get_mut();
-            let return_nan = this.machine.float_nondet && rng.random() && base.is_signaling();
+            let rng = ecx.machine.rng.get_mut();
+            let return_nan = ecx.machine.float_nondet && rng.random() && base.is_signaling();
             // For SNaN treatment, we are consistent with `powf`above.
             // (We wouldn't have two, unlike powf all implementations seem to agree for powi,
             // but for now we are maximally conservative.)
-            if return_nan { this.generate_nan(&[base]) } else { one }
+            Some(if return_nan { ecx.generate_nan(&[base]) } else { one })
         }
 
         _ => return None,
-    })
+    }
 }
 
 pub(crate) fn sqrt<S: rustc_apfloat::ieee::Semantics>(x: IeeeFloat<S>) -> IeeeFloat<S> {
@@ -299,19 +394,47 @@ pub(crate) fn sqrt<S: rustc_apfloat::ieee::Semantics>(x: IeeeFloat<S>) -> IeeeFl
     }
 }
 
-/// Extend functionality of rustc_apfloat softfloats
+/// Extend functionality of `rustc_apfloat` softfloats for IEEE float types.
 pub trait IeeeExt: rustc_apfloat::Float {
+    // Some values we use:
+
     #[inline]
     fn one() -> Self {
         Self::from_u128(1).value
     }
 
+    #[inline]
+    fn two() -> Self {
+        Self::from_u128(2).value
+    }
+
+    #[inline]
+    fn three() -> Self {
+        Self::from_u128(3).value
+    }
+
+    fn pi() -> Self;
+
     #[inline]
     fn clamp(self, min: Self, max: Self) -> Self {
         self.maximum(min).minimum(max)
     }
 }
-impl<S: rustc_apfloat::ieee::Semantics> IeeeExt for IeeeFloat<S> {}
+
+macro_rules! impl_ieee_pi {
+    ($float_ty:ident, $semantic:ty) => {
+        impl IeeeExt for IeeeFloat<$semantic> {
+            #[inline]
+            fn pi() -> Self {
+                // We take the value from the standard library as the most reasonable source for an exact π here.
+                Self::from_bits($float_ty::consts::PI.to_bits().into())
+            }
+        }
+    };
+}
+
+impl_ieee_pi!(f32, SingleS);
+impl_ieee_pi!(f64, DoubleS);
 
 #[cfg(test)]
 mod tests {
diff --git a/src/tools/miri/src/shims/foreign_items.rs b/src/tools/miri/src/shims/foreign_items.rs
index a700644b95d82..187423472ab8c 100644
--- a/src/tools/miri/src/shims/foreign_items.rs
+++ b/src/tools/miri/src/shims/foreign_items.rs
@@ -18,6 +18,7 @@ use rustc_target::callconv::FnAbi;
 use self::helpers::{ToHost, ToSoft};
 use super::alloc::EvalContextExt as _;
 use super::backtrace::EvalContextExt as _;
+use crate::helpers::EvalContextExt as _;
 use crate::*;
 
 /// Type of dynamic symbols (for `dlsym` et al)
@@ -826,33 +827,36 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
             => {
                 let [f] = this.check_shim_sig_lenient(abi, CanonAbi::C , link_name, args)?;
                 let f = this.read_scalar(f)?.to_f32()?;
-                // Using host floats (but it's fine, these operations do not have guaranteed precision).
-                let f_host = f.to_host();
-                let res = match link_name.as_str() {
-                    "cbrtf" => f_host.cbrt(),
-                    "coshf" => f_host.cosh(),
-                    "sinhf" => f_host.sinh(),
-                    "tanf" => f_host.tan(),
-                    "tanhf" => f_host.tanh(),
-                    "acosf" => f_host.acos(),
-                    "asinf" => f_host.asin(),
-                    "atanf" => f_host.atan(),
-                    "log1pf" => f_host.ln_1p(),
-                    "expm1f" => f_host.exp_m1(),
-                    "tgammaf" => f_host.gamma(),
-                    "erff" => f_host.erf(),
-                    "erfcf" => f_host.erfc(),
-                    _ => bug!(),
-                };
-                let res = res.to_soft();
-                // Apply a relative error of 16ULP to introduce some non-determinism
-                // simulating imprecise implementations and optimizations.
-                // FIXME: temporarily disabled as it breaks std tests.
-                // let res = math::apply_random_float_error_ulp(
-                //     this,
-                //     res,
-                //     4, // log2(16)
-                // );
+
+                let res = math::fixed_float_value(this, link_name.as_str(), &[f]).unwrap_or_else(|| {
+                    // Using host floats (but it's fine, these operations do not have
+                    // guaranteed precision).
+                    let f_host = f.to_host();
+                    let res = match link_name.as_str() {
+                        "cbrtf" => f_host.cbrt(),
+                        "coshf" => f_host.cosh(),
+                        "sinhf" => f_host.sinh(),
+                        "tanf" => f_host.tan(),
+                        "tanhf" => f_host.tanh(),
+                        "acosf" => f_host.acos(),
+                        "asinf" => f_host.asin(),
+                        "atanf" => f_host.atan(),
+                        "log1pf" => f_host.ln_1p(),
+                        "expm1f" => f_host.exp_m1(),
+                        "tgammaf" => f_host.gamma(),
+                        "erff" => f_host.erf(),
+                        "erfcf" => f_host.erfc(),
+                        _ => bug!(),
+                    };
+                    let res = res.to_soft();
+                    // Apply a relative error of 4ULP to introduce some non-determinism
+                    // simulating imprecise implementations and optimizations.
+                    let res = math::apply_random_float_error_ulp(this, res, 4);
+
+                    // Clamp the result to the guaranteed range of this function according to the C standard,
+                    // if any.
+                    math::clamp_float_value(link_name.as_str(), res)
+                });
                 let res = this.adjust_nan(res, &[f]);
                 this.write_scalar(res, dest)?;
             }
@@ -865,24 +869,27 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 let [f1, f2] = this.check_shim_sig_lenient(abi, CanonAbi::C , link_name, args)?;
                 let f1 = this.read_scalar(f1)?.to_f32()?;
                 let f2 = this.read_scalar(f2)?.to_f32()?;
-                // underscore case for windows, here and below
-                // (see https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/floating-point-primitives?view=vs-2019)
-                // Using host floats (but it's fine, these operations do not have guaranteed precision).
-                let res = match link_name.as_str() {
-                    "_hypotf" | "hypotf" => f1.to_host().hypot(f2.to_host()).to_soft(),
-                    "atan2f" => f1.to_host().atan2(f2.to_host()).to_soft(),
-                    #[allow(deprecated)]
-                    "fdimf" => f1.to_host().abs_sub(f2.to_host()).to_soft(),
-                    _ => bug!(),
-                };
-                // Apply a relative error of 16ULP to introduce some non-determinism
-                // simulating imprecise implementations and optimizations.
-                // FIXME: temporarily disabled as it breaks std tests.
-                // let res = math::apply_random_float_error_ulp(
-                //     this,
-                //     res,
-                //     4, // log2(16)
-                // );
+
+                let res = math::fixed_float_value(this, link_name.as_str(), &[f1, f2])
+                    .unwrap_or_else(|| {
+                        let res = match link_name.as_str() {
+                            // underscore case for windows, here and below
+                            // (see https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/floating-point-primitives?view=vs-2019)
+                            // Using host floats (but it's fine, these operations do not have guaranteed precision).
+                            "_hypotf" | "hypotf" => f1.to_host().hypot(f2.to_host()).to_soft(),
+                            "atan2f" => f1.to_host().atan2(f2.to_host()).to_soft(),
+                            #[allow(deprecated)]
+                            "fdimf" => f1.to_host().abs_sub(f2.to_host()).to_soft(),
+                            _ => bug!(),
+                        };
+                        // Apply a relative error of 4ULP to introduce some non-determinism
+                        // simulating imprecise implementations and optimizations.
+                        let res = math::apply_random_float_error_ulp(this, res, 4);
+
+                        // Clamp the result to the guaranteed range of this function according to the C standard,
+                        // if any.
+                        math::clamp_float_value(link_name.as_str(), res)
+                    });
                 let res = this.adjust_nan(res, &[f1, f2]);
                 this.write_scalar(res, dest)?;
             }
@@ -903,33 +910,36 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
             => {
                 let [f] = this.check_shim_sig_lenient(abi, CanonAbi::C , link_name, args)?;
                 let f = this.read_scalar(f)?.to_f64()?;
-                // Using host floats (but it's fine, these operations do not have guaranteed precision).
-                let f_host = f.to_host();
-                let res = match link_name.as_str() {
-                    "cbrt" => f_host.cbrt(),
-                    "cosh" => f_host.cosh(),
-                    "sinh" => f_host.sinh(),
-                    "tan" => f_host.tan(),
-                    "tanh" => f_host.tanh(),
-                    "acos" => f_host.acos(),
-                    "asin" => f_host.asin(),
-                    "atan" => f_host.atan(),
-                    "log1p" => f_host.ln_1p(),
-                    "expm1" => f_host.exp_m1(),
-                    "tgamma" => f_host.gamma(),
-                    "erf" => f_host.erf(),
-                    "erfc" => f_host.erfc(),
-                    _ => bug!(),
-                };
-                let res = res.to_soft();
-                // Apply a relative error of 16ULP to introduce some non-determinism
-                // simulating imprecise implementations and optimizations.
-                // FIXME: temporarily disabled as it breaks std tests.
-                // let res = math::apply_random_float_error_ulp(
-                //     this,
-                //     res.to_soft(),
-                //     4, // log2(16)
-                // );
+
+                let res = math::fixed_float_value(this, link_name.as_str(), &[f]).unwrap_or_else(|| {
+                    // Using host floats (but it's fine, these operations do not have
+                    // guaranteed precision).
+                    let f_host = f.to_host();
+                    let res = match link_name.as_str() {
+                        "cbrt" => f_host.cbrt(),
+                        "cosh" => f_host.cosh(),
+                        "sinh" => f_host.sinh(),
+                        "tan" => f_host.tan(),
+                        "tanh" => f_host.tanh(),
+                        "acos" => f_host.acos(),
+                        "asin" => f_host.asin(),
+                        "atan" => f_host.atan(),
+                        "log1p" => f_host.ln_1p(),
+                        "expm1" => f_host.exp_m1(),
+                        "tgamma" => f_host.gamma(),
+                        "erf" => f_host.erf(),
+                        "erfc" => f_host.erfc(),
+                        _ => bug!(),
+                    };
+                    let res = res.to_soft();
+                    // Apply a relative error of 4ULP to introduce some non-determinism
+                    // simulating imprecise implementations and optimizations.
+                    let res = math::apply_random_float_error_ulp(this, res, 4);
+
+                    // Clamp the result to the guaranteed range of this function according to the C standard,
+                    // if any.
+                    math::clamp_float_value(link_name.as_str(), res)
+                });
                 let res = this.adjust_nan(res, &[f]);
                 this.write_scalar(res, dest)?;
             }
@@ -942,24 +952,26 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 let [f1, f2] = this.check_shim_sig_lenient(abi, CanonAbi::C , link_name, args)?;
                 let f1 = this.read_scalar(f1)?.to_f64()?;
                 let f2 = this.read_scalar(f2)?.to_f64()?;
-                // underscore case for windows, here and below
-                // (see https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/floating-point-primitives?view=vs-2019)
-                // Using host floats (but it's fine, these operations do not have guaranteed precision).
-                let res = match link_name.as_str() {
-                    "_hypot" | "hypot" => f1.to_host().hypot(f2.to_host()).to_soft(),
-                    "atan2" => f1.to_host().atan2(f2.to_host()).to_soft(),
-                    #[allow(deprecated)]
-                    "fdim" => f1.to_host().abs_sub(f2.to_host()).to_soft(),
-                    _ => bug!(),
-                };
-                // Apply a relative error of 16ULP to introduce some non-determinism
-                // simulating imprecise implementations and optimizations.
-                // FIXME: temporarily disabled as it breaks std tests.
-                // let res = math::apply_random_float_error_ulp(
-                //     this,
-                //     res,
-                //     4, // log2(16)
-                // );
+
+                let res = math::fixed_float_value(this, link_name.as_str(), &[f1, f2]).unwrap_or_else(|| {
+                    let res = match link_name.as_str() {
+                        // underscore case for windows, here and below
+                        // (see https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/floating-point-primitives?view=vs-2019)
+                        // Using host floats (but it's fine, these operations do not have guaranteed precision).
+                        "_hypot" | "hypot" => f1.to_host().hypot(f2.to_host()).to_soft(),
+                        "atan2" => f1.to_host().atan2(f2.to_host()).to_soft(),
+                        #[allow(deprecated)]
+                        "fdim" => f1.to_host().abs_sub(f2.to_host()).to_soft(),
+                        _ => bug!(),
+                    };
+                    // Apply a relative error of 4ULP to introduce some non-determinism
+                    // simulating imprecise implementations and optimizations.
+                    let res = math::apply_random_float_error_ulp(this, res, 4);
+
+                    // Clamp the result to the guaranteed range of this function according to the C standard,
+                    // if any.
+                    math::clamp_float_value(link_name.as_str(), res)
+                });
                 let res = this.adjust_nan(res, &[f1, f2]);
                 this.write_scalar(res, dest)?;
             }
@@ -985,11 +997,14 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 // Using host floats (but it's fine, these operations do not have guaranteed precision).
                 let (res, sign) = x.to_host().ln_gamma();
                 this.write_int(sign, &signp)?;
+
                 let res = res.to_soft();
-                // Apply a relative error of 16ULP to introduce some non-determinism
+                // Apply a relative error of 4ULP to introduce some non-determinism
                 // simulating imprecise implementations and optimizations.
-                // FIXME: temporarily disabled as it breaks std tests.
-                // let res = math::apply_random_float_error_ulp(this, res, 4 /* log2(16) */);
+                let res = math::apply_random_float_error_ulp(this, res, 4);
+                // Clamp the result to the guaranteed range of this function according to the C standard,
+                // if any.
+                let res = math::clamp_float_value(link_name.as_str(), res);
                 let res = this.adjust_nan(res, &[x]);
                 this.write_scalar(res, dest)?;
             }
@@ -1001,11 +1016,14 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 // Using host floats (but it's fine, these operations do not have guaranteed precision).
                 let (res, sign) = x.to_host().ln_gamma();
                 this.write_int(sign, &signp)?;
+
                 let res = res.to_soft();
-                // Apply a relative error of 16ULP to introduce some non-determinism
+                // Apply a relative error of 4ULP to introduce some non-determinism
                 // simulating imprecise implementations and optimizations.
-                // FIXME: temporarily disabled as it breaks std tests.
-                // let res = math::apply_random_float_error_ulp(this, res, 4 /* log2(16) */);
+                let res = math::apply_random_float_error_ulp(this, res, 4);
+                // Clamp the result to the guaranteed range of this function according to the C standard,
+                // if any.
+                let res = math::clamp_float_value(link_name.as_str(), res);
                 let res = this.adjust_nan(res, &[x]);
                 this.write_scalar(res, dest)?;
             }
diff --git a/src/tools/miri/tests/pass/float.rs b/src/tools/miri/tests/pass/float.rs
index 1b1163c77978e..d6e1b2a83d936 100644
--- a/src/tools/miri/tests/pass/float.rs
+++ b/src/tools/miri/tests/pass/float.rs
@@ -1093,6 +1093,8 @@ pub fn libm() {
 
     assert_approx_eq!(1f32.exp_m1(), f32::consts::E - 1.0);
     assert_approx_eq!(1f64.exp_m1(), f64::consts::E - 1.0);
+    assert_approx_eq!(f32::NEG_INFINITY.exp_m1(), -1.0);
+    assert_approx_eq!(f64::NEG_INFINITY.exp_m1(), -1.0);
 
     assert_approx_eq!(10f32.exp2(), 1024f32);
     assert_approx_eq!(50f64.exp2(), 1125899906842624f64);
@@ -1128,6 +1130,7 @@ pub fn libm() {
     assert_eq!(ldexp(0.65f64, 3i32), 5.2f64);
     assert_eq!(ldexp(1.42, 0xFFFF), f64::INFINITY);
     assert_eq!(ldexp(1.42, -0xFFFF), 0f64);
+    assert_eq!(ldexp(42.0, 0), 42.0);
 
     // Trigonometric functions.
 
@@ -1136,8 +1139,14 @@ pub fn libm() {
     assert_approx_eq!((f64::consts::PI / 2f64).sin(), 1f64);
     assert_approx_eq!(f32::consts::FRAC_PI_6.sin(), 0.5);
     assert_approx_eq!(f64::consts::FRAC_PI_6.sin(), 0.5);
-    assert_approx_eq!(f32::consts::FRAC_PI_4.sin().asin(), f32::consts::FRAC_PI_4);
-    assert_approx_eq!(f64::consts::FRAC_PI_4.sin().asin(), f64::consts::FRAC_PI_4);
+    // Increase error tolerance from 12ULP to 16ULP because of the extra operation.
+    assert_approx_eq!(f32::consts::FRAC_PI_4.sin().asin(), f32::consts::FRAC_PI_4, 16);
+    assert_approx_eq!(f64::consts::FRAC_PI_4.sin().asin(), f64::consts::FRAC_PI_4, 16);
+    assert_biteq(0.0f32.asin(), 0.0f32, "asin(+0) = +0");
+    assert_biteq((-0.0f32).asin(), -0.0, "asin(-0) = -0");
+    assert_biteq(0.0f64.asin(), 0.0, "asin(+0) = +0");
+    assert_biteq((-0.0f64).asin(), -0.0, "asin(-0) = -0");
+
 
     assert_approx_eq!(1.0f32.sinh(), 1.1752012f32);
     assert_approx_eq!(1.0f64.sinh(), 1.1752011936438014f64);
@@ -1164,11 +1173,18 @@ pub fn libm() {
     assert_approx_eq!((f64::consts::PI * 2f64).cos(), 1f64);
     assert_approx_eq!(f32::consts::FRAC_PI_3.cos(), 0.5);
     assert_approx_eq!(f64::consts::FRAC_PI_3.cos(), 0.5);
-    assert_approx_eq!(f32::consts::FRAC_PI_4.cos().acos(), f32::consts::FRAC_PI_4);
-    assert_approx_eq!(f64::consts::FRAC_PI_4.cos().acos(), f64::consts::FRAC_PI_4);
+    // Increase error tolerance from 12ULP to 16ULP because of the extra operation.
+    assert_approx_eq!(f32::consts::FRAC_PI_4.cos().acos(), f32::consts::FRAC_PI_4, 16);
+    assert_approx_eq!(f64::consts::FRAC_PI_4.cos().acos(), f64::consts::FRAC_PI_4, 16);
+    assert_biteq(1.0f32.acos(), 0.0, "acos(1) = 0");
+    assert_biteq(1.0f64.acos(), 0.0, "acos(1) = 0");
 
     assert_approx_eq!(1.0f32.cosh(), 1.54308f32);
     assert_approx_eq!(1.0f64.cosh(), 1.5430806348152437f64);
+    assert_eq!(0.0f32.cosh(), 1.0);
+    assert_eq!(0.0f64.cosh(), 1.0);
+    assert_eq!((-0.0f32).cosh(), 1.0);
+    assert_eq!((-0.0f64).cosh(), 1.0);
     assert_approx_eq!(2.0f32.acosh(), 1.31695789692481670862504634730796844f32);
     assert_approx_eq!(3.0f64.acosh(), 1.76274717403908605046521864995958461f64);
 
@@ -1178,6 +1194,47 @@ pub fn libm() {
     assert_approx_eq!(1.0_f64, 1.0_f64.tan().atan());
     assert_approx_eq!(1.0f32.atan2(2.0f32), 0.46364761f32);
     assert_approx_eq!(1.0f32.atan2(2.0f32), 0.46364761f32);
+    // C standard defines a bunch of fixed outputs for atan2
+    macro_rules! fixed_atan2_cases{
+        ($float_type:ident) => {{
+            use std::$float_type::consts::{PI, FRAC_PI_2, FRAC_PI_4};
+            use $float_type::{INFINITY, NEG_INFINITY};
+
+            // atan2(±0,−0) = ±π.
+            assert_eq!($float_type::atan2(0.0, -0.0), PI, "atan2(0,−0) = π");
+            assert_eq!($float_type::atan2(-0.0, -0.0), -PI, "atan2(-0,−0) = -π");
+
+            // atan2(±0, y) = ±π for y < 0.
+            assert_eq!($float_type::atan2(0.0, -1.0), PI, "atan2(0, y) = π for y < 0.");
+            assert_eq!($float_type::atan2(-0.0, -1.0), -PI, "atan2(-0, y) = -π for y < 0.");
+
+            // atan2(x, ±0) = −π/2 for x < 0.
+            assert_eq!($float_type::atan2(-1.0, 0.0), -FRAC_PI_2, "atan2(x, 0) = −π/2 for x < 0");
+            assert_eq!($float_type::atan2(-1.0, -0.0), -FRAC_PI_2, "atan2(x, -0) = −π/2 for x < 0");
+
+            // atan2(x, ±0) =  π/2 for x > 0.
+            assert_eq!($float_type::atan2(1.0, 0.0), FRAC_PI_2, "atan2(x, 0) =  π/2 for x > 0.");
+            assert_eq!($float_type::atan2(1.0, -0.0), FRAC_PI_2, "atan2(x, -0) =  π/2 for x > 0.");
+
+            // atan2(±x,−∞) = ±π for finite x > 0.
+            assert_eq!($float_type::atan2(1.0, NEG_INFINITY), PI, "atan2(x, −∞) = π for finite x > 0");
+            assert_eq!($float_type::atan2(-1.0, NEG_INFINITY), -PI, "atan2(-x, −∞) = -π for finite x > 0");
+
+            // atan2(±∞, y) returns ±π/2 for finite y.
+            assert_eq!($float_type::atan2(INFINITY, 1.0), FRAC_PI_2, "atan2(+∞, y) returns π/2 for finite y");
+            assert_eq!($float_type::atan2(NEG_INFINITY, 1.0), -FRAC_PI_2, "atan2(-∞, y) returns -π/2 for finite y");
+
+            // atan2(±∞, −∞) = ±3π/4
+            assert_eq!($float_type::atan2(INFINITY, NEG_INFINITY), 3.0 * FRAC_PI_4, "atan2(+∞, −∞) = 3π/4");
+            assert_eq!($float_type::atan2(NEG_INFINITY, NEG_INFINITY), -3.0 * FRAC_PI_4, "atan2(-∞, −∞) = -3π/4");
+
+            // atan2(±∞, +∞) = ±π/4
+            assert_eq!($float_type::atan2(INFINITY, INFINITY), FRAC_PI_4, "atan2(+∞, +∞) = π/4");
+            assert_eq!($float_type::atan2(NEG_INFINITY, INFINITY), -FRAC_PI_4, "atan2(-∞, +∞) = -π/4");
+        }}
+    }
+    fixed_atan2_cases!(f32);
+    fixed_atan2_cases!(f64);
 
     assert_approx_eq!(
         1.0f32.tanh(),
@@ -1187,6 +1244,11 @@ pub fn libm() {
         1.0f64.tanh(),
         (1.0 - f64::consts::E.powi(-2)) / (1.0 + f64::consts::E.powi(-2))
     );
+    assert_eq!(f32::INFINITY.tanh(), 1.0);
+    assert_eq!(f32::NEG_INFINITY.tanh(), -1.0);
+    assert_eq!(f64::INFINITY.tanh(), 1.0);
+    assert_eq!(f64::NEG_INFINITY.tanh(), -1.0);
+
     assert_approx_eq!(0.5f32.atanh(), 0.54930614433405484569762261846126285f32);
     assert_approx_eq!(0.5f64.atanh(), 0.54930614433405484569762261846126285f64);
 
@@ -1207,8 +1269,14 @@ pub fn libm() {
 
     assert_approx_eq!(1.0f32.erf(), 0.84270079294971486934122063508260926f32);
     assert_approx_eq!(1.0f64.erf(), 0.84270079294971486934122063508260926f64);
+    assert_eq!(f32::INFINITY.erf(), 1.0);
+    assert_eq!(f64::INFINITY.erf(), 1.0);
     assert_approx_eq!(1.0f32.erfc(), 0.15729920705028513065877936491739074f32);
     assert_approx_eq!(1.0f64.erfc(), 0.15729920705028513065877936491739074f64);
+    assert_eq!(f32::NEG_INFINITY.erfc(), 2.0);
+    assert_eq!(f64::NEG_INFINITY.erfc(), 2.0);
+    assert_eq!(f32::INFINITY.erfc(), 0.0);
+    assert_eq!(f64::INFINITY.erfc(), 0.0);
 }
 
 fn test_fast() {
@@ -1418,7 +1486,6 @@ fn test_non_determinism() {
     }
     pub fn test_operations_f32(a: f32, b: f32) {
         test_operations_f!(a, b);
-        // FIXME: some are temporarily disabled as it breaks std tests.
         ensure_nondet(|| a.powf(b));
         ensure_nondet(|| a.powi(2));
         ensure_nondet(|| a.log(b));
@@ -1427,35 +1494,34 @@ fn test_non_determinism() {
         ensure_nondet(|| f32::consts::E.ln());
         ensure_nondet(|| 10f32.log10());
         ensure_nondet(|| 8f32.log2());
-        // ensure_nondet(|| 1f32.ln_1p());
-        // ensure_nondet(|| 27.0f32.cbrt());
-        // ensure_nondet(|| 3.0f32.hypot(4.0f32));
+        ensure_nondet(|| 1f32.ln_1p());
+        ensure_nondet(|| 27.0f32.cbrt());
+        ensure_nondet(|| 3.0f32.hypot(4.0f32));
         ensure_nondet(|| 1f32.sin());
         ensure_nondet(|| 1f32.cos());
         // On i686-pc-windows-msvc , these functions are implemented by calling the `f64` version,
         // which means the little rounding errors Miri introduces are discarded by the cast down to
         // `f32`. Just skip the test for them.
-        // if !cfg!(all(target_os = "windows", target_env = "msvc", target_arch = "x86")) {
-        //     ensure_nondet(|| 1.0f32.tan());
-        //     ensure_nondet(|| 1.0f32.asin());
-        //     ensure_nondet(|| 5.0f32.acos());
-        //     ensure_nondet(|| 1.0f32.atan());
-        //     ensure_nondet(|| 1.0f32.atan2(2.0f32));
-        //     ensure_nondet(|| 1.0f32.sinh());
-        //     ensure_nondet(|| 1.0f32.cosh());
-        //     ensure_nondet(|| 1.0f32.tanh());
-        // }
-        // ensure_nondet(|| 1.0f32.asinh());
-        // ensure_nondet(|| 2.0f32.acosh());
-        // ensure_nondet(|| 0.5f32.atanh());
-        // ensure_nondet(|| 5.0f32.gamma());
-        // ensure_nondet(|| 5.0f32.ln_gamma());
-        // ensure_nondet(|| 5.0f32.erf());
-        // ensure_nondet(|| 5.0f32.erfc());
+        if !cfg!(all(target_os = "windows", target_env = "msvc", target_arch = "x86")) {
+            ensure_nondet(|| 1.0f32.tan());
+            ensure_nondet(|| 1.0f32.asin());
+            ensure_nondet(|| 5.0f32.acos());
+            ensure_nondet(|| 1.0f32.atan());
+            ensure_nondet(|| 1.0f32.atan2(2.0f32));
+            ensure_nondet(|| 1.0f32.sinh());
+            ensure_nondet(|| 1.0f32.cosh());
+            ensure_nondet(|| 1.0f32.tanh());
+        }
+        ensure_nondet(|| 1.0f32.asinh());
+        ensure_nondet(|| 2.0f32.acosh());
+        ensure_nondet(|| 0.5f32.atanh());
+        ensure_nondet(|| 5.0f32.gamma());
+        ensure_nondet(|| 5.0f32.ln_gamma());
+        ensure_nondet(|| 5.0f32.erf());
+        ensure_nondet(|| 5.0f32.erfc());
     }
     pub fn test_operations_f64(a: f64, b: f64) {
         test_operations_f!(a, b);
-        // FIXME: some are temporarily disabled as it breaks std tests.
         ensure_nondet(|| a.powf(b));
         ensure_nondet(|| a.powi(2));
         ensure_nondet(|| a.log(b));
@@ -1464,26 +1530,26 @@ fn test_non_determinism() {
         ensure_nondet(|| 3f64.ln());
         ensure_nondet(|| f64::consts::E.log10());
         ensure_nondet(|| f64::consts::E.log2());
-        // ensure_nondet(|| 1f64.ln_1p());
-        // ensure_nondet(|| 27.0f64.cbrt());
-        // ensure_nondet(|| 3.0f64.hypot(4.0f64));
+        ensure_nondet(|| 1f64.ln_1p());
+        ensure_nondet(|| 27.0f64.cbrt());
+        ensure_nondet(|| 3.0f64.hypot(4.0f64));
         ensure_nondet(|| 1f64.sin());
         ensure_nondet(|| 1f64.cos());
-        // ensure_nondet(|| 1.0f64.tan());
-        // ensure_nondet(|| 1.0f64.asin());
-        // ensure_nondet(|| 5.0f64.acos());
-        // ensure_nondet(|| 1.0f64.atan());
-        // ensure_nondet(|| 1.0f64.atan2(2.0f64));
-        // ensure_nondet(|| 1.0f64.sinh());
-        // ensure_nondet(|| 1.0f64.cosh());
-        // ensure_nondet(|| 1.0f64.tanh());
-        // ensure_nondet(|| 1.0f64.asinh());
-        // ensure_nondet(|| 3.0f64.acosh());
-        // ensure_nondet(|| 0.5f64.atanh());
-        // ensure_nondet(|| 5.0f64.gamma());
-        // ensure_nondet(|| 5.0f64.ln_gamma());
-        // ensure_nondet(|| 5.0f64.erf());
-        // ensure_nondet(|| 5.0f64.erfc());
+        ensure_nondet(|| 1.0f64.tan());
+        ensure_nondet(|| 1.0f64.asin());
+        ensure_nondet(|| 5.0f64.acos());
+        ensure_nondet(|| 1.0f64.atan());
+        ensure_nondet(|| 1.0f64.atan2(2.0f64));
+        ensure_nondet(|| 1.0f64.sinh());
+        ensure_nondet(|| 1.0f64.cosh());
+        ensure_nondet(|| 1.0f64.tanh());
+        ensure_nondet(|| 1.0f64.asinh());
+        ensure_nondet(|| 3.0f64.acosh());
+        ensure_nondet(|| 0.5f64.atanh());
+        ensure_nondet(|| 5.0f64.gamma());
+        ensure_nondet(|| 5.0f64.ln_gamma());
+        ensure_nondet(|| 5.0f64.erf());
+        ensure_nondet(|| 5.0f64.erfc());
     }
     pub fn test_operations_f128(a: f128, b: f128) {
         test_operations_f!(a, b);

From e7e06aca38243b7d4534f15b0502d96e67003c5d Mon Sep 17 00:00:00 2001
From: LorrensP-2158466 <lorrens.pantelis@student.uhasselt.be>
Date: Sun, 13 Jul 2025 21:04:30 +0200
Subject: [PATCH 0592/1889] Change stdlib float tests to account for miri
 nondet floats.

---
 library/core/src/num/f32.rs        |  6 ++--
 library/std/src/num/f128.rs        | 10 +++----
 library/std/src/num/f16.rs         | 10 +++----
 library/std/src/num/f32.rs         | 44 +++++++++++++++---------------
 library/std/src/num/f64.rs         | 16 +++++------
 library/std/tests/floats/f32.rs    | 14 +++++-----
 src/tools/miri/tests/pass/float.rs |  7 ++---
 7 files changed, 53 insertions(+), 54 deletions(-)

diff --git a/library/core/src/num/f32.rs b/library/core/src/num/f32.rs
index da08bfc595059..28b262187fb62 100644
--- a/library/core/src/num/f32.rs
+++ b/library/core/src/num/f32.rs
@@ -1954,8 +1954,8 @@ pub mod math {
     /// let abs_difference_x = (f32::math::abs_sub(x, 1.0) - 2.0).abs();
     /// let abs_difference_y = (f32::math::abs_sub(y, 1.0) - 0.0).abs();
     ///
-    /// assert!(abs_difference_x <= f32::EPSILON);
-    /// assert!(abs_difference_y <= f32::EPSILON);
+    /// assert!(abs_difference_x <= 1e-6);
+    /// assert!(abs_difference_y <= 1e-6);
     /// ```
     ///
     /// _This standalone function is for testing only.
@@ -2000,7 +2000,7 @@ pub mod math {
     /// // x^(1/3) - 2 == 0
     /// let abs_difference = (f32::math::cbrt(x) - 2.0).abs();
     ///
-    /// assert!(abs_difference <= f32::EPSILON);
+    /// assert!(abs_difference <= 1e-6);
     /// ```
     ///
     /// _This standalone function is for testing only.
diff --git a/library/std/src/num/f128.rs b/library/std/src/num/f128.rs
index 64e604e35f75f..b83692390b6bc 100644
--- a/library/std/src/num/f128.rs
+++ b/library/std/src/num/f128.rs
@@ -467,10 +467,10 @@ impl f128 {
     /// # #[cfg(not(miri))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
-    /// let f = std::f128::consts::FRAC_PI_2;
+    /// let f = std::f128::consts::FRAC_PI_4;
     ///
     /// // asin(sin(pi/2))
-    /// let abs_difference = (f.sin().asin() - std::f128::consts::FRAC_PI_2).abs();
+    /// let abs_difference = (f.sin().asin() - f).abs();
     ///
     /// assert!(abs_difference <= f128::EPSILON);
     /// # }
@@ -912,10 +912,10 @@ impl f128 {
     /// # #[cfg(not(miri))]
     /// # #[cfg(target_has_reliable_f128_math)] {
     ///
-    /// let e = std::f128::consts::E;
-    /// let f = e.tanh().atanh();
+    /// let x = std::f128::consts::FRAC_PI_6;
+    /// let f = x.tanh().atanh();
     ///
-    /// let abs_difference = (f - e).abs();
+    /// let abs_difference = (f - x).abs();
     ///
     /// assert!(abs_difference <= 1e-5);
     /// # }
diff --git a/library/std/src/num/f16.rs b/library/std/src/num/f16.rs
index 7bdefb05858ef..5599528717cbe 100644
--- a/library/std/src/num/f16.rs
+++ b/library/std/src/num/f16.rs
@@ -432,10 +432,10 @@ impl f16 {
     /// # #[cfg(not(miri))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
-    /// let f = std::f16::consts::FRAC_PI_2;
+    /// let f = std::f16::consts::FRAC_PI_4;
     ///
     /// // asin(sin(pi/2))
-    /// let abs_difference = (f.sin().asin() - std::f16::consts::FRAC_PI_2).abs();
+    /// let abs_difference = (f.sin().asin() - f).abs();
     ///
     /// assert!(abs_difference <= f16::EPSILON);
     /// # }
@@ -877,10 +877,10 @@ impl f16 {
     /// # #[cfg(not(miri))]
     /// # #[cfg(target_has_reliable_f16_math)] {
     ///
-    /// let e = std::f16::consts::E;
-    /// let f = e.tanh().atanh();
+    /// let x = std::f16::consts::FRAC_PI_6;
+    /// let f = x.tanh().atanh();
     ///
-    /// let abs_difference = (f - e).abs();
+    /// let abs_difference = (f - x).abs();
     ///
     /// assert!(abs_difference <= 0.01);
     /// # }
diff --git a/library/std/src/num/f32.rs b/library/std/src/num/f32.rs
index 5dee68ad909e2..0247080a8d6be 100644
--- a/library/std/src/num/f32.rs
+++ b/library/std/src/num/f32.rs
@@ -582,8 +582,8 @@ impl f32 {
     /// let abs_difference_x = (x.abs_sub(1.0) - 2.0).abs();
     /// let abs_difference_y = (y.abs_sub(1.0) - 0.0).abs();
     ///
-    /// assert!(abs_difference_x <= f32::EPSILON);
-    /// assert!(abs_difference_y <= f32::EPSILON);
+    /// assert!(abs_difference_x <= 1e-6);
+    /// assert!(abs_difference_y <= 1e-6);
     /// ```
     #[rustc_allow_incoherent_impl]
     #[must_use = "method returns a new number and does not mutate the original value"]
@@ -621,7 +621,7 @@ impl f32 {
     /// // x^(1/3) - 2 == 0
     /// let abs_difference = (x.cbrt() - 2.0).abs();
     ///
-    /// assert!(abs_difference <= f32::EPSILON);
+    /// assert!(abs_difference <= 1e-6);
     /// ```
     #[rustc_allow_incoherent_impl]
     #[must_use = "method returns a new number and does not mutate the original value"]
@@ -652,7 +652,7 @@ impl f32 {
     /// // sqrt(x^2 + y^2)
     /// let abs_difference = (x.hypot(y) - (x.powi(2) + y.powi(2)).sqrt()).abs();
     ///
-    /// assert!(abs_difference <= 1e-6);
+    /// assert!(abs_difference <= 1e-5);
     /// ```
     #[rustc_allow_incoherent_impl]
     #[must_use = "method returns a new number and does not mutate the original value"]
@@ -725,7 +725,7 @@ impl f32 {
     /// let x = std::f32::consts::FRAC_PI_4;
     /// let abs_difference = (x.tan() - 1.0).abs();
     ///
-    /// assert!(abs_difference <= f32::EPSILON);
+    /// assert!(abs_difference <= 1e-6);
     /// ```
     #[rustc_allow_incoherent_impl]
     #[must_use = "method returns a new number and does not mutate the original value"]
@@ -749,12 +749,12 @@ impl f32 {
     /// # Examples
     ///
     /// ```
-    /// let f = std::f32::consts::FRAC_PI_2;
+    /// let f = std::f32::consts::FRAC_PI_4;
     ///
     /// // asin(sin(pi/2))
-    /// let abs_difference = (f.sin().asin() - std::f32::consts::FRAC_PI_2).abs();
+    /// let abs_difference = (f.sin().asin() - f).abs();
     ///
-    /// assert!(abs_difference <= 1e-3);
+    /// assert!(abs_difference <= 1e-6);
     /// ```
     #[doc(alias = "arcsin")]
     #[rustc_allow_incoherent_impl]
@@ -813,7 +813,7 @@ impl f32 {
     /// // atan(tan(1))
     /// let abs_difference = (f.tan().atan() - 1.0).abs();
     ///
-    /// assert!(abs_difference <= f32::EPSILON);
+    /// assert!(abs_difference <= 1e-6);
     /// ```
     #[doc(alias = "arctan")]
     #[rustc_allow_incoherent_impl]
@@ -854,8 +854,8 @@ impl f32 {
     /// let abs_difference_1 = (y1.atan2(x1) - (-std::f32::consts::FRAC_PI_4)).abs();
     /// let abs_difference_2 = (y2.atan2(x2) - (3.0 * std::f32::consts::FRAC_PI_4)).abs();
     ///
-    /// assert!(abs_difference_1 <= f32::EPSILON);
-    /// assert!(abs_difference_2 <= f32::EPSILON);
+    /// assert!(abs_difference_1 <= 1e-5);
+    /// assert!(abs_difference_2 <= 1e-5);
     /// ```
     #[rustc_allow_incoherent_impl]
     #[must_use = "method returns a new number and does not mutate the original value"]
@@ -884,8 +884,8 @@ impl f32 {
     /// let abs_difference_0 = (f.0 - x.sin()).abs();
     /// let abs_difference_1 = (f.1 - x.cos()).abs();
     ///
-    /// assert!(abs_difference_0 <= 1e-6);
-    /// assert!(abs_difference_1 <= 1e-6);
+    /// assert!(abs_difference_0 <= 1e-4);
+    /// assert!(abs_difference_1 <= 1e-4);
     /// ```
     #[doc(alias = "sincos")]
     #[rustc_allow_incoherent_impl]
@@ -982,7 +982,7 @@ impl f32 {
     /// let g = ((e * e) - 1.0) / (2.0 * e);
     /// let abs_difference = (f - g).abs();
     ///
-    /// assert!(abs_difference <= f32::EPSILON);
+    /// assert!(abs_difference <= 1e-6);
     /// ```
     #[rustc_allow_incoherent_impl]
     #[must_use = "method returns a new number and does not mutate the original value"]
@@ -1012,7 +1012,7 @@ impl f32 {
     /// let abs_difference = (f - g).abs();
     ///
     /// // Same result
-    /// assert!(abs_difference <= f32::EPSILON);
+    /// assert!(abs_difference <= 1e-6);
     /// ```
     #[rustc_allow_incoherent_impl]
     #[must_use = "method returns a new number and does not mutate the original value"]
@@ -1042,7 +1042,7 @@ impl f32 {
     /// let g = (1.0 - e.powi(-2)) / (1.0 + e.powi(-2));
     /// let abs_difference = (f - g).abs();
     ///
-    /// assert!(abs_difference <= f32::EPSILON);
+    /// assert!(abs_difference <= 1e-6);
     /// ```
     #[rustc_allow_incoherent_impl]
     #[must_use = "method returns a new number and does not mutate the original value"]
@@ -1067,7 +1067,7 @@ impl f32 {
     ///
     /// let abs_difference = (f - x).abs();
     ///
-    /// assert!(abs_difference <= 1e-7);
+    /// assert!(abs_difference <= 1e-6);
     /// ```
     #[doc(alias = "arcsinh")]
     #[rustc_allow_incoherent_impl]
@@ -1120,10 +1120,10 @@ impl f32 {
     /// # Examples
     ///
     /// ```
-    /// let e = std::f32::consts::E;
-    /// let f = e.tanh().atanh();
+    /// let x = std::f32::consts::FRAC_PI_6;
+    /// let f = x.tanh().atanh();
     ///
-    /// let abs_difference = (f - e).abs();
+    /// let abs_difference = (f - x).abs();
     ///
     /// assert!(abs_difference <= 1e-5);
     /// ```
@@ -1153,7 +1153,7 @@ impl f32 {
     ///
     /// let abs_difference = (x.gamma() - 24.0).abs();
     ///
-    /// assert!(abs_difference <= f32::EPSILON);
+    /// assert!(abs_difference <= 1e-5);
     /// ```
     #[rustc_allow_incoherent_impl]
     #[must_use = "method returns a new number and does not mutate the original value"]
@@ -1248,7 +1248,7 @@ impl f32 {
     /// let one = x.erf() + x.erfc();
     /// let abs_difference = (one - 1.0).abs();
     ///
-    /// assert!(abs_difference <= f32::EPSILON);
+    /// assert!(abs_difference <= 1e-6);
     /// ```
     #[rustc_allow_incoherent_impl]
     #[must_use = "method returns a new number and does not mutate the original value"]
diff --git a/library/std/src/num/f64.rs b/library/std/src/num/f64.rs
index 3ec80f68bdb2f..1cfd3909d967e 100644
--- a/library/std/src/num/f64.rs
+++ b/library/std/src/num/f64.rs
@@ -749,12 +749,12 @@ impl f64 {
     /// # Examples
     ///
     /// ```
-    /// let f = std::f64::consts::FRAC_PI_2;
+    /// let f = std::f64::consts::FRAC_PI_4;
     ///
     /// // asin(sin(pi/2))
-    /// let abs_difference = (f.sin().asin() - std::f64::consts::FRAC_PI_2).abs();
+    /// let abs_difference = (f.sin().asin() - f).abs();
     ///
-    /// assert!(abs_difference < 1e-7);
+    /// assert!(abs_difference < 1e-14);
     /// ```
     #[doc(alias = "arcsin")]
     #[rustc_allow_incoherent_impl]
@@ -1120,10 +1120,10 @@ impl f64 {
     /// # Examples
     ///
     /// ```
-    /// let e = std::f64::consts::E;
-    /// let f = e.tanh().atanh();
+    /// let x = std::f64::consts::FRAC_PI_6;
+    /// let f = x.tanh().atanh();
     ///
-    /// let abs_difference = (f - e).abs();
+    /// let abs_difference = (f - x).abs();
     ///
     /// assert!(abs_difference < 1.0e-10);
     /// ```
@@ -1153,7 +1153,7 @@ impl f64 {
     ///
     /// let abs_difference = (x.gamma() - 24.0).abs();
     ///
-    /// assert!(abs_difference <= f64::EPSILON);
+    /// assert!(abs_difference <= 1e-10);
     /// ```
     #[rustc_allow_incoherent_impl]
     #[must_use = "method returns a new number and does not mutate the original value"]
@@ -1248,7 +1248,7 @@ impl f64 {
     /// let one = x.erf() + x.erfc();
     /// let abs_difference = (one - 1.0).abs();
     ///
-    /// assert!(abs_difference <= f64::EPSILON);
+    /// assert!(abs_difference <= 1e-10);
     /// ```
     #[rustc_allow_incoherent_impl]
     #[must_use = "method returns a new number and does not mutate the original value"]
diff --git a/library/std/tests/floats/f32.rs b/library/std/tests/floats/f32.rs
index c61a8ec4d2096..c29d803b25e41 100644
--- a/library/std/tests/floats/f32.rs
+++ b/library/std/tests/floats/f32.rs
@@ -79,8 +79,8 @@ fn test_log() {
     let nan: f32 = f32::NAN;
     let inf: f32 = f32::INFINITY;
     let neg_inf: f32 = f32::NEG_INFINITY;
-    assert_approx_eq!(10.0f32.log(10.0), 1.0, APPROX_DELTA);
-    assert_approx_eq!(2.3f32.log(3.5), 0.664858, APPROX_DELTA);
+    assert_approx_eq!(10.0f32.log(10.0), 1.0);
+    assert_approx_eq!(2.3f32.log(3.5), 0.664858);
     assert_approx_eq!(1.0f32.exp().log(1.0f32.exp()), 1.0, APPROX_DELTA);
     assert!(1.0f32.log(1.0).is_nan());
     assert!(1.0f32.log(-13.9).is_nan());
@@ -140,10 +140,10 @@ fn test_asinh() {
     assert_approx_eq!(2.0f32.asinh(), 1.443635475178810342493276740273105f32);
     assert_approx_eq!((-2.0f32).asinh(), -1.443635475178810342493276740273105f32);
     // regression test for the catastrophic cancellation fixed in 72486
-    assert_approx_eq!((-3000.0f32).asinh(), -8.699514775987968673236893537700647f32);
+    assert_approx_eq!((-3000.0f32).asinh(), -8.699514775987968673236893537700647f32, APPROX_DELTA);
 
     // test for low accuracy from issue 104548
-    assert_approx_eq!(60.0f32, 60.0f32.sinh().asinh());
+    assert_approx_eq!(60.0f32, 60.0f32.sinh().asinh(), APPROX_DELTA);
     // mul needed for approximate comparison to be meaningful
     assert_approx_eq!(1.0f32, 1e-15f32.sinh().asinh() * 1e15f32);
 }
@@ -196,8 +196,8 @@ fn test_gamma() {
     assert_approx_eq!(1.0f32.gamma(), 1.0f32);
     assert_approx_eq!(2.0f32.gamma(), 1.0f32);
     assert_approx_eq!(3.0f32.gamma(), 2.0f32);
-    assert_approx_eq!(4.0f32.gamma(), 6.0f32);
-    assert_approx_eq!(5.0f32.gamma(), 24.0f32);
+    assert_approx_eq!(4.0f32.gamma(), 6.0f32, APPROX_DELTA);
+    assert_approx_eq!(5.0f32.gamma(), 24.0f32, APPROX_DELTA);
     assert_approx_eq!(0.5f32.gamma(), consts::PI.sqrt());
     assert_approx_eq!((-0.5f32).gamma(), -2.0 * consts::PI.sqrt());
     assert_eq!(0.0f32.gamma(), f32::INFINITY);
@@ -218,7 +218,7 @@ fn test_ln_gamma() {
     assert_eq!(2.0f32.ln_gamma().1, 1);
     assert_approx_eq!(3.0f32.ln_gamma().0, 2.0f32.ln());
     assert_eq!(3.0f32.ln_gamma().1, 1);
-    assert_approx_eq!((-0.5f32).ln_gamma().0, (2.0 * consts::PI.sqrt()).ln());
+    assert_approx_eq!((-0.5f32).ln_gamma().0, (2.0 * consts::PI.sqrt()).ln(), APPROX_DELTA);
     assert_eq!((-0.5f32).ln_gamma().1, -1);
 }
 
diff --git a/src/tools/miri/tests/pass/float.rs b/src/tools/miri/tests/pass/float.rs
index d6e1b2a83d936..9f1b3f612b2d2 100644
--- a/src/tools/miri/tests/pass/float.rs
+++ b/src/tools/miri/tests/pass/float.rs
@@ -1139,7 +1139,7 @@ pub fn libm() {
     assert_approx_eq!((f64::consts::PI / 2f64).sin(), 1f64);
     assert_approx_eq!(f32::consts::FRAC_PI_6.sin(), 0.5);
     assert_approx_eq!(f64::consts::FRAC_PI_6.sin(), 0.5);
-    // Increase error tolerance from 12ULP to 16ULP because of the extra operation.
+    // Increase error tolerance to 16ULP because of the extra operation.
     assert_approx_eq!(f32::consts::FRAC_PI_4.sin().asin(), f32::consts::FRAC_PI_4, 16);
     assert_approx_eq!(f64::consts::FRAC_PI_4.sin().asin(), f64::consts::FRAC_PI_4, 16);
     assert_biteq(0.0f32.asin(), 0.0f32, "asin(+0) = +0");
@@ -1147,7 +1147,6 @@ pub fn libm() {
     assert_biteq(0.0f64.asin(), 0.0, "asin(+0) = +0");
     assert_biteq((-0.0f64).asin(), -0.0, "asin(-0) = -0");
 
-
     assert_approx_eq!(1.0f32.sinh(), 1.1752012f32);
     assert_approx_eq!(1.0f64.sinh(), 1.1752011936438014f64);
     assert_approx_eq!(2.0f32.asinh(), 1.443635475178810342493276740273105f32);
@@ -1173,13 +1172,13 @@ pub fn libm() {
     assert_approx_eq!((f64::consts::PI * 2f64).cos(), 1f64);
     assert_approx_eq!(f32::consts::FRAC_PI_3.cos(), 0.5);
     assert_approx_eq!(f64::consts::FRAC_PI_3.cos(), 0.5);
-    // Increase error tolerance from 12ULP to 16ULP because of the extra operation.
+    // Increase error tolerance to 16ULP because of the extra operation.
     assert_approx_eq!(f32::consts::FRAC_PI_4.cos().acos(), f32::consts::FRAC_PI_4, 16);
     assert_approx_eq!(f64::consts::FRAC_PI_4.cos().acos(), f64::consts::FRAC_PI_4, 16);
     assert_biteq(1.0f32.acos(), 0.0, "acos(1) = 0");
     assert_biteq(1.0f64.acos(), 0.0, "acos(1) = 0");
 
-    assert_approx_eq!(1.0f32.cosh(), 1.54308f32);
+    assert_approx_eq!(1.0f32.cosh(), 1.5430806f32);
     assert_approx_eq!(1.0f64.cosh(), 1.5430806348152437f64);
     assert_eq!(0.0f32.cosh(), 1.0);
     assert_eq!(0.0f64.cosh(), 1.0);

From 0c0e764ff7d0708b90baa1386c6cbe75d70bce7d Mon Sep 17 00:00:00 2001
From: niacdoial <niac.notirl@gmail.com>
Date: Fri, 22 Aug 2025 23:07:40 +0200
Subject: [PATCH 0593/1889] ImproperCTypes: move code and tests into proper
 directories

---
 compiler/rustc_lint/src/types.rs              | 867 +-----------------
 .../rustc_lint/src/types/improper_ctypes.rs   | 861 ++++++++++++++++-
 .../allow-phantomdata-in-ffi.rs               |   0
 .../lint-113436-1.rs}                         |   0
 .../lint-113436-1.stderr}                     |  10 +-
 .../lint-73249-2.rs}                          |   0
 .../lint-73249-2.stderr}                      |   4 +-
 .../lint-73249-3.rs}                          |   0
 .../lint-73249-3.stderr}                      |   4 +-
 .../lint-73249-5.rs}                          |   0
 .../lint-73249-5.stderr}                      |   4 +-
 .../lint-73251-1.rs}                          |   0
 .../lint-73251-1.stderr}                      |   4 +-
 .../lint-73251-2.rs}                          |   0
 .../lint-73251-2.stderr}                      |   4 +-
 .../lint-94223.rs}                            |   0
 .../lint-94223.stderr}                        |  34 +-
 .../lint-cstr.rs}                             |   0
 .../lint-cstr.stderr}                         |  20 +-
 .../lint/{ => improper-ctypes}/lint-ctypes.rs |   0
 .../{ => improper-ctypes}/lint-ctypes.stderr  |   0
 .../lint-enum.rs}                             |   0
 .../lint-enum.stderr}                         |  50 +-
 .../lint-fn.rs}                               |   0
 .../lint-fn.stderr}                           |  40 +-
 .../lint-non-recursion-limit.rs}              |   0
 .../lint-option-nonnull-unsized.rs}           |   0
 .../lint-option-nonnull-unsized.stderr}       |   4 +-
 .../mustpass-113436.rs}                       |   0
 .../mustpass-113900.rs}                       |   0
 .../mustpass-134060.rs}                       |   0
 .../mustpass-134060.stderr}                   |   2 +-
 .../mustpass-66202.rs}                        |   0
 .../mustpass-73249-1.rs}                      |   0
 .../mustpass-73249-4.rs}                      |   0
 .../mustpass-73249.rs}                        |   0
 .../mustpass-73251.rs}                        |   0
 .../mustpass-73747.rs}                        |   0
 .../repr-rust-is-undefined.rs                 |   0
 .../repr-rust-is-undefined.stderr             |   0
 40 files changed, 959 insertions(+), 949 deletions(-)
 rename tests/ui/lint/{improper_ctypes => improper-ctypes}/allow-phantomdata-in-ffi.rs (100%)
 rename tests/ui/lint/{lint-ctypes-113436-1.rs => improper-ctypes/lint-113436-1.rs} (100%)
 rename tests/ui/lint/{lint-ctypes-113436-1.stderr => improper-ctypes/lint-113436-1.stderr} (82%)
 rename tests/ui/lint/{lint-ctypes-73249-2.rs => improper-ctypes/lint-73249-2.rs} (100%)
 rename tests/ui/lint/{lint-ctypes-73249-2.stderr => improper-ctypes/lint-73249-2.stderr} (81%)
 rename tests/ui/lint/{lint-ctypes-73249-3.rs => improper-ctypes/lint-73249-3.rs} (100%)
 rename tests/ui/lint/{lint-ctypes-73249-5.stderr => improper-ctypes/lint-73249-3.stderr} (81%)
 rename tests/ui/lint/{lint-ctypes-73249-5.rs => improper-ctypes/lint-73249-5.rs} (100%)
 rename tests/ui/lint/{lint-ctypes-73249-3.stderr => improper-ctypes/lint-73249-5.stderr} (81%)
 rename tests/ui/lint/{lint-ctypes-73251-1.rs => improper-ctypes/lint-73251-1.rs} (100%)
 rename tests/ui/lint/{lint-ctypes-73251-1.stderr => improper-ctypes/lint-73251-1.stderr} (82%)
 rename tests/ui/lint/{lint-ctypes-73251-2.rs => improper-ctypes/lint-73251-2.rs} (100%)
 rename tests/ui/lint/{lint-ctypes-73251-2.stderr => improper-ctypes/lint-73251-2.stderr} (82%)
 rename tests/ui/lint/{lint-ctypes-94223.rs => improper-ctypes/lint-94223.rs} (100%)
 rename tests/ui/lint/{lint-ctypes-94223.stderr => improper-ctypes/lint-94223.stderr} (86%)
 rename tests/ui/lint/{lint-ctypes-cstr.rs => improper-ctypes/lint-cstr.rs} (100%)
 rename tests/ui/lint/{lint-ctypes-cstr.stderr => improper-ctypes/lint-cstr.stderr} (88%)
 rename tests/ui/lint/{ => improper-ctypes}/lint-ctypes.rs (100%)
 rename tests/ui/lint/{ => improper-ctypes}/lint-ctypes.stderr (100%)
 rename tests/ui/lint/{lint-ctypes-enum.rs => improper-ctypes/lint-enum.rs} (100%)
 rename tests/ui/lint/{lint-ctypes-enum.stderr => improper-ctypes/lint-enum.stderr} (90%)
 rename tests/ui/lint/{lint-ctypes-fn.rs => improper-ctypes/lint-fn.rs} (100%)
 rename tests/ui/lint/{lint-ctypes-fn.stderr => improper-ctypes/lint-fn.stderr} (88%)
 rename tests/ui/lint/{lint-ctypes-non-recursion-limit.rs => improper-ctypes/lint-non-recursion-limit.rs} (100%)
 rename tests/ui/lint/{lint-ctypes-option-nonnull-unsized.rs => improper-ctypes/lint-option-nonnull-unsized.rs} (100%)
 rename tests/ui/lint/{lint-ctypes-option-nonnull-unsized.stderr => improper-ctypes/lint-option-nonnull-unsized.stderr} (83%)
 rename tests/ui/lint/{lint-ctypes-113436.rs => improper-ctypes/mustpass-113436.rs} (100%)
 rename tests/ui/lint/{lint-ctypes-113900.rs => improper-ctypes/mustpass-113900.rs} (100%)
 rename tests/ui/lint/{improper_ctypes_definitions_ice_134060.rs => improper-ctypes/mustpass-134060.rs} (100%)
 rename tests/ui/lint/{improper_ctypes_definitions_ice_134060.stderr => improper-ctypes/mustpass-134060.stderr} (85%)
 rename tests/ui/lint/{lint-ctypes-66202.rs => improper-ctypes/mustpass-66202.rs} (100%)
 rename tests/ui/lint/{lint-ctypes-73249-1.rs => improper-ctypes/mustpass-73249-1.rs} (100%)
 rename tests/ui/lint/{lint-ctypes-73249-4.rs => improper-ctypes/mustpass-73249-4.rs} (100%)
 rename tests/ui/lint/{lint-ctypes-73249.rs => improper-ctypes/mustpass-73249.rs} (100%)
 rename tests/ui/lint/{lint-ctypes-73251.rs => improper-ctypes/mustpass-73251.rs} (100%)
 rename tests/ui/lint/{lint-ctypes-73747.rs => improper-ctypes/mustpass-73747.rs} (100%)
 rename tests/ui/lint/{improper_ctypes => improper-ctypes}/repr-rust-is-undefined.rs (100%)
 rename tests/ui/lint/{improper_ctypes => improper-ctypes}/repr-rust-is-undefined.stderr (100%)

diff --git a/compiler/rustc_lint/src/types.rs b/compiler/rustc_lint/src/types.rs
index f8a692313f030..056ecb70af8a4 100644
--- a/compiler/rustc_lint/src/types.rs
+++ b/compiler/rustc_lint/src/types.rs
@@ -1,35 +1,30 @@
 use std::iter;
-use std::ops::ControlFlow;
 
-use rustc_abi::{BackendRepr, TagEncoding, VariantIdx, Variants, WrappingRange};
-use rustc_data_structures::fx::FxHashSet;
-use rustc_errors::DiagMessage;
-use rustc_hir::intravisit::VisitorExt;
-use rustc_hir::{AmbigArg, Expr, ExprKind, HirId, LangItem};
+use rustc_abi::{BackendRepr, TagEncoding, Variants, WrappingRange};
+use rustc_hir::{Expr, ExprKind, HirId, LangItem};
 use rustc_middle::bug;
 use rustc_middle::ty::layout::{LayoutOf, SizeSkeleton};
-use rustc_middle::ty::{
-    self, Adt, AdtKind, GenericArgsRef, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable,
-    TypeVisitableExt,
-};
+use rustc_middle::ty::{self, Ty, TyCtxt, TypeVisitableExt};
 use rustc_session::{declare_lint, declare_lint_pass, impl_lint_pass};
-use rustc_span::def_id::LocalDefId;
 use rustc_span::{Span, Symbol, sym};
 use tracing::debug;
 use {rustc_ast as ast, rustc_hir as hir};
 
-mod improper_ctypes;
+mod improper_ctypes; // these filed do the implementation for ImproperCTypesDefinitions,ImproperCTypesDeclarations
+pub(crate) use improper_ctypes::{
+    CItemKind, ImproperCTypesDeclarations, ImproperCTypesDefinitions,
+};
 
 use crate::lints::{
     AmbiguousWidePointerComparisons, AmbiguousWidePointerComparisonsAddrMetadataSuggestion,
     AmbiguousWidePointerComparisonsAddrSuggestion, AmbiguousWidePointerComparisonsCastSuggestion,
     AmbiguousWidePointerComparisonsExpectSuggestion, AtomicOrderingFence, AtomicOrderingLoad,
-    AtomicOrderingStore, ImproperCTypes, InvalidAtomicOrderingDiag, InvalidNanComparisons,
+    AtomicOrderingStore, InvalidAtomicOrderingDiag, InvalidNanComparisons,
     InvalidNanComparisonsSuggestion, UnpredictableFunctionPointerComparisons,
-    UnpredictableFunctionPointerComparisonsSuggestion, UnusedComparisons, UsesPowerAlignment,
+    UnpredictableFunctionPointerComparisonsSuggestion, UnusedComparisons,
     VariantSizeDifferencesDiag,
 };
-use crate::{LateContext, LateLintPass, LintContext, fluent_generated as fluent};
+use crate::{LateContext, LateLintPass, LintContext};
 
 mod literal;
 
@@ -690,144 +685,6 @@ impl<'tcx> LateLintPass<'tcx> for TypeLimits {
     }
 }
 
-declare_lint! {
-    /// The `improper_ctypes` lint detects incorrect use of types in foreign
-    /// modules.
-    ///
-    /// ### Example
-    ///
-    /// ```rust
-    /// unsafe extern "C" {
-    ///     static STATIC: String;
-    /// }
-    /// ```
-    ///
-    /// {{produces}}
-    ///
-    /// ### Explanation
-    ///
-    /// The compiler has several checks to verify that types used in `extern`
-    /// blocks are safe and follow certain rules to ensure proper
-    /// compatibility with the foreign interfaces. This lint is issued when it
-    /// detects a probable mistake in a definition. The lint usually should
-    /// provide a description of the issue, along with possibly a hint on how
-    /// to resolve it.
-    IMPROPER_CTYPES,
-    Warn,
-    "proper use of libc types in foreign modules"
-}
-
-declare_lint_pass!(ImproperCTypesDeclarations => [IMPROPER_CTYPES]);
-
-declare_lint! {
-    /// The `improper_ctypes_definitions` lint detects incorrect use of
-    /// [`extern` function] definitions.
-    ///
-    /// [`extern` function]: https://doc.rust-lang.org/reference/items/functions.html#extern-function-qualifier
-    ///
-    /// ### Example
-    ///
-    /// ```rust
-    /// # #![allow(unused)]
-    /// pub extern "C" fn str_type(p: &str) { }
-    /// ```
-    ///
-    /// {{produces}}
-    ///
-    /// ### Explanation
-    ///
-    /// There are many parameter and return types that may be specified in an
-    /// `extern` function that are not compatible with the given ABI. This
-    /// lint is an alert that these types should not be used. The lint usually
-    /// should provide a description of the issue, along with possibly a hint
-    /// on how to resolve it.
-    IMPROPER_CTYPES_DEFINITIONS,
-    Warn,
-    "proper use of libc types in foreign item definitions"
-}
-
-declare_lint! {
-    /// The `uses_power_alignment` lint detects specific `repr(C)`
-    /// aggregates on AIX.
-    /// In its platform C ABI, AIX uses the "power" (as in PowerPC) alignment
-    /// rule (detailed in https://www.ibm.com/docs/en/xl-c-and-cpp-aix/16.1?topic=data-using-alignment-modes#alignment),
-    /// which can also be set for XLC by `#pragma align(power)` or
-    /// `-qalign=power`. Aggregates with a floating-point type as the
-    /// recursively first field (as in "at offset 0") modify the layout of
-    /// *subsequent* fields of the associated structs to use an alignment value
-    /// where the floating-point type is aligned on a 4-byte boundary.
-    ///
-    /// Effectively, subsequent floating-point fields act as-if they are `repr(packed(4))`. This
-    /// would be unsound to do in a `repr(C)` type without all the restrictions that come with
-    /// `repr(packed)`. Rust instead chooses a layout that maintains soundness of Rust code, at the
-    /// expense of incompatibility with C code.
-    ///
-    /// ### Example
-    ///
-    /// ```rust,ignore (fails on non-powerpc64-ibm-aix)
-    /// #[repr(C)]
-    /// pub struct Floats {
-    ///     a: f64,
-    ///     b: u8,
-    ///     c: f64,
-    /// }
-    /// ```
-    ///
-    /// This will produce:
-    ///
-    /// ```text
-    /// warning: repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
-    ///  --> <source>:5:3
-    ///   |
-    /// 5 |   c: f64,
-    ///   |   ^^^^^^
-    ///   |
-    ///   = note: `#[warn(uses_power_alignment)]` on by default
-    /// ```
-    ///
-    /// ### Explanation
-    ///
-    /// The power alignment rule specifies that the above struct has the
-    /// following alignment:
-    ///  - offset_of!(Floats, a) == 0
-    ///  - offset_of!(Floats, b) == 8
-    ///  - offset_of!(Floats, c) == 12
-    ///
-    /// However, Rust currently aligns `c` at `offset_of!(Floats, c) == 16`.
-    /// Using offset 12 would be unsound since `f64` generally must be 8-aligned on this target.
-    /// Thus, a warning is produced for the above struct.
-    USES_POWER_ALIGNMENT,
-    Warn,
-    "Structs do not follow the power alignment rule under repr(C)"
-}
-
-declare_lint_pass!(ImproperCTypesDefinitions => [IMPROPER_CTYPES_DEFINITIONS, USES_POWER_ALIGNMENT]);
-
-#[derive(Clone, Copy)]
-pub(crate) enum CItemKind {
-    Declaration,
-    Definition,
-}
-
-struct ImproperCTypesVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'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>),
-    FfiUnsafe { ty: Ty<'tcx>, reason: DiagMessage, help: Option<DiagMessage> },
-}
-
 pub(crate) fn nonnull_optimization_guaranteed<'tcx>(
     tcx: TyCtxt<'tcx>,
     def: ty::AdtDef<'tcx>,
@@ -1076,710 +933,6 @@ fn get_nullable_type_from_pat<'tcx>(
     }
 }
 
-impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
-    /// Check if the type is array and emit an unsafe type lint.
-    fn check_for_array_ty(&mut self, sp: Span, ty: Ty<'tcx>) -> bool {
-        if let ty::Array(..) = ty.kind() {
-            self.emit_ffi_unsafe_type_lint(
-                ty,
-                sp,
-                fluent::lint_improper_ctypes_array_reason,
-                Some(fluent::lint_improper_ctypes_array_help),
-            );
-            true
-        } else {
-            false
-        }
-    }
-
-    /// Checks if the given field's type is "ffi-safe".
-    fn check_field_type_for_ffi(
-        &self,
-        acc: &mut CTypesVisitorState<'tcx>,
-        field: &ty::FieldDef,
-        args: GenericArgsRef<'tcx>,
-    ) -> FfiResult<'tcx> {
-        let field_ty = field.ty(self.cx.tcx, args);
-        let field_ty = self
-            .cx
-            .tcx
-            .try_normalize_erasing_regions(self.cx.typing_env(), field_ty)
-            .unwrap_or(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,
-        acc: &mut CTypesVisitorState<'tcx>,
-        ty: Ty<'tcx>,
-        def: ty::AdtDef<'tcx>,
-        variant: &ty::VariantDef,
-        args: GenericArgsRef<'tcx>,
-    ) -> FfiResult<'tcx> {
-        use FfiResult::*;
-        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(acc, field, args) {
-                    FfiUnsafe { ty, .. } if ty.is_unit() => (),
-                    r => return r,
-                }
-
-                false
-            } else {
-                // ..or have only ZST fields, which is FFI-unsafe (unless those fields are all
-                // `PhantomData`).
-                true
-            }
-        } else {
-            false
-        };
-
-        // 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(acc, field, args) {
-                FfiSafe => false,
-                // `()` fields are FFI-safe!
-                FfiUnsafe { ty, .. } if ty.is_unit() => false,
-                FfiPhantom(..) => true,
-                r @ FfiUnsafe { .. } => return r,
-            }
-        }
-
-        if all_phantom {
-            FfiPhantom(ty)
-        } else if transparent_with_all_zst_fields {
-            FfiUnsafe { ty, reason: fluent::lint_improper_ctypes_struct_zst, help: None }
-        } else {
-            FfiSafe
-        }
-    }
-
-    /// 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,
-        acc: &mut CTypesVisitorState<'tcx>,
-        ty: Ty<'tcx>,
-    ) -> FfiResult<'tcx> {
-        use FfiResult::*;
-
-        let tcx = self.cx.tcx;
-
-        // Protect against infinite recursion, for example
-        // `struct S(*mut S);`.
-        // FIXME: A recursion limit is necessary as well, for irregular
-        // recursive types.
-        if !acc.cache.insert(ty) {
-            return FfiSafe;
-        }
-
-        match *ty.kind() {
-            ty::Adt(def, args) => {
-                if let Some(boxed) = ty.boxed_ty()
-                    && matches!(self.mode, CItemKind::Definition)
-                {
-                    if boxed.is_sized(tcx, self.cx.typing_env()) {
-                        return FfiSafe;
-                    } else {
-                        return FfiUnsafe {
-                            ty,
-                            reason: fluent::lint_improper_ctypes_box,
-                            help: None,
-                        };
-                    }
-                }
-                if def.is_phantom_data() {
-                    return FfiPhantom(ty);
-                }
-                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,
-                                reason: if def.is_struct() {
-                                    fluent::lint_improper_ctypes_struct_layout_reason
-                                } else {
-                                    fluent::lint_improper_ctypes_union_layout_reason
-                                },
-                                help: if def.is_struct() {
-                                    Some(fluent::lint_improper_ctypes_struct_layout_help)
-                                } else {
-                                    Some(fluent::lint_improper_ctypes_union_layout_help)
-                                },
-                            };
-                        }
-
-                        if def.non_enum_variant().field_list_has_applicable_non_exhaustive() {
-                            return FfiUnsafe {
-                                ty,
-                                reason: if def.is_struct() {
-                                    fluent::lint_improper_ctypes_struct_non_exhaustive
-                                } else {
-                                    fluent::lint_improper_ctypes_union_non_exhaustive
-                                },
-                                help: None,
-                            };
-                        }
-
-                        if def.non_enum_variant().fields.is_empty() {
-                            return FfiUnsafe {
-                                ty,
-                                reason: if def.is_struct() {
-                                    fluent::lint_improper_ctypes_struct_fieldless_reason
-                                } else {
-                                    fluent::lint_improper_ctypes_union_fieldless_reason
-                                },
-                                help: if def.is_struct() {
-                                    Some(fluent::lint_improper_ctypes_struct_fieldless_help)
-                                } else {
-                                    Some(fluent::lint_improper_ctypes_union_fieldless_help)
-                                },
-                            };
-                        }
-
-                        self.check_variant_for_ffi(acc, ty, def, def.non_enum_variant(), args)
-                    }
-                    AdtKind::Enum => {
-                        if def.variants().is_empty() {
-                            // Empty enums are okay... although sort of useless.
-                            return FfiSafe;
-                        }
-                        // Check for a repr() attribute to specify the size of the
-                        // discriminant.
-                        if !def.repr().c() && !def.repr().transparent() && def.repr().int.is_none()
-                        {
-                            // Special-case types like `Option<extern fn()>` and `Result<extern fn(), ()>`
-                            if let Some(ty) =
-                                repr_nullable_ptr(self.cx.tcx, self.cx.typing_env(), ty, self.mode)
-                            {
-                                return self.check_type_for_ffi(acc, ty);
-                            }
-
-                            return FfiUnsafe {
-                                ty,
-                                reason: fluent::lint_improper_ctypes_enum_repr_reason,
-                                help: Some(fluent::lint_improper_ctypes_enum_repr_help),
-                            };
-                        }
-
-                        use improper_ctypes::check_non_exhaustive_variant;
-
-                        let non_exhaustive = def.variant_list_has_applicable_non_exhaustive();
-                        // Check the contained variants.
-                        let ret = def.variants().iter().try_for_each(|variant| {
-                            check_non_exhaustive_variant(non_exhaustive, variant)
-                                .map_break(|reason| FfiUnsafe { ty, reason, help: None })?;
-
-                            match self.check_variant_for_ffi(acc, ty, def, variant, args) {
-                                FfiSafe => ControlFlow::Continue(()),
-                                r => ControlFlow::Break(r),
-                            }
-                        });
-                        if let ControlFlow::Break(result) = ret {
-                            return result;
-                        }
-
-                        FfiSafe
-                    }
-                }
-            }
-
-            ty::Char => FfiUnsafe {
-                ty,
-                reason: fluent::lint_improper_ctypes_char_reason,
-                help: Some(fluent::lint_improper_ctypes_char_help),
-            },
-
-            // It's just extra invariants on the type that you need to uphold,
-            // but only the base type is relevant for being representable in FFI.
-            ty::Pat(base, ..) => self.check_type_for_ffi(acc, base),
-
-            // Primitive types with a stable representation.
-            ty::Bool | ty::Int(..) | ty::Uint(..) | ty::Float(..) | ty::Never => FfiSafe,
-
-            ty::Slice(_) => FfiUnsafe {
-                ty,
-                reason: fluent::lint_improper_ctypes_slice_reason,
-                help: Some(fluent::lint_improper_ctypes_slice_help),
-            },
-
-            ty::Dynamic(..) => {
-                FfiUnsafe { ty, reason: fluent::lint_improper_ctypes_dyn, help: None }
-            }
-
-            ty::Str => FfiUnsafe {
-                ty,
-                reason: fluent::lint_improper_ctypes_str_reason,
-                help: Some(fluent::lint_improper_ctypes_str_help),
-            },
-
-            ty::Tuple(..) => FfiUnsafe {
-                ty,
-                reason: fluent::lint_improper_ctypes_tuple_reason,
-                help: Some(fluent::lint_improper_ctypes_tuple_help),
-            },
-
-            ty::RawPtr(ty, _) | ty::Ref(_, ty, _)
-                if {
-                    matches!(self.mode, CItemKind::Definition)
-                        && ty.is_sized(self.cx.tcx, self.cx.typing_env())
-                } =>
-            {
-                FfiSafe
-            }
-
-            ty::RawPtr(ty, _)
-                if match ty.kind() {
-                    ty::Tuple(tuple) => tuple.is_empty(),
-                    _ => false,
-                } =>
-            {
-                FfiSafe
-            }
-
-            ty::RawPtr(ty, _) | ty::Ref(_, ty, _) => self.check_type_for_ffi(acc, ty),
-
-            ty::Array(inner_ty, _) => self.check_type_for_ffi(acc, inner_ty),
-
-            ty::FnPtr(sig_tys, hdr) => {
-                let sig = sig_tys.with(hdr);
-                if sig.abi().is_rustic_abi() {
-                    return FfiUnsafe {
-                        ty,
-                        reason: fluent::lint_improper_ctypes_fnptr_reason,
-                        help: Some(fluent::lint_improper_ctypes_fnptr_help),
-                    };
-                }
-
-                let sig = tcx.instantiate_bound_regions_with_erased(sig);
-                for arg in sig.inputs() {
-                    match self.check_type_for_ffi(acc, *arg) {
-                        FfiSafe => {}
-                        r => return r,
-                    }
-                }
-
-                let ret_ty = sig.output();
-                if ret_ty.is_unit() {
-                    return FfiSafe;
-                }
-
-                self.check_type_for_ffi(acc, ret_ty)
-            }
-
-            ty::Foreign(..) => FfiSafe,
-
-            // While opaque types are checked for earlier, if a projection in a struct field
-            // normalizes to an opaque type, then it will reach this branch.
-            ty::Alias(ty::Opaque, ..) => {
-                FfiUnsafe { ty, reason: fluent::lint_improper_ctypes_opaque, help: None }
-            }
-
-            // `extern "C" fn` functions can have type parameters, which may or may not be FFI-safe,
-            //  so they are currently ignored for the purposes of this lint.
-            ty::Param(..) | ty::Alias(ty::Projection | ty::Inherent, ..)
-                if matches!(self.mode, CItemKind::Definition) =>
-            {
-                FfiSafe
-            }
-
-            ty::UnsafeBinder(_) => todo!("FIXME(unsafe_binder)"),
-
-            ty::Param(..)
-            | ty::Alias(ty::Projection | ty::Inherent | ty::Free, ..)
-            | ty::Infer(..)
-            | ty::Bound(..)
-            | ty::Error(_)
-            | ty::Closure(..)
-            | ty::CoroutineClosure(..)
-            | ty::Coroutine(..)
-            | ty::CoroutineWitness(..)
-            | ty::Placeholder(..)
-            | ty::FnDef(..) => bug!("unexpected type in foreign function: {:?}", ty),
-        }
-    }
-
-    fn emit_ffi_unsafe_type_lint(
-        &mut self,
-        ty: Ty<'tcx>,
-        sp: Span,
-        note: DiagMessage,
-        help: Option<DiagMessage>,
-    ) {
-        let lint = match self.mode {
-            CItemKind::Declaration => IMPROPER_CTYPES,
-            CItemKind::Definition => IMPROPER_CTYPES_DEFINITIONS,
-        };
-        let desc = match self.mode {
-            CItemKind::Declaration => "block",
-            CItemKind::Definition => "fn",
-        };
-        let span_note = if let ty::Adt(def, _) = ty.kind()
-            && let Some(sp) = self.cx.tcx.hir_span_if_local(def.did())
-        {
-            Some(sp)
-        } else {
-            None
-        };
-        self.cx.emit_span_lint(
-            lint,
-            sp,
-            ImproperCTypes { ty, desc, label: sp, help, note, span_note },
-        );
-    }
-
-    fn check_for_opaque_ty(&mut self, sp: Span, ty: Ty<'tcx>) -> bool {
-        struct ProhibitOpaqueTypes;
-        impl<'tcx> ty::TypeVisitor<TyCtxt<'tcx>> for ProhibitOpaqueTypes {
-            type Result = ControlFlow<Ty<'tcx>>;
-
-            fn visit_ty(&mut self, ty: Ty<'tcx>) -> Self::Result {
-                if !ty.has_opaque_types() {
-                    return ControlFlow::Continue(());
-                }
-
-                if let ty::Alias(ty::Opaque, ..) = ty.kind() {
-                    ControlFlow::Break(ty)
-                } else {
-                    ty.super_visit_with(self)
-                }
-            }
-        }
-
-        if let Some(ty) = self
-            .cx
-            .tcx
-            .try_normalize_erasing_regions(self.cx.typing_env(), ty)
-            .unwrap_or(ty)
-            .visit_with(&mut ProhibitOpaqueTypes)
-            .break_value()
-        {
-            self.emit_ffi_unsafe_type_lint(ty, sp, fluent::lint_improper_ctypes_opaque, None);
-            true
-        } else {
-            false
-        }
-    }
-
-    fn check_type_for_ffi_and_report_errors(
-        &mut self,
-        sp: Span,
-        ty: Ty<'tcx>,
-        is_static: bool,
-        is_return_type: bool,
-    ) {
-        if self.check_for_opaque_ty(sp, ty) {
-            // We've already emitted an error due to an opaque type.
-            return;
-        }
-
-        let ty = self.cx.tcx.try_normalize_erasing_regions(self.cx.typing_env(), ty).unwrap_or(ty);
-
-        // C doesn't really support passing arrays by value - the only way to pass an array by value
-        // is through a struct. So, first test that the top level isn't an array, and then
-        // recursively check the types inside.
-        if !is_static && self.check_for_array_ty(sp, ty) {
-            return;
-        }
-
-        // Don't report FFI errors for unit return types. This check exists here, and not in
-        // the caller (where it would make more sense) so that normalization has definitely
-        // happened.
-        if is_return_type && ty.is_unit() {
-            return;
-        }
-
-        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(
-                    ty,
-                    sp,
-                    fluent::lint_improper_ctypes_only_phantomdata,
-                    None,
-                );
-            }
-            FfiResult::FfiUnsafe { ty, reason, help } => {
-                self.emit_ffi_unsafe_type_lint(ty, sp, reason, help);
-            }
-        }
-    }
-
-    /// Check if a function's argument types and result type are "ffi-safe".
-    ///
-    /// For a external ABI function, argument types and the result type are walked to find fn-ptr
-    /// types that have external ABIs, as these still need checked.
-    fn check_fn(&mut self, def_id: LocalDefId, decl: &'tcx hir::FnDecl<'_>) {
-        let sig = self.cx.tcx.fn_sig(def_id).instantiate_identity();
-        let sig = self.cx.tcx.instantiate_bound_regions_with_erased(sig);
-
-        for (input_ty, input_hir) in iter::zip(sig.inputs(), decl.inputs) {
-            for (fn_ptr_ty, span) in self.find_fn_ptr_ty_with_external_abi(input_hir, *input_ty) {
-                self.check_type_for_ffi_and_report_errors(span, fn_ptr_ty, false, false);
-            }
-        }
-
-        if let hir::FnRetTy::Return(ret_hir) = decl.output {
-            for (fn_ptr_ty, span) in self.find_fn_ptr_ty_with_external_abi(ret_hir, sig.output()) {
-                self.check_type_for_ffi_and_report_errors(span, fn_ptr_ty, false, true);
-            }
-        }
-    }
-
-    /// Check if a function's argument types and result type are "ffi-safe".
-    fn check_foreign_fn(&mut self, def_id: LocalDefId, decl: &'tcx hir::FnDecl<'_>) {
-        let sig = self.cx.tcx.fn_sig(def_id).instantiate_identity();
-        let sig = self.cx.tcx.instantiate_bound_regions_with_erased(sig);
-
-        for (input_ty, input_hir) in iter::zip(sig.inputs(), decl.inputs) {
-            self.check_type_for_ffi_and_report_errors(input_hir.span, *input_ty, false, false);
-        }
-
-        if let hir::FnRetTy::Return(ret_hir) = decl.output {
-            self.check_type_for_ffi_and_report_errors(ret_hir.span, sig.output(), false, true);
-        }
-    }
-
-    fn check_foreign_static(&mut self, id: hir::OwnerId, span: Span) {
-        let ty = self.cx.tcx.type_of(id).instantiate_identity();
-        self.check_type_for_ffi_and_report_errors(span, ty, true, false);
-    }
-
-    /// Find any fn-ptr types with external ABIs in `ty`.
-    ///
-    /// For example, `Option<extern "C" fn()>` returns `extern "C" fn()`
-    fn find_fn_ptr_ty_with_external_abi(
-        &self,
-        hir_ty: &hir::Ty<'tcx>,
-        ty: Ty<'tcx>,
-    ) -> Vec<(Ty<'tcx>, Span)> {
-        struct FnPtrFinder<'tcx> {
-            spans: Vec<Span>,
-            tys: Vec<Ty<'tcx>>,
-        }
-
-        impl<'tcx> hir::intravisit::Visitor<'_> for FnPtrFinder<'tcx> {
-            fn visit_ty(&mut self, ty: &'_ hir::Ty<'_, AmbigArg>) {
-                debug!(?ty);
-                if let hir::TyKind::FnPtr(hir::FnPtrTy { abi, .. }) = ty.kind
-                    && !abi.is_rustic_abi()
-                {
-                    self.spans.push(ty.span);
-                }
-
-                hir::intravisit::walk_ty(self, ty)
-            }
-        }
-
-        impl<'tcx> ty::TypeVisitor<TyCtxt<'tcx>> for FnPtrFinder<'tcx> {
-            type Result = ();
-
-            fn visit_ty(&mut self, ty: Ty<'tcx>) -> Self::Result {
-                if let ty::FnPtr(_, hdr) = ty.kind()
-                    && !hdr.abi.is_rustic_abi()
-                {
-                    self.tys.push(ty);
-                }
-
-                ty.super_visit_with(self)
-            }
-        }
-
-        let mut visitor = FnPtrFinder { spans: Vec::new(), tys: Vec::new() };
-        ty.visit_with(&mut visitor);
-        visitor.visit_ty_unambig(hir_ty);
-
-        iter::zip(visitor.tys.drain(..), visitor.spans.drain(..)).collect()
-    }
-}
-
-impl<'tcx> LateLintPass<'tcx> for ImproperCTypesDeclarations {
-    fn check_foreign_item(&mut self, cx: &LateContext<'tcx>, it: &hir::ForeignItem<'tcx>) {
-        let mut vis = ImproperCTypesVisitor { cx, mode: CItemKind::Declaration };
-        let abi = cx.tcx.hir_get_foreign_abi(it.hir_id());
-
-        match it.kind {
-            hir::ForeignItemKind::Fn(sig, _, _) => {
-                if abi.is_rustic_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 !abi.is_rustic_abi() => {
-                vis.check_foreign_static(it.owner_id, ty.span);
-            }
-            hir::ForeignItemKind::Static(..) | hir::ForeignItemKind::Type => (),
-        }
-    }
-}
-
-impl ImproperCTypesDefinitions {
-    fn check_ty_maybe_containing_foreign_fnptr<'tcx>(
-        &mut self,
-        cx: &LateContext<'tcx>,
-        hir_ty: &'tcx hir::Ty<'_>,
-        ty: Ty<'tcx>,
-    ) {
-        let mut vis = ImproperCTypesVisitor { cx, mode: CItemKind::Definition };
-        for (fn_ptr_ty, span) in vis.find_fn_ptr_ty_with_external_abi(hir_ty, ty) {
-            vis.check_type_for_ffi_and_report_errors(span, fn_ptr_ty, true, false);
-        }
-    }
-
-    fn check_arg_for_power_alignment<'tcx>(
-        &mut self,
-        cx: &LateContext<'tcx>,
-        ty: Ty<'tcx>,
-    ) -> bool {
-        assert!(cx.tcx.sess.target.os == "aix");
-        // Structs (under repr(C)) follow the power alignment rule if:
-        //   - the first field of the struct is a floating-point type that
-        //     is greater than 4-bytes, or
-        //   - the first field of the struct is an aggregate whose
-        //     recursively first field is a floating-point type greater than
-        //     4 bytes.
-        if ty.is_floating_point() && ty.primitive_size(cx.tcx).bytes() > 4 {
-            return true;
-        } else if let Adt(adt_def, _) = ty.kind()
-            && adt_def.is_struct()
-            && adt_def.repr().c()
-            && !adt_def.repr().packed()
-            && adt_def.repr().align.is_none()
-        {
-            let struct_variant = adt_def.variant(VariantIdx::ZERO);
-            // Within a nested struct, all fields are examined to correctly
-            // report if any fields after the nested struct within the
-            // original struct are misaligned.
-            for struct_field in &struct_variant.fields {
-                let field_ty = cx.tcx.type_of(struct_field.did).instantiate_identity();
-                if self.check_arg_for_power_alignment(cx, field_ty) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-    fn check_struct_for_power_alignment<'tcx>(
-        &mut self,
-        cx: &LateContext<'tcx>,
-        item: &'tcx hir::Item<'tcx>,
-    ) {
-        let adt_def = cx.tcx.adt_def(item.owner_id.to_def_id());
-        // repr(C) structs also with packed or aligned representation
-        // should be ignored.
-        if adt_def.repr().c()
-            && !adt_def.repr().packed()
-            && adt_def.repr().align.is_none()
-            && cx.tcx.sess.target.os == "aix"
-            && !adt_def.all_fields().next().is_none()
-        {
-            let struct_variant_data = item.expect_struct().2;
-            for field_def in struct_variant_data.fields().iter().skip(1) {
-                // Struct fields (after the first field) are checked for the
-                // power alignment rule, as fields after the first are likely
-                // to be the fields that are misaligned.
-                let def_id = field_def.def_id;
-                let ty = cx.tcx.type_of(def_id).instantiate_identity();
-                if self.check_arg_for_power_alignment(cx, ty) {
-                    cx.emit_span_lint(USES_POWER_ALIGNMENT, field_def.span, UsesPowerAlignment);
-                }
-            }
-        }
-    }
-}
-
-/// `ImproperCTypesDefinitions` checks items outside of foreign items (e.g. stuff that isn't in
-/// `extern "C" { }` blocks):
-///
-/// - `extern "<abi>" fn` definitions are checked in the same way as the
-///   `ImproperCtypesDeclarations` visitor checks functions if `<abi>` is external (e.g. "C").
-/// - All other items which contain types (e.g. other functions, struct definitions, etc) are
-///   checked for extern fn-ptrs with external ABIs.
-impl<'tcx> LateLintPass<'tcx> for ImproperCTypesDefinitions {
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'tcx>) {
-        match item.kind {
-            hir::ItemKind::Static(_, _, ty, _)
-            | hir::ItemKind::Const(_, _, ty, _)
-            | hir::ItemKind::TyAlias(_, _, ty) => {
-                self.check_ty_maybe_containing_foreign_fnptr(
-                    cx,
-                    ty,
-                    cx.tcx.type_of(item.owner_id).instantiate_identity(),
-                );
-            }
-            // See `check_fn`..
-            hir::ItemKind::Fn { .. } => {}
-            // Structs are checked based on if they follow the power alignment
-            // rule (under repr(C)).
-            hir::ItemKind::Struct(..) => {
-                self.check_struct_for_power_alignment(cx, item);
-            }
-            // See `check_field_def`..
-            hir::ItemKind::Union(..) | hir::ItemKind::Enum(..) => {}
-            // Doesn't define something that can contain a external type to be checked.
-            hir::ItemKind::Impl(..)
-            | hir::ItemKind::TraitAlias(..)
-            | hir::ItemKind::Trait(..)
-            | hir::ItemKind::GlobalAsm { .. }
-            | hir::ItemKind::ForeignMod { .. }
-            | hir::ItemKind::Mod(..)
-            | hir::ItemKind::Macro(..)
-            | hir::ItemKind::Use(..)
-            | hir::ItemKind::ExternCrate(..) => {}
-        }
-    }
-
-    fn check_field_def(&mut self, cx: &LateContext<'tcx>, field: &'tcx hir::FieldDef<'tcx>) {
-        self.check_ty_maybe_containing_foreign_fnptr(
-            cx,
-            field.ty,
-            cx.tcx.type_of(field.def_id).instantiate_identity(),
-        );
-    }
-
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'tcx>,
-        kind: hir::intravisit::FnKind<'tcx>,
-        decl: &'tcx hir::FnDecl<'_>,
-        _: &'tcx hir::Body<'_>,
-        _: Span,
-        id: LocalDefId,
-    ) {
-        use hir::intravisit::FnKind;
-
-        let abi = match kind {
-            FnKind::ItemFn(_, _, header, ..) => header.abi,
-            FnKind::Method(_, sig, ..) => sig.header.abi,
-            _ => return,
-        };
-
-        let mut vis = ImproperCTypesVisitor { cx, mode: CItemKind::Definition };
-        if abi.is_rustic_abi() {
-            vis.check_fn(id, decl);
-        } else {
-            vis.check_foreign_fn(id, decl);
-        }
-    }
-}
-
 declare_lint_pass!(VariantSizeDifferences => [VARIANT_SIZE_DIFFERENCES]);
 
 impl<'tcx> LateLintPass<'tcx> for VariantSizeDifferences {
diff --git a/compiler/rustc_lint/src/types/improper_ctypes.rs b/compiler/rustc_lint/src/types/improper_ctypes.rs
index 13afa540afcf6..6f732fc2a50c8 100644
--- a/compiler/rustc_lint/src/types/improper_ctypes.rs
+++ b/compiler/rustc_lint/src/types/improper_ctypes.rs
@@ -1,10 +1,140 @@
+use std::iter;
 use std::ops::ControlFlow;
 
+use rustc_abi::VariantIdx;
+use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::DiagMessage;
 use rustc_hir::def::CtorKind;
-use rustc_middle::ty;
+use rustc_hir::intravisit::VisitorExt;
+use rustc_hir::{self as hir, AmbigArg};
+use rustc_middle::bug;
+use rustc_middle::ty::{
+    self, Adt, AdtKind, GenericArgsRef, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable,
+    TypeVisitableExt,
+};
+use rustc_session::{declare_lint, declare_lint_pass};
+use rustc_span::def_id::LocalDefId;
+use rustc_span::{Span, sym};
+use tracing::debug;
+
+use super::repr_nullable_ptr;
+use crate::lints::{ImproperCTypes, UsesPowerAlignment};
+use crate::{LateContext, LateLintPass, LintContext, fluent_generated as fluent};
+
+
+declare_lint! {
+    /// The `improper_ctypes` lint detects incorrect use of types in foreign
+    /// modules.
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// unsafe extern "C" {
+    ///     static STATIC: String;
+    /// }
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// The compiler has several checks to verify that types used in `extern`
+    /// blocks are safe and follow certain rules to ensure proper
+    /// compatibility with the foreign interfaces. This lint is issued when it
+    /// detects a probable mistake in a definition. The lint usually should
+    /// provide a description of the issue, along with possibly a hint on how
+    /// to resolve it.
+    IMPROPER_CTYPES,
+    Warn,
+    "proper use of libc types in foreign modules"
+}
+
+declare_lint_pass!(ImproperCTypesDeclarations => [IMPROPER_CTYPES]);
+
+declare_lint! {
+    /// The `improper_ctypes_definitions` lint detects incorrect use of
+    /// [`extern` function] definitions.
+    ///
+    /// [`extern` function]: https://doc.rust-lang.org/reference/items/functions.html#extern-function-qualifier
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// # #![allow(unused)]
+    /// pub extern "C" fn str_type(p: &str) { }
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// There are many parameter and return types that may be specified in an
+    /// `extern` function that are not compatible with the given ABI. This
+    /// lint is an alert that these types should not be used. The lint usually
+    /// should provide a description of the issue, along with possibly a hint
+    /// on how to resolve it.
+    IMPROPER_CTYPES_DEFINITIONS,
+    Warn,
+    "proper use of libc types in foreign item definitions"
+}
+
+declare_lint! {
+    /// The `uses_power_alignment` lint detects specific `repr(C)`
+    /// aggregates on AIX.
+    /// In its platform C ABI, AIX uses the "power" (as in PowerPC) alignment
+    /// rule (detailed in https://www.ibm.com/docs/en/xl-c-and-cpp-aix/16.1?topic=data-using-alignment-modes#alignment),
+    /// which can also be set for XLC by `#pragma align(power)` or
+    /// `-qalign=power`. Aggregates with a floating-point type as the
+    /// recursively first field (as in "at offset 0") modify the layout of
+    /// *subsequent* fields of the associated structs to use an alignment value
+    /// where the floating-point type is aligned on a 4-byte boundary.
+    ///
+    /// Effectively, subsequent floating-point fields act as-if they are `repr(packed(4))`. This
+    /// would be unsound to do in a `repr(C)` type without all the restrictions that come with
+    /// `repr(packed)`. Rust instead chooses a layout that maintains soundness of Rust code, at the
+    /// expense of incompatibility with C code.
+    ///
+    /// ### Example
+    ///
+    /// ```rust,ignore (fails on non-powerpc64-ibm-aix)
+    /// #[repr(C)]
+    /// pub struct Floats {
+    ///     a: f64,
+    ///     b: u8,
+    ///     c: f64,
+    /// }
+    /// ```
+    ///
+    /// This will produce:
+    ///
+    /// ```text
+    /// warning: repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+    ///  --> <source>:5:3
+    ///   |
+    /// 5 |   c: f64,
+    ///   |   ^^^^^^
+    ///   |
+    ///   = note: `#[warn(uses_power_alignment)]` on by default
+    /// ```
+    ///
+    /// ### Explanation
+    ///
+    /// The power alignment rule specifies that the above struct has the
+    /// following alignment:
+    ///  - offset_of!(Floats, a) == 0
+    ///  - offset_of!(Floats, b) == 8
+    ///  - offset_of!(Floats, c) == 12
+    ///
+    /// However, Rust currently aligns `c` at `offset_of!(Floats, c) == 16`.
+    /// Using offset 12 would be unsound since `f64` generally must be 8-aligned on this target.
+    /// Thus, a warning is produced for the above struct.
+    USES_POWER_ALIGNMENT,
+    Warn,
+    "Structs do not follow the power alignment rule under repr(C)"
+}
+
+declare_lint_pass!(ImproperCTypesDefinitions => [IMPROPER_CTYPES_DEFINITIONS, USES_POWER_ALIGNMENT]);
 
-use crate::fluent_generated as fluent;
 
 /// Check a variant of a non-exhaustive enum for improper ctypes
 ///
@@ -41,3 +171,730 @@ fn variant_has_complex_ctor(variant: &ty::VariantDef) -> bool {
     // CtorKind::Const means a "unit" ctor
     !matches!(variant.ctor_kind(), Some(CtorKind::Const))
 }
+
+#[derive(Clone, Copy)]
+pub(crate) enum CItemKind {
+    Declaration,
+    Definition,
+}
+
+enum FfiResult<'tcx> {
+    FfiSafe,
+    FfiPhantom(Ty<'tcx>),
+    FfiUnsafe { ty: Ty<'tcx>, reason: DiagMessage, help: Option<DiagMessage> },
+}
+
+struct ImproperCTypesVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'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>,
+}
+
+impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
+    /// Check if the type is array and emit an unsafe type lint.
+    fn check_for_array_ty(&mut self, sp: Span, ty: Ty<'tcx>) -> bool {
+        if let ty::Array(..) = ty.kind() {
+            self.emit_ffi_unsafe_type_lint(
+                ty,
+                sp,
+                fluent::lint_improper_ctypes_array_reason,
+                Some(fluent::lint_improper_ctypes_array_help),
+            );
+            true
+        } else {
+            false
+        }
+    }
+
+    /// Checks if the given field's type is "ffi-safe".
+    fn check_field_type_for_ffi(
+        &self,
+        acc: &mut CTypesVisitorState<'tcx>,
+        field: &ty::FieldDef,
+        args: GenericArgsRef<'tcx>,
+    ) -> FfiResult<'tcx> {
+        let field_ty = field.ty(self.cx.tcx, args);
+        let field_ty = self
+            .cx
+            .tcx
+            .try_normalize_erasing_regions(self.cx.typing_env(), field_ty)
+            .unwrap_or(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,
+        acc: &mut CTypesVisitorState<'tcx>,
+        ty: Ty<'tcx>,
+        def: ty::AdtDef<'tcx>,
+        variant: &ty::VariantDef,
+        args: GenericArgsRef<'tcx>,
+    ) -> FfiResult<'tcx> {
+        use FfiResult::*;
+        let transparent_with_all_zst_fields = if def.repr().transparent() {
+            if let Some(field) = super::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(acc, field, args) {
+                    FfiUnsafe { ty, .. } if ty.is_unit() => (),
+                    r => return r,
+                }
+
+                false
+            } else {
+                // ..or have only ZST fields, which is FFI-unsafe (unless those fields are all
+                // `PhantomData`).
+                true
+            }
+        } else {
+            false
+        };
+
+        // 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(acc, field, args) {
+                FfiSafe => false,
+                // `()` fields are FFI-safe!
+                FfiUnsafe { ty, .. } if ty.is_unit() => false,
+                FfiPhantom(..) => true,
+                r @ FfiUnsafe { .. } => return r,
+            }
+        }
+
+        if all_phantom {
+            FfiPhantom(ty)
+        } else if transparent_with_all_zst_fields {
+            FfiUnsafe { ty, reason: fluent::lint_improper_ctypes_struct_zst, help: None }
+        } else {
+            FfiSafe
+        }
+    }
+
+    /// 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,
+        acc: &mut CTypesVisitorState<'tcx>,
+        ty: Ty<'tcx>,
+    ) -> FfiResult<'tcx> {
+        use FfiResult::*;
+
+        let tcx = self.cx.tcx;
+
+        // Protect against infinite recursion, for example
+        // `struct S(*mut S);`.
+        // FIXME: A recursion limit is necessary as well, for irregular
+        // recursive types.
+        if !acc.cache.insert(ty) {
+            return FfiSafe;
+        }
+
+        match *ty.kind() {
+            ty::Adt(def, args) => {
+                if let Some(boxed) = ty.boxed_ty()
+                    && matches!(self.mode, CItemKind::Definition)
+                {
+                    if boxed.is_sized(tcx, self.cx.typing_env()) {
+                        return FfiSafe;
+                    } else {
+                        return FfiUnsafe {
+                            ty,
+                            reason: fluent::lint_improper_ctypes_box,
+                            help: None,
+                        };
+                    }
+                }
+                if def.is_phantom_data() {
+                    return FfiPhantom(ty);
+                }
+                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,
+                                reason: if def.is_struct() {
+                                    fluent::lint_improper_ctypes_struct_layout_reason
+                                } else {
+                                    fluent::lint_improper_ctypes_union_layout_reason
+                                },
+                                help: if def.is_struct() {
+                                    Some(fluent::lint_improper_ctypes_struct_layout_help)
+                                } else {
+                                    Some(fluent::lint_improper_ctypes_union_layout_help)
+                                },
+                            };
+                        }
+
+                        if def.non_enum_variant().field_list_has_applicable_non_exhaustive() {
+                            return FfiUnsafe {
+                                ty,
+                                reason: if def.is_struct() {
+                                    fluent::lint_improper_ctypes_struct_non_exhaustive
+                                } else {
+                                    fluent::lint_improper_ctypes_union_non_exhaustive
+                                },
+                                help: None,
+                            };
+                        }
+
+                        if def.non_enum_variant().fields.is_empty() {
+                            return FfiUnsafe {
+                                ty,
+                                reason: if def.is_struct() {
+                                    fluent::lint_improper_ctypes_struct_fieldless_reason
+                                } else {
+                                    fluent::lint_improper_ctypes_union_fieldless_reason
+                                },
+                                help: if def.is_struct() {
+                                    Some(fluent::lint_improper_ctypes_struct_fieldless_help)
+                                } else {
+                                    Some(fluent::lint_improper_ctypes_union_fieldless_help)
+                                },
+                            };
+                        }
+
+                        self.check_variant_for_ffi(acc, ty, def, def.non_enum_variant(), args)
+                    }
+                    AdtKind::Enum => {
+                        if def.variants().is_empty() {
+                            // Empty enums are okay... although sort of useless.
+                            return FfiSafe;
+                        }
+                        // Check for a repr() attribute to specify the size of the
+                        // discriminant.
+                        if !def.repr().c() && !def.repr().transparent() && def.repr().int.is_none()
+                        {
+                            // Special-case types like `Option<extern fn()>` and `Result<extern fn(), ()>`
+                            if let Some(ty) =
+                                repr_nullable_ptr(self.cx.tcx, self.cx.typing_env(), ty, self.mode)
+                            {
+                                return self.check_type_for_ffi(acc, ty);
+                            }
+
+                            return FfiUnsafe {
+                                ty,
+                                reason: fluent::lint_improper_ctypes_enum_repr_reason,
+                                help: Some(fluent::lint_improper_ctypes_enum_repr_help),
+                            };
+                        }
+
+                        let non_exhaustive = def.variant_list_has_applicable_non_exhaustive();
+                        // Check the contained variants.
+                        let ret = def.variants().iter().try_for_each(|variant| {
+                            check_non_exhaustive_variant(non_exhaustive, variant)
+                                .map_break(|reason| FfiUnsafe { ty, reason, help: None })?;
+
+                            match self.check_variant_for_ffi(acc, ty, def, variant, args) {
+                                FfiSafe => ControlFlow::Continue(()),
+                                r => ControlFlow::Break(r),
+                            }
+                        });
+                        if let ControlFlow::Break(result) = ret {
+                            return result;
+                        }
+
+                        FfiSafe
+                    }
+                }
+            }
+
+            ty::Char => FfiUnsafe {
+                ty,
+                reason: fluent::lint_improper_ctypes_char_reason,
+                help: Some(fluent::lint_improper_ctypes_char_help),
+            },
+
+            // It's just extra invariants on the type that you need to uphold,
+            // but only the base type is relevant for being representable in FFI.
+            ty::Pat(base, ..) => self.check_type_for_ffi(acc, base),
+
+            // Primitive types with a stable representation.
+            ty::Bool | ty::Int(..) | ty::Uint(..) | ty::Float(..) | ty::Never => FfiSafe,
+
+            ty::Slice(_) => FfiUnsafe {
+                ty,
+                reason: fluent::lint_improper_ctypes_slice_reason,
+                help: Some(fluent::lint_improper_ctypes_slice_help),
+            },
+
+            ty::Dynamic(..) => {
+                FfiUnsafe { ty, reason: fluent::lint_improper_ctypes_dyn, help: None }
+            }
+
+            ty::Str => FfiUnsafe {
+                ty,
+                reason: fluent::lint_improper_ctypes_str_reason,
+                help: Some(fluent::lint_improper_ctypes_str_help),
+            },
+
+            ty::Tuple(..) => FfiUnsafe {
+                ty,
+                reason: fluent::lint_improper_ctypes_tuple_reason,
+                help: Some(fluent::lint_improper_ctypes_tuple_help),
+            },
+
+            ty::RawPtr(ty, _) | ty::Ref(_, ty, _)
+                if {
+                    matches!(self.mode, CItemKind::Definition)
+                        && ty.is_sized(self.cx.tcx, self.cx.typing_env())
+                } =>
+            {
+                FfiSafe
+            }
+
+            ty::RawPtr(ty, _)
+                if match ty.kind() {
+                    ty::Tuple(tuple) => tuple.is_empty(),
+                    _ => false,
+                } =>
+            {
+                FfiSafe
+            }
+
+            ty::RawPtr(ty, _) | ty::Ref(_, ty, _) => self.check_type_for_ffi(acc, ty),
+
+            ty::Array(inner_ty, _) => self.check_type_for_ffi(acc, inner_ty),
+
+            ty::FnPtr(sig_tys, hdr) => {
+                let sig = sig_tys.with(hdr);
+                if sig.abi().is_rustic_abi() {
+                    return FfiUnsafe {
+                        ty,
+                        reason: fluent::lint_improper_ctypes_fnptr_reason,
+                        help: Some(fluent::lint_improper_ctypes_fnptr_help),
+                    };
+                }
+
+                let sig = tcx.instantiate_bound_regions_with_erased(sig);
+                for arg in sig.inputs() {
+                    match self.check_type_for_ffi(acc, *arg) {
+                        FfiSafe => {}
+                        r => return r,
+                    }
+                }
+
+                let ret_ty = sig.output();
+                if ret_ty.is_unit() {
+                    return FfiSafe;
+                }
+
+                self.check_type_for_ffi(acc, ret_ty)
+            }
+
+            ty::Foreign(..) => FfiSafe,
+
+            // While opaque types are checked for earlier, if a projection in a struct field
+            // normalizes to an opaque type, then it will reach this branch.
+            ty::Alias(ty::Opaque, ..) => {
+                FfiUnsafe { ty, reason: fluent::lint_improper_ctypes_opaque, help: None }
+            }
+
+            // `extern "C" fn` functions can have type parameters, which may or may not be FFI-safe,
+            //  so they are currently ignored for the purposes of this lint.
+            ty::Param(..) | ty::Alias(ty::Projection | ty::Inherent, ..)
+                if matches!(self.mode, CItemKind::Definition) =>
+            {
+                FfiSafe
+            }
+
+            ty::UnsafeBinder(_) => todo!("FIXME(unsafe_binder)"),
+
+            ty::Param(..)
+            | ty::Alias(ty::Projection | ty::Inherent | ty::Free, ..)
+            | ty::Infer(..)
+            | ty::Bound(..)
+            | ty::Error(_)
+            | ty::Closure(..)
+            | ty::CoroutineClosure(..)
+            | ty::Coroutine(..)
+            | ty::CoroutineWitness(..)
+            | ty::Placeholder(..)
+            | ty::FnDef(..) => bug!("unexpected type in foreign function: {:?}", ty),
+        }
+    }
+
+    fn emit_ffi_unsafe_type_lint(
+        &mut self,
+        ty: Ty<'tcx>,
+        sp: Span,
+        note: DiagMessage,
+        help: Option<DiagMessage>,
+    ) {
+        let lint = match self.mode {
+            CItemKind::Declaration => IMPROPER_CTYPES,
+            CItemKind::Definition => IMPROPER_CTYPES_DEFINITIONS,
+        };
+        let desc = match self.mode {
+            CItemKind::Declaration => "block",
+            CItemKind::Definition => "fn",
+        };
+        let span_note = if let ty::Adt(def, _) = ty.kind()
+            && let Some(sp) = self.cx.tcx.hir_span_if_local(def.did())
+        {
+            Some(sp)
+        } else {
+            None
+        };
+        self.cx.emit_span_lint(
+            lint,
+            sp,
+            ImproperCTypes { ty, desc, label: sp, help, note, span_note },
+        );
+    }
+
+    fn check_for_opaque_ty(&mut self, sp: Span, ty: Ty<'tcx>) -> bool {
+        struct ProhibitOpaqueTypes;
+        impl<'tcx> ty::TypeVisitor<TyCtxt<'tcx>> for ProhibitOpaqueTypes {
+            type Result = ControlFlow<Ty<'tcx>>;
+
+            fn visit_ty(&mut self, ty: Ty<'tcx>) -> Self::Result {
+                if !ty.has_opaque_types() {
+                    return ControlFlow::Continue(());
+                }
+
+                if let ty::Alias(ty::Opaque, ..) = ty.kind() {
+                    ControlFlow::Break(ty)
+                } else {
+                    ty.super_visit_with(self)
+                }
+            }
+        }
+
+        if let Some(ty) = self
+            .cx
+            .tcx
+            .try_normalize_erasing_regions(self.cx.typing_env(), ty)
+            .unwrap_or(ty)
+            .visit_with(&mut ProhibitOpaqueTypes)
+            .break_value()
+        {
+            self.emit_ffi_unsafe_type_lint(ty, sp, fluent::lint_improper_ctypes_opaque, None);
+            true
+        } else {
+            false
+        }
+    }
+
+    fn check_type_for_ffi_and_report_errors(
+        &mut self,
+        sp: Span,
+        ty: Ty<'tcx>,
+        is_static: bool,
+        is_return_type: bool,
+    ) {
+        if self.check_for_opaque_ty(sp, ty) {
+            // We've already emitted an error due to an opaque type.
+            return;
+        }
+
+        let ty = self.cx.tcx.try_normalize_erasing_regions(self.cx.typing_env(), ty).unwrap_or(ty);
+
+        // C doesn't really support passing arrays by value - the only way to pass an array by value
+        // is through a struct. So, first test that the top level isn't an array, and then
+        // recursively check the types inside.
+        if !is_static && self.check_for_array_ty(sp, ty) {
+            return;
+        }
+
+        // Don't report FFI errors for unit return types. This check exists here, and not in
+        // the caller (where it would make more sense) so that normalization has definitely
+        // happened.
+        if is_return_type && ty.is_unit() {
+            return;
+        }
+
+        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(
+                    ty,
+                    sp,
+                    fluent::lint_improper_ctypes_only_phantomdata,
+                    None,
+                );
+            }
+            FfiResult::FfiUnsafe { ty, reason, help } => {
+                self.emit_ffi_unsafe_type_lint(ty, sp, reason, help);
+            }
+        }
+    }
+
+    /// Check if a function's argument types and result type are "ffi-safe".
+    ///
+    /// For a external ABI function, argument types and the result type are walked to find fn-ptr
+    /// types that have external ABIs, as these still need checked.
+    fn check_fn(&mut self, def_id: LocalDefId, decl: &'tcx hir::FnDecl<'_>) {
+        let sig = self.cx.tcx.fn_sig(def_id).instantiate_identity();
+        let sig = self.cx.tcx.instantiate_bound_regions_with_erased(sig);
+
+        for (input_ty, input_hir) in iter::zip(sig.inputs(), decl.inputs) {
+            for (fn_ptr_ty, span) in self.find_fn_ptr_ty_with_external_abi(input_hir, *input_ty) {
+                self.check_type_for_ffi_and_report_errors(span, fn_ptr_ty, false, false);
+            }
+        }
+
+        if let hir::FnRetTy::Return(ret_hir) = decl.output {
+            for (fn_ptr_ty, span) in self.find_fn_ptr_ty_with_external_abi(ret_hir, sig.output()) {
+                self.check_type_for_ffi_and_report_errors(span, fn_ptr_ty, false, true);
+            }
+        }
+    }
+
+    /// Check if a function's argument types and result type are "ffi-safe".
+    fn check_foreign_fn(&mut self, def_id: LocalDefId, decl: &'tcx hir::FnDecl<'_>) {
+        let sig = self.cx.tcx.fn_sig(def_id).instantiate_identity();
+        let sig = self.cx.tcx.instantiate_bound_regions_with_erased(sig);
+
+        for (input_ty, input_hir) in iter::zip(sig.inputs(), decl.inputs) {
+            self.check_type_for_ffi_and_report_errors(input_hir.span, *input_ty, false, false);
+        }
+
+        if let hir::FnRetTy::Return(ret_hir) = decl.output {
+            self.check_type_for_ffi_and_report_errors(ret_hir.span, sig.output(), false, true);
+        }
+    }
+
+    fn check_foreign_static(&mut self, id: hir::OwnerId, span: Span) {
+        let ty = self.cx.tcx.type_of(id).instantiate_identity();
+        self.check_type_for_ffi_and_report_errors(span, ty, true, false);
+    }
+
+    /// Find any fn-ptr types with external ABIs in `ty`.
+    ///
+    /// For example, `Option<extern "C" fn()>` returns `extern "C" fn()`
+    fn find_fn_ptr_ty_with_external_abi(
+        &self,
+        hir_ty: &hir::Ty<'tcx>,
+        ty: Ty<'tcx>,
+    ) -> Vec<(Ty<'tcx>, Span)> {
+        struct FnPtrFinder<'tcx> {
+            spans: Vec<Span>,
+            tys: Vec<Ty<'tcx>>,
+        }
+
+        impl<'tcx> hir::intravisit::Visitor<'_> for FnPtrFinder<'tcx> {
+            fn visit_ty(&mut self, ty: &'_ hir::Ty<'_, AmbigArg>) {
+                debug!(?ty);
+                if let hir::TyKind::FnPtr(hir::FnPtrTy { abi, .. }) = ty.kind
+                    && !abi.is_rustic_abi()
+                {
+                    self.spans.push(ty.span);
+                }
+
+                hir::intravisit::walk_ty(self, ty)
+            }
+        }
+
+        impl<'tcx> ty::TypeVisitor<TyCtxt<'tcx>> for FnPtrFinder<'tcx> {
+            type Result = ();
+
+            fn visit_ty(&mut self, ty: Ty<'tcx>) -> Self::Result {
+                if let ty::FnPtr(_, hdr) = ty.kind()
+                    && !hdr.abi.is_rustic_abi()
+                {
+                    self.tys.push(ty);
+                }
+
+                ty.super_visit_with(self)
+            }
+        }
+
+        let mut visitor = FnPtrFinder { spans: Vec::new(), tys: Vec::new() };
+        ty.visit_with(&mut visitor);
+        visitor.visit_ty_unambig(hir_ty);
+
+        iter::zip(visitor.tys.drain(..), visitor.spans.drain(..)).collect()
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for ImproperCTypesDeclarations {
+    fn check_foreign_item(&mut self, cx: &LateContext<'tcx>, it: &hir::ForeignItem<'tcx>) {
+        let mut vis = ImproperCTypesVisitor { cx, mode: CItemKind::Declaration };
+        let abi = cx.tcx.hir_get_foreign_abi(it.hir_id());
+
+        match it.kind {
+            hir::ForeignItemKind::Fn(sig, _, _) => {
+                if abi.is_rustic_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 !abi.is_rustic_abi() => {
+                vis.check_foreign_static(it.owner_id, ty.span);
+            }
+            hir::ForeignItemKind::Static(..) | hir::ForeignItemKind::Type => (),
+        }
+    }
+}
+
+impl ImproperCTypesDefinitions {
+    fn check_ty_maybe_containing_foreign_fnptr<'tcx>(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        hir_ty: &'tcx hir::Ty<'_>,
+        ty: Ty<'tcx>,
+    ) {
+        let mut vis = ImproperCTypesVisitor { cx, mode: CItemKind::Definition };
+        for (fn_ptr_ty, span) in vis.find_fn_ptr_ty_with_external_abi(hir_ty, ty) {
+            vis.check_type_for_ffi_and_report_errors(span, fn_ptr_ty, true, false);
+        }
+    }
+
+    fn check_arg_for_power_alignment<'tcx>(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        ty: Ty<'tcx>,
+    ) -> bool {
+        assert!(cx.tcx.sess.target.os == "aix");
+        // Structs (under repr(C)) follow the power alignment rule if:
+        //   - the first field of the struct is a floating-point type that
+        //     is greater than 4-bytes, or
+        //   - the first field of the struct is an aggregate whose
+        //     recursively first field is a floating-point type greater than
+        //     4 bytes.
+        if ty.is_floating_point() && ty.primitive_size(cx.tcx).bytes() > 4 {
+            return true;
+        } else if let Adt(adt_def, _) = ty.kind()
+            && adt_def.is_struct()
+            && adt_def.repr().c()
+            && !adt_def.repr().packed()
+            && adt_def.repr().align.is_none()
+        {
+            let struct_variant = adt_def.variant(VariantIdx::ZERO);
+            // Within a nested struct, all fields are examined to correctly
+            // report if any fields after the nested struct within the
+            // original struct are misaligned.
+            for struct_field in &struct_variant.fields {
+                let field_ty = cx.tcx.type_of(struct_field.did).instantiate_identity();
+                if self.check_arg_for_power_alignment(cx, field_ty) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    fn check_struct_for_power_alignment<'tcx>(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        item: &'tcx hir::Item<'tcx>,
+    ) {
+        let adt_def = cx.tcx.adt_def(item.owner_id.to_def_id());
+        // repr(C) structs also with packed or aligned representation
+        // should be ignored.
+        if adt_def.repr().c()
+            && !adt_def.repr().packed()
+            && adt_def.repr().align.is_none()
+            && cx.tcx.sess.target.os == "aix"
+            && !adt_def.all_fields().next().is_none()
+        {
+            let struct_variant_data = item.expect_struct().2;
+            for field_def in struct_variant_data.fields().iter().skip(1) {
+                // Struct fields (after the first field) are checked for the
+                // power alignment rule, as fields after the first are likely
+                // to be the fields that are misaligned.
+                let def_id = field_def.def_id;
+                let ty = cx.tcx.type_of(def_id).instantiate_identity();
+                if self.check_arg_for_power_alignment(cx, ty) {
+                    cx.emit_span_lint(USES_POWER_ALIGNMENT, field_def.span, UsesPowerAlignment);
+                }
+            }
+        }
+    }
+}
+
+/// `ImproperCTypesDefinitions` checks items outside of foreign items (e.g. stuff that isn't in
+/// `extern "C" { }` blocks):
+///
+/// - `extern "<abi>" fn` definitions are checked in the same way as the
+///   `ImproperCtypesDeclarations` visitor checks functions if `<abi>` is external (e.g. "C").
+/// - All other items which contain types (e.g. other functions, struct definitions, etc) are
+///   checked for extern fn-ptrs with external ABIs.
+impl<'tcx> LateLintPass<'tcx> for ImproperCTypesDefinitions {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'tcx>) {
+        match item.kind {
+            hir::ItemKind::Static(_, _, ty, _)
+            | hir::ItemKind::Const(_, _, ty, _)
+            | hir::ItemKind::TyAlias(_, _, ty) => {
+                self.check_ty_maybe_containing_foreign_fnptr(
+                    cx,
+                    ty,
+                    cx.tcx.type_of(item.owner_id).instantiate_identity(),
+                );
+            }
+            // See `check_fn`..
+            hir::ItemKind::Fn { .. } => {}
+            // Structs are checked based on if they follow the power alignment
+            // rule (under repr(C)).
+            hir::ItemKind::Struct(..) => {
+                self.check_struct_for_power_alignment(cx, item);
+            }
+            // See `check_field_def`..
+            hir::ItemKind::Union(..) | hir::ItemKind::Enum(..) => {}
+            // Doesn't define something that can contain a external type to be checked.
+            hir::ItemKind::Impl(..)
+            | hir::ItemKind::TraitAlias(..)
+            | hir::ItemKind::Trait(..)
+            | hir::ItemKind::GlobalAsm { .. }
+            | hir::ItemKind::ForeignMod { .. }
+            | hir::ItemKind::Mod(..)
+            | hir::ItemKind::Macro(..)
+            | hir::ItemKind::Use(..)
+            | hir::ItemKind::ExternCrate(..) => {}
+        }
+    }
+
+    fn check_field_def(&mut self, cx: &LateContext<'tcx>, field: &'tcx hir::FieldDef<'tcx>) {
+        self.check_ty_maybe_containing_foreign_fnptr(
+            cx,
+            field.ty,
+            cx.tcx.type_of(field.def_id).instantiate_identity(),
+        );
+    }
+
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        kind: hir::intravisit::FnKind<'tcx>,
+        decl: &'tcx hir::FnDecl<'_>,
+        _: &'tcx hir::Body<'_>,
+        _: Span,
+        id: LocalDefId,
+    ) {
+        use hir::intravisit::FnKind;
+
+        let abi = match kind {
+            FnKind::ItemFn(_, _, header, ..) => header.abi,
+            FnKind::Method(_, sig, ..) => sig.header.abi,
+            _ => return,
+        };
+
+        let mut vis = ImproperCTypesVisitor { cx, mode: CItemKind::Definition };
+        if abi.is_rustic_abi() {
+            vis.check_fn(id, decl);
+        } else {
+            vis.check_foreign_fn(id, decl);
+        }
+    }
+}
diff --git a/tests/ui/lint/improper_ctypes/allow-phantomdata-in-ffi.rs b/tests/ui/lint/improper-ctypes/allow-phantomdata-in-ffi.rs
similarity index 100%
rename from tests/ui/lint/improper_ctypes/allow-phantomdata-in-ffi.rs
rename to tests/ui/lint/improper-ctypes/allow-phantomdata-in-ffi.rs
diff --git a/tests/ui/lint/lint-ctypes-113436-1.rs b/tests/ui/lint/improper-ctypes/lint-113436-1.rs
similarity index 100%
rename from tests/ui/lint/lint-ctypes-113436-1.rs
rename to tests/ui/lint/improper-ctypes/lint-113436-1.rs
diff --git a/tests/ui/lint/lint-ctypes-113436-1.stderr b/tests/ui/lint/improper-ctypes/lint-113436-1.stderr
similarity index 82%
rename from tests/ui/lint/lint-ctypes-113436-1.stderr
rename to tests/ui/lint/improper-ctypes/lint-113436-1.stderr
index 7b63043f05756..f01dc3b6e0d1e 100644
--- a/tests/ui/lint/lint-ctypes-113436-1.stderr
+++ b/tests/ui/lint/improper-ctypes/lint-113436-1.stderr
@@ -1,5 +1,5 @@
 error: `extern` fn uses type `NotSafe`, which is not FFI-safe
-  --> $DIR/lint-ctypes-113436-1.rs:22:22
+  --> $DIR/lint-113436-1.rs:22:22
    |
 LL | extern "C" fn bar(x: Bar) -> Bar {
    |                      ^^^ not FFI-safe
@@ -7,18 +7,18 @@ LL | extern "C" fn bar(x: Bar) -> Bar {
    = help: consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct
    = note: this struct has unspecified layout
 note: the type is defined here
-  --> $DIR/lint-ctypes-113436-1.rs:13:1
+  --> $DIR/lint-113436-1.rs:13:1
    |
 LL | struct NotSafe(u32);
    | ^^^^^^^^^^^^^^
 note: the lint level is defined here
-  --> $DIR/lint-ctypes-113436-1.rs:1:9
+  --> $DIR/lint-113436-1.rs:1:9
    |
 LL | #![deny(improper_ctypes_definitions)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `extern` fn uses type `NotSafe`, which is not FFI-safe
-  --> $DIR/lint-ctypes-113436-1.rs:22:30
+  --> $DIR/lint-113436-1.rs:22:30
    |
 LL | extern "C" fn bar(x: Bar) -> Bar {
    |                              ^^^ not FFI-safe
@@ -26,7 +26,7 @@ LL | extern "C" fn bar(x: Bar) -> Bar {
    = help: consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct
    = note: this struct has unspecified layout
 note: the type is defined here
-  --> $DIR/lint-ctypes-113436-1.rs:13:1
+  --> $DIR/lint-113436-1.rs:13:1
    |
 LL | struct NotSafe(u32);
    | ^^^^^^^^^^^^^^
diff --git a/tests/ui/lint/lint-ctypes-73249-2.rs b/tests/ui/lint/improper-ctypes/lint-73249-2.rs
similarity index 100%
rename from tests/ui/lint/lint-ctypes-73249-2.rs
rename to tests/ui/lint/improper-ctypes/lint-73249-2.rs
diff --git a/tests/ui/lint/lint-ctypes-73249-2.stderr b/tests/ui/lint/improper-ctypes/lint-73249-2.stderr
similarity index 81%
rename from tests/ui/lint/lint-ctypes-73249-2.stderr
rename to tests/ui/lint/improper-ctypes/lint-73249-2.stderr
index 2d0dfe94f097e..d6c1cec2bd6c1 100644
--- a/tests/ui/lint/lint-ctypes-73249-2.stderr
+++ b/tests/ui/lint/improper-ctypes/lint-73249-2.stderr
@@ -1,12 +1,12 @@
 error: `extern` block uses type `Qux`, which is not FFI-safe
-  --> $DIR/lint-ctypes-73249-2.rs:27:21
+  --> $DIR/lint-73249-2.rs:27:21
    |
 LL |     fn lint_me() -> A<()>;
    |                     ^^^^^ not FFI-safe
    |
    = note: opaque types have no C equivalent
 note: the lint level is defined here
-  --> $DIR/lint-ctypes-73249-2.rs:2:9
+  --> $DIR/lint-73249-2.rs:2:9
    |
 LL | #![deny(improper_ctypes)]
    |         ^^^^^^^^^^^^^^^
diff --git a/tests/ui/lint/lint-ctypes-73249-3.rs b/tests/ui/lint/improper-ctypes/lint-73249-3.rs
similarity index 100%
rename from tests/ui/lint/lint-ctypes-73249-3.rs
rename to tests/ui/lint/improper-ctypes/lint-73249-3.rs
diff --git a/tests/ui/lint/lint-ctypes-73249-5.stderr b/tests/ui/lint/improper-ctypes/lint-73249-3.stderr
similarity index 81%
rename from tests/ui/lint/lint-ctypes-73249-5.stderr
rename to tests/ui/lint/improper-ctypes/lint-73249-3.stderr
index c4fa955de05ed..ebc9eb5eb8274 100644
--- a/tests/ui/lint/lint-ctypes-73249-5.stderr
+++ b/tests/ui/lint/improper-ctypes/lint-73249-3.stderr
@@ -1,12 +1,12 @@
 error: `extern` block uses type `Qux`, which is not FFI-safe
-  --> $DIR/lint-ctypes-73249-5.rs:21:25
+  --> $DIR/lint-73249-3.rs:21:25
    |
 LL |     pub fn lint_me() -> A;
    |                         ^ not FFI-safe
    |
    = note: opaque types have no C equivalent
 note: the lint level is defined here
-  --> $DIR/lint-ctypes-73249-5.rs:2:9
+  --> $DIR/lint-73249-3.rs:2:9
    |
 LL | #![deny(improper_ctypes)]
    |         ^^^^^^^^^^^^^^^
diff --git a/tests/ui/lint/lint-ctypes-73249-5.rs b/tests/ui/lint/improper-ctypes/lint-73249-5.rs
similarity index 100%
rename from tests/ui/lint/lint-ctypes-73249-5.rs
rename to tests/ui/lint/improper-ctypes/lint-73249-5.rs
diff --git a/tests/ui/lint/lint-ctypes-73249-3.stderr b/tests/ui/lint/improper-ctypes/lint-73249-5.stderr
similarity index 81%
rename from tests/ui/lint/lint-ctypes-73249-3.stderr
rename to tests/ui/lint/improper-ctypes/lint-73249-5.stderr
index e1a313a290651..484927f57fead 100644
--- a/tests/ui/lint/lint-ctypes-73249-3.stderr
+++ b/tests/ui/lint/improper-ctypes/lint-73249-5.stderr
@@ -1,12 +1,12 @@
 error: `extern` block uses type `Qux`, which is not FFI-safe
-  --> $DIR/lint-ctypes-73249-3.rs:21:25
+  --> $DIR/lint-73249-5.rs:21:25
    |
 LL |     pub fn lint_me() -> A;
    |                         ^ not FFI-safe
    |
    = note: opaque types have no C equivalent
 note: the lint level is defined here
-  --> $DIR/lint-ctypes-73249-3.rs:2:9
+  --> $DIR/lint-73249-5.rs:2:9
    |
 LL | #![deny(improper_ctypes)]
    |         ^^^^^^^^^^^^^^^
diff --git a/tests/ui/lint/lint-ctypes-73251-1.rs b/tests/ui/lint/improper-ctypes/lint-73251-1.rs
similarity index 100%
rename from tests/ui/lint/lint-ctypes-73251-1.rs
rename to tests/ui/lint/improper-ctypes/lint-73251-1.rs
diff --git a/tests/ui/lint/lint-ctypes-73251-1.stderr b/tests/ui/lint/improper-ctypes/lint-73251-1.stderr
similarity index 82%
rename from tests/ui/lint/lint-ctypes-73251-1.stderr
rename to tests/ui/lint/improper-ctypes/lint-73251-1.stderr
index 675a9de51cd02..749722f0e2203 100644
--- a/tests/ui/lint/lint-ctypes-73251-1.stderr
+++ b/tests/ui/lint/improper-ctypes/lint-73251-1.stderr
@@ -1,12 +1,12 @@
 error: `extern` block uses type `Qux`, which is not FFI-safe
-  --> $DIR/lint-ctypes-73251-1.rs:24:21
+  --> $DIR/lint-73251-1.rs:24:21
    |
 LL |     fn lint_me() -> <u32 as Foo>::Assoc;
    |                     ^^^^^^^^^^^^^^^^^^^ not FFI-safe
    |
    = note: opaque types have no C equivalent
 note: the lint level is defined here
-  --> $DIR/lint-ctypes-73251-1.rs:2:9
+  --> $DIR/lint-73251-1.rs:2:9
    |
 LL | #![deny(improper_ctypes)]
    |         ^^^^^^^^^^^^^^^
diff --git a/tests/ui/lint/lint-ctypes-73251-2.rs b/tests/ui/lint/improper-ctypes/lint-73251-2.rs
similarity index 100%
rename from tests/ui/lint/lint-ctypes-73251-2.rs
rename to tests/ui/lint/improper-ctypes/lint-73251-2.rs
diff --git a/tests/ui/lint/lint-ctypes-73251-2.stderr b/tests/ui/lint/improper-ctypes/lint-73251-2.stderr
similarity index 82%
rename from tests/ui/lint/lint-ctypes-73251-2.stderr
rename to tests/ui/lint/improper-ctypes/lint-73251-2.stderr
index 634950b29ed43..3770b7d789f67 100644
--- a/tests/ui/lint/lint-ctypes-73251-2.stderr
+++ b/tests/ui/lint/improper-ctypes/lint-73251-2.stderr
@@ -1,12 +1,12 @@
 error: `extern` block uses type `AliasA`, which is not FFI-safe
-  --> $DIR/lint-ctypes-73251-2.rs:38:21
+  --> $DIR/lint-73251-2.rs:38:21
    |
 LL |     fn lint_me() -> <AliasB as TraitB>::Assoc;
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
    |
    = note: opaque types have no C equivalent
 note: the lint level is defined here
-  --> $DIR/lint-ctypes-73251-2.rs:2:9
+  --> $DIR/lint-73251-2.rs:2:9
    |
 LL | #![deny(improper_ctypes)]
    |         ^^^^^^^^^^^^^^^
diff --git a/tests/ui/lint/lint-ctypes-94223.rs b/tests/ui/lint/improper-ctypes/lint-94223.rs
similarity index 100%
rename from tests/ui/lint/lint-ctypes-94223.rs
rename to tests/ui/lint/improper-ctypes/lint-94223.rs
diff --git a/tests/ui/lint/lint-ctypes-94223.stderr b/tests/ui/lint/improper-ctypes/lint-94223.stderr
similarity index 86%
rename from tests/ui/lint/lint-ctypes-94223.stderr
rename to tests/ui/lint/improper-ctypes/lint-94223.stderr
index bd127cf60044c..008debf8f010a 100644
--- a/tests/ui/lint/lint-ctypes-94223.stderr
+++ b/tests/ui/lint/improper-ctypes/lint-94223.stderr
@@ -1,5 +1,5 @@
 error: `extern` fn uses type `[u8]`, which is not FFI-safe
-  --> $DIR/lint-ctypes-94223.rs:4:15
+  --> $DIR/lint-94223.rs:4:15
    |
 LL | pub fn bad(f: extern "C" fn([u8])) {}
    |               ^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -7,13 +7,13 @@ LL | pub fn bad(f: extern "C" fn([u8])) {}
    = help: consider using a raw pointer instead
    = note: slices have no C equivalent
 note: the lint level is defined here
-  --> $DIR/lint-ctypes-94223.rs:2:9
+  --> $DIR/lint-94223.rs:2:9
    |
 LL | #![deny(improper_ctypes_definitions)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `extern` fn uses type `[u8]`, which is not FFI-safe
-  --> $DIR/lint-ctypes-94223.rs:7:28
+  --> $DIR/lint-94223.rs:7:28
    |
 LL | pub fn bad_twice(f: Result<extern "C" fn([u8]), extern "C" fn([u8])>) {}
    |                            ^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -22,7 +22,7 @@ LL | pub fn bad_twice(f: Result<extern "C" fn([u8]), extern "C" fn([u8])>) {}
    = note: slices have no C equivalent
 
 error: `extern` fn uses type `[u8]`, which is not FFI-safe
-  --> $DIR/lint-ctypes-94223.rs:7:49
+  --> $DIR/lint-94223.rs:7:49
    |
 LL | pub fn bad_twice(f: Result<extern "C" fn([u8]), extern "C" fn([u8])>) {}
    |                                                 ^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -31,7 +31,7 @@ LL | pub fn bad_twice(f: Result<extern "C" fn([u8]), extern "C" fn([u8])>) {}
    = note: slices have no C equivalent
 
 error: `extern` fn uses type `[u8]`, which is not FFI-safe
-  --> $DIR/lint-ctypes-94223.rs:11:18
+  --> $DIR/lint-94223.rs:11:18
    |
 LL | struct BadStruct(extern "C" fn([u8]));
    |                  ^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -40,7 +40,7 @@ LL | struct BadStruct(extern "C" fn([u8]));
    = note: slices have no C equivalent
 
 error: `extern` fn uses type `[u8]`, which is not FFI-safe
-  --> $DIR/lint-ctypes-94223.rs:15:7
+  --> $DIR/lint-94223.rs:15:7
    |
 LL |     A(extern "C" fn([u8])),
    |       ^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -49,7 +49,7 @@ LL |     A(extern "C" fn([u8])),
    = note: slices have no C equivalent
 
 error: `extern` fn uses type `[u8]`, which is not FFI-safe
-  --> $DIR/lint-ctypes-94223.rs:20:7
+  --> $DIR/lint-94223.rs:20:7
    |
 LL |     A(extern "C" fn([u8])),
    |       ^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -58,7 +58,7 @@ LL |     A(extern "C" fn([u8])),
    = note: slices have no C equivalent
 
 error: `extern` fn uses type `[u8]`, which is not FFI-safe
-  --> $DIR/lint-ctypes-94223.rs:24:12
+  --> $DIR/lint-94223.rs:24:12
    |
 LL | type Foo = extern "C" fn([u8]);
    |            ^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -67,7 +67,7 @@ LL | type Foo = extern "C" fn([u8]);
    = note: slices have no C equivalent
 
 error: `extern` fn uses type `Option<&<T as FooTrait>::FooType>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-94223.rs:31:20
+  --> $DIR/lint-94223.rs:31:20
    |
 LL | pub type Foo2<T> = extern "C" fn(Option<&<T as FooTrait>::FooType>);
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -76,7 +76,7 @@ LL | pub type Foo2<T> = extern "C" fn(Option<&<T as FooTrait>::FooType>);
    = note: enum has no representation hint
 
 error: `extern` fn uses type `FfiUnsafe`, which is not FFI-safe
-  --> $DIR/lint-ctypes-94223.rs:41:17
+  --> $DIR/lint-94223.rs:41:17
    |
 LL | pub static BAD: extern "C" fn(FfiUnsafe) = f;
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -84,13 +84,13 @@ LL | pub static BAD: extern "C" fn(FfiUnsafe) = f;
    = help: consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct
    = note: this struct has unspecified layout
 note: the type is defined here
-  --> $DIR/lint-ctypes-94223.rs:34:1
+  --> $DIR/lint-94223.rs:34:1
    |
 LL | pub struct FfiUnsafe;
    | ^^^^^^^^^^^^^^^^^^^^
 
 error: `extern` fn uses type `FfiUnsafe`, which is not FFI-safe
-  --> $DIR/lint-ctypes-94223.rs:44:30
+  --> $DIR/lint-94223.rs:44:30
    |
 LL | pub static BAD_TWICE: Result<extern "C" fn(FfiUnsafe), extern "C" fn(FfiUnsafe)> = Ok(f);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -98,13 +98,13 @@ LL | pub static BAD_TWICE: Result<extern "C" fn(FfiUnsafe), extern "C" fn(FfiUns
    = help: consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct
    = note: this struct has unspecified layout
 note: the type is defined here
-  --> $DIR/lint-ctypes-94223.rs:34:1
+  --> $DIR/lint-94223.rs:34:1
    |
 LL | pub struct FfiUnsafe;
    | ^^^^^^^^^^^^^^^^^^^^
 
 error: `extern` fn uses type `FfiUnsafe`, which is not FFI-safe
-  --> $DIR/lint-ctypes-94223.rs:44:56
+  --> $DIR/lint-94223.rs:44:56
    |
 LL | pub static BAD_TWICE: Result<extern "C" fn(FfiUnsafe), extern "C" fn(FfiUnsafe)> = Ok(f);
    |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -112,13 +112,13 @@ LL | pub static BAD_TWICE: Result<extern "C" fn(FfiUnsafe), extern "C" fn(FfiUns
    = help: consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct
    = note: this struct has unspecified layout
 note: the type is defined here
-  --> $DIR/lint-ctypes-94223.rs:34:1
+  --> $DIR/lint-94223.rs:34:1
    |
 LL | pub struct FfiUnsafe;
    | ^^^^^^^^^^^^^^^^^^^^
 
 error: `extern` fn uses type `FfiUnsafe`, which is not FFI-safe
-  --> $DIR/lint-ctypes-94223.rs:48:22
+  --> $DIR/lint-94223.rs:48:22
    |
 LL | pub const BAD_CONST: extern "C" fn(FfiUnsafe) = f;
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -126,7 +126,7 @@ LL | pub const BAD_CONST: extern "C" fn(FfiUnsafe) = f;
    = help: consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct
    = note: this struct has unspecified layout
 note: the type is defined here
-  --> $DIR/lint-ctypes-94223.rs:34:1
+  --> $DIR/lint-94223.rs:34:1
    |
 LL | pub struct FfiUnsafe;
    | ^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/lint/lint-ctypes-cstr.rs b/tests/ui/lint/improper-ctypes/lint-cstr.rs
similarity index 100%
rename from tests/ui/lint/lint-ctypes-cstr.rs
rename to tests/ui/lint/improper-ctypes/lint-cstr.rs
diff --git a/tests/ui/lint/lint-ctypes-cstr.stderr b/tests/ui/lint/improper-ctypes/lint-cstr.stderr
similarity index 88%
rename from tests/ui/lint/lint-ctypes-cstr.stderr
rename to tests/ui/lint/improper-ctypes/lint-cstr.stderr
index 8957758d57732..da26306584311 100644
--- a/tests/ui/lint/lint-ctypes-cstr.stderr
+++ b/tests/ui/lint/improper-ctypes/lint-cstr.stderr
@@ -1,5 +1,5 @@
 error: `extern` block uses type `CStr`, which is not FFI-safe
-  --> $DIR/lint-ctypes-cstr.rs:7:21
+  --> $DIR/lint-cstr.rs:7:21
    |
 LL |     fn take_cstr(s: CStr);
    |                     ^^^^ not FFI-safe
@@ -7,13 +7,13 @@ LL |     fn take_cstr(s: CStr);
    = 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
+  --> $DIR/lint-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
+  --> $DIR/lint-cstr.rs:10:25
    |
 LL |     fn take_cstr_ref(s: &CStr);
    |                         ^^^^^ not FFI-safe
@@ -22,7 +22,7 @@ LL |     fn take_cstr_ref(s: &CStr);
    = 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
+  --> $DIR/lint-cstr.rs:13:24
    |
 LL |     fn take_cstring(s: CString);
    |                        ^^^^^^^ not FFI-safe
@@ -31,7 +31,7 @@ LL |     fn take_cstring(s: CString);
    = 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
+  --> $DIR/lint-cstr.rs:16:28
    |
 LL |     fn take_cstring_ref(s: &CString);
    |                            ^^^^^^^^ not FFI-safe
@@ -40,7 +40,7 @@ LL |     fn take_cstring_ref(s: &CString);
    = 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
+  --> $DIR/lint-cstr.rs:20:43
    |
 LL |     fn no_special_help_for_mut_cstring(s: *mut CString);
    |                                           ^^^^^^^^^^^^ not FFI-safe
@@ -49,7 +49,7 @@ LL |     fn no_special_help_for_mut_cstring(s: *mut CString);
    = note: this struct has unspecified layout
 
 error: `extern` block uses type `CString`, which is not FFI-safe
-  --> $DIR/lint-ctypes-cstr.rs:24:47
+  --> $DIR/lint-cstr.rs:24:47
    |
 LL |     fn no_special_help_for_mut_cstring_ref(s: &mut CString);
    |                                               ^^^^^^^^^^^^ not FFI-safe
@@ -58,7 +58,7 @@ LL |     fn no_special_help_for_mut_cstring_ref(s: &mut CString);
    = note: this struct has unspecified layout
 
 error: `extern` fn uses type `CStr`, which is not FFI-safe
-  --> $DIR/lint-ctypes-cstr.rs:29:37
+  --> $DIR/lint-cstr.rs:29:37
    |
 LL | extern "C" fn rust_take_cstr_ref(s: &CStr) {}
    |                                     ^^^^^ not FFI-safe
@@ -66,13 +66,13 @@ LL | extern "C" fn rust_take_cstr_ref(s: &CStr) {}
    = 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
+  --> $DIR/lint-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
+  --> $DIR/lint-cstr.rs:32:36
    |
 LL | extern "C" fn rust_take_cstring(s: CString) {}
    |                                    ^^^^^^^ not FFI-safe
diff --git a/tests/ui/lint/lint-ctypes.rs b/tests/ui/lint/improper-ctypes/lint-ctypes.rs
similarity index 100%
rename from tests/ui/lint/lint-ctypes.rs
rename to tests/ui/lint/improper-ctypes/lint-ctypes.rs
diff --git a/tests/ui/lint/lint-ctypes.stderr b/tests/ui/lint/improper-ctypes/lint-ctypes.stderr
similarity index 100%
rename from tests/ui/lint/lint-ctypes.stderr
rename to tests/ui/lint/improper-ctypes/lint-ctypes.stderr
diff --git a/tests/ui/lint/lint-ctypes-enum.rs b/tests/ui/lint/improper-ctypes/lint-enum.rs
similarity index 100%
rename from tests/ui/lint/lint-ctypes-enum.rs
rename to tests/ui/lint/improper-ctypes/lint-enum.rs
diff --git a/tests/ui/lint/lint-ctypes-enum.stderr b/tests/ui/lint/improper-ctypes/lint-enum.stderr
similarity index 90%
rename from tests/ui/lint/lint-ctypes-enum.stderr
rename to tests/ui/lint/improper-ctypes/lint-enum.stderr
index 40d22723309fb..35d1dcb87fd82 100644
--- a/tests/ui/lint/lint-ctypes-enum.stderr
+++ b/tests/ui/lint/improper-ctypes/lint-enum.stderr
@@ -1,5 +1,5 @@
 error: `extern` block uses type `U`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:82:14
+  --> $DIR/lint-enum.rs:82:14
    |
 LL |     fn uf(x: U);
    |              ^ not FFI-safe
@@ -7,18 +7,18 @@ LL |     fn uf(x: U);
    = help: consider adding a `#[repr(C)]`, `#[repr(transparent)]`, or integer `#[repr(...)]` attribute to this enum
    = note: enum has no representation hint
 note: the type is defined here
-  --> $DIR/lint-ctypes-enum.rs:9:1
+  --> $DIR/lint-enum.rs:9:1
    |
 LL | enum U {
    | ^^^^^^
 note: the lint level is defined here
-  --> $DIR/lint-ctypes-enum.rs:2:9
+  --> $DIR/lint-enum.rs:2:9
    |
 LL | #![deny(improper_ctypes)]
    |         ^^^^^^^^^^^^^^^
 
 error: `extern` block uses type `B`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:83:14
+  --> $DIR/lint-enum.rs:83:14
    |
 LL |     fn bf(x: B);
    |              ^ not FFI-safe
@@ -26,13 +26,13 @@ LL |     fn bf(x: B);
    = help: consider adding a `#[repr(C)]`, `#[repr(transparent)]`, or integer `#[repr(...)]` attribute to this enum
    = note: enum has no representation hint
 note: the type is defined here
-  --> $DIR/lint-ctypes-enum.rs:12:1
+  --> $DIR/lint-enum.rs:12:1
    |
 LL | enum B {
    | ^^^^^^
 
 error: `extern` block uses type `T`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:84:14
+  --> $DIR/lint-enum.rs:84:14
    |
 LL |     fn tf(x: T);
    |              ^ not FFI-safe
@@ -40,13 +40,13 @@ LL |     fn tf(x: T);
    = help: consider adding a `#[repr(C)]`, `#[repr(transparent)]`, or integer `#[repr(...)]` attribute to this enum
    = note: enum has no representation hint
 note: the type is defined here
-  --> $DIR/lint-ctypes-enum.rs:16:1
+  --> $DIR/lint-enum.rs:16:1
    |
 LL | enum T {
    | ^^^^^^
 
 error: `extern` block uses type `Option<TransparentUnion<NonZero<u8>>>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:108:36
+  --> $DIR/lint-enum.rs:108:36
    |
 LL |     fn option_transparent_union(x: Option<TransparentUnion<num::NonZero<u8>>>);
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -55,7 +55,7 @@ LL |     fn option_transparent_union(x: Option<TransparentUnion<num::NonZero<u8>
    = note: enum has no representation hint
 
 error: `extern` block uses type `Option<Rust<NonZero<u8>>>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:110:28
+  --> $DIR/lint-enum.rs:110:28
    |
 LL |     fn option_repr_rust(x: Option<Rust<num::NonZero<u8>>>);
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -64,7 +64,7 @@ LL |     fn option_repr_rust(x: Option<Rust<num::NonZero<u8>>>);
    = note: enum has no representation hint
 
 error: `extern` block uses type `Option<u8>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:111:21
+  --> $DIR/lint-enum.rs:111:21
    |
 LL |     fn option_u8(x: Option<u8>);
    |                     ^^^^^^^^^^ not FFI-safe
@@ -73,7 +73,7 @@ LL |     fn option_u8(x: Option<u8>);
    = note: enum has no representation hint
 
 error: `extern` block uses type `Result<TransparentUnion<NonZero<u8>>, ()>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:131:38
+  --> $DIR/lint-enum.rs:131:38
    |
 LL |     fn result_transparent_union_t(x: Result<TransparentUnion<num::NonZero<u8>>, ()>);
    |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -82,7 +82,7 @@ LL |     fn result_transparent_union_t(x: Result<TransparentUnion<num::NonZero<u
    = note: enum has no representation hint
 
 error: `extern` block uses type `Result<Rust<NonZero<u8>>, ()>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:133:30
+  --> $DIR/lint-enum.rs:133:30
    |
 LL |     fn result_repr_rust_t(x: Result<Rust<num::NonZero<u8>>, ()>);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -91,7 +91,7 @@ LL |     fn result_repr_rust_t(x: Result<Rust<num::NonZero<u8>>, ()>);
    = note: enum has no representation hint
 
 error: `extern` block uses type `Result<NonZero<u8>, U>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:137:51
+  --> $DIR/lint-enum.rs:137:51
    |
 LL |     fn result_1zst_exhaustive_single_variant_t(x: Result<num::NonZero<u8>, U>);
    |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -100,7 +100,7 @@ LL |     fn result_1zst_exhaustive_single_variant_t(x: Result<num::NonZero<u8>,
    = note: enum has no representation hint
 
 error: `extern` block uses type `Result<NonZero<u8>, B>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:139:53
+  --> $DIR/lint-enum.rs:139:53
    |
 LL |     fn result_1zst_exhaustive_multiple_variant_t(x: Result<num::NonZero<u8>, B>);
    |                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -109,7 +109,7 @@ LL |     fn result_1zst_exhaustive_multiple_variant_t(x: Result<num::NonZero<u8>
    = note: enum has no representation hint
 
 error: `extern` block uses type `Result<NonZero<u8>, NonExhaustive>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:141:51
+  --> $DIR/lint-enum.rs:141:51
    |
 LL |     fn result_1zst_non_exhaustive_no_variant_t(x: Result<num::NonZero<u8>, NonExhaustive>);
    |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -118,7 +118,7 @@ LL |     fn result_1zst_non_exhaustive_no_variant_t(x: Result<num::NonZero<u8>,
    = note: enum has no representation hint
 
 error: `extern` block uses type `Result<NonZero<u8>, Field>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:144:49
+  --> $DIR/lint-enum.rs:144:49
    |
 LL |     fn result_1zst_exhaustive_single_field_t(x: Result<num::NonZero<u8>, Field>);
    |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -127,7 +127,7 @@ LL |     fn result_1zst_exhaustive_single_field_t(x: Result<num::NonZero<u8>, Fi
    = note: enum has no representation hint
 
 error: `extern` block uses type `Result<Result<(), NonZero<u8>>, ()>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:146:30
+  --> $DIR/lint-enum.rs:146:30
    |
 LL |     fn result_cascading_t(x: Result<Result<(), num::NonZero<u8>>, ()>);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -136,7 +136,7 @@ LL |     fn result_cascading_t(x: Result<Result<(), num::NonZero<u8>>, ()>);
    = note: enum has no representation hint
 
 error: `extern` block uses type `Result<(), TransparentUnion<NonZero<u8>>>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:167:38
+  --> $DIR/lint-enum.rs:167:38
    |
 LL |     fn result_transparent_union_e(x: Result<(), TransparentUnion<num::NonZero<u8>>>);
    |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -145,7 +145,7 @@ LL |     fn result_transparent_union_e(x: Result<(), TransparentUnion<num::NonZe
    = note: enum has no representation hint
 
 error: `extern` block uses type `Result<(), Rust<NonZero<u8>>>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:169:30
+  --> $DIR/lint-enum.rs:169:30
    |
 LL |     fn result_repr_rust_e(x: Result<(), Rust<num::NonZero<u8>>>);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -154,7 +154,7 @@ LL |     fn result_repr_rust_e(x: Result<(), Rust<num::NonZero<u8>>>);
    = note: enum has no representation hint
 
 error: `extern` block uses type `Result<U, NonZero<u8>>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:173:51
+  --> $DIR/lint-enum.rs:173:51
    |
 LL |     fn result_1zst_exhaustive_single_variant_e(x: Result<U, num::NonZero<u8>>);
    |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -163,7 +163,7 @@ LL |     fn result_1zst_exhaustive_single_variant_e(x: Result<U, num::NonZero<u8
    = note: enum has no representation hint
 
 error: `extern` block uses type `Result<B, NonZero<u8>>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:175:53
+  --> $DIR/lint-enum.rs:175:53
    |
 LL |     fn result_1zst_exhaustive_multiple_variant_e(x: Result<B, num::NonZero<u8>>);
    |                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -172,7 +172,7 @@ LL |     fn result_1zst_exhaustive_multiple_variant_e(x: Result<B, num::NonZero<
    = note: enum has no representation hint
 
 error: `extern` block uses type `Result<NonExhaustive, NonZero<u8>>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:177:51
+  --> $DIR/lint-enum.rs:177:51
    |
 LL |     fn result_1zst_non_exhaustive_no_variant_e(x: Result<NonExhaustive, num::NonZero<u8>>);
    |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -181,7 +181,7 @@ LL |     fn result_1zst_non_exhaustive_no_variant_e(x: Result<NonExhaustive, num
    = note: enum has no representation hint
 
 error: `extern` block uses type `Result<Field, NonZero<u8>>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:180:49
+  --> $DIR/lint-enum.rs:180:49
    |
 LL |     fn result_1zst_exhaustive_single_field_e(x: Result<Field, num::NonZero<u8>>);
    |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -190,7 +190,7 @@ LL |     fn result_1zst_exhaustive_single_field_e(x: Result<Field, num::NonZero<
    = note: enum has no representation hint
 
 error: `extern` block uses type `Result<(), Result<(), NonZero<u8>>>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:182:30
+  --> $DIR/lint-enum.rs:182:30
    |
 LL |     fn result_cascading_e(x: Result<(), Result<(), num::NonZero<u8>>>);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -199,7 +199,7 @@ LL |     fn result_cascading_e(x: Result<(), Result<(), num::NonZero<u8>>>);
    = note: enum has no representation hint
 
 error: `extern` block uses type `Result<(), ()>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-enum.rs:184:27
+  --> $DIR/lint-enum.rs:184:27
    |
 LL |     fn result_unit_t_e(x: Result<(), ()>);
    |                           ^^^^^^^^^^^^^^ not FFI-safe
diff --git a/tests/ui/lint/lint-ctypes-fn.rs b/tests/ui/lint/improper-ctypes/lint-fn.rs
similarity index 100%
rename from tests/ui/lint/lint-ctypes-fn.rs
rename to tests/ui/lint/improper-ctypes/lint-fn.rs
diff --git a/tests/ui/lint/lint-ctypes-fn.stderr b/tests/ui/lint/improper-ctypes/lint-fn.stderr
similarity index 88%
rename from tests/ui/lint/lint-ctypes-fn.stderr
rename to tests/ui/lint/improper-ctypes/lint-fn.stderr
index a19c04a63b566..34e3bd021b92d 100644
--- a/tests/ui/lint/lint-ctypes-fn.stderr
+++ b/tests/ui/lint/improper-ctypes/lint-fn.stderr
@@ -1,5 +1,5 @@
 error: `extern` fn uses type `[u32]`, which is not FFI-safe
-  --> $DIR/lint-ctypes-fn.rs:70:33
+  --> $DIR/lint-fn.rs:70:33
    |
 LL | pub extern "C" fn slice_type(p: &[u32]) { }
    |                                 ^^^^^^ not FFI-safe
@@ -7,13 +7,13 @@ LL | pub extern "C" fn slice_type(p: &[u32]) { }
    = help: consider using a raw pointer instead
    = note: slices have no C equivalent
 note: the lint level is defined here
-  --> $DIR/lint-ctypes-fn.rs:2:9
+  --> $DIR/lint-fn.rs:2:9
    |
 LL | #![deny(improper_ctypes_definitions)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `extern` fn uses type `str`, which is not FFI-safe
-  --> $DIR/lint-ctypes-fn.rs:73:31
+  --> $DIR/lint-fn.rs:73:31
    |
 LL | pub extern "C" fn str_type(p: &str) { }
    |                               ^^^^ not FFI-safe
@@ -22,7 +22,7 @@ LL | pub extern "C" fn str_type(p: &str) { }
    = note: string slices have no C equivalent
 
 error: `extern` fn uses type `Box<[u8]>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-fn.rs:80:34
+  --> $DIR/lint-fn.rs:80:34
    |
 LL | pub extern "C" fn boxed_slice(p: Box<[u8]>) { }
    |                                  ^^^^^^^^^ not FFI-safe
@@ -30,7 +30,7 @@ LL | pub extern "C" fn boxed_slice(p: Box<[u8]>) { }
    = note: box cannot be represented as a single pointer
 
 error: `extern` fn uses type `Box<str>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-fn.rs:83:35
+  --> $DIR/lint-fn.rs:83:35
    |
 LL | pub extern "C" fn boxed_string(p: Box<str>) { }
    |                                   ^^^^^^^^ not FFI-safe
@@ -38,7 +38,7 @@ LL | pub extern "C" fn boxed_string(p: Box<str>) { }
    = note: box cannot be represented as a single pointer
 
 error: `extern` fn uses type `Box<dyn Trait>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-fn.rs:86:34
+  --> $DIR/lint-fn.rs:86:34
    |
 LL | pub extern "C" fn boxed_trait(p: Box<dyn Trait>) { }
    |                                  ^^^^^^^^^^^^^^ not FFI-safe
@@ -46,7 +46,7 @@ LL | pub extern "C" fn boxed_trait(p: Box<dyn Trait>) { }
    = note: box cannot be represented as a single pointer
 
 error: `extern` fn uses type `char`, which is not FFI-safe
-  --> $DIR/lint-ctypes-fn.rs:89:32
+  --> $DIR/lint-fn.rs:89:32
    |
 LL | pub extern "C" fn char_type(p: char) { }
    |                                ^^^^ not FFI-safe
@@ -55,7 +55,7 @@ LL | pub extern "C" fn char_type(p: char) { }
    = note: the `char` type has no C equivalent
 
 error: `extern` fn uses type `(i32, i32)`, which is not FFI-safe
-  --> $DIR/lint-ctypes-fn.rs:92:33
+  --> $DIR/lint-fn.rs:92:33
    |
 LL | pub extern "C" fn tuple_type(p: (i32, i32)) { }
    |                                 ^^^^^^^^^^ not FFI-safe
@@ -64,7 +64,7 @@ LL | pub extern "C" fn tuple_type(p: (i32, i32)) { }
    = note: tuples have unspecified layout
 
 error: `extern` fn uses type `(i32, i32)`, which is not FFI-safe
-  --> $DIR/lint-ctypes-fn.rs:95:34
+  --> $DIR/lint-fn.rs:95:34
    |
 LL | pub extern "C" fn tuple_type2(p: I32Pair) { }
    |                                  ^^^^^^^ not FFI-safe
@@ -73,7 +73,7 @@ LL | pub extern "C" fn tuple_type2(p: I32Pair) { }
    = note: tuples have unspecified layout
 
 error: `extern` fn uses type `ZeroSize`, which is not FFI-safe
-  --> $DIR/lint-ctypes-fn.rs:98:32
+  --> $DIR/lint-fn.rs:98:32
    |
 LL | pub extern "C" fn zero_size(p: ZeroSize) { }
    |                                ^^^^^^^^ not FFI-safe
@@ -81,26 +81,26 @@ LL | pub extern "C" fn zero_size(p: ZeroSize) { }
    = help: consider adding a member to this struct
    = note: this struct has no fields
 note: the type is defined here
-  --> $DIR/lint-ctypes-fn.rs:25:1
+  --> $DIR/lint-fn.rs:25:1
    |
 LL | pub struct ZeroSize;
    | ^^^^^^^^^^^^^^^^^^^
 
 error: `extern` fn uses type `ZeroSizeWithPhantomData`, which is not FFI-safe
-  --> $DIR/lint-ctypes-fn.rs:101:40
+  --> $DIR/lint-fn.rs:101:40
    |
 LL | pub extern "C" fn zero_size_phantom(p: ZeroSizeWithPhantomData) { }
    |                                        ^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
    |
    = note: composed only of `PhantomData`
 note: the type is defined here
-  --> $DIR/lint-ctypes-fn.rs:60:1
+  --> $DIR/lint-fn.rs:60:1
    |
 LL | pub struct ZeroSizeWithPhantomData(PhantomData<i32>);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `extern` fn uses type `PhantomData<bool>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-fn.rs:104:51
+  --> $DIR/lint-fn.rs:104:51
    |
 LL | pub extern "C" fn zero_size_phantom_toplevel() -> PhantomData<bool> {
    |                                                   ^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -108,7 +108,7 @@ LL | pub extern "C" fn zero_size_phantom_toplevel() -> PhantomData<bool> {
    = note: composed only of `PhantomData`
 
 error: `extern` fn uses type `fn()`, which is not FFI-safe
-  --> $DIR/lint-ctypes-fn.rs:109:30
+  --> $DIR/lint-fn.rs:109:30
    |
 LL | pub extern "C" fn fn_type(p: RustFn) { }
    |                              ^^^^^^ not FFI-safe
@@ -117,7 +117,7 @@ LL | pub extern "C" fn fn_type(p: RustFn) { }
    = note: this function pointer has Rust-specific calling convention
 
 error: `extern` fn uses type `fn()`, which is not FFI-safe
-  --> $DIR/lint-ctypes-fn.rs:112:31
+  --> $DIR/lint-fn.rs:112:31
    |
 LL | pub extern "C" fn fn_type2(p: fn()) { }
    |                               ^^^^ not FFI-safe
@@ -126,7 +126,7 @@ LL | pub extern "C" fn fn_type2(p: fn()) { }
    = note: this function pointer has Rust-specific calling convention
 
 error: `extern` fn uses type `str`, which is not FFI-safe
-  --> $DIR/lint-ctypes-fn.rs:117:38
+  --> $DIR/lint-fn.rs:117:38
    |
 LL | pub extern "C" fn transparent_str(p: TransparentStr) { }
    |                                      ^^^^^^^^^^^^^^ not FFI-safe
@@ -135,7 +135,7 @@ LL | pub extern "C" fn transparent_str(p: TransparentStr) { }
    = note: string slices have no C equivalent
 
 error: `extern` fn uses type `PhantomData<bool>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-fn.rs:169:43
+  --> $DIR/lint-fn.rs:169:43
    |
 LL | pub extern "C" fn unused_generic2<T>() -> PhantomData<bool> {
    |                                           ^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -143,7 +143,7 @@ LL | pub extern "C" fn unused_generic2<T>() -> PhantomData<bool> {
    = note: composed only of `PhantomData`
 
 error: `extern` fn uses type `Vec<T>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-fn.rs:182:39
+  --> $DIR/lint-fn.rs:182:39
    |
 LL | pub extern "C" fn used_generic4<T>(x: Vec<T>) { }
    |                                       ^^^^^^ not FFI-safe
@@ -152,7 +152,7 @@ LL | pub extern "C" fn used_generic4<T>(x: Vec<T>) { }
    = note: this struct has unspecified layout
 
 error: `extern` fn uses type `Vec<T>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-fn.rs:185:41
+  --> $DIR/lint-fn.rs:185:41
    |
 LL | pub extern "C" fn used_generic5<T>() -> Vec<T> {
    |                                         ^^^^^^ not FFI-safe
diff --git a/tests/ui/lint/lint-ctypes-non-recursion-limit.rs b/tests/ui/lint/improper-ctypes/lint-non-recursion-limit.rs
similarity index 100%
rename from tests/ui/lint/lint-ctypes-non-recursion-limit.rs
rename to tests/ui/lint/improper-ctypes/lint-non-recursion-limit.rs
diff --git a/tests/ui/lint/lint-ctypes-option-nonnull-unsized.rs b/tests/ui/lint/improper-ctypes/lint-option-nonnull-unsized.rs
similarity index 100%
rename from tests/ui/lint/lint-ctypes-option-nonnull-unsized.rs
rename to tests/ui/lint/improper-ctypes/lint-option-nonnull-unsized.rs
diff --git a/tests/ui/lint/lint-ctypes-option-nonnull-unsized.stderr b/tests/ui/lint/improper-ctypes/lint-option-nonnull-unsized.stderr
similarity index 83%
rename from tests/ui/lint/lint-ctypes-option-nonnull-unsized.stderr
rename to tests/ui/lint/improper-ctypes/lint-option-nonnull-unsized.stderr
index 746304694167f..b17fb6bd6145d 100644
--- a/tests/ui/lint/lint-ctypes-option-nonnull-unsized.stderr
+++ b/tests/ui/lint/improper-ctypes/lint-option-nonnull-unsized.stderr
@@ -1,5 +1,5 @@
 error: `extern` fn uses type `Option<&T>`, which is not FFI-safe
-  --> $DIR/lint-ctypes-option-nonnull-unsized.rs:3:45
+  --> $DIR/lint-option-nonnull-unsized.rs:3:45
    |
 LL | extern "C" fn foo<T: ?Sized + 'static>() -> Option<&'static T> {
    |                                             ^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -7,7 +7,7 @@ LL | extern "C" fn foo<T: ?Sized + 'static>() -> Option<&'static T> {
    = help: consider adding a `#[repr(C)]`, `#[repr(transparent)]`, or integer `#[repr(...)]` attribute to this enum
    = note: enum has no representation hint
 note: the lint level is defined here
-  --> $DIR/lint-ctypes-option-nonnull-unsized.rs:1:9
+  --> $DIR/lint-option-nonnull-unsized.rs:1:9
    |
 LL | #![deny(improper_ctypes_definitions)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/lint/lint-ctypes-113436.rs b/tests/ui/lint/improper-ctypes/mustpass-113436.rs
similarity index 100%
rename from tests/ui/lint/lint-ctypes-113436.rs
rename to tests/ui/lint/improper-ctypes/mustpass-113436.rs
diff --git a/tests/ui/lint/lint-ctypes-113900.rs b/tests/ui/lint/improper-ctypes/mustpass-113900.rs
similarity index 100%
rename from tests/ui/lint/lint-ctypes-113900.rs
rename to tests/ui/lint/improper-ctypes/mustpass-113900.rs
diff --git a/tests/ui/lint/improper_ctypes_definitions_ice_134060.rs b/tests/ui/lint/improper-ctypes/mustpass-134060.rs
similarity index 100%
rename from tests/ui/lint/improper_ctypes_definitions_ice_134060.rs
rename to tests/ui/lint/improper-ctypes/mustpass-134060.rs
diff --git a/tests/ui/lint/improper_ctypes_definitions_ice_134060.stderr b/tests/ui/lint/improper-ctypes/mustpass-134060.stderr
similarity index 85%
rename from tests/ui/lint/improper_ctypes_definitions_ice_134060.stderr
rename to tests/ui/lint/improper-ctypes/mustpass-134060.stderr
index f6ac9a92cd5f0..791b2f7370983 100644
--- a/tests/ui/lint/improper_ctypes_definitions_ice_134060.stderr
+++ b/tests/ui/lint/improper-ctypes/mustpass-134060.stderr
@@ -1,5 +1,5 @@
 warning: `extern` fn uses type `()`, which is not FFI-safe
-  --> $DIR/improper_ctypes_definitions_ice_134060.rs:11:34
+  --> $DIR/mustpass-134060.rs:11:34
    |
 LL |     extern "C" fn foo_(&self, _: ()) -> i64 {
    |                                  ^^ not FFI-safe
diff --git a/tests/ui/lint/lint-ctypes-66202.rs b/tests/ui/lint/improper-ctypes/mustpass-66202.rs
similarity index 100%
rename from tests/ui/lint/lint-ctypes-66202.rs
rename to tests/ui/lint/improper-ctypes/mustpass-66202.rs
diff --git a/tests/ui/lint/lint-ctypes-73249-1.rs b/tests/ui/lint/improper-ctypes/mustpass-73249-1.rs
similarity index 100%
rename from tests/ui/lint/lint-ctypes-73249-1.rs
rename to tests/ui/lint/improper-ctypes/mustpass-73249-1.rs
diff --git a/tests/ui/lint/lint-ctypes-73249-4.rs b/tests/ui/lint/improper-ctypes/mustpass-73249-4.rs
similarity index 100%
rename from tests/ui/lint/lint-ctypes-73249-4.rs
rename to tests/ui/lint/improper-ctypes/mustpass-73249-4.rs
diff --git a/tests/ui/lint/lint-ctypes-73249.rs b/tests/ui/lint/improper-ctypes/mustpass-73249.rs
similarity index 100%
rename from tests/ui/lint/lint-ctypes-73249.rs
rename to tests/ui/lint/improper-ctypes/mustpass-73249.rs
diff --git a/tests/ui/lint/lint-ctypes-73251.rs b/tests/ui/lint/improper-ctypes/mustpass-73251.rs
similarity index 100%
rename from tests/ui/lint/lint-ctypes-73251.rs
rename to tests/ui/lint/improper-ctypes/mustpass-73251.rs
diff --git a/tests/ui/lint/lint-ctypes-73747.rs b/tests/ui/lint/improper-ctypes/mustpass-73747.rs
similarity index 100%
rename from tests/ui/lint/lint-ctypes-73747.rs
rename to tests/ui/lint/improper-ctypes/mustpass-73747.rs
diff --git a/tests/ui/lint/improper_ctypes/repr-rust-is-undefined.rs b/tests/ui/lint/improper-ctypes/repr-rust-is-undefined.rs
similarity index 100%
rename from tests/ui/lint/improper_ctypes/repr-rust-is-undefined.rs
rename to tests/ui/lint/improper-ctypes/repr-rust-is-undefined.rs
diff --git a/tests/ui/lint/improper_ctypes/repr-rust-is-undefined.stderr b/tests/ui/lint/improper-ctypes/repr-rust-is-undefined.stderr
similarity index 100%
rename from tests/ui/lint/improper_ctypes/repr-rust-is-undefined.stderr
rename to tests/ui/lint/improper-ctypes/repr-rust-is-undefined.stderr

From 33943d183207980a56387ca78dc7865b21b99c10 Mon Sep 17 00:00:00 2001
From: niacdoial <niac.notirl@gmail.com>
Date: Fri, 22 Aug 2025 23:39:07 +0200
Subject: [PATCH 0594/1889] ImproperCTypes: more pre-emptive cleanup

Mainly, we realise that the non-null assumption on a Box<_> argument
does not depend on what side of the FFI boundary the function is on.
And anyway, this is not the way to deal with this assumption being maybe violated.
---
 compiler/rustc_lint/src/foreign_modules.rs    | 27 ++++--------
 compiler/rustc_lint/src/types.rs              | 14 +++----
 .../rustc_lint/src/types/improper_ctypes.rs   |  4 +-
 tests/ui/lint/improper-ctypes/lint-ctypes.rs  |  1 -
 .../lint/improper-ctypes/lint-ctypes.stderr   | 41 ++++++++-----------
 5 files changed, 31 insertions(+), 56 deletions(-)

diff --git a/compiler/rustc_lint/src/foreign_modules.rs b/compiler/rustc_lint/src/foreign_modules.rs
index 3267e70f1de26..ad73e15e31f37 100644
--- a/compiler/rustc_lint/src/foreign_modules.rs
+++ b/compiler/rustc_lint/src/foreign_modules.rs
@@ -136,7 +136,6 @@ impl ClashingExternDeclarations {
             ty::TypingEnv::non_body_analysis(tcx, this_fi.owner_id),
             existing_decl_ty,
             this_decl_ty,
-            types::CItemKind::Declaration,
         ) {
             let orig = name_of_extern_decl(tcx, existing_did);
 
@@ -214,10 +213,9 @@ fn structurally_same_type<'tcx>(
     typing_env: ty::TypingEnv<'tcx>,
     a: Ty<'tcx>,
     b: Ty<'tcx>,
-    ckind: types::CItemKind,
 ) -> bool {
     let mut seen_types = UnordSet::default();
-    let result = structurally_same_type_impl(&mut seen_types, tcx, typing_env, a, b, ckind);
+    let result = structurally_same_type_impl(&mut seen_types, tcx, typing_env, a, b);
     if cfg!(debug_assertions) && result {
         // Sanity-check: must have same ABI, size and alignment.
         // `extern` blocks cannot be generic, so we'll always get a layout here.
@@ -236,7 +234,6 @@ fn structurally_same_type_impl<'tcx>(
     typing_env: ty::TypingEnv<'tcx>,
     a: Ty<'tcx>,
     b: Ty<'tcx>,
-    ckind: types::CItemKind,
 ) -> bool {
     debug!("structurally_same_type_impl(tcx, a = {:?}, b = {:?})", a, b);
 
@@ -307,7 +304,6 @@ fn structurally_same_type_impl<'tcx>(
                                 typing_env,
                                 tcx.type_of(a_did).instantiate(tcx, a_gen_args),
                                 tcx.type_of(b_did).instantiate(tcx, b_gen_args),
-                                ckind,
                             )
                         },
                     )
@@ -315,25 +311,19 @@ fn structurally_same_type_impl<'tcx>(
                 (ty::Array(a_ty, a_len), ty::Array(b_ty, b_len)) => {
                     // For arrays, we also check the length.
                     a_len == b_len
-                        && structurally_same_type_impl(
-                            seen_types, tcx, typing_env, *a_ty, *b_ty, ckind,
-                        )
+                        && structurally_same_type_impl(seen_types, tcx, typing_env, *a_ty, *b_ty)
                 }
                 (ty::Slice(a_ty), ty::Slice(b_ty)) => {
-                    structurally_same_type_impl(seen_types, tcx, typing_env, *a_ty, *b_ty, ckind)
+                    structurally_same_type_impl(seen_types, tcx, typing_env, *a_ty, *b_ty)
                 }
                 (ty::RawPtr(a_ty, a_mutbl), ty::RawPtr(b_ty, b_mutbl)) => {
                     a_mutbl == b_mutbl
-                        && structurally_same_type_impl(
-                            seen_types, tcx, typing_env, *a_ty, *b_ty, ckind,
-                        )
+                        && structurally_same_type_impl(seen_types, tcx, typing_env, *a_ty, *b_ty)
                 }
                 (ty::Ref(_a_region, a_ty, a_mut), ty::Ref(_b_region, b_ty, b_mut)) => {
                     // For structural sameness, we don't need the region to be same.
                     a_mut == b_mut
-                        && structurally_same_type_impl(
-                            seen_types, tcx, typing_env, *a_ty, *b_ty, ckind,
-                        )
+                        && structurally_same_type_impl(seen_types, tcx, typing_env, *a_ty, *b_ty)
                 }
                 (ty::FnDef(..), ty::FnDef(..)) => {
                     let a_poly_sig = a.fn_sig(tcx);
@@ -347,7 +337,7 @@ fn structurally_same_type_impl<'tcx>(
                     (a_sig.abi, a_sig.safety, a_sig.c_variadic)
                         == (b_sig.abi, b_sig.safety, b_sig.c_variadic)
                         && a_sig.inputs().iter().eq_by(b_sig.inputs().iter(), |a, b| {
-                            structurally_same_type_impl(seen_types, tcx, typing_env, *a, *b, ckind)
+                            structurally_same_type_impl(seen_types, tcx, typing_env, *a, *b)
                         })
                         && structurally_same_type_impl(
                             seen_types,
@@ -355,7 +345,6 @@ fn structurally_same_type_impl<'tcx>(
                             typing_env,
                             a_sig.output(),
                             b_sig.output(),
-                            ckind,
                         )
                 }
                 (ty::Tuple(..), ty::Tuple(..)) => {
@@ -383,14 +372,14 @@ fn structurally_same_type_impl<'tcx>(
                 // An Adt and a primitive or pointer type. This can be FFI-safe if non-null
                 // enum layout optimisation is being applied.
                 (ty::Adt(..) | ty::Pat(..), _) if is_primitive_or_pointer(b) => {
-                    if let Some(a_inner) = types::repr_nullable_ptr(tcx, typing_env, a, ckind) {
+                    if let Some(a_inner) = types::repr_nullable_ptr(tcx, typing_env, a) {
                         a_inner == b
                     } else {
                         false
                     }
                 }
                 (_, ty::Adt(..) | ty::Pat(..)) if is_primitive_or_pointer(a) => {
-                    if let Some(b_inner) = types::repr_nullable_ptr(tcx, typing_env, b, ckind) {
+                    if let Some(b_inner) = types::repr_nullable_ptr(tcx, typing_env, b) {
                         b_inner == a
                     } else {
                         false
diff --git a/compiler/rustc_lint/src/types.rs b/compiler/rustc_lint/src/types.rs
index 056ecb70af8a4..979a863170100 100644
--- a/compiler/rustc_lint/src/types.rs
+++ b/compiler/rustc_lint/src/types.rs
@@ -11,9 +11,7 @@ use tracing::debug;
 use {rustc_ast as ast, rustc_hir as hir};
 
 mod improper_ctypes; // these filed do the implementation for ImproperCTypesDefinitions,ImproperCTypesDeclarations
-pub(crate) use improper_ctypes::{
-    CItemKind, ImproperCTypesDeclarations, ImproperCTypesDefinitions,
-};
+pub(crate) use improper_ctypes::{ImproperCTypesDeclarations, ImproperCTypesDefinitions};
 
 use crate::lints::{
     AmbiguousWidePointerComparisons, AmbiguousWidePointerComparisonsAddrMetadataSuggestion,
@@ -712,14 +710,13 @@ fn ty_is_known_nonnull<'tcx>(
     tcx: TyCtxt<'tcx>,
     typing_env: ty::TypingEnv<'tcx>,
     ty: Ty<'tcx>,
-    mode: CItemKind,
 ) -> bool {
     let ty = tcx.try_normalize_erasing_regions(typing_env, ty).unwrap_or(ty);
 
     match ty.kind() {
         ty::FnPtr(..) => true,
         ty::Ref(..) => true,
-        ty::Adt(def, _) if def.is_box() && matches!(mode, CItemKind::Definition) => true,
+        ty::Adt(def, _) if def.is_box() => true,
         ty::Adt(def, args) if def.repr().transparent() && !def.is_union() => {
             let marked_non_null = nonnull_optimization_guaranteed(tcx, *def);
 
@@ -735,10 +732,10 @@ fn ty_is_known_nonnull<'tcx>(
             def.variants()
                 .iter()
                 .filter_map(|variant| transparent_newtype_field(tcx, variant))
-                .any(|field| ty_is_known_nonnull(tcx, typing_env, field.ty(tcx, args), mode))
+                .any(|field| ty_is_known_nonnull(tcx, typing_env, field.ty(tcx, args)))
         }
         ty::Pat(base, pat) => {
-            ty_is_known_nonnull(tcx, typing_env, *base, mode)
+            ty_is_known_nonnull(tcx, typing_env, *base)
                 || pat_ty_is_known_nonnull(tcx, typing_env, *pat)
         }
         _ => false,
@@ -849,7 +846,6 @@ pub(crate) fn repr_nullable_ptr<'tcx>(
     tcx: TyCtxt<'tcx>,
     typing_env: ty::TypingEnv<'tcx>,
     ty: Ty<'tcx>,
-    ckind: CItemKind,
 ) -> Option<Ty<'tcx>> {
     debug!("is_repr_nullable_ptr(tcx, ty = {:?})", ty);
     match ty.kind() {
@@ -874,7 +870,7 @@ pub(crate) fn repr_nullable_ptr<'tcx>(
                 _ => return None,
             };
 
-            if !ty_is_known_nonnull(tcx, typing_env, field_ty, ckind) {
+            if !ty_is_known_nonnull(tcx, typing_env, field_ty) {
                 return None;
             }
 
diff --git a/compiler/rustc_lint/src/types/improper_ctypes.rs b/compiler/rustc_lint/src/types/improper_ctypes.rs
index 6f732fc2a50c8..7d7d86f93fc9a 100644
--- a/compiler/rustc_lint/src/types/improper_ctypes.rs
+++ b/compiler/rustc_lint/src/types/improper_ctypes.rs
@@ -173,7 +173,7 @@ fn variant_has_complex_ctor(variant: &ty::VariantDef) -> bool {
 }
 
 #[derive(Clone, Copy)]
-pub(crate) enum CItemKind {
+enum CItemKind {
     Declaration,
     Definition,
 }
@@ -385,7 +385,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
                         {
                             // Special-case types like `Option<extern fn()>` and `Result<extern fn(), ()>`
                             if let Some(ty) =
-                                repr_nullable_ptr(self.cx.tcx, self.cx.typing_env(), ty, self.mode)
+                                repr_nullable_ptr(self.cx.tcx, self.cx.typing_env(), ty)
                             {
                                 return self.check_type_for_ffi(acc, ty);
                             }
diff --git a/tests/ui/lint/improper-ctypes/lint-ctypes.rs b/tests/ui/lint/improper-ctypes/lint-ctypes.rs
index 47586c826ab86..7dc06079fa32c 100644
--- a/tests/ui/lint/improper-ctypes/lint-ctypes.rs
+++ b/tests/ui/lint/improper-ctypes/lint-ctypes.rs
@@ -52,7 +52,6 @@ extern "C" {
     pub fn str_type(p: &str); //~ ERROR: uses type `str`
     pub fn box_type(p: Box<u32>); //~ ERROR uses type `Box<u32>`
     pub fn opt_box_type(p: Option<Box<u32>>);
-    //~^ ERROR uses type `Option<Box<u32>>`
     pub fn char_type(p: char); //~ ERROR uses type `char`
     pub fn trait_type(p: &dyn Bar); //~ ERROR uses type `dyn Bar`
     pub fn tuple_type(p: (i32, i32)); //~ ERROR uses type `(i32, i32)`
diff --git a/tests/ui/lint/improper-ctypes/lint-ctypes.stderr b/tests/ui/lint/improper-ctypes/lint-ctypes.stderr
index 3fb36647d4f1c..6f8b951c53d70 100644
--- a/tests/ui/lint/improper-ctypes/lint-ctypes.stderr
+++ b/tests/ui/lint/improper-ctypes/lint-ctypes.stderr
@@ -67,17 +67,8 @@ LL |     pub fn box_type(p: Box<u32>);
    = help: consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct
    = note: this struct has unspecified layout
 
-error: `extern` block uses type `Option<Box<u32>>`, which is not FFI-safe
-  --> $DIR/lint-ctypes.rs:54:28
-   |
-LL |     pub fn opt_box_type(p: Option<Box<u32>>);
-   |                            ^^^^^^^^^^^^^^^^ not FFI-safe
-   |
-   = help: consider adding a `#[repr(C)]`, `#[repr(transparent)]`, or integer `#[repr(...)]` attribute to this enum
-   = note: enum has no representation hint
-
 error: `extern` block uses type `char`, which is not FFI-safe
-  --> $DIR/lint-ctypes.rs:56:25
+  --> $DIR/lint-ctypes.rs:55:25
    |
 LL |     pub fn char_type(p: char);
    |                         ^^^^ not FFI-safe
@@ -86,7 +77,7 @@ LL |     pub fn char_type(p: char);
    = note: the `char` type has no C equivalent
 
 error: `extern` block uses type `dyn Bar`, which is not FFI-safe
-  --> $DIR/lint-ctypes.rs:57:26
+  --> $DIR/lint-ctypes.rs:56:26
    |
 LL |     pub fn trait_type(p: &dyn Bar);
    |                          ^^^^^^^^ not FFI-safe
@@ -94,7 +85,7 @@ LL |     pub fn trait_type(p: &dyn Bar);
    = note: trait objects have no C equivalent
 
 error: `extern` block uses type `(i32, i32)`, which is not FFI-safe
-  --> $DIR/lint-ctypes.rs:58:26
+  --> $DIR/lint-ctypes.rs:57:26
    |
 LL |     pub fn tuple_type(p: (i32, i32));
    |                          ^^^^^^^^^^ not FFI-safe
@@ -103,7 +94,7 @@ LL |     pub fn tuple_type(p: (i32, i32));
    = note: tuples have unspecified layout
 
 error: `extern` block uses type `(i32, i32)`, which is not FFI-safe
-  --> $DIR/lint-ctypes.rs:59:27
+  --> $DIR/lint-ctypes.rs:58:27
    |
 LL |     pub fn tuple_type2(p: I32Pair);
    |                           ^^^^^^^ not FFI-safe
@@ -112,7 +103,7 @@ LL |     pub fn tuple_type2(p: I32Pair);
    = note: tuples have unspecified layout
 
 error: `extern` block uses type `ZeroSize`, which is not FFI-safe
-  --> $DIR/lint-ctypes.rs:60:25
+  --> $DIR/lint-ctypes.rs:59:25
    |
 LL |     pub fn zero_size(p: ZeroSize);
    |                         ^^^^^^^^ not FFI-safe
@@ -126,7 +117,7 @@ LL | pub struct ZeroSize;
    | ^^^^^^^^^^^^^^^^^^^
 
 error: `extern` block uses type `ZeroSizeWithPhantomData`, which is not FFI-safe
-  --> $DIR/lint-ctypes.rs:61:33
+  --> $DIR/lint-ctypes.rs:60:33
    |
 LL |     pub fn zero_size_phantom(p: ZeroSizeWithPhantomData);
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -139,7 +130,7 @@ LL | pub struct ZeroSizeWithPhantomData(::std::marker::PhantomData<i32>);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `extern` block uses type `PhantomData<bool>`, which is not FFI-safe
-  --> $DIR/lint-ctypes.rs:64:12
+  --> $DIR/lint-ctypes.rs:63:12
    |
 LL |         -> ::std::marker::PhantomData<bool>;
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -147,7 +138,7 @@ LL |         -> ::std::marker::PhantomData<bool>;
    = note: composed only of `PhantomData`
 
 error: `extern` block uses type `fn()`, which is not FFI-safe
-  --> $DIR/lint-ctypes.rs:65:23
+  --> $DIR/lint-ctypes.rs:64:23
    |
 LL |     pub fn fn_type(p: RustFn);
    |                       ^^^^^^ not FFI-safe
@@ -156,7 +147,7 @@ LL |     pub fn fn_type(p: RustFn);
    = note: this function pointer has Rust-specific calling convention
 
 error: `extern` block uses type `fn()`, which is not FFI-safe
-  --> $DIR/lint-ctypes.rs:66:24
+  --> $DIR/lint-ctypes.rs:65:24
    |
 LL |     pub fn fn_type2(p: fn());
    |                        ^^^^ not FFI-safe
@@ -165,7 +156,7 @@ LL |     pub fn fn_type2(p: fn());
    = note: this function pointer has Rust-specific calling convention
 
 error: `extern` block uses type `Box<u32>`, which is not FFI-safe
-  --> $DIR/lint-ctypes.rs:67:28
+  --> $DIR/lint-ctypes.rs:66:28
    |
 LL |     pub fn fn_contained(p: RustBadRet);
    |                            ^^^^^^^^^^ not FFI-safe
@@ -174,7 +165,7 @@ LL |     pub fn fn_contained(p: RustBadRet);
    = note: this struct has unspecified layout
 
 error: `extern` block uses type `str`, which is not FFI-safe
-  --> $DIR/lint-ctypes.rs:68:31
+  --> $DIR/lint-ctypes.rs:67:31
    |
 LL |     pub fn transparent_str(p: TransparentStr);
    |                               ^^^^^^^^^^^^^^ not FFI-safe
@@ -183,7 +174,7 @@ LL |     pub fn transparent_str(p: TransparentStr);
    = note: string slices have no C equivalent
 
 error: `extern` block uses type `Box<u32>`, which is not FFI-safe
-  --> $DIR/lint-ctypes.rs:69:30
+  --> $DIR/lint-ctypes.rs:68:30
    |
 LL |     pub fn transparent_fn(p: TransparentBadFn);
    |                              ^^^^^^^^^^^^^^^^ not FFI-safe
@@ -192,7 +183,7 @@ LL |     pub fn transparent_fn(p: TransparentBadFn);
    = note: this struct has unspecified layout
 
 error: `extern` block uses type `[u8; 8]`, which is not FFI-safe
-  --> $DIR/lint-ctypes.rs:70:27
+  --> $DIR/lint-ctypes.rs:69:27
    |
 LL |     pub fn raw_array(arr: [u8; 8]);
    |                           ^^^^^^^ not FFI-safe
@@ -201,7 +192,7 @@ LL |     pub fn raw_array(arr: [u8; 8]);
    = note: passing raw arrays by value is not FFI-safe
 
 error: `extern` block uses type `Option<UnsafeCell<extern "C" fn()>>`, which is not FFI-safe
-  --> $DIR/lint-ctypes.rs:72:26
+  --> $DIR/lint-ctypes.rs:71:26
    |
 LL |     pub fn no_niche_a(a: Option<UnsafeCell<extern "C" fn()>>);
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -210,7 +201,7 @@ LL |     pub fn no_niche_a(a: Option<UnsafeCell<extern "C" fn()>>);
    = note: enum has no representation hint
 
 error: `extern` block uses type `Option<UnsafeCell<&i32>>`, which is not FFI-safe
-  --> $DIR/lint-ctypes.rs:74:26
+  --> $DIR/lint-ctypes.rs:73:26
    |
 LL |     pub fn no_niche_b(b: Option<UnsafeCell<&i32>>);
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
@@ -218,5 +209,5 @@ LL |     pub fn no_niche_b(b: Option<UnsafeCell<&i32>>);
    = help: consider adding a `#[repr(C)]`, `#[repr(transparent)]`, or integer `#[repr(...)]` attribute to this enum
    = note: enum has no representation hint
 
-error: aborting due to 22 previous errors
+error: aborting due to 21 previous errors
 

From 050c1197841082f1251251b717cad26690627a11 Mon Sep 17 00:00:00 2001
From: niacdoial <niac.notirl@gmail.com>
Date: Sun, 24 Aug 2025 00:05:14 +0200
Subject: [PATCH 0595/1889] ImproperCTypes: re-separate linting and checking

no visible changes to rust users, just making the inner architecture of
the ImproperCTypes lints more sensible, with a clean separation between
the struct (now singular) that interacts with the linting system
and the struct (now singular) that visits the types to check FFI-safety
---
 compiler/rustc_lint/src/lib.rs                |   3 +-
 compiler/rustc_lint/src/types.rs              |   2 +-
 .../rustc_lint/src/types/improper_ctypes.rs   | 511 ++++++++++--------
 3 files changed, 292 insertions(+), 224 deletions(-)

diff --git a/compiler/rustc_lint/src/lib.rs b/compiler/rustc_lint/src/lib.rs
index bdbac7fc4d13f..9bb53fea54a18 100644
--- a/compiler/rustc_lint/src/lib.rs
+++ b/compiler/rustc_lint/src/lib.rs
@@ -194,8 +194,7 @@ late_lint_methods!(
             DefaultCouldBeDerived: DefaultCouldBeDerived::default(),
             DerefIntoDynSupertrait: DerefIntoDynSupertrait,
             DropForgetUseless: DropForgetUseless,
-            ImproperCTypesDeclarations: ImproperCTypesDeclarations,
-            ImproperCTypesDefinitions: ImproperCTypesDefinitions,
+            ImproperCTypesLint: ImproperCTypesLint,
             InvalidFromUtf8: InvalidFromUtf8,
             VariantSizeDifferences: VariantSizeDifferences,
             PathStatements: PathStatements,
diff --git a/compiler/rustc_lint/src/types.rs b/compiler/rustc_lint/src/types.rs
index 979a863170100..a72b802eb5d13 100644
--- a/compiler/rustc_lint/src/types.rs
+++ b/compiler/rustc_lint/src/types.rs
@@ -11,7 +11,7 @@ use tracing::debug;
 use {rustc_ast as ast, rustc_hir as hir};
 
 mod improper_ctypes; // these filed do the implementation for ImproperCTypesDefinitions,ImproperCTypesDeclarations
-pub(crate) use improper_ctypes::{ImproperCTypesDeclarations, ImproperCTypesDefinitions};
+pub(crate) use improper_ctypes::ImproperCTypesLint;
 
 use crate::lints::{
     AmbiguousWidePointerComparisons, AmbiguousWidePointerComparisonsAddrMetadataSuggestion,
diff --git a/compiler/rustc_lint/src/types/improper_ctypes.rs b/compiler/rustc_lint/src/types/improper_ctypes.rs
index 7d7d86f93fc9a..0b6938affa10b 100644
--- a/compiler/rustc_lint/src/types/improper_ctypes.rs
+++ b/compiler/rustc_lint/src/types/improper_ctypes.rs
@@ -9,7 +9,7 @@ use rustc_hir::intravisit::VisitorExt;
 use rustc_hir::{self as hir, AmbigArg};
 use rustc_middle::bug;
 use rustc_middle::ty::{
-    self, Adt, AdtKind, GenericArgsRef, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable,
+    self, Adt, AdtDef, AdtKind, GenericArgsRef, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable,
     TypeVisitableExt,
 };
 use rustc_session::{declare_lint, declare_lint_pass};
@@ -49,8 +49,6 @@ declare_lint! {
     "proper use of libc types in foreign modules"
 }
 
-declare_lint_pass!(ImproperCTypesDeclarations => [IMPROPER_CTYPES]);
-
 declare_lint! {
     /// The `improper_ctypes_definitions` lint detects incorrect use of
     /// [`extern` function] definitions.
@@ -133,8 +131,11 @@ declare_lint! {
     "Structs do not follow the power alignment rule under repr(C)"
 }
 
-declare_lint_pass!(ImproperCTypesDefinitions => [IMPROPER_CTYPES_DEFINITIONS, USES_POWER_ALIGNMENT]);
-
+declare_lint_pass!(ImproperCTypesLint => [
+    IMPROPER_CTYPES,
+    IMPROPER_CTYPES_DEFINITIONS,
+    USES_POWER_ALIGNMENT
+]);
 
 /// Check a variant of a non-exhaustive enum for improper ctypes
 ///
@@ -184,12 +185,17 @@ enum FfiResult<'tcx> {
     FfiUnsafe { ty: Ty<'tcx>, reason: DiagMessage, help: Option<DiagMessage> },
 }
 
+/// The result when a type has been checked but perhaps not completely. `None` indicates that
+/// FFI safety/unsafety has not yet been determined, `Some(res)` indicates that the safety/unsafety
+/// in the `FfiResult` is final.
+type PartialFfiResult<'tcx> = Option<FfiResult<'tcx>>;
+
 struct ImproperCTypesVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     mode: CItemKind,
 }
 
-/// Accumulator for recursive ffi type checking
+/// Accumulator for recursive ffi type checking.
 struct CTypesVisitorState<'tcx> {
     cache: FxHashSet<Ty<'tcx>>,
     /// The original type being checked, before we recursed
@@ -198,21 +204,6 @@ struct CTypesVisitorState<'tcx> {
 }
 
 impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
-    /// Check if the type is array and emit an unsafe type lint.
-    fn check_for_array_ty(&mut self, sp: Span, ty: Ty<'tcx>) -> bool {
-        if let ty::Array(..) = ty.kind() {
-            self.emit_ffi_unsafe_type_lint(
-                ty,
-                sp,
-                fluent::lint_improper_ctypes_array_reason,
-                Some(fluent::lint_improper_ctypes_array_help),
-            );
-            true
-        } else {
-            false
-        }
-    }
-
     /// Checks if the given field's type is "ffi-safe".
     fn check_field_type_for_ffi(
         &self,
@@ -226,7 +217,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
             .tcx
             .try_normalize_erasing_regions(self.cx.typing_env(), field_ty)
             .unwrap_or(field_ty);
-        self.check_type_for_ffi(acc, field_ty)
+        self.visit_type(acc, field_ty)
     }
 
     /// Checks if the given `VariantDef`'s field types are "ffi-safe".
@@ -280,11 +271,7 @@ 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,
-        acc: &mut CTypesVisitorState<'tcx>,
-        ty: Ty<'tcx>,
-    ) -> FfiResult<'tcx> {
+    fn visit_type(&self, acc: &mut CTypesVisitorState<'tcx>, ty: Ty<'tcx>) -> FfiResult<'tcx> {
         use FfiResult::*;
 
         let tcx = self.cx.tcx;
@@ -387,7 +374,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
                             if let Some(ty) =
                                 repr_nullable_ptr(self.cx.tcx, self.cx.typing_env(), ty)
                             {
-                                return self.check_type_for_ffi(acc, ty);
+                                return self.visit_type(acc, ty);
                             }
 
                             return FfiUnsafe {
@@ -425,7 +412,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
 
             // It's just extra invariants on the type that you need to uphold,
             // but only the base type is relevant for being representable in FFI.
-            ty::Pat(base, ..) => self.check_type_for_ffi(acc, base),
+            ty::Pat(base, ..) => self.visit_type(acc, base),
 
             // Primitive types with a stable representation.
             ty::Bool | ty::Int(..) | ty::Uint(..) | ty::Float(..) | ty::Never => FfiSafe,
@@ -470,9 +457,9 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
                 FfiSafe
             }
 
-            ty::RawPtr(ty, _) | ty::Ref(_, ty, _) => self.check_type_for_ffi(acc, ty),
+            ty::RawPtr(ty, _) | ty::Ref(_, ty, _) => self.visit_type(acc, ty),
 
-            ty::Array(inner_ty, _) => self.check_type_for_ffi(acc, inner_ty),
+            ty::Array(inner_ty, _) => self.visit_type(acc, inner_ty),
 
             ty::FnPtr(sig_tys, hdr) => {
                 let sig = sig_tys.with(hdr);
@@ -486,7 +473,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(acc, *arg) {
+                    match self.visit_type(acc, *arg) {
                         FfiSafe => {}
                         r => return r,
                     }
@@ -497,7 +484,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
                     return FfiSafe;
                 }
 
-                self.check_type_for_ffi(acc, ret_ty)
+                self.visit_type(acc, ret_ty)
             }
 
             ty::Foreign(..) => FfiSafe,
@@ -532,36 +519,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
         }
     }
 
-    fn emit_ffi_unsafe_type_lint(
-        &mut self,
-        ty: Ty<'tcx>,
-        sp: Span,
-        note: DiagMessage,
-        help: Option<DiagMessage>,
-    ) {
-        let lint = match self.mode {
-            CItemKind::Declaration => IMPROPER_CTYPES,
-            CItemKind::Definition => IMPROPER_CTYPES_DEFINITIONS,
-        };
-        let desc = match self.mode {
-            CItemKind::Declaration => "block",
-            CItemKind::Definition => "fn",
-        };
-        let span_note = if let ty::Adt(def, _) = ty.kind()
-            && let Some(sp) = self.cx.tcx.hir_span_if_local(def.did())
-        {
-            Some(sp)
-        } else {
-            None
-        };
-        self.cx.emit_span_lint(
-            lint,
-            sp,
-            ImproperCTypes { ty, desc, label: sp, help, note, span_note },
-        );
-    }
-
-    fn check_for_opaque_ty(&mut self, sp: Span, ty: Ty<'tcx>) -> bool {
+    fn visit_for_opaque_ty(&mut self, ty: Ty<'tcx>) -> PartialFfiResult<'tcx> {
         struct ProhibitOpaqueTypes;
         impl<'tcx> ty::TypeVisitor<TyCtxt<'tcx>> for ProhibitOpaqueTypes {
             type Result = ControlFlow<Ty<'tcx>>;
@@ -587,23 +545,37 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
             .visit_with(&mut ProhibitOpaqueTypes)
             .break_value()
         {
-            self.emit_ffi_unsafe_type_lint(ty, sp, fluent::lint_improper_ctypes_opaque, None);
-            true
+            Some(FfiResult::FfiUnsafe { ty, reason: fluent::lint_improper_ctypes_opaque, help: None })
         } else {
-            false
+            None
+        }
+    }
+
+    /// Check if the type is array and emit an unsafe type lint.
+    fn check_for_array_ty(&mut self, ty: Ty<'tcx>) -> PartialFfiResult<'tcx> {
+        if let ty::Array(..) = ty.kind() {
+            Some(FfiResult::FfiUnsafe {
+                ty,
+                reason: fluent::lint_improper_ctypes_array_reason,
+                help: Some(fluent::lint_improper_ctypes_array_help),
+            })
+        } else {
+            None
         }
     }
 
-    fn check_type_for_ffi_and_report_errors(
+    /// Determine the FFI-safety of a single (MIR) type, given the context of how it is used.
+    fn check_type(
         &mut self,
-        sp: Span,
         ty: Ty<'tcx>,
         is_static: bool,
         is_return_type: bool,
-    ) {
-        if self.check_for_opaque_ty(sp, ty) {
-            // We've already emitted an error due to an opaque type.
-            return;
+    ) -> FfiResult<'tcx> {
+        match self.visit_for_opaque_ty(ty) {
+            None => {}
+            Some(res) => {
+                return res;
+            }
         }
 
         let ty = self.cx.tcx.try_normalize_erasing_regions(self.cx.typing_env(), ty).unwrap_or(ty);
@@ -611,82 +583,109 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
         // C doesn't really support passing arrays by value - the only way to pass an array by value
         // is through a struct. So, first test that the top level isn't an array, and then
         // recursively check the types inside.
-        if !is_static && self.check_for_array_ty(sp, ty) {
-            return;
+        if !is_static {
+            match self.check_for_array_ty(ty) {
+                None => {}
+                Some(res) => {
+                    return res;
+                }
+            }
         }
 
         // Don't report FFI errors for unit return types. This check exists here, and not in
         // the caller (where it would make more sense) so that normalization has definitely
         // happened.
         if is_return_type && ty.is_unit() {
-            return;
+            return FfiResult::FfiSafe;
         }
 
-        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(
-                    ty,
-                    sp,
-                    fluent::lint_improper_ctypes_only_phantomdata,
-                    None,
-                );
-            }
-            FfiResult::FfiUnsafe { ty, reason, help } => {
-                self.emit_ffi_unsafe_type_lint(ty, sp, reason, help);
-            }
-        }
+        let mut acc = CTypesVisitorState { cache: Default::default(), base_ty: ty };
+        self.visit_type(&mut acc, ty)
     }
 
-    /// Check if a function's argument types and result type are "ffi-safe".
-    ///
-    /// For a external ABI function, argument types and the result type are walked to find fn-ptr
-    /// types that have external ABIs, as these still need checked.
-    fn check_fn(&mut self, def_id: LocalDefId, decl: &'tcx hir::FnDecl<'_>) {
-        let sig = self.cx.tcx.fn_sig(def_id).instantiate_identity();
-        let sig = self.cx.tcx.instantiate_bound_regions_with_erased(sig);
-
-        for (input_ty, input_hir) in iter::zip(sig.inputs(), decl.inputs) {
-            for (fn_ptr_ty, span) in self.find_fn_ptr_ty_with_external_abi(input_hir, *input_ty) {
-                self.check_type_for_ffi_and_report_errors(span, fn_ptr_ty, false, false);
-            }
-        }
-
-        if let hir::FnRetTy::Return(ret_hir) = decl.output {
-            for (fn_ptr_ty, span) in self.find_fn_ptr_ty_with_external_abi(ret_hir, sig.output()) {
-                self.check_type_for_ffi_and_report_errors(span, fn_ptr_ty, false, true);
+    /// Per-struct-field function that checks if a struct definition follows
+    /// the Power alignment Rule (see the `check_struct_for_power_alignment` method).
+    fn check_arg_for_power_alignment(&mut self, ty: Ty<'tcx>) -> bool {
+        let tcx = self.cx.tcx;
+        assert!(tcx.sess.target.os == "aix");
+        // Structs (under repr(C)) follow the power alignment rule if:
+        //   - the first field of the struct is a floating-point type that
+        //     is greater than 4-bytes, or
+        //   - the first field of the struct is an aggregate whose
+        //     recursively first field is a floating-point type greater than
+        //     4 bytes.
+        if ty.is_floating_point() && ty.primitive_size(tcx).bytes() > 4 {
+            return true;
+        } else if let Adt(adt_def, _) = ty.kind()
+            && adt_def.is_struct()
+            && adt_def.repr().c()
+            && !adt_def.repr().packed()
+            && adt_def.repr().align.is_none()
+        {
+            let struct_variant = adt_def.variant(VariantIdx::ZERO);
+            // Within a nested struct, all fields are examined to correctly
+            // report if any fields after the nested struct within the
+            // original struct are misaligned.
+            for struct_field in &struct_variant.fields {
+                let field_ty = tcx.type_of(struct_field.did).instantiate_identity();
+                if self.check_arg_for_power_alignment(field_ty) {
+                    return true;
+                }
             }
         }
+        return false;
     }
 
-    /// Check if a function's argument types and result type are "ffi-safe".
-    fn check_foreign_fn(&mut self, def_id: LocalDefId, decl: &'tcx hir::FnDecl<'_>) {
-        let sig = self.cx.tcx.fn_sig(def_id).instantiate_identity();
-        let sig = self.cx.tcx.instantiate_bound_regions_with_erased(sig);
-
-        for (input_ty, input_hir) in iter::zip(sig.inputs(), decl.inputs) {
-            self.check_type_for_ffi_and_report_errors(input_hir.span, *input_ty, false, false);
-        }
-
-        if let hir::FnRetTy::Return(ret_hir) = decl.output {
-            self.check_type_for_ffi_and_report_errors(ret_hir.span, sig.output(), false, true);
+    /// Check a struct definition for respect of the Power alignment Rule (as in PowerPC),
+    /// which should be respected in the "aix" target OS.
+    /// To do so, we must follow one of the two following conditions:
+    /// - The first field of the struct must be floating-point type that
+    ///    is greater than 4-bytes.
+    ///  - The first field of the struct must be an aggregate whose
+    ///    recursively first field is a floating-point type greater than
+    ///    4 bytes.
+    fn check_struct_for_power_alignment(&mut self, item: &'tcx hir::Item<'tcx>) {
+        let tcx = self.cx.tcx;
+        let adt_def = tcx.adt_def(item.owner_id.to_def_id());
+        // repr(C) structs also with packed or aligned representation
+        // should be ignored.
+        if adt_def.repr().c()
+            && !adt_def.repr().packed()
+            && adt_def.repr().align.is_none()
+            && tcx.sess.target.os == "aix"
+            && !adt_def.all_fields().next().is_none()
+        {
+            let struct_variant_data = item.expect_struct().2;
+            for field_def in struct_variant_data.fields().iter().skip(1) {
+                // Struct fields (after the first field) are checked for the
+                // power alignment rule, as fields after the first are likely
+                // to be the fields that are misaligned.
+                let def_id = field_def.def_id;
+                let ty = tcx.type_of(def_id).instantiate_identity();
+                if self.check_arg_for_power_alignment(ty) {
+                    self.cx.emit_span_lint(
+                        USES_POWER_ALIGNMENT,
+                        field_def.span,
+                        UsesPowerAlignment,
+                    );
+                }
+            }
         }
     }
+}
 
-    fn check_foreign_static(&mut self, id: hir::OwnerId, span: Span) {
-        let ty = self.cx.tcx.type_of(id).instantiate_identity();
-        self.check_type_for_ffi_and_report_errors(span, ty, true, false);
-    }
-
-    /// Find any fn-ptr types with external ABIs in `ty`.
-    ///
-    /// For example, `Option<extern "C" fn()>` returns `extern "C" fn()`
-    fn find_fn_ptr_ty_with_external_abi(
-        &self,
+impl<'tcx> ImproperCTypesLint {
+    /// Find any fn-ptr types with external ABIs in `ty`, and FFI-checks them.
+    /// For example, `Option<extern "C" fn()>` FFI-checks `extern "C" fn()`.
+    fn check_type_for_external_abi_fnptr(
+        &mut self,
+        cx: &LateContext<'tcx>,
         hir_ty: &hir::Ty<'tcx>,
         ty: Ty<'tcx>,
-    ) -> Vec<(Ty<'tcx>, Span)> {
+        fn_mode: CItemKind,
+        is_static: bool,
+        is_return: bool,
+    ) {
         struct FnPtrFinder<'tcx> {
             spans: Vec<Span>,
             tys: Vec<Ty<'tcx>>,
@@ -723,105 +722,138 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
         ty.visit_with(&mut visitor);
         visitor.visit_ty_unambig(hir_ty);
 
-        iter::zip(visitor.tys.drain(..), visitor.spans.drain(..)).collect()
+        let all_types = iter::zip(visitor.tys.drain(..), visitor.spans.drain(..));
+        for (fn_ptr_ty, span) in all_types {
+            let mut visitor = ImproperCTypesVisitor { cx, mode: fn_mode };
+            // TODO: make a check_for_fnptr
+            let ffi_res = visitor.check_type(fn_ptr_ty, is_static, is_return);
+
+            self.process_ffi_result(cx, span, ffi_res, fn_mode);
+        }
     }
-}
 
-impl<'tcx> LateLintPass<'tcx> for ImproperCTypesDeclarations {
-    fn check_foreign_item(&mut self, cx: &LateContext<'tcx>, it: &hir::ForeignItem<'tcx>) {
-        let mut vis = ImproperCTypesVisitor { cx, mode: CItemKind::Declaration };
-        let abi = cx.tcx.hir_get_foreign_abi(it.hir_id());
+    /// Regardless of a function's need to be "ffi-safe", look for fn-ptr argument/return types
+    /// that need to be checked for ffi-safety.
+    fn check_fn_for_external_abi_fnptr(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        fn_mode: CItemKind,
+        def_id: LocalDefId,
+        decl: &'tcx hir::FnDecl<'_>,
+    ) {
+        let sig = cx.tcx.fn_sig(def_id).instantiate_identity();
+        let sig = cx.tcx.instantiate_bound_regions_with_erased(sig);
 
-        match it.kind {
-            hir::ForeignItemKind::Fn(sig, _, _) => {
-                if abi.is_rustic_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 !abi.is_rustic_abi() => {
-                vis.check_foreign_static(it.owner_id, ty.span);
-            }
-            hir::ForeignItemKind::Static(..) | hir::ForeignItemKind::Type => (),
+        for (input_ty, input_hir) in iter::zip(sig.inputs(), decl.inputs) {
+            self.check_type_for_external_abi_fnptr(cx, input_hir, *input_ty, fn_mode, false, false);
+        }
+
+        if let hir::FnRetTy::Return(ret_hir) = decl.output {
+            self.check_type_for_external_abi_fnptr(cx, ret_hir, sig.output(), fn_mode, false, true);
         }
     }
-}
 
-impl ImproperCTypesDefinitions {
-    fn check_ty_maybe_containing_foreign_fnptr<'tcx>(
+    /// For a local definition of a #[repr(C)] struct/enum/union, check that it is indeed FFI-safe.
+    fn check_reprc_adt(
         &mut self,
         cx: &LateContext<'tcx>,
-        hir_ty: &'tcx hir::Ty<'_>,
-        ty: Ty<'tcx>,
+        item: &'tcx hir::Item<'tcx>,
+        adt_def: AdtDef<'tcx>,
     ) {
-        let mut vis = ImproperCTypesVisitor { cx, mode: CItemKind::Definition };
-        for (fn_ptr_ty, span) in vis.find_fn_ptr_ty_with_external_abi(hir_ty, ty) {
-            vis.check_type_for_ffi_and_report_errors(span, fn_ptr_ty, true, false);
-        }
+        debug_assert!(
+            adt_def.repr().c() && !adt_def.repr().packed() && adt_def.repr().align.is_none()
+        );
+
+        let mut visitor = ImproperCTypesVisitor { cx, mode: CItemKind::Declaration };
+
+        // FIXME(ctypes): this following call is awkward.
+        // is there a way to perform its logic in MIR space rather than HIR space?
+        // (so that its logic can be absorbed into visitor.visit_struct_or_union)
+        visitor.check_struct_for_power_alignment(item);
+    }
+
+    fn check_foreign_static(&mut self, cx: &LateContext<'tcx>, id: hir::OwnerId, span: Span) {
+        let ty = cx.tcx.type_of(id).instantiate_identity();
+        let mut visitor = ImproperCTypesVisitor { cx, mode: CItemKind::Declaration };
+        let ffi_res = visitor.check_type(ty, true, false);
+        self.process_ffi_result(cx, span, ffi_res, CItemKind::Declaration);
     }
 
-    fn check_arg_for_power_alignment<'tcx>(
+    /// Check if a function's argument types and result type are "ffi-safe".
+    fn check_foreign_fn(
         &mut self,
         cx: &LateContext<'tcx>,
-        ty: Ty<'tcx>,
-    ) -> bool {
-        assert!(cx.tcx.sess.target.os == "aix");
-        // Structs (under repr(C)) follow the power alignment rule if:
-        //   - the first field of the struct is a floating-point type that
-        //     is greater than 4-bytes, or
-        //   - the first field of the struct is an aggregate whose
-        //     recursively first field is a floating-point type greater than
-        //     4 bytes.
-        if ty.is_floating_point() && ty.primitive_size(cx.tcx).bytes() > 4 {
-            return true;
-        } else if let Adt(adt_def, _) = ty.kind()
-            && adt_def.is_struct()
-            && adt_def.repr().c()
-            && !adt_def.repr().packed()
-            && adt_def.repr().align.is_none()
-        {
-            let struct_variant = adt_def.variant(VariantIdx::ZERO);
-            // Within a nested struct, all fields are examined to correctly
-            // report if any fields after the nested struct within the
-            // original struct are misaligned.
-            for struct_field in &struct_variant.fields {
-                let field_ty = cx.tcx.type_of(struct_field.did).instantiate_identity();
-                if self.check_arg_for_power_alignment(cx, field_ty) {
-                    return true;
-                }
-            }
+        fn_mode: CItemKind,
+        def_id: LocalDefId,
+        decl: &'tcx hir::FnDecl<'_>,
+    ) {
+        let sig = cx.tcx.fn_sig(def_id).instantiate_identity();
+        let sig = cx.tcx.instantiate_bound_regions_with_erased(sig);
+
+        for (input_ty, input_hir) in iter::zip(sig.inputs(), decl.inputs) {
+            let mut visitor = ImproperCTypesVisitor { cx, mode: fn_mode };
+            let ffi_res = visitor.check_type(*input_ty, false, false);
+            self.process_ffi_result(cx, input_hir.span, ffi_res, fn_mode);
+        }
+
+        if let hir::FnRetTy::Return(ret_hir) = decl.output {
+            let mut visitor = ImproperCTypesVisitor { cx, mode: fn_mode };
+            let ffi_res = visitor.check_type(sig.output(), false, true);
+            self.process_ffi_result(cx, ret_hir.span, ffi_res, fn_mode);
         }
-        return false;
     }
 
-    fn check_struct_for_power_alignment<'tcx>(
-        &mut self,
+    fn process_ffi_result(
+        &self,
         cx: &LateContext<'tcx>,
-        item: &'tcx hir::Item<'tcx>,
+        sp: Span,
+        res: FfiResult<'tcx>,
+        fn_mode: CItemKind,
     ) {
-        let adt_def = cx.tcx.adt_def(item.owner_id.to_def_id());
-        // repr(C) structs also with packed or aligned representation
-        // should be ignored.
-        if adt_def.repr().c()
-            && !adt_def.repr().packed()
-            && adt_def.repr().align.is_none()
-            && cx.tcx.sess.target.os == "aix"
-            && !adt_def.all_fields().next().is_none()
-        {
-            let struct_variant_data = item.expect_struct().2;
-            for field_def in struct_variant_data.fields().iter().skip(1) {
-                // Struct fields (after the first field) are checked for the
-                // power alignment rule, as fields after the first are likely
-                // to be the fields that are misaligned.
-                let def_id = field_def.def_id;
-                let ty = cx.tcx.type_of(def_id).instantiate_identity();
-                if self.check_arg_for_power_alignment(cx, ty) {
-                    cx.emit_span_lint(USES_POWER_ALIGNMENT, field_def.span, UsesPowerAlignment);
-                }
+        match res {
+            FfiResult::FfiSafe => {}
+            FfiResult::FfiPhantom(ty) => {
+                self.emit_ffi_unsafe_type_lint(
+                    cx,
+                    ty,
+                    sp,
+                    fluent::lint_improper_ctypes_only_phantomdata,
+                    None,
+                    fn_mode,
+                );
+            }
+            FfiResult::FfiUnsafe { ty, reason, help } => {
+                self.emit_ffi_unsafe_type_lint(cx, ty, sp, reason, help, fn_mode);
             }
         }
     }
+
+    fn emit_ffi_unsafe_type_lint(
+        &self,
+        cx: &LateContext<'tcx>,
+        ty: Ty<'tcx>,
+        sp: Span,
+        note: DiagMessage,
+        help: Option<DiagMessage>,
+        fn_mode: CItemKind,
+    ) {
+        let lint = match fn_mode {
+            CItemKind::Declaration => IMPROPER_CTYPES,
+            CItemKind::Definition => IMPROPER_CTYPES_DEFINITIONS,
+        };
+        let desc = match fn_mode {
+            CItemKind::Declaration => "block",
+            CItemKind::Definition => "fn",
+        };
+        let span_note = if let ty::Adt(def, _) = ty.kind()
+            && let Some(sp) = cx.tcx.hir_span_if_local(def.did())
+        {
+            Some(sp)
+        } else {
+            None
+        };
+        cx.emit_span_lint(lint, sp, ImproperCTypes { ty, desc, label: sp, help, note, span_note });
+    }
 }
 
 /// `ImproperCTypesDefinitions` checks items outside of foreign items (e.g. stuff that isn't in
@@ -831,27 +863,59 @@ impl ImproperCTypesDefinitions {
 ///   `ImproperCtypesDeclarations` visitor checks functions if `<abi>` is external (e.g. "C").
 /// - All other items which contain types (e.g. other functions, struct definitions, etc) are
 ///   checked for extern fn-ptrs with external ABIs.
-impl<'tcx> LateLintPass<'tcx> for ImproperCTypesDefinitions {
+impl<'tcx> LateLintPass<'tcx> for ImproperCTypesLint {
+    fn check_foreign_item(&mut self, cx: &LateContext<'tcx>, it: &hir::ForeignItem<'tcx>) {
+        let abi = cx.tcx.hir_get_foreign_abi(it.hir_id());
+
+        match it.kind {
+            hir::ForeignItemKind::Fn(sig, _, _) => {
+                // fnptrs are a special case, they always need to be treated as
+                // "the element rendered unsafe" because their unsafety doesn't affect
+                // their surroundings, and their type is often declared inline
+                if !abi.is_rustic_abi() {
+                    self.check_foreign_fn(cx, CItemKind::Declaration, it.owner_id.def_id, sig.decl);
+                } else {
+                    self.check_fn_for_external_abi_fnptr(
+                        cx,
+                        CItemKind::Declaration,
+                        it.owner_id.def_id,
+                        sig.decl,
+                    );
+                }
+            }
+            hir::ForeignItemKind::Static(ty, _, _) if !abi.is_rustic_abi() => {
+                self.check_foreign_static(cx, it.owner_id, ty.span);
+            }
+            hir::ForeignItemKind::Static(..) | hir::ForeignItemKind::Type => (),
+        }
+    }
+
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'tcx>) {
         match item.kind {
             hir::ItemKind::Static(_, _, ty, _)
             | hir::ItemKind::Const(_, _, ty, _)
             | hir::ItemKind::TyAlias(_, _, ty) => {
-                self.check_ty_maybe_containing_foreign_fnptr(
+                self.check_type_for_external_abi_fnptr(
                     cx,
                     ty,
                     cx.tcx.type_of(item.owner_id).instantiate_identity(),
+                    CItemKind::Definition,
+                    true,
+                    false,
                 );
             }
-            // See `check_fn`..
+            // See `check_fn` for declarations, `check_foreign_items` for definitions in extern blocks
             hir::ItemKind::Fn { .. } => {}
-            // Structs are checked based on if they follow the power alignment
-            // rule (under repr(C)).
-            hir::ItemKind::Struct(..) => {
-                self.check_struct_for_power_alignment(cx, item);
+            hir::ItemKind::Struct(..) | hir::ItemKind::Union(..) | hir::ItemKind::Enum(..) => {
+                // looking for extern FnPtr:s is delegated to `check_field_def`.
+                let adt_def: AdtDef<'tcx> = cx.tcx.adt_def(item.owner_id.to_def_id());
+
+                if adt_def.repr().c() && !adt_def.repr().packed() && adt_def.repr().align.is_none()
+                {
+                    self.check_reprc_adt(cx, item, adt_def);
+                }
             }
-            // See `check_field_def`..
-            hir::ItemKind::Union(..) | hir::ItemKind::Enum(..) => {}
+
             // Doesn't define something that can contain a external type to be checked.
             hir::ItemKind::Impl(..)
             | hir::ItemKind::TraitAlias(..)
@@ -866,10 +930,13 @@ impl<'tcx> LateLintPass<'tcx> for ImproperCTypesDefinitions {
     }
 
     fn check_field_def(&mut self, cx: &LateContext<'tcx>, field: &'tcx hir::FieldDef<'tcx>) {
-        self.check_ty_maybe_containing_foreign_fnptr(
+        self.check_type_for_external_abi_fnptr(
             cx,
             field.ty,
             cx.tcx.type_of(field.def_id).instantiate_identity(),
+            CItemKind::Definition,
+            true,
+            false,
         );
     }
 
@@ -890,11 +957,13 @@ impl<'tcx> LateLintPass<'tcx> for ImproperCTypesDefinitions {
             _ => return,
         };
 
-        let mut vis = ImproperCTypesVisitor { cx, mode: CItemKind::Definition };
-        if abi.is_rustic_abi() {
-            vis.check_fn(id, decl);
+        // fnptrs are a special case, they always need to be treated as
+        // "the element rendered unsafe" because their unsafety doesn't affect
+        // their surroundings, and their type is often declared inline
+        if !abi.is_rustic_abi() {
+            self.check_foreign_fn(cx, CItemKind::Definition, id, decl);
         } else {
-            vis.check_foreign_fn(id, decl);
+            self.check_fn_for_external_abi_fnptr(cx, CItemKind::Definition, id, decl);
         }
     }
 }

From 20f050b44431ac1e0dd2a6285b736a0d5c046ce3 Mon Sep 17 00:00:00 2001
From: niacdoial <niac.notirl@gmail.com>
Date: Sun, 24 Aug 2025 14:23:24 +0200
Subject: [PATCH 0596/1889] ImproperCTypes: redo state tracking

No changes should be visible by rustc users
This is just some architecture changes to the type checking to
facilitate FFI-safety decisions that depend on how the type is used
(the change here is not complete, there are still bits of "legacy" state
passing for this, but since this is a retconned commit, I can tell you
those bits will disappear before the end of the commit chain)
(there is at least one bit where the decision making code is weird, but
that this is because we do not want to change the lint's behaviour this
early in the chain)
---
 Cargo.lock                                    |   1 +
 compiler/rustc_lint/Cargo.toml                |   1 +
 .../rustc_lint/src/types/improper_ctypes.rs   | 362 +++++++++++-------
 3 files changed, 226 insertions(+), 138 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index c4c96f1569b6f..6db512c3137d6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4022,6 +4022,7 @@ dependencies = [
 name = "rustc_lint"
 version = "0.0.0"
 dependencies = [
+ "bitflags",
  "rustc_abi",
  "rustc_ast",
  "rustc_ast_pretty",
diff --git a/compiler/rustc_lint/Cargo.toml b/compiler/rustc_lint/Cargo.toml
index 7718f16984dab..3a50aac50cb3e 100644
--- a/compiler/rustc_lint/Cargo.toml
+++ b/compiler/rustc_lint/Cargo.toml
@@ -5,6 +5,7 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
+bitflags = "2.4.1"
 rustc_abi = { path = "../rustc_abi" }
 rustc_ast = { path = "../rustc_ast" }
 rustc_ast_pretty = { path = "../rustc_ast_pretty" }
diff --git a/compiler/rustc_lint/src/types/improper_ctypes.rs b/compiler/rustc_lint/src/types/improper_ctypes.rs
index 0b6938affa10b..7ca57b0094ee3 100644
--- a/compiler/rustc_lint/src/types/improper_ctypes.rs
+++ b/compiler/rustc_lint/src/types/improper_ctypes.rs
@@ -1,6 +1,7 @@
 use std::iter;
 use std::ops::ControlFlow;
 
+use bitflags::bitflags;
 use rustc_abi::VariantIdx;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::DiagMessage;
@@ -21,7 +22,6 @@ use super::repr_nullable_ptr;
 use crate::lints::{ImproperCTypes, UsesPowerAlignment};
 use crate::{LateContext, LateLintPass, LintContext, fluent_generated as fluent};
 
-
 declare_lint! {
     /// The `improper_ctypes` lint detects incorrect use of types in foreign
     /// modules.
@@ -173,6 +173,75 @@ fn variant_has_complex_ctor(variant: &ty::VariantDef) -> bool {
     !matches!(variant.ctor_kind(), Some(CtorKind::Const))
 }
 
+/// Per-struct-field function that checks if a struct definition follows
+/// the Power alignment Rule (see the `check_struct_for_power_alignment` function).
+fn check_arg_for_power_alignment<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+    let tcx = cx.tcx;
+    assert!(tcx.sess.target.os == "aix");
+    // Structs (under repr(C)) follow the power alignment rule if:
+    //   - the first field of the struct is a floating-point type that
+    //     is greater than 4-bytes, or
+    //   - the first field of the struct is an aggregate whose
+    //     recursively first field is a floating-point type greater than
+    //     4 bytes.
+    if ty.is_floating_point() && ty.primitive_size(tcx).bytes() > 4 {
+        return true;
+    } else if let Adt(adt_def, _) = ty.kind()
+        && adt_def.is_struct()
+        && adt_def.repr().c()
+        && !adt_def.repr().packed()
+        && adt_def.repr().align.is_none()
+    {
+        let struct_variant = adt_def.variant(VariantIdx::ZERO);
+        // Within a nested struct, all fields are examined to correctly
+        // report if any fields after the nested struct within the
+        // original struct are misaligned.
+        for struct_field in &struct_variant.fields {
+            let field_ty = tcx.type_of(struct_field.did).instantiate_identity();
+            if check_arg_for_power_alignment(cx, field_ty) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+/// Check a struct definition for respect of the Power alignment Rule (as in PowerPC),
+/// which should be respected in the "aix" target OS.
+/// To do so, we must follow one of the two following conditions:
+/// - The first field of the struct must be floating-point type that
+///    is greater than 4-bytes.
+///  - The first field of the struct must be an aggregate whose
+///    recursively first field is a floating-point type greater than
+///    4 bytes.
+fn check_struct_for_power_alignment<'tcx>(
+    cx: &LateContext<'tcx>,
+    item: &'tcx hir::Item<'tcx>,
+    adt_def: AdtDef<'tcx>,
+) {
+    let tcx = cx.tcx;
+    // repr(C) structs also with packed or aligned representation
+    // should be ignored.
+    if adt_def.repr().c()
+        && !adt_def.repr().packed()
+        && adt_def.repr().align.is_none()
+        && tcx.sess.target.os == "aix"
+        && !adt_def.all_fields().next().is_none()
+    {
+        let struct_variant_data = item.expect_struct().2;
+        for field_def in struct_variant_data.fields().iter().skip(1) {
+            // Struct fields (after the first field) are checked for the
+            // power alignment rule, as fields after the first are likely
+            // to be the fields that are misaligned.
+            let def_id = field_def.def_id;
+            let ty = tcx.type_of(def_id).instantiate_identity();
+            if check_arg_for_power_alignment(cx, ty) {
+                cx.emit_span_lint(USES_POWER_ALIGNMENT, field_def.span, UsesPowerAlignment);
+            }
+        }
+    }
+}
+
 #[derive(Clone, Copy)]
 enum CItemKind {
     Declaration,
@@ -190,24 +259,115 @@ enum FfiResult<'tcx> {
 /// in the `FfiResult` is final.
 type PartialFfiResult<'tcx> = Option<FfiResult<'tcx>>;
 
-struct ImproperCTypesVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    mode: CItemKind,
+bitflags! {
+    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
+    struct VisitorState: u8 {
+        /// For use in (externally-linked) static variables.
+        const STATIC = 0b000001;
+        /// For use in functions in general.
+        const FUNC = 0b000010;
+        /// For variables in function returns (implicitly: not for static variables).
+        const FN_RETURN = 0b000100;
+        /// For variables in functions/variables which are defined in rust.
+        const DEFINED = 0b001000;
+        /// For times where we are only defining the type of something
+        /// (struct/enum/union definitions, FnPtrs).
+        const THEORETICAL = 0b010000;
+    }
 }
 
-/// Accumulator for recursive ffi type checking.
-struct CTypesVisitorState<'tcx> {
+impl VisitorState {
+    // The values that can be set.
+    const STATIC_TY: Self = Self::STATIC;
+    const ARGUMENT_TY_IN_DEFINITION: Self =
+        Self::from_bits(Self::FUNC.bits() | Self::DEFINED.bits()).unwrap();
+    const RETURN_TY_IN_DEFINITION: Self =
+        Self::from_bits(Self::FUNC.bits() | Self::FN_RETURN.bits() | Self::DEFINED.bits()).unwrap();
+    const ARGUMENT_TY_IN_DECLARATION: Self = Self::FUNC;
+    const RETURN_TY_IN_DECLARATION: Self =
+        Self::from_bits(Self::FUNC.bits() | Self::FN_RETURN.bits()).unwrap();
+    const ARGUMENT_TY_IN_FNPTR: Self =
+        Self::from_bits(Self::FUNC.bits() | Self::THEORETICAL.bits()).unwrap();
+    const RETURN_TY_IN_FNPTR: Self =
+        Self::from_bits(Self::FUNC.bits() | Self::THEORETICAL.bits() | Self::FN_RETURN.bits())
+            .unwrap();
+
+    /// Get the proper visitor state for a given function's arguments.
+    fn argument_from_fnmode(fn_mode: CItemKind) -> Self {
+        match fn_mode {
+            CItemKind::Definition => VisitorState::ARGUMENT_TY_IN_DEFINITION,
+            CItemKind::Declaration => VisitorState::ARGUMENT_TY_IN_DECLARATION,
+        }
+    }
+
+    /// Get the proper visitor state for a given function's return type.
+    fn return_from_fnmode(fn_mode: CItemKind) -> Self {
+        match fn_mode {
+            CItemKind::Definition => VisitorState::RETURN_TY_IN_DEFINITION,
+            CItemKind::Declaration => VisitorState::RETURN_TY_IN_DECLARATION,
+        }
+    }
+
+    /// Whether the type is used in a function.
+    fn is_in_function(self) -> bool {
+        let ret = self.contains(Self::FUNC);
+        if ret {
+            debug_assert!(!self.contains(Self::STATIC));
+        }
+        ret
+    }
+    /// Whether the type is used (directly or not) in a function, in return position.
+    fn is_in_function_return(self) -> bool {
+        let ret = self.contains(Self::FN_RETURN);
+        if ret {
+            debug_assert!(self.is_in_function());
+        }
+        ret
+    }
+    /// Whether the type is used (directly or not) in a defined function.
+    /// In other words, whether or not we allow non-FFI-safe types behind a C pointer,
+    /// to be treated as an opaque type on the other side of the FFI boundary.
+    fn is_in_defined_function(self) -> bool {
+        self.contains(Self::DEFINED) && self.is_in_function()
+    }
+
+    /// Whether the type is used (directly or not) in a function pointer type.
+    /// Here, we also allow non-FFI-safe types behind a C pointer,
+    /// to be treated as an opaque type on the other side of the FFI boundary.
+    fn is_in_fnptr(self) -> bool {
+        self.contains(Self::THEORETICAL) && self.is_in_function()
+    }
+
+    /// Whether we can expect type parameters and co in a given type.
+    fn can_expect_ty_params(self) -> bool {
+        // rust-defined functions, as well as FnPtrs
+        self.contains(Self::THEORETICAL) || self.is_in_defined_function()
+    }
+}
+
+/// Visitor used to recursively traverse MIR types and evaluate FFI-safety.
+/// It uses ``check_*`` methods as entrypoints to be called elsewhere,
+/// and ``visit_*`` methods to recurse.
+struct ImproperCTypesVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    /// To prevent problems with recursive types,
+    /// add a types-in-check cache.
     cache: FxHashSet<Ty<'tcx>>,
     /// The original type being checked, before we recursed
     /// to any other types it contains.
     base_ty: Ty<'tcx>,
+    base_fn_mode: CItemKind,
 }
 
 impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
+    fn new(cx: &'a LateContext<'tcx>, base_ty: Ty<'tcx>, base_fn_mode: CItemKind) -> Self {
+        Self { cx, base_ty, base_fn_mode, cache: FxHashSet::default() }
+    }
+
     /// Checks if the given field's type is "ffi-safe".
     fn check_field_type_for_ffi(
-        &self,
-        acc: &mut CTypesVisitorState<'tcx>,
+        &mut self,
+        state: VisitorState,
         field: &ty::FieldDef,
         args: GenericArgsRef<'tcx>,
     ) -> FfiResult<'tcx> {
@@ -217,13 +377,13 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
             .tcx
             .try_normalize_erasing_regions(self.cx.typing_env(), field_ty)
             .unwrap_or(field_ty);
-        self.visit_type(acc, field_ty)
+        self.visit_type(state, field_ty)
     }
 
     /// Checks if the given `VariantDef`'s field types are "ffi-safe".
     fn check_variant_for_ffi(
-        &self,
-        acc: &mut CTypesVisitorState<'tcx>,
+        &mut self,
+        state: VisitorState,
         ty: Ty<'tcx>,
         def: ty::AdtDef<'tcx>,
         variant: &ty::VariantDef,
@@ -233,7 +393,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
         let transparent_with_all_zst_fields = if def.repr().transparent() {
             if let Some(field) = super::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(acc, field, args) {
+                match self.check_field_type_for_ffi(state, field, args) {
                     FfiUnsafe { ty, .. } if ty.is_unit() => (),
                     r => return r,
                 }
@@ -251,7 +411,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(acc, field, args) {
+            all_phantom &= match self.check_field_type_for_ffi(state, field, args) {
                 FfiSafe => false,
                 // `()` fields are FFI-safe!
                 FfiUnsafe { ty, .. } if ty.is_unit() => false,
@@ -271,7 +431,7 @@ 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 visit_type(&self, acc: &mut CTypesVisitorState<'tcx>, ty: Ty<'tcx>) -> FfiResult<'tcx> {
+    fn visit_type(&mut self, state: VisitorState, ty: Ty<'tcx>) -> FfiResult<'tcx> {
         use FfiResult::*;
 
         let tcx = self.cx.tcx;
@@ -280,14 +440,19 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
         // `struct S(*mut S);`.
         // FIXME: A recursion limit is necessary as well, for irregular
         // recursive types.
-        if !acc.cache.insert(ty) {
+        if !self.cache.insert(ty) {
             return FfiSafe;
         }
 
         match *ty.kind() {
             ty::Adt(def, args) => {
                 if let Some(boxed) = ty.boxed_ty()
-                    && matches!(self.mode, CItemKind::Definition)
+                    && (
+                        // FIXME(ctypes): this logic is broken, but it still fits the current tests
+                        state.is_in_defined_function()
+                            || (state.is_in_fnptr()
+                                && matches!(self.base_fn_mode, CItemKind::Definition))
+                    )
                 {
                     if boxed.is_sized(tcx, self.cx.typing_env()) {
                         return FfiSafe;
@@ -306,7 +471,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
                     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()
+                            && !self.base_ty.is_mutable_ptr()
                         {
                             return FfiUnsafe {
                                 ty,
@@ -359,7 +524,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
                             };
                         }
 
-                        self.check_variant_for_ffi(acc, ty, def, def.non_enum_variant(), args)
+                        self.check_variant_for_ffi(state, ty, def, def.non_enum_variant(), args)
                     }
                     AdtKind::Enum => {
                         if def.variants().is_empty() {
@@ -374,7 +539,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
                             if let Some(ty) =
                                 repr_nullable_ptr(self.cx.tcx, self.cx.typing_env(), ty)
                             {
-                                return self.visit_type(acc, ty);
+                                return self.visit_type(state, ty);
                             }
 
                             return FfiUnsafe {
@@ -390,7 +555,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
                             check_non_exhaustive_variant(non_exhaustive, variant)
                                 .map_break(|reason| FfiUnsafe { ty, reason, help: None })?;
 
-                            match self.check_variant_for_ffi(acc, ty, def, variant, args) {
+                            match self.check_variant_for_ffi(state, ty, def, variant, args) {
                                 FfiSafe => ControlFlow::Continue(()),
                                 r => ControlFlow::Break(r),
                             }
@@ -412,7 +577,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
 
             // It's just extra invariants on the type that you need to uphold,
             // but only the base type is relevant for being representable in FFI.
-            ty::Pat(base, ..) => self.visit_type(acc, base),
+            ty::Pat(base, ..) => self.visit_type(state, base),
 
             // Primitive types with a stable representation.
             ty::Bool | ty::Int(..) | ty::Uint(..) | ty::Float(..) | ty::Never => FfiSafe,
@@ -441,7 +606,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
 
             ty::RawPtr(ty, _) | ty::Ref(_, ty, _)
                 if {
-                    matches!(self.mode, CItemKind::Definition)
+                    (state.is_in_defined_function() || state.is_in_fnptr())
                         && ty.is_sized(self.cx.tcx, self.cx.typing_env())
                 } =>
             {
@@ -457,9 +622,9 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
                 FfiSafe
             }
 
-            ty::RawPtr(ty, _) | ty::Ref(_, ty, _) => self.visit_type(acc, ty),
+            ty::RawPtr(ty, _) | ty::Ref(_, ty, _) => self.visit_type(state, ty),
 
-            ty::Array(inner_ty, _) => self.visit_type(acc, inner_ty),
+            ty::Array(inner_ty, _) => self.visit_type(state, inner_ty),
 
             ty::FnPtr(sig_tys, hdr) => {
                 let sig = sig_tys.with(hdr);
@@ -473,7 +638,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
 
                 let sig = tcx.instantiate_bound_regions_with_erased(sig);
                 for arg in sig.inputs() {
-                    match self.visit_type(acc, *arg) {
+                    match self.visit_type(VisitorState::ARGUMENT_TY_IN_FNPTR, *arg) {
                         FfiSafe => {}
                         r => return r,
                     }
@@ -484,7 +649,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
                     return FfiSafe;
                 }
 
-                self.visit_type(acc, ret_ty)
+                self.visit_type(VisitorState::RETURN_TY_IN_FNPTR, ret_ty)
             }
 
             ty::Foreign(..) => FfiSafe,
@@ -498,7 +663,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
             // `extern "C" fn` functions can have type parameters, which may or may not be FFI-safe,
             //  so they are currently ignored for the purposes of this lint.
             ty::Param(..) | ty::Alias(ty::Projection | ty::Inherent, ..)
-                if matches!(self.mode, CItemKind::Definition) =>
+                if state.can_expect_ty_params() =>
             {
                 FfiSafe
             }
@@ -545,7 +710,11 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
             .visit_with(&mut ProhibitOpaqueTypes)
             .break_value()
         {
-            Some(FfiResult::FfiUnsafe { ty, reason: fluent::lint_improper_ctypes_opaque, help: None })
+            Some(FfiResult::FfiUnsafe {
+                ty,
+                reason: fluent::lint_improper_ctypes_opaque,
+                help: None,
+            })
         } else {
             None
         }
@@ -565,17 +734,9 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
     }
 
     /// Determine the FFI-safety of a single (MIR) type, given the context of how it is used.
-    fn check_type(
-        &mut self,
-        ty: Ty<'tcx>,
-        is_static: bool,
-        is_return_type: bool,
-    ) -> FfiResult<'tcx> {
-        match self.visit_for_opaque_ty(ty) {
-            None => {}
-            Some(res) => {
-                return res;
-            }
+    fn check_type(&mut self, state: VisitorState, ty: Ty<'tcx>) -> FfiResult<'tcx> {
+        if let Some(res) = self.visit_for_opaque_ty(ty) {
+            return res;
         }
 
         let ty = self.cx.tcx.try_normalize_erasing_regions(self.cx.typing_env(), ty).unwrap_or(ty);
@@ -583,94 +744,20 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
         // C doesn't really support passing arrays by value - the only way to pass an array by value
         // is through a struct. So, first test that the top level isn't an array, and then
         // recursively check the types inside.
-        if !is_static {
-            match self.check_for_array_ty(ty) {
-                None => {}
-                Some(res) => {
-                    return res;
-                }
+        if state.is_in_function() {
+            if let Some(res) = self.check_for_array_ty(ty) {
+                return res;
             }
         }
 
         // Don't report FFI errors for unit return types. This check exists here, and not in
         // the caller (where it would make more sense) so that normalization has definitely
         // happened.
-        if is_return_type && ty.is_unit() {
+        if state.is_in_function_return() && ty.is_unit() {
             return FfiResult::FfiSafe;
         }
 
-        let mut acc = CTypesVisitorState { cache: Default::default(), base_ty: ty };
-        self.visit_type(&mut acc, ty)
-    }
-
-    /// Per-struct-field function that checks if a struct definition follows
-    /// the Power alignment Rule (see the `check_struct_for_power_alignment` method).
-    fn check_arg_for_power_alignment(&mut self, ty: Ty<'tcx>) -> bool {
-        let tcx = self.cx.tcx;
-        assert!(tcx.sess.target.os == "aix");
-        // Structs (under repr(C)) follow the power alignment rule if:
-        //   - the first field of the struct is a floating-point type that
-        //     is greater than 4-bytes, or
-        //   - the first field of the struct is an aggregate whose
-        //     recursively first field is a floating-point type greater than
-        //     4 bytes.
-        if ty.is_floating_point() && ty.primitive_size(tcx).bytes() > 4 {
-            return true;
-        } else if let Adt(adt_def, _) = ty.kind()
-            && adt_def.is_struct()
-            && adt_def.repr().c()
-            && !adt_def.repr().packed()
-            && adt_def.repr().align.is_none()
-        {
-            let struct_variant = adt_def.variant(VariantIdx::ZERO);
-            // Within a nested struct, all fields are examined to correctly
-            // report if any fields after the nested struct within the
-            // original struct are misaligned.
-            for struct_field in &struct_variant.fields {
-                let field_ty = tcx.type_of(struct_field.did).instantiate_identity();
-                if self.check_arg_for_power_alignment(field_ty) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-    /// Check a struct definition for respect of the Power alignment Rule (as in PowerPC),
-    /// which should be respected in the "aix" target OS.
-    /// To do so, we must follow one of the two following conditions:
-    /// - The first field of the struct must be floating-point type that
-    ///    is greater than 4-bytes.
-    ///  - The first field of the struct must be an aggregate whose
-    ///    recursively first field is a floating-point type greater than
-    ///    4 bytes.
-    fn check_struct_for_power_alignment(&mut self, item: &'tcx hir::Item<'tcx>) {
-        let tcx = self.cx.tcx;
-        let adt_def = tcx.adt_def(item.owner_id.to_def_id());
-        // repr(C) structs also with packed or aligned representation
-        // should be ignored.
-        if adt_def.repr().c()
-            && !adt_def.repr().packed()
-            && adt_def.repr().align.is_none()
-            && tcx.sess.target.os == "aix"
-            && !adt_def.all_fields().next().is_none()
-        {
-            let struct_variant_data = item.expect_struct().2;
-            for field_def in struct_variant_data.fields().iter().skip(1) {
-                // Struct fields (after the first field) are checked for the
-                // power alignment rule, as fields after the first are likely
-                // to be the fields that are misaligned.
-                let def_id = field_def.def_id;
-                let ty = tcx.type_of(def_id).instantiate_identity();
-                if self.check_arg_for_power_alignment(ty) {
-                    self.cx.emit_span_lint(
-                        USES_POWER_ALIGNMENT,
-                        field_def.span,
-                        UsesPowerAlignment,
-                    );
-                }
-            }
-        }
+        self.visit_type(state, ty)
     }
 }
 
@@ -680,11 +767,10 @@ impl<'tcx> ImproperCTypesLint {
     fn check_type_for_external_abi_fnptr(
         &mut self,
         cx: &LateContext<'tcx>,
+        state: VisitorState,
         hir_ty: &hir::Ty<'tcx>,
         ty: Ty<'tcx>,
         fn_mode: CItemKind,
-        is_static: bool,
-        is_return: bool,
     ) {
         struct FnPtrFinder<'tcx> {
             spans: Vec<Span>,
@@ -724,9 +810,9 @@ impl<'tcx> ImproperCTypesLint {
 
         let all_types = iter::zip(visitor.tys.drain(..), visitor.spans.drain(..));
         for (fn_ptr_ty, span) in all_types {
-            let mut visitor = ImproperCTypesVisitor { cx, mode: fn_mode };
-            // TODO: make a check_for_fnptr
-            let ffi_res = visitor.check_type(fn_ptr_ty, is_static, is_return);
+            let mut visitor = ImproperCTypesVisitor::new(cx, fn_ptr_ty, fn_mode);
+            // FIXME(ctypes): make a check_for_fnptr
+            let ffi_res = visitor.check_type(state, fn_ptr_ty);
 
             self.process_ffi_result(cx, span, ffi_res, fn_mode);
         }
@@ -745,11 +831,13 @@ impl<'tcx> ImproperCTypesLint {
         let sig = cx.tcx.instantiate_bound_regions_with_erased(sig);
 
         for (input_ty, input_hir) in iter::zip(sig.inputs(), decl.inputs) {
-            self.check_type_for_external_abi_fnptr(cx, input_hir, *input_ty, fn_mode, false, false);
+            let state = VisitorState::argument_from_fnmode(fn_mode);
+            self.check_type_for_external_abi_fnptr(cx, state, input_hir, *input_ty, fn_mode);
         }
 
         if let hir::FnRetTy::Return(ret_hir) = decl.output {
-            self.check_type_for_external_abi_fnptr(cx, ret_hir, sig.output(), fn_mode, false, true);
+            let state = VisitorState::return_from_fnmode(fn_mode);
+            self.check_type_for_external_abi_fnptr(cx, state, ret_hir, sig.output(), fn_mode);
         }
     }
 
@@ -764,18 +852,16 @@ impl<'tcx> ImproperCTypesLint {
             adt_def.repr().c() && !adt_def.repr().packed() && adt_def.repr().align.is_none()
         );
 
-        let mut visitor = ImproperCTypesVisitor { cx, mode: CItemKind::Declaration };
-
         // FIXME(ctypes): this following call is awkward.
         // is there a way to perform its logic in MIR space rather than HIR space?
         // (so that its logic can be absorbed into visitor.visit_struct_or_union)
-        visitor.check_struct_for_power_alignment(item);
+        check_struct_for_power_alignment(cx, item, adt_def);
     }
 
     fn check_foreign_static(&mut self, cx: &LateContext<'tcx>, id: hir::OwnerId, span: Span) {
         let ty = cx.tcx.type_of(id).instantiate_identity();
-        let mut visitor = ImproperCTypesVisitor { cx, mode: CItemKind::Declaration };
-        let ffi_res = visitor.check_type(ty, true, false);
+        let mut visitor = ImproperCTypesVisitor::new(cx, ty, CItemKind::Declaration);
+        let ffi_res = visitor.check_type(VisitorState::STATIC_TY, ty);
         self.process_ffi_result(cx, span, ffi_res, CItemKind::Declaration);
     }
 
@@ -791,14 +877,16 @@ impl<'tcx> ImproperCTypesLint {
         let sig = cx.tcx.instantiate_bound_regions_with_erased(sig);
 
         for (input_ty, input_hir) in iter::zip(sig.inputs(), decl.inputs) {
-            let mut visitor = ImproperCTypesVisitor { cx, mode: fn_mode };
-            let ffi_res = visitor.check_type(*input_ty, false, false);
+            let state = VisitorState::argument_from_fnmode(fn_mode);
+            let mut visitor = ImproperCTypesVisitor::new(cx, *input_ty, fn_mode);
+            let ffi_res = visitor.check_type(state, *input_ty);
             self.process_ffi_result(cx, input_hir.span, ffi_res, fn_mode);
         }
 
         if let hir::FnRetTy::Return(ret_hir) = decl.output {
-            let mut visitor = ImproperCTypesVisitor { cx, mode: fn_mode };
-            let ffi_res = visitor.check_type(sig.output(), false, true);
+            let state = VisitorState::return_from_fnmode(fn_mode);
+            let mut visitor = ImproperCTypesVisitor::new(cx, sig.output(), fn_mode);
+            let ffi_res = visitor.check_type(state, sig.output());
             self.process_ffi_result(cx, ret_hir.span, ffi_res, fn_mode);
         }
     }
@@ -897,11 +985,10 @@ impl<'tcx> LateLintPass<'tcx> for ImproperCTypesLint {
             | hir::ItemKind::TyAlias(_, _, ty) => {
                 self.check_type_for_external_abi_fnptr(
                     cx,
+                    VisitorState::STATIC_TY,
                     ty,
                     cx.tcx.type_of(item.owner_id).instantiate_identity(),
                     CItemKind::Definition,
-                    true,
-                    false,
                 );
             }
             // See `check_fn` for declarations, `check_foreign_items` for definitions in extern blocks
@@ -932,11 +1019,10 @@ impl<'tcx> LateLintPass<'tcx> for ImproperCTypesLint {
     fn check_field_def(&mut self, cx: &LateContext<'tcx>, field: &'tcx hir::FieldDef<'tcx>) {
         self.check_type_for_external_abi_fnptr(
             cx,
+            VisitorState::STATIC_TY,
             field.ty,
             cx.tcx.type_of(field.def_id).instantiate_identity(),
             CItemKind::Definition,
-            true,
-            false,
         );
     }
 

From 24c34d738f00f0f38b88cead5ab869d156513609 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Mon, 25 Aug 2025 17:20:37 +0200
Subject: [PATCH 0597/1889] extend the let-chain

removes one level of nesting
---
 clippy_lints/src/future_not_send.rs | 107 ++++++++++++++--------------
 1 file changed, 53 insertions(+), 54 deletions(-)

diff --git a/clippy_lints/src/future_not_send.rs b/clippy_lints/src/future_not_send.rs
index 3ccfa51ab70b7..2788b89f1439c 100644
--- a/clippy_lints/src/future_not_send.rs
+++ b/clippy_lints/src/future_not_send.rs
@@ -78,66 +78,65 @@ impl<'tcx> LateLintPass<'tcx> for FutureNotSend {
         if let ty::Alias(ty::Opaque, AliasTy { def_id, args, .. }) = *ret_ty.kind()
             && let Some(future_trait) = cx.tcx.lang_items().future_trait()
             && let Some(send_trait) = cx.tcx.get_diagnostic_item(sym::Send)
-        {
-            let preds = cx.tcx.explicit_item_self_bounds(def_id);
-            let is_future = preds.iter_instantiated_copied(cx.tcx, args).any(|(p, _)| {
+            && let preds = cx.tcx.explicit_item_self_bounds(def_id)
+            // If is a Future
+            && preds.iter_instantiated_copied(cx.tcx, args).any(|(p, _)| {
                 p.as_trait_clause()
                     .is_some_and(|trait_pred| trait_pred.skip_binder().trait_ref.def_id == future_trait)
-            });
-            if is_future {
-                let span = decl.output.span();
-                let infcx = cx.tcx.infer_ctxt().build(cx.typing_mode());
-                let ocx = ObligationCtxt::new_with_diagnostics(&infcx);
-                let cause = traits::ObligationCause::misc(span, fn_def_id);
-                ocx.register_bound(cause, cx.param_env, ret_ty, send_trait);
-                let send_errors = ocx.select_all_or_error();
+            })
+        {
+            let span = decl.output.span();
+            let infcx = cx.tcx.infer_ctxt().build(cx.typing_mode());
+            let ocx = ObligationCtxt::new_with_diagnostics(&infcx);
+            let cause = traits::ObligationCause::misc(span, fn_def_id);
+            ocx.register_bound(cause, cx.param_env, ret_ty, send_trait);
+            let send_errors = ocx.select_all_or_error();
 
-                // Allow errors that try to prove `Send` for types that "mention" a generic parameter at the "top
-                // level".
-                // For example, allow errors that `T: Send` can't be proven, but reject `Rc<T>: Send` errors,
-                // which is always unconditionally `!Send` for any possible type `T`.
-                //
-                // We also allow associated type projections if the self type is either itself a projection or a
-                // type parameter.
-                // This is to prevent emitting warnings for e.g. holding a `<Fut as Future>::Output` across await
-                // points, where `Fut` is a type parameter.
+            // Allow errors that try to prove `Send` for types that "mention" a generic parameter at the "top
+            // level".
+            // For example, allow errors that `T: Send` can't be proven, but reject `Rc<T>: Send` errors,
+            // which is always unconditionally `!Send` for any possible type `T`.
+            //
+            // We also allow associated type projections if the self type is either itself a projection or a
+            // type parameter.
+            // This is to prevent emitting warnings for e.g. holding a `<Fut as Future>::Output` across await
+            // points, where `Fut` is a type parameter.
 
-                let is_send = send_errors.iter().all(|err| {
-                    err.obligation
-                        .predicate
-                        .as_trait_clause()
-                        .map(Binder::skip_binder)
-                        .is_some_and(|pred| {
-                            pred.def_id() == send_trait
-                                && pred.self_ty().has_param()
-                                && TyParamAtTopLevelVisitor.visit_ty(pred.self_ty()) == ControlFlow::Break(true)
-                        })
-                });
+            let is_send = send_errors.iter().all(|err| {
+                err.obligation
+                    .predicate
+                    .as_trait_clause()
+                    .map(Binder::skip_binder)
+                    .is_some_and(|pred| {
+                        pred.def_id() == send_trait
+                            && pred.self_ty().has_param()
+                            && TyParamAtTopLevelVisitor.visit_ty(pred.self_ty()) == ControlFlow::Break(true)
+                    })
+            });
 
-                if !is_send {
-                    span_lint_and_then(
-                        cx,
-                        FUTURE_NOT_SEND,
-                        span,
-                        "future cannot be sent between threads safely",
-                        |db| {
-                            for FulfillmentError { obligation, .. } in send_errors {
-                                infcx
-                                    .err_ctxt()
-                                    .maybe_note_obligation_cause_for_async_await(db, &obligation);
-                                if let PredicateKind::Clause(ClauseKind::Trait(trait_pred)) =
-                                    obligation.predicate.kind().skip_binder()
-                                {
-                                    db.note(format!(
-                                        "`{}` doesn't implement `{}`",
-                                        trait_pred.self_ty(),
-                                        trait_pred.trait_ref.print_only_trait_path(),
-                                    ));
-                                }
+            if !is_send {
+                span_lint_and_then(
+                    cx,
+                    FUTURE_NOT_SEND,
+                    span,
+                    "future cannot be sent between threads safely",
+                    |db| {
+                        for FulfillmentError { obligation, .. } in send_errors {
+                            infcx
+                                .err_ctxt()
+                                .maybe_note_obligation_cause_for_async_await(db, &obligation);
+                            if let PredicateKind::Clause(ClauseKind::Trait(trait_pred)) =
+                                obligation.predicate.kind().skip_binder()
+                            {
+                                db.note(format!(
+                                    "`{}` doesn't implement `{}`",
+                                    trait_pred.self_ty(),
+                                    trait_pred.trait_ref.print_only_trait_path(),
+                                ));
                             }
-                        },
-                    );
-                }
+                        }
+                    },
+                );
             }
         }
     }

From fe86ce6bcc07ff199c804a6a2e0a66c8557c5364 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sun, 7 Sep 2025 00:13:40 +0200
Subject: [PATCH 0598/1889] split `any` in two parts

---
 clippy_lints/src/future_not_send.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/clippy_lints/src/future_not_send.rs b/clippy_lints/src/future_not_send.rs
index 2788b89f1439c..596047977a9b1 100644
--- a/clippy_lints/src/future_not_send.rs
+++ b/clippy_lints/src/future_not_send.rs
@@ -80,10 +80,10 @@ impl<'tcx> LateLintPass<'tcx> for FutureNotSend {
             && let Some(send_trait) = cx.tcx.get_diagnostic_item(sym::Send)
             && let preds = cx.tcx.explicit_item_self_bounds(def_id)
             // If is a Future
-            && preds.iter_instantiated_copied(cx.tcx, args).any(|(p, _)| {
-                p.as_trait_clause()
-                    .is_some_and(|trait_pred| trait_pred.skip_binder().trait_ref.def_id == future_trait)
-            })
+            && preds
+                .iter_instantiated_copied(cx.tcx, args)
+                .filter_map(|(p, _)| p.as_trait_clause())
+                .any(|trait_pred| trait_pred.skip_binder().trait_ref.def_id == future_trait)
         {
             let span = decl.output.span();
             let infcx = cx.tcx.infer_ctxt().build(cx.typing_mode());

From 52f74a5162e20e6b9bc8a94f61009fd9d4f38fdb Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Tue, 1 Jul 2025 08:17:01 +0000
Subject: [PATCH 0599/1889] Allow simplifying aggregates if LHS is not a simple
 local.

---
 compiler/rustc_mir_transform/src/gvn.rs       | 45 +++++++------------
 tests/mir-opt/gvn_overlapping.fields.GVN.diff | 14 ++++++
 tests/mir-opt/gvn_overlapping.rs              | 42 ++++++++++++++++-
 ...gvn_overlapping.stable_projection.GVN.diff | 19 ++++++++
 4 files changed, 90 insertions(+), 30 deletions(-)
 create mode 100644 tests/mir-opt/gvn_overlapping.fields.GVN.diff
 create mode 100644 tests/mir-opt/gvn_overlapping.stable_projection.GVN.diff

diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index 5a13394543b4a..754469a35d5c2 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -895,18 +895,13 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
 
     fn simplify_aggregate_to_copy(
         &mut self,
-        lhs: &Place<'tcx>,
-        rvalue: &mut Rvalue<'tcx>,
-        location: Location,
-        fields: &[VnIndex],
+        ty: Ty<'tcx>,
         variant_index: VariantIdx,
+        fields: &[VnIndex],
     ) -> Option<VnIndex> {
-        let Some(&first_field) = fields.first() else {
-            return None;
-        };
-        let Value::Projection(copy_from_value, _) = *self.get(first_field) else {
-            return None;
-        };
+        let Some(&first_field) = fields.first() else { return None };
+        let Value::Projection(copy_from_value, _) = *self.get(first_field) else { return None };
+
         // All fields must correspond one-to-one and come from the same aggregate value.
         if fields.iter().enumerate().any(|(index, &v)| {
             if let Value::Projection(pointer, ProjectionElem::Field(from_index, _)) = *self.get(v)
@@ -933,21 +928,8 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             }
         }
 
-        // Allow introducing places with non-constant offsets, as those are still better than
-        // reconstructing an aggregate.
-        if self.ty(copy_from_local_value) == rvalue.ty(self.local_decls, self.tcx)
-            && let Some(place) = self.try_as_place(copy_from_local_value, location, true)
-        {
-            // Avoid creating `*a = copy (*b)`, as they might be aliases resulting in overlapping assignments.
-            // FIXME: This also avoids any kind of projection, not just derefs. We can add allowed projections.
-            if lhs.as_local().is_some() {
-                self.reused_locals.insert(place.local);
-                *rvalue = Rvalue::Use(Operand::Copy(place));
-            }
-            return Some(copy_from_local_value);
-        }
-
-        None
+        // Both must be variants of the same type.
+        if self.ty(copy_from_local_value) == ty { Some(copy_from_local_value) } else { None }
     }
 
     fn simplify_aggregate(
@@ -1034,9 +1016,16 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             }
         }
 
-        if let Some(value) =
-            self.simplify_aggregate_to_copy(lhs, rvalue, location, &fields, variant_index)
-        {
+        if let Some(value) = self.simplify_aggregate_to_copy(ty, variant_index, &fields) {
+            // Allow introducing places with non-constant offsets, as those are still better than
+            // reconstructing an aggregate. But avoid creating `*a = copy (*b)`, as they might be
+            // aliases resulting in overlapping assignments.
+            let allow_complex_projection =
+                lhs.projection[..].iter().all(PlaceElem::is_stable_offset);
+            if let Some(place) = self.try_as_place(value, location, allow_complex_projection) {
+                self.reused_locals.insert(place.local);
+                *rvalue = Rvalue::Use(Operand::Copy(place));
+            }
             return Some(value);
         }
 
diff --git a/tests/mir-opt/gvn_overlapping.fields.GVN.diff b/tests/mir-opt/gvn_overlapping.fields.GVN.diff
new file mode 100644
index 0000000000000..0548f4e42e434
--- /dev/null
+++ b/tests/mir-opt/gvn_overlapping.fields.GVN.diff
@@ -0,0 +1,14 @@
+- // MIR for `fields` before GVN
++ // MIR for `fields` after GVN
+  
+  fn fields(_1: (Adt, Adt)) -> () {
+      let mut _0: ();
+      let mut _2: u32;
+  
+      bb0: {
+          _2 = copy (((_1.0: Adt) as variant#1).0: u32);
+          (_1.1: Adt) = Adt::Some(copy _2);
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/gvn_overlapping.rs b/tests/mir-opt/gvn_overlapping.rs
index 99113445e683d..f148a84356125 100644
--- a/tests/mir-opt/gvn_overlapping.rs
+++ b/tests/mir-opt/gvn_overlapping.rs
@@ -2,11 +2,10 @@
 
 #![feature(custom_mir, core_intrinsics)]
 
-// Check that we do not create overlapping assignments.
-
 use std::intrinsics::mir::*;
 
 // EMIT_MIR gvn_overlapping.overlapping.GVN.diff
+/// Check that we do not create overlapping assignments.
 #[custom_mir(dialect = "runtime")]
 fn overlapping(_17: Adt) {
     // CHECK-LABEL: fn overlapping(
@@ -26,6 +25,45 @@ fn overlapping(_17: Adt) {
     }
 }
 
+// EMIT_MIR gvn_overlapping.stable_projection.GVN.diff
+/// Check that we allow dereferences in the RHS if the LHS is a stable projection.
+#[custom_mir(dialect = "runtime")]
+fn stable_projection(_1: (Adt,)) {
+    // CHECK-LABEL: fn stable_projection(
+    // CHECK: let mut _2: *mut Adt;
+    // CHECK: let mut _4: &Adt;
+    // CHECK: (_1.0: Adt) = copy (*_4);
+    mir! {
+        let _2: *mut Adt;
+        let _3: u32;
+        let _4: &Adt;
+        {
+            _2 = core::ptr::addr_of_mut!(_1.0);
+            _4 = &(*_2);
+            _3 = Field(Variant((*_4), 1), 0);
+            _1.0 = Adt::Some(_3);
+            Return()
+        }
+    }
+}
+
+// EMIT_MIR gvn_overlapping.fields.GVN.diff
+/// Check that we do not create assignments between different fields of the same local.
+#[custom_mir(dialect = "runtime")]
+fn fields(_1: (Adt, Adt)) {
+    // CHECK-LABEL: fn fields(
+    // CHECK: _2 = copy (((_1.0: Adt) as variant#1).0: u32);
+    // CHECK-NEXT: (_1.1: Adt) = Adt::Some(copy _2);
+    mir! {
+        let _2: u32;
+        {
+            _2 = Field(Variant(_1.0, 1), 0);
+            _1.1 = Adt::Some(_2);
+            Return()
+        }
+    }
+}
+
 fn main() {
     overlapping(Adt::Some(0));
 }
diff --git a/tests/mir-opt/gvn_overlapping.stable_projection.GVN.diff b/tests/mir-opt/gvn_overlapping.stable_projection.GVN.diff
new file mode 100644
index 0000000000000..0883545659113
--- /dev/null
+++ b/tests/mir-opt/gvn_overlapping.stable_projection.GVN.diff
@@ -0,0 +1,19 @@
+- // MIR for `stable_projection` before GVN
++ // MIR for `stable_projection` after GVN
+  
+  fn stable_projection(_1: (Adt,)) -> () {
+      let mut _0: ();
+      let mut _2: *mut Adt;
+      let mut _3: u32;
+      let mut _4: &Adt;
+  
+      bb0: {
+          _2 = &raw mut (_1.0: Adt);
+          _4 = &(*_2);
+          _3 = copy (((*_4) as variant#1).0: u32);
+-         (_1.0: Adt) = Adt::Some(copy _3);
++         (_1.0: Adt) = copy (*_4);
+          return;
+      }
+  }
+  

From 58e2cd4263930426b7dbb9f645b733693c5f26e7 Mon Sep 17 00:00:00 2001
From: WANG Rui <wangrui@loongson.cn>
Date: Sun, 7 Sep 2025 11:24:08 +0800
Subject: [PATCH 0600/1889] Revert "Add LSX accelerated implementation for
 source file analysis"

This reverts commit 5b43244ac59119870c9e0f6b642340ab88355b23 to fix
native build failures on LoongArch.
---
 .../rustc_span/src/analyze_source_file.rs     | 109 +-----------------
 compiler/rustc_span/src/lib.rs                |   1 -
 2 files changed, 3 insertions(+), 107 deletions(-)

diff --git a/compiler/rustc_span/src/analyze_source_file.rs b/compiler/rustc_span/src/analyze_source_file.rs
index bb2cda77dffff..c32593a6d95ab 100644
--- a/compiler/rustc_span/src/analyze_source_file.rs
+++ b/compiler/rustc_span/src/analyze_source_file.rs
@@ -81,8 +81,8 @@ cfg_select! {
                 // use `loadu`, which supports unaligned loading.
                 let chunk = unsafe { _mm_loadu_si128(chunk.as_ptr() as *const __m128i) };
 
-                // For each character in the chunk, see if its byte value is < 0,
-                // which indicates that it's part of a UTF-8 char.
+                // For character in the chunk, see if its byte value is < 0, which
+                // indicates that it's part of a UTF-8 char.
                 let multibyte_test = _mm_cmplt_epi8(chunk, _mm_set1_epi8(0));
                 // Create a bit mask from the comparison results.
                 let multibyte_mask = _mm_movemask_epi8(multibyte_test);
@@ -132,111 +132,8 @@ cfg_select! {
             }
         }
     }
-    target_arch = "loongarch64" => {
-        fn analyze_source_file_dispatch(
-            src: &str,
-            lines: &mut Vec<RelativeBytePos>,
-            multi_byte_chars: &mut Vec<MultiByteChar>,
-        ) {
-            use std::arch::is_loongarch_feature_detected;
-
-            if is_loongarch_feature_detected!("lsx") {
-                unsafe {
-                    analyze_source_file_lsx(src, lines, multi_byte_chars);
-                }
-            } else {
-                analyze_source_file_generic(
-                    src,
-                    src.len(),
-                    RelativeBytePos::from_u32(0),
-                    lines,
-                    multi_byte_chars,
-                );
-            }
-        }
-
-        /// Checks 16 byte chunks of text at a time. If the chunk contains
-        /// something other than printable ASCII characters and newlines, the
-        /// function falls back to the generic implementation. Otherwise it uses
-        /// LSX intrinsics to quickly find all newlines.
-        #[target_feature(enable = "lsx")]
-        unsafe fn analyze_source_file_lsx(
-            src: &str,
-            lines: &mut Vec<RelativeBytePos>,
-            multi_byte_chars: &mut Vec<MultiByteChar>,
-        ) {
-            use std::arch::loongarch64::*;
-
-            const CHUNK_SIZE: usize = 16;
-
-            let (chunks, tail) = src.as_bytes().as_chunks::<CHUNK_SIZE>();
-
-            // This variable keeps track of where we should start decoding a
-            // chunk. If a multi-byte character spans across chunk boundaries,
-            // we need to skip that part in the next chunk because we already
-            // handled it.
-            let mut intra_chunk_offset = 0;
-
-            for (chunk_index, chunk) in chunks.iter().enumerate() {
-                // All LSX memory instructions support unaligned access, so using
-                // vld is fine.
-                let chunk = unsafe { lsx_vld::<0>(chunk.as_ptr() as *const i8) };
-
-                // For each character in the chunk, see if its byte value is < 0,
-                // which indicates that it's part of a UTF-8 char.
-                let multibyte_mask = lsx_vmskltz_b(chunk);
-                // Create a bit mask from the comparison results.
-                let multibyte_mask = lsx_vpickve2gr_w::<0>(multibyte_mask);
-
-                // If the bit mask is all zero, we only have ASCII chars here:
-                if multibyte_mask == 0 {
-                    assert!(intra_chunk_offset == 0);
-
-                    // Check for newlines in the chunk
-                    let newlines_test = lsx_vseqi_b::<{b'\n' as i32}>(chunk);
-                    let newlines_mask = lsx_vmskltz_b(newlines_test);
-                    let mut newlines_mask = lsx_vpickve2gr_w::<0>(newlines_mask);
-
-                    let output_offset = RelativeBytePos::from_usize(chunk_index * CHUNK_SIZE + 1);
-
-                    while newlines_mask != 0 {
-                        let index = newlines_mask.trailing_zeros();
-
-                        lines.push(RelativeBytePos(index) + output_offset);
-
-                        // Clear the bit, so we can find the next one.
-                        newlines_mask &= newlines_mask - 1;
-                    }
-                } else {
-                    // The slow path.
-                    // There are multibyte chars in here, fallback to generic decoding.
-                    let scan_start = chunk_index * CHUNK_SIZE + intra_chunk_offset;
-                    intra_chunk_offset = analyze_source_file_generic(
-                        &src[scan_start..],
-                        CHUNK_SIZE - intra_chunk_offset,
-                        RelativeBytePos::from_usize(scan_start),
-                        lines,
-                        multi_byte_chars,
-                    );
-                }
-            }
-
-            // There might still be a tail left to analyze
-            let tail_start = src.len() - tail.len() + intra_chunk_offset;
-            if tail_start < src.len() {
-                analyze_source_file_generic(
-                    &src[tail_start..],
-                    src.len() - tail_start,
-                    RelativeBytePos::from_usize(tail_start),
-                    lines,
-                    multi_byte_chars,
-                );
-            }
-        }
-    }
     _ => {
-        // The target (or compiler version) does not support vector instructions
-        // our specialized implementations need (x86 SSE2, loongarch64 LSX)...
+        // The target (or compiler version) does not support SSE2 ...
         fn analyze_source_file_dispatch(
             src: &str,
             lines: &mut Vec<RelativeBytePos>,
diff --git a/compiler/rustc_span/src/lib.rs b/compiler/rustc_span/src/lib.rs
index 8907c5e4c4aeb..ae6755f076424 100644
--- a/compiler/rustc_span/src/lib.rs
+++ b/compiler/rustc_span/src/lib.rs
@@ -18,7 +18,6 @@
 // tidy-alphabetical-start
 #![allow(internal_features)]
 #![cfg_attr(bootstrap, feature(round_char_boundary))]
-#![cfg_attr(target_arch = "loongarch64", feature(stdarch_loongarch))]
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
 #![doc(rust_logo)]
 #![feature(array_windows)]

From 01edb24d3ced043116a00bc45cc6c459b4ba9638 Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Sat, 6 Sep 2025 02:30:50 -0600
Subject: [PATCH 0601/1889] feat(std): emulate flock for solaris via fcntl

Upstream Solaris flock emulation to libstd from cargo.

This is borrowed from
https://github.com/rust-lang/cargo/blob/3b379fcc541b39321a7758552d37e5e0cc4277b9/src/cargo/util/flock.rs#L502-L536
which was implemented by an Oracle employee.
The code has been in cargo since 2022-12.

Python's `fcntl.flock` emulates like this as well:
https://github.com/python/cpython/blob/c919d02edecfe9d75fe374756fb8aa1db8d95f55/Modules/fcntlmodule.c#L337-L400

We did the same thing in
https://github.com/rust-lang/rust/blob/0d0f4eac8b98133e5da6d3604d86a8f3b5a67844/compiler/rustc_data_structures/src/flock/unix.rs#L13-L39
---
 library/std/src/fs/tests.rs    |  4 +++
 library/std/src/sys/fs/unix.rs | 66 ++++++++++++++++++++++++++++++++++
 2 files changed, 70 insertions(+)

diff --git a/library/std/src/fs/tests.rs b/library/std/src/fs/tests.rs
index f4431cedd180f..f8dfb0d633400 100644
--- a/library/std/src/fs/tests.rs
+++ b/library/std/src/fs/tests.rs
@@ -226,6 +226,7 @@ fn file_test_io_seek_and_write() {
     target_os = "freebsd",
     target_os = "linux",
     target_os = "netbsd",
+    target_os = "solaris",
     target_vendor = "apple",
 ))]
 fn file_lock_multiple_shared() {
@@ -249,6 +250,7 @@ fn file_lock_multiple_shared() {
     target_os = "freebsd",
     target_os = "linux",
     target_os = "netbsd",
+    target_os = "solaris",
     target_vendor = "apple",
 ))]
 fn file_lock_blocking() {
@@ -273,6 +275,7 @@ fn file_lock_blocking() {
     target_os = "freebsd",
     target_os = "linux",
     target_os = "netbsd",
+    target_os = "solaris",
     target_vendor = "apple",
 ))]
 fn file_lock_drop() {
@@ -294,6 +297,7 @@ fn file_lock_drop() {
     target_os = "freebsd",
     target_os = "linux",
     target_os = "netbsd",
+    target_os = "solaris",
     target_vendor = "apple",
 ))]
 fn file_lock_dup() {
diff --git a/library/std/src/sys/fs/unix.rs b/library/std/src/sys/fs/unix.rs
index 3b525406223c9..dfd6ce56a7682 100644
--- a/library/std/src/sys/fs/unix.rs
+++ b/library/std/src/sys/fs/unix.rs
@@ -1293,6 +1293,15 @@ impl File {
         return Ok(());
     }
 
+    #[cfg(target_os = "solaris")]
+    pub fn lock(&self) -> io::Result<()> {
+        let mut flock: libc::flock = unsafe { mem::zeroed() };
+        flock.l_type = libc::F_WRLCK as libc::c_short;
+        flock.l_whence = libc::SEEK_SET as libc::c_short;
+        cvt(unsafe { libc::fcntl(self.as_raw_fd(), libc::F_SETLKW, &flock) })?;
+        Ok(())
+    }
+
     #[cfg(not(any(
         target_os = "freebsd",
         target_os = "fuchsia",
@@ -1300,6 +1309,7 @@ impl File {
         target_os = "netbsd",
         target_os = "openbsd",
         target_os = "cygwin",
+        target_os = "solaris",
         target_vendor = "apple",
     )))]
     pub fn lock(&self) -> io::Result<()> {
@@ -1320,6 +1330,15 @@ impl File {
         return Ok(());
     }
 
+    #[cfg(target_os = "solaris")]
+    pub fn lock_shared(&self) -> io::Result<()> {
+        let mut flock: libc::flock = unsafe { mem::zeroed() };
+        flock.l_type = libc::F_RDLCK as libc::c_short;
+        flock.l_whence = libc::SEEK_SET as libc::c_short;
+        cvt(unsafe { libc::fcntl(self.as_raw_fd(), libc::F_SETLKW, &flock) })?;
+        Ok(())
+    }
+
     #[cfg(not(any(
         target_os = "freebsd",
         target_os = "fuchsia",
@@ -1327,6 +1346,7 @@ impl File {
         target_os = "netbsd",
         target_os = "openbsd",
         target_os = "cygwin",
+        target_os = "solaris",
         target_vendor = "apple",
     )))]
     pub fn lock_shared(&self) -> io::Result<()> {
@@ -1355,6 +1375,23 @@ impl File {
         }
     }
 
+    #[cfg(target_os = "solaris")]
+    pub fn try_lock(&self) -> Result<(), TryLockError> {
+        let mut flock: libc::flock = unsafe { mem::zeroed() };
+        flock.l_type = libc::F_WRLCK as libc::c_short;
+        flock.l_whence = libc::SEEK_SET as libc::c_short;
+        let result = cvt(unsafe { libc::fcntl(self.as_raw_fd(), libc::F_SETLK, &flock) });
+        if let Err(err) = result {
+            if err.kind() == io::ErrorKind::WouldBlock {
+                Err(TryLockError::WouldBlock)
+            } else {
+                Err(TryLockError::Error(err))
+            }
+        } else {
+            Ok(())
+        }
+    }
+
     #[cfg(not(any(
         target_os = "freebsd",
         target_os = "fuchsia",
@@ -1362,6 +1399,7 @@ impl File {
         target_os = "netbsd",
         target_os = "openbsd",
         target_os = "cygwin",
+        target_os = "solaris",
         target_vendor = "apple",
     )))]
     pub fn try_lock(&self) -> Result<(), TryLockError> {
@@ -1393,6 +1431,23 @@ impl File {
         }
     }
 
+    #[cfg(target_os = "solaris")]
+    pub fn try_lock_shared(&self) -> Result<(), TryLockError> {
+        let mut flock: libc::flock = unsafe { mem::zeroed() };
+        flock.l_type = libc::F_RDLCK as libc::c_short;
+        flock.l_whence = libc::SEEK_SET as libc::c_short;
+        let result = cvt(unsafe { libc::fcntl(self.as_raw_fd(), libc::F_SETLK, &flock) });
+        if let Err(err) = result {
+            if err.kind() == io::ErrorKind::WouldBlock {
+                Err(TryLockError::WouldBlock)
+            } else {
+                Err(TryLockError::Error(err))
+            }
+        } else {
+            Ok(())
+        }
+    }
+
     #[cfg(not(any(
         target_os = "freebsd",
         target_os = "fuchsia",
@@ -1400,6 +1455,7 @@ impl File {
         target_os = "netbsd",
         target_os = "openbsd",
         target_os = "cygwin",
+        target_os = "solaris",
         target_vendor = "apple",
     )))]
     pub fn try_lock_shared(&self) -> Result<(), TryLockError> {
@@ -1423,6 +1479,15 @@ impl File {
         return Ok(());
     }
 
+    #[cfg(target_os = "solaris")]
+    pub fn unlock(&self) -> io::Result<()> {
+        let mut flock: libc::flock = unsafe { mem::zeroed() };
+        flock.l_type = libc::F_UNLCK as libc::c_short;
+        flock.l_whence = libc::SEEK_SET as libc::c_short;
+        cvt(unsafe { libc::fcntl(self.as_raw_fd(), libc::F_SETLKW, &flock) })?;
+        Ok(())
+    }
+
     #[cfg(not(any(
         target_os = "freebsd",
         target_os = "fuchsia",
@@ -1430,6 +1495,7 @@ impl File {
         target_os = "netbsd",
         target_os = "openbsd",
         target_os = "cygwin",
+        target_os = "solaris",
         target_vendor = "apple",
     )))]
     pub fn unlock(&self) -> io::Result<()> {

From 589515bc8a1d4939c4a738e9bc895dcfb217d2d8 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sun, 7 Sep 2025 12:37:15 +0200
Subject: [PATCH 0602/1889] update Cargo.lock

---
 library/stdarch/Cargo.lock | 217 ++++++++++++++++++++++++++-----------
 1 file changed, 152 insertions(+), 65 deletions(-)

diff --git a/library/stdarch/Cargo.lock b/library/stdarch/Cargo.lock
index 9df0791b86523..a10a456acce1d 100644
--- a/library/stdarch/Cargo.lock
+++ b/library/stdarch/Cargo.lock
@@ -13,9 +13,9 @@ dependencies = [
 
 [[package]]
 name = "anstream"
-version = "0.6.19"
+version = "0.6.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "301af1932e46185686725e0fad2f8f2aa7da69dd70bf6ecc44d6b703844a3933"
+checksum = "3ae563653d1938f79b1ab1b5e668c87c76a9930414574a6583a7b7e11a8e6192"
 dependencies = [
  "anstyle",
  "anstyle-parse",
@@ -43,29 +43,29 @@ dependencies = [
 
 [[package]]
 name = "anstyle-query"
-version = "1.1.3"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c8bdeb6047d8983be085bab0ba1472e6dc604e7041dbf6fcd5e71523014fae9"
+checksum = "9e231f6134f61b71076a3eab506c379d4f36122f2af15a9ff04415ea4c3339e2"
 dependencies = [
- "windows-sys",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
 name = "anstyle-wincon"
-version = "3.0.9"
+version = "3.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "403f75924867bb1033c59fbf0797484329750cfbe3c4325cd33127941fabc882"
+checksum = "3e0633414522a32ffaac8ac6cc8f748e090c5717661fddeea04219e2344f5f2a"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
- "windows-sys",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
 name = "anyhow"
-version = "1.0.98"
+version = "1.0.99"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
+checksum = "b0674a1ddeecb70197781e945de4b3b8ffb61fa939a5597bcf48503737663100"
 
 [[package]]
 name = "assert-instr-macro"
@@ -84,30 +84,31 @@ checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
 [[package]]
 name = "bitflags"
-version = "2.9.1"
+version = "2.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967"
+checksum = "2261d10cca569e4643e526d8dc2e62e433cc8aba21ab764233731f8d369bf394"
 
 [[package]]
 name = "cc"
-version = "1.2.31"
+version = "1.2.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3a42d84bb6b69d3a8b3eaacf0d88f179e1929695e1ad012b6cf64d9caaa5fd2"
+checksum = "5252b3d2648e5eedbc1a6f501e3c795e07025c1e93bbf8bbdd6eef7f447a6d54"
 dependencies = [
+ "find-msvc-tools",
  "shlex",
 ]
 
 [[package]]
 name = "cfg-if"
-version = "1.0.1"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268"
+checksum = "2fd1289c04a9ea8cb22300a459a72a385d7c73d3259e2ed7dcb2af674838cfa9"
 
 [[package]]
 name = "clap"
-version = "4.5.42"
+version = "4.5.47"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed87a9d530bb41a67537289bafcac159cb3ee28460e0a4571123d2a778a6a882"
+checksum = "7eac00902d9d136acd712710d71823fb8ac8004ca445a89e73a41d45aa712931"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -115,9 +116,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.42"
+version = "4.5.47"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64f4f3f3c77c94aff3c7e9aac9a2ca1974a5adf392a8bb751e827d6d127ab966"
+checksum = "2ad9bbf750e73b5884fb8a211a9424a1906c1e156724260fdae972f31d70e1d6"
 dependencies = [
  "anstream",
  "anstyle",
@@ -127,9 +128,9 @@ dependencies = [
 
 [[package]]
 name = "clap_derive"
-version = "4.5.41"
+version = "4.5.47"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef4f52386a59ca4c860f7393bcf8abd8dfd91ecccc0f774635ff68e92eeef491"
+checksum = "bbfd7eae0b0f1a6e63d4b13c9c478de77c2eb546fba158ad50b4203dc24b9f9c"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -258,6 +259,12 @@ version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fd99930f64d146689264c637b5af2f0233a933bef0d8570e2526bf9e083192d"
+
 [[package]]
 name = "fnv"
 version = "1.0.7"
@@ -283,9 +290,9 @@ checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
 
 [[package]]
 name = "hashbrown"
-version = "0.15.4"
+version = "0.15.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5971ac85611da7067dbfcabef3c70ebb5606018acd9e2a3903a0da507521e0d5"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
 
 [[package]]
 name = "heck"
@@ -323,12 +330,12 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.10.0"
+version = "2.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe4cd85333e22411419a0bcae1297d25e58c9443848b11dc6a86fefe8c78a661"
+checksum = "f2481980430f9f78649238835720ddccc57e52df14ffce1c6f37391d61b563e9"
 dependencies = [
  "equivalent",
- "hashbrown 0.15.4",
+ "hashbrown 0.15.5",
 ]
 
 [[package]]
@@ -353,7 +360,7 @@ checksum = "e04d7f318608d35d4b61ddd75cbdaee86b023ebe2bd5a66ee0915f0bf93095a9"
 dependencies = [
  "hermit-abi",
  "libc",
- "windows-sys",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -379,9 +386,9 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "libc"
-version = "0.2.174"
+version = "0.2.175"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
+checksum = "6a82ae493e598baaea5209805c49bbf2ea7de956d50d7da0da1164f9c6d28543"
 
 [[package]]
 name = "linked-hash-map"
@@ -391,9 +398,9 @@ checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
 
 [[package]]
 name = "log"
-version = "0.4.27"
+version = "0.4.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
+checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
 
 [[package]]
 name = "memchr"
@@ -428,9 +435,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.95"
+version = "1.0.101"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
+checksum = "89ae43fd86e4158d6db51ad8e2b80f313af9cc74f5c0e03ccb87de09998732de"
 dependencies = [
  "unicode-ident",
 ]
@@ -497,9 +504,9 @@ dependencies = [
 
 [[package]]
 name = "rayon"
-version = "1.10.0"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
+checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f"
 dependencies = [
  "either",
  "rayon-core",
@@ -507,9 +514,9 @@ dependencies = [
 
 [[package]]
 name = "rayon-core"
-version = "1.12.1"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
 dependencies = [
  "crossbeam-deque",
  "crossbeam-utils",
@@ -517,9 +524,9 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.11.1"
+version = "1.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
+checksum = "23d7fd106d8c02486a8d64e778353d1cffe08ce79ac2e82f540c86d0facf6912"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -529,9 +536,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.4.9"
+version = "0.4.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
+checksum = "6b9458fa0bfeeac22b5ca447c63aaf45f28439a709ccd244698632f9aa6394d6"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -540,9 +547,9 @@ dependencies = [
 
 [[package]]
 name = "regex-syntax"
-version = "0.8.5"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
+checksum = "caf4aa5b0f434c91fe5c7f1ecb6a5ece2130b02ad2a590589dda5146df959001"
 
 [[package]]
 name = "rustc-demangle"
@@ -593,9 +600,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.142"
+version = "1.0.143"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "030fedb782600dcbd6f02d479bf0d817ac3bb40d644745b769d6a96bc3afc5a7"
+checksum = "d401abef1d108fbd9cbaebc3e46611f4b1021f714a0597a71f41ee463f5f4a5a"
 dependencies = [
  "itoa",
  "memchr",
@@ -715,9 +722,9 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
 [[package]]
 name = "syn"
-version = "2.0.104"
+version = "2.0.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17b6f705963418cdb9927482fa304bc562ece2fdd4f616084c50b7023b435a40"
+checksum = "ede7c438028d4436d71104916910f5bb611972c5cfd7f89b8300a8186e6fada6"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -774,7 +781,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "161296c618fa2d63f6ed5fffd1112937e803cb9ec71b32b01a76321555660917"
 dependencies = [
  "bitflags",
- "indexmap 2.10.0",
+ "indexmap 2.11.0",
  "semver",
 ]
 
@@ -791,20 +798,35 @@ dependencies = [
 
 [[package]]
 name = "winapi-util"
-version = "0.1.9"
+version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
+checksum = "0978bf7171b3d90bac376700cb56d606feb40f251a475a5d6634613564460b22"
 dependencies = [
- "windows-sys",
+ "windows-sys 0.60.2",
 ]
 
+[[package]]
+name = "windows-link"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
+
 [[package]]
 name = "windows-sys"
 version = "0.59.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
 dependencies = [
- "windows-targets",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+dependencies = [
+ "windows-targets 0.53.3",
 ]
 
 [[package]]
@@ -813,14 +835,31 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
 dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_gnullvm",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm 0.52.6",
+ "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]]
+name = "windows-targets"
+version = "0.53.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d5fe6031c4041849d7c496a8ded650796e7b6ecc19df1a431c1a363342e5dc91"
+dependencies = [
+ "windows-link",
+ "windows_aarch64_gnullvm 0.53.0",
+ "windows_aarch64_msvc 0.53.0",
+ "windows_i686_gnu 0.53.0",
+ "windows_i686_gnullvm 0.53.0",
+ "windows_i686_msvc 0.53.0",
+ "windows_x86_64_gnu 0.53.0",
+ "windows_x86_64_gnullvm 0.53.0",
+ "windows_x86_64_msvc 0.53.0",
 ]
 
 [[package]]
@@ -829,48 +868,96 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764"
+
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c"
+
 [[package]]
 name = "windows_i686_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3"
+
 [[package]]
 name = "windows_i686_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11"
+
 [[package]]
 name = "windows_i686_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d"
+
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba"
+
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57"
+
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
+
 [[package]]
 name = "yaml-rust"
 version = "0.4.5"
@@ -882,18 +969,18 @@ dependencies = [
 
 [[package]]
 name = "zerocopy"
-version = "0.8.26"
+version = "0.8.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1039dd0d3c310cf05de012d8a39ff557cb0d23087fd44cad61df08fc31907a2f"
+checksum = "0894878a5fa3edfd6da3f88c4805f4c8558e2b996227a3d864f47fe11e38282c"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.26"
+version = "0.8.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ecf5b4cc5364572d7f4c329661bcc82724222973f2cab6f050a4e5c22f75181"
+checksum = "88d2b8d9c68ad2b9e4340d7832716a4d21a22a1154777ad56ea55c51a9cf3831"
 dependencies = [
  "proc-macro2",
  "quote",

From d70ef4f0a7468fe7fb2dfabf89d8ccbb956a45d9 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sun, 7 Sep 2025 12:38:02 +0200
Subject: [PATCH 0603/1889] move `compare_outputs` implementation into
 `SupportedArchitectureTest` definition

---
 .../crates/intrinsic-test/src/arm/mod.rs      | 35 +++++++------------
 .../crates/intrinsic-test/src/common/mod.rs   | 31 +++++++++++++---
 .../stdarch/crates/intrinsic-test/src/main.rs | 21 ++++-------
 3 files changed, 47 insertions(+), 40 deletions(-)

diff --git a/library/stdarch/crates/intrinsic-test/src/arm/mod.rs b/library/stdarch/crates/intrinsic-test/src/arm/mod.rs
index 51f5ac4283783..d8f7ae9b30610 100644
--- a/library/stdarch/crates/intrinsic-test/src/arm/mod.rs
+++ b/library/stdarch/crates/intrinsic-test/src/arm/mod.rs
@@ -10,7 +10,6 @@ use std::fs::{self, File};
 use rayon::prelude::*;
 
 use crate::common::cli::ProcessedCli;
-use crate::common::compare::compare_outputs;
 use crate::common::gen_c::{write_main_cpp, write_mod_cpp};
 use crate::common::gen_rust::{
     compile_rust_programs, write_bin_cargo_toml, write_lib_cargo_toml, write_lib_rs, write_main_rs,
@@ -28,7 +27,17 @@ pub struct ArmArchitectureTest {
 }
 
 impl SupportedArchitectureTest for ArmArchitectureTest {
-    fn create(cli_options: ProcessedCli) -> Box<Self> {
+    type IntrinsicImpl = ArmIntrinsicType;
+
+    fn cli_options(&self) -> &ProcessedCli {
+        &self.cli_options
+    }
+
+    fn intrinsics(&self) -> &[Intrinsic<ArmIntrinsicType>] {
+        &self.intrinsics
+    }
+
+    fn create(cli_options: ProcessedCli) -> Self {
         let a32 = cli_options.target.contains("v7");
         let mut intrinsics = get_neon_intrinsics(&cli_options.filename, &cli_options.target)
             .expect("Error parsing input file");
@@ -50,10 +59,10 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
             .collect::<Vec<_>>();
         intrinsics.dedup();
 
-        Box::new(Self {
+        Self {
             intrinsics,
             cli_options,
-        })
+        }
     }
 
     fn build_c_file(&self) -> bool {
@@ -177,22 +186,4 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
 
         compile_rust_programs(toolchain, target, linker)
     }
-
-    fn compare_outputs(&self) -> bool {
-        if self.cli_options.toolchain.is_some() {
-            let intrinsics_name_list = self
-                .intrinsics
-                .iter()
-                .map(|i| i.name.clone())
-                .collect::<Vec<_>>();
-
-            compare_outputs(
-                &intrinsics_name_list,
-                &self.cli_options.runner,
-                &self.cli_options.target,
-            )
-        } else {
-            true
-        }
-    }
 }
diff --git a/library/stdarch/crates/intrinsic-test/src/common/mod.rs b/library/stdarch/crates/intrinsic-test/src/common/mod.rs
index 5a57c8027db9b..f1def1e9c0eb0 100644
--- a/library/stdarch/crates/intrinsic-test/src/common/mod.rs
+++ b/library/stdarch/crates/intrinsic-test/src/common/mod.rs
@@ -1,5 +1,7 @@
 use cli::ProcessedCli;
 
+use crate::common::{intrinsic::Intrinsic, intrinsic_helpers::IntrinsicTypeDefinition};
+
 pub mod argument;
 pub mod cli;
 pub mod compare;
@@ -15,12 +17,33 @@ pub mod values;
 /// Architectures must support this trait
 /// to be successfully tested.
 pub trait SupportedArchitectureTest {
-    fn create(cli_options: ProcessedCli) -> Box<Self>
-    where
-        Self: Sized;
+    type IntrinsicImpl: IntrinsicTypeDefinition;
+
+    fn cli_options(&self) -> &ProcessedCli;
+    fn intrinsics(&self) -> &[Intrinsic<Self::IntrinsicImpl>];
+
+    fn create(cli_options: ProcessedCli) -> Self;
+
     fn build_c_file(&self) -> bool;
     fn build_rust_file(&self) -> bool;
-    fn compare_outputs(&self) -> bool;
+
+    fn compare_outputs(&self) -> bool {
+        if self.cli_options().toolchain.is_some() {
+            let intrinsics_name_list = self
+                .intrinsics()
+                .iter()
+                .map(|i| i.name.clone())
+                .collect::<Vec<_>>();
+
+            compare::compare_outputs(
+                &intrinsics_name_list,
+                &self.cli_options().runner,
+                &self.cli_options().target,
+            )
+        } else {
+            true
+        }
+    }
 }
 
 pub fn chunk_info(intrinsic_count: usize) -> (usize, usize) {
diff --git a/library/stdarch/crates/intrinsic-test/src/main.rs b/library/stdarch/crates/intrinsic-test/src/main.rs
index 538f317a2978b..44d7aafd827fe 100644
--- a/library/stdarch/crates/intrinsic-test/src/main.rs
+++ b/library/stdarch/crates/intrinsic-test/src/main.rs
@@ -13,23 +13,16 @@ fn main() {
     let args: Cli = clap::Parser::parse();
     let processed_cli_options = ProcessedCli::new(args);
 
-    let test_environment_result: Option<Box<dyn SupportedArchitectureTest>> =
-        match processed_cli_options.target.as_str() {
-            "aarch64-unknown-linux-gnu"
-            | "armv7-unknown-linux-gnueabihf"
-            | "aarch64_be-unknown-linux-gnu" => {
-                Some(ArmArchitectureTest::create(processed_cli_options))
-            }
+    match processed_cli_options.target.as_str() {
+        "aarch64-unknown-linux-gnu"
+        | "armv7-unknown-linux-gnueabihf"
+        | "aarch64_be-unknown-linux-gnu" => run(ArmArchitectureTest::create(processed_cli_options)),
 
-            _ => None,
-        };
-
-    if test_environment_result.is_none() {
-        std::process::exit(0);
+        _ => std::process::exit(0),
     }
+}
 
-    let test_environment = test_environment_result.unwrap();
-
+fn run(test_environment: impl SupportedArchitectureTest) {
     info!("building C binaries");
     if !test_environment.build_c_file() {
         std::process::exit(2);

From 6ab097b2453c5247f8d78c7ed5dfd4184b9a1c1d Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sun, 7 Sep 2025 12:42:48 +0200
Subject: [PATCH 0604/1889] move platform headers into
 `SupportedArchitectureTest`

---
 library/stdarch/crates/intrinsic-test/src/arm/mod.rs    | 5 +++--
 library/stdarch/crates/intrinsic-test/src/common/mod.rs | 2 ++
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/library/stdarch/crates/intrinsic-test/src/arm/mod.rs b/library/stdarch/crates/intrinsic-test/src/arm/mod.rs
index d8f7ae9b30610..60e1ebe5f33ba 100644
--- a/library/stdarch/crates/intrinsic-test/src/arm/mod.rs
+++ b/library/stdarch/crates/intrinsic-test/src/arm/mod.rs
@@ -65,9 +65,10 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
         }
     }
 
+    const PLATFORM_HEADERS: &[&str] = &["arm_neon.h", "arm_acle.h", "arm_fp16.h"];
+
     fn build_c_file(&self) -> bool {
         let c_target = "aarch64";
-        let platform_headers = &["arm_neon.h", "arm_acle.h", "arm_fp16.h"];
 
         let (chunk_size, chunk_count) = chunk_info(self.intrinsics.len());
 
@@ -81,7 +82,7 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
             .map(|(i, chunk)| {
                 let c_filename = format!("c_programs/mod_{i}.cpp");
                 let mut file = File::create(&c_filename).unwrap();
-                write_mod_cpp(&mut file, notice, c_target, platform_headers, chunk).unwrap();
+                write_mod_cpp(&mut file, notice, c_target, Self::PLATFORM_HEADERS, chunk).unwrap();
 
                 // compile this cpp file into a .o file.
                 //
diff --git a/library/stdarch/crates/intrinsic-test/src/common/mod.rs b/library/stdarch/crates/intrinsic-test/src/common/mod.rs
index f1def1e9c0eb0..be08aaecaba19 100644
--- a/library/stdarch/crates/intrinsic-test/src/common/mod.rs
+++ b/library/stdarch/crates/intrinsic-test/src/common/mod.rs
@@ -24,6 +24,8 @@ pub trait SupportedArchitectureTest {
 
     fn create(cli_options: ProcessedCli) -> Self;
 
+    const PLATFORM_HEADERS: &[&str];
+
     fn build_c_file(&self) -> bool;
     fn build_rust_file(&self) -> bool;
 

From 916424f38d1b3d763cf19c0392799d7208482573 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sun, 7 Sep 2025 13:16:40 +0200
Subject: [PATCH 0605/1889] move more constants into
 `SupportedArchitectureTest`

---
 .../crates/intrinsic-test/src/arm/config.rs   | 13 ++---
 .../crates/intrinsic-test/src/arm/mod.rs      | 52 +++++++++++++------
 .../crates/intrinsic-test/src/common/mod.rs   | 16 ++++--
 3 files changed, 53 insertions(+), 28 deletions(-)

diff --git a/library/stdarch/crates/intrinsic-test/src/arm/config.rs b/library/stdarch/crates/intrinsic-test/src/arm/config.rs
index 9a7b37253d1cb..beaca621378d4 100644
--- a/library/stdarch/crates/intrinsic-test/src/arm/config.rs
+++ b/library/stdarch/crates/intrinsic-test/src/arm/config.rs
@@ -1,12 +1,7 @@
-pub fn build_notices(line_prefix: &str) -> String {
-    format!(
-        "\
-{line_prefix}This is a transient test file, not intended for distribution. Some aspects of the
-{line_prefix}test are derived from a JSON specification, published under the same license as the
-{line_prefix}`intrinsic-test` crate.\n
-"
-    )
-}
+pub const NOTICE: &str = "\
+// This is a transient test file, not intended for distribution. Some aspects of the
+// test are derived from a JSON specification, published under the same license as the
+// `intrinsic-test` crate.\n";
 
 pub const POLY128_OSTREAM_DEF: &str = r#"std::ostream& operator<<(std::ostream& os, poly128_t value) {
     std::stringstream temp;
diff --git a/library/stdarch/crates/intrinsic-test/src/arm/mod.rs b/library/stdarch/crates/intrinsic-test/src/arm/mod.rs
index 60e1ebe5f33ba..82dc5001adf06 100644
--- a/library/stdarch/crates/intrinsic-test/src/arm/mod.rs
+++ b/library/stdarch/crates/intrinsic-test/src/arm/mod.rs
@@ -5,11 +5,12 @@ mod intrinsic;
 mod json_parser;
 mod types;
 
-use std::fs::{self, File};
+use std::fs::File;
 
 use rayon::prelude::*;
 
 use crate::common::cli::ProcessedCli;
+use crate::common::compile_c::CppCompilation;
 use crate::common::gen_c::{write_main_cpp, write_mod_cpp};
 use crate::common::gen_rust::{
     compile_rust_programs, write_bin_cargo_toml, write_lib_cargo_toml, write_lib_rs, write_main_rs,
@@ -17,7 +18,6 @@ use crate::common::gen_rust::{
 use crate::common::intrinsic::Intrinsic;
 use crate::common::intrinsic_helpers::TypeKind;
 use crate::common::{SupportedArchitectureTest, chunk_info};
-use config::{AARCH_CONFIGURATIONS, F16_FORMATTING_DEF, POLY128_OSTREAM_DEF, build_notices};
 use intrinsic::ArmIntrinsicType;
 use json_parser::get_neon_intrinsics;
 
@@ -65,24 +65,40 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
         }
     }
 
-    const PLATFORM_HEADERS: &[&str] = &["arm_neon.h", "arm_acle.h", "arm_fp16.h"];
+    const NOTICE: &str = config::NOTICE;
+
+    const PLATFORM_C_HEADERS: &[&str] = &["arm_neon.h", "arm_acle.h", "arm_fp16.h"];
+    const PLATFORM_C_DEFINITIONS: &str = config::POLY128_OSTREAM_DEF;
+
+    const PLATFORM_RUST_DEFINITIONS: &str = config::F16_FORMATTING_DEF;
+    const PLATFORM_RUST_CFGS: &str = config::AARCH_CONFIGURATIONS;
+
+    fn cpp_compilation(&self) -> Option<CppCompilation> {
+        compile::build_cpp_compilation(&self.cli_options)
+    }
 
     fn build_c_file(&self) -> bool {
         let c_target = "aarch64";
 
-        let (chunk_size, chunk_count) = chunk_info(self.intrinsics.len());
+        let (chunk_size, chunk_count) = chunk_info(self.intrinsics().len());
 
-        let cpp_compiler_wrapped = compile::build_cpp_compilation(&self.cli_options);
+        let cpp_compiler_wrapped = self.cpp_compilation();
 
-        let notice = &build_notices("// ");
-        fs::create_dir_all("c_programs").unwrap();
-        self.intrinsics
+        std::fs::create_dir_all("c_programs").unwrap();
+        self.intrinsics()
             .par_chunks(chunk_size)
             .enumerate()
             .map(|(i, chunk)| {
                 let c_filename = format!("c_programs/mod_{i}.cpp");
                 let mut file = File::create(&c_filename).unwrap();
-                write_mod_cpp(&mut file, notice, c_target, Self::PLATFORM_HEADERS, chunk).unwrap();
+                write_mod_cpp(
+                    &mut file,
+                    Self::NOTICE,
+                    c_target,
+                    Self::PLATFORM_C_HEADERS,
+                    chunk,
+                )
+                .unwrap();
 
                 // compile this cpp file into a .o file.
                 //
@@ -103,8 +119,8 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
         write_main_cpp(
             &mut file,
             c_target,
-            POLY128_OSTREAM_DEF,
-            self.intrinsics.iter().map(|i| i.name.as_str()),
+            Self::PLATFORM_C_DEFINITIONS,
+            self.intrinsics().iter().map(|i| i.name.as_str()),
         )
         .unwrap();
 
@@ -149,7 +165,7 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
         write_main_rs(
             &mut main_rs,
             chunk_count,
-            AARCH_CONFIGURATIONS,
+            Self::PLATFORM_RUST_CFGS,
             "",
             self.intrinsics.iter().map(|i| i.name.as_str()),
         )
@@ -159,7 +175,6 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
         let toolchain = self.cli_options.toolchain.as_deref();
         let linker = self.cli_options.linker.as_deref();
 
-        let notice = &build_notices("// ");
         self.intrinsics
             .par_chunks(chunk_size)
             .enumerate()
@@ -170,9 +185,14 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
                 trace!("generating `{rust_filename}`");
                 let mut file = File::create(rust_filename)?;
 
-                let cfg = AARCH_CONFIGURATIONS;
-                let definitions = F16_FORMATTING_DEF;
-                write_lib_rs(&mut file, architecture, notice, cfg, definitions, chunk)?;
+                write_lib_rs(
+                    &mut file,
+                    architecture,
+                    Self::NOTICE,
+                    Self::PLATFORM_RUST_CFGS,
+                    Self::PLATFORM_RUST_DEFINITIONS,
+                    chunk,
+                )?;
 
                 let toml_filename = format!("rust_programs/mod_{i}/Cargo.toml");
                 trace!("generating `{toml_filename}`");
diff --git a/library/stdarch/crates/intrinsic-test/src/common/mod.rs b/library/stdarch/crates/intrinsic-test/src/common/mod.rs
index be08aaecaba19..13e6c9fe9e28e 100644
--- a/library/stdarch/crates/intrinsic-test/src/common/mod.rs
+++ b/library/stdarch/crates/intrinsic-test/src/common/mod.rs
@@ -1,6 +1,8 @@
 use cli::ProcessedCli;
 
-use crate::common::{intrinsic::Intrinsic, intrinsic_helpers::IntrinsicTypeDefinition};
+use crate::common::{
+    compile_c::CppCompilation, intrinsic::Intrinsic, intrinsic_helpers::IntrinsicTypeDefinition,
+};
 
 pub mod argument;
 pub mod cli;
@@ -17,14 +19,22 @@ pub mod values;
 /// Architectures must support this trait
 /// to be successfully tested.
 pub trait SupportedArchitectureTest {
-    type IntrinsicImpl: IntrinsicTypeDefinition;
+    type IntrinsicImpl: IntrinsicTypeDefinition + Sync;
 
     fn cli_options(&self) -> &ProcessedCli;
     fn intrinsics(&self) -> &[Intrinsic<Self::IntrinsicImpl>];
 
     fn create(cli_options: ProcessedCli) -> Self;
 
-    const PLATFORM_HEADERS: &[&str];
+    const NOTICE: &str;
+
+    const PLATFORM_C_HEADERS: &[&str];
+    const PLATFORM_C_DEFINITIONS: &str;
+
+    const PLATFORM_RUST_CFGS: &str;
+    const PLATFORM_RUST_DEFINITIONS: &str;
+
+    fn cpp_compilation(&self) -> Option<CppCompilation>;
 
     fn build_c_file(&self) -> bool;
     fn build_rust_file(&self) -> bool;

From 9d9ca01bfa541e9badd9f34c776b588cfbf0e3ce Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sun, 7 Sep 2025 13:23:24 +0200
Subject: [PATCH 0606/1889] move `print_result_c` into the inner intrinsic type

---
 .../intrinsic-test/src/arm/intrinsic.rs       | 52 +++++++++++--------
 1 file changed, 30 insertions(+), 22 deletions(-)

diff --git a/library/stdarch/crates/intrinsic-test/src/arm/intrinsic.rs b/library/stdarch/crates/intrinsic-test/src/arm/intrinsic.rs
index fd93eff76e09c..7c31fd4d9dd0a 100644
--- a/library/stdarch/crates/intrinsic-test/src/arm/intrinsic.rs
+++ b/library/stdarch/crates/intrinsic-test/src/arm/intrinsic.rs
@@ -41,18 +41,27 @@ impl IntrinsicDefinition<ArmIntrinsicType> for Intrinsic<ArmIntrinsicType> {
     /// rust debug output format for the return type. The generated line assumes
     /// there is an int i in scope which is the current pass number.
     fn print_result_c(&self, indentation: Indentation, additional: &str) -> String {
-        let lanes = if self.results().num_vectors() > 1 {
-            (0..self.results().num_vectors())
+        self.results().print_result_c(indentation, additional)
+    }
+}
+
+impl ArmIntrinsicType {
+    /// Generates a std::cout for the intrinsics results that will match the
+    /// rust debug output format for the return type. The generated line assumes
+    /// there is an int i in scope which is the current pass number.
+    fn print_result_c(&self, indentation: Indentation, additional: &str) -> String {
+        let lanes = if self.num_vectors() > 1 {
+            (0..self.num_vectors())
                 .map(|vector| {
                     format!(
                         r#""{ty}(" << {lanes} << ")""#,
-                        ty = self.results().c_single_vector_type(),
-                        lanes = (0..self.results().num_lanes())
+                        ty = self.c_single_vector_type(),
+                        lanes = (0..self.num_lanes())
                             .map(move |idx| -> std::string::String {
                                 format!(
                                     "{cast}{lane_fn}(__return_value.val[{vector}], {lane})",
-                                    cast = self.results().c_promotion(),
-                                    lane_fn = self.results().get_lane_function(),
+                                    cast = self.c_promotion(),
+                                    lane_fn = self.get_lane_function(),
                                     lane = idx,
                                     vector = vector,
                                 )
@@ -63,13 +72,13 @@ impl IntrinsicDefinition<ArmIntrinsicType> for Intrinsic<ArmIntrinsicType> {
                 })
                 .collect::<Vec<_>>()
                 .join(r#" << ", " << "#)
-        } else if self.results().num_lanes() > 1 {
-            (0..self.results().num_lanes())
+        } else if self.num_lanes() > 1 {
+            (0..self.num_lanes())
                 .map(|idx| -> std::string::String {
                     format!(
                         "{cast}{lane_fn}(__return_value, {lane})",
-                        cast = self.results().c_promotion(),
-                        lane_fn = self.results().get_lane_function(),
+                        cast = self.c_promotion(),
+                        lane_fn = self.get_lane_function(),
                         lane = idx
                     )
                 })
@@ -78,28 +87,27 @@ impl IntrinsicDefinition<ArmIntrinsicType> for Intrinsic<ArmIntrinsicType> {
         } else {
             format!(
                 "{promote}cast<{cast}>(__return_value)",
-                cast = match self.results.kind() {
-                    TypeKind::Float if self.results().inner_size() == 16 => "float16_t".to_string(),
-                    TypeKind::Float if self.results().inner_size() == 32 => "float".to_string(),
-                    TypeKind::Float if self.results().inner_size() == 64 => "double".to_string(),
-                    TypeKind::Int(Sign::Signed) => format!("int{}_t", self.results().inner_size()),
-                    TypeKind::Int(Sign::Unsigned) =>
-                        format!("uint{}_t", self.results().inner_size()),
-                    TypeKind::Poly => format!("poly{}_t", self.results().inner_size()),
+                cast = match self.kind() {
+                    TypeKind::Float if self.inner_size() == 16 => "float16_t".to_string(),
+                    TypeKind::Float if self.inner_size() == 32 => "float".to_string(),
+                    TypeKind::Float if self.inner_size() == 64 => "double".to_string(),
+                    TypeKind::Int(Sign::Signed) => format!("int{}_t", self.inner_size()),
+                    TypeKind::Int(Sign::Unsigned) => format!("uint{}_t", self.inner_size()),
+                    TypeKind::Poly => format!("poly{}_t", self.inner_size()),
                     ty => todo!("print_result_c - Unknown type: {:#?}", ty),
                 },
-                promote = self.results().c_promotion(),
+                promote = self.c_promotion(),
             )
         };
 
         format!(
             r#"{indentation}std::cout << "Result {additional}-" << i+1 << ": {ty}" << std::fixed << std::setprecision(150) <<  {lanes} << "{close}" << std::endl;"#,
-            ty = if self.results().is_simd() {
-                format!("{}(", self.results().c_type())
+            ty = if self.is_simd() {
+                format!("{}(", self.c_type())
             } else {
                 String::from("")
             },
-            close = if self.results.is_simd() { ")" } else { "" },
+            close = if self.is_simd() { ")" } else { "" },
         )
     }
 }

From 2ba0a6e48974e3f358c18724ebf673787d72ceea Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sun, 7 Sep 2025 13:26:50 +0200
Subject: [PATCH 0607/1889] move `print_result_c` into the trait

---
 .../intrinsic-test/src/arm/intrinsic.rs       | 77 +------------------
 .../crates/intrinsic-test/src/arm/types.rs    | 66 ++++++++++++++++
 .../crates/intrinsic-test/src/common/gen_c.rs |  4 +-
 .../intrinsic-test/src/common/intrinsic.rs    |  6 --
 .../src/common/intrinsic_helpers.rs           |  5 ++
 5 files changed, 75 insertions(+), 83 deletions(-)

diff --git a/library/stdarch/crates/intrinsic-test/src/arm/intrinsic.rs b/library/stdarch/crates/intrinsic-test/src/arm/intrinsic.rs
index 7c31fd4d9dd0a..1928a00f4f382 100644
--- a/library/stdarch/crates/intrinsic-test/src/arm/intrinsic.rs
+++ b/library/stdarch/crates/intrinsic-test/src/arm/intrinsic.rs
@@ -1,7 +1,6 @@
 use crate::common::argument::ArgumentList;
-use crate::common::indentation::Indentation;
 use crate::common::intrinsic::{Intrinsic, IntrinsicDefinition};
-use crate::common::intrinsic_helpers::{IntrinsicType, IntrinsicTypeDefinition, Sign, TypeKind};
+use crate::common::intrinsic_helpers::IntrinsicType;
 use std::ops::{Deref, DerefMut};
 
 #[derive(Debug, Clone, PartialEq)]
@@ -36,78 +35,4 @@ impl IntrinsicDefinition<ArmIntrinsicType> for Intrinsic<ArmIntrinsicType> {
     fn name(&self) -> String {
         self.name.clone()
     }
-
-    /// Generates a std::cout for the intrinsics results that will match the
-    /// rust debug output format for the return type. The generated line assumes
-    /// there is an int i in scope which is the current pass number.
-    fn print_result_c(&self, indentation: Indentation, additional: &str) -> String {
-        self.results().print_result_c(indentation, additional)
-    }
-}
-
-impl ArmIntrinsicType {
-    /// Generates a std::cout for the intrinsics results that will match the
-    /// rust debug output format for the return type. The generated line assumes
-    /// there is an int i in scope which is the current pass number.
-    fn print_result_c(&self, indentation: Indentation, additional: &str) -> String {
-        let lanes = if self.num_vectors() > 1 {
-            (0..self.num_vectors())
-                .map(|vector| {
-                    format!(
-                        r#""{ty}(" << {lanes} << ")""#,
-                        ty = self.c_single_vector_type(),
-                        lanes = (0..self.num_lanes())
-                            .map(move |idx| -> std::string::String {
-                                format!(
-                                    "{cast}{lane_fn}(__return_value.val[{vector}], {lane})",
-                                    cast = self.c_promotion(),
-                                    lane_fn = self.get_lane_function(),
-                                    lane = idx,
-                                    vector = vector,
-                                )
-                            })
-                            .collect::<Vec<_>>()
-                            .join(r#" << ", " << "#)
-                    )
-                })
-                .collect::<Vec<_>>()
-                .join(r#" << ", " << "#)
-        } else if self.num_lanes() > 1 {
-            (0..self.num_lanes())
-                .map(|idx| -> std::string::String {
-                    format!(
-                        "{cast}{lane_fn}(__return_value, {lane})",
-                        cast = self.c_promotion(),
-                        lane_fn = self.get_lane_function(),
-                        lane = idx
-                    )
-                })
-                .collect::<Vec<_>>()
-                .join(r#" << ", " << "#)
-        } else {
-            format!(
-                "{promote}cast<{cast}>(__return_value)",
-                cast = match self.kind() {
-                    TypeKind::Float if self.inner_size() == 16 => "float16_t".to_string(),
-                    TypeKind::Float if self.inner_size() == 32 => "float".to_string(),
-                    TypeKind::Float if self.inner_size() == 64 => "double".to_string(),
-                    TypeKind::Int(Sign::Signed) => format!("int{}_t", self.inner_size()),
-                    TypeKind::Int(Sign::Unsigned) => format!("uint{}_t", self.inner_size()),
-                    TypeKind::Poly => format!("poly{}_t", self.inner_size()),
-                    ty => todo!("print_result_c - Unknown type: {:#?}", ty),
-                },
-                promote = self.c_promotion(),
-            )
-        };
-
-        format!(
-            r#"{indentation}std::cout << "Result {additional}-" << i+1 << ": {ty}" << std::fixed << std::setprecision(150) <<  {lanes} << "{close}" << std::endl;"#,
-            ty = if self.is_simd() {
-                format!("{}(", self.c_type())
-            } else {
-                String::from("")
-            },
-            close = if self.is_simd() { ")" } else { "" },
-        )
-    }
 }
diff --git a/library/stdarch/crates/intrinsic-test/src/arm/types.rs b/library/stdarch/crates/intrinsic-test/src/arm/types.rs
index 32f8f106ce26d..e86a2c5189f0b 100644
--- a/library/stdarch/crates/intrinsic-test/src/arm/types.rs
+++ b/library/stdarch/crates/intrinsic-test/src/arm/types.rs
@@ -1,5 +1,6 @@
 use super::intrinsic::ArmIntrinsicType;
 use crate::common::cli::Language;
+use crate::common::indentation::Indentation;
 use crate::common::intrinsic_helpers::{IntrinsicType, IntrinsicTypeDefinition, Sign, TypeKind};
 
 impl IntrinsicTypeDefinition for ArmIntrinsicType {
@@ -98,6 +99,71 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
             todo!("get_lane_function IntrinsicType: {:#?}", self)
         }
     }
+
+    /// Generates a std::cout for the intrinsics results that will match the
+    /// rust debug output format for the return type. The generated line assumes
+    /// there is an int i in scope which is the current pass number.
+    fn print_result_c(&self, indentation: Indentation, additional: &str) -> String {
+        let lanes = if self.num_vectors() > 1 {
+            (0..self.num_vectors())
+                .map(|vector| {
+                    format!(
+                        r#""{ty}(" << {lanes} << ")""#,
+                        ty = self.c_single_vector_type(),
+                        lanes = (0..self.num_lanes())
+                            .map(move |idx| -> std::string::String {
+                                format!(
+                                    "{cast}{lane_fn}(__return_value.val[{vector}], {lane})",
+                                    cast = self.c_promotion(),
+                                    lane_fn = self.get_lane_function(),
+                                    lane = idx,
+                                    vector = vector,
+                                )
+                            })
+                            .collect::<Vec<_>>()
+                            .join(r#" << ", " << "#)
+                    )
+                })
+                .collect::<Vec<_>>()
+                .join(r#" << ", " << "#)
+        } else if self.num_lanes() > 1 {
+            (0..self.num_lanes())
+                .map(|idx| -> std::string::String {
+                    format!(
+                        "{cast}{lane_fn}(__return_value, {lane})",
+                        cast = self.c_promotion(),
+                        lane_fn = self.get_lane_function(),
+                        lane = idx
+                    )
+                })
+                .collect::<Vec<_>>()
+                .join(r#" << ", " << "#)
+        } else {
+            format!(
+                "{promote}cast<{cast}>(__return_value)",
+                cast = match self.kind() {
+                    TypeKind::Float if self.inner_size() == 16 => "float16_t".to_string(),
+                    TypeKind::Float if self.inner_size() == 32 => "float".to_string(),
+                    TypeKind::Float if self.inner_size() == 64 => "double".to_string(),
+                    TypeKind::Int(Sign::Signed) => format!("int{}_t", self.inner_size()),
+                    TypeKind::Int(Sign::Unsigned) => format!("uint{}_t", self.inner_size()),
+                    TypeKind::Poly => format!("poly{}_t", self.inner_size()),
+                    ty => todo!("print_result_c - Unknown type: {:#?}", ty),
+                },
+                promote = self.c_promotion(),
+            )
+        };
+
+        format!(
+            r#"{indentation}std::cout << "Result {additional}-" << i+1 << ": {ty}" << std::fixed << std::setprecision(150) <<  {lanes} << "{close}" << std::endl;"#,
+            ty = if self.is_simd() {
+                format!("{}(", self.c_type())
+            } else {
+                String::from("")
+            },
+            close = if self.is_simd() { ")" } else { "" },
+        )
+    }
 }
 
 impl ArmIntrinsicType {
diff --git a/library/stdarch/crates/intrinsic-test/src/common/gen_c.rs b/library/stdarch/crates/intrinsic-test/src/common/gen_c.rs
index 84755ce525053..bfb77be1d4a24 100644
--- a/library/stdarch/crates/intrinsic-test/src/common/gen_c.rs
+++ b/library/stdarch/crates/intrinsic-test/src/common/gen_c.rs
@@ -24,7 +24,9 @@ pub fn generate_c_test_loop<T: IntrinsicTypeDefinition + Sized>(
         loaded_args = intrinsic.arguments().load_values_c(body_indentation),
         intrinsic_call = intrinsic.name(),
         args = intrinsic.arguments().as_call_param_c(),
-        print_result = intrinsic.print_result_c(body_indentation, additional)
+        print_result = intrinsic
+            .results()
+            .print_result_c(body_indentation, additional)
     )
 }
 
diff --git a/library/stdarch/crates/intrinsic-test/src/common/intrinsic.rs b/library/stdarch/crates/intrinsic-test/src/common/intrinsic.rs
index bc46ccfbac40c..810681337fd5e 100644
--- a/library/stdarch/crates/intrinsic-test/src/common/intrinsic.rs
+++ b/library/stdarch/crates/intrinsic-test/src/common/intrinsic.rs
@@ -1,5 +1,4 @@
 use super::argument::ArgumentList;
-use super::indentation::Indentation;
 use super::intrinsic_helpers::{IntrinsicTypeDefinition, TypeKind};
 
 /// An intrinsic
@@ -27,11 +26,6 @@ where
     fn results(&self) -> T;
 
     fn name(&self) -> String;
-
-    /// Generates a std::cout for the intrinsics results that will match the
-    /// rust debug output format for the return type. The generated line assumes
-    /// there is an int i in scope which is the current pass number.
-    fn print_result_c(&self, _indentation: Indentation, _additional: &str) -> String;
 }
 
 pub fn format_f16_return_value<T: IntrinsicTypeDefinition>(
diff --git a/library/stdarch/crates/intrinsic-test/src/common/intrinsic_helpers.rs b/library/stdarch/crates/intrinsic-test/src/common/intrinsic_helpers.rs
index f5e84ca97af21..7bc1015a387c1 100644
--- a/library/stdarch/crates/intrinsic-test/src/common/intrinsic_helpers.rs
+++ b/library/stdarch/crates/intrinsic-test/src/common/intrinsic_helpers.rs
@@ -325,4 +325,9 @@ pub trait IntrinsicTypeDefinition: Deref<Target = IntrinsicType> {
 
     /// can be directly defined in `impl` blocks
     fn c_single_vector_type(&self) -> String;
+
+    /// Generates a std::cout for the intrinsics results that will match the
+    /// rust debug output format for the return type. The generated line assumes
+    /// there is an int i in scope which is the current pass number.
+    fn print_result_c(&self, indentation: Indentation, additional: &str) -> String;
 }

From 1697f36225310391cb96a2c0616f4596d3ba490f Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sun, 7 Sep 2025 13:32:19 +0200
Subject: [PATCH 0608/1889] remove `trait IntrinsicDefinition`

---
 .../intrinsic-test/src/arm/intrinsic.rs       | 16 -------------
 .../crates/intrinsic-test/src/common/gen_c.rs | 23 +++++++++---------
 .../intrinsic-test/src/common/gen_rust.rs     | 24 ++++++++++---------
 .../intrinsic-test/src/common/intrinsic.rs    | 19 +++------------
 4 files changed, 28 insertions(+), 54 deletions(-)

diff --git a/library/stdarch/crates/intrinsic-test/src/arm/intrinsic.rs b/library/stdarch/crates/intrinsic-test/src/arm/intrinsic.rs
index 1928a00f4f382..29343bee4c300 100644
--- a/library/stdarch/crates/intrinsic-test/src/arm/intrinsic.rs
+++ b/library/stdarch/crates/intrinsic-test/src/arm/intrinsic.rs
@@ -1,5 +1,3 @@
-use crate::common::argument::ArgumentList;
-use crate::common::intrinsic::{Intrinsic, IntrinsicDefinition};
 use crate::common::intrinsic_helpers::IntrinsicType;
 use std::ops::{Deref, DerefMut};
 
@@ -22,17 +20,3 @@ impl DerefMut for ArmIntrinsicType {
         &mut self.data
     }
 }
-
-impl IntrinsicDefinition<ArmIntrinsicType> for Intrinsic<ArmIntrinsicType> {
-    fn arguments(&self) -> ArgumentList<ArmIntrinsicType> {
-        self.arguments.clone()
-    }
-
-    fn results(&self) -> ArmIntrinsicType {
-        self.results.clone()
-    }
-
-    fn name(&self) -> String {
-        self.name.clone()
-    }
-}
diff --git a/library/stdarch/crates/intrinsic-test/src/common/gen_c.rs b/library/stdarch/crates/intrinsic-test/src/common/gen_c.rs
index bfb77be1d4a24..20a5f2c63f0e1 100644
--- a/library/stdarch/crates/intrinsic-test/src/common/gen_c.rs
+++ b/library/stdarch/crates/intrinsic-test/src/common/gen_c.rs
@@ -1,6 +1,7 @@
+use crate::common::intrinsic::Intrinsic;
+
 use super::argument::Argument;
 use super::indentation::Indentation;
-use super::intrinsic::IntrinsicDefinition;
 use super::intrinsic_helpers::IntrinsicTypeDefinition;
 
 // The number of times each intrinsic will be called.
@@ -8,7 +9,7 @@ const PASSES: u32 = 20;
 
 pub fn generate_c_test_loop<T: IntrinsicTypeDefinition + Sized>(
     w: &mut impl std::io::Write,
-    intrinsic: &dyn IntrinsicDefinition<T>,
+    intrinsic: &Intrinsic<T>,
     indentation: Indentation,
     additional: &str,
     passes: u32,
@@ -21,18 +22,18 @@ pub fn generate_c_test_loop<T: IntrinsicTypeDefinition + Sized>(
             {body_indentation}auto __return_value = {intrinsic_call}({args});\n\
             {print_result}\n\
         {indentation}}}",
-        loaded_args = intrinsic.arguments().load_values_c(body_indentation),
-        intrinsic_call = intrinsic.name(),
-        args = intrinsic.arguments().as_call_param_c(),
+        loaded_args = intrinsic.arguments.load_values_c(body_indentation),
+        intrinsic_call = intrinsic.name,
+        args = intrinsic.arguments.as_call_param_c(),
         print_result = intrinsic
-            .results()
+            .results
             .print_result_c(body_indentation, additional)
     )
 }
 
 pub fn generate_c_constraint_blocks<'a, T: IntrinsicTypeDefinition + 'a>(
     w: &mut impl std::io::Write,
-    intrinsic: &dyn IntrinsicDefinition<T>,
+    intrinsic: &Intrinsic<T>,
     indentation: Indentation,
     constraints: &mut (impl Iterator<Item = &'a Argument<T>> + Clone),
     name: String,
@@ -65,14 +66,14 @@ pub fn generate_c_constraint_blocks<'a, T: IntrinsicTypeDefinition + 'a>(
 // Compiles C test programs using specified compiler
 pub fn create_c_test_function<T: IntrinsicTypeDefinition>(
     w: &mut impl std::io::Write,
-    intrinsic: &dyn IntrinsicDefinition<T>,
+    intrinsic: &Intrinsic<T>,
 ) -> std::io::Result<()> {
     let indentation = Indentation::default();
 
-    writeln!(w, "int run_{}() {{", intrinsic.name())?;
+    writeln!(w, "int run_{}() {{", intrinsic.name)?;
 
     // Define the arrays of arguments.
-    let arguments = intrinsic.arguments();
+    let arguments = &intrinsic.arguments;
     arguments.gen_arglists_c(w, indentation.nested(), PASSES)?;
 
     generate_c_constraint_blocks(
@@ -94,7 +95,7 @@ pub fn write_mod_cpp<T: IntrinsicTypeDefinition>(
     notice: &str,
     architecture: &str,
     platform_headers: &[&str],
-    intrinsics: &[impl IntrinsicDefinition<T>],
+    intrinsics: &[Intrinsic<T>],
 ) -> std::io::Result<()> {
     write!(w, "{notice}")?;
 
diff --git a/library/stdarch/crates/intrinsic-test/src/common/gen_rust.rs b/library/stdarch/crates/intrinsic-test/src/common/gen_rust.rs
index 2a02b8fdff1df..240496f9b765e 100644
--- a/library/stdarch/crates/intrinsic-test/src/common/gen_rust.rs
+++ b/library/stdarch/crates/intrinsic-test/src/common/gen_rust.rs
@@ -1,8 +1,10 @@
 use itertools::Itertools;
 use std::process::Command;
 
+use crate::common::intrinsic::Intrinsic;
+
 use super::indentation::Indentation;
-use super::intrinsic::{IntrinsicDefinition, format_f16_return_value};
+use super::intrinsic::format_f16_return_value;
 use super::intrinsic_helpers::IntrinsicTypeDefinition;
 
 // The number of times each intrinsic will be called.
@@ -100,7 +102,7 @@ pub fn write_lib_rs<T: IntrinsicTypeDefinition>(
     notice: &str,
     cfg: &str,
     definitions: &str,
-    intrinsics: &[impl IntrinsicDefinition<T>],
+    intrinsics: &[Intrinsic<T>],
 ) -> std::io::Result<()> {
     write!(w, "{notice}")?;
 
@@ -189,16 +191,16 @@ pub fn compile_rust_programs(toolchain: Option<&str>, target: &str, linker: Opti
 
 pub fn generate_rust_test_loop<T: IntrinsicTypeDefinition>(
     w: &mut impl std::io::Write,
-    intrinsic: &dyn IntrinsicDefinition<T>,
+    intrinsic: &Intrinsic<T>,
     indentation: Indentation,
     specializations: &[Vec<u8>],
     passes: u32,
 ) -> std::io::Result<()> {
-    let intrinsic_name = intrinsic.name();
+    let intrinsic_name = &intrinsic.name;
 
     // Each function (and each specialization) has its own type. Erase that type with a cast.
     let mut coerce = String::from("unsafe fn(");
-    for _ in intrinsic.arguments().iter().filter(|a| !a.has_constraint()) {
+    for _ in intrinsic.arguments.iter().filter(|a| !a.has_constraint()) {
         coerce += "_, ";
     }
     coerce += ") -> _";
@@ -248,8 +250,8 @@ pub fn generate_rust_test_loop<T: IntrinsicTypeDefinition>(
                     }}\n\
                 }}\n\
             }}",
-        loaded_args = intrinsic.arguments().load_values_rust(indentation3),
-        args = intrinsic.arguments().as_call_param_rust(),
+        loaded_args = intrinsic.arguments.load_values_rust(indentation3),
+        args = intrinsic.arguments.as_call_param_rust(),
     )
 }
 
@@ -277,15 +279,15 @@ fn generate_rust_specializations<'a>(
 // Top-level function to create complete test program
 pub fn create_rust_test_module<T: IntrinsicTypeDefinition>(
     w: &mut impl std::io::Write,
-    intrinsic: &dyn IntrinsicDefinition<T>,
+    intrinsic: &Intrinsic<T>,
 ) -> std::io::Result<()> {
-    trace!("generating `{}`", intrinsic.name());
+    trace!("generating `{}`", intrinsic.name);
     let indentation = Indentation::default();
 
-    writeln!(w, "pub fn run_{}() {{", intrinsic.name())?;
+    writeln!(w, "pub fn run_{}() {{", intrinsic.name)?;
 
     // Define the arrays of arguments.
-    let arguments = intrinsic.arguments();
+    let arguments = &intrinsic.arguments;
     arguments.gen_arglists_rust(w, indentation.nested(), PASSES)?;
 
     // Define any const generics as `const` items, then generate the actual test loop.
diff --git a/library/stdarch/crates/intrinsic-test/src/common/intrinsic.rs b/library/stdarch/crates/intrinsic-test/src/common/intrinsic.rs
index 810681337fd5e..95276d19b72f9 100644
--- a/library/stdarch/crates/intrinsic-test/src/common/intrinsic.rs
+++ b/library/stdarch/crates/intrinsic-test/src/common/intrinsic.rs
@@ -17,27 +17,14 @@ pub struct Intrinsic<T: IntrinsicTypeDefinition> {
     pub arch_tags: Vec<String>,
 }
 
-pub trait IntrinsicDefinition<T>
-where
-    T: IntrinsicTypeDefinition,
-{
-    fn arguments(&self) -> ArgumentList<T>;
-
-    fn results(&self) -> T;
-
-    fn name(&self) -> String;
-}
-
-pub fn format_f16_return_value<T: IntrinsicTypeDefinition>(
-    intrinsic: &dyn IntrinsicDefinition<T>,
-) -> String {
+pub fn format_f16_return_value<T: IntrinsicTypeDefinition>(intrinsic: &Intrinsic<T>) -> String {
     // the `intrinsic-test` crate compares the output of C and Rust intrinsics. Currently, It uses
     // a string representation of the output value to compare. In C, f16 values are currently printed
     // as hexadecimal integers. Since https://github.com/rust-lang/rust/pull/127013, rust does print
     // them as decimal floating point values. To keep the intrinsics tests working, for now, format
     // vectors containing f16 values like C prints them.
-    let return_value = match intrinsic.results().kind() {
-        TypeKind::Float if intrinsic.results().inner_size() == 16 => "debug_f16(__return_value)",
+    let return_value = match intrinsic.results.kind() {
+        TypeKind::Float if intrinsic.results.inner_size() == 16 => "debug_f16(__return_value)",
         _ => "format_args!(\"{__return_value:.150?}\")",
     };
 

From ccec2027272c635aaa8713df0943c85df765570e Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sun, 7 Sep 2025 13:35:30 +0200
Subject: [PATCH 0609/1889] move `build_c_file` and `build_rust_file` into
 `SupportedArchitectureTest`

---
 .../crates/intrinsic-test/src/arm/mod.rs      | 141 +----------------
 .../crates/intrinsic-test/src/common/mod.rs   | 145 +++++++++++++++++-
 2 files changed, 143 insertions(+), 143 deletions(-)

diff --git a/library/stdarch/crates/intrinsic-test/src/arm/mod.rs b/library/stdarch/crates/intrinsic-test/src/arm/mod.rs
index 82dc5001adf06..bbf6a7a5a2d62 100644
--- a/library/stdarch/crates/intrinsic-test/src/arm/mod.rs
+++ b/library/stdarch/crates/intrinsic-test/src/arm/mod.rs
@@ -5,19 +5,11 @@ mod intrinsic;
 mod json_parser;
 mod types;
 
-use std::fs::File;
-
-use rayon::prelude::*;
-
+use crate::common::SupportedArchitectureTest;
 use crate::common::cli::ProcessedCli;
 use crate::common::compile_c::CppCompilation;
-use crate::common::gen_c::{write_main_cpp, write_mod_cpp};
-use crate::common::gen_rust::{
-    compile_rust_programs, write_bin_cargo_toml, write_lib_cargo_toml, write_lib_rs, write_main_rs,
-};
 use crate::common::intrinsic::Intrinsic;
 use crate::common::intrinsic_helpers::TypeKind;
-use crate::common::{SupportedArchitectureTest, chunk_info};
 use intrinsic::ArmIntrinsicType;
 use json_parser::get_neon_intrinsics;
 
@@ -76,135 +68,4 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
     fn cpp_compilation(&self) -> Option<CppCompilation> {
         compile::build_cpp_compilation(&self.cli_options)
     }
-
-    fn build_c_file(&self) -> bool {
-        let c_target = "aarch64";
-
-        let (chunk_size, chunk_count) = chunk_info(self.intrinsics().len());
-
-        let cpp_compiler_wrapped = self.cpp_compilation();
-
-        std::fs::create_dir_all("c_programs").unwrap();
-        self.intrinsics()
-            .par_chunks(chunk_size)
-            .enumerate()
-            .map(|(i, chunk)| {
-                let c_filename = format!("c_programs/mod_{i}.cpp");
-                let mut file = File::create(&c_filename).unwrap();
-                write_mod_cpp(
-                    &mut file,
-                    Self::NOTICE,
-                    c_target,
-                    Self::PLATFORM_C_HEADERS,
-                    chunk,
-                )
-                .unwrap();
-
-                // compile this cpp file into a .o file.
-                //
-                // This is done because `cpp_compiler_wrapped` is None when
-                // the --generate-only flag is passed
-                if let Some(cpp_compiler) = cpp_compiler_wrapped.as_ref() {
-                    let output = cpp_compiler
-                        .compile_object_file(&format!("mod_{i}.cpp"), &format!("mod_{i}.o"))?;
-                    assert!(output.status.success(), "{output:?}");
-                }
-
-                Ok(())
-            })
-            .collect::<Result<(), std::io::Error>>()
-            .unwrap();
-
-        let mut file = File::create("c_programs/main.cpp").unwrap();
-        write_main_cpp(
-            &mut file,
-            c_target,
-            Self::PLATFORM_C_DEFINITIONS,
-            self.intrinsics().iter().map(|i| i.name.as_str()),
-        )
-        .unwrap();
-
-        // This is done because `cpp_compiler_wrapped` is None when
-        // the --generate-only flag is passed
-        if let Some(cpp_compiler) = cpp_compiler_wrapped.as_ref() {
-            // compile this cpp file into a .o file
-            info!("compiling main.cpp");
-            let output = cpp_compiler
-                .compile_object_file("main.cpp", "intrinsic-test-programs.o")
-                .unwrap();
-            assert!(output.status.success(), "{output:?}");
-
-            let object_files = (0..chunk_count)
-                .map(|i| format!("mod_{i}.o"))
-                .chain(["intrinsic-test-programs.o".to_owned()]);
-
-            let output = cpp_compiler
-                .link_executable(object_files, "intrinsic-test-programs")
-                .unwrap();
-            assert!(output.status.success(), "{output:?}");
-        }
-
-        true
-    }
-
-    fn build_rust_file(&self) -> bool {
-        std::fs::create_dir_all("rust_programs/src").unwrap();
-
-        let architecture = if self.cli_options.target.contains("v7") {
-            "arm"
-        } else {
-            "aarch64"
-        };
-
-        let (chunk_size, chunk_count) = chunk_info(self.intrinsics.len());
-
-        let mut cargo = File::create("rust_programs/Cargo.toml").unwrap();
-        write_bin_cargo_toml(&mut cargo, chunk_count).unwrap();
-
-        let mut main_rs = File::create("rust_programs/src/main.rs").unwrap();
-        write_main_rs(
-            &mut main_rs,
-            chunk_count,
-            Self::PLATFORM_RUST_CFGS,
-            "",
-            self.intrinsics.iter().map(|i| i.name.as_str()),
-        )
-        .unwrap();
-
-        let target = &self.cli_options.target;
-        let toolchain = self.cli_options.toolchain.as_deref();
-        let linker = self.cli_options.linker.as_deref();
-
-        self.intrinsics
-            .par_chunks(chunk_size)
-            .enumerate()
-            .map(|(i, chunk)| {
-                std::fs::create_dir_all(format!("rust_programs/mod_{i}/src"))?;
-
-                let rust_filename = format!("rust_programs/mod_{i}/src/lib.rs");
-                trace!("generating `{rust_filename}`");
-                let mut file = File::create(rust_filename)?;
-
-                write_lib_rs(
-                    &mut file,
-                    architecture,
-                    Self::NOTICE,
-                    Self::PLATFORM_RUST_CFGS,
-                    Self::PLATFORM_RUST_DEFINITIONS,
-                    chunk,
-                )?;
-
-                let toml_filename = format!("rust_programs/mod_{i}/Cargo.toml");
-                trace!("generating `{toml_filename}`");
-                let mut file = File::create(toml_filename).unwrap();
-
-                write_lib_cargo_toml(&mut file, &format!("mod_{i}"))?;
-
-                Ok(())
-            })
-            .collect::<Result<(), std::io::Error>>()
-            .unwrap();
-
-        compile_rust_programs(toolchain, target, linker)
-    }
 }
diff --git a/library/stdarch/crates/intrinsic-test/src/common/mod.rs b/library/stdarch/crates/intrinsic-test/src/common/mod.rs
index 13e6c9fe9e28e..b6589ddaef8ef 100644
--- a/library/stdarch/crates/intrinsic-test/src/common/mod.rs
+++ b/library/stdarch/crates/intrinsic-test/src/common/mod.rs
@@ -1,7 +1,18 @@
+use std::fs::File;
+
+use rayon::prelude::*;
+
 use cli::ProcessedCli;
 
 use crate::common::{
-    compile_c::CppCompilation, intrinsic::Intrinsic, intrinsic_helpers::IntrinsicTypeDefinition,
+    compile_c::CppCompilation,
+    gen_c::{write_main_cpp, write_mod_cpp},
+    gen_rust::{
+        compile_rust_programs, write_bin_cargo_toml, write_lib_cargo_toml, write_lib_rs,
+        write_main_rs,
+    },
+    intrinsic::Intrinsic,
+    intrinsic_helpers::IntrinsicTypeDefinition,
 };
 
 pub mod argument;
@@ -36,8 +47,136 @@ pub trait SupportedArchitectureTest {
 
     fn cpp_compilation(&self) -> Option<CppCompilation>;
 
-    fn build_c_file(&self) -> bool;
-    fn build_rust_file(&self) -> bool;
+    fn build_c_file(&self) -> bool {
+        let c_target = "aarch64";
+
+        let (chunk_size, chunk_count) = chunk_info(self.intrinsics().len());
+
+        let cpp_compiler_wrapped = self.cpp_compilation();
+
+        std::fs::create_dir_all("c_programs").unwrap();
+        self.intrinsics()
+            .par_chunks(chunk_size)
+            .enumerate()
+            .map(|(i, chunk)| {
+                let c_filename = format!("c_programs/mod_{i}.cpp");
+                let mut file = File::create(&c_filename).unwrap();
+                write_mod_cpp(
+                    &mut file,
+                    Self::NOTICE,
+                    c_target,
+                    Self::PLATFORM_C_HEADERS,
+                    chunk,
+                )
+                .unwrap();
+
+                // compile this cpp file into a .o file.
+                //
+                // This is done because `cpp_compiler_wrapped` is None when
+                // the --generate-only flag is passed
+                if let Some(cpp_compiler) = cpp_compiler_wrapped.as_ref() {
+                    let output = cpp_compiler
+                        .compile_object_file(&format!("mod_{i}.cpp"), &format!("mod_{i}.o"))?;
+                    assert!(output.status.success(), "{output:?}");
+                }
+
+                Ok(())
+            })
+            .collect::<Result<(), std::io::Error>>()
+            .unwrap();
+
+        let mut file = File::create("c_programs/main.cpp").unwrap();
+        write_main_cpp(
+            &mut file,
+            c_target,
+            Self::PLATFORM_C_DEFINITIONS,
+            self.intrinsics().iter().map(|i| i.name.as_str()),
+        )
+        .unwrap();
+
+        // This is done because `cpp_compiler_wrapped` is None when
+        // the --generate-only flag is passed
+        if let Some(cpp_compiler) = cpp_compiler_wrapped.as_ref() {
+            // compile this cpp file into a .o file
+            info!("compiling main.cpp");
+            let output = cpp_compiler
+                .compile_object_file("main.cpp", "intrinsic-test-programs.o")
+                .unwrap();
+            assert!(output.status.success(), "{output:?}");
+
+            let object_files = (0..chunk_count)
+                .map(|i| format!("mod_{i}.o"))
+                .chain(["intrinsic-test-programs.o".to_owned()]);
+
+            let output = cpp_compiler
+                .link_executable(object_files, "intrinsic-test-programs")
+                .unwrap();
+            assert!(output.status.success(), "{output:?}");
+        }
+
+        true
+    }
+
+    fn build_rust_file(&self) -> bool {
+        std::fs::create_dir_all("rust_programs/src").unwrap();
+
+        let architecture = if self.cli_options().target.contains("v7") {
+            "arm"
+        } else {
+            "aarch64"
+        };
+
+        let (chunk_size, chunk_count) = chunk_info(self.intrinsics().len());
+
+        let mut cargo = File::create("rust_programs/Cargo.toml").unwrap();
+        write_bin_cargo_toml(&mut cargo, chunk_count).unwrap();
+
+        let mut main_rs = File::create("rust_programs/src/main.rs").unwrap();
+        write_main_rs(
+            &mut main_rs,
+            chunk_count,
+            Self::PLATFORM_RUST_CFGS,
+            "",
+            self.intrinsics().iter().map(|i| i.name.as_str()),
+        )
+        .unwrap();
+
+        let target = &self.cli_options().target;
+        let toolchain = self.cli_options().toolchain.as_deref();
+        let linker = self.cli_options().linker.as_deref();
+
+        self.intrinsics()
+            .par_chunks(chunk_size)
+            .enumerate()
+            .map(|(i, chunk)| {
+                std::fs::create_dir_all(format!("rust_programs/mod_{i}/src"))?;
+
+                let rust_filename = format!("rust_programs/mod_{i}/src/lib.rs");
+                trace!("generating `{rust_filename}`");
+                let mut file = File::create(rust_filename)?;
+
+                write_lib_rs(
+                    &mut file,
+                    architecture,
+                    Self::NOTICE,
+                    Self::PLATFORM_RUST_CFGS,
+                    Self::PLATFORM_RUST_DEFINITIONS,
+                    chunk,
+                )?;
+
+                let toml_filename = format!("rust_programs/mod_{i}/Cargo.toml");
+                trace!("generating `{toml_filename}`");
+                let mut file = File::create(toml_filename).unwrap();
+
+                write_lib_cargo_toml(&mut file, &format!("mod_{i}"))?;
+
+                Ok(())
+            })
+            .collect::<Result<(), std::io::Error>>()
+            .unwrap();
+
+        compile_rust_programs(toolchain, target, linker)
+    }
 
     fn compare_outputs(&self) -> bool {
         if self.cli_options().toolchain.is_some() {

From 4b549a7330736bad6f7296241c6ce1cdbab4ef60 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sun, 7 Sep 2025 14:10:47 +0200
Subject: [PATCH 0610/1889] move target-specific definitions into constants

---
 .../crates/intrinsic-test/src/arm/config.rs   | 20 +++++++++++++--
 .../crates/intrinsic-test/src/arm/mod.rs      | 25 ++++++++++---------
 .../crates/intrinsic-test/src/common/gen_c.rs | 13 +++-------
 .../intrinsic-test/src/common/gen_rust.rs     |  3 ---
 .../crates/intrinsic-test/src/common/mod.rs   | 13 ++--------
 5 files changed, 36 insertions(+), 38 deletions(-)

diff --git a/library/stdarch/crates/intrinsic-test/src/arm/config.rs b/library/stdarch/crates/intrinsic-test/src/arm/config.rs
index beaca621378d4..72e997de154ab 100644
--- a/library/stdarch/crates/intrinsic-test/src/arm/config.rs
+++ b/library/stdarch/crates/intrinsic-test/src/arm/config.rs
@@ -3,7 +3,15 @@ pub const NOTICE: &str = "\
 // test are derived from a JSON specification, published under the same license as the
 // `intrinsic-test` crate.\n";
 
-pub const POLY128_OSTREAM_DEF: &str = r#"std::ostream& operator<<(std::ostream& os, poly128_t value) {
+pub const POLY128_OSTREAM_DECL: &str = r#"
+#ifdef __aarch64__
+std::ostream& operator<<(std::ostream& os, poly128_t value);
+#endif
+"#;
+
+pub const POLY128_OSTREAM_DEF: &str = r#"
+#ifdef __aarch64__
+std::ostream& operator<<(std::ostream& os, poly128_t value) {
     std::stringstream temp;
     do {
       int n = value % 10;
@@ -14,7 +22,9 @@ pub const POLY128_OSTREAM_DEF: &str = r#"std::ostream& operator<<(std::ostream&
     std::string res(tempstr.rbegin(), tempstr.rend());
     os << res;
     return os;
-}"#;
+}
+#endif
+"#;
 
 // Format f16 values (and vectors containing them) in a way that is consistent with C.
 pub const F16_FORMATTING_DEF: &str = r#"
@@ -113,4 +123,10 @@ pub const AARCH_CONFIGURATIONS: &str = r#"
 #![cfg_attr(any(target_arch = "aarch64", target_arch = "arm64ec"), feature(stdarch_neon_ftts))]
 #![feature(fmt_helpers_for_derive)]
 #![feature(stdarch_neon_f16)]
+
+#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
+use core::arch::aarch64::*;
+
+#[cfg(target_arch = "arm")]
+use core::arch::arm::*;
 "#;
diff --git a/library/stdarch/crates/intrinsic-test/src/arm/mod.rs b/library/stdarch/crates/intrinsic-test/src/arm/mod.rs
index bbf6a7a5a2d62..08dc2d38702cd 100644
--- a/library/stdarch/crates/intrinsic-test/src/arm/mod.rs
+++ b/library/stdarch/crates/intrinsic-test/src/arm/mod.rs
@@ -29,6 +29,19 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
         &self.intrinsics
     }
 
+    const NOTICE: &str = config::NOTICE;
+
+    const PLATFORM_C_HEADERS: &[&str] = &["arm_neon.h", "arm_acle.h", "arm_fp16.h"];
+    const PLATFORM_C_DEFINITIONS: &str = config::POLY128_OSTREAM_DEF;
+    const PLATFORM_C_FORWARD_DECLARATIONS: &str = config::POLY128_OSTREAM_DECL;
+
+    const PLATFORM_RUST_DEFINITIONS: &str = config::F16_FORMATTING_DEF;
+    const PLATFORM_RUST_CFGS: &str = config::AARCH_CONFIGURATIONS;
+
+    fn cpp_compilation(&self) -> Option<CppCompilation> {
+        compile::build_cpp_compilation(&self.cli_options)
+    }
+
     fn create(cli_options: ProcessedCli) -> Self {
         let a32 = cli_options.target.contains("v7");
         let mut intrinsics = get_neon_intrinsics(&cli_options.filename, &cli_options.target)
@@ -56,16 +69,4 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
             cli_options,
         }
     }
-
-    const NOTICE: &str = config::NOTICE;
-
-    const PLATFORM_C_HEADERS: &[&str] = &["arm_neon.h", "arm_acle.h", "arm_fp16.h"];
-    const PLATFORM_C_DEFINITIONS: &str = config::POLY128_OSTREAM_DEF;
-
-    const PLATFORM_RUST_DEFINITIONS: &str = config::F16_FORMATTING_DEF;
-    const PLATFORM_RUST_CFGS: &str = config::AARCH_CONFIGURATIONS;
-
-    fn cpp_compilation(&self) -> Option<CppCompilation> {
-        compile::build_cpp_compilation(&self.cli_options)
-    }
 }
diff --git a/library/stdarch/crates/intrinsic-test/src/common/gen_c.rs b/library/stdarch/crates/intrinsic-test/src/common/gen_c.rs
index 20a5f2c63f0e1..28902b3dfe981 100644
--- a/library/stdarch/crates/intrinsic-test/src/common/gen_c.rs
+++ b/library/stdarch/crates/intrinsic-test/src/common/gen_c.rs
@@ -93,8 +93,8 @@ pub fn create_c_test_function<T: IntrinsicTypeDefinition>(
 pub fn write_mod_cpp<T: IntrinsicTypeDefinition>(
     w: &mut impl std::io::Write,
     notice: &str,
-    architecture: &str,
     platform_headers: &[&str],
+    forward_declarations: &str,
     intrinsics: &[Intrinsic<T>],
 ) -> std::io::Result<()> {
     write!(w, "{notice}")?;
@@ -125,12 +125,7 @@ std::ostream& operator<<(std::ostream& os, float16_t value);
 "#
     )?;
 
-    writeln!(w, "#ifdef __{architecture}__")?;
-    writeln!(
-        w,
-        "std::ostream& operator<<(std::ostream& os, poly128_t value);"
-    )?;
-    writeln!(w, "#endif")?;
+    writeln!(w, "{}", forward_declarations)?;
 
     for intrinsic in intrinsics {
         create_c_test_function(w, intrinsic)?;
@@ -141,7 +136,6 @@ std::ostream& operator<<(std::ostream& os, float16_t value);
 
 pub fn write_main_cpp<'a>(
     w: &mut impl std::io::Write,
-    architecture: &str,
     arch_specific_definitions: &str,
     intrinsics: impl Iterator<Item = &'a str> + Clone,
 ) -> std::io::Result<()> {
@@ -170,9 +164,8 @@ std::ostream& operator<<(std::ostream& os, float16_t value) {{
 "#
     )?;
 
-    writeln!(w, "#ifdef __{architecture}__")?;
+    // NOTE: It's assumed that this value contains the required `ifdef`s.
     writeln!(w, "{arch_specific_definitions }")?;
-    writeln!(w, "#endif")?;
 
     for intrinsic in intrinsics.clone() {
         writeln!(w, "extern int run_{intrinsic}(void);")?;
diff --git a/library/stdarch/crates/intrinsic-test/src/common/gen_rust.rs b/library/stdarch/crates/intrinsic-test/src/common/gen_rust.rs
index 240496f9b765e..312cbee692a56 100644
--- a/library/stdarch/crates/intrinsic-test/src/common/gen_rust.rs
+++ b/library/stdarch/crates/intrinsic-test/src/common/gen_rust.rs
@@ -98,7 +98,6 @@ pub fn write_main_rs<'a>(
 
 pub fn write_lib_rs<T: IntrinsicTypeDefinition>(
     w: &mut impl std::io::Write,
-    architecture: &str,
     notice: &str,
     cfg: &str,
     definitions: &str,
@@ -117,8 +116,6 @@ pub fn write_lib_rs<T: IntrinsicTypeDefinition>(
 
     writeln!(w, "{cfg}")?;
 
-    writeln!(w, "use core_arch::arch::{architecture}::*;")?;
-
     writeln!(w, "{definitions}")?;
 
     for intrinsic in intrinsics {
diff --git a/library/stdarch/crates/intrinsic-test/src/common/mod.rs b/library/stdarch/crates/intrinsic-test/src/common/mod.rs
index b6589ddaef8ef..666b3885c147b 100644
--- a/library/stdarch/crates/intrinsic-test/src/common/mod.rs
+++ b/library/stdarch/crates/intrinsic-test/src/common/mod.rs
@@ -41,6 +41,7 @@ pub trait SupportedArchitectureTest {
 
     const PLATFORM_C_HEADERS: &[&str];
     const PLATFORM_C_DEFINITIONS: &str;
+    const PLATFORM_C_FORWARD_DECLARATIONS: &str;
 
     const PLATFORM_RUST_CFGS: &str;
     const PLATFORM_RUST_DEFINITIONS: &str;
@@ -48,8 +49,6 @@ pub trait SupportedArchitectureTest {
     fn cpp_compilation(&self) -> Option<CppCompilation>;
 
     fn build_c_file(&self) -> bool {
-        let c_target = "aarch64";
-
         let (chunk_size, chunk_count) = chunk_info(self.intrinsics().len());
 
         let cpp_compiler_wrapped = self.cpp_compilation();
@@ -64,8 +63,8 @@ pub trait SupportedArchitectureTest {
                 write_mod_cpp(
                     &mut file,
                     Self::NOTICE,
-                    c_target,
                     Self::PLATFORM_C_HEADERS,
+                    Self::PLATFORM_C_FORWARD_DECLARATIONS,
                     chunk,
                 )
                 .unwrap();
@@ -88,7 +87,6 @@ pub trait SupportedArchitectureTest {
         let mut file = File::create("c_programs/main.cpp").unwrap();
         write_main_cpp(
             &mut file,
-            c_target,
             Self::PLATFORM_C_DEFINITIONS,
             self.intrinsics().iter().map(|i| i.name.as_str()),
         )
@@ -120,12 +118,6 @@ pub trait SupportedArchitectureTest {
     fn build_rust_file(&self) -> bool {
         std::fs::create_dir_all("rust_programs/src").unwrap();
 
-        let architecture = if self.cli_options().target.contains("v7") {
-            "arm"
-        } else {
-            "aarch64"
-        };
-
         let (chunk_size, chunk_count) = chunk_info(self.intrinsics().len());
 
         let mut cargo = File::create("rust_programs/Cargo.toml").unwrap();
@@ -157,7 +149,6 @@ pub trait SupportedArchitectureTest {
 
                 write_lib_rs(
                     &mut file,
-                    architecture,
                     Self::NOTICE,
                     Self::PLATFORM_RUST_CFGS,
                     Self::PLATFORM_RUST_DEFINITIONS,

From a8c669461f0c71985c72dd5b05f70b8d4d149e3b Mon Sep 17 00:00:00 2001
From: Karl Meakin <karl.meakin@arm.com>
Date: Sat, 2 Aug 2025 23:32:10 +0100
Subject: [PATCH 0611/1889] optimization: Don't include ASCII characters in
 Unicode tables

The ASCII subset of Unicode is fixed and will never change, so we don't
need to generate tables for it with every new Unicode version. This
saves a few bytes of static data and speeds up `char::is_control` and
`char::is_grapheme_extended` on ASCII inputs.

Since the table lookup functions exported from the `unicode` module will
give nonsensical errors on ASCII input (and in fact will panic in debug
mode), I had to add some private wrapper methods to `char` which check
for ASCII-ness first.
---
 library/alloc/src/str.rs                      |   5 +-
 library/core/src/char/methods.rs              |  38 +-
 library/core/src/unicode/unicode_data.rs      | 519 ++++++++++--------
 .../src/cascading_map.rs                      |   1 +
 src/tools/unicode-table-generator/src/main.rs |   1 +
 .../src/raw_emitter.rs                        |   1 +
 .../unicode-table-generator/src/skiplist.rs   |   2 +
 7 files changed, 320 insertions(+), 247 deletions(-)

diff --git a/library/alloc/src/str.rs b/library/alloc/src/str.rs
index 22cdd8ecde022..e772ac25a95c2 100644
--- a/library/alloc/src/str.rs
+++ b/library/alloc/src/str.rs
@@ -418,9 +418,8 @@ impl str {
         }
 
         fn case_ignorable_then_cased<I: Iterator<Item = char>>(iter: I) -> bool {
-            use core::unicode::{Case_Ignorable, Cased};
-            match iter.skip_while(|&c| Case_Ignorable(c)).next() {
-                Some(c) => Cased(c),
+            match iter.skip_while(|&c| c.is_case_ignorable()).next() {
+                Some(c) => c.is_cased(),
                 None => false,
             }
         }
diff --git a/library/core/src/char/methods.rs b/library/core/src/char/methods.rs
index 3336d028e273e..76f54db287079 100644
--- a/library/core/src/char/methods.rs
+++ b/library/core/src/char/methods.rs
@@ -969,7 +969,43 @@ impl char {
     #[must_use]
     #[inline]
     pub(crate) fn is_grapheme_extended(self) -> bool {
-        unicode::Grapheme_Extend(self)
+        !self.is_ascii() && unicode::Grapheme_Extend(self)
+    }
+
+    /// Returns `true` if this `char` has the `Cased` property.
+    ///
+    /// `Cased` is described in Chapter 4 (Character Properties) of the [Unicode Standard] and
+    /// specified in the [Unicode Character Database][ucd] [`DerivedCoreProperties.txt`].
+    ///
+    /// [Unicode Standard]: https://www.unicode.org/versions/latest/
+    /// [ucd]: https://www.unicode.org/reports/tr44/
+    /// [`DerivedCoreProperties.txt`]: https://www.unicode.org/Public/UCD/latest/ucd/DerivedCoreProperties.txt
+    #[must_use]
+    #[inline]
+    #[doc(hidden)]
+    #[unstable(feature = "char_internals", reason = "exposed only for libstd", issue = "none")]
+    pub fn is_cased(self) -> bool {
+        if self.is_ascii() { self.is_ascii_alphabetic() } else { unicode::Cased(self) }
+    }
+
+    /// Returns `true` if this `char` has the `Case_Ignorable` property.
+    ///
+    /// `Case_Ignorable` is described in Chapter 4 (Character Properties) of the [Unicode Standard] and
+    /// specified in the [Unicode Character Database][ucd] [`DerivedCoreProperties.txt`].
+    ///
+    /// [Unicode Standard]: https://www.unicode.org/versions/latest/
+    /// [ucd]: https://www.unicode.org/reports/tr44/
+    /// [`DerivedCoreProperties.txt`]: https://www.unicode.org/Public/UCD/latest/ucd/DerivedCoreProperties.txt
+    #[must_use]
+    #[inline]
+    #[doc(hidden)]
+    #[unstable(feature = "char_internals", reason = "exposed only for libstd", issue = "none")]
+    pub fn is_case_ignorable(self) -> bool {
+        if self.is_ascii() {
+            matches!(self, '\'' | '.' | ':' | '^' | '`')
+        } else {
+            unicode::Case_Ignorable(self)
+        }
     }
 
     /// Returns `true` if this `char` has one of the general categories for numbers.
diff --git a/library/core/src/unicode/unicode_data.rs b/library/core/src/unicode/unicode_data.rs
index 0bf2f948e85bd..2f53de183f629 100644
--- a/library/core/src/unicode/unicode_data.rs
+++ b/library/core/src/unicode/unicode_data.rs
@@ -1,16 +1,15 @@
 //! This file is generated by `./x run src/tools/unicode-table-generator`; do not edit manually!
-// Alphabetic      :  1727 bytes, 142759 codepoints in 757 ranges (U+000041 - U+0323B0) using skiplist
-// Case_Ignorable  :  1053 bytes,   2749 codepoints in 452 ranges (U+000027 - U+0E01F0) using skiplist
-// Cased           :   407 bytes,   4578 codepoints in 159 ranges (U+000041 - U+01F18A) using skiplist
-// Cc              :     9 bytes,     65 codepoints in   2 ranges (U+000000 - U+0000A0) using skiplist
+// Alphabetic      :  1723 bytes, 142707 codepoints in 755 ranges (U+0000AA - U+0323B0) using skiplist
+// Case_Ignorable  :  1043 bytes,   2744 codepoints in 447 ranges (U+0000A8 - U+0E01F0) using skiplist
+// Cased           :   403 bytes,   4526 codepoints in 157 ranges (U+0000AA - U+01F18A) using skiplist
 // Grapheme_Extend :   887 bytes,   2193 codepoints in 375 ranges (U+000300 - U+0E01F0) using skiplist
-// Lowercase       :   935 bytes,   2569 codepoints in 675 ranges (U+000061 - U+01E944) using bitset
-// N               :   457 bytes,   1911 codepoints in 144 ranges (U+000030 - U+01FBFA) using skiplist
-// Uppercase       :   799 bytes,   1978 codepoints in 656 ranges (U+000041 - U+01F18A) using bitset
-// White_Space     :   256 bytes,     25 codepoints in  10 ranges (U+000009 - U+003001) using cascading
+// Lowercase       :   933 bytes,   2543 codepoints in 674 ranges (U+0000AA - U+01E944) using bitset
+// N               :   455 bytes,   1901 codepoints in 143 ranges (U+0000B2 - U+01FBFA) using skiplist
+// Uppercase       :   797 bytes,   1952 codepoints in 655 ranges (U+0000C0 - U+01F18A) using bitset
+// White_Space     :   256 bytes,     19 codepoints in   8 ranges (U+000085 - U+003001) using cascading
 // to_lower        : 11484 bytes
 // to_upper        : 13432 bytes
-// Total           : 31446 bytes
+// Total           : 31413 bytes
 
 #[inline(always)]
 const fn bitset_search<
@@ -148,93 +147,100 @@ pub mod alphabetic {
     use super::ShortOffsetRunHeader;
 
     static SHORT_OFFSET_RUNS: [ShortOffsetRunHeader; 53] = [
-        ShortOffsetRunHeader::new(0, 706), ShortOffsetRunHeader::new(16, 4681),
-        ShortOffsetRunHeader::new(418, 5741), ShortOffsetRunHeader::new(456, 7958),
-        ShortOffsetRunHeader::new(556, 9398), ShortOffsetRunHeader::new(627, 11264),
-        ShortOffsetRunHeader::new(629, 12293), ShortOffsetRunHeader::new(667, 13312),
-        ShortOffsetRunHeader::new(691, 19904), ShortOffsetRunHeader::new(692, 42125),
-        ShortOffsetRunHeader::new(694, 42509), ShortOffsetRunHeader::new(698, 55204),
-        ShortOffsetRunHeader::new(788, 63744), ShortOffsetRunHeader::new(793, 64110),
-        ShortOffsetRunHeader::new(794, 64830), ShortOffsetRunHeader::new(816, 66176),
-        ShortOffsetRunHeader::new(857, 67383), ShortOffsetRunHeader::new(904, 73440),
-        ShortOffsetRunHeader::new(1221, 74650), ShortOffsetRunHeader::new(1232, 77712),
-        ShortOffsetRunHeader::new(1237, 78896), ShortOffsetRunHeader::new(1240, 82939),
-        ShortOffsetRunHeader::new(1244, 83527), ShortOffsetRunHeader::new(1246, 90368),
-        ShortOffsetRunHeader::new(1247, 92160), ShortOffsetRunHeader::new(1249, 92729),
-        ShortOffsetRunHeader::new(1250, 93504), ShortOffsetRunHeader::new(1265, 100344),
-        ShortOffsetRunHeader::new(1282, 101590), ShortOffsetRunHeader::new(1284, 110576),
-        ShortOffsetRunHeader::new(1287, 110883), ShortOffsetRunHeader::new(1294, 111356),
-        ShortOffsetRunHeader::new(1304, 113664), ShortOffsetRunHeader::new(1305, 119808),
-        ShortOffsetRunHeader::new(1315, 120486), ShortOffsetRunHeader::new(1352, 122624),
-        ShortOffsetRunHeader::new(1375, 123536), ShortOffsetRunHeader::new(1399, 124112),
-        ShortOffsetRunHeader::new(1403, 124896), ShortOffsetRunHeader::new(1409, 126464),
-        ShortOffsetRunHeader::new(1425, 127280), ShortOffsetRunHeader::new(1491, 131072),
-        ShortOffsetRunHeader::new(1497, 173792), ShortOffsetRunHeader::new(1498, 177978),
-        ShortOffsetRunHeader::new(1500, 183970), ShortOffsetRunHeader::new(1504, 191457),
-        ShortOffsetRunHeader::new(1506, 192094), ShortOffsetRunHeader::new(1508, 194560),
-        ShortOffsetRunHeader::new(1509, 195102), ShortOffsetRunHeader::new(1510, 196608),
-        ShortOffsetRunHeader::new(1511, 201547), ShortOffsetRunHeader::new(1512, 205744),
-        ShortOffsetRunHeader::new(1514, 1319856),
+        ShortOffsetRunHeader::new(0, 706), ShortOffsetRunHeader::new(12, 4681),
+        ShortOffsetRunHeader::new(414, 5741), ShortOffsetRunHeader::new(452, 7958),
+        ShortOffsetRunHeader::new(552, 9398), ShortOffsetRunHeader::new(623, 11264),
+        ShortOffsetRunHeader::new(625, 12293), ShortOffsetRunHeader::new(663, 13312),
+        ShortOffsetRunHeader::new(687, 19904), ShortOffsetRunHeader::new(688, 42125),
+        ShortOffsetRunHeader::new(690, 42509), ShortOffsetRunHeader::new(694, 55204),
+        ShortOffsetRunHeader::new(784, 63744), ShortOffsetRunHeader::new(789, 64110),
+        ShortOffsetRunHeader::new(790, 64830), ShortOffsetRunHeader::new(812, 66176),
+        ShortOffsetRunHeader::new(853, 67383), ShortOffsetRunHeader::new(900, 73440),
+        ShortOffsetRunHeader::new(1217, 74650), ShortOffsetRunHeader::new(1228, 77712),
+        ShortOffsetRunHeader::new(1233, 78896), ShortOffsetRunHeader::new(1236, 82939),
+        ShortOffsetRunHeader::new(1240, 83527), ShortOffsetRunHeader::new(1242, 90368),
+        ShortOffsetRunHeader::new(1243, 92160), ShortOffsetRunHeader::new(1245, 92729),
+        ShortOffsetRunHeader::new(1246, 93504), ShortOffsetRunHeader::new(1261, 100344),
+        ShortOffsetRunHeader::new(1278, 101590), ShortOffsetRunHeader::new(1280, 110576),
+        ShortOffsetRunHeader::new(1283, 110883), ShortOffsetRunHeader::new(1290, 111356),
+        ShortOffsetRunHeader::new(1300, 113664), ShortOffsetRunHeader::new(1301, 119808),
+        ShortOffsetRunHeader::new(1311, 120486), ShortOffsetRunHeader::new(1348, 122624),
+        ShortOffsetRunHeader::new(1371, 123536), ShortOffsetRunHeader::new(1395, 124112),
+        ShortOffsetRunHeader::new(1399, 124896), ShortOffsetRunHeader::new(1405, 126464),
+        ShortOffsetRunHeader::new(1421, 127280), ShortOffsetRunHeader::new(1487, 131072),
+        ShortOffsetRunHeader::new(1493, 173792), ShortOffsetRunHeader::new(1494, 177978),
+        ShortOffsetRunHeader::new(1496, 183970), ShortOffsetRunHeader::new(1500, 191457),
+        ShortOffsetRunHeader::new(1502, 192094), ShortOffsetRunHeader::new(1504, 194560),
+        ShortOffsetRunHeader::new(1505, 195102), ShortOffsetRunHeader::new(1506, 196608),
+        ShortOffsetRunHeader::new(1507, 201547), ShortOffsetRunHeader::new(1508, 205744),
+        ShortOffsetRunHeader::new(1510, 1319856),
     ];
-    static OFFSETS: [u8; 1515] = [
-        65, 26, 6, 26, 47, 1, 10, 1, 4, 1, 5, 23, 1, 31, 1, 0, 4, 12, 14, 5, 7, 1, 1, 1, 86, 1, 29,
-        18, 1, 2, 2, 4, 1, 1, 6, 1, 1, 3, 1, 1, 1, 20, 1, 83, 1, 139, 8, 166, 1, 38, 2, 1, 6, 41,
-        39, 14, 1, 1, 1, 2, 1, 2, 1, 1, 8, 27, 4, 4, 29, 11, 5, 56, 1, 7, 14, 102, 1, 8, 4, 8, 4, 3,
-        10, 3, 2, 1, 16, 48, 13, 101, 24, 33, 9, 2, 4, 1, 5, 24, 2, 19, 19, 25, 7, 11, 5, 24, 1, 6,
-        8, 1, 8, 42, 10, 12, 3, 7, 6, 76, 1, 16, 1, 3, 4, 15, 13, 19, 1, 8, 2, 2, 2, 22, 1, 7, 1, 1,
-        3, 4, 3, 8, 2, 2, 2, 2, 1, 1, 8, 1, 4, 2, 1, 5, 12, 2, 10, 1, 4, 3, 1, 6, 4, 2, 2, 22, 1, 7,
-        1, 2, 1, 2, 1, 2, 4, 5, 4, 2, 2, 2, 4, 1, 7, 4, 1, 1, 17, 6, 11, 3, 1, 9, 1, 3, 1, 22, 1, 7,
-        1, 2, 1, 5, 3, 9, 1, 3, 1, 2, 3, 1, 15, 4, 21, 4, 4, 3, 1, 8, 2, 2, 2, 22, 1, 7, 1, 2, 1, 5,
-        3, 8, 2, 2, 2, 2, 9, 2, 4, 2, 1, 5, 13, 1, 16, 2, 1, 6, 3, 3, 1, 4, 3, 2, 1, 1, 1, 2, 3, 2,
-        3, 3, 3, 12, 4, 5, 3, 3, 1, 3, 3, 1, 6, 1, 40, 13, 1, 3, 1, 23, 1, 16, 3, 8, 1, 3, 1, 3, 8,
-        2, 1, 3, 2, 1, 2, 4, 28, 4, 1, 8, 1, 3, 1, 23, 1, 10, 1, 5, 3, 8, 1, 3, 1, 3, 8, 2, 6, 2, 1,
-        4, 13, 3, 12, 13, 1, 3, 1, 41, 2, 8, 1, 3, 1, 3, 1, 1, 5, 4, 7, 5, 22, 6, 1, 3, 1, 18, 3,
-        24, 1, 9, 1, 1, 2, 7, 8, 6, 1, 1, 1, 8, 18, 2, 13, 58, 5, 7, 6, 1, 51, 2, 1, 1, 1, 5, 1, 24,
-        1, 1, 1, 19, 1, 3, 2, 5, 1, 1, 6, 1, 14, 4, 32, 1, 63, 8, 1, 36, 4, 19, 4, 16, 1, 36, 67,
-        55, 1, 1, 2, 5, 16, 64, 10, 4, 2, 38, 1, 1, 5, 1, 2, 43, 1, 0, 1, 4, 2, 7, 1, 1, 1, 4, 2,
-        41, 1, 4, 2, 33, 1, 4, 2, 7, 1, 1, 1, 4, 2, 15, 1, 57, 1, 4, 2, 67, 37, 16, 16, 86, 2, 6, 3,
-        0, 2, 17, 1, 26, 5, 75, 3, 11, 7, 20, 11, 21, 12, 20, 12, 13, 1, 3, 1, 2, 12, 52, 2, 19, 14,
-        1, 4, 1, 67, 89, 7, 43, 5, 70, 10, 31, 1, 12, 4, 9, 23, 30, 2, 5, 11, 44, 4, 26, 54, 28, 4,
-        63, 2, 20, 50, 1, 23, 2, 11, 3, 49, 52, 1, 15, 1, 8, 51, 42, 2, 4, 10, 44, 1, 11, 14, 55,
-        22, 3, 10, 36, 2, 11, 5, 43, 2, 3, 41, 4, 1, 6, 1, 2, 3, 1, 5, 192, 19, 34, 11, 0, 2, 6, 2,
-        38, 2, 6, 2, 8, 1, 1, 1, 1, 1, 1, 1, 31, 2, 53, 1, 7, 1, 1, 3, 3, 1, 7, 3, 4, 2, 6, 4, 13,
-        5, 3, 1, 7, 116, 1, 13, 1, 16, 13, 101, 1, 4, 1, 2, 10, 1, 1, 3, 5, 6, 1, 1, 1, 1, 1, 1, 4,
-        1, 11, 2, 4, 5, 5, 4, 1, 17, 41, 0, 52, 0, 229, 6, 4, 3, 2, 12, 38, 1, 1, 5, 1, 2, 56, 7, 1,
-        16, 23, 9, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 32, 47, 1, 0, 3, 25, 9, 7, 5, 2,
-        5, 4, 86, 6, 3, 1, 90, 1, 4, 5, 43, 1, 94, 17, 32, 48, 16, 0, 0, 64, 0, 67, 46, 2, 0, 3, 16,
-        10, 2, 20, 47, 5, 8, 3, 113, 39, 9, 2, 103, 2, 67, 2, 2, 1, 1, 1, 8, 21, 20, 1, 33, 24, 52,
-        12, 68, 1, 1, 44, 6, 3, 1, 1, 3, 10, 33, 5, 35, 13, 29, 3, 51, 1, 12, 15, 1, 16, 16, 10, 5,
-        1, 55, 9, 14, 18, 23, 3, 69, 1, 1, 1, 1, 24, 3, 2, 16, 2, 4, 11, 6, 2, 6, 2, 6, 9, 7, 1, 7,
-        1, 43, 1, 14, 6, 123, 21, 0, 12, 23, 4, 49, 0, 0, 2, 106, 38, 7, 12, 5, 5, 12, 1, 13, 1, 5,
-        1, 1, 1, 2, 1, 2, 1, 108, 33, 0, 18, 64, 2, 54, 40, 12, 116, 5, 1, 135, 36, 26, 6, 26, 11,
-        89, 3, 6, 2, 6, 2, 6, 2, 3, 35, 12, 1, 26, 1, 19, 1, 2, 1, 15, 2, 14, 34, 123, 69, 53, 0,
-        29, 3, 49, 47, 32, 13, 30, 5, 43, 5, 30, 2, 36, 4, 8, 1, 5, 42, 158, 18, 36, 4, 36, 4, 40,
-        8, 52, 12, 11, 1, 15, 1, 7, 1, 2, 1, 11, 1, 15, 1, 7, 1, 2, 3, 52, 12, 0, 9, 22, 10, 8, 24,
-        6, 1, 42, 1, 9, 69, 6, 2, 1, 1, 44, 1, 2, 3, 1, 2, 23, 10, 23, 9, 31, 65, 19, 1, 2, 10, 22,
-        10, 26, 70, 56, 6, 2, 64, 4, 1, 2, 5, 8, 1, 3, 1, 29, 42, 29, 3, 29, 35, 8, 1, 28, 27, 54,
-        10, 22, 10, 19, 13, 18, 110, 73, 55, 51, 13, 51, 13, 40, 34, 28, 3, 1, 5, 23, 250, 42, 1, 2,
-        3, 2, 16, 3, 55, 1, 3, 29, 10, 1, 8, 22, 42, 18, 46, 21, 27, 23, 9, 70, 43, 5, 10, 57, 9, 1,
-        13, 25, 23, 51, 17, 4, 8, 35, 3, 1, 9, 64, 1, 4, 9, 2, 10, 1, 1, 1, 35, 18, 1, 34, 2, 1, 6,
-        4, 62, 7, 1, 1, 1, 4, 1, 15, 1, 10, 7, 57, 23, 4, 1, 8, 2, 2, 2, 22, 1, 7, 1, 2, 1, 5, 3, 8,
-        2, 2, 2, 2, 3, 1, 6, 1, 5, 7, 28, 10, 1, 1, 2, 1, 1, 38, 1, 10, 1, 1, 2, 1, 1, 4, 1, 2, 3,
-        1, 1, 1, 44, 66, 1, 3, 1, 4, 20, 3, 30, 66, 2, 2, 1, 1, 184, 54, 2, 7, 25, 6, 34, 63, 1, 1,
-        3, 1, 59, 54, 2, 1, 71, 27, 2, 14, 21, 7, 185, 57, 103, 64, 31, 8, 2, 1, 2, 8, 1, 2, 1, 30,
-        1, 2, 2, 2, 2, 4, 93, 8, 2, 46, 2, 6, 1, 1, 1, 2, 27, 51, 2, 10, 17, 72, 5, 1, 18, 73, 199,
-        33, 31, 9, 1, 45, 1, 7, 1, 1, 49, 30, 2, 22, 1, 14, 73, 7, 1, 2, 1, 44, 3, 1, 1, 2, 1, 3, 1,
-        1, 2, 2, 24, 6, 1, 2, 1, 37, 1, 2, 1, 4, 1, 1, 0, 23, 9, 17, 1, 41, 3, 3, 111, 1, 79, 0,
-        102, 111, 17, 196, 0, 97, 15, 0, 17, 6, 25, 0, 5, 0, 0, 47, 0, 0, 7, 31, 17, 79, 17, 30, 18,
-        48, 16, 4, 31, 21, 5, 19, 0, 45, 211, 64, 128, 75, 4, 57, 7, 17, 64, 2, 1, 1, 12, 2, 14, 0,
-        8, 0, 41, 10, 0, 4, 1, 7, 1, 2, 1, 0, 15, 1, 29, 3, 2, 1, 14, 4, 8, 0, 0, 107, 5, 13, 3, 9,
-        7, 10, 4, 1, 0, 85, 1, 71, 1, 2, 2, 1, 2, 2, 2, 4, 1, 12, 1, 1, 1, 7, 1, 65, 1, 4, 2, 8, 1,
-        7, 1, 28, 1, 4, 1, 5, 1, 1, 3, 7, 1, 0, 2, 25, 1, 25, 1, 31, 1, 25, 1, 31, 1, 25, 1, 31, 1,
-        25, 1, 31, 1, 25, 1, 8, 0, 31, 6, 6, 213, 7, 1, 17, 2, 7, 1, 2, 1, 5, 5, 62, 33, 1, 112, 45,
-        10, 7, 16, 1, 0, 30, 18, 44, 0, 28, 228, 30, 2, 1, 0, 7, 1, 4, 1, 2, 1, 15, 1, 197, 59, 68,
-        3, 1, 3, 1, 0, 4, 1, 27, 1, 2, 1, 1, 2, 1, 1, 10, 1, 4, 1, 1, 1, 1, 6, 1, 4, 1, 1, 1, 1, 1,
-        1, 3, 1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 2, 4, 1, 7, 1, 4, 1, 4, 1, 1, 1,
-        10, 1, 17, 5, 3, 1, 5, 1, 17, 0, 26, 6, 26, 6, 26, 0, 0, 32, 0, 6, 222, 2, 0, 14, 0, 15, 0,
-        0, 0, 0, 0, 5, 0, 0,
+    static OFFSETS: [u8; 1511] = [
+        170, 1, 10, 1, 4, 1, 5, 23, 1, 31, 1, 0, 4, 12, 14, 5, 7, 1, 1, 1, 86, 1, 29, 18, 1, 2, 2,
+        4, 1, 1, 6, 1, 1, 3, 1, 1, 1, 20, 1, 83, 1, 139, 8, 166, 1, 38, 2, 1, 6, 41, 39, 14, 1, 1,
+        1, 2, 1, 2, 1, 1, 8, 27, 4, 4, 29, 11, 5, 56, 1, 7, 14, 102, 1, 8, 4, 8, 4, 3, 10, 3, 2, 1,
+        16, 48, 13, 101, 24, 33, 9, 2, 4, 1, 5, 24, 2, 19, 19, 25, 7, 11, 5, 24, 1, 6, 8, 1, 8, 42,
+        10, 12, 3, 7, 6, 76, 1, 16, 1, 3, 4, 15, 13, 19, 1, 8, 2, 2, 2, 22, 1, 7, 1, 1, 3, 4, 3, 8,
+        2, 2, 2, 2, 1, 1, 8, 1, 4, 2, 1, 5, 12, 2, 10, 1, 4, 3, 1, 6, 4, 2, 2, 22, 1, 7, 1, 2, 1, 2,
+        1, 2, 4, 5, 4, 2, 2, 2, 4, 1, 7, 4, 1, 1, 17, 6, 11, 3, 1, 9, 1, 3, 1, 22, 1, 7, 1, 2, 1, 5,
+        3, 9, 1, 3, 1, 2, 3, 1, 15, 4, 21, 4, 4, 3, 1, 8, 2, 2, 2, 22, 1, 7, 1, 2, 1, 5, 3, 8, 2, 2,
+        2, 2, 9, 2, 4, 2, 1, 5, 13, 1, 16, 2, 1, 6, 3, 3, 1, 4, 3, 2, 1, 1, 1, 2, 3, 2, 3, 3, 3, 12,
+        4, 5, 3, 3, 1, 3, 3, 1, 6, 1, 40, 13, 1, 3, 1, 23, 1, 16, 3, 8, 1, 3, 1, 3, 8, 2, 1, 3, 2,
+        1, 2, 4, 28, 4, 1, 8, 1, 3, 1, 23, 1, 10, 1, 5, 3, 8, 1, 3, 1, 3, 8, 2, 6, 2, 1, 4, 13, 3,
+        12, 13, 1, 3, 1, 41, 2, 8, 1, 3, 1, 3, 1, 1, 5, 4, 7, 5, 22, 6, 1, 3, 1, 18, 3, 24, 1, 9, 1,
+        1, 2, 7, 8, 6, 1, 1, 1, 8, 18, 2, 13, 58, 5, 7, 6, 1, 51, 2, 1, 1, 1, 5, 1, 24, 1, 1, 1, 19,
+        1, 3, 2, 5, 1, 1, 6, 1, 14, 4, 32, 1, 63, 8, 1, 36, 4, 19, 4, 16, 1, 36, 67, 55, 1, 1, 2, 5,
+        16, 64, 10, 4, 2, 38, 1, 1, 5, 1, 2, 43, 1, 0, 1, 4, 2, 7, 1, 1, 1, 4, 2, 41, 1, 4, 2, 33,
+        1, 4, 2, 7, 1, 1, 1, 4, 2, 15, 1, 57, 1, 4, 2, 67, 37, 16, 16, 86, 2, 6, 3, 0, 2, 17, 1, 26,
+        5, 75, 3, 11, 7, 20, 11, 21, 12, 20, 12, 13, 1, 3, 1, 2, 12, 52, 2, 19, 14, 1, 4, 1, 67, 89,
+        7, 43, 5, 70, 10, 31, 1, 12, 4, 9, 23, 30, 2, 5, 11, 44, 4, 26, 54, 28, 4, 63, 2, 20, 50, 1,
+        23, 2, 11, 3, 49, 52, 1, 15, 1, 8, 51, 42, 2, 4, 10, 44, 1, 11, 14, 55, 22, 3, 10, 36, 2,
+        11, 5, 43, 2, 3, 41, 4, 1, 6, 1, 2, 3, 1, 5, 192, 19, 34, 11, 0, 2, 6, 2, 38, 2, 6, 2, 8, 1,
+        1, 1, 1, 1, 1, 1, 31, 2, 53, 1, 7, 1, 1, 3, 3, 1, 7, 3, 4, 2, 6, 4, 13, 5, 3, 1, 7, 116, 1,
+        13, 1, 16, 13, 101, 1, 4, 1, 2, 10, 1, 1, 3, 5, 6, 1, 1, 1, 1, 1, 1, 4, 1, 11, 2, 4, 5, 5,
+        4, 1, 17, 41, 0, 52, 0, 229, 6, 4, 3, 2, 12, 38, 1, 1, 5, 1, 2, 56, 7, 1, 16, 23, 9, 7, 1,
+        7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 32, 47, 1, 0, 3, 25, 9, 7, 5, 2, 5, 4, 86, 6, 3,
+        1, 90, 1, 4, 5, 43, 1, 94, 17, 32, 48, 16, 0, 0, 64, 0, 67, 46, 2, 0, 3, 16, 10, 2, 20, 47,
+        5, 8, 3, 113, 39, 9, 2, 103, 2, 67, 2, 2, 1, 1, 1, 8, 21, 20, 1, 33, 24, 52, 12, 68, 1, 1,
+        44, 6, 3, 1, 1, 3, 10, 33, 5, 35, 13, 29, 3, 51, 1, 12, 15, 1, 16, 16, 10, 5, 1, 55, 9, 14,
+        18, 23, 3, 69, 1, 1, 1, 1, 24, 3, 2, 16, 2, 4, 11, 6, 2, 6, 2, 6, 9, 7, 1, 7, 1, 43, 1, 14,
+        6, 123, 21, 0, 12, 23, 4, 49, 0, 0, 2, 106, 38, 7, 12, 5, 5, 12, 1, 13, 1, 5, 1, 1, 1, 2, 1,
+        2, 1, 108, 33, 0, 18, 64, 2, 54, 40, 12, 116, 5, 1, 135, 36, 26, 6, 26, 11, 89, 3, 6, 2, 6,
+        2, 6, 2, 3, 35, 12, 1, 26, 1, 19, 1, 2, 1, 15, 2, 14, 34, 123, 69, 53, 0, 29, 3, 49, 47, 32,
+        13, 30, 5, 43, 5, 30, 2, 36, 4, 8, 1, 5, 42, 158, 18, 36, 4, 36, 4, 40, 8, 52, 12, 11, 1,
+        15, 1, 7, 1, 2, 1, 11, 1, 15, 1, 7, 1, 2, 3, 52, 12, 0, 9, 22, 10, 8, 24, 6, 1, 42, 1, 9,
+        69, 6, 2, 1, 1, 44, 1, 2, 3, 1, 2, 23, 10, 23, 9, 31, 65, 19, 1, 2, 10, 22, 10, 26, 70, 56,
+        6, 2, 64, 4, 1, 2, 5, 8, 1, 3, 1, 29, 42, 29, 3, 29, 35, 8, 1, 28, 27, 54, 10, 22, 10, 19,
+        13, 18, 110, 73, 55, 51, 13, 51, 13, 40, 34, 28, 3, 1, 5, 23, 250, 42, 1, 2, 3, 2, 16, 3,
+        55, 1, 3, 29, 10, 1, 8, 22, 42, 18, 46, 21, 27, 23, 9, 70, 43, 5, 10, 57, 9, 1, 13, 25, 23,
+        51, 17, 4, 8, 35, 3, 1, 9, 64, 1, 4, 9, 2, 10, 1, 1, 1, 35, 18, 1, 34, 2, 1, 6, 4, 62, 7, 1,
+        1, 1, 4, 1, 15, 1, 10, 7, 57, 23, 4, 1, 8, 2, 2, 2, 22, 1, 7, 1, 2, 1, 5, 3, 8, 2, 2, 2, 2,
+        3, 1, 6, 1, 5, 7, 28, 10, 1, 1, 2, 1, 1, 38, 1, 10, 1, 1, 2, 1, 1, 4, 1, 2, 3, 1, 1, 1, 44,
+        66, 1, 3, 1, 4, 20, 3, 30, 66, 2, 2, 1, 1, 184, 54, 2, 7, 25, 6, 34, 63, 1, 1, 3, 1, 59, 54,
+        2, 1, 71, 27, 2, 14, 21, 7, 185, 57, 103, 64, 31, 8, 2, 1, 2, 8, 1, 2, 1, 30, 1, 2, 2, 2, 2,
+        4, 93, 8, 2, 46, 2, 6, 1, 1, 1, 2, 27, 51, 2, 10, 17, 72, 5, 1, 18, 73, 199, 33, 31, 9, 1,
+        45, 1, 7, 1, 1, 49, 30, 2, 22, 1, 14, 73, 7, 1, 2, 1, 44, 3, 1, 1, 2, 1, 3, 1, 1, 2, 2, 24,
+        6, 1, 2, 1, 37, 1, 2, 1, 4, 1, 1, 0, 23, 9, 17, 1, 41, 3, 3, 111, 1, 79, 0, 102, 111, 17,
+        196, 0, 97, 15, 0, 17, 6, 25, 0, 5, 0, 0, 47, 0, 0, 7, 31, 17, 79, 17, 30, 18, 48, 16, 4,
+        31, 21, 5, 19, 0, 45, 211, 64, 128, 75, 4, 57, 7, 17, 64, 2, 1, 1, 12, 2, 14, 0, 8, 0, 41,
+        10, 0, 4, 1, 7, 1, 2, 1, 0, 15, 1, 29, 3, 2, 1, 14, 4, 8, 0, 0, 107, 5, 13, 3, 9, 7, 10, 4,
+        1, 0, 85, 1, 71, 1, 2, 2, 1, 2, 2, 2, 4, 1, 12, 1, 1, 1, 7, 1, 65, 1, 4, 2, 8, 1, 7, 1, 28,
+        1, 4, 1, 5, 1, 1, 3, 7, 1, 0, 2, 25, 1, 25, 1, 31, 1, 25, 1, 31, 1, 25, 1, 31, 1, 25, 1, 31,
+        1, 25, 1, 8, 0, 31, 6, 6, 213, 7, 1, 17, 2, 7, 1, 2, 1, 5, 5, 62, 33, 1, 112, 45, 10, 7, 16,
+        1, 0, 30, 18, 44, 0, 28, 228, 30, 2, 1, 0, 7, 1, 4, 1, 2, 1, 15, 1, 197, 59, 68, 3, 1, 3, 1,
+        0, 4, 1, 27, 1, 2, 1, 1, 2, 1, 1, 10, 1, 4, 1, 1, 1, 1, 6, 1, 4, 1, 1, 1, 1, 1, 1, 3, 1, 2,
+        1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 2, 4, 1, 7, 1, 4, 1, 4, 1, 1, 1, 10, 1, 17,
+        5, 3, 1, 5, 1, 17, 0, 26, 6, 26, 6, 26, 0, 0, 32, 0, 6, 222, 2, 0, 14, 0, 15, 0, 0, 0, 0, 0,
+        5, 0, 0,
     ];
+    #[inline]
     pub fn lookup(c: char) -> bool {
+        debug_assert!(!c.is_ascii());
+        (c as u32) >= 0xaa && lookup_slow(c)
+    }
+
+    #[inline(never)]
+    fn lookup_slow(c: char) -> bool {
         const {
             assert!(SHORT_OFFSET_RUNS.last().unwrap().0 > char::MAX as u32);
             let mut i = 0;
@@ -254,62 +260,69 @@ pub mod case_ignorable {
     use super::ShortOffsetRunHeader;
 
     static SHORT_OFFSET_RUNS: [ShortOffsetRunHeader; 37] = [
-        ShortOffsetRunHeader::new(0, 688), ShortOffsetRunHeader::new(21, 4957),
-        ShortOffsetRunHeader::new(273, 5906), ShortOffsetRunHeader::new(275, 8125),
-        ShortOffsetRunHeader::new(385, 11388), ShortOffsetRunHeader::new(419, 12293),
-        ShortOffsetRunHeader::new(431, 40981), ShortOffsetRunHeader::new(443, 42232),
-        ShortOffsetRunHeader::new(445, 42508), ShortOffsetRunHeader::new(447, 64286),
-        ShortOffsetRunHeader::new(543, 65024), ShortOffsetRunHeader::new(547, 66045),
-        ShortOffsetRunHeader::new(577, 67456), ShortOffsetRunHeader::new(583, 68097),
-        ShortOffsetRunHeader::new(589, 68900), ShortOffsetRunHeader::new(601, 69291),
-        ShortOffsetRunHeader::new(609, 71727), ShortOffsetRunHeader::new(733, 71995),
-        ShortOffsetRunHeader::new(737, 72752), ShortOffsetRunHeader::new(765, 73459),
-        ShortOffsetRunHeader::new(795, 78896), ShortOffsetRunHeader::new(807, 90398),
-        ShortOffsetRunHeader::new(811, 92912), ShortOffsetRunHeader::new(815, 93504),
-        ShortOffsetRunHeader::new(821, 94031), ShortOffsetRunHeader::new(825, 110576),
-        ShortOffsetRunHeader::new(833, 113821), ShortOffsetRunHeader::new(839, 118528),
-        ShortOffsetRunHeader::new(843, 119143), ShortOffsetRunHeader::new(847, 121344),
-        ShortOffsetRunHeader::new(857, 122880), ShortOffsetRunHeader::new(869, 123566),
-        ShortOffsetRunHeader::new(885, 124139), ShortOffsetRunHeader::new(889, 125136),
-        ShortOffsetRunHeader::new(893, 127995), ShortOffsetRunHeader::new(897, 917505),
-        ShortOffsetRunHeader::new(899, 2032112),
+        ShortOffsetRunHeader::new(0, 688), ShortOffsetRunHeader::new(11, 4957),
+        ShortOffsetRunHeader::new(263, 5906), ShortOffsetRunHeader::new(265, 8125),
+        ShortOffsetRunHeader::new(375, 11388), ShortOffsetRunHeader::new(409, 12293),
+        ShortOffsetRunHeader::new(421, 40981), ShortOffsetRunHeader::new(433, 42232),
+        ShortOffsetRunHeader::new(435, 42508), ShortOffsetRunHeader::new(437, 64286),
+        ShortOffsetRunHeader::new(533, 65024), ShortOffsetRunHeader::new(537, 66045),
+        ShortOffsetRunHeader::new(567, 67456), ShortOffsetRunHeader::new(573, 68097),
+        ShortOffsetRunHeader::new(579, 68900), ShortOffsetRunHeader::new(591, 69291),
+        ShortOffsetRunHeader::new(599, 71727), ShortOffsetRunHeader::new(723, 71995),
+        ShortOffsetRunHeader::new(727, 72752), ShortOffsetRunHeader::new(755, 73459),
+        ShortOffsetRunHeader::new(785, 78896), ShortOffsetRunHeader::new(797, 90398),
+        ShortOffsetRunHeader::new(801, 92912), ShortOffsetRunHeader::new(805, 93504),
+        ShortOffsetRunHeader::new(811, 94031), ShortOffsetRunHeader::new(815, 110576),
+        ShortOffsetRunHeader::new(823, 113821), ShortOffsetRunHeader::new(829, 118528),
+        ShortOffsetRunHeader::new(833, 119143), ShortOffsetRunHeader::new(837, 121344),
+        ShortOffsetRunHeader::new(847, 122880), ShortOffsetRunHeader::new(859, 123566),
+        ShortOffsetRunHeader::new(875, 124139), ShortOffsetRunHeader::new(879, 125136),
+        ShortOffsetRunHeader::new(883, 127995), ShortOffsetRunHeader::new(887, 917505),
+        ShortOffsetRunHeader::new(889, 2032112),
     ];
-    static OFFSETS: [u8; 905] = [
-        39, 1, 6, 1, 11, 1, 35, 1, 1, 1, 71, 1, 4, 1, 1, 1, 4, 1, 2, 2, 0, 192, 4, 2, 4, 1, 9, 2,
-        1, 1, 251, 7, 207, 1, 5, 1, 49, 45, 1, 1, 1, 2, 1, 2, 1, 1, 44, 1, 11, 6, 10, 11, 1, 1, 35,
-        1, 10, 21, 16, 1, 101, 8, 1, 10, 1, 4, 33, 1, 1, 1, 30, 27, 91, 11, 58, 11, 4, 1, 2, 1, 24,
-        24, 43, 3, 44, 1, 7, 2, 5, 9, 41, 58, 55, 1, 1, 1, 4, 8, 4, 1, 3, 7, 10, 2, 13, 1, 15, 1,
-        58, 1, 4, 4, 8, 1, 20, 2, 26, 1, 2, 2, 57, 1, 4, 2, 4, 2, 2, 3, 3, 1, 30, 2, 3, 1, 11, 2,
-        57, 1, 4, 5, 1, 2, 4, 1, 20, 2, 22, 6, 1, 1, 58, 1, 2, 1, 1, 4, 8, 1, 7, 2, 11, 2, 30, 1,
-        61, 1, 12, 1, 50, 1, 3, 1, 55, 1, 1, 3, 5, 3, 1, 4, 7, 2, 11, 2, 29, 1, 58, 1, 2, 1, 6, 1,
-        5, 2, 20, 2, 28, 2, 57, 2, 4, 4, 8, 1, 20, 2, 29, 1, 72, 1, 7, 3, 1, 1, 90, 1, 2, 7, 11, 9,
-        98, 1, 2, 9, 9, 1, 1, 7, 73, 2, 27, 1, 1, 1, 1, 1, 55, 14, 1, 5, 1, 2, 5, 11, 1, 36, 9, 1,
-        102, 4, 1, 6, 1, 2, 2, 2, 25, 2, 4, 3, 16, 4, 13, 1, 2, 2, 6, 1, 15, 1, 94, 1, 0, 3, 0, 3,
-        29, 2, 30, 2, 30, 2, 64, 2, 1, 7, 8, 1, 2, 11, 3, 1, 5, 1, 45, 5, 51, 1, 65, 2, 34, 1, 118,
-        3, 4, 2, 9, 1, 6, 3, 219, 2, 2, 1, 58, 1, 1, 7, 1, 1, 1, 1, 2, 8, 6, 10, 2, 1, 39, 1, 8, 31,
-        49, 4, 48, 1, 1, 5, 1, 1, 5, 1, 40, 9, 12, 2, 32, 4, 2, 2, 1, 3, 56, 1, 1, 2, 3, 1, 1, 3,
-        58, 8, 2, 2, 64, 6, 82, 3, 1, 13, 1, 7, 4, 1, 6, 1, 3, 2, 50, 63, 13, 1, 34, 101, 0, 1, 1,
-        3, 11, 3, 13, 3, 13, 3, 13, 2, 12, 5, 8, 2, 10, 1, 2, 1, 2, 5, 49, 5, 1, 10, 1, 1, 13, 1,
-        16, 13, 51, 33, 0, 2, 113, 3, 125, 1, 15, 1, 96, 32, 47, 1, 0, 1, 36, 4, 3, 5, 5, 1, 93, 6,
-        93, 3, 0, 1, 0, 6, 0, 1, 98, 4, 1, 10, 1, 1, 28, 4, 80, 2, 14, 34, 78, 1, 23, 3, 103, 3, 3,
-        2, 8, 1, 3, 1, 4, 1, 25, 2, 5, 1, 151, 2, 26, 18, 13, 1, 38, 8, 25, 11, 46, 3, 48, 1, 2, 4,
-        2, 2, 17, 1, 21, 2, 66, 6, 2, 2, 2, 2, 12, 1, 8, 1, 35, 1, 11, 1, 51, 1, 1, 3, 2, 2, 5, 2,
-        1, 1, 27, 1, 14, 2, 5, 2, 1, 1, 100, 5, 9, 3, 121, 1, 2, 1, 4, 1, 0, 1, 147, 17, 0, 16, 3,
-        1, 12, 16, 34, 1, 2, 1, 169, 1, 7, 1, 6, 1, 11, 1, 35, 1, 1, 1, 47, 1, 45, 2, 67, 1, 21, 3,
-        0, 1, 226, 1, 149, 5, 0, 6, 1, 42, 1, 9, 0, 3, 1, 2, 5, 4, 40, 3, 4, 1, 165, 2, 0, 4, 38, 1,
-        26, 5, 1, 1, 0, 2, 79, 4, 70, 11, 49, 4, 123, 1, 54, 15, 41, 1, 2, 2, 10, 3, 49, 4, 2, 2, 2,
-        1, 4, 1, 10, 1, 50, 3, 36, 5, 1, 8, 62, 1, 12, 2, 52, 9, 10, 4, 2, 1, 95, 3, 2, 1, 1, 2, 6,
-        1, 2, 1, 157, 1, 3, 8, 21, 2, 57, 2, 3, 1, 37, 7, 3, 5, 70, 6, 13, 1, 1, 1, 1, 1, 14, 2, 85,
-        8, 2, 3, 1, 1, 23, 1, 84, 6, 1, 1, 4, 2, 1, 2, 238, 4, 6, 2, 1, 2, 27, 2, 85, 8, 2, 1, 1, 2,
-        106, 1, 1, 1, 2, 6, 1, 1, 101, 1, 1, 1, 2, 4, 1, 5, 0, 9, 1, 2, 0, 2, 1, 1, 4, 1, 144, 4, 2,
-        2, 4, 1, 32, 10, 40, 6, 2, 4, 8, 1, 9, 6, 2, 3, 46, 13, 1, 2, 0, 7, 1, 6, 1, 1, 82, 22, 2,
-        7, 1, 2, 1, 2, 122, 6, 3, 1, 1, 2, 1, 7, 1, 1, 72, 2, 3, 1, 1, 1, 0, 2, 11, 2, 52, 5, 5, 1,
-        1, 1, 23, 1, 0, 17, 6, 15, 0, 12, 3, 3, 0, 5, 59, 7, 9, 4, 0, 3, 40, 2, 0, 1, 63, 17, 64, 2,
-        1, 2, 0, 4, 1, 7, 1, 2, 0, 2, 1, 4, 0, 46, 2, 23, 0, 3, 9, 16, 2, 7, 30, 4, 148, 3, 0, 55,
-        4, 50, 8, 1, 14, 1, 22, 5, 1, 15, 0, 7, 1, 17, 2, 7, 1, 2, 1, 5, 5, 62, 33, 1, 160, 14, 0,
-        1, 61, 4, 0, 5, 254, 2, 0, 7, 109, 8, 0, 5, 0, 1, 30, 96, 128, 240, 0,
+    static OFFSETS: [u8; 895] = [
+        168, 1, 4, 1, 1, 1, 4, 1, 2, 2, 0, 192, 4, 2, 4, 1, 9, 2, 1, 1, 251, 7, 207, 1, 5, 1, 49,
+        45, 1, 1, 1, 2, 1, 2, 1, 1, 44, 1, 11, 6, 10, 11, 1, 1, 35, 1, 10, 21, 16, 1, 101, 8, 1, 10,
+        1, 4, 33, 1, 1, 1, 30, 27, 91, 11, 58, 11, 4, 1, 2, 1, 24, 24, 43, 3, 44, 1, 7, 2, 5, 9, 41,
+        58, 55, 1, 1, 1, 4, 8, 4, 1, 3, 7, 10, 2, 13, 1, 15, 1, 58, 1, 4, 4, 8, 1, 20, 2, 26, 1, 2,
+        2, 57, 1, 4, 2, 4, 2, 2, 3, 3, 1, 30, 2, 3, 1, 11, 2, 57, 1, 4, 5, 1, 2, 4, 1, 20, 2, 22, 6,
+        1, 1, 58, 1, 2, 1, 1, 4, 8, 1, 7, 2, 11, 2, 30, 1, 61, 1, 12, 1, 50, 1, 3, 1, 55, 1, 1, 3,
+        5, 3, 1, 4, 7, 2, 11, 2, 29, 1, 58, 1, 2, 1, 6, 1, 5, 2, 20, 2, 28, 2, 57, 2, 4, 4, 8, 1,
+        20, 2, 29, 1, 72, 1, 7, 3, 1, 1, 90, 1, 2, 7, 11, 9, 98, 1, 2, 9, 9, 1, 1, 7, 73, 2, 27, 1,
+        1, 1, 1, 1, 55, 14, 1, 5, 1, 2, 5, 11, 1, 36, 9, 1, 102, 4, 1, 6, 1, 2, 2, 2, 25, 2, 4, 3,
+        16, 4, 13, 1, 2, 2, 6, 1, 15, 1, 94, 1, 0, 3, 0, 3, 29, 2, 30, 2, 30, 2, 64, 2, 1, 7, 8, 1,
+        2, 11, 3, 1, 5, 1, 45, 5, 51, 1, 65, 2, 34, 1, 118, 3, 4, 2, 9, 1, 6, 3, 219, 2, 2, 1, 58,
+        1, 1, 7, 1, 1, 1, 1, 2, 8, 6, 10, 2, 1, 39, 1, 8, 31, 49, 4, 48, 1, 1, 5, 1, 1, 5, 1, 40, 9,
+        12, 2, 32, 4, 2, 2, 1, 3, 56, 1, 1, 2, 3, 1, 1, 3, 58, 8, 2, 2, 64, 6, 82, 3, 1, 13, 1, 7,
+        4, 1, 6, 1, 3, 2, 50, 63, 13, 1, 34, 101, 0, 1, 1, 3, 11, 3, 13, 3, 13, 3, 13, 2, 12, 5, 8,
+        2, 10, 1, 2, 1, 2, 5, 49, 5, 1, 10, 1, 1, 13, 1, 16, 13, 51, 33, 0, 2, 113, 3, 125, 1, 15,
+        1, 96, 32, 47, 1, 0, 1, 36, 4, 3, 5, 5, 1, 93, 6, 93, 3, 0, 1, 0, 6, 0, 1, 98, 4, 1, 10, 1,
+        1, 28, 4, 80, 2, 14, 34, 78, 1, 23, 3, 103, 3, 3, 2, 8, 1, 3, 1, 4, 1, 25, 2, 5, 1, 151, 2,
+        26, 18, 13, 1, 38, 8, 25, 11, 46, 3, 48, 1, 2, 4, 2, 2, 17, 1, 21, 2, 66, 6, 2, 2, 2, 2, 12,
+        1, 8, 1, 35, 1, 11, 1, 51, 1, 1, 3, 2, 2, 5, 2, 1, 1, 27, 1, 14, 2, 5, 2, 1, 1, 100, 5, 9,
+        3, 121, 1, 2, 1, 4, 1, 0, 1, 147, 17, 0, 16, 3, 1, 12, 16, 34, 1, 2, 1, 169, 1, 7, 1, 6, 1,
+        11, 1, 35, 1, 1, 1, 47, 1, 45, 2, 67, 1, 21, 3, 0, 1, 226, 1, 149, 5, 0, 6, 1, 42, 1, 9, 0,
+        3, 1, 2, 5, 4, 40, 3, 4, 1, 165, 2, 0, 4, 38, 1, 26, 5, 1, 1, 0, 2, 79, 4, 70, 11, 49, 4,
+        123, 1, 54, 15, 41, 1, 2, 2, 10, 3, 49, 4, 2, 2, 2, 1, 4, 1, 10, 1, 50, 3, 36, 5, 1, 8, 62,
+        1, 12, 2, 52, 9, 10, 4, 2, 1, 95, 3, 2, 1, 1, 2, 6, 1, 2, 1, 157, 1, 3, 8, 21, 2, 57, 2, 3,
+        1, 37, 7, 3, 5, 70, 6, 13, 1, 1, 1, 1, 1, 14, 2, 85, 8, 2, 3, 1, 1, 23, 1, 84, 6, 1, 1, 4,
+        2, 1, 2, 238, 4, 6, 2, 1, 2, 27, 2, 85, 8, 2, 1, 1, 2, 106, 1, 1, 1, 2, 6, 1, 1, 101, 1, 1,
+        1, 2, 4, 1, 5, 0, 9, 1, 2, 0, 2, 1, 1, 4, 1, 144, 4, 2, 2, 4, 1, 32, 10, 40, 6, 2, 4, 8, 1,
+        9, 6, 2, 3, 46, 13, 1, 2, 0, 7, 1, 6, 1, 1, 82, 22, 2, 7, 1, 2, 1, 2, 122, 6, 3, 1, 1, 2, 1,
+        7, 1, 1, 72, 2, 3, 1, 1, 1, 0, 2, 11, 2, 52, 5, 5, 1, 1, 1, 23, 1, 0, 17, 6, 15, 0, 12, 3,
+        3, 0, 5, 59, 7, 9, 4, 0, 3, 40, 2, 0, 1, 63, 17, 64, 2, 1, 2, 0, 4, 1, 7, 1, 2, 0, 2, 1, 4,
+        0, 46, 2, 23, 0, 3, 9, 16, 2, 7, 30, 4, 148, 3, 0, 55, 4, 50, 8, 1, 14, 1, 22, 5, 1, 15, 0,
+        7, 1, 17, 2, 7, 1, 2, 1, 5, 5, 62, 33, 1, 160, 14, 0, 1, 61, 4, 0, 5, 254, 2, 0, 7, 109, 8,
+        0, 5, 0, 1, 30, 96, 128, 240, 0,
     ];
+    #[inline]
     pub fn lookup(c: char) -> bool {
+        debug_assert!(!c.is_ascii());
+        (c as u32) >= 0xa8 && lookup_slow(c)
+    }
+
+    #[inline(never)]
+    fn lookup_slow(c: char) -> bool {
         const {
             assert!(SHORT_OFFSET_RUNS.last().unwrap().0 > char::MAX as u32);
             let mut i = 0;
@@ -329,33 +342,40 @@ pub mod cased {
     use super::ShortOffsetRunHeader;
 
     static SHORT_OFFSET_RUNS: [ShortOffsetRunHeader; 22] = [
-        ShortOffsetRunHeader::new(0, 4256), ShortOffsetRunHeader::new(55, 5024),
-        ShortOffsetRunHeader::new(65, 7296), ShortOffsetRunHeader::new(69, 7958),
-        ShortOffsetRunHeader::new(78, 9398), ShortOffsetRunHeader::new(153, 11264),
-        ShortOffsetRunHeader::new(155, 42560), ShortOffsetRunHeader::new(167, 43824),
-        ShortOffsetRunHeader::new(187, 64256), ShortOffsetRunHeader::new(193, 65313),
-        ShortOffsetRunHeader::new(197, 66560), ShortOffsetRunHeader::new(201, 67456),
-        ShortOffsetRunHeader::new(223, 68736), ShortOffsetRunHeader::new(231, 71840),
-        ShortOffsetRunHeader::new(239, 93760), ShortOffsetRunHeader::new(241, 119808),
-        ShortOffsetRunHeader::new(243, 120486), ShortOffsetRunHeader::new(280, 122624),
-        ShortOffsetRunHeader::new(303, 122928), ShortOffsetRunHeader::new(309, 125184),
-        ShortOffsetRunHeader::new(311, 127280), ShortOffsetRunHeader::new(313, 1241482),
+        ShortOffsetRunHeader::new(0, 4256), ShortOffsetRunHeader::new(51, 5024),
+        ShortOffsetRunHeader::new(61, 7296), ShortOffsetRunHeader::new(65, 7958),
+        ShortOffsetRunHeader::new(74, 9398), ShortOffsetRunHeader::new(149, 11264),
+        ShortOffsetRunHeader::new(151, 42560), ShortOffsetRunHeader::new(163, 43824),
+        ShortOffsetRunHeader::new(183, 64256), ShortOffsetRunHeader::new(189, 65313),
+        ShortOffsetRunHeader::new(193, 66560), ShortOffsetRunHeader::new(197, 67456),
+        ShortOffsetRunHeader::new(219, 68736), ShortOffsetRunHeader::new(227, 71840),
+        ShortOffsetRunHeader::new(235, 93760), ShortOffsetRunHeader::new(237, 119808),
+        ShortOffsetRunHeader::new(239, 120486), ShortOffsetRunHeader::new(276, 122624),
+        ShortOffsetRunHeader::new(299, 122928), ShortOffsetRunHeader::new(305, 125184),
+        ShortOffsetRunHeader::new(307, 127280), ShortOffsetRunHeader::new(309, 1241482),
     ];
-    static OFFSETS: [u8; 319] = [
-        65, 26, 6, 26, 47, 1, 10, 1, 4, 1, 5, 23, 1, 31, 1, 195, 1, 4, 4, 208, 1, 36, 7, 2, 30, 5,
-        96, 1, 42, 4, 2, 2, 2, 4, 1, 1, 6, 1, 1, 3, 1, 1, 1, 20, 1, 83, 1, 139, 8, 166, 1, 38, 9,
-        41, 0, 38, 1, 1, 5, 1, 2, 43, 1, 4, 0, 86, 2, 6, 0, 11, 5, 43, 2, 3, 64, 192, 64, 0, 2, 6,
-        2, 38, 2, 6, 2, 8, 1, 1, 1, 1, 1, 1, 1, 31, 2, 53, 1, 7, 1, 1, 3, 3, 1, 7, 3, 4, 2, 6, 4,
-        13, 5, 3, 1, 7, 116, 1, 13, 1, 16, 13, 101, 1, 4, 1, 2, 10, 1, 1, 3, 5, 6, 1, 1, 1, 1, 1, 1,
-        4, 1, 6, 4, 1, 2, 4, 5, 5, 4, 1, 17, 32, 3, 2, 0, 52, 0, 229, 6, 4, 3, 2, 12, 38, 1, 1, 5,
-        1, 0, 46, 18, 30, 132, 102, 3, 4, 1, 62, 2, 2, 1, 1, 1, 8, 21, 5, 1, 3, 0, 43, 1, 14, 6, 80,
-        0, 7, 12, 5, 0, 26, 6, 26, 0, 80, 96, 36, 4, 36, 116, 11, 1, 15, 1, 7, 1, 2, 1, 11, 1, 15,
-        1, 7, 1, 2, 0, 1, 2, 3, 1, 42, 1, 9, 0, 51, 13, 51, 93, 22, 10, 22, 0, 64, 0, 64, 0, 85, 1,
-        71, 1, 2, 2, 1, 2, 2, 2, 4, 1, 12, 1, 1, 1, 7, 1, 65, 1, 4, 2, 8, 1, 7, 1, 28, 1, 4, 1, 5,
-        1, 1, 3, 7, 1, 0, 2, 25, 1, 25, 1, 31, 1, 25, 1, 31, 1, 25, 1, 31, 1, 25, 1, 31, 1, 25, 1,
-        8, 0, 10, 1, 20, 6, 6, 0, 62, 0, 68, 0, 26, 6, 26, 6, 26, 0,
+    static OFFSETS: [u8; 315] = [
+        170, 1, 10, 1, 4, 1, 5, 23, 1, 31, 1, 195, 1, 4, 4, 208, 1, 36, 7, 2, 30, 5, 96, 1, 42, 4,
+        2, 2, 2, 4, 1, 1, 6, 1, 1, 3, 1, 1, 1, 20, 1, 83, 1, 139, 8, 166, 1, 38, 9, 41, 0, 38, 1, 1,
+        5, 1, 2, 43, 1, 4, 0, 86, 2, 6, 0, 11, 5, 43, 2, 3, 64, 192, 64, 0, 2, 6, 2, 38, 2, 6, 2, 8,
+        1, 1, 1, 1, 1, 1, 1, 31, 2, 53, 1, 7, 1, 1, 3, 3, 1, 7, 3, 4, 2, 6, 4, 13, 5, 3, 1, 7, 116,
+        1, 13, 1, 16, 13, 101, 1, 4, 1, 2, 10, 1, 1, 3, 5, 6, 1, 1, 1, 1, 1, 1, 4, 1, 6, 4, 1, 2, 4,
+        5, 5, 4, 1, 17, 32, 3, 2, 0, 52, 0, 229, 6, 4, 3, 2, 12, 38, 1, 1, 5, 1, 0, 46, 18, 30, 132,
+        102, 3, 4, 1, 62, 2, 2, 1, 1, 1, 8, 21, 5, 1, 3, 0, 43, 1, 14, 6, 80, 0, 7, 12, 5, 0, 26, 6,
+        26, 0, 80, 96, 36, 4, 36, 116, 11, 1, 15, 1, 7, 1, 2, 1, 11, 1, 15, 1, 7, 1, 2, 0, 1, 2, 3,
+        1, 42, 1, 9, 0, 51, 13, 51, 93, 22, 10, 22, 0, 64, 0, 64, 0, 85, 1, 71, 1, 2, 2, 1, 2, 2, 2,
+        4, 1, 12, 1, 1, 1, 7, 1, 65, 1, 4, 2, 8, 1, 7, 1, 28, 1, 4, 1, 5, 1, 1, 3, 7, 1, 0, 2, 25,
+        1, 25, 1, 31, 1, 25, 1, 31, 1, 25, 1, 31, 1, 25, 1, 31, 1, 25, 1, 8, 0, 10, 1, 20, 6, 6, 0,
+        62, 0, 68, 0, 26, 6, 26, 6, 26, 0,
     ];
+    #[inline]
     pub fn lookup(c: char) -> bool {
+        debug_assert!(!c.is_ascii());
+        (c as u32) >= 0xaa && lookup_slow(c)
+    }
+
+    #[inline(never)]
+    fn lookup_slow(c: char) -> bool {
         const {
             assert!(SHORT_OFFSET_RUNS.last().unwrap().0 > char::MAX as u32);
             let mut i = 0;
@@ -424,6 +444,7 @@ pub mod grapheme_extend {
     ];
     #[inline]
     pub fn lookup(c: char) -> bool {
+        debug_assert!(!c.is_ascii());
         (c as u32) >= 0x300 && lookup_slow(c)
     }
 
@@ -446,7 +467,7 @@ pub mod grapheme_extend {
 #[rustfmt::skip]
 pub mod lowercase {
     static BITSET_CHUNKS_MAP: [u8; 123] = [
-        14, 17, 0, 0, 9, 0, 0, 12, 13, 10, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        12, 17, 0, 0, 9, 0, 0, 13, 14, 10, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 4, 1, 0, 15, 0, 8, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19, 0,
@@ -458,37 +479,37 @@ pub mod lowercase {
         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 14, 56, 0],
         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 0, 0, 0],
         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 44, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0],
         [0, 0, 0, 0, 0, 0, 0, 0, 0, 67, 43, 0, 52, 48, 50, 33],
-        [0, 0, 0, 0, 10, 57, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 9, 57, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
         [0, 0, 0, 3, 0, 16, 58, 0, 0, 0, 0, 0, 0, 0, 0, 0],
         [0, 0, 0, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 27],
         [0, 0, 0, 62, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
         [0, 0, 0, 71, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        [0, 0, 34, 17, 23, 53, 54, 49, 47, 7, 35, 42, 0, 28, 12, 31],
         [0, 0, 46, 0, 56, 56, 56, 0, 22, 22, 69, 22, 36, 25, 24, 37],
         [0, 5, 70, 0, 29, 15, 75, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-        [0, 66, 34, 17, 23, 53, 54, 49, 47, 8, 35, 42, 0, 28, 13, 31],
-        [11, 60, 0, 6, 0, 0, 30, 0, 0, 0, 0, 0, 0, 0, 32, 0],
+        [10, 60, 0, 6, 0, 0, 30, 0, 0, 0, 0, 0, 0, 0, 32, 0],
         [16, 26, 22, 38, 39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-        [16, 51, 2, 21, 68, 9, 59, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        [16, 51, 2, 21, 68, 8, 59, 0, 0, 0, 0, 0, 0, 0, 0, 0],
         [16, 72, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-        [65, 41, 55, 12, 77, 63, 18, 1, 7, 64, 76, 20, 73, 74, 4, 45],
+        [65, 41, 55, 11, 66, 63, 18, 13, 1, 64, 76, 20, 73, 74, 4, 45],
     ];
     static BITSET_CANONICAL: [u64; 56] = [
         0b0000000000000000000000000000000000000000000000000000000000000000,
-        0b1111111111111111110000000000000000000000000011111111111111111111,
+        0b0000111111111111111111111111110000000000000000000000000011111111,
         0b1010101010101010101010101010101010101010101010101010100000000010,
         0b0000000000000111111111111111111111111111111111111111111111111111,
         0b1111111111111111111111000000000000000000000000001111110111111111,
         0b1000000000000010000000000000000000000000000000000000000000000000,
         0b0000111111111111111111111111111111111111000000000000000000000000,
-        0b0000111111111111111111111111110000000000000000000000000011111111,
         0b1111111111111111111111111111111111111111111111111010101010000101,
         0b1111111111111111111111111111111100000000000000000000000000000000,
         0b1111111111111111111111111111110000000000000000000000000000000000,
         0b1111111111111111111111110000000000000000000000000000000000000000,
         0b1111111111111111111111000000000000000000000000001111111111101111,
         0b1111111111111111111100000000000000000000000000010000000000000000,
+        0b1111111111111111110000000000000000000000000011111111111111111111,
         0b1111111111111111000000111111111111110111111111111111111111111111,
         0b1111111111111111000000000000000000000000000000000100001111000000,
         0b1111111111111111000000000000000000000000000000000000000000000000,
@@ -532,13 +553,15 @@ pub mod lowercase {
         0b1110011001010001001011010010101001001110001001000011000100101001,
         0b1110101111000000000000000000000000001111111111111111111111111100,
     ];
-    static BITSET_MAPPING: [(u8, u8); 22] = [
-        (0, 64), (1, 188), (1, 186), (1, 183), (1, 176), (1, 109), (1, 124), (1, 126), (1, 66),
-        (1, 70), (1, 77), (2, 146), (2, 144), (2, 83), (3, 93), (3, 147), (3, 133), (4, 12), (4, 6),
-        (5, 187), (6, 78), (7, 132),
+    static BITSET_MAPPING: [(u8, u8); 21] = [
+        (0, 64), (1, 184), (1, 182), (1, 179), (1, 172), (1, 161), (1, 146), (1, 144), (1, 140),
+        (1, 136), (1, 132), (2, 146), (2, 144), (2, 83), (3, 93), (3, 147), (3, 133), (4, 12),
+        (4, 6), (5, 187), (6, 78),
     ];
 
     pub const fn lookup(c: char) -> bool {
+        debug_assert!(!c.is_ascii());
+        (c as u32) >= 0xaa &&
         super::bitset_search(
             c as u32,
             &BITSET_CHUNKS_MAP,
@@ -554,43 +577,50 @@ pub mod n {
     use super::ShortOffsetRunHeader;
 
     static SHORT_OFFSET_RUNS: [ShortOffsetRunHeader; 42] = [
-        ShortOffsetRunHeader::new(0, 1632), ShortOffsetRunHeader::new(9, 2406),
-        ShortOffsetRunHeader::new(15, 4160), ShortOffsetRunHeader::new(49, 4969),
-        ShortOffsetRunHeader::new(53, 5870), ShortOffsetRunHeader::new(55, 6470),
-        ShortOffsetRunHeader::new(63, 8304), ShortOffsetRunHeader::new(79, 9312),
-        ShortOffsetRunHeader::new(89, 10102), ShortOffsetRunHeader::new(93, 11517),
-        ShortOffsetRunHeader::new(95, 12295), ShortOffsetRunHeader::new(97, 12690),
-        ShortOffsetRunHeader::new(103, 42528), ShortOffsetRunHeader::new(115, 43056),
-        ShortOffsetRunHeader::new(119, 44016), ShortOffsetRunHeader::new(131, 65296),
-        ShortOffsetRunHeader::new(133, 65799), ShortOffsetRunHeader::new(135, 66273),
-        ShortOffsetRunHeader::new(141, 67672), ShortOffsetRunHeader::new(153, 68858),
-        ShortOffsetRunHeader::new(183, 69216), ShortOffsetRunHeader::new(189, 70736),
-        ShortOffsetRunHeader::new(209, 71248), ShortOffsetRunHeader::new(213, 71904),
-        ShortOffsetRunHeader::new(221, 72688), ShortOffsetRunHeader::new(225, 73552),
-        ShortOffsetRunHeader::new(233, 74752), ShortOffsetRunHeader::new(237, 90416),
-        ShortOffsetRunHeader::new(239, 92768), ShortOffsetRunHeader::new(241, 93552),
-        ShortOffsetRunHeader::new(249, 93824), ShortOffsetRunHeader::new(251, 118000),
-        ShortOffsetRunHeader::new(253, 119488), ShortOffsetRunHeader::new(255, 120782),
-        ShortOffsetRunHeader::new(261, 123200), ShortOffsetRunHeader::new(263, 123632),
-        ShortOffsetRunHeader::new(265, 124144), ShortOffsetRunHeader::new(267, 125127),
-        ShortOffsetRunHeader::new(271, 126065), ShortOffsetRunHeader::new(275, 127232),
-        ShortOffsetRunHeader::new(285, 130032), ShortOffsetRunHeader::new(287, 1244154),
+        ShortOffsetRunHeader::new(0, 1632), ShortOffsetRunHeader::new(7, 2406),
+        ShortOffsetRunHeader::new(13, 4160), ShortOffsetRunHeader::new(47, 4969),
+        ShortOffsetRunHeader::new(51, 5870), ShortOffsetRunHeader::new(53, 6470),
+        ShortOffsetRunHeader::new(61, 8304), ShortOffsetRunHeader::new(77, 9312),
+        ShortOffsetRunHeader::new(87, 10102), ShortOffsetRunHeader::new(91, 11517),
+        ShortOffsetRunHeader::new(93, 12295), ShortOffsetRunHeader::new(95, 12690),
+        ShortOffsetRunHeader::new(101, 42528), ShortOffsetRunHeader::new(113, 43056),
+        ShortOffsetRunHeader::new(117, 44016), ShortOffsetRunHeader::new(129, 65296),
+        ShortOffsetRunHeader::new(131, 65799), ShortOffsetRunHeader::new(133, 66273),
+        ShortOffsetRunHeader::new(139, 67672), ShortOffsetRunHeader::new(151, 68858),
+        ShortOffsetRunHeader::new(181, 69216), ShortOffsetRunHeader::new(187, 70736),
+        ShortOffsetRunHeader::new(207, 71248), ShortOffsetRunHeader::new(211, 71904),
+        ShortOffsetRunHeader::new(219, 72688), ShortOffsetRunHeader::new(223, 73552),
+        ShortOffsetRunHeader::new(231, 74752), ShortOffsetRunHeader::new(235, 90416),
+        ShortOffsetRunHeader::new(237, 92768), ShortOffsetRunHeader::new(239, 93552),
+        ShortOffsetRunHeader::new(247, 93824), ShortOffsetRunHeader::new(249, 118000),
+        ShortOffsetRunHeader::new(251, 119488), ShortOffsetRunHeader::new(253, 120782),
+        ShortOffsetRunHeader::new(259, 123200), ShortOffsetRunHeader::new(261, 123632),
+        ShortOffsetRunHeader::new(263, 124144), ShortOffsetRunHeader::new(265, 125127),
+        ShortOffsetRunHeader::new(269, 126065), ShortOffsetRunHeader::new(273, 127232),
+        ShortOffsetRunHeader::new(283, 130032), ShortOffsetRunHeader::new(285, 1244154),
     ];
-    static OFFSETS: [u8; 289] = [
-        48, 10, 120, 2, 5, 1, 2, 3, 0, 10, 134, 10, 198, 10, 0, 10, 118, 10, 4, 6, 108, 10, 118,
-        10, 118, 10, 2, 6, 110, 13, 115, 10, 8, 7, 103, 10, 104, 7, 7, 19, 109, 10, 96, 10, 118, 10,
-        70, 20, 0, 10, 70, 10, 0, 20, 0, 3, 239, 10, 6, 10, 22, 10, 0, 10, 128, 11, 165, 10, 6, 10,
-        182, 10, 86, 10, 134, 10, 6, 10, 0, 1, 3, 6, 6, 10, 198, 51, 2, 5, 0, 60, 78, 22, 0, 30, 0,
-        1, 0, 1, 25, 9, 14, 3, 0, 4, 138, 10, 30, 8, 1, 15, 32, 10, 39, 15, 0, 10, 188, 10, 0, 6,
-        154, 10, 38, 10, 198, 10, 22, 10, 86, 10, 0, 10, 0, 10, 0, 45, 12, 57, 17, 2, 0, 27, 36, 4,
-        29, 1, 8, 1, 134, 5, 202, 10, 0, 8, 25, 7, 39, 9, 75, 5, 22, 6, 160, 2, 2, 16, 2, 46, 64, 9,
-        52, 2, 30, 3, 75, 5, 104, 8, 24, 8, 41, 7, 0, 6, 48, 10, 6, 10, 0, 31, 158, 10, 42, 4, 112,
-        7, 134, 30, 128, 10, 60, 10, 144, 10, 7, 20, 251, 10, 0, 10, 118, 10, 0, 10, 102, 10, 6, 20,
-        76, 12, 0, 19, 93, 10, 0, 10, 86, 29, 227, 10, 70, 10, 0, 10, 102, 21, 0, 111, 0, 10, 0, 10,
-        86, 10, 134, 10, 1, 7, 0, 10, 0, 23, 0, 10, 0, 20, 12, 20, 108, 25, 0, 50, 0, 10, 0, 10, 0,
-        10, 247, 10, 0, 9, 128, 10, 0, 59, 1, 3, 1, 4, 76, 45, 1, 15, 0, 13, 0, 10, 0,
+    static OFFSETS: [u8; 287] = [
+        178, 2, 5, 1, 2, 3, 0, 10, 134, 10, 198, 10, 0, 10, 118, 10, 4, 6, 108, 10, 118, 10, 118,
+        10, 2, 6, 110, 13, 115, 10, 8, 7, 103, 10, 104, 7, 7, 19, 109, 10, 96, 10, 118, 10, 70, 20,
+        0, 10, 70, 10, 0, 20, 0, 3, 239, 10, 6, 10, 22, 10, 0, 10, 128, 11, 165, 10, 6, 10, 182, 10,
+        86, 10, 134, 10, 6, 10, 0, 1, 3, 6, 6, 10, 198, 51, 2, 5, 0, 60, 78, 22, 0, 30, 0, 1, 0, 1,
+        25, 9, 14, 3, 0, 4, 138, 10, 30, 8, 1, 15, 32, 10, 39, 15, 0, 10, 188, 10, 0, 6, 154, 10,
+        38, 10, 198, 10, 22, 10, 86, 10, 0, 10, 0, 10, 0, 45, 12, 57, 17, 2, 0, 27, 36, 4, 29, 1, 8,
+        1, 134, 5, 202, 10, 0, 8, 25, 7, 39, 9, 75, 5, 22, 6, 160, 2, 2, 16, 2, 46, 64, 9, 52, 2,
+        30, 3, 75, 5, 104, 8, 24, 8, 41, 7, 0, 6, 48, 10, 6, 10, 0, 31, 158, 10, 42, 4, 112, 7, 134,
+        30, 128, 10, 60, 10, 144, 10, 7, 20, 251, 10, 0, 10, 118, 10, 0, 10, 102, 10, 6, 20, 76, 12,
+        0, 19, 93, 10, 0, 10, 86, 29, 227, 10, 70, 10, 0, 10, 102, 21, 0, 111, 0, 10, 0, 10, 86, 10,
+        134, 10, 1, 7, 0, 10, 0, 23, 0, 10, 0, 20, 12, 20, 108, 25, 0, 50, 0, 10, 0, 10, 0, 10, 247,
+        10, 0, 9, 128, 10, 0, 59, 1, 3, 1, 4, 76, 45, 1, 15, 0, 13, 0, 10, 0,
     ];
+    #[inline]
     pub fn lookup(c: char) -> bool {
+        debug_assert!(!c.is_ascii());
+        (c as u32) >= 0xb2 && lookup_slow(c)
+    }
+
+    #[inline(never)]
+    fn lookup_slow(c: char) -> bool {
         const {
             assert!(SHORT_OFFSET_RUNS.last().unwrap().0 > char::MAX as u32);
             let mut i = 0;
@@ -608,34 +638,34 @@ pub mod n {
 #[rustfmt::skip]
 pub mod uppercase {
     static BITSET_CHUNKS_MAP: [u8; 125] = [
-        12, 15, 6, 6, 0, 6, 6, 2, 4, 11, 6, 16, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-        6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 8, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-        6, 6, 6, 5, 6, 14, 6, 10, 6, 6, 1, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-        6, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 13, 6, 6,
-        6, 6, 9, 6, 3,
+        3, 14, 6, 6, 0, 6, 6, 2, 5, 12, 6, 15, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+        6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 9, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+        6, 6, 6, 7, 6, 13, 6, 11, 6, 6, 1, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+        6, 8, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 16, 6, 6,
+        6, 6, 10, 6, 4,
     ];
     static BITSET_INDEX_CHUNKS: [[u8; 16]; 17] = [
-        [44, 44, 5, 35, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 5, 1],
+        [44, 44, 5, 35, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 5, 0],
         [44, 44, 5, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44],
-        [44, 44, 40, 44, 44, 44, 44, 44, 17, 17, 63, 17, 43, 29, 24, 23],
+        [44, 44, 40, 44, 44, 44, 44, 44, 17, 17, 62, 17, 43, 29, 24, 23],
+        [44, 44, 44, 32, 36, 21, 22, 15, 13, 34, 44, 44, 44, 11, 30, 39],
         [44, 44, 44, 44, 9, 8, 45, 44, 44, 44, 44, 44, 44, 44, 44, 44],
-        [44, 44, 44, 44, 37, 28, 67, 44, 44, 44, 44, 44, 44, 44, 44, 44],
-        [44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 0, 44, 44, 44],
+        [44, 44, 44, 44, 37, 28, 66, 44, 44, 44, 44, 44, 44, 44, 44, 44],
         [44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44],
-        [44, 44, 44, 44, 44, 44, 44, 44, 44, 55, 44, 44, 44, 44, 44, 44],
-        [44, 44, 44, 44, 44, 44, 44, 44, 44, 62, 61, 44, 20, 14, 16, 4],
-        [44, 44, 44, 44, 56, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44],
-        [44, 44, 59, 44, 44, 31, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44],
-        [44, 44, 60, 46, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44],
-        [44, 49, 44, 32, 36, 21, 22, 15, 13, 34, 44, 44, 44, 11, 30, 39],
-        [52, 54, 26, 50, 12, 7, 25, 51, 41, 53, 6, 3, 66, 65, 64, 68],
-        [57, 44, 9, 47, 44, 42, 33, 44, 44, 44, 44, 44, 44, 44, 44, 44],
-        [58, 19, 2, 18, 10, 48, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44],
-        [58, 38, 17, 27, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44],
+        [44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 57, 44, 44, 44],
+        [44, 44, 44, 44, 44, 44, 44, 44, 44, 49, 44, 44, 44, 44, 44, 44],
+        [44, 44, 44, 44, 44, 44, 44, 44, 44, 61, 60, 44, 20, 14, 16, 4],
+        [44, 44, 44, 44, 50, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44],
+        [44, 44, 53, 44, 44, 31, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44],
+        [44, 44, 54, 46, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44],
+        [51, 44, 9, 47, 44, 42, 33, 44, 44, 44, 44, 44, 44, 44, 44, 44],
+        [52, 19, 2, 18, 10, 48, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44],
+        [52, 38, 17, 27, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44],
+        [58, 1, 26, 55, 12, 7, 25, 56, 41, 59, 6, 3, 65, 64, 63, 67],
     ];
     static BITSET_CANONICAL: [u64; 44] = [
-        0b0000011111111111111111111111111000000000000000000000000000000000,
         0b0000000000111111111111111111111111111111111111111111111111111111,
+        0b1111111111111111111111110000000000000000000000000011111111111111,
         0b0101010101010101010101010101010101010101010101010101010000000001,
         0b0000011111111111111111111111110000000000000000000000000000000001,
         0b0000000000100000000000000000000000010101010000010001101011110101,
@@ -679,13 +709,15 @@ pub mod uppercase {
         0b1111011111111111000000000000000000000000000000000000000000000000,
         0b1111111100000000111111110000000000111111000000001111111100000000,
     ];
-    static BITSET_MAPPING: [(u8, u8); 25] = [
-        (0, 187), (0, 177), (0, 171), (0, 167), (0, 164), (0, 32), (0, 47), (0, 51), (0, 121),
-        (0, 117), (0, 109), (1, 150), (1, 148), (1, 142), (1, 134), (1, 131), (1, 64), (2, 164),
-        (2, 146), (2, 20), (3, 146), (3, 140), (3, 134), (4, 178), (4, 171),
+    static BITSET_MAPPING: [(u8, u8); 24] = [
+        (0, 182), (0, 74), (0, 166), (0, 162), (0, 159), (0, 150), (0, 148), (0, 142), (0, 134),
+        (0, 131), (0, 64), (1, 66), (1, 70), (1, 83), (1, 12), (1, 8), (2, 164), (2, 146), (2, 20),
+        (3, 146), (3, 140), (3, 134), (4, 178), (4, 171),
     ];
 
     pub const fn lookup(c: char) -> bool {
+        debug_assert!(!c.is_ascii());
+        (c as u32) >= 0xc0 &&
         super::bitset_search(
             c as u32,
             &BITSET_CHUNKS_MAP,
@@ -699,8 +731,8 @@ pub mod uppercase {
 #[rustfmt::skip]
 pub mod white_space {
     static WHITESPACE_MAP: [u8; 256] = [
-        2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -711,6 +743,7 @@ pub mod white_space {
     ];
     #[inline]
     pub const fn lookup(c: char) -> bool {
+        debug_assert!(!c.is_ascii());
         match c as u32 >> 8 {
             0 => WHITESPACE_MAP[c as usize & 0xff] & 1 != 0,
             22 => c as u32 == 0x1680,
diff --git a/src/tools/unicode-table-generator/src/cascading_map.rs b/src/tools/unicode-table-generator/src/cascading_map.rs
index 78a7bba320870..56e6401908dcf 100644
--- a/src/tools/unicode-table-generator/src/cascading_map.rs
+++ b/src/tools/unicode-table-generator/src/cascading_map.rs
@@ -64,6 +64,7 @@ impl RawEmitter {
 
         writeln!(&mut self.file, "#[inline]").unwrap();
         writeln!(&mut self.file, "pub const fn lookup(c: char) -> bool {{").unwrap();
+        writeln!(&mut self.file, "    debug_assert!(!c.is_ascii());").unwrap();
         writeln!(&mut self.file, "    match c as u32 >> 8 {{").unwrap();
         for arm in arms {
             writeln!(&mut self.file, "        {arm},").unwrap();
diff --git a/src/tools/unicode-table-generator/src/main.rs b/src/tools/unicode-table-generator/src/main.rs
index aa7d97f7f3d7c..ded9205ffc4b9 100644
--- a/src/tools/unicode-table-generator/src/main.rs
+++ b/src/tools/unicode-table-generator/src/main.rs
@@ -195,6 +195,7 @@ fn load_data() -> UnicodeData {
                 .into_iter()
                 .flatten()
                 .flat_map(|cp| cp.scalar())
+                .filter(|c| !c.is_ascii())
                 .map(u32::from)
                 .collect::<Vec<_>>();
             (prop, ranges_from_set(&codepoints))
diff --git a/src/tools/unicode-table-generator/src/raw_emitter.rs b/src/tools/unicode-table-generator/src/raw_emitter.rs
index 03ed9499e26c5..297965615c1a5 100644
--- a/src/tools/unicode-table-generator/src/raw_emitter.rs
+++ b/src/tools/unicode-table-generator/src/raw_emitter.rs
@@ -98,6 +98,7 @@ impl RawEmitter {
         self.blank_line();
 
         writeln!(&mut self.file, "pub const fn lookup(c: char) -> bool {{").unwrap();
+        writeln!(&mut self.file, "    debug_assert!(!c.is_ascii());").unwrap();
         if first_code_point > 0x7f {
             writeln!(&mut self.file, "    (c as u32) >= {first_code_point:#04x} &&").unwrap();
         }
diff --git a/src/tools/unicode-table-generator/src/skiplist.rs b/src/tools/unicode-table-generator/src/skiplist.rs
index 34c9802e122f6..660a8f342f7a7 100644
--- a/src/tools/unicode-table-generator/src/skiplist.rs
+++ b/src/tools/unicode-table-generator/src/skiplist.rs
@@ -99,6 +99,7 @@ impl RawEmitter {
         if first_code_point > 0x7f {
             writeln!(&mut self.file, "#[inline]").unwrap();
             writeln!(&mut self.file, "pub fn lookup(c: char) -> bool {{").unwrap();
+            writeln!(&mut self.file, "    debug_assert!(!c.is_ascii());").unwrap();
             writeln!(&mut self.file, "    (c as u32) >= {first_code_point:#04x} && lookup_slow(c)")
                 .unwrap();
             writeln!(&mut self.file, "}}").unwrap();
@@ -107,6 +108,7 @@ impl RawEmitter {
             writeln!(&mut self.file, "fn lookup_slow(c: char) -> bool {{").unwrap();
         } else {
             writeln!(&mut self.file, "pub fn lookup(c: char) -> bool {{").unwrap();
+            writeln!(&mut self.file, "    debug_assert!(!c.is_ascii());").unwrap();
         }
         writeln!(&mut self.file, "    const {{").unwrap();
         writeln!(

From f8180c3c429794b87968932166e8c8333f682956 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sun, 7 Sep 2025 15:17:25 +0200
Subject: [PATCH 0612/1889] extract to a separate file

---
 clippy_lints/src/declared_lints.rs   |   2 +-
 clippy_lints/src/lib.rs              |   2 +
 clippy_lints/src/misc.rs             | 118 +-------------------------
 clippy_lints/src/toplevel_ref_arg.rs | 120 +++++++++++++++++++++++++++
 4 files changed, 126 insertions(+), 116 deletions(-)
 create mode 100644 clippy_lints/src/toplevel_ref_arg.rs

diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index d0c7443a4a4b9..e610e655f1582 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -503,7 +503,6 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::min_ident_chars::MIN_IDENT_CHARS_INFO,
     crate::minmax::MIN_MAX_INFO,
     crate::misc::SHORT_CIRCUIT_STATEMENT_INFO,
-    crate::misc::TOPLEVEL_REF_ARG_INFO,
     crate::misc::USED_UNDERSCORE_BINDING_INFO,
     crate::misc::USED_UNDERSCORE_ITEMS_INFO,
     crate::misc_early::BUILTIN_TYPE_SHADOW_INFO,
@@ -706,6 +705,7 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::tests_outside_test_module::TESTS_OUTSIDE_TEST_MODULE_INFO,
     crate::to_digit_is_some::TO_DIGIT_IS_SOME_INFO,
     crate::to_string_trait_impl::TO_STRING_TRAIT_IMPL_INFO,
+    crate::toplevel_ref_arg::TOPLEVEL_REF_ARG_INFO,
     crate::trailing_empty_array::TRAILING_EMPTY_ARRAY_INFO,
     crate::trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS_INFO,
     crate::trait_bounds::TYPE_REPETITION_IN_BOUNDS_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index a89cf3fdc1eee..7590bec9e1e99 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -360,6 +360,7 @@ mod temporary_assignment;
 mod tests_outside_test_module;
 mod to_digit_is_some;
 mod to_string_trait_impl;
+mod toplevel_ref_arg;
 mod trailing_empty_array;
 mod trait_bounds;
 mod transmute;
@@ -831,5 +832,6 @@ pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Co
     store.register_late_pass(|_| Box::new(cloned_ref_to_slice_refs::ClonedRefToSliceRefs::new(conf)));
     store.register_late_pass(|_| Box::new(infallible_try_from::InfallibleTryFrom));
     store.register_late_pass(|_| Box::new(coerce_container_to_any::CoerceContainerToAny));
+    store.register_late_pass(|_| Box::new(toplevel_ref_arg::ToplevelRefArg));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 09ee6f7037c64..19e9910dfe9dd 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -1,57 +1,11 @@
-use clippy_utils::diagnostics::{span_lint_and_then, span_lint_hir, span_lint_hir_and_then};
-use clippy_utils::source::{snippet, snippet_with_context};
+use clippy_utils::diagnostics::{span_lint_and_then, span_lint_hir_and_then};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::{
-    SpanlessEq, fulfill_or_allowed, get_parent_expr, in_automatically_derived, is_lint_allowed, iter_input_pats,
-    last_path_segment,
-};
+use clippy_utils::{SpanlessEq, fulfill_or_allowed, get_parent_expr, in_automatically_derived, last_path_segment};
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
-use rustc_hir::intravisit::FnKind;
-use rustc_hir::{
-    BinOpKind, BindingMode, Body, ByRef, Expr, ExprKind, FnDecl, Mutability, PatKind, QPath, Stmt, StmtKind,
-};
+use rustc_hir::{BinOpKind, Expr, ExprKind, QPath, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::declare_lint_pass;
-use rustc_span::Span;
-use rustc_span::def_id::LocalDefId;
-
-use crate::ref_patterns::REF_PATTERNS;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for function arguments and let bindings denoted as
-    /// `ref`.
-    ///
-    /// ### Why is this bad?
-    /// The `ref` declaration makes the function take an owned
-    /// value, but turns the argument into a reference (which means that the value
-    /// is destroyed when exiting the function). This adds not much value: either
-    /// take a reference type, or take an owned value and create references in the
-    /// body.
-    ///
-    /// For let bindings, `let x = &foo;` is preferred over `let ref x = foo`. The
-    /// type of `x` is more obvious with the former.
-    ///
-    /// ### Known problems
-    /// If the argument is dereferenced within the function,
-    /// removing the `ref` will lead to errors. This can be fixed by removing the
-    /// dereferences, e.g., changing `*x` to `x` within the function.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// fn foo(ref _x: u8) {}
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// fn foo(_x: &u8) {}
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub TOPLEVEL_REF_ARG,
-    style,
-    "an entire binding declared as `ref`, in a function argument or a `let` statement"
-}
 
 declare_clippy_lint! {
     /// ### What it does
@@ -140,79 +94,13 @@ declare_clippy_lint! {
 }
 
 declare_lint_pass!(LintPass => [
-    TOPLEVEL_REF_ARG,
     USED_UNDERSCORE_BINDING,
     USED_UNDERSCORE_ITEMS,
     SHORT_CIRCUIT_STATEMENT,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for LintPass {
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'tcx>,
-        k: FnKind<'tcx>,
-        decl: &'tcx FnDecl<'_>,
-        body: &'tcx Body<'_>,
-        _: Span,
-        _: LocalDefId,
-    ) {
-        if !matches!(k, FnKind::Closure) {
-            for arg in iter_input_pats(decl, body) {
-                if let PatKind::Binding(BindingMode(ByRef::Yes(_), _), ..) = arg.pat.kind
-                    && is_lint_allowed(cx, REF_PATTERNS, arg.pat.hir_id)
-                    && !arg.span.in_external_macro(cx.tcx.sess.source_map())
-                {
-                    span_lint_hir(
-                        cx,
-                        TOPLEVEL_REF_ARG,
-                        arg.hir_id,
-                        arg.pat.span,
-                        "`ref` directly on a function parameter does not prevent taking ownership of the passed argument. \
-                        Consider using a reference type instead",
-                    );
-                }
-            }
-        }
-    }
-
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
-        if let StmtKind::Let(local) = stmt.kind
-            && let PatKind::Binding(BindingMode(ByRef::Yes(mutabl), _), .., name, None) = local.pat.kind
-            && let Some(init) = local.init
-            // Do not emit if clippy::ref_patterns is not allowed to avoid having two lints for the same issue.
-            && is_lint_allowed(cx, REF_PATTERNS, local.pat.hir_id)
-            && !stmt.span.in_external_macro(cx.tcx.sess.source_map())
-        {
-            let ctxt = local.span.ctxt();
-            let mut app = Applicability::MachineApplicable;
-            let sugg_init = Sugg::hir_with_context(cx, init, ctxt, "..", &mut app);
-            let (mutopt, initref) = if mutabl == Mutability::Mut {
-                ("mut ", sugg_init.mut_addr())
-            } else {
-                ("", sugg_init.addr())
-            };
-            let tyopt = if let Some(ty) = local.ty {
-                let ty_snip = snippet_with_context(cx, ty.span, ctxt, "_", &mut app).0;
-                format!(": &{mutopt}{ty_snip}")
-            } else {
-                String::new()
-            };
-            span_lint_hir_and_then(
-                cx,
-                TOPLEVEL_REF_ARG,
-                init.hir_id,
-                local.pat.span,
-                "`ref` on an entire `let` pattern is discouraged, take a reference with `&` instead",
-                |diag| {
-                    diag.span_suggestion(
-                        stmt.span,
-                        "try",
-                        format!("let {name}{tyopt} = {initref};", name = snippet(cx, name.span, ".."),),
-                        app,
-                    );
-                },
-            );
-        }
         if let StmtKind::Semi(expr) = stmt.kind
             && let ExprKind::Binary(binop, a, b) = &expr.kind
             && matches!(binop.node, BinOpKind::And | BinOpKind::Or)
diff --git a/clippy_lints/src/toplevel_ref_arg.rs b/clippy_lints/src/toplevel_ref_arg.rs
new file mode 100644
index 0000000000000..04da5efce5da2
--- /dev/null
+++ b/clippy_lints/src/toplevel_ref_arg.rs
@@ -0,0 +1,120 @@
+use clippy_utils::diagnostics::{span_lint_hir, span_lint_hir_and_then};
+use clippy_utils::source::{snippet, snippet_with_context};
+use clippy_utils::sugg::Sugg;
+use clippy_utils::{is_lint_allowed, iter_input_pats};
+use rustc_errors::Applicability;
+use rustc_hir::intravisit::FnKind;
+use rustc_hir::{BindingMode, Body, ByRef, FnDecl, Mutability, PatKind, Stmt, StmtKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::declare_lint_pass;
+use rustc_span::Span;
+use rustc_span::def_id::LocalDefId;
+
+use crate::ref_patterns::REF_PATTERNS;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for function arguments and let bindings denoted as
+    /// `ref`.
+    ///
+    /// ### Why is this bad?
+    /// The `ref` declaration makes the function take an owned
+    /// value, but turns the argument into a reference (which means that the value
+    /// is destroyed when exiting the function). This adds not much value: either
+    /// take a reference type, or take an owned value and create references in the
+    /// body.
+    ///
+    /// For let bindings, `let x = &foo;` is preferred over `let ref x = foo`. The
+    /// type of `x` is more obvious with the former.
+    ///
+    /// ### Known problems
+    /// If the argument is dereferenced within the function,
+    /// removing the `ref` will lead to errors. This can be fixed by removing the
+    /// dereferences, e.g., changing `*x` to `x` within the function.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// fn foo(ref _x: u8) {}
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// fn foo(_x: &u8) {}
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub TOPLEVEL_REF_ARG,
+    style,
+    "an entire binding declared as `ref`, in a function argument or a `let` statement"
+}
+
+declare_lint_pass!(ToplevelRefArg => [TOPLEVEL_REF_ARG]);
+
+impl<'tcx> LateLintPass<'tcx> for ToplevelRefArg {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        k: FnKind<'tcx>,
+        decl: &'tcx FnDecl<'_>,
+        body: &'tcx Body<'_>,
+        _: Span,
+        _: LocalDefId,
+    ) {
+        if !matches!(k, FnKind::Closure) {
+            for arg in iter_input_pats(decl, body) {
+                if let PatKind::Binding(BindingMode(ByRef::Yes(_), _), ..) = arg.pat.kind
+                    && is_lint_allowed(cx, REF_PATTERNS, arg.pat.hir_id)
+                    && !arg.span.in_external_macro(cx.tcx.sess.source_map())
+                {
+                    span_lint_hir(
+                        cx,
+                        TOPLEVEL_REF_ARG,
+                        arg.hir_id,
+                        arg.pat.span,
+                        "`ref` directly on a function parameter does not prevent taking ownership of the passed argument. \
+                            Consider using a reference type instead",
+                    );
+                }
+            }
+        }
+    }
+
+    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
+        if let StmtKind::Let(local) = stmt.kind
+            && let PatKind::Binding(BindingMode(ByRef::Yes(mutabl), _), .., name, None) = local.pat.kind
+            && let Some(init) = local.init
+            // Do not emit if clippy::ref_patterns is not allowed to avoid having two lints for the same issue.
+            && is_lint_allowed(cx, REF_PATTERNS, local.pat.hir_id)
+            && !stmt.span.in_external_macro(cx.tcx.sess.source_map())
+        {
+            let ctxt = local.span.ctxt();
+            let mut app = Applicability::MachineApplicable;
+            let sugg_init = Sugg::hir_with_context(cx, init, ctxt, "..", &mut app);
+            let (mutopt, initref) = if mutabl == Mutability::Mut {
+                ("mut ", sugg_init.mut_addr())
+            } else {
+                ("", sugg_init.addr())
+            };
+            let tyopt = if let Some(ty) = local.ty {
+                let ty_snip = snippet_with_context(cx, ty.span, ctxt, "_", &mut app).0;
+                format!(": &{mutopt}{ty_snip}")
+            } else {
+                String::new()
+            };
+            span_lint_hir_and_then(
+                cx,
+                TOPLEVEL_REF_ARG,
+                init.hir_id,
+                local.pat.span,
+                "`ref` on an entire `let` pattern is discouraged, take a reference with `&` instead",
+                |diag| {
+                    diag.span_suggestion(
+                        stmt.span,
+                        "try",
+                        format!("let {name}{tyopt} = {initref};", name = snippet(cx, name.span, ".."),),
+                        app,
+                    );
+                },
+            );
+        }
+    }
+}

From 2c27b586183779d2437ac758055bb21011c6551c Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sun, 7 Sep 2025 15:26:50 +0200
Subject: [PATCH 0613/1889] tiny clean-up

---
 clippy_lints/src/toplevel_ref_arg.rs | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/clippy_lints/src/toplevel_ref_arg.rs b/clippy_lints/src/toplevel_ref_arg.rs
index 04da5efce5da2..074b79263d377 100644
--- a/clippy_lints/src/toplevel_ref_arg.rs
+++ b/clippy_lints/src/toplevel_ref_arg.rs
@@ -89,10 +89,9 @@ impl<'tcx> LateLintPass<'tcx> for ToplevelRefArg {
             let ctxt = local.span.ctxt();
             let mut app = Applicability::MachineApplicable;
             let sugg_init = Sugg::hir_with_context(cx, init, ctxt, "..", &mut app);
-            let (mutopt, initref) = if mutabl == Mutability::Mut {
-                ("mut ", sugg_init.mut_addr())
-            } else {
-                ("", sugg_init.addr())
+            let (mutopt, initref) = match mutabl {
+                Mutability::Mut => ("mut ", sugg_init.mut_addr()),
+                Mutability::Not => ("", sugg_init.addr()),
             };
             let tyopt = if let Some(ty) = local.ty {
                 let ty_snip = snippet_with_context(cx, ty.span, ctxt, "_", &mut app).0;

From 4e7a068c9a155807b40a592a092d8bc77d33d47c Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Mon, 23 Jun 2025 16:05:09 +0000
Subject: [PATCH 0614/1889] Introduce PlaceContext::may_observe_address.

---
 compiler/rustc_middle/src/mir/visit.rs         | 18 ++++++++++++++++++
 .../rustc_mir_dataflow/src/value_analysis.rs   |  9 ++-------
 compiler/rustc_mir_transform/src/ssa.rs        |  4 +++-
 3 files changed, 23 insertions(+), 8 deletions(-)

diff --git a/compiler/rustc_middle/src/mir/visit.rs b/compiler/rustc_middle/src/mir/visit.rs
index 904d78d69b61c..b498b7b8912cc 100644
--- a/compiler/rustc_middle/src/mir/visit.rs
+++ b/compiler/rustc_middle/src/mir/visit.rs
@@ -1415,6 +1415,24 @@ impl PlaceContext {
         )
     }
 
+    /// Returns `true` if this place context may be used to know the address of the given place.
+    #[inline]
+    pub fn may_observe_address(self) -> bool {
+        matches!(
+            self,
+            PlaceContext::NonMutatingUse(
+                NonMutatingUseContext::SharedBorrow
+                    | NonMutatingUseContext::RawBorrow
+                    | NonMutatingUseContext::FakeBorrow
+            ) | PlaceContext::MutatingUse(
+                MutatingUseContext::Drop
+                    | MutatingUseContext::Borrow
+                    | MutatingUseContext::RawBorrow
+                    | MutatingUseContext::AsmOutput
+            )
+        )
+    }
+
     /// Returns `true` if this place context represents a storage live or storage dead marker.
     #[inline]
     pub fn is_storage_marker(self) -> bool {
diff --git a/compiler/rustc_mir_dataflow/src/value_analysis.rs b/compiler/rustc_mir_dataflow/src/value_analysis.rs
index 005e797313070..9a00831dc012b 100644
--- a/compiler/rustc_mir_dataflow/src/value_analysis.rs
+++ b/compiler/rustc_mir_dataflow/src/value_analysis.rs
@@ -6,7 +6,7 @@ use rustc_data_structures::fx::{FxHashMap, FxIndexSet, StdEntry};
 use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_index::IndexVec;
 use rustc_index::bit_set::DenseBitSet;
-use rustc_middle::mir::visit::{MutatingUseContext, PlaceContext, Visitor};
+use rustc_middle::mir::visit::{PlaceContext, Visitor};
 use rustc_middle::mir::*;
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use tracing::debug;
@@ -917,12 +917,7 @@ pub fn excluded_locals(body: &Body<'_>) -> DenseBitSet<Local> {
 
     impl<'tcx> Visitor<'tcx> for Collector {
         fn visit_place(&mut self, place: &Place<'tcx>, context: PlaceContext, _location: Location) {
-            if (context.is_borrow()
-                || context.is_address_of()
-                || context.is_drop()
-                || context == PlaceContext::MutatingUse(MutatingUseContext::AsmOutput))
-                && !place.is_indirect()
-            {
+            if context.may_observe_address() && !place.is_indirect() {
                 // A pointer to a place could be used to access other places with the same local,
                 // hence we have to exclude the local completely.
                 self.result.insert(place.local);
diff --git a/compiler/rustc_mir_transform/src/ssa.rs b/compiler/rustc_mir_transform/src/ssa.rs
index cd9a7f4a39dfe..73c249a3c8cdb 100644
--- a/compiler/rustc_mir_transform/src/ssa.rs
+++ b/compiler/rustc_mir_transform/src/ssa.rs
@@ -225,6 +225,9 @@ impl SsaVisitor<'_, '_> {
 
 impl<'tcx> Visitor<'tcx> for SsaVisitor<'_, 'tcx> {
     fn visit_local(&mut self, local: Local, ctxt: PlaceContext, loc: Location) {
+        if ctxt.may_observe_address() {
+            self.borrowed_locals.insert(local);
+        }
         match ctxt {
             PlaceContext::MutatingUse(MutatingUseContext::Projection)
             | PlaceContext::NonMutatingUse(NonMutatingUseContext::Projection) => bug!(),
@@ -237,7 +240,6 @@ impl<'tcx> Visitor<'tcx> for SsaVisitor<'_, 'tcx> {
             PlaceContext::NonMutatingUse(
                 NonMutatingUseContext::SharedBorrow | NonMutatingUseContext::FakeBorrow,
             ) => {
-                self.borrowed_locals.insert(local);
                 self.check_dominates(local, loc);
                 self.direct_uses[local] += 1;
             }

From 91241a1d255bde9d1bc3399c1c1f779bb17f1cfa Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Wed, 2 Jul 2025 22:09:46 +0000
Subject: [PATCH 0615/1889] Ensure indirect is first projection in
 try_as_place.

---
 compiler/rustc_mir_transform/src/gvn.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index 5a13394543b4a..7f005accc655f 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -1654,6 +1654,11 @@ impl<'tcx> VnState<'_, 'tcx> {
                 let place =
                     Place { local, projection: self.tcx.mk_place_elems(projection.as_slice()) };
                 return Some(place);
+            } else if projection.last() == Some(&PlaceElem::Deref) {
+                // `Deref` can only be the first projection in a place.
+                // If we are here, we failed to find a local, and we already have a `Deref`.
+                // Trying to add projections will only result in an ill-formed place.
+                return None;
             } else if let Value::Projection(pointer, proj) = *self.get(index)
                 && (allow_complex_projection || proj.is_stable_offset())
                 && let Some(proj) = self.try_as_place_elem(self.ty(index), proj, loc)

From 6da8094b1385b1647178a3ab9dab3c359ef1c38d Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Sun, 7 Sep 2025 21:49:55 +0800
Subject: [PATCH 0616/1889] Improve make::struct_ field_list whitespace

Example
---
**Before this PR**:

```rust
struct Variant{
    field: u32
}
```

**After this PR**:

```rust
struct Variant {
    field: u32
}
```
---
 .../extract_struct_from_enum_variant.rs       | 44 +++++++++----------
 .../src/handlers/json_is_not_rust.rs          | 24 +++++-----
 .../crates/syntax/src/ast/make.rs             |  7 ++-
 3 files changed, 39 insertions(+), 36 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs
index c56d0b3de5d6a..79a4c73c698d1 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -478,7 +478,7 @@ macro_rules! foo {
     };
 }
 
-struct TheVariant{ the_field: u8 }
+struct TheVariant { the_field: u8 }
 
 enum TheEnum {
     TheVariant(TheVariant),
@@ -502,7 +502,7 @@ enum Foo {
 }
 "#,
             r#"
-struct Bar{ node: Box<Foo> }
+struct Bar { node: Box<Foo> }
 
 enum Foo {
     Bar(Bar),
@@ -519,7 +519,7 @@ enum Foo {
 }
 "#,
             r#"
-struct Bar{ node: Box<Foo>, a: Arc<Box<Foo>> }
+struct Bar { node: Box<Foo>, a: Arc<Box<Foo>> }
 
 enum Foo {
     Bar(Bar),
@@ -560,7 +560,7 @@ enum A { One(One) }"#,
         check_assist(
             extract_struct_from_enum_variant,
             "enum A { $0One { foo: u32, bar: u32 } }",
-            r#"struct One{ foo: u32, bar: u32 }
+            r#"struct One { foo: u32, bar: u32 }
 
 enum A { One(One) }"#,
         );
@@ -571,7 +571,7 @@ enum A { One(One) }"#,
         check_assist(
             extract_struct_from_enum_variant,
             "enum A { $0One { foo: u32 } }",
-            r#"struct One{ foo: u32 }
+            r#"struct One { foo: u32 }
 
 enum A { One(One) }"#,
         );
@@ -582,7 +582,7 @@ enum A { One(One) }"#,
         check_assist(
             extract_struct_from_enum_variant,
             r"enum En<T> { Var { a: T$0 } }",
-            r#"struct Var<T>{ a: T }
+            r#"struct Var<T> { a: T }
 
 enum En<T> { Var(Var<T>) }"#,
         );
@@ -599,7 +599,7 @@ enum Enum { Variant{ field: u32$0 } }"#,
             r#"
 #[derive(Debug)]
 #[derive(Clone)]
-struct Variant{ field: u32 }
+struct Variant { field: u32 }
 
 #[derive(Debug)]
 #[derive(Clone)]
@@ -618,7 +618,7 @@ enum Enum {
     }
 }"#,
             r#"
-struct Variant{
+struct Variant {
     field: u32
 }
 
@@ -642,7 +642,7 @@ mod indenting {
 }"#,
             r#"
 mod indenting {
-    struct Variant{
+    struct Variant {
         field: u32
     }
 
@@ -668,7 +668,7 @@ enum A {
     }
 }"#,
             r#"
-struct One{
+struct One {
     // leading comment
     /// doc comment
     #[an_attr]
@@ -700,7 +700,7 @@ enum A {
     }
 }"#,
             r#"
-struct One{
+struct One {
     // comment
     /// doc
     #[attr]
@@ -747,7 +747,7 @@ enum A {
 /* comment */
 // other
 /// comment
-struct One{
+struct One {
     a: u32
 }
 
@@ -789,7 +789,7 @@ enum A {
             extract_struct_from_enum_variant,
             "enum A { $0One{ a: u32, pub(crate) b: u32, pub(super) c: u32, d: u32 } }",
             r#"
-struct One{ a: u32, pub(crate) b: u32, pub(super) c: u32, d: u32 }
+struct One { a: u32, pub(crate) b: u32, pub(super) c: u32, d: u32 }
 
 enum A { One(One) }"#,
         );
@@ -850,7 +850,7 @@ pub enum A { One(One) }"#,
             extract_struct_from_enum_variant,
             "pub(in something) enum A { $0One{ a: u32, b: u32 } }",
             r#"
-pub(in something) struct One{ pub(in something) a: u32, pub(in something) b: u32 }
+pub(in something) struct One { pub(in something) a: u32, pub(in something) b: u32 }
 
 pub(in something) enum A { One(One) }"#,
         );
@@ -862,7 +862,7 @@ pub(in something) enum A { One(One) }"#,
             extract_struct_from_enum_variant,
             "pub(crate) enum A { $0One{ a: u32, b: u32, c: u32 } }",
             r#"
-pub(crate) struct One{ pub(crate) a: u32, pub(crate) b: u32, pub(crate) c: u32 }
+pub(crate) struct One { pub(crate) a: u32, pub(crate) b: u32, pub(crate) c: u32 }
 
 pub(crate) enum A { One(One) }"#,
         );
@@ -933,7 +933,7 @@ fn f() {
 }
 "#,
             r#"
-struct V{ i: i32, j: i32 }
+struct V { i: i32, j: i32 }
 
 enum E {
     V(V)
@@ -1027,7 +1027,7 @@ fn f() {
 "#,
             r#"
 //- /main.rs
-struct V{ i: i32, j: i32 }
+struct V { i: i32, j: i32 }
 
 enum E {
     V(V)
@@ -1057,7 +1057,7 @@ fn foo() {
 }
 "#,
             r#"
-struct One{ a: u32, b: u32 }
+struct One { a: u32, b: u32 }
 
 enum A { One(One) }
 
@@ -1114,7 +1114,7 @@ enum X<'a, 'b, 'x> {
 }
 "#,
             r#"
-struct A<'a, 'x>{ a: &'a &'x mut () }
+struct A<'a, 'x> { a: &'a &'x mut () }
 
 enum X<'a, 'b, 'x> {
     A(A<'a, 'x>),
@@ -1136,7 +1136,7 @@ enum X<'b, T, V, const C: usize> {
 }
 "#,
             r#"
-struct A<'b, T, const C: usize>{ a: T, b: X<'b>, c: [u8; C] }
+struct A<'b, T, const C: usize> { a: T, b: X<'b>, c: [u8; C] }
 
 enum X<'b, T, V, const C: usize> {
     A(A<'b, T, C>),
@@ -1158,7 +1158,7 @@ enum X<'a, 'b> {
 }
 "#,
             r#"
-struct C{ c: () }
+struct C { c: () }
 
 enum X<'a, 'b> {
     A { a: &'a () },
@@ -1180,7 +1180,7 @@ enum En<T: TraitT, V: TraitV> {
 }
 "#,
             r#"
-struct A<T: TraitT>{ a: T }
+struct A<T: TraitT> { a: T }
 
 enum En<T: TraitT, V: TraitV> {
     A(A<T>),
diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/json_is_not_rust.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/json_is_not_rust.rs
index 742d614bc5673..a300997723b4d 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/json_is_not_rust.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/json_is_not_rust.rs
@@ -233,7 +233,7 @@ mod tests {
             }
 
             #[derive(Serialize)]
-            struct Root1{ bar: f64, bay: i64, baz: (), r#box: bool, foo: String }
+            struct Root1 { bar: f64, bay: i64, baz: (), r#box: bool, foo: String }
 
             "#,
         );
@@ -252,9 +252,9 @@ mod tests {
             }
             "#,
             r#"
-            struct Value1{  }
-            struct Bar1{ kind: String, value: Value1 }
-            struct Root1{ bar: Bar1, foo: String }
+            struct Value1 {  }
+            struct Bar1 { kind: String, value: Value1 }
+            struct Root1 { bar: Bar1, foo: String }
 
             "#,
         );
@@ -284,12 +284,12 @@ mod tests {
             }
             "#,
             r#"
-            struct Address1{ house: i64, street: String }
-            struct User1{ address: Address1, email: String }
-            struct AnotherUser1{ user: User1 }
-            struct Address2{ house: i64, street: String }
-            struct User2{ address: Address2, email: String }
-            struct Root1{ another_user: AnotherUser1, user: User2 }
+            struct Address1 { house: i64, street: String }
+            struct User1 { address: Address1, email: String }
+            struct AnotherUser1 { user: User1 }
+            struct Address2 { house: i64, street: String }
+            struct User2 { address: Address2, email: String }
+            struct Root1 { another_user: AnotherUser1, user: User2 }
 
             "#,
         );
@@ -326,9 +326,9 @@ mod tests {
             use serde::Deserialize;
 
             #[derive(Serialize, Deserialize)]
-            struct OfObject1{ x: i64, y: i64 }
+            struct OfObject1 { x: i64, y: i64 }
             #[derive(Serialize, Deserialize)]
-            struct Root1{ empty: Vec<_>, nested: Vec<Vec<Vec<i64>>>, of_object: Vec<OfObject1>, of_string: Vec<String> }
+            struct Root1 { empty: Vec<_>, nested: Vec<Vec<Vec<i64>>>, of_object: Vec<OfObject1>, of_string: Vec<String> }
 
             "#,
         );
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/make.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/make.rs
index 9897fd0941570..051c5835571bc 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/make.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/make.rs
@@ -1244,14 +1244,17 @@ pub fn struct_(
     generic_param_list: Option<ast::GenericParamList>,
     field_list: ast::FieldList,
 ) -> ast::Struct {
-    let semicolon = if matches!(field_list, ast::FieldList::TupleFieldList(_)) { ";" } else { "" };
+    let (semicolon, ws) =
+        if matches!(field_list, ast::FieldList::TupleFieldList(_)) { (";", "") } else { ("", " ") };
     let type_params = generic_param_list.map_or_else(String::new, |it| it.to_string());
     let visibility = match visibility {
         None => String::new(),
         Some(it) => format!("{it} "),
     };
 
-    ast_from_text(&format!("{visibility}struct {strukt_name}{type_params}{field_list}{semicolon}",))
+    ast_from_text(&format!(
+        "{visibility}struct {strukt_name}{type_params}{ws}{field_list}{semicolon}"
+    ))
 }
 
 pub fn enum_(

From 4b5d0e02ca2647bf1efb2ecd3303c21ead64d2ea Mon Sep 17 00:00:00 2001
From: Soroush Mirzaei <soroush.mirzaei@shopify.com>
Date: Sun, 7 Sep 2025 11:14:00 -0400
Subject: [PATCH 0617/1889] docs(std): add error docs for path canonicalize

---
 library/std/src/path.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/library/std/src/path.rs b/library/std/src/path.rs
index 19663e4a9df62..70ba502d68421 100644
--- a/library/std/src/path.rs
+++ b/library/std/src/path.rs
@@ -3037,6 +3037,14 @@ impl Path {
     ///
     /// This is an alias to [`fs::canonicalize`].
     ///
+    /// # Errors
+    ///
+    /// This method will return an error in the following situations, but is not
+    /// limited to just these cases:
+    ///
+    /// * `path` does not exist.
+    /// * A non-final component in path is not a directory.
+    ///
     /// # Examples
     ///
     /// ```no_run

From 02602ef65125ac743cc0a61c5afe7c0c5acbad56 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Gabriel=20Bj=C3=B8rnager=20Jensen?= <gabriel@achernar.io>
Date: Sun, 7 Sep 2025 18:01:39 +0200
Subject: [PATCH 0618/1889] Implement 'Sum' and 'Product' for 'f16' and 'f128';

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

diff --git a/library/core/src/iter/traits/accum.rs b/library/core/src/iter/traits/accum.rs
index 73122369b41dd..3b805139ded17 100644
--- a/library/core/src/iter/traits/accum.rs
+++ b/library/core/src/iter/traits/accum.rs
@@ -203,7 +203,7 @@ macro_rules! float_sum_product {
 
 integer_sum_product! { i8 i16 i32 i64 i128 isize u8 u16 u32 u64 u128 usize }
 saturating_integer_sum_product! { u8 u16 u32 u64 u128 usize }
-float_sum_product! { f32 f64 }
+float_sum_product! { f16 f32 f64 f128 }
 
 #[stable(feature = "iter_arith_traits_result", since = "1.16.0")]
 impl<T, U, E> Sum<Result<U, E>> for Result<T, E>

From 2ff92e83af6d646e05218374954c6ed2ebb67b3d Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Mon, 28 Aug 2023 18:28:43 +0000
Subject: [PATCH 0619/1889] Introduce fast insertion at extremities to
 IntervalSet.

---
 compiler/rustc_index/src/interval.rs      | 51 ++++++++++++++++++
 compiler/rustc_mir_dataflow/src/points.rs | 66 +++++++++++++----------
 2 files changed, 90 insertions(+), 27 deletions(-)

diff --git a/compiler/rustc_index/src/interval.rs b/compiler/rustc_index/src/interval.rs
index 0225c5c4f329a..4af5bfcaee6dc 100644
--- a/compiler/rustc_index/src/interval.rs
+++ b/compiler/rustc_index/src/interval.rs
@@ -140,6 +140,49 @@ impl<I: Idx> IntervalSet<I> {
         result
     }
 
+    /// Specialized version of `insert` when we know that the inserted point is *before* any
+    /// contained.
+    pub fn prepend(&mut self, point: I) {
+        let point = point.index() as u32;
+
+        if let Some((first_start, _)) = self.map.first_mut() {
+            assert!(point < *first_start);
+            if point + 1 == *first_start {
+                *first_start = point;
+            } else {
+                self.map.insert(0, (point, point));
+            }
+        } else {
+            // If the map is empty, push is faster than insert.
+            self.map.push((point, point));
+        }
+
+        debug_assert!(
+            self.check_invariants(),
+            "wrong intervals after prepend {point:?} to {self:?}"
+        );
+    }
+
+    /// Specialized version of `insert` when we know that the inserted point is *after* any
+    /// contained.
+    pub fn append(&mut self, point: I) {
+        let point = point.index() as u32;
+
+        if let Some((_, last_end)) = self.map.last_mut()
+            && let _ = assert!(*last_end < point)
+            && point == *last_end + 1
+        {
+            *last_end = point;
+        } else {
+            self.map.push((point, point));
+        }
+
+        debug_assert!(
+            self.check_invariants(),
+            "wrong intervals after append {point:?} to {self:?}"
+        );
+    }
+
     pub fn contains(&self, needle: I) -> bool {
         let needle = needle.index() as u32;
         let Some(last) = self.map.partition_point(|r| r.0 <= needle).checked_sub(1) else {
@@ -325,6 +368,14 @@ impl<R: Idx, C: Step + Idx> SparseIntervalMatrix<R, C> {
         self.ensure_row(row).insert(point)
     }
 
+    pub fn prepend(&mut self, row: R, point: C) {
+        self.ensure_row(row).prepend(point)
+    }
+
+    pub fn append(&mut self, row: R, point: C) {
+        self.ensure_row(row).append(point)
+    }
+
     pub fn contains(&self, row: R, point: C) -> bool {
         self.row(row).is_some_and(|r| r.contains(point))
     }
diff --git a/compiler/rustc_mir_dataflow/src/points.rs b/compiler/rustc_mir_dataflow/src/points.rs
index 70d1a34b5fb13..55a373d4c5199 100644
--- a/compiler/rustc_mir_dataflow/src/points.rs
+++ b/compiler/rustc_mir_dataflow/src/points.rs
@@ -3,7 +3,7 @@ use rustc_index::interval::SparseIntervalMatrix;
 use rustc_index::{Idx, IndexVec};
 use rustc_middle::mir::{self, BasicBlock, Body, Location};
 
-use crate::framework::{Analysis, Results, ResultsVisitor, visit_results};
+use crate::framework::{Analysis, Direction, Results, ResultsVisitor, visit_results};
 
 /// Maps between a `Location` and a `PointIndex` (and vice versa).
 pub struct DenseLocationMap {
@@ -105,27 +105,47 @@ where
     N: Idx,
     A: Analysis<'tcx, Domain = DenseBitSet<N>>,
 {
-    let values = SparseIntervalMatrix::new(elements.num_points());
-    let mut visitor = Visitor { elements, values };
-    visit_results(
-        body,
-        body.basic_blocks.reverse_postorder().iter().copied(),
-        &mut analysis,
-        &results,
-        &mut visitor,
-    );
-    visitor.values
+    let mut values = SparseIntervalMatrix::new(elements.num_points());
+    let reachable_blocks = mir::traversal::reachable_as_bitset(body);
+    if A::Direction::IS_BACKWARD {
+        // Iterate blocks in decreasing order, to visit locations in decreasing order. This
+        // allows to use the more efficient `prepend` method to interval sets.
+        let callback = |state: &DenseBitSet<N>, location| {
+            let point = elements.point_from_location(location);
+            // Use internal iterator manually as it is much more efficient.
+            state.iter().for_each(|node| values.prepend(node, point));
+        };
+        let mut visitor = Visitor { callback };
+        visit_results(
+            body,
+            // Note the `.rev()`.
+            body.basic_blocks.indices().filter(|&bb| reachable_blocks.contains(bb)).rev(),
+            &mut analysis,
+            &results,
+            &mut visitor,
+        );
+    } else {
+        // Iterate blocks in increasing order, to visit locations in increasing order. This
+        // allows to use the more efficient `append` method to interval sets.
+        let callback = |state: &DenseBitSet<N>, location| {
+            let point = elements.point_from_location(location);
+            // Use internal iterator manually as it is much more efficient.
+            state.iter().for_each(|node| values.append(node, point));
+        };
+        let mut visitor = Visitor { callback };
+        visit_results(body, reachable_blocks.iter(), &mut analysis, &results, &mut visitor);
+    }
+    values
 }
 
-struct Visitor<'a, N: Idx> {
-    elements: &'a DenseLocationMap,
-    values: SparseIntervalMatrix<N, PointIndex>,
+struct Visitor<F> {
+    callback: F,
 }
 
-impl<'tcx, A, N> ResultsVisitor<'tcx, A> for Visitor<'_, N>
+impl<'tcx, A, F> ResultsVisitor<'tcx, A> for Visitor<F>
 where
-    A: Analysis<'tcx, Domain = DenseBitSet<N>>,
-    N: Idx,
+    A: Analysis<'tcx>,
+    F: FnMut(&A::Domain, Location),
 {
     fn visit_after_primary_statement_effect<'mir>(
         &mut self,
@@ -134,11 +154,7 @@ where
         _statement: &'mir mir::Statement<'tcx>,
         location: Location,
     ) {
-        let point = self.elements.point_from_location(location);
-        // Use internal iterator manually as it is much more efficient.
-        state.iter().for_each(|node| {
-            self.values.insert(node, point);
-        });
+        (self.callback)(state, location);
     }
 
     fn visit_after_primary_terminator_effect<'mir>(
@@ -148,10 +164,6 @@ where
         _terminator: &'mir mir::Terminator<'tcx>,
         location: Location,
     ) {
-        let point = self.elements.point_from_location(location);
-        // Use internal iterator manually as it is much more efficient.
-        state.iter().for_each(|node| {
-            self.values.insert(node, point);
-        });
+        (self.callback)(state, location);
     }
 }

From 9b8a719ae48db491a5f18d52fdbb802508bf75a5 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Wed, 2 Jul 2025 08:36:22 +0000
Subject: [PATCH 0620/1889] Reimplement DestinationPropagation according to
 live ranges.

---
 compiler/rustc_index/src/interval.rs          |  26 +
 .../rustc_mir_dataflow/src/impls/liveness.rs  |  37 +-
 compiler/rustc_mir_dataflow/src/impls/mod.rs  |   3 +-
 compiler/rustc_mir_dataflow/src/points.rs     |  80 +-
 compiler/rustc_mir_transform/src/dest_prop.rs | 843 ++++++++----------
 ...in.DestinationPropagation.panic-abort.diff |  16 +-
 ...n.DestinationPropagation.panic-unwind.diff |  16 +-
 7 files changed, 449 insertions(+), 572 deletions(-)

diff --git a/compiler/rustc_index/src/interval.rs b/compiler/rustc_index/src/interval.rs
index 4af5bfcaee6dc..69a7a69610e04 100644
--- a/compiler/rustc_index/src/interval.rs
+++ b/compiler/rustc_index/src/interval.rs
@@ -219,6 +219,32 @@ impl<I: Idx> IntervalSet<I> {
         })
     }
 
+    pub fn disjoint(&self, other: &IntervalSet<I>) -> bool
+    where
+        I: Step,
+    {
+        let helper = move || {
+            let mut self_iter = self.iter_intervals();
+            let mut other_iter = other.iter_intervals();
+
+            let mut self_current = self_iter.next()?;
+            let mut other_current = other_iter.next()?;
+
+            loop {
+                if self_current.end <= other_current.start {
+                    self_current = self_iter.next()?;
+                    continue;
+                }
+                if other_current.end <= self_current.start {
+                    other_current = other_iter.next()?;
+                    continue;
+                }
+                return Some(false);
+            }
+        };
+        helper().unwrap_or(true)
+    }
+
     pub fn is_empty(&self) -> bool {
         self.map.is_empty()
     }
diff --git a/compiler/rustc_mir_dataflow/src/impls/liveness.rs b/compiler/rustc_mir_dataflow/src/impls/liveness.rs
index 6ec1b03a34e68..5eba474a60c7a 100644
--- a/compiler/rustc_mir_dataflow/src/impls/liveness.rs
+++ b/compiler/rustc_mir_dataflow/src/impls/liveness.rs
@@ -92,7 +92,7 @@ impl<'tcx> Visitor<'tcx> for TransferFunction<'_> {
         }
 
         match DefUse::for_place(*place, context) {
-            Some(DefUse::Def) => {
+            DefUse::Def => {
                 if let PlaceContext::MutatingUse(
                     MutatingUseContext::Call | MutatingUseContext::AsmOutput,
                 ) = context
@@ -105,8 +105,8 @@ impl<'tcx> Visitor<'tcx> for TransferFunction<'_> {
                     self.0.kill(place.local);
                 }
             }
-            Some(DefUse::Use) => self.0.gen_(place.local),
-            None => {}
+            DefUse::Use => self.0.gen_(place.local),
+            DefUse::PartialWrite | DefUse::NonUse => {}
         }
 
         self.visit_projection(place.as_ref(), context, location);
@@ -131,23 +131,29 @@ impl<'tcx> Visitor<'tcx> for YieldResumeEffect<'_> {
 }
 
 #[derive(Eq, PartialEq, Clone)]
-enum DefUse {
+pub enum DefUse {
+    /// Full write to the local.
     Def,
+    /// Read of any part of the local.
     Use,
+    /// Partial write to the local.
+    PartialWrite,
+    /// Non-use, like debuginfo.
+    NonUse,
 }
 
 impl DefUse {
     fn apply(state: &mut DenseBitSet<Local>, place: Place<'_>, context: PlaceContext) {
         match DefUse::for_place(place, context) {
-            Some(DefUse::Def) => state.kill(place.local),
-            Some(DefUse::Use) => state.gen_(place.local),
-            None => {}
+            DefUse::Def => state.kill(place.local),
+            DefUse::Use => state.gen_(place.local),
+            DefUse::PartialWrite | DefUse::NonUse => {}
         }
     }
 
-    fn for_place(place: Place<'_>, context: PlaceContext) -> Option<DefUse> {
+    pub fn for_place(place: Place<'_>, context: PlaceContext) -> DefUse {
         match context {
-            PlaceContext::NonUse(_) => None,
+            PlaceContext::NonUse(_) => DefUse::NonUse,
 
             PlaceContext::MutatingUse(
                 MutatingUseContext::Call
@@ -156,21 +162,20 @@ impl DefUse {
                 | MutatingUseContext::Store
                 | MutatingUseContext::Deinit,
             ) => {
+                // Treat derefs as a use of the base local. `*p = 4` is not a def of `p` but a use.
                 if place.is_indirect() {
-                    // Treat derefs as a use of the base local. `*p = 4` is not a def of `p` but a
-                    // use.
-                    Some(DefUse::Use)
+                    DefUse::Use
                 } else if place.projection.is_empty() {
-                    Some(DefUse::Def)
+                    DefUse::Def
                 } else {
-                    None
+                    DefUse::PartialWrite
                 }
             }
 
             // Setting the discriminant is not a use because it does no reading, but it is also not
             // a def because it does not overwrite the whole place
             PlaceContext::MutatingUse(MutatingUseContext::SetDiscriminant) => {
-                place.is_indirect().then_some(DefUse::Use)
+                if place.is_indirect() { DefUse::Use } else { DefUse::PartialWrite }
             }
 
             // All other contexts are uses...
@@ -188,7 +193,7 @@ impl DefUse {
                 | NonMutatingUseContext::PlaceMention
                 | NonMutatingUseContext::FakeBorrow
                 | NonMutatingUseContext::SharedBorrow,
-            ) => Some(DefUse::Use),
+            ) => DefUse::Use,
 
             PlaceContext::MutatingUse(MutatingUseContext::Projection)
             | PlaceContext::NonMutatingUse(NonMutatingUseContext::Projection) => {
diff --git a/compiler/rustc_mir_dataflow/src/impls/mod.rs b/compiler/rustc_mir_dataflow/src/impls/mod.rs
index 3f29b819a6d18..6d573e1c00e1c 100644
--- a/compiler/rustc_mir_dataflow/src/impls/mod.rs
+++ b/compiler/rustc_mir_dataflow/src/impls/mod.rs
@@ -9,7 +9,8 @@ pub use self::initialized::{
     MaybeUninitializedPlaces, MaybeUninitializedPlacesDomain,
 };
 pub use self::liveness::{
-    MaybeLiveLocals, MaybeTransitiveLiveLocals, TransferFunction as LivenessTransferFunction,
+    DefUse, MaybeLiveLocals, MaybeTransitiveLiveLocals,
+    TransferFunction as LivenessTransferFunction,
 };
 pub use self::storage_liveness::{
     MaybeRequiresStorage, MaybeStorageDead, MaybeStorageLive, always_storage_live_locals,
diff --git a/compiler/rustc_mir_dataflow/src/points.rs b/compiler/rustc_mir_dataflow/src/points.rs
index 55a373d4c5199..e3d1e04a319ba 100644
--- a/compiler/rustc_mir_dataflow/src/points.rs
+++ b/compiler/rustc_mir_dataflow/src/points.rs
@@ -1,9 +1,5 @@
-use rustc_index::bit_set::DenseBitSet;
-use rustc_index::interval::SparseIntervalMatrix;
 use rustc_index::{Idx, IndexVec};
-use rustc_middle::mir::{self, BasicBlock, Body, Location};
-
-use crate::framework::{Analysis, Direction, Results, ResultsVisitor, visit_results};
+use rustc_middle::mir::{BasicBlock, Body, Location};
 
 /// Maps between a `Location` and a `PointIndex` (and vice versa).
 pub struct DenseLocationMap {
@@ -93,77 +89,3 @@ rustc_index::newtype_index! {
     #[debug_format = "PointIndex({})"]
     pub struct PointIndex {}
 }
-
-/// Add points depending on the result of the given dataflow analysis.
-pub fn save_as_intervals<'tcx, N, A>(
-    elements: &DenseLocationMap,
-    body: &mir::Body<'tcx>,
-    mut analysis: A,
-    results: Results<A::Domain>,
-) -> SparseIntervalMatrix<N, PointIndex>
-where
-    N: Idx,
-    A: Analysis<'tcx, Domain = DenseBitSet<N>>,
-{
-    let mut values = SparseIntervalMatrix::new(elements.num_points());
-    let reachable_blocks = mir::traversal::reachable_as_bitset(body);
-    if A::Direction::IS_BACKWARD {
-        // Iterate blocks in decreasing order, to visit locations in decreasing order. This
-        // allows to use the more efficient `prepend` method to interval sets.
-        let callback = |state: &DenseBitSet<N>, location| {
-            let point = elements.point_from_location(location);
-            // Use internal iterator manually as it is much more efficient.
-            state.iter().for_each(|node| values.prepend(node, point));
-        };
-        let mut visitor = Visitor { callback };
-        visit_results(
-            body,
-            // Note the `.rev()`.
-            body.basic_blocks.indices().filter(|&bb| reachable_blocks.contains(bb)).rev(),
-            &mut analysis,
-            &results,
-            &mut visitor,
-        );
-    } else {
-        // Iterate blocks in increasing order, to visit locations in increasing order. This
-        // allows to use the more efficient `append` method to interval sets.
-        let callback = |state: &DenseBitSet<N>, location| {
-            let point = elements.point_from_location(location);
-            // Use internal iterator manually as it is much more efficient.
-            state.iter().for_each(|node| values.append(node, point));
-        };
-        let mut visitor = Visitor { callback };
-        visit_results(body, reachable_blocks.iter(), &mut analysis, &results, &mut visitor);
-    }
-    values
-}
-
-struct Visitor<F> {
-    callback: F,
-}
-
-impl<'tcx, A, F> ResultsVisitor<'tcx, A> for Visitor<F>
-where
-    A: Analysis<'tcx>,
-    F: FnMut(&A::Domain, Location),
-{
-    fn visit_after_primary_statement_effect<'mir>(
-        &mut self,
-        _analysis: &mut A,
-        state: &A::Domain,
-        _statement: &'mir mir::Statement<'tcx>,
-        location: Location,
-    ) {
-        (self.callback)(state, location);
-    }
-
-    fn visit_after_primary_terminator_effect<'mir>(
-        &mut self,
-        _analysis: &mut A,
-        state: &A::Domain,
-        _terminator: &'mir mir::Terminator<'tcx>,
-        location: Location,
-    ) {
-        (self.callback)(state, location);
-    }
-}
diff --git a/compiler/rustc_mir_transform/src/dest_prop.rs b/compiler/rustc_mir_transform/src/dest_prop.rs
index cf7425251e8e0..da1d339b52658 100644
--- a/compiler/rustc_mir_transform/src/dest_prop.rs
+++ b/compiler/rustc_mir_transform/src/dest_prop.rs
@@ -59,6 +59,12 @@
 //! The first two conditions are simple structural requirements on the `Assign` statements that can
 //! be trivially checked. The third requirement however is more difficult and costly to check.
 //!
+//! ## Current implementation
+//!
+//! The current implementation relies on live range computation to check for conflicts. We only
+//! allow to merge locals that have disjoint live ranges. The live range are defined with
+//! half-statement granularity, so as to make all writes be live for at least a half statement.
+//!
 //! ## Future Improvements
 //!
 //! There are a number of ways in which this pass could be improved in the future:
@@ -117,9 +123,8 @@
 //! - Layout optimizations for coroutines have been added to improve code generation for
 //!   async/await, which are very similar in spirit to what this optimization does.
 //!
-//! Also, rustc now has a simple NRVO pass (see `nrvo.rs`), which handles a subset of the cases that
-//! this destination propagation pass handles, proving that similar optimizations can be performed
-//! on MIR.
+//! [The next approach][attempt 4] computes a conflict matrix between locals by forbidding merging
+//! locals with competing writes or with one write while the other is live.
 //!
 //! ## Pre/Post Optimization
 //!
@@ -130,20 +135,18 @@
 //! [attempt 1]: https://github.com/rust-lang/rust/pull/47954
 //! [attempt 2]: https://github.com/rust-lang/rust/pull/71003
 //! [attempt 3]: https://github.com/rust-lang/rust/pull/72632
+//! [attempt 4]: https://github.com/rust-lang/rust/pull/96451
 
-use rustc_data_structures::fx::{FxIndexMap, IndexEntry, IndexOccupiedEntry};
+use rustc_data_structures::fx::FxIndexMap;
 use rustc_index::bit_set::DenseBitSet;
 use rustc_index::interval::SparseIntervalMatrix;
-use rustc_middle::bug;
-use rustc_middle::mir::visit::{MutVisitor, PlaceContext, Visitor};
-use rustc_middle::mir::{
-    Body, HasLocalDecls, InlineAsmOperand, Local, LocalKind, Location, MirDumper, Operand,
-    PassWhere, Place, Rvalue, Statement, StatementKind, TerminatorKind, traversal,
-};
+use rustc_index::{IndexSlice, IndexVec, newtype_index};
+use rustc_middle::mir::visit::{MutVisitor, NonMutatingUseContext, PlaceContext, Visitor};
+use rustc_middle::mir::*;
 use rustc_middle::ty::TyCtxt;
-use rustc_mir_dataflow::Analysis;
-use rustc_mir_dataflow::impls::MaybeLiveLocals;
-use rustc_mir_dataflow::points::{DenseLocationMap, PointIndex, save_as_intervals};
+use rustc_mir_dataflow::impls::DefUse;
+use rustc_mir_dataflow::points::{DenseLocationMap, PointIndex};
+use rustc_mir_dataflow::{Analysis, Backward, Results};
 use tracing::{debug, trace};
 
 pub(super) struct DestinationPropagation;
@@ -161,84 +164,62 @@ impl<'tcx> crate::MirPass<'tcx> for DestinationPropagation {
         sess.mir_opt_level() >= 3
     }
 
+    #[tracing::instrument(level = "trace", skip(self, tcx, body))]
     fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
         let def_id = body.source.def_id();
-        let mut candidates = Candidates::default();
-        let mut write_info = WriteInfo::default();
-        trace!(func = ?tcx.def_path_str(def_id));
+        trace!(?def_id);
 
         let borrowed = rustc_mir_dataflow::impls::borrowed_locals(body);
 
-        let live = MaybeLiveLocals.iterate_to_fixpoint(tcx, body, Some("MaybeLiveLocals-DestProp"));
+        let candidates = Candidates::find(body, &borrowed);
+        trace!(?candidates);
+        if candidates.c.is_empty() {
+            return;
+        }
+
+        let live =
+            MaybeTwoStepLiveLocals.iterate_to_fixpoint(tcx, body, Some("MaybeLiveLocals-DestProp"));
+
         let points = DenseLocationMap::new(body);
-        let mut live = save_as_intervals(&points, body, live.analysis, live.results);
-
-        // In order to avoid having to collect data for every single pair of locals in the body, we
-        // do not allow doing more than one merge for places that are derived from the same local at
-        // once. To avoid missed opportunities, we instead iterate to a fixed point - we'll refer to
-        // each of these iterations as a "round."
-        //
-        // Reaching a fixed point could in theory take up to `min(l, s)` rounds - however, we do not
-        // expect to see MIR like that. To verify this, a test was run against `[rust-lang/regex]` -
-        // the average MIR body saw 1.32 full iterations of this loop. The most that was hit were 30
-        // for a single function. Only 80/2801 (2.9%) of functions saw at least 5.
-        //
-        // [rust-lang/regex]:
-        //     https://github.com/rust-lang/regex/tree/b5372864e2df6a2f5e543a556a62197f50ca3650
-        let mut round_count = 0;
-        loop {
-            // PERF: Can we do something smarter than recalculating the candidates and liveness
-            // results?
-            candidates.reset_and_find(body, &borrowed);
-            trace!(?candidates);
-            dest_prop_mir_dump(tcx, body, &points, &live, round_count);
-
-            FilterInformation::filter_liveness(
-                &mut candidates,
-                &points,
-                &live,
-                &mut write_info,
-                body,
-            );
-
-            // Because we only filter once per round, it is unsound to use a local for more than
-            // one merge operation within a single round of optimizations. We store here which ones
-            // we have already used.
-            let mut merged_locals: DenseBitSet<Local> =
-                DenseBitSet::new_empty(body.local_decls.len());
-
-            // This is the set of merges we will apply this round. It is a subset of the candidates.
-            let mut merges = FxIndexMap::default();
-
-            for (src, candidates) in candidates.c.iter() {
-                if merged_locals.contains(*src) {
-                    continue;
-                }
-                let Some(dest) = candidates.iter().find(|dest| !merged_locals.contains(**dest))
-                else {
-                    continue;
-                };
-
-                // Replace `src` by `dest` everywhere.
-                merges.insert(*src, *dest);
-                merged_locals.insert(*src);
-                merged_locals.insert(*dest);
-
-                // Update liveness information based on the merge we just performed.
-                // Every location where `src` was live, `dest` will be live.
-                live.union_rows(*src, *dest);
-            }
-            trace!(merging = ?merges);
+        let mut relevant = RelevantLocals::compute(&candidates, body.local_decls.len());
+        let mut live = save_as_intervals(&points, body, &relevant.original, live.results);
 
-            if merges.is_empty() {
-                break;
-            }
-            round_count += 1;
+        dest_prop_mir_dump(tcx, body, &points, &live, &relevant);
+
+        let mut merged_locals = DenseBitSet::new_empty(body.local_decls.len());
+
+        for (src, candidates) in candidates.c.into_iter() {
+            trace!(?src, ?candidates);
+
+            let Some(src) = relevant.find(src) else { continue };
+            let Some(src_live_ranges) = &live.row(src) else { continue };
+            trace!(?src, ?src_live_ranges);
+
+            let dst = candidates.into_iter().find_map(|dst| {
+                let dst = relevant.find(dst)?;
+                let dst_live_ranges = &live.row(dst)?;
+                trace!(?dst, ?dst_live_ranges);
+
+                let disjoint = src_live_ranges.disjoint(dst_live_ranges);
+                disjoint.then_some(dst)
+            });
+            let Some(dst) = dst else { continue };
+
+            merged_locals.insert(relevant.original[src]);
+            merged_locals.insert(relevant.original[dst]);
 
-            apply_merges(body, tcx, merges, merged_locals);
+            relevant.union(src, dst);
+            live.union_rows(src, dst);
         }
+        trace!(?merged_locals);
 
-        trace!(round_count);
+        relevant.make_idempotent();
+
+        if merged_locals.is_empty() {
+            return;
+        }
+
+        apply_merges(body, tcx, relevant, merged_locals);
     }
 
     fn is_required(&self) -> bool {
@@ -246,30 +227,6 @@ impl<'tcx> crate::MirPass<'tcx> for DestinationPropagation {
     }
 }
 
-#[derive(Debug, Default)]
-struct Candidates {
-    /// The set of candidates we are considering in this optimization.
-    ///
-    /// We will always merge the key into at most one of its values.
-    ///
-    /// Whether a place ends up in the key or the value does not correspond to whether it appears as
-    /// the lhs or rhs of any assignment. As a matter of fact, the places in here might never appear
-    /// in an assignment at all. This happens because if we see an assignment like this:
-    ///
-    /// ```ignore (syntax-highlighting-only)
-    /// _1.0 = _2.0
-    /// ```
-    ///
-    /// We will still report that we would like to merge `_1` and `_2` in an attempt to allow us to
-    /// remove that assignment.
-    c: FxIndexMap<Local, Vec<Local>>,
-
-    /// A reverse index of the `c` set; if the `c` set contains `a => Place { local: b, proj }`,
-    /// then this contains `b => a`.
-    // PERF: Possibly these should be `SmallVec`s?
-    reverse: FxIndexMap<Local, Vec<Local>>,
-}
-
 //////////////////////////////////////////////////////////
 // Merging
 //
@@ -278,16 +235,16 @@ struct Candidates {
 fn apply_merges<'tcx>(
     body: &mut Body<'tcx>,
     tcx: TyCtxt<'tcx>,
-    merges: FxIndexMap<Local, Local>,
+    relevant: RelevantLocals,
     merged_locals: DenseBitSet<Local>,
 ) {
-    let mut merger = Merger { tcx, merges, merged_locals };
+    let mut merger = Merger { tcx, relevant, merged_locals };
     merger.visit_body_preserves_cfg(body);
 }
 
 struct Merger<'tcx> {
     tcx: TyCtxt<'tcx>,
-    merges: FxIndexMap<Local, Local>,
+    relevant: RelevantLocals,
     merged_locals: DenseBitSet<Local>,
 }
 
@@ -297,8 +254,8 @@ impl<'tcx> MutVisitor<'tcx> for Merger<'tcx> {
     }
 
     fn visit_local(&mut self, local: &mut Local, _: PlaceContext, _location: Location) {
-        if let Some(dest) = self.merges.get(local) {
-            *local = *dest;
+        if let Some(relevant) = self.relevant.find(*local) {
+            *local = self.relevant.original[relevant];
         }
     }
 
@@ -336,376 +293,116 @@ impl<'tcx> MutVisitor<'tcx> for Merger<'tcx> {
 }
 
 //////////////////////////////////////////////////////////
-// Liveness filtering
+// Relevant locals
 //
-// This section enforces bullet point 2
+// Small utility to reduce size of the conflict matrix by only considering locals that appear in
+// the candidates
 
-struct FilterInformation<'a, 'tcx> {
-    body: &'a Body<'tcx>,
-    points: &'a DenseLocationMap,
-    live: &'a SparseIntervalMatrix<Local, PointIndex>,
-    candidates: &'a mut Candidates,
-    write_info: &'a mut WriteInfo,
-    at: Location,
+newtype_index! {
+    /// Represent a subset of locals which appear in candidates.
+    struct RelevantLocal {}
 }
 
-// We first implement some utility functions which we will expose removing candidates according to
-// different needs. Throughout the liveness filtering, the `candidates` are only ever accessed
-// through these methods, and not directly.
-impl Candidates {
-    /// Collects the candidates for merging.
-    ///
-    /// This is responsible for enforcing the first and third bullet point.
-    fn reset_and_find<'tcx>(&mut self, body: &Body<'tcx>, borrowed: &DenseBitSet<Local>) {
-        self.c.clear();
-        self.reverse.clear();
-        let mut visitor = FindAssignments { body, candidates: &mut self.c, borrowed };
-        visitor.visit_body(body);
-        // Deduplicate candidates.
-        for (_, cands) in self.c.iter_mut() {
-            cands.sort();
-            cands.dedup();
-        }
-        // Generate the reverse map.
-        for (src, cands) in self.c.iter() {
-            for dest in cands.iter().copied() {
-                self.reverse.entry(dest).or_default().push(*src);
-            }
-        }
-    }
-
-    /// Just `Vec::retain`, but the condition is inverted and we add debugging output
-    fn vec_filter_candidates(
-        src: Local,
-        v: &mut Vec<Local>,
-        mut f: impl FnMut(Local) -> CandidateFilter,
-        at: Location,
-    ) {
-        v.retain(|dest| {
-            let remove = f(*dest);
-            if remove == CandidateFilter::Remove {
-                trace!("eliminating {:?} => {:?} due to conflict at {:?}", src, dest, at);
-            }
-            remove == CandidateFilter::Keep
-        });
-    }
-
-    /// `vec_filter_candidates` but for an `Entry`
-    fn entry_filter_candidates(
-        mut entry: IndexOccupiedEntry<'_, Local, Vec<Local>>,
-        p: Local,
-        f: impl FnMut(Local) -> CandidateFilter,
-        at: Location,
-    ) {
-        let candidates = entry.get_mut();
-        Self::vec_filter_candidates(p, candidates, f, at);
-        if candidates.len() == 0 {
-            // FIXME(#120456) - is `swap_remove` correct?
-            entry.swap_remove();
-        }
-    }
-
-    /// For all candidates `(p, q)` or `(q, p)` removes the candidate if `f(q)` says to do so
-    fn filter_candidates_by(
-        &mut self,
-        p: Local,
-        mut f: impl FnMut(Local) -> CandidateFilter,
-        at: Location,
-    ) {
-        // Cover the cases where `p` appears as a `src`
-        if let IndexEntry::Occupied(entry) = self.c.entry(p) {
-            Self::entry_filter_candidates(entry, p, &mut f, at);
-        }
-        // And the cases where `p` appears as a `dest`
-        let Some(srcs) = self.reverse.get_mut(&p) else {
-            return;
-        };
-        // We use `retain` here to remove the elements from the reverse set if we've removed the
-        // matching candidate in the forward set.
-        srcs.retain(|src| {
-            if f(*src) == CandidateFilter::Keep {
-                return true;
-            }
-            let IndexEntry::Occupied(entry) = self.c.entry(*src) else {
-                return false;
-            };
-            Self::entry_filter_candidates(
-                entry,
-                *src,
-                |dest| {
-                    if dest == p { CandidateFilter::Remove } else { CandidateFilter::Keep }
-                },
-                at,
-            );
-            false
-        });
-    }
+#[derive(Debug)]
+struct RelevantLocals {
+    original: IndexVec<RelevantLocal, Local>,
+    shrink: IndexVec<Local, Option<RelevantLocal>>,
+    renames: IndexVec<RelevantLocal, RelevantLocal>,
 }
 
-#[derive(Copy, Clone, PartialEq, Eq)]
-enum CandidateFilter {
-    Keep,
-    Remove,
-}
+impl RelevantLocals {
+    #[tracing::instrument(level = "trace", skip(candidates, num_locals), ret)]
+    fn compute(candidates: &Candidates, num_locals: usize) -> RelevantLocals {
+        let mut original = IndexVec::with_capacity(candidates.c.len());
+        let mut shrink = IndexVec::from_elem_n(None, num_locals);
 
-impl<'a, 'tcx> FilterInformation<'a, 'tcx> {
-    /// Filters the set of candidates to remove those that conflict.
-    ///
-    /// The steps we take are exactly those that are outlined at the top of the file. For each
-    /// statement/terminator, we collect the set of locals that are written to in that
-    /// statement/terminator, and then we remove all pairs of candidates that contain one such local
-    /// and another one that is live.
-    ///
-    /// We need to be careful about the ordering of operations within each statement/terminator
-    /// here. Many statements might write and read from more than one place, and we need to consider
-    /// them all. The strategy for doing this is as follows: We first gather all the places that are
-    /// written to within the statement/terminator via `WriteInfo`. Then, we use the liveness
-    /// analysis from *before* the statement/terminator (in the control flow sense) to eliminate
-    /// candidates - this is because we want to conservatively treat a pair of locals that is both
-    /// read and written in the statement/terminator to be conflicting, and the liveness analysis
-    /// before the statement/terminator will correctly report locals that are read in the
-    /// statement/terminator to be live. We are additionally conservative by treating all written to
-    /// locals as also being read from.
-    fn filter_liveness(
-        candidates: &mut Candidates,
-        points: &DenseLocationMap,
-        live: &SparseIntervalMatrix<Local, PointIndex>,
-        write_info: &mut WriteInfo,
-        body: &Body<'tcx>,
-    ) {
-        let mut this = FilterInformation {
-            body,
-            points,
-            live,
-            candidates,
-            // We don't actually store anything at this scope, we just keep things here to be able
-            // to reuse the allocation.
-            write_info,
-            // Doesn't matter what we put here, will be overwritten before being used
-            at: Location::START,
+        // Mark a local as relevant and record it into the maps.
+        let mut declare = |local| {
+            shrink.get_or_insert_with(local, || original.push(local));
         };
-        this.internal_filter_liveness();
-    }
-
-    fn internal_filter_liveness(&mut self) {
-        for (block, data) in traversal::preorder(self.body) {
-            self.at = Location { block, statement_index: data.statements.len() };
-            self.write_info.for_terminator(&data.terminator().kind);
-            self.apply_conflicts();
 
-            for (i, statement) in data.statements.iter().enumerate().rev() {
-                self.at = Location { block, statement_index: i };
-                self.write_info.for_statement(&statement.kind, self.body);
-                self.apply_conflicts();
+        for (&src, destinations) in candidates.c.iter() {
+            declare(src);
+            for &dest in destinations {
+                declare(dest)
             }
         }
-    }
 
-    fn apply_conflicts(&mut self) {
-        let writes = &self.write_info.writes;
-        for p in writes {
-            let other_skip = self.write_info.skip_pair.and_then(|(a, b)| {
-                if a == *p {
-                    Some(b)
-                } else if b == *p {
-                    Some(a)
-                } else {
-                    None
-                }
-            });
-            let at = self.points.point_from_location(self.at);
-            self.candidates.filter_candidates_by(
-                *p,
-                |q| {
-                    if Some(q) == other_skip {
-                        return CandidateFilter::Keep;
-                    }
-                    // It is possible that a local may be live for less than the
-                    // duration of a statement This happens in the case of function
-                    // calls or inline asm. Because of this, we also mark locals as
-                    // conflicting when both of them are written to in the same
-                    // statement.
-                    if self.live.contains(q, at) || writes.contains(&q) {
-                        CandidateFilter::Remove
-                    } else {
-                        CandidateFilter::Keep
-                    }
-                },
-                self.at,
-            );
-        }
+        let renames = IndexVec::from_fn_n(|l| l, original.len());
+        RelevantLocals { original, shrink, renames }
     }
-}
 
-/// Describes where a statement/terminator writes to
-#[derive(Default, Debug)]
-struct WriteInfo {
-    writes: Vec<Local>,
-    /// If this pair of locals is a candidate pair, completely skip processing it during this
-    /// statement. All other candidates are unaffected.
-    skip_pair: Option<(Local, Local)>,
-}
-
-impl WriteInfo {
-    fn for_statement<'tcx>(&mut self, statement: &StatementKind<'tcx>, body: &Body<'tcx>) {
-        self.reset();
-        match statement {
-            StatementKind::Assign(box (lhs, rhs)) => {
-                self.add_place(*lhs);
-                match rhs {
-                    Rvalue::Use(op) => {
-                        self.add_operand(op);
-                        self.consider_skipping_for_assign_use(*lhs, op, body);
-                    }
-                    Rvalue::Repeat(op, _) => {
-                        self.add_operand(op);
-                    }
-                    Rvalue::Cast(_, op, _)
-                    | Rvalue::UnaryOp(_, op)
-                    | Rvalue::ShallowInitBox(op, _) => {
-                        self.add_operand(op);
-                    }
-                    Rvalue::BinaryOp(_, ops) => {
-                        for op in [&ops.0, &ops.1] {
-                            self.add_operand(op);
-                        }
-                    }
-                    Rvalue::Aggregate(_, ops) => {
-                        for op in ops {
-                            self.add_operand(op);
-                        }
-                    }
-                    Rvalue::WrapUnsafeBinder(op, _) => {
-                        self.add_operand(op);
-                    }
-                    Rvalue::ThreadLocalRef(_)
-                    | Rvalue::NullaryOp(_, _)
-                    | Rvalue::Ref(_, _, _)
-                    | Rvalue::RawPtr(_, _)
-                    | Rvalue::Len(_)
-                    | Rvalue::Discriminant(_)
-                    | Rvalue::CopyForDeref(_) => {}
-                }
-            }
-            // Retags are technically also reads, but reporting them as a write suffices
-            StatementKind::SetDiscriminant { place, .. }
-            | StatementKind::Deinit(place)
-            | StatementKind::Retag(_, place) => {
-                self.add_place(**place);
-            }
-            StatementKind::Intrinsic(_)
-            | StatementKind::ConstEvalCounter
-            | StatementKind::Nop
-            | StatementKind::Coverage(_)
-            | StatementKind::StorageLive(_)
-            | StatementKind::StorageDead(_)
-            | StatementKind::BackwardIncompatibleDropHint { .. }
-            | StatementKind::PlaceMention(_) => {}
-            StatementKind::FakeRead(_) | StatementKind::AscribeUserType(_, _) => {
-                bug!("{:?} not found in this MIR phase", statement)
-            }
+    fn find(&self, src: Local) -> Option<RelevantLocal> {
+        let mut src = self.shrink[src]?;
+        while let s2 = self.renames[src]
+            && src != s2
+        {
+            src = s2
         }
+        Some(src)
     }
 
-    fn consider_skipping_for_assign_use<'tcx>(
-        &mut self,
-        lhs: Place<'tcx>,
-        rhs: &Operand<'tcx>,
-        body: &Body<'tcx>,
-    ) {
-        let Some(rhs) = rhs.place() else { return };
-        if let Some(pair) = places_to_candidate_pair(lhs, rhs, body) {
-            self.skip_pair = Some(pair);
-        }
+    fn union(&mut self, lhs: RelevantLocal, rhs: RelevantLocal) {
+        self.renames[lhs] = rhs;
     }
 
-    fn for_terminator<'tcx>(&mut self, terminator: &TerminatorKind<'tcx>) {
-        self.reset();
-        match terminator {
-            TerminatorKind::SwitchInt { discr: op, .. }
-            | TerminatorKind::Assert { cond: op, .. } => {
-                self.add_operand(op);
-            }
-            TerminatorKind::Call { destination, func, args, .. } => {
-                self.add_place(*destination);
-                self.add_operand(func);
-                for arg in args {
-                    self.add_operand(&arg.node);
-                }
-            }
-            TerminatorKind::TailCall { func, args, .. } => {
-                self.add_operand(func);
-                for arg in args {
-                    self.add_operand(&arg.node);
-                }
-            }
-            TerminatorKind::InlineAsm { operands, .. } => {
-                for asm_operand in operands {
-                    match asm_operand {
-                        InlineAsmOperand::In { value, .. } => {
-                            self.add_operand(value);
-                        }
-                        InlineAsmOperand::Out { place, .. } => {
-                            if let Some(place) = place {
-                                self.add_place(*place);
-                            }
-                        }
-                        // Note that the `late` field in `InOut` is about whether the registers used
-                        // for these things overlap, and is of absolutely no interest to us.
-                        InlineAsmOperand::InOut { in_value, out_place, .. } => {
-                            if let Some(place) = out_place {
-                                self.add_place(*place);
-                            }
-                            self.add_operand(in_value);
-                        }
-                        InlineAsmOperand::Const { .. }
-                        | InlineAsmOperand::SymFn { .. }
-                        | InlineAsmOperand::SymStatic { .. }
-                        | InlineAsmOperand::Label { .. } => {}
-                    }
-                }
-            }
-            TerminatorKind::Goto { .. }
-            | TerminatorKind::UnwindResume
-            | TerminatorKind::UnwindTerminate(_)
-            | TerminatorKind::Return
-            | TerminatorKind::Unreachable { .. } => (),
-            TerminatorKind::Drop { .. } => {
-                // `Drop`s create a `&mut` and so are not considered
-            }
-            TerminatorKind::Yield { .. }
-            | TerminatorKind::CoroutineDrop
-            | TerminatorKind::FalseEdge { .. }
-            | TerminatorKind::FalseUnwind { .. } => {
-                bug!("{:?} not found in this MIR phase", terminator)
+    fn make_idempotent(&mut self) {
+        for l in self.renames.indices() {
+            let mut h = self.renames[l];
+            while let h2 = self.renames[h]
+                && h != h2
+            {
+                h = h2
             }
+            self.renames[l] = h;
+            debug_assert_eq!(h, self.renames[h], "non-idempotent for {l:?}");
         }
     }
+}
 
-    fn add_place(&mut self, place: Place<'_>) {
-        self.writes.push(place.local);
-    }
+/////////////////////////////////////////////////////
+// Candidate accumulation
+
+#[derive(Debug, Default)]
+struct Candidates {
+    /// The set of candidates we are considering in this optimization.
+    ///
+    /// We will always merge the key into at most one of its values.
+    ///
+    /// Whether a place ends up in the key or the value does not correspond to whether it appears as
+    /// the lhs or rhs of any assignment. As a matter of fact, the places in here might never appear
+    /// in an assignment at all. This happens because if we see an assignment like this:
+    ///
+    /// ```ignore (syntax-highlighting-only)
+    /// _1.0 = _2.0
+    /// ```
+    ///
+    /// We will still report that we would like to merge `_1` and `_2` in an attempt to allow us to
+    /// remove that assignment.
+    c: FxIndexMap<Local, Vec<Local>>,
+}
+
+// We first implement some utility functions which we will expose removing candidates according to
+// different needs. Throughout the liveness filtering, the `candidates` are only ever accessed
+// through these methods, and not directly.
+impl Candidates {
+    /// Collects the candidates for merging.
+    ///
+    /// This is responsible for enforcing the first and third bullet point.
+    fn find(body: &Body<'_>, borrowed: &DenseBitSet<Local>) -> Candidates {
+        let mut visitor = FindAssignments { body, candidates: Default::default(), borrowed };
+        visitor.visit_body(body);
 
-    fn add_operand<'tcx>(&mut self, op: &Operand<'tcx>) {
-        match op {
-            // FIXME(JakobDegen): In a previous version, the `Move` case was incorrectly treated as
-            // being a read only. This was unsound, however we cannot add a regression test because
-            // it is not possible to set this off with current MIR. Once we have that ability, a
-            // regression test should be added.
-            Operand::Move(p) => self.add_place(*p),
-            Operand::Copy(_) | Operand::Constant(_) => (),
+        // Deduplicate candidates.
+        for (_, cands) in visitor.candidates.iter_mut() {
+            cands.sort();
+            cands.dedup();
         }
-    }
 
-    fn reset(&mut self) {
-        self.writes.clear();
-        self.skip_pair = None;
+        Candidates { c: visitor.candidates }
     }
 }
 
-/////////////////////////////////////////////////////
-// Candidate accumulation
-
 /// If the pair of places is being considered for merging, returns the candidate which would be
 /// merged in order to accomplish this.
 ///
@@ -743,7 +440,7 @@ fn places_to_candidate_pair<'tcx>(
 
 struct FindAssignments<'a, 'tcx> {
     body: &'a Body<'tcx>,
-    candidates: &'a mut FxIndexMap<Local, Vec<Local>>,
+    candidates: FxIndexMap<Local, Vec<Local>>,
     borrowed: &'a DenseBitSet<Local>,
 }
 
@@ -803,22 +500,252 @@ fn dest_prop_mir_dump<'tcx>(
     tcx: TyCtxt<'tcx>,
     body: &Body<'tcx>,
     points: &DenseLocationMap,
-    live: &SparseIntervalMatrix<Local, PointIndex>,
-    round: usize,
+    live: &SparseIntervalMatrix<RelevantLocal, TwoStepIndex>,
+    relevant: &RelevantLocals,
 ) {
-    let locals_live_at = |location| {
+    let locals_live_at = |location, effect| {
         let location = points.point_from_location(location);
-        live.rows().filter(|&r| live.contains(r, location)).collect::<Vec<_>>()
+        let location = TwoStepIndex::new(location, effect);
+        live.rows()
+            .filter(|&r| live.contains(r, location))
+            .map(|rl| relevant.original[rl])
+            .collect::<Vec<_>>()
     };
 
     if let Some(dumper) = MirDumper::new(tcx, "DestinationPropagation-dataflow", body) {
         let extra_data = &|pass_where, w: &mut dyn std::io::Write| {
             if let PassWhere::BeforeLocation(loc) = pass_where {
-                writeln!(w, "        // live: {:?}", locals_live_at(loc))?;
+                writeln!(w, "        // before: {:?}", locals_live_at(loc, Effect::Before))?;
+            }
+            if let PassWhere::AfterLocation(loc) = pass_where {
+                writeln!(w, "        // after: {:?}", locals_live_at(loc, Effect::After))?;
             }
             Ok(())
         };
 
-        dumper.set_disambiguator(&round).set_extra_data(extra_data).dump_mir(body)
+        dumper.set_extra_data(extra_data).dump_mir(body)
+    }
+}
+
+struct MaybeTwoStepLiveLocals;
+
+#[derive(Copy, Clone, Debug)]
+enum Effect {
+    Before,
+    After,
+}
+
+rustc_index::newtype_index! {
+    /// A `PointIndex` but with the lower bit encoding early/late inside the statement.
+    #[orderable]
+    #[debug_format = "TwoStepIndex({})"]
+    struct TwoStepIndex {}
+}
+
+impl TwoStepIndex {
+    fn new(point: PointIndex, effect: Effect) -> TwoStepIndex {
+        let effect = match effect {
+            Effect::Before => 0,
+            Effect::After => 1,
+        };
+        TwoStepIndex::from_u32(2 * point.as_u32() + (effect as u32))
+    }
+}
+
+struct VisitPlacesWith<F>(F);
+
+impl<'tcx, F> Visitor<'tcx> for VisitPlacesWith<F>
+where
+    F: FnMut(Place<'tcx>, PlaceContext),
+{
+    fn visit_place(&mut self, place: &Place<'tcx>, ctxt: PlaceContext, _: Location) {
+        (self.0)(*place, ctxt);
+        for proj in place.projection.iter() {
+            match proj {
+                ProjectionElem::Index(index) => (self.0)(
+                    index.into(),
+                    PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy),
+                ),
+                ProjectionElem::Deref
+                | ProjectionElem::Field(..)
+                | ProjectionElem::Downcast(..)
+                | ProjectionElem::ConstantIndex { .. }
+                | ProjectionElem::Subslice { .. }
+                | ProjectionElem::OpaqueCast(..)
+                | ProjectionElem::UnwrapUnsafeBinder(..)
+                | ProjectionElem::Subtype(..) => {}
+            };
+        }
+    }
+}
+
+impl<'tcx> Analysis<'tcx> for MaybeTwoStepLiveLocals {
+    type Domain = DenseBitSet<Local>;
+    type Direction = Backward;
+
+    const NAME: &'static str = "transitive liveness";
+
+    fn bottom_value(&self, body: &Body<'tcx>) -> DenseBitSet<Local> {
+        // bottom = not live
+        DenseBitSet::new_empty(body.local_decls.len())
+    }
+
+    fn initialize_start_block(&self, _: &Body<'tcx>, _: &mut DenseBitSet<Local>) {
+        // No variables are live until we observe a use
+    }
+
+    // This happens between the previous statement and this one.
+    #[tracing::instrument(level = "trace", skip(self, statement))]
+    fn apply_primary_statement_effect(
+        &mut self,
+        state: &mut DenseBitSet<Local>,
+        statement: &Statement<'tcx>,
+        location: Location,
+    ) {
+        VisitPlacesWith(|place, ctxt| match DefUse::for_place(place, ctxt) {
+            DefUse::Def => {
+                state.remove(place.local);
+            }
+            DefUse::Use => {
+                state.insert(place.local);
+            }
+            DefUse::PartialWrite | DefUse::NonUse => {}
+        })
+        .visit_statement(statement, location);
+    }
+
+    // This happens between this statement and the next one.
+    #[tracing::instrument(level = "trace", skip(self, statement))]
+    fn apply_early_statement_effect(
+        &mut self,
+        state: &mut DenseBitSet<Local>,
+        statement: &Statement<'tcx>,
+        location: Location,
+    ) {
+        // We need to ensure we have a non-zero live range even for dead stores. This is done by
+        // marking all the writes locals as live in the second half of the statement.
+        VisitPlacesWith(|place: Place<'tcx>, ctxt| match DefUse::for_place(place, ctxt) {
+            DefUse::Def | DefUse::PartialWrite => {
+                state.insert(place.local);
+            }
+            // We already perform the reads in the first part of the statement. As statements are
+            // not splittable, we do not need to re-read the same values.
+            DefUse::Use | DefUse::NonUse => {}
+        })
+        .visit_statement(statement, location);
+    }
+
+    // We model terminator as a special case in this two-step analysis. Consider the terminator
+    // `destination = func(arg0...)`.
+    //
+    // -- state at (location, Effect::Before)
+    // read(arg0)...
+    // write(destination)
+    // -- state at (location, Effect::After)
+    // read(arg0)...
+
+    // This happens between the last statement and the terminator.
+    #[tracing::instrument(level = "trace", skip(self, terminator))]
+    fn apply_primary_terminator_effect<'mir>(
+        &mut self,
+        state: &mut DenseBitSet<Local>,
+        terminator: &'mir Terminator<'tcx>,
+        location: Location,
+    ) -> TerminatorEdges<'mir, 'tcx> {
+        // Consider that all writes in this terminator happen at the start of the execution of the
+        // terminator. For instance if we pass a return-pointer to a `Call` terminator.
+        VisitPlacesWith(|place: Place<'tcx>, ctxt| match DefUse::for_place(place, ctxt) {
+            DefUse::Def => {
+                state.remove(place.local);
+            }
+            DefUse::Use => {
+                state.insert(place.local);
+            }
+            DefUse::PartialWrite | DefUse::NonUse => {}
+        })
+        .visit_terminator(terminator, location);
+        terminator.edges()
+    }
+
+    // This happens between the terminator and the end of the block.
+    #[tracing::instrument(level = "trace", skip(self, terminator))]
+    fn apply_early_terminator_effect<'mir>(
+        &mut self,
+        state: &mut DenseBitSet<Local>,
+        terminator: &'mir Terminator<'tcx>,
+        location: Location,
+    ) {
+        // Consider that all reads in this terminator happen at the end of the execution of the
+        // terminator, even after it may have written to the destination local. For instance if we
+        // pass arguments as pointers to a `Call` terminator.
+        VisitPlacesWith(|place: Place<'tcx>, ctxt| match DefUse::for_place(place, ctxt) {
+            DefUse::Def | DefUse::Use | DefUse::PartialWrite => {
+                state.insert(place.local);
+            }
+            DefUse::NonUse => {}
+        })
+        .visit_terminator(terminator, location);
     }
 }
+
+/// Add points depending on the result of the given dataflow analysis.
+fn save_as_intervals<'tcx>(
+    elements: &DenseLocationMap,
+    body: &Body<'tcx>,
+    relevant: &IndexSlice<RelevantLocal, Local>,
+    results: Results<DenseBitSet<Local>>,
+) -> SparseIntervalMatrix<RelevantLocal, TwoStepIndex> {
+    let mut values = SparseIntervalMatrix::new(2 * elements.num_points());
+    let mut state = MaybeTwoStepLiveLocals.bottom_value(body);
+    let reachable_blocks = traversal::reachable_as_bitset(body);
+
+    let two_step_loc = |location, effect| {
+        let point = elements.point_from_location(location);
+        TwoStepIndex::new(point, effect)
+    };
+    let mut prepend_at = |state: &mut DenseBitSet<Local>, twostep| {
+        for (relevant, &original) in relevant.iter_enumerated() {
+            if state.contains(original) {
+                values.prepend(relevant, twostep);
+            }
+        }
+    };
+
+    // Iterate blocks in decreasing order, to visit locations in decreasing order. This
+    // allows to use the more efficient `prepend` method to interval sets.
+    for block in body.basic_blocks.indices().rev() {
+        if !reachable_blocks.contains(block) {
+            continue;
+        }
+
+        state.clone_from(&results[block]);
+
+        let block_data = &body.basic_blocks[block];
+        let loc = Location { block, statement_index: block_data.statements.len() };
+
+        let term = block_data.terminator();
+        let mut twostep = two_step_loc(loc, Effect::After);
+        MaybeTwoStepLiveLocals.apply_early_terminator_effect(&mut state, term, loc);
+        prepend_at(&mut state, twostep);
+
+        twostep = TwoStepIndex::from_u32(twostep.as_u32() - 1);
+        debug_assert_eq!(twostep, two_step_loc(loc, Effect::Before));
+        MaybeTwoStepLiveLocals.apply_primary_terminator_effect(&mut state, term, loc);
+        prepend_at(&mut state, twostep);
+
+        for (statement_index, stmt) in block_data.statements.iter().enumerate().rev() {
+            let loc = Location { block, statement_index };
+            twostep = TwoStepIndex::from_u32(twostep.as_u32() - 1);
+            debug_assert_eq!(twostep, two_step_loc(loc, Effect::After));
+            MaybeTwoStepLiveLocals.apply_early_statement_effect(&mut state, stmt, loc);
+            prepend_at(&mut state, twostep);
+
+            twostep = TwoStepIndex::from_u32(twostep.as_u32() - 1);
+            debug_assert_eq!(twostep, two_step_loc(loc, Effect::Before));
+            MaybeTwoStepLiveLocals.apply_primary_statement_effect(&mut state, stmt, loc);
+            prepend_at(&mut state, twostep);
+        }
+    }
+
+    values
+}
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 5d8aaedae3742..f9b8881ae3b15 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
@@ -9,15 +9,15 @@
       let mut _6: i32;
       scope 1 {
 -         debug x => _1;
-+         debug x => _6;
++         debug x => _4;
           let _2: i32;
           scope 2 {
 -             debug y => _2;
-+             debug y => _6;
++             debug y => _4;
               let _3: i32;
               scope 3 {
 -                 debug z => _3;
-+                 debug z => _6;
++                 debug z => _4;
               }
           }
       }
@@ -26,7 +26,7 @@
 -         StorageLive(_1);
 -         _1 = val() -> [return: bb1, unwind unreachable];
 +         nop;
-+         _6 = val() -> [return: bb1, unwind unreachable];
++         _4 = val() -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
@@ -47,16 +47,14 @@
 +         nop;
 +         nop;
           StorageLive(_5);
--         StorageLive(_6);
+          StorageLive(_6);
 -         _6 = copy _1;
-+         nop;
-+         nop;
++         _6 = copy _4;
           _5 = std::mem::drop::<i32>(move _6) -> [return: bb2, unwind unreachable];
       }
   
       bb2: {
--         StorageDead(_6);
-+         nop;
+          StorageDead(_6);
           StorageDead(_5);
           _0 = const ();
 -         StorageDead(_3);
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 05c9bcc1d7371..013e40ff462de 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
@@ -9,15 +9,15 @@
       let mut _6: i32;
       scope 1 {
 -         debug x => _1;
-+         debug x => _6;
++         debug x => _4;
           let _2: i32;
           scope 2 {
 -             debug y => _2;
-+             debug y => _6;
++             debug y => _4;
               let _3: i32;
               scope 3 {
 -                 debug z => _3;
-+                 debug z => _6;
++                 debug z => _4;
               }
           }
       }
@@ -26,7 +26,7 @@
 -         StorageLive(_1);
 -         _1 = val() -> [return: bb1, unwind continue];
 +         nop;
-+         _6 = val() -> [return: bb1, unwind continue];
++         _4 = val() -> [return: bb1, unwind continue];
       }
   
       bb1: {
@@ -47,16 +47,14 @@
 +         nop;
 +         nop;
           StorageLive(_5);
--         StorageLive(_6);
+          StorageLive(_6);
 -         _6 = copy _1;
-+         nop;
-+         nop;
++         _6 = copy _4;
           _5 = std::mem::drop::<i32>(move _6) -> [return: bb2, unwind continue];
       }
   
       bb2: {
--         StorageDead(_6);
-+         nop;
+          StorageDead(_6);
           StorageDead(_5);
           _0 = const ();
 -         StorageDead(_3);

From b9262bce67f6d924d17632bf5539e4745e7b3a29 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Mon, 18 Aug 2025 22:53:14 +0000
Subject: [PATCH 0621/1889] Use regular MaybeLiveLocals.

---
 compiler/rustc_index/src/interval.rs          |   7 +-
 compiler/rustc_mir_transform/src/dest_prop.rs | 181 +++++-------------
 tests/mir-opt/nrvo_miscompile_111005.rs       |   6 +-
 3 files changed, 58 insertions(+), 136 deletions(-)

diff --git a/compiler/rustc_index/src/interval.rs b/compiler/rustc_index/src/interval.rs
index 69a7a69610e04..e81e7e2bc442a 100644
--- a/compiler/rustc_index/src/interval.rs
+++ b/compiler/rustc_index/src/interval.rs
@@ -146,8 +146,11 @@ impl<I: Idx> IntervalSet<I> {
         let point = point.index() as u32;
 
         if let Some((first_start, _)) = self.map.first_mut() {
-            assert!(point < *first_start);
-            if point + 1 == *first_start {
+            assert!(point <= *first_start);
+            if point == *first_start {
+                // The point is already present in the set.
+            } else if point + 1 == *first_start {
+                // Just extend the first range.
                 *first_start = point;
             } else {
                 self.map.insert(0, (point, point));
diff --git a/compiler/rustc_mir_transform/src/dest_prop.rs b/compiler/rustc_mir_transform/src/dest_prop.rs
index da1d339b52658..aa9b0a961eada 100644
--- a/compiler/rustc_mir_transform/src/dest_prop.rs
+++ b/compiler/rustc_mir_transform/src/dest_prop.rs
@@ -140,13 +140,13 @@
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_index::bit_set::DenseBitSet;
 use rustc_index::interval::SparseIntervalMatrix;
-use rustc_index::{IndexSlice, IndexVec, newtype_index};
+use rustc_index::{IndexVec, newtype_index};
 use rustc_middle::mir::visit::{MutVisitor, NonMutatingUseContext, PlaceContext, Visitor};
 use rustc_middle::mir::*;
 use rustc_middle::ty::TyCtxt;
-use rustc_mir_dataflow::impls::DefUse;
+use rustc_mir_dataflow::impls::{DefUse, MaybeLiveLocals};
 use rustc_mir_dataflow::points::{DenseLocationMap, PointIndex};
-use rustc_mir_dataflow::{Analysis, Backward, Results};
+use rustc_mir_dataflow::{Analysis, Results};
 use tracing::{debug, trace};
 
 pub(super) struct DestinationPropagation;
@@ -177,12 +177,11 @@ impl<'tcx> crate::MirPass<'tcx> for DestinationPropagation {
             return;
         }
 
-        let live =
-            MaybeTwoStepLiveLocals.iterate_to_fixpoint(tcx, body, Some("MaybeLiveLocals-DestProp"));
+        let live = MaybeLiveLocals.iterate_to_fixpoint(tcx, body, Some("MaybeLiveLocals-DestProp"));
 
         let points = DenseLocationMap::new(body);
         let mut relevant = RelevantLocals::compute(&candidates, body.local_decls.len());
-        let mut live = save_as_intervals(&points, body, &relevant.original, live.results);
+        let mut live = save_as_intervals(&points, body, &relevant, live.results);
 
         dest_prop_mir_dump(tcx, body, &points, &live, &relevant);
 
@@ -527,8 +526,6 @@ fn dest_prop_mir_dump<'tcx>(
     }
 }
 
-struct MaybeTwoStepLiveLocals;
-
 #[derive(Copy, Clone, Debug)]
 enum Effect {
     Before,
@@ -579,137 +576,29 @@ where
     }
 }
 
-impl<'tcx> Analysis<'tcx> for MaybeTwoStepLiveLocals {
-    type Domain = DenseBitSet<Local>;
-    type Direction = Backward;
-
-    const NAME: &'static str = "transitive liveness";
-
-    fn bottom_value(&self, body: &Body<'tcx>) -> DenseBitSet<Local> {
-        // bottom = not live
-        DenseBitSet::new_empty(body.local_decls.len())
-    }
-
-    fn initialize_start_block(&self, _: &Body<'tcx>, _: &mut DenseBitSet<Local>) {
-        // No variables are live until we observe a use
-    }
-
-    // This happens between the previous statement and this one.
-    #[tracing::instrument(level = "trace", skip(self, statement))]
-    fn apply_primary_statement_effect(
-        &mut self,
-        state: &mut DenseBitSet<Local>,
-        statement: &Statement<'tcx>,
-        location: Location,
-    ) {
-        VisitPlacesWith(|place, ctxt| match DefUse::for_place(place, ctxt) {
-            DefUse::Def => {
-                state.remove(place.local);
-            }
-            DefUse::Use => {
-                state.insert(place.local);
-            }
-            DefUse::PartialWrite | DefUse::NonUse => {}
-        })
-        .visit_statement(statement, location);
-    }
-
-    // This happens between this statement and the next one.
-    #[tracing::instrument(level = "trace", skip(self, statement))]
-    fn apply_early_statement_effect(
-        &mut self,
-        state: &mut DenseBitSet<Local>,
-        statement: &Statement<'tcx>,
-        location: Location,
-    ) {
-        // We need to ensure we have a non-zero live range even for dead stores. This is done by
-        // marking all the writes locals as live in the second half of the statement.
-        VisitPlacesWith(|place: Place<'tcx>, ctxt| match DefUse::for_place(place, ctxt) {
-            DefUse::Def | DefUse::PartialWrite => {
-                state.insert(place.local);
-            }
-            // We already perform the reads in the first part of the statement. As statements are
-            // not splittable, we do not need to re-read the same values.
-            DefUse::Use | DefUse::NonUse => {}
-        })
-        .visit_statement(statement, location);
-    }
-
-    // We model terminator as a special case in this two-step analysis. Consider the terminator
-    // `destination = func(arg0...)`.
-    //
-    // -- state at (location, Effect::Before)
-    // read(arg0)...
-    // write(destination)
-    // -- state at (location, Effect::After)
-    // read(arg0)...
-
-    // This happens between the last statement and the terminator.
-    #[tracing::instrument(level = "trace", skip(self, terminator))]
-    fn apply_primary_terminator_effect<'mir>(
-        &mut self,
-        state: &mut DenseBitSet<Local>,
-        terminator: &'mir Terminator<'tcx>,
-        location: Location,
-    ) -> TerminatorEdges<'mir, 'tcx> {
-        // Consider that all writes in this terminator happen at the start of the execution of the
-        // terminator. For instance if we pass a return-pointer to a `Call` terminator.
-        VisitPlacesWith(|place: Place<'tcx>, ctxt| match DefUse::for_place(place, ctxt) {
-            DefUse::Def => {
-                state.remove(place.local);
-            }
-            DefUse::Use => {
-                state.insert(place.local);
-            }
-            DefUse::PartialWrite | DefUse::NonUse => {}
-        })
-        .visit_terminator(terminator, location);
-        terminator.edges()
-    }
-
-    // This happens between the terminator and the end of the block.
-    #[tracing::instrument(level = "trace", skip(self, terminator))]
-    fn apply_early_terminator_effect<'mir>(
-        &mut self,
-        state: &mut DenseBitSet<Local>,
-        terminator: &'mir Terminator<'tcx>,
-        location: Location,
-    ) {
-        // Consider that all reads in this terminator happen at the end of the execution of the
-        // terminator, even after it may have written to the destination local. For instance if we
-        // pass arguments as pointers to a `Call` terminator.
-        VisitPlacesWith(|place: Place<'tcx>, ctxt| match DefUse::for_place(place, ctxt) {
-            DefUse::Def | DefUse::Use | DefUse::PartialWrite => {
-                state.insert(place.local);
-            }
-            DefUse::NonUse => {}
-        })
-        .visit_terminator(terminator, location);
-    }
-}
-
 /// Add points depending on the result of the given dataflow analysis.
 fn save_as_intervals<'tcx>(
     elements: &DenseLocationMap,
     body: &Body<'tcx>,
-    relevant: &IndexSlice<RelevantLocal, Local>,
+    relevant: &RelevantLocals,
     results: Results<DenseBitSet<Local>>,
 ) -> SparseIntervalMatrix<RelevantLocal, TwoStepIndex> {
     let mut values = SparseIntervalMatrix::new(2 * elements.num_points());
-    let mut state = MaybeTwoStepLiveLocals.bottom_value(body);
+    let mut state = MaybeLiveLocals.bottom_value(body);
     let reachable_blocks = traversal::reachable_as_bitset(body);
 
     let two_step_loc = |location, effect| {
         let point = elements.point_from_location(location);
         TwoStepIndex::new(point, effect)
     };
-    let mut prepend_at = |state: &mut DenseBitSet<Local>, twostep| {
-        for (relevant, &original) in relevant.iter_enumerated() {
-            if state.contains(original) {
-                values.prepend(relevant, twostep);
+    let prepend_at =
+        |values: &mut SparseIntervalMatrix<_, _>, state: &DenseBitSet<Local>, twostep| {
+            for (relevant, &original) in relevant.original.iter_enumerated() {
+                if state.contains(original) {
+                    values.prepend(relevant, twostep);
+                }
             }
-        }
-    };
+        };
 
     // Iterate blocks in decreasing order, to visit locations in decreasing order. This
     // allows to use the more efficient `prepend` method to interval sets.
@@ -725,25 +614,51 @@ fn save_as_intervals<'tcx>(
 
         let term = block_data.terminator();
         let mut twostep = two_step_loc(loc, Effect::After);
-        MaybeTwoStepLiveLocals.apply_early_terminator_effect(&mut state, term, loc);
-        prepend_at(&mut state, twostep);
+        prepend_at(&mut values, &state, twostep);
+        // Ensure we have a non-zero live range even for dead stores. This is done by marking all
+        // the written-to locals as live in the second half of the statement.
+        // We also ensure that operands read by terminators conflict with writes by that terminator.
+        // For instance a function call may read args after having written to the destination.
+        VisitPlacesWith(|place, ctxt| match DefUse::for_place(place, ctxt) {
+            DefUse::Def | DefUse::Use | DefUse::PartialWrite => {
+                if let Some(relevant) = relevant.shrink[place.local] {
+                    values.insert(relevant, twostep);
+                }
+            }
+            DefUse::NonUse => {}
+        })
+        .visit_terminator(term, loc);
 
         twostep = TwoStepIndex::from_u32(twostep.as_u32() - 1);
         debug_assert_eq!(twostep, two_step_loc(loc, Effect::Before));
-        MaybeTwoStepLiveLocals.apply_primary_terminator_effect(&mut state, term, loc);
-        prepend_at(&mut state, twostep);
+        MaybeLiveLocals.apply_early_terminator_effect(&mut state, term, loc);
+        MaybeLiveLocals.apply_primary_terminator_effect(&mut state, term, loc);
+        prepend_at(&mut values, &state, twostep);
 
         for (statement_index, stmt) in block_data.statements.iter().enumerate().rev() {
             let loc = Location { block, statement_index };
             twostep = TwoStepIndex::from_u32(twostep.as_u32() - 1);
             debug_assert_eq!(twostep, two_step_loc(loc, Effect::After));
-            MaybeTwoStepLiveLocals.apply_early_statement_effect(&mut state, stmt, loc);
-            prepend_at(&mut state, twostep);
+            prepend_at(&mut values, &state, twostep);
+            // Ensure we have a non-zero live range even for dead stores. This is done by marking
+            // all the written-to locals as live in the second half of the statement.
+            VisitPlacesWith(|place, ctxt| match DefUse::for_place(place, ctxt) {
+                DefUse::Def | DefUse::PartialWrite => {
+                    if let Some(relevant) = relevant.shrink[place.local] {
+                        values.insert(relevant, twostep);
+                    }
+                }
+                DefUse::Use | DefUse::NonUse => {}
+            })
+            .visit_statement(stmt, loc);
 
             twostep = TwoStepIndex::from_u32(twostep.as_u32() - 1);
             debug_assert_eq!(twostep, two_step_loc(loc, Effect::Before));
-            MaybeTwoStepLiveLocals.apply_primary_statement_effect(&mut state, stmt, loc);
-            prepend_at(&mut state, twostep);
+            MaybeLiveLocals.apply_early_statement_effect(&mut state, stmt, loc);
+            MaybeLiveLocals.apply_primary_statement_effect(&mut state, stmt, loc);
+            // ... but reads from operands are marked as live here so they do not conflict with
+            // the all the writes we manually marked as live in the second half of the statement.
+            prepend_at(&mut values, &state, twostep);
         }
     }
 
diff --git a/tests/mir-opt/nrvo_miscompile_111005.rs b/tests/mir-opt/nrvo_miscompile_111005.rs
index 03008fa819156..131f7b8f6f991 100644
--- a/tests/mir-opt/nrvo_miscompile_111005.rs
+++ b/tests/mir-opt/nrvo_miscompile_111005.rs
@@ -1,4 +1,3 @@
-// skip-filecheck
 // This is a miscompilation, #111005 to track
 
 //@ test-mir-pass: RenameReturnPlace
@@ -10,6 +9,11 @@ use core::intrinsics::mir::*;
 // EMIT_MIR nrvo_miscompile_111005.wrong.RenameReturnPlace.diff
 #[custom_mir(dialect = "runtime", phase = "initial")]
 pub fn wrong(arg: char) -> char {
+    // CHECK-LABEL: fn wrong(
+    // CHECK: _0 = copy _1;
+    // FIXME: This is wrong:
+    // CHECK-NEXT: _0 = const 'b';
+    // CHECK-NEXT: return;
     mir! {
         {
             let temp = arg;

From de7c633ee5a20f938819033b1111777bd6496a3b Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Tue, 19 Aug 2025 23:27:06 +0000
Subject: [PATCH 0622/1889] Simplify VisitPlacesWith.

---
 compiler/rustc_mir_transform/src/dest_prop.rs | 25 ++++++-------------
 1 file changed, 7 insertions(+), 18 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/dest_prop.rs b/compiler/rustc_mir_transform/src/dest_prop.rs
index aa9b0a961eada..fde45229d520d 100644
--- a/compiler/rustc_mir_transform/src/dest_prop.rs
+++ b/compiler/rustc_mir_transform/src/dest_prop.rs
@@ -141,7 +141,7 @@ use rustc_data_structures::fx::FxIndexMap;
 use rustc_index::bit_set::DenseBitSet;
 use rustc_index::interval::SparseIntervalMatrix;
 use rustc_index::{IndexVec, newtype_index};
-use rustc_middle::mir::visit::{MutVisitor, NonMutatingUseContext, PlaceContext, Visitor};
+use rustc_middle::mir::visit::{MutVisitor, PlaceContext, Visitor};
 use rustc_middle::mir::*;
 use rustc_middle::ty::TyCtxt;
 use rustc_mir_dataflow::impls::{DefUse, MaybeLiveLocals};
@@ -555,24 +555,13 @@ impl<'tcx, F> Visitor<'tcx> for VisitPlacesWith<F>
 where
     F: FnMut(Place<'tcx>, PlaceContext),
 {
-    fn visit_place(&mut self, place: &Place<'tcx>, ctxt: PlaceContext, _: Location) {
+    fn visit_local(&mut self, local: Local, ctxt: PlaceContext, _: Location) {
+        (self.0)(local.into(), ctxt);
+    }
+
+    fn visit_place(&mut self, place: &Place<'tcx>, ctxt: PlaceContext, location: Location) {
         (self.0)(*place, ctxt);
-        for proj in place.projection.iter() {
-            match proj {
-                ProjectionElem::Index(index) => (self.0)(
-                    index.into(),
-                    PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy),
-                ),
-                ProjectionElem::Deref
-                | ProjectionElem::Field(..)
-                | ProjectionElem::Downcast(..)
-                | ProjectionElem::ConstantIndex { .. }
-                | ProjectionElem::Subslice { .. }
-                | ProjectionElem::OpaqueCast(..)
-                | ProjectionElem::UnwrapUnsafeBinder(..)
-                | ProjectionElem::Subtype(..) => {}
-            };
-        }
+        self.visit_projection(place.as_ref(), ctxt, location);
     }
 }
 

From 4e9dd1b67bf215865b95558ee4528ad43a5fd38c Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Fri, 22 Aug 2025 20:51:46 +0000
Subject: [PATCH 0623/1889] Do not use prepend to avoid quadratic behaviour.

---
 compiler/rustc_index/src/interval.rs          | 44 ++++------------
 compiler/rustc_mir_transform/src/dest_prop.rs | 51 ++++++++++---------
 2 files changed, 37 insertions(+), 58 deletions(-)

diff --git a/compiler/rustc_index/src/interval.rs b/compiler/rustc_index/src/interval.rs
index e81e7e2bc442a..dda5253e7c547 100644
--- a/compiler/rustc_index/src/interval.rs
+++ b/compiler/rustc_index/src/interval.rs
@@ -140,42 +140,20 @@ impl<I: Idx> IntervalSet<I> {
         result
     }
 
-    /// Specialized version of `insert` when we know that the inserted point is *before* any
-    /// contained.
-    pub fn prepend(&mut self, point: I) {
-        let point = point.index() as u32;
-
-        if let Some((first_start, _)) = self.map.first_mut() {
-            assert!(point <= *first_start);
-            if point == *first_start {
-                // The point is already present in the set.
-            } else if point + 1 == *first_start {
-                // Just extend the first range.
-                *first_start = point;
-            } else {
-                self.map.insert(0, (point, point));
-            }
-        } else {
-            // If the map is empty, push is faster than insert.
-            self.map.push((point, point));
-        }
-
-        debug_assert!(
-            self.check_invariants(),
-            "wrong intervals after prepend {point:?} to {self:?}"
-        );
-    }
-
     /// Specialized version of `insert` when we know that the inserted point is *after* any
     /// contained.
     pub fn append(&mut self, point: I) {
         let point = point.index() as u32;
 
-        if let Some((_, last_end)) = self.map.last_mut()
-            && let _ = assert!(*last_end < point)
-            && point == *last_end + 1
-        {
-            *last_end = point;
+        if let Some((_, last_end)) = self.map.last_mut() {
+            assert!(*last_end <= point);
+            if point == *last_end {
+                // The point is already in the set.
+            } else if point == *last_end + 1 {
+                *last_end = point;
+            } else {
+                self.map.push((point, point));
+            }
         } else {
             self.map.push((point, point));
         }
@@ -397,10 +375,6 @@ impl<R: Idx, C: Step + Idx> SparseIntervalMatrix<R, C> {
         self.ensure_row(row).insert(point)
     }
 
-    pub fn prepend(&mut self, row: R, point: C) {
-        self.ensure_row(row).prepend(point)
-    }
-
     pub fn append(&mut self, row: R, point: C) {
         self.ensure_row(row).append(point)
     }
diff --git a/compiler/rustc_mir_transform/src/dest_prop.rs b/compiler/rustc_mir_transform/src/dest_prop.rs
index fde45229d520d..7f2b786e4da5e 100644
--- a/compiler/rustc_mir_transform/src/dest_prop.rs
+++ b/compiler/rustc_mir_transform/src/dest_prop.rs
@@ -145,7 +145,7 @@ use rustc_middle::mir::visit::{MutVisitor, PlaceContext, Visitor};
 use rustc_middle::mir::*;
 use rustc_middle::ty::TyCtxt;
 use rustc_mir_dataflow::impls::{DefUse, MaybeLiveLocals};
-use rustc_mir_dataflow::points::{DenseLocationMap, PointIndex};
+use rustc_mir_dataflow::points::DenseLocationMap;
 use rustc_mir_dataflow::{Analysis, Results};
 use tracing::{debug, trace};
 
@@ -502,9 +502,7 @@ fn dest_prop_mir_dump<'tcx>(
     live: &SparseIntervalMatrix<RelevantLocal, TwoStepIndex>,
     relevant: &RelevantLocals,
 ) {
-    let locals_live_at = |location, effect| {
-        let location = points.point_from_location(location);
-        let location = TwoStepIndex::new(location, effect);
+    let locals_live_at = |location| {
         live.rows()
             .filter(|&r| live.contains(r, location))
             .map(|rl| relevant.original[rl])
@@ -514,10 +512,14 @@ fn dest_prop_mir_dump<'tcx>(
     if let Some(dumper) = MirDumper::new(tcx, "DestinationPropagation-dataflow", body) {
         let extra_data = &|pass_where, w: &mut dyn std::io::Write| {
             if let PassWhere::BeforeLocation(loc) = pass_where {
-                writeln!(w, "        // before: {:?}", locals_live_at(loc, Effect::Before))?;
+                let location = TwoStepIndex::new(points, loc, Effect::Before);
+                let live = locals_live_at(location);
+                writeln!(w, "        // before: {:?} => {:?}", location, live)?;
             }
             if let PassWhere::AfterLocation(loc) = pass_where {
-                writeln!(w, "        // after: {:?}", locals_live_at(loc, Effect::After))?;
+                let location = TwoStepIndex::new(points, loc, Effect::After);
+                let live = locals_live_at(location);
+                writeln!(w, "        // after: {:?} => {:?}", location, live)?;
             }
             Ok(())
         };
@@ -533,19 +535,25 @@ enum Effect {
 }
 
 rustc_index::newtype_index! {
-    /// A `PointIndex` but with the lower bit encoding early/late inside the statement.
+    /// A reversed `PointIndex` but with the lower bit encoding early/late inside the statement.
+    /// The reversed order allows to use the more efficient `IntervalSet::append` method while we
+    /// iterate on the statements in reverse order.
     #[orderable]
     #[debug_format = "TwoStepIndex({})"]
     struct TwoStepIndex {}
 }
 
 impl TwoStepIndex {
-    fn new(point: PointIndex, effect: Effect) -> TwoStepIndex {
+    fn new(elements: &DenseLocationMap, location: Location, effect: Effect) -> TwoStepIndex {
+        let point = elements.point_from_location(location);
         let effect = match effect {
             Effect::Before => 0,
             Effect::After => 1,
         };
-        TwoStepIndex::from_u32(2 * point.as_u32() + (effect as u32))
+        let max_index = 2 * elements.num_points() as u32 - 1;
+        let index = 2 * point.as_u32() + (effect as u32);
+        // Reverse the indexing to use more efficient `IntervalSet::append`.
+        TwoStepIndex::from_u32(max_index - index)
     }
 }
 
@@ -576,21 +584,18 @@ fn save_as_intervals<'tcx>(
     let mut state = MaybeLiveLocals.bottom_value(body);
     let reachable_blocks = traversal::reachable_as_bitset(body);
 
-    let two_step_loc = |location, effect| {
-        let point = elements.point_from_location(location);
-        TwoStepIndex::new(point, effect)
-    };
-    let prepend_at =
+    let two_step_loc = |location, effect| TwoStepIndex::new(elements, location, effect);
+    let append_at =
         |values: &mut SparseIntervalMatrix<_, _>, state: &DenseBitSet<Local>, twostep| {
             for (relevant, &original) in relevant.original.iter_enumerated() {
                 if state.contains(original) {
-                    values.prepend(relevant, twostep);
+                    values.append(relevant, twostep);
                 }
             }
         };
 
     // Iterate blocks in decreasing order, to visit locations in decreasing order. This
-    // allows to use the more efficient `prepend` method to interval sets.
+    // allows to use the more efficient `append` method to interval sets.
     for block in body.basic_blocks.indices().rev() {
         if !reachable_blocks.contains(block) {
             continue;
@@ -603,7 +608,7 @@ fn save_as_intervals<'tcx>(
 
         let term = block_data.terminator();
         let mut twostep = two_step_loc(loc, Effect::After);
-        prepend_at(&mut values, &state, twostep);
+        append_at(&mut values, &state, twostep);
         // Ensure we have a non-zero live range even for dead stores. This is done by marking all
         // the written-to locals as live in the second half of the statement.
         // We also ensure that operands read by terminators conflict with writes by that terminator.
@@ -618,17 +623,17 @@ fn save_as_intervals<'tcx>(
         })
         .visit_terminator(term, loc);
 
-        twostep = TwoStepIndex::from_u32(twostep.as_u32() - 1);
+        twostep = TwoStepIndex::from_u32(twostep.as_u32() + 1);
         debug_assert_eq!(twostep, two_step_loc(loc, Effect::Before));
         MaybeLiveLocals.apply_early_terminator_effect(&mut state, term, loc);
         MaybeLiveLocals.apply_primary_terminator_effect(&mut state, term, loc);
-        prepend_at(&mut values, &state, twostep);
+        append_at(&mut values, &state, twostep);
 
         for (statement_index, stmt) in block_data.statements.iter().enumerate().rev() {
             let loc = Location { block, statement_index };
-            twostep = TwoStepIndex::from_u32(twostep.as_u32() - 1);
+            twostep = TwoStepIndex::from_u32(twostep.as_u32() + 1);
             debug_assert_eq!(twostep, two_step_loc(loc, Effect::After));
-            prepend_at(&mut values, &state, twostep);
+            append_at(&mut values, &state, twostep);
             // Ensure we have a non-zero live range even for dead stores. This is done by marking
             // all the written-to locals as live in the second half of the statement.
             VisitPlacesWith(|place, ctxt| match DefUse::for_place(place, ctxt) {
@@ -641,13 +646,13 @@ fn save_as_intervals<'tcx>(
             })
             .visit_statement(stmt, loc);
 
-            twostep = TwoStepIndex::from_u32(twostep.as_u32() - 1);
+            twostep = TwoStepIndex::from_u32(twostep.as_u32() + 1);
             debug_assert_eq!(twostep, two_step_loc(loc, Effect::Before));
             MaybeLiveLocals.apply_early_statement_effect(&mut state, stmt, loc);
             MaybeLiveLocals.apply_primary_statement_effect(&mut state, stmt, loc);
             // ... but reads from operands are marked as live here so they do not conflict with
             // the all the writes we manually marked as live in the second half of the statement.
-            prepend_at(&mut values, &state, twostep);
+            append_at(&mut values, &state, twostep);
         }
     }
 

From 99f6bcf38065c78897a80c9fc7f8c49962df0ab7 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Tue, 26 Aug 2025 23:22:59 +0000
Subject: [PATCH 0624/1889] Unify a source with all possible destinations.

---
 compiler/rustc_mir_transform/src/dest_prop.rs | 98 ++++++++-----------
 ...in.DestinationPropagation.panic-abort.diff | 21 ++--
 ...n.DestinationPropagation.panic-unwind.diff | 21 ++--
 ...stinationPropagation.after.panic-abort.mir |  6 +-
 ...tinationPropagation.after.panic-unwind.mir |  6 +-
 ...stinationPropagation.after.panic-abort.mir |  6 +-
 ...tinationPropagation.after.panic-unwind.mir |  6 +-
 ...py.enum_clone_as_copy.PreCodegen.after.mir |  4 +-
 8 files changed, 75 insertions(+), 93 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/dest_prop.rs b/compiler/rustc_mir_transform/src/dest_prop.rs
index 7f2b786e4da5e..359cd622608fa 100644
--- a/compiler/rustc_mir_transform/src/dest_prop.rs
+++ b/compiler/rustc_mir_transform/src/dest_prop.rs
@@ -190,29 +190,51 @@ impl<'tcx> crate::MirPass<'tcx> for DestinationPropagation {
         for (src, candidates) in candidates.c.into_iter() {
             trace!(?src, ?candidates);
 
-            let Some(src) = relevant.find(src) else { continue };
-            let Some(src_live_ranges) = &live.row(src) else { continue };
-            trace!(?src, ?src_live_ranges);
-
-            let dst = candidates.into_iter().find_map(|dst| {
-                let dst = relevant.find(dst)?;
-                let dst_live_ranges = &live.row(dst)?;
+            for dst in candidates {
+                // We call `relevant.find(src)` inside the loop, as a previous iteration may have
+                // renamed `src` to one of the locals in `dst`.
+                let Some(mut src) = relevant.find(src) else { continue };
+                let Some(src_live_ranges) = live.row(src) else { continue };
+                trace!(?src, ?src_live_ranges);
+
+                let Some(mut dst) = relevant.find(dst) else { continue };
+                let Some(dst_live_ranges) = live.row(dst) else { continue };
                 trace!(?dst, ?dst_live_ranges);
 
-                let disjoint = src_live_ranges.disjoint(dst_live_ranges);
-                disjoint.then_some(dst)
-            });
-            let Some(dst) = dst else { continue };
+                if src_live_ranges.disjoint(dst_live_ranges) {
+                    // We want to replace `src` by `dst`.
+                    let mut orig_src = relevant.original[src];
+                    let mut orig_dst = relevant.original[dst];
+
+                    // The return place and function arguments are required and cannot be renamed.
+                    // This check cannot be made during candidate collection, as we may want to
+                    // unify the same non-required local with several required locals.
+                    match (is_local_required(orig_src, body), is_local_required(orig_dst, body)) {
+                        // Renaming `src` is ok.
+                        (false, _) => {}
+                        // Renaming `src` is wrong, but renaming `dst` is ok.
+                        (true, false) => {
+                            std::mem::swap(&mut src, &mut dst);
+                            std::mem::swap(&mut orig_src, &mut orig_dst);
+                        }
+                        // Neither local can be renamed, so skip this case.
+                        (true, true) => continue,
+                    }
 
-            merged_locals.insert(relevant.original[src]);
-            merged_locals.insert(relevant.original[dst]);
+                    trace!(?src, ?dst, "merge");
+                    merged_locals.insert(orig_src);
+                    merged_locals.insert(orig_dst);
 
-            relevant.union(src, dst);
-            live.union_rows(src, dst);
+                    // Replace `src` by `dst`.
+                    relevant.union(src, dst);
+                    live.union_rows(/* read */ src, /* write */ dst);
+                }
+            }
         }
         trace!(?merged_locals);
 
         relevant.make_idempotent();
+        trace!(?relevant.renames);
 
         if merged_locals.is_empty() {
             return;
@@ -402,41 +424,6 @@ impl Candidates {
     }
 }
 
-/// If the pair of places is being considered for merging, returns the candidate which would be
-/// merged in order to accomplish this.
-///
-/// The contract here is in one direction - there is a guarantee that merging the locals that are
-/// outputted by this function would result in an assignment between the inputs becoming a
-/// self-assignment. However, there is no guarantee that the returned pair is actually suitable for
-/// merging - candidate collection must still check this independently.
-///
-/// This output is unique for each unordered pair of input places.
-fn places_to_candidate_pair<'tcx>(
-    a: Place<'tcx>,
-    b: Place<'tcx>,
-    body: &Body<'tcx>,
-) -> Option<(Local, Local)> {
-    let (mut a, mut b) = if a.projection.len() == 0 && b.projection.len() == 0 {
-        (a.local, b.local)
-    } else {
-        return None;
-    };
-
-    // By sorting, we make sure we're input order independent
-    if a > b {
-        std::mem::swap(&mut a, &mut b);
-    }
-
-    // We could now return `(a, b)`, but then we miss some candidates in the case where `a` can't be
-    // used as a `src`.
-    if is_local_required(a, body) {
-        std::mem::swap(&mut a, &mut b);
-    }
-    // We could check `is_local_required` again here, but there's no need - after all, we make no
-    // promise that the candidate pair is actually valid
-    Some((a, b))
-}
-
 struct FindAssignments<'a, 'tcx> {
     body: &'a Body<'tcx>,
     candidates: FxIndexMap<Local, Vec<Local>>,
@@ -449,11 +436,9 @@ impl<'tcx> Visitor<'tcx> for FindAssignments<'_, 'tcx> {
             lhs,
             Rvalue::CopyForDeref(rhs) | Rvalue::Use(Operand::Copy(rhs) | Operand::Move(rhs)),
         )) = &statement.kind
+            && let Some(src) = lhs.as_local()
+            && let Some(dest) = rhs.as_local()
         {
-            let Some((src, dest)) = places_to_candidate_pair(*lhs, *rhs, self.body) else {
-                return;
-            };
-
             // As described at the top of the file, we do not go near things that have
             // their address taken.
             if self.borrowed.contains(src) || self.borrowed.contains(dest) {
@@ -470,11 +455,6 @@ impl<'tcx> Visitor<'tcx> for FindAssignments<'_, 'tcx> {
                 return;
             }
 
-            // Also, we need to make sure that MIR actually allows the `src` to be removed
-            if is_local_required(src, self.body) {
-                return;
-            }
-
             // We may insert duplicates here, but that's fine
             self.candidates.entry(src).or_default().push(dest);
         }
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 f9b8881ae3b15..a2f10be31a9e8 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
@@ -8,25 +8,23 @@
       let _5: ();
       let mut _6: i32;
       scope 1 {
--         debug x => _1;
-+         debug x => _4;
+          debug x => _1;
           let _2: i32;
           scope 2 {
 -             debug y => _2;
-+             debug y => _4;
++             debug y => _1;
               let _3: i32;
               scope 3 {
 -                 debug z => _3;
-+                 debug z => _4;
++                 debug z => _1;
               }
           }
       }
   
       bb0: {
 -         StorageLive(_1);
--         _1 = val() -> [return: bb1, unwind unreachable];
 +         nop;
-+         _4 = val() -> [return: bb1, unwind unreachable];
+          _1 = val() -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
@@ -47,14 +45,17 @@
 +         nop;
 +         nop;
           StorageLive(_5);
-          StorageLive(_6);
+-         StorageLive(_6);
 -         _6 = copy _1;
-+         _6 = copy _4;
-          _5 = std::mem::drop::<i32>(move _6) -> [return: bb2, unwind unreachable];
+-         _5 = std::mem::drop::<i32>(move _6) -> [return: bb2, unwind unreachable];
++         nop;
++         nop;
++         _5 = std::mem::drop::<i32>(move _1) -> [return: bb2, unwind unreachable];
       }
   
       bb2: {
-          StorageDead(_6);
+-         StorageDead(_6);
++         nop;
           StorageDead(_5);
           _0 = const ();
 -         StorageDead(_3);
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 013e40ff462de..a08488615b15a 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
@@ -8,25 +8,23 @@
       let _5: ();
       let mut _6: i32;
       scope 1 {
--         debug x => _1;
-+         debug x => _4;
+          debug x => _1;
           let _2: i32;
           scope 2 {
 -             debug y => _2;
-+             debug y => _4;
++             debug y => _1;
               let _3: i32;
               scope 3 {
 -                 debug z => _3;
-+                 debug z => _4;
++                 debug z => _1;
               }
           }
       }
   
       bb0: {
 -         StorageLive(_1);
--         _1 = val() -> [return: bb1, unwind continue];
 +         nop;
-+         _4 = val() -> [return: bb1, unwind continue];
+          _1 = val() -> [return: bb1, unwind continue];
       }
   
       bb1: {
@@ -47,14 +45,17 @@
 +         nop;
 +         nop;
           StorageLive(_5);
-          StorageLive(_6);
+-         StorageLive(_6);
 -         _6 = copy _1;
-+         _6 = copy _4;
-          _5 = std::mem::drop::<i32>(move _6) -> [return: bb2, unwind continue];
+-         _5 = std::mem::drop::<i32>(move _6) -> [return: bb2, unwind continue];
++         nop;
++         nop;
++         _5 = std::mem::drop::<i32>(move _1) -> [return: bb2, unwind continue];
       }
   
       bb2: {
-          StorageDead(_6);
+-         StorageDead(_6);
++         nop;
           StorageDead(_5);
           _0 = const ();
 -         StorageDead(_3);
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 eb4209731c62f..15061da812063 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
@@ -7,16 +7,16 @@ fn f(_1: usize) -> usize {
     let mut _3: usize;
     let mut _4: usize;
     scope 1 {
-        debug b => _3;
+        debug b => _2;
     }
 
     bb0: {
         nop;
-        _3 = copy _1;
+        _2 = copy _1;
         _1 = const 5_usize;
         nop;
         nop;
-        _1 = move _3;
+        _1 = move _2;
         nop;
         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 fe9a7376a5856..ddfe4dc5b3ebf 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
@@ -7,16 +7,16 @@ fn f(_1: usize) -> usize {
     let mut _3: usize;
     let mut _4: usize;
     scope 1 {
-        debug b => _3;
+        debug b => _2;
     }
 
     bb0: {
         nop;
-        _3 = copy _1;
+        _2 = copy _1;
         _1 = const 5_usize;
         nop;
         nop;
-        _1 = move _3;
+        _1 = move _2;
         nop;
         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 eb4209731c62f..15061da812063 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
@@ -7,16 +7,16 @@ fn f(_1: usize) -> usize {
     let mut _3: usize;
     let mut _4: usize;
     scope 1 {
-        debug b => _3;
+        debug b => _2;
     }
 
     bb0: {
         nop;
-        _3 = copy _1;
+        _2 = copy _1;
         _1 = const 5_usize;
         nop;
         nop;
-        _1 = move _3;
+        _1 = move _2;
         nop;
         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 fe9a7376a5856..ddfe4dc5b3ebf 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
@@ -7,16 +7,16 @@ fn f(_1: usize) -> usize {
     let mut _3: usize;
     let mut _4: usize;
     scope 1 {
-        debug b => _3;
+        debug b => _2;
     }
 
     bb0: {
         nop;
-        _3 = copy _1;
+        _2 = copy _1;
         _1 = const 5_usize;
         nop;
         nop;
-        _1 = move _3;
+        _1 = move _2;
         nop;
         nop;
         nop;
diff --git a/tests/mir-opt/pre-codegen/clone_as_copy.enum_clone_as_copy.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/clone_as_copy.enum_clone_as_copy.PreCodegen.after.mir
index 9f88e1961ec88..e67f362ee04ae 100644
--- a/tests/mir-opt/pre-codegen/clone_as_copy.enum_clone_as_copy.PreCodegen.after.mir
+++ b/tests/mir-opt/pre-codegen/clone_as_copy.enum_clone_as_copy.PreCodegen.after.mir
@@ -6,8 +6,8 @@ fn enum_clone_as_copy(_1: &Enum1) -> Enum1 {
     scope 1 (inlined <Enum1 as Clone>::clone) {
         debug self => _1;
         let mut _2: isize;
-        let mut _3: &AllCopy;
-        let mut _4: &NestCopy;
+        let _3: &AllCopy;
+        let _4: &NestCopy;
         scope 2 {
             debug __self_0 => _3;
             scope 6 (inlined <AllCopy as Clone>::clone) {

From 28ff5cf502a0132a4eed8aa46fa7371c7e7ed3f1 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Tue, 26 Aug 2025 23:38:45 +0000
Subject: [PATCH 0625/1889] Simplify candidate collection.

---
 compiler/rustc_mir_transform/src/dest_prop.rs | 98 ++++++++-----------
 1 file changed, 43 insertions(+), 55 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/dest_prop.rs b/compiler/rustc_mir_transform/src/dest_prop.rs
index 359cd622608fa..b6306c4869bd9 100644
--- a/compiler/rustc_mir_transform/src/dest_prop.rs
+++ b/compiler/rustc_mir_transform/src/dest_prop.rs
@@ -137,7 +137,6 @@
 //! [attempt 3]: https://github.com/rust-lang/rust/pull/72632
 //! [attempt 4]: https://github.com/rust-lang/rust/pull/96451
 
-use rustc_data_structures::fx::FxIndexMap;
 use rustc_index::bit_set::DenseBitSet;
 use rustc_index::interval::SparseIntervalMatrix;
 use rustc_index::{IndexVec, newtype_index};
@@ -187,48 +186,47 @@ impl<'tcx> crate::MirPass<'tcx> for DestinationPropagation {
 
         let mut merged_locals = DenseBitSet::new_empty(body.local_decls.len());
 
-        for (src, candidates) in candidates.c.into_iter() {
-            trace!(?src, ?candidates);
-
-            for dst in candidates {
-                // We call `relevant.find(src)` inside the loop, as a previous iteration may have
-                // renamed `src` to one of the locals in `dst`.
-                let Some(mut src) = relevant.find(src) else { continue };
-                let Some(src_live_ranges) = live.row(src) else { continue };
-                trace!(?src, ?src_live_ranges);
-
-                let Some(mut dst) = relevant.find(dst) else { continue };
-                let Some(dst_live_ranges) = live.row(dst) else { continue };
-                trace!(?dst, ?dst_live_ranges);
-
-                if src_live_ranges.disjoint(dst_live_ranges) {
-                    // We want to replace `src` by `dst`.
-                    let mut orig_src = relevant.original[src];
-                    let mut orig_dst = relevant.original[dst];
-
-                    // The return place and function arguments are required and cannot be renamed.
-                    // This check cannot be made during candidate collection, as we may want to
-                    // unify the same non-required local with several required locals.
-                    match (is_local_required(orig_src, body), is_local_required(orig_dst, body)) {
-                        // Renaming `src` is ok.
-                        (false, _) => {}
-                        // Renaming `src` is wrong, but renaming `dst` is ok.
-                        (true, false) => {
-                            std::mem::swap(&mut src, &mut dst);
-                            std::mem::swap(&mut orig_src, &mut orig_dst);
-                        }
-                        // Neither local can be renamed, so skip this case.
-                        (true, true) => continue,
-                    }
+        for (src, dst) in candidates.c.into_iter() {
+            trace!(?src, ?dst);
 
-                    trace!(?src, ?dst, "merge");
-                    merged_locals.insert(orig_src);
-                    merged_locals.insert(orig_dst);
+            let Some(mut src) = relevant.find(src) else { continue };
+            let Some(mut dst) = relevant.find(dst) else { continue };
+            if src == dst {
+                continue;
+            }
 
-                    // Replace `src` by `dst`.
-                    relevant.union(src, dst);
-                    live.union_rows(/* read */ src, /* write */ dst);
+            let Some(src_live_ranges) = live.row(src) else { continue };
+            let Some(dst_live_ranges) = live.row(dst) else { continue };
+            trace!(?src, ?src_live_ranges);
+            trace!(?dst, ?dst_live_ranges);
+
+            if src_live_ranges.disjoint(dst_live_ranges) {
+                // We want to replace `src` by `dst`.
+                let mut orig_src = relevant.original[src];
+                let mut orig_dst = relevant.original[dst];
+
+                // The return place and function arguments are required and cannot be renamed.
+                // This check cannot be made during candidate collection, as we may want to
+                // unify the same non-required local with several required locals.
+                match (is_local_required(orig_src, body), is_local_required(orig_dst, body)) {
+                    // Renaming `src` is ok.
+                    (false, _) => {}
+                    // Renaming `src` is wrong, but renaming `dst` is ok.
+                    (true, false) => {
+                        std::mem::swap(&mut src, &mut dst);
+                        std::mem::swap(&mut orig_src, &mut orig_dst);
+                    }
+                    // Neither local can be renamed, so skip this case.
+                    (true, true) => continue,
                 }
+
+                trace!(?src, ?dst, "merge");
+                merged_locals.insert(orig_src);
+                merged_locals.insert(orig_dst);
+
+                // Replace `src` by `dst`.
+                relevant.union(src, dst);
+                live.union_rows(/* read */ src, /* write */ dst);
             }
         }
         trace!(?merged_locals);
@@ -342,11 +340,9 @@ impl RelevantLocals {
             shrink.get_or_insert_with(local, || original.push(local));
         };
 
-        for (&src, destinations) in candidates.c.iter() {
+        for &(src, dest) in candidates.c.iter() {
             declare(src);
-            for &dest in destinations {
-                declare(dest)
-            }
+            declare(dest)
         }
 
         let renames = IndexVec::from_fn_n(|l| l, original.len());
@@ -388,8 +384,6 @@ impl RelevantLocals {
 struct Candidates {
     /// The set of candidates we are considering in this optimization.
     ///
-    /// We will always merge the key into at most one of its values.
-    ///
     /// Whether a place ends up in the key or the value does not correspond to whether it appears as
     /// the lhs or rhs of any assignment. As a matter of fact, the places in here might never appear
     /// in an assignment at all. This happens because if we see an assignment like this:
@@ -400,7 +394,7 @@ struct Candidates {
     ///
     /// We will still report that we would like to merge `_1` and `_2` in an attempt to allow us to
     /// remove that assignment.
-    c: FxIndexMap<Local, Vec<Local>>,
+    c: Vec<(Local, Local)>,
 }
 
 // We first implement some utility functions which we will expose removing candidates according to
@@ -414,19 +408,13 @@ impl Candidates {
         let mut visitor = FindAssignments { body, candidates: Default::default(), borrowed };
         visitor.visit_body(body);
 
-        // Deduplicate candidates.
-        for (_, cands) in visitor.candidates.iter_mut() {
-            cands.sort();
-            cands.dedup();
-        }
-
         Candidates { c: visitor.candidates }
     }
 }
 
 struct FindAssignments<'a, 'tcx> {
     body: &'a Body<'tcx>,
-    candidates: FxIndexMap<Local, Vec<Local>>,
+    candidates: Vec<(Local, Local)>,
     borrowed: &'a DenseBitSet<Local>,
 }
 
@@ -456,7 +444,7 @@ impl<'tcx> Visitor<'tcx> for FindAssignments<'_, 'tcx> {
             }
 
             // We may insert duplicates here, but that's fine
-            self.candidates.entry(src).or_default().push(dest);
+            self.candidates.push((src, dest));
         }
     }
 }

From 5d0e66d451b0da5e7a712d5f9e041e5bbbbb0255 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Wed, 27 Aug 2025 01:40:16 +0000
Subject: [PATCH 0626/1889] Use rustc_data_structures::union_find.

---
 compiler/rustc_mir_transform/src/dest_prop.rs | 42 +++++++------------
 1 file changed, 14 insertions(+), 28 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/dest_prop.rs b/compiler/rustc_mir_transform/src/dest_prop.rs
index b6306c4869bd9..9ba2d274691de 100644
--- a/compiler/rustc_mir_transform/src/dest_prop.rs
+++ b/compiler/rustc_mir_transform/src/dest_prop.rs
@@ -137,6 +137,7 @@
 //! [attempt 3]: https://github.com/rust-lang/rust/pull/72632
 //! [attempt 4]: https://github.com/rust-lang/rust/pull/96451
 
+use rustc_data_structures::union_find::UnionFind;
 use rustc_index::bit_set::DenseBitSet;
 use rustc_index::interval::SparseIntervalMatrix;
 use rustc_index::{IndexVec, newtype_index};
@@ -225,13 +226,12 @@ impl<'tcx> crate::MirPass<'tcx> for DestinationPropagation {
                 merged_locals.insert(orig_dst);
 
                 // Replace `src` by `dst`.
-                relevant.union(src, dst);
-                live.union_rows(/* read */ src, /* write */ dst);
+                let head = relevant.union(src, dst);
+                live.union_rows(/* read */ src, /* write */ head);
+                live.union_rows(/* read */ dst, /* write */ head);
             }
         }
         trace!(?merged_locals);
-
-        relevant.make_idempotent();
         trace!(?relevant.renames);
 
         if merged_locals.is_empty() {
@@ -326,7 +326,7 @@ newtype_index! {
 struct RelevantLocals {
     original: IndexVec<RelevantLocal, Local>,
     shrink: IndexVec<Local, Option<RelevantLocal>>,
-    renames: IndexVec<RelevantLocal, RelevantLocal>,
+    renames: UnionFind<RelevantLocal>,
 }
 
 impl RelevantLocals {
@@ -345,35 +345,21 @@ impl RelevantLocals {
             declare(dest)
         }
 
-        let renames = IndexVec::from_fn_n(|l| l, original.len());
+        let renames = UnionFind::new(original.len());
         RelevantLocals { original, shrink, renames }
     }
 
-    fn find(&self, src: Local) -> Option<RelevantLocal> {
-        let mut src = self.shrink[src]?;
-        while let s2 = self.renames[src]
-            && src != s2
-        {
-            src = s2
-        }
+    fn find(&mut self, src: Local) -> Option<RelevantLocal> {
+        let src = self.shrink[src]?;
+        let src = self.renames.find(src);
         Some(src)
     }
 
-    fn union(&mut self, lhs: RelevantLocal, rhs: RelevantLocal) {
-        self.renames[lhs] = rhs;
-    }
-
-    fn make_idempotent(&mut self) {
-        for l in self.renames.indices() {
-            let mut h = self.renames[l];
-            while let h2 = self.renames[h]
-                && h != h2
-            {
-                h = h2
-            }
-            self.renames[l] = h;
-            debug_assert_eq!(h, self.renames[h], "non-idempotent for {l:?}");
-        }
+    fn union(&mut self, lhs: RelevantLocal, rhs: RelevantLocal) -> RelevantLocal {
+        let head = self.renames.unify(lhs, rhs);
+        // We need to ensure we keep the original local of the RHS, as it may be a required local.
+        self.original[head] = self.original[rhs];
+        head
     }
 }
 

From a2d66db9badf35d4ad31323b0f5e6132d56f9391 Mon Sep 17 00:00:00 2001
From: Kivooeo <Kivooeo123@gmail.com>
Date: Sat, 6 Sep 2025 17:47:54 +0000
Subject: [PATCH 0627/1889] remove unsused div_rem method from bignum

---
 library/core/src/num/bignum.rs        | 37 ---------------------------
 library/coretests/tests/num/bignum.rs | 19 --------------
 2 files changed, 56 deletions(-)

diff --git a/library/core/src/num/bignum.rs b/library/core/src/num/bignum.rs
index e33f58197bba5..f21fe0b4438fb 100644
--- a/library/core/src/num/bignum.rs
+++ b/library/core/src/num/bignum.rs
@@ -335,43 +335,6 @@ macro_rules! define_bignum {
                 }
                 (self, borrow)
             }
-
-            /// Divide self by another bignum, overwriting `q` with the quotient and `r` with the
-            /// remainder.
-            pub fn div_rem(&self, d: &$name, q: &mut $name, r: &mut $name) {
-                // Stupid slow base-2 long division taken from
-                // https://en.wikipedia.org/wiki/Division_algorithm
-                // FIXME use a greater base ($ty) for the long division.
-                assert!(!d.is_zero());
-                let digitbits = <$ty>::BITS as usize;
-                for digit in &mut q.base[..] {
-                    *digit = 0;
-                }
-                for digit in &mut r.base[..] {
-                    *digit = 0;
-                }
-                r.size = d.size;
-                q.size = 1;
-                let mut q_is_zero = true;
-                let end = self.bit_length();
-                for i in (0..end).rev() {
-                    r.mul_pow2(1);
-                    r.base[0] |= self.get_bit(i) as $ty;
-                    if &*r >= d {
-                        r.sub(d);
-                        // Set bit `i` of q to 1.
-                        let digit_idx = i / digitbits;
-                        let bit_idx = i % digitbits;
-                        if q_is_zero {
-                            q.size = digit_idx + 1;
-                            q_is_zero = false;
-                        }
-                        q.base[digit_idx] |= 1 << bit_idx;
-                    }
-                }
-                debug_assert!(q.base[q.size..].iter().all(|&d| d == 0));
-                debug_assert!(r.base[r.size..].iter().all(|&d| d == 0));
-            }
         }
 
         impl crate::cmp::PartialEq for $name {
diff --git a/library/coretests/tests/num/bignum.rs b/library/coretests/tests/num/bignum.rs
index f213fd5366cbf..6dfa496e018bf 100644
--- a/library/coretests/tests/num/bignum.rs
+++ b/library/coretests/tests/num/bignum.rs
@@ -167,25 +167,6 @@ fn test_div_rem_small() {
     );
 }
 
-#[test]
-fn test_div_rem() {
-    fn div_rem(n: u64, d: u64) -> (Big, Big) {
-        let mut q = Big::from_small(42);
-        let mut r = Big::from_small(42);
-        Big::from_u64(n).div_rem(&Big::from_u64(d), &mut q, &mut r);
-        (q, r)
-    }
-    assert_eq!(div_rem(1, 1), (Big::from_small(1), Big::from_small(0)));
-    assert_eq!(div_rem(4, 3), (Big::from_small(1), Big::from_small(1)));
-    assert_eq!(div_rem(1, 7), (Big::from_small(0), Big::from_small(1)));
-    assert_eq!(div_rem(45, 9), (Big::from_small(5), Big::from_small(0)));
-    assert_eq!(div_rem(103, 9), (Big::from_small(11), Big::from_small(4)));
-    assert_eq!(div_rem(123456, 77), (Big::from_u64(1603), Big::from_small(25)));
-    assert_eq!(div_rem(0xffff, 1), (Big::from_u64(0xffff), Big::from_small(0)));
-    assert_eq!(div_rem(0xeeee, 0xffff), (Big::from_small(0), Big::from_u64(0xeeee)));
-    assert_eq!(div_rem(2_000_000, 2), (Big::from_u64(1_000_000), Big::from_u64(0)));
-}
-
 #[test]
 fn test_is_zero() {
     assert!(Big::from_small(0).is_zero());

From 380c906bebfb4e2c8f6672870952505e4a92c577 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Mon, 8 Sep 2025 06:07:20 +1000
Subject: [PATCH 0628/1889] Minor symbol comment fixes.

- The empty symbol is no longer a keyword.
- I don't think any of the special reserved identifiers are used for
  error recovery.
---
 compiler/rustc_span/src/symbol.rs | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index e5108d8b7e921..02bf3595279ce 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -21,18 +21,17 @@ mod tests;
 
 // The proc macro code for this is in `compiler/rustc_macros/src/symbols.rs`.
 symbols! {
-    // This list includes things that are definitely keywords (e.g. `if`),
-    // a few things that are definitely not keywords (e.g. the empty symbol,
-    // `{{root}}`) and things where there is disagreement between people and/or
-    // documents (such as the Rust Reference) about whether it is a keyword
-    // (e.g. `_`).
+    // This list includes things that are definitely keywords (e.g. `if`), a
+    // few things that are definitely not keywords (e.g. `{{root}}`) and things
+    // where there is disagreement between people and/or documents (such as the
+    // Rust Reference) about whether it is a keyword (e.g. `_`).
     //
     // If you modify this list, adjust any relevant `Symbol::{is,can_be}_*`
     // predicates and `used_keywords`. Also consider adding new keywords to the
     // `ui/parser/raw/raw-idents.rs` test.
     Keywords {
-        // Special reserved identifiers used internally for elided lifetimes,
-        // unnamed method parameters, crate root module, error recovery etc.
+        // Special reserved identifiers used internally for unnamed method
+        // parameters, crate root module, etc.
         // Matching predicates: `is_special`/`is_reserved`
         //
         // tidy-alphabetical-start

From 1cb749aa3b421db4f918e8befca569166e8ba6ab Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Sun, 7 Sep 2025 21:26:24 +0200
Subject: [PATCH 0629/1889] support integer literals in `${concat()}`

---
 compiler/rustc_expand/src/mbe/transcribe.rs   | 18 ++++++++-
 .../concat-allowed-operations.rs              | 18 +++++++++
 .../concat-usage-errors.rs                    | 10 +++--
 .../concat-usage-errors.stderr                | 40 ++++++++++---------
 4 files changed, 62 insertions(+), 24 deletions(-)

diff --git a/compiler/rustc_expand/src/mbe/transcribe.rs b/compiler/rustc_expand/src/mbe/transcribe.rs
index e4e4866b64cdf..ed8aa71d59dda 100644
--- a/compiler/rustc_expand/src/mbe/transcribe.rs
+++ b/compiler/rustc_expand/src/mbe/transcribe.rs
@@ -940,11 +940,27 @@ fn extract_symbol_from_pnr<'a>(
         {
             Ok(*symbol)
         }
+        ParseNtResult::Literal(expr)
+            if let ExprKind::Lit(lit @ Lit { kind: LitKind::Integer, symbol, suffix }) =
+                &expr.kind =>
+        {
+            if lit.is_semantic_float() {
+                Err(dcx
+                    .struct_err("floats are not supported as metavariables of `${concat(..)}`")
+                    .with_span(span_err))
+            } else if suffix.is_none() {
+                Ok(*symbol)
+            } else {
+                Err(dcx
+                    .struct_err("integer metavariables of `${concat(..)}` must not be suffixed")
+                    .with_span(span_err))
+            }
+        }
         _ => Err(dcx
             .struct_err(
                 "metavariables of `${concat(..)}` must be of type `ident`, `literal` or `tt`",
             )
-            .with_note("currently only string literals are supported")
+            .with_note("currently only string and integer literals are supported")
             .with_span(span_err)),
     }
 }
diff --git a/tests/ui/macros/metavar-expressions/concat-allowed-operations.rs b/tests/ui/macros/metavar-expressions/concat-allowed-operations.rs
index 695a752fe17d4..5ac50c943d030 100644
--- a/tests/ui/macros/metavar-expressions/concat-allowed-operations.rs
+++ b/tests/ui/macros/metavar-expressions/concat-allowed-operations.rs
@@ -92,6 +92,12 @@ macro_rules! combinations {
     }};
 }
 
+macro_rules! int_struct {
+    ($n: literal) => {
+        struct ${concat(E, $n)};
+    }
+}
+
 fn main() {
     create_things!(behold);
     behold_separated_idents_in_a_fn();
@@ -112,4 +118,16 @@ fn main() {
     assert_eq!(VAR_123, 2);
 
     combinations!(_hello, "a", b, "b");
+
+    int_struct!(1_0);
+    int_struct!(2);
+    int_struct!(3___0);
+    int_struct!(7_);
+    int_struct!(08);
+
+    let _ = E1_0;
+    let _ = E2;
+    let _ = E3___0;
+    let _ = E7_;
+    let _ = E08;
 }
diff --git a/tests/ui/macros/metavar-expressions/concat-usage-errors.rs b/tests/ui/macros/metavar-expressions/concat-usage-errors.rs
index 7d8756de9e20b..277ad240b1bf2 100644
--- a/tests/ui/macros/metavar-expressions/concat-usage-errors.rs
+++ b/tests/ui/macros/metavar-expressions/concat-usage-errors.rs
@@ -140,7 +140,9 @@ macro_rules! bad_literal_non_string {
         //~| ERROR metavariables of `${concat(..)}` must be of type
         //~| ERROR metavariables of `${concat(..)}` must be of type
         //~| ERROR metavariables of `${concat(..)}` must be of type
-        //~| ERROR metavariables of `${concat(..)}` must be of type
+        //~| ERROR floats are not supported as metavariables of `${concat(..)}`
+        //~| ERROR integer metavariables of `${concat(..)}` must not be suffixed
+        //~| ERROR integer metavariables of `${concat(..)}` must not be suffixed
     }
 }
 
@@ -149,7 +151,6 @@ macro_rules! bad_tt_literal {
         const ${concat(_foo, $tt)}: () = ();
         //~^ ERROR metavariables of `${concat(..)}` must be of type
         //~| ERROR metavariables of `${concat(..)}` must be of type
-        //~| ERROR metavariables of `${concat(..)}` must be of type
     }
 }
 
@@ -178,13 +179,14 @@ fn main() {
     bad_literal_string!("1.0");
     bad_literal_string!("'1'");
 
-    bad_literal_non_string!(1);
     bad_literal_non_string!(-1);
     bad_literal_non_string!(1.0);
     bad_literal_non_string!('1');
     bad_literal_non_string!(false);
+    bad_literal_non_string!(4f64);
+    bad_literal_non_string!(5u8);
+    bad_literal_non_string!(6_u8);
 
-    bad_tt_literal!(1);
     bad_tt_literal!(1.0);
     bad_tt_literal!('1');
 }
diff --git a/tests/ui/macros/metavar-expressions/concat-usage-errors.stderr b/tests/ui/macros/metavar-expressions/concat-usage-errors.stderr
index 8be3e792ec3f2..c124b76cb781a 100644
--- a/tests/ui/macros/metavar-expressions/concat-usage-errors.stderr
+++ b/tests/ui/macros/metavar-expressions/concat-usage-errors.stderr
@@ -130,7 +130,7 @@ error: metavariables of `${concat(..)}` must be of type `ident`, `literal` or `t
 LL |         ${concat($ex, aaaa)}
    |                   ^^
    |
-   = note: currently only string literals are supported
+   = note: currently only string and integer literals are supported
 
 error: variable `foo` is not recognized in meta-variable expression
   --> $DIR/concat-usage-errors.rs:37:30
@@ -276,7 +276,7 @@ error: metavariables of `${concat(..)}` must be of type `ident`, `literal` or `t
 LL |         const ${concat(_foo, $literal)}: () = ();
    |                               ^^^^^^^
    |
-   = note: currently only string literals are supported
+   = note: currently only string and integer literals are supported
 
 error: metavariables of `${concat(..)}` must be of type `ident`, `literal` or `tt`
   --> $DIR/concat-usage-errors.rs:138:31
@@ -284,7 +284,7 @@ error: metavariables of `${concat(..)}` must be of type `ident`, `literal` or `t
 LL |         const ${concat(_foo, $literal)}: () = ();
    |                               ^^^^^^^
    |
-   = note: currently only string literals are supported
+   = note: currently only string and integer literals are supported
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error: metavariables of `${concat(..)}` must be of type `ident`, `literal` or `tt`
@@ -293,7 +293,7 @@ error: metavariables of `${concat(..)}` must be of type `ident`, `literal` or `t
 LL |         const ${concat(_foo, $literal)}: () = ();
    |                               ^^^^^^^
    |
-   = note: currently only string literals are supported
+   = note: currently only string and integer literals are supported
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error: metavariables of `${concat(..)}` must be of type `ident`, `literal` or `tt`
@@ -302,43 +302,45 @@ error: metavariables of `${concat(..)}` must be of type `ident`, `literal` or `t
 LL |         const ${concat(_foo, $literal)}: () = ();
    |                               ^^^^^^^
    |
-   = note: currently only string literals are supported
+   = note: currently only string and integer literals are supported
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error: metavariables of `${concat(..)}` must be of type `ident`, `literal` or `tt`
+error: floats are not supported as metavariables of `${concat(..)}`
   --> $DIR/concat-usage-errors.rs:138:31
    |
 LL |         const ${concat(_foo, $literal)}: () = ();
    |                               ^^^^^^^
+
+error: integer metavariables of `${concat(..)}` must not be suffixed
+  --> $DIR/concat-usage-errors.rs:138:31
    |
-   = note: currently only string literals are supported
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+LL |         const ${concat(_foo, $literal)}: () = ();
+   |                               ^^^^^^^
 
-error: metavariables of `${concat(..)}` must be of type `ident`, `literal` or `tt`
-  --> $DIR/concat-usage-errors.rs:149:31
+error: integer metavariables of `${concat(..)}` must not be suffixed
+  --> $DIR/concat-usage-errors.rs:138:31
    |
-LL |         const ${concat(_foo, $tt)}: () = ();
-   |                               ^^
+LL |         const ${concat(_foo, $literal)}: () = ();
+   |                               ^^^^^^^
    |
-   = note: currently only string literals are supported
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error: metavariables of `${concat(..)}` must be of type `ident`, `literal` or `tt`
-  --> $DIR/concat-usage-errors.rs:149:31
+  --> $DIR/concat-usage-errors.rs:151:31
    |
 LL |         const ${concat(_foo, $tt)}: () = ();
    |                               ^^
    |
-   = note: currently only string literals are supported
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+   = note: currently only string and integer literals are supported
 
 error: metavariables of `${concat(..)}` must be of type `ident`, `literal` or `tt`
-  --> $DIR/concat-usage-errors.rs:149:31
+  --> $DIR/concat-usage-errors.rs:151:31
    |
 LL |         const ${concat(_foo, $tt)}: () = ();
    |                               ^^
    |
-   = note: currently only string literals are supported
+   = note: currently only string and integer literals are supported
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error: aborting due to 43 previous errors
+error: aborting due to 44 previous errors
 

From 006c85d017e9eb404e3798c59520d6058d971cd8 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Thu, 31 Jul 2025 15:53:18 +1000
Subject: [PATCH 0630/1889] Make some matches non-exhaustive.

Exhaustive match isn't necessary for these trivial cases, and some
similar nearby methods are non-exhaustive.
---
 compiler/rustc_middle/src/ty/predicate.rs | 32 ++---------------------
 1 file changed, 2 insertions(+), 30 deletions(-)

diff --git a/compiler/rustc_middle/src/ty/predicate.rs b/compiler/rustc_middle/src/ty/predicate.rs
index 59e00f85957e7..69dcca54f469d 100644
--- a/compiler/rustc_middle/src/ty/predicate.rs
+++ b/compiler/rustc_middle/src/ty/predicate.rs
@@ -638,21 +638,7 @@ impl<'tcx> Predicate<'tcx> {
         let predicate = self.kind();
         match predicate.skip_binder() {
             PredicateKind::Clause(ClauseKind::Trait(t)) => Some(predicate.rebind(t)),
-            PredicateKind::Clause(ClauseKind::Projection(..))
-            | PredicateKind::Clause(ClauseKind::HostEffect(..))
-            | PredicateKind::Clause(ClauseKind::ConstArgHasType(..))
-            | PredicateKind::Clause(ClauseKind::UnstableFeature(_))
-            | PredicateKind::NormalizesTo(..)
-            | PredicateKind::AliasRelate(..)
-            | PredicateKind::Subtype(..)
-            | PredicateKind::Coerce(..)
-            | PredicateKind::Clause(ClauseKind::RegionOutlives(..))
-            | PredicateKind::Clause(ClauseKind::WellFormed(..))
-            | PredicateKind::DynCompatible(..)
-            | PredicateKind::Clause(ClauseKind::TypeOutlives(..))
-            | PredicateKind::Clause(ClauseKind::ConstEvaluatable(..))
-            | PredicateKind::ConstEquate(..)
-            | PredicateKind::Ambiguous => None,
+            _ => None,
         }
     }
 
@@ -660,21 +646,7 @@ impl<'tcx> Predicate<'tcx> {
         let predicate = self.kind();
         match predicate.skip_binder() {
             PredicateKind::Clause(ClauseKind::Projection(t)) => Some(predicate.rebind(t)),
-            PredicateKind::Clause(ClauseKind::Trait(..))
-            | PredicateKind::Clause(ClauseKind::HostEffect(..))
-            | PredicateKind::Clause(ClauseKind::ConstArgHasType(..))
-            | PredicateKind::Clause(ClauseKind::UnstableFeature(_))
-            | PredicateKind::NormalizesTo(..)
-            | PredicateKind::AliasRelate(..)
-            | PredicateKind::Subtype(..)
-            | PredicateKind::Coerce(..)
-            | PredicateKind::Clause(ClauseKind::RegionOutlives(..))
-            | PredicateKind::Clause(ClauseKind::WellFormed(..))
-            | PredicateKind::DynCompatible(..)
-            | PredicateKind::Clause(ClauseKind::TypeOutlives(..))
-            | PredicateKind::Clause(ClauseKind::ConstEvaluatable(..))
-            | PredicateKind::ConstEquate(..)
-            | PredicateKind::Ambiguous => None,
+            _ => None,
         }
     }
 

From 1e679154da915f971216f8e925eda2a1b47a38af Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Thu, 31 Jul 2025 16:35:38 +1000
Subject: [PATCH 0631/1889] Move `rustc_middle::MaxUniverse` to `rustc_infer`.

Because `rust_infer` is the only crate that uses it.
---
 .../src/infer/relate/generalize.rs            | 43 ++++++++++++++++++-
 compiler/rustc_middle/src/ty/mod.rs           |  1 -
 compiler/rustc_middle/src/ty/visit.rs         | 39 -----------------
 3 files changed, 41 insertions(+), 42 deletions(-)

diff --git a/compiler/rustc_infer/src/infer/relate/generalize.rs b/compiler/rustc_infer/src/infer/relate/generalize.rs
index a000bb1123c1c..a75fd8dfa18b6 100644
--- a/compiler/rustc_infer/src/infer/relate/generalize.rs
+++ b/compiler/rustc_infer/src/infer/relate/generalize.rs
@@ -6,8 +6,8 @@ use rustc_hir::def_id::DefId;
 use rustc_middle::bug;
 use rustc_middle::ty::error::TypeError;
 use rustc_middle::ty::{
-    self, AliasRelationDirection, InferConst, MaxUniverse, Term, Ty, TyCtxt, TypeVisitable,
-    TypeVisitableExt, TypingMode,
+    self, AliasRelationDirection, InferConst, Term, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable,
+    TypeVisitableExt, TypeVisitor, TypingMode,
 };
 use rustc_span::Span;
 use tracing::{debug, instrument, warn};
@@ -290,6 +290,45 @@ impl<'tcx> InferCtxt<'tcx> {
     }
 }
 
+/// Finds the max universe present
+struct MaxUniverse {
+    max_universe: ty::UniverseIndex,
+}
+
+impl MaxUniverse {
+    fn new() -> Self {
+        MaxUniverse { max_universe: ty::UniverseIndex::ROOT }
+    }
+
+    fn max_universe(self) -> ty::UniverseIndex {
+        self.max_universe
+    }
+}
+
+impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for MaxUniverse {
+    fn visit_ty(&mut self, t: Ty<'tcx>) {
+        if let ty::Placeholder(placeholder) = t.kind() {
+            self.max_universe = self.max_universe.max(placeholder.universe);
+        }
+
+        t.super_visit_with(self)
+    }
+
+    fn visit_const(&mut self, c: ty::Const<'tcx>) {
+        if let ty::ConstKind::Placeholder(placeholder) = c.kind() {
+            self.max_universe = self.max_universe.max(placeholder.universe);
+        }
+
+        c.super_visit_with(self)
+    }
+
+    fn visit_region(&mut self, r: ty::Region<'tcx>) {
+        if let ty::RePlaceholder(placeholder) = r.kind() {
+            self.max_universe = self.max_universe.max(placeholder.universe);
+        }
+    }
+}
+
 /// The "generalizer" is used when handling inference variables.
 ///
 /// The basic strategy for handling a constraint like `?A <: B` is to
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index e567ba05f61cb..da17ec1f9f379 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -109,7 +109,6 @@ pub use self::typeck_results::{
     CanonicalUserType, CanonicalUserTypeAnnotation, CanonicalUserTypeAnnotations, IsIdentity,
     Rust2024IncompatiblePatInfo, TypeckResults, UserType, UserTypeAnnotationIndex, UserTypeKind,
 };
-pub use self::visit::*;
 use crate::error::{OpaqueHiddenTypeMismatch, TypeMismatchReason};
 use crate::metadata::ModChild;
 use crate::middle::privacy::EffectiveVisibilities;
diff --git a/compiler/rustc_middle/src/ty/visit.rs b/compiler/rustc_middle/src/ty/visit.rs
index 3853a804a920f..f0c47f257cc4e 100644
--- a/compiler/rustc_middle/src/ty/visit.rs
+++ b/compiler/rustc_middle/src/ty/visit.rs
@@ -212,42 +212,3 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for LateBoundRegionsCollector {
         }
     }
 }
-
-/// Finds the max universe present
-pub struct MaxUniverse {
-    max_universe: ty::UniverseIndex,
-}
-
-impl MaxUniverse {
-    pub fn new() -> Self {
-        MaxUniverse { max_universe: ty::UniverseIndex::ROOT }
-    }
-
-    pub fn max_universe(self) -> ty::UniverseIndex {
-        self.max_universe
-    }
-}
-
-impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for MaxUniverse {
-    fn visit_ty(&mut self, t: Ty<'tcx>) {
-        if let ty::Placeholder(placeholder) = t.kind() {
-            self.max_universe = self.max_universe.max(placeholder.universe);
-        }
-
-        t.super_visit_with(self)
-    }
-
-    fn visit_const(&mut self, c: ty::consts::Const<'tcx>) {
-        if let ty::ConstKind::Placeholder(placeholder) = c.kind() {
-            self.max_universe = self.max_universe.max(placeholder.universe);
-        }
-
-        c.super_visit_with(self)
-    }
-
-    fn visit_region(&mut self, r: ty::Region<'tcx>) {
-        if let ty::RePlaceholder(placeholder) = r.kind() {
-            self.max_universe = self.max_universe.max(placeholder.universe);
-        }
-    }
-}

From a171ec3cf04be09b7889223caa1e9a7768d82de4 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Thu, 31 Jul 2025 16:46:21 +1000
Subject: [PATCH 0632/1889] Move `describe_as_module` from
 `rustc_middle::print` to `rustc:middle::query`.

That way it doesn't need to be exported.
---
 compiler/rustc_middle/src/query/mod.rs    | 11 ++++++++++-
 compiler/rustc_middle/src/ty/print/mod.rs | 12 +-----------
 2 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 874cee54c7c63..8fba218cc71cd 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -135,7 +135,7 @@ use crate::traits::{
 };
 use crate::ty::fast_reject::SimplifiedType;
 use crate::ty::layout::ValidityRequirement;
-use crate::ty::print::{PrintTraitRefExt, describe_as_module};
+use crate::ty::print::PrintTraitRefExt;
 use crate::ty::util::AlwaysRequiresDrop;
 use crate::ty::{
     self, CrateInherentImpls, GenericArg, GenericArgsRef, PseudoCanonicalInput, SizedTraitKind, Ty,
@@ -2731,3 +2731,12 @@ rustc_queries! {
 
 rustc_with_all_queries! { define_callbacks! }
 rustc_feedable_queries! { define_feedable! }
+
+fn describe_as_module(def_id: impl Into<LocalDefId>, tcx: TyCtxt<'_>) -> String {
+    let def_id = def_id.into();
+    if def_id.is_top_level_module() {
+        "top-level module".to_string()
+    } else {
+        format!("module `{}`", tcx.def_path_str(def_id))
+    }
+}
diff --git a/compiler/rustc_middle/src/ty/print/mod.rs b/compiler/rustc_middle/src/ty/print/mod.rs
index 9e6f277ef7700..d636e8ef31ff5 100644
--- a/compiler/rustc_middle/src/ty/print/mod.rs
+++ b/compiler/rustc_middle/src/ty/print/mod.rs
@@ -2,7 +2,7 @@ use hir::def::Namespace;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_data_structures::sso::SsoHashSet;
 use rustc_hir as hir;
-use rustc_hir::def_id::{CrateNum, DefId, LocalDefId};
+use rustc_hir::def_id::{CrateNum, DefId};
 use rustc_hir::definitions::{DefPathData, DisambiguatedDefPathData};
 use tracing::{debug, instrument, trace};
 
@@ -396,16 +396,6 @@ impl<'tcx, P: Printer<'tcx>> Print<'tcx, P> for ty::Const<'tcx> {
     }
 }
 
-// This is only used by query descriptions
-pub fn describe_as_module(def_id: impl Into<LocalDefId>, tcx: TyCtxt<'_>) -> String {
-    let def_id = def_id.into();
-    if def_id.is_top_level_module() {
-        "top-level module".to_string()
-    } else {
-        format!("module `{}`", tcx.def_path_str(def_id))
-    }
-}
-
 impl<T> rustc_type_ir::ir_print::IrPrint<T> for TyCtxt<'_>
 where
     T: Copy + for<'a, 'tcx> Lift<TyCtxt<'tcx>, Lifted: Print<'tcx, FmtPrinter<'a, 'tcx>>>,

From 61af5da8dfc9f5fd6e2d36f8316f7bf5884f5388 Mon Sep 17 00:00:00 2001
From: Patrick-6 <pamu99@gmx.ch>
Date: Fri, 14 Mar 2025 09:58:46 +0100
Subject: [PATCH 0633/1889] Implement more features for GenMC mode - Support
 for atomic fences. - Support for atomic read-modify-write (RMW). - Add tests
 using RMW and fences. - Add options:   - to disable weak memory effects in
 GenMC mode.   - to print GenMC execution graphs.   - to print GenMC output
 message. - Fix GenMC full rebuild issue and run configure step when commit
 changes. - Do cleanup.

Co-authored-by: Ralf Jung <post@ralfj.de>
---
 src/tools/miri/doc/genmc.md                   |   7 +-
 src/tools/miri/genmc-sys/build.rs             |  37 +++-
 .../genmc-sys/cpp/include/MiriInterface.hpp   |  29 +++
 .../cpp/src/MiriInterface/EventHandling.cpp   |  66 ++++++
 .../genmc-sys/cpp/src/MiriInterface/Setup.cpp |  13 +-
 src/tools/miri/genmc-sys/src/lib.rs           |  77 ++++++-
 src/tools/miri/src/bin/miri.rs                |  23 +--
 src/tools/miri/src/concurrency/data_race.rs   |  12 +-
 .../miri/src/concurrency/genmc/config.rs      |  60 +++++-
 src/tools/miri/src/concurrency/genmc/dummy.rs |   8 +-
 .../miri/src/concurrency/genmc/helper.rs      |  54 ++++-
 src/tools/miri/src/concurrency/genmc/mod.rs   | 191 ++++++++++++------
 src/tools/miri/src/concurrency/genmc/run.rs   |  13 +-
 .../miri/tests/genmc/fail/loom/buggy_inc.rs   |  66 ++++++
 .../tests/genmc/fail/loom/buggy_inc.stderr    |  13 ++
 .../fail/simple/2w2w_weak.relaxed4.stderr     |   8 +-
 .../fail/simple/2w2w_weak.release4.stderr     |   8 +-
 .../miri/tests/genmc/fail/simple/2w2w_weak.rs |   7 +-
 .../fail/simple/2w2w_weak.sc3_rel1.stderr     |   8 +-
 .../miri/tests/genmc/pass/atomics/rmw_ops.rs  |  91 +++++++++
 .../tests/genmc/pass/atomics/rmw_ops.stderr   |   2 +
 .../tests/genmc/pass/litmus/2w2w_2sc_scf.rs   |  33 +++
 .../genmc/pass/litmus/2w2w_2sc_scf.stderr     |   2 +
 .../miri/tests/genmc/pass/litmus/2w2w_4rel.rs |   4 +
 .../genmc/pass/litmus/2w2w_4rel.sc.stderr     |   2 +
 ...2w2w_4rel.stderr => 2w2w_4rel.weak.stderr} |   0
 .../tests/genmc/pass/litmus/IRIW-acq-sc.rs    |   2 +-
 .../miri/tests/genmc/pass/litmus/IRIWish.rs   |  66 ++++++
 .../tests/genmc/pass/litmus/IRIWish.stderr    |  30 +++
 .../miri/tests/genmc/pass/litmus/LB_incMPs.rs |  41 ++++
 .../tests/genmc/pass/litmus/LB_incMPs.stderr  |   2 +
 .../tests/genmc/pass/litmus/MPU_rels_acq.rs   |  42 ++++
 .../genmc/pass/litmus/MPU_rels_acq.stderr     |   2 +
 .../miri/tests/genmc/pass/litmus/MP_incMPs.rs |  36 ++++
 .../tests/genmc/pass/litmus/MP_incMPs.stderr  |   2 +
 .../tests/genmc/pass/litmus/MP_rels_acqf.rs   |  40 ++++
 .../genmc/pass/litmus/MP_rels_acqf.stderr     |   2 +
 .../tests/genmc/pass/litmus/SB_2sc_scf.rs     |  32 +++
 .../tests/genmc/pass/litmus/SB_2sc_scf.stderr |   2 +
 .../miri/tests/genmc/pass/litmus/Z6_U.rs      |  65 ++++++
 .../tests/genmc/pass/litmus/Z6_U.sc.stderr    |  20 ++
 .../tests/genmc/pass/litmus/Z6_U.weak.stderr  |  24 +++
 .../miri/tests/genmc/pass/litmus/Z6_acq.rs    |  38 ++++
 .../tests/genmc/pass/litmus/Z6_acq.stderr     |   2 +
 .../miri/tests/genmc/pass/litmus/atomicpo.rs  |  32 +++
 .../tests/genmc/pass/litmus/atomicpo.stderr   |   2 +
 .../tests/genmc/pass/litmus/cumul-release.rs  |  58 ++++++
 .../genmc/pass/litmus/cumul-release.stderr    |   2 +
 .../tests/genmc/pass/litmus/fr_w_w_w_reads.rs |   1 -
 .../miri/tests/genmc/pass/litmus/inc2w.rs     |  45 +++++
 .../miri/tests/genmc/pass/litmus/inc2w.stderr |   2 +
 .../genmc/pass/litmus/inc_inc_RR_W_RR.rs      |  63 ++++++
 .../genmc/pass/litmus/inc_inc_RR_W_RR.stderr  |   2 +
 .../miri/tests/genmc/pass/litmus/riwi.rs      |  31 +++
 .../miri/tests/genmc/pass/litmus/riwi.stderr  |   2 +
 .../tests/genmc/pass/litmus/viktor-relseq.rs  |  36 ++++
 .../genmc/pass/litmus/viktor-relseq.stderr    |   2 +
 src/tools/miri/tests/utils/genmc.rs           |   7 +
 58 files changed, 1431 insertions(+), 136 deletions(-)
 create mode 100644 src/tools/miri/tests/genmc/fail/loom/buggy_inc.rs
 create mode 100644 src/tools/miri/tests/genmc/fail/loom/buggy_inc.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/atomics/rmw_ops.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/atomics/rmw_ops.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/2w2w_2sc_scf.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/2w2w_2sc_scf.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/2w2w_4rel.sc.stderr
 rename src/tools/miri/tests/genmc/pass/litmus/{2w2w_4rel.stderr => 2w2w_4rel.weak.stderr} (100%)
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/IRIWish.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/IRIWish.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/LB_incMPs.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/LB_incMPs.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/MPU_rels_acq.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/MPU_rels_acq.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/MP_incMPs.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/MP_incMPs.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/MP_rels_acqf.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/MP_rels_acqf.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/SB_2sc_scf.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/SB_2sc_scf.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/Z6_U.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/Z6_U.sc.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/Z6_U.weak.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/Z6_acq.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/Z6_acq.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/atomicpo.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/atomicpo.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/cumul-release.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/cumul-release.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/inc2w.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/inc2w.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/inc_inc_RR_W_RR.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/inc_inc_RR_W_RR.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/riwi.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/riwi.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/viktor-relseq.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/viktor-relseq.stderr

diff --git a/src/tools/miri/doc/genmc.md b/src/tools/miri/doc/genmc.md
index fdbf2defe42dc..8af697be34a61 100644
--- a/src/tools/miri/doc/genmc.md
+++ b/src/tools/miri/doc/genmc.md
@@ -24,6 +24,9 @@ Note that `cargo miri test` in GenMC mode is currently not supported.
 ### Supported Parameters
 
 - `-Zmiri-genmc`: Enable GenMC mode (not required if any other GenMC options are used).
+- `-Zmiri-genmc-print-exec-graphs={none,explored,blocked,all}`: Make GenMC print the execution graph of the program after every explored, every blocked, or after every execution (default: None).
+- `-Zmiri-genmc-print-exec-graphs`: Shorthand for suffix `=explored`.
+- `-Zmiri-genmc-print-genmc-output`: Print the output that GenMC provides. NOTE: this output is quite verbose and the events in the printed execution graph are hard to map back to the Rust code location they originate from.
 - `-Zmiri-genmc-log=LOG_LEVEL`: Change the log level for GenMC. Default: `warning`.
   - `quiet`:    Disable logging.
   - `error`:    Print errors.
@@ -34,7 +37,9 @@ Note that `cargo miri test` in GenMC mode is currently not supported.
     - `debug2`:   Print the execution graph after every memory access.
     - `debug3`:   Print reads-from values considered by GenMC.
 
-<!-- FIXME(genmc): explain options. -->
+#### Regular Miri parameters useful for GenMC mode
+
+- `-Zmiri-disable-weak-memory-emulation`: Disable any weak memory effects (effectively upgrading all atomic orderings in the program to `SeqCst`). This option may reduce the number of explored program executions, but any bugs related to weak memory effects will be missed. This option can help determine if an error is caused by weak memory effects (i.e., if it disappears with this option enabled).
 
 <!-- FIXME(genmc): explain Miri-GenMC specific functions. -->
 
diff --git a/src/tools/miri/genmc-sys/build.rs b/src/tools/miri/genmc-sys/build.rs
index 8eb818a6b265b..8d437c20a0926 100644
--- a/src/tools/miri/genmc-sys/build.rs
+++ b/src/tools/miri/genmc-sys/build.rs
@@ -30,13 +30,23 @@ mod downloading {
     /// The GenMC commit we depend on. It must be available on the specified GenMC repository.
     pub(crate) const GENMC_COMMIT: &str = "af9cc9ccd5d412b16defc35dbf36571c63a19c76";
 
-    pub(crate) fn download_genmc() -> PathBuf {
+    /// Ensure that a local GenMC repo is present and set to the correct commit.
+    /// Return the path of the GenMC repo and whether the checked out commit was changed.
+    pub(crate) fn download_genmc() -> (PathBuf, bool) {
         let Ok(genmc_download_path) = PathBuf::from_str(GENMC_DOWNLOAD_PATH);
         let commit_oid = Oid::from_str(GENMC_COMMIT).expect("Commit should be valid.");
 
         match Repository::open(&genmc_download_path) {
             Ok(repo) => {
                 assert_repo_unmodified(&repo);
+                if let Ok(head) = repo.head()
+                    && let Ok(head_commit) = head.peel_to_commit()
+                    && head_commit.id() == commit_oid
+                {
+                    // Fast path: The expected commit is already checked out.
+                    return (genmc_download_path, false);
+                }
+                // Check if the local repository already contains the commit we need, download it otherwise.
                 let commit = update_local_repo(&repo, commit_oid);
                 checkout_commit(&repo, &commit);
             }
@@ -51,7 +61,7 @@ mod downloading {
             }
         };
 
-        genmc_download_path
+        (genmc_download_path, true)
     }
 
     fn get_remote(repo: &Repository) -> Remote<'_> {
@@ -71,7 +81,8 @@ mod downloading {
 
         // Update remote URL.
         println!(
-            "cargo::warning=GenMC repository remote URL has changed from '{remote_url:?}' to '{GENMC_GITHUB_URL}'"
+            "cargo::warning=GenMC repository remote URL has changed from '{}' to '{GENMC_GITHUB_URL}'",
+            remote_url.unwrap_or_default()
         );
         repo.remote_set_url("origin", GENMC_GITHUB_URL)
             .expect("cannot rename url of remote 'origin'");
@@ -175,7 +186,7 @@ fn link_to_llvm(config_file: &Path) -> (String, String) {
 }
 
 /// Build the GenMC model checker library and the Rust-C++ interop library with cxx.rs
-fn compile_cpp_dependencies(genmc_path: &Path) {
+fn compile_cpp_dependencies(genmc_path: &Path, always_configure: bool) {
     // Give each step a separate build directory to prevent interference.
     let out_dir = PathBuf::from(std::env::var("OUT_DIR").as_deref().unwrap());
     let genmc_build_dir = out_dir.join("genmc");
@@ -184,15 +195,13 @@ fn compile_cpp_dependencies(genmc_path: &Path) {
     // Part 1:
     // Compile the GenMC library using cmake.
 
-    let cmakelists_path = genmc_path.join("CMakeLists.txt");
-
     // FIXME(genmc,cargo): Switch to using `CARGO_CFG_DEBUG_ASSERTIONS` once https://github.com/rust-lang/cargo/issues/15760 is completed.
     // Enable/disable additional debug checks, prints and options for GenMC, based on the Rust profile (debug/release)
     let enable_genmc_debug = matches!(std::env::var("PROFILE").as_deref().unwrap(), "debug");
 
-    let mut config = cmake::Config::new(cmakelists_path);
+    let mut config = cmake::Config::new(genmc_path);
     config
-        .always_configure(false) // We don't need to reconfigure on subsequent compilation runs.
+        .always_configure(always_configure) // We force running the configure step when the GenMC commit changed.
         .out_dir(genmc_build_dir)
         .profile(GENMC_CMAKE_PROFILE)
         .define("GENMC_DEBUG", if enable_genmc_debug { "ON" } else { "OFF" });
@@ -251,7 +260,8 @@ fn compile_cpp_dependencies(genmc_path: &Path) {
 
 fn main() {
     // Select which path to use for the GenMC repo:
-    let genmc_path = if let Some(genmc_src_path) = option_env!("GENMC_SRC_PATH") {
+    let (genmc_path, always_configure) = if let Some(genmc_src_path) = option_env!("GENMC_SRC_PATH")
+    {
         let genmc_src_path =
             PathBuf::from_str(&genmc_src_path).expect("GENMC_SRC_PATH should contain a valid path");
         assert!(
@@ -261,13 +271,18 @@ fn main() {
         );
         // Rebuild files in the given path change.
         println!("cargo::rerun-if-changed={}", genmc_src_path.display());
-        genmc_src_path
+        // We disable `always_configure` when working with a local repository,
+        // since it increases compile times when working on `genmc-sys`.
+        (genmc_src_path, false)
     } else {
+        // Download GenMC if required and ensure that the correct commit is checked out.
+        // If anything changed in the downloaded repository (e.g., the commit),
+        // we set `always_configure` to ensure there are no weird configs from previous builds.
         downloading::download_genmc()
     };
 
     // Build all required components:
-    compile_cpp_dependencies(&genmc_path);
+    compile_cpp_dependencies(&genmc_path, always_configure);
 
     // Only rebuild if anything changes:
     // Note that we don't add the downloaded GenMC repo, since that should never be modified
diff --git a/src/tools/miri/genmc-sys/cpp/include/MiriInterface.hpp b/src/tools/miri/genmc-sys/cpp/include/MiriInterface.hpp
index 4484f0b73caec..b076937584326 100644
--- a/src/tools/miri/genmc-sys/cpp/include/MiriInterface.hpp
+++ b/src/tools/miri/genmc-sys/cpp/include/MiriInterface.hpp
@@ -33,6 +33,7 @@ struct GenmcScalar;
 struct SchedulingResult;
 struct LoadResult;
 struct StoreResult;
+struct ReadModifyWriteResult;
 
 // GenMC uses `int` for its thread IDs.
 using ThreadId = int;
@@ -90,6 +91,15 @@ struct MiriGenmcShim : private GenMCDriver {
         MemOrdering ord,
         GenmcScalar old_val
     );
+    [[nodiscard]] ReadModifyWriteResult handle_read_modify_write(
+        ThreadId thread_id,
+        uint64_t address,
+        uint64_t size,
+        RMWBinOp rmw_op,
+        MemOrdering ordering,
+        GenmcScalar rhs_value,
+        GenmcScalar old_val
+    );
     [[nodiscard]] StoreResult handle_store(
         ThreadId thread_id,
         uint64_t address,
@@ -99,6 +109,8 @@ struct MiriGenmcShim : private GenMCDriver {
         MemOrdering ord
     );
 
+    void handle_fence(ThreadId thread_id, MemOrdering ord);
+
     /**** Memory (de)allocation ****/
     auto handle_malloc(ThreadId thread_id, uint64_t size, uint64_t alignment) -> uint64_t;
     void handle_free(ThreadId thread_id, uint64_t address);
@@ -271,4 +283,21 @@ inline StoreResult from_error(std::unique_ptr<std::string> error) {
 }
 } // namespace StoreResultExt
 
+namespace ReadModifyWriteResultExt {
+inline ReadModifyWriteResult
+ok(SVal old_value, SVal new_value, bool is_coherence_order_maximal_write) {
+    return ReadModifyWriteResult { /* error: */ std::unique_ptr<std::string>(nullptr),
+                                   /* old_value: */ GenmcScalarExt::from_sval(old_value),
+                                   /* new_value: */ GenmcScalarExt::from_sval(new_value),
+                                   is_coherence_order_maximal_write };
+}
+
+inline ReadModifyWriteResult from_error(std::unique_ptr<std::string> error) {
+    return ReadModifyWriteResult { /* error: */ std::move(error),
+                                   /* old_value: */ GenmcScalarExt::uninit(),
+                                   /* new_value: */ GenmcScalarExt::uninit(),
+                                   /* is_coherence_order_maximal_write: */ false };
+}
+} // namespace ReadModifyWriteResultExt
+
 #endif /* GENMC_MIRI_INTERFACE_HPP */
diff --git a/src/tools/miri/genmc-sys/cpp/src/MiriInterface/EventHandling.cpp b/src/tools/miri/genmc-sys/cpp/src/MiriInterface/EventHandling.cpp
index 7d8f0b16b49ab..cd28e0d148f58 100644
--- a/src/tools/miri/genmc-sys/cpp/src/MiriInterface/EventHandling.cpp
+++ b/src/tools/miri/genmc-sys/cpp/src/MiriInterface/EventHandling.cpp
@@ -89,6 +89,72 @@
     );
 }
 
+void MiriGenmcShim::handle_fence(ThreadId thread_id, MemOrdering ord) {
+    const auto pos = inc_pos(thread_id);
+    GenMCDriver::handleFence(pos, ord, EventDeps());
+}
+
+[[nodiscard]] auto MiriGenmcShim::handle_read_modify_write(
+    ThreadId thread_id,
+    uint64_t address,
+    uint64_t size,
+    RMWBinOp rmw_op,
+    MemOrdering ordering,
+    GenmcScalar rhs_value,
+    GenmcScalar old_val
+) -> ReadModifyWriteResult {
+    // NOTE: Both the store and load events should get the same `ordering`, it should not be split
+    // into a load and a store component. This means we can have for example `AcqRel` loads and
+    // stores, but this is intended for RMW operations.
+
+    // Somewhat confusingly, the GenMC term for RMW read/write labels is
+    // `FaiRead` and `FaiWrite`.
+    const auto load_ret = handle_load_reset_if_none<EventLabel::EventLabelKind::FaiRead>(
+        thread_id,
+        ordering,
+        SAddr(address),
+        ASize(size),
+        AType::Unsigned, // The type is only used for printing.
+        rmw_op,
+        GenmcScalarExt::to_sval(rhs_value),
+        EventDeps()
+    );
+    if (const auto* err = std::get_if<VerificationError>(&load_ret))
+        return ReadModifyWriteResultExt::from_error(format_error(*err));
+
+    const auto* ret_val = std::get_if<SVal>(&load_ret);
+    if (nullptr == ret_val) {
+        ERROR("Unimplemented: read-modify-write returned unexpected result.");
+    }
+    const auto read_old_val = *ret_val;
+    const auto new_value =
+        executeRMWBinOp(read_old_val, GenmcScalarExt::to_sval(rhs_value), size, rmw_op);
+
+    const auto storePos = inc_pos(thread_id);
+    const auto store_ret = GenMCDriver::handleStore<EventLabel::EventLabelKind::FaiWrite>(
+        storePos,
+        ordering,
+        SAddr(address),
+        ASize(size),
+        AType::Unsigned, // The type is only used for printing.
+        new_value
+    );
+    if (const auto* err = std::get_if<VerificationError>(&store_ret))
+        return ReadModifyWriteResultExt::from_error(format_error(*err));
+
+    const auto* store_ret_val = std::get_if<std::monostate>(&store_ret);
+    ERROR_ON(nullptr == store_ret_val, "Unimplemented: RMW store returned unexpected result.");
+
+    // FIXME(genmc,mixed-accesses): Use the value that GenMC returns from handleStore (once
+    // available).
+    const auto& g = getExec().getGraph();
+    return ReadModifyWriteResultExt::ok(
+        /* old_value: */ read_old_val,
+        new_value,
+        /* is_coherence_order_maximal_write */ g.co_max(SAddr(address))->getPos() == storePos
+    );
+}
+
 /**** Memory (de)allocation ****/
 
 auto MiriGenmcShim::handle_malloc(ThreadId thread_id, uint64_t size, uint64_t alignment)
diff --git a/src/tools/miri/genmc-sys/cpp/src/MiriInterface/Setup.cpp b/src/tools/miri/genmc-sys/cpp/src/MiriInterface/Setup.cpp
index 7194ed02da432..5a53fee059216 100644
--- a/src/tools/miri/genmc-sys/cpp/src/MiriInterface/Setup.cpp
+++ b/src/tools/miri/genmc-sys/cpp/src/MiriInterface/Setup.cpp
@@ -63,9 +63,12 @@ static auto to_genmc_verbosity_level(const LogLevel log_level) -> VerbosityLevel
     auto conf = std::make_shared<Config>();
 
     // Set whether GenMC should print execution graphs after every explored/blocked execution.
-    // FIXME(genmc): pass these settings from Miri.
-    conf->printExecGraphs = false;
-    conf->printBlockedExecs = false;
+    conf->printExecGraphs =
+        (params.print_execution_graphs == ExecutiongraphPrinting::Explored ||
+         params.print_execution_graphs == ExecutiongraphPrinting::ExploredAndBlocked);
+    conf->printBlockedExecs =
+        (params.print_execution_graphs == ExecutiongraphPrinting::Blocked ||
+         params.print_execution_graphs == ExecutiongraphPrinting::ExploredAndBlocked);
 
     // `1024` is the default value that GenMC uses.
     // If any thread has at least this many events, a warning/tip will be printed.
@@ -79,8 +82,8 @@ static auto to_genmc_verbosity_level(const LogLevel log_level) -> VerbosityLevel
     // Miri.
     conf->warnOnGraphSize = 1024 * 1024;
 
-    // We only support the RC11 memory model for Rust.
-    conf->model = ModelType::RC11;
+    // We only support the `RC11` memory model for Rust, and `SC` when weak memory emulation is disabled.
+    conf->model = params.disable_weak_memory_emulation ? ModelType::SC : ModelType::RC11;
 
     // This prints the seed that GenMC picks for randomized scheduling during estimation mode.
     conf->printRandomScheduleSeed = params.print_random_schedule_seed;
diff --git a/src/tools/miri/genmc-sys/src/lib.rs b/src/tools/miri/genmc-sys/src/lib.rs
index 406c90809fcd5..1de4c4eb5e8e9 100644
--- a/src/tools/miri/genmc-sys/src/lib.rs
+++ b/src/tools/miri/genmc-sys/src/lib.rs
@@ -53,7 +53,13 @@ impl GenmcScalar {
 
 impl Default for GenmcParams {
     fn default() -> Self {
-        Self { print_random_schedule_seed: false, do_symmetry_reduction: false }
+        Self {
+            print_random_schedule_seed: false,
+            do_symmetry_reduction: false,
+            // GenMC graphs can be quite large since Miri produces a lot of (non-atomic) events.
+            print_execution_graphs: ExecutiongraphPrinting::None,
+            disable_weak_memory_emulation: false,
+        }
     }
 }
 
@@ -91,7 +97,10 @@ mod ffi {
     struct GenmcParams {
         pub print_random_schedule_seed: bool,
         pub do_symmetry_reduction: bool,
-        // FIXME(GenMC): Add remaining parameters.
+        pub print_execution_graphs: ExecutiongraphPrinting,
+        /// Enabling this will set the memory model used by GenMC to "Sequential Consistency" (SC).
+        /// This will disable any weak memory effects, which reduces the number of program executions that will be explored.
+        pub disable_weak_memory_emulation: bool,
     }
 
     /// This is mostly equivalent to GenMC `VerbosityLevel`, but the debug log levels are always present (not conditionally compiled based on `ENABLE_GENMC_DEBUG`).
@@ -120,6 +129,19 @@ mod ffi {
         Debug3ReadsFrom,
     }
 
+    #[derive(Debug)]
+    /// Setting to control which execution graphs GenMC prints after every execution.
+    enum ExecutiongraphPrinting {
+        /// Print no graphs.
+        None,
+        /// Print graphs of all fully explored executions.
+        Explored,
+        /// Print graphs of all blocked executions.
+        Blocked,
+        /// Print graphs of all executions.
+        ExploredAndBlocked,
+    }
+
     /// This type corresponds to `Option<SVal>` (or `std::optional<SVal>`), where `SVal` is the type that GenMC uses for storing values.
     /// CXX doesn't support `std::optional` currently, so we need to use an extra `bool` to define whether this value is initialized or not.
     #[derive(Debug, Clone, Copy)]
@@ -163,7 +185,21 @@ mod ffi {
         is_coherence_order_maximal_write: bool,
     }
 
-    /**** Types shared between Miri/Rust and GenMC/C++ through cxx_bridge: ****/
+    #[must_use]
+    #[derive(Debug)]
+    struct ReadModifyWriteResult {
+        /// If there was an error, it will be stored in `error`, otherwise it is `None`.
+        error: UniquePtr<CxxString>,
+        /// The value that was read by the RMW operation as the left operand.
+        old_value: GenmcScalar,
+        /// The value that was produced by the RMW operation.
+        new_value: GenmcScalar,
+        /// `true` if the write should also be reflected in Miri's memory representation.
+        is_coherence_order_maximal_write: bool,
+    }
+
+    /**** These are GenMC types that we have to copy-paste here since cxx does not support
+    "importing" externally defined C++ types. ****/
 
     #[derive(Debug)]
     /// Corresponds to GenMC's type with the same name.
@@ -188,6 +224,21 @@ mod ffi {
         SequentiallyConsistent = 6,
     }
 
+    #[derive(Debug)]
+    enum RMWBinOp {
+        Xchg = 0,
+        Add = 1,
+        Sub = 2,
+        And = 3,
+        Nand = 4,
+        Or = 5,
+        Xor = 6,
+        Max = 7,
+        Min = 8,
+        UMax = 9,
+        UMin = 10,
+    }
+
     // # Safety
     //
     // This block is unsafe to allow defining safe methods inside.
@@ -202,9 +253,12 @@ mod ffi {
         /**** Types shared between Miri/Rust and Miri/C++: ****/
         type MiriGenmcShim;
 
-        /**** Types shared between Miri/Rust and GenMC/C++: ****/
+        /**** Types shared between Miri/Rust and GenMC/C++:
+        (This tells cxx that the enums defined above are already defined on the C++ side;
+        it will emit assertions to ensure that the two definitions agree.) ****/
         type ActionKind;
         type MemOrdering;
+        type RMWBinOp;
 
         /// Set the log level for GenMC.
         ///
@@ -249,6 +303,16 @@ mod ffi {
             memory_ordering: MemOrdering,
             old_value: GenmcScalar,
         ) -> LoadResult;
+        fn handle_read_modify_write(
+            self: Pin<&mut MiriGenmcShim>,
+            thread_id: i32,
+            address: u64,
+            size: u64,
+            rmw_op: RMWBinOp,
+            ordering: MemOrdering,
+            rhs_value: GenmcScalar,
+            old_value: GenmcScalar,
+        ) -> ReadModifyWriteResult;
         fn handle_store(
             self: Pin<&mut MiriGenmcShim>,
             thread_id: i32,
@@ -258,6 +322,11 @@ mod ffi {
             old_value: GenmcScalar,
             memory_ordering: MemOrdering,
         ) -> StoreResult;
+        fn handle_fence(
+            self: Pin<&mut MiriGenmcShim>,
+            thread_id: i32,
+            memory_ordering: MemOrdering,
+        );
 
         /**** Memory (de)allocation ****/
         fn handle_malloc(
diff --git a/src/tools/miri/src/bin/miri.rs b/src/tools/miri/src/bin/miri.rs
index ff05b4b14c79a..731fe283a2195 100644
--- a/src/tools/miri/src/bin/miri.rs
+++ b/src/tools/miri/src/bin/miri.rs
@@ -746,24 +746,11 @@ fn main() {
         many_seeds.map(|seeds| ManySeedsConfig { seeds, keep_going: many_seeds_keep_going });
 
     // Validate settings for data race detection and GenMC mode.
-    if miri_config.genmc_config.is_some() {
-        if !miri_config.data_race_detector {
-            fatal_error!("Cannot disable data race detection in GenMC mode");
-        } else if !miri_config.weak_memory_emulation {
-            fatal_error!("Cannot disable weak memory emulation in GenMC mode");
-        } else if !miri_config.native_lib.is_empty() {
-            fatal_error!("native-lib not supported in GenMC mode.");
-        }
-        if miri_config.borrow_tracker.is_some() {
-            eprintln!(
-                "warning: borrow tracking has been disabled, it is not (yet) supported in GenMC mode."
-            );
-            miri_config.borrow_tracker = None;
-        }
-        // We enable fixed scheduling so Miri doesn't randomly yield before a terminator, which anyway
-        // would be a NOP in GenMC mode.
-        miri_config.fixed_scheduling = true;
-    } else if miri_config.weak_memory_emulation && !miri_config.data_race_detector {
+    if let Err(err) = GenmcConfig::validate_genmc_mode_settings(&mut miri_config) {
+        fatal_error!("Invalid settings: {err}");
+    }
+
+    if miri_config.weak_memory_emulation && !miri_config.data_race_detector {
         fatal_error!(
             "Weak memory emulation cannot be enabled when the data race detector is disabled"
         );
diff --git a/src/tools/miri/src/concurrency/data_race.rs b/src/tools/miri/src/concurrency/data_race.rs
index a7822d0d6fa31..30061a78594aa 100644
--- a/src/tools/miri/src/concurrency/data_race.rs
+++ b/src/tools/miri/src/concurrency/data_race.rs
@@ -793,9 +793,9 @@ pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
                 this,
                 place.ptr().addr(),
                 place.layout.size,
+                atomic_op,
                 place.layout.backend_repr.is_signed(),
                 ord,
-                atomic_op,
                 rhs.to_scalar(),
                 old.to_scalar(),
             )?;
@@ -901,7 +901,6 @@ pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
                 can_fail_spuriously,
                 old.to_scalar(),
             )?;
-
             // The store might be the latest store in coherence order (determined by GenMC).
             // If it is, we need to update the value in Miri's memory:
             if let Some(new_value) = new_value {
@@ -961,6 +960,11 @@ pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
     /// The closure will only be invoked if data race handling is on.
     fn release_clock<R>(&self, callback: impl FnOnce(&VClock) -> R) -> Option<R> {
         let this = self.eval_context_ref();
+        // FIXME: make this a proper error instead of ICEing the interpreter.
+        assert!(
+            this.machine.data_race.as_genmc_ref().is_none(),
+            "this operation performs synchronization that is not supported in GenMC mode"
+        );
         Some(
             this.machine.data_race.as_vclocks_ref()?.release_clock(&this.machine.threads, callback),
         )
@@ -973,7 +977,9 @@ pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
         match &this.machine.data_race {
             GlobalDataRaceHandler::None => {}
             GlobalDataRaceHandler::Genmc(_genmc_ctx) =>
-                throw_unsup_format!("acquire_clock is not (yet) supported in GenMC mode."),
+                throw_unsup_format!(
+                    "this operation performs synchronization that is not supported in GenMC mode"
+                ),
             GlobalDataRaceHandler::Vclocks(data_race) =>
                 data_race.acquire_clock(clock, &this.machine.threads),
         }
diff --git a/src/tools/miri/src/concurrency/genmc/config.rs b/src/tools/miri/src/concurrency/genmc/config.rs
index 66116d5cf23c7..34933d423f064 100644
--- a/src/tools/miri/src/concurrency/genmc/config.rs
+++ b/src/tools/miri/src/concurrency/genmc/config.rs
@@ -1,4 +1,7 @@
-use genmc_sys::{GenmcParams, LogLevel};
+use genmc_sys::LogLevel;
+
+use super::GenmcParams;
+use crate::{IsolatedOp, MiriConfig, RejectOpWith};
 
 /// Configuration for GenMC mode.
 /// The `params` field is shared with the C++ side.
@@ -7,6 +10,9 @@ use genmc_sys::{GenmcParams, LogLevel};
 pub struct GenmcConfig {
     /// Parameters sent to the C++ side to create a new handle to the GenMC model checker.
     pub(super) params: GenmcParams,
+    /// Print the output message that GenMC generates when an error occurs.
+    /// This error message is currently hard to use, since there is no clear mapping between the events that GenMC sees and the Rust code location where this event was produced.
+    pub(super) print_genmc_output: bool,
     /// The log level for GenMC.
     pub(super) log_level: LogLevel,
 }
@@ -36,9 +42,61 @@ impl GenmcConfig {
         };
         if let Some(log_level) = trimmed_arg.strip_prefix("log=") {
             genmc_config.log_level = log_level.parse()?;
+        } else if let Some(trimmed_arg) = trimmed_arg.strip_prefix("print-exec-graphs") {
+            use genmc_sys::ExecutiongraphPrinting;
+            genmc_config.params.print_execution_graphs = match trimmed_arg {
+                "=none" => ExecutiongraphPrinting::None,
+                // Make GenMC print explored executions.
+                "" | "=explored" => ExecutiongraphPrinting::Explored,
+                // Make GenMC print blocked executions.
+                "=blocked" => ExecutiongraphPrinting::Blocked,
+                // Make GenMC print all executions.
+                "=all" => ExecutiongraphPrinting::ExploredAndBlocked,
+                _ =>
+                    return Err(format!(
+                        "Invalid suffix to GenMC argument '-Zmiri-genmc-print-exec-graphs', expected '', '=none', '=explored', '=blocked' or '=all'"
+                    )),
+            }
+        } else if trimmed_arg == "print-genmc-output" {
+            genmc_config.print_genmc_output = true;
         } else {
             return Err(format!("Invalid GenMC argument: \"-Zmiri-genmc-{trimmed_arg}\""));
         }
         Ok(())
     }
+
+    /// Validate settings for GenMC mode (NOP if GenMC mode disabled).
+    ///
+    /// Unsupported configurations return an error.
+    /// Adjusts Miri settings where required, printing a warnings if the change might be unexpected for the user.
+    pub fn validate_genmc_mode_settings(miri_config: &mut MiriConfig) -> Result<(), &'static str> {
+        let Some(genmc_config) = miri_config.genmc_config.as_mut() else {
+            return Ok(());
+        };
+
+        // Check for disallowed configurations.
+        if !miri_config.data_race_detector {
+            return Err("Cannot disable data race detection in GenMC mode");
+        } else if !miri_config.native_lib.is_empty() {
+            return Err("native-lib not supported in GenMC mode.");
+        } else if miri_config.isolated_op != IsolatedOp::Reject(RejectOpWith::Abort) {
+            return Err("Cannot disable isolation in GenMC mode");
+        }
+
+        // Adjust settings where needed.
+        if !miri_config.weak_memory_emulation {
+            genmc_config.params.disable_weak_memory_emulation = true;
+        }
+        if miri_config.borrow_tracker.is_some() {
+            eprintln!(
+                "warning: borrow tracking has been disabled, it is not (yet) supported in GenMC mode."
+            );
+            miri_config.borrow_tracker = None;
+        }
+        // We enable fixed scheduling so Miri doesn't randomly yield before a terminator, which anyway
+        // would be a NOP in GenMC mode.
+        miri_config.fixed_scheduling = true;
+
+        Ok(())
+    }
 }
diff --git a/src/tools/miri/src/concurrency/genmc/dummy.rs b/src/tools/miri/src/concurrency/genmc/dummy.rs
index 7c420961ec54a..92b34b83ee0fc 100644
--- a/src/tools/miri/src/concurrency/genmc/dummy.rs
+++ b/src/tools/miri/src/concurrency/genmc/dummy.rs
@@ -94,9 +94,9 @@ impl GenmcCtx {
         _ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
         _address: Size,
         _size: Size,
+        _atomic_op: AtomicRmwOp,
         _is_signed: bool,
         _ordering: AtomicRwOrd,
-        _atomic_op: AtomicRmwOp,
         _rhs_scalar: Scalar,
         _old_value: Scalar,
     ) -> InterpResult<'tcx, (Scalar, Option<Scalar>)> {
@@ -242,4 +242,10 @@ impl GenmcConfig {
             Err(format!("GenMC is not supported on this target"))
         }
     }
+
+    pub fn validate_genmc_mode_settings(
+        _miri_config: &mut crate::MiriConfig,
+    ) -> Result<(), &'static str> {
+        Ok(())
+    }
 }
diff --git a/src/tools/miri/src/concurrency/genmc/helper.rs b/src/tools/miri/src/concurrency/genmc/helper.rs
index b70ca8faadfed..2a84ca2036676 100644
--- a/src/tools/miri/src/concurrency/genmc/helper.rs
+++ b/src/tools/miri/src/concurrency/genmc/helper.rs
@@ -1,11 +1,16 @@
-use genmc_sys::MemOrdering;
+use genmc_sys::{MemOrdering, RMWBinOp};
 use rustc_abi::Size;
 use rustc_const_eval::interpret::{InterpResult, interp_ok};
+use rustc_middle::mir;
 use rustc_middle::ty::ScalarInt;
 use tracing::debug;
 
 use super::GenmcScalar;
-use crate::{AtomicReadOrd, AtomicWriteOrd, MiriInterpCx, Scalar, throw_unsup_format};
+use crate::intrinsics::AtomicRmwOp;
+use crate::{
+    AtomicFenceOrd, AtomicReadOrd, AtomicRwOrd, AtomicWriteOrd, MiriInterpCx, Scalar,
+    throw_unsup_format,
+};
 
 /// Maximum size memory access in bytes that GenMC supports.
 pub(super) const MAX_ACCESS_SIZE: u64 = 8;
@@ -95,3 +100,48 @@ impl AtomicWriteOrd {
         }
     }
 }
+
+impl AtomicFenceOrd {
+    pub(super) fn to_genmc(self) -> MemOrdering {
+        match self {
+            AtomicFenceOrd::Acquire => MemOrdering::Acquire,
+            AtomicFenceOrd::Release => MemOrdering::Release,
+            AtomicFenceOrd::AcqRel => MemOrdering::AcquireRelease,
+            AtomicFenceOrd::SeqCst => MemOrdering::SequentiallyConsistent,
+        }
+    }
+}
+
+impl AtomicRwOrd {
+    pub(super) fn to_genmc(self) -> MemOrdering {
+        match self {
+            AtomicRwOrd::Relaxed => MemOrdering::Relaxed,
+            AtomicRwOrd::Acquire => MemOrdering::Acquire,
+            AtomicRwOrd::Release => MemOrdering::Release,
+            AtomicRwOrd::AcqRel => MemOrdering::AcquireRelease,
+            AtomicRwOrd::SeqCst => MemOrdering::SequentiallyConsistent,
+        }
+    }
+}
+
+/// Convert an atomic binary operation to its GenMC counterpart.
+pub(super) fn to_genmc_rmw_op(atomic_op: AtomicRmwOp, is_signed: bool) -> RMWBinOp {
+    match (atomic_op, is_signed) {
+        (AtomicRmwOp::Min, true) => RMWBinOp::Min,
+        (AtomicRmwOp::Max, true) => RMWBinOp::Max,
+        (AtomicRmwOp::Min, false) => RMWBinOp::UMin,
+        (AtomicRmwOp::Max, false) => RMWBinOp::UMax,
+        (AtomicRmwOp::MirOp { op, neg }, _is_signed) =>
+            match (op, neg) {
+                (mir::BinOp::Add, false) => RMWBinOp::Add,
+                (mir::BinOp::Sub, false) => RMWBinOp::Sub,
+                (mir::BinOp::BitXor, false) => RMWBinOp::Xor,
+                (mir::BinOp::BitAnd, false) => RMWBinOp::And,
+                (mir::BinOp::BitAnd, true) => RMWBinOp::Nand,
+                (mir::BinOp::BitOr, false) => RMWBinOp::Or,
+                _ => {
+                    panic!("unsupported atomic operation: bin_op: {op:?}, negate: {neg}");
+                }
+            },
+    }
+}
diff --git a/src/tools/miri/src/concurrency/genmc/mod.rs b/src/tools/miri/src/concurrency/genmc/mod.rs
index 26ce0b9c43ac7..c1da86c673364 100644
--- a/src/tools/miri/src/concurrency/genmc/mod.rs
+++ b/src/tools/miri/src/concurrency/genmc/mod.rs
@@ -2,7 +2,7 @@ use std::cell::{Cell, RefCell};
 use std::sync::Arc;
 
 use genmc_sys::{
-    GENMC_GLOBAL_ADDRESSES_MASK, GenmcScalar, MemOrdering, MiriGenmcShim, UniquePtr,
+    GENMC_GLOBAL_ADDRESSES_MASK, GenmcScalar, MemOrdering, MiriGenmcShim, RMWBinOp, UniquePtr,
     create_genmc_driver_handle,
 };
 use rustc_abi::{Align, Size};
@@ -12,7 +12,9 @@ use rustc_middle::{throw_machine_stop, throw_ub_format, throw_unsup_format};
 use tracing::{debug, info};
 
 use self::global_allocations::{EvalContextExt as _, GlobalAllocationHandler};
-use self::helper::{MAX_ACCESS_SIZE, genmc_scalar_to_scalar, scalar_to_genmc_scalar};
+use self::helper::{
+    MAX_ACCESS_SIZE, genmc_scalar_to_scalar, scalar_to_genmc_scalar, to_genmc_rmw_op,
+};
 use self::thread_id_map::ThreadIdMap;
 use crate::concurrency::genmc::helper::split_access;
 use crate::intrinsics::AtomicRmwOp;
@@ -29,6 +31,8 @@ mod run;
 pub(crate) mod scheduling;
 mod thread_id_map;
 
+pub use genmc_sys::GenmcParams;
+
 pub use self::config::GenmcConfig;
 pub use self::run::run_genmc_mode;
 
@@ -126,22 +130,19 @@ impl GenmcCtx {
 
     /// Get the number of blocked executions encountered by GenMC.
     pub fn get_blocked_execution_count(&self) -> u64 {
-        let mc = self.handle.borrow();
-        mc.as_ref().unwrap().get_blocked_execution_count()
+        self.handle.borrow().get_blocked_execution_count()
     }
 
     /// Get the number of explored executions encountered by GenMC.
     pub fn get_explored_execution_count(&self) -> u64 {
-        let mc = self.handle.borrow();
-        mc.as_ref().unwrap().get_explored_execution_count()
+        self.handle.borrow().get_explored_execution_count()
     }
 
     /// Check if GenMC encountered an error that wasn't immediately returned during execution.
     /// Returns a string representation of the error if one occurred.
     pub fn try_get_error(&self) -> Option<String> {
-        let mc = self.handle.borrow();
-        mc.as_ref()
-            .unwrap()
+        self.handle
+            .borrow()
             .get_error_string()
             .as_ref()
             .map(|error| error.to_string_lossy().to_string())
@@ -150,9 +151,8 @@ impl GenmcCtx {
     /// Check if GenMC encountered an error that wasn't immediately returned during execution.
     /// Returns a string representation of the error if one occurred.
     pub fn get_result_message(&self) -> String {
-        let mc = self.handle.borrow();
-        mc.as_ref()
-            .unwrap()
+        self.handle
+            .borrow()
             .get_result_message()
             .as_ref()
             .map(|error| error.to_string_lossy().to_string())
@@ -163,8 +163,7 @@ impl GenmcCtx {
     ///
     /// In GenMC mode, the input program should be repeatedly executed until this function returns `true` or an error is found.
     pub fn is_exploration_done(&self) -> bool {
-        let mut mc = self.handle.borrow_mut();
-        mc.as_mut().unwrap().is_exploration_done()
+        self.handle.borrow_mut().pin_mut().is_exploration_done()
     }
 
     /// Select whether data race free actions should be allowed. This function should be used carefully!
@@ -196,8 +195,7 @@ impl GenmcCtx {
         // Reset per-execution state.
         self.exec_state.reset();
         // Inform GenMC about the new execution.
-        let mut mc = self.handle.borrow_mut();
-        mc.as_mut().unwrap().handle_execution_start();
+        self.handle.borrow_mut().pin_mut().handle_execution_start();
     }
 
     /// Inform GenMC that the program's execution has ended.
@@ -214,13 +212,11 @@ impl GenmcCtx {
     ///
     /// To get the all messages (warnings, errors) that GenMC produces, use the `get_result_message` method.
     fn handle_execution_end(&self) -> Option<String> {
-        let mut mc = self.handle.borrow_mut();
-        let result = mc.as_mut().unwrap().handle_execution_end();
+        let result = self.handle.borrow_mut().pin_mut().handle_execution_end();
         result.as_ref().map(|msg| msg.to_string_lossy().to_string())?;
 
         // GenMC currently does not return an error value immediately in all cases.
         // We manually query for any errors here to ensure we don't miss any.
-        drop(mc); // `try_get_error` needs access to the `RefCell`.
         self.try_get_error()
     }
 
@@ -282,11 +278,17 @@ impl GenmcCtx {
     /// Inform GenMC about an atomic fence.
     pub(crate) fn atomic_fence<'tcx>(
         &self,
-        _machine: &MiriMachine<'tcx>,
-        _ordering: AtomicFenceOrd,
+        machine: &MiriMachine<'tcx>,
+        ordering: AtomicFenceOrd,
     ) -> InterpResult<'tcx> {
         assert!(!self.get_alloc_data_races(), "atomic fence with data race checking disabled.");
-        throw_unsup_format!("FIXME(genmc): Add support for atomic fences.")
+
+        let thread_infos = self.exec_state.thread_id_manager.borrow();
+        let curr_thread = machine.threads.active_thread();
+        let genmc_tid = thread_infos.get_genmc_tid(curr_thread);
+
+        self.handle.borrow_mut().pin_mut().handle_fence(genmc_tid, ordering.to_genmc());
+        interp_ok(())
     }
 
     /// Inform GenMC about an atomic read-modify-write operation.
@@ -296,20 +298,24 @@ impl GenmcCtx {
     /// `old_value` is the value that a non-atomic load would read here, or `None` if the memory is uninitalized.
     pub(crate) fn atomic_rmw_op<'tcx>(
         &self,
-        _ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
-        _address: Size,
-        _size: Size,
-        _is_signed: bool,
-        _ordering: AtomicRwOrd,
-        _atomic_op: AtomicRmwOp,
-        _rhs_scalar: Scalar,
-        _old_value: Scalar,
+        ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
+        address: Size,
+        size: Size,
+        atomic_op: AtomicRmwOp,
+        is_signed: bool,
+        ordering: AtomicRwOrd,
+        rhs_scalar: Scalar,
+        old_value: Scalar,
     ) -> InterpResult<'tcx, (Scalar, Option<Scalar>)> {
-        assert!(
-            !self.get_alloc_data_races(),
-            "atomic read-modify-write operation with data race checking disabled."
-        );
-        throw_unsup_format!("FIXME(genmc): Add support for atomic RMW.")
+        self.handle_atomic_rmw_op(
+            ecx,
+            address,
+            size,
+            ordering,
+            to_genmc_rmw_op(atomic_op, is_signed),
+            scalar_to_genmc_scalar(ecx, rhs_scalar)?,
+            scalar_to_genmc_scalar(ecx, old_value)?,
+        )
     }
 
     /// Returns `(old_val, Option<new_val>)`. `new_val` might not be the latest write in coherence order, which is indicated by `None`.
@@ -317,18 +323,22 @@ impl GenmcCtx {
     /// `old_value` is the value that a non-atomic load would read here, or `None` if the memory is uninitalized.
     pub(crate) fn atomic_exchange<'tcx>(
         &self,
-        _ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
-        _address: Size,
-        _size: Size,
-        _rhs_scalar: Scalar,
-        _ordering: AtomicRwOrd,
-        _old_value: Scalar,
+        ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
+        address: Size,
+        size: Size,
+        rhs_scalar: Scalar,
+        ordering: AtomicRwOrd,
+        old_value: Scalar,
     ) -> InterpResult<'tcx, (Scalar, Option<Scalar>)> {
-        assert!(
-            !self.get_alloc_data_races(),
-            "atomic swap operation with data race checking disabled."
-        );
-        throw_unsup_format!("FIXME(genmc): Add support for atomic swap.")
+        self.handle_atomic_rmw_op(
+            ecx,
+            address,
+            size,
+            ordering,
+            /* genmc_rmw_op */ RMWBinOp::Xchg,
+            scalar_to_genmc_scalar(ecx, rhs_scalar)?,
+            scalar_to_genmc_scalar(ecx, old_value)?,
+        )
     }
 
     /// Inform GenMC about an atomic compare-exchange operation.
@@ -493,9 +503,11 @@ impl GenmcCtx {
         // GenMC doesn't support ZSTs, so we set the minimum size to 1 byte
         let genmc_size = size.bytes().max(1);
 
-        let mut mc = self.handle.borrow_mut();
-        let pinned_mc = mc.as_mut().unwrap();
-        let chosen_address = pinned_mc.handle_malloc(genmc_tid, genmc_size, alignment.bytes());
+        let chosen_address = self.handle.borrow_mut().pin_mut().handle_malloc(
+            genmc_tid,
+            genmc_size,
+            alignment.bytes(),
+        );
 
         // Non-global addresses should not be in the global address space or null.
         assert_ne!(0, chosen_address, "GenMC malloc returned nullptr.");
@@ -530,9 +542,7 @@ impl GenmcCtx {
         let curr_thread = machine.threads.active_thread();
         let genmc_tid = thread_infos.get_genmc_tid(curr_thread);
 
-        let mut mc = self.handle.borrow_mut();
-        let pinned_mc = mc.as_mut().unwrap();
-        pinned_mc.handle_free(genmc_tid, address.bytes());
+        self.handle.borrow_mut().pin_mut().handle_free(genmc_tid, address.bytes());
 
         interp_ok(())
     }
@@ -554,9 +564,7 @@ impl GenmcCtx {
         let genmc_parent_tid = thread_infos.get_genmc_tid(curr_thread_id);
         let genmc_new_tid = thread_infos.add_thread(new_thread_id);
 
-        let mut mc = self.handle.borrow_mut();
-        mc.as_mut().unwrap().handle_thread_create(genmc_new_tid, genmc_parent_tid);
-
+        self.handle.borrow_mut().pin_mut().handle_thread_create(genmc_new_tid, genmc_parent_tid);
         interp_ok(())
     }
 
@@ -571,8 +579,7 @@ impl GenmcCtx {
         let genmc_curr_tid = thread_infos.get_genmc_tid(active_thread_id);
         let genmc_child_tid = thread_infos.get_genmc_tid(child_thread_id);
 
-        let mut mc = self.handle.borrow_mut();
-        mc.as_mut().unwrap().handle_thread_join(genmc_curr_tid, genmc_child_tid);
+        self.handle.borrow_mut().pin_mut().handle_thread_join(genmc_curr_tid, genmc_child_tid);
 
         interp_ok(())
     }
@@ -585,9 +592,8 @@ impl GenmcCtx {
         let genmc_tid = thread_infos.get_genmc_tid(curr_thread_id);
 
         debug!("GenMC: thread {curr_thread_id:?} ({genmc_tid:?}) finished.");
-        let mut mc = self.handle.borrow_mut();
         // NOTE: Miri doesn't support return values for threads, but GenMC expects one, so we return 0
-        mc.as_mut().unwrap().handle_thread_finish(genmc_tid, /* ret_val */ 0);
+        self.handle.borrow_mut().pin_mut().handle_thread_finish(genmc_tid, /* ret_val */ 0);
     }
 
     /// Handle a call to `libc::exit` or the exit of the main thread.
@@ -618,8 +624,7 @@ impl GenmcCtx {
             let thread_infos = self.exec_state.thread_id_manager.borrow();
             let genmc_tid = thread_infos.get_genmc_tid(thread);
 
-            let mut mc = self.handle.borrow_mut();
-            mc.as_mut().unwrap().handle_thread_kill(genmc_tid);
+            self.handle.borrow_mut().pin_mut().handle_thread_kill(genmc_tid);
         } else {
             assert_eq!(thread, ThreadId::MAIN_THREAD);
         }
@@ -669,9 +674,7 @@ impl GenmcCtx {
             addr = address.bytes()
         );
 
-        let mut mc = self.handle.borrow_mut();
-        let pinned_mc = mc.as_mut().unwrap();
-        let load_result = pinned_mc.handle_load(
+        let load_result = self.handle.borrow_mut().pin_mut().handle_load(
             genmc_tid,
             address.bytes(),
             size.bytes(),
@@ -722,9 +725,7 @@ impl GenmcCtx {
             addr = address.bytes()
         );
 
-        let mut mc = self.handle.borrow_mut();
-        let pinned_mc = mc.as_mut().unwrap();
-        let store_result = pinned_mc.handle_store(
+        let store_result = self.handle.borrow_mut().pin_mut().handle_store(
             genmc_tid,
             address.bytes(),
             size.bytes(),
@@ -741,6 +742,62 @@ impl GenmcCtx {
         interp_ok(store_result.is_coherence_order_maximal_write)
     }
 
+    /// Inform GenMC about an atomic read-modify-write operation.
+    /// This includes atomic swap (also often called "exchange"), but does *not*
+    /// include compare-exchange (see `RMWBinOp` for full list of operations).
+    /// Returns the previous value at that memory location, and optionally the value that should be written back to Miri's memory.
+    fn handle_atomic_rmw_op<'tcx>(
+        &self,
+        ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
+        address: Size,
+        size: Size,
+        ordering: AtomicRwOrd,
+        genmc_rmw_op: RMWBinOp,
+        genmc_rhs_scalar: GenmcScalar,
+        genmc_old_value: GenmcScalar,
+    ) -> InterpResult<'tcx, (Scalar, Option<Scalar>)> {
+        assert!(
+            !self.get_alloc_data_races(),
+            "atomic read-modify-write operation with data race checking disabled."
+        );
+        assert_ne!(0, size.bytes());
+        assert!(
+            size.bytes() <= MAX_ACCESS_SIZE,
+            "GenMC currently does not support atomic accesses larger than {} bytes (got {} bytes)",
+            MAX_ACCESS_SIZE,
+            size.bytes()
+        );
+
+        let curr_thread_id = ecx.machine.threads.active_thread();
+        let genmc_tid = self.exec_state.thread_id_manager.borrow().get_genmc_tid(curr_thread_id);
+        debug!(
+            "GenMC: atomic_rmw_op, thread: {curr_thread_id:?} ({genmc_tid:?}) (op: {genmc_rmw_op:?}, rhs value: {genmc_rhs_scalar:?}), address: {address:?}, size: {size:?}, ordering: {ordering:?}",
+        );
+        let rmw_result = self.handle.borrow_mut().pin_mut().handle_read_modify_write(
+            genmc_tid,
+            address.bytes(),
+            size.bytes(),
+            genmc_rmw_op,
+            ordering.to_genmc(),
+            genmc_rhs_scalar,
+            genmc_old_value,
+        );
+
+        if let Some(error) = rmw_result.error.as_ref() {
+            // FIXME(genmc): error handling
+            throw_ub_format!("{}", error.to_string_lossy());
+        }
+
+        let old_value_scalar = genmc_scalar_to_scalar(ecx, rmw_result.old_value, size)?;
+
+        let new_value_scalar = if rmw_result.is_coherence_order_maximal_write {
+            Some(genmc_scalar_to_scalar(ecx, rmw_result.new_value, size)?)
+        } else {
+            None
+        };
+        interp_ok((old_value_scalar, new_value_scalar))
+    }
+
     /**** Blocking functionality ****/
 
     /// Handle a user thread getting blocked.
diff --git a/src/tools/miri/src/concurrency/genmc/run.rs b/src/tools/miri/src/concurrency/genmc/run.rs
index 62553297a2024..24d13e6375b11 100644
--- a/src/tools/miri/src/concurrency/genmc/run.rs
+++ b/src/tools/miri/src/concurrency/genmc/run.rs
@@ -18,6 +18,8 @@ pub fn run_genmc_mode<'tcx>(
     eval_entry: impl Fn(Rc<GenmcCtx>) -> Option<i32>,
     tcx: TyCtxt<'tcx>,
 ) -> Option<i32> {
+    let genmc_config = config.genmc_config.as_ref().unwrap();
+
     // There exists only one `global_state` per full run in GenMC mode.
     // It is shared by all `GenmcCtx` in this run.
     // FIXME(genmc): implement multithreading once GenMC supports it.
@@ -32,8 +34,15 @@ pub fn run_genmc_mode<'tcx>(
         genmc_ctx.prepare_next_execution();
 
         // Execute the program until completion to get the return value, or return if an error happens:
-        // FIXME(genmc): add an option to allow the user to see the GenMC output message when the verification is done.
-        let return_code = eval_entry(genmc_ctx.clone())?;
+        let Some(return_code) = eval_entry(genmc_ctx.clone()) else {
+            // If requested, print the output GenMC produced:
+            if genmc_config.print_genmc_output {
+                eprintln!("== raw GenMC output =========================");
+                eprintln!("{}", genmc_ctx.get_result_message());
+                eprintln!("== end of raw GenMC output ==================");
+            }
+            return None;
+        };
 
         // We inform GenMC that the execution is complete. If there was an error, we print it.
         if let Some(error) = genmc_ctx.handle_execution_end() {
diff --git a/src/tools/miri/tests/genmc/fail/loom/buggy_inc.rs b/src/tools/miri/tests/genmc/fail/loom/buggy_inc.rs
new file mode 100644
index 0000000000000..508eae756f320
--- /dev/null
+++ b/src/tools/miri/tests/genmc/fail/loom/buggy_inc.rs
@@ -0,0 +1,66 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) 2019 Carl Lerche
+
+// This is the test `checks_fail` from loom/test/smoke.rs adapted for Miri-GenMC.
+// https://github.com/tokio-rs/loom/blob/dbf32b04bae821c64be44405a0bb72ca08741558/tests/smoke.rs
+
+// This test checks that an incorrect implementation of an incrementing counter is detected.
+// The counter behaves wrong if two threads try to increment at the same time (increments can be lost).
+
+#![no_main]
+
+#[cfg(not(any(non_genmc_std, genmc_std)))]
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+struct BuggyInc {
+    num: AtomicUsize,
+}
+
+impl BuggyInc {
+    const fn new() -> BuggyInc {
+        BuggyInc { num: AtomicUsize::new(0) }
+    }
+
+    fn inc(&self) {
+        // The bug is here:
+        // Another thread can increment `self.num` between the next two lines,
+        // which is then overridden by this thread.
+        let curr = self.num.load(Acquire);
+        self.num.store(curr + 1, Release);
+    }
+}
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    unsafe {
+        static BUGGY_INC: BuggyInc = BuggyInc::new();
+        // FIXME(genmc,HACK): remove this initializing write once Miri-GenMC supports mixed atomic-non-atomic accesses.
+        BUGGY_INC.num.store(0, Relaxed);
+
+        let ids = [
+            spawn_pthread_closure(|| {
+                BUGGY_INC.inc();
+            }),
+            spawn_pthread_closure(|| {
+                BUGGY_INC.inc();
+            }),
+        ];
+        // Join so we can read the final values.
+        join_pthreads(ids);
+
+        // We check that we can detect the incorrect counter implementation:
+        if 2 != BUGGY_INC.num.load(Relaxed) {
+            std::process::abort(); //~ ERROR: abnormal termination
+        }
+
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/fail/loom/buggy_inc.stderr b/src/tools/miri/tests/genmc/fail/loom/buggy_inc.stderr
new file mode 100644
index 0000000000000..5a8948ff9b4b8
--- /dev/null
+++ b/src/tools/miri/tests/genmc/fail/loom/buggy_inc.stderr
@@ -0,0 +1,13 @@
+error: abnormal termination: the program aborted execution
+  --> tests/genmc/fail/loom/buggy_inc.rs:LL:CC
+   |
+LL |             std::process::abort();
+   |             ^^^^^^^^^^^^^^^^^^^^^ abnormal termination occurred here
+   |
+   = note: BACKTRACE:
+   = note: inside `miri_start` at tests/genmc/fail/loom/buggy_inc.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/genmc/fail/simple/2w2w_weak.relaxed4.stderr b/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.relaxed4.stderr
index e2b114df652f8..cbfb6ec833eb0 100644
--- a/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.relaxed4.stderr
+++ b/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.relaxed4.stderr
@@ -1,11 +1,9 @@
-error: Undefined Behavior: entering unreachable code
+error: abnormal termination: the program aborted execution
   --> tests/genmc/fail/simple/2w2w_weak.rs:LL:CC
    |
-LL |             std::hint::unreachable_unchecked();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
+LL |             std::process::abort();
+   |             ^^^^^^^^^^^^^^^^^^^^^ abnormal termination occurred here
    |
-   = 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 `miri_start` at tests/genmc/fail/simple/2w2w_weak.rs:LL:CC
 
diff --git a/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.release4.stderr b/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.release4.stderr
index e2b114df652f8..cbfb6ec833eb0 100644
--- a/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.release4.stderr
+++ b/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.release4.stderr
@@ -1,11 +1,9 @@
-error: Undefined Behavior: entering unreachable code
+error: abnormal termination: the program aborted execution
   --> tests/genmc/fail/simple/2w2w_weak.rs:LL:CC
    |
-LL |             std::hint::unreachable_unchecked();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
+LL |             std::process::abort();
+   |             ^^^^^^^^^^^^^^^^^^^^^ abnormal termination occurred here
    |
-   = 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 `miri_start` at tests/genmc/fail/simple/2w2w_weak.rs:LL:CC
 
diff --git a/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.rs b/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.rs
index dea2b5f952e7e..baf3584966ec8 100644
--- a/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.rs
+++ b/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.rs
@@ -7,7 +7,7 @@
 // When using any combination of orderings except using all 4 `SeqCst`, the memory model allows the program to result in (X, Y) == (1, 1).
 // The "pass" variants only check that we get the expected number of executions (3 for all SC, 4 otherwise),
 // and a valid outcome every execution, but do not check that we get all allowed results.
-// This "fail" variant ensures we can explore the execution resulting in (1, 1), an incorrect unsafe assumption that the result (1, 1) is impossible.
+// This "fail" variant ensures we can explore the execution resulting in (1, 1), with an incorrect assumption that the result (1, 1) is impossible.
 //
 // Miri without GenMC is unable to produce this program execution and thus detect the incorrect assumption, even with `-Zmiri-many-seeds`.
 //
@@ -61,11 +61,10 @@ fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
         // Join so we can read the final values.
         join_pthreads(ids);
 
-        // We mark the result (1, 1) as unreachable, which is incorrect.
+        // We incorrectly assume that the result (1, 1) as unreachable.
         let result = (X.load(Relaxed), Y.load(Relaxed));
         if result == (1, 1) {
-            // FIXME(genmc): Use `std::process::abort()` once backtraces for that are improved (https://github.com/rust-lang/rust/pull/146118)
-            std::hint::unreachable_unchecked(); //~ ERROR: entering unreachable code
+            std::process::abort(); //~ ERROR: abnormal termination
         }
 
         0
diff --git a/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.sc3_rel1.stderr b/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.sc3_rel1.stderr
index e2b114df652f8..cbfb6ec833eb0 100644
--- a/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.sc3_rel1.stderr
+++ b/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.sc3_rel1.stderr
@@ -1,11 +1,9 @@
-error: Undefined Behavior: entering unreachable code
+error: abnormal termination: the program aborted execution
   --> tests/genmc/fail/simple/2w2w_weak.rs:LL:CC
    |
-LL |             std::hint::unreachable_unchecked();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
+LL |             std::process::abort();
+   |             ^^^^^^^^^^^^^^^^^^^^^ abnormal termination occurred here
    |
-   = 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 `miri_start` at tests/genmc/fail/simple/2w2w_weak.rs:LL:CC
 
diff --git a/src/tools/miri/tests/genmc/pass/atomics/rmw_ops.rs b/src/tools/miri/tests/genmc/pass/atomics/rmw_ops.rs
new file mode 100644
index 0000000000000..f48466e8ce10c
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/atomics/rmw_ops.rs
@@ -0,0 +1,91 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// This test check for correct handling of atomic read-modify-write operations for all integer sizes.
+// Atomic max and min should return the previous value, and store the result in the atomic.
+// Atomic addition and subtraction should have wrapping semantics.
+// `and`, `nand`, `or`, `xor` should behave like their non-atomic counterparts.
+
+// FIXME(genmc): add 128 bit atomics for platforms that support it, once GenMC gets 128 bit atomic support
+
+#![no_main]
+
+use std::sync::atomic::*;
+
+const ORD: Ordering = Ordering::SeqCst;
+
+fn assert_eq<T: Eq>(x: T, y: T) {
+    if x != y {
+        std::process::abort();
+    }
+}
+
+macro_rules! test_rmw_edge_cases {
+    ($int:ty, $atomic:ty) => {{
+        let x = <$atomic>::new(123);
+        // FIXME(genmc,HACK): remove this initializing write once Miri-GenMC supports mixed atomic-non-atomic accesses.
+        x.store(123, ORD);
+
+        // MAX, ADD
+        assert_eq(123, x.fetch_max(0, ORD)); // `max` keeps existing value
+        assert_eq(123, x.fetch_max(<$int>::MAX, ORD)); // `max` stores the new value
+        assert_eq(<$int>::MAX, x.fetch_add(10, ORD)); // `fetch_add` should be wrapping
+        assert_eq(<$int>::MAX.wrapping_add(10), x.load(ORD));
+
+        // MIN, SUB
+        x.store(42, ORD);
+        assert_eq(42, x.fetch_min(<$int>::MAX, ORD)); // `min` keeps existing value
+        assert_eq(42, x.fetch_min(<$int>::MIN, ORD)); // `min` stores the new value
+        assert_eq(<$int>::MIN, x.fetch_sub(10, ORD)); // `fetch_sub` should be wrapping
+        assert_eq(<$int>::MIN.wrapping_sub(10), x.load(ORD));
+
+        // Small enough pattern to work for all integer sizes.
+        let pattern = 0b01010101;
+
+        // AND
+        x.store(!0, ORD);
+        assert_eq(!0, x.fetch_and(pattern, ORD));
+        assert_eq(!0 & pattern, x.load(ORD));
+
+        // NAND
+        x.store(!0, ORD);
+        assert_eq(!0, x.fetch_nand(pattern, ORD));
+        assert_eq(!(!0 & pattern), x.load(ORD));
+
+        // OR
+        x.store(!0, ORD);
+        assert_eq(!0, x.fetch_or(pattern, ORD));
+        assert_eq(!0 | pattern, x.load(ORD));
+
+        // XOR
+        x.store(!0, ORD);
+        assert_eq(!0, x.fetch_xor(pattern, ORD));
+        assert_eq(!0 ^ pattern, x.load(ORD));
+
+        // SWAP
+        x.store(!0, ORD);
+        assert_eq(!0, x.swap(pattern, ORD));
+        assert_eq(pattern, x.load(ORD));
+
+        // Check correct behavior of atomic min/max combined with overflowing add/sub.
+        x.store(10, ORD);
+        assert_eq(10, x.fetch_add(<$int>::MAX, ORD)); // definitely overflows, so new value of x is smaller than 10
+        assert_eq(<$int>::MAX.wrapping_add(10), x.fetch_max(10, ORD)); // new value of x should be 10
+        // assert_eq(10, x.load(ORD)); // FIXME(genmc,#4572): enable this check once GenMC correctly handles min/max truncation.
+    }};
+}
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    test_rmw_edge_cases!(u8, AtomicU8);
+    test_rmw_edge_cases!(u16, AtomicU16);
+    test_rmw_edge_cases!(u32, AtomicU32);
+    test_rmw_edge_cases!(u64, AtomicU64);
+    test_rmw_edge_cases!(usize, AtomicUsize);
+    test_rmw_edge_cases!(i8, AtomicI8);
+    test_rmw_edge_cases!(i16, AtomicI16);
+    test_rmw_edge_cases!(i32, AtomicI32);
+    test_rmw_edge_cases!(i64, AtomicI64);
+    test_rmw_edge_cases!(isize, AtomicIsize);
+
+    0
+}
diff --git a/src/tools/miri/tests/genmc/pass/atomics/rmw_ops.stderr b/src/tools/miri/tests/genmc/pass/atomics/rmw_ops.stderr
new file mode 100644
index 0000000000000..3b22247ee44cb
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/atomics/rmw_ops.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 1
diff --git a/src/tools/miri/tests/genmc/pass/litmus/2w2w_2sc_scf.rs b/src/tools/miri/tests/genmc/pass/litmus/2w2w_2sc_scf.rs
new file mode 100644
index 0000000000000..3b3fca02285d6
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/2w2w_2sc_scf.rs
@@ -0,0 +1,33 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's test "2+2W+2sc+scf".
+// It tests correct handling of SeqCst fences combined with relaxed accesses.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+static Y: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    unsafe {
+        spawn_pthread_closure(|| {
+            X.store(1, SeqCst);
+            Y.store(2, SeqCst);
+        });
+        spawn_pthread_closure(|| {
+            Y.store(1, Relaxed);
+            std::sync::atomic::fence(SeqCst);
+            X.store(2, Relaxed);
+        });
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/2w2w_2sc_scf.stderr b/src/tools/miri/tests/genmc/pass/litmus/2w2w_2sc_scf.stderr
new file mode 100644
index 0000000000000..115b1986ce557
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/2w2w_2sc_scf.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 3
diff --git a/src/tools/miri/tests/genmc/pass/litmus/2w2w_4rel.rs b/src/tools/miri/tests/genmc/pass/litmus/2w2w_4rel.rs
index bbe9995dea0b2..f47f5a11c5c96 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/2w2w_4rel.rs
+++ b/src/tools/miri/tests/genmc/pass/litmus/2w2w_4rel.rs
@@ -1,9 +1,13 @@
+//@revisions: weak sc
 //@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+//@[sc]compile-flags: -Zmiri-disable-weak-memory-emulation
 
 // Translated from GenMC's test "2+2W".
 //
 // The pass tests "2w2w_3sc_1rel.rs", "2w2w_4rel" and "2w2w_4sc" and the fail test "2w2w_weak.rs" are related.
 // Check "2w2w_weak.rs" for a more detailed description.
+//
+// The `sc` variant of this test checks that without weak memory emulation, only 3 instead of 4 executions are explored (like the `2w2w_4sc.rs` test).
 
 #![no_main]
 
diff --git a/src/tools/miri/tests/genmc/pass/litmus/2w2w_4rel.sc.stderr b/src/tools/miri/tests/genmc/pass/litmus/2w2w_4rel.sc.stderr
new file mode 100644
index 0000000000000..115b1986ce557
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/2w2w_4rel.sc.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 3
diff --git a/src/tools/miri/tests/genmc/pass/litmus/2w2w_4rel.stderr b/src/tools/miri/tests/genmc/pass/litmus/2w2w_4rel.weak.stderr
similarity index 100%
rename from src/tools/miri/tests/genmc/pass/litmus/2w2w_4rel.stderr
rename to src/tools/miri/tests/genmc/pass/litmus/2w2w_4rel.weak.stderr
diff --git a/src/tools/miri/tests/genmc/pass/litmus/IRIW-acq-sc.rs b/src/tools/miri/tests/genmc/pass/litmus/IRIW-acq-sc.rs
index 79e7c7feb7aac..1ec62ff21342d 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/IRIW-acq-sc.rs
+++ b/src/tools/miri/tests/genmc/pass/litmus/IRIW-acq-sc.rs
@@ -1,6 +1,6 @@
 //@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
 
-// Translated from GenMC's "IRIW-acq-sc" test.
+// Translated from GenMC's "litmus/IRIW-acq-sc" test.
 
 #![no_main]
 
diff --git a/src/tools/miri/tests/genmc/pass/litmus/IRIWish.rs b/src/tools/miri/tests/genmc/pass/litmus/IRIWish.rs
new file mode 100644
index 0000000000000..163556dcc8975
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/IRIWish.rs
@@ -0,0 +1,66 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's "litmus/IRIWish" test.
+// This test prints the values read by the different threads to check that we get all the values we expect.
+
+// NOTE: the order of the lines in the output may change with changes to GenMC.
+// Before blessing the new output, ensure that only the order of lines in the output changed, and none of the outputs are missing.
+
+// NOTE: GenMC supports instruction caching and does not need replay completed threads.
+// This means that an identical test in GenMC may output fewer lines (disable instruction caching to see all results).
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+#[path = "../../../utils/mod.rs"]
+mod utils;
+
+use std::fmt::Write;
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+use crate::utils::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+static Y: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    // FIXME(genmc,HACK): remove these initializing writes once Miri-GenMC supports mixed atomic-non-atomic accesses.
+    X.store(0, Relaxed);
+    Y.store(0, Relaxed);
+
+    unsafe {
+        let mut results = [1234; 5];
+        let ids = [
+            spawn_pthread_closure(|| {
+                X.store(1, Relaxed);
+            }),
+            spawn_pthread_closure(|| {
+                let r1 = X.load(Relaxed);
+                Y.store(r1, Release);
+                results[0] = r1;
+            }),
+            spawn_pthread_closure(|| {
+                results[1] = X.load(Relaxed);
+                std::sync::atomic::fence(AcqRel);
+                results[2] = Y.load(Relaxed);
+            }),
+            spawn_pthread_closure(|| {
+                results[3] = Y.load(Relaxed);
+                std::sync::atomic::fence(AcqRel);
+                results[4] = X.load(Relaxed);
+            }),
+        ];
+        join_pthreads(ids);
+
+        // Print the values to check that we get all of them:
+        if writeln!(MiriStderr, "{results:?}").is_err() {
+            std::process::abort();
+        }
+
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/IRIWish.stderr b/src/tools/miri/tests/genmc/pass/litmus/IRIWish.stderr
new file mode 100644
index 0000000000000..4fc77b63f3803
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/IRIWish.stderr
@@ -0,0 +1,30 @@
+[1, 1, 1, 1, 1]
+[1, 1, 1, 0, 1]
+[1, 1, 1, 0, 0]
+[1, 1, 0, 1, 1]
+[1, 1, 0, 0, 1]
+[1, 1, 0, 0, 0]
+[1, 0, 1, 1, 1]
+[1, 0, 1, 0, 1]
+[1, 0, 1, 0, 0]
+[1, 0, 0, 1, 1]
+[1, 0, 0, 0, 1]
+[1, 0, 0, 0, 0]
+[0, 1, 0, 0, 1]
+[0, 1, 0, 0, 0]
+[0, 1, 0, 0, 1]
+[0, 1, 0, 0, 0]
+[0, 1, 0, 0, 1]
+[0, 1, 0, 0, 0]
+[0, 1, 0, 0, 1]
+[0, 1, 0, 0, 0]
+[0, 0, 0, 0, 1]
+[0, 0, 0, 0, 0]
+[0, 0, 0, 0, 1]
+[0, 0, 0, 0, 0]
+[0, 0, 0, 0, 1]
+[0, 0, 0, 0, 0]
+[0, 0, 0, 0, 1]
+[0, 0, 0, 0, 0]
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 28
diff --git a/src/tools/miri/tests/genmc/pass/litmus/LB_incMPs.rs b/src/tools/miri/tests/genmc/pass/litmus/LB_incMPs.rs
new file mode 100644
index 0000000000000..e43d92fc6c55a
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/LB_incMPs.rs
@@ -0,0 +1,41 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's "litmus/LB+incMPs" test.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+static Y: AtomicU64 = AtomicU64::new(0);
+static W: AtomicU64 = AtomicU64::new(0);
+static Z: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    unsafe {
+        spawn_pthread_closure(|| {
+            X.load(Acquire);
+            Z.fetch_add(1, AcqRel);
+        });
+        spawn_pthread_closure(|| {
+            Z.fetch_add(1, AcqRel);
+            Y.store(1, Release);
+        });
+        spawn_pthread_closure(|| {
+            Y.load(Acquire);
+            W.fetch_add(1, AcqRel);
+        });
+        spawn_pthread_closure(|| {
+            W.fetch_add(1, AcqRel);
+            X.store(1, Release);
+        });
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/LB_incMPs.stderr b/src/tools/miri/tests/genmc/pass/litmus/LB_incMPs.stderr
new file mode 100644
index 0000000000000..c879e95a17085
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/LB_incMPs.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 15
diff --git a/src/tools/miri/tests/genmc/pass/litmus/MPU_rels_acq.rs b/src/tools/miri/tests/genmc/pass/litmus/MPU_rels_acq.rs
new file mode 100644
index 0000000000000..b36c8a288f426
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/MPU_rels_acq.rs
@@ -0,0 +1,42 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's "litmus/MPU+rels+acq" test.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+// Note: the GenMC equivalent of this test (genmc/tests/correct/litmus/MPU+rels+acq/mpu+rels+acq.c) uses non-atomic accesses for `X` with disabled race detection.
+static X: AtomicU64 = AtomicU64::new(0);
+static Y: AtomicU64 = AtomicU64::new(0);
+
+use crate::genmc::*;
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    // FIXME(genmc,HACK): remove these initializing writes once Miri-GenMC supports mixed atomic-non-atomic accesses.
+    X.store(0, Relaxed);
+    Y.store(0, Relaxed);
+
+    unsafe {
+        spawn_pthread_closure(|| {
+            X.store(1, Relaxed);
+
+            Y.store(0, Release);
+            Y.store(1, Relaxed);
+        });
+        spawn_pthread_closure(|| {
+            Y.fetch_add(1, Relaxed);
+        });
+        spawn_pthread_closure(|| {
+            if Y.load(Acquire) > 1 {
+                X.store(2, Relaxed);
+            }
+        });
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/MPU_rels_acq.stderr b/src/tools/miri/tests/genmc/pass/litmus/MPU_rels_acq.stderr
new file mode 100644
index 0000000000000..c5e34b00642aa
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/MPU_rels_acq.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 13
diff --git a/src/tools/miri/tests/genmc/pass/litmus/MP_incMPs.rs b/src/tools/miri/tests/genmc/pass/litmus/MP_incMPs.rs
new file mode 100644
index 0000000000000..a08b7de27d13c
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/MP_incMPs.rs
@@ -0,0 +1,36 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's "litmus/MP+incMP" test.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+static Y: AtomicU64 = AtomicU64::new(0);
+static Z: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    unsafe {
+        spawn_pthread_closure(|| {
+            Y.load(Acquire);
+            Z.fetch_add(1, AcqRel);
+        });
+        spawn_pthread_closure(|| {
+            Z.fetch_add(1, AcqRel);
+            X.load(Acquire);
+        });
+        spawn_pthread_closure(|| {
+            X.store(1, Release);
+            Y.store(1, Release);
+        });
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/MP_incMPs.stderr b/src/tools/miri/tests/genmc/pass/litmus/MP_incMPs.stderr
new file mode 100644
index 0000000000000..2be9a6c7fbded
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/MP_incMPs.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 7
diff --git a/src/tools/miri/tests/genmc/pass/litmus/MP_rels_acqf.rs b/src/tools/miri/tests/genmc/pass/litmus/MP_rels_acqf.rs
new file mode 100644
index 0000000000000..cf9f5f2dbfa34
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/MP_rels_acqf.rs
@@ -0,0 +1,40 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's "litmus/MP+rels+acqf" test.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+// Note: the GenMC equivalent of this test (genmc/tests/correct/litmus/MP+rels+acqf/mp+rels+acqf.c) uses non-atomic accesses for `X` with disabled race detection.
+static X: AtomicU64 = AtomicU64::new(0);
+static Y: AtomicU64 = AtomicU64::new(0);
+
+use crate::genmc::*;
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    // FIXME(genmc,HACK): remove these initializing writes once Miri-GenMC supports mixed atomic-non-atomic accesses.
+    X.store(0, Relaxed);
+    Y.store(0, Relaxed);
+
+    unsafe {
+        spawn_pthread_closure(|| {
+            X.store(1, Relaxed);
+
+            Y.store(0, Release);
+            Y.store(1, Relaxed);
+        });
+        spawn_pthread_closure(|| {
+            if Y.load(Relaxed) != 0 {
+                std::sync::atomic::fence(Acquire);
+                let _x = X.load(Relaxed);
+            }
+        });
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/MP_rels_acqf.stderr b/src/tools/miri/tests/genmc/pass/litmus/MP_rels_acqf.stderr
new file mode 100644
index 0000000000000..0667962f99c88
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/MP_rels_acqf.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 4
diff --git a/src/tools/miri/tests/genmc/pass/litmus/SB_2sc_scf.rs b/src/tools/miri/tests/genmc/pass/litmus/SB_2sc_scf.rs
new file mode 100644
index 0000000000000..ffc44de1bc7cf
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/SB_2sc_scf.rs
@@ -0,0 +1,32 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's "litmus/SB+2sc+scf" test.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+static Y: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    unsafe {
+        spawn_pthread_closure(|| {
+            X.store(1, SeqCst);
+            Y.load(SeqCst);
+        });
+        spawn_pthread_closure(|| {
+            Y.store(1, Relaxed);
+            std::sync::atomic::fence(SeqCst);
+            X.load(Relaxed);
+        });
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/SB_2sc_scf.stderr b/src/tools/miri/tests/genmc/pass/litmus/SB_2sc_scf.stderr
new file mode 100644
index 0000000000000..115b1986ce557
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/SB_2sc_scf.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 3
diff --git a/src/tools/miri/tests/genmc/pass/litmus/Z6_U.rs b/src/tools/miri/tests/genmc/pass/litmus/Z6_U.rs
new file mode 100644
index 0000000000000..ac5c3724254d6
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/Z6_U.rs
@@ -0,0 +1,65 @@
+//@revisions: weak sc
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+//@[sc]compile-flags: -Zmiri-disable-weak-memory-emulation
+
+// Translated from GenMC's "litmus/Z6.U" test.
+//
+// The `sc` variant of this test checks that we get fewer executions when weak memory emulation is disabled.
+
+// NOTE: the order of the lines in the output may change with changes to GenMC.
+// Before blessing the new output, ensure that only the order of lines in the output changed, and none of the outputs are missing.
+
+// NOTE: GenMC supports instruction caching and does not need replay completed threads.
+// This means that an identical test in GenMC may output fewer lines (disable instruction caching to see all results).
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+#[path = "../../../utils/mod.rs"]
+mod utils;
+
+use std::fmt::Write;
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+use crate::utils::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+static Y: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    // FIXME(genmc,HACK): remove these initializing writes once Miri-GenMC supports mixed atomic-non-atomic accesses.
+    X.store(0, Relaxed);
+    Y.store(0, Relaxed);
+
+    unsafe {
+        let mut a = 1234;
+        let mut b = 1234;
+        let ids = [
+            spawn_pthread_closure(|| {
+                X.store(1, SeqCst);
+                Y.store(1, Release);
+            }),
+            spawn_pthread_closure(|| {
+                Y.fetch_add(1, SeqCst);
+                a = Y.load(Relaxed);
+            }),
+            spawn_pthread_closure(|| {
+                Y.store(3, SeqCst);
+                b = X.load(SeqCst);
+            }),
+        ];
+        join_pthreads(ids);
+
+        // Print the values to check that we get all of them:
+        if writeln!(MiriStderr, "a={a}, b={b}, X={}, Y={}", X.load(Relaxed), Y.load(Relaxed))
+            .is_err()
+        {
+            std::process::abort();
+        }
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/Z6_U.sc.stderr b/src/tools/miri/tests/genmc/pass/litmus/Z6_U.sc.stderr
new file mode 100644
index 0000000000000..8dd2fbe1b9757
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/Z6_U.sc.stderr
@@ -0,0 +1,20 @@
+a=2, b=1, X=1, Y=3
+a=4, b=1, X=1, Y=4
+a=3, b=1, X=1, Y=3
+a=2, b=1, X=1, Y=2
+a=2, b=0, X=1, Y=2
+a=1, b=1, X=1, Y=1
+a=1, b=0, X=1, Y=1
+a=4, b=1, X=1, Y=1
+a=4, b=0, X=1, Y=1
+a=1, b=1, X=1, Y=3
+a=3, b=1, X=1, Y=3
+a=1, b=1, X=1, Y=1
+a=1, b=0, X=1, Y=1
+a=3, b=1, X=1, Y=1
+a=3, b=0, X=1, Y=1
+a=1, b=1, X=1, Y=3
+a=1, b=1, X=1, Y=1
+a=1, b=0, X=1, Y=1
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 18
diff --git a/src/tools/miri/tests/genmc/pass/litmus/Z6_U.weak.stderr b/src/tools/miri/tests/genmc/pass/litmus/Z6_U.weak.stderr
new file mode 100644
index 0000000000000..65622575de21d
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/Z6_U.weak.stderr
@@ -0,0 +1,24 @@
+a=2, b=1, X=1, Y=3
+a=4, b=1, X=1, Y=4
+a=4, b=0, X=1, Y=4
+a=3, b=1, X=1, Y=3
+a=2, b=1, X=1, Y=2
+a=2, b=0, X=1, Y=2
+a=1, b=1, X=1, Y=1
+a=1, b=0, X=1, Y=1
+a=4, b=1, X=1, Y=1
+a=4, b=0, X=1, Y=1
+a=1, b=1, X=1, Y=3
+a=1, b=0, X=1, Y=3
+a=3, b=1, X=1, Y=3
+a=3, b=0, X=1, Y=3
+a=1, b=1, X=1, Y=1
+a=1, b=0, X=1, Y=1
+a=3, b=1, X=1, Y=1
+a=3, b=0, X=1, Y=1
+a=1, b=1, X=1, Y=3
+a=1, b=0, X=1, Y=3
+a=1, b=1, X=1, Y=1
+a=1, b=0, X=1, Y=1
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 22
diff --git a/src/tools/miri/tests/genmc/pass/litmus/Z6_acq.rs b/src/tools/miri/tests/genmc/pass/litmus/Z6_acq.rs
new file mode 100644
index 0000000000000..b00f3a59ce672
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/Z6_acq.rs
@@ -0,0 +1,38 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's "litmus/Z6+acq" test.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+static Y: AtomicU64 = AtomicU64::new(0);
+static Z: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    unsafe {
+        spawn_pthread_closure(|| {
+            X.store(1, Relaxed);
+            std::sync::atomic::fence(SeqCst);
+            Y.store(1, Relaxed);
+        });
+        spawn_pthread_closure(|| {
+            Y.load(Acquire);
+            Z.store(1, Relaxed);
+        });
+        spawn_pthread_closure(|| {
+            Z.store(2, Relaxed);
+            std::sync::atomic::fence(SeqCst);
+            X.load(Relaxed);
+        });
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/Z6_acq.stderr b/src/tools/miri/tests/genmc/pass/litmus/Z6_acq.stderr
new file mode 100644
index 0000000000000..2be9a6c7fbded
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/Z6_acq.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 7
diff --git a/src/tools/miri/tests/genmc/pass/litmus/atomicpo.rs b/src/tools/miri/tests/genmc/pass/litmus/atomicpo.rs
new file mode 100644
index 0000000000000..75be89893dab8
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/atomicpo.rs
@@ -0,0 +1,32 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's test "litmus/atomicpo".
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+static Y: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    unsafe {
+        spawn_pthread_closure(|| {
+            X.store(1, Relaxed);
+            std::sync::atomic::fence(AcqRel);
+            Y.store(1, Relaxed);
+        });
+        spawn_pthread_closure(|| {
+            Y.swap(1, Relaxed);
+            X.swap(1, Relaxed);
+        });
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/atomicpo.stderr b/src/tools/miri/tests/genmc/pass/litmus/atomicpo.stderr
new file mode 100644
index 0000000000000..0667962f99c88
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/atomicpo.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 4
diff --git a/src/tools/miri/tests/genmc/pass/litmus/cumul-release.rs b/src/tools/miri/tests/genmc/pass/litmus/cumul-release.rs
new file mode 100644
index 0000000000000..2387976a8ca61
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/cumul-release.rs
@@ -0,0 +1,58 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's test "litmus/cumul-release".
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+static Y: AtomicU64 = AtomicU64::new(0);
+static Z: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    // FIXME(genmc,HACK): remove these initializing writes once Miri-GenMC supports mixed atomic-non-atomic accesses.
+    X.store(0, Relaxed);
+    Y.store(0, Relaxed);
+    Z.store(0, Relaxed);
+
+    unsafe {
+        let mut a = 1234;
+        let mut b = 1234;
+        let mut c = 1234;
+        let ids = [
+            spawn_pthread_closure(|| {
+                X.store(1, Relaxed);
+                Y.store(1, Release);
+            }),
+            spawn_pthread_closure(|| {
+                a = Y.load(Relaxed);
+                Z.store(a, Relaxed);
+            }),
+            spawn_pthread_closure(|| {
+                b = Z.load(Relaxed);
+                std::sync::atomic::fence(AcqRel);
+                c = X.load(Relaxed);
+            }),
+        ];
+        // Join so we can read the final values.
+        join_pthreads(ids);
+
+        // Check that we don't get any unexpected values:
+        if !matches!(
+            (a, b, c),
+            (0, 0, 0) | (0, 0, 1) | (1, 0, 0) | (1, 0, 1) | (1, 1, 0) | (1, 1, 1)
+        ) {
+            std::process::abort();
+        }
+
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/cumul-release.stderr b/src/tools/miri/tests/genmc/pass/litmus/cumul-release.stderr
new file mode 100644
index 0000000000000..00394048ec5c6
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/cumul-release.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 8
diff --git a/src/tools/miri/tests/genmc/pass/litmus/fr_w_w_w_reads.rs b/src/tools/miri/tests/genmc/pass/litmus/fr_w_w_w_reads.rs
index 9a08d517b7c60..796ffbf97f96b 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/fr_w_w_w_reads.rs
+++ b/src/tools/miri/tests/genmc/pass/litmus/fr_w_w_w_reads.rs
@@ -38,7 +38,6 @@ fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
                 result[3] = X.load(Relaxed);
             }),
         ];
-
         // Join so we can read the final values.
         join_pthreads(ids);
 
diff --git a/src/tools/miri/tests/genmc/pass/litmus/inc2w.rs b/src/tools/miri/tests/genmc/pass/litmus/inc2w.rs
new file mode 100644
index 0000000000000..fd8574c4f7c78
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/inc2w.rs
@@ -0,0 +1,45 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's test "litmus/inc2w".
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    // FIXME(genmc,HACK): remove this initializing write once Miri-GenMC supports mixed atomic-non-atomic accesses.
+    X.store(0, Relaxed);
+
+    unsafe {
+        let ids = [
+            spawn_pthread_closure(|| {
+                X.fetch_add(1, Relaxed);
+            }),
+            spawn_pthread_closure(|| {
+                X.store(4, Release);
+            }),
+            spawn_pthread_closure(|| {
+                X.fetch_add(2, Relaxed);
+            }),
+        ];
+        // Join so we can read the final values.
+        join_pthreads(ids);
+
+        // Check that we don't get any unexpected values:
+        let x = X.load(Relaxed);
+        if !matches!(x, 4..=7) {
+            std::process::abort();
+        }
+
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/inc2w.stderr b/src/tools/miri/tests/genmc/pass/litmus/inc2w.stderr
new file mode 100644
index 0000000000000..be75e68fde77d
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/inc2w.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 6
diff --git a/src/tools/miri/tests/genmc/pass/litmus/inc_inc_RR_W_RR.rs b/src/tools/miri/tests/genmc/pass/litmus/inc_inc_RR_W_RR.rs
new file mode 100644
index 0000000000000..40ca486318598
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/inc_inc_RR_W_RR.rs
@@ -0,0 +1,63 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::ffi::c_void;
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+
+static mut A: u64 = 0;
+static mut B: u64 = 0;
+static mut C: u64 = 0;
+static mut D: u64 = 0;
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    let thread_order = [thread_1, thread_2, thread_3, thread_4, thread_5];
+    let ids = unsafe { spawn_pthreads_no_params(thread_order) };
+    unsafe { join_pthreads(ids) };
+
+    if unsafe { A == 42 && B == 2 && C == 1 && D == 42 } {
+        std::process::abort();
+    }
+
+    0
+}
+
+pub extern "C" fn thread_1(_value: *mut c_void) -> *mut c_void {
+    X.fetch_add(1, Relaxed);
+    std::ptr::null_mut()
+}
+
+pub extern "C" fn thread_2(_value: *mut c_void) -> *mut c_void {
+    X.fetch_add(1, Relaxed);
+    std::ptr::null_mut()
+}
+
+pub extern "C" fn thread_3(_value: *mut c_void) -> *mut c_void {
+    unsafe {
+        A = X.load(Relaxed);
+        B = X.load(Relaxed);
+    }
+    std::ptr::null_mut()
+}
+
+pub extern "C" fn thread_4(_value: *mut c_void) -> *mut c_void {
+    X.store(42, Relaxed);
+    std::ptr::null_mut()
+}
+
+pub extern "C" fn thread_5(_value: *mut c_void) -> *mut c_void {
+    unsafe {
+        C = X.load(Relaxed);
+        D = X.load(Relaxed);
+    }
+    std::ptr::null_mut()
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/inc_inc_RR_W_RR.stderr b/src/tools/miri/tests/genmc/pass/litmus/inc_inc_RR_W_RR.stderr
new file mode 100644
index 0000000000000..b5f8cd15b683f
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/inc_inc_RR_W_RR.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 600
diff --git a/src/tools/miri/tests/genmc/pass/litmus/riwi.rs b/src/tools/miri/tests/genmc/pass/litmus/riwi.rs
new file mode 100644
index 0000000000000..49564c8e4fe0a
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/riwi.rs
@@ -0,0 +1,31 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's "litmus/riwi" test.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+static Y: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    unsafe {
+        spawn_pthread_closure(|| {
+            Y.load(Relaxed);
+            X.fetch_add(1, Relaxed);
+        });
+        spawn_pthread_closure(|| {
+            X.fetch_add(1, Relaxed);
+            Y.store(1, Release);
+        });
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/riwi.stderr b/src/tools/miri/tests/genmc/pass/litmus/riwi.stderr
new file mode 100644
index 0000000000000..115b1986ce557
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/riwi.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 3
diff --git a/src/tools/miri/tests/genmc/pass/litmus/viktor-relseq.rs b/src/tools/miri/tests/genmc/pass/litmus/viktor-relseq.rs
new file mode 100644
index 0000000000000..a193dcf0683ea
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/viktor-relseq.rs
@@ -0,0 +1,36 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's "litmus/viktor-relseq" test.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static LOCK: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    unsafe {
+        spawn_pthread_closure(|| {
+            LOCK.fetch_add(1, Acquire);
+            LOCK.fetch_add(1, Relaxed);
+        });
+        spawn_pthread_closure(|| {
+            LOCK.fetch_add(1, Relaxed);
+            LOCK.fetch_add(1, Relaxed);
+        });
+        spawn_pthread_closure(|| {
+            LOCK.fetch_add(1, Release);
+        });
+        spawn_pthread_closure(|| {
+            LOCK.fetch_add(1, Relaxed);
+        });
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/viktor-relseq.stderr b/src/tools/miri/tests/genmc/pass/litmus/viktor-relseq.stderr
new file mode 100644
index 0000000000000..d63ac5199d5d4
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/viktor-relseq.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 180
diff --git a/src/tools/miri/tests/utils/genmc.rs b/src/tools/miri/tests/utils/genmc.rs
index fb6334bd06086..29b3181992b11 100644
--- a/src/tools/miri/tests/utils/genmc.rs
+++ b/src/tools/miri/tests/utils/genmc.rs
@@ -51,6 +51,13 @@ pub unsafe fn join_pthread(thread_id: pthread_t) {
     }
 }
 
+/// Spawn `N` threads using `pthread_create` without any arguments, abort the process on any errors.
+pub unsafe fn spawn_pthreads_no_params<const N: usize>(
+    functions: [extern "C" fn(*mut c_void) -> *mut c_void; N],
+) -> [pthread_t; N] {
+    functions.map(|func| spawn_pthread(func, std::ptr::null_mut()))
+}
+
 // Join the `N` given pthreads, abort the process on any errors.
 pub unsafe fn join_pthreads<const N: usize>(thread_ids: [pthread_t; N]) {
     let _ = thread_ids.map(|id| join_pthread(id));

From cfc73b5c94243ef41eb705f7de49eb8a1efabdc6 Mon Sep 17 00:00:00 2001
From: The rustc-josh-sync Cronjob Bot <github-actions@github.com>
Date: Mon, 8 Sep 2025 04:10:15 +0000
Subject: [PATCH 0634/1889] Prepare for merging from rust-lang/rust

This updates the rust-version file to 2f3f27bf79ec147fec9d2e7980605307a74067f4.
---
 src/doc/rustc-dev-guide/rust-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/rust-version b/src/doc/rustc-dev-guide/rust-version
index f412399cc8c39..df2bac877b66f 100644
--- a/src/doc/rustc-dev-guide/rust-version
+++ b/src/doc/rustc-dev-guide/rust-version
@@ -1 +1 @@
-a1dbb443527bd126452875eb5d5860c1d001d761
+2f3f27bf79ec147fec9d2e7980605307a74067f4

From 7fa23530bfe04fa9644c1bdaa245aaa24101a1b5 Mon Sep 17 00:00:00 2001
From: Justin Yao Du <justinyaodu@gmail.com>
Date: Sun, 7 Sep 2025 21:16:35 -0700
Subject: [PATCH 0635/1889] Fix typo in default.rs

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

diff --git a/library/core/src/default.rs b/library/core/src/default.rs
index cc9289307c1df..1cc4fb6e8fdd3 100644
--- a/library/core/src/default.rs
+++ b/library/core/src/default.rs
@@ -33,7 +33,7 @@ use crate::ascii::Char as AsciiChar;
 /// }
 /// ```
 ///
-/// Now, you get all of the default values. Rust implements `Default` for various primitives types.
+/// Now, you get all of the default values. Rust implements `Default` for various primitive types.
 ///
 /// If you want to override a particular option, but still retain the other defaults:
 ///

From 1806a8244e96e3cb2be8dc93d95e350f81505083 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Mon, 8 Sep 2025 06:20:07 +0200
Subject: [PATCH 0636/1889] remove confusing parts of sentence

I can guess what this meant, but decided to just keep it simple
---
 src/doc/rustc-dev-guide/src/profiling/with_perf.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/profiling/with_perf.md b/src/doc/rustc-dev-guide/src/profiling/with_perf.md
index 0d4f23bcd9ad3..e452dde5226d4 100644
--- a/src/doc/rustc-dev-guide/src/profiling/with_perf.md
+++ b/src/doc/rustc-dev-guide/src/profiling/with_perf.md
@@ -4,8 +4,7 @@ This is a guide for how to profile rustc with [perf](https://perf.wiki.kernel.or
 
 ## Initial steps
 
-- Get a clean checkout of rust-lang/master, or whatever it is you want
-  to profile.
+- Get a clean checkout of rust-lang/rust
 - Set the following settings in your `bootstrap.toml`:
   - `rust.debuginfo-level = 1` - enables line debuginfo
   - `rust.jemalloc = false` - lets you do memory use profiling with valgrind

From 755db7fdac7217dc320cd2649e213df63e6411dd Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Mon, 8 Sep 2025 06:48:10 +0200
Subject: [PATCH 0637/1889] sembr

---
 .../bootstrapping/writing-tools-in-bootstrap.md  | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/building/bootstrapping/writing-tools-in-bootstrap.md b/src/doc/rustc-dev-guide/src/building/bootstrapping/writing-tools-in-bootstrap.md
index c3660e24b1526..f5f4dfadce27f 100644
--- a/src/doc/rustc-dev-guide/src/building/bootstrapping/writing-tools-in-bootstrap.md
+++ b/src/doc/rustc-dev-guide/src/building/bootstrapping/writing-tools-in-bootstrap.md
@@ -4,16 +4,22 @@ There are three types of tools you can write in bootstrap:
 
 - **`Mode::ToolBootstrap`**
   Use this for tools that don’t need anything from the in-tree compiler and can run with the stage0 `rustc`.
-  The output is placed in the "bootstrap-tools" directory. This mode is for general-purpose tools built
-  entirely with the stage0 compiler, including target libraries and only works for stage 0.
+  The output is placed in the "bootstrap-tools" directory.
+  This mode is for general-purpose tools built entirely with the stage0 compiler,
+  including target libraries and only works for stage 0.
 
 - **`Mode::ToolStd`**
-  Use this for tools that rely on the locally built std. The output goes into the "stageN-tools" directory.
+  Use this for tools that rely on the locally built std.
+  The output goes into the "stageN-tools" directory.
   This mode is rarely used, mainly for `compiletest` which requires `libtest`.
 
 - **`Mode::ToolRustcPrivate`**
-  Use this for tools that use the `rustc_private` mechanism, and thus depend on the locally built `rustc` and its rlib artifacts. This is more complex than the other modes because the tool must be built with the same compiler used for `rustc` and placed in the "stageN-tools" directory. When you choose `Mode::ToolRustcPrivate`, `ToolBuild` implementation takes care of this automatically. If you need to use the builder’s compiler for something specific, you can get it from `ToolBuildResult`, which is
-  returned by the tool's [`Step`].
+  Use this for tools that use the `rustc_private` mechanism,
+  and thus depend on the locally built `rustc` and its rlib artifacts.
+  This is more complex than the other modes because the tool must be built with the same compiler used for `rustc` and placed in the "stageN-tools" directory.
+  When you choose `Mode::ToolRustcPrivate`, `ToolBuild` implementation takes care of this automatically.
+  If you need to use the builder’s compiler for something specific,
+  you can get it from `ToolBuildResult`, which is returned by the tool's [`Step`].
 
 Regardless of the tool type you must return `ToolBuildResult` from the tool’s [`Step`] implementation and use `ToolBuild` inside it.
 

From cb0e26ff4c40bc7e8e05d62f12ca685928a5f130 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Mon, 8 Sep 2025 06:50:14 +0200
Subject: [PATCH 0638/1889] fix markup

---
 .../src/building/bootstrapping/writing-tools-in-bootstrap.md   | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/doc/rustc-dev-guide/src/building/bootstrapping/writing-tools-in-bootstrap.md b/src/doc/rustc-dev-guide/src/building/bootstrapping/writing-tools-in-bootstrap.md
index f5f4dfadce27f..8bda2257536a4 100644
--- a/src/doc/rustc-dev-guide/src/building/bootstrapping/writing-tools-in-bootstrap.md
+++ b/src/doc/rustc-dev-guide/src/building/bootstrapping/writing-tools-in-bootstrap.md
@@ -3,17 +3,20 @@
 There are three types of tools you can write in bootstrap:
 
 - **`Mode::ToolBootstrap`**
+
   Use this for tools that don’t need anything from the in-tree compiler and can run with the stage0 `rustc`.
   The output is placed in the "bootstrap-tools" directory.
   This mode is for general-purpose tools built entirely with the stage0 compiler,
   including target libraries and only works for stage 0.
 
 - **`Mode::ToolStd`**
+
   Use this for tools that rely on the locally built std.
   The output goes into the "stageN-tools" directory.
   This mode is rarely used, mainly for `compiletest` which requires `libtest`.
 
 - **`Mode::ToolRustcPrivate`**
+
   Use this for tools that use the `rustc_private` mechanism,
   and thus depend on the locally built `rustc` and its rlib artifacts.
   This is more complex than the other modes because the tool must be built with the same compiler used for `rustc` and placed in the "stageN-tools" directory.

From 94da52007bf7583a833911c92cb58f9e90544542 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Mon, 8 Sep 2025 06:54:04 +0200
Subject: [PATCH 0639/1889] readability

---
 .../src/building/bootstrapping/writing-tools-in-bootstrap.md    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/src/building/bootstrapping/writing-tools-in-bootstrap.md b/src/doc/rustc-dev-guide/src/building/bootstrapping/writing-tools-in-bootstrap.md
index 8bda2257536a4..8250a6f3b51df 100644
--- a/src/doc/rustc-dev-guide/src/building/bootstrapping/writing-tools-in-bootstrap.md
+++ b/src/doc/rustc-dev-guide/src/building/bootstrapping/writing-tools-in-bootstrap.md
@@ -7,7 +7,7 @@ There are three types of tools you can write in bootstrap:
   Use this for tools that don’t need anything from the in-tree compiler and can run with the stage0 `rustc`.
   The output is placed in the "bootstrap-tools" directory.
   This mode is for general-purpose tools built entirely with the stage0 compiler,
-  including target libraries and only works for stage 0.
+  including target libraries, and it only works for stage 0.
 
 - **`Mode::ToolStd`**
 

From 344b4ac427999c382f575308af3569b2148485a9 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 8 Sep 2025 07:55:10 +0200
Subject: [PATCH 0640/1889] print proper error when using unsupported
 synchronization primitive with GenMC

---
 src/tools/miri/src/alloc_addresses/mod.rs     |  2 +
 src/tools/miri/src/concurrency/data_race.rs   | 22 +++---
 src/tools/miri/src/concurrency/init_once.rs   | 10 +--
 src/tools/miri/src/concurrency/sync.rs        | 68 ++++++-------------
 .../miri/src/shims/unix/linux_like/epoll.rs   |  2 +-
 .../miri/src/shims/unix/linux_like/eventfd.rs |  2 +-
 src/tools/miri/src/shims/unix/macos/sync.rs   |  4 +-
 src/tools/miri/src/shims/unix/sync.rs         | 16 ++---
 .../miri/src/shims/unix/unnamed_socket.rs     |  2 +-
 9 files changed, 52 insertions(+), 76 deletions(-)

diff --git a/src/tools/miri/src/alloc_addresses/mod.rs b/src/tools/miri/src/alloc_addresses/mod.rs
index 5d94a1f4138a6..f011ee717850d 100644
--- a/src/tools/miri/src/alloc_addresses/mod.rs
+++ b/src/tools/miri/src/alloc_addresses/mod.rs
@@ -498,6 +498,8 @@ impl<'tcx> MiriMachine<'tcx> {
         // Also remember this address for future reuse.
         let thread = self.threads.active_thread();
         global_state.reuse.add_addr(rng, addr, size, align, kind, thread, || {
+            // We already excluded GenMC above. We cannot use `self.release_clock` as
+            // `self.alloc_addresses` is borrowed.
             if let Some(data_race) = self.data_race.as_vclocks_ref() {
                 data_race.release_clock(&self.threads, |clock| clock.clone())
             } else {
diff --git a/src/tools/miri/src/concurrency/data_race.rs b/src/tools/miri/src/concurrency/data_race.rs
index 30061a78594aa..de60e80b9f7eb 100644
--- a/src/tools/miri/src/concurrency/data_race.rs
+++ b/src/tools/miri/src/concurrency/data_race.rs
@@ -958,16 +958,20 @@ pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
     /// with this program point.
     ///
     /// The closure will only be invoked if data race handling is on.
-    fn release_clock<R>(&self, callback: impl FnOnce(&VClock) -> R) -> Option<R> {
+    fn release_clock<R>(
+        &self,
+        callback: impl FnOnce(&VClock) -> R,
+    ) -> InterpResult<'tcx, Option<R>> {
         let this = self.eval_context_ref();
-        // FIXME: make this a proper error instead of ICEing the interpreter.
-        assert!(
-            this.machine.data_race.as_genmc_ref().is_none(),
-            "this operation performs synchronization that is not supported in GenMC mode"
-        );
-        Some(
-            this.machine.data_race.as_vclocks_ref()?.release_clock(&this.machine.threads, callback),
-        )
+        interp_ok(match &this.machine.data_race {
+            GlobalDataRaceHandler::None => None,
+            GlobalDataRaceHandler::Genmc(_genmc_ctx) =>
+                throw_unsup_format!(
+                    "this operation performs synchronization that is not supported in GenMC mode"
+                ),
+            GlobalDataRaceHandler::Vclocks(data_race) =>
+                Some(data_race.release_clock(&this.machine.threads, callback)),
+        })
     }
 
     /// Acquire the given clock into the current thread, establishing synchronization with
diff --git a/src/tools/miri/src/concurrency/init_once.rs b/src/tools/miri/src/concurrency/init_once.rs
index 3fb3d890419f7..daea20b3779b2 100644
--- a/src/tools/miri/src/concurrency/init_once.rs
+++ b/src/tools/miri/src/concurrency/init_once.rs
@@ -96,10 +96,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         init_once.status = InitOnceStatus::Complete;
 
         // Each complete happens-before the end of the wait
-        if let Some(data_race) = this.machine.data_race.as_vclocks_ref() {
-            data_race
-                .release_clock(&this.machine.threads, |clock| init_once.clock.clone_from(clock));
-        }
+        this.release_clock(|clock| init_once.clock.clone_from(clock))?;
 
         // Wake up everyone.
         // need to take the queue to avoid having `this` be borrowed multiple times
@@ -125,10 +122,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         init_once.status = InitOnceStatus::Uninitialized;
 
         // Each complete happens-before the end of the wait
-        if let Some(data_race) = this.machine.data_race.as_vclocks_ref() {
-            data_race
-                .release_clock(&this.machine.threads, |clock| init_once.clock.clone_from(clock));
-        }
+        this.release_clock(|clock| init_once.clock.clone_from(clock))?;
 
         // Wake up one waiting thread, so they can go ahead and try to init this.
         if let Some(waiter) = init_once.waiters.pop_front() {
diff --git a/src/tools/miri/src/concurrency/sync.rs b/src/tools/miri/src/concurrency/sync.rs
index 179094db0febd..15d486c27e36a 100644
--- a/src/tools/miri/src/concurrency/sync.rs
+++ b/src/tools/miri/src/concurrency/sync.rs
@@ -204,7 +204,7 @@ pub(super) trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
             this.mutex_enqueue_and_block(mutex_ref, Some((retval, dest)));
         } else {
             // We can have it right now!
-            this.mutex_lock(&mutex_ref);
+            this.mutex_lock(&mutex_ref)?;
             // Don't forget to write the return value.
             this.write_scalar(retval, &dest)?;
         }
@@ -338,7 +338,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     }
 
     /// Lock by setting the mutex owner and increasing the lock count.
-    fn mutex_lock(&mut self, mutex_ref: &MutexRef) {
+    fn mutex_lock(&mut self, mutex_ref: &MutexRef) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
         let thread = this.active_thread();
         let mut mutex = mutex_ref.0.borrow_mut();
@@ -352,9 +352,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             mutex.owner = Some(thread);
         }
         mutex.lock_count = mutex.lock_count.strict_add(1);
-        if let Some(data_race) = this.machine.data_race.as_vclocks_ref() {
-            data_race.acquire_clock(&mutex.clock, &this.machine.threads);
-        }
+        this.acquire_clock(&mutex.clock)?;
+        interp_ok(())
     }
 
     /// Try unlocking by decreasing the lock count and returning the old lock
@@ -377,11 +376,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 // The mutex is completely unlocked. Try transferring ownership
                 // to another thread.
 
-                if let Some(data_race) = this.machine.data_race.as_vclocks_ref() {
-                    data_race.release_clock(&this.machine.threads, |clock| {
-                        mutex.clock.clone_from(clock)
-                    });
-                }
+                this.release_clock(|clock| mutex.clock.clone_from(clock))?;
                 let thread_id = mutex.queue.pop_front();
                 // We need to drop our mutex borrow before unblock_thread
                 // because it will be borrowed again in the unblock callback.
@@ -425,7 +420,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     assert_eq!(unblock, UnblockKind::Ready);
 
                     assert!(mutex_ref.owner().is_none());
-                    this.mutex_lock(&mutex_ref);
+                    this.mutex_lock(&mutex_ref)?;
 
                     if let Some((retval, dest)) = retval_dest {
                         this.write_scalar(retval, &dest)?;
@@ -439,7 +434,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
     /// Read-lock the lock by adding the `reader` the list of threads that own
     /// this lock.
-    fn rwlock_reader_lock(&mut self, rwlock_ref: &RwLockRef) {
+    fn rwlock_reader_lock(&mut self, rwlock_ref: &RwLockRef) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
         let thread = this.active_thread();
         trace!("rwlock_reader_lock: now also held (one more time) by {:?}", thread);
@@ -447,9 +442,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         assert!(!rwlock.is_write_locked(), "the lock is write locked");
         let count = rwlock.readers.entry(thread).or_insert(0);
         *count = count.strict_add(1);
-        if let Some(data_race) = this.machine.data_race.as_vclocks_ref() {
-            data_race.acquire_clock(&rwlock.clock_unlocked, &this.machine.threads);
-        }
+        this.acquire_clock(&rwlock.clock_unlocked)?;
+        interp_ok(())
     }
 
     /// Try read-unlock the lock for the current threads and potentially give the lock to a new owner.
@@ -472,12 +466,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             }
             Entry::Vacant(_) => return interp_ok(false), // we did not even own this lock
         }
-        if let Some(data_race) = this.machine.data_race.as_vclocks_ref() {
-            // Add this to the shared-release clock of all concurrent readers.
-            data_race.release_clock(&this.machine.threads, |clock| {
-                rwlock.clock_current_readers.join(clock)
-            });
-        }
+        // Add this to the shared-release clock of all concurrent readers.
+        this.release_clock(|clock| rwlock.clock_current_readers.join(clock))?;
 
         // The thread was a reader. If the lock is not held any more, give it to a writer.
         if rwlock.is_locked().not() {
@@ -521,7 +511,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 }
                 |this, unblock: UnblockKind| {
                     assert_eq!(unblock, UnblockKind::Ready);
-                    this.rwlock_reader_lock(&rwlock_ref);
+                    this.rwlock_reader_lock(&rwlock_ref)?;
                     this.write_scalar(retval, &dest)?;
                     interp_ok(())
                 }
@@ -531,7 +521,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
     /// Lock by setting the writer that owns the lock.
     #[inline]
-    fn rwlock_writer_lock(&mut self, rwlock_ref: &RwLockRef) {
+    fn rwlock_writer_lock(&mut self, rwlock_ref: &RwLockRef) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
         let thread = this.active_thread();
         trace!("rwlock_writer_lock: now held by {:?}", thread);
@@ -539,9 +529,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let mut rwlock = rwlock_ref.0.borrow_mut();
         assert!(!rwlock.is_locked(), "the rwlock is already locked");
         rwlock.writer = Some(thread);
-        if let Some(data_race) = this.machine.data_race.as_vclocks_ref() {
-            data_race.acquire_clock(&rwlock.clock_unlocked, &this.machine.threads);
-        }
+        this.acquire_clock(&rwlock.clock_unlocked)?;
+        interp_ok(())
     }
 
     /// Try to unlock an rwlock held by the current thread.
@@ -559,11 +548,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             rwlock.writer = None;
             trace!("rwlock_writer_unlock: unlocked by {:?}", thread);
             // Record release clock for next lock holder.
-            if let Some(data_race) = this.machine.data_race.as_vclocks_ref() {
-                data_race.release_clock(&this.machine.threads, |clock| {
-                    rwlock.clock_unlocked.clone_from(clock)
-                });
-            }
+            this.release_clock(|clock| rwlock.clock_unlocked.clone_from(clock))?;
 
             // The thread was a writer.
             //
@@ -613,7 +598,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 }
                 |this, unblock: UnblockKind| {
                     assert_eq!(unblock, UnblockKind::Ready);
-                    this.rwlock_writer_lock(&rwlock_ref);
+                    this.rwlock_writer_lock(&rwlock_ref)?;
                     this.write_scalar(retval, &dest)?;
                     interp_ok(())
                 }
@@ -663,12 +648,9 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     match unblock {
                         UnblockKind::Ready => {
                             // The condvar was signaled. Make sure we get the clock for that.
-                            if let Some(data_race) = this.machine.data_race.as_vclocks_ref() {
-                                data_race.acquire_clock(
+                            this.acquire_clock(
                                     &condvar_ref.0.borrow().clock,
-                                    &this.machine.threads,
-                                );
-                            }
+                                )?;
                             // Try to acquire the mutex.
                             // The timeout only applies to the first wait (until the signal), not for mutex acquisition.
                             this.condvar_reacquire_mutex(mutex_ref, retval_succ, dest)
@@ -695,9 +677,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let mut condvar = condvar_ref.0.borrow_mut();
 
         // Each condvar signal happens-before the end of the condvar wake
-        if let Some(data_race) = this.machine.data_race.as_vclocks_ref() {
-            data_race.release_clock(&this.machine.threads, |clock| condvar.clock.clone_from(clock));
-        }
+        this.release_clock(|clock| condvar.clock.clone_from(clock))?;
         let Some(waiter) = condvar.waiters.pop_front() else {
             return interp_ok(false);
         };
@@ -736,9 +716,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                         UnblockKind::Ready => {
                             let futex = futex_ref.0.borrow();
                             // Acquire the clock of the futex.
-                            if let Some(data_race) = this.machine.data_race.as_vclocks_ref() {
-                                data_race.acquire_clock(&futex.clock, &this.machine.threads);
-                            }
+                            this.acquire_clock(&futex.clock)?;
                         },
                         UnblockKind::TimedOut => {
                             // Remove the waiter from the futex.
@@ -766,9 +744,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let mut futex = futex_ref.0.borrow_mut();
 
         // Each futex-wake happens-before the end of the futex wait
-        if let Some(data_race) = this.machine.data_race.as_vclocks_ref() {
-            data_race.release_clock(&this.machine.threads, |clock| futex.clock.clone_from(clock));
-        }
+        this.release_clock(|clock| futex.clock.clone_from(clock))?;
 
         // Remove `count` of the threads in the queue that match any of the bits in the bitset.
         // We collect all of them before unblocking because the unblock callback may access the
diff --git a/src/tools/miri/src/shims/unix/linux_like/epoll.rs b/src/tools/miri/src/shims/unix/linux_like/epoll.rs
index aac880feda40e..3133c149293db 100644
--- a/src/tools/miri/src/shims/unix/linux_like/epoll.rs
+++ b/src/tools/miri/src/shims/unix/linux_like/epoll.rs
@@ -608,7 +608,7 @@ fn check_and_update_one_event_interest<'tcx>(
         // If we are tracking data races, remember the current clock so we can sync with it later.
         ecx.release_clock(|clock| {
             event_instance.clock.clone_from(clock);
-        });
+        })?;
         // Triggers the notification by inserting it to the ready list.
         ready_list.insert(epoll_key, event_instance);
         interp_ok(true)
diff --git a/src/tools/miri/src/shims/unix/linux_like/eventfd.rs b/src/tools/miri/src/shims/unix/linux_like/eventfd.rs
index 54cc571884dc8..5d4f207d365e1 100644
--- a/src/tools/miri/src/shims/unix/linux_like/eventfd.rs
+++ b/src/tools/miri/src/shims/unix/linux_like/eventfd.rs
@@ -199,7 +199,7 @@ fn eventfd_write<'tcx>(
             // Future `read` calls will synchronize with this write, so update the FD clock.
             ecx.release_clock(|clock| {
                 eventfd.clock.borrow_mut().join(clock);
-            });
+            })?;
 
             // Store new counter value.
             eventfd.counter.set(new_count);
diff --git a/src/tools/miri/src/shims/unix/macos/sync.rs b/src/tools/miri/src/shims/unix/macos/sync.rs
index 05616dd5a4287..c4ddff7805ed2 100644
--- a/src/tools/miri/src/shims/unix/macos/sync.rs
+++ b/src/tools/miri/src/shims/unix/macos/sync.rs
@@ -296,7 +296,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
             this.mutex_enqueue_and_block(mutex_ref, None);
         } else {
-            this.mutex_lock(&mutex_ref);
+            this.mutex_lock(&mutex_ref)?;
         }
 
         interp_ok(())
@@ -321,7 +321,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             // reentrancy.
             this.write_scalar(Scalar::from_bool(false), dest)?;
         } else {
-            this.mutex_lock(&mutex_ref);
+            this.mutex_lock(&mutex_ref)?;
             this.write_scalar(Scalar::from_bool(true), dest)?;
         }
 
diff --git a/src/tools/miri/src/shims/unix/sync.rs b/src/tools/miri/src/shims/unix/sync.rs
index 5ad4fd501a607..cefd8b81ac180 100644
--- a/src/tools/miri/src/shims/unix/sync.rs
+++ b/src/tools/miri/src/shims/unix/sync.rs
@@ -498,14 +498,14 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     MutexKind::Normal => throw_machine_stop!(TerminationInfo::Deadlock),
                     MutexKind::ErrorCheck => this.eval_libc_i32("EDEADLK"),
                     MutexKind::Recursive => {
-                        this.mutex_lock(&mutex.mutex_ref);
+                        this.mutex_lock(&mutex.mutex_ref)?;
                         0
                     }
                 }
             }
         } else {
             // The mutex is unlocked. Let's lock it.
-            this.mutex_lock(&mutex.mutex_ref);
+            this.mutex_lock(&mutex.mutex_ref)?;
             0
         };
         this.write_scalar(Scalar::from_i32(ret), dest)?;
@@ -525,14 +525,14 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     MutexKind::Default | MutexKind::Normal | MutexKind::ErrorCheck =>
                         this.eval_libc_i32("EBUSY"),
                     MutexKind::Recursive => {
-                        this.mutex_lock(&mutex.mutex_ref);
+                        this.mutex_lock(&mutex.mutex_ref)?;
                         0
                     }
                 }
             }
         } else {
             // The mutex is unlocked. Let's lock it.
-            this.mutex_lock(&mutex.mutex_ref);
+            this.mutex_lock(&mutex.mutex_ref)?;
             0
         }))
     }
@@ -600,7 +600,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 dest.clone(),
             );
         } else {
-            this.rwlock_reader_lock(&rwlock.rwlock_ref);
+            this.rwlock_reader_lock(&rwlock.rwlock_ref)?;
             this.write_null(dest)?;
         }
 
@@ -615,7 +615,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         if rwlock.rwlock_ref.is_write_locked() {
             interp_ok(Scalar::from_i32(this.eval_libc_i32("EBUSY")))
         } else {
-            this.rwlock_reader_lock(&rwlock.rwlock_ref);
+            this.rwlock_reader_lock(&rwlock.rwlock_ref)?;
             interp_ok(Scalar::from_i32(0))
         }
     }
@@ -648,7 +648,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 dest.clone(),
             );
         } else {
-            this.rwlock_writer_lock(&rwlock.rwlock_ref);
+            this.rwlock_writer_lock(&rwlock.rwlock_ref)?;
             this.write_null(dest)?;
         }
 
@@ -663,7 +663,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         if rwlock.rwlock_ref.is_locked() {
             interp_ok(Scalar::from_i32(this.eval_libc_i32("EBUSY")))
         } else {
-            this.rwlock_writer_lock(&rwlock.rwlock_ref);
+            this.rwlock_writer_lock(&rwlock.rwlock_ref)?;
             interp_ok(Scalar::from_i32(0))
         }
     }
diff --git a/src/tools/miri/src/shims/unix/unnamed_socket.rs b/src/tools/miri/src/shims/unix/unnamed_socket.rs
index 0585f3ba7471d..81703d6e176bf 100644
--- a/src/tools/miri/src/shims/unix/unnamed_socket.rs
+++ b/src/tools/miri/src/shims/unix/unnamed_socket.rs
@@ -259,7 +259,7 @@ fn anonsocket_write<'tcx>(
         // Remember this clock so `read` can synchronize with us.
         ecx.release_clock(|clock| {
             writebuf.clock.join(clock);
-        });
+        })?;
         // Do full write / partial write based on the space available.
         let write_size = len.min(available_space);
         let actual_write_size = ecx.write_to_host(&mut writebuf.buf, write_size, ptr)?.unwrap();

From a5575f8f051c2379bae4a83a3ee1bd91a269343a Mon Sep 17 00:00:00 2001
From: Ali Nazzal <ali90h7@pm.me>
Date: Mon, 8 Sep 2025 11:19:28 +0300
Subject: [PATCH 0641/1889] Fix broken Microsoft URL missing slash

---
 src/doc/rustc-dev-guide/src/building/how-to-build-and-run.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/src/building/how-to-build-and-run.md b/src/doc/rustc-dev-guide/src/building/how-to-build-and-run.md
index b07d3533f59bc..36610f28854b5 100644
--- a/src/doc/rustc-dev-guide/src/building/how-to-build-and-run.md
+++ b/src/doc/rustc-dev-guide/src/building/how-to-build-and-run.md
@@ -149,7 +149,7 @@ On Windows, the Powershell commands may give you an error that looks like this:
 ```
 PS C:\Users\vboxuser\rust> ./x
 ./x : File C:\Users\vboxuser\rust\x.ps1 cannot be loaded because running scripts is disabled on this system. For more
-information, see about_Execution_Policies at https:/go.microsoft.com/fwlink/?LinkID=135170.
+information, see about_Execution_Policies at https://go.microsoft.com/fwlink/?LinkID=135170.
 At line:1 char:1
 + ./x
 + ~~~

From c776fbf1eb44a90aa613042c60ba48859f4949e4 Mon Sep 17 00:00:00 2001
From: Fang He <hf.enigma@gmail.com>
Date: Mon, 8 Sep 2025 16:35:03 +0800
Subject: [PATCH 0642/1889] check before test for hardware capabilites in bits
 32~63 of usize

---
 .../std_detect/src/detect/os/linux/aarch64.rs | 71 ++++++++++---------
 1 file changed, 38 insertions(+), 33 deletions(-)

diff --git a/library/std_detect/src/detect/os/linux/aarch64.rs b/library/std_detect/src/detect/os/linux/aarch64.rs
index 87a9d6ebb8875..ba5e8f0025683 100644
--- a/library/std_detect/src/detect/os/linux/aarch64.rs
+++ b/library/std_detect/src/detect/os/linux/aarch64.rs
@@ -140,7 +140,7 @@ struct AtHwcap {
 impl From<auxvec::AuxVec> for AtHwcap {
     /// Reads AtHwcap from the auxiliary vector.
     fn from(auxv: auxvec::AuxVec) -> Self {
-        AtHwcap {
+        let mut cap = AtHwcap {
             fp: bit::test(auxv.hwcap, 0),
             asimd: bit::test(auxv.hwcap, 1),
             // evtstrm: bit::test(auxv.hwcap, 2),
@@ -207,39 +207,44 @@ impl From<auxvec::AuxVec> for AtHwcap {
             // smef32f32: bit::test(auxv.hwcap2, 29),
             smefa64: bit::test(auxv.hwcap2, 30),
             wfxt: bit::test(auxv.hwcap2, 31),
-            // ebf16: bit::test(auxv.hwcap2, 32),
-            // sveebf16: bit::test(auxv.hwcap2, 33),
-            cssc: bit::test(auxv.hwcap2, 34),
-            // rprfm: bit::test(auxv.hwcap2, 35),
-            sve2p1: bit::test(auxv.hwcap2, 36),
-            sme2: bit::test(auxv.hwcap2, 37),
-            sme2p1: bit::test(auxv.hwcap2, 38),
-            // smei16i32: bit::test(auxv.hwcap2, 39),
-            // smebi32i32: bit::test(auxv.hwcap2, 40),
-            smeb16b16: bit::test(auxv.hwcap2, 41),
-            smef16f16: bit::test(auxv.hwcap2, 42),
-            mops: bit::test(auxv.hwcap2, 43),
-            hbc: bit::test(auxv.hwcap2, 44),
-            sveb16b16: bit::test(auxv.hwcap2, 45),
-            lrcpc3: bit::test(auxv.hwcap2, 46),
-            lse128: bit::test(auxv.hwcap2, 47),
-            fpmr: bit::test(auxv.hwcap2, 48),
-            lut: bit::test(auxv.hwcap2, 49),
-            faminmax: bit::test(auxv.hwcap2, 50),
-            f8cvt: bit::test(auxv.hwcap2, 51),
-            f8fma: bit::test(auxv.hwcap2, 52),
-            f8dp4: bit::test(auxv.hwcap2, 53),
-            f8dp2: bit::test(auxv.hwcap2, 54),
-            f8e4m3: bit::test(auxv.hwcap2, 55),
-            f8e5m2: bit::test(auxv.hwcap2, 56),
-            smelutv2: bit::test(auxv.hwcap2, 57),
-            smef8f16: bit::test(auxv.hwcap2, 58),
-            smef8f32: bit::test(auxv.hwcap2, 59),
-            smesf8fma: bit::test(auxv.hwcap2, 60),
-            smesf8dp4: bit::test(auxv.hwcap2, 61),
-            smesf8dp2: bit::test(auxv.hwcap2, 62),
-            // pauthlr: bit::test(auxv.hwcap2, ??),
+            ..Default::default()
+        };
+        #[cfg(target_pointer_width = "64")]
+        {
+            // cap.ebf16: bit::test(auxv.hwcap2, 32);
+            // cap.sveebf16: bit::test(auxv.hwcap2, 33);
+            cap.cssc = bit::test(auxv.hwcap2, 34);
+            // cap.rprfm: bit::test(auxv.hwcap2, 35);
+            cap.sve2p1 = bit::test(auxv.hwcap2, 36);
+            cap.sme2 = bit::test(auxv.hwcap2, 37);
+            cap.sme2p1 = bit::test(auxv.hwcap2, 38);
+            // cap.smei16i32 = bit::test(auxv.hwcap2, 39);
+            // cap.smebi32i32 = bit::test(auxv.hwcap2, 40);
+            cap.smeb16b16 = bit::test(auxv.hwcap2, 41);
+            cap.smef16f16 = bit::test(auxv.hwcap2, 42);
+            cap.mops = bit::test(auxv.hwcap2, 43);
+            cap.hbc = bit::test(auxv.hwcap2, 44);
+            cap.sveb16b16 = bit::test(auxv.hwcap2, 45);
+            cap.lrcpc3 = bit::test(auxv.hwcap2, 46);
+            cap.lse128 = bit::test(auxv.hwcap2, 47);
+            cap.fpmr = bit::test(auxv.hwcap2, 48);
+            cap.lut = bit::test(auxv.hwcap2, 49);
+            cap.faminmax = bit::test(auxv.hwcap2, 50);
+            cap.f8cvt = bit::test(auxv.hwcap2, 51);
+            cap.f8fma = bit::test(auxv.hwcap2, 52);
+            cap.f8dp4 = bit::test(auxv.hwcap2, 53);
+            cap.f8dp2 = bit::test(auxv.hwcap2, 54);
+            cap.f8e4m3 = bit::test(auxv.hwcap2, 55);
+            cap.f8e5m2 = bit::test(auxv.hwcap2, 56);
+            cap.smelutv2 = bit::test(auxv.hwcap2, 57);
+            cap.smef8f16 = bit::test(auxv.hwcap2, 58);
+            cap.smef8f32 = bit::test(auxv.hwcap2, 59);
+            cap.smesf8fma = bit::test(auxv.hwcap2, 60);
+            cap.smesf8dp4 = bit::test(auxv.hwcap2, 61);
+            cap.smesf8dp2 = bit::test(auxv.hwcap2, 62);
+            // cap.pauthlr = bit::test(auxv.hwcap2, ??);
         }
+        cap
     }
 }
 

From 9a52a8354e50bd824bdefebc659d8c3c38eccc0a Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Mon, 8 Sep 2025 05:27:52 +1000
Subject: [PATCH 0643/1889] Allow static regions in `type_name`.

Fixes #146249.
---
 compiler/rustc_const_eval/src/util/type_name.rs |  5 +++--
 tests/ui/type/type-name-basic.rs                | 15 +++++++++++++++
 2 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_const_eval/src/util/type_name.rs b/compiler/rustc_const_eval/src/util/type_name.rs
index 2ae6655901b67..5bcf96abd8cb5 100644
--- a/compiler/rustc_const_eval/src/util/type_name.rs
+++ b/compiler/rustc_const_eval/src/util/type_name.rs
@@ -168,10 +168,11 @@ impl<'tcx> PrettyPrinter<'tcx> for TypeNamePrinter<'tcx> {
         // Bound regions are always printed (as `'_`), which gives some idea that they are special,
         // even though the `for` is omitted by the pretty printer.
         // E.g. `for<'a, 'b> fn(&'a u32, &'b u32)` is printed as "fn(&'_ u32, &'_ u32)".
+        let kind = region.kind();
         match region.kind() {
-            ty::ReErased | ty::ReEarlyParam(_) => false,
+            ty::ReErased | ty::ReEarlyParam(_) | ty::ReStatic => false,
             ty::ReBound(..) => true,
-            _ => unreachable!(),
+            _ => panic!("type_name unhandled region: {kind:?}"),
         }
     }
 
diff --git a/tests/ui/type/type-name-basic.rs b/tests/ui/type/type-name-basic.rs
index 343bcae175a04..2c41cb80aea8f 100644
--- a/tests/ui/type/type-name-basic.rs
+++ b/tests/ui/type/type-name-basic.rs
@@ -107,4 +107,19 @@ pub fn main() {
     }
     let a = Wrap(&()).get();
     v!(a, "type_name_basic::main::Wrap<&()>::get::Info");
+
+    struct Issue146249<T>(T);
+    impl Issue146249<Box<dyn FnOnce()>> {
+        pub fn bar(&self) {
+            let f = || {};
+            v!(
+                f,
+                "type_name_basic::main::Issue146249<\
+                    alloc::boxed::Box<dyn core::ops::function::FnOnce()>\
+                >::bar::{{closure}}"
+            );
+        }
+    }
+    let v: Issue146249<Box<dyn FnOnce()>> = Issue146249(Box::new(|| {}));
+    v.bar();
 }

From deca4895ca0412ea1a646310c0026d66b1230b9a Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 8 Sep 2025 11:57:19 +0200
Subject: [PATCH 0644/1889] Prepare for merging from rust-lang/rust

This updates the rust-version file to a09fbe2c8372643a27a8082236120f95ed4e6bba.
---
 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 a51d86c3d6f15..5b3139b25092b 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-b3cfb8faf84c5f3b7909479a9f9b6a3290d5f4d7
+a09fbe2c8372643a27a8082236120f95ed4e6bba

From 24ce839fb953d1172a19479edcb2f75877cf153e Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 8 Sep 2025 12:00:36 +0200
Subject: [PATCH 0645/1889] clippy

---
 src/tools/miri/src/math.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/miri/src/math.rs b/src/tools/miri/src/math.rs
index 7d2f1c083687c..254495637da42 100644
--- a/src/tools/miri/src/math.rs
+++ b/src/tools/miri/src/math.rs
@@ -308,7 +308,7 @@ where
             Some(if return_nan { ecx.generate_nan(&[base]) } else { one })
         }
 
-        _ => return None,
+        _ => None,
     }
 }
 

From be284b697fef4c560e040a433fbe2b832ed8426d Mon Sep 17 00:00:00 2001
From: Fang He <hf.enigma@gmail.com>
Date: Mon, 8 Sep 2025 18:39:39 +0800
Subject: [PATCH 0646/1889] add some comments to clarify the fix

---
 library/std_detect/src/detect/os/linux/aarch64.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/library/std_detect/src/detect/os/linux/aarch64.rs b/library/std_detect/src/detect/os/linux/aarch64.rs
index ba5e8f0025683..2c36a073b74e8 100644
--- a/library/std_detect/src/detect/os/linux/aarch64.rs
+++ b/library/std_detect/src/detect/os/linux/aarch64.rs
@@ -209,6 +209,12 @@ impl From<auxvec::AuxVec> for AtHwcap {
             wfxt: bit::test(auxv.hwcap2, 31),
             ..Default::default()
         };
+
+        // Hardware capabilites from bits 32 to 63 should only
+        // be tested on LP64 targets with 64 bits `usize`.
+        // On ILP32 targets like `aarch64-unknown-linux-gun_ilp32`,
+        // these hardware capabilites will default to `false`.
+        // https://github.com/rust-lang/rust/issues/146230
         #[cfg(target_pointer_width = "64")]
         {
             // cap.ebf16: bit::test(auxv.hwcap2, 32);

From de359c569b7c3eb630fb44e9078c4bea012eac99 Mon Sep 17 00:00:00 2001
From: Fang He <hf.enigma@gmail.com>
Date: Mon, 8 Sep 2025 18:48:19 +0800
Subject: [PATCH 0647/1889] fix typos in comment

---
 library/std_detect/src/detect/os/linux/aarch64.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/library/std_detect/src/detect/os/linux/aarch64.rs b/library/std_detect/src/detect/os/linux/aarch64.rs
index 2c36a073b74e8..c53dbf3fd9ba6 100644
--- a/library/std_detect/src/detect/os/linux/aarch64.rs
+++ b/library/std_detect/src/detect/os/linux/aarch64.rs
@@ -210,10 +210,10 @@ impl From<auxvec::AuxVec> for AtHwcap {
             ..Default::default()
         };
 
-        // Hardware capabilites from bits 32 to 63 should only
+        // Hardware capabilities from bits 32 to 63 should only
         // be tested on LP64 targets with 64 bits `usize`.
         // On ILP32 targets like `aarch64-unknown-linux-gun_ilp32`,
-        // these hardware capabilites will default to `false`.
+        // these hardware capabilities will default to `false`.
         // https://github.com/rust-lang/rust/issues/146230
         #[cfg(target_pointer_width = "64")]
         {

From 94ab2b9f15b3c5ffe139d17fdae98cc2adff883d Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 19 Jul 2025 11:57:49 +0200
Subject: [PATCH 0648/1889] move math intrinsics to their own file

---
 src/tools/miri/src/intrinsics/math.rs | 311 ++++++++++++++++++++++++++
 src/tools/miri/src/intrinsics/mod.rs  | 291 +-----------------------
 2 files changed, 315 insertions(+), 287 deletions(-)
 create mode 100644 src/tools/miri/src/intrinsics/math.rs

diff --git a/src/tools/miri/src/intrinsics/math.rs b/src/tools/miri/src/intrinsics/math.rs
new file mode 100644
index 0000000000000..21d4a92e7d288
--- /dev/null
+++ b/src/tools/miri/src/intrinsics/math.rs
@@ -0,0 +1,311 @@
+use rand::Rng;
+use rustc_apfloat::{self, Float, Round};
+use rustc_middle::mir;
+use rustc_middle::ty::{self, FloatTy};
+
+use self::helpers::{ToHost, ToSoft};
+use super::check_intrinsic_arg_count;
+use crate::*;
+
+impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
+pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
+    fn emulate_math_intrinsic(
+        &mut self,
+        intrinsic_name: &str,
+        _generic_args: ty::GenericArgsRef<'tcx>,
+        args: &[OpTy<'tcx>],
+        dest: &MPlaceTy<'tcx>,
+    ) -> InterpResult<'tcx, EmulateItemResult> {
+        let this = self.eval_context_mut();
+
+        match intrinsic_name {
+            // Operations we can do with soft-floats.
+            "sqrtf32" => {
+                let [f] = check_intrinsic_arg_count(args)?;
+                let f = this.read_scalar(f)?.to_f32()?;
+                // Sqrt is specified to be fully precise.
+                let res = math::sqrt(f);
+                let res = this.adjust_nan(res, &[f]);
+                this.write_scalar(res, dest)?;
+            }
+            "sqrtf64" => {
+                let [f] = check_intrinsic_arg_count(args)?;
+                let f = this.read_scalar(f)?.to_f64()?;
+                // Sqrt is specified to be fully precise.
+                let res = math::sqrt(f);
+                let res = this.adjust_nan(res, &[f]);
+                this.write_scalar(res, dest)?;
+            }
+
+            "fmaf32" => {
+                let [a, b, c] = check_intrinsic_arg_count(args)?;
+                let a = this.read_scalar(a)?.to_f32()?;
+                let b = this.read_scalar(b)?.to_f32()?;
+                let c = this.read_scalar(c)?.to_f32()?;
+                let res = a.mul_add(b, c).value;
+                let res = this.adjust_nan(res, &[a, b, c]);
+                this.write_scalar(res, dest)?;
+            }
+            "fmaf64" => {
+                let [a, b, c] = check_intrinsic_arg_count(args)?;
+                let a = this.read_scalar(a)?.to_f64()?;
+                let b = this.read_scalar(b)?.to_f64()?;
+                let c = this.read_scalar(c)?.to_f64()?;
+                let res = a.mul_add(b, c).value;
+                let res = this.adjust_nan(res, &[a, b, c]);
+                this.write_scalar(res, dest)?;
+            }
+
+            "fmuladdf32" => {
+                let [a, b, c] = check_intrinsic_arg_count(args)?;
+                let a = this.read_scalar(a)?.to_f32()?;
+                let b = this.read_scalar(b)?.to_f32()?;
+                let c = this.read_scalar(c)?.to_f32()?;
+                let fuse: bool = this.machine.float_nondet && this.machine.rng.get_mut().random();
+                let res = if fuse { a.mul_add(b, c).value } else { ((a * b).value + c).value };
+                let res = this.adjust_nan(res, &[a, b, c]);
+                this.write_scalar(res, dest)?;
+            }
+            "fmuladdf64" => {
+                let [a, b, c] = check_intrinsic_arg_count(args)?;
+                let a = this.read_scalar(a)?.to_f64()?;
+                let b = this.read_scalar(b)?.to_f64()?;
+                let c = this.read_scalar(c)?.to_f64()?;
+                let fuse: bool = this.machine.float_nondet && this.machine.rng.get_mut().random();
+                let res = if fuse { a.mul_add(b, c).value } else { ((a * b).value + c).value };
+                let res = this.adjust_nan(res, &[a, b, c]);
+                this.write_scalar(res, dest)?;
+            }
+
+            #[rustfmt::skip]
+            | "fadd_fast"
+            | "fsub_fast"
+            | "fmul_fast"
+            | "fdiv_fast"
+            | "frem_fast"
+            => {
+                let [a, b] = check_intrinsic_arg_count(args)?;
+                let a = this.read_immediate(a)?;
+                let b = this.read_immediate(b)?;
+                let op = match intrinsic_name {
+                    "fadd_fast" => mir::BinOp::Add,
+                    "fsub_fast" => mir::BinOp::Sub,
+                    "fmul_fast" => mir::BinOp::Mul,
+                    "fdiv_fast" => mir::BinOp::Div,
+                    "frem_fast" => mir::BinOp::Rem,
+                    _ => bug!(),
+                };
+                let float_finite = |x: &ImmTy<'tcx>| -> InterpResult<'tcx, bool> {
+                    let ty::Float(fty) = x.layout.ty.kind() else {
+                        bug!("float_finite: non-float input type {}", x.layout.ty)
+                    };
+                    interp_ok(match fty {
+                        FloatTy::F16 => x.to_scalar().to_f16()?.is_finite(),
+                        FloatTy::F32 => x.to_scalar().to_f32()?.is_finite(),
+                        FloatTy::F64 => x.to_scalar().to_f64()?.is_finite(),
+                        FloatTy::F128 => x.to_scalar().to_f128()?.is_finite(),
+                    })
+                };
+                match (float_finite(&a)?, float_finite(&b)?) {
+                    (false, false) => throw_ub_format!(
+                        "`{intrinsic_name}` intrinsic called with non-finite value as both parameters",
+                    ),
+                    (false, _) => throw_ub_format!(
+                        "`{intrinsic_name}` intrinsic called with non-finite value as first parameter",
+                    ),
+                    (_, false) => throw_ub_format!(
+                        "`{intrinsic_name}` intrinsic called with non-finite value as second parameter",
+                    ),
+                    _ => {}
+                }
+                let res = this.binary_op(op, &a, &b)?;
+                // This cannot be a NaN so we also don't have to apply any non-determinism.
+                // (Also, `binary_op` already called `generate_nan` if needed.)
+                if !float_finite(&res)? {
+                    throw_ub_format!("`{intrinsic_name}` intrinsic produced non-finite value as result");
+                }
+                // Apply a relative error of 4ULP to simulate non-deterministic precision loss
+                // due to optimizations.
+                let res = math::apply_random_float_error_to_imm(this, res, 4)?;
+                this.write_immediate(*res, dest)?;
+            }
+
+            "float_to_int_unchecked" => {
+                let [val] = check_intrinsic_arg_count(args)?;
+                let val = this.read_immediate(val)?;
+
+                let res = this
+                    .float_to_int_checked(&val, dest.layout, Round::TowardZero)?
+                    .ok_or_else(|| {
+                        err_ub_format!(
+                            "`float_to_int_unchecked` intrinsic called on {val} which cannot be represented in target type `{:?}`",
+                            dest.layout.ty
+                        )
+                    })?;
+
+                this.write_immediate(*res, dest)?;
+            }
+
+            // Operations that need host floats.
+            #[rustfmt::skip]
+            | "sinf32"
+            | "cosf32"
+            | "expf32"
+            | "exp2f32"
+            | "logf32"
+            | "log10f32"
+            | "log2f32"
+            => {
+                let [f] = check_intrinsic_arg_count(args)?;
+                let f = this.read_scalar(f)?.to_f32()?;
+
+                let res = math::fixed_float_value(this, intrinsic_name, &[f]).unwrap_or_else(|| {
+                    // Using host floats (but it's fine, these operations do not have
+                    // guaranteed precision).
+                    let host = f.to_host();
+                    let res = match intrinsic_name {
+                        "sinf32" => host.sin(),
+                        "cosf32" => host.cos(),
+                        "expf32" => host.exp(),
+                        "exp2f32" => host.exp2(),
+                        "logf32" => host.ln(),
+                        "log10f32" => host.log10(),
+                        "log2f32" => host.log2(),
+                        _ => bug!(),
+                    };
+                    let res = res.to_soft();
+
+                    // Apply a relative error of 4ULP to introduce some non-determinism
+                    // simulating imprecise implementations and optimizations.
+                    let res = math::apply_random_float_error_ulp(
+                        this,
+                        res,
+                        4,
+                    );
+
+                    // Clamp the result to the guaranteed range of this function according to the C standard,
+                    // if any.
+                    math::clamp_float_value(intrinsic_name, res)
+                });
+                let res = this.adjust_nan(res, &[f]);
+                this.write_scalar(res, dest)?;
+            }
+
+            #[rustfmt::skip]
+            | "sinf64"
+            | "cosf64"
+            | "expf64"
+            | "exp2f64"
+            | "logf64"
+            | "log10f64"
+            | "log2f64"
+            => {
+                let [f] = check_intrinsic_arg_count(args)?;
+                let f = this.read_scalar(f)?.to_f64()?;
+
+                let res = math::fixed_float_value(this, intrinsic_name, &[f]).unwrap_or_else(|| {
+                    // Using host floats (but it's fine, these operations do not have
+                    // guaranteed precision).
+                    let host = f.to_host();
+                    let res = match intrinsic_name {
+                        "sinf64" => host.sin(),
+                        "cosf64" => host.cos(),
+                        "expf64" => host.exp(),
+                        "exp2f64" => host.exp2(),
+                        "logf64" => host.ln(),
+                        "log10f64" => host.log10(),
+                        "log2f64" => host.log2(),
+                        _ => bug!(),
+                    };
+                    let res = res.to_soft();
+
+                    // Apply a relative error of 4ULP to introduce some non-determinism
+                    // simulating imprecise implementations and optimizations.
+                    let res = math::apply_random_float_error_ulp(
+                        this,
+                        res,
+                        4,
+                    );
+
+                    // Clamp the result to the guaranteed range of this function according to the C standard,
+                    // if any.
+                    math::clamp_float_value(intrinsic_name, res)
+                });
+                let res = this.adjust_nan(res, &[f]);
+                this.write_scalar(res, dest)?;
+            }
+
+            "powf32" => {
+                let [f1, f2] = check_intrinsic_arg_count(args)?;
+                let f1 = this.read_scalar(f1)?.to_f32()?;
+                let f2 = this.read_scalar(f2)?.to_f32()?;
+
+                let res =
+                    math::fixed_float_value(this, intrinsic_name, &[f1, f2]).unwrap_or_else(|| {
+                        // Using host floats (but it's fine, this operation does not have guaranteed precision).
+                        let res = f1.to_host().powf(f2.to_host()).to_soft();
+
+                        // Apply a relative error of 4ULP to introduce some non-determinism
+                        // simulating imprecise implementations and optimizations.
+                        math::apply_random_float_error_ulp(this, res, 4)
+                    });
+                let res = this.adjust_nan(res, &[f1, f2]);
+                this.write_scalar(res, dest)?;
+            }
+            "powf64" => {
+                let [f1, f2] = check_intrinsic_arg_count(args)?;
+                let f1 = this.read_scalar(f1)?.to_f64()?;
+                let f2 = this.read_scalar(f2)?.to_f64()?;
+
+                let res =
+                    math::fixed_float_value(this, intrinsic_name, &[f1, f2]).unwrap_or_else(|| {
+                        // Using host floats (but it's fine, this operation does not have guaranteed precision).
+                        let res = f1.to_host().powf(f2.to_host()).to_soft();
+
+                        // Apply a relative error of 4ULP to introduce some non-determinism
+                        // simulating imprecise implementations and optimizations.
+                        math::apply_random_float_error_ulp(this, res, 4)
+                    });
+                let res = this.adjust_nan(res, &[f1, f2]);
+                this.write_scalar(res, dest)?;
+            }
+
+            "powif32" => {
+                let [f, i] = check_intrinsic_arg_count(args)?;
+                let f = this.read_scalar(f)?.to_f32()?;
+                let i = this.read_scalar(i)?.to_i32()?;
+
+                let res = math::fixed_powi_value(this, f, i).unwrap_or_else(|| {
+                    // Using host floats (but it's fine, this operation does not have guaranteed precision).
+                    let res = f.to_host().powi(i).to_soft();
+
+                    // Apply a relative error of 4ULP to introduce some non-determinism
+                    // simulating imprecise implementations and optimizations.
+                    math::apply_random_float_error_ulp(this, res, 4)
+                });
+                let res = this.adjust_nan(res, &[f]);
+                this.write_scalar(res, dest)?;
+            }
+            "powif64" => {
+                let [f, i] = check_intrinsic_arg_count(args)?;
+                let f = this.read_scalar(f)?.to_f64()?;
+                let i = this.read_scalar(i)?.to_i32()?;
+
+                let res = math::fixed_powi_value(this, f, i).unwrap_or_else(|| {
+                    // Using host floats (but it's fine, this operation does not have guaranteed precision).
+                    let res = f.to_host().powi(i).to_soft();
+
+                    // Apply a relative error of 4ULP to introduce some non-determinism
+                    // simulating imprecise implementations and optimizations.
+                    math::apply_random_float_error_ulp(this, res, 4)
+                });
+                let res = this.adjust_nan(res, &[f]);
+                this.write_scalar(res, dest)?;
+            }
+
+            _ => return interp_ok(EmulateItemResult::NotSupported),
+        }
+
+        interp_ok(EmulateItemResult::NeedsReturn)
+    }
+}
diff --git a/src/tools/miri/src/intrinsics/mod.rs b/src/tools/miri/src/intrinsics/mod.rs
index 8d323ec169df3..a80b939d84ea9 100644
--- a/src/tools/miri/src/intrinsics/mod.rs
+++ b/src/tools/miri/src/intrinsics/mod.rs
@@ -1,6 +1,7 @@
 #![warn(clippy::arithmetic_side_effects)]
 
 mod atomic;
+mod math;
 mod simd;
 
 pub use self::atomic::AtomicRmwOp;
@@ -8,13 +9,11 @@ pub use self::atomic::AtomicRmwOp;
 #[rustfmt::skip] // prevent `use` reordering
 use rand::Rng;
 use rustc_abi::Size;
-use rustc_apfloat::{self, Float, Round};
-use rustc_middle::mir;
-use rustc_middle::ty::{self, FloatTy};
+use rustc_middle::{mir, ty};
 use rustc_span::{Symbol, sym};
 
 use self::atomic::EvalContextExt as _;
-use self::helpers::{ToHost, ToSoft};
+use self::math::EvalContextExt as _;
 use self::simd::EvalContextExt as _;
 use crate::*;
 
@@ -179,288 +178,6 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 this.write_scalar(Scalar::from_bool(branch), dest)?;
             }
 
-            "sqrtf32" => {
-                let [f] = check_intrinsic_arg_count(args)?;
-                let f = this.read_scalar(f)?.to_f32()?;
-                // Sqrt is specified to be fully precise.
-                let res = math::sqrt(f);
-                let res = this.adjust_nan(res, &[f]);
-                this.write_scalar(res, dest)?;
-            }
-            "sqrtf64" => {
-                let [f] = check_intrinsic_arg_count(args)?;
-                let f = this.read_scalar(f)?.to_f64()?;
-                // Sqrt is specified to be fully precise.
-                let res = math::sqrt(f);
-                let res = this.adjust_nan(res, &[f]);
-                this.write_scalar(res, dest)?;
-            }
-
-            #[rustfmt::skip]
-            | "sinf32"
-            | "cosf32"
-            | "expf32"
-            | "exp2f32"
-            | "logf32"
-            | "log10f32"
-            | "log2f32"
-            => {
-                let [f] = check_intrinsic_arg_count(args)?;
-                let f = this.read_scalar(f)?.to_f32()?;
-
-                let res = math::fixed_float_value(this, intrinsic_name, &[f]).unwrap_or_else(|| {
-                    // Using host floats (but it's fine, these operations do not have
-                    // guaranteed precision).
-                    let host = f.to_host();
-                    let res = match intrinsic_name {
-                        "sinf32" => host.sin(),
-                        "cosf32" => host.cos(),
-                        "expf32" => host.exp(),
-                        "exp2f32" => host.exp2(),
-                        "logf32" => host.ln(),
-                        "log10f32" => host.log10(),
-                        "log2f32" => host.log2(),
-                        _ => bug!(),
-                    };
-                    let res = res.to_soft();
-
-                    // Apply a relative error of 4ULP to introduce some non-determinism
-                    // simulating imprecise implementations and optimizations.
-                    let res = math::apply_random_float_error_ulp(
-                        this,
-                        res,
-                        4,
-                    );
-
-                    // Clamp the result to the guaranteed range of this function according to the C standard,
-                    // if any.
-                    math::clamp_float_value(intrinsic_name, res)
-                });
-                let res = this.adjust_nan(res, &[f]);
-                this.write_scalar(res, dest)?;
-            }
-
-            #[rustfmt::skip]
-            | "sinf64"
-            | "cosf64"
-            | "expf64"
-            | "exp2f64"
-            | "logf64"
-            | "log10f64"
-            | "log2f64"
-            => {
-                let [f] = check_intrinsic_arg_count(args)?;
-                let f = this.read_scalar(f)?.to_f64()?;
-
-                let res = math::fixed_float_value(this, intrinsic_name, &[f]).unwrap_or_else(|| {
-                    // Using host floats (but it's fine, these operations do not have
-                    // guaranteed precision).
-                    let host = f.to_host();
-                    let res = match intrinsic_name {
-                        "sinf64" => host.sin(),
-                        "cosf64" => host.cos(),
-                        "expf64" => host.exp(),
-                        "exp2f64" => host.exp2(),
-                        "logf64" => host.ln(),
-                        "log10f64" => host.log10(),
-                        "log2f64" => host.log2(),
-                        _ => bug!(),
-                    };
-                    let res = res.to_soft();
-
-                    // Apply a relative error of 4ULP to introduce some non-determinism
-                    // simulating imprecise implementations and optimizations.
-                    let res = math::apply_random_float_error_ulp(
-                        this,
-                        res,
-                        4,
-                    );
-
-                    // Clamp the result to the guaranteed range of this function according to the C standard,
-                    // if any.
-                    math::clamp_float_value(intrinsic_name, res)
-                });
-                let res = this.adjust_nan(res, &[f]);
-                this.write_scalar(res, dest)?;
-            }
-
-            "fmaf32" => {
-                let [a, b, c] = check_intrinsic_arg_count(args)?;
-                let a = this.read_scalar(a)?.to_f32()?;
-                let b = this.read_scalar(b)?.to_f32()?;
-                let c = this.read_scalar(c)?.to_f32()?;
-                let res = a.mul_add(b, c).value;
-                let res = this.adjust_nan(res, &[a, b, c]);
-                this.write_scalar(res, dest)?;
-            }
-            "fmaf64" => {
-                let [a, b, c] = check_intrinsic_arg_count(args)?;
-                let a = this.read_scalar(a)?.to_f64()?;
-                let b = this.read_scalar(b)?.to_f64()?;
-                let c = this.read_scalar(c)?.to_f64()?;
-                let res = a.mul_add(b, c).value;
-                let res = this.adjust_nan(res, &[a, b, c]);
-                this.write_scalar(res, dest)?;
-            }
-
-            "fmuladdf32" => {
-                let [a, b, c] = check_intrinsic_arg_count(args)?;
-                let a = this.read_scalar(a)?.to_f32()?;
-                let b = this.read_scalar(b)?.to_f32()?;
-                let c = this.read_scalar(c)?.to_f32()?;
-                let fuse: bool = this.machine.float_nondet && this.machine.rng.get_mut().random();
-                let res = if fuse { a.mul_add(b, c).value } else { ((a * b).value + c).value };
-                let res = this.adjust_nan(res, &[a, b, c]);
-                this.write_scalar(res, dest)?;
-            }
-            "fmuladdf64" => {
-                let [a, b, c] = check_intrinsic_arg_count(args)?;
-                let a = this.read_scalar(a)?.to_f64()?;
-                let b = this.read_scalar(b)?.to_f64()?;
-                let c = this.read_scalar(c)?.to_f64()?;
-                let fuse: bool = this.machine.float_nondet && this.machine.rng.get_mut().random();
-                let res = if fuse { a.mul_add(b, c).value } else { ((a * b).value + c).value };
-                let res = this.adjust_nan(res, &[a, b, c]);
-                this.write_scalar(res, dest)?;
-            }
-
-            "powf32" => {
-                let [f1, f2] = check_intrinsic_arg_count(args)?;
-                let f1 = this.read_scalar(f1)?.to_f32()?;
-                let f2 = this.read_scalar(f2)?.to_f32()?;
-
-                let res =
-                    math::fixed_float_value(this, intrinsic_name, &[f1, f2]).unwrap_or_else(|| {
-                        // Using host floats (but it's fine, this operation does not have guaranteed precision).
-                        let res = f1.to_host().powf(f2.to_host()).to_soft();
-
-                        // Apply a relative error of 4ULP to introduce some non-determinism
-                        // simulating imprecise implementations and optimizations.
-                        math::apply_random_float_error_ulp(this, res, 4)
-                    });
-                let res = this.adjust_nan(res, &[f1, f2]);
-                this.write_scalar(res, dest)?;
-            }
-            "powf64" => {
-                let [f1, f2] = check_intrinsic_arg_count(args)?;
-                let f1 = this.read_scalar(f1)?.to_f64()?;
-                let f2 = this.read_scalar(f2)?.to_f64()?;
-
-                let res =
-                    math::fixed_float_value(this, intrinsic_name, &[f1, f2]).unwrap_or_else(|| {
-                        // Using host floats (but it's fine, this operation does not have guaranteed precision).
-                        let res = f1.to_host().powf(f2.to_host()).to_soft();
-
-                        // Apply a relative error of 4ULP to introduce some non-determinism
-                        // simulating imprecise implementations and optimizations.
-                        math::apply_random_float_error_ulp(this, res, 4)
-                    });
-                let res = this.adjust_nan(res, &[f1, f2]);
-                this.write_scalar(res, dest)?;
-            }
-
-            "powif32" => {
-                let [f, i] = check_intrinsic_arg_count(args)?;
-                let f = this.read_scalar(f)?.to_f32()?;
-                let i = this.read_scalar(i)?.to_i32()?;
-
-                let res = math::fixed_powi_value(this, f, i).unwrap_or_else(|| {
-                    // Using host floats (but it's fine, this operation does not have guaranteed precision).
-                    let res = f.to_host().powi(i).to_soft();
-
-                    // Apply a relative error of 4ULP to introduce some non-determinism
-                    // simulating imprecise implementations and optimizations.
-                    math::apply_random_float_error_ulp(this, res, 4)
-                });
-                let res = this.adjust_nan(res, &[f]);
-                this.write_scalar(res, dest)?;
-            }
-            "powif64" => {
-                let [f, i] = check_intrinsic_arg_count(args)?;
-                let f = this.read_scalar(f)?.to_f64()?;
-                let i = this.read_scalar(i)?.to_i32()?;
-
-                let res = math::fixed_powi_value(this, f, i).unwrap_or_else(|| {
-                    // Using host floats (but it's fine, this operation does not have guaranteed precision).
-                    let res = f.to_host().powi(i).to_soft();
-
-                    // Apply a relative error of 4ULP to introduce some non-determinism
-                    // simulating imprecise implementations and optimizations.
-                    math::apply_random_float_error_ulp(this, res, 4)
-                });
-                let res = this.adjust_nan(res, &[f]);
-                this.write_scalar(res, dest)?;
-            }
-
-            #[rustfmt::skip]
-            | "fadd_fast"
-            | "fsub_fast"
-            | "fmul_fast"
-            | "fdiv_fast"
-            | "frem_fast"
-            => {
-                let [a, b] = check_intrinsic_arg_count(args)?;
-                let a = this.read_immediate(a)?;
-                let b = this.read_immediate(b)?;
-                let op = match intrinsic_name {
-                    "fadd_fast" => mir::BinOp::Add,
-                    "fsub_fast" => mir::BinOp::Sub,
-                    "fmul_fast" => mir::BinOp::Mul,
-                    "fdiv_fast" => mir::BinOp::Div,
-                    "frem_fast" => mir::BinOp::Rem,
-                    _ => bug!(),
-                };
-                let float_finite = |x: &ImmTy<'tcx>| -> InterpResult<'tcx, bool> {
-                    let ty::Float(fty) = x.layout.ty.kind() else {
-                        bug!("float_finite: non-float input type {}", x.layout.ty)
-                    };
-                    interp_ok(match fty {
-                        FloatTy::F16 => x.to_scalar().to_f16()?.is_finite(),
-                        FloatTy::F32 => x.to_scalar().to_f32()?.is_finite(),
-                        FloatTy::F64 => x.to_scalar().to_f64()?.is_finite(),
-                        FloatTy::F128 => x.to_scalar().to_f128()?.is_finite(),
-                    })
-                };
-                match (float_finite(&a)?, float_finite(&b)?) {
-                    (false, false) => throw_ub_format!(
-                        "`{intrinsic_name}` intrinsic called with non-finite value as both parameters",
-                    ),
-                    (false, _) => throw_ub_format!(
-                        "`{intrinsic_name}` intrinsic called with non-finite value as first parameter",
-                    ),
-                    (_, false) => throw_ub_format!(
-                        "`{intrinsic_name}` intrinsic called with non-finite value as second parameter",
-                    ),
-                    _ => {}
-                }
-                let res = this.binary_op(op, &a, &b)?;
-                // This cannot be a NaN so we also don't have to apply any non-determinism.
-                // (Also, `binary_op` already called `generate_nan` if needed.)
-                if !float_finite(&res)? {
-                    throw_ub_format!("`{intrinsic_name}` intrinsic produced non-finite value as result");
-                }
-                // Apply a relative error of 4ULP to simulate non-deterministic precision loss
-                // due to optimizations.
-                let res = math::apply_random_float_error_to_imm(this, res, 4)?;
-                this.write_immediate(*res, dest)?;
-            }
-
-            "float_to_int_unchecked" => {
-                let [val] = check_intrinsic_arg_count(args)?;
-                let val = this.read_immediate(val)?;
-
-                let res = this
-                    .float_to_int_checked(&val, dest.layout, Round::TowardZero)?
-                    .ok_or_else(|| {
-                        err_ub_format!(
-                            "`float_to_int_unchecked` intrinsic called on {val} which cannot be represented in target type `{:?}`",
-                            dest.layout.ty
-                        )
-                    })?;
-
-                this.write_immediate(*res, dest)?;
-            }
-
             // Other
             "breakpoint" => {
                 let [] = check_intrinsic_arg_count(args)?;
@@ -472,7 +189,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 // Make these a NOP, so we get the better Miri-native error messages.
             }
 
-            _ => return interp_ok(EmulateItemResult::NotSupported),
+            _ => return this.emulate_math_intrinsic(intrinsic_name, generic_args, args, dest),
         }
 
         interp_ok(EmulateItemResult::NeedsReturn)

From e00051299aa7a355307baeeac0bd593c71e8019e Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 19 Jul 2025 12:11:04 +0200
Subject: [PATCH 0649/1889] extract core operation name instead of listing all
 function name variants

---
 src/tools/miri/src/math.rs | 43 +++++++++++++++++++++++---------------
 1 file changed, 26 insertions(+), 17 deletions(-)

diff --git a/src/tools/miri/src/math.rs b/src/tools/miri/src/math.rs
index 254495637da42..f89abbaba4805 100644
--- a/src/tools/miri/src/math.rs
+++ b/src/tools/miri/src/math.rs
@@ -210,61 +210,70 @@ where
     let pi_over_2 = (pi / two).value;
     let pi_over_4 = (pi_over_2 / two).value;
 
-    Some(match (intrinsic_name, args) {
+    // Remove `f32`/`f64` suffix, if any.
+    let name = intrinsic_name
+        .strip_suffix("f32")
+        .or_else(|| intrinsic_name.strip_suffix("f64"))
+        .unwrap_or(intrinsic_name);
+    // Also strip trailing `f` (indicates "float"), with an exception for "erf" to avoid
+    // removing that `f`.
+    let name = if name == "erf" { name } else { name.strip_suffix("f").unwrap_or(name) };
+    Some(match (name, args) {
         // cos(±0) and cosh(±0)= 1
-        ("cosf32" | "cosf64" | "coshf" | "cosh", [input]) if input.is_zero() => one,
+        ("cos" | "cosh", [input]) if input.is_zero() => one,
 
         // e^0 = 1
-        ("expf32" | "expf64" | "exp2f32" | "exp2f64", [input]) if input.is_zero() => one,
+        ("exp" | "exp2", [input]) if input.is_zero() => one,
 
         // tanh(±INF) = ±1
-        ("tanhf" | "tanh", [input]) if input.is_infinite() => one.copy_sign(*input),
+        ("tanh", [input]) if input.is_infinite() => one.copy_sign(*input),
 
         // atan(±INF) = ±π/2
-        ("atanf" | "atan", [input]) if input.is_infinite() => pi_over_2.copy_sign(*input),
+        ("atan", [input]) if input.is_infinite() => pi_over_2.copy_sign(*input),
 
         // erf(±INF) = ±1
-        ("erff" | "erf", [input]) if input.is_infinite() => one.copy_sign(*input),
+        ("erf", [input]) if input.is_infinite() => one.copy_sign(*input),
 
         // erfc(-INF) = 2
-        ("erfcf" | "erfc", [input]) if input.is_neg_infinity() => (one + one).value,
+        ("erfc", [input]) if input.is_neg_infinity() => (one + one).value,
 
         // hypot(x, ±0) = abs(x), if x is not a NaN.
-        ("_hypotf" | "hypotf" | "_hypot" | "hypot", [x, y]) if !x.is_nan() && y.is_zero() =>
+        // `_hypot` is the Windows name for this.
+        ("_hypot" | "hypot", [x, y]) if !x.is_nan() && y.is_zero() =>
             x.abs(),
 
         // atan2(±0,−0) = ±π.
         // atan2(±0, y) = ±π for y < 0.
         // Must check for non NaN because `y.is_negative()` also applies to NaN.
-        ("atan2f" | "atan2", [x, y]) if (x.is_zero() && (y.is_negative() && !y.is_nan())) =>
+        ("atan2", [x, y]) if (x.is_zero() && (y.is_negative() && !y.is_nan())) =>
             pi.copy_sign(*x),
 
         // atan2(±x,−∞) = ±π for finite x > 0.
-        ("atan2f" | "atan2", [x, y])
+        ("atan2", [x, y])
             if (!x.is_zero() && !x.is_infinite()) && y.is_neg_infinity() =>
             pi.copy_sign(*x),
 
         // atan2(x, ±0) = −π/2 for x < 0.
         // atan2(x, ±0) =  π/2 for x > 0.
-        ("atan2f" | "atan2", [x, y]) if !x.is_zero() && y.is_zero() => pi_over_2.copy_sign(*x),
+        ("atan2", [x, y]) if !x.is_zero() && y.is_zero() => pi_over_2.copy_sign(*x),
 
         //atan2(±∞, −∞) = ±3π/4
-        ("atan2f" | "atan2", [x, y]) if x.is_infinite() && y.is_neg_infinity() =>
+        ("atan2", [x, y]) if x.is_infinite() && y.is_neg_infinity() =>
             (pi_over_4 * three).value.copy_sign(*x),
 
         //atan2(±∞, +∞) = ±π/4
-        ("atan2f" | "atan2", [x, y]) if x.is_infinite() && y.is_pos_infinity() =>
+        ("atan2", [x, y]) if x.is_infinite() && y.is_pos_infinity() =>
             pi_over_4.copy_sign(*x),
 
         // atan2(±∞, y) returns ±π/2 for finite y.
-        ("atan2f" | "atan2", [x, y]) if x.is_infinite() && (!y.is_infinite() && !y.is_nan()) =>
+        ("atan2", [x, y]) if x.is_infinite() && (!y.is_infinite() && !y.is_nan()) =>
             pi_over_2.copy_sign(*x),
 
         // (-1)^(±INF) = 1
-        ("powf32" | "powf64", [base, exp]) if *base == -one && exp.is_infinite() => one,
+        ("pow", [base, exp]) if *base == -one && exp.is_infinite() => one,
 
         // 1^y = 1 for any y, even a NaN
-        ("powf32" | "powf64", [base, exp]) if *base == one => {
+        ("pow", [base, exp]) if *base == one => {
             let rng = this.machine.rng.get_mut();
             // SNaN exponents get special treatment: they might return 1, or a NaN.
             let return_nan = exp.is_signaling() && this.machine.float_nondet && rng.random();
@@ -273,7 +282,7 @@ where
         }
 
         // x^(±0) = 1 for any x, even a NaN
-        ("powf32" | "powf64", [base, exp]) if exp.is_zero() => {
+        ("pow", [base, exp]) if exp.is_zero() => {
             let rng = this.machine.rng.get_mut();
             // SNaN bases get special treatment: they might return 1, or a NaN.
             let return_nan = base.is_signaling() && this.machine.float_nondet && rng.random();

From 84e1950065525589f2d22860aa64c36f171fc782 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 19 Jul 2025 12:20:43 +0200
Subject: [PATCH 0650/1889] move math foreign_items into their own file

---
 src/tools/miri/src/math.rs                |  12 +-
 src/tools/miri/src/shims/foreign_items.rs | 238 ++-------------------
 src/tools/miri/src/shims/math.rs          | 247 ++++++++++++++++++++++
 src/tools/miri/src/shims/mod.rs           |   1 +
 4 files changed, 266 insertions(+), 232 deletions(-)
 create mode 100644 src/tools/miri/src/shims/math.rs

diff --git a/src/tools/miri/src/math.rs b/src/tools/miri/src/math.rs
index f89abbaba4805..401e6dd7aab84 100644
--- a/src/tools/miri/src/math.rs
+++ b/src/tools/miri/src/math.rs
@@ -239,18 +239,15 @@ where
 
         // hypot(x, ±0) = abs(x), if x is not a NaN.
         // `_hypot` is the Windows name for this.
-        ("_hypot" | "hypot", [x, y]) if !x.is_nan() && y.is_zero() =>
-            x.abs(),
+        ("_hypot" | "hypot", [x, y]) if !x.is_nan() && y.is_zero() => x.abs(),
 
         // atan2(±0,−0) = ±π.
         // atan2(±0, y) = ±π for y < 0.
         // Must check for non NaN because `y.is_negative()` also applies to NaN.
-        ("atan2", [x, y]) if (x.is_zero() && (y.is_negative() && !y.is_nan())) =>
-            pi.copy_sign(*x),
+        ("atan2", [x, y]) if (x.is_zero() && (y.is_negative() && !y.is_nan())) => pi.copy_sign(*x),
 
         // atan2(±x,−∞) = ±π for finite x > 0.
-        ("atan2", [x, y])
-            if (!x.is_zero() && !x.is_infinite()) && y.is_neg_infinity() =>
+        ("atan2", [x, y]) if (!x.is_zero() && !x.is_infinite()) && y.is_neg_infinity() =>
             pi.copy_sign(*x),
 
         // atan2(x, ±0) = −π/2 for x < 0.
@@ -262,8 +259,7 @@ where
             (pi_over_4 * three).value.copy_sign(*x),
 
         //atan2(±∞, +∞) = ±π/4
-        ("atan2", [x, y]) if x.is_infinite() && y.is_pos_infinity() =>
-            pi_over_4.copy_sign(*x),
+        ("atan2", [x, y]) if x.is_infinite() && y.is_pos_infinity() => pi_over_4.copy_sign(*x),
 
         // atan2(±∞, y) returns ±π/2 for finite y.
         ("atan2", [x, y]) if x.is_infinite() && (!y.is_infinite() && !y.is_nan()) =>
diff --git a/src/tools/miri/src/shims/foreign_items.rs b/src/tools/miri/src/shims/foreign_items.rs
index 10e28178177b2..eca8cccf5efc4 100644
--- a/src/tools/miri/src/shims/foreign_items.rs
+++ b/src/tools/miri/src/shims/foreign_items.rs
@@ -3,7 +3,6 @@ use std::io::Write;
 use std::path::Path;
 
 use rustc_abi::{Align, AlignFromBytesError, CanonAbi, Size};
-use rustc_apfloat::Float;
 use rustc_ast::expand::allocator::alloc_error_handler_name;
 use rustc_hir::attrs::Linkage;
 use rustc_hir::def::DefKind;
@@ -15,7 +14,6 @@ use rustc_middle::{mir, ty};
 use rustc_span::Symbol;
 use rustc_target::callconv::FnAbi;
 
-use self::helpers::{ToHost, ToSoft};
 use super::alloc::EvalContextExt as _;
 use super::backtrace::EvalContextExt as _;
 use crate::helpers::EvalContextExt as _;
@@ -818,225 +816,6 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 this.write_pointer(ptr_dest, dest)?;
             }
 
-            // math functions (note that there are also intrinsics for some other functions)
-            #[rustfmt::skip]
-            | "cbrtf"
-            | "coshf"
-            | "sinhf"
-            | "tanf"
-            | "tanhf"
-            | "acosf"
-            | "asinf"
-            | "atanf"
-            | "log1pf"
-            | "expm1f"
-            | "tgammaf"
-            | "erff"
-            | "erfcf"
-            => {
-                let [f] = this.check_shim_sig_lenient(abi, CanonAbi::C , link_name, args)?;
-                let f = this.read_scalar(f)?.to_f32()?;
-
-                let res = math::fixed_float_value(this, link_name.as_str(), &[f]).unwrap_or_else(|| {
-                    // Using host floats (but it's fine, these operations do not have
-                    // guaranteed precision).
-                    let f_host = f.to_host();
-                    let res = match link_name.as_str() {
-                        "cbrtf" => f_host.cbrt(),
-                        "coshf" => f_host.cosh(),
-                        "sinhf" => f_host.sinh(),
-                        "tanf" => f_host.tan(),
-                        "tanhf" => f_host.tanh(),
-                        "acosf" => f_host.acos(),
-                        "asinf" => f_host.asin(),
-                        "atanf" => f_host.atan(),
-                        "log1pf" => f_host.ln_1p(),
-                        "expm1f" => f_host.exp_m1(),
-                        "tgammaf" => f_host.gamma(),
-                        "erff" => f_host.erf(),
-                        "erfcf" => f_host.erfc(),
-                        _ => bug!(),
-                    };
-                    let res = res.to_soft();
-                    // Apply a relative error of 4ULP to introduce some non-determinism
-                    // simulating imprecise implementations and optimizations.
-                    let res = math::apply_random_float_error_ulp(this, res, 4);
-
-                    // Clamp the result to the guaranteed range of this function according to the C standard,
-                    // if any.
-                    math::clamp_float_value(link_name.as_str(), res)
-                });
-                let res = this.adjust_nan(res, &[f]);
-                this.write_scalar(res, dest)?;
-            }
-            #[rustfmt::skip]
-            | "_hypotf"
-            | "hypotf"
-            | "atan2f"
-            | "fdimf"
-            => {
-                let [f1, f2] = this.check_shim_sig_lenient(abi, CanonAbi::C , link_name, args)?;
-                let f1 = this.read_scalar(f1)?.to_f32()?;
-                let f2 = this.read_scalar(f2)?.to_f32()?;
-
-                let res = math::fixed_float_value(this, link_name.as_str(), &[f1, f2])
-                    .unwrap_or_else(|| {
-                        let res = match link_name.as_str() {
-                            // underscore case for windows, here and below
-                            // (see https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/floating-point-primitives?view=vs-2019)
-                            // Using host floats (but it's fine, these operations do not have guaranteed precision).
-                            "_hypotf" | "hypotf" => f1.to_host().hypot(f2.to_host()).to_soft(),
-                            "atan2f" => f1.to_host().atan2(f2.to_host()).to_soft(),
-                            #[allow(deprecated)]
-                            "fdimf" => f1.to_host().abs_sub(f2.to_host()).to_soft(),
-                            _ => bug!(),
-                        };
-                        // Apply a relative error of 4ULP to introduce some non-determinism
-                        // simulating imprecise implementations and optimizations.
-                        let res = math::apply_random_float_error_ulp(this, res, 4);
-
-                        // Clamp the result to the guaranteed range of this function according to the C standard,
-                        // if any.
-                        math::clamp_float_value(link_name.as_str(), res)
-                    });
-                let res = this.adjust_nan(res, &[f1, f2]);
-                this.write_scalar(res, dest)?;
-            }
-            #[rustfmt::skip]
-            | "cbrt"
-            | "cosh"
-            | "sinh"
-            | "tan"
-            | "tanh"
-            | "acos"
-            | "asin"
-            | "atan"
-            | "log1p"
-            | "expm1"
-            | "tgamma"
-            | "erf"
-            | "erfc"
-            => {
-                let [f] = this.check_shim_sig_lenient(abi, CanonAbi::C , link_name, args)?;
-                let f = this.read_scalar(f)?.to_f64()?;
-
-                let res = math::fixed_float_value(this, link_name.as_str(), &[f]).unwrap_or_else(|| {
-                    // Using host floats (but it's fine, these operations do not have
-                    // guaranteed precision).
-                    let f_host = f.to_host();
-                    let res = match link_name.as_str() {
-                        "cbrt" => f_host.cbrt(),
-                        "cosh" => f_host.cosh(),
-                        "sinh" => f_host.sinh(),
-                        "tan" => f_host.tan(),
-                        "tanh" => f_host.tanh(),
-                        "acos" => f_host.acos(),
-                        "asin" => f_host.asin(),
-                        "atan" => f_host.atan(),
-                        "log1p" => f_host.ln_1p(),
-                        "expm1" => f_host.exp_m1(),
-                        "tgamma" => f_host.gamma(),
-                        "erf" => f_host.erf(),
-                        "erfc" => f_host.erfc(),
-                        _ => bug!(),
-                    };
-                    let res = res.to_soft();
-                    // Apply a relative error of 4ULP to introduce some non-determinism
-                    // simulating imprecise implementations and optimizations.
-                    let res = math::apply_random_float_error_ulp(this, res, 4);
-
-                    // Clamp the result to the guaranteed range of this function according to the C standard,
-                    // if any.
-                    math::clamp_float_value(link_name.as_str(), res)
-                });
-                let res = this.adjust_nan(res, &[f]);
-                this.write_scalar(res, dest)?;
-            }
-            #[rustfmt::skip]
-            | "_hypot"
-            | "hypot"
-            | "atan2"
-            | "fdim"
-            => {
-                let [f1, f2] = this.check_shim_sig_lenient(abi, CanonAbi::C , link_name, args)?;
-                let f1 = this.read_scalar(f1)?.to_f64()?;
-                let f2 = this.read_scalar(f2)?.to_f64()?;
-
-                let res = math::fixed_float_value(this, link_name.as_str(), &[f1, f2]).unwrap_or_else(|| {
-                    let res = match link_name.as_str() {
-                        // underscore case for windows, here and below
-                        // (see https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/floating-point-primitives?view=vs-2019)
-                        // Using host floats (but it's fine, these operations do not have guaranteed precision).
-                        "_hypot" | "hypot" => f1.to_host().hypot(f2.to_host()).to_soft(),
-                        "atan2" => f1.to_host().atan2(f2.to_host()).to_soft(),
-                        #[allow(deprecated)]
-                        "fdim" => f1.to_host().abs_sub(f2.to_host()).to_soft(),
-                        _ => bug!(),
-                    };
-                    // Apply a relative error of 4ULP to introduce some non-determinism
-                    // simulating imprecise implementations and optimizations.
-                    let res = math::apply_random_float_error_ulp(this, res, 4);
-
-                    // Clamp the result to the guaranteed range of this function according to the C standard,
-                    // if any.
-                    math::clamp_float_value(link_name.as_str(), res)
-                });
-                let res = this.adjust_nan(res, &[f1, f2]);
-                this.write_scalar(res, dest)?;
-            }
-            #[rustfmt::skip]
-            | "_ldexp"
-            | "ldexp"
-            | "scalbn"
-            => {
-                let [x, exp] = this.check_shim_sig_lenient(abi, CanonAbi::C , link_name, args)?;
-                // For radix-2 (binary) systems, `ldexp` and `scalbn` are the same.
-                let x = this.read_scalar(x)?.to_f64()?;
-                let exp = this.read_scalar(exp)?.to_i32()?;
-
-                let res = x.scalbn(exp);
-                let res = this.adjust_nan(res, &[x]);
-                this.write_scalar(res, dest)?;
-            }
-            "lgammaf_r" => {
-                let [x, signp] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
-                let x = this.read_scalar(x)?.to_f32()?;
-                let signp = this.deref_pointer_as(signp, this.machine.layouts.i32)?;
-
-                // Using host floats (but it's fine, these operations do not have guaranteed precision).
-                let (res, sign) = x.to_host().ln_gamma();
-                this.write_int(sign, &signp)?;
-
-                let res = res.to_soft();
-                // Apply a relative error of 4ULP to introduce some non-determinism
-                // simulating imprecise implementations and optimizations.
-                let res = math::apply_random_float_error_ulp(this, res, 4);
-                // Clamp the result to the guaranteed range of this function according to the C standard,
-                // if any.
-                let res = math::clamp_float_value(link_name.as_str(), res);
-                let res = this.adjust_nan(res, &[x]);
-                this.write_scalar(res, dest)?;
-            }
-            "lgamma_r" => {
-                let [x, signp] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
-                let x = this.read_scalar(x)?.to_f64()?;
-                let signp = this.deref_pointer_as(signp, this.machine.layouts.i32)?;
-
-                // Using host floats (but it's fine, these operations do not have guaranteed precision).
-                let (res, sign) = x.to_host().ln_gamma();
-                this.write_int(sign, &signp)?;
-
-                let res = res.to_soft();
-                // Apply a relative error of 4ULP to introduce some non-determinism
-                // simulating imprecise implementations and optimizations.
-                let res = math::apply_random_float_error_ulp(this, res, 4);
-                // Clamp the result to the guaranteed range of this function according to the C standard,
-                // if any.
-                let res = math::clamp_float_value(link_name.as_str(), res);
-                let res = this.adjust_nan(res, &[x]);
-                this.write_scalar(res, dest)?;
-            }
-
             // LLVM intrinsics
             "llvm.prefetch" => {
                 let [p, rw, loc, ty] =
@@ -1118,8 +897,18 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 }
             }
 
-            // Platform-specific shims
-            _ =>
+            // Fallback to shims in submodules.
+            _ => {
+                // Math shims
+                #[expect(irrefutable_let_patterns)]
+                if let res = shims::math::EvalContextExt::emulate_foreign_item_inner(
+                    this, link_name, abi, args, dest,
+                )? && !matches!(res, EmulateItemResult::NotSupported)
+                {
+                    return interp_ok(res);
+                }
+
+                // Platform-specific shims
                 return match this.tcx.sess.target.os.as_ref() {
                     _ if this.target_os_is_unix() =>
                         shims::unix::foreign_items::EvalContextExt::emulate_foreign_item_inner(
@@ -1134,7 +923,8 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                             this, link_name, abi, args, dest,
                         ),
                     _ => interp_ok(EmulateItemResult::NotSupported),
-                },
+                };
+            }
         };
         // We only fall through to here if we did *not* hit the `_` arm above,
         // i.e., if we actually emulated the function with one of the shims.
diff --git a/src/tools/miri/src/shims/math.rs b/src/tools/miri/src/shims/math.rs
new file mode 100644
index 0000000000000..576e76494bcb7
--- /dev/null
+++ b/src/tools/miri/src/shims/math.rs
@@ -0,0 +1,247 @@
+use rustc_abi::CanonAbi;
+use rustc_apfloat::Float;
+use rustc_middle::ty::Ty;
+use rustc_span::Symbol;
+use rustc_target::callconv::FnAbi;
+
+use self::helpers::{ToHost, ToSoft};
+use crate::*;
+
+impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
+pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
+    fn emulate_foreign_item_inner(
+        &mut self,
+        link_name: Symbol,
+        abi: &FnAbi<'tcx, Ty<'tcx>>,
+        args: &[OpTy<'tcx>],
+        dest: &MPlaceTy<'tcx>,
+    ) -> InterpResult<'tcx, EmulateItemResult> {
+        let this = self.eval_context_mut();
+
+        // math functions (note that there are also intrinsics for some other functions)
+        match link_name.as_str() {
+            // math functions (note that there are also intrinsics for some other functions)
+            #[rustfmt::skip]
+            | "cbrtf"
+            | "coshf"
+            | "sinhf"
+            | "tanf"
+            | "tanhf"
+            | "acosf"
+            | "asinf"
+            | "atanf"
+            | "log1pf"
+            | "expm1f"
+            | "tgammaf"
+            | "erff"
+            | "erfcf"
+            => {
+                let [f] = this.check_shim_sig_lenient(abi, CanonAbi::C , link_name, args)?;
+                let f = this.read_scalar(f)?.to_f32()?;
+
+                let res = math::fixed_float_value(this, link_name.as_str(), &[f]).unwrap_or_else(|| {
+                    // Using host floats (but it's fine, these operations do not have
+                    // guaranteed precision).
+                    let f_host = f.to_host();
+                    let res = match link_name.as_str() {
+                        "cbrtf" => f_host.cbrt(),
+                        "coshf" => f_host.cosh(),
+                        "sinhf" => f_host.sinh(),
+                        "tanf" => f_host.tan(),
+                        "tanhf" => f_host.tanh(),
+                        "acosf" => f_host.acos(),
+                        "asinf" => f_host.asin(),
+                        "atanf" => f_host.atan(),
+                        "log1pf" => f_host.ln_1p(),
+                        "expm1f" => f_host.exp_m1(),
+                        "tgammaf" => f_host.gamma(),
+                        "erff" => f_host.erf(),
+                        "erfcf" => f_host.erfc(),
+                        _ => bug!(),
+                    };
+                    let res = res.to_soft();
+                    // Apply a relative error of 4ULP to introduce some non-determinism
+                    // simulating imprecise implementations and optimizations.
+                    let res = math::apply_random_float_error_ulp(this, res, 4);
+
+                    // Clamp the result to the guaranteed range of this function according to the C standard,
+                    // if any.
+                    math::clamp_float_value(link_name.as_str(), res)
+                });
+                let res = this.adjust_nan(res, &[f]);
+                this.write_scalar(res, dest)?;
+            }
+            #[rustfmt::skip]
+            | "_hypotf"
+            | "hypotf"
+            | "atan2f"
+            | "fdimf"
+            => {
+                let [f1, f2] = this.check_shim_sig_lenient(abi, CanonAbi::C , link_name, args)?;
+                let f1 = this.read_scalar(f1)?.to_f32()?;
+                let f2 = this.read_scalar(f2)?.to_f32()?;
+
+                let res = math::fixed_float_value(this, link_name.as_str(), &[f1, f2])
+                    .unwrap_or_else(|| {
+                        let res = match link_name.as_str() {
+                            // underscore case for windows, here and below
+                            // (see https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/floating-point-primitives?view=vs-2019)
+                            // Using host floats (but it's fine, these operations do not have guaranteed precision).
+                            "_hypotf" | "hypotf" => f1.to_host().hypot(f2.to_host()).to_soft(),
+                            "atan2f" => f1.to_host().atan2(f2.to_host()).to_soft(),
+                            #[allow(deprecated)]
+                            "fdimf" => f1.to_host().abs_sub(f2.to_host()).to_soft(),
+                            _ => bug!(),
+                        };
+                        // Apply a relative error of 4ULP to introduce some non-determinism
+                        // simulating imprecise implementations and optimizations.
+                        let res = math::apply_random_float_error_ulp(this, res, 4);
+
+                        // Clamp the result to the guaranteed range of this function according to the C standard,
+                        // if any.
+                        math::clamp_float_value(link_name.as_str(), res)
+                    });
+                let res = this.adjust_nan(res, &[f1, f2]);
+                this.write_scalar(res, dest)?;
+            }
+            #[rustfmt::skip]
+            | "cbrt"
+            | "cosh"
+            | "sinh"
+            | "tan"
+            | "tanh"
+            | "acos"
+            | "asin"
+            | "atan"
+            | "log1p"
+            | "expm1"
+            | "tgamma"
+            | "erf"
+            | "erfc"
+            => {
+                let [f] = this.check_shim_sig_lenient(abi, CanonAbi::C , link_name, args)?;
+                let f = this.read_scalar(f)?.to_f64()?;
+
+                let res = math::fixed_float_value(this, link_name.as_str(), &[f]).unwrap_or_else(|| {
+                    // Using host floats (but it's fine, these operations do not have
+                    // guaranteed precision).
+                    let f_host = f.to_host();
+                    let res = match link_name.as_str() {
+                        "cbrt" => f_host.cbrt(),
+                        "cosh" => f_host.cosh(),
+                        "sinh" => f_host.sinh(),
+                        "tan" => f_host.tan(),
+                        "tanh" => f_host.tanh(),
+                        "acos" => f_host.acos(),
+                        "asin" => f_host.asin(),
+                        "atan" => f_host.atan(),
+                        "log1p" => f_host.ln_1p(),
+                        "expm1" => f_host.exp_m1(),
+                        "tgamma" => f_host.gamma(),
+                        "erf" => f_host.erf(),
+                        "erfc" => f_host.erfc(),
+                        _ => bug!(),
+                    };
+                    let res = res.to_soft();
+                    // Apply a relative error of 4ULP to introduce some non-determinism
+                    // simulating imprecise implementations and optimizations.
+                    let res = math::apply_random_float_error_ulp(this, res, 4);
+
+                    // Clamp the result to the guaranteed range of this function according to the C standard,
+                    // if any.
+                    math::clamp_float_value(link_name.as_str(), res)
+                });
+                let res = this.adjust_nan(res, &[f]);
+                this.write_scalar(res, dest)?;
+            }
+            #[rustfmt::skip]
+            | "_hypot"
+            | "hypot"
+            | "atan2"
+            | "fdim"
+            => {
+                let [f1, f2] = this.check_shim_sig_lenient(abi, CanonAbi::C , link_name, args)?;
+                let f1 = this.read_scalar(f1)?.to_f64()?;
+                let f2 = this.read_scalar(f2)?.to_f64()?;
+
+                let res = math::fixed_float_value(this, link_name.as_str(), &[f1, f2]).unwrap_or_else(|| {
+                    let res = match link_name.as_str() {
+                        // underscore case for windows, here and below
+                        // (see https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/floating-point-primitives?view=vs-2019)
+                        // Using host floats (but it's fine, these operations do not have guaranteed precision).
+                        "_hypot" | "hypot" => f1.to_host().hypot(f2.to_host()).to_soft(),
+                        "atan2" => f1.to_host().atan2(f2.to_host()).to_soft(),
+                        #[allow(deprecated)]
+                        "fdim" => f1.to_host().abs_sub(f2.to_host()).to_soft(),
+                        _ => bug!(),
+                    };
+                    // Apply a relative error of 4ULP to introduce some non-determinism
+                    // simulating imprecise implementations and optimizations.
+                    let res = math::apply_random_float_error_ulp(this, res, 4);
+
+                    // Clamp the result to the guaranteed range of this function according to the C standard,
+                    // if any.
+                    math::clamp_float_value(link_name.as_str(), res)
+                });
+                let res = this.adjust_nan(res, &[f1, f2]);
+                this.write_scalar(res, dest)?;
+            }
+            #[rustfmt::skip]
+            | "_ldexp"
+            | "ldexp"
+            | "scalbn"
+            => {
+                let [x, exp] = this.check_shim_sig_lenient(abi, CanonAbi::C , link_name, args)?;
+                // For radix-2 (binary) systems, `ldexp` and `scalbn` are the same.
+                let x = this.read_scalar(x)?.to_f64()?;
+                let exp = this.read_scalar(exp)?.to_i32()?;
+
+                let res = x.scalbn(exp);
+                let res = this.adjust_nan(res, &[x]);
+                this.write_scalar(res, dest)?;
+            }
+            "lgammaf_r" => {
+                let [x, signp] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
+                let x = this.read_scalar(x)?.to_f32()?;
+                let signp = this.deref_pointer_as(signp, this.machine.layouts.i32)?;
+
+                // Using host floats (but it's fine, these operations do not have guaranteed precision).
+                let (res, sign) = x.to_host().ln_gamma();
+                this.write_int(sign, &signp)?;
+
+                let res = res.to_soft();
+                // Apply a relative error of 4ULP to introduce some non-determinism
+                // simulating imprecise implementations and optimizations.
+                let res = math::apply_random_float_error_ulp(this, res, 4);
+                // Clamp the result to the guaranteed range of this function according to the C standard,
+                // if any.
+                let res = math::clamp_float_value(link_name.as_str(), res);
+                let res = this.adjust_nan(res, &[x]);
+                this.write_scalar(res, dest)?;
+            }
+            "lgamma_r" => {
+                let [x, signp] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
+                let x = this.read_scalar(x)?.to_f64()?;
+                let signp = this.deref_pointer_as(signp, this.machine.layouts.i32)?;
+
+                // Using host floats (but it's fine, these operations do not have guaranteed precision).
+                let (res, sign) = x.to_host().ln_gamma();
+                this.write_int(sign, &signp)?;
+
+                let res = res.to_soft();
+                // Apply a relative error of 4ULP to introduce some non-determinism
+                // simulating imprecise implementations and optimizations.
+                let res = math::apply_random_float_error_ulp(this, res, 4);
+                // Clamp the result to the guaranteed range of this function according to the C standard,
+                // if any.
+                let res = math::clamp_float_value(link_name.as_str(), res);
+                let res = this.adjust_nan(res, &[x]);
+                this.write_scalar(res, dest)?;
+            }
+
+            _ => return interp_ok(EmulateItemResult::NotSupported),
+        }
+
+        interp_ok(EmulateItemResult::NeedsReturn)
+    }
+}
diff --git a/src/tools/miri/src/shims/mod.rs b/src/tools/miri/src/shims/mod.rs
index 7f594d4fdd6bc..7f7bc3b1cf720 100644
--- a/src/tools/miri/src/shims/mod.rs
+++ b/src/tools/miri/src/shims/mod.rs
@@ -4,6 +4,7 @@ mod aarch64;
 mod alloc;
 mod backtrace;
 mod files;
+mod math;
 #[cfg(all(unix, feature = "native-lib"))]
 mod native_lib;
 mod unix;

From aed0ed4c93d661fc7b66dc4a39690948476e8a4a Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 8 Sep 2025 10:40:18 +0200
Subject: [PATCH 0651/1889] const-eval: disable pointer fragment support

---
 .../rustc_const_eval/src/interpret/memory.rs  |  6 ++-
 .../src/mir/interpret/allocation.rs           |  5 +++
 .../interpret/allocation/provenance_map.rs    | 16 +++++++-
 library/core/src/ptr/mod.rs                   | 38 ++++++++++++++++++-
 library/coretests/tests/ptr.rs                |  9 +++--
 tests/ui/consts/const-eval/ptr_fragments.rs   |  1 +
 .../const-eval/ptr_fragments_in_final.rs      |  1 +
 .../consts/const-eval/ptr_fragments_mixed.rs  | 28 ++++++++++++++
 .../const-eval/ptr_fragments_mixed.stderr     | 23 +++++++++++
 .../ui/consts/const-eval/read_partial_ptr.rs  |  1 +
 10 files changed, 119 insertions(+), 9 deletions(-)
 create mode 100644 tests/ui/consts/const-eval/ptr_fragments_mixed.rs
 create mode 100644 tests/ui/consts/const-eval/ptr_fragments_mixed.stderr

diff --git a/compiler/rustc_const_eval/src/interpret/memory.rs b/compiler/rustc_const_eval/src/interpret/memory.rs
index 2c1e5087e1c6b..6ec85648d6d88 100644
--- a/compiler/rustc_const_eval/src/interpret/memory.rs
+++ b/compiler/rustc_const_eval/src/interpret/memory.rs
@@ -1501,8 +1501,10 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         // `get_bytes_mut` will clear the provenance, which is correct,
         // since we don't want to keep any provenance at the target.
         // This will also error if copying partial provenance is not supported.
-        let provenance =
-            src_alloc.provenance().prepare_copy(src_range, dest_offset, num_copies, self);
+        let provenance = src_alloc
+            .provenance()
+            .prepare_copy(src_range, dest_offset, num_copies, self)
+            .map_err(|e| e.to_interp_error(src_alloc_id))?;
         // Prepare a copy of the initialization mask.
         let init = src_alloc.init_mask().prepare_copy(src_range);
 
diff --git a/compiler/rustc_middle/src/mir/interpret/allocation.rs b/compiler/rustc_middle/src/mir/interpret/allocation.rs
index 2ea92a39d4828..67962813ae437 100644
--- a/compiler/rustc_middle/src/mir/interpret/allocation.rs
+++ b/compiler/rustc_middle/src/mir/interpret/allocation.rs
@@ -724,6 +724,11 @@ impl<Prov: Provenance, Extra, Bytes: AllocBytes> Allocation<Prov, Extra, Bytes>
             }
             // If we get here, we have to check per-byte provenance, and join them together.
             let prov = 'prov: {
+                if !Prov::OFFSET_IS_ADDR {
+                    // FIXME(#146291): We need to ensure that we don't mix different pointers with
+                    // the same provenance.
+                    return Err(AllocError::ReadPartialPointer(range.start));
+                }
                 // Initialize with first fragment. Must have index 0.
                 let Some((mut joint_prov, 0)) = self.provenance.get_byte(range.start, cx) else {
                     break 'prov None;
diff --git a/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs b/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs
index dbbd95408c8ab..720e58d7aa0eb 100644
--- a/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs
+++ b/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs
@@ -11,6 +11,7 @@ use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
 use tracing::trace;
 
 use super::{AllocRange, CtfeProvenance, Provenance, alloc_range};
+use crate::mir::interpret::{AllocError, AllocResult};
 
 /// Stores the provenance information of pointers stored in memory.
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
@@ -137,6 +138,11 @@ impl<Prov: Provenance> ProvenanceMap<Prov> {
         let Some(bytes) = self.bytes.as_deref_mut() else {
             return true;
         };
+        if !Prov::OFFSET_IS_ADDR {
+            // FIXME(#146291): We need to ensure that we don't mix different pointers with
+            // the same provenance.
+            return false;
+        }
         let ptr_size = cx.data_layout().pointer_size();
         while let Some((offset, (prov, _))) = bytes.iter().next().copied() {
             // Check if this fragment starts a pointer.
@@ -285,7 +291,7 @@ impl<Prov: Provenance> ProvenanceMap<Prov> {
         dest: Size,
         count: u64,
         cx: &impl HasDataLayout,
-    ) -> ProvenanceCopy<Prov> {
+    ) -> AllocResult<ProvenanceCopy<Prov>> {
         let shift_offset = move |idx, offset| {
             // compute offset for current repetition
             let dest_offset = dest + src.size * idx; // `Size` operations
@@ -363,6 +369,12 @@ impl<Prov: Provenance> ProvenanceMap<Prov> {
             }
             trace!("byte provenances: {bytes:?}");
 
+            if !bytes.is_empty() && !Prov::OFFSET_IS_ADDR {
+                // FIXME(#146291): We need to ensure that we don't mix different pointers with
+                // the same provenance.
+                return Err(AllocError::ReadPartialPointer(src.start));
+            }
+
             // And again a buffer for the new list on the target side.
             let mut dest_bytes = Vec::with_capacity(bytes.len() * (count as usize));
             for i in 0..count {
@@ -373,7 +385,7 @@ impl<Prov: Provenance> ProvenanceMap<Prov> {
             dest_bytes_box = Some(dest_bytes.into_boxed_slice());
         }
 
-        ProvenanceCopy { dest_ptrs: dest_ptrs_box, dest_bytes: dest_bytes_box }
+        Ok(ProvenanceCopy { dest_ptrs: dest_ptrs_box, dest_bytes: dest_bytes_box })
     }
 
     /// Applies a provenance copy.
diff --git a/library/core/src/ptr/mod.rs b/library/core/src/ptr/mod.rs
index 6b94088cb5679..625024373ef47 100644
--- a/library/core/src/ptr/mod.rs
+++ b/library/core/src/ptr/mod.rs
@@ -1348,6 +1348,40 @@ pub const unsafe fn swap<T>(x: *mut T, y: *mut T) {
 /// assert_eq!(x, [7, 8, 3, 4]);
 /// assert_eq!(y, [1, 2, 9]);
 /// ```
+///
+/// # Const evaluation limitations
+///
+/// If this function is invoked during const-evaluation, the current implementation has a small (and
+/// rarely relevant) limitation: if `count` is at least 2 and the data pointed to by `x` or `y`
+/// contains a pointer that crosses the boundary of two `T`-sized chunks of memory, the function may
+/// fail to evaluate (similar to a panic during const-evaluation). This behavior may change in the
+/// future.
+///
+/// The limitation is illustrated by the following example:
+///
+/// ```
+/// use std::mem::size_of;
+/// use std::ptr;
+///
+/// const { unsafe {
+///     const PTR_SIZE: usize = size_of::<*const i32>();
+///     let mut data1 = [0u8; PTR_SIZE];
+///     let mut data2 = [0u8; PTR_SIZE];
+///     // Store a pointer in `data1`.
+///     data1.as_mut_ptr().cast::<*const i32>().write_unaligned(&42);
+///     // Swap the contents of `data1` and `data2` by swapping `PTR_SIZE` many `u8`-sized chunks.
+///     // This call will fail, because the pointer in `data1` crosses the boundary
+///     // between several of the 1-byte chunks that are being swapped here.
+///     //ptr::swap_nonoverlapping(data1.as_mut_ptr(), data2.as_mut_ptr(), PTR_SIZE);
+///     // Swap the contents of `data1` and `data2` by swapping a single chunk of size
+///     // `[u8; PTR_SIZE]`. That works, as there is no pointer crossing the boundary between
+///     // two chunks.
+///     ptr::swap_nonoverlapping(&mut data1, &mut data2, 1);
+///     // Read the pointer from `data2` and dereference it.
+///     let ptr = data2.as_ptr().cast::<*const i32>().read_unaligned();
+///     assert!(*ptr == 42);
+/// } }
+/// ```
 #[inline]
 #[stable(feature = "swap_nonoverlapping", since = "1.27.0")]
 #[rustc_const_stable(feature = "const_swap_nonoverlapping", since = "1.88.0")]
@@ -1376,7 +1410,9 @@ pub const unsafe fn swap_nonoverlapping<T>(x: *mut T, y: *mut T, count: usize) {
     const_eval_select!(
         @capture[T] { x: *mut T, y: *mut T, count: usize }:
         if const {
-            // At compile-time we don't need all the special code below.
+            // At compile-time we want to always copy this in chunks of `T`, to ensure that if there
+            // are pointers inside `T` we will copy them in one go rather than trying to copy a part
+            // of a pointer (which would not work).
             // SAFETY: Same preconditions as this function
             unsafe { swap_nonoverlapping_const(x, y, count) }
         } else {
diff --git a/library/coretests/tests/ptr.rs b/library/coretests/tests/ptr.rs
index c13fb96a67f92..f8774833d0a54 100644
--- a/library/coretests/tests/ptr.rs
+++ b/library/coretests/tests/ptr.rs
@@ -936,12 +936,13 @@ fn test_const_swap_ptr() {
         assert!(*s1.0.ptr == 666);
         assert!(*s2.0.ptr == 1);
 
-        // Swap them back, byte-for-byte
+        // Swap them back, again as an array.
+        // FIXME(#146291): we should be swapping back at type `u8` but that currently does not work.
         unsafe {
             ptr::swap_nonoverlapping(
-                ptr::from_mut(&mut s1).cast::<u8>(),
-                ptr::from_mut(&mut s2).cast::<u8>(),
-                size_of::<A>(),
+                ptr::from_mut(&mut s1).cast::<T>(),
+                ptr::from_mut(&mut s2).cast::<T>(),
+                1,
             );
         }
 
diff --git a/tests/ui/consts/const-eval/ptr_fragments.rs b/tests/ui/consts/const-eval/ptr_fragments.rs
index 04dcbe55590e9..7dc5870f89e2b 100644
--- a/tests/ui/consts/const-eval/ptr_fragments.rs
+++ b/tests/ui/consts/const-eval/ptr_fragments.rs
@@ -1,5 +1,6 @@
 //! Test that various operations involving pointer fragments work as expected.
 //@ run-pass
+//@ ignore-test: disabled due to <https://github.com/rust-lang/rust/issues/146291>
 
 use std::mem::{self, MaybeUninit, transmute};
 use std::ptr;
diff --git a/tests/ui/consts/const-eval/ptr_fragments_in_final.rs b/tests/ui/consts/const-eval/ptr_fragments_in_final.rs
index e2f3f51b08638..aed33d7ed8d31 100644
--- a/tests/ui/consts/const-eval/ptr_fragments_in_final.rs
+++ b/tests/ui/consts/const-eval/ptr_fragments_in_final.rs
@@ -1,4 +1,5 @@
 //! Test that we properly error when there is a pointer fragment in the final value.
+//@ ignore-test: disabled due to <https://github.com/rust-lang/rust/issues/146291>
 
 use std::{mem::{self, MaybeUninit}, ptr};
 
diff --git a/tests/ui/consts/const-eval/ptr_fragments_mixed.rs b/tests/ui/consts/const-eval/ptr_fragments_mixed.rs
new file mode 100644
index 0000000000000..79a42820f501e
--- /dev/null
+++ b/tests/ui/consts/const-eval/ptr_fragments_mixed.rs
@@ -0,0 +1,28 @@
+//! This mixes fragments from different pointers to the same allocarion, in a way
+//! that we should not accept. See <https://github.com/rust-lang/rust/issues/146291>.
+static A: u8 = 123;
+
+const HALF_PTR: usize = std::mem::size_of::<*const ()>() / 2;
+
+const fn mix_ptr() -> *const u8 {
+    unsafe {
+        let x: *const u8 = &raw const A;
+        let mut y = x.wrapping_add(usize::MAX / 4);
+        core::ptr::copy_nonoverlapping(
+            (&raw const x).cast::<u8>(),
+            (&raw mut y).cast::<u8>(),
+            HALF_PTR,
+        );
+        y
+    }
+}
+
+const APTR: *const u8 = mix_ptr(); //~ERROR: unable to read parts of a pointer
+
+fn main() {
+    let a = APTR;
+    println!("{a:p}");
+    let b = mix_ptr();
+    println!("{b:p}");
+    assert_eq!(a, b);
+}
diff --git a/tests/ui/consts/const-eval/ptr_fragments_mixed.stderr b/tests/ui/consts/const-eval/ptr_fragments_mixed.stderr
new file mode 100644
index 0000000000000..9e991ab7a7d38
--- /dev/null
+++ b/tests/ui/consts/const-eval/ptr_fragments_mixed.stderr
@@ -0,0 +1,23 @@
+error[E0080]: unable to read parts of a pointer from memory at ALLOC0
+  --> $DIR/ptr_fragments_mixed.rs:20:25
+   |
+LL | const APTR: *const u8 = mix_ptr();
+   |                         ^^^^^^^^^ evaluation of `APTR` failed inside this call
+   |
+   = 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
+note: inside `mix_ptr`
+  --> $DIR/ptr_fragments_mixed.rs:11:9
+   |
+LL | /         core::ptr::copy_nonoverlapping(
+LL | |             (&raw const x).cast::<u8>(),
+LL | |             (&raw mut y).cast::<u8>(),
+LL | |             HALF_PTR,
+LL | |         );
+   | |_________^
+note: inside `std::ptr::copy_nonoverlapping::<u8>`
+  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
+
+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/read_partial_ptr.rs b/tests/ui/consts/const-eval/read_partial_ptr.rs
index bccef9c0bc6ca..c153e274e41f6 100644
--- a/tests/ui/consts/const-eval/read_partial_ptr.rs
+++ b/tests/ui/consts/const-eval/read_partial_ptr.rs
@@ -1,4 +1,5 @@
 //! Ensure we error when trying to load from a pointer whose provenance has been messed with.
+//@ ignore-test: disabled due to <https://github.com/rust-lang/rust/issues/146291>
 
 const PARTIAL_OVERWRITE: () = {
     let mut p = &42;

From e4e7e71e3dbc88df948ffede96b8d76c675496e1 Mon Sep 17 00:00:00 2001
From: Alice Ryhl <aliceryhl@google.com>
Date: Tue, 19 Aug 2025 17:26:39 +0000
Subject: [PATCH 0652/1889] Add some error message tests

---
 tests/ui/deref/pin-deref-const.rs     | 79 +++++++++++++++++++++++++
 tests/ui/deref/pin-deref-const.stderr | 51 ++++++++++++++++
 tests/ui/deref/pin-deref.rs           | 76 ++++++++++++++++++++++++
 tests/ui/deref/pin-deref.stderr       | 51 ++++++++++++++++
 tests/ui/deref/pin-impl-deref.rs      | 40 +++++++++++++
 tests/ui/deref/pin-impl-deref.stderr  | 85 +++++++++++++++++++++++++++
 6 files changed, 382 insertions(+)
 create mode 100644 tests/ui/deref/pin-deref-const.rs
 create mode 100644 tests/ui/deref/pin-deref-const.stderr
 create mode 100644 tests/ui/deref/pin-deref.rs
 create mode 100644 tests/ui/deref/pin-deref.stderr
 create mode 100644 tests/ui/deref/pin-impl-deref.rs
 create mode 100644 tests/ui/deref/pin-impl-deref.stderr

diff --git a/tests/ui/deref/pin-deref-const.rs b/tests/ui/deref/pin-deref-const.rs
new file mode 100644
index 0000000000000..6ed00177b2323
--- /dev/null
+++ b/tests/ui/deref/pin-deref-const.rs
@@ -0,0 +1,79 @@
+// The purpose of this file is to track the error messages from Pin and DerefMut interacting.
+//
+// Identical to `pin-deref.rs` except for using unstable `const fn`.
+
+//@ check-fail
+
+#![feature(const_convert)]
+#![feature(const_trait_impl)]
+
+use std::ops::DerefMut;
+use std::pin::Pin;
+
+struct MyUnpinType {}
+
+impl MyUnpinType {
+    const fn at_self(&self) {}
+    const fn at_mut_self(&mut self) {}
+}
+
+struct MyPinType(core::marker::PhantomPinned);
+
+impl MyPinType {
+    const fn at_self(&self) {}
+    const fn at_mut_self(&mut self) {}
+}
+
+const fn call_mut_ref_unpin(mut r_unpin: Pin<&mut MyUnpinType>) {
+    r_unpin.at_self();
+    r_unpin.at_mut_self();
+}
+
+const fn call_ref_unpin(mut r_unpin: Pin<&MyUnpinType>) {
+    r_unpin.at_self();
+    r_unpin.at_mut_self(); //~ ERROR: cannot borrow data in dereference of `Pin<&MyUnpinType>` as mutable
+}
+
+const fn call_mut_ref_pin(mut r_pin: Pin<&mut MyPinType>) {
+    r_pin.at_self();
+    r_pin.at_mut_self(); //~ ERROR: cannot borrow data in dereference of `Pin<&mut MyPinType>` as mutable
+}
+
+const fn call_ref_pin(mut r_pin: Pin<&MyPinType>) {
+    r_pin.at_self();
+    r_pin.at_mut_self(); //~ ERROR: cannot borrow data in dereference of `Pin<&MyPinType>` as mutable
+}
+
+const fn coerce_unpin_rr<'a>(mut r_unpin: &'a mut Pin<&MyUnpinType>) -> &'a MyUnpinType {
+    r_unpin
+}
+
+const fn coerce_unpin_rm<'a>(mut r_unpin: &'a mut Pin<&MyUnpinType>) -> &'a mut MyUnpinType {
+    r_unpin //~ ERROR: cannot borrow data in dereference of `Pin<&MyUnpinType>` as mutable
+}
+
+const fn coerce_unpin_mr<'a>(mut r_unpin: &'a mut Pin<&mut MyUnpinType>) -> &'a MyUnpinType {
+    r_unpin
+}
+
+const fn coerce_unpin_mm<'a>(mut r_unpin: &'a mut Pin<&mut MyUnpinType>) -> &'a mut MyUnpinType {
+    r_unpin
+}
+
+const fn coerce_pin_rr<'a>(mut r_pin: &'a mut Pin<&MyPinType>) -> &'a MyPinType {
+    r_pin
+}
+
+const fn coerce_pin_rm<'a>(mut r_pin: &'a mut Pin<&MyPinType>) -> &'a mut MyPinType {
+    r_pin //~ ERROR: cannot borrow data in dereference of `Pin<&MyPinType>` as mutable
+}
+
+const fn coerce_pin_mr<'a>(mut r_pin: &'a mut Pin<&mut MyPinType>) -> &'a MyPinType {
+    r_pin
+}
+
+const fn coerce_pin_mm<'a>(mut r_pin: &'a mut Pin<&mut MyPinType>) -> &'a mut MyPinType {
+    r_pin //~ ERROR: cannot borrow data in dereference of `Pin<&mut MyPinType>` as mutable
+}
+
+fn main() {}
diff --git a/tests/ui/deref/pin-deref-const.stderr b/tests/ui/deref/pin-deref-const.stderr
new file mode 100644
index 0000000000000..caa270e64ffee
--- /dev/null
+++ b/tests/ui/deref/pin-deref-const.stderr
@@ -0,0 +1,51 @@
+error[E0596]: cannot borrow data in dereference of `Pin<&MyUnpinType>` as mutable
+  --> $DIR/pin-deref-const.rs:34:5
+   |
+LL |     r_unpin.at_mut_self();
+   |     ^^^^^^^ cannot borrow as mutable
+   |
+   = help: trait `DerefMut` is required to modify through a dereference, but it is not implemented for `Pin<&MyUnpinType>`
+
+error[E0596]: cannot borrow data in dereference of `Pin<&mut MyPinType>` as mutable
+  --> $DIR/pin-deref-const.rs:39:5
+   |
+LL |     r_pin.at_mut_self();
+   |     ^^^^^ cannot borrow as mutable
+   |
+   = help: trait `DerefMut` is required to modify through a dereference, but it is not implemented for `Pin<&mut MyPinType>`
+
+error[E0596]: cannot borrow data in dereference of `Pin<&MyPinType>` as mutable
+  --> $DIR/pin-deref-const.rs:44:5
+   |
+LL |     r_pin.at_mut_self();
+   |     ^^^^^ cannot borrow as mutable
+   |
+   = help: trait `DerefMut` is required to modify through a dereference, but it is not implemented for `Pin<&MyPinType>`
+
+error[E0596]: cannot borrow data in dereference of `Pin<&MyUnpinType>` as mutable
+  --> $DIR/pin-deref-const.rs:52:5
+   |
+LL |     r_unpin
+   |     ^^^^^^^ cannot borrow as mutable
+   |
+   = help: trait `DerefMut` is required to modify through a dereference, but it is not implemented for `Pin<&MyUnpinType>`
+
+error[E0596]: cannot borrow data in dereference of `Pin<&MyPinType>` as mutable
+  --> $DIR/pin-deref-const.rs:68:5
+   |
+LL |     r_pin
+   |     ^^^^^ cannot borrow as mutable
+   |
+   = help: trait `DerefMut` is required to modify through a dereference, but it is not implemented for `Pin<&MyPinType>`
+
+error[E0596]: cannot borrow data in dereference of `Pin<&mut MyPinType>` as mutable
+  --> $DIR/pin-deref-const.rs:76:5
+   |
+LL |     r_pin
+   |     ^^^^^ cannot borrow as mutable
+   |
+   = help: trait `DerefMut` is required to modify through a dereference, but it is not implemented for `Pin<&mut MyPinType>`
+
+error: aborting due to 6 previous errors
+
+For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/deref/pin-deref.rs b/tests/ui/deref/pin-deref.rs
new file mode 100644
index 0000000000000..180831c9bc610
--- /dev/null
+++ b/tests/ui/deref/pin-deref.rs
@@ -0,0 +1,76 @@
+// The purpose of this file is to track the error messages from Pin and DerefMut interacting.
+//
+// Identical to `pin-deref-const.rs` except for being stable and not using `const fn`.
+
+//@ check-fail
+
+use std::ops::DerefMut;
+use std::pin::Pin;
+
+struct MyUnpinType {}
+
+impl MyUnpinType {
+    fn at_self(&self) {}
+    fn at_mut_self(&mut self) {}
+}
+
+struct MyPinType(core::marker::PhantomPinned);
+
+impl MyPinType {
+    fn at_self(&self) {}
+    fn at_mut_self(&mut self) {}
+}
+
+fn call_mut_ref_unpin(mut r_unpin: Pin<&mut MyUnpinType>) {
+    r_unpin.at_self();
+    r_unpin.at_mut_self();
+}
+
+fn call_ref_unpin(mut r_unpin: Pin<&MyUnpinType>) {
+    r_unpin.at_self();
+    r_unpin.at_mut_self(); //~ ERROR: cannot borrow data in dereference of `Pin<&MyUnpinType>` as mutable
+}
+
+fn call_mut_ref_pin(mut r_pin: Pin<&mut MyPinType>) {
+    r_pin.at_self();
+    r_pin.at_mut_self(); //~ ERROR: cannot borrow data in dereference of `Pin<&mut MyPinType>` as mutable
+}
+
+fn call_ref_pin(mut r_pin: Pin<&MyPinType>) {
+    r_pin.at_self();
+    r_pin.at_mut_self(); //~ ERROR: cannot borrow data in dereference of `Pin<&MyPinType>` as mutable
+}
+
+fn coerce_unpin_rr<'a>(mut r_unpin: &'a mut Pin<&MyUnpinType>) -> &'a MyUnpinType {
+    r_unpin
+}
+
+fn coerce_unpin_rm<'a>(mut r_unpin: &'a mut Pin<&MyUnpinType>) -> &'a mut MyUnpinType {
+    r_unpin //~ ERROR: cannot borrow data in dereference of `Pin<&MyUnpinType>` as mutable
+}
+
+fn coerce_unpin_mr<'a>(mut r_unpin: &'a mut Pin<&mut MyUnpinType>) -> &'a MyUnpinType {
+    r_unpin
+}
+
+fn coerce_unpin_mm<'a>(mut r_unpin: &'a mut Pin<&mut MyUnpinType>) -> &'a mut MyUnpinType {
+    r_unpin
+}
+
+fn coerce_pin_rr<'a>(mut r_pin: &'a mut Pin<&MyPinType>) -> &'a MyPinType {
+    r_pin
+}
+
+fn coerce_pin_rm<'a>(mut r_pin: &'a mut Pin<&MyPinType>) -> &'a mut MyPinType {
+    r_pin //~ ERROR: cannot borrow data in dereference of `Pin<&MyPinType>` as mutable
+}
+
+fn coerce_pin_mr<'a>(mut r_pin: &'a mut Pin<&mut MyPinType>) -> &'a MyPinType {
+    r_pin
+}
+
+fn coerce_pin_mm<'a>(mut r_pin: &'a mut Pin<&mut MyPinType>) -> &'a mut MyPinType {
+    r_pin //~ ERROR: cannot borrow data in dereference of `Pin<&mut MyPinType>` as mutable
+}
+
+fn main() {}
diff --git a/tests/ui/deref/pin-deref.stderr b/tests/ui/deref/pin-deref.stderr
new file mode 100644
index 0000000000000..71277a10cdfb6
--- /dev/null
+++ b/tests/ui/deref/pin-deref.stderr
@@ -0,0 +1,51 @@
+error[E0596]: cannot borrow data in dereference of `Pin<&MyUnpinType>` as mutable
+  --> $DIR/pin-deref.rs:31:5
+   |
+LL |     r_unpin.at_mut_self();
+   |     ^^^^^^^ cannot borrow as mutable
+   |
+   = help: trait `DerefMut` is required to modify through a dereference, but it is not implemented for `Pin<&MyUnpinType>`
+
+error[E0596]: cannot borrow data in dereference of `Pin<&mut MyPinType>` as mutable
+  --> $DIR/pin-deref.rs:36:5
+   |
+LL |     r_pin.at_mut_self();
+   |     ^^^^^ cannot borrow as mutable
+   |
+   = help: trait `DerefMut` is required to modify through a dereference, but it is not implemented for `Pin<&mut MyPinType>`
+
+error[E0596]: cannot borrow data in dereference of `Pin<&MyPinType>` as mutable
+  --> $DIR/pin-deref.rs:41:5
+   |
+LL |     r_pin.at_mut_self();
+   |     ^^^^^ cannot borrow as mutable
+   |
+   = help: trait `DerefMut` is required to modify through a dereference, but it is not implemented for `Pin<&MyPinType>`
+
+error[E0596]: cannot borrow data in dereference of `Pin<&MyUnpinType>` as mutable
+  --> $DIR/pin-deref.rs:49:5
+   |
+LL |     r_unpin
+   |     ^^^^^^^ cannot borrow as mutable
+   |
+   = help: trait `DerefMut` is required to modify through a dereference, but it is not implemented for `Pin<&MyUnpinType>`
+
+error[E0596]: cannot borrow data in dereference of `Pin<&MyPinType>` as mutable
+  --> $DIR/pin-deref.rs:65:5
+   |
+LL |     r_pin
+   |     ^^^^^ cannot borrow as mutable
+   |
+   = help: trait `DerefMut` is required to modify through a dereference, but it is not implemented for `Pin<&MyPinType>`
+
+error[E0596]: cannot borrow data in dereference of `Pin<&mut MyPinType>` as mutable
+  --> $DIR/pin-deref.rs:73:5
+   |
+LL |     r_pin
+   |     ^^^^^ cannot borrow as mutable
+   |
+   = help: trait `DerefMut` is required to modify through a dereference, but it is not implemented for `Pin<&mut MyPinType>`
+
+error: aborting due to 6 previous errors
+
+For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/deref/pin-impl-deref.rs b/tests/ui/deref/pin-impl-deref.rs
new file mode 100644
index 0000000000000..b1dc8dea3f248
--- /dev/null
+++ b/tests/ui/deref/pin-impl-deref.rs
@@ -0,0 +1,40 @@
+// The purpose of this file is to track the error messages from Pin and DerefMut interacting.
+
+//@ check-fail
+
+use std::ops::DerefMut;
+use std::pin::Pin;
+
+struct MyUnpinType {}
+
+impl MyUnpinType {
+    fn at_self(&self) {}
+    fn at_mut_self(&mut self) {}
+}
+
+struct MyPinType(core::marker::PhantomPinned);
+
+impl MyPinType {
+    fn at_self(&self) {}
+    fn at_mut_self(&mut self) {}
+}
+
+fn impl_deref_mut(_: impl DerefMut) {}
+fn unpin_impl_ref(r_unpin: Pin<&MyUnpinType>) {
+    impl_deref_mut(r_unpin)
+    //~^ ERROR: the trait bound `Pin<&MyUnpinType>: DerefMut` is not satisfied
+}
+fn unpin_impl_mut(r_unpin: Pin<&mut MyUnpinType>) {
+    impl_deref_mut(r_unpin)
+}
+fn pin_impl_ref(r_pin: Pin<&MyPinType>) {
+    impl_deref_mut(r_pin)
+    //~^ ERROR: `PhantomPinned` cannot be unpinned
+    //~| ERROR: the trait bound `Pin<&MyPinType>: DerefMut` is not satisfied
+}
+fn pin_impl_mut(r_pin: Pin<&mut MyPinType>) {
+    impl_deref_mut(r_pin)
+    //~^ ERROR: `PhantomPinned` cannot be unpinned
+}
+
+fn main() {}
diff --git a/tests/ui/deref/pin-impl-deref.stderr b/tests/ui/deref/pin-impl-deref.stderr
new file mode 100644
index 0000000000000..106654641a117
--- /dev/null
+++ b/tests/ui/deref/pin-impl-deref.stderr
@@ -0,0 +1,85 @@
+error[E0277]: the trait bound `Pin<&MyUnpinType>: DerefMut` is not satisfied
+  --> $DIR/pin-impl-deref.rs:24:20
+   |
+LL |     impl_deref_mut(r_unpin)
+   |     -------------- ^^^^^^^ the trait `DerefMut` is not implemented for `Pin<&MyUnpinType>`
+   |     |
+   |     required by a bound introduced by this call
+   |
+   = note: required for `Pin<&MyUnpinType>` to implement `DerefMut`
+note: required by a bound in `impl_deref_mut`
+  --> $DIR/pin-impl-deref.rs:22:27
+   |
+LL | fn impl_deref_mut(_: impl DerefMut) {}
+   |                           ^^^^^^^^ required by this bound in `impl_deref_mut`
+help: consider mutably borrowing here
+   |
+LL |     impl_deref_mut(&mut r_unpin)
+   |                    ++++
+
+error[E0277]: the trait bound `Pin<&MyPinType>: DerefMut` is not satisfied
+  --> $DIR/pin-impl-deref.rs:31:20
+   |
+LL |     impl_deref_mut(r_pin)
+   |     -------------- ^^^^^ the trait `DerefMut` is not implemented for `Pin<&MyPinType>`
+   |     |
+   |     required by a bound introduced by this call
+   |
+   = note: required for `Pin<&MyPinType>` to implement `DerefMut`
+note: required by a bound in `impl_deref_mut`
+  --> $DIR/pin-impl-deref.rs:22:27
+   |
+LL | fn impl_deref_mut(_: impl DerefMut) {}
+   |                           ^^^^^^^^ required by this bound in `impl_deref_mut`
+help: consider mutably borrowing here
+   |
+LL |     impl_deref_mut(&mut r_pin)
+   |                    ++++
+
+error[E0277]: `PhantomPinned` cannot be unpinned
+  --> $DIR/pin-impl-deref.rs:31:20
+   |
+LL |     impl_deref_mut(r_pin)
+   |     -------------- ^^^^^ within `MyPinType`, the trait `Unpin` is not implemented for `PhantomPinned`
+   |     |
+   |     required by a bound introduced by this call
+   |
+   = note: consider using the `pin!` macro
+           consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required because it appears within the type `MyPinType`
+  --> $DIR/pin-impl-deref.rs:15:8
+   |
+LL | struct MyPinType(core::marker::PhantomPinned);
+   |        ^^^^^^^^^
+   = note: required for `Pin<&MyPinType>` to implement `DerefMut`
+note: required by a bound in `impl_deref_mut`
+  --> $DIR/pin-impl-deref.rs:22:27
+   |
+LL | fn impl_deref_mut(_: impl DerefMut) {}
+   |                           ^^^^^^^^ required by this bound in `impl_deref_mut`
+
+error[E0277]: `PhantomPinned` cannot be unpinned
+  --> $DIR/pin-impl-deref.rs:36:20
+   |
+LL |     impl_deref_mut(r_pin)
+   |     -------------- ^^^^^ within `MyPinType`, the trait `Unpin` is not implemented for `PhantomPinned`
+   |     |
+   |     required by a bound introduced by this call
+   |
+   = note: consider using the `pin!` macro
+           consider using `Box::pin` if you need to access the pinned value outside of the current scope
+note: required because it appears within the type `MyPinType`
+  --> $DIR/pin-impl-deref.rs:15:8
+   |
+LL | struct MyPinType(core::marker::PhantomPinned);
+   |        ^^^^^^^^^
+   = note: required for `Pin<&mut MyPinType>` to implement `DerefMut`
+note: required by a bound in `impl_deref_mut`
+  --> $DIR/pin-impl-deref.rs:22:27
+   |
+LL | fn impl_deref_mut(_: impl DerefMut) {}
+   |                           ^^^^^^^^ required by this bound in `impl_deref_mut`
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0277`.

From 94fbb2178ae5960894aaae199233b0d3ac020d79 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sun, 27 Jul 2025 21:21:07 +0200
Subject: [PATCH 0653/1889] implement `va_arg` for arm in rustc itself

---
 compiler/rustc_codegen_llvm/src/va_arg.rs | 15 +++++++++++++
 tests/assembly-llvm/c-variadic-arm.rs     | 26 +++++++++++++++++++++++
 2 files changed, 41 insertions(+)
 create mode 100644 tests/assembly-llvm/c-variadic-arm.rs

diff --git a/compiler/rustc_codegen_llvm/src/va_arg.rs b/compiler/rustc_codegen_llvm/src/va_arg.rs
index 7eb5d30205887..ab08125217ff5 100644
--- a/compiler/rustc_codegen_llvm/src/va_arg.rs
+++ b/compiler/rustc_codegen_llvm/src/va_arg.rs
@@ -908,6 +908,21 @@ pub(super) fn emit_va_arg<'ll, 'tcx>(
             )
         }
         "aarch64" => emit_aapcs_va_arg(bx, addr, target_ty),
+        "arm" => {
+            // Types wider than 16 bytes are not currently supported. Clang has special logic for
+            // such types, but `VaArgSafe` is not implemented for any type that is this large.
+            assert!(bx.cx.size_of(target_ty).bytes() <= 16);
+
+            emit_ptr_va_arg(
+                bx,
+                addr,
+                target_ty,
+                PassMode::Direct,
+                SlotSize::Bytes4,
+                AllowHigherAlign::Yes,
+                ForceRightAdjust::No,
+            )
+        }
         "s390x" => emit_s390x_va_arg(bx, addr, target_ty),
         "powerpc" => emit_powerpc_va_arg(bx, addr, target_ty),
         "powerpc64" | "powerpc64le" => emit_ptr_va_arg(
diff --git a/tests/assembly-llvm/c-variadic-arm.rs b/tests/assembly-llvm/c-variadic-arm.rs
new file mode 100644
index 0000000000000..2ef307405e131
--- /dev/null
+++ b/tests/assembly-llvm/c-variadic-arm.rs
@@ -0,0 +1,26 @@
+//@ assembly-output: emit-asm
+//@ compile-flags: -Copt-level=3
+//@ only-arm
+//@ ignore-thumb
+//@ ignore-android
+#![no_std]
+#![crate_type = "lib"]
+#![feature(c_variadic)]
+
+// Check that the assembly that rustc generates matches what clang emits.
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn variadic(a: f64, mut args: ...) -> f64 {
+    // CHECK-LABEL: variadic
+    // CHECK: sub sp, sp
+
+    // CHECK: vldr
+    // CHECK: vadd.f64
+    // CHECK: vldr
+    // CHECK: vadd.f64
+    let b = args.arg::<f64>();
+    let c = args.arg::<f64>();
+    a + b + c
+
+    // CHECK: add sp, sp
+}

From 78718d55700865328d1abf584956125bec7f5d9d Mon Sep 17 00:00:00 2001
From: Daria Sukhonina <dariasukhonina@gmail.com>
Date: Mon, 8 Sep 2025 14:32:26 +0300
Subject: [PATCH 0654/1889] Skip typeck for items w/o their own typeck context

More details on about this fix:

https://rust-lang.zulipchat.com/#narrow/channel/187679-t-compiler.2Fparallel-rustc/topic/ICE.3A.20typecks.20AnonConst.20under.20parallel.20rustc.28.23141951.29/with/538200980

Co-authored-by: ywxt <ywxtcwh@gmail.com>
---
 compiler/rustc_hir/src/def.rs          | 7 +++++++
 compiler/rustc_hir_analysis/src/lib.rs | 3 ++-
 compiler/rustc_middle/src/ty/util.rs   | 5 +----
 3 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/compiler/rustc_hir/src/def.rs b/compiler/rustc_hir/src/def.rs
index 8af4740f376b6..d563fd0a54728 100644
--- a/compiler/rustc_hir/src/def.rs
+++ b/compiler/rustc_hir/src/def.rs
@@ -440,6 +440,13 @@ impl DefKind {
             | DefKind::ExternCrate => false,
         }
     }
+
+    /// Returns `true` if `self` is a kind of definition that does not have its own
+    /// type-checking context, i.e. closure, coroutine or inline const.
+    #[inline]
+    pub fn is_typeck_child(self) -> bool {
+        matches!(self, DefKind::Closure | DefKind::InlineConst | DefKind::SyntheticCoroutineBody)
+    }
 }
 
 /// The resolution of a path or export.
diff --git a/compiler/rustc_hir_analysis/src/lib.rs b/compiler/rustc_hir_analysis/src/lib.rs
index 2562ab7542a6a..6659aff711107 100644
--- a/compiler/rustc_hir_analysis/src/lib.rs
+++ b/compiler/rustc_hir_analysis/src/lib.rs
@@ -238,7 +238,8 @@ pub fn check_crate(tcx: TyCtxt<'_>) {
             _ => (),
         }
         // Skip `AnonConst`s because we feed their `type_of`.
-        if !matches!(def_kind, DefKind::AnonConst) {
+        // Also skip items for which typeck forwards to parent typeck.
+        if !(matches!(def_kind, DefKind::AnonConst) || def_kind.is_typeck_child()) {
             tcx.ensure_ok().typeck(item_def_id);
         }
         // Ensure we generate the new `DefId` before finishing `check_crate`.
diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs
index a7d07adf78f02..781a13340776a 100644
--- a/compiler/rustc_middle/src/ty/util.rs
+++ b/compiler/rustc_middle/src/ty/util.rs
@@ -609,10 +609,7 @@ impl<'tcx> TyCtxt<'tcx> {
     /// Returns `true` if `def_id` refers to a definition that does not have its own
     /// type-checking context, i.e. closure, coroutine or inline const.
     pub fn is_typeck_child(self, def_id: DefId) -> bool {
-        matches!(
-            self.def_kind(def_id),
-            DefKind::Closure | DefKind::InlineConst | DefKind::SyntheticCoroutineBody
-        )
+        self.def_kind(def_id).is_typeck_child()
     }
 
     /// Returns `true` if `def_id` refers to a trait (i.e., `trait Foo { ... }`).

From f099b241e20d0d9b2fc02fd66a487529bd597d72 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Tue, 26 Aug 2025 14:11:04 +0200
Subject: [PATCH 0655/1889] remove outdated opaque type test

---
 tests/ui/type-alias-impl-trait/fallback.rs    | 29 -------------------
 .../ui/type-alias-impl-trait/fallback.stderr  | 20 -------------
 2 files changed, 49 deletions(-)
 delete mode 100644 tests/ui/type-alias-impl-trait/fallback.rs
 delete mode 100644 tests/ui/type-alias-impl-trait/fallback.stderr

diff --git a/tests/ui/type-alias-impl-trait/fallback.rs b/tests/ui/type-alias-impl-trait/fallback.rs
deleted file mode 100644
index a2f25acca0d3a..0000000000000
--- a/tests/ui/type-alias-impl-trait/fallback.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-// Tests that we correctly handle opaque types being used opaquely,
-// even within their defining scope.
-//
-#![feature(type_alias_impl_trait)]
-
-type Foo = impl Copy;
-
-enum Wrapper<T> {
-    First(T),
-    Second,
-}
-
-// This method constrains `Foo` to be `bool`
-#[define_opaque(Foo)]
-fn constrained_foo() -> Foo {
-    true
-}
-
-// This method does not constrain `Foo`.
-// Per RFC 2071, function bodies may either
-// fully constrain an opaque type, or place no
-// constraints on it.
-#[define_opaque(Foo)]
-fn unconstrained_foo() -> Wrapper<Foo> {
-    Wrapper::Second
-    //~^ ERROR: type annotations needed
-}
-
-fn main() {}
diff --git a/tests/ui/type-alias-impl-trait/fallback.stderr b/tests/ui/type-alias-impl-trait/fallback.stderr
deleted file mode 100644
index 1eb0afb13a8d0..0000000000000
--- a/tests/ui/type-alias-impl-trait/fallback.stderr
+++ /dev/null
@@ -1,20 +0,0 @@
-error[E0283]: type annotations needed
-  --> $DIR/fallback.rs:25:5
-   |
-LL | fn unconstrained_foo() -> Wrapper<Foo> {
-   |                           ------------ type must be known at this point
-LL |     Wrapper::Second
-   |     ^^^^^^^^^^^^^^^
-   |     |
-   |     cannot infer type of the type parameter `T` declared on the enum `Wrapper`
-   |     return type was inferred to be `Wrapper<_>` here
-   |
-   = note: cannot satisfy `_: Copy`
-help: consider specifying the generic argument
-   |
-LL |     Wrapper::<T>::Second
-   |            +++++
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0283`.

From 67965f817d2eb47f5238b43f21b35259806b6280 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Wed, 27 Aug 2025 10:03:47 +0200
Subject: [PATCH 0656/1889] eagerly compute `sub_relations` again

---
 compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs  |   7 --
 compiler/rustc_infer/src/infer/context.rs     |   4 +
 compiler/rustc_infer/src/infer/mod.rs         |   9 ++
 .../src/infer/relate/generalize.rs            |   4 +
 .../src/infer/snapshot/undo_log.rs            |   4 +-
 .../rustc_infer/src/infer/type_variable.rs    | 111 ++++++++++++++++++
 .../src/solve/eval_ctxt/mod.rs                |   4 +
 .../rustc_next_trait_solver/src/solve/mod.rs  |  14 ++-
 .../src/error_reporting/infer/mod.rs          |   1 -
 .../error_reporting/infer/need_type_info.rs   |   2 +-
 .../error_reporting/infer/sub_relations.rs    |  81 -------------
 .../src/error_reporting/mod.rs                |   4 -
 .../src/error_reporting/traits/mod.rs         |   4 -
 .../src/solve/delegate.rs                     |  13 +-
 compiler/rustc_type_ir/src/infer_ctxt.rs      |   1 +
 15 files changed, 152 insertions(+), 111 deletions(-)
 delete mode 100644 compiler/rustc_trait_selection/src/error_reporting/infer/sub_relations.rs

diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs
index 74f27e85cba25..7a060cafeab1c 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs
@@ -21,7 +21,6 @@ use rustc_middle::ty::{self, Const, Ty, TyCtxt, TypeVisitableExt};
 use rustc_session::Session;
 use rustc_span::{self, DUMMY_SP, ErrorGuaranteed, Ident, Span, sym};
 use rustc_trait_selection::error_reporting::TypeErrCtxt;
-use rustc_trait_selection::error_reporting::infer::sub_relations::SubRelations;
 use rustc_trait_selection::traits::{
     self, FulfillmentError, ObligationCause, ObligationCauseCode, ObligationCtxt,
 };
@@ -188,14 +187,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     ///
     /// [`InferCtxtErrorExt::err_ctxt`]: rustc_trait_selection::error_reporting::InferCtxtErrorExt::err_ctxt
     pub(crate) fn err_ctxt(&'a self) -> TypeErrCtxt<'a, 'tcx> {
-        let mut sub_relations = SubRelations::default();
-        sub_relations.add_constraints(
-            self,
-            self.fulfillment_cx.borrow_mut().pending_obligations().iter().map(|o| o.predicate),
-        );
         TypeErrCtxt {
             infcx: &self.infcx,
-            sub_relations: RefCell::new(sub_relations),
             typeck_results: Some(self.typeck_results.borrow()),
             fallback_has_occurred: self.fallback_has_occurred.get(),
             normalize_fn_sig: Box::new(|fn_sig| {
diff --git a/compiler/rustc_infer/src/infer/context.rs b/compiler/rustc_infer/src/infer/context.rs
index 8265fccabc96f..efd623fac7880 100644
--- a/compiler/rustc_infer/src/infer/context.rs
+++ b/compiler/rustc_infer/src/infer/context.rs
@@ -179,6 +179,10 @@ impl<'tcx> rustc_type_ir::InferCtxtLike for InferCtxt<'tcx> {
         self.inner.borrow_mut().type_variables().equate(a, b);
     }
 
+    fn sub_ty_vids_raw(&self, a: ty::TyVid, b: ty::TyVid) {
+        self.sub_ty_vids_raw(a, b);
+    }
+
     fn equate_int_vids_raw(&self, a: ty::IntVid, b: ty::IntVid) {
         self.inner.borrow_mut().int_unification_table().union(a, b);
     }
diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
index d105d24bed778..48dd699cd50cb 100644
--- a/compiler/rustc_infer/src/infer/mod.rs
+++ b/compiler/rustc_infer/src/infer/mod.rs
@@ -764,6 +764,7 @@ impl<'tcx> InferCtxt<'tcx> {
         let r_b = self.shallow_resolve(predicate.skip_binder().b);
         match (r_a.kind(), r_b.kind()) {
             (&ty::Infer(ty::TyVar(a_vid)), &ty::Infer(ty::TyVar(b_vid))) => {
+                self.sub_ty_vids_raw(a_vid, b_vid);
                 return Err((a_vid, b_vid));
             }
             _ => {}
@@ -1128,6 +1129,14 @@ impl<'tcx> InferCtxt<'tcx> {
         self.inner.borrow_mut().type_variables().root_var(var)
     }
 
+    pub fn sub_ty_vids_raw(&self, a: ty::TyVid, b: ty::TyVid) {
+        self.inner.borrow_mut().type_variables().sub(a, b);
+    }
+
+    pub fn sub_root_var(&self, var: ty::TyVid) -> ty::TyVid {
+        self.inner.borrow_mut().type_variables().sub_root_var(var)
+    }
+
     pub fn root_const_var(&self, var: ty::ConstVid) -> ty::ConstVid {
         self.inner.borrow_mut().const_unification_table().find(var).vid
     }
diff --git a/compiler/rustc_infer/src/infer/relate/generalize.rs b/compiler/rustc_infer/src/infer/relate/generalize.rs
index a000bb1123c1c..2323add0b3201 100644
--- a/compiler/rustc_infer/src/infer/relate/generalize.rs
+++ b/compiler/rustc_infer/src/infer/relate/generalize.rs
@@ -519,6 +519,10 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for Generalizer<'_, 'tcx> {
                             let origin = inner.type_variables().var_origin(vid);
                             let new_var_id =
                                 inner.type_variables().new_var(self.for_universe, origin);
+                            // Record that `vid` and `new_var_id` have to be subtypes
+                            // of each other. This is currently only used for diagnostics.
+                            // To see why, see the docs in the `type_variables` module.
+                            inner.type_variables().sub(vid, new_var_id);
                             // If we're in the new solver and create a new inference
                             // variable inside of an alias we eagerly constrain that
                             // inference variable to prevent unexpected ambiguity errors.
diff --git a/compiler/rustc_infer/src/infer/snapshot/undo_log.rs b/compiler/rustc_infer/src/infer/snapshot/undo_log.rs
index fcc0ab3af410c..22c815fb87c62 100644
--- a/compiler/rustc_infer/src/infer/snapshot/undo_log.rs
+++ b/compiler/rustc_infer/src/infer/snapshot/undo_log.rs
@@ -20,7 +20,7 @@ pub struct Snapshot<'tcx> {
 pub(crate) enum UndoLog<'tcx> {
     DuplicateOpaqueType,
     OpaqueTypes(OpaqueTypeKey<'tcx>, Option<OpaqueHiddenType<'tcx>>),
-    TypeVariables(sv::UndoLog<ut::Delegate<type_variable::TyVidEqKey<'tcx>>>),
+    TypeVariables(type_variable::UndoLog<'tcx>),
     ConstUnificationTable(sv::UndoLog<ut::Delegate<ConstVidKey<'tcx>>>),
     IntUnificationTable(sv::UndoLog<ut::Delegate<ty::IntVid>>),
     FloatUnificationTable(sv::UndoLog<ut::Delegate<ty::FloatVid>>),
@@ -49,6 +49,8 @@ impl_from! {
     RegionConstraintCollector(region_constraints::UndoLog<'tcx>),
 
     TypeVariables(sv::UndoLog<ut::Delegate<type_variable::TyVidEqKey<'tcx>>>),
+    TypeVariables(sv::UndoLog<ut::Delegate<type_variable::TyVidSubKey>>),
+    TypeVariables(type_variable::UndoLog<'tcx>),
     IntUnificationTable(sv::UndoLog<ut::Delegate<ty::IntVid>>),
     FloatUnificationTable(sv::UndoLog<ut::Delegate<ty::FloatVid>>),
 
diff --git a/compiler/rustc_infer/src/infer/type_variable.rs b/compiler/rustc_infer/src/infer/type_variable.rs
index 6f6791804d326..613e5a5883a3d 100644
--- a/compiler/rustc_infer/src/infer/type_variable.rs
+++ b/compiler/rustc_infer/src/infer/type_variable.rs
@@ -13,12 +13,48 @@ use tracing::debug;
 
 use crate::infer::InferCtxtUndoLogs;
 
+/// Represents a single undo-able action that affects a type inference variable.
+#[derive(Clone)]
+pub(crate) enum UndoLog<'tcx> {
+    EqRelation(sv::UndoLog<ut::Delegate<TyVidEqKey<'tcx>>>),
+    SubRelation(sv::UndoLog<ut::Delegate<TyVidSubKey>>),
+}
+
+/// Convert from a specific kind of undo to the more general UndoLog
+impl<'tcx> From<sv::UndoLog<ut::Delegate<TyVidEqKey<'tcx>>>> for UndoLog<'tcx> {
+    fn from(l: sv::UndoLog<ut::Delegate<TyVidEqKey<'tcx>>>) -> Self {
+        UndoLog::EqRelation(l)
+    }
+}
+
+/// Convert from a specific kind of undo to the more general UndoLog
+impl<'tcx> From<sv::UndoLog<ut::Delegate<TyVidSubKey>>> for UndoLog<'tcx> {
+    fn from(l: sv::UndoLog<ut::Delegate<TyVidSubKey>>) -> Self {
+        UndoLog::SubRelation(l)
+    }
+}
+
 impl<'tcx> Rollback<sv::UndoLog<ut::Delegate<TyVidEqKey<'tcx>>>> for TypeVariableStorage<'tcx> {
     fn reverse(&mut self, undo: sv::UndoLog<ut::Delegate<TyVidEqKey<'tcx>>>) {
         self.eq_relations.reverse(undo)
     }
 }
 
+impl<'tcx> Rollback<sv::UndoLog<ut::Delegate<TyVidSubKey>>> for TypeVariableStorage<'tcx> {
+    fn reverse(&mut self, undo: sv::UndoLog<ut::Delegate<TyVidSubKey>>) {
+        self.sub_relations.reverse(undo)
+    }
+}
+
+impl<'tcx> Rollback<UndoLog<'tcx>> for TypeVariableStorage<'tcx> {
+    fn reverse(&mut self, undo: UndoLog<'tcx>) {
+        match undo {
+            UndoLog::EqRelation(undo) => self.eq_relations.reverse(undo),
+            UndoLog::SubRelation(undo) => self.sub_relations.reverse(undo),
+        }
+    }
+}
+
 #[derive(Clone, Default)]
 pub(crate) struct TypeVariableStorage<'tcx> {
     /// The origins of each type variable.
@@ -27,6 +63,23 @@ pub(crate) struct TypeVariableStorage<'tcx> {
     /// constraint `?X == ?Y`. This table also stores, for each key,
     /// the known value.
     eq_relations: ut::UnificationTableStorage<TyVidEqKey<'tcx>>,
+    /// Only used by `-Znext-solver` and for diagnostics.
+    ///
+    /// When reporting ambiguity errors, we sometimes want to
+    /// treat all inference vars which are subtypes of each
+    /// others as if they are equal. For this case we compute
+    /// the transitive closure of our subtype obligations here.
+    ///
+    /// E.g. when encountering ambiguity errors, we want to suggest
+    /// specifying some method argument or to add a type annotation
+    /// to a local variable. Because subtyping cannot change the
+    /// shape of a type, it's fine if the cause of the ambiguity error
+    /// is only related to the suggested variable via subtyping.
+    ///
+    /// Even for something like `let x = returns_arg(); x.method();` the
+    /// type of `x` is only a supertype of the argument of `returns_arg`. We
+    /// still want to suggest specifying the type of the argument.
+    sub_relations: ut::UnificationTableStorage<TyVidSubKey>,
 }
 
 pub(crate) struct TypeVariableTable<'a, 'tcx> {
@@ -109,6 +162,16 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
         debug_assert!(self.probe(a).is_unknown());
         debug_assert!(self.probe(b).is_unknown());
         self.eq_relations().union(a, b);
+        self.sub_relations().union(a, b);
+    }
+
+    /// Records that `a <: b`, depending on `dir`.
+    ///
+    /// Precondition: neither `a` nor `b` are known.
+    pub(crate) fn sub(&mut self, a: ty::TyVid, b: ty::TyVid) {
+        debug_assert!(self.probe(a).is_unknown());
+        debug_assert!(self.probe(b).is_unknown());
+        self.sub_relations().union(a, b);
     }
 
     /// Instantiates `vid` with the type `ty`.
@@ -142,6 +205,10 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
         origin: TypeVariableOrigin,
     ) -> ty::TyVid {
         let eq_key = self.eq_relations().new_key(TypeVariableValue::Unknown { universe });
+
+        let sub_key = self.sub_relations().new_key(());
+        debug_assert_eq!(eq_key.vid, sub_key.vid);
+
         let index = self.storage.values.push(TypeVariableData { origin });
         debug_assert_eq!(eq_key.vid, index);
 
@@ -164,6 +231,18 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
         self.eq_relations().find(vid).vid
     }
 
+    /// Returns the "root" variable of `vid` in the `sub_relations`
+    /// equivalence table. All type variables that have been are
+    /// related via equality or subtyping will yield the same root
+    /// variable (per the union-find algorithm), so `sub_root_var(a)
+    /// == sub_root_var(b)` implies that:
+    /// ```text
+    /// exists X. (a <: X || X <: a) && (b <: X || X <: b)
+    /// ```
+    pub(crate) fn sub_root_var(&mut self, vid: ty::TyVid) -> ty::TyVid {
+        self.sub_relations().find(vid).vid
+    }
+
     /// Retrieves the type to which `vid` has been instantiated, if
     /// any.
     pub(crate) fn probe(&mut self, vid: ty::TyVid) -> TypeVariableValue<'tcx> {
@@ -181,6 +260,11 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
         self.storage.eq_relations.with_log(self.undo_log)
     }
 
+    #[inline]
+    fn sub_relations(&mut self) -> super::UnificationTable<'_, 'tcx, TyVidSubKey> {
+        self.storage.sub_relations.with_log(self.undo_log)
+    }
+
     /// Returns a range of the type variables created during the snapshot.
     pub(crate) fn vars_since_snapshot(
         &mut self,
@@ -243,6 +327,33 @@ impl<'tcx> ut::UnifyKey for TyVidEqKey<'tcx> {
     }
 }
 
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub(crate) struct TyVidSubKey {
+    vid: ty::TyVid,
+}
+
+impl From<ty::TyVid> for TyVidSubKey {
+    #[inline] // make this function eligible for inlining - it is quite hot.
+    fn from(vid: ty::TyVid) -> Self {
+        TyVidSubKey { vid }
+    }
+}
+
+impl ut::UnifyKey for TyVidSubKey {
+    type Value = ();
+    #[inline]
+    fn index(&self) -> u32 {
+        self.vid.as_u32()
+    }
+    #[inline]
+    fn from_index(i: u32) -> TyVidSubKey {
+        TyVidSubKey { vid: ty::TyVid::from_u32(i) }
+    }
+    fn tag() -> &'static str {
+        "TyVidSubKey"
+    }
+}
+
 impl<'tcx> ut::UnifyValue for TypeVariableValue<'tcx> {
     type Error = ut::NoError;
 
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
index 443aebbdb4d69..f0f95e53265cc 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
@@ -900,6 +900,10 @@ where
             && goal.param_env.visit_with(&mut visitor).is_continue()
     }
 
+    pub(super) fn sub_ty_vids_raw(&self, a: ty::TyVid, b: ty::TyVid) {
+        self.delegate.sub_ty_vids_raw(a, b)
+    }
+
     #[instrument(level = "trace", skip(self, param_env), ret)]
     pub(super) fn eq<T: Relate<I>>(
         &mut self,
diff --git a/compiler/rustc_next_trait_solver/src/solve/mod.rs b/compiler/rustc_next_trait_solver/src/solve/mod.rs
index 85f9d852d9593..a2db21796a205 100644
--- a/compiler/rustc_next_trait_solver/src/solve/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/mod.rs
@@ -119,11 +119,15 @@ where
 
     #[instrument(level = "trace", skip(self))]
     fn compute_subtype_goal(&mut self, goal: Goal<I, ty::SubtypePredicate<I>>) -> QueryResult<I> {
-        if goal.predicate.a.is_ty_var() && goal.predicate.b.is_ty_var() {
-            self.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS)
-        } else {
-            self.sub(goal.param_env, goal.predicate.a, goal.predicate.b)?;
-            self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
+        match (goal.predicate.a.kind(), goal.predicate.b.kind()) {
+            (ty::Infer(ty::TyVar(a_vid)), ty::Infer(ty::TyVar(b_vid))) => {
+                self.sub_ty_vids_raw(a_vid, b_vid);
+                self.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS)
+            }
+            _ => {
+                self.sub(goal.param_env, goal.predicate.a, goal.predicate.b)?;
+                self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
+            }
         }
     }
 
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 812e20e433822..d3a17232a40d7 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
@@ -91,7 +91,6 @@ mod suggest;
 pub mod need_type_info;
 pub mod nice_region_error;
 pub mod region;
-pub mod sub_relations;
 
 /// Makes a valid string literal from a string by escaping special characters (" and \),
 /// unless they are already escaped.
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 ec2287ed5161d..dff1311070ce6 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
@@ -894,7 +894,7 @@ impl<'a, 'tcx> FindInferSourceVisitor<'a, 'tcx> {
                 use ty::{Infer, TyVar};
                 match (inner_ty.kind(), target_ty.kind()) {
                     (&Infer(TyVar(a_vid)), &Infer(TyVar(b_vid))) => {
-                        self.tecx.sub_relations.borrow_mut().unified(self.tecx, a_vid, b_vid)
+                        self.tecx.sub_root_var(a_vid) == self.tecx.sub_root_var(b_vid)
                     }
                     _ => false,
                 }
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/sub_relations.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/sub_relations.rs
deleted file mode 100644
index ef26a8ff7b863..0000000000000
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/sub_relations.rs
+++ /dev/null
@@ -1,81 +0,0 @@
-use rustc_data_structures::fx::FxHashMap;
-use rustc_data_structures::undo_log::NoUndo;
-use rustc_data_structures::unify as ut;
-use rustc_middle::ty;
-
-use crate::infer::InferCtxt;
-
-#[derive(Debug, Copy, Clone, PartialEq)]
-struct SubId(u32);
-impl ut::UnifyKey for SubId {
-    type Value = ();
-    #[inline]
-    fn index(&self) -> u32 {
-        self.0
-    }
-    #[inline]
-    fn from_index(i: u32) -> SubId {
-        SubId(i)
-    }
-    fn tag() -> &'static str {
-        "SubId"
-    }
-}
-
-/// When reporting ambiguity errors, we sometimes want to
-/// treat all inference vars which are subtypes of each
-/// others as if they are equal. For this case we compute
-/// the transitive closure of our subtype obligations here.
-///
-/// E.g. when encountering ambiguity errors, we want to suggest
-/// specifying some method argument or to add a type annotation
-/// to a local variable. Because subtyping cannot change the
-/// shape of a type, it's fine if the cause of the ambiguity error
-/// is only related to the suggested variable via subtyping.
-///
-/// Even for something like `let x = returns_arg(); x.method();` the
-/// type of `x` is only a supertype of the argument of `returns_arg`. We
-/// still want to suggest specifying the type of the argument.
-#[derive(Default)]
-pub struct SubRelations {
-    map: FxHashMap<ty::TyVid, SubId>,
-    table: ut::UnificationTableStorage<SubId>,
-}
-
-impl SubRelations {
-    fn get_id<'tcx>(&mut self, infcx: &InferCtxt<'tcx>, vid: ty::TyVid) -> SubId {
-        let root_vid = infcx.root_var(vid);
-        *self.map.entry(root_vid).or_insert_with(|| self.table.with_log(&mut NoUndo).new_key(()))
-    }
-
-    pub fn add_constraints<'tcx>(
-        &mut self,
-        infcx: &InferCtxt<'tcx>,
-        obls: impl IntoIterator<Item = ty::Predicate<'tcx>>,
-    ) {
-        for p in obls {
-            let (a, b) = match p.kind().skip_binder() {
-                ty::PredicateKind::Subtype(ty::SubtypePredicate { a_is_expected: _, a, b }) => {
-                    (a, b)
-                }
-                ty::PredicateKind::Coerce(ty::CoercePredicate { a, b }) => (a, b),
-                _ => continue,
-            };
-
-            match (a.kind(), b.kind()) {
-                (&ty::Infer(ty::TyVar(a_vid)), &ty::Infer(ty::TyVar(b_vid))) => {
-                    let a = self.get_id(infcx, a_vid);
-                    let b = self.get_id(infcx, b_vid);
-                    self.table.with_log(&mut NoUndo).unify_var_var(a, b).unwrap();
-                }
-                _ => continue,
-            }
-        }
-    }
-
-    pub fn unified<'tcx>(&mut self, infcx: &InferCtxt<'tcx>, a: ty::TyVid, b: ty::TyVid) -> bool {
-        let a = self.get_id(infcx, a);
-        let b = self.get_id(infcx, b);
-        self.table.with_log(&mut NoUndo).unioned(a, b)
-    }
-}
diff --git a/compiler/rustc_trait_selection/src/error_reporting/mod.rs b/compiler/rustc_trait_selection/src/error_reporting/mod.rs
index 82695688ae897..cce20b05c79aa 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/mod.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/mod.rs
@@ -7,8 +7,6 @@ use rustc_macros::extension;
 use rustc_middle::bug;
 use rustc_middle::ty::{self, Ty};
 
-use crate::error_reporting::infer::sub_relations;
-
 pub mod infer;
 pub mod traits;
 
@@ -21,7 +19,6 @@ pub mod traits;
 /// methods which should not be used during the happy path.
 pub struct TypeErrCtxt<'a, 'tcx> {
     pub infcx: &'a InferCtxt<'tcx>,
-    pub sub_relations: std::cell::RefCell<sub_relations::SubRelations>,
 
     pub typeck_results: Option<std::cell::Ref<'a, ty::TypeckResults<'tcx>>>,
     pub fallback_has_occurred: bool,
@@ -38,7 +35,6 @@ impl<'tcx> InferCtxt<'tcx> {
     fn err_ctxt(&self) -> TypeErrCtxt<'_, 'tcx> {
         TypeErrCtxt {
             infcx: self,
-            sub_relations: Default::default(),
             typeck_results: None,
             fallback_has_occurred: false,
             normalize_fn_sig: Box::new(|fn_sig| fn_sig),
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/mod.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/mod.rs
index c8500b2d9d4ab..f794ff632c592 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/mod.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/mod.rs
@@ -139,10 +139,6 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         &self,
         mut errors: Vec<FulfillmentError<'tcx>>,
     ) -> ErrorGuaranteed {
-        self.sub_relations
-            .borrow_mut()
-            .add_constraints(self, errors.iter().map(|e| e.obligation.predicate));
-
         #[derive(Debug)]
         struct ErrorDescriptor<'tcx> {
             goal: Goal<'tcx, ty::Predicate<'tcx>>,
diff --git a/compiler/rustc_trait_selection/src/solve/delegate.rs b/compiler/rustc_trait_selection/src/solve/delegate.rs
index e6a2761db5a91..448fc025be665 100644
--- a/compiler/rustc_trait_selection/src/solve/delegate.rs
+++ b/compiler/rustc_trait_selection/src/solve/delegate.rs
@@ -126,13 +126,12 @@ impl<'tcx> rustc_next_trait_solver::delegate::SolverDelegate for SolverDelegate<
             }
             ty::PredicateKind::Subtype(ty::SubtypePredicate { a, b, .. })
             | ty::PredicateKind::Coerce(ty::CoercePredicate { a, b }) => {
-                if self.shallow_resolve(a).is_ty_var() && self.shallow_resolve(b).is_ty_var() {
-                    // FIXME: We also need to register a subtype relation between these vars
-                    // when those are added, and if they aren't in the same sub root then
-                    // we should mark this goal as `has_changed`.
-                    Some(Certainty::AMBIGUOUS)
-                } else {
-                    None
+                match (self.shallow_resolve(a).kind(), self.shallow_resolve(b).kind()) {
+                    (&ty::Infer(ty::TyVar(a_vid)), &ty::Infer(ty::TyVar(b_vid))) => {
+                        self.sub_ty_vids_raw(a_vid, b_vid);
+                        Some(Certainty::AMBIGUOUS)
+                    }
+                    _ => None,
                 }
             }
             ty::PredicateKind::Clause(ty::ClauseKind::ConstArgHasType(ct, _)) => {
diff --git a/compiler/rustc_type_ir/src/infer_ctxt.rs b/compiler/rustc_type_ir/src/infer_ctxt.rs
index b4462294700ac..3fac50ff9ccfc 100644
--- a/compiler/rustc_type_ir/src/infer_ctxt.rs
+++ b/compiler/rustc_type_ir/src/infer_ctxt.rs
@@ -197,6 +197,7 @@ pub trait InferCtxtLike: Sized {
     ) -> U;
 
     fn equate_ty_vids_raw(&self, a: ty::TyVid, b: ty::TyVid);
+    fn sub_ty_vids_raw(&self, a: ty::TyVid, b: ty::TyVid);
     fn equate_int_vids_raw(&self, a: ty::IntVid, b: ty::IntVid);
     fn equate_float_vids_raw(&self, a: ty::FloatVid, b: ty::FloatVid);
     fn equate_const_vids_raw(&self, a: ty::ConstVid, b: ty::ConstVid);

From 2cb04b960fb8ae7f29401cd982bdb829b6c54a03 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Mon, 28 Apr 2025 17:21:36 +0000
Subject: [PATCH 0657/1889] inline `CanonicalTyVarKind`

---
 .../src/infer/canonical/canonicalizer.rs      | 17 ++---
 .../rustc_infer/src/infer/canonical/mod.rs    | 13 +---
 compiler/rustc_middle/src/infer/canonical.rs  |  1 -
 .../src/canonicalizer.rs                      | 21 +++---
 compiler/rustc_type_ir/src/canonical.rs       | 71 ++++++++-----------
 ..._of_reborrow.SimplifyCfg-initial.after.mir | 18 ++---
 6 files changed, 58 insertions(+), 83 deletions(-)

diff --git a/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs b/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
index 3ad14dc79d519..40d3e8acaa44b 100644
--- a/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
+++ b/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
@@ -17,7 +17,7 @@ use tracing::debug;
 
 use crate::infer::InferCtxt;
 use crate::infer::canonical::{
-    Canonical, CanonicalQueryInput, CanonicalTyVarKind, CanonicalVarKind, OriginalQueryValues,
+    Canonical, CanonicalQueryInput, CanonicalVarKind, OriginalQueryValues,
 };
 
 impl<'tcx> InferCtxt<'tcx> {
@@ -361,10 +361,7 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
                             // FIXME: perf problem described in #55921.
                             ui = ty::UniverseIndex::ROOT;
                         }
-                        self.canonicalize_ty_var(
-                            CanonicalVarKind::Ty(CanonicalTyVarKind::General(ui)),
-                            t,
-                        )
+                        self.canonicalize_ty_var(CanonicalVarKind::Ty(ui), t)
                     }
                 }
             }
@@ -374,7 +371,7 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
                 if nt != t {
                     return self.fold_ty(nt);
                 } else {
-                    self.canonicalize_ty_var(CanonicalVarKind::Ty(CanonicalTyVarKind::Int), t)
+                    self.canonicalize_ty_var(CanonicalVarKind::Int, t)
                 }
             }
             ty::Infer(ty::FloatVar(vid)) => {
@@ -382,7 +379,7 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
                 if nt != t {
                     return self.fold_ty(nt);
                 } else {
-                    self.canonicalize_ty_var(CanonicalVarKind::Ty(CanonicalTyVarKind::Float), t)
+                    self.canonicalize_ty_var(CanonicalVarKind::Float, t)
                 }
             }
 
@@ -679,12 +676,10 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
         self.variables
             .iter()
             .map(|&kind| match kind {
-                CanonicalVarKind::Ty(CanonicalTyVarKind::Int | CanonicalTyVarKind::Float) => {
+                CanonicalVarKind::Int | CanonicalVarKind::Float => {
                     return kind;
                 }
-                CanonicalVarKind::Ty(CanonicalTyVarKind::General(u)) => {
-                    CanonicalVarKind::Ty(CanonicalTyVarKind::General(reverse_universe_map[&u]))
-                }
+                CanonicalVarKind::Ty(u) => CanonicalVarKind::Ty(reverse_universe_map[&u]),
                 CanonicalVarKind::Region(u) => CanonicalVarKind::Region(reverse_universe_map[&u]),
                 CanonicalVarKind::Const(u) => CanonicalVarKind::Const(reverse_universe_map[&u]),
                 CanonicalVarKind::PlaceholderTy(placeholder) => {
diff --git a/compiler/rustc_infer/src/infer/canonical/mod.rs b/compiler/rustc_infer/src/infer/canonical/mod.rs
index 79a2aa54ef834..223fb8419ecc9 100644
--- a/compiler/rustc_infer/src/infer/canonical/mod.rs
+++ b/compiler/rustc_infer/src/infer/canonical/mod.rs
@@ -108,18 +108,11 @@ impl<'tcx> InferCtxt<'tcx> {
         universe_map: impl Fn(ty::UniverseIndex) -> ty::UniverseIndex,
     ) -> GenericArg<'tcx> {
         match kind {
-            CanonicalVarKind::Ty(ty_kind) => {
-                let ty = match ty_kind {
-                    CanonicalTyVarKind::General(ui) => {
-                        self.next_ty_var_in_universe(span, universe_map(ui))
-                    }
+            CanonicalVarKind::Ty(ui) => self.next_ty_var_in_universe(span, universe_map(ui)).into(),
 
-                    CanonicalTyVarKind::Int => self.next_int_var(),
+            CanonicalVarKind::Int => self.next_int_var().into(),
 
-                    CanonicalTyVarKind::Float => self.next_float_var(),
-                };
-                ty.into()
-            }
+            CanonicalVarKind::Float => self.next_float_var().into(),
 
             CanonicalVarKind::PlaceholderTy(ty::PlaceholderType { universe, bound }) => {
                 let universe_mapped = universe_map(universe);
diff --git a/compiler/rustc_middle/src/infer/canonical.rs b/compiler/rustc_middle/src/infer/canonical.rs
index 4fe4c2dadee11..153605ee7f814 100644
--- a/compiler/rustc_middle/src/infer/canonical.rs
+++ b/compiler/rustc_middle/src/infer/canonical.rs
@@ -27,7 +27,6 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::sync::Lock;
 use rustc_macros::{HashStable, TypeFoldable, TypeVisitable};
 pub use rustc_type_ir as ir;
-pub use rustc_type_ir::CanonicalTyVarKind;
 use smallvec::SmallVec;
 
 use crate::mir::ConstraintCategory;
diff --git a/compiler/rustc_next_trait_solver/src/canonicalizer.rs b/compiler/rustc_next_trait_solver/src/canonicalizer.rs
index da05c49756ff9..7a8ee09650e71 100644
--- a/compiler/rustc_next_trait_solver/src/canonicalizer.rs
+++ b/compiler/rustc_next_trait_solver/src/canonicalizer.rs
@@ -2,9 +2,8 @@ use rustc_type_ir::data_structures::{HashMap, ensure_sufficient_stack};
 use rustc_type_ir::inherent::*;
 use rustc_type_ir::solve::{Goal, QueryInput};
 use rustc_type_ir::{
-    self as ty, Canonical, CanonicalParamEnvCacheEntry, CanonicalTyVarKind, CanonicalVarKind,
-    Flags, InferCtxtLike, Interner, TypeFlags, TypeFoldable, TypeFolder, TypeSuperFoldable,
-    TypeVisitableExt,
+    self as ty, Canonical, CanonicalParamEnvCacheEntry, CanonicalVarKind, Flags, InferCtxtLike,
+    Interner, TypeFlags, TypeFoldable, TypeFolder, TypeSuperFoldable, TypeVisitableExt,
 };
 
 use crate::delegate::SolverDelegate;
@@ -314,14 +313,12 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
                     );
 
                     match self.canonicalize_mode {
-                        CanonicalizeMode::Input { .. } => CanonicalVarKind::Ty(
-                            CanonicalTyVarKind::General(ty::UniverseIndex::ROOT),
-                        ),
+                        CanonicalizeMode::Input { .. } => {
+                            CanonicalVarKind::Ty(ty::UniverseIndex::ROOT)
+                        }
                         CanonicalizeMode::Response { .. } => {
-                            CanonicalVarKind::Ty(CanonicalTyVarKind::General(
-                                self.delegate.universe_of_ty(vid).unwrap_or_else(|| {
-                                    panic!("ty var should have been resolved: {t:?}")
-                                }),
+                            CanonicalVarKind::Ty(self.delegate.universe_of_ty(vid).unwrap_or_else(
+                                || panic!("ty var should have been resolved: {t:?}"),
                             ))
                         }
                     }
@@ -332,7 +329,7 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
                         t,
                         "ty vid should have been resolved fully before canonicalization"
                     );
-                    CanonicalVarKind::Ty(CanonicalTyVarKind::Int)
+                    CanonicalVarKind::Int
                 }
                 ty::FloatVar(vid) => {
                     debug_assert_eq!(
@@ -340,7 +337,7 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
                         t,
                         "ty vid should have been resolved fully before canonicalization"
                     );
-                    CanonicalVarKind::Ty(CanonicalTyVarKind::Float)
+                    CanonicalVarKind::Float
                 }
                 ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_) => {
                     panic!("fresh vars not expected in canonicalization")
diff --git a/compiler/rustc_type_ir/src/canonical.rs b/compiler/rustc_type_ir/src/canonical.rs
index de2a9186e7c94..cd509ed3f72f7 100644
--- a/compiler/rustc_type_ir/src/canonical.rs
+++ b/compiler/rustc_type_ir/src/canonical.rs
@@ -1,5 +1,4 @@
 use std::fmt;
-use std::hash::Hash;
 use std::ops::Index;
 
 use derive_where::derive_where;
@@ -91,8 +90,14 @@ impl<I: Interner, V: fmt::Display> fmt::Display for Canonical<I, V> {
     derive(Decodable_NoContext, Encodable_NoContext, HashStable_NoContext)
 )]
 pub enum CanonicalVarKind<I: Interner> {
-    /// Some kind of type inference variable.
-    Ty(CanonicalTyVarKind),
+    /// General type variable `?T` that can be unified with arbitrary types.
+    Ty(UniverseIndex),
+
+    /// Integral type variable `?I` (that can only be unified with integral types).
+    Int,
+
+    /// Floating-point type variable `?F` (that can only be unified with float types).
+    Float,
 
     /// A "placeholder" that represents "any type".
     PlaceholderTy(I::PlaceholderTy),
@@ -117,15 +122,13 @@ impl<I: Interner> Eq for CanonicalVarKind<I> {}
 impl<I: Interner> CanonicalVarKind<I> {
     pub fn universe(self) -> UniverseIndex {
         match self {
-            CanonicalVarKind::Ty(CanonicalTyVarKind::General(ui)) => ui,
+            CanonicalVarKind::Ty(ui) => ui,
             CanonicalVarKind::Region(ui) => ui,
             CanonicalVarKind::Const(ui) => ui,
             CanonicalVarKind::PlaceholderTy(placeholder) => placeholder.universe(),
             CanonicalVarKind::PlaceholderRegion(placeholder) => placeholder.universe(),
             CanonicalVarKind::PlaceholderConst(placeholder) => placeholder.universe(),
-            CanonicalVarKind::Ty(CanonicalTyVarKind::Float | CanonicalTyVarKind::Int) => {
-                UniverseIndex::ROOT
-            }
+            CanonicalVarKind::Float | CanonicalVarKind::Int => UniverseIndex::ROOT,
         }
     }
 
@@ -135,9 +138,7 @@ impl<I: Interner> CanonicalVarKind<I> {
     /// the updated universe is not the root.
     pub fn with_updated_universe(self, ui: UniverseIndex) -> CanonicalVarKind<I> {
         match self {
-            CanonicalVarKind::Ty(CanonicalTyVarKind::General(_)) => {
-                CanonicalVarKind::Ty(CanonicalTyVarKind::General(ui))
-            }
+            CanonicalVarKind::Ty(_) => CanonicalVarKind::Ty(ui),
             CanonicalVarKind::Region(_) => CanonicalVarKind::Region(ui),
             CanonicalVarKind::Const(_) => CanonicalVarKind::Const(ui),
 
@@ -150,7 +151,7 @@ impl<I: Interner> CanonicalVarKind<I> {
             CanonicalVarKind::PlaceholderConst(placeholder) => {
                 CanonicalVarKind::PlaceholderConst(placeholder.with_updated_universe(ui))
             }
-            CanonicalVarKind::Ty(CanonicalTyVarKind::Int | CanonicalTyVarKind::Float) => {
+            CanonicalVarKind::Int | CanonicalVarKind::Float => {
                 assert_eq!(ui, UniverseIndex::ROOT);
                 self
             }
@@ -159,12 +160,14 @@ impl<I: Interner> CanonicalVarKind<I> {
 
     pub fn is_existential(self) -> bool {
         match self {
-            CanonicalVarKind::Ty(_) => true,
-            CanonicalVarKind::PlaceholderTy(_) => false,
-            CanonicalVarKind::Region(_) => true,
-            CanonicalVarKind::PlaceholderRegion(..) => false,
-            CanonicalVarKind::Const(_) => true,
-            CanonicalVarKind::PlaceholderConst(_) => false,
+            CanonicalVarKind::Ty(_)
+            | CanonicalVarKind::Int
+            | CanonicalVarKind::Float
+            | CanonicalVarKind::Region(_)
+            | CanonicalVarKind::Const(_) => true,
+            CanonicalVarKind::PlaceholderTy(_)
+            | CanonicalVarKind::PlaceholderRegion(..)
+            | CanonicalVarKind::PlaceholderConst(_) => false,
         }
     }
 
@@ -172,6 +175,8 @@ impl<I: Interner> CanonicalVarKind<I> {
         match self {
             CanonicalVarKind::Region(_) | CanonicalVarKind::PlaceholderRegion(_) => true,
             CanonicalVarKind::Ty(_)
+            | CanonicalVarKind::Int
+            | CanonicalVarKind::Float
             | CanonicalVarKind::PlaceholderTy(_)
             | CanonicalVarKind::Const(_)
             | CanonicalVarKind::PlaceholderConst(_) => false,
@@ -180,7 +185,11 @@ impl<I: Interner> CanonicalVarKind<I> {
 
     pub fn expect_placeholder_index(self) -> usize {
         match self {
-            CanonicalVarKind::Ty(_) | CanonicalVarKind::Region(_) | CanonicalVarKind::Const(_) => {
+            CanonicalVarKind::Ty(_)
+            | CanonicalVarKind::Int
+            | CanonicalVarKind::Float
+            | CanonicalVarKind::Region(_)
+            | CanonicalVarKind::Const(_) => {
                 panic!("expected placeholder: {self:?}")
             }
 
@@ -191,27 +200,6 @@ impl<I: Interner> CanonicalVarKind<I> {
     }
 }
 
-/// Rust actually has more than one category of type variables;
-/// notably, the type variables we create for literals (e.g., 22 or
-/// 22.) can only be instantiated with integral/float types (e.g.,
-/// usize or f32). In order to faithfully reproduce a type, we need to
-/// know what set of types a given type variable can be unified with.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(
-    feature = "nightly",
-    derive(Decodable_NoContext, Encodable_NoContext, HashStable_NoContext)
-)]
-pub enum CanonicalTyVarKind {
-    /// General type variable `?T` that can be unified with arbitrary types.
-    General(UniverseIndex),
-
-    /// Integral type variable `?I` (that can only be unified with integral types).
-    Int,
-
-    /// Floating-point type variable `?F` (that can only be unified with float types).
-    Float,
-}
-
 /// A set of values corresponding to the canonical variables from some
 /// `Canonical`. You can give these values to
 /// `canonical_value.instantiate` to instantiate them into the canonical
@@ -287,7 +275,10 @@ impl<I: Interner> CanonicalVarValues<I> {
             var_values: cx.mk_args_from_iter(infos.iter().enumerate().map(
                 |(i, kind)| -> I::GenericArg {
                     match kind {
-                        CanonicalVarKind::Ty(_) | CanonicalVarKind::PlaceholderTy(_) => {
+                        CanonicalVarKind::Ty(_)
+                        | CanonicalVarKind::Int
+                        | CanonicalVarKind::Float
+                        | CanonicalVarKind::PlaceholderTy(_) => {
                             Ty::new_anon_bound(cx, ty::INNERMOST, ty::BoundVar::from_usize(i))
                                 .into()
                         }
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 8afb6ad250e03..906e5828aba82 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
@@ -1,30 +1,30 @@
 // MIR for `address_of_reborrow` after SimplifyCfg-initial
 
 | User Type Annotations
-| 0: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty(General(U0))] }, span: $DIR/address_of.rs:8:10: 8:18, inferred_ty: *const [i32; 10]
+| 0: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty(U0)] }, span: $DIR/address_of.rs:8:10: 8:18, inferred_ty: *const [i32; 10]
 | 1: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:10:10: 10:25, inferred_ty: *const dyn std::marker::Send
-| 2: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty(General(U0))] }, span: $DIR/address_of.rs:14:12: 14:20, inferred_ty: *const [i32; 10]
-| 3: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty(General(U0))] }, span: $DIR/address_of.rs:14:12: 14:20, inferred_ty: *const [i32; 10]
+| 2: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty(U0)] }, span: $DIR/address_of.rs:14:12: 14:20, inferred_ty: *const [i32; 10]
+| 3: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty(U0)] }, span: $DIR/address_of.rs:14:12: 14:20, inferred_ty: *const [i32; 10]
 | 4: user_ty: Canonical { value: Ty(*const [i32; 10]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:15:12: 15:28, inferred_ty: *const [i32; 10]
 | 5: user_ty: Canonical { value: Ty(*const [i32; 10]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:15:12: 15:28, inferred_ty: *const [i32; 10]
 | 6: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:16:12: 16:27, inferred_ty: *const dyn std::marker::Send
 | 7: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:16:12: 16:27, inferred_ty: *const dyn std::marker::Send
 | 8: user_ty: Canonical { value: Ty(*const [i32]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:17:12: 17:24, inferred_ty: *const [i32]
 | 9: user_ty: Canonical { value: Ty(*const [i32]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:17:12: 17:24, inferred_ty: *const [i32]
-| 10: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty(General(U0))] }, span: $DIR/address_of.rs:19:10: 19:18, inferred_ty: *const [i32; 10]
+| 10: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty(U0)] }, span: $DIR/address_of.rs:19:10: 19:18, inferred_ty: *const [i32; 10]
 | 11: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:21:10: 21:25, inferred_ty: *const dyn std::marker::Send
-| 12: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty(General(U0))] }, span: $DIR/address_of.rs:24:12: 24:20, inferred_ty: *const [i32; 10]
-| 13: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty(General(U0))] }, span: $DIR/address_of.rs:24:12: 24:20, inferred_ty: *const [i32; 10]
+| 12: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty(U0)] }, span: $DIR/address_of.rs:24:12: 24:20, inferred_ty: *const [i32; 10]
+| 13: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty(U0)] }, span: $DIR/address_of.rs:24:12: 24:20, inferred_ty: *const [i32; 10]
 | 14: user_ty: Canonical { value: Ty(*const [i32; 10]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:25:12: 25:28, inferred_ty: *const [i32; 10]
 | 15: user_ty: Canonical { value: Ty(*const [i32; 10]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:25:12: 25:28, inferred_ty: *const [i32; 10]
 | 16: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:26:12: 26:27, inferred_ty: *const dyn std::marker::Send
 | 17: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:26:12: 26:27, inferred_ty: *const dyn std::marker::Send
 | 18: user_ty: Canonical { value: Ty(*const [i32]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:27:12: 27:24, inferred_ty: *const [i32]
 | 19: user_ty: Canonical { value: Ty(*const [i32]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:27:12: 27:24, inferred_ty: *const [i32]
-| 20: user_ty: Canonical { value: Ty(*mut ^0), max_universe: U0, variables: [Ty(General(U0))] }, span: $DIR/address_of.rs:29:10: 29:16, inferred_ty: *mut [i32; 10]
+| 20: user_ty: Canonical { value: Ty(*mut ^0), max_universe: U0, variables: [Ty(U0)] }, span: $DIR/address_of.rs:29:10: 29:16, inferred_ty: *mut [i32; 10]
 | 21: user_ty: Canonical { value: Ty(*mut dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:31:10: 31:23, inferred_ty: *mut dyn std::marker::Send
-| 22: user_ty: Canonical { value: Ty(*mut ^0), max_universe: U0, variables: [Ty(General(U0))] }, span: $DIR/address_of.rs:34:12: 34:18, inferred_ty: *mut [i32; 10]
-| 23: user_ty: Canonical { value: Ty(*mut ^0), max_universe: U0, variables: [Ty(General(U0))] }, span: $DIR/address_of.rs:34:12: 34:18, inferred_ty: *mut [i32; 10]
+| 22: user_ty: Canonical { value: Ty(*mut ^0), max_universe: U0, variables: [Ty(U0)] }, span: $DIR/address_of.rs:34:12: 34:18, inferred_ty: *mut [i32; 10]
+| 23: user_ty: Canonical { value: Ty(*mut ^0), max_universe: U0, variables: [Ty(U0)] }, span: $DIR/address_of.rs:34:12: 34:18, inferred_ty: *mut [i32; 10]
 | 24: user_ty: Canonical { value: Ty(*mut [i32; 10]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:35:12: 35:26, inferred_ty: *mut [i32; 10]
 | 25: user_ty: Canonical { value: Ty(*mut [i32; 10]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:35:12: 35:26, inferred_ty: *mut [i32; 10]
 | 26: user_ty: Canonical { value: Ty(*mut dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:36:12: 36:25, inferred_ty: *mut dyn std::marker::Send

From 28a0e77d1318210540fa1a561b9a8af08e2ffe40 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Tue, 26 Aug 2025 15:23:57 +0200
Subject: [PATCH 0658/1889] pass `sub_relations` into canonical queries

---
 .../src/infer/canonical/canonicalizer.rs      |  17 +-
 .../rustc_infer/src/infer/canonical/mod.rs    |  25 +-
 .../src/infer/canonical/query_response.rs     |  73 ++--
 compiler/rustc_infer/src/infer/context.rs     |   4 +
 .../src/canonicalizer.rs                      |  33 +-
 .../rustc_next_trait_solver/src/delegate.rs   |   4 +-
 .../src/solve/eval_ctxt/canonical.rs          |  71 ++--
 .../rustc_next_trait_solver/src/solve/mod.rs  |   5 +
 .../src/solve/delegate.rs                     |   5 +-
 compiler/rustc_type_ir/src/canonical.rs       |  18 +-
 compiler/rustc_type_ir/src/infer_ctxt.rs      |   1 +
 ..._of_reborrow.SimplifyCfg-initial.after.mir |  18 +-
 .../multiline-removal-suggestion.svg          | 364 ++++++++----------
 .../recursive-in-exhaustiveness.next.stderr   |  22 +-
 14 files changed, 342 insertions(+), 318 deletions(-)

diff --git a/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs b/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
index 40d3e8acaa44b..be68609502a8a 100644
--- a/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
+++ b/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
@@ -6,6 +6,7 @@
 //! [c]: https://rust-lang.github.io/chalk/book/canonical_queries/canonicalization.html
 
 use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::sso::SsoHashMap;
 use rustc_index::Idx;
 use rustc_middle::bug;
 use rustc_middle::ty::{
@@ -293,6 +294,7 @@ struct Canonicalizer<'cx, 'tcx> {
     // Note that indices is only used once `var_values` is big enough to be
     // heap-allocated.
     indices: FxHashMap<GenericArg<'tcx>, BoundVar>,
+    sub_root_lookup_table: SsoHashMap<ty::TyVid, usize>,
     canonicalize_mode: &'cx dyn CanonicalizeMode,
     needs_canonical_flags: TypeFlags,
 
@@ -361,7 +363,8 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
                             // FIXME: perf problem described in #55921.
                             ui = ty::UniverseIndex::ROOT;
                         }
-                        self.canonicalize_ty_var(CanonicalVarKind::Ty(ui), t)
+                        let sub_root = self.get_or_insert_sub_root(vid);
+                        self.canonicalize_ty_var(CanonicalVarKind::Ty { ui, sub_root }, t)
                     }
                 }
             }
@@ -559,6 +562,7 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
             variables: SmallVec::from_slice(base.variables),
             query_state,
             indices: FxHashMap::default(),
+            sub_root_lookup_table: Default::default(),
             binder_index: ty::INNERMOST,
         };
         if canonicalizer.query_state.var_values.spilled() {
@@ -657,6 +661,13 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
         }
     }
 
+    fn get_or_insert_sub_root(&mut self, vid: ty::TyVid) -> ty::BoundVar {
+        let root_vid = self.infcx.unwrap().sub_root_var(vid);
+        let idx =
+            *self.sub_root_lookup_table.entry(root_vid).or_insert_with(|| self.variables.len());
+        ty::BoundVar::from(idx)
+    }
+
     /// Replaces the universe indexes used in `var_values` with their index in
     /// `query_state.universe_map`. This minimizes the maximum universe used in
     /// the canonicalized value.
@@ -679,7 +690,9 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
                 CanonicalVarKind::Int | CanonicalVarKind::Float => {
                     return kind;
                 }
-                CanonicalVarKind::Ty(u) => CanonicalVarKind::Ty(reverse_universe_map[&u]),
+                CanonicalVarKind::Ty { ui, sub_root } => {
+                    CanonicalVarKind::Ty { ui: reverse_universe_map[&ui], sub_root }
+                }
                 CanonicalVarKind::Region(u) => CanonicalVarKind::Region(reverse_universe_map[&u]),
                 CanonicalVarKind::Const(u) => CanonicalVarKind::Const(reverse_universe_map[&u]),
                 CanonicalVarKind::PlaceholderTy(placeholder) => {
diff --git a/compiler/rustc_infer/src/infer/canonical/mod.rs b/compiler/rustc_infer/src/infer/canonical/mod.rs
index 223fb8419ecc9..4e1ea52af4c93 100644
--- a/compiler/rustc_infer/src/infer/canonical/mod.rs
+++ b/compiler/rustc_infer/src/infer/canonical/mod.rs
@@ -84,13 +84,12 @@ impl<'tcx> InferCtxt<'tcx> {
         variables: &List<CanonicalVarKind<'tcx>>,
         universe_map: impl Fn(ty::UniverseIndex) -> ty::UniverseIndex,
     ) -> CanonicalVarValues<'tcx> {
-        CanonicalVarValues {
-            var_values: self.tcx.mk_args_from_iter(
-                variables
-                    .iter()
-                    .map(|kind| self.instantiate_canonical_var(span, kind, &universe_map)),
-            ),
+        let mut var_values = Vec::with_capacity(variables.len());
+        for info in variables.iter() {
+            let value = self.instantiate_canonical_var(span, info, &var_values, &universe_map);
+            var_values.push(value);
         }
+        CanonicalVarValues { var_values: self.tcx.mk_args(&var_values) }
     }
 
     /// Given the "info" about a canonical variable, creates a fresh
@@ -105,10 +104,22 @@ impl<'tcx> InferCtxt<'tcx> {
         &self,
         span: Span,
         kind: CanonicalVarKind<'tcx>,
+        previous_var_values: &[GenericArg<'tcx>],
         universe_map: impl Fn(ty::UniverseIndex) -> ty::UniverseIndex,
     ) -> GenericArg<'tcx> {
         match kind {
-            CanonicalVarKind::Ty(ui) => self.next_ty_var_in_universe(span, universe_map(ui)).into(),
+            CanonicalVarKind::Ty { ui, sub_root } => {
+                let vid = self.next_ty_vid_in_universe(span, universe_map(ui));
+                // Fetch the `sub_root` in case it exists.
+                if let Some(prev) = previous_var_values.get(sub_root.as_usize()) {
+                    if let &ty::Infer(ty::TyVar(sub_root)) = prev.expect_ty().kind() {
+                        self.inner.borrow_mut().type_variables().sub(vid, sub_root);
+                    } else {
+                        unreachable!()
+                    }
+                }
+                Ty::new_var(self.tcx, vid).into()
+            }
 
             CanonicalVarKind::Int => self.next_int_var().into(),
 
diff --git a/compiler/rustc_infer/src/infer/canonical/query_response.rs b/compiler/rustc_infer/src/infer/canonical/query_response.rs
index 09578598114b4..22c9c4edccc43 100644
--- a/compiler/rustc_infer/src/infer/canonical/query_response.rs
+++ b/compiler/rustc_infer/src/infer/canonical/query_response.rs
@@ -13,6 +13,7 @@ use std::iter;
 use rustc_index::{Idx, IndexVec};
 use rustc_middle::arena::ArenaAllocatable;
 use rustc_middle::bug;
+use rustc_middle::infer::canonical::CanonicalVarKind;
 use rustc_middle::ty::{self, BoundVar, GenericArg, GenericArgKind, Ty, TyCtxt, TypeFoldable};
 use tracing::{debug, instrument};
 
@@ -413,26 +414,27 @@ impl<'tcx> InferCtxt<'tcx> {
         let mut opt_values: IndexVec<BoundVar, Option<GenericArg<'tcx>>> =
             IndexVec::from_elem_n(None, query_response.variables.len());
 
-        // In terms of our example above, we are iterating over pairs like:
-        // [(?A, Vec<?0>), ('static, '?1), (?B, ?0)]
         for (original_value, result_value) in iter::zip(&original_values.var_values, result_values)
         {
             match result_value.kind() {
                 GenericArgKind::Type(result_value) => {
-                    // e.g., here `result_value` might be `?0` in the example above...
-                    if let ty::Bound(debruijn, b) = *result_value.kind() {
-                        // ...in which case we would set `canonical_vars[0]` to `Some(?U)`.
-
+                    // We disable the instantiation guess for inference variables
+                    // and only use it for placeholders. We need to handle the
+                    // `sub_root` of type inference variables which would make this
+                    // more involved. They are also a lot rarer than region variables.
+                    if let ty::Bound(debruijn, b) = *result_value.kind()
+                        && !matches!(
+                            query_response.variables[b.var.as_usize()],
+                            CanonicalVarKind::Ty { .. }
+                        )
+                    {
                         // We only allow a `ty::INNERMOST` index in generic parameters.
                         assert_eq!(debruijn, ty::INNERMOST);
                         opt_values[b.var] = Some(*original_value);
                     }
                 }
                 GenericArgKind::Lifetime(result_value) => {
-                    // e.g., here `result_value` might be `'?1` in the example above...
                     if let ty::ReBound(debruijn, b) = result_value.kind() {
-                        // ... in which case we would set `canonical_vars[0]` to `Some('static)`.
-
                         // We only allow a `ty::INNERMOST` index in generic parameters.
                         assert_eq!(debruijn, ty::INNERMOST);
                         opt_values[b.var] = Some(*original_value);
@@ -440,8 +442,6 @@ impl<'tcx> InferCtxt<'tcx> {
                 }
                 GenericArgKind::Const(result_value) => {
                     if let ty::ConstKind::Bound(debruijn, b) = result_value.kind() {
-                        // ...in which case we would set `canonical_vars[0]` to `Some(const X)`.
-
                         // We only allow a `ty::INNERMOST` index in generic parameters.
                         assert_eq!(debruijn, ty::INNERMOST);
                         opt_values[b.var] = Some(*original_value);
@@ -453,32 +453,31 @@ impl<'tcx> InferCtxt<'tcx> {
         // Create result arguments: if we found a value for a
         // given variable in the loop above, use that. Otherwise, use
         // a fresh inference variable.
-        let result_args = CanonicalVarValues {
-            var_values: self.tcx.mk_args_from_iter(
-                query_response.variables.iter().enumerate().map(|(index, var_kind)| {
-                    if var_kind.universe() != ty::UniverseIndex::ROOT {
-                        // A variable from inside a binder of the query. While ideally these shouldn't
-                        // exist at all, we have to deal with them for now.
-                        self.instantiate_canonical_var(cause.span, var_kind, |u| {
-                            universe_map[u.as_usize()]
-                        })
-                    } else if var_kind.is_existential() {
-                        match opt_values[BoundVar::new(index)] {
-                            Some(k) => k,
-                            None => self.instantiate_canonical_var(cause.span, var_kind, |u| {
-                                universe_map[u.as_usize()]
-                            }),
-                        }
-                    } else {
-                        // For placeholders which were already part of the input, we simply map this
-                        // universal bound variable back the placeholder of the input.
-                        opt_values[BoundVar::new(index)].expect(
-                            "expected placeholder to be unified with itself during response",
-                        )
-                    }
-                }),
-            ),
-        };
+        let mut var_values = Vec::with_capacity(query_response.variables.len());
+        for (index, kind) in query_response.variables.iter().enumerate() {
+            let value = if kind.universe() != ty::UniverseIndex::ROOT {
+                // A variable from inside a binder of the query. While ideally these shouldn't
+                // exist at all, we have to deal with them for now.
+                self.instantiate_canonical_var(cause.span, kind, &var_values, |u| {
+                    universe_map[u.as_usize()]
+                })
+            } else if kind.is_existential() {
+                match opt_values[BoundVar::new(index)] {
+                    Some(k) => k,
+                    None => self.instantiate_canonical_var(cause.span, kind, &var_values, |u| {
+                        universe_map[u.as_usize()]
+                    }),
+                }
+            } else {
+                // For placeholders which were already part of the input, we simply map this
+                // universal bound variable back the placeholder of the input.
+                opt_values[BoundVar::new(index)]
+                    .expect("expected placeholder to be unified with itself during response")
+            };
+            var_values.push(value);
+        }
+
+        let result_args = CanonicalVarValues { var_values: self.tcx.mk_args(&var_values) };
 
         let mut obligations = PredicateObligations::new();
 
diff --git a/compiler/rustc_infer/src/infer/context.rs b/compiler/rustc_infer/src/infer/context.rs
index efd623fac7880..b76931caaa579 100644
--- a/compiler/rustc_infer/src/infer/context.rs
+++ b/compiler/rustc_infer/src/infer/context.rs
@@ -59,6 +59,10 @@ impl<'tcx> rustc_type_ir::InferCtxtLike for InferCtxt<'tcx> {
         self.root_var(var)
     }
 
+    fn sub_root_ty_var(&self, var: ty::TyVid) -> ty::TyVid {
+        self.sub_root_var(var)
+    }
+
     fn root_const_var(&self, var: ty::ConstVid) -> ty::ConstVid {
         self.root_const_var(var)
     }
diff --git a/compiler/rustc_next_trait_solver/src/canonicalizer.rs b/compiler/rustc_next_trait_solver/src/canonicalizer.rs
index 7a8ee09650e71..d42c62439f6eb 100644
--- a/compiler/rustc_next_trait_solver/src/canonicalizer.rs
+++ b/compiler/rustc_next_trait_solver/src/canonicalizer.rs
@@ -67,6 +67,7 @@ pub struct Canonicalizer<'a, D: SolverDelegate<Interner = I>, I: Interner> {
     variables: &'a mut Vec<I::GenericArg>,
     var_kinds: Vec<CanonicalVarKind<I>>,
     variable_lookup_table: HashMap<I::GenericArg, usize>,
+    sub_root_lookup_table: HashMap<ty::TyVid, usize>,
     binder_index: ty::DebruijnIndex,
 
     /// We only use the debruijn index during lookup. We don't need to
@@ -88,6 +89,7 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
 
             variables,
             variable_lookup_table: Default::default(),
+            sub_root_lookup_table: Default::default(),
             var_kinds: Vec::new(),
             binder_index: ty::INNERMOST,
 
@@ -132,6 +134,7 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
 
                         variables: &mut variables,
                         variable_lookup_table: Default::default(),
+                        sub_root_lookup_table: Default::default(),
                         var_kinds: Vec::new(),
                         binder_index: ty::INNERMOST,
 
@@ -139,6 +142,7 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
                     };
                     let param_env = param_env.fold_with(&mut env_canonicalizer);
                     debug_assert_eq!(env_canonicalizer.binder_index, ty::INNERMOST);
+                    debug_assert!(env_canonicalizer.sub_root_lookup_table.is_empty());
                     CanonicalParamEnvCacheEntry {
                         param_env,
                         variable_lookup_table: env_canonicalizer.variable_lookup_table,
@@ -164,6 +168,7 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
 
                 variables,
                 variable_lookup_table: Default::default(),
+                sub_root_lookup_table: Default::default(),
                 var_kinds: Vec::new(),
                 binder_index: ty::INNERMOST,
 
@@ -171,6 +176,7 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
             };
             let param_env = param_env.fold_with(&mut env_canonicalizer);
             debug_assert_eq!(env_canonicalizer.binder_index, ty::INNERMOST);
+            debug_assert!(env_canonicalizer.sub_root_lookup_table.is_empty());
             (param_env, env_canonicalizer.variable_lookup_table, env_canonicalizer.var_kinds)
         }
     }
@@ -199,6 +205,7 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
 
             variables,
             variable_lookup_table,
+            sub_root_lookup_table: Default::default(),
             var_kinds,
             binder_index: ty::INNERMOST,
 
@@ -265,6 +272,13 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
         ty::BoundVar::from(idx)
     }
 
+    fn get_or_insert_sub_root(&mut self, vid: ty::TyVid) -> ty::BoundVar {
+        let root_vid = self.delegate.sub_root_ty_var(vid);
+        let idx =
+            *self.sub_root_lookup_table.entry(root_vid).or_insert_with(|| self.variables.len());
+        ty::BoundVar::from(idx)
+    }
+
     fn finalize(self) -> (ty::UniverseIndex, I::CanonicalVarKinds) {
         let mut var_kinds = self.var_kinds;
         // See the rustc-dev-guide section about how we deal with universes
@@ -312,16 +326,15 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
                         "ty vid should have been resolved fully before canonicalization"
                     );
 
-                    match self.canonicalize_mode {
-                        CanonicalizeMode::Input { .. } => {
-                            CanonicalVarKind::Ty(ty::UniverseIndex::ROOT)
-                        }
-                        CanonicalizeMode::Response { .. } => {
-                            CanonicalVarKind::Ty(self.delegate.universe_of_ty(vid).unwrap_or_else(
-                                || panic!("ty var should have been resolved: {t:?}"),
-                            ))
-                        }
-                    }
+                    let sub_root = self.get_or_insert_sub_root(vid);
+                    let ui = match self.canonicalize_mode {
+                        CanonicalizeMode::Input { .. } => ty::UniverseIndex::ROOT,
+                        CanonicalizeMode::Response { .. } => self
+                            .delegate
+                            .universe_of_ty(vid)
+                            .unwrap_or_else(|| panic!("ty var should have been resolved: {t:?}")),
+                    };
+                    CanonicalVarKind::Ty { ui, sub_root }
                 }
                 ty::IntVar(vid) => {
                     debug_assert_eq!(
diff --git a/compiler/rustc_next_trait_solver/src/delegate.rs b/compiler/rustc_next_trait_solver/src/delegate.rs
index 7b932010d498a..4460e9ad2f1f9 100644
--- a/compiler/rustc_next_trait_solver/src/delegate.rs
+++ b/compiler/rustc_next_trait_solver/src/delegate.rs
@@ -57,12 +57,14 @@ pub trait SolverDelegate: Deref<Target = Self::Infcx> + Sized {
     where
         V: TypeFoldable<Self::Interner>;
 
-    fn instantiate_canonical_var_with_infer(
+    fn instantiate_canonical_var(
         &self,
         kind: ty::CanonicalVarKind<Self::Interner>,
         span: <Self::Interner as Interner>::Span,
+        var_values: &[<Self::Interner as Interner>::GenericArg],
         universe_map: impl Fn(ty::UniverseIndex) -> ty::UniverseIndex,
     ) -> <Self::Interner as Interner>::GenericArg;
+
     fn add_item_bounds_for_hidden_type(
         &self,
         def_id: <Self::Interner as Interner>::DefId,
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs
index 6f9f40673847c..8d7a55c55be96 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs
@@ -16,7 +16,8 @@ use rustc_type_ir::data_structures::HashSet;
 use rustc_type_ir::inherent::*;
 use rustc_type_ir::relate::solver_relating::RelateExt;
 use rustc_type_ir::{
-    self as ty, Canonical, CanonicalVarValues, InferCtxtLike, Interner, TypeFoldable,
+    self as ty, Canonical, CanonicalVarKind, CanonicalVarValues, InferCtxtLike, Interner,
+    TypeFoldable,
 };
 use tracing::{debug, instrument, trace};
 
@@ -336,7 +337,16 @@ where
         {
             match result_value.kind() {
                 ty::GenericArgKind::Type(t) => {
-                    if let ty::Bound(debruijn, b) = t.kind() {
+                    // We disable the instantiation guess for inference variables
+                    // and only use it for placeholders. We need to handle the
+                    // `sub_root` of type inference variables which would make this
+                    // more involved. They are also a lot rarer than region variables.
+                    if let ty::Bound(debruijn, b) = t.kind()
+                        && !matches!(
+                            response.variables.get(b.var().as_usize()).unwrap(),
+                            CanonicalVarKind::Ty { .. }
+                        )
+                    {
                         assert_eq!(debruijn, ty::INNERMOST);
                         opt_values[b.var()] = Some(*original_value);
                     }
@@ -356,38 +366,37 @@ where
             }
         }
 
-        let var_values = delegate.cx().mk_args_from_iter(
-            response.variables.iter().enumerate().map(|(index, var_kind)| {
-                if var_kind.universe() != ty::UniverseIndex::ROOT {
-                    // A variable from inside a binder of the query. While ideally these shouldn't
-                    // exist at all (see the FIXME at the start of this method), we have to deal with
-                    // them for now.
-                    delegate.instantiate_canonical_var_with_infer(var_kind, span, |idx| {
-                        prev_universe + idx.index()
-                    })
-                } else if var_kind.is_existential() {
-                    // As an optimization we sometimes avoid creating a new inference variable here.
-                    //
-                    // All new inference variables we create start out in the current universe of the caller.
-                    // This is conceptually wrong as these inference variables would be able to name
-                    // more placeholders then they should be able to. However the inference variables have
-                    // to "come from somewhere", so by equating them with the original values of the caller
-                    // later on, we pull them down into their correct universe again.
-                    if let Some(v) = opt_values[ty::BoundVar::from_usize(index)] {
-                        v
-                    } else {
-                        delegate
-                            .instantiate_canonical_var_with_infer(var_kind, span, |_| prev_universe)
-                    }
+        let mut var_values = Vec::with_capacity(response.variables.len());
+        for (index, kind) in response.variables.iter().enumerate() {
+            let value = if kind.universe() != ty::UniverseIndex::ROOT {
+                // A variable from inside a binder of the query. While ideally these shouldn't
+                // exist at all (see the FIXME at the start of this method), we have to deal with
+                // them for now.
+                delegate.instantiate_canonical_var(kind, span, &var_values, |idx| {
+                    prev_universe + idx.index()
+                })
+            } else if kind.is_existential() {
+                // As an optimization we sometimes avoid creating a new inference variable here.
+                //
+                // All new inference variables we create start out in the current universe of the caller.
+                // This is conceptually wrong as these inference variables would be able to name
+                // more placeholders then they should be able to. However the inference variables have
+                // to "come from somewhere", so by equating them with the original values of the caller
+                // later on, we pull them down into their correct universe again.
+                if let Some(v) = opt_values[ty::BoundVar::from_usize(index)] {
+                    v
                 } else {
-                    // For placeholders which were already part of the input, we simply map this
-                    // universal bound variable back the placeholder of the input.
-                    original_values[var_kind.expect_placeholder_index()]
+                    delegate.instantiate_canonical_var(kind, span, &var_values, |_| prev_universe)
                 }
-            }),
-        );
+            } else {
+                // For placeholders which were already part of the input, we simply map this
+                // universal bound variable back the placeholder of the input.
+                original_values[kind.expect_placeholder_index()]
+            };
+            var_values.push(value)
+        }
 
-        CanonicalVarValues { var_values }
+        CanonicalVarValues { var_values: delegate.cx().mk_args(&var_values) }
     }
 
     /// Unify the `original_values` with the `var_values` returned by the canonical query..
diff --git a/compiler/rustc_next_trait_solver/src/solve/mod.rs b/compiler/rustc_next_trait_solver/src/solve/mod.rs
index a2db21796a205..91b83e6cbbeb5 100644
--- a/compiler/rustc_next_trait_solver/src/solve/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/mod.rs
@@ -418,6 +418,11 @@ pub struct GoalEvaluation<I: Interner> {
     pub has_changed: HasChanged,
     /// If the [`Certainty`] was `Maybe`, then keep track of whether the goal has changed
     /// before rerunning it.
+    ///
+    /// We knowingly ignore the `sub_root` of our inference variables here. This means we
+    /// may not reevaluate a goal even though a change to the `sub_root` could cause a goal
+    /// to make progress. Tracking them adds additional complexity for an incredibly minor
+    /// type inference improvement. We could look into properly handling this in the future.
     pub stalled_on: Option<GoalStalledOn<I>>,
 }
 
diff --git a/compiler/rustc_trait_selection/src/solve/delegate.rs b/compiler/rustc_trait_selection/src/solve/delegate.rs
index 448fc025be665..44230624ddba4 100644
--- a/compiler/rustc_trait_selection/src/solve/delegate.rs
+++ b/compiler/rustc_trait_selection/src/solve/delegate.rs
@@ -237,13 +237,14 @@ impl<'tcx> rustc_next_trait_solver::delegate::SolverDelegate for SolverDelegate<
         canonical.instantiate(self.tcx, &values)
     }
 
-    fn instantiate_canonical_var_with_infer(
+    fn instantiate_canonical_var(
         &self,
         kind: CanonicalVarKind<'tcx>,
         span: Span,
+        var_values: &[ty::GenericArg<'tcx>],
         universe_map: impl Fn(ty::UniverseIndex) -> ty::UniverseIndex,
     ) -> ty::GenericArg<'tcx> {
-        self.0.instantiate_canonical_var(span, kind, universe_map)
+        self.0.instantiate_canonical_var(span, kind, var_values, universe_map)
     }
 
     fn add_item_bounds_for_hidden_type(
diff --git a/compiler/rustc_type_ir/src/canonical.rs b/compiler/rustc_type_ir/src/canonical.rs
index cd509ed3f72f7..04bf90080358d 100644
--- a/compiler/rustc_type_ir/src/canonical.rs
+++ b/compiler/rustc_type_ir/src/canonical.rs
@@ -91,7 +91,11 @@ impl<I: Interner, V: fmt::Display> fmt::Display for Canonical<I, V> {
 )]
 pub enum CanonicalVarKind<I: Interner> {
     /// General type variable `?T` that can be unified with arbitrary types.
-    Ty(UniverseIndex),
+    ///
+    /// We also store the index of the first type variable which is sub-unified
+    /// with this one. If there is no inference variable related to this one,
+    /// its `sub_root` just points to itself.
+    Ty { ui: UniverseIndex, sub_root: ty::BoundVar },
 
     /// Integral type variable `?I` (that can only be unified with integral types).
     Int,
@@ -122,7 +126,7 @@ impl<I: Interner> Eq for CanonicalVarKind<I> {}
 impl<I: Interner> CanonicalVarKind<I> {
     pub fn universe(self) -> UniverseIndex {
         match self {
-            CanonicalVarKind::Ty(ui) => ui,
+            CanonicalVarKind::Ty { ui, sub_root: _ } => ui,
             CanonicalVarKind::Region(ui) => ui,
             CanonicalVarKind::Const(ui) => ui,
             CanonicalVarKind::PlaceholderTy(placeholder) => placeholder.universe(),
@@ -138,7 +142,7 @@ impl<I: Interner> CanonicalVarKind<I> {
     /// the updated universe is not the root.
     pub fn with_updated_universe(self, ui: UniverseIndex) -> CanonicalVarKind<I> {
         match self {
-            CanonicalVarKind::Ty(_) => CanonicalVarKind::Ty(ui),
+            CanonicalVarKind::Ty { ui: _, sub_root } => CanonicalVarKind::Ty { ui, sub_root },
             CanonicalVarKind::Region(_) => CanonicalVarKind::Region(ui),
             CanonicalVarKind::Const(_) => CanonicalVarKind::Const(ui),
 
@@ -160,7 +164,7 @@ impl<I: Interner> CanonicalVarKind<I> {
 
     pub fn is_existential(self) -> bool {
         match self {
-            CanonicalVarKind::Ty(_)
+            CanonicalVarKind::Ty { .. }
             | CanonicalVarKind::Int
             | CanonicalVarKind::Float
             | CanonicalVarKind::Region(_)
@@ -174,7 +178,7 @@ impl<I: Interner> CanonicalVarKind<I> {
     pub fn is_region(self) -> bool {
         match self {
             CanonicalVarKind::Region(_) | CanonicalVarKind::PlaceholderRegion(_) => true,
-            CanonicalVarKind::Ty(_)
+            CanonicalVarKind::Ty { .. }
             | CanonicalVarKind::Int
             | CanonicalVarKind::Float
             | CanonicalVarKind::PlaceholderTy(_)
@@ -185,7 +189,7 @@ impl<I: Interner> CanonicalVarKind<I> {
 
     pub fn expect_placeholder_index(self) -> usize {
         match self {
-            CanonicalVarKind::Ty(_)
+            CanonicalVarKind::Ty { .. }
             | CanonicalVarKind::Int
             | CanonicalVarKind::Float
             | CanonicalVarKind::Region(_)
@@ -275,7 +279,7 @@ impl<I: Interner> CanonicalVarValues<I> {
             var_values: cx.mk_args_from_iter(infos.iter().enumerate().map(
                 |(i, kind)| -> I::GenericArg {
                     match kind {
-                        CanonicalVarKind::Ty(_)
+                        CanonicalVarKind::Ty { .. }
                         | CanonicalVarKind::Int
                         | CanonicalVarKind::Float
                         | CanonicalVarKind::PlaceholderTy(_) => {
diff --git a/compiler/rustc_type_ir/src/infer_ctxt.rs b/compiler/rustc_type_ir/src/infer_ctxt.rs
index 3fac50ff9ccfc..7fec869f10078 100644
--- a/compiler/rustc_type_ir/src/infer_ctxt.rs
+++ b/compiler/rustc_type_ir/src/infer_ctxt.rs
@@ -158,6 +158,7 @@ pub trait InferCtxtLike: Sized {
     fn universe_of_ct(&self, ct: ty::ConstVid) -> Option<ty::UniverseIndex>;
 
     fn root_ty_var(&self, var: ty::TyVid) -> ty::TyVid;
+    fn sub_root_ty_var(&self, var: ty::TyVid) -> ty::TyVid;
     fn root_const_var(&self, var: ty::ConstVid) -> ty::ConstVid;
 
     fn opportunistic_resolve_ty_var(&self, vid: ty::TyVid) -> <Self::Interner as Interner>::Ty;
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 906e5828aba82..a18d7e7478fce 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
@@ -1,30 +1,30 @@
 // MIR for `address_of_reborrow` after SimplifyCfg-initial
 
 | User Type Annotations
-| 0: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty(U0)] }, span: $DIR/address_of.rs:8:10: 8:18, inferred_ty: *const [i32; 10]
+| 0: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:8:10: 8:18, inferred_ty: *const [i32; 10]
 | 1: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:10:10: 10:25, inferred_ty: *const dyn std::marker::Send
-| 2: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty(U0)] }, span: $DIR/address_of.rs:14:12: 14:20, inferred_ty: *const [i32; 10]
-| 3: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty(U0)] }, span: $DIR/address_of.rs:14:12: 14:20, inferred_ty: *const [i32; 10]
+| 2: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:14:12: 14:20, inferred_ty: *const [i32; 10]
+| 3: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:14:12: 14:20, inferred_ty: *const [i32; 10]
 | 4: user_ty: Canonical { value: Ty(*const [i32; 10]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:15:12: 15:28, inferred_ty: *const [i32; 10]
 | 5: user_ty: Canonical { value: Ty(*const [i32; 10]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:15:12: 15:28, inferred_ty: *const [i32; 10]
 | 6: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:16:12: 16:27, inferred_ty: *const dyn std::marker::Send
 | 7: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:16:12: 16:27, inferred_ty: *const dyn std::marker::Send
 | 8: user_ty: Canonical { value: Ty(*const [i32]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:17:12: 17:24, inferred_ty: *const [i32]
 | 9: user_ty: Canonical { value: Ty(*const [i32]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:17:12: 17:24, inferred_ty: *const [i32]
-| 10: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty(U0)] }, span: $DIR/address_of.rs:19:10: 19:18, inferred_ty: *const [i32; 10]
+| 10: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:19:10: 19:18, inferred_ty: *const [i32; 10]
 | 11: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:21:10: 21:25, inferred_ty: *const dyn std::marker::Send
-| 12: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty(U0)] }, span: $DIR/address_of.rs:24:12: 24:20, inferred_ty: *const [i32; 10]
-| 13: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty(U0)] }, span: $DIR/address_of.rs:24:12: 24:20, inferred_ty: *const [i32; 10]
+| 12: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:24:12: 24:20, inferred_ty: *const [i32; 10]
+| 13: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:24:12: 24:20, inferred_ty: *const [i32; 10]
 | 14: user_ty: Canonical { value: Ty(*const [i32; 10]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:25:12: 25:28, inferred_ty: *const [i32; 10]
 | 15: user_ty: Canonical { value: Ty(*const [i32; 10]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:25:12: 25:28, inferred_ty: *const [i32; 10]
 | 16: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:26:12: 26:27, inferred_ty: *const dyn std::marker::Send
 | 17: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:26:12: 26:27, inferred_ty: *const dyn std::marker::Send
 | 18: user_ty: Canonical { value: Ty(*const [i32]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:27:12: 27:24, inferred_ty: *const [i32]
 | 19: user_ty: Canonical { value: Ty(*const [i32]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:27:12: 27:24, inferred_ty: *const [i32]
-| 20: user_ty: Canonical { value: Ty(*mut ^0), max_universe: U0, variables: [Ty(U0)] }, span: $DIR/address_of.rs:29:10: 29:16, inferred_ty: *mut [i32; 10]
+| 20: user_ty: Canonical { value: Ty(*mut ^0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:29:10: 29:16, inferred_ty: *mut [i32; 10]
 | 21: user_ty: Canonical { value: Ty(*mut dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:31:10: 31:23, inferred_ty: *mut dyn std::marker::Send
-| 22: user_ty: Canonical { value: Ty(*mut ^0), max_universe: U0, variables: [Ty(U0)] }, span: $DIR/address_of.rs:34:12: 34:18, inferred_ty: *mut [i32; 10]
-| 23: user_ty: Canonical { value: Ty(*mut ^0), max_universe: U0, variables: [Ty(U0)] }, span: $DIR/address_of.rs:34:12: 34:18, inferred_ty: *mut [i32; 10]
+| 22: user_ty: Canonical { value: Ty(*mut ^0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:34:12: 34:18, inferred_ty: *mut [i32; 10]
+| 23: user_ty: Canonical { value: Ty(*mut ^0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:34:12: 34:18, inferred_ty: *mut [i32; 10]
 | 24: user_ty: Canonical { value: Ty(*mut [i32; 10]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:35:12: 35:26, inferred_ty: *mut [i32; 10]
 | 25: user_ty: Canonical { value: Ty(*mut [i32; 10]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:35:12: 35:26, inferred_ty: *mut [i32; 10]
 | 26: user_ty: Canonical { value: Ty(*mut dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:36:12: 36:25, inferred_ty: *mut dyn std::marker::Send
diff --git a/tests/ui/error-emitter/multiline-removal-suggestion.svg b/tests/ui/error-emitter/multiline-removal-suggestion.svg
index 9c9bd163ecd49..7a88ac55b23e2 100644
--- a/tests/ui/error-emitter/multiline-removal-suggestion.svg
+++ b/tests/ui/error-emitter/multiline-removal-suggestion.svg
@@ -1,4 +1,4 @@
-<svg width="2322px" height="4322px" xmlns="http://www.w3.org/2000/svg">
+<svg width="2238px" height="3890px" xmlns="http://www.w3.org/2000/svg">
   <style>
     .fg { fill: #AAAAAA }
     .bg { background: #000000 }
@@ -129,375 +129,327 @@
 </tspan>
     <tspan x="10px" y="982px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: the following trait bounds were not satisfied:</tspan>
 </tspan>
-    <tspan x="10px" y="1000px"><tspan>           `&lt;Flatten&lt;Map&lt;std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:16:10: 16:13}&gt;&gt; as IntoIterator&gt;::IntoIter = _`</tspan>
+    <tspan x="10px" y="1000px"><tspan>           `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:14:8: 14:23}&gt;&gt;: Iterator`</tspan>
 </tspan>
-    <tspan x="10px" y="1018px"><tspan>           which is required by `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:14:8: 14:23}&gt;&gt;: Iterator`</tspan>
+    <tspan x="10px" y="1018px"><tspan>           which is required by `&amp;mut Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:14:8: 14:23}&gt;&gt;: Iterator`</tspan>
 </tspan>
-    <tspan x="10px" y="1036px"><tspan>           `&lt;Flatten&lt;Map&lt;std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:16:10: 16:13}&gt;&gt; as IntoIterator&gt;::Item = _`</tspan>
+    <tspan x="10px" y="1036px">
 </tspan>
-    <tspan x="10px" y="1054px"><tspan>           which is required by `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:14:8: 14:23}&gt;&gt;: Iterator`</tspan>
+    <tspan x="10px" y="1054px"><tspan class="fg-ansi256-009 bold">error[E0277]</tspan><tspan class="bold">: `(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
 </tspan>
-    <tspan x="10px" y="1072px"><tspan>           `Flatten&lt;Map&lt;std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:16:10: 16:13}&gt;&gt;: IntoIterator`</tspan>
+    <tspan x="10px" y="1072px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:32:6</tspan>
 </tspan>
-    <tspan x="10px" y="1090px"><tspan>           which is required by `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:14:8: 14:23}&gt;&gt;: Iterator`</tspan>
+    <tspan x="10px" y="1090px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="1108px"><tspan>           `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:14:8: 14:23}&gt;&gt;: Iterator`</tspan>
+    <tspan x="10px" y="1108px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>                 .flatten()</tspan>
 </tspan>
-    <tspan x="10px" y="1126px"><tspan>           which is required by `&amp;mut Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:14:8: 14:23}&gt;&gt;: Iterator`</tspan>
+    <tspan x="10px" y="1126px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>                  </tspan><tspan class="fg-ansi256-009 bold">^^^^^^^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">`(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
 </tspan>
-    <tspan x="10px" y="1144px">
+    <tspan x="10px" y="1144px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="1162px"><tspan class="fg-ansi256-009 bold">error[E0277]</tspan><tspan class="bold">: `(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
+    <tspan x="10px" y="1162px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">help</tspan><tspan>: the trait `Iterator` is not implemented for `(bool, HashSet&lt;u8&gt;)`</tspan>
 </tspan>
-    <tspan x="10px" y="1180px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:32:6</tspan>
+    <tspan x="10px" y="1180px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: required for `(bool, HashSet&lt;u8&gt;)` to implement `IntoIterator`</tspan>
 </tspan>
-    <tspan x="10px" y="1198px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+    <tspan x="10px" y="1198px"><tspan class="fg-ansi256-010 bold">note</tspan><tspan>: required by a bound in `flatten`</tspan>
 </tspan>
-    <tspan x="10px" y="1216px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>                 .flatten()</tspan>
+    <tspan x="10px" y="1216px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL</tspan>
 </tspan>
-    <tspan x="10px" y="1234px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>                  </tspan><tspan class="fg-ansi256-009 bold">^^^^^^^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">`(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
+    <tspan x="10px" y="1234px"><tspan class="fg-ansi256-014 bold">help</tspan><tspan>: consider removing this method call, as the receiver has type `std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;` and `std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;: Iterator` trivially holds</tspan>
 </tspan>
     <tspan x="10px" y="1252px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="1270px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">help</tspan><tspan>: the trait `Iterator` is not implemented for `(bool, HashSet&lt;u8&gt;)`</tspan>
+    <tspan x="10px" y="1270px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">- </tspan><tspan>            ts.into_iter()</tspan>
 </tspan>
-    <tspan x="10px" y="1288px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: required for `(bool, HashSet&lt;u8&gt;)` to implement `IntoIterator`</tspan>
+    <tspan x="10px" y="1288px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">-                 .map(|t| (is_true, t))</tspan>
 </tspan>
-    <tspan x="10px" y="1306px"><tspan class="fg-ansi256-010 bold">note</tspan><tspan>: required by a bound in `flatten`</tspan>
+    <tspan x="10px" y="1306px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-010">+ </tspan><tspan>            ts.into_iter()</tspan>
 </tspan>
-    <tspan x="10px" y="1324px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL</tspan>
+    <tspan x="10px" y="1324px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="1342px"><tspan class="fg-ansi256-014 bold">help</tspan><tspan>: consider removing this method call, as the receiver has type `std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;` and `std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;: Iterator` trivially holds</tspan>
+    <tspan x="10px" y="1342px">
 </tspan>
-    <tspan x="10px" y="1360px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+    <tspan x="10px" y="1360px"><tspan class="fg-ansi256-009 bold">error[E0277]</tspan><tspan class="bold">: `(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
 </tspan>
-    <tspan x="10px" y="1378px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">- </tspan><tspan>            ts.into_iter()</tspan>
+    <tspan x="10px" y="1378px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:28:2</tspan>
 </tspan>
-    <tspan x="10px" y="1396px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">-                 .map(|t| (is_true, t))</tspan>
+    <tspan x="10px" y="1396px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="1414px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-010">+ </tspan><tspan>            ts.into_iter()</tspan>
+    <tspan x="10px" y="1414px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">/</tspan><tspan>     hm.into_iter()</tspan>
 </tspan>
-    <tspan x="10px" y="1432px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+    <tspan x="10px" y="1432px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>         .map(|(is_true, ts)| {</tspan>
 </tspan>
-    <tspan x="10px" y="1450px">
+    <tspan x="10px" y="1450px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>             ts.into_iter()</tspan>
 </tspan>
-    <tspan x="10px" y="1468px"><tspan class="fg-ansi256-009 bold">error[E0277]</tspan><tspan class="bold">: `(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
+    <tspan x="10px" y="1468px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>                 .map(|t| (is_true, t))</tspan>
 </tspan>
-    <tspan x="10px" y="1486px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:28:2</tspan>
+    <tspan x="10px" y="1486px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>                 .flatten()</tspan>
 </tspan>
-    <tspan x="10px" y="1504px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+    <tspan x="10px" y="1504px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>         })</tspan>
 </tspan>
-    <tspan x="10px" y="1522px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">/</tspan><tspan>     hm.into_iter()</tspan>
+    <tspan x="10px" y="1522px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|__________^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">`(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
 </tspan>
-    <tspan x="10px" y="1540px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>         .map(|(is_true, ts)| {</tspan>
+    <tspan x="10px" y="1540px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="1558px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>             ts.into_iter()</tspan>
+    <tspan x="10px" y="1558px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">help</tspan><tspan>: the trait `Iterator` is not implemented for `(bool, HashSet&lt;u8&gt;)`</tspan>
 </tspan>
-    <tspan x="10px" y="1576px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>                 .map(|t| (is_true, t))</tspan>
+    <tspan x="10px" y="1576px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: required for `(bool, HashSet&lt;u8&gt;)` to implement `IntoIterator`</tspan>
 </tspan>
-    <tspan x="10px" y="1594px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>                 .flatten()</tspan>
+    <tspan x="10px" y="1594px"><tspan class="fg-ansi256-010 bold">note</tspan><tspan>: required by a bound in `Flatten`</tspan>
 </tspan>
-    <tspan x="10px" y="1612px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>         })</tspan>
+    <tspan x="10px" y="1612px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$SRC_DIR/core/src/iter/adapters/flatten.rs:LL:COL</tspan>
 </tspan>
-    <tspan x="10px" y="1630px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|__________^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">`(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
+    <tspan x="10px" y="1630px">
 </tspan>
-    <tspan x="10px" y="1648px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+    <tspan x="10px" y="1648px"><tspan class="fg-ansi256-009 bold">error[E0599]</tspan><tspan class="bold">: the method `collect` exists for struct `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:29:8: 29:23}&gt;&gt;`, but its trait bounds were not satisfied</tspan>
 </tspan>
-    <tspan x="10px" y="1666px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">help</tspan><tspan>: the trait `Iterator` is not implemented for `(bool, HashSet&lt;u8&gt;)`</tspan>
+    <tspan x="10px" y="1666px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:35:4</tspan>
 </tspan>
-    <tspan x="10px" y="1684px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: required for `(bool, HashSet&lt;u8&gt;)` to implement `IntoIterator`</tspan>
+    <tspan x="10px" y="1684px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="1702px"><tspan class="fg-ansi256-010 bold">note</tspan><tspan>: required by a bound in `Flatten`</tspan>
+    <tspan x="10px" y="1702px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">/</tspan><tspan>     hm.into_iter()</tspan>
 </tspan>
-    <tspan x="10px" y="1720px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$SRC_DIR/core/src/iter/adapters/flatten.rs:LL:COL</tspan>
+    <tspan x="10px" y="1720px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .map(|(is_true, ts)| {</tspan>
 </tspan>
-    <tspan x="10px" y="1738px">
+    <tspan x="10px" y="1738px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>             ts.into_iter()</tspan>
 </tspan>
-    <tspan x="10px" y="1756px"><tspan class="fg-ansi256-009 bold">error[E0599]</tspan><tspan class="bold">: the method `collect` exists for struct `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:29:8: 29:23}&gt;&gt;`, but its trait bounds were not satisfied</tspan>
+    <tspan x="10px" y="1756px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>                 .map(|t| (is_true, t))</tspan>
 </tspan>
-    <tspan x="10px" y="1774px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:35:4</tspan>
+    <tspan x="10px" y="1774px"><tspan class="fg-ansi256-012 bold">...</tspan><tspan>  </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="1792px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+    <tspan x="10px" y="1792px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .flatten()</tspan>
 </tspan>
-    <tspan x="10px" y="1810px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">/</tspan><tspan>     hm.into_iter()</tspan>
+    <tspan x="10px" y="1810px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .collect()</tspan>
 </tspan>
-    <tspan x="10px" y="1828px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .map(|(is_true, ts)| {</tspan>
+    <tspan x="10px" y="1828px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         </tspan><tspan class="fg-ansi256-012 bold">-</tspan><tspan class="fg-ansi256-009 bold">^^^^^^^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">method cannot be called due to unsatisfied trait bounds</tspan>
 </tspan>
-    <tspan x="10px" y="1846px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>             ts.into_iter()</tspan>
+    <tspan x="10px" y="1846px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|_________|</tspan>
 </tspan>
-    <tspan x="10px" y="1864px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>                 .map(|t| (is_true, t))</tspan>
+    <tspan x="10px" y="1864px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="1882px"><tspan class="fg-ansi256-012 bold">...</tspan><tspan>  </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+    <tspan x="10px" y="1882px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="1900px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .flatten()</tspan>
+    <tspan x="10px" y="1900px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: the following trait bounds were not satisfied:</tspan>
 </tspan>
-    <tspan x="10px" y="1918px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .collect()</tspan>
+    <tspan x="10px" y="1918px"><tspan>           `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:29:8: 29:23}&gt;&gt;: Iterator`</tspan>
 </tspan>
-    <tspan x="10px" y="1936px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         </tspan><tspan class="fg-ansi256-012 bold">-</tspan><tspan class="fg-ansi256-009 bold">^^^^^^^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">method cannot be called due to unsatisfied trait bounds</tspan>
+    <tspan x="10px" y="1936px"><tspan>           which is required by `&amp;mut Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:29:8: 29:23}&gt;&gt;: Iterator`</tspan>
 </tspan>
-    <tspan x="10px" y="1954px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|_________|</tspan>
+    <tspan x="10px" y="1954px">
 </tspan>
-    <tspan x="10px" y="1972px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+    <tspan x="10px" y="1972px"><tspan class="fg-ansi256-009 bold">error[E0277]</tspan><tspan class="bold">: `(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
 </tspan>
-    <tspan x="10px" y="1990px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+    <tspan x="10px" y="1990px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:43:7</tspan>
 </tspan>
-    <tspan x="10px" y="2008px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: the following trait bounds were not satisfied:</tspan>
+    <tspan x="10px" y="2008px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="2026px"><tspan>           `&lt;Flatten&lt;Map&lt;std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:31:10: 31:13}&gt;&gt; as IntoIterator&gt;::IntoIter = _`</tspan>
+    <tspan x="10px" y="2026px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>             }).flatten()</tspan>
 </tspan>
-    <tspan x="10px" y="2044px"><tspan>           which is required by `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:29:8: 29:23}&gt;&gt;: Iterator`</tspan>
+    <tspan x="10px" y="2044px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>                </tspan><tspan class="fg-ansi256-009 bold">^^^^^^^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">`(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
 </tspan>
-    <tspan x="10px" y="2062px"><tspan>           `&lt;Flatten&lt;Map&lt;std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:31:10: 31:13}&gt;&gt; as IntoIterator&gt;::Item = _`</tspan>
+    <tspan x="10px" y="2062px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="2080px"><tspan>           which is required by `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:29:8: 29:23}&gt;&gt;: Iterator`</tspan>
+    <tspan x="10px" y="2080px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">help</tspan><tspan>: the trait `Iterator` is not implemented for `(bool, HashSet&lt;u8&gt;)`</tspan>
 </tspan>
-    <tspan x="10px" y="2098px"><tspan>           `Flatten&lt;Map&lt;std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:31:10: 31:13}&gt;&gt;: IntoIterator`</tspan>
+    <tspan x="10px" y="2098px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: required for `(bool, HashSet&lt;u8&gt;)` to implement `IntoIterator`</tspan>
 </tspan>
-    <tspan x="10px" y="2116px"><tspan>           which is required by `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:29:8: 29:23}&gt;&gt;: Iterator`</tspan>
+    <tspan x="10px" y="2116px"><tspan class="fg-ansi256-010 bold">note</tspan><tspan>: required by a bound in `flatten`</tspan>
 </tspan>
-    <tspan x="10px" y="2134px"><tspan>           `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:29:8: 29:23}&gt;&gt;: Iterator`</tspan>
+    <tspan x="10px" y="2134px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL</tspan>
 </tspan>
-    <tspan x="10px" y="2152px"><tspan>           which is required by `&amp;mut Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:29:8: 29:23}&gt;&gt;: Iterator`</tspan>
+    <tspan x="10px" y="2152px"><tspan class="fg-ansi256-014 bold">help</tspan><tspan>: consider removing this method call, as the receiver has type `std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;` and `std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;: Iterator` trivially holds</tspan>
 </tspan>
-    <tspan x="10px" y="2170px">
+    <tspan x="10px" y="2170px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="2188px"><tspan class="fg-ansi256-009 bold">error[E0277]</tspan><tspan class="bold">: `(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
+    <tspan x="10px" y="2188px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">- </tspan><tspan>            ts.into_iter()</tspan><tspan class="fg-ansi256-009">.map(|t| {</tspan>
 </tspan>
-    <tspan x="10px" y="2206px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:43:7</tspan>
+    <tspan x="10px" y="2206px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">-                 (is_true, t)</tspan>
 </tspan>
-    <tspan x="10px" y="2224px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+    <tspan x="10px" y="2224px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">-             })</tspan><tspan>.flatten()</tspan>
 </tspan>
-    <tspan x="10px" y="2242px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>             }).flatten()</tspan>
+    <tspan x="10px" y="2242px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-010">+ </tspan><tspan>            ts.into_iter().flatten()</tspan>
 </tspan>
-    <tspan x="10px" y="2260px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>                </tspan><tspan class="fg-ansi256-009 bold">^^^^^^^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">`(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
+    <tspan x="10px" y="2260px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="2278px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+    <tspan x="10px" y="2278px">
 </tspan>
-    <tspan x="10px" y="2296px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">help</tspan><tspan>: the trait `Iterator` is not implemented for `(bool, HashSet&lt;u8&gt;)`</tspan>
+    <tspan x="10px" y="2296px"><tspan class="fg-ansi256-009 bold">error[E0277]</tspan><tspan class="bold">: `(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
 </tspan>
-    <tspan x="10px" y="2314px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: required for `(bool, HashSet&lt;u8&gt;)` to implement `IntoIterator`</tspan>
+    <tspan x="10px" y="2314px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:39:2</tspan>
 </tspan>
-    <tspan x="10px" y="2332px"><tspan class="fg-ansi256-010 bold">note</tspan><tspan>: required by a bound in `flatten`</tspan>
+    <tspan x="10px" y="2332px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="2350px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL</tspan>
+    <tspan x="10px" y="2350px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">/</tspan><tspan>     hm.into_iter()</tspan>
 </tspan>
-    <tspan x="10px" y="2368px"><tspan class="fg-ansi256-014 bold">help</tspan><tspan>: consider removing this method call, as the receiver has type `std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;` and `std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;: Iterator` trivially holds</tspan>
+    <tspan x="10px" y="2368px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>         .map(|(is_true, ts)| {</tspan>
 </tspan>
-    <tspan x="10px" y="2386px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+    <tspan x="10px" y="2386px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>             ts.into_iter().map(|t| {</tspan>
 </tspan>
-    <tspan x="10px" y="2404px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">- </tspan><tspan>            ts.into_iter()</tspan><tspan class="fg-ansi256-009">.map(|t| {</tspan>
+    <tspan x="10px" y="2404px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>                 (is_true, t)</tspan>
 </tspan>
-    <tspan x="10px" y="2422px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">-                 (is_true, t)</tspan>
+    <tspan x="10px" y="2422px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>             }).flatten()</tspan>
 </tspan>
-    <tspan x="10px" y="2440px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">-             })</tspan><tspan>.flatten()</tspan>
+    <tspan x="10px" y="2440px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>         })</tspan>
 </tspan>
-    <tspan x="10px" y="2458px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-010">+ </tspan><tspan>            ts.into_iter().flatten()</tspan>
+    <tspan x="10px" y="2458px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|__________^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">`(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
 </tspan>
     <tspan x="10px" y="2476px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="2494px">
+    <tspan x="10px" y="2494px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">help</tspan><tspan>: the trait `Iterator` is not implemented for `(bool, HashSet&lt;u8&gt;)`</tspan>
 </tspan>
-    <tspan x="10px" y="2512px"><tspan class="fg-ansi256-009 bold">error[E0277]</tspan><tspan class="bold">: `(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
+    <tspan x="10px" y="2512px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: required for `(bool, HashSet&lt;u8&gt;)` to implement `IntoIterator`</tspan>
 </tspan>
-    <tspan x="10px" y="2530px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:39:2</tspan>
+    <tspan x="10px" y="2530px"><tspan class="fg-ansi256-010 bold">note</tspan><tspan>: required by a bound in `Flatten`</tspan>
 </tspan>
-    <tspan x="10px" y="2548px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+    <tspan x="10px" y="2548px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$SRC_DIR/core/src/iter/adapters/flatten.rs:LL:COL</tspan>
 </tspan>
-    <tspan x="10px" y="2566px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">/</tspan><tspan>     hm.into_iter()</tspan>
+    <tspan x="10px" y="2566px">
 </tspan>
-    <tspan x="10px" y="2584px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>         .map(|(is_true, ts)| {</tspan>
+    <tspan x="10px" y="2584px"><tspan class="fg-ansi256-009 bold">error[E0599]</tspan><tspan class="bold">: the method `collect` exists for struct `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:40:8: 40:23}&gt;&gt;`, but its trait bounds were not satisfied</tspan>
 </tspan>
-    <tspan x="10px" y="2602px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>             ts.into_iter().map(|t| {</tspan>
+    <tspan x="10px" y="2602px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:46:4</tspan>
 </tspan>
-    <tspan x="10px" y="2620px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>                 (is_true, t)</tspan>
+    <tspan x="10px" y="2620px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="2638px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>             }).flatten()</tspan>
+    <tspan x="10px" y="2638px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">/</tspan><tspan>     hm.into_iter()</tspan>
 </tspan>
-    <tspan x="10px" y="2656px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>         })</tspan>
+    <tspan x="10px" y="2656px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .map(|(is_true, ts)| {</tspan>
 </tspan>
-    <tspan x="10px" y="2674px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|__________^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">`(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
+    <tspan x="10px" y="2674px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>             ts.into_iter().map(|t| {</tspan>
 </tspan>
-    <tspan x="10px" y="2692px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+    <tspan x="10px" y="2692px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>                 (is_true, t)</tspan>
 </tspan>
-    <tspan x="10px" y="2710px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">help</tspan><tspan>: the trait `Iterator` is not implemented for `(bool, HashSet&lt;u8&gt;)`</tspan>
+    <tspan x="10px" y="2710px"><tspan class="fg-ansi256-012 bold">...</tspan><tspan>  </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="2728px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: required for `(bool, HashSet&lt;u8&gt;)` to implement `IntoIterator`</tspan>
+    <tspan x="10px" y="2728px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .flatten()</tspan>
 </tspan>
-    <tspan x="10px" y="2746px"><tspan class="fg-ansi256-010 bold">note</tspan><tspan>: required by a bound in `Flatten`</tspan>
+    <tspan x="10px" y="2746px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .collect()</tspan>
 </tspan>
-    <tspan x="10px" y="2764px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$SRC_DIR/core/src/iter/adapters/flatten.rs:LL:COL</tspan>
+    <tspan x="10px" y="2764px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         </tspan><tspan class="fg-ansi256-012 bold">-</tspan><tspan class="fg-ansi256-009 bold">^^^^^^^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">method cannot be called due to unsatisfied trait bounds</tspan>
 </tspan>
-    <tspan x="10px" y="2782px">
+    <tspan x="10px" y="2782px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|_________|</tspan>
 </tspan>
-    <tspan x="10px" y="2800px"><tspan class="fg-ansi256-009 bold">error[E0599]</tspan><tspan class="bold">: the method `collect` exists for struct `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:40:8: 40:23}&gt;&gt;`, but its trait bounds were not satisfied</tspan>
+    <tspan x="10px" y="2800px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="2818px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:46:4</tspan>
+    <tspan x="10px" y="2818px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="2836px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+    <tspan x="10px" y="2836px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: the following trait bounds were not satisfied:</tspan>
 </tspan>
-    <tspan x="10px" y="2854px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">/</tspan><tspan>     hm.into_iter()</tspan>
+    <tspan x="10px" y="2854px"><tspan>           `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:40:8: 40:23}&gt;&gt;: Iterator`</tspan>
 </tspan>
-    <tspan x="10px" y="2872px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .map(|(is_true, ts)| {</tspan>
+    <tspan x="10px" y="2872px"><tspan>           which is required by `&amp;mut Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:40:8: 40:23}&gt;&gt;: Iterator`</tspan>
 </tspan>
-    <tspan x="10px" y="2890px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>             ts.into_iter().map(|t| {</tspan>
+    <tspan x="10px" y="2890px">
 </tspan>
-    <tspan x="10px" y="2908px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>                 (is_true, t)</tspan>
+    <tspan x="10px" y="2908px"><tspan class="fg-ansi256-009 bold">error[E0277]</tspan><tspan class="bold">: `(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
 </tspan>
-    <tspan x="10px" y="2926px"><tspan class="fg-ansi256-012 bold">...</tspan><tspan>  </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+    <tspan x="10px" y="2926px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:53:28</tspan>
 </tspan>
-    <tspan x="10px" y="2944px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .flatten()</tspan>
+    <tspan x="10px" y="2944px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="2962px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .collect()</tspan>
+    <tspan x="10px" y="2962px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>                 .map(|t| (is_true, t)).flatten()</tspan>
 </tspan>
-    <tspan x="10px" y="2980px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         </tspan><tspan class="fg-ansi256-012 bold">-</tspan><tspan class="fg-ansi256-009 bold">^^^^^^^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">method cannot be called due to unsatisfied trait bounds</tspan>
+    <tspan x="10px" y="2980px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>                                        </tspan><tspan class="fg-ansi256-009 bold">^^^^^^^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">`(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
 </tspan>
-    <tspan x="10px" y="2998px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|_________|</tspan>
+    <tspan x="10px" y="2998px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="3016px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+    <tspan x="10px" y="3016px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">help</tspan><tspan>: the trait `Iterator` is not implemented for `(bool, HashSet&lt;u8&gt;)`</tspan>
 </tspan>
-    <tspan x="10px" y="3034px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+    <tspan x="10px" y="3034px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: required for `(bool, HashSet&lt;u8&gt;)` to implement `IntoIterator`</tspan>
 </tspan>
-    <tspan x="10px" y="3052px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: the following trait bounds were not satisfied:</tspan>
+    <tspan x="10px" y="3052px"><tspan class="fg-ansi256-010 bold">note</tspan><tspan>: required by a bound in `flatten`</tspan>
 </tspan>
-    <tspan x="10px" y="3070px"><tspan>           `&lt;Flatten&lt;Map&lt;std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:41:23: 41:26}&gt;&gt; as IntoIterator&gt;::IntoIter = _`</tspan>
+    <tspan x="10px" y="3070px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL</tspan>
 </tspan>
-    <tspan x="10px" y="3088px"><tspan>           which is required by `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:40:8: 40:23}&gt;&gt;: Iterator`</tspan>
+    <tspan x="10px" y="3088px"><tspan class="fg-ansi256-014 bold">help</tspan><tspan>: consider removing this method call, as the receiver has type `std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;` and `std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;: Iterator` trivially holds</tspan>
 </tspan>
-    <tspan x="10px" y="3106px"><tspan>           `&lt;Flatten&lt;Map&lt;std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:41:23: 41:26}&gt;&gt; as IntoIterator&gt;::Item = _`</tspan>
+    <tspan x="10px" y="3106px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="3124px"><tspan>           which is required by `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:40:8: 40:23}&gt;&gt;: Iterator`</tspan>
+    <tspan x="10px" y="3124px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">- </tspan><tspan>            ts.into_iter()</tspan>
 </tspan>
-    <tspan x="10px" y="3142px"><tspan>           `Flatten&lt;Map&lt;std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:41:23: 41:26}&gt;&gt;: IntoIterator`</tspan>
+    <tspan x="10px" y="3142px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">-                 .map(|t| (is_true, t))</tspan><tspan>.flatten()</tspan>
 </tspan>
-    <tspan x="10px" y="3160px"><tspan>           which is required by `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:40:8: 40:23}&gt;&gt;: Iterator`</tspan>
+    <tspan x="10px" y="3160px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-010">+ </tspan><tspan>            ts.into_iter().flatten()</tspan>
 </tspan>
-    <tspan x="10px" y="3178px"><tspan>           `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:40:8: 40:23}&gt;&gt;: Iterator`</tspan>
+    <tspan x="10px" y="3178px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="3196px"><tspan>           which is required by `&amp;mut Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:40:8: 40:23}&gt;&gt;: Iterator`</tspan>
+    <tspan x="10px" y="3196px">
 </tspan>
-    <tspan x="10px" y="3214px">
+    <tspan x="10px" y="3214px"><tspan class="fg-ansi256-009 bold">error[E0277]</tspan><tspan class="bold">: `(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
 </tspan>
-    <tspan x="10px" y="3232px"><tspan class="fg-ansi256-009 bold">error[E0277]</tspan><tspan class="bold">: `(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
+    <tspan x="10px" y="3232px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:50:2</tspan>
 </tspan>
-    <tspan x="10px" y="3250px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:53:28</tspan>
+    <tspan x="10px" y="3250px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="3268px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+    <tspan x="10px" y="3268px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">/</tspan><tspan>     hm.into_iter()</tspan>
 </tspan>
-    <tspan x="10px" y="3286px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>                 .map(|t| (is_true, t)).flatten()</tspan>
+    <tspan x="10px" y="3286px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>         .map(|(is_true, ts)| {</tspan>
 </tspan>
-    <tspan x="10px" y="3304px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>                                        </tspan><tspan class="fg-ansi256-009 bold">^^^^^^^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">`(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
+    <tspan x="10px" y="3304px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>             ts.into_iter()</tspan>
 </tspan>
-    <tspan x="10px" y="3322px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+    <tspan x="10px" y="3322px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>                 .map(|t| (is_true, t)).flatten()</tspan>
 </tspan>
-    <tspan x="10px" y="3340px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">help</tspan><tspan>: the trait `Iterator` is not implemented for `(bool, HashSet&lt;u8&gt;)`</tspan>
+    <tspan x="10px" y="3340px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>         })</tspan>
 </tspan>
-    <tspan x="10px" y="3358px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: required for `(bool, HashSet&lt;u8&gt;)` to implement `IntoIterator`</tspan>
+    <tspan x="10px" y="3358px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|__________^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">`(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
 </tspan>
-    <tspan x="10px" y="3376px"><tspan class="fg-ansi256-010 bold">note</tspan><tspan>: required by a bound in `flatten`</tspan>
+    <tspan x="10px" y="3376px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="3394px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL</tspan>
+    <tspan x="10px" y="3394px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">help</tspan><tspan>: the trait `Iterator` is not implemented for `(bool, HashSet&lt;u8&gt;)`</tspan>
 </tspan>
-    <tspan x="10px" y="3412px"><tspan class="fg-ansi256-014 bold">help</tspan><tspan>: consider removing this method call, as the receiver has type `std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;` and `std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;: Iterator` trivially holds</tspan>
+    <tspan x="10px" y="3412px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: required for `(bool, HashSet&lt;u8&gt;)` to implement `IntoIterator`</tspan>
 </tspan>
-    <tspan x="10px" y="3430px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+    <tspan x="10px" y="3430px"><tspan class="fg-ansi256-010 bold">note</tspan><tspan>: required by a bound in `Flatten`</tspan>
 </tspan>
-    <tspan x="10px" y="3448px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">- </tspan><tspan>            ts.into_iter()</tspan>
+    <tspan x="10px" y="3448px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$SRC_DIR/core/src/iter/adapters/flatten.rs:LL:COL</tspan>
 </tspan>
-    <tspan x="10px" y="3466px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">-                 .map(|t| (is_true, t))</tspan><tspan>.flatten()</tspan>
+    <tspan x="10px" y="3466px">
 </tspan>
-    <tspan x="10px" y="3484px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-010">+ </tspan><tspan>            ts.into_iter().flatten()</tspan>
+    <tspan x="10px" y="3484px"><tspan class="fg-ansi256-009 bold">error[E0599]</tspan><tspan class="bold">: the method `collect` exists for struct `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:51:8: 51:23}&gt;&gt;`, but its trait bounds were not satisfied</tspan>
 </tspan>
-    <tspan x="10px" y="3502px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+    <tspan x="10px" y="3502px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:56:4</tspan>
 </tspan>
-    <tspan x="10px" y="3520px">
+    <tspan x="10px" y="3520px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="3538px"><tspan class="fg-ansi256-009 bold">error[E0277]</tspan><tspan class="bold">: `(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
+    <tspan x="10px" y="3538px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">/</tspan><tspan>     hm.into_iter()</tspan>
 </tspan>
-    <tspan x="10px" y="3556px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:50:2</tspan>
+    <tspan x="10px" y="3556px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .map(|(is_true, ts)| {</tspan>
 </tspan>
-    <tspan x="10px" y="3574px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+    <tspan x="10px" y="3574px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>             ts.into_iter()</tspan>
 </tspan>
-    <tspan x="10px" y="3592px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">/</tspan><tspan>     hm.into_iter()</tspan>
+    <tspan x="10px" y="3592px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>                 .map(|t| (is_true, t)).flatten()</tspan>
 </tspan>
-    <tspan x="10px" y="3610px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>         .map(|(is_true, ts)| {</tspan>
+    <tspan x="10px" y="3610px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         })</tspan>
 </tspan>
-    <tspan x="10px" y="3628px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>             ts.into_iter()</tspan>
+    <tspan x="10px" y="3628px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .flatten()</tspan>
 </tspan>
-    <tspan x="10px" y="3646px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>                 .map(|t| (is_true, t)).flatten()</tspan>
+    <tspan x="10px" y="3646px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .collect()</tspan>
 </tspan>
-    <tspan x="10px" y="3664px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|</tspan><tspan>         })</tspan>
+    <tspan x="10px" y="3664px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         </tspan><tspan class="fg-ansi256-012 bold">-</tspan><tspan class="fg-ansi256-009 bold">^^^^^^^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">method cannot be called due to unsatisfied trait bounds</tspan>
 </tspan>
-    <tspan x="10px" y="3682px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">|__________^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">`(bool, HashSet&lt;u8&gt;)` is not an iterator</tspan>
+    <tspan x="10px" y="3682px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|_________|</tspan>
 </tspan>
     <tspan x="10px" y="3700px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="3718px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">help</tspan><tspan>: the trait `Iterator` is not implemented for `(bool, HashSet&lt;u8&gt;)`</tspan>
+    <tspan x="10px" y="3718px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="3736px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: required for `(bool, HashSet&lt;u8&gt;)` to implement `IntoIterator`</tspan>
+    <tspan x="10px" y="3736px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: the following trait bounds were not satisfied:</tspan>
 </tspan>
-    <tspan x="10px" y="3754px"><tspan class="fg-ansi256-010 bold">note</tspan><tspan>: required by a bound in `Flatten`</tspan>
+    <tspan x="10px" y="3754px"><tspan>           `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:51:8: 51:23}&gt;&gt;: Iterator`</tspan>
 </tspan>
-    <tspan x="10px" y="3772px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$SRC_DIR/core/src/iter/adapters/flatten.rs:LL:COL</tspan>
+    <tspan x="10px" y="3772px"><tspan>           which is required by `&amp;mut Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:51:8: 51:23}&gt;&gt;: Iterator`</tspan>
 </tspan>
     <tspan x="10px" y="3790px">
 </tspan>
-    <tspan x="10px" y="3808px"><tspan class="fg-ansi256-009 bold">error[E0599]</tspan><tspan class="bold">: the method `collect` exists for struct `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:51:8: 51:23}&gt;&gt;`, but its trait bounds were not satisfied</tspan>
+    <tspan x="10px" y="3808px"><tspan class="fg-ansi256-009 bold">error</tspan><tspan class="bold">: aborting due to 12 previous errors</tspan>
 </tspan>
-    <tspan x="10px" y="3826px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/multiline-removal-suggestion.rs:56:4</tspan>
+    <tspan x="10px" y="3826px">
 </tspan>
-    <tspan x="10px" y="3844px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+    <tspan x="10px" y="3844px"><tspan class="bold">Some errors have detailed explanations: E0277, E0599.</tspan>
 </tspan>
-    <tspan x="10px" y="3862px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">/</tspan><tspan>     hm.into_iter()</tspan>
+    <tspan x="10px" y="3862px"><tspan class="bold">For more information about an error, try `rustc --explain E0277`.</tspan>
 </tspan>
-    <tspan x="10px" y="3880px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .map(|(is_true, ts)| {</tspan>
-</tspan>
-    <tspan x="10px" y="3898px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>             ts.into_iter()</tspan>
-</tspan>
-    <tspan x="10px" y="3916px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>                 .map(|t| (is_true, t)).flatten()</tspan>
-</tspan>
-    <tspan x="10px" y="3934px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         })</tspan>
-</tspan>
-    <tspan x="10px" y="3952px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .flatten()</tspan>
-</tspan>
-    <tspan x="10px" y="3970px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         .collect()</tspan>
-</tspan>
-    <tspan x="10px" y="3988px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         </tspan><tspan class="fg-ansi256-012 bold">-</tspan><tspan class="fg-ansi256-009 bold">^^^^^^^</tspan><tspan> </tspan><tspan class="fg-ansi256-009 bold">method cannot be called due to unsatisfied trait bounds</tspan>
-</tspan>
-    <tspan x="10px" y="4006px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|_________|</tspan>
-</tspan>
-    <tspan x="10px" y="4024px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
-</tspan>
-    <tspan x="10px" y="4042px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
-</tspan>
-    <tspan x="10px" y="4060px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">= </tspan><tspan class="bold">note</tspan><tspan>: the following trait bounds were not satisfied:</tspan>
-</tspan>
-    <tspan x="10px" y="4078px"><tspan>           `&lt;Flatten&lt;Map&lt;std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:53:10: 53:13}&gt;&gt; as IntoIterator&gt;::IntoIter = _`</tspan>
-</tspan>
-    <tspan x="10px" y="4096px"><tspan>           which is required by `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:51:8: 51:23}&gt;&gt;: Iterator`</tspan>
-</tspan>
-    <tspan x="10px" y="4114px"><tspan>           `&lt;Flatten&lt;Map&lt;std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:53:10: 53:13}&gt;&gt; as IntoIterator&gt;::Item = _`</tspan>
-</tspan>
-    <tspan x="10px" y="4132px"><tspan>           which is required by `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:51:8: 51:23}&gt;&gt;: Iterator`</tspan>
-</tspan>
-    <tspan x="10px" y="4150px"><tspan>           `Flatten&lt;Map&lt;std::vec::IntoIter&lt;HashSet&lt;u8&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:53:10: 53:13}&gt;&gt;: IntoIterator`</tspan>
-</tspan>
-    <tspan x="10px" y="4168px"><tspan>           which is required by `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:51:8: 51:23}&gt;&gt;: Iterator`</tspan>
-</tspan>
-    <tspan x="10px" y="4186px"><tspan>           `Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:51:8: 51:23}&gt;&gt;: Iterator`</tspan>
-</tspan>
-    <tspan x="10px" y="4204px"><tspan>           which is required by `&amp;mut Flatten&lt;Map&lt;std::collections::hash_map::IntoIter&lt;bool, Vec&lt;HashSet&lt;u8&gt;&gt;&gt;, {closure@$DIR/multiline-removal-suggestion.rs:51:8: 51:23}&gt;&gt;: Iterator`</tspan>
-</tspan>
-    <tspan x="10px" y="4222px">
-</tspan>
-    <tspan x="10px" y="4240px"><tspan class="fg-ansi256-009 bold">error</tspan><tspan class="bold">: aborting due to 12 previous errors</tspan>
-</tspan>
-    <tspan x="10px" y="4258px">
-</tspan>
-    <tspan x="10px" y="4276px"><tspan class="bold">Some errors have detailed explanations: E0277, E0599.</tspan>
-</tspan>
-    <tspan x="10px" y="4294px"><tspan class="bold">For more information about an error, try `rustc --explain E0277`.</tspan>
-</tspan>
-    <tspan x="10px" y="4312px">
+    <tspan x="10px" y="3880px">
 </tspan>
   </text>
 
diff --git a/tests/ui/impl-trait/recursive-in-exhaustiveness.next.stderr b/tests/ui/impl-trait/recursive-in-exhaustiveness.next.stderr
index 45df8cc9c0ca9..10e8dbf41ccbf 100644
--- a/tests/ui/impl-trait/recursive-in-exhaustiveness.next.stderr
+++ b/tests/ui/impl-trait/recursive-in-exhaustiveness.next.stderr
@@ -1,14 +1,24 @@
-error[E0282]: type annotations needed
-  --> $DIR/recursive-in-exhaustiveness.rs:19:17
+error[E0282]: type annotations needed for `(_,)`
+  --> $DIR/recursive-in-exhaustiveness.rs:19:9
    |
 LL |     let (x,) = (build(x),);
-   |                 ^^^^^^^^ cannot infer type
+   |         ^^^^
+   |
+help: consider giving this pattern a type, where the placeholders `_` are specified
+   |
+LL |     let (x,): (_,) = (build(x),);
+   |             ++++++
 
-error[E0282]: type annotations needed
-  --> $DIR/recursive-in-exhaustiveness.rs:29:17
+error[E0282]: type annotations needed for `((_,),)`
+  --> $DIR/recursive-in-exhaustiveness.rs:29:9
    |
 LL |     let (x,) = (build2(x),);
-   |                 ^^^^^^^^^ cannot infer type
+   |         ^^^^
+   |
+help: consider giving this pattern a type, where the placeholders `_` are specified
+   |
+LL |     let (x,): ((_,),) = (build2(x),);
+   |             +++++++++
 
 error[E0282]: type annotations needed
   --> $DIR/recursive-in-exhaustiveness.rs:40:5

From f51458640840cb94c32f1e55431b1c855ca22e88 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Wed, 27 Aug 2025 09:42:09 +0200
Subject: [PATCH 0659/1889] optimize `CanonicalVarValues::instantiate`

---
 Cargo.lock                                    |  1 +
 compiler/rustc_hir_typeck/src/method/probe.rs |  8 ++---
 .../rustc_infer/src/infer/canonical/mod.rs    | 31 ++++--------------
 .../src/infer/canonical/query_response.rs     | 24 +++++++-------
 .../src/solve/eval_ctxt/canonical.rs          | 15 +++------
 compiler/rustc_trait_selection/src/infer.rs   |  5 ++-
 .../rustc_traits/src/evaluate_obligation.rs   |  2 +-
 compiler/rustc_type_ir/Cargo.toml             |  1 +
 compiler/rustc_type_ir/src/canonical.rs       | 32 +++++++++++++++++++
 9 files changed, 63 insertions(+), 56 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 81f19668c24b7..f58782a59124d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4681,6 +4681,7 @@ dependencies = [
 name = "rustc_type_ir"
 version = "0.0.0"
 dependencies = [
+ "arrayvec",
  "bitflags",
  "derive-where",
  "ena",
diff --git a/compiler/rustc_hir_typeck/src/method/probe.rs b/compiler/rustc_hir_typeck/src/method/probe.rs
index ab584eb7c909e..52a8eff984b9b 100644
--- a/compiler/rustc_hir_typeck/src/method/probe.rs
+++ b/compiler/rustc_hir_typeck/src/method/probe.rs
@@ -403,15 +403,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 // special handling for this "trivial case" is a good idea.
 
                 let infcx = &self.infcx;
-                let (ParamEnvAnd { param_env: _, value: self_ty }, canonical_inference_vars) =
+                let (ParamEnvAnd { param_env: _, value: self_ty }, var_values) =
                     infcx.instantiate_canonical(span, &query_input.canonical);
                 debug!(?self_ty, ?query_input, "probe_op: Mode::Path");
                 MethodAutoderefStepsResult {
                     steps: infcx.tcx.arena.alloc_from_iter([CandidateStep {
-                        self_ty: self.make_query_response_ignoring_pending_obligations(
-                            canonical_inference_vars,
-                            self_ty,
-                        ),
+                        self_ty: self
+                            .make_query_response_ignoring_pending_obligations(var_values, self_ty),
                         autoderefs: 0,
                         from_unsafe_deref: false,
                         unsize: false,
diff --git a/compiler/rustc_infer/src/infer/canonical/mod.rs b/compiler/rustc_infer/src/infer/canonical/mod.rs
index 4e1ea52af4c93..517331c324576 100644
--- a/compiler/rustc_infer/src/infer/canonical/mod.rs
+++ b/compiler/rustc_infer/src/infer/canonical/mod.rs
@@ -24,7 +24,7 @@
 pub use instantiate::CanonicalExt;
 use rustc_index::IndexVec;
 pub use rustc_middle::infer::canonical::*;
-use rustc_middle::ty::{self, GenericArg, List, Ty, TyCtxt, TypeFoldable};
+use rustc_middle::ty::{self, GenericArg, Ty, TyCtxt, TypeFoldable};
 use rustc_span::Span;
 
 use crate::infer::{InferCtxt, RegionVariableOrigin};
@@ -67,29 +67,12 @@ impl<'tcx> InferCtxt<'tcx> {
             .chain((1..=canonical.max_universe.as_u32()).map(|_| self.create_next_universe()))
             .collect();
 
-        let canonical_inference_vars =
-            self.instantiate_canonical_vars(span, canonical.variables, |ui| universes[ui]);
-        let result = canonical.instantiate(self.tcx, &canonical_inference_vars);
-        (result, canonical_inference_vars)
-    }
-
-    /// Given the "infos" about the canonical variables from some
-    /// canonical, creates fresh variables with the same
-    /// characteristics (see `instantiate_canonical_var` for
-    /// details). You can then use `instantiate` to instantiate the
-    /// canonical variable with these inference variables.
-    fn instantiate_canonical_vars(
-        &self,
-        span: Span,
-        variables: &List<CanonicalVarKind<'tcx>>,
-        universe_map: impl Fn(ty::UniverseIndex) -> ty::UniverseIndex,
-    ) -> CanonicalVarValues<'tcx> {
-        let mut var_values = Vec::with_capacity(variables.len());
-        for info in variables.iter() {
-            let value = self.instantiate_canonical_var(span, info, &var_values, &universe_map);
-            var_values.push(value);
-        }
-        CanonicalVarValues { var_values: self.tcx.mk_args(&var_values) }
+        let var_values =
+            CanonicalVarValues::instantiate(self.tcx, &canonical.variables, |var_values, info| {
+                self.instantiate_canonical_var(span, info, &var_values, |ui| universes[ui])
+            });
+        let result = canonical.instantiate(self.tcx, &var_values);
+        (result, var_values)
     }
 
     /// Given the "info" about a canonical variable, creates a fresh
diff --git a/compiler/rustc_infer/src/infer/canonical/query_response.rs b/compiler/rustc_infer/src/infer/canonical/query_response.rs
index 22c9c4edccc43..5d1b4be9e57bb 100644
--- a/compiler/rustc_infer/src/infer/canonical/query_response.rs
+++ b/compiler/rustc_infer/src/infer/canonical/query_response.rs
@@ -453,16 +453,17 @@ impl<'tcx> InferCtxt<'tcx> {
         // Create result arguments: if we found a value for a
         // given variable in the loop above, use that. Otherwise, use
         // a fresh inference variable.
-        let mut var_values = Vec::with_capacity(query_response.variables.len());
-        for (index, kind) in query_response.variables.iter().enumerate() {
-            let value = if kind.universe() != ty::UniverseIndex::ROOT {
+        let tcx = self.tcx;
+        let variables = query_response.variables;
+        let var_values = CanonicalVarValues::instantiate(tcx, variables, |var_values, kind| {
+            if kind.universe() != ty::UniverseIndex::ROOT {
                 // A variable from inside a binder of the query. While ideally these shouldn't
                 // exist at all, we have to deal with them for now.
                 self.instantiate_canonical_var(cause.span, kind, &var_values, |u| {
                     universe_map[u.as_usize()]
                 })
             } else if kind.is_existential() {
-                match opt_values[BoundVar::new(index)] {
+                match opt_values[BoundVar::new(var_values.len())] {
                     Some(k) => k,
                     None => self.instantiate_canonical_var(cause.span, kind, &var_values, |u| {
                         universe_map[u.as_usize()]
@@ -471,20 +472,17 @@ impl<'tcx> InferCtxt<'tcx> {
             } else {
                 // For placeholders which were already part of the input, we simply map this
                 // universal bound variable back the placeholder of the input.
-                opt_values[BoundVar::new(index)]
+                opt_values[BoundVar::new(var_values.len())]
                     .expect("expected placeholder to be unified with itself during response")
-            };
-            var_values.push(value);
-        }
-
-        let result_args = CanonicalVarValues { var_values: self.tcx.mk_args(&var_values) };
+            }
+        });
 
         let mut obligations = PredicateObligations::new();
 
         // Carry all newly resolved opaque types to the caller's scope
         for &(a, b) in &query_response.value.opaque_types {
-            let a = instantiate_value(self.tcx, &result_args, a);
-            let b = instantiate_value(self.tcx, &result_args, b);
+            let a = instantiate_value(self.tcx, &var_values, a);
+            let b = instantiate_value(self.tcx, &var_values, b);
             debug!(?a, ?b, "constrain opaque type");
             // We use equate here instead of, for example, just registering the
             // opaque type's hidden value directly, because the hidden type may have been an inference
@@ -501,7 +499,7 @@ impl<'tcx> InferCtxt<'tcx> {
             );
         }
 
-        Ok(InferOk { value: result_args, obligations })
+        Ok(InferOk { value: var_values, obligations })
     }
 
     /// Given a "guess" at the values for the canonical variables in
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs
index 8d7a55c55be96..169832ca5fbde 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs
@@ -365,10 +365,8 @@ where
                 }
             }
         }
-
-        let mut var_values = Vec::with_capacity(response.variables.len());
-        for (index, kind) in response.variables.iter().enumerate() {
-            let value = if kind.universe() != ty::UniverseIndex::ROOT {
+        CanonicalVarValues::instantiate(delegate.cx(), response.variables, |var_values, kind| {
+            if kind.universe() != ty::UniverseIndex::ROOT {
                 // A variable from inside a binder of the query. While ideally these shouldn't
                 // exist at all (see the FIXME at the start of this method), we have to deal with
                 // them for now.
@@ -383,7 +381,7 @@ where
                 // more placeholders then they should be able to. However the inference variables have
                 // to "come from somewhere", so by equating them with the original values of the caller
                 // later on, we pull them down into their correct universe again.
-                if let Some(v) = opt_values[ty::BoundVar::from_usize(index)] {
+                if let Some(v) = opt_values[ty::BoundVar::from_usize(var_values.len())] {
                     v
                 } else {
                     delegate.instantiate_canonical_var(kind, span, &var_values, |_| prev_universe)
@@ -392,11 +390,8 @@ where
                 // For placeholders which were already part of the input, we simply map this
                 // universal bound variable back the placeholder of the input.
                 original_values[kind.expect_placeholder_index()]
-            };
-            var_values.push(value)
-        }
-
-        CanonicalVarValues { var_values: delegate.cx().mk_args(&var_values) }
+            }
+        })
     }
 
     /// Unify the `original_values` with the `var_values` returned by the canonical query..
diff --git a/compiler/rustc_trait_selection/src/infer.rs b/compiler/rustc_trait_selection/src/infer.rs
index 7c6b7b14ecbeb..4c50c44b84182 100644
--- a/compiler/rustc_trait_selection/src/infer.rs
+++ b/compiler/rustc_trait_selection/src/infer.rs
@@ -184,10 +184,9 @@ impl<'tcx> InferCtxtBuilder<'tcx> {
         R: Debug + TypeFoldable<TyCtxt<'tcx>>,
         Canonical<'tcx, QueryResponse<'tcx, R>>: ArenaAllocatable<'tcx>,
     {
-        let (infcx, key, canonical_inference_vars) =
-            self.build_with_canonical(DUMMY_SP, canonical_key);
+        let (infcx, key, var_values) = self.build_with_canonical(DUMMY_SP, canonical_key);
         let ocx = ObligationCtxt::new(&infcx);
         let value = operation(&ocx, key)?;
-        ocx.make_canonicalized_query_response(canonical_inference_vars, value)
+        ocx.make_canonicalized_query_response(var_values, value)
     }
 }
diff --git a/compiler/rustc_traits/src/evaluate_obligation.rs b/compiler/rustc_traits/src/evaluate_obligation.rs
index 819b8e3231ce2..8f72bdf097261 100644
--- a/compiler/rustc_traits/src/evaluate_obligation.rs
+++ b/compiler/rustc_traits/src/evaluate_obligation.rs
@@ -19,7 +19,7 @@ fn evaluate_obligation<'tcx>(
 ) -> Result<EvaluationResult, OverflowError> {
     assert!(!tcx.next_trait_solver_globally());
     debug!("evaluate_obligation(canonical_goal={:#?})", canonical_goal);
-    let (ref infcx, goal, _canonical_inference_vars) =
+    let (ref infcx, goal, _var_values) =
         tcx.infer_ctxt().build_with_canonical(DUMMY_SP, &canonical_goal);
     debug!("evaluate_obligation: goal={:#?}", goal);
     let ParamEnvAnd { param_env, value: predicate } = goal;
diff --git a/compiler/rustc_type_ir/Cargo.toml b/compiler/rustc_type_ir/Cargo.toml
index d55e9b3b1be82..6ccddb17ff22b 100644
--- a/compiler/rustc_type_ir/Cargo.toml
+++ b/compiler/rustc_type_ir/Cargo.toml
@@ -5,6 +5,7 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
+arrayvec = { version = "0.7", default-features = false }
 bitflags = "2.4.1"
 derive-where = "1.2.7"
 ena = "0.14.3"
diff --git a/compiler/rustc_type_ir/src/canonical.rs b/compiler/rustc_type_ir/src/canonical.rs
index 04bf90080358d..ecf3ae4f8b2c9 100644
--- a/compiler/rustc_type_ir/src/canonical.rs
+++ b/compiler/rustc_type_ir/src/canonical.rs
@@ -1,6 +1,7 @@
 use std::fmt;
 use std::ops::Index;
 
+use arrayvec::ArrayVec;
 use derive_where::derive_where;
 #[cfg(feature = "nightly")]
 use rustc_macros::{Decodable_NoContext, Encodable_NoContext, HashStable_NoContext};
@@ -306,6 +307,37 @@ impl<I: Interner> CanonicalVarValues<I> {
         CanonicalVarValues { var_values: Default::default() }
     }
 
+    pub fn instantiate(
+        cx: I,
+        variables: I::CanonicalVarKinds,
+        mut f: impl FnMut(&[I::GenericArg], CanonicalVarKind<I>) -> I::GenericArg,
+    ) -> CanonicalVarValues<I> {
+        // Instantiating `CanonicalVarValues` is really hot, but limited to less than
+        // 4 most of the time. Avoid creating a `Vec` here.
+        if variables.len() <= 4 {
+            let mut var_values = ArrayVec::<_, 4>::new();
+            for info in variables.iter() {
+                var_values.push(f(&var_values, info));
+            }
+            CanonicalVarValues { var_values: cx.mk_args(&var_values) }
+        } else {
+            CanonicalVarValues::instantiate_cold(cx, variables, f)
+        }
+    }
+
+    #[cold]
+    fn instantiate_cold(
+        cx: I,
+        variables: I::CanonicalVarKinds,
+        mut f: impl FnMut(&[I::GenericArg], CanonicalVarKind<I>) -> I::GenericArg,
+    ) -> CanonicalVarValues<I> {
+        let mut var_values = Vec::with_capacity(variables.len());
+        for info in variables.iter() {
+            var_values.push(f(&var_values, info));
+        }
+        CanonicalVarValues { var_values: cx.mk_args(&var_values) }
+    }
+
     #[inline]
     pub fn len(&self) -> usize {
         self.var_values.len()

From b51a3a565a056235f3864e2cefdb9449f6b0dcb1 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Mon, 8 Sep 2025 11:41:43 +0200
Subject: [PATCH 0660/1889] review

---
 .../src/infer/canonical/canonicalizer.rs      |  8 +++-
 .../rustc_infer/src/infer/canonical/mod.rs    |  5 ++-
 compiler/rustc_infer/src/infer/context.rs     |  8 ++--
 compiler/rustc_infer/src/infer/mod.rs         | 10 ++---
 .../src/infer/relate/generalize.rs            |  2 +-
 .../rustc_infer/src/infer/type_variable.rs    | 41 ++++++++++---------
 .../src/canonicalizer.rs                      |  8 +++-
 .../src/solve/eval_ctxt/mod.rs                |  4 +-
 .../rustc_next_trait_solver/src/solve/mod.rs  |  2 +-
 .../error_reporting/infer/need_type_info.rs   |  3 +-
 .../src/solve/delegate.rs                     |  2 +-
 compiler/rustc_type_ir/src/infer_ctxt.rs      |  4 +-
 12 files changed, 57 insertions(+), 40 deletions(-)

diff --git a/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs b/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
index be68609502a8a..3c5e4a91c98c7 100644
--- a/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
+++ b/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
@@ -294,6 +294,12 @@ struct Canonicalizer<'cx, 'tcx> {
     // Note that indices is only used once `var_values` is big enough to be
     // heap-allocated.
     indices: FxHashMap<GenericArg<'tcx>, BoundVar>,
+    /// Maps each `sub_unification_table_root_var` to the index of the first
+    /// variable which used it.
+    ///
+    /// This means in case two type variables have the same sub relations root,
+    /// we set the `sub_root` of the second variable to the position of the first.
+    /// Otherwise the `sub_root` of each type variable is just its own position.
     sub_root_lookup_table: SsoHashMap<ty::TyVid, usize>,
     canonicalize_mode: &'cx dyn CanonicalizeMode,
     needs_canonical_flags: TypeFlags,
@@ -662,7 +668,7 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
     }
 
     fn get_or_insert_sub_root(&mut self, vid: ty::TyVid) -> ty::BoundVar {
-        let root_vid = self.infcx.unwrap().sub_root_var(vid);
+        let root_vid = self.infcx.unwrap().sub_unification_table_root_var(vid);
         let idx =
             *self.sub_root_lookup_table.entry(root_vid).or_insert_with(|| self.variables.len());
         ty::BoundVar::from(idx)
diff --git a/compiler/rustc_infer/src/infer/canonical/mod.rs b/compiler/rustc_infer/src/infer/canonical/mod.rs
index 517331c324576..f99f228e19d8e 100644
--- a/compiler/rustc_infer/src/infer/canonical/mod.rs
+++ b/compiler/rustc_infer/src/infer/canonical/mod.rs
@@ -93,10 +93,11 @@ impl<'tcx> InferCtxt<'tcx> {
         match kind {
             CanonicalVarKind::Ty { ui, sub_root } => {
                 let vid = self.next_ty_vid_in_universe(span, universe_map(ui));
-                // Fetch the `sub_root` in case it exists.
+                // If this inference variable is related to an earlier variable
+                // via subtyping, we need to add that info to the inference context.
                 if let Some(prev) = previous_var_values.get(sub_root.as_usize()) {
                     if let &ty::Infer(ty::TyVar(sub_root)) = prev.expect_ty().kind() {
-                        self.inner.borrow_mut().type_variables().sub(vid, sub_root);
+                        self.sub_unify_ty_vids_raw(vid, sub_root);
                     } else {
                         unreachable!()
                     }
diff --git a/compiler/rustc_infer/src/infer/context.rs b/compiler/rustc_infer/src/infer/context.rs
index b76931caaa579..14cc590720ac5 100644
--- a/compiler/rustc_infer/src/infer/context.rs
+++ b/compiler/rustc_infer/src/infer/context.rs
@@ -59,8 +59,8 @@ impl<'tcx> rustc_type_ir::InferCtxtLike for InferCtxt<'tcx> {
         self.root_var(var)
     }
 
-    fn sub_root_ty_var(&self, var: ty::TyVid) -> ty::TyVid {
-        self.sub_root_var(var)
+    fn sub_unification_table_root_var(&self, var: ty::TyVid) -> ty::TyVid {
+        self.sub_unification_table_root_var(var)
     }
 
     fn root_const_var(&self, var: ty::ConstVid) -> ty::ConstVid {
@@ -183,8 +183,8 @@ impl<'tcx> rustc_type_ir::InferCtxtLike for InferCtxt<'tcx> {
         self.inner.borrow_mut().type_variables().equate(a, b);
     }
 
-    fn sub_ty_vids_raw(&self, a: ty::TyVid, b: ty::TyVid) {
-        self.sub_ty_vids_raw(a, b);
+    fn sub_unify_ty_vids_raw(&self, a: ty::TyVid, b: ty::TyVid) {
+        self.sub_unify_ty_vids_raw(a, b);
     }
 
     fn equate_int_vids_raw(&self, a: ty::IntVid, b: ty::IntVid) {
diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
index 48dd699cd50cb..9d3886aff1c1a 100644
--- a/compiler/rustc_infer/src/infer/mod.rs
+++ b/compiler/rustc_infer/src/infer/mod.rs
@@ -764,7 +764,7 @@ impl<'tcx> InferCtxt<'tcx> {
         let r_b = self.shallow_resolve(predicate.skip_binder().b);
         match (r_a.kind(), r_b.kind()) {
             (&ty::Infer(ty::TyVar(a_vid)), &ty::Infer(ty::TyVar(b_vid))) => {
-                self.sub_ty_vids_raw(a_vid, b_vid);
+                self.sub_unify_ty_vids_raw(a_vid, b_vid);
                 return Err((a_vid, b_vid));
             }
             _ => {}
@@ -1129,12 +1129,12 @@ impl<'tcx> InferCtxt<'tcx> {
         self.inner.borrow_mut().type_variables().root_var(var)
     }
 
-    pub fn sub_ty_vids_raw(&self, a: ty::TyVid, b: ty::TyVid) {
-        self.inner.borrow_mut().type_variables().sub(a, b);
+    pub fn sub_unify_ty_vids_raw(&self, a: ty::TyVid, b: ty::TyVid) {
+        self.inner.borrow_mut().type_variables().sub_unify(a, b);
     }
 
-    pub fn sub_root_var(&self, var: ty::TyVid) -> ty::TyVid {
-        self.inner.borrow_mut().type_variables().sub_root_var(var)
+    pub fn sub_unification_table_root_var(&self, var: ty::TyVid) -> ty::TyVid {
+        self.inner.borrow_mut().type_variables().sub_unification_table_root_var(var)
     }
 
     pub fn root_const_var(&self, var: ty::ConstVid) -> ty::ConstVid {
diff --git a/compiler/rustc_infer/src/infer/relate/generalize.rs b/compiler/rustc_infer/src/infer/relate/generalize.rs
index 2323add0b3201..f0b5b164a0be6 100644
--- a/compiler/rustc_infer/src/infer/relate/generalize.rs
+++ b/compiler/rustc_infer/src/infer/relate/generalize.rs
@@ -522,7 +522,7 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for Generalizer<'_, 'tcx> {
                             // Record that `vid` and `new_var_id` have to be subtypes
                             // of each other. This is currently only used for diagnostics.
                             // To see why, see the docs in the `type_variables` module.
-                            inner.type_variables().sub(vid, new_var_id);
+                            inner.type_variables().sub_unify(vid, new_var_id);
                             // If we're in the new solver and create a new inference
                             // variable inside of an alias we eagerly constrain that
                             // inference variable to prevent unexpected ambiguity errors.
diff --git a/compiler/rustc_infer/src/infer/type_variable.rs b/compiler/rustc_infer/src/infer/type_variable.rs
index 613e5a5883a3d..65f77fe8e25f3 100644
--- a/compiler/rustc_infer/src/infer/type_variable.rs
+++ b/compiler/rustc_infer/src/infer/type_variable.rs
@@ -42,7 +42,7 @@ impl<'tcx> Rollback<sv::UndoLog<ut::Delegate<TyVidEqKey<'tcx>>>> for TypeVariabl
 
 impl<'tcx> Rollback<sv::UndoLog<ut::Delegate<TyVidSubKey>>> for TypeVariableStorage<'tcx> {
     fn reverse(&mut self, undo: sv::UndoLog<ut::Delegate<TyVidSubKey>>) {
-        self.sub_relations.reverse(undo)
+        self.sub_unification_table.reverse(undo)
     }
 }
 
@@ -50,7 +50,7 @@ impl<'tcx> Rollback<UndoLog<'tcx>> for TypeVariableStorage<'tcx> {
     fn reverse(&mut self, undo: UndoLog<'tcx>) {
         match undo {
             UndoLog::EqRelation(undo) => self.eq_relations.reverse(undo),
-            UndoLog::SubRelation(undo) => self.sub_relations.reverse(undo),
+            UndoLog::SubRelation(undo) => self.sub_unification_table.reverse(undo),
         }
     }
 }
@@ -63,7 +63,9 @@ pub(crate) struct TypeVariableStorage<'tcx> {
     /// constraint `?X == ?Y`. This table also stores, for each key,
     /// the known value.
     eq_relations: ut::UnificationTableStorage<TyVidEqKey<'tcx>>,
-    /// Only used by `-Znext-solver` and for diagnostics.
+    /// Only used by `-Znext-solver` and for diagnostics. Tracks whether
+    /// type variables are related via subtyping at all, ignoring which of
+    /// the two is the subtype.
     ///
     /// When reporting ambiguity errors, we sometimes want to
     /// treat all inference vars which are subtypes of each
@@ -79,7 +81,7 @@ pub(crate) struct TypeVariableStorage<'tcx> {
     /// Even for something like `let x = returns_arg(); x.method();` the
     /// type of `x` is only a supertype of the argument of `returns_arg`. We
     /// still want to suggest specifying the type of the argument.
-    sub_relations: ut::UnificationTableStorage<TyVidSubKey>,
+    sub_unification_table: ut::UnificationTableStorage<TyVidSubKey>,
 }
 
 pub(crate) struct TypeVariableTable<'a, 'tcx> {
@@ -155,23 +157,24 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
         self.storage.values[vid].origin
     }
 
-    /// Records that `a == b`, depending on `dir`.
+    /// Records that `a == b`.
     ///
     /// Precondition: neither `a` nor `b` are known.
     pub(crate) fn equate(&mut self, a: ty::TyVid, b: ty::TyVid) {
         debug_assert!(self.probe(a).is_unknown());
         debug_assert!(self.probe(b).is_unknown());
         self.eq_relations().union(a, b);
-        self.sub_relations().union(a, b);
+        self.sub_unification_table().union(a, b);
     }
 
-    /// Records that `a <: b`, depending on `dir`.
+    /// Records that `a` and `b` are related via subtyping. We don't track
+    /// which of the two is the subtype.
     ///
     /// Precondition: neither `a` nor `b` are known.
-    pub(crate) fn sub(&mut self, a: ty::TyVid, b: ty::TyVid) {
+    pub(crate) fn sub_unify(&mut self, a: ty::TyVid, b: ty::TyVid) {
         debug_assert!(self.probe(a).is_unknown());
         debug_assert!(self.probe(b).is_unknown());
-        self.sub_relations().union(a, b);
+        self.sub_unification_table().union(a, b);
     }
 
     /// Instantiates `vid` with the type `ty`.
@@ -206,7 +209,7 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
     ) -> ty::TyVid {
         let eq_key = self.eq_relations().new_key(TypeVariableValue::Unknown { universe });
 
-        let sub_key = self.sub_relations().new_key(());
+        let sub_key = self.sub_unification_table().new_key(());
         debug_assert_eq!(eq_key.vid, sub_key.vid);
 
         let index = self.storage.values.push(TypeVariableData { origin });
@@ -231,16 +234,16 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
         self.eq_relations().find(vid).vid
     }
 
-    /// Returns the "root" variable of `vid` in the `sub_relations`
-    /// equivalence table. All type variables that have been are
-    /// related via equality or subtyping will yield the same root
-    /// variable (per the union-find algorithm), so `sub_root_var(a)
-    /// == sub_root_var(b)` implies that:
+    /// Returns the "root" variable of `vid` in the `sub_unification_table`
+    /// equivalence table. All type variables that have been are related via
+    /// equality or subtyping will yield the same root variable (per the
+    /// union-find algorithm), so `sub_unification_table_root_var(a)
+    /// == sub_unification_table_root_var(b)` implies that:
     /// ```text
     /// exists X. (a <: X || X <: a) && (b <: X || X <: b)
     /// ```
-    pub(crate) fn sub_root_var(&mut self, vid: ty::TyVid) -> ty::TyVid {
-        self.sub_relations().find(vid).vid
+    pub(crate) fn sub_unification_table_root_var(&mut self, vid: ty::TyVid) -> ty::TyVid {
+        self.sub_unification_table().find(vid).vid
     }
 
     /// Retrieves the type to which `vid` has been instantiated, if
@@ -261,8 +264,8 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
     }
 
     #[inline]
-    fn sub_relations(&mut self) -> super::UnificationTable<'_, 'tcx, TyVidSubKey> {
-        self.storage.sub_relations.with_log(self.undo_log)
+    fn sub_unification_table(&mut self) -> super::UnificationTable<'_, 'tcx, TyVidSubKey> {
+        self.storage.sub_unification_table.with_log(self.undo_log)
     }
 
     /// Returns a range of the type variables created during the snapshot.
diff --git a/compiler/rustc_next_trait_solver/src/canonicalizer.rs b/compiler/rustc_next_trait_solver/src/canonicalizer.rs
index d42c62439f6eb..a8f2b4e8db662 100644
--- a/compiler/rustc_next_trait_solver/src/canonicalizer.rs
+++ b/compiler/rustc_next_trait_solver/src/canonicalizer.rs
@@ -67,6 +67,12 @@ pub struct Canonicalizer<'a, D: SolverDelegate<Interner = I>, I: Interner> {
     variables: &'a mut Vec<I::GenericArg>,
     var_kinds: Vec<CanonicalVarKind<I>>,
     variable_lookup_table: HashMap<I::GenericArg, usize>,
+    /// Maps each `sub_unification_table_root_var` to the index of the first
+    /// variable which used it.
+    ///
+    /// This means in case two type variables have the same sub relations root,
+    /// we set the `sub_root` of the second variable to the position of the first.
+    /// Otherwise the `sub_root` of each type variable is just its own position.
     sub_root_lookup_table: HashMap<ty::TyVid, usize>,
     binder_index: ty::DebruijnIndex,
 
@@ -273,7 +279,7 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
     }
 
     fn get_or_insert_sub_root(&mut self, vid: ty::TyVid) -> ty::BoundVar {
-        let root_vid = self.delegate.sub_root_ty_var(vid);
+        let root_vid = self.delegate.sub_unification_table_root_var(vid);
         let idx =
             *self.sub_root_lookup_table.entry(root_vid).or_insert_with(|| self.variables.len());
         ty::BoundVar::from(idx)
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
index f0f95e53265cc..71f9481d5af8b 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
@@ -900,8 +900,8 @@ where
             && goal.param_env.visit_with(&mut visitor).is_continue()
     }
 
-    pub(super) fn sub_ty_vids_raw(&self, a: ty::TyVid, b: ty::TyVid) {
-        self.delegate.sub_ty_vids_raw(a, b)
+    pub(super) fn sub_unify_ty_vids_raw(&self, a: ty::TyVid, b: ty::TyVid) {
+        self.delegate.sub_unify_ty_vids_raw(a, b)
     }
 
     #[instrument(level = "trace", skip(self, param_env), ret)]
diff --git a/compiler/rustc_next_trait_solver/src/solve/mod.rs b/compiler/rustc_next_trait_solver/src/solve/mod.rs
index 91b83e6cbbeb5..db3460c4ff676 100644
--- a/compiler/rustc_next_trait_solver/src/solve/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/mod.rs
@@ -121,7 +121,7 @@ where
     fn compute_subtype_goal(&mut self, goal: Goal<I, ty::SubtypePredicate<I>>) -> QueryResult<I> {
         match (goal.predicate.a.kind(), goal.predicate.b.kind()) {
             (ty::Infer(ty::TyVar(a_vid)), ty::Infer(ty::TyVar(b_vid))) => {
-                self.sub_ty_vids_raw(a_vid, b_vid);
+                self.sub_unify_ty_vids_raw(a_vid, b_vid);
                 self.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS)
             }
             _ => {
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 dff1311070ce6..edab530590b2a 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
@@ -894,7 +894,8 @@ impl<'a, 'tcx> FindInferSourceVisitor<'a, 'tcx> {
                 use ty::{Infer, TyVar};
                 match (inner_ty.kind(), target_ty.kind()) {
                     (&Infer(TyVar(a_vid)), &Infer(TyVar(b_vid))) => {
-                        self.tecx.sub_root_var(a_vid) == self.tecx.sub_root_var(b_vid)
+                        self.tecx.sub_unification_table_root_var(a_vid)
+                            == self.tecx.sub_unification_table_root_var(b_vid)
                     }
                     _ => false,
                 }
diff --git a/compiler/rustc_trait_selection/src/solve/delegate.rs b/compiler/rustc_trait_selection/src/solve/delegate.rs
index 44230624ddba4..16f444486a64f 100644
--- a/compiler/rustc_trait_selection/src/solve/delegate.rs
+++ b/compiler/rustc_trait_selection/src/solve/delegate.rs
@@ -128,7 +128,7 @@ impl<'tcx> rustc_next_trait_solver::delegate::SolverDelegate for SolverDelegate<
             | ty::PredicateKind::Coerce(ty::CoercePredicate { a, b }) => {
                 match (self.shallow_resolve(a).kind(), self.shallow_resolve(b).kind()) {
                     (&ty::Infer(ty::TyVar(a_vid)), &ty::Infer(ty::TyVar(b_vid))) => {
-                        self.sub_ty_vids_raw(a_vid, b_vid);
+                        self.sub_unify_ty_vids_raw(a_vid, b_vid);
                         Some(Certainty::AMBIGUOUS)
                     }
                     _ => None,
diff --git a/compiler/rustc_type_ir/src/infer_ctxt.rs b/compiler/rustc_type_ir/src/infer_ctxt.rs
index 7fec869f10078..56962b4597b88 100644
--- a/compiler/rustc_type_ir/src/infer_ctxt.rs
+++ b/compiler/rustc_type_ir/src/infer_ctxt.rs
@@ -158,7 +158,7 @@ pub trait InferCtxtLike: Sized {
     fn universe_of_ct(&self, ct: ty::ConstVid) -> Option<ty::UniverseIndex>;
 
     fn root_ty_var(&self, var: ty::TyVid) -> ty::TyVid;
-    fn sub_root_ty_var(&self, var: ty::TyVid) -> ty::TyVid;
+    fn sub_unification_table_root_var(&self, var: ty::TyVid) -> ty::TyVid;
     fn root_const_var(&self, var: ty::ConstVid) -> ty::ConstVid;
 
     fn opportunistic_resolve_ty_var(&self, vid: ty::TyVid) -> <Self::Interner as Interner>::Ty;
@@ -198,7 +198,7 @@ pub trait InferCtxtLike: Sized {
     ) -> U;
 
     fn equate_ty_vids_raw(&self, a: ty::TyVid, b: ty::TyVid);
-    fn sub_ty_vids_raw(&self, a: ty::TyVid, b: ty::TyVid);
+    fn sub_unify_ty_vids_raw(&self, a: ty::TyVid, b: ty::TyVid);
     fn equate_int_vids_raw(&self, a: ty::IntVid, b: ty::IntVid);
     fn equate_float_vids_raw(&self, a: ty::FloatVid, b: ty::FloatVid);
     fn equate_const_vids_raw(&self, a: ty::ConstVid, b: ty::ConstVid);

From 7e826fb14be36b4faf879c3aa1fe1a50b5750a5b Mon Sep 17 00:00:00 2001
From: Daria Sukhonina <dariasukhonina@gmail.com>
Date: Mon, 8 Sep 2025 15:27:29 +0300
Subject: [PATCH 0661/1889] Make `is_typeck_child` match exhaustive

---
 compiler/rustc_hir/src/def.rs | 32 +++++++++++++++++++++++++++++++-
 1 file changed, 31 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_hir/src/def.rs b/compiler/rustc_hir/src/def.rs
index d563fd0a54728..95abe5c40dd43 100644
--- a/compiler/rustc_hir/src/def.rs
+++ b/compiler/rustc_hir/src/def.rs
@@ -445,7 +445,37 @@ impl DefKind {
     /// type-checking context, i.e. closure, coroutine or inline const.
     #[inline]
     pub fn is_typeck_child(self) -> bool {
-        matches!(self, DefKind::Closure | DefKind::InlineConst | DefKind::SyntheticCoroutineBody)
+        match self {
+            DefKind::Closure | DefKind::InlineConst | DefKind::SyntheticCoroutineBody => true,
+            DefKind::Mod
+            | DefKind::Struct
+            | DefKind::Union
+            | DefKind::Enum
+            | DefKind::Variant
+            | DefKind::Trait
+            | DefKind::TyAlias
+            | DefKind::ForeignTy
+            | DefKind::TraitAlias
+            | DefKind::AssocTy
+            | DefKind::TyParam
+            | DefKind::Fn
+            | DefKind::Const
+            | DefKind::ConstParam
+            | DefKind::Static { .. }
+            | DefKind::Ctor(_, _)
+            | DefKind::AssocFn
+            | DefKind::AssocConst
+            | DefKind::Macro(_)
+            | DefKind::ExternCrate
+            | DefKind::Use
+            | DefKind::ForeignMod
+            | DefKind::AnonConst
+            | DefKind::OpaqueTy
+            | DefKind::Field
+            | DefKind::LifetimeParam
+            | DefKind::GlobalAsm
+            | DefKind::Impl { .. } => false,
+        }
     }
 }
 

From 2f0c1035ed7a1ad2348565c8d3fc4c5c3e758a24 Mon Sep 17 00:00:00 2001
From: Jeremy Smart <jeremy3141592@gmail.com>
Date: Wed, 27 Aug 2025 10:04:05 -0400
Subject: [PATCH 0662/1889] fix APITIT being treated as a normal generic
 parameter in suggestions

---
 compiler/rustc_hir_analysis/src/check/mod.rs  | 73 ++++++++++++-------
 .../apitit-unimplemented-method.rs            | 12 +++
 .../apitit-unimplemented-method.stderr        | 12 +++
 tests/ui/suggestions/auxiliary/dep.rs         |  4 +
 4 files changed, 74 insertions(+), 27 deletions(-)
 create mode 100644 tests/ui/suggestions/apitit-unimplemented-method.rs
 create mode 100644 tests/ui/suggestions/apitit-unimplemented-method.stderr
 create mode 100644 tests/ui/suggestions/auxiliary/dep.rs

diff --git a/compiler/rustc_hir_analysis/src/check/mod.rs b/compiler/rustc_hir_analysis/src/check/mod.rs
index 85445cb3c004d..e4c1e304c4b3d 100644
--- a/compiler/rustc_hir_analysis/src/check/mod.rs
+++ b/compiler/rustc_hir_analysis/src/check/mod.rs
@@ -85,7 +85,9 @@ use rustc_infer::traits::ObligationCause;
 use rustc_middle::query::Providers;
 use rustc_middle::ty::error::{ExpectedFound, TypeError};
 use rustc_middle::ty::print::with_types_for_signature;
-use rustc_middle::ty::{self, GenericArgs, GenericArgsRef, Ty, TyCtxt, TypingMode};
+use rustc_middle::ty::{
+    self, GenericArgs, GenericArgsRef, GenericParamDefKind, Ty, TyCtxt, TypingMode,
+};
 use rustc_middle::{bug, span_bug};
 use rustc_session::parse::feature_err;
 use rustc_span::def_id::CRATE_DEF_ID;
@@ -232,8 +234,7 @@ fn missing_items_err(
     };
 
     // Obtain the level of indentation ending in `sugg_sp`.
-    let padding =
-        tcx.sess.source_map().indentation_before(sugg_sp).unwrap_or_else(|| String::new());
+    let padding = tcx.sess.source_map().indentation_before(sugg_sp).unwrap_or_else(String::new);
     let (mut missing_trait_item, mut missing_trait_item_none, mut missing_trait_item_label) =
         (Vec::new(), Vec::new(), Vec::new());
 
@@ -330,6 +331,7 @@ fn default_body_is_unstable(
 fn bounds_from_generic_predicates<'tcx>(
     tcx: TyCtxt<'tcx>,
     predicates: impl IntoIterator<Item = (ty::Clause<'tcx>, Span)>,
+    assoc: ty::AssocItem,
 ) -> (String, String) {
     let mut types: FxIndexMap<Ty<'tcx>, Vec<DefId>> = FxIndexMap::default();
     let mut projections = vec![];
@@ -353,34 +355,50 @@ fn bounds_from_generic_predicates<'tcx>(
     }
 
     let mut where_clauses = vec![];
-    let mut types_str = vec![];
-    for (ty, bounds) in types {
-        if let ty::Param(_) = ty.kind() {
-            let mut bounds_str = vec![];
-            for bound in bounds {
-                let mut projections_str = vec![];
-                for projection in &projections {
-                    let p = projection.skip_binder();
-                    if bound == tcx.parent(p.projection_term.def_id)
-                        && p.projection_term.self_ty() == ty
-                    {
-                        let name = tcx.item_name(p.projection_term.def_id);
-                        projections_str.push(format!("{} = {}", name, p.term));
+    let generics = tcx.generics_of(assoc.def_id);
+    let types_str = generics
+        .own_params
+        .iter()
+        .filter(|p| matches!(p.kind, GenericParamDefKind::Type { synthetic: false, .. }))
+        .map(|p| {
+            // we just checked that it's a type, so the unwrap can't fail
+            let ty = tcx.mk_param_from_def(p).as_type().unwrap();
+            if let Some(bounds) = types.get(&ty) {
+                let mut bounds_str = vec![];
+                for bound in bounds.iter().copied() {
+                    let mut projections_str = vec![];
+                    for projection in &projections {
+                        let p = projection.skip_binder();
+                        if bound == tcx.parent(p.projection_term.def_id)
+                            && p.projection_term.self_ty() == ty
+                        {
+                            let name = tcx.item_name(p.projection_term.def_id);
+                            projections_str.push(format!("{} = {}", name, p.term));
+                        }
+                    }
+                    let bound_def_path = tcx.def_path_str(bound);
+                    if projections_str.is_empty() {
+                        where_clauses.push(format!("{}: {}", ty, bound_def_path));
+                    } else {
+                        bounds_str.push(format!(
+                            "{}<{}>",
+                            bound_def_path,
+                            projections_str.join(", ")
+                        ));
                     }
                 }
-                let bound_def_path = tcx.def_path_str(bound);
-                if projections_str.is_empty() {
-                    where_clauses.push(format!("{}: {}", ty, bound_def_path));
+                if bounds_str.is_empty() {
+                    ty.to_string()
                 } else {
-                    bounds_str.push(format!("{}<{}>", bound_def_path, projections_str.join(", ")));
+                    format!("{}: {}", ty, bounds_str.join(" + "))
                 }
-            }
-            if bounds_str.is_empty() {
-                types_str.push(ty.to_string());
             } else {
-                types_str.push(format!("{}: {}", ty, bounds_str.join(" + ")));
+                ty.to_string()
             }
-        } else {
+        })
+        .collect::<Vec<_>>();
+    for (ty, bounds) in types.into_iter() {
+        if !matches!(ty.kind(), ty::Param(_)) {
             // Avoid suggesting the following:
             // fn foo<T, <T as Trait>::Bar>(_: T) where T: Trait, <T as Trait>::Bar: Other {}
             where_clauses.extend(
@@ -472,10 +490,10 @@ fn fn_sig_suggestion<'tcx>(
     let output = if !output.is_unit() { format!(" -> {output}") } else { String::new() };
 
     let safety = sig.safety.prefix_str();
-    let (generics, where_clauses) = bounds_from_generic_predicates(tcx, predicates);
+    let (generics, where_clauses) = bounds_from_generic_predicates(tcx, predicates, assoc);
 
     // FIXME: this is not entirely correct, as the lifetimes from borrowed params will
-    // not be present in the `fn` definition, not will we account for renamed
+    // not be present in the `fn` definition, nor will we account for renamed
     // lifetimes between the `impl` and the `trait`, but this should be good enough to
     // fill in a significant portion of the missing code, and other subsequent
     // suggestions can help the user fix the code.
@@ -511,6 +529,7 @@ fn suggestion_signature<'tcx>(
             let (generics, where_clauses) = bounds_from_generic_predicates(
                 tcx,
                 tcx.predicates_of(assoc.def_id).instantiate_own(tcx, args),
+                assoc,
             );
             format!("type {}{generics} = /* Type */{where_clauses};", assoc.name())
         }
diff --git a/tests/ui/suggestions/apitit-unimplemented-method.rs b/tests/ui/suggestions/apitit-unimplemented-method.rs
new file mode 100644
index 0000000000000..b182e1939b3e3
--- /dev/null
+++ b/tests/ui/suggestions/apitit-unimplemented-method.rs
@@ -0,0 +1,12 @@
+//@ aux-build:dep.rs
+
+extern crate dep;
+use dep::*;
+
+struct Local;
+impl Trait for Local {}
+//~^ ERROR not all trait items implemented
+//~| HELP implement the missing item: `fn foo(_: impl Sized) { todo!() }`
+//~| HELP implement the missing item: `fn bar<T>(_: impl Sized) { todo!() }`
+
+fn main() {}
diff --git a/tests/ui/suggestions/apitit-unimplemented-method.stderr b/tests/ui/suggestions/apitit-unimplemented-method.stderr
new file mode 100644
index 0000000000000..b309a64e95829
--- /dev/null
+++ b/tests/ui/suggestions/apitit-unimplemented-method.stderr
@@ -0,0 +1,12 @@
+error[E0046]: not all trait items implemented, missing: `foo`, `bar`
+  --> $DIR/apitit-unimplemented-method.rs:7:1
+   |
+LL | impl Trait for Local {}
+   | ^^^^^^^^^^^^^^^^^^^^ missing `foo`, `bar` in implementation
+   |
+   = help: implement the missing item: `fn foo(_: impl Sized) { todo!() }`
+   = help: implement the missing item: `fn bar<T>(_: impl Sized) { todo!() }`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/suggestions/auxiliary/dep.rs b/tests/ui/suggestions/auxiliary/dep.rs
new file mode 100644
index 0000000000000..ac0de418313c0
--- /dev/null
+++ b/tests/ui/suggestions/auxiliary/dep.rs
@@ -0,0 +1,4 @@
+pub trait Trait {
+    fn foo(_: impl Sized);
+    fn bar<T>(_: impl Sized);
+}

From edc94e61841506c6957e1ee0ed57a2232fe339c4 Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Sun, 7 Sep 2025 23:20:40 +0200
Subject: [PATCH 0663/1889] mark `format_args_nl!` as `#[doc(hidden)]`

---
 library/core/src/macros/mod.rs   | 1 +
 src/librustdoc/html/highlight.rs | 2 +-
 src/librustdoc/lib.rs            | 1 -
 3 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/library/core/src/macros/mod.rs b/library/core/src/macros/mod.rs
index ccf41dfb01dd1..3f58fc448aa68 100644
--- a/library/core/src/macros/mod.rs
+++ b/library/core/src/macros/mod.rs
@@ -1017,6 +1017,7 @@ pub(crate) mod builtin {
     )]
     #[allow_internal_unstable(fmt_internals)]
     #[rustc_builtin_macro]
+    #[doc(hidden)]
     #[macro_export]
     macro_rules! format_args_nl {
         ($fmt:expr) => {{ /* compiler built-in */ }};
diff --git a/src/librustdoc/html/highlight.rs b/src/librustdoc/html/highlight.rs
index feafb41dc9905..0e06361024b9f 100644
--- a/src/librustdoc/html/highlight.rs
+++ b/src/librustdoc/html/highlight.rs
@@ -578,7 +578,7 @@ pub(super) fn write_code(
 }
 
 fn write_footer(out: &mut String, playground_button: Option<&str>) {
-    write_str(out, format_args_nl!("</code></pre>{}</div>", playground_button.unwrap_or_default()));
+    write_str(out, format_args!("</code></pre>{}</div>", playground_button.unwrap_or_default()));
 }
 
 /// How a span of text is classified. Mostly corresponds to token kinds.
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index f62eba4b3c195..9871066b9eb51 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -10,7 +10,6 @@
 #![feature(box_patterns)]
 #![feature(debug_closure_helpers)]
 #![feature(file_buffered)]
-#![feature(format_args_nl)]
 #![feature(if_let_guard)]
 #![feature(iter_advance_by)]
 #![feature(iter_intersperse)]

From 469a80ec725556ec1be482983b0321a10eeb61f4 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Mon, 8 Sep 2025 08:08:43 -0500
Subject: [PATCH 0664/1889] all tidy extra checks now print what they do in
 present tense

---
 src/tools/tidy/src/extra_checks/mod.rs | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/tools/tidy/src/extra_checks/mod.rs b/src/tools/tidy/src/extra_checks/mod.rs
index 321ef65117e25..83e94b78c71f3 100644
--- a/src/tools/tidy/src/extra_checks/mod.rs
+++ b/src/tools/tidy/src/extra_checks/mod.rs
@@ -290,10 +290,10 @@ fn check_impl(
         args.extend_from_slice(SPELLCHECK_DIRS);
 
         if bless {
-            eprintln!("spellcheck files and fix");
+            eprintln!("spellchecking files and fixing typos");
             args.push("--write-changes");
         } else {
-            eprintln!("spellcheck files");
+            eprintln!("spellchecking files");
         }
         spellcheck_runner(root_path, &outdir, &cargo, &args)?;
     }
@@ -303,11 +303,17 @@ fn check_impl(
     }
 
     if js_lint {
+        if bless {
+            eprintln!("linting javascript files");
+        } else {
+            eprintln!("linting javascript files and applying suggestions");
+        }
         rustdoc_js::lint(outdir, librustdoc_path, tools_path, bless)?;
         rustdoc_js::es_check(outdir, librustdoc_path)?;
     }
 
     if js_typecheck {
+        eprintln!("typechecking javascript files");
         rustdoc_js::typecheck(outdir, librustdoc_path)?;
     }
 

From a9d884df81a1af5983eb01a94429ffc4b2803a08 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Mon, 8 Sep 2025 08:24:56 -0500
Subject: [PATCH 0665/1889] tidy: py:lint extra check now works with --bless

---
 src/tools/tidy/src/extra_checks/mod.rs | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/src/tools/tidy/src/extra_checks/mod.rs b/src/tools/tidy/src/extra_checks/mod.rs
index 83e94b78c71f3..5e7a686e775e8 100644
--- a/src/tools/tidy/src/extra_checks/mod.rs
+++ b/src/tools/tidy/src/extra_checks/mod.rs
@@ -147,9 +147,16 @@ fn check_impl(
     }
 
     if python_lint {
-        eprintln!("linting python files");
         let py_path = py_path.as_ref().unwrap();
-        let res = run_ruff(root_path, outdir, py_path, &cfg_args, &file_args, &["check".as_ref()]);
+        let args: &[&OsStr] = if bless {
+            eprintln!("linting python files and applying suggestions");
+            &["check".as_ref(), "--fix".as_ref()]
+        } else {
+            eprintln!("linting python files");
+            &["check".as_ref()]
+        };
+
+        let res = run_ruff(root_path, outdir, py_path, &cfg_args, &file_args, args);
 
         if res.is_err() && show_diff {
             eprintln!("\npython linting failed! Printing diff suggestions:");

From c19d81badb87c138483e950f7adcf86639ede76c Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Mon, 8 Sep 2025 08:53:20 -0500
Subject: [PATCH 0666/1889] tidy extra checks that interact with --bless now
 all recommend using it

---
 src/tools/tidy/src/extra_checks/mod.rs | 31 +++++++++++++++++++++-----
 1 file changed, 25 insertions(+), 6 deletions(-)

diff --git a/src/tools/tidy/src/extra_checks/mod.rs b/src/tools/tidy/src/extra_checks/mod.rs
index 5e7a686e775e8..a6b50b5ca4701 100644
--- a/src/tools/tidy/src/extra_checks/mod.rs
+++ b/src/tools/tidy/src/extra_checks/mod.rs
@@ -124,6 +124,12 @@ fn check_impl(
         };
     }
 
+    let rerun_with_bless = |mode: &str, action: &str| {
+        if !bless {
+            eprintln!("rerun tidy with `--extra-checks={mode} --bless` to {action}");
+        }
+    };
+
     let python_lint = extra_check!(Py, Lint);
     let python_fmt = extra_check!(Py, Fmt);
     let shell_lint = extra_check!(Shell, Lint);
@@ -158,10 +164,10 @@ fn check_impl(
 
         let res = run_ruff(root_path, outdir, py_path, &cfg_args, &file_args, args);
 
-        if res.is_err() && show_diff {
+        if res.is_err() && show_diff && !bless {
             eprintln!("\npython linting failed! Printing diff suggestions:");
 
-            let _ = run_ruff(
+            let diff_res = run_ruff(
                 root_path,
                 outdir,
                 py_path,
@@ -169,6 +175,10 @@ fn check_impl(
                 &file_args,
                 &["check".as_ref(), "--diff".as_ref()],
             );
+            // `ruff check --diff` will return status 0 if there are no suggestions.
+            if diff_res.is_err() {
+                rerun_with_bless("py:lint", "apply ruff suggestions");
+            }
         }
         // Rethrow error
         res?;
@@ -199,7 +209,7 @@ fn check_impl(
                     &["format".as_ref(), "--diff".as_ref()],
                 );
             }
-            eprintln!("rerun tidy with `--extra-checks=py:fmt --bless` to reformat Python code");
+            rerun_with_bless("py:fmt", "reformat Python code");
         }
 
         // Rethrow error
@@ -232,7 +242,7 @@ fn check_impl(
         let args = merge_args(&cfg_args_clang_format, &file_args_clang_format);
         let res = py_runner(py_path.as_ref().unwrap(), false, None, "clang-format", &args);
 
-        if res.is_err() && show_diff {
+        if res.is_err() && show_diff && !bless {
             eprintln!("\nclang-format linting failed! Printing diff suggestions:");
 
             let mut cfg_args_clang_format_diff = cfg_args.clone();
@@ -272,6 +282,7 @@ fn check_impl(
                     );
                 }
             }
+            rerun_with_bless("cpp:fmt", "reformat C++ code");
         }
         // Rethrow error
         res?;
@@ -302,7 +313,11 @@ fn check_impl(
         } else {
             eprintln!("spellchecking files");
         }
-        spellcheck_runner(root_path, &outdir, &cargo, &args)?;
+        let res = spellcheck_runner(root_path, &outdir, &cargo, &args);
+        if res.is_err() {
+            rerun_with_bless("spellcheck", "fix typos");
+        }
+        res?;
     }
 
     if js_lint || js_typecheck {
@@ -315,7 +330,11 @@ fn check_impl(
         } else {
             eprintln!("linting javascript files and applying suggestions");
         }
-        rustdoc_js::lint(outdir, librustdoc_path, tools_path, bless)?;
+        let res = rustdoc_js::lint(outdir, librustdoc_path, tools_path, bless);
+        if res.is_err() {
+            rerun_with_bless("js:lint", "apply eslint suggestions");
+        }
+        res?;
         rustdoc_js::es_check(outdir, librustdoc_path)?;
     }
 

From 8222f7d95bee2b91bddfd87a43949e4583047363 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Mon, 8 Sep 2025 08:56:12 -0500
Subject: [PATCH 0667/1889] tidy extra checks: use Error::FailedCheck correctly

---
 src/tools/tidy/src/extra_checks/rustdoc_js.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/tools/tidy/src/extra_checks/rustdoc_js.rs b/src/tools/tidy/src/extra_checks/rustdoc_js.rs
index a6c66b8be8029..5137e61836728 100644
--- a/src/tools/tidy/src/extra_checks/rustdoc_js.rs
+++ b/src/tools/tidy/src/extra_checks/rustdoc_js.rs
@@ -57,7 +57,7 @@ fn run_eslint(
             if exit_status.success() {
                 return Ok(());
             }
-            Err(super::Error::FailedCheck("eslint command failed"))
+            Err(super::Error::FailedCheck("eslint"))
         }
         Err(error) => Err(super::Error::Generic(format!("eslint command failed: {error:?}"))),
     }
@@ -94,7 +94,7 @@ pub(super) fn typecheck(outdir: &Path, librustdoc_path: &Path) -> Result<(), sup
             if exit_status.success() {
                 return Ok(());
             }
-            Err(super::Error::FailedCheck("tsc command failed"))
+            Err(super::Error::FailedCheck("tsc"))
         }
         Err(error) => Err(super::Error::Generic(format!("tsc command failed: {error:?}"))),
     }
@@ -112,7 +112,7 @@ pub(super) fn es_check(outdir: &Path, librustdoc_path: &Path) -> Result<(), supe
             if exit_status.success() {
                 return Ok(());
             }
-            Err(super::Error::FailedCheck("es-check command failed"))
+            Err(super::Error::FailedCheck("es-check"))
         }
         Err(error) => Err(super::Error::Generic(format!("es-check command failed: {error:?}"))),
     }

From ef95c63816bcc6f217601abf308b1b1561340731 Mon Sep 17 00:00:00 2001
From: Ariel Ben-Yehuda <me@arielby.net>
Date: Mon, 8 Sep 2025 14:08:26 +0000
Subject: [PATCH 0668/1889] disable core dumps for panic-uninitialized-zeroed

That test causes a large amount of crashes. If a system
has a /proc/sys/kernel/core_pattern that uploads core dumps enabled,
it will take a long time to complete. Set dumpable to 0 to avoid that.

Before:

$ time ./panic-uninitialized-zeroed

real    0m47.457s
user    0m0.023s
sys     0m0.021s

After:
$ ./panic-uninitialized-zeroed

real    0m0.029s
user    0m0.019s
sys     0m0.010s
---
 .../ui/intrinsics/panic-uninitialized-zeroed.rs | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/tests/ui/intrinsics/panic-uninitialized-zeroed.rs b/tests/ui/intrinsics/panic-uninitialized-zeroed.rs
index cdf8aa854826a..db2b4a6ad20a7 100644
--- a/tests/ui/intrinsics/panic-uninitialized-zeroed.rs
+++ b/tests/ui/intrinsics/panic-uninitialized-zeroed.rs
@@ -5,9 +5,10 @@
 //@ [strict]compile-flags: -Zstrict-init-checks
 //@ needs-subprocess
 //@ ignore-backends: gcc
+//@ edition:2024
 
 #![allow(deprecated, invalid_value)]
-#![feature(never_type)]
+#![feature(never_type, rustc_private)]
 
 use std::{
     mem::{self, MaybeUninit, ManuallyDrop},
@@ -15,6 +16,9 @@ use std::{
     num,
 };
 
+#[cfg(target_os = "linux")]
+extern crate libc;
+
 #[allow(dead_code)]
 struct Foo {
     x: u8,
@@ -108,6 +112,17 @@ fn test_panic_msg_only_if_strict<T>(op: impl (FnOnce() -> T) + 'static, msg: &st
 
 fn main() {
     unsafe {
+        #[cfg(target_os = "linux")]
+        {
+            // This test causes a large amount of crashes. If a system
+            // has a /proc/sys/kernel/core_pattern that uploads core dumps enabled,
+            // it will take a long time to complete. Set dumpable to 0 to avoid that.
+            if libc::prctl(libc::PR_SET_DUMPABLE, 0) < 0 {
+                let err = std::io::Error::last_os_error();
+                panic!("failed to disable core dumps {err:?}");
+            }
+        }
+
         // Uninhabited types
         test_panic_msg(
             || mem::uninitialized::<!>(),

From a21866a563836da1c47c1088f0e6085514c9595a Mon Sep 17 00:00:00 2001
From: Wilfred Hughes <wilfred@meta.com>
Date: Mon, 8 Sep 2025 15:56:56 +0100
Subject: [PATCH 0669/1889] Remove support for register_attr

This was removed in rustc in 2022: https://github.com/rust-lang/rust/pull/101123

Closes #20525.
---
 .../crates/hir-def/src/nameres.rs             |  9 -----
 .../hir-def/src/nameres/attr_resolution.rs    |  9 +----
 .../crates/hir-def/src/nameres/collector.rs   |  6 ---
 src/tools/rust-analyzer/crates/hir/src/lib.rs | 38 ++++---------------
 .../crates/hir/src/source_analyzer.rs         |  3 +-
 .../rust-analyzer/crates/ide-db/src/defs.rs   |  6 +--
 .../src/handlers/macro_error.rs               |  5 +--
 7 files changed, 14 insertions(+), 62 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-def/src/nameres.rs b/src/tools/rust-analyzer/crates/hir-def/src/nameres.rs
index bf6fc15b7d199..7d5e627964eb1 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/nameres.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/nameres.rs
@@ -192,8 +192,6 @@ struct DefMapCrateData {
     exported_derives: FxHashMap<MacroId, Box<[Name]>>,
     fn_proc_macro_mapping: FxHashMap<FunctionId, ProcMacroId>,
 
-    /// Custom attributes registered with `#![register_attr]`.
-    registered_attrs: Vec<Symbol>,
     /// Custom tool modules registered with `#![register_tool]`.
     registered_tools: Vec<Symbol>,
     /// Unstable features of Rust enabled with `#![feature(A, B)]`.
@@ -212,7 +210,6 @@ impl DefMapCrateData {
         Self {
             exported_derives: FxHashMap::default(),
             fn_proc_macro_mapping: FxHashMap::default(),
-            registered_attrs: Vec::new(),
             registered_tools: PREDEFINED_TOOLS.iter().map(|it| Symbol::intern(it)).collect(),
             unstable_features: FxHashSet::default(),
             rustc_coherence_is_core: false,
@@ -227,7 +224,6 @@ impl DefMapCrateData {
         let Self {
             exported_derives,
             fn_proc_macro_mapping,
-            registered_attrs,
             registered_tools,
             unstable_features,
             rustc_coherence_is_core: _,
@@ -238,7 +234,6 @@ impl DefMapCrateData {
         } = self;
         exported_derives.shrink_to_fit();
         fn_proc_macro_mapping.shrink_to_fit();
-        registered_attrs.shrink_to_fit();
         registered_tools.shrink_to_fit();
         unstable_features.shrink_to_fit();
     }
@@ -529,10 +524,6 @@ impl DefMap {
         &self.data.registered_tools
     }
 
-    pub fn registered_attrs(&self) -> &[Symbol] {
-        &self.data.registered_attrs
-    }
-
     pub fn is_unstable_feature_enabled(&self, feature: &Symbol) -> bool {
         self.data.unstable_features.contains(feature)
     }
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/nameres/attr_resolution.rs b/src/tools/rust-analyzer/crates/hir-def/src/nameres/attr_resolution.rs
index e7e96804ae737..2f56d608fcbf4 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/nameres/attr_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/nameres/attr_resolution.rs
@@ -90,13 +90,8 @@ impl DefMap {
                 return true;
             }
 
-            if segments.len() == 1 {
-                if find_builtin_attr_idx(name).is_some() {
-                    return true;
-                }
-                if self.data.registered_attrs.iter().any(pred) {
-                    return true;
-                }
+            if segments.len() == 1 && find_builtin_attr_idx(name).is_some() {
+                return true;
             }
         }
         false
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/nameres/collector.rs b/src/tools/rust-analyzer/crates/hir-def/src/nameres/collector.rs
index 0f84728dcb4a8..a2ce538356515 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/nameres/collector.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/nameres/collector.rs
@@ -298,12 +298,6 @@ impl<'db> DefCollector<'db> {
                         );
                     crate_data.unstable_features.extend(features);
                 }
-                () if *attr_name == sym::register_attr => {
-                    if let Some(ident) = attr.single_ident_value() {
-                        crate_data.registered_attrs.push(ident.sym.clone());
-                        cov_mark::hit!(register_attr);
-                    }
-                }
                 () if *attr_name == sym::register_tool => {
                     if let Some(ident) = attr.single_ident_value() {
                         crate_data.registered_tools.push(ident.sym.clone());
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index 6610375451dd0..6eb8a8bf60fd1 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -4060,49 +4060,25 @@ impl DeriveHelper {
     }
 }
 
-// FIXME: Wrong name? This is could also be a registered attribute
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct BuiltinAttr {
-    krate: Option<base_db::Crate>,
     idx: u32,
 }
 
 impl BuiltinAttr {
-    // FIXME: consider crates\hir_def\src\nameres\attr_resolution.rs?
-    pub(crate) fn by_name(db: &dyn HirDatabase, krate: Crate, name: &str) -> Option<Self> {
-        if let builtin @ Some(_) = Self::builtin(name) {
-            return builtin;
-        }
-        let idx = crate_def_map(db, krate.id)
-            .registered_attrs()
-            .iter()
-            .position(|it| it.as_str() == name)? as u32;
-        Some(BuiltinAttr { krate: Some(krate.id), idx })
-    }
-
     fn builtin(name: &str) -> Option<Self> {
         hir_expand::inert_attr_macro::find_builtin_attr_idx(&Symbol::intern(name))
-            .map(|idx| BuiltinAttr { krate: None, idx: idx as u32 })
+            .map(|idx| BuiltinAttr { idx: idx as u32 })
     }
 
-    pub fn name(&self, db: &dyn HirDatabase) -> Name {
-        match self.krate {
-            Some(krate) => Name::new_symbol_root(
-                crate_def_map(db, krate).registered_attrs()[self.idx as usize].clone(),
-            ),
-            None => Name::new_symbol_root(Symbol::intern(
-                hir_expand::inert_attr_macro::INERT_ATTRIBUTES[self.idx as usize].name,
-            )),
-        }
+    pub fn name(&self) -> Name {
+        Name::new_symbol_root(Symbol::intern(
+            hir_expand::inert_attr_macro::INERT_ATTRIBUTES[self.idx as usize].name,
+        ))
     }
 
-    pub fn template(&self, _: &dyn HirDatabase) -> Option<AttributeTemplate> {
-        match self.krate {
-            Some(_) => None,
-            None => {
-                Some(hir_expand::inert_attr_macro::INERT_ATTRIBUTES[self.idx as usize].template)
-            }
-        }
+    pub fn template(&self) -> Option<AttributeTemplate> {
+        Some(hir_expand::inert_attr_macro::INERT_ATTRIBUTES[self.idx as usize].template)
     }
 }
 
diff --git a/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs b/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
index dbc2539a9b91c..539b25387aef0 100644
--- a/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
@@ -1062,8 +1062,7 @@ impl<'db> SourceAnalyzer<'db> {
             // in this case we have to check for inert/builtin attributes and tools and prioritize
             // resolution of attributes over other namespaces
             if let Some(name_ref) = path.as_single_name_ref() {
-                let builtin =
-                    BuiltinAttr::by_name(db, self.resolver.krate().into(), &name_ref.text());
+                let builtin = BuiltinAttr::builtin(&name_ref.text());
                 if builtin.is_some() {
                     return builtin.map(|it| (PathResolution::BuiltinAttr(it), None));
                 }
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/defs.rs b/src/tools/rust-analyzer/crates/ide-db/src/defs.rs
index 61a21ccf2f775..44ff9d6006d66 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/defs.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/defs.rs
@@ -259,8 +259,8 @@ impl Definition {
             Definition::ExternCrateDecl(it) => it.docs_with_rangemap(db),
 
             Definition::BuiltinAttr(it) => {
-                let name = it.name(db);
-                let AttributeTemplate { word, list, name_value_str } = it.template(db)?;
+                let name = it.name();
+                let AttributeTemplate { word, list, name_value_str } = it.template()?;
                 let mut docs = "Valid forms are:".to_owned();
                 if word {
                     format_to!(docs, "\n - #\\[{}]", name.display(db, display_target.edition));
@@ -348,7 +348,7 @@ impl Definition {
             Definition::Label(it) => it.name(db).display(db, display_target.edition).to_string(),
             Definition::ExternCrateDecl(it) => it.display(db, display_target).to_string(),
             Definition::BuiltinAttr(it) => {
-                format!("#[{}]", it.name(db).display(db, display_target.edition))
+                format!("#[{}]", it.name().display(db, display_target.edition))
             }
             Definition::ToolModule(it) => {
                 it.name(db).display(db, display_target.edition).to_string()
diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/macro_error.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/macro_error.rs
index c39e00e178f81..6a1ecae651501 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/macro_error.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/macro_error.rs
@@ -144,16 +144,13 @@ macro_rules! concat { () => {} }
     }
 
     #[test]
-    fn register_attr_and_tool() {
-        cov_mark::check!(register_attr);
+    fn register_tool() {
         cov_mark::check!(register_tool);
         check_diagnostics(
             r#"
 #![register_tool(tool)]
-#![register_attr(attr)]
 
 #[tool::path]
-#[attr]
 struct S;
 "#,
         );

From 207a01e88f05f028f7a6c0db0d324fbedb8178a4 Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Tue, 12 Aug 2025 18:37:07 +0200
Subject: [PATCH 0670/1889] std: make address resolution weirdness local to SGX

---
 library/std/src/io/error.rs                   |   3 +
 library/std/src/net/mod.rs                    |  21 ----
 library/std/src/net/tcp.rs                    |   4 +-
 library/std/src/net/tcp/tests.rs              |   2 +-
 library/std/src/net/udp.rs                    |   4 +-
 library/std/src/net/udp/tests.rs              |   1 +
 library/std/src/sys/net/connection/mod.rs     |  57 +++++++++
 library/std/src/sys/net/connection/sgx.rs     |  81 +++++++++----
 .../connection/{socket.rs => socket/mod.rs}   | 108 +++++++++---------
 .../std/src/sys/net/connection/uefi/mod.rs    |  27 +++--
 .../std/src/sys/net/connection/unsupported.rs |  10 +-
 library/std/src/sys/net/connection/wasip1.rs  |  10 +-
 .../sys/net/connection/xous/tcplistener.rs    |  26 +++--
 .../src/sys/net/connection/xous/tcpstream.rs  |   9 +-
 .../std/src/sys/net/connection/xous/udp.rs    |  81 +++++++------
 library/std/src/sys/net/mod.rs                |  48 +-------
 16 files changed, 276 insertions(+), 216 deletions(-)
 create mode 100644 library/std/src/sys/net/connection/mod.rs
 rename library/std/src/sys/net/connection/{socket.rs => socket/mod.rs} (90%)

diff --git a/library/std/src/io/error.rs b/library/std/src/io/error.rs
index 57a980d6acdb5..21e82d43a800c 100644
--- a/library/std/src/io/error.rs
+++ b/library/std/src/io/error.rs
@@ -95,6 +95,9 @@ impl Error {
 
     pub(crate) const ZERO_TIMEOUT: Self =
         const_error!(ErrorKind::InvalidInput, "cannot set a 0 duration timeout");
+
+    pub(crate) const NO_ADDRESSES: Self =
+        const_error!(ErrorKind::InvalidInput, "could not resolve to any addresses");
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
diff --git a/library/std/src/net/mod.rs b/library/std/src/net/mod.rs
index ddd3b68dd2d63..40f1a93e39ded 100644
--- a/library/std/src/net/mod.rs
+++ b/library/std/src/net/mod.rs
@@ -34,7 +34,6 @@ pub use self::tcp::IntoIncoming;
 pub use self::tcp::{Incoming, TcpListener, TcpStream};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use self::udp::UdpSocket;
-use crate::io::{self, ErrorKind};
 
 mod ip_addr;
 mod socket_addr;
@@ -67,23 +66,3 @@ pub enum Shutdown {
     #[stable(feature = "rust1", since = "1.0.0")]
     Both,
 }
-
-fn each_addr<A: ToSocketAddrs, F, T>(addr: A, mut f: F) -> io::Result<T>
-where
-    F: FnMut(io::Result<&SocketAddr>) -> io::Result<T>,
-{
-    let addrs = match addr.to_socket_addrs() {
-        Ok(addrs) => addrs,
-        Err(e) => return f(Err(e)),
-    };
-    let mut last_err = None;
-    for addr in addrs {
-        match f(Ok(&addr)) {
-            Ok(l) => return Ok(l),
-            Err(e) => last_err = Some(e),
-        }
-    }
-    Err(last_err.unwrap_or_else(|| {
-        io::const_error!(ErrorKind::InvalidInput, "could not resolve to any addresses")
-    }))
-}
diff --git a/library/std/src/net/tcp.rs b/library/std/src/net/tcp.rs
index 10685b4931949..ae50f531a7162 100644
--- a/library/std/src/net/tcp.rs
+++ b/library/std/src/net/tcp.rs
@@ -167,7 +167,7 @@ impl TcpStream {
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn connect<A: ToSocketAddrs>(addr: A) -> io::Result<TcpStream> {
-        super::each_addr(addr, net_imp::TcpStream::connect).map(TcpStream)
+        net_imp::TcpStream::connect(addr).map(TcpStream)
     }
 
     /// Opens a TCP connection to a remote host with a timeout.
@@ -782,7 +782,7 @@ impl TcpListener {
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn bind<A: ToSocketAddrs>(addr: A) -> io::Result<TcpListener> {
-        super::each_addr(addr, net_imp::TcpListener::bind).map(TcpListener)
+        net_imp::TcpListener::bind(addr).map(TcpListener)
     }
 
     /// Returns the local socket address of this listener.
diff --git a/library/std/src/net/tcp/tests.rs b/library/std/src/net/tcp/tests.rs
index 03003037b295c..7c7ef7b2f7018 100644
--- a/library/std/src/net/tcp/tests.rs
+++ b/library/std/src/net/tcp/tests.rs
@@ -1,5 +1,5 @@
 use crate::io::prelude::*;
-use crate::io::{BorrowedBuf, IoSlice, IoSliceMut};
+use crate::io::{BorrowedBuf, ErrorKind, IoSlice, IoSliceMut};
 use crate::mem::MaybeUninit;
 use crate::net::test::{next_test_ip4, next_test_ip6};
 use crate::net::*;
diff --git a/library/std/src/net/udp.rs b/library/std/src/net/udp.rs
index a97b3299774bb..72e292e3d157c 100644
--- a/library/std/src/net/udp.rs
+++ b/library/std/src/net/udp.rs
@@ -120,7 +120,7 @@ impl UdpSocket {
     /// [`Ipv4Addr::UNSPECIFIED`] or [`Ipv6Addr::UNSPECIFIED`].
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn bind<A: ToSocketAddrs>(addr: A) -> io::Result<UdpSocket> {
-        super::each_addr(addr, net_imp::UdpSocket::bind).map(UdpSocket)
+        net_imp::UdpSocket::bind(addr).map(UdpSocket)
     }
 
     /// Receives a single datagram message on the socket. On success, returns the number
@@ -677,7 +677,7 @@ impl UdpSocket {
     /// on the platform.
     #[stable(feature = "net2_mutators", since = "1.9.0")]
     pub fn connect<A: ToSocketAddrs>(&self, addr: A) -> io::Result<()> {
-        super::each_addr(addr, |addr| self.0.connect(addr))
+        self.0.connect(addr)
     }
 
     /// Sends data on the socket to the remote address to which it is connected.
diff --git a/library/std/src/net/udp/tests.rs b/library/std/src/net/udp/tests.rs
index 91da3135f97c6..0638b36c54f9d 100644
--- a/library/std/src/net/udp/tests.rs
+++ b/library/std/src/net/udp/tests.rs
@@ -1,3 +1,4 @@
+use crate::io::ErrorKind;
 use crate::net::test::{compare_ignore_zoneid, next_test_ip4, next_test_ip6};
 use crate::net::*;
 use crate::sync::mpsc::channel;
diff --git a/library/std/src/sys/net/connection/mod.rs b/library/std/src/sys/net/connection/mod.rs
new file mode 100644
index 0000000000000..7f9636a8ccfd6
--- /dev/null
+++ b/library/std/src/sys/net/connection/mod.rs
@@ -0,0 +1,57 @@
+cfg_select! {
+    any(
+        all(target_family = "unix", not(target_os = "l4re")),
+        target_os = "windows",
+        target_os = "hermit",
+        all(target_os = "wasi", target_env = "p2"),
+        target_os = "solid_asp3",
+    ) => {
+        mod socket;
+        pub use socket::*;
+    }
+    all(target_vendor = "fortanix", target_env = "sgx") => {
+        mod sgx;
+        pub use sgx::*;
+    }
+    all(target_os = "wasi", target_env = "p1") => {
+        mod wasip1;
+        pub use wasip1::*;
+    }
+    target_os = "xous" => {
+        mod xous;
+        pub use xous::*;
+    }
+    target_os = "uefi" => {
+        mod uefi;
+        pub use uefi::*;
+    }
+    _ => {
+        mod unsupported;
+        pub use unsupported::*;
+    }
+}
+
+#[cfg_attr(
+    // Make sure that this is used on some platforms at least.
+    not(any(target_os = "linux", target_os = "windows")),
+    allow(dead_code)
+)]
+fn each_addr<A: crate::net::ToSocketAddrs, F, T>(addr: A, mut f: F) -> crate::io::Result<T>
+where
+    F: FnMut(&crate::net::SocketAddr) -> crate::io::Result<T>,
+{
+    use crate::io::Error;
+
+    let mut last_err = None;
+    for addr in addr.to_socket_addrs()? {
+        match f(&addr) {
+            Ok(l) => return Ok(l),
+            Err(e) => last_err = Some(e),
+        }
+    }
+
+    match last_err {
+        Some(err) => Err(err),
+        None => Err(Error::NO_ADDRESSES),
+    }
+}
diff --git a/library/std/src/sys/net/connection/sgx.rs b/library/std/src/sys/net/connection/sgx.rs
index 2389fd1bcb6ca..9b54571997d0b 100644
--- a/library/std/src/sys/net/connection/sgx.rs
+++ b/library/std/src/sys/net/connection/sgx.rs
@@ -1,3 +1,5 @@
+use crate::error;
+use crate::fmt::{self, Write};
 use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut};
 use crate::net::{Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr, ToSocketAddrs};
 use crate::sync::Arc;
@@ -5,7 +7,6 @@ use crate::sys::abi::usercalls;
 use crate::sys::fd::FileDesc;
 use crate::sys::{AsInner, FromInner, IntoInner, TryIntoInner, sgx_ineffective, unsupported};
 use crate::time::Duration;
-use crate::{error, fmt};
 
 const DEFAULT_FAKE_TTL: u32 = 64;
 
@@ -63,18 +64,52 @@ impl fmt::Debug for TcpStream {
     }
 }
 
-fn io_err_to_addr(result: io::Result<&SocketAddr>) -> io::Result<String> {
-    match result {
-        Ok(saddr) => Ok(saddr.to_string()),
-        // need to downcast twice because io::Error::into_inner doesn't return the original
-        // value if the conversion fails
-        Err(e) => {
-            if e.get_ref().and_then(|e| e.downcast_ref::<NonIpSockAddr>()).is_some() {
-                Ok(e.into_inner().unwrap().downcast::<NonIpSockAddr>().unwrap().host)
-            } else {
-                Err(e)
+/// Converts each address in `addr` into a hostname.
+///
+/// SGX doesn't support DNS resolution but rather accepts hostnames in
+/// the same place as socket addresses. So, to make e.g.
+/// ```rust
+/// TcpStream::connect("example.com:80")`
+/// ```
+/// work, the DNS lookup returns a special error (`NonIpSockAddr`) instead,
+/// which contains the hostname being looked up. When `.to_socket_addrs()`
+/// fails, we inspect the error and try recover the hostname from it. If that
+/// succeeds, we thus continue with the hostname.
+///
+/// This is a terrible hack and leads to buggy code. For instance, when users
+/// use the result of `.to_socket_addrs()` in their own `ToSocketAddrs`
+/// implementation to select from a list of possible URLs, the only URL used
+/// will be that of the last item tried.
+// FIXME: This is a terrible, terrible hack. Fixing this requires Fortanix to
+// add a method for resolving addresses.
+fn each_addr<A: ToSocketAddrs, F, T>(addr: A, mut f: F) -> io::Result<T>
+where
+    F: FnMut(&str) -> io::Result<T>,
+{
+    match addr.to_socket_addrs() {
+        Ok(addrs) => {
+            let mut last_err = None;
+            let mut encoded = String::new();
+            for addr in addrs {
+                // Format the IP address as a string, reusing the buffer.
+                encoded.clear();
+                write!(encoded, "{}", &addr).unwrap();
+
+                match f(&encoded) {
+                    Ok(val) => return Ok(val),
+                    Err(err) => last_err = Some(err),
+                }
+            }
+
+            match last_err {
+                Some(err) => Err(err),
+                None => Err(io::Error::NO_ADDRESSES),
             }
         }
+        Err(err) => match err.get_ref().and_then(|e| e.downcast_ref::<NonIpSockAddr>()) {
+            Some(NonIpSockAddr { host }) => f(host),
+            None => Err(err),
+        },
     }
 }
 
@@ -86,17 +121,18 @@ fn addr_to_sockaddr(addr: Option<&str>) -> io::Result<SocketAddr> {
 }
 
 impl TcpStream {
-    pub fn connect(addr: io::Result<&SocketAddr>) -> io::Result<TcpStream> {
-        let addr = io_err_to_addr(addr)?;
-        let (fd, local_addr, peer_addr) = usercalls::connect_stream(&addr)?;
-        Ok(TcpStream { inner: Socket::new(fd, local_addr), peer_addr: Some(peer_addr) })
+    pub fn connect<A: ToSocketAddrs>(addr: A) -> io::Result<TcpStream> {
+        each_addr(addr, |addr| {
+            let (fd, local_addr, peer_addr) = usercalls::connect_stream(addr)?;
+            Ok(TcpStream { inner: Socket::new(fd, local_addr), peer_addr: Some(peer_addr) })
+        })
     }
 
     pub fn connect_timeout(addr: &SocketAddr, dur: Duration) -> io::Result<TcpStream> {
         if dur == Duration::default() {
             return Err(io::Error::ZERO_TIMEOUT);
         }
-        Self::connect(Ok(addr)) // FIXME: ignoring timeout
+        Self::connect(addr) // FIXME: ignoring timeout
     }
 
     pub fn set_read_timeout(&self, dur: Option<Duration>) -> io::Result<()> {
@@ -247,10 +283,11 @@ impl fmt::Debug for TcpListener {
 }
 
 impl TcpListener {
-    pub fn bind(addr: io::Result<&SocketAddr>) -> io::Result<TcpListener> {
-        let addr = io_err_to_addr(addr)?;
-        let (fd, local_addr) = usercalls::bind_stream(&addr)?;
-        Ok(TcpListener { inner: Socket::new(fd, local_addr) })
+    pub fn bind<A: ToSocketAddrs>(addr: A) -> io::Result<TcpListener> {
+        each_addr(addr, |addr| {
+            let (fd, local_addr) = usercalls::bind_stream(addr)?;
+            Ok(TcpListener { inner: Socket::new(fd, local_addr) })
+        })
     }
 
     pub fn socket_addr(&self) -> io::Result<SocketAddr> {
@@ -316,7 +353,7 @@ impl FromInner<Socket> for TcpListener {
 pub struct UdpSocket(!);
 
 impl UdpSocket {
-    pub fn bind(_: io::Result<&SocketAddr>) -> io::Result<UdpSocket> {
+    pub fn bind<A: ToSocketAddrs>(_: A) -> io::Result<UdpSocket> {
         unsupported()
     }
 
@@ -436,7 +473,7 @@ impl UdpSocket {
         self.0
     }
 
-    pub fn connect(&self, _: io::Result<&SocketAddr>) -> io::Result<()> {
+    pub fn connect<A: ToSocketAddrs>(&self, _: A) -> io::Result<()> {
         self.0
     }
 }
diff --git a/library/std/src/sys/net/connection/socket.rs b/library/std/src/sys/net/connection/socket/mod.rs
similarity index 90%
rename from library/std/src/sys/net/connection/socket.rs
rename to library/std/src/sys/net/connection/socket/mod.rs
index aa83ed65d4c2e..564f2e3a01f3b 100644
--- a/library/std/src/sys/net/connection/socket.rs
+++ b/library/std/src/sys/net/connection/socket/mod.rs
@@ -3,8 +3,11 @@ mod tests;
 
 use crate::ffi::{c_int, c_void};
 use crate::io::{self, BorrowedCursor, ErrorKind, IoSlice, IoSliceMut};
-use crate::net::{Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr, SocketAddrV4, SocketAddrV6};
+use crate::net::{
+    Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs,
+};
 use crate::sys::common::small_c_string::run_with_cstr;
+use crate::sys::net::connection::each_addr;
 use crate::sys_common::{AsInner, FromInner};
 use crate::time::Duration;
 use crate::{cmp, fmt, mem, ptr};
@@ -342,14 +345,15 @@ pub struct TcpStream {
 }
 
 impl TcpStream {
-    pub fn connect(addr: io::Result<&SocketAddr>) -> io::Result<TcpStream> {
-        let addr = addr?;
-
+    pub fn connect<A: ToSocketAddrs>(addr: A) -> io::Result<TcpStream> {
         init();
+        return each_addr(addr, inner);
 
-        let sock = Socket::new(addr, c::SOCK_STREAM)?;
-        sock.connect(addr)?;
-        Ok(TcpStream { inner: sock })
+        fn inner(addr: &SocketAddr) -> io::Result<TcpStream> {
+            let sock = Socket::new(addr, c::SOCK_STREAM)?;
+            sock.connect(addr)?;
+            Ok(TcpStream { inner: sock })
+        }
     }
 
     pub fn connect_timeout(addr: &SocketAddr, timeout: Duration) -> io::Result<TcpStream> {
@@ -512,48 +516,45 @@ pub struct TcpListener {
 }
 
 impl TcpListener {
-    pub fn bind(addr: io::Result<&SocketAddr>) -> io::Result<TcpListener> {
-        let addr = addr?;
-
+    pub fn bind<A: ToSocketAddrs>(addr: A) -> io::Result<TcpListener> {
         init();
-
-        let sock = Socket::new(addr, c::SOCK_STREAM)?;
-
-        // On platforms with Berkeley-derived sockets, this allows to quickly
-        // rebind a socket, without needing to wait for the OS to clean up the
-        // previous one.
-        //
-        // On Windows, this allows rebinding sockets which are actively in use,
-        // which allows “socket hijacking”, so we explicitly don't set it here.
-        // https://docs.microsoft.com/en-us/windows/win32/winsock/using-so-reuseaddr-and-so-exclusiveaddruse
-        #[cfg(not(windows))]
-        setsockopt(&sock, c::SOL_SOCKET, c::SO_REUSEADDR, 1 as c_int)?;
-
-        // Bind our new socket
-        let (addr, len) = socket_addr_to_c(addr);
-        cvt(unsafe { c::bind(sock.as_raw(), addr.as_ptr(), len as _) })?;
-
-        cfg_select! {
-            target_os = "horizon" => {
+        return each_addr(addr, inner);
+
+        fn inner(addr: &SocketAddr) -> io::Result<TcpListener> {
+            let sock = Socket::new(addr, c::SOCK_STREAM)?;
+
+            // On platforms with Berkeley-derived sockets, this allows to quickly
+            // rebind a socket, without needing to wait for the OS to clean up the
+            // previous one.
+            //
+            // On Windows, this allows rebinding sockets which are actively in use,
+            // which allows “socket hijacking”, so we explicitly don't set it here.
+            // https://docs.microsoft.com/en-us/windows/win32/winsock/using-so-reuseaddr-and-so-exclusiveaddruse
+            #[cfg(not(windows))]
+            setsockopt(&sock, c::SOL_SOCKET, c::SO_REUSEADDR, 1 as c_int)?;
+
+            // Bind our new socket
+            let (addr, len) = socket_addr_to_c(addr);
+            cvt(unsafe { c::bind(sock.as_raw(), addr.as_ptr(), len as _) })?;
+
+            let backlog = if cfg!(target_os = "horizon") {
                 // The 3DS doesn't support a big connection backlog. Sometimes
                 // it allows up to about 37, but other times it doesn't even
                 // accept 32. There may be a global limitation causing this.
-                let backlog = 20;
-            }
-            target_os = "haiku" => {
+                20
+            } else if cfg!(target_os = "haiku") {
                 // Haiku does not support a queue length > 32
                 // https://github.com/haiku/haiku/blob/979a0bc487864675517fb2fab28f87dc8bf43041/headers/posix/sys/socket.h#L81
-                let backlog = 32;
-            }
-            _ => {
+                32
+            } else {
                 // The default for all other platforms
-                let backlog = 128;
-            }
-        }
+                128
+            };
 
-        // Start listening
-        cvt(unsafe { c::listen(sock.as_raw(), backlog) })?;
-        Ok(TcpListener { inner: sock })
+            // Start listening
+            cvt(unsafe { c::listen(sock.as_raw(), backlog) })?;
+            Ok(TcpListener { inner: sock })
+        }
     }
 
     #[inline]
@@ -639,15 +640,16 @@ pub struct UdpSocket {
 }
 
 impl UdpSocket {
-    pub fn bind(addr: io::Result<&SocketAddr>) -> io::Result<UdpSocket> {
-        let addr = addr?;
-
+    pub fn bind<A: ToSocketAddrs>(addr: A) -> io::Result<UdpSocket> {
         init();
+        return each_addr(addr, inner);
 
-        let sock = Socket::new(addr, c::SOCK_DGRAM)?;
-        let (addr, len) = socket_addr_to_c(addr);
-        cvt(unsafe { c::bind(sock.as_raw(), addr.as_ptr(), len as _) })?;
-        Ok(UdpSocket { inner: sock })
+        fn inner(addr: &SocketAddr) -> io::Result<UdpSocket> {
+            let sock = Socket::new(addr, c::SOCK_DGRAM)?;
+            let (addr, len) = socket_addr_to_c(addr);
+            cvt(unsafe { c::bind(sock.as_raw(), addr.as_ptr(), len as _) })?;
+            Ok(UdpSocket { inner: sock })
+        }
     }
 
     #[inline]
@@ -822,9 +824,13 @@ impl UdpSocket {
         Ok(ret as usize)
     }
 
-    pub fn connect(&self, addr: io::Result<&SocketAddr>) -> io::Result<()> {
-        let (addr, len) = socket_addr_to_c(addr?);
-        cvt_r(|| unsafe { c::connect(self.inner.as_raw(), addr.as_ptr(), len) }).map(drop)
+    pub fn connect<A: ToSocketAddrs>(&self, addr: A) -> io::Result<()> {
+        return each_addr(addr, |addr| inner(self, addr));
+
+        fn inner(this: &UdpSocket, addr: &SocketAddr) -> io::Result<()> {
+            let (addr, len) = socket_addr_to_c(addr);
+            cvt_r(|| unsafe { c::connect(this.inner.as_raw(), addr.as_ptr(), len) }).map(drop)
+        }
     }
 }
 
diff --git a/library/std/src/sys/net/connection/uefi/mod.rs b/library/std/src/sys/net/connection/uefi/mod.rs
index 16e3487a1747f..0036804287352 100644
--- a/library/std/src/sys/net/connection/uefi/mod.rs
+++ b/library/std/src/sys/net/connection/uefi/mod.rs
@@ -1,6 +1,7 @@
+use super::each_addr;
 use crate::fmt;
 use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut};
-use crate::net::{Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr};
+use crate::net::{Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr, ToSocketAddrs};
 use crate::sync::{Arc, Mutex};
 use crate::sys::unsupported;
 use crate::time::Duration;
@@ -15,13 +16,17 @@ pub struct TcpStream {
 }
 
 impl TcpStream {
-    pub fn connect(addr: io::Result<&SocketAddr>) -> io::Result<TcpStream> {
-        let inner = tcp::Tcp::connect(addr?, None)?;
-        Ok(Self {
-            inner,
-            read_timeout: Arc::new(Mutex::new(None)),
-            write_timeout: Arc::new(Mutex::new(None)),
-        })
+    pub fn connect<A: ToSocketAddrs>(addr: A) -> io::Result<TcpStream> {
+        return each_addr(addr, inner);
+
+        fn inner(addr: &SocketAddr) -> io::Result<TcpStream> {
+            let inner = tcp::Tcp::connect(addr, None)?;
+            Ok(TcpStream {
+                inner,
+                read_timeout: Arc::new(Mutex::new(None)),
+                write_timeout: Arc::new(Mutex::new(None)),
+            })
+        }
     }
 
     pub fn connect_timeout(addr: &SocketAddr, timeout: Duration) -> io::Result<TcpStream> {
@@ -145,7 +150,7 @@ pub struct TcpListener {
 }
 
 impl TcpListener {
-    pub fn bind(_: io::Result<&SocketAddr>) -> io::Result<TcpListener> {
+    pub fn bind<A: ToSocketAddrs>(_: A) -> io::Result<TcpListener> {
         unsupported()
     }
 
@@ -195,7 +200,7 @@ impl fmt::Debug for TcpListener {
 pub struct UdpSocket(!);
 
 impl UdpSocket {
-    pub fn bind(_: io::Result<&SocketAddr>) -> io::Result<UdpSocket> {
+    pub fn bind<A: ToSocketAddrs>(_: A) -> io::Result<UdpSocket> {
         unsupported()
     }
 
@@ -315,7 +320,7 @@ impl UdpSocket {
         self.0
     }
 
-    pub fn connect(&self, _: io::Result<&SocketAddr>) -> io::Result<()> {
+    pub fn connect<A: ToSocketAddrs>(&self, _: A) -> io::Result<()> {
         self.0
     }
 }
diff --git a/library/std/src/sys/net/connection/unsupported.rs b/library/std/src/sys/net/connection/unsupported.rs
index da2174396266f..fbc86343272fc 100644
--- a/library/std/src/sys/net/connection/unsupported.rs
+++ b/library/std/src/sys/net/connection/unsupported.rs
@@ -1,13 +1,13 @@
 use crate::fmt;
 use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut};
-use crate::net::{Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr};
+use crate::net::{Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr, ToSocketAddrs};
 use crate::sys::unsupported;
 use crate::time::Duration;
 
 pub struct TcpStream(!);
 
 impl TcpStream {
-    pub fn connect(_: io::Result<&SocketAddr>) -> io::Result<TcpStream> {
+    pub fn connect<A: ToSocketAddrs>(_: A) -> io::Result<TcpStream> {
         unsupported()
     }
 
@@ -121,7 +121,7 @@ impl fmt::Debug for TcpStream {
 pub struct TcpListener(!);
 
 impl TcpListener {
-    pub fn bind(_: io::Result<&SocketAddr>) -> io::Result<TcpListener> {
+    pub fn bind<A: ToSocketAddrs>(_: A) -> io::Result<TcpListener> {
         unsupported()
     }
 
@@ -171,7 +171,7 @@ impl fmt::Debug for TcpListener {
 pub struct UdpSocket(!);
 
 impl UdpSocket {
-    pub fn bind(_: io::Result<&SocketAddr>) -> io::Result<UdpSocket> {
+    pub fn bind<A: ToSocketAddrs>(_: A) -> io::Result<UdpSocket> {
         unsupported()
     }
 
@@ -291,7 +291,7 @@ impl UdpSocket {
         self.0
     }
 
-    pub fn connect(&self, _: io::Result<&SocketAddr>) -> io::Result<()> {
+    pub fn connect<A: ToSocketAddrs>(&self, _: A) -> io::Result<()> {
         self.0
     }
 }
diff --git a/library/std/src/sys/net/connection/wasip1.rs b/library/std/src/sys/net/connection/wasip1.rs
index 951dc65e5b47d..cdfa25c8a4407 100644
--- a/library/std/src/sys/net/connection/wasip1.rs
+++ b/library/std/src/sys/net/connection/wasip1.rs
@@ -2,7 +2,7 @@
 
 use crate::fmt;
 use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut};
-use crate::net::{Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr};
+use crate::net::{Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr, ToSocketAddrs};
 use crate::os::wasi::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, RawFd};
 use crate::sys::fd::WasiFd;
 use crate::sys::{err2io, unsupported};
@@ -60,7 +60,7 @@ impl FromRawFd for Socket {
 }
 
 impl TcpStream {
-    pub fn connect(_: io::Result<&SocketAddr>) -> io::Result<TcpStream> {
+    pub fn connect<A: ToSocketAddrs>(_: A) -> io::Result<TcpStream> {
         unsupported()
     }
 
@@ -212,7 +212,7 @@ pub struct TcpListener {
 }
 
 impl TcpListener {
-    pub fn bind(_: io::Result<&SocketAddr>) -> io::Result<TcpListener> {
+    pub fn bind<A: ToSocketAddrs>(_: A) -> io::Result<TcpListener> {
         unsupported()
     }
 
@@ -316,7 +316,7 @@ pub struct UdpSocket {
 }
 
 impl UdpSocket {
-    pub fn bind(_: io::Result<&SocketAddr>) -> io::Result<UdpSocket> {
+    pub fn bind<A: ToSocketAddrs>(_: A) -> io::Result<UdpSocket> {
         unsupported()
     }
 
@@ -436,7 +436,7 @@ impl UdpSocket {
         unsupported()
     }
 
-    pub fn connect(&self, _: io::Result<&SocketAddr>) -> io::Result<()> {
+    pub fn connect<A: ToSocketAddrs>(&self, _: A) -> io::Result<()> {
         unsupported()
     }
 
diff --git a/library/std/src/sys/net/connection/xous/tcplistener.rs b/library/std/src/sys/net/connection/xous/tcplistener.rs
index bdf1fcd9302b7..8818ef2ca9a9b 100644
--- a/library/std/src/sys/net/connection/xous/tcplistener.rs
+++ b/library/std/src/sys/net/connection/xous/tcplistener.rs
@@ -2,9 +2,10 @@ use core::convert::TryInto;
 use core::sync::atomic::{Atomic, AtomicBool, AtomicU16, AtomicUsize, Ordering};
 
 use super::*;
-use crate::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
+use crate::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, ToSocketAddrs};
 use crate::os::xous::services;
 use crate::sync::Arc;
+use crate::sys::net::connection::each_addr;
 use crate::{fmt, io};
 
 macro_rules! unimpl {
@@ -25,16 +26,19 @@ pub struct TcpListener {
 }
 
 impl TcpListener {
-    pub fn bind(socketaddr: io::Result<&SocketAddr>) -> io::Result<TcpListener> {
-        let mut addr = *socketaddr?;
-
-        let fd = TcpListener::bind_inner(&mut addr)?;
-        return Ok(TcpListener {
-            fd: Arc::new(AtomicU16::new(fd)),
-            local: addr,
-            handle_count: Arc::new(AtomicUsize::new(1)),
-            nonblocking: Arc::new(AtomicBool::new(false)),
-        });
+    pub fn bind<A: ToSocketAddrs>(addr: A) -> io::Result<TcpListener> {
+        return each_addr(addr, inner);
+
+        fn inner(addr: &SocketAddr) -> io::Result<TcpListener> {
+            let mut addr = *addr;
+            let fd = TcpListener::bind_inner(&mut addr)?;
+            Ok(TcpListener {
+                fd: Arc::new(AtomicU16::new(fd)),
+                local: addr,
+                handle_count: Arc::new(AtomicUsize::new(1)),
+                nonblocking: Arc::new(AtomicBool::new(false)),
+            })
+        }
     }
 
     /// This returns the raw fd of a Listener, so that it can also be used by the
diff --git a/library/std/src/sys/net/connection/xous/tcpstream.rs b/library/std/src/sys/net/connection/xous/tcpstream.rs
index 5452476745265..4df75453d1f45 100644
--- a/library/std/src/sys/net/connection/xous/tcpstream.rs
+++ b/library/std/src/sys/net/connection/xous/tcpstream.rs
@@ -3,9 +3,12 @@ use core::sync::atomic::{Atomic, AtomicBool, AtomicU32, AtomicUsize, Ordering};
 use super::*;
 use crate::fmt;
 use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut};
-use crate::net::{IpAddr, Ipv4Addr, Shutdown, SocketAddr, SocketAddrV4, SocketAddrV6};
+use crate::net::{
+    IpAddr, Ipv4Addr, Shutdown, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs,
+};
 use crate::os::xous::services;
 use crate::sync::Arc;
+use crate::sys::net::connection::each_addr;
 use crate::time::Duration;
 
 macro_rules! unimpl {
@@ -79,8 +82,8 @@ impl TcpStream {
         }
     }
 
-    pub fn connect(socketaddr: io::Result<&SocketAddr>) -> io::Result<TcpStream> {
-        Self::connect_timeout(socketaddr?, Duration::ZERO)
+    pub fn connect<A: ToSocketAddrs>(addr: A) -> io::Result<TcpStream> {
+        each_addr(addr, |addr| Self::connect_timeout(addr, Duration::ZERO))
     }
 
     pub fn connect_timeout(addr: &SocketAddr, duration: Duration) -> io::Result<TcpStream> {
diff --git a/library/std/src/sys/net/connection/xous/udp.rs b/library/std/src/sys/net/connection/xous/udp.rs
index 2127d3267ed47..ce54ea3b79ef8 100644
--- a/library/std/src/sys/net/connection/xous/udp.rs
+++ b/library/std/src/sys/net/connection/xous/udp.rs
@@ -3,9 +3,10 @@ use core::sync::atomic::{Atomic, AtomicUsize, Ordering};
 
 use super::*;
 use crate::cell::Cell;
-use crate::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
+use crate::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, ToSocketAddrs};
 use crate::os::xous::services;
 use crate::sync::Arc;
+use crate::sys::net::connection::each_addr;
 use crate::time::Duration;
 use crate::{fmt, io};
 
@@ -32,40 +33,45 @@ pub struct UdpSocket {
 }
 
 impl UdpSocket {
-    pub fn bind(socketaddr: io::Result<&SocketAddr>) -> io::Result<UdpSocket> {
-        let addr = socketaddr?;
-        // Construct the request
-        let mut connect_request = ConnectRequest { raw: [0u8; 4096] };
-
-        // Serialize the StdUdpBind structure. This is done "manually" because we don't want to
-        // make an auto-serdes (like bincode or rkyv) crate a dependency of Xous.
-        let port_bytes = addr.port().to_le_bytes();
-        connect_request.raw[0] = port_bytes[0];
-        connect_request.raw[1] = port_bytes[1];
-        match addr.ip() {
-            IpAddr::V4(addr) => {
-                connect_request.raw[2] = 4;
-                for (dest, src) in connect_request.raw[3..].iter_mut().zip(addr.octets()) {
-                    *dest = src;
+    pub fn bind<A: ToSocketAddrs>(addr: A) -> io::Result<UdpSocket> {
+        return each_addr(addr, inner);
+
+        fn inner(addr: &SocketAddr) -> io::Result<UdpSocket> {
+            // Construct the request
+            let mut connect_request = ConnectRequest { raw: [0u8; 4096] };
+
+            // Serialize the StdUdpBind structure. This is done "manually" because we don't want to
+            // make an auto-serdes (like bincode or rkyv) crate a dependency of Xous.
+            let port_bytes = addr.port().to_le_bytes();
+            connect_request.raw[0] = port_bytes[0];
+            connect_request.raw[1] = port_bytes[1];
+            match addr.ip() {
+                IpAddr::V4(addr) => {
+                    connect_request.raw[2] = 4;
+                    for (dest, src) in connect_request.raw[3..].iter_mut().zip(addr.octets()) {
+                        *dest = src;
+                    }
                 }
-            }
-            IpAddr::V6(addr) => {
-                connect_request.raw[2] = 6;
-                for (dest, src) in connect_request.raw[3..].iter_mut().zip(addr.octets()) {
-                    *dest = src;
+                IpAddr::V6(addr) => {
+                    connect_request.raw[2] = 6;
+                    for (dest, src) in connect_request.raw[3..].iter_mut().zip(addr.octets()) {
+                        *dest = src;
+                    }
                 }
             }
-        }
 
-        let response = crate::os::xous::ffi::lend_mut(
-            services::net_server(),
-            services::NetLendMut::StdUdpBind.into(),
-            &mut connect_request.raw,
-            0,
-            4096,
-        );
+            let response = crate::os::xous::ffi::lend_mut(
+                services::net_server(),
+                services::NetLendMut::StdUdpBind.into(),
+                &mut connect_request.raw,
+                0,
+                4096,
+            );
+
+            let Ok((_, valid)) = response else {
+                return Err(io::const_error!(io::ErrorKind::InvalidInput, "invalid response"));
+            };
 
-        if let Ok((_, valid)) = response {
             // The first four bytes should be zero upon success, and will be nonzero
             // for an error.
             let response = connect_request.raw;
@@ -87,8 +93,9 @@ impl UdpSocket {
                     ));
                 }
             }
+
             let fd = response[1] as u16;
-            return Ok(UdpSocket {
+            Ok(UdpSocket {
                 fd,
                 local: *addr,
                 remote: Cell::new(None),
@@ -96,9 +103,8 @@ impl UdpSocket {
                 write_timeout: Cell::new(0),
                 handle_count: Arc::new(AtomicUsize::new(1)),
                 nonblocking: Cell::new(false),
-            });
+            })
         }
-        Err(io::const_error!(io::ErrorKind::InvalidInput, "invalid response"))
     }
 
     pub fn peer_addr(&self) -> io::Result<SocketAddr> {
@@ -198,10 +204,11 @@ impl UdpSocket {
         self.peek_from(buf).map(|(len, _addr)| len)
     }
 
-    pub fn connect(&self, maybe_addr: io::Result<&SocketAddr>) -> io::Result<()> {
-        let addr = maybe_addr?;
-        self.remote.set(Some(*addr));
-        Ok(())
+    pub fn connect<A: ToSocketAddrs>(&self, addr: A) -> io::Result<()> {
+        each_addr(addr, |addr| {
+            self.remote.set(Some(*addr));
+            Ok(())
+        })
     }
 
     pub fn send(&self, buf: &[u8]) -> io::Result<usize> {
diff --git a/library/std/src/sys/net/mod.rs b/library/std/src/sys/net/mod.rs
index 5df1fe138ab24..dffc4ea7f81ad 100644
--- a/library/std/src/sys/net/mod.rs
+++ b/library/std/src/sys/net/mod.rs
@@ -1,46 +1,4 @@
-cfg_select! {
-    any(
-        all(target_family = "unix", not(target_os = "l4re")),
-        target_os = "windows",
-        target_os = "hermit",
-        all(target_os = "wasi", target_env = "p2"),
-        target_os = "solid_asp3",
-    ) => {
-        mod connection {
-            mod socket;
-            pub use socket::*;
-        }
-    }
-    all(target_vendor = "fortanix", target_env = "sgx") => {
-        mod connection {
-            mod sgx;
-            pub use sgx::*;
-        }
-    }
-    all(target_os = "wasi", target_env = "p1") => {
-        mod connection {
-            mod wasip1;
-            pub use wasip1::*;
-        }
-    }
-    target_os = "xous" => {
-        mod connection {
-            mod xous;
-            pub use xous::*;
-        }
-    }
-    target_os = "uefi" => {
-        mod connection {
-            mod uefi;
-            pub use uefi::*;
-        }
-    }
-    _ => {
-        mod connection {
-            mod unsupported;
-            pub use unsupported::*;
-        }
-    }
-}
-
+/// This module contains the implementations of `TcpStream`, `TcpListener` and
+/// `UdpSocket` as well as related functionality like DNS resolving.
+mod connection;
 pub use connection::*;

From 4b15dd5a84742f9e7641b62e490765e0c1cb415c Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Fri, 29 Aug 2025 18:01:02 +0200
Subject: [PATCH 0671/1889] std: move `thread` into `sys` (rename only)

---
 library/std/src/sys/{pal/hermit/thread.rs => thread/hermit.rs}    | 0
 library/std/src/sys/{pal/sgx/thread.rs => thread/sgx.rs}          | 0
 library/std/src/sys/{pal/itron/thread.rs => thread/solid.rs}      | 0
 library/std/src/sys/{pal/teeos/thread.rs => thread/teeos.rs}      | 0
 library/std/src/sys/{pal/uefi/thread.rs => thread/uefi.rs}        | 0
 library/std/src/sys/{pal/unix/thread.rs => thread/unix.rs}        | 0
 .../src/sys/{pal/unsupported/thread.rs => thread/unsupported.rs}  | 0
 library/std/src/sys/{pal/wasip1/thread.rs => thread/wasip1.rs}    | 0
 library/std/src/sys/{pal/wasip2/thread.rs => thread/wasip2.rs}    | 0
 .../std/src/sys/{pal/wasm/atomics/thread.rs => thread/wasm.rs}    | 0
 library/std/src/sys/{pal/windows/thread.rs => thread/windows.rs}  | 0
 library/std/src/sys/{pal/xous/thread.rs => thread/xous.rs}        | 0
 12 files changed, 0 insertions(+), 0 deletions(-)
 rename library/std/src/sys/{pal/hermit/thread.rs => thread/hermit.rs} (100%)
 rename library/std/src/sys/{pal/sgx/thread.rs => thread/sgx.rs} (100%)
 rename library/std/src/sys/{pal/itron/thread.rs => thread/solid.rs} (100%)
 rename library/std/src/sys/{pal/teeos/thread.rs => thread/teeos.rs} (100%)
 rename library/std/src/sys/{pal/uefi/thread.rs => thread/uefi.rs} (100%)
 rename library/std/src/sys/{pal/unix/thread.rs => thread/unix.rs} (100%)
 rename library/std/src/sys/{pal/unsupported/thread.rs => thread/unsupported.rs} (100%)
 rename library/std/src/sys/{pal/wasip1/thread.rs => thread/wasip1.rs} (100%)
 rename library/std/src/sys/{pal/wasip2/thread.rs => thread/wasip2.rs} (100%)
 rename library/std/src/sys/{pal/wasm/atomics/thread.rs => thread/wasm.rs} (100%)
 rename library/std/src/sys/{pal/windows/thread.rs => thread/windows.rs} (100%)
 rename library/std/src/sys/{pal/xous/thread.rs => thread/xous.rs} (100%)

diff --git a/library/std/src/sys/pal/hermit/thread.rs b/library/std/src/sys/thread/hermit.rs
similarity index 100%
rename from library/std/src/sys/pal/hermit/thread.rs
rename to library/std/src/sys/thread/hermit.rs
diff --git a/library/std/src/sys/pal/sgx/thread.rs b/library/std/src/sys/thread/sgx.rs
similarity index 100%
rename from library/std/src/sys/pal/sgx/thread.rs
rename to library/std/src/sys/thread/sgx.rs
diff --git a/library/std/src/sys/pal/itron/thread.rs b/library/std/src/sys/thread/solid.rs
similarity index 100%
rename from library/std/src/sys/pal/itron/thread.rs
rename to library/std/src/sys/thread/solid.rs
diff --git a/library/std/src/sys/pal/teeos/thread.rs b/library/std/src/sys/thread/teeos.rs
similarity index 100%
rename from library/std/src/sys/pal/teeos/thread.rs
rename to library/std/src/sys/thread/teeos.rs
diff --git a/library/std/src/sys/pal/uefi/thread.rs b/library/std/src/sys/thread/uefi.rs
similarity index 100%
rename from library/std/src/sys/pal/uefi/thread.rs
rename to library/std/src/sys/thread/uefi.rs
diff --git a/library/std/src/sys/pal/unix/thread.rs b/library/std/src/sys/thread/unix.rs
similarity index 100%
rename from library/std/src/sys/pal/unix/thread.rs
rename to library/std/src/sys/thread/unix.rs
diff --git a/library/std/src/sys/pal/unsupported/thread.rs b/library/std/src/sys/thread/unsupported.rs
similarity index 100%
rename from library/std/src/sys/pal/unsupported/thread.rs
rename to library/std/src/sys/thread/unsupported.rs
diff --git a/library/std/src/sys/pal/wasip1/thread.rs b/library/std/src/sys/thread/wasip1.rs
similarity index 100%
rename from library/std/src/sys/pal/wasip1/thread.rs
rename to library/std/src/sys/thread/wasip1.rs
diff --git a/library/std/src/sys/pal/wasip2/thread.rs b/library/std/src/sys/thread/wasip2.rs
similarity index 100%
rename from library/std/src/sys/pal/wasip2/thread.rs
rename to library/std/src/sys/thread/wasip2.rs
diff --git a/library/std/src/sys/pal/wasm/atomics/thread.rs b/library/std/src/sys/thread/wasm.rs
similarity index 100%
rename from library/std/src/sys/pal/wasm/atomics/thread.rs
rename to library/std/src/sys/thread/wasm.rs
diff --git a/library/std/src/sys/pal/windows/thread.rs b/library/std/src/sys/thread/windows.rs
similarity index 100%
rename from library/std/src/sys/pal/windows/thread.rs
rename to library/std/src/sys/thread/windows.rs
diff --git a/library/std/src/sys/pal/xous/thread.rs b/library/std/src/sys/thread/xous.rs
similarity index 100%
rename from library/std/src/sys/pal/xous/thread.rs
rename to library/std/src/sys/thread/xous.rs

From bb5b153b7bccab4347d1a4deead6dcc9ca400a34 Mon Sep 17 00:00:00 2001
From: Ryan Mehri <rmehri01@pm.me>
Date: Mon, 8 Sep 2025 11:12:57 -0400
Subject: [PATCH 0672/1889] feat: support navigation on primitives

---
 .../rust-analyzer/crates/ide-db/src/defs.rs   |  2 +-
 .../crates/ide/src/goto_definition.rs         | 27 +++++++++++++++++--
 .../crates/ide/src/hover/render.rs            | 15 +----------
 3 files changed, 27 insertions(+), 17 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-db/src/defs.rs b/src/tools/rust-analyzer/crates/ide-db/src/defs.rs
index 61a21ccf2f775..43d4611b18ac1 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/defs.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/defs.rs
@@ -363,7 +363,7 @@ impl Definition {
     }
 }
 
-fn find_std_module(
+pub fn find_std_module(
     famous_defs: &FamousDefs<'_, '_>,
     name: &str,
     edition: Edition,
diff --git a/src/tools/rust-analyzer/crates/ide/src/goto_definition.rs b/src/tools/rust-analyzer/crates/ide/src/goto_definition.rs
index f768d4b68f469..002f5b3fe8f44 100644
--- a/src/tools/rust-analyzer/crates/ide/src/goto_definition.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/goto_definition.rs
@@ -6,12 +6,13 @@ use crate::{
     navigation_target::{self, ToNav},
 };
 use hir::{
-    AsAssocItem, AssocItem, CallableKind, FileRange, HasCrate, InFile, ModuleDef, Semantics, sym,
+    AsAssocItem, AssocItem, CallableKind, FileRange, HasCrate, InFile, ModuleDef, PathResolution,
+    Semantics, sym,
 };
 use ide_db::{
     RootDatabase, SymbolKind,
     base_db::{AnchoredPath, SourceDatabase},
-    defs::{Definition, IdentClass},
+    defs::{Definition, IdentClass, find_std_module},
     famous_defs::FamousDefs,
     helpers::pick_best_token,
 };
@@ -90,6 +91,9 @@ pub(crate) fn goto_definition(
             if let Some(navs) = find_definition_for_known_blanket_dual_impls(sema, &token.value) {
                 return Some(navs);
             }
+            if let Some(navs) = find_definition_for_builtin_types(sema, &token.value, edition) {
+                return Some(navs);
+            }
 
             let parent = token.value.parent()?;
 
@@ -204,6 +208,25 @@ fn find_definition_for_known_blanket_dual_impls(
     Some(def_to_nav(sema.db, def))
 }
 
+// If the token is a builtin type search the definition from the rustdoc module shims.
+fn find_definition_for_builtin_types(
+    sema: &Semantics<'_, RootDatabase>,
+    original_token: &SyntaxToken,
+    edition: Edition,
+) -> Option<Vec<NavigationTarget>> {
+    let path = original_token.parent_ancestors().find_map(ast::Path::cast)?;
+    let res = sema.resolve_path(&path)?;
+    let PathResolution::Def(ModuleDef::BuiltinType(builtin)) = res else {
+        return None;
+    };
+
+    let fd = FamousDefs(sema, sema.scope(path.syntax())?.krate());
+    let primitive_mod = format!("prim_{}", builtin.name().display(fd.0.db, edition));
+    let doc_owner = find_std_module(&fd, &primitive_mod, edition)?;
+
+    Some(def_to_nav(sema.db, doc_owner.into()))
+}
+
 fn try_lookup_include_path(
     sema: &Semantics<'_, RootDatabase>,
     token: InFile<ast::String>,
diff --git a/src/tools/rust-analyzer/crates/ide/src/hover/render.rs b/src/tools/rust-analyzer/crates/ide/src/hover/render.rs
index 290ee80984edc..2adafbb7af6f7 100644
--- a/src/tools/rust-analyzer/crates/ide/src/hover/render.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/hover/render.rs
@@ -10,7 +10,7 @@ use hir::{
 };
 use ide_db::{
     RootDatabase,
-    defs::Definition,
+    defs::{Definition, find_std_module},
     documentation::{DocsRangeMap, HasDocs},
     famous_defs::FamousDefs,
     generated::lints::{CLIPPY_LINTS, DEFAULT_LINTS, FEATURES},
@@ -1160,19 +1160,6 @@ fn markup(
     }
 }
 
-fn find_std_module(
-    famous_defs: &FamousDefs<'_, '_>,
-    name: &str,
-    edition: Edition,
-) -> Option<hir::Module> {
-    let db = famous_defs.0.db;
-    let std_crate = famous_defs.std()?;
-    let std_root_module = std_crate.root_module();
-    std_root_module.children(db).find(|module| {
-        module.name(db).is_some_and(|module| module.display(db, edition).to_string() == name)
-    })
-}
-
 fn render_memory_layout(
     config: Option<MemoryLayoutHoverConfig>,
     layout: impl FnOnce() -> Result<Layout, LayoutError>,

From e656e52ccb33f92ca8bfd7ad78ee5b028ff61a62 Mon Sep 17 00:00:00 2001
From: IoaNNUwU <ioannxd@gmail.com>
Date: Tue, 2 Sep 2025 16:15:23 +0200
Subject: [PATCH 0673/1889] Suggest examples of format specifiers in error
 messages

---
 compiler/rustc_builtin_macros/src/format.rs   | 27 ++++++++-
 .../missing-format-specifiers-issue-68293.rs  | 34 +++++++++++
 ...ssing-format-specifiers-issue-68293.stderr | 59 +++++++++++++++++++
 3 files changed, 118 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/suggestions/missing-format-specifiers-issue-68293.rs
 create mode 100644 tests/ui/suggestions/missing-format-specifiers-issue-68293.stderr

diff --git a/compiler/rustc_builtin_macros/src/format.rs b/compiler/rustc_builtin_macros/src/format.rs
index 6415e55e0b034..ce9bda10721a4 100644
--- a/compiler/rustc_builtin_macros/src/format.rs
+++ b/compiler/rustc_builtin_macros/src/format.rs
@@ -758,8 +758,31 @@ fn report_missing_placeholders(
             check_foreign!(shell);
         }
     }
-    if !found_foreign && unused.len() == 1 {
-        diag.span_label(fmt_span, "formatting specifier missing");
+    if !found_foreign {
+        if unused.len() == 1 {
+            diag.span_label(fmt_span, "formatting specifier missing");
+        }
+        if used.iter().all(|used| !used) {
+            diag.note("format specifiers use curly braces: `{}`");
+        }
+
+        let mut suggest_fixed_fmt = format!("\"{}", &fmt_str[..fmt_str.len() - 1]);
+        for _ in &unused {
+            suggest_fixed_fmt.push_str("{}");
+        }
+        suggest_fixed_fmt.push('"');
+
+        let suggest_fmt_count = if unused.len() == 1 {
+            "consider adding format specifier".to_string()
+        } else {
+            format!("consider adding {} format specifiers", unused.len())
+        };
+        diag.span_suggestion_verbose(
+            fmt_span,
+            suggest_fmt_count,
+            suggest_fixed_fmt,
+            Applicability::MaybeIncorrect,
+        );
     }
 
     diag.emit();
diff --git a/tests/ui/suggestions/missing-format-specifiers-issue-68293.rs b/tests/ui/suggestions/missing-format-specifiers-issue-68293.rs
new file mode 100644
index 0000000000000..e1f8710db5a33
--- /dev/null
+++ b/tests/ui/suggestions/missing-format-specifiers-issue-68293.rs
@@ -0,0 +1,34 @@
+fn no_format_specifier_two_unused_args() {
+    println!("Hello", "World");
+    //~^ ERROR argument never used
+    //~| NOTE formatting specifier missing
+    //~| NOTE format specifiers use curly braces: `{}`
+    //~| NOTE argument never used
+}
+
+fn no_format_specifier_multiple_unused_args() {
+    println!("list: ", 1, 2, 3);
+    //~^ ERROR multiple unused formatting arguments
+    //~| NOTE multiple missing formatting specifiers
+    //~| NOTE format specifiers use curly braces: `{}`
+    //~| NOTE argument never used
+    //~| NOTE argument never used
+    //~| NOTE argument never used
+}
+
+fn missing_format_specifiers_one_unused_arg() {
+    println!("list: {}, {}", 1, 2, 3);
+    //~^ ERROR argument never used
+    //~| NOTE formatting specifier missing
+    //~| NOTE argument never used
+}
+
+fn missing_format_specifiers_multiple_unused_args() {
+    println!("list: {}", 1, 2, 3);
+    //~^ ERROR multiple unused formatting arguments
+    //~| NOTE multiple missing formatting specifiers
+    //~| NOTE argument never used
+    //~| NOTE argument never used
+}
+
+fn main() { }
diff --git a/tests/ui/suggestions/missing-format-specifiers-issue-68293.stderr b/tests/ui/suggestions/missing-format-specifiers-issue-68293.stderr
new file mode 100644
index 0000000000000..654c8b0712a4f
--- /dev/null
+++ b/tests/ui/suggestions/missing-format-specifiers-issue-68293.stderr
@@ -0,0 +1,59 @@
+error: argument never used
+  --> $DIR/missing-format-specifiers-issue-68293.rs:2:23
+   |
+LL |     println!("Hello", "World");
+   |              -------  ^^^^^^^ argument never used
+   |              |
+   |              formatting specifier missing
+   |
+   = note: format specifiers use curly braces: `{}`
+help: consider adding format specifier
+   |
+LL |     println!("Hello{}", "World");
+   |                    ++
+
+error: multiple unused formatting arguments
+  --> $DIR/missing-format-specifiers-issue-68293.rs:10:24
+   |
+LL |     println!("list: ", 1, 2, 3);
+   |              --------  ^  ^  ^ argument never used
+   |              |         |  |
+   |              |         |  argument never used
+   |              |         argument never used
+   |              multiple missing formatting specifiers
+   |
+   = note: format specifiers use curly braces: `{}`
+help: consider adding 3 format specifiers
+   |
+LL |     println!("list: {}{}{}", 1, 2, 3);
+   |                     ++++++
+
+error: argument never used
+  --> $DIR/missing-format-specifiers-issue-68293.rs:20:36
+   |
+LL |     println!("list: {}, {}", 1, 2, 3);
+   |              --------------        ^ argument never used
+   |              |
+   |              formatting specifier missing
+   |
+help: consider adding format specifier
+   |
+LL |     println!("list: {}, {}{}", 1, 2, 3);
+   |                           ++
+
+error: multiple unused formatting arguments
+  --> $DIR/missing-format-specifiers-issue-68293.rs:27:29
+   |
+LL |     println!("list: {}", 1, 2, 3);
+   |              ----------     ^  ^ argument never used
+   |              |              |
+   |              |              argument never used
+   |              multiple missing formatting specifiers
+   |
+help: consider adding 2 format specifiers
+   |
+LL |     println!("list: {}{}{}", 1, 2, 3);
+   |                       ++++
+
+error: aborting due to 4 previous errors
+

From 1e733b389192b48110779bc1cd8edcaed7c43b0e Mon Sep 17 00:00:00 2001
From: IoaNNUwU <ioannxd@gmail.com>
Date: Tue, 2 Sep 2025 23:53:54 +0200
Subject: [PATCH 0674/1889] Implement better suggestions based on additional
 tests and other code paths

---
 compiler/rustc_builtin_macros/src/format.rs   | 58 ++++++++++++-------
 tests/ui/fmt/ifmt-bad-arg.stderr              | 14 +++++
 tests/ui/macros/format-unused-lables.stderr   | 18 ++++++
 tests/ui/mir/unsized-extern-static.stderr     |  6 ++
 .../missing-format-specifiers-issue-68293.rs  |  1 +
 ...ssing-format-specifiers-issue-68293.stderr | 10 +---
 6 files changed, 78 insertions(+), 29 deletions(-)

diff --git a/compiler/rustc_builtin_macros/src/format.rs b/compiler/rustc_builtin_macros/src/format.rs
index ce9bda10721a4..e5f73188dbdfa 100644
--- a/compiler/rustc_builtin_macros/src/format.rs
+++ b/compiler/rustc_builtin_macros/src/format.rs
@@ -565,6 +565,7 @@ fn make_format_args(
             &used,
             &args,
             &pieces,
+            &invalid_refs,
             detect_foreign_fmt,
             str_style,
             fmt_str,
@@ -645,6 +646,7 @@ fn report_missing_placeholders(
     used: &[bool],
     args: &FormatArguments,
     pieces: &[parse::Piece<'_>],
+    invalid_refs: &[(usize, Option<Span>, PositionUsedAs, FormatArgPositionKind)],
     detect_foreign_fmt: bool,
     str_style: Option<usize>,
     fmt_str: &str,
@@ -758,31 +760,47 @@ fn report_missing_placeholders(
             check_foreign!(shell);
         }
     }
-    if !found_foreign {
-        if unused.len() == 1 {
-            diag.span_label(fmt_span, "formatting specifier missing");
+    if !found_foreign && unused.len() == 1 {
+        diag.span_label(fmt_span, "formatting specifier missing");
+    }
+
+    if !found_foreign && invalid_refs.is_empty() {
+        // Show example if user didn't use any format specifiers
+        let show_example = used.iter().all(|used| !used);
+
+        if !show_example && unused.len() > 1 {
+            diag.note(format!("consider adding {} format specifiers", unused.len()));
         }
-        if used.iter().all(|used| !used) {
+
+        let original_fmt_str = if fmt_str.len() >= 1 { &fmt_str[..fmt_str.len() - 1] } else { "" };
+
+        if show_example && unused.len() == 1 {
             diag.note("format specifiers use curly braces: `{}`");
-        }
 
-        let mut suggest_fixed_fmt = format!("\"{}", &fmt_str[..fmt_str.len() - 1]);
-        for _ in &unused {
-            suggest_fixed_fmt.push_str("{}");
+            diag.span_suggestion_verbose(
+                fmt_span,
+                "consider adding format specifier",
+                format!("\"{}{{}}\"", original_fmt_str),
+                Applicability::MaybeIncorrect,
+            );
         }
-        suggest_fixed_fmt.push('"');
 
-        let suggest_fmt_count = if unused.len() == 1 {
-            "consider adding format specifier".to_string()
-        } else {
-            format!("consider adding {} format specifiers", unused.len())
-        };
-        diag.span_suggestion_verbose(
-            fmt_span,
-            suggest_fmt_count,
-            suggest_fixed_fmt,
-            Applicability::MaybeIncorrect,
-        );
+        if show_example && unused.len() > 1 {
+            diag.note("format specifiers use curly braces: `{}`");
+
+            let mut suggest_fixed_fmt = format!("\"{}", original_fmt_str);
+            for _ in &unused {
+                suggest_fixed_fmt.push_str("{}");
+            }
+            suggest_fixed_fmt.push('"');
+
+            diag.span_suggestion_verbose(
+                fmt_span,
+                format!("consider adding {} format specifiers", unused.len()),
+                suggest_fixed_fmt,
+                Applicability::MaybeIncorrect,
+            );
+        }
     }
 
     diag.emit();
diff --git a/tests/ui/fmt/ifmt-bad-arg.stderr b/tests/ui/fmt/ifmt-bad-arg.stderr
index 4344aee83c2b1..6ddc817290155 100644
--- a/tests/ui/fmt/ifmt-bad-arg.stderr
+++ b/tests/ui/fmt/ifmt-bad-arg.stderr
@@ -62,6 +62,12 @@ LL |     format!("", 1, 2);
    |             |   |
    |             |   argument never used
    |             multiple missing formatting specifiers
+   |
+   = note: format specifiers use curly braces: `{}`
+help: consider adding 2 format specifiers
+   |
+LL |     format!("{}{}", 1, 2);
+   |              ++++
 
 error: argument never used
   --> $DIR/ifmt-bad-arg.rs:33:22
@@ -102,6 +108,12 @@ LL |     format!("", foo=2);
    |             --      ^ named argument never used
    |             |
    |             formatting specifier missing
+   |
+   = note: format specifiers use curly braces: `{}`
+help: consider adding format specifier
+   |
+LL |     format!("{}", foo=2);
+   |              ++
 
 error: multiple unused formatting arguments
   --> $DIR/ifmt-bad-arg.rs:38:32
@@ -111,6 +123,8 @@ LL |     format!("{} {}", 1, 2, foo=1, bar=2);
    |             |                  |
    |             |                  named argument never used
    |             multiple missing formatting specifiers
+   |
+   = note: consider adding 2 format specifiers
 
 error: duplicate argument named `foo`
   --> $DIR/ifmt-bad-arg.rs:40:29
diff --git a/tests/ui/macros/format-unused-lables.stderr b/tests/ui/macros/format-unused-lables.stderr
index fad87fa2aeea8..1c5cdcc2346d4 100644
--- a/tests/ui/macros/format-unused-lables.stderr
+++ b/tests/ui/macros/format-unused-lables.stderr
@@ -7,6 +7,12 @@ LL |     println!("Test", 123, 456, 789);
    |              |       |    argument never used
    |              |       argument never used
    |              multiple missing formatting specifiers
+   |
+   = note: format specifiers use curly braces: `{}`
+help: consider adding 3 format specifiers
+   |
+LL |     println!("Test{}{}{}", 123, 456, 789);
+   |                   ++++++
 
 error: multiple unused formatting arguments
   --> $DIR/format-unused-lables.rs:6:9
@@ -19,6 +25,12 @@ LL |         456,
    |         ^^^ argument never used
 LL |         789
    |         ^^^ argument never used
+   |
+   = note: format specifiers use curly braces: `{}`
+help: consider adding 3 format specifiers
+   |
+LL |     println!("Test2{}{}{}",
+   |                    ++++++
 
 error: named argument never used
   --> $DIR/format-unused-lables.rs:11:35
@@ -27,6 +39,12 @@ LL |     println!("Some stuff", UNUSED="args");
    |              ------------         ^^^^^^ named argument never used
    |              |
    |              formatting specifier missing
+   |
+   = note: format specifiers use curly braces: `{}`
+help: consider adding format specifier
+   |
+LL |     println!("Some stuff{}", UNUSED="args");
+   |                         ++
 
 error: multiple unused formatting arguments
   --> $DIR/format-unused-lables.rs:14:9
diff --git a/tests/ui/mir/unsized-extern-static.stderr b/tests/ui/mir/unsized-extern-static.stderr
index 93aed3549d762..005dc59d78f90 100644
--- a/tests/ui/mir/unsized-extern-static.stderr
+++ b/tests/ui/mir/unsized-extern-static.stderr
@@ -5,6 +5,12 @@ LL |     println!("C", unsafe { &symbol });
    |              ---  ^^^^^^^^^^^^^^^^^^ argument never used
    |              |
    |              formatting specifier missing
+   |
+   = note: format specifiers use curly braces: `{}`
+help: consider adding format specifier
+   |
+LL |     println!("C{}", unsafe { &symbol });
+   |                ++
 
 error[E0277]: the size for values of type `[i8]` cannot be known at compilation time
   --> $DIR/unsized-extern-static.rs:6:5
diff --git a/tests/ui/suggestions/missing-format-specifiers-issue-68293.rs b/tests/ui/suggestions/missing-format-specifiers-issue-68293.rs
index e1f8710db5a33..2f5e962944153 100644
--- a/tests/ui/suggestions/missing-format-specifiers-issue-68293.rs
+++ b/tests/ui/suggestions/missing-format-specifiers-issue-68293.rs
@@ -29,6 +29,7 @@ fn missing_format_specifiers_multiple_unused_args() {
     //~| NOTE multiple missing formatting specifiers
     //~| NOTE argument never used
     //~| NOTE argument never used
+    //~| NOTE consider adding 2 format specifiers
 }
 
 fn main() { }
diff --git a/tests/ui/suggestions/missing-format-specifiers-issue-68293.stderr b/tests/ui/suggestions/missing-format-specifiers-issue-68293.stderr
index 654c8b0712a4f..961887a7e3faa 100644
--- a/tests/ui/suggestions/missing-format-specifiers-issue-68293.stderr
+++ b/tests/ui/suggestions/missing-format-specifiers-issue-68293.stderr
@@ -35,11 +35,6 @@ LL |     println!("list: {}, {}", 1, 2, 3);
    |              --------------        ^ argument never used
    |              |
    |              formatting specifier missing
-   |
-help: consider adding format specifier
-   |
-LL |     println!("list: {}, {}{}", 1, 2, 3);
-   |                           ++
 
 error: multiple unused formatting arguments
   --> $DIR/missing-format-specifiers-issue-68293.rs:27:29
@@ -50,10 +45,7 @@ LL |     println!("list: {}", 1, 2, 3);
    |              |              argument never used
    |              multiple missing formatting specifiers
    |
-help: consider adding 2 format specifiers
-   |
-LL |     println!("list: {}{}{}", 1, 2, 3);
-   |                       ++++
+   = note: consider adding 2 format specifiers
 
 error: aborting due to 4 previous errors
 

From 266f8c9c0073745044a8eaeef5803b90090f5ad5 Mon Sep 17 00:00:00 2001
From: Daniel Paoliello <danpao@microsoft.com>
Date: Wed, 3 Sep 2025 17:12:03 -0700
Subject: [PATCH 0675/1889] Update tracing, again

---
 Cargo.lock                    | 5 ++---
 compiler/rustc_log/Cargo.toml | 5 ++---
 2 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 81f19668c24b7..875086163f6a0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5518,11 +5518,10 @@ checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801"
 
 [[package]]
 name = "tracing"
-version = "0.1.37"
+version = "0.1.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ce8c33a8d48bd45d624a6e523445fd21ec13d3653cd51f681abf67418f54eb8"
+checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0"
 dependencies = [
- "cfg-if",
  "pin-project-lite",
  "tracing-attributes",
  "tracing-core",
diff --git a/compiler/rustc_log/Cargo.toml b/compiler/rustc_log/Cargo.toml
index 2332ff9b323b2..72f68d685cd38 100644
--- a/compiler/rustc_log/Cargo.toml
+++ b/compiler/rustc_log/Cargo.toml
@@ -5,13 +5,12 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-# tracing > 0.1.37 have huge binary size / instructions regression
-tracing = "=0.1.37"
+tracing = "0.1.41"
 tracing-subscriber = { version = "0.3.3", default-features = false, features = ["fmt", "env-filter", "smallvec", "parking_lot", "ansi"] }
 tracing-tree = "0.3.1"
 # tidy-alphabetical-end
 
 [features]
 # tidy-alphabetical-start
-max_level_info = ['tracing/max_level_info']
+max_level_info = ['tracing/max_level_info', 'tracing/release_max_level_info']
 # tidy-alphabetical-end

From 1656f6c668e0603fb31dac6b2b95f1cfb1be2402 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sat, 6 Sep 2025 15:00:19 +0200
Subject: [PATCH 0676/1889] disallow c-variadic coroutines

---
 compiler/rustc_ast_passes/messages.ftl        |  4 ++++
 .../rustc_ast_passes/src/ast_validation.rs    |  9 +++++++++
 compiler/rustc_ast_passes/src/errors.rs       | 12 ++++++++++++
 tests/ui/c-variadic/not-async.rs              |  7 +++++++
 tests/ui/c-variadic/not-async.stderr          | 19 +++++++++++++++++++
 .../note-and-explain-ReVar-124973.rs          |  3 ++-
 .../note-and-explain-ReVar-124973.stderr      |  8 +++++++-
 7 files changed, 60 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/c-variadic/not-async.rs
 create mode 100644 tests/ui/c-variadic/not-async.stderr

diff --git a/compiler/rustc_ast_passes/messages.ftl b/compiler/rustc_ast_passes/messages.ftl
index e5f1fcdc4b40d..68ac2a05a4883 100644
--- a/compiler/rustc_ast_passes/messages.ftl
+++ b/compiler/rustc_ast_passes/messages.ftl
@@ -84,6 +84,10 @@ ast_passes_const_without_body =
 ast_passes_constraint_on_negative_bound =
     associated type constraints not allowed on negative bounds
 
+ast_passes_coroutine_and_c_variadic = functions cannot be both `{$coroutine_kind}` and C-variadic
+    .const = `{$coroutine_kind}` because of this
+    .variadic = C-variadic because of this
+
 ast_passes_equality_in_where = equality constraints are not yet supported in `where` clauses
     .label = not supported
     .suggestion = if `{$ident}` is an associated type you're trying to set, use the associated type binding syntax
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index 538918a890d52..672c1e9441884 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -685,6 +685,15 @@ impl<'a> AstValidator<'a> {
             });
         }
 
+        if let Some(coroutine_kind) = sig.header.coroutine_kind {
+            self.dcx().emit_err(errors::CoroutineAndCVariadic {
+                spans: vec![coroutine_kind.span(), variadic_param.span],
+                coroutine_kind: coroutine_kind.as_str(),
+                coroutine_span: coroutine_kind.span(),
+                variadic_span: variadic_param.span,
+            });
+        }
+
         match fn_ctxt {
             FnCtxt::Foreign => return,
             FnCtxt::Free => match sig.header.ext {
diff --git a/compiler/rustc_ast_passes/src/errors.rs b/compiler/rustc_ast_passes/src/errors.rs
index 476ed27a10e3c..f8806ef21c16d 100644
--- a/compiler/rustc_ast_passes/src/errors.rs
+++ b/compiler/rustc_ast_passes/src/errors.rs
@@ -659,6 +659,18 @@ pub(crate) struct ConstAndCVariadic {
     pub variadic_span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(ast_passes_coroutine_and_c_variadic)]
+pub(crate) struct CoroutineAndCVariadic {
+    #[primary_span]
+    pub spans: Vec<Span>,
+    pub coroutine_kind: &'static str,
+    #[label(ast_passes_const)]
+    pub coroutine_span: Span,
+    #[label(ast_passes_variadic)]
+    pub variadic_span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(ast_passes_pattern_in_foreign, code = E0130)]
 // FIXME: deduplicate with rustc_lint (`BuiltinLintDiag::PatternsInFnsWithoutBody`)
diff --git a/tests/ui/c-variadic/not-async.rs b/tests/ui/c-variadic/not-async.rs
new file mode 100644
index 0000000000000..45a7e1f8972bf
--- /dev/null
+++ b/tests/ui/c-variadic/not-async.rs
@@ -0,0 +1,7 @@
+//@ edition: 2021
+#![feature(c_variadic)]
+#![crate_type = "lib"]
+
+async unsafe extern "C" fn cannot_be_async(x: isize, ...) {}
+//~^ ERROR functions cannot be both `async` and C-variadic
+//~| ERROR hidden type for `impl Future<Output = ()>` captures lifetime that does not appear in bounds
diff --git a/tests/ui/c-variadic/not-async.stderr b/tests/ui/c-variadic/not-async.stderr
new file mode 100644
index 0000000000000..b8caf0d8bd852
--- /dev/null
+++ b/tests/ui/c-variadic/not-async.stderr
@@ -0,0 +1,19 @@
+error: functions cannot be both `async` and C-variadic
+  --> $DIR/not-async.rs:5:1
+   |
+LL | async unsafe extern "C" fn cannot_be_async(x: isize, ...) {}
+   | ^^^^^ `async` because of this                        ^^^ C-variadic because of this
+
+error[E0700]: hidden type for `impl Future<Output = ()>` captures lifetime that does not appear in bounds
+  --> $DIR/not-async.rs:5:59
+   |
+LL | async unsafe extern "C" fn cannot_be_async(x: isize, ...) {}
+   | --------------------------------------------------------- ^^
+   | |
+   | opaque type defined here
+   |
+   = note: hidden type `{async fn body of cannot_be_async()}` captures lifetime `'_`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0700`.
diff --git a/tests/ui/inference/note-and-explain-ReVar-124973.rs b/tests/ui/inference/note-and-explain-ReVar-124973.rs
index f1e2464563699..aa4b909fa76c8 100644
--- a/tests/ui/inference/note-and-explain-ReVar-124973.rs
+++ b/tests/ui/inference/note-and-explain-ReVar-124973.rs
@@ -3,6 +3,7 @@
 #![feature(c_variadic)]
 
 async unsafe extern "C" fn multiple_named_lifetimes<'a, 'b>(_: u8, ...) {}
-//~^ ERROR hidden type for `impl Future<Output = ()>` captures lifetime that does not appear in bounds
+//~^ ERROR functions cannot be both `async` and C-variadic
+//~| ERROR hidden type for `impl Future<Output = ()>` captures lifetime that does not appear in bounds
 
 fn main() {}
diff --git a/tests/ui/inference/note-and-explain-ReVar-124973.stderr b/tests/ui/inference/note-and-explain-ReVar-124973.stderr
index 574f6508e4c78..964fbc4a4fb7a 100644
--- a/tests/ui/inference/note-and-explain-ReVar-124973.stderr
+++ b/tests/ui/inference/note-and-explain-ReVar-124973.stderr
@@ -1,3 +1,9 @@
+error: functions cannot be both `async` and C-variadic
+  --> $DIR/note-and-explain-ReVar-124973.rs:5:1
+   |
+LL | async unsafe extern "C" fn multiple_named_lifetimes<'a, 'b>(_: u8, ...) {}
+   | ^^^^^ `async` because of this                                      ^^^ C-variadic because of this
+
 error[E0700]: hidden type for `impl Future<Output = ()>` captures lifetime that does not appear in bounds
   --> $DIR/note-and-explain-ReVar-124973.rs:5:73
    |
@@ -8,6 +14,6 @@ LL | async unsafe extern "C" fn multiple_named_lifetimes<'a, 'b>(_: u8, ...) {}
    |
    = note: hidden type `{async fn body of multiple_named_lifetimes<'a, 'b>()}` captures lifetime `'_`
 
-error: aborting due to 1 previous error
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0700`.

From a093372e5e560b1a768971c2b87b306755f2c17d Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sat, 6 Sep 2025 15:13:02 +0200
Subject: [PATCH 0677/1889] disallow c-variadic associated functions (for now)

there is no reason this should not work, really, we're just cutting some scope for now
---
 compiler/rustc_ast_passes/messages.ftl         |  2 ++
 .../rustc_ast_passes/src/ast_validation.rs     | 14 +++++++++-----
 compiler/rustc_ast_passes/src/errors.rs        |  7 +++++++
 .../feature-gates/feature-gate-c_variadic.rs   |  8 ++++----
 .../feature-gate-c_variadic.stderr             | 12 ++++++------
 .../variadic-ffi-semantic-restrictions.rs      | 18 +++++++++---------
 .../variadic-ffi-semantic-restrictions.stderr  | 18 +++++++++---------
 7 files changed, 46 insertions(+), 33 deletions(-)

diff --git a/compiler/rustc_ast_passes/messages.ftl b/compiler/rustc_ast_passes/messages.ftl
index 68ac2a05a4883..6eb4e4bc45272 100644
--- a/compiler/rustc_ast_passes/messages.ftl
+++ b/compiler/rustc_ast_passes/messages.ftl
@@ -66,6 +66,8 @@ ast_passes_body_in_extern = incorrect `{$kind}` inside `extern` block
 
 ast_passes_bound_in_context = bounds on `type`s in {$ctx} have no effect
 
+ast_passes_c_variadic_associated_function = associated functions cannot have a C variable argument list
+
 ast_passes_const_and_c_variadic = functions cannot be both `const` and C-variadic
     .const = `const` because of this
     .variadic = C-variadic because of this
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index 672c1e9441884..c5c23c47e74e2 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -704,12 +704,16 @@ impl<'a> AstValidator<'a> {
                 {
                     return;
                 }
-                _ => {}
+                _ => {
+                    self.dcx().emit_err(errors::BadCVariadic { span: variadic_param.span });
+                }
             },
-            FnCtxt::Assoc(_) => {}
-        };
-
-        self.dcx().emit_err(errors::BadCVariadic { span: variadic_param.span });
+            FnCtxt::Assoc(_) => {
+                // For now, C variable argument lists are unsupported in associated functions.
+                let err = errors::CVariadicAssociatedFunction { span: variadic_param.span };
+                self.dcx().emit_err(err);
+            }
+        }
     }
 
     fn check_item_named(&self, ident: Ident, kind: &str) {
diff --git a/compiler/rustc_ast_passes/src/errors.rs b/compiler/rustc_ast_passes/src/errors.rs
index f8806ef21c16d..a085e09fe9483 100644
--- a/compiler/rustc_ast_passes/src/errors.rs
+++ b/compiler/rustc_ast_passes/src/errors.rs
@@ -318,6 +318,13 @@ pub(crate) struct ExternItemAscii {
     pub block: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(ast_passes_c_variadic_associated_function)]
+pub(crate) struct CVariadicAssociatedFunction {
+    #[primary_span]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(ast_passes_bad_c_variadic)]
 pub(crate) struct BadCVariadic {
diff --git a/tests/ui/feature-gates/feature-gate-c_variadic.rs b/tests/ui/feature-gates/feature-gate-c_variadic.rs
index 45c688420931d..88d91dbd081fb 100644
--- a/tests/ui/feature-gates/feature-gate-c_variadic.rs
+++ b/tests/ui/feature-gates/feature-gate-c_variadic.rs
@@ -1,10 +1,10 @@
-#![crate_type="lib"]
+#![crate_type = "lib"]
 
-pub unsafe extern "C" fn test(_: i32, ap: ...) { }
+pub unsafe extern "C" fn test(_: i32, ap: ...) {}
 //~^ ERROR C-variadic functions are unstable
 
 trait Trait {
-    unsafe extern "C" fn trait_test(_: i32, ap: ...) { }
+    unsafe extern "C" fn trait_test(_: i32, ap: ...) {}
     //~^ ERROR C-variadic functions are unstable
-    //~| ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+    //~| ERROR associated functions cannot have a C variable argument list
 }
diff --git a/tests/ui/feature-gates/feature-gate-c_variadic.stderr b/tests/ui/feature-gates/feature-gate-c_variadic.stderr
index e30a2f1ede367..808aa20948d03 100644
--- a/tests/ui/feature-gates/feature-gate-c_variadic.stderr
+++ b/tests/ui/feature-gates/feature-gate-c_variadic.stderr
@@ -1,14 +1,14 @@
-error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+error: associated functions cannot have a C variable argument list
   --> $DIR/feature-gate-c_variadic.rs:7:45
    |
-LL |     unsafe extern "C" fn trait_test(_: i32, ap: ...) { }
+LL |     unsafe extern "C" fn trait_test(_: i32, ap: ...) {}
    |                                             ^^^^^^^
 
 error[E0658]: C-variadic functions are unstable
   --> $DIR/feature-gate-c_variadic.rs:3:1
    |
-LL | pub unsafe extern "C" fn test(_: i32, ap: ...) { }
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | pub unsafe extern "C" fn test(_: i32, ap: ...) {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: see issue #44930 <https://github.com/rust-lang/rust/issues/44930> for more information
    = help: add `#![feature(c_variadic)]` to the crate attributes to enable
@@ -17,8 +17,8 @@ LL | pub unsafe extern "C" fn test(_: i32, ap: ...) { }
 error[E0658]: C-variadic functions are unstable
   --> $DIR/feature-gate-c_variadic.rs:7:5
    |
-LL |     unsafe extern "C" fn trait_test(_: i32, ap: ...) { }
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     unsafe extern "C" fn trait_test(_: i32, ap: ...) {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: see issue #44930 <https://github.com/rust-lang/rust/issues/44930> for more information
    = help: add `#![feature(c_variadic)]` to the crate attributes to enable
diff --git a/tests/ui/parser/variadic-ffi-semantic-restrictions.rs b/tests/ui/parser/variadic-ffi-semantic-restrictions.rs
index 243924e6c53ee..e76bdc21fa043 100644
--- a/tests/ui/parser/variadic-ffi-semantic-restrictions.rs
+++ b/tests/ui/parser/variadic-ffi-semantic-restrictions.rs
@@ -50,30 +50,30 @@ struct X;
 
 impl X {
     fn i_f1(x: isize, ...) {}
-    //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+    //~^ ERROR associated functions cannot have a C variable argument list
     fn i_f2(...) {}
-    //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+    //~^ ERROR associated functions cannot have a C variable argument list
     fn i_f3(..., x: isize, ...) {}
-    //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+    //~^ ERROR associated functions cannot have a C variable argument list
     //~| ERROR `...` must be the last argument of a C-variadic function
     fn i_f4(..., x: isize, ...) {}
-    //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+    //~^ ERROR associated functions cannot have a C variable argument list
     //~| ERROR `...` must be the last argument of a C-variadic function
     const fn i_f5(x: isize, ...) {}
-    //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+    //~^ ERROR associated functions cannot have a C variable argument list
     //~| ERROR functions cannot be both `const` and C-variadic
     //~| ERROR destructor of `VaListImpl<'_>` cannot be evaluated at compile-time
 }
 
 trait T {
     fn t_f1(x: isize, ...) {}
-    //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+    //~^ ERROR associated functions cannot have a C variable argument list
     fn t_f2(x: isize, ...);
-    //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+    //~^ ERROR associated functions cannot have a C variable argument list
     fn t_f3(...) {}
-    //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+    //~^ ERROR associated functions cannot have a C variable argument list
     fn t_f4(...);
-    //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+    //~^ ERROR associated functions cannot have a C variable argument list
     fn t_f5(..., x: isize) {}
     //~^ ERROR `...` must be the last argument of a C-variadic function
     fn t_f6(..., x: isize);
diff --git a/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr b/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr
index 5c55cc38b5682..1317f63a88adc 100644
--- a/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr
+++ b/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr
@@ -88,13 +88,13 @@ error: `...` must be the last argument of a C-variadic function
 LL |     fn e_f2(..., x: isize);
    |             ^^^
 
-error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+error: associated functions cannot have a C variable argument list
   --> $DIR/variadic-ffi-semantic-restrictions.rs:52:23
    |
 LL |     fn i_f1(x: isize, ...) {}
    |                       ^^^
 
-error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+error: associated functions cannot have a C variable argument list
   --> $DIR/variadic-ffi-semantic-restrictions.rs:54:13
    |
 LL |     fn i_f2(...) {}
@@ -106,7 +106,7 @@ error: `...` must be the last argument of a C-variadic function
 LL |     fn i_f3(..., x: isize, ...) {}
    |             ^^^
 
-error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+error: associated functions cannot have a C variable argument list
   --> $DIR/variadic-ffi-semantic-restrictions.rs:56:28
    |
 LL |     fn i_f3(..., x: isize, ...) {}
@@ -118,7 +118,7 @@ error: `...` must be the last argument of a C-variadic function
 LL |     fn i_f4(..., x: isize, ...) {}
    |             ^^^
 
-error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+error: associated functions cannot have a C variable argument list
   --> $DIR/variadic-ffi-semantic-restrictions.rs:59:28
    |
 LL |     fn i_f4(..., x: isize, ...) {}
@@ -132,31 +132,31 @@ LL |     const fn i_f5(x: isize, ...) {}
    |     |
    |     `const` because of this
 
-error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+error: associated functions cannot have a C variable argument list
   --> $DIR/variadic-ffi-semantic-restrictions.rs:62:29
    |
 LL |     const fn i_f5(x: isize, ...) {}
    |                             ^^^
 
-error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+error: associated functions cannot have a C variable argument list
   --> $DIR/variadic-ffi-semantic-restrictions.rs:69:23
    |
 LL |     fn t_f1(x: isize, ...) {}
    |                       ^^^
 
-error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+error: associated functions cannot have a C variable argument list
   --> $DIR/variadic-ffi-semantic-restrictions.rs:71:23
    |
 LL |     fn t_f2(x: isize, ...);
    |                       ^^^
 
-error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+error: associated functions cannot have a C variable argument list
   --> $DIR/variadic-ffi-semantic-restrictions.rs:73:13
    |
 LL |     fn t_f3(...) {}
    |             ^^^
 
-error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+error: associated functions cannot have a C variable argument list
   --> $DIR/variadic-ffi-semantic-restrictions.rs:75:13
    |
 LL |     fn t_f4(...);

From 7075000ae72c3ead855dc660a37c6bf263b7b452 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sat, 6 Sep 2025 17:19:01 +0200
Subject: [PATCH 0678/1889] clarify control flow of `check_c_variadic_type`

---
 .../rustc_ast_passes/src/ast_validation.rs    | 23 +++++++++++++------
 1 file changed, 16 insertions(+), 7 deletions(-)

diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index c5c23c47e74e2..79947b514b10b 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -697,14 +697,23 @@ impl<'a> AstValidator<'a> {
         match fn_ctxt {
             FnCtxt::Foreign => return,
             FnCtxt::Free => match sig.header.ext {
-                Extern::Explicit(StrLit { symbol_unescaped: sym::C, .. }, _)
-                | Extern::Explicit(StrLit { symbol_unescaped: sym::C_dash_unwind, .. }, _)
-                | Extern::Implicit(_)
-                    if matches!(sig.header.safety, Safety::Unsafe(_)) =>
-                {
-                    return;
+                Extern::Implicit(_) => {
+                    if matches!(sig.header.safety, Safety::Unsafe(_)) {
+                        return;
+                    }
+
+                    self.dcx().emit_err(errors::BadCVariadic { span: variadic_param.span });
+                }
+                Extern::Explicit(StrLit { symbol_unescaped, .. }, _) => {
+                    if matches!(symbol_unescaped, sym::C | sym::C_dash_unwind) {
+                        if matches!(sig.header.safety, Safety::Unsafe(_)) {
+                            return;
+                        }
+                    }
+
+                    self.dcx().emit_err(errors::BadCVariadic { span: variadic_param.span });
                 }
-                _ => {
+                Extern::None => {
                     self.dcx().emit_err(errors::BadCVariadic { span: variadic_param.span });
                 }
             },

From f7dbd752fd9abcd419ee6bdf1cccd5e806e2d6e7 Mon Sep 17 00:00:00 2001
From: rustbot <47979223+rustbot@users.noreply.github.com>
Date: Mon, 8 Sep 2025 19:01:31 +0200
Subject: [PATCH 0679/1889] Update books

---
 src/doc/nomicon         | 2 +-
 src/doc/reference       | 2 +-
 src/doc/rust-by-example | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/doc/nomicon b/src/doc/nomicon
index 57ed447366056..f17a018b99894 160000
--- a/src/doc/nomicon
+++ b/src/doc/nomicon
@@ -1 +1 @@
-Subproject commit 57ed4473660565d9357fcae176b358d7e8724ebf
+Subproject commit f17a018b9989430967d1c58e9a12c51169abc744
diff --git a/src/doc/reference b/src/doc/reference
index 89f67b3c1b904..b3ce60628c6f5 160000
--- a/src/doc/reference
+++ b/src/doc/reference
@@ -1 +1 @@
-Subproject commit 89f67b3c1b904cbcd9ed55e443d6fc67c8ca2769
+Subproject commit b3ce60628c6f55ab8ff3dba9f3d20203df1c0dee
diff --git a/src/doc/rust-by-example b/src/doc/rust-by-example
index ad27f82c18464..dd26bc8e726dc 160000
--- a/src/doc/rust-by-example
+++ b/src/doc/rust-by-example
@@ -1 +1 @@
-Subproject commit ad27f82c18464525c761a4a8db2e01785da59e1f
+Subproject commit dd26bc8e726dc2e73534c8972d4dccd1bed7495f

From 2b9fce8c8cf4373ee9da938ad5eeb97e85ca2739 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sat, 6 Sep 2025 17:23:34 +0200
Subject: [PATCH 0680/1889] c-variadic: reject non-extern functions

---
 compiler/rustc_ast_passes/messages.ftl        |  2 ++
 .../rustc_ast_passes/src/ast_validation.rs    |  3 ++-
 compiler/rustc_ast_passes/src/errors.rs       |  7 +++++++
 tests/ui/c-variadic/issue-86053-1.rs          |  2 +-
 tests/ui/c-variadic/issue-86053-1.stderr      |  2 +-
 .../issue-83499-input-output-iteration-ice.rs |  5 ++---
 ...ue-83499-input-output-iteration-ice.stderr | 20 +++++++------------
 .../variadic-ffi-semantic-restrictions.rs     |  4 ++--
 .../variadic-ffi-semantic-restrictions.stderr |  4 ++--
 9 files changed, 26 insertions(+), 23 deletions(-)

diff --git a/compiler/rustc_ast_passes/messages.ftl b/compiler/rustc_ast_passes/messages.ftl
index 6eb4e4bc45272..958797a608947 100644
--- a/compiler/rustc_ast_passes/messages.ftl
+++ b/compiler/rustc_ast_passes/messages.ftl
@@ -68,6 +68,8 @@ ast_passes_bound_in_context = bounds on `type`s in {$ctx} have no effect
 
 ast_passes_c_variadic_associated_function = associated functions cannot have a C variable argument list
 
+ast_passes_c_variadic_no_extern = `...` is not supported for non-extern functions
+
 ast_passes_const_and_c_variadic = functions cannot be both `const` and C-variadic
     .const = `const` because of this
     .variadic = C-variadic because of this
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index 79947b514b10b..bbba235a6d16b 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -714,7 +714,8 @@ impl<'a> AstValidator<'a> {
                     self.dcx().emit_err(errors::BadCVariadic { span: variadic_param.span });
                 }
                 Extern::None => {
-                    self.dcx().emit_err(errors::BadCVariadic { span: variadic_param.span });
+                    let err = errors::CVariadicNoExtern { span: variadic_param.span };
+                    self.dcx().emit_err(err);
                 }
             },
             FnCtxt::Assoc(_) => {
diff --git a/compiler/rustc_ast_passes/src/errors.rs b/compiler/rustc_ast_passes/src/errors.rs
index a085e09fe9483..6b57e5ef37613 100644
--- a/compiler/rustc_ast_passes/src/errors.rs
+++ b/compiler/rustc_ast_passes/src/errors.rs
@@ -325,6 +325,13 @@ pub(crate) struct CVariadicAssociatedFunction {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(ast_passes_c_variadic_no_extern)]
+pub(crate) struct CVariadicNoExtern {
+    #[primary_span]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(ast_passes_bad_c_variadic)]
 pub(crate) struct BadCVariadic {
diff --git a/tests/ui/c-variadic/issue-86053-1.rs b/tests/ui/c-variadic/issue-86053-1.rs
index 537d0263adf78..58dfee55cf885 100644
--- a/tests/ui/c-variadic/issue-86053-1.rs
+++ b/tests/ui/c-variadic/issue-86053-1.rs
@@ -13,6 +13,6 @@ fn ordering4 < 'a , 'b     > ( a :            ,   self , self ,   self ,
     //~| ERROR unexpected `self` parameter in function
     //~| ERROR unexpected `self` parameter in function
     //~| ERROR `...` must be the last argument of a C-variadic function
-    //~| ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+    //~| ERROR `...` is not supported for non-extern functions
     //~| ERROR cannot find type `F` in this scope
 }
diff --git a/tests/ui/c-variadic/issue-86053-1.stderr b/tests/ui/c-variadic/issue-86053-1.stderr
index b58016b5a8165..eb08370b4f800 100644
--- a/tests/ui/c-variadic/issue-86053-1.stderr
+++ b/tests/ui/c-variadic/issue-86053-1.stderr
@@ -46,7 +46,7 @@ error: `...` must be the last argument of a C-variadic function
 LL |     self , ... ,   self ,   self , ... ) where F : FnOnce ( & 'a & 'b usize ) {
    |            ^^^
 
-error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+error: `...` is not supported for non-extern functions
   --> $DIR/issue-86053-1.rs:11:36
    |
 LL |     self , ... ,   self ,   self , ... ) where F : FnOnce ( & 'a & 'b usize ) {
diff --git a/tests/ui/mir/issue-83499-input-output-iteration-ice.rs b/tests/ui/mir/issue-83499-input-output-iteration-ice.rs
index 9277994d9b30f..dc0d14bf9d6b6 100644
--- a/tests/ui/mir/issue-83499-input-output-iteration-ice.rs
+++ b/tests/ui/mir/issue-83499-input-output-iteration-ice.rs
@@ -4,7 +4,6 @@
 
 fn main() {}
 
-fn foo(_: Bar, ...) -> impl {}
-//~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
-//~| ERROR cannot find type `Bar` in this scope
+unsafe extern "C" fn foo(_: Bar, ...) -> impl {}
+//~^ ERROR cannot find type `Bar` in this scope
 //~| ERROR at least one trait must be specified
diff --git a/tests/ui/mir/issue-83499-input-output-iteration-ice.stderr b/tests/ui/mir/issue-83499-input-output-iteration-ice.stderr
index 4a1aa49eb6e6f..31a393e7367a3 100644
--- a/tests/ui/mir/issue-83499-input-output-iteration-ice.stderr
+++ b/tests/ui/mir/issue-83499-input-output-iteration-ice.stderr
@@ -1,21 +1,15 @@
-error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
-  --> $DIR/issue-83499-input-output-iteration-ice.rs:7:16
-   |
-LL | fn foo(_: Bar, ...) -> impl {}
-   |                ^^^
-
 error: at least one trait must be specified
-  --> $DIR/issue-83499-input-output-iteration-ice.rs:7:24
+  --> $DIR/issue-83499-input-output-iteration-ice.rs:7:42
    |
-LL | fn foo(_: Bar, ...) -> impl {}
-   |                        ^^^^
+LL | unsafe extern "C" fn foo(_: Bar, ...) -> impl {}
+   |                                          ^^^^
 
 error[E0412]: cannot find type `Bar` in this scope
-  --> $DIR/issue-83499-input-output-iteration-ice.rs:7:11
+  --> $DIR/issue-83499-input-output-iteration-ice.rs:7:29
    |
-LL | fn foo(_: Bar, ...) -> impl {}
-   |           ^^^ not found in this scope
+LL | unsafe extern "C" fn foo(_: Bar, ...) -> impl {}
+   |                             ^^^ not found in this scope
 
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/parser/variadic-ffi-semantic-restrictions.rs b/tests/ui/parser/variadic-ffi-semantic-restrictions.rs
index e76bdc21fa043..fe5421ab2c0ae 100644
--- a/tests/ui/parser/variadic-ffi-semantic-restrictions.rs
+++ b/tests/ui/parser/variadic-ffi-semantic-restrictions.rs
@@ -4,10 +4,10 @@
 fn main() {}
 
 fn f1_1(x: isize, ...) {}
-//~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+//~^ ERROR `...` is not supported for non-extern functions
 
 fn f1_2(...) {}
-//~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+//~^ ERROR `...` is not supported for non-extern functions
 
 extern "C" fn f2_1(x: isize, ...) {}
 //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
diff --git a/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr b/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr
index 1317f63a88adc..0abe152640530 100644
--- a/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr
+++ b/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr
@@ -1,10 +1,10 @@
-error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+error: `...` is not supported for non-extern functions
   --> $DIR/variadic-ffi-semantic-restrictions.rs:6:19
    |
 LL | fn f1_1(x: isize, ...) {}
    |                   ^^^
 
-error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+error: `...` is not supported for non-extern functions
   --> $DIR/variadic-ffi-semantic-restrictions.rs:9:9
    |
 LL | fn f1_2(...) {}

From 2912efa879912b56f4676eaa3024382b040144f5 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Mon, 8 Sep 2025 19:07:35 +0200
Subject: [PATCH 0681/1889] c-variadic: update cmse-nonsecure example

---
 .../cmse-nonsecure-entry/generics.rs          | 10 +++-----
 .../cmse-nonsecure-entry/generics.stderr      | 24 +++++++++----------
 2 files changed, 15 insertions(+), 19 deletions(-)

diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs
index ad4fca8252d24..4ebc2bbf76129 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs
@@ -53,9 +53,7 @@ extern "cmse-nonsecure-entry" fn trait_object(x: &dyn Trait) -> &dyn Trait {
     x
 }
 
-extern "cmse-nonsecure-entry" fn static_trait_object(
-    x: &'static dyn Trait,
-) -> &'static dyn Trait {
+extern "cmse-nonsecure-entry" fn static_trait_object(x: &'static dyn Trait) -> &'static dyn Trait {
     //~^ ERROR return value of `"cmse-nonsecure-entry"` function too large to pass via registers [E0798]
     x
 }
@@ -63,14 +61,12 @@ extern "cmse-nonsecure-entry" fn static_trait_object(
 #[repr(transparent)]
 struct WrapperTransparent<'a>(&'a dyn Trait);
 
-extern "cmse-nonsecure-entry" fn wrapped_trait_object(
-    x: WrapperTransparent,
-) -> WrapperTransparent {
+extern "cmse-nonsecure-entry" fn wrapped_trait_object(x: WrapperTransparent) -> WrapperTransparent {
     //~^ ERROR return value of `"cmse-nonsecure-entry"` function too large to pass via registers [E0798]
     x
 }
 
-extern "cmse-nonsecure-entry" fn c_variadic(_: u32, _: ...) {
+unsafe extern "cmse-nonsecure-entry" fn c_variadic(_: u32, _: ...) {
     //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
     //~| ERROR requires `va_list` lang_item
 }
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr
index 7aeb6969feb9f..55921e764ba21 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr
@@ -1,8 +1,8 @@
 error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
-  --> $DIR/generics.rs:73:53
+  --> $DIR/generics.rs:69:60
    |
-LL | extern "cmse-nonsecure-entry" fn c_variadic(_: u32, _: ...) {
-   |                                                     ^^^^^^
+LL | unsafe extern "cmse-nonsecure-entry" fn c_variadic(_: u32, _: ...) {
+   |                                                            ^^^^^^
 
 error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
   --> $DIR/generics.rs:30:1
@@ -50,28 +50,28 @@ LL | extern "cmse-nonsecure-entry" fn trait_object(x: &dyn Trait) -> &dyn Trait
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0798]: return value of `"cmse-nonsecure-entry"` function too large to pass via registers
-  --> $DIR/generics.rs:58:6
+  --> $DIR/generics.rs:56:80
    |
-LL | ) -> &'static dyn Trait {
-   |      ^^^^^^^^^^^^^^^^^^ this type doesn't fit in the available registers
+LL | extern "cmse-nonsecure-entry" fn static_trait_object(x: &'static dyn Trait) -> &'static dyn Trait {
+   |                                                                                ^^^^^^^^^^^^^^^^^^ this type doesn't fit in the available registers
    |
    = note: functions with the `"cmse-nonsecure-entry"` ABI must pass their result via the available return registers
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0798]: return value of `"cmse-nonsecure-entry"` function too large to pass via registers
-  --> $DIR/generics.rs:68:6
+  --> $DIR/generics.rs:64:81
    |
-LL | ) -> WrapperTransparent {
-   |      ^^^^^^^^^^^^^^^^^^ this type doesn't fit in the available registers
+LL | extern "cmse-nonsecure-entry" fn wrapped_trait_object(x: WrapperTransparent) -> WrapperTransparent {
+   |                                                                                 ^^^^^^^^^^^^^^^^^^ this type doesn't fit in the available registers
    |
    = note: functions with the `"cmse-nonsecure-entry"` ABI must pass their result via the available return registers
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error: requires `va_list` lang_item
-  --> $DIR/generics.rs:73:53
+  --> $DIR/generics.rs:69:60
    |
-LL | extern "cmse-nonsecure-entry" fn c_variadic(_: u32, _: ...) {
-   |                                                     ^^^^^^
+LL | unsafe extern "cmse-nonsecure-entry" fn c_variadic(_: u32, _: ...) {
+   |                                                            ^^^^^^
 
 error: aborting due to 9 previous errors
 

From 5de9bc73e76f60ee27c37f20d0a9530e5a957df7 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Mon, 7 Jul 2025 11:52:14 +0200
Subject: [PATCH 0682/1889] Refactor how to get the span of a function header

---
 compiler/rustc_ast/src/ast.rs                 | 67 +++++++++----------
 .../rustc_ast_passes/src/ast_validation.rs    |  2 +-
 2 files changed, 32 insertions(+), 37 deletions(-)

diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index 802a6fa324984..2733a2603d6d8 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -2284,6 +2284,33 @@ pub struct FnSig {
     pub span: Span,
 }
 
+impl FnSig {
+    /// Return a span encompassing the header, or where to insert it if empty.
+    pub fn header_span(&self) -> Span {
+        match self.header.ext {
+            Extern::Implicit(span) | Extern::Explicit(_, span) => {
+                return self.span.with_hi(span.hi());
+            }
+            Extern::None => {}
+        }
+
+        match self.header.safety {
+            Safety::Unsafe(span) | Safety::Safe(span) => return self.span.with_hi(span.hi()),
+            Safety::Default => {}
+        };
+
+        if let Some(coroutine_kind) = self.header.coroutine_kind {
+            return self.span.with_hi(coroutine_kind.span().hi());
+        }
+
+        if let Const::Yes(span) = self.header.constness {
+            return self.span.with_hi(span.hi());
+        }
+
+        self.span.shrink_to_lo()
+    }
+}
+
 /// A constraint on an associated item.
 ///
 /// ### Examples
@@ -3534,12 +3561,12 @@ impl Extern {
 /// included in this struct (e.g., `async unsafe fn` or `const extern "C" fn`).
 #[derive(Clone, Copy, Encodable, Decodable, Debug, Walkable)]
 pub struct FnHeader {
-    /// Whether this is `unsafe`, or has a default safety.
-    pub safety: Safety,
-    /// Whether this is `async`, `gen`, or nothing.
-    pub coroutine_kind: Option<CoroutineKind>,
     /// The `const` keyword, if any
     pub constness: Const,
+    /// Whether this is `async`, `gen`, or nothing.
+    pub coroutine_kind: Option<CoroutineKind>,
+    /// Whether this is `unsafe`, or has a default safety.
+    pub safety: Safety,
     /// The `extern` keyword and corresponding ABI string, if any.
     pub ext: Extern,
 }
@@ -3553,38 +3580,6 @@ impl FnHeader {
             || matches!(constness, Const::Yes(_))
             || !matches!(ext, Extern::None)
     }
-
-    /// Return a span encompassing the header, or none if all options are default.
-    pub fn span(&self) -> Option<Span> {
-        fn append(a: &mut Option<Span>, b: Span) {
-            *a = match a {
-                None => Some(b),
-                Some(x) => Some(x.to(b)),
-            }
-        }
-
-        let mut full_span = None;
-
-        match self.safety {
-            Safety::Unsafe(span) | Safety::Safe(span) => append(&mut full_span, span),
-            Safety::Default => {}
-        };
-
-        if let Some(coroutine_kind) = self.coroutine_kind {
-            append(&mut full_span, coroutine_kind.span());
-        }
-
-        if let Const::Yes(span) = self.constness {
-            append(&mut full_span, span);
-        }
-
-        match self.ext {
-            Extern::Implicit(span) | Extern::Explicit(_, span) => append(&mut full_span, span),
-            Extern::None => {}
-        }
-
-        full_span
-    }
 }
 
 impl Default for FnHeader {
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index bbba235a6d16b..f425acda3583e 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -492,7 +492,7 @@ impl<'a> AstValidator<'a> {
         }
 
         if !spans.is_empty() {
-            let header_span = sig.header.span().unwrap_or(sig.span.shrink_to_lo());
+            let header_span = sig.header_span();
             let suggestion_span = header_span.shrink_to_hi().to(sig.decl.output.span());
             let padding = if header_span.is_empty() { "" } else { " " };
 

From 43a6f56ca78295164dbf964695a43be7e35b1994 Mon Sep 17 00:00:00 2001
From: IoaNNUwU <ioannxd@gmail.com>
Date: Mon, 8 Sep 2025 19:15:35 +0200
Subject: [PATCH 0683/1889] Apply requested changes

---
 compiler/rustc_builtin_macros/src/format.rs   | 44 +++++++------------
 tests/ui/fmt/ifmt-bad-arg.stderr              |  6 +--
 tests/ui/macros/format-unused-lables.stderr   |  9 ++--
 tests/ui/mir/unsized-extern-static.stderr     |  3 +-
 .../missing-format-specifiers-issue-68293.rs  |  4 +-
 ...ssing-format-specifiers-issue-68293.stderr |  6 +--
 6 files changed, 25 insertions(+), 47 deletions(-)

diff --git a/compiler/rustc_builtin_macros/src/format.rs b/compiler/rustc_builtin_macros/src/format.rs
index e5f73188dbdfa..a6c8e7d29cc7a 100644
--- a/compiler/rustc_builtin_macros/src/format.rs
+++ b/compiler/rustc_builtin_macros/src/format.rs
@@ -768,38 +768,24 @@ fn report_missing_placeholders(
         // Show example if user didn't use any format specifiers
         let show_example = used.iter().all(|used| !used);
 
-        if !show_example && unused.len() > 1 {
-            diag.note(format!("consider adding {} format specifiers", unused.len()));
-        }
-
-        let original_fmt_str = if fmt_str.len() >= 1 { &fmt_str[..fmt_str.len() - 1] } else { "" };
-
-        if show_example && unused.len() == 1 {
-            diag.note("format specifiers use curly braces: `{}`");
+        if !show_example {
+            if unused.len() > 1 {
+                diag.note(format!("consider adding {} format specifiers", unused.len()));
+            }
+        } else {
+            let original_fmt_str =
+                if fmt_str.len() >= 1 { &fmt_str[..fmt_str.len() - 1] } else { "" };
 
-            diag.span_suggestion_verbose(
-                fmt_span,
-                "consider adding format specifier",
-                format!("\"{}{{}}\"", original_fmt_str),
-                Applicability::MaybeIncorrect,
-            );
-        }
+            let msg = if unused.len() == 1 {
+                "a format specifier".to_string()
+            } else {
+                format!("{} format specifiers", unused.len())
+            };
 
-        if show_example && unused.len() > 1 {
-            diag.note("format specifiers use curly braces: `{}`");
+            let sugg = format!("\"{}{}\"", original_fmt_str, "{}".repeat(unused.len()));
+            let msg = format!("format specifiers use curly braces, consider adding {msg}");
 
-            let mut suggest_fixed_fmt = format!("\"{}", original_fmt_str);
-            for _ in &unused {
-                suggest_fixed_fmt.push_str("{}");
-            }
-            suggest_fixed_fmt.push('"');
-
-            diag.span_suggestion_verbose(
-                fmt_span,
-                format!("consider adding {} format specifiers", unused.len()),
-                suggest_fixed_fmt,
-                Applicability::MaybeIncorrect,
-            );
+            diag.span_suggestion_verbose(fmt_span, msg, sugg, Applicability::MaybeIncorrect);
         }
     }
 
diff --git a/tests/ui/fmt/ifmt-bad-arg.stderr b/tests/ui/fmt/ifmt-bad-arg.stderr
index 6ddc817290155..b565b836f211e 100644
--- a/tests/ui/fmt/ifmt-bad-arg.stderr
+++ b/tests/ui/fmt/ifmt-bad-arg.stderr
@@ -63,8 +63,7 @@ LL |     format!("", 1, 2);
    |             |   argument never used
    |             multiple missing formatting specifiers
    |
-   = note: format specifiers use curly braces: `{}`
-help: consider adding 2 format specifiers
+help: format specifiers use curly braces, consider adding 2 format specifiers
    |
 LL |     format!("{}{}", 1, 2);
    |              ++++
@@ -109,8 +108,7 @@ LL |     format!("", foo=2);
    |             |
    |             formatting specifier missing
    |
-   = note: format specifiers use curly braces: `{}`
-help: consider adding format specifier
+help: format specifiers use curly braces, consider adding a format specifier
    |
 LL |     format!("{}", foo=2);
    |              ++
diff --git a/tests/ui/macros/format-unused-lables.stderr b/tests/ui/macros/format-unused-lables.stderr
index 1c5cdcc2346d4..90eed8dd86b5a 100644
--- a/tests/ui/macros/format-unused-lables.stderr
+++ b/tests/ui/macros/format-unused-lables.stderr
@@ -8,8 +8,7 @@ LL |     println!("Test", 123, 456, 789);
    |              |       argument never used
    |              multiple missing formatting specifiers
    |
-   = note: format specifiers use curly braces: `{}`
-help: consider adding 3 format specifiers
+help: format specifiers use curly braces, consider adding 3 format specifiers
    |
 LL |     println!("Test{}{}{}", 123, 456, 789);
    |                   ++++++
@@ -26,8 +25,7 @@ LL |         456,
 LL |         789
    |         ^^^ argument never used
    |
-   = note: format specifiers use curly braces: `{}`
-help: consider adding 3 format specifiers
+help: format specifiers use curly braces, consider adding 3 format specifiers
    |
 LL |     println!("Test2{}{}{}",
    |                    ++++++
@@ -40,8 +38,7 @@ LL |     println!("Some stuff", UNUSED="args");
    |              |
    |              formatting specifier missing
    |
-   = note: format specifiers use curly braces: `{}`
-help: consider adding format specifier
+help: format specifiers use curly braces, consider adding a format specifier
    |
 LL |     println!("Some stuff{}", UNUSED="args");
    |                         ++
diff --git a/tests/ui/mir/unsized-extern-static.stderr b/tests/ui/mir/unsized-extern-static.stderr
index 005dc59d78f90..c0810e650ef12 100644
--- a/tests/ui/mir/unsized-extern-static.stderr
+++ b/tests/ui/mir/unsized-extern-static.stderr
@@ -6,8 +6,7 @@ LL |     println!("C", unsafe { &symbol });
    |              |
    |              formatting specifier missing
    |
-   = note: format specifiers use curly braces: `{}`
-help: consider adding format specifier
+help: format specifiers use curly braces, consider adding a format specifier
    |
 LL |     println!("C{}", unsafe { &symbol });
    |                ++
diff --git a/tests/ui/suggestions/missing-format-specifiers-issue-68293.rs b/tests/ui/suggestions/missing-format-specifiers-issue-68293.rs
index 2f5e962944153..29799624d7821 100644
--- a/tests/ui/suggestions/missing-format-specifiers-issue-68293.rs
+++ b/tests/ui/suggestions/missing-format-specifiers-issue-68293.rs
@@ -2,18 +2,18 @@ fn no_format_specifier_two_unused_args() {
     println!("Hello", "World");
     //~^ ERROR argument never used
     //~| NOTE formatting specifier missing
-    //~| NOTE format specifiers use curly braces: `{}`
     //~| NOTE argument never used
+    //~| HELP format specifiers use curly braces, consider adding a format specifier
 }
 
 fn no_format_specifier_multiple_unused_args() {
     println!("list: ", 1, 2, 3);
     //~^ ERROR multiple unused formatting arguments
     //~| NOTE multiple missing formatting specifiers
-    //~| NOTE format specifiers use curly braces: `{}`
     //~| NOTE argument never used
     //~| NOTE argument never used
     //~| NOTE argument never used
+    //~| HELP format specifiers use curly braces, consider adding 3 format specifiers
 }
 
 fn missing_format_specifiers_one_unused_arg() {
diff --git a/tests/ui/suggestions/missing-format-specifiers-issue-68293.stderr b/tests/ui/suggestions/missing-format-specifiers-issue-68293.stderr
index 961887a7e3faa..081409789f5a4 100644
--- a/tests/ui/suggestions/missing-format-specifiers-issue-68293.stderr
+++ b/tests/ui/suggestions/missing-format-specifiers-issue-68293.stderr
@@ -6,8 +6,7 @@ LL |     println!("Hello", "World");
    |              |
    |              formatting specifier missing
    |
-   = note: format specifiers use curly braces: `{}`
-help: consider adding format specifier
+help: format specifiers use curly braces, consider adding a format specifier
    |
 LL |     println!("Hello{}", "World");
    |                    ++
@@ -22,8 +21,7 @@ LL |     println!("list: ", 1, 2, 3);
    |              |         argument never used
    |              multiple missing formatting specifiers
    |
-   = note: format specifiers use curly braces: `{}`
-help: consider adding 3 format specifiers
+help: format specifiers use curly braces, consider adding 3 format specifiers
    |
 LL |     println!("list: {}{}{}", 1, 2, 3);
    |                     ++++++

From 8b58777968a4c663d6c1293bacff6da99e6e5203 Mon Sep 17 00:00:00 2001
From: nixxo <nixxo@protonmail.com>
Date: Thu, 4 Sep 2025 09:33:11 +0200
Subject: [PATCH 0684/1889] fix partial urlencoded link support

- added full urlencoding to properly check urlencoded anchor links against non-urlencoded heading IDs
- added tests

urlecoding provided by https://crates.io/crates/urlencoding
---
 Cargo.lock                                          |  7 +++++++
 src/tools/linkchecker/Cargo.toml                    |  1 +
 src/tools/linkchecker/main.rs                       | 13 +------------
 src/tools/linkchecker/tests/valid/inner/bar.html    |  3 +++
 src/tools/linkchecker/tests/valid/inner/foo.html    |  8 ++++++++
 .../linkchecker/tests/valid/inner/redir-target.html |  3 +++
 6 files changed, 23 insertions(+), 12 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 52f5048115753..fd4b661c40de7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2167,6 +2167,7 @@ version = "0.1.0"
 dependencies = [
  "html5ever",
  "regex",
+ "urlencoding",
 ]
 
 [[package]]
@@ -5825,6 +5826,12 @@ dependencies = [
  "percent-encoding",
 ]
 
+[[package]]
+name = "urlencoding"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"
+
 [[package]]
 name = "utf-8"
 version = "0.7.6"
diff --git a/src/tools/linkchecker/Cargo.toml b/src/tools/linkchecker/Cargo.toml
index fb5bff3fe63ff..f0886e31b243f 100644
--- a/src/tools/linkchecker/Cargo.toml
+++ b/src/tools/linkchecker/Cargo.toml
@@ -10,3 +10,4 @@ path = "main.rs"
 [dependencies]
 regex = "1"
 html5ever = "0.29.0"
+urlencoding = "2.1.3"
diff --git a/src/tools/linkchecker/main.rs b/src/tools/linkchecker/main.rs
index 1dc45728c90cd..e07a0784cdb3a 100644
--- a/src/tools/linkchecker/main.rs
+++ b/src/tools/linkchecker/main.rs
@@ -232,18 +232,7 @@ enum FileEntry {
 type Cache = HashMap<String, FileEntry>;
 
 fn small_url_encode(s: &str) -> String {
-    s.replace('<', "%3C")
-        .replace('>', "%3E")
-        .replace(' ', "%20")
-        .replace('?', "%3F")
-        .replace('\'', "%27")
-        .replace('&', "%26")
-        .replace(',', "%2C")
-        .replace(':', "%3A")
-        .replace(';', "%3B")
-        .replace('[', "%5B")
-        .replace(']', "%5D")
-        .replace('\"', "%22")
+    urlencoding::encode(s).to_string()
 }
 
 impl Checker {
diff --git a/src/tools/linkchecker/tests/valid/inner/bar.html b/src/tools/linkchecker/tests/valid/inner/bar.html
index 4b500d78b76e4..6ffda259c40eb 100644
--- a/src/tools/linkchecker/tests/valid/inner/bar.html
+++ b/src/tools/linkchecker/tests/valid/inner/bar.html
@@ -3,5 +3,8 @@
 
   <h2 id="barfrag">Bar</h2>
 
+  <!-- testing urlecoded anchor link against a non-urlencoded heading IDs -->
+  <h2 id="barfrag-è">Bar</h2>
+
 </body>
 </html>
diff --git a/src/tools/linkchecker/tests/valid/inner/foo.html b/src/tools/linkchecker/tests/valid/inner/foo.html
index 3c6a7483bcd46..f30bf71820519 100644
--- a/src/tools/linkchecker/tests/valid/inner/foo.html
+++ b/src/tools/linkchecker/tests/valid/inner/foo.html
@@ -8,7 +8,15 @@
   <a href="https://example.com/doesnotexist">external links not validated</a>
   <a href="redir.html#redirfrag">Redirect</a>
 
+  <!-- testing urlecoded anchor link against a non-urlencoded heading IDs -->
+  <a href="#localfrag-%C3%A8"></a>
+  <a href="bar.html#barfrag-%C3%A8"></a>
+  <a href="redir.html#redirfrag-%C3%A8"></a>
+
   <h2 id="localfrag">Local</h2>
 
+  <!-- testing urlecoded anchor link against a non-urlencoded heading IDs -->
+  <h2 id="localfrag-è">Local</h2>
+
 </body>
 </html>
diff --git a/src/tools/linkchecker/tests/valid/inner/redir-target.html b/src/tools/linkchecker/tests/valid/inner/redir-target.html
index bd59884a01ecf..ac1dec6d5b4aa 100644
--- a/src/tools/linkchecker/tests/valid/inner/redir-target.html
+++ b/src/tools/linkchecker/tests/valid/inner/redir-target.html
@@ -1,5 +1,8 @@
 <html>
 <body>
   <h2 id="redirfrag">Redir</h2>
+
+  <!-- testing urlecoded anchor link against a non-urlencoded heading IDs -->
+  <h2 id="redirfrag-è">Redir</h2>
 </body>
 </html>

From 224428d8fd5f4d2ad28b833d6e4502d4d7952f9b Mon Sep 17 00:00:00 2001
From: Wilfred Hughes <wilfred@meta.com>
Date: Mon, 8 Sep 2025 16:45:58 +0100
Subject: [PATCH 0685/1889] Clarify intro in README and manual

The first sentence a new user should see should ideally answer the
questions:

* What is rust-analyzer?
* Why might I want to use it?

The vast majority of users will be interested in using rust-analyzer
inside their favourite editor. We should clarify that rust-analyzer is
an LSP implementation and that it supports all the classic IDE
features.

Whilst it's also true that rust-analyzer is modular and organised into
libraries, the first impression should (I think) focus on an overview
and the primary use case.
---
 src/tools/rust-analyzer/README.md             | 17 +++++++++++++--
 .../rust-analyzer/docs/book/src/README.md     | 21 ++++++++++++-------
 2 files changed, 29 insertions(+), 9 deletions(-)

diff --git a/src/tools/rust-analyzer/README.md b/src/tools/rust-analyzer/README.md
index 4360dea4a113c..cb3a41eec5a62 100644
--- a/src/tools/rust-analyzer/README.md
+++ b/src/tools/rust-analyzer/README.md
@@ -4,8 +4,21 @@
     alt="rust-analyzer logo">
 </p>
 
-rust-analyzer is a modular compiler frontend for the Rust language.
-It is a part of a larger rls-2.0 effort to create excellent IDE support for Rust.
+rust-analyzer is a language server that provides IDE functionality for
+writing Rust programs. You can use it with any editor that supports
+the [Language Server
+Protocol](https://microsoft.github.io/language-server-protocol/) (VS
+Code, Vim, Emacs, Zed, etc).
+
+rust-analyzer features include go-to-definition, find-all-references,
+refactorings and code completion. rust-analyzer also supports
+integrated formatting (with rustfmt) and integrated diagnostics (with
+rustc and clippy).
+
+Internally, rust-analyzer is structured as a set of libraries for
+analyzing Rust code. See
+[Architecture](https://rust-analyzer.github.io/book/contributing/architecture.html)
+in the manual.
 
 ## Quick Start
 
diff --git a/src/tools/rust-analyzer/docs/book/src/README.md b/src/tools/rust-analyzer/docs/book/src/README.md
index 71f34e0346646..060bcf0cea399 100644
--- a/src/tools/rust-analyzer/docs/book/src/README.md
+++ b/src/tools/rust-analyzer/docs/book/src/README.md
@@ -1,13 +1,20 @@
 # rust-analyzer
 
-At its core, rust-analyzer is a **library** for semantic analysis of
-Rust code as it changes over time. This manual focuses on a specific
-usage of the library -- running it as part of a server that implements
+rust-analyzer is a language server that provides IDE functionality for
+writing Rust programs. You can use it with any editor that supports
 the [Language Server
-Protocol](https://microsoft.github.io/language-server-protocol/) (LSP).
-The LSP allows various code editors, like VS Code, Emacs or Vim, to
-implement semantic features like completion or goto definition by
-talking to an external language server process.
+Protocol](https://microsoft.github.io/language-server-protocol/) (VS
+Code, Vim, Emacs, Zed, etc).
+
+rust-analyzer features include go-to-definition, find-all-references,
+refactorings and code completion. rust-analyzer also supports
+integrated formatting (with rustfmt) and integrated diagnostics (with
+rustc and clippy).
+
+Internally, rust-analyzer is structured as a set of libraries for
+analyzing Rust code. See
+[Architecture](https://rust-analyzer.github.io/book/contributing/architecture.html)
+for more details.
 
 To improve this document, send a pull request:
 [https://github.com/rust-lang/rust-analyzer](https://github.com/rust-lang/rust-analyzer/blob/master/docs/book/README.md)

From d51f0ea172290f2e99e98a061c326af12edfbd3c Mon Sep 17 00:00:00 2001
From: Mads Marquart <mads@marquart.dk>
Date: Mon, 8 Sep 2025 19:06:24 +0200
Subject: [PATCH 0686/1889] Reorder test to make failures clearer

---
 library/std/src/sys/platform_version/darwin/tests.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/library/std/src/sys/platform_version/darwin/tests.rs b/library/std/src/sys/platform_version/darwin/tests.rs
index 76dc4482c9835..eecd58ec79e35 100644
--- a/library/std/src/sys/platform_version/darwin/tests.rs
+++ b/library/std/src/sys/platform_version/darwin/tests.rs
@@ -28,6 +28,9 @@ fn compare_against_sw_vers() {
     let subminor: i32 = sw_vers.next().unwrap_or("0").parse().unwrap();
     assert_eq!(sw_vers.count(), 0);
 
+    // Test directly against the lookup
+    assert_eq!(lookup_version().get(), pack_os_version(major as _, minor as _, subminor as _));
+
     // Current version is available
     assert_eq!(__isOSVersionAtLeast(major, minor, subminor), 1);
 
@@ -40,9 +43,6 @@ fn compare_against_sw_vers() {
     assert_eq!(__isOSVersionAtLeast(major, minor, subminor + 1), 0);
     assert_eq!(__isOSVersionAtLeast(major, minor + 1, subminor), 0);
     assert_eq!(__isOSVersionAtLeast(major + 1, minor, subminor), 0);
-
-    // Test directly against the lookup
-    assert_eq!(lookup_version().get(), pack_os_version(major as _, minor as _, subminor as _));
 }
 
 #[test]

From fe6f8cc6f5eef1e0dc5e51ca621b32208af0da3c Mon Sep 17 00:00:00 2001
From: Mads Marquart <mads@marquart.dk>
Date: Mon, 8 Sep 2025 20:10:08 +0200
Subject: [PATCH 0687/1889] Weakly export platform_version symbols

The symbols __isPlatformVersionAtLeast and __isOSVersionAtLeast.

This allows the user to link both compiler_rt and std.
---
 library/std/src/sys/platform_version/darwin/public_extern.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/library/std/src/sys/platform_version/darwin/public_extern.rs b/library/std/src/sys/platform_version/darwin/public_extern.rs
index 967cdb4920fd4..c0848d94798f2 100644
--- a/library/std/src/sys/platform_version/darwin/public_extern.rs
+++ b/library/std/src/sys/platform_version/darwin/public_extern.rs
@@ -77,6 +77,10 @@ use super::{current_version, pack_i32_os_version};
 // NOTE: This symbol has a workaround in the compiler's symbol mangling to avoid mangling it, while
 // still not exposing it from non-cdylib (like `#[no_mangle]` would).
 #[rustc_std_internal_symbol]
+// NOTE: Making this a weak symbol might not be entirely the right solution for this, `compiler_rt`
+// doesn't do that, it instead makes the symbol have "hidden" visibility. But since this is placed
+// in `libstd`, which might be used as a dylib, we cannot do the same here.
+#[linkage = "weak"]
 // extern "C" is correct, Clang assumes the function cannot unwind:
 // https://github.com/llvm/llvm-project/blob/llvmorg-20.1.0/clang/lib/CodeGen/CGObjC.cpp#L3980
 //
@@ -145,6 +149,7 @@ pub(super) extern "C" fn __isPlatformVersionAtLeast(
 /// Old entry point for availability. Used when compiling with older Clang versions.
 // SAFETY: Same as for `__isPlatformVersionAtLeast`.
 #[rustc_std_internal_symbol]
+#[linkage = "weak"]
 pub(super) extern "C" fn __isOSVersionAtLeast(major: i32, minor: i32, subminor: i32) -> i32 {
     let version = pack_i32_os_version(major, minor, subminor);
     (version <= current_version()) as i32

From a6a53ace86ad7ff23b6d84379391099862f3bd1a Mon Sep 17 00:00:00 2001
From: Ryan Mehri <rmehri01@pm.me>
Date: Mon, 8 Sep 2025 14:10:25 -0400
Subject: [PATCH 0688/1889] impl TryToNav for BuiltinType instead

---
 .../crates/ide-db/src/famous_defs.rs          |  4 +++
 .../crates/ide/src/goto_definition.rs         | 27 ++--------------
 .../crates/ide/src/navigation_target.rs       | 31 ++++++++++++++++---
 3 files changed, 32 insertions(+), 30 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-db/src/famous_defs.rs b/src/tools/rust-analyzer/crates/ide-db/src/famous_defs.rs
index 8e687385086fc..8eea2b81bab6d 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/famous_defs.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/famous_defs.rs
@@ -210,6 +210,10 @@ impl FamousDefs<'_, '_> {
     fn find_lang_crate(&self, origin: LangCrateOrigin) -> Option<Crate> {
         let krate = self.1;
         let db = self.0.db;
+        if krate.origin(db) == CrateOrigin::Lang(origin) {
+            return Some(krate);
+        }
+
         let res = krate
             .dependencies(db)
             .into_iter()
diff --git a/src/tools/rust-analyzer/crates/ide/src/goto_definition.rs b/src/tools/rust-analyzer/crates/ide/src/goto_definition.rs
index 002f5b3fe8f44..f768d4b68f469 100644
--- a/src/tools/rust-analyzer/crates/ide/src/goto_definition.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/goto_definition.rs
@@ -6,13 +6,12 @@ use crate::{
     navigation_target::{self, ToNav},
 };
 use hir::{
-    AsAssocItem, AssocItem, CallableKind, FileRange, HasCrate, InFile, ModuleDef, PathResolution,
-    Semantics, sym,
+    AsAssocItem, AssocItem, CallableKind, FileRange, HasCrate, InFile, ModuleDef, Semantics, sym,
 };
 use ide_db::{
     RootDatabase, SymbolKind,
     base_db::{AnchoredPath, SourceDatabase},
-    defs::{Definition, IdentClass, find_std_module},
+    defs::{Definition, IdentClass},
     famous_defs::FamousDefs,
     helpers::pick_best_token,
 };
@@ -91,9 +90,6 @@ pub(crate) fn goto_definition(
             if let Some(navs) = find_definition_for_known_blanket_dual_impls(sema, &token.value) {
                 return Some(navs);
             }
-            if let Some(navs) = find_definition_for_builtin_types(sema, &token.value, edition) {
-                return Some(navs);
-            }
 
             let parent = token.value.parent()?;
 
@@ -208,25 +204,6 @@ fn find_definition_for_known_blanket_dual_impls(
     Some(def_to_nav(sema.db, def))
 }
 
-// If the token is a builtin type search the definition from the rustdoc module shims.
-fn find_definition_for_builtin_types(
-    sema: &Semantics<'_, RootDatabase>,
-    original_token: &SyntaxToken,
-    edition: Edition,
-) -> Option<Vec<NavigationTarget>> {
-    let path = original_token.parent_ancestors().find_map(ast::Path::cast)?;
-    let res = sema.resolve_path(&path)?;
-    let PathResolution::Def(ModuleDef::BuiltinType(builtin)) = res else {
-        return None;
-    };
-
-    let fd = FamousDefs(sema, sema.scope(path.syntax())?.krate());
-    let primitive_mod = format!("prim_{}", builtin.name().display(fd.0.db, edition));
-    let doc_owner = find_std_module(&fd, &primitive_mod, edition)?;
-
-    Some(def_to_nav(sema.db, doc_owner.into()))
-}
-
 fn try_lookup_include_path(
     sema: &Semantics<'_, RootDatabase>,
     token: InFile<ast::String>,
diff --git a/src/tools/rust-analyzer/crates/ide/src/navigation_target.rs b/src/tools/rust-analyzer/crates/ide/src/navigation_target.rs
index 1b6a4b726e831..641bde5e2b82a 100644
--- a/src/tools/rust-analyzer/crates/ide/src/navigation_target.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/navigation_target.rs
@@ -5,14 +5,15 @@ use std::fmt;
 use arrayvec::ArrayVec;
 use either::Either;
 use hir::{
-    AssocItem, FieldSource, HasContainer, HasCrate, HasSource, HirDisplay, HirFileId, InFile,
-    LocalSource, ModuleSource, db::ExpandDatabase, symbols::FileSymbol,
+    AssocItem, Crate, FieldSource, HasContainer, HasCrate, HasSource, HirDisplay, HirFileId,
+    InFile, LocalSource, ModuleSource, Semantics, db::ExpandDatabase, symbols::FileSymbol,
 };
 use ide_db::{
     FileId, FileRange, RootDatabase, SymbolKind,
-    base_db::salsa,
-    defs::Definition,
+    base_db::{CrateOrigin, LangCrateOrigin, RootQueryDb, salsa},
+    defs::{Definition, find_std_module},
     documentation::{Documentation, HasDocs},
+    famous_defs::FamousDefs,
 };
 use span::Edition;
 use stdx::never;
@@ -262,8 +263,8 @@ impl TryToNav for Definition {
             Definition::TypeAlias(it) => it.try_to_nav(db),
             Definition::ExternCrateDecl(it) => it.try_to_nav(db),
             Definition::InlineAsmOperand(it) => it.try_to_nav(db),
+            Definition::BuiltinType(it) => it.try_to_nav(db),
             Definition::BuiltinLifetime(_)
-            | Definition::BuiltinType(_)
             | Definition::TupleField(_)
             | Definition::ToolModule(_)
             | Definition::InlineAsmRegOrRegClass(_)
@@ -746,6 +747,26 @@ impl TryToNav for hir::InlineAsmOperand {
     }
 }
 
+impl TryToNav for hir::BuiltinType {
+    fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
+        let sema = Semantics::new(db);
+
+        let krate = db
+            .all_crates()
+            .iter()
+            .copied()
+            .find(|&krate| matches!(krate.data(db).origin, CrateOrigin::Lang(LangCrateOrigin::Std)))
+            .map(Crate::from)?;
+        let edition = krate.edition(db);
+
+        let fd = FamousDefs(&sema, krate);
+        let primitive_mod = format!("prim_{}", self.name().display(fd.0.db, edition));
+        let doc_owner = find_std_module(&fd, &primitive_mod, edition)?;
+
+        Some(doc_owner.to_nav(db))
+    }
+}
+
 #[derive(Debug)]
 pub struct UpmappingResult<T> {
     /// The macro call site.

From d80db5b814f594f2e1ecea2e375990287ba4d4df Mon Sep 17 00:00:00 2001
From: Jens Reidel <adrian@travitia.xyz>
Date: Mon, 8 Sep 2025 20:20:03 +0200
Subject: [PATCH 0689/1889] tests/codegen-llvm: Make
 rust-abi-arch-specific-adjustment portable

This test currently only runs on RISC-V and loongarch hosts, but assumes
that the host target is the -gnu target. By using minicore, we can
run this test on all host targets, regardless of architecture, as long
as the LLVM components are built.
This also fixes this test on musl hosts of these architectures.

Signed-off-by: Jens Reidel <adrian@travitia.xyz>
---
 tests/codegen-llvm/rust-abi-arch-specific-adjustment.rs | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/tests/codegen-llvm/rust-abi-arch-specific-adjustment.rs b/tests/codegen-llvm/rust-abi-arch-specific-adjustment.rs
index 561f081c700ea..ffff4b359947d 100644
--- a/tests/codegen-llvm/rust-abi-arch-specific-adjustment.rs
+++ b/tests/codegen-llvm/rust-abi-arch-specific-adjustment.rs
@@ -1,15 +1,19 @@
+//@ add-core-stubs
 //@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
 //@ revisions: riscv64 loongarch64
 
-//@[riscv64] only-riscv64
 //@[riscv64] compile-flags: --target riscv64gc-unknown-linux-gnu
 //@[riscv64] needs-llvm-components: riscv
 
-//@[loongarch64] only-loongarch64
 //@[loongarch64] compile-flags: --target loongarch64-unknown-linux-gnu
 //@[loongarch64] needs-llvm-components: loongarch
 
 #![crate_type = "lib"]
+#![feature(no_core)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
 
 #[no_mangle]
 // riscv64:     define noundef i8 @arg_attr_u8(i8 noundef zeroext %x)

From fc4450b1f1dedd1328bc9dabad55afc3fda872b7 Mon Sep 17 00:00:00 2001
From: Ryan Mehri <rmehri01@pm.me>
Date: Mon, 8 Sep 2025 14:33:25 -0400
Subject: [PATCH 0690/1889] add test

---
 .../crates/ide/src/goto_definition.rs              | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/ide/src/goto_definition.rs b/src/tools/rust-analyzer/crates/ide/src/goto_definition.rs
index f768d4b68f469..d50d7f602fcb8 100644
--- a/src/tools/rust-analyzer/crates/ide/src/goto_definition.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/goto_definition.rs
@@ -3944,6 +3944,20 @@ fn main() {
         _ => {}
     }
 }
+"#,
+        );
+    }
+
+    #[test]
+    fn goto_builtin_type() {
+        check(
+            r#"
+//- /main.rs crate:main deps:std
+const _: &str$0 = ""; }
+
+//- /libstd.rs crate:std
+mod prim_str {}
+//  ^^^^^^^^
 "#,
         );
     }

From eba09340e043262e30c80f2de12d7038389262ad Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Mon, 8 Sep 2025 21:03:06 +0200
Subject: [PATCH 0691/1889] report duplicate symbol added by the driver

---
 compiler/rustc_span/src/symbol.rs | 21 +++++++++++++++------
 1 file changed, 15 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index e5108d8b7e921..e1768b5cde9d3 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -7,7 +7,7 @@ use std::ops::Deref;
 use std::{fmt, str};
 
 use rustc_arena::DroplessArena;
-use rustc_data_structures::fx::FxIndexSet;
+use rustc_data_structures::fx::{FxHashSet, FxIndexSet};
 use rustc_data_structures::stable_hasher::{
     HashStable, StableCompare, StableHasher, ToStableHashKey,
 };
@@ -2868,11 +2868,20 @@ impl Interner {
         let byte_strs = FxIndexSet::from_iter(
             init.iter().copied().chain(extra.iter().copied()).map(|str| str.as_bytes()),
         );
-        assert_eq!(
-            byte_strs.len(),
-            init.len() + extra.len(),
-            "duplicate symbols in the rustc symbol list and the extra symbols added by the driver",
-        );
+
+        // The order in which duplicates are reported is irrelevant.
+        #[expect(rustc::potential_query_instability)]
+        if byte_strs.len() != init.len() + extra.len() {
+            panic!(
+                "duplicate symbols in the rustc symbol list and the extra symbols added by the driver: {:?}",
+                FxHashSet::intersection(
+                    &init.iter().copied().collect(),
+                    &extra.iter().copied().collect(),
+                )
+                .collect::<Vec<_>>()
+            )
+        }
+
         Interner(Lock::new(InternerInner { arena: Default::default(), byte_strs }))
     }
 

From 36c2c0a8bab6fb5c588ee6980fd8c1be659567c2 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sat, 2 Aug 2025 10:50:04 +0200
Subject: [PATCH 0692/1889] fix(semicolon_inside_block): don't lint if block is
 in parens

---
 clippy_lints/src/semicolon_block.rs    | 14 ++++++++++++++
 tests/ui/semicolon_inside_block.fixed  | 17 ++++++++++++++++-
 tests/ui/semicolon_inside_block.rs     | 17 ++++++++++++++++-
 tests/ui/semicolon_inside_block.stderr |  8 ++++----
 4 files changed, 50 insertions(+), 6 deletions(-)

diff --git a/clippy_lints/src/semicolon_block.rs b/clippy_lints/src/semicolon_block.rs
index 1dea8f17c34be..371d62a068492 100644
--- a/clippy_lints/src/semicolon_block.rs
+++ b/clippy_lints/src/semicolon_block.rs
@@ -1,5 +1,6 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::SpanRangeExt;
 use rustc_errors::Applicability;
 use rustc_hir::{Block, Expr, ExprKind, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -82,6 +83,19 @@ impl SemicolonBlock {
         let insert_span = tail.span.source_callsite().shrink_to_hi();
         let remove_span = semi_span.with_lo(block.span.hi());
 
+        // If the block is surrounded by parens (`({ 0 });`), the author probably knows what
+        // they're doing and why, so don't get in their way.
+        //
+        // This has the additional benefit of stopping the block being parsed as a function call:
+        // ```
+        // fn foo() {
+        //     ({ 0 }); // if we remove this `;`, this will parse as a `({ 0 })(5);` function call
+        //     (5);
+        // }
+        if remove_span.check_source_text(cx, |src| src.contains(')')) {
+            return;
+        }
+
         if self.semicolon_inside_block_ignore_singleline && get_line(cx, remove_span) == get_line(cx, insert_span) {
             return;
         }
diff --git a/tests/ui/semicolon_inside_block.fixed b/tests/ui/semicolon_inside_block.fixed
index 7308e78aae263..468f0a5b1e472 100644
--- a/tests/ui/semicolon_inside_block.fixed
+++ b/tests/ui/semicolon_inside_block.fixed
@@ -3,7 +3,8 @@
     clippy::unused_unit,
     clippy::unnecessary_operation,
     clippy::no_effect,
-    clippy::single_element_loop
+    clippy::single_element_loop,
+    clippy::double_parens
 )]
 #![warn(clippy::semicolon_inside_block)]
 
@@ -87,6 +88,20 @@ fn main() {
     unit_fn_block()
 }
 
+#[rustfmt::skip]
+fn issue15380() {
+    ( {0;0});
+
+    ({
+        0;
+        0
+    });
+
+    (({ 0 }))      ;
+
+    ( ( { 0 } ) ) ;
+}
+
 pub fn issue15388() {
     #[rustfmt::skip]
     {0; 0};
diff --git a/tests/ui/semicolon_inside_block.rs b/tests/ui/semicolon_inside_block.rs
index 467bf4d779f2a..101374af26471 100644
--- a/tests/ui/semicolon_inside_block.rs
+++ b/tests/ui/semicolon_inside_block.rs
@@ -3,7 +3,8 @@
     clippy::unused_unit,
     clippy::unnecessary_operation,
     clippy::no_effect,
-    clippy::single_element_loop
+    clippy::single_element_loop,
+    clippy::double_parens
 )]
 #![warn(clippy::semicolon_inside_block)]
 
@@ -87,6 +88,20 @@ fn main() {
     unit_fn_block()
 }
 
+#[rustfmt::skip]
+fn issue15380() {
+    ( {0;0});
+
+    ({
+        0;
+        0
+    });
+
+    (({ 0 }))      ;
+
+    ( ( { 0 } ) ) ;
+}
+
 pub fn issue15388() {
     #[rustfmt::skip]
     {0; 0};
diff --git a/tests/ui/semicolon_inside_block.stderr b/tests/ui/semicolon_inside_block.stderr
index 23433f4e7ef90..2046dd1c36be7 100644
--- a/tests/ui/semicolon_inside_block.stderr
+++ b/tests/ui/semicolon_inside_block.stderr
@@ -1,5 +1,5 @@
 error: consider moving the `;` inside the block for consistent formatting
-  --> tests/ui/semicolon_inside_block.rs:38:5
+  --> tests/ui/semicolon_inside_block.rs:39:5
    |
 LL |     { unit_fn_block() };
    |     ^^^^^^^^^^^^^^^^^^^^
@@ -13,7 +13,7 @@ LL +     { unit_fn_block(); }
    |
 
 error: consider moving the `;` inside the block for consistent formatting
-  --> tests/ui/semicolon_inside_block.rs:40:5
+  --> tests/ui/semicolon_inside_block.rs:41:5
    |
 LL |     unsafe { unit_fn_block() };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     unsafe { unit_fn_block(); }
    |
 
 error: consider moving the `;` inside the block for consistent formatting
-  --> tests/ui/semicolon_inside_block.rs:49:5
+  --> tests/ui/semicolon_inside_block.rs:50:5
    |
 LL | /     {
 LL | |
@@ -41,7 +41,7 @@ LL ~     }
    |
 
 error: consider moving the `;` inside the block for consistent formatting
-  --> tests/ui/semicolon_inside_block.rs:63:5
+  --> tests/ui/semicolon_inside_block.rs:64:5
    |
 LL |     { m!(()) };
    |     ^^^^^^^^^^^

From 2ffa8510a7f29af51b976d98584d7330eadbeee7 Mon Sep 17 00:00:00 2001
From: Ryan Mehri <rmehri01@pm.me>
Date: Mon, 8 Sep 2025 15:59:46 -0400
Subject: [PATCH 0693/1889] make TryToNav take Semantics instead of
 RootDatabase

---
 .../crates/ide/src/call_hierarchy.rs          |  10 +-
 .../crates/ide/src/doc_links/tests.rs         |   2 +-
 .../crates/ide/src/goto_declaration.rs        |  10 +-
 .../crates/ide/src/goto_definition.rs         |  20 +-
 .../crates/ide/src/goto_implementation.rs     |   6 +-
 .../crates/ide/src/goto_type_definition.rs    |   2 +-
 .../crates/ide/src/highlight_related.rs       |   2 +-
 .../rust-analyzer/crates/ide/src/hover.rs     |  34 +--
 .../crates/ide/src/hover/render.rs            |  12 +-
 .../crates/ide/src/inlay_hints.rs             |   6 +-
 .../crates/ide/src/inlay_hints/bounds.rs      |   2 +-
 src/tools/rust-analyzer/crates/ide/src/lib.rs |   2 +-
 .../crates/ide/src/navigation_target.rs       | 196 ++++++++++++------
 .../crates/ide/src/references.rs              |   2 +-
 .../rust-analyzer/crates/ide/src/runnables.rs |  15 +-
 .../crates/ide/src/static_index.rs            |   4 +-
 .../crates/ide/src/test_explorer.rs           |   2 +-
 17 files changed, 203 insertions(+), 124 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide/src/call_hierarchy.rs b/src/tools/rust-analyzer/crates/ide/src/call_hierarchy.rs
index 7a0405939d10c..f42cead3501d1 100644
--- a/src/tools/rust-analyzer/crates/ide/src/call_hierarchy.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/call_hierarchy.rs
@@ -67,7 +67,7 @@ pub(crate) fn incoming_calls(
                 let def = ast::Fn::cast(node).and_then(|fn_| sema.to_def(&fn_))?;
                 // We should return def before check if it is a test, so that we
                 // will not continue to search for outer fn in nested fns
-                def.try_to_nav(sema.db).map(|nav| (def, nav))
+                def.try_to_nav(sema).map(|nav| (def, nav))
             });
 
             if let Some((def, nav)) = def_nav {
@@ -122,10 +122,10 @@ pub(crate) fn outgoing_calls(
                             if exclude_tests && it.is_test(db) {
                                 return None;
                             }
-                            it.try_to_nav(db)
+                            it.try_to_nav(&sema)
                         }
-                        hir::CallableKind::TupleEnumVariant(it) => it.try_to_nav(db),
-                        hir::CallableKind::TupleStruct(it) => it.try_to_nav(db),
+                        hir::CallableKind::TupleEnumVariant(it) => it.try_to_nav(&sema),
+                        hir::CallableKind::TupleStruct(it) => it.try_to_nav(&sema),
                         _ => None,
                     }
                     .zip(Some(sema.original_range(expr.syntax())))
@@ -136,7 +136,7 @@ pub(crate) fn outgoing_calls(
                         return None;
                     }
                     function
-                        .try_to_nav(db)
+                        .try_to_nav(&sema)
                         .zip(Some(sema.original_range(expr.name_ref()?.syntax())))
                 }
             }?;
diff --git a/src/tools/rust-analyzer/crates/ide/src/doc_links/tests.rs b/src/tools/rust-analyzer/crates/ide/src/doc_links/tests.rs
index b004c07576748..11518d1fbf306 100644
--- a/src/tools/rust-analyzer/crates/ide/src/doc_links/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/doc_links/tests.rs
@@ -68,7 +68,7 @@ fn check_doc_links(#[rust_analyzer::rust_fixture] ra_fixture: &str) {
                 resolve_doc_path_for_def(sema.db, cursor_def, &link, ns, is_inner_attr)
                     .unwrap_or_else(|| panic!("Failed to resolve {link}"))
             });
-            def.try_to_nav(sema.db).unwrap().into_iter().zip(iter::repeat(link))
+            def.try_to_nav(sema).unwrap().into_iter().zip(iter::repeat(link))
         })
         .map(|(nav_target, link)| {
             let range =
diff --git a/src/tools/rust-analyzer/crates/ide/src/goto_declaration.rs b/src/tools/rust-analyzer/crates/ide/src/goto_declaration.rs
index 267e8ff7128be..686dbe2412933 100644
--- a/src/tools/rust-analyzer/crates/ide/src/goto_declaration.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/goto_declaration.rs
@@ -38,14 +38,14 @@ pub(crate) fn goto_declaration(
                     ast::NameRef(name_ref) => match NameRefClass::classify(&sema, &name_ref)? {
                         NameRefClass::Definition(it, _) => Some(it),
                         NameRefClass::FieldShorthand { field_ref, .. } =>
-                            return field_ref.try_to_nav(db),
+                            return field_ref.try_to_nav(&sema),
                         NameRefClass::ExternCrateShorthand { decl, .. } =>
-                            return decl.try_to_nav(db),
+                            return decl.try_to_nav(&sema),
                     },
                     ast::Name(name) => match NameClass::classify(&sema, &name)? {
                         NameClass::Definition(it) | NameClass::ConstReference(it) => Some(it),
                         NameClass::PatFieldShorthand { field_ref, .. } =>
-                            return field_ref.try_to_nav(db),
+                            return field_ref.try_to_nav(&sema),
                     },
                     _ => None
                 }
@@ -57,14 +57,14 @@ pub(crate) fn goto_declaration(
                 Definition::Const(c) => c.as_assoc_item(db),
                 Definition::TypeAlias(ta) => ta.as_assoc_item(db),
                 Definition::Function(f) => f.as_assoc_item(db),
-                Definition::ExternCrateDecl(it) => return it.try_to_nav(db),
+                Definition::ExternCrateDecl(it) => return it.try_to_nav(&sema),
                 _ => None,
             }?;
 
             let trait_ = assoc.implemented_trait(db)?;
             let name = Some(assoc.name(db)?);
             let item = trait_.items(db).into_iter().find(|it| it.name(db) == name)?;
-            item.try_to_nav(db)
+            item.try_to_nav(&sema)
         })
         .flatten()
         .collect();
diff --git a/src/tools/rust-analyzer/crates/ide/src/goto_definition.rs b/src/tools/rust-analyzer/crates/ide/src/goto_definition.rs
index d50d7f602fcb8..2dcb13d9e7aa1 100644
--- a/src/tools/rust-analyzer/crates/ide/src/goto_definition.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/goto_definition.rs
@@ -62,7 +62,7 @@ pub(crate) fn goto_definition(
     })?;
     if let Some(doc_comment) = token_as_doc_comment(&original_token) {
         return doc_comment.get_definition_with_descend_at(sema, offset, |def, _, link_range| {
-            let nav = def.try_to_nav(db)?;
+            let nav = def.try_to_nav(sema)?;
             Some(RangeInfo::new(link_range, nav.collect()))
         });
     }
@@ -73,7 +73,7 @@ pub(crate) fn goto_definition(
         return Some(RangeInfo::new(
             range,
             match resolution {
-                Some(res) => def_to_nav(db, Definition::from(res)),
+                Some(res) => def_to_nav(sema, Definition::from(res)),
                 None => vec![],
             },
         ));
@@ -121,7 +121,7 @@ pub(crate) fn goto_definition(
                                 .collect();
                         }
                         try_filter_trait_item_definition(sema, &def)
-                            .unwrap_or_else(|| def_to_nav(sema.db, def))
+                            .unwrap_or_else(|| def_to_nav(sema, def))
                     })
                     .collect(),
             )
@@ -160,7 +160,7 @@ fn find_definition_for_known_blanket_dual_impls(
                     t_f,
                     [return_type.type_arguments().next()?],
                 )
-                .map(|f| def_to_nav(sema.db, f.into()));
+                .map(|f| def_to_nav(sema, f.into()));
         }
         hir::AssocItemContainer::Impl(_) => return None,
     };
@@ -201,7 +201,7 @@ fn find_definition_for_known_blanket_dual_impls(
     // succeed
     let _t = f.as_assoc_item(sema.db)?.implemented_trait(sema.db)?;
     let def = Definition::from(f);
-    Some(def_to_nav(sema.db, def))
+    Some(def_to_nav(sema, def))
 }
 
 fn try_lookup_include_path(
@@ -246,7 +246,7 @@ fn try_lookup_macro_def_in_macro_use(
     for mod_def in krate.root_module().declarations(sema.db) {
         if let ModuleDef::Macro(mac) = mod_def
             && mac.name(sema.db).as_str() == token.text()
-            && let Some(nav) = mac.try_to_nav(sema.db)
+            && let Some(nav) = mac.try_to_nav(sema)
         {
             return Some(nav.call_site);
         }
@@ -278,7 +278,7 @@ fn try_filter_trait_item_definition(
                 .items(db)
                 .iter()
                 .filter(|itm| discriminant(*itm) == discriminant_value)
-                .find_map(|itm| (itm.name(db)? == name).then(|| itm.try_to_nav(db)).flatten())
+                .find_map(|itm| (itm.name(db)? == name).then(|| itm.try_to_nav(sema)).flatten())
                 .map(|it| it.collect())
         }
     }
@@ -347,7 +347,7 @@ fn nav_for_exit_points(
             match_ast! {
                 match node {
                     ast::Fn(fn_) => {
-                        let mut nav = sema.to_def(&fn_)?.try_to_nav(db)?;
+                        let mut nav = sema.to_def(&fn_)?.try_to_nav(sema)?;
                         // For async token, we navigate to itself, which triggers
                         // VSCode to find the references
                         let focus_token = if matches!(token_kind, T![async]) {
@@ -564,8 +564,8 @@ fn nav_for_break_points(
     Some(navs)
 }
 
-fn def_to_nav(db: &RootDatabase, def: Definition) -> Vec<NavigationTarget> {
-    def.try_to_nav(db).map(|it| it.collect()).unwrap_or_default()
+fn def_to_nav(sema: &Semantics<'_, RootDatabase>, def: Definition) -> Vec<NavigationTarget> {
+    def.try_to_nav(sema).map(|it| it.collect()).unwrap_or_default()
 }
 
 fn expr_to_nav(
diff --git a/src/tools/rust-analyzer/crates/ide/src/goto_implementation.rs b/src/tools/rust-analyzer/crates/ide/src/goto_implementation.rs
index 4f172621908c5..875403c4e32a4 100644
--- a/src/tools/rust-analyzer/crates/ide/src/goto_implementation.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/goto_implementation.rs
@@ -86,7 +86,7 @@ pub(crate) fn goto_implementation(
 fn impls_for_ty(sema: &Semantics<'_, RootDatabase>, ty: hir::Type<'_>) -> Vec<NavigationTarget> {
     Impl::all_for_type(sema.db, ty)
         .into_iter()
-        .filter_map(|imp| imp.try_to_nav(sema.db))
+        .filter_map(|imp| imp.try_to_nav(sema))
         .flatten()
         .collect()
 }
@@ -97,7 +97,7 @@ fn impls_for_trait(
 ) -> Vec<NavigationTarget> {
     Impl::all_for_trait(sema.db, trait_)
         .into_iter()
-        .filter_map(|imp| imp.try_to_nav(sema.db))
+        .filter_map(|imp| imp.try_to_nav(sema))
         .flatten()
         .collect()
 }
@@ -114,7 +114,7 @@ fn impls_for_trait_item(
                 let itm_name = itm.name(sema.db)?;
                 (itm_name == fun_name).then_some(*itm)
             })?;
-            item.try_to_nav(sema.db)
+            item.try_to_nav(sema)
         })
         .flatten()
         .collect()
diff --git a/src/tools/rust-analyzer/crates/ide/src/goto_type_definition.rs b/src/tools/rust-analyzer/crates/ide/src/goto_type_definition.rs
index b80e81d39c6df..ffd144a827e34 100644
--- a/src/tools/rust-analyzer/crates/ide/src/goto_type_definition.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/goto_type_definition.rs
@@ -30,7 +30,7 @@ pub(crate) fn goto_type_definition(
 
     let mut res = Vec::new();
     let mut push = |def: Definition| {
-        if let Some(navs) = def.try_to_nav(db) {
+        if let Some(navs) = def.try_to_nav(&sema) {
             for nav in navs {
                 if !res.contains(&nav) {
                     res.push(nav);
diff --git a/src/tools/rust-analyzer/crates/ide/src/highlight_related.rs b/src/tools/rust-analyzer/crates/ide/src/highlight_related.rs
index af1557f5a9a16..04ce5a7567f3c 100644
--- a/src/tools/rust-analyzer/crates/ide/src/highlight_related.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/highlight_related.rs
@@ -277,7 +277,7 @@ fn highlight_references(
                     Definition::Module(module) => {
                         NavigationTarget::from_module_to_decl(sema.db, module)
                     }
-                    def => match def.try_to_nav(sema.db) {
+                    def => match def.try_to_nav(sema) {
                         Some(it) => it,
                         None => continue,
                     },
diff --git a/src/tools/rust-analyzer/crates/ide/src/hover.rs b/src/tools/rust-analyzer/crates/ide/src/hover.rs
index 44c98a43f6944..3f52303d74e48 100644
--- a/src/tools/rust-analyzer/crates/ide/src/hover.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/hover.rs
@@ -85,10 +85,11 @@ pub enum HoverAction {
 
 impl HoverAction {
     fn goto_type_from_targets(
-        db: &RootDatabase,
+        sema: &Semantics<'_, RootDatabase>,
         targets: Vec<hir::ModuleDef>,
         edition: Edition,
     ) -> Option<Self> {
+        let db = sema.db;
         let targets = targets
             .into_iter()
             .filter_map(|it| {
@@ -99,7 +100,7 @@ impl HoverAction {
                         it.name(db).map(|name| name.display(db, edition).to_string()),
                         edition,
                     ),
-                    nav: it.try_to_nav(db)?.call_site(),
+                    nav: it.try_to_nav(sema)?.call_site(),
                 })
             })
             .collect::<Vec<_>>();
@@ -467,10 +468,10 @@ pub(crate) fn hover_for_definition(
     HoverResult {
         markup: render::process_markup(sema.db, def, &markup, range_map, config),
         actions: [
-            show_fn_references_action(sema.db, def),
-            show_implementations_action(sema.db, def),
+            show_fn_references_action(sema, def),
+            show_implementations_action(sema, def),
             runnable_action(sema, def, file_id),
-            goto_type_action_for_def(sema.db, def, &notable_traits, subst_types, edition),
+            goto_type_action_for_def(sema, def, &notable_traits, subst_types, edition),
         ]
         .into_iter()
         .flatten()
@@ -505,7 +506,10 @@ fn notable_traits<'db>(
         .collect::<Vec<_>>()
 }
 
-fn show_implementations_action(db: &RootDatabase, def: Definition) -> Option<HoverAction> {
+fn show_implementations_action(
+    sema: &Semantics<'_, RootDatabase>,
+    def: Definition,
+) -> Option<HoverAction> {
     fn to_action(nav_target: NavigationTarget) -> HoverAction {
         HoverAction::Implementation(FilePosition {
             file_id: nav_target.file_id,
@@ -515,19 +519,22 @@ fn show_implementations_action(db: &RootDatabase, def: Definition) -> Option<Hov
 
     let adt = match def {
         Definition::Trait(it) => {
-            return it.try_to_nav(db).map(UpmappingResult::call_site).map(to_action);
+            return it.try_to_nav(sema).map(UpmappingResult::call_site).map(to_action);
         }
         Definition::Adt(it) => Some(it),
-        Definition::SelfType(it) => it.self_ty(db).as_adt(),
+        Definition::SelfType(it) => it.self_ty(sema.db).as_adt(),
         _ => None,
     }?;
-    adt.try_to_nav(db).map(UpmappingResult::call_site).map(to_action)
+    adt.try_to_nav(sema).map(UpmappingResult::call_site).map(to_action)
 }
 
-fn show_fn_references_action(db: &RootDatabase, def: Definition) -> Option<HoverAction> {
+fn show_fn_references_action(
+    sema: &Semantics<'_, RootDatabase>,
+    def: Definition,
+) -> Option<HoverAction> {
     match def {
         Definition::Function(it) => {
-            it.try_to_nav(db).map(UpmappingResult::call_site).map(|nav_target| {
+            it.try_to_nav(sema).map(UpmappingResult::call_site).map(|nav_target| {
                 HoverAction::Reference(FilePosition {
                     file_id: nav_target.file_id,
                     offset: nav_target.focus_or_full_range().start(),
@@ -560,12 +567,13 @@ fn runnable_action(
 }
 
 fn goto_type_action_for_def(
-    db: &RootDatabase,
+    sema: &Semantics<'_, RootDatabase>,
     def: Definition,
     notable_traits: &[(hir::Trait, Vec<(Option<hir::Type<'_>>, hir::Name)>)],
     subst_types: Option<Vec<(hir::Symbol, hir::Type<'_>)>>,
     edition: Edition,
 ) -> Option<HoverAction> {
+    let db = sema.db;
     let mut targets: Vec<hir::ModuleDef> = Vec::new();
     let mut push_new_def = |item: hir::ModuleDef| {
         if !targets.contains(&item) {
@@ -612,7 +620,7 @@ fn goto_type_action_for_def(
         }
     }
 
-    HoverAction::goto_type_from_targets(db, targets, edition)
+    HoverAction::goto_type_from_targets(sema, targets, edition)
 }
 
 fn walk_and_push_ty(
diff --git a/src/tools/rust-analyzer/crates/ide/src/hover/render.rs b/src/tools/rust-analyzer/crates/ide/src/hover/render.rs
index 2adafbb7af6f7..451260640f844 100644
--- a/src/tools/rust-analyzer/crates/ide/src/hover/render.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/hover/render.rs
@@ -128,7 +128,7 @@ pub(super) fn try_expr(
     };
     walk_and_push_ty(sema.db, &inner_ty, &mut push_new_def);
     walk_and_push_ty(sema.db, &body_ty, &mut push_new_def);
-    if let Some(actions) = HoverAction::goto_type_from_targets(sema.db, targets, edition) {
+    if let Some(actions) = HoverAction::goto_type_from_targets(sema, targets, edition) {
         res.actions.push(actions);
     }
 
@@ -210,7 +210,7 @@ pub(super) fn deref_expr(
         )
         .into()
     };
-    if let Some(actions) = HoverAction::goto_type_from_targets(sema.db, targets, edition) {
+    if let Some(actions) = HoverAction::goto_type_from_targets(sema, targets, edition) {
         res.actions.push(actions);
     }
 
@@ -323,7 +323,7 @@ pub(super) fn struct_rest_pat(
 
         Markup::fenced_block(&s)
     };
-    if let Some(actions) = HoverAction::goto_type_from_targets(sema.db, targets, edition) {
+    if let Some(actions) = HoverAction::goto_type_from_targets(sema, targets, edition) {
         res.actions.push(actions);
     }
     res
@@ -1030,7 +1030,7 @@ fn type_info(
         };
         desc.into()
     };
-    if let Some(actions) = HoverAction::goto_type_from_targets(db, targets, edition) {
+    if let Some(actions) = HoverAction::goto_type_from_targets(sema, targets, edition) {
         res.actions.push(actions);
     }
     Some(res)
@@ -1098,7 +1098,7 @@ fn closure_ty(
     format_to!(markup, "{adjusted}\n\n## Captures\n{}", captures_rendered,);
 
     let mut res = HoverResult::default();
-    if let Some(actions) = HoverAction::goto_type_from_targets(sema.db, targets, edition) {
+    if let Some(actions) = HoverAction::goto_type_from_targets(sema, targets, edition) {
         res.actions.push(actions);
     }
     res.markup = markup.into();
@@ -1302,7 +1302,7 @@ fn keyword_hints(
                     KeywordHint {
                         description,
                         keyword_mod,
-                        actions: HoverAction::goto_type_from_targets(sema.db, targets, edition)
+                        actions: HoverAction::goto_type_from_targets(sema, targets, edition)
                             .into_iter()
                             .collect(),
                     }
diff --git a/src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs b/src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs
index cc44ae8fc8b9e..507af41d84461 100644
--- a/src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/inlay_hints.rs
@@ -672,7 +672,7 @@ impl fmt::Debug for InlayHintLabelPart {
 
 #[derive(Debug)]
 struct InlayHintLabelBuilder<'a> {
-    db: &'a RootDatabase,
+    sema: &'a Semantics<'a, RootDatabase>,
     result: InlayHintLabel,
     last_part: String,
     resolve: bool,
@@ -694,7 +694,7 @@ impl HirWrite for InlayHintLabelBuilder<'_> {
             LazyProperty::Lazy
         } else {
             LazyProperty::Computed({
-                let Some(location) = ModuleDef::from(def).try_to_nav(self.db) else { return };
+                let Some(location) = ModuleDef::from(def).try_to_nav(self.sema) else { return };
                 let location = location.call_site();
                 FileRange { file_id: location.file_id, range: location.focus_or_full_range() }
             })
@@ -782,7 +782,7 @@ fn label_of_ty(
     }
 
     let mut label_builder = InlayHintLabelBuilder {
-        db: sema.db,
+        sema,
         last_part: String::new(),
         location: None,
         result: InlayHintLabel::default(),
diff --git a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/bounds.rs b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/bounds.rs
index f0003dae3f36f..4abd67b91f5ec 100644
--- a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/bounds.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/bounds.rs
@@ -44,7 +44,7 @@ pub(super) fn hints(
                             text: "Sized".to_owned(),
                             linked_location: sized_trait.and_then(|it| {
                                 config.lazy_location_opt(|| {
-                                    it.try_to_nav(sema.db).map(|it| {
+                                    it.try_to_nav(sema).map(|it| {
                                         let n = it.call_site();
                                         FileRange {
                                             file_id: n.file_id,
diff --git a/src/tools/rust-analyzer/crates/ide/src/lib.rs b/src/tools/rust-analyzer/crates/ide/src/lib.rs
index cddf5f04f2442..3a6b3247d65c6 100644
--- a/src/tools/rust-analyzer/crates/ide/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/lib.rs
@@ -483,7 +483,7 @@ impl Analysis {
             salsa::attach(&self.db, || {
                 symbols
                     .into_iter()
-                    .filter_map(|s| s.try_to_nav(&self.db))
+                    .filter_map(|s| s.try_to_nav(&Semantics::new(&self.db)))
                     .take(limit)
                     .map(UpmappingResult::call_site)
                     .collect::<Vec<_>>()
diff --git a/src/tools/rust-analyzer/crates/ide/src/navigation_target.rs b/src/tools/rust-analyzer/crates/ide/src/navigation_target.rs
index 641bde5e2b82a..46ff16f972625 100644
--- a/src/tools/rust-analyzer/crates/ide/src/navigation_target.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/navigation_target.rs
@@ -83,14 +83,20 @@ pub(crate) trait ToNav {
 }
 
 pub trait TryToNav {
-    fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>>;
+    fn try_to_nav(
+        &self,
+        sema: &Semantics<'_, RootDatabase>,
+    ) -> Option<UpmappingResult<NavigationTarget>>;
 }
 
 impl<T: TryToNav, U: TryToNav> TryToNav for Either<T, U> {
-    fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
+    fn try_to_nav(
+        &self,
+        sema: &Semantics<'_, RootDatabase>,
+    ) -> Option<UpmappingResult<NavigationTarget>> {
         match self {
-            Either::Left(it) => it.try_to_nav(db),
-            Either::Right(it) => it.try_to_nav(db),
+            Either::Left(it) => it.try_to_nav(sema),
+            Either::Right(it) => it.try_to_nav(sema),
         }
     }
 }
@@ -185,7 +191,11 @@ impl NavigationTarget {
 }
 
 impl TryToNav for FileSymbol {
-    fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
+    fn try_to_nav(
+        &self,
+        sema: &Semantics<'_, RootDatabase>,
+    ) -> Option<UpmappingResult<NavigationTarget>> {
+        let db = sema.db;
         let edition =
             self.def.module(db).map(|it| it.krate().edition(db)).unwrap_or(Edition::CURRENT);
         let display_target = self.def.krate(db).to_display_target(db);
@@ -244,49 +254,55 @@ impl TryToNav for FileSymbol {
 }
 
 impl TryToNav for Definition {
-    fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
+    fn try_to_nav(
+        &self,
+        sema: &Semantics<'_, RootDatabase>,
+    ) -> Option<UpmappingResult<NavigationTarget>> {
         match self {
-            Definition::Local(it) => Some(it.to_nav(db)),
-            Definition::Label(it) => it.try_to_nav(db),
-            Definition::Module(it) => Some(it.to_nav(db)),
-            Definition::Crate(it) => Some(it.to_nav(db)),
-            Definition::Macro(it) => it.try_to_nav(db),
-            Definition::Field(it) => it.try_to_nav(db),
-            Definition::SelfType(it) => it.try_to_nav(db),
-            Definition::GenericParam(it) => it.try_to_nav(db),
-            Definition::Function(it) => it.try_to_nav(db),
-            Definition::Adt(it) => it.try_to_nav(db),
-            Definition::Variant(it) => it.try_to_nav(db),
-            Definition::Const(it) => it.try_to_nav(db),
-            Definition::Static(it) => it.try_to_nav(db),
-            Definition::Trait(it) => it.try_to_nav(db),
-            Definition::TypeAlias(it) => it.try_to_nav(db),
-            Definition::ExternCrateDecl(it) => it.try_to_nav(db),
-            Definition::InlineAsmOperand(it) => it.try_to_nav(db),
-            Definition::BuiltinType(it) => it.try_to_nav(db),
+            Definition::Local(it) => Some(it.to_nav(sema.db)),
+            Definition::Label(it) => it.try_to_nav(sema),
+            Definition::Module(it) => Some(it.to_nav(sema.db)),
+            Definition::Crate(it) => Some(it.to_nav(sema.db)),
+            Definition::Macro(it) => it.try_to_nav(sema),
+            Definition::Field(it) => it.try_to_nav(sema),
+            Definition::SelfType(it) => it.try_to_nav(sema),
+            Definition::GenericParam(it) => it.try_to_nav(sema),
+            Definition::Function(it) => it.try_to_nav(sema),
+            Definition::Adt(it) => it.try_to_nav(sema),
+            Definition::Variant(it) => it.try_to_nav(sema),
+            Definition::Const(it) => it.try_to_nav(sema),
+            Definition::Static(it) => it.try_to_nav(sema),
+            Definition::Trait(it) => it.try_to_nav(sema),
+            Definition::TypeAlias(it) => it.try_to_nav(sema),
+            Definition::ExternCrateDecl(it) => it.try_to_nav(sema),
+            Definition::InlineAsmOperand(it) => it.try_to_nav(sema),
+            Definition::BuiltinType(it) => it.try_to_nav(sema),
             Definition::BuiltinLifetime(_)
             | Definition::TupleField(_)
             | Definition::ToolModule(_)
             | Definition::InlineAsmRegOrRegClass(_)
             | Definition::BuiltinAttr(_) => None,
             // FIXME: The focus range should be set to the helper declaration
-            Definition::DeriveHelper(it) => it.derive().try_to_nav(db),
+            Definition::DeriveHelper(it) => it.derive().try_to_nav(sema),
         }
     }
 }
 
 impl TryToNav for hir::ModuleDef {
-    fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
+    fn try_to_nav(
+        &self,
+        sema: &Semantics<'_, RootDatabase>,
+    ) -> Option<UpmappingResult<NavigationTarget>> {
         match self {
-            hir::ModuleDef::Module(it) => Some(it.to_nav(db)),
-            hir::ModuleDef::Function(it) => it.try_to_nav(db),
-            hir::ModuleDef::Adt(it) => it.try_to_nav(db),
-            hir::ModuleDef::Variant(it) => it.try_to_nav(db),
-            hir::ModuleDef::Const(it) => it.try_to_nav(db),
-            hir::ModuleDef::Static(it) => it.try_to_nav(db),
-            hir::ModuleDef::Trait(it) => it.try_to_nav(db),
-            hir::ModuleDef::TypeAlias(it) => it.try_to_nav(db),
-            hir::ModuleDef::Macro(it) => it.try_to_nav(db),
+            hir::ModuleDef::Module(it) => Some(it.to_nav(sema.db)),
+            hir::ModuleDef::Function(it) => it.try_to_nav(sema),
+            hir::ModuleDef::Adt(it) => it.try_to_nav(sema),
+            hir::ModuleDef::Variant(it) => it.try_to_nav(sema),
+            hir::ModuleDef::Const(it) => it.try_to_nav(sema),
+            hir::ModuleDef::Static(it) => it.try_to_nav(sema),
+            hir::ModuleDef::Trait(it) => it.try_to_nav(sema),
+            hir::ModuleDef::TypeAlias(it) => it.try_to_nav(sema),
+            hir::ModuleDef::Macro(it) => it.try_to_nav(sema),
             hir::ModuleDef::BuiltinType(_) => None,
         }
     }
@@ -369,7 +385,11 @@ where
     D: HasSource + ToNavFromAst + Copy + HasDocs + HirDisplay + HasCrate,
     D::Ast: ast::HasName,
 {
-    fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
+    fn try_to_nav(
+        &self,
+        sema: &Semantics<'_, RootDatabase>,
+    ) -> Option<UpmappingResult<NavigationTarget>> {
+        let db = sema.db;
         let src = self.source(db)?;
         Some(
             NavigationTarget::from_named(
@@ -423,7 +443,11 @@ impl ToNav for hir::Crate {
 }
 
 impl TryToNav for hir::Impl {
-    fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
+    fn try_to_nav(
+        &self,
+        sema: &Semantics<'_, RootDatabase>,
+    ) -> Option<UpmappingResult<NavigationTarget>> {
+        let db = sema.db;
         let InFile { file_id, value } = self.source(db)?;
         let derive_path = self.as_builtin_derive_path(db);
 
@@ -447,7 +471,11 @@ impl TryToNav for hir::Impl {
 }
 
 impl TryToNav for hir::ExternCrateDecl {
-    fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
+    fn try_to_nav(
+        &self,
+        sema: &Semantics<'_, RootDatabase>,
+    ) -> Option<UpmappingResult<NavigationTarget>> {
+        let db = sema.db;
         let src = self.source(db)?;
         let InFile { file_id, value } = src;
         let focus = value
@@ -479,7 +507,11 @@ impl TryToNav for hir::ExternCrateDecl {
 }
 
 impl TryToNav for hir::Field {
-    fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
+    fn try_to_nav(
+        &self,
+        sema: &Semantics<'_, RootDatabase>,
+    ) -> Option<UpmappingResult<NavigationTarget>> {
+        let db = sema.db;
         let src = self.source(db)?;
         let krate = self.parent_def(db).module(db).krate();
 
@@ -512,7 +544,11 @@ impl TryToNav for hir::Field {
 }
 
 impl TryToNav for hir::Macro {
-    fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
+    fn try_to_nav(
+        &self,
+        sema: &Semantics<'_, RootDatabase>,
+    ) -> Option<UpmappingResult<NavigationTarget>> {
+        let db = sema.db;
         let src = self.source(db)?;
         let name_owner: &dyn ast::HasName = match &src.value {
             Either::Left(it) => it,
@@ -533,31 +569,40 @@ impl TryToNav for hir::Macro {
 }
 
 impl TryToNav for hir::Adt {
-    fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
+    fn try_to_nav(
+        &self,
+        sema: &Semantics<'_, RootDatabase>,
+    ) -> Option<UpmappingResult<NavigationTarget>> {
         match self {
-            hir::Adt::Struct(it) => it.try_to_nav(db),
-            hir::Adt::Union(it) => it.try_to_nav(db),
-            hir::Adt::Enum(it) => it.try_to_nav(db),
+            hir::Adt::Struct(it) => it.try_to_nav(sema),
+            hir::Adt::Union(it) => it.try_to_nav(sema),
+            hir::Adt::Enum(it) => it.try_to_nav(sema),
         }
     }
 }
 
 impl TryToNav for hir::AssocItem {
-    fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
+    fn try_to_nav(
+        &self,
+        sema: &Semantics<'_, RootDatabase>,
+    ) -> Option<UpmappingResult<NavigationTarget>> {
         match self {
-            AssocItem::Function(it) => it.try_to_nav(db),
-            AssocItem::Const(it) => it.try_to_nav(db),
-            AssocItem::TypeAlias(it) => it.try_to_nav(db),
+            AssocItem::Function(it) => it.try_to_nav(sema),
+            AssocItem::Const(it) => it.try_to_nav(sema),
+            AssocItem::TypeAlias(it) => it.try_to_nav(sema),
         }
     }
 }
 
 impl TryToNav for hir::GenericParam {
-    fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
+    fn try_to_nav(
+        &self,
+        sema: &Semantics<'_, RootDatabase>,
+    ) -> Option<UpmappingResult<NavigationTarget>> {
         match self {
-            hir::GenericParam::TypeParam(it) => it.try_to_nav(db),
-            hir::GenericParam::ConstParam(it) => it.try_to_nav(db),
-            hir::GenericParam::LifetimeParam(it) => it.try_to_nav(db),
+            hir::GenericParam::TypeParam(it) => it.try_to_nav(sema),
+            hir::GenericParam::ConstParam(it) => it.try_to_nav(sema),
+            hir::GenericParam::LifetimeParam(it) => it.try_to_nav(sema),
         }
     }
 }
@@ -606,7 +651,11 @@ impl ToNav for hir::Local {
 }
 
 impl TryToNav for hir::Label {
-    fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
+    fn try_to_nav(
+        &self,
+        sema: &Semantics<'_, RootDatabase>,
+    ) -> Option<UpmappingResult<NavigationTarget>> {
+        let db = sema.db;
         let InFile { file_id, value } = self.source(db)?;
         // Labels can't be keywords, so no escaping needed.
         let name = self.name(db).display_no_db(Edition::Edition2015).to_smolstr();
@@ -628,7 +677,11 @@ impl TryToNav for hir::Label {
 }
 
 impl TryToNav for hir::TypeParam {
-    fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
+    fn try_to_nav(
+        &self,
+        sema: &Semantics<'_, RootDatabase>,
+    ) -> Option<UpmappingResult<NavigationTarget>> {
+        let db = sema.db;
         let InFile { file_id, value } = self.merge().source(db)?;
         let edition = self.module(db).krate().edition(db);
         let name = self.name(db).display_no_db(edition).to_smolstr();
@@ -665,13 +718,20 @@ impl TryToNav for hir::TypeParam {
 }
 
 impl TryToNav for hir::TypeOrConstParam {
-    fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
-        self.split(db).try_to_nav(db)
+    fn try_to_nav(
+        &self,
+        sema: &Semantics<'_, RootDatabase>,
+    ) -> Option<UpmappingResult<NavigationTarget>> {
+        self.split(sema.db).try_to_nav(sema)
     }
 }
 
 impl TryToNav for hir::LifetimeParam {
-    fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
+    fn try_to_nav(
+        &self,
+        sema: &Semantics<'_, RootDatabase>,
+    ) -> Option<UpmappingResult<NavigationTarget>> {
+        let db = sema.db;
         let InFile { file_id, value } = self.source(db)?;
         // Lifetimes cannot be keywords, so not escaping needed.
         let name = self.name(db).display_no_db(Edition::Edition2015).to_smolstr();
@@ -693,7 +753,11 @@ impl TryToNav for hir::LifetimeParam {
 }
 
 impl TryToNav for hir::ConstParam {
-    fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
+    fn try_to_nav(
+        &self,
+        sema: &Semantics<'_, RootDatabase>,
+    ) -> Option<UpmappingResult<NavigationTarget>> {
+        let db = sema.db;
         let InFile { file_id, value } = self.merge().source(db)?;
         let edition = self.module(db).krate().edition(db);
         let name = self.name(db).display_no_db(edition).to_smolstr();
@@ -723,7 +787,11 @@ impl TryToNav for hir::ConstParam {
 }
 
 impl TryToNav for hir::InlineAsmOperand {
-    fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
+    fn try_to_nav(
+        &self,
+        sema: &Semantics<'_, RootDatabase>,
+    ) -> Option<UpmappingResult<NavigationTarget>> {
+        let db = sema.db;
         let InFile { file_id, value } = &self.source(db)?;
         let file_id = *file_id;
         Some(orig_range_with_focus(db, file_id, value.syntax(), value.name()).map(
@@ -748,9 +816,11 @@ impl TryToNav for hir::InlineAsmOperand {
 }
 
 impl TryToNav for hir::BuiltinType {
-    fn try_to_nav(&self, db: &RootDatabase) -> Option<UpmappingResult<NavigationTarget>> {
-        let sema = Semantics::new(db);
-
+    fn try_to_nav(
+        &self,
+        sema: &Semantics<'_, RootDatabase>,
+    ) -> Option<UpmappingResult<NavigationTarget>> {
+        let db = sema.db;
         let krate = db
             .all_crates()
             .iter()
@@ -759,7 +829,7 @@ impl TryToNav for hir::BuiltinType {
             .map(Crate::from)?;
         let edition = krate.edition(db);
 
-        let fd = FamousDefs(&sema, krate);
+        let fd = FamousDefs(sema, krate);
         let primitive_mod = format!("prim_{}", self.name().display(fd.0.db, edition));
         let doc_owner = find_std_module(&fd, &primitive_mod, edition)?;
 
diff --git a/src/tools/rust-analyzer/crates/ide/src/references.rs b/src/tools/rust-analyzer/crates/ide/src/references.rs
index dc509b3858389..0189939eac310 100644
--- a/src/tools/rust-analyzer/crates/ide/src/references.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/references.rs
@@ -138,7 +138,7 @@ pub(crate) fn find_all_refs(
                 Definition::Module(module) => {
                     Some(NavigationTarget::from_module_to_decl(sema.db, module))
                 }
-                def => def.try_to_nav(sema.db),
+                def => def.try_to_nav(sema),
             }
             .map(|nav| {
                 let (nav, extra_ref) = match nav.def_site {
diff --git a/src/tools/rust-analyzer/crates/ide/src/runnables.rs b/src/tools/rust-analyzer/crates/ide/src/runnables.rs
index 6d33ddcde0479..6ad9c7884db93 100644
--- a/src/tools/rust-analyzer/crates/ide/src/runnables.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/runnables.rs
@@ -158,15 +158,15 @@ pub(crate) fn runnables(db: &RootDatabase, file_id: FileId) -> Vec<Runnable> {
             Definition::SelfType(impl_) => runnable_impl(&sema, &impl_),
             _ => None,
         };
-        add_opt(runnable.or_else(|| module_def_doctest(sema.db, def)), Some(def));
+        add_opt(runnable.or_else(|| module_def_doctest(&sema, def)), Some(def));
         if let Definition::SelfType(impl_) = def {
             impl_.items(db).into_iter().for_each(|assoc| {
                 let runnable = match assoc {
                     hir::AssocItem::Function(it) => {
-                        runnable_fn(&sema, it).or_else(|| module_def_doctest(sema.db, it.into()))
+                        runnable_fn(&sema, it).or_else(|| module_def_doctest(&sema, it.into()))
                     }
-                    hir::AssocItem::Const(it) => module_def_doctest(sema.db, it.into()),
-                    hir::AssocItem::TypeAlias(it) => module_def_doctest(sema.db, it.into()),
+                    hir::AssocItem::Const(it) => module_def_doctest(&sema, it.into()),
+                    hir::AssocItem::TypeAlias(it) => module_def_doctest(&sema, it.into()),
                 };
                 add_opt(runnable, Some(assoc.into()))
             });
@@ -410,7 +410,7 @@ pub(crate) fn runnable_impl(
         return None;
     }
     let cfg = attrs.cfg();
-    let nav = def.try_to_nav(sema.db)?.call_site();
+    let nav = def.try_to_nav(sema)?.call_site();
     let ty = def.self_ty(sema.db);
     let adt_name = ty.as_adt()?.name(sema.db);
     let mut ty_args = ty.generic_parameters(sema.db, display_target).peekable();
@@ -486,7 +486,8 @@ fn runnable_mod_outline_definition(
     })
 }
 
-fn module_def_doctest(db: &RootDatabase, def: Definition) -> Option<Runnable> {
+fn module_def_doctest(sema: &Semantics<'_, RootDatabase>, def: Definition) -> Option<Runnable> {
+    let db = sema.db;
     let attrs = match def {
         Definition::Module(it) => it.attrs(db),
         Definition::Function(it) => it.attrs(db),
@@ -540,7 +541,7 @@ fn module_def_doctest(db: &RootDatabase, def: Definition) -> Option<Runnable> {
 
     let mut nav = match def {
         Definition::Module(def) => NavigationTarget::from_module_to_decl(db, def),
-        def => def.try_to_nav(db)?,
+        def => def.try_to_nav(sema)?,
     }
     .call_site();
     nav.focus_range = None;
diff --git a/src/tools/rust-analyzer/crates/ide/src/static_index.rs b/src/tools/rust-analyzer/crates/ide/src/static_index.rs
index 8c3275df1baab..8214b4d1de22f 100644
--- a/src/tools/rust-analyzer/crates/ide/src/static_index.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/static_index.rs
@@ -243,7 +243,7 @@ impl StaticIndex<'_> {
                             edition,
                             display_target,
                         )),
-                        definition: def.try_to_nav(self.db).map(UpmappingResult::call_site).map(
+                        definition: def.try_to_nav(&sema).map(UpmappingResult::call_site).map(
                             |it| FileRange { file_id: it.file_id, range: it.focus_or_full_range() },
                         ),
                         references: vec![],
@@ -261,7 +261,7 @@ impl StaticIndex<'_> {
             let token = self.tokens.get_mut(id).unwrap();
             token.references.push(ReferenceData {
                 range: FileRange { range, file_id },
-                is_definition: match def.try_to_nav(self.db).map(UpmappingResult::call_site) {
+                is_definition: match def.try_to_nav(&sema).map(UpmappingResult::call_site) {
                     Some(it) => it.file_id == file_id && it.focus_or_full_range() == range,
                     None => false,
                 },
diff --git a/src/tools/rust-analyzer/crates/ide/src/test_explorer.rs b/src/tools/rust-analyzer/crates/ide/src/test_explorer.rs
index 06cbd50e946ac..bd60ffe559120 100644
--- a/src/tools/rust-analyzer/crates/ide/src/test_explorer.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/test_explorer.rs
@@ -94,7 +94,7 @@ fn discover_tests_in_module(
         if !f.is_test(db) {
             continue;
         }
-        let nav = f.try_to_nav(db).map(|r| r.call_site);
+        let nav = f.try_to_nav(&sema).map(|r| r.call_site);
         let fn_name = f.name(db).as_str().to_owned();
         r.push(TestItem {
             id: format!("{prefix_id}::{fn_name}"),

From 9899ab3fa4559461c1ddae641565995acf9c2223 Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Mon, 8 Sep 2025 21:21:55 +0200
Subject: [PATCH 0694/1889] simplify the declaration of the legacy integer
 modules (`std::u32` etc.)

---
 library/core/src/lib.rs                       | 51 +++----------
 library/core/src/num/shells/i128.rs           | 11 ---
 library/core/src/num/shells/i16.rs            | 11 ---
 library/core/src/num/shells/i32.rs            | 11 ---
 library/core/src/num/shells/i64.rs            | 11 ---
 library/core/src/num/shells/i8.rs             | 11 ---
 library/core/src/num/shells/int_macros.rs     | 46 ------------
 library/core/src/num/shells/isize.rs          | 11 ---
 .../core/src/num/shells/legacy_int_modules.rs | 71 +++++++++++++++++++
 library/core/src/num/shells/u128.rs           | 11 ---
 library/core/src/num/shells/u16.rs            | 11 ---
 library/core/src/num/shells/u32.rs            | 11 ---
 library/core/src/num/shells/u64.rs            | 11 ---
 library/core/src/num/shells/u8.rs             | 11 ---
 library/core/src/num/shells/usize.rs          | 11 ---
 15 files changed, 81 insertions(+), 219 deletions(-)
 delete mode 100644 library/core/src/num/shells/i128.rs
 delete mode 100644 library/core/src/num/shells/i16.rs
 delete mode 100644 library/core/src/num/shells/i32.rs
 delete mode 100644 library/core/src/num/shells/i64.rs
 delete mode 100644 library/core/src/num/shells/i8.rs
 delete mode 100644 library/core/src/num/shells/int_macros.rs
 delete mode 100644 library/core/src/num/shells/isize.rs
 create mode 100644 library/core/src/num/shells/legacy_int_modules.rs
 delete mode 100644 library/core/src/num/shells/u128.rs
 delete mode 100644 library/core/src/num/shells/u16.rs
 delete mode 100644 library/core/src/num/shells/u32.rs
 delete mode 100644 library/core/src/num/shells/u64.rs
 delete mode 100644 library/core/src/num/shells/u8.rs
 delete mode 100644 library/core/src/num/shells/usize.rs

diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index c306011bdda39..86a68e18b0af4 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -252,47 +252,16 @@ pub use crate::macros::cfg_select;
 #[macro_use]
 mod internal_macros;
 
-#[path = "num/shells/int_macros.rs"]
-#[macro_use]
-mod int_macros;
-
-#[rustc_diagnostic_item = "i128_legacy_mod"]
-#[path = "num/shells/i128.rs"]
-pub mod i128;
-#[rustc_diagnostic_item = "i16_legacy_mod"]
-#[path = "num/shells/i16.rs"]
-pub mod i16;
-#[rustc_diagnostic_item = "i32_legacy_mod"]
-#[path = "num/shells/i32.rs"]
-pub mod i32;
-#[rustc_diagnostic_item = "i64_legacy_mod"]
-#[path = "num/shells/i64.rs"]
-pub mod i64;
-#[rustc_diagnostic_item = "i8_legacy_mod"]
-#[path = "num/shells/i8.rs"]
-pub mod i8;
-#[rustc_diagnostic_item = "isize_legacy_mod"]
-#[path = "num/shells/isize.rs"]
-pub mod isize;
-
-#[rustc_diagnostic_item = "u128_legacy_mod"]
-#[path = "num/shells/u128.rs"]
-pub mod u128;
-#[rustc_diagnostic_item = "u16_legacy_mod"]
-#[path = "num/shells/u16.rs"]
-pub mod u16;
-#[rustc_diagnostic_item = "u32_legacy_mod"]
-#[path = "num/shells/u32.rs"]
-pub mod u32;
-#[rustc_diagnostic_item = "u64_legacy_mod"]
-#[path = "num/shells/u64.rs"]
-pub mod u64;
-#[rustc_diagnostic_item = "u8_legacy_mod"]
-#[path = "num/shells/u8.rs"]
-pub mod u8;
-#[rustc_diagnostic_item = "usize_legacy_mod"]
-#[path = "num/shells/usize.rs"]
-pub mod usize;
+#[path = "num/shells/legacy_int_modules.rs"]
+mod legacy_int_modules;
+#[stable(feature = "rust1", since = "1.0.0")]
+#[allow(clippy::useless_attribute)] // FIXME false positive (https://github.com/rust-lang/rust-clippy/issues/15636)
+#[allow(deprecated_in_future)]
+pub use legacy_int_modules::{i8, i16, i32, i64, isize, u8, u16, u32, u64, usize};
+#[stable(feature = "i128", since = "1.26.0")]
+#[allow(clippy::useless_attribute)] // FIXME false positive (https://github.com/rust-lang/rust-clippy/issues/15636)
+#[allow(deprecated_in_future)]
+pub use legacy_int_modules::{i128, u128};
 
 #[path = "num/f128.rs"]
 pub mod f128;
diff --git a/library/core/src/num/shells/i128.rs b/library/core/src/num/shells/i128.rs
deleted file mode 100644
index b3b3d3b4875ab..0000000000000
--- a/library/core/src/num/shells/i128.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//! Redundant constants module for the [`i128` primitive type][i128].
-//!
-//! New code should use the associated constants directly on the primitive type.
-
-#![stable(feature = "i128", since = "1.26.0")]
-#![deprecated(
-    since = "TBD",
-    note = "all constants in this module replaced by associated constants on `i128`"
-)]
-
-int_module! { i128, #[stable(feature = "i128", since="1.26.0")] }
diff --git a/library/core/src/num/shells/i16.rs b/library/core/src/num/shells/i16.rs
deleted file mode 100644
index 70a452e193983..0000000000000
--- a/library/core/src/num/shells/i16.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//! Redundant constants module for the [`i16` primitive type][i16].
-//!
-//! New code should use the associated constants directly on the primitive type.
-
-#![stable(feature = "rust1", since = "1.0.0")]
-#![deprecated(
-    since = "TBD",
-    note = "all constants in this module replaced by associated constants on `i16`"
-)]
-
-int_module! { i16 }
diff --git a/library/core/src/num/shells/i32.rs b/library/core/src/num/shells/i32.rs
deleted file mode 100644
index c30849e2591c3..0000000000000
--- a/library/core/src/num/shells/i32.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//! Redundant constants module for the [`i32` primitive type][i32].
-//!
-//! New code should use the associated constants directly on the primitive type.
-
-#![stable(feature = "rust1", since = "1.0.0")]
-#![deprecated(
-    since = "TBD",
-    note = "all constants in this module replaced by associated constants on `i32`"
-)]
-
-int_module! { i32 }
diff --git a/library/core/src/num/shells/i64.rs b/library/core/src/num/shells/i64.rs
deleted file mode 100644
index 77d95d712506b..0000000000000
--- a/library/core/src/num/shells/i64.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//! Redundant constants module for the [`i64` primitive type][i64].
-//!
-//! New code should use the associated constants directly on the primitive type.
-
-#![stable(feature = "rust1", since = "1.0.0")]
-#![deprecated(
-    since = "TBD",
-    note = "all constants in this module replaced by associated constants on `i64`"
-)]
-
-int_module! { i64 }
diff --git a/library/core/src/num/shells/i8.rs b/library/core/src/num/shells/i8.rs
deleted file mode 100644
index 516ba8cdef3bf..0000000000000
--- a/library/core/src/num/shells/i8.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//! Redundant constants module for the [`i8` primitive type][i8].
-//!
-//! New code should use the associated constants directly on the primitive type.
-
-#![stable(feature = "rust1", since = "1.0.0")]
-#![deprecated(
-    since = "TBD",
-    note = "all constants in this module replaced by associated constants on `i8`"
-)]
-
-int_module! { i8 }
diff --git a/library/core/src/num/shells/int_macros.rs b/library/core/src/num/shells/int_macros.rs
deleted file mode 100644
index 8ae9b7abae3bd..0000000000000
--- a/library/core/src/num/shells/int_macros.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-#![doc(hidden)]
-
-macro_rules! int_module {
-    ($T:ident) => (int_module!($T, #[stable(feature = "rust1", since = "1.0.0")]););
-    ($T:ident, #[$attr:meta]) => (
-        #[doc = concat!(
-            "The smallest value that can be represented by this integer type. Use ",
-            "[`", stringify!($T), "::MIN", "`] instead."
-        )]
-        ///
-        /// # Examples
-        ///
-        /// ```rust
-        /// // deprecated way
-        #[doc = concat!("let min = std::", stringify!($T), "::MIN;")]
-        ///
-        /// // intended way
-        #[doc = concat!("let min = ", stringify!($T), "::MIN;")]
-        /// ```
-        ///
-        #[$attr]
-        #[deprecated(since = "TBD", note = "replaced by the `MIN` associated constant on this type")]
-        #[rustc_diagnostic_item = concat!(stringify!($T), "_legacy_const_min")]
-        pub const MIN: $T = $T::MIN;
-
-        #[doc = concat!(
-            "The largest value that can be represented by this integer type. Use ",
-            "[`", stringify!($T), "::MAX", "`] instead."
-        )]
-        ///
-        /// # Examples
-        ///
-        /// ```rust
-        /// // deprecated way
-        #[doc = concat!("let max = std::", stringify!($T), "::MAX;")]
-        ///
-        /// // intended way
-        #[doc = concat!("let max = ", stringify!($T), "::MAX;")]
-        /// ```
-        ///
-        #[$attr]
-        #[deprecated(since = "TBD", note = "replaced by the `MAX` associated constant on this type")]
-        #[rustc_diagnostic_item = concat!(stringify!($T), "_legacy_const_max")]
-        pub const MAX: $T = $T::MAX;
-    )
-}
diff --git a/library/core/src/num/shells/isize.rs b/library/core/src/num/shells/isize.rs
deleted file mode 100644
index 828f7345bafbe..0000000000000
--- a/library/core/src/num/shells/isize.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//! Redundant constants module for the [`isize` primitive type][isize].
-//!
-//! New code should use the associated constants directly on the primitive type.
-
-#![stable(feature = "rust1", since = "1.0.0")]
-#![deprecated(
-    since = "TBD",
-    note = "all constants in this module replaced by associated constants on `isize`"
-)]
-
-int_module! { isize }
diff --git a/library/core/src/num/shells/legacy_int_modules.rs b/library/core/src/num/shells/legacy_int_modules.rs
new file mode 100644
index 0000000000000..6b4f253911157
--- /dev/null
+++ b/library/core/src/num/shells/legacy_int_modules.rs
@@ -0,0 +1,71 @@
+#![doc(hidden)]
+
+macro_rules! legacy_int_module {
+    ($T:ident) => (legacy_int_module!($T, #[stable(feature = "rust1", since = "1.0.0")]););
+    ($T:ident, #[$attr:meta]) => (
+        #[$attr]
+        #[deprecated(
+            since = "TBD",
+            note = "all constants in this module replaced by associated constants on the type"
+        )]
+        #[rustc_diagnostic_item = concat!(stringify!($T), "_legacy_mod")]
+        pub mod $T {
+            #![doc = concat!("Redundant constants module for the [`", stringify!($T), "` primitive type][", stringify!($T), "].")]
+            //!
+            //! New code should use the associated constants directly on the primitive type.
+
+            #[doc = concat!(
+                "The smallest value that can be represented by this integer type. Use ",
+                "[`", stringify!($T), "::MIN", "`] instead."
+            )]
+            ///
+            /// # Examples
+            ///
+            /// ```rust
+            /// // deprecated way
+            #[doc = concat!("let min = std::", stringify!($T), "::MIN;")]
+            ///
+            /// // intended way
+            #[doc = concat!("let min = ", stringify!($T), "::MIN;")]
+            /// ```
+            ///
+            #[$attr]
+            #[deprecated(since = "TBD", note = "replaced by the `MIN` associated constant on this type")]
+            #[rustc_diagnostic_item = concat!(stringify!($T), "_legacy_const_min")]
+            pub const MIN: $T = $T::MIN;
+
+            #[doc = concat!(
+                "The largest value that can be represented by this integer type. Use ",
+                "[`", stringify!($T), "::MAX", "`] instead."
+            )]
+            ///
+            /// # Examples
+            ///
+            /// ```rust
+            /// // deprecated way
+            #[doc = concat!("let max = std::", stringify!($T), "::MAX;")]
+            ///
+            /// // intended way
+            #[doc = concat!("let max = ", stringify!($T), "::MAX;")]
+            /// ```
+            ///
+            #[$attr]
+            #[deprecated(since = "TBD", note = "replaced by the `MAX` associated constant on this type")]
+            #[rustc_diagnostic_item = concat!(stringify!($T), "_legacy_const_max")]
+            pub const MAX: $T = $T::MAX;
+        }
+    )
+}
+
+legacy_int_module! { i128, #[stable(feature = "i128", since = "1.26.0")] }
+legacy_int_module! { i16 }
+legacy_int_module! { i32 }
+legacy_int_module! { i64 }
+legacy_int_module! { i8 }
+legacy_int_module! { isize }
+legacy_int_module! { u128, #[stable(feature = "i128", since = "1.26.0")] }
+legacy_int_module! { u16 }
+legacy_int_module! { u32 }
+legacy_int_module! { u64 }
+legacy_int_module! { u8 }
+legacy_int_module! { usize }
diff --git a/library/core/src/num/shells/u128.rs b/library/core/src/num/shells/u128.rs
deleted file mode 100644
index b1e30e3843525..0000000000000
--- a/library/core/src/num/shells/u128.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//! Redundant constants module for the [`u128` primitive type][u128].
-//!
-//! New code should use the associated constants directly on the primitive type.
-
-#![stable(feature = "i128", since = "1.26.0")]
-#![deprecated(
-    since = "TBD",
-    note = "all constants in this module replaced by associated constants on `u128`"
-)]
-
-int_module! { u128, #[stable(feature = "i128", since="1.26.0")] }
diff --git a/library/core/src/num/shells/u16.rs b/library/core/src/num/shells/u16.rs
deleted file mode 100644
index 7394977e5078a..0000000000000
--- a/library/core/src/num/shells/u16.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//! Redundant constants module for the [`u16` primitive type][u16].
-//!
-//! New code should use the associated constants directly on the primitive type.
-
-#![stable(feature = "rust1", since = "1.0.0")]
-#![deprecated(
-    since = "TBD",
-    note = "all constants in this module replaced by associated constants on `u16`"
-)]
-
-int_module! { u16 }
diff --git a/library/core/src/num/shells/u32.rs b/library/core/src/num/shells/u32.rs
deleted file mode 100644
index 4c84274e752ec..0000000000000
--- a/library/core/src/num/shells/u32.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//! Redundant constants module for the [`u32` primitive type][u32].
-//!
-//! New code should use the associated constants directly on the primitive type.
-
-#![stable(feature = "rust1", since = "1.0.0")]
-#![deprecated(
-    since = "TBD",
-    note = "all constants in this module replaced by associated constants on `u32`"
-)]
-
-int_module! { u32 }
diff --git a/library/core/src/num/shells/u64.rs b/library/core/src/num/shells/u64.rs
deleted file mode 100644
index 47a95c6820f2f..0000000000000
--- a/library/core/src/num/shells/u64.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//! Redundant constants module for the [`u64` primitive type][u64].
-//!
-//! New code should use the associated constants directly on the primitive type.
-
-#![stable(feature = "rust1", since = "1.0.0")]
-#![deprecated(
-    since = "TBD",
-    note = "all constants in this module replaced by associated constants on `u64`"
-)]
-
-int_module! { u64 }
diff --git a/library/core/src/num/shells/u8.rs b/library/core/src/num/shells/u8.rs
deleted file mode 100644
index 360baef722869..0000000000000
--- a/library/core/src/num/shells/u8.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//! Redundant constants module for the [`u8` primitive type][u8].
-//!
-//! New code should use the associated constants directly on the primitive type.
-
-#![stable(feature = "rust1", since = "1.0.0")]
-#![deprecated(
-    since = "TBD",
-    note = "all constants in this module replaced by associated constants on `u8`"
-)]
-
-int_module! { u8 }
diff --git a/library/core/src/num/shells/usize.rs b/library/core/src/num/shells/usize.rs
deleted file mode 100644
index 44c24dfc2cf58..0000000000000
--- a/library/core/src/num/shells/usize.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//! Redundant constants module for the [`usize` primitive type][usize].
-//!
-//! New code should use the associated constants directly on the primitive type.
-
-#![stable(feature = "rust1", since = "1.0.0")]
-#![deprecated(
-    since = "TBD",
-    note = "all constants in this module replaced by associated constants on `usize`"
-)]
-
-int_module! { usize }

From 17943cc47a42472fed79d92cdabeff55f021d6e3 Mon Sep 17 00:00:00 2001
From: Ifeanyi Orizu <iorizu1811@gmail.com>
Date: Mon, 8 Sep 2025 13:29:06 -0500
Subject: [PATCH 0695/1889] Skip flycheck for workspace if it is already being
 checked

---
 .../src/handlers/notification.rs              | 25 ++++++++++++-------
 1 file changed, 16 insertions(+), 9 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/notification.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/notification.rs
index e193ff77743d1..fb743e73c74a4 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/notification.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/notification.rs
@@ -303,11 +303,11 @@ fn run_flycheck(state: &mut GlobalState, vfs_path: VfsPath) -> bool {
         let world = state.snapshot();
         let invocation_strategy_once = state.config.flycheck(None).invocation_strategy_once();
         let may_flycheck_workspace = state.config.flycheck_workspace(None);
-        let mut updated = false;
+        let mut workspace_check_triggered = false;
         let task = move || -> std::result::Result<(), Cancelled> {
+            let saved_file = vfs_path.as_path().map(|p| p.to_owned());
             if invocation_strategy_once {
-                let saved_file = vfs_path.as_path().map(|p| p.to_owned());
-                world.flycheck[0].restart_workspace(saved_file);
+                world.flycheck[0].restart_workspace(saved_file.clone());
             }
 
             let target = TargetSpec::for_file(&world, file_id)?.and_then(|it| {
@@ -330,6 +330,7 @@ fn run_flycheck(state: &mut GlobalState, vfs_path: VfsPath) -> bool {
             tracing::debug!(?target, "flycheck target");
             // we have a specific non-library target, attempt to only check that target, nothing
             // else will be affected
+            let mut package_workspace_idx = None;
             if let Some((target, root, package)) = target {
                 // trigger a package check if we have a non-library target as that can't affect
                 // anything else in the workspace OR if we're not allowed to check the workspace as
@@ -345,6 +346,7 @@ fn run_flycheck(state: &mut GlobalState, vfs_path: VfsPath) -> bool {
                         _ => false,
                     });
                     if let Some(idx) = workspace {
+                        package_workspace_idx = Some(idx);
                         world.flycheck[idx].restart_for_package(package, target);
                     }
                 }
@@ -381,8 +383,15 @@ fn run_flycheck(state: &mut GlobalState, vfs_path: VfsPath) -> bool {
             tracing::debug!(?crate_root_paths, "flycheck crate roots");
 
             // Find all workspaces that have at least one target containing the saved file
-            let workspace_ids =
-                world.workspaces.iter().enumerate().filter(|(_, ws)| match &ws.kind {
+            let workspace_ids = world
+                .workspaces
+                .iter()
+                .enumerate()
+                .filter(|&(idx, _)| match package_workspace_idx {
+                    Some(pkg_idx) => idx != pkg_idx,
+                    None => true,
+                })
+                .filter(|&(_, ws)| match &ws.kind {
                     project_model::ProjectWorkspaceKind::Cargo { cargo, .. }
                     | project_model::ProjectWorkspaceKind::DetachedFile {
                         cargo: Some((cargo, _, _)),
@@ -399,20 +408,18 @@ fn run_flycheck(state: &mut GlobalState, vfs_path: VfsPath) -> bool {
                     project_model::ProjectWorkspaceKind::DetachedFile { .. } => false,
                 });
 
-            let saved_file = vfs_path.as_path().map(|p| p.to_owned());
-
             // Find and trigger corresponding flychecks
             'flychecks: for flycheck in world.flycheck.iter() {
                 for (id, _) in workspace_ids.clone() {
                     if id == flycheck.id() {
-                        updated = true;
+                        workspace_check_triggered = true;
                         flycheck.restart_workspace(saved_file.clone());
                         continue 'flychecks;
                     }
                 }
             }
             // No specific flycheck was triggered, so let's trigger all of them.
-            if !updated {
+            if !workspace_check_triggered && package_workspace_idx.is_none() {
                 for flycheck in world.flycheck.iter() {
                     flycheck.restart_workspace(saved_file.clone());
                 }

From 92f24020967e4e1f1375dbb2d1ba85cd4430fc78 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Sun, 24 Aug 2025 10:56:41 +0200
Subject: [PATCH 0696/1889] port `#[recursion_limit]` to the new attribute
 parsing infrastructure

---
 compiler/rustc_attr_parsing/messages.ftl      |  4 ++
 .../src/attributes/crate_level.rs             | 62 ++++++++++++++++++-
 .../src/attributes/prelude.rs                 |  2 +-
 compiler/rustc_attr_parsing/src/context.rs    |  3 +-
 .../src/session_diagnostics.rs                | 10 +++
 .../rustc_hir/src/attrs/data_structures.rs    |  3 +
 .../rustc_hir/src/attrs/encode_cross_crate.rs |  1 +
 .../rustc_hir/src/attrs/pretty_printing.rs    |  2 +-
 compiler/rustc_passes/src/check_attr.rs       |  1 +
 9 files changed, 84 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_attr_parsing/messages.ftl b/compiler/rustc_attr_parsing/messages.ftl
index 7fa1293463cc5..839a5d23c3b4d 100644
--- a/compiler/rustc_attr_parsing/messages.ftl
+++ b/compiler/rustc_attr_parsing/messages.ftl
@@ -247,3 +247,7 @@ attr_parsing_raw_dylib_only_windows =
 
 attr_parsing_whole_archive_needs_static =
     linking modifier `whole-archive` is only compatible with `static` linking kind
+
+attr_parsing_limit_invalid =
+    `limit` must be a non-negative integer
+    .label = {$error_str}
diff --git a/compiler/rustc_attr_parsing/src/attributes/crate_level.rs b/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
index 2fed09b85e87b..e3654d495801b 100644
--- a/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
@@ -1,7 +1,40 @@
-use rustc_feature::AttributeType;
+use std::num::IntErrorKind;
+
+use crate::session_diagnostics::LimitInvalid;
 
 use super::prelude::*;
 
+impl<S: Stage> AcceptContext<'_, '_, S> {
+    fn parse_limit_int(&self, nv: &NameValueParser) -> Option<usize> {
+        let Some(limit) = nv.value_as_str() else {
+            self.expected_string_literal(nv.value_span, Some(nv.value_as_lit()));
+            return None;
+        };
+
+        let error_str = match limit.as_str().parse() {
+            Ok(i) => return Some(i),
+            Err(e) => match e.kind() {
+                IntErrorKind::PosOverflow => "`limit` is too large",
+                IntErrorKind::Empty => "`limit` must be a non-negative integer",
+                IntErrorKind::InvalidDigit => "not a valid integer",
+                IntErrorKind::NegOverflow => {
+                    panic!(
+                        "`limit` should never negatively overflow since we're parsing into a usize and we'd get Empty instead"
+                    )
+                }
+                IntErrorKind::Zero => {
+                    panic!("zero is a valid `limit` so should have returned Ok() when parsing")
+                }
+                kind => panic!("unimplemented IntErrorKind variant: {:?}", kind),
+            },
+        };
+
+        self.emit_err(LimitInvalid { span: self.attr_span, value_span: nv.value_span, error_str });
+
+        None
+    }
+}
+
 pub(crate) struct CrateNameParser;
 
 impl<S: Stage> SingleAttributeParser<S> for CrateNameParser {
@@ -34,3 +67,30 @@ impl<S: Stage> SingleAttributeParser<S> for CrateNameParser {
         })
     }
 }
+
+pub(crate) struct RecursionLimitParser;
+
+impl<S: Stage> SingleAttributeParser<S> for RecursionLimitParser {
+    const PATH: &[Symbol] = &[sym::recursion_limit];
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
+    const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N", "https://doc.rust-lang.org/reference/attributes/limits.html#the-recursion_limit-attribute");
+    const TYPE: AttributeType = AttributeType::CrateLevel;
+
+    // FIXME: recursion limit is allowed on all targets and ignored,
+    //        even though it should only be valid on crates of course
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
+
+    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
+        let ArgParser::NameValue(nv) = args else {
+            cx.expected_name_value(cx.attr_span, None);
+            return None;
+        };
+
+        Some(AttributeKind::RecursionLimit {
+            limit: cx.parse_limit_int(nv)?,
+            attr_span: cx.attr_span,
+            limit_span: nv.value_span,
+        })
+    }
+}
diff --git a/compiler/rustc_attr_parsing/src/attributes/prelude.rs b/compiler/rustc_attr_parsing/src/attributes/prelude.rs
index 6aef7e7a67be4..e53a436613180 100644
--- a/compiler/rustc_attr_parsing/src/attributes/prelude.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/prelude.rs
@@ -1,6 +1,6 @@
 // templates
 #[doc(hidden)]
-pub(super) use rustc_feature::{AttributeTemplate, template};
+pub(super) use rustc_feature::{AttributeTemplate, AttributeType, template};
 // data structures
 #[doc(hidden)]
 pub(super) use rustc_hir::attrs::AttributeKind;
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index 7f5b810f244f1..5700668145bfd 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -24,7 +24,7 @@ use crate::attributes::codegen_attrs::{
     UsedParser,
 };
 use crate::attributes::confusables::ConfusablesParser;
-use crate::attributes::crate_level::CrateNameParser;
+use crate::attributes::crate_level::{CrateNameParser, RecursionLimitParser};
 use crate::attributes::deprecation::DeprecationParser;
 use crate::attributes::dummy::DummyParser;
 use crate::attributes::inline::{InlineParser, RustcForceInlineParser};
@@ -185,6 +185,7 @@ attribute_parsers!(
         Single<OptimizeParser>,
         Single<PathAttributeParser>,
         Single<ProcMacroDeriveParser>,
+        Single<RecursionLimitParser>,
         Single<RustcBuiltinMacroParser>,
         Single<RustcForceInlineParser>,
         Single<RustcLayoutScalarValidRangeEnd>,
diff --git a/compiler/rustc_attr_parsing/src/session_diagnostics.rs b/compiler/rustc_attr_parsing/src/session_diagnostics.rs
index a9dee23bf6a3b..32ea9005a97d0 100644
--- a/compiler/rustc_attr_parsing/src/session_diagnostics.rs
+++ b/compiler/rustc_attr_parsing/src/session_diagnostics.rs
@@ -930,3 +930,13 @@ pub(crate) struct ImportNameTypeRaw {
     #[primary_span]
     pub span: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag(attr_parsing_limit_invalid)]
+pub(crate) struct LimitInvalid<'a> {
+    #[primary_span]
+    pub span: Span,
+    #[label]
+    pub value_span: Span,
+    pub error_str: &'a str,
+}
diff --git a/compiler/rustc_hir/src/attrs/data_structures.rs b/compiler/rustc_hir/src/attrs/data_structures.rs
index dd5565d6f9092..bfc7613342a06 100644
--- a/compiler/rustc_hir/src/attrs/data_structures.rs
+++ b/compiler/rustc_hir/src/attrs/data_structures.rs
@@ -611,6 +611,9 @@ pub enum AttributeKind {
     /// Represents `#[rustc_pub_transparent]` (used by the `repr_transparent_external_private_fields` lint).
     PubTransparent(Span),
 
+    /// Represents [`#[recursion_limit]`](https://doc.rust-lang.org/reference/attributes/limits.html#the-recursion_limit-attribute)
+    RecursionLimit { attr_span: Span, limit_span: Span, limit: usize },
+
     /// Represents [`#[repr]`](https://doc.rust-lang.org/stable/reference/type-layout.html#representations).
     Repr { reprs: ThinVec<(ReprAttr, Span)>, first_span: Span },
 
diff --git a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
index 3810bb6d0038e..26929e805a52f 100644
--- a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
+++ b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
@@ -75,6 +75,7 @@ impl AttributeKind {
             ProcMacroAttribute(..) => No,
             ProcMacroDerive { .. } => No,
             PubTransparent(..) => Yes,
+            RecursionLimit { .. } => No,
             Repr { .. } => No,
             RustcBuiltinMacro { .. } => Yes,
             RustcLayoutScalarValidRangeEnd(..) => Yes,
diff --git a/compiler/rustc_hir/src/attrs/pretty_printing.rs b/compiler/rustc_hir/src/attrs/pretty_printing.rs
index e65de25b45117..a4c2beb689dcc 100644
--- a/compiler/rustc_hir/src/attrs/pretty_printing.rs
+++ b/compiler/rustc_hir/src/attrs/pretty_printing.rs
@@ -146,7 +146,7 @@ macro_rules! print_tup {
 
 print_tup!(A B C D E F G H);
 print_skip!(Span, (), ErrorGuaranteed);
-print_disp!(u16, bool, NonZero<u32>);
+print_disp!(u16, bool, NonZero<u32>, usize);
 print_debug!(
     Symbol,
     Ident,
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 2cd4830b5d935..9a94f849a089c 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -270,6 +270,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::Linkage(..)
                     | AttributeKind::MustUse { .. }
                     | AttributeKind::CrateName { .. }
+                    | AttributeKind::RecursionLimit { .. }
                 ) => { /* do nothing  */ }
                 Attribute::Unparsed(attr_item) => {
                     style = Some(attr_item.style);

From a38288bbe00f64204967819fd2cfe107a7902404 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Sun, 24 Aug 2025 13:14:27 +0200
Subject: [PATCH 0697/1889] port `#[move_size_limit]` to the new attribute
 parsing infrastructure

---
 .../src/attributes/crate_level.rs             | 26 +++++++++++++++++++
 compiler/rustc_attr_parsing/src/context.rs    |  3 ++-
 .../rustc_hir/src/attrs/data_structures.rs    |  3 +++
 .../rustc_hir/src/attrs/encode_cross_crate.rs |  1 +
 compiler/rustc_passes/src/check_attr.rs       |  1 +
 5 files changed, 33 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_attr_parsing/src/attributes/crate_level.rs b/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
index e3654d495801b..af19b9f552da0 100644
--- a/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
@@ -94,3 +94,29 @@ impl<S: Stage> SingleAttributeParser<S> for RecursionLimitParser {
         })
     }
 }
+
+pub(crate) struct MoveSizeLimitParser;
+
+impl<S: Stage> SingleAttributeParser<S> for MoveSizeLimitParser {
+    const PATH: &[Symbol] = &[sym::move_size_limit];
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N");
+
+    // FIXME: move size limit is allowed on all targets and ignored,
+    //        even though it should only be valid on crates of course
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
+
+    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
+        let ArgParser::NameValue(nv) = args else {
+            cx.expected_name_value(cx.attr_span, None);
+            return None;
+        };
+
+        Some(AttributeKind::MoveSizeLimit {
+            limit: cx.parse_limit_int(nv)?,
+            attr_span: cx.attr_span,
+            limit_span: nv.value_span,
+        })
+    }
+}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index 5700668145bfd..4ec9df88e8274 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -24,7 +24,7 @@ use crate::attributes::codegen_attrs::{
     UsedParser,
 };
 use crate::attributes::confusables::ConfusablesParser;
-use crate::attributes::crate_level::{CrateNameParser, RecursionLimitParser};
+use crate::attributes::crate_level::{CrateNameParser, MoveSizeLimitParser, RecursionLimitParser};
 use crate::attributes::deprecation::DeprecationParser;
 use crate::attributes::dummy::DummyParser;
 use crate::attributes::inline::{InlineParser, RustcForceInlineParser};
@@ -181,6 +181,7 @@ attribute_parsers!(
         Single<LinkOrdinalParser>,
         Single<LinkSectionParser>,
         Single<LinkageParser>,
+        Single<MoveSizeLimitParser>,
         Single<MustUseParser>,
         Single<OptimizeParser>,
         Single<PathAttributeParser>,
diff --git a/compiler/rustc_hir/src/attrs/data_structures.rs b/compiler/rustc_hir/src/attrs/data_structures.rs
index bfc7613342a06..c565b8226197e 100644
--- a/compiler/rustc_hir/src/attrs/data_structures.rs
+++ b/compiler/rustc_hir/src/attrs/data_structures.rs
@@ -565,6 +565,9 @@ pub enum AttributeKind {
     /// Represents [`#[may_dangle]`](https://std-dev-guide.rust-lang.org/tricky/may-dangle.html).
     MayDangle(Span),
 
+    /// Represents `#[move_size_limit]`
+    MoveSizeLimit { attr_span: Span, limit_span: Span, limit: usize },
+
     /// Represents `#[must_use]`.
     MustUse {
         span: Span,
diff --git a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
index 26929e805a52f..4df77c901557c 100644
--- a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
+++ b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
@@ -61,6 +61,7 @@ impl AttributeKind {
             MacroUse { .. } => No,
             Marker(..) => No,
             MayDangle(..) => No,
+            MoveSizeLimit { .. } => No,
             MustUse { .. } => Yes,
             Naked(..) => No,
             NoImplicitPrelude(..) => No,
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 9a94f849a089c..08c3162b83170 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -271,6 +271,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::MustUse { .. }
                     | AttributeKind::CrateName { .. }
                     | AttributeKind::RecursionLimit { .. }
+                    | AttributeKind::MoveSizeLimit { .. }
                 ) => { /* do nothing  */ }
                 Attribute::Unparsed(attr_item) => {
                     style = Some(attr_item.style);

From 5dbe099dd3b9abb13cd63f8655e495f7a8d1bfcb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Sun, 24 Aug 2025 13:18:51 +0200
Subject: [PATCH 0698/1889] port `#[type_length_limit]` to the new attribute
 parsing infrastructure

---
 .../src/attributes/crate_level.rs             | 27 +++++++++++++++++++
 compiler/rustc_attr_parsing/src/context.rs    |  5 +++-
 .../rustc_hir/src/attrs/data_structures.rs    |  3 +++
 .../rustc_hir/src/attrs/encode_cross_crate.rs |  1 +
 compiler/rustc_passes/src/check_attr.rs       |  1 +
 5 files changed, 36 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_attr_parsing/src/attributes/crate_level.rs b/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
index af19b9f552da0..34793a7f403f2 100644
--- a/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
@@ -120,3 +120,30 @@ impl<S: Stage> SingleAttributeParser<S> for MoveSizeLimitParser {
         })
     }
 }
+
+pub(crate) struct TypeLengthLimitParser;
+
+impl<S: Stage> SingleAttributeParser<S> for TypeLengthLimitParser {
+    const PATH: &[Symbol] = &[sym::type_length_limit];
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
+    const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N");
+    const TYPE: AttributeType = AttributeType::CrateLevel;
+
+    // FIXME: recursion limit is allowed on all targets and ignored,
+    //        even though it should only be valid on crates of course
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowListWarnRest(&[Target::Crate]);
+
+    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
+        let ArgParser::NameValue(nv) = args else {
+            cx.expected_name_value(cx.attr_span, None);
+            return None;
+        };
+
+        Some(AttributeKind::TypeLengthLimit {
+            limit: cx.parse_limit_int(nv)?,
+            attr_span: cx.attr_span,
+            limit_span: nv.value_span,
+        })
+    }
+}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index 4ec9df88e8274..25a1993d08964 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -24,7 +24,9 @@ use crate::attributes::codegen_attrs::{
     UsedParser,
 };
 use crate::attributes::confusables::ConfusablesParser;
-use crate::attributes::crate_level::{CrateNameParser, MoveSizeLimitParser, RecursionLimitParser};
+use crate::attributes::crate_level::{
+    CrateNameParser, MoveSizeLimitParser, RecursionLimitParser, TypeLengthLimitParser,
+};
 use crate::attributes::deprecation::DeprecationParser;
 use crate::attributes::dummy::DummyParser;
 use crate::attributes::inline::{InlineParser, RustcForceInlineParser};
@@ -196,6 +198,7 @@ attribute_parsers!(
         Single<ShouldPanicParser>,
         Single<SkipDuringMethodDispatchParser>,
         Single<TransparencyParser>,
+        Single<TypeLengthLimitParser>,
         Single<WithoutArgs<AllowIncoherentImplParser>>,
         Single<WithoutArgs<AllowInternalUnsafeParser>>,
         Single<WithoutArgs<AsPtrParser>>,
diff --git a/compiler/rustc_hir/src/attrs/data_structures.rs b/compiler/rustc_hir/src/attrs/data_structures.rs
index c565b8226197e..22b39cb19e11e 100644
--- a/compiler/rustc_hir/src/attrs/data_structures.rs
+++ b/compiler/rustc_hir/src/attrs/data_structures.rs
@@ -667,6 +667,9 @@ pub enum AttributeKind {
     /// Represents `#[type_const]`.
     TypeConst(Span),
 
+    /// Represents `#[type_length_limit]`
+    TypeLengthLimit { attr_span: Span, limit_span: Span, limit: usize },
+
     /// Represents `#[rustc_unsafe_specialization_marker]`.
     UnsafeSpecializationMarker(Span),
 
diff --git a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
index 4df77c901557c..e1f2d6d36403b 100644
--- a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
+++ b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
@@ -91,6 +91,7 @@ impl AttributeKind {
             TargetFeature { .. } => No,
             TrackCaller(..) => Yes,
             TypeConst(..) => Yes,
+            TypeLengthLimit { .. } => Yes,
             UnsafeSpecializationMarker(..) => No,
             UnstableFeatureBound(..) => No,
             Used { .. } => No,
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 08c3162b83170..e69071c73e1e7 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -272,6 +272,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::CrateName { .. }
                     | AttributeKind::RecursionLimit { .. }
                     | AttributeKind::MoveSizeLimit { .. }
+                    | AttributeKind::TypeLengthLimit { .. }
                 ) => { /* do nothing  */ }
                 Attribute::Unparsed(attr_item) => {
                     style = Some(attr_item.style);

From b82171de5fe2a13a12f35ce4368ef34a477f55c4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Sun, 24 Aug 2025 13:19:31 +0200
Subject: [PATCH 0699/1889] port `#[pattern_complexity_limit]` to the new
 attribute parsing infrastructure

---
 .../src/attributes/crate_level.rs             | 27 +++++++++++++++++++
 compiler/rustc_attr_parsing/src/context.rs    |  4 ++-
 .../rustc_hir/src/attrs/data_structures.rs    |  3 +++
 .../rustc_hir/src/attrs/encode_cross_crate.rs |  1 +
 compiler/rustc_passes/src/check_attr.rs       |  1 +
 5 files changed, 35 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_attr_parsing/src/attributes/crate_level.rs b/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
index 34793a7f403f2..6fd4a4a753b66 100644
--- a/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
@@ -147,3 +147,30 @@ impl<S: Stage> SingleAttributeParser<S> for TypeLengthLimitParser {
         })
     }
 }
+
+pub(crate) struct PatternComplexityLimitParser;
+
+impl<S: Stage> SingleAttributeParser<S> for PatternComplexityLimitParser {
+    const PATH: &[Symbol] = &[sym::pattern_complexity_limit];
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N");
+    const TYPE: AttributeType = AttributeType::CrateLevel;
+
+    // FIXME: recursion limit is allowed on all targets and ignored,
+    //        even though it should only be valid on crates of course
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
+
+    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
+        let ArgParser::NameValue(nv) = args else {
+            cx.expected_name_value(cx.attr_span, None);
+            return None;
+        };
+
+        Some(AttributeKind::PatternComplexityLimit {
+            limit: cx.parse_limit_int(nv)?,
+            attr_span: cx.attr_span,
+            limit_span: nv.value_span,
+        })
+    }
+}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index 25a1993d08964..fc41e38c797b4 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -25,7 +25,8 @@ use crate::attributes::codegen_attrs::{
 };
 use crate::attributes::confusables::ConfusablesParser;
 use crate::attributes::crate_level::{
-    CrateNameParser, MoveSizeLimitParser, RecursionLimitParser, TypeLengthLimitParser,
+    CrateNameParser, MoveSizeLimitParser, PatternComplexityLimitParser, RecursionLimitParser,
+    TypeLengthLimitParser,
 };
 use crate::attributes::deprecation::DeprecationParser;
 use crate::attributes::dummy::DummyParser;
@@ -187,6 +188,7 @@ attribute_parsers!(
         Single<MustUseParser>,
         Single<OptimizeParser>,
         Single<PathAttributeParser>,
+        Single<PatternComplexityLimitParser>,
         Single<ProcMacroDeriveParser>,
         Single<RecursionLimitParser>,
         Single<RustcBuiltinMacroParser>,
diff --git a/compiler/rustc_hir/src/attrs/data_structures.rs b/compiler/rustc_hir/src/attrs/data_structures.rs
index 22b39cb19e11e..c4e068ad42577 100644
--- a/compiler/rustc_hir/src/attrs/data_structures.rs
+++ b/compiler/rustc_hir/src/attrs/data_structures.rs
@@ -599,6 +599,9 @@ pub enum AttributeKind {
     /// Represents `#[path]`
     Path(Symbol, Span),
 
+    /// Represents `#[pattern_complexity_limit]`
+    PatternComplexityLimit { attr_span: Span, limit_span: Span, limit: usize },
+
     /// Represents `#[pointee]`
     Pointee(Span),
 
diff --git a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
index e1f2d6d36403b..89ba1e0d7de45 100644
--- a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
+++ b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
@@ -71,6 +71,7 @@ impl AttributeKind {
             ParenSugar(..) => No,
             PassByValue(..) => Yes,
             Path(..) => No,
+            PatternComplexityLimit { .. } => No,
             Pointee(..) => No,
             ProcMacro(..) => No,
             ProcMacroAttribute(..) => No,
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index e69071c73e1e7..487bdd2a888e7 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -273,6 +273,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::RecursionLimit { .. }
                     | AttributeKind::MoveSizeLimit { .. }
                     | AttributeKind::TypeLengthLimit { .. }
+                    | AttributeKind::PatternComplexityLimit { .. }
                 ) => { /* do nothing  */ }
                 Attribute::Unparsed(attr_item) => {
                     style = Some(attr_item.style);

From 6087d89004eda5e1f6406182b9866497ecb22e99 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Sun, 24 Aug 2025 13:25:36 +0200
Subject: [PATCH 0700/1889] fixup limit handling code

---
 Cargo.lock                                    |   1 -
 .../src/attributes/crate_level.rs             |  34 +--
 .../src/attributes/prelude.rs                 |   3 +-
 compiler/rustc_attr_parsing/src/context.rs    |  13 +-
 .../src/interpret/eval_context.rs             |   2 +-
 compiler/rustc_expand/src/base.rs             |   3 +-
 compiler/rustc_expand/src/errors.rs           |   2 +-
 compiler/rustc_expand/src/expand.rs           |   4 +-
 .../rustc_hir/src/attrs/data_structures.rs    |   9 +-
 .../rustc_hir/src/attrs/encode_cross_crate.rs |   2 +-
 .../rustc_hir/src/attrs/pretty_printing.rs    |   4 +-
 compiler/rustc_hir/src/lib.rs                 |   1 +
 compiler/rustc_hir/src/limit.rs               |  63 +++++
 compiler/rustc_hir_analysis/src/autoderef.rs  |   2 +-
 compiler/rustc_hir_analysis/src/errors.rs     |   3 +-
 compiler/rustc_interface/messages.ftl         |   4 -
 compiler/rustc_interface/src/errors.rs        |  10 -
 compiler/rustc_interface/src/limits.rs        |  88 ++----
 compiler/rustc_interface/src/passes.rs        |  54 ++--
 compiler/rustc_middle/src/error.rs            |   2 +-
 compiler/rustc_middle/src/ty/context.rs       |   3 +-
 compiler/rustc_middle/src/ty/error.rs         |   3 +-
 compiler/rustc_middle/src/ty/print/pretty.rs  |   2 +-
 compiler/rustc_middle/src/ty/util.rs          |   2 +-
 .../rustc_mir_transform/src/inline/cycle.rs   |   2 +-
 compiler/rustc_monomorphize/src/collector.rs  |   2 +-
 .../src/mono_checks/move_check.rs             |   2 +-
 compiler/rustc_query_impl/Cargo.toml          |   1 -
 compiler/rustc_query_impl/src/plumbing.rs     |   2 +-
 compiler/rustc_query_system/src/error.rs      |   2 +-
 compiler/rustc_session/src/session.rs         |  62 +----
 .../src/error_reporting/traits/overflow.rs    |   4 +-
 compiler/rustc_ty_utils/src/needs_drop.rs     |   2 +-
 .../issue-43106-gating-of-builtin-attrs.rs    |  24 +-
 ...issue-43106-gating-of-builtin-attrs.stderr | 262 ++++++++++--------
 .../lint/unused/unused-attr-duplicate.stderr  |  52 ++--
 .../unused/unused-attr-macro-rules.stderr     |  35 +--
 tests/ui/recursion_limit/empty.rs             |   8 +-
 tests/ui/recursion_limit/empty.stderr         |  12 +-
 tests/ui/recursion_limit/invalid_digit.rs     |   8 +-
 tests/ui/recursion_limit/invalid_digit.stderr |  12 +-
 .../recursion_limit/invalid_digit_type.stderr |   8 +-
 tests/ui/recursion_limit/invalid_macro.rs     |   2 +-
 tests/ui/recursion_limit/invalid_macro.stderr |   8 +-
 tests/ui/recursion_limit/no-value.stderr      |   3 +-
 tests/ui/recursion_limit/overflow.rs          |   3 -
 tests/ui/recursion_limit/overflow.stderr      |  12 +-
 47 files changed, 385 insertions(+), 457 deletions(-)
 create mode 100644 compiler/rustc_hir/src/limit.rs

diff --git a/Cargo.lock b/Cargo.lock
index 81f19668c24b7..78be59b3091be 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4409,7 +4409,6 @@ dependencies = [
  "rustc_middle",
  "rustc_query_system",
  "rustc_serialize",
- "rustc_session",
  "rustc_span",
  "tracing",
 ]
diff --git a/compiler/rustc_attr_parsing/src/attributes/crate_level.rs b/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
index 6fd4a4a753b66..d23a7ae72f8c8 100644
--- a/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
@@ -1,18 +1,19 @@
 use std::num::IntErrorKind;
 
-use crate::session_diagnostics::LimitInvalid;
+use rustc_hir::limit::Limit;
 
 use super::prelude::*;
+use crate::session_diagnostics::LimitInvalid;
 
 impl<S: Stage> AcceptContext<'_, '_, S> {
-    fn parse_limit_int(&self, nv: &NameValueParser) -> Option<usize> {
+    fn parse_limit_int(&self, nv: &NameValueParser) -> Option<Limit> {
         let Some(limit) = nv.value_as_str() else {
             self.expected_string_literal(nv.value_span, Some(nv.value_as_lit()));
             return None;
         };
 
         let error_str = match limit.as_str().parse() {
-            Ok(i) => return Some(i),
+            Ok(i) => return Some(Limit::new(i)),
             Err(e) => match e.kind() {
                 IntErrorKind::PosOverflow => "`limit` is too large",
                 IntErrorKind::Empty => "`limit` must be a non-negative integer",
@@ -44,8 +45,8 @@ impl<S: Stage> SingleAttributeParser<S> for CrateNameParser {
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "name");
     const TYPE: AttributeType = AttributeType::CrateLevel;
 
-    // FIXME: crate name is allowed on all targets and ignored,
-    //        even though it should only be valid on crates of course
+    // because it's a crate-level attribute, we already warn about it.
+    // Putting target limitations here would give duplicate warnings
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
@@ -77,8 +78,8 @@ impl<S: Stage> SingleAttributeParser<S> for RecursionLimitParser {
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N", "https://doc.rust-lang.org/reference/attributes/limits.html#the-recursion_limit-attribute");
     const TYPE: AttributeType = AttributeType::CrateLevel;
 
-    // FIXME: recursion limit is allowed on all targets and ignored,
-    //        even though it should only be valid on crates of course
+    // because it's a crate-level attribute, we already warn about it.
+    // Putting target limitations here would give duplicate warnings
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
@@ -102,10 +103,11 @@ impl<S: Stage> SingleAttributeParser<S> for MoveSizeLimitParser {
     const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N");
+    const TYPE: AttributeType = AttributeType::CrateLevel;
 
-    // FIXME: move size limit is allowed on all targets and ignored,
-    //        even though it should only be valid on crates of course
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
+    // because it's a crate-level attribute, we already warn about it.
+    // Putting target limitations here would give duplicate warnings
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
         let ArgParser::NameValue(nv) = args else {
@@ -130,9 +132,9 @@ impl<S: Stage> SingleAttributeParser<S> for TypeLengthLimitParser {
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N");
     const TYPE: AttributeType = AttributeType::CrateLevel;
 
-    // FIXME: recursion limit is allowed on all targets and ignored,
-    //        even though it should only be valid on crates of course
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowListWarnRest(&[Target::Crate]);
+    // because it's a crate-level attribute, we already warn about it.
+    // Putting target limitations here would give duplicate warnings
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
         let ArgParser::NameValue(nv) = args else {
@@ -157,9 +159,9 @@ impl<S: Stage> SingleAttributeParser<S> for PatternComplexityLimitParser {
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N");
     const TYPE: AttributeType = AttributeType::CrateLevel;
 
-    // FIXME: recursion limit is allowed on all targets and ignored,
-    //        even though it should only be valid on crates of course
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
+    // because it's a crate-level attribute, we already warn about it.
+    // Putting target limitations here would give duplicate warnings
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
         let ArgParser::NameValue(nv) = args else {
diff --git a/compiler/rustc_attr_parsing/src/attributes/prelude.rs b/compiler/rustc_attr_parsing/src/attributes/prelude.rs
index e53a436613180..8f040ffb9d41c 100644
--- a/compiler/rustc_attr_parsing/src/attributes/prelude.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/prelude.rs
@@ -1,7 +1,6 @@
-// templates
+// data structures
 #[doc(hidden)]
 pub(super) use rustc_feature::{AttributeTemplate, AttributeType, template};
-// data structures
 #[doc(hidden)]
 pub(super) use rustc_hir::attrs::AttributeKind;
 #[doc(hidden)]
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index fc41e38c797b4..98e86838a3a18 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -353,7 +353,10 @@ impl<'f, 'sess: 'f, S: Stage> SharedContext<'f, 'sess, S> {
     /// must be delayed until after HIR is built. This method will take care of the details of
     /// that.
     pub(crate) fn emit_lint(&mut self, lint: AttributeLintKind, span: Span) {
-        if matches!(self.stage.should_emit(), ShouldEmit::Nothing) {
+        if !matches!(
+            self.stage.should_emit(),
+            ShouldEmit::ErrorsAndLints | ShouldEmit::EarlyFatal { also_emit_lints: true }
+        ) {
             return;
         }
         let id = self.target_id;
@@ -677,20 +680,20 @@ pub enum ShouldEmit {
     ///
     /// Only relevant when early parsing, in late parsing equivalent to `ErrorsAndLints`.
     /// Late parsing is never fatal, and instead tries to emit as many diagnostics as possible.
-    EarlyFatal,
+    EarlyFatal { also_emit_lints: bool },
     /// The operation will emit errors and lints.
     /// This is usually what you need.
     ErrorsAndLints,
     /// The operation will emit *not* errors and lints.
-    /// Use this if you are *sure* that this operation will be called at a different time with `ShouldEmit::Emit`.
+    /// Use this if you are *sure* that this operation will be called at a different time with `ShouldEmit::ErrorsAndLints`.
     Nothing,
 }
 
 impl ShouldEmit {
     pub(crate) fn emit_err(&self, diag: Diag<'_>) -> ErrorGuaranteed {
         match self {
-            ShouldEmit::EarlyFatal if diag.level() == Level::DelayedBug => diag.emit(),
-            ShouldEmit::EarlyFatal => diag.upgrade_to_fatal().emit(),
+            ShouldEmit::EarlyFatal { .. } if diag.level() == Level::DelayedBug => diag.emit(),
+            ShouldEmit::EarlyFatal { .. } => diag.upgrade_to_fatal().emit(),
             ShouldEmit::ErrorsAndLints => diag.emit(),
             ShouldEmit::Nothing => diag.delay_as_bug(),
         }
diff --git a/compiler/rustc_const_eval/src/interpret/eval_context.rs b/compiler/rustc_const_eval/src/interpret/eval_context.rs
index 9681d89ce35f2..91ed71ac3e54c 100644
--- a/compiler/rustc_const_eval/src/interpret/eval_context.rs
+++ b/compiler/rustc_const_eval/src/interpret/eval_context.rs
@@ -4,6 +4,7 @@ use either::{Left, Right};
 use rustc_abi::{Align, HasDataLayout, Size, TargetDataLayout};
 use rustc_errors::DiagCtxtHandle;
 use rustc_hir::def_id::DefId;
+use rustc_hir::limit::Limit;
 use rustc_middle::mir::interpret::{ErrorHandled, InvalidMetaKind, ReportedErrorInfo};
 use rustc_middle::query::TyCtxtAt;
 use rustc_middle::ty::layout::{
@@ -12,7 +13,6 @@ use rustc_middle::ty::layout::{
 };
 use rustc_middle::ty::{self, GenericArgsRef, Ty, TyCtxt, TypeFoldable, TypingEnv, Variance};
 use rustc_middle::{mir, span_bug};
-use rustc_session::Limit;
 use rustc_span::Span;
 use rustc_target::callconv::FnAbi;
 use tracing::{debug, trace};
diff --git a/compiler/rustc_expand/src/base.rs b/compiler/rustc_expand/src/base.rs
index 8ff21509f4a9b..88f88f30a8c69 100644
--- a/compiler/rustc_expand/src/base.rs
+++ b/compiler/rustc_expand/src/base.rs
@@ -18,13 +18,14 @@ use rustc_feature::Features;
 use rustc_hir as hir;
 use rustc_hir::attrs::{AttributeKind, CfgEntry, Deprecation};
 use rustc_hir::def::MacroKinds;
+use rustc_hir::limit::Limit;
 use rustc_hir::{Stability, find_attr};
 use rustc_lint_defs::RegisteredTools;
 use rustc_parse::MACRO_ARGUMENTS;
 use rustc_parse::parser::{ForceCollect, Parser};
+use rustc_session::Session;
 use rustc_session::config::CollapseMacroDebuginfo;
 use rustc_session::parse::ParseSess;
-use rustc_session::{Limit, Session};
 use rustc_span::def_id::{CrateNum, DefId, LocalDefId};
 use rustc_span::edition::Edition;
 use rustc_span::hygiene::{AstPass, ExpnData, ExpnKind, LocalExpnId, MacroKind};
diff --git a/compiler/rustc_expand/src/errors.rs b/compiler/rustc_expand/src/errors.rs
index ba9d76970f0cc..6eb5cd65846eb 100644
--- a/compiler/rustc_expand/src/errors.rs
+++ b/compiler/rustc_expand/src/errors.rs
@@ -2,8 +2,8 @@ use std::borrow::Cow;
 
 use rustc_ast::ast;
 use rustc_errors::codes::*;
+use rustc_hir::limit::Limit;
 use rustc_macros::{Diagnostic, Subdiagnostic};
-use rustc_session::Limit;
 use rustc_span::{Ident, MacroRulesNormalizedIdent, Span, Symbol};
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_expand/src/expand.rs b/compiler/rustc_expand/src/expand.rs
index dbb4a9de9e03a..38e057d2776e4 100644
--- a/compiler/rustc_expand/src/expand.rs
+++ b/compiler/rustc_expand/src/expand.rs
@@ -19,14 +19,15 @@ use rustc_errors::PResult;
 use rustc_feature::Features;
 use rustc_hir::Target;
 use rustc_hir::def::MacroKinds;
+use rustc_hir::limit::Limit;
 use rustc_parse::parser::{
     AttemptLocalParseRecovery, CommaRecoveryMode, ForceCollect, Parser, RecoverColon, RecoverComma,
     token_descr,
 };
+use rustc_session::Session;
 use rustc_session::lint::BuiltinLintDiag;
 use rustc_session::lint::builtin::{UNUSED_ATTRIBUTES, UNUSED_DOC_COMMENTS};
 use rustc_session::parse::feature_err;
-use rustc_session::{Limit, Session};
 use rustc_span::hygiene::SyntaxContext;
 use rustc_span::{ErrorGuaranteed, FileName, Ident, LocalExpnId, Span, Symbol, sym};
 use smallvec::SmallVec;
@@ -2529,6 +2530,7 @@ impl ExpansionConfig<'_> {
         ExpansionConfig {
             crate_name,
             features,
+            // FIXME should this limit be configurable?
             recursion_limit: Limit::new(1024),
             trace_mac: false,
             should_test: false,
diff --git a/compiler/rustc_hir/src/attrs/data_structures.rs b/compiler/rustc_hir/src/attrs/data_structures.rs
index c4e068ad42577..b4c1b61b9b586 100644
--- a/compiler/rustc_hir/src/attrs/data_structures.rs
+++ b/compiler/rustc_hir/src/attrs/data_structures.rs
@@ -14,6 +14,7 @@ pub use rustc_target::spec::SanitizerSet;
 use thin_vec::ThinVec;
 
 use crate::attrs::pretty_printing::PrintAttribute;
+use crate::limit::Limit;
 use crate::{DefaultBodyStability, PartialConstStability, RustcVersion, Stability};
 
 #[derive(Copy, Clone, PartialEq, Encodable, Decodable, Debug, HashStable_Generic, PrintAttribute)]
@@ -566,7 +567,7 @@ pub enum AttributeKind {
     MayDangle(Span),
 
     /// Represents `#[move_size_limit]`
-    MoveSizeLimit { attr_span: Span, limit_span: Span, limit: usize },
+    MoveSizeLimit { attr_span: Span, limit_span: Span, limit: Limit },
 
     /// Represents `#[must_use]`.
     MustUse {
@@ -600,7 +601,7 @@ pub enum AttributeKind {
     Path(Symbol, Span),
 
     /// Represents `#[pattern_complexity_limit]`
-    PatternComplexityLimit { attr_span: Span, limit_span: Span, limit: usize },
+    PatternComplexityLimit { attr_span: Span, limit_span: Span, limit: Limit },
 
     /// Represents `#[pointee]`
     Pointee(Span),
@@ -618,7 +619,7 @@ pub enum AttributeKind {
     PubTransparent(Span),
 
     /// Represents [`#[recursion_limit]`](https://doc.rust-lang.org/reference/attributes/limits.html#the-recursion_limit-attribute)
-    RecursionLimit { attr_span: Span, limit_span: Span, limit: usize },
+    RecursionLimit { attr_span: Span, limit_span: Span, limit: Limit },
 
     /// Represents [`#[repr]`](https://doc.rust-lang.org/stable/reference/type-layout.html#representations).
     Repr { reprs: ThinVec<(ReprAttr, Span)>, first_span: Span },
@@ -671,7 +672,7 @@ pub enum AttributeKind {
     TypeConst(Span),
 
     /// Represents `#[type_length_limit]`
-    TypeLengthLimit { attr_span: Span, limit_span: Span, limit: usize },
+    TypeLengthLimit { attr_span: Span, limit_span: Span, limit: Limit },
 
     /// Represents `#[rustc_unsafe_specialization_marker]`.
     UnsafeSpecializationMarker(Span),
diff --git a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
index 89ba1e0d7de45..0e208be3497ae 100644
--- a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
+++ b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
@@ -92,7 +92,7 @@ impl AttributeKind {
             TargetFeature { .. } => No,
             TrackCaller(..) => Yes,
             TypeConst(..) => Yes,
-            TypeLengthLimit { .. } => Yes,
+            TypeLengthLimit { .. } => No,
             UnsafeSpecializationMarker(..) => No,
             UnstableFeatureBound(..) => No,
             Used { .. } => No,
diff --git a/compiler/rustc_hir/src/attrs/pretty_printing.rs b/compiler/rustc_hir/src/attrs/pretty_printing.rs
index a4c2beb689dcc..d13cd3fd1dab0 100644
--- a/compiler/rustc_hir/src/attrs/pretty_printing.rs
+++ b/compiler/rustc_hir/src/attrs/pretty_printing.rs
@@ -9,6 +9,8 @@ use rustc_span::{ErrorGuaranteed, Ident, Span, Symbol};
 use rustc_target::spec::SanitizerSet;
 use thin_vec::ThinVec;
 
+use crate::limit::Limit;
+
 /// This trait is used to print attributes in `rustc_hir_pretty`.
 ///
 /// For structs and enums it can be derived using [`rustc_macros::PrintAttribute`].
@@ -146,7 +148,7 @@ macro_rules! print_tup {
 
 print_tup!(A B C D E F G H);
 print_skip!(Span, (), ErrorGuaranteed);
-print_disp!(u16, bool, NonZero<u32>, usize);
+print_disp!(u16, bool, NonZero<u32>, Limit);
 print_debug!(
     Symbol,
     Ident,
diff --git a/compiler/rustc_hir/src/lib.rs b/compiler/rustc_hir/src/lib.rs
index 78fc63753a2e4..eb630fc801863 100644
--- a/compiler/rustc_hir/src/lib.rs
+++ b/compiler/rustc_hir/src/lib.rs
@@ -25,6 +25,7 @@ mod hir;
 pub use rustc_hir_id::{self as hir_id, *};
 pub mod intravisit;
 pub mod lang_items;
+pub mod limit;
 pub mod lints;
 pub mod pat_util;
 mod stability;
diff --git a/compiler/rustc_hir/src/limit.rs b/compiler/rustc_hir/src/limit.rs
new file mode 100644
index 0000000000000..7e6d23f51bdb9
--- /dev/null
+++ b/compiler/rustc_hir/src/limit.rs
@@ -0,0 +1,63 @@
+use std::fmt;
+use std::ops::{Div, Mul};
+
+use rustc_error_messages::{DiagArgValue, IntoDiagArg};
+use rustc_macros::{Decodable, Encodable, HashStable_Generic};
+
+/// New-type wrapper around `usize` for representing limits. Ensures that comparisons against
+/// limits are consistent throughout the compiler.
+#[derive(Clone, Copy, Debug, HashStable_Generic, Encodable, Decodable)]
+pub struct Limit(pub usize);
+
+impl Limit {
+    /// Create a new limit from a `usize`.
+    pub fn new(value: usize) -> Self {
+        Limit(value)
+    }
+
+    /// Create a new unlimited limit.
+    pub fn unlimited() -> Self {
+        Limit(usize::MAX)
+    }
+
+    /// Check that `value` is within the limit. Ensures that the same comparisons are used
+    /// throughout the compiler, as mismatches can cause ICEs, see #72540.
+    #[inline]
+    pub fn value_within_limit(&self, value: usize) -> bool {
+        value <= self.0
+    }
+}
+
+impl From<usize> for Limit {
+    fn from(value: usize) -> Self {
+        Self::new(value)
+    }
+}
+
+impl fmt::Display for Limit {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl Div<usize> for Limit {
+    type Output = Limit;
+
+    fn div(self, rhs: usize) -> Self::Output {
+        Limit::new(self.0 / rhs)
+    }
+}
+
+impl Mul<usize> for Limit {
+    type Output = Limit;
+
+    fn mul(self, rhs: usize) -> Self::Output {
+        Limit::new(self.0 * rhs)
+    }
+}
+
+impl IntoDiagArg for Limit {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
+        self.to_string().into_diag_arg(&mut None)
+    }
+}
diff --git a/compiler/rustc_hir_analysis/src/autoderef.rs b/compiler/rustc_hir_analysis/src/autoderef.rs
index e27e68d36624e..e8237471e1b68 100644
--- a/compiler/rustc_hir_analysis/src/autoderef.rs
+++ b/compiler/rustc_hir_analysis/src/autoderef.rs
@@ -1,7 +1,7 @@
+use rustc_hir::limit::Limit;
 use rustc_infer::infer::InferCtxt;
 use rustc_infer::traits::PredicateObligations;
 use rustc_middle::ty::{self, Ty, TyCtxt, TypeVisitableExt};
-use rustc_session::Limit;
 use rustc_span::def_id::{LOCAL_CRATE, LocalDefId};
 use rustc_span::{ErrorGuaranteed, Span};
 use rustc_trait_selection::traits::ObligationCtxt;
diff --git a/compiler/rustc_hir_analysis/src/errors.rs b/compiler/rustc_hir_analysis/src/errors.rs
index 6565ad7cf5367..3b6367219b7ff 100644
--- a/compiler/rustc_hir_analysis/src/errors.rs
+++ b/compiler/rustc_hir_analysis/src/errors.rs
@@ -6,6 +6,7 @@ use rustc_errors::{
     Applicability, Diag, DiagCtxtHandle, DiagSymbolList, Diagnostic, EmissionGuarantee, Level,
     MultiSpan,
 };
+use rustc_hir::limit::Limit;
 use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
 use rustc_middle::ty::Ty;
 use rustc_span::{Ident, Span, Symbol};
@@ -557,7 +558,7 @@ pub(crate) struct AutoDerefReachedRecursionLimit<'a> {
     #[label]
     pub span: Span,
     pub ty: Ty<'a>,
-    pub suggested_limit: rustc_session::Limit,
+    pub suggested_limit: Limit,
     pub crate_name: Symbol,
 }
 
diff --git a/compiler/rustc_interface/messages.ftl b/compiler/rustc_interface/messages.ftl
index 4b9c71d71725c..d83b18cbc2df6 100644
--- a/compiler/rustc_interface/messages.ftl
+++ b/compiler/rustc_interface/messages.ftl
@@ -30,10 +30,6 @@ interface_ignoring_out_dir = ignoring --out-dir flag due to -o flag
 interface_input_file_would_be_overwritten =
     the input file "{$path}" would be overwritten by the generated executable
 
-interface_limit_invalid =
-    `limit` must be a non-negative integer
-    .label = {$error_str}
-
 interface_mixed_bin_crate =
     cannot mix `bin` crate type with others
 
diff --git a/compiler/rustc_interface/src/errors.rs b/compiler/rustc_interface/src/errors.rs
index 6b39b4f18911c..d1082eaf6173c 100644
--- a/compiler/rustc_interface/src/errors.rs
+++ b/compiler/rustc_interface/src/errors.rs
@@ -108,13 +108,3 @@ pub(crate) struct AbiRequiredTargetFeature<'a> {
     pub feature: &'a str,
     pub enabled: &'a str,
 }
-
-#[derive(Diagnostic)]
-#[diag(interface_limit_invalid)]
-pub(crate) struct LimitInvalid<'a> {
-    #[primary_span]
-    pub span: Span,
-    #[label]
-    pub value_span: Span,
-    pub error_str: &'a str,
-}
diff --git a/compiler/rustc_interface/src/limits.rs b/compiler/rustc_interface/src/limits.rs
index 8f01edec09f33..10e58f32256f1 100644
--- a/compiler/rustc_interface/src/limits.rs
+++ b/compiler/rustc_interface/src/limits.rs
@@ -8,78 +8,32 @@
 //! Users can override these limits via an attribute on the crate like
 //! `#![recursion_limit="22"]`. This pass just looks for those attributes.
 
-use std::num::IntErrorKind;
-
-use rustc_ast::attr::AttributeExt;
-use rustc_middle::bug;
+use rustc_hir::attrs::AttributeKind;
+use rustc_hir::limit::Limit;
+use rustc_hir::{Attribute, find_attr};
 use rustc_middle::query::Providers;
-use rustc_session::{Limit, Limits, Session};
-use rustc_span::{Symbol, sym};
-
-use crate::errors::LimitInvalid;
+use rustc_session::Limits;
 
 pub(crate) fn provide(providers: &mut Providers) {
-    providers.limits = |tcx, ()| Limits {
-        recursion_limit: get_recursion_limit(tcx.hir_krate_attrs(), tcx.sess),
-        move_size_limit: get_limit(
-            tcx.hir_krate_attrs(),
-            tcx.sess,
-            sym::move_size_limit,
-            Limit::new(tcx.sess.opts.unstable_opts.move_size_limit.unwrap_or(0)),
-        ),
-        type_length_limit: get_limit(
-            tcx.hir_krate_attrs(),
-            tcx.sess,
-            sym::type_length_limit,
-            Limit::new(2usize.pow(24)),
-        ),
-        pattern_complexity_limit: get_limit(
-            tcx.hir_krate_attrs(),
-            tcx.sess,
-            sym::pattern_complexity_limit,
-            Limit::unlimited(),
-        ),
+    providers.limits = |tcx, ()| {
+        let attrs = tcx.hir_krate_attrs();
+        Limits {
+            recursion_limit: get_recursion_limit(tcx.hir_krate_attrs()),
+            move_size_limit:
+                find_attr!(attrs, AttributeKind::MoveSizeLimit { limit, .. } => *limit)
+                    .unwrap_or(Limit::new(tcx.sess.opts.unstable_opts.move_size_limit.unwrap_or(0))),
+            type_length_limit:
+                find_attr!(attrs, AttributeKind::TypeLengthLimit { limit, .. } => *limit)
+                    .unwrap_or(Limit::new(2usize.pow(24))),
+            pattern_complexity_limit:
+                find_attr!(attrs, AttributeKind::PatternComplexityLimit { limit, .. } => *limit)
+                    .unwrap_or(Limit::unlimited()),
+        }
     }
 }
 
 // This one is separate because it must be read prior to macro expansion.
-pub(crate) fn get_recursion_limit(krate_attrs: &[impl AttributeExt], sess: &Session) -> Limit {
-    get_limit(krate_attrs, sess, sym::recursion_limit, Limit::new(128))
-}
-
-fn get_limit(
-    krate_attrs: &[impl AttributeExt],
-    sess: &Session,
-    name: Symbol,
-    default: Limit,
-) -> Limit {
-    for attr in krate_attrs {
-        if !attr.has_name(name) {
-            continue;
-        }
-
-        if let Some(sym) = attr.value_str() {
-            match sym.as_str().parse() {
-                Ok(n) => return Limit::new(n),
-                Err(e) => {
-                    let error_str = match e.kind() {
-                        IntErrorKind::PosOverflow => "`limit` is too large",
-                        IntErrorKind::Empty => "`limit` must be a non-negative integer",
-                        IntErrorKind::InvalidDigit => "not a valid integer",
-                        IntErrorKind::NegOverflow => {
-                            bug!("`limit` should never negatively overflow")
-                        }
-                        IntErrorKind::Zero => bug!("zero is a valid `limit`"),
-                        kind => bug!("unimplemented IntErrorKind variant: {:?}", kind),
-                    };
-                    sess.dcx().emit_err(LimitInvalid {
-                        span: attr.span(),
-                        value_span: attr.value_span().unwrap(),
-                        error_str,
-                    });
-                }
-            }
-        }
-    }
-    default
+pub(crate) fn get_recursion_limit(attrs: &[Attribute]) -> Limit {
+    find_attr!(attrs, AttributeKind::RecursionLimit { limit, .. } => *limit)
+        .unwrap_or(Limit::new(128))
 }
diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs
index ca8c10311fb8f..6d9751d7d4d61 100644
--- a/compiler/rustc_interface/src/passes.rs
+++ b/compiler/rustc_interface/src/passes.rs
@@ -6,7 +6,7 @@ use std::sync::{Arc, LazyLock, OnceLock};
 use std::{env, fs, iter};
 
 use rustc_ast as ast;
-use rustc_attr_parsing::{AttributeParser, ShouldEmit, validate_attr};
+use rustc_attr_parsing::{AttributeParser, ShouldEmit};
 use rustc_codegen_ssa::traits::CodegenBackend;
 use rustc_data_structures::jobserver::Proxy;
 use rustc_data_structures::steal::Steal;
@@ -19,6 +19,7 @@ use rustc_fs_util::try_canonicalize;
 use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def_id::{LOCAL_CRATE, StableCrateId, StableCrateIdMap};
 use rustc_hir::definitions::Definitions;
+use rustc_hir::limit::Limit;
 use rustc_incremental::setup_dep_graph;
 use rustc_lint::{BufferedEarlyLint, EarlyCheckNode, LintStore, unerased_lint_store};
 use rustc_metadata::EncodedMetadata;
@@ -30,12 +31,12 @@ use rustc_middle::util::Providers;
 use rustc_parse::{new_parser_from_file, new_parser_from_source_str, unwrap_or_emit_fatal};
 use rustc_passes::{abi_test, input_stats, layout_test};
 use rustc_resolve::{Resolver, ResolverOutputs};
+use rustc_session::Session;
 use rustc_session::config::{CrateType, Input, OutFileName, OutputFilenames, OutputType};
 use rustc_session::cstore::Untracked;
 use rustc_session::output::{collect_crate_types, filename_for_input};
 use rustc_session::parse::feature_err;
 use rustc_session::search_paths::PathKind;
-use rustc_session::{Limit, Session};
 use rustc_span::{
     DUMMY_SP, ErrorGuaranteed, ExpnKind, FileName, SourceFileHash, SourceFileHashAlgorithm, Span,
     Symbol, sym,
@@ -1246,7 +1247,8 @@ pub fn get_crate_name(sess: &Session, krate_attrs: &[ast::Attribute]) -> Symbol
     // in all code paths that require the crate name very early on, namely before
     // macro expansion.
 
-    let attr_crate_name = parse_crate_name(sess, krate_attrs, ShouldEmit::EarlyFatal);
+    let attr_crate_name =
+        parse_crate_name(sess, krate_attrs, ShouldEmit::EarlyFatal { also_emit_lints: true });
 
     let validate = |name, span| {
         rustc_session::output::validate_crate_name(sess, name, span);
@@ -1307,36 +1309,18 @@ pub(crate) fn parse_crate_name(
 }
 
 fn get_recursion_limit(krate_attrs: &[ast::Attribute], sess: &Session) -> Limit {
-    // We don't permit macro calls inside of the attribute (e.g., #![recursion_limit = `expand!()`])
-    // because that would require expanding this while in the middle of expansion, which needs to
-    // know the limit before expanding.
-    let _ = validate_and_find_value_str_builtin_attr(sym::recursion_limit, sess, krate_attrs);
-    crate::limits::get_recursion_limit(krate_attrs, sess)
-}
-
-/// Validate *all* occurrences of the given "[value-str]" built-in attribute and return the first find.
-///
-/// This validator is intended for built-in attributes whose value needs to be known very early
-/// during compilation (namely, before macro expansion) and it mainly exists to reject macro calls
-/// inside of the attributes, such as in `#![name = expand!()]`. Normal attribute validation happens
-/// during semantic analysis via [`TyCtxt::check_mod_attrs`] which happens *after* macro expansion
-/// when such macro calls (here: `expand`) have already been expanded and we can no longer check for
-/// their presence.
-///
-/// [value-str]: ast::Attribute::value_str
-fn validate_and_find_value_str_builtin_attr(
-    name: Symbol,
-    sess: &Session,
-    krate_attrs: &[ast::Attribute],
-) -> Option<(Symbol, Span)> {
-    let mut result = None;
-    // Validate *all* relevant attributes, not just the first occurrence.
-    for attr in ast::attr::filter_by_name(krate_attrs, name) {
-        let Some(value) = attr.value_str() else {
-            validate_attr::emit_fatal_malformed_builtin_attribute(&sess.psess, attr, name)
-        };
-        // Choose the first occurrence as our result.
-        result.get_or_insert((value, attr.span));
-    }
-    result
+    let attr = AttributeParser::parse_limited_should_emit(
+        sess,
+        &krate_attrs,
+        sym::recursion_limit,
+        DUMMY_SP,
+        rustc_ast::node_id::CRATE_NODE_ID,
+        None,
+        // errors are fatal here, but lints aren't.
+        // If things aren't fatal we continue, and will parse this again.
+        // That makes the same lint trigger again.
+        // So, no lints here to avoid duplicates.
+        ShouldEmit::EarlyFatal { also_emit_lints: false },
+    );
+    crate::limits::get_recursion_limit(attr.as_slice())
 }
diff --git a/compiler/rustc_middle/src/error.rs b/compiler/rustc_middle/src/error.rs
index 7520bc262c6bc..dad402ec69616 100644
--- a/compiler/rustc_middle/src/error.rs
+++ b/compiler/rustc_middle/src/error.rs
@@ -72,7 +72,7 @@ pub enum TypeMismatchReason {
 #[help]
 pub(crate) struct RecursionLimitReached<'tcx> {
     pub ty: Ty<'tcx>,
-    pub suggested_limit: rustc_session::Limit,
+    pub suggested_limit: rustc_hir::limit::Limit,
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index de6fa4c344e69..218ac2cfbc19d 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -38,6 +38,7 @@ use rustc_hir::def_id::{CrateNum, DefId, LOCAL_CRATE, LocalDefId};
 use rustc_hir::definitions::{DefPathData, Definitions, DisambiguatorState};
 use rustc_hir::intravisit::VisitorExt;
 use rustc_hir::lang_items::LangItem;
+use rustc_hir::limit::Limit;
 use rustc_hir::{self as hir, Attribute, HirId, Node, TraitCandidate, find_attr};
 use rustc_index::IndexVec;
 use rustc_macros::{HashStable, TyDecodable, TyEncodable};
@@ -45,10 +46,10 @@ use rustc_query_system::cache::WithDepNode;
 use rustc_query_system::dep_graph::DepNodeIndex;
 use rustc_query_system::ich::StableHashingContext;
 use rustc_serialize::opaque::{FileEncodeResult, FileEncoder};
+use rustc_session::Session;
 use rustc_session::config::CrateType;
 use rustc_session::cstore::{CrateStoreDyn, Untracked};
 use rustc_session::lint::Lint;
-use rustc_session::{Limit, Session};
 use rustc_span::def_id::{CRATE_DEF_ID, DefPathHash, StableCrateId};
 use rustc_span::{DUMMY_SP, Ident, Span, Symbol, kw, sym};
 use rustc_type_ir::TyKind::*;
diff --git a/compiler/rustc_middle/src/ty/error.rs b/compiler/rustc_middle/src/ty/error.rs
index 3f854038651aa..66542525d2841 100644
--- a/compiler/rustc_middle/src/ty/error.rs
+++ b/compiler/rustc_middle/src/ty/error.rs
@@ -7,6 +7,7 @@ use std::path::PathBuf;
 use rustc_errors::pluralize;
 use rustc_hir as hir;
 use rustc_hir::def::{CtorOf, DefKind};
+use rustc_hir::limit::Limit;
 use rustc_macros::extension;
 pub use rustc_type_ir::error::ExpectedFound;
 
@@ -233,7 +234,7 @@ impl<'tcx> TyCtxt<'tcx> {
         loop {
             // Look for the longest properly trimmed path that still fits in length_limit.
             short = with_forced_trimmed_paths!({
-                let mut p = FmtPrinter::new_with_limit(self, ns, rustc_session::Limit(type_limit));
+                let mut p = FmtPrinter::new_with_limit(self, ns, Limit(type_limit));
                 self.lift(t)
                     .expect("could not lift for printing")
                     .print(&mut p)
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index 74caee7336a5f..8101cabccdd02 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -13,8 +13,8 @@ use rustc_hir::LangItem;
 use rustc_hir::def::{self, CtorKind, DefKind, Namespace};
 use rustc_hir::def_id::{DefIdMap, DefIdSet, LOCAL_CRATE, ModDefId};
 use rustc_hir::definitions::{DefKey, DefPathDataName};
+use rustc_hir::limit::Limit;
 use rustc_macros::{Lift, extension};
-use rustc_session::Limit;
 use rustc_session::cstore::{ExternCrate, ExternCrateSource};
 use rustc_span::{FileNameDisplayPreference, Ident, Symbol, kw, sym};
 use rustc_type_ir::{Upcast as _, elaborate};
diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs
index a7d07adf78f02..b8c99e83a8f95 100644
--- a/compiler/rustc_middle/src/ty/util.rs
+++ b/compiler/rustc_middle/src/ty/util.rs
@@ -12,9 +12,9 @@ use rustc_hashes::Hash128;
 use rustc_hir as hir;
 use rustc_hir::def::{CtorOf, DefKind, Res};
 use rustc_hir::def_id::{CrateNum, DefId, LocalDefId};
+use rustc_hir::limit::Limit;
 use rustc_index::bit_set::GrowableBitSet;
 use rustc_macros::{HashStable, TyDecodable, TyEncodable, extension};
-use rustc_session::Limit;
 use rustc_span::sym;
 use rustc_type_ir::solve::SizedTraitKind;
 use smallvec::{SmallVec, smallvec};
diff --git a/compiler/rustc_mir_transform/src/inline/cycle.rs b/compiler/rustc_mir_transform/src/inline/cycle.rs
index 7f9234d1dc891..25a9baffe582d 100644
--- a/compiler/rustc_mir_transform/src/inline/cycle.rs
+++ b/compiler/rustc_mir_transform/src/inline/cycle.rs
@@ -2,9 +2,9 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexSet};
 use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_data_structures::unord::UnordSet;
 use rustc_hir::def_id::{DefId, LocalDefId};
+use rustc_hir::limit::Limit;
 use rustc_middle::mir::TerminatorKind;
 use rustc_middle::ty::{self, GenericArgsRef, InstanceKind, TyCtxt, TypeVisitableExt};
-use rustc_session::Limit;
 use rustc_span::sym;
 use tracing::{instrument, trace};
 
diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs
index cffeb6f980755..3169f2d4e1a44 100644
--- a/compiler/rustc_monomorphize/src/collector.rs
+++ b/compiler/rustc_monomorphize/src/collector.rs
@@ -217,6 +217,7 @@ use rustc_hir::attrs::InlineAttr;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, DefIdMap, LocalDefId};
 use rustc_hir::lang_items::LangItem;
+use rustc_hir::limit::Limit;
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use rustc_middle::mir::interpret::{AllocId, ErrorHandled, GlobalAlloc, Scalar};
 use rustc_middle::mir::mono::{CollectionMode, InstantiationMode, MonoItem};
@@ -231,7 +232,6 @@ use rustc_middle::ty::{
 };
 use rustc_middle::util::Providers;
 use rustc_middle::{bug, span_bug};
-use rustc_session::Limit;
 use rustc_session::config::{DebugInfo, EntryFnType};
 use rustc_span::source_map::{Spanned, dummy_spanned, respan};
 use rustc_span::{DUMMY_SP, Span};
diff --git a/compiler/rustc_monomorphize/src/mono_checks/move_check.rs b/compiler/rustc_monomorphize/src/mono_checks/move_check.rs
index 7251ef478c6f1..0adf1b089b53e 100644
--- a/compiler/rustc_monomorphize/src/mono_checks/move_check.rs
+++ b/compiler/rustc_monomorphize/src/mono_checks/move_check.rs
@@ -1,10 +1,10 @@
 use rustc_abi::Size;
 use rustc_data_structures::fx::FxIndexSet;
 use rustc_hir::def_id::DefId;
+use rustc_hir::limit::Limit;
 use rustc_middle::mir::visit::Visitor as MirVisitor;
 use rustc_middle::mir::{self, Location, traversal};
 use rustc_middle::ty::{self, AssocTag, Instance, Ty, TyCtxt, TypeFoldable};
-use rustc_session::Limit;
 use rustc_session::lint::builtin::LARGE_ASSIGNMENTS;
 use rustc_span::source_map::Spanned;
 use rustc_span::{Ident, Span, sym};
diff --git a/compiler/rustc_query_impl/Cargo.toml b/compiler/rustc_query_impl/Cargo.toml
index e5cceacf15da8..257785b10c8bc 100644
--- a/compiler/rustc_query_impl/Cargo.toml
+++ b/compiler/rustc_query_impl/Cargo.toml
@@ -13,7 +13,6 @@ rustc_index = { path = "../rustc_index" }
 rustc_middle = { path = "../rustc_middle" }
 rustc_query_system = { path = "../rustc_query_system" }
 rustc_serialize = { path = "../rustc_serialize" }
-rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs
index 55549cba737e6..4e601a6c59442 100644
--- a/compiler/rustc_query_impl/src/plumbing.rs
+++ b/compiler/rustc_query_impl/src/plumbing.rs
@@ -9,6 +9,7 @@ use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_data_structures::sync::{DynSend, DynSync};
 use rustc_data_structures::unord::UnordMap;
 use rustc_hashes::Hash64;
+use rustc_hir::limit::Limit;
 use rustc_index::Idx;
 use rustc_middle::bug;
 use rustc_middle::dep_graph::{
@@ -31,7 +32,6 @@ use rustc_query_system::query::{
 };
 use rustc_query_system::{QueryOverflow, QueryOverflowNote};
 use rustc_serialize::{Decodable, Encodable};
-use rustc_session::Limit;
 use rustc_span::def_id::LOCAL_CRATE;
 
 use crate::QueryConfigRestored;
diff --git a/compiler/rustc_query_system/src/error.rs b/compiler/rustc_query_system/src/error.rs
index 5108ecaeea3a1..2778b24e7741b 100644
--- a/compiler/rustc_query_system/src/error.rs
+++ b/compiler/rustc_query_system/src/error.rs
@@ -1,6 +1,6 @@
 use rustc_errors::codes::*;
+use rustc_hir::limit::Limit;
 use rustc_macros::{Diagnostic, Subdiagnostic};
-use rustc_session::Limit;
 use rustc_span::{Span, Symbol};
 
 #[derive(Subdiagnostic)]
diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
index 96767d054398c..3525c7c1d1a99 100644
--- a/compiler/rustc_session/src/session.rs
+++ b/compiler/rustc_session/src/session.rs
@@ -1,10 +1,9 @@
 use std::any::Any;
-use std::ops::{Div, Mul};
 use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use std::sync::Arc;
 use std::sync::atomic::AtomicBool;
-use std::{env, fmt, io};
+use std::{env, io};
 
 use rand::{RngCore, rng};
 use rustc_ast::NodeId;
@@ -25,6 +24,7 @@ use rustc_errors::{
     Diag, DiagCtxt, DiagCtxtHandle, DiagMessage, Diagnostic, ErrorGuaranteed, FatalAbort,
     LintEmitter, TerminalUrl, fallback_fluent_bundle,
 };
+use rustc_hir::limit::Limit;
 use rustc_macros::HashStable_Generic;
 pub use rustc_span::def_id::StableCrateId;
 use rustc_span::edition::Edition;
@@ -62,64 +62,6 @@ pub enum CtfeBacktrace {
     Immediate,
 }
 
-/// New-type wrapper around `usize` for representing limits. Ensures that comparisons against
-/// limits are consistent throughout the compiler.
-#[derive(Clone, Copy, Debug, HashStable_Generic)]
-pub struct Limit(pub usize);
-
-impl Limit {
-    /// Create a new limit from a `usize`.
-    pub fn new(value: usize) -> Self {
-        Limit(value)
-    }
-
-    /// Create a new unlimited limit.
-    pub fn unlimited() -> Self {
-        Limit(usize::MAX)
-    }
-
-    /// Check that `value` is within the limit. Ensures that the same comparisons are used
-    /// throughout the compiler, as mismatches can cause ICEs, see #72540.
-    #[inline]
-    pub fn value_within_limit(&self, value: usize) -> bool {
-        value <= self.0
-    }
-}
-
-impl From<usize> for Limit {
-    fn from(value: usize) -> Self {
-        Self::new(value)
-    }
-}
-
-impl fmt::Display for Limit {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-impl Div<usize> for Limit {
-    type Output = Limit;
-
-    fn div(self, rhs: usize) -> Self::Output {
-        Limit::new(self.0 / rhs)
-    }
-}
-
-impl Mul<usize> for Limit {
-    type Output = Limit;
-
-    fn mul(self, rhs: usize) -> Self::Output {
-        Limit::new(self.0 * rhs)
-    }
-}
-
-impl rustc_errors::IntoDiagArg for Limit {
-    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {
-        self.to_string().into_diag_arg(&mut None)
-    }
-}
-
 #[derive(Clone, Copy, Debug, HashStable_Generic)]
 pub struct Limits {
     /// The maximum recursion limit for potentially infinitely recursive
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/overflow.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/overflow.rs
index 4f1f5c330e5f4..a0876d8fe7599 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/overflow.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/overflow.rs
@@ -3,10 +3,10 @@ use std::fmt;
 use rustc_errors::{Diag, E0275, EmissionGuarantee, ErrorGuaranteed, struct_span_code_err};
 use rustc_hir::def::Namespace;
 use rustc_hir::def_id::LOCAL_CRATE;
+use rustc_hir::limit::Limit;
 use rustc_infer::traits::{Obligation, PredicateObligation};
 use rustc_middle::ty::print::{FmtPrinter, Print};
 use rustc_middle::ty::{self, TyCtxt, Upcast};
-use rustc_session::Limit;
 use rustc_span::Span;
 use tracing::debug;
 
@@ -67,7 +67,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 // We don't need to save the type to a file, we will be talking about this type already
                 // in a separate note when we explain the obligation, so it will be available that way.
                 let mut p: FmtPrinter<'_, '_> =
-                    FmtPrinter::new_with_limit(tcx, Namespace::TypeNS, rustc_session::Limit(6));
+                    FmtPrinter::new_with_limit(tcx, Namespace::TypeNS, Limit(6));
                 value.print(&mut p).unwrap();
                 p.into_buffer()
             } else {
diff --git a/compiler/rustc_ty_utils/src/needs_drop.rs b/compiler/rustc_ty_utils/src/needs_drop.rs
index 13d56889bd12a..0ef435b1a0e21 100644
--- a/compiler/rustc_ty_utils/src/needs_drop.rs
+++ b/compiler/rustc_ty_utils/src/needs_drop.rs
@@ -2,11 +2,11 @@
 
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::def_id::DefId;
+use rustc_hir::limit::Limit;
 use rustc_middle::bug;
 use rustc_middle::query::Providers;
 use rustc_middle::ty::util::{AlwaysRequiresDrop, needs_drop_components};
 use rustc_middle::ty::{self, EarlyBinder, GenericArgsRef, Ty, TyCtxt};
-use rustc_session::Limit;
 use rustc_span::sym;
 use tracing::{debug, instrument};
 
diff --git a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.rs b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.rs
index e5dae4c0069e1..c2653dd82a9f5 100644
--- a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.rs
+++ b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.rs
@@ -917,50 +917,50 @@ mod no_builtins {
 
 #[recursion_limit="0200"]
 //~^ WARN crate-level attribute should be an inner attribute
-//~| HELP add a `!`
 mod recursion_limit {
+    //~^ NOTE This attribute does not have an `!`, which means it is applied to this module
     mod inner { #![recursion_limit="0200"] }
-//~^ WARN crate-level attribute should be in the root module
+//~^ WARN the `#![recursion_limit]` attribute can only be used at the crate root
 
     #[recursion_limit="0200"] fn f() { }
     //~^ WARN crate-level attribute should be an inner attribute
-    //~| HELP add a `!`
+    //~| NOTE This attribute does not have an `!`, which means it is applied to this function
 
     #[recursion_limit="0200"] struct S;
     //~^ WARN crate-level attribute should be an inner attribute
-    //~| HELP add a `!`
+    //~| NOTE This attribute does not have an `!`, which means it is applied to this struct
 
     #[recursion_limit="0200"] type T = S;
     //~^ WARN crate-level attribute should be an inner attribute
-    //~| HELP add a `!`
+    //~| NOTE This attribute does not have an `!`, which means it is applied to this type alias
 
     #[recursion_limit="0200"] impl S { }
     //~^ WARN crate-level attribute should be an inner attribute
-    //~| HELP add a `!`
+    //~| NOTE This attribute does not have an `!`, which means it is applied to this implementation block
 }
 
 #[type_length_limit="0100"]
 //~^ WARN crate-level attribute should be an inner attribute
-//~| HELP add a `!`
 mod type_length_limit {
+    //~^ NOTE This attribute does not have an `!`, which means it is applied to this module
     mod inner { #![type_length_limit="0100"] }
-//~^ WARN crate-level attribute should be in the root module
+//~^ WARN the `#![type_length_limit]` attribute can only be used at the crate root
 
     #[type_length_limit="0100"] fn f() { }
     //~^ WARN crate-level attribute should be an inner attribute
-    //~| HELP add a `!`
+    //~| NOTE This attribute does not have an `!`, which means it is applied to this function
 
     #[type_length_limit="0100"] struct S;
     //~^ WARN crate-level attribute should be an inner attribute
-    //~| HELP add a `!`
+    //~| NOTE This attribute does not have an `!`, which means it is applied to this struct
 
     #[type_length_limit="0100"] type T = S;
     //~^ WARN crate-level attribute should be an inner attribute
-    //~| HELP add a `!`
+    //~| NOTE This attribute does not have an `!`, which means it is applied to this type alias
 
     #[type_length_limit="0100"] impl S { }
     //~^ WARN crate-level attribute should be an inner attribute
-    //~| HELP add a `!`
+    //~| NOTE This attribute does not have an `!`, which means it is applied to this implementation block
 }
 
 fn main() {}
diff --git a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr
index ef74a00e5a1cd..4a3520972bf56 100644
--- a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr
+++ b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr
@@ -291,28 +291,6 @@ help: add a `!`
 LL | #![no_builtins]
    |  +
 
-warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:918:1
-   |
-LL | #[recursion_limit="0200"]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: add a `!`
-   |
-LL | #![recursion_limit="0200"]
-   |  +
-
-warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:942:1
-   |
-LL | #[type_length_limit="0100"]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: add a `!`
-   |
-LL | #![type_length_limit="0100"]
-   |  +
-
 warning: attribute should be applied to an `extern` block with non-Rust ABI
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:72:1
    |
@@ -757,106 +735,6 @@ help: add a `!`
 LL |     #![no_builtins] impl S { }
    |      +
 
-warning: crate-level attribute should be in the root module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:922:17
-   |
-LL |     mod inner { #![recursion_limit="0200"] }
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:925:5
-   |
-LL |     #[recursion_limit="0200"] fn f() { }
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: add a `!`
-   |
-LL |     #![recursion_limit="0200"] fn f() { }
-   |      +
-
-warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:929:5
-   |
-LL |     #[recursion_limit="0200"] struct S;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: add a `!`
-   |
-LL |     #![recursion_limit="0200"] struct S;
-   |      +
-
-warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:933:5
-   |
-LL |     #[recursion_limit="0200"] type T = S;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: add a `!`
-   |
-LL |     #![recursion_limit="0200"] type T = S;
-   |      +
-
-warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:937:5
-   |
-LL |     #[recursion_limit="0200"] impl S { }
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: add a `!`
-   |
-LL |     #![recursion_limit="0200"] impl S { }
-   |      +
-
-warning: crate-level attribute should be in the root module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:946:17
-   |
-LL |     mod inner { #![type_length_limit="0100"] }
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:949:5
-   |
-LL |     #[type_length_limit="0100"] fn f() { }
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: add a `!`
-   |
-LL |     #![type_length_limit="0100"] fn f() { }
-   |      +
-
-warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:953:5
-   |
-LL |     #[type_length_limit="0100"] struct S;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: add a `!`
-   |
-LL |     #![type_length_limit="0100"] struct S;
-   |      +
-
-warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:957:5
-   |
-LL |     #[type_length_limit="0100"] type T = S;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: add a `!`
-   |
-LL |     #![type_length_limit="0100"] type T = S;
-   |      +
-
-warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:961:5
-   |
-LL |     #[type_length_limit="0100"] impl S { }
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: add a `!`
-   |
-LL |     #![type_length_limit="0100"] impl S { }
-   |      +
-
 warning: `#[macro_use]` attribute cannot be used on functions
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:191:5
    |
@@ -1476,6 +1354,146 @@ note: This attribute does not have an `!`, which means it is applied to this imp
 LL |     #[crate_name = "0900"] impl S { }
    |                            ^^^^^^^^^^
 
+warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![recursion_limit]`
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:918:1
+   |
+LL | #[recursion_limit="0200"]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: This attribute does not have an `!`, which means it is applied to this module
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:920:1
+   |
+LL | / mod recursion_limit {
+LL | |
+LL | |     mod inner { #![recursion_limit="0200"] }
+...  |
+LL | | }
+   | |_^
+
+warning: the `#![recursion_limit]` attribute can only be used at the crate root
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:922:17
+   |
+LL |     mod inner { #![recursion_limit="0200"] }
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![recursion_limit]`
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:925:5
+   |
+LL |     #[recursion_limit="0200"] fn f() { }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: This attribute does not have an `!`, which means it is applied to this function
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:925:31
+   |
+LL |     #[recursion_limit="0200"] fn f() { }
+   |                               ^^^^^^^^^^
+
+warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![recursion_limit]`
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:929:5
+   |
+LL |     #[recursion_limit="0200"] struct S;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: This attribute does not have an `!`, which means it is applied to this struct
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:929:31
+   |
+LL |     #[recursion_limit="0200"] struct S;
+   |                               ^^^^^^^^^
+
+warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![recursion_limit]`
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:933:5
+   |
+LL |     #[recursion_limit="0200"] type T = S;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: This attribute does not have an `!`, which means it is applied to this type alias
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:933:31
+   |
+LL |     #[recursion_limit="0200"] type T = S;
+   |                               ^^^^^^^^^^^
+
+warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![recursion_limit]`
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:937:5
+   |
+LL |     #[recursion_limit="0200"] impl S { }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: This attribute does not have an `!`, which means it is applied to this implementation block
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:937:31
+   |
+LL |     #[recursion_limit="0200"] impl S { }
+   |                               ^^^^^^^^^^
+
+warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![type_length_limit]`
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:942:1
+   |
+LL | #[type_length_limit="0100"]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: This attribute does not have an `!`, which means it is applied to this module
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:944:1
+   |
+LL | / mod type_length_limit {
+LL | |
+LL | |     mod inner { #![type_length_limit="0100"] }
+...  |
+LL | | }
+   | |_^
+
+warning: the `#![type_length_limit]` attribute can only be used at the crate root
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:946:17
+   |
+LL |     mod inner { #![type_length_limit="0100"] }
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![type_length_limit]`
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:949:5
+   |
+LL |     #[type_length_limit="0100"] fn f() { }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: This attribute does not have an `!`, which means it is applied to this function
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:949:33
+   |
+LL |     #[type_length_limit="0100"] fn f() { }
+   |                                 ^^^^^^^^^^
+
+warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![type_length_limit]`
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:953:5
+   |
+LL |     #[type_length_limit="0100"] struct S;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: This attribute does not have an `!`, which means it is applied to this struct
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:953:33
+   |
+LL |     #[type_length_limit="0100"] struct S;
+   |                                 ^^^^^^^^^
+
+warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![type_length_limit]`
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:957:5
+   |
+LL |     #[type_length_limit="0100"] type T = S;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: This attribute does not have an `!`, which means it is applied to this type alias
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:957:33
+   |
+LL |     #[type_length_limit="0100"] type T = S;
+   |                                 ^^^^^^^^^^^
+
+warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![type_length_limit]`
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:961:5
+   |
+LL |     #[type_length_limit="0100"] impl S { }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: This attribute does not have an `!`, which means it is applied to this implementation block
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:961:33
+   |
+LL |     #[type_length_limit="0100"] impl S { }
+   |                                 ^^^^^^^^^^
+
 warning: `#[should_panic]` attribute cannot be used on crates
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:50:1
    |
diff --git a/tests/ui/lint/unused/unused-attr-duplicate.stderr b/tests/ui/lint/unused/unused-attr-duplicate.stderr
index 203211d0d5620..076a08ac6f248 100644
--- a/tests/ui/lint/unused/unused-attr-duplicate.stderr
+++ b/tests/ui/lint/unused/unused-attr-duplicate.stderr
@@ -28,32 +28,6 @@ note: attribute also specified here
 LL | #[no_link]
    | ^^^^^^^^^^
 
-error: unused attribute
-  --> $DIR/unused-attr-duplicate.rs:21:1
-   |
-LL | #![recursion_limit = "256"]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute
-   |
-note: attribute also specified here
-  --> $DIR/unused-attr-duplicate.rs:20:1
-   |
-LL | #![recursion_limit = "128"]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-
-error: unused attribute
-  --> $DIR/unused-attr-duplicate.rs:24:1
-   |
-LL | #![type_length_limit = "1"]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute
-   |
-note: attribute also specified here
-  --> $DIR/unused-attr-duplicate.rs:23:1
-   |
-LL | #![type_length_limit = "1048576"]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-
 error: unused attribute
   --> $DIR/unused-attr-duplicate.rs:27:1
    |
@@ -304,6 +278,32 @@ LL | #![crate_name = "unused_attr_duplicate"]
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
+error: unused attribute
+  --> $DIR/unused-attr-duplicate.rs:21:1
+   |
+LL | #![recursion_limit = "256"]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute
+   |
+note: attribute also specified here
+  --> $DIR/unused-attr-duplicate.rs:20:1
+   |
+LL | #![recursion_limit = "128"]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+
+error: unused attribute
+  --> $DIR/unused-attr-duplicate.rs:24:1
+   |
+LL | #![type_length_limit = "1"]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute
+   |
+note: attribute also specified here
+  --> $DIR/unused-attr-duplicate.rs:23:1
+   |
+LL | #![type_length_limit = "1048576"]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+
 error: unused attribute
   --> $DIR/unused-attr-duplicate.rs:29:1
    |
diff --git a/tests/ui/lint/unused/unused-attr-macro-rules.stderr b/tests/ui/lint/unused/unused-attr-macro-rules.stderr
index af64be8f6e9bd..0c6825026ed3b 100644
--- a/tests/ui/lint/unused/unused-attr-macro-rules.stderr
+++ b/tests/ui/lint/unused/unused-attr-macro-rules.stderr
@@ -1,19 +1,3 @@
-error: crate-level attribute should be an inner attribute
-  --> $DIR/unused-attr-macro-rules.rs:11:1
-   |
-LL | #[recursion_limit="1"]
-   | ^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: the lint level is defined here
-  --> $DIR/unused-attr-macro-rules.rs:1:9
-   |
-LL | #![deny(unused_attributes)]
-   |         ^^^^^^^^^^^^^^^^^
-help: add a `!`
-   |
-LL | #![recursion_limit="1"]
-   |  +
-
 error: `#[macro_use]` attribute cannot be used on macro defs
   --> $DIR/unused-attr-macro-rules.rs:7:1
    |
@@ -22,6 +6,11 @@ LL | #[macro_use]
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = help: `#[macro_use]` can be applied to modules, extern crates, and crates
+note: the lint level is defined here
+  --> $DIR/unused-attr-macro-rules.rs:1:9
+   |
+LL | #![deny(unused_attributes)]
+   |         ^^^^^^^^^^^^^^^^^
 
 error: `#[path]` attribute cannot be used on macro defs
   --> $DIR/unused-attr-macro-rules.rs:9:1
@@ -32,5 +21,19 @@ LL | #[path="foo"]
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = help: `#[path]` can only be applied to modules
 
+error: crate-level attribute should be an inner attribute: add an exclamation mark: `#![recursion_limit]`
+  --> $DIR/unused-attr-macro-rules.rs:11:1
+   |
+LL | #[recursion_limit="1"]
+   | ^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: This attribute does not have an `!`, which means it is applied to this macro def
+  --> $DIR/unused-attr-macro-rules.rs:12:1
+   |
+LL | / macro_rules! foo {
+LL | |     () => {};
+LL | | }
+   | |_^
+
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/recursion_limit/empty.rs b/tests/ui/recursion_limit/empty.rs
index 5987fa2f881c2..a901267d847c7 100644
--- a/tests/ui/recursion_limit/empty.rs
+++ b/tests/ui/recursion_limit/empty.rs
@@ -1,9 +1,7 @@
 // Test the parse error for an empty recursion_limit
 
-#![recursion_limit = ""] //~ ERROR `limit` must be a non-negative integer
-                         //~| NOTE `limit` must be a non-negative integer
-                         //~| ERROR `limit` must be a non-negative integer
-                         //~| NOTE `limit` must be a non-negative integer
-                         //~| NOTE duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+#![recursion_limit = ""]
+//~^ ERROR `limit` must be a non-negative integer
+//~| NOTE `limit` must be a non-negative integer
 
 fn main() {}
diff --git a/tests/ui/recursion_limit/empty.stderr b/tests/ui/recursion_limit/empty.stderr
index 2f73067750706..9afe9e6db565d 100644
--- a/tests/ui/recursion_limit/empty.stderr
+++ b/tests/ui/recursion_limit/empty.stderr
@@ -6,15 +6,5 @@ LL | #![recursion_limit = ""]
    |                      |
    |                      `limit` must be a non-negative integer
 
-error: `limit` must be a non-negative integer
-  --> $DIR/empty.rs:3:1
-   |
-LL | #![recursion_limit = ""]
-   | ^^^^^^^^^^^^^^^^^^^^^--^
-   |                      |
-   |                      `limit` must be a non-negative integer
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/recursion_limit/invalid_digit.rs b/tests/ui/recursion_limit/invalid_digit.rs
index 79d8f3708bac6..1d0e6a18227ce 100644
--- a/tests/ui/recursion_limit/invalid_digit.rs
+++ b/tests/ui/recursion_limit/invalid_digit.rs
@@ -1,8 +1,6 @@
 // Test the parse error for an invalid digit in recursion_limit
 
-#![recursion_limit = "-100"] //~ ERROR `limit` must be a non-negative integer
-                             //~| NOTE not a valid integer
-                             //~| ERROR `limit` must be a non-negative integer
-                             //~| NOTE not a valid integer
-                             //~| NOTE duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+#![recursion_limit = "-100"]
+//~^ ERROR `limit` must be a non-negative integer
+//~| NOTE not a valid integer
 fn main() {}
diff --git a/tests/ui/recursion_limit/invalid_digit.stderr b/tests/ui/recursion_limit/invalid_digit.stderr
index 4fda3039032a8..9c2d1422df28e 100644
--- a/tests/ui/recursion_limit/invalid_digit.stderr
+++ b/tests/ui/recursion_limit/invalid_digit.stderr
@@ -6,15 +6,5 @@ LL | #![recursion_limit = "-100"]
    |                      |
    |                      not a valid integer
 
-error: `limit` must be a non-negative integer
-  --> $DIR/invalid_digit.rs:3:1
-   |
-LL | #![recursion_limit = "-100"]
-   | ^^^^^^^^^^^^^^^^^^^^^------^
-   |                      |
-   |                      not a valid integer
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/recursion_limit/invalid_digit_type.stderr b/tests/ui/recursion_limit/invalid_digit_type.stderr
index a122262f1df45..489e8bd82c2d0 100644
--- a/tests/ui/recursion_limit/invalid_digit_type.stderr
+++ b/tests/ui/recursion_limit/invalid_digit_type.stderr
@@ -1,10 +1,14 @@
-error: malformed `recursion_limit` attribute input
+error[E0539]: malformed `recursion_limit` attribute input
   --> $DIR/invalid_digit_type.rs:1:1
    |
 LL | #![recursion_limit = 123]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#![recursion_limit = "N"]`
+   | ^^^^^^^^^^^^^^^^^^^^^---^
+   | |                    |
+   | |                    expected a string literal here
+   | help: must be of the form: `#![recursion_limit = "N"]`
    |
    = note: for more information, visit <https://doc.rust-lang.org/reference/attributes/limits.html#the-recursion_limit-attribute>
 
 error: aborting due to 1 previous error
 
+For more information about this error, try `rustc --explain E0539`.
diff --git a/tests/ui/recursion_limit/invalid_macro.rs b/tests/ui/recursion_limit/invalid_macro.rs
index 7db67a8d16284..eae348523dbc8 100644
--- a/tests/ui/recursion_limit/invalid_macro.rs
+++ b/tests/ui/recursion_limit/invalid_macro.rs
@@ -1,4 +1,4 @@
-#![recursion_limit = foo!()] //~ ERROR malformed `recursion_limit` attribute
+#![recursion_limit = foo!()] //~ ERROR attribute value must be a literal
 
 macro_rules! foo {
     () => {"128"};
diff --git a/tests/ui/recursion_limit/invalid_macro.stderr b/tests/ui/recursion_limit/invalid_macro.stderr
index b4dbc9fcb1346..de1df3e9a3586 100644
--- a/tests/ui/recursion_limit/invalid_macro.stderr
+++ b/tests/ui/recursion_limit/invalid_macro.stderr
@@ -1,10 +1,8 @@
-error: malformed `recursion_limit` attribute input
-  --> $DIR/invalid_macro.rs:1:1
+error: attribute value must be a literal
+  --> $DIR/invalid_macro.rs:1:22
    |
 LL | #![recursion_limit = foo!()]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#![recursion_limit = "N"]`
-   |
-   = note: for more information, visit <https://doc.rust-lang.org/reference/attributes/limits.html#the-recursion_limit-attribute>
+   |                      ^^^^^^
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/recursion_limit/no-value.stderr b/tests/ui/recursion_limit/no-value.stderr
index 4a0ad04f2715b..eafc50bafb49d 100644
--- a/tests/ui/recursion_limit/no-value.stderr
+++ b/tests/ui/recursion_limit/no-value.stderr
@@ -1,4 +1,4 @@
-error: malformed `recursion_limit` attribute input
+error[E0539]: malformed `recursion_limit` attribute input
   --> $DIR/no-value.rs:3:1
    |
 LL | #![recursion_limit]
@@ -8,3 +8,4 @@ LL | #![recursion_limit]
 
 error: aborting due to 1 previous error
 
+For more information about this error, try `rustc --explain E0539`.
diff --git a/tests/ui/recursion_limit/overflow.rs b/tests/ui/recursion_limit/overflow.rs
index 7cd1d572e0971..24cb8e286a895 100644
--- a/tests/ui/recursion_limit/overflow.rs
+++ b/tests/ui/recursion_limit/overflow.rs
@@ -3,8 +3,5 @@
 #![recursion_limit = "999999999999999999999999"]
 //~^ ERROR `limit` must be a non-negative integer
 //~| NOTE `limit` is too large
-//~| ERROR `limit` must be a non-negative integer
-//~| NOTE `limit` is too large
-//~| NOTE duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 fn main() {}
diff --git a/tests/ui/recursion_limit/overflow.stderr b/tests/ui/recursion_limit/overflow.stderr
index 6057177deb2f9..5a8548b7c7f1e 100644
--- a/tests/ui/recursion_limit/overflow.stderr
+++ b/tests/ui/recursion_limit/overflow.stderr
@@ -6,15 +6,5 @@ LL | #![recursion_limit = "999999999999999999999999"]
    |                      |
    |                      `limit` is too large
 
-error: `limit` must be a non-negative integer
-  --> $DIR/overflow.rs:3:1
-   |
-LL | #![recursion_limit = "999999999999999999999999"]
-   | ^^^^^^^^^^^^^^^^^^^^^--------------------------^
-   |                      |
-   |                      `limit` is too large
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 

From 8d0c07f1a1ccc46f58d2c6dbf0dbf32dc0b0d6b9 Mon Sep 17 00:00:00 2001
From: Jeremy Smart <jeremy3141592@gmail.com>
Date: Thu, 31 Jul 2025 23:27:02 -0400
Subject: [PATCH 0701/1889] change end to last

---
 compiler/rustc_ast_lowering/src/expr.rs       |  29 +++-
 compiler/rustc_hir/src/hir.rs                 |  15 +-
 compiler/rustc_hir/src/lang_items.rs          |   1 +
 compiler/rustc_index/src/idx.rs               |  15 ++
 compiler/rustc_span/src/symbol.rs             |   2 +
 library/core/src/range.rs                     | 140 +++++++++++++++---
 library/core/src/range/iter.rs                |   2 +-
 library/core/src/range/legacy.rs              |   4 +-
 library/core/src/slice/index.rs               |  41 +++++
 library/core/src/str/traits.rs                |   8 +-
 src/tools/clippy/clippy_utils/src/sym.rs      |   1 -
 .../std/const-generics-range.full.stderr      |   2 +-
 .../std/const-generics-range.min.stderr       |   2 +-
 .../std/const-generics-range.rs               |  14 +-
 tests/ui/iterators/ranges.stderr              |   6 +-
 tests/ui/new-range/disabled.rs                |   4 +-
 tests/ui/new-range/enabled.rs                 |   4 +-
 tests/ui/range/issue-54505-no-literals.stderr |   4 +-
 tests/ui/range/issue-54505-no-std.stderr      |   2 +-
 tests/ui/range/issue-54505.stderr             |   2 +-
 20 files changed, 245 insertions(+), 53 deletions(-)

diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index 3674814b796c2..bb6b25baf013d 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -1536,7 +1536,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     hir::LangItem::Range
                 }
             }
-            (None, Some(..), Closed) => hir::LangItem::RangeToInclusive,
+            (None, Some(..), Closed) => {
+                if self.tcx.features().new_range() {
+                    hir::LangItem::RangeToInclusiveCopy
+                } else {
+                    hir::LangItem::RangeToInclusive
+                }
+            }
             (Some(e1), Some(e2), Closed) => {
                 if self.tcx.features().new_range() {
                     hir::LangItem::RangeInclusiveCopy
@@ -1560,13 +1566,26 @@ impl<'hir> LoweringContext<'_, 'hir> {
         };
 
         let fields = self.arena.alloc_from_iter(
-            e1.iter().map(|e| (sym::start, e)).chain(e2.iter().map(|e| (sym::end, e))).map(
-                |(s, e)| {
+            e1.iter()
+                .map(|e| (sym::start, e))
+                .chain(e2.iter().map(|e| {
+                    (
+                        if matches!(
+                            lang_item,
+                            hir::LangItem::RangeInclusiveCopy | hir::LangItem::RangeToInclusiveCopy
+                        ) {
+                            sym::last
+                        } else {
+                            sym::end
+                        },
+                        e,
+                    )
+                }))
+                .map(|(s, e)| {
                     let expr = self.lower_expr(e);
                     let ident = Ident::new(s, self.lower_span(e.span));
                     self.expr_field(ident, expr, e.span)
-                },
-            ),
+                }),
         );
 
         hir::ExprKind::Struct(
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index ae03121e5f705..75551fe4c196a 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -2614,6 +2614,18 @@ impl Expr<'_> {
                     StructTailExpr::None,
                 ),
             )
+            | (
+                ExprKind::Struct(
+                    QPath::LangItem(LangItem::RangeToInclusiveCopy, _),
+                    [val1],
+                    StructTailExpr::None,
+                ),
+                ExprKind::Struct(
+                    QPath::LangItem(LangItem::RangeToInclusiveCopy, _),
+                    [val2],
+                    StructTailExpr::None,
+                ),
+            )
             | (
                 ExprKind::Struct(
                     QPath::LangItem(LangItem::RangeFrom, _),
@@ -2705,7 +2717,8 @@ pub fn is_range_literal(expr: &Expr<'_>) -> bool {
                     | LangItem::RangeToInclusive
                     | LangItem::RangeCopy
                     | LangItem::RangeFromCopy
-                    | LangItem::RangeInclusiveCopy,
+                    | LangItem::RangeInclusiveCopy
+                    | LangItem::RangeToInclusiveCopy,
                 ..
             )
         ),
diff --git a/compiler/rustc_hir/src/lang_items.rs b/compiler/rustc_hir/src/lang_items.rs
index 0464665b41fc5..67d2f15d41472 100644
--- a/compiler/rustc_hir/src/lang_items.rs
+++ b/compiler/rustc_hir/src/lang_items.rs
@@ -422,6 +422,7 @@ language_item_table! {
     RangeFromCopy,           sym::RangeFromCopy,       range_from_copy_struct,     Target::Struct,         GenericRequirement::None;
     RangeCopy,               sym::RangeCopy,           range_copy_struct,          Target::Struct,         GenericRequirement::None;
     RangeInclusiveCopy,      sym::RangeInclusiveCopy,  range_inclusive_copy_struct, Target::Struct,         GenericRequirement::None;
+    RangeToInclusiveCopy,    sym::RangeToInclusiveCopy,     range_to_inclusive_copy_struct, Target::Struct, GenericRequirement::None;
 
     String,                  sym::String,              string,                     Target::Struct,         GenericRequirement::None;
     CStr,                    sym::CStr,                c_str,                      Target::Struct,         GenericRequirement::None;
diff --git a/compiler/rustc_index/src/idx.rs b/compiler/rustc_index/src/idx.rs
index 33f406e21137d..9cd7134659c55 100644
--- a/compiler/rustc_index/src/idx.rs
+++ b/compiler/rustc_index/src/idx.rs
@@ -130,7 +130,22 @@ impl<I: Idx, T> IntoSliceIdx<I, [T]> for core::range::RangeFrom<I> {
 impl<I: Idx, T> IntoSliceIdx<I, [T]> for core::range::RangeInclusive<I> {
     type Output = core::range::RangeInclusive<usize>;
     #[inline]
+    #[cfg(bootstrap)]
     fn into_slice_idx(self) -> Self::Output {
         core::range::RangeInclusive { start: self.start.index(), end: self.end.index() }
     }
+    #[inline]
+    #[cfg(not(bootstrap))]
+    fn into_slice_idx(self) -> Self::Output {
+        core::range::RangeInclusive { start: self.start.index(), last: self.last.index() }
+    }
+}
+
+#[cfg(all(feature = "nightly", not(bootstrap)))]
+impl<I: Idx, T> IntoSliceIdx<I, [T]> for core::range::RangeToInclusive<I> {
+    type Output = core::range::RangeToInclusive<usize>;
+    #[inline]
+    fn into_slice_idx(self) -> Self::Output {
+        core::range::RangeToInclusive { last: self.last.index() }
+    }
 }
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 77260d07c9950..f6bb5be025f5e 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -326,6 +326,7 @@ symbols! {
         RangeSub,
         RangeTo,
         RangeToInclusive,
+        RangeToInclusiveCopy,
         Rc,
         RcWeak,
         Ready,
@@ -1280,6 +1281,7 @@ symbols! {
         lang,
         lang_items,
         large_assignments,
+        last,
         lateout,
         lazy_normalization_consts,
         lazy_type_alias,
diff --git a/library/core/src/range.rs b/library/core/src/range.rs
index 7158fa0fcf069..cca7f47d9b940 100644
--- a/library/core/src/range.rs
+++ b/library/core/src/range.rs
@@ -31,9 +31,7 @@ pub use iter::{IterRange, IterRangeFrom, IterRangeInclusive};
 #[doc(inline)]
 pub use crate::iter::Step;
 #[doc(inline)]
-pub use crate::ops::{
-    Bound, IntoBounds, OneSidedRange, RangeBounds, RangeFull, RangeTo, RangeToInclusive,
-};
+pub use crate::ops::{Bound, IntoBounds, OneSidedRange, RangeBounds, RangeFull, RangeTo};
 
 /// A (half-open) range bounded inclusively below and exclusively above
 /// (`start..end` in a future edition).
@@ -209,20 +207,20 @@ impl<T> const From<legacy::Range<T>> for Range<T> {
     }
 }
 
-/// A range bounded inclusively below and above (`start..=end`).
+/// A range bounded inclusively below and above (`start..=last`).
 ///
-/// The `RangeInclusive` `start..=end` contains all values with `x >= start`
-/// and `x <= end`. It is empty unless `start <= end`.
+/// The `RangeInclusive` `start..=last` contains all values with `x >= start`
+/// and `x <= last`. It is empty unless `start <= last`.
 ///
 /// # Examples
 ///
-/// The `start..=end` syntax is a `RangeInclusive`:
+/// The `start..=last` syntax is a `RangeInclusive`:
 ///
 /// ```
 /// #![feature(new_range_api)]
 /// use core::range::RangeInclusive;
 ///
-/// assert_eq!(RangeInclusive::from(3..=5), RangeInclusive { start: 3, end: 5 });
+/// assert_eq!(RangeInclusive::from(3..=5), RangeInclusive { start: 3, last: 5 });
 /// assert_eq!(3 + 4 + 5, RangeInclusive::from(3..=5).into_iter().sum());
 /// ```
 #[lang = "RangeInclusiveCopy"]
@@ -234,7 +232,7 @@ pub struct RangeInclusive<Idx> {
     pub start: Idx,
     /// The upper bound of the range (inclusive).
     #[unstable(feature = "new_range_api", issue = "125687")]
-    pub end: Idx,
+    pub last: Idx,
 }
 
 #[unstable(feature = "new_range_api", issue = "125687")]
@@ -242,7 +240,7 @@ impl<Idx: fmt::Debug> fmt::Debug for RangeInclusive<Idx> {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.start.fmt(fmt)?;
         write!(fmt, "..=")?;
-        self.end.fmt(fmt)?;
+        self.last.fmt(fmt)?;
         Ok(())
     }
 }
@@ -306,7 +304,7 @@ impl<Idx: PartialOrd<Idx>> RangeInclusive<Idx> {
     #[unstable(feature = "new_range_api", issue = "125687")]
     #[inline]
     pub fn is_empty(&self) -> bool {
-        !(self.start <= self.end)
+        !(self.start <= self.last)
     }
 }
 
@@ -335,10 +333,10 @@ impl<Idx: Step> RangeInclusive<Idx> {
 
 impl RangeInclusive<usize> {
     /// Converts to an exclusive `Range` for `SliceIndex` implementations.
-    /// The caller is responsible for dealing with `end == usize::MAX`.
+    /// The caller is responsible for dealing with `last == usize::MAX`.
     #[inline]
     pub(crate) const fn into_slice_range(self) -> Range<usize> {
-        Range { start: self.start, end: self.end + 1 }
+        Range { start: self.start, end: self.last + 1 }
     }
 }
 
@@ -348,7 +346,7 @@ impl<T> RangeBounds<T> for RangeInclusive<T> {
         Included(&self.start)
     }
     fn end_bound(&self) -> Bound<&T> {
-        Included(&self.end)
+        Included(&self.last)
     }
 }
 
@@ -364,7 +362,7 @@ impl<T> RangeBounds<T> for RangeInclusive<&T> {
         Included(self.start)
     }
     fn end_bound(&self) -> Bound<&T> {
-        Included(self.end)
+        Included(self.last)
     }
 }
 
@@ -372,7 +370,7 @@ impl<T> RangeBounds<T> for RangeInclusive<&T> {
 #[unstable(feature = "new_range_api", issue = "125687")]
 impl<T> IntoBounds<T> for RangeInclusive<T> {
     fn into_bounds(self) -> (Bound<T>, Bound<T>) {
-        (Included(self.start), Included(self.end))
+        (Included(self.start), Included(self.last))
     }
 }
 
@@ -381,7 +379,7 @@ impl<T> IntoBounds<T> for RangeInclusive<T> {
 impl<T> const From<RangeInclusive<T>> for legacy::RangeInclusive<T> {
     #[inline]
     fn from(value: RangeInclusive<T>) -> Self {
-        Self::new(value.start, value.end)
+        Self::new(value.start, value.last)
     }
 }
 #[unstable(feature = "new_range_api", issue = "125687")]
@@ -393,8 +391,8 @@ impl<T> From<legacy::RangeInclusive<T>> for RangeInclusive<T> {
             "attempted to convert from an exhausted `legacy::RangeInclusive` (unspecified behavior)"
         );
 
-        let (start, end) = value.into_inner();
-        RangeInclusive { start, end }
+        let (start, last) = value.into_inner();
+        RangeInclusive { start, last }
     }
 }
 
@@ -543,3 +541,107 @@ impl<T> const From<legacy::RangeFrom<T>> for RangeFrom<T> {
         Self { start: value.start }
     }
 }
+
+/// A range only bounded inclusively above (`..=last`).
+///
+/// The `RangeToInclusive` `..=last` contains all values with `x <= last`.
+/// It cannot serve as an [`Iterator`] because it doesn't have a starting point.
+///
+/// # Examples
+///
+/// The `..=last` syntax is a `RangeToInclusive`:
+///
+/// ```
+/// #![feature(new_range_api)]
+/// #![feature(new_range)]
+/// assert_eq!((..=5), std::range::RangeToInclusive{ last: 5 });
+/// ```
+///
+/// It does not have an [`IntoIterator`] implementation, so you can't use it in a
+/// `for` loop directly. This won't compile:
+///
+/// ```compile_fail,E0277
+/// // error[E0277]: the trait bound `std::range::RangeToInclusive<{integer}>:
+/// // std::iter::Iterator` is not satisfied
+/// for i in ..=5 {
+///     // ...
+/// }
+/// ```
+///
+/// When used as a [slicing index], `RangeToInclusive` produces a slice of all
+/// array elements up to and including the index indicated by `last`.
+///
+/// ```
+/// let arr = [0, 1, 2, 3, 4];
+/// assert_eq!(arr[ ..  ], [0, 1, 2, 3, 4]);
+/// assert_eq!(arr[ .. 3], [0, 1, 2      ]);
+/// assert_eq!(arr[ ..=3], [0, 1, 2, 3   ]); // This is a `RangeToInclusive`
+/// assert_eq!(arr[1..  ], [   1, 2, 3, 4]);
+/// assert_eq!(arr[1.. 3], [   1, 2      ]);
+/// assert_eq!(arr[1..=3], [   1, 2, 3   ]);
+/// ```
+///
+/// [slicing index]: crate::slice::SliceIndex
+#[lang = "RangeToInclusiveCopy"]
+#[doc(alias = "..=")]
+#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+#[unstable(feature = "new_range_api", issue = "125687")]
+pub struct RangeToInclusive<Idx> {
+    /// The upper bound of the range (inclusive)
+    #[unstable(feature = "new_range_api", issue = "125687")]
+    pub last: Idx,
+}
+
+#[unstable(feature = "new_range_api", issue = "125687")]
+impl<Idx: fmt::Debug> fmt::Debug for RangeToInclusive<Idx> {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(fmt, "..=")?;
+        self.last.fmt(fmt)?;
+        Ok(())
+    }
+}
+
+impl<Idx: PartialOrd<Idx>> RangeToInclusive<Idx> {
+    /// Returns `true` if `item` is contained in the range.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// assert!( (..=5).contains(&-1_000_000_000));
+    /// assert!( (..=5).contains(&5));
+    /// assert!(!(..=5).contains(&6));
+    ///
+    /// assert!( (..=1.0).contains(&1.0));
+    /// assert!(!(..=1.0).contains(&f32::NAN));
+    /// assert!(!(..=f32::NAN).contains(&0.5));
+    /// ```
+    #[inline]
+    #[unstable(feature = "new_range_api", issue = "125687")]
+    pub fn contains<U>(&self, item: &U) -> bool
+    where
+        Idx: PartialOrd<U>,
+        U: ?Sized + PartialOrd<Idx>,
+    {
+        <Self as RangeBounds<Idx>>::contains(self, item)
+    }
+}
+
+// RangeToInclusive<Idx> cannot impl From<RangeTo<Idx>>
+// because underflow would be possible with (..0).into()
+
+#[unstable(feature = "new_range_api", issue = "125687")]
+impl<T> RangeBounds<T> for RangeToInclusive<T> {
+    fn start_bound(&self) -> Bound<&T> {
+        Unbounded
+    }
+    fn end_bound(&self) -> Bound<&T> {
+        Included(&self.last)
+    }
+}
+
+#[unstable(feature = "range_into_bounds", issue = "136903")]
+impl<T> IntoBounds<T> for RangeToInclusive<T> {
+    fn into_bounds(self) -> (Bound<T>, Bound<T>) {
+        (Unbounded, Included(self.last))
+    }
+}
diff --git a/library/core/src/range/iter.rs b/library/core/src/range/iter.rs
index 1e261d8c1d93a..24efd4a204a5f 100644
--- a/library/core/src/range/iter.rs
+++ b/library/core/src/range/iter.rs
@@ -164,7 +164,7 @@ impl<A: Step> IterRangeInclusive<A> {
             return None;
         }
 
-        Some(RangeInclusive { start: self.0.start, end: self.0.end })
+        Some(RangeInclusive { start: self.0.start, last: self.0.end })
     }
 }
 
diff --git a/library/core/src/range/legacy.rs b/library/core/src/range/legacy.rs
index 6723c4903f756..aa11331382dd0 100644
--- a/library/core/src/range/legacy.rs
+++ b/library/core/src/range/legacy.rs
@@ -1,10 +1,10 @@
 //! # Legacy range types
 //!
 //! The types within this module will be replaced by the types
-//! [`Range`], [`RangeInclusive`], and [`RangeFrom`] in the parent
+//! [`Range`], [`RangeInclusive`], [`RangeToInclusive`], and [`RangeFrom`] in the parent
 //! module, [`core::range`].
 //!
 //! The types here are equivalent to those in [`core::ops`].
 
 #[doc(inline)]
-pub use crate::ops::{Range, RangeFrom, RangeInclusive};
+pub use crate::ops::{Range, RangeFrom, RangeInclusive, RangeToInclusive};
diff --git a/library/core/src/slice/index.rs b/library/core/src/slice/index.rs
index 98091e9fe83fb..82a1c66ffec7c 100644
--- a/library/core/src/slice/index.rs
+++ b/library/core/src/slice/index.rs
@@ -129,6 +129,8 @@ mod private_slice_index {
     #[unstable(feature = "new_range_api", issue = "125687")]
     impl Sealed for range::RangeInclusive<usize> {}
     #[unstable(feature = "new_range_api", issue = "125687")]
+    impl Sealed for range::RangeToInclusive<usize> {}
+    #[unstable(feature = "new_range_api", issue = "125687")]
     impl Sealed for range::RangeFrom<usize> {}
 
     impl Sealed for ops::IndexRange {}
@@ -788,6 +790,45 @@ unsafe impl<T> const SliceIndex<[T]> for ops::RangeToInclusive<usize> {
     }
 }
 
+/// The methods `index` and `index_mut` panic if the end of the range is out of bounds.
+#[stable(feature = "inclusive_range", since = "1.26.0")]
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+unsafe impl<T> const SliceIndex<[T]> for range::RangeToInclusive<usize> {
+    type Output = [T];
+
+    #[inline]
+    fn get(self, slice: &[T]) -> Option<&[T]> {
+        (0..=self.last).get(slice)
+    }
+
+    #[inline]
+    fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]> {
+        (0..=self.last).get_mut(slice)
+    }
+
+    #[inline]
+    unsafe fn get_unchecked(self, slice: *const [T]) -> *const [T] {
+        // SAFETY: the caller has to uphold the safety contract for `get_unchecked`.
+        unsafe { (0..=self.last).get_unchecked(slice) }
+    }
+
+    #[inline]
+    unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut [T] {
+        // SAFETY: the caller has to uphold the safety contract for `get_unchecked_mut`.
+        unsafe { (0..=self.last).get_unchecked_mut(slice) }
+    }
+
+    #[inline]
+    fn index(self, slice: &[T]) -> &[T] {
+        (0..=self.last).index(slice)
+    }
+
+    #[inline]
+    fn index_mut(self, slice: &mut [T]) -> &mut [T] {
+        (0..=self.last).index_mut(slice)
+    }
+}
+
 /// Performs bounds checking of a range.
 ///
 /// This method is similar to [`Index::index`] for slices, but it returns a
diff --git a/library/core/src/str/traits.rs b/library/core/src/str/traits.rs
index dc88f35eca7ea..6a0cdc85dea9d 100644
--- a/library/core/src/str/traits.rs
+++ b/library/core/src/str/traits.rs
@@ -677,11 +677,11 @@ unsafe impl const SliceIndex<str> for range::RangeInclusive<usize> {
     type Output = str;
     #[inline]
     fn get(self, slice: &str) -> Option<&Self::Output> {
-        if self.end == usize::MAX { None } else { self.into_slice_range().get(slice) }
+        if self.last == usize::MAX { None } else { self.into_slice_range().get(slice) }
     }
     #[inline]
     fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output> {
-        if self.end == usize::MAX { None } else { self.into_slice_range().get_mut(slice) }
+        if self.last == usize::MAX { None } else { self.into_slice_range().get_mut(slice) }
     }
     #[inline]
     unsafe fn get_unchecked(self, slice: *const str) -> *const Self::Output {
@@ -695,14 +695,14 @@ unsafe impl const SliceIndex<str> for range::RangeInclusive<usize> {
     }
     #[inline]
     fn index(self, slice: &str) -> &Self::Output {
-        if self.end == usize::MAX {
+        if self.last == usize::MAX {
             str_index_overflow_fail();
         }
         self.into_slice_range().index(slice)
     }
     #[inline]
     fn index_mut(self, slice: &mut str) -> &mut Self::Output {
-        if self.end == usize::MAX {
+        if self.last == usize::MAX {
             str_index_overflow_fail();
         }
         self.into_slice_range().index_mut(slice)
diff --git a/src/tools/clippy/clippy_utils/src/sym.rs b/src/tools/clippy/clippy_utils/src/sym.rs
index 278101ac27f96..8033b74a8d25c 100644
--- a/src/tools/clippy/clippy_utils/src/sym.rs
+++ b/src/tools/clippy/clippy_utils/src/sym.rs
@@ -194,7 +194,6 @@ generate! {
     itertools,
     join,
     kw,
-    last,
     lazy_static,
     lint_vec,
     ln,
diff --git a/tests/ui/const-generics/std/const-generics-range.full.stderr b/tests/ui/const-generics/std/const-generics-range.full.stderr
index 2b5c63e6643d8..ccede2af9e553 100644
--- a/tests/ui/const-generics/std/const-generics-range.full.stderr
+++ b/tests/ui/const-generics/std/const-generics-range.full.stderr
@@ -28,7 +28,7 @@ error[E0741]: `RangeTo<usize>` must implement `ConstParamTy` to be used as the t
 LL | struct _RangeTo<const R: std::ops::RangeTo<usize>>;
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0741]: `RangeToInclusive<usize>` must implement `ConstParamTy` to be used as the type of a const generic parameter
+error[E0741]: `std::ops::RangeToInclusive<usize>` must implement `ConstParamTy` to be used as the type of a const generic parameter
   --> $DIR/const-generics-range.rs:34:35
    |
 LL | struct _RangeToInclusive<const R: std::ops::RangeToInclusive<usize>>;
diff --git a/tests/ui/const-generics/std/const-generics-range.min.stderr b/tests/ui/const-generics/std/const-generics-range.min.stderr
index 04e3fe744534f..43a57c880d5d8 100644
--- a/tests/ui/const-generics/std/const-generics-range.min.stderr
+++ b/tests/ui/const-generics/std/const-generics-range.min.stderr
@@ -58,7 +58,7 @@ help: add `#![feature(adt_const_params)]` to the crate attributes to enable more
 LL + #![feature(adt_const_params)]
    |
 
-error: `RangeToInclusive<usize>` is forbidden as the type of a const generic parameter
+error: `std::ops::RangeToInclusive<usize>` is forbidden as the type of a const generic parameter
   --> $DIR/const-generics-range.rs:34:35
    |
 LL | struct _RangeToInclusive<const R: std::ops::RangeToInclusive<usize>>;
diff --git a/tests/ui/const-generics/std/const-generics-range.rs b/tests/ui/const-generics/std/const-generics-range.rs
index 3a238ed177e0f..391366dadba0a 100644
--- a/tests/ui/const-generics/std/const-generics-range.rs
+++ b/tests/ui/const-generics/std/const-generics-range.rs
@@ -7,32 +7,32 @@
 // `Range` should be usable within const generics:
 struct _Range<const R: std::ops::Range<usize>>;
 //[min]~^ ERROR `std::ops::Range<usize>` is forbidden
-const RANGE : _Range<{ 0 .. 1000 }> = _Range;
+const RANGE: _Range<{ 0..1000 }> = _Range;
 
 // `RangeFrom` should be usable within const generics:
 struct _RangeFrom<const R: std::ops::RangeFrom<usize>>;
 //[min]~^ ERROR `std::ops::RangeFrom<usize>` is forbidden
-const RANGE_FROM : _RangeFrom<{ 0 .. }> = _RangeFrom;
+const RANGE_FROM: _RangeFrom<{ 0.. }> = _RangeFrom;
 
 // `RangeFull` should be usable within const generics:
 struct _RangeFull<const R: std::ops::RangeFull>;
 //[min]~^ ERROR `RangeFull` is forbidden
-const RANGE_FULL : _RangeFull<{ .. }> = _RangeFull;
+const RANGE_FULL: _RangeFull<{ .. }> = _RangeFull;
 
 // Regression test for #70155
 // `RangeInclusive` should be usable within const generics:
 struct _RangeInclusive<const R: std::ops::RangeInclusive<usize>>;
 //[min]~^ ERROR `std::ops::RangeInclusive<usize>` is forbidden
-const RANGE_INCLUSIVE : _RangeInclusive<{ 0 ..= 999 }> = _RangeInclusive;
+const RANGE_INCLUSIVE: _RangeInclusive<{ 0..=999 }> = _RangeInclusive;
 
 // `RangeTo` should be usable within const generics:
 struct _RangeTo<const R: std::ops::RangeTo<usize>>;
 //[min]~^ ERROR `RangeTo<usize>` is forbidden
-const RANGE_TO : _RangeTo<{ .. 1000 }> = _RangeTo;
+const RANGE_TO: _RangeTo<{ ..1000 }> = _RangeTo;
 
 // `RangeToInclusive` should be usable within const generics:
 struct _RangeToInclusive<const R: std::ops::RangeToInclusive<usize>>;
-//[min]~^ ERROR `RangeToInclusive<usize>` is forbidden
-const RANGE_TO_INCLUSIVE : _RangeToInclusive<{ ..= 999 }> = _RangeToInclusive;
+//[min]~^ ERROR `std::ops::RangeToInclusive<usize>` is forbidden
+const RANGE_TO_INCLUSIVE: _RangeToInclusive<{ ..=999 }> = _RangeToInclusive;
 
 pub fn main() {}
diff --git a/tests/ui/iterators/ranges.stderr b/tests/ui/iterators/ranges.stderr
index b9fbcd5304b1f..f85ce644073ef 100644
--- a/tests/ui/iterators/ranges.stderr
+++ b/tests/ui/iterators/ranges.stderr
@@ -8,15 +8,15 @@ LL |     for _ in ..10 {}
    = note: `..end` is a `RangeTo`, which cannot be iterated on; you might have meant to have a bounded `Range`: `0..end`
    = note: required for `RangeTo<{integer}>` to implement `IntoIterator`
 
-error[E0277]: `RangeToInclusive<{integer}>` is not an iterator
+error[E0277]: `std::ops::RangeToInclusive<{integer}>` is not an iterator
   --> $DIR/ranges.rs:4:14
    |
 LL |     for _ in ..=10 {}
    |              ^^^^^ if you meant to iterate until a value (including it), add a starting value
    |
-   = help: the trait `Iterator` is not implemented for `RangeToInclusive<{integer}>`
+   = help: the trait `Iterator` is not implemented for `std::ops::RangeToInclusive<{integer}>`
    = note: `..=end` is a `RangeToInclusive`, which cannot be iterated on; you might have meant to have a bounded `RangeInclusive`: `0..=end`
-   = note: required for `RangeToInclusive<{integer}>` to implement `IntoIterator`
+   = note: required for `std::ops::RangeToInclusive<{integer}>` to implement `IntoIterator`
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/new-range/disabled.rs b/tests/ui/new-range/disabled.rs
index 1a5fe3f974360..6ba29f5ca9a25 100644
--- a/tests/ui/new-range/disabled.rs
+++ b/tests/ui/new-range/disabled.rs
@@ -6,20 +6,20 @@ fn main() {
     // Unchanged
     let a: core::range::RangeFull = ..;
     let b: core::range::RangeTo<u8> = ..2;
-    let c: core::range::RangeToInclusive<u8> = ..=3;
 
     let _: core::ops::RangeFull = a;
     let _: core::ops::RangeTo<u8> = b;
-    let _: core::ops::RangeToInclusive<u8> = c;
 
     // Changed
     let a: core::range::legacy::RangeFrom<u8> = 1..;
     let b: core::range::legacy::Range<u8> = 2..3;
     let c: core::range::legacy::RangeInclusive<u8> = 4..=5;
+    let d: core::range::legacy::RangeToInclusive<u8> = ..=3;
 
     let a: core::ops::RangeFrom<u8> = a;
     let b: core::ops::Range<u8> = b;
     let c: core::ops::RangeInclusive<u8> = c;
+    let d: core::ops::RangeToInclusive<u8> = d;
 
     let _: core::ops::RangeFrom<u8> = a.into_iter();
     let _: core::ops::Range<u8> = b.into_iter();
diff --git a/tests/ui/new-range/enabled.rs b/tests/ui/new-range/enabled.rs
index a5fb76ad52b72..5ddbba492e763 100644
--- a/tests/ui/new-range/enabled.rs
+++ b/tests/ui/new-range/enabled.rs
@@ -7,18 +7,18 @@ fn main() {
     // Unchanged
     let a: core::range::RangeFull = ..;
     let b: core::range::RangeTo<u8> = ..2;
-    let c: core::range::RangeToInclusive<u8> = ..=3;
 
     let _: core::ops::RangeFull = a;
     let _: core::ops::RangeTo<u8> = b;
-    let _: core::ops::RangeToInclusive<u8> = c;
 
     // Changed
     let a: core::range::RangeFrom<u8> = 1..;
     let b: core::range::Range<u8> = 2..3;
     let c: core::range::RangeInclusive<u8> = 4..=5;
+    let d: core::range::RangeToInclusive<u8> = ..=3;
 
     let _: core::range::IterRangeFrom<u8> = a.into_iter();
     let _: core::range::IterRange<u8> = b.into_iter();
     let _: core::range::IterRangeInclusive<u8> = c.into_iter();
+    // RangeToInclusive has no Iterator implementation
 }
diff --git a/tests/ui/range/issue-54505-no-literals.stderr b/tests/ui/range/issue-54505-no-literals.stderr
index c6d4384bcd33c..62e2fe4a83896 100644
--- a/tests/ui/range/issue-54505-no-literals.stderr
+++ b/tests/ui/range/issue-54505-no-literals.stderr
@@ -207,7 +207,7 @@ LL |     take_range(std::ops::RangeToInclusive { end: 5 });
    |     arguments to this function are incorrect
    |
    = note: expected reference `&_`
-                 found struct `RangeToInclusive<{integer}>`
+                 found struct `std::ops::RangeToInclusive<{integer}>`
 note: function defined here
   --> $DIR/issue-54505-no-literals.rs:12:4
    |
@@ -227,7 +227,7 @@ LL |     take_range(::std::ops::RangeToInclusive { end: 5 });
    |     arguments to this function are incorrect
    |
    = note: expected reference `&_`
-                 found struct `RangeToInclusive<{integer}>`
+                 found struct `std::ops::RangeToInclusive<{integer}>`
 note: function defined here
   --> $DIR/issue-54505-no-literals.rs:12:4
    |
diff --git a/tests/ui/range/issue-54505-no-std.stderr b/tests/ui/range/issue-54505-no-std.stderr
index 2aa1d584046dd..866a82afb7e2f 100644
--- a/tests/ui/range/issue-54505-no-std.stderr
+++ b/tests/ui/range/issue-54505-no-std.stderr
@@ -112,7 +112,7 @@ LL |     take_range(..=42);
    |     arguments to this function are incorrect
    |
    = note: expected reference `&_`
-                 found struct `RangeToInclusive<{integer}>`
+                 found struct `core::ops::RangeToInclusive<{integer}>`
 note: function defined here
   --> $DIR/issue-54505-no-std.rs:25:4
    |
diff --git a/tests/ui/range/issue-54505.stderr b/tests/ui/range/issue-54505.stderr
index 8b669b2910f6b..4d94c6c2d0942 100644
--- a/tests/ui/range/issue-54505.stderr
+++ b/tests/ui/range/issue-54505.stderr
@@ -112,7 +112,7 @@ LL |     take_range(..=42);
    |     arguments to this function are incorrect
    |
    = note: expected reference `&_`
-                 found struct `RangeToInclusive<{integer}>`
+                 found struct `std::ops::RangeToInclusive<{integer}>`
 note: function defined here
   --> $DIR/issue-54505.rs:10:4
    |

From 20226db7ff086e7ddcb9a46bcd9764e9d36bc301 Mon Sep 17 00:00:00 2001
From: Jeremy Smart <jeremy3141592@gmail.com>
Date: Thu, 31 Jul 2025 23:27:02 -0400
Subject: [PATCH 0702/1889] change end to last

---
 clippy_utils/src/sym.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/clippy_utils/src/sym.rs b/clippy_utils/src/sym.rs
index 278101ac27f96..8033b74a8d25c 100644
--- a/clippy_utils/src/sym.rs
+++ b/clippy_utils/src/sym.rs
@@ -194,7 +194,6 @@ generate! {
     itertools,
     join,
     kw,
-    last,
     lazy_static,
     lint_vec,
     ln,

From c63e03490692c2e90e927bae35f51a1f59252868 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 9 Sep 2025 08:31:52 +0200
Subject: [PATCH 0703/1889] triagebot: warn about
 #[rustc_intrinsic_const_stable_indirect]; make warnings a bit more noticeable

---
 triagebot.toml | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/triagebot.toml b/triagebot.toml
index bf9bfee4306d0..2d58c616bc278 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -1308,21 +1308,32 @@ cc = ["@m-ou-se"]
 [mentions."compiler/rustc_ast_lowering/src/format.rs"]
 cc = ["@m-ou-se"]
 
+# Content-based mentions
+
 [mentions."#[miri::intrinsic_fallback_is_spec]"]
 type = "content"
 message = """
-`#[miri::intrinsic_fallback_is_spec]` must only be used if the function actively checks for all UB cases,
+⚠️ `#[miri::intrinsic_fallback_is_spec]` must only be used if the function actively checks for all UB cases,
 and explores the possible non-determinism of the intrinsic.
 """
 cc = ["@rust-lang/miri"]
+
 [mentions."#[rustc_allow_const_fn_unstable"]
 type = "content"
 message = """
-`#[rustc_allow_const_fn_unstable]` needs careful audit to avoid accidentally exposing unstable
+⚠️ `#[rustc_allow_const_fn_unstable]` needs careful audit to avoid accidentally exposing unstable
 implementation details on stable.
 """
 cc = ["@rust-lang/wg-const-eval"]
 
+[mentions."#[rustc_intrinsic_const_stable_indirect]"]
+type = "content"
+message = """
+⚠️ `#[rustc_intrinsic_const_stable_indirect]` controls whether intrinsics can be exposed to stable const
+code; adding it needs t-lang approval.
+"""
+cc = ["@rust-lang/wg-const-eval"]
+
 
 # ------------------------------------------------------------------------------
 # PR assignments

From e8206d0b88cf48d692c059a913d7124375448934 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Tue, 9 Sep 2025 08:37:02 +0200
Subject: [PATCH 0704/1889] Update documentation about how to build the RA book

---
 src/tools/rust-analyzer/docs/book/README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/tools/rust-analyzer/docs/book/README.md b/src/tools/rust-analyzer/docs/book/README.md
index 0a3161f3af38d..11f7e8f98ca56 100644
--- a/src/tools/rust-analyzer/docs/book/README.md
+++ b/src/tools/rust-analyzer/docs/book/README.md
@@ -8,6 +8,7 @@ To run the documentation site locally:
 
 ```shell
 cargo install mdbook
+cargo install mdbook-toc
 cargo xtask codegen
 cd docs/book
 mdbook serve

From 400e687598320fbd9690af5acc4af091b18f577d Mon Sep 17 00:00:00 2001
From: Marco Cavenati <Marco.Cavenati@eurecom.fr>
Date: Mon, 8 Sep 2025 15:55:16 +0200
Subject: [PATCH 0705/1889] Bump unicode_data to version 17.0.0

---
 library/core/src/unicode/unicode_data.rs | 750 ++++++++++++-----------
 1 file changed, 383 insertions(+), 367 deletions(-)

diff --git a/library/core/src/unicode/unicode_data.rs b/library/core/src/unicode/unicode_data.rs
index 2f53de183f629..3c38b44224f87 100644
--- a/library/core/src/unicode/unicode_data.rs
+++ b/library/core/src/unicode/unicode_data.rs
@@ -1,15 +1,15 @@
 //! This file is generated by `./x run src/tools/unicode-table-generator`; do not edit manually!
-// Alphabetic      :  1723 bytes, 142707 codepoints in 755 ranges (U+0000AA - U+0323B0) using skiplist
-// Case_Ignorable  :  1043 bytes,   2744 codepoints in 447 ranges (U+0000A8 - U+0E01F0) using skiplist
-// Cased           :   403 bytes,   4526 codepoints in 157 ranges (U+0000AA - U+01F18A) using skiplist
-// Grapheme_Extend :   887 bytes,   2193 codepoints in 375 ranges (U+000300 - U+0E01F0) using skiplist
-// Lowercase       :   933 bytes,   2543 codepoints in 674 ranges (U+0000AA - U+01E944) using bitset
-// N               :   455 bytes,   1901 codepoints in 143 ranges (U+0000B2 - U+01FBFA) using skiplist
-// Uppercase       :   797 bytes,   1952 codepoints in 655 ranges (U+0000C0 - U+01F18A) using bitset
+// Alphabetic      :  1723 bytes, 147369 codepoints in 759 ranges (U+0000AA - U+03347A) using skiplist
+// Case_Ignorable  :  1063 bytes,   2789 codepoints in 459 ranges (U+0000A8 - U+0E01F0) using skiplist
+// Cased           :   401 bytes,   4580 codepoints in 156 ranges (U+0000AA - U+01F18A) using skiplist
+// Grapheme_Extend :   899 bytes,   2232 codepoints in 383 ranges (U+000300 - U+0E01F0) using skiplist
+// Lowercase       :   943 bytes,   2569 codepoints in 676 ranges (U+0000AA - U+01E944) using bitset
+// N               :   463 bytes,   1914 codepoints in 145 ranges (U+0000B2 - U+01FBFA) using skiplist
+// Uppercase       :   799 bytes,   1980 codepoints in 659 ranges (U+0000C0 - U+01F18A) using bitset
 // White_Space     :   256 bytes,     19 codepoints in   8 ranges (U+000085 - U+003001) using cascading
-// to_lower        : 11484 bytes
-// to_upper        : 13432 bytes
-// Total           : 31413 bytes
+// to_lower        : 11708 bytes
+// to_upper        : 13656 bytes
+// Total           : 31911 bytes
 
 #[inline(always)]
 const fn bitset_search<
@@ -140,53 +140,52 @@ unsafe fn skip_search<const SOR: usize, const OFFSETS: usize>(
     offset_idx % 2 == 1
 }
 
-pub const UNICODE_VERSION: (u8, u8, u8) = (16, 0, 0);
+pub const UNICODE_VERSION: (u8, u8, u8) = (17, 0, 0);
 
 #[rustfmt::skip]
 pub mod alphabetic {
     use super::ShortOffsetRunHeader;
 
-    static SHORT_OFFSET_RUNS: [ShortOffsetRunHeader; 53] = [
+    static SHORT_OFFSET_RUNS: [ShortOffsetRunHeader; 51] = [
         ShortOffsetRunHeader::new(0, 706), ShortOffsetRunHeader::new(12, 4681),
         ShortOffsetRunHeader::new(414, 5741), ShortOffsetRunHeader::new(452, 7958),
         ShortOffsetRunHeader::new(552, 9398), ShortOffsetRunHeader::new(623, 11264),
         ShortOffsetRunHeader::new(625, 12293), ShortOffsetRunHeader::new(663, 13312),
         ShortOffsetRunHeader::new(687, 19904), ShortOffsetRunHeader::new(688, 42125),
         ShortOffsetRunHeader::new(690, 42509), ShortOffsetRunHeader::new(694, 55204),
-        ShortOffsetRunHeader::new(784, 63744), ShortOffsetRunHeader::new(789, 64110),
-        ShortOffsetRunHeader::new(790, 64830), ShortOffsetRunHeader::new(812, 66176),
-        ShortOffsetRunHeader::new(853, 67383), ShortOffsetRunHeader::new(900, 73440),
+        ShortOffsetRunHeader::new(778, 63744), ShortOffsetRunHeader::new(783, 64110),
+        ShortOffsetRunHeader::new(784, 64830), ShortOffsetRunHeader::new(806, 66176),
+        ShortOffsetRunHeader::new(847, 67383), ShortOffsetRunHeader::new(894, 73440),
         ShortOffsetRunHeader::new(1217, 74650), ShortOffsetRunHeader::new(1228, 77712),
         ShortOffsetRunHeader::new(1233, 78896), ShortOffsetRunHeader::new(1236, 82939),
         ShortOffsetRunHeader::new(1240, 83527), ShortOffsetRunHeader::new(1242, 90368),
         ShortOffsetRunHeader::new(1243, 92160), ShortOffsetRunHeader::new(1245, 92729),
-        ShortOffsetRunHeader::new(1246, 93504), ShortOffsetRunHeader::new(1261, 100344),
-        ShortOffsetRunHeader::new(1278, 101590), ShortOffsetRunHeader::new(1280, 110576),
-        ShortOffsetRunHeader::new(1283, 110883), ShortOffsetRunHeader::new(1290, 111356),
-        ShortOffsetRunHeader::new(1300, 113664), ShortOffsetRunHeader::new(1301, 119808),
-        ShortOffsetRunHeader::new(1311, 120486), ShortOffsetRunHeader::new(1348, 122624),
-        ShortOffsetRunHeader::new(1371, 123536), ShortOffsetRunHeader::new(1395, 124112),
-        ShortOffsetRunHeader::new(1399, 124896), ShortOffsetRunHeader::new(1405, 126464),
-        ShortOffsetRunHeader::new(1421, 127280), ShortOffsetRunHeader::new(1487, 131072),
-        ShortOffsetRunHeader::new(1493, 173792), ShortOffsetRunHeader::new(1494, 177978),
-        ShortOffsetRunHeader::new(1496, 183970), ShortOffsetRunHeader::new(1500, 191457),
-        ShortOffsetRunHeader::new(1502, 192094), ShortOffsetRunHeader::new(1504, 194560),
-        ShortOffsetRunHeader::new(1505, 195102), ShortOffsetRunHeader::new(1506, 196608),
-        ShortOffsetRunHeader::new(1507, 201547), ShortOffsetRunHeader::new(1508, 205744),
-        ShortOffsetRunHeader::new(1510, 1319856),
+        ShortOffsetRunHeader::new(1246, 93504), ShortOffsetRunHeader::new(1261, 101590),
+        ShortOffsetRunHeader::new(1282, 110576), ShortOffsetRunHeader::new(1287, 110883),
+        ShortOffsetRunHeader::new(1294, 111356), ShortOffsetRunHeader::new(1304, 113664),
+        ShortOffsetRunHeader::new(1305, 119808), ShortOffsetRunHeader::new(1315, 120486),
+        ShortOffsetRunHeader::new(1352, 122624), ShortOffsetRunHeader::new(1375, 123536),
+        ShortOffsetRunHeader::new(1399, 124112), ShortOffsetRunHeader::new(1403, 126464),
+        ShortOffsetRunHeader::new(1431, 127280), ShortOffsetRunHeader::new(1497, 131072),
+        ShortOffsetRunHeader::new(1503, 173792), ShortOffsetRunHeader::new(1504, 178206),
+        ShortOffsetRunHeader::new(1506, 183982), ShortOffsetRunHeader::new(1508, 191457),
+        ShortOffsetRunHeader::new(1510, 192094), ShortOffsetRunHeader::new(1512, 194560),
+        ShortOffsetRunHeader::new(1513, 195102), ShortOffsetRunHeader::new(1514, 196608),
+        ShortOffsetRunHeader::new(1515, 201547), ShortOffsetRunHeader::new(1516, 210042),
+        ShortOffsetRunHeader::new(1518, 1324154),
     ];
-    static OFFSETS: [u8; 1511] = [
+    static OFFSETS: [u8; 1519] = [
         170, 1, 10, 1, 4, 1, 5, 23, 1, 31, 1, 0, 4, 12, 14, 5, 7, 1, 1, 1, 86, 1, 29, 18, 1, 2, 2,
         4, 1, 1, 6, 1, 1, 3, 1, 1, 1, 20, 1, 83, 1, 139, 8, 166, 1, 38, 2, 1, 6, 41, 39, 14, 1, 1,
         1, 2, 1, 2, 1, 1, 8, 27, 4, 4, 29, 11, 5, 56, 1, 7, 14, 102, 1, 8, 4, 8, 4, 3, 10, 3, 2, 1,
-        16, 48, 13, 101, 24, 33, 9, 2, 4, 1, 5, 24, 2, 19, 19, 25, 7, 11, 5, 24, 1, 6, 8, 1, 8, 42,
+        16, 48, 13, 101, 24, 33, 9, 2, 4, 1, 5, 24, 2, 19, 19, 25, 7, 11, 5, 24, 1, 7, 7, 1, 8, 42,
         10, 12, 3, 7, 6, 76, 1, 16, 1, 3, 4, 15, 13, 19, 1, 8, 2, 2, 2, 22, 1, 7, 1, 1, 3, 4, 3, 8,
         2, 2, 2, 2, 1, 1, 8, 1, 4, 2, 1, 5, 12, 2, 10, 1, 4, 3, 1, 6, 4, 2, 2, 22, 1, 7, 1, 2, 1, 2,
         1, 2, 4, 5, 4, 2, 2, 2, 4, 1, 7, 4, 1, 1, 17, 6, 11, 3, 1, 9, 1, 3, 1, 22, 1, 7, 1, 2, 1, 5,
         3, 9, 1, 3, 1, 2, 3, 1, 15, 4, 21, 4, 4, 3, 1, 8, 2, 2, 2, 22, 1, 7, 1, 2, 1, 5, 3, 8, 2, 2,
         2, 2, 9, 2, 4, 2, 1, 5, 13, 1, 16, 2, 1, 6, 3, 3, 1, 4, 3, 2, 1, 1, 1, 2, 3, 2, 3, 3, 3, 12,
-        4, 5, 3, 3, 1, 3, 3, 1, 6, 1, 40, 13, 1, 3, 1, 23, 1, 16, 3, 8, 1, 3, 1, 3, 8, 2, 1, 3, 2,
-        1, 2, 4, 28, 4, 1, 8, 1, 3, 1, 23, 1, 10, 1, 5, 3, 8, 1, 3, 1, 3, 8, 2, 6, 2, 1, 4, 13, 3,
+        4, 5, 3, 3, 1, 3, 3, 1, 6, 1, 40, 13, 1, 3, 1, 23, 1, 16, 3, 8, 1, 3, 1, 3, 8, 2, 1, 3, 1,
+        2, 2, 4, 28, 4, 1, 8, 1, 3, 1, 23, 1, 10, 1, 5, 3, 8, 1, 3, 1, 3, 8, 2, 5, 3, 1, 4, 13, 3,
         12, 13, 1, 3, 1, 41, 2, 8, 1, 3, 1, 3, 1, 1, 5, 4, 7, 5, 22, 6, 1, 3, 1, 18, 3, 24, 1, 9, 1,
         1, 2, 7, 8, 6, 1, 1, 1, 8, 18, 2, 13, 58, 5, 7, 6, 1, 51, 2, 1, 1, 1, 5, 1, 24, 1, 1, 1, 19,
         1, 3, 2, 5, 1, 1, 6, 1, 14, 4, 32, 1, 63, 8, 1, 36, 4, 19, 4, 16, 1, 36, 67, 55, 1, 1, 2, 5,
@@ -201,37 +200,37 @@ pub mod alphabetic {
         4, 1, 17, 41, 0, 52, 0, 229, 6, 4, 3, 2, 12, 38, 1, 1, 5, 1, 2, 56, 7, 1, 16, 23, 9, 7, 1,
         7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 32, 47, 1, 0, 3, 25, 9, 7, 5, 2, 5, 4, 86, 6, 3,
         1, 90, 1, 4, 5, 43, 1, 94, 17, 32, 48, 16, 0, 0, 64, 0, 67, 46, 2, 0, 3, 16, 10, 2, 20, 47,
-        5, 8, 3, 113, 39, 9, 2, 103, 2, 67, 2, 2, 1, 1, 1, 8, 21, 20, 1, 33, 24, 52, 12, 68, 1, 1,
-        44, 6, 3, 1, 1, 3, 10, 33, 5, 35, 13, 29, 3, 51, 1, 12, 15, 1, 16, 16, 10, 5, 1, 55, 9, 14,
-        18, 23, 3, 69, 1, 1, 1, 1, 24, 3, 2, 16, 2, 4, 11, 6, 2, 6, 2, 6, 9, 7, 1, 7, 1, 43, 1, 14,
-        6, 123, 21, 0, 12, 23, 4, 49, 0, 0, 2, 106, 38, 7, 12, 5, 5, 12, 1, 13, 1, 5, 1, 1, 1, 2, 1,
-        2, 1, 108, 33, 0, 18, 64, 2, 54, 40, 12, 116, 5, 1, 135, 36, 26, 6, 26, 11, 89, 3, 6, 2, 6,
-        2, 6, 2, 3, 35, 12, 1, 26, 1, 19, 1, 2, 1, 15, 2, 14, 34, 123, 69, 53, 0, 29, 3, 49, 47, 32,
-        13, 30, 5, 43, 5, 30, 2, 36, 4, 8, 1, 5, 42, 158, 18, 36, 4, 36, 4, 40, 8, 52, 12, 11, 1,
-        15, 1, 7, 1, 2, 1, 11, 1, 15, 1, 7, 1, 2, 3, 52, 12, 0, 9, 22, 10, 8, 24, 6, 1, 42, 1, 9,
-        69, 6, 2, 1, 1, 44, 1, 2, 3, 1, 2, 23, 10, 23, 9, 31, 65, 19, 1, 2, 10, 22, 10, 26, 70, 56,
-        6, 2, 64, 4, 1, 2, 5, 8, 1, 3, 1, 29, 42, 29, 3, 29, 35, 8, 1, 28, 27, 54, 10, 22, 10, 19,
-        13, 18, 110, 73, 55, 51, 13, 51, 13, 40, 34, 28, 3, 1, 5, 23, 250, 42, 1, 2, 3, 2, 16, 3,
-        55, 1, 3, 29, 10, 1, 8, 22, 42, 18, 46, 21, 27, 23, 9, 70, 43, 5, 10, 57, 9, 1, 13, 25, 23,
-        51, 17, 4, 8, 35, 3, 1, 9, 64, 1, 4, 9, 2, 10, 1, 1, 1, 35, 18, 1, 34, 2, 1, 6, 4, 62, 7, 1,
-        1, 1, 4, 1, 15, 1, 10, 7, 57, 23, 4, 1, 8, 2, 2, 2, 22, 1, 7, 1, 2, 1, 5, 3, 8, 2, 2, 2, 2,
-        3, 1, 6, 1, 5, 7, 28, 10, 1, 1, 2, 1, 1, 38, 1, 10, 1, 1, 2, 1, 1, 4, 1, 2, 3, 1, 1, 1, 44,
-        66, 1, 3, 1, 4, 20, 3, 30, 66, 2, 2, 1, 1, 184, 54, 2, 7, 25, 6, 34, 63, 1, 1, 3, 1, 59, 54,
-        2, 1, 71, 27, 2, 14, 21, 7, 185, 57, 103, 64, 31, 8, 2, 1, 2, 8, 1, 2, 1, 30, 1, 2, 2, 2, 2,
-        4, 93, 8, 2, 46, 2, 6, 1, 1, 1, 2, 27, 51, 2, 10, 17, 72, 5, 1, 18, 73, 199, 33, 31, 9, 1,
-        45, 1, 7, 1, 1, 49, 30, 2, 22, 1, 14, 73, 7, 1, 2, 1, 44, 3, 1, 1, 2, 1, 3, 1, 1, 2, 2, 24,
-        6, 1, 2, 1, 37, 1, 2, 1, 4, 1, 1, 0, 23, 9, 17, 1, 41, 3, 3, 111, 1, 79, 0, 102, 111, 17,
-        196, 0, 97, 15, 0, 17, 6, 25, 0, 5, 0, 0, 47, 0, 0, 7, 31, 17, 79, 17, 30, 18, 48, 16, 4,
-        31, 21, 5, 19, 0, 45, 211, 64, 128, 75, 4, 57, 7, 17, 64, 2, 1, 1, 12, 2, 14, 0, 8, 0, 41,
-        10, 0, 4, 1, 7, 1, 2, 1, 0, 15, 1, 29, 3, 2, 1, 14, 4, 8, 0, 0, 107, 5, 13, 3, 9, 7, 10, 4,
-        1, 0, 85, 1, 71, 1, 2, 2, 1, 2, 2, 2, 4, 1, 12, 1, 1, 1, 7, 1, 65, 1, 4, 2, 8, 1, 7, 1, 28,
-        1, 4, 1, 5, 1, 1, 3, 7, 1, 0, 2, 25, 1, 25, 1, 31, 1, 25, 1, 31, 1, 25, 1, 31, 1, 25, 1, 31,
-        1, 25, 1, 8, 0, 31, 6, 6, 213, 7, 1, 17, 2, 7, 1, 2, 1, 5, 5, 62, 33, 1, 112, 45, 10, 7, 16,
-        1, 0, 30, 18, 44, 0, 28, 228, 30, 2, 1, 0, 7, 1, 4, 1, 2, 1, 15, 1, 197, 59, 68, 3, 1, 3, 1,
-        0, 4, 1, 27, 1, 2, 1, 1, 2, 1, 1, 10, 1, 4, 1, 1, 1, 1, 6, 1, 4, 1, 1, 1, 1, 1, 1, 3, 1, 2,
-        1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 2, 4, 1, 7, 1, 4, 1, 4, 1, 1, 1, 10, 1, 17,
-        5, 3, 1, 5, 1, 17, 0, 26, 6, 26, 6, 26, 0, 0, 32, 0, 6, 222, 2, 0, 14, 0, 15, 0, 0, 0, 0, 0,
-        5, 0, 0,
+        5, 8, 3, 113, 39, 9, 2, 103, 2, 82, 20, 21, 1, 33, 24, 52, 12, 68, 1, 1, 44, 6, 3, 1, 1, 3,
+        10, 33, 5, 35, 13, 29, 3, 51, 1, 12, 15, 1, 16, 16, 10, 5, 1, 55, 9, 14, 18, 23, 3, 69, 1,
+        1, 1, 1, 24, 3, 2, 16, 2, 4, 11, 6, 2, 6, 2, 6, 9, 7, 1, 7, 1, 43, 1, 14, 6, 123, 21, 0, 12,
+        23, 4, 49, 0, 0, 2, 106, 38, 7, 12, 5, 5, 12, 1, 13, 1, 5, 1, 1, 1, 2, 1, 2, 1, 108, 33, 0,
+        18, 64, 2, 54, 40, 12, 116, 5, 1, 135, 36, 26, 6, 26, 11, 89, 3, 6, 2, 6, 2, 6, 2, 3, 35,
+        12, 1, 26, 1, 19, 1, 2, 1, 15, 2, 14, 34, 123, 69, 53, 0, 29, 3, 49, 47, 32, 13, 30, 5, 43,
+        5, 30, 2, 36, 4, 8, 1, 5, 42, 158, 18, 36, 4, 36, 4, 40, 8, 52, 12, 11, 1, 15, 1, 7, 1, 2,
+        1, 11, 1, 15, 1, 7, 1, 2, 3, 52, 12, 0, 9, 22, 10, 8, 24, 6, 1, 42, 1, 9, 69, 6, 2, 1, 1,
+        44, 1, 2, 3, 1, 2, 23, 10, 23, 9, 31, 65, 19, 1, 2, 10, 22, 10, 26, 6, 26, 38, 56, 6, 2, 64,
+        4, 1, 2, 5, 8, 1, 3, 1, 29, 42, 29, 3, 29, 35, 8, 1, 28, 27, 54, 10, 22, 10, 19, 13, 18,
+        110, 73, 55, 51, 13, 51, 13, 40, 34, 28, 3, 1, 5, 23, 250, 42, 1, 2, 3, 2, 16, 6, 50, 3, 3,
+        29, 10, 1, 8, 22, 42, 18, 46, 21, 27, 23, 9, 70, 43, 5, 10, 57, 9, 1, 13, 25, 23, 51, 17, 4,
+        8, 35, 3, 1, 9, 64, 1, 4, 9, 2, 10, 1, 1, 1, 35, 18, 1, 34, 2, 1, 6, 4, 62, 7, 1, 1, 1, 4,
+        1, 15, 1, 10, 7, 57, 23, 4, 1, 8, 2, 2, 2, 22, 1, 7, 1, 2, 1, 5, 3, 8, 2, 2, 2, 2, 3, 1, 6,
+        1, 5, 7, 28, 10, 1, 1, 2, 1, 1, 38, 1, 10, 1, 1, 2, 1, 1, 4, 1, 2, 3, 1, 1, 1, 44, 66, 1, 3,
+        1, 4, 20, 3, 30, 66, 2, 2, 1, 1, 184, 54, 2, 7, 25, 6, 34, 63, 1, 1, 3, 1, 59, 54, 2, 1, 71,
+        27, 2, 14, 21, 7, 185, 57, 103, 64, 31, 8, 2, 1, 2, 8, 1, 2, 1, 30, 1, 2, 2, 2, 2, 4, 93, 8,
+        2, 46, 2, 6, 1, 1, 1, 2, 27, 51, 2, 10, 17, 72, 5, 1, 18, 73, 103, 8, 88, 33, 31, 9, 1, 45,
+        1, 7, 1, 1, 49, 30, 2, 22, 1, 14, 73, 7, 1, 2, 1, 44, 3, 1, 1, 2, 1, 3, 1, 1, 2, 2, 24, 6,
+        1, 2, 1, 37, 1, 2, 1, 4, 1, 1, 23, 44, 0, 23, 9, 17, 1, 41, 3, 3, 111, 1, 79, 0, 102, 111,
+        17, 196, 0, 97, 15, 0, 17, 6, 25, 0, 5, 0, 0, 47, 0, 0, 7, 31, 17, 79, 17, 30, 18, 48, 16,
+        4, 31, 21, 5, 19, 0, 45, 211, 64, 32, 25, 2, 25, 44, 75, 4, 57, 7, 17, 64, 2, 1, 1, 12, 7,
+        9, 0, 41, 32, 97, 115, 0, 4, 1, 7, 1, 2, 1, 0, 15, 1, 29, 3, 2, 1, 14, 4, 8, 0, 0, 107, 5,
+        13, 3, 9, 7, 10, 4, 1, 0, 85, 1, 71, 1, 2, 2, 1, 2, 2, 2, 4, 1, 12, 1, 1, 1, 7, 1, 65, 1, 4,
+        2, 8, 1, 7, 1, 28, 1, 4, 1, 5, 1, 1, 3, 7, 1, 0, 2, 25, 1, 25, 1, 31, 1, 25, 1, 31, 1, 25,
+        1, 31, 1, 25, 1, 31, 1, 25, 1, 8, 0, 31, 6, 6, 213, 7, 1, 17, 2, 7, 1, 2, 1, 5, 5, 62, 33,
+        1, 112, 45, 10, 7, 16, 1, 0, 30, 18, 44, 0, 28, 228, 30, 2, 1, 207, 31, 1, 22, 8, 2, 224, 7,
+        1, 4, 1, 2, 1, 15, 1, 197, 59, 68, 3, 1, 3, 1, 0, 4, 1, 27, 1, 2, 1, 1, 2, 1, 1, 10, 1, 4,
+        1, 1, 1, 1, 6, 1, 4, 1, 1, 1, 1, 1, 1, 3, 1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1,
+        1, 2, 4, 1, 7, 1, 4, 1, 4, 1, 1, 1, 10, 1, 17, 5, 3, 1, 5, 1, 17, 0, 26, 6, 26, 6, 26, 0, 0,
+        32, 0, 2, 0, 2, 0, 15, 0, 0, 0, 0, 0, 5, 0, 0,
     ];
     #[inline]
     pub fn lookup(c: char) -> bool {
@@ -259,28 +258,27 @@ pub mod alphabetic {
 pub mod case_ignorable {
     use super::ShortOffsetRunHeader;
 
-    static SHORT_OFFSET_RUNS: [ShortOffsetRunHeader; 37] = [
+    static SHORT_OFFSET_RUNS: [ShortOffsetRunHeader; 36] = [
         ShortOffsetRunHeader::new(0, 688), ShortOffsetRunHeader::new(11, 4957),
         ShortOffsetRunHeader::new(263, 5906), ShortOffsetRunHeader::new(265, 8125),
-        ShortOffsetRunHeader::new(375, 11388), ShortOffsetRunHeader::new(409, 12293),
-        ShortOffsetRunHeader::new(421, 40981), ShortOffsetRunHeader::new(433, 42232),
-        ShortOffsetRunHeader::new(435, 42508), ShortOffsetRunHeader::new(437, 64286),
-        ShortOffsetRunHeader::new(533, 65024), ShortOffsetRunHeader::new(537, 66045),
-        ShortOffsetRunHeader::new(567, 67456), ShortOffsetRunHeader::new(573, 68097),
-        ShortOffsetRunHeader::new(579, 68900), ShortOffsetRunHeader::new(591, 69291),
-        ShortOffsetRunHeader::new(599, 71727), ShortOffsetRunHeader::new(723, 71995),
-        ShortOffsetRunHeader::new(727, 72752), ShortOffsetRunHeader::new(755, 73459),
-        ShortOffsetRunHeader::new(785, 78896), ShortOffsetRunHeader::new(797, 90398),
-        ShortOffsetRunHeader::new(801, 92912), ShortOffsetRunHeader::new(805, 93504),
-        ShortOffsetRunHeader::new(811, 94031), ShortOffsetRunHeader::new(815, 110576),
-        ShortOffsetRunHeader::new(823, 113821), ShortOffsetRunHeader::new(829, 118528),
-        ShortOffsetRunHeader::new(833, 119143), ShortOffsetRunHeader::new(837, 121344),
-        ShortOffsetRunHeader::new(847, 122880), ShortOffsetRunHeader::new(859, 123566),
-        ShortOffsetRunHeader::new(875, 124139), ShortOffsetRunHeader::new(879, 125136),
-        ShortOffsetRunHeader::new(883, 127995), ShortOffsetRunHeader::new(887, 917505),
-        ShortOffsetRunHeader::new(889, 2032112),
+        ShortOffsetRunHeader::new(377, 11388), ShortOffsetRunHeader::new(411, 12293),
+        ShortOffsetRunHeader::new(423, 40981), ShortOffsetRunHeader::new(435, 42232),
+        ShortOffsetRunHeader::new(437, 42508), ShortOffsetRunHeader::new(439, 64286),
+        ShortOffsetRunHeader::new(535, 65024), ShortOffsetRunHeader::new(539, 66045),
+        ShortOffsetRunHeader::new(569, 67456), ShortOffsetRunHeader::new(575, 68097),
+        ShortOffsetRunHeader::new(581, 68900), ShortOffsetRunHeader::new(593, 69291),
+        ShortOffsetRunHeader::new(601, 71727), ShortOffsetRunHeader::new(727, 71995),
+        ShortOffsetRunHeader::new(731, 73459), ShortOffsetRunHeader::new(797, 78896),
+        ShortOffsetRunHeader::new(809, 90398), ShortOffsetRunHeader::new(813, 92912),
+        ShortOffsetRunHeader::new(817, 93504), ShortOffsetRunHeader::new(823, 94031),
+        ShortOffsetRunHeader::new(827, 110576), ShortOffsetRunHeader::new(837, 113821),
+        ShortOffsetRunHeader::new(843, 118528), ShortOffsetRunHeader::new(847, 119143),
+        ShortOffsetRunHeader::new(851, 121344), ShortOffsetRunHeader::new(861, 122880),
+        ShortOffsetRunHeader::new(873, 123566), ShortOffsetRunHeader::new(889, 124139),
+        ShortOffsetRunHeader::new(893, 125136), ShortOffsetRunHeader::new(907, 127995),
+        ShortOffsetRunHeader::new(911, 917505), ShortOffsetRunHeader::new(913, 2032112),
     ];
-    static OFFSETS: [u8; 895] = [
+    static OFFSETS: [u8; 919] = [
         168, 1, 4, 1, 1, 1, 4, 1, 2, 2, 0, 192, 4, 2, 4, 1, 9, 2, 1, 1, 251, 7, 207, 1, 5, 1, 49,
         45, 1, 1, 1, 2, 1, 2, 1, 1, 44, 1, 11, 6, 10, 11, 1, 1, 35, 1, 10, 21, 16, 1, 101, 8, 1, 10,
         1, 4, 33, 1, 1, 1, 30, 27, 91, 11, 58, 11, 4, 1, 2, 1, 24, 24, 43, 3, 44, 1, 7, 2, 5, 9, 41,
@@ -292,28 +290,29 @@ pub mod case_ignorable {
         1, 1, 1, 1, 55, 14, 1, 5, 1, 2, 5, 11, 1, 36, 9, 1, 102, 4, 1, 6, 1, 2, 2, 2, 25, 2, 4, 3,
         16, 4, 13, 1, 2, 2, 6, 1, 15, 1, 94, 1, 0, 3, 0, 3, 29, 2, 30, 2, 30, 2, 64, 2, 1, 7, 8, 1,
         2, 11, 3, 1, 5, 1, 45, 5, 51, 1, 65, 2, 34, 1, 118, 3, 4, 2, 9, 1, 6, 3, 219, 2, 2, 1, 58,
-        1, 1, 7, 1, 1, 1, 1, 2, 8, 6, 10, 2, 1, 39, 1, 8, 31, 49, 4, 48, 1, 1, 5, 1, 1, 5, 1, 40, 9,
-        12, 2, 32, 4, 2, 2, 1, 3, 56, 1, 1, 2, 3, 1, 1, 3, 58, 8, 2, 2, 64, 6, 82, 3, 1, 13, 1, 7,
-        4, 1, 6, 1, 3, 2, 50, 63, 13, 1, 34, 101, 0, 1, 1, 3, 11, 3, 13, 3, 13, 3, 13, 2, 12, 5, 8,
-        2, 10, 1, 2, 1, 2, 5, 49, 5, 1, 10, 1, 1, 13, 1, 16, 13, 51, 33, 0, 2, 113, 3, 125, 1, 15,
-        1, 96, 32, 47, 1, 0, 1, 36, 4, 3, 5, 5, 1, 93, 6, 93, 3, 0, 1, 0, 6, 0, 1, 98, 4, 1, 10, 1,
-        1, 28, 4, 80, 2, 14, 34, 78, 1, 23, 3, 103, 3, 3, 2, 8, 1, 3, 1, 4, 1, 25, 2, 5, 1, 151, 2,
-        26, 18, 13, 1, 38, 8, 25, 11, 46, 3, 48, 1, 2, 4, 2, 2, 17, 1, 21, 2, 66, 6, 2, 2, 2, 2, 12,
-        1, 8, 1, 35, 1, 11, 1, 51, 1, 1, 3, 2, 2, 5, 2, 1, 1, 27, 1, 14, 2, 5, 2, 1, 1, 100, 5, 9,
-        3, 121, 1, 2, 1, 4, 1, 0, 1, 147, 17, 0, 16, 3, 1, 12, 16, 34, 1, 2, 1, 169, 1, 7, 1, 6, 1,
-        11, 1, 35, 1, 1, 1, 47, 1, 45, 2, 67, 1, 21, 3, 0, 1, 226, 1, 149, 5, 0, 6, 1, 42, 1, 9, 0,
-        3, 1, 2, 5, 4, 40, 3, 4, 1, 165, 2, 0, 4, 38, 1, 26, 5, 1, 1, 0, 2, 79, 4, 70, 11, 49, 4,
-        123, 1, 54, 15, 41, 1, 2, 2, 10, 3, 49, 4, 2, 2, 2, 1, 4, 1, 10, 1, 50, 3, 36, 5, 1, 8, 62,
-        1, 12, 2, 52, 9, 10, 4, 2, 1, 95, 3, 2, 1, 1, 2, 6, 1, 2, 1, 157, 1, 3, 8, 21, 2, 57, 2, 3,
-        1, 37, 7, 3, 5, 70, 6, 13, 1, 1, 1, 1, 1, 14, 2, 85, 8, 2, 3, 1, 1, 23, 1, 84, 6, 1, 1, 4,
-        2, 1, 2, 238, 4, 6, 2, 1, 2, 27, 2, 85, 8, 2, 1, 1, 2, 106, 1, 1, 1, 2, 6, 1, 1, 101, 1, 1,
-        1, 2, 4, 1, 5, 0, 9, 1, 2, 0, 2, 1, 1, 4, 1, 144, 4, 2, 2, 4, 1, 32, 10, 40, 6, 2, 4, 8, 1,
-        9, 6, 2, 3, 46, 13, 1, 2, 0, 7, 1, 6, 1, 1, 82, 22, 2, 7, 1, 2, 1, 2, 122, 6, 3, 1, 1, 2, 1,
-        7, 1, 1, 72, 2, 3, 1, 1, 1, 0, 2, 11, 2, 52, 5, 5, 1, 1, 1, 23, 1, 0, 17, 6, 15, 0, 12, 3,
-        3, 0, 5, 59, 7, 9, 4, 0, 3, 40, 2, 0, 1, 63, 17, 64, 2, 1, 2, 0, 4, 1, 7, 1, 2, 0, 2, 1, 4,
-        0, 46, 2, 23, 0, 3, 9, 16, 2, 7, 30, 4, 148, 3, 0, 55, 4, 50, 8, 1, 14, 1, 22, 5, 1, 15, 0,
-        7, 1, 17, 2, 7, 1, 2, 1, 5, 5, 62, 33, 1, 160, 14, 0, 1, 61, 4, 0, 5, 254, 2, 0, 7, 109, 8,
-        0, 5, 0, 1, 30, 96, 128, 240, 0,
+        1, 1, 7, 1, 1, 1, 1, 2, 8, 6, 10, 2, 1, 39, 1, 8, 46, 2, 12, 20, 4, 48, 1, 1, 5, 1, 1, 5, 1,
+        40, 9, 12, 2, 32, 4, 2, 2, 1, 3, 56, 1, 1, 2, 3, 1, 1, 3, 58, 8, 2, 2, 64, 6, 82, 3, 1, 13,
+        1, 7, 4, 1, 6, 1, 3, 2, 50, 63, 13, 1, 34, 101, 0, 1, 1, 3, 11, 3, 13, 3, 13, 3, 13, 2, 12,
+        5, 8, 2, 10, 1, 2, 1, 2, 5, 49, 5, 1, 10, 1, 1, 13, 1, 16, 13, 51, 33, 0, 2, 113, 3, 125, 1,
+        15, 1, 96, 32, 47, 1, 0, 1, 36, 4, 3, 5, 5, 1, 93, 6, 93, 3, 0, 1, 0, 6, 0, 1, 98, 4, 1, 10,
+        1, 1, 28, 4, 80, 2, 14, 34, 78, 1, 23, 3, 102, 4, 3, 2, 8, 1, 3, 1, 4, 1, 25, 2, 5, 1, 151,
+        2, 26, 18, 13, 1, 38, 8, 25, 11, 46, 3, 48, 1, 2, 4, 2, 2, 17, 1, 21, 2, 66, 6, 2, 2, 2, 2,
+        12, 1, 8, 1, 35, 1, 11, 1, 51, 1, 1, 3, 2, 2, 5, 2, 1, 1, 27, 1, 14, 2, 5, 2, 1, 1, 100, 5,
+        9, 3, 121, 1, 2, 1, 4, 1, 0, 1, 147, 17, 0, 16, 3, 1, 12, 16, 34, 1, 2, 1, 169, 1, 7, 1, 6,
+        1, 11, 1, 35, 1, 1, 1, 47, 1, 45, 2, 67, 1, 21, 3, 0, 1, 226, 1, 149, 5, 0, 6, 1, 42, 1, 9,
+        0, 3, 1, 2, 5, 4, 40, 3, 4, 1, 165, 2, 0, 4, 38, 1, 26, 5, 1, 1, 0, 2, 24, 1, 52, 6, 70, 11,
+        49, 4, 123, 1, 54, 15, 41, 1, 2, 2, 10, 3, 49, 4, 2, 2, 2, 1, 4, 1, 10, 1, 50, 3, 36, 5, 1,
+        8, 62, 1, 12, 2, 52, 9, 10, 4, 2, 1, 95, 3, 2, 1, 1, 2, 6, 1, 2, 1, 157, 1, 3, 8, 21, 2, 57,
+        2, 3, 1, 37, 7, 3, 5, 70, 6, 13, 1, 1, 1, 1, 1, 14, 2, 85, 8, 2, 3, 1, 1, 23, 1, 84, 6, 1,
+        1, 4, 2, 1, 2, 238, 4, 6, 2, 1, 2, 27, 2, 85, 8, 2, 1, 1, 2, 106, 1, 1, 1, 2, 6, 1, 1, 101,
+        1, 1, 1, 2, 4, 1, 5, 0, 9, 1, 2, 0, 2, 1, 1, 4, 1, 144, 4, 2, 2, 4, 1, 32, 10, 40, 6, 2, 4,
+        8, 1, 9, 6, 2, 3, 46, 13, 1, 2, 198, 1, 1, 3, 1, 1, 201, 7, 1, 6, 1, 1, 82, 22, 2, 7, 1, 2,
+        1, 2, 122, 6, 3, 1, 1, 2, 1, 7, 1, 1, 72, 2, 3, 1, 1, 1, 65, 1, 0, 2, 11, 2, 52, 5, 5, 1, 1,
+        1, 23, 1, 0, 17, 6, 15, 0, 12, 3, 3, 0, 5, 59, 7, 9, 4, 0, 3, 40, 2, 0, 1, 63, 17, 64, 2, 1,
+        2, 13, 2, 0, 4, 1, 7, 1, 2, 0, 2, 1, 4, 0, 46, 2, 23, 0, 3, 9, 16, 2, 7, 30, 4, 148, 3, 0,
+        55, 4, 50, 8, 1, 14, 1, 22, 5, 1, 15, 0, 7, 1, 17, 2, 7, 1, 2, 1, 5, 5, 62, 33, 1, 160, 14,
+        0, 1, 61, 4, 0, 5, 254, 2, 243, 1, 2, 1, 7, 2, 5, 1, 9, 1, 0, 7, 109, 8, 0, 5, 0, 1, 30, 96,
+        128, 240, 0,
     ];
     #[inline]
     pub fn lookup(c: char) -> bool {
@@ -346,24 +345,24 @@ pub mod cased {
         ShortOffsetRunHeader::new(61, 7296), ShortOffsetRunHeader::new(65, 7958),
         ShortOffsetRunHeader::new(74, 9398), ShortOffsetRunHeader::new(149, 11264),
         ShortOffsetRunHeader::new(151, 42560), ShortOffsetRunHeader::new(163, 43824),
-        ShortOffsetRunHeader::new(183, 64256), ShortOffsetRunHeader::new(189, 65313),
-        ShortOffsetRunHeader::new(193, 66560), ShortOffsetRunHeader::new(197, 67456),
-        ShortOffsetRunHeader::new(219, 68736), ShortOffsetRunHeader::new(227, 71840),
-        ShortOffsetRunHeader::new(235, 93760), ShortOffsetRunHeader::new(237, 119808),
-        ShortOffsetRunHeader::new(239, 120486), ShortOffsetRunHeader::new(276, 122624),
-        ShortOffsetRunHeader::new(299, 122928), ShortOffsetRunHeader::new(305, 125184),
-        ShortOffsetRunHeader::new(307, 127280), ShortOffsetRunHeader::new(309, 1241482),
+        ShortOffsetRunHeader::new(177, 64256), ShortOffsetRunHeader::new(183, 65313),
+        ShortOffsetRunHeader::new(187, 66560), ShortOffsetRunHeader::new(191, 67456),
+        ShortOffsetRunHeader::new(213, 68736), ShortOffsetRunHeader::new(221, 71840),
+        ShortOffsetRunHeader::new(229, 93760), ShortOffsetRunHeader::new(231, 119808),
+        ShortOffsetRunHeader::new(237, 120486), ShortOffsetRunHeader::new(274, 122624),
+        ShortOffsetRunHeader::new(297, 122928), ShortOffsetRunHeader::new(303, 125184),
+        ShortOffsetRunHeader::new(305, 127280), ShortOffsetRunHeader::new(307, 1241482),
     ];
-    static OFFSETS: [u8; 315] = [
-        170, 1, 10, 1, 4, 1, 5, 23, 1, 31, 1, 195, 1, 4, 4, 208, 1, 36, 7, 2, 30, 5, 96, 1, 42, 4,
+    static OFFSETS: [u8; 313] = [
+        170, 1, 10, 1, 4, 1, 5, 23, 1, 31, 1, 195, 1, 4, 4, 208, 2, 35, 7, 2, 30, 5, 96, 1, 42, 4,
         2, 2, 2, 4, 1, 1, 6, 1, 1, 3, 1, 1, 1, 20, 1, 83, 1, 139, 8, 166, 1, 38, 9, 41, 0, 38, 1, 1,
         5, 1, 2, 43, 1, 4, 0, 86, 2, 6, 0, 11, 5, 43, 2, 3, 64, 192, 64, 0, 2, 6, 2, 38, 2, 6, 2, 8,
         1, 1, 1, 1, 1, 1, 1, 31, 2, 53, 1, 7, 1, 1, 3, 3, 1, 7, 3, 4, 2, 6, 4, 13, 5, 3, 1, 7, 116,
         1, 13, 1, 16, 13, 101, 1, 4, 1, 2, 10, 1, 1, 3, 5, 6, 1, 1, 1, 1, 1, 1, 4, 1, 6, 4, 1, 2, 4,
         5, 5, 4, 1, 17, 32, 3, 2, 0, 52, 0, 229, 6, 4, 3, 2, 12, 38, 1, 1, 5, 1, 0, 46, 18, 30, 132,
-        102, 3, 4, 1, 62, 2, 2, 1, 1, 1, 8, 21, 5, 1, 3, 0, 43, 1, 14, 6, 80, 0, 7, 12, 5, 0, 26, 6,
-        26, 0, 80, 96, 36, 4, 36, 116, 11, 1, 15, 1, 7, 1, 2, 1, 11, 1, 15, 1, 7, 1, 2, 0, 1, 2, 3,
-        1, 42, 1, 9, 0, 51, 13, 51, 93, 22, 10, 22, 0, 64, 0, 64, 0, 85, 1, 71, 1, 2, 2, 1, 2, 2, 2,
+        102, 3, 4, 1, 77, 20, 6, 1, 3, 0, 43, 1, 14, 6, 80, 0, 7, 12, 5, 0, 26, 6, 26, 0, 80, 96,
+        36, 4, 36, 116, 11, 1, 15, 1, 7, 1, 2, 1, 11, 1, 15, 1, 7, 1, 2, 0, 1, 2, 3, 1, 42, 1, 9, 0,
+        51, 13, 51, 93, 22, 10, 22, 0, 64, 0, 64, 32, 25, 2, 25, 0, 85, 1, 71, 1, 2, 2, 1, 2, 2, 2,
         4, 1, 12, 1, 1, 1, 7, 1, 65, 1, 4, 2, 8, 1, 7, 1, 28, 1, 4, 1, 5, 1, 1, 3, 7, 1, 0, 2, 25,
         1, 25, 1, 31, 1, 25, 1, 31, 1, 25, 1, 31, 1, 25, 1, 31, 1, 25, 1, 8, 0, 10, 1, 20, 6, 6, 0,
         62, 0, 68, 0, 26, 6, 26, 6, 26, 0,
@@ -394,26 +393,26 @@ pub mod cased {
 pub mod grapheme_extend {
     use super::ShortOffsetRunHeader;
 
-    static SHORT_OFFSET_RUNS: [ShortOffsetRunHeader; 34] = [
+    static SHORT_OFFSET_RUNS: [ShortOffsetRunHeader; 33] = [
         ShortOffsetRunHeader::new(0, 768), ShortOffsetRunHeader::new(1, 1155),
         ShortOffsetRunHeader::new(3, 1425), ShortOffsetRunHeader::new(5, 4957),
         ShortOffsetRunHeader::new(249, 5906), ShortOffsetRunHeader::new(251, 8204),
-        ShortOffsetRunHeader::new(345, 11503), ShortOffsetRunHeader::new(349, 12330),
-        ShortOffsetRunHeader::new(355, 42607), ShortOffsetRunHeader::new(359, 43010),
-        ShortOffsetRunHeader::new(367, 64286), ShortOffsetRunHeader::new(433, 65024),
-        ShortOffsetRunHeader::new(435, 65438), ShortOffsetRunHeader::new(439, 66045),
-        ShortOffsetRunHeader::new(441, 68097), ShortOffsetRunHeader::new(447, 68900),
-        ShortOffsetRunHeader::new(459, 69291), ShortOffsetRunHeader::new(463, 71727),
-        ShortOffsetRunHeader::new(599, 72752), ShortOffsetRunHeader::new(631, 73459),
-        ShortOffsetRunHeader::new(661, 78912), ShortOffsetRunHeader::new(671, 90398),
-        ShortOffsetRunHeader::new(675, 92912), ShortOffsetRunHeader::new(679, 94031),
-        ShortOffsetRunHeader::new(683, 113821), ShortOffsetRunHeader::new(691, 118528),
-        ShortOffsetRunHeader::new(693, 119141), ShortOffsetRunHeader::new(697, 121344),
-        ShortOffsetRunHeader::new(709, 122880), ShortOffsetRunHeader::new(721, 123566),
-        ShortOffsetRunHeader::new(735, 124140), ShortOffsetRunHeader::new(739, 125136),
-        ShortOffsetRunHeader::new(743, 917536), ShortOffsetRunHeader::new(747, 2032112),
+        ShortOffsetRunHeader::new(347, 11503), ShortOffsetRunHeader::new(351, 12330),
+        ShortOffsetRunHeader::new(357, 42607), ShortOffsetRunHeader::new(361, 43010),
+        ShortOffsetRunHeader::new(369, 64286), ShortOffsetRunHeader::new(435, 65024),
+        ShortOffsetRunHeader::new(437, 65438), ShortOffsetRunHeader::new(441, 66045),
+        ShortOffsetRunHeader::new(443, 68097), ShortOffsetRunHeader::new(449, 68900),
+        ShortOffsetRunHeader::new(461, 69291), ShortOffsetRunHeader::new(465, 71727),
+        ShortOffsetRunHeader::new(601, 73459), ShortOffsetRunHeader::new(669, 78912),
+        ShortOffsetRunHeader::new(679, 90398), ShortOffsetRunHeader::new(683, 92912),
+        ShortOffsetRunHeader::new(687, 94031), ShortOffsetRunHeader::new(691, 113821),
+        ShortOffsetRunHeader::new(699, 118528), ShortOffsetRunHeader::new(701, 119141),
+        ShortOffsetRunHeader::new(705, 121344), ShortOffsetRunHeader::new(717, 122880),
+        ShortOffsetRunHeader::new(729, 123566), ShortOffsetRunHeader::new(743, 124140),
+        ShortOffsetRunHeader::new(747, 125136), ShortOffsetRunHeader::new(759, 917536),
+        ShortOffsetRunHeader::new(763, 2032112),
     ];
-    static OFFSETS: [u8; 751] = [
+    static OFFSETS: [u8; 767] = [
         0, 112, 0, 7, 0, 45, 1, 1, 1, 2, 1, 2, 1, 1, 72, 11, 48, 21, 16, 1, 101, 7, 2, 6, 2, 2, 1,
         4, 35, 1, 30, 27, 91, 11, 58, 9, 9, 1, 24, 4, 1, 9, 1, 3, 1, 5, 43, 3, 59, 9, 42, 24, 1, 32,
         55, 1, 1, 1, 4, 8, 4, 1, 3, 7, 10, 2, 29, 1, 58, 1, 1, 1, 2, 4, 8, 1, 9, 1, 10, 2, 26, 1, 2,
@@ -424,23 +423,24 @@ pub mod grapheme_extend {
         12, 8, 98, 1, 2, 9, 11, 7, 73, 2, 27, 1, 1, 1, 1, 1, 55, 14, 1, 5, 1, 2, 5, 11, 1, 36, 9, 1,
         102, 4, 1, 6, 1, 2, 2, 2, 25, 2, 4, 3, 16, 4, 13, 1, 2, 2, 6, 1, 15, 1, 0, 3, 0, 4, 28, 3,
         29, 2, 30, 2, 64, 2, 1, 7, 8, 1, 2, 11, 9, 1, 45, 3, 1, 1, 117, 2, 34, 1, 118, 3, 4, 2, 9,
-        1, 6, 3, 219, 2, 2, 1, 58, 1, 1, 7, 1, 1, 1, 1, 2, 8, 6, 10, 2, 1, 48, 31, 49, 4, 48, 10, 4,
-        3, 38, 9, 12, 2, 32, 4, 2, 6, 56, 1, 1, 2, 3, 1, 1, 5, 56, 8, 2, 2, 152, 3, 1, 13, 1, 7, 4,
-        1, 6, 1, 3, 2, 198, 64, 0, 1, 195, 33, 0, 3, 141, 1, 96, 32, 0, 6, 105, 2, 0, 4, 1, 10, 32,
-        2, 80, 2, 0, 1, 3, 1, 4, 1, 25, 2, 5, 1, 151, 2, 26, 18, 13, 1, 38, 8, 25, 11, 1, 1, 44, 3,
-        48, 1, 2, 4, 2, 2, 2, 1, 36, 1, 67, 6, 2, 2, 2, 2, 12, 1, 8, 1, 47, 1, 51, 1, 1, 3, 2, 2, 5,
-        2, 1, 1, 42, 2, 8, 1, 238, 1, 2, 1, 4, 1, 0, 1, 0, 16, 16, 16, 0, 2, 0, 1, 226, 1, 149, 5,
-        0, 3, 1, 2, 5, 4, 40, 3, 4, 1, 165, 2, 0, 4, 65, 5, 0, 2, 79, 4, 70, 11, 49, 4, 123, 1, 54,
-        15, 41, 1, 2, 2, 10, 3, 49, 4, 2, 2, 7, 1, 61, 3, 36, 5, 1, 8, 62, 1, 12, 2, 52, 9, 1, 1, 8,
-        4, 2, 1, 95, 3, 2, 4, 6, 1, 2, 1, 157, 1, 3, 8, 21, 2, 57, 2, 1, 1, 1, 1, 12, 1, 9, 1, 14,
-        7, 3, 5, 67, 1, 2, 6, 1, 1, 2, 1, 1, 3, 4, 3, 1, 1, 14, 2, 85, 8, 2, 3, 1, 1, 23, 1, 81, 1,
-        2, 6, 1, 1, 2, 1, 1, 2, 1, 2, 235, 1, 2, 4, 6, 2, 1, 2, 27, 2, 85, 8, 2, 1, 1, 2, 106, 1, 1,
-        1, 2, 8, 101, 1, 1, 1, 2, 4, 1, 5, 0, 9, 1, 2, 245, 1, 10, 4, 4, 1, 144, 4, 2, 2, 4, 1, 32,
-        10, 40, 6, 2, 4, 8, 1, 9, 6, 2, 3, 46, 13, 1, 2, 0, 7, 1, 6, 1, 1, 82, 22, 2, 7, 1, 2, 1, 2,
-        122, 6, 3, 1, 1, 2, 1, 7, 1, 1, 72, 2, 3, 1, 1, 1, 0, 2, 11, 2, 52, 5, 5, 3, 23, 1, 0, 1, 6,
-        15, 0, 12, 3, 3, 0, 5, 59, 7, 0, 1, 63, 4, 81, 1, 11, 2, 0, 2, 0, 46, 2, 23, 0, 5, 3, 6, 8,
-        8, 2, 7, 30, 4, 148, 3, 0, 55, 4, 50, 8, 1, 14, 1, 22, 5, 1, 15, 0, 7, 1, 17, 2, 7, 1, 2, 1,
-        5, 100, 1, 160, 7, 0, 1, 61, 4, 0, 4, 254, 2, 0, 7, 109, 7, 0, 96, 128, 240, 0,
+        1, 6, 3, 219, 2, 2, 1, 58, 1, 1, 7, 1, 1, 1, 1, 2, 8, 6, 10, 2, 1, 48, 46, 2, 12, 20, 4, 48,
+        10, 4, 3, 38, 9, 12, 2, 32, 4, 2, 6, 56, 1, 1, 2, 3, 1, 1, 5, 56, 8, 2, 2, 152, 3, 1, 13, 1,
+        7, 4, 1, 6, 1, 3, 2, 198, 64, 0, 1, 195, 33, 0, 3, 141, 1, 96, 32, 0, 6, 105, 2, 0, 4, 1,
+        10, 32, 2, 80, 2, 0, 1, 3, 1, 4, 1, 25, 2, 5, 1, 151, 2, 26, 18, 13, 1, 38, 8, 25, 11, 1, 1,
+        44, 3, 48, 1, 2, 4, 2, 2, 2, 1, 36, 1, 67, 6, 2, 2, 2, 2, 12, 1, 8, 1, 47, 1, 51, 1, 1, 3,
+        2, 2, 5, 2, 1, 1, 42, 2, 8, 1, 238, 1, 2, 1, 4, 1, 0, 1, 0, 16, 16, 16, 0, 2, 0, 1, 226, 1,
+        149, 5, 0, 3, 1, 2, 5, 4, 40, 3, 4, 1, 165, 2, 0, 4, 65, 5, 0, 2, 77, 6, 70, 11, 49, 4, 123,
+        1, 54, 15, 41, 1, 2, 2, 10, 3, 49, 4, 2, 2, 7, 1, 61, 3, 36, 5, 1, 8, 62, 1, 12, 2, 52, 9,
+        1, 1, 8, 4, 2, 1, 95, 3, 2, 4, 6, 1, 2, 1, 157, 1, 3, 8, 21, 2, 57, 2, 1, 1, 1, 1, 12, 1, 9,
+        1, 14, 7, 3, 5, 67, 1, 2, 6, 1, 1, 2, 1, 1, 3, 4, 3, 1, 1, 14, 2, 85, 8, 2, 3, 1, 1, 23, 1,
+        81, 1, 2, 6, 1, 1, 2, 1, 1, 2, 1, 2, 235, 1, 2, 4, 6, 2, 1, 2, 27, 2, 85, 8, 2, 1, 1, 2,
+        106, 1, 1, 1, 2, 8, 101, 1, 1, 1, 2, 4, 1, 5, 0, 9, 1, 2, 245, 1, 10, 4, 4, 1, 144, 4, 2, 2,
+        4, 1, 32, 10, 40, 6, 2, 4, 8, 1, 9, 6, 2, 3, 46, 13, 1, 2, 198, 1, 1, 3, 1, 1, 201, 7, 1, 6,
+        1, 1, 82, 22, 2, 7, 1, 2, 1, 2, 122, 6, 3, 1, 1, 2, 1, 7, 1, 1, 72, 2, 3, 1, 1, 1, 0, 2, 11,
+        2, 52, 5, 5, 3, 23, 1, 0, 1, 6, 15, 0, 12, 3, 3, 0, 5, 59, 7, 0, 1, 63, 4, 81, 1, 11, 2, 0,
+        2, 0, 46, 2, 23, 0, 5, 3, 6, 8, 8, 2, 7, 30, 4, 148, 3, 0, 55, 4, 50, 8, 1, 14, 1, 22, 5, 1,
+        15, 0, 7, 1, 17, 2, 7, 1, 2, 1, 5, 100, 1, 160, 7, 0, 1, 61, 4, 0, 4, 254, 2, 243, 1, 2, 1,
+        7, 2, 5, 1, 0, 7, 109, 7, 0, 96, 128, 240, 0,
     ];
     #[inline]
     pub fn lookup(c: char) -> bool {
@@ -475,27 +475,27 @@ pub mod lowercase {
     ];
     static BITSET_INDEX_CHUNKS: [[u8; 16]; 20] = [
         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 61, 0, 0],
-        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 14, 56, 0],
-        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 44, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0, 0, 0, 0, 67, 43, 0, 52, 48, 50, 33],
-        [0, 0, 0, 0, 9, 57, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 3, 0, 16, 58, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 27],
-        [0, 0, 0, 62, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 71, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-        [0, 0, 34, 17, 23, 53, 54, 49, 47, 7, 35, 42, 0, 28, 12, 31],
-        [0, 0, 46, 0, 56, 56, 56, 0, 22, 22, 69, 22, 36, 25, 24, 37],
-        [0, 5, 70, 0, 29, 15, 75, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-        [10, 60, 0, 6, 0, 0, 30, 0, 0, 0, 0, 0, 0, 0, 32, 0],
-        [16, 26, 22, 38, 39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-        [16, 51, 2, 21, 68, 8, 59, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-        [16, 72, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-        [65, 41, 55, 11, 66, 63, 18, 13, 1, 64, 76, 20, 73, 74, 4, 45],
+        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 63, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 14, 57, 0],
+        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 41, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 45, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 19, 62, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 0, 0, 69, 44, 0, 53, 49, 51, 34],
+        [0, 0, 0, 0, 9, 58, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 3, 0, 16, 59, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28],
+        [0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 73, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        [0, 0, 35, 17, 24, 54, 55, 50, 48, 7, 36, 43, 0, 29, 12, 32],
+        [0, 0, 47, 0, 57, 57, 57, 0, 23, 23, 71, 23, 37, 26, 25, 38],
+        [0, 5, 72, 0, 30, 15, 77, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        [10, 61, 0, 6, 0, 0, 31, 0, 0, 0, 0, 0, 0, 0, 33, 0],
+        [16, 27, 23, 39, 40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        [16, 52, 2, 22, 70, 8, 60, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        [16, 74, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        [67, 42, 56, 11, 68, 65, 18, 13, 1, 66, 78, 21, 75, 76, 4, 46],
     ];
-    static BITSET_CANONICAL: [u64; 56] = [
+    static BITSET_CANONICAL: [u64; 57] = [
         0b0000000000000000000000000000000000000000000000000000000000000000,
         0b0000111111111111111111111111110000000000000000000000000011111111,
         0b1010101010101010101010101010101010101010101010101010100000000010,
@@ -515,6 +515,7 @@ pub mod lowercase {
         0b1111111111111111000000000000000000000000000000000000000000000000,
         0b1111111101111111111111111111111110000000000000000000000000000000,
         0b1111110000000000000000000000000011111111111111111111111111000000,
+        0b1111100000000000000000000000000000000000000000000000000000000000,
         0b1111011111111111111111111111111111111111111111110000000000000000,
         0b1111000000000000000000000000001111110111111111111111111111111100,
         0b1010101010101010101010101010101010101010101010101101010101010100,
@@ -529,9 +530,9 @@ pub mod lowercase {
         0b0001101111111011111111111111101111111111100000000000000000000000,
         0b0001100100101111101010101010101010101010111000110111111111111111,
         0b0000011111111101111111111111111111111111111111111111111110111001,
-        0b0000011101011100000000000000000000001010101010100010010100001010,
+        0b0000011101011110000000000000000000001010101010101010010100001010,
         0b0000010000100000000001000000000000000000000000000000000000000000,
-        0b0000000111111111111111111111111111111111111011111111111111111111,
+        0b0000000111111111111111111111111111111111110011111111111111111111,
         0b0000000011111111000000001111111100000000001111110000000011111111,
         0b0000000011011100000000001111111100000000110011110000000011011100,
         0b0000000000001000010100000001101010101010101010101010101010101010,
@@ -553,10 +554,10 @@ pub mod lowercase {
         0b1110011001010001001011010010101001001110001001000011000100101001,
         0b1110101111000000000000000000000000001111111111111111111111111100,
     ];
-    static BITSET_MAPPING: [(u8, u8); 21] = [
-        (0, 64), (1, 184), (1, 182), (1, 179), (1, 172), (1, 161), (1, 146), (1, 144), (1, 140),
-        (1, 136), (1, 132), (2, 146), (2, 144), (2, 83), (3, 93), (3, 147), (3, 133), (4, 12),
-        (4, 6), (5, 187), (6, 78),
+    static BITSET_MAPPING: [(u8, u8); 22] = [
+        (0, 64), (1, 184), (1, 182), (1, 179), (1, 172), (1, 168), (1, 161), (1, 146), (1, 144),
+        (1, 140), (1, 136), (1, 132), (2, 146), (2, 144), (2, 83), (3, 93), (3, 147), (3, 133),
+        (4, 12), (4, 6), (5, 187), (6, 78),
     ];
 
     pub const fn lookup(c: char) -> bool {
@@ -576,7 +577,7 @@ pub mod lowercase {
 pub mod n {
     use super::ShortOffsetRunHeader;
 
-    static SHORT_OFFSET_RUNS: [ShortOffsetRunHeader; 42] = [
+    static SHORT_OFFSET_RUNS: [ShortOffsetRunHeader; 43] = [
         ShortOffsetRunHeader::new(0, 1632), ShortOffsetRunHeader::new(7, 2406),
         ShortOffsetRunHeader::new(13, 4160), ShortOffsetRunHeader::new(47, 4969),
         ShortOffsetRunHeader::new(51, 5870), ShortOffsetRunHeader::new(53, 6470),
@@ -590,16 +591,17 @@ pub mod n {
         ShortOffsetRunHeader::new(181, 69216), ShortOffsetRunHeader::new(187, 70736),
         ShortOffsetRunHeader::new(207, 71248), ShortOffsetRunHeader::new(211, 71904),
         ShortOffsetRunHeader::new(219, 72688), ShortOffsetRunHeader::new(223, 73552),
-        ShortOffsetRunHeader::new(231, 74752), ShortOffsetRunHeader::new(235, 90416),
-        ShortOffsetRunHeader::new(237, 92768), ShortOffsetRunHeader::new(239, 93552),
-        ShortOffsetRunHeader::new(247, 93824), ShortOffsetRunHeader::new(249, 118000),
-        ShortOffsetRunHeader::new(251, 119488), ShortOffsetRunHeader::new(253, 120782),
-        ShortOffsetRunHeader::new(259, 123200), ShortOffsetRunHeader::new(261, 123632),
-        ShortOffsetRunHeader::new(263, 124144), ShortOffsetRunHeader::new(265, 125127),
-        ShortOffsetRunHeader::new(269, 126065), ShortOffsetRunHeader::new(273, 127232),
-        ShortOffsetRunHeader::new(283, 130032), ShortOffsetRunHeader::new(285, 1244154),
+        ShortOffsetRunHeader::new(233, 74752), ShortOffsetRunHeader::new(237, 90416),
+        ShortOffsetRunHeader::new(239, 92768), ShortOffsetRunHeader::new(241, 93552),
+        ShortOffsetRunHeader::new(249, 93824), ShortOffsetRunHeader::new(251, 94196),
+        ShortOffsetRunHeader::new(253, 118000), ShortOffsetRunHeader::new(255, 119488),
+        ShortOffsetRunHeader::new(257, 120782), ShortOffsetRunHeader::new(263, 123200),
+        ShortOffsetRunHeader::new(265, 123632), ShortOffsetRunHeader::new(267, 124144),
+        ShortOffsetRunHeader::new(269, 125127), ShortOffsetRunHeader::new(273, 126065),
+        ShortOffsetRunHeader::new(277, 127232), ShortOffsetRunHeader::new(287, 130032),
+        ShortOffsetRunHeader::new(289, 1244154),
     ];
-    static OFFSETS: [u8; 287] = [
+    static OFFSETS: [u8; 291] = [
         178, 2, 5, 1, 2, 3, 0, 10, 134, 10, 198, 10, 0, 10, 118, 10, 4, 6, 108, 10, 118, 10, 118,
         10, 2, 6, 110, 13, 115, 10, 8, 7, 103, 10, 104, 7, 7, 19, 109, 10, 96, 10, 118, 10, 70, 20,
         0, 10, 70, 10, 0, 20, 0, 3, 239, 10, 6, 10, 22, 10, 0, 10, 128, 11, 165, 10, 6, 10, 182, 10,
@@ -609,9 +611,9 @@ pub mod n {
         1, 134, 5, 202, 10, 0, 8, 25, 7, 39, 9, 75, 5, 22, 6, 160, 2, 2, 16, 2, 46, 64, 9, 52, 2,
         30, 3, 75, 5, 104, 8, 24, 8, 41, 7, 0, 6, 48, 10, 6, 10, 0, 31, 158, 10, 42, 4, 112, 7, 134,
         30, 128, 10, 60, 10, 144, 10, 7, 20, 251, 10, 0, 10, 118, 10, 0, 10, 102, 10, 6, 20, 76, 12,
-        0, 19, 93, 10, 0, 10, 86, 29, 227, 10, 70, 10, 0, 10, 102, 21, 0, 111, 0, 10, 0, 10, 86, 10,
-        134, 10, 1, 7, 0, 10, 0, 23, 0, 10, 0, 20, 12, 20, 108, 25, 0, 50, 0, 10, 0, 10, 0, 10, 247,
-        10, 0, 9, 128, 10, 0, 59, 1, 3, 1, 4, 76, 45, 1, 15, 0, 13, 0, 10, 0,
+        0, 19, 93, 10, 0, 10, 86, 29, 227, 10, 70, 10, 54, 10, 0, 10, 102, 21, 0, 111, 0, 10, 0, 10,
+        86, 10, 134, 10, 1, 7, 0, 10, 0, 23, 0, 3, 0, 10, 0, 20, 12, 20, 108, 25, 0, 50, 0, 10, 0,
+        10, 0, 10, 247, 10, 0, 9, 128, 10, 0, 59, 1, 3, 1, 4, 76, 45, 1, 15, 0, 13, 0, 10, 0,
     ];
     #[inline]
     pub fn lookup(c: char) -> bool {
@@ -647,28 +649,28 @@ pub mod uppercase {
     static BITSET_INDEX_CHUNKS: [[u8; 16]; 17] = [
         [44, 44, 5, 35, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 5, 0],
         [44, 44, 5, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44],
-        [44, 44, 40, 44, 44, 44, 44, 44, 17, 17, 62, 17, 43, 29, 24, 23],
+        [44, 44, 40, 44, 44, 44, 44, 44, 17, 17, 66, 17, 43, 29, 24, 23],
         [44, 44, 44, 32, 36, 21, 22, 15, 13, 34, 44, 44, 44, 11, 30, 39],
         [44, 44, 44, 44, 9, 8, 45, 44, 44, 44, 44, 44, 44, 44, 44, 44],
-        [44, 44, 44, 44, 37, 28, 66, 44, 44, 44, 44, 44, 44, 44, 44, 44],
+        [44, 44, 44, 44, 37, 28, 67, 44, 44, 44, 44, 44, 44, 44, 44, 44],
         [44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44],
         [44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 57, 44, 44, 44],
-        [44, 44, 44, 44, 44, 44, 44, 44, 44, 49, 44, 44, 44, 44, 44, 44],
-        [44, 44, 44, 44, 44, 44, 44, 44, 44, 61, 60, 44, 20, 14, 16, 4],
+        [44, 44, 44, 44, 44, 44, 44, 44, 44, 49, 63, 44, 44, 44, 44, 44],
+        [44, 44, 44, 44, 44, 44, 44, 44, 44, 65, 64, 44, 20, 14, 16, 4],
         [44, 44, 44, 44, 50, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44],
         [44, 44, 53, 44, 44, 31, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44],
         [44, 44, 54, 46, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44],
         [51, 44, 9, 47, 44, 42, 33, 44, 44, 44, 44, 44, 44, 44, 44, 44],
-        [52, 19, 2, 18, 10, 48, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44],
+        [52, 19, 3, 18, 10, 48, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44],
         [52, 38, 17, 27, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44],
-        [58, 1, 26, 55, 12, 7, 25, 56, 41, 59, 6, 3, 65, 64, 63, 67],
+        [58, 1, 26, 55, 12, 7, 25, 56, 41, 59, 6, 2, 62, 61, 60, 68],
     ];
     static BITSET_CANONICAL: [u64; 44] = [
         0b0000000000111111111111111111111111111111111111111111111111111111,
         0b1111111111111111111111110000000000000000000000000011111111111111,
-        0b0101010101010101010101010101010101010101010101010101010000000001,
         0b0000011111111111111111111111110000000000000000000000000000000001,
-        0b0000000000100000000000000000000000010101010000010001101011110101,
+        0b0101010101010101010101010101010101010101010101010101010000000001,
+        0b0000000000100000000000000000000000010101010101010101101011110101,
         0b1111111111111111111111111111111100000000000000000000000000000000,
         0b1111111111111111111111110000000000000000000000000000001111111111,
         0b1111111111111111111100000000000000000000000000011111110001011111,
@@ -709,10 +711,10 @@ pub mod uppercase {
         0b1111011111111111000000000000000000000000000000000000000000000000,
         0b1111111100000000111111110000000000111111000000001111111100000000,
     ];
-    static BITSET_MAPPING: [(u8, u8); 24] = [
+    static BITSET_MAPPING: [(u8, u8); 25] = [
         (0, 182), (0, 74), (0, 166), (0, 162), (0, 159), (0, 150), (0, 148), (0, 142), (0, 134),
-        (0, 131), (0, 64), (1, 66), (1, 70), (1, 83), (1, 12), (1, 8), (2, 164), (2, 146), (2, 20),
-        (3, 146), (3, 140), (3, 134), (4, 178), (4, 171),
+        (0, 131), (0, 64), (1, 66), (1, 70), (1, 83), (1, 12), (1, 8), (2, 146), (2, 140), (2, 134),
+        (2, 130), (3, 164), (3, 146), (3, 20), (4, 178), (4, 171),
     ];
 
     pub const fn lookup(c: char) -> bool {
@@ -792,7 +794,7 @@ pub mod conversions {
         }
     }
 
-    static LOWERCASE_TABLE: &[(char, u32); 1434] = &[
+    static LOWERCASE_TABLE: &[(char, u32); 1462] = &[
         ('\u{c0}', 224), ('\u{c1}', 225), ('\u{c2}', 226), ('\u{c3}', 227), ('\u{c4}', 228),
         ('\u{c5}', 229), ('\u{c6}', 230), ('\u{c7}', 231), ('\u{c8}', 232), ('\u{c9}', 233),
         ('\u{ca}', 234), ('\u{cb}', 235), ('\u{cc}', 236), ('\u{cd}', 237), ('\u{ce}', 238),
@@ -1060,77 +1062,84 @@ pub mod conversions {
         ('\u{a7b4}', 42933), ('\u{a7b6}', 42935), ('\u{a7b8}', 42937), ('\u{a7ba}', 42939),
         ('\u{a7bc}', 42941), ('\u{a7be}', 42943), ('\u{a7c0}', 42945), ('\u{a7c2}', 42947),
         ('\u{a7c4}', 42900), ('\u{a7c5}', 642), ('\u{a7c6}', 7566), ('\u{a7c7}', 42952),
-        ('\u{a7c9}', 42954), ('\u{a7cb}', 612), ('\u{a7cc}', 42957), ('\u{a7d0}', 42961),
-        ('\u{a7d6}', 42967), ('\u{a7d8}', 42969), ('\u{a7da}', 42971), ('\u{a7dc}', 411),
-        ('\u{a7f5}', 42998), ('\u{ff21}', 65345), ('\u{ff22}', 65346), ('\u{ff23}', 65347),
-        ('\u{ff24}', 65348), ('\u{ff25}', 65349), ('\u{ff26}', 65350), ('\u{ff27}', 65351),
-        ('\u{ff28}', 65352), ('\u{ff29}', 65353), ('\u{ff2a}', 65354), ('\u{ff2b}', 65355),
-        ('\u{ff2c}', 65356), ('\u{ff2d}', 65357), ('\u{ff2e}', 65358), ('\u{ff2f}', 65359),
-        ('\u{ff30}', 65360), ('\u{ff31}', 65361), ('\u{ff32}', 65362), ('\u{ff33}', 65363),
-        ('\u{ff34}', 65364), ('\u{ff35}', 65365), ('\u{ff36}', 65366), ('\u{ff37}', 65367),
-        ('\u{ff38}', 65368), ('\u{ff39}', 65369), ('\u{ff3a}', 65370), ('\u{10400}', 66600),
-        ('\u{10401}', 66601), ('\u{10402}', 66602), ('\u{10403}', 66603), ('\u{10404}', 66604),
-        ('\u{10405}', 66605), ('\u{10406}', 66606), ('\u{10407}', 66607), ('\u{10408}', 66608),
-        ('\u{10409}', 66609), ('\u{1040a}', 66610), ('\u{1040b}', 66611), ('\u{1040c}', 66612),
-        ('\u{1040d}', 66613), ('\u{1040e}', 66614), ('\u{1040f}', 66615), ('\u{10410}', 66616),
-        ('\u{10411}', 66617), ('\u{10412}', 66618), ('\u{10413}', 66619), ('\u{10414}', 66620),
-        ('\u{10415}', 66621), ('\u{10416}', 66622), ('\u{10417}', 66623), ('\u{10418}', 66624),
-        ('\u{10419}', 66625), ('\u{1041a}', 66626), ('\u{1041b}', 66627), ('\u{1041c}', 66628),
-        ('\u{1041d}', 66629), ('\u{1041e}', 66630), ('\u{1041f}', 66631), ('\u{10420}', 66632),
-        ('\u{10421}', 66633), ('\u{10422}', 66634), ('\u{10423}', 66635), ('\u{10424}', 66636),
-        ('\u{10425}', 66637), ('\u{10426}', 66638), ('\u{10427}', 66639), ('\u{104b0}', 66776),
-        ('\u{104b1}', 66777), ('\u{104b2}', 66778), ('\u{104b3}', 66779), ('\u{104b4}', 66780),
-        ('\u{104b5}', 66781), ('\u{104b6}', 66782), ('\u{104b7}', 66783), ('\u{104b8}', 66784),
-        ('\u{104b9}', 66785), ('\u{104ba}', 66786), ('\u{104bb}', 66787), ('\u{104bc}', 66788),
-        ('\u{104bd}', 66789), ('\u{104be}', 66790), ('\u{104bf}', 66791), ('\u{104c0}', 66792),
-        ('\u{104c1}', 66793), ('\u{104c2}', 66794), ('\u{104c3}', 66795), ('\u{104c4}', 66796),
-        ('\u{104c5}', 66797), ('\u{104c6}', 66798), ('\u{104c7}', 66799), ('\u{104c8}', 66800),
-        ('\u{104c9}', 66801), ('\u{104ca}', 66802), ('\u{104cb}', 66803), ('\u{104cc}', 66804),
-        ('\u{104cd}', 66805), ('\u{104ce}', 66806), ('\u{104cf}', 66807), ('\u{104d0}', 66808),
-        ('\u{104d1}', 66809), ('\u{104d2}', 66810), ('\u{104d3}', 66811), ('\u{10570}', 66967),
-        ('\u{10571}', 66968), ('\u{10572}', 66969), ('\u{10573}', 66970), ('\u{10574}', 66971),
-        ('\u{10575}', 66972), ('\u{10576}', 66973), ('\u{10577}', 66974), ('\u{10578}', 66975),
-        ('\u{10579}', 66976), ('\u{1057a}', 66977), ('\u{1057c}', 66979), ('\u{1057d}', 66980),
-        ('\u{1057e}', 66981), ('\u{1057f}', 66982), ('\u{10580}', 66983), ('\u{10581}', 66984),
-        ('\u{10582}', 66985), ('\u{10583}', 66986), ('\u{10584}', 66987), ('\u{10585}', 66988),
-        ('\u{10586}', 66989), ('\u{10587}', 66990), ('\u{10588}', 66991), ('\u{10589}', 66992),
-        ('\u{1058a}', 66993), ('\u{1058c}', 66995), ('\u{1058d}', 66996), ('\u{1058e}', 66997),
-        ('\u{1058f}', 66998), ('\u{10590}', 66999), ('\u{10591}', 67000), ('\u{10592}', 67001),
-        ('\u{10594}', 67003), ('\u{10595}', 67004), ('\u{10c80}', 68800), ('\u{10c81}', 68801),
-        ('\u{10c82}', 68802), ('\u{10c83}', 68803), ('\u{10c84}', 68804), ('\u{10c85}', 68805),
-        ('\u{10c86}', 68806), ('\u{10c87}', 68807), ('\u{10c88}', 68808), ('\u{10c89}', 68809),
-        ('\u{10c8a}', 68810), ('\u{10c8b}', 68811), ('\u{10c8c}', 68812), ('\u{10c8d}', 68813),
-        ('\u{10c8e}', 68814), ('\u{10c8f}', 68815), ('\u{10c90}', 68816), ('\u{10c91}', 68817),
-        ('\u{10c92}', 68818), ('\u{10c93}', 68819), ('\u{10c94}', 68820), ('\u{10c95}', 68821),
-        ('\u{10c96}', 68822), ('\u{10c97}', 68823), ('\u{10c98}', 68824), ('\u{10c99}', 68825),
-        ('\u{10c9a}', 68826), ('\u{10c9b}', 68827), ('\u{10c9c}', 68828), ('\u{10c9d}', 68829),
-        ('\u{10c9e}', 68830), ('\u{10c9f}', 68831), ('\u{10ca0}', 68832), ('\u{10ca1}', 68833),
-        ('\u{10ca2}', 68834), ('\u{10ca3}', 68835), ('\u{10ca4}', 68836), ('\u{10ca5}', 68837),
-        ('\u{10ca6}', 68838), ('\u{10ca7}', 68839), ('\u{10ca8}', 68840), ('\u{10ca9}', 68841),
-        ('\u{10caa}', 68842), ('\u{10cab}', 68843), ('\u{10cac}', 68844), ('\u{10cad}', 68845),
-        ('\u{10cae}', 68846), ('\u{10caf}', 68847), ('\u{10cb0}', 68848), ('\u{10cb1}', 68849),
-        ('\u{10cb2}', 68850), ('\u{10d50}', 68976), ('\u{10d51}', 68977), ('\u{10d52}', 68978),
-        ('\u{10d53}', 68979), ('\u{10d54}', 68980), ('\u{10d55}', 68981), ('\u{10d56}', 68982),
-        ('\u{10d57}', 68983), ('\u{10d58}', 68984), ('\u{10d59}', 68985), ('\u{10d5a}', 68986),
-        ('\u{10d5b}', 68987), ('\u{10d5c}', 68988), ('\u{10d5d}', 68989), ('\u{10d5e}', 68990),
-        ('\u{10d5f}', 68991), ('\u{10d60}', 68992), ('\u{10d61}', 68993), ('\u{10d62}', 68994),
-        ('\u{10d63}', 68995), ('\u{10d64}', 68996), ('\u{10d65}', 68997), ('\u{118a0}', 71872),
-        ('\u{118a1}', 71873), ('\u{118a2}', 71874), ('\u{118a3}', 71875), ('\u{118a4}', 71876),
-        ('\u{118a5}', 71877), ('\u{118a6}', 71878), ('\u{118a7}', 71879), ('\u{118a8}', 71880),
-        ('\u{118a9}', 71881), ('\u{118aa}', 71882), ('\u{118ab}', 71883), ('\u{118ac}', 71884),
-        ('\u{118ad}', 71885), ('\u{118ae}', 71886), ('\u{118af}', 71887), ('\u{118b0}', 71888),
-        ('\u{118b1}', 71889), ('\u{118b2}', 71890), ('\u{118b3}', 71891), ('\u{118b4}', 71892),
-        ('\u{118b5}', 71893), ('\u{118b6}', 71894), ('\u{118b7}', 71895), ('\u{118b8}', 71896),
-        ('\u{118b9}', 71897), ('\u{118ba}', 71898), ('\u{118bb}', 71899), ('\u{118bc}', 71900),
-        ('\u{118bd}', 71901), ('\u{118be}', 71902), ('\u{118bf}', 71903), ('\u{16e40}', 93792),
-        ('\u{16e41}', 93793), ('\u{16e42}', 93794), ('\u{16e43}', 93795), ('\u{16e44}', 93796),
-        ('\u{16e45}', 93797), ('\u{16e46}', 93798), ('\u{16e47}', 93799), ('\u{16e48}', 93800),
-        ('\u{16e49}', 93801), ('\u{16e4a}', 93802), ('\u{16e4b}', 93803), ('\u{16e4c}', 93804),
-        ('\u{16e4d}', 93805), ('\u{16e4e}', 93806), ('\u{16e4f}', 93807), ('\u{16e50}', 93808),
-        ('\u{16e51}', 93809), ('\u{16e52}', 93810), ('\u{16e53}', 93811), ('\u{16e54}', 93812),
-        ('\u{16e55}', 93813), ('\u{16e56}', 93814), ('\u{16e57}', 93815), ('\u{16e58}', 93816),
-        ('\u{16e59}', 93817), ('\u{16e5a}', 93818), ('\u{16e5b}', 93819), ('\u{16e5c}', 93820),
-        ('\u{16e5d}', 93821), ('\u{16e5e}', 93822), ('\u{16e5f}', 93823), ('\u{1e900}', 125218),
+        ('\u{a7c9}', 42954), ('\u{a7cb}', 612), ('\u{a7cc}', 42957), ('\u{a7ce}', 42959),
+        ('\u{a7d0}', 42961), ('\u{a7d2}', 42963), ('\u{a7d4}', 42965), ('\u{a7d6}', 42967),
+        ('\u{a7d8}', 42969), ('\u{a7da}', 42971), ('\u{a7dc}', 411), ('\u{a7f5}', 42998),
+        ('\u{ff21}', 65345), ('\u{ff22}', 65346), ('\u{ff23}', 65347), ('\u{ff24}', 65348),
+        ('\u{ff25}', 65349), ('\u{ff26}', 65350), ('\u{ff27}', 65351), ('\u{ff28}', 65352),
+        ('\u{ff29}', 65353), ('\u{ff2a}', 65354), ('\u{ff2b}', 65355), ('\u{ff2c}', 65356),
+        ('\u{ff2d}', 65357), ('\u{ff2e}', 65358), ('\u{ff2f}', 65359), ('\u{ff30}', 65360),
+        ('\u{ff31}', 65361), ('\u{ff32}', 65362), ('\u{ff33}', 65363), ('\u{ff34}', 65364),
+        ('\u{ff35}', 65365), ('\u{ff36}', 65366), ('\u{ff37}', 65367), ('\u{ff38}', 65368),
+        ('\u{ff39}', 65369), ('\u{ff3a}', 65370), ('\u{10400}', 66600), ('\u{10401}', 66601),
+        ('\u{10402}', 66602), ('\u{10403}', 66603), ('\u{10404}', 66604), ('\u{10405}', 66605),
+        ('\u{10406}', 66606), ('\u{10407}', 66607), ('\u{10408}', 66608), ('\u{10409}', 66609),
+        ('\u{1040a}', 66610), ('\u{1040b}', 66611), ('\u{1040c}', 66612), ('\u{1040d}', 66613),
+        ('\u{1040e}', 66614), ('\u{1040f}', 66615), ('\u{10410}', 66616), ('\u{10411}', 66617),
+        ('\u{10412}', 66618), ('\u{10413}', 66619), ('\u{10414}', 66620), ('\u{10415}', 66621),
+        ('\u{10416}', 66622), ('\u{10417}', 66623), ('\u{10418}', 66624), ('\u{10419}', 66625),
+        ('\u{1041a}', 66626), ('\u{1041b}', 66627), ('\u{1041c}', 66628), ('\u{1041d}', 66629),
+        ('\u{1041e}', 66630), ('\u{1041f}', 66631), ('\u{10420}', 66632), ('\u{10421}', 66633),
+        ('\u{10422}', 66634), ('\u{10423}', 66635), ('\u{10424}', 66636), ('\u{10425}', 66637),
+        ('\u{10426}', 66638), ('\u{10427}', 66639), ('\u{104b0}', 66776), ('\u{104b1}', 66777),
+        ('\u{104b2}', 66778), ('\u{104b3}', 66779), ('\u{104b4}', 66780), ('\u{104b5}', 66781),
+        ('\u{104b6}', 66782), ('\u{104b7}', 66783), ('\u{104b8}', 66784), ('\u{104b9}', 66785),
+        ('\u{104ba}', 66786), ('\u{104bb}', 66787), ('\u{104bc}', 66788), ('\u{104bd}', 66789),
+        ('\u{104be}', 66790), ('\u{104bf}', 66791), ('\u{104c0}', 66792), ('\u{104c1}', 66793),
+        ('\u{104c2}', 66794), ('\u{104c3}', 66795), ('\u{104c4}', 66796), ('\u{104c5}', 66797),
+        ('\u{104c6}', 66798), ('\u{104c7}', 66799), ('\u{104c8}', 66800), ('\u{104c9}', 66801),
+        ('\u{104ca}', 66802), ('\u{104cb}', 66803), ('\u{104cc}', 66804), ('\u{104cd}', 66805),
+        ('\u{104ce}', 66806), ('\u{104cf}', 66807), ('\u{104d0}', 66808), ('\u{104d1}', 66809),
+        ('\u{104d2}', 66810), ('\u{104d3}', 66811), ('\u{10570}', 66967), ('\u{10571}', 66968),
+        ('\u{10572}', 66969), ('\u{10573}', 66970), ('\u{10574}', 66971), ('\u{10575}', 66972),
+        ('\u{10576}', 66973), ('\u{10577}', 66974), ('\u{10578}', 66975), ('\u{10579}', 66976),
+        ('\u{1057a}', 66977), ('\u{1057c}', 66979), ('\u{1057d}', 66980), ('\u{1057e}', 66981),
+        ('\u{1057f}', 66982), ('\u{10580}', 66983), ('\u{10581}', 66984), ('\u{10582}', 66985),
+        ('\u{10583}', 66986), ('\u{10584}', 66987), ('\u{10585}', 66988), ('\u{10586}', 66989),
+        ('\u{10587}', 66990), ('\u{10588}', 66991), ('\u{10589}', 66992), ('\u{1058a}', 66993),
+        ('\u{1058c}', 66995), ('\u{1058d}', 66996), ('\u{1058e}', 66997), ('\u{1058f}', 66998),
+        ('\u{10590}', 66999), ('\u{10591}', 67000), ('\u{10592}', 67001), ('\u{10594}', 67003),
+        ('\u{10595}', 67004), ('\u{10c80}', 68800), ('\u{10c81}', 68801), ('\u{10c82}', 68802),
+        ('\u{10c83}', 68803), ('\u{10c84}', 68804), ('\u{10c85}', 68805), ('\u{10c86}', 68806),
+        ('\u{10c87}', 68807), ('\u{10c88}', 68808), ('\u{10c89}', 68809), ('\u{10c8a}', 68810),
+        ('\u{10c8b}', 68811), ('\u{10c8c}', 68812), ('\u{10c8d}', 68813), ('\u{10c8e}', 68814),
+        ('\u{10c8f}', 68815), ('\u{10c90}', 68816), ('\u{10c91}', 68817), ('\u{10c92}', 68818),
+        ('\u{10c93}', 68819), ('\u{10c94}', 68820), ('\u{10c95}', 68821), ('\u{10c96}', 68822),
+        ('\u{10c97}', 68823), ('\u{10c98}', 68824), ('\u{10c99}', 68825), ('\u{10c9a}', 68826),
+        ('\u{10c9b}', 68827), ('\u{10c9c}', 68828), ('\u{10c9d}', 68829), ('\u{10c9e}', 68830),
+        ('\u{10c9f}', 68831), ('\u{10ca0}', 68832), ('\u{10ca1}', 68833), ('\u{10ca2}', 68834),
+        ('\u{10ca3}', 68835), ('\u{10ca4}', 68836), ('\u{10ca5}', 68837), ('\u{10ca6}', 68838),
+        ('\u{10ca7}', 68839), ('\u{10ca8}', 68840), ('\u{10ca9}', 68841), ('\u{10caa}', 68842),
+        ('\u{10cab}', 68843), ('\u{10cac}', 68844), ('\u{10cad}', 68845), ('\u{10cae}', 68846),
+        ('\u{10caf}', 68847), ('\u{10cb0}', 68848), ('\u{10cb1}', 68849), ('\u{10cb2}', 68850),
+        ('\u{10d50}', 68976), ('\u{10d51}', 68977), ('\u{10d52}', 68978), ('\u{10d53}', 68979),
+        ('\u{10d54}', 68980), ('\u{10d55}', 68981), ('\u{10d56}', 68982), ('\u{10d57}', 68983),
+        ('\u{10d58}', 68984), ('\u{10d59}', 68985), ('\u{10d5a}', 68986), ('\u{10d5b}', 68987),
+        ('\u{10d5c}', 68988), ('\u{10d5d}', 68989), ('\u{10d5e}', 68990), ('\u{10d5f}', 68991),
+        ('\u{10d60}', 68992), ('\u{10d61}', 68993), ('\u{10d62}', 68994), ('\u{10d63}', 68995),
+        ('\u{10d64}', 68996), ('\u{10d65}', 68997), ('\u{118a0}', 71872), ('\u{118a1}', 71873),
+        ('\u{118a2}', 71874), ('\u{118a3}', 71875), ('\u{118a4}', 71876), ('\u{118a5}', 71877),
+        ('\u{118a6}', 71878), ('\u{118a7}', 71879), ('\u{118a8}', 71880), ('\u{118a9}', 71881),
+        ('\u{118aa}', 71882), ('\u{118ab}', 71883), ('\u{118ac}', 71884), ('\u{118ad}', 71885),
+        ('\u{118ae}', 71886), ('\u{118af}', 71887), ('\u{118b0}', 71888), ('\u{118b1}', 71889),
+        ('\u{118b2}', 71890), ('\u{118b3}', 71891), ('\u{118b4}', 71892), ('\u{118b5}', 71893),
+        ('\u{118b6}', 71894), ('\u{118b7}', 71895), ('\u{118b8}', 71896), ('\u{118b9}', 71897),
+        ('\u{118ba}', 71898), ('\u{118bb}', 71899), ('\u{118bc}', 71900), ('\u{118bd}', 71901),
+        ('\u{118be}', 71902), ('\u{118bf}', 71903), ('\u{16e40}', 93792), ('\u{16e41}', 93793),
+        ('\u{16e42}', 93794), ('\u{16e43}', 93795), ('\u{16e44}', 93796), ('\u{16e45}', 93797),
+        ('\u{16e46}', 93798), ('\u{16e47}', 93799), ('\u{16e48}', 93800), ('\u{16e49}', 93801),
+        ('\u{16e4a}', 93802), ('\u{16e4b}', 93803), ('\u{16e4c}', 93804), ('\u{16e4d}', 93805),
+        ('\u{16e4e}', 93806), ('\u{16e4f}', 93807), ('\u{16e50}', 93808), ('\u{16e51}', 93809),
+        ('\u{16e52}', 93810), ('\u{16e53}', 93811), ('\u{16e54}', 93812), ('\u{16e55}', 93813),
+        ('\u{16e56}', 93814), ('\u{16e57}', 93815), ('\u{16e58}', 93816), ('\u{16e59}', 93817),
+        ('\u{16e5a}', 93818), ('\u{16e5b}', 93819), ('\u{16e5c}', 93820), ('\u{16e5d}', 93821),
+        ('\u{16e5e}', 93822), ('\u{16e5f}', 93823), ('\u{16ea0}', 93883), ('\u{16ea1}', 93884),
+        ('\u{16ea2}', 93885), ('\u{16ea3}', 93886), ('\u{16ea4}', 93887), ('\u{16ea5}', 93888),
+        ('\u{16ea6}', 93889), ('\u{16ea7}', 93890), ('\u{16ea8}', 93891), ('\u{16ea9}', 93892),
+        ('\u{16eaa}', 93893), ('\u{16eab}', 93894), ('\u{16eac}', 93895), ('\u{16ead}', 93896),
+        ('\u{16eae}', 93897), ('\u{16eaf}', 93898), ('\u{16eb0}', 93899), ('\u{16eb1}', 93900),
+        ('\u{16eb2}', 93901), ('\u{16eb3}', 93902), ('\u{16eb4}', 93903), ('\u{16eb5}', 93904),
+        ('\u{16eb6}', 93905), ('\u{16eb7}', 93906), ('\u{16eb8}', 93907), ('\u{1e900}', 125218),
         ('\u{1e901}', 125219), ('\u{1e902}', 125220), ('\u{1e903}', 125221), ('\u{1e904}', 125222),
         ('\u{1e905}', 125223), ('\u{1e906}', 125224), ('\u{1e907}', 125225), ('\u{1e908}', 125226),
         ('\u{1e909}', 125227), ('\u{1e90a}', 125228), ('\u{1e90b}', 125229), ('\u{1e90c}', 125230),
@@ -1146,7 +1155,7 @@ pub mod conversions {
         ['i', '\u{307}', '\u{0}'],
     ];
 
-    static UPPERCASE_TABLE: &[(char, u32); 1526] = &[
+    static UPPERCASE_TABLE: &[(char, u32); 1554] = &[
         ('\u{b5}', 924), ('\u{df}', 4194304), ('\u{e0}', 192), ('\u{e1}', 193), ('\u{e2}', 194),
         ('\u{e3}', 195), ('\u{e4}', 196), ('\u{e5}', 197), ('\u{e6}', 198), ('\u{e7}', 199),
         ('\u{e8}', 200), ('\u{e9}', 201), ('\u{ea}', 202), ('\u{eb}', 203), ('\u{ec}', 204),
@@ -1415,100 +1424,107 @@ pub mod conversions {
         ('\u{a7a7}', 42918), ('\u{a7a9}', 42920), ('\u{a7b5}', 42932), ('\u{a7b7}', 42934),
         ('\u{a7b9}', 42936), ('\u{a7bb}', 42938), ('\u{a7bd}', 42940), ('\u{a7bf}', 42942),
         ('\u{a7c1}', 42944), ('\u{a7c3}', 42946), ('\u{a7c8}', 42951), ('\u{a7ca}', 42953),
-        ('\u{a7cd}', 42956), ('\u{a7d1}', 42960), ('\u{a7d7}', 42966), ('\u{a7d9}', 42968),
-        ('\u{a7db}', 42970), ('\u{a7f6}', 42997), ('\u{ab53}', 42931), ('\u{ab70}', 5024),
-        ('\u{ab71}', 5025), ('\u{ab72}', 5026), ('\u{ab73}', 5027), ('\u{ab74}', 5028),
-        ('\u{ab75}', 5029), ('\u{ab76}', 5030), ('\u{ab77}', 5031), ('\u{ab78}', 5032),
-        ('\u{ab79}', 5033), ('\u{ab7a}', 5034), ('\u{ab7b}', 5035), ('\u{ab7c}', 5036),
-        ('\u{ab7d}', 5037), ('\u{ab7e}', 5038), ('\u{ab7f}', 5039), ('\u{ab80}', 5040),
-        ('\u{ab81}', 5041), ('\u{ab82}', 5042), ('\u{ab83}', 5043), ('\u{ab84}', 5044),
-        ('\u{ab85}', 5045), ('\u{ab86}', 5046), ('\u{ab87}', 5047), ('\u{ab88}', 5048),
-        ('\u{ab89}', 5049), ('\u{ab8a}', 5050), ('\u{ab8b}', 5051), ('\u{ab8c}', 5052),
-        ('\u{ab8d}', 5053), ('\u{ab8e}', 5054), ('\u{ab8f}', 5055), ('\u{ab90}', 5056),
-        ('\u{ab91}', 5057), ('\u{ab92}', 5058), ('\u{ab93}', 5059), ('\u{ab94}', 5060),
-        ('\u{ab95}', 5061), ('\u{ab96}', 5062), ('\u{ab97}', 5063), ('\u{ab98}', 5064),
-        ('\u{ab99}', 5065), ('\u{ab9a}', 5066), ('\u{ab9b}', 5067), ('\u{ab9c}', 5068),
-        ('\u{ab9d}', 5069), ('\u{ab9e}', 5070), ('\u{ab9f}', 5071), ('\u{aba0}', 5072),
-        ('\u{aba1}', 5073), ('\u{aba2}', 5074), ('\u{aba3}', 5075), ('\u{aba4}', 5076),
-        ('\u{aba5}', 5077), ('\u{aba6}', 5078), ('\u{aba7}', 5079), ('\u{aba8}', 5080),
-        ('\u{aba9}', 5081), ('\u{abaa}', 5082), ('\u{abab}', 5083), ('\u{abac}', 5084),
-        ('\u{abad}', 5085), ('\u{abae}', 5086), ('\u{abaf}', 5087), ('\u{abb0}', 5088),
-        ('\u{abb1}', 5089), ('\u{abb2}', 5090), ('\u{abb3}', 5091), ('\u{abb4}', 5092),
-        ('\u{abb5}', 5093), ('\u{abb6}', 5094), ('\u{abb7}', 5095), ('\u{abb8}', 5096),
-        ('\u{abb9}', 5097), ('\u{abba}', 5098), ('\u{abbb}', 5099), ('\u{abbc}', 5100),
-        ('\u{abbd}', 5101), ('\u{abbe}', 5102), ('\u{abbf}', 5103), ('\u{fb00}', 4194394),
-        ('\u{fb01}', 4194395), ('\u{fb02}', 4194396), ('\u{fb03}', 4194397), ('\u{fb04}', 4194398),
-        ('\u{fb05}', 4194399), ('\u{fb06}', 4194400), ('\u{fb13}', 4194401), ('\u{fb14}', 4194402),
-        ('\u{fb15}', 4194403), ('\u{fb16}', 4194404), ('\u{fb17}', 4194405), ('\u{ff41}', 65313),
-        ('\u{ff42}', 65314), ('\u{ff43}', 65315), ('\u{ff44}', 65316), ('\u{ff45}', 65317),
-        ('\u{ff46}', 65318), ('\u{ff47}', 65319), ('\u{ff48}', 65320), ('\u{ff49}', 65321),
-        ('\u{ff4a}', 65322), ('\u{ff4b}', 65323), ('\u{ff4c}', 65324), ('\u{ff4d}', 65325),
-        ('\u{ff4e}', 65326), ('\u{ff4f}', 65327), ('\u{ff50}', 65328), ('\u{ff51}', 65329),
-        ('\u{ff52}', 65330), ('\u{ff53}', 65331), ('\u{ff54}', 65332), ('\u{ff55}', 65333),
-        ('\u{ff56}', 65334), ('\u{ff57}', 65335), ('\u{ff58}', 65336), ('\u{ff59}', 65337),
-        ('\u{ff5a}', 65338), ('\u{10428}', 66560), ('\u{10429}', 66561), ('\u{1042a}', 66562),
-        ('\u{1042b}', 66563), ('\u{1042c}', 66564), ('\u{1042d}', 66565), ('\u{1042e}', 66566),
-        ('\u{1042f}', 66567), ('\u{10430}', 66568), ('\u{10431}', 66569), ('\u{10432}', 66570),
-        ('\u{10433}', 66571), ('\u{10434}', 66572), ('\u{10435}', 66573), ('\u{10436}', 66574),
-        ('\u{10437}', 66575), ('\u{10438}', 66576), ('\u{10439}', 66577), ('\u{1043a}', 66578),
-        ('\u{1043b}', 66579), ('\u{1043c}', 66580), ('\u{1043d}', 66581), ('\u{1043e}', 66582),
-        ('\u{1043f}', 66583), ('\u{10440}', 66584), ('\u{10441}', 66585), ('\u{10442}', 66586),
-        ('\u{10443}', 66587), ('\u{10444}', 66588), ('\u{10445}', 66589), ('\u{10446}', 66590),
-        ('\u{10447}', 66591), ('\u{10448}', 66592), ('\u{10449}', 66593), ('\u{1044a}', 66594),
-        ('\u{1044b}', 66595), ('\u{1044c}', 66596), ('\u{1044d}', 66597), ('\u{1044e}', 66598),
-        ('\u{1044f}', 66599), ('\u{104d8}', 66736), ('\u{104d9}', 66737), ('\u{104da}', 66738),
-        ('\u{104db}', 66739), ('\u{104dc}', 66740), ('\u{104dd}', 66741), ('\u{104de}', 66742),
-        ('\u{104df}', 66743), ('\u{104e0}', 66744), ('\u{104e1}', 66745), ('\u{104e2}', 66746),
-        ('\u{104e3}', 66747), ('\u{104e4}', 66748), ('\u{104e5}', 66749), ('\u{104e6}', 66750),
-        ('\u{104e7}', 66751), ('\u{104e8}', 66752), ('\u{104e9}', 66753), ('\u{104ea}', 66754),
-        ('\u{104eb}', 66755), ('\u{104ec}', 66756), ('\u{104ed}', 66757), ('\u{104ee}', 66758),
-        ('\u{104ef}', 66759), ('\u{104f0}', 66760), ('\u{104f1}', 66761), ('\u{104f2}', 66762),
-        ('\u{104f3}', 66763), ('\u{104f4}', 66764), ('\u{104f5}', 66765), ('\u{104f6}', 66766),
-        ('\u{104f7}', 66767), ('\u{104f8}', 66768), ('\u{104f9}', 66769), ('\u{104fa}', 66770),
-        ('\u{104fb}', 66771), ('\u{10597}', 66928), ('\u{10598}', 66929), ('\u{10599}', 66930),
-        ('\u{1059a}', 66931), ('\u{1059b}', 66932), ('\u{1059c}', 66933), ('\u{1059d}', 66934),
-        ('\u{1059e}', 66935), ('\u{1059f}', 66936), ('\u{105a0}', 66937), ('\u{105a1}', 66938),
-        ('\u{105a3}', 66940), ('\u{105a4}', 66941), ('\u{105a5}', 66942), ('\u{105a6}', 66943),
-        ('\u{105a7}', 66944), ('\u{105a8}', 66945), ('\u{105a9}', 66946), ('\u{105aa}', 66947),
-        ('\u{105ab}', 66948), ('\u{105ac}', 66949), ('\u{105ad}', 66950), ('\u{105ae}', 66951),
-        ('\u{105af}', 66952), ('\u{105b0}', 66953), ('\u{105b1}', 66954), ('\u{105b3}', 66956),
-        ('\u{105b4}', 66957), ('\u{105b5}', 66958), ('\u{105b6}', 66959), ('\u{105b7}', 66960),
-        ('\u{105b8}', 66961), ('\u{105b9}', 66962), ('\u{105bb}', 66964), ('\u{105bc}', 66965),
-        ('\u{10cc0}', 68736), ('\u{10cc1}', 68737), ('\u{10cc2}', 68738), ('\u{10cc3}', 68739),
-        ('\u{10cc4}', 68740), ('\u{10cc5}', 68741), ('\u{10cc6}', 68742), ('\u{10cc7}', 68743),
-        ('\u{10cc8}', 68744), ('\u{10cc9}', 68745), ('\u{10cca}', 68746), ('\u{10ccb}', 68747),
-        ('\u{10ccc}', 68748), ('\u{10ccd}', 68749), ('\u{10cce}', 68750), ('\u{10ccf}', 68751),
-        ('\u{10cd0}', 68752), ('\u{10cd1}', 68753), ('\u{10cd2}', 68754), ('\u{10cd3}', 68755),
-        ('\u{10cd4}', 68756), ('\u{10cd5}', 68757), ('\u{10cd6}', 68758), ('\u{10cd7}', 68759),
-        ('\u{10cd8}', 68760), ('\u{10cd9}', 68761), ('\u{10cda}', 68762), ('\u{10cdb}', 68763),
-        ('\u{10cdc}', 68764), ('\u{10cdd}', 68765), ('\u{10cde}', 68766), ('\u{10cdf}', 68767),
-        ('\u{10ce0}', 68768), ('\u{10ce1}', 68769), ('\u{10ce2}', 68770), ('\u{10ce3}', 68771),
-        ('\u{10ce4}', 68772), ('\u{10ce5}', 68773), ('\u{10ce6}', 68774), ('\u{10ce7}', 68775),
-        ('\u{10ce8}', 68776), ('\u{10ce9}', 68777), ('\u{10cea}', 68778), ('\u{10ceb}', 68779),
-        ('\u{10cec}', 68780), ('\u{10ced}', 68781), ('\u{10cee}', 68782), ('\u{10cef}', 68783),
-        ('\u{10cf0}', 68784), ('\u{10cf1}', 68785), ('\u{10cf2}', 68786), ('\u{10d70}', 68944),
-        ('\u{10d71}', 68945), ('\u{10d72}', 68946), ('\u{10d73}', 68947), ('\u{10d74}', 68948),
-        ('\u{10d75}', 68949), ('\u{10d76}', 68950), ('\u{10d77}', 68951), ('\u{10d78}', 68952),
-        ('\u{10d79}', 68953), ('\u{10d7a}', 68954), ('\u{10d7b}', 68955), ('\u{10d7c}', 68956),
-        ('\u{10d7d}', 68957), ('\u{10d7e}', 68958), ('\u{10d7f}', 68959), ('\u{10d80}', 68960),
-        ('\u{10d81}', 68961), ('\u{10d82}', 68962), ('\u{10d83}', 68963), ('\u{10d84}', 68964),
-        ('\u{10d85}', 68965), ('\u{118c0}', 71840), ('\u{118c1}', 71841), ('\u{118c2}', 71842),
-        ('\u{118c3}', 71843), ('\u{118c4}', 71844), ('\u{118c5}', 71845), ('\u{118c6}', 71846),
-        ('\u{118c7}', 71847), ('\u{118c8}', 71848), ('\u{118c9}', 71849), ('\u{118ca}', 71850),
-        ('\u{118cb}', 71851), ('\u{118cc}', 71852), ('\u{118cd}', 71853), ('\u{118ce}', 71854),
-        ('\u{118cf}', 71855), ('\u{118d0}', 71856), ('\u{118d1}', 71857), ('\u{118d2}', 71858),
-        ('\u{118d3}', 71859), ('\u{118d4}', 71860), ('\u{118d5}', 71861), ('\u{118d6}', 71862),
-        ('\u{118d7}', 71863), ('\u{118d8}', 71864), ('\u{118d9}', 71865), ('\u{118da}', 71866),
-        ('\u{118db}', 71867), ('\u{118dc}', 71868), ('\u{118dd}', 71869), ('\u{118de}', 71870),
-        ('\u{118df}', 71871), ('\u{16e60}', 93760), ('\u{16e61}', 93761), ('\u{16e62}', 93762),
-        ('\u{16e63}', 93763), ('\u{16e64}', 93764), ('\u{16e65}', 93765), ('\u{16e66}', 93766),
-        ('\u{16e67}', 93767), ('\u{16e68}', 93768), ('\u{16e69}', 93769), ('\u{16e6a}', 93770),
-        ('\u{16e6b}', 93771), ('\u{16e6c}', 93772), ('\u{16e6d}', 93773), ('\u{16e6e}', 93774),
-        ('\u{16e6f}', 93775), ('\u{16e70}', 93776), ('\u{16e71}', 93777), ('\u{16e72}', 93778),
-        ('\u{16e73}', 93779), ('\u{16e74}', 93780), ('\u{16e75}', 93781), ('\u{16e76}', 93782),
-        ('\u{16e77}', 93783), ('\u{16e78}', 93784), ('\u{16e79}', 93785), ('\u{16e7a}', 93786),
-        ('\u{16e7b}', 93787), ('\u{16e7c}', 93788), ('\u{16e7d}', 93789), ('\u{16e7e}', 93790),
-        ('\u{16e7f}', 93791), ('\u{1e922}', 125184), ('\u{1e923}', 125185), ('\u{1e924}', 125186),
+        ('\u{a7cd}', 42956), ('\u{a7cf}', 42958), ('\u{a7d1}', 42960), ('\u{a7d3}', 42962),
+        ('\u{a7d5}', 42964), ('\u{a7d7}', 42966), ('\u{a7d9}', 42968), ('\u{a7db}', 42970),
+        ('\u{a7f6}', 42997), ('\u{ab53}', 42931), ('\u{ab70}', 5024), ('\u{ab71}', 5025),
+        ('\u{ab72}', 5026), ('\u{ab73}', 5027), ('\u{ab74}', 5028), ('\u{ab75}', 5029),
+        ('\u{ab76}', 5030), ('\u{ab77}', 5031), ('\u{ab78}', 5032), ('\u{ab79}', 5033),
+        ('\u{ab7a}', 5034), ('\u{ab7b}', 5035), ('\u{ab7c}', 5036), ('\u{ab7d}', 5037),
+        ('\u{ab7e}', 5038), ('\u{ab7f}', 5039), ('\u{ab80}', 5040), ('\u{ab81}', 5041),
+        ('\u{ab82}', 5042), ('\u{ab83}', 5043), ('\u{ab84}', 5044), ('\u{ab85}', 5045),
+        ('\u{ab86}', 5046), ('\u{ab87}', 5047), ('\u{ab88}', 5048), ('\u{ab89}', 5049),
+        ('\u{ab8a}', 5050), ('\u{ab8b}', 5051), ('\u{ab8c}', 5052), ('\u{ab8d}', 5053),
+        ('\u{ab8e}', 5054), ('\u{ab8f}', 5055), ('\u{ab90}', 5056), ('\u{ab91}', 5057),
+        ('\u{ab92}', 5058), ('\u{ab93}', 5059), ('\u{ab94}', 5060), ('\u{ab95}', 5061),
+        ('\u{ab96}', 5062), ('\u{ab97}', 5063), ('\u{ab98}', 5064), ('\u{ab99}', 5065),
+        ('\u{ab9a}', 5066), ('\u{ab9b}', 5067), ('\u{ab9c}', 5068), ('\u{ab9d}', 5069),
+        ('\u{ab9e}', 5070), ('\u{ab9f}', 5071), ('\u{aba0}', 5072), ('\u{aba1}', 5073),
+        ('\u{aba2}', 5074), ('\u{aba3}', 5075), ('\u{aba4}', 5076), ('\u{aba5}', 5077),
+        ('\u{aba6}', 5078), ('\u{aba7}', 5079), ('\u{aba8}', 5080), ('\u{aba9}', 5081),
+        ('\u{abaa}', 5082), ('\u{abab}', 5083), ('\u{abac}', 5084), ('\u{abad}', 5085),
+        ('\u{abae}', 5086), ('\u{abaf}', 5087), ('\u{abb0}', 5088), ('\u{abb1}', 5089),
+        ('\u{abb2}', 5090), ('\u{abb3}', 5091), ('\u{abb4}', 5092), ('\u{abb5}', 5093),
+        ('\u{abb6}', 5094), ('\u{abb7}', 5095), ('\u{abb8}', 5096), ('\u{abb9}', 5097),
+        ('\u{abba}', 5098), ('\u{abbb}', 5099), ('\u{abbc}', 5100), ('\u{abbd}', 5101),
+        ('\u{abbe}', 5102), ('\u{abbf}', 5103), ('\u{fb00}', 4194394), ('\u{fb01}', 4194395),
+        ('\u{fb02}', 4194396), ('\u{fb03}', 4194397), ('\u{fb04}', 4194398), ('\u{fb05}', 4194399),
+        ('\u{fb06}', 4194400), ('\u{fb13}', 4194401), ('\u{fb14}', 4194402), ('\u{fb15}', 4194403),
+        ('\u{fb16}', 4194404), ('\u{fb17}', 4194405), ('\u{ff41}', 65313), ('\u{ff42}', 65314),
+        ('\u{ff43}', 65315), ('\u{ff44}', 65316), ('\u{ff45}', 65317), ('\u{ff46}', 65318),
+        ('\u{ff47}', 65319), ('\u{ff48}', 65320), ('\u{ff49}', 65321), ('\u{ff4a}', 65322),
+        ('\u{ff4b}', 65323), ('\u{ff4c}', 65324), ('\u{ff4d}', 65325), ('\u{ff4e}', 65326),
+        ('\u{ff4f}', 65327), ('\u{ff50}', 65328), ('\u{ff51}', 65329), ('\u{ff52}', 65330),
+        ('\u{ff53}', 65331), ('\u{ff54}', 65332), ('\u{ff55}', 65333), ('\u{ff56}', 65334),
+        ('\u{ff57}', 65335), ('\u{ff58}', 65336), ('\u{ff59}', 65337), ('\u{ff5a}', 65338),
+        ('\u{10428}', 66560), ('\u{10429}', 66561), ('\u{1042a}', 66562), ('\u{1042b}', 66563),
+        ('\u{1042c}', 66564), ('\u{1042d}', 66565), ('\u{1042e}', 66566), ('\u{1042f}', 66567),
+        ('\u{10430}', 66568), ('\u{10431}', 66569), ('\u{10432}', 66570), ('\u{10433}', 66571),
+        ('\u{10434}', 66572), ('\u{10435}', 66573), ('\u{10436}', 66574), ('\u{10437}', 66575),
+        ('\u{10438}', 66576), ('\u{10439}', 66577), ('\u{1043a}', 66578), ('\u{1043b}', 66579),
+        ('\u{1043c}', 66580), ('\u{1043d}', 66581), ('\u{1043e}', 66582), ('\u{1043f}', 66583),
+        ('\u{10440}', 66584), ('\u{10441}', 66585), ('\u{10442}', 66586), ('\u{10443}', 66587),
+        ('\u{10444}', 66588), ('\u{10445}', 66589), ('\u{10446}', 66590), ('\u{10447}', 66591),
+        ('\u{10448}', 66592), ('\u{10449}', 66593), ('\u{1044a}', 66594), ('\u{1044b}', 66595),
+        ('\u{1044c}', 66596), ('\u{1044d}', 66597), ('\u{1044e}', 66598), ('\u{1044f}', 66599),
+        ('\u{104d8}', 66736), ('\u{104d9}', 66737), ('\u{104da}', 66738), ('\u{104db}', 66739),
+        ('\u{104dc}', 66740), ('\u{104dd}', 66741), ('\u{104de}', 66742), ('\u{104df}', 66743),
+        ('\u{104e0}', 66744), ('\u{104e1}', 66745), ('\u{104e2}', 66746), ('\u{104e3}', 66747),
+        ('\u{104e4}', 66748), ('\u{104e5}', 66749), ('\u{104e6}', 66750), ('\u{104e7}', 66751),
+        ('\u{104e8}', 66752), ('\u{104e9}', 66753), ('\u{104ea}', 66754), ('\u{104eb}', 66755),
+        ('\u{104ec}', 66756), ('\u{104ed}', 66757), ('\u{104ee}', 66758), ('\u{104ef}', 66759),
+        ('\u{104f0}', 66760), ('\u{104f1}', 66761), ('\u{104f2}', 66762), ('\u{104f3}', 66763),
+        ('\u{104f4}', 66764), ('\u{104f5}', 66765), ('\u{104f6}', 66766), ('\u{104f7}', 66767),
+        ('\u{104f8}', 66768), ('\u{104f9}', 66769), ('\u{104fa}', 66770), ('\u{104fb}', 66771),
+        ('\u{10597}', 66928), ('\u{10598}', 66929), ('\u{10599}', 66930), ('\u{1059a}', 66931),
+        ('\u{1059b}', 66932), ('\u{1059c}', 66933), ('\u{1059d}', 66934), ('\u{1059e}', 66935),
+        ('\u{1059f}', 66936), ('\u{105a0}', 66937), ('\u{105a1}', 66938), ('\u{105a3}', 66940),
+        ('\u{105a4}', 66941), ('\u{105a5}', 66942), ('\u{105a6}', 66943), ('\u{105a7}', 66944),
+        ('\u{105a8}', 66945), ('\u{105a9}', 66946), ('\u{105aa}', 66947), ('\u{105ab}', 66948),
+        ('\u{105ac}', 66949), ('\u{105ad}', 66950), ('\u{105ae}', 66951), ('\u{105af}', 66952),
+        ('\u{105b0}', 66953), ('\u{105b1}', 66954), ('\u{105b3}', 66956), ('\u{105b4}', 66957),
+        ('\u{105b5}', 66958), ('\u{105b6}', 66959), ('\u{105b7}', 66960), ('\u{105b8}', 66961),
+        ('\u{105b9}', 66962), ('\u{105bb}', 66964), ('\u{105bc}', 66965), ('\u{10cc0}', 68736),
+        ('\u{10cc1}', 68737), ('\u{10cc2}', 68738), ('\u{10cc3}', 68739), ('\u{10cc4}', 68740),
+        ('\u{10cc5}', 68741), ('\u{10cc6}', 68742), ('\u{10cc7}', 68743), ('\u{10cc8}', 68744),
+        ('\u{10cc9}', 68745), ('\u{10cca}', 68746), ('\u{10ccb}', 68747), ('\u{10ccc}', 68748),
+        ('\u{10ccd}', 68749), ('\u{10cce}', 68750), ('\u{10ccf}', 68751), ('\u{10cd0}', 68752),
+        ('\u{10cd1}', 68753), ('\u{10cd2}', 68754), ('\u{10cd3}', 68755), ('\u{10cd4}', 68756),
+        ('\u{10cd5}', 68757), ('\u{10cd6}', 68758), ('\u{10cd7}', 68759), ('\u{10cd8}', 68760),
+        ('\u{10cd9}', 68761), ('\u{10cda}', 68762), ('\u{10cdb}', 68763), ('\u{10cdc}', 68764),
+        ('\u{10cdd}', 68765), ('\u{10cde}', 68766), ('\u{10cdf}', 68767), ('\u{10ce0}', 68768),
+        ('\u{10ce1}', 68769), ('\u{10ce2}', 68770), ('\u{10ce3}', 68771), ('\u{10ce4}', 68772),
+        ('\u{10ce5}', 68773), ('\u{10ce6}', 68774), ('\u{10ce7}', 68775), ('\u{10ce8}', 68776),
+        ('\u{10ce9}', 68777), ('\u{10cea}', 68778), ('\u{10ceb}', 68779), ('\u{10cec}', 68780),
+        ('\u{10ced}', 68781), ('\u{10cee}', 68782), ('\u{10cef}', 68783), ('\u{10cf0}', 68784),
+        ('\u{10cf1}', 68785), ('\u{10cf2}', 68786), ('\u{10d70}', 68944), ('\u{10d71}', 68945),
+        ('\u{10d72}', 68946), ('\u{10d73}', 68947), ('\u{10d74}', 68948), ('\u{10d75}', 68949),
+        ('\u{10d76}', 68950), ('\u{10d77}', 68951), ('\u{10d78}', 68952), ('\u{10d79}', 68953),
+        ('\u{10d7a}', 68954), ('\u{10d7b}', 68955), ('\u{10d7c}', 68956), ('\u{10d7d}', 68957),
+        ('\u{10d7e}', 68958), ('\u{10d7f}', 68959), ('\u{10d80}', 68960), ('\u{10d81}', 68961),
+        ('\u{10d82}', 68962), ('\u{10d83}', 68963), ('\u{10d84}', 68964), ('\u{10d85}', 68965),
+        ('\u{118c0}', 71840), ('\u{118c1}', 71841), ('\u{118c2}', 71842), ('\u{118c3}', 71843),
+        ('\u{118c4}', 71844), ('\u{118c5}', 71845), ('\u{118c6}', 71846), ('\u{118c7}', 71847),
+        ('\u{118c8}', 71848), ('\u{118c9}', 71849), ('\u{118ca}', 71850), ('\u{118cb}', 71851),
+        ('\u{118cc}', 71852), ('\u{118cd}', 71853), ('\u{118ce}', 71854), ('\u{118cf}', 71855),
+        ('\u{118d0}', 71856), ('\u{118d1}', 71857), ('\u{118d2}', 71858), ('\u{118d3}', 71859),
+        ('\u{118d4}', 71860), ('\u{118d5}', 71861), ('\u{118d6}', 71862), ('\u{118d7}', 71863),
+        ('\u{118d8}', 71864), ('\u{118d9}', 71865), ('\u{118da}', 71866), ('\u{118db}', 71867),
+        ('\u{118dc}', 71868), ('\u{118dd}', 71869), ('\u{118de}', 71870), ('\u{118df}', 71871),
+        ('\u{16e60}', 93760), ('\u{16e61}', 93761), ('\u{16e62}', 93762), ('\u{16e63}', 93763),
+        ('\u{16e64}', 93764), ('\u{16e65}', 93765), ('\u{16e66}', 93766), ('\u{16e67}', 93767),
+        ('\u{16e68}', 93768), ('\u{16e69}', 93769), ('\u{16e6a}', 93770), ('\u{16e6b}', 93771),
+        ('\u{16e6c}', 93772), ('\u{16e6d}', 93773), ('\u{16e6e}', 93774), ('\u{16e6f}', 93775),
+        ('\u{16e70}', 93776), ('\u{16e71}', 93777), ('\u{16e72}', 93778), ('\u{16e73}', 93779),
+        ('\u{16e74}', 93780), ('\u{16e75}', 93781), ('\u{16e76}', 93782), ('\u{16e77}', 93783),
+        ('\u{16e78}', 93784), ('\u{16e79}', 93785), ('\u{16e7a}', 93786), ('\u{16e7b}', 93787),
+        ('\u{16e7c}', 93788), ('\u{16e7d}', 93789), ('\u{16e7e}', 93790), ('\u{16e7f}', 93791),
+        ('\u{16ebb}', 93856), ('\u{16ebc}', 93857), ('\u{16ebd}', 93858), ('\u{16ebe}', 93859),
+        ('\u{16ebf}', 93860), ('\u{16ec0}', 93861), ('\u{16ec1}', 93862), ('\u{16ec2}', 93863),
+        ('\u{16ec3}', 93864), ('\u{16ec4}', 93865), ('\u{16ec5}', 93866), ('\u{16ec6}', 93867),
+        ('\u{16ec7}', 93868), ('\u{16ec8}', 93869), ('\u{16ec9}', 93870), ('\u{16eca}', 93871),
+        ('\u{16ecb}', 93872), ('\u{16ecc}', 93873), ('\u{16ecd}', 93874), ('\u{16ece}', 93875),
+        ('\u{16ecf}', 93876), ('\u{16ed0}', 93877), ('\u{16ed1}', 93878), ('\u{16ed2}', 93879),
+        ('\u{16ed3}', 93880), ('\u{1e922}', 125184), ('\u{1e923}', 125185), ('\u{1e924}', 125186),
         ('\u{1e925}', 125187), ('\u{1e926}', 125188), ('\u{1e927}', 125189), ('\u{1e928}', 125190),
         ('\u{1e929}', 125191), ('\u{1e92a}', 125192), ('\u{1e92b}', 125193), ('\u{1e92c}', 125194),
         ('\u{1e92d}', 125195), ('\u{1e92e}', 125196), ('\u{1e92f}', 125197), ('\u{1e930}', 125198),

From a1a1ed25f2749de58c24a618460cb3d4279b1d5c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Tue, 9 Sep 2025 09:12:09 +0200
Subject: [PATCH 0706/1889] Add a FAQ entry about RA and Cargo interaction

---
 src/tools/rust-analyzer/docs/book/src/faq.md | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/tools/rust-analyzer/docs/book/src/faq.md b/src/tools/rust-analyzer/docs/book/src/faq.md
index c87203309011b..8c143ab949357 100644
--- a/src/tools/rust-analyzer/docs/book/src/faq.md
+++ b/src/tools/rust-analyzer/docs/book/src/faq.md
@@ -5,3 +5,12 @@
 rust-analyzer fails to resolve `None`, and thinks you are binding to a variable
 named `None`. That's usually a sign of a corrupted sysroot. Try removing and re-installing
 it: `rustup component remove rust-src` then `rustup component install rust-src`.
+
+### Rust Analyzer and Cargo compete over the build lock
+
+Rust Analyzer invokes Cargo in the background, and it can thus block manually executed
+`cargo` commands from making progress (or vice-versa). In some cases, this can also cause
+unnecessary recompilations caused by cache thrashing. To avoid this, you can configure
+Rust Analyzer to use a [different target directory](./configuration.md#cargo.targetDir).
+This will allow both the IDE and Cargo to make progress independently, at the cost of
+increased disk space usage caused by the duplicated artifact directories.

From 2079d1126bcfb5ed125009f3ccfc67ebd7995d56 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Sun, 7 Sep 2025 15:05:11 +0800
Subject: [PATCH 0707/1889] Fix LifetimeParam::lifetime_bounds invalid
 implement

Lifetime node example:

```
LIFETIME_PARAM@15..21
  LIFETIME@15..17
    LIFETIME_IDENT@15..17 "'a"
  COLON@17..18 ":"
  WHITESPACE@18..19 " "
  TYPE_BOUND_LIST@19..21
    TYPE_BOUND@19..21
      LIFETIME@19..21
        LIFETIME_IDENT@19..21 "'b"
```
---
 .../rust-analyzer/crates/syntax/src/ast/node_ext.rs | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/node_ext.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/node_ext.rs
index 42b0f5cf2da1c..af741d100f680 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/node_ext.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/node_ext.rs
@@ -12,8 +12,8 @@ use rowan::{GreenNodeData, GreenTokenData};
 use crate::{
     NodeOrToken, SmolStr, SyntaxElement, SyntaxToken, T, TokenText,
     ast::{
-        self, AstNode, AstToken, HasAttrs, HasGenericArgs, HasGenericParams, HasName, SyntaxNode,
-        support,
+        self, AstNode, AstToken, HasAttrs, HasGenericArgs, HasGenericParams, HasName,
+        HasTypeBounds, SyntaxNode, support,
     },
     ted,
 };
@@ -912,11 +912,10 @@ impl ast::Visibility {
 
 impl ast::LifetimeParam {
     pub fn lifetime_bounds(&self) -> impl Iterator<Item = SyntaxToken> {
-        self.syntax()
-            .children_with_tokens()
-            .filter_map(|it| it.into_token())
-            .skip_while(|x| x.kind() != T![:])
-            .filter(|it| it.kind() == T![lifetime_ident])
+        self.type_bound_list()
+            .into_iter()
+            .flat_map(|it| it.bounds())
+            .filter_map(|it| it.lifetime()?.lifetime_ident_token())
     }
 }
 

From e3dfcb26cd816046451a4dc85a85c5294245ded7 Mon Sep 17 00:00:00 2001
From: Miguel Ojeda <ojeda@kernel.org>
Date: Tue, 9 Sep 2025 09:33:49 +0200
Subject: [PATCH 0708/1889] CI: rfl: move job forward to Linux v6.17-rc5 to
 remove temporary commits

v6.17-rc5 contains the equivalent of the two commits we had here, thus
move the Rust for Linux job forward to that so that we don't need the
temporary commits anymore.

Signed-off-by: Miguel Ojeda <ojeda@kernel.org>
---
 src/ci/docker/scripts/rfl-build.sh | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/ci/docker/scripts/rfl-build.sh b/src/ci/docker/scripts/rfl-build.sh
index 7e0fb5794f47c..b7d7151b171d5 100755
--- a/src/ci/docker/scripts/rfl-build.sh
+++ b/src/ci/docker/scripts/rfl-build.sh
@@ -2,9 +2,7 @@
 
 set -euo pipefail
 
-# https://github.com/rust-lang/rust/pull/144443
-# https://github.com/rust-lang/rust/pull/145928
-LINUX_VERSION=8851e27d2cb947ea8bbbe8e812068f7bf5cbd00b
+LINUX_VERSION=v6.17-rc5
 
 # Build rustc, rustdoc, cargo, clippy-driver and rustfmt
 ../x.py build --stage 2 library rustdoc clippy rustfmt

From a69ac553992de87fd5192621a09a21a58887b164 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Tue, 9 Sep 2025 10:38:20 +0300
Subject: [PATCH 0709/1889] Resolve paths to snapshot test libraries absolutely

That is, resolve them globally, not from the test's location.

This *should* result in more robust resolution; for example, previously the code failed to detect the presence of snapshot testing if the snapshot library was renamed in the dependency or was an indirect dependency.
---
 .../crates/ide/src/hover/tests.rs             | 71 +++++++++++++++++++
 .../rust-analyzer/crates/ide/src/runnables.rs | 37 ++++------
 2 files changed, 85 insertions(+), 23 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs b/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
index 6f1bbad6ba169..58d8a7edbe042 100644
--- a/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
@@ -10569,6 +10569,77 @@ macro_rules! str {
     );
 }
 
+#[test]
+fn test_runnables_with_snapshot_tests_indirect_dep() {
+    check_actions(
+        r#"
+//- /lib.rs crate:foo deps:utils
+use utils::expect_test::expect;
+
+#[test]
+fn test$0() {
+    let actual = "new25";
+    expect!["new25"].assert_eq(&actual);
+}
+
+//- /expect-test/lib.rs crate:expect_test
+struct Expect;
+
+impl Expect {
+    fn assert_eq(&self, actual: &str) {}
+}
+
+#[macro_export]
+macro_rules! expect {
+    ($e:expr) => Expect; // dummy
+}
+
+//- /utils/lib.rs crate:utils deps:expect_test
+pub use expect_test;
+        "#,
+        expect![[r#"
+            [
+                Reference(
+                    FilePositionWrapper {
+                        file_id: FileId(
+                            0,
+                        ),
+                        offset: 44,
+                    },
+                ),
+                Runnable(
+                    Runnable {
+                        use_name_in_title: false,
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                0,
+                            ),
+                            full_range: 33..121,
+                            focus_range: 44..48,
+                            name: "test",
+                            kind: Function,
+                        },
+                        kind: Test {
+                            test_id: Path(
+                                "test",
+                            ),
+                            attr: TestAttr {
+                                ignore: false,
+                            },
+                        },
+                        cfg: None,
+                        update_test: UpdateTest {
+                            expect_test: true,
+                            insta: false,
+                            snapbox: false,
+                        },
+                    },
+                ),
+            ]
+        "#]],
+    );
+}
+
 #[test]
 fn drop_glue() {
     check(
diff --git a/src/tools/rust-analyzer/crates/ide/src/runnables.rs b/src/tools/rust-analyzer/crates/ide/src/runnables.rs
index 6ad9c7884db93..ec13ba0fde340 100644
--- a/src/tools/rust-analyzer/crates/ide/src/runnables.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/runnables.rs
@@ -4,8 +4,8 @@ use arrayvec::ArrayVec;
 use ast::HasName;
 use cfg::{CfgAtom, CfgExpr};
 use hir::{
-    AsAssocItem, AttrsWithOwner, HasAttrs, HasCrate, HasSource, ModPath, Name, PathKind, Semantics,
-    Symbol, db::HirDatabase, sym,
+    AsAssocItem, AttrsWithOwner, HasAttrs, HasCrate, HasSource, Semantics, Symbol, db::HirDatabase,
+    sym,
 };
 use ide_assists::utils::{has_test_related_attribute, test_related_attribute_syn};
 use ide_db::{
@@ -352,8 +352,7 @@ pub(crate) fn runnable_fn(
     .call_site();
 
     let file_range = fn_source.syntax().original_file_range_with_macro_call_input(sema.db);
-    let update_test =
-        UpdateTest::find_snapshot_macro(sema, &fn_source.file_syntax(sema.db), file_range);
+    let update_test = UpdateTest::find_snapshot_macro(sema, file_range);
 
     let cfg = def.attrs(sema.db).cfg();
     Some(Runnable { use_name_in_title: false, nav, kind, cfg, update_test })
@@ -388,7 +387,7 @@ pub(crate) fn runnable_mod(
         file_id: module_source.file_id.original_file(sema.db),
         range: module_syntax.text_range(),
     };
-    let update_test = UpdateTest::find_snapshot_macro(sema, &module_syntax, file_range);
+    let update_test = UpdateTest::find_snapshot_macro(sema, file_range);
 
     Some(Runnable {
         use_name_in_title: false,
@@ -428,8 +427,7 @@ pub(crate) fn runnable_impl(
     let impl_source = sema.source(*def)?;
     let impl_syntax = impl_source.syntax();
     let file_range = impl_syntax.original_file_range_with_macro_call_input(sema.db);
-    let update_test =
-        UpdateTest::find_snapshot_macro(sema, &impl_syntax.file_syntax(sema.db), file_range);
+    let update_test = UpdateTest::find_snapshot_macro(sema, file_range);
 
     Some(Runnable {
         use_name_in_title: false,
@@ -475,7 +473,7 @@ fn runnable_mod_outline_definition(
         file_id: mod_source.file_id.original_file(sema.db),
         range: mod_syntax.text_range(),
     };
-    let update_test = UpdateTest::find_snapshot_macro(sema, &mod_syntax, file_range);
+    let update_test = UpdateTest::find_snapshot_macro(sema, file_range);
 
     Some(Runnable {
         use_name_in_title: false,
@@ -641,7 +639,7 @@ pub struct UpdateTest {
     pub snapbox: bool,
 }
 
-static SNAPSHOT_TEST_MACROS: OnceLock<FxHashMap<&str, Vec<ModPath>>> = OnceLock::new();
+static SNAPSHOT_TEST_MACROS: OnceLock<FxHashMap<&str, Vec<[Symbol; 2]>>> = OnceLock::new();
 
 impl UpdateTest {
     const EXPECT_CRATE: &str = "expect_test";
@@ -665,22 +663,17 @@ impl UpdateTest {
     const SNAPBOX_CRATE: &str = "snapbox";
     const SNAPBOX_MACROS: &[&str] = &["assert_data_eq", "file", "str"];
 
-    fn find_snapshot_macro(
-        sema: &Semantics<'_, RootDatabase>,
-        scope: &SyntaxNode,
-        file_range: hir::FileRange,
-    ) -> Self {
+    fn find_snapshot_macro(sema: &Semantics<'_, RootDatabase>, file_range: hir::FileRange) -> Self {
         fn init<'a>(
             krate_name: &'a str,
             paths: &[&str],
-            map: &mut FxHashMap<&'a str, Vec<ModPath>>,
+            map: &mut FxHashMap<&'a str, Vec<[Symbol; 2]>>,
         ) {
             let mut res = Vec::with_capacity(paths.len());
-            let krate = Name::new_symbol_root(Symbol::intern(krate_name));
+            let krate = Symbol::intern(krate_name);
             for path in paths {
-                let segments = [krate.clone(), Name::new_symbol_root(Symbol::intern(path))];
-                let mod_path = ModPath::from_segments(PathKind::Abs, segments);
-                res.push(mod_path);
+                let segments = [krate.clone(), Symbol::intern(path)];
+                res.push(segments);
             }
             map.insert(krate_name, res);
         }
@@ -694,11 +687,9 @@ impl UpdateTest {
         });
 
         let search_scope = SearchScope::file_range(file_range);
-        let find_macro = |paths: &[ModPath]| {
+        let find_macro = |paths: &[[Symbol; 2]]| {
             for path in paths {
-                let Some(items) = sema.resolve_mod_path(scope, path) else {
-                    continue;
-                };
+                let items = hir::resolve_absolute_path(sema.db, path.iter().cloned());
                 for item in items {
                     if let hir::ItemInNs::Macros(makro) = item
                         && Definition::Macro(makro)

From c4cbb54f3f01b1e2c1927049d04f98d677734c3a Mon Sep 17 00:00:00 2001
From: LorrensP-2158466 <lorrens.pantelis@student.uhasselt.be>
Date: Tue, 9 Sep 2025 09:49:48 +0200
Subject: [PATCH 0710/1889] add approx_delta to all gamma tests

---
 library/std/tests/floats/f32.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/library/std/tests/floats/f32.rs b/library/std/tests/floats/f32.rs
index c29d803b25e41..3acd067091415 100644
--- a/library/std/tests/floats/f32.rs
+++ b/library/std/tests/floats/f32.rs
@@ -193,13 +193,13 @@ fn test_atanh() {
 #[test]
 fn test_gamma() {
     // precision can differ between platforms
-    assert_approx_eq!(1.0f32.gamma(), 1.0f32);
-    assert_approx_eq!(2.0f32.gamma(), 1.0f32);
-    assert_approx_eq!(3.0f32.gamma(), 2.0f32);
+    assert_approx_eq!(1.0f32.gamma(), 1.0f32, APPROX_DELTA);
+    assert_approx_eq!(2.0f32.gamma(), 1.0f32, APPROX_DELTA);
+    assert_approx_eq!(3.0f32.gamma(), 2.0f32, APPROX_DELTA);
     assert_approx_eq!(4.0f32.gamma(), 6.0f32, APPROX_DELTA);
     assert_approx_eq!(5.0f32.gamma(), 24.0f32, APPROX_DELTA);
-    assert_approx_eq!(0.5f32.gamma(), consts::PI.sqrt());
-    assert_approx_eq!((-0.5f32).gamma(), -2.0 * consts::PI.sqrt());
+    assert_approx_eq!(0.5f32.gamma(), consts::PI.sqrt(), APPROX_DELTA);
+    assert_approx_eq!((-0.5f32).gamma(), -2.0 * consts::PI.sqrt(), APPROX_DELTA);
     assert_eq!(0.0f32.gamma(), f32::INFINITY);
     assert_eq!((-0.0f32).gamma(), f32::NEG_INFINITY);
     assert!((-1.0f32).gamma().is_nan());

From 74a8f7451e75a789a4f656682465b4a2f6b559d2 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Tue, 9 Sep 2025 13:31:05 +0300
Subject: [PATCH 0711/1889] Expand target info to include the architecture

And make it easier to expand it more in the future, if needed.
---
 .../rust-analyzer/crates/base-db/src/input.rs |  4 +-
 .../rust-analyzer/crates/base-db/src/lib.rs   |  7 ++-
 .../crates/base-db/src/target.rs              | 50 +++++++++++++++++++
 .../hir-def/src/nameres/tests/incremental.rs  |  2 +-
 .../rust-analyzer/crates/hir-ty/src/db.rs     |  3 +-
 .../crates/hir-ty/src/layout/target.rs        |  8 +--
 .../crates/hir-ty/src/layout/tests.rs         | 11 ++--
 .../crates/hir-ty/src/mir/eval.rs             |  3 +-
 src/tools/rust-analyzer/crates/ide/src/lib.rs |  2 +-
 .../crates/project-model/src/lib.rs           |  2 +-
 .../crates/project-model/src/tests.rs         |  7 ++-
 .../{target_data_layout.rs => target_data.rs} | 41 +++++++++++++--
 .../crates/project-model/src/workspace.rs     | 38 +++++++-------
 .../cargo_hello_world_project_model.txt       | 10 ++--
 ...project_model_with_selective_overrides.txt | 10 ++--
 ..._project_model_with_wildcard_overrides.txt | 10 ++--
 .../output/rust_project_cfg_groups.txt        |  8 +--
 ...rust_project_hello_world_project_model.txt |  4 +-
 .../rust-analyzer/src/cli/rustc_tests.rs      |  7 ++-
 .../rust-analyzer/tests/slow-tests/support.rs |  2 +
 .../crates/test-fixture/src/lib.rs            | 18 +++++--
 .../crates/test-utils/src/fixture.rs          | 19 ++++++-
 22 files changed, 188 insertions(+), 78 deletions(-)
 create mode 100644 src/tools/rust-analyzer/crates/base-db/src/target.rs
 rename src/tools/rust-analyzer/crates/project-model/src/toolchain_info/{target_data_layout.rs => target_data.rs} (72%)

diff --git a/src/tools/rust-analyzer/crates/base-db/src/input.rs b/src/tools/rust-analyzer/crates/base-db/src/input.rs
index 0bf4fbdfbd691..cac74778a26b0 100644
--- a/src/tools/rust-analyzer/crates/base-db/src/input.rs
+++ b/src/tools/rust-analyzer/crates/base-db/src/input.rs
@@ -295,8 +295,6 @@ impl CrateDisplayName {
     }
 }
 
-pub type TargetLayoutLoadResult = Result<Arc<str>, Arc<str>>;
-
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub enum ReleaseChannel {
     Stable,
@@ -929,7 +927,7 @@ mod tests {
     use super::{CrateGraphBuilder, CrateName, CrateOrigin, Edition::Edition2018, Env, FileId};
 
     fn empty_ws_data() -> Arc<CrateWorkspaceData> {
-        Arc::new(CrateWorkspaceData { data_layout: Err("".into()), toolchain: None })
+        Arc::new(CrateWorkspaceData { target: Err("".into()), toolchain: None })
     }
 
     #[test]
diff --git a/src/tools/rust-analyzer/crates/base-db/src/lib.rs b/src/tools/rust-analyzer/crates/base-db/src/lib.rs
index 14544acc11bdf..0e411bcfae60e 100644
--- a/src/tools/rust-analyzer/crates/base-db/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/base-db/src/lib.rs
@@ -6,6 +6,7 @@ pub use salsa_macros;
 // FIXME: Rename this crate, base db is non descriptive
 mod change;
 mod input;
+pub mod target;
 
 use std::{
     cell::RefCell,
@@ -20,8 +21,7 @@ pub use crate::{
         BuiltCrateData, BuiltDependency, Crate, CrateBuilder, CrateBuilderId, CrateDataBuilder,
         CrateDisplayName, CrateGraphBuilder, CrateName, CrateOrigin, CratesIdMap, CratesMap,
         DependencyBuilder, Env, ExtraCrateData, LangCrateOrigin, ProcMacroLoadingError,
-        ProcMacroPaths, ReleaseChannel, SourceRoot, SourceRootId, TargetLayoutLoadResult,
-        UniqueCrateData,
+        ProcMacroPaths, ReleaseChannel, SourceRoot, SourceRootId, UniqueCrateData,
     },
 };
 use dashmap::{DashMap, mapref::entry::Entry};
@@ -359,8 +359,7 @@ impl Nonce {
 /// Crate related data shared by the whole workspace.
 #[derive(Debug, PartialEq, Eq, Hash, Clone)]
 pub struct CrateWorkspaceData {
-    // FIXME: Consider removing this, making HirDatabase::target_data_layout an input query
-    pub data_layout: TargetLayoutLoadResult,
+    pub target: Result<target::TargetData, target::TargetLoadError>,
     /// Toolchain version used to compile the crate.
     pub toolchain: Option<Version>,
 }
diff --git a/src/tools/rust-analyzer/crates/base-db/src/target.rs b/src/tools/rust-analyzer/crates/base-db/src/target.rs
new file mode 100644
index 0000000000000..19d3407bf3c80
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/base-db/src/target.rs
@@ -0,0 +1,50 @@
+//! Information about the target.
+
+use std::fmt;
+
+use triomphe::Arc;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum Arch {
+    // Only what we need is present here.
+    Wasm32,
+    Wasm64,
+    Other,
+}
+
+#[derive(Debug, PartialEq, Eq, Hash, Clone)]
+pub struct TargetData {
+    pub data_layout: Box<str>,
+    pub arch: Arch,
+}
+
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct TargetLoadError(Arc<str>);
+
+impl fmt::Debug for TargetLoadError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(&self.0, f)
+    }
+}
+
+impl fmt::Display for TargetLoadError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(&self.0, f)
+    }
+}
+
+impl std::error::Error for TargetLoadError {}
+
+impl From<String> for TargetLoadError {
+    fn from(value: String) -> Self {
+        Self(value.into())
+    }
+}
+
+impl From<&str> for TargetLoadError {
+    fn from(value: &str) -> Self {
+        Self(value.into())
+    }
+}
+
+pub type TargetLoadResult = Result<TargetData, TargetLoadError>;
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/nameres/tests/incremental.rs b/src/tools/rust-analyzer/crates/hir-def/src/nameres/tests/incremental.rs
index 338851b715bf0..6afa04bc412aa 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/nameres/tests/incremental.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/nameres/tests/incremental.rs
@@ -84,7 +84,7 @@ pub const BAZ: u32 = 0;
                     )
                     .unwrap(),
                 ),
-                Arc::new(CrateWorkspaceData { data_layout: Err("".into()), toolchain: None }),
+                Arc::new(CrateWorkspaceData { target: Err("".into()), toolchain: None }),
             )
         };
         let a = add_crate("a", 0);
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
index 0b7213d785c91..0aec2b9dec7bc 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
@@ -2,6 +2,7 @@
 //! type inference-related queries.
 
 use base_db::Crate;
+use base_db::target::TargetLoadError;
 use hir_def::{
     AdtId, BlockId, CallableDefId, ConstParamId, DefWithBodyId, EnumVariantId, FunctionId,
     GeneralConstId, GenericDefId, ImplId, LifetimeParamId, LocalFieldId, StaticId, TraitId,
@@ -108,7 +109,7 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
     ) -> Result<Arc<Layout>, LayoutError>;
 
     #[salsa::invoke(crate::layout::target_data_layout_query)]
-    fn target_data_layout(&self, krate: Crate) -> Result<Arc<TargetDataLayout>, Arc<str>>;
+    fn target_data_layout(&self, krate: Crate) -> Result<Arc<TargetDataLayout>, TargetLoadError>;
 
     #[salsa::invoke(crate::dyn_compatibility::dyn_compatibility_of_trait_query)]
     fn dyn_compatibility_of_trait(&self, trait_: TraitId) -> Option<DynCompatibilityViolation>;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout/target.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout/target.rs
index 82d0ed4f19470..8a7d93d50c05b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout/target.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout/target.rs
@@ -1,6 +1,6 @@
 //! Target dependent parameters needed for layouts
 
-use base_db::Crate;
+use base_db::{Crate, target::TargetLoadError};
 use hir_def::layout::TargetDataLayout;
 use rustc_abi::{AddressSpace, AlignFromBytesError, TargetDataLayoutErrors};
 use triomphe::Arc;
@@ -10,9 +10,9 @@ use crate::db::HirDatabase;
 pub fn target_data_layout_query(
     db: &dyn HirDatabase,
     krate: Crate,
-) -> Result<Arc<TargetDataLayout>, Arc<str>> {
-    match &krate.workspace_data(db).data_layout {
-        Ok(it) => match TargetDataLayout::parse_from_llvm_datalayout_string(it, AddressSpace::ZERO) {
+) -> Result<Arc<TargetDataLayout>, TargetLoadError> {
+    match &krate.workspace_data(db).target {
+        Ok(target) => match TargetDataLayout::parse_from_llvm_datalayout_string(&target.data_layout, AddressSpace::ZERO) {
             Ok(it) => Ok(Arc::new(it)),
             Err(e) => {
                 Err(match e {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs
index 90de7e5ca633d..523ddad94666b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs
@@ -1,3 +1,4 @@
+use base_db::target::TargetData;
 use chalk_ir::{AdtId, TyKind};
 use either::Either;
 use hir_def::db::DefDatabase;
@@ -18,8 +19,8 @@ use crate::{
 
 mod closure;
 
-fn current_machine_data_layout() -> String {
-    project_model::toolchain_info::target_data_layout::get(
+fn current_machine_target_data() -> TargetData {
+    project_model::toolchain_info::target_data::get(
         QueryConfig::Rustc(&Sysroot::empty(), &std::env::current_dir().unwrap()),
         None,
         &FxHashMap::default(),
@@ -32,7 +33,8 @@ fn eval_goal(
     minicore: &str,
 ) -> Result<Arc<Layout>, LayoutError> {
     let _tracing = setup_tracing();
-    let target_data_layout = current_machine_data_layout();
+    let target_data = current_machine_target_data();
+    let target_data_layout = target_data.data_layout;
     let ra_fixture = format!(
         "//- target_data_layout: {target_data_layout}\n{minicore}//- /main.rs crate:test\n{ra_fixture}",
     );
@@ -104,7 +106,8 @@ fn eval_expr(
     minicore: &str,
 ) -> Result<Arc<Layout>, LayoutError> {
     let _tracing = setup_tracing();
-    let target_data_layout = current_machine_data_layout();
+    let target_data = current_machine_target_data();
+    let target_data_layout = target_data.data_layout;
     let ra_fixture = format!(
         "//- target_data_layout: {target_data_layout}\n{minicore}//- /main.rs crate:test\nfn main(){{let goal = {{{ra_fixture}}};}}",
     );
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
index c60ace85be124..94d7c2f5ec5ae 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
@@ -3,6 +3,7 @@
 use std::{borrow::Cow, cell::RefCell, fmt::Write, iter, mem, ops::Range};
 
 use base_db::Crate;
+use base_db::target::TargetLoadError;
 use chalk_ir::{Mutability, cast::Cast};
 use either::Either;
 use hir_def::{
@@ -337,7 +338,7 @@ impl Address {
 pub enum MirEvalError {
     ConstEvalError(String, Box<ConstEvalError>),
     LayoutError(LayoutError, Ty),
-    TargetDataLayoutNotAvailable(Arc<str>),
+    TargetDataLayoutNotAvailable(TargetLoadError),
     /// Means that code had undefined behavior. We don't try to actively detect UB, but if it was detected
     /// then use this type of error.
     UndefinedBehavior(String),
diff --git a/src/tools/rust-analyzer/crates/ide/src/lib.rs b/src/tools/rust-analyzer/crates/ide/src/lib.rs
index 3a6b3247d65c6..50cbef581c7d7 100644
--- a/src/tools/rust-analyzer/crates/ide/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/lib.rs
@@ -263,7 +263,7 @@ impl Analysis {
             false,
             proc_macro_cwd,
             Arc::new(CrateWorkspaceData {
-                data_layout: Err("fixture has no layout".into()),
+                target: Err("fixture has no layout".into()),
                 toolchain: None,
             }),
         );
diff --git a/src/tools/rust-analyzer/crates/project-model/src/lib.rs b/src/tools/rust-analyzer/crates/project-model/src/lib.rs
index d39781b15066d..e36b904881513 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/lib.rs
@@ -18,7 +18,7 @@
 pub mod project_json;
 pub mod toolchain_info {
     pub mod rustc_cfg;
-    pub mod target_data_layout;
+    pub mod target_data;
     pub mod target_tuple;
     pub mod version;
 
diff --git a/src/tools/rust-analyzer/crates/project-model/src/tests.rs b/src/tools/rust-analyzer/crates/project-model/src/tests.rs
index ed72520f40d4d..987d381fac638 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/tests.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/tests.rs
@@ -9,7 +9,6 @@ use paths::{AbsPath, AbsPathBuf, Utf8Path, Utf8PathBuf};
 use rustc_hash::FxHashMap;
 use serde::de::DeserializeOwned;
 use span::FileId;
-use triomphe::Arc;
 
 use crate::{
     CargoWorkspace, CfgOverrides, ManifestPath, ProjectJson, ProjectJsonData, ProjectWorkspace,
@@ -47,7 +46,7 @@ fn load_workspace_from_metadata(file: &str) -> ProjectWorkspace {
         sysroot: Sysroot::empty(),
         rustc_cfg: Vec::new(),
         toolchain: None,
-        target_layout: Err("target_data_layout not loaded".into()),
+        target: Err("target_data_layout not loaded".into()),
         extra_includes: Vec::new(),
         set_test: true,
     }
@@ -62,7 +61,7 @@ fn load_rust_project(file: &str) -> (CrateGraphBuilder, ProcMacroPaths) {
         sysroot,
         rustc_cfg: Vec::new(),
         toolchain: None,
-        target_layout: Err(Arc::from("test has no data layout")),
+        target: Err("test has no target data".into()),
         cfg_overrides: Default::default(),
         extra_includes: Vec::new(),
         set_test: true,
@@ -265,7 +264,7 @@ fn smoke_test_real_sysroot_cargo() {
         rustc_cfg: Vec::new(),
         cfg_overrides: Default::default(),
         toolchain: None,
-        target_layout: Err("target_data_layout not loaded".into()),
+        target: Err("target_data_layout not loaded".into()),
         extra_includes: Vec::new(),
         set_test: true,
     };
diff --git a/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/target_data_layout.rs b/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/target_data.rs
similarity index 72%
rename from src/tools/rust-analyzer/crates/project-model/src/toolchain_info/target_data_layout.rs
rename to src/tools/rust-analyzer/crates/project-model/src/toolchain_info/target_data.rs
index f1d99cb8b002c..b815c0b79718e 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/target_data_layout.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/target_data.rs
@@ -1,23 +1,54 @@
 //! Runs `rustc --print target-spec-json` to get the target_data_layout.
 
 use anyhow::Context;
+use base_db::target;
 use rustc_hash::FxHashMap;
+use serde_derive::Deserialize;
 use toolchain::Tool;
 
 use crate::{Sysroot, toolchain_info::QueryConfig, utf8_stdout};
 
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum Arch {
+    Wasm32,
+    Wasm64,
+    #[serde(other)]
+    Other,
+}
+
+impl From<Arch> for target::Arch {
+    fn from(value: Arch) -> Self {
+        match value {
+            Arch::Wasm32 => target::Arch::Wasm32,
+            Arch::Wasm64 => target::Arch::Wasm64,
+            Arch::Other => target::Arch::Other,
+        }
+    }
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct TargetSpec {
+    pub data_layout: String,
+    pub arch: Arch,
+}
+
 /// Uses `rustc --print target-spec-json`.
 pub fn get(
     config: QueryConfig<'_>,
     target: Option<&str>,
     extra_env: &FxHashMap<String, Option<String>>,
-) -> anyhow::Result<String> {
+) -> anyhow::Result<target::TargetData> {
     const RUSTC_ARGS: [&str; 2] = ["--print", "target-spec-json"];
     let process = |output: String| {
-        (|| Some(output.split_once(r#""data-layout": ""#)?.1.split_once('"')?.0.to_owned()))()
-            .ok_or_else(|| {
-                anyhow::format_err!("could not parse target-spec-json from command output")
-            })
+        let target_spec = serde_json::from_str::<TargetSpec>(&output).map_err(|_| {
+            anyhow::format_err!("could not parse target-spec-json from command output")
+        })?;
+        Ok(target::TargetData {
+            arch: target_spec.arch.into(),
+            data_layout: target_spec.data_layout.into_boxed_str(),
+        })
     };
     let (sysroot, current_dir) = match config {
         QueryConfig::Cargo(sysroot, cargo_toml, _) => {
diff --git a/src/tools/rust-analyzer/crates/project-model/src/workspace.rs b/src/tools/rust-analyzer/crates/project-model/src/workspace.rs
index 00032bcf1d2e4..e0d2105c8df89 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/workspace.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/workspace.rs
@@ -8,7 +8,7 @@ use anyhow::Context;
 use base_db::{
     CrateBuilderId, CrateDisplayName, CrateGraphBuilder, CrateName, CrateOrigin,
     CrateWorkspaceData, DependencyBuilder, Env, LangCrateOrigin, ProcMacroLoadingError,
-    ProcMacroPaths, TargetLayoutLoadResult,
+    ProcMacroPaths, target::TargetLoadResult,
 };
 use cfg::{CfgAtom, CfgDiff, CfgOptions};
 use intern::{Symbol, sym};
@@ -30,7 +30,7 @@ use crate::{
     env::{cargo_config_env, inject_cargo_env, inject_cargo_package_env, inject_rustc_tool_env},
     project_json::{Crate, CrateArrayIdx},
     sysroot::RustLibSrcWorkspace,
-    toolchain_info::{QueryConfig, rustc_cfg, target_data_layout, target_tuple, version},
+    toolchain_info::{QueryConfig, rustc_cfg, target_data, target_tuple, version},
     utf8_stdout,
 };
 use tracing::{debug, error, info};
@@ -63,7 +63,7 @@ pub struct ProjectWorkspace {
     /// The toolchain version used by this workspace.
     pub toolchain: Option<Version>,
     /// The target data layout queried for workspace.
-    pub target_layout: TargetLayoutLoadResult,
+    pub target: TargetLoadResult,
     /// A set of cfg overrides for this workspace.
     pub cfg_overrides: CfgOverrides,
     /// Additional includes to add for the VFS.
@@ -115,7 +115,7 @@ impl fmt::Debug for ProjectWorkspace {
             sysroot,
             rustc_cfg,
             toolchain,
-            target_layout,
+            target: target_layout,
             cfg_overrides,
             extra_includes,
             set_test,
@@ -309,8 +309,8 @@ impl ProjectWorkspace {
             let rustc_cfg = s.spawn(|| {
                 rustc_cfg::get(toolchain_config, targets.first().map(Deref::deref), extra_env)
             });
-            let data_layout = s.spawn(|| {
-                target_data_layout::get(
+            let target_data = s.spawn(|| {
+                target_data::get(
                     toolchain_config,
                     targets.first().map(Deref::deref),
                     extra_env,
@@ -392,7 +392,7 @@ impl ProjectWorkspace {
                 s.spawn(move || cargo_config_env(cargo_toml, &config_file));
             thread::Result::Ok((
                 rustc_cfg.join()?,
-                data_layout.join()?,
+                target_data.join()?,
                 rustc_dir.join()?,
                 loaded_sysroot.join()?,
                 cargo_metadata.join()?,
@@ -442,7 +442,7 @@ impl ProjectWorkspace {
             rustc_cfg,
             cfg_overrides: cfg_overrides.clone(),
             toolchain,
-            target_layout: data_layout.map(Arc::from).map_err(|it| Arc::from(it.to_string())),
+            target: data_layout.map_err(|it| it.to_string().into()),
             extra_includes: extra_includes.clone(),
             set_test: *set_test,
         })
@@ -480,11 +480,7 @@ impl ProjectWorkspace {
                 rustc_cfg::get(query_config, targets.first().map(Deref::deref), &config.extra_env)
             });
             let data_layout = s.spawn(|| {
-                target_data_layout::get(
-                    query_config,
-                    targets.first().map(Deref::deref),
-                    &config.extra_env,
-                )
+                target_data::get(query_config, targets.first().map(Deref::deref), &config.extra_env)
             });
             let loaded_sysroot = s.spawn(|| {
                 if let Some(sysroot_project) = sysroot_project {
@@ -513,7 +509,7 @@ impl ProjectWorkspace {
             thread::Result::Ok((rustc_cfg.join()?, data_layout.join()?, loaded_sysroot.join()?))
         });
 
-        let (rustc_cfg, target_layout, loaded_sysroot) = match join {
+        let (rustc_cfg, target_data, loaded_sysroot) = match join {
             Ok(it) => it,
             Err(e) => std::panic::resume_unwind(e),
         };
@@ -527,7 +523,7 @@ impl ProjectWorkspace {
             sysroot,
             rustc_cfg,
             toolchain,
-            target_layout: target_layout.map(Arc::from).map_err(|it| Arc::from(it.to_string())),
+            target: target_data.map_err(|it| it.to_string().into()),
             cfg_overrides: config.cfg_overrides.clone(),
             extra_includes: config.extra_includes.clone(),
             set_test: config.set_test,
@@ -551,7 +547,7 @@ impl ProjectWorkspace {
         let targets = target_tuple::get(query_config, config.target.as_deref(), &config.extra_env)
             .unwrap_or_default();
         let rustc_cfg = rustc_cfg::get(query_config, None, &config.extra_env);
-        let data_layout = target_data_layout::get(query_config, None, &config.extra_env);
+        let target_data = target_data::get(query_config, None, &config.extra_env);
         let target_dir = config
             .target_dir
             .clone()
@@ -610,7 +606,7 @@ impl ProjectWorkspace {
             sysroot,
             rustc_cfg,
             toolchain,
-            target_layout: data_layout.map(Arc::from).map_err(|it| Arc::from(it.to_string())),
+            target: target_data.map_err(|it| it.to_string().into()),
             cfg_overrides: config.cfg_overrides.clone(),
             extra_includes: config.extra_includes.clone(),
             set_test: config.set_test,
@@ -942,7 +938,7 @@ impl ProjectWorkspace {
         let Self { kind, sysroot, cfg_overrides, rustc_cfg, .. } = self;
         let crate_ws_data = Arc::new(CrateWorkspaceData {
             toolchain: self.toolchain.clone(),
-            data_layout: self.target_layout.clone(),
+            target: self.target.clone(),
         });
         let (crate_graph, proc_macros) = match kind {
             ProjectWorkspaceKind::Json(project) => project_json_to_crate_graph(
@@ -1000,13 +996,15 @@ impl ProjectWorkspace {
     }
 
     pub fn eq_ignore_build_data(&self, other: &Self) -> bool {
-        let Self { kind, sysroot, rustc_cfg, toolchain, target_layout, cfg_overrides, .. } = self;
+        let Self {
+            kind, sysroot, rustc_cfg, toolchain, target: target_layout, cfg_overrides, ..
+        } = self;
         let Self {
             kind: o_kind,
             sysroot: o_sysroot,
             rustc_cfg: o_rustc_cfg,
             toolchain: o_toolchain,
-            target_layout: o_target_layout,
+            target: o_target_layout,
             cfg_overrides: o_cfg_overrides,
             ..
         } = other;
diff --git a/src/tools/rust-analyzer/crates/project-model/test_data/output/cargo_hello_world_project_model.txt b/src/tools/rust-analyzer/crates/project-model/test_data/output/cargo_hello_world_project_model.txt
index 3722e2c721686..4f6ce4dc95374 100644
--- a/src/tools/rust-analyzer/crates/project-model/test_data/output/cargo_hello_world_project_model.txt
+++ b/src/tools/rust-analyzer/crates/project-model/test_data/output/cargo_hello_world_project_model.txt
@@ -70,7 +70,7 @@
             },
         },
         ws_data: CrateWorkspaceData {
-            data_layout: Err(
+            target: Err(
                 "target_data_layout not loaded",
             ),
             toolchain: None,
@@ -155,7 +155,7 @@
             },
         },
         ws_data: CrateWorkspaceData {
-            data_layout: Err(
+            target: Err(
                 "target_data_layout not loaded",
             ),
             toolchain: None,
@@ -240,7 +240,7 @@
             },
         },
         ws_data: CrateWorkspaceData {
-            data_layout: Err(
+            target: Err(
                 "target_data_layout not loaded",
             ),
             toolchain: None,
@@ -325,7 +325,7 @@
             },
         },
         ws_data: CrateWorkspaceData {
-            data_layout: Err(
+            target: Err(
                 "target_data_layout not loaded",
             ),
             toolchain: None,
@@ -406,7 +406,7 @@
             },
         },
         ws_data: CrateWorkspaceData {
-            data_layout: Err(
+            target: Err(
                 "target_data_layout not loaded",
             ),
             toolchain: None,
diff --git a/src/tools/rust-analyzer/crates/project-model/test_data/output/cargo_hello_world_project_model_with_selective_overrides.txt b/src/tools/rust-analyzer/crates/project-model/test_data/output/cargo_hello_world_project_model_with_selective_overrides.txt
index 3722e2c721686..4f6ce4dc95374 100644
--- a/src/tools/rust-analyzer/crates/project-model/test_data/output/cargo_hello_world_project_model_with_selective_overrides.txt
+++ b/src/tools/rust-analyzer/crates/project-model/test_data/output/cargo_hello_world_project_model_with_selective_overrides.txt
@@ -70,7 +70,7 @@
             },
         },
         ws_data: CrateWorkspaceData {
-            data_layout: Err(
+            target: Err(
                 "target_data_layout not loaded",
             ),
             toolchain: None,
@@ -155,7 +155,7 @@
             },
         },
         ws_data: CrateWorkspaceData {
-            data_layout: Err(
+            target: Err(
                 "target_data_layout not loaded",
             ),
             toolchain: None,
@@ -240,7 +240,7 @@
             },
         },
         ws_data: CrateWorkspaceData {
-            data_layout: Err(
+            target: Err(
                 "target_data_layout not loaded",
             ),
             toolchain: None,
@@ -325,7 +325,7 @@
             },
         },
         ws_data: CrateWorkspaceData {
-            data_layout: Err(
+            target: Err(
                 "target_data_layout not loaded",
             ),
             toolchain: None,
@@ -406,7 +406,7 @@
             },
         },
         ws_data: CrateWorkspaceData {
-            data_layout: Err(
+            target: Err(
                 "target_data_layout not loaded",
             ),
             toolchain: None,
diff --git a/src/tools/rust-analyzer/crates/project-model/test_data/output/cargo_hello_world_project_model_with_wildcard_overrides.txt b/src/tools/rust-analyzer/crates/project-model/test_data/output/cargo_hello_world_project_model_with_wildcard_overrides.txt
index 7b156ea63a58f..6862918e09ae6 100644
--- a/src/tools/rust-analyzer/crates/project-model/test_data/output/cargo_hello_world_project_model_with_wildcard_overrides.txt
+++ b/src/tools/rust-analyzer/crates/project-model/test_data/output/cargo_hello_world_project_model_with_wildcard_overrides.txt
@@ -69,7 +69,7 @@
             },
         },
         ws_data: CrateWorkspaceData {
-            data_layout: Err(
+            target: Err(
                 "target_data_layout not loaded",
             ),
             toolchain: None,
@@ -153,7 +153,7 @@
             },
         },
         ws_data: CrateWorkspaceData {
-            data_layout: Err(
+            target: Err(
                 "target_data_layout not loaded",
             ),
             toolchain: None,
@@ -237,7 +237,7 @@
             },
         },
         ws_data: CrateWorkspaceData {
-            data_layout: Err(
+            target: Err(
                 "target_data_layout not loaded",
             ),
             toolchain: None,
@@ -321,7 +321,7 @@
             },
         },
         ws_data: CrateWorkspaceData {
-            data_layout: Err(
+            target: Err(
                 "target_data_layout not loaded",
             ),
             toolchain: None,
@@ -402,7 +402,7 @@
             },
         },
         ws_data: CrateWorkspaceData {
-            data_layout: Err(
+            target: Err(
                 "target_data_layout not loaded",
             ),
             toolchain: None,
diff --git a/src/tools/rust-analyzer/crates/project-model/test_data/output/rust_project_cfg_groups.txt b/src/tools/rust-analyzer/crates/project-model/test_data/output/rust_project_cfg_groups.txt
index 98fe598eb3a32..28ad3236ae813 100644
--- a/src/tools/rust-analyzer/crates/project-model/test_data/output/rust_project_cfg_groups.txt
+++ b/src/tools/rust-analyzer/crates/project-model/test_data/output/rust_project_cfg_groups.txt
@@ -43,8 +43,8 @@
             entries: {},
         },
         ws_data: CrateWorkspaceData {
-            data_layout: Err(
-                "test has no data layout",
+            target: Err(
+                "test has no target data",
             ),
             toolchain: None,
         },
@@ -93,8 +93,8 @@
             entries: {},
         },
         ws_data: CrateWorkspaceData {
-            data_layout: Err(
-                "test has no data layout",
+            target: Err(
+                "test has no target data",
             ),
             toolchain: None,
         },
diff --git a/src/tools/rust-analyzer/crates/project-model/test_data/output/rust_project_hello_world_project_model.txt b/src/tools/rust-analyzer/crates/project-model/test_data/output/rust_project_hello_world_project_model.txt
index 0dc373b5b47ed..dabb3aa674414 100644
--- a/src/tools/rust-analyzer/crates/project-model/test_data/output/rust_project_hello_world_project_model.txt
+++ b/src/tools/rust-analyzer/crates/project-model/test_data/output/rust_project_hello_world_project_model.txt
@@ -40,8 +40,8 @@
             entries: {},
         },
         ws_data: CrateWorkspaceData {
-            data_layout: Err(
-                "test has no data layout",
+            target: Err(
+                "test has no target data",
             ),
             toolchain: None,
         },
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/rustc_tests.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/rustc_tests.rs
index 36ae98b321b84..609ebf2b514f0 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/rustc_tests.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/rustc_tests.rs
@@ -11,7 +11,7 @@ use ide_db::base_db;
 use itertools::Either;
 use paths::Utf8PathBuf;
 use profile::StopWatch;
-use project_model::toolchain_info::{QueryConfig, target_data_layout};
+use project_model::toolchain_info::{QueryConfig, target_data};
 use project_model::{
     CargoConfig, ManifestPath, ProjectWorkspace, ProjectWorkspaceKind, RustLibSource,
     RustSourceWorkspaceConfig, Sysroot,
@@ -19,7 +19,6 @@ use project_model::{
 
 use load_cargo::{LoadCargoConfig, ProcMacroServerChoice, load_workspace};
 use rustc_hash::FxHashMap;
-use triomphe::Arc;
 use vfs::{AbsPathBuf, FileId};
 use walkdir::WalkDir;
 
@@ -87,7 +86,7 @@ impl Tester {
             sysroot.set_workspace(loaded_sysroot);
         }
 
-        let data_layout = target_data_layout::get(
+        let target_data = target_data::get(
             QueryConfig::Rustc(&sysroot, tmp_file.parent().unwrap().as_ref()),
             None,
             &cargo_config.extra_env,
@@ -101,7 +100,7 @@ impl Tester {
             sysroot,
             rustc_cfg: vec![],
             toolchain: None,
-            target_layout: data_layout.map(Arc::from).map_err(|it| Arc::from(it.to_string())),
+            target: target_data.map_err(|it| it.to_string().into()),
             cfg_overrides: Default::default(),
             extra_includes: vec![],
             set_test: true,
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/tests/slow-tests/support.rs b/src/tools/rust-analyzer/crates/rust-analyzer/tests/slow-tests/support.rs
index 2bebb0c1b9700..3464a9644b19d 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/tests/slow-tests/support.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/tests/slow-tests/support.rs
@@ -97,6 +97,7 @@ impl Project<'_> {
             proc_macro_names,
             toolchain,
             target_data_layout: _,
+            target_arch: _,
         } = FixtureWithProjectMeta::parse(self.fixture);
         assert!(proc_macro_names.is_empty());
         assert!(mini_core.is_none());
@@ -177,6 +178,7 @@ impl Project<'_> {
             proc_macro_names,
             toolchain,
             target_data_layout: _,
+            target_arch: _,
         } = FixtureWithProjectMeta::parse(self.fixture);
         assert!(proc_macro_names.is_empty());
         assert!(mini_core.is_none());
diff --git a/src/tools/rust-analyzer/crates/test-fixture/src/lib.rs b/src/tools/rust-analyzer/crates/test-fixture/src/lib.rs
index 57fca70547bf9..7574d12c0cfd0 100644
--- a/src/tools/rust-analyzer/crates/test-fixture/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/test-fixture/src/lib.rs
@@ -1,6 +1,7 @@
 //! A set of high-level utility fixture methods to use in tests.
 use std::{any::TypeId, mem, str::FromStr, sync};
 
+use base_db::target::TargetData;
 use base_db::{
     Crate, CrateDisplayName, CrateGraphBuilder, CrateName, CrateOrigin, CrateWorkspaceData,
     DependencyBuilder, Env, FileChange, FileSet, FxIndexMap, LangCrateOrigin, SourceDatabase,
@@ -136,8 +137,11 @@ impl ChangeFixture {
             proc_macro_names,
             toolchain,
             target_data_layout,
+            target_arch,
         } = FixtureWithProjectMeta::parse(ra_fixture);
-        let target_data_layout = Ok(target_data_layout.into());
+        let target_data_layout = target_data_layout.into();
+        let target_arch = parse_target_arch(&target_arch);
+        let target = Ok(TargetData { arch: target_arch, data_layout: target_data_layout });
         let toolchain = Some({
             let channel = toolchain.as_deref().unwrap_or("stable");
             Version::parse(&format!("1.76.0-{channel}")).unwrap()
@@ -163,8 +167,7 @@ impl ChangeFixture {
 
         let mut file_position = None;
 
-        let crate_ws_data =
-            Arc::new(CrateWorkspaceData { data_layout: target_data_layout, toolchain });
+        let crate_ws_data = Arc::new(CrateWorkspaceData { target, toolchain });
 
         // FIXME: This is less than ideal
         let proc_macro_cwd = Arc::new(AbsPathBuf::assert_utf8(std::env::current_dir().unwrap()));
@@ -395,6 +398,15 @@ impl ChangeFixture {
     }
 }
 
+fn parse_target_arch(arch: &str) -> base_db::target::Arch {
+    use base_db::target::Arch::*;
+    match arch {
+        "wasm32" => Wasm32,
+        "wasm64" => Wasm64,
+        _ => Other,
+    }
+}
+
 fn default_test_proc_macros() -> Box<[(String, ProcMacro)]> {
     Box::new([
         (
diff --git a/src/tools/rust-analyzer/crates/test-utils/src/fixture.rs b/src/tools/rust-analyzer/crates/test-utils/src/fixture.rs
index e830c6a7cf688..c024089a016f9 100644
--- a/src/tools/rust-analyzer/crates/test-utils/src/fixture.rs
+++ b/src/tools/rust-analyzer/crates/test-utils/src/fixture.rs
@@ -149,6 +149,8 @@ pub struct FixtureWithProjectMeta {
     /// You probably don't want to manually specify this. See LLVM manual for the
     /// syntax, if you must: <https://llvm.org/docs/LangRef.html#data-layout>
     pub target_data_layout: String,
+    /// Specifies the target architecture.
+    pub target_arch: String,
 }
 
 impl FixtureWithProjectMeta {
@@ -178,6 +180,7 @@ impl FixtureWithProjectMeta {
         let mut toolchain = None;
         let mut target_data_layout =
             "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128".to_owned();
+        let mut target_arch = "x86_64".to_owned();
         let mut mini_core = None;
         let mut res: Vec<Fixture> = Vec::new();
         let mut proc_macro_names = vec![];
@@ -194,6 +197,12 @@ impl FixtureWithProjectMeta {
             fixture = remain;
         }
 
+        if let Some(meta) = fixture.strip_prefix("//- target_arch:") {
+            let (meta, remain) = meta.split_once('\n').unwrap();
+            meta.trim().clone_into(&mut target_arch);
+            fixture = remain;
+        }
+
         if let Some(meta) = fixture.strip_prefix("//- proc_macros:") {
             let (meta, remain) = meta.split_once('\n').unwrap();
             proc_macro_names = meta.split(',').map(|it| it.trim().to_owned()).collect();
@@ -232,7 +241,14 @@ impl FixtureWithProjectMeta {
             }
         }
 
-        Self { fixture: res, mini_core, proc_macro_names, toolchain, target_data_layout }
+        Self {
+            fixture: res,
+            mini_core,
+            proc_macro_names,
+            toolchain,
+            target_data_layout,
+            target_arch,
+        }
     }
 
     //- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b env:OUTDIR=path/to,OTHER=foo
@@ -511,6 +527,7 @@ fn parse_fixture_gets_full_meta() {
         proc_macro_names,
         toolchain,
         target_data_layout: _,
+        target_arch: _,
     } = FixtureWithProjectMeta::parse(
         r#"
 //- toolchain: nightly

From d6638e9bd2b455cf0d3a0df04afc2bab8f134fc9 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Tue, 9 Sep 2025 13:49:11 +0300
Subject: [PATCH 0712/1889] Make `#[target_feature]` safe always on WASM

Even when the feature isn't enabled, as it's not UB to invoke an undefined feature in WASM (just a trap).
---
 .../hir-ty/src/diagnostics/unsafe_check.rs    | 24 +++++++++++++++----
 .../rust-analyzer/crates/hir-ty/src/lib.rs    |  5 +++-
 .../rust-analyzer/crates/hir-ty/src/utils.rs  | 12 ++++++++--
 src/tools/rust-analyzer/crates/hir/src/lib.rs | 23 ++++++++++++++----
 .../src/handlers/missing_unsafe.rs            | 16 +++++++++++++
 5 files changed, 69 insertions(+), 11 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs
index d6d669258cc1f..64c4cdeaddf31 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs
@@ -15,8 +15,9 @@ use hir_def::{
 use span::Edition;
 
 use crate::{
-    InferenceResult, Interner, TargetFeatures, TyExt, TyKind, db::HirDatabase,
-    utils::is_fn_unsafe_to_call,
+    InferenceResult, Interner, TargetFeatures, TyExt, TyKind,
+    db::HirDatabase,
+    utils::{is_fn_unsafe_to_call, target_feature_is_safe_in_target},
 };
 
 #[derive(Debug, Default)]
@@ -144,6 +145,9 @@ struct UnsafeVisitor<'db> {
     def_target_features: TargetFeatures,
     // FIXME: This needs to be the edition of the span of each call.
     edition: Edition,
+    /// On some targets (WASM), calling safe functions with `#[target_feature]` is always safe, even when
+    /// the target feature is not enabled. This flag encodes that.
+    target_feature_is_safe: bool,
 }
 
 impl<'db> UnsafeVisitor<'db> {
@@ -159,7 +163,12 @@ impl<'db> UnsafeVisitor<'db> {
             DefWithBodyId::FunctionId(func) => TargetFeatures::from_attrs(&db.attrs(func.into())),
             _ => TargetFeatures::default(),
         };
-        let edition = resolver.module().krate().data(db).edition;
+        let krate = resolver.module().krate();
+        let edition = krate.data(db).edition;
+        let target_feature_is_safe = match &krate.workspace_data(db).target {
+            Ok(target) => target_feature_is_safe_in_target(target),
+            Err(_) => false,
+        };
         Self {
             db,
             infer,
@@ -172,6 +181,7 @@ impl<'db> UnsafeVisitor<'db> {
             callback: unsafe_expr_cb,
             def_target_features,
             edition,
+            target_feature_is_safe,
         }
     }
 
@@ -184,7 +194,13 @@ impl<'db> UnsafeVisitor<'db> {
     }
 
     fn check_call(&mut self, node: ExprId, func: FunctionId) {
-        let unsafety = is_fn_unsafe_to_call(self.db, func, &self.def_target_features, self.edition);
+        let unsafety = is_fn_unsafe_to_call(
+            self.db,
+            func,
+            &self.def_target_features,
+            self.edition,
+            self.target_feature_is_safe,
+        );
         match unsafety {
             crate::utils::Unsafety::Safe => {}
             crate::utils::Unsafety::Unsafe => {
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 c16bbb7b99221..ee352619487c6 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
@@ -129,7 +129,10 @@ pub use mapping::{
 pub use method_resolution::check_orphan_rules;
 pub use target_feature::TargetFeatures;
 pub use traits::TraitEnvironment;
-pub use utils::{Unsafety, all_super_traits, direct_super_traits, is_fn_unsafe_to_call};
+pub use utils::{
+    Unsafety, all_super_traits, direct_super_traits, is_fn_unsafe_to_call,
+    target_feature_is_safe_in_target,
+};
 pub use variance::Variance;
 
 pub use chalk_ir::{
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/utils.rs b/src/tools/rust-analyzer/crates/hir-ty/src/utils.rs
index 881b1c1a9db26..07679d2a119d3 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/utils.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/utils.rs
@@ -3,7 +3,10 @@
 
 use std::{cell::LazyCell, iter};
 
-use base_db::Crate;
+use base_db::{
+    Crate,
+    target::{self, TargetData},
+};
 use chalk_ir::{DebruijnIndex, fold::FallibleTypeFolder};
 use hir_def::{
     EnumId, EnumVariantId, FunctionId, Lookup, TraitId, TypeAliasId, TypeOrConstParamId,
@@ -275,18 +278,23 @@ pub enum Unsafety {
     DeprecatedSafe2024,
 }
 
+pub fn target_feature_is_safe_in_target(target: &TargetData) -> bool {
+    matches!(target.arch, target::Arch::Wasm32 | target::Arch::Wasm64)
+}
+
 pub fn is_fn_unsafe_to_call(
     db: &dyn HirDatabase,
     func: FunctionId,
     caller_target_features: &TargetFeatures,
     call_edition: Edition,
+    target_feature_is_safe: bool,
 ) -> Unsafety {
     let data = db.function_signature(func);
     if data.is_unsafe() {
         return Unsafety::Unsafe;
     }
 
-    if data.has_target_feature() {
+    if data.has_target_feature() && !target_feature_is_safe {
         // RFC 2396 <https://rust-lang.github.io/rfcs/2396-target-feature-1.1.html>.
         let callee_target_features =
             TargetFeatures::from_attrs_no_implications(&db.attrs(func.into()));
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index 6eb8a8bf60fd1..3f78a04df1d29 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -2542,11 +2542,26 @@ impl Function {
         caller: Option<Function>,
         call_edition: Edition,
     ) -> bool {
-        let target_features = caller
-            .map(|caller| hir_ty::TargetFeatures::from_attrs(&db.attrs(caller.id.into())))
-            .unwrap_or_default();
+        let (target_features, target_feature_is_safe_in_target) = caller
+            .map(|caller| {
+                let target_features =
+                    hir_ty::TargetFeatures::from_attrs(&db.attrs(caller.id.into()));
+                let target_feature_is_safe_in_target =
+                    match &caller.krate(db).id.workspace_data(db).target {
+                        Ok(target) => hir_ty::target_feature_is_safe_in_target(target),
+                        Err(_) => false,
+                    };
+                (target_features, target_feature_is_safe_in_target)
+            })
+            .unwrap_or_else(|| (hir_ty::TargetFeatures::default(), false));
         matches!(
-            hir_ty::is_fn_unsafe_to_call(db, self.id, &target_features, call_edition),
+            hir_ty::is_fn_unsafe_to_call(
+                db,
+                self.id,
+                &target_features,
+                call_edition,
+                target_feature_is_safe_in_target
+            ),
             hir_ty::Unsafety::Unsafe
         )
     }
diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_unsafe.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_unsafe.rs
index 17caf63018256..4bb64747f5bb7 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_unsafe.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_unsafe.rs
@@ -998,4 +998,20 @@ extern "C" fn naked() {
         "#,
         );
     }
+
+    #[test]
+    fn target_feature_safe_on_wasm() {
+        check_diagnostics(
+            r#"
+//- target_arch: wasm32
+
+#[target_feature(enable = "simd128")]
+fn requires_target_feature() {}
+
+fn main() {
+    requires_target_feature();
+}
+            "#,
+        );
+    }
 }

From 4c84f0a1b8740503f98723c66b90a921302098b4 Mon Sep 17 00:00:00 2001
From: WANG Rui <wangrui@loongson.cn>
Date: Tue, 9 Sep 2025 20:26:45 +0800
Subject: [PATCH 0713/1889] Update the LoongArch target documentation

This patch defines minimum CPU feature requirements, updates toolchain
baseline, and streamlines maintainer list:

- Specify double-precision floating-point and LSX as mandatory CPU features
- Raise the minimum required binutils version to 2.42+, due to relocations
  introduced by the default medium code model
- Remove outdated maintainers to reduce irrelevant notifications
---
 src/doc/rustc/src/platform-support.md             |  4 ++--
 .../rustc/src/platform-support/loongarch-linux.md | 15 +++++++++------
 2 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/src/doc/rustc/src/platform-support.md b/src/doc/rustc/src/platform-support.md
index 6c5b48d8c8f5c..9ad9cb5b5264e 100644
--- a/src/doc/rustc/src/platform-support.md
+++ b/src/doc/rustc/src/platform-support.md
@@ -95,8 +95,8 @@ target | notes
 `arm-unknown-linux-gnueabihf` | Armv6 Linux, hardfloat (kernel 3.2+, glibc 2.17)
 `armv7-unknown-linux-gnueabihf` | Armv7-A Linux, hardfloat (kernel 3.2+, glibc 2.17)
 [`armv7-unknown-linux-ohos`](platform-support/openharmony.md) | Armv7-A OpenHarmony
-[`loongarch64-unknown-linux-gnu`](platform-support/loongarch-linux.md) | LoongArch64 Linux, LP64D ABI (kernel 5.19+, glibc 2.36)
-[`loongarch64-unknown-linux-musl`](platform-support/loongarch-linux.md) | LoongArch64 Linux, LP64D ABI (kernel 5.19+, musl 1.2.5)
+[`loongarch64-unknown-linux-gnu`](platform-support/loongarch-linux.md) | LoongArch64 Linux, LP64D ABI (kernel 5.19+, glibc 2.36), LSX required
+[`loongarch64-unknown-linux-musl`](platform-support/loongarch-linux.md) | LoongArch64 Linux, LP64D ABI (kernel 5.19+, musl 1.2.5), LSX required
 [`i686-pc-windows-gnu`](platform-support/windows-gnu.md) | 32-bit MinGW (Windows 10+, Windows Server 2016+, Pentium 4) [^x86_32-floats-return-ABI] [^win32-msvc-alignment]
 `powerpc-unknown-linux-gnu` | PowerPC Linux (kernel 3.2+, glibc 2.17)
 `powerpc64-unknown-linux-gnu` | PPC64 Linux (kernel 3.2+, glibc 2.17)
diff --git a/src/doc/rustc/src/platform-support/loongarch-linux.md b/src/doc/rustc/src/platform-support/loongarch-linux.md
index 817d3a892303a..a923218282c1e 100644
--- a/src/doc/rustc/src/platform-support/loongarch-linux.md
+++ b/src/doc/rustc/src/platform-support/loongarch-linux.md
@@ -7,8 +7,8 @@ LoongArch is a RISC ISA developed by Loongson Technology Corporation Limited.
 
 | Target | Description |
 |--------|-------------|
-| `loongarch64-unknown-linux-gnu` | LoongArch64 Linux, LP64D ABI (kernel 5.19, glibc 2.36) |
-| `loongarch64-unknown-linux-musl` | LoongArch64 Linux, LP64D ABI (kernel 5.19, musl 1.2.5) |
+| `loongarch64-unknown-linux-gnu` | LoongArch64 Linux, LP64D ABI (kernel 5.19, glibc 2.36), LSX required |
+| `loongarch64-unknown-linux-musl` | LoongArch64 Linux, LP64D ABI (kernel 5.19, musl 1.2.5), LSX required |
 
 These support both native and cross builds, and have full support for `std`.
 
@@ -23,8 +23,6 @@ Reference material:
 ## Target maintainers
 
 [@heiher](https://github.com/heiher)
-[@xiangzhai](https://github.com/xiangzhai)
-[@zhaixiaojuan](https://github.com/zhaixiaojuan)
 [@xen0n](https://github.com/xen0n)
 
 ## Requirements
@@ -46,8 +44,8 @@ The targets require a reasonably up-to-date LoongArch toolchain on the host.
 Currently the following components are used by the Rust CI to build the target,
 and the versions can be seen as the minimum requirement:
 
-* GNU Binutils 2.40
-* GCC 13.x
+* GNU Binutils 2.42
+* GCC 14.x
 * glibc 2.36
 * linux-headers 5.19
 
@@ -59,6 +57,11 @@ for newer LoongArch ELF relocation types, among other features.
 Recent LLVM/Clang toolchains may be able to build the targets, but are not
 currently being actively tested.
 
+### CPU features
+
+These targets require the double-precision floating-point and LSX (LoongArch
+SIMD Extension) features.
+
 ## Building
 
 These targets are distributed through `rustup`, and otherwise require no

From e379c7758667f900aaf5551c4553c7d4c121e3e1 Mon Sep 17 00:00:00 2001
From: Boxy <rust@boxyuwu.dev>
Date: Thu, 21 Aug 2025 16:50:54 +0100
Subject: [PATCH 0714/1889] erase_regions to erase_and_anonymize_regions

---
 .../rustc_borrowck/src/region_infer/mod.rs    |  2 +-
 .../src/region_infer/opaque_types/mod.rs      |  2 +-
 compiler/rustc_borrowck/src/type_check/mod.rs |  8 ++--
 compiler/rustc_codegen_gcc/src/type_of.rs     |  2 +-
 .../src/debuginfo/metadata.rs                 |  4 +-
 compiler/rustc_codegen_llvm/src/type_of.rs    |  2 +-
 .../rustc_const_eval/src/interpret/traits.rs  |  7 ++--
 .../rustc_hir_analysis/src/check/wfcheck.rs   |  2 +-
 .../src/coherence/orphan.rs                   |  2 +-
 .../src/hir_ty_lowering/errors.rs             |  2 +-
 compiler/rustc_hir_typeck/src/cast.rs         |  4 +-
 .../src/fn_ctxt/suggestions.rs                |  2 +-
 compiler/rustc_hir_typeck/src/inline_asm.rs   |  2 +-
 compiler/rustc_hir_typeck/src/writeback.rs    |  4 +-
 .../src/infer/outlives/test_type_match.rs     |  2 +-
 .../rustc_infer/src/infer/outlives/verify.rs  |  4 +-
 .../src/deref_into_dyn_supertrait.rs          |  2 +-
 .../src/for_loops_over_fallibles.rs           |  2 +-
 compiler/rustc_lint/src/types.rs              |  2 +-
 .../rustc_middle/src/mir/interpret/queries.rs | 12 +++---
 compiler/rustc_middle/src/query/mod.rs        |  4 +-
 .../rustc_middle/src/ty/abstract_const.rs     |  2 +-
 compiler/rustc_middle/src/ty/erase_regions.rs | 28 ++++++-------
 compiler/rustc_middle/src/ty/instance.rs      |  4 +-
 compiler/rustc_middle/src/ty/layout.rs        |  5 ++-
 .../src/ty/normalize_erasing_regions.rs       |  4 +-
 compiler/rustc_middle/src/ty/print/pretty.rs  |  4 +-
 compiler/rustc_middle/src/ty/util.rs          | 10 ++---
 compiler/rustc_middle/src/ty/vtable.rs        |  2 +-
 .../rustc_mir_build/src/check_tail_calls.rs   |  4 +-
 compiler/rustc_mir_build/src/thir/cx/expr.rs  | 13 ++++---
 .../src/thir/pattern/const_to_pat.rs          |  8 ++--
 .../rustc_mir_dataflow/src/value_analysis.rs  |  2 +-
 .../src/add_subtyping_projections.rs          |  4 +-
 .../rustc_mir_transform/src/promote_consts.rs |  3 +-
 compiler/rustc_monomorphize/src/collector.rs  |  2 +-
 compiler/rustc_symbol_mangling/src/legacy.rs  |  7 +++-
 compiler/rustc_symbol_mangling/src/test.rs    |  2 +-
 compiler/rustc_symbol_mangling/src/v0.rs      |  5 ++-
 .../src/error_reporting/infer/mod.rs          |  4 +-
 .../error_reporting/infer/note_and_explain.rs |  6 ++-
 .../traits/fulfillment_errors.rs              |  7 ++--
 .../src/error_reporting/traits/suggestions.rs |  6 +--
 .../src/solve/delegate.rs                     |  2 +-
 .../src/traits/dyn_compatibility.rs           |  2 +-
 .../rustc_trait_selection/src/traits/mod.rs   |  8 ++--
 .../src/traits/query/dropck_outlives.rs       |  2 +-
 compiler/rustc_traits/src/codegen.rs          |  2 +-
 .../src/normalize_erasing_regions.rs          |  2 +-
 compiler/rustc_transmute/src/layout/mod.rs    |  2 +-
 compiler/rustc_transmute/src/layout/tree.rs   | 39 ++++++++++---------
 compiler/rustc_ty_utils/src/instance.rs       |  8 ++--
 compiler/rustc_type_ir/src/visit.rs           |  2 +-
 .../clippy/clippy_lints/src/dereference.rs    |  2 +-
 .../src/loops/explicit_iter_loop.rs           |  2 +-
 .../src/only_used_in_recursion.rs             |  2 +-
 .../src/transmute/transmute_ref_to_ref.rs     |  2 +-
 .../src/transmute/transmute_undefined_repr.rs |  4 +-
 .../clippy_lints/src/useless_conversion.rs    |  2 +-
 src/tools/clippy/clippy_utils/src/ty/mod.rs   |  2 +-
 60 files changed, 158 insertions(+), 132 deletions(-)

diff --git a/compiler/rustc_borrowck/src/region_infer/mod.rs b/compiler/rustc_borrowck/src/region_infer/mod.rs
index 9990f4cb3f2ae..f57456949bb5e 100644
--- a/compiler/rustc_borrowck/src/region_infer/mod.rs
+++ b/compiler/rustc_borrowck/src/region_infer/mod.rs
@@ -615,7 +615,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
             }
 
             // Type-test failed. Report the error.
-            let erased_generic_kind = infcx.tcx.erase_regions(type_test.generic_kind);
+            let erased_generic_kind = infcx.tcx.erase_and_anonymize_regions(type_test.generic_kind);
 
             // Skip duplicate-ish errors.
             if deduplicate_errors.insert((
diff --git a/compiler/rustc_borrowck/src/region_infer/opaque_types/mod.rs b/compiler/rustc_borrowck/src/region_infer/opaque_types/mod.rs
index 95c5366a6c8e1..0af636aa734ca 100644
--- a/compiler/rustc_borrowck/src/region_infer/opaque_types/mod.rs
+++ b/compiler/rustc_borrowck/src/region_infer/opaque_types/mod.rs
@@ -341,7 +341,7 @@ fn compute_concrete_types_from_defining_uses<'tcx>(
         //
         // FIXME(-Znext-solver): This isn't necessary after all. We can remove this check again.
         if let Some((prev_decl_key, prev_span)) = decls_modulo_regions.insert(
-            rcx.infcx.tcx.erase_regions(opaque_type_key),
+            rcx.infcx.tcx.erase_and_anonymize_regions(opaque_type_key),
             (opaque_type_key, hidden_type.span),
         ) && let Some((arg1, arg2)) = std::iter::zip(
             prev_decl_key.iter_captured_args(infcx.tcx).map(|(_, arg)| arg),
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
index 02be78f90b0d6..8c5447fe1e9e7 100644
--- a/compiler/rustc_borrowck/src/type_check/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -1892,7 +1892,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         if is_diverging {
             // The signature in this call can reference region variables,
             // so erase them before calling a query.
-            let output_ty = self.tcx().erase_regions(sig.output());
+            let output_ty = self.tcx().erase_and_anonymize_regions(sig.output());
             if !output_ty
                 .is_privately_uninhabited(self.tcx(), self.infcx.typing_env(self.infcx.param_env))
             {
@@ -1986,7 +1986,9 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
 
             let op_arg_ty = self.normalize(op_arg_ty, term_location);
             let category = if call_source.from_hir_call() {
-                ConstraintCategory::CallArgument(Some(self.infcx.tcx.erase_regions(func_ty)))
+                ConstraintCategory::CallArgument(Some(
+                    self.infcx.tcx.erase_and_anonymize_regions(func_ty),
+                ))
             } else {
                 ConstraintCategory::Boring
             };
@@ -2120,7 +2122,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         // Erase the regions from `ty` to get a global type. The
         // `Sized` bound in no way depends on precise regions, so this
         // shouldn't affect `is_sized`.
-        let erased_ty = tcx.erase_regions(ty);
+        let erased_ty = tcx.erase_and_anonymize_regions(ty);
         // FIXME(#132279): Using `Ty::is_sized` causes us to incorrectly handle opaques here.
         if !erased_ty.is_sized(tcx, self.infcx.typing_env(self.infcx.param_env)) {
             // in current MIR construction, all non-control-flow rvalue
diff --git a/compiler/rustc_codegen_gcc/src/type_of.rs b/compiler/rustc_codegen_gcc/src/type_of.rs
index 093f902bc3d86..93202483eed81 100644
--- a/compiler/rustc_codegen_gcc/src/type_of.rs
+++ b/compiler/rustc_codegen_gcc/src/type_of.rs
@@ -240,7 +240,7 @@ impl<'tcx> LayoutGccExt<'tcx> for TyAndLayout<'tcx> {
 
         // Make sure lifetimes are erased, to avoid generating distinct LLVM
         // types for Rust types that only differ in the choice of lifetimes.
-        let normal_ty = cx.tcx.erase_regions(self.ty);
+        let normal_ty = cx.tcx.erase_and_anonymize_regions(self.ty);
 
         let mut defer = None;
         let ty = if self.ty != normal_ty {
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
index caa3369f413a8..0d71de21fef02 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
@@ -1435,7 +1435,7 @@ fn build_vtable_type_di_node<'ll, 'tcx>(
 
     let vtable_entries = if let Some(poly_trait_ref) = poly_trait_ref {
         let trait_ref = poly_trait_ref.with_self_ty(tcx, ty);
-        let trait_ref = tcx.erase_regions(trait_ref);
+        let trait_ref = tcx.erase_and_anonymize_regions(trait_ref);
 
         tcx.vtable_entries(trait_ref)
     } else {
@@ -1562,7 +1562,7 @@ pub(crate) fn apply_vcall_visibility_metadata<'ll, 'tcx>(
     // Unwrap potential addrspacecast
     let vtable = find_vtable_behind_cast(vtable);
     let trait_ref_self = trait_ref.with_self_ty(cx.tcx, ty);
-    let trait_ref_self = cx.tcx.erase_regions(trait_ref_self);
+    let trait_ref_self = cx.tcx.erase_and_anonymize_regions(trait_ref_self);
     let trait_def_id = trait_ref_self.def_id;
     let trait_vis = cx.tcx.visibility(trait_def_id);
 
diff --git a/compiler/rustc_codegen_llvm/src/type_of.rs b/compiler/rustc_codegen_llvm/src/type_of.rs
index 4e7096da502d0..d28ffc4c96e78 100644
--- a/compiler/rustc_codegen_llvm/src/type_of.rs
+++ b/compiler/rustc_codegen_llvm/src/type_of.rs
@@ -226,7 +226,7 @@ impl<'tcx> LayoutLlvmExt<'tcx> for TyAndLayout<'tcx> {
 
         // Make sure lifetimes are erased, to avoid generating distinct LLVM
         // types for Rust types that only differ in the choice of lifetimes.
-        let normal_ty = cx.tcx.erase_regions(self.ty);
+        let normal_ty = cx.tcx.erase_and_anonymize_regions(self.ty);
 
         let mut defer = None;
         let llty = if self.ty != normal_ty {
diff --git a/compiler/rustc_const_eval/src/interpret/traits.rs b/compiler/rustc_const_eval/src/interpret/traits.rs
index e4b5c82853a28..870f9a396ae2b 100644
--- a/compiler/rustc_const_eval/src/interpret/traits.rs
+++ b/compiler/rustc_const_eval/src/interpret/traits.rs
@@ -23,7 +23,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
     ) -> InterpResult<'tcx, Pointer<Option<M::Provenance>>> {
         trace!("get_vtable(ty={ty:?}, dyn_ty={dyn_ty:?})");
 
-        let (ty, dyn_ty) = self.tcx.erase_regions((ty, dyn_ty));
+        let (ty, dyn_ty) = self.tcx.erase_and_anonymize_regions((ty, dyn_ty));
 
         // All vtables must be monomorphic, bail out otherwise.
         ensure_monomorphic_enough(*self.tcx, ty)?;
@@ -53,8 +53,9 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
     ) -> &'tcx [VtblEntry<'tcx>] {
         if let Some(trait_) = trait_ {
             let trait_ref = trait_.with_self_ty(*self.tcx, dyn_ty);
-            let trait_ref =
-                self.tcx.erase_regions(self.tcx.instantiate_bound_regions_with_erased(trait_ref));
+            let trait_ref = self.tcx.erase_and_anonymize_regions(
+                self.tcx.instantiate_bound_regions_with_erased(trait_ref),
+            );
             self.tcx.vtable_entries(trait_ref)
         } else {
             TyCtxt::COMMON_VTABLE_ENTRIES
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
index e6a1f6d8d8bb7..22a9446fd4cf1 100644
--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -1047,7 +1047,7 @@ fn check_type_defn<'tcx>(
             let needs_drop_copy = || {
                 packed && {
                     let ty = tcx.type_of(variant.tail().did).instantiate_identity();
-                    let ty = tcx.erase_regions(ty);
+                    let ty = tcx.erase_and_anonymize_regions(ty);
                     assert!(!ty.has_infer());
                     ty.needs_drop(tcx, wfcx.infcx.typing_env(wfcx.param_env))
                 }
diff --git a/compiler/rustc_hir_analysis/src/coherence/orphan.rs b/compiler/rustc_hir_analysis/src/coherence/orphan.rs
index f707196c81635..621431ae2343c 100644
--- a/compiler/rustc_hir_analysis/src/coherence/orphan.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/orphan.rs
@@ -404,7 +404,7 @@ fn emit_orphan_check_error<'tcx>(
                     of_trait.trait_ref.path.span
                 };
 
-                ty = tcx.erase_regions(ty);
+                ty = tcx.erase_and_anonymize_regions(ty);
 
                 let is_foreign =
                     !trait_ref.def_id.is_local() && matches!(is_target_ty, IsFirstInputType::No);
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 93b82acf6212c..0cf9cb7193f72 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
@@ -482,7 +482,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 .map(|header| header.trait_ref.instantiate_identity().self_ty())
                 // We don't care about blanket impls.
                 .filter(|self_ty| !self_ty.has_non_region_param())
-                .map(|self_ty| tcx.erase_regions(self_ty).to_string())
+                .map(|self_ty| tcx.erase_and_anonymize_regions(self_ty).to_string())
                 .collect()
         };
         // FIXME: also look at `tcx.generics_of(self.item_def_id()).params` any that
diff --git a/compiler/rustc_hir_typeck/src/cast.rs b/compiler/rustc_hir_typeck/src/cast.rs
index 3eeb0eac023a9..27540fd1a4382 100644
--- a/compiler/rustc_hir_typeck/src/cast.rs
+++ b/compiler/rustc_hir_typeck/src/cast.rs
@@ -851,8 +851,8 @@ impl<'a, 'tcx> CastCheck<'tcx> {
         debug!("check_ptr_ptr_cast m_src={m_src:?} m_dst={m_dst:?}");
         // ptr-ptr cast. metadata must match.
 
-        let src_kind = fcx.tcx.erase_regions(fcx.pointer_kind(m_src.ty, self.span)?);
-        let dst_kind = fcx.tcx.erase_regions(fcx.pointer_kind(m_dst.ty, self.span)?);
+        let src_kind = fcx.tcx.erase_and_anonymize_regions(fcx.pointer_kind(m_src.ty, self.span)?);
+        let dst_kind = fcx.tcx.erase_and_anonymize_regions(fcx.pointer_kind(m_dst.ty, self.span)?);
 
         // We can't cast if target pointer kind is unknown
         let Some(dst_kind) = dst_kind else {
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
index 84ea2ec0f8a43..d7ddbcc8b53b4 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
@@ -1358,7 +1358,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 .infcx
                 .type_implements_trait(
                     clone_trait_def,
-                    [self.tcx.erase_regions(expected_ty)],
+                    [self.tcx.erase_and_anonymize_regions(expected_ty)],
                     self.param_env,
                 )
                 .must_apply_modulo_regions()
diff --git a/compiler/rustc_hir_typeck/src/inline_asm.rs b/compiler/rustc_hir_typeck/src/inline_asm.rs
index b59c1752c25ad..c0cd23be6909d 100644
--- a/compiler/rustc_hir_typeck/src/inline_asm.rs
+++ b/compiler/rustc_hir_typeck/src/inline_asm.rs
@@ -44,7 +44,7 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
         if ty.has_non_region_infer() {
             Ty::new_misc_error(self.tcx())
         } else {
-            self.tcx().erase_regions(ty)
+            self.tcx().erase_and_anonymize_regions(ty)
         }
     }
 
diff --git a/compiler/rustc_hir_typeck/src/writeback.rs b/compiler/rustc_hir_typeck/src/writeback.rs
index d75bc9edab20a..8e0180426ef6a 100644
--- a/compiler/rustc_hir_typeck/src/writeback.rs
+++ b/compiler/rustc_hir_typeck/src/writeback.rs
@@ -802,7 +802,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
                         format!("unexpected inference variable after writeback: {predicate:?}"),
                     );
                 } else {
-                    let predicate = self.tcx().erase_regions(predicate);
+                    let predicate = self.tcx().erase_and_anonymize_regions(predicate);
                     if cause.has_infer() || cause.has_placeholders() {
                         // We can't use the the obligation cause as it references
                         // information local to this query.
@@ -984,7 +984,7 @@ impl<'cx, 'tcx> Resolver<'cx, 'tcx> {
         // borrowck, and specifically region constraints will be populated during
         // MIR typeck which is run on the new body.
         //
-        // We're not using `tcx.erase_regions` as that also anonymizes bound variables,
+        // We're not using `tcx.erase_and_anonymize_regions` as that also anonymizes bound variables,
         // regressing borrowck diagnostics.
         value = fold_regions(tcx, value, |_, _| tcx.lifetimes.re_erased);
 
diff --git a/compiler/rustc_infer/src/infer/outlives/test_type_match.rs b/compiler/rustc_infer/src/infer/outlives/test_type_match.rs
index bfdd282d7e11d..f06eb58a371c2 100644
--- a/compiler/rustc_infer/src/infer/outlives/test_type_match.rs
+++ b/compiler/rustc_infer/src/infer/outlives/test_type_match.rs
@@ -76,7 +76,7 @@ pub(super) fn can_match_erased_ty<'tcx>(
     erased_ty: Ty<'tcx>,
 ) -> bool {
     assert!(!outlives_predicate.has_escaping_bound_vars());
-    let erased_outlives_predicate = tcx.erase_regions(outlives_predicate);
+    let erased_outlives_predicate = tcx.erase_and_anonymize_regions(outlives_predicate);
     let outlives_ty = erased_outlives_predicate.skip_binder().0;
     if outlives_ty == erased_ty {
         // pointless micro-optimization
diff --git a/compiler/rustc_infer/src/infer/outlives/verify.rs b/compiler/rustc_infer/src/infer/outlives/verify.rs
index 69feecfe30a49..f67b99cb3f846 100644
--- a/compiler/rustc_infer/src/infer/outlives/verify.rs
+++ b/compiler/rustc_infer/src/infer/outlives/verify.rs
@@ -96,7 +96,7 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
         &self,
         alias_ty: ty::AliasTy<'tcx>,
     ) -> Vec<ty::PolyTypeOutlivesPredicate<'tcx>> {
-        let erased_alias_ty = self.tcx.erase_regions(alias_ty.to_ty(self.tcx));
+        let erased_alias_ty = self.tcx.erase_and_anonymize_regions(alias_ty.to_ty(self.tcx));
         self.declared_generic_bounds_from_env_for_erased_ty(erased_alias_ty)
     }
 
@@ -241,7 +241,7 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
             }
 
             let p_ty = p.to_ty(tcx);
-            let erased_p_ty = self.tcx.erase_regions(p_ty);
+            let erased_p_ty = self.tcx.erase_and_anonymize_regions(p_ty);
             (erased_p_ty == erased_ty).then_some(ty::Binder::dummy(ty::OutlivesPredicate(p_ty, r)))
         }));
 
diff --git a/compiler/rustc_lint/src/deref_into_dyn_supertrait.rs b/compiler/rustc_lint/src/deref_into_dyn_supertrait.rs
index 943fcc0801b1e..e1c51ff829907 100644
--- a/compiler/rustc_lint/src/deref_into_dyn_supertrait.rs
+++ b/compiler/rustc_lint/src/deref_into_dyn_supertrait.rs
@@ -78,7 +78,7 @@ impl<'tcx> LateLintPass<'tcx> for DerefIntoDynSupertrait {
         {
             // erase regions in self type for better diagnostic presentation
             let (self_ty, target_principal, supertrait_principal) =
-                tcx.erase_regions((self_ty, target_principal, supertrait_principal));
+                tcx.erase_and_anonymize_regions((self_ty, target_principal, supertrait_principal));
             let label2 = tcx
                 .associated_items(item.owner_id)
                 .find_by_ident_and_kind(
diff --git a/compiler/rustc_lint/src/for_loops_over_fallibles.rs b/compiler/rustc_lint/src/for_loops_over_fallibles.rs
index a56b753bda726..9e1fc59817119 100644
--- a/compiler/rustc_lint/src/for_loops_over_fallibles.rs
+++ b/compiler/rustc_lint/src/for_loops_over_fallibles.rs
@@ -176,7 +176,7 @@ fn suggest_question_mark<'tcx>(
         cause,
         param_env,
         // Erase any region vids from the type, which may not be resolved
-        infcx.tcx.erase_regions(ty),
+        infcx.tcx.erase_and_anonymize_regions(ty),
         into_iterator_did,
     );
 
diff --git a/compiler/rustc_lint/src/types.rs b/compiler/rustc_lint/src/types.rs
index a72b802eb5d13..88527fa2e6e78 100644
--- a/compiler/rustc_lint/src/types.rs
+++ b/compiler/rustc_lint/src/types.rs
@@ -935,7 +935,7 @@ impl<'tcx> LateLintPass<'tcx> for VariantSizeDifferences {
     fn check_item(&mut self, cx: &LateContext<'_>, it: &hir::Item<'_>) {
         if let hir::ItemKind::Enum(_, _, ref enum_definition) = it.kind {
             let t = cx.tcx.type_of(it.owner_id).instantiate_identity();
-            let ty = cx.tcx.erase_regions(t);
+            let ty = cx.tcx.erase_and_anonymize_regions(t);
             let Ok(layout) = cx.layout_of(ty) else { return };
             let Variants::Multiple { tag_encoding: TagEncoding::Direct, tag, variants, .. } =
                 &layout.variants
diff --git a/compiler/rustc_middle/src/mir/interpret/queries.rs b/compiler/rustc_middle/src/mir/interpret/queries.rs
index e25f35c59c286..ecf35d9dd6d7e 100644
--- a/compiler/rustc_middle/src/mir/interpret/queries.rs
+++ b/compiler/rustc_middle/src/mir/interpret/queries.rs
@@ -41,7 +41,7 @@ impl<'tcx> TyCtxt<'tcx> {
         let instance = ty::Instance::new_raw(def_id, args);
         let cid = GlobalId { instance, promoted: None };
         let typing_env = ty::TypingEnv::post_analysis(self, def_id);
-        let inputs = self.erase_regions(typing_env.as_query_input(cid));
+        let inputs = self.erase_and_anonymize_regions(typing_env.as_query_input(cid));
         self.eval_to_allocation_raw(inputs)
     }
 
@@ -172,8 +172,9 @@ impl<'tcx> TyCtxt<'tcx> {
     ) -> EvalToConstValueResult<'tcx> {
         // Const-eval shouldn't depend on lifetimes at all, so we can erase them, which should
         // improve caching of queries.
-        let inputs =
-            self.erase_regions(typing_env.with_post_analysis_normalized(self).as_query_input(cid));
+        let inputs = self.erase_and_anonymize_regions(
+            typing_env.with_post_analysis_normalized(self).as_query_input(cid),
+        );
         if !span.is_dummy() {
             // The query doesn't know where it is being invoked, so we need to fix the span.
             self.at(span).eval_to_const_value_raw(inputs).map_err(|e| e.with_span(span))
@@ -192,8 +193,9 @@ impl<'tcx> TyCtxt<'tcx> {
     ) -> ConstToValTreeResult<'tcx> {
         // Const-eval shouldn't depend on lifetimes at all, so we can erase them, which should
         // improve caching of queries.
-        let inputs =
-            self.erase_regions(typing_env.with_post_analysis_normalized(self).as_query_input(cid));
+        let inputs = self.erase_and_anonymize_regions(
+            typing_env.with_post_analysis_normalized(self).as_query_input(cid),
+        );
         debug!(?inputs);
         let res = if !span.is_dummy() {
             // The query doesn't know where it is being invoked, so we need to fix the span.
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 8fba218cc71cd..2aa32dfa0d825 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -761,9 +761,9 @@ rustc_queries! {
     }
 
     /// Erases regions from `ty` to yield a new type.
-    /// Normally you would just use `tcx.erase_regions(value)`,
+    /// Normally you would just use `tcx.erase_and_anonymize_regions(value)`,
     /// however, which uses this query as a kind of cache.
-    query erase_regions_ty(ty: Ty<'tcx>) -> Ty<'tcx> {
+    query erase_and_anonymize_regions_ty(ty: Ty<'tcx>) -> Ty<'tcx> {
         // This query is not expected to have input -- as a result, it
         // is not a good candidates for "replay" because it is essentially a
         // pure function of its input (and hence the expectation is that
diff --git a/compiler/rustc_middle/src/ty/abstract_const.rs b/compiler/rustc_middle/src/ty/abstract_const.rs
index c9b9ec771b324..463e4c5880556 100644
--- a/compiler/rustc_middle/src/ty/abstract_const.rs
+++ b/compiler/rustc_middle/src/ty/abstract_const.rs
@@ -55,7 +55,7 @@ impl<'tcx> TyCtxt<'tcx> {
                     ty::ConstKind::Unevaluated(uv) => match self.tcx.thir_abstract_const(uv.def) {
                         Err(e) => ty::Const::new_error(self.tcx, e),
                         Ok(Some(bac)) => {
-                            let args = self.tcx.erase_regions(uv.args);
+                            let args = self.tcx.erase_and_anonymize_regions(uv.args);
                             let bac = bac.instantiate(self.tcx, args);
                             return bac.fold_with(self);
                         }
diff --git a/compiler/rustc_middle/src/ty/erase_regions.rs b/compiler/rustc_middle/src/ty/erase_regions.rs
index f4fead7e9526d..74b4adda7fdd4 100644
--- a/compiler/rustc_middle/src/ty/erase_regions.rs
+++ b/compiler/rustc_middle/src/ty/erase_regions.rs
@@ -6,20 +6,20 @@ use crate::ty::{
 };
 
 pub(super) fn provide(providers: &mut Providers) {
-    *providers = Providers { erase_regions_ty, ..*providers };
+    *providers = Providers { erase_and_anonymize_regions_ty, ..*providers };
 }
 
-fn erase_regions_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
+fn erase_and_anonymize_regions_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
     // N.B., use `super_fold_with` here. If we used `fold_with`, it
-    // could invoke the `erase_regions_ty` query recursively.
-    ty.super_fold_with(&mut RegionEraserVisitor { tcx })
+    // could invoke the `erase_and_anonymize_regions_ty` query recursively.
+    ty.super_fold_with(&mut RegionEraserAndAnonymizerVisitor { tcx })
 }
 
 impl<'tcx> TyCtxt<'tcx> {
-    /// Returns an equivalent value with all free regions removed (note
-    /// that late-bound regions remain, because they are important for
-    /// subtyping, but they are anonymized and normalized as well)..
-    pub fn erase_regions<T>(self, value: T) -> T
+    /// Returns an equivalent value with all free regions removed and
+    /// bound regions anonymized. (note that bound regions are important
+    /// for subtyping and generally type equality so *cannot* be removed)
+    pub fn erase_and_anonymize_regions<T>(self, value: T) -> T
     where
         T: TypeFoldable<TyCtxt<'tcx>>,
     {
@@ -27,18 +27,18 @@ impl<'tcx> TyCtxt<'tcx> {
         if !value.has_type_flags(TypeFlags::HAS_BINDER_VARS | TypeFlags::HAS_FREE_REGIONS) {
             return value;
         }
-        debug!("erase_regions({:?})", value);
-        let value1 = value.fold_with(&mut RegionEraserVisitor { tcx: self });
-        debug!("erase_regions = {:?}", value1);
+        debug!("erase_and_anonymize_regions({:?})", value);
+        let value1 = value.fold_with(&mut RegionEraserAndAnonymizerVisitor { tcx: self });
+        debug!("erase_and_anonymize_regions = {:?}", value1);
         value1
     }
 }
 
-struct RegionEraserVisitor<'tcx> {
+struct RegionEraserAndAnonymizerVisitor<'tcx> {
     tcx: TyCtxt<'tcx>,
 }
 
-impl<'tcx> TypeFolder<TyCtxt<'tcx>> for RegionEraserVisitor<'tcx> {
+impl<'tcx> TypeFolder<TyCtxt<'tcx>> for RegionEraserAndAnonymizerVisitor<'tcx> {
     fn cx(&self) -> TyCtxt<'tcx> {
         self.tcx
     }
@@ -49,7 +49,7 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for RegionEraserVisitor<'tcx> {
         } else if ty.has_infer() {
             ty.super_fold_with(self)
         } else {
-            self.tcx.erase_regions_ty(ty)
+            self.tcx.erase_and_anonymize_regions_ty(ty)
         }
     }
 
diff --git a/compiler/rustc_middle/src/ty/instance.rs b/compiler/rustc_middle/src/ty/instance.rs
index 3a51f79f12169..e76993e0542bd 100644
--- a/compiler/rustc_middle/src/ty/instance.rs
+++ b/compiler/rustc_middle/src/ty/instance.rs
@@ -544,7 +544,9 @@ impl<'tcx> Instance<'tcx> {
 
         // All regions in the result of this query are erased, so it's
         // fine to erase all of the input regions.
-        tcx.resolve_instance_raw(tcx.erase_regions(typing_env.as_query_input((def_id, args))))
+        tcx.resolve_instance_raw(
+            tcx.erase_and_anonymize_regions(typing_env.as_query_input((def_id, args))),
+        )
     }
 
     pub fn expect_resolve(
diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs
index aed94f9aa04d8..2114d080dfa43 100644
--- a/compiler/rustc_middle/src/ty/layout.rs
+++ b/compiler/rustc_middle/src/ty/layout.rs
@@ -401,7 +401,10 @@ impl<'tcx> SizeSkeleton<'tcx> {
                 match tail.kind() {
                     ty::Param(_) | ty::Alias(ty::Projection | ty::Inherent, _) => {
                         debug_assert!(tail.has_non_region_param());
-                        Ok(SizeSkeleton::Pointer { non_zero, tail: tcx.erase_regions(tail) })
+                        Ok(SizeSkeleton::Pointer {
+                            non_zero,
+                            tail: tcx.erase_and_anonymize_regions(tail),
+                        })
                     }
                     ty::Error(guar) => {
                         // Fixes ICE #124031
diff --git a/compiler/rustc_middle/src/ty/normalize_erasing_regions.rs b/compiler/rustc_middle/src/ty/normalize_erasing_regions.rs
index f2a4a5a4ecf78..69c1eb9b34543 100644
--- a/compiler/rustc_middle/src/ty/normalize_erasing_regions.rs
+++ b/compiler/rustc_middle/src/ty/normalize_erasing_regions.rs
@@ -51,7 +51,7 @@ impl<'tcx> TyCtxt<'tcx> {
 
         // Erase first before we do the real query -- this keeps the
         // cache from being too polluted.
-        let value = self.erase_regions(value);
+        let value = self.erase_and_anonymize_regions(value);
         debug!(?value);
 
         if !value.has_aliases() {
@@ -83,7 +83,7 @@ impl<'tcx> TyCtxt<'tcx> {
 
         // Erase first before we do the real query -- this keeps the
         // cache from being too polluted.
-        let value = self.erase_regions(value);
+        let value = self.erase_and_anonymize_regions(value);
         debug!(?value);
 
         if !value.has_aliases() {
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index 74caee7336a5f..05c812b6f9050 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -1436,8 +1436,8 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
                                 // anonymized regions, but the super projections can still
                                 // contain named regions. So we erase and anonymize everything
                                 // here to compare the types modulo regions below.
-                                let proj = p.tcx().erase_regions(proj);
-                                let super_proj = p.tcx().erase_regions(super_proj);
+                                let proj = p.tcx().erase_and_anonymize_regions(proj);
+                                let super_proj = p.tcx().erase_and_anonymize_regions(super_proj);
 
                                 proj == super_proj
                             });
diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs
index a7d07adf78f02..5a9e1918e4c62 100644
--- a/compiler/rustc_middle/src/ty/util.rs
+++ b/compiler/rustc_middle/src/ty/util.rs
@@ -132,9 +132,9 @@ impl<'tcx> TyCtxt<'tcx> {
     /// context it's calculated within. This is used by the `type_id` intrinsic.
     pub fn type_id_hash(self, ty: Ty<'tcx>) -> Hash128 {
         // We want the type_id be independent of the types free regions, so we
-        // erase them. The erase_regions() call will also anonymize bound
-        // regions, which is desirable too.
-        let ty = self.erase_regions(ty);
+        // erase them. We also want type_id to be independnt of the names of bound
+        // regions so we anonymize them.
+        let ty = self.erase_and_anonymize_regions(ty);
 
         self.with_stable_hashing_context(|mut hcx| {
             let mut hasher = StableHasher::new();
@@ -1309,7 +1309,7 @@ impl<'tcx> Ty<'tcx> {
                 debug_assert!(!typing_env.param_env.has_infer());
                 let query_ty = tcx
                     .try_normalize_erasing_regions(typing_env, query_ty)
-                    .unwrap_or_else(|_| tcx.erase_regions(query_ty));
+                    .unwrap_or_else(|_| tcx.erase_and_anonymize_regions(query_ty));
 
                 tcx.needs_drop_raw(typing_env.as_query_input(query_ty))
             }
@@ -1346,7 +1346,7 @@ impl<'tcx> Ty<'tcx> {
                 debug_assert!(!typing_env.has_infer());
                 let query_ty = tcx
                     .try_normalize_erasing_regions(typing_env, query_ty)
-                    .unwrap_or_else(|_| tcx.erase_regions(query_ty));
+                    .unwrap_or_else(|_| tcx.erase_and_anonymize_regions(query_ty));
 
                 tcx.needs_async_drop_raw(typing_env.as_query_input(query_ty))
             }
diff --git a/compiler/rustc_middle/src/ty/vtable.rs b/compiler/rustc_middle/src/ty/vtable.rs
index 6fc19c82342f9..e2f09fdcb4b43 100644
--- a/compiler/rustc_middle/src/ty/vtable.rs
+++ b/compiler/rustc_middle/src/ty/vtable.rs
@@ -89,7 +89,7 @@ pub(super) fn vtable_allocation_provider<'tcx>(
 
     let vtable_entries = if let Some(poly_trait_ref) = poly_trait_ref {
         let trait_ref = poly_trait_ref.with_self_ty(tcx, ty);
-        let trait_ref = tcx.erase_regions(trait_ref);
+        let trait_ref = tcx.erase_and_anonymize_regions(trait_ref);
 
         tcx.vtable_entries(trait_ref)
     } else {
diff --git a/compiler/rustc_mir_build/src/check_tail_calls.rs b/compiler/rustc_mir_build/src/check_tail_calls.rs
index e0cbe8519edd5..43a4106297a3d 100644
--- a/compiler/rustc_mir_build/src/check_tail_calls.rs
+++ b/compiler/rustc_mir_build/src/check_tail_calls.rs
@@ -65,9 +65,9 @@ impl<'tcx> TailCallCkVisitor<'_, 'tcx> {
             )
         };
         // While the `caller_sig` does have its regions erased, it does not have its
-        // binders anonymized. We call `erase_regions` once again to anonymize any binders
+        // binders anonymized. We call `erase_and_anonymize_regions` once again to anonymize any binders
         // within the signature, such as in function pointer or `dyn Trait` args.
-        let caller_sig = self.tcx.erase_regions(caller_sig);
+        let caller_sig = self.tcx.erase_and_anonymize_regions(caller_sig);
 
         let ExprKind::Scope { value, .. } = call.kind else {
             span_bug!(call.span, "expected scope, found: {call:?}")
diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs
index 81b0e21a5f55a..0b9bc018a09b3 100644
--- a/compiler/rustc_mir_build/src/thir/cx/expr.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/expr.rs
@@ -792,10 +792,9 @@ impl<'tcx> ThirBuildCx<'tcx> {
                             let ty = self.typeck_results.node_type(anon_const.hir_id);
                             let did = anon_const.def_id.to_def_id();
                             let typeck_root_def_id = tcx.typeck_root_def_id(did);
-                            let parent_args = tcx.erase_regions(GenericArgs::identity_for_item(
-                                tcx,
-                                typeck_root_def_id,
-                            ));
+                            let parent_args = tcx.erase_and_anonymize_regions(
+                                GenericArgs::identity_for_item(tcx, typeck_root_def_id),
+                            );
                             let args =
                                 InlineConstArgs::new(tcx, InlineConstArgsParts { parent_args, ty })
                                     .args;
@@ -831,8 +830,10 @@ impl<'tcx> ThirBuildCx<'tcx> {
                 let ty = self.typeck_results.node_type(anon_const.hir_id);
                 let did = anon_const.def_id.to_def_id();
                 let typeck_root_def_id = tcx.typeck_root_def_id(did);
-                let parent_args =
-                    tcx.erase_regions(GenericArgs::identity_for_item(tcx, typeck_root_def_id));
+                let parent_args = tcx.erase_and_anonymize_regions(GenericArgs::identity_for_item(
+                    tcx,
+                    typeck_root_def_id,
+                ));
                 let args = InlineConstArgs::new(tcx, InlineConstArgsParts { parent_args, ty }).args;
 
                 ExprKind::ConstBlock { did, args }
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 d46c4678bcf7d..6316ccf1b8c5b 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
@@ -105,9 +105,11 @@ impl<'tcx> ConstToPat<'tcx> {
         //
         // FIXME: `const_eval_resolve_for_typeck` should probably just modify the env itself
         // instead of having this logic here
-        let typing_env =
-            self.tcx.erase_regions(self.typing_env).with_post_analysis_normalized(self.tcx);
-        let uv = self.tcx.erase_regions(uv);
+        let typing_env = self
+            .tcx
+            .erase_and_anonymize_regions(self.typing_env)
+            .with_post_analysis_normalized(self.tcx);
+        let uv = self.tcx.erase_and_anonymize_regions(uv);
 
         // try to resolve e.g. associated constants to their definition on an impl, and then
         // evaluate the const.
diff --git a/compiler/rustc_mir_dataflow/src/value_analysis.rs b/compiler/rustc_mir_dataflow/src/value_analysis.rs
index 9a00831dc012b..bf5ec8f459e61 100644
--- a/compiler/rustc_mir_dataflow/src/value_analysis.rs
+++ b/compiler/rustc_mir_dataflow/src/value_analysis.rs
@@ -891,7 +891,7 @@ pub fn iter_fields<'tcx>(
                     let field_ty = f_def.ty(tcx, args);
                     let field_ty = tcx
                         .try_normalize_erasing_regions(typing_env, field_ty)
-                        .unwrap_or_else(|_| tcx.erase_regions(field_ty));
+                        .unwrap_or_else(|_| tcx.erase_and_anonymize_regions(field_ty));
                     f(variant, f_index.into(), field_ty);
                 }
             }
diff --git a/compiler/rustc_mir_transform/src/add_subtyping_projections.rs b/compiler/rustc_mir_transform/src/add_subtyping_projections.rs
index 92ee80eaa353e..be4f84d64d03f 100644
--- a/compiler/rustc_mir_transform/src/add_subtyping_projections.rs
+++ b/compiler/rustc_mir_transform/src/add_subtyping_projections.rs
@@ -32,8 +32,8 @@ impl<'a, 'tcx> MutVisitor<'tcx> for SubTypeChecker<'a, 'tcx> {
         let mut rval_ty = rvalue.ty(self.local_decls, self.tcx);
         // Not erasing this causes `Free Regions` errors in validator,
         // when rval is `ReStatic`.
-        rval_ty = self.tcx.erase_regions(rval_ty);
-        place_ty = self.tcx.erase_regions(place_ty);
+        rval_ty = self.tcx.erase_and_anonymize_regions(rval_ty);
+        place_ty = self.tcx.erase_and_anonymize_regions(place_ty);
         if place_ty != rval_ty {
             let temp = self
                 .patcher
diff --git a/compiler/rustc_mir_transform/src/promote_consts.rs b/compiler/rustc_mir_transform/src/promote_consts.rs
index 462ddfa3dd3ca..9ea2eb4f25d91 100644
--- a/compiler/rustc_mir_transform/src/promote_consts.rs
+++ b/compiler/rustc_mir_transform/src/promote_consts.rs
@@ -875,7 +875,8 @@ impl<'a, 'tcx> Promoter<'a, 'tcx> {
             let mut promoted_operand = |ty, span| {
                 promoted.span = span;
                 promoted.local_decls[RETURN_PLACE] = LocalDecl::new(ty, span);
-                let args = tcx.erase_regions(GenericArgs::identity_for_item(tcx, def));
+                let args =
+                    tcx.erase_and_anonymize_regions(GenericArgs::identity_for_item(tcx, def));
                 let uneval =
                     mir::UnevaluatedConst { def, args, promoted: Some(next_promoted_index) };
 
diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs
index cffeb6f980755..77a3b12d19cbf 100644
--- a/compiler/rustc_monomorphize/src/collector.rs
+++ b/compiler/rustc_monomorphize/src/collector.rs
@@ -1558,7 +1558,7 @@ impl<'v> RootCollector<'_, 'v> {
                         ty::Closure(def_id, args)
                         | ty::Coroutine(def_id, args)
                         | ty::CoroutineClosure(def_id, args) => {
-                            Instance::new_raw(def_id, self.tcx.erase_regions(args))
+                            Instance::new_raw(def_id, self.tcx.erase_and_anonymize_regions(args))
                         }
                         _ => unreachable!(),
                     };
diff --git a/compiler/rustc_symbol_mangling/src/legacy.rs b/compiler/rustc_symbol_mangling/src/legacy.rs
index 4d9741f1d11cc..95a7ec61868d9 100644
--- a/compiler/rustc_symbol_mangling/src/legacy.rs
+++ b/compiler/rustc_symbol_mangling/src/legacy.rs
@@ -54,7 +54,7 @@ pub(super) fn mangle<'tcx>(
 
     // Erase regions because they may not be deterministic when hashed
     // and should not matter anyhow.
-    let instance_ty = tcx.erase_regions(instance_ty);
+    let instance_ty = tcx.erase_and_anonymize_regions(instance_ty);
 
     let hash = get_symbol_hash(tcx, instance, instance_ty, instantiating_crate);
 
@@ -422,7 +422,10 @@ impl<'tcx> Printer<'tcx> for LegacySymbolMangler<'tcx> {
             || &args[..generics.count()]
                 == self
                     .tcx
-                    .erase_regions(ty::GenericArgs::identity_for_item(self.tcx, impl_def_id))
+                    .erase_and_anonymize_regions(ty::GenericArgs::identity_for_item(
+                        self.tcx,
+                        impl_def_id,
+                    ))
                     .as_slice()
         {
             (
diff --git a/compiler/rustc_symbol_mangling/src/test.rs b/compiler/rustc_symbol_mangling/src/test.rs
index 0c6d1495e39cf..50935e7caf33c 100644
--- a/compiler/rustc_symbol_mangling/src/test.rs
+++ b/compiler/rustc_symbol_mangling/src/test.rs
@@ -58,7 +58,7 @@ impl SymbolNamesTest<'_> {
             let def_id = def_id.to_def_id();
             let instance = Instance::new_raw(
                 def_id,
-                tcx.erase_regions(GenericArgs::identity_for_item(tcx, def_id)),
+                tcx.erase_and_anonymize_regions(GenericArgs::identity_for_item(tcx, def_id)),
             );
             let mangled = tcx.symbol_name(instance);
             tcx.dcx().emit_err(TestOutput {
diff --git a/compiler/rustc_symbol_mangling/src/v0.rs b/compiler/rustc_symbol_mangling/src/v0.rs
index 0655c2d5e8145..121d3b6b10550 100644
--- a/compiler/rustc_symbol_mangling/src/v0.rs
+++ b/compiler/rustc_symbol_mangling/src/v0.rs
@@ -329,7 +329,10 @@ impl<'tcx> Printer<'tcx> for V0SymbolMangler<'tcx> {
             || &args[..generics.count()]
                 == self
                     .tcx
-                    .erase_regions(ty::GenericArgs::identity_for_item(self.tcx, impl_def_id))
+                    .erase_and_anonymize_regions(ty::GenericArgs::identity_for_item(
+                        self.tcx,
+                        impl_def_id,
+                    ))
                     .as_slice()
         {
             (
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 d3a17232a40d7..d71110521ffa5 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
@@ -1616,8 +1616,8 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             && let Some((e, f)) = values.ty()
             && let TypeError::ArgumentSorts(..) | TypeError::Sorts(_) = terr
         {
-            let e = self.tcx.erase_regions(e);
-            let f = self.tcx.erase_regions(f);
+            let e = self.tcx.erase_and_anonymize_regions(e);
+            let f = self.tcx.erase_and_anonymize_regions(f);
             let mut expected = with_forced_trimmed_paths!(e.sort_string(self.tcx));
             let mut found = with_forced_trimmed_paths!(f.sort_string(self.tcx));
             if let ObligationCauseCode::Pattern { span, .. } = cause.code()
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 40285e5d0e96c..e042ce84955e7 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
@@ -629,7 +629,11 @@ impl<T> Trait<T> for X {
         let tcx = self.tcx;
 
         // Don't suggest constraining a projection to something containing itself
-        if self.tcx.erase_regions(values.found).contains(self.tcx.erase_regions(values.expected)) {
+        if self
+            .tcx
+            .erase_and_anonymize_regions(values.found)
+            .contains(self.tcx.erase_and_anonymize_regions(values.expected))
+        {
             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 bc984f30472d9..c82043f022238 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
@@ -75,7 +75,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 {
                     if let Some(cause) = self
                         .tcx
-                        .diagnostic_hir_wf_check((tcx.erase_regions(obligation.predicate), *wf_loc))
+                        .diagnostic_hir_wf_check((tcx.erase_and_anonymize_regions(obligation.predicate), *wf_loc))
                     {
                         obligation.cause = cause.clone();
                         span = obligation.cause.span;
@@ -2612,8 +2612,9 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             }
 
             // Erase regions because layout code doesn't particularly care about regions.
-            let trait_pred =
-                self.tcx.erase_regions(self.tcx.instantiate_bound_regions_with_erased(trait_pred));
+            let trait_pred = self.tcx.erase_and_anonymize_regions(
+                self.tcx.instantiate_bound_regions_with_erased(trait_pred),
+            );
 
             let src_and_dst = rustc_transmute::Types {
                 dst: trait_pred.trait_ref.args.type_at(0),
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 f6dbbeb51cab6..cb84d583e6e93 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -2442,7 +2442,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
 
         // Look for a type inside the coroutine interior that matches the target type to get
         // a span.
-        let target_ty_erased = self.tcx.erase_regions(target_ty);
+        let target_ty_erased = self.tcx.erase_and_anonymize_regions(target_ty);
         let ty_matches = |ty| -> bool {
             // Careful: the regions for types that appear in the
             // coroutine interior are not generally known, so we
@@ -2454,10 +2454,10 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             // interior generally contain "bound regions" to
             // represent regions that are part of the suspended
             // coroutine frame. Bound regions are preserved by
-            // `erase_regions` and so we must also call
+            // `erase_and_anonymize_regions` and so we must also call
             // `instantiate_bound_regions_with_erased`.
             let ty_erased = self.tcx.instantiate_bound_regions_with_erased(ty);
-            let ty_erased = self.tcx.erase_regions(ty_erased);
+            let ty_erased = self.tcx.erase_and_anonymize_regions(ty_erased);
             let eq = ty_erased == target_ty_erased;
             debug!(?ty_erased, ?target_ty_erased, ?eq);
             eq
diff --git a/compiler/rustc_trait_selection/src/solve/delegate.rs b/compiler/rustc_trait_selection/src/solve/delegate.rs
index 16f444486a64f..b6bdf1067a35e 100644
--- a/compiler/rustc_trait_selection/src/solve/delegate.rs
+++ b/compiler/rustc_trait_selection/src/solve/delegate.rs
@@ -300,7 +300,7 @@ impl<'tcx> rustc_next_trait_solver::delegate::SolverDelegate for SolverDelegate<
     ) -> Result<Certainty, NoSolution> {
         // Erase regions because we compute layouts in `rustc_transmute`,
         // which will ICE for region vars.
-        let (dst, src) = self.tcx.erase_regions((dst, src));
+        let (dst, src) = self.tcx.erase_and_anonymize_regions((dst, src));
 
         let Some(assume) = rustc_transmute::Assume::from_const(self.tcx, assume) else {
             return Err(NoSolution);
diff --git a/compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs b/compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs
index 4b493c95d5934..bcd11d6918d9a 100644
--- a/compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs
+++ b/compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs
@@ -759,7 +759,7 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for IllegalSelfTypeVisitor<'tcx> {
                                     )),
                                 )
                                 .map(|trait_ref| {
-                                    self.tcx.erase_regions(
+                                    self.tcx.erase_and_anonymize_regions(
                                         self.tcx.instantiate_bound_regions_with_erased(trait_ref),
                                     )
                                 })
diff --git a/compiler/rustc_trait_selection/src/traits/mod.rs b/compiler/rustc_trait_selection/src/traits/mod.rs
index a9fb16b8000a9..6fefac436994d 100644
--- a/compiler/rustc_trait_selection/src/traits/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/mod.rs
@@ -576,7 +576,7 @@ pub fn try_evaluate_const<'tcx>(
                                     let args =
                                         replace_param_and_infer_args_with_placeholder(tcx, uv.args);
                                     let typing_env = infcx
-                                        .typing_env(tcx.erase_regions(param_env))
+                                        .typing_env(tcx.erase_and_anonymize_regions(param_env))
                                         .with_post_analysis_normalized(tcx);
                                     (args, typing_env)
                                 }
@@ -589,7 +589,7 @@ pub fn try_evaluate_const<'tcx>(
                         }
                     } else {
                         let typing_env = infcx
-                            .typing_env(tcx.erase_regions(param_env))
+                            .typing_env(tcx.erase_and_anonymize_regions(param_env))
                             .with_post_analysis_normalized(tcx);
                         (uv.args, typing_env)
                     }
@@ -634,14 +634,14 @@ pub fn try_evaluate_const<'tcx>(
                     }
 
                     let typing_env = infcx
-                        .typing_env(tcx.erase_regions(param_env))
+                        .typing_env(tcx.erase_and_anonymize_regions(param_env))
                         .with_post_analysis_normalized(tcx);
                     (uv.args, typing_env)
                 }
             };
 
             let uv = ty::UnevaluatedConst::new(uv.def, args);
-            let erased_uv = tcx.erase_regions(uv);
+            let erased_uv = tcx.erase_and_anonymize_regions(uv);
 
             use rustc_middle::mir::interpret::ErrorHandled;
             // FIXME: `def_span` will point at the definition of this const; ideally, we'd point at
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 de40453289979..f917b62e461dd 100644
--- a/compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs
@@ -350,7 +350,7 @@ pub fn dtorck_constraint_for_ty_inner<'tcx>(
             // Note that we don't care about whether the resume type has any drops since this is
             // redundant; there is no storage for the resume type, so if it is actually stored
             // in the interior, we'll already detect the need for a drop by checking the interior.
-            let typing_env = tcx.erase_regions(typing_env);
+            let typing_env = tcx.erase_and_anonymize_regions(typing_env);
             let needs_drop = tcx.mir_coroutine_witnesses(def_id).is_some_and(|witness| {
                 witness.field_tys.iter().any(|field| field.ty.needs_drop(tcx, typing_env))
             });
diff --git a/compiler/rustc_traits/src/codegen.rs b/compiler/rustc_traits/src/codegen.rs
index 7dd3c59edd05f..4b05e2cc38118 100644
--- a/compiler/rustc_traits/src/codegen.rs
+++ b/compiler/rustc_traits/src/codegen.rs
@@ -73,7 +73,7 @@ pub(crate) fn codegen_select_candidate<'tcx>(
     }
 
     let impl_source = infcx.resolve_vars_if_possible(impl_source);
-    let impl_source = tcx.erase_regions(impl_source);
+    let impl_source = tcx.erase_and_anonymize_regions(impl_source);
     if impl_source.has_non_region_infer() {
         // Unused generic types or consts on an impl get replaced with inference vars,
         // but never resolved, causing the return value of a query to contain inference
diff --git a/compiler/rustc_traits/src/normalize_erasing_regions.rs b/compiler/rustc_traits/src/normalize_erasing_regions.rs
index c1b848a2e79da..c98b56abe9c1d 100644
--- a/compiler/rustc_traits/src/normalize_erasing_regions.rs
+++ b/compiler/rustc_traits/src/normalize_erasing_regions.rs
@@ -41,7 +41,7 @@ fn try_normalize_after_erasing_regions<'tcx, T: TypeFoldable<TyCtxt<'tcx>> + Par
             // fresh `InferCtxt`. If this assert does trigger, it will give
             // us a test case.
             debug_assert_eq!(normalized_value, resolved_value);
-            let erased = infcx.tcx.erase_regions(resolved_value);
+            let erased = infcx.tcx.erase_and_anonymize_regions(resolved_value);
             debug_assert!(!erased.has_infer(), "{erased:?}");
             Ok(erased)
         }
diff --git a/compiler/rustc_transmute/src/layout/mod.rs b/compiler/rustc_transmute/src/layout/mod.rs
index acbce258f39be..4e548ff8fe20c 100644
--- a/compiler/rustc_transmute/src/layout/mod.rs
+++ b/compiler/rustc_transmute/src/layout/mod.rs
@@ -163,7 +163,7 @@ pub mod rustc {
         ty: Ty<'tcx>,
     ) -> Result<Layout<'tcx>, &'tcx LayoutError<'tcx>> {
         use rustc_middle::ty::layout::LayoutOf;
-        let ty = cx.tcx().erase_regions(ty);
+        let ty = cx.tcx().erase_and_anonymize_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 3f83b4d50aad5..406a1b5746f9b 100644
--- a/compiler/rustc_transmute/src/layout/tree.rs
+++ b/compiler/rustc_transmute/src/layout/tree.rs
@@ -426,24 +426,25 @@ pub(crate) mod rustc {
             assert!(def.is_enum());
 
             // Computes the layout of a variant.
-            let layout_of_variant =
-                |index, encoding: Option<TagEncoding<VariantIdx>>| -> Result<Self, Err> {
-                    let variant_layout = ty_variant(cx, (ty, layout), index);
-                    if variant_layout.is_uninhabited() {
-                        return Ok(Self::uninhabited());
-                    }
-                    let tag = cx.tcx().tag_for_variant(
-                        cx.typing_env.as_query_input((cx.tcx().erase_regions(ty), index)),
-                    );
-                    let variant_def = Def::Variant(def.variant(index));
-                    Self::from_variant(
-                        variant_def,
-                        tag.map(|tag| (tag, index, encoding.unwrap())),
-                        (ty, variant_layout),
-                        layout.size,
-                        cx,
-                    )
-                };
+            let layout_of_variant = |index,
+                                     encoding: Option<TagEncoding<VariantIdx>>|
+             -> Result<Self, Err> {
+                let variant_layout = ty_variant(cx, (ty, layout), index);
+                if variant_layout.is_uninhabited() {
+                    return Ok(Self::uninhabited());
+                }
+                let tag = cx.tcx().tag_for_variant(
+                    cx.typing_env.as_query_input((cx.tcx().erase_and_anonymize_regions(ty), index)),
+                );
+                let variant_def = Def::Variant(def.variant(index));
+                Self::from_variant(
+                    variant_def,
+                    tag.map(|tag| (tag, index, encoding.unwrap())),
+                    (ty, variant_layout),
+                    layout.size,
+                    cx,
+                )
+            };
 
             match layout.variants() {
                 Variants::Empty => Ok(Self::uninhabited()),
@@ -634,7 +635,7 @@ pub(crate) mod rustc {
         (ty, layout): (Ty<'tcx>, Layout<'tcx>),
         i: VariantIdx,
     ) -> Layout<'tcx> {
-        let ty = cx.tcx().erase_regions(ty);
+        let ty = cx.tcx().erase_and_anonymize_regions(ty);
         TyAndLayout { ty, layout }.for_variant(&cx, i).layout
     }
 }
diff --git a/compiler/rustc_ty_utils/src/instance.rs b/compiler/rustc_ty_utils/src/instance.rs
index 5c3f7d491a574..e28ebaabc0a1f 100644
--- a/compiler/rustc_ty_utils/src/instance.rs
+++ b/compiler/rustc_ty_utils/src/instance.rs
@@ -176,7 +176,7 @@ fn resolve_associated_item<'tcx>(
                 args,
                 leaf_def.defining_node,
             );
-            let args = infcx.tcx.erase_regions(args);
+            let args = infcx.tcx.erase_and_anonymize_regions(args);
 
             // HACK: We may have overlapping `dyn Trait` built-in impls and
             // user-provided blanket impls. Detect that case here, and return
@@ -222,7 +222,7 @@ fn resolve_associated_item<'tcx>(
                 return Err(guar);
             }
 
-            let args = tcx.erase_regions(args);
+            let args = tcx.erase_and_anonymize_regions(args);
 
             // We check that the impl item is compatible with the trait item
             // because otherwise we may ICE in const eval due to type mismatches,
@@ -279,7 +279,7 @@ fn resolve_associated_item<'tcx>(
                     assert_eq!(name, sym::clone_from);
 
                     // Use the default `fn clone_from` from `trait Clone`.
-                    let args = tcx.erase_regions(rcvr_args);
+                    let args = tcx.erase_and_anonymize_regions(rcvr_args);
                     Some(ty::Instance::new_raw(trait_item_id, args))
                 }
             } else if tcx.is_lang_item(trait_ref.def_id, LangItem::FnPtrTrait) {
@@ -380,7 +380,7 @@ fn resolve_associated_item<'tcx>(
             } 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);
+                let args = tcx.erase_and_anonymize_regions(rcvr_args);
                 Some(ty::Instance::new_raw(trait_item_id, args))
             } else {
                 Instance::try_resolve_item_for_coroutine(tcx, trait_item_id, trait_id, rcvr_args)
diff --git a/compiler/rustc_type_ir/src/visit.rs b/compiler/rustc_type_ir/src/visit.rs
index 5104484e9c432..a30aa42a0a49d 100644
--- a/compiler/rustc_type_ir/src/visit.rs
+++ b/compiler/rustc_type_ir/src/visit.rs
@@ -400,7 +400,7 @@ impl std::fmt::Debug for HasTypeFlagsVisitor {
 // N.B. The only case where this isn't totally true is binders, which also
 // add `HAS_{RE,TY,CT}_LATE_BOUND` flag depending on the *bound variables* that
 // are present, regardless of whether those bound variables are used. This
-// is important for anonymization of binders in `TyCtxt::erase_regions`. We
+// is important for anonymization of binders in `TyCtxt::erase_and_anonymize_regions`. We
 // specifically detect this case in `visit_binder`.
 impl<I: Interner> TypeVisitor<I> for HasTypeFlagsVisitor {
     type Result = ControlFlow<FoundFlags>;
diff --git a/src/tools/clippy/clippy_lints/src/dereference.rs b/src/tools/clippy/clippy_lints/src/dereference.rs
index 9aa2f3cf0a5b7..9645a26a68ae1 100644
--- a/src/tools/clippy/clippy_lints/src/dereference.rs
+++ b/src/tools/clippy/clippy_lints/src/dereference.rs
@@ -364,7 +364,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                                 //   priority.
                                 if let Some(fn_id) = typeck.type_dependent_def_id(hir_id)
                                     && let Some(trait_id) = cx.tcx.trait_of_assoc(fn_id)
-                                    && let arg_ty = cx.tcx.erase_regions(adjusted_ty)
+                                    && let arg_ty = cx.tcx.erase_and_anonymize_regions(adjusted_ty)
                                     && let ty::Ref(_, sub_ty, _) = *arg_ty.kind()
                                     && let args =
                                         typeck.node_args_opt(hir_id).map(|args| &args[1..]).unwrap_or_default()
diff --git a/src/tools/clippy/clippy_lints/src/loops/explicit_iter_loop.rs b/src/tools/clippy/clippy_lints/src/loops/explicit_iter_loop.rs
index 010652e1cb902..6ce7f0b1f0bc9 100644
--- a/src/tools/clippy/clippy_lints/src/loops/explicit_iter_loop.rs
+++ b/src/tools/clippy/clippy_lints/src/loops/explicit_iter_loop.rs
@@ -140,7 +140,7 @@ fn is_ref_iterable<'tcx>(
 
         let res_ty = cx
             .tcx
-            .erase_regions(EarlyBinder::bind(req_res_ty).instantiate(cx.tcx, typeck.node_args(call_expr.hir_id)));
+            .erase_and_anonymize_regions(EarlyBinder::bind(req_res_ty).instantiate(cx.tcx, typeck.node_args(call_expr.hir_id)));
         let mutbl = if let ty::Ref(_, _, mutbl) = *req_self_ty.kind() {
             Some(mutbl)
         } else {
diff --git a/src/tools/clippy/clippy_lints/src/only_used_in_recursion.rs b/src/tools/clippy/clippy_lints/src/only_used_in_recursion.rs
index a42763172f565..809a6728e1280 100644
--- a/src/tools/clippy/clippy_lints/src/only_used_in_recursion.rs
+++ b/src/tools/clippy/clippy_lints/src/only_used_in_recursion.rs
@@ -252,7 +252,7 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
                 {
                     (
                         trait_item_id,
-                        FnKind::ImplTraitFn(std::ptr::from_ref(cx.tcx.erase_regions(trait_ref.args)) as usize),
+                        FnKind::ImplTraitFn(std::ptr::from_ref(cx.tcx.erase_and_anonymize_regions(trait_ref.args)) as usize),
                         usize::from(sig.decl.implicit_self.has_implicit_self()),
                     )
                 } else {
diff --git a/src/tools/clippy/clippy_lints/src/transmute/transmute_ref_to_ref.rs b/src/tools/clippy/clippy_lints/src/transmute/transmute_ref_to_ref.rs
index 3842c4eb60e82..6aeb22d41a7d7 100644
--- a/src/tools/clippy/clippy_lints/src/transmute/transmute_ref_to_ref.rs
+++ b/src/tools/clippy/clippy_lints/src/transmute/transmute_ref_to_ref.rs
@@ -45,7 +45,7 @@ pub(super) fn check<'tcx>(
                 Applicability::MaybeIncorrect,
             );
             triggered = true;
-        } else if (cx.tcx.erase_regions(from_ty) != cx.tcx.erase_regions(to_ty)) && !const_context {
+        } else if (cx.tcx.erase_and_anonymize_regions(from_ty) != cx.tcx.erase_and_anonymize_regions(to_ty)) && !const_context {
             span_lint_and_then(
                 cx,
                 TRANSMUTE_PTR_TO_PTR,
diff --git a/src/tools/clippy/clippy_lints/src/transmute/transmute_undefined_repr.rs b/src/tools/clippy/clippy_lints/src/transmute/transmute_undefined_repr.rs
index 26323af312288..3e6aae475ecce 100644
--- a/src/tools/clippy/clippy_lints/src/transmute/transmute_undefined_repr.rs
+++ b/src/tools/clippy/clippy_lints/src/transmute/transmute_undefined_repr.rs
@@ -12,8 +12,8 @@ pub(super) fn check<'tcx>(
     from_ty_orig: Ty<'tcx>,
     to_ty_orig: Ty<'tcx>,
 ) -> bool {
-    let mut from_ty = cx.tcx.erase_regions(from_ty_orig);
-    let mut to_ty = cx.tcx.erase_regions(to_ty_orig);
+    let mut from_ty = cx.tcx.erase_and_anonymize_regions(from_ty_orig);
+    let mut to_ty = cx.tcx.erase_and_anonymize_regions(to_ty_orig);
 
     while from_ty != to_ty {
         let reduced_tys = reduce_refs(cx, from_ty, to_ty);
diff --git a/src/tools/clippy/clippy_lints/src/useless_conversion.rs b/src/tools/clippy/clippy_lints/src/useless_conversion.rs
index 70ae982a4458b..e45f884cfcbcf 100644
--- a/src/tools/clippy/clippy_lints/src/useless_conversion.rs
+++ b/src/tools/clippy/clippy_lints/src/useless_conversion.rs
@@ -98,7 +98,7 @@ fn into_iter_bound<'tcx>(
             if tr.def_id() == into_iter_did {
                 into_iter_span = Some(*span);
             } else {
-                let tr = cx.tcx.erase_regions(tr);
+                let tr = cx.tcx.erase_and_anonymize_regions(tr);
                 if tr.has_escaping_bound_vars() {
                     return None;
                 }
diff --git a/src/tools/clippy/clippy_utils/src/ty/mod.rs b/src/tools/clippy/clippy_utils/src/ty/mod.rs
index 8e302f9d2ad12..9f77a1c4d9b62 100644
--- a/src/tools/clippy/clippy_utils/src/ty/mod.rs
+++ b/src/tools/clippy/clippy_utils/src/ty/mod.rs
@@ -285,7 +285,7 @@ pub fn implements_trait_with_env_from_iter<'tcx>(
         let _ = tcx.hir_body_owner_kind(callee_id);
     }
 
-    let ty = tcx.erase_regions(ty);
+    let ty = tcx.erase_and_anonymize_regions(ty);
     if ty.has_escaping_bound_vars() {
         return false;
     }

From 332d8d62356a1be77bfe6412ab5ed3fa33ae9af6 Mon Sep 17 00:00:00 2001
From: Boxy <rust@boxyuwu.dev>
Date: Fri, 22 Aug 2025 12:31:34 +0100
Subject: [PATCH 0715/1889] Driveby fixes

---
 compiler/rustc_hir_typeck/src/writeback.rs                   | 4 ++--
 compiler/rustc_middle/src/ty/util.rs                         | 5 ++---
 compiler/rustc_mir_build/src/check_tail_calls.rs             | 2 +-
 .../src/traits/query/dropck_outlives.rs                      | 2 ++
 compiler/rustc_transmute/src/layout/tree.rs                  | 4 +---
 compiler/rustc_type_ir/src/visit.rs                          | 2 +-
 6 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/writeback.rs b/compiler/rustc_hir_typeck/src/writeback.rs
index 8e0180426ef6a..90301d1b391a0 100644
--- a/compiler/rustc_hir_typeck/src/writeback.rs
+++ b/compiler/rustc_hir_typeck/src/writeback.rs
@@ -984,8 +984,8 @@ impl<'cx, 'tcx> Resolver<'cx, 'tcx> {
         // borrowck, and specifically region constraints will be populated during
         // MIR typeck which is run on the new body.
         //
-        // We're not using `tcx.erase_and_anonymize_regions` as that also anonymizes bound variables,
-        // regressing borrowck diagnostics.
+        // We're not using `tcx.erase_and_anonymize_regions` as that also
+        // anonymizes bound variables, regressing borrowck diagnostics.
         value = fold_regions(tcx, value, |_, _| tcx.lifetimes.re_erased);
 
         // Normalize consts in writeback, because GCE doesn't normalize eagerly.
diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs
index 5a9e1918e4c62..3b14e0256db28 100644
--- a/compiler/rustc_middle/src/ty/util.rs
+++ b/compiler/rustc_middle/src/ty/util.rs
@@ -131,9 +131,8 @@ impl<'tcx> TyCtxt<'tcx> {
     /// Creates a hash of the type `Ty` which will be the same no matter what crate
     /// context it's calculated within. This is used by the `type_id` intrinsic.
     pub fn type_id_hash(self, ty: Ty<'tcx>) -> Hash128 {
-        // We want the type_id be independent of the types free regions, so we
-        // erase them. We also want type_id to be independnt of the names of bound
-        // regions so we anonymize them.
+        // We don't have region information, so we erase all free regions. Equal types
+        // must have the same `TypeId`, so we must anonymize all bound regions as well.
         let ty = self.erase_and_anonymize_regions(ty);
 
         self.with_stable_hashing_context(|mut hcx| {
diff --git a/compiler/rustc_mir_build/src/check_tail_calls.rs b/compiler/rustc_mir_build/src/check_tail_calls.rs
index 43a4106297a3d..d40c77d145f47 100644
--- a/compiler/rustc_mir_build/src/check_tail_calls.rs
+++ b/compiler/rustc_mir_build/src/check_tail_calls.rs
@@ -64,7 +64,7 @@ impl<'tcx> TailCallCkVisitor<'_, 'tcx> {
                 "`become` outside of functions should have been disallowed by hir_typeck"
             )
         };
-        // While the `caller_sig` does have its regions erased, it does not have its
+        // While the `caller_sig` does have its free regions erased, it does not have its
         // binders anonymized. We call `erase_and_anonymize_regions` once again to anonymize any binders
         // within the signature, such as in function pointer or `dyn Trait` args.
         let caller_sig = self.tcx.erase_and_anonymize_regions(caller_sig);
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 f917b62e461dd..945ca7c37758f 100644
--- a/compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs
@@ -350,6 +350,8 @@ pub fn dtorck_constraint_for_ty_inner<'tcx>(
             // Note that we don't care about whether the resume type has any drops since this is
             // redundant; there is no storage for the resume type, so if it is actually stored
             // in the interior, we'll already detect the need for a drop by checking the interior.
+            //
+            // FIXME(@lcnr): Why do we erase regions in the env here? Seems odd
             let typing_env = tcx.erase_and_anonymize_regions(typing_env);
             let needs_drop = tcx.mir_coroutine_witnesses(def_id).is_some_and(|witness| {
                 witness.field_tys.iter().any(|field| field.ty.needs_drop(tcx, typing_env))
diff --git a/compiler/rustc_transmute/src/layout/tree.rs b/compiler/rustc_transmute/src/layout/tree.rs
index 406a1b5746f9b..d7ea26a2ab1d0 100644
--- a/compiler/rustc_transmute/src/layout/tree.rs
+++ b/compiler/rustc_transmute/src/layout/tree.rs
@@ -426,9 +426,7 @@ pub(crate) mod rustc {
             assert!(def.is_enum());
 
             // Computes the layout of a variant.
-            let layout_of_variant = |index,
-                                     encoding: Option<TagEncoding<VariantIdx>>|
-             -> Result<Self, Err> {
+            let layout_of_variant = |index, encoding: Option<_>| -> Result<Self, Err> {
                 let variant_layout = ty_variant(cx, (ty, layout), index);
                 if variant_layout.is_uninhabited() {
                     return Ok(Self::uninhabited());
diff --git a/compiler/rustc_type_ir/src/visit.rs b/compiler/rustc_type_ir/src/visit.rs
index a30aa42a0a49d..6e62e1031a969 100644
--- a/compiler/rustc_type_ir/src/visit.rs
+++ b/compiler/rustc_type_ir/src/visit.rs
@@ -398,7 +398,7 @@ impl std::fmt::Debug for HasTypeFlagsVisitor {
 // looks, particular for `Ty`/`Predicate` where it's just a field access.
 //
 // N.B. The only case where this isn't totally true is binders, which also
-// add `HAS_{RE,TY,CT}_LATE_BOUND` flag depending on the *bound variables* that
+// add `HAS_BINDER_VARS` flag depending on the *bound variables* that
 // are present, regardless of whether those bound variables are used. This
 // is important for anonymization of binders in `TyCtxt::erase_and_anonymize_regions`. We
 // specifically detect this case in `visit_binder`.

From 8cde544b737892e12a757b1c0399781f44080730 Mon Sep 17 00:00:00 2001
From: Boxy <rust@boxyuwu.dev>
Date: Sun, 24 Aug 2025 17:50:13 +0100
Subject: [PATCH 0716/1889] Add assertion

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

diff --git a/compiler/rustc_symbol_mangling/src/v0.rs b/compiler/rustc_symbol_mangling/src/v0.rs
index 121d3b6b10550..1605b4958ba3d 100644
--- a/compiler/rustc_symbol_mangling/src/v0.rs
+++ b/compiler/rustc_symbol_mangling/src/v0.rs
@@ -342,7 +342,7 @@ impl<'tcx> Printer<'tcx> for V0SymbolMangler<'tcx> {
             )
         } else {
             assert!(
-                !args.has_non_region_param(),
+                !args.has_non_region_param() && !args.has_free_regions(),
                 "should not be mangling partially substituted \
                 polymorphic instance: {impl_def_id:?} {args:?}"
             );

From 0df12d7b0a4c8f9e05319cc761858841351d7db4 Mon Sep 17 00:00:00 2001
From: Boxy <rust@boxyuwu.dev>
Date: Thu, 21 Aug 2025 16:50:54 +0100
Subject: [PATCH 0717/1889] erase_regions to erase_and_anonymize_regions

---
 clippy_lints/src/dereference.rs                        | 2 +-
 clippy_lints/src/loops/explicit_iter_loop.rs           | 2 +-
 clippy_lints/src/only_used_in_recursion.rs             | 2 +-
 clippy_lints/src/transmute/transmute_ref_to_ref.rs     | 2 +-
 clippy_lints/src/transmute/transmute_undefined_repr.rs | 4 ++--
 clippy_lints/src/useless_conversion.rs                 | 2 +-
 clippy_utils/src/ty/mod.rs                             | 2 +-
 7 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 9aa2f3cf0a5b7..9645a26a68ae1 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -364,7 +364,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                                 //   priority.
                                 if let Some(fn_id) = typeck.type_dependent_def_id(hir_id)
                                     && let Some(trait_id) = cx.tcx.trait_of_assoc(fn_id)
-                                    && let arg_ty = cx.tcx.erase_regions(adjusted_ty)
+                                    && let arg_ty = cx.tcx.erase_and_anonymize_regions(adjusted_ty)
                                     && let ty::Ref(_, sub_ty, _) = *arg_ty.kind()
                                     && let args =
                                         typeck.node_args_opt(hir_id).map(|args| &args[1..]).unwrap_or_default()
diff --git a/clippy_lints/src/loops/explicit_iter_loop.rs b/clippy_lints/src/loops/explicit_iter_loop.rs
index 010652e1cb902..6ce7f0b1f0bc9 100644
--- a/clippy_lints/src/loops/explicit_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_iter_loop.rs
@@ -140,7 +140,7 @@ fn is_ref_iterable<'tcx>(
 
         let res_ty = cx
             .tcx
-            .erase_regions(EarlyBinder::bind(req_res_ty).instantiate(cx.tcx, typeck.node_args(call_expr.hir_id)));
+            .erase_and_anonymize_regions(EarlyBinder::bind(req_res_ty).instantiate(cx.tcx, typeck.node_args(call_expr.hir_id)));
         let mutbl = if let ty::Ref(_, _, mutbl) = *req_self_ty.kind() {
             Some(mutbl)
         } else {
diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index a42763172f565..809a6728e1280 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -252,7 +252,7 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
                 {
                     (
                         trait_item_id,
-                        FnKind::ImplTraitFn(std::ptr::from_ref(cx.tcx.erase_regions(trait_ref.args)) as usize),
+                        FnKind::ImplTraitFn(std::ptr::from_ref(cx.tcx.erase_and_anonymize_regions(trait_ref.args)) as usize),
                         usize::from(sig.decl.implicit_self.has_implicit_self()),
                     )
                 } else {
diff --git a/clippy_lints/src/transmute/transmute_ref_to_ref.rs b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
index 3842c4eb60e82..6aeb22d41a7d7 100644
--- a/clippy_lints/src/transmute/transmute_ref_to_ref.rs
+++ b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
@@ -45,7 +45,7 @@ pub(super) fn check<'tcx>(
                 Applicability::MaybeIncorrect,
             );
             triggered = true;
-        } else if (cx.tcx.erase_regions(from_ty) != cx.tcx.erase_regions(to_ty)) && !const_context {
+        } else if (cx.tcx.erase_and_anonymize_regions(from_ty) != cx.tcx.erase_and_anonymize_regions(to_ty)) && !const_context {
             span_lint_and_then(
                 cx,
                 TRANSMUTE_PTR_TO_PTR,
diff --git a/clippy_lints/src/transmute/transmute_undefined_repr.rs b/clippy_lints/src/transmute/transmute_undefined_repr.rs
index 26323af312288..3e6aae475ecce 100644
--- a/clippy_lints/src/transmute/transmute_undefined_repr.rs
+++ b/clippy_lints/src/transmute/transmute_undefined_repr.rs
@@ -12,8 +12,8 @@ pub(super) fn check<'tcx>(
     from_ty_orig: Ty<'tcx>,
     to_ty_orig: Ty<'tcx>,
 ) -> bool {
-    let mut from_ty = cx.tcx.erase_regions(from_ty_orig);
-    let mut to_ty = cx.tcx.erase_regions(to_ty_orig);
+    let mut from_ty = cx.tcx.erase_and_anonymize_regions(from_ty_orig);
+    let mut to_ty = cx.tcx.erase_and_anonymize_regions(to_ty_orig);
 
     while from_ty != to_ty {
         let reduced_tys = reduce_refs(cx, from_ty, to_ty);
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 70ae982a4458b..e45f884cfcbcf 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -98,7 +98,7 @@ fn into_iter_bound<'tcx>(
             if tr.def_id() == into_iter_did {
                 into_iter_span = Some(*span);
             } else {
-                let tr = cx.tcx.erase_regions(tr);
+                let tr = cx.tcx.erase_and_anonymize_regions(tr);
                 if tr.has_escaping_bound_vars() {
                     return None;
                 }
diff --git a/clippy_utils/src/ty/mod.rs b/clippy_utils/src/ty/mod.rs
index 8e302f9d2ad12..9f77a1c4d9b62 100644
--- a/clippy_utils/src/ty/mod.rs
+++ b/clippy_utils/src/ty/mod.rs
@@ -285,7 +285,7 @@ pub fn implements_trait_with_env_from_iter<'tcx>(
         let _ = tcx.hir_body_owner_kind(callee_id);
     }
 
-    let ty = tcx.erase_regions(ty);
+    let ty = tcx.erase_and_anonymize_regions(ty);
     if ty.has_escaping_bound_vars() {
         return false;
     }

From 83a99aadcff60482552fc81e0dc2992403c5652e Mon Sep 17 00:00:00 2001
From: Marco Cavenati <Marco.Cavenati@eurecom.fr>
Date: Tue, 9 Sep 2025 15:01:47 +0200
Subject: [PATCH 0718/1889] Bump unicode printable to version 17.0.0

---
 library/core/src/unicode/printable.rs | 160 +++++++++++++-------------
 1 file changed, 82 insertions(+), 78 deletions(-)

diff --git a/library/core/src/unicode/printable.rs b/library/core/src/unicode/printable.rs
index d8fb50e4ed296..68e1c8ae31c06 100644
--- a/library/core/src/unicode/printable.rs
+++ b/library/core/src/unicode/printable.rs
@@ -54,13 +54,10 @@ pub(crate) fn is_printable(x: char) -> bool {
         if 0x2a6e0 <= x && x < 0x2a700 {
             return false;
         }
-        if 0x2b73a <= x && x < 0x2b740 {
-            return false;
-        }
         if 0x2b81e <= x && x < 0x2b820 {
             return false;
         }
-        if 0x2cea2 <= x && x < 0x2ceb0 {
+        if 0x2ceae <= x && x < 0x2ceb0 {
             return false;
         }
         if 0x2ebe1 <= x && x < 0x2ebf0 {
@@ -75,7 +72,7 @@ pub(crate) fn is_printable(x: char) -> bool {
         if 0x3134b <= x && x < 0x31350 {
             return false;
         }
-        if 0x323b0 <= x && x < 0xe0100 {
+        if 0x3347a <= x && x < 0xe0100 {
             return false;
         }
         if 0xe01f0 <= x && x < 0x110000 {
@@ -96,7 +93,7 @@ const SINGLETONS0U: &[(u8, u8)] = &[
     (0x09, 17),
     (0x0a, 28),
     (0x0b, 25),
-    (0x0c, 26),
+    (0x0c, 25),
     (0x0d, 16),
     (0x0e, 12),
     (0x0f, 4),
@@ -107,24 +104,22 @@ const SINGLETONS0U: &[(u8, u8)] = &[
     (0x17, 4),
     (0x18, 1),
     (0x19, 3),
-    (0x1a, 7),
+    (0x1a, 9),
     (0x1b, 1),
     (0x1c, 2),
     (0x1f, 22),
     (0x20, 3),
-    (0x2b, 3),
+    (0x2b, 2),
     (0x2d, 11),
     (0x2e, 1),
     (0x30, 4),
     (0x31, 2),
     (0x32, 1),
-    (0xa7, 4),
     (0xa9, 2),
     (0xaa, 4),
     (0xab, 8),
     (0xfa, 2),
     (0xfb, 5),
-    (0xfd, 2),
     (0xfe, 3),
     (0xff, 9),
 ];
@@ -143,30 +138,29 @@ const SINGLETONS0L: &[u8] = &[
     0x34, 0x3a, 0x3b, 0x45, 0x46, 0x49, 0x4a, 0x5e,
     0x64, 0x65, 0x84, 0x91, 0x9b, 0x9d, 0xc9, 0xce,
     0xcf, 0x0d, 0x11, 0x29, 0x3a, 0x3b, 0x45, 0x49,
-    0x57, 0x5b, 0x5c, 0x5e, 0x5f, 0x64, 0x65, 0x8d,
-    0x91, 0xa9, 0xb4, 0xba, 0xbb, 0xc5, 0xc9, 0xdf,
-    0xe4, 0xe5, 0xf0, 0x0d, 0x11, 0x45, 0x49, 0x64,
-    0x65, 0x80, 0x84, 0xb2, 0xbc, 0xbe, 0xbf, 0xd5,
-    0xd7, 0xf0, 0xf1, 0x83, 0x85, 0x8b, 0xa4, 0xa6,
-    0xbe, 0xbf, 0xc5, 0xc7, 0xcf, 0xda, 0xdb, 0x48,
-    0x98, 0xbd, 0xcd, 0xc6, 0xce, 0xcf, 0x49, 0x4e,
-    0x4f, 0x57, 0x59, 0x5e, 0x5f, 0x89, 0x8e, 0x8f,
-    0xb1, 0xb6, 0xb7, 0xbf, 0xc1, 0xc6, 0xc7, 0xd7,
-    0x11, 0x16, 0x17, 0x5b, 0x5c, 0xf6, 0xf7, 0xfe,
-    0xff, 0x80, 0x6d, 0x71, 0xde, 0xdf, 0x0e, 0x1f,
-    0x6e, 0x6f, 0x1c, 0x1d, 0x5f, 0x7d, 0x7e, 0xae,
-    0xaf, 0x4d, 0xbb, 0xbc, 0x16, 0x17, 0x1e, 0x1f,
-    0x46, 0x47, 0x4e, 0x4f, 0x58, 0x5a, 0x5c, 0x5e,
-    0x7e, 0x7f, 0xb5, 0xc5, 0xd4, 0xd5, 0xdc, 0xf0,
-    0xf1, 0xf5, 0x72, 0x73, 0x8f, 0x74, 0x75, 0x96,
+    0x57, 0x5b, 0x5e, 0x5f, 0x64, 0x65, 0x8d, 0x91,
+    0xa9, 0xb4, 0xba, 0xbb, 0xc5, 0xc9, 0xdf, 0xe4,
+    0xe5, 0xf0, 0x0d, 0x11, 0x45, 0x49, 0x64, 0x65,
+    0x80, 0x84, 0xb2, 0xbc, 0xbe, 0xbf, 0xd5, 0xd7,
+    0xf0, 0xf1, 0x83, 0x85, 0x8b, 0xa4, 0xa6, 0xbe,
+    0xbf, 0xc5, 0xc7, 0xcf, 0xda, 0xdb, 0x48, 0x98,
+    0xbd, 0xcd, 0xc6, 0xce, 0xcf, 0x49, 0x4e, 0x4f,
+    0x57, 0x59, 0x5e, 0x5f, 0x89, 0x8e, 0x8f, 0xb1,
+    0xb6, 0xb7, 0xbf, 0xc1, 0xc6, 0xc7, 0xd7, 0x11,
+    0x16, 0x17, 0x5b, 0x5c, 0xf6, 0xf7, 0xfe, 0xff,
+    0x80, 0x6d, 0x71, 0xde, 0xdf, 0x0e, 0x1f, 0x6e,
+    0x6f, 0x1c, 0x1d, 0x5f, 0x7d, 0x7e, 0xae, 0xaf,
+    0xde, 0xdf, 0x4d, 0xbb, 0xbc, 0x16, 0x17, 0x1e,
+    0x1f, 0x46, 0x47, 0x4e, 0x4f, 0x58, 0x5a, 0x5c,
+    0x5e, 0x7e, 0x7f, 0xb5, 0xc5, 0xd4, 0xd5, 0xdc,
+    0xf0, 0xf1, 0xf5, 0x72, 0x73, 0x8f, 0x74, 0x75,
     0x26, 0x2e, 0x2f, 0xa7, 0xaf, 0xb7, 0xbf, 0xc7,
     0xcf, 0xd7, 0xdf, 0x9a, 0x00, 0x40, 0x97, 0x98,
-    0x30, 0x8f, 0x1f, 0xce, 0xcf, 0xd2, 0xd4, 0xce,
-    0xff, 0x4e, 0x4f, 0x5a, 0x5b, 0x07, 0x08, 0x0f,
-    0x10, 0x27, 0x2f, 0xee, 0xef, 0x6e, 0x6f, 0x37,
-    0x3d, 0x3f, 0x42, 0x45, 0x90, 0x91, 0x53, 0x67,
-    0x75, 0xc8, 0xc9, 0xd0, 0xd1, 0xd8, 0xd9, 0xe7,
-    0xfe, 0xff,
+    0x30, 0x8f, 0x1f, 0xce, 0xff, 0x4e, 0x4f, 0x5a,
+    0x5b, 0x07, 0x08, 0x0f, 0x10, 0x27, 0x2f, 0xee,
+    0xef, 0x6e, 0x6f, 0x37, 0x3d, 0x3f, 0x42, 0x45,
+    0x53, 0x67, 0x75, 0xc8, 0xc9, 0xd0, 0xd1, 0xd8,
+    0xd9, 0xe7, 0xfe, 0xff,
 ];
 #[rustfmt::skip]
 const SINGLETONS1U: &[(u8, u8)] = &[
@@ -195,6 +189,7 @@ const SINGLETONS1U: &[(u8, u8)] = &[
     (0x24, 1),
     (0x6a, 4),
     (0x6b, 2),
+    (0x6e, 2),
     (0xaf, 3),
     (0xb1, 2),
     (0xbc, 2),
@@ -207,12 +202,13 @@ const SINGLETONS1U: &[(u8, u8)] = &[
     (0xda, 1),
     (0xe0, 5),
     (0xe1, 2),
+    (0xe6, 1),
     (0xe7, 4),
     (0xe8, 2),
     (0xee, 32),
     (0xf0, 4),
     (0xf8, 2),
-    (0xfa, 4),
+    (0xfa, 5),
     (0xfb, 1),
 ];
 #[rustfmt::skip]
@@ -231,18 +227,19 @@ const SINGLETONS1L: &[u8] = &[
     0x39, 0x3a, 0xa8, 0xa9, 0xd8, 0xd9, 0x09, 0x37,
     0x90, 0x91, 0xa8, 0x07, 0x0a, 0x3b, 0x3e, 0x66,
     0x69, 0x8f, 0x92, 0x11, 0x6f, 0x5f, 0xbf, 0xee,
-    0xef, 0x5a, 0x62, 0xf4, 0xfc, 0xff, 0x53, 0x54,
-    0x9a, 0x9b, 0x2e, 0x2f, 0x27, 0x28, 0x55, 0x9d,
-    0xa0, 0xa1, 0xa3, 0xa4, 0xa7, 0xa8, 0xad, 0xba,
-    0xbc, 0xc4, 0x06, 0x0b, 0x0c, 0x15, 0x1d, 0x3a,
-    0x3f, 0x45, 0x51, 0xa6, 0xa7, 0xcc, 0xcd, 0xa0,
-    0x07, 0x19, 0x1a, 0x22, 0x25, 0x3e, 0x3f, 0xe7,
-    0xec, 0xef, 0xff, 0xc5, 0xc6, 0x04, 0x20, 0x23,
-    0x25, 0x26, 0x28, 0x33, 0x38, 0x3a, 0x48, 0x4a,
-    0x4c, 0x50, 0x53, 0x55, 0x56, 0x58, 0x5a, 0x5c,
-    0x5e, 0x60, 0x63, 0x65, 0x66, 0x6b, 0x73, 0x78,
-    0x7d, 0x7f, 0x8a, 0xa4, 0xaa, 0xaf, 0xb0, 0xc0,
-    0xd0, 0xae, 0xaf, 0x6e, 0x6f, 0xdd, 0xde, 0x93,
+    0xef, 0x5a, 0x62, 0xb9, 0xba, 0xf4, 0xfc, 0xff,
+    0x53, 0x54, 0x9a, 0x9b, 0x2e, 0x2f, 0x27, 0x28,
+    0x55, 0x9d, 0xa0, 0xa1, 0xa3, 0xa4, 0xa7, 0xa8,
+    0xad, 0xba, 0xbc, 0xc4, 0x06, 0x0b, 0x0c, 0x15,
+    0x1d, 0x3a, 0x3f, 0x45, 0x51, 0xa6, 0xa7, 0xcc,
+    0xcd, 0xa0, 0x07, 0x19, 0x1a, 0x22, 0x25, 0x3e,
+    0x3f, 0xdf, 0xe7, 0xec, 0xef, 0xff, 0xc5, 0xc6,
+    0x04, 0x20, 0x23, 0x25, 0x26, 0x28, 0x33, 0x38,
+    0x3a, 0x48, 0x4a, 0x4c, 0x50, 0x53, 0x55, 0x56,
+    0x58, 0x5a, 0x5c, 0x5e, 0x60, 0x63, 0x65, 0x66,
+    0x6b, 0x73, 0x78, 0x7d, 0x7f, 0x8a, 0xa4, 0xaa,
+    0xaf, 0xb0, 0xc0, 0xd0, 0xae, 0xaf, 0x6e, 0x6f,
+    0xc7, 0xdd, 0xde, 0x93,
 ];
 #[rustfmt::skip]
 const NORMAL0: &[u8] = &[
@@ -254,7 +251,7 @@ const NORMAL0: &[u8] = &[
     0x06, 0x11,
     0x81, 0xac, 0x0e,
     0x80, 0xab, 0x05,
-    0x1f, 0x08,
+    0x20, 0x07,
     0x81, 0x1c, 0x03,
     0x19, 0x08,
     0x01, 0x04,
@@ -282,8 +279,8 @@ const NORMAL0: &[u8] = &[
     0x4e, 0x07,
     0x1b, 0x07,
     0x57, 0x07,
-    0x02, 0x06,
-    0x17, 0x0c,
+    0x02, 0x05,
+    0x18, 0x0c,
     0x50, 0x04,
     0x43, 0x03,
     0x2d, 0x03,
@@ -319,7 +316,7 @@ const NORMAL0: &[u8] = &[
     0x0b, 0x03,
     0x80, 0xac, 0x06,
     0x0a, 0x06,
-    0x2f, 0x31,
+    0x4c, 0x14,
     0x80, 0xf4, 0x08,
     0x3c, 0x03,
     0x0f, 0x03,
@@ -330,7 +327,7 @@ const NORMAL0: &[u8] = &[
     0x18, 0x08,
     0x2f, 0x11,
     0x2d, 0x03,
-    0x21, 0x0f,
+    0x22, 0x0e,
     0x21, 0x0f,
     0x80, 0x8c, 0x04,
     0x82, 0x9a, 0x16,
@@ -349,8 +346,8 @@ const NORMAL0: &[u8] = &[
     0x37, 0x09,
     0x81, 0x5c, 0x14,
     0x80, 0xb8, 0x08,
-    0x80, 0xdd, 0x15,
-    0x3b, 0x03,
+    0x80, 0xdd, 0x14,
+    0x3c, 0x03,
     0x0a, 0x06,
     0x38, 0x08,
     0x46, 0x08,
@@ -370,9 +367,7 @@ const NORMAL0: &[u8] = &[
     0x81, 0xda, 0x26,
     0x07, 0x0c,
     0x05, 0x05,
-    0x80, 0xa6, 0x10,
-    0x81, 0xf5, 0x07,
-    0x01, 0x20,
+    0x82, 0xb3, 0x20,
     0x2a, 0x06,
     0x4c, 0x04,
     0x80, 0x8d, 0x04,
@@ -414,7 +409,7 @@ const NORMAL1: &[u8] = &[
     0x16, 0x05,
     0x21, 0x03,
     0x1b, 0x05,
-    0x01, 0x40,
+    0x1b, 0x26,
     0x38, 0x04,
     0x4b, 0x05,
     0x2f, 0x04,
@@ -437,8 +432,9 @@ const NORMAL1: &[u8] = &[
     0x1d, 0x08,
     0x02, 0x80, 0xd0,
     0x52, 0x10,
-    0x03, 0x37,
-    0x2c, 0x08,
+    0x06, 0x08,
+    0x09, 0x21,
+    0x2e, 0x08,
     0x2a, 0x16,
     0x1a, 0x26,
     0x1c, 0x14,
@@ -481,7 +477,8 @@ const NORMAL1: &[u8] = &[
     0x48, 0x08,
     0x53, 0x0d,
     0x49, 0x07,
-    0x0a, 0x80, 0xb6,
+    0x0a, 0x56,
+    0x08, 0x58,
     0x22, 0x0e,
     0x0a, 0x06,
     0x46, 0x0a,
@@ -491,7 +488,9 @@ const NORMAL1: &[u8] = &[
     0x0e, 0x08,
     0x0a, 0x06,
     0x39, 0x07,
-    0x0a, 0x81, 0x36,
+    0x0a, 0x06,
+    0x2c, 0x04,
+    0x0a, 0x80, 0xf6,
     0x19, 0x07,
     0x3b, 0x03,
     0x1d, 0x55,
@@ -514,15 +513,16 @@ const NORMAL1: &[u8] = &[
     0x28, 0x05,
     0x13, 0x81, 0xb0,
     0x3a, 0x80, 0xc6,
-    0x5b, 0x65,
+    0x5b, 0x05,
+    0x34, 0x2c,
     0x4b, 0x04,
     0x39, 0x07,
     0x11, 0x40,
     0x05, 0x0b,
-    0x02, 0x0e,
-    0x97, 0xf8, 0x08,
-    0x84, 0xd6, 0x29,
-    0x0a, 0xa2, 0xe7,
+    0x07, 0x09,
+    0x9c, 0xd6, 0x29,
+    0x20, 0x61,
+    0x73, 0xa1, 0xfd,
     0x81, 0x33, 0x0f,
     0x01, 0x1d,
     0x06, 0x0e,
@@ -532,8 +532,10 @@ const NORMAL1: &[u8] = &[
     0x0d, 0x03,
     0x09, 0x07,
     0x10, 0x8f, 0x60,
-    0x80, 0xfa, 0x06,
-    0x81, 0xb4, 0x4c,
+    0x80, 0xfd, 0x03,
+    0x81, 0xb4, 0x06,
+    0x17, 0x0f,
+    0x11, 0x0f,
     0x47, 0x09,
     0x74, 0x3c,
     0x80, 0xf6, 0x0a,
@@ -560,7 +562,9 @@ const NORMAL1: &[u8] = &[
     0x01, 0x81, 0xd0,
     0x2a, 0x80, 0xd6,
     0x2b, 0x04,
-    0x01, 0x81, 0xe0,
+    0x01, 0x80, 0xc0,
+    0x36, 0x08,
+    0x02, 0x80, 0xe0,
     0x80, 0xf7, 0x29,
     0x4c, 0x04,
     0x0a, 0x04,
@@ -581,11 +585,10 @@ const NORMAL1: &[u8] = &[
     0x09, 0x07,
     0x02, 0x0e,
     0x06, 0x80, 0x9a,
-    0x83, 0xd8, 0x04,
+    0x83, 0xd9, 0x03,
     0x11, 0x03,
     0x0d, 0x03,
-    0x77, 0x04,
-    0x5f, 0x06,
+    0x80, 0xda, 0x06,
     0x0c, 0x04,
     0x01, 0x0f,
     0x0c, 0x04,
@@ -593,12 +596,13 @@ const NORMAL1: &[u8] = &[
     0x0a, 0x06,
     0x28, 0x08,
     0x2c, 0x04,
-    0x02, 0x3e,
-    0x81, 0x54, 0x0c,
+    0x02, 0x0e,
+    0x09, 0x27,
+    0x81, 0x58, 0x08,
     0x1d, 0x03,
-    0x0a, 0x05,
-    0x38, 0x07,
-    0x1c, 0x06,
-    0x09, 0x07,
-    0x80, 0xfa, 0x84, 0x06,
+    0x0b, 0x03,
+    0x3b, 0x04,
+    0x1e, 0x04,
+    0x0a, 0x07,
+    0x80, 0xfb, 0x84, 0x05,
 ];

From 0fad52401e39eba86e8246834a5317b9c8d77652 Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Wed, 13 Aug 2025 22:54:10 +0000
Subject: [PATCH 0719/1889] WIP switch inference table to next-solver

---
 .../crates/hir-ty/src/consteval_nextsolver.rs |   6 +-
 .../crates/hir-ty/src/infer/closure.rs        |   2 +-
 .../crates/hir-ty/src/infer/coerce.rs         |  64 +-
 .../crates/hir-ty/src/infer/expr.rs           |  32 +-
 .../crates/hir-ty/src/infer/path.rs           |  12 +-
 .../crates/hir-ty/src/infer/unify.rs          | 589 ++++++-----
 .../rust-analyzer/crates/hir-ty/src/lib.rs    |  16 +-
 .../crates/hir-ty/src/method_resolution.rs    | 201 ++--
 .../infer/canonical/canonicalizer.rs          | 785 ++++++++++++++
 .../src/next_solver/infer/canonical/mod.rs    |   1 +
 .../hir-ty/src/next_solver/infer/mod.rs       |  54 +-
 .../src/next_solver/infer/snapshot/mod.rs     |   4 +-
 .../crates/hir-ty/src/next_solver/mapping.rs  | 965 +++++++++++++++++-
 .../crates/hir-ty/src/next_solver/solver.rs   |   4 +-
 .../rust-analyzer/crates/hir-ty/src/traits.rs |  67 +-
 .../rust-analyzer/crates/hir/src/attrs.rs     |   4 +-
 src/tools/rust-analyzer/crates/hir/src/lib.rs |  12 +-
 17 files changed, 2292 insertions(+), 526 deletions(-)
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/canonicalizer.rs

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs
index 4f95c9a13acdb..4700335931549 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs
@@ -27,7 +27,7 @@ use crate::{
     next_solver::{
         Const, ConstBytes, ConstKind, DbInterner, ErrorGuaranteed, GenericArg, GenericArgs,
         ParamConst, SolverDefId, Ty, ValueConst,
-        mapping::{ChalkToNextSolver, convert_args_for_result, convert_binder_to_early_binder},
+        mapping::{ChalkToNextSolver, convert_binder_to_early_binder},
     },
 };
 
@@ -145,7 +145,7 @@ pub fn try_const_usize<'db>(db: &'db dyn HirDatabase, c: Const<'db>) -> Option<u
                 SolverDefId::StaticId(id) => GeneralConstId::StaticId(id),
                 _ => unreachable!(),
             };
-            let subst = convert_args_for_result(interner, unevaluated_const.args.as_slice());
+            let subst = ChalkToNextSolver::from_nextsolver(unevaluated_const.args, interner);
             let ec = db.const_eval(c, subst, None).ok()?.to_nextsolver(interner);
             try_const_usize(db, ec)
         }
@@ -168,7 +168,7 @@ pub fn try_const_isize<'db>(db: &'db dyn HirDatabase, c: &Const<'db>) -> Option<
                 SolverDefId::StaticId(id) => GeneralConstId::StaticId(id),
                 _ => unreachable!(),
             };
-            let subst = convert_args_for_result(interner, unevaluated_const.args.as_slice());
+            let subst = ChalkToNextSolver::from_nextsolver(unevaluated_const.args, interner);
             let ec = db.const_eval(c, subst, None).ok()?.to_nextsolver(interner);
             try_const_isize(db, &ec)
         }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
index 9ef046afdb3d3..493652b764015 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
@@ -568,7 +568,7 @@ impl InferenceContext<'_> {
         let supplied_sig = self.supplied_sig_of_closure(body, ret_type, arg_types, closure_kind);
 
         let snapshot = self.table.snapshot();
-        if !self.table.unify(&expected_sig.substitution, &supplied_sig.expected_sig.substitution) {
+        if !self.table.unify::<_, crate::next_solver::GenericArgs<'_>>(&expected_sig.substitution.0, &supplied_sig.expected_sig.substitution.0) {
             self.table.rollback_to(snapshot);
         }
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
index 631a91bac481b..b47834f0c749c 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
@@ -7,22 +7,20 @@
 
 use std::iter;
 
-use chalk_ir::{BoundVar, Goal, Mutability, TyKind, TyVariableKind, cast::Cast};
-use hir_def::{hir::ExprId, lang_item::LangItem};
+use chalk_ir::{BoundVar, Mutability, TyKind, TyVariableKind, cast::Cast};
+use hir_def::{
+    hir::ExprId,
+    lang_item::LangItem,
+};
+use rustc_type_ir::solve::Certainty;
 use stdx::always;
 use triomphe::Arc;
 
 use crate::{
-    Canonical, DomainGoal, FnAbi, FnPointer, FnSig, InEnvironment, Interner, Lifetime,
-    Substitution, TraitEnvironment, Ty, TyBuilder, TyExt,
-    autoderef::{Autoderef, AutoderefKind},
-    db::HirDatabase,
-    infer::{
+    autoderef::{Autoderef, AutoderefKind}, db::HirDatabase, infer::{
         Adjust, Adjustment, AutoBorrow, InferOk, InferenceContext, OverloadedDeref, PointerCast,
         TypeError, TypeMismatch,
-    },
-    traits::NextTraitSolveResult,
-    utils::ClosureSubst,
+    }, utils::ClosureSubst, Canonical, FnAbi, FnPointer, FnSig, Goal, InEnvironment, Interner, Lifetime, Substitution, TraitEnvironment, Ty, TyBuilder, TyExt
 };
 
 use super::unify::InferenceTable;
@@ -42,7 +40,7 @@ fn simple(kind: Adjust) -> impl FnOnce(Ty) -> Vec<Adjustment> {
 fn success(
     adj: Vec<Adjustment>,
     target: Ty,
-    goals: Vec<InEnvironment<Goal<Interner>>>,
+    goals: Vec<InEnvironment<Goal>>,
 ) -> CoerceResult {
     Ok(InferOk { goals, value: (adj, target) })
 }
@@ -304,7 +302,7 @@ impl InferenceTable<'_> {
     fn coerce_inner(&mut self, from_ty: Ty, to_ty: &Ty, coerce_never: CoerceNever) -> CoerceResult {
         if from_ty.is_never() {
             if let TyKind::InferenceVar(tv, TyVariableKind::General) = to_ty.kind(Interner) {
-                self.set_diverging(*tv, true);
+                self.set_diverging(*tv, TyVariableKind::General, true);
             }
             if coerce_never == CoerceNever::Yes {
                 // Subtle: If we are coercing from `!` to `?T`, where `?T` is an unbound
@@ -707,41 +705,15 @@ impl InferenceTable<'_> {
             b.push(coerce_from).push(to_ty.clone()).build()
         };
 
-        let goal: InEnvironment<DomainGoal> =
-            InEnvironment::new(&self.trait_env.env, coerce_unsized_tref.cast(Interner));
-
-        let canonicalized = self.canonicalize_with_free_vars(goal);
-
-        // FIXME: rustc's coerce_unsized is more specialized -- it only tries to
-        // solve `CoerceUnsized` and `Unsize` goals at this point and leaves the
-        // rest for later. Also, there's some logic about sized type variables.
-        // Need to find out in what cases this is necessary
-        let solution = self.db.trait_solve(
-            krate,
-            self.trait_env.block,
-            canonicalized.value.clone().cast(Interner),
-        );
-
-        match solution {
-            // FIXME: this is a weaker guarantee than Chalk's `Guidance::Unique`
-            // was. Chalk's unique guidance at least guarantees that the real solution
-            // is some "subset" of the solutions matching the guidance, but the
-            // substs for `Certainty::No` don't have that same guarantee (I think).
-            NextTraitSolveResult::Certain(v) => {
-                canonicalized.apply_solution(
-                    self,
-                    Canonical {
-                        binders: v.binders,
-                        // FIXME handle constraints
-                        value: v.value.subst,
-                    },
-                );
-            }
-            // ...so, should think about how to get some actually get some guidance here
-            NextTraitSolveResult::Uncertain(..) | NextTraitSolveResult::NoSolution => {
-                return Err(TypeError);
+        let goal: Goal = coerce_unsized_tref.cast(Interner);
+
+        self.commit_if_ok(|table| {
+            match table.solve_obligation(goal) {
+                Ok(Certainty::Yes) => Ok(()),
+                Ok(Certainty::Maybe(_)) => Ok(()),
+                Err(_) => Err(TypeError),
             }
-        }
+        })?;
 
         let unsize =
             Adjustment { kind: Adjust::Pointer(PointerCast::Unsize), target: to_ty.clone() };
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
index 261c02386822d..e39f3ab75f16f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
@@ -23,28 +23,9 @@ use stdx::always;
 use syntax::ast::RangeOp;
 
 use crate::{
-    Adjust, Adjustment, AdtId, AutoBorrow, Binders, CallableDefId, CallableSig, DeclContext,
-    DeclOrigin, IncorrectGenericsLenKind, Interner, Rawness, Scalar, Substitution,
-    TraitEnvironment, TraitRef, Ty, TyBuilder, TyExt, TyKind,
-    autoderef::{Autoderef, builtin_deref, deref_by_trait},
-    consteval,
-    generics::generics,
-    infer::{
-        BreakableKind,
-        coerce::{CoerceMany, CoerceNever, CoercionCause},
-        find_continuable,
-        pat::contains_explicit_ref_binding,
-    },
-    lang_items::lang_items_for_bin_op,
-    lower::{
-        LifetimeElisionKind, ParamLoweringMode, lower_to_chalk_mutability,
-        path::{GenericArgsLowerer, TypeLikeConst, substs_from_args_and_bindings},
-    },
-    mapping::{ToChalk, from_chalk},
-    method_resolution::{self, VisibleFromModule},
-    primitive::{self, UintTy},
-    static_lifetime, to_chalk_trait_id,
-    traits::FnTrait,
+    autoderef::{builtin_deref, deref_by_trait, Autoderef}, consteval, generics::generics, infer::{
+        coerce::{CoerceMany, CoerceNever, CoercionCause}, find_continuable, pat::contains_explicit_ref_binding, BreakableKind
+    }, lang_items::lang_items_for_bin_op, lower::{lower_to_chalk_mutability, path::{substs_from_args_and_bindings, GenericArgsLowerer, TypeLikeConst}, ParamLoweringMode}, mapping::{from_chalk, ToChalk}, method_resolution::{self, VisibleFromModule}, next_solver::mapping::ChalkToNextSolver, primitive::{self, UintTy}, static_lifetime, to_chalk_trait_id, traits::FnTrait, Adjust, Adjustment, AdtId, AutoBorrow, Binders, CallableDefId, CallableSig, DeclContext, DeclOrigin, IncorrectGenericsLenKind, Interner, LifetimeElisionKind, Rawness, Scalar, Substitution, TraitEnvironment, TraitRef, Ty, TyBuilder, TyExt, TyKind
 };
 
 use super::{
@@ -826,7 +807,7 @@ impl InferenceContext<'_> {
                 let index_ty = self.infer_expr(*index, &Expectation::none(), ExprIsRead::Yes);
 
                 if let Some(index_trait) = self.resolve_lang_trait(LangItem::Index) {
-                    let canonicalized = self.canonicalize(base_ty.clone());
+                    let canonicalized = ChalkToNextSolver::from_nextsolver(self.canonicalize(base_ty.clone().to_nextsolver(self.table.interner)), self.table.interner);
                     let receiver_adjustments = method_resolution::resolve_indexing_op(
                         self.db,
                         self.table.trait_env.clone(),
@@ -932,6 +913,7 @@ impl InferenceContext<'_> {
                     }
                     None => {
                         let expected_ty = expected.to_option(&mut self.table);
+                        tracing::debug!(?expected_ty);
                         let opt_ty = match expected_ty.as_ref().map(|it| it.kind(Interner)) {
                             Some(TyKind::Scalar(Scalar::Int(_) | Scalar::Uint(_))) => expected_ty,
                             Some(TyKind::Scalar(Scalar::Char)) => {
@@ -1678,7 +1660,7 @@ impl InferenceContext<'_> {
             None => {
                 // no field found, lets attempt to resolve it like a function so that IDE things
                 // work out while people are typing
-                let canonicalized_receiver = self.canonicalize(receiver_ty.clone());
+                let canonicalized_receiver = self.canonicalize(receiver_ty.clone().to_nextsolver(self.table.interner));
                 let resolved = method_resolution::lookup_method(
                     self.db,
                     &canonicalized_receiver,
@@ -1824,7 +1806,7 @@ impl InferenceContext<'_> {
         expected: &Expectation,
     ) -> Ty {
         let receiver_ty = self.infer_expr_inner(receiver, &Expectation::none(), ExprIsRead::Yes);
-        let canonicalized_receiver = self.canonicalize(receiver_ty.clone());
+        let canonicalized_receiver = self.canonicalize(receiver_ty.clone().to_nextsolver(self.table.interner));
 
         let resolved = method_resolution::lookup_method(
             self.db,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs
index bc8648ecdd943..9f3cd2b8fb006 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs
@@ -10,15 +10,7 @@ use hir_expand::name::Name;
 use stdx::never;
 
 use crate::{
-    InferenceDiagnostic, Interner, Substitution, TraitRef, TraitRefExt, Ty, TyBuilder, TyExt,
-    TyKind, ValueTyDefId,
-    builder::ParamKind,
-    consteval, error_lifetime,
-    generics::generics,
-    infer::diagnostics::InferenceTyLoweringContext as TyLoweringContext,
-    lower::LifetimeElisionKind,
-    method_resolution::{self, VisibleFromModule},
-    to_chalk_trait_id,
+    builder::ParamKind, consteval, error_lifetime, generics::generics, infer::diagnostics::InferenceTyLoweringContext as TyLoweringContext, method_resolution::{self, VisibleFromModule}, next_solver::mapping::ChalkToNextSolver, to_chalk_trait_id, InferenceDiagnostic, Interner, LifetimeElisionKind, Substitution, TraitRef, TraitRefExt, Ty, TyBuilder, TyExt, TyKind, ValueTyDefId
 };
 
 use super::{ExprOrPatId, InferenceContext, InferenceTyDiagnosticSource};
@@ -322,7 +314,7 @@ impl InferenceContext<'_> {
             return Some(result);
         }
 
-        let canonical_ty = self.canonicalize(ty.clone());
+        let canonical_ty = self.canonicalize(ty.clone().to_nextsolver(self.table.interner));
 
         let mut not_visible = None;
         let res = method_resolution::iterate_method_candidates(
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
index bb4782bd41942..3745d2c98fd9f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
@@ -3,35 +3,27 @@
 use std::{fmt, mem};
 
 use chalk_ir::{
-    CanonicalVarKind, FloatTy, IntTy, TyVariableKind, UniverseIndex, cast::Cast,
-    fold::TypeFoldable, interner::HasInterner, zip::Zip,
+    cast::Cast, fold::TypeFoldable, interner::HasInterner, CanonicalVarKind, FloatTy, IntTy, TyVariableKind,
 };
-use chalk_solve::infer::ParameterEnaVariableExt;
 use either::Either;
-use ena::unify::UnifyKey;
 use hir_def::{AdtId, lang_item::LangItem};
 use hir_expand::name::Name;
 use intern::sym;
-use rustc_hash::FxHashMap;
+use rustc_hash::{FxHashMap, FxHashSet};
+use rustc_next_trait_solver::solve::HasChanged;
+use rustc_type_ir::{inherent::Span, relate::{solver_relating::RelateExt, Relate}, solve::{Certainty, NoSolution}, FloatVid, IntVid, TyVid};
 use smallvec::SmallVec;
 use triomphe::Arc;
 
 use super::{InferOk, InferResult, InferenceContext, TypeError};
 use crate::{
-    AliasEq, AliasTy, BoundVar, Canonical, Const, ConstValue, DebruijnIndex, DomainGoal,
-    GenericArg, GenericArgData, Goal, GoalData, InEnvironment, InferenceVar, Interner, Lifetime,
-    OpaqueTyId, ParamKind, ProjectionTy, ProjectionTyExt, Scalar, Substitution, TraitEnvironment,
-    TraitRef, Ty, TyBuilder, TyExt, TyKind, VariableKind, WhereClause,
-    consteval::unknown_const,
-    db::HirDatabase,
-    fold_generic_args, fold_tys_and_consts, to_chalk_trait_id,
-    traits::{FnTrait, NextTraitSolveResult},
+    consteval::unknown_const, db::HirDatabase, fold_generic_args, fold_tys_and_consts, next_solver::{infer::{canonical::canonicalizer::OriginalQueryValues, snapshot::CombinedSnapshot, DbInternerInferExt, InferCtxt}, mapping::{ChalkToNextSolver, InferenceVarExt}, DbInterner, ParamEnvAnd, SolverDefIds}, to_chalk_trait_id, traits::{next_trait_solve, next_trait_solve_canonical, next_trait_solve_in_ctxt, FnTrait, NextTraitSolveResult}, AliasEq, AliasTy, BoundVar, Canonical, Const, ConstValue, DebruijnIndex, DomainGoal, GenericArg, GenericArgData, Goal, GoalData, InEnvironment, InferenceVar, Interner, Lifetime, OpaqueTyId, ParamKind, ProjectionTy, ProjectionTyExt, Scalar, Substitution, TraitEnvironment, TraitRef, Ty, TyBuilder, TyExt, TyKind, VariableKind, WhereClause
 };
 
-impl InferenceContext<'_> {
-    pub(super) fn canonicalize<T>(&mut self, t: T) -> Canonical<T>
+impl<'db> InferenceContext<'db> {
+    pub(super) fn canonicalize<T>(&mut self, t: T) -> rustc_type_ir::Canonical<DbInterner<'db>, T>
     where
-        T: TypeFoldable<Interner> + HasInterner<Interner = Interner>,
+        T: rustc_type_ir::TypeFoldable<DbInterner<'db>>,
     {
         self.table.canonicalize(t)
     }
@@ -42,11 +34,11 @@ impl InferenceContext<'_> {
     ) -> SmallVec<[WhereClause; 4]> {
         self.table.resolve_obligations_as_possible();
 
-        let root = self.table.var_unification_table.inference_var_root(self_ty);
+        let root = InferenceVar::from_vid(self.table.infer_ctxt.root_var(self_ty.to_vid()));
         let pending_obligations = mem::take(&mut self.table.pending_obligations);
         let obligations = pending_obligations
             .iter()
-            .filter_map(|obligation| match obligation.value.value.goal.data(Interner) {
+            .filter_map(|obligation| match obligation.goal.data(Interner) {
                 GoalData::DomainGoal(DomainGoal::Holds(clause)) => {
                     let ty = match clause {
                         WhereClause::AliasEq(AliasEq {
@@ -59,18 +51,9 @@ impl InferenceContext<'_> {
                         WhereClause::TypeOutlives(to) => to.ty.clone(),
                         _ => return None,
                     };
-
-                    let uncanonical =
-                        chalk_ir::Substitute::apply(&obligation.free_vars, ty, Interner);
-                    if matches!(
-                        self.resolve_ty_shallow(&uncanonical).kind(Interner),
-                        TyKind::InferenceVar(iv, TyVariableKind::General) if *iv == root,
-                    ) {
-                        Some(chalk_ir::Substitute::apply(
-                            &obligation.free_vars,
-                            clause.clone(),
-                            Interner,
-                        ))
+                    let ty = self.resolve_ty_shallow(&ty);
+                    if matches!(ty.kind(Interner), TyKind::InferenceVar(iv, TyVariableKind::General) if *iv == root) {
+                        Some(clause.clone())
                     } else {
                         None
                     }
@@ -229,32 +212,31 @@ type ChalkInferenceTable = chalk_solve::infer::InferenceTable<Interner>;
 #[derive(Clone)]
 pub(crate) struct InferenceTable<'a> {
     pub(crate) db: &'a dyn HirDatabase,
+    pub(crate) interner: DbInterner<'a>,
     pub(crate) trait_env: Arc<TraitEnvironment>,
     pub(crate) tait_coercion_table: Option<FxHashMap<OpaqueTyId, Ty>>,
-    var_unification_table: ChalkInferenceTable,
-    type_variable_table: SmallVec<[TypeVariableFlags; 16]>,
-    pending_obligations: Vec<Canonicalized<InEnvironment<Goal>>>,
-    /// Double buffer used in [`Self::resolve_obligations_as_possible`] to cut down on
-    /// temporary allocations.
-    resolve_obligations_buffer: Vec<Canonicalized<InEnvironment<Goal>>>,
+    infer_ctxt: InferCtxt<'a>,
+    diverging_tys: FxHashSet<Ty>,
+    pending_obligations: Vec<InEnvironment<Goal>>,
 }
 
 pub(crate) struct InferenceTableSnapshot {
-    var_table_snapshot: chalk_solve::infer::InferenceSnapshot<Interner>,
-    type_variable_table: SmallVec<[TypeVariableFlags; 16]>,
-    pending_obligations: Vec<Canonicalized<InEnvironment<Goal>>>,
+    ctxt_snapshot: CombinedSnapshot,
+    diverging_tys: FxHashSet<Ty>,
+    pending_obligations: Vec<InEnvironment<Goal>>,
 }
 
 impl<'a> InferenceTable<'a> {
     pub(crate) fn new(db: &'a dyn HirDatabase, trait_env: Arc<TraitEnvironment>) -> Self {
+        let interner = DbInterner::new_with(db, Some(trait_env.krate), trait_env.block);
         InferenceTable {
             db,
+            interner,
             trait_env,
             tait_coercion_table: None,
-            var_unification_table: ChalkInferenceTable::new(),
-            type_variable_table: SmallVec::new(),
+            infer_ctxt: interner.infer_ctxt().build(rustc_type_ir::TypingMode::Analysis { defining_opaque_types_and_generators: SolverDefIds::new_from_iter(interner, []) }),
+            diverging_tys: FxHashSet::default(),
             pending_obligations: Vec::new(),
-            resolve_obligations_buffer: Vec::new(),
         }
     }
 
@@ -265,29 +247,43 @@ impl<'a> InferenceTable<'a> {
     /// marked as diverging if necessary, so that resolving them gives the right
     /// result.
     pub(super) fn propagate_diverging_flag(&mut self) {
-        for i in 0..self.type_variable_table.len() {
-            if !self.type_variable_table[i].contains(TypeVariableFlags::DIVERGING) {
-                continue;
+        let mut new_tys = FxHashSet::default();
+        for ty in self.diverging_tys.iter() {
+            match ty.kind(Interner) {
+                TyKind::InferenceVar(var, kind) => {
+                    match kind {
+                        TyVariableKind::General => {
+                            let root = InferenceVar::from(self.infer_ctxt.root_var(TyVid::from_u32(var.index())).as_u32());
+                            if root.index() != var.index() {
+                                new_tys.insert(TyKind::InferenceVar(root, *kind).intern(Interner));
+                            }
+                        }
+                        TyVariableKind::Integer => {
+                            let root = InferenceVar::from(self.infer_ctxt.inner.borrow_mut().int_unification_table().find(IntVid::from_usize(var.index() as usize)).as_u32());
+                            if root.index() != var.index() {
+                                new_tys.insert(TyKind::InferenceVar(root, *kind).intern(Interner));
+                            }
+                        }
+                        TyVariableKind::Float => {
+                            let root = InferenceVar::from(self.infer_ctxt.inner.borrow_mut().float_unification_table().find(FloatVid::from_usize(var.index() as usize)).as_u32());
+                            if root.index() != var.index() {
+                                new_tys.insert(TyKind::InferenceVar(root, *kind).intern(Interner));
+                            }
+                        }
+                    }
+                }
+                _ => {}
             }
-            let v = InferenceVar::from(i as u32);
-            let root = self.var_unification_table.inference_var_root(v);
-            self.modify_type_variable_flag(root, |f| {
-                *f |= TypeVariableFlags::DIVERGING;
-            });
         }
+        self.diverging_tys.extend(new_tys.into_iter());
     }
 
-    pub(super) fn set_diverging(&mut self, iv: InferenceVar, diverging: bool) {
-        self.modify_type_variable_flag(iv, |f| {
-            f.set(TypeVariableFlags::DIVERGING, diverging);
-        });
+    pub(super) fn set_diverging(&mut self, iv: InferenceVar, kind: TyVariableKind, diverging: bool) {
+        self.diverging_tys.insert(TyKind::InferenceVar(iv, kind).intern(Interner));
     }
 
     fn fallback_value(&self, iv: InferenceVar, kind: TyVariableKind) -> Ty {
-        let is_diverging = self
-            .type_variable_table
-            .get(iv.index() as usize)
-            .is_some_and(|data| data.contains(TypeVariableFlags::DIVERGING));
+        let is_diverging = self.diverging_tys.contains(&TyKind::InferenceVar(iv, kind).intern(Interner));
         if is_diverging {
             return TyKind::Never.intern(Interner);
         }
@@ -299,30 +295,27 @@ impl<'a> InferenceTable<'a> {
         .intern(Interner)
     }
 
-    pub(crate) fn canonicalize_with_free_vars<T>(&mut self, t: T) -> Canonicalized<T>
+    pub(crate) fn canonicalize_with_free_vars<T>(&mut self, t: ParamEnvAnd<'a, T>) -> (rustc_type_ir::Canonical<DbInterner<'a>, ParamEnvAnd<'a, T>>, OriginalQueryValues<'a>)
     where
-        T: TypeFoldable<Interner> + HasInterner<Interner = Interner>,
+        T: rustc_type_ir::TypeFoldable<DbInterner<'a>>,
     {
         // try to resolve obligations before canonicalizing, since this might
         // result in new knowledge about variables
         self.resolve_obligations_as_possible();
-        let result = self.var_unification_table.canonicalize(Interner, t);
-        let free_vars = result
-            .free_vars
-            .into_iter()
-            .map(|free_var| free_var.to_generic_arg(Interner))
-            .collect();
-        Canonicalized { value: result.quantified, free_vars }
+
+        let mut orig_values = OriginalQueryValues::default();
+        let result = self.infer_ctxt.canonicalize_query(t, &mut orig_values);
+        (result.canonical, orig_values)
     }
 
-    pub(crate) fn canonicalize<T>(&mut self, t: T) -> Canonical<T>
+    pub(crate) fn canonicalize<T>(&mut self, t: T) -> rustc_type_ir::Canonical<DbInterner<'a>, T>
     where
-        T: TypeFoldable<Interner> + HasInterner<Interner = Interner>,
+        T: rustc_type_ir::TypeFoldable<DbInterner<'a>>,
     {
         // try to resolve obligations before canonicalizing, since this might
         // result in new knowledge about variables
         self.resolve_obligations_as_possible();
-        self.var_unification_table.canonicalize(Interner, t).quantified
+        self.infer_ctxt.canonicalize_response(t)
     }
 
     /// Recurses through the given type, normalizing associated types mentioned
@@ -348,6 +341,7 @@ impl<'a> InferenceTable<'a> {
                             self.resolve_ty_shallow(&ty)
                         }
                         TyKind::AssociatedType(id, subst) => {
+                            return Either::Left(self.resolve_ty_shallow(&ty));
                             if ty.data(Interner).flags.intersects(
                                 chalk_ir::TypeFlags::HAS_TY_INFER
                                     | chalk_ir::TypeFlags::HAS_CT_INFER,
@@ -370,21 +364,24 @@ impl<'a> InferenceTable<'a> {
                                 )),
                             );
                             let in_env = InEnvironment::new(&self.trait_env.env, goal);
+                            let goal = in_env.to_nextsolver(self.interner);
+                            let goal = ParamEnvAnd { param_env: goal.param_env, value: goal.predicate };
 
-                            let canonicalized = {
-                                let result =
-                                    self.var_unification_table.canonicalize(Interner, in_env);
-                                let free_vars = result
-                                    .free_vars
-                                    .into_iter()
-                                    .map(|free_var| free_var.to_generic_arg(Interner))
-                                    .collect();
-                                Canonicalized { value: result.quantified, free_vars }
+                            let (canonical_goal, _orig_values) = {
+                                let mut orig_values = OriginalQueryValues::default();
+                                let result = self.infer_ctxt.canonicalize_query(goal, &mut orig_values);
+                                (result.canonical, orig_values)
+                            };
+                            let canonical_goal = rustc_type_ir::Canonical {
+                                max_universe: canonical_goal.max_universe,
+                                variables: canonical_goal.variables,
+                                value: crate::next_solver::Goal { param_env: canonical_goal.value.param_env, predicate: canonical_goal.value.value },
                             };
-                            let solution = self.db.trait_solve(
+                            let solution = next_trait_solve_canonical(
+                                self.db,
                                 self.trait_env.krate,
                                 self.trait_env.block,
-                                canonicalized.value.clone(),
+                                canonical_goal.clone(),
                             );
                             if let NextTraitSolveResult::Certain(canonical_subst) = solution {
                                 // This is not great :) But let's just assert this for now and come back to it later.
@@ -512,38 +509,27 @@ impl<'a> InferenceTable<'a> {
         var
     }
 
-    fn modify_type_variable_flag<F>(&mut self, var: InferenceVar, cb: F)
-    where
-        F: FnOnce(&mut TypeVariableFlags),
-    {
-        let idx = var.index() as usize;
-        if self.type_variable_table.len() <= idx {
-            self.extend_type_variable_table(idx);
-        }
-        if let Some(f) = self.type_variable_table.get_mut(idx) {
-            cb(f);
-        }
-    }
-    fn extend_type_variable_table(&mut self, to_index: usize) {
-        let count = to_index - self.type_variable_table.len() + 1;
-        self.type_variable_table.extend(std::iter::repeat_n(TypeVariableFlags::default(), count));
-    }
-
     fn new_var(&mut self, kind: TyVariableKind, diverging: bool) -> Ty {
-        let var = self.var_unification_table.new_variable(UniverseIndex::ROOT);
-        // Chalk might have created some type variables for its own purposes that we don't know about...
-        self.extend_type_variable_table(var.index() as usize);
-        assert_eq!(var.index() as usize, self.type_variable_table.len() - 1);
-        let flags = self.type_variable_table.get_mut(var.index() as usize).unwrap();
+        let var = match kind {
+            TyVariableKind::General => {
+                let var = self.infer_ctxt.next_ty_vid();
+                InferenceVar::from(var.as_u32())
+            }
+            TyVariableKind::Integer => {
+                let var = self.infer_ctxt.next_int_vid();
+                InferenceVar::from(var.as_u32())
+            }
+            TyVariableKind::Float => {
+                let var = self.infer_ctxt.next_float_vid();
+                InferenceVar::from(var.as_u32())
+            }
+        };
+
+        let ty = var.to_ty(Interner, kind);
         if diverging {
-            *flags |= TypeVariableFlags::DIVERGING;
-        }
-        if matches!(kind, TyVariableKind::Integer) {
-            *flags |= TypeVariableFlags::INTEGER;
-        } else if matches!(kind, TyVariableKind::Float) {
-            *flags |= TypeVariableFlags::FLOAT;
+            self.diverging_tys.insert(ty.clone());
         }
-        var.to_ty_with_kind(Interner, kind)
+        ty
     }
 
     pub(crate) fn new_type_var(&mut self) -> Ty {
@@ -563,12 +549,14 @@ impl<'a> InferenceTable<'a> {
     }
 
     pub(crate) fn new_const_var(&mut self, ty: Ty) -> Const {
-        let var = self.var_unification_table.new_variable(UniverseIndex::ROOT);
+        let var = self.infer_ctxt.next_const_vid();
+        let var = InferenceVar::from(var.as_u32());
         var.to_const(Interner, ty)
     }
 
     pub(crate) fn new_lifetime_var(&mut self) -> Lifetime {
-        let var = self.var_unification_table.new_variable(UniverseIndex::ROOT);
+        let var = self.infer_ctxt.next_region_vid();
+        let var = InferenceVar::from(var.as_u32());
         var.to_lifetime(Interner)
     }
 
@@ -580,16 +568,16 @@ impl<'a> InferenceTable<'a> {
     where
         T: HasInterner<Interner = Interner> + TypeFoldable<Interner>,
     {
-        self.resolve_with_fallback_inner(&mut Vec::new(), t, &fallback)
+        self.resolve_with_fallback_inner(t, &fallback)
     }
 
     pub(crate) fn fresh_subst(&mut self, binders: &[CanonicalVarKind<Interner>]) -> Substitution {
         Substitution::from_iter(
             Interner,
-            binders.iter().map(|kind| {
-                let param_infer_var =
-                    kind.map_ref(|&ui| self.var_unification_table.new_variable(ui));
-                param_infer_var.to_generic_arg(Interner)
+            binders.iter().map(|kind| match &kind.kind {
+                chalk_ir::VariableKind::Ty(ty_variable_kind) => self.new_var(*ty_variable_kind, false).cast(Interner),
+                chalk_ir::VariableKind::Lifetime => self.new_lifetime_var().cast(Interner),
+                chalk_ir::VariableKind::Const(ty) => self.new_const_var(ty.clone()).cast(Interner),
             }),
         )
     }
@@ -601,16 +589,23 @@ impl<'a> InferenceTable<'a> {
         let subst = self.fresh_subst(canonical.binders.as_slice(Interner));
         subst.apply(canonical.value, Interner)
     }
+    
+    pub(crate) fn instantiate_canonical_ns<T>(&mut self, canonical: rustc_type_ir::Canonical<DbInterner<'a>, T>) -> T
+    where
+        T: rustc_type_ir::TypeFoldable<DbInterner<'a>>,
+    {
+        self.infer_ctxt.instantiate_canonical(&canonical).0
+    }
 
     fn resolve_with_fallback_inner<T>(
         &mut self,
-        var_stack: &mut Vec<InferenceVar>,
         t: T,
         fallback: &dyn Fn(InferenceVar, VariableKind, GenericArg, DebruijnIndex) -> GenericArg,
     ) -> T
     where
         T: HasInterner<Interner = Interner> + TypeFoldable<Interner>,
     {
+        let mut var_stack = &mut vec![];
         t.fold_with(
             &mut resolve::Resolver { table: self, var_stack, fallback },
             DebruijnIndex::INNERMOST,
@@ -639,29 +634,26 @@ impl<'a> InferenceTable<'a> {
         let int_fallback = TyKind::Scalar(Scalar::Int(IntTy::I32)).intern(Interner);
         let float_fallback = TyKind::Scalar(Scalar::Float(FloatTy::F64)).intern(Interner);
 
-        let scalar_vars: Vec<_> = self
-            .type_variable_table
-            .iter()
-            .enumerate()
-            .filter_map(|(index, flags)| {
-                let kind = if flags.contains(TypeVariableFlags::INTEGER) {
-                    TyVariableKind::Integer
-                } else if flags.contains(TypeVariableFlags::FLOAT) {
-                    TyVariableKind::Float
-                } else {
-                    return None;
+        let int_vars = self.infer_ctxt.inner.borrow_mut().int_unification_table().len();
+        for v in 0..int_vars {
+            let var = InferenceVar::from(v as u32).to_ty(Interner, TyVariableKind::Integer);
+            let maybe_resolved = self.resolve_ty_shallow(&var);
+            if let TyKind::InferenceVar(_, kind) = maybe_resolved.kind(Interner) {
+                // I don't think we can ever unify these vars with float vars, but keep this here for now
+                let fallback = match kind {
+                    TyVariableKind::Integer => &int_fallback,
+                    TyVariableKind::Float => &float_fallback,
+                    TyVariableKind::General => unreachable!(),
                 };
-
-                // FIXME: This is not really the nicest way to get `InferenceVar`s. Can we get them
-                // without directly constructing them from `index`?
-                let var = InferenceVar::from(index as u32).to_ty(Interner, kind);
-                Some(var)
-            })
-            .collect();
-
-        for var in scalar_vars {
+                self.unify(&var, fallback);
+            }
+        }
+        let float_vars = self.infer_ctxt.inner.borrow_mut().float_unification_table().len();
+        for v in 0..float_vars {
+            let var = InferenceVar::from(v as u32).to_ty(Interner, TyVariableKind::Integer);
             let maybe_resolved = self.resolve_ty_shallow(&var);
             if let TyKind::InferenceVar(_, kind) = maybe_resolved.kind(Interner) {
+                // I don't think we can ever unify these vars with float vars, but keep this here for now
                 let fallback = match kind {
                     TyVariableKind::Integer => &int_fallback,
                     TyVariableKind::Float => &float_fallback,
@@ -673,7 +665,7 @@ impl<'a> InferenceTable<'a> {
     }
 
     /// Unify two relatable values (e.g. `Ty`) and register new trait goals that arise from that.
-    pub(crate) fn unify<T: ?Sized + Zip<Interner>>(&mut self, ty1: &T, ty2: &T) -> bool {
+    pub(crate) fn unify<T: ChalkToNextSolver<'a, U>, U: Relate<DbInterner<'a>>>(&mut self, ty1: &T, ty2: &T) -> bool {
         let result = match self.try_unify(ty1, ty2) {
             Ok(r) => r,
             Err(_) => return false,
@@ -683,58 +675,65 @@ impl<'a> InferenceTable<'a> {
     }
 
     /// Unify two relatable values (e.g. `Ty`) and check whether trait goals which arise from that could be fulfilled
-    pub(crate) fn unify_deeply<T: ?Sized + Zip<Interner>>(&mut self, ty1: &T, ty2: &T) -> bool {
+    pub(crate) fn unify_deeply<T: ChalkToNextSolver<'a, U>, U: Relate<DbInterner<'a>>>(&mut self, ty1: &T, ty2: &T) -> bool {
         let result = match self.try_unify(ty1, ty2) {
             Ok(r) => r,
             Err(_) => return false,
         };
         result.goals.iter().all(|goal| {
-            let canonicalized = self.canonicalize_with_free_vars(goal.clone());
-            self.try_resolve_obligation(&canonicalized).certain()
+            let goal = goal.to_nextsolver(self.interner);
+            match next_trait_solve_in_ctxt(&self.infer_ctxt, goal) {
+                Ok((_, Certainty::Yes)) => true,
+                _ => false,
+            }
         })
     }
 
     /// Unify two relatable values (e.g. `Ty`) and return new trait goals arising from it, so the
     /// caller needs to deal with them.
-    pub(crate) fn try_unify<T: ?Sized + Zip<Interner>>(
+    pub(crate) fn try_unify<T: ChalkToNextSolver<'a, U>, U: Relate<DbInterner<'a>>>(
         &mut self,
         t1: &T,
         t2: &T,
     ) -> InferResult<()> {
-        match self.var_unification_table.relate(
-            Interner,
-            &self.db,
-            &self.trait_env.env,
-            chalk_ir::Variance::Invariant,
-            t1,
-            t2,
-        ) {
-            Ok(result) => Ok(InferOk { goals: result.goals, value: () }),
-            Err(chalk_ir::NoSolution) => Err(TypeError),
+        let param_env = self.trait_env.env.to_nextsolver(self.interner);
+        let lhs = t1.to_nextsolver(self.interner);
+        let rhs = t2.to_nextsolver(self.interner);
+        let variance = rustc_type_ir::Variance::Invariant;
+        let span = crate::next_solver::Span::dummy();
+        match self.infer_ctxt.relate(param_env, lhs, variance, rhs, span) {
+            Ok(res) => {
+            let goals = res.into_iter().map(|g| ChalkToNextSolver::from_nextsolver(g, self.interner)).collect();
+                Ok(InferOk { goals, value: () })
+            }
+            Err(_) => {
+                Err(TypeError)
+            }
         }
     }
 
     /// If `ty` is a type variable with known type, returns that type;
     /// otherwise, return ty.
+    #[tracing::instrument(skip(self))]
     pub(crate) fn resolve_ty_shallow(&mut self, ty: &Ty) -> Ty {
         if !ty.data(Interner).flags.intersects(chalk_ir::TypeFlags::HAS_FREE_LOCAL_NAMES) {
             return ty.clone();
         }
         self.resolve_obligations_as_possible();
-        self.var_unification_table.normalize_ty_shallow(Interner, ty).unwrap_or_else(|| ty.clone())
+        ChalkToNextSolver::from_nextsolver(self.infer_ctxt.resolve_vars_if_possible(ty.to_nextsolver(self.interner)), self.interner)
     }
 
     pub(crate) fn snapshot(&mut self) -> InferenceTableSnapshot {
-        let var_table_snapshot = self.var_unification_table.snapshot();
-        let type_variable_table = self.type_variable_table.clone();
+        let ctxt_snapshot = self.infer_ctxt.start_snapshot();
+        let diverging_tys = self.diverging_tys.clone();
         let pending_obligations = self.pending_obligations.clone();
-        InferenceTableSnapshot { var_table_snapshot, pending_obligations, type_variable_table }
+        InferenceTableSnapshot {ctxt_snapshot, pending_obligations, diverging_tys }
     }
 
     #[tracing::instrument(skip_all)]
     pub(crate) fn rollback_to(&mut self, snapshot: InferenceTableSnapshot) {
-        self.var_unification_table.rollback_to(snapshot.var_table_snapshot);
-        self.type_variable_table = snapshot.type_variable_table;
+        self.infer_ctxt.rollback_to(snapshot.ctxt_snapshot);
+        self.diverging_tys = snapshot.diverging_tys;
         self.pending_obligations = snapshot.pending_obligations;
     }
 
@@ -746,15 +745,39 @@ impl<'a> InferenceTable<'a> {
         result
     }
 
+    pub(crate) fn commit_if_ok<T, E>(&mut self, f: impl FnOnce(&mut InferenceTable<'_>) -> Result<T, E>) -> Result<T, E> {
+        let snapshot = self.snapshot();
+        let result = f(self);
+        match result {
+            Ok(_) => {}
+            Err(_) => {
+                self.rollback_to(snapshot);
+            }
+        }
+        result
+    }
+
     /// Checks an obligation without registering it. Useful mostly to check
     /// whether a trait *might* be implemented before deciding to 'lock in' the
     /// choice (during e.g. method resolution or deref).
     #[tracing::instrument(level = "debug", skip(self))]
     pub(crate) fn try_obligation(&mut self, goal: Goal) -> NextTraitSolveResult {
         let in_env = InEnvironment::new(&self.trait_env.env, goal);
-        let canonicalized = self.canonicalize(in_env);
+        let canonicalized = self.canonicalize(in_env.to_nextsolver(self.interner));
 
-        self.db.trait_solve(self.trait_env.krate, self.trait_env.block, canonicalized)
+        next_trait_solve_canonical(self.db, self.trait_env.krate, self.trait_env.block, canonicalized)
+    }
+    
+    #[tracing::instrument(level = "debug", skip(self))]
+    pub(crate) fn solve_obligation(&mut self, goal: Goal) -> Result<Certainty, NoSolution> {
+        let goal = InEnvironment::new(&self.trait_env.env, goal);
+        let Some(goal) = self.unify_opaque_instead_of_solve(goal) else { 
+            return Ok(Certainty::Yes);
+        };
+
+        let goal = goal.to_nextsolver(self.interner);
+        let result = next_trait_solve_in_ctxt(&self.infer_ctxt, goal);
+        result.map(|m| m.1)
     }
 
     pub(crate) fn register_obligation(&mut self, goal: Goal) {
@@ -762,8 +785,8 @@ impl<'a> InferenceTable<'a> {
         self.register_obligation_in_env(in_env)
     }
 
-    #[tracing::instrument(level = "debug", skip(self))]
-    fn register_obligation_in_env(&mut self, goal: InEnvironment<Goal>) {
+    // If this goal is an `AliasEq` for an opaque type, just unify instead of trying to solve (since the next-solver is lazy)
+    fn unify_opaque_instead_of_solve(&mut self, goal: InEnvironment<Goal>) -> Option<InEnvironment<Goal>> {
         match goal.goal.data(Interner) {
             chalk_ir::GoalData::DomainGoal(chalk_ir::DomainGoal::Holds(
                 chalk_ir::WhereClause::AliasEq(chalk_ir::AliasEq { alias, ty }),
@@ -779,7 +802,7 @@ impl<'a> InferenceTable<'a> {
                                 .intern(Interner),
                                 ty,
                             ) {
-                                return;
+                                return None;
                             }
                         }
                         _ => {}
@@ -788,20 +811,20 @@ impl<'a> InferenceTable<'a> {
             }
             _ => {}
         }
-        let canonicalized = {
-            let result = self.var_unification_table.canonicalize(Interner, goal);
-            let free_vars = result
-                .free_vars
-                .into_iter()
-                .map(|free_var| free_var.to_generic_arg(Interner))
-                .collect();
-            Canonicalized { value: result.quantified, free_vars }
-        };
-        tracing::debug!(?canonicalized);
-        let solution = self.try_resolve_obligation(&canonicalized);
-        tracing::debug!(?solution);
-        if solution.uncertain() {
-            self.pending_obligations.push(canonicalized);
+        Some(goal)
+    }
+
+    #[tracing::instrument(level = "debug", skip(self))]
+    fn register_obligation_in_env(&mut self, goal: InEnvironment<Goal>) {
+        let Some(goal) = self.unify_opaque_instead_of_solve(goal) else { return };
+        let result = next_trait_solve_in_ctxt(&self.infer_ctxt, goal.to_nextsolver(self.interner));
+        tracing::debug!(?result);
+        match result {
+            Ok((_, Certainty::Yes)) => {}
+            Err(rustc_type_ir::solve::NoSolution) => {}
+            Ok((_, Certainty::Maybe(_))) => {
+                self.pending_obligations.push(goal);
+            }
         }
     }
 
@@ -812,28 +835,35 @@ impl<'a> InferenceTable<'a> {
     pub(crate) fn resolve_obligations_as_possible(&mut self) {
         let _span = tracing::info_span!("resolve_obligations_as_possible").entered();
         let mut changed = true;
-        let mut obligations = mem::take(&mut self.resolve_obligations_buffer);
         while mem::take(&mut changed) {
-            mem::swap(&mut self.pending_obligations, &mut obligations);
+            let mut obligations = mem::take(&mut self.pending_obligations);
 
-            for canonicalized in obligations.drain(..) {
-                tracing::debug!(obligation = ?canonicalized);
-                if !self.check_changed(&canonicalized) {
-                    tracing::debug!("not changed");
-                    self.pending_obligations.push(canonicalized);
+            for goal in obligations.drain(..) {
+                tracing::debug!(obligation = ?goal);
+
+                let Some(goal) = self.unify_opaque_instead_of_solve(goal) else { 
+                    changed = true;
                     continue;
+                };
+
+                let result = next_trait_solve_in_ctxt(&self.infer_ctxt, goal.to_nextsolver(self.interner));
+                let (has_changed, certainty) = match result {
+                    Ok(result) => result,
+                    Err(_) => {
+                        continue;
+                    }
+                };
+
+                if matches!(has_changed, HasChanged::Yes) {
+                    changed = true;
+                }
+
+                match certainty {
+                    Certainty::Yes => {}
+                    Certainty::Maybe(_) => self.pending_obligations.push(goal),
                 }
-                changed = true;
-                let uncanonical = chalk_ir::Substitute::apply(
-                    &canonicalized.free_vars,
-                    canonicalized.value.value,
-                    Interner,
-                );
-                self.register_obligation_in_env(uncanonical);
             }
         }
-        self.resolve_obligations_buffer = obligations;
-        self.resolve_obligations_buffer.clear();
     }
 
     pub(crate) fn fudge_inference<T: TypeFoldable<Interner>>(
@@ -904,32 +934,13 @@ impl<'a> InferenceTable<'a> {
             .fold_with(&mut VarFudger { table: self, highest_known_var }, DebruijnIndex::INNERMOST)
     }
 
-    /// This checks whether any of the free variables in the `canonicalized`
-    /// have changed (either been unified with another variable, or with a
-    /// value). If this is not the case, we don't need to try to solve the goal
-    /// again -- it'll give the same result as last time.
-    fn check_changed(&mut self, canonicalized: &Canonicalized<InEnvironment<Goal>>) -> bool {
-        canonicalized.free_vars.iter().any(|var| {
-            let iv = match var.data(Interner) {
-                GenericArgData::Ty(ty) => ty.inference_var(Interner),
-                GenericArgData::Lifetime(lt) => lt.inference_var(Interner),
-                GenericArgData::Const(c) => c.inference_var(Interner),
-            }
-            .expect("free var is not inference var");
-            if self.var_unification_table.probe_var(iv).is_some() {
-                return true;
-            }
-            let root = self.var_unification_table.inference_var_root(iv);
-            iv != root
-        })
-    }
-
     #[tracing::instrument(level = "debug", skip(self))]
     fn try_resolve_obligation(
         &mut self,
         canonicalized: &Canonicalized<InEnvironment<Goal>>,
     ) -> NextTraitSolveResult {
-        let solution = self.db.trait_solve(
+        let solution = next_trait_solve(
+            self.db,
             self.trait_env.krate,
             self.trait_env.block,
             canonicalized.value.clone(),
@@ -1014,33 +1025,15 @@ impl<'a> InferenceTable<'a> {
             .fill_with_unknown()
             .build();
 
-            let trait_env = self.trait_env.env.clone();
-            let obligation = InEnvironment {
-                goal: trait_ref.clone().cast(Interner),
-                environment: trait_env.clone(),
-            };
-            let canonical = self.canonicalize(obligation.clone());
-            if !self
-                .db
-                .trait_solve(krate, self.trait_env.block, canonical.cast(Interner))
-                .no_solution()
-            {
-                self.register_obligation(obligation.goal);
+            let goal: Goal = trait_ref.clone().cast(Interner);
+            if !self.try_obligation(goal.clone()).no_solution() {
+                self.register_obligation(goal);
                 let return_ty = self.normalize_projection_ty(projection);
                 for &fn_x in subtraits {
                     let fn_x_trait = fn_x.get_id(self.db, krate)?;
                     trait_ref.trait_id = to_chalk_trait_id(fn_x_trait);
-                    let obligation: chalk_ir::InEnvironment<chalk_ir::Goal<Interner>> =
-                        InEnvironment {
-                            goal: trait_ref.clone().cast(Interner),
-                            environment: trait_env.clone(),
-                        };
-                    let canonical = self.canonicalize(obligation.clone());
-                    if !self
-                        .db
-                        .trait_solve(krate, self.trait_env.block, canonical.cast(Interner))
-                        .no_solution()
-                    {
+                    let goal = trait_ref.clone().cast(Interner);
+                    if !self.try_obligation(goal).no_solution() {
                         return Some((fn_x, arg_tys, return_ty));
                     }
                 }
@@ -1165,20 +1158,26 @@ impl<'a> InferenceTable<'a> {
 
 impl fmt::Debug for InferenceTable<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("InferenceTable").field("num_vars", &self.type_variable_table.len()).finish()
+        f.debug_struct("InferenceTable").finish()
     }
 }
 
 mod resolve {
     use super::InferenceTable;
     use crate::{
-        ConcreteConst, Const, ConstData, ConstScalar, ConstValue, DebruijnIndex, GenericArg,
-        InferenceVar, Interner, Lifetime, Ty, TyVariableKind, VariableKind,
+        next_solver::mapping::ChalkToNextSolver, ConcreteConst, Const, ConstData, ConstScalar, ConstValue, DebruijnIndex, GenericArg, InferenceVar, Interner, Lifetime, Ty, TyVariableKind, VariableKind
     };
     use chalk_ir::{
         cast::Cast,
         fold::{TypeFoldable, TypeFolder},
     };
+    use rustc_type_ir::{FloatVid, IntVid, TyVid};
+
+    #[derive(Copy, Clone, PartialEq, Eq)]
+    pub(super) enum VarKind {
+        Ty(TyVariableKind),
+        Const,
+    }
 
     #[derive(chalk_derive::FallibleTypeFolder)]
     #[has_interner(Interner)]
@@ -1188,7 +1187,7 @@ mod resolve {
         F: Fn(InferenceVar, VariableKind, GenericArg, DebruijnIndex) -> GenericArg,
     > {
         pub(super) table: &'a mut InferenceTable<'b>,
-        pub(super) var_stack: &'a mut Vec<InferenceVar>,
+        pub(super) var_stack: &'a mut Vec<(InferenceVar, VarKind)>,
         pub(super) fallback: F,
     }
     impl<F> TypeFolder<Interner> for Resolver<'_, '_, F>
@@ -1209,25 +1208,79 @@ mod resolve {
             kind: TyVariableKind,
             outer_binder: DebruijnIndex,
         ) -> Ty {
-            let var = self.table.var_unification_table.inference_var_root(var);
-            if self.var_stack.contains(&var) {
-                // recursive type
-                let default = self.table.fallback_value(var, kind).cast(Interner);
-                return (self.fallback)(var, VariableKind::Ty(kind), default, outer_binder)
-                    .assert_ty_ref(Interner)
-                    .clone();
-            }
-            if let Some(known_ty) = self.table.var_unification_table.probe_var(var) {
-                // known_ty may contain other variables that are known by now
-                self.var_stack.push(var);
-                let result = known_ty.fold_with(self, outer_binder);
-                self.var_stack.pop();
-                result.assert_ty_ref(Interner).clone()
-            } else {
-                let default = self.table.fallback_value(var, kind).cast(Interner);
-                (self.fallback)(var, VariableKind::Ty(kind), default, outer_binder)
-                    .assert_ty_ref(Interner)
-                    .clone()
+            match kind {
+                TyVariableKind::General => {
+                    let vid = self.table.infer_ctxt.root_var(TyVid::from(var.index()));
+                    let var = InferenceVar::from(vid.as_u32());
+                    if self.var_stack.contains(&(var, VarKind::Ty(kind))) {
+                        // recursive type
+                        let default = self.table.fallback_value(var, kind).cast(Interner);
+                        return (self.fallback)(var, VariableKind::Ty(kind), default, outer_binder)
+                            .assert_ty_ref(Interner)
+                            .clone();
+                    }
+                    if let Ok(known_ty) = self.table.infer_ctxt.probe_ty_var(vid) {
+                        let known_ty: Ty = ChalkToNextSolver::from_nextsolver(known_ty, self.table.interner);
+                        // known_ty may contain other variables that are known by now
+                        self.var_stack.push((var, VarKind::Ty(kind)));
+                        let result = known_ty.fold_with(self, outer_binder);
+                        self.var_stack.pop();
+                        result
+                    } else {
+                        let default = self.table.fallback_value(var, kind).cast(Interner);
+                        (self.fallback)(var, VariableKind::Ty(kind), default, outer_binder)
+                            .assert_ty_ref(Interner)
+                            .clone()
+                    }
+                }
+                TyVariableKind::Integer => {
+                    let vid = self.table.infer_ctxt.inner.borrow_mut().int_unification_table().find(IntVid::from(var.index()));
+                    let var = InferenceVar::from(vid.as_u32());
+                    if self.var_stack.contains(&(var, VarKind::Ty(kind))) {
+                        // recursive type
+                        let default = self.table.fallback_value(var, kind).cast(Interner);
+                        return (self.fallback)(var, VariableKind::Ty(kind), default, outer_binder)
+                            .assert_ty_ref(Interner)
+                            .clone();
+                    }
+                    if let Some(known_ty) = self.table.infer_ctxt.resolve_int_var(vid) {
+                        let known_ty: Ty = ChalkToNextSolver::from_nextsolver(known_ty, self.table.interner);
+                        // known_ty may contain other variables that are known by now
+                        self.var_stack.push((var, VarKind::Ty(kind)));
+                        let result = known_ty.fold_with(self, outer_binder);
+                        self.var_stack.pop();
+                        result
+                    } else {
+                        let default = self.table.fallback_value(var, kind).cast(Interner);
+                        (self.fallback)(var, VariableKind::Ty(kind), default, outer_binder)
+                            .assert_ty_ref(Interner)
+                            .clone()
+                    }
+                }
+                TyVariableKind::Float => {
+                    let vid = self.table.infer_ctxt.inner.borrow_mut().float_unification_table().find(FloatVid::from(var.index()));
+                    let var = InferenceVar::from(vid.as_u32());
+                    if self.var_stack.contains(&(var, VarKind::Ty(kind))) {
+                        // recursive type
+                        let default = self.table.fallback_value(var, kind).cast(Interner);
+                        return (self.fallback)(var, VariableKind::Ty(kind), default, outer_binder)
+                            .assert_ty_ref(Interner)
+                            .clone();
+                    }
+                    if let Some(known_ty) = self.table.infer_ctxt.resolve_float_var(vid) {
+                        let known_ty: Ty = ChalkToNextSolver::from_nextsolver(known_ty, self.table.interner);
+                        // known_ty may contain other variables that are known by now
+                        self.var_stack.push((var, VarKind::Ty(kind)));
+                        let result = known_ty.fold_with(self, outer_binder);
+                        self.var_stack.pop();
+                        result
+                    } else {
+                        let default = self.table.fallback_value(var, kind).cast(Interner);
+                        (self.fallback)(var, VariableKind::Ty(kind), default, outer_binder)
+                            .assert_ty_ref(Interner)
+                            .clone()
+                    }
+                }
             }
         }
 
@@ -1237,25 +1290,27 @@ mod resolve {
             var: InferenceVar,
             outer_binder: DebruijnIndex,
         ) -> Const {
-            let var = self.table.var_unification_table.inference_var_root(var);
+            let vid = self.table.infer_ctxt.root_const_var(rustc_type_ir::ConstVid::from_u32(var.index()));
+            let var = InferenceVar::from(vid.as_u32());
             let default = ConstData {
                 ty: ty.clone(),
                 value: ConstValue::Concrete(ConcreteConst { interned: ConstScalar::Unknown }),
             }
             .intern(Interner)
             .cast(Interner);
-            if self.var_stack.contains(&var) {
+            if self.var_stack.contains(&(var, VarKind::Const)) {
                 // recursive
                 return (self.fallback)(var, VariableKind::Const(ty), default, outer_binder)
                     .assert_const_ref(Interner)
                     .clone();
             }
-            if let Some(known_ty) = self.table.var_unification_table.probe_var(var) {
+            if let Ok(known_const) = self.table.infer_ctxt.probe_const_var(vid) {
+                let known_const: Const = ChalkToNextSolver::from_nextsolver(known_const, self.table.interner);
                 // known_ty may contain other variables that are known by now
-                self.var_stack.push(var);
-                let result = known_ty.fold_with(self, outer_binder);
+                self.var_stack.push((var, VarKind::Const));
+                let result = known_const.fold_with(self, outer_binder);
                 self.var_stack.pop();
-                result.assert_const_ref(Interner).clone()
+                result
             } else {
                 (self.fallback)(var, VariableKind::Const(ty), default, outer_binder)
                     .assert_const_ref(Interner)
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 c16bbb7b99221..323ea951a9141 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
@@ -957,23 +957,13 @@ pub fn callable_sig_from_fn_trait(
     )
     .build();
 
-    let block = trait_env.block;
-    let trait_env = trait_env.env.clone();
-    let obligation =
-        InEnvironment { goal: trait_ref.clone().cast(Interner), environment: trait_env.clone() };
-    let canonical = table.canonicalize(obligation.clone());
-    if !db.trait_solve(krate, block, canonical.cast(Interner)).no_solution() {
-        table.register_obligation(obligation.goal);
+    if !table.try_obligation(trait_ref.clone().cast(Interner)).no_solution() {
+        table.register_obligation(trait_ref.clone().cast(Interner));
         let return_ty = table.normalize_projection_ty(projection);
         for fn_x in [FnTrait::Fn, FnTrait::FnMut, FnTrait::FnOnce] {
             let fn_x_trait = fn_x.get_id(db, krate)?;
             trait_ref.trait_id = to_chalk_trait_id(fn_x_trait);
-            let obligation: chalk_ir::InEnvironment<chalk_ir::Goal<Interner>> = InEnvironment {
-                goal: trait_ref.clone().cast(Interner),
-                environment: trait_env.clone(),
-            };
-            let canonical = table.canonicalize(obligation.clone());
-            if !db.trait_solve(krate, block, canonical.cast(Interner)).no_solution() {
+            if !table.try_obligation(trait_ref.clone().cast(Interner)).no_solution() {
                 let ret_ty = table.resolve_completely(return_ty);
                 let args_ty = table.resolve_completely(args_ty);
                 let params = args_ty
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
index f0be352fdd151..ee223059d1e56 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
@@ -16,25 +16,13 @@ use hir_def::{
 use hir_expand::name::Name;
 use intern::sym;
 use rustc_hash::{FxHashMap, FxHashSet};
-use rustc_type_ir::inherent::{IntoKind, SliceLike};
+use rustc_type_ir::inherent::{IntoKind, SliceLike, Ty as _};
 use smallvec::{SmallVec, smallvec};
 use stdx::never;
 use triomphe::Arc;
 
 use crate::{
-    AdtId, Canonical, CanonicalVarKinds, DebruijnIndex, DynTyExt, ForeignDefId, GenericArgData,
-    Goal, InEnvironment, Interner, Mutability, Scalar, Substitution, TraitEnvironment, TraitRef,
-    TraitRefExt, Ty, TyBuilder, TyExt, TyKind, TyVariableKind, VariableKind, WhereClause,
-    autoderef::{self, AutoderefKind},
-    db::HirDatabase,
-    error_lifetime, from_chalk_trait_id, from_foreign_def_id,
-    infer::{Adjust, Adjustment, OverloadedDeref, PointerCast, unify::InferenceTable},
-    lang_items::is_box,
-    next_solver::SolverDefId,
-    primitive::{FloatTy, IntTy, UintTy},
-    to_chalk_trait_id,
-    traits::NextTraitSolveResult,
-    utils::all_super_traits,
+    autoderef::{self, AutoderefKind}, db::HirDatabase, from_chalk_trait_id, from_foreign_def_id, infer::{unify::InferenceTable, Adjust, Adjustment, OverloadedDeref, PointerCast}, lang_items::is_box, next_solver::{mapping::ChalkToNextSolver, SolverDefId}, primitive::{FloatTy, IntTy, UintTy}, to_chalk_trait_id, traits::{next_trait_solve_canonical}, utils::all_super_traits, AdtId, Canonical, CanonicalVarKinds, DebruijnIndex, DynTyExt, ForeignDefId, GenericArgData, Goal, InEnvironment, Interner, Mutability, Scalar, Substitution, TraitEnvironment, TraitRef, TraitRefExt, Ty, TyBuilder, TyExt, TyKind, TyVariableKind, VariableKind, WhereClause
 };
 
 /// This is used as a key for indexing impls.
@@ -533,9 +521,9 @@ pub fn def_crates(db: &dyn HirDatabase, ty: &Ty, cur_crate: Crate) -> Option<Sma
 }
 
 /// Look up the method with the given name.
-pub(crate) fn lookup_method(
-    db: &dyn HirDatabase,
-    ty: &Canonical<Ty>,
+pub(crate) fn lookup_method<'db>(
+    db: &'db dyn HirDatabase,
+    ty: &crate::next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
     env: Arc<TraitEnvironment>,
     traits_in_scope: &FxHashSet<TraitId>,
     visible_from_module: VisibleFromModule,
@@ -697,9 +685,9 @@ impl ReceiverAdjustments {
 // This would be nicer if it just returned an iterator, but that runs into
 // lifetime problems, because we need to borrow temp `CrateImplDefs`.
 // FIXME add a context type here?
-pub(crate) fn iterate_method_candidates<T>(
-    ty: &Canonical<Ty>,
-    db: &dyn HirDatabase,
+pub(crate) fn iterate_method_candidates<'db, T>(
+    ty: &crate::next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
+    db: &'db dyn HirDatabase,
     env: Arc<TraitEnvironment>,
     traits_in_scope: &FxHashSet<TraitId>,
     visible_from_module: VisibleFromModule,
@@ -1046,9 +1034,9 @@ pub fn check_orphan_rules(db: &dyn HirDatabase, impl_: ImplId) -> bool {
     is_not_orphan
 }
 
-pub fn iterate_path_candidates(
-    ty: &Canonical<Ty>,
-    db: &dyn HirDatabase,
+pub fn iterate_path_candidates<'db>(
+    ty: &crate::next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
+    db: &'db dyn HirDatabase,
     env: Arc<TraitEnvironment>,
     traits_in_scope: &FxHashSet<TraitId>,
     visible_from_module: VisibleFromModule,
@@ -1068,9 +1056,9 @@ pub fn iterate_path_candidates(
     )
 }
 
-pub fn iterate_method_candidates_dyn(
-    ty: &Canonical<Ty>,
-    db: &dyn HirDatabase,
+pub fn iterate_method_candidates_dyn<'db>(
+    ty: &crate::next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
+    db: &'db dyn HirDatabase,
     env: Arc<TraitEnvironment>,
     traits_in_scope: &FxHashSet<TraitId>,
     visible_from_module: VisibleFromModule,
@@ -1108,7 +1096,7 @@ pub fn iterate_method_candidates_dyn(
             // types*.
 
             let mut table = InferenceTable::new(db, env);
-            let ty = table.instantiate_canonical(ty.clone());
+            let ty = table.instantiate_canonical_ns(ty.clone());
             let deref_chain = autoderef_method_receiver(&mut table, ty);
 
             deref_chain.into_iter().try_for_each(|(receiver_ty, adj)| {
@@ -1139,20 +1127,22 @@ pub fn iterate_method_candidates_dyn(
 }
 
 #[tracing::instrument(skip_all, fields(name = ?name))]
-fn iterate_method_candidates_with_autoref(
-    table: &mut InferenceTable<'_>,
-    receiver_ty: Canonical<Ty>,
+fn iterate_method_candidates_with_autoref<'db>(
+    table: &mut InferenceTable<'db>,
+    receiver_ty: crate::next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
     first_adjustment: ReceiverAdjustments,
     traits_in_scope: &FxHashSet<TraitId>,
     visible_from_module: VisibleFromModule,
     name: Option<&Name>,
     callback: &mut dyn MethodCandidateCallback,
 ) -> ControlFlow<()> {
-    if receiver_ty.value.is_general_var(Interner, &receiver_ty.binders) {
+    if matches!(receiver_ty.value.kind(), rustc_type_ir::TyKind::Bound(..)) {
         // don't try to resolve methods on unknown types
         return ControlFlow::Continue(());
     }
 
+    let interner = table.interner;
+
     let mut iterate_method_candidates_by_receiver = move |receiver_ty, first_adjustment| {
         iterate_method_candidates_by_receiver(
             table,
@@ -1166,7 +1156,11 @@ fn iterate_method_candidates_with_autoref(
     };
 
     let mut maybe_reborrowed = first_adjustment.clone();
-    if let Some((_, _, m)) = receiver_ty.value.as_reference() {
+    if let rustc_type_ir::TyKind::Ref(_, _, m) = receiver_ty.value.kind() {
+        let m = match m {
+            rustc_ast_ir::Mutability::Mut => chalk_ir::Mutability::Mut,
+            rustc_ast_ir::Mutability::Not => chalk_ir::Mutability::Not,
+        };
         // Prefer reborrow of references to move
         maybe_reborrowed.autoref = Some(AutorefOrPtrAdjustment::Autoref(m));
         maybe_reborrowed.autoderefs += 1;
@@ -1174,10 +1168,10 @@ fn iterate_method_candidates_with_autoref(
 
     iterate_method_candidates_by_receiver(receiver_ty.clone(), maybe_reborrowed)?;
 
-    let refed = Canonical {
-        value: TyKind::Ref(Mutability::Not, error_lifetime(), receiver_ty.value.clone())
-            .intern(Interner),
-        binders: receiver_ty.binders.clone(),
+    let refed = crate::next_solver::Canonical {
+        max_universe: receiver_ty.max_universe,
+        variables: receiver_ty.variables,
+        value: crate::next_solver::Ty::new_ref(interner, crate::next_solver::Region::error(interner), receiver_ty.value, rustc_ast_ir::Mutability::Not),
     };
 
     iterate_method_candidates_by_receiver(
@@ -1185,10 +1179,10 @@ fn iterate_method_candidates_with_autoref(
         first_adjustment.with_autoref(AutorefOrPtrAdjustment::Autoref(Mutability::Not)),
     )?;
 
-    let ref_muted = Canonical {
-        value: TyKind::Ref(Mutability::Mut, error_lifetime(), receiver_ty.value.clone())
-            .intern(Interner),
-        binders: receiver_ty.binders.clone(),
+    let ref_muted = crate::next_solver::Canonical {
+        max_universe: receiver_ty.max_universe,
+        variables: receiver_ty.variables,
+        value: crate::next_solver::Ty::new_ref(interner, crate::next_solver::Region::error(interner), receiver_ty.value, rustc_ast_ir::Mutability::Mut),
     };
 
     iterate_method_candidates_by_receiver(
@@ -1196,10 +1190,11 @@ fn iterate_method_candidates_with_autoref(
         first_adjustment.with_autoref(AutorefOrPtrAdjustment::Autoref(Mutability::Mut)),
     )?;
 
-    if let Some((ty, Mutability::Mut)) = receiver_ty.value.as_raw_ptr() {
-        let const_ptr_ty = Canonical {
-            value: TyKind::Raw(Mutability::Not, ty.clone()).intern(Interner),
-            binders: receiver_ty.binders,
+    if let rustc_type_ir::TyKind::RawPtr(ty, rustc_ast_ir::Mutability::Mut) = receiver_ty.value.kind() {
+        let const_ptr_ty = rustc_type_ir::Canonical {
+            max_universe: rustc_type_ir::UniverseIndex::ZERO,
+            value: crate::next_solver::Ty::new_ptr(interner, ty, rustc_ast_ir::Mutability::Not),
+            variables: receiver_ty.variables,
         };
         iterate_method_candidates_by_receiver(
             const_ptr_ty,
@@ -1250,16 +1245,17 @@ where
 }
 
 #[tracing::instrument(skip_all, fields(name = ?name))]
-fn iterate_method_candidates_by_receiver(
-    table: &mut InferenceTable<'_>,
-    receiver_ty: Canonical<Ty>,
+fn iterate_method_candidates_by_receiver<'db>(
+    table: &mut InferenceTable<'db>,
+    receiver_ty: crate::next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
     receiver_adjustments: ReceiverAdjustments,
     traits_in_scope: &FxHashSet<TraitId>,
     visible_from_module: VisibleFromModule,
     name: Option<&Name>,
     callback: &mut dyn MethodCandidateCallback,
 ) -> ControlFlow<()> {
-    let receiver_ty = table.instantiate_canonical(receiver_ty);
+    let receiver_ty = table.instantiate_canonical_ns(receiver_ty);
+    let receiver_ty: crate::Ty = ChalkToNextSolver::from_nextsolver(receiver_ty, table.interner);
     // We're looking for methods with *receiver* type receiver_ty. These could
     // be found in any of the derefs of receiver_ty, so we have to go through
     // that, including raw derefs.
@@ -1307,9 +1303,9 @@ fn iterate_method_candidates_by_receiver(
 }
 
 #[tracing::instrument(skip_all, fields(name = ?name))]
-fn iterate_method_candidates_for_self_ty(
-    self_ty: &Canonical<Ty>,
-    db: &dyn HirDatabase,
+fn iterate_method_candidates_for_self_ty<'db>(
+    self_ty: &crate::next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
+    db: &'db dyn HirDatabase,
     env: Arc<TraitEnvironment>,
     traits_in_scope: &FxHashSet<TraitId>,
     visible_from_module: VisibleFromModule,
@@ -1317,7 +1313,7 @@ fn iterate_method_candidates_for_self_ty(
     callback: &mut dyn MethodCandidateCallback,
 ) -> ControlFlow<()> {
     let mut table = InferenceTable::new(db, env);
-    let self_ty = table.instantiate_canonical(self_ty.clone());
+    let self_ty = ChalkToNextSolver::from_nextsolver(table.instantiate_canonical_ns(self_ty.clone()), table.interner);
     iterate_inherent_methods(
         &self_ty,
         &mut table,
@@ -1354,7 +1350,7 @@ fn iterate_trait_method_candidates(
 ) -> ControlFlow<()> {
     let db = table.db;
 
-    let canonical_self_ty = table.canonicalize(self_ty.clone());
+    let canonical_self_ty = ChalkToNextSolver::from_nextsolver(table.canonicalize(self_ty.clone().to_nextsolver(table.interner)), table.interner);
     let TraitEnvironment { krate, block, .. } = *table.trait_env;
 
     'traits: for &t in traits_in_scope {
@@ -1583,13 +1579,14 @@ pub(crate) fn resolve_indexing_op(
 ) -> Option<ReceiverAdjustments> {
     let mut table = InferenceTable::new(db, env);
     let ty = table.instantiate_canonical(ty);
-    let deref_chain = autoderef_method_receiver(&mut table, ty);
+    let interner = table.interner;
+    let deref_chain = autoderef_method_receiver(&mut table, ty.to_nextsolver(interner));
     for (ty, adj) in deref_chain {
-        let goal = generic_implements_goal(db, &table.trait_env, index_trait, &ty);
-        if !db
-            .trait_solve(table.trait_env.krate, table.trait_env.block, goal.cast(Interner))
-            .no_solution()
-        {
+        //let goal = generic_implements_goal_ns(db, &table.trait_env, index_trait, &ty);
+        let goal = generic_implements_goal(db, &table.trait_env, index_trait, &ChalkToNextSolver::from_nextsolver(ty, interner));
+        let goal: chalk_ir::Canonical<chalk_ir::InEnvironment<chalk_ir::Goal<Interner>>> = goal.cast(Interner);
+        let goal = goal.to_nextsolver(interner);
+        if !next_trait_solve_canonical(db, table.trait_env.krate, table.trait_env.block, goal).no_solution() {
             return Some(adj);
         }
     }
@@ -1773,26 +1770,11 @@ fn is_valid_impl_fn_candidate(
         });
 
         for goal in goals.clone() {
-            let in_env = InEnvironment::new(&table.trait_env.env, goal);
-            let canonicalized = table.canonicalize_with_free_vars(in_env);
-            let solution = table.db.trait_solve(
-                table.trait_env.krate,
-                table.trait_env.block,
-                canonicalized.value.clone(),
-            );
-
-            match solution {
-                NextTraitSolveResult::Certain(canonical_subst) => {
-                    canonicalized.apply_solution(
-                        table,
-                        Canonical {
-                            binders: canonical_subst.binders,
-                            value: canonical_subst.value.subst,
-                        },
-                    );
+            match table.solve_obligation(goal) {
+                Ok(_) => {}
+                Err(_) => {
+                    return IsValidCandidate::No;
                 }
-                NextTraitSolveResult::Uncertain(..) => {}
-                NextTraitSolveResult::NoSolution => return IsValidCandidate::No,
             }
         }
 
@@ -1857,25 +1839,66 @@ fn generic_implements_goal(
     Canonical { binders, value }
 }
 
-fn autoderef_method_receiver(
-    table: &mut InferenceTable<'_>,
-    ty: Ty,
-) -> Vec<(Canonical<Ty>, ReceiverAdjustments)> {
-    let mut deref_chain: Vec<_> = Vec::new();
-    let mut autoderef = autoderef::Autoderef::new_no_tracking(table, ty, false, true);
+/*
+/// This creates Substs for a trait with the given Self type and type variables
+/// for all other parameters, to query the trait solver with it.
+#[tracing::instrument(skip_all)]
+fn generic_implements_goal_ns<'db>(
+    db: &'db dyn HirDatabase,
+    interner: DbInterner<'db>,
+    env: &TraitEnvironment,
+    trait_: TraitId,
+    self_ty: &crate::next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
+) -> crate::next_solver::Canonical<'db, crate::next_solver::Goal<'db, crate::next_solver::Predicate<'db>>> {
+    let variables = self_ty.variables;
+    let trait_ref = TyBuilder::trait_ref(db, trait_)
+        .push(ChalkToNextSolver::from_nextsolver(self_ty.value, interner))
+        .fill_with_bound_vars(DebruijnIndex::INNERMOST, variables.len())
+        .build();
+
+    let infer_ctxt = interner.infer_ctxt().build(TypingMode::non_body_analysis());
+    let args = infer_ctxt.fresh_args_for_item(SolverDefId::TraitId(trait_));
+
+    rustc_type_ir::TraitRef::new(interner, SolverDefId::TraitId(trait_)).with_self_ty(interner, self_ty.value);
+    
+
+    let kinds =
+        binders.iter().cloned().chain(trait_ref.substitution.iter(Interner).skip(1).map(|it| {
+            let vk = match it.data(Interner) {
+                GenericArgData::Ty(_) => VariableKind::Ty(chalk_ir::TyVariableKind::General),
+                GenericArgData::Lifetime(_) => VariableKind::Lifetime,
+                GenericArgData::Const(c) => VariableKind::Const(c.data(Interner).ty.clone()),
+            };
+            WithKind::new(vk, UniverseIndex::ROOT)
+        }));
+    let binders = CanonicalVarKinds::from_iter(Interner, kinds);
+
+    let obligation = trait_ref.cast(Interner);
+    let value = InEnvironment::new(&env.env, obligation);
+    crate::next_solver::Canonical { max_universe, value, variables }
+}
+*/
+
+fn autoderef_method_receiver<'db>(
+    table: &mut InferenceTable<'db>,
+    ty: crate::next_solver::Ty<'db>,
+) -> Vec<(crate::next_solver::Canonical<'db, crate::next_solver::Ty<'db>>, ReceiverAdjustments)> {
+    let interner = table.interner;
+    let mut deref_chain = Vec::new();
+    let mut autoderef = autoderef::Autoderef::new_no_tracking(table, ChalkToNextSolver::from_nextsolver(ty, interner), false, true);
     while let Some((ty, derefs)) = autoderef.next() {
         deref_chain.push((
-            autoderef.table.canonicalize(ty),
+            autoderef.table.canonicalize(ty.to_nextsolver(interner)),
             ReceiverAdjustments { autoref: None, autoderefs: derefs, unsize_array: false },
         ));
     }
     // As a last step, we can do array unsizing (that's the only unsizing that rustc does for method receivers!)
-    if let Some((TyKind::Array(parameters, _), binders, adj)) =
-        deref_chain.last().map(|(ty, adj)| (ty.value.kind(Interner), ty.binders.clone(), adj))
+    if let Some((rustc_type_ir::Array(parameters, _), variables, max_universe, adj)) =
+        deref_chain.last().map(|d| (d.0.value.kind(), d.0.variables.clone(), d.0.max_universe, d.1.clone()))
     {
-        let unsized_ty = TyKind::Slice(parameters.clone()).intern(Interner);
+        let unsized_ty = crate::next_solver::Ty::new_slice(interner, parameters);
         deref_chain.push((
-            Canonical { value: unsized_ty, binders },
+            crate::next_solver::Canonical { max_universe, value: unsized_ty, variables, },
             ReceiverAdjustments { unsize_array: true, ..adj.clone() },
         ));
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/canonicalizer.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/canonicalizer.rs
new file mode 100644
index 0000000000000..0820006e5dfb0
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/canonicalizer.rs
@@ -0,0 +1,785 @@
+
+use rustc_hash::FxHashMap;
+use rustc_index::Idx;
+use rustc_type_ir::inherent::{Const as _, IntoKind as _, Region as _, SliceLike, Ty as _};
+use rustc_type_ir::InferTy::{self, FloatVar, IntVar, TyVar};
+use rustc_type_ir::{BoundVar, CanonicalQueryInput, CanonicalTyVarKind, DebruijnIndex, Flags, InferConst, RegionKind, TypeFlags, TypeFoldable, TypeFolder, TypeSuperFoldable, TypeVisitableExt, UniverseIndex};
+use smallvec::SmallVec;
+use tracing::debug;
+
+use crate::next_solver::infer::InferCtxt;
+use crate::next_solver::{Binder, BoundRegion, BoundRegionKind, BoundTy, Canonical, CanonicalVarKind, CanonicalVars, Const, ConstKind, DbInterner, GenericArg, ParamEnvAnd, Placeholder, Region, Ty, TyKind};
+
+/// When we canonicalize a value to form a query, we wind up replacing
+/// various parts of it with canonical variables. This struct stores
+/// those replaced bits to remember for when we process the query
+/// result.
+#[derive(Clone, Debug)]
+pub struct OriginalQueryValues<'db> {
+    /// Map from the universes that appear in the query to the universes in the
+    /// caller context. For all queries except `evaluate_goal` (used by Chalk),
+    /// we only ever put ROOT values into the query, so this map is very
+    /// simple.
+    pub universe_map: SmallVec<[UniverseIndex; 4]>,
+
+    /// This is equivalent to `CanonicalVarValues`, but using a
+    /// `SmallVec` yields a significant performance win.
+    pub var_values: SmallVec<[GenericArg<'db>; 8]>,
+}
+
+impl<'db> Default for OriginalQueryValues<'db> {
+    fn default() -> Self {
+        let mut universe_map = SmallVec::default();
+        universe_map.push(UniverseIndex::ROOT);
+
+        Self { universe_map, var_values: SmallVec::default() }
+    }
+}
+
+impl<'db> InferCtxt<'db> {
+    /// Canonicalizes a query value `V`. When we canonicalize a query,
+    /// we not only canonicalize unbound inference variables, but we
+    /// *also* replace all free regions whatsoever. So for example a
+    /// query like `T: Trait<'static>` would be canonicalized to
+    ///
+    /// ```text
+    /// T: Trait<'?0>
+    /// ```
+    ///
+    /// with a mapping M that maps `'?0` to `'static`.
+    ///
+    /// To get a good understanding of what is happening here, check
+    /// out the [chapter in the rustc dev guide][c].
+    ///
+    /// [c]: https://rust-lang.github.io/chalk/book/canonical_queries/canonicalization.html#canonicalizing-the-query
+    pub fn canonicalize_query<V>(
+        &self,
+        value: ParamEnvAnd<'db, V>,
+        query_state: &mut OriginalQueryValues<'db>,
+    ) -> CanonicalQueryInput<DbInterner<'db>, ParamEnvAnd<'db, V>>
+    where
+        V: TypeFoldable<DbInterner<'db>>,
+    {
+        let (param_env, value) = value.into_parts();
+        // FIXME(#118965): We don't canonicalize the static lifetimes that appear in the
+        // `param_env` because they are treated differently by trait selection.
+        let canonical_param_env = Canonicalizer::canonicalize(
+            param_env,
+            None,
+            self.interner,
+            &CanonicalizeFreeRegionsOtherThanStatic,
+            query_state,
+        );
+
+        let canonical = Canonicalizer::canonicalize_with_base(
+            canonical_param_env,
+            value,
+            Some(self),
+            self.interner,
+            &CanonicalizeAllFreeRegions,
+            query_state,
+        )
+        .unchecked_map(|(param_env, value)| ParamEnvAnd { param_env, value });
+        CanonicalQueryInput { canonical, typing_mode: self.typing_mode() }
+    }
+
+    /// Canonicalizes a query *response* `V`. When we canonicalize a
+    /// query response, we only canonicalize unbound inference
+    /// variables, and we leave other free regions alone. So,
+    /// continuing with the example from `canonicalize_query`, if
+    /// there was an input query `T: Trait<'static>`, it would have
+    /// been canonicalized to
+    ///
+    /// ```text
+    /// T: Trait<'?0>
+    /// ```
+    ///
+    /// with a mapping M that maps `'?0` to `'static`. But if we found that there
+    /// exists only one possible impl of `Trait`, and it looks like
+    /// ```ignore (illustrative)
+    /// impl<T> Trait<'static> for T { .. }
+    /// ```
+    /// then we would prepare a query result R that (among other
+    /// things) includes a mapping to `'?0 := 'static`. When
+    /// canonicalizing this query result R, we would leave this
+    /// reference to `'static` alone.
+    ///
+    /// To get a good understanding of what is happening here, check
+    /// out the [chapter in the rustc dev guide][c].
+    ///
+    /// [c]: https://rust-lang.github.io/chalk/book/canonical_queries/canonicalization.html#canonicalizing-the-query-result
+    pub fn canonicalize_response<V>(&self, value: V) -> Canonical<'db, V>
+    where
+        V: TypeFoldable<DbInterner<'db>>,
+    {
+        let mut query_state = OriginalQueryValues::default();
+        Canonicalizer::canonicalize(
+            value,
+            Some(self),
+            self.interner,
+            &CanonicalizeQueryResponse,
+            &mut query_state,
+        )
+    }
+
+    pub fn canonicalize_user_type_annotation<V>(&self, value: V) -> Canonical<'db, V>
+    where
+        V: TypeFoldable<DbInterner<'db>>,
+    {
+        let mut query_state = OriginalQueryValues::default();
+        Canonicalizer::canonicalize(
+            value,
+            Some(self),
+            self.interner,
+            &CanonicalizeUserTypeAnnotation,
+            &mut query_state,
+        )
+    }
+}
+
+/// Controls how we canonicalize "free regions" that are not inference
+/// variables. This depends on what we are canonicalizing *for* --
+/// e.g., if we are canonicalizing to create a query, we want to
+/// replace those with inference variables, since we want to make a
+/// maximally general query. But if we are canonicalizing a *query
+/// response*, then we don't typically replace free regions, as they
+/// must have been introduced from other parts of the system.
+trait CanonicalizeMode {
+    fn canonicalize_free_region<'db>(
+        &self,
+        canonicalizer: &mut Canonicalizer<'_, 'db>,
+        r: Region<'db>,
+    ) -> Region<'db>;
+
+    fn any(&self) -> bool;
+
+    // Do we preserve universe of variables.
+    fn preserve_universes(&self) -> bool;
+}
+
+struct CanonicalizeQueryResponse;
+
+impl CanonicalizeMode for CanonicalizeQueryResponse {
+    fn canonicalize_free_region<'db>(
+        &self,
+        canonicalizer: &mut Canonicalizer<'_, 'db>,
+        mut r: Region<'db>,
+    ) -> Region<'db> {
+        let infcx = canonicalizer.infcx.unwrap();
+
+        if let RegionKind::ReVar(vid) = r.kind() {
+            r = infcx
+                .inner
+                .borrow_mut()
+                .unwrap_region_constraints()
+                .opportunistic_resolve_var(canonicalizer.tcx, vid);
+            debug!(
+                "canonical: region var found with vid {vid:?}, \
+                     opportunistically resolved to {r:?}",
+            );
+        };
+
+        match r.kind() {
+            RegionKind::ReLateParam(_) | RegionKind::ReErased | RegionKind::ReStatic | RegionKind::ReEarlyParam(..) | RegionKind::ReError(..) => r,
+
+            RegionKind::RePlaceholder(placeholder) => canonicalizer.canonical_var_for_region(
+                CanonicalVarKind::PlaceholderRegion(placeholder),
+                r,
+            ),
+
+            RegionKind::ReVar(vid) => {
+                let universe = infcx
+                    .inner
+                    .borrow_mut()
+                    .unwrap_region_constraints()
+                    .probe_value(vid)
+                    .unwrap_err();
+                canonicalizer.canonical_var_for_region(
+                    CanonicalVarKind::Region(universe),
+                    r,
+                )
+            }
+
+            _ => {
+                // Other than `'static` or `'empty`, the query
+                // response should be executing in a fully
+                // canonicalized environment, so there shouldn't be
+                // any other region names it can come up.
+                //
+                // rust-lang/rust#57464: `impl Trait` can leak local
+                // scopes (in manner violating typeck). Therefore, use
+                // `delayed_bug` to allow type error over an ICE.
+                panic!("unexpected region in query response: `{r:?}`");
+            }
+        }
+    }
+
+    fn any(&self) -> bool {
+        false
+    }
+
+    fn preserve_universes(&self) -> bool {
+        true
+    }
+}
+
+struct CanonicalizeUserTypeAnnotation;
+
+impl CanonicalizeMode for CanonicalizeUserTypeAnnotation {
+    fn canonicalize_free_region<'db>(
+        &self,
+        canonicalizer: &mut Canonicalizer<'_, 'db>,
+        r: Region<'db>,
+    ) -> Region<'db> {
+        match r.kind() {
+            RegionKind::ReEarlyParam(_)
+            | RegionKind::ReLateParam(_)
+            | RegionKind::ReErased
+            | RegionKind::ReStatic
+            | RegionKind::ReError(_) => r,
+            RegionKind::ReVar(_) => canonicalizer.canonical_var_for_region_in_root_universe(r),
+            RegionKind::RePlaceholder(..) | RegionKind::ReBound(..) => {
+                // We only expect region names that the user can type.
+                panic!("unexpected region in query response: `{:?}`", r)
+            }
+        }
+    }
+
+    fn any(&self) -> bool {
+        false
+    }
+
+    fn preserve_universes(&self) -> bool {
+        false
+    }
+}
+
+struct CanonicalizeAllFreeRegions;
+
+impl CanonicalizeMode for CanonicalizeAllFreeRegions {
+    fn canonicalize_free_region<'db>(
+        &self,
+        canonicalizer: &mut Canonicalizer<'_, 'db>,
+        r: Region<'db>,
+    ) -> Region<'db> {
+        canonicalizer.canonical_var_for_region_in_root_universe(r)
+    }
+
+    fn any(&self) -> bool {
+        true
+    }
+
+    fn preserve_universes(&self) -> bool {
+        false
+    }
+}
+
+struct CanonicalizeFreeRegionsOtherThanStatic;
+
+impl CanonicalizeMode for CanonicalizeFreeRegionsOtherThanStatic {
+    fn canonicalize_free_region<'db>(
+        &self,
+        canonicalizer: &mut Canonicalizer<'_, 'db>,
+        r: Region<'db>,
+    ) -> Region<'db> {
+        if r.is_static() { r } else { canonicalizer.canonical_var_for_region_in_root_universe(r) }
+    }
+
+    fn any(&self) -> bool {
+        true
+    }
+
+    fn preserve_universes(&self) -> bool {
+        false
+    }
+}
+
+struct Canonicalizer<'cx, 'db> {
+    /// Set to `None` to disable the resolution of inference variables.
+    infcx: Option<&'cx InferCtxt<'db>>,
+    tcx: DbInterner<'db>,
+    variables: SmallVec<[CanonicalVarKind<'db>; 8]>,
+    query_state: &'cx mut OriginalQueryValues<'db>,
+    // Note that indices is only used once `var_values` is big enough to be
+    // heap-allocated.
+    indices: FxHashMap<GenericArg<'db>, BoundVar>,
+    canonicalize_mode: &'cx dyn CanonicalizeMode,
+    needs_canonical_flags: TypeFlags,
+
+    binder_index: DebruijnIndex,
+}
+
+impl<'cx, 'db> TypeFolder<DbInterner<'db>> for Canonicalizer<'cx, 'db> {
+    fn cx(&self) -> DbInterner<'db> {
+        self.tcx
+    }
+
+    fn fold_binder<T>(&mut self, t: Binder<'db, T>) -> Binder<'db, T>
+    where
+        T: TypeFoldable<DbInterner<'db>>,
+    {
+        self.binder_index.shift_in(1);
+        let t = t.super_fold_with(self);
+        self.binder_index.shift_out(1);
+        t
+    }
+
+    fn fold_region(&mut self, r: Region<'db>) -> Region<'db> {
+        match r.kind() {
+            RegionKind::ReBound(index, ..) => {
+                if index >= self.binder_index {
+                    panic!("escaping late-bound region during canonicalization");
+                } else {
+                    r
+                }
+            }
+
+            RegionKind::ReStatic
+            | RegionKind::ReEarlyParam(..)
+            | RegionKind::ReError(_)
+            | RegionKind::ReLateParam(_)
+            | RegionKind::RePlaceholder(..)
+            | RegionKind::ReVar(_)
+            | RegionKind::ReErased => self.canonicalize_mode.canonicalize_free_region(self, r),
+        }
+    }
+
+    fn fold_ty(&mut self, mut t: Ty<'db>) -> Ty<'db> {
+        match t.kind() {
+            TyKind::Infer(TyVar(mut vid)) => {
+                // We need to canonicalize the *root* of our ty var.
+                // This is so that our canonical response correctly reflects
+                // any equated inference vars correctly!
+                let root_vid = self.infcx.unwrap().root_var(vid);
+                if root_vid != vid {
+                    t = Ty::new_var(self.tcx, root_vid);
+                    vid = root_vid;
+                }
+
+                debug!("canonical: type var found with vid {:?}", vid);
+                match self.infcx.unwrap().probe_ty_var(vid) {
+                    // `t` could be a float / int variable; canonicalize that instead.
+                    Ok(t) => {
+                        debug!("(resolved to {:?})", t);
+                        self.fold_ty(t)
+                    }
+
+                    // `TyVar(vid)` is unresolved, track its universe index in the canonicalized
+                    // result.
+                    Err(mut ui) => {
+                        if !self.canonicalize_mode.preserve_universes() {
+                            // FIXME: perf problem described in #55921.
+                            ui = UniverseIndex::ROOT;
+                        }
+                        self.canonicalize_ty_var(
+                            CanonicalVarKind::Ty(CanonicalTyVarKind::General(ui)),
+                            t,
+                        )
+                    }
+                }
+            }
+
+            TyKind::Infer(IntVar(vid)) => {
+                let nt = self.infcx.unwrap().opportunistic_resolve_int_var(vid);
+                if nt != t {
+                    return self.fold_ty(nt);
+                } else {
+                    self.canonicalize_ty_var(
+                        CanonicalVarKind::Ty(CanonicalTyVarKind::Int),
+                        t,
+                    )
+                }
+            }
+            TyKind::Infer(FloatVar(vid)) => {
+                let nt = self.infcx.unwrap().opportunistic_resolve_float_var(vid);
+                if nt != t {
+                    return self.fold_ty(nt);
+                } else {
+                    self.canonicalize_ty_var(
+                        CanonicalVarKind::Ty(CanonicalTyVarKind::Float),
+                        t,
+                    )
+                }
+            }
+
+            TyKind::Infer(InferTy::FreshTy(_) | InferTy::FreshIntTy(_) | InferTy::FreshFloatTy(_)) => {
+                panic!("encountered a fresh type during canonicalization")
+            }
+
+            TyKind::Placeholder(mut placeholder) => {
+                if !self.canonicalize_mode.preserve_universes() {
+                    placeholder.universe = UniverseIndex::ROOT;
+                }
+                self.canonicalize_ty_var(
+                    CanonicalVarKind::PlaceholderTy(placeholder),
+                    t,
+                )
+            }
+
+            TyKind::Bound(debruijn, _) => {
+                if debruijn >= self.binder_index {
+                    panic!("escaping bound type during canonicalization")
+                } else {
+                    t
+                }
+            }
+
+            TyKind::Closure(..)
+            | TyKind::CoroutineClosure(..)
+            | TyKind::Coroutine(..)
+            | TyKind::CoroutineWitness(..)
+            | TyKind::Bool
+            | TyKind::Char
+            | TyKind::Int(..)
+            | TyKind::Uint(..)
+            | TyKind::Float(..)
+            | TyKind::Adt(..)
+            | TyKind::Str
+            | TyKind::Error(_)
+            | TyKind::Array(..)
+            | TyKind::Slice(..)
+            | TyKind::RawPtr(..)
+            | TyKind::Ref(..)
+            | TyKind::FnDef(..)
+            | TyKind::FnPtr(..)
+            | TyKind::Dynamic(..)
+            | TyKind::UnsafeBinder(_)
+            | TyKind::Never
+            | TyKind::Tuple(..)
+            | TyKind::Alias(..)
+            | TyKind::Foreign(..)
+            | TyKind::Pat(..)
+            | TyKind::Param(..) => {
+                if t.flags().intersects(self.needs_canonical_flags) {
+                    t.super_fold_with(self)
+                } else {
+                    t
+                }
+            }
+        }
+    }
+
+    fn fold_const(&mut self, mut ct: Const<'db>) -> Const<'db> {
+        match ct.kind() {
+            ConstKind::Infer(InferConst::Var(mut vid)) => {
+                // We need to canonicalize the *root* of our const var.
+                // This is so that our canonical response correctly reflects
+                // any equated inference vars correctly!
+                let root_vid = self.infcx.unwrap().root_const_var(vid);
+                if root_vid != vid {
+                    ct = Const::new_var(self.tcx, root_vid);
+                    vid = root_vid;
+                }
+
+                debug!("canonical: const var found with vid {:?}", vid);
+                match self.infcx.unwrap().probe_const_var(vid) {
+                    Ok(c) => {
+                        debug!("(resolved to {:?})", c);
+                        return self.fold_const(c);
+                    }
+
+                    // `ConstVar(vid)` is unresolved, track its universe index in the
+                    // canonicalized result
+                    Err(mut ui) => {
+                        if !self.canonicalize_mode.preserve_universes() {
+                            // FIXME: perf problem described in #55921.
+                            ui = UniverseIndex::ROOT;
+                        }
+                        return self.canonicalize_const_var(
+                            CanonicalVarKind::Const(ui),
+                            ct,
+                        );
+                    }
+                }
+            }
+            ConstKind::Infer(InferConst::Fresh(_)) => {
+                panic!("encountered a fresh const during canonicalization")
+            }
+            ConstKind::Bound(debruijn, _) => {
+                if debruijn >= self.binder_index {
+                    panic!("escaping bound const during canonicalization")
+                } else {
+                    return ct;
+                }
+            }
+            ConstKind::Placeholder(placeholder) => {
+                return self.canonicalize_const_var(
+                    CanonicalVarKind::PlaceholderConst(placeholder),
+                    ct,
+                );
+            }
+            _ => {}
+        }
+
+        if ct.flags().intersects(self.needs_canonical_flags) {
+            ct.super_fold_with(self)
+        } else {
+            ct
+        }
+    }
+}
+
+impl<'cx, 'db> Canonicalizer<'cx, 'db> {
+    /// The main `canonicalize` method, shared impl of
+    /// `canonicalize_query` and `canonicalize_response`.
+    fn canonicalize<V>(
+        value: V,
+        infcx: Option<&InferCtxt<'db>>,
+        tcx: DbInterner<'db>,
+        canonicalize_region_mode: &dyn CanonicalizeMode,
+        query_state: &mut OriginalQueryValues<'db>,
+    ) -> Canonical<'db, V>
+    where
+        V: TypeFoldable<DbInterner<'db>>,
+    {
+        let base = Canonical {
+            max_universe: UniverseIndex::ROOT,
+            variables: CanonicalVars::new_from_iter(tcx, []),
+            value: (),
+        };
+        Canonicalizer::canonicalize_with_base(
+            base,
+            value,
+            infcx,
+            tcx,
+            canonicalize_region_mode,
+            query_state,
+        )
+        .unchecked_map(|((), val)| val)
+    }
+
+    fn canonicalize_with_base<U, V>(
+        base: Canonical<'db, U>,
+        value: V,
+        infcx: Option<&InferCtxt<'db>>,
+        tcx: DbInterner<'db>,
+        canonicalize_region_mode: &dyn CanonicalizeMode,
+        query_state: &mut OriginalQueryValues<'db>,
+    ) -> Canonical<'db, (U, V)>
+    where
+        V: TypeFoldable<DbInterner<'db>>,
+    {
+        let needs_canonical_flags = if canonicalize_region_mode.any() {
+            TypeFlags::HAS_INFER | TypeFlags::HAS_PLACEHOLDER | TypeFlags::HAS_FREE_REGIONS
+        } else {
+            TypeFlags::HAS_INFER | TypeFlags::HAS_PLACEHOLDER
+        };
+
+        // Fast path: nothing that needs to be canonicalized.
+        if !value.has_type_flags(needs_canonical_flags) {
+            return base.unchecked_map(|b| (b, value));
+        }
+
+        let mut canonicalizer = Canonicalizer {
+            infcx,
+            tcx,
+            canonicalize_mode: canonicalize_region_mode,
+            needs_canonical_flags,
+            variables: SmallVec::from_slice(base.variables.as_slice()),
+            query_state,
+            indices: FxHashMap::default(),
+            binder_index: DebruijnIndex::ZERO,
+        };
+        if canonicalizer.query_state.var_values.spilled() {
+            canonicalizer.indices = canonicalizer
+                .query_state
+                .var_values
+                .iter()
+                .enumerate()
+                .map(|(i, &kind)| (kind, BoundVar::from(i)))
+                .collect();
+        }
+        let out_value = value.fold_with(&mut canonicalizer);
+
+        // Once we have canonicalized `out_value`, it should not
+        // contain anything that ties it to this inference context
+        // anymore.
+        debug_assert!(!out_value.has_infer() && !out_value.has_placeholders());
+
+        let canonical_variables = CanonicalVars::new_from_iter(tcx, canonicalizer.universe_canonicalized_variables());
+
+        let max_universe = canonical_variables
+            .iter()
+            .map(|cvar| cvar.universe())
+            .max()
+            .unwrap_or(UniverseIndex::ROOT);
+
+        Canonical { max_universe, variables: canonical_variables, value: (base.value, out_value) }
+    }
+
+    /// Creates a canonical variable replacing `kind` from the input,
+    /// or returns an existing variable if `kind` has already been
+    /// seen. `kind` is expected to be an unbound variable (or
+    /// potentially a free region).
+    fn canonical_var(&mut self, info: CanonicalVarKind<'db>, kind: GenericArg<'db>) -> BoundVar {
+        let Canonicalizer { variables, query_state, indices, .. } = self;
+
+        let var_values = &mut query_state.var_values;
+
+        let universe = info.universe();
+        if universe != UniverseIndex::ROOT {
+            assert!(self.canonicalize_mode.preserve_universes());
+
+            // Insert universe into the universe map. To preserve the order of the
+            // universes in the value being canonicalized, we don't update the
+            // universe in `info` until we have finished canonicalizing.
+            match query_state.universe_map.binary_search(&universe) {
+                Err(idx) => query_state.universe_map.insert(idx, universe),
+                Ok(_) => {}
+            }
+        }
+
+        // This code is hot. `variables` and `var_values` are usually small
+        // (fewer than 8 elements ~95% of the time). They are SmallVec's to
+        // avoid allocations in those cases. We also don't use `indices` to
+        // determine if a kind has been seen before until the limit of 8 has
+        // been exceeded, to also avoid allocations for `indices`.
+        if !var_values.spilled() {
+            // `var_values` is stack-allocated. `indices` isn't used yet. Do a
+            // direct linear search of `var_values`.
+            if let Some(idx) = var_values.iter().position(|&k| k == kind) {
+                // `kind` is already present in `var_values`.
+                BoundVar::new(idx)
+            } else {
+                // `kind` isn't present in `var_values`. Append it. Likewise
+                // for `info` and `variables`.
+                variables.push(info);
+                var_values.push(kind);
+                assert_eq!(variables.len(), var_values.len());
+
+                // If `var_values` has become big enough to be heap-allocated,
+                // fill up `indices` to facilitate subsequent lookups.
+                if var_values.spilled() {
+                    assert!(indices.is_empty());
+                    *indices = var_values
+                        .iter()
+                        .enumerate()
+                        .map(|(i, &kind)| (kind, BoundVar::new(i)))
+                        .collect();
+                }
+                // The cv is the index of the appended element.
+                BoundVar::new(var_values.len() - 1)
+            }
+        } else {
+            // `var_values` is large. Do a hashmap search via `indices`.
+            *indices.entry(kind).or_insert_with(|| {
+                variables.push(info);
+                var_values.push(kind);
+                assert_eq!(variables.len(), var_values.len());
+                BoundVar::new(variables.len() - 1)
+            })
+        }
+    }
+
+    /// Replaces the universe indexes used in `var_values` with their index in
+    /// `query_state.universe_map`. This minimizes the maximum universe used in
+    /// the canonicalized value.
+    fn universe_canonicalized_variables(self) -> SmallVec<[CanonicalVarKind<'db>; 8]> {
+        if self.query_state.universe_map.len() == 1 {
+            return self.variables;
+        }
+
+        let reverse_universe_map: FxHashMap<UniverseIndex, UniverseIndex> = self
+            .query_state
+            .universe_map
+            .iter()
+            .enumerate()
+            .map(|(idx, universe)| (*universe, UniverseIndex::from_usize(idx)))
+            .collect();
+
+        self.variables
+            .iter()
+            .map(|v| match *v {
+                CanonicalVarKind::Ty(CanonicalTyVarKind::Int | CanonicalTyVarKind::Float) => {
+                    return *v;
+                }
+                CanonicalVarKind::Ty(CanonicalTyVarKind::General(u)) => {
+                    CanonicalVarKind::Ty(CanonicalTyVarKind::General(reverse_universe_map[&u]))
+                }
+                CanonicalVarKind::Region(u) => {
+                    CanonicalVarKind::Region(reverse_universe_map[&u])
+                }
+                CanonicalVarKind::Const(u) => CanonicalVarKind::Const(reverse_universe_map[&u]),
+                CanonicalVarKind::PlaceholderTy(placeholder) => {
+                    CanonicalVarKind::PlaceholderTy(Placeholder {
+                        universe: reverse_universe_map[&placeholder.universe],
+                        ..placeholder
+                    })
+                }
+                CanonicalVarKind::PlaceholderRegion(placeholder) => {
+                    CanonicalVarKind::PlaceholderRegion(Placeholder {
+                        universe: reverse_universe_map[&placeholder.universe],
+                        ..placeholder
+                    })
+                }
+                CanonicalVarKind::PlaceholderConst(placeholder) => {
+                    CanonicalVarKind::PlaceholderConst(Placeholder {
+                        universe: reverse_universe_map[&placeholder.universe],
+                        ..placeholder
+                    })
+                }
+            })
+            .collect()
+    }
+
+    /// Shorthand helper that creates a canonical region variable for
+    /// `r` (always in the root universe). The reason that we always
+    /// put these variables into the root universe is because this
+    /// method is used during **query construction:** in that case, we
+    /// are taking all the regions and just putting them into the most
+    /// generic context we can. This may generate solutions that don't
+    /// fit (e.g., that equate some region variable with a placeholder
+    /// it can't name) on the caller side, but that's ok, the caller
+    /// can figure that out. In the meantime, it maximizes our
+    /// caching.
+    ///
+    /// (This works because unification never fails -- and hence trait
+    /// selection is never affected -- due to a universe mismatch.)
+    fn canonical_var_for_region_in_root_universe(
+        &mut self,
+        r: Region<'db>,
+    ) -> Region<'db> {
+        self.canonical_var_for_region(
+            CanonicalVarKind::Region(UniverseIndex::ROOT),
+            r,
+        )
+    }
+
+    /// Creates a canonical variable (with the given `info`)
+    /// representing the region `r`; return a region referencing it.
+    fn canonical_var_for_region(
+        &mut self,
+        info: CanonicalVarKind<'db>,
+        r: Region<'db>,
+    ) -> Region<'db> {
+        let var = self.canonical_var(info, r.into());
+        let br = BoundRegion { var, kind: BoundRegionKind::Anon };
+        Region::new_bound(self.cx(), self.binder_index, br)
+    }
+
+    /// Given a type variable `ty_var` of the given kind, first check
+    /// if `ty_var` is bound to anything; if so, canonicalize
+    /// *that*. Otherwise, create a new canonical variable for
+    /// `ty_var`.
+    fn canonicalize_ty_var(&mut self, info: CanonicalVarKind<'db>, ty_var: Ty<'db>) -> Ty<'db> {
+        debug_assert!(!self.infcx.is_some_and(|infcx| ty_var != infcx.shallow_resolve(ty_var)));
+        let var = self.canonical_var(info, ty_var.into());
+        Ty::new_bound(self.tcx, self.binder_index, BoundTy { kind: crate::next_solver::BoundTyKind::Anon, var })
+    }
+
+    /// Given a type variable `const_var` of the given kind, first check
+    /// if `const_var` is bound to anything; if so, canonicalize
+    /// *that*. Otherwise, create a new canonical variable for
+    /// `const_var`.
+    fn canonicalize_const_var(
+        &mut self,
+        info: CanonicalVarKind<'db>,
+        const_var: Const<'db>,
+    ) -> Const<'db> {
+        debug_assert!(
+            !self.infcx.is_some_and(|infcx| const_var != infcx.shallow_resolve_const(const_var))
+        );
+        let var = self.canonical_var(info, const_var.into());
+        Const::new_bound(self.tcx, self.binder_index, var)
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/mod.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/mod.rs
index 4457e1340d584..ec41111ed8153 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/mod.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/mod.rs
@@ -42,6 +42,7 @@ use rustc_type_ir::{
     },
 };
 
+pub mod canonicalizer;
 pub mod instantiate;
 
 impl<'db> InferCtxt<'db> {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs
index 585719144ef42..894c91e0f49db 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs
@@ -190,12 +190,13 @@ impl<'db> InferCtxtInner<'db> {
     }
 
     #[inline]
-    fn int_unification_table(&mut self) -> UnificationTable<'_, 'db, IntVid> {
+    pub(crate) fn int_unification_table(&mut self) -> UnificationTable<'_, 'db, IntVid> {
+        tracing::debug!(?self.int_unification_storage);
         self.int_unification_storage.with_log(&mut self.undo_log)
     }
 
     #[inline]
-    fn float_unification_table(&mut self) -> UnificationTable<'_, 'db, FloatVid> {
+    pub(crate) fn float_unification_table(&mut self) -> UnificationTable<'_, 'db, FloatVid> {
         self.float_unification_storage.with_log(&mut self.undo_log)
     }
 
@@ -213,6 +214,7 @@ impl<'db> InferCtxtInner<'db> {
     }
 }
 
+#[derive(Clone)]
 pub struct InferCtxt<'db> {
     pub interner: DbInterner<'db>,
 
@@ -500,6 +502,10 @@ impl<'db> InferCtxt<'db> {
         self.next_ty_var_with_origin(TypeVariableOrigin { param_def_id: None })
     }
 
+    pub fn next_ty_vid(&self) -> TyVid {
+        self.inner.borrow_mut().type_variables().new_var(self.universe(), TypeVariableOrigin { param_def_id: None })
+    }
+
     pub fn next_ty_var_with_origin(&self, origin: TypeVariableOrigin) -> Ty<'db> {
         let vid = self.inner.borrow_mut().type_variables().new_var(self.universe(), origin);
         Ty::new_var(self.interner, vid)
@@ -519,6 +525,15 @@ impl<'db> InferCtxt<'db> {
         self.next_const_var_with_origin(ConstVariableOrigin { param_def_id: None })
     }
 
+    pub fn next_const_vid(&self) -> ConstVid {
+        self
+            .inner
+            .borrow_mut()
+            .const_unification_table()
+            .new_key(ConstVariableValue::Unknown { origin: ConstVariableOrigin { param_def_id: None }, universe: self.universe() })
+            .vid
+    }
+
     pub fn next_const_var_with_origin(&self, origin: ConstVariableOrigin) -> Const<'db> {
         let vid = self
             .inner
@@ -546,12 +561,20 @@ impl<'db> InferCtxt<'db> {
         Ty::new_int_var(self.interner, next_int_var_id)
     }
 
+    pub fn next_int_vid(&self) -> IntVid {
+        self.inner.borrow_mut().int_unification_table().new_key(IntVarValue::Unknown)
+    }
+
     pub fn next_float_var(&self) -> Ty<'db> {
         let next_float_var_id =
             self.inner.borrow_mut().float_unification_table().new_key(FloatVarValue::Unknown);
         Ty::new_float_var(self.interner, next_float_var_id)
     }
 
+    pub fn next_float_vid(&self) -> FloatVid {
+        self.inner.borrow_mut().float_unification_table().new_key(FloatVarValue::Unknown)
+    }
+
     /// Creates a fresh region variable with the next available index.
     /// The variable will be created in the maximum universe created
     /// thus far, allowing it to name any region created thus far.
@@ -559,6 +582,10 @@ impl<'db> InferCtxt<'db> {
         self.next_region_var_in_universe(self.universe())
     }
 
+    pub fn next_region_vid(&self) -> RegionVid {
+        self.inner.borrow_mut().unwrap_region_constraints().new_region_var(self.universe())
+    }
+
     /// Creates a fresh region variable with the next available index
     /// in the given universe; typically, you can use
     /// `next_region_var` and just use the maximal universe.
@@ -782,6 +809,18 @@ impl<'db> InferCtxt<'db> {
         }
     }
 
+    pub fn resolve_int_var(&self, vid: IntVid) -> Option<Ty<'db>> {
+        let mut inner = self.inner.borrow_mut();
+        let value = inner.int_unification_table().probe_value(vid);
+        match value {
+            IntVarValue::IntType(ty) => Some(Ty::new_int(self.interner, ty)),
+            IntVarValue::UintType(ty) => Some(Ty::new_uint(self.interner, ty)),
+            IntVarValue::Unknown => {
+                None
+            }
+        }
+    }
+
     /// Resolves a float var to a rigid int type, if it was constrained to one,
     /// or else the root float var in the unification table.
     pub fn opportunistic_resolve_float_var(&self, vid: FloatVid) -> Ty<'db> {
@@ -795,6 +834,17 @@ impl<'db> InferCtxt<'db> {
         }
     }
 
+    pub fn resolve_float_var(&self, vid: FloatVid) -> Option<Ty<'db>> {
+        let mut inner = self.inner.borrow_mut();
+        let value = inner.float_unification_table().probe_value(vid);
+        match value {
+            FloatVarValue::Known(ty) => Some(Ty::new_float(self.interner, ty)),
+            FloatVarValue::Unknown => {
+                None
+            }
+        }
+    }
+
     /// Where possible, replaces type/const variables in
     /// `value` with their final value. Note that region variables
     /// are unaffected. If a type/const variable has not been unified, it
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/snapshot/mod.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/snapshot/mod.rs
index eb426205575ad..8c7dfb25e07f9 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/snapshot/mod.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/snapshot/mod.rs
@@ -46,7 +46,7 @@ impl<'db> InferCtxt<'db> {
         UndoLogs::<UndoLog<'db>>::num_open_snapshots(&self.inner.borrow_mut().undo_log)
     }
 
-    fn start_snapshot(&self) -> CombinedSnapshot {
+    pub(crate) fn start_snapshot(&self) -> CombinedSnapshot {
         debug!("start_snapshot()");
 
         let mut inner = self.inner.borrow_mut();
@@ -59,7 +59,7 @@ impl<'db> InferCtxt<'db> {
     }
 
     #[instrument(skip(self, snapshot), level = "debug")]
-    fn rollback_to(&self, snapshot: CombinedSnapshot) {
+    pub(crate) fn rollback_to(&self, snapshot: CombinedSnapshot) {
         let CombinedSnapshot { undo_snapshot, region_constraints_snapshot, universe } = snapshot;
 
         self.universe.set(universe);
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
index dc54ee7d58785..79c402ff29c3d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
@@ -2,8 +2,8 @@
 
 use base_db::Crate;
 use chalk_ir::{
-    CanonicalVarKind, CanonicalVarKinds, ForeignDefId, InferenceVar, Substitution, TyVariableKind,
-    WellFormed, fold::Shift, interner::HasInterner,
+    CanonicalVarKind, CanonicalVarKinds, FnPointer, InferenceVar, Substitution, TyVariableKind,
+    WellFormed, cast::Cast, fold::Shift, interner::HasInterner,
 };
 use hir_def::{
     CallableDefId, ConstParamId, FunctionId, GeneralConstId, LifetimeParamId, TypeAliasId,
@@ -24,12 +24,12 @@ use salsa::{Id, plumbing::AsId};
 
 use crate::next_solver::BoundConst;
 use crate::{
-    ConcreteConst, ConstScalar, ImplTraitId, Interner, MemoryMap,
+    ConstScalar, ImplTraitId, Interner, MemoryMap,
     db::{
         HirDatabase, InternedClosureId, InternedCoroutineId, InternedLifetimeParamId,
         InternedOpaqueTyId, InternedTypeOrConstParamId,
     },
-    from_assoc_type_id, from_chalk_trait_id,
+    from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id,
     mapping::ToChalk,
     next_solver::{
         Binder, ClauseKind, ConstBytes, TraitPredicate, UnevaluatedConst,
@@ -141,6 +141,7 @@ impl<'db> rustc_type_ir::TypeFolder<DbInterner<'db>> for BinderToEarlyBinder<'db
 
 pub trait ChalkToNextSolver<'db, Out> {
     fn to_nextsolver(&self, interner: DbInterner<'db>) -> Out;
+    fn from_nextsolver(out: Out, interner: DbInterner<'db>) -> Self;
 }
 
 impl<'db> ChalkToNextSolver<'db, Ty<'db>> for chalk_ir::Ty<Interner> {
@@ -427,6 +428,343 @@ impl<'db> ChalkToNextSolver<'db, Ty<'db>> for chalk_ir::Ty<Interner> {
             },
         )
     }
+
+    fn from_nextsolver(out: Ty<'db>, interner: DbInterner<'db>) -> Self {
+        use crate::{Scalar, TyKind};
+        use chalk_ir::{FloatTy, IntTy, UintTy};
+        match out.kind() {
+            rustc_type_ir::TyKind::Bool => TyKind::Scalar(Scalar::Bool),
+            rustc_type_ir::TyKind::Char => TyKind::Scalar(Scalar::Char),
+            rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::I8) => {
+                TyKind::Scalar(Scalar::Int(IntTy::I8))
+            }
+            rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::I16) => {
+                TyKind::Scalar(Scalar::Int(IntTy::I16))
+            }
+            rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::I32) => {
+                TyKind::Scalar(Scalar::Int(IntTy::I32))
+            }
+            rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::I64) => {
+                TyKind::Scalar(Scalar::Int(IntTy::I64))
+            }
+            rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::I128) => {
+                TyKind::Scalar(Scalar::Int(IntTy::I128))
+            }
+            rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::Isize) => {
+                TyKind::Scalar(Scalar::Int(IntTy::Isize))
+            }
+            rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::U8) => {
+                TyKind::Scalar(Scalar::Uint(UintTy::U8))
+            }
+            rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::U16) => {
+                TyKind::Scalar(Scalar::Uint(UintTy::U16))
+            }
+            rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::U32) => {
+                TyKind::Scalar(Scalar::Uint(UintTy::U32))
+            }
+            rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::U64) => {
+                TyKind::Scalar(Scalar::Uint(UintTy::U64))
+            }
+            rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::U128) => {
+                TyKind::Scalar(Scalar::Uint(UintTy::U128))
+            }
+            rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::Usize) => {
+                TyKind::Scalar(Scalar::Uint(UintTy::Usize))
+            }
+            rustc_type_ir::TyKind::Float(rustc_type_ir::FloatTy::F16) => {
+                TyKind::Scalar(Scalar::Float(FloatTy::F16))
+            }
+            rustc_type_ir::TyKind::Float(rustc_type_ir::FloatTy::F32) => {
+                TyKind::Scalar(Scalar::Float(FloatTy::F32))
+            }
+            rustc_type_ir::TyKind::Float(rustc_type_ir::FloatTy::F64) => {
+                TyKind::Scalar(Scalar::Float(FloatTy::F64))
+            }
+            rustc_type_ir::TyKind::Float(rustc_type_ir::FloatTy::F128) => {
+                TyKind::Scalar(Scalar::Float(FloatTy::F128))
+            }
+            rustc_type_ir::TyKind::Str => TyKind::Str,
+            rustc_type_ir::TyKind::Error(_) => TyKind::Error,
+            rustc_type_ir::TyKind::Never => TyKind::Never,
+
+            rustc_type_ir::TyKind::Adt(def, args) => {
+                let adt_id = def.inner().id;
+                let subst = ChalkToNextSolver::from_nextsolver(args, interner);
+                TyKind::Adt(chalk_ir::AdtId(adt_id), subst)
+            }
+
+            rustc_type_ir::TyKind::Infer(infer_ty) => {
+                let (var, kind) = match infer_ty {
+                    rustc_type_ir::InferTy::TyVar(var) => {
+                        (InferenceVar::from(var.as_u32()), TyVariableKind::General)
+                    }
+                    rustc_type_ir::InferTy::IntVar(var) => {
+                        (InferenceVar::from(var.as_u32()), TyVariableKind::Integer)
+                    }
+                    rustc_type_ir::InferTy::FloatVar(var) => {
+                        (InferenceVar::from(var.as_u32()), TyVariableKind::Float)
+                    }
+                    _ => todo!(),
+                };
+                TyKind::InferenceVar(var, kind)
+            }
+
+            rustc_type_ir::TyKind::Ref(r, ty, mutability) => {
+                let mutability = match mutability {
+                    rustc_ast_ir::Mutability::Mut => chalk_ir::Mutability::Mut,
+                    rustc_ast_ir::Mutability::Not => chalk_ir::Mutability::Not,
+                };
+                let r = ChalkToNextSolver::from_nextsolver(r, interner);
+                let ty = ChalkToNextSolver::from_nextsolver(ty, interner);
+                TyKind::Ref(mutability, r, ty)
+            }
+
+            rustc_type_ir::TyKind::Tuple(tys) => {
+                let size = tys.len();
+                let subst = Substitution::from_iter(
+                    Interner,
+                    tys.iter().map(|ty| {
+                        chalk_ir::GenericArgData::Ty(ChalkToNextSolver::from_nextsolver(
+                            ty, interner,
+                        ))
+                        .intern(Interner)
+                    }),
+                );
+                TyKind::Tuple(size, subst)
+            }
+
+            rustc_type_ir::TyKind::Array(ty, const_) => {
+                let ty = ChalkToNextSolver::from_nextsolver(ty, interner);
+                let const_ = ChalkToNextSolver::from_nextsolver(const_, interner);
+                TyKind::Array(ty, const_)
+            }
+
+            rustc_type_ir::TyKind::Alias(alias_ty_kind, alias_ty) => match alias_ty_kind {
+                rustc_type_ir::AliasTyKind::Projection => {
+                    let assoc_ty_id = match alias_ty.def_id {
+                        SolverDefId::TypeAliasId(id) => id,
+                        _ => unreachable!(),
+                    };
+                    let associated_ty_id = to_assoc_type_id(assoc_ty_id);
+                    let substitution = ChalkToNextSolver::from_nextsolver(alias_ty.args, interner);
+                    TyKind::AssociatedType(associated_ty_id, substitution)
+                }
+                rustc_type_ir::AliasTyKind::Opaque => {
+                    let opaque_ty_id = match alias_ty.def_id {
+                        SolverDefId::InternedOpaqueTyId(id) => id,
+                        _ => unreachable!(),
+                    };
+                    let substitution = ChalkToNextSolver::from_nextsolver(alias_ty.args, interner);
+                    TyKind::Alias(chalk_ir::AliasTy::Opaque(chalk_ir::OpaqueTy {
+                        opaque_ty_id: opaque_ty_id.into(),
+                        substitution,
+                    }))
+                }
+                rustc_type_ir::AliasTyKind::Inherent => todo!(),
+                rustc_type_ir::AliasTyKind::Free => todo!(),
+            },
+
+            rustc_type_ir::TyKind::Placeholder(placeholder) => {
+                let ui = chalk_ir::UniverseIndex { counter: placeholder.universe.as_usize() };
+                let placeholder_index =
+                    chalk_ir::PlaceholderIndex { idx: placeholder.bound.var.as_usize(), ui };
+                TyKind::Placeholder(placeholder_index)
+            }
+
+            rustc_type_ir::TyKind::Bound(debruijn_index, ty) => {
+                TyKind::BoundVar(chalk_ir::BoundVar {
+                    debruijn: chalk_ir::DebruijnIndex::new(debruijn_index.as_u32()),
+                    index: ty.var.as_usize(),
+                })
+            }
+
+            rustc_type_ir::TyKind::FnPtr(bound_sig, fn_header) => {
+                let num_binders = bound_sig.bound_vars().len();
+                let sig = chalk_ir::FnSig {
+                    abi: fn_header.abi,
+                    safety: match fn_header.safety {
+                        crate::next_solver::abi::Safety::Safe => chalk_ir::Safety::Safe,
+                        crate::next_solver::abi::Safety::Unsafe => chalk_ir::Safety::Unsafe,
+                    },
+                    variadic: fn_header.c_variadic,
+                };
+                let args = GenericArgs::new_from_iter(
+                    interner,
+                    bound_sig.skip_binder().inputs_and_output.iter().map(|a| a.into()),
+                );
+                let substitution = ChalkToNextSolver::from_nextsolver(args, interner);
+                let substitution = chalk_ir::FnSubst(substitution);
+                let fnptr = chalk_ir::FnPointer { num_binders, sig, substitution };
+                TyKind::Function(fnptr)
+            }
+
+            rustc_type_ir::TyKind::Dynamic(preds, region, dyn_kind) => {
+                assert!(matches!(dyn_kind, rustc_type_ir::DynKind::Dyn));
+                let self_ty = Ty::new_bound(
+                    interner,
+                    DebruijnIndex::from_u32(1),
+                    BoundTy { kind: BoundTyKind::Anon, var: BoundVar::from_u32(0) },
+                );
+                let bounds = chalk_ir::QuantifiedWhereClauses::from_iter(
+                    Interner,
+                    preds.iter().map(|p| {
+                        let binders = chalk_ir::VariableKinds::from_iter(
+                            Interner,
+                            p.bound_vars().iter().map(|b| match b {
+                                BoundVarKind::Ty(kind) => {
+                                    chalk_ir::VariableKind::Ty(TyVariableKind::General)
+                                }
+                                BoundVarKind::Region(kind) => chalk_ir::VariableKind::Lifetime,
+                                BoundVarKind::Const => chalk_ir::VariableKind::Const(
+                                    crate::TyKind::Error.intern(Interner),
+                                ),
+                            }),
+                        );
+                        let where_clause = match p.skip_binder() {
+                            rustc_type_ir::ExistentialPredicate::Trait(trait_ref) => {
+                                let trait_ref = TraitRef::new(
+                                    interner,
+                                    trait_ref.def_id,
+                                    [self_ty.clone().into()]
+                                        .into_iter()
+                                        .chain(trait_ref.args.iter()),
+                                );
+                                let trait_id = match trait_ref.def_id {
+                                    SolverDefId::TraitId(id) => to_chalk_trait_id(id),
+                                    _ => unreachable!(),
+                                };
+                                let substitution =
+                                    ChalkToNextSolver::from_nextsolver(trait_ref.args, interner);
+                                let trait_ref = chalk_ir::TraitRef { trait_id, substitution };
+                                chalk_ir::WhereClause::Implemented(trait_ref)
+                            }
+                            rustc_type_ir::ExistentialPredicate::AutoTrait(trait_) => {
+                                let trait_id = match trait_ {
+                                    SolverDefId::TraitId(id) => to_chalk_trait_id(id),
+                                    _ => unreachable!(),
+                                };
+                                let substitution = chalk_ir::Substitution::empty(Interner);
+                                let trait_ref = chalk_ir::TraitRef { trait_id, substitution };
+                                chalk_ir::WhereClause::Implemented(trait_ref)
+                            }
+                            rustc_type_ir::ExistentialPredicate::Projection(
+                                existential_projection,
+                            ) => {
+                                let projection = ProjectionPredicate {
+                                    projection_term: AliasTerm::new(
+                                        interner,
+                                        existential_projection.def_id,
+                                        [self_ty.clone().into()]
+                                            .iter()
+                                            .chain(existential_projection.args.clone().iter()),
+                                    ),
+                                    term: existential_projection.term.clone(),
+                                };
+                                let associated_ty_id = match projection.projection_term.def_id {
+                                    SolverDefId::TypeAliasId(id) => to_assoc_type_id(id),
+                                    _ => unreachable!(),
+                                };
+                                let substitution = ChalkToNextSolver::from_nextsolver(
+                                    projection.projection_term.args,
+                                    interner,
+                                );
+                                let alias = chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy {
+                                    associated_ty_id,
+                                    substitution,
+                                });
+                                let ty = match projection.term {
+                                    Term::Ty(ty) => ty,
+                                    _ => unreachable!(),
+                                };
+                                let ty = ChalkToNextSolver::from_nextsolver(ty, interner);
+                                let alias_eq = chalk_ir::AliasEq { alias, ty };
+                                chalk_ir::WhereClause::AliasEq(alias_eq)
+                            }
+                        };
+                        chalk_ir::Binders::new(binders, where_clause)
+                    }),
+                );
+                let binders = chalk_ir::VariableKinds::from1(
+                    Interner,
+                    chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General),
+                );
+                let bounds = chalk_ir::Binders::new(binders, bounds);
+                let dyn_ty = chalk_ir::DynTy {
+                    bounds,
+                    lifetime: ChalkToNextSolver::from_nextsolver(region, interner),
+                };
+                TyKind::Dyn(dyn_ty)
+            }
+
+            rustc_type_ir::TyKind::Slice(ty) => {
+                let ty = ChalkToNextSolver::from_nextsolver(ty, interner);
+                TyKind::Slice(ty)
+            }
+
+            rustc_type_ir::TyKind::Foreign(def_id) => {
+                let id = match def_id {
+                    SolverDefId::TypeAliasId(id) => to_foreign_def_id(id),
+                    _ => unreachable!(),
+                };
+                TyKind::Foreign(id)
+            }
+            rustc_type_ir::TyKind::Pat(_, _) => todo!(),
+            rustc_type_ir::TyKind::RawPtr(ty, mutability) => {
+                let mutability = match mutability {
+                    rustc_ast_ir::Mutability::Mut => chalk_ir::Mutability::Mut,
+                    rustc_ast_ir::Mutability::Not => chalk_ir::Mutability::Not,
+                };
+                let ty = ChalkToNextSolver::from_nextsolver(ty, interner);
+                TyKind::Raw(mutability, ty)
+            }
+            rustc_type_ir::TyKind::FnDef(def_id, args) => {
+                let subst = ChalkToNextSolver::from_nextsolver(args, interner);
+                match def_id {
+                    SolverDefId::FunctionId(id) => {
+                        TyKind::FnDef(CallableDefId::FunctionId(id).to_chalk(interner.db()), subst)
+                    }
+                    SolverDefId::Ctor(Ctor::Enum(e)) => TyKind::FnDef(
+                        CallableDefId::EnumVariantId(e).to_chalk(interner.db()),
+                        subst,
+                    ),
+                    SolverDefId::Ctor(Ctor::Struct(s)) => {
+                        TyKind::FnDef(CallableDefId::StructId(s).to_chalk(interner.db()), subst)
+                    }
+                    _ => unreachable!("Unexpected def id {:?}", def_id),
+                }
+            }
+
+            rustc_type_ir::TyKind::Closure(def_id, args) => {
+                let id = match def_id {
+                    SolverDefId::InternedClosureId(id) => id,
+                    _ => unreachable!(),
+                };
+                let subst = ChalkToNextSolver::from_nextsolver(args, interner);
+                TyKind::Closure(id.into(), subst)
+            }
+            rustc_type_ir::TyKind::CoroutineClosure(_, _) => todo!(),
+            rustc_type_ir::TyKind::Coroutine(def_id, args) => {
+                let id = match def_id {
+                    SolverDefId::InternedCoroutineId(id) => id,
+                    _ => unreachable!(),
+                };
+                let subst = ChalkToNextSolver::from_nextsolver(args, interner);
+                TyKind::Coroutine(id.into(), subst)
+            }
+            rustc_type_ir::TyKind::CoroutineWitness(def_id, args) => {
+                let id = match def_id {
+                    SolverDefId::InternedCoroutineId(id) => id,
+                    _ => unreachable!(),
+                };
+                let subst = ChalkToNextSolver::from_nextsolver(args, interner);
+                TyKind::CoroutineWitness(id.into(), subst)
+            }
+
+            rustc_type_ir::TyKind::Param(_) => todo!(),
+            rustc_type_ir::TyKind::UnsafeBinder(_) => todo!(),
+        }
+        .intern(Interner)
+    }
 }
 
 impl<'db> ChalkToNextSolver<'db, Region<'db>> for chalk_ir::Lifetime<Interner> {
@@ -461,6 +799,40 @@ impl<'db> ChalkToNextSolver<'db, Region<'db>> for chalk_ir::Lifetime<Interner> {
             },
         )
     }
+
+    fn from_nextsolver(out: Region<'db>, interner: DbInterner<'db>) -> Self {
+        match out.kind() {
+            rustc_type_ir::RegionKind::ReEarlyParam(early) => todo!(),
+            rustc_type_ir::RegionKind::ReBound(db, bound) => chalk_ir::Lifetime::new(
+                Interner,
+                chalk_ir::LifetimeData::BoundVar(chalk_ir::BoundVar::new(
+                    chalk_ir::DebruijnIndex::new(db.as_u32()),
+                    bound.var.as_usize(),
+                )),
+            ),
+            rustc_type_ir::RegionKind::ReLateParam(_) => todo!(),
+            rustc_type_ir::RegionKind::ReStatic => {
+                chalk_ir::Lifetime::new(Interner, chalk_ir::LifetimeData::Static)
+            }
+            rustc_type_ir::RegionKind::ReVar(vid) => chalk_ir::Lifetime::new(
+                Interner,
+                chalk_ir::LifetimeData::InferenceVar(chalk_ir::InferenceVar::from(vid.as_u32())),
+            ),
+            rustc_type_ir::RegionKind::RePlaceholder(placeholder) => chalk_ir::Lifetime::new(
+                Interner,
+                chalk_ir::LifetimeData::Placeholder(chalk_ir::PlaceholderIndex {
+                    idx: placeholder.bound.var.as_usize(),
+                    ui: chalk_ir::UniverseIndex { counter: placeholder.universe.as_usize() },
+                }),
+            ),
+            rustc_type_ir::RegionKind::ReErased => {
+                chalk_ir::Lifetime::new(Interner, chalk_ir::LifetimeData::Erased)
+            }
+            rustc_type_ir::RegionKind::ReError(_) => {
+                chalk_ir::Lifetime::new(Interner, chalk_ir::LifetimeData::Error)
+            }
+        }
+    }
 }
 
 impl<'db> ChalkToNextSolver<'db, Const<'db>> for chalk_ir::Const<Interner> {
@@ -505,6 +877,62 @@ impl<'db> ChalkToNextSolver<'db, Const<'db>> for chalk_ir::Const<Interner> {
             },
         )
     }
+
+    fn from_nextsolver(out: Const<'db>, interner: DbInterner<'db>) -> Self {
+        let value: chalk_ir::ConstValue<Interner> = match out.kind() {
+            rustc_type_ir::ConstKind::Param(_) => unimplemented!(),
+            rustc_type_ir::ConstKind::Infer(rustc_type_ir::InferConst::Var(var)) => {
+                chalk_ir::ConstValue::InferenceVar(chalk_ir::InferenceVar::from(var.as_u32()))
+            }
+            rustc_type_ir::ConstKind::Infer(rustc_type_ir::InferConst::Fresh(fresh)) => {
+                panic!("Vars should not be freshened.")
+            }
+            rustc_type_ir::ConstKind::Bound(debruijn_index, var) => {
+                chalk_ir::ConstValue::BoundVar(chalk_ir::BoundVar::new(
+                    chalk_ir::DebruijnIndex::new(debruijn_index.as_u32()),
+                    var.index(),
+                ))
+            }
+            rustc_type_ir::ConstKind::Placeholder(placeholder_const) => {
+                chalk_ir::ConstValue::Placeholder(chalk_ir::PlaceholderIndex {
+                    ui: chalk_ir::UniverseIndex { counter: placeholder_const.universe.as_usize() },
+                    idx: placeholder_const.bound.as_usize(),
+                })
+            }
+            rustc_type_ir::ConstKind::Unevaluated(unevaluated_const) => {
+                let id = match unevaluated_const.def {
+                    SolverDefId::ConstId(id) => GeneralConstId::ConstId(id),
+                    SolverDefId::StaticId(id) => GeneralConstId::StaticId(id),
+                    _ => unreachable!(),
+                };
+                let subst = ChalkToNextSolver::from_nextsolver(unevaluated_const.args, interner);
+                chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst {
+                    interned: ConstScalar::UnevaluatedConst(id, subst),
+                })
+            }
+            rustc_type_ir::ConstKind::Value(value_const) => {
+                let bytes = value_const.value.inner();
+                let value = chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst {
+                    // SAFETY: will never use this without a db
+                    interned: ConstScalar::Bytes(bytes.0.clone(), unsafe {
+                        std::mem::transmute::<MemoryMap<'_>, MemoryMap<'static>>(bytes.1.clone())
+                    }),
+                });
+                return chalk_ir::ConstData {
+                    ty: ChalkToNextSolver::from_nextsolver(value_const.ty, interner),
+                    value,
+                }
+                .intern(Interner);
+            }
+            rustc_type_ir::ConstKind::Error(_) => {
+                chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst {
+                    interned: ConstScalar::Unknown,
+                })
+            }
+            rustc_type_ir::ConstKind::Expr(_) => unimplemented!(),
+        };
+        chalk_ir::ConstData { ty: crate::TyKind::Error.intern(Interner), value }.intern(Interner)
+    }
 }
 
 impl<'db> ChalkToNextSolver<'db, rustc_type_ir::FnSigTys<DbInterner<'db>>>
@@ -518,6 +946,13 @@ impl<'db> ChalkToNextSolver<'db, rustc_type_ir::FnSigTys<DbInterner<'db>>>
             ),
         }
     }
+
+    fn from_nextsolver(
+        out: rustc_type_ir::FnSigTys<DbInterner<'db>>,
+        interner: DbInterner<'db>,
+    ) -> Self {
+        todo!()
+    }
 }
 
 impl<
@@ -536,6 +971,13 @@ impl<
             binders.to_nextsolver(interner),
         )
     }
+
+    fn from_nextsolver(
+        out: rustc_type_ir::Binder<DbInterner<'db>, U>,
+        interner: DbInterner<'db>,
+    ) -> Self {
+        todo!()
+    }
 }
 
 impl<'db> ChalkToNextSolver<'db, BoundVarKinds> for chalk_ir::VariableKinds<Interner> {
@@ -545,6 +987,10 @@ impl<'db> ChalkToNextSolver<'db, BoundVarKinds> for chalk_ir::VariableKinds<Inte
             self.iter(Interner).map(|v| v.to_nextsolver(interner)),
         )
     }
+
+    fn from_nextsolver(out: BoundVarKinds, interner: DbInterner<'db>) -> Self {
+        todo!()
+    }
 }
 
 impl<'db> ChalkToNextSolver<'db, BoundVarKind> for chalk_ir::VariableKind<Interner> {
@@ -555,6 +1001,10 @@ impl<'db> ChalkToNextSolver<'db, BoundVarKind> for chalk_ir::VariableKind<Intern
             chalk_ir::VariableKind::Const(_ty) => BoundVarKind::Const,
         }
     }
+
+    fn from_nextsolver(out: BoundVarKind, interner: DbInterner<'db>) -> Self {
+        todo!()
+    }
 }
 
 impl<'db> ChalkToNextSolver<'db, GenericArg<'db>> for chalk_ir::GenericArg<Interner> {
@@ -565,6 +1015,10 @@ impl<'db> ChalkToNextSolver<'db, GenericArg<'db>> for chalk_ir::GenericArg<Inter
             chalk_ir::GenericArgData::Const(const_) => const_.to_nextsolver(interner).into(),
         }
     }
+
+    fn from_nextsolver(out: GenericArg<'db>, interner: DbInterner<'db>) -> Self {
+        todo!()
+    }
 }
 impl<'db> ChalkToNextSolver<'db, GenericArgs<'db>> for chalk_ir::Substitution<Interner> {
     fn to_nextsolver(&self, interner: DbInterner<'db>) -> GenericArgs<'db> {
@@ -573,6 +1027,31 @@ impl<'db> ChalkToNextSolver<'db, GenericArgs<'db>> for chalk_ir::Substitution<In
             self.iter(Interner).map(|arg| -> GenericArg<'db> { arg.to_nextsolver(interner) }),
         )
     }
+
+    fn from_nextsolver(out: GenericArgs<'db>, interner: DbInterner<'db>) -> Self {
+        let mut substs = Vec::with_capacity(out.len());
+        for arg in out.iter() {
+            match arg.clone().kind() {
+                rustc_type_ir::GenericArgKind::Type(ty) => {
+                    let ty = ChalkToNextSolver::from_nextsolver(ty, interner);
+                    substs.push(chalk_ir::GenericArgData::Ty(ty).intern(Interner));
+                }
+                rustc_type_ir::GenericArgKind::Lifetime(region) => {
+                    let lifetime = ChalkToNextSolver::from_nextsolver(region, interner);
+                    substs.push(chalk_ir::GenericArgData::Lifetime(lifetime).intern(Interner));
+                }
+                rustc_type_ir::GenericArgKind::Const(const_) => {
+                    substs.push(
+                        chalk_ir::GenericArgData::Const(ChalkToNextSolver::from_nextsolver(
+                            const_, interner,
+                        ))
+                        .intern(Interner),
+                    );
+                }
+            }
+        }
+        Substitution::from_iter(Interner, substs)
+    }
 }
 
 impl<'db> ChalkToNextSolver<'db, Tys<'db>> for chalk_ir::Substitution<Interner> {
@@ -588,18 +1067,30 @@ impl<'db> ChalkToNextSolver<'db, Tys<'db>> for chalk_ir::Substitution<Interner>
             }),
         )
     }
+
+    fn from_nextsolver(out: Tys<'db>, interner: DbInterner<'db>) -> Self {
+        todo!()
+    }
 }
 
 impl<'db> ChalkToNextSolver<'db, rustc_type_ir::DebruijnIndex> for chalk_ir::DebruijnIndex {
     fn to_nextsolver(&self, interner: DbInterner<'db>) -> rustc_type_ir::DebruijnIndex {
         rustc_type_ir::DebruijnIndex::from_u32(self.depth())
     }
+
+    fn from_nextsolver(out: rustc_type_ir::DebruijnIndex, interner: DbInterner<'db>) -> Self {
+        todo!()
+    }
 }
 
 impl<'db> ChalkToNextSolver<'db, rustc_type_ir::UniverseIndex> for chalk_ir::UniverseIndex {
     fn to_nextsolver(&self, interner: DbInterner<'db>) -> rustc_type_ir::UniverseIndex {
         rustc_type_ir::UniverseIndex::from_u32(self.counter as u32)
     }
+
+    fn from_nextsolver(out: rustc_type_ir::UniverseIndex, interner: DbInterner<'db>) -> Self {
+        todo!()
+    }
 }
 
 impl<'db> ChalkToNextSolver<'db, rustc_type_ir::InferTy>
@@ -618,6 +1109,10 @@ impl<'db> ChalkToNextSolver<'db, rustc_type_ir::InferTy>
             }
         }
     }
+
+    fn from_nextsolver(out: rustc_type_ir::InferTy, interner: DbInterner<'db>) -> Self {
+        todo!()
+    }
 }
 
 impl<'db> ChalkToNextSolver<'db, rustc_ast_ir::Mutability> for chalk_ir::Mutability {
@@ -627,6 +1122,10 @@ impl<'db> ChalkToNextSolver<'db, rustc_ast_ir::Mutability> for chalk_ir::Mutabil
             chalk_ir::Mutability::Not => rustc_ast_ir::Mutability::Not,
         }
     }
+
+    fn from_nextsolver(out: rustc_ast_ir::Mutability, interner: DbInterner<'db>) -> Self {
+        todo!()
+    }
 }
 
 impl<'db> ChalkToNextSolver<'db, rustc_type_ir::Variance> for crate::Variance {
@@ -638,16 +1137,65 @@ impl<'db> ChalkToNextSolver<'db, rustc_type_ir::Variance> for crate::Variance {
             crate::Variance::Bivariant => rustc_type_ir::Variance::Bivariant,
         }
     }
+
+    fn from_nextsolver(out: rustc_type_ir::Variance, interner: DbInterner<'db>) -> Self {
+        todo!()
+    }
 }
 
-impl<'db> ChalkToNextSolver<'db, Canonical<'db, Goal<DbInterner<'db>, Predicate<'db>>>>
-    for chalk_ir::Canonical<chalk_ir::InEnvironment<chalk_ir::Goal<Interner>>>
+impl<'db> ChalkToNextSolver<'db, rustc_type_ir::Variance> for chalk_ir::Variance {
+    fn to_nextsolver(&self, interner: DbInterner<'db>) -> rustc_type_ir::Variance {
+        match self {
+            chalk_ir::Variance::Covariant => rustc_type_ir::Variance::Covariant,
+            chalk_ir::Variance::Invariant => rustc_type_ir::Variance::Invariant,
+            chalk_ir::Variance::Contravariant => rustc_type_ir::Variance::Contravariant,
+        }
+    }
+
+    fn from_nextsolver(out: rustc_type_ir::Variance, interner: DbInterner<'db>) -> Self {
+        todo!()
+    }
+}
+
+impl<'db> ChalkToNextSolver<'db, VariancesOf> for chalk_ir::Variances<Interner> {
+    fn to_nextsolver(&self, interner: DbInterner<'db>) -> VariancesOf {
+        VariancesOf::new_from_iter(
+            interner,
+            self.as_slice(Interner).iter().map(|v| v.to_nextsolver(interner)),
+        )
+    }
+
+    fn from_nextsolver(out: VariancesOf, interner: DbInterner<'db>) -> Self {
+        todo!()
+    }
+}
+
+impl<'db> ChalkToNextSolver<'db, Goal<DbInterner<'db>, Predicate<'db>>>
+    for chalk_ir::InEnvironment<chalk_ir::Goal<Interner>>
 {
-    fn to_nextsolver(
-        &self,
+    fn to_nextsolver(&self, interner: DbInterner<'db>) -> Goal<DbInterner<'db>, Predicate<'db>> {
+        Goal::new(
+            interner,
+            self.environment.to_nextsolver(interner),
+            self.goal.to_nextsolver(interner),
+        )
+    }
+
+    fn from_nextsolver(
+        out: Goal<DbInterner<'db>, Predicate<'db>>,
         interner: DbInterner<'db>,
-    ) -> Canonical<'db, Goal<DbInterner<'db>, Predicate<'db>>> {
-        let param_env = self.value.environment.to_nextsolver(interner);
+    ) -> Self {
+        chalk_ir::InEnvironment {
+            environment: ChalkToNextSolver::from_nextsolver(out.param_env, interner),
+            goal: ChalkToNextSolver::from_nextsolver(out.predicate, interner),
+        }
+    }
+}
+
+impl<'db, T: HasInterner<Interner = Interner> + ChalkToNextSolver<'db, U>, U>
+    ChalkToNextSolver<'db, Canonical<'db, U>> for chalk_ir::Canonical<T>
+{
+    fn to_nextsolver(&self, interner: DbInterner<'db>) -> Canonical<'db, U> {
         let variables = CanonicalVars::new_from_iter(
             interner,
             self.binders.iter(Interner).map(|k| match &k.kind {
@@ -672,10 +1220,49 @@ impl<'db> ChalkToNextSolver<'db, Canonical<'db, Goal<DbInterner<'db>, Predicate<
         );
         Canonical {
             max_universe: UniverseIndex::ROOT,
-            value: Goal::new(interner, param_env, self.value.goal.to_nextsolver(interner)),
+            value: self.value.to_nextsolver(interner),
             variables,
         }
     }
+
+    fn from_nextsolver(out: Canonical<'db, U>, interner: DbInterner<'db>) -> Self {
+        let binders = chalk_ir::CanonicalVarKinds::from_iter(
+            Interner,
+            out.variables.iter().map(|v| match v {
+                rustc_type_ir::CanonicalVarKind::Ty(
+                    rustc_type_ir::CanonicalTyVarKind::General(ui),
+                ) => chalk_ir::CanonicalVarKind::new(
+                    chalk_ir::VariableKind::Ty(TyVariableKind::General),
+                    chalk_ir::UniverseIndex { counter: ui.as_usize() },
+                ),
+                rustc_type_ir::CanonicalVarKind::Ty(rustc_type_ir::CanonicalTyVarKind::Int) => {
+                    chalk_ir::CanonicalVarKind::new(
+                        chalk_ir::VariableKind::Ty(TyVariableKind::Integer),
+                        chalk_ir::UniverseIndex::root(),
+                    )
+                }
+                rustc_type_ir::CanonicalVarKind::Ty(rustc_type_ir::CanonicalTyVarKind::Float) => {
+                    chalk_ir::CanonicalVarKind::new(
+                        chalk_ir::VariableKind::Ty(TyVariableKind::Float),
+                        chalk_ir::UniverseIndex::root(),
+                    )
+                }
+                rustc_type_ir::CanonicalVarKind::PlaceholderTy(_) => todo!(),
+                rustc_type_ir::CanonicalVarKind::Region(ui) => chalk_ir::CanonicalVarKind::new(
+                    chalk_ir::VariableKind::Lifetime,
+                    chalk_ir::UniverseIndex { counter: ui.as_usize() },
+                ),
+                rustc_type_ir::CanonicalVarKind::PlaceholderRegion(_) => todo!(),
+                rustc_type_ir::CanonicalVarKind::Const(ui) => chalk_ir::CanonicalVarKind::new(
+                    chalk_ir::VariableKind::Const(chalk_ir::TyKind::Error.intern(Interner)),
+                    chalk_ir::UniverseIndex { counter: ui.as_usize() },
+                ),
+                rustc_type_ir::CanonicalVarKind::PlaceholderConst(_) => todo!(),
+            }),
+        );
+        let value = ChalkToNextSolver::from_nextsolver(out.value, interner);
+        chalk_ir::Canonical { binders, value }
+    }
 }
 
 impl<'db> ChalkToNextSolver<'db, Predicate<'db>> for chalk_ir::Goal<Interner> {
@@ -693,7 +1280,16 @@ impl<'db> ChalkToNextSolver<'db, Predicate<'db>> for chalk_ir::Goal<Interner> {
             }
             chalk_ir::GoalData::All(goals) => panic!("Should not be constructed."),
             chalk_ir::GoalData::Not(goal) => panic!("Should not be constructed."),
-            chalk_ir::GoalData::EqGoal(eq_goal) => panic!("Should not be constructed."),
+            chalk_ir::GoalData::EqGoal(eq_goal) => {
+                let pred_kind = PredicateKind::AliasRelate(
+                    Term::Ty(eq_goal.a.assert_ty_ref(Interner).clone().to_nextsolver(interner)),
+                    Term::Ty(eq_goal.b.assert_ty_ref(Interner).clone().to_nextsolver(interner)),
+                    rustc_type_ir::AliasRelationDirection::Equate,
+                );
+                let pred_kind =
+                    Binder::bind_with_vars(pred_kind, BoundVarKinds::new_from_iter(interner, []));
+                Predicate::new(interner, pred_kind)
+            }
             chalk_ir::GoalData::SubtypeGoal(subtype_goal) => {
                 let subtype_predicate = SubtypePredicate {
                     a: subtype_goal.a.to_nextsolver(interner),
@@ -718,6 +1314,124 @@ impl<'db> ChalkToNextSolver<'db, Predicate<'db>> for chalk_ir::Goal<Interner> {
             chalk_ir::GoalData::CannotProve => panic!("Should not be constructed."),
         }
     }
+
+    fn from_nextsolver(out: Predicate<'db>, interner: DbInterner<'db>) -> Self {
+        chalk_ir::Goal::new(
+            Interner,
+            match out.kind().skip_binder() {
+                rustc_type_ir::PredicateKind::Clause(rustc_type_ir::ClauseKind::Trait(
+                    trait_pred,
+                )) => {
+                    let trait_ref =
+                        ChalkToNextSolver::from_nextsolver(trait_pred.trait_ref, interner);
+                    let where_clause = chalk_ir::WhereClause::Implemented(trait_ref);
+                    chalk_ir::GoalData::DomainGoal(chalk_ir::DomainGoal::Holds(where_clause))
+                }
+                rustc_type_ir::PredicateKind::Clause(rustc_type_ir::ClauseKind::Projection(
+                    proj_predicate,
+                )) => {
+                    let associated_ty_id = match proj_predicate.def_id() {
+                        SolverDefId::TypeAliasId(id) => to_assoc_type_id(id),
+                        _ => unreachable!(),
+                    };
+                    let substitution = ChalkToNextSolver::from_nextsolver(
+                        proj_predicate.projection_term.args,
+                        interner,
+                    );
+                    let alias = chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy {
+                        associated_ty_id,
+                        substitution,
+                    });
+                    let ty = match proj_predicate.term.kind() {
+                        rustc_type_ir::TermKind::Ty(ty) => ty,
+                        rustc_type_ir::TermKind::Const(_) => todo!(),
+                    };
+                    let ty = ChalkToNextSolver::from_nextsolver(ty, interner);
+                    let alias_eq = chalk_ir::AliasEq { alias, ty };
+                    let where_clause = chalk_ir::WhereClause::AliasEq(alias_eq);
+                    chalk_ir::GoalData::DomainGoal(chalk_ir::DomainGoal::Holds(where_clause))
+                }
+                rustc_type_ir::PredicateKind::Clause(rustc_type_ir::ClauseKind::TypeOutlives(
+                    outlives,
+                )) => {
+                    let lifetime = ChalkToNextSolver::from_nextsolver(outlives.1, interner);
+                    let ty = ChalkToNextSolver::from_nextsolver(outlives.0, interner);
+                    let where_clause =
+                        chalk_ir::WhereClause::TypeOutlives(chalk_ir::TypeOutlives {
+                            lifetime,
+                            ty,
+                        });
+                    chalk_ir::GoalData::DomainGoal(chalk_ir::DomainGoal::Holds(where_clause))
+                }
+                rustc_type_ir::PredicateKind::Clause(
+                    rustc_type_ir::ClauseKind::RegionOutlives(outlives),
+                ) => {
+                    let a = ChalkToNextSolver::from_nextsolver(outlives.0, interner);
+                    let b = ChalkToNextSolver::from_nextsolver(outlives.1, interner);
+                    let where_clause =
+                        chalk_ir::WhereClause::LifetimeOutlives(chalk_ir::LifetimeOutlives {
+                            a,
+                            b,
+                        });
+                    chalk_ir::GoalData::DomainGoal(chalk_ir::DomainGoal::Holds(where_clause))
+                }
+                rustc_type_ir::PredicateKind::Clause(_) => todo!(),
+                rustc_type_ir::PredicateKind::DynCompatible(_) => todo!(),
+                rustc_type_ir::PredicateKind::Subtype(subtype_predicate) => todo!(),
+                rustc_type_ir::PredicateKind::Coerce(coerce_predicate) => todo!(),
+                rustc_type_ir::PredicateKind::ConstEquate(_, _) => todo!(),
+                rustc_type_ir::PredicateKind::Ambiguous => todo!(),
+                rustc_type_ir::PredicateKind::NormalizesTo(normalizes_to) => todo!(),
+                rustc_type_ir::PredicateKind::AliasRelate(
+                    alias_term,
+                    ty_term,
+                    alias_relation_direction,
+                ) => {
+                    let ty = match ty_term {
+                        Term::Ty(ty) => ChalkToNextSolver::from_nextsolver(ty, interner),
+                        Term::Const(..) => todo!(),
+                    };
+                    match alias_term {
+                        Term::Ty(alias_ty) => match alias_ty.kind() {
+                            rustc_type_ir::TyKind::Alias(kind, alias) => match kind {
+                                rustc_type_ir::AliasTyKind::Projection => {
+                                    let associated_ty_id = match alias.def_id {
+                                        SolverDefId::TypeAliasId(id) => to_assoc_type_id(id),
+                                        _ => todo!(),
+                                    };
+                                    let substitution =
+                                        ChalkToNextSolver::from_nextsolver(alias.args, interner);
+                                    let proj_ty =
+                                        chalk_ir::ProjectionTy { associated_ty_id, substitution };
+                                    let alias = chalk_ir::AliasTy::Projection(proj_ty);
+                                    let alias_eq = chalk_ir::AliasEq { alias, ty };
+                                    chalk_ir::GoalData::DomainGoal(chalk_ir::DomainGoal::Holds(
+                                        chalk_ir::WhereClause::AliasEq(alias_eq),
+                                    ))
+                                }
+                                _ => todo!(),
+                            },
+                            rustc_type_ir::TyKind::Infer(var) => {
+                                assert!(matches!(
+                                    alias_relation_direction,
+                                    rustc_type_ir::AliasRelationDirection::Equate
+                                ));
+                                let a: chalk_ir::Ty<_> =
+                                    ChalkToNextSolver::from_nextsolver(alias_ty, interner);
+                                let eq_goal = chalk_ir::EqGoal {
+                                    a: chalk_ir::GenericArgData::Ty(a).intern(Interner),
+                                    b: chalk_ir::GenericArgData::Ty(ty).intern(Interner),
+                                };
+                                chalk_ir::GoalData::EqGoal(eq_goal)
+                            }
+                            _ => todo!("Unexpected alias term {:?}", alias_term),
+                        },
+                        Term::Const(..) => todo!(),
+                    }
+                }
+            },
+        )
+    }
 }
 
 impl<'db> ChalkToNextSolver<'db, ParamEnv<'db>> for chalk_ir::Environment<Interner> {
@@ -730,12 +1444,32 @@ impl<'db> ChalkToNextSolver<'db, ParamEnv<'db>> for chalk_ir::Environment<Intern
             Clauses::new_from_iter(interner, elaborate::elaborate(interner, clauses.iter()));
         ParamEnv { clauses }
     }
+
+    fn from_nextsolver(out: ParamEnv<'db>, interner: DbInterner<'db>) -> Self {
+        let clauses = chalk_ir::ProgramClauses::from_iter(
+            Interner,
+            out.clauses.iter().map(|c| -> chalk_ir::ProgramClause<Interner> {
+                ChalkToNextSolver::from_nextsolver(c, interner)
+            }),
+        );
+        chalk_ir::Environment { clauses }
+    }
 }
 
 impl<'db> ChalkToNextSolver<'db, Clause<'db>> for chalk_ir::ProgramClause<Interner> {
     fn to_nextsolver(&self, interner: DbInterner<'db>) -> Clause<'db> {
         Clause(Predicate::new(interner, self.data(Interner).0.to_nextsolver(interner)))
     }
+
+    fn from_nextsolver(out: Clause<'db>, interner: DbInterner<'db>) -> Self {
+        chalk_ir::ProgramClause::new(
+            Interner,
+            chalk_ir::ProgramClauseData(chalk_ir::Binders::empty(
+                Interner,
+                ChalkToNextSolver::from_nextsolver(out.0.kind().skip_binder(), interner),
+            )),
+        )
+    }
 }
 
 impl<'db> ChalkToNextSolver<'db, PredicateKind<'db>>
@@ -746,6 +1480,14 @@ impl<'db> ChalkToNextSolver<'db, PredicateKind<'db>>
         assert!(self.constraints.is_empty(Interner));
         self.consequence.to_nextsolver(interner)
     }
+    fn from_nextsolver(out: PredicateKind<'db>, interner: DbInterner<'db>) -> Self {
+        chalk_ir::ProgramClauseImplication {
+            consequence: ChalkToNextSolver::from_nextsolver(out, interner),
+            conditions: chalk_ir::Goals::empty(Interner),
+            constraints: chalk_ir::Constraints::empty(Interner),
+            priority: chalk_ir::ClausePriority::High,
+        }
+    }
 }
 
 impl<'db> ChalkToNextSolver<'db, PredicateKind<'db>> for chalk_ir::DomainGoal<Interner> {
@@ -864,6 +1606,98 @@ impl<'db> ChalkToNextSolver<'db, PredicateKind<'db>> for chalk_ir::DomainGoal<In
             chalk_ir::DomainGoal::ObjectSafe(trait_id) => panic!("Should not be constructed."),
         }
     }
+
+    fn from_nextsolver(out: PredicateKind<'db>, interner: DbInterner<'db>) -> Self {
+        let domain_goal = match out {
+            rustc_type_ir::PredicateKind::Clause(rustc_type_ir::ClauseKind::Trait(trait_pred)) => {
+                let trait_ref = ChalkToNextSolver::from_nextsolver(trait_pred.trait_ref, interner);
+                let where_clause = chalk_ir::WhereClause::Implemented(trait_ref);
+                chalk_ir::DomainGoal::Holds(where_clause)
+            }
+            rustc_type_ir::PredicateKind::Clause(rustc_type_ir::ClauseKind::Projection(
+                proj_predicate,
+            )) => {
+                let associated_ty_id = match proj_predicate.def_id() {
+                    SolverDefId::TypeAliasId(id) => to_assoc_type_id(id),
+                    _ => unreachable!(),
+                };
+                let substitution = ChalkToNextSolver::from_nextsolver(
+                    proj_predicate.projection_term.args,
+                    interner,
+                );
+                let alias = chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy {
+                    associated_ty_id,
+                    substitution,
+                });
+                let ty = match proj_predicate.term.kind() {
+                    rustc_type_ir::TermKind::Ty(ty) => ty,
+                    rustc_type_ir::TermKind::Const(_) => todo!(),
+                };
+                let ty = ChalkToNextSolver::from_nextsolver(ty, interner);
+                let alias_eq = chalk_ir::AliasEq { alias, ty };
+                let where_clause = chalk_ir::WhereClause::AliasEq(alias_eq);
+                chalk_ir::DomainGoal::Holds(where_clause)
+            }
+            rustc_type_ir::PredicateKind::Clause(rustc_type_ir::ClauseKind::TypeOutlives(
+                outlives,
+            )) => {
+                let lifetime = ChalkToNextSolver::from_nextsolver(outlives.1, interner);
+                let ty = ChalkToNextSolver::from_nextsolver(outlives.0, interner);
+                let where_clause =
+                    chalk_ir::WhereClause::TypeOutlives(chalk_ir::TypeOutlives { lifetime, ty });
+                chalk_ir::DomainGoal::Holds(where_clause)
+            }
+            rustc_type_ir::PredicateKind::Clause(rustc_type_ir::ClauseKind::RegionOutlives(
+                outlives,
+            )) => {
+                let a = ChalkToNextSolver::from_nextsolver(outlives.0, interner);
+                let b = ChalkToNextSolver::from_nextsolver(outlives.1, interner);
+                let where_clause =
+                    chalk_ir::WhereClause::LifetimeOutlives(chalk_ir::LifetimeOutlives { a, b });
+                chalk_ir::DomainGoal::Holds(where_clause)
+            }
+            rustc_type_ir::PredicateKind::Clause(_) => todo!(),
+            rustc_type_ir::PredicateKind::DynCompatible(_) => todo!(),
+            rustc_type_ir::PredicateKind::Subtype(subtype_predicate) => todo!(),
+            rustc_type_ir::PredicateKind::Coerce(coerce_predicate) => todo!(),
+            rustc_type_ir::PredicateKind::ConstEquate(_, _) => todo!(),
+            rustc_type_ir::PredicateKind::Ambiguous => todo!(),
+            rustc_type_ir::PredicateKind::NormalizesTo(normalizes_to) => todo!(),
+            rustc_type_ir::PredicateKind::AliasRelate(
+                alias_term,
+                ty_term,
+                alias_relation_direction,
+            ) => {
+                let alias = match alias_term {
+                    Term::Ty(alias_ty) => match alias_ty.kind() {
+                        rustc_type_ir::TyKind::Alias(kind, alias) => match kind {
+                            rustc_type_ir::AliasTyKind::Projection => {
+                                let associated_ty_id = match alias.def_id {
+                                    SolverDefId::TypeAliasId(id) => to_assoc_type_id(id),
+                                    _ => todo!(),
+                                };
+                                let substitution =
+                                    ChalkToNextSolver::from_nextsolver(alias.args, interner);
+                                let proj_ty =
+                                    chalk_ir::ProjectionTy { associated_ty_id, substitution };
+                                chalk_ir::AliasTy::Projection(proj_ty)
+                            }
+                            _ => todo!(),
+                        },
+                        _ => todo!(),
+                    },
+                    Term::Const(..) => todo!(),
+                };
+                let ty = match ty_term {
+                    Term::Ty(ty) => ChalkToNextSolver::from_nextsolver(ty, interner),
+                    Term::Const(..) => todo!(),
+                };
+                let alias_eq = chalk_ir::AliasEq { alias, ty };
+                chalk_ir::DomainGoal::Holds(chalk_ir::WhereClause::AliasEq(alias_eq))
+            }
+        };
+        domain_goal
+    }
 }
 
 impl<'db> ChalkToNextSolver<'db, TraitRef<'db>> for chalk_ir::TraitRef<Interner> {
@@ -871,6 +1705,15 @@ impl<'db> ChalkToNextSolver<'db, TraitRef<'db>> for chalk_ir::TraitRef<Interner>
         let args = self.substitution.to_nextsolver(interner);
         TraitRef::new_from_args(interner, from_chalk_trait_id(self.trait_id).into(), args)
     }
+
+    fn from_nextsolver(out: TraitRef<'db>, interner: DbInterner<'db>) -> Self {
+        let trait_id = match out.def_id {
+            SolverDefId::TraitId(id) => to_chalk_trait_id(id),
+            _ => unreachable!(),
+        };
+        let substitution = ChalkToNextSolver::from_nextsolver(out.args, interner);
+        chalk_ir::TraitRef { trait_id, substitution }
+    }
 }
 
 impl<'db> ChalkToNextSolver<'db, PredicateKind<'db>> for chalk_ir::WhereClause<Interner> {
@@ -911,6 +1754,10 @@ impl<'db> ChalkToNextSolver<'db, PredicateKind<'db>> for chalk_ir::WhereClause<I
             }
         }
     }
+
+    fn from_nextsolver(out: PredicateKind<'db>, interner: DbInterner<'db>) -> Self {
+        todo!()
+    }
 }
 
 pub fn convert_canonical_args_for_result<'db>(
@@ -956,7 +1803,10 @@ pub fn convert_canonical_args_for_result<'db>(
         binders,
         value: chalk_ir::ConstrainedSubst {
             constraints: chalk_ir::Constraints::empty(Interner),
-            subst: convert_args_for_result(interner, &value),
+            subst: ChalkToNextSolver::from_nextsolver(
+                GenericArgs::new_from_iter(interner, value),
+                interner,
+            ),
         },
     }
 }
@@ -1047,7 +1897,7 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
 
         rustc_type_ir::TyKind::Adt(def, args) => {
             let adt_id = def.inner().id;
-            let subst = convert_args_for_result(interner, args.as_slice());
+            let subst = ChalkToNextSolver::from_nextsolver(args, interner);
             TyKind::Adt(chalk_ir::AdtId(adt_id), subst)
         }
 
@@ -1062,11 +1912,7 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
                 rustc_type_ir::InferTy::FloatVar(var) => {
                     (InferenceVar::from(var.as_u32()), TyVariableKind::Float)
                 }
-                rustc_type_ir::InferTy::FreshFloatTy(..)
-                | rustc_type_ir::InferTy::FreshIntTy(..)
-                | rustc_type_ir::InferTy::FreshTy(..) => {
-                    panic!("Freshening shouldn't happen.")
-                }
+                _ => todo!(),
             };
             TyKind::InferenceVar(var, kind)
         }
@@ -1086,7 +1932,7 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
             let subst = Substitution::from_iter(
                 Interner,
                 tys.iter().map(|ty| {
-                    chalk_ir::GenericArgData::Ty(convert_ty_for_result(interner, ty))
+                    chalk_ir::GenericArgData::Ty(ChalkToNextSolver::from_nextsolver(ty, interner))
                         .intern(Interner)
                 }),
             );
@@ -1094,8 +1940,8 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
         }
 
         rustc_type_ir::TyKind::Array(ty, const_) => {
-            let ty = convert_ty_for_result(interner, ty);
-            let const_ = convert_const_for_result(interner, const_);
+            let ty = ChalkToNextSolver::from_nextsolver(ty, interner);
+            let const_ = ChalkToNextSolver::from_nextsolver(const_, interner);
             TyKind::Array(ty, const_)
         }
 
@@ -1106,7 +1952,7 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
                     _ => unreachable!(),
                 };
                 let associated_ty_id = to_assoc_type_id(assoc_ty_id);
-                let substitution = convert_args_for_result(interner, alias_ty.args.as_slice());
+                let substitution = ChalkToNextSolver::from_nextsolver(alias_ty.args, interner);
                 TyKind::AssociatedType(associated_ty_id, substitution)
             }
             rustc_type_ir::AliasTyKind::Opaque => {
@@ -1114,14 +1960,14 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
                     SolverDefId::InternedOpaqueTyId(id) => id,
                     _ => unreachable!(),
                 };
-                let substitution = convert_args_for_result(interner, alias_ty.args.as_slice());
+                let substitution = ChalkToNextSolver::from_nextsolver(alias_ty.args, interner);
                 TyKind::Alias(chalk_ir::AliasTy::Opaque(chalk_ir::OpaqueTy {
                     opaque_ty_id: opaque_ty_id.into(),
                     substitution,
                 }))
             }
-            rustc_type_ir::AliasTyKind::Inherent => unimplemented!(),
-            rustc_type_ir::AliasTyKind::Free => unimplemented!(),
+            rustc_type_ir::AliasTyKind::Inherent => todo!(),
+            rustc_type_ir::AliasTyKind::Free => todo!(),
         },
 
         // For `Placeholder`, `Bound` and `Param`, see the comment on the reverse conversion.
@@ -1156,7 +2002,7 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
                 interner,
                 bound_sig.skip_binder().inputs_and_output.iter().map(|a| a.into()),
             );
-            let substitution = convert_args_for_result(interner, args.as_slice());
+            let substitution = ChalkToNextSolver::from_nextsolver(args, interner);
             let substitution = chalk_ir::FnSubst(substitution);
             let fnptr = chalk_ir::FnPointer { num_binders, sig, substitution };
             TyKind::Function(fnptr)
@@ -1199,11 +2045,11 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
                             let trait_ref = TraitRef::new(
                                 interner,
                                 trait_ref.def_id,
-                                [self_ty.into()].into_iter().chain(trait_ref.args.iter()),
+                                [self_ty.clone().into()].into_iter().chain(trait_ref.args.iter()),
                             );
                             let trait_id = to_chalk_trait_id(trait_ref.def_id.0);
                             let substitution =
-                                convert_args_for_result(interner, trait_ref.args.as_slice());
+                                ChalkToNextSolver::from_nextsolver(trait_ref.args, interner);
                             let trait_ref = chalk_ir::TraitRef { trait_id, substitution };
                             chalk_ir::WhereClause::Implemented(trait_ref)
                         }
@@ -1221,19 +2067,19 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
                                 projection_term: AliasTerm::new(
                                     interner,
                                     existential_projection.def_id,
-                                    [self_ty.into()]
+                                    [self_ty.clone().into()]
                                         .iter()
-                                        .chain(existential_projection.args.iter()),
+                                        .chain(existential_projection.args.clone().iter()),
                                 ),
-                                term: existential_projection.term,
+                                term: existential_projection.term.clone(),
                             };
                             let associated_ty_id = match projection.projection_term.def_id {
                                 SolverDefId::TypeAliasId(id) => to_assoc_type_id(id),
                                 _ => unreachable!(),
                             };
-                            let substitution = convert_args_for_result(
+                            let substitution = ChalkToNextSolver::from_nextsolver(
+                                projection.projection_term.args,
                                 interner,
-                                projection.projection_term.args.as_slice(),
                             );
                             let alias = chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy {
                                 associated_ty_id,
@@ -1243,7 +2089,7 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
                                 Term::Ty(ty) => ty,
                                 _ => unreachable!(),
                             };
-                            let ty = convert_ty_for_result(interner, ty);
+                            let ty = ChalkToNextSolver::from_nextsolver(ty, interner);
                             let alias_eq = chalk_ir::AliasEq { alias, ty };
                             chalk_ir::WhereClause::AliasEq(alias_eq)
                         }
@@ -1262,7 +2108,7 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
         }
 
         rustc_type_ir::TyKind::Slice(ty) => {
-            let ty = convert_ty_for_result(interner, ty);
+            let ty = ChalkToNextSolver::from_nextsolver(ty, interner);
             TyKind::Slice(ty)
         }
 
@@ -1273,24 +2119,29 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
             };
             TyKind::Foreign(to_foreign_def_id(def_id))
         }
-        rustc_type_ir::TyKind::Pat(_, _) => unimplemented!(),
+        rustc_type_ir::TyKind::Pat(_, _) => todo!(),
         rustc_type_ir::TyKind::RawPtr(ty, mutability) => {
             let mutability = match mutability {
                 rustc_ast_ir::Mutability::Mut => chalk_ir::Mutability::Mut,
                 rustc_ast_ir::Mutability::Not => chalk_ir::Mutability::Not,
             };
-            let ty = convert_ty_for_result(interner, ty);
+            let ty = ChalkToNextSolver::from_nextsolver(ty, interner);
             TyKind::Raw(mutability, ty)
         }
         rustc_type_ir::TyKind::FnDef(def_id, args) => {
-            let id = match def_id {
-                SolverDefId::FunctionId(id) => CallableDefId::FunctionId(id),
-                SolverDefId::Ctor(Ctor::Struct(id)) => CallableDefId::StructId(id),
-                SolverDefId::Ctor(Ctor::Enum(id)) => CallableDefId::EnumVariantId(id),
-                _ => unreachable!(),
-            };
-            let subst = convert_args_for_result(interner, args.as_slice());
-            TyKind::FnDef(id.to_chalk(interner.db()), subst)
+            let subst = ChalkToNextSolver::from_nextsolver(args, interner);
+            match def_id {
+                SolverDefId::FunctionId(id) => {
+                    TyKind::FnDef(CallableDefId::FunctionId(id).to_chalk(interner.db()), subst)
+                }
+                SolverDefId::Ctor(Ctor::Enum(e)) => {
+                    TyKind::FnDef(CallableDefId::EnumVariantId(e).to_chalk(interner.db()), subst)
+                }
+                SolverDefId::Ctor(Ctor::Struct(s)) => {
+                    TyKind::FnDef(CallableDefId::StructId(s).to_chalk(interner.db()), subst)
+                }
+                _ => unreachable!("Unexpected def id {:?}", def_id),
+            }
         }
 
         rustc_type_ir::TyKind::Closure(def_id, args) => {
@@ -1298,16 +2149,16 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
                 SolverDefId::InternedClosureId(id) => id,
                 _ => unreachable!(),
             };
-            let subst = convert_args_for_result(interner, args.as_slice());
+            let subst = ChalkToNextSolver::from_nextsolver(args, interner);
             TyKind::Closure(id.into(), subst)
         }
-        rustc_type_ir::TyKind::CoroutineClosure(_, _) => unimplemented!(),
+        rustc_type_ir::TyKind::CoroutineClosure(_, _) => todo!(),
         rustc_type_ir::TyKind::Coroutine(def_id, args) => {
             let id = match def_id {
                 SolverDefId::InternedCoroutineId(id) => id,
                 _ => unreachable!(),
             };
-            let subst = convert_args_for_result(interner, args.as_slice());
+            let subst = ChalkToNextSolver::from_nextsolver(args, interner);
             TyKind::Coroutine(id.into(), subst)
         }
         rustc_type_ir::TyKind::CoroutineWitness(def_id, args) => {
@@ -1315,7 +2166,7 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
                 SolverDefId::InternedCoroutineId(id) => id,
                 _ => unreachable!(),
             };
-            let subst = convert_args_for_result(interner, args.as_slice());
+            let subst = ChalkToNextSolver::from_nextsolver(args, interner);
             TyKind::CoroutineWitness(id.into(), subst)
         }
 
@@ -1419,3 +2270,17 @@ pub fn convert_region_for_result<'db>(
     };
     chalk_ir::Lifetime::new(Interner, lifetime)
 }
+
+pub trait InferenceVarExt {
+    fn to_vid(self) -> rustc_type_ir::TyVid;
+    fn from_vid(vid: rustc_type_ir::TyVid) -> InferenceVar;
+}
+
+impl InferenceVarExt for InferenceVar {
+    fn to_vid(self) -> rustc_type_ir::TyVid {
+        rustc_type_ir::TyVid::from_u32(self.index())
+    }
+    fn from_vid(vid: rustc_type_ir::TyVid) -> InferenceVar {
+        InferenceVar::from(vid.as_u32())
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
index 1d0ee0e488dcf..b9b2950a94a3b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
@@ -14,7 +14,7 @@ use crate::{
     db::HirDatabase,
     next_solver::{
         ClauseKind, CoercePredicate, PredicateKind, SubtypePredicate,
-        mapping::{ChalkToNextSolver, convert_args_for_result},
+        mapping::ChalkToNextSolver,
         util::sizedness_fast_path,
     },
 };
@@ -200,7 +200,7 @@ impl<'db> SolverDelegate for SolverContext<'db> {
             SolverDefId::StaticId(c) => GeneralConstId::StaticId(c),
             _ => unreachable!(),
         };
-        let subst = convert_args_for_result(self.interner, uv.args.as_slice());
+        let subst = ChalkToNextSolver::from_nextsolver(uv.args, self.interner);
         let ec = self.cx().db.const_eval(c, subst, None).ok()?;
         Some(ec.to_nextsolver(self.interner))
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs b/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
index 51cf5be1372ca..0c58e031c3a0f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
@@ -1,6 +1,7 @@
 //! Trait solving using Chalk.
 
 use core::fmt;
+use std::hash::Hash;
 
 use chalk_ir::{DebruijnIndex, GoalData, fold::TypeFoldable};
 use chalk_solve::rust_ir;
@@ -20,17 +21,9 @@ use stdx::never;
 use triomphe::Arc;
 
 use crate::{
-    AliasEq, AliasTy, Canonical, DomainGoal, Goal, InEnvironment, Interner, ProjectionTy,
-    ProjectionTyExt, TraitRefExt, Ty, TyKind, TypeFlags, WhereClause,
-    db::HirDatabase,
-    infer::unify::InferenceTable,
-    next_solver::{
-        DbInterner, GenericArg, SolverContext, Span,
-        infer::{DbInternerInferExt, InferCtxt},
-        mapping::{ChalkToNextSolver, convert_canonical_args_for_result},
-        util::mini_canonicalize,
-    },
-    utils::UnevaluatedConstEvaluatorFolder,
+    db::HirDatabase, infer::unify::InferenceTable, next_solver::{
+        infer::{DbInternerInferExt, InferCtxt}, mapping::{convert_canonical_args_for_result, ChalkToNextSolver}, util::mini_canonicalize, DbInterner, GenericArg, Predicate, SolverContext, Span
+    }, utils::UnevaluatedConstEvaluatorFolder, AliasEq, AliasTy, Canonical, DomainGoal, Goal, InEnvironment, Interner, ProjectionTy, ProjectionTyExt, TraitRefExt, Ty, TyKind, TypeFlags, WhereClause
 };
 
 /// A set of clauses that we assume to be true. E.g. if we are inside this function:
@@ -231,7 +224,6 @@ impl NextTraitSolveResult {
     }
 }
 
-/// Solve a trait goal using Chalk.
 pub fn next_trait_solve(
     db: &dyn HirDatabase,
     krate: Crate,
@@ -290,6 +282,57 @@ pub fn next_trait_solve(
     }
 }
 
+pub fn next_trait_solve_canonical<'db>(
+    db: &'db dyn HirDatabase,
+    krate: Crate,
+    block: Option<BlockId>,
+    goal: crate::next_solver::Canonical<'db, crate::next_solver::Goal<'db, Predicate<'db>>>,
+) -> NextTraitSolveResult {
+    // FIXME: should use analysis_in_body, but that needs GenericDefId::Block
+    let context = SolverContext(
+        DbInterner::new_with(db, Some(krate), block)
+            .infer_ctxt()
+            .build(TypingMode::non_body_analysis()),
+    );
+
+    tracing::info!(?goal);
+
+    let (goal, var_values) =
+        context.instantiate_canonical(&goal);
+    tracing::info!(?var_values);
+
+    let res = context.evaluate_root_goal(
+        goal.clone(),
+        Span::dummy(),
+        None
+    );
+
+    let vars =
+        var_values.var_values.iter().map(|g| context.0.resolve_vars_if_possible(g)).collect();
+    let canonical_var_values = mini_canonicalize(context, vars);
+
+    let res = res.map(|r| (r.has_changed, r.certainty, canonical_var_values));
+
+    tracing::debug!("solve_nextsolver({:?}) => {:?}", goal, res);
+
+    match res {
+        Err(_) => NextTraitSolveResult::NoSolution,
+        Ok((_, Certainty::Yes, args)) => NextTraitSolveResult::Certain(
+            convert_canonical_args_for_result(DbInterner::new_with(db, Some(krate), block), args)
+        ),
+        Ok((_, Certainty::Maybe(_), args)) => {
+            let subst = convert_canonical_args_for_result(
+                DbInterner::new_with(db, Some(krate), block),
+                args,
+            );
+            NextTraitSolveResult::Uncertain(chalk_ir::Canonical {
+                binders: subst.binders,
+                value: subst.value.subst,
+            })
+        }
+    }
+}
+
 /// Solve a trait goal using Chalk.
 pub fn next_trait_solve_in_ctxt<'db, 'a>(
     infer_ctxt: &'a InferCtxt<'db>,
diff --git a/src/tools/rust-analyzer/crates/hir/src/attrs.rs b/src/tools/rust-analyzer/crates/hir/src/attrs.rs
index 928753ef0edeb..79a154a5d8e6e 100644
--- a/src/tools/rust-analyzer/crates/hir/src/attrs.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/attrs.rs
@@ -14,7 +14,7 @@ use hir_expand::{
     mod_path::{ModPath, PathKind},
     name::Name,
 };
-use hir_ty::{db::HirDatabase, method_resolution};
+use hir_ty::{db::HirDatabase, method_resolution, next_solver::{mapping::ChalkToNextSolver, DbInterner}};
 
 use crate::{
     Adt, AsAssocItem, AssocItem, BuiltinType, Const, ConstParam, DocLinkDef, Enum, ExternCrateDecl,
@@ -271,7 +271,7 @@ fn resolve_impl_trait_item<'db>(
     //
     // FIXME: resolve type aliases (which are not yielded by iterate_path_candidates)
     _ = method_resolution::iterate_path_candidates(
-        &canonical,
+        &canonical.to_nextsolver(DbInterner::new_with(db, Some(environment.krate), environment.block)),
         db,
         environment,
         &traits_in_scope,
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index 6eb8a8bf60fd1..52ab808d22841 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -5611,7 +5611,11 @@ impl<'db> Type<'db> {
             .map_or_else(|| TraitEnvironment::empty(krate.id), |d| db.trait_environment(d));
 
         _ = method_resolution::iterate_method_candidates_dyn(
-            &canonical,
+            &canonical.to_nextsolver(DbInterner::new_with(
+                db,
+                Some(environment.krate),
+                environment.block,
+            )),
             db,
             environment,
             traits_in_scope,
@@ -5698,7 +5702,11 @@ impl<'db> Type<'db> {
             .map_or_else(|| TraitEnvironment::empty(krate.id), |d| db.trait_environment(d));
 
         _ = method_resolution::iterate_path_candidates(
-            &canonical,
+            &canonical.to_nextsolver(DbInterner::new_with(
+                db,
+                Some(environment.krate),
+                environment.block,
+            )),
             db,
             environment,
             traits_in_scope,

From 7c20f9c5888ff8ebe66997c2eca504a521d49dd8 Mon Sep 17 00:00:00 2001
From: calvinhirsch <calvinhirsch7@gmail.com>
Date: Tue, 9 Sep 2025 10:09:09 -0400
Subject: [PATCH 0720/1889] fix comments about trait solver cycle heads

---
 compiler/rustc_type_ir/src/search_graph/mod.rs   | 4 ++--
 compiler/rustc_type_ir/src/search_graph/stack.rs | 4 ++--
 2 files changed, 4 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 dbbc0c217d7d4..8f8f019510fe8 100644
--- a/compiler/rustc_type_ir/src/search_graph/mod.rs
+++ b/compiler/rustc_type_ir/src/search_graph/mod.rs
@@ -1262,7 +1262,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             encountered_overflow |= stack_entry.encountered_overflow;
             debug_assert_eq!(stack_entry.input, input);
 
-            // If the current goal is not the root of a cycle, we are done.
+            // If the current goal is not a cycle head, we are done.
             //
             // There are no provisional cache entries which depend on this goal.
             let Some(usages) = stack_entry.usages else {
@@ -1278,7 +1278,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             //
             // 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
+            // this was only the head 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, usages, result) {
                 self.rebase_provisional_cache_entries(&stack_entry, |_, result| result);
diff --git a/compiler/rustc_type_ir/src/search_graph/stack.rs b/compiler/rustc_type_ir/src/search_graph/stack.rs
index 3fd8e2bd16e4e..8348666be412d 100644
--- a/compiler/rustc_type_ir/src/search_graph/stack.rs
+++ b/compiler/rustc_type_ir/src/search_graph/stack.rs
@@ -13,7 +13,7 @@ rustc_index::newtype_index! {
     pub(super) struct StackDepth {}
 }
 
-/// Stack entries of the evaluation stack. Its fields tend to be lazily
+/// Stack entries of the evaluation stack. Its fields tend to be lazily updated
 /// when popping a child goal or completely immutable.
 #[derive_where(Debug; X: Cx)]
 pub(super) struct StackEntry<X: Cx> {
@@ -42,7 +42,7 @@ pub(super) struct StackEntry<X: Cx> {
     /// Whether evaluating this goal encountered overflow. Lazily updated.
     pub encountered_overflow: bool,
 
-    /// Whether and how this goal has been used as the root of a cycle. Lazily updated.
+    /// Whether and how this goal has been used as a cycle head. Lazily updated.
     pub usages: Option<HeadUsages>,
 
     /// We want to be able to ignore head usages if they happen inside of candidates

From 20d02258fc24c5ab7572cfa5064a733021e6fbcd Mon Sep 17 00:00:00 2001
From: Georg Semmler <github@weiznich.de>
Date: Mon, 8 Sep 2025 08:17:06 +0200
Subject: [PATCH 0721/1889] Make Barrier RefUnwindSafe again

This commit manually implements `RefUnwindSafe` for
`std::sync::Barrier` to fix 146087. This is a fix for a regression
indroduced by https://github.com/rust-lang/rust/commit/e95db591a4550e28ad92660b753ad85b89271882
---
 library/std/src/sync/barrier.rs   |  5 +++++
 library/std/tests/sync/barrier.rs | 10 ++++++++++
 2 files changed, 15 insertions(+)

diff --git a/library/std/src/sync/barrier.rs b/library/std/src/sync/barrier.rs
index 712ce03f90b02..47d63c57ff1e8 100644
--- a/library/std/src/sync/barrier.rs
+++ b/library/std/src/sync/barrier.rs
@@ -1,3 +1,5 @@
+use core::panic::RefUnwindSafe;
+
 use crate::fmt;
 use crate::sync::nonpoison::{Condvar, Mutex};
 
@@ -31,6 +33,9 @@ pub struct Barrier {
     num_threads: usize,
 }
 
+#[stable(feature = "rust1", since = "1.0.0")]
+impl RefUnwindSafe for Barrier {}
+
 // The inner state of a double barrier
 struct BarrierState {
     count: usize,
diff --git a/library/std/tests/sync/barrier.rs b/library/std/tests/sync/barrier.rs
index 8aefff9d5071c..cc9ee322c6c25 100644
--- a/library/std/tests/sync/barrier.rs
+++ b/library/std/tests/sync/barrier.rs
@@ -1,3 +1,4 @@
+use std::panic::RefUnwindSafe;
 use std::sync::mpsc::{TryRecvError, channel};
 use std::sync::{Arc, Barrier};
 use std::thread;
@@ -33,3 +34,12 @@ fn test_barrier() {
     }
     assert!(leader_found);
 }
+
+#[expect(dead_code, reason = "this is essentially a compile pass test")]
+fn check_barrier_is_ref_unwind_safe() {
+    let barrier = Arc::new(Barrier::new(10));
+
+    fn check<T: RefUnwindSafe>(_: T) {}
+
+    check(barrier);
+}

From 30fd32eca506a96e228abdd6ab18f6f1054b4db3 Mon Sep 17 00:00:00 2001
From: Georg Semmler <github@weiznich.de>
Date: Tue, 9 Sep 2025 17:14:07 +0200
Subject: [PATCH 0722/1889] Make the compile test use a const instead

---
 library/std/tests/sync/barrier.rs | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/library/std/tests/sync/barrier.rs b/library/std/tests/sync/barrier.rs
index cc9ee322c6c25..a66bd6296999b 100644
--- a/library/std/tests/sync/barrier.rs
+++ b/library/std/tests/sync/barrier.rs
@@ -35,11 +35,10 @@ fn test_barrier() {
     assert!(leader_found);
 }
 
-#[expect(dead_code, reason = "this is essentially a compile pass test")]
-fn check_barrier_is_ref_unwind_safe() {
-    let barrier = Arc::new(Barrier::new(10));
-
-    fn check<T: RefUnwindSafe>(_: T) {}
-
-    check(barrier);
-}
+/// Asserts that `Barrier` is ref unwind safe.
+///
+/// See <https://github.com/rust-lang/rust/issues/146087>.
+const _: () = {
+    const fn check_ref_unwind_safe<T: RefUnwindSafe>() {}
+    check_ref_unwind_safe::<Barrier>();
+};

From ec8725010120bfbe0430ea54ab820db1d9ed84eb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Mon, 8 Sep 2025 15:49:51 +0200
Subject: [PATCH 0723/1889] Improve docs of certain built-in macro expanders

---
 .../rustc_builtin_macros/src/source_util.rs   | 31 +++++++++++--------
 1 file changed, 18 insertions(+), 13 deletions(-)

diff --git a/compiler/rustc_builtin_macros/src/source_util.rs b/compiler/rustc_builtin_macros/src/source_util.rs
index 37bab5be5421e..f95c8f38229b2 100644
--- a/compiler/rustc_builtin_macros/src/source_util.rs
+++ b/compiler/rustc_builtin_macros/src/source_util.rs
@@ -1,3 +1,5 @@
+//! The implementation of built-in macros which relate to the file system.
+
 use std::path::{Path, PathBuf};
 use std::rc::Rc;
 use std::sync::Arc;
@@ -23,11 +25,7 @@ use crate::util::{
     check_zero_tts, get_single_str_from_tts, get_single_str_spanned_from_tts, parse_expr,
 };
 
-// These macros all relate to the file system; they either return
-// the column/row/filename of the expression, or they include
-// a given file into the current one.
-
-/// line!(): expands to the current line number
+/// Expand `line!()` to the current line number.
 pub(crate) fn expand_line(
     cx: &mut ExtCtxt<'_>,
     sp: Span,
@@ -42,7 +40,7 @@ pub(crate) fn expand_line(
     ExpandResult::Ready(MacEager::expr(cx.expr_u32(topmost, loc.line as u32)))
 }
 
-/* column!(): expands to the current column number */
+/// Expand `column!()` to the current column number.
 pub(crate) fn expand_column(
     cx: &mut ExtCtxt<'_>,
     sp: Span,
@@ -57,9 +55,7 @@ pub(crate) fn expand_column(
     ExpandResult::Ready(MacEager::expr(cx.expr_u32(topmost, loc.col.to_usize() as u32 + 1)))
 }
 
-/// file!(): expands to the current filename */
-/// The source_file (`loc.file`) contains a bunch more information we could spit
-/// out if we wanted.
+/// Expand `file!()` to the current filename.
 pub(crate) fn expand_file(
     cx: &mut ExtCtxt<'_>,
     sp: Span,
@@ -81,6 +77,7 @@ pub(crate) fn expand_file(
     )))
 }
 
+/// Expand `stringify!($input)`.
 pub(crate) fn expand_stringify(
     cx: &mut ExtCtxt<'_>,
     sp: Span,
@@ -91,6 +88,7 @@ pub(crate) fn expand_stringify(
     ExpandResult::Ready(MacEager::expr(cx.expr_str(sp, Symbol::intern(&s))))
 }
 
+/// Expand `module_path!()` to (a textual representation of) the current module path.
 pub(crate) fn expand_mod(
     cx: &mut ExtCtxt<'_>,
     sp: Span,
@@ -104,9 +102,9 @@ pub(crate) fn expand_mod(
     ExpandResult::Ready(MacEager::expr(cx.expr_str(sp, Symbol::intern(&string))))
 }
 
-/// include! : parse the given file as an expr
-/// This is generally a bad idea because it's going to behave
-/// unhygienically.
+/// Expand `include!($input)`.
+///
+/// This works in item and expression position. Notably, it doesn't work in pattern position.
 pub(crate) fn expand_include<'cx>(
     cx: &'cx mut ExtCtxt<'_>,
     sp: Span,
@@ -187,7 +185,9 @@ pub(crate) fn expand_include<'cx>(
     ExpandResult::Ready(Box::new(ExpandInclude { p, node_id: cx.current_expansion.lint_node_id }))
 }
 
-/// `include_str!`: read the given file, insert it as a literal string expr
+/// Expand `include_str!($input)` to the content of the UTF-8-encoded file given by path `$input` as a string literal.
+///
+/// This works in expression, pattern and statement position.
 pub(crate) fn expand_include_str(
     cx: &mut ExtCtxt<'_>,
     sp: Span,
@@ -206,6 +206,7 @@ pub(crate) fn expand_include_str(
         Ok((bytes, bsp)) => match std::str::from_utf8(&bytes) {
             Ok(src) => {
                 let interned_src = Symbol::intern(src);
+                // MacEager converts the expr into a pat if need be.
                 MacEager::expr(cx.expr_str(cx.with_def_site_ctxt(bsp), interned_src))
             }
             Err(utf8err) => {
@@ -218,6 +219,9 @@ pub(crate) fn expand_include_str(
     })
 }
 
+/// Expand `include_bytes!($input)` to the content of the file given by path `$input`.
+///
+/// This works in expression, pattern and statement position.
 pub(crate) fn expand_include_bytes(
     cx: &mut ExtCtxt<'_>,
     sp: Span,
@@ -237,6 +241,7 @@ pub(crate) fn expand_include_bytes(
             // Don't care about getting the span for the raw bytes,
             // because the console can't really show them anyway.
             let expr = cx.expr(sp, ast::ExprKind::IncludedBytes(ByteSymbol::intern(&bytes)));
+            // MacEager converts the expr into a pat if need be.
             MacEager::expr(expr)
         }
         Err(dummy) => dummy,

From 1a13522b56be87ed9d30e4727472da57cdc9ab3c Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 9 Sep 2025 17:19:36 +0200
Subject: [PATCH 0724/1889] Update `browser-ui-test` version to `0.22.2`

---
 package-lock.json | 8 ++++----
 package.json      | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index def0cfa86a584..d0297bf70b63f 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -5,7 +5,7 @@
   "packages": {
     "": {
       "dependencies": {
-        "browser-ui-test": "^0.22.0",
+        "browser-ui-test": "^0.22.2",
         "es-check": "^6.2.1",
         "eslint": "^8.57.1",
         "eslint-js": "github:eslint/js",
@@ -485,9 +485,9 @@
       }
     },
     "node_modules/browser-ui-test": {
-      "version": "0.22.0",
-      "resolved": "https://registry.npmjs.org/browser-ui-test/-/browser-ui-test-0.22.0.tgz",
-      "integrity": "sha512-p/C02TMybTDKsAjpGOdnyNC0Q25KDae/fKMnvHaqcJ0tXRqNKwndW2Ltq7HTmin5xqg8GGOmysEgWTZkXu6pfA==",
+      "version": "0.22.2",
+      "resolved": "https://registry.npmjs.org/browser-ui-test/-/browser-ui-test-0.22.2.tgz",
+      "integrity": "sha512-eNB/PN2yDGe5n5IwE3ld/N6A39jM1oRzJmT5nOVQqrvoZEtcd9JSggDQPNVUnMEyuGcD4OEOWMsEa4oJppAmDQ==",
       "license": "MIT",
       "dependencies": {
         "css-unit-converter": "^1.1.2",
diff --git a/package.json b/package.json
index 976d630363413..04e0f6af19a0c 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "browser-ui-test": "^0.22.0",
+    "browser-ui-test": "^0.22.2",
     "es-check": "^6.2.1",
     "eslint": "^8.57.1",
     "eslint-js": "github:eslint/js",

From 7e7ce10e5b0474e6833c22062c4973f447ca6463 Mon Sep 17 00:00:00 2001
From: yanglsh <yanglsh@shanghaitech.edu.cn>
Date: Wed, 10 Sep 2025 00:10:05 +0800
Subject: [PATCH 0725/1889] fix: `useless_attribute` FP on
 `deprecated_in_future`

---
 clippy_lints/src/attrs/useless_attribute.rs |  1 +
 clippy_utils/src/sym.rs                     |  1 +
 tests/ui/useless_attribute.fixed            | 10 ++++++++++
 tests/ui/useless_attribute.rs               | 10 ++++++++++
 4 files changed, 22 insertions(+)

diff --git a/clippy_lints/src/attrs/useless_attribute.rs b/clippy_lints/src/attrs/useless_attribute.rs
index b9b5cedb5aa76..1cebc18edc90a 100644
--- a/clippy_lints/src/attrs/useless_attribute.rs
+++ b/clippy_lints/src/attrs/useless_attribute.rs
@@ -30,6 +30,7 @@ pub(super) fn check(cx: &EarlyContext<'_>, item: &Item, attrs: &[Attribute]) {
                                 sym::ambiguous_glob_reexports
                                     | sym::dead_code
                                     | sym::deprecated
+                                    | sym::deprecated_in_future
                                     | sym::hidden_glob_reexports
                                     | sym::unreachable_pub
                                     | sym::unused
diff --git a/clippy_utils/src/sym.rs b/clippy_utils/src/sym.rs
index 278101ac27f96..e2570a151584f 100644
--- a/clippy_utils/src/sym.rs
+++ b/clippy_utils/src/sym.rs
@@ -125,6 +125,7 @@ generate! {
     cycle,
     cyclomatic_complexity,
     de,
+    deprecated_in_future,
     diagnostics,
     disallowed_types,
     drain,
diff --git a/tests/ui/useless_attribute.fixed b/tests/ui/useless_attribute.fixed
index be4fb55ddfb86..15070dd9c2ca6 100644
--- a/tests/ui/useless_attribute.fixed
+++ b/tests/ui/useless_attribute.fixed
@@ -158,3 +158,13 @@ pub mod redundant_imports_issue {
 
     empty!();
 }
+
+pub mod issue15636 {
+    pub mod f {
+        #[deprecated(since = "TBD")]
+        pub mod deprec {}
+    }
+
+    #[allow(deprecated_in_future)]
+    pub use f::deprec;
+}
diff --git a/tests/ui/useless_attribute.rs b/tests/ui/useless_attribute.rs
index 5a1bcf97a5b46..3f530de7fd8e3 100644
--- a/tests/ui/useless_attribute.rs
+++ b/tests/ui/useless_attribute.rs
@@ -158,3 +158,13 @@ pub mod redundant_imports_issue {
 
     empty!();
 }
+
+pub mod issue15636 {
+    pub mod f {
+        #[deprecated(since = "TBD")]
+        pub mod deprec {}
+    }
+
+    #[allow(deprecated_in_future)]
+    pub use f::deprec;
+}

From 69140ec44c2f57497ae2375a6f75f0bfe76b8003 Mon Sep 17 00:00:00 2001
From: Shoyu Vanilla <modulo641@gmail.com>
Date: Fri, 29 Aug 2025 21:47:10 +0900
Subject: [PATCH 0726/1889] Fix failing tests and fill-in missing details

---
 .../crates/hir-ty/src/autoderef.rs            |  14 +-
 .../crates/hir-ty/src/chalk_ext.rs            |  41 +-
 .../crates/hir-ty/src/consteval_nextsolver.rs |   6 +-
 .../rust-analyzer/crates/hir-ty/src/infer.rs  |  28 +-
 .../crates/hir-ty/src/infer/closure.rs        |  12 +-
 .../crates/hir-ty/src/infer/coerce.rs         |  67 +-
 .../crates/hir-ty/src/infer/expr.rs           |  57 +-
 .../crates/hir-ty/src/infer/pat.rs            |  12 +-
 .../crates/hir-ty/src/infer/path.rs           |  12 +-
 .../crates/hir-ty/src/infer/unify.rs          | 472 +++++----
 .../rust-analyzer/crates/hir-ty/src/lib.rs    |  11 +-
 .../crates/hir-ty/src/method_resolution.rs    | 223 ++--
 .../rust-analyzer/crates/hir-ty/src/mir.rs    |   3 +-
 .../crates/hir-ty/src/mir/monomorphization.rs |  26 +-
 .../crates/hir-ty/src/next_solver.rs          |   4 +-
 .../infer/canonical/canonicalizer.rs          | 136 ++-
 .../hir-ty/src/next_solver/infer/mod.rs       |  25 +-
 .../crates/hir-ty/src/next_solver/mapping.rs  | 974 ++++--------------
 .../crates/hir-ty/src/next_solver/solver.rs   |   6 +-
 .../crates/hir-ty/src/tests/coercion.rs       |  14 +-
 .../crates/hir-ty/src/tests/incremental.rs    |   6 +-
 .../crates/hir-ty/src/tests/macros.rs         |   4 +-
 .../hir-ty/src/tests/method_resolution.rs     |  10 +-
 .../crates/hir-ty/src/tests/never_type.rs     |  24 +-
 .../crates/hir-ty/src/tests/opaque_types.rs   |   4 +-
 .../crates/hir-ty/src/tests/patterns.rs       |  26 +-
 .../crates/hir-ty/src/tests/regression.rs     |  12 +-
 .../hir-ty/src/tests/regression/new_solver.rs |   2 +-
 .../crates/hir-ty/src/tests/simple.rs         |   4 +-
 .../crates/hir-ty/src/tests/traits.rs         |  28 +-
 .../rust-analyzer/crates/hir-ty/src/traits.rs |  43 +-
 .../rust-analyzer/crates/hir/src/attrs.rs     |  12 +-
 .../ide-completion/src/context/tests.rs       |   3 +-
 .../src/handlers/type_mismatch.rs             |   3 +-
 .../rust-analyzer/crates/ide-ssr/src/tests.rs |  15 +-
 .../crates/ide/src/doc_links/tests.rs         |   3 +-
 36 files changed, 914 insertions(+), 1428 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs b/src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs
index 4ea0156e1248a..82696a5c94daf 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs
@@ -13,7 +13,7 @@ use triomphe::Arc;
 
 use crate::{
     Canonical, Goal, Interner, ProjectionTyExt, TraitEnvironment, Ty, TyBuilder, TyKind,
-    db::HirDatabase, infer::unify::InferenceTable,
+    db::HirDatabase, infer::unify::InferenceTable, next_solver::mapping::ChalkToNextSolver,
 };
 
 const AUTODEREF_RECURSION_LIMIT: usize = 20;
@@ -98,7 +98,7 @@ impl<'table, 'db> Autoderef<'table, 'db> {
         explicit: bool,
         use_receiver_trait: bool,
     ) -> Self {
-        let ty = table.resolve_ty_shallow(&ty);
+        let ty = table.structurally_resolve_type(&ty);
         Autoderef { table, ty, at_start: true, steps: Vec::new(), explicit, use_receiver_trait }
     }
 
@@ -114,7 +114,7 @@ impl<'table, 'db> Autoderef<'table, 'db, usize> {
         explicit: bool,
         use_receiver_trait: bool,
     ) -> Self {
-        let ty = table.resolve_ty_shallow(&ty);
+        let ty = table.structurally_resolve_type(&ty);
         Autoderef { table, ty, at_start: true, steps: 0, explicit, use_receiver_trait }
     }
 }
@@ -160,7 +160,7 @@ pub(crate) fn autoderef_step(
     use_receiver_trait: bool,
 ) -> Option<(AutoderefKind, Ty)> {
     if let Some(derefed) = builtin_deref(table.db, &ty, explicit) {
-        Some((AutoderefKind::Builtin, table.resolve_ty_shallow(derefed)))
+        Some((AutoderefKind::Builtin, table.structurally_resolve_type(derefed)))
     } else {
         Some((AutoderefKind::Overloaded, deref_by_trait(table, ty, use_receiver_trait)?))
     }
@@ -187,7 +187,7 @@ pub(crate) fn deref_by_trait(
     use_receiver_trait: bool,
 ) -> Option<Ty> {
     let _p = tracing::info_span!("deref_by_trait").entered();
-    if table.resolve_ty_shallow(&ty).inference_var(Interner).is_some() {
+    if table.structurally_resolve_type(&ty).inference_var(Interner).is_some() {
         // don't try to deref unknown variables
         return None;
     }
@@ -229,8 +229,8 @@ pub(crate) fn deref_by_trait(
         return None;
     }
 
-    table.register_obligation(implements_goal);
+    table.register_obligation(implements_goal.to_nextsolver(table.interner));
 
     let result = table.normalize_projection_ty(projection);
-    Some(table.resolve_ty_shallow(&result))
+    Some(table.structurally_resolve_type(&result))
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/chalk_ext.rs b/src/tools/rust-analyzer/crates/hir-ty/src/chalk_ext.rs
index 33ae099c690ea..9f0ea14a8063d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/chalk_ext.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/chalk_ext.rs
@@ -245,26 +245,30 @@ impl TyExt for Ty {
     }
 
     fn impl_trait_bounds(&self, db: &dyn HirDatabase) -> Option<Vec<QuantifiedWhereClause>> {
+        let handle_async_block_type_impl_trait = |def: DefWithBodyId| {
+            let krate = def.module(db).krate();
+            if let Some(future_trait) = LangItem::Future.resolve_trait(db, krate) {
+                // This is only used by type walking.
+                // Parameters will be walked outside, and projection predicate is not used.
+                // So just provide the Future trait.
+                let impl_bound = Binders::empty(
+                    Interner,
+                    WhereClause::Implemented(TraitRef {
+                        trait_id: to_chalk_trait_id(future_trait),
+                        substitution: Substitution::empty(Interner),
+                    }),
+                );
+                Some(vec![impl_bound])
+            } else {
+                None
+            }
+        };
+
         match self.kind(Interner) {
             TyKind::OpaqueType(opaque_ty_id, subst) => {
                 match db.lookup_intern_impl_trait_id((*opaque_ty_id).into()) {
                     ImplTraitId::AsyncBlockTypeImplTrait(def, _expr) => {
-                        let krate = def.module(db).krate();
-                        if let Some(future_trait) = LangItem::Future.resolve_trait(db, krate) {
-                            // This is only used by type walking.
-                            // Parameters will be walked outside, and projection predicate is not used.
-                            // So just provide the Future trait.
-                            let impl_bound = Binders::empty(
-                                Interner,
-                                WhereClause::Implemented(TraitRef {
-                                    trait_id: to_chalk_trait_id(future_trait),
-                                    substitution: Substitution::empty(Interner),
-                                }),
-                            );
-                            Some(vec![impl_bound])
-                        } else {
-                            None
-                        }
+                        handle_async_block_type_impl_trait(def)
                     }
                     ImplTraitId::ReturnTypeImplTrait(func, idx) => {
                         db.return_type_impl_traits(func).map(|it| {
@@ -299,8 +303,9 @@ impl TyExt for Ty {
                             data.substitute(Interner, &opaque_ty.substitution)
                         })
                     }
-                    // It always has an parameter for Future::Output type.
-                    ImplTraitId::AsyncBlockTypeImplTrait(..) => unreachable!(),
+                    ImplTraitId::AsyncBlockTypeImplTrait(def, _) => {
+                        return handle_async_block_type_impl_trait(def);
+                    }
                 };
 
                 predicates.map(|it| it.into_value_and_skipped_binders().0)
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs
index 4700335931549..6e07d3afe5524 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs
@@ -27,7 +27,7 @@ use crate::{
     next_solver::{
         Const, ConstBytes, ConstKind, DbInterner, ErrorGuaranteed, GenericArg, GenericArgs,
         ParamConst, SolverDefId, Ty, ValueConst,
-        mapping::{ChalkToNextSolver, convert_binder_to_early_binder},
+        mapping::{ChalkToNextSolver, NextSolverToChalk, convert_binder_to_early_binder},
     },
 };
 
@@ -145,7 +145,7 @@ pub fn try_const_usize<'db>(db: &'db dyn HirDatabase, c: Const<'db>) -> Option<u
                 SolverDefId::StaticId(id) => GeneralConstId::StaticId(id),
                 _ => unreachable!(),
             };
-            let subst = ChalkToNextSolver::from_nextsolver(unevaluated_const.args, interner);
+            let subst = unevaluated_const.args.to_chalk(interner);
             let ec = db.const_eval(c, subst, None).ok()?.to_nextsolver(interner);
             try_const_usize(db, ec)
         }
@@ -168,7 +168,7 @@ pub fn try_const_isize<'db>(db: &'db dyn HirDatabase, c: &Const<'db>) -> Option<
                 SolverDefId::StaticId(id) => GeneralConstId::StaticId(id),
                 _ => unreachable!(),
             };
-            let subst = ChalkToNextSolver::from_nextsolver(unevaluated_const.args, interner);
+            let subst = unevaluated_const.args.to_chalk(interner);
             let ec = db.const_eval(c, subst, None).ok()?.to_nextsolver(interner);
             try_const_isize(db, &ec)
         }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
index 71b33a0e9035f..265d1f8541cc8 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
@@ -55,10 +55,9 @@ use stdx::{always, never};
 use triomphe::Arc;
 
 use crate::{
-    AliasEq, AliasTy, Binders, ClosureId, Const, DomainGoal, GenericArg, Goal, ImplTraitId,
-    ImplTraitIdx, InEnvironment, IncorrectGenericsLenKind, Interner, Lifetime, OpaqueTyId,
-    ParamLoweringMode, PathLoweringDiagnostic, ProjectionTy, Substitution, TraitEnvironment, Ty,
-    TyBuilder, TyExt,
+    AliasEq, AliasTy, Binders, ClosureId, Const, DomainGoal, GenericArg, ImplTraitId, ImplTraitIdx,
+    IncorrectGenericsLenKind, Interner, Lifetime, OpaqueTyId, ParamLoweringMode,
+    PathLoweringDiagnostic, ProjectionTy, Substitution, TraitEnvironment, Ty, TyBuilder, TyExt,
     db::HirDatabase,
     fold_tys,
     generics::Generics,
@@ -70,6 +69,7 @@ use crate::{
     },
     lower::{ImplTraitLoweringMode, LifetimeElisionKind, diagnostics::TyLoweringDiagnostic},
     mir::MirSpan,
+    next_solver::{self, mapping::ChalkToNextSolver},
     static_lifetime, to_assoc_type_id,
     traits::FnTrait,
     utils::UnevaluatedConstEvaluatorFolder,
@@ -182,13 +182,13 @@ impl BindingMode {
 }
 
 #[derive(Debug)]
-pub(crate) struct InferOk<T> {
+pub(crate) struct InferOk<'db, T> {
     value: T,
-    goals: Vec<InEnvironment<Goal>>,
+    goals: Vec<next_solver::Goal<'db, next_solver::Predicate<'db>>>,
 }
 
-impl<T> InferOk<T> {
-    fn map<U>(self, f: impl FnOnce(T) -> U) -> InferOk<U> {
+impl<'db, T> InferOk<'db, T> {
+    fn map<U>(self, f: impl FnOnce(T) -> U) -> InferOk<'db, U> {
         InferOk { value: f(self.value), goals: self.goals }
     }
 }
@@ -203,7 +203,7 @@ pub enum InferenceTyDiagnosticSource {
 
 #[derive(Debug)]
 pub(crate) struct TypeError;
-pub(crate) type InferResult<T> = Result<InferOk<T>, TypeError>;
+pub(crate) type InferResult<'db, T> = Result<InferOk<'db, T>, TypeError>;
 
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum InferenceDiagnostic {
@@ -832,6 +832,7 @@ impl<'db> InferenceContext<'db> {
             coercion_casts,
             diagnostics: _,
         } = &mut result;
+        table.resolve_obligations_as_possible();
         table.fallback_if_possible();
 
         // Comment from rustc:
@@ -1480,7 +1481,8 @@ impl<'db> InferenceContext<'db> {
     }
 
     fn push_obligation(&mut self, o: DomainGoal) {
-        self.table.register_obligation(o.cast(Interner));
+        let goal: crate::Goal = o.cast(Interner);
+        self.table.register_obligation(goal.to_nextsolver(self.table.interner));
     }
 
     fn unify(&mut self, ty1: &Ty, ty2: &Ty) -> bool {
@@ -1746,7 +1748,7 @@ impl<'db> InferenceContext<'db> {
 
                     ty = self.table.insert_type_vars(ty);
                     ty = self.table.normalize_associated_types_in(ty);
-                    ty = self.table.resolve_ty_shallow(&ty);
+                    ty = self.table.structurally_resolve_type(&ty);
                     if ty.is_unknown() {
                         return (self.err_ty(), None);
                     }
@@ -1817,7 +1819,7 @@ impl<'db> InferenceContext<'db> {
         let ty = match ty.kind(Interner) {
             TyKind::Alias(AliasTy::Projection(proj_ty)) => {
                 let ty = self.table.normalize_projection_ty(proj_ty.clone());
-                self.table.resolve_ty_shallow(&ty)
+                self.table.structurally_resolve_type(&ty)
             }
             _ => ty,
         };
@@ -2047,7 +2049,7 @@ impl Expectation {
     fn adjust_for_branches(&self, table: &mut unify::InferenceTable<'_>) -> Expectation {
         match self {
             Expectation::HasType(ety) => {
-                let ety = table.resolve_ty_shallow(ety);
+                let ety = table.structurally_resolve_type(ety);
                 if ety.is_ty_var() { Expectation::None } else { Expectation::HasType(ety) }
             }
             Expectation::RValueLikeUnsized(ety) => Expectation::RValueLikeUnsized(ety.clone()),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
index 493652b764015..5a69ad68b58e4 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
@@ -39,6 +39,7 @@ use crate::{
     infer::{BreakableKind, CoerceMany, Diverges, coerce::CoerceNever},
     make_binders,
     mir::{BorrowKind, MirSpan, MutBorrowKind, ProjectionElem},
+    next_solver::mapping::ChalkToNextSolver,
     to_assoc_type_id,
     traits::FnTrait,
     utils::{self, elaborate_clause_supertraits},
@@ -437,10 +438,10 @@ impl InferenceContext<'_> {
             associated_ty_id: to_assoc_type_id(future_output),
             substitution: Substitution::from1(Interner, ret_param_future.clone()),
         });
-        self.table.register_obligation(
+        let goal: crate::Goal =
             crate::AliasEq { alias: future_projection, ty: ret_param_future_output.clone() }
-                .cast(Interner),
-        );
+                .cast(Interner);
+        self.table.register_obligation(goal.to_nextsolver(self.table.interner));
 
         Some(FnSubst(Substitution::from_iter(
             Interner,
@@ -568,7 +569,10 @@ impl InferenceContext<'_> {
         let supplied_sig = self.supplied_sig_of_closure(body, ret_type, arg_types, closure_kind);
 
         let snapshot = self.table.snapshot();
-        if !self.table.unify::<_, crate::next_solver::GenericArgs<'_>>(&expected_sig.substitution.0, &supplied_sig.expected_sig.substitution.0) {
+        if !self.table.unify::<_, crate::next_solver::GenericArgs<'_>>(
+            &expected_sig.substitution.0,
+            &supplied_sig.expected_sig.substitution.0,
+        ) {
             self.table.rollback_to(snapshot);
         }
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
index b47834f0c749c..df516662bfd37 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
@@ -8,24 +8,27 @@
 use std::iter;
 
 use chalk_ir::{BoundVar, Mutability, TyKind, TyVariableKind, cast::Cast};
-use hir_def::{
-    hir::ExprId,
-    lang_item::LangItem,
-};
+use hir_def::{hir::ExprId, lang_item::LangItem};
 use rustc_type_ir::solve::Certainty;
 use stdx::always;
 use triomphe::Arc;
 
 use crate::{
-    autoderef::{Autoderef, AutoderefKind}, db::HirDatabase, infer::{
+    Canonical, FnAbi, FnPointer, FnSig, Goal, Interner, Lifetime, Substitution, TraitEnvironment,
+    Ty, TyBuilder, TyExt,
+    autoderef::{Autoderef, AutoderefKind},
+    db::HirDatabase,
+    infer::{
         Adjust, Adjustment, AutoBorrow, InferOk, InferenceContext, OverloadedDeref, PointerCast,
         TypeError, TypeMismatch,
-    }, utils::ClosureSubst, Canonical, FnAbi, FnPointer, FnSig, Goal, InEnvironment, Interner, Lifetime, Substitution, TraitEnvironment, Ty, TyBuilder, TyExt
+    },
+    next_solver,
+    utils::ClosureSubst,
 };
 
 use super::unify::InferenceTable;
 
-pub(crate) type CoerceResult = Result<InferOk<(Vec<Adjustment>, Ty)>, TypeError>;
+pub(crate) type CoerceResult<'db> = Result<InferOk<'db, (Vec<Adjustment>, Ty)>, TypeError>;
 
 /// Do not require any adjustments, i.e. coerce `x -> x`.
 fn identity(_: Ty) -> Vec<Adjustment> {
@@ -37,11 +40,11 @@ fn simple(kind: Adjust) -> impl FnOnce(Ty) -> Vec<Adjustment> {
 }
 
 /// This always returns `Ok(...)`.
-fn success(
+fn success<'db>(
     adj: Vec<Adjustment>,
     target: Ty,
-    goals: Vec<InEnvironment<Goal>>,
-) -> CoerceResult {
+    goals: Vec<next_solver::Goal<'db, next_solver::Predicate<'db>>>,
+) -> CoerceResult<'db> {
     Ok(InferOk { goals, value: (adj, target) })
 }
 
@@ -107,9 +110,9 @@ impl CoerceMany {
     ///    coerce both to function pointers;
     ///  - if we were concerned with lifetime subtyping, we'd need to look for a
     ///    least upper bound.
-    pub(super) fn coerce(
+    pub(super) fn coerce<'db>(
         &mut self,
-        ctx: &mut InferenceContext<'_>,
+        ctx: &mut InferenceContext<'db>,
         expr: Option<ExprId>,
         expr_ty: &Ty,
         cause: CoercionCause,
@@ -276,7 +279,7 @@ impl InferenceContext<'_> {
     }
 }
 
-impl InferenceTable<'_> {
+impl<'db> InferenceTable<'db> {
     /// Unify two types, but may coerce the first one to the second one
     /// using "implicit coercion rules" if needed.
     pub(crate) fn coerce(
@@ -285,8 +288,8 @@ impl InferenceTable<'_> {
         to_ty: &Ty,
         coerce_never: CoerceNever,
     ) -> Result<(Vec<Adjustment>, Ty), TypeError> {
-        let from_ty = self.resolve_ty_shallow(from_ty);
-        let to_ty = self.resolve_ty_shallow(to_ty);
+        let from_ty = self.structurally_resolve_type(from_ty);
+        let to_ty = self.structurally_resolve_type(to_ty);
         match self.coerce_inner(from_ty, &to_ty, coerce_never) {
             Ok(InferOk { value: (adjustments, ty), goals }) => {
                 self.register_infer_ok(InferOk { value: (), goals });
@@ -299,10 +302,15 @@ impl InferenceTable<'_> {
         }
     }
 
-    fn coerce_inner(&mut self, from_ty: Ty, to_ty: &Ty, coerce_never: CoerceNever) -> CoerceResult {
+    fn coerce_inner(
+        &mut self,
+        from_ty: Ty,
+        to_ty: &Ty,
+        coerce_never: CoerceNever,
+    ) -> CoerceResult<'db> {
         if from_ty.is_never() {
             if let TyKind::InferenceVar(tv, TyVariableKind::General) = to_ty.kind(Interner) {
-                self.set_diverging(*tv, TyVariableKind::General, true);
+                self.set_diverging(*tv, TyVariableKind::General);
             }
             if coerce_never == CoerceNever::Yes {
                 // Subtle: If we are coercing from `!` to `?T`, where `?T` is an unbound
@@ -370,7 +378,7 @@ impl InferenceTable<'_> {
     }
 
     /// Unify two types (using sub or lub) and produce a specific coercion.
-    fn unify_and<F>(&mut self, t1: &Ty, t2: &Ty, f: F) -> CoerceResult
+    fn unify_and<F>(&mut self, t1: &Ty, t2: &Ty, f: F) -> CoerceResult<'db>
     where
         F: FnOnce(Ty) -> Vec<Adjustment>,
     {
@@ -378,7 +386,7 @@ impl InferenceTable<'_> {
             .and_then(|InferOk { goals, .. }| success(f(t1.clone()), t1.clone(), goals))
     }
 
-    fn coerce_ptr(&mut self, from_ty: Ty, to_ty: &Ty, to_mt: Mutability) -> CoerceResult {
+    fn coerce_ptr(&mut self, from_ty: Ty, to_ty: &Ty, to_mt: Mutability) -> CoerceResult<'db> {
         let (is_ref, from_mt, from_inner) = match from_ty.kind(Interner) {
             TyKind::Ref(mt, _, ty) => (true, mt, ty),
             TyKind::Raw(mt, ty) => (false, mt, ty),
@@ -420,7 +428,7 @@ impl InferenceTable<'_> {
         to_ty: &Ty,
         to_mt: Mutability,
         to_lt: &Lifetime,
-    ) -> CoerceResult {
+    ) -> CoerceResult<'db> {
         let (_from_lt, from_mt) = match from_ty.kind(Interner) {
             TyKind::Ref(mt, lt, _) => {
                 coerce_mutabilities(*mt, to_mt)?;
@@ -524,7 +532,7 @@ impl InferenceTable<'_> {
     }
 
     /// Attempts to coerce from the type of a Rust function item into a function pointer.
-    fn coerce_from_fn_item(&mut self, from_ty: Ty, to_ty: &Ty) -> CoerceResult {
+    fn coerce_from_fn_item(&mut self, from_ty: Ty, to_ty: &Ty) -> CoerceResult<'db> {
         match to_ty.kind(Interner) {
             TyKind::Function(_) => {
                 let from_sig = from_ty.callable_sig(self.db).expect("FnDef had no sig");
@@ -566,7 +574,7 @@ impl InferenceTable<'_> {
         from_ty: Ty,
         from_f: &FnPointer,
         to_ty: &Ty,
-    ) -> CoerceResult {
+    ) -> CoerceResult<'db> {
         self.coerce_from_safe_fn(
             from_ty,
             from_f,
@@ -583,7 +591,7 @@ impl InferenceTable<'_> {
         to_ty: &Ty,
         to_unsafe: F,
         normal: G,
-    ) -> CoerceResult
+    ) -> CoerceResult<'db>
     where
         F: FnOnce(Ty) -> Vec<Adjustment>,
         G: FnOnce(Ty) -> Vec<Adjustment>,
@@ -606,7 +614,7 @@ impl InferenceTable<'_> {
         from_ty: Ty,
         from_substs: &Substitution,
         to_ty: &Ty,
-    ) -> CoerceResult {
+    ) -> CoerceResult<'db> {
         match to_ty.kind(Interner) {
             // if from_substs is non-capturing (FIXME)
             TyKind::Function(fn_ty) => {
@@ -631,7 +639,7 @@ impl InferenceTable<'_> {
     /// Coerce a type using `from_ty: CoerceUnsized<ty_ty>`
     ///
     /// See: <https://doc.rust-lang.org/nightly/std/marker/trait.CoerceUnsized.html>
-    fn try_coerce_unsized(&mut self, from_ty: &Ty, to_ty: &Ty) -> CoerceResult {
+    fn try_coerce_unsized(&mut self, from_ty: &Ty, to_ty: &Ty) -> CoerceResult<'db> {
         // These 'if' statements require some explanation.
         // The `CoerceUnsized` trait is special - it is only
         // possible to write `impl CoerceUnsized<B> for A` where
@@ -707,12 +715,9 @@ impl InferenceTable<'_> {
 
         let goal: Goal = coerce_unsized_tref.cast(Interner);
 
-        self.commit_if_ok(|table| {
-            match table.solve_obligation(goal) {
-                Ok(Certainty::Yes) => Ok(()),
-                Ok(Certainty::Maybe(_)) => Ok(()),
-                Err(_) => Err(TypeError),
-            }
+        self.commit_if_ok(|table| match table.solve_obligation(goal) {
+            Ok(Certainty::Yes) => Ok(()),
+            _ => Err(TypeError),
         })?;
 
         let unsize =
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
index e39f3ab75f16f..bfeb5bae851a5 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
@@ -23,9 +23,29 @@ use stdx::always;
 use syntax::ast::RangeOp;
 
 use crate::{
-    autoderef::{builtin_deref, deref_by_trait, Autoderef}, consteval, generics::generics, infer::{
-        coerce::{CoerceMany, CoerceNever, CoercionCause}, find_continuable, pat::contains_explicit_ref_binding, BreakableKind
-    }, lang_items::lang_items_for_bin_op, lower::{lower_to_chalk_mutability, path::{substs_from_args_and_bindings, GenericArgsLowerer, TypeLikeConst}, ParamLoweringMode}, mapping::{from_chalk, ToChalk}, method_resolution::{self, VisibleFromModule}, next_solver::mapping::ChalkToNextSolver, primitive::{self, UintTy}, static_lifetime, to_chalk_trait_id, traits::FnTrait, Adjust, Adjustment, AdtId, AutoBorrow, Binders, CallableDefId, CallableSig, DeclContext, DeclOrigin, IncorrectGenericsLenKind, Interner, LifetimeElisionKind, Rawness, Scalar, Substitution, TraitEnvironment, TraitRef, Ty, TyBuilder, TyExt, TyKind
+    Adjust, Adjustment, AdtId, AutoBorrow, Binders, CallableDefId, CallableSig, DeclContext,
+    DeclOrigin, IncorrectGenericsLenKind, Interner, LifetimeElisionKind, Rawness, Scalar,
+    Substitution, TraitEnvironment, TraitRef, Ty, TyBuilder, TyExt, TyKind,
+    autoderef::{Autoderef, builtin_deref, deref_by_trait},
+    consteval,
+    generics::generics,
+    infer::{
+        BreakableKind,
+        coerce::{CoerceMany, CoerceNever, CoercionCause},
+        find_continuable,
+        pat::contains_explicit_ref_binding,
+    },
+    lang_items::lang_items_for_bin_op,
+    lower::{
+        ParamLoweringMode, lower_to_chalk_mutability,
+        path::{GenericArgsLowerer, TypeLikeConst, substs_from_args_and_bindings},
+    },
+    mapping::{ToChalk, from_chalk},
+    method_resolution::{self, VisibleFromModule},
+    next_solver::mapping::ChalkToNextSolver,
+    primitive::{self, UintTy},
+    static_lifetime, to_chalk_trait_id,
+    traits::FnTrait,
 };
 
 use super::{
@@ -383,7 +403,7 @@ impl InferenceContext<'_> {
                     let matchee_diverges = mem::replace(&mut self.diverges, Diverges::Maybe);
                     let mut all_arms_diverge = Diverges::Always;
                     for arm in arms.iter() {
-                        let input_ty = self.resolve_ty_shallow(&input_ty);
+                        let input_ty = self.table.structurally_resolve_type(&input_ty);
                         self.infer_top_pat(arm.pat, &input_ty, None);
                     }
 
@@ -633,7 +653,7 @@ impl InferenceContext<'_> {
             &Expr::Box { expr } => self.infer_expr_box(expr, expected),
             Expr::UnaryOp { expr, op } => {
                 let inner_ty = self.infer_expr_inner(*expr, &Expectation::none(), ExprIsRead::Yes);
-                let inner_ty = self.resolve_ty_shallow(&inner_ty);
+                let inner_ty = self.table.structurally_resolve_type(&inner_ty);
                 // FIXME: Note down method resolution her
                 match op {
                     UnaryOp::Deref => {
@@ -651,7 +671,7 @@ impl InferenceContext<'_> {
                             );
                         }
                         if let Some(derefed) = builtin_deref(self.table.db, &inner_ty, true) {
-                            self.resolve_ty_shallow(derefed)
+                            self.table.structurally_resolve_type(derefed)
                         } else {
                             deref_by_trait(&mut self.table, inner_ty, false)
                                 .unwrap_or_else(|| self.err_ty())
@@ -807,10 +827,10 @@ impl InferenceContext<'_> {
                 let index_ty = self.infer_expr(*index, &Expectation::none(), ExprIsRead::Yes);
 
                 if let Some(index_trait) = self.resolve_lang_trait(LangItem::Index) {
-                    let canonicalized = ChalkToNextSolver::from_nextsolver(self.canonicalize(base_ty.clone().to_nextsolver(self.table.interner)), self.table.interner);
+                    let canonicalized =
+                        self.canonicalize(base_ty.clone().to_nextsolver(self.table.interner));
                     let receiver_adjustments = method_resolution::resolve_indexing_op(
-                        self.db,
-                        self.table.trait_env.clone(),
+                        &mut self.table,
                         canonicalized,
                         index_trait,
                     );
@@ -983,7 +1003,7 @@ impl InferenceContext<'_> {
                     // allows them to be inferred based on how they are used later in the
                     // function.
                     if is_input {
-                        let ty = this.resolve_ty_shallow(&ty);
+                        let ty = this.table.structurally_resolve_type(&ty);
                         match ty.kind(Interner) {
                             TyKind::FnDef(def, parameters) => {
                                 let fnptr_ty = TyKind::Function(
@@ -1405,9 +1425,10 @@ impl InferenceContext<'_> {
             // use knowledge of built-in binary ops, which can sometimes help inference
             let builtin_ret = self.enforce_builtin_binop_types(&lhs_ty, &rhs_ty, op);
             self.unify(&builtin_ret, &ret_ty);
+            builtin_ret
+        } else {
+            ret_ty
         }
-
-        ret_ty
     }
 
     fn infer_block(
@@ -1660,7 +1681,8 @@ impl InferenceContext<'_> {
             None => {
                 // no field found, lets attempt to resolve it like a function so that IDE things
                 // work out while people are typing
-                let canonicalized_receiver = self.canonicalize(receiver_ty.clone().to_nextsolver(self.table.interner));
+                let canonicalized_receiver =
+                    self.canonicalize(receiver_ty.clone().to_nextsolver(self.table.interner));
                 let resolved = method_resolution::lookup_method(
                     self.db,
                     &canonicalized_receiver,
@@ -1806,7 +1828,8 @@ impl InferenceContext<'_> {
         expected: &Expectation,
     ) -> Ty {
         let receiver_ty = self.infer_expr_inner(receiver, &Expectation::none(), ExprIsRead::Yes);
-        let canonicalized_receiver = self.canonicalize(receiver_ty.clone().to_nextsolver(self.table.interner));
+        let canonicalized_receiver =
+            self.canonicalize(receiver_ty.clone().to_nextsolver(self.table.interner));
 
         let resolved = method_resolution::lookup_method(
             self.db,
@@ -2216,7 +2239,7 @@ impl InferenceContext<'_> {
     }
 
     fn register_obligations_for_call(&mut self, callable_ty: &Ty) {
-        let callable_ty = self.resolve_ty_shallow(callable_ty);
+        let callable_ty = self.table.structurally_resolve_type(callable_ty);
         if let TyKind::FnDef(fn_def, parameters) = callable_ty.kind(Interner) {
             let def: CallableDefId = from_chalk(self.db, *fn_def);
             let generic_predicates =
@@ -2305,9 +2328,9 @@ impl InferenceContext<'_> {
 
     /// Dereferences a single level of immutable referencing.
     fn deref_ty_if_possible(&mut self, ty: &Ty) -> Ty {
-        let ty = self.resolve_ty_shallow(ty);
+        let ty = self.table.structurally_resolve_type(ty);
         match ty.kind(Interner) {
-            TyKind::Ref(Mutability::Not, _, inner) => self.resolve_ty_shallow(inner),
+            TyKind::Ref(Mutability::Not, _, inner) => self.table.structurally_resolve_type(inner),
             _ => ty,
         }
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/pat.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/pat.rs
index 707bec0fce4ce..16489e3068f35 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/pat.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/pat.rs
@@ -190,7 +190,7 @@ impl InferenceContext<'_> {
         subs: &[PatId],
         decl: Option<DeclContext>,
     ) -> Ty {
-        let expected = self.resolve_ty_shallow(expected);
+        let expected = self.table.structurally_resolve_type(expected);
         let expectations = match expected.as_tuple() {
             Some(parameters) => parameters.as_slice(Interner),
             _ => &[],
@@ -238,7 +238,7 @@ impl InferenceContext<'_> {
         mut default_bm: BindingMode,
         decl: Option<DeclContext>,
     ) -> Ty {
-        let mut expected = self.resolve_ty_shallow(expected);
+        let mut expected = self.table.structurally_resolve_type(expected);
 
         if matches!(&self.body[pat], Pat::Ref { .. }) || self.inside_assignment {
             cov_mark::hit!(match_ergonomics_ref);
@@ -251,7 +251,7 @@ impl InferenceContext<'_> {
             let mut pat_adjustments = Vec::new();
             while let Some((inner, _lifetime, mutability)) = expected.as_reference() {
                 pat_adjustments.push(expected.clone());
-                expected = self.resolve_ty_shallow(inner);
+                expected = self.table.structurally_resolve_type(inner);
                 default_bm = match default_bm {
                     BindingMode::Move => BindingMode::Ref(mutability),
                     BindingMode::Ref(Mutability::Not) => BindingMode::Ref(Mutability::Not),
@@ -494,7 +494,7 @@ impl InferenceContext<'_> {
         default_bm: BindingMode,
         decl: Option<DeclContext>,
     ) -> Ty {
-        let expected = self.resolve_ty_shallow(expected);
+        let expected = self.table.structurally_resolve_type(expected);
 
         // If `expected` is an infer ty, we try to equate it to an array if the given pattern
         // allows it. See issue #16609
@@ -506,7 +506,7 @@ impl InferenceContext<'_> {
             self.unify(&expected, &resolved_array_ty);
         }
 
-        let expected = self.resolve_ty_shallow(&expected);
+        let expected = self.table.structurally_resolve_type(&expected);
         let elem_ty = match expected.kind(Interner) {
             TyKind::Array(st, _) | TyKind::Slice(st) => st.clone(),
             _ => self.err_ty(),
@@ -542,7 +542,7 @@ impl InferenceContext<'_> {
         if let Expr::Literal(Literal::ByteString(_)) = self.body[expr]
             && let Some((inner, ..)) = expected.as_reference()
         {
-            let inner = self.resolve_ty_shallow(inner);
+            let inner = self.table.structurally_resolve_type(inner);
             if matches!(inner.kind(Interner), TyKind::Slice(_)) {
                 let elem_ty = TyKind::Scalar(Scalar::Uint(UintTy::U8)).intern(Interner);
                 let slice_ty = TyKind::Slice(elem_ty).intern(Interner);
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs
index 9f3cd2b8fb006..1f62f9c4aa113 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs
@@ -10,7 +10,15 @@ use hir_expand::name::Name;
 use stdx::never;
 
 use crate::{
-    builder::ParamKind, consteval, error_lifetime, generics::generics, infer::diagnostics::InferenceTyLoweringContext as TyLoweringContext, method_resolution::{self, VisibleFromModule}, next_solver::mapping::ChalkToNextSolver, to_chalk_trait_id, InferenceDiagnostic, Interner, LifetimeElisionKind, Substitution, TraitRef, TraitRefExt, Ty, TyBuilder, TyExt, TyKind, ValueTyDefId
+    InferenceDiagnostic, Interner, LifetimeElisionKind, Substitution, TraitRef, TraitRefExt, Ty,
+    TyBuilder, TyExt, TyKind, ValueTyDefId,
+    builder::ParamKind,
+    consteval, error_lifetime,
+    generics::generics,
+    infer::diagnostics::InferenceTyLoweringContext as TyLoweringContext,
+    method_resolution::{self, VisibleFromModule},
+    next_solver::mapping::ChalkToNextSolver,
+    to_chalk_trait_id,
 };
 
 use super::{ExprOrPatId, InferenceContext, InferenceTyDiagnosticSource};
@@ -384,7 +392,7 @@ impl InferenceContext<'_> {
         name: &Name,
         id: ExprOrPatId,
     ) -> Option<(ValueNs, Substitution)> {
-        let ty = self.resolve_ty_shallow(ty);
+        let ty = self.table.structurally_resolve_type(ty);
         let (enum_id, subst) = match ty.as_adt() {
             Some((AdtId::EnumId(e), subst)) => (e, subst),
             _ => return None,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
index 3745d2c98fd9f..ec4b7ee85dc67 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
@@ -3,7 +3,8 @@
 use std::{fmt, mem};
 
 use chalk_ir::{
-    cast::Cast, fold::TypeFoldable, interner::HasInterner, CanonicalVarKind, FloatTy, IntTy, TyVariableKind,
+    CanonicalVarKind, FloatTy, IntTy, TyVariableKind, cast::Cast, fold::TypeFoldable,
+    interner::HasInterner,
 };
 use either::Either;
 use hir_def::{AdtId, lang_item::LangItem};
@@ -11,13 +12,36 @@ use hir_expand::name::Name;
 use intern::sym;
 use rustc_hash::{FxHashMap, FxHashSet};
 use rustc_next_trait_solver::solve::HasChanged;
-use rustc_type_ir::{inherent::Span, relate::{solver_relating::RelateExt, Relate}, solve::{Certainty, NoSolution}, FloatVid, IntVid, TyVid};
+use rustc_type_ir::{
+    AliasRelationDirection, FloatVid, IntVid, TyVid,
+    inherent::{Span, Term as _},
+    relate::{Relate, solver_relating::RelateExt},
+    solve::{Certainty, NoSolution},
+};
 use smallvec::SmallVec;
 use triomphe::Arc;
 
 use super::{InferOk, InferResult, InferenceContext, TypeError};
 use crate::{
-    consteval::unknown_const, db::HirDatabase, fold_generic_args, fold_tys_and_consts, next_solver::{infer::{canonical::canonicalizer::OriginalQueryValues, snapshot::CombinedSnapshot, DbInternerInferExt, InferCtxt}, mapping::{ChalkToNextSolver, InferenceVarExt}, DbInterner, ParamEnvAnd, SolverDefIds}, to_chalk_trait_id, traits::{next_trait_solve, next_trait_solve_canonical, next_trait_solve_in_ctxt, FnTrait, NextTraitSolveResult}, AliasEq, AliasTy, BoundVar, Canonical, Const, ConstValue, DebruijnIndex, DomainGoal, GenericArg, GenericArgData, Goal, GoalData, InEnvironment, InferenceVar, Interner, Lifetime, OpaqueTyId, ParamKind, ProjectionTy, ProjectionTyExt, Scalar, Substitution, TraitEnvironment, TraitRef, Ty, TyBuilder, TyExt, TyKind, VariableKind, WhereClause
+    AliasEq, AliasTy, BoundVar, Canonical, Const, ConstValue, DebruijnIndex, DomainGoal,
+    GenericArg, GenericArgData, Goal, GoalData, InEnvironment, InferenceVar, Interner, Lifetime,
+    OpaqueTyId, ParamKind, ProjectionTy, ProjectionTyExt, Scalar, Substitution, TraitEnvironment,
+    TraitRef, Ty, TyBuilder, TyExt, TyKind, VariableKind, WhereClause,
+    consteval::unknown_const,
+    db::HirDatabase,
+    fold_generic_args, fold_tys_and_consts,
+    next_solver::{
+        self, Binder, DbInterner, ParamEnvAnd, Predicate, PredicateKind, SolverDefIds, Term,
+        infer::{
+            DbInternerInferExt, InferCtxt, canonical::canonicalizer::OriginalQueryValues,
+            snapshot::CombinedSnapshot,
+        },
+        mapping::{ChalkToNextSolver, InferenceVarExt, NextSolverToChalk},
+    },
+    to_chalk_trait_id,
+    traits::{
+        FnTrait, NextTraitSolveResult, next_trait_solve_canonical_in_ctxt, next_trait_solve_in_ctxt,
+    },
 };
 
 impl<'db> InferenceContext<'db> {
@@ -38,7 +62,7 @@ impl<'db> InferenceContext<'db> {
         let pending_obligations = mem::take(&mut self.table.pending_obligations);
         let obligations = pending_obligations
             .iter()
-            .filter_map(|obligation| match obligation.goal.data(Interner) {
+            .filter_map(|obligation| match obligation.to_chalk(self.table.interner).goal.data(Interner) {
                 GoalData::DomainGoal(DomainGoal::Holds(clause)) => {
                     let ty = match clause {
                         WhereClause::AliasEq(AliasEq {
@@ -67,51 +91,6 @@ impl<'db> InferenceContext<'db> {
     }
 }
 
-#[derive(Debug, Clone)]
-pub(crate) struct Canonicalized<T>
-where
-    T: HasInterner<Interner = Interner>,
-{
-    pub(crate) value: Canonical<T>,
-    free_vars: Vec<GenericArg>,
-}
-
-impl<T: HasInterner<Interner = Interner>> Canonicalized<T> {
-    pub(crate) fn apply_solution(
-        &self,
-        ctx: &mut InferenceTable<'_>,
-        solution: Canonical<Substitution>,
-    ) {
-        // the solution may contain new variables, which we need to convert to new inference vars
-        let new_vars = Substitution::from_iter(
-            Interner,
-            solution.binders.iter(Interner).map(|k| match &k.kind {
-                VariableKind::Ty(TyVariableKind::General) => ctx.new_type_var().cast(Interner),
-                VariableKind::Ty(TyVariableKind::Integer) => ctx.new_integer_var().cast(Interner),
-                VariableKind::Ty(TyVariableKind::Float) => ctx.new_float_var().cast(Interner),
-                // Chalk can sometimes return new lifetime variables. We just replace them by errors
-                // for now.
-                VariableKind::Lifetime => ctx.new_lifetime_var().cast(Interner),
-                VariableKind::Const(ty) => ctx.new_const_var(ty.clone()).cast(Interner),
-            }),
-        );
-        for (i, v) in solution.value.iter(Interner).enumerate() {
-            let var = &self.free_vars[i];
-            if let Some(ty) = v.ty(Interner) {
-                // eagerly replace projections in the type; we may be getting types
-                // e.g. from where clauses where this hasn't happened yet
-                let ty = ctx.normalize_associated_types_in(new_vars.apply(ty.clone(), Interner));
-                tracing::debug!("unifying {:?} {:?}", var, ty);
-                ctx.unify(var.assert_ty_ref(Interner), &ty);
-            } else {
-                let v = new_vars.apply(v.clone(), Interner);
-                tracing::debug!("try_unifying {:?} {:?}", var, v);
-                let _ = ctx.try_unify(var, &v);
-            }
-        }
-    }
-}
-
 /// Check if types unify.
 ///
 /// Note that we consider placeholder types to unify with everything.
@@ -207,23 +186,21 @@ bitflags::bitflags! {
     }
 }
 
-type ChalkInferenceTable = chalk_solve::infer::InferenceTable<Interner>;
-
 #[derive(Clone)]
 pub(crate) struct InferenceTable<'a> {
     pub(crate) db: &'a dyn HirDatabase,
     pub(crate) interner: DbInterner<'a>,
     pub(crate) trait_env: Arc<TraitEnvironment>,
     pub(crate) tait_coercion_table: Option<FxHashMap<OpaqueTyId, Ty>>,
-    infer_ctxt: InferCtxt<'a>,
+    pub(crate) infer_ctxt: InferCtxt<'a>,
     diverging_tys: FxHashSet<Ty>,
-    pending_obligations: Vec<InEnvironment<Goal>>,
+    pending_obligations: Vec<next_solver::Goal<'a, next_solver::Predicate<'a>>>,
 }
 
-pub(crate) struct InferenceTableSnapshot {
+pub(crate) struct InferenceTableSnapshot<'a> {
     ctxt_snapshot: CombinedSnapshot,
     diverging_tys: FxHashSet<Ty>,
-    pending_obligations: Vec<InEnvironment<Goal>>,
+    pending_obligations: Vec<next_solver::Goal<'a, next_solver::Predicate<'a>>>,
 }
 
 impl<'a> InferenceTable<'a> {
@@ -234,7 +211,9 @@ impl<'a> InferenceTable<'a> {
             interner,
             trait_env,
             tait_coercion_table: None,
-            infer_ctxt: interner.infer_ctxt().build(rustc_type_ir::TypingMode::Analysis { defining_opaque_types_and_generators: SolverDefIds::new_from_iter(interner, []) }),
+            infer_ctxt: interner.infer_ctxt().build(rustc_type_ir::TypingMode::Analysis {
+                defining_opaque_types_and_generators: SolverDefIds::new_from_iter(interner, []),
+            }),
             diverging_tys: FxHashSet::default(),
             pending_obligations: Vec::new(),
         }
@@ -250,40 +229,55 @@ impl<'a> InferenceTable<'a> {
         let mut new_tys = FxHashSet::default();
         for ty in self.diverging_tys.iter() {
             match ty.kind(Interner) {
-                TyKind::InferenceVar(var, kind) => {
-                    match kind {
-                        TyVariableKind::General => {
-                            let root = InferenceVar::from(self.infer_ctxt.root_var(TyVid::from_u32(var.index())).as_u32());
-                            if root.index() != var.index() {
-                                new_tys.insert(TyKind::InferenceVar(root, *kind).intern(Interner));
-                            }
+                TyKind::InferenceVar(var, kind) => match kind {
+                    TyVariableKind::General => {
+                        let root = InferenceVar::from(
+                            self.infer_ctxt.root_var(TyVid::from_u32(var.index())).as_u32(),
+                        );
+                        if root.index() != var.index() {
+                            new_tys.insert(TyKind::InferenceVar(root, *kind).intern(Interner));
                         }
-                        TyVariableKind::Integer => {
-                            let root = InferenceVar::from(self.infer_ctxt.inner.borrow_mut().int_unification_table().find(IntVid::from_usize(var.index() as usize)).as_u32());
-                            if root.index() != var.index() {
-                                new_tys.insert(TyKind::InferenceVar(root, *kind).intern(Interner));
-                            }
+                    }
+                    TyVariableKind::Integer => {
+                        let root = InferenceVar::from(
+                            self.infer_ctxt
+                                .inner
+                                .borrow_mut()
+                                .int_unification_table()
+                                .find(IntVid::from_usize(var.index() as usize))
+                                .as_u32(),
+                        );
+                        if root.index() != var.index() {
+                            new_tys.insert(TyKind::InferenceVar(root, *kind).intern(Interner));
                         }
-                        TyVariableKind::Float => {
-                            let root = InferenceVar::from(self.infer_ctxt.inner.borrow_mut().float_unification_table().find(FloatVid::from_usize(var.index() as usize)).as_u32());
-                            if root.index() != var.index() {
-                                new_tys.insert(TyKind::InferenceVar(root, *kind).intern(Interner));
-                            }
+                    }
+                    TyVariableKind::Float => {
+                        let root = InferenceVar::from(
+                            self.infer_ctxt
+                                .inner
+                                .borrow_mut()
+                                .float_unification_table()
+                                .find(FloatVid::from_usize(var.index() as usize))
+                                .as_u32(),
+                        );
+                        if root.index() != var.index() {
+                            new_tys.insert(TyKind::InferenceVar(root, *kind).intern(Interner));
                         }
                     }
-                }
+                },
                 _ => {}
             }
         }
-        self.diverging_tys.extend(new_tys.into_iter());
+        self.diverging_tys.extend(new_tys);
     }
 
-    pub(super) fn set_diverging(&mut self, iv: InferenceVar, kind: TyVariableKind, diverging: bool) {
+    pub(super) fn set_diverging(&mut self, iv: InferenceVar, kind: TyVariableKind) {
         self.diverging_tys.insert(TyKind::InferenceVar(iv, kind).intern(Interner));
     }
 
     fn fallback_value(&self, iv: InferenceVar, kind: TyVariableKind) -> Ty {
-        let is_diverging = self.diverging_tys.contains(&TyKind::InferenceVar(iv, kind).intern(Interner));
+        let is_diverging =
+            self.diverging_tys.contains(&TyKind::InferenceVar(iv, kind).intern(Interner));
         if is_diverging {
             return TyKind::Never.intern(Interner);
         }
@@ -295,19 +289,6 @@ impl<'a> InferenceTable<'a> {
         .intern(Interner)
     }
 
-    pub(crate) fn canonicalize_with_free_vars<T>(&mut self, t: ParamEnvAnd<'a, T>) -> (rustc_type_ir::Canonical<DbInterner<'a>, ParamEnvAnd<'a, T>>, OriginalQueryValues<'a>)
-    where
-        T: rustc_type_ir::TypeFoldable<DbInterner<'a>>,
-    {
-        // try to resolve obligations before canonicalizing, since this might
-        // result in new knowledge about variables
-        self.resolve_obligations_as_possible();
-
-        let mut orig_values = OriginalQueryValues::default();
-        let result = self.infer_ctxt.canonicalize_query(t, &mut orig_values);
-        (result.canonical, orig_values)
-    }
-
     pub(crate) fn canonicalize<T>(&mut self, t: T) -> rustc_type_ir::Canonical<DbInterner<'a>, T>
     where
         T: rustc_type_ir::TypeFoldable<DbInterner<'a>>,
@@ -341,7 +322,7 @@ impl<'a> InferenceTable<'a> {
                             self.resolve_ty_shallow(&ty)
                         }
                         TyKind::AssociatedType(id, subst) => {
-                            return Either::Left(self.resolve_ty_shallow(&ty));
+                            // return Either::Left(self.resolve_ty_shallow(&ty));
                             if ty.data(Interner).flags.intersects(
                                 chalk_ir::TypeFlags::HAS_TY_INFER
                                     | chalk_ir::TypeFlags::HAS_CT_INFER,
@@ -365,51 +346,44 @@ impl<'a> InferenceTable<'a> {
                             );
                             let in_env = InEnvironment::new(&self.trait_env.env, goal);
                             let goal = in_env.to_nextsolver(self.interner);
-                            let goal = ParamEnvAnd { param_env: goal.param_env, value: goal.predicate };
+                            let goal =
+                                ParamEnvAnd { param_env: goal.param_env, value: goal.predicate };
 
-                            let (canonical_goal, _orig_values) = {
+                            let (canonical_goal, orig_values) = {
                                 let mut orig_values = OriginalQueryValues::default();
-                                let result = self.infer_ctxt.canonicalize_query(goal, &mut orig_values);
+                                let result =
+                                    self.infer_ctxt.canonicalize_query(goal, &mut orig_values);
                                 (result.canonical, orig_values)
                             };
                             let canonical_goal = rustc_type_ir::Canonical {
                                 max_universe: canonical_goal.max_universe,
                                 variables: canonical_goal.variables,
-                                value: crate::next_solver::Goal { param_env: canonical_goal.value.param_env, predicate: canonical_goal.value.value },
+                                value: crate::next_solver::Goal {
+                                    param_env: canonical_goal.value.param_env,
+                                    predicate: canonical_goal.value.value,
+                                },
                             };
-                            let solution = next_trait_solve_canonical(
-                                self.db,
-                                self.trait_env.krate,
-                                self.trait_env.block,
-                                canonical_goal.clone(),
+                            let solution = next_trait_solve_canonical_in_ctxt(
+                                &self.infer_ctxt,
+                                canonical_goal,
                             );
                             if let NextTraitSolveResult::Certain(canonical_subst) = solution {
-                                // This is not great :) But let's just assert this for now and come back to it later.
-                                if canonical_subst.value.subst.len(Interner) != 1 {
+                                let subst = self.instantiate_canonical(canonical_subst).subst;
+                                if subst.len(Interner) != orig_values.var_values.len() {
                                     ty
                                 } else {
-                                    let normalized = canonical_subst.value.subst.as_slice(Interner)
-                                        [0]
-                                    .assert_ty_ref(Interner);
-                                    match normalized.kind(Interner) {
-                                        TyKind::Alias(AliasTy::Projection(proj_ty)) => {
-                                            if id == &proj_ty.associated_ty_id
-                                                && subst == &proj_ty.substitution
-                                            {
-                                                ty
-                                            } else {
-                                                normalized.clone()
-                                            }
-                                        }
-                                        TyKind::AssociatedType(new_id, new_subst) => {
-                                            if new_id == id && new_subst == subst {
-                                                ty
+                                    let target_ty = var.to_nextsolver(self.interner);
+                                    subst
+                                        .iter(Interner)
+                                        .zip(orig_values.var_values.iter())
+                                        .find_map(|(new, orig)| {
+                                            if orig.ty() == Some(target_ty) {
+                                                Some(new.assert_ty_ref(Interner).clone())
                                             } else {
-                                                normalized.clone()
+                                                None
                                             }
-                                        }
-                                        _ => normalized.clone(),
-                                    }
+                                        })
+                                        .unwrap_or(ty)
                                 }
                             } else {
                                 ty
@@ -504,8 +478,8 @@ impl<'a> InferenceTable<'a> {
     pub(crate) fn normalize_projection_ty(&mut self, proj_ty: ProjectionTy) -> Ty {
         let var = self.new_type_var();
         let alias_eq = AliasEq { alias: AliasTy::Projection(proj_ty), ty: var.clone() };
-        let obligation = alias_eq.cast(Interner);
-        self.register_obligation(obligation);
+        let obligation: Goal = alias_eq.cast(Interner);
+        self.register_obligation(obligation.to_nextsolver(self.interner));
         var
     }
 
@@ -575,7 +549,9 @@ impl<'a> InferenceTable<'a> {
         Substitution::from_iter(
             Interner,
             binders.iter().map(|kind| match &kind.kind {
-                chalk_ir::VariableKind::Ty(ty_variable_kind) => self.new_var(*ty_variable_kind, false).cast(Interner),
+                chalk_ir::VariableKind::Ty(ty_variable_kind) => {
+                    self.new_var(*ty_variable_kind, false).cast(Interner)
+                }
                 chalk_ir::VariableKind::Lifetime => self.new_lifetime_var().cast(Interner),
                 chalk_ir::VariableKind::Const(ty) => self.new_const_var(ty.clone()).cast(Interner),
             }),
@@ -589,8 +565,11 @@ impl<'a> InferenceTable<'a> {
         let subst = self.fresh_subst(canonical.binders.as_slice(Interner));
         subst.apply(canonical.value, Interner)
     }
-    
-    pub(crate) fn instantiate_canonical_ns<T>(&mut self, canonical: rustc_type_ir::Canonical<DbInterner<'a>, T>) -> T
+
+    pub(crate) fn instantiate_canonical_ns<T>(
+        &mut self,
+        canonical: rustc_type_ir::Canonical<DbInterner<'a>, T>,
+    ) -> T
     where
         T: rustc_type_ir::TypeFoldable<DbInterner<'a>>,
     {
@@ -605,7 +584,7 @@ impl<'a> InferenceTable<'a> {
     where
         T: HasInterner<Interner = Interner> + TypeFoldable<Interner>,
     {
-        let mut var_stack = &mut vec![];
+        let var_stack = &mut vec![];
         t.fold_with(
             &mut resolve::Resolver { table: self, var_stack, fallback },
             DebruijnIndex::INNERMOST,
@@ -618,6 +597,7 @@ impl<'a> InferenceTable<'a> {
     {
         let t = self.resolve_with_fallback(t, &|_, _, d, _| d);
         let t = self.normalize_associated_types_in(t);
+        // let t = self.resolve_opaque_tys_in(t);
         // Resolve again, because maybe normalization inserted infer vars.
         self.resolve_with_fallback(t, &|_, _, d, _| d)
     }
@@ -650,7 +630,7 @@ impl<'a> InferenceTable<'a> {
         }
         let float_vars = self.infer_ctxt.inner.borrow_mut().float_unification_table().len();
         for v in 0..float_vars {
-            let var = InferenceVar::from(v as u32).to_ty(Interner, TyVariableKind::Integer);
+            let var = InferenceVar::from(v as u32).to_ty(Interner, TyVariableKind::Float);
             let maybe_resolved = self.resolve_ty_shallow(&var);
             if let TyKind::InferenceVar(_, kind) = maybe_resolved.kind(Interner) {
                 // I don't think we can ever unify these vars with float vars, but keep this here for now
@@ -665,7 +645,11 @@ impl<'a> InferenceTable<'a> {
     }
 
     /// Unify two relatable values (e.g. `Ty`) and register new trait goals that arise from that.
-    pub(crate) fn unify<T: ChalkToNextSolver<'a, U>, U: Relate<DbInterner<'a>>>(&mut self, ty1: &T, ty2: &T) -> bool {
+    pub(crate) fn unify<T: ChalkToNextSolver<'a, U>, U: Relate<DbInterner<'a>>>(
+        &mut self,
+        ty1: &T,
+        ty2: &T,
+    ) -> bool {
         let result = match self.try_unify(ty1, ty2) {
             Ok(r) => r,
             Err(_) => return false,
@@ -675,17 +659,17 @@ impl<'a> InferenceTable<'a> {
     }
 
     /// Unify two relatable values (e.g. `Ty`) and check whether trait goals which arise from that could be fulfilled
-    pub(crate) fn unify_deeply<T: ChalkToNextSolver<'a, U>, U: Relate<DbInterner<'a>>>(&mut self, ty1: &T, ty2: &T) -> bool {
+    pub(crate) fn unify_deeply<T: ChalkToNextSolver<'a, U>, U: Relate<DbInterner<'a>>>(
+        &mut self,
+        ty1: &T,
+        ty2: &T,
+    ) -> bool {
         let result = match self.try_unify(ty1, ty2) {
             Ok(r) => r,
             Err(_) => return false,
         };
-        result.goals.iter().all(|goal| {
-            let goal = goal.to_nextsolver(self.interner);
-            match next_trait_solve_in_ctxt(&self.infer_ctxt, goal) {
-                Ok((_, Certainty::Yes)) => true,
-                _ => false,
-            }
+        result.goals.into_iter().all(|goal| {
+            matches!(next_trait_solve_in_ctxt(&self.infer_ctxt, goal), Ok((_, Certainty::Yes)))
         })
     }
 
@@ -695,20 +679,15 @@ impl<'a> InferenceTable<'a> {
         &mut self,
         t1: &T,
         t2: &T,
-    ) -> InferResult<()> {
+    ) -> InferResult<'a, ()> {
         let param_env = self.trait_env.env.to_nextsolver(self.interner);
         let lhs = t1.to_nextsolver(self.interner);
         let rhs = t2.to_nextsolver(self.interner);
         let variance = rustc_type_ir::Variance::Invariant;
         let span = crate::next_solver::Span::dummy();
         match self.infer_ctxt.relate(param_env, lhs, variance, rhs, span) {
-            Ok(res) => {
-            let goals = res.into_iter().map(|g| ChalkToNextSolver::from_nextsolver(g, self.interner)).collect();
-                Ok(InferOk { goals, value: () })
-            }
-            Err(_) => {
-                Err(TypeError)
-            }
+            Ok(goals) => Ok(InferOk { goals, value: () }),
+            Err(_) => Err(TypeError),
         }
     }
 
@@ -719,19 +698,75 @@ impl<'a> InferenceTable<'a> {
         if !ty.data(Interner).flags.intersects(chalk_ir::TypeFlags::HAS_FREE_LOCAL_NAMES) {
             return ty.clone();
         }
+        self.infer_ctxt
+            .resolve_vars_if_possible(ty.to_nextsolver(self.interner))
+            .to_chalk(self.interner)
+    }
+
+    pub(crate) fn resolve_vars_with_obligations<T>(&mut self, t: T) -> T
+    where
+        T: rustc_type_ir::TypeFoldable<DbInterner<'a>>,
+    {
+        use rustc_type_ir::TypeVisitableExt;
+
+        if !t.has_non_region_infer() {
+            return t;
+        }
+
+        let t = self.infer_ctxt.resolve_vars_if_possible(t);
+
+        if !t.has_non_region_infer() {
+            return t;
+        }
+
+        self.resolve_obligations_as_possible();
+        self.infer_ctxt.resolve_vars_if_possible(t)
+    }
+
+    pub(crate) fn structurally_resolve_type(&mut self, ty: &Ty) -> Ty {
+        if let TyKind::Alias(..) = ty.kind(Interner) {
+            self.structurally_normalize_ty(ty)
+        } else {
+            self.resolve_vars_with_obligations(ty.to_nextsolver(self.interner))
+                .to_chalk(self.interner)
+        }
+    }
+
+    fn structurally_normalize_ty(&mut self, ty: &Ty) -> Ty {
+        self.structurally_normalize_term(ty.to_nextsolver(self.interner).into())
+            .expect_ty()
+            .to_chalk(self.interner)
+    }
+
+    fn structurally_normalize_term(&mut self, term: Term<'a>) -> Term<'a> {
+        if term.to_alias_term().is_none() {
+            return term;
+        }
+
+        let new_infer = self.infer_ctxt.next_term_var_of_kind(term);
+
+        self.register_obligation(Predicate::new(
+            self.interner,
+            Binder::dummy(PredicateKind::AliasRelate(
+                term,
+                new_infer,
+                AliasRelationDirection::Equate,
+            )),
+        ));
         self.resolve_obligations_as_possible();
-        ChalkToNextSolver::from_nextsolver(self.infer_ctxt.resolve_vars_if_possible(ty.to_nextsolver(self.interner)), self.interner)
+        let res = self.infer_ctxt.resolve_vars_if_possible(new_infer);
+        if res == new_infer { term } else { res }
     }
 
-    pub(crate) fn snapshot(&mut self) -> InferenceTableSnapshot {
+    pub(crate) fn snapshot(&mut self) -> InferenceTableSnapshot<'a> {
         let ctxt_snapshot = self.infer_ctxt.start_snapshot();
         let diverging_tys = self.diverging_tys.clone();
         let pending_obligations = self.pending_obligations.clone();
-        InferenceTableSnapshot {ctxt_snapshot, pending_obligations, diverging_tys }
+        InferenceTableSnapshot { ctxt_snapshot, pending_obligations, diverging_tys }
     }
 
     #[tracing::instrument(skip_all)]
-    pub(crate) fn rollback_to(&mut self, snapshot: InferenceTableSnapshot) {
+    pub(crate) fn rollback_to(&mut self, snapshot: InferenceTableSnapshot<'a>) {
         self.infer_ctxt.rollback_to(snapshot.ctxt_snapshot);
         self.diverging_tys = snapshot.diverging_tys;
         self.pending_obligations = snapshot.pending_obligations;
@@ -745,7 +780,10 @@ impl<'a> InferenceTable<'a> {
         result
     }
 
-    pub(crate) fn commit_if_ok<T, E>(&mut self, f: impl FnOnce(&mut InferenceTable<'_>) -> Result<T, E>) -> Result<T, E> {
+    pub(crate) fn commit_if_ok<T, E>(
+        &mut self,
+        f: impl FnOnce(&mut InferenceTable<'_>) -> Result<T, E>,
+    ) -> Result<T, E> {
         let snapshot = self.snapshot();
         let result = f(self);
         match result {
@@ -765,59 +803,31 @@ impl<'a> InferenceTable<'a> {
         let in_env = InEnvironment::new(&self.trait_env.env, goal);
         let canonicalized = self.canonicalize(in_env.to_nextsolver(self.interner));
 
-        next_trait_solve_canonical(self.db, self.trait_env.krate, self.trait_env.block, canonicalized)
+        next_trait_solve_canonical_in_ctxt(&self.infer_ctxt, canonicalized)
     }
-    
+
     #[tracing::instrument(level = "debug", skip(self))]
     pub(crate) fn solve_obligation(&mut self, goal: Goal) -> Result<Certainty, NoSolution> {
         let goal = InEnvironment::new(&self.trait_env.env, goal);
-        let Some(goal) = self.unify_opaque_instead_of_solve(goal) else { 
-            return Ok(Certainty::Yes);
-        };
-
         let goal = goal.to_nextsolver(self.interner);
         let result = next_trait_solve_in_ctxt(&self.infer_ctxt, goal);
         result.map(|m| m.1)
     }
 
-    pub(crate) fn register_obligation(&mut self, goal: Goal) {
-        let in_env = InEnvironment::new(&self.trait_env.env, goal);
-        self.register_obligation_in_env(in_env)
-    }
-
-    // If this goal is an `AliasEq` for an opaque type, just unify instead of trying to solve (since the next-solver is lazy)
-    fn unify_opaque_instead_of_solve(&mut self, goal: InEnvironment<Goal>) -> Option<InEnvironment<Goal>> {
-        match goal.goal.data(Interner) {
-            chalk_ir::GoalData::DomainGoal(chalk_ir::DomainGoal::Holds(
-                chalk_ir::WhereClause::AliasEq(chalk_ir::AliasEq { alias, ty }),
-            )) => {
-                if ty.inference_var(Interner).is_some() {
-                    match alias {
-                        chalk_ir::AliasTy::Opaque(opaque) => {
-                            if self.unify(
-                                &chalk_ir::TyKind::OpaqueType(
-                                    opaque.opaque_ty_id,
-                                    opaque.substitution.clone(),
-                                )
-                                .intern(Interner),
-                                ty,
-                            ) {
-                                return None;
-                            }
-                        }
-                        _ => {}
-                    }
-                }
-            }
-            _ => {}
-        }
-        Some(goal)
+    pub(crate) fn register_obligation(&mut self, predicate: Predicate<'a>) {
+        let goal = next_solver::Goal {
+            param_env: self.trait_env.env.to_nextsolver(self.interner),
+            predicate,
+        };
+        self.register_obligation_in_env(goal)
     }
 
     #[tracing::instrument(level = "debug", skip(self))]
-    fn register_obligation_in_env(&mut self, goal: InEnvironment<Goal>) {
-        let Some(goal) = self.unify_opaque_instead_of_solve(goal) else { return };
-        let result = next_trait_solve_in_ctxt(&self.infer_ctxt, goal.to_nextsolver(self.interner));
+    fn register_obligation_in_env(
+        &mut self,
+        goal: next_solver::Goal<'a, next_solver::Predicate<'a>>,
+    ) {
+        let result = next_trait_solve_in_ctxt(&self.infer_ctxt, goal);
         tracing::debug!(?result);
         match result {
             Ok((_, Certainty::Yes)) => {}
@@ -828,7 +838,7 @@ impl<'a> InferenceTable<'a> {
         }
     }
 
-    pub(crate) fn register_infer_ok<T>(&mut self, infer_ok: InferOk<T>) {
+    pub(crate) fn register_infer_ok<T>(&mut self, infer_ok: InferOk<'a, T>) {
         infer_ok.goals.into_iter().for_each(|goal| self.register_obligation_in_env(goal));
     }
 
@@ -841,12 +851,7 @@ impl<'a> InferenceTable<'a> {
             for goal in obligations.drain(..) {
                 tracing::debug!(obligation = ?goal);
 
-                let Some(goal) = self.unify_opaque_instead_of_solve(goal) else { 
-                    changed = true;
-                    continue;
-                };
-
-                let result = next_trait_solve_in_ctxt(&self.infer_ctxt, goal.to_nextsolver(self.interner));
+                let result = next_trait_solve_in_ctxt(&self.infer_ctxt, goal);
                 let (has_changed, certainty) = match result {
                     Ok(result) => result,
                     Err(_) => {
@@ -934,40 +939,6 @@ impl<'a> InferenceTable<'a> {
             .fold_with(&mut VarFudger { table: self, highest_known_var }, DebruijnIndex::INNERMOST)
     }
 
-    #[tracing::instrument(level = "debug", skip(self))]
-    fn try_resolve_obligation(
-        &mut self,
-        canonicalized: &Canonicalized<InEnvironment<Goal>>,
-    ) -> NextTraitSolveResult {
-        let solution = next_trait_solve(
-            self.db,
-            self.trait_env.krate,
-            self.trait_env.block,
-            canonicalized.value.clone(),
-        );
-
-        tracing::debug!(?solution, ?canonicalized);
-        match &solution {
-            NextTraitSolveResult::Certain(v) => {
-                canonicalized.apply_solution(
-                    self,
-                    Canonical {
-                        binders: v.binders.clone(),
-                        // FIXME handle constraints
-                        value: v.value.subst.clone(),
-                    },
-                );
-            }
-            // ...so, should think about how to get some actually get some guidance here
-            NextTraitSolveResult::Uncertain(v) => {
-                canonicalized.apply_solution(self, v.clone());
-            }
-            NextTraitSolveResult::NoSolution => {}
-        }
-
-        solution
-    }
-
     pub(crate) fn callable_sig(
         &mut self,
         ty: &Ty,
@@ -1027,7 +998,7 @@ impl<'a> InferenceTable<'a> {
 
             let goal: Goal = trait_ref.clone().cast(Interner);
             if !self.try_obligation(goal.clone()).no_solution() {
-                self.register_obligation(goal);
+                self.register_obligation(goal.to_nextsolver(self.interner));
                 let return_ty = self.normalize_projection_ty(projection);
                 for &fn_x in subtraits {
                     let fn_x_trait = fn_x.get_id(self.db, krate)?;
@@ -1067,7 +1038,7 @@ impl<'a> InferenceTable<'a> {
         match ty.kind(Interner) {
             TyKind::Error => self.new_type_var(),
             TyKind::InferenceVar(..) => {
-                let ty_resolved = self.resolve_ty_shallow(&ty);
+                let ty_resolved = self.structurally_resolve_type(&ty);
                 if ty_resolved.is_unknown() { self.new_type_var() } else { ty }
             }
             _ => ty,
@@ -1165,7 +1136,9 @@ impl fmt::Debug for InferenceTable<'_> {
 mod resolve {
     use super::InferenceTable;
     use crate::{
-        next_solver::mapping::ChalkToNextSolver, ConcreteConst, Const, ConstData, ConstScalar, ConstValue, DebruijnIndex, GenericArg, InferenceVar, Interner, Lifetime, Ty, TyVariableKind, VariableKind
+        ConcreteConst, Const, ConstData, ConstScalar, ConstValue, DebruijnIndex, GenericArg,
+        InferenceVar, Interner, Lifetime, Ty, TyVariableKind, VariableKind,
+        next_solver::mapping::NextSolverToChalk,
     };
     use chalk_ir::{
         cast::Cast,
@@ -1220,7 +1193,7 @@ mod resolve {
                             .clone();
                     }
                     if let Ok(known_ty) = self.table.infer_ctxt.probe_ty_var(vid) {
-                        let known_ty: Ty = ChalkToNextSolver::from_nextsolver(known_ty, self.table.interner);
+                        let known_ty: Ty = known_ty.to_chalk(self.table.interner);
                         // known_ty may contain other variables that are known by now
                         self.var_stack.push((var, VarKind::Ty(kind)));
                         let result = known_ty.fold_with(self, outer_binder);
@@ -1234,7 +1207,13 @@ mod resolve {
                     }
                 }
                 TyVariableKind::Integer => {
-                    let vid = self.table.infer_ctxt.inner.borrow_mut().int_unification_table().find(IntVid::from(var.index()));
+                    let vid = self
+                        .table
+                        .infer_ctxt
+                        .inner
+                        .borrow_mut()
+                        .int_unification_table()
+                        .find(IntVid::from(var.index()));
                     let var = InferenceVar::from(vid.as_u32());
                     if self.var_stack.contains(&(var, VarKind::Ty(kind))) {
                         // recursive type
@@ -1244,7 +1223,7 @@ mod resolve {
                             .clone();
                     }
                     if let Some(known_ty) = self.table.infer_ctxt.resolve_int_var(vid) {
-                        let known_ty: Ty = ChalkToNextSolver::from_nextsolver(known_ty, self.table.interner);
+                        let known_ty: Ty = known_ty.to_chalk(self.table.interner);
                         // known_ty may contain other variables that are known by now
                         self.var_stack.push((var, VarKind::Ty(kind)));
                         let result = known_ty.fold_with(self, outer_binder);
@@ -1258,7 +1237,13 @@ mod resolve {
                     }
                 }
                 TyVariableKind::Float => {
-                    let vid = self.table.infer_ctxt.inner.borrow_mut().float_unification_table().find(FloatVid::from(var.index()));
+                    let vid = self
+                        .table
+                        .infer_ctxt
+                        .inner
+                        .borrow_mut()
+                        .float_unification_table()
+                        .find(FloatVid::from(var.index()));
                     let var = InferenceVar::from(vid.as_u32());
                     if self.var_stack.contains(&(var, VarKind::Ty(kind))) {
                         // recursive type
@@ -1268,7 +1253,7 @@ mod resolve {
                             .clone();
                     }
                     if let Some(known_ty) = self.table.infer_ctxt.resolve_float_var(vid) {
-                        let known_ty: Ty = ChalkToNextSolver::from_nextsolver(known_ty, self.table.interner);
+                        let known_ty: Ty = known_ty.to_chalk(self.table.interner);
                         // known_ty may contain other variables that are known by now
                         self.var_stack.push((var, VarKind::Ty(kind)));
                         let result = known_ty.fold_with(self, outer_binder);
@@ -1290,7 +1275,10 @@ mod resolve {
             var: InferenceVar,
             outer_binder: DebruijnIndex,
         ) -> Const {
-            let vid = self.table.infer_ctxt.root_const_var(rustc_type_ir::ConstVid::from_u32(var.index()));
+            let vid = self
+                .table
+                .infer_ctxt
+                .root_const_var(rustc_type_ir::ConstVid::from_u32(var.index()));
             let var = InferenceVar::from(vid.as_u32());
             let default = ConstData {
                 ty: ty.clone(),
@@ -1305,7 +1293,7 @@ mod resolve {
                     .clone();
             }
             if let Ok(known_const) = self.table.infer_ctxt.probe_const_var(vid) {
-                let known_const: Const = ChalkToNextSolver::from_nextsolver(known_const, self.table.interner);
+                let known_const: Const = known_const.to_chalk(self.table.interner);
                 // known_ty may contain other variables that are known by now
                 self.var_stack.push((var, VarKind::Const));
                 let result = known_const.fold_with(self, outer_binder);
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 323ea951a9141..659bc5ade3c79 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
@@ -101,7 +101,10 @@ use crate::{
     display::{DisplayTarget, HirDisplay},
     generics::Generics,
     infer::unify::InferenceTable,
-    next_solver::{DbInterner, mapping::convert_ty_for_result},
+    next_solver::{
+        DbInterner,
+        mapping::{ChalkToNextSolver, convert_ty_for_result},
+    },
 };
 
 pub use autoderef::autoderef;
@@ -957,8 +960,10 @@ pub fn callable_sig_from_fn_trait(
     )
     .build();
 
-    if !table.try_obligation(trait_ref.clone().cast(Interner)).no_solution() {
-        table.register_obligation(trait_ref.clone().cast(Interner));
+    let goal: Goal = trait_ref.clone().cast(Interner);
+    let pred = goal.to_nextsolver(table.interner);
+    if !table.try_obligation(goal).no_solution() {
+        table.register_obligation(pred);
         let return_ty = table.normalize_projection_ty(projection);
         for fn_x in [FnTrait::Fn, FnTrait::FnMut, FnTrait::FnOnce] {
             let fn_x_trait = fn_x.get_id(db, krate)?;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
index ee223059d1e56..fa80567b1ecc0 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
@@ -22,7 +22,25 @@ use stdx::never;
 use triomphe::Arc;
 
 use crate::{
-    autoderef::{self, AutoderefKind}, db::HirDatabase, from_chalk_trait_id, from_foreign_def_id, infer::{unify::InferenceTable, Adjust, Adjustment, OverloadedDeref, PointerCast}, lang_items::is_box, next_solver::{mapping::ChalkToNextSolver, SolverDefId}, primitive::{FloatTy, IntTy, UintTy}, to_chalk_trait_id, traits::{next_trait_solve_canonical}, utils::all_super_traits, AdtId, Canonical, CanonicalVarKinds, DebruijnIndex, DynTyExt, ForeignDefId, GenericArgData, Goal, InEnvironment, Interner, Mutability, Scalar, Substitution, TraitEnvironment, TraitRef, TraitRefExt, Ty, TyBuilder, TyExt, TyKind, TyVariableKind, VariableKind, WhereClause
+    AdtId, AliasTy, Canonical, CanonicalVarKinds, DebruijnIndex, DynTyExt, ForeignDefId,
+    GenericArgData, Goal, InEnvironment, Interner, Mutability, Scalar, Substitution,
+    TraitEnvironment, TraitRef, TraitRefExt, Ty, TyBuilder, TyExt, TyKind, TyVariableKind,
+    VariableKind, WhereClause,
+    autoderef::{self, AutoderefKind},
+    db::HirDatabase,
+    from_chalk_trait_id, from_foreign_def_id,
+    infer::{Adjust, Adjustment, OverloadedDeref, PointerCast, unify::InferenceTable},
+    lang_items::is_box,
+    next_solver::{
+        self, SolverDefId,
+        fulfill::FulfillmentCtxt,
+        infer::DefineOpaqueTypes,
+        mapping::{ChalkToNextSolver, NextSolverToChalk},
+    },
+    primitive::{FloatTy, IntTy, UintTy},
+    to_chalk_trait_id,
+    traits::next_trait_solve_canonical_in_ctxt,
+    utils::all_super_traits,
 };
 
 /// This is used as a key for indexing impls.
@@ -89,6 +107,7 @@ impl TyFingerprint {
             }
             TyKind::AssociatedType(_, _)
             | TyKind::OpaqueType(_, _)
+            | TyKind::Alias(AliasTy::Opaque(_))
             | TyKind::FnDef(_, _)
             | TyKind::Closure(_, _)
             | TyKind::Coroutine(..)
@@ -106,7 +125,7 @@ impl TyFingerprint {
     }
 
     /// Creates a TyFingerprint for looking up a trait impl.
-    pub fn for_trait_impl_ns<'db>(ty: &crate::next_solver::Ty<'db>) -> Option<TyFingerprint> {
+    pub fn for_trait_impl_ns<'db>(ty: &next_solver::Ty<'db>) -> Option<TyFingerprint> {
         use rustc_type_ir::TyKind;
         let fp = match (*ty).kind() {
             TyKind::Str => TyFingerprint::Str,
@@ -523,7 +542,7 @@ pub fn def_crates(db: &dyn HirDatabase, ty: &Ty, cur_crate: Crate) -> Option<Sma
 /// Look up the method with the given name.
 pub(crate) fn lookup_method<'db>(
     db: &'db dyn HirDatabase,
-    ty: &crate::next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
+    ty: &next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
     env: Arc<TraitEnvironment>,
     traits_in_scope: &FxHashSet<TraitId>,
     visible_from_module: VisibleFromModule,
@@ -605,7 +624,7 @@ pub struct ReceiverAdjustments {
 
 impl ReceiverAdjustments {
     pub(crate) fn apply(&self, table: &mut InferenceTable<'_>, ty: Ty) -> (Ty, Vec<Adjustment>) {
-        let mut ty = table.resolve_ty_shallow(&ty);
+        let mut ty = table.structurally_resolve_type(&ty);
         let mut adjust = Vec::new();
         for _ in 0..self.autoderefs {
             match autoderef::autoderef_step(table, ty.clone(), true, false) {
@@ -686,7 +705,7 @@ impl ReceiverAdjustments {
 // lifetime problems, because we need to borrow temp `CrateImplDefs`.
 // FIXME add a context type here?
 pub(crate) fn iterate_method_candidates<'db, T>(
-    ty: &crate::next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
+    ty: &next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
     db: &'db dyn HirDatabase,
     env: Arc<TraitEnvironment>,
     traits_in_scope: &FxHashSet<TraitId>,
@@ -887,7 +906,7 @@ fn find_matching_impl(
                 if table.try_obligation(goal.clone()).no_solution() {
                     return None;
                 }
-                table.register_obligation(goal);
+                table.register_obligation(goal.to_nextsolver(table.interner));
             }
             Some((impl_.impl_items(db), table.resolve_completely(impl_substs)))
         })
@@ -1035,7 +1054,7 @@ pub fn check_orphan_rules(db: &dyn HirDatabase, impl_: ImplId) -> bool {
 }
 
 pub fn iterate_path_candidates<'db>(
-    ty: &crate::next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
+    ty: &next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
     db: &'db dyn HirDatabase,
     env: Arc<TraitEnvironment>,
     traits_in_scope: &FxHashSet<TraitId>,
@@ -1057,7 +1076,7 @@ pub fn iterate_path_candidates<'db>(
 }
 
 pub fn iterate_method_candidates_dyn<'db>(
-    ty: &crate::next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
+    ty: &next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
     db: &'db dyn HirDatabase,
     env: Arc<TraitEnvironment>,
     traits_in_scope: &FxHashSet<TraitId>,
@@ -1096,7 +1115,7 @@ pub fn iterate_method_candidates_dyn<'db>(
             // types*.
 
             let mut table = InferenceTable::new(db, env);
-            let ty = table.instantiate_canonical_ns(ty.clone());
+            let ty = table.instantiate_canonical_ns(*ty);
             let deref_chain = autoderef_method_receiver(&mut table, ty);
 
             deref_chain.into_iter().try_for_each(|(receiver_ty, adj)| {
@@ -1129,18 +1148,13 @@ pub fn iterate_method_candidates_dyn<'db>(
 #[tracing::instrument(skip_all, fields(name = ?name))]
 fn iterate_method_candidates_with_autoref<'db>(
     table: &mut InferenceTable<'db>,
-    receiver_ty: crate::next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
+    receiver_ty: next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
     first_adjustment: ReceiverAdjustments,
     traits_in_scope: &FxHashSet<TraitId>,
     visible_from_module: VisibleFromModule,
     name: Option<&Name>,
     callback: &mut dyn MethodCandidateCallback,
 ) -> ControlFlow<()> {
-    if matches!(receiver_ty.value.kind(), rustc_type_ir::TyKind::Bound(..)) {
-        // don't try to resolve methods on unknown types
-        return ControlFlow::Continue(());
-    }
-
     let interner = table.interner;
 
     let mut iterate_method_candidates_by_receiver = move |receiver_ty, first_adjustment| {
@@ -1166,12 +1180,17 @@ fn iterate_method_candidates_with_autoref<'db>(
         maybe_reborrowed.autoderefs += 1;
     }
 
-    iterate_method_candidates_by_receiver(receiver_ty.clone(), maybe_reborrowed)?;
+    iterate_method_candidates_by_receiver(receiver_ty, maybe_reborrowed)?;
 
-    let refed = crate::next_solver::Canonical {
+    let refed = next_solver::Canonical {
         max_universe: receiver_ty.max_universe,
         variables: receiver_ty.variables,
-        value: crate::next_solver::Ty::new_ref(interner, crate::next_solver::Region::error(interner), receiver_ty.value, rustc_ast_ir::Mutability::Not),
+        value: next_solver::Ty::new_ref(
+            interner,
+            next_solver::Region::error(interner),
+            receiver_ty.value,
+            rustc_ast_ir::Mutability::Not,
+        ),
     };
 
     iterate_method_candidates_by_receiver(
@@ -1179,10 +1198,15 @@ fn iterate_method_candidates_with_autoref<'db>(
         first_adjustment.with_autoref(AutorefOrPtrAdjustment::Autoref(Mutability::Not)),
     )?;
 
-    let ref_muted = crate::next_solver::Canonical {
+    let ref_muted = next_solver::Canonical {
         max_universe: receiver_ty.max_universe,
         variables: receiver_ty.variables,
-        value: crate::next_solver::Ty::new_ref(interner, crate::next_solver::Region::error(interner), receiver_ty.value, rustc_ast_ir::Mutability::Mut),
+        value: next_solver::Ty::new_ref(
+            interner,
+            next_solver::Region::error(interner),
+            receiver_ty.value,
+            rustc_ast_ir::Mutability::Mut,
+        ),
     };
 
     iterate_method_candidates_by_receiver(
@@ -1190,10 +1214,12 @@ fn iterate_method_candidates_with_autoref<'db>(
         first_adjustment.with_autoref(AutorefOrPtrAdjustment::Autoref(Mutability::Mut)),
     )?;
 
-    if let rustc_type_ir::TyKind::RawPtr(ty, rustc_ast_ir::Mutability::Mut) = receiver_ty.value.kind() {
+    if let rustc_type_ir::TyKind::RawPtr(ty, rustc_ast_ir::Mutability::Mut) =
+        receiver_ty.value.kind()
+    {
         let const_ptr_ty = rustc_type_ir::Canonical {
             max_universe: rustc_type_ir::UniverseIndex::ZERO,
-            value: crate::next_solver::Ty::new_ptr(interner, ty, rustc_ast_ir::Mutability::Not),
+            value: next_solver::Ty::new_ptr(interner, ty, rustc_ast_ir::Mutability::Not),
             variables: receiver_ty.variables,
         };
         iterate_method_candidates_by_receiver(
@@ -1247,7 +1273,7 @@ where
 #[tracing::instrument(skip_all, fields(name = ?name))]
 fn iterate_method_candidates_by_receiver<'db>(
     table: &mut InferenceTable<'db>,
-    receiver_ty: crate::next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
+    receiver_ty: next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
     receiver_adjustments: ReceiverAdjustments,
     traits_in_scope: &FxHashSet<TraitId>,
     visible_from_module: VisibleFromModule,
@@ -1255,7 +1281,7 @@ fn iterate_method_candidates_by_receiver<'db>(
     callback: &mut dyn MethodCandidateCallback,
 ) -> ControlFlow<()> {
     let receiver_ty = table.instantiate_canonical_ns(receiver_ty);
-    let receiver_ty: crate::Ty = ChalkToNextSolver::from_nextsolver(receiver_ty, table.interner);
+    let receiver_ty: crate::Ty = receiver_ty.to_chalk(table.interner);
     // We're looking for methods with *receiver* type receiver_ty. These could
     // be found in any of the derefs of receiver_ty, so we have to go through
     // that, including raw derefs.
@@ -1270,6 +1296,7 @@ fn iterate_method_candidates_by_receiver<'db>(
                 Some(&receiver_ty),
                 Some(receiver_adjustments.clone()),
                 visible_from_module,
+                LookupMode::MethodCall,
                 &mut |adjustments, item, is_visible| {
                     callback.on_inherent_method(adjustments, item, is_visible)
                 },
@@ -1293,6 +1320,7 @@ fn iterate_method_candidates_by_receiver<'db>(
                 name,
                 Some(&receiver_ty),
                 Some(receiver_adjustments.clone()),
+                LookupMode::MethodCall,
                 &mut |adjustments, item, is_visible| {
                     callback.on_trait_method(adjustments, item, is_visible)
                 },
@@ -1304,7 +1332,7 @@ fn iterate_method_candidates_by_receiver<'db>(
 
 #[tracing::instrument(skip_all, fields(name = ?name))]
 fn iterate_method_candidates_for_self_ty<'db>(
-    self_ty: &crate::next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
+    self_ty: &next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
     db: &'db dyn HirDatabase,
     env: Arc<TraitEnvironment>,
     traits_in_scope: &FxHashSet<TraitId>,
@@ -1313,7 +1341,7 @@ fn iterate_method_candidates_for_self_ty<'db>(
     callback: &mut dyn MethodCandidateCallback,
 ) -> ControlFlow<()> {
     let mut table = InferenceTable::new(db, env);
-    let self_ty = ChalkToNextSolver::from_nextsolver(table.instantiate_canonical_ns(self_ty.clone()), table.interner);
+    let self_ty = table.instantiate_canonical_ns(*self_ty).to_chalk(table.interner);
     iterate_inherent_methods(
         &self_ty,
         &mut table,
@@ -1321,6 +1349,7 @@ fn iterate_method_candidates_for_self_ty<'db>(
         None,
         None,
         visible_from_module,
+        LookupMode::Path,
         &mut |adjustments, item, is_visible| {
             callback.on_inherent_method(adjustments, item, is_visible)
         },
@@ -1332,6 +1361,7 @@ fn iterate_method_candidates_for_self_ty<'db>(
         name,
         None,
         None,
+        LookupMode::Path,
         &mut |adjustments, item, is_visible| {
             callback.on_trait_method(adjustments, item, is_visible)
         },
@@ -1346,12 +1376,13 @@ fn iterate_trait_method_candidates(
     name: Option<&Name>,
     receiver_ty: Option<&Ty>,
     receiver_adjustments: Option<ReceiverAdjustments>,
+    mode: LookupMode,
     callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId, bool) -> ControlFlow<()>,
 ) -> ControlFlow<()> {
     let db = table.db;
 
-    let canonical_self_ty = ChalkToNextSolver::from_nextsolver(table.canonicalize(self_ty.clone().to_nextsolver(table.interner)), table.interner);
-    let TraitEnvironment { krate, block, .. } = *table.trait_env;
+    let canonical_self_ty = table.canonicalize(self_ty.clone().to_nextsolver(table.interner));
+    let TraitEnvironment { krate, .. } = *table.trait_env;
 
     'traits: for &t in traits_in_scope {
         let data = db.trait_signature(t);
@@ -1391,15 +1422,22 @@ fn iterate_trait_method_candidates(
         for &(_, item) in t.trait_items(db).items.iter() {
             // Don't pass a `visible_from_module` down to `is_valid_candidate`,
             // since only inherent methods should be included into visibility checking.
-            let visible =
-                match is_valid_trait_method_candidate(table, t, name, receiver_ty, item, self_ty) {
-                    IsValidCandidate::Yes => true,
-                    IsValidCandidate::NotVisible => false,
-                    IsValidCandidate::No => continue,
-                };
+            let visible = match is_valid_trait_method_candidate(
+                table,
+                t,
+                name,
+                receiver_ty,
+                item,
+                self_ty,
+                mode,
+            ) {
+                IsValidCandidate::Yes => true,
+                IsValidCandidate::NotVisible => false,
+                IsValidCandidate::No => continue,
+            };
             if !known_implemented {
-                let goal = generic_implements_goal(db, &table.trait_env, t, &canonical_self_ty);
-                if db.trait_solve(krate, block, goal.cast(Interner)).no_solution() {
+                let goal = generic_implements_goal_ns(table, t, canonical_self_ty);
+                if next_trait_solve_canonical_in_ctxt(&table.infer_ctxt, goal).no_solution() {
                     continue 'traits;
                 }
             }
@@ -1418,6 +1456,7 @@ fn iterate_inherent_methods(
     receiver_ty: Option<&Ty>,
     receiver_adjustments: Option<ReceiverAdjustments>,
     visible_from_module: VisibleFromModule,
+    mode: LookupMode,
     callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId, bool) -> ControlFlow<()>,
 ) -> ControlFlow<()> {
     let db = table.db;
@@ -1441,6 +1480,7 @@ fn iterate_inherent_methods(
                 receiver_adjustments.clone(),
                 callback,
                 traits,
+                mode,
             )?;
         }
         TyKind::Dyn(_) => {
@@ -1454,6 +1494,7 @@ fn iterate_inherent_methods(
                     receiver_adjustments.clone(),
                     callback,
                     traits.into_iter(),
+                    mode,
                 )?;
             }
         }
@@ -1512,6 +1553,7 @@ fn iterate_inherent_methods(
         receiver_adjustments: Option<ReceiverAdjustments>,
         callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId, bool) -> ControlFlow<()>,
         traits: impl Iterator<Item = TraitId>,
+        mode: LookupMode,
     ) -> ControlFlow<()> {
         let db = table.db;
         for t in traits {
@@ -1525,6 +1567,7 @@ fn iterate_inherent_methods(
                     receiver_ty,
                     item,
                     self_ty,
+                    mode,
                 ) {
                     IsValidCandidate::Yes => true,
                     IsValidCandidate::NotVisible => false,
@@ -1571,22 +1614,17 @@ fn iterate_inherent_methods(
 }
 
 /// Returns the receiver type for the index trait call.
-pub(crate) fn resolve_indexing_op(
-    db: &dyn HirDatabase,
-    env: Arc<TraitEnvironment>,
-    ty: Canonical<Ty>,
+pub(crate) fn resolve_indexing_op<'db>(
+    table: &mut InferenceTable<'db>,
+    ty: next_solver::Canonical<'db, next_solver::Ty<'db>>,
     index_trait: TraitId,
 ) -> Option<ReceiverAdjustments> {
-    let mut table = InferenceTable::new(db, env);
-    let ty = table.instantiate_canonical(ty);
-    let interner = table.interner;
-    let deref_chain = autoderef_method_receiver(&mut table, ty.to_nextsolver(interner));
+    let ty = table.instantiate_canonical_ns(ty);
+    let deref_chain = autoderef_method_receiver(table, ty);
     for (ty, adj) in deref_chain {
         //let goal = generic_implements_goal_ns(db, &table.trait_env, index_trait, &ty);
-        let goal = generic_implements_goal(db, &table.trait_env, index_trait, &ChalkToNextSolver::from_nextsolver(ty, interner));
-        let goal: chalk_ir::Canonical<chalk_ir::InEnvironment<chalk_ir::Goal<Interner>>> = goal.cast(Interner);
-        let goal = goal.to_nextsolver(interner);
-        if !next_trait_solve_canonical(db, table.trait_env.krate, table.trait_env.block, goal).no_solution() {
+        let goal = generic_implements_goal_ns(table, index_trait, ty);
+        if !next_trait_solve_canonical_in_ctxt(&table.infer_ctxt, goal).no_solution() {
             return Some(adj);
         }
     }
@@ -1666,6 +1704,7 @@ fn is_valid_trait_method_candidate(
     receiver_ty: Option<&Ty>,
     item: AssocItemId,
     self_ty: &Ty,
+    mode: LookupMode,
 ) -> IsValidCandidate {
     let db = table.db;
     match item {
@@ -1693,6 +1732,35 @@ fn is_valid_trait_method_candidate(
                     let expected_receiver =
                         sig.map(|s| s.params()[0].clone()).substitute(Interner, &fn_subst);
 
+                    // FIXME: Clean up this mess with some context struct like rustc's `ProbeContext`
+                    let variance = match mode {
+                        LookupMode::MethodCall => rustc_type_ir::Variance::Covariant,
+                        LookupMode::Path => rustc_type_ir::Variance::Invariant,
+                    };
+                    let res = table
+                        .infer_ctxt
+                        .at(
+                            &next_solver::infer::traits::ObligationCause::dummy(),
+                            table.trait_env.env.to_nextsolver(table.interner),
+                        )
+                        .relate(
+                            DefineOpaqueTypes::No,
+                            expected_receiver.to_nextsolver(table.interner),
+                            variance,
+                            receiver_ty.to_nextsolver(table.interner),
+                        );
+                    let Ok(infer_ok) = res else {
+                        return IsValidCandidate::No;
+                    };
+
+                    if !infer_ok.obligations.is_empty() {
+                        let mut ctxt = FulfillmentCtxt::new(&table.infer_ctxt);
+                        for pred in infer_ok.into_obligations() {
+                            ctxt.register_predicate_obligation(&table.infer_ctxt, pred);
+                        }
+                        check_that!(ctxt.select_all_or_error(&table.infer_ctxt).is_empty());
+                    }
+
                     check_that!(table.unify(receiver_ty, &expected_receiver));
                 }
 
@@ -1839,53 +1907,36 @@ fn generic_implements_goal(
     Canonical { binders, value }
 }
 
-/*
 /// This creates Substs for a trait with the given Self type and type variables
 /// for all other parameters, to query the trait solver with it.
 #[tracing::instrument(skip_all)]
 fn generic_implements_goal_ns<'db>(
-    db: &'db dyn HirDatabase,
-    interner: DbInterner<'db>,
-    env: &TraitEnvironment,
+    table: &mut InferenceTable<'db>,
     trait_: TraitId,
-    self_ty: &crate::next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
-) -> crate::next_solver::Canonical<'db, crate::next_solver::Goal<'db, crate::next_solver::Predicate<'db>>> {
-    let variables = self_ty.variables;
-    let trait_ref = TyBuilder::trait_ref(db, trait_)
-        .push(ChalkToNextSolver::from_nextsolver(self_ty.value, interner))
-        .fill_with_bound_vars(DebruijnIndex::INNERMOST, variables.len())
-        .build();
-
-    let infer_ctxt = interner.infer_ctxt().build(TypingMode::non_body_analysis());
-    let args = infer_ctxt.fresh_args_for_item(SolverDefId::TraitId(trait_));
-
-    rustc_type_ir::TraitRef::new(interner, SolverDefId::TraitId(trait_)).with_self_ty(interner, self_ty.value);
-    
-
-    let kinds =
-        binders.iter().cloned().chain(trait_ref.substitution.iter(Interner).skip(1).map(|it| {
-            let vk = match it.data(Interner) {
-                GenericArgData::Ty(_) => VariableKind::Ty(chalk_ir::TyVariableKind::General),
-                GenericArgData::Lifetime(_) => VariableKind::Lifetime,
-                GenericArgData::Const(c) => VariableKind::Const(c.data(Interner).ty.clone()),
-            };
-            WithKind::new(vk, UniverseIndex::ROOT)
-        }));
-    let binders = CanonicalVarKinds::from_iter(Interner, kinds);
+    self_ty: next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
+) -> next_solver::Canonical<'db, next_solver::Goal<'db, crate::next_solver::Predicate<'db>>> {
+    let args = table.infer_ctxt.fresh_args_for_item(SolverDefId::TraitId(trait_));
+    let self_ty = table.instantiate_canonical_ns(self_ty);
+    let trait_ref =
+        rustc_type_ir::TraitRef::new_from_args(table.infer_ctxt.interner, trait_.into(), args)
+            .with_replaced_self_ty(table.infer_ctxt.interner, self_ty);
+    let goal = next_solver::Goal::new(
+        table.infer_ctxt.interner,
+        table.trait_env.env.to_nextsolver(table.infer_ctxt.interner),
+        trait_ref,
+    );
 
-    let obligation = trait_ref.cast(Interner);
-    let value = InEnvironment::new(&env.env, obligation);
-    crate::next_solver::Canonical { max_universe, value, variables }
+    table.canonicalize(goal)
 }
-*/
 
 fn autoderef_method_receiver<'db>(
     table: &mut InferenceTable<'db>,
-    ty: crate::next_solver::Ty<'db>,
-) -> Vec<(crate::next_solver::Canonical<'db, crate::next_solver::Ty<'db>>, ReceiverAdjustments)> {
+    ty: next_solver::Ty<'db>,
+) -> Vec<(next_solver::Canonical<'db, crate::next_solver::Ty<'db>>, ReceiverAdjustments)> {
     let interner = table.interner;
     let mut deref_chain = Vec::new();
-    let mut autoderef = autoderef::Autoderef::new_no_tracking(table, ChalkToNextSolver::from_nextsolver(ty, interner), false, true);
+    let mut autoderef =
+        autoderef::Autoderef::new_no_tracking(table, ty.to_chalk(interner), false, true);
     while let Some((ty, derefs)) = autoderef.next() {
         deref_chain.push((
             autoderef.table.canonicalize(ty.to_nextsolver(interner)),
@@ -1894,11 +1945,11 @@ fn autoderef_method_receiver<'db>(
     }
     // As a last step, we can do array unsizing (that's the only unsizing that rustc does for method receivers!)
     if let Some((rustc_type_ir::Array(parameters, _), variables, max_universe, adj)) =
-        deref_chain.last().map(|d| (d.0.value.kind(), d.0.variables.clone(), d.0.max_universe, d.1.clone()))
+        deref_chain.last().map(|d| (d.0.value.kind(), d.0.variables, d.0.max_universe, d.1.clone()))
     {
-        let unsized_ty = crate::next_solver::Ty::new_slice(interner, parameters);
+        let unsized_ty = next_solver::Ty::new_slice(interner, parameters);
         deref_chain.push((
-            crate::next_solver::Canonical { max_universe, value: unsized_ty, variables, },
+            next_solver::Canonical { max_universe, value: unsized_ty, variables },
             ReceiverAdjustments { unsize_array: true, ..adj.clone() },
         ));
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir.rs
index 8c48a16537a2e..6465099dffd7f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir.rs
@@ -34,8 +34,7 @@ pub use eval::{
 };
 pub use lower::{MirLowerError, lower_to_mir, mir_body_for_closure_query, mir_body_query};
 pub use monomorphization::{
-    monomorphize_mir_body_bad, monomorphized_mir_body_for_closure_query,
-    monomorphized_mir_body_query,
+    monomorphized_mir_body_for_closure_query, monomorphized_mir_body_query,
 };
 use rustc_hash::FxHashMap;
 use smallvec::{SmallVec, smallvec};
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/monomorphization.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/monomorphization.rs
index b0b922316914b..555b87850924c 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/monomorphization.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/monomorphization.rs
@@ -38,7 +38,6 @@ struct Filler<'a> {
     trait_env: Arc<TraitEnvironment>,
     subst: &'a Substitution,
     generics: Option<Generics>,
-    owner: DefWithBodyId,
 }
 impl FallibleTypeFolder<Interner> for Filler<'_> {
     type Error = MirLowerError;
@@ -66,7 +65,11 @@ impl FallibleTypeFolder<Interner> for Filler<'_> {
                 }))
                 .intern(Interner))
             }
-            TyKind::OpaqueType(id, subst) => {
+            TyKind::Alias(chalk_ir::AliasTy::Opaque(chalk_ir::OpaqueTy {
+                opaque_ty_id: id,
+                substitution: subst,
+            }))
+            | TyKind::OpaqueType(id, subst) => {
                 let impl_trait_id = self.db.lookup_intern_impl_trait_id((*id).into());
                 let subst = subst.clone().try_fold_with(self.as_dyn(), outer_binder)?;
                 match impl_trait_id {
@@ -74,7 +77,6 @@ impl FallibleTypeFolder<Interner> for Filler<'_> {
                         let infer = self.db.infer(func.into());
                         let filler = &mut Filler {
                             db: self.db,
-                            owner: self.owner,
                             trait_env: self.trait_env.clone(),
                             subst: &subst,
                             generics: Some(generics(self.db, func.into())),
@@ -306,7 +308,7 @@ pub fn monomorphized_mir_body_query(
     trait_env: Arc<crate::TraitEnvironment>,
 ) -> Result<Arc<MirBody>, MirLowerError> {
     let generics = owner.as_generic_def_id(db).map(|g_def| generics(db, g_def));
-    let filler = &mut Filler { db, subst: &subst, trait_env, generics, owner };
+    let filler = &mut Filler { db, subst: &subst, trait_env, generics };
     let body = db.mir_body(owner)?;
     let mut body = (*body).clone();
     filler.fill_body(&mut body)?;
@@ -330,23 +332,9 @@ pub fn monomorphized_mir_body_for_closure_query(
 ) -> Result<Arc<MirBody>, MirLowerError> {
     let InternedClosure(owner, _) = db.lookup_intern_closure(closure);
     let generics = owner.as_generic_def_id(db).map(|g_def| generics(db, g_def));
-    let filler = &mut Filler { db, subst: &subst, trait_env, generics, owner };
+    let filler = &mut Filler { db, subst: &subst, trait_env, generics };
     let body = db.mir_body_for_closure(closure)?;
     let mut body = (*body).clone();
     filler.fill_body(&mut body)?;
     Ok(Arc::new(body))
 }
-
-// FIXME: remove this function. Monomorphization is a time consuming job and should always be a query.
-pub fn monomorphize_mir_body_bad(
-    db: &dyn HirDatabase,
-    mut body: MirBody,
-    subst: Substitution,
-    trait_env: Arc<crate::TraitEnvironment>,
-) -> Result<MirBody, MirLowerError> {
-    let owner = body.owner;
-    let generics = owner.as_generic_def_id(db).map(|g_def| generics(db, g_def));
-    let filler = &mut Filler { db, subst: &subst, trait_env, generics, owner };
-    filler.fill_body(&mut body)?;
-    Ok(body)
-}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver.rs
index 21762aa66a858..0225deebe4f31 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver.rs
@@ -5,11 +5,10 @@ pub mod abi;
 mod consts;
 mod def_id;
 pub mod fold;
-mod fulfill;
+pub mod fulfill;
 mod generic_arg;
 pub mod generics;
 pub mod infer;
-//mod infer_new;
 pub mod interner;
 mod ir_print;
 pub mod mapping;
@@ -24,7 +23,6 @@ pub mod util;
 pub use consts::*;
 pub use def_id::*;
 pub use generic_arg::*;
-//pub use infer_new::*;
 pub use interner::*;
 pub use opaques::*;
 pub use predicate::*;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/canonicalizer.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/canonicalizer.rs
index 0820006e5dfb0..5d11525cd199f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/canonicalizer.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/canonicalizer.rs
@@ -1,14 +1,28 @@
+//! This module contains code to canonicalize values into a `Canonical<'db, T>`.
+//!
+//! For an overview of what canonicalization is and how it fits into
+//! rustc, check out the [chapter in the rustc dev guide][c].
+//!
+//! [c]: https://rust-lang.github.io/chalk/book/canonical_queries/canonicalization.html
 
 use rustc_hash::FxHashMap;
 use rustc_index::Idx;
-use rustc_type_ir::inherent::{Const as _, IntoKind as _, Region as _, SliceLike, Ty as _};
 use rustc_type_ir::InferTy::{self, FloatVar, IntVar, TyVar};
-use rustc_type_ir::{BoundVar, CanonicalQueryInput, CanonicalTyVarKind, DebruijnIndex, Flags, InferConst, RegionKind, TypeFlags, TypeFoldable, TypeFolder, TypeSuperFoldable, TypeVisitableExt, UniverseIndex};
+use rustc_type_ir::inherent::{Const as _, IntoKind as _, Region as _, SliceLike, Ty as _};
+use rustc_type_ir::{
+    BoundVar, CanonicalQueryInput, CanonicalTyVarKind, DebruijnIndex, Flags, InferConst,
+    RegionKind, TypeFlags, TypeFoldable, TypeFolder, TypeSuperFoldable, TypeVisitableExt,
+    UniverseIndex,
+};
 use smallvec::SmallVec;
 use tracing::debug;
 
 use crate::next_solver::infer::InferCtxt;
-use crate::next_solver::{Binder, BoundRegion, BoundRegionKind, BoundTy, Canonical, CanonicalVarKind, CanonicalVars, Const, ConstKind, DbInterner, GenericArg, ParamEnvAnd, Placeholder, Region, Ty, TyKind};
+use crate::next_solver::{
+    Binder, BoundConst, BoundRegion, BoundRegionKind, BoundTy, Canonical, CanonicalVarKind,
+    CanonicalVars, Const, ConstKind, DbInterner, GenericArg, ParamEnvAnd, Placeholder, Region, Ty,
+    TyKind,
+};
 
 /// When we canonicalize a value to form a query, we wind up replacing
 /// various parts of it with canonical variables. This struct stores
@@ -65,7 +79,7 @@ impl<'db> InferCtxt<'db> {
         // `param_env` because they are treated differently by trait selection.
         let canonical_param_env = Canonicalizer::canonicalize(
             param_env,
-            None,
+            self,
             self.interner,
             &CanonicalizeFreeRegionsOtherThanStatic,
             query_state,
@@ -74,7 +88,7 @@ impl<'db> InferCtxt<'db> {
         let canonical = Canonicalizer::canonicalize_with_base(
             canonical_param_env,
             value,
-            Some(self),
+            self,
             self.interner,
             &CanonicalizeAllFreeRegions,
             query_state,
@@ -115,7 +129,7 @@ impl<'db> InferCtxt<'db> {
         let mut query_state = OriginalQueryValues::default();
         Canonicalizer::canonicalize(
             value,
-            Some(self),
+            self,
             self.interner,
             &CanonicalizeQueryResponse,
             &mut query_state,
@@ -129,7 +143,7 @@ impl<'db> InferCtxt<'db> {
         let mut query_state = OriginalQueryValues::default();
         Canonicalizer::canonicalize(
             value,
-            Some(self),
+            self,
             self.interner,
             &CanonicalizeUserTypeAnnotation,
             &mut query_state,
@@ -165,7 +179,7 @@ impl CanonicalizeMode for CanonicalizeQueryResponse {
         canonicalizer: &mut Canonicalizer<'_, 'db>,
         mut r: Region<'db>,
     ) -> Region<'db> {
-        let infcx = canonicalizer.infcx.unwrap();
+        let infcx = canonicalizer.infcx;
 
         if let RegionKind::ReVar(vid) = r.kind() {
             r = infcx
@@ -180,12 +194,14 @@ impl CanonicalizeMode for CanonicalizeQueryResponse {
         };
 
         match r.kind() {
-            RegionKind::ReLateParam(_) | RegionKind::ReErased | RegionKind::ReStatic | RegionKind::ReEarlyParam(..) | RegionKind::ReError(..) => r,
+            RegionKind::ReLateParam(_)
+            | RegionKind::ReErased
+            | RegionKind::ReStatic
+            | RegionKind::ReEarlyParam(..)
+            | RegionKind::ReError(..) => r,
 
-            RegionKind::RePlaceholder(placeholder) => canonicalizer.canonical_var_for_region(
-                CanonicalVarKind::PlaceholderRegion(placeholder),
-                r,
-            ),
+            RegionKind::RePlaceholder(placeholder) => canonicalizer
+                .canonical_var_for_region(CanonicalVarKind::PlaceholderRegion(placeholder), r),
 
             RegionKind::ReVar(vid) => {
                 let universe = infcx
@@ -194,10 +210,7 @@ impl CanonicalizeMode for CanonicalizeQueryResponse {
                     .unwrap_region_constraints()
                     .probe_value(vid)
                     .unwrap_err();
-                canonicalizer.canonical_var_for_region(
-                    CanonicalVarKind::Region(universe),
-                    r,
-                )
+                canonicalizer.canonical_var_for_region(CanonicalVarKind::Region(universe), r)
             }
 
             _ => {
@@ -240,7 +253,7 @@ impl CanonicalizeMode for CanonicalizeUserTypeAnnotation {
             RegionKind::ReVar(_) => canonicalizer.canonical_var_for_region_in_root_universe(r),
             RegionKind::RePlaceholder(..) | RegionKind::ReBound(..) => {
                 // We only expect region names that the user can type.
-                panic!("unexpected region in query response: `{:?}`", r)
+                panic!("unexpected region in query response: `{r:?}`")
             }
         }
     }
@@ -296,7 +309,7 @@ impl CanonicalizeMode for CanonicalizeFreeRegionsOtherThanStatic {
 
 struct Canonicalizer<'cx, 'db> {
     /// Set to `None` to disable the resolution of inference variables.
-    infcx: Option<&'cx InferCtxt<'db>>,
+    infcx: &'cx InferCtxt<'db>,
     tcx: DbInterner<'db>,
     variables: SmallVec<[CanonicalVarKind<'db>; 8]>,
     query_state: &'cx mut OriginalQueryValues<'db>,
@@ -350,14 +363,14 @@ impl<'cx, 'db> TypeFolder<DbInterner<'db>> for Canonicalizer<'cx, 'db> {
                 // We need to canonicalize the *root* of our ty var.
                 // This is so that our canonical response correctly reflects
                 // any equated inference vars correctly!
-                let root_vid = self.infcx.unwrap().root_var(vid);
+                let root_vid = self.infcx.root_var(vid);
                 if root_vid != vid {
                     t = Ty::new_var(self.tcx, root_vid);
                     vid = root_vid;
                 }
 
                 debug!("canonical: type var found with vid {:?}", vid);
-                match self.infcx.unwrap().probe_ty_var(vid) {
+                match self.infcx.probe_ty_var(vid) {
                     // `t` could be a float / int variable; canonicalize that instead.
                     Ok(t) => {
                         debug!("(resolved to {:?})", t);
@@ -380,29 +393,25 @@ impl<'cx, 'db> TypeFolder<DbInterner<'db>> for Canonicalizer<'cx, 'db> {
             }
 
             TyKind::Infer(IntVar(vid)) => {
-                let nt = self.infcx.unwrap().opportunistic_resolve_int_var(vid);
+                let nt = self.infcx.opportunistic_resolve_int_var(vid);
                 if nt != t {
-                    return self.fold_ty(nt);
+                    self.fold_ty(nt)
                 } else {
-                    self.canonicalize_ty_var(
-                        CanonicalVarKind::Ty(CanonicalTyVarKind::Int),
-                        t,
-                    )
+                    self.canonicalize_ty_var(CanonicalVarKind::Ty(CanonicalTyVarKind::Int), t)
                 }
             }
             TyKind::Infer(FloatVar(vid)) => {
-                let nt = self.infcx.unwrap().opportunistic_resolve_float_var(vid);
+                let nt = self.infcx.opportunistic_resolve_float_var(vid);
                 if nt != t {
-                    return self.fold_ty(nt);
+                    self.fold_ty(nt)
                 } else {
-                    self.canonicalize_ty_var(
-                        CanonicalVarKind::Ty(CanonicalTyVarKind::Float),
-                        t,
-                    )
+                    self.canonicalize_ty_var(CanonicalVarKind::Ty(CanonicalTyVarKind::Float), t)
                 }
             }
 
-            TyKind::Infer(InferTy::FreshTy(_) | InferTy::FreshIntTy(_) | InferTy::FreshFloatTy(_)) => {
+            TyKind::Infer(
+                InferTy::FreshTy(_) | InferTy::FreshIntTy(_) | InferTy::FreshFloatTy(_),
+            ) => {
                 panic!("encountered a fresh type during canonicalization")
             }
 
@@ -410,10 +419,7 @@ impl<'cx, 'db> TypeFolder<DbInterner<'db>> for Canonicalizer<'cx, 'db> {
                 if !self.canonicalize_mode.preserve_universes() {
                     placeholder.universe = UniverseIndex::ROOT;
                 }
-                self.canonicalize_ty_var(
-                    CanonicalVarKind::PlaceholderTy(placeholder),
-                    t,
-                )
+                self.canonicalize_ty_var(CanonicalVarKind::PlaceholderTy(placeholder), t)
             }
 
             TyKind::Bound(debruijn, _) => {
@@ -465,14 +471,14 @@ impl<'cx, 'db> TypeFolder<DbInterner<'db>> for Canonicalizer<'cx, 'db> {
                 // We need to canonicalize the *root* of our const var.
                 // This is so that our canonical response correctly reflects
                 // any equated inference vars correctly!
-                let root_vid = self.infcx.unwrap().root_const_var(vid);
+                let root_vid = self.infcx.root_const_var(vid);
                 if root_vid != vid {
                     ct = Const::new_var(self.tcx, root_vid);
                     vid = root_vid;
                 }
 
                 debug!("canonical: const var found with vid {:?}", vid);
-                match self.infcx.unwrap().probe_const_var(vid) {
+                match self.infcx.probe_const_var(vid) {
                     Ok(c) => {
                         debug!("(resolved to {:?})", c);
                         return self.fold_const(c);
@@ -485,10 +491,7 @@ impl<'cx, 'db> TypeFolder<DbInterner<'db>> for Canonicalizer<'cx, 'db> {
                             // FIXME: perf problem described in #55921.
                             ui = UniverseIndex::ROOT;
                         }
-                        return self.canonicalize_const_var(
-                            CanonicalVarKind::Const(ui),
-                            ct,
-                        );
+                        return self.canonicalize_const_var(CanonicalVarKind::Const(ui), ct);
                     }
                 }
             }
@@ -503,10 +506,8 @@ impl<'cx, 'db> TypeFolder<DbInterner<'db>> for Canonicalizer<'cx, 'db> {
                 }
             }
             ConstKind::Placeholder(placeholder) => {
-                return self.canonicalize_const_var(
-                    CanonicalVarKind::PlaceholderConst(placeholder),
-                    ct,
-                );
+                return self
+                    .canonicalize_const_var(CanonicalVarKind::PlaceholderConst(placeholder), ct);
             }
             _ => {}
         }
@@ -524,7 +525,7 @@ impl<'cx, 'db> Canonicalizer<'cx, 'db> {
     /// `canonicalize_query` and `canonicalize_response`.
     fn canonicalize<V>(
         value: V,
-        infcx: Option<&InferCtxt<'db>>,
+        infcx: &InferCtxt<'db>,
         tcx: DbInterner<'db>,
         canonicalize_region_mode: &dyn CanonicalizeMode,
         query_state: &mut OriginalQueryValues<'db>,
@@ -551,7 +552,7 @@ impl<'cx, 'db> Canonicalizer<'cx, 'db> {
     fn canonicalize_with_base<U, V>(
         base: Canonical<'db, U>,
         value: V,
-        infcx: Option<&InferCtxt<'db>>,
+        infcx: &InferCtxt<'db>,
         tcx: DbInterner<'db>,
         canonicalize_region_mode: &dyn CanonicalizeMode,
         query_state: &mut OriginalQueryValues<'db>,
@@ -596,7 +597,8 @@ impl<'cx, 'db> Canonicalizer<'cx, 'db> {
         // anymore.
         debug_assert!(!out_value.has_infer() && !out_value.has_placeholders());
 
-        let canonical_variables = CanonicalVars::new_from_iter(tcx, canonicalizer.universe_canonicalized_variables());
+        let canonical_variables =
+            CanonicalVars::new_from_iter(tcx, canonicalizer.universe_canonicalized_variables());
 
         let max_universe = canonical_variables
             .iter()
@@ -690,15 +692,11 @@ impl<'cx, 'db> Canonicalizer<'cx, 'db> {
         self.variables
             .iter()
             .map(|v| match *v {
-                CanonicalVarKind::Ty(CanonicalTyVarKind::Int | CanonicalTyVarKind::Float) => {
-                    return *v;
-                }
+                CanonicalVarKind::Ty(CanonicalTyVarKind::Int | CanonicalTyVarKind::Float) => *v,
                 CanonicalVarKind::Ty(CanonicalTyVarKind::General(u)) => {
                     CanonicalVarKind::Ty(CanonicalTyVarKind::General(reverse_universe_map[&u]))
                 }
-                CanonicalVarKind::Region(u) => {
-                    CanonicalVarKind::Region(reverse_universe_map[&u])
-                }
+                CanonicalVarKind::Region(u) => CanonicalVarKind::Region(reverse_universe_map[&u]),
                 CanonicalVarKind::Const(u) => CanonicalVarKind::Const(reverse_universe_map[&u]),
                 CanonicalVarKind::PlaceholderTy(placeholder) => {
                     CanonicalVarKind::PlaceholderTy(Placeholder {
@@ -735,14 +733,8 @@ impl<'cx, 'db> Canonicalizer<'cx, 'db> {
     ///
     /// (This works because unification never fails -- and hence trait
     /// selection is never affected -- due to a universe mismatch.)
-    fn canonical_var_for_region_in_root_universe(
-        &mut self,
-        r: Region<'db>,
-    ) -> Region<'db> {
-        self.canonical_var_for_region(
-            CanonicalVarKind::Region(UniverseIndex::ROOT),
-            r,
-        )
+    fn canonical_var_for_region_in_root_universe(&mut self, r: Region<'db>) -> Region<'db> {
+        self.canonical_var_for_region(CanonicalVarKind::Region(UniverseIndex::ROOT), r)
     }
 
     /// Creates a canonical variable (with the given `info`)
@@ -762,9 +754,13 @@ impl<'cx, 'db> Canonicalizer<'cx, 'db> {
     /// *that*. Otherwise, create a new canonical variable for
     /// `ty_var`.
     fn canonicalize_ty_var(&mut self, info: CanonicalVarKind<'db>, ty_var: Ty<'db>) -> Ty<'db> {
-        debug_assert!(!self.infcx.is_some_and(|infcx| ty_var != infcx.shallow_resolve(ty_var)));
+        debug_assert_eq!(ty_var, self.infcx.shallow_resolve(ty_var));
         let var = self.canonical_var(info, ty_var.into());
-        Ty::new_bound(self.tcx, self.binder_index, BoundTy { kind: crate::next_solver::BoundTyKind::Anon, var })
+        Ty::new_bound(
+            self.tcx,
+            self.binder_index,
+            BoundTy { kind: crate::next_solver::BoundTyKind::Anon, var },
+        )
     }
 
     /// Given a type variable `const_var` of the given kind, first check
@@ -776,10 +772,8 @@ impl<'cx, 'db> Canonicalizer<'cx, 'db> {
         info: CanonicalVarKind<'db>,
         const_var: Const<'db>,
     ) -> Const<'db> {
-        debug_assert!(
-            !self.infcx.is_some_and(|infcx| const_var != infcx.shallow_resolve_const(const_var))
-        );
+        debug_assert_eq!(const_var, self.infcx.shallow_resolve_const(const_var));
         let var = self.canonical_var(info, const_var.into());
-        Const::new_bound(self.tcx, self.binder_index, var)
+        Const::new_bound(self.tcx, self.binder_index, BoundConst { var })
     }
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs
index 894c91e0f49db..2630f2a8cc4e5 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs
@@ -503,7 +503,10 @@ impl<'db> InferCtxt<'db> {
     }
 
     pub fn next_ty_vid(&self) -> TyVid {
-        self.inner.borrow_mut().type_variables().new_var(self.universe(), TypeVariableOrigin { param_def_id: None })
+        self.inner
+            .borrow_mut()
+            .type_variables()
+            .new_var(self.universe(), TypeVariableOrigin { param_def_id: None })
     }
 
     pub fn next_ty_var_with_origin(&self, origin: TypeVariableOrigin) -> Ty<'db> {
@@ -526,11 +529,13 @@ impl<'db> InferCtxt<'db> {
     }
 
     pub fn next_const_vid(&self) -> ConstVid {
-        self
-            .inner
+        self.inner
             .borrow_mut()
             .const_unification_table()
-            .new_key(ConstVariableValue::Unknown { origin: ConstVariableOrigin { param_def_id: None }, universe: self.universe() })
+            .new_key(ConstVariableValue::Unknown {
+                origin: ConstVariableOrigin { param_def_id: None },
+                universe: self.universe(),
+            })
             .vid
     }
 
@@ -566,9 +571,7 @@ impl<'db> InferCtxt<'db> {
     }
 
     pub fn next_float_var(&self) -> Ty<'db> {
-        let next_float_var_id =
-            self.inner.borrow_mut().float_unification_table().new_key(FloatVarValue::Unknown);
-        Ty::new_float_var(self.interner, next_float_var_id)
+        Ty::new_float_var(self.interner, self.next_float_vid())
     }
 
     pub fn next_float_vid(&self) -> FloatVid {
@@ -815,9 +818,7 @@ impl<'db> InferCtxt<'db> {
         match value {
             IntVarValue::IntType(ty) => Some(Ty::new_int(self.interner, ty)),
             IntVarValue::UintType(ty) => Some(Ty::new_uint(self.interner, ty)),
-            IntVarValue::Unknown => {
-                None
-            }
+            IntVarValue::Unknown => None,
         }
     }
 
@@ -839,9 +840,7 @@ impl<'db> InferCtxt<'db> {
         let value = inner.float_unification_table().probe_value(vid);
         match value {
             FloatVarValue::Known(ty) => Some(Ty::new_float(self.interner, ty)),
-            FloatVarValue::Unknown => {
-                None
-            }
+            FloatVarValue::Unknown => None,
         }
     }
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
index 79c402ff29c3d..f66b8dace30a6 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
@@ -141,7 +141,10 @@ impl<'db> rustc_type_ir::TypeFolder<DbInterner<'db>> for BinderToEarlyBinder<'db
 
 pub trait ChalkToNextSolver<'db, Out> {
     fn to_nextsolver(&self, interner: DbInterner<'db>) -> Out;
-    fn from_nextsolver(out: Out, interner: DbInterner<'db>) -> Self;
+}
+
+pub trait NextSolverToChalk<'db, Out> {
+    fn to_chalk(self, interner: DbInterner<'db>) -> Out;
 }
 
 impl<'db> ChalkToNextSolver<'db, Ty<'db>> for chalk_ir::Ty<Interner> {
@@ -428,342 +431,11 @@ impl<'db> ChalkToNextSolver<'db, Ty<'db>> for chalk_ir::Ty<Interner> {
             },
         )
     }
+}
 
-    fn from_nextsolver(out: Ty<'db>, interner: DbInterner<'db>) -> Self {
-        use crate::{Scalar, TyKind};
-        use chalk_ir::{FloatTy, IntTy, UintTy};
-        match out.kind() {
-            rustc_type_ir::TyKind::Bool => TyKind::Scalar(Scalar::Bool),
-            rustc_type_ir::TyKind::Char => TyKind::Scalar(Scalar::Char),
-            rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::I8) => {
-                TyKind::Scalar(Scalar::Int(IntTy::I8))
-            }
-            rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::I16) => {
-                TyKind::Scalar(Scalar::Int(IntTy::I16))
-            }
-            rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::I32) => {
-                TyKind::Scalar(Scalar::Int(IntTy::I32))
-            }
-            rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::I64) => {
-                TyKind::Scalar(Scalar::Int(IntTy::I64))
-            }
-            rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::I128) => {
-                TyKind::Scalar(Scalar::Int(IntTy::I128))
-            }
-            rustc_type_ir::TyKind::Int(rustc_type_ir::IntTy::Isize) => {
-                TyKind::Scalar(Scalar::Int(IntTy::Isize))
-            }
-            rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::U8) => {
-                TyKind::Scalar(Scalar::Uint(UintTy::U8))
-            }
-            rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::U16) => {
-                TyKind::Scalar(Scalar::Uint(UintTy::U16))
-            }
-            rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::U32) => {
-                TyKind::Scalar(Scalar::Uint(UintTy::U32))
-            }
-            rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::U64) => {
-                TyKind::Scalar(Scalar::Uint(UintTy::U64))
-            }
-            rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::U128) => {
-                TyKind::Scalar(Scalar::Uint(UintTy::U128))
-            }
-            rustc_type_ir::TyKind::Uint(rustc_type_ir::UintTy::Usize) => {
-                TyKind::Scalar(Scalar::Uint(UintTy::Usize))
-            }
-            rustc_type_ir::TyKind::Float(rustc_type_ir::FloatTy::F16) => {
-                TyKind::Scalar(Scalar::Float(FloatTy::F16))
-            }
-            rustc_type_ir::TyKind::Float(rustc_type_ir::FloatTy::F32) => {
-                TyKind::Scalar(Scalar::Float(FloatTy::F32))
-            }
-            rustc_type_ir::TyKind::Float(rustc_type_ir::FloatTy::F64) => {
-                TyKind::Scalar(Scalar::Float(FloatTy::F64))
-            }
-            rustc_type_ir::TyKind::Float(rustc_type_ir::FloatTy::F128) => {
-                TyKind::Scalar(Scalar::Float(FloatTy::F128))
-            }
-            rustc_type_ir::TyKind::Str => TyKind::Str,
-            rustc_type_ir::TyKind::Error(_) => TyKind::Error,
-            rustc_type_ir::TyKind::Never => TyKind::Never,
-
-            rustc_type_ir::TyKind::Adt(def, args) => {
-                let adt_id = def.inner().id;
-                let subst = ChalkToNextSolver::from_nextsolver(args, interner);
-                TyKind::Adt(chalk_ir::AdtId(adt_id), subst)
-            }
-
-            rustc_type_ir::TyKind::Infer(infer_ty) => {
-                let (var, kind) = match infer_ty {
-                    rustc_type_ir::InferTy::TyVar(var) => {
-                        (InferenceVar::from(var.as_u32()), TyVariableKind::General)
-                    }
-                    rustc_type_ir::InferTy::IntVar(var) => {
-                        (InferenceVar::from(var.as_u32()), TyVariableKind::Integer)
-                    }
-                    rustc_type_ir::InferTy::FloatVar(var) => {
-                        (InferenceVar::from(var.as_u32()), TyVariableKind::Float)
-                    }
-                    _ => todo!(),
-                };
-                TyKind::InferenceVar(var, kind)
-            }
-
-            rustc_type_ir::TyKind::Ref(r, ty, mutability) => {
-                let mutability = match mutability {
-                    rustc_ast_ir::Mutability::Mut => chalk_ir::Mutability::Mut,
-                    rustc_ast_ir::Mutability::Not => chalk_ir::Mutability::Not,
-                };
-                let r = ChalkToNextSolver::from_nextsolver(r, interner);
-                let ty = ChalkToNextSolver::from_nextsolver(ty, interner);
-                TyKind::Ref(mutability, r, ty)
-            }
-
-            rustc_type_ir::TyKind::Tuple(tys) => {
-                let size = tys.len();
-                let subst = Substitution::from_iter(
-                    Interner,
-                    tys.iter().map(|ty| {
-                        chalk_ir::GenericArgData::Ty(ChalkToNextSolver::from_nextsolver(
-                            ty, interner,
-                        ))
-                        .intern(Interner)
-                    }),
-                );
-                TyKind::Tuple(size, subst)
-            }
-
-            rustc_type_ir::TyKind::Array(ty, const_) => {
-                let ty = ChalkToNextSolver::from_nextsolver(ty, interner);
-                let const_ = ChalkToNextSolver::from_nextsolver(const_, interner);
-                TyKind::Array(ty, const_)
-            }
-
-            rustc_type_ir::TyKind::Alias(alias_ty_kind, alias_ty) => match alias_ty_kind {
-                rustc_type_ir::AliasTyKind::Projection => {
-                    let assoc_ty_id = match alias_ty.def_id {
-                        SolverDefId::TypeAliasId(id) => id,
-                        _ => unreachable!(),
-                    };
-                    let associated_ty_id = to_assoc_type_id(assoc_ty_id);
-                    let substitution = ChalkToNextSolver::from_nextsolver(alias_ty.args, interner);
-                    TyKind::AssociatedType(associated_ty_id, substitution)
-                }
-                rustc_type_ir::AliasTyKind::Opaque => {
-                    let opaque_ty_id = match alias_ty.def_id {
-                        SolverDefId::InternedOpaqueTyId(id) => id,
-                        _ => unreachable!(),
-                    };
-                    let substitution = ChalkToNextSolver::from_nextsolver(alias_ty.args, interner);
-                    TyKind::Alias(chalk_ir::AliasTy::Opaque(chalk_ir::OpaqueTy {
-                        opaque_ty_id: opaque_ty_id.into(),
-                        substitution,
-                    }))
-                }
-                rustc_type_ir::AliasTyKind::Inherent => todo!(),
-                rustc_type_ir::AliasTyKind::Free => todo!(),
-            },
-
-            rustc_type_ir::TyKind::Placeholder(placeholder) => {
-                let ui = chalk_ir::UniverseIndex { counter: placeholder.universe.as_usize() };
-                let placeholder_index =
-                    chalk_ir::PlaceholderIndex { idx: placeholder.bound.var.as_usize(), ui };
-                TyKind::Placeholder(placeholder_index)
-            }
-
-            rustc_type_ir::TyKind::Bound(debruijn_index, ty) => {
-                TyKind::BoundVar(chalk_ir::BoundVar {
-                    debruijn: chalk_ir::DebruijnIndex::new(debruijn_index.as_u32()),
-                    index: ty.var.as_usize(),
-                })
-            }
-
-            rustc_type_ir::TyKind::FnPtr(bound_sig, fn_header) => {
-                let num_binders = bound_sig.bound_vars().len();
-                let sig = chalk_ir::FnSig {
-                    abi: fn_header.abi,
-                    safety: match fn_header.safety {
-                        crate::next_solver::abi::Safety::Safe => chalk_ir::Safety::Safe,
-                        crate::next_solver::abi::Safety::Unsafe => chalk_ir::Safety::Unsafe,
-                    },
-                    variadic: fn_header.c_variadic,
-                };
-                let args = GenericArgs::new_from_iter(
-                    interner,
-                    bound_sig.skip_binder().inputs_and_output.iter().map(|a| a.into()),
-                );
-                let substitution = ChalkToNextSolver::from_nextsolver(args, interner);
-                let substitution = chalk_ir::FnSubst(substitution);
-                let fnptr = chalk_ir::FnPointer { num_binders, sig, substitution };
-                TyKind::Function(fnptr)
-            }
-
-            rustc_type_ir::TyKind::Dynamic(preds, region, dyn_kind) => {
-                assert!(matches!(dyn_kind, rustc_type_ir::DynKind::Dyn));
-                let self_ty = Ty::new_bound(
-                    interner,
-                    DebruijnIndex::from_u32(1),
-                    BoundTy { kind: BoundTyKind::Anon, var: BoundVar::from_u32(0) },
-                );
-                let bounds = chalk_ir::QuantifiedWhereClauses::from_iter(
-                    Interner,
-                    preds.iter().map(|p| {
-                        let binders = chalk_ir::VariableKinds::from_iter(
-                            Interner,
-                            p.bound_vars().iter().map(|b| match b {
-                                BoundVarKind::Ty(kind) => {
-                                    chalk_ir::VariableKind::Ty(TyVariableKind::General)
-                                }
-                                BoundVarKind::Region(kind) => chalk_ir::VariableKind::Lifetime,
-                                BoundVarKind::Const => chalk_ir::VariableKind::Const(
-                                    crate::TyKind::Error.intern(Interner),
-                                ),
-                            }),
-                        );
-                        let where_clause = match p.skip_binder() {
-                            rustc_type_ir::ExistentialPredicate::Trait(trait_ref) => {
-                                let trait_ref = TraitRef::new(
-                                    interner,
-                                    trait_ref.def_id,
-                                    [self_ty.clone().into()]
-                                        .into_iter()
-                                        .chain(trait_ref.args.iter()),
-                                );
-                                let trait_id = match trait_ref.def_id {
-                                    SolverDefId::TraitId(id) => to_chalk_trait_id(id),
-                                    _ => unreachable!(),
-                                };
-                                let substitution =
-                                    ChalkToNextSolver::from_nextsolver(trait_ref.args, interner);
-                                let trait_ref = chalk_ir::TraitRef { trait_id, substitution };
-                                chalk_ir::WhereClause::Implemented(trait_ref)
-                            }
-                            rustc_type_ir::ExistentialPredicate::AutoTrait(trait_) => {
-                                let trait_id = match trait_ {
-                                    SolverDefId::TraitId(id) => to_chalk_trait_id(id),
-                                    _ => unreachable!(),
-                                };
-                                let substitution = chalk_ir::Substitution::empty(Interner);
-                                let trait_ref = chalk_ir::TraitRef { trait_id, substitution };
-                                chalk_ir::WhereClause::Implemented(trait_ref)
-                            }
-                            rustc_type_ir::ExistentialPredicate::Projection(
-                                existential_projection,
-                            ) => {
-                                let projection = ProjectionPredicate {
-                                    projection_term: AliasTerm::new(
-                                        interner,
-                                        existential_projection.def_id,
-                                        [self_ty.clone().into()]
-                                            .iter()
-                                            .chain(existential_projection.args.clone().iter()),
-                                    ),
-                                    term: existential_projection.term.clone(),
-                                };
-                                let associated_ty_id = match projection.projection_term.def_id {
-                                    SolverDefId::TypeAliasId(id) => to_assoc_type_id(id),
-                                    _ => unreachable!(),
-                                };
-                                let substitution = ChalkToNextSolver::from_nextsolver(
-                                    projection.projection_term.args,
-                                    interner,
-                                );
-                                let alias = chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy {
-                                    associated_ty_id,
-                                    substitution,
-                                });
-                                let ty = match projection.term {
-                                    Term::Ty(ty) => ty,
-                                    _ => unreachable!(),
-                                };
-                                let ty = ChalkToNextSolver::from_nextsolver(ty, interner);
-                                let alias_eq = chalk_ir::AliasEq { alias, ty };
-                                chalk_ir::WhereClause::AliasEq(alias_eq)
-                            }
-                        };
-                        chalk_ir::Binders::new(binders, where_clause)
-                    }),
-                );
-                let binders = chalk_ir::VariableKinds::from1(
-                    Interner,
-                    chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General),
-                );
-                let bounds = chalk_ir::Binders::new(binders, bounds);
-                let dyn_ty = chalk_ir::DynTy {
-                    bounds,
-                    lifetime: ChalkToNextSolver::from_nextsolver(region, interner),
-                };
-                TyKind::Dyn(dyn_ty)
-            }
-
-            rustc_type_ir::TyKind::Slice(ty) => {
-                let ty = ChalkToNextSolver::from_nextsolver(ty, interner);
-                TyKind::Slice(ty)
-            }
-
-            rustc_type_ir::TyKind::Foreign(def_id) => {
-                let id = match def_id {
-                    SolverDefId::TypeAliasId(id) => to_foreign_def_id(id),
-                    _ => unreachable!(),
-                };
-                TyKind::Foreign(id)
-            }
-            rustc_type_ir::TyKind::Pat(_, _) => todo!(),
-            rustc_type_ir::TyKind::RawPtr(ty, mutability) => {
-                let mutability = match mutability {
-                    rustc_ast_ir::Mutability::Mut => chalk_ir::Mutability::Mut,
-                    rustc_ast_ir::Mutability::Not => chalk_ir::Mutability::Not,
-                };
-                let ty = ChalkToNextSolver::from_nextsolver(ty, interner);
-                TyKind::Raw(mutability, ty)
-            }
-            rustc_type_ir::TyKind::FnDef(def_id, args) => {
-                let subst = ChalkToNextSolver::from_nextsolver(args, interner);
-                match def_id {
-                    SolverDefId::FunctionId(id) => {
-                        TyKind::FnDef(CallableDefId::FunctionId(id).to_chalk(interner.db()), subst)
-                    }
-                    SolverDefId::Ctor(Ctor::Enum(e)) => TyKind::FnDef(
-                        CallableDefId::EnumVariantId(e).to_chalk(interner.db()),
-                        subst,
-                    ),
-                    SolverDefId::Ctor(Ctor::Struct(s)) => {
-                        TyKind::FnDef(CallableDefId::StructId(s).to_chalk(interner.db()), subst)
-                    }
-                    _ => unreachable!("Unexpected def id {:?}", def_id),
-                }
-            }
-
-            rustc_type_ir::TyKind::Closure(def_id, args) => {
-                let id = match def_id {
-                    SolverDefId::InternedClosureId(id) => id,
-                    _ => unreachable!(),
-                };
-                let subst = ChalkToNextSolver::from_nextsolver(args, interner);
-                TyKind::Closure(id.into(), subst)
-            }
-            rustc_type_ir::TyKind::CoroutineClosure(_, _) => todo!(),
-            rustc_type_ir::TyKind::Coroutine(def_id, args) => {
-                let id = match def_id {
-                    SolverDefId::InternedCoroutineId(id) => id,
-                    _ => unreachable!(),
-                };
-                let subst = ChalkToNextSolver::from_nextsolver(args, interner);
-                TyKind::Coroutine(id.into(), subst)
-            }
-            rustc_type_ir::TyKind::CoroutineWitness(def_id, args) => {
-                let id = match def_id {
-                    SolverDefId::InternedCoroutineId(id) => id,
-                    _ => unreachable!(),
-                };
-                let subst = ChalkToNextSolver::from_nextsolver(args, interner);
-                TyKind::CoroutineWitness(id.into(), subst)
-            }
-
-            rustc_type_ir::TyKind::Param(_) => todo!(),
-            rustc_type_ir::TyKind::UnsafeBinder(_) => todo!(),
-        }
-        .intern(Interner)
+impl<'db> NextSolverToChalk<'db, chalk_ir::Ty<Interner>> for Ty<'db> {
+    fn to_chalk(self, interner: DbInterner<'db>) -> chalk_ir::Ty<Interner> {
+        convert_ty_for_result(interner, self)
     }
 }
 
@@ -799,39 +471,11 @@ impl<'db> ChalkToNextSolver<'db, Region<'db>> for chalk_ir::Lifetime<Interner> {
             },
         )
     }
+}
 
-    fn from_nextsolver(out: Region<'db>, interner: DbInterner<'db>) -> Self {
-        match out.kind() {
-            rustc_type_ir::RegionKind::ReEarlyParam(early) => todo!(),
-            rustc_type_ir::RegionKind::ReBound(db, bound) => chalk_ir::Lifetime::new(
-                Interner,
-                chalk_ir::LifetimeData::BoundVar(chalk_ir::BoundVar::new(
-                    chalk_ir::DebruijnIndex::new(db.as_u32()),
-                    bound.var.as_usize(),
-                )),
-            ),
-            rustc_type_ir::RegionKind::ReLateParam(_) => todo!(),
-            rustc_type_ir::RegionKind::ReStatic => {
-                chalk_ir::Lifetime::new(Interner, chalk_ir::LifetimeData::Static)
-            }
-            rustc_type_ir::RegionKind::ReVar(vid) => chalk_ir::Lifetime::new(
-                Interner,
-                chalk_ir::LifetimeData::InferenceVar(chalk_ir::InferenceVar::from(vid.as_u32())),
-            ),
-            rustc_type_ir::RegionKind::RePlaceholder(placeholder) => chalk_ir::Lifetime::new(
-                Interner,
-                chalk_ir::LifetimeData::Placeholder(chalk_ir::PlaceholderIndex {
-                    idx: placeholder.bound.var.as_usize(),
-                    ui: chalk_ir::UniverseIndex { counter: placeholder.universe.as_usize() },
-                }),
-            ),
-            rustc_type_ir::RegionKind::ReErased => {
-                chalk_ir::Lifetime::new(Interner, chalk_ir::LifetimeData::Erased)
-            }
-            rustc_type_ir::RegionKind::ReError(_) => {
-                chalk_ir::Lifetime::new(Interner, chalk_ir::LifetimeData::Error)
-            }
-        }
+impl<'db> NextSolverToChalk<'db, chalk_ir::Lifetime<Interner>> for Region<'db> {
+    fn to_chalk(self, interner: DbInterner<'db>) -> chalk_ir::Lifetime<Interner> {
+        convert_region_for_result(interner, self)
     }
 }
 
@@ -877,61 +521,11 @@ impl<'db> ChalkToNextSolver<'db, Const<'db>> for chalk_ir::Const<Interner> {
             },
         )
     }
+}
 
-    fn from_nextsolver(out: Const<'db>, interner: DbInterner<'db>) -> Self {
-        let value: chalk_ir::ConstValue<Interner> = match out.kind() {
-            rustc_type_ir::ConstKind::Param(_) => unimplemented!(),
-            rustc_type_ir::ConstKind::Infer(rustc_type_ir::InferConst::Var(var)) => {
-                chalk_ir::ConstValue::InferenceVar(chalk_ir::InferenceVar::from(var.as_u32()))
-            }
-            rustc_type_ir::ConstKind::Infer(rustc_type_ir::InferConst::Fresh(fresh)) => {
-                panic!("Vars should not be freshened.")
-            }
-            rustc_type_ir::ConstKind::Bound(debruijn_index, var) => {
-                chalk_ir::ConstValue::BoundVar(chalk_ir::BoundVar::new(
-                    chalk_ir::DebruijnIndex::new(debruijn_index.as_u32()),
-                    var.index(),
-                ))
-            }
-            rustc_type_ir::ConstKind::Placeholder(placeholder_const) => {
-                chalk_ir::ConstValue::Placeholder(chalk_ir::PlaceholderIndex {
-                    ui: chalk_ir::UniverseIndex { counter: placeholder_const.universe.as_usize() },
-                    idx: placeholder_const.bound.as_usize(),
-                })
-            }
-            rustc_type_ir::ConstKind::Unevaluated(unevaluated_const) => {
-                let id = match unevaluated_const.def {
-                    SolverDefId::ConstId(id) => GeneralConstId::ConstId(id),
-                    SolverDefId::StaticId(id) => GeneralConstId::StaticId(id),
-                    _ => unreachable!(),
-                };
-                let subst = ChalkToNextSolver::from_nextsolver(unevaluated_const.args, interner);
-                chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst {
-                    interned: ConstScalar::UnevaluatedConst(id, subst),
-                })
-            }
-            rustc_type_ir::ConstKind::Value(value_const) => {
-                let bytes = value_const.value.inner();
-                let value = chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst {
-                    // SAFETY: will never use this without a db
-                    interned: ConstScalar::Bytes(bytes.0.clone(), unsafe {
-                        std::mem::transmute::<MemoryMap<'_>, MemoryMap<'static>>(bytes.1.clone())
-                    }),
-                });
-                return chalk_ir::ConstData {
-                    ty: ChalkToNextSolver::from_nextsolver(value_const.ty, interner),
-                    value,
-                }
-                .intern(Interner);
-            }
-            rustc_type_ir::ConstKind::Error(_) => {
-                chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst {
-                    interned: ConstScalar::Unknown,
-                })
-            }
-            rustc_type_ir::ConstKind::Expr(_) => unimplemented!(),
-        };
-        chalk_ir::ConstData { ty: crate::TyKind::Error.intern(Interner), value }.intern(Interner)
+impl<'db> NextSolverToChalk<'db, chalk_ir::Const<Interner>> for Const<'db> {
+    fn to_chalk(self, interner: DbInterner<'db>) -> chalk_ir::Const<Interner> {
+        convert_const_for_result(interner, self)
     }
 }
 
@@ -946,13 +540,6 @@ impl<'db> ChalkToNextSolver<'db, rustc_type_ir::FnSigTys<DbInterner<'db>>>
             ),
         }
     }
-
-    fn from_nextsolver(
-        out: rustc_type_ir::FnSigTys<DbInterner<'db>>,
-        interner: DbInterner<'db>,
-    ) -> Self {
-        todo!()
-    }
 }
 
 impl<
@@ -971,13 +558,6 @@ impl<
             binders.to_nextsolver(interner),
         )
     }
-
-    fn from_nextsolver(
-        out: rustc_type_ir::Binder<DbInterner<'db>, U>,
-        interner: DbInterner<'db>,
-    ) -> Self {
-        todo!()
-    }
 }
 
 impl<'db> ChalkToNextSolver<'db, BoundVarKinds> for chalk_ir::VariableKinds<Interner> {
@@ -987,10 +567,6 @@ impl<'db> ChalkToNextSolver<'db, BoundVarKinds> for chalk_ir::VariableKinds<Inte
             self.iter(Interner).map(|v| v.to_nextsolver(interner)),
         )
     }
-
-    fn from_nextsolver(out: BoundVarKinds, interner: DbInterner<'db>) -> Self {
-        todo!()
-    }
 }
 
 impl<'db> ChalkToNextSolver<'db, BoundVarKind> for chalk_ir::VariableKind<Interner> {
@@ -1001,10 +577,6 @@ impl<'db> ChalkToNextSolver<'db, BoundVarKind> for chalk_ir::VariableKind<Intern
             chalk_ir::VariableKind::Const(_ty) => BoundVarKind::Const,
         }
     }
-
-    fn from_nextsolver(out: BoundVarKind, interner: DbInterner<'db>) -> Self {
-        todo!()
-    }
 }
 
 impl<'db> ChalkToNextSolver<'db, GenericArg<'db>> for chalk_ir::GenericArg<Interner> {
@@ -1015,11 +587,8 @@ impl<'db> ChalkToNextSolver<'db, GenericArg<'db>> for chalk_ir::GenericArg<Inter
             chalk_ir::GenericArgData::Const(const_) => const_.to_nextsolver(interner).into(),
         }
     }
-
-    fn from_nextsolver(out: GenericArg<'db>, interner: DbInterner<'db>) -> Self {
-        todo!()
-    }
 }
+
 impl<'db> ChalkToNextSolver<'db, GenericArgs<'db>> for chalk_ir::Substitution<Interner> {
     fn to_nextsolver(&self, interner: DbInterner<'db>) -> GenericArgs<'db> {
         GenericArgs::new_from_iter(
@@ -1027,30 +596,11 @@ impl<'db> ChalkToNextSolver<'db, GenericArgs<'db>> for chalk_ir::Substitution<In
             self.iter(Interner).map(|arg| -> GenericArg<'db> { arg.to_nextsolver(interner) }),
         )
     }
+}
 
-    fn from_nextsolver(out: GenericArgs<'db>, interner: DbInterner<'db>) -> Self {
-        let mut substs = Vec::with_capacity(out.len());
-        for arg in out.iter() {
-            match arg.clone().kind() {
-                rustc_type_ir::GenericArgKind::Type(ty) => {
-                    let ty = ChalkToNextSolver::from_nextsolver(ty, interner);
-                    substs.push(chalk_ir::GenericArgData::Ty(ty).intern(Interner));
-                }
-                rustc_type_ir::GenericArgKind::Lifetime(region) => {
-                    let lifetime = ChalkToNextSolver::from_nextsolver(region, interner);
-                    substs.push(chalk_ir::GenericArgData::Lifetime(lifetime).intern(Interner));
-                }
-                rustc_type_ir::GenericArgKind::Const(const_) => {
-                    substs.push(
-                        chalk_ir::GenericArgData::Const(ChalkToNextSolver::from_nextsolver(
-                            const_, interner,
-                        ))
-                        .intern(Interner),
-                    );
-                }
-            }
-        }
-        Substitution::from_iter(Interner, substs)
+impl<'db> NextSolverToChalk<'db, chalk_ir::Substitution<Interner>> for GenericArgs<'db> {
+    fn to_chalk(self, interner: DbInterner<'db>) -> chalk_ir::Substitution<Interner> {
+        convert_args_for_result(interner, self.as_slice())
     }
 }
 
@@ -1067,29 +617,29 @@ impl<'db> ChalkToNextSolver<'db, Tys<'db>> for chalk_ir::Substitution<Interner>
             }),
         )
     }
-
-    fn from_nextsolver(out: Tys<'db>, interner: DbInterner<'db>) -> Self {
-        todo!()
-    }
 }
 
 impl<'db> ChalkToNextSolver<'db, rustc_type_ir::DebruijnIndex> for chalk_ir::DebruijnIndex {
-    fn to_nextsolver(&self, interner: DbInterner<'db>) -> rustc_type_ir::DebruijnIndex {
+    fn to_nextsolver(&self, _interner: DbInterner<'db>) -> rustc_type_ir::DebruijnIndex {
         rustc_type_ir::DebruijnIndex::from_u32(self.depth())
     }
+}
 
-    fn from_nextsolver(out: rustc_type_ir::DebruijnIndex, interner: DbInterner<'db>) -> Self {
-        todo!()
+impl<'db> NextSolverToChalk<'db, chalk_ir::DebruijnIndex> for rustc_type_ir::DebruijnIndex {
+    fn to_chalk(self, _interner: DbInterner<'db>) -> chalk_ir::DebruijnIndex {
+        chalk_ir::DebruijnIndex::new(self.index() as u32)
     }
 }
 
 impl<'db> ChalkToNextSolver<'db, rustc_type_ir::UniverseIndex> for chalk_ir::UniverseIndex {
-    fn to_nextsolver(&self, interner: DbInterner<'db>) -> rustc_type_ir::UniverseIndex {
+    fn to_nextsolver(&self, _interner: DbInterner<'db>) -> rustc_type_ir::UniverseIndex {
         rustc_type_ir::UniverseIndex::from_u32(self.counter as u32)
     }
+}
 
-    fn from_nextsolver(out: rustc_type_ir::UniverseIndex, interner: DbInterner<'db>) -> Self {
-        todo!()
+impl<'db> NextSolverToChalk<'db, chalk_ir::UniverseIndex> for rustc_type_ir::UniverseIndex {
+    fn to_chalk(self, _interner: DbInterner<'db>) -> chalk_ir::UniverseIndex {
+        chalk_ir::UniverseIndex { counter: self.index() }
     }
 }
 
@@ -1109,10 +659,6 @@ impl<'db> ChalkToNextSolver<'db, rustc_type_ir::InferTy>
             }
         }
     }
-
-    fn from_nextsolver(out: rustc_type_ir::InferTy, interner: DbInterner<'db>) -> Self {
-        todo!()
-    }
 }
 
 impl<'db> ChalkToNextSolver<'db, rustc_ast_ir::Mutability> for chalk_ir::Mutability {
@@ -1122,10 +668,6 @@ impl<'db> ChalkToNextSolver<'db, rustc_ast_ir::Mutability> for chalk_ir::Mutabil
             chalk_ir::Mutability::Not => rustc_ast_ir::Mutability::Not,
         }
     }
-
-    fn from_nextsolver(out: rustc_ast_ir::Mutability, interner: DbInterner<'db>) -> Self {
-        todo!()
-    }
 }
 
 impl<'db> ChalkToNextSolver<'db, rustc_type_ir::Variance> for crate::Variance {
@@ -1137,10 +679,6 @@ impl<'db> ChalkToNextSolver<'db, rustc_type_ir::Variance> for crate::Variance {
             crate::Variance::Bivariant => rustc_type_ir::Variance::Bivariant,
         }
     }
-
-    fn from_nextsolver(out: rustc_type_ir::Variance, interner: DbInterner<'db>) -> Self {
-        todo!()
-    }
 }
 
 impl<'db> ChalkToNextSolver<'db, rustc_type_ir::Variance> for chalk_ir::Variance {
@@ -1151,10 +689,6 @@ impl<'db> ChalkToNextSolver<'db, rustc_type_ir::Variance> for chalk_ir::Variance
             chalk_ir::Variance::Contravariant => rustc_type_ir::Variance::Contravariant,
         }
     }
-
-    fn from_nextsolver(out: rustc_type_ir::Variance, interner: DbInterner<'db>) -> Self {
-        todo!()
-    }
 }
 
 impl<'db> ChalkToNextSolver<'db, VariancesOf> for chalk_ir::Variances<Interner> {
@@ -1164,10 +698,6 @@ impl<'db> ChalkToNextSolver<'db, VariancesOf> for chalk_ir::Variances<Interner>
             self.as_slice(Interner).iter().map(|v| v.to_nextsolver(interner)),
         )
     }
-
-    fn from_nextsolver(out: VariancesOf, interner: DbInterner<'db>) -> Self {
-        todo!()
-    }
 }
 
 impl<'db> ChalkToNextSolver<'db, Goal<DbInterner<'db>, Predicate<'db>>>
@@ -1180,14 +710,18 @@ impl<'db> ChalkToNextSolver<'db, Goal<DbInterner<'db>, Predicate<'db>>>
             self.goal.to_nextsolver(interner),
         )
     }
+}
 
-    fn from_nextsolver(
-        out: Goal<DbInterner<'db>, Predicate<'db>>,
+impl<'db> NextSolverToChalk<'db, chalk_ir::InEnvironment<chalk_ir::Goal<Interner>>>
+    for Goal<DbInterner<'db>, Predicate<'db>>
+{
+    fn to_chalk(
+        self,
         interner: DbInterner<'db>,
-    ) -> Self {
+    ) -> chalk_ir::InEnvironment<chalk_ir::Goal<Interner>> {
         chalk_ir::InEnvironment {
-            environment: ChalkToNextSolver::from_nextsolver(out.param_env, interner),
-            goal: ChalkToNextSolver::from_nextsolver(out.predicate, interner),
+            environment: self.param_env.to_chalk(interner),
+            goal: self.predicate.to_chalk(interner),
         }
     }
 }
@@ -1224,11 +758,15 @@ impl<'db, T: HasInterner<Interner = Interner> + ChalkToNextSolver<'db, U>, U>
             variables,
         }
     }
+}
 
-    fn from_nextsolver(out: Canonical<'db, U>, interner: DbInterner<'db>) -> Self {
+impl<'db, T: NextSolverToChalk<'db, U>, U: HasInterner<Interner = Interner>>
+    NextSolverToChalk<'db, chalk_ir::Canonical<U>> for Canonical<'db, T>
+{
+    fn to_chalk(self, interner: DbInterner<'db>) -> chalk_ir::Canonical<U> {
         let binders = chalk_ir::CanonicalVarKinds::from_iter(
             Interner,
-            out.variables.iter().map(|v| match v {
+            self.variables.iter().map(|v| match v {
                 rustc_type_ir::CanonicalVarKind::Ty(
                     rustc_type_ir::CanonicalTyVarKind::General(ui),
                 ) => chalk_ir::CanonicalVarKind::new(
@@ -1247,20 +785,20 @@ impl<'db, T: HasInterner<Interner = Interner> + ChalkToNextSolver<'db, U>, U>
                         chalk_ir::UniverseIndex::root(),
                     )
                 }
-                rustc_type_ir::CanonicalVarKind::PlaceholderTy(_) => todo!(),
                 rustc_type_ir::CanonicalVarKind::Region(ui) => chalk_ir::CanonicalVarKind::new(
                     chalk_ir::VariableKind::Lifetime,
                     chalk_ir::UniverseIndex { counter: ui.as_usize() },
                 ),
-                rustc_type_ir::CanonicalVarKind::PlaceholderRegion(_) => todo!(),
                 rustc_type_ir::CanonicalVarKind::Const(ui) => chalk_ir::CanonicalVarKind::new(
                     chalk_ir::VariableKind::Const(chalk_ir::TyKind::Error.intern(Interner)),
                     chalk_ir::UniverseIndex { counter: ui.as_usize() },
                 ),
-                rustc_type_ir::CanonicalVarKind::PlaceholderConst(_) => todo!(),
+                rustc_type_ir::CanonicalVarKind::PlaceholderTy(_) => unimplemented!(),
+                rustc_type_ir::CanonicalVarKind::PlaceholderRegion(_) => unimplemented!(),
+                rustc_type_ir::CanonicalVarKind::PlaceholderConst(_) => unimplemented!(),
             }),
         );
-        let value = ChalkToNextSolver::from_nextsolver(out.value, interner);
+        let value = self.value.to_chalk(interner);
         chalk_ir::Canonical { binders, value }
     }
 }
@@ -1281,9 +819,16 @@ impl<'db> ChalkToNextSolver<'db, Predicate<'db>> for chalk_ir::Goal<Interner> {
             chalk_ir::GoalData::All(goals) => panic!("Should not be constructed."),
             chalk_ir::GoalData::Not(goal) => panic!("Should not be constructed."),
             chalk_ir::GoalData::EqGoal(eq_goal) => {
+                let arg_to_term = |g: &chalk_ir::GenericArg<Interner>| match g.data(Interner) {
+                    chalk_ir::GenericArgData::Ty(ty) => Term::Ty(ty.to_nextsolver(interner)),
+                    chalk_ir::GenericArgData::Const(const_) => {
+                        Term::Const(const_.to_nextsolver(interner))
+                    }
+                    chalk_ir::GenericArgData::Lifetime(lifetime) => unreachable!(),
+                };
                 let pred_kind = PredicateKind::AliasRelate(
-                    Term::Ty(eq_goal.a.assert_ty_ref(Interner).clone().to_nextsolver(interner)),
-                    Term::Ty(eq_goal.b.assert_ty_ref(Interner).clone().to_nextsolver(interner)),
+                    arg_to_term(&eq_goal.a),
+                    arg_to_term(&eq_goal.b),
                     rustc_type_ir::AliasRelationDirection::Equate,
                 );
                 let pred_kind =
@@ -1314,123 +859,11 @@ impl<'db> ChalkToNextSolver<'db, Predicate<'db>> for chalk_ir::Goal<Interner> {
             chalk_ir::GoalData::CannotProve => panic!("Should not be constructed."),
         }
     }
+}
 
-    fn from_nextsolver(out: Predicate<'db>, interner: DbInterner<'db>) -> Self {
-        chalk_ir::Goal::new(
-            Interner,
-            match out.kind().skip_binder() {
-                rustc_type_ir::PredicateKind::Clause(rustc_type_ir::ClauseKind::Trait(
-                    trait_pred,
-                )) => {
-                    let trait_ref =
-                        ChalkToNextSolver::from_nextsolver(trait_pred.trait_ref, interner);
-                    let where_clause = chalk_ir::WhereClause::Implemented(trait_ref);
-                    chalk_ir::GoalData::DomainGoal(chalk_ir::DomainGoal::Holds(where_clause))
-                }
-                rustc_type_ir::PredicateKind::Clause(rustc_type_ir::ClauseKind::Projection(
-                    proj_predicate,
-                )) => {
-                    let associated_ty_id = match proj_predicate.def_id() {
-                        SolverDefId::TypeAliasId(id) => to_assoc_type_id(id),
-                        _ => unreachable!(),
-                    };
-                    let substitution = ChalkToNextSolver::from_nextsolver(
-                        proj_predicate.projection_term.args,
-                        interner,
-                    );
-                    let alias = chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy {
-                        associated_ty_id,
-                        substitution,
-                    });
-                    let ty = match proj_predicate.term.kind() {
-                        rustc_type_ir::TermKind::Ty(ty) => ty,
-                        rustc_type_ir::TermKind::Const(_) => todo!(),
-                    };
-                    let ty = ChalkToNextSolver::from_nextsolver(ty, interner);
-                    let alias_eq = chalk_ir::AliasEq { alias, ty };
-                    let where_clause = chalk_ir::WhereClause::AliasEq(alias_eq);
-                    chalk_ir::GoalData::DomainGoal(chalk_ir::DomainGoal::Holds(where_clause))
-                }
-                rustc_type_ir::PredicateKind::Clause(rustc_type_ir::ClauseKind::TypeOutlives(
-                    outlives,
-                )) => {
-                    let lifetime = ChalkToNextSolver::from_nextsolver(outlives.1, interner);
-                    let ty = ChalkToNextSolver::from_nextsolver(outlives.0, interner);
-                    let where_clause =
-                        chalk_ir::WhereClause::TypeOutlives(chalk_ir::TypeOutlives {
-                            lifetime,
-                            ty,
-                        });
-                    chalk_ir::GoalData::DomainGoal(chalk_ir::DomainGoal::Holds(where_clause))
-                }
-                rustc_type_ir::PredicateKind::Clause(
-                    rustc_type_ir::ClauseKind::RegionOutlives(outlives),
-                ) => {
-                    let a = ChalkToNextSolver::from_nextsolver(outlives.0, interner);
-                    let b = ChalkToNextSolver::from_nextsolver(outlives.1, interner);
-                    let where_clause =
-                        chalk_ir::WhereClause::LifetimeOutlives(chalk_ir::LifetimeOutlives {
-                            a,
-                            b,
-                        });
-                    chalk_ir::GoalData::DomainGoal(chalk_ir::DomainGoal::Holds(where_clause))
-                }
-                rustc_type_ir::PredicateKind::Clause(_) => todo!(),
-                rustc_type_ir::PredicateKind::DynCompatible(_) => todo!(),
-                rustc_type_ir::PredicateKind::Subtype(subtype_predicate) => todo!(),
-                rustc_type_ir::PredicateKind::Coerce(coerce_predicate) => todo!(),
-                rustc_type_ir::PredicateKind::ConstEquate(_, _) => todo!(),
-                rustc_type_ir::PredicateKind::Ambiguous => todo!(),
-                rustc_type_ir::PredicateKind::NormalizesTo(normalizes_to) => todo!(),
-                rustc_type_ir::PredicateKind::AliasRelate(
-                    alias_term,
-                    ty_term,
-                    alias_relation_direction,
-                ) => {
-                    let ty = match ty_term {
-                        Term::Ty(ty) => ChalkToNextSolver::from_nextsolver(ty, interner),
-                        Term::Const(..) => todo!(),
-                    };
-                    match alias_term {
-                        Term::Ty(alias_ty) => match alias_ty.kind() {
-                            rustc_type_ir::TyKind::Alias(kind, alias) => match kind {
-                                rustc_type_ir::AliasTyKind::Projection => {
-                                    let associated_ty_id = match alias.def_id {
-                                        SolverDefId::TypeAliasId(id) => to_assoc_type_id(id),
-                                        _ => todo!(),
-                                    };
-                                    let substitution =
-                                        ChalkToNextSolver::from_nextsolver(alias.args, interner);
-                                    let proj_ty =
-                                        chalk_ir::ProjectionTy { associated_ty_id, substitution };
-                                    let alias = chalk_ir::AliasTy::Projection(proj_ty);
-                                    let alias_eq = chalk_ir::AliasEq { alias, ty };
-                                    chalk_ir::GoalData::DomainGoal(chalk_ir::DomainGoal::Holds(
-                                        chalk_ir::WhereClause::AliasEq(alias_eq),
-                                    ))
-                                }
-                                _ => todo!(),
-                            },
-                            rustc_type_ir::TyKind::Infer(var) => {
-                                assert!(matches!(
-                                    alias_relation_direction,
-                                    rustc_type_ir::AliasRelationDirection::Equate
-                                ));
-                                let a: chalk_ir::Ty<_> =
-                                    ChalkToNextSolver::from_nextsolver(alias_ty, interner);
-                                let eq_goal = chalk_ir::EqGoal {
-                                    a: chalk_ir::GenericArgData::Ty(a).intern(Interner),
-                                    b: chalk_ir::GenericArgData::Ty(ty).intern(Interner),
-                                };
-                                chalk_ir::GoalData::EqGoal(eq_goal)
-                            }
-                            _ => todo!("Unexpected alias term {:?}", alias_term),
-                        },
-                        Term::Const(..) => todo!(),
-                    }
-                }
-            },
-        )
+impl<'db> NextSolverToChalk<'db, chalk_ir::Goal<Interner>> for Predicate<'db> {
+    fn to_chalk(self, interner: DbInterner<'db>) -> chalk_ir::Goal<Interner> {
+        chalk_ir::Goal::new(Interner, self.kind().skip_binder().to_chalk(interner))
     }
 }
 
@@ -1444,12 +877,14 @@ impl<'db> ChalkToNextSolver<'db, ParamEnv<'db>> for chalk_ir::Environment<Intern
             Clauses::new_from_iter(interner, elaborate::elaborate(interner, clauses.iter()));
         ParamEnv { clauses }
     }
+}
 
-    fn from_nextsolver(out: ParamEnv<'db>, interner: DbInterner<'db>) -> Self {
+impl<'db> NextSolverToChalk<'db, chalk_ir::Environment<Interner>> for ParamEnv<'db> {
+    fn to_chalk(self, interner: DbInterner<'db>) -> chalk_ir::Environment<Interner> {
         let clauses = chalk_ir::ProgramClauses::from_iter(
             Interner,
-            out.clauses.iter().map(|c| -> chalk_ir::ProgramClause<Interner> {
-                ChalkToNextSolver::from_nextsolver(c, interner)
+            self.clauses.iter().filter_map(|c| -> Option<chalk_ir::ProgramClause<Interner>> {
+                c.to_chalk(interner)
             }),
         );
         chalk_ir::Environment { clauses }
@@ -1460,15 +895,19 @@ impl<'db> ChalkToNextSolver<'db, Clause<'db>> for chalk_ir::ProgramClause<Intern
     fn to_nextsolver(&self, interner: DbInterner<'db>) -> Clause<'db> {
         Clause(Predicate::new(interner, self.data(Interner).0.to_nextsolver(interner)))
     }
+}
 
-    fn from_nextsolver(out: Clause<'db>, interner: DbInterner<'db>) -> Self {
-        chalk_ir::ProgramClause::new(
+impl<'db> NextSolverToChalk<'db, Option<chalk_ir::ProgramClause<Interner>>> for Clause<'db> {
+    fn to_chalk(self, interner: DbInterner<'db>) -> Option<chalk_ir::ProgramClause<Interner>> {
+        let value: chalk_ir::ProgramClauseImplication<Interner> =
+            <PredicateKind<'db> as NextSolverToChalk<
+                'db,
+                Option<chalk_ir::ProgramClauseImplication<Interner>>,
+            >>::to_chalk(self.0.kind().skip_binder(), interner)?;
+        Some(chalk_ir::ProgramClause::new(
             Interner,
-            chalk_ir::ProgramClauseData(chalk_ir::Binders::empty(
-                Interner,
-                ChalkToNextSolver::from_nextsolver(out.0.kind().skip_binder(), interner),
-            )),
-        )
+            chalk_ir::ProgramClauseData(chalk_ir::Binders::empty(Interner, value)),
+        ))
     }
 }
 
@@ -1480,13 +919,25 @@ impl<'db> ChalkToNextSolver<'db, PredicateKind<'db>>
         assert!(self.constraints.is_empty(Interner));
         self.consequence.to_nextsolver(interner)
     }
-    fn from_nextsolver(out: PredicateKind<'db>, interner: DbInterner<'db>) -> Self {
-        chalk_ir::ProgramClauseImplication {
-            consequence: ChalkToNextSolver::from_nextsolver(out, interner),
+}
+
+impl<'db> NextSolverToChalk<'db, Option<chalk_ir::ProgramClauseImplication<Interner>>>
+    for PredicateKind<'db>
+{
+    fn to_chalk(
+        self,
+        interner: DbInterner<'db>,
+    ) -> Option<chalk_ir::ProgramClauseImplication<Interner>> {
+        let chalk_ir::GoalData::DomainGoal(consequence) = self.to_chalk(interner) else {
+            return None;
+        };
+
+        Some(chalk_ir::ProgramClauseImplication {
+            consequence,
             conditions: chalk_ir::Goals::empty(Interner),
             constraints: chalk_ir::Constraints::empty(Interner),
             priority: chalk_ir::ClausePriority::High,
-        }
+        })
     }
 }
 
@@ -1606,13 +1057,15 @@ impl<'db> ChalkToNextSolver<'db, PredicateKind<'db>> for chalk_ir::DomainGoal<In
             chalk_ir::DomainGoal::ObjectSafe(trait_id) => panic!("Should not be constructed."),
         }
     }
+}
 
-    fn from_nextsolver(out: PredicateKind<'db>, interner: DbInterner<'db>) -> Self {
-        let domain_goal = match out {
+impl<'db> NextSolverToChalk<'db, chalk_ir::GoalData<Interner>> for PredicateKind<'db> {
+    fn to_chalk(self, interner: DbInterner<'db>) -> chalk_ir::GoalData<Interner> {
+        match self {
             rustc_type_ir::PredicateKind::Clause(rustc_type_ir::ClauseKind::Trait(trait_pred)) => {
-                let trait_ref = ChalkToNextSolver::from_nextsolver(trait_pred.trait_ref, interner);
+                let trait_ref = trait_pred.trait_ref.to_chalk(interner);
                 let where_clause = chalk_ir::WhereClause::Implemented(trait_ref);
-                chalk_ir::DomainGoal::Holds(where_clause)
+                chalk_ir::GoalData::DomainGoal(chalk_ir::DomainGoal::Holds(where_clause))
             }
             rustc_type_ir::PredicateKind::Clause(rustc_type_ir::ClauseKind::Projection(
                 proj_predicate,
@@ -1621,82 +1074,67 @@ impl<'db> ChalkToNextSolver<'db, PredicateKind<'db>> for chalk_ir::DomainGoal<In
                     SolverDefId::TypeAliasId(id) => to_assoc_type_id(id),
                     _ => unreachable!(),
                 };
-                let substitution = ChalkToNextSolver::from_nextsolver(
-                    proj_predicate.projection_term.args,
-                    interner,
-                );
+                let substitution = proj_predicate.projection_term.args.to_chalk(interner);
                 let alias = chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy {
                     associated_ty_id,
                     substitution,
                 });
                 let ty = match proj_predicate.term.kind() {
                     rustc_type_ir::TermKind::Ty(ty) => ty,
-                    rustc_type_ir::TermKind::Const(_) => todo!(),
+                    rustc_type_ir::TermKind::Const(_) => unimplemented!(),
                 };
-                let ty = ChalkToNextSolver::from_nextsolver(ty, interner);
+                let ty = ty.to_chalk(interner);
                 let alias_eq = chalk_ir::AliasEq { alias, ty };
                 let where_clause = chalk_ir::WhereClause::AliasEq(alias_eq);
-                chalk_ir::DomainGoal::Holds(where_clause)
+                chalk_ir::GoalData::DomainGoal(chalk_ir::DomainGoal::Holds(where_clause))
             }
             rustc_type_ir::PredicateKind::Clause(rustc_type_ir::ClauseKind::TypeOutlives(
                 outlives,
             )) => {
-                let lifetime = ChalkToNextSolver::from_nextsolver(outlives.1, interner);
-                let ty = ChalkToNextSolver::from_nextsolver(outlives.0, interner);
+                let lifetime = outlives.1.to_chalk(interner);
+                let ty = outlives.0.to_chalk(interner);
                 let where_clause =
                     chalk_ir::WhereClause::TypeOutlives(chalk_ir::TypeOutlives { lifetime, ty });
-                chalk_ir::DomainGoal::Holds(where_clause)
+                chalk_ir::GoalData::DomainGoal(chalk_ir::DomainGoal::Holds(where_clause))
             }
             rustc_type_ir::PredicateKind::Clause(rustc_type_ir::ClauseKind::RegionOutlives(
                 outlives,
             )) => {
-                let a = ChalkToNextSolver::from_nextsolver(outlives.0, interner);
-                let b = ChalkToNextSolver::from_nextsolver(outlives.1, interner);
+                let a = outlives.0.to_chalk(interner);
+                let b = outlives.1.to_chalk(interner);
                 let where_clause =
                     chalk_ir::WhereClause::LifetimeOutlives(chalk_ir::LifetimeOutlives { a, b });
-                chalk_ir::DomainGoal::Holds(where_clause)
+                chalk_ir::GoalData::DomainGoal(chalk_ir::DomainGoal::Holds(where_clause))
             }
-            rustc_type_ir::PredicateKind::Clause(_) => todo!(),
-            rustc_type_ir::PredicateKind::DynCompatible(_) => todo!(),
-            rustc_type_ir::PredicateKind::Subtype(subtype_predicate) => todo!(),
-            rustc_type_ir::PredicateKind::Coerce(coerce_predicate) => todo!(),
-            rustc_type_ir::PredicateKind::ConstEquate(_, _) => todo!(),
-            rustc_type_ir::PredicateKind::Ambiguous => todo!(),
-            rustc_type_ir::PredicateKind::NormalizesTo(normalizes_to) => todo!(),
             rustc_type_ir::PredicateKind::AliasRelate(
                 alias_term,
-                ty_term,
+                target_term,
                 alias_relation_direction,
             ) => {
-                let alias = match alias_term {
-                    Term::Ty(alias_ty) => match alias_ty.kind() {
-                        rustc_type_ir::TyKind::Alias(kind, alias) => match kind {
-                            rustc_type_ir::AliasTyKind::Projection => {
-                                let associated_ty_id = match alias.def_id {
-                                    SolverDefId::TypeAliasId(id) => to_assoc_type_id(id),
-                                    _ => todo!(),
-                                };
-                                let substitution =
-                                    ChalkToNextSolver::from_nextsolver(alias.args, interner);
-                                let proj_ty =
-                                    chalk_ir::ProjectionTy { associated_ty_id, substitution };
-                                chalk_ir::AliasTy::Projection(proj_ty)
-                            }
-                            _ => todo!(),
-                        },
-                        _ => todo!(),
-                    },
-                    Term::Const(..) => todo!(),
-                };
-                let ty = match ty_term {
-                    Term::Ty(ty) => ChalkToNextSolver::from_nextsolver(ty, interner),
-                    Term::Const(..) => todo!(),
+                let term_to_generic_arg = |term: Term<'db>| match term {
+                    Term::Ty(ty) => chalk_ir::GenericArg::new(
+                        Interner,
+                        chalk_ir::GenericArgData::Ty(ty.to_chalk(interner)),
+                    ),
+                    Term::Const(const_) => chalk_ir::GenericArg::new(
+                        Interner,
+                        chalk_ir::GenericArgData::Const(const_.to_chalk(interner)),
+                    ),
                 };
-                let alias_eq = chalk_ir::AliasEq { alias, ty };
-                chalk_ir::DomainGoal::Holds(chalk_ir::WhereClause::AliasEq(alias_eq))
+
+                chalk_ir::GoalData::EqGoal(chalk_ir::EqGoal {
+                    a: term_to_generic_arg(alias_term),
+                    b: term_to_generic_arg(target_term),
+                })
             }
-        };
-        domain_goal
+            rustc_type_ir::PredicateKind::Clause(_) => unimplemented!(),
+            rustc_type_ir::PredicateKind::DynCompatible(_) => unimplemented!(),
+            rustc_type_ir::PredicateKind::Subtype(_) => unimplemented!(),
+            rustc_type_ir::PredicateKind::Coerce(_) => unimplemented!(),
+            rustc_type_ir::PredicateKind::ConstEquate(_, _) => unimplemented!(),
+            rustc_type_ir::PredicateKind::Ambiguous => unimplemented!(),
+            rustc_type_ir::PredicateKind::NormalizesTo(_) => unimplemented!(),
+        }
     }
 }
 
@@ -1705,13 +1143,12 @@ impl<'db> ChalkToNextSolver<'db, TraitRef<'db>> for chalk_ir::TraitRef<Interner>
         let args = self.substitution.to_nextsolver(interner);
         TraitRef::new_from_args(interner, from_chalk_trait_id(self.trait_id).into(), args)
     }
+}
 
-    fn from_nextsolver(out: TraitRef<'db>, interner: DbInterner<'db>) -> Self {
-        let trait_id = match out.def_id {
-            SolverDefId::TraitId(id) => to_chalk_trait_id(id),
-            _ => unreachable!(),
-        };
-        let substitution = ChalkToNextSolver::from_nextsolver(out.args, interner);
+impl<'db> NextSolverToChalk<'db, chalk_ir::TraitRef<Interner>> for TraitRef<'db> {
+    fn to_chalk(self, interner: DbInterner<'db>) -> chalk_ir::TraitRef<Interner> {
+        let trait_id = to_chalk_trait_id(self.def_id.0);
+        let substitution = self.args.to_chalk(interner);
         chalk_ir::TraitRef { trait_id, substitution }
     }
 }
@@ -1754,9 +1191,17 @@ impl<'db> ChalkToNextSolver<'db, PredicateKind<'db>> for chalk_ir::WhereClause<I
             }
         }
     }
+}
 
-    fn from_nextsolver(out: PredicateKind<'db>, interner: DbInterner<'db>) -> Self {
-        todo!()
+impl<'db, I> NextSolverToChalk<'db, chalk_ir::ConstrainedSubst<Interner>> for I
+where
+    I: IntoIterator<Item = GenericArg<'db>>,
+{
+    fn to_chalk(self, interner: DbInterner<'db>) -> chalk_ir::ConstrainedSubst<Interner> {
+        chalk_ir::ConstrainedSubst {
+            constraints: chalk_ir::Constraints::empty(Interner),
+            subst: GenericArgs::new_from_iter(interner, self).to_chalk(interner),
+        }
     }
 }
 
@@ -1764,51 +1209,7 @@ pub fn convert_canonical_args_for_result<'db>(
     interner: DbInterner<'db>,
     args: Canonical<'db, Vec<GenericArg<'db>>>,
 ) -> chalk_ir::Canonical<chalk_ir::ConstrainedSubst<Interner>> {
-    let Canonical { value, variables, max_universe } = args;
-    let binders = CanonicalVarKinds::from_iter(
-        Interner,
-        variables.iter().map(|v| match v {
-            rustc_type_ir::CanonicalVarKind::Ty(rustc_type_ir::CanonicalTyVarKind::General(_)) => {
-                CanonicalVarKind::new(
-                    chalk_ir::VariableKind::Ty(TyVariableKind::General),
-                    chalk_ir::UniverseIndex::ROOT,
-                )
-            }
-            rustc_type_ir::CanonicalVarKind::Ty(rustc_type_ir::CanonicalTyVarKind::Int) => {
-                CanonicalVarKind::new(
-                    chalk_ir::VariableKind::Ty(TyVariableKind::Integer),
-                    chalk_ir::UniverseIndex::ROOT,
-                )
-            }
-            rustc_type_ir::CanonicalVarKind::Ty(rustc_type_ir::CanonicalTyVarKind::Float) => {
-                CanonicalVarKind::new(
-                    chalk_ir::VariableKind::Ty(TyVariableKind::Float),
-                    chalk_ir::UniverseIndex::ROOT,
-                )
-            }
-            rustc_type_ir::CanonicalVarKind::Region(universe_index) => CanonicalVarKind::new(
-                chalk_ir::VariableKind::Lifetime,
-                chalk_ir::UniverseIndex::ROOT,
-            ),
-            rustc_type_ir::CanonicalVarKind::Const(universe_index) => CanonicalVarKind::new(
-                chalk_ir::VariableKind::Const(crate::TyKind::Error.intern(Interner)),
-                chalk_ir::UniverseIndex::ROOT,
-            ),
-            rustc_type_ir::CanonicalVarKind::PlaceholderTy(_) => unimplemented!(),
-            rustc_type_ir::CanonicalVarKind::PlaceholderRegion(_) => unimplemented!(),
-            rustc_type_ir::CanonicalVarKind::PlaceholderConst(_) => unimplemented!(),
-        }),
-    );
-    chalk_ir::Canonical {
-        binders,
-        value: chalk_ir::ConstrainedSubst {
-            constraints: chalk_ir::Constraints::empty(Interner),
-            subst: ChalkToNextSolver::from_nextsolver(
-                GenericArgs::new_from_iter(interner, value),
-                interner,
-            ),
-        },
-    }
+    args.to_chalk(interner)
 }
 
 pub fn convert_args_for_result<'db>(
@@ -1897,7 +1298,7 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
 
         rustc_type_ir::TyKind::Adt(def, args) => {
             let adt_id = def.inner().id;
-            let subst = ChalkToNextSolver::from_nextsolver(args, interner);
+            let subst = convert_args_for_result(interner, args.as_slice());
             TyKind::Adt(chalk_ir::AdtId(adt_id), subst)
         }
 
@@ -1912,7 +1313,11 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
                 rustc_type_ir::InferTy::FloatVar(var) => {
                     (InferenceVar::from(var.as_u32()), TyVariableKind::Float)
                 }
-                _ => todo!(),
+                rustc_type_ir::InferTy::FreshFloatTy(..)
+                | rustc_type_ir::InferTy::FreshIntTy(..)
+                | rustc_type_ir::InferTy::FreshTy(..) => {
+                    panic!("Freshening shouldn't happen.")
+                }
             };
             TyKind::InferenceVar(var, kind)
         }
@@ -1932,7 +1337,7 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
             let subst = Substitution::from_iter(
                 Interner,
                 tys.iter().map(|ty| {
-                    chalk_ir::GenericArgData::Ty(ChalkToNextSolver::from_nextsolver(ty, interner))
+                    chalk_ir::GenericArgData::Ty(convert_ty_for_result(interner, ty))
                         .intern(Interner)
                 }),
             );
@@ -1940,8 +1345,8 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
         }
 
         rustc_type_ir::TyKind::Array(ty, const_) => {
-            let ty = ChalkToNextSolver::from_nextsolver(ty, interner);
-            let const_ = ChalkToNextSolver::from_nextsolver(const_, interner);
+            let ty = convert_ty_for_result(interner, ty);
+            let const_ = convert_const_for_result(interner, const_);
             TyKind::Array(ty, const_)
         }
 
@@ -1952,7 +1357,7 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
                     _ => unreachable!(),
                 };
                 let associated_ty_id = to_assoc_type_id(assoc_ty_id);
-                let substitution = ChalkToNextSolver::from_nextsolver(alias_ty.args, interner);
+                let substitution = convert_args_for_result(interner, alias_ty.args.as_slice());
                 TyKind::AssociatedType(associated_ty_id, substitution)
             }
             rustc_type_ir::AliasTyKind::Opaque => {
@@ -1960,14 +1365,14 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
                     SolverDefId::InternedOpaqueTyId(id) => id,
                     _ => unreachable!(),
                 };
-                let substitution = ChalkToNextSolver::from_nextsolver(alias_ty.args, interner);
+                let substitution = convert_args_for_result(interner, alias_ty.args.as_slice());
                 TyKind::Alias(chalk_ir::AliasTy::Opaque(chalk_ir::OpaqueTy {
                     opaque_ty_id: opaque_ty_id.into(),
                     substitution,
                 }))
             }
-            rustc_type_ir::AliasTyKind::Inherent => todo!(),
-            rustc_type_ir::AliasTyKind::Free => todo!(),
+            rustc_type_ir::AliasTyKind::Inherent => unimplemented!(),
+            rustc_type_ir::AliasTyKind::Free => unimplemented!(),
         },
 
         // For `Placeholder`, `Bound` and `Param`, see the comment on the reverse conversion.
@@ -2002,7 +1407,7 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
                 interner,
                 bound_sig.skip_binder().inputs_and_output.iter().map(|a| a.into()),
             );
-            let substitution = ChalkToNextSolver::from_nextsolver(args, interner);
+            let substitution = convert_args_for_result(interner, args.as_slice());
             let substitution = chalk_ir::FnSubst(substitution);
             let fnptr = chalk_ir::FnPointer { num_binders, sig, substitution };
             TyKind::Function(fnptr)
@@ -2045,11 +1450,11 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
                             let trait_ref = TraitRef::new(
                                 interner,
                                 trait_ref.def_id,
-                                [self_ty.clone().into()].into_iter().chain(trait_ref.args.iter()),
+                                [self_ty.into()].into_iter().chain(trait_ref.args.iter()),
                             );
                             let trait_id = to_chalk_trait_id(trait_ref.def_id.0);
                             let substitution =
-                                ChalkToNextSolver::from_nextsolver(trait_ref.args, interner);
+                                convert_args_for_result(interner, trait_ref.args.as_slice());
                             let trait_ref = chalk_ir::TraitRef { trait_id, substitution };
                             chalk_ir::WhereClause::Implemented(trait_ref)
                         }
@@ -2067,19 +1472,19 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
                                 projection_term: AliasTerm::new(
                                     interner,
                                     existential_projection.def_id,
-                                    [self_ty.clone().into()]
+                                    [self_ty.into()]
                                         .iter()
-                                        .chain(existential_projection.args.clone().iter()),
+                                        .chain(existential_projection.args.iter()),
                                 ),
-                                term: existential_projection.term.clone(),
+                                term: existential_projection.term,
                             };
                             let associated_ty_id = match projection.projection_term.def_id {
                                 SolverDefId::TypeAliasId(id) => to_assoc_type_id(id),
                                 _ => unreachable!(),
                             };
-                            let substitution = ChalkToNextSolver::from_nextsolver(
-                                projection.projection_term.args,
+                            let substitution = convert_args_for_result(
                                 interner,
+                                projection.projection_term.args.as_slice(),
                             );
                             let alias = chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy {
                                 associated_ty_id,
@@ -2089,7 +1494,7 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
                                 Term::Ty(ty) => ty,
                                 _ => unreachable!(),
                             };
-                            let ty = ChalkToNextSolver::from_nextsolver(ty, interner);
+                            let ty = convert_ty_for_result(interner, ty);
                             let alias_eq = chalk_ir::AliasEq { alias, ty };
                             chalk_ir::WhereClause::AliasEq(alias_eq)
                         }
@@ -2108,7 +1513,7 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
         }
 
         rustc_type_ir::TyKind::Slice(ty) => {
-            let ty = ChalkToNextSolver::from_nextsolver(ty, interner);
+            let ty = convert_ty_for_result(interner, ty);
             TyKind::Slice(ty)
         }
 
@@ -2119,29 +1524,24 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
             };
             TyKind::Foreign(to_foreign_def_id(def_id))
         }
-        rustc_type_ir::TyKind::Pat(_, _) => todo!(),
+        rustc_type_ir::TyKind::Pat(_, _) => unimplemented!(),
         rustc_type_ir::TyKind::RawPtr(ty, mutability) => {
             let mutability = match mutability {
                 rustc_ast_ir::Mutability::Mut => chalk_ir::Mutability::Mut,
                 rustc_ast_ir::Mutability::Not => chalk_ir::Mutability::Not,
             };
-            let ty = ChalkToNextSolver::from_nextsolver(ty, interner);
+            let ty = convert_ty_for_result(interner, ty);
             TyKind::Raw(mutability, ty)
         }
         rustc_type_ir::TyKind::FnDef(def_id, args) => {
-            let subst = ChalkToNextSolver::from_nextsolver(args, interner);
-            match def_id {
-                SolverDefId::FunctionId(id) => {
-                    TyKind::FnDef(CallableDefId::FunctionId(id).to_chalk(interner.db()), subst)
-                }
-                SolverDefId::Ctor(Ctor::Enum(e)) => {
-                    TyKind::FnDef(CallableDefId::EnumVariantId(e).to_chalk(interner.db()), subst)
-                }
-                SolverDefId::Ctor(Ctor::Struct(s)) => {
-                    TyKind::FnDef(CallableDefId::StructId(s).to_chalk(interner.db()), subst)
-                }
-                _ => unreachable!("Unexpected def id {:?}", def_id),
-            }
+            let id = match def_id {
+                SolverDefId::FunctionId(id) => CallableDefId::FunctionId(id),
+                SolverDefId::Ctor(Ctor::Struct(id)) => CallableDefId::StructId(id),
+                SolverDefId::Ctor(Ctor::Enum(id)) => CallableDefId::EnumVariantId(id),
+                _ => unreachable!(),
+            };
+            let subst = convert_args_for_result(interner, args.as_slice());
+            TyKind::FnDef(id.to_chalk(interner.db()), subst)
         }
 
         rustc_type_ir::TyKind::Closure(def_id, args) => {
@@ -2149,16 +1549,16 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
                 SolverDefId::InternedClosureId(id) => id,
                 _ => unreachable!(),
             };
-            let subst = ChalkToNextSolver::from_nextsolver(args, interner);
+            let subst = convert_args_for_result(interner, args.as_slice());
             TyKind::Closure(id.into(), subst)
         }
-        rustc_type_ir::TyKind::CoroutineClosure(_, _) => todo!(),
+        rustc_type_ir::TyKind::CoroutineClosure(_, _) => unimplemented!(),
         rustc_type_ir::TyKind::Coroutine(def_id, args) => {
             let id = match def_id {
                 SolverDefId::InternedCoroutineId(id) => id,
                 _ => unreachable!(),
             };
-            let subst = ChalkToNextSolver::from_nextsolver(args, interner);
+            let subst = convert_args_for_result(interner, args.as_slice());
             TyKind::Coroutine(id.into(), subst)
         }
         rustc_type_ir::TyKind::CoroutineWitness(def_id, args) => {
@@ -2166,7 +1566,7 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
                 SolverDefId::InternedCoroutineId(id) => id,
                 _ => unreachable!(),
             };
-            let subst = ChalkToNextSolver::from_nextsolver(args, interner);
+            let subst = convert_args_for_result(interner, args.as_slice());
             TyKind::CoroutineWitness(id.into(), subst)
         }
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
index b9b2950a94a3b..385149d78432e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
@@ -9,12 +9,12 @@ use rustc_type_ir::{
     solve::{Certainty, NoSolution},
 };
 
+use crate::next_solver::mapping::NextSolverToChalk;
 use crate::{
     TraitRefExt,
     db::HirDatabase,
     next_solver::{
-        ClauseKind, CoercePredicate, PredicateKind, SubtypePredicate,
-        mapping::ChalkToNextSolver,
+        ClauseKind, CoercePredicate, PredicateKind, SubtypePredicate, mapping::ChalkToNextSolver,
         util::sizedness_fast_path,
     },
 };
@@ -200,7 +200,7 @@ impl<'db> SolverDelegate for SolverContext<'db> {
             SolverDefId::StaticId(c) => GeneralConstId::StaticId(c),
             _ => unreachable!(),
         };
-        let subst = ChalkToNextSolver::from_nextsolver(uv.args, self.interner);
+        let subst = uv.args.to_chalk(self.interner);
         let ec = self.cx().db.const_eval(c, subst, None).ok()?;
         Some(ec.to_nextsolver(self.interner))
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/coercion.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/coercion.rs
index 3b7d4d2184a59..7ec5231a7341a 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/coercion.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/coercion.rs
@@ -49,7 +49,7 @@ fn let_stmt_coerce() {
 //- minicore: coerce_unsized
 fn test() {
     let x: &[isize] = &[1];
-                   // ^^^^ adjustments: Deref(None), Borrow(Ref('?2, Not)), Pointer(Unsize)
+                   // ^^^^ adjustments: Deref(None), Borrow(Ref('?1, Not)), Pointer(Unsize)
     let x: *const [isize] = &[1];
                          // ^^^^ adjustments: Deref(None), Borrow(RawPtr(Not)), Pointer(Unsize)
 }
@@ -96,7 +96,7 @@ fn foo<T>(x: &[T]) -> &[T] { x }
 fn test() {
     let x = if true {
         foo(&[1])
-         // ^^^^ adjustments: Deref(None), Borrow(Ref('?11, Not)), Pointer(Unsize)
+         // ^^^^ adjustments: Deref(None), Borrow(Ref('?1, Not)), Pointer(Unsize)
     } else {
         &[1]
     };
@@ -148,7 +148,7 @@ fn foo<T>(x: &[T]) -> &[T] { x }
 fn test(i: i32) {
     let x = match i {
         2 => foo(&[2]),
-              // ^^^^ adjustments: Deref(None), Borrow(Ref('?11, Not)), Pointer(Unsize)
+              // ^^^^ adjustments: Deref(None), Borrow(Ref('?1, Not)), Pointer(Unsize)
         1 => &[1],
         _ => &[3],
     };
@@ -881,7 +881,7 @@ fn adjust_index() {
 fn test() {
     let x = [1, 2, 3];
     x[2] = 6;
- // ^ adjustments: Borrow(Ref('?8, Mut))
+ // ^ adjustments: Borrow(Ref('?0, Mut))
 }
     ",
     );
@@ -906,11 +906,11 @@ impl core::ops::IndexMut<usize> for StructMut {
 }
 fn test() {
     Struct[0];
- // ^^^^^^ adjustments: Borrow(Ref('?2, Not))
+ // ^^^^^^ adjustments: Borrow(Ref('?0, Not))
     StructMut[0];
- // ^^^^^^^^^ adjustments: Borrow(Ref('?5, Not))
+ // ^^^^^^^^^ adjustments: Borrow(Ref('?1, Not))
     &mut StructMut[0];
-      // ^^^^^^^^^ adjustments: Borrow(Ref('?8, Mut))
+      // ^^^^^^^^^ adjustments: Borrow(Ref('?2, Mut))
 }",
     );
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
index df9061d23bf5d..d79639b93727b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
@@ -589,6 +589,7 @@ fn main() {
                 "attrs_shim",
                 "attrs_shim",
                 "return_type_impl_traits_shim",
+                "generic_predicates_ns_shim",
                 "infer_shim",
                 "function_signature_shim",
                 "function_signature_with_source_map_shim",
@@ -605,8 +606,6 @@ fn main() {
                 "impl_signature_shim",
                 "impl_signature_with_source_map_shim",
                 "callable_item_signature_shim",
-                "adt_variance_shim",
-                "variances_of_shim",
                 "trait_impls_in_deps_shim",
                 "trait_impls_in_crate_shim",
                 "impl_trait_with_diagnostics_shim",
@@ -615,7 +614,6 @@ fn main() {
                 "impl_trait_with_diagnostics_ns_shim",
                 "impl_self_ty_with_diagnostics_ns_shim",
                 "generic_predicates_ns_shim",
-                "generic_predicates_ns_shim",
                 "value_ty_shim",
                 "generic_predicates_shim",
                 "lang_item",
@@ -691,6 +689,7 @@ fn main() {
                 "attrs_shim",
                 "attrs_shim",
                 "return_type_impl_traits_shim",
+                "generic_predicates_ns_shim",
                 "infer_shim",
                 "function_signature_with_source_map_shim",
                 "expr_scopes_shim",
@@ -706,7 +705,6 @@ fn main() {
                 "impl_trait_with_diagnostics_ns_shim",
                 "impl_self_ty_with_diagnostics_ns_shim",
                 "generic_predicates_ns_shim",
-                "generic_predicates_ns_shim",
                 "generic_predicates_shim",
             ]
         "#]],
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/macros.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/macros.rs
index 5d088e40cdeda..6490554b22b7d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/macros.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/macros.rs
@@ -202,7 +202,7 @@ fn expr_macro_def_expanded_in_various_places() {
             100..119 'for _ ...!() {}': {unknown}
             100..119 'for _ ...!() {}': &'? mut {unknown}
             100..119 'for _ ...!() {}': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
-            100..119 'for _ ...!() {}': Option<{unknown}>
+            100..119 'for _ ...!() {}': Option<<{unknown} as Iterator>::Item>
             100..119 'for _ ...!() {}': ()
             100..119 'for _ ...!() {}': ()
             100..119 'for _ ...!() {}': ()
@@ -296,7 +296,7 @@ fn expr_macro_rules_expanded_in_various_places() {
             114..133 'for _ ...!() {}': {unknown}
             114..133 'for _ ...!() {}': &'? mut {unknown}
             114..133 'for _ ...!() {}': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
-            114..133 'for _ ...!() {}': Option<{unknown}>
+            114..133 'for _ ...!() {}': Option<<{unknown} as Iterator>::Item>
             114..133 'for _ ...!() {}': ()
             114..133 'for _ ...!() {}': ()
             114..133 'for _ ...!() {}': ()
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs
index f09b3ef6bfd0f..d50daf0f0d5be 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs
@@ -1876,9 +1876,9 @@ impl Foo {
 }
 fn test() {
     Foo.foo();
-  //^^^ adjustments: Borrow(Ref('?1, Not))
+  //^^^ adjustments: Borrow(Ref('?0, Not))
     (&Foo).foo();
-  // ^^^^ adjustments: Deref(None), Borrow(Ref('?3, Not))
+  // ^^^^ adjustments: Deref(None), Borrow(Ref('?2, Not))
 }
 "#,
     );
@@ -1892,7 +1892,7 @@ fn receiver_adjustment_unsize_array() {
 fn test() {
     let a = [1, 2, 3];
     a.len();
-} //^ adjustments: Borrow(Ref('?7, Not)), Pointer(Unsize)
+} //^ adjustments: Borrow(Ref('?0, Not)), Pointer(Unsize)
 "#,
     );
 }
@@ -2105,7 +2105,7 @@ impl Foo {
 }
 fn test() {
     Box::new(Foo).foo();
-  //^^^^^^^^^^^^^ adjustments: Deref(None), Borrow(Ref('?5, Not))
+  //^^^^^^^^^^^^^ adjustments: Deref(None), Borrow(Ref('?0, Not))
 }
 "#,
     );
@@ -2123,7 +2123,7 @@ impl Foo {
 use core::mem::ManuallyDrop;
 fn test() {
     ManuallyDrop::new(Foo).foo();
-  //^^^^^^^^^^^^^^^^^^^^^^ adjustments: Deref(Some(OverloadedDeref(Some(Not)))), Borrow(Ref('?6, Not))
+  //^^^^^^^^^^^^^^^^^^^^^^ adjustments: Deref(Some(OverloadedDeref(Some(Not)))), Borrow(Ref('?0, Not))
 }
 "#,
     );
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/never_type.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/never_type.rs
index 6a9135622deb6..baca7f2318e22 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/never_type.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/never_type.rs
@@ -362,12 +362,12 @@ fn diverging_expression_3_break() {
             140..141 'x': u32
             149..175 '{ for ...; }; }': u32
             151..172 'for a ...eak; }': fn into_iter<{unknown}>({unknown}) -> <{unknown} as IntoIterator>::IntoIter
-            151..172 'for a ...eak; }': {unknown}
+            151..172 'for a ...eak; }': <{unknown} as IntoIterator>::IntoIter
             151..172 'for a ...eak; }': !
-            151..172 'for a ...eak; }': {unknown}
-            151..172 'for a ...eak; }': &'? mut {unknown}
+            151..172 'for a ...eak; }': <{unknown} as IntoIterator>::IntoIter
+            151..172 'for a ...eak; }': &'? mut <{unknown} as IntoIterator>::IntoIter
             151..172 'for a ...eak; }': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
-            151..172 'for a ...eak; }': Option<{unknown}>
+            151..172 'for a ...eak; }': Option<<{unknown} as Iterator>::Item>
             151..172 'for a ...eak; }': ()
             151..172 'for a ...eak; }': ()
             151..172 'for a ...eak; }': ()
@@ -379,12 +379,12 @@ fn diverging_expression_3_break() {
             226..227 'x': u32
             235..253 '{ for ... {}; }': u32
             237..250 'for a in b {}': fn into_iter<{unknown}>({unknown}) -> <{unknown} as IntoIterator>::IntoIter
-            237..250 'for a in b {}': {unknown}
+            237..250 'for a in b {}': <{unknown} as IntoIterator>::IntoIter
             237..250 'for a in b {}': !
-            237..250 'for a in b {}': {unknown}
-            237..250 'for a in b {}': &'? mut {unknown}
+            237..250 'for a in b {}': <{unknown} as IntoIterator>::IntoIter
+            237..250 'for a in b {}': &'? mut <{unknown} as IntoIterator>::IntoIter
             237..250 'for a in b {}': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
-            237..250 'for a in b {}': Option<{unknown}>
+            237..250 'for a in b {}': Option<<{unknown} as Iterator>::Item>
             237..250 'for a in b {}': ()
             237..250 'for a in b {}': ()
             237..250 'for a in b {}': ()
@@ -395,12 +395,12 @@ fn diverging_expression_3_break() {
             304..305 'x': u32
             313..340 '{ for ...; }; }': u32
             315..337 'for a ...urn; }': fn into_iter<{unknown}>({unknown}) -> <{unknown} as IntoIterator>::IntoIter
-            315..337 'for a ...urn; }': {unknown}
+            315..337 'for a ...urn; }': <{unknown} as IntoIterator>::IntoIter
             315..337 'for a ...urn; }': !
-            315..337 'for a ...urn; }': {unknown}
-            315..337 'for a ...urn; }': &'? mut {unknown}
+            315..337 'for a ...urn; }': <{unknown} as IntoIterator>::IntoIter
+            315..337 'for a ...urn; }': &'? mut <{unknown} as IntoIterator>::IntoIter
             315..337 'for a ...urn; }': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
-            315..337 'for a ...urn; }': Option<{unknown}>
+            315..337 'for a ...urn; }': Option<<{unknown} as Iterator>::Item>
             315..337 'for a ...urn; }': ()
             315..337 'for a ...urn; }': ()
             315..337 'for a ...urn; }': ()
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/opaque_types.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/opaque_types.rs
index 11d1a58e5367e..256ca7defb78a 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/opaque_types.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/opaque_types.rs
@@ -134,6 +134,9 @@ static ALIAS: AliasTy = {
 "#,
     );
 
+    // FIXME(next-solver): This should emit type mismatch error but leaving it for now
+    // as we should fully migrate into next-solver without chalk-ir and TAIT should be
+    // reworked on r-a to handle `#[define_opaque(T)]`
     check_infer_with_mismatches(
         r#"
 trait Trait {}
@@ -155,7 +158,6 @@ static ALIAS: i32 = {
             191..193 '_a': impl Trait + ?Sized
             205..211 'Struct': Struct
             217..218 '5': i32
-            205..211: expected impl Trait + ?Sized, got Struct
         "#]],
     )
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/patterns.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/patterns.rs
index 4949d4016bf15..60a2641e1a20e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/patterns.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/patterns.rs
@@ -48,12 +48,12 @@ fn infer_pattern() {
             83..84 '1': i32
             86..93 '"hello"': &'static str
             101..151 'for (e...     }': fn into_iter<{unknown}>({unknown}) -> <{unknown} as IntoIterator>::IntoIter
-            101..151 'for (e...     }': {unknown}
+            101..151 'for (e...     }': <{unknown} as IntoIterator>::IntoIter
             101..151 'for (e...     }': !
-            101..151 'for (e...     }': {unknown}
-            101..151 'for (e...     }': &'? mut {unknown}
+            101..151 'for (e...     }': <{unknown} as IntoIterator>::IntoIter
+            101..151 'for (e...     }': &'? mut <{unknown} as IntoIterator>::IntoIter
             101..151 'for (e...     }': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
-            101..151 'for (e...     }': Option<({unknown}, {unknown})>
+            101..151 'for (e...     }': Option<<{unknown} as Iterator>::Item>
             101..151 'for (e...     }': ()
             101..151 'for (e...     }': ()
             101..151 'for (e...     }': ()
@@ -719,28 +719,28 @@ fn test() {
             51..58 'loop {}': !
             56..58 '{}': ()
             72..171 '{     ... x); }': ()
-            78..81 'foo': fn foo<&'? (i32, &'? str), i32, impl FnOnce(&'? (i32, &'? str)) -> i32>(&'? (i32, &'? str), impl FnOnce(&'? (i32, &'? str)) -> i32) -> i32
+            78..81 'foo': fn foo<&'? (i32, &'static str), i32, impl FnOnce(&'? (i32, &'static str)) -> i32>(&'? (i32, &'static str), impl FnOnce(&'? (i32, &'static str)) -> i32) -> i32
             78..105 'foo(&(...y)| x)': i32
             82..91 '&(1, "a")': &'? (i32, &'static str)
             83..91 '(1, "a")': (i32, &'static str)
             84..85 '1': i32
             87..90 '"a"': &'static str
-            93..104 '|&(x, y)| x': impl FnOnce(&'? (i32, &'? str)) -> i32
-            94..101 '&(x, y)': &'? (i32, &'? str)
-            95..101 '(x, y)': (i32, &'? str)
+            93..104 '|&(x, y)| x': impl FnOnce(&'? (i32, &'static str)) -> i32
+            94..101 '&(x, y)': &'? (i32, &'static str)
+            95..101 '(x, y)': (i32, &'static str)
             96..97 'x': i32
-            99..100 'y': &'? str
+            99..100 'y': &'static str
             103..104 'x': i32
-            142..145 'foo': fn foo<&'? (i32, &'? str), &'? i32, impl FnOnce(&'? (i32, &'? str)) -> &'? i32>(&'? (i32, &'? str), impl FnOnce(&'? (i32, &'? str)) -> &'? i32) -> &'? i32
+            142..145 'foo': fn foo<&'? (i32, &'static str), &'? i32, impl FnOnce(&'? (i32, &'static str)) -> &'? i32>(&'? (i32, &'static str), impl FnOnce(&'? (i32, &'static str)) -> &'? i32) -> &'? i32
             142..168 'foo(&(...y)| x)': &'? i32
             146..155 '&(1, "a")': &'? (i32, &'static str)
             147..155 '(1, "a")': (i32, &'static str)
             148..149 '1': i32
             151..154 '"a"': &'static str
-            157..167 '|(x, y)| x': impl FnOnce(&'? (i32, &'? str)) -> &'? i32
-            158..164 '(x, y)': (i32, &'? str)
+            157..167 '|(x, y)| x': impl FnOnce(&'? (i32, &'static str)) -> &'? i32
+            158..164 '(x, y)': (i32, &'static str)
             159..160 'x': &'? i32
-            162..163 'y': &'? &'? str
+            162..163 'y': &'? &'static str
             166..167 'x': &'? i32
         "#]],
     );
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
index 6a3f2286215f4..eacc4603ea1af 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
@@ -268,12 +268,12 @@ fn infer_std_crash_5() {
         expect![[r#"
             26..322 '{     ...   } }': ()
             32..320 'for co...     }': fn into_iter<{unknown}>({unknown}) -> <{unknown} as IntoIterator>::IntoIter
-            32..320 'for co...     }': {unknown}
+            32..320 'for co...     }': <{unknown} as IntoIterator>::IntoIter
             32..320 'for co...     }': !
-            32..320 'for co...     }': {unknown}
-            32..320 'for co...     }': &'? mut {unknown}
+            32..320 'for co...     }': <{unknown} as IntoIterator>::IntoIter
+            32..320 'for co...     }': &'? mut <{unknown} as IntoIterator>::IntoIter
             32..320 'for co...     }': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
-            32..320 'for co...     }': Option<{unknown}>
+            32..320 'for co...     }': Option<<{unknown} as Iterator>::Item>
             32..320 'for co...     }': ()
             32..320 'for co...     }': ()
             32..320 'for co...     }': ()
@@ -628,7 +628,7 @@ fn issue_4053_diesel_where_clauses() {
             65..69 'self': Self
             267..271 'self': Self
             466..470 'self': SelectStatement<F, S, D, W, O, LOf, {unknown}, {unknown}>
-            488..522 '{     ...     }': ()
+            488..522 '{     ...     }': <SelectStatement<F, S, D, W, O, LOf, {unknown}, {unknown}> as BoxedDsl<DB>>::Output
             498..502 'self': SelectStatement<F, S, D, W, O, LOf, {unknown}, {unknown}>
             498..508 'self.order': O
             498..515 'self.o...into()': dyn QueryFragment<DB> + '?
@@ -1248,7 +1248,7 @@ fn test() {
             16..66 'for _ ...     }': {unknown}
             16..66 'for _ ...     }': &'? mut {unknown}
             16..66 'for _ ...     }': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
-            16..66 'for _ ...     }': Option<{unknown}>
+            16..66 'for _ ...     }': Option<<{unknown} as Iterator>::Item>
             16..66 'for _ ...     }': ()
             16..66 'for _ ...     }': ()
             16..66 'for _ ...     }': ()
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
index e4ee52f45eb75..97473bbabba04 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
@@ -20,7 +20,7 @@ impl<'a> IntoIterator for &'a Grid {
     "#,
         expect![[r#"
             150..154 'self': &'a Grid
-            174..181 '{     }': impl Iterator<Item = &'a ()>
+            174..181 '{     }': impl Iterator<Item = &'? ()>
         "#]],
     );
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/simple.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/simple.rs
index a995a45f6e752..e7357ed5aa78b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/simple.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/simple.rs
@@ -1954,6 +1954,8 @@ fn closure_return_inferred() {
     );
 }
 
+// FIXME(next-solver): `&'? str` in 231..262 seems suspicious.
+// Should revisit this once we fully migrated into next-solver without chalk-ir.
 #[test]
 fn coroutine_types_inferred() {
     check_infer(
@@ -1998,7 +2000,7 @@ fn test() {
             225..360 'match ...     }': ()
             231..239 'Pin::new': fn new<&'? mut |usize| yields i64 -> &'static str>(&'? mut |usize| yields i64 -> &'static str) -> Pin<&'? mut |usize| yields i64 -> &'static str>
             231..247 'Pin::n...mut g)': Pin<&'? mut |usize| yields i64 -> &'static str>
-            231..262 'Pin::n...usize)': CoroutineState<i64, &'static str>
+            231..262 'Pin::n...usize)': CoroutineState<i64, &'? str>
             240..246 '&mut g': &'? mut |usize| yields i64 -> &'static str
             245..246 'g': |usize| yields i64 -> &'static str
             255..261 '0usize': usize
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
index a311e579744df..7a946f7ec7ced 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
@@ -1,6 +1,8 @@
 use cov_mark::check;
 use expect_test::expect;
 
+use crate::tests::infer_with_mismatches;
+
 use super::{check, check_infer, check_infer_with_mismatches, check_no_mismatches, check_types};
 
 #[test]
@@ -2460,7 +2462,7 @@ use core::ops::Index;
 
 type Key<S: UnificationStoreBase> = <S as UnificationStoreBase>::Key;
 
-pub trait UnificationStoreBase: Index<Output = Key<Self>> {
+pub trait UnificationStoreBase: Index<usize, Output = Key<Self>> {
     type Key;
 
     fn len(&self) -> usize;
@@ -3634,8 +3636,7 @@ fn minimized() {
 
 #[test]
 fn no_builtin_binop_expectation_for_general_ty_var() {
-    // FIXME: Ideally type mismatch should be reported on `take_u32(42 - p)`.
-    check_types(
+    infer_with_mismatches(
         r#"
 //- minicore: add
 use core::ops::Add;
@@ -3659,6 +3660,7 @@ fn minimized() {
     take_u32(42 + p);
 }
 "#,
+        true,
     );
 }
 
@@ -4188,6 +4190,8 @@ fn g<P: PointerFamily>(p: <P as PointerFamily>::Pointer<i32>) {
     );
 }
 
+// FIXME(next-solver): Was `&'a T` but now getting error lifetime.
+// This might be fixed once we migrate into next-solver fully without chalk-ir in lowering.
 #[test]
 fn gats_with_impl_trait() {
     // FIXME: the last function (`fn i()`) is not valid Rust as of this writing because you cannot
@@ -4211,21 +4215,21 @@ fn f<T>(v: impl Trait) {
 }
 fn g<'a, T: 'a>(v: impl Trait<Assoc<T> = &'a T>) {
     let a = v.get::<T>();
-      //^ &'a T
+      //^ &'? T
     let a = v.get::<()>();
       //^ <impl Trait<Assoc<T> = &'a T> as Trait>::Assoc<()>
 }
 fn h<'a>(v: impl Trait<Assoc<i32> = &'a i32> + Trait<Assoc<i64> = &'a i64>) {
     let a = v.get::<i32>();
-      //^ &'a i32
+      //^ &'? i32
     let a = v.get::<i64>();
-      //^ &'a i64
+      //^ &'? i64
 }
 fn i<'a>(v: impl Trait<Assoc<i32> = &'a i32, Assoc<i64> = &'a i64>) {
     let a = v.get::<i32>();
-      //^ &'a i32
+      //^ &'? i32
     let a = v.get::<i64>();
-      //^ &'a i64
+      //^ &'? i64
 }
     "#,
     );
@@ -4255,8 +4259,8 @@ fn f<'a>(v: &dyn Trait<Assoc<i32> = &'a i32>) {
             127..128 'v': &'? (dyn Trait<Assoc<i32> = &'a i32> + '?)
             164..195 '{     ...f(); }': ()
             170..171 'v': &'? (dyn Trait<Assoc<i32> = &'a i32> + '?)
-            170..184 'v.get::<i32>()': {unknown}
-            170..192 'v.get:...eref()': &'? {unknown}
+            170..184 'v.get::<i32>()': <dyn Trait<Assoc<i32> = &'a i32> + '? as Trait>::Assoc<i32>
+            170..192 'v.get:...eref()': {unknown}
         "#]],
     );
 }
@@ -4931,6 +4935,8 @@ fn main() {
     );
 }
 
+// FIXME(next-solver): Was `<D as Deserializer<'de>>::Error` but now getting error lifetime.
+// This might be fixed once we migrate into next-solver fully without chalk-ir in lowering.
 #[test]
 fn new_solver_crash_1() {
     check_infer(
@@ -4947,7 +4953,7 @@ where
 "#,
         expect![[r#"
             84..86 'de': D
-            135..138 '{ }': <D as Deserializer<'de>>::Error
+            135..138 '{ }': <D as Deserializer<'?>>::Error
         "#]],
     );
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs b/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
index 0c58e031c3a0f..a6377243ed984 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
@@ -21,9 +21,17 @@ use stdx::never;
 use triomphe::Arc;
 
 use crate::{
-    db::HirDatabase, infer::unify::InferenceTable, next_solver::{
-        infer::{DbInternerInferExt, InferCtxt}, mapping::{convert_canonical_args_for_result, ChalkToNextSolver}, util::mini_canonicalize, DbInterner, GenericArg, Predicate, SolverContext, Span
-    }, utils::UnevaluatedConstEvaluatorFolder, AliasEq, AliasTy, Canonical, DomainGoal, Goal, InEnvironment, Interner, ProjectionTy, ProjectionTyExt, TraitRefExt, Ty, TyKind, TypeFlags, WhereClause
+    AliasEq, AliasTy, Canonical, DomainGoal, Goal, InEnvironment, Interner, ProjectionTy,
+    ProjectionTyExt, TraitRefExt, Ty, TyKind, TypeFlags, WhereClause,
+    db::HirDatabase,
+    infer::unify::InferenceTable,
+    next_solver::{
+        DbInterner, GenericArg, Predicate, SolverContext, Span,
+        infer::{DbInternerInferExt, InferCtxt},
+        mapping::{ChalkToNextSolver, convert_canonical_args_for_result},
+        util::mini_canonicalize,
+    },
+    utils::UnevaluatedConstEvaluatorFolder,
 };
 
 /// A set of clauses that we assume to be true. E.g. if we are inside this function:
@@ -282,30 +290,18 @@ pub fn next_trait_solve(
     }
 }
 
-pub fn next_trait_solve_canonical<'db>(
-    db: &'db dyn HirDatabase,
-    krate: Crate,
-    block: Option<BlockId>,
+pub fn next_trait_solve_canonical_in_ctxt<'db>(
+    infer_ctxt: &InferCtxt<'db>,
     goal: crate::next_solver::Canonical<'db, crate::next_solver::Goal<'db, Predicate<'db>>>,
 ) -> NextTraitSolveResult {
-    // FIXME: should use analysis_in_body, but that needs GenericDefId::Block
-    let context = SolverContext(
-        DbInterner::new_with(db, Some(krate), block)
-            .infer_ctxt()
-            .build(TypingMode::non_body_analysis()),
-    );
+    let context = SolverContext(infer_ctxt.clone());
 
     tracing::info!(?goal);
 
-    let (goal, var_values) =
-        context.instantiate_canonical(&goal);
+    let (goal, var_values) = context.instantiate_canonical(&goal);
     tracing::info!(?var_values);
 
-    let res = context.evaluate_root_goal(
-        goal.clone(),
-        Span::dummy(),
-        None
-    );
+    let res = context.evaluate_root_goal(goal, Span::dummy(), None);
 
     let vars =
         var_values.var_values.iter().map(|g| context.0.resolve_vars_if_possible(g)).collect();
@@ -318,13 +314,10 @@ pub fn next_trait_solve_canonical<'db>(
     match res {
         Err(_) => NextTraitSolveResult::NoSolution,
         Ok((_, Certainty::Yes, args)) => NextTraitSolveResult::Certain(
-            convert_canonical_args_for_result(DbInterner::new_with(db, Some(krate), block), args)
+            convert_canonical_args_for_result(infer_ctxt.interner, args),
         ),
         Ok((_, Certainty::Maybe(_), args)) => {
-            let subst = convert_canonical_args_for_result(
-                DbInterner::new_with(db, Some(krate), block),
-                args,
-            );
+            let subst = convert_canonical_args_for_result(infer_ctxt.interner, args);
             NextTraitSolveResult::Uncertain(chalk_ir::Canonical {
                 binders: subst.binders,
                 value: subst.value.subst,
diff --git a/src/tools/rust-analyzer/crates/hir/src/attrs.rs b/src/tools/rust-analyzer/crates/hir/src/attrs.rs
index 79a154a5d8e6e..c230bbad0bc45 100644
--- a/src/tools/rust-analyzer/crates/hir/src/attrs.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/attrs.rs
@@ -14,7 +14,11 @@ use hir_expand::{
     mod_path::{ModPath, PathKind},
     name::Name,
 };
-use hir_ty::{db::HirDatabase, method_resolution, next_solver::{mapping::ChalkToNextSolver, DbInterner}};
+use hir_ty::{
+    db::HirDatabase,
+    method_resolution,
+    next_solver::{DbInterner, mapping::ChalkToNextSolver},
+};
 
 use crate::{
     Adt, AsAssocItem, AssocItem, BuiltinType, Const, ConstParam, DocLinkDef, Enum, ExternCrateDecl,
@@ -271,7 +275,11 @@ fn resolve_impl_trait_item<'db>(
     //
     // FIXME: resolve type aliases (which are not yielded by iterate_path_candidates)
     _ = method_resolution::iterate_path_candidates(
-        &canonical.to_nextsolver(DbInterner::new_with(db, Some(environment.krate), environment.block)),
+        &canonical.to_nextsolver(DbInterner::new_with(
+            db,
+            Some(environment.krate),
+            environment.block,
+        )),
         db,
         environment,
         &traits_in_scope,
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context/tests.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context/tests.rs
index 6121c61ea3f49..445afa75f3f4f 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context/tests.rs
@@ -10,7 +10,8 @@ use crate::{
 fn check_expected_type_and_name(#[rust_analyzer::rust_fixture] ra_fixture: &str, expect: Expect) {
     let (db, pos) = position(ra_fixture);
     let config = TEST_CONFIG;
-    let (completion_context, _analysis) = CompletionContext::new(&db, pos, &config).unwrap();
+    let (completion_context, _analysis) =
+        salsa::attach(&db, || CompletionContext::new(&db, pos, &config).unwrap());
 
     let ty = completion_context
         .expected_type
diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/type_mismatch.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/type_mismatch.rs
index ac54ac0950f39..8613581292f75 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/type_mismatch.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/type_mismatch.rs
@@ -526,8 +526,7 @@ fn main() {
             fn run(_t: Rate<5>) {
             }
             fn main() {
-                run(f()) // FIXME: remove this error
-                  //^^^ error: expected Rate<5>, found Rate<_>
+                run(f())
             }
 "#,
         );
diff --git a/src/tools/rust-analyzer/crates/ide-ssr/src/tests.rs b/src/tools/rust-analyzer/crates/ide-ssr/src/tests.rs
index 46b633b8a3250..875b4d9b06cec 100644
--- a/src/tools/rust-analyzer/crates/ide-ssr/src/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide-ssr/src/tests.rs
@@ -2,7 +2,10 @@ use expect_test::{Expect, expect};
 use hir::{FilePosition, FileRange};
 use ide_db::{
     EditionedFileId, FxHashSet,
-    base_db::{SourceDatabase, salsa::Durability},
+    base_db::{
+        SourceDatabase,
+        salsa::{self, Durability},
+    },
 };
 use test_utils::RangeOrOffset;
 use triomphe::Arc;
@@ -116,7 +119,7 @@ fn assert_ssr_transforms(rules: &[&str], input: &str, expected: Expect) {
         let rule: SsrRule = rule.parse().unwrap();
         match_finder.add_rule(rule).unwrap();
     }
-    let edits = match_finder.edits();
+    let edits = salsa::attach(&db, || match_finder.edits());
     if edits.is_empty() {
         panic!("No edits were made");
     }
@@ -155,8 +158,12 @@ fn assert_matches(pattern: &str, code: &str, expected: &[&str]) {
     )
     .unwrap();
     match_finder.add_search_pattern(pattern.parse().unwrap()).unwrap();
-    let matched_strings: Vec<String> =
-        match_finder.matches().flattened().matches.iter().map(|m| m.matched_text()).collect();
+    let matched_strings: Vec<String> = salsa::attach(&db, || match_finder.matches())
+        .flattened()
+        .matches
+        .iter()
+        .map(|m| m.matched_text())
+        .collect();
     if matched_strings != expected && !expected.is_empty() {
         print_match_debug_info(&match_finder, position.file_id, expected[0]);
     }
diff --git a/src/tools/rust-analyzer/crates/ide/src/doc_links/tests.rs b/src/tools/rust-analyzer/crates/ide/src/doc_links/tests.rs
index 11518d1fbf306..72436307d2cee 100644
--- a/src/tools/rust-analyzer/crates/ide/src/doc_links/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/doc_links/tests.rs
@@ -47,7 +47,8 @@ fn check_rewrite(#[rust_analyzer::rust_fixture] ra_fixture: &str, expect: Expect
     let (analysis, position) = fixture::position(ra_fixture);
     let sema = &Semantics::new(&analysis.db);
     let (cursor_def, docs, range) = def_under_cursor(sema, &position);
-    let res = rewrite_links(sema.db, docs.as_str(), cursor_def, Some(range));
+    let res =
+        salsa::attach(sema.db, || rewrite_links(sema.db, docs.as_str(), cursor_def, Some(range)));
     expect.assert_eq(&res)
 }
 

From 6e36750c617c656432aafaffe170691b91ecc985 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Tue, 9 Sep 2025 10:30:03 -0700
Subject: [PATCH 0727/1889] Update wasm-component-ld to 0.5.17

Keeping this up-to-date as the project itself, and its dependencies, are
updated.
---
 Cargo.lock                             | 50 +++++++++++++-------------
 src/tools/wasm-component-ld/Cargo.toml |  2 +-
 2 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index c29c3158d4a1b..cff5864dbbe09 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5984,9 +5984,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-component-ld"
-version = "0.5.16"
+version = "0.5.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14cd35d6cae91109a0ffd207b573cf3c741cab7e921dd376ea7aaf2c52a3408c"
+checksum = "1c9208f87cac2332fd80dcf36d54e9163d3446e28301e0c6e424984425738984"
 dependencies = [
  "anyhow",
  "clap",
@@ -5994,9 +5994,9 @@ dependencies = [
  "libc",
  "tempfile",
  "wasi-preview1-component-adapter-provider",
- "wasmparser 0.237.0",
+ "wasmparser 0.239.0",
  "wat",
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
  "winsplit",
  "wit-component",
  "wit-parser",
@@ -6021,24 +6021,24 @@ dependencies = [
 
 [[package]]
 name = "wasm-encoder"
-version = "0.237.0"
+version = "0.239.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "efe92d1321afa53ffc88a57c497bb7330c3cf84c98ffdba4a4caf6a0684fad3c"
+checksum = "5be00faa2b4950c76fe618c409d2c3ea5a3c9422013e079482d78544bb2d184c"
 dependencies = [
  "leb128fmt",
- "wasmparser 0.237.0",
+ "wasmparser 0.239.0",
 ]
 
 [[package]]
 name = "wasm-metadata"
-version = "0.237.0"
+version = "0.239.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4cc0b0a0c4f35ca6efa7a797671372915d4e9659dba2d59edc6fafc931d19997"
+checksum = "20b3ec880a9ac69ccd92fbdbcf46ee833071cf09f82bb005b2327c7ae6025ae2"
 dependencies = [
  "anyhow",
  "indexmap",
- "wasm-encoder 0.237.0",
- "wasmparser 0.237.0",
+ "wasm-encoder 0.239.0",
+ "wasmparser 0.239.0",
 ]
 
 [[package]]
@@ -6063,9 +6063,9 @@ dependencies = [
 
 [[package]]
 name = "wasmparser"
-version = "0.237.0"
+version = "0.239.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d2a40ca0d2bdf4b0bf36c13a737d0b2c58e4c8aaefe1c57f336dd75369ca250"
+checksum = "8c9d90bb93e764f6beabf1d02028c70a2156a6583e63ac4218dd07ef733368b0"
 dependencies = [
  "bitflags",
  "hashbrown",
@@ -6076,22 +6076,22 @@ dependencies = [
 
 [[package]]
 name = "wast"
-version = "237.0.0"
+version = "239.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fcf66f545acbd55082485cb9a6daab54579cb8628a027162253e8e9f5963c767"
+checksum = "9139176fe8a2590e0fb174cdcaf373b224cb93c3dde08e4297c1361d2ba1ea5d"
 dependencies = [
  "bumpalo",
  "leb128fmt",
  "memchr",
  "unicode-width 0.2.1",
- "wasm-encoder 0.237.0",
+ "wasm-encoder 0.239.0",
 ]
 
 [[package]]
 name = "wat"
-version = "1.237.0"
+version = "1.239.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "27975186f549e4b8d6878b627be732863883c72f7bf4dcf8f96e5f8242f73da9"
+checksum = "3e1c941927d34709f255558166f8901a2005f8ab4a9650432e9281b7cc6f3b75"
 dependencies = [
  "wast",
 ]
@@ -6580,9 +6580,9 @@ dependencies = [
 
 [[package]]
 name = "wit-component"
-version = "0.237.0"
+version = "0.239.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfb7674f76c10e82fe00b256a9d4ffb2b8d037d42ab8e9a83ebb3be35c9d0bf6"
+checksum = "88a866b19dba2c94d706ec58c92a4c62ab63e482b4c935d2a085ac94caecb136"
 dependencies = [
  "anyhow",
  "bitflags",
@@ -6591,17 +6591,17 @@ dependencies = [
  "serde",
  "serde_derive",
  "serde_json",
- "wasm-encoder 0.237.0",
+ "wasm-encoder 0.239.0",
  "wasm-metadata",
- "wasmparser 0.237.0",
+ "wasmparser 0.239.0",
  "wit-parser",
 ]
 
 [[package]]
 name = "wit-parser"
-version = "0.237.0"
+version = "0.239.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce2596a5bc7c24cc965b56ad6ff9e32394c4e401764f89620a888519c6e849ab"
+checksum = "55c92c939d667b7bf0c6bf2d1f67196529758f99a2a45a3355cc56964fd5315d"
 dependencies = [
  "anyhow",
  "id-arena",
@@ -6612,7 +6612,7 @@ dependencies = [
  "serde_derive",
  "serde_json",
  "unicode-xid",
- "wasmparser 0.237.0",
+ "wasmparser 0.239.0",
 ]
 
 [[package]]
diff --git a/src/tools/wasm-component-ld/Cargo.toml b/src/tools/wasm-component-ld/Cargo.toml
index 23dc86998e88f..3def2391a13f6 100644
--- a/src/tools/wasm-component-ld/Cargo.toml
+++ b/src/tools/wasm-component-ld/Cargo.toml
@@ -10,4 +10,4 @@ name = "wasm-component-ld"
 path = "src/main.rs"
 
 [dependencies]
-wasm-component-ld = "0.5.16"
+wasm-component-ld = "0.5.17"

From 23edc4dd4266836980dc3e71a1f5ddd151a3e92a Mon Sep 17 00:00:00 2001
From: Mads Marquart <mads@marquart.dk>
Date: Tue, 9 Sep 2025 19:43:50 +0200
Subject: [PATCH 0728/1889] Fix compare_against_sw_vers test when a version
 part is 0

---
 library/std/src/sys/platform_version/darwin/tests.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/library/std/src/sys/platform_version/darwin/tests.rs b/library/std/src/sys/platform_version/darwin/tests.rs
index eecd58ec79e35..17b2cc18ec096 100644
--- a/library/std/src/sys/platform_version/darwin/tests.rs
+++ b/library/std/src/sys/platform_version/darwin/tests.rs
@@ -35,9 +35,9 @@ fn compare_against_sw_vers() {
     assert_eq!(__isOSVersionAtLeast(major, minor, subminor), 1);
 
     // One lower is available
-    assert_eq!(__isOSVersionAtLeast(major, minor, subminor.saturating_sub(1)), 1);
-    assert_eq!(__isOSVersionAtLeast(major, minor.saturating_sub(1), subminor), 1);
-    assert_eq!(__isOSVersionAtLeast(major.saturating_sub(1), minor, subminor), 1);
+    assert_eq!(__isOSVersionAtLeast(major, minor, (subminor as u32).saturating_sub(1) as i32), 1);
+    assert_eq!(__isOSVersionAtLeast(major, (minor as u32).saturating_sub(1) as i32, subminor), 1);
+    assert_eq!(__isOSVersionAtLeast((major as u32).saturating_sub(1) as i32, minor, subminor), 1);
 
     // One higher isn't available
     assert_eq!(__isOSVersionAtLeast(major, minor, subminor + 1), 0);

From 7a66925a8138df105f77d646f9206024baf7ea4b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Mon, 8 Sep 2025 19:25:22 +0200
Subject: [PATCH 0729/1889] Strip frontmatter in fewer places

---
 .../rustc_builtin_macros/src/source_util.rs   | 69 ++++++++++++-------
 compiler/rustc_driver_impl/src/lib.rs         | 12 +++-
 compiler/rustc_expand/src/module.rs           |  9 ++-
 .../rustc_expand/src/proc_macro_server.rs     | 11 ++-
 compiler/rustc_interface/src/interface.rs     | 22 +++---
 compiler/rustc_interface/src/passes.rs        | 17 +++--
 compiler/rustc_parse/src/lexer/mod.rs         |  2 +-
 compiler/rustc_parse/src/lib.rs               | 36 +++++-----
 compiler/rustc_parse/src/parser/tests.rs      |  7 +-
 src/librustdoc/clean/render_macro_matchers.rs | 21 +++---
 src/librustdoc/doctest/make.rs                | 19 ++---
 .../src/doc/needless_doctest_main.rs          | 16 +++--
 src/tools/rustfmt/src/parse/parser.rs         | 14 +++-
 tests/ui-fulldeps/auxiliary/parser.rs         |  3 +-
 .../ui-fulldeps/mod_dir_path_canonicalized.rs |  9 ++-
 tests/ui/frontmatter/auxiliary/expr.rs        |  4 ++
 tests/ui/frontmatter/auxiliary/makro.rs       | 14 +++-
 tests/ui/frontmatter/include-in-expr-ctxt.rs  |  9 +++
 tests/ui/frontmatter/include-in-item-ctxt.rs  | 10 +++
 tests/ui/frontmatter/included-frontmatter.rs  | 12 ----
 tests/ui/frontmatter/proc-macro-observer.rs   |  7 +-
 21 files changed, 208 insertions(+), 115 deletions(-)
 create mode 100644 tests/ui/frontmatter/auxiliary/expr.rs
 create mode 100644 tests/ui/frontmatter/include-in-expr-ctxt.rs
 create mode 100644 tests/ui/frontmatter/include-in-item-ctxt.rs
 delete mode 100644 tests/ui/frontmatter/included-frontmatter.rs

diff --git a/compiler/rustc_builtin_macros/src/source_util.rs b/compiler/rustc_builtin_macros/src/source_util.rs
index f95c8f38229b2..11b868f81a976 100644
--- a/compiler/rustc_builtin_macros/src/source_util.rs
+++ b/compiler/rustc_builtin_macros/src/source_util.rs
@@ -13,9 +13,11 @@ use rustc_expand::base::{
 };
 use rustc_expand::module::DirOwnership;
 use rustc_lint_defs::BuiltinLintDiag;
-use rustc_parse::parser::{ForceCollect, Parser};
+use rustc_parse::lexer::StripTokens;
+use rustc_parse::parser::ForceCollect;
 use rustc_parse::{new_parser_from_file, unwrap_or_emit_fatal, utf8_error};
 use rustc_session::lint::builtin::INCOMPLETE_INCLUDE;
+use rustc_session::parse::ParseSess;
 use rustc_span::source_map::SourceMap;
 use rustc_span::{ByteSymbol, Pos, Span, Symbol};
 use smallvec::SmallVec;
@@ -114,39 +116,48 @@ pub(crate) fn expand_include<'cx>(
     let ExpandResult::Ready(mac) = get_single_str_from_tts(cx, sp, tts, "include!") else {
         return ExpandResult::Retry(());
     };
-    let file = match mac {
-        Ok(file) => file,
+    let path = match mac {
+        Ok(path) => path,
         Err(guar) => return ExpandResult::Ready(DummyResult::any(sp, guar)),
     };
     // The file will be added to the code map by the parser
-    let file = match resolve_path(&cx.sess, file.as_str(), sp) {
-        Ok(f) => f,
+    let path = match resolve_path(&cx.sess, path.as_str(), sp) {
+        Ok(path) => path,
         Err(err) => {
             let guar = err.emit();
             return ExpandResult::Ready(DummyResult::any(sp, guar));
         }
     };
-    let p = unwrap_or_emit_fatal(new_parser_from_file(cx.psess(), &file, Some(sp)));
 
     // If in the included file we have e.g., `mod bar;`,
-    // then the path of `bar.rs` should be relative to the directory of `file`.
+    // then the path of `bar.rs` should be relative to the directory of `path`.
     // See https://github.com/rust-lang/rust/pull/69838/files#r395217057 for a discussion.
     // `MacroExpander::fully_expand_fragment` later restores, so "stack discipline" is maintained.
-    let dir_path = file.parent().unwrap_or(&file).to_owned();
+    let dir_path = path.parent().unwrap_or(&path).to_owned();
     cx.current_expansion.module = Rc::new(cx.current_expansion.module.with_dir_path(dir_path));
     cx.current_expansion.dir_ownership = DirOwnership::Owned { relative: None };
 
     struct ExpandInclude<'a> {
-        p: Parser<'a>,
+        psess: &'a ParseSess,
+        path: PathBuf,
         node_id: ast::NodeId,
+        span: Span,
     }
     impl<'a> MacResult for ExpandInclude<'a> {
-        fn make_expr(mut self: Box<ExpandInclude<'a>>) -> Option<Box<ast::Expr>> {
-            let expr = parse_expr(&mut self.p).ok()?;
-            if self.p.token != token::Eof {
-                self.p.psess.buffer_lint(
+        fn make_expr(self: Box<ExpandInclude<'a>>) -> Option<Box<ast::Expr>> {
+            let mut p = unwrap_or_emit_fatal(new_parser_from_file(
+                self.psess,
+                &self.path,
+                // Don't strip frontmatter for backward compatibility, `---` may be the start of a
+                // manifold negation. FIXME: Ideally, we wouldn't strip shebangs here either.
+                StripTokens::Shebang,
+                Some(self.span),
+            ));
+            let expr = parse_expr(&mut p).ok()?;
+            if p.token != token::Eof {
+                p.psess.buffer_lint(
                     INCOMPLETE_INCLUDE,
-                    self.p.token.span,
+                    p.token.span,
                     self.node_id,
                     BuiltinLintDiag::IncompleteInclude,
                 );
@@ -154,24 +165,27 @@ pub(crate) fn expand_include<'cx>(
             Some(expr)
         }
 
-        fn make_items(mut self: Box<ExpandInclude<'a>>) -> Option<SmallVec<[Box<ast::Item>; 1]>> {
+        fn make_items(self: Box<ExpandInclude<'a>>) -> Option<SmallVec<[Box<ast::Item>; 1]>> {
+            let mut p = unwrap_or_emit_fatal(new_parser_from_file(
+                self.psess,
+                &self.path,
+                StripTokens::ShebangAndFrontmatter,
+                Some(self.span),
+            ));
             let mut ret = SmallVec::new();
             loop {
-                match self.p.parse_item(ForceCollect::No) {
+                match p.parse_item(ForceCollect::No) {
                     Err(err) => {
                         err.emit();
                         break;
                     }
                     Ok(Some(item)) => ret.push(item),
                     Ok(None) => {
-                        if self.p.token != token::Eof {
-                            self.p
-                                .dcx()
-                                .create_err(errors::ExpectedItem {
-                                    span: self.p.token.span,
-                                    token: &pprust::token_to_string(&self.p.token),
-                                })
-                                .emit();
+                        if p.token != token::Eof {
+                            p.dcx().emit_err(errors::ExpectedItem {
+                                span: p.token.span,
+                                token: &pprust::token_to_string(&p.token),
+                            });
                         }
 
                         break;
@@ -182,7 +196,12 @@ pub(crate) fn expand_include<'cx>(
         }
     }
 
-    ExpandResult::Ready(Box::new(ExpandInclude { p, node_id: cx.current_expansion.lint_node_id }))
+    ExpandResult::Ready(Box::new(ExpandInclude {
+        psess: cx.psess(),
+        path,
+        node_id: cx.current_expansion.lint_node_id,
+        span: sp,
+    }))
 }
 
 /// Expand `include_str!($input)` to the content of the UTF-8-encoded file given by path `$input` as a string literal.
diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
index f3ed604210565..d00a4c3583403 100644
--- a/compiler/rustc_driver_impl/src/lib.rs
+++ b/compiler/rustc_driver_impl/src/lib.rs
@@ -51,6 +51,7 @@ use rustc_lint::unerased_lint_store;
 use rustc_metadata::creader::MetadataLoader;
 use rustc_metadata::locator;
 use rustc_middle::ty::TyCtxt;
+use rustc_parse::lexer::StripTokens;
 use rustc_parse::{new_parser_from_file, new_parser_from_source_str, unwrap_or_emit_fatal};
 use rustc_session::config::{
     CG_OPTIONS, CrateType, ErrorOutputType, Input, OptionDesc, OutFileName, OutputType, Sysroot,
@@ -1288,10 +1289,15 @@ fn warn_on_confusing_output_filename_flag(
 
 fn parse_crate_attrs<'a>(sess: &'a Session) -> PResult<'a, ast::AttrVec> {
     let mut parser = unwrap_or_emit_fatal(match &sess.io.input {
-        Input::File(file) => new_parser_from_file(&sess.psess, file, None),
-        Input::Str { name, input } => {
-            new_parser_from_source_str(&sess.psess, name.clone(), input.clone())
+        Input::File(file) => {
+            new_parser_from_file(&sess.psess, file, StripTokens::ShebangAndFrontmatter, None)
         }
+        Input::Str { name, input } => new_parser_from_source_str(
+            &sess.psess,
+            name.clone(),
+            input.clone(),
+            StripTokens::ShebangAndFrontmatter,
+        ),
     });
     parser.parse_inner_attributes()
 }
diff --git a/compiler/rustc_expand/src/module.rs b/compiler/rustc_expand/src/module.rs
index 19f3cdbc54911..79ab3cab22ce2 100644
--- a/compiler/rustc_expand/src/module.rs
+++ b/compiler/rustc_expand/src/module.rs
@@ -4,6 +4,7 @@ use std::path::{self, Path, PathBuf};
 use rustc_ast::{AttrVec, Attribute, Inline, Item, ModSpans};
 use rustc_attr_parsing::validate_attr;
 use rustc_errors::{Diag, ErrorGuaranteed};
+use rustc_parse::lexer::StripTokens;
 use rustc_parse::{exp, new_parser_from_file, unwrap_or_emit_fatal};
 use rustc_session::Session;
 use rustc_session::parse::ParseSess;
@@ -67,8 +68,12 @@ pub(crate) fn parse_external_mod(
         }
 
         // Actually parse the external file as a module.
-        let mut parser =
-            unwrap_or_emit_fatal(new_parser_from_file(&sess.psess, &mp.file_path, Some(span)));
+        let mut parser = unwrap_or_emit_fatal(new_parser_from_file(
+            &sess.psess,
+            &mp.file_path,
+            StripTokens::ShebangAndFrontmatter,
+            Some(span),
+        ));
         let (inner_attrs, items, inner_span) =
             parser.parse_mod(exp!(Eof)).map_err(|err| ModError::ParserError(err))?;
         attrs.extend(inner_attrs);
diff --git a/compiler/rustc_expand/src/proc_macro_server.rs b/compiler/rustc_expand/src/proc_macro_server.rs
index 5b1d3d6d35b6b..295573f449267 100644
--- a/compiler/rustc_expand/src/proc_macro_server.rs
+++ b/compiler/rustc_expand/src/proc_macro_server.rs
@@ -8,7 +8,7 @@ use rustc_ast::util::literal::escape_byte_str_symbol;
 use rustc_ast_pretty::pprust;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::{Diag, ErrorGuaranteed, MultiSpan, PResult};
-use rustc_parse::lexer::nfc_normalize;
+use rustc_parse::lexer::{StripTokens, nfc_normalize};
 use rustc_parse::parser::Parser;
 use rustc_parse::{exp, new_parser_from_source_str, source_str_to_stream, unwrap_or_emit_fatal};
 use rustc_proc_macro::bridge::{
@@ -485,8 +485,13 @@ impl server::FreeFunctions for Rustc<'_, '_> {
 
     fn literal_from_str(&mut self, s: &str) -> Result<Literal<Self::Span, Self::Symbol>, ()> {
         let name = FileName::proc_macro_source_code(s);
-        let mut parser =
-            unwrap_or_emit_fatal(new_parser_from_source_str(self.psess(), name, s.to_owned()));
+
+        let mut parser = unwrap_or_emit_fatal(new_parser_from_source_str(
+            self.psess(),
+            name,
+            s.to_owned(),
+            StripTokens::Nothing,
+        ));
 
         let first_span = parser.token.span.data();
         let minus_present = parser.eat(exp!(Minus));
diff --git a/compiler/rustc_interface/src/interface.rs b/compiler/rustc_interface/src/interface.rs
index 4c820b8877b75..b52c5b4cd663b 100644
--- a/compiler/rustc_interface/src/interface.rs
+++ b/compiler/rustc_interface/src/interface.rs
@@ -13,7 +13,8 @@ use rustc_lint::LintStore;
 use rustc_middle::ty;
 use rustc_middle::ty::CurrentGcx;
 use rustc_middle::util::Providers;
-use rustc_parse::new_parser_from_simple_source_str;
+use rustc_parse::lexer::StripTokens;
+use rustc_parse::new_parser_from_source_str;
 use rustc_parse::parser::attr::AllowLeadingUnsafe;
 use rustc_query_impl::QueryCtxt;
 use rustc_query_system::query::print_query_stack;
@@ -68,7 +69,8 @@ pub(crate) fn parse_cfg(dcx: DiagCtxtHandle<'_>, cfgs: Vec<String>) -> Cfg {
                 };
             }
 
-            match new_parser_from_simple_source_str(&psess, filename, s.to_string()) {
+            match new_parser_from_source_str(&psess, filename, s.to_string(), StripTokens::Nothing)
+            {
                 Ok(mut parser) => match parser.parse_meta_item(AllowLeadingUnsafe::No) {
                     Ok(meta_item) if parser.token == token::Eof => {
                         if meta_item.path.segments.len() != 1 {
@@ -166,13 +168,15 @@ pub(crate) fn parse_check_cfg(dcx: DiagCtxtHandle<'_>, specs: Vec<String>) -> Ch
             error!("expected `cfg(name, values(\"value1\", \"value2\", ... \"valueN\"))`")
         };
 
-        let mut parser = match new_parser_from_simple_source_str(&psess, filename, s.to_string()) {
-            Ok(parser) => parser,
-            Err(errs) => {
-                errs.into_iter().for_each(|err| err.cancel());
-                expected_error();
-            }
-        };
+        let mut parser =
+            match new_parser_from_source_str(&psess, filename, s.to_string(), StripTokens::Nothing)
+            {
+                Ok(parser) => parser,
+                Err(errs) => {
+                    errs.into_iter().for_each(|err| err.cancel());
+                    expected_error();
+                }
+            };
 
         let meta_item = match parser.parse_meta_item(AllowLeadingUnsafe::No) {
             Ok(meta_item) if parser.token == token::Eof => meta_item,
diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs
index ca8c10311fb8f..cf81a1257070a 100644
--- a/compiler/rustc_interface/src/passes.rs
+++ b/compiler/rustc_interface/src/passes.rs
@@ -27,6 +27,7 @@ use rustc_middle::arena::Arena;
 use rustc_middle::dep_graph::DepsType;
 use rustc_middle::ty::{self, CurrentGcx, GlobalCtxt, RegisteredTools, TyCtxt};
 use rustc_middle::util::Providers;
+use rustc_parse::lexer::StripTokens;
 use rustc_parse::{new_parser_from_file, new_parser_from_source_str, unwrap_or_emit_fatal};
 use rustc_passes::{abi_test, input_stats, layout_test};
 use rustc_resolve::{Resolver, ResolverOutputs};
@@ -51,10 +52,18 @@ pub fn parse<'a>(sess: &'a Session) -> ast::Crate {
     let mut krate = sess
         .time("parse_crate", || {
             let mut parser = unwrap_or_emit_fatal(match &sess.io.input {
-                Input::File(file) => new_parser_from_file(&sess.psess, file, None),
-                Input::Str { input, name } => {
-                    new_parser_from_source_str(&sess.psess, name.clone(), input.clone())
-                }
+                Input::File(file) => new_parser_from_file(
+                    &sess.psess,
+                    file,
+                    StripTokens::ShebangAndFrontmatter,
+                    None,
+                ),
+                Input::Str { input, name } => new_parser_from_source_str(
+                    &sess.psess,
+                    name.clone(),
+                    input.clone(),
+                    StripTokens::ShebangAndFrontmatter,
+                ),
             });
             parser.parse_crate_mod()
         })
diff --git a/compiler/rustc_parse/src/lexer/mod.rs b/compiler/rustc_parse/src/lexer/mod.rs
index f5f081efc4956..51019db7c00e4 100644
--- a/compiler/rustc_parse/src/lexer/mod.rs
+++ b/compiler/rustc_parse/src/lexer/mod.rs
@@ -45,7 +45,7 @@ pub(crate) struct UnmatchedDelim {
 }
 
 /// Which tokens should be stripped before lexing the tokens.
-pub(crate) enum StripTokens {
+pub enum StripTokens {
     /// Strip both shebang and frontmatter.
     ShebangAndFrontmatter,
     /// Strip the shebang but not frontmatter.
diff --git a/compiler/rustc_parse/src/lib.rs b/compiler/rustc_parse/src/lib.rs
index d8792d7af4c36..88b67d792deb9 100644
--- a/compiler/rustc_parse/src/lib.rs
+++ b/compiler/rustc_parse/src/lib.rs
@@ -54,29 +54,18 @@ pub fn unwrap_or_emit_fatal<T>(expr: Result<T, Vec<Diag<'_>>>) -> T {
     }
 }
 
-/// Creates a new parser from a source string. On failure, the errors must be consumed via
-/// `unwrap_or_emit_fatal`, `emit`, `cancel`, etc., otherwise a panic will occur when they are
-/// dropped.
-pub fn new_parser_from_source_str(
-    psess: &ParseSess,
-    name: FileName,
-    source: String,
-) -> Result<Parser<'_>, Vec<Diag<'_>>> {
-    let source_file = psess.source_map().new_source_file(name, source);
-    new_parser_from_source_file(psess, source_file, StripTokens::ShebangAndFrontmatter)
-}
-
-/// Creates a new parser from a simple (no shebang, no frontmatter) source string.
+/// Creates a new parser from a source string.
 ///
 /// On failure, the errors must be consumed via `unwrap_or_emit_fatal`, `emit`, `cancel`,
 /// etc., otherwise a panic will occur when they are dropped.
-pub fn new_parser_from_simple_source_str(
+pub fn new_parser_from_source_str(
     psess: &ParseSess,
     name: FileName,
     source: String,
+    strip_tokens: StripTokens,
 ) -> Result<Parser<'_>, Vec<Diag<'_>>> {
     let source_file = psess.source_map().new_source_file(name, source);
-    new_parser_from_source_file(psess, source_file, StripTokens::Nothing)
+    new_parser_from_source_file(psess, source_file, strip_tokens)
 }
 
 /// Creates a new parser from a filename. On failure, the errors must be consumed via
@@ -87,6 +76,7 @@ pub fn new_parser_from_simple_source_str(
 pub fn new_parser_from_file<'a>(
     psess: &'a ParseSess,
     path: &Path,
+    strip_tokens: StripTokens,
     sp: Option<Span>,
 ) -> Result<Parser<'a>, Vec<Diag<'a>>> {
     let sm = psess.source_map();
@@ -110,7 +100,7 @@ pub fn new_parser_from_file<'a>(
         }
         err.emit();
     });
-    new_parser_from_source_file(psess, source_file, StripTokens::ShebangAndFrontmatter)
+    new_parser_from_source_file(psess, source_file, strip_tokens)
 }
 
 pub fn utf8_error<E: EmissionGuarantee>(
@@ -172,6 +162,9 @@ fn new_parser_from_source_file(
     Ok(parser)
 }
 
+/// Given a source string, produces a sequence of token trees.
+///
+/// NOTE: This only strips shebangs, not frontmatter!
 pub fn source_str_to_stream(
     psess: &ParseSess,
     name: FileName,
@@ -179,13 +172,16 @@ pub fn source_str_to_stream(
     override_span: Option<Span>,
 ) -> Result<TokenStream, Vec<Diag<'_>>> {
     let source_file = psess.source_map().new_source_file(name, source);
-    // used mainly for `proc_macro` and the likes, not for our parsing purposes, so don't parse
-    // frontmatters as frontmatters, but for compatibility reason still strip the shebang
+    // FIXME(frontmatter): Consider stripping frontmatter in a future edition. We can't strip them
+    // in the current edition since that would be breaking.
+    // See also <https://github.com/rust-lang/rust/issues/145520>.
+    // Alternatively, stop stripping shebangs here, too, if T-lang and crater approve.
     source_file_to_stream(psess, source_file, override_span, StripTokens::Shebang)
 }
 
-/// Given a source file, produces a sequence of token trees. Returns any buffered errors from
-/// parsing the token stream.
+/// Given a source file, produces a sequence of token trees.
+///
+/// Returns any buffered errors from parsing the token stream.
 fn source_file_to_stream<'psess>(
     psess: &'psess ParseSess,
     source_file: Arc<SourceFile>,
diff --git a/compiler/rustc_parse/src/parser/tests.rs b/compiler/rustc_parse/src/parser/tests.rs
index a6e7266e71b4d..e645fb47b9ecf 100644
--- a/compiler/rustc_parse/src/parser/tests.rs
+++ b/compiler/rustc_parse/src/parser/tests.rs
@@ -22,6 +22,7 @@ use rustc_span::{
 };
 use termcolor::WriteColor;
 
+use crate::lexer::StripTokens;
 use crate::parser::{ForceCollect, Parser};
 use crate::{new_parser_from_source_str, source_str_to_stream, unwrap_or_emit_fatal};
 
@@ -35,6 +36,7 @@ fn string_to_parser(psess: &ParseSess, source_str: String) -> Parser<'_> {
         psess,
         PathBuf::from("bogofile").into(),
         source_str,
+        StripTokens::Nothing,
     ))
 }
 
@@ -2240,7 +2242,7 @@ fn parse_item_from_source_str(
     source: String,
     psess: &ParseSess,
 ) -> PResult<'_, Option<Box<ast::Item>>> {
-    unwrap_or_emit_fatal(new_parser_from_source_str(psess, name, source))
+    unwrap_or_emit_fatal(new_parser_from_source_str(psess, name, source, StripTokens::Nothing))
         .parse_item(ForceCollect::No)
 }
 
@@ -2520,7 +2522,8 @@ fn ttdelim_span() {
         source: String,
         psess: &ParseSess,
     ) -> PResult<'_, Box<ast::Expr>> {
-        unwrap_or_emit_fatal(new_parser_from_source_str(psess, name, source)).parse_expr()
+        unwrap_or_emit_fatal(new_parser_from_source_str(psess, name, source, StripTokens::Nothing))
+            .parse_expr()
     }
 
     create_default_session_globals_then(|| {
diff --git a/src/librustdoc/clean/render_macro_matchers.rs b/src/librustdoc/clean/render_macro_matchers.rs
index d684e6f8650f9..b5a8d64ff4f56 100644
--- a/src/librustdoc/clean/render_macro_matchers.rs
+++ b/src/librustdoc/clean/render_macro_matchers.rs
@@ -3,6 +3,7 @@ use rustc_ast::tokenstream::{TokenStream, TokenTree};
 use rustc_ast_pretty::pprust::PrintState;
 use rustc_ast_pretty::pprust::state::State as Printer;
 use rustc_middle::ty::TyCtxt;
+use rustc_parse::lexer::StripTokens;
 use rustc_session::parse::ParseSess;
 use rustc_span::symbol::{Ident, Symbol, kw};
 use rustc_span::{FileName, Span};
@@ -64,14 +65,18 @@ fn snippet_equal_to_token(tcx: TyCtxt<'_>, matcher: &TokenTree) -> Option<String
     // Create a Parser.
     let psess = ParseSess::new(rustc_driver::DEFAULT_LOCALE_RESOURCES.to_vec());
     let file_name = FileName::macro_expansion_source_code(&snippet);
-    let mut parser =
-        match rustc_parse::new_parser_from_source_str(&psess, file_name, snippet.clone()) {
-            Ok(parser) => parser,
-            Err(errs) => {
-                errs.into_iter().for_each(|err| err.cancel());
-                return None;
-            }
-        };
+    let mut parser = match rustc_parse::new_parser_from_source_str(
+        &psess,
+        file_name,
+        snippet.clone(),
+        StripTokens::Nothing,
+    ) {
+        Ok(parser) => parser,
+        Err(errs) => {
+            errs.into_iter().for_each(|err| err.cancel());
+            return None;
+        }
+    };
 
     // Reparse a single token tree.
     if parser.token == token::Eof {
diff --git a/src/librustdoc/doctest/make.rs b/src/librustdoc/doctest/make.rs
index f229f77c97846..5eaadc9eb4510 100644
--- a/src/librustdoc/doctest/make.rs
+++ b/src/librustdoc/doctest/make.rs
@@ -10,6 +10,7 @@ use rustc_ast::tokenstream::TokenTree;
 use rustc_ast::{self as ast, AttrStyle, HasAttrs, StmtKind};
 use rustc_errors::emitter::stderr_destination;
 use rustc_errors::{ColorConfig, DiagCtxtHandle};
+use rustc_parse::lexer::StripTokens;
 use rustc_parse::new_parser_from_source_str;
 use rustc_session::parse::ParseSess;
 use rustc_span::edition::{DEFAULT_EDITION, Edition};
@@ -468,14 +469,16 @@ fn parse_source(
     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, wrapped_source) {
-        Ok(p) => p,
-        Err(errs) => {
-            errs.into_iter().for_each(|err| err.cancel());
-            reset_error_count(&psess);
-            return Err(());
-        }
-    };
+    // Don't strip any tokens; it wouldn't matter anyway because the source is wrapped in a function.
+    let mut parser =
+        match new_parser_from_source_str(&psess, filename, wrapped_source, StripTokens::Nothing) {
+            Ok(p) => p,
+            Err(errs) => {
+                errs.into_iter().for_each(|err| err.cancel());
+                reset_error_count(&psess);
+                return Err(());
+            }
+        };
 
     fn push_to_s(s: &mut String, source: &str, span: rustc_span::Span, prev_span_hi: &mut usize) {
         let extra_len = DOCTEST_CODE_WRAPPER.len();
diff --git a/src/tools/clippy/clippy_lints/src/doc/needless_doctest_main.rs b/src/tools/clippy/clippy_lints/src/doc/needless_doctest_main.rs
index 74283d7ba863b..43bb972355500 100644
--- a/src/tools/clippy/clippy_lints/src/doc/needless_doctest_main.rs
+++ b/src/tools/clippy/clippy_lints/src/doc/needless_doctest_main.rs
@@ -8,6 +8,7 @@ use rustc_ast::{CoroutineKind, Fn, FnRetTy, Item, ItemKind};
 use rustc_errors::emitter::HumanEmitter;
 use rustc_errors::{Diag, DiagCtxt};
 use rustc_lint::LateContext;
+use rustc_parse::lexer::StripTokens;
 use rustc_parse::new_parser_from_source_str;
 use rustc_parse::parser::ForceCollect;
 use rustc_session::parse::ParseSess;
@@ -49,13 +50,14 @@ pub fn check(
                 let sm = Arc::new(SourceMap::new(FilePathMapping::empty()));
                 let psess = ParseSess::with_dcx(dcx, sm);
 
-                let mut parser = match new_parser_from_source_str(&psess, filename, code) {
-                    Ok(p) => p,
-                    Err(errs) => {
-                        errs.into_iter().for_each(Diag::cancel);
-                        return (false, test_attr_spans);
-                    },
-                };
+                let mut parser =
+                    match new_parser_from_source_str(&psess, filename, code, StripTokens::ShebangAndFrontmatter) {
+                        Ok(p) => p,
+                        Err(errs) => {
+                            errs.into_iter().for_each(Diag::cancel);
+                            return (false, test_attr_spans);
+                        },
+                    };
 
                 let mut relevant_main_found = false;
                 let mut eligible = true;
diff --git a/src/tools/rustfmt/src/parse/parser.rs b/src/tools/rustfmt/src/parse/parser.rs
index 2ec8769c45f2a..63c6c8c99d0dd 100644
--- a/src/tools/rustfmt/src/parse/parser.rs
+++ b/src/tools/rustfmt/src/parse/parser.rs
@@ -3,6 +3,7 @@ use std::path::{Path, PathBuf};
 
 use rustc_ast::{ast, attr};
 use rustc_errors::Diag;
+use rustc_parse::lexer::StripTokens;
 use rustc_parse::parser::Parser as RawParser;
 use rustc_parse::{exp, new_parser_from_file, new_parser_from_source_str, unwrap_or_emit_fatal};
 use rustc_span::{Span, sym};
@@ -64,11 +65,14 @@ impl<'a> ParserBuilder<'a> {
         input: Input,
     ) -> Result<RawParser<'a>, Vec<Diag<'a>>> {
         match input {
-            Input::File(ref file) => new_parser_from_file(psess, file, None),
+            Input::File(ref file) => {
+                new_parser_from_file(psess, file, StripTokens::ShebangAndFrontmatter, None)
+            }
             Input::Text(text) => new_parser_from_source_str(
                 psess,
                 rustc_span::FileName::Custom("stdin".to_owned()),
                 text,
+                StripTokens::ShebangAndFrontmatter,
             ),
         }
     }
@@ -104,8 +108,12 @@ impl<'a> Parser<'a> {
         span: Span,
     ) -> Result<(ast::AttrVec, ThinVec<Box<ast::Item>>, Span), ParserError> {
         let result = catch_unwind(AssertUnwindSafe(|| {
-            let mut parser =
-                unwrap_or_emit_fatal(new_parser_from_file(psess.inner(), path, Some(span)));
+            let mut parser = unwrap_or_emit_fatal(new_parser_from_file(
+                psess.inner(),
+                path,
+                StripTokens::ShebangAndFrontmatter,
+                Some(span),
+            ));
             match parser.parse_mod(exp!(Eof)) {
                 Ok((a, i, spans)) => Some((a, i, spans.inner_span)),
                 Err(e) => {
diff --git a/tests/ui-fulldeps/auxiliary/parser.rs b/tests/ui-fulldeps/auxiliary/parser.rs
index 6726969350dd1..6ee39e5130f68 100644
--- a/tests/ui-fulldeps/auxiliary/parser.rs
+++ b/tests/ui-fulldeps/auxiliary/parser.rs
@@ -10,7 +10,7 @@ extern crate rustc_span;
 use rustc_ast::ast::{AttrKind, Attribute, DUMMY_NODE_ID, Expr};
 use rustc_ast::mut_visit::{self, MutVisitor};
 use rustc_ast::node_id::NodeId;
-use rustc_ast::token::{self, Token};
+use rustc_ast::token;
 use rustc_ast::tokenstream::{AttrTokenStream, AttrTokenTree, LazyAttrTokenStream};
 use rustc_errors::Diag;
 use rustc_parse::parser::Recovery;
@@ -23,6 +23,7 @@ pub fn parse_expr(psess: &ParseSess, source_code: &str) -> Option<Box<Expr>> {
         psess,
         FileName::anon_source_code(source_code),
         source_code.to_owned(),
+        rustc_parse::lexer::StripTokens::Nothing,
     ));
 
     let mut parser = parser.recovery(Recovery::Forbidden);
diff --git a/tests/ui-fulldeps/mod_dir_path_canonicalized.rs b/tests/ui-fulldeps/mod_dir_path_canonicalized.rs
index 99cb5fc5aa1c6..df5f29e35fe69 100644
--- a/tests/ui-fulldeps/mod_dir_path_canonicalized.rs
+++ b/tests/ui-fulldeps/mod_dir_path_canonicalized.rs
@@ -16,7 +16,7 @@ extern crate rustc_span;
 #[allow(unused_extern_crates)]
 extern crate rustc_driver;
 
-use rustc_parse::{new_parser_from_file, unwrap_or_emit_fatal};
+use rustc_parse::{lexer::StripTokens, new_parser_from_file, unwrap_or_emit_fatal};
 use rustc_session::parse::ParseSess;
 use std::path::Path;
 
@@ -34,6 +34,11 @@ fn parse() {
 
     let path = Path::new(file!());
     let path = path.canonicalize().unwrap();
-    let mut parser = unwrap_or_emit_fatal(new_parser_from_file(&psess, &path, None));
+    let mut parser = unwrap_or_emit_fatal(new_parser_from_file(
+        &psess,
+        &path,
+        StripTokens::ShebangAndFrontmatter,
+        None,
+    ));
     let _ = parser.parse_crate_mod();
 }
diff --git a/tests/ui/frontmatter/auxiliary/expr.rs b/tests/ui/frontmatter/auxiliary/expr.rs
new file mode 100644
index 0000000000000..5f6941106664c
--- /dev/null
+++ b/tests/ui/frontmatter/auxiliary/expr.rs
@@ -0,0 +1,4 @@
+---
+-
+---
+1
diff --git a/tests/ui/frontmatter/auxiliary/makro.rs b/tests/ui/frontmatter/auxiliary/makro.rs
index 70707b27bff95..1d64fa44bd3e1 100644
--- a/tests/ui/frontmatter/auxiliary/makro.rs
+++ b/tests/ui/frontmatter/auxiliary/makro.rs
@@ -1,8 +1,20 @@
 extern crate proc_macro;
-use proc_macro::TokenStream;
+use proc_macro::{Literal, TokenStream};
 
 #[proc_macro]
 pub fn check(_: TokenStream) -> TokenStream {
+    // In the following test cases, the `---` may look like the start of frontmatter but it is not!
+    // That's because it would be backward incompatible to interpret them as such in the latest
+    // stable edition. That's not only the case due to the feature gate error but also due to the
+    // fact that we "eagerly" emit errors on malformed frontmatter.
+
+    // issue: <https://github.com/rust-lang/rust/issues/145520>
+    _ = "---".parse::<TokenStream>();
+    // Just a sequence of regular Rust punctuation tokens.
     assert_eq!(6, "---\n---".parse::<TokenStream>().unwrap().into_iter().count());
+
+    // issue: <https://github.com/rust-lang/rust/issues/146132>
+    assert!("---".parse::<Literal>().is_err());
+
     Default::default()
 }
diff --git a/tests/ui/frontmatter/include-in-expr-ctxt.rs b/tests/ui/frontmatter/include-in-expr-ctxt.rs
new file mode 100644
index 0000000000000..7b02c9cb8a54e
--- /dev/null
+++ b/tests/ui/frontmatter/include-in-expr-ctxt.rs
@@ -0,0 +1,9 @@
+// Check that an expr-ctxt `include` doesn't try to parse frontmatter and instead
+// treats it as a regular Rust token sequence.
+//@ check-pass
+#![expect(double_negations)]
+
+fn main() {
+    // issue: <https://github.com/rust-lang/rust/issues/145945>
+    const _: () = assert!(-1 == include!("auxiliary/expr.rs"));
+}
diff --git a/tests/ui/frontmatter/include-in-item-ctxt.rs b/tests/ui/frontmatter/include-in-item-ctxt.rs
new file mode 100644
index 0000000000000..c8455bc49abd2
--- /dev/null
+++ b/tests/ui/frontmatter/include-in-item-ctxt.rs
@@ -0,0 +1,10 @@
+// Ensure that in item ctxts we can `include` files that contain frontmatter.
+//@ check-pass
+
+#![feature(frontmatter)]
+
+include!("auxiliary/lib.rs");
+
+fn main() {
+    foo(1);
+}
diff --git a/tests/ui/frontmatter/included-frontmatter.rs b/tests/ui/frontmatter/included-frontmatter.rs
deleted file mode 100644
index 57616cd1228c1..0000000000000
--- a/tests/ui/frontmatter/included-frontmatter.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-#![feature(frontmatter)]
-
-//@ check-pass
-
-include!("auxiliary/lib.rs");
-
-// auxiliary/lib.rs contains a frontmatter. Ensure that we can use them in an
-// `include!` macro.
-
-fn main() {
-    foo(1);
-}
diff --git a/tests/ui/frontmatter/proc-macro-observer.rs b/tests/ui/frontmatter/proc-macro-observer.rs
index b1cc1460933f2..6c4c8c572897e 100644
--- a/tests/ui/frontmatter/proc-macro-observer.rs
+++ b/tests/ui/frontmatter/proc-macro-observer.rs
@@ -2,10 +2,9 @@
 //@ proc-macro: makro.rs
 //@ edition: 2021
 
-makro::check!();
+// Check that a proc-macro doesn't try to parse frontmatter and instead treats
+// it as a regular Rust token sequence. See `auxiliary/makro.rs` for details.
 
-// checks that a proc-macro doesn't know or parse frontmatters at all and instead treats
-// it as normal Rust code.
-// see auxiliary/makro.rs for how it is tested.
+makro::check!();
 
 fn main() {}

From c9ed8a1ced9601bfd96a63be4fa0cdc4c6cb41a7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Mon, 8 Sep 2025 19:25:22 +0200
Subject: [PATCH 0730/1889] Strip frontmatter in fewer places

---
 clippy_lints/src/doc/needless_doctest_main.rs | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/clippy_lints/src/doc/needless_doctest_main.rs b/clippy_lints/src/doc/needless_doctest_main.rs
index 74283d7ba863b..43bb972355500 100644
--- a/clippy_lints/src/doc/needless_doctest_main.rs
+++ b/clippy_lints/src/doc/needless_doctest_main.rs
@@ -8,6 +8,7 @@ use rustc_ast::{CoroutineKind, Fn, FnRetTy, Item, ItemKind};
 use rustc_errors::emitter::HumanEmitter;
 use rustc_errors::{Diag, DiagCtxt};
 use rustc_lint::LateContext;
+use rustc_parse::lexer::StripTokens;
 use rustc_parse::new_parser_from_source_str;
 use rustc_parse::parser::ForceCollect;
 use rustc_session::parse::ParseSess;
@@ -49,13 +50,14 @@ pub fn check(
                 let sm = Arc::new(SourceMap::new(FilePathMapping::empty()));
                 let psess = ParseSess::with_dcx(dcx, sm);
 
-                let mut parser = match new_parser_from_source_str(&psess, filename, code) {
-                    Ok(p) => p,
-                    Err(errs) => {
-                        errs.into_iter().for_each(Diag::cancel);
-                        return (false, test_attr_spans);
-                    },
-                };
+                let mut parser =
+                    match new_parser_from_source_str(&psess, filename, code, StripTokens::ShebangAndFrontmatter) {
+                        Ok(p) => p,
+                        Err(errs) => {
+                            errs.into_iter().for_each(Diag::cancel);
+                            return (false, test_attr_spans);
+                        },
+                    };
 
                 let mut relevant_main_found = false;
                 let mut eligible = true;

From 0c96200f268df10d4f3ac102f3161c67e5e67221 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Mon, 8 Sep 2025 18:45:41 +0200
Subject: [PATCH 0731/1889] c-variadic: reject non-unsafe functions

---
 compiler/rustc_ast/src/ast.rs                 | 23 ++++++++++
 compiler/rustc_ast_passes/messages.ftl        |  4 ++
 .../rustc_ast_passes/src/ast_validation.rs    | 23 ++++++----
 compiler/rustc_ast_passes/src/errors.rs       | 15 +++++++
 .../variadic-ffi-semantic-restrictions.rs     | 12 +++---
 .../variadic-ffi-semantic-restrictions.stderr | 42 ++++++++++++++++---
 6 files changed, 98 insertions(+), 21 deletions(-)

diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index 2733a2603d6d8..915bae9e5f5aa 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -2309,6 +2309,22 @@ impl FnSig {
 
         self.span.shrink_to_lo()
     }
+
+    /// The span of the header's safety, or where to insert it if empty.
+    pub fn safety_span(&self) -> Span {
+        match self.header.safety {
+            Safety::Unsafe(span) | Safety::Safe(span) => span,
+            Safety::Default => {
+                // Insert after the `coroutine_kind` if available.
+                if let Some(extern_span) = self.header.ext.span() {
+                    return extern_span.shrink_to_lo();
+                }
+
+                // Insert right at the front of the signature.
+                self.header_span().shrink_to_hi()
+            }
+        }
+    }
 }
 
 /// A constraint on an associated item.
@@ -3553,6 +3569,13 @@ impl Extern {
             None => Extern::Implicit(span),
         }
     }
+
+    pub fn span(self) -> Option<Span> {
+        match self {
+            Extern::None => None,
+            Extern::Implicit(span) | Extern::Explicit(_, span) => Some(span),
+        }
+    }
 }
 
 /// A function header.
diff --git a/compiler/rustc_ast_passes/messages.ftl b/compiler/rustc_ast_passes/messages.ftl
index 958797a608947..1aa38a1beda3a 100644
--- a/compiler/rustc_ast_passes/messages.ftl
+++ b/compiler/rustc_ast_passes/messages.ftl
@@ -68,6 +68,10 @@ ast_passes_bound_in_context = bounds on `type`s in {$ctx} have no effect
 
 ast_passes_c_variadic_associated_function = associated functions cannot have a C variable argument list
 
+ast_passes_c_variadic_must_be_unsafe =
+    functions with a C variable argument list must be unsafe
+    .suggestion = add the `unsafe` keyword to this definition
+
 ast_passes_c_variadic_no_extern = `...` is not supported for non-extern functions
 
 ast_passes_const_and_c_variadic = functions cannot be both `const` and C-variadic
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index f425acda3583e..7b32778ddf042 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -698,20 +698,25 @@ impl<'a> AstValidator<'a> {
             FnCtxt::Foreign => return,
             FnCtxt::Free => match sig.header.ext {
                 Extern::Implicit(_) => {
-                    if matches!(sig.header.safety, Safety::Unsafe(_)) {
-                        return;
+                    // Implicitly defaults to C.
+                    if !matches!(sig.header.safety, Safety::Unsafe(_)) {
+                        self.dcx().emit_err(errors::CVariadicMustBeUnsafe {
+                            span: variadic_param.span,
+                            unsafe_span: sig.safety_span(),
+                        });
                     }
-
-                    self.dcx().emit_err(errors::BadCVariadic { span: variadic_param.span });
                 }
                 Extern::Explicit(StrLit { symbol_unescaped, .. }, _) => {
-                    if matches!(symbol_unescaped, sym::C | sym::C_dash_unwind) {
-                        if matches!(sig.header.safety, Safety::Unsafe(_)) {
-                            return;
-                        }
+                    if !matches!(symbol_unescaped, sym::C | sym::C_dash_unwind) {
+                        self.dcx().emit_err(errors::BadCVariadic { span: variadic_param.span });
                     }
 
-                    self.dcx().emit_err(errors::BadCVariadic { span: variadic_param.span });
+                    if !matches!(sig.header.safety, Safety::Unsafe(_)) {
+                        self.dcx().emit_err(errors::CVariadicMustBeUnsafe {
+                            span: variadic_param.span,
+                            unsafe_span: sig.safety_span(),
+                        });
+                    }
                 }
                 Extern::None => {
                     let err = errors::CVariadicNoExtern { span: variadic_param.span };
diff --git a/compiler/rustc_ast_passes/src/errors.rs b/compiler/rustc_ast_passes/src/errors.rs
index 6b57e5ef37613..946a22d2e759e 100644
--- a/compiler/rustc_ast_passes/src/errors.rs
+++ b/compiler/rustc_ast_passes/src/errors.rs
@@ -332,6 +332,21 @@ pub(crate) struct CVariadicNoExtern {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(ast_passes_c_variadic_must_be_unsafe)]
+pub(crate) struct CVariadicMustBeUnsafe {
+    #[primary_span]
+    pub span: Span,
+
+    #[suggestion(
+        ast_passes_suggestion,
+        applicability = "maybe-incorrect",
+        code = "unsafe ",
+        style = "verbose"
+    )]
+    pub unsafe_span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(ast_passes_bad_c_variadic)]
 pub(crate) struct BadCVariadic {
diff --git a/tests/ui/parser/variadic-ffi-semantic-restrictions.rs b/tests/ui/parser/variadic-ffi-semantic-restrictions.rs
index fe5421ab2c0ae..ff491322efc50 100644
--- a/tests/ui/parser/variadic-ffi-semantic-restrictions.rs
+++ b/tests/ui/parser/variadic-ffi-semantic-restrictions.rs
@@ -10,19 +10,19 @@ fn f1_2(...) {}
 //~^ ERROR `...` is not supported for non-extern functions
 
 extern "C" fn f2_1(x: isize, ...) {}
-//~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+//~^ ERROR functions with a C variable argument list must be unsafe
 
 extern "C" fn f2_2(...) {}
-//~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+//~^ ERROR functions with a C variable argument list must be unsafe
 
 extern "C" fn f2_3(..., x: isize) {}
 //~^ ERROR `...` must be the last argument of a C-variadic function
 
 extern "C" fn f3_1(x: isize, ...) {}
-//~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+//~^ ERROR functions with a C variable argument list must be unsafe
 
 extern "C" fn f3_2(...) {}
-//~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+//~^ ERROR functions with a C variable argument list must be unsafe
 
 extern "C" fn f3_3(..., x: isize) {}
 //~^ ERROR `...` must be the last argument of a C-variadic function
@@ -33,12 +33,12 @@ const unsafe extern "C" fn f4_1(x: isize, ...) {}
 
 const extern "C" fn f4_2(x: isize, ...) {}
 //~^ ERROR functions cannot be both `const` and C-variadic
-//~| ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+//~| ERROR functions with a C variable argument list must be unsafe
 //~| ERROR destructor of `VaListImpl<'_>` cannot be evaluated at compile-time
 
 const extern "C" fn f4_3(..., x: isize, ...) {}
 //~^ ERROR functions cannot be both `const` and C-variadic
-//~| ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+//~| ERROR functions with a C variable argument list must be unsafe
 //~| ERROR `...` must be the last argument of a C-variadic function
 
 extern "C" {
diff --git a/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr b/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr
index 0abe152640530..98f1d79f8f4e3 100644
--- a/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr
+++ b/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr
@@ -10,17 +10,27 @@ error: `...` is not supported for non-extern functions
 LL | fn f1_2(...) {}
    |         ^^^
 
-error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+error: functions with a C variable argument list must be unsafe
   --> $DIR/variadic-ffi-semantic-restrictions.rs:12:30
    |
 LL | extern "C" fn f2_1(x: isize, ...) {}
    |                              ^^^
+   |
+help: add the `unsafe` keyword to this definition
+   |
+LL | unsafe extern "C" fn f2_1(x: isize, ...) {}
+   | ++++++
 
-error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+error: functions with a C variable argument list must be unsafe
   --> $DIR/variadic-ffi-semantic-restrictions.rs:15:20
    |
 LL | extern "C" fn f2_2(...) {}
    |                    ^^^
+   |
+help: add the `unsafe` keyword to this definition
+   |
+LL | unsafe extern "C" fn f2_2(...) {}
+   | ++++++
 
 error: `...` must be the last argument of a C-variadic function
   --> $DIR/variadic-ffi-semantic-restrictions.rs:18:20
@@ -28,17 +38,27 @@ error: `...` must be the last argument of a C-variadic function
 LL | extern "C" fn f2_3(..., x: isize) {}
    |                    ^^^
 
-error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+error: functions with a C variable argument list must be unsafe
   --> $DIR/variadic-ffi-semantic-restrictions.rs:21:30
    |
 LL | extern "C" fn f3_1(x: isize, ...) {}
    |                              ^^^
+   |
+help: add the `unsafe` keyword to this definition
+   |
+LL | unsafe extern "C" fn f3_1(x: isize, ...) {}
+   | ++++++
 
-error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+error: functions with a C variable argument list must be unsafe
   --> $DIR/variadic-ffi-semantic-restrictions.rs:24:20
    |
 LL | extern "C" fn f3_2(...) {}
    |                    ^^^
+   |
+help: add the `unsafe` keyword to this definition
+   |
+LL | unsafe extern "C" fn f3_2(...) {}
+   | ++++++
 
 error: `...` must be the last argument of a C-variadic function
   --> $DIR/variadic-ffi-semantic-restrictions.rs:27:20
@@ -58,11 +78,16 @@ error: functions cannot be both `const` and C-variadic
 LL | const extern "C" fn f4_2(x: isize, ...) {}
    | ^^^^^ `const` because of this      ^^^ C-variadic because of this
 
-error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+error: functions with a C variable argument list must be unsafe
   --> $DIR/variadic-ffi-semantic-restrictions.rs:34:36
    |
 LL | const extern "C" fn f4_2(x: isize, ...) {}
    |                                    ^^^
+   |
+help: add the `unsafe` keyword to this definition
+   |
+LL | const unsafe extern "C" fn f4_2(x: isize, ...) {}
+   |       ++++++
 
 error: `...` must be the last argument of a C-variadic function
   --> $DIR/variadic-ffi-semantic-restrictions.rs:39:26
@@ -76,11 +101,16 @@ error: functions cannot be both `const` and C-variadic
 LL | const extern "C" fn f4_3(..., x: isize, ...) {}
    | ^^^^^ `const` because of this           ^^^ C-variadic because of this
 
-error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+error: functions with a C variable argument list must be unsafe
   --> $DIR/variadic-ffi-semantic-restrictions.rs:39:41
    |
 LL | const extern "C" fn f4_3(..., x: isize, ...) {}
    |                                         ^^^
+   |
+help: add the `unsafe` keyword to this definition
+   |
+LL | const unsafe extern "C" fn f4_3(..., x: isize, ...) {}
+   |       ++++++
 
 error: `...` must be the last argument of a C-variadic function
   --> $DIR/variadic-ffi-semantic-restrictions.rs:45:13

From 9196844f0d86242ee3d6a446fe681b6b2d2d674c Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Mon, 8 Sep 2025 19:27:07 +0200
Subject: [PATCH 0732/1889] c-variadic: reject functions with unsupported
 extern ABI

---
 compiler/rustc_ast/src/ast.rs                 |  5 ++
 compiler/rustc_ast_passes/messages.ftl        |  7 +-
 .../rustc_ast_passes/src/ast_validation.rs    |  7 +-
 compiler/rustc_ast_passes/src/errors.rs       |  9 ++-
 tests/ui/c-variadic/issue-86053-1.stderr      |  2 +
 .../cmse-nonsecure-entry/generics.rs          |  2 +-
 .../cmse-nonsecure-entry/generics.stderr      |  8 +-
 .../variadic-ffi-semantic-restrictions.rs     |  3 +
 .../variadic-ffi-semantic-restrictions.stderr | 76 +++++++++++--------
 9 files changed, 79 insertions(+), 40 deletions(-)

diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index 915bae9e5f5aa..3e8fddd9954e2 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -2325,6 +2325,11 @@ impl FnSig {
             }
         }
     }
+
+    /// The span of the header's extern, or where to insert it if empty.
+    pub fn extern_span(&self) -> Span {
+        self.header.ext.span().unwrap_or(self.safety_span().shrink_to_hi())
+    }
 }
 
 /// A constraint on an associated item.
diff --git a/compiler/rustc_ast_passes/messages.ftl b/compiler/rustc_ast_passes/messages.ftl
index 1aa38a1beda3a..8dcf3e3aa3882 100644
--- a/compiler/rustc_ast_passes/messages.ftl
+++ b/compiler/rustc_ast_passes/messages.ftl
@@ -57,8 +57,6 @@ ast_passes_auto_super_lifetime = auto traits cannot have super traits or lifetim
     .label = {ast_passes_auto_super_lifetime}
     .suggestion = remove the super traits or lifetime bounds
 
-ast_passes_bad_c_variadic = defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
-
 ast_passes_body_in_extern = incorrect `{$kind}` inside `extern` block
     .cannot_have = cannot have a body
     .invalid = the invalid body
@@ -68,11 +66,16 @@ ast_passes_bound_in_context = bounds on `type`s in {$ctx} have no effect
 
 ast_passes_c_variadic_associated_function = associated functions cannot have a C variable argument list
 
+ast_passes_c_variadic_bad_extern = `...` is not supported for `extern "{$abi}"` functions
+    .label = `extern "{$abi}"` because of this
+    .help = only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
 ast_passes_c_variadic_must_be_unsafe =
     functions with a C variable argument list must be unsafe
     .suggestion = add the `unsafe` keyword to this definition
 
 ast_passes_c_variadic_no_extern = `...` is not supported for non-extern functions
+    .help = only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
 
 ast_passes_const_and_c_variadic = functions cannot be both `const` and C-variadic
     .const = `const` because of this
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index 7b32778ddf042..a6ef89b553db4 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -698,7 +698,6 @@ impl<'a> AstValidator<'a> {
             FnCtxt::Foreign => return,
             FnCtxt::Free => match sig.header.ext {
                 Extern::Implicit(_) => {
-                    // Implicitly defaults to C.
                     if !matches!(sig.header.safety, Safety::Unsafe(_)) {
                         self.dcx().emit_err(errors::CVariadicMustBeUnsafe {
                             span: variadic_param.span,
@@ -708,7 +707,11 @@ impl<'a> AstValidator<'a> {
                 }
                 Extern::Explicit(StrLit { symbol_unescaped, .. }, _) => {
                     if !matches!(symbol_unescaped, sym::C | sym::C_dash_unwind) {
-                        self.dcx().emit_err(errors::BadCVariadic { span: variadic_param.span });
+                        self.dcx().emit_err(errors::CVariadicBadExtern {
+                            span: variadic_param.span,
+                            abi: symbol_unescaped,
+                            extern_span: sig.extern_span(),
+                        });
                     }
 
                     if !matches!(sig.header.safety, Safety::Unsafe(_)) {
diff --git a/compiler/rustc_ast_passes/src/errors.rs b/compiler/rustc_ast_passes/src/errors.rs
index 946a22d2e759e..ae805042c549f 100644
--- a/compiler/rustc_ast_passes/src/errors.rs
+++ b/compiler/rustc_ast_passes/src/errors.rs
@@ -327,6 +327,7 @@ pub(crate) struct CVariadicAssociatedFunction {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_c_variadic_no_extern)]
+#[help]
 pub(crate) struct CVariadicNoExtern {
     #[primary_span]
     pub span: Span,
@@ -348,10 +349,14 @@ pub(crate) struct CVariadicMustBeUnsafe {
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_passes_bad_c_variadic)]
-pub(crate) struct BadCVariadic {
+#[diag(ast_passes_c_variadic_bad_extern)]
+#[help]
+pub(crate) struct CVariadicBadExtern {
     #[primary_span]
     pub span: Span,
+    pub abi: Symbol,
+    #[label]
+    pub extern_span: Span,
 }
 
 #[derive(Diagnostic)]
diff --git a/tests/ui/c-variadic/issue-86053-1.stderr b/tests/ui/c-variadic/issue-86053-1.stderr
index eb08370b4f800..adbc04d3a65a4 100644
--- a/tests/ui/c-variadic/issue-86053-1.stderr
+++ b/tests/ui/c-variadic/issue-86053-1.stderr
@@ -51,6 +51,8 @@ error: `...` is not supported for non-extern functions
    |
 LL |     self , ... ,   self ,   self , ... ) where F : FnOnce ( & 'a & 'b usize ) {
    |                                    ^^^
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
 
 error[E0412]: cannot find type `F` in this scope
   --> $DIR/issue-86053-1.rs:11:48
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs
index 4ebc2bbf76129..eb6f4a323655b 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs
@@ -67,6 +67,6 @@ extern "cmse-nonsecure-entry" fn wrapped_trait_object(x: WrapperTransparent) ->
 }
 
 unsafe extern "cmse-nonsecure-entry" fn c_variadic(_: u32, _: ...) {
-    //~^ ERROR defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+    //~^ ERROR `...` is not supported for `extern "cmse-nonsecure-entry"` functions
     //~| ERROR requires `va_list` lang_item
 }
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr
index 55921e764ba21..8937def9428cf 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr
@@ -1,8 +1,12 @@
-error: defining functions with C-variadic arguments is only allowed for free functions with the "C" or "C-unwind" calling convention
+error: `...` is not supported for `extern "cmse-nonsecure-entry"` functions
   --> $DIR/generics.rs:69:60
    |
 LL | unsafe extern "cmse-nonsecure-entry" fn c_variadic(_: u32, _: ...) {
-   |                                                            ^^^^^^
+   |        -----------------------------                       ^^^^^^
+   |        |
+   |        `extern "cmse-nonsecure-entry"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
 
 error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
   --> $DIR/generics.rs:30:1
diff --git a/tests/ui/parser/variadic-ffi-semantic-restrictions.rs b/tests/ui/parser/variadic-ffi-semantic-restrictions.rs
index ff491322efc50..4db056f15a51f 100644
--- a/tests/ui/parser/variadic-ffi-semantic-restrictions.rs
+++ b/tests/ui/parser/variadic-ffi-semantic-restrictions.rs
@@ -9,6 +9,9 @@ fn f1_1(x: isize, ...) {}
 fn f1_2(...) {}
 //~^ ERROR `...` is not supported for non-extern functions
 
+unsafe extern "Rust" fn f1_3(...) {}
+//~^ ERROR `...` is not supported for `extern "Rust"` functions
+
 extern "C" fn f2_1(x: isize, ...) {}
 //~^ ERROR functions with a C variable argument list must be unsafe
 
diff --git a/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr b/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr
index 98f1d79f8f4e3..0cd78318de6a8 100644
--- a/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr
+++ b/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr
@@ -3,16 +3,30 @@ error: `...` is not supported for non-extern functions
    |
 LL | fn f1_1(x: isize, ...) {}
    |                   ^^^
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
 
 error: `...` is not supported for non-extern functions
   --> $DIR/variadic-ffi-semantic-restrictions.rs:9:9
    |
 LL | fn f1_2(...) {}
    |         ^^^
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
 
-error: functions with a C variable argument list must be unsafe
+error: `...` is not supported for `extern "Rust"` functions
   --> $DIR/variadic-ffi-semantic-restrictions.rs:12:30
    |
+LL | unsafe extern "Rust" fn f1_3(...) {}
+   |        -------------         ^^^
+   |        |
+   |        `extern "Rust"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: functions with a C variable argument list must be unsafe
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:15:30
+   |
 LL | extern "C" fn f2_1(x: isize, ...) {}
    |                              ^^^
    |
@@ -22,7 +36,7 @@ LL | unsafe extern "C" fn f2_1(x: isize, ...) {}
    | ++++++
 
 error: functions with a C variable argument list must be unsafe
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:15:20
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:18:20
    |
 LL | extern "C" fn f2_2(...) {}
    |                    ^^^
@@ -33,13 +47,13 @@ LL | unsafe extern "C" fn f2_2(...) {}
    | ++++++
 
 error: `...` must be the last argument of a C-variadic function
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:18:20
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:21:20
    |
 LL | extern "C" fn f2_3(..., x: isize) {}
    |                    ^^^
 
 error: functions with a C variable argument list must be unsafe
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:21:30
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:24:30
    |
 LL | extern "C" fn f3_1(x: isize, ...) {}
    |                              ^^^
@@ -50,7 +64,7 @@ LL | unsafe extern "C" fn f3_1(x: isize, ...) {}
    | ++++++
 
 error: functions with a C variable argument list must be unsafe
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:24:20
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:27:20
    |
 LL | extern "C" fn f3_2(...) {}
    |                    ^^^
@@ -61,25 +75,25 @@ LL | unsafe extern "C" fn f3_2(...) {}
    | ++++++
 
 error: `...` must be the last argument of a C-variadic function
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:27:20
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:30:20
    |
 LL | extern "C" fn f3_3(..., x: isize) {}
    |                    ^^^
 
 error: functions cannot be both `const` and C-variadic
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:30:1
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:33:1
    |
 LL | const unsafe extern "C" fn f4_1(x: isize, ...) {}
    | ^^^^^ `const` because of this             ^^^ C-variadic because of this
 
 error: functions cannot be both `const` and C-variadic
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:34:1
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:37:1
    |
 LL | const extern "C" fn f4_2(x: isize, ...) {}
    | ^^^^^ `const` because of this      ^^^ C-variadic because of this
 
 error: functions with a C variable argument list must be unsafe
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:34:36
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:37:36
    |
 LL | const extern "C" fn f4_2(x: isize, ...) {}
    |                                    ^^^
@@ -90,19 +104,19 @@ LL | const unsafe extern "C" fn f4_2(x: isize, ...) {}
    |       ++++++
 
 error: `...` must be the last argument of a C-variadic function
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:39:26
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:42:26
    |
 LL | const extern "C" fn f4_3(..., x: isize, ...) {}
    |                          ^^^
 
 error: functions cannot be both `const` and C-variadic
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:39:1
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:42:1
    |
 LL | const extern "C" fn f4_3(..., x: isize, ...) {}
    | ^^^^^ `const` because of this           ^^^ C-variadic because of this
 
 error: functions with a C variable argument list must be unsafe
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:39:41
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:42:41
    |
 LL | const extern "C" fn f4_3(..., x: isize, ...) {}
    |                                         ^^^
@@ -113,49 +127,49 @@ LL | const unsafe extern "C" fn f4_3(..., x: isize, ...) {}
    |       ++++++
 
 error: `...` must be the last argument of a C-variadic function
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:45:13
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:48:13
    |
 LL |     fn e_f2(..., x: isize);
    |             ^^^
 
 error: associated functions cannot have a C variable argument list
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:52:23
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:55:23
    |
 LL |     fn i_f1(x: isize, ...) {}
    |                       ^^^
 
 error: associated functions cannot have a C variable argument list
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:54:13
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:57:13
    |
 LL |     fn i_f2(...) {}
    |             ^^^
 
 error: `...` must be the last argument of a C-variadic function
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:56:13
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:59:13
    |
 LL |     fn i_f3(..., x: isize, ...) {}
    |             ^^^
 
 error: associated functions cannot have a C variable argument list
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:56:28
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:59:28
    |
 LL |     fn i_f3(..., x: isize, ...) {}
    |                            ^^^
 
 error: `...` must be the last argument of a C-variadic function
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:59:13
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:62:13
    |
 LL |     fn i_f4(..., x: isize, ...) {}
    |             ^^^
 
 error: associated functions cannot have a C variable argument list
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:59:28
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:62:28
    |
 LL |     fn i_f4(..., x: isize, ...) {}
    |                            ^^^
 
 error: functions cannot be both `const` and C-variadic
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:62:5
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:65:5
    |
 LL |     const fn i_f5(x: isize, ...) {}
    |     ^^^^^                   ^^^ C-variadic because of this
@@ -163,49 +177,49 @@ LL |     const fn i_f5(x: isize, ...) {}
    |     `const` because of this
 
 error: associated functions cannot have a C variable argument list
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:62:29
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:65:29
    |
 LL |     const fn i_f5(x: isize, ...) {}
    |                             ^^^
 
 error: associated functions cannot have a C variable argument list
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:69:23
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:72:23
    |
 LL |     fn t_f1(x: isize, ...) {}
    |                       ^^^
 
 error: associated functions cannot have a C variable argument list
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:71:23
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:74:23
    |
 LL |     fn t_f2(x: isize, ...);
    |                       ^^^
 
 error: associated functions cannot have a C variable argument list
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:73:13
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:76:13
    |
 LL |     fn t_f3(...) {}
    |             ^^^
 
 error: associated functions cannot have a C variable argument list
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:75:13
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:78:13
    |
 LL |     fn t_f4(...);
    |             ^^^
 
 error: `...` must be the last argument of a C-variadic function
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:77:13
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:80:13
    |
 LL |     fn t_f5(..., x: isize) {}
    |             ^^^
 
 error: `...` must be the last argument of a C-variadic function
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:79:13
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:82:13
    |
 LL |     fn t_f6(..., x: isize);
    |             ^^^
 
 error[E0493]: destructor of `VaListImpl<'_>` cannot be evaluated at compile-time
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:30:43
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:33:43
    |
 LL | const unsafe extern "C" fn f4_1(x: isize, ...) {}
    |                                           ^^^   - value is dropped here
@@ -213,7 +227,7 @@ LL | const unsafe extern "C" fn f4_1(x: isize, ...) {}
    |                                           the destructor for this type cannot be evaluated in constant functions
 
 error[E0493]: destructor of `VaListImpl<'_>` cannot be evaluated at compile-time
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:34:36
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:37:36
    |
 LL | const extern "C" fn f4_2(x: isize, ...) {}
    |                                    ^^^   - value is dropped here
@@ -221,13 +235,13 @@ LL | const extern "C" fn f4_2(x: isize, ...) {}
    |                                    the destructor for this type cannot be evaluated in constant functions
 
 error[E0493]: destructor of `VaListImpl<'_>` cannot be evaluated at compile-time
-  --> $DIR/variadic-ffi-semantic-restrictions.rs:62:29
+  --> $DIR/variadic-ffi-semantic-restrictions.rs:65:29
    |
 LL |     const fn i_f5(x: isize, ...) {}
    |                             ^^^   - value is dropped here
    |                             |
    |                             the destructor for this type cannot be evaluated in constant functions
 
-error: aborting due to 32 previous errors
+error: aborting due to 33 previous errors
 
 For more information about this error, try `rustc --explain E0493`.

From cbacd00f106778830803ad2e2364518f06ff9078 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sat, 7 Jun 2025 22:56:22 +0200
Subject: [PATCH 0733/1889] allow `#[rustc_align_static(N)]` on `static`s

We need a different attribute than `rustc_align` because unstable attributes are
tied to their feature (we can't have two unstable features use the same
unstable attribute). Otherwise this uses all of the same infrastructure
as `#[rustc_align]`.
---
 .../src/attributes/codegen_attrs.rs           |  1 +
 .../rustc_attr_parsing/src/attributes/repr.rs | 27 +++++++++++
 compiler/rustc_attr_parsing/src/context.rs    |  3 +-
 compiler/rustc_codegen_gcc/src/consts.rs      |  2 +
 compiler/rustc_codegen_llvm/src/consts.rs     |  2 +
 .../rustc_const_eval/src/interpret/memory.rs  |  1 +
 .../rustc_const_eval/src/interpret/util.rs    | 11 ++++-
 compiler/rustc_feature/src/builtin_attrs.rs   |  1 +
 compiler/rustc_feature/src/unstable.rs        |  2 +
 .../rustc_middle/src/mir/interpret/mod.rs     | 11 ++++-
 compiler/rustc_passes/messages.ftl            |  4 ++
 compiler/rustc_passes/src/check_attr.rs       |  8 +++-
 compiler/rustc_passes/src/errors.rs           |  9 ++++
 compiler/rustc_span/src/symbol.rs             |  2 +
 src/tools/miri/tests/pass/static_align.rs     | 14 ++++++
 tests/codegen-llvm/align-static.rs            | 31 +++++++++++++
 tests/ui/attributes/malformed-static-align.rs | 17 +++++++
 .../attributes/malformed-static-align.stderr  | 45 +++++++++++++++++++
 .../feature-gate-static_align.rs              | 11 +++++
 .../feature-gate-static_align.stderr          | 23 ++++++++++
 tests/ui/static/static-align.rs               | 26 +++++++++++
 21 files changed, 246 insertions(+), 5 deletions(-)
 create mode 100644 src/tools/miri/tests/pass/static_align.rs
 create mode 100644 tests/codegen-llvm/align-static.rs
 create mode 100644 tests/ui/attributes/malformed-static-align.rs
 create mode 100644 tests/ui/attributes/malformed-static-align.stderr
 create mode 100644 tests/ui/feature-gates/feature-gate-static_align.rs
 create mode 100644 tests/ui/feature-gates/feature-gate-static_align.stderr
 create mode 100644 tests/ui/static/static-align.rs

diff --git a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
index ffdacff71521e..d5d51f2e79ab8 100644
--- a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
@@ -218,6 +218,7 @@ impl<S: Stage> AttributeParser<S> for NakedParser {
             sym::rustc_std_internal_symbol,
             // FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
             sym::rustc_align,
+            sym::rustc_align_static,
             // obviously compatible with self
             sym::naked,
             // documentation
diff --git a/compiler/rustc_attr_parsing/src/attributes/repr.rs b/compiler/rustc_attr_parsing/src/attributes/repr.rs
index 23aabd1559762..0330e2515c7df 100644
--- a/compiler/rustc_attr_parsing/src/attributes/repr.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/repr.rs
@@ -331,3 +331,30 @@ impl<S: Stage> AttributeParser<S> for AlignParser {
         Some(AttributeKind::Align { align, span })
     }
 }
+
+#[derive(Default)]
+pub(crate) struct AlignStaticParser(AlignParser);
+
+impl AlignStaticParser {
+    const PATH: &'static [Symbol] = &[sym::rustc_align_static];
+    const TEMPLATE: AttributeTemplate = AlignParser::TEMPLATE;
+
+    fn parse<'c, S: Stage>(
+        &mut self,
+        cx: &'c mut AcceptContext<'_, '_, S>,
+        args: &'c ArgParser<'_>,
+    ) {
+        self.0.parse(cx, args)
+    }
+}
+
+impl<S: Stage> AttributeParser<S> for AlignStaticParser {
+    const ATTRIBUTES: AcceptMapping<Self, S> = &[(Self::PATH, Self::TEMPLATE, Self::parse)];
+    const ALLOWED_TARGETS: AllowedTargets =
+        AllowedTargets::AllowList(&[Allow(Target::Static), Allow(Target::ForeignStatic)]);
+
+    fn finalize(self, _cx: &FinalizeContext<'_, '_, S>) -> Option<AttributeKind> {
+        let (align, span) = self.0.0?;
+        Some(AttributeKind::Align { align, span })
+    }
+}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index 7f5b810f244f1..1fb0660f53494 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -47,7 +47,7 @@ use crate::attributes::proc_macro_attrs::{
     ProcMacroAttributeParser, ProcMacroDeriveParser, ProcMacroParser, RustcBuiltinMacroParser,
 };
 use crate::attributes::prototype::CustomMirParser;
-use crate::attributes::repr::{AlignParser, ReprParser};
+use crate::attributes::repr::{AlignParser, AlignStaticParser, ReprParser};
 use crate::attributes::rustc_internal::{
     RustcLayoutScalarValidRangeEnd, RustcLayoutScalarValidRangeStart,
     RustcObjectLifetimeDefaultParser,
@@ -149,6 +149,7 @@ attribute_parsers!(
     pub(crate) static ATTRIBUTE_PARSERS = [
         // tidy-alphabetical-start
         AlignParser,
+        AlignStaticParser,
         BodyStabilityParser,
         ConfusablesParser,
         ConstStabilityParser,
diff --git a/compiler/rustc_codegen_gcc/src/consts.rs b/compiler/rustc_codegen_gcc/src/consts.rs
index 619277eba8b83..7fe8fc122b3cc 100644
--- a/compiler/rustc_codegen_gcc/src/consts.rs
+++ b/compiler/rustc_codegen_gcc/src/consts.rs
@@ -81,6 +81,8 @@ impl<'gcc, 'tcx> StaticCodegenMethods for CodegenCx<'gcc, 'tcx> {
         if global.to_rvalue().get_type() != val_llty {
             global.to_rvalue().set_type(val_llty);
         }
+
+        // NOTE: Alignment from attributes has already been applied to the allocation.
         set_global_alignment(self, global, alloc.align);
 
         global.global_set_initializer_rvalue(value);
diff --git a/compiler/rustc_codegen_llvm/src/consts.rs b/compiler/rustc_codegen_llvm/src/consts.rs
index 9ec7b0f80aee7..dc9bb743560dd 100644
--- a/compiler/rustc_codegen_llvm/src/consts.rs
+++ b/compiler/rustc_codegen_llvm/src/consts.rs
@@ -452,6 +452,8 @@ impl<'ll> CodegenCx<'ll, '_> {
             self.statics_to_rauw.borrow_mut().push((g, new_g));
             new_g
         };
+
+        // NOTE: Alignment from attributes has already been applied to the allocation.
         set_global_alignment(self, g, alloc.align);
         llvm::set_initializer(g, v);
 
diff --git a/compiler/rustc_const_eval/src/interpret/memory.rs b/compiler/rustc_const_eval/src/interpret/memory.rs
index 2c1e5087e1c6b..67e1f6b2fbd2b 100644
--- a/compiler/rustc_const_eval/src/interpret/memory.rs
+++ b/compiler/rustc_const_eval/src/interpret/memory.rs
@@ -953,6 +953,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
 
         // # Global allocations
         if let Some(global_alloc) = self.tcx.try_get_global_alloc(id) {
+            // NOTE: `static` alignment from attributes has already been applied to the allocation.
             let (size, align) = global_alloc.size_and_align(*self.tcx, self.typing_env);
             let mutbl = global_alloc.mutability(*self.tcx, self.typing_env);
             let kind = match global_alloc {
diff --git a/compiler/rustc_const_eval/src/interpret/util.rs b/compiler/rustc_const_eval/src/interpret/util.rs
index 72bee34540656..f667823723c0a 100644
--- a/compiler/rustc_const_eval/src/interpret/util.rs
+++ b/compiler/rustc_const_eval/src/interpret/util.rs
@@ -1,6 +1,6 @@
 use rustc_hir::def_id::LocalDefId;
 use rustc_middle::mir;
-use rustc_middle::mir::interpret::{AllocInit, Allocation, InterpResult, Pointer};
+use rustc_middle::mir::interpret::{AllocInit, Allocation, GlobalAlloc, InterpResult, Pointer};
 use rustc_middle::ty::layout::TyAndLayout;
 use rustc_middle::ty::{TyCtxt, TypeVisitable, TypeVisitableExt};
 use tracing::debug;
@@ -38,7 +38,14 @@ pub(crate) fn create_static_alloc<'tcx>(
     static_def_id: LocalDefId,
     layout: TyAndLayout<'tcx>,
 ) -> InterpResult<'tcx, MPlaceTy<'tcx>> {
-    let alloc = Allocation::try_new(layout.size, layout.align.abi, AllocInit::Uninit, ())?;
+    // Inherit size and align from the `GlobalAlloc::Static` so we can avoid duplicating
+    // the alignment attribute logic.
+    let (size, align) =
+        GlobalAlloc::Static(static_def_id.into()).size_and_align(*ecx.tcx, ecx.typing_env);
+    assert_eq!(size, layout.size);
+    assert!(align >= layout.align.abi);
+
+    let alloc = Allocation::try_new(size, align, AllocInit::Uninit, ())?;
     let alloc_id = ecx.tcx.reserve_and_set_static_alloc(static_def_id.into());
     assert_eq!(ecx.machine.static_root_ids, None);
     ecx.machine.static_root_ids = Some((alloc_id, static_def_id));
diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs
index e81003b18972a..129ab7eccb577 100644
--- a/compiler/rustc_feature/src/builtin_attrs.rs
+++ b/compiler/rustc_feature/src/builtin_attrs.rs
@@ -621,6 +621,7 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
     ),
     // FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
     gated!(rustc_align, Normal, template!(List: &["alignment"]), DuplicatesOk, EncodeCrossCrate::No, fn_align, experimental!(rustc_align)),
+    gated!(rustc_align_static, Normal, template!(List: &["alignment"]), DuplicatesOk, EncodeCrossCrate::No, static_align, experimental!(rustc_align_static)),
     ungated!(
         unsafe(Edition2024) export_name, Normal,
         template!(NameValueStr: "name", "https://doc.rust-lang.org/reference/abi.html#the-export_name-attribute"),
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 4f35bf63a1a43..93e5588146e14 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -632,6 +632,8 @@ declare_features! (
     (unstable, simd_ffi, "1.0.0", Some(27731)),
     /// Allows specialization of implementations (RFC 1210).
     (incomplete, specialization, "1.7.0", Some(31844)),
+    /// Allows using `#[rustc_align_static(...)]` on static items.
+    (unstable, static_align, "CURRENT_RUSTC_VERSION", Some(146177)),
     /// Allows attributes on expressions and non-item statements.
     (unstable, stmt_expr_attributes, "1.6.0", Some(15701)),
     /// Allows lints part of the strict provenance effort.
diff --git a/compiler/rustc_middle/src/mir/interpret/mod.rs b/compiler/rustc_middle/src/mir/interpret/mod.rs
index bed99a4ff2ab2..9762e0f21da9f 100644
--- a/compiler/rustc_middle/src/mir/interpret/mod.rs
+++ b/compiler/rustc_middle/src/mir/interpret/mod.rs
@@ -386,7 +386,16 @@ impl<'tcx> GlobalAlloc<'tcx> {
                         .expect("statics should not have generic parameters");
                     let layout = tcx.layout_of(typing_env.as_query_input(ty)).unwrap();
                     assert!(layout.is_sized());
-                    (layout.size, layout.align.abi)
+
+                    // Take over-alignment from attributes into account.
+                    let align = match tcx.codegen_fn_attrs(def_id).alignment {
+                        Some(align_from_attribute) => {
+                            Ord::max(align_from_attribute, layout.align.abi)
+                        }
+                        None => layout.align.abi,
+                    };
+
+                    (layout.size, align)
                 }
             }
             GlobalAlloc::Memory(alloc) => {
diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index afd08319738df..ab7885905a6e7 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -501,6 +501,10 @@ passes_repr_align_should_be_align =
     `#[repr(align(...))]` is not supported on {$item}
     .help = use `#[rustc_align(...)]` instead
 
+passes_repr_align_should_be_align_static =
+    `#[repr(align(...))]` is not supported on {$item}
+    .help = use `#[rustc_align_static(...)]` instead
+
 passes_repr_conflicting =
     conflicting representation hints
 
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 2cd4830b5d935..10585e7b9208d 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -1602,12 +1602,18 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 ReprAttr::ReprAlign(align) => {
                     match target {
                         Target::Struct | Target::Union | Target::Enum => {}
-                        Target::Fn | Target::Method(_) => {
+                        Target::Fn | Target::Method(_) if self.tcx.features().fn_align() => {
                             self.dcx().emit_err(errors::ReprAlignShouldBeAlign {
                                 span: *repr_span,
                                 item: target.plural_name(),
                             });
                         }
+                        Target::Static if self.tcx.features().static_align() => {
+                            self.dcx().emit_err(errors::ReprAlignShouldBeAlignStatic {
+                                span: *repr_span,
+                                item: target.plural_name(),
+                            });
+                        }
                         _ => {
                             self.dcx().emit_err(errors::AttrApplication::StructEnumUnion {
                                 hint_span: *repr_span,
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index 23dcabef1a177..2da4b6f52cf2c 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -1609,6 +1609,15 @@ pub(crate) struct ReprAlignShouldBeAlign {
     pub item: &'static str,
 }
 
+#[derive(Diagnostic)]
+#[diag(passes_repr_align_should_be_align_static)]
+pub(crate) struct ReprAlignShouldBeAlignStatic {
+    #[primary_span]
+    #[help]
+    pub span: Span,
+    pub item: &'static str,
+}
+
 #[derive(Diagnostic)]
 #[diag(passes_custom_mir_phase_requires_dialect)]
 pub(crate) struct CustomMirPhaseRequiresDialect {
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index e5108d8b7e921..ac933b2060863 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1846,6 +1846,7 @@ symbols! {
         rustc_abi,
         // FIXME(#82232, #143834): temporary name to mitigate `#[align]` nameres ambiguity
         rustc_align,
+        rustc_align_static,
         rustc_allocator,
         rustc_allocator_zeroed,
         rustc_allocator_zeroed_variant,
@@ -2097,6 +2098,7 @@ symbols! {
         staged_api,
         start,
         state,
+        static_align,
         static_in_const,
         static_nobundle,
         static_recursion,
diff --git a/src/tools/miri/tests/pass/static_align.rs b/src/tools/miri/tests/pass/static_align.rs
new file mode 100644
index 0000000000000..f292f028568b6
--- /dev/null
+++ b/src/tools/miri/tests/pass/static_align.rs
@@ -0,0 +1,14 @@
+#![feature(static_align)]
+
+// When a static uses `align(N)`, its address should be a multiple of `N`.
+
+#[rustc_align_static(256)]
+static FOO: u64 = 0;
+
+#[rustc_align_static(512)]
+static BAR: u64 = 0;
+
+fn main() {
+    assert!(core::ptr::from_ref(&FOO).addr().is_multiple_of(256));
+    assert!(core::ptr::from_ref(&BAR).addr().is_multiple_of(512));
+}
diff --git a/tests/codegen-llvm/align-static.rs b/tests/codegen-llvm/align-static.rs
new file mode 100644
index 0000000000000..53db998919af3
--- /dev/null
+++ b/tests/codegen-llvm/align-static.rs
@@ -0,0 +1,31 @@
+//@ compile-flags: -C no-prepopulate-passes -Z mir-opt-level=0
+
+#![crate_type = "lib"]
+#![feature(static_align)]
+
+// CHECK: @STATIC_ALIGN =
+// CHECK-SAME: align 16
+#[no_mangle]
+#[rustc_align_static(16)]
+pub static STATIC_ALIGN: u64 = 0;
+
+// CHECK: @ALIGN_SPECIFIED_TWICE_1 =
+// CHECK-SAME: align 64
+#[no_mangle]
+#[rustc_align_static(32)]
+#[rustc_align_static(64)]
+pub static ALIGN_SPECIFIED_TWICE_1: u64 = 0;
+
+// CHECK: @ALIGN_SPECIFIED_TWICE_2 =
+// CHECK-SAME: align 128
+#[no_mangle]
+#[rustc_align_static(128)]
+#[rustc_align_static(32)]
+pub static ALIGN_SPECIFIED_TWICE_2: u64 = 0;
+
+// CHECK: @ALIGN_SPECIFIED_TWICE_3 =
+// CHECK-SAME: align 256
+#[no_mangle]
+#[rustc_align_static(32)]
+#[rustc_align_static(256)]
+pub static ALIGN_SPECIFIED_TWICE_3: u64 = 0;
diff --git a/tests/ui/attributes/malformed-static-align.rs b/tests/ui/attributes/malformed-static-align.rs
new file mode 100644
index 0000000000000..305d8acf8af24
--- /dev/null
+++ b/tests/ui/attributes/malformed-static-align.rs
@@ -0,0 +1,17 @@
+#![feature(static_align)]
+#![crate_type = "lib"]
+
+#[rustc_align_static = 16] //~ ERROR malformed `rustc_align_static` attribute input
+static S1: () = ();
+
+#[rustc_align_static("hello")] //~ ERROR invalid alignment value: not an unsuffixed integer
+static S2: () = ();
+
+#[rustc_align_static(0)] //~ ERROR invalid alignment value: not a power of two
+static S3: () = ();
+
+#[repr(align(16))] //~ ERROR `#[repr(align(...))]` is not supported on static
+static S4: () = ();
+
+#[rustc_align_static(16)] //~ ERROR `#[rustc_align_static]` attribute cannot be used on structs
+struct Struct1;
diff --git a/tests/ui/attributes/malformed-static-align.stderr b/tests/ui/attributes/malformed-static-align.stderr
new file mode 100644
index 0000000000000..35f654d3990f2
--- /dev/null
+++ b/tests/ui/attributes/malformed-static-align.stderr
@@ -0,0 +1,45 @@
+error[E0539]: malformed `rustc_align_static` attribute input
+  --> $DIR/malformed-static-align.rs:4:1
+   |
+LL | #[rustc_align_static = 16]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   | |
+   | expected this to be a list
+   | help: must be of the form: `#[rustc_align_static(<alignment in bytes>)]`
+
+error[E0589]: invalid alignment value: not an unsuffixed integer
+  --> $DIR/malformed-static-align.rs:7:22
+   |
+LL | #[rustc_align_static("hello")]
+   |                      ^^^^^^^
+
+error[E0589]: invalid alignment value: not a power of two
+  --> $DIR/malformed-static-align.rs:10:22
+   |
+LL | #[rustc_align_static(0)]
+   |                      ^
+
+error: `#[rustc_align_static]` attribute cannot be used on structs
+  --> $DIR/malformed-static-align.rs:16:1
+   |
+LL | #[rustc_align_static(16)]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: `#[rustc_align_static]` can be applied to statics and foreign statics
+
+error: `#[repr(align(...))]` is not supported on statics
+  --> $DIR/malformed-static-align.rs:13:8
+   |
+LL | #[repr(align(16))]
+   |        ^^^^^^^^^
+   |
+help: use `#[rustc_align_static(...)]` instead
+  --> $DIR/malformed-static-align.rs:13:8
+   |
+LL | #[repr(align(16))]
+   |        ^^^^^^^^^
+
+error: aborting due to 5 previous errors
+
+Some errors have detailed explanations: E0539, E0589.
+For more information about an error, try `rustc --explain E0539`.
diff --git a/tests/ui/feature-gates/feature-gate-static_align.rs b/tests/ui/feature-gates/feature-gate-static_align.rs
new file mode 100644
index 0000000000000..4d8f0e18d94cb
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-static_align.rs
@@ -0,0 +1,11 @@
+#![crate_type = "lib"]
+
+#[rustc_align_static(16)]
+//~^ ERROR the `#[rustc_align_static]` attribute is an experimental feature
+static REQUIRES_ALIGNMENT: u64 = 0;
+
+extern "C" {
+    #[rustc_align_static(16)]
+    //~^ ERROR the `#[rustc_align_static]` attribute is an experimental feature
+    static FOREIGN_STATIC: u32;
+}
diff --git a/tests/ui/feature-gates/feature-gate-static_align.stderr b/tests/ui/feature-gates/feature-gate-static_align.stderr
new file mode 100644
index 0000000000000..b45fcdefc9cdf
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-static_align.stderr
@@ -0,0 +1,23 @@
+error[E0658]: the `#[rustc_align_static]` attribute is an experimental feature
+  --> $DIR/feature-gate-static_align.rs:3:1
+   |
+LL | #[rustc_align_static(16)]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #146177 <https://github.com/rust-lang/rust/issues/146177> for more information
+   = help: add `#![feature(static_align)]` 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 `#[rustc_align_static]` attribute is an experimental feature
+  --> $DIR/feature-gate-static_align.rs:8:5
+   |
+LL |     #[rustc_align_static(16)]
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #146177 <https://github.com/rust-lang/rust/issues/146177> for more information
+   = help: add `#![feature(static_align)]` 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`.
diff --git a/tests/ui/static/static-align.rs b/tests/ui/static/static-align.rs
new file mode 100644
index 0000000000000..93241db09f949
--- /dev/null
+++ b/tests/ui/static/static-align.rs
@@ -0,0 +1,26 @@
+//@ run-pass
+#![feature(static_align)]
+
+#[rustc_align_static(64)]
+static A: u8 = 0;
+
+#[rustc_align_static(64)]
+static B: u8 = 0;
+
+#[rustc_align_static(128)]
+#[no_mangle]
+static EXPORTED: u64 = 0;
+
+unsafe extern "C" {
+    #[rustc_align_static(128)]
+    #[link_name = "EXPORTED"]
+    static C: u64;
+}
+
+fn main() {
+    assert!(core::ptr::from_ref(&A).addr().is_multiple_of(64));
+    assert!(core::ptr::from_ref(&B).addr().is_multiple_of(64));
+
+    assert!(core::ptr::from_ref(&EXPORTED).addr().is_multiple_of(128));
+    unsafe { assert!(core::ptr::from_ref(&C).addr().is_multiple_of(128)) };
+}

From ce2f518b5393c48370f67725a4e15573b49f2c7d Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Tue, 9 Sep 2025 21:57:19 +0300
Subject: [PATCH 0734/1889] Upgrade rustc crates and handle changes to
 canonicalization

They have to do with diagnostics, we could probably not support them but we will also someday want good diagnostics.

The code is mostly copied from rustc.
---
 src/tools/rust-analyzer/Cargo.lock            |  45 +++----
 src/tools/rust-analyzer/Cargo.toml            |  16 +--
 .../infer/canonical/canonicalizer.rs          |  41 +++---
 .../src/next_solver/infer/canonical/mod.rs    |  59 ++++-----
 .../hir-ty/src/next_solver/infer/context.rs   |   8 ++
 .../hir-ty/src/next_solver/infer/mod.rs       |   8 ++
 .../next_solver/infer/snapshot/undo_log.rs    |   4 +-
 .../src/next_solver/infer/type_variable.rs    | 117 ++++++++++++++++++
 .../hir-ty/src/next_solver/infer/unify_key.rs |   3 +
 .../crates/hir-ty/src/next_solver/mapping.rs  |  42 +++----
 .../crates/hir-ty/src/next_solver/solver.rs   |  12 +-
 .../crates/hir-ty/src/next_solver/util.rs     |  17 ++-
 12 files changed, 256 insertions(+), 116 deletions(-)

diff --git a/src/tools/rust-analyzer/Cargo.lock b/src/tools/rust-analyzer/Cargo.lock
index 344e6d101fe35..b70b89ea543d8 100644
--- a/src/tools/rust-analyzer/Cargo.lock
+++ b/src/tools/rust-analyzer/Cargo.lock
@@ -1863,9 +1863,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_abi"
-version = "0.126.0"
+version = "0.128.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c6789d94fb3e6e30d62f55e99a321ba63484a8bb3b4ead338687c9ddc282d28"
+checksum = "8da95e732b424802b1f043ab4007c78a0fc515ab249587abbea4634bf5fdce9a"
 dependencies = [
  "bitflags 2.9.1",
  "ra-ap-rustc_hashes",
@@ -1875,24 +1875,24 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_ast_ir"
-version = "0.126.0"
+version = "0.128.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aaab80bda0f05e9842e3afb7779b0bad0a4b54e0f7ba6deb5705dcf86482811d"
+checksum = "3838d9d7a3a5cdc511cfb6ad78740ce532f75a2366d3fc3b9853ea1b5c872779"
 
 [[package]]
 name = "ra-ap-rustc_hashes"
-version = "0.126.0"
+version = "0.128.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64bd405e538102b5f699241794b2eefee39d5414c0e4bc72435e91430c51f905"
+checksum = "bdc8995d268d3bb4ece910f575ea5a063d6003e193ec155d15703b65882d53fb"
 dependencies = [
  "rustc-stable-hash",
 ]
 
 [[package]]
 name = "ra-ap-rustc_index"
-version = "0.126.0"
+version = "0.128.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "521621e271aa03b8433dad5981838278d6cfd7d2d8c9f4eb6d427f1d671f90fc"
+checksum = "ed0ccdf6e5627c6c3e54e571e52ce0bc8b94d5f0b94b7460269ca68a4706be69"
 dependencies = [
  "ra-ap-rustc_index_macros",
  "smallvec",
@@ -1900,9 +1900,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_index_macros"
-version = "0.126.0"
+version = "0.128.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "245e30f2e1fef258913cc548b36f575549c8af31cbc4649929d21deda96ceeb7"
+checksum = "bd28f42362b5c9fb9b8766c3189df02a402b13363600c6885e11027889f03ee6"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1911,9 +1911,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_lexer"
-version = "0.126.0"
+version = "0.128.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a82681f924500e888c860e60ed99e9bf702a219a69374f59116c4261525a2157"
+checksum = "f1c31a82f091b910a27ee53a86a9af28a2df10c3484e2f1bbfe70633aa84dee9"
 dependencies = [
  "memchr",
  "unicode-properties",
@@ -1922,9 +1922,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_next_trait_solver"
-version = "0.126.0"
+version = "0.128.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c9ce51f2431fbdc7fabd2d957522b6e27f41f68ec2af74b52a6f4116352ce1a"
+checksum = "f8cac6c2b5a8924209d4ca682cbc507252c58a664911e0ef463c112882ba6f72"
 dependencies = [
  "derive-where",
  "ra-ap-rustc_index",
@@ -1935,9 +1935,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_parse_format"
-version = "0.126.0"
+version = "0.128.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "adc85ef3fdb6c084bde84857d8948dc66b752129dc8417a8614ce490e99a143f"
+checksum = "a085a1cf902dcca8abbc537faaef154bbccbbb51850f779ce5484ae3782b5d8f"
 dependencies = [
  "ra-ap-rustc_lexer",
  "rustc-literal-escaper 0.0.5",
@@ -1945,9 +1945,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_pattern_analysis"
-version = "0.126.0"
+version = "0.128.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3cd81eccf33d9528905d4e5abaa254b3129a6405d6c5f123fed9b73a3d217f35"
+checksum = "8ba32e3985367bc34856b41c7604133649d4a367eb5d7bdf50623025731459d8"
 dependencies = [
  "ra-ap-rustc_index",
  "rustc-hash 2.1.1",
@@ -1958,10 +1958,11 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_type_ir"
-version = "0.126.0"
+version = "0.128.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11cb0da02853698d9c89e1d1c01657b9969752befd56365e8899d4310e52b373"
+checksum = "9c9911d72f75d85d21fe88374d7bcec94f2200feffb7234108a24cc3da7c3591"
 dependencies = [
+ "arrayvec",
  "bitflags 2.9.1",
  "derive-where",
  "ena",
@@ -1977,9 +1978,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_type_ir_macros"
-version = "0.126.0"
+version = "0.128.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffc93adeb52c483ede13bee6680466458218243ab479c04fb71bb53925a6e0ff"
+checksum = "22f539b87991683ce17cc52e62600fdf2b4a8af43952db30387edc1a576d3b43"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/src/tools/rust-analyzer/Cargo.toml b/src/tools/rust-analyzer/Cargo.toml
index f325027ee5871..c5ffad544a6b3 100644
--- a/src/tools/rust-analyzer/Cargo.toml
+++ b/src/tools/rust-analyzer/Cargo.toml
@@ -89,14 +89,14 @@ vfs-notify = { path = "./crates/vfs-notify", version = "0.0.0" }
 vfs = { path = "./crates/vfs", version = "0.0.0" }
 edition = { path = "./crates/edition", version = "0.0.0" }
 
-ra-ap-rustc_lexer = { version = "0.126", default-features = false }
-ra-ap-rustc_parse_format = { version = "0.126", default-features = false }
-ra-ap-rustc_index = { version = "0.126", default-features = false }
-ra-ap-rustc_abi = { version = "0.126", default-features = false }
-ra-ap-rustc_pattern_analysis = { version = "0.126", default-features = false }
-ra-ap-rustc_ast_ir = { version = "0.126", default-features = false }
-ra-ap-rustc_type_ir = { version = "0.126", default-features = false }
-ra-ap-rustc_next_trait_solver = { version = "0.126", default-features = false }
+ra-ap-rustc_lexer = { version = "0.128", default-features = false }
+ra-ap-rustc_parse_format = { version = "0.128", default-features = false }
+ra-ap-rustc_index = { version = "0.128", default-features = false }
+ra-ap-rustc_abi = { version = "0.128", default-features = false }
+ra-ap-rustc_pattern_analysis = { version = "0.128", default-features = false }
+ra-ap-rustc_ast_ir = { version = "0.128", default-features = false }
+ra-ap-rustc_type_ir = { version = "0.128", default-features = false }
+ra-ap-rustc_next_trait_solver = { version = "0.128", default-features = false }
 
 # local crates that aren't published to crates.io. These should not have versions.
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/canonicalizer.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/canonicalizer.rs
index 5d11525cd199f..ffb9c076fa061 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/canonicalizer.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/canonicalizer.rs
@@ -10,9 +10,8 @@ use rustc_index::Idx;
 use rustc_type_ir::InferTy::{self, FloatVar, IntVar, TyVar};
 use rustc_type_ir::inherent::{Const as _, IntoKind as _, Region as _, SliceLike, Ty as _};
 use rustc_type_ir::{
-    BoundVar, CanonicalQueryInput, CanonicalTyVarKind, DebruijnIndex, Flags, InferConst,
-    RegionKind, TypeFlags, TypeFoldable, TypeFolder, TypeSuperFoldable, TypeVisitableExt,
-    UniverseIndex,
+    BoundVar, CanonicalQueryInput, DebruijnIndex, Flags, InferConst, RegionKind, TyVid, TypeFlags,
+    TypeFoldable, TypeFolder, TypeSuperFoldable, TypeVisitableExt, UniverseIndex,
 };
 use smallvec::SmallVec;
 use tracing::debug;
@@ -316,6 +315,13 @@ struct Canonicalizer<'cx, 'db> {
     // Note that indices is only used once `var_values` is big enough to be
     // heap-allocated.
     indices: FxHashMap<GenericArg<'db>, BoundVar>,
+    /// Maps each `sub_unification_table_root_var` to the index of the first
+    /// variable which used it.
+    ///
+    /// This means in case two type variables have the same sub relations root,
+    /// we set the `sub_root` of the second variable to the position of the first.
+    /// Otherwise the `sub_root` of each type variable is just its own position.
+    sub_root_lookup_table: FxHashMap<TyVid, usize>,
     canonicalize_mode: &'cx dyn CanonicalizeMode,
     needs_canonical_flags: TypeFlags,
 
@@ -384,10 +390,9 @@ impl<'cx, 'db> TypeFolder<DbInterner<'db>> for Canonicalizer<'cx, 'db> {
                             // FIXME: perf problem described in #55921.
                             ui = UniverseIndex::ROOT;
                         }
-                        self.canonicalize_ty_var(
-                            CanonicalVarKind::Ty(CanonicalTyVarKind::General(ui)),
-                            t,
-                        )
+
+                        let sub_root = self.get_or_insert_sub_root(vid);
+                        self.canonicalize_ty_var(CanonicalVarKind::Ty { ui, sub_root }, t)
                     }
                 }
             }
@@ -395,17 +400,17 @@ impl<'cx, 'db> TypeFolder<DbInterner<'db>> for Canonicalizer<'cx, 'db> {
             TyKind::Infer(IntVar(vid)) => {
                 let nt = self.infcx.opportunistic_resolve_int_var(vid);
                 if nt != t {
-                    self.fold_ty(nt)
+                    return self.fold_ty(nt);
                 } else {
-                    self.canonicalize_ty_var(CanonicalVarKind::Ty(CanonicalTyVarKind::Int), t)
+                    self.canonicalize_ty_var(CanonicalVarKind::Int, t)
                 }
             }
             TyKind::Infer(FloatVar(vid)) => {
                 let nt = self.infcx.opportunistic_resolve_float_var(vid);
                 if nt != t {
-                    self.fold_ty(nt)
+                    return self.fold_ty(nt);
                 } else {
-                    self.canonicalize_ty_var(CanonicalVarKind::Ty(CanonicalTyVarKind::Float), t)
+                    self.canonicalize_ty_var(CanonicalVarKind::Float, t)
                 }
             }
 
@@ -579,6 +584,7 @@ impl<'cx, 'db> Canonicalizer<'cx, 'db> {
             variables: SmallVec::from_slice(base.variables.as_slice()),
             query_state,
             indices: FxHashMap::default(),
+            sub_root_lookup_table: Default::default(),
             binder_index: DebruijnIndex::ZERO,
         };
         if canonicalizer.query_state.var_values.spilled() {
@@ -673,6 +679,13 @@ impl<'cx, 'db> Canonicalizer<'cx, 'db> {
         }
     }
 
+    fn get_or_insert_sub_root(&mut self, vid: TyVid) -> BoundVar {
+        let root_vid = self.infcx.sub_unification_table_root_var(vid);
+        let idx =
+            *self.sub_root_lookup_table.entry(root_vid).or_insert_with(|| self.variables.len());
+        BoundVar::from(idx)
+    }
+
     /// Replaces the universe indexes used in `var_values` with their index in
     /// `query_state.universe_map`. This minimizes the maximum universe used in
     /// the canonicalized value.
@@ -692,9 +705,9 @@ impl<'cx, 'db> Canonicalizer<'cx, 'db> {
         self.variables
             .iter()
             .map(|v| match *v {
-                CanonicalVarKind::Ty(CanonicalTyVarKind::Int | CanonicalTyVarKind::Float) => *v,
-                CanonicalVarKind::Ty(CanonicalTyVarKind::General(u)) => {
-                    CanonicalVarKind::Ty(CanonicalTyVarKind::General(reverse_universe_map[&u]))
+                CanonicalVarKind::Int | CanonicalVarKind::Float => *v,
+                CanonicalVarKind::Ty { ui, sub_root } => {
+                    CanonicalVarKind::Ty { ui: reverse_universe_map[&ui], sub_root }
                 }
                 CanonicalVarKind::Region(u) => CanonicalVarKind::Region(reverse_universe_map[&u]),
                 CanonicalVarKind::Const(u) => CanonicalVarKind::Const(reverse_universe_map[&u]),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/mod.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/mod.rs
index ec41111ed8153..8db4320acc9c0 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/mod.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/mod.rs
@@ -32,9 +32,10 @@ use crate::next_solver::{
 };
 use instantiate::CanonicalExt;
 use rustc_index::IndexVec;
+use rustc_type_ir::inherent::IntoKind;
 use rustc_type_ir::{
-    AliasRelationDirection, AliasTyKind, CanonicalTyVarKind, CanonicalVarKind, InferTy,
-    TypeFoldable, UniverseIndex, Upcast, Variance,
+    AliasRelationDirection, AliasTyKind, CanonicalVarKind, InferTy, TypeFoldable, UniverseIndex,
+    Upcast, Variance,
     inherent::{SliceLike, Ty as _},
     relate::{
         Relate, TypeRelation, VarianceDiagInfo,
@@ -78,27 +79,15 @@ impl<'db> InferCtxt<'db> {
             .chain((1..=canonical.max_universe.as_u32()).map(|_| self.create_next_universe()))
             .collect();
 
-        let canonical_inference_vars =
-            self.instantiate_canonical_vars(canonical.variables, |ui| universes[ui]);
-        let result = canonical.instantiate(self.interner, &canonical_inference_vars);
-        (result, canonical_inference_vars)
-    }
-
-    /// Given the "infos" about the canonical variables from some
-    /// canonical, creates fresh variables with the same
-    /// characteristics (see `instantiate_canonical_var` for
-    /// details). You can then use `instantiate` to instantiate the
-    /// canonical variable with these inference variables.
-    fn instantiate_canonical_vars(
-        &self,
-        variables: CanonicalVars<'db>,
-        universe_map: impl Fn(UniverseIndex) -> UniverseIndex,
-    ) -> CanonicalVarValues<'db> {
-        CanonicalVarValues {
-            var_values: self.interner.mk_args_from_iter(
-                variables.iter().map(|info| self.instantiate_canonical_var(info, &universe_map)),
-            ),
-        }
+        let var_values = CanonicalVarValues::instantiate(
+            self.interner,
+            canonical.variables,
+            |var_values, info| {
+                self.instantiate_canonical_var(info, &var_values, |ui| universes[ui])
+            },
+        );
+        let result = canonical.instantiate(self.interner, &var_values);
+        (result, var_values)
     }
 
     /// Given the "info" about a canonical variable, creates a fresh
@@ -112,21 +101,27 @@ impl<'db> InferCtxt<'db> {
     pub fn instantiate_canonical_var(
         &self,
         cv_info: CanonicalVarKind<DbInterner<'db>>,
+        previous_var_values: &[GenericArg<'db>],
         universe_map: impl Fn(UniverseIndex) -> UniverseIndex,
     ) -> GenericArg<'db> {
         match cv_info {
-            CanonicalVarKind::Ty(ty_kind) => {
-                let ty = match ty_kind {
-                    CanonicalTyVarKind::General(ui) => {
-                        self.next_ty_var_in_universe(universe_map(ui))
+            CanonicalVarKind::Ty { ui, sub_root } => {
+                let vid = self.next_ty_var_id_in_universe(universe_map(ui));
+                // If this inference variable is related to an earlier variable
+                // via subtyping, we need to add that info to the inference context.
+                if let Some(prev) = previous_var_values.get(sub_root.as_usize()) {
+                    if let TyKind::Infer(InferTy::TyVar(sub_root)) = prev.expect_ty().kind() {
+                        self.sub_unify_ty_vids_raw(vid, sub_root);
+                    } else {
+                        unreachable!()
                     }
+                }
+                Ty::new_var(self.interner, vid).into()
+            }
 
-                    CanonicalTyVarKind::Int => self.next_int_var(),
+            CanonicalVarKind::Int => self.next_int_var().into(),
 
-                    CanonicalTyVarKind::Float => self.next_float_var(),
-                };
-                ty.into()
-            }
+            CanonicalVarKind::Float => self.next_float_var().into(),
 
             CanonicalVarKind::PlaceholderTy(PlaceholderTy { universe, bound }) => {
                 let universe_mapped = universe_map(universe);
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/context.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/context.rs
index 93fd6eeab34e4..45ce7e6f6cc75 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/context.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/context.rs
@@ -313,4 +313,12 @@ impl<'db> rustc_type_ir::InferCtxtLike for InferCtxt<'db> {
     fn reset_opaque_types(&self) {
         let _ = self.take_opaque_types();
     }
+
+    fn sub_unification_table_root_var(&self, var: rustc_type_ir::TyVid) -> rustc_type_ir::TyVid {
+        self.sub_unification_table_root_var(var)
+    }
+
+    fn sub_unify_ty_vids_raw(&self, a: rustc_type_ir::TyVid, b: rustc_type_ir::TyVid) {
+        self.sub_unify_ty_vids_raw(a, b);
+    }
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs
index 2630f2a8cc4e5..ce6c941287325 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs
@@ -1019,6 +1019,14 @@ impl<'db> InferCtxt<'db> {
             }
         }
     }
+
+    fn sub_unification_table_root_var(&self, var: rustc_type_ir::TyVid) -> rustc_type_ir::TyVid {
+        self.inner.borrow_mut().type_variables().sub_unification_table_root_var(var)
+    }
+
+    fn sub_unify_ty_vids_raw(&self, a: rustc_type_ir::TyVid, b: rustc_type_ir::TyVid) {
+        self.inner.borrow_mut().type_variables().sub_unify(a, b);
+    }
 }
 
 /// Helper for [InferCtxt::ty_or_const_infer_var_changed] (see comment on that), currently
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/snapshot/undo_log.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/snapshot/undo_log.rs
index 0fa6421f517de..28ae56f4ee70a 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/snapshot/undo_log.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/snapshot/undo_log.rs
@@ -25,7 +25,7 @@ pub struct Snapshot {
 pub(crate) enum UndoLog<'db> {
     DuplicateOpaqueType,
     OpaqueTypes(OpaqueTypeKey<'db>, Option<OpaqueHiddenType<'db>>),
-    TypeVariables(sv::UndoLog<ut::Delegate<type_variable::TyVidEqKey<'db>>>),
+    TypeVariables(type_variable::UndoLog<'db>),
     ConstUnificationTable(sv::UndoLog<ut::Delegate<ConstVidKey<'db>>>),
     IntUnificationTable(sv::UndoLog<ut::Delegate<IntVid>>),
     FloatUnificationTable(sv::UndoLog<ut::Delegate<FloatVid>>),
@@ -51,6 +51,8 @@ impl_from! {
     RegionConstraintCollector(region_constraints::UndoLog<'db>),
 
     TypeVariables(sv::UndoLog<ut::Delegate<type_variable::TyVidEqKey<'db>>>),
+    TypeVariables(sv::UndoLog<ut::Delegate<type_variable::TyVidSubKey>>),
+    TypeVariables(type_variable::UndoLog<'db>),
     IntUnificationTable(sv::UndoLog<ut::Delegate<IntVid>>),
     FloatUnificationTable(sv::UndoLog<ut::Delegate<FloatVid>>),
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/type_variable.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/type_variable.rs
index 5217308af473c..b640039af625b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/type_variable.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/type_variable.rs
@@ -17,12 +17,48 @@ use crate::next_solver::SolverDefId;
 use crate::next_solver::Ty;
 use crate::next_solver::infer::InferCtxtUndoLogs;
 
+/// Represents a single undo-able action that affects a type inference variable.
+#[derive(Clone)]
+pub(crate) enum UndoLog<'tcx> {
+    EqRelation(sv::UndoLog<ut::Delegate<TyVidEqKey<'tcx>>>),
+    SubRelation(sv::UndoLog<ut::Delegate<TyVidSubKey>>),
+}
+
+/// Convert from a specific kind of undo to the more general UndoLog
+impl<'db> From<sv::UndoLog<ut::Delegate<TyVidEqKey<'db>>>> for UndoLog<'db> {
+    fn from(l: sv::UndoLog<ut::Delegate<TyVidEqKey<'db>>>) -> Self {
+        UndoLog::EqRelation(l)
+    }
+}
+
+/// Convert from a specific kind of undo to the more general UndoLog
+impl<'db> From<sv::UndoLog<ut::Delegate<TyVidSubKey>>> for UndoLog<'db> {
+    fn from(l: sv::UndoLog<ut::Delegate<TyVidSubKey>>) -> Self {
+        UndoLog::SubRelation(l)
+    }
+}
+
 impl<'db> Rollback<sv::UndoLog<ut::Delegate<TyVidEqKey<'db>>>> for TypeVariableStorage<'db> {
     fn reverse(&mut self, undo: sv::UndoLog<ut::Delegate<TyVidEqKey<'db>>>) {
         self.eq_relations.reverse(undo)
     }
 }
 
+impl<'tcx> Rollback<sv::UndoLog<ut::Delegate<TyVidSubKey>>> for TypeVariableStorage<'tcx> {
+    fn reverse(&mut self, undo: sv::UndoLog<ut::Delegate<TyVidSubKey>>) {
+        self.sub_unification_table.reverse(undo)
+    }
+}
+
+impl<'tcx> Rollback<UndoLog<'tcx>> for TypeVariableStorage<'tcx> {
+    fn reverse(&mut self, undo: UndoLog<'tcx>) {
+        match undo {
+            UndoLog::EqRelation(undo) => self.eq_relations.reverse(undo),
+            UndoLog::SubRelation(undo) => self.sub_unification_table.reverse(undo),
+        }
+    }
+}
+
 #[derive(Clone, Default)]
 pub(crate) struct TypeVariableStorage<'db> {
     /// The origins of each type variable.
@@ -31,6 +67,25 @@ pub(crate) struct TypeVariableStorage<'db> {
     /// constraint `?X == ?Y`. This table also stores, for each key,
     /// the known value.
     eq_relations: ut::UnificationTableStorage<TyVidEqKey<'db>>,
+    /// Only used by `-Znext-solver` and for diagnostics. Tracks whether
+    /// type variables are related via subtyping at all, ignoring which of
+    /// the two is the subtype.
+    ///
+    /// When reporting ambiguity errors, we sometimes want to
+    /// treat all inference vars which are subtypes of each
+    /// others as if they are equal. For this case we compute
+    /// the transitive closure of our subtype obligations here.
+    ///
+    /// E.g. when encountering ambiguity errors, we want to suggest
+    /// specifying some method argument or to add a type annotation
+    /// to a local variable. Because subtyping cannot change the
+    /// shape of a type, it's fine if the cause of the ambiguity error
+    /// is only related to the suggested variable via subtyping.
+    ///
+    /// Even for something like `let x = returns_arg(); x.method();` the
+    /// type of `x` is only a supertype of the argument of `returns_arg`. We
+    /// still want to suggest specifying the type of the argument.
+    sub_unification_table: ut::UnificationTableStorage<TyVidSubKey>,
 }
 
 pub(crate) struct TypeVariableTable<'a, 'db> {
@@ -112,6 +167,17 @@ impl<'db> TypeVariableTable<'_, 'db> {
         debug_assert!(self.probe(a).is_unknown());
         debug_assert!(self.probe(b).is_unknown());
         self.eq_relations().union(a, b);
+        self.sub_unification_table().union(a, b);
+    }
+
+    /// Records that `a` and `b` are related via subtyping. We don't track
+    /// which of the two is the subtype.
+    ///
+    /// Precondition: neither `a` nor `b` are known.
+    pub(crate) fn sub_unify(&mut self, a: TyVid, b: TyVid) {
+        debug_assert!(self.probe(a).is_unknown());
+        debug_assert!(self.probe(b).is_unknown());
+        self.sub_unification_table().union(a, b);
     }
 
     /// Instantiates `vid` with the type `ty`.
@@ -141,6 +207,10 @@ impl<'db> TypeVariableTable<'_, 'db> {
     ///   for improving error messages.
     pub(crate) fn new_var(&mut self, universe: UniverseIndex, origin: TypeVariableOrigin) -> TyVid {
         let eq_key = self.eq_relations().new_key(TypeVariableValue::Unknown { universe });
+
+        let sub_key = self.sub_unification_table().new_key(());
+        debug_assert_eq!(eq_key.vid, sub_key.vid);
+
         let index = self.storage.values.push(TypeVariableData { origin });
         debug_assert_eq!(eq_key.vid, index);
 
@@ -163,6 +233,18 @@ impl<'db> TypeVariableTable<'_, 'db> {
         self.eq_relations().find(vid).vid
     }
 
+    /// Returns the "root" variable of `vid` in the `sub_unification_table`
+    /// equivalence table. All type variables that have been are related via
+    /// equality or subtyping will yield the same root variable (per the
+    /// union-find algorithm), so `sub_unification_table_root_var(a)
+    /// == sub_unification_table_root_var(b)` implies that:
+    /// ```text
+    /// exists X. (a <: X || X <: a) && (b <: X || X <: b)
+    /// ```
+    pub(crate) fn sub_unification_table_root_var(&mut self, vid: TyVid) -> TyVid {
+        self.sub_unification_table().find(vid).vid
+    }
+
     /// Retrieves the type to which `vid` has been instantiated, if
     /// any.
     pub(crate) fn probe(&mut self, vid: TyVid) -> TypeVariableValue<'db> {
@@ -180,6 +262,11 @@ impl<'db> TypeVariableTable<'_, 'db> {
         self.storage.eq_relations.with_log(self.undo_log)
     }
 
+    #[inline]
+    fn sub_unification_table(&mut self) -> super::UnificationTable<'_, 'db, TyVidSubKey> {
+        self.storage.sub_unification_table.with_log(self.undo_log)
+    }
+
     /// Returns indices of all variables that are not yet
     /// instantiated.
     pub(crate) fn unresolved_variables(&mut self) -> Vec<TyVid> {
@@ -228,6 +315,36 @@ impl<'db> ut::UnifyKey for TyVidEqKey<'db> {
     fn tag() -> &'static str {
         "TyVidEqKey"
     }
+    fn order_roots(a: Self, _: &Self::Value, b: Self, _: &Self::Value) -> Option<(Self, Self)> {
+        if a.vid.as_u32() < b.vid.as_u32() { Some((a, b)) } else { Some((b, a)) }
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub(crate) struct TyVidSubKey {
+    vid: TyVid,
+}
+
+impl From<TyVid> for TyVidSubKey {
+    #[inline] // make this function eligible for inlining - it is quite hot.
+    fn from(vid: TyVid) -> Self {
+        TyVidSubKey { vid }
+    }
+}
+
+impl ut::UnifyKey for TyVidSubKey {
+    type Value = ();
+    #[inline]
+    fn index(&self) -> u32 {
+        self.vid.as_u32()
+    }
+    #[inline]
+    fn from_index(i: u32) -> TyVidSubKey {
+        TyVidSubKey { vid: TyVid::from_u32(i) }
+    }
+    fn tag() -> &'static str {
+        "TyVidSubKey"
+    }
 }
 
 impl<'db> ut::UnifyValue for TypeVariableValue<'db> {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/unify_key.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/unify_key.rs
index b9afb45ba89da..dc913b262a7c2 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/unify_key.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/unify_key.rs
@@ -139,6 +139,9 @@ impl<'db> UnifyKey for ConstVidKey<'db> {
     fn tag() -> &'static str {
         "ConstVidKey"
     }
+    fn order_roots(a: Self, _: &Self::Value, b: Self, _: &Self::Value) -> Option<(Self, Self)> {
+        if a.vid.as_u32() < b.vid.as_u32() { Some((a, b)) } else { Some((b, a)) }
+    }
 }
 
 impl<'db> UnifyValue for ConstVariableValue<'db> {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
index f66b8dace30a6..11bc6e6abe94b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
@@ -734,15 +734,13 @@ impl<'db, T: HasInterner<Interner = Interner> + ChalkToNextSolver<'db, U>, U>
             interner,
             self.binders.iter(Interner).map(|k| match &k.kind {
                 chalk_ir::VariableKind::Ty(ty_variable_kind) => match ty_variable_kind {
-                    TyVariableKind::General => rustc_type_ir::CanonicalVarKind::Ty(
-                        rustc_type_ir::CanonicalTyVarKind::General(UniverseIndex::ROOT),
-                    ),
-                    TyVariableKind::Integer => {
-                        rustc_type_ir::CanonicalVarKind::Ty(rustc_type_ir::CanonicalTyVarKind::Int)
-                    }
-                    TyVariableKind::Float => rustc_type_ir::CanonicalVarKind::Ty(
-                        rustc_type_ir::CanonicalTyVarKind::Float,
-                    ),
+                    // FIXME(next-solver): the info is incorrect, but we have no way to store the information in Chalk.
+                    TyVariableKind::General => rustc_type_ir::CanonicalVarKind::Ty {
+                        ui: UniverseIndex::ROOT,
+                        sub_root: BoundVar::from_u32(0),
+                    },
+                    TyVariableKind::Integer => rustc_type_ir::CanonicalVarKind::Int,
+                    TyVariableKind::Float => rustc_type_ir::CanonicalVarKind::Float,
                 },
                 chalk_ir::VariableKind::Lifetime => {
                     rustc_type_ir::CanonicalVarKind::Region(UniverseIndex::ROOT)
@@ -767,24 +765,20 @@ impl<'db, T: NextSolverToChalk<'db, U>, U: HasInterner<Interner = Interner>>
         let binders = chalk_ir::CanonicalVarKinds::from_iter(
             Interner,
             self.variables.iter().map(|v| match v {
-                rustc_type_ir::CanonicalVarKind::Ty(
-                    rustc_type_ir::CanonicalTyVarKind::General(ui),
-                ) => chalk_ir::CanonicalVarKind::new(
-                    chalk_ir::VariableKind::Ty(TyVariableKind::General),
-                    chalk_ir::UniverseIndex { counter: ui.as_usize() },
-                ),
-                rustc_type_ir::CanonicalVarKind::Ty(rustc_type_ir::CanonicalTyVarKind::Int) => {
+                rustc_type_ir::CanonicalVarKind::Ty { ui, sub_root: _ } => {
                     chalk_ir::CanonicalVarKind::new(
-                        chalk_ir::VariableKind::Ty(TyVariableKind::Integer),
-                        chalk_ir::UniverseIndex::root(),
-                    )
-                }
-                rustc_type_ir::CanonicalVarKind::Ty(rustc_type_ir::CanonicalTyVarKind::Float) => {
-                    chalk_ir::CanonicalVarKind::new(
-                        chalk_ir::VariableKind::Ty(TyVariableKind::Float),
-                        chalk_ir::UniverseIndex::root(),
+                        chalk_ir::VariableKind::Ty(TyVariableKind::General),
+                        chalk_ir::UniverseIndex { counter: ui.as_usize() },
                     )
                 }
+                rustc_type_ir::CanonicalVarKind::Int => chalk_ir::CanonicalVarKind::new(
+                    chalk_ir::VariableKind::Ty(TyVariableKind::Integer),
+                    chalk_ir::UniverseIndex::root(),
+                ),
+                rustc_type_ir::CanonicalVarKind::Float => chalk_ir::CanonicalVarKind::new(
+                    chalk_ir::VariableKind::Ty(TyVariableKind::Float),
+                    chalk_ir::UniverseIndex::root(),
+                ),
                 rustc_type_ir::CanonicalVarKind::Region(ui) => chalk_ir::CanonicalVarKind::new(
                     chalk_ir::VariableKind::Lifetime,
                     chalk_ir::UniverseIndex { counter: ui.as_usize() },
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
index 385149d78432e..dc5073305c8ca 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
@@ -9,6 +9,7 @@ use rustc_type_ir::{
     solve::{Certainty, NoSolution},
 };
 
+use crate::next_solver::CanonicalVarKind;
 use crate::next_solver::mapping::NextSolverToChalk;
 use crate::{
     TraitRefExt,
@@ -117,13 +118,14 @@ impl<'db> SolverDelegate for SolverContext<'db> {
         canonical.instantiate(self.cx(), &values)
     }
 
-    fn instantiate_canonical_var_with_infer(
+    fn instantiate_canonical_var(
         &self,
-        cv_info: rustc_type_ir::CanonicalVarKind<Self::Interner>,
-        _span: <Self::Interner as rustc_type_ir::Interner>::Span,
+        kind: CanonicalVarKind<'db>,
+        span: <Self::Interner as Interner>::Span,
+        var_values: &[GenericArg<'db>],
         universe_map: impl Fn(rustc_type_ir::UniverseIndex) -> rustc_type_ir::UniverseIndex,
-    ) -> <Self::Interner as rustc_type_ir::Interner>::GenericArg {
-        self.0.instantiate_canonical_var(cv_info, universe_map)
+    ) -> GenericArg<'db> {
+        self.0.instantiate_canonical_var(kind, var_values, universe_map)
     }
 
     fn add_item_bounds_for_hidden_type(
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/util.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/util.rs
index 50b96a160ed10..97d3ea72c93cb 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/util.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/util.rs
@@ -532,17 +532,14 @@ pub(crate) fn mini_canonicalize<'db, T: TypeFoldable<DbInterner<'db>>>(
         max_universe: UniverseIndex::from_u32(1),
         variables: CanonicalVars::new_from_iter(
             context.cx(),
-            vars.iter().map(|(k, v)| match (*k).kind() {
+            vars.iter().enumerate().map(|(idx, (k, v))| match (*k).kind() {
                 GenericArgKind::Type(ty) => match ty.kind() {
-                    TyKind::Int(..) | TyKind::Uint(..) => {
-                        rustc_type_ir::CanonicalVarKind::Ty(rustc_type_ir::CanonicalTyVarKind::Int)
-                    }
-                    TyKind::Float(..) => rustc_type_ir::CanonicalVarKind::Ty(
-                        rustc_type_ir::CanonicalTyVarKind::Float,
-                    ),
-                    _ => rustc_type_ir::CanonicalVarKind::Ty(
-                        rustc_type_ir::CanonicalTyVarKind::General(UniverseIndex::ZERO),
-                    ),
+                    TyKind::Int(..) | TyKind::Uint(..) => rustc_type_ir::CanonicalVarKind::Int,
+                    TyKind::Float(..) => rustc_type_ir::CanonicalVarKind::Float,
+                    _ => rustc_type_ir::CanonicalVarKind::Ty {
+                        ui: UniverseIndex::ZERO,
+                        sub_root: BoundVar::from_usize(idx),
+                    },
                 },
                 GenericArgKind::Lifetime(_) => {
                     rustc_type_ir::CanonicalVarKind::Region(UniverseIndex::ZERO)

From 8407376006546c484bcd72d2743f0e4e1f66ac94 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Tue, 9 Sep 2025 22:32:07 +0300
Subject: [PATCH 0735/1889] Adopt even more custom types in the new solver

A lot of simplification and fun.
---
 .../crates/hir-def/src/lang_item.rs           |  13 ++
 .../crates/hir-ty/src/display.rs              |  43 ++---
 .../rust-analyzer/crates/hir-ty/src/layout.rs |  12 +-
 .../crates/hir-ty/src/method_resolution.rs    |   5 +-
 .../crates/hir-ty/src/mir/eval.rs             |  61 +++----
 .../crates/hir-ty/src/next_solver/def_id.rs   |  63 ++++++-
 .../infer/canonical/canonicalizer.rs          |   4 +-
 .../src/next_solver/infer/canonical/mod.rs    |   4 +-
 .../crates/hir-ty/src/next_solver/interner.rs | 158 +++++++++---------
 .../crates/hir-ty/src/next_solver/mapping.rs  |  46 ++---
 .../crates/hir-ty/src/next_solver/solver.rs   |  12 +-
 .../crates/hir-ty/src/next_solver/ty.rs       |  21 ++-
 12 files changed, 220 insertions(+), 222 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-def/src/lang_item.rs b/src/tools/rust-analyzer/crates/hir-def/src/lang_item.rs
index 600f206770016..df0705bf90cbc 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/lang_item.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/lang_item.rs
@@ -84,6 +84,15 @@ impl LangItemTarget {
             _ => None,
         }
     }
+
+    pub fn as_adt(self) -> Option<AdtId> {
+        match self {
+            LangItemTarget::Union(it) => Some(it.into()),
+            LangItemTarget::EnumId(it) => Some(it.into()),
+            LangItemTarget::Struct(it) => Some(it.into()),
+            _ => None,
+        }
+    }
 }
 
 /// Salsa query. This will look for lang items in a specific crate.
@@ -289,6 +298,10 @@ impl LangItem {
         lang_item(db, start_crate, self).and_then(|t| t.as_trait())
     }
 
+    pub fn resolve_adt(self, db: &dyn DefDatabase, start_crate: Crate) -> Option<AdtId> {
+        lang_item(db, start_crate, self).and_then(|t| t.as_adt())
+    }
+
     pub fn resolve_enum(self, db: &dyn DefDatabase, start_crate: Crate) -> Option<EnumId> {
         lang_item(db, start_crate, self).and_then(|t| t.as_enum())
     }
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 fcb79e9ffb579..ea8bdf8bcbae4 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
@@ -59,7 +59,7 @@ use crate::{
     lt_from_placeholder_idx,
     mir::pad16,
     next_solver::{
-        BoundExistentialPredicate, Ctor, DbInterner, GenericArgs, SolverDefId,
+        BoundExistentialPredicate, DbInterner, GenericArgs, SolverDefId,
         mapping::{
             ChalkToNextSolver, convert_args_for_result, convert_const_for_result,
             convert_region_for_result, convert_ty_for_result,
@@ -911,14 +911,13 @@ fn render_const_scalar_inner(
                 f.write_str("&")?;
                 render_const_scalar_ns(f, bytes, memory_map, t)
             }
-            TyKind::Adt(adt, _) if b.len() == 2 * size_of::<usize>() => match adt.def_id() {
-                SolverDefId::AdtId(hir_def::AdtId::StructId(s)) => {
+            TyKind::Adt(adt, _) if b.len() == 2 * size_of::<usize>() => match adt.def_id().0 {
+                hir_def::AdtId::StructId(s) => {
                     let data = f.db.struct_signature(s);
                     write!(f, "&{}", data.name.display(f.db, f.edition()))?;
                     Ok(())
                 }
-                SolverDefId::AdtId(_) => f.write_str("<unsized-enum-or-union>"),
-                _ => unreachable!(),
+                _ => f.write_str("<unsized-enum-or-union>"),
             },
             _ => {
                 let addr = usize::from_le_bytes(match b.try_into() {
@@ -966,10 +965,7 @@ fn render_const_scalar_inner(
             f.write_str(")")
         }
         TyKind::Adt(def, args) => {
-            let def = match def.def_id() {
-                SolverDefId::AdtId(def) => def,
-                _ => unreachable!(),
-            };
+            let def = def.def_id().0;
             let Ok(layout) = f.db.layout_of_adt(def, args, trait_env.clone()) else {
                 return f.write_str("<layout-error>");
             };
@@ -1300,12 +1296,7 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                 sig.hir_fmt(f)?;
             }
             TyKind::FnDef(def, args) => {
-                let def = match def {
-                    SolverDefId::FunctionId(id) => CallableDefId::FunctionId(id),
-                    SolverDefId::Ctor(Ctor::Enum(e)) => CallableDefId::EnumVariantId(e),
-                    SolverDefId::Ctor(Ctor::Struct(s)) => CallableDefId::StructId(s),
-                    _ => unreachable!(),
-                };
+                let def = def.0;
                 let sig = db
                     .callable_item_signature(def)
                     .substitute(Interner, &convert_args_for_result(interner, args.as_slice()));
@@ -1406,10 +1397,7 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                 }
             }
             TyKind::Adt(def, parameters) => {
-                let def_id = match def.def_id() {
-                    SolverDefId::AdtId(id) => id,
-                    _ => unreachable!(),
-                };
+                let def_id = def.def_id().0;
                 f.start_location_link(def_id.into());
                 match f.display_kind {
                     DisplayKind::Diagnostics | DisplayKind::Test => {
@@ -1448,7 +1436,7 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                 hir_fmt_generics(
                     f,
                     convert_args_for_result(interner, parameters.as_slice()).as_slice(Interner),
-                    def.def_id().try_into().ok(),
+                    Some(def.def_id().0.into()),
                     None,
                 )?;
             }
@@ -1466,13 +1454,9 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
 
                 projection_ty.hir_fmt(f)?;
             }
-            TyKind::Foreign(type_alias) => {
-                let alias = match type_alias {
-                    SolverDefId::TypeAliasId(id) => id,
-                    _ => unreachable!(),
-                };
-                let type_alias = db.type_alias_signature(alias);
-                f.start_location_link(alias.into());
+            TyKind::Foreign(alias) => {
+                let type_alias = db.type_alias_signature(alias.0);
+                f.start_location_link(alias.0.into());
                 write!(f, "{}", type_alias.name.display(f.db, f.edition()))?;
                 f.end_location_link();
             }
@@ -1549,10 +1533,7 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                 }
             }
             TyKind::Closure(id, substs) => {
-                let id = match id {
-                    SolverDefId::InternedClosureId(id) => id,
-                    _ => unreachable!(),
-                };
+                let id = id.0;
                 let substs = convert_args_for_result(interner, substs.as_slice());
                 if f.display_kind.is_source_code() {
                     if !f.display_kind.allows_opaque() {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
index f8abb3b7f6fef..2020a8b34b4f9 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
@@ -25,7 +25,7 @@ use crate::{
     consteval_nextsolver::try_const_usize,
     db::HirDatabase,
     next_solver::{
-        DbInterner, GenericArgs, ParamEnv, SolverDefId, Ty, TyKind, TypingMode,
+        DbInterner, GenericArgs, ParamEnv, Ty, TyKind, TypingMode,
         infer::{DbInternerInferExt, traits::ObligationCause},
         mapping::{ChalkToNextSolver, convert_args_for_result},
         project::solve_normalize::deeply_normalize,
@@ -323,14 +323,10 @@ pub fn layout_of_ty_query<'db>(
             ptr.valid_range_mut().start = 1;
             Layout::scalar(dl, ptr)
         }
-        TyKind::Closure(c, args) => {
-            let id = match c {
-                SolverDefId::InternedClosureId(id) => id,
-                _ => unreachable!(),
-            };
-            let def = db.lookup_intern_closure(id);
+        TyKind::Closure(id, args) => {
+            let def = db.lookup_intern_closure(id.0);
             let infer = db.infer(def.0);
-            let (captures, _) = infer.closure_info(&id.into());
+            let (captures, _) = infer.closure_info(&id.0.into());
             let fields = captures
                 .iter()
                 .map(|it| {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
index fa80567b1ecc0..3f966694d504f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
@@ -161,10 +161,7 @@ impl TyFingerprint {
                 rustc_ast_ir::Mutability::Mut => TyFingerprint::RawPtr(Mutability::Mut),
                 rustc_ast_ir::Mutability::Not => TyFingerprint::RawPtr(Mutability::Not),
             },
-            TyKind::Foreign(def) => {
-                let SolverDefId::TypeAliasId(def) = def else { unreachable!() };
-                TyFingerprint::ForeignType(crate::to_foreign_def_id(def))
-            }
+            TyKind::Foreign(def) => TyFingerprint::ForeignType(crate::to_foreign_def_id(def.0)),
             TyKind::Dynamic(bounds, _, _) => {
                 let trait_ref = bounds
                     .as_slice()
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
index c60ace85be124..ca7467d3855fa 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
@@ -42,7 +42,7 @@ use crate::{
     layout::{Layout, LayoutError, RustcEnumVariantIdx},
     method_resolution::{is_dyn_method, lookup_impl_const},
     next_solver::{
-        Ctor, DbInterner, SolverDefId,
+        DbInterner,
         mapping::{ChalkToNextSolver, convert_args_for_result, convert_ty_for_result},
     },
     static_lifetime,
@@ -2366,8 +2366,8 @@ impl<'db> Evaluator<'db> {
                 let new_id = self.vtable_map.id(ty);
                 self.write_memory(addr, &new_id.to_le_bytes())?;
             }
-            TyKind::Adt(id, args) => match id.def_id() {
-                SolverDefId::AdtId(AdtId::StructId(s)) => {
+            TyKind::Adt(id, args) => match id.def_id().0 {
+                AdtId::StructId(s) => {
                     for (i, (_, ty)) in self.db.field_types_ns(s.into()).iter().enumerate() {
                         let offset = layout.fields.offset(i).bytes_usize();
                         let ty = ty.instantiate(interner, args);
@@ -2380,8 +2380,8 @@ impl<'db> Evaluator<'db> {
                         )?;
                     }
                 }
-                SolverDefId::AdtId(AdtId::UnionId(_)) => (),
-                SolverDefId::AdtId(AdtId::EnumId(e)) => {
+                AdtId::UnionId(_) => (),
+                AdtId::EnumId(e) => {
                     if let Some((ev, layout)) = detect_variant_from_bytes(
                         &layout,
                         self.db,
@@ -2402,7 +2402,6 @@ impl<'db> Evaluator<'db> {
                         }
                     }
                 }
-                _ => unreachable!(),
             },
             TyKind::Tuple(tys) => {
                 for (id, ty) in tys.iter().enumerate() {
@@ -2472,38 +2471,24 @@ impl<'db> Evaluator<'db> {
         let interner = DbInterner::new_with(self.db, None, None);
         use rustc_type_ir::TyKind;
         match next_ty.kind() {
-            TyKind::FnDef(def, generic_args) => {
-                let def = match def {
-                    SolverDefId::FunctionId(id) => CallableDefId::FunctionId(id),
-                    SolverDefId::Ctor(Ctor::Struct(s)) => CallableDefId::StructId(s),
-                    SolverDefId::Ctor(Ctor::Enum(e)) => CallableDefId::EnumVariantId(e),
-                    _ => unreachable!(),
-                };
-                self.exec_fn_def(
-                    def,
-                    &convert_args_for_result(interner, generic_args.as_slice()),
-                    destination,
-                    args,
-                    locals,
-                    target_bb,
-                    span,
-                )
-            }
-            TyKind::Closure(id, generic_args) => {
-                let id = match id {
-                    SolverDefId::InternedClosureId(id) => id,
-                    _ => unreachable!(),
-                };
-                self.exec_closure(
-                    id.into(),
-                    bytes.slice(0..0),
-                    &convert_args_for_result(interner, generic_args.as_slice()),
-                    destination,
-                    args,
-                    locals,
-                    span,
-                )
-            }
+            TyKind::FnDef(def, generic_args) => self.exec_fn_def(
+                def.0,
+                &convert_args_for_result(interner, generic_args.as_slice()),
+                destination,
+                args,
+                locals,
+                target_bb,
+                span,
+            ),
+            TyKind::Closure(id, generic_args) => self.exec_closure(
+                id.0.into(),
+                bytes.slice(0..0),
+                &convert_args_for_result(interner, generic_args.as_slice()),
+                destination,
+                args,
+                locals,
+                span,
+            ),
             _ => Err(MirEvalError::InternalError("function pointer to non function".into())),
         }
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
index 8bbc6e3370399..a9c572d3f34ee 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
@@ -1,8 +1,8 @@
 //! Definition of `SolverDefId`
 
 use hir_def::{
-    AdtId, ConstId, EnumId, EnumVariantId, FunctionId, GenericDefId, ImplId, StaticId, StructId,
-    TraitId, TypeAliasId, UnionId,
+    AdtId, CallableDefId, ConstId, EnumId, EnumVariantId, FunctionId, GenericDefId, ImplId,
+    StaticId, StructId, TraitId, TypeAliasId, UnionId,
 };
 use rustc_type_ir::inherent;
 use stdx::impl_from;
@@ -42,7 +42,8 @@ impl_from!(
     TypeAliasId,
     InternedClosureId,
     InternedCoroutineId,
-    InternedOpaqueTyId
+    InternedOpaqueTyId,
+    Ctor
     for SolverDefId
 );
 
@@ -145,3 +146,59 @@ macro_rules! declare_id_wrapper {
 }
 
 declare_id_wrapper!(TraitIdWrapper, TraitId);
+declare_id_wrapper!(TypeAliasIdWrapper, TypeAliasId);
+declare_id_wrapper!(ClosureIdWrapper, InternedClosureId);
+declare_id_wrapper!(CoroutineIdWrapper, InternedCoroutineId);
+declare_id_wrapper!(AdtIdWrapper, AdtId);
+declare_id_wrapper!(ImplIdWrapper, ImplId);
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+pub struct CallableIdWrapper(pub CallableDefId);
+
+impl std::fmt::Debug for CallableIdWrapper {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Debug::fmt(&self.0, f)
+    }
+}
+impl From<CallableIdWrapper> for CallableDefId {
+    #[inline]
+    fn from(value: CallableIdWrapper) -> CallableDefId {
+        value.0
+    }
+}
+impl From<CallableDefId> for CallableIdWrapper {
+    #[inline]
+    fn from(value: CallableDefId) -> CallableIdWrapper {
+        Self(value)
+    }
+}
+impl From<CallableIdWrapper> for SolverDefId {
+    #[inline]
+    fn from(value: CallableIdWrapper) -> SolverDefId {
+        match value.0 {
+            CallableDefId::FunctionId(it) => it.into(),
+            CallableDefId::StructId(it) => Ctor::Struct(it).into(),
+            CallableDefId::EnumVariantId(it) => Ctor::Enum(it).into(),
+        }
+    }
+}
+impl TryFrom<SolverDefId> for CallableIdWrapper {
+    type Error = ();
+    #[inline]
+    fn try_from(value: SolverDefId) -> Result<Self, Self::Error> {
+        match value {
+            SolverDefId::FunctionId(it) => Ok(Self(it.into())),
+            SolverDefId::Ctor(Ctor::Struct(it)) => Ok(Self(it.into())),
+            SolverDefId::Ctor(Ctor::Enum(it)) => Ok(Self(it.into())),
+            _ => Err(()),
+        }
+    }
+}
+impl<'db> inherent::DefId<DbInterner<'db>> for CallableIdWrapper {
+    fn as_local(self) -> Option<SolverDefId> {
+        Some(self.into())
+    }
+    fn is_local(self) -> bool {
+        true
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/canonicalizer.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/canonicalizer.rs
index ffb9c076fa061..beaac11a2de41 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/canonicalizer.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/canonicalizer.rs
@@ -400,7 +400,7 @@ impl<'cx, 'db> TypeFolder<DbInterner<'db>> for Canonicalizer<'cx, 'db> {
             TyKind::Infer(IntVar(vid)) => {
                 let nt = self.infcx.opportunistic_resolve_int_var(vid);
                 if nt != t {
-                    return self.fold_ty(nt);
+                    self.fold_ty(nt)
                 } else {
                     self.canonicalize_ty_var(CanonicalVarKind::Int, t)
                 }
@@ -408,7 +408,7 @@ impl<'cx, 'db> TypeFolder<DbInterner<'db>> for Canonicalizer<'cx, 'db> {
             TyKind::Infer(FloatVar(vid)) => {
                 let nt = self.infcx.opportunistic_resolve_float_var(vid);
                 if nt != t {
-                    return self.fold_ty(nt);
+                    self.fold_ty(nt)
                 } else {
                     self.canonicalize_ty_var(CanonicalVarKind::Float, t)
                 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/mod.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/mod.rs
index 8db4320acc9c0..d0669f5c3bcc5 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/mod.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/canonical/mod.rs
@@ -82,9 +82,7 @@ impl<'db> InferCtxt<'db> {
         let var_values = CanonicalVarValues::instantiate(
             self.interner,
             canonical.variables,
-            |var_values, info| {
-                self.instantiate_canonical_var(info, &var_values, |ui| universes[ui])
-            },
+            |var_values, info| self.instantiate_canonical_var(info, var_values, |ui| universes[ui]),
         );
         let result = canonical.instantiate(self.interner, &var_values);
         (result, var_values)
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
index 5709beaefc292..0f512fdaf8687 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
@@ -19,7 +19,7 @@ use rustc_type_ir::error::TypeError;
 use rustc_type_ir::inherent::{
     AdtDef as _, GenericArgs as _, GenericsOf, IntoKind, SliceLike as _, Span as _,
 };
-use rustc_type_ir::lang_items::{SolverLangItem, SolverTraitLangItem};
+use rustc_type_ir::lang_items::{SolverAdtLangItem, SolverLangItem, SolverTraitLangItem};
 use rustc_type_ir::solve::SizedTraitKind;
 use rustc_type_ir::{
     AliasTerm, AliasTermKind, AliasTy, AliasTyKind, EarlyBinder, FlagComputation, Flags,
@@ -47,8 +47,9 @@ use crate::method_resolution::{ALL_FLOAT_FPS, ALL_INT_FPS, TyFingerprint};
 use crate::next_solver::infer::InferCtxt;
 use crate::next_solver::util::{ContainsTypeErrors, explicit_item_bounds, for_trait_impls};
 use crate::next_solver::{
-    BoundConst, CanonicalVarKind, FxIndexMap, InternedWrapperNoDebug, RegionAssumptions,
-    SolverContext, SolverDefIds, TraitIdWrapper,
+    AdtIdWrapper, BoundConst, CallableIdWrapper, CanonicalVarKind, ClosureIdWrapper,
+    CoroutineIdWrapper, FxIndexMap, ImplIdWrapper, InternedWrapperNoDebug, RegionAssumptions,
+    SolverContext, SolverDefIds, TraitIdWrapper, TypeAliasIdWrapper,
 };
 use crate::{ConstScalar, FnAbi, Interner, db::HirDatabase};
 
@@ -609,8 +610,8 @@ impl AdtDef {
 }
 
 impl<'db> inherent::AdtDef<DbInterner<'db>> for AdtDef {
-    fn def_id(self) -> <DbInterner<'db> as rustc_type_ir::Interner>::DefId {
-        SolverDefId::AdtId(self.inner().id)
+    fn def_id(self) -> AdtIdWrapper {
+        self.inner().id.into()
     }
 
     fn is_struct(self) -> bool {
@@ -889,6 +890,13 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
     type LocalDefId = SolverDefId;
     type LocalDefIds = SolverDefIds;
     type TraitId = TraitIdWrapper;
+    type ForeignId = TypeAliasIdWrapper;
+    type FunctionId = CallableIdWrapper;
+    type ClosureId = ClosureIdWrapper;
+    type CoroutineClosureId = CoroutineIdWrapper;
+    type CoroutineId = CoroutineIdWrapper;
+    type AdtId = AdtIdWrapper;
+    type ImplId = ImplIdWrapper;
     type Span = Span;
 
     type GenericArgs = GenericArgs<'db>;
@@ -1103,12 +1111,8 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
         self.db().ty_ns(def_id)
     }
 
-    fn adt_def(self, adt_def_id: Self::DefId) -> Self::AdtDef {
-        let def_id = match adt_def_id {
-            SolverDefId::AdtId(adt_id) => adt_id,
-            _ => panic!("Invalid DefId passed to adt_def"),
-        };
-        AdtDef::new(def_id, self)
+    fn adt_def(self, def_id: Self::AdtId) -> Self::AdtDef {
+        AdtDef::new(def_id.0, self)
     }
 
     fn alias_ty_kind(self, alias: rustc_type_ir::AliasTy<Self>) -> AliasTyKind {
@@ -1219,24 +1223,16 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
 
     fn fn_sig(
         self,
-        def_id: Self::DefId,
+        def_id: Self::FunctionId,
     ) -> EarlyBinder<Self, rustc_type_ir::Binder<Self, rustc_type_ir::FnSig<Self>>> {
-        let id = match def_id {
-            SolverDefId::FunctionId(id) => CallableDefId::FunctionId(id),
-            SolverDefId::Ctor(ctor) => match ctor {
-                super::Ctor::Struct(struct_id) => CallableDefId::StructId(struct_id),
-                super::Ctor::Enum(enum_variant_id) => CallableDefId::EnumVariantId(enum_variant_id),
-            },
-            def => unreachable!("{:?}", def),
-        };
-        self.db().callable_item_signature_ns(id)
+        self.db().callable_item_signature_ns(def_id.0)
     }
 
-    fn coroutine_movability(self, def_id: Self::DefId) -> rustc_ast_ir::Movability {
+    fn coroutine_movability(self, def_id: Self::CoroutineId) -> rustc_ast_ir::Movability {
         unimplemented!()
     }
 
-    fn coroutine_for_closure(self, def_id: Self::DefId) -> Self::DefId {
+    fn coroutine_for_closure(self, def_id: Self::CoroutineId) -> Self::CoroutineId {
         unimplemented!()
     }
 
@@ -1361,13 +1357,9 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
 
     fn impl_super_outlives(
         self,
-        impl_def_id: Self::DefId,
+        impl_id: Self::ImplId,
     ) -> EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>> {
-        let impl_id = match impl_def_id {
-            SolverDefId::ImplId(id) => id,
-            _ => unreachable!(),
-        };
-        let trait_ref = self.db().impl_trait_ns(impl_id).expect("expected an impl of trait");
+        let trait_ref = self.db().impl_trait_ns(impl_id.0).expect("expected an impl of trait");
         trait_ref.map_bound(|trait_ref| {
             let clause: Clause<'_> = trait_ref.upcast(self);
             Clauses::new_from_iter(
@@ -1392,7 +1384,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
         EarlyBinder::bind([unimplemented!()])
     }
 
-    fn has_target_features(self, def_id: Self::DefId) -> bool {
+    fn has_target_features(self, def_id: Self::FunctionId) -> bool {
         false
     }
 
@@ -1407,8 +1399,6 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
             SolverLangItem::DynMetadata => LangItem::DynMetadata,
             SolverLangItem::FutureOutput => LangItem::FutureOutput,
             SolverLangItem::Metadata => LangItem::Metadata,
-            SolverLangItem::Option => LangItem::Option,
-            SolverLangItem::Poll => LangItem::Poll,
         };
         let target = hir_def::lang_item::lang_item(
             self.db(),
@@ -1468,21 +1458,30 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
             .into()
     }
 
-    #[allow(clippy::match_like_matches_macro)]
-    fn is_lang_item(self, def_id: Self::DefId, lang_item: SolverLangItem) -> bool {
-        use SolverLangItem::*;
+    fn require_adt_lang_item(self, lang_item: SolverAdtLangItem) -> AdtIdWrapper {
+        let lang_item = match lang_item {
+            SolverAdtLangItem::Option => LangItem::Option,
+            SolverAdtLangItem::Poll => LangItem::Poll,
+        };
+        lang_item
+            .resolve_adt(self.db(), self.krate.expect("Must have self.krate"))
+            .unwrap_or_else(|| panic!("Lang item {lang_item:?} required but not found."))
+            .into()
+    }
 
-        // FIXME: derive PartialEq on SolverLangItem
+    fn is_lang_item(self, def_id: Self::DefId, lang_item: SolverLangItem) -> bool {
         self.as_lang_item(def_id)
             .map_or(false, |l| std::mem::discriminant(&l) == std::mem::discriminant(&lang_item))
     }
 
-    #[allow(clippy::match_like_matches_macro)]
     fn is_trait_lang_item(self, def_id: Self::TraitId, lang_item: SolverTraitLangItem) -> bool {
-        use SolverTraitLangItem::*;
+        self.as_trait_lang_item(def_id)
+            .map_or(false, |l| std::mem::discriminant(&l) == std::mem::discriminant(&lang_item))
+    }
 
+    fn is_adt_lang_item(self, def_id: Self::AdtId, lang_item: SolverAdtLangItem) -> bool {
         // FIXME: derive PartialEq on SolverTraitLangItem
-        self.as_trait_lang_item(def_id)
+        self.as_adt_lang_item(def_id)
             .map_or(false, |l| std::mem::discriminant(&l) == std::mem::discriminant(&lang_item))
     }
 
@@ -1505,9 +1504,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
             DynMetadata,
             CoroutineReturn,
             CoroutineYield,
-            Poll,
             FutureOutput,
-            Option,
             AsyncFnOnceOutput,
             CallRefFuture,
             CallOnceFuture,
@@ -1556,6 +1553,19 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
         )
     }
 
+    fn as_adt_lang_item(self, def_id: Self::AdtId) -> Option<SolverAdtLangItem> {
+        let def_id: AttrDefId = def_id.0.into();
+        let lang_item = self.db().lang_attr(def_id)?;
+        as_lang_item!(
+            SolverAdtLangItem, lang_item;
+
+            ignore = {}
+
+            Option,
+            Poll,
+        )
+    }
+
     fn associated_type_def_ids(self, def_id: Self::DefId) -> impl IntoIterator<Item = Self::DefId> {
         let trait_ = match def_id {
             SolverDefId::TraitId(id) => id,
@@ -1568,7 +1578,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
         self,
         trait_: Self::TraitId,
         self_ty: Self::Ty,
-        mut f: impl FnMut(Self::DefId),
+        mut f: impl FnMut(Self::ImplId),
     ) {
         let trait_ = trait_.0;
         let self_ty_fp = TyFingerprint::for_trait_impl_ns(&self_ty);
@@ -1595,7 +1605,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
                             continue;
                         }
 
-                        f(SolverDefId::ImplId(i));
+                        f(i.into());
                     }
                     ControlFlow::Continue(())
                 },
@@ -1618,7 +1628,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
                                 continue;
                             }
 
-                            f(SolverDefId::ImplId(i));
+                            f(i.into());
                         }
                     }
                     ControlFlow::Continue(())
@@ -1632,7 +1642,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
         true
     }
 
-    fn impl_is_default(self, impl_def_id: Self::DefId) -> bool {
+    fn impl_is_default(self, impl_def_id: Self::ImplId) -> bool {
         // FIXME
         false
     }
@@ -1640,26 +1650,16 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
     #[tracing::instrument(skip(self), ret)]
     fn impl_trait_ref(
         self,
-        impl_def_id: Self::DefId,
+        impl_id: Self::ImplId,
     ) -> EarlyBinder<Self, rustc_type_ir::TraitRef<Self>> {
-        let impl_id = match impl_def_id {
-            SolverDefId::ImplId(id) => id,
-            _ => panic!("Unexpected SolverDefId in impl_trait_ref"),
-        };
-
         let db = self.db();
-
-        db.impl_trait_ns(impl_id)
+        db.impl_trait_ns(impl_id.0)
             // ImplIds for impls where the trait ref can't be resolved should never reach trait solving
             .expect("invalid impl passed to trait solver")
     }
 
-    fn impl_polarity(self, impl_def_id: Self::DefId) -> rustc_type_ir::ImplPolarity {
-        let impl_id = match impl_def_id {
-            SolverDefId::ImplId(id) => id,
-            _ => unreachable!(),
-        };
-        let impl_data = self.db().impl_signature(impl_id);
+    fn impl_polarity(self, impl_id: Self::ImplId) -> rustc_type_ir::ImplPolarity {
+        let impl_data = self.db().impl_signature(impl_id.0);
         if impl_data.flags.contains(ImplFlags::NEGATIVE) {
             ImplPolarity::Negative
         } else {
@@ -1701,33 +1701,29 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
         panic!("Bug encountered in next-trait-solver.")
     }
 
-    fn is_general_coroutine(self, coroutine_def_id: Self::DefId) -> bool {
+    fn is_general_coroutine(self, coroutine_def_id: Self::CoroutineId) -> bool {
         // FIXME(next-solver)
         true
     }
 
-    fn coroutine_is_async(self, coroutine_def_id: Self::DefId) -> bool {
+    fn coroutine_is_async(self, coroutine_def_id: Self::CoroutineId) -> bool {
         // FIXME(next-solver)
         true
     }
 
-    fn coroutine_is_gen(self, coroutine_def_id: Self::DefId) -> bool {
+    fn coroutine_is_gen(self, coroutine_def_id: Self::CoroutineId) -> bool {
         // FIXME(next-solver)
         false
     }
 
-    fn coroutine_is_async_gen(self, coroutine_def_id: Self::DefId) -> bool {
+    fn coroutine_is_async_gen(self, coroutine_def_id: Self::CoroutineId) -> bool {
         // FIXME(next-solver)
         false
     }
 
-    fn unsizing_params_for_adt(self, adt_def_id: Self::DefId) -> Self::UnsizingParams {
-        let id = match adt_def_id {
-            SolverDefId::AdtId(id) => id,
-            _ => unreachable!(),
-        };
-        let def = AdtDef::new(id, self);
-        let num_params = self.generics_of(adt_def_id).count();
+    fn unsizing_params_for_adt(self, id: Self::AdtId) -> Self::UnsizingParams {
+        let def = AdtDef::new(id.0, self);
+        let num_params = self.generics_of(id.into()).count();
 
         let maybe_unsizing_param_idx = |arg: GenericArg<'db>| match arg.kind() {
             GenericArgKind::Type(ty) => match ty.kind() {
@@ -1835,15 +1831,15 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
         EarlyBinder::bind([])
     }
 
-    fn fn_is_const(self, def_id: Self::DefId) -> bool {
-        let id = match def_id {
-            SolverDefId::FunctionId(id) => id,
-            _ => unreachable!(),
+    fn fn_is_const(self, id: Self::FunctionId) -> bool {
+        let id = match id.0 {
+            CallableDefId::FunctionId(id) => id,
+            _ => return false,
         };
         self.db().function_signature(id).flags.contains(FnFlags::CONST)
     }
 
-    fn impl_is_const(self, def_id: Self::DefId) -> bool {
+    fn impl_is_const(self, def_id: Self::ImplId) -> bool {
         false
     }
 
@@ -1877,7 +1873,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
 
     fn coroutine_hidden_types(
         self,
-        def_id: Self::DefId,
+        def_id: Self::CoroutineId,
     ) -> EarlyBinder<Self, rustc_type_ir::Binder<Self, rustc_type_ir::CoroutineWitnessTypes<Self>>>
     {
         // FIXME(next-solver)
@@ -1896,11 +1892,11 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
         self.db().trait_signature(trait_.0).flags.contains(TraitFlags::UNSAFE)
     }
 
-    fn impl_self_is_guaranteed_unsized(self, def_id: Self::DefId) -> bool {
+    fn impl_self_is_guaranteed_unsized(self, def_id: Self::ImplId) -> bool {
         false
     }
 
-    fn impl_specializes(self, impl_def_id: Self::DefId, victim_def_id: Self::DefId) -> bool {
+    fn impl_specializes(self, impl_def_id: Self::ImplId, victim_def_id: Self::ImplId) -> bool {
         false
     }
 
@@ -2020,6 +2016,12 @@ macro_rules! TrivialTypeTraversalImpls {
 TrivialTypeTraversalImpls! {
     SolverDefId,
     TraitIdWrapper,
+    TypeAliasIdWrapper,
+    CallableIdWrapper,
+    ClosureIdWrapper,
+    CoroutineIdWrapper,
+    AdtIdWrapper,
+    ImplIdWrapper,
     Pattern<'db>,
     Safety,
     FnAbi,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
index 11bc6e6abe94b..ce56282a00b24 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
@@ -243,12 +243,10 @@ impl<'db> ChalkToNextSolver<'db, Ty<'db>> for chalk_ir::Ty<Interner> {
                 }
                 chalk_ir::TyKind::FnDef(fn_def_id, substitution) => {
                     let def_id = CallableDefId::from_chalk(interner.db(), *fn_def_id);
-                    let id: SolverDefId = match def_id {
-                        CallableDefId::FunctionId(id) => id.into(),
-                        CallableDefId::StructId(id) => SolverDefId::Ctor(Ctor::Struct(id)),
-                        CallableDefId::EnumVariantId(id) => SolverDefId::Ctor(Ctor::Enum(id)),
-                    };
-                    rustc_type_ir::TyKind::FnDef(id, substitution.to_nextsolver(interner))
+                    rustc_type_ir::TyKind::FnDef(
+                        def_id.into(),
+                        substitution.to_nextsolver(interner),
+                    )
                 }
                 chalk_ir::TyKind::Str => rustc_type_ir::TyKind::Str,
                 chalk_ir::TyKind::Never => rustc_type_ir::TyKind::Never,
@@ -271,7 +269,7 @@ impl<'db> ChalkToNextSolver<'db, Ty<'db>> for chalk_ir::Ty<Interner> {
                     )
                 }
                 chalk_ir::TyKind::Foreign(foreign_def_id) => rustc_type_ir::TyKind::Foreign(
-                    SolverDefId::TypeAliasId(crate::from_foreign_def_id(*foreign_def_id)),
+                    crate::from_foreign_def_id(*foreign_def_id).into(),
                 ),
                 chalk_ir::TyKind::Error => rustc_type_ir::TyKind::Error(ErrorGuaranteed),
                 chalk_ir::TyKind::Dyn(dyn_ty) => {
@@ -1511,13 +1509,7 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
             TyKind::Slice(ty)
         }
 
-        rustc_type_ir::TyKind::Foreign(foreign) => {
-            let def_id = match foreign {
-                SolverDefId::TypeAliasId(id) => id,
-                _ => unreachable!(),
-            };
-            TyKind::Foreign(to_foreign_def_id(def_id))
-        }
+        rustc_type_ir::TyKind::Foreign(foreign) => TyKind::Foreign(to_foreign_def_id(foreign.0)),
         rustc_type_ir::TyKind::Pat(_, _) => unimplemented!(),
         rustc_type_ir::TyKind::RawPtr(ty, mutability) => {
             let mutability = match mutability {
@@ -1528,40 +1520,22 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
             TyKind::Raw(mutability, ty)
         }
         rustc_type_ir::TyKind::FnDef(def_id, args) => {
-            let id = match def_id {
-                SolverDefId::FunctionId(id) => CallableDefId::FunctionId(id),
-                SolverDefId::Ctor(Ctor::Struct(id)) => CallableDefId::StructId(id),
-                SolverDefId::Ctor(Ctor::Enum(id)) => CallableDefId::EnumVariantId(id),
-                _ => unreachable!(),
-            };
             let subst = convert_args_for_result(interner, args.as_slice());
-            TyKind::FnDef(id.to_chalk(interner.db()), subst)
+            TyKind::FnDef(def_id.0.to_chalk(interner.db()), subst)
         }
 
         rustc_type_ir::TyKind::Closure(def_id, args) => {
-            let id = match def_id {
-                SolverDefId::InternedClosureId(id) => id,
-                _ => unreachable!(),
-            };
             let subst = convert_args_for_result(interner, args.as_slice());
-            TyKind::Closure(id.into(), subst)
+            TyKind::Closure(def_id.0.into(), subst)
         }
         rustc_type_ir::TyKind::CoroutineClosure(_, _) => unimplemented!(),
         rustc_type_ir::TyKind::Coroutine(def_id, args) => {
-            let id = match def_id {
-                SolverDefId::InternedCoroutineId(id) => id,
-                _ => unreachable!(),
-            };
             let subst = convert_args_for_result(interner, args.as_slice());
-            TyKind::Coroutine(id.into(), subst)
+            TyKind::Coroutine(def_id.0.into(), subst)
         }
         rustc_type_ir::TyKind::CoroutineWitness(def_id, args) => {
-            let id = match def_id {
-                SolverDefId::InternedCoroutineId(id) => id,
-                _ => unreachable!(),
-            };
             let subst = convert_args_for_result(interner, args.as_slice());
-            TyKind::CoroutineWitness(id.into(), subst)
+            TyKind::CoroutineWitness(def_id.0.into(), subst)
         }
 
         rustc_type_ir::TyKind::UnsafeBinder(_) => unimplemented!(),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
index dc5073305c8ca..c7591c0c77966 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
@@ -9,8 +9,8 @@ use rustc_type_ir::{
     solve::{Certainty, NoSolution},
 };
 
-use crate::next_solver::CanonicalVarKind;
 use crate::next_solver::mapping::NextSolverToChalk;
+use crate::next_solver::{CanonicalVarKind, ImplIdWrapper};
 use crate::{
     TraitRefExt,
     db::HirDatabase,
@@ -148,12 +148,8 @@ impl<'db> SolverDelegate for SolverContext<'db> {
         &self,
         goal_trait_ref: rustc_type_ir::TraitRef<Self::Interner>,
         trait_assoc_def_id: <Self::Interner as rustc_type_ir::Interner>::DefId,
-        impl_def_id: <Self::Interner as rustc_type_ir::Interner>::DefId,
+        impl_id: ImplIdWrapper,
     ) -> Result<Option<<Self::Interner as rustc_type_ir::Interner>::DefId>, ErrorGuaranteed> {
-        let impl_id = match impl_def_id {
-            SolverDefId::ImplId(id) => id,
-            _ => panic!("Unexpected SolverDefId"),
-        };
         let trait_assoc_id = match trait_assoc_def_id {
             SolverDefId::TypeAliasId(id) => id,
             _ => panic!("Unexpected SolverDefId"),
@@ -162,7 +158,7 @@ impl<'db> SolverDelegate for SolverContext<'db> {
             .0
             .interner
             .db()
-            .impl_trait(impl_id)
+            .impl_trait(impl_id.0)
             // ImplIds for impls where the trait ref can't be resolved should never reach solver
             .expect("invalid impl passed to next-solver")
             .into_value_and_skipped_binders()
@@ -170,7 +166,7 @@ impl<'db> SolverDelegate for SolverContext<'db> {
         let trait_ = trait_ref.hir_trait_id();
         let trait_data = trait_.trait_items(self.0.interner.db());
         let id =
-            impl_id.impl_items(self.0.interner.db()).items.iter().find_map(|item| -> Option<_> {
+            impl_id.0.impl_items(self.0.interner.db()).items.iter().find_map(|item| -> Option<_> {
                 match item {
                     (_, AssocItemId::TypeAliasId(type_alias)) => {
                         let name = &self.0.interner.db().type_alias_signature(*type_alias).name;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
index 4794e2d604509..e1c29160ad1ae 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
@@ -20,7 +20,9 @@ use rustc_type_ir::{
 use salsa::plumbing::{AsId, FromId};
 use smallvec::SmallVec;
 
-use crate::next_solver::GenericArg;
+use crate::next_solver::{
+    CallableIdWrapper, ClosureIdWrapper, CoroutineIdWrapper, GenericArg, TypeAliasIdWrapper,
+};
 use crate::{
     db::HirDatabase,
     interner::InternedWrapperNoDebug,
@@ -599,10 +601,7 @@ impl<'db> rustc_type_ir::inherent::Ty<DbInterner<'db>> for Ty<'db> {
         Ty::new(interner, TyKind::Adt(adt_def, args))
     }
 
-    fn new_foreign(
-        interner: DbInterner<'db>,
-        def_id: <DbInterner<'db> as rustc_type_ir::Interner>::DefId,
-    ) -> Self {
+    fn new_foreign(interner: DbInterner<'db>, def_id: TypeAliasIdWrapper) -> Self {
         Ty::new(interner, TyKind::Foreign(def_id))
     }
 
@@ -617,7 +616,7 @@ impl<'db> rustc_type_ir::inherent::Ty<DbInterner<'db>> for Ty<'db> {
 
     fn new_coroutine(
         interner: DbInterner<'db>,
-        def_id: <DbInterner<'db> as rustc_type_ir::Interner>::DefId,
+        def_id: CoroutineIdWrapper,
         args: <DbInterner<'db> as rustc_type_ir::Interner>::GenericArgs,
     ) -> Self {
         Ty::new(interner, TyKind::Coroutine(def_id, args))
@@ -625,7 +624,7 @@ impl<'db> rustc_type_ir::inherent::Ty<DbInterner<'db>> for Ty<'db> {
 
     fn new_coroutine_closure(
         interner: DbInterner<'db>,
-        def_id: <DbInterner<'db> as rustc_type_ir::Interner>::DefId,
+        def_id: CoroutineIdWrapper,
         args: <DbInterner<'db> as rustc_type_ir::Interner>::GenericArgs,
     ) -> Self {
         Ty::new(interner, TyKind::CoroutineClosure(def_id, args))
@@ -633,7 +632,7 @@ impl<'db> rustc_type_ir::inherent::Ty<DbInterner<'db>> for Ty<'db> {
 
     fn new_closure(
         interner: DbInterner<'db>,
-        def_id: <DbInterner<'db> as rustc_type_ir::Interner>::DefId,
+        def_id: ClosureIdWrapper,
         args: <DbInterner<'db> as rustc_type_ir::Interner>::GenericArgs,
     ) -> Self {
         Ty::new(interner, TyKind::Closure(def_id, args))
@@ -641,7 +640,7 @@ impl<'db> rustc_type_ir::inherent::Ty<DbInterner<'db>> for Ty<'db> {
 
     fn new_coroutine_witness(
         interner: DbInterner<'db>,
-        def_id: <DbInterner<'db> as rustc_type_ir::Interner>::DefId,
+        def_id: CoroutineIdWrapper,
         args: <DbInterner<'db> as rustc_type_ir::Interner>::GenericArgs,
     ) -> Self {
         Ty::new(interner, TyKind::CoroutineWitness(def_id, args))
@@ -649,7 +648,7 @@ impl<'db> rustc_type_ir::inherent::Ty<DbInterner<'db>> for Ty<'db> {
 
     fn new_coroutine_witness_for_coroutine(
         interner: DbInterner<'db>,
-        def_id: <DbInterner<'db> as rustc_type_ir::Interner>::DefId,
+        def_id: CoroutineIdWrapper,
         coroutine_args: <DbInterner<'db> as rustc_type_ir::Interner>::GenericArgs,
     ) -> Self {
         // HACK: Coroutine witness types are lifetime erased, so they
@@ -714,7 +713,7 @@ impl<'db> rustc_type_ir::inherent::Ty<DbInterner<'db>> for Ty<'db> {
 
     fn new_fn_def(
         interner: DbInterner<'db>,
-        def_id: <DbInterner<'db> as rustc_type_ir::Interner>::DefId,
+        def_id: CallableIdWrapper,
         args: <DbInterner<'db> as rustc_type_ir::Interner>::GenericArgs,
     ) -> Self {
         Ty::new(interner, TyKind::FnDef(def_id, args))

From 1acb4c2c1621578ea787afb698ed8718cbdf3d4f Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Thu, 28 Aug 2025 03:35:22 +0300
Subject: [PATCH 0736/1889] An associated type is not a projection!

More correctly, a `TyKind::AssociatedType` is not the same as `TyKind::Projection`.

We used to map next-solver `TyKind::Alias` to Chalk's `TyKind::AssociatedType`. This is very incorrect, as `AssociatedType` is assumed to be fully normalized, and caused a lot of type mismatches.

Unfortunately fixing this causes a lot of stack overflows, because the next solver doesn't have something akin to `AssociatedType` so we normalize again and again. The reason is that is the lazy-normalization nature of the next solver, which means we need to stop normalizing everything. This will be fixed in the next commit.
---
 .../crates/hir-ty/src/next_solver/mapping.rs  |  5 +++-
 .../hir-ty/src/tests/regression/new_solver.rs | 27 +++++++++++++++++++
 2 files changed, 31 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
index f66b8dace30a6..57a56b3f0c662 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
@@ -1358,7 +1358,10 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
                 };
                 let associated_ty_id = to_assoc_type_id(assoc_ty_id);
                 let substitution = convert_args_for_result(interner, alias_ty.args.as_slice());
-                TyKind::AssociatedType(associated_ty_id, substitution)
+                TyKind::Alias(crate::AliasTy::Projection(crate::ProjectionTy {
+                    associated_ty_id,
+                    substitution,
+                }))
             }
             rustc_type_ir::AliasTyKind::Opaque => {
                 let opaque_ty_id = match alias_ty.def_id {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
index 97473bbabba04..471108d964f6e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
@@ -71,3 +71,30 @@ fn main() {
 }"#,
     );
 }
+
+#[test]
+fn projection_is_not_associated_type() {
+    check_no_mismatches(
+        r#"
+//- minicore: fn
+trait Iterator {
+    type Item;
+
+    fn partition<F>(self, f: F)
+    where
+        F: FnMut(&Self::Item) -> bool,
+    {
+    }
+}
+
+struct Iter;
+impl Iterator for Iter {
+    type Item = i32;
+}
+
+fn main() {
+    Iter.partition(|n| true);
+}
+    "#,
+    );
+}

From b262cae8575589997d4f2a9bc166d99cc48e5eb1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Sun, 24 Aug 2025 11:14:26 +0200
Subject: [PATCH 0737/1889] port `#[no_core]` to the new attribute parsing
 infrastructure

---
 .../rustc_attr_parsing/src/attributes/crate_level.rs | 12 ++++++++++++
 compiler/rustc_attr_parsing/src/context.rs           |  5 +++--
 compiler/rustc_hir/src/attrs/data_structures.rs      |  3 +++
 compiler/rustc_hir/src/attrs/encode_cross_crate.rs   |  1 +
 compiler/rustc_passes/src/check_attr.rs              |  1 +
 5 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_attr_parsing/src/attributes/crate_level.rs b/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
index d23a7ae72f8c8..d2e28ed97aac0 100644
--- a/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
@@ -176,3 +176,15 @@ impl<S: Stage> SingleAttributeParser<S> for PatternComplexityLimitParser {
         })
     }
 }
+
+pub(crate) struct NoCoreParser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for NoCoreParser {
+    const PATH: &[Symbol] = &[sym::no_core];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    // FIXME: recursion limit is allowed on all targets and ignored,
+    //        even though it should only be valid on crates of course
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::NoCore;
+    const TYPE: AttributeType = AttributeType::CrateLevel;
+}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index 98e86838a3a18..3d532d432b5c3 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -25,8 +25,8 @@ use crate::attributes::codegen_attrs::{
 };
 use crate::attributes::confusables::ConfusablesParser;
 use crate::attributes::crate_level::{
-    CrateNameParser, MoveSizeLimitParser, PatternComplexityLimitParser, RecursionLimitParser,
-    TypeLengthLimitParser,
+    CrateNameParser, MoveSizeLimitParser, NoCoreParser, PatternComplexityLimitParser,
+    RecursionLimitParser, TypeLengthLimitParser,
 };
 use crate::attributes::deprecation::DeprecationParser;
 use crate::attributes::dummy::DummyParser;
@@ -222,6 +222,7 @@ attribute_parsers!(
         Single<WithoutArgs<MacroEscapeParser>>,
         Single<WithoutArgs<MarkerParser>>,
         Single<WithoutArgs<MayDangleParser>>,
+        Single<WithoutArgs<NoCoreParser>>,
         Single<WithoutArgs<NoImplicitPreludeParser>>,
         Single<WithoutArgs<NoMangleParser>>,
         Single<WithoutArgs<NonExhaustiveParser>>,
diff --git a/compiler/rustc_hir/src/attrs/data_structures.rs b/compiler/rustc_hir/src/attrs/data_structures.rs
index b4c1b61b9b586..c2a3844af0226 100644
--- a/compiler/rustc_hir/src/attrs/data_structures.rs
+++ b/compiler/rustc_hir/src/attrs/data_structures.rs
@@ -579,6 +579,9 @@ pub enum AttributeKind {
     /// Represents `#[naked]`
     Naked(Span),
 
+    /// Represents `#[no_core]`
+    NoCore(Span),
+
     /// Represents `#[no_implicit_prelude]`
     NoImplicitPrelude(Span),
 
diff --git a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
index 0e208be3497ae..d46e8abf93781 100644
--- a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
+++ b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
@@ -64,6 +64,7 @@ impl AttributeKind {
             MoveSizeLimit { .. } => No,
             MustUse { .. } => Yes,
             Naked(..) => No,
+            NoCore(..) => No,
             NoImplicitPrelude(..) => No,
             NoMangle(..) => Yes,      // Needed for rustdoc
             NonExhaustive(..) => Yes, // Needed for rustdoc
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 487bdd2a888e7..cecc8b7fa6ba0 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -274,6 +274,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::MoveSizeLimit { .. }
                     | AttributeKind::TypeLengthLimit { .. }
                     | AttributeKind::PatternComplexityLimit { .. }
+                    | AttributeKind::NoCore { .. }
                 ) => { /* do nothing  */ }
                 Attribute::Unparsed(attr_item) => {
                     style = Some(attr_item.style);

From 0db2eb7734633fe55dacbb05dbc677a079301cab Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Sun, 24 Aug 2025 11:15:09 +0200
Subject: [PATCH 0738/1889] port `#[no_std]` to the new attribute parsing
 infrastructure

---
 .../rustc_attr_parsing/src/attributes/crate_level.rs  | 11 +++++++++++
 compiler/rustc_attr_parsing/src/context.rs            |  3 ++-
 compiler/rustc_hir/src/attrs/data_structures.rs       |  3 +++
 compiler/rustc_hir/src/attrs/encode_cross_crate.rs    |  3 ++-
 compiler/rustc_passes/src/check_attr.rs               |  1 +
 5 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_attr_parsing/src/attributes/crate_level.rs b/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
index d2e28ed97aac0..3ec847bcaae2d 100644
--- a/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
@@ -188,3 +188,14 @@ impl<S: Stage> NoArgsAttributeParser<S> for NoCoreParser {
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::NoCore;
     const TYPE: AttributeType = AttributeType::CrateLevel;
 }
+
+pub(crate) struct NoStdParser;
+impl<S: Stage> NoArgsAttributeParser<S> for NoStdParser {
+    const PATH: &[Symbol] = &[sym::no_std];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    // FIXME: recursion limit is allowed on all targets and ignored,
+    //        even though it should only be valid on crates of course
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::NoStd;
+    const TYPE: AttributeType = AttributeType::CrateLevel;
+}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index 3d532d432b5c3..2e6d840ab5175 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -25,7 +25,7 @@ use crate::attributes::codegen_attrs::{
 };
 use crate::attributes::confusables::ConfusablesParser;
 use crate::attributes::crate_level::{
-    CrateNameParser, MoveSizeLimitParser, NoCoreParser, PatternComplexityLimitParser,
+    CrateNameParser, MoveSizeLimitParser, NoCoreParser, NoStdParser, PatternComplexityLimitParser,
     RecursionLimitParser, TypeLengthLimitParser,
 };
 use crate::attributes::deprecation::DeprecationParser;
@@ -225,6 +225,7 @@ attribute_parsers!(
         Single<WithoutArgs<NoCoreParser>>,
         Single<WithoutArgs<NoImplicitPreludeParser>>,
         Single<WithoutArgs<NoMangleParser>>,
+        Single<WithoutArgs<NoStdParser>>,
         Single<WithoutArgs<NonExhaustiveParser>>,
         Single<WithoutArgs<ParenSugarParser>>,
         Single<WithoutArgs<PassByValueParser>>,
diff --git a/compiler/rustc_hir/src/attrs/data_structures.rs b/compiler/rustc_hir/src/attrs/data_structures.rs
index c2a3844af0226..ea11a99efbc35 100644
--- a/compiler/rustc_hir/src/attrs/data_structures.rs
+++ b/compiler/rustc_hir/src/attrs/data_structures.rs
@@ -588,6 +588,9 @@ pub enum AttributeKind {
     /// Represents `#[no_mangle]`
     NoMangle(Span),
 
+    /// Represents `#[no_std]`
+    NoStd(Span),
+
     /// Represents `#[non_exhaustive]`
     NonExhaustive(Span),
 
diff --git a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
index d46e8abf93781..55521c1585402 100644
--- a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
+++ b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
@@ -66,7 +66,8 @@ impl AttributeKind {
             Naked(..) => No,
             NoCore(..) => No,
             NoImplicitPrelude(..) => No,
-            NoMangle(..) => Yes,      // Needed for rustdoc
+            NoMangle(..) => Yes, // Needed for rustdoc
+            NoStd(..) => No,
             NonExhaustive(..) => Yes, // Needed for rustdoc
             Optimize(..) => No,
             ParenSugar(..) => No,
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index cecc8b7fa6ba0..3b744acbca6bd 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -275,6 +275,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::TypeLengthLimit { .. }
                     | AttributeKind::PatternComplexityLimit { .. }
                     | AttributeKind::NoCore { .. }
+                    | AttributeKind::NoStd { .. }
                 ) => { /* do nothing  */ }
                 Attribute::Unparsed(attr_item) => {
                     style = Some(attr_item.style);

From 90e74de473a1c46f34437c4337fe2f3065800b92 Mon Sep 17 00:00:00 2001
From: beepster4096 <19316085+beepster4096@users.noreply.github.com>
Date: Tue, 9 Sep 2025 16:23:14 -0700
Subject: [PATCH 0739/1889] don't trim paths in mir dumping when filtering and
 at the top of the file

---
 compiler/rustc_middle/src/mir/pretty.rs              | 12 +++++++-----
 ....Test.SimplifyCfg-make_shim.after.panic-abort.mir |  2 +-
 ...Test.SimplifyCfg-make_shim.after.panic-unwind.mir |  2 +-
 ...ace.[String;42].AddMovesForPackedDrops.before.mir |  2 +-
 ..._place.[String].AddMovesForPackedDrops.before.mir |  2 +-
 ..._place.Vec_i32_.AddMovesForPackedDrops.before.mir |  2 +-
 6 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
index a7d99f513a12a..f9d0a5f0a3b66 100644
--- a/compiler/rustc_middle/src/mir/pretty.rs
+++ b/compiler/rustc_middle/src/mir/pretty.rs
@@ -78,8 +78,9 @@ impl<'dis, 'de, 'tcx> MirDumper<'dis, 'de, 'tcx> {
     pub fn new(tcx: TyCtxt<'tcx>, pass_name: &'static str, body: &Body<'tcx>) -> Option<Self> {
         let dump_enabled = if let Some(ref filters) = tcx.sess.opts.unstable_opts.dump_mir {
             // see notes on #41697 below
-            let node_path =
-                ty::print::with_forced_impl_filename_line!(tcx.def_path_str(body.source.def_id()));
+            let node_path = ty::print::with_no_trimmed_paths!(
+                ty::print::with_forced_impl_filename_line!(tcx.def_path_str(body.source.def_id()))
+            );
             filters.split('|').any(|or_filter| {
                 or_filter.split('&').all(|and_filter| {
                     let and_filter_trimmed = and_filter.trim();
@@ -173,9 +174,10 @@ impl<'dis, 'de, 'tcx> MirDumper<'dis, 'de, 'tcx> {
     // trigger `type_of`, and this can run while we are already attempting to evaluate `type_of`.
     pub fn dump_mir_to_writer(&self, body: &Body<'tcx>, w: &mut dyn io::Write) -> io::Result<()> {
         // see notes on #41697 above
-        let def_path = ty::print::with_forced_impl_filename_line!(
-            self.tcx().def_path_str(body.source.def_id())
-        );
+        let def_path =
+            ty::print::with_no_trimmed_paths!(ty::print::with_forced_impl_filename_line!(
+                self.tcx().def_path_str(body.source.def_id())
+            ));
         // ignore-tidy-odd-backticks the literal below is fine
         write!(w, "// MIR for `{def_path}")?;
         match body.source.promoted {
diff --git a/tests/mir-opt/retag.core.ptr-drop_in_place.Test.SimplifyCfg-make_shim.after.panic-abort.mir b/tests/mir-opt/retag.core.ptr-drop_in_place.Test.SimplifyCfg-make_shim.after.panic-abort.mir
index 7be3ab8cbae92..8e47aabb9b9f3 100644
--- a/tests/mir-opt/retag.core.ptr-drop_in_place.Test.SimplifyCfg-make_shim.after.panic-abort.mir
+++ b/tests/mir-opt/retag.core.ptr-drop_in_place.Test.SimplifyCfg-make_shim.after.panic-abort.mir
@@ -1,4 +1,4 @@
-// MIR for `drop_in_place` after SimplifyCfg-make_shim
+// MIR for `std::ptr::drop_in_place` after SimplifyCfg-make_shim
 
 fn drop_in_place(_1: *mut Test) -> () {
     let mut _0: ();
diff --git a/tests/mir-opt/retag.core.ptr-drop_in_place.Test.SimplifyCfg-make_shim.after.panic-unwind.mir b/tests/mir-opt/retag.core.ptr-drop_in_place.Test.SimplifyCfg-make_shim.after.panic-unwind.mir
index 6c3c1aaa2bd2b..2457405d9969a 100644
--- a/tests/mir-opt/retag.core.ptr-drop_in_place.Test.SimplifyCfg-make_shim.after.panic-unwind.mir
+++ b/tests/mir-opt/retag.core.ptr-drop_in_place.Test.SimplifyCfg-make_shim.after.panic-unwind.mir
@@ -1,4 +1,4 @@
-// MIR for `drop_in_place` after SimplifyCfg-make_shim
+// MIR for `std::ptr::drop_in_place` after SimplifyCfg-make_shim
 
 fn drop_in_place(_1: *mut Test) -> () {
     let mut _0: ();
diff --git a/tests/mir-opt/slice_drop_shim.core.ptr-drop_in_place.[String;42].AddMovesForPackedDrops.before.mir b/tests/mir-opt/slice_drop_shim.core.ptr-drop_in_place.[String;42].AddMovesForPackedDrops.before.mir
index 9d5af8e84e4f1..ed3f4788cea7d 100644
--- a/tests/mir-opt/slice_drop_shim.core.ptr-drop_in_place.[String;42].AddMovesForPackedDrops.before.mir
+++ b/tests/mir-opt/slice_drop_shim.core.ptr-drop_in_place.[String;42].AddMovesForPackedDrops.before.mir
@@ -1,4 +1,4 @@
-// MIR for `drop_in_place` before AddMovesForPackedDrops
+// MIR for `std::ptr::drop_in_place` before AddMovesForPackedDrops
 
 fn drop_in_place(_1: *mut [String; 42]) -> () {
     let mut _0: ();
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 144880d15989c..bee671af6dfea 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
@@ -1,4 +1,4 @@
-// MIR for `drop_in_place` before AddMovesForPackedDrops
+// MIR for `std::ptr::drop_in_place` before AddMovesForPackedDrops
 
 fn drop_in_place(_1: *mut [String]) -> () {
     let mut _0: ();
diff --git a/tests/mir-opt/unusual_item_types.core.ptr-drop_in_place.Vec_i32_.AddMovesForPackedDrops.before.mir b/tests/mir-opt/unusual_item_types.core.ptr-drop_in_place.Vec_i32_.AddMovesForPackedDrops.before.mir
index 51ef9f7c068ec..1bdb1c1debdbb 100644
--- a/tests/mir-opt/unusual_item_types.core.ptr-drop_in_place.Vec_i32_.AddMovesForPackedDrops.before.mir
+++ b/tests/mir-opt/unusual_item_types.core.ptr-drop_in_place.Vec_i32_.AddMovesForPackedDrops.before.mir
@@ -1,4 +1,4 @@
-// MIR for `drop_in_place` before AddMovesForPackedDrops
+// MIR for `std::ptr::drop_in_place` before AddMovesForPackedDrops
 
 fn drop_in_place(_1: *mut Vec<i32>) -> () {
     let mut _0: ();

From 4a4b77f1c75e48944507fd69e75db36a1658f800 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Wed, 10 Sep 2025 03:32:06 +0300
Subject: [PATCH 0740/1889] Properly handle normalization

Previously normalization was broken, which caused a lot of fake errors.

This fix most type mismatches of the new solver, and it also reverts many test regressions.

The downside is that now `chalk_ir::TyKind::AssociatedType`/`chalk_ir::TyKind::Alias` cannot be trusted anymore with their roles, namely: `AssociatedType` is always fully normalized and `Alias` only if it can possibly be normalized further. That seems okay as the new solver does not have this distinction at all (due to it being a lazy normalizer), so this will only hold for the migration time. This does mean we have to change some APIs, notably `hir::Type::walk()` and `TyFingerprint`, to treat `Alias` the same as `AssociatedType`.

Another small thing this commit does is to isolate processing of user-written types (currently involving replacing error types and normalizing, but in the future validation will also be needed) to separate functions.
---
 .../rust-analyzer/crates/hir-ty/src/infer.rs  |  50 +++-
 .../crates/hir-ty/src/infer/closure.rs        |  10 +-
 .../crates/hir-ty/src/infer/expr.rs           |   8 +-
 .../crates/hir-ty/src/infer/pat.rs            |   4 +-
 .../crates/hir-ty/src/infer/path.rs           |  17 +-
 .../crates/hir-ty/src/infer/unify.rs          | 244 +++++++++---------
 .../crates/hir-ty/src/method_resolution.rs    |  21 +-
 .../crates/hir-ty/src/tests/macros.rs         |   4 +-
 .../crates/hir-ty/src/tests/never_type.rs     |  24 +-
 .../crates/hir-ty/src/tests/patterns.rs       |   8 +-
 .../crates/hir-ty/src/tests/regression.rs     |  12 +-
 .../hir-ty/src/tests/regression/new_solver.rs |   2 +-
 .../crates/hir-ty/src/tests/simple.rs         |   2 +-
 .../crates/hir-ty/src/tests/traits.rs         |  18 +-
 src/tools/rust-analyzer/crates/hir/src/lib.rs |   9 +-
 15 files changed, 235 insertions(+), 198 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
index 265d1f8541cc8..3d91a2558f0b1 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
@@ -54,6 +54,8 @@ use rustc_hash::{FxHashMap, FxHashSet};
 use stdx::{always, never};
 use triomphe::Arc;
 
+use crate::next_solver::DbInterner;
+use crate::next_solver::mapping::NextSolverToChalk;
 use crate::{
     AliasEq, AliasTy, Binders, ClosureId, Const, DomainGoal, GenericArg, ImplTraitId, ImplTraitIdx,
     IncorrectGenericsLenKind, Interner, Lifetime, OpaqueTyId, ParamLoweringMode,
@@ -922,13 +924,15 @@ impl<'db> InferenceContext<'db> {
         });
         diagnostics.shrink_to_fit();
         for (_, subst) in method_resolutions.values_mut() {
-            *subst = table.resolve_completely(subst.clone());
+            *subst =
+                table.resolve_completely::<_, crate::next_solver::GenericArgs<'db>>(subst.clone());
             *has_errors =
                 *has_errors || subst.type_parameters(Interner).any(|ty| ty.contains_unknown());
         }
         method_resolutions.shrink_to_fit();
         for (_, subst) in assoc_resolutions.values_mut() {
-            *subst = table.resolve_completely(subst.clone());
+            *subst =
+                table.resolve_completely::<_, crate::next_solver::GenericArgs<'db>>(subst.clone());
             *has_errors =
                 *has_errors || subst.type_parameters(Interner).any(|ty| ty.contains_unknown());
         }
@@ -946,7 +950,12 @@ impl<'db> InferenceContext<'db> {
         result.tuple_field_access_types = tuple_field_accesses_rev
             .into_iter()
             .enumerate()
-            .map(|(idx, subst)| (TupleId(idx as u32), table.resolve_completely(subst)))
+            .map(|(idx, subst)| {
+                (
+                    TupleId(idx as u32),
+                    table.resolve_completely::<_, crate::next_solver::GenericArgs<'db>>(subst),
+                )
+            })
             .inspect(|(_, subst)| {
                 *has_errors =
                     *has_errors || subst.type_parameters(Interner).any(|ty| ty.contains_unknown());
@@ -1015,14 +1024,12 @@ impl<'db> InferenceContext<'db> {
         if let Some(self_param) = self.body.self_param
             && let Some(ty) = param_tys.next()
         {
-            let ty = self.insert_type_vars(ty);
-            let ty = self.normalize_associated_types_in(ty);
+            let ty = self.process_user_written_ty(ty);
             self.write_binding_ty(self_param, ty);
         }
         let mut tait_candidates = FxHashSet::default();
         for (ty, pat) in param_tys.zip(&*self.body.params) {
-            let ty = self.insert_type_vars(ty);
-            let ty = self.normalize_associated_types_in(ty);
+            let ty = self.process_user_written_ty(ty);
 
             self.infer_top_pat(*pat, &ty, None);
             if ty
@@ -1073,7 +1080,7 @@ impl<'db> InferenceContext<'db> {
             None => self.result.standard_types.unit.clone(),
         };
 
-        self.return_ty = self.normalize_associated_types_in(return_ty);
+        self.return_ty = self.process_user_written_ty(return_ty);
         self.return_coercion = Some(CoerceMany::new(self.return_ty.clone()));
 
         // Functions might be defining usage sites of TAITs.
@@ -1415,8 +1422,7 @@ impl<'db> InferenceContext<'db> {
     ) -> Ty {
         let ty = self
             .with_ty_lowering(store, type_source, lifetime_elision, |ctx| ctx.lower_ty(type_ref));
-        let ty = self.insert_type_vars(ty);
-        self.normalize_associated_types_in(ty)
+        self.process_user_written_ty(ty)
     }
 
     fn make_body_ty(&mut self, type_ref: TypeRefId) -> Ty {
@@ -1562,15 +1568,35 @@ impl<'db> InferenceContext<'db> {
         ty
     }
 
+    /// Whenever you lower a user-written type, you should call this.
+    fn process_user_written_ty<T, U>(&mut self, ty: T) -> T
+    where
+        T: HasInterner<Interner = Interner> + TypeFoldable<Interner> + ChalkToNextSolver<'db, U>,
+        U: NextSolverToChalk<'db, T> + rustc_type_ir::TypeFoldable<DbInterner<'db>>,
+    {
+        self.table.process_user_written_ty(ty)
+    }
+
+    /// The difference of this method from `process_user_written_ty()` is that this method doesn't register a well-formed obligation,
+    /// while `process_user_written_ty()` should (but doesn't currently).
+    fn process_remote_user_written_ty<T, U>(&mut self, ty: T) -> T
+    where
+        T: HasInterner<Interner = Interner> + TypeFoldable<Interner> + ChalkToNextSolver<'db, U>,
+        U: NextSolverToChalk<'db, T> + rustc_type_ir::TypeFoldable<DbInterner<'db>>,
+    {
+        self.table.process_remote_user_written_ty(ty)
+    }
+
     /// Recurses through the given type, normalizing associated types mentioned
     /// in it by replacing them by type variables and registering obligations to
     /// resolve later. This should be done once for every type we get from some
     /// type annotation (e.g. from a let type annotation, field type or function
     /// call). `make_ty` handles this already, but e.g. for field types we need
     /// to do it as well.
-    fn normalize_associated_types_in<T>(&mut self, ty: T) -> T
+    fn normalize_associated_types_in<T, U>(&mut self, ty: T) -> T
     where
-        T: HasInterner<Interner = Interner> + TypeFoldable<Interner>,
+        T: HasInterner<Interner = Interner> + TypeFoldable<Interner> + ChalkToNextSolver<'db, U>,
+        U: NextSolverToChalk<'db, T> + rustc_type_ir::TypeFoldable<DbInterner<'db>>,
     {
         self.table.normalize_associated_types_in(ty)
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
index 5a69ad68b58e4..fd7e5a6a0e121 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
@@ -53,7 +53,7 @@ pub(super) struct ClosureSignature {
     pub(super) expected_sig: FnPointer,
 }
 
-impl InferenceContext<'_> {
+impl<'db> InferenceContext<'db> {
     pub(super) fn infer_closure(
         &mut self,
         body: &ExprId,
@@ -71,9 +71,13 @@ impl InferenceContext<'_> {
             None => (None, None),
         };
 
-        let ClosureSignature { expected_sig: bound_sig, ret_ty: body_ret_ty } =
+        let ClosureSignature { expected_sig: mut bound_sig, ret_ty: body_ret_ty } =
             self.sig_of_closure(body, ret_type, arg_types, closure_kind, expected_sig);
-        let bound_sig = self.normalize_associated_types_in(bound_sig);
+        bound_sig.substitution.0 = self
+            .normalize_associated_types_in::<_, crate::next_solver::GenericArgs<'db>>(
+                bound_sig.substitution.0,
+            );
+        let bound_sig = bound_sig;
         let sig_ty = TyKind::Function(bound_sig.clone()).intern(Interner);
 
         let (id, ty, resume_yield_tys) = match closure_kind {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
index bfeb5bae851a5..0a58ea11bb871 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
@@ -1419,7 +1419,7 @@ impl InferenceContext<'_> {
             None => self.err_ty(),
         };
 
-        let ret_ty = self.normalize_associated_types_in(ret_ty);
+        let ret_ty = self.process_remote_user_written_ty(ret_ty);
 
         if self.is_builtin_binop(&lhs_ty, &rhs_ty, op) {
             // use knowledge of built-in binary ops, which can sometimes help inference
@@ -1630,8 +1630,7 @@ impl InferenceContext<'_> {
         Some(match res {
             Some((field_id, ty)) => {
                 let adjustments = auto_deref_adjust_steps(&autoderef);
-                let ty = self.insert_type_vars(ty);
-                let ty = self.normalize_associated_types_in(ty);
+                let ty = self.process_remote_user_written_ty(ty);
 
                 (ty, field_id, adjustments, true)
             }
@@ -1641,8 +1640,7 @@ impl InferenceContext<'_> {
                 let ty = self.db.field_types(field_id.parent)[field_id.local_id]
                     .clone()
                     .substitute(Interner, &subst);
-                let ty = self.insert_type_vars(ty);
-                let ty = self.normalize_associated_types_in(ty);
+                let ty = self.process_remote_user_written_ty(ty);
 
                 (ty, Either::Left(field_id), adjustments, false)
             }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/pat.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/pat.rs
index 16489e3068f35..6781bc84d1c11 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/pat.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/pat.rs
@@ -88,7 +88,7 @@ impl InferenceContext<'_> {
                                     Some(substs) => f.substitute(Interner, substs),
                                     None => f.substitute(Interner, &Substitution::empty(Interner)),
                                 };
-                                self.normalize_associated_types_in(expected_ty)
+                                self.process_remote_user_written_ty(expected_ty)
                             }
                             None => self.err_ty(),
                         }
@@ -152,7 +152,7 @@ impl InferenceContext<'_> {
                                     Some(substs) => f.substitute(Interner, substs),
                                     None => f.substitute(Interner, &Substitution::empty(Interner)),
                                 };
-                                self.normalize_associated_types_in(expected_ty)
+                                self.process_remote_user_written_ty(expected_ty)
                             }
                             None => {
                                 self.push_diagnostic(InferenceDiagnostic::NoSuchField {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs
index 1f62f9c4aa113..80f7324e58b2b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs
@@ -23,7 +23,7 @@ use crate::{
 
 use super::{ExprOrPatId, InferenceContext, InferenceTyDiagnosticSource};
 
-impl InferenceContext<'_> {
+impl<'db> InferenceContext<'db> {
     pub(super) fn infer_path(&mut self, path: &Path, id: ExprOrPatId) -> Option<Ty> {
         let (value_def, generic_def, substs) = match self.resolve_value_path(path, id)? {
             ValuePathResolution::GenericDef(value_def, generic_def, substs) => {
@@ -31,13 +31,13 @@ impl InferenceContext<'_> {
             }
             ValuePathResolution::NonGeneric(ty) => return Some(ty),
         };
-        let substs = self.insert_type_vars(substs);
-        let substs = self.normalize_associated_types_in(substs);
+        let substs =
+            self.process_remote_user_written_ty::<_, crate::next_solver::GenericArgs<'db>>(substs);
 
         self.add_required_obligations_for_value_path(generic_def, &substs);
 
         let ty = self.db.value_ty(value_def)?.substitute(Interner, &substs);
-        let ty = self.normalize_associated_types_in(ty);
+        let ty = self.process_remote_user_written_ty(ty);
         Some(ty)
     }
 
@@ -173,14 +173,12 @@ impl InferenceContext<'_> {
             let last = path.segments().last()?;
 
             let (ty, orig_ns) = path_ctx.ty_ctx().lower_ty_ext(type_ref);
-            let ty = self.table.insert_type_vars(ty);
-            let ty = self.table.normalize_associated_types_in(ty);
+            let ty = self.table.process_user_written_ty(ty);
 
             path_ctx.ignore_last_segment();
             let (ty, _) = path_ctx.lower_ty_relative_path(ty, orig_ns, true);
             drop_ctx(ctx, no_diagnostics);
-            let ty = self.table.insert_type_vars(ty);
-            let ty = self.table.normalize_associated_types_in(ty);
+            let ty = self.table.process_user_written_ty(ty);
             self.resolve_ty_assoc_item(ty, last.name, id).map(|(it, substs)| (it, Some(substs)))?
         } else {
             let hygiene = self.body.expr_or_pat_path_hygiene(id);
@@ -223,8 +221,7 @@ impl InferenceContext<'_> {
                                 return None;
                             }
 
-                            let ty = self.insert_type_vars(ty);
-                            let ty = self.normalize_associated_types_in(ty);
+                            let ty = self.process_user_written_ty(ty);
 
                             self.resolve_ty_assoc_item(ty, last_segment.name, id)
                         }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
index ec4b7ee85dc67..19b83d3c212df 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
@@ -12,12 +12,14 @@ use hir_expand::name::Name;
 use intern::sym;
 use rustc_hash::{FxHashMap, FxHashSet};
 use rustc_next_trait_solver::solve::HasChanged;
+use rustc_type_ir::inherent::IntoKind;
 use rustc_type_ir::{
     AliasRelationDirection, FloatVid, IntVid, TyVid,
     inherent::{Span, Term as _},
     relate::{Relate, solver_relating::RelateExt},
     solve::{Certainty, NoSolution},
 };
+use rustc_type_ir::{TypeSuperFoldable, TypeVisitableExt};
 use smallvec::SmallVec;
 use triomphe::Arc;
 
@@ -31,11 +33,8 @@ use crate::{
     db::HirDatabase,
     fold_generic_args, fold_tys_and_consts,
     next_solver::{
-        self, Binder, DbInterner, ParamEnvAnd, Predicate, PredicateKind, SolverDefIds, Term,
-        infer::{
-            DbInternerInferExt, InferCtxt, canonical::canonicalizer::OriginalQueryValues,
-            snapshot::CombinedSnapshot,
-        },
+        self, Binder, DbInterner, Predicate, PredicateKind, SolverDefIds, Term,
+        infer::{DbInternerInferExt, InferCtxt, snapshot::CombinedSnapshot},
         mapping::{ChalkToNextSolver, InferenceVarExt, NextSolverToChalk},
     },
     to_chalk_trait_id,
@@ -305,116 +304,21 @@ impl<'a> InferenceTable<'a> {
     /// type annotation (e.g. from a let type annotation, field type or function
     /// call). `make_ty` handles this already, but e.g. for field types we need
     /// to do it as well.
-    #[tracing::instrument(skip(self), ret)]
-    pub(crate) fn normalize_associated_types_in<T>(&mut self, ty: T) -> T
+    pub(crate) fn normalize_associated_types_in<T, U>(&mut self, ty: T) -> T
     where
-        T: HasInterner<Interner = Interner> + TypeFoldable<Interner>,
+        T: ChalkToNextSolver<'a, U>,
+        U: NextSolverToChalk<'a, T> + rustc_type_ir::TypeFoldable<DbInterner<'a>>,
     {
-        fold_tys_and_consts(
-            ty,
-            |e, _| match e {
-                Either::Left(ty) => {
-                    let ty = self.resolve_ty_shallow(&ty);
-                    tracing::debug!(?ty);
-                    Either::Left(match ty.kind(Interner) {
-                        TyKind::Alias(AliasTy::Projection(proj_ty)) => {
-                            let ty = self.normalize_projection_ty(proj_ty.clone());
-                            self.resolve_ty_shallow(&ty)
-                        }
-                        TyKind::AssociatedType(id, subst) => {
-                            // return Either::Left(self.resolve_ty_shallow(&ty));
-                            if ty.data(Interner).flags.intersects(
-                                chalk_ir::TypeFlags::HAS_TY_INFER
-                                    | chalk_ir::TypeFlags::HAS_CT_INFER,
-                            ) {
-                                return Either::Left(ty);
-                            }
-                            let var = self.new_type_var();
-                            let proj_ty = chalk_ir::ProjectionTy {
-                                associated_ty_id: *id,
-                                substitution: subst.clone(),
-                            };
-                            let normalize = chalk_ir::Normalize {
-                                alias: AliasTy::Projection(proj_ty),
-                                ty: var.clone(),
-                            };
-                            let goal = chalk_ir::Goal::new(
-                                Interner,
-                                chalk_ir::GoalData::DomainGoal(chalk_ir::DomainGoal::Normalize(
-                                    normalize,
-                                )),
-                            );
-                            let in_env = InEnvironment::new(&self.trait_env.env, goal);
-                            let goal = in_env.to_nextsolver(self.interner);
-                            let goal =
-                                ParamEnvAnd { param_env: goal.param_env, value: goal.predicate };
-
-                            let (canonical_goal, orig_values) = {
-                                let mut orig_values = OriginalQueryValues::default();
-                                let result =
-                                    self.infer_ctxt.canonicalize_query(goal, &mut orig_values);
-                                (result.canonical, orig_values)
-                            };
-                            let canonical_goal = rustc_type_ir::Canonical {
-                                max_universe: canonical_goal.max_universe,
-                                variables: canonical_goal.variables,
-                                value: crate::next_solver::Goal {
-                                    param_env: canonical_goal.value.param_env,
-                                    predicate: canonical_goal.value.value,
-                                },
-                            };
-                            let solution = next_trait_solve_canonical_in_ctxt(
-                                &self.infer_ctxt,
-                                canonical_goal,
-                            );
-                            if let NextTraitSolveResult::Certain(canonical_subst) = solution {
-                                let subst = self.instantiate_canonical(canonical_subst).subst;
-                                if subst.len(Interner) != orig_values.var_values.len() {
-                                    ty
-                                } else {
-                                    let target_ty = var.to_nextsolver(self.interner);
-                                    subst
-                                        .iter(Interner)
-                                        .zip(orig_values.var_values.iter())
-                                        .find_map(|(new, orig)| {
-                                            if orig.ty() == Some(target_ty) {
-                                                Some(new.assert_ty_ref(Interner).clone())
-                                            } else {
-                                                None
-                                            }
-                                        })
-                                        .unwrap_or(ty)
-                                }
-                            } else {
-                                ty
-                            }
-                        }
-                        _ => ty,
-                    })
-                }
-                Either::Right(c) => Either::Right(match &c.data(Interner).value {
-                    chalk_ir::ConstValue::Concrete(cc) => match &cc.interned {
-                        crate::ConstScalar::UnevaluatedConst(c_id, subst) => {
-                            // FIXME: Ideally here we should do everything that we do with type alias, i.e. adding a variable
-                            // and registering an obligation. But it needs chalk support, so we handle the most basic
-                            // case (a non associated const without generic parameters) manually.
-                            if subst.len(Interner) == 0 {
-                                if let Ok(eval) = self.db.const_eval(*c_id, subst.clone(), None) {
-                                    eval
-                                } else {
-                                    unknown_const(c.data(Interner).ty.clone())
-                                }
-                            } else {
-                                unknown_const(c.data(Interner).ty.clone())
-                            }
-                        }
-                        _ => c,
-                    },
-                    _ => c,
-                }),
-            },
-            DebruijnIndex::INNERMOST,
-        )
+        self.normalize_associated_types_in_ns(ty.to_nextsolver(self.interner))
+            .to_chalk(self.interner)
+    }
+
+    pub(crate) fn normalize_associated_types_in_ns<T>(&mut self, ty: T) -> T
+    where
+        T: rustc_type_ir::TypeFoldable<DbInterner<'a>>,
+    {
+        let ty = self.resolve_vars_with_obligations(ty);
+        ty.fold_with(&mut Normalizer { table: self })
     }
 
     /// Works almost same as [`Self::normalize_associated_types_in`], but this also resolves shallow
@@ -476,11 +380,27 @@ impl<'a> InferenceTable<'a> {
     }
 
     pub(crate) fn normalize_projection_ty(&mut self, proj_ty: ProjectionTy) -> Ty {
-        let var = self.new_type_var();
-        let alias_eq = AliasEq { alias: AliasTy::Projection(proj_ty), ty: var.clone() };
-        let obligation: Goal = alias_eq.cast(Interner);
-        self.register_obligation(obligation.to_nextsolver(self.interner));
-        var
+        let ty = TyKind::Alias(chalk_ir::AliasTy::Projection(proj_ty))
+            .intern(Interner)
+            .to_nextsolver(self.interner);
+        self.normalize_alias_ty(ty).to_chalk(self.interner)
+    }
+
+    pub(crate) fn normalize_alias_ty(
+        &mut self,
+        alias: crate::next_solver::Ty<'a>,
+    ) -> crate::next_solver::Ty<'a> {
+        let infer_term = self.infer_ctxt.next_ty_var();
+        let obligation = crate::next_solver::Predicate::new(
+            self.interner,
+            crate::next_solver::Binder::dummy(crate::next_solver::PredicateKind::AliasRelate(
+                alias.into(),
+                infer_term.into(),
+                rustc_type_ir::AliasRelationDirection::Equate,
+            )),
+        );
+        self.register_obligation(obligation);
+        self.resolve_vars_with_obligations(infer_term)
     }
 
     fn new_var(&mut self, kind: TyVariableKind, diverging: bool) -> Ty {
@@ -591,9 +511,10 @@ impl<'a> InferenceTable<'a> {
         )
     }
 
-    pub(crate) fn resolve_completely<T>(&mut self, t: T) -> T
+    pub(crate) fn resolve_completely<T, U>(&mut self, t: T) -> T
     where
-        T: HasInterner<Interner = Interner> + TypeFoldable<Interner>,
+        T: HasInterner<Interner = Interner> + TypeFoldable<Interner> + ChalkToNextSolver<'a, U>,
+        U: NextSolverToChalk<'a, T> + rustc_type_ir::TypeFoldable<DbInterner<'a>>,
     {
         let t = self.resolve_with_fallback(t, &|_, _, d, _| d);
         let t = self.normalize_associated_types_in(t);
@@ -1045,6 +966,30 @@ impl<'a> InferenceTable<'a> {
         }
     }
 
+    /// Whenever you lower a user-written type, you should call this.
+    pub(crate) fn process_user_written_ty<T, U>(&mut self, ty: T) -> T
+    where
+        T: HasInterner<Interner = Interner> + TypeFoldable<Interner> + ChalkToNextSolver<'a, U>,
+        U: NextSolverToChalk<'a, T> + rustc_type_ir::TypeFoldable<DbInterner<'a>>,
+    {
+        self.process_remote_user_written_ty(ty)
+        // FIXME: Register a well-formed obligation.
+    }
+
+    /// The difference of this method from `process_user_written_ty()` is that this method doesn't register a well-formed obligation,
+    /// while `process_user_written_ty()` should (but doesn't currently).
+    pub(crate) fn process_remote_user_written_ty<T, U>(&mut self, ty: T) -> T
+    where
+        T: HasInterner<Interner = Interner> + TypeFoldable<Interner> + ChalkToNextSolver<'a, U>,
+        U: NextSolverToChalk<'a, T> + rustc_type_ir::TypeFoldable<DbInterner<'a>>,
+    {
+        let ty = self.insert_type_vars(ty);
+        // See https://github.com/rust-lang/rust/blob/cdb45c87e2cd43495379f7e867e3cc15dcee9f93/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs#L487-L495:
+        // Even though the new solver only lazily normalizes usually, here we eagerly normalize so that not everything needs
+        // to normalize before inspecting the `TyKind`.
+        self.normalize_associated_types_in(ty)
+    }
+
     /// Replaces ConstScalar::Unknown by a new type var, so we can maybe still infer it.
     pub(super) fn insert_const_vars_shallow(&mut self, c: Const) -> Const {
         let data = c.data(Interner);
@@ -1319,3 +1264,62 @@ mod resolve {
         }
     }
 }
+
+/// This expects its input to be resolved.
+struct Normalizer<'a, 'b> {
+    table: &'a mut InferenceTable<'b>,
+}
+
+impl<'db> Normalizer<'_, 'db> {
+    fn normalize_alias_term(
+        &mut self,
+        alias_term: crate::next_solver::Term<'db>,
+    ) -> crate::next_solver::Term<'db> {
+        let infer_term = self.table.infer_ctxt.next_term_var_of_kind(alias_term);
+        let obligation = crate::next_solver::Predicate::new(
+            self.table.interner,
+            crate::next_solver::Binder::dummy(crate::next_solver::PredicateKind::AliasRelate(
+                alias_term,
+                infer_term,
+                rustc_type_ir::AliasRelationDirection::Equate,
+            )),
+        );
+        self.table.register_obligation(obligation);
+        let term = self.table.resolve_vars_with_obligations(infer_term);
+        // Now normalize the result, because maybe it contains more aliases.
+        match term {
+            Term::Ty(term) => term.super_fold_with(self).into(),
+            Term::Const(term) => term.super_fold_with(self).into(),
+        }
+    }
+}
+
+impl<'db> rustc_type_ir::TypeFolder<DbInterner<'db>> for Normalizer<'_, 'db> {
+    fn cx(&self) -> DbInterner<'db> {
+        self.table.interner
+    }
+
+    fn fold_ty(&mut self, ty: crate::next_solver::Ty<'db>) -> crate::next_solver::Ty<'db> {
+        if !ty.has_aliases() {
+            return ty;
+        }
+
+        let crate::next_solver::TyKind::Alias(..) = ty.kind() else {
+            return ty.super_fold_with(self);
+        };
+        // FIXME: Handle escaping bound vars by replacing them with placeholders (relevant to when we handle HRTB only).
+        self.normalize_alias_term(ty.into()).expect_type()
+    }
+
+    fn fold_const(&mut self, ct: crate::next_solver::Const<'db>) -> crate::next_solver::Const<'db> {
+        if !ct.has_aliases() {
+            return ct;
+        }
+
+        let crate::next_solver::ConstKind::Unevaluated(..) = ct.kind() else {
+            return ct.super_fold_with(self);
+        };
+        // FIXME: Handle escaping bound vars by replacing them with placeholders (relevant to when we handle HRTB only).
+        self.normalize_alias_term(ct.into()).expect_const()
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
index fa80567b1ecc0..a234312173a23 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
@@ -22,10 +22,9 @@ use stdx::never;
 use triomphe::Arc;
 
 use crate::{
-    AdtId, AliasTy, Canonical, CanonicalVarKinds, DebruijnIndex, DynTyExt, ForeignDefId,
-    GenericArgData, Goal, InEnvironment, Interner, Mutability, Scalar, Substitution,
-    TraitEnvironment, TraitRef, TraitRefExt, Ty, TyBuilder, TyExt, TyKind, TyVariableKind,
-    VariableKind, WhereClause,
+    AdtId, Canonical, CanonicalVarKinds, DebruijnIndex, DynTyExt, ForeignDefId, GenericArgData,
+    Goal, InEnvironment, Interner, Mutability, Scalar, Substitution, TraitEnvironment, TraitRef,
+    TraitRefExt, Ty, TyBuilder, TyExt, TyKind, TyVariableKind, VariableKind, WhereClause,
     autoderef::{self, AutoderefKind},
     db::HirDatabase,
     from_chalk_trait_id, from_foreign_def_id,
@@ -106,8 +105,12 @@ impl TyFingerprint {
                 }
             }
             TyKind::AssociatedType(_, _)
+            // FIXME(next-solver): Putting `Alias` here is *probably* incorrect, AFAIK it should return `None`. But this breaks
+            // flyimport, which uses an incorrect but fast method resolution algorithm. Therefore we put it here,
+            // because this function is only called by flyimport, and anyway we should get rid of `TyFingerprint`
+            // and switch to `rustc_type_ir`'s `SimplifiedType`.
+            | TyKind::Alias(_)
             | TyKind::OpaqueType(_, _)
-            | TyKind::Alias(AliasTy::Opaque(_))
             | TyKind::FnDef(_, _)
             | TyKind::Closure(_, _)
             | TyKind::Coroutine(..)
@@ -115,8 +118,7 @@ impl TyFingerprint {
             TyKind::Function(fn_ptr) => {
                 TyFingerprint::Function(fn_ptr.substitution.0.len(Interner) as u32)
             }
-            TyKind::Alias(_)
-            | TyKind::Placeholder(_)
+            TyKind::Placeholder(_)
             | TyKind::BoundVar(_)
             | TyKind::InferenceVar(_, _)
             | TyKind::Error => return None,
@@ -908,7 +910,10 @@ fn find_matching_impl(
                 }
                 table.register_obligation(goal.to_nextsolver(table.interner));
             }
-            Some((impl_.impl_items(db), table.resolve_completely(impl_substs)))
+            Some((
+                impl_.impl_items(db),
+                table.resolve_completely::<_, crate::next_solver::GenericArgs<'_>>(impl_substs),
+            ))
         })
     })
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/macros.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/macros.rs
index 6490554b22b7d..5d088e40cdeda 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/macros.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/macros.rs
@@ -202,7 +202,7 @@ fn expr_macro_def_expanded_in_various_places() {
             100..119 'for _ ...!() {}': {unknown}
             100..119 'for _ ...!() {}': &'? mut {unknown}
             100..119 'for _ ...!() {}': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
-            100..119 'for _ ...!() {}': Option<<{unknown} as Iterator>::Item>
+            100..119 'for _ ...!() {}': Option<{unknown}>
             100..119 'for _ ...!() {}': ()
             100..119 'for _ ...!() {}': ()
             100..119 'for _ ...!() {}': ()
@@ -296,7 +296,7 @@ fn expr_macro_rules_expanded_in_various_places() {
             114..133 'for _ ...!() {}': {unknown}
             114..133 'for _ ...!() {}': &'? mut {unknown}
             114..133 'for _ ...!() {}': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
-            114..133 'for _ ...!() {}': Option<<{unknown} as Iterator>::Item>
+            114..133 'for _ ...!() {}': Option<{unknown}>
             114..133 'for _ ...!() {}': ()
             114..133 'for _ ...!() {}': ()
             114..133 'for _ ...!() {}': ()
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/never_type.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/never_type.rs
index baca7f2318e22..6a9135622deb6 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/never_type.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/never_type.rs
@@ -362,12 +362,12 @@ fn diverging_expression_3_break() {
             140..141 'x': u32
             149..175 '{ for ...; }; }': u32
             151..172 'for a ...eak; }': fn into_iter<{unknown}>({unknown}) -> <{unknown} as IntoIterator>::IntoIter
-            151..172 'for a ...eak; }': <{unknown} as IntoIterator>::IntoIter
+            151..172 'for a ...eak; }': {unknown}
             151..172 'for a ...eak; }': !
-            151..172 'for a ...eak; }': <{unknown} as IntoIterator>::IntoIter
-            151..172 'for a ...eak; }': &'? mut <{unknown} as IntoIterator>::IntoIter
+            151..172 'for a ...eak; }': {unknown}
+            151..172 'for a ...eak; }': &'? mut {unknown}
             151..172 'for a ...eak; }': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
-            151..172 'for a ...eak; }': Option<<{unknown} as Iterator>::Item>
+            151..172 'for a ...eak; }': Option<{unknown}>
             151..172 'for a ...eak; }': ()
             151..172 'for a ...eak; }': ()
             151..172 'for a ...eak; }': ()
@@ -379,12 +379,12 @@ fn diverging_expression_3_break() {
             226..227 'x': u32
             235..253 '{ for ... {}; }': u32
             237..250 'for a in b {}': fn into_iter<{unknown}>({unknown}) -> <{unknown} as IntoIterator>::IntoIter
-            237..250 'for a in b {}': <{unknown} as IntoIterator>::IntoIter
+            237..250 'for a in b {}': {unknown}
             237..250 'for a in b {}': !
-            237..250 'for a in b {}': <{unknown} as IntoIterator>::IntoIter
-            237..250 'for a in b {}': &'? mut <{unknown} as IntoIterator>::IntoIter
+            237..250 'for a in b {}': {unknown}
+            237..250 'for a in b {}': &'? mut {unknown}
             237..250 'for a in b {}': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
-            237..250 'for a in b {}': Option<<{unknown} as Iterator>::Item>
+            237..250 'for a in b {}': Option<{unknown}>
             237..250 'for a in b {}': ()
             237..250 'for a in b {}': ()
             237..250 'for a in b {}': ()
@@ -395,12 +395,12 @@ fn diverging_expression_3_break() {
             304..305 'x': u32
             313..340 '{ for ...; }; }': u32
             315..337 'for a ...urn; }': fn into_iter<{unknown}>({unknown}) -> <{unknown} as IntoIterator>::IntoIter
-            315..337 'for a ...urn; }': <{unknown} as IntoIterator>::IntoIter
+            315..337 'for a ...urn; }': {unknown}
             315..337 'for a ...urn; }': !
-            315..337 'for a ...urn; }': <{unknown} as IntoIterator>::IntoIter
-            315..337 'for a ...urn; }': &'? mut <{unknown} as IntoIterator>::IntoIter
+            315..337 'for a ...urn; }': {unknown}
+            315..337 'for a ...urn; }': &'? mut {unknown}
             315..337 'for a ...urn; }': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
-            315..337 'for a ...urn; }': Option<<{unknown} as Iterator>::Item>
+            315..337 'for a ...urn; }': Option<{unknown}>
             315..337 'for a ...urn; }': ()
             315..337 'for a ...urn; }': ()
             315..337 'for a ...urn; }': ()
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/patterns.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/patterns.rs
index 60a2641e1a20e..02cb03706919b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/patterns.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/patterns.rs
@@ -48,12 +48,12 @@ fn infer_pattern() {
             83..84 '1': i32
             86..93 '"hello"': &'static str
             101..151 'for (e...     }': fn into_iter<{unknown}>({unknown}) -> <{unknown} as IntoIterator>::IntoIter
-            101..151 'for (e...     }': <{unknown} as IntoIterator>::IntoIter
+            101..151 'for (e...     }': {unknown}
             101..151 'for (e...     }': !
-            101..151 'for (e...     }': <{unknown} as IntoIterator>::IntoIter
-            101..151 'for (e...     }': &'? mut <{unknown} as IntoIterator>::IntoIter
+            101..151 'for (e...     }': {unknown}
+            101..151 'for (e...     }': &'? mut {unknown}
             101..151 'for (e...     }': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
-            101..151 'for (e...     }': Option<<{unknown} as Iterator>::Item>
+            101..151 'for (e...     }': Option<({unknown}, {unknown})>
             101..151 'for (e...     }': ()
             101..151 'for (e...     }': ()
             101..151 'for (e...     }': ()
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
index eacc4603ea1af..6a3f2286215f4 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
@@ -268,12 +268,12 @@ fn infer_std_crash_5() {
         expect![[r#"
             26..322 '{     ...   } }': ()
             32..320 'for co...     }': fn into_iter<{unknown}>({unknown}) -> <{unknown} as IntoIterator>::IntoIter
-            32..320 'for co...     }': <{unknown} as IntoIterator>::IntoIter
+            32..320 'for co...     }': {unknown}
             32..320 'for co...     }': !
-            32..320 'for co...     }': <{unknown} as IntoIterator>::IntoIter
-            32..320 'for co...     }': &'? mut <{unknown} as IntoIterator>::IntoIter
+            32..320 'for co...     }': {unknown}
+            32..320 'for co...     }': &'? mut {unknown}
             32..320 'for co...     }': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
-            32..320 'for co...     }': Option<<{unknown} as Iterator>::Item>
+            32..320 'for co...     }': Option<{unknown}>
             32..320 'for co...     }': ()
             32..320 'for co...     }': ()
             32..320 'for co...     }': ()
@@ -628,7 +628,7 @@ fn issue_4053_diesel_where_clauses() {
             65..69 'self': Self
             267..271 'self': Self
             466..470 'self': SelectStatement<F, S, D, W, O, LOf, {unknown}, {unknown}>
-            488..522 '{     ...     }': <SelectStatement<F, S, D, W, O, LOf, {unknown}, {unknown}> as BoxedDsl<DB>>::Output
+            488..522 '{     ...     }': ()
             498..502 'self': SelectStatement<F, S, D, W, O, LOf, {unknown}, {unknown}>
             498..508 'self.order': O
             498..515 'self.o...into()': dyn QueryFragment<DB> + '?
@@ -1248,7 +1248,7 @@ fn test() {
             16..66 'for _ ...     }': {unknown}
             16..66 'for _ ...     }': &'? mut {unknown}
             16..66 'for _ ...     }': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
-            16..66 'for _ ...     }': Option<<{unknown} as Iterator>::Item>
+            16..66 'for _ ...     }': Option<{unknown}>
             16..66 'for _ ...     }': ()
             16..66 'for _ ...     }': ()
             16..66 'for _ ...     }': ()
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
index 471108d964f6e..6d6c56696a30d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
@@ -20,7 +20,7 @@ impl<'a> IntoIterator for &'a Grid {
     "#,
         expect![[r#"
             150..154 'self': &'a Grid
-            174..181 '{     }': impl Iterator<Item = &'? ()>
+            174..181 '{     }': impl Iterator<Item = &'a ()>
         "#]],
     );
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/simple.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/simple.rs
index e7357ed5aa78b..60ad0f49c6ab0 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/simple.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/simple.rs
@@ -2000,7 +2000,7 @@ fn test() {
             225..360 'match ...     }': ()
             231..239 'Pin::new': fn new<&'? mut |usize| yields i64 -> &'static str>(&'? mut |usize| yields i64 -> &'static str) -> Pin<&'? mut |usize| yields i64 -> &'static str>
             231..247 'Pin::n...mut g)': Pin<&'? mut |usize| yields i64 -> &'static str>
-            231..262 'Pin::n...usize)': CoroutineState<i64, &'? str>
+            231..262 'Pin::n...usize)': CoroutineState<i64, &'static str>
             240..246 '&mut g': &'? mut |usize| yields i64 -> &'static str
             245..246 'g': |usize| yields i64 -> &'static str
             255..261 '0usize': usize
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
index 7a946f7ec7ced..22332fdc2b8aa 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
@@ -4190,8 +4190,6 @@ fn g<P: PointerFamily>(p: <P as PointerFamily>::Pointer<i32>) {
     );
 }
 
-// FIXME(next-solver): Was `&'a T` but now getting error lifetime.
-// This might be fixed once we migrate into next-solver fully without chalk-ir in lowering.
 #[test]
 fn gats_with_impl_trait() {
     // FIXME: the last function (`fn i()`) is not valid Rust as of this writing because you cannot
@@ -4215,21 +4213,21 @@ fn f<T>(v: impl Trait) {
 }
 fn g<'a, T: 'a>(v: impl Trait<Assoc<T> = &'a T>) {
     let a = v.get::<T>();
-      //^ &'? T
+      //^ &'a T
     let a = v.get::<()>();
       //^ <impl Trait<Assoc<T> = &'a T> as Trait>::Assoc<()>
 }
 fn h<'a>(v: impl Trait<Assoc<i32> = &'a i32> + Trait<Assoc<i64> = &'a i64>) {
     let a = v.get::<i32>();
-      //^ &'? i32
+      //^ &'a i32
     let a = v.get::<i64>();
-      //^ &'? i64
+      //^ &'a i64
 }
 fn i<'a>(v: impl Trait<Assoc<i32> = &'a i32, Assoc<i64> = &'a i64>) {
     let a = v.get::<i32>();
-      //^ &'? i32
+      //^ &'a i32
     let a = v.get::<i64>();
-      //^ &'? i64
+      //^ &'a i64
 }
     "#,
     );
@@ -4259,8 +4257,8 @@ fn f<'a>(v: &dyn Trait<Assoc<i32> = &'a i32>) {
             127..128 'v': &'? (dyn Trait<Assoc<i32> = &'a i32> + '?)
             164..195 '{     ...f(); }': ()
             170..171 'v': &'? (dyn Trait<Assoc<i32> = &'a i32> + '?)
-            170..184 'v.get::<i32>()': <dyn Trait<Assoc<i32> = &'a i32> + '? as Trait>::Assoc<i32>
-            170..192 'v.get:...eref()': {unknown}
+            170..184 'v.get::<i32>()': {unknown}
+            170..192 'v.get:...eref()': &'? {unknown}
         "#]],
     );
 }
@@ -4953,7 +4951,7 @@ where
 "#,
         expect![[r#"
             84..86 'de': D
-            135..138 '{ }': <D as Deserializer<'?>>::Error
+            135..138 '{ }': <D as Deserializer<'de>>::Error
         "#]],
     );
 }
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index 52ab808d22841..888392b0ff207 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -76,7 +76,7 @@ use hir_expand::{
 };
 use hir_ty::{
     AliasTy, CallableSig, Canonical, CanonicalVarKinds, Cast, ClosureId, GenericArg,
-    GenericArgData, Interner, ParamKind, QuantifiedWhereClause, Scalar, Substitution,
+    GenericArgData, Interner, ParamKind, ProjectionTy, QuantifiedWhereClause, Scalar, Substitution,
     TraitEnvironment, TraitRefExt, Ty, TyBuilder, TyDefId, TyExt, TyKind, TyLoweringDiagnostic,
     ValueTyDefId, WhereClause, all_super_traits, autoderef, check_orphan_rules,
     consteval::{ConstExt, try_const_usize, unknown_const_as_generic},
@@ -4973,6 +4973,7 @@ impl<'db> Type<'db> {
                 | TyKind::Tuple(_, substitution)
                 | TyKind::OpaqueType(_, substitution)
                 | TyKind::AssociatedType(_, substitution)
+                | TyKind::Alias(AliasTy::Projection(ProjectionTy { substitution, .. }))
                 | TyKind::FnDef(_, substitution) => {
                     substitution.iter(Interner).filter_map(|x| x.ty(Interner)).any(|ty| go(db, ty))
                 }
@@ -5819,7 +5820,11 @@ impl<'db> Type<'db> {
                     cb(type_.derived(ty.clone()));
                     walk_substs(db, type_, substs, cb);
                 }
-                TyKind::AssociatedType(_, substs) => {
+                TyKind::AssociatedType(_, substs)
+                | TyKind::Alias(AliasTy::Projection(hir_ty::ProjectionTy {
+                    substitution: substs,
+                    ..
+                })) => {
                     if ty.associated_type_parent_trait(db).is_some() {
                         cb(type_.derived(ty.clone()));
                     }

From b2b33f9faab81507abda08d025c0680eb8d4995d Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Wed, 10 Sep 2025 04:51:33 +0300
Subject: [PATCH 0741/1889] Always coerce in a cast, even when there are
 unknown types

This cause the relationships between inference vars to get recorded.
---
 .../crates/hir-ty/src/infer/cast.rs            | 13 +++++++------
 .../hir-ty/src/tests/regression/new_solver.rs  | 18 ++++++++++++++++++
 2 files changed, 25 insertions(+), 6 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs
index 43364963eb054..bc3ee3c4c54d9 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs
@@ -106,6 +106,13 @@ impl CastCheck {
         self.expr_ty = table.eagerly_normalize_and_resolve_shallow_in(self.expr_ty.clone());
         self.cast_ty = table.eagerly_normalize_and_resolve_shallow_in(self.cast_ty.clone());
 
+        // This should always come first so that we apply the coercion, which impacts infer vars.
+        if let Ok((adj, _)) = table.coerce(&self.expr_ty, &self.cast_ty, CoerceNever::Yes) {
+            apply_adjustments(self.source_expr, adj);
+            set_coercion_cast(self.source_expr);
+            return Ok(());
+        }
+
         if self.expr_ty.contains_unknown() || self.cast_ty.contains_unknown() {
             return Ok(());
         }
@@ -126,12 +133,6 @@ impl CastCheck {
             return Ok(());
         }
 
-        if let Ok((adj, _)) = table.coerce(&self.expr_ty, &self.cast_ty, CoerceNever::Yes) {
-            apply_adjustments(self.source_expr, adj);
-            set_coercion_cast(self.source_expr);
-            return Ok(());
-        }
-
         self.do_check(table, apply_adjustments)
             .map_err(|e| e.into_diagnostic(self.expr, self.expr_ty.clone(), self.cast_ty.clone()))
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
index 6d6c56696a30d..4df788638a315 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
@@ -98,3 +98,21 @@ fn main() {
     "#,
     );
 }
+
+#[test]
+fn cast_error_type() {
+    check_infer(
+        r#"
+fn main() {
+  let foo: [_; _] = [false] as _;
+}
+    "#,
+        expect![[r#"
+            10..47 '{   le...s _; }': ()
+            18..21 'foo': [bool; 1]
+            32..39 '[false]': [bool; 1]
+            32..44 '[false] as _': [bool; 1]
+            33..38 'false': bool
+        "#]],
+    );
+}

From ef7b036458552bb5a2ab1cdef8e39a17d9f68839 Mon Sep 17 00:00:00 2001
From: Georg Semmler <github@weiznich.de>
Date: Wed, 10 Sep 2025 07:55:03 +0200
Subject: [PATCH 0742/1889] Add suggestions

---
 library/std/src/sync/barrier.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/library/std/src/sync/barrier.rs b/library/std/src/sync/barrier.rs
index 47d63c57ff1e8..8988126bd90c0 100644
--- a/library/std/src/sync/barrier.rs
+++ b/library/std/src/sync/barrier.rs
@@ -1,6 +1,5 @@
-use core::panic::RefUnwindSafe;
-
 use crate::fmt;
+use crate::panic::RefUnwindSafe;
 use crate::sync::nonpoison::{Condvar, Mutex};
 
 /// A barrier enables multiple threads to synchronize the beginning
@@ -33,7 +32,7 @@ pub struct Barrier {
     num_threads: usize,
 }
 
-#[stable(feature = "rust1", since = "1.0.0")]
+#[stable(feature = "unwind_safe_lock_refs", since = "1.12.0")]
 impl RefUnwindSafe for Barrier {}
 
 // The inner state of a double barrier

From 64ea775d27599a33b070dd3aa4353e1e7faee0b4 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 8 Sep 2025 15:56:48 +0200
Subject: [PATCH 0743/1889] interpret: copy_provenance: avoid large
 intermediate buffer for large repeat counts

---
 .../rustc_const_eval/src/interpret/memory.rs  |   4 +-
 compiler/rustc_data_structures/src/lib.rs     |   1 +
 .../rustc_data_structures/src/sorted_map.rs   |  33 +++---
 .../src/sorted_map/tests.rs                   |  10 +-
 .../src/mir/interpret/allocation.rs           |   9 +-
 .../interpret/allocation/provenance_map.rs    | 105 ++++++++----------
 6 files changed, 81 insertions(+), 81 deletions(-)

diff --git a/compiler/rustc_const_eval/src/interpret/memory.rs b/compiler/rustc_const_eval/src/interpret/memory.rs
index 6ec85648d6d88..43bcd34eb36de 100644
--- a/compiler/rustc_const_eval/src/interpret/memory.rs
+++ b/compiler/rustc_const_eval/src/interpret/memory.rs
@@ -1503,7 +1503,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         // This will also error if copying partial provenance is not supported.
         let provenance = src_alloc
             .provenance()
-            .prepare_copy(src_range, dest_offset, num_copies, self)
+            .prepare_copy(src_range, self)
             .map_err(|e| e.to_interp_error(src_alloc_id))?;
         // Prepare a copy of the initialization mask.
         let init = src_alloc.init_mask().prepare_copy(src_range);
@@ -1589,7 +1589,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             num_copies,
         );
         // copy the provenance to the destination
-        dest_alloc.provenance_apply_copy(provenance);
+        dest_alloc.provenance_apply_copy(provenance, alloc_range(dest_offset, size), num_copies);
 
         interp_ok(())
     }
diff --git a/compiler/rustc_data_structures/src/lib.rs b/compiler/rustc_data_structures/src/lib.rs
index 17da3ea83c819..e4e86bcc41aa6 100644
--- a/compiler/rustc_data_structures/src/lib.rs
+++ b/compiler/rustc_data_structures/src/lib.rs
@@ -34,6 +34,7 @@
 #![feature(sized_hierarchy)]
 #![feature(test)]
 #![feature(thread_id_value)]
+#![feature(trusted_len)]
 #![feature(type_alias_impl_trait)]
 #![feature(unwrap_infallible)]
 // tidy-alphabetical-end
diff --git a/compiler/rustc_data_structures/src/sorted_map.rs b/compiler/rustc_data_structures/src/sorted_map.rs
index c002d47815b17..c3c173b3fc4d8 100644
--- a/compiler/rustc_data_structures/src/sorted_map.rs
+++ b/compiler/rustc_data_structures/src/sorted_map.rs
@@ -1,6 +1,7 @@
 use std::borrow::Borrow;
 use std::cmp::Ordering;
 use std::fmt::Debug;
+use std::iter::TrustedLen;
 use std::mem;
 use std::ops::{Bound, Index, IndexMut, RangeBounds};
 
@@ -215,32 +216,36 @@ impl<K: Ord, V> SortedMap<K, V> {
     /// It is up to the caller to make sure that the elements are sorted by key
     /// and that there are no duplicates.
     #[inline]
-    pub fn insert_presorted(&mut self, elements: Vec<(K, V)>) {
-        if elements.is_empty() {
+    pub fn insert_presorted(
+        &mut self,
+        // We require `TrustedLen` to ensure that the `splice` below is actually efficient.
+        mut elements: impl Iterator<Item = (K, V)> + DoubleEndedIterator + TrustedLen,
+    ) {
+        let Some(first) = elements.next() else {
             return;
-        }
-
-        debug_assert!(elements.array_windows().all(|[fst, snd]| fst.0 < snd.0));
+        };
 
-        let start_index = self.lookup_index_for(&elements[0].0);
+        let start_index = self.lookup_index_for(&first.0);
 
         let elements = match start_index {
             Ok(index) => {
-                let mut elements = elements.into_iter();
-                self.data[index] = elements.next().unwrap();
-                elements
+                self.data[index] = first; // overwrite first element
+                elements.chain(None) // insert the rest below
             }
             Err(index) => {
-                if index == self.data.len() || elements.last().unwrap().0 < self.data[index].0 {
+                let last = elements.next_back();
+                if index == self.data.len()
+                    || last.as_ref().is_none_or(|l| l.0 < self.data[index].0)
+                {
                     // We can copy the whole range without having to mix with
                     // existing elements.
-                    self.data.splice(index..index, elements);
+                    self.data
+                        .splice(index..index, std::iter::once(first).chain(elements).chain(last));
                     return;
                 }
 
-                let mut elements = elements.into_iter();
-                self.data.insert(index, elements.next().unwrap());
-                elements
+                self.data.insert(index, first);
+                elements.chain(last) // insert the rest below
             }
         };
 
diff --git a/compiler/rustc_data_structures/src/sorted_map/tests.rs b/compiler/rustc_data_structures/src/sorted_map/tests.rs
index ea4d2f1feacc0..17d0d3cb1701d 100644
--- a/compiler/rustc_data_structures/src/sorted_map/tests.rs
+++ b/compiler/rustc_data_structures/src/sorted_map/tests.rs
@@ -171,7 +171,7 @@ fn test_insert_presorted_non_overlapping() {
     map.insert(2, 0);
     map.insert(8, 0);
 
-    map.insert_presorted(vec![(3, 0), (7, 0)]);
+    map.insert_presorted(vec![(3, 0), (7, 0)].into_iter());
 
     let expected = vec![2, 3, 7, 8];
     assert_eq!(keys(map), expected);
@@ -183,7 +183,7 @@ fn test_insert_presorted_first_elem_equal() {
     map.insert(2, 2);
     map.insert(8, 8);
 
-    map.insert_presorted(vec![(2, 0), (7, 7)]);
+    map.insert_presorted(vec![(2, 0), (7, 7)].into_iter());
 
     let expected = vec![(2, 0), (7, 7), (8, 8)];
     assert_eq!(elements(map), expected);
@@ -195,7 +195,7 @@ fn test_insert_presorted_last_elem_equal() {
     map.insert(2, 2);
     map.insert(8, 8);
 
-    map.insert_presorted(vec![(3, 3), (8, 0)]);
+    map.insert_presorted(vec![(3, 3), (8, 0)].into_iter());
 
     let expected = vec![(2, 2), (3, 3), (8, 0)];
     assert_eq!(elements(map), expected);
@@ -207,7 +207,7 @@ fn test_insert_presorted_shuffle() {
     map.insert(2, 2);
     map.insert(7, 7);
 
-    map.insert_presorted(vec![(1, 1), (3, 3), (8, 8)]);
+    map.insert_presorted(vec![(1, 1), (3, 3), (8, 8)].into_iter());
 
     let expected = vec![(1, 1), (2, 2), (3, 3), (7, 7), (8, 8)];
     assert_eq!(elements(map), expected);
@@ -219,7 +219,7 @@ fn test_insert_presorted_at_end() {
     map.insert(1, 1);
     map.insert(2, 2);
 
-    map.insert_presorted(vec![(3, 3), (8, 8)]);
+    map.insert_presorted(vec![(3, 3), (8, 8)].into_iter());
 
     let expected = vec![(1, 1), (2, 2), (3, 3), (8, 8)];
     assert_eq!(elements(map), expected);
diff --git a/compiler/rustc_middle/src/mir/interpret/allocation.rs b/compiler/rustc_middle/src/mir/interpret/allocation.rs
index 67962813ae437..8e603ce1b911a 100644
--- a/compiler/rustc_middle/src/mir/interpret/allocation.rs
+++ b/compiler/rustc_middle/src/mir/interpret/allocation.rs
@@ -849,8 +849,13 @@ impl<Prov: Provenance, Extra, Bytes: AllocBytes> Allocation<Prov, Extra, Bytes>
     ///
     /// This is dangerous to use as it can violate internal `Allocation` invariants!
     /// It only exists to support an efficient implementation of `mem_copy_repeatedly`.
-    pub fn provenance_apply_copy(&mut self, copy: ProvenanceCopy<Prov>) {
-        self.provenance.apply_copy(copy)
+    pub fn provenance_apply_copy(
+        &mut self,
+        copy: ProvenanceCopy<Prov>,
+        range: AllocRange,
+        repeat: u64,
+    ) {
+        self.provenance.apply_copy(copy, range, repeat)
     }
 
     /// Applies a previously prepared copy of the init mask.
diff --git a/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs b/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs
index 720e58d7aa0eb..46f28328aebc3 100644
--- a/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs
+++ b/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs
@@ -278,90 +278,78 @@ impl<Prov: Provenance> ProvenanceMap<Prov> {
 
 /// A partial, owned list of provenance to transfer into another allocation.
 ///
-/// Offsets are already adjusted to the destination allocation.
+/// Offsets are relative to the beginning of the copied range.
 pub struct ProvenanceCopy<Prov> {
-    dest_ptrs: Option<Box<[(Size, Prov)]>>,
-    dest_bytes: Option<Box<[(Size, (Prov, u8))]>>,
+    ptrs: Box<[(Size, Prov)]>,
+    bytes: Box<[(Size, (Prov, u8))]>,
 }
 
 impl<Prov: Provenance> ProvenanceMap<Prov> {
     pub fn prepare_copy(
         &self,
-        src: AllocRange,
-        dest: Size,
-        count: u64,
+        range: AllocRange,
         cx: &impl HasDataLayout,
     ) -> AllocResult<ProvenanceCopy<Prov>> {
-        let shift_offset = move |idx, offset| {
-            // compute offset for current repetition
-            let dest_offset = dest + src.size * idx; // `Size` operations
-            // shift offsets from source allocation to destination allocation
-            (offset - src.start) + dest_offset // `Size` operations
-        };
+        let shift_offset = move |offset| offset - range.start;
         let ptr_size = cx.data_layout().pointer_size();
 
         // # Pointer-sized provenances
         // Get the provenances that are entirely within this range.
         // (Different from `range_get_ptrs` which asks if they overlap the range.)
         // Only makes sense if we are copying at least one pointer worth of bytes.
-        let mut dest_ptrs_box = None;
-        if src.size >= ptr_size {
-            let adjusted_end = Size::from_bytes(src.end().bytes() - (ptr_size.bytes() - 1));
-            let ptrs = self.ptrs.range(src.start..adjusted_end);
-            // If `count` is large, this is rather wasteful -- we are allocating a big array here, which
-            // is mostly filled with redundant information since it's just N copies of the same `Prov`s
-            // at slightly adjusted offsets. The reason we do this is so that in `mark_provenance_range`
-            // we can use `insert_presorted`. That wouldn't work with an `Iterator` that just produces
-            // the right sequence of provenance for all N copies.
-            // Basically, this large array would have to be created anyway in the target allocation.
-            let mut dest_ptrs = Vec::with_capacity(ptrs.len() * (count as usize));
-            for i in 0..count {
-                dest_ptrs
-                    .extend(ptrs.iter().map(|&(offset, reloc)| (shift_offset(i, offset), reloc)));
-            }
-            debug_assert_eq!(dest_ptrs.len(), dest_ptrs.capacity());
-            dest_ptrs_box = Some(dest_ptrs.into_boxed_slice());
+        let mut ptrs_box: Box<[_]> = Box::new([]);
+        if range.size >= ptr_size {
+            let adjusted_end = Size::from_bytes(range.end().bytes() - (ptr_size.bytes() - 1));
+            let ptrs = self.ptrs.range(range.start..adjusted_end);
+            ptrs_box = ptrs.iter().map(|&(offset, reloc)| (shift_offset(offset), reloc)).collect();
         };
 
         // # Byte-sized provenances
         // This includes the existing bytewise provenance in the range, and ptr provenance
         // that overlaps with the begin/end of the range.
-        let mut dest_bytes_box = None;
-        let begin_overlap = self.range_ptrs_get(alloc_range(src.start, Size::ZERO), cx).first();
-        let end_overlap = self.range_ptrs_get(alloc_range(src.end(), Size::ZERO), cx).first();
+        let mut bytes_box: Box<[_]> = Box::new([]);
+        let begin_overlap = self.range_ptrs_get(alloc_range(range.start, Size::ZERO), cx).first();
+        let end_overlap = self.range_ptrs_get(alloc_range(range.end(), Size::ZERO), cx).first();
         // We only need to go here if there is some overlap or some bytewise provenance.
         if begin_overlap.is_some() || end_overlap.is_some() || self.bytes.is_some() {
             let mut bytes: Vec<(Size, (Prov, u8))> = Vec::new();
             // First, if there is a part of a pointer at the start, add that.
             if let Some(entry) = begin_overlap {
                 trace!("start overlapping entry: {entry:?}");
-                // For really small copies, make sure we don't run off the end of the `src` range.
-                let entry_end = cmp::min(entry.0 + ptr_size, src.end());
-                for offset in src.start..entry_end {
-                    bytes.push((offset, (entry.1, (offset - entry.0).bytes() as u8)));
+                // For really small copies, make sure we don't run off the end of the range.
+                let entry_end = cmp::min(entry.0 + ptr_size, range.end());
+                for offset in range.start..entry_end {
+                    bytes.push((shift_offset(offset), (entry.1, (offset - entry.0).bytes() as u8)));
                 }
             } else {
                 trace!("no start overlapping entry");
             }
 
             // Then the main part, bytewise provenance from `self.bytes`.
-            bytes.extend(self.range_bytes_get(src));
+            bytes.extend(
+                self.range_bytes_get(range)
+                    .iter()
+                    .map(|&(offset, reloc)| (shift_offset(offset), reloc)),
+            );
 
             // And finally possibly parts of a pointer at the end.
             if let Some(entry) = end_overlap {
                 trace!("end overlapping entry: {entry:?}");
-                // For really small copies, make sure we don't start before `src` does.
-                let entry_start = cmp::max(entry.0, src.start);
-                for offset in entry_start..src.end() {
+                // For really small copies, make sure we don't start before `range` does.
+                let entry_start = cmp::max(entry.0, range.start);
+                for offset in entry_start..range.end() {
                     if bytes.last().is_none_or(|bytes_entry| bytes_entry.0 < offset) {
                         // The last entry, if it exists, has a lower offset than us, so we
                         // can add it at the end and remain sorted.
-                        bytes.push((offset, (entry.1, (offset - entry.0).bytes() as u8)));
+                        bytes.push((
+                            shift_offset(offset),
+                            (entry.1, (offset - entry.0).bytes() as u8),
+                        ));
                     } else {
                         // There already is an entry for this offset in there! This can happen when the
                         // start and end range checks actually end up hitting the same pointer, so we
                         // already added this in the "pointer at the start" part above.
-                        assert!(entry.0 <= src.start);
+                        assert!(entry.0 <= range.start);
                     }
                 }
             } else {
@@ -372,33 +360,34 @@ impl<Prov: Provenance> ProvenanceMap<Prov> {
             if !bytes.is_empty() && !Prov::OFFSET_IS_ADDR {
                 // FIXME(#146291): We need to ensure that we don't mix different pointers with
                 // the same provenance.
-                return Err(AllocError::ReadPartialPointer(src.start));
+                return Err(AllocError::ReadPartialPointer(range.start));
             }
 
             // And again a buffer for the new list on the target side.
-            let mut dest_bytes = Vec::with_capacity(bytes.len() * (count as usize));
-            for i in 0..count {
-                dest_bytes
-                    .extend(bytes.iter().map(|&(offset, reloc)| (shift_offset(i, offset), reloc)));
-            }
-            debug_assert_eq!(dest_bytes.len(), dest_bytes.capacity());
-            dest_bytes_box = Some(dest_bytes.into_boxed_slice());
+            bytes_box = bytes.into_boxed_slice();
         }
 
-        Ok(ProvenanceCopy { dest_ptrs: dest_ptrs_box, dest_bytes: dest_bytes_box })
+        Ok(ProvenanceCopy { ptrs: ptrs_box, bytes: bytes_box })
     }
 
     /// Applies a provenance copy.
     /// The affected range, as defined in the parameters to `prepare_copy` is expected
     /// to be clear of provenance.
-    pub fn apply_copy(&mut self, copy: ProvenanceCopy<Prov>) {
-        if let Some(dest_ptrs) = copy.dest_ptrs {
-            self.ptrs.insert_presorted(dest_ptrs.into());
+    pub fn apply_copy(&mut self, copy: ProvenanceCopy<Prov>, range: AllocRange, repeat: u64) {
+        let shift_offset = |idx: u64, offset: Size| offset + range.start + idx * range.size;
+        if !copy.ptrs.is_empty() {
+            for i in 0..repeat {
+                self.ptrs.insert_presorted(
+                    copy.ptrs.iter().map(|&(offset, reloc)| (shift_offset(i, offset), reloc)),
+                );
+            }
         }
-        if let Some(dest_bytes) = copy.dest_bytes
-            && !dest_bytes.is_empty()
-        {
-            self.bytes.get_or_insert_with(Box::default).insert_presorted(dest_bytes.into());
+        if !copy.bytes.is_empty() {
+            for i in 0..repeat {
+                self.bytes.get_or_insert_with(Box::default).insert_presorted(
+                    copy.bytes.iter().map(|&(offset, reloc)| (shift_offset(i, offset), reloc)),
+                );
+            }
         }
     }
 }

From 7abbc9c8b2c638752e2a6b0913ed1e93e14d21ba Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 8 Sep 2025 16:10:37 +0200
Subject: [PATCH 0744/1889] avoid calling insert_presorted more than once

---
 .../rustc_data_structures/src/sorted_map.rs   |  2 +-
 .../interpret/allocation/provenance_map.rs    | 26 ++++++++++++-------
 2 files changed, 17 insertions(+), 11 deletions(-)

diff --git a/compiler/rustc_data_structures/src/sorted_map.rs b/compiler/rustc_data_structures/src/sorted_map.rs
index c3c173b3fc4d8..15e3e6ea4c329 100644
--- a/compiler/rustc_data_structures/src/sorted_map.rs
+++ b/compiler/rustc_data_structures/src/sorted_map.rs
@@ -249,7 +249,7 @@ impl<K: Ord, V> SortedMap<K, V> {
             }
         };
 
-        // Insert the rest
+        // Insert the rest. This is super inefficicent since each insertion copies the entire tail.
         for (k, v) in elements {
             self.insert(k, v);
         }
diff --git a/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs b/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs
index 46f28328aebc3..67baf63bbfadd 100644
--- a/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs
+++ b/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs
@@ -376,18 +376,24 @@ impl<Prov: Provenance> ProvenanceMap<Prov> {
     pub fn apply_copy(&mut self, copy: ProvenanceCopy<Prov>, range: AllocRange, repeat: u64) {
         let shift_offset = |idx: u64, offset: Size| offset + range.start + idx * range.size;
         if !copy.ptrs.is_empty() {
-            for i in 0..repeat {
-                self.ptrs.insert_presorted(
-                    copy.ptrs.iter().map(|&(offset, reloc)| (shift_offset(i, offset), reloc)),
-                );
-            }
+            // We want to call `insert_presorted` only once so that, if possible, the entries
+            // after the range we insert are moved back only once.
+            let chunk_len = copy.ptrs.len() as u64;
+            self.ptrs.insert_presorted((0..chunk_len * repeat).map(|i| {
+                let chunk = i / chunk_len;
+                let (offset, reloc) = copy.ptrs[(i % chunk_len) as usize];
+                (shift_offset(chunk, offset), reloc)
+            }));
         }
         if !copy.bytes.is_empty() {
-            for i in 0..repeat {
-                self.bytes.get_or_insert_with(Box::default).insert_presorted(
-                    copy.bytes.iter().map(|&(offset, reloc)| (shift_offset(i, offset), reloc)),
-                );
-            }
+            let chunk_len = copy.bytes.len() as u64;
+            self.bytes.get_or_insert_with(Box::default).insert_presorted(
+                (0..chunk_len * repeat).map(|i| {
+                    let chunk = i / chunk_len;
+                    let (offset, reloc) = copy.bytes[(i % chunk_len) as usize];
+                    (shift_offset(chunk, offset), reloc)
+                }),
+            );
         }
     }
 }

From 092d653882f50bba2eea1158ed57891d1a272542 Mon Sep 17 00:00:00 2001
From: Nikita Popov <npopov@redhat.com>
Date: Wed, 10 Sep 2025 10:24:07 +0200
Subject: [PATCH 0745/1889] Update to LLVM 21.1.1

---
 src/llvm-project | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/llvm-project b/src/llvm-project
index 19f0a49c5c3f4..333793696b0a0 160000
--- a/src/llvm-project
+++ b/src/llvm-project
@@ -1 +1 @@
-Subproject commit 19f0a49c5c3f4ba88b5e7ac620b9a0d8574c09cb
+Subproject commit 333793696b0a08002acac6af983adc7a5233fc56

From e4f69ea1af40cd43da1aec1d6489ac6e78d3e769 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 10 Sep 2025 09:35:45 +0200
Subject: [PATCH 0746/1889] fix(needless_closure): don't lint on `AsyncFn*`s

---
 clippy_lints/src/eta_reduction.rs | 27 +++++++++++++++------------
 tests/ui/eta.fixed                |  8 ++++++++
 tests/ui/eta.rs                   |  8 ++++++++
 3 files changed, 31 insertions(+), 12 deletions(-)

diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 2da1c2bad1174..752f39b4e6dc1 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -197,6 +197,18 @@ fn check_closure<'tcx>(cx: &LateContext<'tcx>, outer_receiver: Option<&Expr<'tcx
                 // 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(_)))
+                // Rule out `AsyncFn*`s, because while they can be called as `|x| f(x)`,
+                // they can't be passed directly into a place expecting an `Fn*` (#13892)
+                && let Ok((closure_kind, _)) = cx
+                    .tcx
+                    .infer_ctxt()
+                    .build(cx.typing_mode())
+                    .err_ctxt()
+                    .type_implements_fn_trait(
+                        cx.param_env,
+                        Binder::bind_with_vars(callee_ty_adjusted, List::empty()),
+                        ty::PredicatePolarity::Positive,
+                    )
             {
                 span_lint_hir_and_then(
                     cx,
@@ -213,19 +225,10 @@ fn check_closure<'tcx>(cx: &LateContext<'tcx>, outer_receiver: Option<&Expr<'tcx
                                 // '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(cx.typing_mode())
-                                    .err_ctxt()
-                                    .type_implements_fn_trait(
-                                        cx.param_env,
-                                        Binder::bind_with_vars(callee_ty_adjusted, List::empty()),
-                                        ty::PredicatePolarity::Positive,
-                                    ) {
+                                match closure_kind {
                                     // 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() => {
+                                    ClosureKind::FnMut => snippet = format!("&mut {snippet}"),
+                                    ClosureKind::Fn if !callee_ty_raw.is_ref() => {
                                         snippet = format!("&{snippet}");
                                     },
                                     _ => (),
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index 6944a979c05e6..107318e5323d0 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -635,3 +635,11 @@ fn issue8817() {
         //~| HELP: replace the closure with the tuple variant itself
         .unwrap(); // just for nicer formatting
 }
+
+async fn issue13892<'a, T, F>(maybe: Option<&'a T>, visitor: F)
+where
+    F: AsyncFn(&'a T),
+    T: 'a,
+{
+    maybe.map(|x| visitor(x));
+}
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index 5bcc1cb26fd78..b85e8e75153a1 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -635,3 +635,11 @@ fn issue8817() {
         //~| HELP: replace the closure with the tuple variant itself
         .unwrap(); // just for nicer formatting
 }
+
+async fn issue13892<'a, T, F>(maybe: Option<&'a T>, visitor: F)
+where
+    F: AsyncFn(&'a T),
+    T: 'a,
+{
+    maybe.map(|x| visitor(x));
+}

From bd089e1e6e52256c0535f19f58b4b6fe9609b70c Mon Sep 17 00:00:00 2001
From: Bryanskiy <ivakin.kir@gmail.com>
Date: Tue, 19 Aug 2025 21:34:33 +0300
Subject: [PATCH 0747/1889] Default auto traits: revert to the default
 supertraits

---
 .../src/collect/predicates_of.rs              |   6 -
 .../src/hir_ty_lowering/bounds.rs             | 144 ++----------------
 .../src/multiple_supertrait_upcastable.rs     |   3 +-
 .../backward-compatible-lazy-bounds-pass.rs   |  31 ----
 .../maybe-bounds-in-dyn-traits.rs             |  80 +++++++---
 .../maybe-bounds-in-dyn-traits.stderr         |  66 ++++----
 .../maybe-bounds-in-traits.rs                 |  78 +++-------
 .../maybe-bounds-in-traits.stderr             |  80 +++-------
 8 files changed, 155 insertions(+), 333 deletions(-)
 delete mode 100644 tests/ui/traits/default_auto_traits/backward-compatible-lazy-bounds-pass.rs

diff --git a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
index b59dc4bd132f9..126ffabd448c7 100644
--- a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
@@ -174,12 +174,6 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
         }
     };
 
-    if let Node::TraitItem(item) = node {
-        let mut bounds = Vec::new();
-        icx.lowerer().add_default_trait_item_bounds(item, &mut bounds);
-        predicates.extend(bounds);
-    }
-
     let generics = tcx.generics_of(def_id);
 
     // Below we'll consider the bounds on the type parameters (including `Self`)
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
index d14aef8ace46e..99dc8e6e52217 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
@@ -1,12 +1,13 @@
+use std::assert_matches::assert_matches;
 use std::ops::ControlFlow;
 
 use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
 use rustc_errors::codes::*;
 use rustc_errors::struct_span_code_err;
 use rustc_hir as hir;
+use rustc_hir::PolyTraitRef;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{CRATE_DEF_ID, DefId, LocalDefId};
-use rustc_hir::{AmbigArg, PolyTraitRef};
 use rustc_middle::bug;
 use rustc_middle::ty::{
     self as ty, IsSuggestable, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitableExt,
@@ -230,122 +231,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         }
     }
 
-    /// Checks whether `Self: DefaultAutoTrait` bounds should be added on trait super bounds
-    /// or associated items.
-    ///
-    /// To keep backward compatibility with existing code, `experimental_default_bounds` bounds
-    /// should be added everywhere, including super bounds. However this causes a huge performance
-    /// costs. For optimization purposes instead of adding default supertraits, bounds
-    /// are added to the associated items:
-    ///
-    /// ```ignore(illustrative)
-    /// // Default bounds are generated in the following way:
-    /// trait Trait {
-    ///     fn foo(&self) where Self: Leak {}
-    /// }
-    ///
-    /// // instead of this:
-    /// trait Trait: Leak {
-    ///     fn foo(&self) {}
-    /// }
-    /// ```
-    /// It is not always possible to do this because of backward compatibility:
-    ///
-    /// ```ignore(illustrative)
-    /// pub trait Trait<Rhs = Self> {}
-    /// pub trait Trait1 : Trait {}
-    /// //~^ ERROR: `Rhs` requires `DefaultAutoTrait`, but `Self` is not `DefaultAutoTrait`
-    /// ```
-    ///
-    /// or:
-    ///
-    /// ```ignore(illustrative)
-    /// trait Trait {
-    ///     type Type where Self: Sized;
-    /// }
-    /// trait Trait2<T> : Trait<Type = T> {}
-    /// //~^ ERROR: `DefaultAutoTrait` required for `Trait2`, by implicit  `Self: DefaultAutoTrait` in `Trait::Type`
-    /// ```
-    ///
-    /// Therefore, `experimental_default_bounds` are still being added to supertraits if
-    /// the `SelfTyParam` or `AssocItemConstraint` were found in a trait header.
-    fn requires_default_supertraits(
-        &self,
-        hir_bounds: &'tcx [hir::GenericBound<'tcx>],
-        hir_generics: &'tcx hir::Generics<'tcx>,
-    ) -> bool {
-        struct TraitInfoCollector;
-
-        impl<'tcx> hir::intravisit::Visitor<'tcx> for TraitInfoCollector {
-            type Result = ControlFlow<()>;
-
-            fn visit_assoc_item_constraint(
-                &mut self,
-                _constraint: &'tcx hir::AssocItemConstraint<'tcx>,
-            ) -> Self::Result {
-                ControlFlow::Break(())
-            }
-
-            fn visit_ty(&mut self, t: &'tcx hir::Ty<'tcx, AmbigArg>) -> Self::Result {
-                if matches!(
-                    &t.kind,
-                    hir::TyKind::Path(hir::QPath::Resolved(
-                        _,
-                        hir::Path { res: hir::def::Res::SelfTyParam { .. }, .. },
-                    ))
-                ) {
-                    return ControlFlow::Break(());
-                }
-                hir::intravisit::walk_ty(self, t)
-            }
-        }
-
-        let mut found = false;
-        for bound in hir_bounds {
-            found |= hir::intravisit::walk_param_bound(&mut TraitInfoCollector, bound).is_break();
-        }
-        found |= hir::intravisit::walk_generics(&mut TraitInfoCollector, hir_generics).is_break();
-        found
-    }
-
-    /// Implicitly add `Self: DefaultAutoTrait` clauses on trait associated items if
-    /// they are not added as super trait bounds to the trait itself. See
-    /// `requires_default_supertraits` for more information.
-    pub(crate) fn add_default_trait_item_bounds(
-        &self,
-        trait_item: &hir::TraitItem<'tcx>,
-        bounds: &mut Vec<(ty::Clause<'tcx>, Span)>,
-    ) {
-        let tcx = self.tcx();
-        if !tcx.sess.opts.unstable_opts.experimental_default_bounds {
-            return;
-        }
-
-        let parent = tcx.local_parent(trait_item.hir_id().owner.def_id);
-        let hir::Node::Item(parent_trait) = tcx.hir_node_by_def_id(parent) else {
-            unreachable!();
-        };
-
-        let (trait_generics, trait_bounds) = match parent_trait.kind {
-            hir::ItemKind::Trait(_, _, _, _, generics, supertraits, _) => (generics, supertraits),
-            hir::ItemKind::TraitAlias(_, generics, supertraits) => (generics, supertraits),
-            _ => unreachable!(),
-        };
-
-        if !self.requires_default_supertraits(trait_bounds, trait_generics) {
-            let self_ty_where_predicates = (parent, trait_item.generics.predicates);
-            self.add_default_traits(
-                bounds,
-                tcx.types.self_param,
-                &[],
-                Some(self_ty_where_predicates),
-                trait_item.span,
-            );
-        }
-    }
-
-    /// Lazily sets `experimental_default_bounds` to true on trait super bounds.
-    /// See `requires_default_supertraits` for more information.
+    /// Adds `experimental_default_bounds` bounds to the supertrait bounds.
     pub(crate) fn add_default_super_traits(
         &self,
         trait_def_id: LocalDefId,
@@ -354,21 +240,21 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         hir_generics: &'tcx hir::Generics<'tcx>,
         span: Span,
     ) {
-        if !self.tcx().sess.opts.unstable_opts.experimental_default_bounds {
+        assert_matches!(self.tcx().def_kind(trait_def_id), DefKind::Trait | DefKind::TraitAlias);
+
+        // Supertraits for auto trait are unsound according to the unstable book:
+        // https://doc.rust-lang.org/beta/unstable-book/language-features/auto-traits.html#supertraits
+        if self.tcx().trait_is_auto(trait_def_id.to_def_id()) {
             return;
         }
 
-        assert!(matches!(self.tcx().def_kind(trait_def_id), DefKind::Trait | DefKind::TraitAlias));
-        if self.requires_default_supertraits(hir_bounds, hir_generics) {
-            let self_ty_where_predicates = (trait_def_id, hir_generics.predicates);
-            self.add_default_traits(
-                bounds,
-                self.tcx().types.self_param,
-                hir_bounds,
-                Some(self_ty_where_predicates),
-                span,
-            );
-        }
+        self.add_default_traits(
+            bounds,
+            self.tcx().types.self_param,
+            hir_bounds,
+            Some((trait_def_id, hir_generics.predicates)),
+            span,
+        );
     }
 
     pub(crate) fn add_default_traits(
diff --git a/compiler/rustc_lint/src/multiple_supertrait_upcastable.rs b/compiler/rustc_lint/src/multiple_supertrait_upcastable.rs
index 5513c703f1d54..93f067d09833a 100644
--- a/compiler/rustc_lint/src/multiple_supertrait_upcastable.rs
+++ b/compiler/rustc_lint/src/multiple_supertrait_upcastable.rs
@@ -47,7 +47,8 @@ impl<'tcx> LateLintPass<'tcx> for MultipleSupertraitUpcastable {
                 .explicit_super_predicates_of(def_id)
                 .iter_identity_copied()
                 .filter_map(|(pred, _)| pred.as_trait_clause())
-                .filter(|pred| !cx.tcx.is_lang_item(pred.def_id(), hir::LangItem::MetaSized));
+                .filter(|pred| !cx.tcx.is_lang_item(pred.def_id(), hir::LangItem::MetaSized))
+                .filter(|pred| !cx.tcx.is_default_trait(pred.def_id()));
             if direct_super_traits_iter.count() > 1 {
                 cx.emit_span_lint(
                     MULTIPLE_SUPERTRAIT_UPCASTABLE,
diff --git a/tests/ui/traits/default_auto_traits/backward-compatible-lazy-bounds-pass.rs b/tests/ui/traits/default_auto_traits/backward-compatible-lazy-bounds-pass.rs
deleted file mode 100644
index 745b6ee9bc5cc..0000000000000
--- a/tests/ui/traits/default_auto_traits/backward-compatible-lazy-bounds-pass.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-//@ check-pass
-//@ compile-flags: -Zexperimental-default-bounds
-
-#![feature(auto_traits, lang_items, no_core, rustc_attrs, trait_alias)]
-#![no_std]
-#![no_core]
-
-#[lang = "pointee_sized"]
-trait PointeeSized {}
-
-#[lang = "meta_sized"]
-trait MetaSized: PointeeSized {}
-
-#[lang = "sized"]
-trait Sized: MetaSized {}
-
-#[lang = "default_trait1"]
-auto trait DefaultTrait1 {}
-
-#[lang = "default_trait2"]
-auto trait DefaultTrait2 {}
-
-trait Trait<Rhs: ?Sized = Self> {}
-trait Trait1 : Trait {}
-
-trait Trait2 {
-    type Type;
-}
-trait Trait3<T> = Trait2<Type = T>;
-
-fn main() {}
diff --git a/tests/ui/traits/default_auto_traits/maybe-bounds-in-dyn-traits.rs b/tests/ui/traits/default_auto_traits/maybe-bounds-in-dyn-traits.rs
index e7cca41a47eab..2e1a5d2424bfa 100644
--- a/tests/ui/traits/default_auto_traits/maybe-bounds-in-dyn-traits.rs
+++ b/tests/ui/traits/default_auto_traits/maybe-bounds-in-dyn-traits.rs
@@ -13,32 +13,37 @@
 #![no_core]
 
 #[lang = "pointee_sized"]
-trait PointeeSized {}
+trait PointeeSized: ?Leak {}
 
 #[lang = "meta_sized"]
-trait MetaSized: PointeeSized {}
+trait MetaSized: PointeeSized + ?Leak {}
 
 #[lang = "sized"]
-trait Sized: MetaSized {}
+trait Sized: MetaSized + ?Leak {}
 
 #[lang = "copy"]
-pub trait Copy {}
+pub trait Copy: ?Leak {}
 impl<'a, T: ?Sized> Copy for &'a T {}
 
 #[lang = "legacy_receiver"]
-trait Receiver {}
+trait Receiver: ?Leak {}
 impl<T: ?Sized + ?Leak> Receiver for &T {}
+impl<T: ?Sized + ?Leak> Receiver for &mut T {}
 
 #[lang = "unsize"]
-trait Unsize<T: ?Sized + ?Leak> {}
+trait Unsize<T: ?Sized + ?Leak>: ?Leak {}
 
 #[lang = "coerce_unsized"]
-trait CoerceUnsized<T: ?Leak + ?Sized> {}
+trait CoerceUnsized<T: ?Leak + ?Sized>: ?Leak {}
 impl<'a, 'b: 'a, T: ?Sized + ?Leak + Unsize<U>, U: ?Sized + ?Leak> CoerceUnsized<&'a U> for &'b T {}
+// Omit `T: ?Leak` and `U: ?Leak`.
+impl<'a, 'b: 'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<&'a mut U> for &'b mut T {}
 
 #[lang = "dispatch_from_dyn"]
-trait DispatchFromDyn<T: ?Leak> {}
+trait DispatchFromDyn<T: ?Leak>: ?Leak {}
 impl<'a, T: ?Sized + ?Leak + Unsize<U>, U: ?Sized + ?Leak> DispatchFromDyn<&'a U> for &'a T {}
+// Omit `T: ?Leak` and `U: ?Leak`.
+impl<'a, T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<&'a mut U> for &'a mut T {}
 
 #[lang = "default_trait1"]
 auto trait Leak {}
@@ -47,25 +52,52 @@ struct NonLeakS;
 impl !Leak for NonLeakS {}
 struct LeakS;
 
-trait Trait {
-    fn leak_foo(&self) {}
-    fn maybe_leak_foo(&self) where Self: ?Leak {}
+fn bounds_check() {
+    trait LeakTr {}
+
+    trait MaybeLeakTr: ?Leak {}
+
+    impl MaybeLeakTr for NonLeakS {}
+
+    impl LeakTr for LeakS {}
+    impl MaybeLeakTr for LeakS {}
+
+    let _: &dyn LeakTr = &NonLeakS;
+    //~^ ERROR  the trait bound `NonLeakS: bounds_check::LeakTr` is not satisfied
+    let _: &dyn LeakTr = &LeakS;
+
+    let _: &(dyn LeakTr + ?Leak) = &NonLeakS;
+    let _: &(dyn LeakTr + ?Leak) = &LeakS;
+
+    let _: &dyn MaybeLeakTr = &NonLeakS;
+    let _: &dyn MaybeLeakTr = &LeakS;
 }
 
-impl Trait for NonLeakS {}
-impl Trait for LeakS {}
-
-fn main() {
-    let _: &dyn Trait = &NonLeakS;
-    //~^ ERROR the trait bound `NonLeakS: Leak` is not satisfied
-    let _: &dyn Trait = &LeakS;
-    let _: &(dyn Trait + ?Leak) = &LeakS;
-    let x: &(dyn Trait + ?Leak) = &NonLeakS;
-    x.leak_foo();
-    //~^ ERROR the trait bound `dyn Trait: Leak` is not satisfied
-    x.maybe_leak_foo();
+fn dyn_compat_check() {
+    trait DynCompatCheck1: ?Leak {
+        fn foo(&self) {}
+    }
+
+    trait DynCompatCheck2: ?Leak {
+        fn mut_foo(&mut self) {}
+    }
+
+    impl DynCompatCheck1 for NonLeakS {}
+    impl DynCompatCheck2 for NonLeakS {}
+
+    let _: &(dyn DynCompatCheck1 + ?Leak) = &NonLeakS;
+    // There is no `?Leak` bound on corresponding `DispatchFromDyn` impl.
+    let _: &dyn DynCompatCheck2 = &NonLeakS;
+    //~^ ERROR the trait `DynCompatCheck2` is not dyn compatible
+}
+
+fn args_check() {
+    trait LeakTr {}
+
     // Ensure that we validate the generic args of relaxed bounds in trait object types.
-    let _: dyn Trait + ?Leak<(), Undefined = ()>;
+    let _: dyn LeakTr + ?Leak<(), Undefined = ()>;
     //~^ ERROR trait takes 0 generic arguments but 1 generic argument was supplied
     //~| ERROR associated type `Undefined` not found for `Leak`
 }
+
+fn main() {}
diff --git a/tests/ui/traits/default_auto_traits/maybe-bounds-in-dyn-traits.stderr b/tests/ui/traits/default_auto_traits/maybe-bounds-in-dyn-traits.stderr
index b19c082a1b8fd..b96a2915c3330 100644
--- a/tests/ui/traits/default_auto_traits/maybe-bounds-in-dyn-traits.stderr
+++ b/tests/ui/traits/default_auto_traits/maybe-bounds-in-dyn-traits.stderr
@@ -1,49 +1,57 @@
-error[E0277]: the trait bound `NonLeakS: Leak` is not satisfied
-  --> $DIR/maybe-bounds-in-dyn-traits.rs:59:25
+error[E0277]: the trait bound `NonLeakS: bounds_check::LeakTr` is not satisfied
+  --> $DIR/maybe-bounds-in-dyn-traits.rs:65:26
    |
-LL |     let _: &dyn Trait = &NonLeakS;
-   |                         ^^^^^^^^^ unsatisfied trait bound
+LL |     let _: &dyn LeakTr = &NonLeakS;
+   |                          ^^^^^^^^^ unsatisfied trait bound
    |
-help: the trait `Leak` is not implemented for `NonLeakS`
-  --> $DIR/maybe-bounds-in-dyn-traits.rs:46:1
+help: the trait `bounds_check::LeakTr` is not implemented for `NonLeakS`
+  --> $DIR/maybe-bounds-in-dyn-traits.rs:51:1
    |
 LL | struct NonLeakS;
    | ^^^^^^^^^^^^^^^
-   = note: required for the cast from `&NonLeakS` to `&dyn Trait + Leak`
+   = help: the trait `bounds_check::LeakTr` is implemented for `LeakS`
+   = note: required for the cast from `&NonLeakS` to `&dyn bounds_check::LeakTr + Leak`
 
-error[E0277]: the trait bound `dyn Trait: Leak` is not satisfied
-  --> $DIR/maybe-bounds-in-dyn-traits.rs:64:7
-   |
-LL |     x.leak_foo();
-   |       ^^^^^^^^ the trait `Leak` is not implemented for `dyn Trait`
-   |
-note: required by a bound in `Trait::leak_foo`
-  --> $DIR/maybe-bounds-in-dyn-traits.rs:51:5
-   |
-LL |     fn leak_foo(&self) {}
-   |     ^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Trait::leak_foo`
+error[E0038]: the trait `DynCompatCheck2` is not dyn compatible
+  --> $DIR/maybe-bounds-in-dyn-traits.rs:90:17
+   |
+LL |         fn mut_foo(&mut self) {}
+   |                    --------- help: consider changing method `mut_foo`'s `self` parameter to be `&self`: `&Self`
+...
+LL |     let _: &dyn DynCompatCheck2 = &NonLeakS;
+   |                 ^^^^^^^^^^^^^^^ `DynCompatCheck2` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/maybe-bounds-in-dyn-traits.rs:82:20
+   |
+LL |     trait DynCompatCheck2: ?Leak {
+   |           --------------- this trait is not dyn compatible...
+LL |         fn mut_foo(&mut self) {}
+   |                    ^^^^^^^^^ ...because method `mut_foo`'s `self` parameter cannot be dispatched on
+   = help: only type `NonLeakS` implements `DynCompatCheck2`; consider using it directly instead.
 
 error[E0107]: trait takes 0 generic arguments but 1 generic argument was supplied
-  --> $DIR/maybe-bounds-in-dyn-traits.rs:68:25
+  --> $DIR/maybe-bounds-in-dyn-traits.rs:98:26
    |
-LL |     let _: dyn Trait + ?Leak<(), Undefined = ()>;
-   |                         ^^^^-------------------- help: remove the unnecessary generics
-   |                         |
-   |                         expected 0 generic arguments
+LL |     let _: dyn LeakTr + ?Leak<(), Undefined = ()>;
+   |                          ^^^^-------------------- help: remove the unnecessary generics
+   |                          |
+   |                          expected 0 generic arguments
    |
 note: trait defined here, with 0 generic parameters
-  --> $DIR/maybe-bounds-in-dyn-traits.rs:44:12
+  --> $DIR/maybe-bounds-in-dyn-traits.rs:49:12
    |
 LL | auto trait Leak {}
    |            ^^^^
 
 error[E0220]: associated type `Undefined` not found for `Leak`
-  --> $DIR/maybe-bounds-in-dyn-traits.rs:68:34
+  --> $DIR/maybe-bounds-in-dyn-traits.rs:98:35
    |
-LL |     let _: dyn Trait + ?Leak<(), Undefined = ()>;
-   |                                  ^^^^^^^^^ associated type `Undefined` not found
+LL |     let _: dyn LeakTr + ?Leak<(), Undefined = ()>;
+   |                                   ^^^^^^^^^ associated type `Undefined` not found
 
 error: aborting due to 4 previous errors
 
-Some errors have detailed explanations: E0107, E0220, E0277.
-For more information about an error, try `rustc --explain E0107`.
+Some errors have detailed explanations: E0038, E0107, E0220, E0277.
+For more information about an error, try `rustc --explain E0038`.
diff --git a/tests/ui/traits/default_auto_traits/maybe-bounds-in-traits.rs b/tests/ui/traits/default_auto_traits/maybe-bounds-in-traits.rs
index b3801baaf7047..820132b4e5433 100644
--- a/tests/ui/traits/default_auto_traits/maybe-bounds-in-traits.rs
+++ b/tests/ui/traits/default_auto_traits/maybe-bounds-in-traits.rs
@@ -14,18 +14,22 @@
 #![no_std]
 #![no_core]
 
+#[lang = "copy"]
+pub trait Copy: ?Leak {}
+
 #[lang = "pointee_sized"]
-trait PointeeSized {}
+trait PointeeSized: ?Leak {}
 
 #[lang = "meta_sized"]
-trait MetaSized: PointeeSized {}
+trait MetaSized: PointeeSized + ?Leak {}
 
 #[lang = "sized"]
-trait Sized: MetaSized {}
+trait Sized: MetaSized + ?Leak {}
 
 #[lang = "legacy_receiver"]
-trait LegacyReceiver {}
+trait LegacyReceiver: ?Leak {}
 impl<T: ?Sized + ?Leak> LegacyReceiver for &T {}
+// Omit `T: ?Leak`.
 impl<T: ?Sized> LegacyReceiver for &mut T {}
 
 #[lang = "default_trait1"]
@@ -43,78 +47,38 @@ mod supertraits {
 
     impl MaybeLeakT1 for NonLeakS {}
     impl MaybeLeakT2 for NonLeakS {}
+
+    trait LeakT {}
+    impl LeakT for NonLeakS {}
+    //~^ ERROR the trait bound `NonLeakS: Leak` is not satisfied
 }
 
-mod maybe_self_assoc_type {
+mod assoc_type_maybe_bounds {
     use crate::*;
 
-    trait TestBase1<T: ?Sized> {}
-    trait TestBase2<T: ?Leak + ?Sized> {}
-
-    trait Test1<T> {
-        type MaybeLeakSelf: TestBase1<Self> where Self: ?Leak;
-        //~^ ERROR the trait bound `Self: Leak` is not satisfied
-        type LeakSelf: TestBase1<Self>;
-    }
-
-    trait Test2<T> {
-        type MaybeLeakSelf: TestBase2<Self> where Self: ?Leak;
-        type LeakSelf: TestBase2<Self>;
-    }
-
-    trait Test3 {
+    trait Test1 {
         type Leak1 = LeakS;
         type Leak2 = NonLeakS;
         //~^ ERROR the trait bound `NonLeakS: Leak` is not satisfied
     }
 
-    trait Test4 {
+    trait Test2 {
         type MaybeLeak1: ?Leak = LeakS;
         type MaybeLeak2: ?Leak = NonLeakS;
     }
-
-    trait Test5: ?Leak {
-        // ok, because assoc types have implicit where Self: Leak
-        type MaybeLeakSelf1: TestBase1<Self>;
-        type MaybeLeakSelf2: TestBase2<Self>;
-    }
-}
-
-mod maybe_self_assoc_const {
-    use crate::*;
-
-    const fn size_of<T: ?Sized>() -> usize {
-        0
-    }
-
-    trait Trait {
-        const CLeak: usize = size_of::<Self>();
-        const CNonLeak: usize = size_of::<Self>() where Self: ?Leak;
-        //~^ ERROR the trait bound `Self: Leak` is not satisfied
-    }
 }
 
 mod methods {
     use crate::*;
 
-    trait Trait {
-        fn leak_foo(&self) {}
-        fn maybe_leak_foo(&self) where Self: ?Leak {}
-        fn mut_leak_foo(&mut self) {}
-        // there is no relax bound on corresponding Receiver impl
-        fn mut_maybe_leak_foo(&mut self) where Self: ?Leak {}
-        //~^ ERROR `&mut Self` cannot be used as the type of `self` without the `arbitrary_self_types`
+    trait ReceiveCheck1: ?Leak {
+        fn foo(&self) {}
     }
 
-    impl Trait for NonLeakS {}
-    impl Trait for LeakS {}
-
-    fn foo() {
-        LeakS.leak_foo();
-        LeakS.maybe_leak_foo();
-        NonLeakS.leak_foo();
-        //~^ ERROR the trait bound `NonLeakS: Leak` is not satisfied
-        NonLeakS.maybe_leak_foo();
+    trait ReceiveCheck2: ?Leak {
+        // There is no `?Leak` bound on corresponding `LegacyReceiver` impl.
+        fn mut_foo(&mut self) {}
+        //~^ ERROR `&mut Self` cannot be used as the type of `self` without the `arbitrary_self_types`
     }
 }
 
diff --git a/tests/ui/traits/default_auto_traits/maybe-bounds-in-traits.stderr b/tests/ui/traits/default_auto_traits/maybe-bounds-in-traits.stderr
index 372bf81760093..95c77b1756cf9 100644
--- a/tests/ui/traits/default_auto_traits/maybe-bounds-in-traits.stderr
+++ b/tests/ui/traits/default_auto_traits/maybe-bounds-in-traits.stderr
@@ -1,81 +1,49 @@
 error[E0277]: the trait bound `NonLeakS: Leak` is not satisfied
-  --> $DIR/maybe-bounds-in-traits.rs:67:22
+  --> $DIR/maybe-bounds-in-traits.rs:52:20
    |
-LL |         type Leak2 = NonLeakS;
-   |                      ^^^^^^^^ unsatisfied trait bound
+LL |     impl LeakT for NonLeakS {}
+   |                    ^^^^^^^^ unsatisfied trait bound
    |
 help: the trait `Leak` is not implemented for `NonLeakS`
-  --> $DIR/maybe-bounds-in-traits.rs:34:1
+  --> $DIR/maybe-bounds-in-traits.rs:38:1
    |
 LL | struct NonLeakS;
    | ^^^^^^^^^^^^^^^
-note: required by a bound in `Test3::Leak2`
-  --> $DIR/maybe-bounds-in-traits.rs:67:9
+note: required by a bound in `LeakT`
+  --> $DIR/maybe-bounds-in-traits.rs:51:5
    |
-LL |         type Leak2 = NonLeakS;
-   |         ^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Test3::Leak2`
+LL |     trait LeakT {}
+   |     ^^^^^^^^^^^^^^ required by this bound in `LeakT`
 
-error[E0277]: the trait bound `Self: Leak` is not satisfied
-  --> $DIR/maybe-bounds-in-traits.rs:55:29
+error[E0277]: the trait bound `NonLeakS: Leak` is not satisfied
+  --> $DIR/maybe-bounds-in-traits.rs:61:22
    |
-LL |         type MaybeLeakSelf: TestBase1<Self> where Self: ?Leak;
-   |                             ^^^^^^^^^^^^^^^ the trait `Leak` is not implemented for `Self`
+LL |         type Leak2 = NonLeakS;
+   |                      ^^^^^^^^ unsatisfied trait bound
    |
-note: required by a bound in `TestBase1`
-  --> $DIR/maybe-bounds-in-traits.rs:51:21
+help: the trait `Leak` is not implemented for `NonLeakS`
+  --> $DIR/maybe-bounds-in-traits.rs:38:1
    |
-LL |     trait TestBase1<T: ?Sized> {}
-   |                     ^ required by this bound in `TestBase1`
-help: consider further restricting `Self`
+LL | struct NonLeakS;
+   | ^^^^^^^^^^^^^^^
+note: required by a bound in `Test1::Leak2`
+  --> $DIR/maybe-bounds-in-traits.rs:61:9
    |
-LL |     trait Test1<T>: Leak {
-   |                   ++++++
+LL |         type Leak2 = NonLeakS;
+   |         ^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Test1::Leak2`
 
 error[E0658]: `&mut Self` cannot be used as the type of `self` without the `arbitrary_self_types` feature
-  --> $DIR/maybe-bounds-in-traits.rs:105:31
+  --> $DIR/maybe-bounds-in-traits.rs:80:20
    |
-LL |         fn mut_maybe_leak_foo(&mut self) where Self: ?Leak {}
-   |                               ^^^^^^^^^
+LL |         fn mut_foo(&mut self) {}
+   |                    ^^^^^^^^^
    |
    = note: see issue #44874 <https://github.com/rust-lang/rust/issues/44874> for more information
    = help: add `#![feature(arbitrary_self_types)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
    = help: consider changing to `self`, `&self`, `&mut self`, or a type implementing `Receiver` such as `self: Box<Self>`, `self: Rc<Self>`, or `self: Arc<Self>`
 
-error[E0277]: the trait bound `Self: Leak` is not satisfied
-  --> $DIR/maybe-bounds-in-traits.rs:92:43
-   |
-LL |         const CNonLeak: usize = size_of::<Self>() where Self: ?Leak;
-   |                                           ^^^^ the trait `Leak` is not implemented for `Self`
-   |
-note: required by a bound in `size_of`
-  --> $DIR/maybe-bounds-in-traits.rs:86:22
-   |
-LL |     const fn size_of<T: ?Sized>() -> usize {
-   |                      ^ required by this bound in `size_of`
-help: consider further restricting `Self`
-   |
-LL |     trait Trait: Leak {
-   |                ++++++
-
-error[E0277]: the trait bound `NonLeakS: Leak` is not satisfied
-  --> $DIR/maybe-bounds-in-traits.rs:115:18
-   |
-LL |         NonLeakS.leak_foo();
-   |                  ^^^^^^^^ unsatisfied trait bound
-   |
-help: the trait `Leak` is not implemented for `NonLeakS`
-  --> $DIR/maybe-bounds-in-traits.rs:34:1
-   |
-LL | struct NonLeakS;
-   | ^^^^^^^^^^^^^^^
-note: required by a bound in `methods::Trait::leak_foo`
-  --> $DIR/maybe-bounds-in-traits.rs:101:9
-   |
-LL |         fn leak_foo(&self) {}
-   |         ^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Trait::leak_foo`
-
-error: aborting due to 5 previous errors
+error: aborting due to 3 previous errors
 
 Some errors have detailed explanations: E0277, E0658.
 For more information about an error, try `rustc --explain E0277`.

From 3ab7b397bbd27d220d1eebc1b21963235dd26711 Mon Sep 17 00:00:00 2001
From: Bryanskiy <ivakin.kir@gmail.com>
Date: Sun, 24 Aug 2025 21:29:26 +0300
Subject: [PATCH 0748/1889] Permit `more_maybe_bounds` in supertraits and trait
 objects only

---
 compiler/rustc_ast_lowering/src/lib.rs        | 15 +++++----
 tests/ui/trait-bounds/more_maybe_bounds.rs    | 14 ++++++++
 .../ui/trait-bounds/more_maybe_bounds.stderr  | 32 ++++++++++++++++++-
 .../maybe-bounds-in-traits.rs                 |  7 ++--
 .../maybe-bounds-in-traits.stderr             | 10 +++---
 5 files changed, 60 insertions(+), 18 deletions(-)

diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index 72f20a95ff02d..4e2243e87873c 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -2101,17 +2101,14 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 {
                     return;
                 }
-                if self.tcx.features().more_maybe_bounds() {
-                    return;
-                }
             }
             RelaxedBoundPolicy::Forbidden(reason) => {
-                if self.tcx.features().more_maybe_bounds() {
-                    return;
-                }
-
                 match reason {
                     RelaxedBoundForbiddenReason::TraitObjectTy => {
+                        if self.tcx.features().more_maybe_bounds() {
+                            return;
+                        }
+
                         self.dcx().span_err(
                             span,
                             "relaxed bounds are not permitted in trait object types",
@@ -2119,6 +2116,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         return;
                     }
                     RelaxedBoundForbiddenReason::SuperTrait => {
+                        if self.tcx.features().more_maybe_bounds() {
+                            return;
+                        }
+
                         let mut diag = self.dcx().struct_span_err(
                             span,
                             "relaxed bounds are not permitted in supertrait bounds",
diff --git a/tests/ui/trait-bounds/more_maybe_bounds.rs b/tests/ui/trait-bounds/more_maybe_bounds.rs
index d367dd5b299dd..ddd4313bd5e15 100644
--- a/tests/ui/trait-bounds/more_maybe_bounds.rs
+++ b/tests/ui/trait-bounds/more_maybe_bounds.rs
@@ -21,6 +21,20 @@ fn bar<T: ?Sized + ?Trait2 + ?Trait1 + ?Trait4>(_: &T) {}
 
 // FIXME: `?Trait1` should be rejected, `Trait1` isn't marked `#[lang = "default_traitN"]`.
 fn baz<T>() where T: Iterator<Item: ?Trait1> {}
+//~^ ERROR this relaxed bound is not permitted here
+
+struct S1<T>(T);
+
+impl<T> S1<T> {
+    fn f() where T: ?Trait1 {}
+    //~^ ERROR this relaxed bound is not permitted here
+}
+
+trait Trait5<'a> {}
+
+struct S2<T>(T) where for<'a> T: ?Trait5<'a>;
+//~^ ERROR this relaxed bound is not permitted here
+//~| ERROR bound modifier `?` can only be applied to default traits like `Sized`
 
 struct S;
 impl !Trait2 for S {}
diff --git a/tests/ui/trait-bounds/more_maybe_bounds.stderr b/tests/ui/trait-bounds/more_maybe_bounds.stderr
index 8dd83fc7728a9..0d78cfd582047 100644
--- a/tests/ui/trait-bounds/more_maybe_bounds.stderr
+++ b/tests/ui/trait-bounds/more_maybe_bounds.stderr
@@ -1,3 +1,27 @@
+error: this relaxed bound is not permitted here
+  --> $DIR/more_maybe_bounds.rs:23:37
+   |
+LL | fn baz<T>() where T: Iterator<Item: ?Trait1> {}
+   |                                     ^^^^^^^
+   |
+   = note: in this context, relaxed bounds are only allowed on type parameters defined by the closest item
+
+error: this relaxed bound is not permitted here
+  --> $DIR/more_maybe_bounds.rs:29:21
+   |
+LL |     fn f() where T: ?Trait1 {}
+   |                     ^^^^^^^
+   |
+   = note: in this context, relaxed bounds are only allowed on type parameters defined by the closest item
+
+error: this relaxed bound is not permitted here
+  --> $DIR/more_maybe_bounds.rs:35:34
+   |
+LL | struct S2<T>(T) where for<'a> T: ?Trait5<'a>;
+   |                                  ^^^^^^^^^^^
+   |
+   = note: in this context, relaxed bounds are only allowed on type parameters defined by the closest item
+
 error: bound modifier `?` can only be applied to default traits like `Sized`
   --> $DIR/more_maybe_bounds.rs:17:20
    |
@@ -16,5 +40,11 @@ error: bound modifier `?` can only be applied to default traits like `Sized`
 LL | fn bar<T: ?Sized + ?Trait2 + ?Trait1 + ?Trait4>(_: &T) {}
    |                                        ^^^^^^^
 
-error: aborting due to 3 previous errors
+error: bound modifier `?` can only be applied to default traits like `Sized`
+  --> $DIR/more_maybe_bounds.rs:35:34
+   |
+LL | struct S2<T>(T) where for<'a> T: ?Trait5<'a>;
+   |                                  ^^^^^^^^^^^
+
+error: aborting due to 7 previous errors
 
diff --git a/tests/ui/traits/default_auto_traits/maybe-bounds-in-traits.rs b/tests/ui/traits/default_auto_traits/maybe-bounds-in-traits.rs
index 820132b4e5433..ac4c4aca2efe3 100644
--- a/tests/ui/traits/default_auto_traits/maybe-bounds-in-traits.rs
+++ b/tests/ui/traits/default_auto_traits/maybe-bounds-in-traits.rs
@@ -42,11 +42,8 @@ struct LeakS;
 mod supertraits {
     use crate::*;
 
-    trait MaybeLeakT1: ?Leak {}
-    trait MaybeLeakT2 where Self: ?Leak {}
-
-    impl MaybeLeakT1 for NonLeakS {}
-    impl MaybeLeakT2 for NonLeakS {}
+    trait MaybeLeak: ?Leak {}
+    impl MaybeLeak for NonLeakS {}
 
     trait LeakT {}
     impl LeakT for NonLeakS {}
diff --git a/tests/ui/traits/default_auto_traits/maybe-bounds-in-traits.stderr b/tests/ui/traits/default_auto_traits/maybe-bounds-in-traits.stderr
index 95c77b1756cf9..ab62ab81b213b 100644
--- a/tests/ui/traits/default_auto_traits/maybe-bounds-in-traits.stderr
+++ b/tests/ui/traits/default_auto_traits/maybe-bounds-in-traits.stderr
@@ -1,5 +1,5 @@
 error[E0277]: the trait bound `NonLeakS: Leak` is not satisfied
-  --> $DIR/maybe-bounds-in-traits.rs:52:20
+  --> $DIR/maybe-bounds-in-traits.rs:49:20
    |
 LL |     impl LeakT for NonLeakS {}
    |                    ^^^^^^^^ unsatisfied trait bound
@@ -10,13 +10,13 @@ help: the trait `Leak` is not implemented for `NonLeakS`
 LL | struct NonLeakS;
    | ^^^^^^^^^^^^^^^
 note: required by a bound in `LeakT`
-  --> $DIR/maybe-bounds-in-traits.rs:51:5
+  --> $DIR/maybe-bounds-in-traits.rs:48:5
    |
 LL |     trait LeakT {}
    |     ^^^^^^^^^^^^^^ required by this bound in `LeakT`
 
 error[E0277]: the trait bound `NonLeakS: Leak` is not satisfied
-  --> $DIR/maybe-bounds-in-traits.rs:61:22
+  --> $DIR/maybe-bounds-in-traits.rs:58:22
    |
 LL |         type Leak2 = NonLeakS;
    |                      ^^^^^^^^ unsatisfied trait bound
@@ -27,13 +27,13 @@ help: the trait `Leak` is not implemented for `NonLeakS`
 LL | struct NonLeakS;
    | ^^^^^^^^^^^^^^^
 note: required by a bound in `Test1::Leak2`
-  --> $DIR/maybe-bounds-in-traits.rs:61:9
+  --> $DIR/maybe-bounds-in-traits.rs:58:9
    |
 LL |         type Leak2 = NonLeakS;
    |         ^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Test1::Leak2`
 
 error[E0658]: `&mut Self` cannot be used as the type of `self` without the `arbitrary_self_types` feature
-  --> $DIR/maybe-bounds-in-traits.rs:80:20
+  --> $DIR/maybe-bounds-in-traits.rs:77:20
    |
 LL |         fn mut_foo(&mut self) {}
    |                    ^^^^^^^^^

From b1c4e19e13d7ad2eea0d2afae92791c28d7239fa Mon Sep 17 00:00:00 2001
From: Romain Perier <romain.perier@gmail.com>
Date: Tue, 9 Sep 2025 19:57:56 +0200
Subject: [PATCH 0749/1889] Unify and deduplicate bits conv float tests

---
 library/coretests/tests/floats/f128.rs | 28 ------------
 library/coretests/tests/floats/f16.rs  | 27 -----------
 library/coretests/tests/floats/f32.rs  | 28 ------------
 library/coretests/tests/floats/f64.rs  | 27 -----------
 library/coretests/tests/floats/mod.rs  | 63 ++++++++++++++++++++++++++
 5 files changed, 63 insertions(+), 110 deletions(-)

diff --git a/library/coretests/tests/floats/f128.rs b/library/coretests/tests/floats/f128.rs
index 4267fef50f83c..d31eba863f5fe 100644
--- a/library/coretests/tests/floats/f128.rs
+++ b/library/coretests/tests/floats/f128.rs
@@ -17,12 +17,6 @@ const TOL: f128 = 1e-12;
 #[allow(unused)]
 const TOL_PRECISE: f128 = 1e-28;
 
-/// First pattern over the mantissa
-const NAN_MASK1: u128 = 0x0000aaaaaaaaaaaaaaaaaaaaaaaaaaaa;
-
-/// Second pattern over the mantissa
-const NAN_MASK2: u128 = 0x00005555555555555555555555555555;
-
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
@@ -54,28 +48,6 @@ fn test_max_recip() {
     );
 }
 
-#[test]
-fn test_float_bits_conv() {
-    assert_eq!((1f128).to_bits(), 0x3fff0000000000000000000000000000);
-    assert_eq!((12.5f128).to_bits(), 0x40029000000000000000000000000000);
-    assert_eq!((1337f128).to_bits(), 0x40094e40000000000000000000000000);
-    assert_eq!((-14.25f128).to_bits(), 0xc002c800000000000000000000000000);
-    assert_biteq!(f128::from_bits(0x3fff0000000000000000000000000000), 1.0);
-    assert_biteq!(f128::from_bits(0x40029000000000000000000000000000), 12.5);
-    assert_biteq!(f128::from_bits(0x40094e40000000000000000000000000), 1337.0);
-    assert_biteq!(f128::from_bits(0xc002c800000000000000000000000000), -14.25);
-
-    // Check that NaNs roundtrip their bits regardless of signaling-ness
-    // 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits
-    let masked_nan1 = f128::NAN.to_bits() ^ NAN_MASK1;
-    let masked_nan2 = f128::NAN.to_bits() ^ NAN_MASK2;
-    assert!(f128::from_bits(masked_nan1).is_nan());
-    assert!(f128::from_bits(masked_nan2).is_nan());
-
-    assert_eq!(f128::from_bits(masked_nan1).to_bits(), masked_nan1);
-    assert_eq!(f128::from_bits(masked_nan2).to_bits(), masked_nan2);
-}
-
 #[test]
 fn test_from() {
     assert_biteq!(f128::from(false), 0.0);
diff --git a/library/coretests/tests/floats/f16.rs b/library/coretests/tests/floats/f16.rs
index d2818a6d76897..302fd0861d75d 100644
--- a/library/coretests/tests/floats/f16.rs
+++ b/library/coretests/tests/floats/f16.rs
@@ -19,12 +19,6 @@ const TOL_P2: f16 = 0.5;
 #[allow(unused)]
 const TOL_P4: f16 = 10.0;
 
-/// First pattern over the mantissa
-const NAN_MASK1: u16 = 0x02aa;
-
-/// Second pattern over the mantissa
-const NAN_MASK2: u16 = 0x0155;
-
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
@@ -52,27 +46,6 @@ fn test_max_recip() {
     assert_approx_eq!(f16::MAX.recip(), 1.526624e-5f16, 1e-4);
 }
 
-#[test]
-fn test_float_bits_conv() {
-    assert_eq!((1f16).to_bits(), 0x3c00);
-    assert_eq!((12.5f16).to_bits(), 0x4a40);
-    assert_eq!((1337f16).to_bits(), 0x6539);
-    assert_eq!((-14.25f16).to_bits(), 0xcb20);
-    assert_biteq!(f16::from_bits(0x3c00), 1.0);
-    assert_biteq!(f16::from_bits(0x4a40), 12.5);
-    assert_biteq!(f16::from_bits(0x6539), 1337.0);
-    assert_biteq!(f16::from_bits(0xcb20), -14.25);
-
-    // Check that NaNs roundtrip their bits regardless of signaling-ness
-    let masked_nan1 = f16::NAN.to_bits() ^ NAN_MASK1;
-    let masked_nan2 = f16::NAN.to_bits() ^ NAN_MASK2;
-    assert!(f16::from_bits(masked_nan1).is_nan());
-    assert!(f16::from_bits(masked_nan2).is_nan());
-
-    assert_eq!(f16::from_bits(masked_nan1).to_bits(), masked_nan1);
-    assert_eq!(f16::from_bits(masked_nan2).to_bits(), masked_nan2);
-}
-
 #[test]
 fn test_from() {
     assert_biteq!(f16::from(false), 0.0);
diff --git a/library/coretests/tests/floats/f32.rs b/library/coretests/tests/floats/f32.rs
index 7b25f354da428..a1fe8b076501d 100644
--- a/library/coretests/tests/floats/f32.rs
+++ b/library/coretests/tests/floats/f32.rs
@@ -2,12 +2,6 @@ use core::f32;
 
 use super::assert_biteq;
 
-/// First pattern over the mantissa
-const NAN_MASK1: u32 = 0x002a_aaaa;
-
-/// Second pattern over the mantissa
-const NAN_MASK2: u32 = 0x0055_5555;
-
 // FIXME(#140515): mingw has an incorrect fma https://sourceforge.net/p/mingw-w64/bugs/848/
 #[cfg_attr(all(target_os = "windows", target_env = "gnu", not(target_abi = "llvm")), ignore)]
 #[test]
@@ -25,25 +19,3 @@ fn test_mul_add() {
     assert_biteq!(f32::math::mul_add(8.9f32, inf, 3.2), inf);
     assert_biteq!(f32::math::mul_add(-3.2f32, 2.4, neg_inf), neg_inf);
 }
-
-#[test]
-fn test_float_bits_conv() {
-    assert_eq!((1f32).to_bits(), 0x3f800000);
-    assert_eq!((12.5f32).to_bits(), 0x41480000);
-    assert_eq!((1337f32).to_bits(), 0x44a72000);
-    assert_eq!((-14.25f32).to_bits(), 0xc1640000);
-    assert_biteq!(f32::from_bits(0x3f800000), 1.0);
-    assert_biteq!(f32::from_bits(0x41480000), 12.5);
-    assert_biteq!(f32::from_bits(0x44a72000), 1337.0);
-    assert_biteq!(f32::from_bits(0xc1640000), -14.25);
-
-    // Check that NaNs roundtrip their bits regardless of signaling-ness
-    // 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits
-    let masked_nan1 = f32::NAN.to_bits() ^ NAN_MASK1;
-    let masked_nan2 = f32::NAN.to_bits() ^ NAN_MASK2;
-    assert!(f32::from_bits(masked_nan1).is_nan());
-    assert!(f32::from_bits(masked_nan2).is_nan());
-
-    assert_eq!(f32::from_bits(masked_nan1).to_bits(), masked_nan1);
-    assert_eq!(f32::from_bits(masked_nan2).to_bits(), masked_nan2);
-}
diff --git a/library/coretests/tests/floats/f64.rs b/library/coretests/tests/floats/f64.rs
index 099d85627a346..4c5a3d68d1fd6 100644
--- a/library/coretests/tests/floats/f64.rs
+++ b/library/coretests/tests/floats/f64.rs
@@ -2,12 +2,6 @@ use core::f64;
 
 use super::assert_biteq;
 
-/// First pattern over the mantissa
-const NAN_MASK1: u64 = 0x000a_aaaa_aaaa_aaaa;
-
-/// Second pattern over the mantissa
-const NAN_MASK2: u64 = 0x0005_5555_5555_5555;
-
 // FIXME(#140515): mingw has an incorrect fma https://sourceforge.net/p/mingw-w64/bugs/848/
 #[cfg_attr(all(target_os = "windows", target_env = "gnu", not(target_abi = "llvm")), ignore)]
 #[test]
@@ -25,24 +19,3 @@ fn test_mul_add() {
     assert_biteq!(8.9f64.mul_add(inf, 3.2), inf);
     assert_biteq!((-3.2f64).mul_add(2.4, neg_inf), neg_inf);
 }
-
-#[test]
-fn test_float_bits_conv() {
-    assert_eq!((1f64).to_bits(), 0x3ff0000000000000);
-    assert_eq!((12.5f64).to_bits(), 0x4029000000000000);
-    assert_eq!((1337f64).to_bits(), 0x4094e40000000000);
-    assert_eq!((-14.25f64).to_bits(), 0xc02c800000000000);
-    assert_biteq!(f64::from_bits(0x3ff0000000000000), 1.0);
-    assert_biteq!(f64::from_bits(0x4029000000000000), 12.5);
-    assert_biteq!(f64::from_bits(0x4094e40000000000), 1337.0);
-    assert_biteq!(f64::from_bits(0xc02c800000000000), -14.25);
-
-    // Check that NaNs roundtrip their bits regardless of signaling-ness
-    let masked_nan1 = f64::NAN.to_bits() ^ NAN_MASK1;
-    let masked_nan2 = f64::NAN.to_bits() ^ NAN_MASK2;
-    assert!(f64::from_bits(masked_nan1).is_nan());
-    assert!(f64::from_bits(masked_nan2).is_nan());
-
-    assert_eq!(f64::from_bits(masked_nan1).to_bits(), masked_nan1);
-    assert_eq!(f64::from_bits(masked_nan2).to_bits(), masked_nan2);
-}
diff --git a/library/coretests/tests/floats/mod.rs b/library/coretests/tests/floats/mod.rs
index c0439845a4a48..31515561c637b 100644
--- a/library/coretests/tests/floats/mod.rs
+++ b/library/coretests/tests/floats/mod.rs
@@ -30,6 +30,10 @@ trait TestableFloat: Sized {
     const EPS_ADD: Self;
     const EPS_MUL: Self;
     const EPS_DIV: Self;
+    const RAW_1: Self;
+    const RAW_12_DOT_5: Self;
+    const RAW_1337: Self;
+    const RAW_MINUS_14_DOT_25: Self;
 }
 
 impl TestableFloat for f16 {
@@ -50,6 +54,10 @@ impl TestableFloat for f16 {
     const EPS_ADD: Self = if cfg!(miri) { 1e1 } else { 0.0 };
     const EPS_MUL: Self = if cfg!(miri) { 1e3 } else { 0.0 };
     const EPS_DIV: Self = if cfg!(miri) { 1e0 } else { 0.0 };
+    const RAW_1: Self = Self::from_bits(0x3c00);
+    const RAW_12_DOT_5: Self = Self::from_bits(0x4a40);
+    const RAW_1337: Self = Self::from_bits(0x6539);
+    const RAW_MINUS_14_DOT_25: Self = Self::from_bits(0xcb20);
 }
 
 impl TestableFloat for f32 {
@@ -72,6 +80,10 @@ impl TestableFloat for f32 {
     const EPS_ADD: Self = if cfg!(miri) { 1e-3 } else { 0.0 };
     const EPS_MUL: Self = if cfg!(miri) { 1e-1 } else { 0.0 };
     const EPS_DIV: Self = if cfg!(miri) { 1e-4 } else { 0.0 };
+    const RAW_1: Self = Self::from_bits(0x3f800000);
+    const RAW_12_DOT_5: Self = Self::from_bits(0x41480000);
+    const RAW_1337: Self = Self::from_bits(0x44a72000);
+    const RAW_MINUS_14_DOT_25: Self = Self::from_bits(0xc1640000);
 }
 
 impl TestableFloat for f64 {
@@ -90,6 +102,10 @@ impl TestableFloat for f64 {
     const EPS_ADD: Self = if cfg!(miri) { 1e-6 } else { 0.0 };
     const EPS_MUL: Self = if cfg!(miri) { 1e-6 } else { 0.0 };
     const EPS_DIV: Self = if cfg!(miri) { 1e-6 } else { 0.0 };
+    const RAW_1: Self = Self::from_bits(0x3ff0000000000000);
+    const RAW_12_DOT_5: Self = Self::from_bits(0x4029000000000000);
+    const RAW_1337: Self = Self::from_bits(0x4094e40000000000);
+    const RAW_MINUS_14_DOT_25: Self = Self::from_bits(0xc02c800000000000);
 }
 
 impl TestableFloat for f128 {
@@ -108,6 +124,10 @@ impl TestableFloat for f128 {
     const EPS_ADD: Self = if cfg!(miri) { 1e-6 } else { 0.0 };
     const EPS_MUL: Self = if cfg!(miri) { 1e-6 } else { 0.0 };
     const EPS_DIV: Self = if cfg!(miri) { 1e-6 } else { 0.0 };
+    const RAW_1: Self = Self::from_bits(0x3fff0000000000000000000000000000);
+    const RAW_12_DOT_5: Self = Self::from_bits(0x40029000000000000000000000000000);
+    const RAW_1337: Self = Self::from_bits(0x40094e40000000000000000000000000);
+    const RAW_MINUS_14_DOT_25: Self = Self::from_bits(0xc002c800000000000000000000000000);
 }
 
 /// Determine the tolerance for values of the argument type.
@@ -250,6 +270,8 @@ macro_rules! float_test {
             $( $( #[$f16_meta] )+ )?
             fn test_f16() {
                 type $fty = f16;
+                #[allow(unused)]
+                const fn flt (x: $fty) -> $fty { x }
                 $test
             }
 
@@ -257,6 +279,8 @@ macro_rules! float_test {
             $( $( #[$f32_meta] )+ )?
             fn test_f32() {
                 type $fty = f32;
+                #[allow(unused)]
+                const fn flt (x: $fty) -> $fty { x }
                 $test
             }
 
@@ -264,6 +288,8 @@ macro_rules! float_test {
             $( $( #[$f64_meta] )+ )?
             fn test_f64() {
                 type $fty = f64;
+                #[allow(unused)]
+                const fn flt (x: $fty) -> $fty { x }
                 $test
             }
 
@@ -271,6 +297,8 @@ macro_rules! float_test {
             $( $( #[$f128_meta] )+ )?
             fn test_f128() {
                 type $fty = f128;
+                #[allow(unused)]
+                const fn flt (x: $fty) -> $fty { x }
                 $test
             }
 
@@ -293,6 +321,8 @@ macro_rules! float_test {
                 $( $( #[$f16_const_meta] )+ )?
                 fn test_f16() {
                     type $fty = f16;
+                    #[allow(unused)]
+                    const fn flt (x: $fty) -> $fty { x }
                     const { $test }
                 }
 
@@ -300,6 +330,8 @@ macro_rules! float_test {
                 $( $( #[$f32_const_meta] )+ )?
                 fn test_f32() {
                     type $fty = f32;
+                    #[allow(unused)]
+                    const fn flt (x: $fty) -> $fty { x }
                     const { $test }
                 }
 
@@ -307,6 +339,8 @@ macro_rules! float_test {
                 $( $( #[$f64_const_meta] )+ )?
                 fn test_f64() {
                     type $fty = f64;
+                    #[allow(unused)]
+                    const fn flt (x: $fty) -> $fty { x }
                     const { $test }
                 }
 
@@ -314,6 +348,8 @@ macro_rules! float_test {
                 $( $( #[$f128_const_meta] )+ )?
                 fn test_f128() {
                     type $fty = f128;
+                    #[allow(unused)]
+                    const fn flt (x: $fty) -> $fty { x }
                     const { $test }
                 }
             }
@@ -1479,3 +1515,30 @@ float_test! {
         assert_approx_eq!(a.algebraic_rem(b), a % b, Float::EPS_DIV);
     }
 }
+
+float_test! {
+    name: to_bits_conv,
+    attrs: {
+        f16: #[cfg(target_has_reliable_f16)],
+        f128: #[cfg(target_has_reliable_f128)],
+    },
+    test<Float> {
+        assert_biteq!(flt(1.0), Float::RAW_1);
+        assert_biteq!(flt(12.5), Float::RAW_12_DOT_5);
+        assert_biteq!(flt(1337.0), Float::RAW_1337);
+        assert_biteq!(flt(-14.25), Float::RAW_MINUS_14_DOT_25);
+        assert_biteq!(Float::RAW_1, 1.0);
+        assert_biteq!(Float::RAW_12_DOT_5, 12.5);
+        assert_biteq!(Float::RAW_1337, 1337.0);
+        assert_biteq!(Float::RAW_MINUS_14_DOT_25, -14.25);
+
+        // Check that NaNs roundtrip their bits regardless of signaling-ness
+        let masked_nan1 = Float::NAN.to_bits() ^ Float::NAN_MASK1;
+        let masked_nan2 = Float::NAN.to_bits() ^ Float::NAN_MASK2;
+        assert!(Float::from_bits(masked_nan1).is_nan());
+        assert!(Float::from_bits(masked_nan2).is_nan());
+
+        assert_biteq!(Float::from_bits(masked_nan1), Float::from_bits(masked_nan1));
+        assert_biteq!(Float::from_bits(masked_nan2), Float::from_bits(masked_nan2));
+    }
+}

From ad08577a503dfd03e308bd272e76d95e31c6d0ef Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Sat, 9 Aug 2025 19:07:08 +0200
Subject: [PATCH 0750/1889] std: move `thread` into `sys`

---
 library/std/src/sys/mod.rs                |   1 +
 library/std/src/sys/pal/hermit/mod.rs     |   1 -
 library/std/src/sys/pal/sgx/abi/mod.rs    |   2 +-
 library/std/src/sys/pal/sgx/mod.rs        |   1 -
 library/std/src/sys/pal/solid/mod.rs      |   4 +-
 library/std/src/sys/pal/teeos/mod.rs      |   1 -
 library/std/src/sys/pal/uefi/mod.rs       |   1 -
 library/std/src/sys/pal/unix/mod.rs       |   3 +-
 library/std/src/sys/pal/wasip1/mod.rs     |   1 -
 library/std/src/sys/pal/wasip2/mod.rs     |   1 -
 library/std/src/sys/pal/wasip2/time.rs    |   2 +-
 library/std/src/sys/pal/wasm/mod.rs       |  15 +-
 library/std/src/sys/pal/windows/mod.rs    |   5 +-
 library/std/src/sys/pal/windows/time.rs   |   2 +-
 library/std/src/sys/pal/xous/mod.rs       |   1 -
 library/std/src/sys/thread/hermit.rs      |  66 +--
 library/std/src/sys/thread/mod.rs         | 152 +++++
 library/std/src/sys/thread/sgx.rs         |  49 +-
 library/std/src/sys/thread/solid.rs       |  42 +-
 library/std/src/sys/thread/teeos.rs       |  71 +--
 library/std/src/sys/thread/uefi.rs        |  73 +--
 library/std/src/sys/thread/unix.rs        | 667 +++++++++++-----------
 library/std/src/sys/thread/unsupported.rs |  39 +-
 library/std/src/sys/thread/wasip1.rs      | 329 +++++------
 library/std/src/sys/thread/wasip2.rs      |  87 +--
 library/std/src/sys/thread/wasm.rs        |  94 +--
 library/std/src/sys/thread/windows.rs     | 112 ++--
 library/std/src/sys/thread/xous.rs        |  54 +-
 library/std/src/thread/mod.rs             |   8 +-
 29 files changed, 842 insertions(+), 1042 deletions(-)
 create mode 100644 library/std/src/sys/thread/mod.rs

diff --git a/library/std/src/sys/mod.rs b/library/std/src/sys/mod.rs
index 8c11501558069..2dbdc8a4e026e 100644
--- a/library/std/src/sys/mod.rs
+++ b/library/std/src/sys/mod.rs
@@ -31,6 +31,7 @@ pub mod process;
 pub mod random;
 pub mod stdio;
 pub mod sync;
+pub mod thread;
 pub mod thread_local;
 
 // FIXME(117276): remove this, move feature implementations into individual
diff --git a/library/std/src/sys/pal/hermit/mod.rs b/library/std/src/sys/pal/hermit/mod.rs
index fb8d69b73759d..3ddf6e5acb02e 100644
--- a/library/std/src/sys/pal/hermit/mod.rs
+++ b/library/std/src/sys/pal/hermit/mod.rs
@@ -25,7 +25,6 @@ pub mod futex;
 pub mod os;
 #[path = "../unsupported/pipe.rs"]
 pub mod pipe;
-pub mod thread;
 pub mod time;
 
 pub fn unsupported<T>() -> crate::io::Result<T> {
diff --git a/library/std/src/sys/pal/sgx/abi/mod.rs b/library/std/src/sys/pal/sgx/abi/mod.rs
index 57247cffad3f2..b8c4d7740c4e1 100644
--- a/library/std/src/sys/pal/sgx/abi/mod.rs
+++ b/library/std/src/sys/pal/sgx/abi/mod.rs
@@ -67,7 +67,7 @@ extern "C" fn entry(p1: u64, p2: u64, p3: u64, secondary: bool, p4: u64, p5: u64
     let tls_guard = unsafe { tls.activate() };
 
     if secondary {
-        let join_notifier = super::thread::Thread::entry();
+        let join_notifier = crate::sys::thread::Thread::entry();
         drop(tls_guard);
         drop(join_notifier);
 
diff --git a/library/std/src/sys/pal/sgx/mod.rs b/library/std/src/sys/pal/sgx/mod.rs
index 4a297b6823f20..9a33873af581f 100644
--- a/library/std/src/sys/pal/sgx/mod.rs
+++ b/library/std/src/sys/pal/sgx/mod.rs
@@ -13,7 +13,6 @@ mod libunwind_integration;
 pub mod os;
 #[path = "../unsupported/pipe.rs"]
 pub mod pipe;
-pub mod thread;
 pub mod thread_parking;
 pub mod time;
 pub mod waitqueue;
diff --git a/library/std/src/sys/pal/solid/mod.rs b/library/std/src/sys/pal/solid/mod.rs
index 0011cf256df74..9ca6dc581183d 100644
--- a/library/std/src/sys/pal/solid/mod.rs
+++ b/library/std/src/sys/pal/solid/mod.rs
@@ -10,10 +10,8 @@ pub mod itron {
     pub mod error;
     pub mod spin;
     pub mod task;
-    pub mod thread;
     pub mod thread_parking;
     pub mod time;
-    use super::unsupported;
 }
 
 // `error` is `pub(crate)` so that it can be accessed by `itron/error.rs` as
@@ -22,7 +20,7 @@ pub(crate) mod error;
 pub mod os;
 #[path = "../unsupported/pipe.rs"]
 pub mod pipe;
-pub use self::itron::{thread, thread_parking};
+pub use self::itron::thread_parking;
 pub mod time;
 
 // SAFETY: must be called only once during runtime initialization.
diff --git a/library/std/src/sys/pal/teeos/mod.rs b/library/std/src/sys/pal/teeos/mod.rs
index c7b1777725858..dd0155265da63 100644
--- a/library/std/src/sys/pal/teeos/mod.rs
+++ b/library/std/src/sys/pal/teeos/mod.rs
@@ -9,7 +9,6 @@
 pub mod os;
 #[path = "../unsupported/pipe.rs"]
 pub mod pipe;
-pub mod thread;
 #[allow(non_upper_case_globals)]
 #[path = "../unix/time.rs"]
 pub mod time;
diff --git a/library/std/src/sys/pal/uefi/mod.rs b/library/std/src/sys/pal/uefi/mod.rs
index 8911a2ee5194d..ebd311db1e12c 100644
--- a/library/std/src/sys/pal/uefi/mod.rs
+++ b/library/std/src/sys/pal/uefi/mod.rs
@@ -17,7 +17,6 @@ pub mod helpers;
 pub mod os;
 #[path = "../unsupported/pipe.rs"]
 pub mod pipe;
-pub mod thread;
 pub mod time;
 
 #[cfg(test)]
diff --git a/library/std/src/sys/pal/unix/mod.rs b/library/std/src/sys/pal/unix/mod.rs
index ac5c823a1bf6d..dd1059fe04a2d 100644
--- a/library/std/src/sys/pal/unix/mod.rs
+++ b/library/std/src/sys/pal/unix/mod.rs
@@ -17,7 +17,6 @@ pub mod os;
 pub mod pipe;
 pub mod stack_overflow;
 pub mod sync;
-pub mod thread;
 pub mod thread_parking;
 pub mod time;
 
@@ -55,7 +54,7 @@ pub unsafe fn init(argc: isize, argv: *const *const u8, sigpipe: u8) {
     // thread-id for the main thread and so renaming the main thread will rename the
     // process and we only want to enable this on platforms we've tested.
     if cfg!(target_vendor = "apple") {
-        thread::Thread::set_name(&c"main");
+        crate::sys::thread::set_name(c"main");
     }
 
     unsafe fn sanitize_standard_fds() {
diff --git a/library/std/src/sys/pal/wasip1/mod.rs b/library/std/src/sys/pal/wasip1/mod.rs
index 61dd1c3f98b10..ae5da3c1f77be 100644
--- a/library/std/src/sys/pal/wasip1/mod.rs
+++ b/library/std/src/sys/pal/wasip1/mod.rs
@@ -20,7 +20,6 @@ pub mod futex;
 pub mod os;
 #[path = "../unsupported/pipe.rs"]
 pub mod pipe;
-pub mod thread;
 pub mod time;
 
 #[path = "../unsupported/common.rs"]
diff --git a/library/std/src/sys/pal/wasip2/mod.rs b/library/std/src/sys/pal/wasip2/mod.rs
index 5f3fb6d6ddfbf..c1d89da2677c9 100644
--- a/library/std/src/sys/pal/wasip2/mod.rs
+++ b/library/std/src/sys/pal/wasip2/mod.rs
@@ -14,7 +14,6 @@ pub mod futex;
 pub mod os;
 #[path = "../unsupported/pipe.rs"]
 pub mod pipe;
-pub mod thread;
 pub mod time;
 
 #[path = "../unsupported/common.rs"]
diff --git a/library/std/src/sys/pal/wasip2/time.rs b/library/std/src/sys/pal/wasip2/time.rs
index f1f6839774b91..980070e7b851e 100644
--- a/library/std/src/sys/pal/wasip2/time.rs
+++ b/library/std/src/sys/pal/wasip2/time.rs
@@ -25,7 +25,7 @@ impl Instant {
         Some(Instant(self.0.checked_sub(*other)?))
     }
 
-    pub(super) fn as_duration(&self) -> &Duration {
+    pub(crate) fn as_duration(&self) -> &Duration {
         &self.0
     }
 }
diff --git a/library/std/src/sys/pal/wasm/mod.rs b/library/std/src/sys/pal/wasm/mod.rs
index 346c9ff88c963..a20cd0e9ac776 100644
--- a/library/std/src/sys/pal/wasm/mod.rs
+++ b/library/std/src/sys/pal/wasm/mod.rs
@@ -23,18 +23,9 @@ pub mod pipe;
 #[path = "../unsupported/time.rs"]
 pub mod time;
 
-cfg_select! {
-    target_feature = "atomics" => {
-        #[path = "atomics/futex.rs"]
-        pub mod futex;
-        #[path = "atomics/thread.rs"]
-        pub mod thread;
-    }
-    _ => {
-        #[path = "../unsupported/thread.rs"]
-        pub mod thread;
-    }
-}
+#[cfg(target_feature = "atomics")]
+#[path = "atomics/futex.rs"]
+pub mod futex;
 
 #[path = "../unsupported/common.rs"]
 #[deny(unsafe_op_in_unsafe_fn)]
diff --git a/library/std/src/sys/pal/windows/mod.rs b/library/std/src/sys/pal/windows/mod.rs
index 3b6a86cbc8f41..3357946b8f71d 100644
--- a/library/std/src/sys/pal/windows/mod.rs
+++ b/library/std/src/sys/pal/windows/mod.rs
@@ -20,7 +20,6 @@ pub mod futex;
 pub mod handle;
 pub mod os;
 pub mod pipe;
-pub mod thread;
 pub mod time;
 cfg_select! {
     not(target_vendor = "uwp") => {
@@ -48,9 +47,9 @@ pub unsafe fn init(_argc: isize, _argv: *const *const u8, _sigpipe: u8) {
     unsafe {
         stack_overflow::init();
 
-        // Normally, `thread::spawn` will call `Thread::set_name` but since this thread already
+        // Normally, `thread::spawn` will call `set_name` but since this thread already
         // exists, we have to call it ourselves.
-        thread::Thread::set_name_wide(wide_str!("main"));
+        crate::sys::thread::set_name_wide(wide_str!("main"));
     }
 }
 
diff --git a/library/std/src/sys/pal/windows/time.rs b/library/std/src/sys/pal/windows/time.rs
index a948c07e0a31e..f8f9a9fd81809 100644
--- a/library/std/src/sys/pal/windows/time.rs
+++ b/library/std/src/sys/pal/windows/time.rs
@@ -232,7 +232,7 @@ mod perf_counter {
 }
 
 /// A timer you can wait on.
-pub(super) struct WaitableTimer {
+pub(crate) struct WaitableTimer {
     handle: c::HANDLE,
 }
 impl WaitableTimer {
diff --git a/library/std/src/sys/pal/xous/mod.rs b/library/std/src/sys/pal/xous/mod.rs
index 042c4ff862ff6..e673157e0eb55 100644
--- a/library/std/src/sys/pal/xous/mod.rs
+++ b/library/std/src/sys/pal/xous/mod.rs
@@ -5,7 +5,6 @@ use crate::os::xous::ffi::exit;
 pub mod os;
 #[path = "../unsupported/pipe.rs"]
 pub mod pipe;
-pub mod thread;
 pub mod time;
 
 #[path = "../unsupported/common.rs"]
diff --git a/library/std/src/sys/thread/hermit.rs b/library/std/src/sys/thread/hermit.rs
index cc4734b681908..4d9f3b114c2a0 100644
--- a/library/std/src/sys/thread/hermit.rs
+++ b/library/std/src/sys/thread/hermit.rs
@@ -1,10 +1,5 @@
-#![allow(dead_code)]
-
-use super::hermit_abi;
-use crate::ffi::CStr;
-use crate::mem::ManuallyDrop;
 use crate::num::NonZero;
-use crate::time::{Duration, Instant};
+use crate::time::Duration;
 use crate::{io, ptr};
 
 pub type Tid = hermit_abi::Tid;
@@ -68,57 +63,30 @@ impl Thread {
         }
     }
 
-    #[inline]
-    pub fn yield_now() {
-        unsafe {
-            hermit_abi::yield_now();
-        }
-    }
-
-    #[inline]
-    pub fn set_name(_name: &CStr) {
-        // nope
-    }
-
-    #[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);
-        }
-    }
-
-    pub fn sleep_until(deadline: Instant) {
-        let now = Instant::now();
-
-        if let Some(delay) = deadline.checked_duration_since(now) {
-            Self::sleep(delay);
-        }
-    }
-
     pub fn join(self) {
         unsafe {
             let _ = hermit_abi::join(self.tid);
         }
     }
+}
 
-    #[inline]
-    pub fn id(&self) -> Tid {
-        self.tid
-    }
-
-    #[inline]
-    pub fn into_id(self) -> Tid {
-        ManuallyDrop::new(self).tid
-    }
+pub fn available_parallelism() -> io::Result<NonZero<usize>> {
+    unsafe { Ok(NonZero::new_unchecked(hermit_abi::available_parallelism())) }
 }
 
-pub(crate) fn current_os_id() -> Option<u64> {
-    None
+#[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);
+    }
 }
 
-pub fn available_parallelism() -> io::Result<NonZero<usize>> {
-    unsafe { Ok(NonZero::new_unchecked(hermit_abi::available_parallelism())) }
+#[inline]
+pub fn yield_now() {
+    unsafe {
+        hermit_abi::yield_now();
+    }
 }
diff --git a/library/std/src/sys/thread/mod.rs b/library/std/src/sys/thread/mod.rs
new file mode 100644
index 0000000000000..6bb7fc1a20e2f
--- /dev/null
+++ b/library/std/src/sys/thread/mod.rs
@@ -0,0 +1,152 @@
+cfg_select! {
+    target_os = "hermit" => {
+        mod hermit;
+        pub use hermit::{Thread, available_parallelism, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
+        #[expect(dead_code)]
+        mod unsupported;
+        pub use unsupported::{current_os_id, set_name};
+    }
+    all(target_vendor = "fortanix", target_env = "sgx") => {
+        mod sgx;
+        pub use sgx::{Thread, current_os_id, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
+
+        // SGX should protect in-enclave data from outside attackers, so there
+        // must not be any data leakage to the OS, particularly no 1-1 mapping
+        // between SGX thread names and OS thread names. Hence `set_name` is
+        // intentionally a no-op.
+        //
+        // Note that the internally visible SGX thread name is already provided
+        // by the platform-agnostic Rust thread code. This can be observed in
+        // the [`std::thread::tests::test_named_thread`] test, which succeeds
+        // as-is with the SGX target.
+        #[expect(dead_code)]
+        mod unsupported;
+        pub use unsupported::{available_parallelism, set_name};
+    }
+    target_os = "solid_asp3" => {
+        mod solid;
+        pub use solid::{Thread, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
+        #[expect(dead_code)]
+        mod unsupported;
+        pub use unsupported::{available_parallelism, current_os_id, set_name};
+    }
+    target_os = "teeos" => {
+        mod teeos;
+        pub use teeos::{Thread, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
+        #[expect(dead_code)]
+        mod unsupported;
+        pub use unsupported::{available_parallelism, current_os_id, set_name};
+    }
+    target_os = "uefi" => {
+        mod uefi;
+        pub use uefi::{available_parallelism, sleep};
+        #[expect(dead_code)]
+        mod unsupported;
+        pub use unsupported::{Thread, current_os_id, set_name, yield_now, DEFAULT_MIN_STACK_SIZE};
+    }
+    target_family = "unix" => {
+        mod unix;
+        pub use unix::{Thread, available_parallelism, current_os_id, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
+        #[cfg(not(any(
+            target_env = "newlib",
+            target_os = "l4re",
+            target_os = "emscripten",
+            target_os = "redox",
+            target_os = "hurd",
+            target_os = "aix",
+        )))]
+        pub use unix::set_name;
+        #[cfg(any(
+            target_os = "freebsd",
+            target_os = "netbsd",
+            target_os = "linux",
+            target_os = "android",
+            target_os = "solaris",
+            target_os = "illumos",
+            target_os = "dragonfly",
+            target_os = "hurd",
+            target_os = "fuchsia",
+            target_os = "vxworks",
+        ))]
+        pub use unix::sleep_until;
+        #[expect(dead_code)]
+        mod unsupported;
+        #[cfg(any(
+            target_env = "newlib",
+            target_os = "l4re",
+            target_os = "emscripten",
+            target_os = "redox",
+            target_os = "hurd",
+            target_os = "aix",
+        ))]
+        pub use unsupported::set_name;
+    }
+    all(target_os = "wasi", target_env = "p1") => {
+        mod wasip1;
+        pub use wasip1::{DEFAULT_MIN_STACK_SIZE, sleep, yield_now};
+        #[cfg(target_feature = "atomics")]
+        pub use wasip1::{Thread, available_parallelism};
+        #[expect(dead_code)]
+        mod unsupported;
+        pub use unsupported::{current_os_id, set_name};
+        #[cfg(not(target_feature = "atomics"))]
+        pub use unsupported::{Thread, available_parallelism};
+    }
+    all(target_os = "wasi", target_env = "p2") => {
+        mod wasip2;
+        pub use wasip2::{sleep, sleep_until};
+        #[expect(dead_code)]
+        mod unsupported;
+        // Note that unlike WASIp1 even if the wasm `atomics` feature is enabled
+        // there is no support for threads, not even experimentally, not even in
+        // wasi-libc. Thus this is unconditionally unsupported.
+        pub use unsupported::{Thread, available_parallelism, current_os_id, set_name, yield_now, DEFAULT_MIN_STACK_SIZE};
+    }
+    all(target_family = "wasm", target_feature = "atomics") => {
+        mod wasm;
+        pub use wasm::sleep;
+
+        #[expect(dead_code)]
+        mod unsupported;
+        pub use unsupported::{Thread, available_parallelism, current_os_id, set_name, yield_now, DEFAULT_MIN_STACK_SIZE};
+    }
+    target_os = "windows" => {
+        mod windows;
+        pub use windows::{Thread, available_parallelism, current_os_id, set_name, set_name_wide, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
+    }
+    target_os = "xous" => {
+        mod xous;
+        pub use xous::{Thread, available_parallelism, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
+
+        #[expect(dead_code)]
+        mod unsupported;
+        pub use unsupported::{current_os_id, set_name};
+    }
+    _ => {
+        mod unsupported;
+        pub use unsupported::{Thread, available_parallelism, current_os_id, set_name, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
+    }
+}
+
+#[cfg(not(any(
+    target_os = "freebsd",
+    target_os = "netbsd",
+    target_os = "linux",
+    target_os = "android",
+    target_os = "solaris",
+    target_os = "illumos",
+    target_os = "dragonfly",
+    target_os = "hurd",
+    target_os = "fuchsia",
+    target_os = "vxworks",
+    all(target_os = "wasi", target_env = "p2"),
+)))]
+pub fn sleep_until(deadline: crate::time::Instant) {
+    use crate::time::Instant;
+
+    let now = Instant::now();
+
+    if let Some(delay) = deadline.checked_duration_since(now) {
+        sleep(delay);
+    }
+}
diff --git a/library/std/src/sys/thread/sgx.rs b/library/std/src/sys/thread/sgx.rs
index 1f613badcd704..f20ef7d86b9c7 100644
--- a/library/std/src/sys/thread/sgx.rs
+++ b/library/std/src/sys/thread/sgx.rs
@@ -1,11 +1,8 @@
 #![cfg_attr(test, allow(dead_code))] // why is this necessary?
 
-use super::abi::{thread, usercalls};
-use super::unsupported;
-use crate::ffi::CStr;
 use crate::io;
-use crate::num::NonZero;
-use crate::time::{Duration, Instant};
+use crate::sys::pal::abi::{thread, usercalls};
+use crate::time::Duration;
 
 pub struct Thread(task_queue::JoinHandle);
 
@@ -108,51 +105,27 @@ impl Thread {
         Ok(Thread(handle))
     }
 
-    pub(super) fn entry() -> JoinNotifier {
+    pub(crate) fn entry() -> JoinNotifier {
         let mut pending_tasks = task_queue::lock();
         let task = rtunwrap!(Some, pending_tasks.pop());
         drop(pending_tasks); // make sure to not hold the task queue lock longer than necessary
         task.run()
     }
 
-    pub fn yield_now() {
-        let wait_error = rtunwrap!(Err, usercalls::wait(0, usercalls::raw::WAIT_NO));
-        rtassert!(wait_error.kind() == io::ErrorKind::WouldBlock);
-    }
-
-    /// SGX should protect in-enclave data from the outside (attacker),
-    /// so there should be no data leakage to the OS,
-    /// and therefore also no 1-1 mapping between SGX thread names and OS thread names.
-    ///
-    /// This is why the method is intentionally No-Op.
-    pub fn set_name(_name: &CStr) {
-        // Note that the internally visible SGX thread name is already provided
-        // by the platform-agnostic (target-agnostic) Rust thread code.
-        // This can be observed in the [`std::thread::tests::test_named_thread`] test,
-        // which succeeds as-is with the SGX target.
-    }
-
-    pub fn sleep(dur: Duration) {
-        usercalls::wait_timeout(0, dur, || true);
-    }
-
-    pub fn sleep_until(deadline: Instant) {
-        let now = Instant::now();
-
-        if let Some(delay) = deadline.checked_duration_since(now) {
-            Self::sleep(delay);
-        }
-    }
-
     pub fn join(self) {
         self.0.wait();
     }
 }
 
-pub(crate) fn current_os_id() -> Option<u64> {
+pub fn current_os_id() -> Option<u64> {
     Some(thread::current().addr().get() as u64)
 }
 
-pub fn available_parallelism() -> io::Result<NonZero<usize>> {
-    unsupported()
+pub fn sleep(dur: Duration) {
+    usercalls::wait_timeout(0, dur, || true);
+}
+
+pub fn yield_now() {
+    let wait_error = rtunwrap!(Err, usercalls::wait(0, usercalls::raw::WAIT_NO));
+    rtassert!(wait_error.kind() == io::ErrorKind::WouldBlock);
 }
diff --git a/library/std/src/sys/thread/solid.rs b/library/std/src/sys/thread/solid.rs
index 4e14cb3cbcaad..46a84faa80225 100644
--- a/library/std/src/sys/thread/solid.rs
+++ b/library/std/src/sys/thread/solid.rs
@@ -1,16 +1,14 @@
 //! Thread implementation backed by μITRON tasks. Assumes `acre_tsk` and
 //! `exd_tsk` are available.
 
-use super::error::{ItronError, expect_success, expect_success_aborting};
-use super::time::dur2reltims;
-use super::{abi, task};
 use crate::cell::UnsafeCell;
-use crate::ffi::CStr;
 use crate::mem::ManuallyDrop;
-use crate::num::NonZero;
 use crate::ptr::NonNull;
 use crate::sync::atomic::{Atomic, AtomicUsize, Ordering};
-use crate::time::{Duration, Instant};
+use crate::sys::pal::itron::error::{ItronError, expect_success, expect_success_aborting};
+use crate::sys::pal::itron::time::dur2reltims;
+use crate::sys::pal::itron::{abi, task};
+use crate::time::Duration;
 use crate::{hint, io};
 
 pub struct Thread {
@@ -195,28 +193,6 @@ impl Thread {
         Ok(Self { p_inner, task: new_task })
     }
 
-    pub fn yield_now() {
-        expect_success(unsafe { abi::rot_rdq(abi::TPRI_SELF) }, &"rot_rdq");
-    }
-
-    pub fn set_name(_name: &CStr) {
-        // nope
-    }
-
-    pub fn sleep(dur: Duration) {
-        for timeout in dur2reltims(dur) {
-            expect_success(unsafe { abi::dly_tsk(timeout) }, &"dly_tsk");
-        }
-    }
-
-    pub fn sleep_until(deadline: Instant) {
-        let now = Instant::now();
-
-        if let Some(delay) = deadline.checked_duration_since(now) {
-            Self::sleep(delay);
-        }
-    }
-
     pub fn join(self) {
         // Safety: `ThreadInner` is alive at this point
         let inner = unsafe { self.p_inner.as_ref() };
@@ -361,10 +337,12 @@ unsafe fn terminate_and_delete_current_task() -> ! {
     unsafe { crate::hint::unreachable_unchecked() };
 }
 
-pub(crate) fn current_os_id() -> Option<u64> {
-    None
+pub fn yield_now() {
+    expect_success(unsafe { abi::rot_rdq(abi::TPRI_SELF) }, &"rot_rdq");
 }
 
-pub fn available_parallelism() -> io::Result<NonZero<usize>> {
-    super::unsupported()
+pub fn sleep(dur: Duration) {
+    for timeout in dur2reltims(dur) {
+        expect_success(unsafe { abi::dly_tsk(timeout) }, &"dly_tsk");
+    }
 }
diff --git a/library/std/src/sys/thread/teeos.rs b/library/std/src/sys/thread/teeos.rs
index 1812d11e692e8..cad100395c9f8 100644
--- a/library/std/src/sys/thread/teeos.rs
+++ b/library/std/src/sys/thread/teeos.rs
@@ -1,12 +1,18 @@
-use crate::ffi::CStr;
 use crate::mem::{self, ManuallyDrop};
-use crate::num::NonZero;
 use crate::sys::os;
-use crate::time::{Duration, Instant};
+use crate::time::Duration;
 use crate::{cmp, io, ptr};
 
 pub const DEFAULT_MIN_STACK_SIZE: usize = 8 * 1024;
 
+unsafe extern "C" {
+    safe fn TEE_Wait(timeout: u32) -> u32;
+}
+
+fn min_stack_size(_: *const libc::pthread_attr_t) -> usize {
+    libc::PTHREAD_STACK_MIN.try_into().expect("Infallible")
+}
+
 pub struct Thread {
     id: libc::pthread_t,
 }
@@ -16,10 +22,6 @@ pub struct Thread {
 unsafe impl Send for Thread {}
 unsafe impl Sync for Thread {}
 
-unsafe extern "C" {
-    pub fn TEE_Wait(timeout: u32) -> u32;
-}
-
 impl Thread {
     // unsafe: see thread::Builder::spawn_unchecked for safety requirements
     pub unsafe fn new(
@@ -74,7 +76,7 @@ impl Thread {
         } else {
             // The new thread will start running earliest after the next yield.
             // We add a yield here, so that the user does not have to.
-            Thread::yield_now();
+            yield_now();
             Ok(Thread { id: native })
         };
 
@@ -91,36 +93,6 @@ impl Thread {
         }
     }
 
-    pub fn yield_now() {
-        let ret = unsafe { libc::sched_yield() };
-        debug_assert_eq!(ret, 0);
-    }
-
-    /// This does not do anything on teeos
-    pub fn set_name(_name: &CStr) {
-        // Both pthread_setname_np and prctl are not available to the TA,
-        // so we can't implement this currently. If the need arises please
-        // contact the teeos rustzone team.
-    }
-
-    /// only main thread could wait for sometime in teeos
-    pub fn sleep(dur: Duration) {
-        let sleep_millis = dur.as_millis();
-        let final_sleep: u32 =
-            if sleep_millis >= u32::MAX as u128 { u32::MAX } else { sleep_millis as u32 };
-        unsafe {
-            let _ = TEE_Wait(final_sleep);
-        }
-    }
-
-    pub fn sleep_until(deadline: Instant) {
-        let now = Instant::now();
-
-        if let Some(delay) = deadline.checked_duration_since(now) {
-            Self::sleep(delay);
-        }
-    }
-
     /// must join, because no pthread_detach supported
     pub fn join(self) {
         let id = self.into_id();
@@ -128,10 +100,6 @@ impl Thread {
         assert!(ret == 0, "failed to join thread: {}", io::Error::from_raw_os_error(ret));
     }
 
-    pub fn id(&self) -> libc::pthread_t {
-        self.id
-    }
-
     pub fn into_id(self) -> libc::pthread_t {
         ManuallyDrop::new(self).id
     }
@@ -144,16 +112,15 @@ impl Drop for Thread {
     }
 }
 
-pub(crate) fn current_os_id() -> Option<u64> {
-    None
-}
-
-// Note: Both `sched_getaffinity` and `sysconf` are available but not functional on
-// teeos, so this function always returns an Error!
-pub fn available_parallelism() -> io::Result<NonZero<usize>> {
-    Err(io::Error::UNKNOWN_THREAD_COUNT)
+pub fn yield_now() {
+    let ret = unsafe { libc::sched_yield() };
+    debug_assert_eq!(ret, 0);
 }
 
-fn min_stack_size(_: *const libc::pthread_attr_t) -> usize {
-    libc::PTHREAD_STACK_MIN.try_into().expect("Infallible")
+/// only main thread could wait for sometime in teeos
+pub fn sleep(dur: Duration) {
+    let sleep_millis = dur.as_millis();
+    let final_sleep: u32 =
+        if sleep_millis >= u32::MAX as u128 { u32::MAX } else { sleep_millis as u32 };
+    TEE_Wait(final_sleep);
 }
diff --git a/library/std/src/sys/thread/uefi.rs b/library/std/src/sys/thread/uefi.rs
index 47a48008c76da..94f67d7ace2b8 100644
--- a/library/std/src/sys/thread/uefi.rs
+++ b/library/std/src/sys/thread/uefi.rs
@@ -1,66 +1,25 @@
-use super::unsupported;
-use crate::ffi::CStr;
 use crate::io;
 use crate::num::NonZero;
 use crate::ptr::NonNull;
-use crate::time::{Duration, Instant};
+use crate::time::Duration;
 
-pub struct Thread(!);
-
-pub const DEFAULT_MIN_STACK_SIZE: usize = 64 * 1024;
-
-impl Thread {
-    // unsafe: see thread::Builder::spawn_unchecked for safety requirements
-    pub unsafe fn new(
-        _stack: usize,
-        _name: Option<&str>,
-        _p: Box<dyn FnOnce()>,
-    ) -> io::Result<Thread> {
-        unsupported()
-    }
-
-    pub fn yield_now() {
-        // do nothing
-    }
-
-    pub fn set_name(_name: &CStr) {
-        // nope
-    }
-
-    pub fn sleep(dur: Duration) {
-        let boot_services: NonNull<r_efi::efi::BootServices> =
-            crate::os::uefi::env::boot_services().expect("can't sleep").cast();
-        let mut dur_ms = dur.as_micros();
-        // ceil up to the nearest microsecond
-        if dur.subsec_nanos() % 1000 > 0 {
-            dur_ms += 1;
-        }
-
-        while dur_ms > 0 {
-            let ms = crate::cmp::min(dur_ms, usize::MAX as u128);
-            let _ = unsafe { ((*boot_services.as_ptr()).stall)(ms as usize) };
-            dur_ms -= ms;
-        }
-    }
-
-    pub fn sleep_until(deadline: Instant) {
-        let now = Instant::now();
+pub fn available_parallelism() -> io::Result<NonZero<usize>> {
+    // UEFI is single threaded
+    Ok(NonZero::new(1).unwrap())
+}
 
-        if let Some(delay) = deadline.checked_duration_since(now) {
-            Self::sleep(delay);
-        }
+pub fn sleep(dur: Duration) {
+    let boot_services: NonNull<r_efi::efi::BootServices> =
+        crate::os::uefi::env::boot_services().expect("can't sleep").cast();
+    let mut dur_ms = dur.as_micros();
+    // ceil up to the nearest microsecond
+    if dur.subsec_nanos() % 1000 > 0 {
+        dur_ms += 1;
     }
 
-    pub fn join(self) {
-        self.0
+    while dur_ms > 0 {
+        let ms = crate::cmp::min(dur_ms, usize::MAX as u128);
+        let _ = unsafe { ((*boot_services.as_ptr()).stall)(ms as usize) };
+        dur_ms -= ms;
     }
 }
-
-pub(crate) fn current_os_id() -> Option<u64> {
-    None
-}
-
-pub fn available_parallelism() -> io::Result<NonZero<usize>> {
-    // UEFI is single threaded
-    Ok(NonZero::new(1).unwrap())
-}
diff --git a/library/std/src/sys/thread/unix.rs b/library/std/src/sys/thread/unix.rs
index 3389b8c0c8a55..2d2c4f9021288 100644
--- a/library/std/src/sys/thread/unix.rs
+++ b/library/std/src/sys/thread/unix.rs
@@ -1,3 +1,11 @@
+#[cfg(not(any(
+    target_env = "newlib",
+    target_os = "l4re",
+    target_os = "emscripten",
+    target_os = "redox",
+    target_os = "hurd",
+    target_os = "aix",
+)))]
 use crate::ffi::CStr;
 use crate::mem::{self, ManuallyDrop};
 use crate::num::NonZero;
@@ -6,7 +14,7 @@ use crate::sys::weak::dlsym;
 #[cfg(any(target_os = "solaris", target_os = "illumos", target_os = "nto",))]
 use crate::sys::weak::weak;
 use crate::sys::{os, stack_overflow};
-use crate::time::{Duration, Instant};
+use crate::time::Duration;
 use crate::{cmp, io, ptr};
 #[cfg(not(any(
     target_os = "l4re",
@@ -121,273 +129,6 @@ impl Thread {
         }
     }
 
-    pub fn yield_now() {
-        let ret = unsafe { libc::sched_yield() };
-        debug_assert_eq!(ret, 0);
-    }
-
-    #[cfg(target_os = "android")]
-    pub fn set_name(name: &CStr) {
-        const PR_SET_NAME: libc::c_int = 15;
-        unsafe {
-            let res = libc::prctl(
-                PR_SET_NAME,
-                name.as_ptr(),
-                0 as libc::c_ulong,
-                0 as libc::c_ulong,
-                0 as libc::c_ulong,
-            );
-            // We have no good way of propagating errors here, but in debug-builds let's check that this actually worked.
-            debug_assert_eq!(res, 0);
-        }
-    }
-
-    #[cfg(any(
-        target_os = "linux",
-        target_os = "freebsd",
-        target_os = "dragonfly",
-        target_os = "nuttx",
-        target_os = "cygwin"
-    ))]
-    pub fn set_name(name: &CStr) {
-        unsafe {
-            cfg_select! {
-                any(target_os = "linux", target_os = "cygwin") => {
-                    // Linux and Cygwin limits the allowed length of the name.
-                    const TASK_COMM_LEN: usize = 16;
-                    let name = truncate_cstr::<{ TASK_COMM_LEN }>(name);
-                }
-                _ => {
-                    // FreeBSD, DragonFly BSD and NuttX do not enforce length limits.
-                }
-            };
-            // Available since glibc 2.12, musl 1.1.16, and uClibc 1.0.20 for Linux,
-            // FreeBSD 12.2 and 13.0, and DragonFly BSD 6.0.
-            let res = libc::pthread_setname_np(libc::pthread_self(), name.as_ptr());
-            // We have no good way of propagating errors here, but in debug-builds let's check that this actually worked.
-            debug_assert_eq!(res, 0);
-        }
-    }
-
-    #[cfg(target_os = "openbsd")]
-    pub fn set_name(name: &CStr) {
-        unsafe {
-            libc::pthread_set_name_np(libc::pthread_self(), name.as_ptr());
-        }
-    }
-
-    #[cfg(target_vendor = "apple")]
-    pub fn set_name(name: &CStr) {
-        unsafe {
-            let name = truncate_cstr::<{ libc::MAXTHREADNAMESIZE }>(name);
-            let res = libc::pthread_setname_np(name.as_ptr());
-            // We have no good way of propagating errors here, but in debug-builds let's check that this actually worked.
-            debug_assert_eq!(res, 0);
-        }
-    }
-
-    #[cfg(target_os = "netbsd")]
-    pub fn set_name(name: &CStr) {
-        unsafe {
-            let res = libc::pthread_setname_np(
-                libc::pthread_self(),
-                c"%s".as_ptr(),
-                name.as_ptr() as *mut libc::c_void,
-            );
-            debug_assert_eq!(res, 0);
-        }
-    }
-
-    #[cfg(any(target_os = "solaris", target_os = "illumos", target_os = "nto"))]
-    pub fn set_name(name: &CStr) {
-        weak!(
-            fn pthread_setname_np(
-                thread: libc::pthread_t,
-                name: *const libc::c_char,
-            ) -> libc::c_int;
-        );
-
-        if let Some(f) = pthread_setname_np.get() {
-            #[cfg(target_os = "nto")]
-            const THREAD_NAME_MAX: usize = libc::_NTO_THREAD_NAME_MAX as usize;
-            #[cfg(any(target_os = "solaris", target_os = "illumos"))]
-            const THREAD_NAME_MAX: usize = 32;
-
-            let name = truncate_cstr::<{ THREAD_NAME_MAX }>(name);
-            let res = unsafe { f(libc::pthread_self(), name.as_ptr()) };
-            debug_assert_eq!(res, 0);
-        }
-    }
-
-    #[cfg(target_os = "fuchsia")]
-    pub fn set_name(name: &CStr) {
-        use super::fuchsia::*;
-        unsafe {
-            zx_object_set_property(
-                zx_thread_self(),
-                ZX_PROP_NAME,
-                name.as_ptr() as *const libc::c_void,
-                name.to_bytes().len(),
-            );
-        }
-    }
-
-    #[cfg(target_os = "haiku")]
-    pub fn set_name(name: &CStr) {
-        unsafe {
-            let thread_self = libc::find_thread(ptr::null_mut());
-            let res = libc::rename_thread(thread_self, name.as_ptr());
-            // We have no good way of propagating errors here, but in debug-builds let's check that this actually worked.
-            debug_assert_eq!(res, libc::B_OK);
-        }
-    }
-
-    #[cfg(target_os = "vxworks")]
-    pub fn set_name(name: &CStr) {
-        let mut name = truncate_cstr::<{ (libc::VX_TASK_RENAME_LENGTH - 1) as usize }>(name);
-        let res = unsafe { libc::taskNameSet(libc::taskIdSelf(), name.as_mut_ptr()) };
-        debug_assert_eq!(res, libc::OK);
-    }
-
-    #[cfg(any(
-        target_env = "newlib",
-        target_os = "l4re",
-        target_os = "emscripten",
-        target_os = "redox",
-        target_os = "hurd",
-        target_os = "aix",
-    ))]
-    pub fn set_name(_name: &CStr) {
-        // Newlib and Emscripten have no way to set a thread name.
-    }
-
-    #[cfg(not(target_os = "espidf"))]
-    pub fn sleep(dur: Duration) {
-        let mut secs = dur.as_secs();
-        let mut nsecs = dur.subsec_nanos() as _;
-
-        // If we're awoken with a signal then the return value will be -1 and
-        // nanosleep will fill in `ts` with the remaining time.
-        unsafe {
-            while secs > 0 || nsecs > 0 {
-                let mut ts = libc::timespec {
-                    tv_sec: cmp::min(libc::time_t::MAX as u64, secs) as libc::time_t,
-                    tv_nsec: nsecs,
-                };
-                secs -= ts.tv_sec as u64;
-                let ts_ptr = &raw mut ts;
-                if libc::nanosleep(ts_ptr, ts_ptr) == -1 {
-                    assert_eq!(os::errno(), libc::EINTR);
-                    secs += ts.tv_sec as u64;
-                    nsecs = ts.tv_nsec;
-                } else {
-                    nsecs = 0;
-                }
-            }
-        }
-    }
-
-    #[cfg(target_os = "espidf")]
-    pub fn sleep(dur: Duration) {
-        // 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;
-        }
-    }
-
-    // Any unix that has clock_nanosleep
-    // If this list changes update the MIRI chock_nanosleep shim
-    #[cfg(any(
-        target_os = "freebsd",
-        target_os = "netbsd",
-        target_os = "linux",
-        target_os = "android",
-        target_os = "solaris",
-        target_os = "illumos",
-        target_os = "dragonfly",
-        target_os = "hurd",
-        target_os = "fuchsia",
-        target_os = "vxworks",
-    ))]
-    pub fn sleep_until(deadline: Instant) {
-        let Some(ts) = deadline.into_inner().into_timespec().to_timespec() else {
-            // The deadline is further in the future then can be passed to
-            // clock_nanosleep. We have to use Self::sleep instead. This might
-            // happen on 32 bit platforms, especially closer to 2038.
-            let now = Instant::now();
-            if let Some(delay) = deadline.checked_duration_since(now) {
-                Self::sleep(delay);
-            }
-            return;
-        };
-
-        unsafe {
-            // When we get interrupted (res = EINTR) call clock_nanosleep again
-            loop {
-                let res = libc::clock_nanosleep(
-                    super::time::Instant::CLOCK_ID,
-                    libc::TIMER_ABSTIME,
-                    &ts,
-                    core::ptr::null_mut(), // not required with TIMER_ABSTIME
-                );
-
-                if res == 0 {
-                    break;
-                } else {
-                    assert_eq!(
-                        res,
-                        libc::EINTR,
-                        "timespec is in range,
-                         clockid is valid and kernel should support it"
-                    );
-                }
-            }
-        }
-    }
-
-    // Any unix that does not have clock_nanosleep
-    #[cfg(not(any(
-        target_os = "freebsd",
-        target_os = "netbsd",
-        target_os = "linux",
-        target_os = "android",
-        target_os = "solaris",
-        target_os = "illumos",
-        target_os = "dragonfly",
-        target_os = "hurd",
-        target_os = "fuchsia",
-        target_os = "vxworks",
-    )))]
-    pub fn sleep_until(deadline: Instant) {
-        let now = Instant::now();
-        if let Some(delay) = deadline.checked_duration_since(now) {
-            Self::sleep(delay);
-        }
-    }
-
     pub fn join(self) {
         let id = self.into_id();
         let ret = unsafe { libc::pthread_join(id, ptr::null_mut()) };
@@ -410,84 +151,6 @@ impl Drop for Thread {
     }
 }
 
-pub(crate) fn current_os_id() -> Option<u64> {
-    // Most Unix platforms have a way to query an integer ID of the current thread, all with
-    // slightly different spellings.
-    //
-    // The OS thread ID is used rather than `pthread_self` so as to match what will be displayed
-    // for process inspection (debuggers, trace, `top`, etc.).
-    cfg_select! {
-        // Most platforms have a function returning a `pid_t` or int, which is an `i32`.
-        any(target_os = "android", target_os = "linux") => {
-            use crate::sys::weak::syscall;
-
-            // `libc::gettid` is only available on glibc 2.30+, but the syscall is available
-            // since Linux 2.4.11.
-            syscall!(fn gettid() -> libc::pid_t;);
-
-            // SAFETY: FFI call with no preconditions.
-            let id: libc::pid_t = unsafe { gettid() };
-            Some(id as u64)
-        }
-        target_os = "nto" => {
-            // SAFETY: FFI call with no preconditions.
-            let id: libc::pid_t = unsafe { libc::gettid() };
-            Some(id as u64)
-        }
-        target_os = "openbsd" => {
-            // SAFETY: FFI call with no preconditions.
-            let id: libc::pid_t = unsafe { libc::getthrid() };
-            Some(id as u64)
-        }
-        target_os = "freebsd" => {
-            // SAFETY: FFI call with no preconditions.
-            let id: libc::c_int = unsafe { libc::pthread_getthreadid_np() };
-            Some(id as u64)
-        }
-        target_os = "netbsd" => {
-            // SAFETY: FFI call with no preconditions.
-            let id: libc::lwpid_t = unsafe { libc::_lwp_self() };
-            Some(id as u64)
-        }
-        any(target_os = "illumos", target_os = "solaris") => {
-            // On Illumos and Solaris, the `pthread_t` is the same as the OS thread ID.
-            // SAFETY: FFI call with no preconditions.
-            let id: libc::pthread_t = unsafe { libc::pthread_self() };
-            Some(id as u64)
-        }
-        target_vendor = "apple" => {
-            // Apple allows querying arbitrary thread IDs, `thread=NULL` queries the current thread.
-            let mut id = 0u64;
-            // SAFETY: `thread_id` is a valid pointer, no other preconditions.
-            let status: libc::c_int = unsafe { libc::pthread_threadid_np(0, &mut id) };
-            if status == 0 {
-                Some(id)
-            } else {
-                None
-            }
-        }
-        // Other platforms don't have an OS thread ID or don't have a way to access it.
-        _ => None,
-    }
-}
-
-#[cfg(any(
-    target_os = "linux",
-    target_os = "nto",
-    target_os = "solaris",
-    target_os = "illumos",
-    target_os = "vxworks",
-    target_os = "cygwin",
-    target_vendor = "apple",
-))]
-fn truncate_cstr<const MAX_WITH_NUL: usize>(cstr: &CStr) -> [libc::c_char; MAX_WITH_NUL] {
-    let mut result = [0; MAX_WITH_NUL];
-    for (src, dst) in cstr.to_bytes().iter().zip(&mut result[..MAX_WITH_NUL - 1]) {
-        *dst = *src as libc::c_char;
-    }
-    result
-}
-
 pub fn available_parallelism() -> io::Result<NonZero<usize>> {
     cfg_select! {
         any(
@@ -668,6 +331,318 @@ pub fn available_parallelism() -> io::Result<NonZero<usize>> {
     }
 }
 
+pub fn current_os_id() -> Option<u64> {
+    // Most Unix platforms have a way to query an integer ID of the current thread, all with
+    // slightly different spellings.
+    //
+    // The OS thread ID is used rather than `pthread_self` so as to match what will be displayed
+    // for process inspection (debuggers, trace, `top`, etc.).
+    cfg_select! {
+        // Most platforms have a function returning a `pid_t` or int, which is an `i32`.
+        any(target_os = "android", target_os = "linux") => {
+            use crate::sys::pal::weak::syscall;
+
+            // `libc::gettid` is only available on glibc 2.30+, but the syscall is available
+            // since Linux 2.4.11.
+            syscall!(fn gettid() -> libc::pid_t;);
+
+            // SAFETY: FFI call with no preconditions.
+            let id: libc::pid_t = unsafe { gettid() };
+            Some(id as u64)
+        }
+        target_os = "nto" => {
+            // SAFETY: FFI call with no preconditions.
+            let id: libc::pid_t = unsafe { libc::gettid() };
+            Some(id as u64)
+        }
+        target_os = "openbsd" => {
+            // SAFETY: FFI call with no preconditions.
+            let id: libc::pid_t = unsafe { libc::getthrid() };
+            Some(id as u64)
+        }
+        target_os = "freebsd" => {
+            // SAFETY: FFI call with no preconditions.
+            let id: libc::c_int = unsafe { libc::pthread_getthreadid_np() };
+            Some(id as u64)
+        }
+        target_os = "netbsd" => {
+            // SAFETY: FFI call with no preconditions.
+            let id: libc::lwpid_t = unsafe { libc::_lwp_self() };
+            Some(id as u64)
+        }
+        any(target_os = "illumos", target_os = "solaris") => {
+            // On Illumos and Solaris, the `pthread_t` is the same as the OS thread ID.
+            // SAFETY: FFI call with no preconditions.
+            let id: libc::pthread_t = unsafe { libc::pthread_self() };
+            Some(id as u64)
+        }
+        target_vendor = "apple" => {
+            // Apple allows querying arbitrary thread IDs, `thread=NULL` queries the current thread.
+            let mut id = 0u64;
+            // SAFETY: `thread_id` is a valid pointer, no other preconditions.
+            let status: libc::c_int = unsafe { libc::pthread_threadid_np(0, &mut id) };
+            if status == 0 {
+                Some(id)
+            } else {
+                None
+            }
+        }
+        // Other platforms don't have an OS thread ID or don't have a way to access it.
+        _ => None,
+    }
+}
+
+#[cfg(any(
+    target_os = "linux",
+    target_os = "nto",
+    target_os = "solaris",
+    target_os = "illumos",
+    target_os = "vxworks",
+    target_os = "cygwin",
+    target_vendor = "apple",
+))]
+fn truncate_cstr<const MAX_WITH_NUL: usize>(cstr: &CStr) -> [libc::c_char; MAX_WITH_NUL] {
+    let mut result = [0; MAX_WITH_NUL];
+    for (src, dst) in cstr.to_bytes().iter().zip(&mut result[..MAX_WITH_NUL - 1]) {
+        *dst = *src as libc::c_char;
+    }
+    result
+}
+
+#[cfg(target_os = "android")]
+pub fn set_name(name: &CStr) {
+    const PR_SET_NAME: libc::c_int = 15;
+    unsafe {
+        let res = libc::prctl(
+            PR_SET_NAME,
+            name.as_ptr(),
+            0 as libc::c_ulong,
+            0 as libc::c_ulong,
+            0 as libc::c_ulong,
+        );
+        // We have no good way of propagating errors here, but in debug-builds let's check that this actually worked.
+        debug_assert_eq!(res, 0);
+    }
+}
+
+#[cfg(any(
+    target_os = "linux",
+    target_os = "freebsd",
+    target_os = "dragonfly",
+    target_os = "nuttx",
+    target_os = "cygwin"
+))]
+pub fn set_name(name: &CStr) {
+    unsafe {
+        cfg_select! {
+            any(target_os = "linux", target_os = "cygwin") => {
+                // Linux and Cygwin limits the allowed length of the name.
+                const TASK_COMM_LEN: usize = 16;
+                let name = truncate_cstr::<{ TASK_COMM_LEN }>(name);
+            }
+            _ => {
+                // FreeBSD, DragonFly BSD and NuttX do not enforce length limits.
+            }
+        };
+        // Available since glibc 2.12, musl 1.1.16, and uClibc 1.0.20 for Linux,
+        // FreeBSD 12.2 and 13.0, and DragonFly BSD 6.0.
+        let res = libc::pthread_setname_np(libc::pthread_self(), name.as_ptr());
+        // We have no good way of propagating errors here, but in debug-builds let's check that this actually worked.
+        debug_assert_eq!(res, 0);
+    }
+}
+
+#[cfg(target_os = "openbsd")]
+pub fn set_name(name: &CStr) {
+    unsafe {
+        libc::pthread_set_name_np(libc::pthread_self(), name.as_ptr());
+    }
+}
+
+#[cfg(target_vendor = "apple")]
+pub fn set_name(name: &CStr) {
+    unsafe {
+        let name = truncate_cstr::<{ libc::MAXTHREADNAMESIZE }>(name);
+        let res = libc::pthread_setname_np(name.as_ptr());
+        // We have no good way of propagating errors here, but in debug-builds let's check that this actually worked.
+        debug_assert_eq!(res, 0);
+    }
+}
+
+#[cfg(target_os = "netbsd")]
+pub fn set_name(name: &CStr) {
+    unsafe {
+        let res = libc::pthread_setname_np(
+            libc::pthread_self(),
+            c"%s".as_ptr(),
+            name.as_ptr() as *mut libc::c_void,
+        );
+        debug_assert_eq!(res, 0);
+    }
+}
+
+#[cfg(any(target_os = "solaris", target_os = "illumos", target_os = "nto"))]
+pub fn set_name(name: &CStr) {
+    weak!(
+        fn pthread_setname_np(thread: libc::pthread_t, name: *const libc::c_char) -> libc::c_int;
+    );
+
+    if let Some(f) = pthread_setname_np.get() {
+        #[cfg(target_os = "nto")]
+        const THREAD_NAME_MAX: usize = libc::_NTO_THREAD_NAME_MAX as usize;
+        #[cfg(any(target_os = "solaris", target_os = "illumos"))]
+        const THREAD_NAME_MAX: usize = 32;
+
+        let name = truncate_cstr::<{ THREAD_NAME_MAX }>(name);
+        let res = unsafe { f(libc::pthread_self(), name.as_ptr()) };
+        debug_assert_eq!(res, 0);
+    }
+}
+
+#[cfg(target_os = "fuchsia")]
+pub fn set_name(name: &CStr) {
+    use crate::sys::pal::fuchsia::*;
+    unsafe {
+        zx_object_set_property(
+            zx_thread_self(),
+            ZX_PROP_NAME,
+            name.as_ptr() as *const libc::c_void,
+            name.to_bytes().len(),
+        );
+    }
+}
+
+#[cfg(target_os = "haiku")]
+pub fn set_name(name: &CStr) {
+    unsafe {
+        let thread_self = libc::find_thread(ptr::null_mut());
+        let res = libc::rename_thread(thread_self, name.as_ptr());
+        // We have no good way of propagating errors here, but in debug-builds let's check that this actually worked.
+        debug_assert_eq!(res, libc::B_OK);
+    }
+}
+
+#[cfg(target_os = "vxworks")]
+pub fn set_name(name: &CStr) {
+    let mut name = truncate_cstr::<{ (libc::VX_TASK_RENAME_LENGTH - 1) as usize }>(name);
+    let res = unsafe { libc::taskNameSet(libc::taskIdSelf(), name.as_mut_ptr()) };
+    debug_assert_eq!(res, libc::OK);
+}
+
+#[cfg(not(target_os = "espidf"))]
+pub fn sleep(dur: Duration) {
+    let mut secs = dur.as_secs();
+    let mut nsecs = dur.subsec_nanos() as _;
+
+    // If we're awoken with a signal then the return value will be -1 and
+    // nanosleep will fill in `ts` with the remaining time.
+    unsafe {
+        while secs > 0 || nsecs > 0 {
+            let mut ts = libc::timespec {
+                tv_sec: cmp::min(libc::time_t::MAX as u64, secs) as libc::time_t,
+                tv_nsec: nsecs,
+            };
+            secs -= ts.tv_sec as u64;
+            let ts_ptr = &raw mut ts;
+            if libc::nanosleep(ts_ptr, ts_ptr) == -1 {
+                assert_eq!(os::errno(), libc::EINTR);
+                secs += ts.tv_sec as u64;
+                nsecs = ts.tv_nsec;
+            } else {
+                nsecs = 0;
+            }
+        }
+    }
+}
+
+#[cfg(target_os = "espidf")]
+pub fn sleep(dur: Duration) {
+    // 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;
+    }
+}
+
+// Any unix that has clock_nanosleep
+// If this list changes update the MIRI chock_nanosleep shim
+#[cfg(any(
+    target_os = "freebsd",
+    target_os = "netbsd",
+    target_os = "linux",
+    target_os = "android",
+    target_os = "solaris",
+    target_os = "illumos",
+    target_os = "dragonfly",
+    target_os = "hurd",
+    target_os = "fuchsia",
+    target_os = "vxworks",
+))]
+pub fn sleep_until(deadline: crate::time::Instant) {
+    use crate::time::Instant;
+
+    let Some(ts) = deadline.into_inner().into_timespec().to_timespec() else {
+        // The deadline is further in the future then can be passed to
+        // clock_nanosleep. We have to use Self::sleep instead. This might
+        // happen on 32 bit platforms, especially closer to 2038.
+        let now = Instant::now();
+        if let Some(delay) = deadline.checked_duration_since(now) {
+            sleep(delay);
+        }
+        return;
+    };
+
+    unsafe {
+        // When we get interrupted (res = EINTR) call clock_nanosleep again
+        loop {
+            let res = libc::clock_nanosleep(
+                crate::sys::time::Instant::CLOCK_ID,
+                libc::TIMER_ABSTIME,
+                &ts,
+                core::ptr::null_mut(), // not required with TIMER_ABSTIME
+            );
+
+            if res == 0 {
+                break;
+            } else {
+                assert_eq!(
+                    res,
+                    libc::EINTR,
+                    "timespec is in range,
+                         clockid is valid and kernel should support it"
+                );
+            }
+        }
+    }
+}
+
+pub fn yield_now() {
+    let ret = unsafe { libc::sched_yield() };
+    debug_assert_eq!(ret, 0);
+}
+
 #[cfg(any(target_os = "android", target_os = "linux"))]
 mod cgroups {
     //! Currently not covered
diff --git a/library/std/src/sys/thread/unsupported.rs b/library/std/src/sys/thread/unsupported.rs
index 34d9b5ec70c6b..a5001efa3b405 100644
--- a/library/std/src/sys/thread/unsupported.rs
+++ b/library/std/src/sys/thread/unsupported.rs
@@ -1,8 +1,7 @@
-use super::unsupported;
 use crate::ffi::CStr;
 use crate::io;
 use crate::num::NonZero;
-use crate::time::{Duration, Instant};
+use crate::time::Duration;
 
 pub struct Thread(!);
 
@@ -15,23 +14,7 @@ impl Thread {
         _name: Option<&str>,
         _p: Box<dyn FnOnce()>,
     ) -> io::Result<Thread> {
-        unsupported()
-    }
-
-    pub fn yield_now() {
-        // do nothing
-    }
-
-    pub fn set_name(_name: &CStr) {
-        // nope
-    }
-
-    pub fn sleep(_dur: Duration) {
-        panic!("can't sleep");
-    }
-
-    pub fn sleep_until(_deadline: Instant) {
-        panic!("can't sleep");
+        Err(io::Error::UNSUPPORTED_PLATFORM)
     }
 
     pub fn join(self) {
@@ -39,10 +22,22 @@ impl Thread {
     }
 }
 
-pub(crate) fn current_os_id() -> Option<u64> {
+pub fn available_parallelism() -> io::Result<NonZero<usize>> {
+    Err(io::Error::UNKNOWN_THREAD_COUNT)
+}
+
+pub fn current_os_id() -> Option<u64> {
     None
 }
 
-pub fn available_parallelism() -> io::Result<NonZero<usize>> {
-    unsupported()
+pub fn yield_now() {
+    // do nothing
+}
+
+pub fn set_name(_name: &CStr) {
+    // nope
+}
+
+pub fn sleep(_dur: Duration) {
+    panic!("can't sleep");
 }
diff --git a/library/std/src/sys/thread/wasip1.rs b/library/std/src/sys/thread/wasip1.rs
index e062b49bd7a29..83001fad49c81 100644
--- a/library/std/src/sys/thread/wasip1.rs
+++ b/library/std/src/sys/thread/wasip1.rs
@@ -1,214 +1,185 @@
 #![forbid(unsafe_op_in_unsafe_fn)]
 
-use crate::ffi::CStr;
+#[cfg(target_feature = "atomics")]
+use crate::io;
+use crate::mem;
+#[cfg(target_feature = "atomics")]
 use crate::num::NonZero;
-use crate::time::{Duration, Instant};
-use crate::{io, mem};
-
-cfg_select! {
-    target_feature = "atomics" => {
-        use crate::cmp;
-        use crate::ptr;
-        use crate::sys::os;
-        // Add a few symbols not in upstream `libc` just yet.
-        mod libc {
-            pub use crate::ffi;
-            pub use libc::*;
-
-            // defined in wasi-libc
-            // https://github.com/WebAssembly/wasi-libc/blob/a6f871343313220b76009827ed0153586361c0d5/libc-top-half/musl/include/alltypes.h.in#L108
-            #[repr(C)]
-            union pthread_attr_union {
-                __i: [ffi::c_int; if size_of::<ffi::c_long>() == 8 { 14 } else { 9 }],
-                __vi: [ffi::c_int; if size_of::<ffi::c_long>() == 8 { 14 } else { 9 }],
-                __s: [ffi::c_ulong; if size_of::<ffi::c_long>() == 8 { 7 } else { 9 }],
-            }
+#[cfg(target_feature = "atomics")]
+use crate::sys::os;
+use crate::time::Duration;
+#[cfg(target_feature = "atomics")]
+use crate::{cmp, ptr};
+
+// Add a few symbols not in upstream `libc` just yet.
+#[cfg(target_feature = "atomics")]
+mod libc {
+    pub use libc::*;
+
+    pub use crate::ffi;
+
+    // defined in wasi-libc
+    // https://github.com/WebAssembly/wasi-libc/blob/a6f871343313220b76009827ed0153586361c0d5/libc-top-half/musl/include/alltypes.h.in#L108
+    #[repr(C)]
+    union pthread_attr_union {
+        __i: [ffi::c_int; if size_of::<ffi::c_long>() == 8 { 14 } else { 9 }],
+        __vi: [ffi::c_int; if size_of::<ffi::c_long>() == 8 { 14 } else { 9 }],
+        __s: [ffi::c_ulong; if size_of::<ffi::c_long>() == 8 { 7 } else { 9 }],
+    }
 
-            #[repr(C)]
-            pub struct pthread_attr_t {
-                __u: pthread_attr_union,
-            }
+    #[repr(C)]
+    pub struct pthread_attr_t {
+        __u: pthread_attr_union,
+    }
 
-            #[allow(non_camel_case_types)]
-            pub type pthread_t = *mut ffi::c_void;
-
-            pub const _SC_NPROCESSORS_ONLN: ffi::c_int = 84;
-
-            unsafe extern "C" {
-                pub fn pthread_create(
-                    native: *mut pthread_t,
-                    attr: *const pthread_attr_t,
-                    f: extern "C" fn(*mut ffi::c_void) -> *mut ffi::c_void,
-                    value: *mut ffi::c_void,
-                ) -> ffi::c_int;
-                pub fn pthread_join(native: pthread_t, value: *mut *mut ffi::c_void) -> ffi::c_int;
-                pub fn pthread_attr_init(attrp: *mut pthread_attr_t) -> ffi::c_int;
-                pub fn pthread_attr_setstacksize(
-                    attr: *mut pthread_attr_t,
-                    stack_size: libc::size_t,
-                ) -> ffi::c_int;
-                pub fn pthread_attr_destroy(attr: *mut pthread_attr_t) -> ffi::c_int;
-                pub fn pthread_detach(thread: pthread_t) -> ffi::c_int;
-            }
-        }
+    #[allow(non_camel_case_types)]
+    pub type pthread_t = *mut ffi::c_void;
+
+    pub const _SC_NPROCESSORS_ONLN: ffi::c_int = 84;
+
+    unsafe extern "C" {
+        pub fn pthread_create(
+            native: *mut pthread_t,
+            attr: *const pthread_attr_t,
+            f: extern "C" fn(*mut ffi::c_void) -> *mut ffi::c_void,
+            value: *mut ffi::c_void,
+        ) -> ffi::c_int;
+        pub fn pthread_join(native: pthread_t, value: *mut *mut ffi::c_void) -> ffi::c_int;
+        pub fn pthread_attr_init(attrp: *mut pthread_attr_t) -> ffi::c_int;
+        pub fn pthread_attr_setstacksize(
+            attr: *mut pthread_attr_t,
+            stack_size: libc::size_t,
+        ) -> ffi::c_int;
+        pub fn pthread_attr_destroy(attr: *mut pthread_attr_t) -> ffi::c_int;
+        pub fn pthread_detach(thread: pthread_t) -> ffi::c_int;
+    }
+}
 
-        pub struct Thread {
-            id: libc::pthread_t,
-        }
+#[cfg(target_feature = "atomics")]
+pub struct Thread {
+    id: libc::pthread_t,
+}
 
-        impl Drop for Thread {
-            fn drop(&mut self) {
-                let ret = unsafe { libc::pthread_detach(self.id) };
-                debug_assert_eq!(ret, 0);
-            }
-        }
-    }
-    _ => {
-        pub struct Thread(!);
+#[cfg(target_feature = "atomics")]
+impl Drop for Thread {
+    fn drop(&mut self) {
+        let ret = unsafe { libc::pthread_detach(self.id) };
+        debug_assert_eq!(ret, 0);
     }
 }
 
 pub const DEFAULT_MIN_STACK_SIZE: usize = 1024 * 1024;
 
+#[cfg(target_feature = "atomics")]
 impl Thread {
     // unsafe: see thread::Builder::spawn_unchecked for safety requirements
-    cfg_select! {
-        target_feature = "atomics" => {
-            pub unsafe fn new(stack: usize, _name: Option<&str>, p: Box<dyn FnOnce()>) -> io::Result<Thread> {
-                let p = Box::into_raw(Box::new(p));
-                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 unsafe { libc::pthread_attr_setstacksize(&mut attr, stack_size) } {
-                    0 => {}
-                    n => {
-                        assert_eq!(n, libc::EINVAL);
-                        // EINVAL means |stack_size| is either too small or not a
-                        // multiple of the system page size. Because it's definitely
-                        // >= PTHREAD_STACK_MIN, it must be an alignment issue.
-                        // Round up to the nearest page and try again.
-                        let page_size = os::page_size();
-                        let stack_size =
-                            (stack_size + page_size - 1) & (-(page_size as isize - 1) as usize - 1);
-                        assert_eq!(unsafe { libc::pthread_attr_setstacksize(&mut attr, stack_size) }, 0);
-                    }
-                };
-
-                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!(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.
-                    unsafe { drop(Box::from_raw(p)); }
-                    Err(io::Error::from_raw_os_error(ret))
-                } else {
-                    Ok(Thread { id: native })
-                };
-
-                extern "C" fn thread_start(main: *mut libc::c_void) -> *mut libc::c_void {
-                    unsafe {
-                        // Finally, let's run some code.
-                        Box::from_raw(main as *mut Box<dyn FnOnce()>)();
-                    }
-                    ptr::null_mut()
-                }
-            }
-        }
-        _ => {
-            pub unsafe fn new(_stack: usize, _name: Option<&str>, _p: Box<dyn FnOnce()>) -> io::Result<Thread> {
-                crate::sys::unsupported()
+    pub unsafe fn new(
+        stack: usize,
+        _name: Option<&str>,
+        p: Box<dyn FnOnce()>,
+    ) -> io::Result<Thread> {
+        let p = Box::into_raw(Box::new(p));
+        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 unsafe { libc::pthread_attr_setstacksize(&mut attr, stack_size) } {
+            0 => {}
+            n => {
+                assert_eq!(n, libc::EINVAL);
+                // EINVAL means |stack_size| is either too small or not a
+                // multiple of the system page size. Because it's definitely
+                // >= PTHREAD_STACK_MIN, it must be an alignment issue.
+                // Round up to the nearest page and try again.
+                let page_size = os::page_size();
+                let stack_size =
+                    (stack_size + page_size - 1) & (-(page_size as isize - 1) as usize - 1);
+                assert_eq!(unsafe { libc::pthread_attr_setstacksize(&mut attr, stack_size) }, 0);
             }
-        }
-    }
+        };
 
-    pub fn yield_now() {
-        let ret = unsafe { wasi::sched_yield() };
-        debug_assert_eq!(ret, Ok(()));
-    }
+        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!(unsafe { libc::pthread_attr_destroy(&mut attr) }, 0);
 
-    pub fn set_name(_name: &CStr) {
-        // nope
-    }
+        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.
+            unsafe {
+                drop(Box::from_raw(p));
+            }
+            Err(io::Error::from_raw_os_error(ret))
+        } else {
+            Ok(Thread { id: native })
+        };
 
-    pub fn sleep(dur: Duration) {
-        let mut nanos = dur.as_nanos();
-        while nanos > 0 {
-            const USERDATA: wasi::Userdata = 0x0123_45678;
-
-            let clock = wasi::SubscriptionClock {
-                id: wasi::CLOCKID_MONOTONIC,
-                timeout: u64::try_from(nanos).unwrap_or(u64::MAX),
-                precision: 0,
-                flags: 0,
-            };
-            nanos -= u128::from(clock.timeout);
-
-            let in_ = wasi::Subscription {
-                userdata: USERDATA,
-                u: wasi::SubscriptionU { tag: 0, u: wasi::SubscriptionUU { clock } },
-            };
+        extern "C" fn thread_start(main: *mut libc::c_void) -> *mut libc::c_void {
             unsafe {
-                let mut event: wasi::Event = mem::zeroed();
-                let res = wasi::poll_oneoff(&in_, &mut event, 1);
-                match (res, event) {
-                    (
-                        Ok(1),
-                        wasi::Event {
-                            userdata: USERDATA,
-                            error: wasi::ERRNO_SUCCESS,
-                            type_: wasi::EVENTTYPE_CLOCK,
-                            ..
-                        },
-                    ) => {}
-                    _ => panic!("thread::sleep(): unexpected result of poll_oneoff"),
-                }
+                // Finally, let's run some code.
+                Box::from_raw(main as *mut Box<dyn FnOnce()>)();
             }
+            ptr::null_mut()
         }
     }
 
-    pub fn sleep_until(deadline: Instant) {
-        let now = Instant::now();
-
-        if let Some(delay) = deadline.checked_duration_since(now) {
-            Self::sleep(delay);
+    pub fn join(self) {
+        let id = mem::ManuallyDrop::new(self).id;
+        let ret = unsafe { libc::pthread_join(id, ptr::null_mut()) };
+        if ret != 0 {
+            rtabort!("failed to join thread: {}", io::Error::from_raw_os_error(ret));
         }
     }
+}
 
-    pub fn join(self) {
-        cfg_select! {
-            target_feature = "atomics" => {
-                let id = mem::ManuallyDrop::new(self).id;
-                let ret = unsafe { libc::pthread_join(id, ptr::null_mut()) };
-                if ret != 0 {
-                    rtabort!("failed to join thread: {}", io::Error::from_raw_os_error(ret));
-                }
-            }
-            _ => {
-                self.0
-            }
-        }
+#[cfg(target_feature = "atomics")]
+pub fn available_parallelism() -> io::Result<NonZero<usize>> {
+    match unsafe { libc::sysconf(libc::_SC_NPROCESSORS_ONLN) } {
+        -1 => Err(io::Error::last_os_error()),
+        cpus => NonZero::new(cpus as usize).ok_or(io::Error::UNKNOWN_THREAD_COUNT),
     }
 }
 
-pub(crate) fn current_os_id() -> Option<u64> {
-    None
+pub fn yield_now() {
+    let ret = unsafe { wasi::sched_yield() };
+    debug_assert_eq!(ret, Ok(()));
 }
 
-pub fn available_parallelism() -> io::Result<NonZero<usize>> {
-    cfg_select! {
-        target_feature = "atomics" => {
-            match unsafe { libc::sysconf(libc::_SC_NPROCESSORS_ONLN) } {
-                -1 => Err(io::Error::last_os_error()),
-                cpus => NonZero::new(cpus as usize).ok_or(io::Error::UNKNOWN_THREAD_COUNT),
+pub fn sleep(dur: Duration) {
+    let mut nanos = dur.as_nanos();
+    while nanos > 0 {
+        const USERDATA: wasi::Userdata = 0x0123_45678;
+
+        let clock = wasi::SubscriptionClock {
+            id: wasi::CLOCKID_MONOTONIC,
+            timeout: u64::try_from(nanos).unwrap_or(u64::MAX),
+            precision: 0,
+            flags: 0,
+        };
+        nanos -= u128::from(clock.timeout);
+
+        let in_ = wasi::Subscription {
+            userdata: USERDATA,
+            u: wasi::SubscriptionU { tag: 0, u: wasi::SubscriptionUU { clock } },
+        };
+        unsafe {
+            let mut event: wasi::Event = mem::zeroed();
+            let res = wasi::poll_oneoff(&in_, &mut event, 1);
+            match (res, event) {
+                (
+                    Ok(1),
+                    wasi::Event {
+                        userdata: USERDATA,
+                        error: wasi::ERRNO_SUCCESS,
+                        type_: wasi::EVENTTYPE_CLOCK,
+                        ..
+                    },
+                ) => {}
+                _ => panic!("thread::sleep(): unexpected result of poll_oneoff"),
             }
         }
-        _ => crate::sys::unsupported(),
     }
 }
diff --git a/library/std/src/sys/thread/wasip2.rs b/library/std/src/sys/thread/wasip2.rs
index ad52918f15a13..420cad2a5e4ab 100644
--- a/library/std/src/sys/thread/wasip2.rs
+++ b/library/std/src/sys/thread/wasip2.rs
@@ -1,73 +1,32 @@
-use crate::ffi::CStr;
-use crate::io;
-use crate::num::NonZero;
 use crate::time::{Duration, Instant};
 
-pub struct Thread(!);
-
-pub const DEFAULT_MIN_STACK_SIZE: usize = 1024 * 1024;
-
-impl Thread {
-    pub unsafe fn new(
-        _stack: usize,
-        _name: Option<&str>,
-        _p: Box<dyn FnOnce()>,
-    ) -> io::Result<Thread> {
-        // Note that unlike WASIp1 even if the wasm `atomics` feature is enabled
-        // there is no support for threads, not even experimentally, not even in
-        // wasi-libc. Thus this is unconditionally unsupported.
-        crate::sys::unsupported()
-    }
-
-    pub fn yield_now() {
-        // no API for this in WASIp2, but there's also no threads, so that's
-        // sort of expected.
-    }
-
-    pub fn set_name(_name: &CStr) {
-        // nope
+pub fn sleep(dur: Duration) {
+    // Sleep in increments of `u64::MAX` nanoseconds until the `dur` is
+    // entirely drained.
+    let mut remaining = dur.as_nanos();
+    while remaining > 0 {
+        let amt = u64::try_from(remaining).unwrap_or(u64::MAX);
+        wasip2::clocks::monotonic_clock::subscribe_duration(amt).block();
+        remaining -= u128::from(amt);
     }
+}
 
-    pub fn sleep(dur: Duration) {
-        // Sleep in increments of `u64::MAX` nanoseconds until the `dur` is
-        // entirely drained.
-        let mut remaining = dur.as_nanos();
-        while remaining > 0 {
-            let amt = u64::try_from(remaining).unwrap_or(u64::MAX);
-            wasip2::clocks::monotonic_clock::subscribe_duration(amt).block();
-            remaining -= u128::from(amt);
+pub fn sleep_until(deadline: Instant) {
+    match u64::try_from(deadline.into_inner().as_duration().as_nanos()) {
+        // If the point in time we're sleeping to fits within a 64-bit
+        // number of nanoseconds then directly use `subscribe_instant`.
+        Ok(deadline) => {
+            wasip2::clocks::monotonic_clock::subscribe_instant(deadline).block();
         }
-    }
-
-    pub fn sleep_until(deadline: Instant) {
-        match u64::try_from(deadline.into_inner().as_duration().as_nanos()) {
-            // If the point in time we're sleeping to fits within a 64-bit
-            // number of nanoseconds then directly use `subscribe_instant`.
-            Ok(deadline) => {
-                wasip2::clocks::monotonic_clock::subscribe_instant(deadline).block();
-            }
-            // ... otherwise we're sleeping for 500+ years relative to the
-            // "start" of what the system is using as a clock so speed/accuracy
-            // is not so much of a concern. Use `sleep` instead.
-            Err(_) => {
-                let now = Instant::now();
-
-                if let Some(delay) = deadline.checked_duration_since(now) {
-                    Self::sleep(delay);
-                }
+        // ... otherwise we're sleeping for 500+ years relative to the
+        // "start" of what the system is using as a clock so speed/accuracy
+        // is not so much of a concern. Use `sleep` instead.
+        Err(_) => {
+            let now = Instant::now();
+
+            if let Some(delay) = deadline.checked_duration_since(now) {
+                sleep(delay);
             }
         }
     }
-
-    pub fn join(self) {
-        self.0
-    }
-}
-
-pub(crate) fn current_os_id() -> Option<u64> {
-    None
-}
-
-pub fn available_parallelism() -> io::Result<NonZero<usize>> {
-    crate::sys::unsupported()
 }
diff --git a/library/std/src/sys/thread/wasm.rs b/library/std/src/sys/thread/wasm.rs
index 42a7dbdf8b8b0..e843bc992ba1b 100644
--- a/library/std/src/sys/thread/wasm.rs
+++ b/library/std/src/sys/thread/wasm.rs
@@ -1,75 +1,23 @@
-use crate::ffi::CStr;
-use crate::io;
-use crate::num::NonZero;
-use crate::sys::unsupported;
-use crate::time::{Duration, Instant};
-
-pub struct Thread(!);
-
-pub const DEFAULT_MIN_STACK_SIZE: usize = 1024 * 1024;
-
-impl Thread {
-    // unsafe: see thread::Builder::spawn_unchecked for safety requirements
-    pub unsafe fn new(
-        _stack: usize,
-        _name: Option<&str>,
-        _p: Box<dyn FnOnce()>,
-    ) -> io::Result<Thread> {
-        unsupported()
-    }
-
-    pub fn yield_now() {}
-
-    pub fn set_name(_name: &CStr) {}
-
-    pub fn sleep(dur: Duration) {
-        #[cfg(target_arch = "wasm32")]
-        use core::arch::wasm32 as wasm;
-        #[cfg(target_arch = "wasm64")]
-        use core::arch::wasm64 as wasm;
-
-        use crate::cmp;
-
-        // Use an atomic wait to block the current thread artificially with a
-        // timeout listed. Note that we should never be notified (return value
-        // of 0) or our comparison should never fail (return value of 1) so we
-        // should always only resume execution through a timeout (return value
-        // 2).
-        let mut nanos = dur.as_nanos();
-        while nanos > 0 {
-            let amt = cmp::min(i64::MAX as u128, nanos);
-            let mut x = 0;
-            let val = unsafe { wasm::memory_atomic_wait32(&mut x, 0, amt as i64) };
-            debug_assert_eq!(val, 2);
-            nanos -= amt;
-        }
-    }
-
-    pub fn sleep_until(deadline: Instant) {
-        let now = Instant::now();
-
-        if let Some(delay) = deadline.checked_duration_since(now) {
-            Self::sleep(delay);
-        }
-    }
-
-    pub fn join(self) {}
-}
-
-pub(crate) fn current_os_id() -> Option<u64> {
-    None
-}
-
-pub fn available_parallelism() -> io::Result<NonZero<usize>> {
-    unsupported()
-}
-
-pub mod guard {
-    pub type Guard = !;
-    pub unsafe fn current() -> Option<Guard> {
-        None
-    }
-    pub unsafe fn init() -> Option<Guard> {
-        None
+use crate::cmp;
+use crate::time::Duration;
+
+pub fn sleep(dur: Duration) {
+    #[cfg(target_arch = "wasm32")]
+    use core::arch::wasm32 as wasm;
+    #[cfg(target_arch = "wasm64")]
+    use core::arch::wasm64 as wasm;
+
+    // Use an atomic wait to block the current thread artificially with a
+    // timeout listed. Note that we should never be notified (return value
+    // of 0) or our comparison should never fail (return value of 1) so we
+    // should always only resume execution through a timeout (return value
+    // 2).
+    let mut nanos = dur.as_nanos();
+    while nanos > 0 {
+        let amt = cmp::min(i64::MAX as u128, nanos);
+        let mut x = 0;
+        let val = unsafe { wasm::memory_atomic_wait32(&mut x, 0, amt as i64) };
+        debug_assert_eq!(val, 2);
+        nanos -= amt;
     }
 }
diff --git a/library/std/src/sys/thread/windows.rs b/library/std/src/sys/thread/windows.rs
index b0e38220a2d3b..a5640c51c4a5d 100644
--- a/library/std/src/sys/thread/windows.rs
+++ b/library/std/src/sys/thread/windows.rs
@@ -1,14 +1,14 @@
 use core::ffi::c_void;
 
-use super::time::WaitableTimer;
-use super::to_u16s;
 use crate::ffi::CStr;
 use crate::num::NonZero;
 use crate::os::windows::io::{AsRawHandle, HandleOrNull};
 use crate::sys::handle::Handle;
+use crate::sys::pal::time::WaitableTimer;
+use crate::sys::pal::{dur2timeout, to_u16s};
 use crate::sys::{c, stack_overflow};
 use crate::sys_common::FromInner;
-use crate::time::{Duration, Instant};
+use crate::time::Duration;
 use crate::{io, ptr};
 
 pub const DEFAULT_MIN_STACK_SIZE: usize = 2 * 1024 * 1024;
@@ -62,24 +62,6 @@ impl Thread {
         }
     }
 
-    pub fn set_name(name: &CStr) {
-        if let Ok(utf8) = name.to_str() {
-            if let Ok(utf16) = to_u16s(utf8) {
-                unsafe {
-                    // SAFETY: the vec returned by `to_u16s` ends with a zero value
-                    Self::set_name_wide(&utf16)
-                }
-            };
-        };
-    }
-
-    /// # Safety
-    ///
-    /// `name` must end with a zero value
-    pub unsafe fn set_name_wide(name: &[u16]) {
-        unsafe { c::SetThreadDescription(c::GetCurrentThread(), name.as_ptr()) };
-    }
-
     pub fn join(self) {
         let rc = unsafe { c::WaitForSingleObject(self.handle.as_raw_handle(), c::INFINITE) };
         if rc == c::WAIT_FAILED {
@@ -87,37 +69,6 @@ impl Thread {
         }
     }
 
-    pub fn yield_now() {
-        // This function will return 0 if there are no other threads to execute,
-        // but this also means that the yield was useless so this isn't really a
-        // case that needs to be worried about.
-        unsafe {
-            c::SwitchToThread();
-        }
-    }
-
-    pub fn sleep(dur: Duration) {
-        fn high_precision_sleep(dur: Duration) -> Result<(), ()> {
-            let timer = WaitableTimer::high_resolution()?;
-            timer.set(dur)?;
-            timer.wait()
-        }
-        // Attempt to use high-precision sleep (Windows 10, version 1803+).
-        // On error fallback to the standard `Sleep` function.
-        // Also preserves the zero duration behavior of `Sleep`.
-        if dur.is_zero() || high_precision_sleep(dur).is_err() {
-            unsafe { c::Sleep(super::dur2timeout(dur)) }
-        }
-    }
-
-    pub fn sleep_until(deadline: Instant) {
-        let now = Instant::now();
-
-        if let Some(delay) = deadline.checked_duration_since(now) {
-            Self::sleep(delay);
-        }
-    }
-
     pub fn handle(&self) -> &Handle {
         &self.handle
     }
@@ -127,14 +78,6 @@ impl Thread {
     }
 }
 
-pub(crate) fn current_os_id() -> Option<u64> {
-    // SAFETY: FFI call with no preconditions.
-    let id: u32 = unsafe { c::GetCurrentThreadId() };
-
-    // A return value of 0 indicates failed lookup.
-    if id == 0 { None } else { Some(id.into()) }
-}
-
 pub fn available_parallelism() -> io::Result<NonZero<usize>> {
     let res = unsafe {
         let mut sysinfo: c::SYSTEM_INFO = crate::mem::zeroed();
@@ -146,3 +89,52 @@ pub fn available_parallelism() -> io::Result<NonZero<usize>> {
         cpus => Ok(unsafe { NonZero::new_unchecked(cpus) }),
     }
 }
+
+pub fn current_os_id() -> Option<u64> {
+    // SAFETY: FFI call with no preconditions.
+    let id: u32 = unsafe { c::GetCurrentThreadId() };
+
+    // A return value of 0 indicates failed lookup.
+    if id == 0 { None } else { Some(id.into()) }
+}
+
+pub fn set_name(name: &CStr) {
+    if let Ok(utf8) = name.to_str() {
+        if let Ok(utf16) = to_u16s(utf8) {
+            unsafe {
+                // SAFETY: the vec returned by `to_u16s` ends with a zero value
+                set_name_wide(&utf16)
+            }
+        };
+    };
+}
+
+/// # Safety
+///
+/// `name` must end with a zero value
+pub unsafe fn set_name_wide(name: &[u16]) {
+    unsafe { c::SetThreadDescription(c::GetCurrentThread(), name.as_ptr()) };
+}
+
+pub fn sleep(dur: Duration) {
+    fn high_precision_sleep(dur: Duration) -> Result<(), ()> {
+        let timer = WaitableTimer::high_resolution()?;
+        timer.set(dur)?;
+        timer.wait()
+    }
+    // Attempt to use high-precision sleep (Windows 10, version 1803+).
+    // On error fallback to the standard `Sleep` function.
+    // Also preserves the zero duration behavior of `Sleep`.
+    if dur.is_zero() || high_precision_sleep(dur).is_err() {
+        unsafe { c::Sleep(dur2timeout(dur)) }
+    }
+}
+
+pub fn yield_now() {
+    // This function will return 0 if there are no other threads to execute,
+    // but this also means that the yield was useless so this isn't really a
+    // case that needs to be worried about.
+    unsafe {
+        c::SwitchToThread();
+    }
+}
diff --git a/library/std/src/sys/thread/xous.rs b/library/std/src/sys/thread/xous.rs
index 92803c94c6e70..133e15a0928c6 100644
--- a/library/std/src/sys/thread/xous.rs
+++ b/library/std/src/sys/thread/xous.rs
@@ -1,6 +1,5 @@
 use core::arch::asm;
 
-use crate::ffi::CStr;
 use crate::io;
 use crate::num::NonZero;
 use crate::os::xous::ffi::{
@@ -8,7 +7,7 @@ use crate::os::xous::ffi::{
     map_memory, update_memory_flags,
 };
 use crate::os::xous::services::{TicktimerScalar, ticktimer_server};
-use crate::time::{Duration, Instant};
+use crate::time::Duration;
 
 pub struct Thread {
     tid: ThreadId,
@@ -110,46 +109,29 @@ impl Thread {
         Ok(Thread { tid })
     }
 
-    pub fn yield_now() {
-        do_yield();
-    }
-
-    pub fn set_name(_name: &CStr) {
-        // nope
-    }
-
-    pub fn sleep(dur: Duration) {
-        // Because the sleep server works on units of `usized milliseconds`, split
-        // the messages up into these chunks. This means we may run into issues
-        // if you try to sleep a thread for more than 49 days on a 32-bit system.
-        let mut millis = dur.as_millis();
-        while millis > 0 {
-            let sleep_duration =
-                if millis > (usize::MAX as _) { usize::MAX } else { millis as usize };
-            blocking_scalar(ticktimer_server(), TicktimerScalar::SleepMs(sleep_duration).into())
-                .expect("failed to send message to ticktimer server");
-            millis -= sleep_duration as u128;
-        }
-    }
-
-    pub fn sleep_until(deadline: Instant) {
-        let now = Instant::now();
-
-        if let Some(delay) = deadline.checked_duration_since(now) {
-            Self::sleep(delay);
-        }
-    }
-
     pub fn join(self) {
         join_thread(self.tid).unwrap();
     }
 }
 
-pub(crate) fn current_os_id() -> Option<u64> {
-    None
-}
-
 pub fn available_parallelism() -> io::Result<NonZero<usize>> {
     // We're unicore right now.
     Ok(unsafe { NonZero::new_unchecked(1) })
 }
+
+pub fn yield_now() {
+    do_yield();
+}
+
+pub fn sleep(dur: Duration) {
+    // Because the sleep server works on units of `usized milliseconds`, split
+    // the messages up into these chunks. This means we may run into issues
+    // if you try to sleep a thread for more than 49 days on a 32-bit system.
+    let mut millis = dur.as_millis();
+    while millis > 0 {
+        let sleep_duration = if millis > (usize::MAX as _) { usize::MAX } else { millis as usize };
+        blocking_scalar(ticktimer_server(), TicktimerScalar::SleepMs(sleep_duration).into())
+            .expect("failed to send message to ticktimer server");
+        millis -= sleep_duration as u128;
+    }
+}
diff --git a/library/std/src/thread/mod.rs b/library/std/src/thread/mod.rs
index b6059c28cec7d..97b506c1b8fe3 100644
--- a/library/std/src/thread/mod.rs
+++ b/library/std/src/thread/mod.rs
@@ -550,7 +550,7 @@ impl Builder {
             }
 
             if let Some(name) = their_thread.cname() {
-                imp::Thread::set_name(name);
+                imp::set_name(name);
             }
 
             let f = f.into_inner();
@@ -763,7 +763,7 @@ where
 /// [`Mutex`]: crate::sync::Mutex
 #[stable(feature = "rust1", since = "1.0.0")]
 pub fn yield_now() {
-    imp::Thread::yield_now()
+    imp::yield_now()
 }
 
 /// Determines whether the current thread is unwinding because of panic.
@@ -884,7 +884,7 @@ pub fn sleep_ms(ms: u32) {
 /// ```
 #[stable(feature = "thread_sleep", since = "1.4.0")]
 pub fn sleep(dur: Duration) {
-    imp::Thread::sleep(dur)
+    imp::sleep(dur)
 }
 
 /// Puts the current thread to sleep until the specified deadline has passed.
@@ -983,7 +983,7 @@ pub fn sleep(dur: Duration) {
 /// ```
 #[unstable(feature = "thread_sleep_until", issue = "113752")]
 pub fn sleep_until(deadline: Instant) {
-    imp::Thread::sleep_until(deadline)
+    imp::sleep_until(deadline)
 }
 
 /// Used to ensure that `park` and `park_timeout` do not unwind, as that can

From f049b6147c15496d70b69490dbcaef4f824f1cdf Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Sat, 9 Aug 2025 23:40:24 +0200
Subject: [PATCH 0751/1889] bless miri tests

---
 .../fail-dep/concurrency/libc_pthread_mutex_deadlock.stderr   | 4 ++--
 .../libc_pthread_rwlock_write_read_deadlock.stderr            | 4 ++--
 .../libc_pthread_rwlock_write_write_deadlock.stderr           | 4 ++--
 .../tests/fail-dep/concurrency/windows_join_detached.stderr   | 4 ++--
 .../miri/tests/fail-dep/concurrency/windows_join_main.stderr  | 4 ++--
 .../miri/tests/fail-dep/concurrency/windows_join_self.stderr  | 4 ++--
 .../miri/tests/fail-dep/libc/eventfd_block_read_twice.stderr  | 4 ++--
 .../miri/tests/fail-dep/libc/eventfd_block_write_twice.stderr | 4 ++--
 .../tests/fail-dep/libc/libc_epoll_block_two_thread.stderr    | 4 ++--
 .../tests/fail-dep/libc/socketpair-close-while-blocked.stderr | 4 ++--
 .../tests/fail-dep/libc/socketpair_block_read_twice.stderr    | 4 ++--
 .../tests/fail-dep/libc/socketpair_block_write_twice.stderr   | 4 ++--
 12 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutex_deadlock.stderr b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutex_deadlock.stderr
index bcec5557a3fa4..c7c1a769cdaa5 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutex_deadlock.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutex_deadlock.stderr
@@ -8,13 +8,13 @@ LL |             assert_eq!(libc::pthread_mutex_lock(lock_copy.0.get() as *mut _
    = note: inside closure at tests/fail-dep/concurrency/libc_pthread_mutex_deadlock.rs:LL:CC
 
 error: the evaluated program deadlocked
-  --> RUSTLIB/std/src/sys/pal/PLATFORM/thread.rs:LL:CC
+  --> RUSTLIB/std/src/sys/thread/PLATFORM.rs:LL:CC
    |
 LL |         let ret = unsafe { libc::pthread_join(id, ptr::null_mut()) };
    |                                                                  ^ this thread got stuck here
    |
    = note: BACKTRACE:
-   = note: inside `std::sys::pal::PLATFORM::thread::Thread::join` at RUSTLIB/std/src/sys/pal/PLATFORM/thread.rs:LL:CC
+   = note: inside `std::sys::thread::PLATFORM::Thread::join` at RUSTLIB/std/src/sys/thread/PLATFORM.rs:LL:CC
    = note: inside `std::thread::JoinInner::<'_, ()>::join` at RUSTLIB/std/src/thread/mod.rs:LL:CC
    = note: inside `std::thread::JoinHandle::<()>::join` at RUSTLIB/std/src/thread/mod.rs:LL:CC
 note: inside `main`
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_rwlock_write_read_deadlock.stderr b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_rwlock_write_read_deadlock.stderr
index 51533cd17a8fb..ae8b2b936a71f 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_rwlock_write_read_deadlock.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_rwlock_write_read_deadlock.stderr
@@ -8,13 +8,13 @@ LL |             assert_eq!(libc::pthread_rwlock_wrlock(lock_copy.0.get() as *mu
    = note: inside closure at tests/fail-dep/concurrency/libc_pthread_rwlock_write_read_deadlock.rs:LL:CC
 
 error: the evaluated program deadlocked
-  --> RUSTLIB/std/src/sys/pal/PLATFORM/thread.rs:LL:CC
+  --> RUSTLIB/std/src/sys/thread/PLATFORM.rs:LL:CC
    |
 LL |         let ret = unsafe { libc::pthread_join(id, ptr::null_mut()) };
    |                                                                  ^ this thread got stuck here
    |
    = note: BACKTRACE:
-   = note: inside `std::sys::pal::PLATFORM::thread::Thread::join` at RUSTLIB/std/src/sys/pal/PLATFORM/thread.rs:LL:CC
+   = note: inside `std::sys::thread::PLATFORM::Thread::join` at RUSTLIB/std/src/sys/thread/PLATFORM.rs:LL:CC
    = note: inside `std::thread::JoinInner::<'_, ()>::join` at RUSTLIB/std/src/thread/mod.rs:LL:CC
    = note: inside `std::thread::JoinHandle::<()>::join` at RUSTLIB/std/src/thread/mod.rs:LL:CC
 note: inside `main`
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_rwlock_write_write_deadlock.stderr b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_rwlock_write_write_deadlock.stderr
index 63fc7ce346e0c..dfa9a6e258310 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_rwlock_write_write_deadlock.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_rwlock_write_write_deadlock.stderr
@@ -8,13 +8,13 @@ LL |             assert_eq!(libc::pthread_rwlock_wrlock(lock_copy.0.get() as *mu
    = note: inside closure at tests/fail-dep/concurrency/libc_pthread_rwlock_write_write_deadlock.rs:LL:CC
 
 error: the evaluated program deadlocked
-  --> RUSTLIB/std/src/sys/pal/PLATFORM/thread.rs:LL:CC
+  --> RUSTLIB/std/src/sys/thread/PLATFORM.rs:LL:CC
    |
 LL |         let ret = unsafe { libc::pthread_join(id, ptr::null_mut()) };
    |                                                                  ^ this thread got stuck here
    |
    = note: BACKTRACE:
-   = note: inside `std::sys::pal::PLATFORM::thread::Thread::join` at RUSTLIB/std/src/sys/pal/PLATFORM/thread.rs:LL:CC
+   = note: inside `std::sys::thread::PLATFORM::Thread::join` at RUSTLIB/std/src/sys/thread/PLATFORM.rs:LL:CC
    = note: inside `std::thread::JoinInner::<'_, ()>::join` at RUSTLIB/std/src/thread/mod.rs:LL:CC
    = note: inside `std::thread::JoinHandle::<()>::join` at RUSTLIB/std/src/thread/mod.rs:LL:CC
 note: inside `main`
diff --git a/src/tools/miri/tests/fail-dep/concurrency/windows_join_detached.stderr b/src/tools/miri/tests/fail-dep/concurrency/windows_join_detached.stderr
index d8a3e058da933..47a0ebdcfef82 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/windows_join_detached.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/windows_join_detached.stderr
@@ -1,5 +1,5 @@
 error: Undefined Behavior: trying to join a detached thread
-  --> RUSTLIB/std/src/sys/pal/PLATFORM/thread.rs:LL:CC
+  --> RUSTLIB/std/src/sys/thread/PLATFORM.rs:LL:CC
    |
 LL |         let rc = unsafe { c::WaitForSingleObject(self.handle.as_raw_handle(), c::INFINITE) };
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
@@ -7,7 +7,7 @@ LL |         let rc = unsafe { c::WaitForSingleObject(self.handle.as_raw_handle(
    = 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::thread::Thread::join` at RUSTLIB/std/src/sys/pal/PLATFORM/thread.rs:LL:CC
+   = note: inside `std::sys::thread::PLATFORM::Thread::join` at RUSTLIB/std/src/sys/thread/PLATFORM.rs:LL:CC
    = note: inside `std::thread::JoinInner::<'_, ()>::join` at RUSTLIB/std/src/thread/mod.rs:LL:CC
    = note: inside `std::thread::JoinHandle::<()>::join` at RUSTLIB/std/src/thread/mod.rs:LL:CC
 note: inside `main`
diff --git a/src/tools/miri/tests/fail-dep/concurrency/windows_join_main.stderr b/src/tools/miri/tests/fail-dep/concurrency/windows_join_main.stderr
index 079f01c0e5493..3b1181c92fd9a 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/windows_join_main.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/windows_join_main.stderr
@@ -9,13 +9,13 @@ LL |             assert_eq!(WaitForSingleObject(MAIN_THREAD, INFINITE), WAIT_OBJ
    = note: this error originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: the evaluated program deadlocked
-  --> RUSTLIB/std/src/sys/pal/PLATFORM/thread.rs:LL:CC
+  --> RUSTLIB/std/src/sys/thread/PLATFORM.rs:LL:CC
    |
 LL |         let rc = unsafe { c::WaitForSingleObject(self.handle.as_raw_handle(), c::INFINITE) };
    |                                                                                          ^ this thread got stuck here
    |
    = note: BACKTRACE:
-   = note: inside `std::sys::pal::PLATFORM::thread::Thread::join` at RUSTLIB/std/src/sys/pal/PLATFORM/thread.rs:LL:CC
+   = note: inside `std::sys::thread::PLATFORM::Thread::join` at RUSTLIB/std/src/sys/thread/PLATFORM.rs:LL:CC
    = note: inside `std::thread::JoinInner::<'_, ()>::join` at RUSTLIB/std/src/thread/mod.rs:LL:CC
    = note: inside `std::thread::JoinHandle::<()>::join` at RUSTLIB/std/src/thread/mod.rs:LL:CC
 note: inside `main`
diff --git a/src/tools/miri/tests/fail-dep/concurrency/windows_join_self.stderr b/src/tools/miri/tests/fail-dep/concurrency/windows_join_self.stderr
index 70de94f56bac3..6eefa2da1d819 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/windows_join_self.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/windows_join_self.stderr
@@ -8,13 +8,13 @@ LL |             assert_eq!(WaitForSingleObject(native, INFINITE), WAIT_OBJECT_0
    = note: inside closure at tests/fail-dep/concurrency/windows_join_self.rs:LL:CC
 
 error: the evaluated program deadlocked
-  --> RUSTLIB/std/src/sys/pal/PLATFORM/thread.rs:LL:CC
+  --> RUSTLIB/std/src/sys/thread/PLATFORM.rs:LL:CC
    |
 LL |         let rc = unsafe { c::WaitForSingleObject(self.handle.as_raw_handle(), c::INFINITE) };
    |                                                                                          ^ this thread got stuck here
    |
    = note: BACKTRACE:
-   = note: inside `std::sys::pal::PLATFORM::thread::Thread::join` at RUSTLIB/std/src/sys/pal/PLATFORM/thread.rs:LL:CC
+   = note: inside `std::sys::thread::PLATFORM::Thread::join` at RUSTLIB/std/src/sys/thread/PLATFORM.rs:LL:CC
    = note: inside `std::thread::JoinInner::<'_, ()>::join` at RUSTLIB/std/src/thread/mod.rs:LL:CC
    = note: inside `std::thread::JoinHandle::<()>::join` at RUSTLIB/std/src/thread/mod.rs:LL:CC
 note: inside `main`
diff --git a/src/tools/miri/tests/fail-dep/libc/eventfd_block_read_twice.stderr b/src/tools/miri/tests/fail-dep/libc/eventfd_block_read_twice.stderr
index 4f3a56fef8262..6dd6c36ab6560 100644
--- a/src/tools/miri/tests/fail-dep/libc/eventfd_block_read_twice.stderr
+++ b/src/tools/miri/tests/fail-dep/libc/eventfd_block_read_twice.stderr
@@ -1,11 +1,11 @@
 error: the evaluated program deadlocked
-  --> RUSTLIB/std/src/sys/pal/PLATFORM/thread.rs:LL:CC
+  --> RUSTLIB/std/src/sys/thread/PLATFORM.rs:LL:CC
    |
 LL |         let ret = unsafe { libc::pthread_join(id, ptr::null_mut()) };
    |                                                                  ^ this thread got stuck here
    |
    = note: BACKTRACE:
-   = note: inside `std::sys::pal::PLATFORM::thread::Thread::join` at RUSTLIB/std/src/sys/pal/PLATFORM/thread.rs:LL:CC
+   = note: inside `std::sys::thread::PLATFORM::Thread::join` at RUSTLIB/std/src/sys/thread/PLATFORM.rs:LL:CC
    = note: inside `std::thread::JoinInner::<'_, ()>::join` at RUSTLIB/std/src/thread/mod.rs:LL:CC
    = note: inside `std::thread::JoinHandle::<()>::join` at RUSTLIB/std/src/thread/mod.rs:LL:CC
 note: inside `main`
diff --git a/src/tools/miri/tests/fail-dep/libc/eventfd_block_write_twice.stderr b/src/tools/miri/tests/fail-dep/libc/eventfd_block_write_twice.stderr
index 5045badaa870f..3154197b95ed4 100644
--- a/src/tools/miri/tests/fail-dep/libc/eventfd_block_write_twice.stderr
+++ b/src/tools/miri/tests/fail-dep/libc/eventfd_block_write_twice.stderr
@@ -1,11 +1,11 @@
 error: the evaluated program deadlocked
-  --> RUSTLIB/std/src/sys/pal/PLATFORM/thread.rs:LL:CC
+  --> RUSTLIB/std/src/sys/thread/PLATFORM.rs:LL:CC
    |
 LL |         let ret = unsafe { libc::pthread_join(id, ptr::null_mut()) };
    |                                                                  ^ this thread got stuck here
    |
    = note: BACKTRACE:
-   = note: inside `std::sys::pal::PLATFORM::thread::Thread::join` at RUSTLIB/std/src/sys/pal/PLATFORM/thread.rs:LL:CC
+   = note: inside `std::sys::thread::PLATFORM::Thread::join` at RUSTLIB/std/src/sys/thread/PLATFORM.rs:LL:CC
    = note: inside `std::thread::JoinInner::<'_, ()>::join` at RUSTLIB/std/src/thread/mod.rs:LL:CC
    = note: inside `std::thread::JoinHandle::<()>::join` at RUSTLIB/std/src/thread/mod.rs:LL:CC
 note: inside `main`
diff --git a/src/tools/miri/tests/fail-dep/libc/libc_epoll_block_two_thread.stderr b/src/tools/miri/tests/fail-dep/libc/libc_epoll_block_two_thread.stderr
index 3713c8da392b7..1af44c107ff85 100644
--- a/src/tools/miri/tests/fail-dep/libc/libc_epoll_block_two_thread.stderr
+++ b/src/tools/miri/tests/fail-dep/libc/libc_epoll_block_two_thread.stderr
@@ -5,13 +5,13 @@ error: the evaluated program deadlocked
    = note: BACKTRACE on thread `unnamed-ID`:
 
 error: the evaluated program deadlocked
-  --> RUSTLIB/std/src/sys/pal/PLATFORM/thread.rs:LL:CC
+  --> RUSTLIB/std/src/sys/thread/PLATFORM.rs:LL:CC
    |
 LL |         let ret = unsafe { libc::pthread_join(id, ptr::null_mut()) };
    |                                                                  ^ this thread got stuck here
    |
    = note: BACKTRACE:
-   = note: inside `std::sys::pal::PLATFORM::thread::Thread::join` at RUSTLIB/std/src/sys/pal/PLATFORM/thread.rs:LL:CC
+   = note: inside `std::sys::thread::PLATFORM::Thread::join` at RUSTLIB/std/src/sys/thread/PLATFORM.rs:LL:CC
    = note: inside `std::thread::JoinInner::<'_, ()>::join` at RUSTLIB/std/src/thread/mod.rs:LL:CC
    = note: inside `std::thread::JoinHandle::<()>::join` at RUSTLIB/std/src/thread/mod.rs:LL:CC
 note: inside `main`
diff --git a/src/tools/miri/tests/fail-dep/libc/socketpair-close-while-blocked.stderr b/src/tools/miri/tests/fail-dep/libc/socketpair-close-while-blocked.stderr
index 47fc889b00106..b85470225c692 100644
--- a/src/tools/miri/tests/fail-dep/libc/socketpair-close-while-blocked.stderr
+++ b/src/tools/miri/tests/fail-dep/libc/socketpair-close-while-blocked.stderr
@@ -1,11 +1,11 @@
 error: the evaluated program deadlocked
-  --> RUSTLIB/std/src/sys/pal/PLATFORM/thread.rs:LL:CC
+  --> RUSTLIB/std/src/sys/thread/PLATFORM.rs:LL:CC
    |
 LL |         let ret = unsafe { libc::pthread_join(id, ptr::null_mut()) };
    |                                                                  ^ this thread got stuck here
    |
    = note: BACKTRACE:
-   = note: inside `std::sys::pal::PLATFORM::thread::Thread::join` at RUSTLIB/std/src/sys/pal/PLATFORM/thread.rs:LL:CC
+   = note: inside `std::sys::thread::PLATFORM::Thread::join` at RUSTLIB/std/src/sys/thread/PLATFORM.rs:LL:CC
    = note: inside `std::thread::JoinInner::<'_, ()>::join` at RUSTLIB/std/src/thread/mod.rs:LL:CC
    = note: inside `std::thread::JoinHandle::<()>::join` at RUSTLIB/std/src/thread/mod.rs:LL:CC
 note: inside `main`
diff --git a/src/tools/miri/tests/fail-dep/libc/socketpair_block_read_twice.stderr b/src/tools/miri/tests/fail-dep/libc/socketpair_block_read_twice.stderr
index 99d242ec7dafa..bbd2ab1c4d8de 100644
--- a/src/tools/miri/tests/fail-dep/libc/socketpair_block_read_twice.stderr
+++ b/src/tools/miri/tests/fail-dep/libc/socketpair_block_read_twice.stderr
@@ -1,11 +1,11 @@
 error: the evaluated program deadlocked
-  --> RUSTLIB/std/src/sys/pal/PLATFORM/thread.rs:LL:CC
+  --> RUSTLIB/std/src/sys/thread/PLATFORM.rs:LL:CC
    |
 LL |         let ret = unsafe { libc::pthread_join(id, ptr::null_mut()) };
    |                                                                  ^ this thread got stuck here
    |
    = note: BACKTRACE:
-   = note: inside `std::sys::pal::PLATFORM::thread::Thread::join` at RUSTLIB/std/src/sys/pal/PLATFORM/thread.rs:LL:CC
+   = note: inside `std::sys::thread::PLATFORM::Thread::join` at RUSTLIB/std/src/sys/thread/PLATFORM.rs:LL:CC
    = note: inside `std::thread::JoinInner::<'_, ()>::join` at RUSTLIB/std/src/thread/mod.rs:LL:CC
    = note: inside `std::thread::JoinHandle::<()>::join` at RUSTLIB/std/src/thread/mod.rs:LL:CC
 note: inside `main`
diff --git a/src/tools/miri/tests/fail-dep/libc/socketpair_block_write_twice.stderr b/src/tools/miri/tests/fail-dep/libc/socketpair_block_write_twice.stderr
index f766500d331da..c3cc206817315 100644
--- a/src/tools/miri/tests/fail-dep/libc/socketpair_block_write_twice.stderr
+++ b/src/tools/miri/tests/fail-dep/libc/socketpair_block_write_twice.stderr
@@ -1,11 +1,11 @@
 error: the evaluated program deadlocked
-  --> RUSTLIB/std/src/sys/pal/PLATFORM/thread.rs:LL:CC
+  --> RUSTLIB/std/src/sys/thread/PLATFORM.rs:LL:CC
    |
 LL |         let ret = unsafe { libc::pthread_join(id, ptr::null_mut()) };
    |                                                                  ^ this thread got stuck here
    |
    = note: BACKTRACE:
-   = note: inside `std::sys::pal::PLATFORM::thread::Thread::join` at RUSTLIB/std/src/sys/pal/PLATFORM/thread.rs:LL:CC
+   = note: inside `std::sys::thread::PLATFORM::Thread::join` at RUSTLIB/std/src/sys/thread/PLATFORM.rs:LL:CC
    = note: inside `std::thread::JoinInner::<'_, ()>::join` at RUSTLIB/std/src/thread/mod.rs:LL:CC
    = note: inside `std::thread::JoinHandle::<()>::join` at RUSTLIB/std/src/thread/mod.rs:LL:CC
 note: inside `main`

From 4c992199598b4fddc25d52f40fa3642c9e065e60 Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Tue, 9 Sep 2025 13:17:45 +0200
Subject: [PATCH 0752/1889] std: only test `dlsym!` on platforms where it is
 actually used

`dlsym` doesn't work for finding libc symbols on platforms like linux-musl, so the test will fail.
---
 library/std/src/sys/pal/unix/weak.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/library/std/src/sys/pal/unix/weak.rs b/library/std/src/sys/pal/unix/weak.rs
index ad649fdbab6c6..a3b980a3f3d85 100644
--- a/library/std/src/sys/pal/unix/weak.rs
+++ b/library/std/src/sys/pal/unix/weak.rs
@@ -27,6 +27,16 @@ use crate::marker::{FnPtr, PhantomData};
 use crate::sync::atomic::{Atomic, AtomicPtr, Ordering};
 use crate::{mem, ptr};
 
+// We currently only test `dlsym!`, but that doesn't work on all platforms, so
+// we gate the tests to only the platforms where it is actually used.
+//
+// FIXME(joboet): add more tests, reorganise the whole module and get rid of
+//                `#[allow(dead_code, unused_macros)]`.
+#[cfg(any(
+    target_vendor = "apple",
+    all(target_os = "linux", target_env = "gnu"),
+    target_os = "freebsd",
+))]
 #[cfg(test)]
 mod tests;
 

From 8ecda4b7f866d77d4a87c5b5bc601d4078841093 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 10 Sep 2025 12:05:53 +0200
Subject: [PATCH 0753/1889] interpret: fix overlapping aggregate initialization

---
 .../rustc_const_eval/src/interpret/place.rs   |  2 +-
 .../rustc_const_eval/src/interpret/step.rs    | 16 +++++++++++++---
 .../fail/both_borrows/issue-miri-1050-1.rs    |  2 ++
 .../fail/both_borrows/issue-miri-1050-2.rs    |  2 ++
 .../return_invalid_shr.stack.stderr           |  2 +-
 .../return_invalid_shr.tree.stderr            |  2 +-
 .../return_invalid_shr_option.stack.stderr    |  2 +-
 .../return_invalid_shr_option.tree.stderr     |  2 +-
 .../return_invalid_shr_tuple.stack.stderr     |  2 +-
 .../return_invalid_shr_tuple.tree.stderr      |  2 +-
 .../fail/overlapping_assignment_aggregate.rs  | 18 ++++++++++++++++++
 .../overlapping_assignment_aggregate.stderr   | 15 +++++++++++++++
 .../miri/tests/fail/validity/nonzero.stderr   |  2 +-
 ...overlapping_assignment_aggregate_scalar.rs | 19 +++++++++++++++++++
 14 files changed, 77 insertions(+), 11 deletions(-)
 create mode 100644 src/tools/miri/tests/fail/overlapping_assignment_aggregate.rs
 create mode 100644 src/tools/miri/tests/fail/overlapping_assignment_aggregate.stderr
 create mode 100644 src/tools/miri/tests/pass/overlapping_assignment_aggregate_scalar.rs

diff --git a/compiler/rustc_const_eval/src/interpret/place.rs b/compiler/rustc_const_eval/src/interpret/place.rs
index a86fdf80f601a..cd34892f029cf 100644
--- a/compiler/rustc_const_eval/src/interpret/place.rs
+++ b/compiler/rustc_const_eval/src/interpret/place.rs
@@ -858,7 +858,7 @@ where
     /// Also, if you use this you are responsible for validating that things get copied at the
     /// right type.
     #[instrument(skip(self), level = "trace")]
-    fn copy_op_no_validate(
+    pub(super) fn copy_op_no_validate(
         &mut self,
         src: &impl Projectable<'tcx, M::Provenance>,
         dest: &impl Writeable<'tcx, M::Provenance>,
diff --git a/compiler/rustc_const_eval/src/interpret/step.rs b/compiler/rustc_const_eval/src/interpret/step.rs
index 23d362de308f3..46950d60f8c78 100644
--- a/compiler/rustc_const_eval/src/interpret/step.rs
+++ b/compiler/rustc_const_eval/src/interpret/step.rs
@@ -310,7 +310,6 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         operands: &IndexSlice<FieldIdx, mir::Operand<'tcx>>,
         dest: &PlaceTy<'tcx, M::Provenance>,
     ) -> InterpResult<'tcx> {
-        self.write_uninit(dest)?; // make sure all the padding ends up as uninit
         let (variant_index, variant_dest, active_field_index) = match *kind {
             mir::AggregateKind::Adt(_, variant_index, _, _, active_field_index) => {
                 let variant_dest = self.project_downcast(dest, variant_index)?;
@@ -346,9 +345,20 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             let field_index = active_field_index.unwrap_or(field_index);
             let field_dest = self.project_field(&variant_dest, field_index)?;
             let op = self.eval_operand(operand, Some(field_dest.layout))?;
-            self.copy_op(&op, &field_dest)?;
+            // We validate manually below so we don't have to do it here.
+            self.copy_op_no_validate(&op, &field_dest, /*allow_transmute*/ false)?;
         }
-        self.write_discriminant(variant_index, dest)
+        self.write_discriminant(variant_index, dest)?;
+        // Validate that the entire thing is valid, and reset padding that might be in between the
+        // fields.
+        if M::enforce_validity(self, dest.layout()) {
+            self.validate_operand(
+                dest,
+                M::enforce_validity_recursively(self, dest.layout()),
+                /*reset_provenance_and_padding*/ true,
+            )?;
+        }
+        interp_ok(())
     }
 
     /// Repeats `operand` into the destination. `dest` must have array type, and that type
diff --git a/src/tools/miri/tests/fail/both_borrows/issue-miri-1050-1.rs b/src/tools/miri/tests/fail/both_borrows/issue-miri-1050-1.rs
index dd7dae9cecf91..d907c5de79700 100644
--- a/src/tools/miri/tests/fail/both_borrows/issue-miri-1050-1.rs
+++ b/src/tools/miri/tests/fail/both_borrows/issue-miri-1050-1.rs
@@ -1,4 +1,6 @@
 //@revisions: stack tree
+// Ensure this even hits the aliasing model
+//@compile-flags: -Zmiri-disable-validation
 //@[tree]compile-flags: -Zmiri-tree-borrows
 //@error-in-other-file: pointer not dereferenceable
 
diff --git a/src/tools/miri/tests/fail/both_borrows/issue-miri-1050-2.rs b/src/tools/miri/tests/fail/both_borrows/issue-miri-1050-2.rs
index 5c947e6414258..b54f27bb8b23e 100644
--- a/src/tools/miri/tests/fail/both_borrows/issue-miri-1050-2.rs
+++ b/src/tools/miri/tests/fail/both_borrows/issue-miri-1050-2.rs
@@ -1,4 +1,6 @@
 //@revisions: stack tree
+// Ensure this even hits the aliasing model
+//@compile-flags: -Zmiri-disable-validation
 //@[tree]compile-flags: -Zmiri-tree-borrows
 //@error-in-other-file: is a dangling pointer
 use std::ptr::NonNull;
diff --git a/src/tools/miri/tests/fail/both_borrows/return_invalid_shr.stack.stderr b/src/tools/miri/tests/fail/both_borrows/return_invalid_shr.stack.stderr
index d52143500c46a..7c4fe74870121 100644
--- a/src/tools/miri/tests/fail/both_borrows/return_invalid_shr.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/return_invalid_shr.stack.stderr
@@ -11,7 +11,7 @@ help: <TAG> was created by a SharedReadOnly retag at offsets [0x4..0x8]
    |
 LL |     let ret = unsafe { &(*xraw).1 };
    |                        ^^^^^^^^^^
-help: <TAG> was later invalidated at offsets [0x0..0x8] by a write access
+help: <TAG> was later invalidated at offsets [0x4..0x8] by a write access
   --> tests/fail/both_borrows/return_invalid_shr.rs:LL:CC
    |
 LL |     unsafe { *xraw = (42, 23) }; // unfreeze
diff --git a/src/tools/miri/tests/fail/both_borrows/return_invalid_shr.tree.stderr b/src/tools/miri/tests/fail/both_borrows/return_invalid_shr.tree.stderr
index ee0f313d980da..a8e3553aae2c2 100644
--- a/src/tools/miri/tests/fail/both_borrows/return_invalid_shr.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/return_invalid_shr.tree.stderr
@@ -12,7 +12,7 @@ help: the accessed tag <TAG> was created here, in the initial state Frozen
    |
 LL |     let ret = unsafe { &(*xraw).1 };
    |                        ^^^^^^^^^^
-help: the accessed tag <TAG> later transitioned to Disabled due to a foreign write access at offsets [0x0..0x8]
+help: the accessed tag <TAG> later transitioned to Disabled due to a foreign write access at offsets [0x4..0x8]
   --> tests/fail/both_borrows/return_invalid_shr.rs:LL:CC
    |
 LL |     unsafe { *xraw = (42, 23) }; // unfreeze
diff --git a/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_option.stack.stderr b/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_option.stack.stderr
index d66c8eeb1af69..8411437ea4c97 100644
--- a/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_option.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_option.stack.stderr
@@ -14,7 +14,7 @@ help: <TAG> was created by a SharedReadOnly retag at offsets [0x4..0x8]
    |
 LL |     let ret = Some(unsafe { &(*xraw).1 });
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: <TAG> was later invalidated at offsets [0x0..0x8] by a write access
+help: <TAG> was later invalidated at offsets [0x4..0x8] by a write access
   --> tests/fail/both_borrows/return_invalid_shr_option.rs:LL:CC
    |
 LL |     unsafe { *xraw = (42, 23) }; // unfreeze
diff --git a/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_option.tree.stderr b/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_option.tree.stderr
index 16110e5b062cc..39da45ad6db4d 100644
--- a/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_option.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_option.tree.stderr
@@ -12,7 +12,7 @@ help: the accessed tag <TAG> was created here, in the initial state Frozen
    |
 LL |     let ret = Some(unsafe { &(*xraw).1 });
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: the accessed tag <TAG> later transitioned to Disabled due to a foreign write access at offsets [0x0..0x8]
+help: the accessed tag <TAG> later transitioned to Disabled due to a foreign write access at offsets [0x4..0x8]
   --> tests/fail/both_borrows/return_invalid_shr_option.rs:LL:CC
    |
 LL |     unsafe { *xraw = (42, 23) }; // unfreeze
diff --git a/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_tuple.stack.stderr b/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_tuple.stack.stderr
index 727b52ec72965..a7c422aa73f2c 100644
--- a/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_tuple.stack.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_tuple.stack.stderr
@@ -14,7 +14,7 @@ help: <TAG> was created by a SharedReadOnly retag at offsets [0x4..0x8]
    |
 LL |     let ret = (unsafe { &(*xraw).1 },);
    |               ^^^^^^^^^^^^^^^^^^^^^^^^
-help: <TAG> was later invalidated at offsets [0x0..0x8] by a write access
+help: <TAG> was later invalidated at offsets [0x4..0x8] by a write access
   --> tests/fail/both_borrows/return_invalid_shr_tuple.rs:LL:CC
    |
 LL |     unsafe { *xraw = (42, 23) }; // unfreeze
diff --git a/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_tuple.tree.stderr b/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_tuple.tree.stderr
index f93698f570ee4..66b03e57905e9 100644
--- a/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_tuple.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/return_invalid_shr_tuple.tree.stderr
@@ -12,7 +12,7 @@ help: the accessed tag <TAG> was created here, in the initial state Frozen
    |
 LL |     let ret = (unsafe { &(*xraw).1 },);
    |               ^^^^^^^^^^^^^^^^^^^^^^^^
-help: the accessed tag <TAG> later transitioned to Disabled due to a foreign write access at offsets [0x0..0x8]
+help: the accessed tag <TAG> later transitioned to Disabled due to a foreign write access at offsets [0x4..0x8]
   --> tests/fail/both_borrows/return_invalid_shr_tuple.rs:LL:CC
    |
 LL |     unsafe { *xraw = (42, 23) }; // unfreeze
diff --git a/src/tools/miri/tests/fail/overlapping_assignment_aggregate.rs b/src/tools/miri/tests/fail/overlapping_assignment_aggregate.rs
new file mode 100644
index 0000000000000..8d7b1946242c0
--- /dev/null
+++ b/src/tools/miri/tests/fail/overlapping_assignment_aggregate.rs
@@ -0,0 +1,18 @@
+//! This is like `pass/overlapping_assignment_aggregate_scalar.rs` but with a non-scalar
+//! type, and that makes it definite UB.
+#![feature(custom_mir, core_intrinsics)]
+#![allow(internal_features)]
+
+use std::intrinsics::mir::*;
+
+#[custom_mir(dialect = "runtime")]
+fn main() {
+    mir! {
+        let _1: ([u8; 1],);
+        {
+            _1.0 = [0_u8; 1];
+            _1 = (_1.0, ); //~ERROR: overlapping ranges
+            Return()
+        }
+    }
+}
diff --git a/src/tools/miri/tests/fail/overlapping_assignment_aggregate.stderr b/src/tools/miri/tests/fail/overlapping_assignment_aggregate.stderr
new file mode 100644
index 0000000000000..f2a6d326b718b
--- /dev/null
+++ b/src/tools/miri/tests/fail/overlapping_assignment_aggregate.stderr
@@ -0,0 +1,15 @@
+error: Undefined Behavior: `copy_nonoverlapping` called on overlapping ranges
+  --> tests/fail/overlapping_assignment_aggregate.rs:LL:CC
+   |
+LL |             _1 = (_1.0, );
+   |             ^^^^^^^^^^^^^ Undefined Behavior occurred here
+   |
+   = 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 tests/fail/overlapping_assignment_aggregate.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/validity/nonzero.stderr b/src/tools/miri/tests/fail/validity/nonzero.stderr
index 0c3a35d6b9fa6..7be3ef46639ca 100644
--- a/src/tools/miri/tests/fail/validity/nonzero.stderr
+++ b/src/tools/miri/tests/fail/validity/nonzero.stderr
@@ -2,7 +2,7 @@ error: Undefined Behavior: constructing invalid value: encountered 0, but expect
   --> tests/fail/validity/nonzero.rs:LL:CC
    |
 LL |     let _x = Some(unsafe { NonZero(0) });
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
+   |                            ^^^^^^^^^^ Undefined Behavior occurred here
    |
    = 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
diff --git a/src/tools/miri/tests/pass/overlapping_assignment_aggregate_scalar.rs b/src/tools/miri/tests/pass/overlapping_assignment_aggregate_scalar.rs
new file mode 100644
index 0000000000000..0cb2f7642424e
--- /dev/null
+++ b/src/tools/miri/tests/pass/overlapping_assignment_aggregate_scalar.rs
@@ -0,0 +1,19 @@
+#![feature(custom_mir, core_intrinsics)]
+#![allow(internal_features)]
+
+use std::intrinsics::mir::*;
+
+#[custom_mir(dialect = "runtime")]
+fn main() {
+    mir! {
+        let _1: (u8,);
+        {
+            _1.0 = 0_u8;
+            // This is a scalar type, so overlap is (for now) not UB.
+            // However, we used to treat such overlapping assignments incorrectly
+            // (see <https://github.com/rust-lang/rust/issues/146383#issuecomment-3273224645>).
+            _1 = (_1.0, );
+            Return()
+        }
+    }
+}

From 72225060edefb6ae4014c671e9953f9822ddff7a Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 10 Sep 2025 14:27:43 +0200
Subject: [PATCH 0754/1889] clarify current MIR semantics re: overlapping
 assignment

and double-check that we match it in codegen
---
 compiler/rustc_codegen_ssa/src/mir/rvalue.rs | 11 ++++++++++-
 compiler/rustc_middle/src/mir/syntax.rs      |  8 +++++---
 2 files changed, 15 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
index f6f2e3f2a3a3c..f8755874014d3 100644
--- a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -1,5 +1,5 @@
 use itertools::Itertools as _;
-use rustc_abi::{self as abi, FIRST_VARIANT};
+use rustc_abi::{self as abi, BackendRepr, FIRST_VARIANT};
 use rustc_middle::ty::adjustment::PointerCoercion;
 use rustc_middle::ty::layout::{HasTyCtxt, HasTypingEnv, LayoutOf, TyAndLayout};
 use rustc_middle::ty::{self, Instance, Ty, TyCtxt};
@@ -25,6 +25,15 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         match *rvalue {
             mir::Rvalue::Use(ref operand) => {
                 let cg_operand = self.codegen_operand(bx, operand);
+                // Crucially, we do *not* use `OperandValue::Ref` for types with
+                // `BackendRepr::Scalar | BackendRepr::ScalarPair`. This ensures we match the MIR
+                // semantics regarding when assignment operators allow overlap of LHS and RHS.
+                if matches!(
+                    cg_operand.layout.backend_repr,
+                    BackendRepr::Scalar(..) | BackendRepr::ScalarPair(..),
+                ) {
+                    debug_assert!(!matches!(cg_operand.val, OperandValue::Ref(..)));
+                }
                 // FIXME: consider not copying constants through stack. (Fixable by codegen'ing
                 // constants into `OperandValue::Ref`; why don’t we do that yet if we don’t?)
                 cg_operand.val.store(bx, dest);
diff --git a/compiler/rustc_middle/src/mir/syntax.rs b/compiler/rustc_middle/src/mir/syntax.rs
index 3b8def67f92d7..d402ea4b04f9c 100644
--- a/compiler/rustc_middle/src/mir/syntax.rs
+++ b/compiler/rustc_middle/src/mir/syntax.rs
@@ -327,9 +327,11 @@ pub enum StatementKind<'tcx> {
     /// interesting for optimizations? Do we want to allow such optimizations?
     ///
     /// **Needs clarification**: We currently require that the LHS place not overlap with any place
-    /// read as part of computation of the RHS for some rvalues (generally those not producing
-    /// primitives). This requirement is under discussion in [#68364]. As a part of this discussion,
-    /// it is also unclear in what order the components are evaluated.
+    /// read as part of computation of the RHS for some rvalues. This requirement is under
+    /// discussion in [#68364]. Specifically, overlap is permitted only for assignments of a type
+    /// with `BackendRepr::Scalar | BackendRepr::ScalarPair` where all the scalar fields are
+    /// [`Scalar::Initialized`][rustc_abi::Scalar::Initialized]. As a part of this discussion, it is
+    /// also unclear in what order the components are evaluated.
     ///
     /// [#68364]: https://github.com/rust-lang/rust/issues/68364
     ///

From edbc0a08fb8bafbb80b4522ae0050244bb21e4f5 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 10 Sep 2025 16:09:28 +0200
Subject: [PATCH 0755/1889] weak memory tests: add more info on where they come
 from

---
 .../tests/pass/0weak_memory_consistency.rs    | 25 +++++++++++--------
 1 file changed, 14 insertions(+), 11 deletions(-)

diff --git a/src/tools/miri/tests/pass/0weak_memory_consistency.rs b/src/tools/miri/tests/pass/0weak_memory_consistency.rs
index e4ed9675de822..16969d9649c94 100644
--- a/src/tools/miri/tests/pass/0weak_memory_consistency.rs
+++ b/src/tools/miri/tests/pass/0weak_memory_consistency.rs
@@ -14,13 +14,6 @@
 // To mitigate this, each test is ran enough times such that the chance
 // of spurious success is very low. These tests never spuriously fail.
 
-// Test cases and their consistent outcomes are from
-// http://svr-pes20-cppmem.cl.cam.ac.uk/cppmem/
-// Based on
-// M. Batty, S. Owens, S. Sarkar, P. Sewell and T. Weber,
-// "Mathematizing C++ concurrency", ACM SIGPLAN Notices, vol. 46, no. 1, pp. 55-66, 2011.
-// Available: https://ss265.host.cs.st-andrews.ac.uk/papers/n3132.pdf.
-
 use std::sync::atomic::Ordering::*;
 use std::sync::atomic::{AtomicBool, AtomicI32, Ordering, fence};
 use std::thread::spawn;
@@ -56,6 +49,7 @@ fn spin_until_bool(loc: &AtomicBool, ord: Ordering, val: bool) -> bool {
     val
 }
 
+/// Test matching https://www.doc.ic.ac.uk/~afd/homepages/papers/pdfs/2017/POPL.pdf, Figure 7
 fn test_corr() {
     let x = static_atomic(0);
     let y = static_atomic(0);
@@ -75,19 +69,25 @@ fn test_corr() {
     let j3 = spawn(move || { //                      |                    |
         spin_until_i32(&y, Acquire, 1); // <---------+                    |
         x.load(Relaxed) // <----------------------------------------------+
-        // The two reads on x are ordered by hb, so they cannot observe values
-        // differently from the modification order. If the first read observed
-        // 2, then the second read must observe 2 as well.
     });
 
     j1.join().unwrap();
     let r2 = j2.join().unwrap();
     let r3 = j3.join().unwrap();
+    // The two reads on x are ordered by hb, so they cannot observe values
+    // differently from the modification order. If the first read observed
+    // 2, then the second read must observe 2 as well.
     if r2 == 2 {
         assert_eq!(r3, 2);
     }
 }
 
+/// This test case is from:
+/// http://svr-pes20-cppmem.cl.cam.ac.uk/cppmem/, "WRC"
+/// Based on
+/// M. Batty, S. Owens, S. Sarkar, P. Sewell and T. Weber,
+/// "Mathematizing C++ concurrency", ACM SIGPLAN Notices, vol. 46, no. 1, pp. 55-66, 2011.
+/// Available: https://www.cl.cam.ac.uk/~pes20/cpp/popl085ap-sewell.pdf.
 fn test_wrc() {
     let x = static_atomic(0);
     let y = static_atomic(0);
@@ -114,6 +114,8 @@ fn test_wrc() {
     assert_eq!(r3, 1);
 }
 
+/// Another test from http://svr-pes20-cppmem.cl.cam.ac.uk/cppmem/:
+/// MP (na_rel+acq_na)
 fn test_message_passing() {
     let mut var = 0u32;
     let ptr = &mut var as *mut u32;
@@ -139,7 +141,8 @@ fn test_message_passing() {
     assert_eq!(r2, 1);
 }
 
-// LB+acq_rel+acq_rel
+/// Another test from http://svr-pes20-cppmem.cl.cam.ac.uk/cppmem/:
+/// LB+acq_rel+acq_rel
 fn test_load_buffering_acq_rel() {
     let x = static_atomic(0);
     let y = static_atomic(0);

From 0e0b254df9b6f7abe4aa0efa8617ac97baa2bea7 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 10 Sep 2025 16:16:49 +0200
Subject: [PATCH 0756/1889] ensure we do not see the inconsistent execution
 from Figure 8

---
 src/tools/miri/tests/pass/0weak_memory_consistency.rs | 3 ++-
 src/tools/miri/tests/pass/weak_memory/weak.rs         | 8 ++++++++
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/tools/miri/tests/pass/0weak_memory_consistency.rs b/src/tools/miri/tests/pass/0weak_memory_consistency.rs
index 16969d9649c94..142080c1372d7 100644
--- a/src/tools/miri/tests/pass/0weak_memory_consistency.rs
+++ b/src/tools/miri/tests/pass/0weak_memory_consistency.rs
@@ -49,7 +49,8 @@ fn spin_until_bool(loc: &AtomicBool, ord: Ordering, val: bool) -> bool {
     val
 }
 
-/// Test matching https://www.doc.ic.ac.uk/~afd/homepages/papers/pdfs/2017/POPL.pdf, Figure 7
+/// Test matching https://www.doc.ic.ac.uk/~afd/homepages/papers/pdfs/2017/POPL.pdf, Figure 7.
+/// (The Figure 8 test is in `weak_memory/weak.rs`.)
 fn test_corr() {
     let x = static_atomic(0);
     let y = static_atomic(0);
diff --git a/src/tools/miri/tests/pass/weak_memory/weak.rs b/src/tools/miri/tests/pass/weak_memory/weak.rs
index 199f83f052860..6794b43bfb37b 100644
--- a/src/tools/miri/tests/pass/weak_memory/weak.rs
+++ b/src/tools/miri/tests/pass/weak_memory/weak.rs
@@ -69,6 +69,9 @@ fn seq_cst() -> bool {
     j2.join().unwrap();
     let r3 = j3.join().unwrap();
 
+    // Even though we force t3 to run last, it can still see the value 1.
+    // And it can *never* see the value 2!
+    assert!(r3 == 1 || r3 == 3);
     r3 == 1
 }
 
@@ -148,4 +151,9 @@ pub fn main() {
     assert_once(|| initialization_write(false));
     assert_once(|| initialization_write(true));
     assert_once(faa_replaced_by_load);
+
+    // Run seq_cst a few more times since it has an assertion we want to ensure holds always.
+    for _ in 0..50 {
+        seq_cst();
+    }
 }

From 21e3111ef90f670b85eebf4a1ed9cc8be2f21061 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 10 Sep 2025 16:31:29 +0200
Subject: [PATCH 0757/1889] refactor weak-mem test to list all expected
 executions

---
 .../tests/pass/0weak_memory_consistency.rs    |   3 +-
 .../tests/pass/0weak_memory_consistency_sc.rs |   3 +-
 src/tools/miri/tests/pass/weak_memory/weak.rs | 211 +++++++++---------
 3 files changed, 114 insertions(+), 103 deletions(-)

diff --git a/src/tools/miri/tests/pass/0weak_memory_consistency.rs b/src/tools/miri/tests/pass/0weak_memory_consistency.rs
index 142080c1372d7..f1d5a56c2b02c 100644
--- a/src/tools/miri/tests/pass/0weak_memory_consistency.rs
+++ b/src/tools/miri/tests/pass/0weak_memory_consistency.rs
@@ -1,6 +1,7 @@
-//@compile-flags: -Zmiri-ignore-leaks -Zmiri-disable-stacked-borrows -Zmiri-disable-validation -Zmiri-provenance-gc=10000
+//@compile-flags: -Zmiri-ignore-leaks -Zmiri-disable-stacked-borrows -Zmiri-disable-validation
 // This test's runtime explodes if the GC interval is set to 1 (which we do in CI), so we
 // override it internally back to the default frequency.
+//@compile-flags: -Zmiri-provenance-gc=10000
 
 // The following tests check whether our weak memory emulation produces
 // any inconsistent execution outcomes
diff --git a/src/tools/miri/tests/pass/0weak_memory_consistency_sc.rs b/src/tools/miri/tests/pass/0weak_memory_consistency_sc.rs
index 937c2a8cf282c..43675a8b5e165 100644
--- a/src/tools/miri/tests/pass/0weak_memory_consistency_sc.rs
+++ b/src/tools/miri/tests/pass/0weak_memory_consistency_sc.rs
@@ -1,6 +1,7 @@
-//@compile-flags: -Zmiri-ignore-leaks -Zmiri-disable-stacked-borrows -Zmiri-disable-validation -Zmiri-provenance-gc=10000
+//@compile-flags: -Zmiri-ignore-leaks -Zmiri-disable-stacked-borrows -Zmiri-disable-validation
 // This test's runtime explodes if the GC interval is set to 1 (which we do in CI), so we
 // override it internally back to the default frequency.
+//@compile-flags: -Zmiri-provenance-gc=10000
 
 // The following tests check whether our weak memory emulation produces
 // any inconsistent execution outcomes
diff --git a/src/tools/miri/tests/pass/weak_memory/weak.rs b/src/tools/miri/tests/pass/weak_memory/weak.rs
index 6794b43bfb37b..f39ef0ed98da9 100644
--- a/src/tools/miri/tests/pass/weak_memory/weak.rs
+++ b/src/tools/miri/tests/pass/weak_memory/weak.rs
@@ -1,9 +1,11 @@
 //@compile-flags: -Zmiri-ignore-leaks -Zmiri-fixed-schedule
+// This test's runtime explodes if the GC interval is set to 1 (which we do in CI), so we
+// override it internally back to the default frequency.
+//@compile-flags: -Zmiri-provenance-gc=10000
+
+// Tests showing weak memory behaviours are exhibited, even with a fixed scheule.
+// We run all tests a number of times and then check that we see the desired list of outcomes.
 
-// 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.
 
@@ -31,129 +33,136 @@ fn spin_until(loc: &AtomicUsize, val: usize) -> usize {
     val
 }
 
-fn relaxed(initial_read: bool) -> bool {
-    let x = static_atomic(0);
-    let j1 = spawn(move || {
-        x.store(1, Relaxed);
-        // Preemption is disabled, so the store above will never be the
-        // latest store visible to another thread.
-        x.store(2, Relaxed);
-    });
+/// Check that the function produces the intended set of outcomes.
+#[track_caller]
+fn check_all_outcomes<T: Eq + std::hash::Hash + std::fmt::Display>(
+    expected: impl IntoIterator<Item = T>,
+    generate: impl Fn() -> T,
+) {
+    use std::collections::HashSet;
+
+    let expected: HashSet<T> = HashSet::from_iter(expected);
+    let mut seen = HashSet::new();
+    // Let's give it N times as many tries as we are expecting values.
+    let tries = expected.len() * 8;
+    for _ in 0..tries {
+        let val = generate();
+        assert!(expected.contains(&val), "got an unexpected value: {val}");
+        seen.insert(val);
+    }
+    // Let's see if we saw them all.
+    for val in expected {
+        if !seen.contains(&val) {
+            panic!("did not get value that should be possible: {val}");
+        }
+    }
+}
 
-    let j2 = spawn(move || x.load(Relaxed));
+fn relaxed() {
+    check_all_outcomes([0, 1, 2], || {
+        let x = static_atomic(0);
+        let j1 = spawn(move || {
+            x.store(1, Relaxed);
+            // Preemption is disabled, so the store above will never be the
+            // latest store visible to another thread.
+            x.store(2, Relaxed);
+        });
 
-    j1.join().unwrap();
-    let r2 = j2.join().unwrap();
+        let j2 = spawn(move || x.load(Relaxed));
 
-    // 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 }
+        j1.join().unwrap();
+        let r2 = j2.join().unwrap();
+
+        // There are three possible values here: 0 (from the initial read), 1 (from the first relaxed
+        // read), and 2 (the last read).
+        r2
+    });
 }
 
 // https://www.doc.ic.ac.uk/~afd/homepages/papers/pdfs/2017/POPL.pdf Figure 8
-fn seq_cst() -> bool {
-    let x = static_atomic(0);
+fn seq_cst() {
+    check_all_outcomes([1, 3], || {
+        let x = static_atomic(0);
 
-    let j1 = spawn(move || {
-        x.store(1, Relaxed);
-    });
+        let j1 = spawn(move || {
+            x.store(1, Relaxed);
+        });
 
-    let j2 = spawn(move || {
-        x.store(2, SeqCst);
-        x.store(3, SeqCst);
-    });
+        let j2 = spawn(move || {
+            x.store(2, SeqCst);
+            x.store(3, SeqCst);
+        });
 
-    let j3 = spawn(move || x.load(SeqCst));
+        let j3 = spawn(move || x.load(SeqCst));
 
-    j1.join().unwrap();
-    j2.join().unwrap();
-    let r3 = j3.join().unwrap();
+        j1.join().unwrap();
+        j2.join().unwrap();
+        let r3 = j3.join().unwrap();
 
-    // Even though we force t3 to run last, it can still see the value 1.
-    // And it can *never* see the value 2!
-    assert!(r3 == 1 || r3 == 3);
-    r3 == 1
+        // Even though we force t3 to run last, it can still see the value 1.
+        // And it can *never* see the value 2!
+        r3
+    });
 }
 
-fn initialization_write(add_fence: bool) -> bool {
-    let x = static_atomic(11);
+fn initialization_write(add_fence: bool) {
+    check_all_outcomes([11, 22], || {
+        let x = static_atomic(11);
 
-    let wait = static_atomic(0);
+        let wait = static_atomic(0);
 
-    let j1 = spawn(move || {
-        x.store(22, Relaxed);
-        // Relaxed is intentional. We want to test if the thread 2 reads the initialisation write
-        // after a relaxed write
-        wait.store(1, Relaxed);
-    });
+        let j1 = spawn(move || {
+            x.store(22, Relaxed);
+            // Relaxed is intentional. We want to test if the thread 2 reads the initialisation write
+            // after a relaxed write
+            wait.store(1, Relaxed);
+        });
 
-    let j2 = spawn(move || {
-        spin_until(wait, 1);
-        if add_fence {
-            fence(AcqRel);
-        }
-        x.load(Relaxed)
-    });
+        let j2 = spawn(move || {
+            spin_until(wait, 1);
+            if add_fence {
+                fence(AcqRel);
+            }
+            x.load(Relaxed)
+        });
 
-    j1.join().unwrap();
-    let r2 = j2.join().unwrap();
+        j1.join().unwrap();
+        let r2 = j2.join().unwrap();
 
-    r2 == 11
+        r2
+    });
 }
 
-fn faa_replaced_by_load() -> bool {
-    // Example from https://github.com/llvm/llvm-project/issues/56450#issuecomment-1183695905
-    #[no_mangle]
-    pub fn rdmw(storing: &AtomicUsize, sync: &AtomicUsize, loading: &AtomicUsize) -> usize {
-        storing.store(1, Relaxed);
-        fence(Release);
-        // sync.fetch_add(0, Relaxed);
-        sync.load(Relaxed);
-        fence(Acquire);
-        loading.load(Relaxed)
-    }
+fn faa_replaced_by_load() {
+    check_all_outcomes([true, false], || {
+        // Example from https://github.com/llvm/llvm-project/issues/56450#issuecomment-1183695905
+        pub fn rdmw(storing: &AtomicUsize, sync: &AtomicUsize, loading: &AtomicUsize) -> usize {
+            storing.store(1, Relaxed);
+            fence(Release);
+            // sync.fetch_add(0, Relaxed);
+            sync.load(Relaxed);
+            fence(Acquire);
+            loading.load(Relaxed)
+        }
 
-    let x = static_atomic(0);
-    let y = static_atomic(0);
-    let z = static_atomic(0);
+        let x = static_atomic(0);
+        let y = static_atomic(0);
+        let z = static_atomic(0);
 
-    // 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
-    let go = static_atomic(0);
+        let t1 = spawn(move || rdmw(y, x, z));
 
-    let t1 = spawn(move || {
-        spin_until(go, 1);
-        rdmw(y, x, z)
-    });
+        let t2 = spawn(move || rdmw(z, x, y));
 
-    let t2 = spawn(move || {
-        spin_until(go, 1);
-        rdmw(z, x, y)
+        let a = t1.join().unwrap();
+        let b = t2.join().unwrap();
+        (a, b) == (0, 0)
     });
-
-    go.store(1, Relaxed);
-
-    let a = t1.join().unwrap();
-    let b = t2.join().unwrap();
-    (a, b) == (0, 0)
-}
-
-/// Asserts that the function returns true at least once in 100 runs
-#[track_caller]
-fn assert_once(f: fn() -> bool) {
-    assert!(std::iter::repeat_with(|| f()).take(100).any(|x| x));
 }
 
 pub fn main() {
-    assert_once(|| relaxed(false));
-    assert_once(|| relaxed(true));
-    assert_once(seq_cst);
-    assert_once(|| initialization_write(false));
-    assert_once(|| initialization_write(true));
-    assert_once(faa_replaced_by_load);
-
-    // Run seq_cst a few more times since it has an assertion we want to ensure holds always.
-    for _ in 0..50 {
-        seq_cst();
-    }
+    relaxed();
+    seq_cst();
+    initialization_write(false);
+    initialization_write(true);
+    faa_replaced_by_load();
 }

From 614dab3ed2e61acd32a572c37e5480538b547da8 Mon Sep 17 00:00:00 2001
From: WANG Rui <wangrui@loongson.cn>
Date: Wed, 10 Sep 2025 23:02:49 +0800
Subject: [PATCH 0758/1889] loongarch: Align intrinsic signatures with LLVM

---
 .../crates/core_arch/src/loongarch32/mod.rs     |  7 ++++---
 .../crates/core_arch/src/loongarch64/mod.rs     | 17 ++++++++++-------
 .../core_arch/src/loongarch_shared/mod.rs       | 12 ++++++------
 3 files changed, 20 insertions(+), 16 deletions(-)

diff --git a/library/stdarch/crates/core_arch/src/loongarch32/mod.rs b/library/stdarch/crates/core_arch/src/loongarch32/mod.rs
index fb05450373c28..4e3f3d27182e4 100644
--- a/library/stdarch/crates/core_arch/src/loongarch32/mod.rs
+++ b/library/stdarch/crates/core_arch/src/loongarch32/mod.rs
@@ -17,9 +17,10 @@ unsafe extern "unadjusted" {
 /// Generates the cache operation instruction
 #[inline]
 #[unstable(feature = "stdarch_loongarch", issue = "117427")]
-pub unsafe fn cacop<const IMM12: i32>(a: i32, b: i32) {
-    static_assert_simm_bits!(IMM12, 12);
-    __cacop(a, b, IMM12);
+pub unsafe fn cacop<const IMM5: i32, const IMM_S12: i32>(b: i32) {
+    static_assert_uimm_bits!(IMM5, 5);
+    static_assert_simm_bits!(IMM_S12, 12);
+    __cacop(IMM5, b, IMM_S12);
 }
 
 /// Reads the CSR
diff --git a/library/stdarch/crates/core_arch/src/loongarch64/mod.rs b/library/stdarch/crates/core_arch/src/loongarch64/mod.rs
index e8249805eae26..ab968aff20bbe 100644
--- a/library/stdarch/crates/core_arch/src/loongarch64/mod.rs
+++ b/library/stdarch/crates/core_arch/src/loongarch64/mod.rs
@@ -64,9 +64,10 @@ pub fn crcc_w_d_w(a: i64, b: i32) -> i32 {
 /// Generates the cache operation instruction
 #[inline]
 #[unstable(feature = "stdarch_loongarch", issue = "117427")]
-pub unsafe fn cacop<const IMM12: i64>(a: i64, b: i64) {
-    static_assert_simm_bits!(IMM12, 12);
-    __cacop(a, b, IMM12);
+pub unsafe fn cacop<const IMM5: i64, const IMM_S12: i64>(b: i64) {
+    static_assert_uimm_bits!(IMM5, 5);
+    static_assert_simm_bits!(IMM_S12, 12);
+    __cacop(IMM5, b, IMM_S12);
 }
 
 /// Reads the CSR
@@ -125,14 +126,16 @@ pub unsafe fn asrtgt(a: i64, b: i64) {
 #[inline]
 #[rustc_legacy_const_generics(1)]
 #[unstable(feature = "stdarch_loongarch", issue = "117427")]
-pub unsafe fn lddir<const B: i64>(a: i64) -> i64 {
-    __lddir(a, B)
+pub unsafe fn lddir<const IMM8: i64>(a: i64) -> i64 {
+    static_assert_uimm_bits!(IMM8, 8);
+    __lddir(a, IMM8)
 }
 
 /// Loads the page table entry
 #[inline]
 #[rustc_legacy_const_generics(1)]
 #[unstable(feature = "stdarch_loongarch", issue = "117427")]
-pub unsafe fn ldpte<const B: i64>(a: i64) {
-    __ldpte(a, B)
+pub unsafe fn ldpte<const IMM8: i64>(a: i64) {
+    static_assert_uimm_bits!(IMM8, 8);
+    __ldpte(a, IMM8)
 }
diff --git a/library/stdarch/crates/core_arch/src/loongarch_shared/mod.rs b/library/stdarch/crates/core_arch/src/loongarch_shared/mod.rs
index 710b926f8df4f..8991fe857682b 100644
--- a/library/stdarch/crates/core_arch/src/loongarch_shared/mod.rs
+++ b/library/stdarch/crates/core_arch/src/loongarch_shared/mod.rs
@@ -131,17 +131,17 @@ pub fn ibar<const IMM15: i32>() {
 /// Moves data from a GPR to the FCSR
 #[inline]
 #[unstable(feature = "stdarch_loongarch", issue = "117427")]
-pub unsafe fn movgr2fcsr<const IMM5: i32>(a: i32) {
-    static_assert_uimm_bits!(IMM5, 5);
-    __movgr2fcsr(IMM5, a);
+pub unsafe fn movgr2fcsr<const IMM2: i32>(a: i32) {
+    static_assert_uimm_bits!(IMM2, 2);
+    __movgr2fcsr(IMM2, a);
 }
 
 /// Moves data from a FCSR to the GPR
 #[inline]
 #[unstable(feature = "stdarch_loongarch", issue = "117427")]
-pub fn movfcsr2gr<const IMM5: i32>() -> i32 {
-    static_assert_uimm_bits!(IMM5, 5);
-    unsafe { __movfcsr2gr(IMM5) }
+pub fn movfcsr2gr<const IMM2: i32>() -> i32 {
+    static_assert_uimm_bits!(IMM2, 2);
+    unsafe { __movfcsr2gr(IMM2) }
 }
 
 /// Reads the 8-bit IO-CSR

From 655b8474348a087acbcec498d48fd705160ee080 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 10 Sep 2025 16:35:07 +0200
Subject: [PATCH 0759/1889] also use nicer check_all_outcomes in float_nan

---
 src/tools/miri/tests/pass/float_nan.rs | 319 +++++++++++--------------
 1 file changed, 142 insertions(+), 177 deletions(-)

diff --git a/src/tools/miri/tests/pass/float_nan.rs b/src/tools/miri/tests/pass/float_nan.rs
index 3ffdb6868ac0a..f0a2b8e9ee060 100644
--- a/src/tools/miri/tests/pass/float_nan.rs
+++ b/src/tools/miri/tests/pass/float_nan.rs
@@ -1,7 +1,8 @@
+// This test's runtime explodes if the GC interval is set to 1 (which we do in CI), so we
+// override it internally back to the default frequency.
+//@compile-flags: -Zmiri-provenance-gc=10000
 #![feature(float_gamma, portable_simd, core_intrinsics)]
-use std::collections::HashSet;
 use std::fmt;
-use std::hash::Hash;
 use std::hint::black_box;
 
 fn ldexp(a: f64, b: i32) -> f64 {
@@ -25,11 +26,18 @@ enum NaNKind {
 }
 use NaNKind::*;
 
+/// Check that the function produces the intended set of outcomes.
 #[track_caller]
-fn check_all_outcomes<T: Eq + Hash + fmt::Display>(expected: HashSet<T>, generate: impl Fn() -> T) {
+fn check_all_outcomes<T: Eq + std::hash::Hash + fmt::Display>(
+    expected: impl IntoIterator<Item = T>,
+    generate: impl Fn() -> T,
+) {
+    use std::collections::HashSet;
+
+    let expected: HashSet<T> = HashSet::from_iter(expected);
     let mut seen = HashSet::new();
-    // Let's give it sixteen times as many tries as we are expecting values.
-    let tries = expected.len() * 16;
+    // Let's give it N times as many tries as we are expecting values.
+    let tries = expected.len() * 12;
     for _ in 0..tries {
         let val = generate();
         assert!(expected.contains(&val), "got an unexpected value: {val}");
@@ -193,51 +201,50 @@ impl F64 {
 
 fn test_f32() {
     // Freshly generated NaNs can have either sign.
-    check_all_outcomes(
-        HashSet::from_iter([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)]),
-        || F32::from(0.0 / black_box(0.0)),
-    );
+    check_all_outcomes([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)], || {
+        F32::from(0.0 / black_box(0.0))
+    });
     // When there are NaN inputs, their payload can be propagated, with any sign.
     let all1_payload = u32_ones(22);
     let all1 = F32::nan(Pos, Quiet, all1_payload).as_f32();
     check_all_outcomes(
-        HashSet::from_iter([
+        [
             F32::nan(Pos, Quiet, 0),
             F32::nan(Neg, Quiet, 0),
             F32::nan(Pos, Quiet, all1_payload),
             F32::nan(Neg, Quiet, all1_payload),
-        ]),
+        ],
         || F32::from(0.0 + all1),
     );
     // When there are two NaN inputs, the output can be either one, or the preferred NaN.
     let just1 = F32::nan(Neg, Quiet, 1).as_f32();
     check_all_outcomes(
-        HashSet::from_iter([
+        [
             F32::nan(Pos, Quiet, 0),
             F32::nan(Neg, Quiet, 0),
             F32::nan(Pos, Quiet, 1),
             F32::nan(Neg, Quiet, 1),
             F32::nan(Pos, Quiet, all1_payload),
             F32::nan(Neg, Quiet, all1_payload),
-        ]),
+        ],
         || F32::from(just1 - all1),
     );
     // When there are *signaling* NaN inputs, they might be quieted or not.
     let all1_snan = F32::nan(Pos, Signaling, all1_payload).as_f32();
     check_all_outcomes(
-        HashSet::from_iter([
+        [
             F32::nan(Pos, Quiet, 0),
             F32::nan(Neg, Quiet, 0),
             F32::nan(Pos, Quiet, all1_payload),
             F32::nan(Neg, Quiet, all1_payload),
             F32::nan(Pos, Signaling, all1_payload),
             F32::nan(Neg, Signaling, all1_payload),
-        ]),
+        ],
         || F32::from(0.0 * all1_snan),
     );
     // Mix signaling and non-signaling NaN.
     check_all_outcomes(
-        HashSet::from_iter([
+        [
             F32::nan(Pos, Quiet, 0),
             F32::nan(Neg, Quiet, 0),
             F32::nan(Pos, Quiet, 1),
@@ -246,35 +253,26 @@ fn test_f32() {
             F32::nan(Neg, Quiet, all1_payload),
             F32::nan(Pos, Signaling, all1_payload),
             F32::nan(Neg, Signaling, all1_payload),
-        ]),
+        ],
         || F32::from(just1 % all1_snan),
     );
 
     // Unary `-` must preserve payloads exactly.
-    check_all_outcomes(HashSet::from_iter([F32::nan(Neg, Quiet, all1_payload)]), || {
-        F32::from(-all1)
-    });
-    check_all_outcomes(HashSet::from_iter([F32::nan(Neg, Signaling, all1_payload)]), || {
-        F32::from(-all1_snan)
-    });
+    check_all_outcomes([F32::nan(Neg, Quiet, all1_payload)], || F32::from(-all1));
+    check_all_outcomes([F32::nan(Neg, Signaling, all1_payload)], || F32::from(-all1_snan));
 
     // Intrinsics
     let nan = F32::nan(Neg, Quiet, 0).as_f32();
     let snan = F32::nan(Neg, Signaling, 1).as_f32();
+    check_all_outcomes([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)], || {
+        F32::from(f32::min(nan, nan))
+    });
+    check_all_outcomes([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)], || {
+        F32::from(nan.floor())
+    });
+    check_all_outcomes([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)], || F32::from(nan.sin()));
     check_all_outcomes(
-        HashSet::from_iter([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)]),
-        || F32::from(f32::min(nan, nan)),
-    );
-    check_all_outcomes(
-        HashSet::from_iter([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)]),
-        || F32::from(nan.floor()),
-    );
-    check_all_outcomes(
-        HashSet::from_iter([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)]),
-        || F32::from(nan.sin()),
-    );
-    check_all_outcomes(
-        HashSet::from_iter([
+        [
             F32::nan(Pos, Quiet, 0),
             F32::nan(Neg, Quiet, 0),
             F32::nan(Pos, Quiet, 1),
@@ -285,37 +283,32 @@ fn test_f32() {
             F32::nan(Neg, Quiet, all1_payload),
             F32::nan(Pos, Signaling, all1_payload),
             F32::nan(Neg, Signaling, all1_payload),
-        ]),
+        ],
         || F32::from(just1.mul_add(F32::nan(Neg, Quiet, 2).as_f32(), all1_snan)),
     );
+    check_all_outcomes([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)], || {
+        F32::from(nan.powf(nan))
+    });
     check_all_outcomes(
-        HashSet::from_iter([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)]),
-        || F32::from(nan.powf(nan)),
-    );
-    check_all_outcomes(
-        HashSet::from_iter([1.0f32.into()]),
+        [1.0f32.into()],
         || F32::from(1.0f32.powf(nan)), // special `pow` rule
     );
-    check_all_outcomes(
-        HashSet::from_iter([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)]),
-        || F32::from(nan.powi(1)),
-    );
+    check_all_outcomes([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)], || {
+        F32::from(nan.powi(1))
+    });
 
     // libm functions
+    check_all_outcomes([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)], || {
+        F32::from(nan.sinh())
+    });
+    check_all_outcomes([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)], || {
+        F32::from(nan.atan2(nan))
+    });
+    check_all_outcomes([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)], || {
+        F32::from(nan.ln_gamma().0)
+    });
     check_all_outcomes(
-        HashSet::from_iter([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)]),
-        || F32::from(nan.sinh()),
-    );
-    check_all_outcomes(
-        HashSet::from_iter([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)]),
-        || F32::from(nan.atan2(nan)),
-    );
-    check_all_outcomes(
-        HashSet::from_iter([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)]),
-        || F32::from(nan.ln_gamma().0),
-    );
-    check_all_outcomes(
-        HashSet::from_iter([
+        [
             F32::from(1.0),
             F32::nan(Pos, Quiet, 0),
             F32::nan(Neg, Quiet, 0),
@@ -323,58 +316,57 @@ fn test_f32() {
             F32::nan(Neg, Quiet, 1),
             F32::nan(Pos, Signaling, 1),
             F32::nan(Neg, Signaling, 1),
-        ]),
+        ],
         || F32::from(snan.powf(0.0)),
     );
 }
 
 fn test_f64() {
     // Freshly generated NaNs can have either sign.
-    check_all_outcomes(
-        HashSet::from_iter([F64::nan(Pos, Quiet, 0), F64::nan(Neg, Quiet, 0)]),
-        || F64::from(0.0 / black_box(0.0)),
-    );
+    check_all_outcomes([F64::nan(Pos, Quiet, 0), F64::nan(Neg, Quiet, 0)], || {
+        F64::from(0.0 / black_box(0.0))
+    });
     // When there are NaN inputs, their payload can be propagated, with any sign.
     let all1_payload = u64_ones(51);
     let all1 = F64::nan(Pos, Quiet, all1_payload).as_f64();
     check_all_outcomes(
-        HashSet::from_iter([
+        [
             F64::nan(Pos, Quiet, 0),
             F64::nan(Neg, Quiet, 0),
             F64::nan(Pos, Quiet, all1_payload),
             F64::nan(Neg, Quiet, all1_payload),
-        ]),
+        ],
         || F64::from(0.0 + all1),
     );
     // When there are two NaN inputs, the output can be either one, or the preferred NaN.
     let just1 = F64::nan(Neg, Quiet, 1).as_f64();
     check_all_outcomes(
-        HashSet::from_iter([
+        [
             F64::nan(Pos, Quiet, 0),
             F64::nan(Neg, Quiet, 0),
             F64::nan(Pos, Quiet, 1),
             F64::nan(Neg, Quiet, 1),
             F64::nan(Pos, Quiet, all1_payload),
             F64::nan(Neg, Quiet, all1_payload),
-        ]),
+        ],
         || F64::from(just1 - all1),
     );
     // When there are *signaling* NaN inputs, they might be quieted or not.
     let all1_snan = F64::nan(Pos, Signaling, all1_payload).as_f64();
     check_all_outcomes(
-        HashSet::from_iter([
+        [
             F64::nan(Pos, Quiet, 0),
             F64::nan(Neg, Quiet, 0),
             F64::nan(Pos, Quiet, all1_payload),
             F64::nan(Neg, Quiet, all1_payload),
             F64::nan(Pos, Signaling, all1_payload),
             F64::nan(Neg, Signaling, all1_payload),
-        ]),
+        ],
         || F64::from(0.0 * all1_snan),
     );
     // Mix signaling and non-signaling NaN.
     check_all_outcomes(
-        HashSet::from_iter([
+        [
             F64::nan(Pos, Quiet, 0),
             F64::nan(Neg, Quiet, 0),
             F64::nan(Pos, Quiet, 1),
@@ -383,27 +375,22 @@ fn test_f64() {
             F64::nan(Neg, Quiet, all1_payload),
             F64::nan(Pos, Signaling, all1_payload),
             F64::nan(Neg, Signaling, all1_payload),
-        ]),
+        ],
         || F64::from(just1 % all1_snan),
     );
 
     // Intrinsics
     let nan = F64::nan(Neg, Quiet, 0).as_f64();
     let snan = F64::nan(Neg, Signaling, 1).as_f64();
+    check_all_outcomes([F64::nan(Pos, Quiet, 0), F64::nan(Neg, Quiet, 0)], || {
+        F64::from(f64::min(nan, nan))
+    });
+    check_all_outcomes([F64::nan(Pos, Quiet, 0), F64::nan(Neg, Quiet, 0)], || {
+        F64::from(nan.floor())
+    });
+    check_all_outcomes([F64::nan(Pos, Quiet, 0), F64::nan(Neg, Quiet, 0)], || F64::from(nan.sin()));
     check_all_outcomes(
-        HashSet::from_iter([F64::nan(Pos, Quiet, 0), F64::nan(Neg, Quiet, 0)]),
-        || F64::from(f64::min(nan, nan)),
-    );
-    check_all_outcomes(
-        HashSet::from_iter([F64::nan(Pos, Quiet, 0), F64::nan(Neg, Quiet, 0)]),
-        || F64::from(nan.floor()),
-    );
-    check_all_outcomes(
-        HashSet::from_iter([F64::nan(Pos, Quiet, 0), F64::nan(Neg, Quiet, 0)]),
-        || F64::from(nan.sin()),
-    );
-    check_all_outcomes(
-        HashSet::from_iter([
+        [
             F64::nan(Pos, Quiet, 0),
             F64::nan(Neg, Quiet, 0),
             F64::nan(Pos, Quiet, 1),
@@ -414,41 +401,35 @@ fn test_f64() {
             F64::nan(Neg, Quiet, all1_payload),
             F64::nan(Pos, Signaling, all1_payload),
             F64::nan(Neg, Signaling, all1_payload),
-        ]),
+        ],
         || F64::from(just1.mul_add(F64::nan(Neg, Quiet, 2).as_f64(), all1_snan)),
     );
+    check_all_outcomes([F64::nan(Pos, Quiet, 0), F64::nan(Neg, Quiet, 0)], || {
+        F64::from(nan.powf(nan))
+    });
     check_all_outcomes(
-        HashSet::from_iter([F64::nan(Pos, Quiet, 0), F64::nan(Neg, Quiet, 0)]),
-        || F64::from(nan.powf(nan)),
-    );
-    check_all_outcomes(
-        HashSet::from_iter([1.0f64.into()]),
+        [1.0f64.into()],
         || F64::from(1.0f64.powf(nan)), // special `pow` rule
     );
-    check_all_outcomes(
-        HashSet::from_iter([F64::nan(Pos, Quiet, 0), F64::nan(Neg, Quiet, 0)]),
-        || F64::from(nan.powi(1)),
-    );
+    check_all_outcomes([F64::nan(Pos, Quiet, 0), F64::nan(Neg, Quiet, 0)], || {
+        F64::from(nan.powi(1))
+    });
 
     // libm functions
+    check_all_outcomes([F64::nan(Pos, Quiet, 0), F64::nan(Neg, Quiet, 0)], || {
+        F64::from(nan.sinh())
+    });
+    check_all_outcomes([F64::nan(Pos, Quiet, 0), F64::nan(Neg, Quiet, 0)], || {
+        F64::from(nan.atan2(nan))
+    });
+    check_all_outcomes([F64::nan(Pos, Quiet, 0), F64::nan(Neg, Quiet, 0)], || {
+        F64::from(ldexp(nan, 1))
+    });
+    check_all_outcomes([F64::nan(Pos, Quiet, 0), F64::nan(Neg, Quiet, 0)], || {
+        F64::from(nan.ln_gamma().0)
+    });
     check_all_outcomes(
-        HashSet::from_iter([F64::nan(Pos, Quiet, 0), F64::nan(Neg, Quiet, 0)]),
-        || F64::from(nan.sinh()),
-    );
-    check_all_outcomes(
-        HashSet::from_iter([F64::nan(Pos, Quiet, 0), F64::nan(Neg, Quiet, 0)]),
-        || F64::from(nan.atan2(nan)),
-    );
-    check_all_outcomes(
-        HashSet::from_iter([F64::nan(Pos, Quiet, 0), F64::nan(Neg, Quiet, 0)]),
-        || F64::from(ldexp(nan, 1)),
-    );
-    check_all_outcomes(
-        HashSet::from_iter([F64::nan(Pos, Quiet, 0), F64::nan(Neg, Quiet, 0)]),
-        || F64::from(nan.ln_gamma().0),
-    );
-    check_all_outcomes(
-        HashSet::from_iter([
+        [
             F64::from(1.0),
             F64::nan(Pos, Quiet, 0),
             F64::nan(Neg, Quiet, 0),
@@ -456,7 +437,7 @@ fn test_f64() {
             F64::nan(Neg, Quiet, 1),
             F64::nan(Pos, Signaling, 1),
             F64::nan(Neg, Signaling, 1),
-        ]),
+        ],
         || F64::from(snan.powf(0.0)),
     );
 }
@@ -467,82 +448,79 @@ fn test_casts() {
     let left1_payload_64 = (all1_payload_32 as u64) << (51 - 22);
 
     // 64-to-32
-    check_all_outcomes(
-        HashSet::from_iter([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)]),
-        || F32::from(F64::nan(Pos, Quiet, 0).as_f64() as f32),
-    );
+    check_all_outcomes([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)], || {
+        F32::from(F64::nan(Pos, Quiet, 0).as_f64() as f32)
+    });
     // The preferred payload is always a possibility.
     check_all_outcomes(
-        HashSet::from_iter([
+        [
             F32::nan(Pos, Quiet, 0),
             F32::nan(Neg, Quiet, 0),
             F32::nan(Pos, Quiet, all1_payload_32),
             F32::nan(Neg, Quiet, all1_payload_32),
-        ]),
+        ],
         || F32::from(F64::nan(Pos, Quiet, all1_payload_64).as_f64() as f32),
     );
     // If the input is signaling, then the output *may* also be signaling.
     check_all_outcomes(
-        HashSet::from_iter([
+        [
             F32::nan(Pos, Quiet, 0),
             F32::nan(Neg, Quiet, 0),
             F32::nan(Pos, Quiet, all1_payload_32),
             F32::nan(Neg, Quiet, all1_payload_32),
             F32::nan(Pos, Signaling, all1_payload_32),
             F32::nan(Neg, Signaling, all1_payload_32),
-        ]),
+        ],
         || F32::from(F64::nan(Pos, Signaling, all1_payload_64).as_f64() as f32),
     );
     // Check that the low bits are gone (not the high bits).
+    check_all_outcomes([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)], || {
+        F32::from(F64::nan(Pos, Quiet, 1).as_f64() as f32)
+    });
     check_all_outcomes(
-        HashSet::from_iter([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)]),
-        || F32::from(F64::nan(Pos, Quiet, 1).as_f64() as f32),
-    );
-    check_all_outcomes(
-        HashSet::from_iter([
+        [
             F32::nan(Pos, Quiet, 0),
             F32::nan(Neg, Quiet, 0),
             F32::nan(Pos, Quiet, 1),
             F32::nan(Neg, Quiet, 1),
-        ]),
+        ],
         || F32::from(F64::nan(Pos, Quiet, 1 << (51 - 22)).as_f64() as f32),
     );
     check_all_outcomes(
-        HashSet::from_iter([
+        [
             F32::nan(Pos, Quiet, 0),
             F32::nan(Neg, Quiet, 0),
             // The `1` payload becomes `0`, and the `0` payload cannot be signaling,
             // so these are the only options.
-        ]),
+        ],
         || F32::from(F64::nan(Pos, Signaling, 1).as_f64() as f32),
     );
 
     // 32-to-64
-    check_all_outcomes(
-        HashSet::from_iter([F64::nan(Pos, Quiet, 0), F64::nan(Neg, Quiet, 0)]),
-        || F64::from(F32::nan(Pos, Quiet, 0).as_f32() as f64),
-    );
+    check_all_outcomes([F64::nan(Pos, Quiet, 0), F64::nan(Neg, Quiet, 0)], || {
+        F64::from(F32::nan(Pos, Quiet, 0).as_f32() as f64)
+    });
     // The preferred payload is always a possibility.
     // Also checks that 0s are added on the right.
     check_all_outcomes(
-        HashSet::from_iter([
+        [
             F64::nan(Pos, Quiet, 0),
             F64::nan(Neg, Quiet, 0),
             F64::nan(Pos, Quiet, left1_payload_64),
             F64::nan(Neg, Quiet, left1_payload_64),
-        ]),
+        ],
         || F64::from(F32::nan(Pos, Quiet, all1_payload_32).as_f32() as f64),
     );
     // If the input is signaling, then the output *may* also be signaling.
     check_all_outcomes(
-        HashSet::from_iter([
+        [
             F64::nan(Pos, Quiet, 0),
             F64::nan(Neg, Quiet, 0),
             F64::nan(Pos, Quiet, left1_payload_64),
             F64::nan(Neg, Quiet, left1_payload_64),
             F64::nan(Pos, Signaling, left1_payload_64),
             F64::nan(Neg, Signaling, left1_payload_64),
-        ]),
+        ],
         || F64::from(F32::nan(Pos, Signaling, all1_payload_32).as_f32() as f64),
     );
 }
@@ -552,48 +530,35 @@ fn test_simd() {
     use std::simd::*;
 
     let nan = F32::nan(Neg, Quiet, 0).as_f32();
-    check_all_outcomes(
-        HashSet::from_iter([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)]),
-        || F32::from(unsafe { simd_div(f32x4::splat(0.0), f32x4::splat(0.0)) }[0]),
-    );
-    check_all_outcomes(
-        HashSet::from_iter([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)]),
-        || F32::from(unsafe { simd_fmin(f32x4::splat(nan), f32x4::splat(nan)) }[0]),
-    );
-    check_all_outcomes(
-        HashSet::from_iter([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)]),
-        || F32::from(unsafe { simd_fmax(f32x4::splat(nan), f32x4::splat(nan)) }[0]),
-    );
-    check_all_outcomes(
-        HashSet::from_iter([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)]),
-        || {
-            F32::from(
-                unsafe { simd_fma(f32x4::splat(nan), f32x4::splat(nan), f32x4::splat(nan)) }[0],
-            )
-        },
-    );
-    check_all_outcomes(
-        HashSet::from_iter([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)]),
-        || F32::from(unsafe { simd_reduce_add_ordered::<_, f32>(f32x4::splat(nan), nan) }),
-    );
-    check_all_outcomes(
-        HashSet::from_iter([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)]),
-        || F32::from(unsafe { simd_reduce_max::<_, f32>(f32x4::splat(nan)) }),
-    );
-    check_all_outcomes(
-        HashSet::from_iter([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)]),
-        || F32::from(unsafe { simd_fsqrt(f32x4::splat(nan)) }[0]),
-    );
-    check_all_outcomes(
-        HashSet::from_iter([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)]),
-        || F32::from(unsafe { simd_ceil(f32x4::splat(nan)) }[0]),
-    );
+    check_all_outcomes([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)], || {
+        F32::from(unsafe { simd_div(f32x4::splat(0.0), f32x4::splat(0.0)) }[0])
+    });
+    check_all_outcomes([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)], || {
+        F32::from(unsafe { simd_fmin(f32x4::splat(nan), f32x4::splat(nan)) }[0])
+    });
+    check_all_outcomes([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)], || {
+        F32::from(unsafe { simd_fmax(f32x4::splat(nan), f32x4::splat(nan)) }[0])
+    });
+    check_all_outcomes([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)], || {
+        F32::from(unsafe { simd_fma(f32x4::splat(nan), f32x4::splat(nan), f32x4::splat(nan)) }[0])
+    });
+    check_all_outcomes([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)], || {
+        F32::from(unsafe { simd_reduce_add_ordered::<_, f32>(f32x4::splat(nan), nan) })
+    });
+    check_all_outcomes([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)], || {
+        F32::from(unsafe { simd_reduce_max::<_, f32>(f32x4::splat(nan)) })
+    });
+    check_all_outcomes([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)], || {
+        F32::from(unsafe { simd_fsqrt(f32x4::splat(nan)) }[0])
+    });
+    check_all_outcomes([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)], || {
+        F32::from(unsafe { simd_ceil(f32x4::splat(nan)) }[0])
+    });
 
     // Casts
-    check_all_outcomes(
-        HashSet::from_iter([F64::nan(Pos, Quiet, 0), F64::nan(Neg, Quiet, 0)]),
-        || F64::from(unsafe { simd_cast::<f32x4, f64x4>(f32x4::splat(nan)) }[0]),
-    );
+    check_all_outcomes([F64::nan(Pos, Quiet, 0), F64::nan(Neg, Quiet, 0)], || {
+        F64::from(unsafe { simd_cast::<f32x4, f64x4>(f32x4::splat(nan)) }[0])
+    });
 }
 
 fn main() {

From 827a6541e6a9e02fee35f1cc94f61e3ded4c258f Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 10 Sep 2025 16:40:48 +0200
Subject: [PATCH 0760/1889] move all weak memory tests into their folder

---
 .../consistency.rs}                                             | 2 +-
 .../consistency_sc.rs}                                          | 2 +-
 .../miri/tests/pass/{weak_memory => 0weak_memory}/extra_cpp.rs  | 0
 src/tools/miri/tests/pass/{weak_memory => 0weak_memory}/weak.rs | 0
 4 files changed, 2 insertions(+), 2 deletions(-)
 rename src/tools/miri/tests/pass/{0weak_memory_consistency.rs => 0weak_memory/consistency.rs} (99%)
 rename src/tools/miri/tests/pass/{0weak_memory_consistency_sc.rs => 0weak_memory/consistency_sc.rs} (99%)
 rename src/tools/miri/tests/pass/{weak_memory => 0weak_memory}/extra_cpp.rs (100%)
 rename src/tools/miri/tests/pass/{weak_memory => 0weak_memory}/weak.rs (100%)

diff --git a/src/tools/miri/tests/pass/0weak_memory_consistency.rs b/src/tools/miri/tests/pass/0weak_memory/consistency.rs
similarity index 99%
rename from src/tools/miri/tests/pass/0weak_memory_consistency.rs
rename to src/tools/miri/tests/pass/0weak_memory/consistency.rs
index f1d5a56c2b02c..16a38ebd9d4da 100644
--- a/src/tools/miri/tests/pass/0weak_memory_consistency.rs
+++ b/src/tools/miri/tests/pass/0weak_memory/consistency.rs
@@ -51,7 +51,7 @@ fn spin_until_bool(loc: &AtomicBool, ord: Ordering, val: bool) -> bool {
 }
 
 /// Test matching https://www.doc.ic.ac.uk/~afd/homepages/papers/pdfs/2017/POPL.pdf, Figure 7.
-/// (The Figure 8 test is in `weak_memory/weak.rs`.)
+/// (The Figure 8 test is in `weak.rs`.)
 fn test_corr() {
     let x = static_atomic(0);
     let y = static_atomic(0);
diff --git a/src/tools/miri/tests/pass/0weak_memory_consistency_sc.rs b/src/tools/miri/tests/pass/0weak_memory/consistency_sc.rs
similarity index 99%
rename from src/tools/miri/tests/pass/0weak_memory_consistency_sc.rs
rename to src/tools/miri/tests/pass/0weak_memory/consistency_sc.rs
index 43675a8b5e165..cb8535b8ad74b 100644
--- a/src/tools/miri/tests/pass/0weak_memory_consistency_sc.rs
+++ b/src/tools/miri/tests/pass/0weak_memory/consistency_sc.rs
@@ -349,7 +349,7 @@ fn test_sc_relaxed() {
 }
 
 pub fn main() {
-    for _ in 0..50 {
+    for _ in 0..32 {
         test_sc_store_buffering();
         test_iriw_sc_rlx();
         test_cpp20_sc_fence_fix();
diff --git a/src/tools/miri/tests/pass/weak_memory/extra_cpp.rs b/src/tools/miri/tests/pass/0weak_memory/extra_cpp.rs
similarity index 100%
rename from src/tools/miri/tests/pass/weak_memory/extra_cpp.rs
rename to src/tools/miri/tests/pass/0weak_memory/extra_cpp.rs
diff --git a/src/tools/miri/tests/pass/weak_memory/weak.rs b/src/tools/miri/tests/pass/0weak_memory/weak.rs
similarity index 100%
rename from src/tools/miri/tests/pass/weak_memory/weak.rs
rename to src/tools/miri/tests/pass/0weak_memory/weak.rs

From cb819729d0d2d3f6f74b05168e17c34ca7f626b0 Mon Sep 17 00:00:00 2001
From: clubby789 <jamie@hill-daniel.co.uk>
Date: Wed, 10 Sep 2025 16:56:36 +0100
Subject: [PATCH 0761/1889] tidy: Introduce `WorkspaceInfo` struct for deps
 information

---
 src/tools/tidy/src/deps.rs    | 97 ++++++++++++++++++++++++-----------
 src/tools/tidy/src/extdeps.rs | 12 +++--
 2 files changed, 73 insertions(+), 36 deletions(-)

diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs
index 60347b2ea6456..08c0d3ca78653 100644
--- a/src/tools/tidy/src/deps.rs
+++ b/src/tools/tidy/src/deps.rs
@@ -48,39 +48,74 @@ const LICENSES: &[&str] = &[
 
 type ExceptionList = &'static [(&'static str, &'static str)];
 
+pub(crate) struct WorkspaceInfo<'a> {
+    /// Path to the directory containing the workspace root Cargo.toml file.
+    pub(crate) path: &'a str,
+    /// The list of license exceptions.
+    pub(crate) exceptions: ExceptionList,
+    /// Optionally:
+    /// * A list of crates for which dependencies need to be explicitly allowed.
+    /// * The list of allowed dependencies.
+    pub(crate) crates_and_deps: Option<(&'a [&'a str], &'a [&'a str])>,
+    /// Submodules required for the workspace
+    pub(crate) submodules: &'a [&'a str],
+}
+
+impl<'a> WorkspaceInfo<'a> {
+    const fn new(
+        path: &'a str,
+        exceptions: ExceptionList,
+        crates_and_deps: Option<(&'a [&str], &'a [&str])>,
+        submodules: &'a [&str],
+    ) -> Self {
+        Self { path, exceptions, crates_and_deps, submodules }
+    }
+}
+
 /// The workspaces to check for licensing and optionally permitted dependencies.
-///
-/// Each entry consists of a tuple with the following elements:
-///
-/// * The path to the workspace root Cargo.toml file.
-/// * The list of license exceptions.
-/// * Optionally a tuple of:
-///     * A list of crates for which dependencies need to be explicitly allowed.
-///     * The list of allowed dependencies.
-/// * Submodules required for the workspace.
 // FIXME auto detect all cargo workspaces
-pub(crate) const WORKSPACES: &[(&str, ExceptionList, Option<(&[&str], &[&str])>, &[&str])] = &[
+pub(crate) const WORKSPACES: &[WorkspaceInfo<'static>] = &[
     // The root workspace has to be first for check_rustfix to work.
-    (".", EXCEPTIONS, Some((&["rustc-main"], PERMITTED_RUSTC_DEPENDENCIES)), &[]),
-    ("library", EXCEPTIONS_STDLIB, Some((&["sysroot"], PERMITTED_STDLIB_DEPENDENCIES)), &[]),
+    WorkspaceInfo::new(".", EXCEPTIONS, Some((&["rustc-main"], PERMITTED_RUSTC_DEPENDENCIES)), &[]),
+    WorkspaceInfo::new(
+        "library",
+        EXCEPTIONS_STDLIB,
+        Some((&["sysroot"], PERMITTED_STDLIB_DEPENDENCIES)),
+        &[],
+    ),
     // Outside of the alphabetical section because rustfmt formats it using multiple lines.
-    (
+    WorkspaceInfo::new(
         "compiler/rustc_codegen_cranelift",
         EXCEPTIONS_CRANELIFT,
         Some((&["rustc_codegen_cranelift"], PERMITTED_CRANELIFT_DEPENDENCIES)),
         &[],
     ),
     // tidy-alphabetical-start
-    ("compiler/rustc_codegen_gcc", EXCEPTIONS_GCC, None, &[]),
-    ("src/bootstrap", EXCEPTIONS_BOOTSTRAP, None, &[]),
-    ("src/tools/cargo", EXCEPTIONS_CARGO, None, &["src/tools/cargo"]),
-    //("src/tools/miri/test-cargo-miri", &[], None), // FIXME uncomment once all deps are vendored
-    //("src/tools/miri/test_dependencies", &[], None), // FIXME uncomment once all deps are vendored
-    ("src/tools/rust-analyzer", EXCEPTIONS_RUST_ANALYZER, None, &[]),
-    ("src/tools/rustbook", EXCEPTIONS_RUSTBOOK, None, &["src/doc/book", "src/doc/reference"]),
-    ("src/tools/rustc-perf", EXCEPTIONS_RUSTC_PERF, None, &["src/tools/rustc-perf"]),
-    ("src/tools/test-float-parse", EXCEPTIONS, None, &[]),
-    ("tests/run-make-cargo/uefi-qemu/uefi_qemu_test", EXCEPTIONS_UEFI_QEMU_TEST, None, &[]),
+    WorkspaceInfo::new("compiler/rustc_codegen_gcc", EXCEPTIONS_GCC, None, &[]),
+    WorkspaceInfo::new("src/bootstrap", EXCEPTIONS_BOOTSTRAP, None, &[]),
+    WorkspaceInfo::new("src/tools/cargo", EXCEPTIONS_CARGO, None, &["src/tools/cargo"]),
+    //WorkspaceInfo::new("src/tools/miri/test-cargo-miri", &[], None), // FIXME uncomment once all deps are vendored
+    //WorkspaceInfo::new("src/tools/miri/test_dependencies", &[], None), // FIXME uncomment once all deps are vendored
+    WorkspaceInfo::new("src/tools/rust-analyzer", EXCEPTIONS_RUST_ANALYZER, None, &[]),
+    WorkspaceInfo::new(
+        "src/tools/rustbook",
+        EXCEPTIONS_RUSTBOOK,
+        None,
+        &["src/doc/book", "src/doc/reference"],
+    ),
+    WorkspaceInfo::new(
+        "src/tools/rustc-perf",
+        EXCEPTIONS_RUSTC_PERF,
+        None,
+        &["src/tools/rustc-perf"],
+    ),
+    WorkspaceInfo::new("src/tools/test-float-parse", EXCEPTIONS, None, &[]),
+    WorkspaceInfo::new(
+        "tests/run-make-cargo/uefi-qemu/uefi_qemu_test",
+        EXCEPTIONS_UEFI_QEMU_TEST,
+        None,
+        &[],
+    ),
     // tidy-alphabetical-end
 ];
 
@@ -567,29 +602,29 @@ pub fn check(root: &Path, cargo: &Path, bless: bool, bad: &mut bool) {
 
     check_proc_macro_dep_list(root, cargo, bless, bad);
 
-    for &(workspace, exceptions, permitted_deps, submodules) in WORKSPACES {
+    for &WorkspaceInfo { path, exceptions, crates_and_deps, submodules } in WORKSPACES {
         if has_missing_submodule(root, submodules) {
             continue;
         }
 
-        if !root.join(workspace).join("Cargo.lock").exists() {
-            tidy_error!(bad, "the `{workspace}` workspace doesn't have a Cargo.lock");
+        if !root.join(path).join("Cargo.lock").exists() {
+            tidy_error!(bad, "the `{path}` workspace doesn't have a Cargo.lock");
             continue;
         }
 
         let mut cmd = cargo_metadata::MetadataCommand::new();
         cmd.cargo_path(cargo)
-            .manifest_path(root.join(workspace).join("Cargo.toml"))
+            .manifest_path(root.join(path).join("Cargo.toml"))
             .features(cargo_metadata::CargoOpt::AllFeatures)
             .other_options(vec!["--locked".to_owned()]);
         let metadata = t!(cmd.exec());
 
-        check_license_exceptions(&metadata, workspace, exceptions, bad);
-        if let Some((crates, permitted_deps)) = permitted_deps {
-            check_permitted_dependencies(&metadata, workspace, permitted_deps, crates, bad);
+        check_license_exceptions(&metadata, path, exceptions, bad);
+        if let Some((crates, permitted_deps)) = crates_and_deps {
+            check_permitted_dependencies(&metadata, path, permitted_deps, crates, bad);
         }
 
-        if workspace == "library" {
+        if path == "library" {
             check_runtime_license_exceptions(&metadata, bad);
             check_runtime_no_duplicate_dependencies(&metadata, bad);
             check_runtime_no_proc_macros(&metadata, bad);
diff --git a/src/tools/tidy/src/extdeps.rs b/src/tools/tidy/src/extdeps.rs
index bc217a55cc199..2b212cfa67a4b 100644
--- a/src/tools/tidy/src/extdeps.rs
+++ b/src/tools/tidy/src/extdeps.rs
@@ -3,6 +3,8 @@
 use std::fs;
 use std::path::Path;
 
+use crate::deps::WorkspaceInfo;
+
 /// List of allowed sources for packages.
 const ALLOWED_SOURCES: &[&str] = &[
     r#""registry+https://github.com/rust-lang/crates.io-index""#,
@@ -13,22 +15,22 @@ const ALLOWED_SOURCES: &[&str] = &[
 /// Checks for external package sources. `root` is the path to the directory that contains the
 /// workspace `Cargo.toml`.
 pub fn check(root: &Path, bad: &mut bool) {
-    for &(workspace, _, _, submodules) in crate::deps::WORKSPACES {
+    for &WorkspaceInfo { path, submodules, .. } in crate::deps::WORKSPACES {
         if crate::deps::has_missing_submodule(root, submodules) {
             continue;
         }
 
         // FIXME check other workspaces too
         // `Cargo.lock` of rust.
-        let path = root.join(workspace).join("Cargo.lock");
+        let lockfile = root.join(path).join("Cargo.lock");
 
-        if !path.exists() {
-            tidy_error!(bad, "the `{workspace}` workspace doesn't have a Cargo.lock");
+        if !lockfile.exists() {
+            tidy_error!(bad, "the `{path}` workspace doesn't have a Cargo.lock");
             continue;
         }
 
         // Open and read the whole file.
-        let cargo_lock = t!(fs::read_to_string(&path));
+        let cargo_lock = t!(fs::read_to_string(&lockfile));
 
         // Process each line.
         for line in cargo_lock.lines() {

From 7d5413bd17ede225bc3c2ac9a7f640885628edc8 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 10 Sep 2025 17:55:44 +0200
Subject: [PATCH 0762/1889] this apparently needs more test rounds

---
 src/tools/miri/tests/pass/0weak_memory/weak.rs | 8 ++++++--
 src/tools/miri/tests/pass/float_nan.rs         | 6 +++++-
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/src/tools/miri/tests/pass/0weak_memory/weak.rs b/src/tools/miri/tests/pass/0weak_memory/weak.rs
index f39ef0ed98da9..0dd661d3e9b4b 100644
--- a/src/tools/miri/tests/pass/0weak_memory/weak.rs
+++ b/src/tools/miri/tests/pass/0weak_memory/weak.rs
@@ -44,11 +44,15 @@ fn check_all_outcomes<T: Eq + std::hash::Hash + std::fmt::Display>(
     let expected: HashSet<T> = HashSet::from_iter(expected);
     let mut seen = HashSet::new();
     // Let's give it N times as many tries as we are expecting values.
-    let tries = expected.len() * 8;
-    for _ in 0..tries {
+    let tries = expected.len() * 12;
+    for i in 0..tries {
         let val = generate();
         assert!(expected.contains(&val), "got an unexpected value: {val}");
         seen.insert(val);
+        if i > tries / 2 && expected.len() == seen.len() {
+            // We saw everything and we did quite a few tries, let's avoid wasting time.
+            return;
+        }
     }
     // Let's see if we saw them all.
     for val in expected {
diff --git a/src/tools/miri/tests/pass/float_nan.rs b/src/tools/miri/tests/pass/float_nan.rs
index f0a2b8e9ee060..902816307403a 100644
--- a/src/tools/miri/tests/pass/float_nan.rs
+++ b/src/tools/miri/tests/pass/float_nan.rs
@@ -38,10 +38,14 @@ fn check_all_outcomes<T: Eq + std::hash::Hash + fmt::Display>(
     let mut seen = HashSet::new();
     // Let's give it N times as many tries as we are expecting values.
     let tries = expected.len() * 12;
-    for _ in 0..tries {
+    for i in 0..tries {
         let val = generate();
         assert!(expected.contains(&val), "got an unexpected value: {val}");
         seen.insert(val);
+        if i > tries / 2 && expected.len() == seen.len() {
+            // We saw everything and we did quite a few tries, let's avoid wasting time.
+            return;
+        }
     }
     // Let's see if we saw them all.
     for val in expected {

From d50a80e1d0e655524a3c0dff1f55d7c667314184 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Tue, 10 Jun 2025 16:35:44 -0500
Subject: [PATCH 0763/1889] core::ptr: deduplicate docs for as_ref, addr, and
 as_uninit_ref

also add INFO.md file explaining the purpouse of the ptr/docs dir.
---
 library/core/src/ptr/const_ptr.rs          | 78 ++++---------------
 library/core/src/ptr/docs/INFO.md          | 21 +++++
 library/core/src/ptr/docs/addr.md          | 22 ++++++
 library/core/src/ptr/docs/as_ref.md        | 19 +++++
 library/core/src/ptr/docs/as_uninit_ref.md | 15 ++++
 library/core/src/ptr/mut_ptr.rs            | 90 +++++-----------------
 6 files changed, 111 insertions(+), 134 deletions(-)
 create mode 100644 library/core/src/ptr/docs/INFO.md
 create mode 100644 library/core/src/ptr/docs/addr.md
 create mode 100644 library/core/src/ptr/docs/as_ref.md
 create mode 100644 library/core/src/ptr/docs/as_uninit_ref.md

diff --git a/library/core/src/ptr/const_ptr.rs b/library/core/src/ptr/const_ptr.rs
index 9366cb36c6efa..7cd2a1d28e332 100644
--- a/library/core/src/ptr/const_ptr.rs
+++ b/library/core/src/ptr/const_ptr.rs
@@ -146,28 +146,7 @@ impl<T: ?Sized> *const T {
         self as _
     }
 
-    /// Gets the "address" portion of the pointer.
-    ///
-    /// This is similar to `self as usize`, except that the [provenance][crate::ptr#provenance] of
-    /// the pointer is discarded and not [exposed][crate::ptr#exposed-provenance]. This means that
-    /// casting the returned address back to a pointer yields a [pointer without
-    /// provenance][without_provenance], which is undefined behavior to dereference. To properly
-    /// restore the lost information and obtain a dereferenceable pointer, use
-    /// [`with_addr`][pointer::with_addr] or [`map_addr`][pointer::map_addr].
-    ///
-    /// If using those APIs is not possible because there is no way to preserve a pointer with the
-    /// required provenance, then Strict Provenance might not be for you. Use pointer-integer casts
-    /// or [`expose_provenance`][pointer::expose_provenance] and [`with_exposed_provenance`][with_exposed_provenance]
-    /// instead. However, note that this makes your code less portable and less amenable to tools
-    /// that check for compliance with the Rust memory model.
-    ///
-    /// On most platforms this will produce a value with the same bytes as the original
-    /// pointer, because all the bytes are dedicated to describing the address.
-    /// Platforms which need to store additional information in the pointer may
-    /// perform a change of representation to produce a value containing only the address
-    /// portion of the pointer. What that means is up to the platform to define.
-    ///
-    /// This is a [Strict Provenance][crate::ptr#strict-provenance] API.
+    #[doc = include_str!("./docs/addr.md")]
     #[must_use]
     #[inline(always)]
     #[stable(feature = "strict_provenance", since = "1.84.0")]
@@ -254,23 +233,16 @@ impl<T: ?Sized> *const T {
         (self.cast(), metadata(self))
     }
 
-    /// Returns `None` if the pointer is null, or else returns a shared reference to
-    /// the value wrapped in `Some`. If the value may be uninitialized, [`as_uninit_ref`]
-    /// must be used instead.
-    ///
-    /// [`as_uninit_ref`]: #method.as_uninit_ref
-    ///
-    /// # 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).
+    #[doc = include_str!("./docs/as_ref.md")]
     ///
-    /// # Panics during const evaluation
-    ///
-    /// This method will panic during const evaluation if the pointer cannot be
-    /// determined to be null or not. See [`is_null`] for more information.
+    /// ```
+    /// let ptr: *const u8 = &10u8 as *const u8;
     ///
-    /// [`is_null`]: #method.is_null
+    /// unsafe {
+    ///     let val_back = &*ptr;
+    ///     assert_eq!(val_back, &10);
+    /// }
+    /// ```
     ///
     /// # Examples
     ///
@@ -284,20 +256,9 @@ impl<T: ?Sized> *const T {
     /// }
     /// ```
     ///
-    /// # Null-unchecked version
     ///
-    /// If you are sure the pointer can never be null and are looking for some kind of
-    /// `as_ref_unchecked` that returns the `&T` instead of `Option<&T>`, know that you can
-    /// dereference the pointer directly.
-    ///
-    /// ```
-    /// let ptr: *const u8 = &10u8 as *const u8;
-    ///
-    /// unsafe {
-    ///     let val_back = &*ptr;
-    ///     assert_eq!(val_back, &10);
-    /// }
-    /// ```
+    /// [`is_null`]: #method.is_null
+    /// [`as_uninit_ref`]: #method.as_uninit_ref
     #[stable(feature = "ptr_as_ref", since = "1.9.0")]
     #[rustc_const_stable(feature = "const_ptr_is_null", since = "1.84.0")]
     #[inline]
@@ -338,23 +299,10 @@ impl<T: ?Sized> *const T {
         unsafe { &*self }
     }
 
-    /// Returns `None` if the pointer is null, or else returns a shared reference to
-    /// the value wrapped in `Some`. In contrast to [`as_ref`], this does not require
-    /// that the value has to be initialized.
-    ///
-    /// [`as_ref`]: #method.as_ref
-    ///
-    /// # 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).
-    ///
-    /// # Panics during const evaluation
-    ///
-    /// This method will panic during const evaluation if the pointer cannot be
-    /// determined to be null or not. See [`is_null`] for more information.
+    #[doc = include_str!("./docs/as_uninit_ref.md")]
     ///
     /// [`is_null`]: #method.is_null
+    /// [`as_ref`]: #method.as_ref
     ///
     /// # Examples
     ///
diff --git a/library/core/src/ptr/docs/INFO.md b/library/core/src/ptr/docs/INFO.md
new file mode 100644
index 0000000000000..28a0da4926a94
--- /dev/null
+++ b/library/core/src/ptr/docs/INFO.md
@@ -0,0 +1,21 @@
+This directory holds method documentation that otherwise
+would be duplicated across mutable and immutable pointers.
+
+Note that most of the docs here are not the complete docs
+for their corresponding method. This is for a few reasons:
+
+1. Examples need to be different for mutable/immutable
+   pointers, in order to actually call the correct method.
+2. Link reference definitions are frequently different
+   between mutable/immutable pointers, in order to link to
+   the correct method.
+   For example, `<*const T>::as_ref` links to
+   `<*const T>::is_null`, while `<*mut T>::as_ref` links to
+   `<*mut T>::is_null`.
+3. Many methods on mutable pointers link to an alternate
+   version that returns a mutable reference instead of
+   a shared reference.
+
+Always review the rendered docs manually when making
+changes to these files to make sure you're not accidentally
+splitting up a section.
diff --git a/library/core/src/ptr/docs/addr.md b/library/core/src/ptr/docs/addr.md
new file mode 100644
index 0000000000000..785b88a998709
--- /dev/null
+++ b/library/core/src/ptr/docs/addr.md
@@ -0,0 +1,22 @@
+Gets the "address" portion of the pointer.
+
+This is similar to `self as usize`, except that the [provenance][crate::ptr#provenance] of
+the pointer is discarded and not [exposed][crate::ptr#exposed-provenance]. This means that
+casting the returned address back to a pointer yields a [pointer without
+provenance][without_provenance], which is undefined behavior to dereference. To properly
+restore the lost information and obtain a dereferenceable pointer, use
+[`with_addr`][pointer::with_addr] or [`map_addr`][pointer::map_addr].
+
+If using those APIs is not possible because there is no way to preserve a pointer with the
+required provenance, then Strict Provenance might not be for you. Use pointer-integer casts
+or [`expose_provenance`][pointer::expose_provenance] and [`with_exposed_provenance`][with_exposed_provenance]
+instead. However, note that this makes your code less portable and less amenable to tools
+that check for compliance with the Rust memory model.
+
+On most platforms this will produce a value with the same bytes as the original
+pointer, because all the bytes are dedicated to describing the address.
+Platforms which need to store additional information in the pointer may
+perform a change of representation to produce a value containing only the address
+portion of the pointer. What that means is up to the platform to define.
+
+This is a [Strict Provenance][crate::ptr#strict-provenance] API.
diff --git a/library/core/src/ptr/docs/as_ref.md b/library/core/src/ptr/docs/as_ref.md
new file mode 100644
index 0000000000000..0c0d2768c7482
--- /dev/null
+++ b/library/core/src/ptr/docs/as_ref.md
@@ -0,0 +1,19 @@
+Returns `None` if the pointer is null, or else returns a shared reference to
+the value wrapped in `Some`. If the value may be uninitialized, [`as_uninit_ref`]
+must be used instead.
+
+# 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).
+
+# Panics during const evaluation
+
+This method will panic during const evaluation if the pointer cannot be
+determined to be null or not. See [`is_null`] for more information.
+
+# Null-unchecked version
+
+If you are sure the pointer can never be null and are looking for some kind of
+`as_ref_unchecked` that returns the `&T` instead of `Option<&T>`, know that you can
+dereference the pointer directly.
diff --git a/library/core/src/ptr/docs/as_uninit_ref.md b/library/core/src/ptr/docs/as_uninit_ref.md
new file mode 100644
index 0000000000000..5b9a1ecb85b91
--- /dev/null
+++ b/library/core/src/ptr/docs/as_uninit_ref.md
@@ -0,0 +1,15 @@
+Returns `None` if the pointer is null, or else returns a shared reference to
+the value wrapped in `Some`. In contrast to [`as_ref`], this does not require
+that the value has to be initialized.
+
+# 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).
+Note that because the created reference is to `MaybeUninit<T>`, the
+source pointer can point to uninitialized memory.
+
+# Panics during const evaluation
+
+This method will panic during const evaluation if the pointer cannot be
+determined to be null or not. See [`is_null`] for more information.
diff --git a/library/core/src/ptr/mut_ptr.rs b/library/core/src/ptr/mut_ptr.rs
index efe1031b79cac..62cada51259ef 100644
--- a/library/core/src/ptr/mut_ptr.rs
+++ b/library/core/src/ptr/mut_ptr.rs
@@ -133,28 +133,9 @@ impl<T: ?Sized> *mut T {
         self as _
     }
 
-    /// Gets the "address" portion of the pointer.
-    ///
-    /// This is similar to `self as usize`, except that the [provenance][crate::ptr#provenance] of
-    /// the pointer is discarded and not [exposed][crate::ptr#exposed-provenance]. This means that
-    /// casting the returned address back to a pointer yields a [pointer without
-    /// provenance][without_provenance_mut], which is undefined behavior to dereference. To properly
-    /// restore the lost information and obtain a dereferenceable pointer, use
-    /// [`with_addr`][pointer::with_addr] or [`map_addr`][pointer::map_addr].
-    ///
-    /// If using those APIs is not possible because there is no way to preserve a pointer with the
-    /// required provenance, then Strict Provenance might not be for you. Use pointer-integer casts
-    /// or [`expose_provenance`][pointer::expose_provenance] and [`with_exposed_provenance`][with_exposed_provenance]
-    /// instead. However, note that this makes your code less portable and less amenable to tools
-    /// that check for compliance with the Rust memory model.
-    ///
-    /// On most platforms this will produce a value with the same bytes as the original
-    /// pointer, because all the bytes are dedicated to describing the address.
-    /// Platforms which need to store additional information in the pointer may
-    /// perform a change of representation to produce a value containing only the address
-    /// portion of the pointer. What that means is up to the platform to define.
+    #[doc = include_str!("./docs/addr.md")]
     ///
-    /// This is a [Strict Provenance][crate::ptr#strict-provenance] API.
+    /// [without_provenance]: without_provenance_mut
     #[must_use]
     #[inline(always)]
     #[stable(feature = "strict_provenance", since = "1.84.0")]
@@ -241,26 +222,16 @@ impl<T: ?Sized> *mut T {
         (self.cast(), super::metadata(self))
     }
 
-    /// Returns `None` if the pointer is null, or else returns a shared reference to
-    /// the value wrapped in `Some`. If the value may be uninitialized, [`as_uninit_ref`]
-    /// must be used instead.
-    ///
-    /// For the mutable counterpart see [`as_mut`].
+    #[doc = include_str!("./docs/as_ref.md")]
     ///
-    /// [`as_uninit_ref`]: pointer#method.as_uninit_ref-1
-    /// [`as_mut`]: #method.as_mut
-    ///
-    /// # 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).
-    ///
-    /// # Panics during const evaluation
-    ///
-    /// This method will panic during const evaluation if the pointer cannot be
-    /// determined to be null or not. See [`is_null`] for more information.
+    /// ```
+    /// let ptr: *mut u8 = &mut 10u8 as *mut u8;
     ///
-    /// [`is_null`]: #method.is_null-1
+    /// unsafe {
+    ///     let val_back = &*ptr;
+    ///     println!("We got back the value: {val_back}!");
+    /// }
+    /// ```
     ///
     /// # Examples
     ///
@@ -274,20 +245,14 @@ impl<T: ?Sized> *mut T {
     /// }
     /// ```
     ///
-    /// # Null-unchecked version
-    ///
-    /// If you are sure the pointer can never be null and are looking for some kind of
-    /// `as_ref_unchecked` that returns the `&T` instead of `Option<&T>`, know that you can
-    /// dereference the pointer directly.
+    /// # See Also
     ///
-    /// ```
-    /// let ptr: *mut u8 = &mut 10u8 as *mut u8;
+    /// For the mutable counterpart see [`as_mut`].
     ///
-    /// unsafe {
-    ///     let val_back = &*ptr;
-    ///     println!("We got back the value: {val_back}!");
-    /// }
-    /// ```
+    /// [`is_null`]: #method.is_null-1
+    /// [`as_uninit_ref`]: pointer#method.as_uninit_ref-1
+    /// [`as_mut`]: #method.as_mut
+
     #[stable(feature = "ptr_as_ref", since = "1.9.0")]
     #[rustc_const_stable(feature = "const_ptr_is_null", since = "1.84.0")]
     #[inline]
@@ -330,28 +295,15 @@ impl<T: ?Sized> *mut T {
         unsafe { &*self }
     }
 
-    /// Returns `None` if the pointer is null, or else returns a shared reference to
-    /// the value wrapped in `Some`. In contrast to [`as_ref`], this does not require
-    /// that the value has to be initialized.
-    ///
-    /// For the mutable counterpart see [`as_uninit_mut`].
+    #[doc = include_str!("./docs/as_uninit_ref.md")]
     ///
+    /// [`is_null`]: #method.is_null-1
     /// [`as_ref`]: pointer#method.as_ref-1
-    /// [`as_uninit_mut`]: #method.as_uninit_mut
-    ///
-    /// # 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).
-    /// Note that because the created reference is to `MaybeUninit<T>`, the
-    /// source pointer can point to uninitialized memory.
-    ///
-    /// # Panics during const evaluation
     ///
-    /// This method will panic during const evaluation if the pointer cannot be
-    /// determined to be null or not. See [`is_null`] for more information.
+    /// # See Also
+    /// For the mutable counterpart see [`as_uninit_mut`].
     ///
-    /// [`is_null`]: #method.is_null-1
+    /// [`as_uninit_mut`]: #method.as_uninit_mut
     ///
     /// # Examples
     ///

From ba874d38a561ec59d0f8e6fdde3d830e84f6da98 Mon Sep 17 00:00:00 2001
From: clubby789 <jamie@hill-daniel.co.uk>
Date: Wed, 10 Sep 2025 17:07:28 +0100
Subject: [PATCH 0764/1889] tidy: Print crate name on dependency error

---
 src/tools/tidy/src/deps.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs
index 08c0d3ca78653..184f52a247f86 100644
--- a/src/tools/tidy/src/deps.rs
+++ b/src/tools/tidy/src/deps.rs
@@ -621,7 +621,8 @@ pub fn check(root: &Path, cargo: &Path, bless: bool, bad: &mut bool) {
 
         check_license_exceptions(&metadata, path, exceptions, bad);
         if let Some((crates, permitted_deps)) = crates_and_deps {
-            check_permitted_dependencies(&metadata, path, permitted_deps, crates, bad);
+            let descr = crates.get(0).unwrap_or(&path);
+            check_permitted_dependencies(&metadata, descr, permitted_deps, crates, bad);
         }
 
         if path == "library" {

From 096ae06e028768e539a7ae9ac56cd913011c6ee5 Mon Sep 17 00:00:00 2001
From: lolbinarycat <binarycat@envs.net>
Date: Tue, 22 Jul 2025 11:57:42 -0500
Subject: [PATCH 0765/1889] glossary: add entry for rustbuild

---
 src/doc/rustc-dev-guide/src/appendix/glossary.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/doc/rustc-dev-guide/src/appendix/glossary.md b/src/doc/rustc-dev-guide/src/appendix/glossary.md
index 1837b59e850ae..4fc3822dd7385 100644
--- a/src/doc/rustc-dev-guide/src/appendix/glossary.md
+++ b/src/doc/rustc-dev-guide/src/appendix/glossary.md
@@ -68,6 +68,7 @@ Term                                                  | Meaning
 <span id="rib">rib</span>                      |  A data structure in the name resolver that keeps track of a single scope for names. ([see more](../name-resolution.md))
 <span id="rpit">RPIT</span>                    |  A return-position `impl Trait`. ([see the reference](https://doc.rust-lang.org/reference/types/impl-trait.html#abstract-return-types)).
 <span id="rpitit">RPITIT</span>                |  A return-position `impl Trait` in trait. Unlike RPIT, this is desugared to a generic associated type (GAT). Introduced in [RFC 3425](https://rust-lang.github.io/rfcs/3425-return-position-impl-trait-in-traits.html). ([see more](../return-position-impl-trait-in-trait.md))
+<span id="rustbuild">rustbuild</span>          |  The part of bootstrap that is written in rust (old deprecated term)
 <span id="scrutinee">scrutinee</span>          |  A scrutinee is the expression that is matched on in `match` expressions and similar pattern matching constructs. For example, in `match x { A => 1, B => 2 }`, the expression `x` is the scrutinee.
 <span id="sess">`sess`</span>                  |  The compiler _session_, which stores global data used throughout compilation
 <span id="side-tables">side tables</span>      |  Because the [AST](#ast) and HIR are immutable once created, we often carry extra information about them in the form of hashtables, indexed by the id of a particular node.

From adfb6ec089fbb41519acd530cbedd3477e84399c Mon Sep 17 00:00:00 2001
From: clubby789 <jamie@hill-daniel.co.uk>
Date: Wed, 10 Sep 2025 17:13:21 +0100
Subject: [PATCH 0766/1889] tidy: More accurate permitted dependencies location

---
 src/tools/tidy/src/deps.rs | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs
index 184f52a247f86..9acd445f3e238 100644
--- a/src/tools/tidy/src/deps.rs
+++ b/src/tools/tidy/src/deps.rs
@@ -261,7 +261,19 @@ const EXCEPTIONS_UEFI_QEMU_TEST: ExceptionList = &[
     ("r-efi", "MIT OR Apache-2.0 OR LGPL-2.1-or-later"), // LGPL is not acceptable, but we use it under MIT OR Apache-2.0
 ];
 
-const PERMITTED_DEPS_LOCATION: &str = concat!(file!(), ":", line!());
+struct ListLocation {
+    path: &'static str,
+    line: u32,
+}
+
+/// Creates a [`ListLocation`] for the current location (with an additional offset to the actual list start);
+macro_rules! location {
+    (+ $offset:literal) => {
+        ListLocation { path: file!(), line: line!() + $offset }
+    };
+}
+
+const PERMITTED_RUSTC_DEPS_LOCATION: ListLocation = location!(+6);
 
 /// Crates rustc is allowed to depend on. Avoid adding to the list if possible.
 ///
@@ -930,7 +942,8 @@ fn check_permitted_dependencies(
     }
 
     if has_permitted_dep_error {
-        eprintln!("Go to `{PERMITTED_DEPS_LOCATION}` for the list.");
+        let ListLocation { path, line } = PERMITTED_RUSTC_DEPS_LOCATION;
+        eprintln!("Go to `{path}:{line}` for the list.");
     }
 }
 

From 11a22b30904fb6e0fd41d9004b3a88e985ec8455 Mon Sep 17 00:00:00 2001
From: clubby789 <jamie@hill-daniel.co.uk>
Date: Wed, 10 Sep 2025 17:19:51 +0100
Subject: [PATCH 0767/1889] tidy: Add specific line info for allowed
 dependencies

---
 src/tools/tidy/src/deps.rs | 34 +++++++++++++++++++++++++---------
 1 file changed, 25 insertions(+), 9 deletions(-)

diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs
index 9acd445f3e238..290f0ea313419 100644
--- a/src/tools/tidy/src/deps.rs
+++ b/src/tools/tidy/src/deps.rs
@@ -48,6 +48,7 @@ const LICENSES: &[&str] = &[
 
 type ExceptionList = &'static [(&'static str, &'static str)];
 
+#[derive(Clone, Copy)]
 pub(crate) struct WorkspaceInfo<'a> {
     /// Path to the directory containing the workspace root Cargo.toml file.
     pub(crate) path: &'a str,
@@ -56,7 +57,8 @@ pub(crate) struct WorkspaceInfo<'a> {
     /// Optionally:
     /// * A list of crates for which dependencies need to be explicitly allowed.
     /// * The list of allowed dependencies.
-    pub(crate) crates_and_deps: Option<(&'a [&'a str], &'a [&'a str])>,
+    /// * The source code location of the allowed dependencies list
+    crates_and_deps: Option<(&'a [&'a str], &'a [&'a str], ListLocation)>,
     /// Submodules required for the workspace
     pub(crate) submodules: &'a [&'a str],
 }
@@ -65,7 +67,7 @@ impl<'a> WorkspaceInfo<'a> {
     const fn new(
         path: &'a str,
         exceptions: ExceptionList,
-        crates_and_deps: Option<(&'a [&str], &'a [&str])>,
+        crates_and_deps: Option<(&'a [&str], &'a [&str], ListLocation)>,
         submodules: &'a [&str],
     ) -> Self {
         Self { path, exceptions, crates_and_deps, submodules }
@@ -76,18 +78,27 @@ impl<'a> WorkspaceInfo<'a> {
 // FIXME auto detect all cargo workspaces
 pub(crate) const WORKSPACES: &[WorkspaceInfo<'static>] = &[
     // The root workspace has to be first for check_rustfix to work.
-    WorkspaceInfo::new(".", EXCEPTIONS, Some((&["rustc-main"], PERMITTED_RUSTC_DEPENDENCIES)), &[]),
+    WorkspaceInfo::new(
+        ".",
+        EXCEPTIONS,
+        Some((&["rustc-main"], PERMITTED_RUSTC_DEPENDENCIES, PERMITTED_RUSTC_DEPS_LOCATION)),
+        &[],
+    ),
     WorkspaceInfo::new(
         "library",
         EXCEPTIONS_STDLIB,
-        Some((&["sysroot"], PERMITTED_STDLIB_DEPENDENCIES)),
+        Some((&["sysroot"], PERMITTED_STDLIB_DEPENDENCIES, PERMITTED_STDLIB_DEPS_LOCATION)),
         &[],
     ),
     // Outside of the alphabetical section because rustfmt formats it using multiple lines.
     WorkspaceInfo::new(
         "compiler/rustc_codegen_cranelift",
         EXCEPTIONS_CRANELIFT,
-        Some((&["rustc_codegen_cranelift"], PERMITTED_CRANELIFT_DEPENDENCIES)),
+        Some((
+            &["rustc_codegen_cranelift"],
+            PERMITTED_CRANELIFT_DEPENDENCIES,
+            PERMITTED_CRANELIFT_DEPS_LOCATION,
+        )),
         &[],
     ),
     // tidy-alphabetical-start
@@ -261,6 +272,7 @@ const EXCEPTIONS_UEFI_QEMU_TEST: ExceptionList = &[
     ("r-efi", "MIT OR Apache-2.0 OR LGPL-2.1-or-later"), // LGPL is not acceptable, but we use it under MIT OR Apache-2.0
 ];
 
+#[derive(Clone, Copy)]
 struct ListLocation {
     path: &'static str,
     line: u32,
@@ -499,6 +511,8 @@ const PERMITTED_RUSTC_DEPENDENCIES: &[&str] = &[
     // tidy-alphabetical-end
 ];
 
+const PERMITTED_STDLIB_DEPS_LOCATION: ListLocation = location!(+2);
+
 const PERMITTED_STDLIB_DEPENDENCIES: &[&str] = &[
     // tidy-alphabetical-start
     "addr2line",
@@ -540,6 +554,8 @@ const PERMITTED_STDLIB_DEPENDENCIES: &[&str] = &[
     // tidy-alphabetical-end
 ];
 
+const PERMITTED_CRANELIFT_DEPS_LOCATION: ListLocation = location!(+2);
+
 const PERMITTED_CRANELIFT_DEPENDENCIES: &[&str] = &[
     // tidy-alphabetical-start
     "allocator-api2",
@@ -632,9 +648,9 @@ pub fn check(root: &Path, cargo: &Path, bless: bool, bad: &mut bool) {
         let metadata = t!(cmd.exec());
 
         check_license_exceptions(&metadata, path, exceptions, bad);
-        if let Some((crates, permitted_deps)) = crates_and_deps {
+        if let Some((crates, permitted_deps, location)) = crates_and_deps {
             let descr = crates.get(0).unwrap_or(&path);
-            check_permitted_dependencies(&metadata, descr, permitted_deps, crates, bad);
+            check_permitted_dependencies(&metadata, descr, permitted_deps, crates, location, bad);
         }
 
         if path == "library" {
@@ -882,6 +898,7 @@ fn check_permitted_dependencies(
     descr: &str,
     permitted_dependencies: &[&'static str],
     restricted_dependency_crates: &[&'static str],
+    permitted_location: ListLocation,
     bad: &mut bool,
 ) {
     let mut has_permitted_dep_error = false;
@@ -942,8 +959,7 @@ fn check_permitted_dependencies(
     }
 
     if has_permitted_dep_error {
-        let ListLocation { path, line } = PERMITTED_RUSTC_DEPS_LOCATION;
-        eprintln!("Go to `{path}:{line}` for the list.");
+        eprintln!("Go to `{}:{}` for the list.", permitted_location.path, permitted_location.line);
     }
 }
 

From 196b49a20ba12281e5465fc5ca7e919ce9fc2b29 Mon Sep 17 00:00:00 2001
From: lolbinarycat <binarycat@envs.net>
Date: Wed, 10 Sep 2025 11:31:04 -0500
Subject: [PATCH 0768/1889] glossary(rustbuild): reword according to code
 review

Co-authored-by: Tshepang Mbambo <hopsi@tuta.io>
---
 src/doc/rustc-dev-guide/src/appendix/glossary.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/src/appendix/glossary.md b/src/doc/rustc-dev-guide/src/appendix/glossary.md
index 4fc3822dd7385..21162f8ee7d08 100644
--- a/src/doc/rustc-dev-guide/src/appendix/glossary.md
+++ b/src/doc/rustc-dev-guide/src/appendix/glossary.md
@@ -68,7 +68,7 @@ Term                                                  | Meaning
 <span id="rib">rib</span>                      |  A data structure in the name resolver that keeps track of a single scope for names. ([see more](../name-resolution.md))
 <span id="rpit">RPIT</span>                    |  A return-position `impl Trait`. ([see the reference](https://doc.rust-lang.org/reference/types/impl-trait.html#abstract-return-types)).
 <span id="rpitit">RPITIT</span>                |  A return-position `impl Trait` in trait. Unlike RPIT, this is desugared to a generic associated type (GAT). Introduced in [RFC 3425](https://rust-lang.github.io/rfcs/3425-return-position-impl-trait-in-traits.html). ([see more](../return-position-impl-trait-in-trait.md))
-<span id="rustbuild">rustbuild</span>          |  The part of bootstrap that is written in rust (old deprecated term)
+<span id="rustbuild">rustbuild</span>          |  A deprecated term for the part of bootstrap that is written in Rust
 <span id="scrutinee">scrutinee</span>          |  A scrutinee is the expression that is matched on in `match` expressions and similar pattern matching constructs. For example, in `match x { A => 1, B => 2 }`, the expression `x` is the scrutinee.
 <span id="sess">`sess`</span>                  |  The compiler _session_, which stores global data used throughout compilation
 <span id="side-tables">side tables</span>      |  Because the [AST](#ast) and HIR are immutable once created, we often carry extra information about them in the form of hashtables, indexed by the id of a particular node.

From 82ff0025b7e12b2bbd9ddff4a5fed685c491bd34 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Wed, 10 Sep 2025 17:13:49 +0200
Subject: [PATCH 0769/1889] Add missing documentation for running tests with
 GCC backend

---
 .../src/tests/codegen-backend-tests/cg_gcc.md | 33 ++++++++++++++++++-
 1 file changed, 32 insertions(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/src/tests/codegen-backend-tests/cg_gcc.md b/src/doc/rustc-dev-guide/src/tests/codegen-backend-tests/cg_gcc.md
index 4caf4c0e0eefa..ef407797fead1 100644
--- a/src/doc/rustc-dev-guide/src/tests/codegen-backend-tests/cg_gcc.md
+++ b/src/doc/rustc-dev-guide/src/tests/codegen-backend-tests/cg_gcc.md
@@ -1,3 +1,34 @@
 # GCC codegen backend tests
 
-TODO: please add some more information to this page.
+To test the GCC codegen backend, you need to add `"gcc"` into the `rust.codegen-backends`
+setting in `bootstrap.toml`:
+
+```toml
+rust.codegen-backends = ["llvm", "gcc"]
+```
+
+If you don't want to change your `bootstrap.toml` file, you can alternatively run your `x.py`
+commands with `--set rust.codegen-backends=["llvm", "gcc"]'`. For example:
+
+```bash
+x.py test --set 'rust.codegen-backends=["llvm", "gcc"]'
+```
+
+If you don't want to build `gcc` yourself, you also need to set:
+
+```toml
+gcc.download-ci-gcc = true
+```
+
+Then when running tests, add the `--test-codegen-backend gcc` option. For example:
+
+```bash
+./x.py test tests/ui --test-codegen-backend gcc
+```
+
+If you want to build the sysroot using the GCC backend, you need to set it first
+in `rust.codegen-backends`:
+
+```toml
+rust.codegen-backends = ["llvm", "gcc"]
+```

From 5a36fe23879ee8dde1326bcf08f0016af6ccd896 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Wed, 10 Sep 2025 15:44:42 +0200
Subject: [PATCH 0770/1889] Improve suggestion in case a bare URL is surrounded
 by brackets

---
 src/librustdoc/passes/lint/bare_urls.rs | 53 +++++++++++++++++++------
 1 file changed, 40 insertions(+), 13 deletions(-)

diff --git a/src/librustdoc/passes/lint/bare_urls.rs b/src/librustdoc/passes/lint/bare_urls.rs
index f70bdf4e4fe37..ffa160beae30b 100644
--- a/src/librustdoc/passes/lint/bare_urls.rs
+++ b/src/librustdoc/passes/lint/bare_urls.rs
@@ -17,7 +17,10 @@ use crate::core::DocContext;
 use crate::html::markdown::main_body_opts;
 
 pub(super) fn visit_item(cx: &DocContext<'_>, item: &Item, hir_id: HirId, dox: &str) {
-    let report_diag = |cx: &DocContext<'_>, msg: &'static str, range: Range<usize>| {
+    let report_diag = |cx: &DocContext<'_>,
+                       msg: &'static str,
+                       range: Range<usize>,
+                       without_brackets: Option<&str>| {
         let maybe_sp = source_span_for_markdown_range(cx.tcx, dox, &range, &item.attrs.doc_strings)
             .map(|(sp, _)| sp);
         let sp = maybe_sp.unwrap_or_else(|| item.attr_span(cx.tcx));
@@ -27,14 +30,22 @@ pub(super) fn visit_item(cx: &DocContext<'_>, item: &Item, hir_id: HirId, dox: &
             // The fallback of using the attribute span is suitable for
             // highlighting where the error is, but not for placing the < and >
             if let Some(sp) = maybe_sp {
-                lint.multipart_suggestion(
-                    "use an automatic link instead",
-                    vec![
-                        (sp.shrink_to_lo(), "<".to_string()),
-                        (sp.shrink_to_hi(), ">".to_string()),
-                    ],
-                    Applicability::MachineApplicable,
-                );
+                if let Some(without_brackets) = without_brackets {
+                    lint.multipart_suggestion(
+                        "use an automatic link instead",
+                        vec![(sp, format!("<{without_brackets}>"))],
+                        Applicability::MachineApplicable,
+                    );
+                } else {
+                    lint.multipart_suggestion(
+                        "use an automatic link instead",
+                        vec![
+                            (sp.shrink_to_lo(), "<".to_string()),
+                            (sp.shrink_to_hi(), ">".to_string()),
+                        ],
+                        Applicability::MachineApplicable,
+                    );
+                }
             }
         });
     };
@@ -43,7 +54,7 @@ pub(super) fn visit_item(cx: &DocContext<'_>, item: &Item, hir_id: HirId, dox: &
 
     while let Some((event, range)) = p.next() {
         match event {
-            Event::Text(s) => find_raw_urls(cx, &s, range, &report_diag),
+            Event::Text(s) => find_raw_urls(cx, dox, &s, range, &report_diag),
             // We don't want to check the text inside code blocks or links.
             Event::Start(tag @ (Tag::CodeBlock(_) | Tag::Link { .. })) => {
                 for (event, _) in p.by_ref() {
@@ -67,25 +78,41 @@ static URL_REGEX: LazyLock<Regex> = LazyLock::new(|| {
         r"https?://",                          // url scheme
         r"([-a-zA-Z0-9@:%._\+~#=]{2,256}\.)+", // one or more subdomains
         r"[a-zA-Z]{2,63}",                     // root domain
-        r"\b([-a-zA-Z0-9@:%_\+.~#?&/=]*)"      // optional query or url fragments
+        r"\b([-a-zA-Z0-9@:%_\+.~#?&/=]*)",     // optional query or url fragments
     ))
     .expect("failed to build regex")
 });
 
 fn find_raw_urls(
     cx: &DocContext<'_>,
+    whole_text: &str,
     text: &str,
     range: Range<usize>,
-    f: &impl Fn(&DocContext<'_>, &'static str, Range<usize>),
+    f: &impl Fn(&DocContext<'_>, &'static str, Range<usize>, Option<&str>),
 ) {
     trace!("looking for raw urls in {text}");
     // For now, we only check "full" URLs (meaning, starting with "http://" or "https://").
     for match_ in URL_REGEX.find_iter(text) {
         let url_range = match_.range();
+        let mut without_brackets = None;
+        let mut extra_range = 0;
+        // If the whole text is contained inside `[]`, then we need to replace the brackets and
+        // not just add `<>`.
+        if whole_text[..range.start + url_range.start].ends_with('[')
+            && range.start + url_range.end <= whole_text.len()
+            && whole_text[range.start + url_range.end..].starts_with(']')
+        {
+            extra_range = 1;
+            without_brackets = Some(match_.as_str());
+        }
         f(
             cx,
             "this URL is not a hyperlink",
-            Range { start: range.start + url_range.start, end: range.start + url_range.end },
+            Range {
+                start: range.start + url_range.start - extra_range,
+                end: range.start + url_range.end + extra_range,
+            },
+            without_brackets,
         );
     }
 }

From 3205e4db0f9278ce06240b9de20d0802afef1de9 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Wed, 10 Sep 2025 15:44:59 +0200
Subject: [PATCH 0771/1889] Add new ui tests for `rustdoc::bare_urls`

---
 tests/rustdoc-ui/lints/bare-urls.fixed  | 14 +++++
 tests/rustdoc-ui/lints/bare-urls.rs     | 14 +++++
 tests/rustdoc-ui/lints/bare-urls.stderr | 70 ++++++++++++++++++++++++-
 3 files changed, 97 insertions(+), 1 deletion(-)

diff --git a/tests/rustdoc-ui/lints/bare-urls.fixed b/tests/rustdoc-ui/lints/bare-urls.fixed
index a91573146b823..ac63e291c5b04 100644
--- a/tests/rustdoc-ui/lints/bare-urls.fixed
+++ b/tests/rustdoc-ui/lints/bare-urls.fixed
@@ -68,3 +68,17 @@ pub mod foo {
     /// https://somewhere.com/a?hello=12&bye=11#xyz
     pub fn bar() {}
 }
+
+/// <https://bloob.blob>
+//~^ ERROR this URL is not a hyperlink
+/// [ <https://bloob.blob> ]
+//~^ ERROR this URL is not a hyperlink
+/// [ <https://bloob.blob>]
+//~^ ERROR this URL is not a hyperlink
+/// [<https://bloob.blob> ]
+//~^ ERROR this URL is not a hyperlink
+/// [<https://bloob.blob>
+//~^ ERROR this URL is not a hyperlink
+/// <https://bloob.blob>]
+//~^ ERROR this URL is not a hyperlink
+pub fn lint_with_brackets() {}
diff --git a/tests/rustdoc-ui/lints/bare-urls.rs b/tests/rustdoc-ui/lints/bare-urls.rs
index 5b008cdafa232..a70a3ec822e4a 100644
--- a/tests/rustdoc-ui/lints/bare-urls.rs
+++ b/tests/rustdoc-ui/lints/bare-urls.rs
@@ -68,3 +68,17 @@ pub mod foo {
     /// https://somewhere.com/a?hello=12&bye=11#xyz
     pub fn bar() {}
 }
+
+/// [https://bloob.blob]
+//~^ ERROR this URL is not a hyperlink
+/// [ https://bloob.blob ]
+//~^ ERROR this URL is not a hyperlink
+/// [ https://bloob.blob]
+//~^ ERROR this URL is not a hyperlink
+/// [https://bloob.blob ]
+//~^ ERROR this URL is not a hyperlink
+/// [https://bloob.blob
+//~^ ERROR this URL is not a hyperlink
+/// https://bloob.blob]
+//~^ ERROR this URL is not a hyperlink
+pub fn lint_with_brackets() {}
diff --git a/tests/rustdoc-ui/lints/bare-urls.stderr b/tests/rustdoc-ui/lints/bare-urls.stderr
index e1108c7e7f84e..fc3c642f5aac4 100644
--- a/tests/rustdoc-ui/lints/bare-urls.stderr
+++ b/tests/rustdoc-ui/lints/bare-urls.stderr
@@ -243,5 +243,73 @@ help: use an automatic link instead
 LL | #[doc = "<https://example.com/raw>"]
    |          +                       +
 
-error: aborting due to 20 previous errors
+error: this URL is not a hyperlink
+  --> $DIR/bare-urls.rs:72:5
+   |
+LL | /// [https://bloob.blob]
+   |     ^^^^^^^^^^^^^^^^^^^^ help: use an automatic link instead: `<https://bloob.blob>`
+   |
+   = note: bare URLs are not automatically turned into clickable links
+
+error: this URL is not a hyperlink
+  --> $DIR/bare-urls.rs:74:7
+   |
+LL | /// [ https://bloob.blob ]
+   |       ^^^^^^^^^^^^^^^^^^
+   |
+   = note: bare URLs are not automatically turned into clickable links
+help: use an automatic link instead
+   |
+LL | /// [ <https://bloob.blob> ]
+   |       +                  +
+
+error: this URL is not a hyperlink
+  --> $DIR/bare-urls.rs:76:7
+   |
+LL | /// [ https://bloob.blob]
+   |       ^^^^^^^^^^^^^^^^^^
+   |
+   = note: bare URLs are not automatically turned into clickable links
+help: use an automatic link instead
+   |
+LL | /// [ <https://bloob.blob>]
+   |       +                  +
+
+error: this URL is not a hyperlink
+  --> $DIR/bare-urls.rs:78:6
+   |
+LL | /// [https://bloob.blob ]
+   |      ^^^^^^^^^^^^^^^^^^
+   |
+   = note: bare URLs are not automatically turned into clickable links
+help: use an automatic link instead
+   |
+LL | /// [<https://bloob.blob> ]
+   |      +                  +
+
+error: this URL is not a hyperlink
+  --> $DIR/bare-urls.rs:80:6
+   |
+LL | /// [https://bloob.blob
+   |      ^^^^^^^^^^^^^^^^^^
+   |
+   = note: bare URLs are not automatically turned into clickable links
+help: use an automatic link instead
+   |
+LL | /// [<https://bloob.blob>
+   |      +                  +
+
+error: this URL is not a hyperlink
+  --> $DIR/bare-urls.rs:82:5
+   |
+LL | /// https://bloob.blob]
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = note: bare URLs are not automatically turned into clickable links
+help: use an automatic link instead
+   |
+LL | /// <https://bloob.blob>]
+   |     +                  +
+
+error: aborting due to 26 previous errors
 

From 7966ae0f3352894834a316bea9fd45068f94d937 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Wed, 10 Sep 2025 18:54:38 +0200
Subject: [PATCH 0772/1889] Simplify code for `find_raw_urls`

---
 src/librustdoc/passes/lint/bare_urls.rs | 28 ++++++++++---------------
 1 file changed, 11 insertions(+), 17 deletions(-)

diff --git a/src/librustdoc/passes/lint/bare_urls.rs b/src/librustdoc/passes/lint/bare_urls.rs
index ffa160beae30b..06256d611512b 100644
--- a/src/librustdoc/passes/lint/bare_urls.rs
+++ b/src/librustdoc/passes/lint/bare_urls.rs
@@ -85,7 +85,7 @@ static URL_REGEX: LazyLock<Regex> = LazyLock::new(|| {
 
 fn find_raw_urls(
     cx: &DocContext<'_>,
-    whole_text: &str,
+    dox: &str,
     text: &str,
     range: Range<usize>,
     f: &impl Fn(&DocContext<'_>, &'static str, Range<usize>, Option<&str>),
@@ -93,26 +93,20 @@ fn find_raw_urls(
     trace!("looking for raw urls in {text}");
     // For now, we only check "full" URLs (meaning, starting with "http://" or "https://").
     for match_ in URL_REGEX.find_iter(text) {
-        let url_range = match_.range();
+        let mut url_range = match_.range();
+        url_range.start += range.start;
+        url_range.end += range.start;
         let mut without_brackets = None;
-        let mut extra_range = 0;
-        // If the whole text is contained inside `[]`, then we need to replace the brackets and
+        // If the link is contained inside `[]`, then we need to replace the brackets and
         // not just add `<>`.
-        if whole_text[..range.start + url_range.start].ends_with('[')
-            && range.start + url_range.end <= whole_text.len()
-            && whole_text[range.start + url_range.end..].starts_with(']')
+        if dox[..url_range.start].ends_with('[')
+            && url_range.end <= dox.len()
+            && dox[url_range.end..].starts_with(']')
         {
-            extra_range = 1;
+            url_range.start -= 1;
+            url_range.end += 1;
             without_brackets = Some(match_.as_str());
         }
-        f(
-            cx,
-            "this URL is not a hyperlink",
-            Range {
-                start: range.start + url_range.start - extra_range,
-                end: range.start + url_range.end + extra_range,
-            },
-            without_brackets,
-        );
+        f(cx, "this URL is not a hyperlink", url_range, without_brackets);
     }
 }

From dbd3ef1332574ef074c147f3b9e3e74dd29cd7b5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Sun, 24 Aug 2025 14:42:44 +0200
Subject: [PATCH 0773/1889] fixup no_{core,std} handling code

---
 .../src/attributes/crate_level.rs             |   9 +-
 src/tools/clippy/clippy_utils/src/lib.rs      |  10 +-
 tests/ui/attributes/malformed-no-std.rs       |  25 ++++
 tests/ui/attributes/malformed-no-std.stderr   |  86 ++++++++++++
 .../issue-43106-gating-of-builtin-attrs.rs    |  12 +-
 ...issue-43106-gating-of-builtin-attrs.stderr | 131 ++++++++++--------
 .../lint/unused/unused-attr-duplicate.stderr  |  24 ++--
 tests/ui/unpretty/exhaustive.hir.stdout       |   2 +-
 8 files changed, 207 insertions(+), 92 deletions(-)
 create mode 100644 tests/ui/attributes/malformed-no-std.rs
 create mode 100644 tests/ui/attributes/malformed-no-std.stderr

diff --git a/compiler/rustc_attr_parsing/src/attributes/crate_level.rs b/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
index 3ec847bcaae2d..0b2c05482bfaa 100644
--- a/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
@@ -182,19 +182,20 @@ pub(crate) struct NoCoreParser;
 impl<S: Stage> NoArgsAttributeParser<S> for NoCoreParser {
     const PATH: &[Symbol] = &[sym::no_core];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
-    // FIXME: recursion limit is allowed on all targets and ignored,
-    //        even though it should only be valid on crates of course
+    // because it's a crate-level attribute, we already warn about it.
+    // Putting target limitations here would give duplicate warnings
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::NoCore;
     const TYPE: AttributeType = AttributeType::CrateLevel;
 }
 
 pub(crate) struct NoStdParser;
+
 impl<S: Stage> NoArgsAttributeParser<S> for NoStdParser {
     const PATH: &[Symbol] = &[sym::no_std];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
-    // FIXME: recursion limit is allowed on all targets and ignored,
-    //        even though it should only be valid on crates of course
+    // because it's a crate-level attribute, we already warn about it.
+    // Putting target limitations here would give duplicate warnings
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::NoStd;
     const TYPE: AttributeType = AttributeType::CrateLevel;
diff --git a/src/tools/clippy/clippy_utils/src/lib.rs b/src/tools/clippy/clippy_utils/src/lib.rs
index 14b64eb4d54e8..e1077bdf4b1a6 100644
--- a/src/tools/clippy/clippy_utils/src/lib.rs
+++ b/src/tools/clippy/clippy_utils/src/lib.rs
@@ -2133,17 +2133,11 @@ pub fn std_or_core(cx: &LateContext<'_>) -> Option<&'static str> {
 }
 
 pub fn is_no_std_crate(cx: &LateContext<'_>) -> bool {
-    cx.tcx
-        .hir_attrs(hir::CRATE_HIR_ID)
-        .iter()
-        .any(|attr| attr.has_name(sym::no_std))
+    find_attr!(cx.tcx.hir_attrs(hir::CRATE_HIR_ID), AttributeKind::NoStd(..))
 }
 
 pub fn is_no_core_crate(cx: &LateContext<'_>) -> bool {
-    cx.tcx
-        .hir_attrs(hir::CRATE_HIR_ID)
-        .iter()
-        .any(|attr| attr.has_name(sym::no_core))
+    find_attr!(cx.tcx.hir_attrs(hir::CRATE_HIR_ID), AttributeKind::NoCore(..))
 }
 
 /// Check if parent of a hir node is a trait implementation block.
diff --git a/tests/ui/attributes/malformed-no-std.rs b/tests/ui/attributes/malformed-no-std.rs
new file mode 100644
index 0000000000000..528ecb549b0e2
--- /dev/null
+++ b/tests/ui/attributes/malformed-no-std.rs
@@ -0,0 +1,25 @@
+#![feature(no_core)]
+// these all still apply no_std and then later error
+#![no_std = "foo"]
+//~^ ERROR malformed `no_std` attribute input
+#![no_std("bar")]
+//~^ ERROR malformed `no_std` attribute input
+#![no_std(foo = "bar")]
+//~^ ERROR malformed `no_std` attribute input
+#![no_core = "foo"]
+//~^ ERROR malformed `no_core` attribute input
+#![no_core("bar")]
+//~^ ERROR malformed `no_core` attribute input
+#![no_core(foo = "bar")]
+//~^ ERROR malformed `no_core` attribute input
+
+#[deny(unused_attributes)]
+#[no_std]
+//~^ ERROR crate-level attribute should be an inner attribute: add an exclamation mark:
+#[no_core]
+//~^ ERROR crate-level attribute should be an inner attribute: add an exclamation mark:
+// to fix compilation
+extern crate core;
+extern crate std;
+
+fn main() {}
diff --git a/tests/ui/attributes/malformed-no-std.stderr b/tests/ui/attributes/malformed-no-std.stderr
new file mode 100644
index 0000000000000..322d5f03e41c4
--- /dev/null
+++ b/tests/ui/attributes/malformed-no-std.stderr
@@ -0,0 +1,86 @@
+error[E0565]: malformed `no_std` attribute input
+  --> $DIR/malformed-no-std.rs:3:1
+   |
+LL | #![no_std = "foo"]
+   | ^^^^^^^^^^-------^
+   | |         |
+   | |         didn't expect any arguments here
+   | help: must be of the form: `#![no_std]`
+
+error[E0565]: malformed `no_std` attribute input
+  --> $DIR/malformed-no-std.rs:5:1
+   |
+LL | #![no_std("bar")]
+   | ^^^^^^^^^-------^
+   | |        |
+   | |        didn't expect any arguments here
+   | help: must be of the form: `#![no_std]`
+
+error[E0565]: malformed `no_std` attribute input
+  --> $DIR/malformed-no-std.rs:7:1
+   |
+LL | #![no_std(foo = "bar")]
+   | ^^^^^^^^^-------------^
+   | |        |
+   | |        didn't expect any arguments here
+   | help: must be of the form: `#![no_std]`
+
+error[E0565]: malformed `no_core` attribute input
+  --> $DIR/malformed-no-std.rs:9:1
+   |
+LL | #![no_core = "foo"]
+   | ^^^^^^^^^^^-------^
+   | |          |
+   | |          didn't expect any arguments here
+   | help: must be of the form: `#![no_core]`
+
+error[E0565]: malformed `no_core` attribute input
+  --> $DIR/malformed-no-std.rs:11:1
+   |
+LL | #![no_core("bar")]
+   | ^^^^^^^^^^-------^
+   | |         |
+   | |         didn't expect any arguments here
+   | help: must be of the form: `#![no_core]`
+
+error[E0565]: malformed `no_core` attribute input
+  --> $DIR/malformed-no-std.rs:13:1
+   |
+LL | #![no_core(foo = "bar")]
+   | ^^^^^^^^^^-------------^
+   | |         |
+   | |         didn't expect any arguments here
+   | help: must be of the form: `#![no_core]`
+
+error: crate-level attribute should be an inner attribute: add an exclamation mark: `#![no_std]`
+  --> $DIR/malformed-no-std.rs:17:1
+   |
+LL | #[no_std]
+   | ^^^^^^^^^
+   |
+note: This attribute does not have an `!`, which means it is applied to this extern crate
+  --> $DIR/malformed-no-std.rs:22:1
+   |
+LL | extern crate core;
+   | ^^^^^^^^^^^^^^^^^^
+note: the lint level is defined here
+  --> $DIR/malformed-no-std.rs:16:8
+   |
+LL | #[deny(unused_attributes)]
+   |        ^^^^^^^^^^^^^^^^^
+
+error: crate-level attribute should be an inner attribute: add an exclamation mark: `#![no_core]`
+  --> $DIR/malformed-no-std.rs:19:1
+   |
+LL | #[no_core]
+   | ^^^^^^^^^^
+   |
+note: This attribute does not have an `!`, which means it is applied to this extern crate
+  --> $DIR/malformed-no-std.rs:22:1
+   |
+LL | extern crate core;
+   | ^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 8 previous errors
+
+For more information about this error, try `rustc --explain E0565`.
diff --git a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.rs b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.rs
index c2653dd82a9f5..546aa4052d333 100644
--- a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.rs
+++ b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.rs
@@ -539,26 +539,26 @@ mod macro_escape {
 
 #[no_std]
 //~^ WARN crate-level attribute should be an inner attribute
-//~| HELP add a `!`
 mod no_std {
+    //~^ NOTE This attribute does not have an `!`, which means it is applied to this module
     mod inner { #![no_std] }
-//~^ WARN crate-level attribute should be in the root module
+//~^ WARN the `#![no_std]` attribute can only be used at the crate root
 
     #[no_std] fn f() { }
     //~^ WARN crate-level attribute should be an inner attribute
-    //~| HELP add a `!`
+    //~| NOTE This attribute does not have an `!`, which means it is applied to this function
 
     #[no_std] struct S;
     //~^ WARN crate-level attribute should be an inner attribute
-    //~| HELP add a `!`
+    //~| NOTE This attribute does not have an `!`, which means it is applied to this struct
 
     #[no_std] type T = S;
     //~^ WARN crate-level attribute should be an inner attribute
-    //~| HELP add a `!`
+    //~| NOTE This attribute does not have an `!`, which means it is applied to this type alias
 
     #[no_std] impl S { }
     //~^ WARN crate-level attribute should be an inner attribute
-    //~| HELP add a `!`
+    //~| NOTE This attribute does not have an `!`, which means it is applied to this implementation block
 }
 
 // At time of authorship, #[proc_macro_derive = "2500"] signals error
diff --git a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr
index 4a3520972bf56..3c835be5cffab 100644
--- a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr
+++ b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr
@@ -209,17 +209,6 @@ help: add a `!`
 LL | #![reexport_test_harness_main = "2900"]
    |  +
 
-warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:540:1
-   |
-LL | #[no_std]
-   | ^^^^^^^^^
-   |
-help: add a `!`
-   |
-LL | #![no_std]
-   |  +
-
 warning: attribute should be applied to an `extern` block with non-Rust ABI
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:695:1
    |
@@ -387,56 +376,6 @@ help: add a `!`
 LL |     #![reexport_test_harness_main = "2900"] impl S { }
    |      +
 
-warning: crate-level attribute should be in the root module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:544:17
-   |
-LL |     mod inner { #![no_std] }
-   |                 ^^^^^^^^^^
-
-warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:547:5
-   |
-LL |     #[no_std] fn f() { }
-   |     ^^^^^^^^^
-   |
-help: add a `!`
-   |
-LL |     #![no_std] fn f() { }
-   |      +
-
-warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:551:5
-   |
-LL |     #[no_std] struct S;
-   |     ^^^^^^^^^
-   |
-help: add a `!`
-   |
-LL |     #![no_std] struct S;
-   |      +
-
-warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:555:5
-   |
-LL |     #[no_std] type T = S;
-   |     ^^^^^^^^^
-   |
-help: add a `!`
-   |
-LL |     #![no_std] type T = S;
-   |      +
-
-warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:559:5
-   |
-LL |     #[no_std] impl S { }
-   |     ^^^^^^^^^
-   |
-help: add a `!`
-   |
-LL |     #![no_std] impl S { }
-   |      +
-
 warning: attribute should be applied to an `extern` block with non-Rust ABI
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:701:17
    |
@@ -1095,6 +1034,76 @@ LL |     #[macro_escape] impl S { }
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = help: `#[macro_escape]` can be applied to modules, extern crates, and crates
 
+warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![no_std]`
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:540:1
+   |
+LL | #[no_std]
+   | ^^^^^^^^^
+   |
+note: This attribute does not have an `!`, which means it is applied to this module
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:542:1
+   |
+LL | / mod no_std {
+LL | |
+LL | |     mod inner { #![no_std] }
+...  |
+LL | | }
+   | |_^
+
+warning: the `#![no_std]` attribute can only be used at the crate root
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:544:17
+   |
+LL |     mod inner { #![no_std] }
+   |                 ^^^^^^^^^^
+
+warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![no_std]`
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:547:5
+   |
+LL |     #[no_std] fn f() { }
+   |     ^^^^^^^^^
+   |
+note: This attribute does not have an `!`, which means it is applied to this function
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:547:15
+   |
+LL |     #[no_std] fn f() { }
+   |               ^^^^^^^^^^
+
+warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![no_std]`
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:551:5
+   |
+LL |     #[no_std] struct S;
+   |     ^^^^^^^^^
+   |
+note: This attribute does not have an `!`, which means it is applied to this struct
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:551:15
+   |
+LL |     #[no_std] struct S;
+   |               ^^^^^^^^^
+
+warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![no_std]`
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:555:5
+   |
+LL |     #[no_std] type T = S;
+   |     ^^^^^^^^^
+   |
+note: This attribute does not have an `!`, which means it is applied to this type alias
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:555:15
+   |
+LL |     #[no_std] type T = S;
+   |               ^^^^^^^^^^^
+
+warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![no_std]`
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:559:5
+   |
+LL |     #[no_std] impl S { }
+   |     ^^^^^^^^^
+   |
+note: This attribute does not have an `!`, which means it is applied to this implementation block
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:559:15
+   |
+LL |     #[no_std] impl S { }
+   |               ^^^^^^^^^^
+
 warning: `#[cold]` attribute cannot be used on modules
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:581:1
    |
diff --git a/tests/ui/lint/unused/unused-attr-duplicate.stderr b/tests/ui/lint/unused/unused-attr-duplicate.stderr
index 076a08ac6f248..3a3b450f3c55f 100644
--- a/tests/ui/lint/unused/unused-attr-duplicate.stderr
+++ b/tests/ui/lint/unused/unused-attr-duplicate.stderr
@@ -28,18 +28,6 @@ note: attribute also specified here
 LL | #[no_link]
    | ^^^^^^^^^^
 
-error: unused attribute
-  --> $DIR/unused-attr-duplicate.rs:27:1
-   |
-LL | #![no_std]
-   | ^^^^^^^^^^ help: remove this attribute
-   |
-note: attribute also specified here
-  --> $DIR/unused-attr-duplicate.rs:26:1
-   |
-LL | #![no_std]
-   | ^^^^^^^^^^
-
 error: unused attribute
   --> $DIR/unused-attr-duplicate.rs:31:1
    |
@@ -304,6 +292,18 @@ LL | #![type_length_limit = "1048576"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
+error: unused attribute
+  --> $DIR/unused-attr-duplicate.rs:27:1
+   |
+LL | #![no_std]
+   | ^^^^^^^^^^ help: remove this attribute
+   |
+note: attribute also specified here
+  --> $DIR/unused-attr-duplicate.rs:26:1
+   |
+LL | #![no_std]
+   | ^^^^^^^^^^
+
 error: unused attribute
   --> $DIR/unused-attr-duplicate.rs:29:1
    |
diff --git a/tests/ui/unpretty/exhaustive.hir.stdout b/tests/ui/unpretty/exhaustive.hir.stdout
index 924fb98ae18a8..96d85d1e7c14f 100644
--- a/tests/ui/unpretty/exhaustive.hir.stdout
+++ b/tests/ui/unpretty/exhaustive.hir.stdout
@@ -55,7 +55,7 @@ use self::prelude::*;
      */
 #[doc = "inner doc attribute"]
 #[allow(dead_code, unused_variables)]
-#[no_std]
+#[attr = NoStd]
 mod attributes {
 
     /// outer single-line doc comment

From 32722771ec2735038567545bad598d45291759a2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Sun, 24 Aug 2025 14:42:44 +0200
Subject: [PATCH 0774/1889] fixup no_{core,std} handling code

---
 clippy_utils/src/lib.rs | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 14b64eb4d54e8..e1077bdf4b1a6 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -2133,17 +2133,11 @@ pub fn std_or_core(cx: &LateContext<'_>) -> Option<&'static str> {
 }
 
 pub fn is_no_std_crate(cx: &LateContext<'_>) -> bool {
-    cx.tcx
-        .hir_attrs(hir::CRATE_HIR_ID)
-        .iter()
-        .any(|attr| attr.has_name(sym::no_std))
+    find_attr!(cx.tcx.hir_attrs(hir::CRATE_HIR_ID), AttributeKind::NoStd(..))
 }
 
 pub fn is_no_core_crate(cx: &LateContext<'_>) -> bool {
-    cx.tcx
-        .hir_attrs(hir::CRATE_HIR_ID)
-        .iter()
-        .any(|attr| attr.has_name(sym::no_core))
+    find_attr!(cx.tcx.hir_attrs(hir::CRATE_HIR_ID), AttributeKind::NoCore(..))
 }
 
 /// Check if parent of a hir node is a trait implementation block.

From faf0e14eedee063f7861eb55767099b42c6c5d62 Mon Sep 17 00:00:00 2001
From: Jonathan 'theJPster' Pallant <github@thejpster.org.uk>
Date: Sun, 7 Sep 2025 18:30:07 +0100
Subject: [PATCH 0775/1889] Update the arm-* and aarch64-* platform docs.

The Rust Embedded Devices Working Group (wg-embedded) Arm Team (t-arm)
agreed to listed as maintainers of:

* aarch64-unknown-none
* aarch64-unknown-none-softfloat
* armv7a-none-eabi
* armv7r-none-eabi
* armv7r-none-eabihf

The aarch64-unknown-none* target didn't have a page so I added it.

wg-embedded t-arm did not want to take over:

* armebv7r-none-eabi
* armebv7r-none-eabihf

So I gave them their own target page. The current maintainer remains.
---
 src/doc/rustc/src/SUMMARY.md                  |   5 +-
 src/doc/rustc/src/platform-support.md         |   6 +-
 .../platform-support/aarch64-unknown-none.md  | 121 ++++++++++++++++++
 .../src/platform-support/arm-none-eabi.md     |   6 +-
 .../platform-support/armebv7r-none-eabi.md    |  54 ++++++++
 .../src/platform-support/armv7a-none-eabi.md  |  51 ++++++++
 .../src/platform-support/armv7r-none-eabi.md  |  20 ++-
 .../platform-support/armv8r-none-eabihf.md    |  20 ++-
 8 files changed, 264 insertions(+), 19 deletions(-)
 create mode 100644 src/doc/rustc/src/platform-support/aarch64-unknown-none.md
 create mode 100644 src/doc/rustc/src/platform-support/armebv7r-none-eabi.md
 create mode 100644 src/doc/rustc/src/platform-support/armv7a-none-eabi.md

diff --git a/src/doc/rustc/src/SUMMARY.md b/src/doc/rustc/src/SUMMARY.md
index 8e378e53e518a..06de834a2f645 100644
--- a/src/doc/rustc/src/SUMMARY.md
+++ b/src/doc/rustc/src/SUMMARY.md
@@ -48,6 +48,7 @@
     - [\*-apple-visionos](platform-support/apple-visionos.md)
     - [aarch64-nintendo-switch-freestanding](platform-support/aarch64-nintendo-switch-freestanding.md)
     - [aarch64-unknown-linux-musl](platform-support/aarch64-unknown-linux-musl.md)
+    - [aarch64-unknown-none{,-softfloat}](aarch64-unknown-none.md)
     - [aarch64_be-unknown-none-softfloat](platform-support/aarch64_be-unknown-none-softfloat.md)
     - [aarch64_be-unknown-linux-musl](platform-support/aarch64_be-unknown-linux-musl.md)
     - [amdgcn-amd-amdhsa](platform-support/amdgcn-amd-amdhsa.md)
@@ -55,7 +56,9 @@
     - [arm-none-eabi](platform-support/arm-none-eabi.md)
       - [armv4t-none-eabi](platform-support/armv4t-none-eabi.md)
       - [armv5te-none-eabi](platform-support/armv5te-none-eabi.md)
-      - [armv7r-none-eabi](platform-support/armv7r-none-eabi.md)
+      - [armv7a-none-eabi{,hf}](platform-support/armv7a-none-eabi.md)
+      - [armv7r-none-eabi{,hf}](platform-support/armv7r-none-eabi.md)
+      - [armebv7r-none-eabi{,hf}](platform-support/armebv7r-none-eabi.md)
       - [armv8r-none-eabihf](platform-support/armv8r-none-eabihf.md)
       - [thumbv6m-none-eabi](./platform-support/thumbv6m-none-eabi.md)
       - [thumbv7em-none-eabi\*](./platform-support/thumbv7em-none-eabi.md)
diff --git a/src/doc/rustc/src/platform-support.md b/src/doc/rustc/src/platform-support.md
index 6c5b48d8c8f5c..3c91d12505771 100644
--- a/src/doc/rustc/src/platform-support.md
+++ b/src/doc/rustc/src/platform-support.md
@@ -156,15 +156,15 @@ target | std | notes
 `arm-unknown-linux-musleabi` | ✓ | Armv6 Linux with musl 1.2.3
 `arm-unknown-linux-musleabihf` | ✓ | Armv6 Linux with musl 1.2.3, hardfloat
 [`arm64ec-pc-windows-msvc`](platform-support/arm64ec-pc-windows-msvc.md) | ✓ | Arm64EC Windows MSVC
-[`armebv7r-none-eabi`](platform-support/armv7r-none-eabi.md) | * | Bare Armv7-R, Big Endian
-[`armebv7r-none-eabihf`](platform-support/armv7r-none-eabi.md) | * | Bare Armv7-R, Big Endian, hardfloat
+[`armebv7r-none-eabi`](platform-support/armebv7r-none-eabi.md) | * | Bare Armv7-R, Big Endian
+[`armebv7r-none-eabihf`](platform-support/armebv7r-none-eabi.md) | * | Bare Armv7-R, Big Endian, hardfloat
 [`armv5te-unknown-linux-gnueabi`](platform-support/armv5te-unknown-linux-gnueabi.md) | ✓ | Armv5TE Linux (kernel 4.4+, glibc 2.23)
 `armv5te-unknown-linux-musleabi` | ✓ | Armv5TE Linux with musl 1.2.3
 [`armv7-linux-androideabi`](platform-support/android.md) | ✓ | Armv7-A Android
 `armv7-unknown-linux-gnueabi` | ✓ | Armv7-A Linux (kernel 4.15+, glibc 2.27)
 `armv7-unknown-linux-musleabi` | ✓ | Armv7-A Linux with musl 1.2.3
 `armv7-unknown-linux-musleabihf` | ✓ | Armv7-A Linux with musl 1.2.3, hardfloat
-[`armv7a-none-eabi`](platform-support/arm-none-eabi.md) | * | Bare Armv7-A
+[`armv7a-none-eabi`](platform-support/armv7a-none-eabi.md) | * | Bare Armv7-A
 [`armv7r-none-eabi`](platform-support/armv7r-none-eabi.md) | * | Bare Armv7-R
 [`armv7r-none-eabihf`](platform-support/armv7r-none-eabi.md) | * | Bare Armv7-R, hardfloat
 `i586-unknown-linux-gnu` | ✓ | 32-bit Linux (kernel 3.2+, glibc 2.17, original Pentium) [^x86_32-floats-x87]
diff --git a/src/doc/rustc/src/platform-support/aarch64-unknown-none.md b/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
new file mode 100644
index 0000000000000..0c1d477961984
--- /dev/null
+++ b/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
@@ -0,0 +1,121 @@
+# `aarch64-unknown-none`
+
+**Tier: 2**
+
+Bare-metal target for CPUs in the Armv8-A architecture family, running in AArch64 mode.
+
+For the AArch32 mode carried over from Armv7-A, see
+[`armv7a-none-eabi`](armv7a-none-eabi.md) instead.
+
+Processors in this family include the [Arm Cortex-A35, 53, 76, etc][aarch64-cpus].
+
+[aarch64-cpus]: https://en.wikipedia.org/wiki/Comparison_of_ARM_processors#ARMv8-A
+
+## Target maintainers
+
+* [Rust Embedded Devices Working Group Arm Team]
+
+[Rust Embedded Devices Working Group Arm Team]: https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team
+
+## Target CPU and Target Feature options
+
+It is possible to tell Rust (or LLVM) that you have a specific model of Arm
+processor, using the [`-Ctarget-cpu`][target-cpu] option. You can also control
+whether Rust (or LLVM) will include instructions that target optional hardware
+features, e.g. hardware floating-point, or Advanced SIMD operations, using
+[`-Ctarget-feature`][target-feature].
+
+It is important to note that selecting a *target-cpu* will typically enable
+*all* the optional features available from Arm on that model of CPU and your
+particular implementation of that CPU may not have those features available.
+In that case, you can use `-Ctarget-feature=-option` to turn off the specific
+CPU features you do not have available, leaving you with the optimized
+instruction scheduling and support for the features you do have. More details
+are available in the detailed target-specific documentation.
+
+<div class="warning">
+
+Many target-features are currently unstable and subject to change, and
+if you use them you should disassemble the compiler output and manually inspect
+it to ensure only appropriate instructions for your CPU have been generated.
+
+</div>
+
+If you wish to use the *target-cpu* and *target-feature* options, you can add
+them to your `.cargo/config.toml` file alongside any other flags your project
+uses (likely linker related ones):
+
+```toml
+rustflags = [
+  # Usual Arm bare-metal linker setup
+  "-Clink-arg=-Tlink.x",
+  "-Clink-arg=--nmagic",
+  # tell Rust we have a Cortex-A72
+  "-Ctarget-cpu=cortex-a72",
+]
+
+[build]
+target = "aarch64-unknown-none"
+```
+
+[target-cpu]: https://doc.rust-lang.org/rustc/codegen-options/index.html#target-cpu
+[target-feature]: https://doc.rust-lang.org/rustc/codegen-options/index.html#target-feature
+
+## Requirements
+
+These targets are cross-compiled and use static linking.
+
+By default, the `lld` linker included with Rust will be used; however, you may
+want to use the GNU linker instead. This can be obtained for Windows/Mac/Linux
+from the [Arm Developer Website][arm-gnu-toolchain], or possibly from your OS's
+package manager. To use it, add the following to your `.cargo/config.toml`:
+
+```toml
+[target.<your-target>]
+linker = "arm-none-eabi-ld"
+```
+
+The GNU linker can also be used by specifying `aarch64-none-gcc` as the
+linker. This is needed when using GCC's link time optimization.
+
+These targets don't provide a linker script, so you'll need to bring your own
+according to the specific device you are using. Pass
+`-Clink-arg=-Tyour_script.ld` as a rustc argument to make the linker use
+`your_script.ld` during linking.
+
+All AArch64 processors include an FPU. The difference between the `-none` and
+`-none-softfloat` targets is whether the FPU is used for passing function arguments.
+You may prefer the `-softfloat` target when writing a kernel or interfacing with
+pre-compiled binaries that use the soft-float ABI.
+
+When using the hardfloat targets, the minimum floating-point features assumed
+are those of the `fp-armv8`, which excludes NEON SIMD support. If your
+processor supports a different set of floating-point features than the default
+expectations of `fp-armv8`, then these should also be enabled or disabled as
+needed with `-C target-feature=(+/-)`. For example,
+`-Ctarget-feature=+neon-fp-armv8`.
+
+[arm-gnu-toolchain]: https://developer.arm.com/Tools%20and%20Software/GNU%20Toolchain
+
+## Testing
+
+This is a cross-compiled target that you will need to emulate during testing.
+
+The exact emulator that you'll need depends on the specific device you want to
+run your code on.
+
+## Start-up and Low-Level Code
+
+The [Rust Embedded Devices Working Group Arm Team] maintain the
+[`aarch64-cpu`], which may be useful for writing bare-metal code using this
+target.
+
+The *TrustedFirmware* group also maintain [Rust crates for this
+target](https://github.com/ArmFirmwareCrates).
+
+[`aarch64-cpu`]: https://docs.rs/aarch64-cpu
+
+## Cross-compilation toolchains and C code
+
+This target supports C code compiled with the `aarch64-unknown-none` target
+triple and a suitable `-march` or `-mcpu` flag.
diff --git a/src/doc/rustc/src/platform-support/arm-none-eabi.md b/src/doc/rustc/src/platform-support/arm-none-eabi.md
index 9732df4be7f72..aaa80e429718e 100644
--- a/src/doc/rustc/src/platform-support/arm-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/arm-none-eabi.md
@@ -12,10 +12,10 @@ their own document.
 ### Tier 2 Target List
 
 - Arm A-Profile Architectures
-  - `armv7a-none-eabi`
+  - [`armv7a-none-eabi`](armv7a-none-eabi.md)
 - Arm R-Profile Architectures
   - [`armv7r-none-eabi` and `armv7r-none-eabihf`](armv7r-none-eabi.md)
-  - [`armebv7r-none-eabi` and `armebv7r-none-eabihf`](armv7r-none-eabi.md)
+  - [`armebv7r-none-eabi` and `armebv7r-none-eabihf`](armebv7r-none-eabi.md)
 - Arm M-Profile Architectures
   - [`thumbv6m-none-eabi`](thumbv6m-none-eabi.md)
   - [`thumbv7m-none-eabi`](thumbv7m-none-eabi.md)
@@ -28,7 +28,7 @@ their own document.
 ### Tier 3 Target List
 
 - Arm A-Profile Architectures
-  - `armv7a-none-eabihf`
+  - [`armv7a-none-eabihf`](armv7a-none-eabi.md)
 - Arm R-Profile Architectures
   - [`armv8r-none-eabihf`](armv8r-none-eabihf.md)
 - Arm M-Profile Architectures
diff --git a/src/doc/rustc/src/platform-support/armebv7r-none-eabi.md b/src/doc/rustc/src/platform-support/armebv7r-none-eabi.md
new file mode 100644
index 0000000000000..a5efd4adb9733
--- /dev/null
+++ b/src/doc/rustc/src/platform-support/armebv7r-none-eabi.md
@@ -0,0 +1,54 @@
+# `armebv7r-none-eabi` and `armebv7r-none-eabihf`
+
+**Tier: 2**
+
+Bare-metal target for CPUs in the Armv7-R architecture family running in Big
+Endian mode. These processors support dual ARM/Thumb mode, with ARM mode as
+the default.
+
+**NOTE:** You should almost always prefer the [little-endian
+versions](armv7r-none-eabi.md) of these target. Big Endian Arm systems are
+highly unusual.
+
+Processors in this family include the [Arm Cortex-R4, 5, 7, and 8][cortex-r].
+
+See [`arm-none-eabi`](arm-none-eabi.md) for information applicable to all
+`arm-none-eabi` targets.
+
+[cortex-r]: https://en.wikipedia.org/wiki/ARM_Cortex-R
+
+## Target maintainers
+
+* [@chrisnc](https://github.com/chrisnc)
+
+## Requirements
+
+Note that some variants of the Cortex-R have both big-endian instructions and
+data. This configuration is known as BE-32, while data-only big-endianness is
+known as BE-8. To build programs for BE-32 processors, the GNU linker must be
+used with the `-mbe32` option. See [ARM Cortex-R Series Programmer's Guide:
+Endianness][endianness] for more details about different endian modes.
+
+When using the hardfloat targets, the minimum floating-point features assumed
+are those of the `vfpv3-d16`, which includes single- and double-precision, with
+16 double-precision registers. This floating-point unit appears in Cortex-R4F
+and Cortex-R5F processors. See [VFP in the Cortex-R processors][vfp]
+for more details on the possible FPU variants.
+
+If your processor supports a different set of floating-point features than the
+default expectations of `vfpv3-d16`, then these should also be enabled or
+disabled as needed with `-C target-feature=(+/-)`.
+
+[endianness]: https://developer.arm.com/documentation/den0042/a/Coding-for-Cortex-R-Processors/Endianness
+
+[vfp]: https://developer.arm.com/documentation/den0042/a/Floating-Point/Floating-point-basics-and-the-IEEE-754-standard/VFP-in-the-Cortex-R-processors
+
+## Start-up and Low-Level Code
+
+The [Rust Embedded Devices Working Group Arm Team] maintain the [`cortex-ar`]
+and [`cortex-r-rt`] crates, which may be useful for writing bare-metal code
+using this target. Those crates include several examples which run in QEMU and
+build using these targets.
+
+[`cortex-ar`]: https://docs.rs/cortex-ar
+[`cortex-r-rt`]: https://docs.rs/cortex-r-rt
diff --git a/src/doc/rustc/src/platform-support/armv7a-none-eabi.md b/src/doc/rustc/src/platform-support/armv7a-none-eabi.md
new file mode 100644
index 0000000000000..9a1c6316c468d
--- /dev/null
+++ b/src/doc/rustc/src/platform-support/armv7a-none-eabi.md
@@ -0,0 +1,51 @@
+# `armv7a-none-eabi` and `armv7a-none-eabihf`
+
+**Tier: 2** for `armv7a-none-eabi`
+**Tier: 3** for `armv7a-none-eabihf`
+
+Bare-metal target for CPUs in the Armv7-A architecture family, supporting
+dual ARM/Thumb mode, with ARM mode as the default.
+
+Note, this is for processors running in AArch32 mode. For the AArch64 mode
+added in Armv8-A, see [`aarch64-unknown-none`](aarch64-unknown-none.md) instead.
+
+Processors in this family include the [Arm Cortex-A5, 8, 32, etc][cortex-a].
+
+See [`arm-none-eabi`](arm-none-eabi.md) for information applicable to all
+`arm-none-eabi` targets.
+
+[cortex-a]: https://en.wikipedia.org/wiki/ARM_Cortex-A
+
+## Target maintainers
+
+* [Rust Embedded Devices Working Group Arm Team]
+
+[Rust Embedded Devices Working Group Arm Team]: https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team
+
+## Requirements
+
+All Armv7-A processors include an FPU (a VFPv3 or a VFPv4). The difference
+between the `-eabi` and `-eabihf` targets is whether the FPU is used for
+passing function arguments. You may prefer the `-eabi` soft-float target when
+
+When using the hardfloat targets, the minimum floating-point features assumed
+are those of the `vfpv3-d16`, which includes single- and double-precision,
+with 16 double-precision registers. This floating-point unit appears in
+Cortex-A8 and Cortex-A8 processors. See [VFP in the Cortex-A processors][vfp]
+for more details on the possible FPU variants.
+
+If your processor supports a different set of floating-point features than the
+default expectations of `vfpv3-d16`, then these should also be enabled or
+disabled as needed with `-C target-feature=(+/-)`.
+
+[vfp]: https://developer.arm.com/documentation/den0013/0400/Floating-Point/Floating-point-basics-and-the-IEEE-754-standard/ARM-VFP
+
+## Start-up and Low-Level Code
+
+The [Rust Embedded Devices Working Group Arm Team] maintain the [`cortex-ar`]
+and [`cortex-a-rt`] crates, which may be useful for writing bare-metal code
+using this target. Those crates include several examples which run in QEMU and
+build using these targets.
+
+[`cortex-ar`]: https://docs.rs/cortex-ar
+[`cortex-a-rt`]: https://docs.rs/cortex-a-rt
diff --git a/src/doc/rustc/src/platform-support/armv7r-none-eabi.md b/src/doc/rustc/src/platform-support/armv7r-none-eabi.md
index 88b2689dcf0f8..7d621e5c827d2 100644
--- a/src/doc/rustc/src/platform-support/armv7r-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/armv7r-none-eabi.md
@@ -1,4 +1,4 @@
-# `arm(eb)?v7r-none-eabi(hf)?`
+# `armv7r-none-eabi` and `armv7r-none-eabihf`
 
 **Tier: 2**
 
@@ -7,8 +7,6 @@ dual ARM/Thumb mode, with ARM mode as the default.
 
 Processors in this family include the [Arm Cortex-R4, 5, 7, and 8][cortex-r].
 
-The `eb` versions of this target generate code for big-endian processors.
-
 See [`arm-none-eabi`](arm-none-eabi.md) for information applicable to all
 `arm-none-eabi` targets.
 
@@ -16,7 +14,10 @@ See [`arm-none-eabi`](arm-none-eabi.md) for information applicable to all
 
 ## Target maintainers
 
-[@chrisnc](https://github.com/chrisnc)
+* [@chrisnc](https://github.com/chrisnc)
+* [Rust Embedded Devices Working Group Arm Team]
+
+[Rust Embedded Devices Working Group Arm Team]: https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team
 
 ## Requirements
 
@@ -41,7 +42,12 @@ disabled as needed with `-C target-feature=(+/-)`.
 
 [vfp]: https://developer.arm.com/documentation/den0042/a/Floating-Point/Floating-point-basics-and-the-IEEE-754-standard/VFP-in-the-Cortex-R-processors
 
-## Cross-compilation toolchains and C code
+## Start-up and Low-Level Code
+
+The [Rust Embedded Devices Working Group Arm Team] maintain the [`cortex-ar`]
+and [`cortex-r-rt`] crates, which may be useful for writing bare-metal code
+using this target. Those crates include several examples which run in QEMU and
+build using these targets.
 
-This target supports C code compiled with the `arm-none-eabi` target triple and
-`-march=armv7-r` or a suitable `-mcpu` flag.
+[`cortex-ar`]: https://docs.rs/cortex-ar
+[`cortex-r-rt`]: https://docs.rs/cortex-r-rt
diff --git a/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md b/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md
index 569d8802ebebe..ed0102f48e081 100644
--- a/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md
+++ b/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md
@@ -16,7 +16,10 @@ See [`arm-none-eabi`](arm-none-eabi.md) for information applicable to all
 
 ## Target maintainers
 
-[@chrisnc](https://github.com/chrisnc)
+* [@chrisnc](https://github.com/chrisnc)
+* [Rust Embedded Devices Working Group Arm Team]
+
+[Rust Embedded Devices Working Group Arm Team]: https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team
 
 ## Requirements
 
@@ -34,7 +37,14 @@ Technical Reference Manual for more details.
 
 [fpu]: https://developer.arm.com/documentation/100026/0104/Advanced-SIMD-and-floating-point-support/About-the-Advanced-SIMD-and-floating-point-support
 
-## Cross-compilation toolchains and C code
-
-This target supports C code compiled with the `arm-none-eabi` target triple and
-`-march=armv8-r` or a suitable `-mcpu` flag.
+### Table of supported CPUs for `armv8r-none-eabihf`
+
+| CPU         | FPU | Neon | Target CPU       | Target Features    |
+|:----------- | --- |:---- |:---------------- |:------------------ |
+| Any         | SP  | No   | None             | None               |
+| Cortex-R52  | SP  | No   | `cortex-r52`     | `-fp64,-d32,-neon` |
+| Cortex-R52  | DP  | No   | `cortex-r52`     | `-neon`            |
+| Cortex-R52  | DP  | Yes  | `cortex-r52`     | None               |
+| Cortex-R52+ | SP  | No   | `cortex-r52plus` | `-fp64,-d32,-neon` |
+| Cortex-R52+ | DP  | No   | `cortex-r52plus` | `-neon`            |
+| Cortex-R52+ | DP  | Yes  | `cortex-r52plus` | None               |

From f1abb70836aa2eee2119b0a9a23795883dc99e43 Mon Sep 17 00:00:00 2001
From: Jonathan 'theJPster' Pallant <github@thejpster.org.uk>
Date: Wed, 10 Sep 2025 20:30:41 +0100
Subject: [PATCH 0776/1889] Pick up changes from robamu that I missed.

From https://github.com/thejpster/rust/pull/1.
---
 src/doc/rustc/src/SUMMARY.md                  |  1 -
 .../src/platform-support/armv7a-none-eabi.md  | 38 ++++++++++++++-----
 .../src/platform-support/armv7r-none-eabi.md  |  7 ----
 3 files changed, 28 insertions(+), 18 deletions(-)

diff --git a/src/doc/rustc/src/SUMMARY.md b/src/doc/rustc/src/SUMMARY.md
index 06de834a2f645..e866f3c0556ab 100644
--- a/src/doc/rustc/src/SUMMARY.md
+++ b/src/doc/rustc/src/SUMMARY.md
@@ -48,7 +48,6 @@
     - [\*-apple-visionos](platform-support/apple-visionos.md)
     - [aarch64-nintendo-switch-freestanding](platform-support/aarch64-nintendo-switch-freestanding.md)
     - [aarch64-unknown-linux-musl](platform-support/aarch64-unknown-linux-musl.md)
-    - [aarch64-unknown-none{,-softfloat}](aarch64-unknown-none.md)
     - [aarch64_be-unknown-none-softfloat](platform-support/aarch64_be-unknown-none-softfloat.md)
     - [aarch64_be-unknown-linux-musl](platform-support/aarch64_be-unknown-linux-musl.md)
     - [amdgcn-amd-amdhsa](platform-support/amdgcn-amd-amdhsa.md)
diff --git a/src/doc/rustc/src/platform-support/armv7a-none-eabi.md b/src/doc/rustc/src/platform-support/armv7a-none-eabi.md
index 9a1c6316c468d..77c463697bf6e 100644
--- a/src/doc/rustc/src/platform-support/armv7a-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/armv7a-none-eabi.md
@@ -24,28 +24,46 @@ See [`arm-none-eabi`](arm-none-eabi.md) for information applicable to all
 
 ## Requirements
 
-All Armv7-A processors include an FPU (a VFPv3 or a VFPv4). The difference
-between the `-eabi` and `-eabihf` targets is whether the FPU is used for
-passing function arguments. You may prefer the `-eabi` soft-float target when
+Almost all Armv7-A processors include an FPU (a VFPv3 or a VFPv4). The
+difference between the `-eabi` and `-eabihf` targets is whether the FPU is
+used for passing function arguments. You may prefer the `-eabi` soft-float
+target when the processor does not have a floating point unit or the compiled
+code should not use the floating point unit.
 
 When using the hardfloat targets, the minimum floating-point features assumed
-are those of the `vfpv3-d16`, which includes single- and double-precision,
-with 16 double-precision registers. This floating-point unit appears in
-Cortex-A8 and Cortex-A8 processors. See [VFP in the Cortex-A processors][vfp]
-for more details on the possible FPU variants.
+are those of the VFPv3-D16, which includes single- and double-precision, with
+16 double-precision registers. This floating-point unit appears in Cortex-A8
+and Cortex-A9 processors. See [VFP in the Cortex-A processors][vfp] for more
+details on the possible FPU variants.
 
 If your processor supports a different set of floating-point features than the
-default expectations of `vfpv3-d16`, then these should also be enabled or
+default expectations of VFPv3-D16, then these should also be enabled or
 disabled as needed with `-C target-feature=(+/-)`.
 
+In general, the following four combinations are possible:
+
+- VFPv3-D16, target feature `+vfp3` and `-d32`
+- VFPv3-D32, target feature `+vfp3` and `+d32`
+- VFPv4-D16, target feature `+vfp4` and `-d32`
+- VFPv4-D32, target feature `+vfp4` and `+d32`
+
+An Armv7-A processor may optionally include a NEON hardware unit which
+provides Single Instruction Multiple Data (SIMD) operations. The
+implementation of this unit implies VFPv3-D32. The target feature `+neon` may
+be added to inform the compiler about the availability of NEON.
+
+You can refer to the [arm-none-eabi](arm-none-eabi.md) documentation for a
+generic guide on target feature and target CPU specification and how to enable
+and disable them via `.cargo/config.toml` file.
+
 [vfp]: https://developer.arm.com/documentation/den0013/0400/Floating-Point/Floating-point-basics-and-the-IEEE-754-standard/ARM-VFP
 
 ## Start-up and Low-Level Code
 
 The [Rust Embedded Devices Working Group Arm Team] maintain the [`cortex-ar`]
 and [`cortex-a-rt`] crates, which may be useful for writing bare-metal code
-using this target. Those crates include several examples which run in QEMU and
-build using these targets.
+using this target. The [`cortex-ar` repository](https://github.com/rust-embedded/cortex-ar)
+includes several examples which run in QEMU and build using these targets.
 
 [`cortex-ar`]: https://docs.rs/cortex-ar
 [`cortex-a-rt`]: https://docs.rs/cortex-a-rt
diff --git a/src/doc/rustc/src/platform-support/armv7r-none-eabi.md b/src/doc/rustc/src/platform-support/armv7r-none-eabi.md
index 7d621e5c827d2..36980a36b19a1 100644
--- a/src/doc/rustc/src/platform-support/armv7r-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/armv7r-none-eabi.md
@@ -21,13 +21,6 @@ See [`arm-none-eabi`](arm-none-eabi.md) for information applicable to all
 
 ## Requirements
 
-When using the big-endian version of this target, note that some variants of
-the Cortex-R have both big-endian instructions and data. This configuration is
-known as BE-32, while data-only big-endianness is known as BE-8. To build
-programs for BE-32 processors, the GNU linker must be used with the `-mbe32`
-option. See [ARM Cortex-R Series Programmer's Guide: Endianness][endianness]
-for more details about different endian modes.
-
 When using the hardfloat targets, the minimum floating-point features assumed
 are those of the `vfpv3-d16`, which includes single- and double-precision, with
 16 double-precision registers. This floating-point unit appears in Cortex-R4F

From b152974301cc24b9003674935e7492fb46d6f299 Mon Sep 17 00:00:00 2001
From: Sasha Pourcelot <sasha.pourcelot@protonmail.com>
Date: Wed, 3 Sep 2025 15:23:07 +0200
Subject: [PATCH 0777/1889] tidy: check that error messages don't start with a
 capitalized letter

---
 compiler/rustc_codegen_ssa/messages.ftl       |  2 +-
 compiler/rustc_passes/messages.ftl            |  2 +-
 src/tools/tidy/src/fluent_lowercase.rs        | 64 +++++++++++++++++++
 src/tools/tidy/src/lib.rs                     |  1 +
 src/tools/tidy/src/main.rs                    |  1 +
 .../raw-dylib/windows/dlltool-failed.rs       |  2 +-
 .../raw-dylib/windows/dlltool-failed.stderr   |  2 +-
 7 files changed, 70 insertions(+), 4 deletions(-)
 create mode 100644 src/tools/tidy/src/fluent_lowercase.rs

diff --git a/compiler/rustc_codegen_ssa/messages.ftl b/compiler/rustc_codegen_ssa/messages.ftl
index dd688b8b34541..1dd65d38a2be7 100644
--- a/compiler/rustc_codegen_ssa/messages.ftl
+++ b/compiler/rustc_codegen_ssa/messages.ftl
@@ -31,7 +31,7 @@ codegen_ssa_cpu_required = target requires explicitly specifying a cpu with `-C
 codegen_ssa_create_temp_dir = couldn't create a temp dir: {$error}
 
 codegen_ssa_dlltool_fail_import_library =
-    Dlltool could not create import library with {$dlltool_path} {$dlltool_args}:
+    dlltool could not create import library with {$dlltool_path} {$dlltool_args}:
     {$stdout}
     {$stderr}
 
diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index afd08319738df..1dd96240f0a94 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -75,7 +75,7 @@ passes_const_stable_not_stable =
     .label = attribute specified here
 
 passes_custom_mir_incompatible_dialect_and_phase =
-    The {$dialect} dialect is not compatible with the {$phase} phase
+    the {$dialect} dialect is not compatible with the {$phase} phase
     .dialect_span = this dialect...
     .phase_span = ... is not compatible with this phase
 
diff --git a/src/tools/tidy/src/fluent_lowercase.rs b/src/tools/tidy/src/fluent_lowercase.rs
new file mode 100644
index 0000000000000..13f0319909e17
--- /dev/null
+++ b/src/tools/tidy/src/fluent_lowercase.rs
@@ -0,0 +1,64 @@
+//! Checks that the error messages start with a lowercased letter (except when allowed to).
+
+use std::path::Path;
+
+use fluent_syntax::ast::{Entry, Message, PatternElement};
+
+use crate::walk::{filter_dirs, walk};
+
+#[rustfmt::skip]
+const ALLOWED_CAPITALIZED_WORDS: &[&str] = &[
+    // tidy-alphabetical-start
+    "ABI",
+    "ABIs",
+    "ADT",
+    "C",
+    "CGU",
+    "Ferris",
+    "MIR",
+    "OK",
+    "Rust",
+    "VS", // VS Code
+    // tidy-alphabetical-end
+];
+
+fn filter_fluent(path: &Path) -> bool {
+    if let Some(ext) = path.extension() { ext.to_str() != Some("ftl") } else { true }
+}
+
+fn is_allowed_capitalized_word(msg: &str) -> bool {
+    ALLOWED_CAPITALIZED_WORDS.iter().any(|word| {
+        msg.strip_prefix(word)
+            .map(|tail| tail.chars().next().map(|c| c == '-' || c.is_whitespace()).unwrap_or(true))
+            .unwrap_or_default()
+    })
+}
+
+fn check_lowercase(filename: &str, contents: &str, bad: &mut bool) {
+    let (Ok(parse) | Err((parse, _))) = fluent_syntax::parser::parse(contents);
+
+    for entry in &parse.body {
+        if let Entry::Message(msg) = entry
+            && let Message { value: Some(pattern), .. } = msg
+            && let [first_pattern, ..] = &pattern.elements[..]
+            && let PatternElement::TextElement { value } = first_pattern
+            && value.chars().next().is_some_and(char::is_uppercase)
+            && !is_allowed_capitalized_word(value)
+        {
+            tidy_error!(
+                bad,
+                "{filename}: message `{value}` starts with an uppercase letter. Fix it or add it to `ALLOWED_CAPITALIZED_WORDS`"
+            );
+        }
+    }
+}
+
+pub fn check(path: &Path, bad: &mut bool) {
+    walk(
+        path,
+        |path, is_dir| filter_dirs(path) || (!is_dir && filter_fluent(path)),
+        &mut |ent, contents| {
+            check_lowercase(ent.path().to_str().unwrap(), contents, bad);
+        },
+    );
+}
diff --git a/src/tools/tidy/src/lib.rs b/src/tools/tidy/src/lib.rs
index 37713cbf75e9b..2a9c3963d2d86 100644
--- a/src/tools/tidy/src/lib.rs
+++ b/src/tools/tidy/src/lib.rs
@@ -257,6 +257,7 @@ pub mod extra_checks;
 pub mod features;
 pub mod filenames;
 pub mod fluent_alphabetical;
+pub mod fluent_lowercase;
 pub mod fluent_period;
 mod fluent_used;
 pub mod gcc_submodule;
diff --git a/src/tools/tidy/src/main.rs b/src/tools/tidy/src/main.rs
index bfe30258915ea..f9e82341b7aa5 100644
--- a/src/tools/tidy/src/main.rs
+++ b/src/tools/tidy/src/main.rs
@@ -121,6 +121,7 @@ fn main() {
         check!(error_codes, &root_path, &[&compiler_path, &librustdoc_path], verbose, &ci_info);
         check!(fluent_alphabetical, &compiler_path, bless);
         check!(fluent_period, &compiler_path);
+        check!(fluent_lowercase, &compiler_path);
         check!(target_policy, &root_path);
         check!(gcc_submodule, &root_path, &compiler_path);
 
diff --git a/tests/ui/linkage-attr/raw-dylib/windows/dlltool-failed.rs b/tests/ui/linkage-attr/raw-dylib/windows/dlltool-failed.rs
index 92cb60bb16d48..dac878c1cd992 100644
--- a/tests/ui/linkage-attr/raw-dylib/windows/dlltool-failed.rs
+++ b/tests/ui/linkage-attr/raw-dylib/windows/dlltool-failed.rs
@@ -20,4 +20,4 @@ pub fn lib_main() {
     unsafe { f(42); }
 }
 
-//~? ERROR Dlltool could not create import library with
+//~? ERROR dlltool could not create import library with
diff --git a/tests/ui/linkage-attr/raw-dylib/windows/dlltool-failed.stderr b/tests/ui/linkage-attr/raw-dylib/windows/dlltool-failed.stderr
index 90cca83d1c1f5..5f3c29c3a212a 100644
--- a/tests/ui/linkage-attr/raw-dylib/windows/dlltool-failed.stderr
+++ b/tests/ui/linkage-attr/raw-dylib/windows/dlltool-failed.stderr
@@ -1,4 +1,4 @@
-error: Dlltool could not create import library with $DLLTOOL -d $DEF_FILE -D foo.dll -l $LIB_FILE $TARGET_MACHINE $ASM_FLAGS --no-leading-underscore $TEMP_PREFIX:
+error: dlltool could not create import library with $DLLTOOL -d $DEF_FILE -D foo.dll -l $LIB_FILE $TARGET_MACHINE $ASM_FLAGS --no-leading-underscore $TEMP_PREFIX:
        
        $DLLTOOL: Syntax error in def file $DEF_FILE:1␍
 

From 3b2178336ff01d1db306be9ac48dc6eadc00763a Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 10 Sep 2025 18:15:59 +0200
Subject: [PATCH 0778/1889] s390x: mark soft-float target feature as
 incompatible

---
 compiler/rustc_target/src/target_features.rs  |  8 ++++++
 tests/ui/abi/simd-abi-checks-s390x.rs         |  1 +
 tests/ui/abi/simd-abi-checks-s390x.z10.stderr | 20 +++++++-------
 ...simd-abi-checks-s390x.z13_no_vector.stderr | 20 +++++++-------
 ...imd-abi-checks-s390x.z13_soft_float.stderr | 27 +++++++++++--------
 5 files changed, 45 insertions(+), 31 deletions(-)

diff --git a/compiler/rustc_target/src/target_features.rs b/compiler/rustc_target/src/target_features.rs
index 4c1b8c99426b6..dc70089c385fe 100644
--- a/compiler/rustc_target/src/target_features.rs
+++ b/compiler/rustc_target/src/target_features.rs
@@ -849,6 +849,7 @@ const IBMZ_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
     ("miscellaneous-extensions-3", Unstable(sym::s390x_target_feature), &[]),
     ("miscellaneous-extensions-4", Unstable(sym::s390x_target_feature), &[]),
     ("nnp-assist", Unstable(sym::s390x_target_feature), &["vector"]),
+    ("soft-float", Forbidden { reason: "currently unsupported ABI-configuration feature" }, &[]),
     ("transactional-execution", Unstable(sym::s390x_target_feature), &[]),
     ("vector", Unstable(sym::s390x_target_feature), &[]),
     ("vector-enhancements-1", Unstable(sym::s390x_target_feature), &["vector"]),
@@ -1177,6 +1178,13 @@ impl Target {
                     _ => unreachable!(),
                 }
             }
+            "s390x" => {
+                // We don't currently support a softfloat target on this architecture.
+                // As usual, we have to reject swapping the `soft-float` target feature.
+                // The "vector" target feature does not affect the ABI for floats
+                // because the vector and float registers overlap.
+                FeatureConstraints { required: &[], incompatible: &["soft-float"] }
+            }
             _ => NOTHING,
         }
     }
diff --git a/tests/ui/abi/simd-abi-checks-s390x.rs b/tests/ui/abi/simd-abi-checks-s390x.rs
index 877a25e8b083f..75232a66ab091 100644
--- a/tests/ui/abi/simd-abi-checks-s390x.rs
+++ b/tests/ui/abi/simd-abi-checks-s390x.rs
@@ -8,6 +8,7 @@
 // FIXME: +soft-float itself doesn't set -vector
 //@[z13_soft_float] compile-flags: --target s390x-unknown-linux-gnu -C target-cpu=z13 -C target-feature=-vector,+soft-float
 //@[z13_soft_float] needs-llvm-components: systemz
+//[z13_soft_float]~? WARN must be disabled to ensure that the ABI of the current target can be implemented correctly
 
 #![feature(no_core, repr_simd, s390x_target_feature)]
 #![no_core]
diff --git a/tests/ui/abi/simd-abi-checks-s390x.z10.stderr b/tests/ui/abi/simd-abi-checks-s390x.z10.stderr
index c1c4e90f3cf89..e1cfa373c63cb 100644
--- a/tests/ui/abi/simd-abi-checks-s390x.z10.stderr
+++ b/tests/ui/abi/simd-abi-checks-s390x.z10.stderr
@@ -1,5 +1,5 @@
 error: this function definition uses SIMD vector type `i8x8` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:38:1
+  --> $DIR/simd-abi-checks-s390x.rs:39:1
    |
 LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
@@ -7,7 +7,7 @@ LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
    = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
 
 error: this function definition uses SIMD vector type `i8x16` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:43:1
+  --> $DIR/simd-abi-checks-s390x.rs:44:1
    |
 LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
@@ -15,7 +15,7 @@ LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
    = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
 
 error: this function definition uses SIMD vector type `TransparentWrapper<i8x8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:89:1
+  --> $DIR/simd-abi-checks-s390x.rs:90:1
    |
 LL | / extern "C" fn vector_transparent_wrapper_ret_small(
 LL | |     x: &TransparentWrapper<i8x8>,
@@ -25,7 +25,7 @@ LL | | ) -> TransparentWrapper<i8x8> {
    = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
 
 error: this function definition uses SIMD vector type `TransparentWrapper<i8x16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:96:1
+  --> $DIR/simd-abi-checks-s390x.rs:97:1
    |
 LL | / extern "C" fn vector_transparent_wrapper_ret(
 LL | |     x: &TransparentWrapper<i8x16>,
@@ -35,7 +35,7 @@ LL | | ) -> TransparentWrapper<i8x16> {
    = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
 
 error: this function definition uses SIMD vector type `i8x8` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:111:1
+  --> $DIR/simd-abi-checks-s390x.rs:112:1
    |
 LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
@@ -43,7 +43,7 @@ LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 {
    = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
 
 error: this function definition uses SIMD vector type `i8x16` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:116:1
+  --> $DIR/simd-abi-checks-s390x.rs:117:1
    |
 LL | extern "C" fn vector_arg(x: i8x16) -> i64 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
@@ -51,7 +51,7 @@ LL | extern "C" fn vector_arg(x: i8x16) -> i64 {
    = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
 
 error: this function definition uses SIMD vector type `Wrapper<i8x8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:127:1
+  --> $DIR/simd-abi-checks-s390x.rs:128:1
    |
 LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
@@ -59,7 +59,7 @@ LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
    = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
 
 error: this function definition uses SIMD vector type `Wrapper<i8x16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:132:1
+  --> $DIR/simd-abi-checks-s390x.rs:133:1
    |
 LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
@@ -67,7 +67,7 @@ LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
    = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
 
 error: this function definition uses SIMD vector type `TransparentWrapper<i8x8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:143:1
+  --> $DIR/simd-abi-checks-s390x.rs:144:1
    |
 LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
@@ -75,7 +75,7 @@ LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8
    = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
 
 error: this function definition uses SIMD vector type `TransparentWrapper<i8x16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:148:1
+  --> $DIR/simd-abi-checks-s390x.rs:149:1
    |
 LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
diff --git a/tests/ui/abi/simd-abi-checks-s390x.z13_no_vector.stderr b/tests/ui/abi/simd-abi-checks-s390x.z13_no_vector.stderr
index c1c4e90f3cf89..e1cfa373c63cb 100644
--- a/tests/ui/abi/simd-abi-checks-s390x.z13_no_vector.stderr
+++ b/tests/ui/abi/simd-abi-checks-s390x.z13_no_vector.stderr
@@ -1,5 +1,5 @@
 error: this function definition uses SIMD vector type `i8x8` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:38:1
+  --> $DIR/simd-abi-checks-s390x.rs:39:1
    |
 LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
@@ -7,7 +7,7 @@ LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
    = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
 
 error: this function definition uses SIMD vector type `i8x16` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:43:1
+  --> $DIR/simd-abi-checks-s390x.rs:44:1
    |
 LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
@@ -15,7 +15,7 @@ LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
    = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
 
 error: this function definition uses SIMD vector type `TransparentWrapper<i8x8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:89:1
+  --> $DIR/simd-abi-checks-s390x.rs:90:1
    |
 LL | / extern "C" fn vector_transparent_wrapper_ret_small(
 LL | |     x: &TransparentWrapper<i8x8>,
@@ -25,7 +25,7 @@ LL | | ) -> TransparentWrapper<i8x8> {
    = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
 
 error: this function definition uses SIMD vector type `TransparentWrapper<i8x16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:96:1
+  --> $DIR/simd-abi-checks-s390x.rs:97:1
    |
 LL | / extern "C" fn vector_transparent_wrapper_ret(
 LL | |     x: &TransparentWrapper<i8x16>,
@@ -35,7 +35,7 @@ LL | | ) -> TransparentWrapper<i8x16> {
    = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
 
 error: this function definition uses SIMD vector type `i8x8` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:111:1
+  --> $DIR/simd-abi-checks-s390x.rs:112:1
    |
 LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
@@ -43,7 +43,7 @@ LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 {
    = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
 
 error: this function definition uses SIMD vector type `i8x16` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:116:1
+  --> $DIR/simd-abi-checks-s390x.rs:117:1
    |
 LL | extern "C" fn vector_arg(x: i8x16) -> i64 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
@@ -51,7 +51,7 @@ LL | extern "C" fn vector_arg(x: i8x16) -> i64 {
    = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
 
 error: this function definition uses SIMD vector type `Wrapper<i8x8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:127:1
+  --> $DIR/simd-abi-checks-s390x.rs:128:1
    |
 LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
@@ -59,7 +59,7 @@ LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
    = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
 
 error: this function definition uses SIMD vector type `Wrapper<i8x16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:132:1
+  --> $DIR/simd-abi-checks-s390x.rs:133:1
    |
 LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
@@ -67,7 +67,7 @@ LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
    = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
 
 error: this function definition uses SIMD vector type `TransparentWrapper<i8x8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:143:1
+  --> $DIR/simd-abi-checks-s390x.rs:144:1
    |
 LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
@@ -75,7 +75,7 @@ LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8
    = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
 
 error: this function definition uses SIMD vector type `TransparentWrapper<i8x16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:148:1
+  --> $DIR/simd-abi-checks-s390x.rs:149:1
    |
 LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
diff --git a/tests/ui/abi/simd-abi-checks-s390x.z13_soft_float.stderr b/tests/ui/abi/simd-abi-checks-s390x.z13_soft_float.stderr
index c1c4e90f3cf89..577fcc23bf166 100644
--- a/tests/ui/abi/simd-abi-checks-s390x.z13_soft_float.stderr
+++ b/tests/ui/abi/simd-abi-checks-s390x.z13_soft_float.stderr
@@ -1,5 +1,10 @@
+warning: target feature `soft-float` must be disabled to ensure that the ABI of the current target can be implemented correctly
+   |
+   = note: 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 #116344 <https://github.com/rust-lang/rust/issues/116344>
+
 error: this function definition uses SIMD vector type `i8x8` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:38:1
+  --> $DIR/simd-abi-checks-s390x.rs:39:1
    |
 LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
@@ -7,7 +12,7 @@ LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
    = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
 
 error: this function definition uses SIMD vector type `i8x16` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:43:1
+  --> $DIR/simd-abi-checks-s390x.rs:44:1
    |
 LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
@@ -15,7 +20,7 @@ LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
    = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
 
 error: this function definition uses SIMD vector type `TransparentWrapper<i8x8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:89:1
+  --> $DIR/simd-abi-checks-s390x.rs:90:1
    |
 LL | / extern "C" fn vector_transparent_wrapper_ret_small(
 LL | |     x: &TransparentWrapper<i8x8>,
@@ -25,7 +30,7 @@ LL | | ) -> TransparentWrapper<i8x8> {
    = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
 
 error: this function definition uses SIMD vector type `TransparentWrapper<i8x16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:96:1
+  --> $DIR/simd-abi-checks-s390x.rs:97:1
    |
 LL | / extern "C" fn vector_transparent_wrapper_ret(
 LL | |     x: &TransparentWrapper<i8x16>,
@@ -35,7 +40,7 @@ LL | | ) -> TransparentWrapper<i8x16> {
    = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
 
 error: this function definition uses SIMD vector type `i8x8` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:111:1
+  --> $DIR/simd-abi-checks-s390x.rs:112:1
    |
 LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
@@ -43,7 +48,7 @@ LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 {
    = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
 
 error: this function definition uses SIMD vector type `i8x16` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:116:1
+  --> $DIR/simd-abi-checks-s390x.rs:117:1
    |
 LL | extern "C" fn vector_arg(x: i8x16) -> i64 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
@@ -51,7 +56,7 @@ LL | extern "C" fn vector_arg(x: i8x16) -> i64 {
    = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
 
 error: this function definition uses SIMD vector type `Wrapper<i8x8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:127:1
+  --> $DIR/simd-abi-checks-s390x.rs:128:1
    |
 LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
@@ -59,7 +64,7 @@ LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
    = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
 
 error: this function definition uses SIMD vector type `Wrapper<i8x16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:132:1
+  --> $DIR/simd-abi-checks-s390x.rs:133:1
    |
 LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
@@ -67,7 +72,7 @@ LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
    = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
 
 error: this function definition uses SIMD vector type `TransparentWrapper<i8x8>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:143:1
+  --> $DIR/simd-abi-checks-s390x.rs:144:1
    |
 LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
@@ -75,12 +80,12 @@ LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8
    = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
 
 error: this function definition uses SIMD vector type `TransparentWrapper<i8x16>` which (with the chosen ABI) requires the `vector` target feature, which is not enabled
-  --> $DIR/simd-abi-checks-s390x.rs:148:1
+  --> $DIR/simd-abi-checks-s390x.rs:149:1
    |
 LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
    |
    = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
 
-error: aborting due to 10 previous errors
+error: aborting due to 10 previous errors; 1 warning emitted
 

From f8302a7c15d69b91ff20080ddcf8c44c81ec32ac Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 10 Sep 2025 23:01:15 +0200
Subject: [PATCH 0779/1889] add release sequence test

---
 .../miri/tests/pass/0weak_memory/weak.rs      | 42 +++++++++++++++++--
 1 file changed, 39 insertions(+), 3 deletions(-)

diff --git a/src/tools/miri/tests/pass/0weak_memory/weak.rs b/src/tools/miri/tests/pass/0weak_memory/weak.rs
index 0dd661d3e9b4b..75c6e8f1a8793 100644
--- a/src/tools/miri/tests/pass/0weak_memory/weak.rs
+++ b/src/tools/miri/tests/pass/0weak_memory/weak.rs
@@ -35,7 +35,7 @@ fn spin_until(loc: &AtomicUsize, val: usize) -> usize {
 
 /// Check that the function produces the intended set of outcomes.
 #[track_caller]
-fn check_all_outcomes<T: Eq + std::hash::Hash + std::fmt::Display>(
+fn check_all_outcomes<T: Eq + std::hash::Hash + std::fmt::Debug>(
     expected: impl IntoIterator<Item = T>,
     generate: impl Fn() -> T,
 ) {
@@ -47,7 +47,7 @@ fn check_all_outcomes<T: Eq + std::hash::Hash + std::fmt::Display>(
     let tries = expected.len() * 12;
     for i in 0..tries {
         let val = generate();
-        assert!(expected.contains(&val), "got an unexpected value: {val}");
+        assert!(expected.contains(&val), "got an unexpected value: {val:?}");
         seen.insert(val);
         if i > tries / 2 && expected.len() == seen.len() {
             // We saw everything and we did quite a few tries, let's avoid wasting time.
@@ -57,7 +57,7 @@ fn check_all_outcomes<T: Eq + std::hash::Hash + std::fmt::Display>(
     // Let's see if we saw them all.
     for val in expected {
         if !seen.contains(&val) {
-            panic!("did not get value that should be possible: {val}");
+            panic!("did not get value that should be possible: {val:?}");
         }
     }
 }
@@ -163,10 +163,46 @@ fn faa_replaced_by_load() {
     });
 }
 
+/// Checking that the weaker release sequence example from
+/// <https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0982r0.html> can actually produce the
+/// new behavior (`Some(0)` in our version).
+fn weaker_release_sequences() {
+    check_all_outcomes([None, Some(0), Some(1)], || {
+        let x = static_atomic(0);
+        let y = static_atomic(0);
+
+        let t1 = spawn(move || {
+            x.store(2, Relaxed);
+        });
+        let t2 = spawn(move || {
+            y.store(1, Relaxed);
+            x.store(1, Release);
+            x.store(3, Relaxed);
+        });
+        let t3 = spawn(move || {
+            if x.load(Acquire) == 3 {
+                // In C++11, if we read the 3 here, and if the store of 1 was just before the store
+                // of 3 in mo order (which it is because we fix the schedule), this forms a release
+                // sequence, meaning we acquire the release store of 1, and we can thus never see
+                // the value 0.
+                // In C++20, this is no longer a release sequence, so 0 can now be observed.
+                Some(y.load(Relaxed))
+            } else {
+                None
+            }
+        });
+
+        t1.join().unwrap();
+        t2.join().unwrap();
+        t3.join().unwrap()
+    });
+}
+
 pub fn main() {
     relaxed();
     seq_cst();
     initialization_write(false);
     initialization_write(true);
     faa_replaced_by_load();
+    weaker_release_sequences();
 }

From 1558e65c9eec9ee0309e1920266e0a4325b63784 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Wed, 10 Sep 2025 21:40:24 +0200
Subject: [PATCH 0780/1889] Restore the test intention of several MBE trait
 bound modifier tests

---
 compiler/rustc_parse/src/parser/ty.rs         |  6 +-
 ...sync-trait-bound-theoretical-regression.rs | 17 ++--
 ...-trait-bound-theoretical-regression.stderr |  8 +-
 ...o-bare-trait-objects-const-trait-bounds.rs | 33 ++++---
 ...re-trait-objects-const-trait-bounds.stderr | 22 -----
 ...onst-trait-bound-theoretical-regression.rs | 30 ++++--
 ...-trait-bound-theoretical-regression.stderr | 92 ++++++++++++-------
 .../const-traits/macro-dyn-const-2015.rs      | 15 ++-
 8 files changed, 123 insertions(+), 100 deletions(-)
 delete mode 100644 tests/ui/traits/const-traits/macro-bare-trait-objects-const-trait-bounds.stderr

diff --git a/compiler/rustc_parse/src/parser/ty.rs b/compiler/rustc_parse/src/parser/ty.rs
index 6168647183fdb..138e828a2304c 100644
--- a/compiler/rustc_parse/src/parser/ty.rs
+++ b/compiler/rustc_parse/src/parser/ty.rs
@@ -92,10 +92,10 @@ fn can_continue_type_after_non_fn_ident(t: &Token) -> bool {
 }
 
 fn can_begin_dyn_bound_in_edition_2015(t: &Token) -> bool {
-    // `Not`, `Tilde` & `Const` are deliberately not part of this list to
+    // `!`, `const`, `[`, `async` are deliberately not part of this list to
     // contain the number of potential regressions esp. in MBE code.
-    // `Const` would regress `rfc-2632-const-trait-impl/mbe-dyn-const-2015.rs`.
-    // `Not` would regress `dyn!(...)` macro calls in Rust 2015.
+    // `const` and `[` would regress UI test `macro-dyn-const-2015.rs`.
+    // `!` would regress `dyn!(...)` macro calls in Rust 2015.
     t.is_path_start()
         || t.is_lifetime()
         || t == &TokenKind::Question
diff --git a/tests/ui/async-await/async-fn/macro-async-trait-bound-theoretical-regression.rs b/tests/ui/async-await/async-fn/macro-async-trait-bound-theoretical-regression.rs
index ea67831b68e67..a13a255d53610 100644
--- a/tests/ui/async-await/async-fn/macro-async-trait-bound-theoretical-regression.rs
+++ b/tests/ui/async-await/async-fn/macro-async-trait-bound-theoretical-regression.rs
@@ -1,21 +1,22 @@
 // Demonstrates and records a theoretical regressions / breaking changes caused by the
 // introduction of async trait bounds.
 
-// Setting the edition to 2018 since we don't regress `demo! { dyn async }` in Rust <2018.
+// Setting the edition to >2015 since we didn't regress `demo! { dyn async }` in Rust 2015.
 //@ edition:2018
 
 macro_rules! demo {
-    ($ty:ty) => { compile_error!("ty"); };
+    ($ty:ty) => { compile_error!("ty"); }; // KEEP THIS RULE FIRST AND AS IS!
     //~^ ERROR ty
     //~| ERROR ty
-    (impl $c:ident Trait) => {};
-    (dyn $c:ident Trait) => {};
+
+    // DON'T MODIFY THE MATCHERS BELOW UNLESS THE ASYNC TRAIT MODIFIER SYNTAX CHANGES!
+
+    (impl $c:ident Trait) => { /* KEEP THIS EMPTY! */ };
+    (dyn $c:ident Trait) => { /* KEEP THIS EMPTY! */ };
 }
 
-demo! { impl async Trait }
-//~^ ERROR `async` trait bounds are unstable
+demo! { impl async Trait } //~ ERROR `async` trait bounds are unstable
 
-demo! { dyn async Trait }
-//~^ ERROR `async` trait bounds are unstable
+demo! { dyn async Trait } //~ ERROR `async` trait bounds are unstable
 
 fn main() {}
diff --git a/tests/ui/async-await/async-fn/macro-async-trait-bound-theoretical-regression.stderr b/tests/ui/async-await/async-fn/macro-async-trait-bound-theoretical-regression.stderr
index 6c3044e64d20c..0292c53fb1c17 100644
--- a/tests/ui/async-await/async-fn/macro-async-trait-bound-theoretical-regression.stderr
+++ b/tests/ui/async-await/async-fn/macro-async-trait-bound-theoretical-regression.stderr
@@ -1,7 +1,7 @@
 error: ty
   --> $DIR/macro-async-trait-bound-theoretical-regression.rs:8:19
    |
-LL |     ($ty:ty) => { compile_error!("ty"); };
+LL |     ($ty:ty) => { compile_error!("ty"); }; // KEEP THIS RULE FIRST AND AS IS!
    |                   ^^^^^^^^^^^^^^^^^^^^
 ...
 LL | demo! { impl async Trait }
@@ -12,7 +12,7 @@ LL | demo! { impl async Trait }
 error: ty
   --> $DIR/macro-async-trait-bound-theoretical-regression.rs:8:19
    |
-LL |     ($ty:ty) => { compile_error!("ty"); };
+LL |     ($ty:ty) => { compile_error!("ty"); }; // KEEP THIS RULE FIRST AND AS IS!
    |                   ^^^^^^^^^^^^^^^^^^^^
 ...
 LL | demo! { dyn async Trait }
@@ -21,7 +21,7 @@ LL | demo! { dyn async Trait }
    = note: this error originates in the macro `demo` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0658]: `async` trait bounds are unstable
-  --> $DIR/macro-async-trait-bound-theoretical-regression.rs:15:14
+  --> $DIR/macro-async-trait-bound-theoretical-regression.rs:18:14
    |
 LL | demo! { impl async Trait }
    |              ^^^^^
@@ -32,7 +32,7 @@ LL | demo! { impl async Trait }
    = help: use the desugared name of the async trait, such as `AsyncFn`
 
 error[E0658]: `async` trait bounds are unstable
-  --> $DIR/macro-async-trait-bound-theoretical-regression.rs:18:13
+  --> $DIR/macro-async-trait-bound-theoretical-regression.rs:20:13
    |
 LL | demo! { dyn async Trait }
    |             ^^^^^
diff --git a/tests/ui/traits/const-traits/macro-bare-trait-objects-const-trait-bounds.rs b/tests/ui/traits/const-traits/macro-bare-trait-objects-const-trait-bounds.rs
index ee04f74c8a64b..9b03ec7553d18 100644
--- a/tests/ui/traits/const-traits/macro-bare-trait-objects-const-trait-bounds.rs
+++ b/tests/ui/traits/const-traits/macro-bare-trait-objects-const-trait-bounds.rs
@@ -1,24 +1,23 @@
-// Ensure that we don't consider `const Trait` to
-// match the macro fragment specifier `ty` as that would be a breaking
-// change theoretically speaking. Syntactically trait object types can
-// be "bare", i.e., lack the prefix `dyn`.
-// By contrast, `?Trait` *does* match `ty` and therefore an arm like
-// `?$Trait:path` would never be reached.
-// See `parser/macro/mbe-bare-trait-object-maybe-trait-bound.rs`.
-// `[const] Trait` is already an error for a `ty` fragment,
-// so we do not need to prevent that.
+// Ensure that we don't consider `const Trait` to match the macro fragment specifier `ty`
+// as that would be a breaking change theoretically speaking.
+//
+// Syntactically trait object types can be "bare", i.e., lack the prefix `dyn`.
+// By contrast, `?Trait` *does* match `ty` and therefore an arm like `?$Trait:path`
+// would never be reached. See `parser/macro/macro-bare-trait-object-maybe-trait-bound.rs`.
+
+//@ check-pass (KEEP THIS AS A PASSING TEST!)
 
 macro_rules! check {
-    ($Type:ty) => {
-        compile_error!("ty");
-    };
-    (const $Trait:path) => {};
-    ([const] $Trait:path) => { [const] Trait };
+    ($ty:ty) => { compile_error!("ty"); }; // KEEP THIS RULE FIRST AND AS IS!
+
+    // DON'T MODIFY THE MATCHERS BELOW UNLESS THE CONST TRAIT MODIFIER SYNTAX CHANGES!
+
+    (const $Trait:path) => { /* KEEP THIS EMPTY! */ };
+    // We don't need to check `[const] Trait` here since that matches the `ty` fragment
+    // already anyway since `[` may begin a slice or array type. However, it'll then
+    // subsequently fail due to #146122 (section 3).
 }
 
 check! { const Trait }
-check! { [const] Trait }
-//~^ ERROR: expected identifier, found `]`
-//~| ERROR: const trait impls are experimental
 
 fn main() {}
diff --git a/tests/ui/traits/const-traits/macro-bare-trait-objects-const-trait-bounds.stderr b/tests/ui/traits/const-traits/macro-bare-trait-objects-const-trait-bounds.stderr
deleted file mode 100644
index a4e77154b17d1..0000000000000
--- a/tests/ui/traits/const-traits/macro-bare-trait-objects-const-trait-bounds.stderr
+++ /dev/null
@@ -1,22 +0,0 @@
-error: expected identifier, found `]`
-  --> $DIR/macro-bare-trait-objects-const-trait-bounds.rs:20:16
-   |
-LL |     ($Type:ty) => {
-   |      -------- while parsing argument for this `ty` macro fragment
-...
-LL | check! { [const] Trait }
-   |                ^ expected identifier
-
-error[E0658]: const trait impls are experimental
-  --> $DIR/macro-bare-trait-objects-const-trait-bounds.rs:20:11
-   |
-LL | check! { [const] Trait }
-   |           ^^^^^
-   |
-   = note: see issue #143874 <https://github.com/rust-lang/rust/issues/143874> for more information
-   = help: add `#![feature(const_trait_impl)]` 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`.
diff --git a/tests/ui/traits/const-traits/macro-const-trait-bound-theoretical-regression.rs b/tests/ui/traits/const-traits/macro-const-trait-bound-theoretical-regression.rs
index 35e964eacec4f..3f70ffa7d10e7 100644
--- a/tests/ui/traits/const-traits/macro-const-trait-bound-theoretical-regression.rs
+++ b/tests/ui/traits/const-traits/macro-const-trait-bound-theoretical-regression.rs
@@ -1,22 +1,32 @@
 // Demonstrates and records a theoretical regressions / breaking changes caused by the
-// introduction of const trait bounds.
+// introduction of `const` and `[const]` trait bounds.
 
-// Setting the edition to 2018 since we don't regress `demo! { dyn const }` in Rust <2018.
+// Setting the edition to >2015 since we didn't regress `demo! { dyn const }` in Rust 2015.
+// See also test `traits/const-traits/macro-dyn-const-2015.rs`.
 //@ edition:2018
 
 trait Trait {}
 
 macro_rules! demo {
-    (impl $c:ident Trait) => { impl $c Trait {} };
-    //~^ ERROR inherent
-    //~| WARN trait objects without an explicit `dyn` are deprecated
-    //~| WARN this is accepted in the current edition
-    (dyn $c:ident Trait) => { dyn $c Trait {} }; //~ ERROR macro expansion
+    ($ty:ty) => { compile_error!("ty"); }; // KEEP THIS RULE FIRST AND AS IS!
+    //~^ ERROR ty
+    //~| ERROR ty
+    //~| ERROR ty
+    //~| ERROR ty
+
+    // DON'T MODIFY THE MATCHERS BELOW UNLESS THE CONST TRAIT MODIFIER SYNTAX CHANGES!
+
+    (impl $c:ident Trait) => { /* KEEP THIS EMPTY! */ };
+    (dyn $c:ident Trait) => { /* KEEP THIS EMPTY! */ };
+
+    (impl [const] Trait) => { /* KEEP THIS EMPTY! */ };
+    (dyn [const] Trait) => { /* KEEP THIS EMPTY! */ };
 }
 
-demo! { impl const Trait }
-//~^ ERROR const trait impls are experimental
+demo! { impl const Trait } //~ ERROR const trait impls are experimental
+demo! { dyn const Trait } //~ ERROR const trait impls are experimental
 
-demo! { dyn const Trait }
+demo! { impl [const] Trait } //~ ERROR const trait impls are experimental
+demo! { dyn [const] Trait } //~ ERROR const trait impls are experimental
 
 fn main() {}
diff --git a/tests/ui/traits/const-traits/macro-const-trait-bound-theoretical-regression.stderr b/tests/ui/traits/const-traits/macro-const-trait-bound-theoretical-regression.stderr
index 7a4061d9c18e5..383936b9df155 100644
--- a/tests/ui/traits/const-traits/macro-const-trait-bound-theoretical-regression.stderr
+++ b/tests/ui/traits/const-traits/macro-const-trait-bound-theoretical-regression.stderr
@@ -1,31 +1,49 @@
-error: inherent impls cannot be const
-  --> $DIR/macro-const-trait-bound-theoretical-regression.rs:10:40
+error: ty
+  --> $DIR/macro-const-trait-bound-theoretical-regression.rs:11:19
    |
-LL |     (impl $c:ident Trait) => { impl $c Trait {} };
-   |                                        ^^^^^ inherent impl for this type
+LL |     ($ty:ty) => { compile_error!("ty"); }; // KEEP THIS RULE FIRST AND AS IS!
+   |                   ^^^^^^^^^^^^^^^^^^^^
 ...
 LL | demo! { impl const Trait }
-   | --------------------------
-   | |            |
-   | |            const because of this
-   | in this macro invocation
+   | -------------------------- in this macro invocation
    |
-   = note: only trait implementations may be annotated with `const`
    = note: this error originates in the macro `demo` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: macro expansion ignores keyword `dyn` and any tokens following
-  --> $DIR/macro-const-trait-bound-theoretical-regression.rs:14:31
+error: ty
+  --> $DIR/macro-const-trait-bound-theoretical-regression.rs:11:19
    |
-LL |     (dyn $c:ident Trait) => { dyn $c Trait {} };
-   |                               ^^^
+LL |     ($ty:ty) => { compile_error!("ty"); }; // KEEP THIS RULE FIRST AND AS IS!
+   |                   ^^^^^^^^^^^^^^^^^^^^
 ...
 LL | demo! { dyn const Trait }
-   | ------------------------- caused by the macro expansion here
+   | ------------------------- in this macro invocation
    |
-   = note: the usage of `demo!` is likely invalid in item context
+   = note: this error originates in the macro `demo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: ty
+  --> $DIR/macro-const-trait-bound-theoretical-regression.rs:11:19
+   |
+LL |     ($ty:ty) => { compile_error!("ty"); }; // KEEP THIS RULE FIRST AND AS IS!
+   |                   ^^^^^^^^^^^^^^^^^^^^
+...
+LL | demo! { impl [const] Trait }
+   | ---------------------------- in this macro invocation
+   |
+   = note: this error originates in the macro `demo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: ty
+  --> $DIR/macro-const-trait-bound-theoretical-regression.rs:11:19
+   |
+LL |     ($ty:ty) => { compile_error!("ty"); }; // KEEP THIS RULE FIRST AND AS IS!
+   |                   ^^^^^^^^^^^^^^^^^^^^
+...
+LL | demo! { dyn [const] Trait }
+   | --------------------------- in this macro invocation
+   |
+   = note: this error originates in the macro `demo` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0658]: const trait impls are experimental
-  --> $DIR/macro-const-trait-bound-theoretical-regression.rs:17:14
+  --> $DIR/macro-const-trait-bound-theoretical-regression.rs:26:14
    |
 LL | demo! { impl const Trait }
    |              ^^^^^
@@ -34,24 +52,36 @@ LL | demo! { impl const Trait }
    = help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-warning: trait objects without an explicit `dyn` are deprecated
-  --> $DIR/macro-const-trait-bound-theoretical-regression.rs:10:40
+error[E0658]: const trait impls are experimental
+  --> $DIR/macro-const-trait-bound-theoretical-regression.rs:27:13
    |
-LL |     (impl $c:ident Trait) => { impl $c Trait {} };
-   |                                        ^^^^^
-...
-LL | demo! { impl const Trait }
-   | -------------------------- in this macro invocation
+LL | demo! { dyn const Trait }
+   |             ^^^^^
    |
-   = warning: this is accepted in the current edition (Rust 2018) but is a hard error in Rust 2021!
-   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/warnings-promoted-to-error.html>
-   = note: `#[warn(bare_trait_objects)]` (part of `#[warn(rust_2021_compatibility)]`) on by default
-   = note: this warning originates in the macro `demo` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: you might have intended to implement this trait for a given type
+   = note: see issue #143874 <https://github.com/rust-lang/rust/issues/143874> for more information
+   = help: add `#![feature(const_trait_impl)]` 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 trait impls are experimental
+  --> $DIR/macro-const-trait-bound-theoretical-regression.rs:29:14
+   |
+LL | demo! { impl [const] Trait }
+   |              ^^^^^^^
+   |
+   = note: see issue #143874 <https://github.com/rust-lang/rust/issues/143874> for more information
+   = help: add `#![feature(const_trait_impl)]` 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 trait impls are experimental
+  --> $DIR/macro-const-trait-bound-theoretical-regression.rs:30:13
    |
-LL |     (impl $c:ident Trait) => { impl $c Trait for /* Type */ {} };
-   |                                              ++++++++++++++
+LL | demo! { dyn [const] Trait }
+   |             ^^^^^^^
+   |
+   = note: see issue #143874 <https://github.com/rust-lang/rust/issues/143874> for more information
+   = help: add `#![feature(const_trait_impl)]` 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; 1 warning emitted
+error: aborting due to 8 previous errors
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/traits/const-traits/macro-dyn-const-2015.rs b/tests/ui/traits/const-traits/macro-dyn-const-2015.rs
index fadfbe667887d..0dfa482b98613 100644
--- a/tests/ui/traits/const-traits/macro-dyn-const-2015.rs
+++ b/tests/ui/traits/const-traits/macro-dyn-const-2015.rs
@@ -1,14 +1,19 @@
-// Ensure that the introduction of const trait bound didn't regress this code in Rust 2015.
-// See also `mbe-const-trait-bound-theoretical-regression.rs`.
+// Ensure that the introduction of `const` and `[const]` trait bounds didn't regress this
+// Rust 2015 code. See also test `macro-const-trait-bound-theoretical-regression.rs`.
 
 //@ edition: 2015
-//@ check-pass
+//@ check-pass (KEEP THIS AS A PASSING TEST!)
 
 macro_rules! check {
-    ($ty:ty) => { compile_error!("ty"); };
-    (dyn $c:ident) => {};
+    ($ty:ty) => { compile_error!("ty"); }; // KEEP THIS RULE FIRST AND AS IS!
+
+    // DON'T MODIFY THE MATCHERS BELOW UNLESS THE CONST TRAIT MODIFIER SYNTAX CHANGES!
+
+    (dyn $c:ident) => { /* KEEP THIS EMPTY! */ };
+    (dyn [$c:ident]) => { /* KEEP THIS EMPTY! */ };
 }
 
 check! { dyn const }
+check! { dyn [const] }
 
 fn main() {}

From f5dad62d4cdf139fb1c6cf2fa24ac525167501cc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Wed, 10 Sep 2025 21:41:00 +0200
Subject: [PATCH 0781/1889] Less greedily parse `[const]` bounds

---
 compiler/rustc_parse/src/parser/ty.rs         | 13 ++++++----
 .../macro-maybe-const-trait-bounds.rs         | 25 +++++++++++++++++++
 2 files changed, 33 insertions(+), 5 deletions(-)
 create mode 100644 tests/ui/traits/const-traits/macro-maybe-const-trait-bounds.rs

diff --git a/compiler/rustc_parse/src/parser/ty.rs b/compiler/rustc_parse/src/parser/ty.rs
index 138e828a2304c..23aaafac934ee 100644
--- a/compiler/rustc_parse/src/parser/ty.rs
+++ b/compiler/rustc_parse/src/parser/ty.rs
@@ -1015,12 +1015,18 @@ impl<'a> Parser<'a> {
             || self.check(exp!(Tilde))
             || self.check_keyword(exp!(For))
             || self.check(exp!(OpenParen))
-            || self.check(exp!(OpenBracket))
+            || self.can_begin_maybe_const_bound()
             || self.check_keyword(exp!(Const))
             || self.check_keyword(exp!(Async))
             || self.check_keyword(exp!(Use))
     }
 
+    fn can_begin_maybe_const_bound(&mut self) -> bool {
+        self.check(exp!(OpenBracket))
+            && self.look_ahead(1, |t| t.is_keyword(kw::Const))
+            && self.look_ahead(2, |t| *t == token::CloseBracket)
+    }
+
     /// Parse a bound.
     ///
     /// ```ebnf
@@ -1199,10 +1205,7 @@ impl<'a> Parser<'a> {
             let span = tilde.to(self.prev_token.span);
             self.psess.gated_spans.gate(sym::const_trait_impl, span);
             BoundConstness::Maybe(span)
-        } else if self.check(exp!(OpenBracket))
-            && self.look_ahead(1, |t| t.is_keyword(kw::Const))
-            && self.look_ahead(2, |t| *t == token::CloseBracket)
-        {
+        } else if self.can_begin_maybe_const_bound() {
             let start = self.token.span;
             self.bump();
             self.expect_keyword(exp!(Const)).unwrap();
diff --git a/tests/ui/traits/const-traits/macro-maybe-const-trait-bounds.rs b/tests/ui/traits/const-traits/macro-maybe-const-trait-bounds.rs
new file mode 100644
index 0000000000000..75077577b8c6e
--- /dev/null
+++ b/tests/ui/traits/const-traits/macro-maybe-const-trait-bounds.rs
@@ -0,0 +1,25 @@
+// Ensure that we don't consider `[` to begin trait bounds to contain breakages.
+// Only `[const]` in its entirety begins a trait bound.
+// See also test `macro-const-trait-bound-theoretical-regression.rs`.
+
+//@ check-pass (KEEP THIS AS A PASSING TEST!)
+// Setting the edition to >2015 since we didn't regress `check! { dyn [const] Trait }` in Rust 2015.
+// See also test `traits/const-traits/macro-dyn-const-2015.rs`.
+//@ edition:2018
+
+macro_rules! check {
+    ($ty:ty) => { compile_error!("ty"); }; // KEEP THIS RULE FIRST AND AS IS!
+
+    // DON'T MODIFY THE MATCHERS BELOW UNLESS THE CONST TRAIT MODIFIER SYNTAX CHANGES!
+
+    (dyn [$($any:tt)*] Trait) => { /* KEEP THIS EMPTY! */ };
+    (impl [$($any:tt)*] Trait) => { /* KEEP THIS EMPTY! */ };
+}
+
+check!(dyn [T] Trait);
+
+// issue: <https://github.com/rust-lang/rust/issues/146417>
+check!(impl [T] Trait);
+check!(impl [T: Bound] Trait);
+
+fn main() {}

From 5f2b04652fe006439aaa52271997a69499dca021 Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Wed, 10 Sep 2025 16:32:04 -0500
Subject: [PATCH 0782/1889] Improve `core::ops` coverage

---
 library/coretests/tests/lib.rs |  1 +
 library/coretests/tests/ops.rs | 74 +++++++++++++++++++++++++++++++++-
 2 files changed, 74 insertions(+), 1 deletion(-)

diff --git a/library/coretests/tests/lib.rs b/library/coretests/tests/lib.rs
index b5658a9970fee..1bdaa6965f64a 100644
--- a/library/coretests/tests/lib.rs
+++ b/library/coretests/tests/lib.rs
@@ -81,6 +81,7 @@
 #![feature(next_index)]
 #![feature(non_exhaustive_omitted_patterns_lint)]
 #![feature(numfmt)]
+#![feature(one_sided_range)]
 #![feature(option_reduce)]
 #![feature(pattern)]
 #![feature(peekable_next_if_map)]
diff --git a/library/coretests/tests/ops.rs b/library/coretests/tests/ops.rs
index 501e0f33fe4cc..921010774e289 100644
--- a/library/coretests/tests/ops.rs
+++ b/library/coretests/tests/ops.rs
@@ -2,7 +2,8 @@ mod control_flow;
 mod from_residual;
 
 use core::ops::{
-    Bound, Deref, DerefMut, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive,
+    Bound, Deref, DerefMut, OneSidedRange, OneSidedRangeBound, Range, RangeBounds, RangeFrom,
+    RangeFull, RangeInclusive, RangeTo, RangeToInclusive,
 };
 
 // Test the Range structs and syntax.
@@ -70,6 +71,35 @@ fn test_range_to_inclusive() {
     let _ = RangeToInclusive { end: 42 };
 }
 
+#[test]
+fn test_range_contains() {
+    assert!(!(1u32..5).contains(&0u32));
+    assert!((1u32..5).contains(&1u32));
+    assert!((1u32..5).contains(&4u32));
+    assert!(!(1u32..5).contains(&5u32));
+    assert!(!(1u32..5).contains(&6u32));
+}
+
+#[test]
+fn test_range_to_contains() {
+    assert!(!(1u32..=5).contains(&0));
+    assert!((1u32..=5).contains(&1));
+    assert!((1u32..=5).contains(&4));
+    assert!((1u32..=5).contains(&5));
+    assert!(!(1u32..=5).contains(&6));
+}
+
+// This test covers `RangeBounds::contains` when the start is excluded.
+#[test]
+fn test_range_bounds_contains() {
+    let r = (Bound::Excluded(1u32), Bound::Included(5u32));
+    assert!(!r.contains(&0));
+    assert!(!r.contains(&1));
+    assert!(r.contains(&3));
+    assert!(r.contains(&5));
+    assert!(!r.contains(&6));
+}
+
 #[test]
 fn test_range_is_empty() {
     assert!(!(0.0..10.0).is_empty());
@@ -91,6 +121,34 @@ fn test_range_is_empty() {
     assert!((f32::NAN..=f32::NAN).is_empty());
 }
 
+#[test]
+fn test_range_inclusive_end_bound() {
+    let mut r = 1u32..=1;
+    r.next().unwrap();
+    assert!(!r.contains(&1));
+}
+
+#[test]
+fn test_range_bounds() {
+    let r = (Bound::Included(1u32), Bound::Excluded(5u32));
+    assert!(!r.contains(&0));
+    assert!(r.contains(&1));
+    assert!(r.contains(&3));
+    assert!(!r.contains(&5));
+    assert!(!r.contains(&6));
+
+    let r = (Bound::<u32>::Unbounded, Bound::Unbounded);
+    assert!(r.contains(&0));
+    assert!(r.contains(&u32::MAX));
+}
+
+#[test]
+fn test_one_sided_range_bound() {
+    assert!(matches!((..1u32).bound(), (OneSidedRangeBound::End, 1)));
+    assert!(matches!((1u32..).bound(), (OneSidedRangeBound::StartInclusive, 1)));
+    assert!(matches!((..=1u32).bound(), (OneSidedRangeBound::EndInclusive, 1)));
+}
+
 #[test]
 fn test_bound_cloned_unbounded() {
     assert_eq!(Bound::<&u32>::Unbounded.cloned(), Bound::Unbounded);
@@ -240,3 +298,17 @@ fn deref_on_ref() {
 fn test_not_never() {
     if !return () {}
 }
+
+#[test]
+fn test_fmt() {
+    let mut r = 1..=1;
+    assert_eq!(format!("{:?}", r), "1..=1");
+    r.next().unwrap();
+    assert_eq!(format!("{:?}", r), "1..=1 (exhausted)");
+
+    assert_eq!(format!("{:?}", 1..1), "1..1");
+    assert_eq!(format!("{:?}", 1..), "1..");
+    assert_eq!(format!("{:?}", ..1), "..1");
+    assert_eq!(format!("{:?}", ..=1), "..=1");
+    assert_eq!(format!("{:?}", ..), "..");
+}

From 789c8408ec0e6ed4e299fb13b047282ed1046e2e Mon Sep 17 00:00:00 2001
From: Christian Poveda Ruiz <31802960+pvdrz@users.noreply.github.com>
Date: Wed, 10 Sep 2025 16:50:45 -0500
Subject: [PATCH 0783/1889] Update library/coretests/tests/ops.rs

Co-authored-by: Jubilee <workingjubilee@gmail.com>
---
 library/coretests/tests/ops.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/library/coretests/tests/ops.rs b/library/coretests/tests/ops.rs
index 921010774e289..121718f2167e2 100644
--- a/library/coretests/tests/ops.rs
+++ b/library/coretests/tests/ops.rs
@@ -89,7 +89,8 @@ fn test_range_to_contains() {
     assert!(!(1u32..=5).contains(&6));
 }
 
-// This test covers `RangeBounds::contains` when the start is excluded.
+// This test covers `RangeBounds::contains` when the start is excluded,
+// which cannot be directly expressed by Rust's built-in range syntax.
 #[test]
 fn test_range_bounds_contains() {
     let r = (Bound::Excluded(1u32), Bound::Included(5u32));

From a7528e7ec3e13ebe00c19a92381b93be8cce8ec6 Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Wed, 10 Sep 2025 16:41:13 -0500
Subject: [PATCH 0784/1889] Improve `core::array` coverage

---
 library/coretests/tests/array.rs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/library/coretests/tests/array.rs b/library/coretests/tests/array.rs
index 30ccbbc320318..c4a8fc74feca3 100644
--- a/library/coretests/tests/array.rs
+++ b/library/coretests/tests/array.rs
@@ -717,3 +717,10 @@ fn array_map_drops_unmapped_elements_on_panic() {
         assert_eq!(counter.load(Ordering::SeqCst), MAX);
     }
 }
+
+// This covers the `PartialEq::<[T]>::eq` impl for `[T; N]` when it returns false.
+#[test]
+fn array_eq() {
+    let not_true = [0u8] == [].as_slice();
+    assert!(!not_true);
+}

From 3d3769a0d384aee773d538b53baef9005f759ac0 Mon Sep 17 00:00:00 2001
From: Jonathan 'theJPster' Pallant <github@thejpster.org.uk>
Date: Wed, 10 Sep 2025 23:36:11 +0100
Subject: [PATCH 0785/1889] Add missing links in platform-support.md

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

diff --git a/src/doc/rustc/src/platform-support.md b/src/doc/rustc/src/platform-support.md
index 3c91d12505771..24945f1fa51ea 100644
--- a/src/doc/rustc/src/platform-support.md
+++ b/src/doc/rustc/src/platform-support.md
@@ -149,8 +149,8 @@ target | std | notes
 [`aarch64-apple-ios-sim`](platform-support/apple-ios.md) | ✓ | Apple iOS Simulator on ARM64
 [`aarch64-linux-android`](platform-support/android.md) | ✓ | ARM64 Android
 [`aarch64-unknown-fuchsia`](platform-support/fuchsia.md) | ✓ | ARM64 Fuchsia
-`aarch64-unknown-none` | * | Bare ARM64, hardfloat
-`aarch64-unknown-none-softfloat` | * | Bare ARM64, softfloat
+[`aarch64-unknown-none`](platform-support/aarch64-unknown-none.md) | * | Bare ARM64, hardfloat
+[`aarch64-unknown-none-softfloat`](platform-support/aarch64-unknown-none.md) | * | Bare ARM64, softfloat
 [`aarch64-unknown-uefi`](platform-support/unknown-uefi.md) | ? | ARM64 UEFI
 [`arm-linux-androideabi`](platform-support/android.md) | ✓ | Armv6 Android
 `arm-unknown-linux-musleabi` | ✓ | Armv6 Linux with musl 1.2.3

From 5a742229eca120eda8226207d8415ed9755408ad Mon Sep 17 00:00:00 2001
From: Jonathan 'theJPster' Pallant <github@thejpster.org.uk>
Date: Wed, 10 Sep 2025 23:37:08 +0100
Subject: [PATCH 0786/1889] Add aarch64-unknown-none 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 e866f3c0556ab..e4bf33dd8a0e4 100644
--- a/src/doc/rustc/src/SUMMARY.md
+++ b/src/doc/rustc/src/SUMMARY.md
@@ -48,6 +48,7 @@
     - [\*-apple-visionos](platform-support/apple-visionos.md)
     - [aarch64-nintendo-switch-freestanding](platform-support/aarch64-nintendo-switch-freestanding.md)
     - [aarch64-unknown-linux-musl](platform-support/aarch64-unknown-linux-musl.md)
+    - [aarch64-unknown-none*](platform-support/aarch64-unknown-none.md)
     - [aarch64_be-unknown-none-softfloat](platform-support/aarch64_be-unknown-none-softfloat.md)
     - [aarch64_be-unknown-linux-musl](platform-support/aarch64_be-unknown-linux-musl.md)
     - [amdgcn-amd-amdhsa](platform-support/amdgcn-amd-amdhsa.md)

From 409a1fbcba4214b0badf458801038f75fba5c707 Mon Sep 17 00:00:00 2001
From: Jonathan 'theJPster' Pallant <github@thejpster.org.uk>
Date: Wed, 10 Sep 2025 23:37:46 +0100
Subject: [PATCH 0787/1889] Update aarch64-unknown-none.md to include
 -softfloat too

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

diff --git a/src/doc/rustc/src/platform-support/aarch64-unknown-none.md b/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
index 0c1d477961984..f3c0764b5bf75 100644
--- a/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
+++ b/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
@@ -1,8 +1,8 @@
-# `aarch64-unknown-none`
+# `aarch64-unknown-none` and `aarch64-unknown-none-softfloat`
 
 **Tier: 2**
 
-Bare-metal target for CPUs in the Armv8-A architecture family, running in AArch64 mode.
+Bare-metal targets for CPUs in the Armv8-A architecture family, running in AArch64 mode.
 
 For the AArch32 mode carried over from Armv7-A, see
 [`armv7a-none-eabi`](armv7a-none-eabi.md) instead.

From 458f3873d65045cbf7e9950caa089a9fc0d9cd5a Mon Sep 17 00:00:00 2001
From: Daniel Paoliello <danpao@microsoft.com>
Date: Wed, 10 Sep 2025 15:39:13 -0700
Subject: [PATCH 0788/1889] Bump miow to 0.60.1

---
 Cargo.lock | 72 +++---------------------------------------------------
 1 file changed, 3 insertions(+), 69 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 8be13e84596da..2dc6e8ff10320 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2347,11 +2347,11 @@ dependencies = [
 
 [[package]]
 name = "miow"
-version = "0.6.0"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "359f76430b20a79f9e20e115b3428614e654f04fab314482fc0fda0ebd3c6044"
+checksum = "536bfad37a309d62069485248eeaba1e8d9853aaf951caaeaed0585a95346f08"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -6314,15 +6314,6 @@ dependencies = [
  "windows-link",
 ]
 
-[[package]]
-name = "windows-sys"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
-dependencies = [
- "windows-targets 0.48.5",
-]
-
 [[package]]
 name = "windows-sys"
 version = "0.52.0"
@@ -6350,21 +6341,6 @@ dependencies = [
  "windows-targets 0.53.3",
 ]
 
-[[package]]
-name = "windows-targets"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
-dependencies = [
- "windows_aarch64_gnullvm 0.48.5",
- "windows_aarch64_msvc 0.48.5",
- "windows_i686_gnu 0.48.5",
- "windows_i686_msvc 0.48.5",
- "windows_x86_64_gnu 0.48.5",
- "windows_x86_64_gnullvm 0.48.5",
- "windows_x86_64_msvc 0.48.5",
-]
-
 [[package]]
 name = "windows-targets"
 version = "0.52.6"
@@ -6407,12 +6383,6 @@ dependencies = [
  "windows-link",
 ]
 
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
-
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.52.6"
@@ -6425,12 +6395,6 @@ version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764"
 
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
-
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.52.6"
@@ -6443,12 +6407,6 @@ version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c"
 
-[[package]]
-name = "windows_i686_gnu"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
-
 [[package]]
 name = "windows_i686_gnu"
 version = "0.52.6"
@@ -6473,12 +6431,6 @@ version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11"
 
-[[package]]
-name = "windows_i686_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
-
 [[package]]
 name = "windows_i686_msvc"
 version = "0.52.6"
@@ -6491,12 +6443,6 @@ version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d"
 
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
-
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.52.6"
@@ -6509,12 +6455,6 @@ version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba"
 
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
-
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.52.6"
@@ -6527,12 +6467,6 @@ version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57"
 
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
-
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.52.6"

From fc58d8f5cce592998d0ba43b25e445eb6b96c827 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Thu, 11 Sep 2025 09:06:56 +0800
Subject: [PATCH 0789/1889] Add regression test for assert desugaring change

Using the MCVE reported in RUST-145770.
---
 tests/ui/macros/assert-desugaring-145770.rs   | 22 +++++++++++++++++++
 .../ui/macros/assert-desugaring-145770.stderr | 14 ++++++++++++
 2 files changed, 36 insertions(+)
 create mode 100644 tests/ui/macros/assert-desugaring-145770.rs
 create mode 100644 tests/ui/macros/assert-desugaring-145770.stderr

diff --git a/tests/ui/macros/assert-desugaring-145770.rs b/tests/ui/macros/assert-desugaring-145770.rs
new file mode 100644
index 0000000000000..9eb850f0380ca
--- /dev/null
+++ b/tests/ui/macros/assert-desugaring-145770.rs
@@ -0,0 +1,22 @@
+//! Regression test for #145770.
+//!
+//! Changing the `assert!` desugaring from an `if !cond {}` to `match` expression is
+//! backwards-incompatible, and may need to be done over an edition boundary or limit editions for
+//! which the desguaring change impacts.
+
+#[derive(Debug)]
+struct F {
+    data: bool
+}
+
+impl std::ops::Not for F {
+  type Output = bool;
+  fn not(self) -> Self::Output { !self.data }
+}
+
+fn main() {
+  let f = F { data: true };
+
+  assert!(f);
+  //~^ ERROR mismatched types
+}
diff --git a/tests/ui/macros/assert-desugaring-145770.stderr b/tests/ui/macros/assert-desugaring-145770.stderr
new file mode 100644
index 0000000000000..875ea8f7c3290
--- /dev/null
+++ b/tests/ui/macros/assert-desugaring-145770.stderr
@@ -0,0 +1,14 @@
+error[E0308]: mismatched types
+  --> $DIR/assert-desugaring-145770.rs:20:11
+   |
+LL |   assert!(f);
+   |           ^ expected `bool`, found `F`
+   |
+help: you might have meant to use field `data` whose type is `bool`
+   |
+LL |   assert!(f.data);
+   |            +++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0308`.

From b38a86f4d7c28ae9ab153b87c7e45037e56306fb Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Thu, 11 Sep 2025 09:00:01 +0800
Subject: [PATCH 0790/1889] Revert "Rollup merge of #122661 -
 estebank:assert-macro-span, r=petrochenkov"

This reverts commit 1eeb8e8b151d1da7daa73837a25dc5f7a1a7fa28, reversing
changes made to 324bf2b9fd8bf9661e7045c8a93f5ff0ec1a8ca5.

Unfortunately the assert desugaring change is not backwards compatible,
see RUST-145770.

Code such as

```rust
#[derive(Debug)]
struct F {
    data: bool
}

impl std::ops::Not for F {
  type Output = bool;
  fn not(self) -> Self::Output { !self.data }
}

fn main() {
  let f = F { data: true };

  assert!(f);
}
```

would be broken by the assert desugaring change. We may need to land
the change over an edition boundary, or limit the editions that the
desugaring change impacts.
---
 compiler/rustc_builtin_macros/src/assert.rs   | 35 +++++++---------
 .../src/error_reporting/infer/mod.rs          | 40 ++-----------------
 .../src/missing_asserts_for_indexing.rs       | 12 +++---
 src/tools/clippy/tests/ui/const_is_empty.rs   |  1 -
 .../clippy/tests/ui/const_is_empty.stderr     | 10 +----
 .../clippy/tests/ui/incompatible_msrv.rs      |  2 +-
 tests/ui/codemap_tests/issue-28308.rs         | 16 +-------
 tests/ui/codemap_tests/issue-28308.stderr     | 28 +++----------
 tests/ui/consts/control-flow/assert.stderr    |  4 +-
 ...st_monomorphization_error_backtrace.stderr |  8 ++--
 .../const-expr-generic-err.stderr             |  4 +-
 tests/ui/macros/assert-desugaring-145770.rs   |  3 +-
 .../ui/macros/assert-desugaring-145770.stderr | 14 -------
 tests/ui/macros/assert-macro-lifetimes.rs     |  8 ----
 tests/ui/mir/alignment/packed.rs              |  2 +-
 .../ui/simd/const-err-trumps-simd-err.stderr  |  4 +-
 tests/ui/transmutability/uninhabited.stderr   | 12 +++---
 17 files changed, 53 insertions(+), 150 deletions(-)
 delete mode 100644 tests/ui/macros/assert-desugaring-145770.stderr
 delete mode 100644 tests/ui/macros/assert-macro-lifetimes.rs

diff --git a/compiler/rustc_builtin_macros/src/assert.rs b/compiler/rustc_builtin_macros/src/assert.rs
index 013258a1b4efa..855da5caa312c 100644
--- a/compiler/rustc_builtin_macros/src/assert.rs
+++ b/compiler/rustc_builtin_macros/src/assert.rs
@@ -1,8 +1,8 @@
 mod context;
 
-use rustc_ast::token::{self, Delimiter};
+use rustc_ast::token::Delimiter;
 use rustc_ast::tokenstream::{DelimSpan, TokenStream};
-use rustc_ast::{DelimArgs, Expr, ExprKind, MacCall, Path, PathSegment};
+use rustc_ast::{DelimArgs, Expr, ExprKind, MacCall, Path, PathSegment, UnOp, token};
 use rustc_ast_pretty::pprust;
 use rustc_errors::PResult;
 use rustc_expand::base::{DummyResult, ExpandResult, ExtCtxt, MacEager, MacroExpanderResult};
@@ -29,7 +29,7 @@ pub(crate) fn expand_assert<'cx>(
 
     // `core::panic` and `std::panic` are different macros, so we use call-site
     // context to pick up whichever is currently in scope.
-    let call_site_span = cx.with_call_site_ctxt(cond_expr.span);
+    let call_site_span = cx.with_call_site_ctxt(span);
 
     let panic_path = || {
         if use_panic_2021(span) {
@@ -63,7 +63,7 @@ pub(crate) fn expand_assert<'cx>(
                 }),
             })),
         );
-        assert_cond_check(cx, call_site_span, cond_expr, then)
+        expr_if_not(cx, call_site_span, cond_expr, then, None)
     }
     // If `generic_assert` is enabled, generates rich captured outputs
     //
@@ -88,33 +88,26 @@ pub(crate) fn expand_assert<'cx>(
                 )),
             )],
         );
-        assert_cond_check(cx, call_site_span, cond_expr, then)
+        expr_if_not(cx, call_site_span, cond_expr, then, None)
     };
 
     ExpandResult::Ready(MacEager::expr(expr))
 }
 
-/// `assert!($cond_expr, $custom_message)`
 struct Assert {
     cond_expr: Box<Expr>,
     custom_message: Option<TokenStream>,
 }
 
-/// `match <cond> { true => {} _ => <then> }`
-fn assert_cond_check(cx: &ExtCtxt<'_>, span: Span, cond: Box<Expr>, then: Box<Expr>) -> Box<Expr> {
-    // Instead of expanding to `if !<cond> { <then> }`, we expand to
-    // `match <cond> { true => {} _ => <then> }`.
-    // This allows us to always complain about mismatched types instead of "cannot apply unary
-    // operator `!` to type `X`" when passing an invalid `<cond>`, while also allowing `<cond>` to
-    // be `&true`.
-    let els = cx.expr_block(cx.block(span, thin_vec![]));
-    let mut arms = thin_vec![];
-    arms.push(cx.arm(span, cx.pat_lit(span, cx.expr_bool(span, true)), els));
-    arms.push(cx.arm(span, cx.pat_wild(span), then));
-
-    // We wrap the `match` in a statement to limit the length of any borrows introduced in the
-    // condition.
-    cx.expr_block(cx.block(span, [cx.stmt_expr(cx.expr_match(span, cond, arms))].into()))
+// if !{ ... } { ... } else { ... }
+fn expr_if_not(
+    cx: &ExtCtxt<'_>,
+    span: Span,
+    cond: Box<Expr>,
+    then: Box<Expr>,
+    els: Option<Box<Expr>>,
+) -> Box<Expr> {
+    cx.expr_if(span, cx.expr(span, ExprKind::Unary(UnOp::Not, cond)), then, els)
 }
 
 fn parse_assert<'a>(cx: &ExtCtxt<'a>, sp: Span, stream: TokenStream) -> PResult<'a, Assert> {
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 d71110521ffa5..e18e294635b52 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
@@ -1618,18 +1618,8 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         {
             let e = self.tcx.erase_and_anonymize_regions(e);
             let f = self.tcx.erase_and_anonymize_regions(f);
-            let mut expected = with_forced_trimmed_paths!(e.sort_string(self.tcx));
-            let mut found = with_forced_trimmed_paths!(f.sort_string(self.tcx));
-            if let ObligationCauseCode::Pattern { span, .. } = cause.code()
-                && let Some(span) = span
-                && !span.from_expansion()
-                && cause.span.from_expansion()
-            {
-                // When the type error comes from a macro like `assert!()`, and we are pointing at
-                // code the user wrote the cause and effect are reversed as the expected value is
-                // what the macro expanded to.
-                (found, expected) = (expected, found);
-            }
+            let expected = with_forced_trimmed_paths!(e.sort_string(self.tcx));
+            let found = with_forced_trimmed_paths!(f.sort_string(self.tcx));
             if expected == found {
                 label_or_note(span, terr.to_string(self.tcx));
             } else {
@@ -2152,9 +2142,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
     ) -> Option<(DiagStyledString, DiagStyledString)> {
         match values {
             ValuePairs::Regions(exp_found) => self.expected_found_str(exp_found),
-            ValuePairs::Terms(exp_found) => {
-                self.expected_found_str_term(cause, exp_found, long_ty_path)
-            }
+            ValuePairs::Terms(exp_found) => self.expected_found_str_term(exp_found, long_ty_path),
             ValuePairs::Aliases(exp_found) => self.expected_found_str(exp_found),
             ValuePairs::ExistentialTraitRef(exp_found) => self.expected_found_str(exp_found),
             ValuePairs::ExistentialProjection(exp_found) => self.expected_found_str(exp_found),
@@ -2193,7 +2181,6 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
 
     fn expected_found_str_term(
         &self,
-        cause: &ObligationCause<'tcx>,
         exp_found: ty::error::ExpectedFound<ty::Term<'tcx>>,
         long_ty_path: &mut Option<PathBuf>,
     ) -> Option<(DiagStyledString, DiagStyledString)> {
@@ -2201,27 +2188,8 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         if exp_found.references_error() {
             return None;
         }
-        let (mut expected, mut found) = (exp_found.expected, exp_found.found);
-
-        if let ObligationCauseCode::Pattern { span, .. } = cause.code()
-            && let Some(span) = span
-            && !span.from_expansion()
-            && cause.span.from_expansion()
-        {
-            // When the type error comes from a macro like `assert!()`, and we are pointing at
-            // code the user wrote, the cause and effect are reversed as the expected value is
-            // what the macro expanded to. So if the user provided a `Type` when the macro is
-            // written in such a way that a `bool` was expected, we want to print:
-            // = note: expected `bool`
-            //            found `Type`"
-            // but as far as the compiler is concerned, after expansion what was expected was `Type`
-            // = note: expected `Type`
-            //            found `bool`"
-            // so we reverse them here to match user expectation.
-            (expected, found) = (found, expected);
-        }
 
-        Some(match (expected.kind(), found.kind()) {
+        Some(match (exp_found.expected.kind(), exp_found.found.kind()) {
             (ty::TermKind::Ty(expected), ty::TermKind::Ty(found)) => {
                 let (mut exp, mut fnd) = self.cmp(expected, found);
                 // Use the terminal width as the basis to determine when to compress the printed
diff --git a/src/tools/clippy/clippy_lints/src/missing_asserts_for_indexing.rs b/src/tools/clippy/clippy_lints/src/missing_asserts_for_indexing.rs
index 788a04357b1e2..cf0c85990b150 100644
--- a/src/tools/clippy/clippy_lints/src/missing_asserts_for_indexing.rs
+++ b/src/tools/clippy/clippy_lints/src/missing_asserts_for_indexing.rs
@@ -11,7 +11,7 @@ use rustc_ast::{BinOpKind, LitKind, RangeLimits};
 use rustc_data_structures::packed::Pu128;
 use rustc_data_structures::unhash::UnindexMap;
 use rustc_errors::{Applicability, Diag};
-use rustc_hir::{Body, Expr, ExprKind};
+use rustc_hir::{Block, Body, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
 use rustc_span::source_map::Spanned;
@@ -135,12 +135,12 @@ fn assert_len_expr<'hir>(
     cx: &LateContext<'_>,
     expr: &'hir Expr<'hir>,
 ) -> Option<(LengthComparison, usize, &'hir Expr<'hir>)> {
-    let (cmp, asserted_len, slice_len) = if let Some(
-        higher::IfLetOrMatch::Match(cond, [_, then], _)
-    ) = higher::IfLetOrMatch::parse(cx, expr)
-        && let ExprKind::Binary(bin_op, left, right) = &cond.kind
+    let (cmp, asserted_len, slice_len) = if let Some(higher::If { cond, then, .. }) = higher::If::hir(expr)
+        && let ExprKind::Unary(UnOp::Not, condition) = &cond.kind
+        && let ExprKind::Binary(bin_op, left, right) = &condition.kind
         // check if `then` block has a never type expression
-        && cx.typeck_results().expr_ty(then.body).is_never()
+        && let ExprKind::Block(Block { expr: Some(then_expr), .. }, _) = then.kind
+        && cx.typeck_results().expr_ty(then_expr).is_never()
     {
         len_comparison(bin_op.node, left, right)?
     } else if let Some((macro_call, bin_op)) = first_node_macro_backtrace(cx, expr).find_map(|macro_call| {
diff --git a/src/tools/clippy/tests/ui/const_is_empty.rs b/src/tools/clippy/tests/ui/const_is_empty.rs
index 63c6342a323ce..8bb4f0e5d9750 100644
--- a/src/tools/clippy/tests/ui/const_is_empty.rs
+++ b/src/tools/clippy/tests/ui/const_is_empty.rs
@@ -196,7 +196,6 @@ fn issue_13106() {
 
     const {
         assert!(EMPTY_STR.is_empty());
-        //~^ const_is_empty
     }
 
     const {
diff --git a/src/tools/clippy/tests/ui/const_is_empty.stderr b/src/tools/clippy/tests/ui/const_is_empty.stderr
index 9a42518698e39..2ba189058e832 100644
--- a/src/tools/clippy/tests/ui/const_is_empty.stderr
+++ b/src/tools/clippy/tests/ui/const_is_empty.stderr
@@ -158,16 +158,10 @@ LL |     let _ = val.is_empty();
    |             ^^^^^^^^^^^^^^
 
 error: this expression always evaluates to true
-  --> tests/ui/const_is_empty.rs:198:17
-   |
-LL |         assert!(EMPTY_STR.is_empty());
-   |                 ^^^^^^^^^^^^^^^^^^^^
-
-error: this expression always evaluates to true
-  --> tests/ui/const_is_empty.rs:203:9
+  --> tests/ui/const_is_empty.rs:202:9
    |
 LL |         EMPTY_STR.is_empty();
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 28 previous errors
+error: aborting due to 27 previous errors
 
diff --git a/src/tools/clippy/tests/ui/incompatible_msrv.rs b/src/tools/clippy/tests/ui/incompatible_msrv.rs
index 882f909e30c97..f7f21e1850d0a 100644
--- a/src/tools/clippy/tests/ui/incompatible_msrv.rs
+++ b/src/tools/clippy/tests/ui/incompatible_msrv.rs
@@ -1,6 +1,6 @@
 #![warn(clippy::incompatible_msrv)]
 #![feature(custom_inner_attributes)]
-#![allow(stable_features, clippy::diverging_sub_expression)]
+#![allow(stable_features)]
 #![feature(strict_provenance)] // For use in test
 #![clippy::msrv = "1.3.0"]
 
diff --git a/tests/ui/codemap_tests/issue-28308.rs b/tests/ui/codemap_tests/issue-28308.rs
index b0e04d0f1f6b1..81493f8c45311 100644
--- a/tests/ui/codemap_tests/issue-28308.rs
+++ b/tests/ui/codemap_tests/issue-28308.rs
@@ -1,16 +1,4 @@
 fn main() {
-    assert!("foo"); //~ ERROR mismatched types
-    //~^ NOTE expected `bool`, found `str`
-    //~| NOTE in this expansion of assert!
-    let x = Some(&1);
-    assert!(x); //~ ERROR mismatched types
-    //~^ NOTE expected `bool`, found `Option<&{integer}>`
-    //~| NOTE expected enum `bool`
-    //~| NOTE in this expansion of assert!
-    //~| NOTE in this expansion of assert!
-    assert!(x, ""); //~ ERROR mismatched types
-    //~^ NOTE expected `bool`, found `Option<&{integer}>`
-    //~| NOTE expected enum `bool`
-    //~| NOTE in this expansion of assert!
-    //~| NOTE in this expansion of assert!
+    assert!("foo");
+    //~^ ERROR cannot apply unary operator `!`
 }
diff --git a/tests/ui/codemap_tests/issue-28308.stderr b/tests/ui/codemap_tests/issue-28308.stderr
index e84ceb44aacba..7bc9e05dfc024 100644
--- a/tests/ui/codemap_tests/issue-28308.stderr
+++ b/tests/ui/codemap_tests/issue-28308.stderr
@@ -1,27 +1,9 @@
-error[E0308]: mismatched types
-  --> $DIR/issue-28308.rs:2:13
+error[E0600]: cannot apply unary operator `!` to type `&'static str`
+  --> $DIR/issue-28308.rs:2:5
    |
 LL |     assert!("foo");
-   |             ^^^^^ expected `bool`, found `str`
+   |     ^^^^^^^^^^^^^^ cannot apply unary operator `!`
 
-error[E0308]: mismatched types
-  --> $DIR/issue-28308.rs:6:13
-   |
-LL |     assert!(x);
-   |             ^ expected `bool`, found `Option<&{integer}>`
-   |
-   = note: expected enum `bool`
-              found type `Option<&{integer}>`
-
-error[E0308]: mismatched types
-  --> $DIR/issue-28308.rs:11:13
-   |
-LL |     assert!(x, "");
-   |             ^ expected `bool`, found `Option<&{integer}>`
-   |
-   = note: expected enum `bool`
-              found type `Option<&{integer}>`
-
-error: aborting due to 3 previous errors
+error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0308`.
+For more information about this error, try `rustc --explain E0600`.
diff --git a/tests/ui/consts/control-flow/assert.stderr b/tests/ui/consts/control-flow/assert.stderr
index deaad6abbccf6..026097a6ba0e1 100644
--- a/tests/ui/consts/control-flow/assert.stderr
+++ b/tests/ui/consts/control-flow/assert.stderr
@@ -1,8 +1,8 @@
 error[E0080]: evaluation panicked: assertion failed: false
-  --> $DIR/assert.rs:5:23
+  --> $DIR/assert.rs:5:15
    |
 LL | const _: () = assert!(false);
-   |                       ^^^^^ evaluation of `_` failed here
+   |               ^^^^^^^^^^^^^^ evaluation of `_` failed here
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/generics/post_monomorphization_error_backtrace.stderr b/tests/ui/generics/post_monomorphization_error_backtrace.stderr
index 92c7df73638f5..6953414f0c235 100644
--- a/tests/ui/generics/post_monomorphization_error_backtrace.stderr
+++ b/tests/ui/generics/post_monomorphization_error_backtrace.stderr
@@ -1,8 +1,8 @@
 error[E0080]: evaluation panicked: assertion failed: std::mem::size_of::<T>() == 0
-  --> $DIR/post_monomorphization_error_backtrace.rs:6:31
+  --> $DIR/post_monomorphization_error_backtrace.rs:6:23
    |
 LL |         const V: () = assert!(std::mem::size_of::<T>() == 0);
-   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `assert_zst::F::<u32>::V` failed here
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `assert_zst::F::<u32>::V` failed here
 
 note: erroneous constant encountered
   --> $DIR/post_monomorphization_error_backtrace.rs:14:5
@@ -17,10 +17,10 @@ LL |     assert_zst::<U>()
    |     ^^^^^^^^^^^^^^^^^
 
 error[E0080]: evaluation panicked: assertion failed: std::mem::size_of::<T>() == 0
-  --> $DIR/post_monomorphization_error_backtrace.rs:6:31
+  --> $DIR/post_monomorphization_error_backtrace.rs:6:23
    |
 LL |         const V: () = assert!(std::mem::size_of::<T>() == 0);
-   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `assert_zst::F::<i32>::V` failed here
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `assert_zst::F::<i32>::V` failed here
 
 note: erroneous constant encountered
   --> $DIR/post_monomorphization_error_backtrace.rs:14:5
diff --git a/tests/ui/inline-const/const-expr-generic-err.stderr b/tests/ui/inline-const/const-expr-generic-err.stderr
index e053e88db172f..26039ba6d4449 100644
--- a/tests/ui/inline-const/const-expr-generic-err.stderr
+++ b/tests/ui/inline-const/const-expr-generic-err.stderr
@@ -1,8 +1,8 @@
 error[E0080]: evaluation panicked: assertion failed: std::mem::size_of::<T>() == 0
-  --> $DIR/const-expr-generic-err.rs:4:21
+  --> $DIR/const-expr-generic-err.rs:4:13
    |
 LL |     const { assert!(std::mem::size_of::<T>() == 0); }
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `foo::<i32>::{constant#0}` failed here
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `foo::<i32>::{constant#0}` failed here
 
 note: erroneous constant encountered
   --> $DIR/const-expr-generic-err.rs:4:5
diff --git a/tests/ui/macros/assert-desugaring-145770.rs b/tests/ui/macros/assert-desugaring-145770.rs
index 9eb850f0380ca..d56e771ecfb07 100644
--- a/tests/ui/macros/assert-desugaring-145770.rs
+++ b/tests/ui/macros/assert-desugaring-145770.rs
@@ -4,6 +4,8 @@
 //! backwards-incompatible, and may need to be done over an edition boundary or limit editions for
 //! which the desguaring change impacts.
 
+//@ check-pass
+
 #[derive(Debug)]
 struct F {
     data: bool
@@ -18,5 +20,4 @@ fn main() {
   let f = F { data: true };
 
   assert!(f);
-  //~^ ERROR mismatched types
 }
diff --git a/tests/ui/macros/assert-desugaring-145770.stderr b/tests/ui/macros/assert-desugaring-145770.stderr
deleted file mode 100644
index 875ea8f7c3290..0000000000000
--- a/tests/ui/macros/assert-desugaring-145770.stderr
+++ /dev/null
@@ -1,14 +0,0 @@
-error[E0308]: mismatched types
-  --> $DIR/assert-desugaring-145770.rs:20:11
-   |
-LL |   assert!(f);
-   |           ^ expected `bool`, found `F`
-   |
-help: you might have meant to use field `data` whose type is `bool`
-   |
-LL |   assert!(f.data);
-   |            +++++
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/macros/assert-macro-lifetimes.rs b/tests/ui/macros/assert-macro-lifetimes.rs
deleted file mode 100644
index cc25928320477..0000000000000
--- a/tests/ui/macros/assert-macro-lifetimes.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-//@ check-pass
-#[derive(PartialEq, Eq, Hash)]
-struct S;
-fn main() {
-    let foo = std::rc::Rc::new(std::cell::RefCell::new(std::collections::HashMap::<S, S>::new()));
-    // Ensure that the lifetimes of the borrow do not leak past the end of `main`.
-    assert!(matches!(foo.borrow().get(&S).unwrap(), S))
-}
diff --git a/tests/ui/mir/alignment/packed.rs b/tests/ui/mir/alignment/packed.rs
index aa79880a21a22..cf908365e1a5d 100644
--- a/tests/ui/mir/alignment/packed.rs
+++ b/tests/ui/mir/alignment/packed.rs
@@ -12,7 +12,7 @@ fn main() {
     // Test that we can use addr_of! to get the address of a packed member which according to its
     // type is not aligned, but because it is a projection from a packed type is a valid place.
     let ptr0 = std::ptr::addr_of!(memory[0].tail);
-    let ptr1 = std::ptr::addr_of!(memory[1].tail);
+    let ptr1 = std::ptr::addr_of!(memory[0].tail);
     // Even if ptr0 happens to be aligned by chance, ptr1 is not.
     assert!(!ptr0.is_aligned() || !ptr1.is_aligned());
 
diff --git a/tests/ui/simd/const-err-trumps-simd-err.stderr b/tests/ui/simd/const-err-trumps-simd-err.stderr
index 6d25a28c92c5c..93d1fce637f2f 100644
--- a/tests/ui/simd/const-err-trumps-simd-err.stderr
+++ b/tests/ui/simd/const-err-trumps-simd-err.stderr
@@ -1,8 +1,8 @@
 error[E0080]: evaluation panicked: assertion failed: LANE < 4
-  --> $DIR/const-err-trumps-simd-err.rs:17:21
+  --> $DIR/const-err-trumps-simd-err.rs:17:13
    |
 LL |     const { assert!(LANE < 4); } // the error should be here...
-   |                     ^^^^^^^^ evaluation of `get_elem::<4>::{constant#0}` failed here
+   |             ^^^^^^^^^^^^^^^^^ evaluation of `get_elem::<4>::{constant#0}` failed here
 
 note: erroneous constant encountered
   --> $DIR/const-err-trumps-simd-err.rs:17:5
diff --git a/tests/ui/transmutability/uninhabited.stderr b/tests/ui/transmutability/uninhabited.stderr
index 9f289852809c2..4757daec9978a 100644
--- a/tests/ui/transmutability/uninhabited.stderr
+++ b/tests/ui/transmutability/uninhabited.stderr
@@ -41,10 +41,10 @@ LL | |         }>
    | |__________^ required by this bound in `is_maybe_transmutable`
 
 error[E0080]: evaluation panicked: assertion failed: false
-  --> $DIR/uninhabited.rs:41:17
+  --> $DIR/uninhabited.rs:41:9
    |
 LL |         assert!(false);
-   |                 ^^^^^ evaluation of `yawning_void_struct::_` failed here
+   |         ^^^^^^^^^^^^^^ evaluation of `yawning_void_struct::_` failed here
 
 error[E0277]: `()` cannot be safely transmuted into `yawning_void_enum::Void`
   --> $DIR/uninhabited.rs:71:41
@@ -68,10 +68,10 @@ LL | |         }>
    | |__________^ required by this bound in `is_maybe_transmutable`
 
 error[E0080]: evaluation panicked: assertion failed: false
-  --> $DIR/uninhabited.rs:63:17
+  --> $DIR/uninhabited.rs:63:9
    |
 LL |         assert!(false);
-   |                 ^^^^^ evaluation of `yawning_void_enum::_` failed here
+   |         ^^^^^^^^^^^^^^ evaluation of `yawning_void_enum::_` failed here
 
 error[E0277]: `u128` cannot be safely transmuted into `DistantVoid`
   --> $DIR/uninhabited.rs:92:43
@@ -95,10 +95,10 @@ LL | |         }>
    | |__________^ required by this bound in `is_maybe_transmutable`
 
 error[E0080]: evaluation panicked: assertion failed: false
-  --> $DIR/uninhabited.rs:87:17
+  --> $DIR/uninhabited.rs:87:9
    |
 LL |         assert!(false);
-   |                 ^^^^^ evaluation of `distant_void::_` failed here
+   |         ^^^^^^^^^^^^^^ evaluation of `distant_void::_` failed here
 
 error[E0277]: `Src` cannot be safely transmuted into `issue_126267::Error`
   --> $DIR/uninhabited.rs:108:42

From ba107fcffba2aefc83e199286a5ccdbb29f69d5d Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Thu, 11 Sep 2025 09:00:01 +0800
Subject: [PATCH 0791/1889] Revert "Rollup merge of #122661 -
 estebank:assert-macro-span, r=petrochenkov"

This reverts commit 1eeb8e8b151d1da7daa73837a25dc5f7a1a7fa28, reversing
changes made to 324bf2b9fd8bf9661e7045c8a93f5ff0ec1a8ca5.

Unfortunately the assert desugaring change is not backwards compatible,
see RUST-145770.

Code such as

```rust
#[derive(Debug)]
struct F {
    data: bool
}

impl std::ops::Not for F {
  type Output = bool;
  fn not(self) -> Self::Output { !self.data }
}

fn main() {
  let f = F { data: true };

  assert!(f);
}
```

would be broken by the assert desugaring change. We may need to land
the change over an edition boundary, or limit the editions that the
desugaring change impacts.
---
 clippy_lints/src/missing_asserts_for_indexing.rs | 12 ++++++------
 tests/ui/const_is_empty.rs                       |  1 -
 tests/ui/const_is_empty.stderr                   | 10 ++--------
 tests/ui/incompatible_msrv.rs                    |  2 +-
 4 files changed, 9 insertions(+), 16 deletions(-)

diff --git a/clippy_lints/src/missing_asserts_for_indexing.rs b/clippy_lints/src/missing_asserts_for_indexing.rs
index 788a04357b1e2..cf0c85990b150 100644
--- a/clippy_lints/src/missing_asserts_for_indexing.rs
+++ b/clippy_lints/src/missing_asserts_for_indexing.rs
@@ -11,7 +11,7 @@ use rustc_ast::{BinOpKind, LitKind, RangeLimits};
 use rustc_data_structures::packed::Pu128;
 use rustc_data_structures::unhash::UnindexMap;
 use rustc_errors::{Applicability, Diag};
-use rustc_hir::{Body, Expr, ExprKind};
+use rustc_hir::{Block, Body, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
 use rustc_span::source_map::Spanned;
@@ -135,12 +135,12 @@ fn assert_len_expr<'hir>(
     cx: &LateContext<'_>,
     expr: &'hir Expr<'hir>,
 ) -> Option<(LengthComparison, usize, &'hir Expr<'hir>)> {
-    let (cmp, asserted_len, slice_len) = if let Some(
-        higher::IfLetOrMatch::Match(cond, [_, then], _)
-    ) = higher::IfLetOrMatch::parse(cx, expr)
-        && let ExprKind::Binary(bin_op, left, right) = &cond.kind
+    let (cmp, asserted_len, slice_len) = if let Some(higher::If { cond, then, .. }) = higher::If::hir(expr)
+        && let ExprKind::Unary(UnOp::Not, condition) = &cond.kind
+        && let ExprKind::Binary(bin_op, left, right) = &condition.kind
         // check if `then` block has a never type expression
-        && cx.typeck_results().expr_ty(then.body).is_never()
+        && let ExprKind::Block(Block { expr: Some(then_expr), .. }, _) = then.kind
+        && cx.typeck_results().expr_ty(then_expr).is_never()
     {
         len_comparison(bin_op.node, left, right)?
     } else if let Some((macro_call, bin_op)) = first_node_macro_backtrace(cx, expr).find_map(|macro_call| {
diff --git a/tests/ui/const_is_empty.rs b/tests/ui/const_is_empty.rs
index 63c6342a323ce..8bb4f0e5d9750 100644
--- a/tests/ui/const_is_empty.rs
+++ b/tests/ui/const_is_empty.rs
@@ -196,7 +196,6 @@ fn issue_13106() {
 
     const {
         assert!(EMPTY_STR.is_empty());
-        //~^ const_is_empty
     }
 
     const {
diff --git a/tests/ui/const_is_empty.stderr b/tests/ui/const_is_empty.stderr
index 9a42518698e39..2ba189058e832 100644
--- a/tests/ui/const_is_empty.stderr
+++ b/tests/ui/const_is_empty.stderr
@@ -158,16 +158,10 @@ LL |     let _ = val.is_empty();
    |             ^^^^^^^^^^^^^^
 
 error: this expression always evaluates to true
-  --> tests/ui/const_is_empty.rs:198:17
-   |
-LL |         assert!(EMPTY_STR.is_empty());
-   |                 ^^^^^^^^^^^^^^^^^^^^
-
-error: this expression always evaluates to true
-  --> tests/ui/const_is_empty.rs:203:9
+  --> tests/ui/const_is_empty.rs:202:9
    |
 LL |         EMPTY_STR.is_empty();
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 28 previous errors
+error: aborting due to 27 previous errors
 
diff --git a/tests/ui/incompatible_msrv.rs b/tests/ui/incompatible_msrv.rs
index 882f909e30c97..f7f21e1850d0a 100644
--- a/tests/ui/incompatible_msrv.rs
+++ b/tests/ui/incompatible_msrv.rs
@@ -1,6 +1,6 @@
 #![warn(clippy::incompatible_msrv)]
 #![feature(custom_inner_attributes)]
-#![allow(stable_features, clippy::diverging_sub_expression)]
+#![allow(stable_features)]
 #![feature(strict_provenance)] // For use in test
 #![clippy::msrv = "1.3.0"]
 

From 2d87bc3e6bfc9e6ccda01a5898980b1e0a706708 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Thu, 11 Sep 2025 10:23:02 +0800
Subject: [PATCH 0792/1889] Fix empty generic param list for generate_function

Example
---
```rust
struct Foo<S>(S);
impl<S> Foo<S> {
    fn foo(&self) {
        self.bar()$0;
    }
}
```

**Before this PR**:

```rust
struct Foo<S>(S);
impl<S> Foo<S> {
    fn foo(&self) {
        self.bar();
    }

    fn bar<>(&self) ${0:-> _} {
        todo!()
    }
}
```

**After this PR**:

```rust
struct Foo<S>(S);
impl<S> Foo<S> {
    fn foo(&self) {
        self.bar();
    }

    fn bar(&self) ${0:-> _} {
        todo!()
    }
}
```
---
 .../src/handlers/generate_function.rs         | 31 ++++++++++++++++++-
 1 file changed, 30 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_function.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_function.rs
index 88ed6f9ce124d..a9cf2c1bae1a4 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_function.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_function.rs
@@ -364,11 +364,13 @@ impl FunctionBuilder {
             Visibility::Crate => Some(make::visibility_pub_crate()),
             Visibility::Pub => Some(make::visibility_pub()),
         };
+        let type_params =
+            self.generic_param_list.filter(|list| list.generic_params().next().is_some());
         let fn_def = make::fn_(
             None,
             visibility,
             self.fn_name,
-            self.generic_param_list,
+            type_params,
             self.where_clause,
             self.params,
             self.fn_body,
@@ -2415,6 +2417,33 @@ impl Foo {
         )
     }
 
+    #[test]
+    fn create_method_with_unused_generics() {
+        check_assist(
+            generate_function,
+            r#"
+struct Foo<S>(S);
+impl<S> Foo<S> {
+    fn foo(&self) {
+        self.bar()$0;
+    }
+}
+"#,
+            r#"
+struct Foo<S>(S);
+impl<S> Foo<S> {
+    fn foo(&self) {
+        self.bar();
+    }
+
+    fn bar(&self) ${0:-> _} {
+        todo!()
+    }
+}
+"#,
+        )
+    }
+
     #[test]
     fn create_function_with_async() {
         check_assist(

From 68bff8cb9db58d7006f609971e6961646b44dbe9 Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Thu, 11 Sep 2025 04:53:20 +0000
Subject: [PATCH 0793/1889] Prepare for merging from rust-lang/rust

This updates the rust-version file to f4665ab8368ad2e8a86d4390ae35c28bdd9561bb.
---
 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 5b3139b25092b..b71a0d219d778 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-a09fbe2c8372643a27a8082236120f95ed4e6bba
+f4665ab8368ad2e8a86d4390ae35c28bdd9561bb

From e54cc43867efe10c73a6063ef36fcc5aa8570ffb Mon Sep 17 00:00:00 2001
From: Tsukasa OI <floss_rust@irq.a4lg.com>
Date: Thu, 11 Sep 2025 06:26:51 +0000
Subject: [PATCH 0794/1889] RISC-V: "Lower" requirements of `aes64im`

This instruction is incorrectly categorized as the same one as
`aes64ks1i` and `aes64ks2` (that should require `zkne || zknd` but
currently require `zkne && zknd`) but `aes64im` only requires
the Zknd extension.

This commit fixes the category of this intrinsic (lowering the
requirements from the Rust perspective but it does not actually lower
it from the RISC-V perspective).
---
 library/stdarch/crates/core_arch/src/riscv64/zk.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/stdarch/crates/core_arch/src/riscv64/zk.rs b/library/stdarch/crates/core_arch/src/riscv64/zk.rs
index c6af750bbc570..a30653cbe0885 100644
--- a/library/stdarch/crates/core_arch/src/riscv64/zk.rs
+++ b/library/stdarch/crates/core_arch/src/riscv64/zk.rs
@@ -176,7 +176,7 @@ pub fn aes64ks2(rs1: u64, rs2: u64) -> u64 {
 /// Version: v1.0.1
 ///
 /// Section: 3.9
-#[target_feature(enable = "zkne", enable = "zknd")]
+#[target_feature(enable = "zknd")]
 #[cfg_attr(test, assert_instr(aes64im))]
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]

From 9fe101b6ea204256bffef357c646012d571416ee Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martin=20Kr=C3=B6ning?=
 <martin.kroening@eonerc.rwth-aachen.de>
Date: Wed, 10 Sep 2025 16:25:57 +0200
Subject: [PATCH 0795/1889] Remove unused import from sys/pal/hermit/os.rs

This fixes

```
error: unused import: `str`
 --> library/std/src/sys/pal/hermit/os.rs:6:22
  |
6 | use crate::{fmt, io, str};
  |                      ^^^
  |
  = note: `-D unused-imports` implied by `-D warnings`
  = help: to override `-D warnings` add `#[allow(unused_imports)]`
```

This was caused by 845311a065a5638c516ed96c73b09862b176b329.
---
 library/std/src/sys/pal/hermit/os.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/std/src/sys/pal/hermit/os.rs b/library/std/src/sys/pal/hermit/os.rs
index 0fe713a503bd0..9681964ed9b2f 100644
--- a/library/std/src/sys/pal/hermit/os.rs
+++ b/library/std/src/sys/pal/hermit/os.rs
@@ -3,7 +3,7 @@ use crate::ffi::{OsStr, OsString};
 use crate::marker::PhantomData;
 use crate::path::{self, PathBuf};
 use crate::sys::unsupported;
-use crate::{fmt, io, str};
+use crate::{fmt, io};
 
 pub fn errno() -> i32 {
     unsafe { hermit_abi::get_errno() }

From af5355cc91fb48ed3d1bf31200b4311f801d24a6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martin=20Kr=C3=B6ning?=
 <martin.kroening@eonerc.rwth-aachen.de>
Date: Wed, 10 Sep 2025 15:26:59 +0200
Subject: [PATCH 0796/1889] Implement `Socket::take_error` for Hermit

---
 library/std/src/sys/net/connection/socket/hermit.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/library/std/src/sys/net/connection/socket/hermit.rs b/library/std/src/sys/net/connection/socket/hermit.rs
index f49821657d940..5200eaa5786ad 100644
--- a/library/std/src/sys/net/connection/socket/hermit.rs
+++ b/library/std/src/sys/net/connection/socket/hermit.rs
@@ -304,7 +304,8 @@ impl Socket {
     }
 
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
-        unimplemented!()
+        let raw: c_int = getsockopt(self, libc::SOL_SOCKET, libc::SO_ERROR)?;
+        if raw == 0 { Ok(None) } else { Ok(Some(io::Error::from_raw_os_error(raw as i32))) }
     }
 
     // This is used by sys_common code to abstract over Windows and Unix.

From d8f084217f9492d7ed0f575538a0ab51324c58aa Mon Sep 17 00:00:00 2001
From: karan <karanjanthe@gmail.com>
Date: Tue, 13 May 2025 20:32:08 +0530
Subject: [PATCH 0797/1889] docs: typetree in autodiff

---
 src/doc/rustc-dev-guide/src/SUMMARY.md        |   1 +
 .../src/autodiff/type-trees.md                | 193 ++++++++++++++++++
 2 files changed, 194 insertions(+)
 create mode 100644 src/doc/rustc-dev-guide/src/autodiff/type-trees.md

diff --git a/src/doc/rustc-dev-guide/src/SUMMARY.md b/src/doc/rustc-dev-guide/src/SUMMARY.md
index a1612738537d7..249140956c09a 100644
--- a/src/doc/rustc-dev-guide/src/SUMMARY.md
+++ b/src/doc/rustc-dev-guide/src/SUMMARY.md
@@ -108,6 +108,7 @@
     - [Installation](./autodiff/installation.md)
     - [How to debug](./autodiff/debugging.md)
     - [Autodiff flags](./autodiff/flags.md)
+    - [Type Trees](./autodiff/type-trees.md)
 
 # Source Code Representation
 
diff --git a/src/doc/rustc-dev-guide/src/autodiff/type-trees.md b/src/doc/rustc-dev-guide/src/autodiff/type-trees.md
new file mode 100644
index 0000000000000..68cb78650b009
--- /dev/null
+++ b/src/doc/rustc-dev-guide/src/autodiff/type-trees.md
@@ -0,0 +1,193 @@
+# TypeTrees for Autodiff
+
+## What are TypeTrees?
+Memory layout descriptors for Enzyme. Tell Enzyme exactly how types are structured in memory so it can compute derivatives efficiently.
+
+## Structure
+```rust
+TypeTree(Vec<Type>)
+
+Type {
+    offset: isize,  // byte offset (-1 = everywhere)
+    size: usize,    // size in bytes
+    kind: Kind,     // Float, Integer, Pointer, etc.
+    child: TypeTree // nested structure
+}
+```
+
+## Example: `fn compute(x: &f32, data: &[f32]) -> f32`
+
+**Input 0: `x: &f32`**
+```rust
+TypeTree(vec![Type {
+    offset: -1, size: 8, kind: Pointer,
+    child: TypeTree(vec![Type {
+        offset: 0, size: 4, kind: Float,  // Single value: use offset 0
+        child: TypeTree::new()
+    }])
+}])
+```
+
+**Input 1: `data: &[f32]`**
+```rust
+TypeTree(vec![Type {
+    offset: -1, size: 8, kind: Pointer,
+    child: TypeTree(vec![Type {
+        offset: -1, size: 4, kind: Float,  // -1 = all elements
+        child: TypeTree::new()
+    }])
+}])
+```
+
+**Output: `f32`**
+```rust
+TypeTree(vec![Type {
+    offset: 0, size: 4, kind: Float,  // Single scalar: use offset 0
+    child: TypeTree::new()
+}])
+```
+
+## Why Needed?
+- Enzyme can't deduce complex type layouts from LLVM IR
+- Prevents slow memory pattern analysis
+- Enables correct derivative computation for nested structures
+- Tells Enzyme which bytes are differentiable vs metadata
+
+## What Enzyme Does With This Information:
+
+Without TypeTrees:
+```llvm
+; Enzyme sees generic LLVM IR:
+define float @distance(ptr %p1, ptr %p2) {
+; Has to guess what these pointers point to
+; Slow analysis of all memory operations
+; May miss optimization opportunities
+}
+```
+
+With TypeTrees:
+```llvm
+define "enzyme_type"="{[-1]:Float@float}" float @distance(
+    ptr "enzyme_type"="{[-1]:Pointer, [-1,0]:Float@float}" %p1, 
+    ptr "enzyme_type"="{[-1]:Pointer, [-1,0]:Float@float}" %p2
+) {
+; Enzyme knows exact type layout
+; Can generate efficient derivative code directly
+}
+```
+
+# TypeTrees - Offset and -1 Explained
+
+## Type Structure
+
+```rust
+Type {
+    offset: isize, // WHERE this type starts
+    size: usize,   // HOW BIG this type is
+    kind: Kind,    // WHAT KIND of data (Float, Int, Pointer)
+    child: TypeTree // WHAT'S INSIDE (for pointers/containers)
+}
+```
+
+## Offset Values
+
+### Regular Offset (0, 4, 8, etc.)
+**Specific byte position within a structure**
+
+```rust
+struct Point {
+    x: f32, // offset 0, size 4
+    y: f32, // offset 4, size 4
+    id: i32, // offset 8, size 4
+}
+```
+
+TypeTree for `&Point` (internal representation):
+```rust
+TypeTree(vec![
+    Type { offset: 0, size: 4, kind: Float },   // x at byte 0
+    Type { offset: 4, size: 4, kind: Float },   // y at byte 4
+    Type { offset: 8, size: 4, kind: Integer }  // id at byte 8
+])
+```
+
+Generates LLVM
+```llvm
+"enzyme_type"="{[-1]:Pointer, [-1,0]:Float@float, [-1,4]:Float@float, [-1,8]:Integer, [-1,9]:Integer, [-1,10]:Integer, [-1,11]:Integer}"
+```
+
+### Offset -1 (Special: "Everywhere")
+**Means "this pattern repeats for ALL elements"**
+
+#### Example 1: Direct Array `[f32; 100]` (no pointer indirection)
+```rust
+TypeTree(vec![Type {
+    offset: -1, // ALL positions
+    size: 4,    // each f32 is 4 bytes
+    kind: Float, // every element is float
+}])
+```
+
+Generates LLVM: `"enzyme_type"="{[-1]:Float@float}"`
+
+#### Example 1b: Array Reference `&[f32; 100]` (with pointer indirection)  
+```rust
+TypeTree(vec![Type {
+    offset: -1, size: 8, kind: Pointer,
+    child: TypeTree(vec![Type {
+        offset: -1, // ALL array elements
+        size: 4,    // each f32 is 4 bytes
+        kind: Float, // every element is float
+    }])
+}])
+```
+
+Generates LLVM: `"enzyme_type"="{[-1]:Pointer, [-1,-1]:Float@float}"`
+
+Instead of listing 100 separate Types with offsets `0,4,8,12...396`
+
+#### Example 2: Slice `&[i32]`
+```rust
+// Pointer to slice data
+TypeTree(vec![Type {
+    offset: -1, size: 8, kind: Pointer,
+    child: TypeTree(vec![Type {
+        offset: -1, // ALL slice elements
+        size: 4,    // each i32 is 4 bytes
+        kind: Integer
+    }])
+}])
+```
+
+Generates LLVM: `"enzyme_type"="{[-1]:Pointer, [-1,-1]:Integer}"`
+
+#### Example 3: Mixed Structure
+```rust
+struct Container {
+    header: i64,        // offset 0
+    data: [f32; 1000],  // offset 8, but elements use -1
+}
+```
+
+```rust
+TypeTree(vec![
+    Type { offset: 0, size: 8, kind: Integer }, // header
+    Type { offset: 8, size: 4000, kind: Pointer,
+        child: TypeTree(vec![Type {
+            offset: -1, size: 4, kind: Float // ALL array elements
+        }])
+    }
+])
+```
+
+## Key Distinction: Single Values vs Arrays
+
+**Single Values** use offset `0` for precision:
+- `&f32` has exactly one f32 value at offset 0
+- More precise than using -1 ("everywhere")  
+- Generates: `{[-1]:Pointer, [-1,0]:Float@float}`
+
+**Arrays** use offset `-1` for efficiency:
+- `&[f32; 100]` has the same pattern repeated 100 times
+- Using -1 avoids listing 100 separate offsets
+- Generates: `{[-1]:Pointer, [-1,-1]:Float@float}`
\ No newline at end of file

From 092802640f760d5a59b644110b8b0186a743ee2f Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 11 Sep 2025 10:04:32 +0200
Subject: [PATCH 0798/1889] rwlock tests: fix miri macos test regression

---
 library/std/tests/sync/rwlock.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/library/std/tests/sync/rwlock.rs b/library/std/tests/sync/rwlock.rs
index eca15d2a4adb8..2554316e90716 100644
--- a/library/std/tests/sync/rwlock.rs
+++ b/library/std/tests/sync/rwlock.rs
@@ -50,7 +50,7 @@ nonpoison_and_poison_unwrap_test!(
 // FIXME: On macOS we use a provenance-incorrect implementation and Miri
 // catches that issue with a chance of around 1/1000.
 // See <https://github.com/rust-lang/rust/issues/121950> for details.
-#[cfg_attr(all(miri, target_os = "macos"), ignore)]
+#[cfg(not(all(miri, target_os = "macos")))]
 nonpoison_and_poison_unwrap_test!(
     name: frob,
     test_body: {
@@ -315,7 +315,7 @@ nonpoison_and_poison_unwrap_test!(
 
 // FIXME: On macOS we use a provenance-incorrect implementation and Miri catches that issue.
 // See <https://github.com/rust-lang/rust/issues/121950> for details.
-#[cfg_attr(all(miri, target_os = "macos"), ignore)]
+#[cfg(not(all(miri, target_os = "macos")))]
 nonpoison_and_poison_unwrap_test!(
     name: test_downgrade_observe,
     test_body: {
@@ -362,7 +362,7 @@ nonpoison_and_poison_unwrap_test!(
 
 // FIXME: On macOS we use a provenance-incorrect implementation and Miri catches that issue.
 // See <https://github.com/rust-lang/rust/issues/121950> for details.
-#[cfg_attr(all(miri, target_os = "macos"), ignore)]
+#[cfg(not(all(miri, target_os = "macos")))]
 nonpoison_and_poison_unwrap_test!(
     name: test_downgrade_atomic,
     test_body: {

From fd48528d185f59f60e301bce1e01d670ff4bdb30 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Wed, 10 Sep 2025 00:17:22 +0200
Subject: [PATCH 0799/1889] c-variadic: allow inherent methods to be c-variadic

---
 .../rustc_ast_passes/src/ast_validation.rs    | 54 ++++++++++---------
 tests/ui/c-variadic/inherent-method.rs        | 45 ++++++++++++++++
 tests/ui/c-variadic/not-async.rs              | 10 +++-
 tests/ui/c-variadic/not-async.stderr          | 30 ++++++++---
 tests/ui/c-variadic/trait-method.rs           | 40 ++++++++++++++
 tests/ui/c-variadic/trait-method.stderr       | 14 +++++
 .../variadic-ffi-semantic-restrictions.rs     | 10 ++--
 .../variadic-ffi-semantic-restrictions.stderr | 20 +++++--
 8 files changed, 179 insertions(+), 44 deletions(-)
 create mode 100644 tests/ui/c-variadic/inherent-method.rs
 create mode 100644 tests/ui/c-variadic/trait-method.rs
 create mode 100644 tests/ui/c-variadic/trait-method.stderr

diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index a6ef89b553db4..cdb3062c59178 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -696,36 +696,38 @@ impl<'a> AstValidator<'a> {
 
         match fn_ctxt {
             FnCtxt::Foreign => return,
-            FnCtxt::Free => match sig.header.ext {
-                Extern::Implicit(_) => {
-                    if !matches!(sig.header.safety, Safety::Unsafe(_)) {
-                        self.dcx().emit_err(errors::CVariadicMustBeUnsafe {
-                            span: variadic_param.span,
-                            unsafe_span: sig.safety_span(),
-                        });
-                    }
-                }
-                Extern::Explicit(StrLit { symbol_unescaped, .. }, _) => {
-                    if !matches!(symbol_unescaped, sym::C | sym::C_dash_unwind) {
-                        self.dcx().emit_err(errors::CVariadicBadExtern {
-                            span: variadic_param.span,
-                            abi: symbol_unescaped,
-                            extern_span: sig.extern_span(),
-                        });
+            FnCtxt::Free | FnCtxt::Assoc(AssocCtxt::Impl { of_trait: false }) => {
+                match sig.header.ext {
+                    Extern::Implicit(_) => {
+                        if !matches!(sig.header.safety, Safety::Unsafe(_)) {
+                            self.dcx().emit_err(errors::CVariadicMustBeUnsafe {
+                                span: variadic_param.span,
+                                unsafe_span: sig.safety_span(),
+                            });
+                        }
                     }
+                    Extern::Explicit(StrLit { symbol_unescaped, .. }, _) => {
+                        if !matches!(symbol_unescaped, sym::C | sym::C_dash_unwind) {
+                            self.dcx().emit_err(errors::CVariadicBadExtern {
+                                span: variadic_param.span,
+                                abi: symbol_unescaped,
+                                extern_span: sig.extern_span(),
+                            });
+                        }
 
-                    if !matches!(sig.header.safety, Safety::Unsafe(_)) {
-                        self.dcx().emit_err(errors::CVariadicMustBeUnsafe {
-                            span: variadic_param.span,
-                            unsafe_span: sig.safety_span(),
-                        });
+                        if !matches!(sig.header.safety, Safety::Unsafe(_)) {
+                            self.dcx().emit_err(errors::CVariadicMustBeUnsafe {
+                                span: variadic_param.span,
+                                unsafe_span: sig.safety_span(),
+                            });
+                        }
+                    }
+                    Extern::None => {
+                        let err = errors::CVariadicNoExtern { span: variadic_param.span };
+                        self.dcx().emit_err(err);
                     }
                 }
-                Extern::None => {
-                    let err = errors::CVariadicNoExtern { span: variadic_param.span };
-                    self.dcx().emit_err(err);
-                }
-            },
+            }
             FnCtxt::Assoc(_) => {
                 // For now, C variable argument lists are unsupported in associated functions.
                 let err = errors::CVariadicAssociatedFunction { span: variadic_param.span };
diff --git a/tests/ui/c-variadic/inherent-method.rs b/tests/ui/c-variadic/inherent-method.rs
new file mode 100644
index 0000000000000..537bae7b3f0f4
--- /dev/null
+++ b/tests/ui/c-variadic/inherent-method.rs
@@ -0,0 +1,45 @@
+//@ run-pass
+#![feature(c_variadic)]
+
+#[repr(transparent)]
+struct S(i32);
+
+impl S {
+    unsafe extern "C" fn associated_function(mut ap: ...) -> i32 {
+        unsafe { ap.arg() }
+    }
+
+    unsafe extern "C" fn method_owned(self, mut ap: ...) -> i32 {
+        self.0 + unsafe { ap.arg::<i32>() }
+    }
+
+    unsafe extern "C" fn method_ref(&self, mut ap: ...) -> i32 {
+        self.0 + unsafe { ap.arg::<i32>() }
+    }
+
+    unsafe extern "C" fn method_mut(&mut self, mut ap: ...) -> i32 {
+        self.0 + unsafe { ap.arg::<i32>() }
+    }
+
+    unsafe extern "C" fn fat_pointer(self: Box<Self>, mut ap: ...) -> i32 {
+        self.0 + unsafe { ap.arg::<i32>() }
+    }
+}
+
+fn main() {
+    unsafe {
+        assert_eq!(S::associated_function(32), 32);
+        assert_eq!(S(100).method_owned(32), 132);
+        assert_eq!(S(100).method_ref(32), 132);
+        assert_eq!(S(100).method_mut(32), 132);
+        assert_eq!(S::fat_pointer(Box::new(S(100)), 32), 132);
+
+        type Method<T> = unsafe extern "C" fn(T, ...) -> i32;
+
+        assert_eq!((S::associated_function as unsafe extern "C" fn(...) -> i32)(32), 32);
+        assert_eq!((S::method_owned as Method<_>)(S(100), 32), 132);
+        assert_eq!((S::method_ref as Method<_>)(&S(100), 32), 132);
+        assert_eq!((S::method_mut as Method<_>)(&mut S(100), 32), 132);
+        assert_eq!((S::fat_pointer as Method<_>)(Box::new(S(100)), 32), 132);
+    }
+}
diff --git a/tests/ui/c-variadic/not-async.rs b/tests/ui/c-variadic/not-async.rs
index 45a7e1f8972bf..bdb51a9a43232 100644
--- a/tests/ui/c-variadic/not-async.rs
+++ b/tests/ui/c-variadic/not-async.rs
@@ -2,6 +2,14 @@
 #![feature(c_variadic)]
 #![crate_type = "lib"]
 
-async unsafe extern "C" fn cannot_be_async(x: isize, ...) {}
+async unsafe extern "C" fn fn_cannot_be_async(x: isize, ...) {}
 //~^ ERROR functions cannot be both `async` and C-variadic
 //~| ERROR hidden type for `impl Future<Output = ()>` captures lifetime that does not appear in bounds
+
+struct S;
+
+impl S {
+    async unsafe extern "C" fn method_cannot_be_async(x: isize, ...) {}
+    //~^ ERROR functions cannot be both `async` and C-variadic
+    //~| ERROR hidden type for `impl Future<Output = ()>` captures lifetime that does not appear in bounds
+}
diff --git a/tests/ui/c-variadic/not-async.stderr b/tests/ui/c-variadic/not-async.stderr
index b8caf0d8bd852..eab4c4f0822c4 100644
--- a/tests/ui/c-variadic/not-async.stderr
+++ b/tests/ui/c-variadic/not-async.stderr
@@ -1,19 +1,35 @@
 error: functions cannot be both `async` and C-variadic
   --> $DIR/not-async.rs:5:1
    |
-LL | async unsafe extern "C" fn cannot_be_async(x: isize, ...) {}
-   | ^^^^^ `async` because of this                        ^^^ C-variadic because of this
+LL | async unsafe extern "C" fn fn_cannot_be_async(x: isize, ...) {}
+   | ^^^^^ `async` because of this                           ^^^ C-variadic because of this
+
+error: functions cannot be both `async` and C-variadic
+  --> $DIR/not-async.rs:12:5
+   |
+LL |     async unsafe extern "C" fn method_cannot_be_async(x: isize, ...) {}
+   |     ^^^^^ `async` because of this                               ^^^ C-variadic because of this
 
 error[E0700]: hidden type for `impl Future<Output = ()>` captures lifetime that does not appear in bounds
-  --> $DIR/not-async.rs:5:59
+  --> $DIR/not-async.rs:5:62
    |
-LL | async unsafe extern "C" fn cannot_be_async(x: isize, ...) {}
-   | --------------------------------------------------------- ^^
+LL | async unsafe extern "C" fn fn_cannot_be_async(x: isize, ...) {}
+   | ------------------------------------------------------------ ^^
    | |
    | opaque type defined here
    |
-   = note: hidden type `{async fn body of cannot_be_async()}` captures lifetime `'_`
+   = note: hidden type `{async fn body of fn_cannot_be_async()}` captures lifetime `'_`
+
+error[E0700]: hidden type for `impl Future<Output = ()>` captures lifetime that does not appear in bounds
+  --> $DIR/not-async.rs:12:70
+   |
+LL |     async unsafe extern "C" fn method_cannot_be_async(x: isize, ...) {}
+   |     ---------------------------------------------------------------- ^^
+   |     |
+   |     opaque type defined here
+   |
+   = note: hidden type `{async fn body of S::method_cannot_be_async()}` captures lifetime `'_`
 
-error: aborting due to 2 previous errors
+error: aborting due to 4 previous errors
 
 For more information about this error, try `rustc --explain E0700`.
diff --git a/tests/ui/c-variadic/trait-method.rs b/tests/ui/c-variadic/trait-method.rs
new file mode 100644
index 0000000000000..4c468c1907bdb
--- /dev/null
+++ b/tests/ui/c-variadic/trait-method.rs
@@ -0,0 +1,40 @@
+// For now C-variadic arguments in trait methods are rejected, though we aim to lift this
+// restriction in the future. In particular we need to think about the interaction with
+// `dyn Trait` and the `ReifyShim`s that it may generate for methods.
+#![feature(c_variadic)]
+#![crate_type = "lib"]
+struct S;
+
+impl S {
+    unsafe extern "C" fn associated_function(mut ap: ...) -> i32 {
+        unsafe { ap.arg() }
+    }
+
+    unsafe extern "C" fn method(&self, mut ap: ...) -> i32 {
+        unsafe { ap.arg() }
+    }
+}
+
+trait T {
+    unsafe extern "C" fn trait_associated_function(mut ap: ...) -> i32 {
+        //~^ ERROR: associated functions cannot have a C variable argument list
+        unsafe { ap.arg() }
+    }
+
+    unsafe extern "C" fn trait_method(&self, mut ap: ...) -> i32 {
+        //~^ ERROR: associated functions cannot have a C variable argument list
+        unsafe { ap.arg() }
+    }
+}
+
+impl T for S {}
+
+fn main() {
+    unsafe {
+        assert_eq!(S::associated_function(32), 32);
+        assert_eq!(S.method(32), 32);
+
+        assert_eq!(S::trait_associated_function(32), 32);
+        assert_eq!(S.trait_method(32), 32);
+    }
+}
diff --git a/tests/ui/c-variadic/trait-method.stderr b/tests/ui/c-variadic/trait-method.stderr
new file mode 100644
index 0000000000000..35f6e24ef710c
--- /dev/null
+++ b/tests/ui/c-variadic/trait-method.stderr
@@ -0,0 +1,14 @@
+error: associated functions cannot have a C variable argument list
+  --> $DIR/trait-method.rs:19:52
+   |
+LL |     unsafe extern "C" fn trait_associated_function(mut ap: ...) -> i32 {
+   |                                                    ^^^^^^^^^^^
+
+error: associated functions cannot have a C variable argument list
+  --> $DIR/trait-method.rs:24:46
+   |
+LL |     unsafe extern "C" fn trait_method(&self, mut ap: ...) -> i32 {
+   |                                              ^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/parser/variadic-ffi-semantic-restrictions.rs b/tests/ui/parser/variadic-ffi-semantic-restrictions.rs
index 4db056f15a51f..566c4d30245c5 100644
--- a/tests/ui/parser/variadic-ffi-semantic-restrictions.rs
+++ b/tests/ui/parser/variadic-ffi-semantic-restrictions.rs
@@ -53,17 +53,17 @@ struct X;
 
 impl X {
     fn i_f1(x: isize, ...) {}
-    //~^ ERROR associated functions cannot have a C variable argument list
+    //~^ ERROR `...` is not supported for non-extern functions
     fn i_f2(...) {}
-    //~^ ERROR associated functions cannot have a C variable argument list
+    //~^ ERROR `...` is not supported for non-extern functions
     fn i_f3(..., x: isize, ...) {}
-    //~^ ERROR associated functions cannot have a C variable argument list
+    //~^ ERROR `...` is not supported for non-extern functions
     //~| ERROR `...` must be the last argument of a C-variadic function
     fn i_f4(..., x: isize, ...) {}
-    //~^ ERROR associated functions cannot have a C variable argument list
+    //~^ ERROR `...` is not supported for non-extern functions
     //~| ERROR `...` must be the last argument of a C-variadic function
     const fn i_f5(x: isize, ...) {}
-    //~^ ERROR associated functions cannot have a C variable argument list
+    //~^ ERROR `...` is not supported for non-extern functions
     //~| ERROR functions cannot be both `const` and C-variadic
     //~| ERROR destructor of `VaListImpl<'_>` cannot be evaluated at compile-time
 }
diff --git a/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr b/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr
index 0cd78318de6a8..c18d857d14e01 100644
--- a/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr
+++ b/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr
@@ -132,17 +132,21 @@ error: `...` must be the last argument of a C-variadic function
 LL |     fn e_f2(..., x: isize);
    |             ^^^
 
-error: associated functions cannot have a C variable argument list
+error: `...` is not supported for non-extern functions
   --> $DIR/variadic-ffi-semantic-restrictions.rs:55:23
    |
 LL |     fn i_f1(x: isize, ...) {}
    |                       ^^^
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
 
-error: associated functions cannot have a C variable argument list
+error: `...` is not supported for non-extern functions
   --> $DIR/variadic-ffi-semantic-restrictions.rs:57:13
    |
 LL |     fn i_f2(...) {}
    |             ^^^
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
 
 error: `...` must be the last argument of a C-variadic function
   --> $DIR/variadic-ffi-semantic-restrictions.rs:59:13
@@ -150,11 +154,13 @@ error: `...` must be the last argument of a C-variadic function
 LL |     fn i_f3(..., x: isize, ...) {}
    |             ^^^
 
-error: associated functions cannot have a C variable argument list
+error: `...` is not supported for non-extern functions
   --> $DIR/variadic-ffi-semantic-restrictions.rs:59:28
    |
 LL |     fn i_f3(..., x: isize, ...) {}
    |                            ^^^
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
 
 error: `...` must be the last argument of a C-variadic function
   --> $DIR/variadic-ffi-semantic-restrictions.rs:62:13
@@ -162,11 +168,13 @@ error: `...` must be the last argument of a C-variadic function
 LL |     fn i_f4(..., x: isize, ...) {}
    |             ^^^
 
-error: associated functions cannot have a C variable argument list
+error: `...` is not supported for non-extern functions
   --> $DIR/variadic-ffi-semantic-restrictions.rs:62:28
    |
 LL |     fn i_f4(..., x: isize, ...) {}
    |                            ^^^
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
 
 error: functions cannot be both `const` and C-variadic
   --> $DIR/variadic-ffi-semantic-restrictions.rs:65:5
@@ -176,11 +184,13 @@ LL |     const fn i_f5(x: isize, ...) {}
    |     |
    |     `const` because of this
 
-error: associated functions cannot have a C variable argument list
+error: `...` is not supported for non-extern functions
   --> $DIR/variadic-ffi-semantic-restrictions.rs:65:29
    |
 LL |     const fn i_f5(x: isize, ...) {}
    |                             ^^^
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
 
 error: associated functions cannot have a C variable argument list
   --> $DIR/variadic-ffi-semantic-restrictions.rs:72:23

From 01e83adc88653123fee444fdb930c16dd08da82d Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Wed, 10 Sep 2025 17:53:41 +0200
Subject: [PATCH 0800/1889] c-variadic: allow trait methods to be c-variadic

but a C-variadic method makes a trait dyn-incompatible. That is because
methods from dyn traits, when cast to a function pointer, create a shim.
That shim can't really forward the c-variadic arguments.
---
 compiler/rustc_ast_passes/messages.ftl        |  2 -
 .../rustc_ast_passes/src/ast_validation.rs    | 59 +++++++---------
 compiler/rustc_ast_passes/src/errors.rs       |  7 --
 compiler/rustc_middle/src/traits/mod.rs       |  6 ++
 .../src/traits/dyn_compatibility.rs           |  3 +
 tests/ui/c-variadic/not-dyn-compatible.rs     | 35 ++++++++++
 tests/ui/c-variadic/not-dyn-compatible.stderr | 21 ++++++
 tests/ui/c-variadic/trait-method.rs           | 67 ++++++++++++++-----
 tests/ui/c-variadic/trait-method.stderr       | 14 ----
 .../feature-gates/feature-gate-c_variadic.rs  |  1 -
 .../feature-gate-c_variadic.stderr            |  8 +--
 .../variadic-ffi-semantic-restrictions.rs     |  8 +--
 .../variadic-ffi-semantic-restrictions.stderr | 16 +++--
 13 files changed, 158 insertions(+), 89 deletions(-)
 create mode 100644 tests/ui/c-variadic/not-dyn-compatible.rs
 create mode 100644 tests/ui/c-variadic/not-dyn-compatible.stderr
 delete mode 100644 tests/ui/c-variadic/trait-method.stderr

diff --git a/compiler/rustc_ast_passes/messages.ftl b/compiler/rustc_ast_passes/messages.ftl
index 8dcf3e3aa3882..ba79fc63fad5b 100644
--- a/compiler/rustc_ast_passes/messages.ftl
+++ b/compiler/rustc_ast_passes/messages.ftl
@@ -64,8 +64,6 @@ ast_passes_body_in_extern = incorrect `{$kind}` inside `extern` block
 
 ast_passes_bound_in_context = bounds on `type`s in {$ctx} have no effect
 
-ast_passes_c_variadic_associated_function = associated functions cannot have a C variable argument list
-
 ast_passes_c_variadic_bad_extern = `...` is not supported for `extern "{$abi}"` functions
     .label = `extern "{$abi}"` because of this
     .help = only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index cdb3062c59178..c6dd625c22864 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -696,43 +696,36 @@ impl<'a> AstValidator<'a> {
 
         match fn_ctxt {
             FnCtxt::Foreign => return,
-            FnCtxt::Free | FnCtxt::Assoc(AssocCtxt::Impl { of_trait: false }) => {
-                match sig.header.ext {
-                    Extern::Implicit(_) => {
-                        if !matches!(sig.header.safety, Safety::Unsafe(_)) {
-                            self.dcx().emit_err(errors::CVariadicMustBeUnsafe {
-                                span: variadic_param.span,
-                                unsafe_span: sig.safety_span(),
-                            });
-                        }
+            FnCtxt::Free | FnCtxt::Assoc(_) => match sig.header.ext {
+                Extern::Implicit(_) => {
+                    if !matches!(sig.header.safety, Safety::Unsafe(_)) {
+                        self.dcx().emit_err(errors::CVariadicMustBeUnsafe {
+                            span: variadic_param.span,
+                            unsafe_span: sig.safety_span(),
+                        });
                     }
-                    Extern::Explicit(StrLit { symbol_unescaped, .. }, _) => {
-                        if !matches!(symbol_unescaped, sym::C | sym::C_dash_unwind) {
-                            self.dcx().emit_err(errors::CVariadicBadExtern {
-                                span: variadic_param.span,
-                                abi: symbol_unescaped,
-                                extern_span: sig.extern_span(),
-                            });
-                        }
-
-                        if !matches!(sig.header.safety, Safety::Unsafe(_)) {
-                            self.dcx().emit_err(errors::CVariadicMustBeUnsafe {
-                                span: variadic_param.span,
-                                unsafe_span: sig.safety_span(),
-                            });
-                        }
+                }
+                Extern::Explicit(StrLit { symbol_unescaped, .. }, _) => {
+                    if !matches!(symbol_unescaped, sym::C | sym::C_dash_unwind) {
+                        self.dcx().emit_err(errors::CVariadicBadExtern {
+                            span: variadic_param.span,
+                            abi: symbol_unescaped,
+                            extern_span: sig.extern_span(),
+                        });
                     }
-                    Extern::None => {
-                        let err = errors::CVariadicNoExtern { span: variadic_param.span };
-                        self.dcx().emit_err(err);
+
+                    if !matches!(sig.header.safety, Safety::Unsafe(_)) {
+                        self.dcx().emit_err(errors::CVariadicMustBeUnsafe {
+                            span: variadic_param.span,
+                            unsafe_span: sig.safety_span(),
+                        });
                     }
                 }
-            }
-            FnCtxt::Assoc(_) => {
-                // For now, C variable argument lists are unsupported in associated functions.
-                let err = errors::CVariadicAssociatedFunction { span: variadic_param.span };
-                self.dcx().emit_err(err);
-            }
+                Extern::None => {
+                    let err = errors::CVariadicNoExtern { span: variadic_param.span };
+                    self.dcx().emit_err(err);
+                }
+            },
         }
     }
 
diff --git a/compiler/rustc_ast_passes/src/errors.rs b/compiler/rustc_ast_passes/src/errors.rs
index ae805042c549f..b1b1ad60c2485 100644
--- a/compiler/rustc_ast_passes/src/errors.rs
+++ b/compiler/rustc_ast_passes/src/errors.rs
@@ -318,13 +318,6 @@ pub(crate) struct ExternItemAscii {
     pub block: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag(ast_passes_c_variadic_associated_function)]
-pub(crate) struct CVariadicAssociatedFunction {
-    #[primary_span]
-    pub span: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag(ast_passes_c_variadic_no_extern)]
 #[help]
diff --git a/compiler/rustc_middle/src/traits/mod.rs b/compiler/rustc_middle/src/traits/mod.rs
index ab8a314295392..0c7bddf60d974 100644
--- a/compiler/rustc_middle/src/traits/mod.rs
+++ b/compiler/rustc_middle/src/traits/mod.rs
@@ -823,6 +823,9 @@ impl DynCompatibilityViolation {
             DynCompatibilityViolation::Method(name, MethodViolationCode::AsyncFn, _) => {
                 format!("method `{name}` is `async`").into()
             }
+            DynCompatibilityViolation::Method(name, MethodViolationCode::CVariadic, _) => {
+                format!("method `{name}` is C-variadic").into()
+            }
             DynCompatibilityViolation::Method(
                 name,
                 MethodViolationCode::WhereClauseReferencesSelf,
@@ -977,6 +980,9 @@ pub enum MethodViolationCode {
     /// e.g., `fn foo<A>()`
     Generic,
 
+    /// e.g., `fn (mut ap: ...)`
+    CVariadic,
+
     /// the method's receiver (`self` argument) can't be dispatched on
     UndispatchableReceiver(Option<Span>),
 }
diff --git a/compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs b/compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs
index bcd11d6918d9a..3260dd712b9e4 100644
--- a/compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs
+++ b/compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs
@@ -426,6 +426,9 @@ fn virtual_call_violations_for_method<'tcx>(
     if let Some(code) = contains_illegal_impl_trait_in_trait(tcx, method.def_id, sig.output()) {
         errors.push(code);
     }
+    if sig.skip_binder().c_variadic {
+        errors.push(MethodViolationCode::CVariadic);
+    }
 
     // We can't monomorphize things like `fn foo<A>(...)`.
     let own_counts = tcx.generics_of(method.def_id).own_counts();
diff --git a/tests/ui/c-variadic/not-dyn-compatible.rs b/tests/ui/c-variadic/not-dyn-compatible.rs
new file mode 100644
index 0000000000000..b40a13e584762
--- /dev/null
+++ b/tests/ui/c-variadic/not-dyn-compatible.rs
@@ -0,0 +1,35 @@
+// Traits where a method is c-variadic are not dyn compatible.
+//
+// Creating a function pointer from a method on an `&dyn T` value creates a ReifyShim.
+// This shim cannot reliably forward C-variadic arguments. Thus the trait as a whole
+// is dyn-incompatible to prevent invalid shims from being created.
+#![feature(c_variadic)]
+
+#[repr(transparent)]
+struct Struct(u64);
+
+trait Trait {
+    fn get(&self) -> u64;
+
+    unsafe extern "C" fn dyn_method_ref(&self, mut ap: ...) -> u64 {
+        self.get() + unsafe { ap.arg::<u64>() }
+    }
+}
+
+impl Trait for Struct {
+    fn get(&self) -> u64 {
+        self.0
+    }
+}
+
+fn main() {
+    unsafe {
+        let dyn_object: &dyn Trait = &Struct(64);
+        //~^ ERROR the trait `Trait` is not dyn compatible
+        assert_eq!(dyn_object.dyn_method_ref(100), 164);
+        assert_eq!(
+            (Trait::dyn_method_ref as unsafe extern "C" fn(_, ...) -> u64)(dyn_object, 100),
+            164
+        );
+    }
+}
diff --git a/tests/ui/c-variadic/not-dyn-compatible.stderr b/tests/ui/c-variadic/not-dyn-compatible.stderr
new file mode 100644
index 0000000000000..76630600c511f
--- /dev/null
+++ b/tests/ui/c-variadic/not-dyn-compatible.stderr
@@ -0,0 +1,21 @@
+error[E0038]: the trait `Trait` is not dyn compatible
+  --> $DIR/not-dyn-compatible.rs:27:30
+   |
+LL |         let dyn_object: &dyn Trait = &Struct(64);
+   |                              ^^^^^ `Trait` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/not-dyn-compatible.rs:14:26
+   |
+LL | trait Trait {
+   |       ----- this trait is not dyn compatible...
+...
+LL |     unsafe extern "C" fn dyn_method_ref(&self, mut ap: ...) -> u64 {
+   |                          ^^^^^^^^^^^^^^ ...because method `dyn_method_ref` is C-variadic
+   = help: consider moving `dyn_method_ref` to another trait
+   = help: only type `Struct` implements `Trait`; consider using it directly instead.
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/c-variadic/trait-method.rs b/tests/ui/c-variadic/trait-method.rs
index 4c468c1907bdb..97da0706a3a18 100644
--- a/tests/ui/c-variadic/trait-method.rs
+++ b/tests/ui/c-variadic/trait-method.rs
@@ -1,40 +1,73 @@
-// For now C-variadic arguments in trait methods are rejected, though we aim to lift this
-// restriction in the future. In particular we need to think about the interaction with
-// `dyn Trait` and the `ReifyShim`s that it may generate for methods.
+//@ run-pass
 #![feature(c_variadic)]
-#![crate_type = "lib"]
-struct S;
 
-impl S {
+#[repr(transparent)]
+struct Struct(i32);
+
+impl Struct {
     unsafe extern "C" fn associated_function(mut ap: ...) -> i32 {
         unsafe { ap.arg() }
     }
 
     unsafe extern "C" fn method(&self, mut ap: ...) -> i32 {
-        unsafe { ap.arg() }
+        self.0 + unsafe { ap.arg::<i32>() }
     }
 }
 
-trait T {
+trait Trait: Sized {
+    fn get(&self) -> i32;
+
     unsafe extern "C" fn trait_associated_function(mut ap: ...) -> i32 {
-        //~^ ERROR: associated functions cannot have a C variable argument list
         unsafe { ap.arg() }
     }
 
-    unsafe extern "C" fn trait_method(&self, mut ap: ...) -> i32 {
-        //~^ ERROR: associated functions cannot have a C variable argument list
-        unsafe { ap.arg() }
+    unsafe extern "C" fn trait_method_owned(self, mut ap: ...) -> i32 {
+        self.get() + unsafe { ap.arg::<i32>() }
+    }
+
+    unsafe extern "C" fn trait_method_ref(&self, mut ap: ...) -> i32 {
+        self.get() + unsafe { ap.arg::<i32>() }
+    }
+
+    unsafe extern "C" fn trait_method_mut(&mut self, mut ap: ...) -> i32 {
+        self.get() + unsafe { ap.arg::<i32>() }
+    }
+
+    unsafe extern "C" fn trait_fat_pointer(self: Box<Self>, mut ap: ...) -> i32 {
+        self.get() + unsafe { ap.arg::<i32>() }
     }
 }
 
-impl T for S {}
+impl Trait for Struct {
+    fn get(&self) -> i32 {
+        self.0
+    }
+}
 
 fn main() {
     unsafe {
-        assert_eq!(S::associated_function(32), 32);
-        assert_eq!(S.method(32), 32);
+        assert_eq!(Struct::associated_function(32), 32);
+        assert_eq!(Struct(100).method(32), 132);
+
+        assert_eq!(Struct::trait_associated_function(32), 32);
+        assert_eq!(Struct(100).trait_method_owned(32), 132);
+        assert_eq!(Struct(100).trait_method_ref(32), 132);
+        assert_eq!(Struct(100).trait_method_mut(32), 132);
+        assert_eq!(Struct::trait_fat_pointer(Box::new(Struct(100)), 32), 132);
+
+        assert_eq!(<Struct as Trait>::trait_associated_function(32), 32);
+        assert_eq!(Trait::trait_method_owned(Struct(100), 32), 132);
+        assert_eq!(Trait::trait_method_ref(&Struct(100), 32), 132);
+        assert_eq!(Trait::trait_method_mut(&mut Struct(100), 32), 132);
+        assert_eq!(Trait::trait_fat_pointer(Box::new(Struct(100)), 32), 132);
+
+        type Associated = unsafe extern "C" fn(...) -> i32;
+        type Method<T> = unsafe extern "C" fn(T, ...) -> i32;
 
-        assert_eq!(S::trait_associated_function(32), 32);
-        assert_eq!(S.trait_method(32), 32);
+        assert_eq!((Struct::trait_associated_function as Associated)(32), 32);
+        assert_eq!((Struct::trait_method_owned as Method<_>)(Struct(100), 32), 132);
+        assert_eq!((Struct::trait_method_ref as Method<_>)(&Struct(100), 32), 132);
+        assert_eq!((Struct::trait_method_mut as Method<_>)(&mut Struct(100), 32), 132);
+        assert_eq!((Struct::trait_fat_pointer as Method<_>)(Box::new(Struct(100)), 32), 132);
     }
 }
diff --git a/tests/ui/c-variadic/trait-method.stderr b/tests/ui/c-variadic/trait-method.stderr
deleted file mode 100644
index 35f6e24ef710c..0000000000000
--- a/tests/ui/c-variadic/trait-method.stderr
+++ /dev/null
@@ -1,14 +0,0 @@
-error: associated functions cannot have a C variable argument list
-  --> $DIR/trait-method.rs:19:52
-   |
-LL |     unsafe extern "C" fn trait_associated_function(mut ap: ...) -> i32 {
-   |                                                    ^^^^^^^^^^^
-
-error: associated functions cannot have a C variable argument list
-  --> $DIR/trait-method.rs:24:46
-   |
-LL |     unsafe extern "C" fn trait_method(&self, mut ap: ...) -> i32 {
-   |                                              ^^^^^^^^^^^
-
-error: aborting due to 2 previous errors
-
diff --git a/tests/ui/feature-gates/feature-gate-c_variadic.rs b/tests/ui/feature-gates/feature-gate-c_variadic.rs
index 88d91dbd081fb..649816b48d784 100644
--- a/tests/ui/feature-gates/feature-gate-c_variadic.rs
+++ b/tests/ui/feature-gates/feature-gate-c_variadic.rs
@@ -6,5 +6,4 @@ pub unsafe extern "C" fn test(_: i32, ap: ...) {}
 trait Trait {
     unsafe extern "C" fn trait_test(_: i32, ap: ...) {}
     //~^ ERROR C-variadic functions are unstable
-    //~| ERROR associated functions cannot have a C variable argument list
 }
diff --git a/tests/ui/feature-gates/feature-gate-c_variadic.stderr b/tests/ui/feature-gates/feature-gate-c_variadic.stderr
index 808aa20948d03..ae880093b980c 100644
--- a/tests/ui/feature-gates/feature-gate-c_variadic.stderr
+++ b/tests/ui/feature-gates/feature-gate-c_variadic.stderr
@@ -1,9 +1,3 @@
-error: associated functions cannot have a C variable argument list
-  --> $DIR/feature-gate-c_variadic.rs:7:45
-   |
-LL |     unsafe extern "C" fn trait_test(_: i32, ap: ...) {}
-   |                                             ^^^^^^^
-
 error[E0658]: C-variadic functions are unstable
   --> $DIR/feature-gate-c_variadic.rs:3:1
    |
@@ -24,6 +18,6 @@ LL |     unsafe extern "C" fn trait_test(_: i32, ap: ...) {}
    = help: add `#![feature(c_variadic)]` 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`.
diff --git a/tests/ui/parser/variadic-ffi-semantic-restrictions.rs b/tests/ui/parser/variadic-ffi-semantic-restrictions.rs
index 566c4d30245c5..415472176d9c4 100644
--- a/tests/ui/parser/variadic-ffi-semantic-restrictions.rs
+++ b/tests/ui/parser/variadic-ffi-semantic-restrictions.rs
@@ -70,13 +70,13 @@ impl X {
 
 trait T {
     fn t_f1(x: isize, ...) {}
-    //~^ ERROR associated functions cannot have a C variable argument list
+    //~^ ERROR `...` is not supported for non-extern functions
     fn t_f2(x: isize, ...);
-    //~^ ERROR associated functions cannot have a C variable argument list
+    //~^ ERROR `...` is not supported for non-extern functions
     fn t_f3(...) {}
-    //~^ ERROR associated functions cannot have a C variable argument list
+    //~^ ERROR `...` is not supported for non-extern functions
     fn t_f4(...);
-    //~^ ERROR associated functions cannot have a C variable argument list
+    //~^ ERROR `...` is not supported for non-extern functions
     fn t_f5(..., x: isize) {}
     //~^ ERROR `...` must be the last argument of a C-variadic function
     fn t_f6(..., x: isize);
diff --git a/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr b/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr
index c18d857d14e01..da9c9b0f76099 100644
--- a/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr
+++ b/tests/ui/parser/variadic-ffi-semantic-restrictions.stderr
@@ -192,29 +192,37 @@ LL |     const fn i_f5(x: isize, ...) {}
    |
    = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
 
-error: associated functions cannot have a C variable argument list
+error: `...` is not supported for non-extern functions
   --> $DIR/variadic-ffi-semantic-restrictions.rs:72:23
    |
 LL |     fn t_f1(x: isize, ...) {}
    |                       ^^^
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
 
-error: associated functions cannot have a C variable argument list
+error: `...` is not supported for non-extern functions
   --> $DIR/variadic-ffi-semantic-restrictions.rs:74:23
    |
 LL |     fn t_f2(x: isize, ...);
    |                       ^^^
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
 
-error: associated functions cannot have a C variable argument list
+error: `...` is not supported for non-extern functions
   --> $DIR/variadic-ffi-semantic-restrictions.rs:76:13
    |
 LL |     fn t_f3(...) {}
    |             ^^^
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
 
-error: associated functions cannot have a C variable argument list
+error: `...` is not supported for non-extern functions
   --> $DIR/variadic-ffi-semantic-restrictions.rs:78:13
    |
 LL |     fn t_f4(...);
    |             ^^^
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
 
 error: `...` must be the last argument of a C-variadic function
   --> $DIR/variadic-ffi-semantic-restrictions.rs:80:13

From ad6004d95343031f3ac0898fe3582410fcc28f0d Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 11 Sep 2025 11:11:40 +0200
Subject: [PATCH 0801/1889] add release sequence test

---
 src/tools/miri/src/concurrency/data_race.rs   |  9 +++--
 src/tools/miri/src/concurrency/weak_memory.rs |  8 +++--
 .../miri/tests/pass/0weak_memory/weak.rs      | 33 +++++++++++++++++++
 3 files changed, 46 insertions(+), 4 deletions(-)

diff --git a/src/tools/miri/src/concurrency/data_race.rs b/src/tools/miri/src/concurrency/data_race.rs
index de60e80b9f7eb..16cac7e6d04c1 100644
--- a/src/tools/miri/src/concurrency/data_race.rs
+++ b/src/tools/miri/src/concurrency/data_race.rs
@@ -276,7 +276,7 @@ struct MemoryCellClocks {
     /// zero on each write operation.
     read: VClock,
 
-    /// Atomic access, acquire, release sequence tracking clocks.
+    /// Atomic access tracking clocks.
     /// For non-atomic memory this value is set to None.
     /// For atomic memory, each byte carries this information.
     atomic_ops: Option<Box<AtomicMemoryCellClocks>>,
@@ -555,7 +555,8 @@ impl MemoryCellClocks {
         // The handling of release sequences was changed in C++20 and so
         // the code here is different to the paper since now all relaxed
         // stores block release sequences. The exception for same-thread
-        // relaxed stores has been removed.
+        // relaxed stores has been removed. We always overwrite the `sync_vector`,
+        // meaning the previous release sequence is broken.
         let atomic = self.atomic_mut_unwrap();
         atomic.sync_vector.clone_from(&thread_clocks.fence_release);
         Ok(())
@@ -571,6 +572,8 @@ impl MemoryCellClocks {
     ) -> Result<(), DataRace> {
         self.atomic_write_detect(thread_clocks, index, access_size)?;
         let atomic = self.atomic_mut_unwrap();
+        // This *joining* of `sync_vector` implements release sequences: future
+        // reads of this location will acquire our clock *and* what was here before.
         atomic.sync_vector.join(&thread_clocks.clock);
         Ok(())
     }
@@ -585,6 +588,8 @@ impl MemoryCellClocks {
     ) -> Result<(), DataRace> {
         self.atomic_write_detect(thread_clocks, index, access_size)?;
         let atomic = self.atomic_mut_unwrap();
+        // This *joining* of `sync_vector` implements release sequences: future
+        // reads of this location will acquire our fence clock *and* what was here before.
         atomic.sync_vector.join(&thread_clocks.fence_release);
         Ok(())
     }
diff --git a/src/tools/miri/src/concurrency/weak_memory.rs b/src/tools/miri/src/concurrency/weak_memory.rs
index a752ef7e45480..caa27422d2f26 100644
--- a/src/tools/miri/src/concurrency/weak_memory.rs
+++ b/src/tools/miri/src/concurrency/weak_memory.rs
@@ -159,9 +159,12 @@ struct StoreElement {
 
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
 struct LoadInfo {
-    /// Timestamp of first loads from this store element by each thread
+    /// Timestamp of first loads from this store element by each thread.
     timestamps: FxHashMap<VectorIdx, VTimestamp>,
-    /// Whether this store element has been read by an SC load
+    /// Whether this store element has been read by an SC load.
+    /// This is crucial to ensure we respect coherence-ordered-before. Concretely we use
+    /// this to ensure that if a store element is seen by an SC load, then all later SC loads
+    /// cannot see `mo`-earlier store elements.
     sc_loaded: bool,
 }
 
@@ -476,6 +479,7 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             }
             let range = alloc_range(base_offset, place.layout.size);
             let buffer = alloc_buffers.get_or_create_store_buffer_mut(range, Some(init))?;
+            // The RMW always reads from the most recent store.
             buffer.read_from_last_store(global, threads, atomic == AtomicRwOrd::SeqCst);
             buffer.buffered_write(new_val, global, threads, atomic == AtomicRwOrd::SeqCst)?;
         }
diff --git a/src/tools/miri/tests/pass/0weak_memory/weak.rs b/src/tools/miri/tests/pass/0weak_memory/weak.rs
index 75c6e8f1a8793..44791d7cd7c50 100644
--- a/src/tools/miri/tests/pass/0weak_memory/weak.rs
+++ b/src/tools/miri/tests/pass/0weak_memory/weak.rs
@@ -198,11 +198,44 @@ fn weaker_release_sequences() {
     });
 }
 
+/// Ensuring normal release sequences (with RMWs) still work correctly.
+fn release_sequence() {
+    check_all_outcomes([None, Some(1)], || {
+        let x = static_atomic(0);
+        let y = static_atomic(0);
+
+        let t1 = spawn(move || {
+            x.store(2, Relaxed);
+        });
+        let t2 = spawn(move || {
+            y.store(1, Relaxed);
+            x.store(1, Release);
+            x.swap(3, Relaxed);
+        });
+        let t3 = spawn(move || {
+            if x.load(Acquire) == 3 {
+                // If we read 3 here, we are seeing the result of the `x.swap` above, which
+                // was relaxed but forms a release sequence with the `x.store` (since we know
+                // `t1` will not be scheduled in between). This means there is a release sequence,
+                // so we acquire the `y.store` and cannot see the original value `0` any more.
+                Some(y.load(Relaxed))
+            } else {
+                None
+            }
+        });
+
+        t1.join().unwrap();
+        t2.join().unwrap();
+        t3.join().unwrap()
+    });
+}
+
 pub fn main() {
     relaxed();
     seq_cst();
     initialization_write(false);
     initialization_write(true);
     faa_replaced_by_load();
+    release_sequence();
     weaker_release_sequences();
 }

From 8d1403cb9b42b99c7b35139ac93f8102b589f007 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Thu, 11 Sep 2025 11:43:53 +0200
Subject: [PATCH 0802/1889] Change the default value of `gcc.download-ci-gcc`
 to `true`

---
 src/bootstrap/defaults/bootstrap.dist.toml | 4 ++++
 src/bootstrap/src/core/config/mod.rs       | 2 +-
 src/bootstrap/src/utils/change_tracker.rs  | 5 +++++
 3 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/bootstrap/defaults/bootstrap.dist.toml b/src/bootstrap/defaults/bootstrap.dist.toml
index 9daf9faac14a2..b111a20f8d868 100644
--- a/src/bootstrap/defaults/bootstrap.dist.toml
+++ b/src/bootstrap/defaults/bootstrap.dist.toml
@@ -14,6 +14,10 @@ compiletest-use-stage0-libtest = false
 [llvm]
 download-ci-llvm = false
 
+# Most users installing from source want to build all parts of the project from source.
+[gcc]
+download-ci-gcc = false
+
 [rust]
 # We have several defaults in bootstrap that depend on whether the channel is `dev` (e.g. `omit-git-hash` and `download-ci-llvm`).
 # Make sure they don't get set when installing from source.
diff --git a/src/bootstrap/src/core/config/mod.rs b/src/bootstrap/src/core/config/mod.rs
index 5999348a7fe8d..05a5dfc0bc5a8 100644
--- a/src/bootstrap/src/core/config/mod.rs
+++ b/src/bootstrap/src/core/config/mod.rs
@@ -422,10 +422,10 @@ impl std::str::FromStr for RustcLto {
 #[derive(Default, Clone)]
 pub enum GccCiMode {
     /// Build GCC from the local `src/gcc` submodule.
-    #[default]
     BuildLocally,
     /// Try to download GCC from CI.
     /// If it is not available on CI, it will be built locally instead.
+    #[default]
     DownloadFromCi,
 }
 
diff --git a/src/bootstrap/src/utils/change_tracker.rs b/src/bootstrap/src/utils/change_tracker.rs
index 01309072927d0..03b39882e30af 100644
--- a/src/bootstrap/src/utils/change_tracker.rs
+++ b/src/bootstrap/src/utils/change_tracker.rs
@@ -541,4 +541,9 @@ pub const CONFIG_CHANGE_HISTORY: &[ChangeInfo] = &[
         severity: ChangeSeverity::Info,
         summary: "Added a new option `rust.break-on-ice` to control if internal compiler errors cause a debug break on Windows.",
     },
+    ChangeInfo {
+        change_id: 146435,
+        severity: ChangeSeverity::Info,
+        summary: "The default value of the `gcc.download-ci-gcc` option has been changed to `true`.",
+    },
 ];

From 0e29865434db8d44109715515ea00479936fa668 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Wed, 10 Sep 2025 13:26:42 +0200
Subject: [PATCH 0803/1889] consider the `sub_unification_table` in
 `stalled_on`

---
 .../src/solve/eval_ctxt/mod.rs                | 49 ++++++++++++-------
 .../rustc_next_trait_solver/src/solve/mod.rs  |  8 +--
 2 files changed, 33 insertions(+), 24 deletions(-)

diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
index 5cd597d4fe6b9..f1c1801dd3f19 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
@@ -407,20 +407,21 @@ where
         // If we have run this goal before, and it was stalled, check that any of the goal's
         // args have changed. Otherwise, we don't need to re-run the goal because it'll remain
         // stalled, since it'll canonicalize the same way and evaluation is pure.
-        if let Some(stalled_on) = stalled_on
-            && !stalled_on.stalled_vars.iter().any(|value| self.delegate.is_changed_arg(*value))
-            && !self
-                .delegate
-                .opaque_types_storage_num_entries()
-                .needs_reevaluation(stalled_on.num_opaques)
+        if let Some(GoalStalledOn { num_opaques, ref stalled_vars, ref sub_roots, stalled_cause }) =
+            stalled_on
+            && !stalled_vars.iter().any(|value| self.delegate.is_changed_arg(*value))
+            && !sub_roots
+                .iter()
+                .any(|&vid| self.delegate.sub_unification_table_root_var(vid) != vid)
+            && !self.delegate.opaque_types_storage_num_entries().needs_reevaluation(num_opaques)
         {
             return Ok((
                 NestedNormalizationGoals::empty(),
                 GoalEvaluation {
                     goal,
-                    certainty: Certainty::Maybe(stalled_on.stalled_cause),
+                    certainty: Certainty::Maybe(stalled_cause),
                     has_changed: HasChanged::No,
-                    stalled_on: Some(stalled_on),
+                    stalled_on,
                 },
             ));
         }
@@ -476,16 +477,6 @@ where
                 HasChanged::No => {
                     let mut stalled_vars = orig_values;
 
-                    // Remove the canonicalized universal vars, since we only care about stalled existentials.
-                    stalled_vars.retain(|arg| match arg.kind() {
-                        ty::GenericArgKind::Type(ty) => matches!(ty.kind(), ty::Infer(_)),
-                        ty::GenericArgKind::Const(ct) => {
-                            matches!(ct.kind(), ty::ConstKind::Infer(_))
-                        }
-                        // Lifetimes can never stall goals.
-                        ty::GenericArgKind::Lifetime(_) => false,
-                    });
-
                     // Remove the unconstrained RHS arg, which is expected to have changed.
                     if let Some(normalizes_to) = goal.predicate.as_normalizes_to() {
                         let normalizes_to = normalizes_to.skip_binder();
@@ -497,6 +488,27 @@ where
                         stalled_vars.swap_remove(idx);
                     }
 
+                    // Remove the canonicalized universal vars, since we only care about stalled existentials.
+                    let mut sub_roots = Vec::new();
+                    stalled_vars.retain(|arg| match arg.kind() {
+                        // Lifetimes can never stall goals.
+                        ty::GenericArgKind::Lifetime(_) => false,
+                        ty::GenericArgKind::Type(ty) => match ty.kind() {
+                            ty::Infer(ty::TyVar(vid)) => {
+                                sub_roots.push(self.delegate.sub_unification_table_root_var(vid));
+                                true
+                            }
+                            ty::Infer(_) => true,
+                            ty::Param(_) | ty::Placeholder(_) => false,
+                            _ => unreachable!("unexpected orig_value: {ty:?}"),
+                        },
+                        ty::GenericArgKind::Const(ct) => match ct.kind() {
+                            ty::ConstKind::Infer(_) => true,
+                            ty::ConstKind::Param(_) | ty::ConstKind::Placeholder(_) => false,
+                            _ => unreachable!("unexpected orig_value: {ct:?}"),
+                        },
+                    });
+
                     Some(GoalStalledOn {
                         num_opaques: canonical_goal
                             .canonical
@@ -505,6 +517,7 @@ where
                             .opaque_types
                             .len(),
                         stalled_vars,
+                        sub_roots,
                         stalled_cause,
                     })
                 }
diff --git a/compiler/rustc_next_trait_solver/src/solve/mod.rs b/compiler/rustc_next_trait_solver/src/solve/mod.rs
index db3460c4ff676..cd27c9c26c1fd 100644
--- a/compiler/rustc_next_trait_solver/src/solve/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/mod.rs
@@ -24,7 +24,7 @@ mod trait_goals;
 use derive_where::derive_where;
 use rustc_type_ir::inherent::*;
 pub use rustc_type_ir::solve::*;
-use rustc_type_ir::{self as ty, Interner, TypingMode};
+use rustc_type_ir::{self as ty, Interner, TyVid, TypingMode};
 use tracing::instrument;
 
 pub use self::eval_ctxt::{
@@ -418,11 +418,6 @@ pub struct GoalEvaluation<I: Interner> {
     pub has_changed: HasChanged,
     /// If the [`Certainty`] was `Maybe`, then keep track of whether the goal has changed
     /// before rerunning it.
-    ///
-    /// We knowingly ignore the `sub_root` of our inference variables here. This means we
-    /// may not reevaluate a goal even though a change to the `sub_root` could cause a goal
-    /// to make progress. Tracking them adds additional complexity for an incredibly minor
-    /// type inference improvement. We could look into properly handling this in the future.
     pub stalled_on: Option<GoalStalledOn<I>>,
 }
 
@@ -431,6 +426,7 @@ pub struct GoalEvaluation<I: Interner> {
 pub struct GoalStalledOn<I: Interner> {
     pub num_opaques: usize,
     pub stalled_vars: Vec<I::GenericArg>,
+    pub sub_roots: Vec<TyVid>,
     /// The cause that will be returned on subsequent evaluations if this goal remains stalled.
     pub stalled_cause: MaybeCause,
 }

From cf224ea1fbe2fb7eb64812288338a2c4cfe1d084 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Mon, 28 Apr 2025 18:16:34 +0000
Subject: [PATCH 0804/1889] incompletely prefer opaque type bounds when self
 type bottoms out in infer

---
 compiler/rustc_middle/src/ty/context.rs       |   6 +-
 .../src/solve/assembly/mod.rs                 | 137 +++++++++++++++++-
 .../src/solve/effect_goals.rs                 |   3 +-
 .../src/solve/eval_ctxt/mod.rs                |  31 ++++
 .../src/solve/normalizes_to/mod.rs            |   7 +-
 .../src/solve/trait_goals.rs                  |   3 +-
 compiler/rustc_type_ir/src/interner.rs        |   1 +
 ...nce-constraints-from-blanket-2.next.stderr |  16 ++
 ...id-inference-constraints-from-blanket-2.rs |  31 ++++
 ...id-inference-constraints-from-blanket-3.rs |  25 ++++
 ...nference-constraints-from-blanket-3.stderr |  25 ++++
 ...void-inference-constraints-from-blanket.rs |  25 ++++
 .../multiple-opaques-ambig.rs                 |  23 +++
 .../non-defining-uses/multiple-opaques-ok.rs  |  37 +++++
 .../non-defining-uses/no-rigid-alias.rs       |  27 ++++
 .../non-defining-uses/use-blanket-impl.rs     |  19 +++
 .../use-item-bound-over-blanket-impl.rs       |  30 ++++
 .../non-defining-uses/use-item-bound.rs       |  25 ++++
 18 files changed, 457 insertions(+), 14 deletions(-)
 create mode 100644 tests/ui/impl-trait/non-defining-uses/avoid-inference-constraints-from-blanket-2.next.stderr
 create mode 100644 tests/ui/impl-trait/non-defining-uses/avoid-inference-constraints-from-blanket-2.rs
 create mode 100644 tests/ui/impl-trait/non-defining-uses/avoid-inference-constraints-from-blanket-3.rs
 create mode 100644 tests/ui/impl-trait/non-defining-uses/avoid-inference-constraints-from-blanket-3.stderr
 create mode 100644 tests/ui/impl-trait/non-defining-uses/avoid-inference-constraints-from-blanket.rs
 create mode 100644 tests/ui/impl-trait/non-defining-uses/multiple-opaques-ambig.rs
 create mode 100644 tests/ui/impl-trait/non-defining-uses/multiple-opaques-ok.rs
 create mode 100644 tests/ui/impl-trait/non-defining-uses/no-rigid-alias.rs
 create mode 100644 tests/ui/impl-trait/non-defining-uses/use-blanket-impl.rs
 create mode 100644 tests/ui/impl-trait/non-defining-uses/use-item-bound-over-blanket-impl.rs
 create mode 100644 tests/ui/impl-trait/non-defining-uses/use-item-bound.rs

diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 218ac2cfbc19d..8ea767dccd3b8 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -651,7 +651,11 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
             | ty::Bound(_, _) => bug!("unexpected self type: {self_ty}"),
         }
 
-        let trait_impls = tcx.trait_impls_of(trait_def_id);
+        #[allow(rustc::usage_of_type_ir_traits)]
+        self.for_each_blanket_impl(trait_def_id, f)
+    }
+    fn for_each_blanket_impl(self, trait_def_id: DefId, mut f: impl FnMut(DefId)) {
+        let trait_impls = self.trait_impls_of(trait_def_id);
         for &impl_def_id in trait_impls.blanket_impls() {
             f(impl_def_id);
         }
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 e3cf0330b14a0..fb777496e31eb 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
@@ -11,8 +11,9 @@ use rustc_type_ir::lang_items::SolverTraitLangItem;
 use rustc_type_ir::search_graph::CandidateHeadUsages;
 use rustc_type_ir::solve::SizedTraitKind;
 use rustc_type_ir::{
-    self as ty, Interner, TypeFlags, TypeFoldable, TypeSuperVisitable, TypeVisitable,
-    TypeVisitableExt as _, TypeVisitor, TypingMode, Upcast as _, elaborate,
+    self as ty, Interner, TypeFlags, TypeFoldable, TypeFolder, TypeSuperFoldable,
+    TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor, TypingMode, Upcast,
+    elaborate,
 };
 use tracing::{debug, instrument};
 
@@ -187,6 +188,7 @@ where
         ecx: &mut EvalCtxt<'_, D>,
         goal: Goal<I, Self>,
         impl_def_id: I::ImplId,
+        then: impl FnOnce(&mut EvalCtxt<'_, D>, Certainty) -> QueryResult<I>,
     ) -> Result<Candidate<I>, NoSolution>;
 
     /// If the predicate contained an error, we want to avoid emitting unnecessary trait
@@ -365,6 +367,15 @@ pub(super) enum AssembleCandidatesFrom {
     EnvAndBounds,
 }
 
+impl AssembleCandidatesFrom {
+    fn should_assemble_impl_candidates(&self) -> bool {
+        match self {
+            AssembleCandidatesFrom::All => true,
+            AssembleCandidatesFrom::EnvAndBounds => false,
+        }
+    }
+}
+
 /// This is currently used to track the [CandidateHeadUsages] of all failed `ParamEnv`
 /// candidates. This is then used to ignore their head usages in case there's another
 /// always applicable `ParamEnv` candidate. Look at how `param_env_head_usages` is
@@ -397,14 +408,15 @@ where
             return (candidates, failed_candidate_info);
         };
 
+        let goal: Goal<I, G> = goal
+            .with(self.cx(), goal.predicate.with_replaced_self_ty(self.cx(), normalized_self_ty));
+
         if normalized_self_ty.is_ty_var() {
             debug!("self type has been normalized to infer");
-            candidates.extend(self.forced_ambiguity(MaybeCause::Ambiguity));
+            self.try_assemble_bounds_via_registered_opaques(goal, assemble_from, &mut candidates);
             return (candidates, failed_candidate_info);
         }
 
-        let goal: Goal<I, G> = goal
-            .with(self.cx(), goal.predicate.with_replaced_self_ty(self.cx(), normalized_self_ty));
         // Vars that show up in the rest of the goal substs may have been constrained by
         // normalizing the self type as well, since type variables are not uniquified.
         let goal = self.resolve_vars_if_possible(goal);
@@ -484,8 +496,9 @@ where
                 if cx.impl_is_default(impl_def_id) {
                     return;
                 }
-
-                match G::consider_impl_candidate(self, goal, impl_def_id) {
+                match G::consider_impl_candidate(self, goal, impl_def_id, |ecx, certainty| {
+                    ecx.evaluate_added_goals_and_make_canonical_response(certainty)
+                }) {
                     Ok(candidate) => candidates.push(candidate),
                     Err(NoSolution) => (),
                 }
@@ -943,6 +956,116 @@ where
         }
     }
 
+    /// If the self type is the hidden type of an opaque, try to assemble
+    /// candidates for it by consider its item bounds and by using blanket
+    /// impls. This is used to incompletely guide type inference when handling
+    /// non-defining uses in the defining scope.
+    ///
+    /// We otherwise just fail fail with ambiguity. Even if we're using an
+    /// opaque type item bound or a blank impls, we still force its certainty
+    /// to be `Maybe` so that we properly prove this goal later.
+    ///
+    /// See <https://github.com/rust-lang/trait-system-refactor-initiative/issues/182>
+    /// for why this is necessary.
+    fn try_assemble_bounds_via_registered_opaques<G: GoalKind<D>>(
+        &mut self,
+        goal: Goal<I, G>,
+        assemble_from: AssembleCandidatesFrom,
+        candidates: &mut Vec<Candidate<I>>,
+    ) {
+        let self_ty = goal.predicate.self_ty();
+        // If the self type is sub unified with any opaque type, we
+        // also look at blanket impls for it.
+        let mut assemble_blanket_impls = false;
+        for alias_ty in self.opaques_with_sub_unified_hidden_type(self_ty) {
+            assemble_blanket_impls = true;
+            debug!("self ty is sub unified with {alias_ty:?}");
+
+            struct ReplaceOpaque<I: Interner> {
+                cx: I,
+                alias_ty: ty::AliasTy<I>,
+                self_ty: I::Ty,
+            }
+            impl<I: Interner> TypeFolder<I> for ReplaceOpaque<I> {
+                fn cx(&self) -> I {
+                    self.cx
+                }
+                fn fold_ty(&mut self, ty: I::Ty) -> I::Ty {
+                    if let ty::Alias(ty::Opaque, alias_ty) = ty.kind() {
+                        if alias_ty == self.alias_ty {
+                            return self.self_ty;
+                        }
+                    }
+                    ty.super_fold_with(self)
+                }
+            }
+
+            // We look at all item-bounds of the opaque, replacing the
+            // opaque with the current self type before considering
+            // them as a candidate. Imagine e've got `?x: Trait<?y>`
+            // and `?x` has been sub-unified with the hidden type of
+            // `impl Trait<u32>`, We take the item bound `opaque: Trait<u32>`
+            // and replace all occurrences of `opaque` with `?x`. This results
+            // in a `?x: Trait<u32>` alias-bound candidate.
+            for item_bound in self
+                .cx()
+                .item_self_bounds(alias_ty.def_id)
+                .iter_instantiated(self.cx(), alias_ty.args)
+            {
+                let assumption =
+                    item_bound.fold_with(&mut ReplaceOpaque { cx: self.cx(), alias_ty, self_ty });
+                candidates.extend(G::probe_and_match_goal_against_assumption(
+                    self,
+                    CandidateSource::AliasBound,
+                    goal,
+                    assumption,
+                    |ecx| {
+                        // We want to reprove this goal once we've inferred the
+                        // hidden type, so we force the certainty to `Maybe`.
+                        ecx.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS)
+                    },
+                ));
+            }
+        }
+
+        // We also need to consider blanket impls for not-yet-defined opaque types.
+        //
+        // See tests/ui/impl-trait/non-defining-uses/use-blanket-impl.rs for an example.
+        if assemble_blanket_impls && assemble_from.should_assemble_impl_candidates() {
+            let cx = self.cx();
+            cx.for_each_blanket_impl(goal.predicate.trait_def_id(cx), |impl_def_id| {
+                // For every `default impl`, there's always a non-default `impl`
+                // that will *also* apply. There's no reason to register a candidate
+                // for this impl, since it is *not* proof that the trait goal holds.
+                if cx.impl_is_default(impl_def_id) {
+                    return;
+                }
+
+                match G::consider_impl_candidate(self, goal, impl_def_id, |ecx, certainty| {
+                    if ecx.shallow_resolve(self_ty).is_ty_var() {
+                        // We force the certainty of impl candidates to be `Maybe`.
+                        let certainty = certainty.and(Certainty::AMBIGUOUS);
+                        ecx.evaluate_added_goals_and_make_canonical_response(certainty)
+                    } else {
+                        // We don't want to use impls if they constrain the opaque.
+                        //
+                        // FIXME(trait-system-refactor-initiative#229): This isn't
+                        // perfect yet as it still allows us to incorrectly constrain
+                        // other inference variables.
+                        Err(NoSolution)
+                    }
+                }) {
+                    Ok(candidate) => candidates.push(candidate),
+                    Err(NoSolution) => (),
+                }
+            });
+        }
+
+        if candidates.is_empty() {
+            candidates.extend(self.forced_ambiguity(MaybeCause::Ambiguity));
+        }
+    }
+
     /// Assemble and merge candidates for goals which are related to an underlying trait
     /// goal. Right now, this is normalizes-to and host effect goals.
     ///
diff --git a/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs b/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
index 6646857a13682..cb72c1cd92b84 100644
--- a/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
@@ -124,6 +124,7 @@ where
         ecx: &mut EvalCtxt<'_, D>,
         goal: Goal<I, Self>,
         impl_def_id: I::ImplId,
+        then: impl FnOnce(&mut EvalCtxt<'_, D>, Certainty) -> QueryResult<I>,
     ) -> Result<Candidate<I>, NoSolution> {
         let cx = ecx.cx();
 
@@ -175,7 +176,7 @@ where
                 });
             ecx.add_goals(GoalSource::ImplWhereBound, const_conditions);
 
-            ecx.evaluate_added_goals_and_make_canonical_response(certainty)
+            then(ecx, certainty)
         })
     }
 
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
index f1c1801dd3f19..3e3a5246f3d76 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
@@ -1060,6 +1060,10 @@ where
         self.delegate.resolve_vars_if_possible(value)
     }
 
+    pub(super) fn shallow_resolve(&self, ty: I::Ty) -> I::Ty {
+        self.delegate.shallow_resolve(ty)
+    }
+
     pub(super) fn eager_resolve_region(&self, r: I::Region) -> I::Region {
         if let ty::ReVar(vid) = r.kind() {
             self.delegate.opportunistic_resolve_lt_var(vid)
@@ -1176,6 +1180,33 @@ where
     ) -> bool {
         may_use_unstable_feature(&**self.delegate, param_env, symbol)
     }
+
+    pub(crate) fn opaques_with_sub_unified_hidden_type(
+        &self,
+        self_ty: I::Ty,
+    ) -> impl Iterator<Item = ty::AliasTy<I>> + use<'a, D, I> {
+        let delegate = self.delegate;
+        delegate
+            .clone_opaque_types_lookup_table()
+            .into_iter()
+            .chain(delegate.clone_duplicate_opaque_types())
+            .filter_map(move |(key, hidden_ty)| {
+                if let ty::Infer(ty::TyVar(self_vid)) = self_ty.kind() {
+                    if let ty::Infer(ty::TyVar(hidden_vid)) = hidden_ty.kind() {
+                        if delegate.sub_unification_table_root_var(self_vid)
+                            == delegate.sub_unification_table_root_var(hidden_vid)
+                        {
+                            return Some(ty::AliasTy::new_from_args(
+                                delegate.cx(),
+                                key.def_id.into(),
+                                key.args,
+                            ));
+                        }
+                    }
+                }
+                None
+            })
+    }
 }
 
 /// Eagerly replace aliases with inference variables, emitting `AliasRelate`
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 6e6be829f5212..54b92ebac1ded 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
@@ -194,6 +194,7 @@ where
         ecx: &mut EvalCtxt<'_, D>,
         goal: Goal<I, NormalizesTo<I>>,
         impl_def_id: I::ImplId,
+        then: impl FnOnce(&mut EvalCtxt<'_, D>, Certainty) -> QueryResult<I>,
     ) -> Result<Candidate<I>, NoSolution> {
         let cx = ecx.cx();
 
@@ -314,8 +315,7 @@ where
                         // nested goal for consistency.
                         ty::TypingMode::Coherence => {
                             ecx.add_goal(GoalSource::Misc, goal.with(cx, PredicateKind::Ambiguous));
-                            return ecx
-                                .evaluate_added_goals_and_make_canonical_response(Certainty::Yes);
+                            return then(ecx, Certainty::Yes);
                         }
                         ty::TypingMode::Analysis { .. }
                         | ty::TypingMode::Borrowck { .. }
@@ -325,8 +325,7 @@ where
                                 goal,
                                 goal.predicate.alias,
                             );
-                            return ecx
-                                .evaluate_added_goals_and_make_canonical_response(Certainty::Yes);
+                            return then(ecx, Certainty::Yes);
                         }
                     }
                 } else {
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 3e720a47f32e7..a69e867289cee 100644
--- a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
@@ -55,6 +55,7 @@ where
         ecx: &mut EvalCtxt<'_, D>,
         goal: Goal<I, TraitPredicate<I>>,
         impl_def_id: I::ImplId,
+        then: impl FnOnce(&mut EvalCtxt<'_, D>, Certainty) -> QueryResult<I>,
     ) -> Result<Candidate<I>, NoSolution> {
         let cx = ecx.cx();
 
@@ -112,7 +113,7 @@ where
                     .map(|pred| goal.with(cx, pred)),
             );
 
-            ecx.evaluate_added_goals_and_make_canonical_response(maximal_certainty)
+            then(ecx, maximal_certainty)
         })
     }
 
diff --git a/compiler/rustc_type_ir/src/interner.rs b/compiler/rustc_type_ir/src/interner.rs
index 3a83b1739ffab..cf58aec14a680 100644
--- a/compiler/rustc_type_ir/src/interner.rs
+++ b/compiler/rustc_type_ir/src/interner.rs
@@ -347,6 +347,7 @@ pub trait Interner:
         self_ty: Self::Ty,
         f: impl FnMut(Self::ImplId),
     );
+    fn for_each_blanket_impl(self, trait_def_id: Self::TraitId, f: impl FnMut(Self::ImplId));
 
     fn has_item_definition(self, def_id: Self::DefId) -> bool;
 
diff --git a/tests/ui/impl-trait/non-defining-uses/avoid-inference-constraints-from-blanket-2.next.stderr b/tests/ui/impl-trait/non-defining-uses/avoid-inference-constraints-from-blanket-2.next.stderr
new file mode 100644
index 0000000000000..86ac1bdad0416
--- /dev/null
+++ b/tests/ui/impl-trait/non-defining-uses/avoid-inference-constraints-from-blanket-2.next.stderr
@@ -0,0 +1,16 @@
+error[E0308]: mismatched types
+  --> $DIR/avoid-inference-constraints-from-blanket-2.rs:27:18
+   |
+LL |     let _: u32 = x;
+   |            ---   ^ expected `u32`, found `u64`
+   |            |
+   |            expected due to this
+   |
+help: you can convert a `u64` to a `u32` and panic if the converted value doesn't fit
+   |
+LL |     let _: u32 = x.try_into().unwrap();
+   |                   ++++++++++++++++++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/impl-trait/non-defining-uses/avoid-inference-constraints-from-blanket-2.rs b/tests/ui/impl-trait/non-defining-uses/avoid-inference-constraints-from-blanket-2.rs
new file mode 100644
index 0000000000000..b4f853de4aad3
--- /dev/null
+++ b/tests/ui/impl-trait/non-defining-uses/avoid-inference-constraints-from-blanket-2.rs
@@ -0,0 +1,31 @@
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[current] check-pass
+
+// Regression test for trait-system-refactor-initiative#205. Avoid
+// constraining other impl arguments when applying blanket impls.
+
+// FIXME(-Znext-solver): This currently incompletely constrains the
+// argument of `opaque: Trait<?x>` using the blanket impl of trait.
+// Ideally we don't do that.
+
+trait Trait<T> {}
+
+impl<T> Trait<u64> for T {}
+impl Trait<u32> for u64 {}
+
+fn impls_trait<T: Trait<U>, U>(_: U) -> T {
+    todo!()
+}
+
+fn foo() -> impl Sized {
+    let x = Default::default();
+    if false {
+        return impls_trait::<_, _>(x);
+    }
+    let _: u32 = x;
+    //[next]~^ ERROR mismatched types
+    1u64
+}
+fn main() {}
diff --git a/tests/ui/impl-trait/non-defining-uses/avoid-inference-constraints-from-blanket-3.rs b/tests/ui/impl-trait/non-defining-uses/avoid-inference-constraints-from-blanket-3.rs
new file mode 100644
index 0000000000000..2f29cb4ee6b4f
--- /dev/null
+++ b/tests/ui/impl-trait/non-defining-uses/avoid-inference-constraints-from-blanket-3.rs
@@ -0,0 +1,25 @@
+//@ compile-flags: -Znext-solver
+//@ ignore-compare-mode-next-solver (explicit revisions)
+#![allow(unconditional_recursion)]
+
+// Regression test for trait-system-refactor-initiative#205. Avoid
+// constraining other impl arguments when applying blanket impls,
+// especially if the nested where-bounds of the blanket impl don't
+// actually apply for the opaque.
+
+// FIXME(-Znext-solver): This currently incompletely constrains the
+// argument of `opaque: Trait<?x>` using the blanket impl of trait.
+// Ideally we don't do that.
+
+trait Trait<T> {}
+
+impl<T: Copy> Trait<u32> for T {}
+impl Trait<u64> for String {}
+fn impls_trait<T: Trait<U>, U>(_: T) {}
+
+fn test() -> impl Sized {
+    let x = test();
+    impls_trait(x); //~ ERROR the trait bound `String: Trait<u32>` is not satisfied
+    String::new()
+}
+fn main() {}
diff --git a/tests/ui/impl-trait/non-defining-uses/avoid-inference-constraints-from-blanket-3.stderr b/tests/ui/impl-trait/non-defining-uses/avoid-inference-constraints-from-blanket-3.stderr
new file mode 100644
index 0000000000000..a5d19b484811b
--- /dev/null
+++ b/tests/ui/impl-trait/non-defining-uses/avoid-inference-constraints-from-blanket-3.stderr
@@ -0,0 +1,25 @@
+error[E0277]: the trait bound `String: Trait<u32>` is not satisfied
+  --> $DIR/avoid-inference-constraints-from-blanket-3.rs:22:5
+   |
+LL |     impls_trait(x);
+   |     ^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `String`
+   |
+   = help: the trait `Trait<u32>` is not implemented for `String`
+           but trait `Trait<u64>` is implemented for it
+   = help: for that trait implementation, expected `u64`, found `u32`
+note: required for `String` to implement `Trait<u32>`
+  --> $DIR/avoid-inference-constraints-from-blanket-3.rs:16:15
+   |
+LL | impl<T: Copy> Trait<u32> for T {}
+   |         ----  ^^^^^^^^^^     ^
+   |         |
+   |         unsatisfied trait bound introduced here
+note: required by a bound in `impls_trait`
+  --> $DIR/avoid-inference-constraints-from-blanket-3.rs:18:19
+   |
+LL | fn impls_trait<T: Trait<U>, U>(_: T) {}
+   |                   ^^^^^^^^ required by this bound in `impls_trait`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/impl-trait/non-defining-uses/avoid-inference-constraints-from-blanket.rs b/tests/ui/impl-trait/non-defining-uses/avoid-inference-constraints-from-blanket.rs
new file mode 100644
index 0000000000000..bb3acfde5bc87
--- /dev/null
+++ b/tests/ui/impl-trait/non-defining-uses/avoid-inference-constraints-from-blanket.rs
@@ -0,0 +1,25 @@
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@ check-pass
+
+// Regression test for trait-system-refactor-initiative#205. Avoid constraining
+// the opaque type when applying blanket impls.
+
+trait Trait<T> {}
+
+impl<T> Trait<T> for T {}
+impl Trait<u32> for u64 {}
+
+fn impls_trait<T: Trait<U>, U>() -> T {
+    todo!()
+}
+
+fn foo() -> impl Sized {
+    if false {
+        // `opaque: Trait<u32>` shouldn't constrain `opaque` to `u32` via the blanket impl
+        return impls_trait::<_, u32>();
+    }
+    1u64
+}
+fn main() {}
diff --git a/tests/ui/impl-trait/non-defining-uses/multiple-opaques-ambig.rs b/tests/ui/impl-trait/non-defining-uses/multiple-opaques-ambig.rs
new file mode 100644
index 0000000000000..e7aaf6fa135a9
--- /dev/null
+++ b/tests/ui/impl-trait/non-defining-uses/multiple-opaques-ambig.rs
@@ -0,0 +1,23 @@
+//@ compile-flags: -Znext-solver
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@ check-pass
+#![allow(unconditional_recursion)]
+
+// Regression test for trait-system-refactor-initiative#182. If multiple
+// opaque types result in different item bounds, do not apply them.
+
+trait Trait<T> {}
+impl<T, U> Trait<T> for U {}
+
+fn impls_trait<T: Trait<U>, U>(_: T) -> U {
+    todo!()
+}
+
+fn overlap<T, U>() -> (impl Trait<T>, impl Trait<U>) {
+    let mut x = overlap::<T, U>().0;
+    x = overlap::<T, U>().1;
+    let u = impls_trait(x);
+    let _: u32 = u;
+    ((), ())
+}
+fn main() {}
diff --git a/tests/ui/impl-trait/non-defining-uses/multiple-opaques-ok.rs b/tests/ui/impl-trait/non-defining-uses/multiple-opaques-ok.rs
new file mode 100644
index 0000000000000..d91efe181e354
--- /dev/null
+++ b/tests/ui/impl-trait/non-defining-uses/multiple-opaques-ok.rs
@@ -0,0 +1,37 @@
+//@ compile-flags: -Znext-solver
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@ check-pass
+#![allow(unconditional_recursion)]
+
+// Regression test for trait-system-refactor-initiative#18, making sure
+// we support being sub unified with more than 1 opaque type.
+
+trait Id {
+    type This;
+}
+impl Id for &'static str {
+    type This = &'static str;
+}
+fn to_assoc<T: Id>(x: T) -> <T as Id>::This {
+    todo!()
+}
+
+fn mirror1() -> (impl Id<This = &'static str>, impl Sized) {
+    let mut opaque = mirror1().0;
+    opaque = mirror1().1;
+    let x = to_assoc(opaque);
+    // `?x` equals both opaques, make sure we still use the applicable
+    // item bound.
+    x.len();
+    (x, x)
+}
+fn mirror2() -> (impl Sized, impl Id<This = &'static str>) {
+    let mut opaque = mirror2().0;
+    opaque = mirror2().1;
+    let x = to_assoc(opaque);
+    // `?x` equals both opaques, make sure we still use the applicable
+    // item bound.
+    x.len();
+    (x, x)
+}
+fn main() {}
diff --git a/tests/ui/impl-trait/non-defining-uses/no-rigid-alias.rs b/tests/ui/impl-trait/non-defining-uses/no-rigid-alias.rs
new file mode 100644
index 0000000000000..fca5db3e20f88
--- /dev/null
+++ b/tests/ui/impl-trait/non-defining-uses/no-rigid-alias.rs
@@ -0,0 +1,27 @@
+//@ compile-flags: -Znext-solver
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@ check-pass
+#![allow(unconditional_recursion)]
+
+// Test for trait-system-refactor-initiative#182 making sure
+// that we don't incorrectly normalize to rigid aliases if the
+// opaque type only has a trait bound.
+
+trait Id {
+    type This;
+}
+impl<T> Id for Vec<T> {
+    type This = Vec<T>;
+}
+fn to_assoc<T: Id>(x: T) -> <T as Id>::This {
+    todo!()
+}
+
+fn mirror<T>(x: Vec<T>) -> impl Id {
+    let x = to_assoc(mirror(x));
+    // `?x` equals `<opaque::<T> as Id>::This`. We should not infer `?x`
+    // to be a rigid alias here.
+    let _: Vec<u32> = x;
+    x
+}
+fn main() {}
diff --git a/tests/ui/impl-trait/non-defining-uses/use-blanket-impl.rs b/tests/ui/impl-trait/non-defining-uses/use-blanket-impl.rs
new file mode 100644
index 0000000000000..50bb3995b9444
--- /dev/null
+++ b/tests/ui/impl-trait/non-defining-uses/use-blanket-impl.rs
@@ -0,0 +1,19 @@
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@ check-pass
+
+// Regression test for trait-system-refactor-initiative#196.
+fn iterator(b: bool) -> impl Iterator<Item = String> {
+    if b {
+        // We need to eagerly figure out the type of `i` here by using
+        // the `<opaque as IntoIterator>::Item` obligation. This means
+        // we not only have to consider item bounds, but also blanket impls.
+        for i in iterator(false) {
+            i.len();
+        }
+    }
+
+    vec![].into_iter()
+}
+fn main() {}
diff --git a/tests/ui/impl-trait/non-defining-uses/use-item-bound-over-blanket-impl.rs b/tests/ui/impl-trait/non-defining-uses/use-item-bound-over-blanket-impl.rs
new file mode 100644
index 0000000000000..7c2766ade3fa5
--- /dev/null
+++ b/tests/ui/impl-trait/non-defining-uses/use-item-bound-over-blanket-impl.rs
@@ -0,0 +1,30 @@
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@ check-pass
+#![allow(unconditional_recursion)]
+
+// Regression test for trait-system-refactor-initiative#182.
+
+trait Id {
+    type This;
+}
+impl<T> Id for T {
+    type This = T;
+}
+fn to_assoc<T>(x: T) -> <T as Id>::This {
+    x
+}
+
+fn mirror<T>(x: Vec<T>) -> impl Id<This = Vec<T>> {
+    let x = to_assoc(mirror(x));
+    // `?x` equals `<opaque::<T> as Id>::This`. We need to eagerly infer the
+    // type of `?x` to prevent this method call from resulting in an error.
+    //
+    // We could use both the item bound to normalize to `Vec<T>`, or the
+    // blanket impl to normalize to `opaque::<T>`. We have to go with the
+    // item bound.
+    x.len();
+    x
+}
+fn main() {}
diff --git a/tests/ui/impl-trait/non-defining-uses/use-item-bound.rs b/tests/ui/impl-trait/non-defining-uses/use-item-bound.rs
new file mode 100644
index 0000000000000..36dcbacbe6fdf
--- /dev/null
+++ b/tests/ui/impl-trait/non-defining-uses/use-item-bound.rs
@@ -0,0 +1,25 @@
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@ check-pass
+#![allow(unconditional_recursion)]
+// Regression test for trait-system-refactor-initiative#182.
+
+trait Id {
+    type This;
+}
+impl<T> Id for Vec<T> {
+    type This = Vec<T>;
+}
+fn to_assoc<T: Id>(x: T) -> <T as Id>::This {
+    todo!()
+}
+
+fn mirror<T>(x: Vec<T>) -> impl Id<This = Vec<T>> {
+    let x = to_assoc(mirror(x));
+    // `?x` equals `<opaque::<T> as Id>::This`. We need to eagerly infer the
+    // type of `?x` to prevent this method call from resulting in an error.
+    x.len();
+    x
+}
+fn main() {}

From d588c110102b803ebb2d3d26d8c24346bb4968a5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Thu, 11 Sep 2025 12:45:28 +0200
Subject: [PATCH 0805/1889] Restructure the docs

---
 .../src/tests/codegen-backend-tests/cg_gcc.md | 52 +++++++++++++------
 1 file changed, 37 insertions(+), 15 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/tests/codegen-backend-tests/cg_gcc.md b/src/doc/rustc-dev-guide/src/tests/codegen-backend-tests/cg_gcc.md
index ef407797fead1..74dbfb7d31b30 100644
--- a/src/doc/rustc-dev-guide/src/tests/codegen-backend-tests/cg_gcc.md
+++ b/src/doc/rustc-dev-guide/src/tests/codegen-backend-tests/cg_gcc.md
@@ -1,34 +1,56 @@
-# GCC codegen backend tests
+# GCC codegen backend
 
-To test the GCC codegen backend, you need to add `"gcc"` into the `rust.codegen-backends`
-setting in `bootstrap.toml`:
+If you ran into an error related to tests executed with the GCC codegen backend on CI,
+you can use the following command to run tests locally using the GCC backend:
+
+```bash
+./x test tests/ui --set 'rust.codegen-backends = ["llvm", "gcc"]' --test-codegen-backend gcc
+```
+
+Below, you can find more information about how to configure the GCC backend in bootstrap.
+
+## Choosing which codegen backends are built
+
+The `rust.codegen-backends = [...]` bootstrap option affects which codegen backends will be built and
+included in the sysroot of the produced `rustc`. To use the GCC codegen backend, `"gcc"` has to
+be included in this array in `bootstrap.toml`:
 
 ```toml
 rust.codegen-backends = ["llvm", "gcc"]
 ```
 
-If you don't want to change your `bootstrap.toml` file, you can alternatively run your `x.py`
+If you don't want to change your `bootstrap.toml` file, you can alternatively run your `x`
 commands with `--set rust.codegen-backends=["llvm", "gcc"]'`. For example:
 
 ```bash
-x.py test --set 'rust.codegen-backends=["llvm", "gcc"]'
+./x build --set 'rust.codegen-backends=["llvm", "gcc"]'
 ```
 
-If you don't want to build `gcc` yourself, you also need to set:
+The first backend in the `codegen-backends` array will determine which backend will be used as the
+*default backend* of the built `rustc`. This also determines which backend will be used to compile the
+stage 1 standard library (or anything built in stage 2+). To produce `rustc` that uses the GCC backend
+by default, you can thus put `"gcc"` as the first element of this array:
 
-```toml
-gcc.download-ci-gcc = true
+```bash
+./x build --set 'rust.codegen-backends=["gcc"]' library
 ```
 
-Then when running tests, add the `--test-codegen-backend gcc` option. For example:
+## Choosing the codegen backend used in tests
+
+To run compiler tests with the GCC codegen backend being used to build the test Rust programs, you can use the
+`--test-codegen-backend` flag:
 
 ```bash
-./x.py test tests/ui --test-codegen-backend gcc
+./x test tests/ui --test-codegen-backend gcc
 ```
 
-If you want to build the sysroot using the GCC backend, you need to set it first
-in `rust.codegen-backends`:
+Note that in order for this to work, the tested compiler must have the GCC codegen backend available in its sysroot
+directory. You can achieve that using the [instructions above](#choosing-which-codegen-backends-are-built).
 
-```toml
-rust.codegen-backends = ["llvm", "gcc"]
-```
+## Downloading GCC from CI
+
+The `gcc.download-ci-gcc` bootstrap option controls if GCC (which is a dependency of the GCC codegen backend)
+will be downloaded from CI or built locally. The default value is `true`, which will download GCC from CI
+if there are no local changes to the GCC sources and the given host target is available on CI.
+
+Note that GCC can currently only be downloaded from CI for the `x86_64-unknown-linux-gnu` target.

From c3bd8b6f387b6b6409347916fe901ccad7ec137a Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Tue, 9 Sep 2025 18:01:24 -0400
Subject: [PATCH 0806/1889] Update cargo submodule

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

diff --git a/src/tools/cargo b/src/tools/cargo
index 761c4658d0079..24bb93c388fb8 160000
--- a/src/tools/cargo
+++ b/src/tools/cargo
@@ -1 +1 @@
-Subproject commit 761c4658d0079d607e6d33cf0c060e61a617cad3
+Subproject commit 24bb93c388fb8c211a37986539f24a819dc669d3

From 35979519ae8125537e765e2adc75ad41cda7a9da Mon Sep 17 00:00:00 2001
From: WANG Rui <wangrui@loongson.cn>
Date: Thu, 11 Sep 2025 21:52:42 +0800
Subject: [PATCH 0807/1889] bootstrap: Build jemalloc for LoongArch with
 support for 16K pages
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

By default, jemalloc is configured with a 4K page size. If the
host’s page size is larger than this, it will crash at runtime.
This patch raises the page size to 16K.
---
 src/bootstrap/src/core/build_steps/compile.rs | 17 ++++++++++-------
 src/bootstrap/src/core/build_steps/tool.rs    | 14 ++++++++++----
 2 files changed, 20 insertions(+), 11 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index 0b75e85772f86..1458b0beefa85 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -1383,14 +1383,17 @@ pub fn rustc_cargo_env(builder: &Builder<'_>, cargo: &mut Cargo, target: TargetS
         }
     }
 
-    // Build jemalloc on AArch64 with support for page sizes up to 64K
-    // See: https://github.com/rust-lang/rust/pull/135081
     // See also the "JEMALLOC_SYS_WITH_LG_PAGE" setting in the tool build step.
-    if builder.config.jemalloc(target)
-        && target.starts_with("aarch64")
-        && env::var_os("JEMALLOC_SYS_WITH_LG_PAGE").is_none()
-    {
-        cargo.env("JEMALLOC_SYS_WITH_LG_PAGE", "16");
+    if builder.config.jemalloc(target) && env::var_os("JEMALLOC_SYS_WITH_LG_PAGE").is_none() {
+        // Build jemalloc on AArch64 with support for page sizes up to 64K
+        // See: https://github.com/rust-lang/rust/pull/135081
+        if target.starts_with("aarch64") {
+            cargo.env("JEMALLOC_SYS_WITH_LG_PAGE", "16");
+        }
+        // Build jemalloc on LoongArch with support for page sizes up to 16K
+        else if target.starts_with("loongarch") {
+            cargo.env("JEMALLOC_SYS_WITH_LG_PAGE", "14");
+        }
     }
 }
 
diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
index 6870bf3eddcd8..dcc4898cae16a 100644
--- a/src/bootstrap/src/core/build_steps/tool.rs
+++ b/src/bootstrap/src/core/build_steps/tool.rs
@@ -228,12 +228,18 @@ pub fn prepare_tool_cargo(
     // own copy
     cargo.env("LZMA_API_STATIC", "1");
 
-    // Build jemalloc on AArch64 with support for page sizes up to 64K
-    // See: https://github.com/rust-lang/rust/pull/135081
     // Note that `miri` always uses jemalloc. As such, there is no checking of the jemalloc build flag.
     // See also the "JEMALLOC_SYS_WITH_LG_PAGE" setting in the compile build step.
-    if target.starts_with("aarch64") && env::var_os("JEMALLOC_SYS_WITH_LG_PAGE").is_none() {
-        cargo.env("JEMALLOC_SYS_WITH_LG_PAGE", "16");
+    if env::var_os("JEMALLOC_SYS_WITH_LG_PAGE").is_none() {
+        // Build jemalloc on AArch64 with support for page sizes up to 64K
+        // See: https://github.com/rust-lang/rust/pull/135081
+        if target.starts_with("aarch64") {
+            cargo.env("JEMALLOC_SYS_WITH_LG_PAGE", "16");
+        }
+        // Build jemalloc on LoongArch with support for page sizes up to 16K
+        else if target.starts_with("loongarch") {
+            cargo.env("JEMALLOC_SYS_WITH_LG_PAGE", "14");
+        }
     }
 
     // CFG_RELEASE is needed by rustfmt (and possibly other tools) which

From 24d195bc07da61a0ab74ac166d659f1924a604ea Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 11 Sep 2025 15:03:53 +0200
Subject: [PATCH 0808/1889] weak_memory: fix sync clock handling when loading
 from old store elements

---
 src/tools/miri/src/concurrency/data_race.rs   | 40 ++++++---
 src/tools/miri/src/concurrency/weak_memory.rs | 87 +++++++++++++------
 .../miri/tests/pass/0weak_memory/weak.rs      | 44 +++++++---
 3 files changed, 121 insertions(+), 50 deletions(-)

diff --git a/src/tools/miri/src/concurrency/data_race.rs b/src/tools/miri/src/concurrency/data_race.rs
index 16cac7e6d04c1..1ad9ace1b5d1a 100644
--- a/src/tools/miri/src/concurrency/data_race.rs
+++ b/src/tools/miri/src/concurrency/data_race.rs
@@ -183,6 +183,9 @@ struct AtomicMemoryCellClocks {
     /// contains the vector of timestamps that will
     /// happen-before a thread if an acquire-load is
     /// performed on the data.
+    ///
+    /// With weak memory emulation, this is the clock of the most recent write. It is then only used
+    /// for release sequences, to integrate the most recent clock into the next one for RMWs.
     sync_vector: VClock,
 
     /// The size of accesses to this atomic location.
@@ -504,10 +507,11 @@ impl MemoryCellClocks {
         thread_clocks: &mut ThreadClockSet,
         index: VectorIdx,
         access_size: Size,
+        sync_clock: Option<&VClock>,
     ) -> Result<(), DataRace> {
         self.atomic_read_detect(thread_clocks, index, access_size)?;
-        if let Some(atomic) = self.atomic() {
-            thread_clocks.clock.join(&atomic.sync_vector);
+        if let Some(sync_clock) = sync_clock.or_else(|| self.atomic().map(|a| &a.sync_vector)) {
+            thread_clocks.clock.join(sync_clock);
         }
         Ok(())
     }
@@ -520,10 +524,11 @@ impl MemoryCellClocks {
         thread_clocks: &mut ThreadClockSet,
         index: VectorIdx,
         access_size: Size,
+        sync_clock: Option<&VClock>,
     ) -> Result<(), DataRace> {
         self.atomic_read_detect(thread_clocks, index, access_size)?;
-        if let Some(atomic) = self.atomic() {
-            thread_clocks.fence_acquire.join(&atomic.sync_vector);
+        if let Some(sync_clock) = sync_clock.or_else(|| self.atomic().map(|a| &a.sync_vector)) {
+            thread_clocks.fence_acquire.join(sync_clock);
         }
         Ok(())
     }
@@ -736,8 +741,8 @@ pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
         }
 
         let scalar = this.allow_data_races_ref(move |this| this.read_scalar(place))?;
-        let buffered_scalar = this.buffered_atomic_read(place, atomic, scalar, || {
-            this.validate_atomic_load(place, atomic)
+        let buffered_scalar = this.buffered_atomic_read(place, atomic, scalar, |sync_clock| {
+            this.validate_atomic_load(place, atomic, sync_clock)
         })?;
         interp_ok(buffered_scalar.ok_or_else(|| err_ub!(InvalidUninitBytes(None)))?)
     }
@@ -935,7 +940,7 @@ pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
             this.validate_atomic_rmw(place, success)?;
             this.buffered_atomic_rmw(new, place, success, old.to_scalar())?;
         } else {
-            this.validate_atomic_load(place, fail)?;
+            this.validate_atomic_load(place, fail, /* can use latest sync clock */ None)?;
             // A failed compare exchange is equivalent to a load, reading from the latest store
             // in the modification order.
             // Since `old` is only a value and not the store element, we need to separately
@@ -1177,6 +1182,18 @@ impl VClockAlloc {
         }))?
     }
 
+    /// Return the release/acquire synchronization clock for the given memory range.
+    pub(super) fn sync_clock(&self, access_range: AllocRange) -> VClock {
+        let alloc_ranges = self.alloc_ranges.borrow();
+        let mut clock = VClock::default();
+        for (_, mem_clocks) in alloc_ranges.iter(access_range.start, access_range.size) {
+            if let Some(atomic) = mem_clocks.atomic() {
+                clock.join(&atomic.sync_vector);
+            }
+        }
+        clock
+    }
+
     /// Detect data-races for an unsynchronized read operation. It will not perform
     /// data-race detection if `race_detecting()` is false, either due to no threads
     /// being created or if it is temporarily disabled during a racy read or write
@@ -1453,6 +1470,7 @@ trait EvalContextPrivExt<'tcx>: MiriInterpCxExt<'tcx> {
         &self,
         place: &MPlaceTy<'tcx>,
         atomic: AtomicReadOrd,
+        sync_clock: Option<&VClock>,
     ) -> InterpResult<'tcx> {
         let this = self.eval_context_ref();
         this.validate_atomic_op(
@@ -1461,9 +1479,9 @@ trait EvalContextPrivExt<'tcx>: MiriInterpCxExt<'tcx> {
             AccessType::AtomicLoad,
             move |memory, clocks, index, atomic| {
                 if atomic == AtomicReadOrd::Relaxed {
-                    memory.load_relaxed(&mut *clocks, index, place.layout.size)
+                    memory.load_relaxed(&mut *clocks, index, place.layout.size, sync_clock)
                 } else {
-                    memory.load_acquire(&mut *clocks, index, place.layout.size)
+                    memory.load_acquire(&mut *clocks, index, place.layout.size, sync_clock)
                 }
             },
         )
@@ -1508,9 +1526,9 @@ trait EvalContextPrivExt<'tcx>: MiriInterpCxExt<'tcx> {
             AccessType::AtomicRmw,
             move |memory, clocks, index, _| {
                 if acquire {
-                    memory.load_acquire(clocks, index, place.layout.size)?;
+                    memory.load_acquire(clocks, index, place.layout.size, None)?;
                 } else {
-                    memory.load_relaxed(clocks, index, place.layout.size)?;
+                    memory.load_relaxed(clocks, index, place.layout.size, None)?;
                 }
                 if release {
                     memory.rmw_release(clocks, index, place.layout.size)
diff --git a/src/tools/miri/src/concurrency/weak_memory.rs b/src/tools/miri/src/concurrency/weak_memory.rs
index caa27422d2f26..6ebade6a568a2 100644
--- a/src/tools/miri/src/concurrency/weak_memory.rs
+++ b/src/tools/miri/src/concurrency/weak_memory.rs
@@ -62,8 +62,11 @@
 //! You can refer to test cases in weak_memory/extra_cpp.rs and weak_memory/extra_cpp_unsafe.rs for examples of these operations.
 
 // Our and the author's own implementation (tsan11) of the paper have some deviations from the provided operational semantics in §5.3:
-// 1. In the operational semantics, store elements keep a copy of the atomic object's vector clock (AtomicCellClocks::sync_vector in miri),
-// but this is not used anywhere so it's omitted here.
+// 1. In the operational semantics, loads acquire the vector clock of the atomic location
+// irrespective of which store buffer element is loaded. That's incorrect; the synchronization clock
+// needs to be tracked per-store-buffer-element. (The paper has a field "clocks" for that purpose,
+// but it is not actuallt used.) tsan11 does this correctly
+// (https://github.com/ChrisLidbury/tsan11/blob/ecbd6b81e9b9454e01cba78eb9d88684168132c7/lib/tsan/rtl/tsan_relaxed.cc#L305).
 //
 // 2. In the operational semantics, each store element keeps the timestamp of a thread when it loads from the store.
 // If the same thread loads from the same store element multiple times, then the timestamps at all loads are saved in a list of load elements.
@@ -138,16 +141,17 @@ enum LoadRecency {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 struct StoreElement {
-    /// The identifier of the vector index, corresponding to a thread
-    /// that performed the store.
-    store_index: VectorIdx,
+    /// The thread that performed the store.
+    store_thread: VectorIdx,
+    /// The timestamp of the storing thread when it performed the store
+    store_timestamp: VTimestamp,
+
+    /// The vector clock that can be acquired by loading this store.
+    sync_clock: VClock,
 
     /// Whether this store is SC.
     is_seqcst: bool,
 
-    /// The timestamp of the storing thread when it performed the store
-    timestamp: VTimestamp,
-
     /// The value of this store. `None` means uninitialized.
     // FIXME: Currently, we cannot represent partial initialization.
     val: Option<Scalar>,
@@ -246,8 +250,10 @@ impl<'tcx> StoreBuffer {
         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
-            store_index: VectorIdx::from(0),
-            timestamp: VTimestamp::ZERO,
+            store_thread: VectorIdx::from(0),
+            store_timestamp: VTimestamp::ZERO,
+            // The initialization write is non-atomic so nothing can be acquired.
+            sync_clock: VClock::default(),
             val: init,
             is_seqcst: false,
             load_info: RefCell::new(LoadInfo::default()),
@@ -276,7 +282,7 @@ impl<'tcx> StoreBuffer {
         thread_mgr: &ThreadManager<'_>,
         is_seqcst: bool,
         rng: &mut (impl rand::Rng + ?Sized),
-        validate: impl FnOnce() -> InterpResult<'tcx>,
+        validate: impl FnOnce(Option<&VClock>) -> InterpResult<'tcx>,
     ) -> 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
@@ -293,7 +299,7 @@ impl<'tcx> StoreBuffer {
         // after we've picked a store element from the store buffer, as presented
         // in ATOMIC LOAD rule of the paper. This is because fetch_store
         // requires access to ThreadClockSet.clock, which is updated by the race detector
-        validate()?;
+        validate(Some(&store_elem.sync_clock))?;
 
         let (index, clocks) = global.active_thread_state(thread_mgr);
         let loaded = store_elem.load_impl(index, &clocks, is_seqcst);
@@ -306,10 +312,11 @@ impl<'tcx> StoreBuffer {
         global: &DataRaceState,
         thread_mgr: &ThreadManager<'_>,
         is_seqcst: bool,
+        sync_clock: VClock,
     ) -> InterpResult<'tcx> {
         let (index, clocks) = global.active_thread_state(thread_mgr);
 
-        self.store_impl(val, index, &clocks.clock, is_seqcst);
+        self.store_impl(val, index, &clocks.clock, is_seqcst, sync_clock);
         interp_ok(())
     }
 
@@ -336,7 +343,9 @@ impl<'tcx> StoreBuffer {
                     return false;
                 }
 
-                keep_searching = if store_elem.timestamp <= clocks.clock[store_elem.store_index] {
+                keep_searching = if store_elem.store_timestamp
+                    <= clocks.clock[store_elem.store_thread]
+                {
                     // CoWR: if a store happens-before the current load,
                     // then we can't read-from anything earlier in modification order.
                     // C++20 §6.9.2.2 [intro.races] paragraph 18
@@ -348,7 +357,7 @@ impl<'tcx> StoreBuffer {
                     // then we cannot read-from anything earlier in modification order.
                     // C++20 §6.9.2.2 [intro.races] paragraph 16
                     false
-                } else if store_elem.timestamp <= clocks.write_seqcst[store_elem.store_index]
+                } else if store_elem.store_timestamp <= clocks.write_seqcst[store_elem.store_thread]
                     && store_elem.is_seqcst
                 {
                     // The current non-SC load, which may be sequenced-after an SC fence,
@@ -356,7 +365,7 @@ impl<'tcx> StoreBuffer {
                     // C++17 §32.4 [atomics.order] paragraph 4
                     false
                 } else if is_seqcst
-                    && store_elem.timestamp <= clocks.read_seqcst[store_elem.store_index]
+                    && store_elem.store_timestamp <= clocks.read_seqcst[store_elem.store_thread]
                 {
                     // The current SC load cannot read-before the last store sequenced-before
                     // the last SC fence.
@@ -394,17 +403,19 @@ impl<'tcx> StoreBuffer {
         }
     }
 
-    /// ATOMIC STORE IMPL in the paper (except we don't need the location's vector clock)
+    /// ATOMIC STORE IMPL in the paper
     fn store_impl(
         &mut self,
         val: Scalar,
         index: VectorIdx,
         thread_clock: &VClock,
         is_seqcst: bool,
+        sync_clock: VClock,
     ) {
         let store_elem = StoreElement {
-            store_index: index,
-            timestamp: thread_clock[index],
+            store_thread: index,
+            store_timestamp: thread_clock[index],
+            sync_clock,
             // 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
@@ -422,7 +433,7 @@ impl<'tcx> StoreBuffer {
             // so that in a later SC load, only the last SC store (i.e. this one) or stores that
             // aren't ordered by hb with the last SC is picked.
             self.buffer.iter_mut().rev().for_each(|elem| {
-                if elem.timestamp <= thread_clock[elem.store_index] {
+                if elem.store_timestamp <= thread_clock[elem.store_thread] {
                     elem.is_seqcst = true;
                 }
             })
@@ -465,7 +476,7 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let (alloc_id, base_offset, ..) = this.ptr_get_alloc_id(place.ptr(), 0)?;
         if let (
             crate::AllocExtra {
-                data_race: AllocDataRaceHandler::Vclocks(_, Some(alloc_buffers)),
+                data_race: AllocDataRaceHandler::Vclocks(data_race_clocks, Some(alloc_buffers)),
                 ..
             },
             crate::MiriMachine {
@@ -478,20 +489,29 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 global.sc_write(threads);
             }
             let range = alloc_range(base_offset, place.layout.size);
+            let sync_clock = data_race_clocks.sync_clock(range);
             let buffer = alloc_buffers.get_or_create_store_buffer_mut(range, Some(init))?;
             // The RMW always reads from the most recent store.
             buffer.read_from_last_store(global, threads, atomic == AtomicRwOrd::SeqCst);
-            buffer.buffered_write(new_val, global, threads, atomic == AtomicRwOrd::SeqCst)?;
+            buffer.buffered_write(
+                new_val,
+                global,
+                threads,
+                atomic == AtomicRwOrd::SeqCst,
+                sync_clock,
+            )?;
         }
         interp_ok(())
     }
 
+    /// The argument to `validate` is the synchronization clock of the memory that is being read,
+    /// if we are reading from a store buffer element.
     fn buffered_atomic_read(
         &self,
         place: &MPlaceTy<'tcx>,
         atomic: AtomicReadOrd,
         latest_in_mo: Scalar,
-        validate: impl FnOnce() -> InterpResult<'tcx>,
+        validate: impl FnOnce(Option<&VClock>) -> InterpResult<'tcx>,
     ) -> InterpResult<'tcx, Option<Scalar>> {
         let this = self.eval_context_ref();
         'fallback: {
@@ -529,7 +549,7 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         }
 
         // Race detector or weak memory disabled, simply read the latest value
-        validate()?;
+        validate(None)?;
         interp_ok(Some(latest_in_mo))
     }
 
@@ -537,6 +557,8 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     ///
     /// `init` says with which value to initialize the store buffer in case there wasn't a store
     /// buffer for this memory range before.
+    ///
+    /// Must be called *after* `validate_atomic_store` to ensure that `sync_clock` is up-to-date.
     fn buffered_atomic_write(
         &mut self,
         val: Scalar,
@@ -548,7 +570,7 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let (alloc_id, base_offset, ..) = this.ptr_get_alloc_id(dest.ptr(), 0)?;
         if let (
             crate::AllocExtra {
-                data_race: AllocDataRaceHandler::Vclocks(_, Some(alloc_buffers)),
+                data_race: AllocDataRaceHandler::Vclocks(data_race_clocks, Some(alloc_buffers)),
                 ..
             },
             crate::MiriMachine {
@@ -560,9 +582,18 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 global.sc_write(threads);
             }
 
-            let buffer = alloc_buffers
-                .get_or_create_store_buffer_mut(alloc_range(base_offset, dest.layout.size), init)?;
-            buffer.buffered_write(val, global, threads, atomic == AtomicWriteOrd::SeqCst)?;
+            let range = alloc_range(base_offset, dest.layout.size);
+            // It's a bit annoying that we have to go back to the data race part to get the clock...
+            // but it does make things a lot simpler.
+            let sync_clock = data_race_clocks.sync_clock(range);
+            let buffer = alloc_buffers.get_or_create_store_buffer_mut(range, init)?;
+            buffer.buffered_write(
+                val,
+                global,
+                threads,
+                atomic == AtomicWriteOrd::SeqCst,
+                sync_clock,
+            )?;
         }
 
         // Caller should've written to dest with the vanilla scalar write, we do nothing here
diff --git a/src/tools/miri/tests/pass/0weak_memory/weak.rs b/src/tools/miri/tests/pass/0weak_memory/weak.rs
index 44791d7cd7c50..c752fc114ba57 100644
--- a/src/tools/miri/tests/pass/0weak_memory/weak.rs
+++ b/src/tools/miri/tests/pass/0weak_memory/weak.rs
@@ -44,7 +44,7 @@ fn check_all_outcomes<T: Eq + std::hash::Hash + std::fmt::Debug>(
     let expected: HashSet<T> = HashSet::from_iter(expected);
     let mut seen = HashSet::new();
     // Let's give it N times as many tries as we are expecting values.
-    let tries = expected.len() * 12;
+    let tries = expected.len() * 16;
     for i in 0..tries {
         let val = generate();
         assert!(expected.contains(&val), "got an unexpected value: {val:?}");
@@ -205,19 +205,16 @@ fn release_sequence() {
         let y = static_atomic(0);
 
         let t1 = spawn(move || {
-            x.store(2, Relaxed);
-        });
-        let t2 = spawn(move || {
             y.store(1, Relaxed);
             x.store(1, Release);
             x.swap(3, Relaxed);
         });
-        let t3 = spawn(move || {
+        let t2 = spawn(move || {
             if x.load(Acquire) == 3 {
-                // If we read 3 here, we are seeing the result of the `x.swap` above, which
-                // was relaxed but forms a release sequence with the `x.store` (since we know
-                // `t1` will not be scheduled in between). This means there is a release sequence,
-                // so we acquire the `y.store` and cannot see the original value `0` any more.
+                // If we read 3 here, we are seeing the result of the `x.swap` above, which was
+                // relaxed but forms a release sequence with the `x.store`. This means there is a
+                // release sequence, so we acquire the `y.store` and cannot see the original value
+                // `0` any more.
                 Some(y.load(Relaxed))
             } else {
                 None
@@ -225,8 +222,32 @@ fn release_sequence() {
         });
 
         t1.join().unwrap();
-        t2.join().unwrap();
-        t3.join().unwrap()
+        t2.join().unwrap()
+    });
+}
+
+/// Ensure that when we read from an outdated release store, we acquire its clock.
+fn old_release_store() {
+    check_all_outcomes([None, Some(1)], || {
+        let x = static_atomic(0);
+        let y = static_atomic(0);
+
+        let t1 = spawn(move || {
+            y.store(1, Relaxed);
+            x.store(1, Release); // this is what we want to read from
+            x.store(3, Relaxed);
+        });
+        let t2 = spawn(move || {
+            if x.load(Acquire) == 1 {
+                // We must have acquired the `y.store` so we cannot see the initial value any more.
+                Some(y.load(Relaxed))
+            } else {
+                None
+            }
+        });
+
+        t1.join().unwrap();
+        t2.join().unwrap()
     });
 }
 
@@ -238,4 +259,5 @@ pub fn main() {
     faa_replaced_by_load();
     release_sequence();
     weaker_release_sequences();
+    old_release_store();
 }

From 2b5b191965571142cff8fab04aad9f243041ca19 Mon Sep 17 00:00:00 2001
From: Johannes Hostert <jhostert@ethz.ch>
Date: Thu, 11 Sep 2025 17:00:59 +0200
Subject: [PATCH 0809/1889] Fix miri issue 4579 by checking if the strong
 protector is actually "active".

Where "active" means that the accessed bit is set.

This also reverts miri PR 3831.
---
 .../src/borrow_tracker/tree_borrows/tree.rs   |  2 ++
 .../zero-sized-protected.stack.stderr         | 15 ---------
 .../zero-sized-protected.tree.stderr          | 32 -------------------
 .../both_borrows/zero-sized-protected.rs      |  7 ++--
 4 files changed, 4 insertions(+), 52 deletions(-)
 delete mode 100644 src/tools/miri/tests/fail/both_borrows/zero-sized-protected.stack.stderr
 delete mode 100644 src/tools/miri/tests/fail/both_borrows/zero-sized-protected.tree.stderr
 rename src/tools/miri/tests/{fail => pass}/both_borrows/zero-sized-protected.rs (53%)

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 1f29bcfc2b035..22bd63bd6b6f4 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/tree.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/tree.rs
@@ -756,6 +756,8 @@ impl<'tcx> Tree {
                             // Don't check for protector if it is a Cell (see `unsafe_cell_deallocate` in `interior_mutability.rs`).
                             // Related to https://github.com/rust-lang/rust/issues/55005.
                             && !perm.permission().is_cell()
+                            // Only trigger UB if the accessed bit is set, i.e. if the protector is actually protecting this offset. See #4579.
+                            && perm.is_accessed()
                         {
                             Err(TransitionError::ProtectedDealloc)
                         } else {
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
deleted file mode 100644
index 3e4a7ccac363d..0000000000000
--- a/src/tools/miri/tests/fail/both_borrows/zero-sized-protected.stack.stderr
+++ /dev/null
@@ -1,15 +0,0 @@
-error: Undefined Behavior: entering unreachable code
-  --> tests/fail/both_borrows/zero-sized-protected.rs:LL:CC
-   |
-LL |     unsafe { std::hint::unreachable_unchecked() };
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
-   |
-   = 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 tests/fail/both_borrows/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
deleted file mode 100644
index 66a7d7794e968..0000000000000
--- a/src/tools/miri/tests/fail/both_borrows/zero-sized-protected.tree.stderr
+++ /dev/null
@@ -1,32 +0,0 @@
-error: Undefined Behavior: deallocation through <TAG> (root of the allocation) at ALLOC[0x0] is forbidden
-  --> tests/fail/both_borrows/zero-sized-protected.rs:LL:CC
-   |
-LL |     unsafe { dealloc(ptr, l) };
-   |              ^^^^^^^^^^^^^^^ Undefined Behavior occurred here
-   |
-   = 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: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/tree-borrows.md for further information
-   = 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
-  --> tests/fail/both_borrows/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
-  --> tests/fail/both_borrows/zero-sized-protected.rs:LL:CC
-   |
-LL | fn test(_x: &mut (), ptr: *mut u8, l: Layout) {
-   |         ^^
-   = note: BACKTRACE (of the first span):
-   = note: inside `test` at tests/fail/both_borrows/zero-sized-protected.rs:LL:CC
-note: inside `main`
-  --> tests/fail/both_borrows/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
-
diff --git a/src/tools/miri/tests/fail/both_borrows/zero-sized-protected.rs b/src/tools/miri/tests/pass/both_borrows/zero-sized-protected.rs
similarity index 53%
rename from src/tools/miri/tests/fail/both_borrows/zero-sized-protected.rs
rename to src/tools/miri/tests/pass/both_borrows/zero-sized-protected.rs
index df9a73a444eda..23d283ff4a19c 100644
--- a/src/tools/miri/tests/fail/both_borrows/zero-sized-protected.rs
+++ b/src/tools/miri/tests/pass/both_borrows/zero-sized-protected.rs
@@ -3,16 +3,13 @@
 use std::alloc::{Layout, alloc, dealloc};
 
 // `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.
+// This should never be UB.
 fn test(_x: &mut (), ptr: *mut u8, l: Layout) {
-    unsafe { dealloc(ptr, l) }; //~[tree] ERROR: /deallocation .* is forbidden/
+    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
 }

From 68217c79b246bceecca23d8d3862af71b97bff0d Mon Sep 17 00:00:00 2001
From: Ifeanyi Orizu <iorizu1811@gmail.com>
Date: Mon, 8 Sep 2025 16:09:59 -0500
Subject: [PATCH 0810/1889] Minor refactoring

---
 .../crates/rust-analyzer/src/flycheck.rs      |   8 +-
 .../src/handlers/notification.rs              | 282 ++++++++++--------
 .../crates/rust-analyzer/src/reload.rs        |  20 +-
 3 files changed, 170 insertions(+), 140 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs
index 01ac75c09aee6..315c45d5b6392 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs
@@ -104,11 +104,11 @@ pub(crate) enum FlycheckConfig {
 }
 
 impl FlycheckConfig {
-    pub(crate) fn invocation_strategy_once(&self) -> bool {
+    pub(crate) fn invocation_strategy(&self) -> InvocationStrategy {
         match self {
-            FlycheckConfig::CargoCommand { .. } => false,
+            FlycheckConfig::CargoCommand { .. } => InvocationStrategy::PerWorkspace,
             FlycheckConfig::CustomCommand { invocation_strategy, .. } => {
-                *invocation_strategy == InvocationStrategy::Once
+                invocation_strategy.clone()
             }
         }
     }
@@ -529,7 +529,7 @@ impl FlycheckActor {
         if let Some(command_handle) = self.command_handle.take() {
             tracing::debug!(
                 command = ?command_handle,
-                "did  cancel flycheck"
+                "did cancel flycheck"
             );
             command_handle.cancel();
             self.command_receiver.take();
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/notification.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/notification.rs
index fb743e73c74a4..68c91a653940b 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/notification.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/notification.rs
@@ -1,9 +1,11 @@
 //! This module is responsible for implementing handlers for Language Server
 //! Protocol. This module specifically handles notifications.
 
-use std::ops::{Deref, Not as _};
+use std::{
+    ops::{Deref, Not as _},
+    panic::UnwindSafe,
+};
 
-use ide_db::base_db::salsa::Cancelled;
 use itertools::Itertools;
 use lsp_types::{
     CancelParams, DidChangeConfigurationParams, DidChangeTextDocumentParams,
@@ -16,7 +18,7 @@ use vfs::{AbsPathBuf, ChangeKind, VfsPath};
 
 use crate::{
     config::{Config, ConfigChange},
-    flycheck::Target,
+    flycheck::{InvocationStrategy, Target},
     global_state::{FetchWorkspaceRequest, GlobalState},
     lsp::{from_proto, utils::apply_document_changes},
     lsp_ext::{self, RunFlycheckParams},
@@ -301,131 +303,165 @@ fn run_flycheck(state: &mut GlobalState, vfs_path: VfsPath) -> bool {
     let file_id = state.vfs.read().0.file_id(&vfs_path);
     if let Some((file_id, vfs::FileExcluded::No)) = file_id {
         let world = state.snapshot();
-        let invocation_strategy_once = state.config.flycheck(None).invocation_strategy_once();
+        let invocation_strategy = state.config.flycheck(None).invocation_strategy();
         let may_flycheck_workspace = state.config.flycheck_workspace(None);
-        let mut workspace_check_triggered = false;
-        let task = move || -> std::result::Result<(), Cancelled> {
-            let saved_file = vfs_path.as_path().map(|p| p.to_owned());
-            if invocation_strategy_once {
-                world.flycheck[0].restart_workspace(saved_file.clone());
-            }
 
-            let target = TargetSpec::for_file(&world, file_id)?.and_then(|it| {
-                let tgt_kind = it.target_kind();
-                let (tgt_name, root, package) = match it {
-                    TargetSpec::Cargo(c) => (c.target, c.workspace_root, c.package),
-                    _ => return None,
-                };
-
-                let tgt = match tgt_kind {
-                    project_model::TargetKind::Bin => Target::Bin(tgt_name),
-                    project_model::TargetKind::Example => Target::Example(tgt_name),
-                    project_model::TargetKind::Test => Target::Test(tgt_name),
-                    project_model::TargetKind::Bench => Target::Benchmark(tgt_name),
-                    _ => return Some((None, root, package)),
-                };
-
-                Some((Some(tgt), root, package))
-            });
-            tracing::debug!(?target, "flycheck target");
-            // we have a specific non-library target, attempt to only check that target, nothing
-            // else will be affected
-            let mut package_workspace_idx = None;
-            if let Some((target, root, package)) = target {
-                // trigger a package check if we have a non-library target as that can't affect
-                // anything else in the workspace OR if we're not allowed to check the workspace as
-                // the user opted into package checks then
-                let package_check_allowed = target.is_some() || !may_flycheck_workspace;
-                if package_check_allowed {
-                    let workspace = world.workspaces.iter().position(|ws| match &ws.kind {
-                        project_model::ProjectWorkspaceKind::Cargo { cargo, .. }
-                        | project_model::ProjectWorkspaceKind::DetachedFile {
-                            cargo: Some((cargo, _, _)),
-                            ..
-                        } => *cargo.workspace_root() == root,
-                        _ => false,
-                    });
-                    if let Some(idx) = workspace {
-                        package_workspace_idx = Some(idx);
-                        world.flycheck[idx].restart_for_package(package, target);
-                    }
+        let task: Box<dyn FnOnce() -> ide::Cancellable<()> + Send + UnwindSafe> =
+            match invocation_strategy {
+                InvocationStrategy::Once => {
+                    Box::new(move || {
+                        // FIXME: Because triomphe::Arc's auto UnwindSafe impl requires that the inner type
+                        // be UnwindSafe, and FlycheckHandle is not UnwindSafe, `word.flycheck` cannot
+                        // be captured directly. std::sync::Arc has an UnwindSafe impl that only requires
+                        // that the inner type be RefUnwindSafe, so if we were using that one we wouldn't
+                        // have this problem. Remove the line below when triomphe::Arc has an UnwindSafe impl
+                        // like std::sync::Arc's.
+                        let world = world;
+                        stdx::always!(
+                            world.flycheck.len() == 1,
+                            "should have exactly one flycheck handle when invocation strategy is once"
+                        );
+                        let saved_file = vfs_path.as_path().map(ToOwned::to_owned);
+                        world.flycheck[0].restart_workspace(saved_file);
+                        Ok(())
+                    })
                 }
-            }
-
-            if !may_flycheck_workspace {
-                return Ok(());
-            }
-
-            // Trigger flychecks for all workspaces that depend on the saved file
-            // Crates containing or depending on the saved file
-            let crate_ids = world
-                .analysis
-                .crates_for(file_id)?
-                .into_iter()
-                .flat_map(|id| world.analysis.transitive_rev_deps(id))
-                .flatten()
-                .unique()
-                .collect::<Vec<_>>();
-            tracing::debug!(?crate_ids, "flycheck crate ids");
-            let crate_root_paths: Vec<_> = crate_ids
-                .iter()
-                .filter_map(|&crate_id| {
-                    world
-                        .analysis
-                        .crate_root(crate_id)
-                        .map(|file_id| {
-                            world.file_id_to_file_path(file_id).as_path().map(ToOwned::to_owned)
-                        })
-                        .transpose()
-                })
-                .collect::<ide::Cancellable<_>>()?;
-            let crate_root_paths: Vec<_> = crate_root_paths.iter().map(Deref::deref).collect();
-            tracing::debug!(?crate_root_paths, "flycheck crate roots");
-
-            // Find all workspaces that have at least one target containing the saved file
-            let workspace_ids = world
-                .workspaces
-                .iter()
-                .enumerate()
-                .filter(|&(idx, _)| match package_workspace_idx {
-                    Some(pkg_idx) => idx != pkg_idx,
-                    None => true,
-                })
-                .filter(|&(_, ws)| match &ws.kind {
-                    project_model::ProjectWorkspaceKind::Cargo { cargo, .. }
-                    | project_model::ProjectWorkspaceKind::DetachedFile {
-                        cargo: Some((cargo, _, _)),
-                        ..
-                    } => cargo.packages().any(|pkg| {
-                        cargo[pkg]
-                            .targets
+                InvocationStrategy::PerWorkspace => {
+                    Box::new(move || {
+                        let target = TargetSpec::for_file(&world, file_id)?.and_then(|it| {
+                            let tgt_kind = it.target_kind();
+                            let (tgt_name, root, package) = match it {
+                                TargetSpec::Cargo(c) => (c.target, c.workspace_root, c.package),
+                                _ => return None,
+                            };
+
+                            let tgt = match tgt_kind {
+                                project_model::TargetKind::Bin => Target::Bin(tgt_name),
+                                project_model::TargetKind::Example => Target::Example(tgt_name),
+                                project_model::TargetKind::Test => Target::Test(tgt_name),
+                                project_model::TargetKind::Bench => Target::Benchmark(tgt_name),
+                                _ => return Some((None, root, package)),
+                            };
+
+                            Some((Some(tgt), root, package))
+                        });
+                        tracing::debug!(?target, "flycheck target");
+                        // we have a specific non-library target, attempt to only check that target, nothing
+                        // else will be affected
+                        let mut package_workspace_idx = None;
+                        if let Some((target, root, package)) = target {
+                            // trigger a package check if we have a non-library target as that can't affect
+                            // anything else in the workspace OR if we're not allowed to check the workspace as
+                            // the user opted into package checks then
+                            let package_check_allowed = target.is_some() || !may_flycheck_workspace;
+                            if package_check_allowed {
+                                package_workspace_idx =
+                                    world.workspaces.iter().position(|ws| match &ws.kind {
+                                        project_model::ProjectWorkspaceKind::Cargo {
+                                            cargo,
+                                            ..
+                                        }
+                                        | project_model::ProjectWorkspaceKind::DetachedFile {
+                                            cargo: Some((cargo, _, _)),
+                                            ..
+                                        } => *cargo.workspace_root() == root,
+                                        _ => false,
+                                    });
+                                if let Some(idx) = package_workspace_idx {
+                                    world.flycheck[idx].restart_for_package(package, target);
+                                }
+                            }
+                        }
+
+                        if !may_flycheck_workspace {
+                            return Ok(());
+                        }
+
+                        // Trigger flychecks for all workspaces that depend on the saved file
+                        // Crates containing or depending on the saved file
+                        let crate_ids: Vec<_> = world
+                            .analysis
+                            .crates_for(file_id)?
+                            .into_iter()
+                            .flat_map(|id| world.analysis.transitive_rev_deps(id))
+                            .flatten()
+                            .unique()
+                            .collect();
+                        tracing::debug!(?crate_ids, "flycheck crate ids");
+                        let crate_root_paths: Vec<_> = crate_ids
                             .iter()
-                            .any(|&it| crate_root_paths.contains(&cargo[it].root.as_path()))
-                    }),
-                    project_model::ProjectWorkspaceKind::Json(project) => project
-                        .crates()
-                        .any(|(_, krate)| crate_root_paths.contains(&krate.root_module.as_path())),
-                    project_model::ProjectWorkspaceKind::DetachedFile { .. } => false,
-                });
-
-            // Find and trigger corresponding flychecks
-            'flychecks: for flycheck in world.flycheck.iter() {
-                for (id, _) in workspace_ids.clone() {
-                    if id == flycheck.id() {
-                        workspace_check_triggered = true;
-                        flycheck.restart_workspace(saved_file.clone());
-                        continue 'flychecks;
-                    }
-                }
-            }
-            // No specific flycheck was triggered, so let's trigger all of them.
-            if !workspace_check_triggered && package_workspace_idx.is_none() {
-                for flycheck in world.flycheck.iter() {
-                    flycheck.restart_workspace(saved_file.clone());
+                            .filter_map(|&crate_id| {
+                                world
+                                    .analysis
+                                    .crate_root(crate_id)
+                                    .map(|file_id| {
+                                        world
+                                            .file_id_to_file_path(file_id)
+                                            .as_path()
+                                            .map(ToOwned::to_owned)
+                                    })
+                                    .transpose()
+                            })
+                            .collect::<ide::Cancellable<_>>()?;
+                        let crate_root_paths: Vec<_> =
+                            crate_root_paths.iter().map(Deref::deref).collect();
+                        tracing::debug!(?crate_root_paths, "flycheck crate roots");
+
+                        // Find all workspaces that have at least one target containing the saved file
+                        let workspace_ids =
+                            world.workspaces.iter().enumerate().filter(|&(idx, ws)| {
+                                let ws_contains_file = match &ws.kind {
+                                    project_model::ProjectWorkspaceKind::Cargo {
+                                        cargo, ..
+                                    }
+                                    | project_model::ProjectWorkspaceKind::DetachedFile {
+                                        cargo: Some((cargo, _, _)),
+                                        ..
+                                    } => cargo.packages().any(|pkg| {
+                                        cargo[pkg].targets.iter().any(|&it| {
+                                            crate_root_paths.contains(&cargo[it].root.as_path())
+                                        })
+                                    }),
+                                    project_model::ProjectWorkspaceKind::Json(project) => {
+                                        project.crates().any(|(_, krate)| {
+                                            crate_root_paths.contains(&krate.root_module.as_path())
+                                        })
+                                    }
+                                    project_model::ProjectWorkspaceKind::DetachedFile {
+                                        ..
+                                    } => false,
+                                };
+                                let is_pkg_ws = match package_workspace_idx {
+                                    Some(pkg_idx) => pkg_idx == idx,
+                                    None => false,
+                                };
+                                ws_contains_file && !is_pkg_ws
+                            });
+
+                        let saved_file = vfs_path.as_path().map(ToOwned::to_owned);
+                        let mut workspace_check_triggered = false;
+                        // Find and trigger corresponding flychecks
+                        'flychecks: for flycheck in world.flycheck.iter() {
+                            for (id, _) in workspace_ids.clone() {
+                                if id == flycheck.id() {
+                                    workspace_check_triggered = true;
+                                    flycheck.restart_workspace(saved_file.clone());
+                                    continue 'flychecks;
+                                }
+                            }
+                        }
+
+                        // No specific flycheck was triggered, so let's trigger all of them.
+                        if !workspace_check_triggered && package_workspace_idx.is_none() {
+                            for flycheck in world.flycheck.iter() {
+                                flycheck.restart_workspace(saved_file.clone());
+                            }
+                        }
+                        Ok(())
+                    })
                 }
-            }
-            Ok(())
-        };
+            };
+
         state.task_pool.handle.spawn_with_sender(stdx::thread::ThreadIntent::Worker, move |_| {
             if let Err(e) = std::panic::catch_unwind(task) {
                 tracing::error!("flycheck task panicked: {e:?}")
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/reload.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/reload.rs
index a8a54930c6e5e..27738fee51407 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/reload.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/reload.rs
@@ -318,7 +318,7 @@ impl GlobalState {
                     }
                 }
 
-                let mut workspaces = linked_projects
+                let mut workspaces: Vec<_> = linked_projects
                     .iter()
                     .map(|project| match project {
                         LinkedProject::ProjectManifest(manifest) => {
@@ -339,7 +339,7 @@ impl GlobalState {
                             Ok(workspace)
                         }
                     })
-                    .collect::<Vec<_>>();
+                    .collect();
 
                 let mut i = 0;
                 while i < workspaces.len() {
@@ -848,23 +848,17 @@ impl GlobalState {
     fn reload_flycheck(&mut self) {
         let _p = tracing::info_span!("GlobalState::reload_flycheck").entered();
         let config = self.config.flycheck(None);
-        let sender = self.flycheck_sender.clone();
-        let invocation_strategy = match config {
-            FlycheckConfig::CargoCommand { .. } => {
-                crate::flycheck::InvocationStrategy::PerWorkspace
-            }
-            FlycheckConfig::CustomCommand { ref invocation_strategy, .. } => {
-                invocation_strategy.clone()
-            }
-        };
-        let next_gen = self.flycheck.iter().map(|f| f.generation() + 1).max().unwrap_or_default();
+        let sender = &self.flycheck_sender;
+        let invocation_strategy = config.invocation_strategy();
+        let next_gen =
+            self.flycheck.iter().map(FlycheckHandle::generation).max().unwrap_or_default() + 1;
 
         self.flycheck = match invocation_strategy {
             crate::flycheck::InvocationStrategy::Once => {
                 vec![FlycheckHandle::spawn(
                     0,
                     next_gen,
-                    sender,
+                    sender.clone(),
                     config,
                     None,
                     self.config.root_path().clone(),

From bfd5a264c7e02ee831aab919c272539cf9395a1d Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 11 Sep 2025 18:05:07 +0200
Subject: [PATCH 0811/1889] Correctly handle literal search on paths

---
 src/librustdoc/html/static/js/search.js | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/librustdoc/html/static/js/search.js b/src/librustdoc/html/static/js/search.js
index b01b596da682e..3b84ae2bed060 100644
--- a/src/librustdoc/html/static/js/search.js
+++ b/src/librustdoc/html/static/js/search.js
@@ -3639,7 +3639,7 @@ class DocSearch {
             if (contains.length === 0) {
                 return 0;
             }
-            const maxPathEditDistance = Math.floor(
+            const maxPathEditDistance = parsedQuery.literalSearch ? 0 : Math.floor(
                 contains.reduce((acc, next) => acc + next.length, 0) / 3,
             );
             let ret_dist = maxPathEditDistance + 1;
@@ -3650,7 +3650,9 @@ class DocSearch {
                 let dist_total = 0;
                 for (let x = 0; x < clength; ++x) {
                     const [p, c] = [path[i + x], contains[x]];
-                    if (Math.floor((p.length - c.length) / 3) <= maxPathEditDistance &&
+                    if (parsedQuery.literalSearch && p !== c) {
+                        continue pathiter;
+                    } else if (Math.floor((p.length - c.length) / 3) <= maxPathEditDistance &&
                         p.indexOf(c) !== -1
                     ) {
                         // discount distance on substring match

From 04a1dd1c175cb0fc18419e0261f99bf35199ab59 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 11 Sep 2025 18:05:21 +0200
Subject: [PATCH 0812/1889] Add regression test for literal search on paths

---
 tests/rustdoc-js/literal-path.js | 23 +++++++++++++++++++++++
 tests/rustdoc-js/literal-path.rs |  7 +++++++
 2 files changed, 30 insertions(+)
 create mode 100644 tests/rustdoc-js/literal-path.js
 create mode 100644 tests/rustdoc-js/literal-path.rs

diff --git a/tests/rustdoc-js/literal-path.js b/tests/rustdoc-js/literal-path.js
new file mode 100644
index 0000000000000..ea999ea1a6f0a
--- /dev/null
+++ b/tests/rustdoc-js/literal-path.js
@@ -0,0 +1,23 @@
+// exact-check
+
+// This test ensures that literal search is always applied on elements of the path.
+
+const EXPECTED = [
+    {
+        'query': '"some::path"',
+        'others': [
+            { 'path': 'literal_path::some', 'name': 'Path' },
+        ],
+    },
+    {
+        'query': '"somea::path"',
+        'others': [
+            { 'path': 'literal_path::somea', 'name': 'Path' },
+        ],
+    },
+    {
+        'query': '"soma::path"',
+        'others': [
+        ],
+    },
+];
diff --git a/tests/rustdoc-js/literal-path.rs b/tests/rustdoc-js/literal-path.rs
new file mode 100644
index 0000000000000..fa7685fd966a1
--- /dev/null
+++ b/tests/rustdoc-js/literal-path.rs
@@ -0,0 +1,7 @@
+pub mod some {
+    pub struct Path;
+}
+
+pub mod somea {
+    pub struct Path;
+}

From 18d0dcbc8e61a0c9f7ffead9245b273fd26467a5 Mon Sep 17 00:00:00 2001
From: Connor Tsui <connor.tsui20@gmail.com>
Date: Thu, 11 Sep 2025 11:29:19 -0400
Subject: [PATCH 0813/1889] fix config for poison macro test

Signed-off-by: Connor Tsui <connor.tsui20@gmail.com>
---
 library/std/tests/sync/condvar.rs | 18 +++++++++---------
 library/std/tests/sync/lib.rs     |  3 +++
 library/std/tests/sync/mutex.rs   |  4 ++--
 library/std/tests/sync/rwlock.rs  |  8 ++++----
 4 files changed, 18 insertions(+), 15 deletions(-)

diff --git a/library/std/tests/sync/condvar.rs b/library/std/tests/sync/condvar.rs
index 1d712a643003a..1b1c33efad58e 100644
--- a/library/std/tests/sync/condvar.rs
+++ b/library/std/tests/sync/condvar.rs
@@ -17,7 +17,7 @@ nonpoison_and_poison_unwrap_test!(
     }
 );
 
-#[cfg_attr(any(target_os = "emscripten", target_os = "wasi"), ignore)] // no threads
+#[cfg(not(any(target_os = "emscripten", target_os = "wasi")))] // No threads.
 nonpoison_and_poison_unwrap_test!(
     name: notify_one,
     test_body: {
@@ -38,7 +38,7 @@ nonpoison_and_poison_unwrap_test!(
     }
 );
 
-#[cfg_attr(any(target_os = "emscripten", target_os = "wasi"), ignore)] // no threads
+#[cfg(not(any(target_os = "emscripten", target_os = "wasi")))] // No threads.
 nonpoison_and_poison_unwrap_test!(
     name: notify_all,
     test_body: {
@@ -79,7 +79,7 @@ nonpoison_and_poison_unwrap_test!(
     }
 );
 
-#[cfg_attr(any(target_os = "emscripten", target_os = "wasi"), ignore)] // no threads
+#[cfg(not(any(target_os = "emscripten", target_os = "wasi")))] // No threads.
 nonpoison_and_poison_unwrap_test!(
     name: test_mutex_arc_condvar,
     test_body: {
@@ -116,7 +116,7 @@ nonpoison_and_poison_unwrap_test!(
     }
 );
 
-#[cfg_attr(any(target_os = "emscripten", target_os = "wasi"), ignore)] // no threads
+#[cfg(not(any(target_os = "emscripten", target_os = "wasi")))] // No threads.
 nonpoison_and_poison_unwrap_test!(
     name: wait_while,
     test_body: {
@@ -141,7 +141,7 @@ nonpoison_and_poison_unwrap_test!(
     }
 );
 
-#[cfg_attr(any(target_os = "emscripten", target_os = "wasi"), ignore)] // no threads
+#[cfg(not(any(target_os = "emscripten", target_os = "wasi")))] // No threads.
 nonpoison_and_poison_unwrap_test!(
     name: wait_timeout_wait,
     test_body: {
@@ -164,7 +164,7 @@ nonpoison_and_poison_unwrap_test!(
     }
 );
 
-#[cfg_attr(any(target_os = "emscripten", target_os = "wasi"), ignore)] // no threads
+#[cfg(not(any(target_os = "emscripten", target_os = "wasi")))] // No threads.
 nonpoison_and_poison_unwrap_test!(
     name: wait_timeout_while_wait,
     test_body: {
@@ -180,7 +180,7 @@ nonpoison_and_poison_unwrap_test!(
     }
 );
 
-#[cfg_attr(any(target_os = "emscripten", target_os = "wasi"), ignore)] // no threads
+#[cfg(not(any(target_os = "emscripten", target_os = "wasi")))] // No threads.
 nonpoison_and_poison_unwrap_test!(
     name: wait_timeout_while_instant_satisfy,
     test_body: {
@@ -197,7 +197,7 @@ nonpoison_and_poison_unwrap_test!(
     }
 );
 
-#[cfg_attr(any(target_os = "emscripten", target_os = "wasi"), ignore)] // no threads
+#[cfg(not(any(target_os = "emscripten", target_os = "wasi")))] // No threads.
 nonpoison_and_poison_unwrap_test!(
     name: wait_timeout_while_wake,
     test_body: {
@@ -226,7 +226,7 @@ nonpoison_and_poison_unwrap_test!(
     }
 );
 
-#[cfg_attr(any(target_os = "emscripten", target_os = "wasi"), ignore)] // no threads
+#[cfg(not(any(target_os = "emscripten", target_os = "wasi")))] // No threads.
 nonpoison_and_poison_unwrap_test!(
     name: wait_timeout_wake,
     test_body: {
diff --git a/library/std/tests/sync/lib.rs b/library/std/tests/sync/lib.rs
index ac1dbebcc5cb0..6d25aa2cf3db5 100644
--- a/library/std/tests/sync/lib.rs
+++ b/library/std/tests/sync/lib.rs
@@ -58,6 +58,9 @@ fn result_unwrap<T, E: std::fmt::Debug>(x: Result<T, E>) -> T {
 /// a no-op (the identity function).
 ///
 /// The test names will be prefiex with `poison_` or `nonpoison_`.
+///
+/// Important: `cfg_attr()` will not apply attributes to both tests.
+/// See <https://github.com/rust-lang/rust/pull/146433> for more information.
 macro_rules! nonpoison_and_poison_unwrap_test {
     (
         name: $name:ident,
diff --git a/library/std/tests/sync/mutex.rs b/library/std/tests/sync/mutex.rs
index 612c75c7aef51..2445764001b8b 100644
--- a/library/std/tests/sync/mutex.rs
+++ b/library/std/tests/sync/mutex.rs
@@ -266,7 +266,7 @@ nonpoison_and_poison_unwrap_test!(
     }
 );
 
-#[cfg_attr(not(panic = "unwind"), ignore = "test requires unwinding support")]
+#[cfg(panic = "unwind")] // Requires unwinding support.
 nonpoison_and_poison_unwrap_test!(
     name: test_panics,
     test_body: {
@@ -297,7 +297,7 @@ nonpoison_and_poison_unwrap_test!(
     }
 );
 
-#[cfg_attr(not(panic = "unwind"), ignore = "test requires unwinding support")]
+#[cfg(panic = "unwind")] // Requires unwinding support.
 nonpoison_and_poison_unwrap_test!(
     name: test_mutex_arc_access_in_unwind,
     test_body: {
diff --git a/library/std/tests/sync/rwlock.rs b/library/std/tests/sync/rwlock.rs
index eca15d2a4adb8..65d8bac719456 100644
--- a/library/std/tests/sync/rwlock.rs
+++ b/library/std/tests/sync/rwlock.rs
@@ -50,7 +50,7 @@ nonpoison_and_poison_unwrap_test!(
 // FIXME: On macOS we use a provenance-incorrect implementation and Miri
 // catches that issue with a chance of around 1/1000.
 // See <https://github.com/rust-lang/rust/issues/121950> for details.
-#[cfg_attr(all(miri, target_os = "macos"), ignore)]
+#[cfg(not(all(miri, target_os = "macos")))]
 nonpoison_and_poison_unwrap_test!(
     name: frob,
     test_body: {
@@ -124,7 +124,7 @@ nonpoison_and_poison_unwrap_test!(
     }
 );
 
-#[cfg_attr(not(panic = "unwind"), ignore = "test requires unwinding support")]
+#[cfg(panic = "unwind")] // Requires unwinding support.
 nonpoison_and_poison_unwrap_test!(
     name: test_rw_arc_access_in_unwind,
     test_body: {
@@ -315,7 +315,7 @@ nonpoison_and_poison_unwrap_test!(
 
 // FIXME: On macOS we use a provenance-incorrect implementation and Miri catches that issue.
 // See <https://github.com/rust-lang/rust/issues/121950> for details.
-#[cfg_attr(all(miri, target_os = "macos"), ignore)]
+#[cfg(not(all(miri, target_os = "macos")))]
 nonpoison_and_poison_unwrap_test!(
     name: test_downgrade_observe,
     test_body: {
@@ -362,7 +362,7 @@ nonpoison_and_poison_unwrap_test!(
 
 // FIXME: On macOS we use a provenance-incorrect implementation and Miri catches that issue.
 // See <https://github.com/rust-lang/rust/issues/121950> for details.
-#[cfg_attr(all(miri, target_os = "macos"), ignore)]
+#[cfg(not(all(miri, target_os = "macos")))]
 nonpoison_and_poison_unwrap_test!(
     name: test_downgrade_atomic,
     test_body: {

From 256aa0d9414f52664dd6e9e97d90fe485a203630 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Thu, 11 Sep 2025 18:35:15 +0200
Subject: [PATCH 0814/1889] Fix `libgccjit` symlink when we build GCC locally

---
 src/bootstrap/src/core/build_steps/gcc.rs | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/src/bootstrap/src/core/build_steps/gcc.rs b/src/bootstrap/src/core/build_steps/gcc.rs
index 77c9622a9bf0d..717dea37e9e61 100644
--- a/src/bootstrap/src/core/build_steps/gcc.rs
+++ b/src/bootstrap/src/core/build_steps/gcc.rs
@@ -32,6 +32,10 @@ pub struct GccOutput {
 impl GccOutput {
     /// Install the required libgccjit library file(s) to the specified `path`.
     pub fn install_to(&self, builder: &Builder<'_>, directory: &Path) {
+        if builder.config.dry_run() {
+            return;
+        }
+
         // At build time, cg_gcc has to link to libgccjit.so (the unversioned symbol).
         // However, at runtime, it will by default look for libgccjit.so.0.
         // So when we install the built libgccjit.so file to the target `directory`, we add it there
@@ -39,8 +43,16 @@ impl GccOutput {
         let mut target_filename = self.libgccjit.file_name().unwrap().to_str().unwrap().to_string();
         target_filename.push_str(".0");
 
+        // If we build libgccjit ourselves, then `self.libgccjit` can actually be a symlink.
+        // In that case, we have to resolve it first, otherwise we'd create a symlink to a symlink,
+        // which wouldn't work.
+        let actual_libgccjit_path = t!(
+            self.libgccjit.canonicalize(),
+            format!("Cannot find libgccjit at {}", self.libgccjit.display())
+        );
+
         let dst = directory.join(target_filename);
-        builder.copy_link(&self.libgccjit, &dst, FileType::NativeLibrary);
+        builder.copy_link(&actual_libgccjit_path, &dst, FileType::NativeLibrary);
     }
 }
 

From 6354c51d2b6ddf61e791b1b89f395e2350f88817 Mon Sep 17 00:00:00 2001
From: Connor Tsui <87130162+connortsui20@users.noreply.github.com>
Date: Thu, 11 Sep 2025 13:08:44 -0400
Subject: [PATCH 0815/1889] update doc comment

Co-authored-by: Ralf Jung <post@ralfj.de>
---
 library/std/tests/sync/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/std/tests/sync/lib.rs b/library/std/tests/sync/lib.rs
index 6d25aa2cf3db5..23112e102844f 100644
--- a/library/std/tests/sync/lib.rs
+++ b/library/std/tests/sync/lib.rs
@@ -59,7 +59,7 @@ fn result_unwrap<T, E: std::fmt::Debug>(x: Result<T, E>) -> T {
 ///
 /// The test names will be prefiex with `poison_` or `nonpoison_`.
 ///
-/// Important: `cfg_attr()` will not apply attributes to both tests.
+/// Important: most attributes (except `cfg`) will not work properly! (They are only applied to the first test.)
 /// See <https://github.com/rust-lang/rust/pull/146433> for more information.
 macro_rules! nonpoison_and_poison_unwrap_test {
     (

From 16b34c6f7056701bbe66892e2d5300d80eae0830 Mon Sep 17 00:00:00 2001
From: Johannes Hostert <jhostert@ethz.ch>
Date: Thu, 11 Sep 2025 19:15:50 +0200
Subject: [PATCH 0816/1889] move zero-sized protector dealloc test

---
 .../pass/both_borrows/basic_aliasing_model.rs     | 10 ++++++++++
 .../pass/both_borrows/zero-sized-protected.rs     | 15 ---------------
 2 files changed, 10 insertions(+), 15 deletions(-)
 delete mode 100644 src/tools/miri/tests/pass/both_borrows/zero-sized-protected.rs

diff --git a/src/tools/miri/tests/pass/both_borrows/basic_aliasing_model.rs b/src/tools/miri/tests/pass/both_borrows/basic_aliasing_model.rs
index 82976326a8df3..115e232dde4c2 100644
--- a/src/tools/miri/tests/pass/both_borrows/basic_aliasing_model.rs
+++ b/src/tools/miri/tests/pass/both_borrows/basic_aliasing_model.rs
@@ -1,6 +1,7 @@
 //@revisions: stack tree
 //@[tree]compile-flags: -Zmiri-tree-borrows
 #![feature(allocator_api)]
+use std::alloc::{Layout, alloc, dealloc};
 use std::cell::Cell;
 use std::ptr;
 
@@ -305,5 +306,14 @@ fn zst() {
         let ptr = &raw mut *b as *mut ();
         drop(b);
         let _ref = &mut *ptr;
+
+        // zero-sized protectors do not affect deallocation
+        fn with_protector(_x: &mut (), ptr: *mut u8, l: Layout) {
+            // `_x` here is strongly protected but covers zero bytes.
+            unsafe { dealloc(ptr, l) };
+        }
+        let l = Layout::from_size_align(1, 1).unwrap();
+        let ptr = alloc(l);
+        with_protector(&mut *ptr.cast::<()>(), ptr, l);
     }
 }
diff --git a/src/tools/miri/tests/pass/both_borrows/zero-sized-protected.rs b/src/tools/miri/tests/pass/both_borrows/zero-sized-protected.rs
deleted file mode 100644
index 23d283ff4a19c..0000000000000
--- a/src/tools/miri/tests/pass/both_borrows/zero-sized-protected.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//@revisions: stack tree
-//@[tree]compile-flags: -Zmiri-tree-borrows
-use std::alloc::{Layout, alloc, dealloc};
-
-// `x` is strongly protected but covers zero bytes.
-// This should never be UB.
-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) };
-}

From 472721b34f73e7a5e6870c9443c35e3ab29958d9 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Thu, 11 Sep 2025 12:47:22 -0500
Subject: [PATCH 0817/1889] bootstrap: rustdoc-js tests can now be filtered by
 js files

---
 src/bootstrap/src/core/build_steps/test.rs | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index 4f839bdf7b83f..723ba80eaf827 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -2086,11 +2086,25 @@ HELP: You can add it into `bootstrap.toml` in `rust.codegen-backends = [{name:?}
         }
 
         // Get paths from cmd args
-        let paths = match &builder.config.cmd {
+        let mut paths = match &builder.config.cmd {
             Subcommand::Test { .. } => &builder.config.paths[..],
             _ => &[],
         };
 
+        // in rustdoc-js mode, allow filters to be rs files or js files.
+        // use a late-initialized Vec to avoid cloning for other modes.
+        let mut paths_v;
+        if mode == "rustdoc-js" {
+            paths_v = paths.to_vec();
+            for p in &mut paths_v {
+                if let Some(ext) = p.extension()
+                    && ext == "js"
+                {
+                    p.set_extension("rs");
+                }
+            }
+            paths = &paths_v;
+        }
         // Get test-args by striping suite path
         let mut test_args: Vec<&str> = paths
             .iter()

From 6e12c54bcddb34b085497bf5ca0a6c02387992f0 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Thu, 11 Sep 2025 20:09:54 +0200
Subject: [PATCH 0818/1889] fix(len_zero): don't eagerly call
 `GenericArgs::type_at`

Results in an ICE if the output type has no generic type params
---
 clippy_lints/src/len_zero.rs  |  6 +++---
 tests/ui/crashes/ice-15657.rs | 11 +++++++++++
 2 files changed, 14 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/crashes/ice-15657.rs

diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index f44a5fdf715e5..28a0fbc051158 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -371,9 +371,9 @@ fn parse_len_output<'tcx>(cx: &LateContext<'tcx>, sig: FnSig<'tcx>) -> Option<Le
 
     match *sig.output().kind() {
         ty::Int(_) | ty::Uint(_) => Some(LenOutput::Integral),
-        ty::Adt(adt, subs) if subs.type_at(0).is_integral() => match cx.tcx.get_diagnostic_name(adt.did()) {
-            Some(sym::Option) => Some(LenOutput::Option(adt.did())),
-            Some(sym::Result) => Some(LenOutput::Result(adt.did())),
+        ty::Adt(adt, subs) => match cx.tcx.get_diagnostic_name(adt.did()) {
+            Some(sym::Option) => subs.type_at(0).is_integral().then(|| LenOutput::Option(adt.did())),
+            Some(sym::Result) => subs.type_at(0).is_integral().then(|| LenOutput::Result(adt.did())),
             _ => None,
         },
         _ => None,
diff --git a/tests/ui/crashes/ice-15657.rs b/tests/ui/crashes/ice-15657.rs
new file mode 100644
index 0000000000000..c6f6506cd8d03
--- /dev/null
+++ b/tests/ui/crashes/ice-15657.rs
@@ -0,0 +1,11 @@
+//@check-pass
+#![warn(clippy::len_zero)]
+
+pub struct S1;
+pub struct S2;
+
+impl S1 {
+    pub fn len(&self) -> S2 {
+        S2
+    }
+}

From 0e5281cea815c5a61ba7e4b8c4dfaaca2c587ca3 Mon Sep 17 00:00:00 2001
From: klensy <klensy@users.noreply.github.com>
Date: Thu, 11 Sep 2025 21:40:25 +0300
Subject: [PATCH 0819/1889] remove unused macro

---
 .../rustc_llvm/llvm-wrapper/PassWrapper.cpp   | 116 ------------------
 1 file changed, 116 deletions(-)

diff --git a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
index 3bb1533c2fe25..d970c4a542271 100644
--- a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
@@ -79,122 +79,6 @@ extern "C" void LLVMRustTimeTraceProfilerFinish(const char *FileName) {
   timeTraceProfilerCleanup();
 }
 
-#ifdef LLVM_COMPONENT_X86
-#define SUBTARGET_X86 SUBTARGET(X86)
-#else
-#define SUBTARGET_X86
-#endif
-
-#ifdef LLVM_COMPONENT_ARM
-#define SUBTARGET_ARM SUBTARGET(ARM)
-#else
-#define SUBTARGET_ARM
-#endif
-
-#ifdef LLVM_COMPONENT_AARCH64
-#define SUBTARGET_AARCH64 SUBTARGET(AArch64)
-#else
-#define SUBTARGET_AARCH64
-#endif
-
-#ifdef LLVM_COMPONENT_AVR
-#define SUBTARGET_AVR SUBTARGET(AVR)
-#else
-#define SUBTARGET_AVR
-#endif
-
-#ifdef LLVM_COMPONENT_M68k
-#define SUBTARGET_M68K SUBTARGET(M68k)
-#else
-#define SUBTARGET_M68K
-#endif
-
-#ifdef LLVM_COMPONENT_CSKY
-#define SUBTARGET_CSKY SUBTARGET(CSKY)
-#else
-#define SUBTARGET_CSKY
-#endif
-
-#ifdef LLVM_COMPONENT_MIPS
-#define SUBTARGET_MIPS SUBTARGET(Mips)
-#else
-#define SUBTARGET_MIPS
-#endif
-
-#ifdef LLVM_COMPONENT_POWERPC
-#define SUBTARGET_PPC SUBTARGET(PPC)
-#else
-#define SUBTARGET_PPC
-#endif
-
-#ifdef LLVM_COMPONENT_SYSTEMZ
-#define SUBTARGET_SYSTEMZ SUBTARGET(SystemZ)
-#else
-#define SUBTARGET_SYSTEMZ
-#endif
-
-#ifdef LLVM_COMPONENT_MSP430
-#define SUBTARGET_MSP430 SUBTARGET(MSP430)
-#else
-#define SUBTARGET_MSP430
-#endif
-
-#ifdef LLVM_COMPONENT_RISCV
-#define SUBTARGET_RISCV SUBTARGET(RISCV)
-#else
-#define SUBTARGET_RISCV
-#endif
-
-#ifdef LLVM_COMPONENT_SPARC
-#define SUBTARGET_SPARC SUBTARGET(Sparc)
-#else
-#define SUBTARGET_SPARC
-#endif
-
-#ifdef LLVM_COMPONENT_XTENSA
-#define SUBTARGET_XTENSA SUBTARGET(XTENSA)
-#else
-#define SUBTARGET_XTENSA
-#endif
-
-#ifdef LLVM_COMPONENT_HEXAGON
-#define SUBTARGET_HEXAGON SUBTARGET(Hexagon)
-#else
-#define SUBTARGET_HEXAGON
-#endif
-
-#ifdef LLVM_COMPONENT_LOONGARCH
-#define SUBTARGET_LOONGARCH SUBTARGET(LoongArch)
-#else
-#define SUBTARGET_LOONGARCH
-#endif
-
-#define GEN_SUBTARGETS                                                         \
-  SUBTARGET_X86                                                                \
-  SUBTARGET_ARM                                                                \
-  SUBTARGET_AARCH64                                                            \
-  SUBTARGET_AVR                                                                \
-  SUBTARGET_M68K                                                               \
-  SUBTARGET_CSKY                                                               \
-  SUBTARGET_MIPS                                                               \
-  SUBTARGET_PPC                                                                \
-  SUBTARGET_SYSTEMZ                                                            \
-  SUBTARGET_MSP430                                                             \
-  SUBTARGET_SPARC                                                              \
-  SUBTARGET_HEXAGON                                                            \
-  SUBTARGET_XTENSA                                                             \
-  SUBTARGET_RISCV                                                              \
-  SUBTARGET_LOONGARCH
-
-#define SUBTARGET(x)                                                           \
-  namespace llvm {                                                             \
-  extern const SubtargetFeatureKV x##FeatureKV[];                              \
-  extern const SubtargetFeatureKV x##SubTypeKV[];                              \
-  }
-
-GEN_SUBTARGETS
-#undef SUBTARGET
-
 // This struct and various functions are sort of a hack right now, but the
 // problem is that we've got in-memory LLVM modules after we generate and
 // optimize all codegen-units for one compilation in rustc. To be compatible

From acb35038ff21f7f41866b8ea36fed72d9fbc6640 Mon Sep 17 00:00:00 2001
From: klensy <klensy@users.noreply.github.com>
Date: Thu, 11 Sep 2025 21:43:18 +0300
Subject: [PATCH 0820/1889] remove unused getLongestEntryLength

---
 compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
index d970c4a542271..91d11ba317a61 100644
--- a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
@@ -224,14 +224,6 @@ static FloatABI::ABIType fromRust(LLVMRustFloatABI RustFloatAbi) {
   report_fatal_error("Bad FloatABI.");
 }
 
-/// getLongestEntryLength - Return the length of the longest entry in the table.
-template <typename KV> static size_t getLongestEntryLength(ArrayRef<KV> Table) {
-  size_t MaxLen = 0;
-  for (auto &I : Table)
-    MaxLen = std::max(MaxLen, std::strlen(I.Key));
-  return MaxLen;
-}
-
 extern "C" void LLVMRustPrintTargetCPUs(LLVMTargetMachineRef TM,
                                         RustStringRef OutStr) {
   ArrayRef<SubtargetSubTypeKV> CPUTable =

From bb31725e679c48e75e54c8ec88c7e654c5509d37 Mon Sep 17 00:00:00 2001
From: sayantn <sayantn05@gmail.com>
Date: Fri, 12 Sep 2025 01:20:34 +0530
Subject: [PATCH 0821/1889] Remove big-endian swizzles from `vreinterpret`

---
 .../core_arch/src/aarch64/neon/generated.rs   |   971 +-
 .../src/arm_shared/neon/generated.rs          | 10279 ++--------------
 .../spec/neon/aarch64.spec.yml                |     2 +
 .../spec/neon/arm_shared.spec.yml             |     4 +
 4 files changed, 988 insertions(+), 10268 deletions(-)

diff --git a/library/stdarch/crates/core_arch/src/aarch64/neon/generated.rs b/library/stdarch/crates/core_arch/src/aarch64/neon/generated.rs
index 554a809db8db2..855261aaecfd0 100644
--- a/library/stdarch/crates/core_arch/src/aarch64/neon/generated.rs
+++ b/library/stdarch/crates/core_arch/src/aarch64/neon/generated.rs
@@ -21477,172 +21477,73 @@ pub fn vrecpxh_f16(a: f16) -> f16 {
 #[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_f16)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_f64_f16(a: float16x4_t) -> float64x1_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_f16)"]
-#[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vreinterpret_f64_f16(a: float16x4_t) -> float64x1_t {
-    let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_f16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_f64_f16(a: float16x8_t) -> float64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_f16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vreinterpretq_f64_f16(a: float16x8_t) -> float64x2_t {
-    let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_f64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_f16_f64(a: float64x1_t) -> float16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_f64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vreinterpret_f16_f64(a: float64x1_t) -> float16x4_t {
-    unsafe {
-        let ret_val: float16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_f64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_f16_f64(a: float64x2_t) -> float16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_f64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vreinterpretq_f16_f64(a: float64x2_t) -> float16x8_t {
-    let a: float64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: float16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_p128)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_f64_p128(a: p128) -> float64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_p128)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vreinterpretq_f64_p128(a: p128) -> float64x2_t {
-    unsafe {
-        let ret_val: float64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_f32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_f64_f32(a: float32x2_t) -> float64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_f32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vreinterpret_f64_f32(a: float32x2_t) -> float64x1_t {
-    let a: float32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_f32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_p64_f32(a: float32x2_t) -> poly64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_f32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vreinterpret_p64_f32(a: float32x2_t) -> poly64x1_t {
-    let a: float32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_f32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
@@ -21650,23 +21551,8 @@ pub fn vreinterpretq_f64_f32(a: float32x4_t) -> float64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_f32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_f64_f32(a: float32x4_t) -> float64x2_t {
-    let a: float32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_f32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
@@ -21674,23 +21560,8 @@ pub fn vreinterpretq_p64_f32(a: float32x4_t) -> poly64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_f32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_p64_f32(a: float32x4_t) -> poly64x2_t {
-    let a: float32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_f64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
@@ -21698,22 +21569,8 @@ pub fn vreinterpret_f32_f64(a: float64x1_t) -> float32x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_f64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_f32_f64(a: float64x1_t) -> float32x2_t {
-    unsafe {
-        let ret_val: float32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_f64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
@@ -21721,22 +21578,8 @@ pub fn vreinterpret_s8_f64(a: float64x1_t) -> int8x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_f64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_s8_f64(a: float64x1_t) -> int8x8_t {
-    unsafe {
-        let ret_val: int8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_f64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
@@ -21744,22 +21587,8 @@ pub fn vreinterpret_s16_f64(a: float64x1_t) -> int16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_f64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_s16_f64(a: float64x1_t) -> int16x4_t {
-    unsafe {
-        let ret_val: int16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_f64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
@@ -21767,19 +21596,6 @@ pub fn vreinterpret_s32_f64(a: float64x1_t) -> int32x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_f64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_s32_f64(a: float64x1_t) -> int32x2_t {
-    unsafe {
-        let ret_val: int32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_f64)"]
 #[inline]
 #[target_feature(enable = "neon")]
@@ -21791,7 +21607,6 @@ pub fn vreinterpret_s64_f64(a: float64x1_t) -> int64x1_t {
 #[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_f64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
@@ -21799,22 +21614,8 @@ pub fn vreinterpret_u8_f64(a: float64x1_t) -> uint8x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_f64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_u8_f64(a: float64x1_t) -> uint8x8_t {
-    unsafe {
-        let ret_val: uint8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_f64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
@@ -21822,22 +21623,8 @@ pub fn vreinterpret_u16_f64(a: float64x1_t) -> uint16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_f64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_u16_f64(a: float64x1_t) -> uint16x4_t {
-    unsafe {
-        let ret_val: uint16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_f64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
@@ -21845,19 +21632,6 @@ pub fn vreinterpret_u32_f64(a: float64x1_t) -> uint32x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_f64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_u32_f64(a: float64x1_t) -> uint32x2_t {
-    unsafe {
-        let ret_val: uint32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_f64)"]
 #[inline]
 #[target_feature(enable = "neon")]
@@ -21869,7 +21643,6 @@ pub fn vreinterpret_u64_f64(a: float64x1_t) -> uint64x1_t {
 #[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_f64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
@@ -21877,22 +21650,8 @@ pub fn vreinterpret_p8_f64(a: float64x1_t) -> poly8x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_f64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_p8_f64(a: float64x1_t) -> poly8x8_t {
-    unsafe {
-        let ret_val: poly8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_f64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
@@ -21900,19 +21659,6 @@ pub fn vreinterpret_p16_f64(a: float64x1_t) -> poly16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_f64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_p16_f64(a: float64x1_t) -> poly16x4_t {
-    unsafe {
-        let ret_val: poly16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_f64)"]
 #[inline]
 #[target_feature(enable = "neon")]
@@ -21924,7 +21670,6 @@ pub fn vreinterpret_p64_f64(a: float64x1_t) -> poly64x1_t {
 #[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_f64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
@@ -21932,96 +21677,35 @@ pub fn vreinterpretq_p128_f64(a: float64x2_t) -> p128 {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_f64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_f64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_p128_f64(a: float64x2_t) -> p128 {
-    let a: float64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
+pub fn vreinterpretq_f32_f64(a: float64x2_t) -> float32x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_f64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_f64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_f32_f64(a: float64x2_t) -> float32x4_t {
+pub fn vreinterpretq_s8_f64(a: float64x2_t) -> int8x16_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_f64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_f64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_f32_f64(a: float64x2_t) -> float32x4_t {
-    let a: float64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: float32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpretq_s16_f64(a: float64x2_t) -> int16x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_f64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_f64)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_s8_f64(a: float64x2_t) -> int8x16_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_f64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_s8_f64(a: float64x2_t) -> int8x16_t {
-    let a: float64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: int8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_f64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_s16_f64(a: float64x2_t) -> int16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_f64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_s16_f64(a: float64x2_t) -> int16x8_t {
-    let a: float64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: int16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_f64)"]
-#[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
@@ -22029,736 +21713,301 @@ pub fn vreinterpretq_s32_f64(a: float64x2_t) -> int32x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_f64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_s32_f64(a: float64x2_t) -> int32x4_t {
-    let a: float64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: int32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_f64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_s64_f64(a: float64x2_t) -> int64x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_f64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vreinterpretq_s64_f64(a: float64x2_t) -> int64x2_t {
-    let a: float64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: int64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_f64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_u8_f64(a: float64x2_t) -> uint8x16_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_f64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_u8_f64(a: float64x2_t) -> uint8x16_t {
-    let a: float64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: uint8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_f64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_u16_f64(a: float64x2_t) -> uint16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_f64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_u16_f64(a: float64x2_t) -> uint16x8_t {
-    let a: float64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: uint16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_f64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_u32_f64(a: float64x2_t) -> uint32x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_f64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_u32_f64(a: float64x2_t) -> uint32x4_t {
-    let a: float64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: uint32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_f64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_u64_f64(a: float64x2_t) -> uint64x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_f64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_u64_f64(a: float64x2_t) -> uint64x2_t {
-    let a: float64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: uint64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_f64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_p8_f64(a: float64x2_t) -> poly8x16_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_f64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_p8_f64(a: float64x2_t) -> poly8x16_t {
-    let a: float64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: poly8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_f64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_p16_f64(a: float64x2_t) -> poly16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_f64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_p16_f64(a: float64x2_t) -> poly16x8_t {
-    let a: float64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: poly16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_f64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_p64_f64(a: float64x2_t) -> poly64x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_f64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_p64_f64(a: float64x2_t) -> poly64x2_t {
-    let a: float64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: poly64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_s8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_f64_s8(a: int8x8_t) -> float64x1_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_s8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_f64_s8(a: int8x8_t) -> float64x1_t {
-    let a: int8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_s8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_f64_s8(a: int8x16_t) -> float64x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_s8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_f64_s8(a: int8x16_t) -> float64x2_t {
-    let a: int8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_s16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_f64_s16(a: int16x4_t) -> float64x1_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_s16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_f64_s16(a: int16x4_t) -> float64x1_t {
-    let a: int16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_s16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_f64_s16(a: int16x8_t) -> float64x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_s16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_f64_s16(a: int16x8_t) -> float64x2_t {
-    let a: int16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_s32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_f64_s32(a: int32x2_t) -> float64x1_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_s32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_f64_s32(a: int32x2_t) -> float64x1_t {
-    let a: int32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_s32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_f64_s32(a: int32x4_t) -> float64x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_s32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_f64_s32(a: int32x4_t) -> float64x2_t {
-    let a: int32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_s64)"]
-#[inline]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_f64_s64(a: int64x1_t) -> float64x1_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_s64)"]
-#[inline]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_p64_s64(a: int64x1_t) -> poly64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_s64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_f64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_f64_s64(a: int64x2_t) -> float64x2_t {
+pub fn vreinterpretq_u8_f64(a: float64x2_t) -> uint8x16_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_s64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_f64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_f64_s64(a: int64x2_t) -> float64x2_t {
-    let a: int64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: float64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpretq_u16_f64(a: float64x2_t) -> uint16x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_s64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_f64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_p64_s64(a: int64x2_t) -> poly64x2_t {
+pub fn vreinterpretq_u32_f64(a: float64x2_t) -> uint32x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_s64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_f64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_p64_s64(a: int64x2_t) -> poly64x2_t {
-    let a: int64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: poly64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpretq_u64_f64(a: float64x2_t) -> uint64x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_u8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_f64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_f64_u8(a: uint8x8_t) -> float64x1_t {
+pub fn vreinterpretq_p8_f64(a: float64x2_t) -> poly8x16_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_u8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_f64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_f64_u8(a: uint8x8_t) -> float64x1_t {
-    let a: uint8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
+pub fn vreinterpretq_p16_f64(a: float64x2_t) -> poly16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_u8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_f64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_f64_u8(a: uint8x16_t) -> float64x2_t {
+pub fn vreinterpretq_p64_f64(a: float64x2_t) -> poly64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_u8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_s8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_f64_u8(a: uint8x16_t) -> float64x2_t {
-    let a: uint8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpret_f64_s8(a: int8x8_t) -> float64x1_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_u16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_s8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_f64_u16(a: uint16x4_t) -> float64x1_t {
+pub fn vreinterpretq_f64_s8(a: int8x16_t) -> float64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_u16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_s16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_f64_u16(a: uint16x4_t) -> float64x1_t {
-    let a: uint16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
+pub fn vreinterpret_f64_s16(a: int16x4_t) -> float64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_u16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_s16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_f64_u16(a: uint16x8_t) -> float64x2_t {
+pub fn vreinterpretq_f64_s16(a: int16x8_t) -> float64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_u16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_s32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_f64_u16(a: uint16x8_t) -> float64x2_t {
-    let a: uint16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpret_f64_s32(a: int32x2_t) -> float64x1_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_s32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_f64_u32(a: uint32x2_t) -> float64x1_t {
+pub fn vreinterpretq_f64_s32(a: int32x4_t) -> float64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_s64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_f64_u32(a: uint32x2_t) -> float64x1_t {
-    let a: uint32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
+pub fn vreinterpret_f64_s64(a: int64x1_t) -> float64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_s64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_f64_u32(a: uint32x4_t) -> float64x2_t {
+pub fn vreinterpret_p64_s64(a: int64x1_t) -> poly64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_s64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_f64_u32(a: uint32x4_t) -> float64x2_t {
-    let a: uint32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpretq_f64_s64(a: int64x2_t) -> float64x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_s64)"]
 #[inline]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_f64_u64(a: uint64x1_t) -> float64x1_t {
+pub fn vreinterpretq_p64_s64(a: int64x2_t) -> poly64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_u8)"]
 #[inline]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_p64_u64(a: uint64x1_t) -> poly64x1_t {
+pub fn vreinterpret_f64_u8(a: uint8x8_t) -> float64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_u8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_f64_u64(a: uint64x2_t) -> float64x2_t {
+pub fn vreinterpretq_f64_u8(a: uint8x16_t) -> float64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_u16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_f64_u64(a: uint64x2_t) -> float64x2_t {
-    let a: uint64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: float64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpret_f64_u16(a: uint16x4_t) -> float64x1_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_u16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_p64_u64(a: uint64x2_t) -> poly64x2_t {
+pub fn vreinterpretq_f64_u16(a: uint16x8_t) -> float64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_u32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_p64_u64(a: uint64x2_t) -> poly64x2_t {
-    let a: uint64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: poly64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpret_f64_u32(a: uint32x2_t) -> float64x1_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_u32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_f64_p8(a: poly8x8_t) -> float64x1_t {
+pub fn vreinterpretq_f64_u32(a: uint32x4_t) -> float64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_u64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_f64_p8(a: poly8x8_t) -> float64x1_t {
-    let a: poly8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
+pub fn vreinterpret_f64_u64(a: uint64x1_t) -> float64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_u64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_f64_p8(a: poly8x16_t) -> float64x2_t {
+pub fn vreinterpret_p64_u64(a: uint64x1_t) -> poly64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_u64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_f64_p8(a: poly8x16_t) -> float64x2_t {
-    let a: poly8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpretq_f64_u64(a: uint64x2_t) -> float64x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_u64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_f64_p16(a: poly16x4_t) -> float64x1_t {
+pub fn vreinterpretq_p64_u64(a: uint64x2_t) -> poly64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_p8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_f64_p16(a: poly16x4_t) -> float64x1_t {
-    let a: poly16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
+pub fn vreinterpret_f64_p8(a: poly8x8_t) -> float64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_p8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_f64_p16(a: poly16x8_t) -> float64x2_t {
+pub fn vreinterpretq_f64_p8(a: poly8x16_t) -> float64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_p16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_f64_p16(a: poly16x8_t) -> float64x2_t {
-    let a: poly16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpret_f64_p16(a: poly16x4_t) -> float64x1_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_p16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpret_f32_p64(a: poly64x1_t) -> float32x2_t {
+pub fn vreinterpretq_f64_p16(a: poly16x8_t) -> float64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_p64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vreinterpret_f32_p64(a: poly64x1_t) -> float32x2_t {
-    unsafe {
-        let ret_val: float32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f64_p64)"]
@@ -22790,7 +22039,6 @@ pub fn vreinterpret_u64_p64(a: poly64x1_t) -> uint64x1_t {
 #[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_p64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
@@ -22798,23 +22046,8 @@ pub fn vreinterpretq_f32_p64(a: poly64x2_t) -> float32x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_p64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_f32_p64(a: poly64x2_t) -> float32x4_t {
-    let a: poly64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: float32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_p64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
@@ -22822,23 +22055,8 @@ pub fn vreinterpretq_f64_p64(a: poly64x2_t) -> float64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f64_p64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_f64_p64(a: poly64x2_t) -> float64x2_t {
-    let a: poly64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: float64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_p64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
@@ -22846,43 +22064,14 @@ pub fn vreinterpretq_s64_p64(a: poly64x2_t) -> int64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_p64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_s64_p64(a: poly64x2_t) -> int64x2_t {
-    let a: poly64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: int64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_p64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 #[cfg_attr(test, assert_instr(nop))]
 pub fn vreinterpretq_u64_p64(a: poly64x2_t) -> uint64x2_t {
     unsafe { transmute(a) }
 }
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_p64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[stable(feature = "neon_intrinsics", since = "1.59.0")]
-#[cfg_attr(test, assert_instr(nop))]
-pub fn vreinterpretq_u64_p64(a: poly64x2_t) -> uint64x2_t {
-    let a: poly64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: uint64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
 #[doc = "Floating-point round to 32-bit integer, using current rounding mode"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnd32x_f32)"]
 #[inline]
diff --git a/library/stdarch/crates/core_arch/src/arm_shared/neon/generated.rs b/library/stdarch/crates/core_arch/src/arm_shared/neon/generated.rs
index b5ba792b18aec..e4e4e040f468d 100644
--- a/library/stdarch/crates/core_arch/src/arm_shared/neon/generated.rs
+++ b/library/stdarch/crates/core_arch/src/arm_shared/neon/generated.rs
@@ -42089,7 +42089,6 @@ pub fn vrecpsq_f32(a: float32x4_t, b: float32x4_t) -> float32x4_t {
 #[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_f16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42103,9 +42102,8 @@ pub fn vreinterpret_f32_f16(a: float16x4_t) -> float32x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_f16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42115,17 +42113,12 @@ pub fn vreinterpret_f32_f16(a: float16x4_t) -> float32x2_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_f32_f16(a: float16x4_t) -> float32x2_t {
-    let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpret_s8_f16(a: float16x4_t) -> int8x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_f16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42135,13 +42128,12 @@ pub fn vreinterpret_f32_f16(a: float16x4_t) -> float32x2_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_s8_f16(a: float16x4_t) -> int8x8_t {
+pub fn vreinterpret_s16_f16(a: float16x4_t) -> int16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_f16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42151,17 +42143,12 @@ pub fn vreinterpret_s8_f16(a: float16x4_t) -> int8x8_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_s8_f16(a: float16x4_t) -> int8x8_t {
-    let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpret_s32_f16(a: float16x4_t) -> int32x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_f16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42171,13 +42158,12 @@ pub fn vreinterpret_s8_f16(a: float16x4_t) -> int8x8_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_s16_f16(a: float16x4_t) -> int16x4_t {
+pub fn vreinterpret_s64_f16(a: float16x4_t) -> int64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_f16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42187,17 +42173,12 @@ pub fn vreinterpret_s16_f16(a: float16x4_t) -> int16x4_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_s16_f16(a: float16x4_t) -> int16x4_t {
-    let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpret_u8_f16(a: float16x4_t) -> uint8x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_f16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42207,13 +42188,12 @@ pub fn vreinterpret_s16_f16(a: float16x4_t) -> int16x4_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_s32_f16(a: float16x4_t) -> int32x2_t {
+pub fn vreinterpret_u16_f16(a: float16x4_t) -> uint16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_f16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42223,17 +42203,12 @@ pub fn vreinterpret_s32_f16(a: float16x4_t) -> int32x2_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_s32_f16(a: float16x4_t) -> int32x2_t {
-    let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpret_u32_f16(a: float16x4_t) -> uint32x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_f16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42243,13 +42218,12 @@ pub fn vreinterpret_s32_f16(a: float16x4_t) -> int32x2_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_s64_f16(a: float16x4_t) -> int64x1_t {
+pub fn vreinterpret_u64_f16(a: float16x4_t) -> uint64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_f16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42259,14 +42233,12 @@ pub fn vreinterpret_s64_f16(a: float16x4_t) -> int64x1_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_s64_f16(a: float16x4_t) -> int64x1_t {
-    let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
+pub fn vreinterpret_p8_f16(a: float16x4_t) -> poly8x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_f16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42276,13 +42248,12 @@ pub fn vreinterpret_s64_f16(a: float16x4_t) -> int64x1_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_u8_f16(a: float16x4_t) -> uint8x8_t {
+pub fn vreinterpret_p16_f16(a: float16x4_t) -> poly16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_f16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42292,17 +42263,12 @@ pub fn vreinterpret_u8_f16(a: float16x4_t) -> uint8x8_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_u8_f16(a: float16x4_t) -> uint8x8_t {
-    let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpretq_f32_f16(a: float16x8_t) -> float32x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_f16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42312,13 +42278,12 @@ pub fn vreinterpret_u8_f16(a: float16x4_t) -> uint8x8_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_u16_f16(a: float16x4_t) -> uint16x4_t {
+pub fn vreinterpretq_s8_f16(a: float16x8_t) -> int8x16_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_f16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42328,17 +42293,12 @@ pub fn vreinterpret_u16_f16(a: float16x4_t) -> uint16x4_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_u16_f16(a: float16x4_t) -> uint16x4_t {
-    let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpretq_s16_f16(a: float16x8_t) -> int16x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_f16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42348,13 +42308,12 @@ pub fn vreinterpret_u16_f16(a: float16x4_t) -> uint16x4_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_u32_f16(a: float16x4_t) -> uint32x2_t {
+pub fn vreinterpretq_s32_f16(a: float16x8_t) -> int32x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_f16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42364,17 +42323,12 @@ pub fn vreinterpret_u32_f16(a: float16x4_t) -> uint32x2_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_u32_f16(a: float16x4_t) -> uint32x2_t {
-    let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpretq_s64_f16(a: float16x8_t) -> int64x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_f16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42384,13 +42338,12 @@ pub fn vreinterpret_u32_f16(a: float16x4_t) -> uint32x2_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_u64_f16(a: float16x4_t) -> uint64x1_t {
+pub fn vreinterpretq_u8_f16(a: float16x8_t) -> uint8x16_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_f16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42400,14 +42353,12 @@ pub fn vreinterpret_u64_f16(a: float16x4_t) -> uint64x1_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_u64_f16(a: float16x4_t) -> uint64x1_t {
-    let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
+pub fn vreinterpretq_u16_f16(a: float16x8_t) -> uint16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_f16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42417,13 +42368,12 @@ pub fn vreinterpret_u64_f16(a: float16x4_t) -> uint64x1_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_p8_f16(a: float16x4_t) -> poly8x8_t {
+pub fn vreinterpretq_u32_f16(a: float16x8_t) -> uint32x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_f16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42433,17 +42383,12 @@ pub fn vreinterpret_p8_f16(a: float16x4_t) -> poly8x8_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_p8_f16(a: float16x4_t) -> poly8x8_t {
-    let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpretq_u64_f16(a: float16x8_t) -> uint64x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_f16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42453,13 +42398,12 @@ pub fn vreinterpret_p8_f16(a: float16x4_t) -> poly8x8_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_p16_f16(a: float16x4_t) -> poly16x4_t {
+pub fn vreinterpretq_p8_f16(a: float16x8_t) -> poly8x16_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_f16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42469,17 +42413,12 @@ pub fn vreinterpret_p16_f16(a: float16x4_t) -> poly16x4_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_p16_f16(a: float16x4_t) -> poly16x4_t {
-    let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpretq_p16_f16(a: float16x8_t) -> poly16x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_f32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42489,13 +42428,12 @@ pub fn vreinterpret_p16_f16(a: float16x4_t) -> poly16x4_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_f32_f16(a: float16x8_t) -> float32x4_t {
+pub fn vreinterpret_f16_f32(a: float32x2_t) -> float16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_f32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42505,17 +42443,12 @@ pub fn vreinterpretq_f32_f16(a: float16x8_t) -> float32x4_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_f32_f16(a: float16x8_t) -> float32x4_t {
-    let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpretq_f16_f32(a: float32x4_t) -> float16x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_s8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42525,13 +42458,12 @@ pub fn vreinterpretq_f32_f16(a: float16x8_t) -> float32x4_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_s8_f16(a: float16x8_t) -> int8x16_t {
+pub fn vreinterpret_f16_s8(a: int8x8_t) -> float16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_s8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42541,21 +42473,12 @@ pub fn vreinterpretq_s8_f16(a: float16x8_t) -> int8x16_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_s8_f16(a: float16x8_t) -> int8x16_t {
-    let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
+pub fn vreinterpretq_f16_s8(a: int8x16_t) -> float16x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_s16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42565,13 +42488,12 @@ pub fn vreinterpretq_s8_f16(a: float16x8_t) -> int8x16_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_s16_f16(a: float16x8_t) -> int16x8_t {
+pub fn vreinterpret_f16_s16(a: int16x4_t) -> float16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_s16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42581,17 +42503,12 @@ pub fn vreinterpretq_s16_f16(a: float16x8_t) -> int16x8_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_s16_f16(a: float16x8_t) -> int16x8_t {
-    let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpretq_f16_s16(a: int16x8_t) -> float16x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_s32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42601,13 +42518,12 @@ pub fn vreinterpretq_s16_f16(a: float16x8_t) -> int16x8_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_s32_f16(a: float16x8_t) -> int32x4_t {
+pub fn vreinterpret_f16_s32(a: int32x2_t) -> float16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_s32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42617,17 +42533,12 @@ pub fn vreinterpretq_s32_f16(a: float16x8_t) -> int32x4_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_s32_f16(a: float16x8_t) -> int32x4_t {
-    let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpretq_f16_s32(a: int32x4_t) -> float16x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_s64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42637,13 +42548,12 @@ pub fn vreinterpretq_s32_f16(a: float16x8_t) -> int32x4_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_s64_f16(a: float16x8_t) -> int64x2_t {
+pub fn vreinterpret_f16_s64(a: int64x1_t) -> float16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_s64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42653,17 +42563,12 @@ pub fn vreinterpretq_s64_f16(a: float16x8_t) -> int64x2_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_s64_f16(a: float16x8_t) -> int64x2_t {
-    let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpretq_f16_s64(a: int64x2_t) -> float16x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_u8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42673,13 +42578,12 @@ pub fn vreinterpretq_s64_f16(a: float16x8_t) -> int64x2_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_u8_f16(a: float16x8_t) -> uint8x16_t {
+pub fn vreinterpret_f16_u8(a: uint8x8_t) -> float16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_u8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42689,21 +42593,12 @@ pub fn vreinterpretq_u8_f16(a: float16x8_t) -> uint8x16_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_u8_f16(a: float16x8_t) -> uint8x16_t {
-    let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
+pub fn vreinterpretq_f16_u8(a: uint8x16_t) -> float16x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_u16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42713,13 +42608,12 @@ pub fn vreinterpretq_u8_f16(a: float16x8_t) -> uint8x16_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_u16_f16(a: float16x8_t) -> uint16x8_t {
+pub fn vreinterpret_f16_u16(a: uint16x4_t) -> float16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_u16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42729,53 +42623,12 @@ pub fn vreinterpretq_u16_f16(a: float16x8_t) -> uint16x8_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_u16_f16(a: float16x8_t) -> uint16x8_t {
-    let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_f16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_u32_f16(a: float16x8_t) -> uint32x4_t {
+pub fn vreinterpretq_f16_u16(a: uint16x8_t) -> float16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_f16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_u32_f16(a: float16x8_t) -> uint32x4_t {
-    let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_u32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42785,33 +42638,12 @@ pub fn vreinterpretq_u32_f16(a: float16x8_t) -> uint32x4_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_u64_f16(a: float16x8_t) -> uint64x2_t {
+pub fn vreinterpret_f16_u32(a: uint32x2_t) -> float16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_f16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_u64_f16(a: float16x8_t) -> uint64x2_t {
-    let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_u32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42821,37 +42653,12 @@ pub fn vreinterpretq_u64_f16(a: float16x8_t) -> uint64x2_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_p8_f16(a: float16x8_t) -> poly8x16_t {
+pub fn vreinterpretq_f16_u32(a: uint32x4_t) -> float16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_f16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_p8_f16(a: float16x8_t) -> poly8x16_t {
-    let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_f16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_u64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42861,33 +42668,12 @@ pub fn vreinterpretq_p8_f16(a: float16x8_t) -> poly8x16_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_p16_f16(a: float16x8_t) -> poly16x8_t {
+pub fn vreinterpret_f16_u64(a: uint64x1_t) -> float16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_f16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_p16_f16(a: float16x8_t) -> poly16x8_t {
-    let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_f32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_u64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42897,33 +42683,12 @@ pub fn vreinterpretq_p16_f16(a: float16x8_t) -> poly16x8_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_f16_f32(a: float32x2_t) -> float16x4_t {
+pub fn vreinterpretq_f16_u64(a: uint64x2_t) -> float16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_f32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_f16_f32(a: float32x2_t) -> float16x4_t {
-    let a: float32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: float16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_f32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_p8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42933,33 +42698,12 @@ pub fn vreinterpret_f16_f32(a: float32x2_t) -> float16x4_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_f16_f32(a: float32x4_t) -> float16x8_t {
+pub fn vreinterpret_f16_p8(a: poly8x8_t) -> float16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_f32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_f16_f32(a: float32x4_t) -> float16x8_t {
-    let a: float32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_s8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_p8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -42969,33 +42713,12 @@ pub fn vreinterpretq_f16_f32(a: float32x4_t) -> float16x8_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_f16_s8(a: int8x8_t) -> float16x4_t {
+pub fn vreinterpretq_f16_p8(a: poly8x16_t) -> float16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_s8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_f16_s8(a: int8x8_t) -> float16x4_t {
-    let a: int8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_s8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_p16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -43005,34 +42728,12 @@ pub fn vreinterpret_f16_s8(a: int8x8_t) -> float16x4_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_f16_s8(a: int8x16_t) -> float16x8_t {
+pub fn vreinterpret_f16_p16(a: poly16x4_t) -> float16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_s8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_f16_s8(a: int8x16_t) -> float16x8_t {
-    let a: int8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_s16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_p16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
@@ -43042,34 +42743,13 @@ pub fn vreinterpretq_f16_s8(a: int8x16_t) -> float16x8_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_f16_s16(a: int16x4_t) -> float16x4_t {
+pub fn vreinterpretq_f16_p16(a: poly16x8_t) -> float16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_s16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_f16_s16(a: int16x4_t) -> float16x4_t {
-    let a: int16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_s16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_p128)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -43078,14 +42758,13 @@ pub fn vreinterpret_f16_s16(a: int16x4_t) -> float16x4_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_f16_s16(a: int16x8_t) -> float16x8_t {
+pub fn vreinterpretq_f16_p128(a: p128) -> float16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_s16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_f16)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -43094,18 +42773,13 @@ pub fn vreinterpretq_f16_s16(a: int16x8_t) -> float16x8_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_f16_s16(a: int16x8_t) -> float16x8_t {
-    let a: int16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpret_p64_f16(a: float16x4_t) -> poly64x1_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_s32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_f16)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -43114,7391 +42788,57 @@ pub fn vreinterpretq_f16_s16(a: int16x8_t) -> float16x8_t {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_f16_s32(a: int32x2_t) -> float16x4_t {
+pub fn vreinterpretq_p128_f16(a: float16x8_t) -> p128 {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_s32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_f16_s32(a: int32x2_t) -> float16x4_t {
-    let a: int32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: float16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_s32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_f16_s32(a: int32x4_t) -> float16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_s32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_f16_s32(a: int32x4_t) -> float16x8_t {
-    let a: int32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_s64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_f16_s64(a: int64x1_t) -> float16x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_s64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_f16_s64(a: int64x1_t) -> float16x4_t {
-    unsafe {
-        let ret_val: float16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_s64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_f16_s64(a: int64x2_t) -> float16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_s64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_f16_s64(a: int64x2_t) -> float16x8_t {
-    let a: int64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: float16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_u8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_f16_u8(a: uint8x8_t) -> float16x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_u8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_f16_u8(a: uint8x8_t) -> float16x4_t {
-    let a: uint8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_u8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_f16_u8(a: uint8x16_t) -> float16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_u8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_f16_u8(a: uint8x16_t) -> float16x8_t {
-    let a: uint8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_u16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_f16_u16(a: uint16x4_t) -> float16x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_u16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_f16_u16(a: uint16x4_t) -> float16x4_t {
-    let a: uint16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_u16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_f16_u16(a: uint16x8_t) -> float16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_u16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_f16_u16(a: uint16x8_t) -> float16x8_t {
-    let a: uint16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_u32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_f16_u32(a: uint32x2_t) -> float16x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_u32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_f16_u32(a: uint32x2_t) -> float16x4_t {
-    let a: uint32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: float16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_u32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_f16_u32(a: uint32x4_t) -> float16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_u32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_f16_u32(a: uint32x4_t) -> float16x8_t {
-    let a: uint32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_u64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_f16_u64(a: uint64x1_t) -> float16x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_u64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_f16_u64(a: uint64x1_t) -> float16x4_t {
-    unsafe {
-        let ret_val: float16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_u64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_f16_u64(a: uint64x2_t) -> float16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_u64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_f16_u64(a: uint64x2_t) -> float16x8_t {
-    let a: uint64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: float16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_p8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_f16_p8(a: poly8x8_t) -> float16x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_p8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_f16_p8(a: poly8x8_t) -> float16x4_t {
-    let a: poly8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_p8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_f16_p8(a: poly8x16_t) -> float16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_p8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_f16_p8(a: poly8x16_t) -> float16x8_t {
-    let a: poly8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_p16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_f16_p16(a: poly16x4_t) -> float16x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_p16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_f16_p16(a: poly16x4_t) -> float16x4_t {
-    let a: poly16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_p16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_f16_p16(a: poly16x8_t) -> float16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_p16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_f16_p16(a: poly16x8_t) -> float16x8_t {
-    let a: poly16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_p128)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_f16_p128(a: p128) -> float16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_p128)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_f16_p128(a: p128) -> float16x8_t {
-    unsafe {
-        let ret_val: float16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_f16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_p64_f16(a: float16x4_t) -> poly64x1_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_f16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_p64_f16(a: float16x4_t) -> poly64x1_t {
-    let a: float16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_f16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_p128_f16(a: float16x8_t) -> p128 {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_f16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_p128_f16(a: float16x8_t) -> p128 {
-    let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_f16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_p64_f16(a: float16x8_t) -> poly64x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_f16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_p64_f16(a: float16x8_t) -> poly64x2_t {
-    let a: float16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_p64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_f16_p64(a: poly64x1_t) -> float16x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_p64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpret_f16_p64(a: poly64x1_t) -> float16x4_t {
-    unsafe {
-        let ret_val: float16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_p64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_f16_p64(a: poly64x2_t) -> float16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_p64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[target_feature(enable = "neon,fp16")]
-#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
-#[cfg(not(target_arch = "arm64ec"))]
-pub fn vreinterpretq_f16_p64(a: poly64x2_t) -> float16x8_t {
-    let a: poly64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: float16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_p128)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_f32_p128(a: p128) -> float32x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_p128)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_f32_p128(a: p128) -> float32x4_t {
-    unsafe {
-        let ret_val: float32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_f32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s8_f32(a: float32x2_t) -> int8x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_f32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s8_f32(a: float32x2_t) -> int8x8_t {
-    let a: float32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: int8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_f32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s16_f32(a: float32x2_t) -> int16x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_f32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s16_f32(a: float32x2_t) -> int16x4_t {
-    let a: float32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: int16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_f32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s32_f32(a: float32x2_t) -> int32x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_f32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s32_f32(a: float32x2_t) -> int32x2_t {
-    let a: float32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: int32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_f32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s64_f32(a: float32x2_t) -> int64x1_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_f32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s64_f32(a: float32x2_t) -> int64x1_t {
-    let a: float32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_f32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u8_f32(a: float32x2_t) -> uint8x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_f32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u8_f32(a: float32x2_t) -> uint8x8_t {
-    let a: float32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: uint8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_f32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u16_f32(a: float32x2_t) -> uint16x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_f32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u16_f32(a: float32x2_t) -> uint16x4_t {
-    let a: float32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: uint16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_f32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u32_f32(a: float32x2_t) -> uint32x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_f32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u32_f32(a: float32x2_t) -> uint32x2_t {
-    let a: float32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: uint32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_f32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u64_f32(a: float32x2_t) -> uint64x1_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_f32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u64_f32(a: float32x2_t) -> uint64x1_t {
-    let a: float32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_f32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_p8_f32(a: float32x2_t) -> poly8x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_f32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_p8_f32(a: float32x2_t) -> poly8x8_t {
-    let a: float32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: poly8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_f32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_p16_f32(a: float32x2_t) -> poly16x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_f32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_p16_f32(a: float32x2_t) -> poly16x4_t {
-    let a: float32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: poly16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_f32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_p128_f32(a: float32x4_t) -> p128 {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_f32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_p128_f32(a: float32x4_t) -> p128 {
-    let a: float32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_f32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s8_f32(a: float32x4_t) -> int8x16_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_f32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s8_f32(a: float32x4_t) -> int8x16_t {
-    let a: float32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_f32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s16_f32(a: float32x4_t) -> int16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_f32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s16_f32(a: float32x4_t) -> int16x8_t {
-    let a: float32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_f32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s32_f32(a: float32x4_t) -> int32x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_f32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s32_f32(a: float32x4_t) -> int32x4_t {
-    let a: float32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_f32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s64_f32(a: float32x4_t) -> int64x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_f32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s64_f32(a: float32x4_t) -> int64x2_t {
-    let a: float32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_f32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u8_f32(a: float32x4_t) -> uint8x16_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_f32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u8_f32(a: float32x4_t) -> uint8x16_t {
-    let a: float32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_f32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u16_f32(a: float32x4_t) -> uint16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_f32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u16_f32(a: float32x4_t) -> uint16x8_t {
-    let a: float32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_f32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u32_f32(a: float32x4_t) -> uint32x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_f32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u32_f32(a: float32x4_t) -> uint32x4_t {
-    let a: float32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_f32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u64_f32(a: float32x4_t) -> uint64x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_f32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u64_f32(a: float32x4_t) -> uint64x2_t {
-    let a: float32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_f32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_p8_f32(a: float32x4_t) -> poly8x16_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_f32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_p8_f32(a: float32x4_t) -> poly8x16_t {
-    let a: float32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_f32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_p16_f32(a: float32x4_t) -> poly16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_f32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_p16_f32(a: float32x4_t) -> poly16x8_t {
-    let a: float32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_s8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_f32_s8(a: int8x8_t) -> float32x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_s8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_f32_s8(a: int8x8_t) -> float32x2_t {
-    let a: int8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_s8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s16_s8(a: int8x8_t) -> int16x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_s8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s16_s8(a: int8x8_t) -> int16x4_t {
-    let a: int8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_s8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s32_s8(a: int8x8_t) -> int32x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_s8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s32_s8(a: int8x8_t) -> int32x2_t {
-    let a: int8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_s8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s64_s8(a: int8x8_t) -> int64x1_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_s8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s64_s8(a: int8x8_t) -> int64x1_t {
-    let a: int8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_s8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u8_s8(a: int8x8_t) -> uint8x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_s8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u8_s8(a: int8x8_t) -> uint8x8_t {
-    let a: int8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_s8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u16_s8(a: int8x8_t) -> uint16x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_s8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u16_s8(a: int8x8_t) -> uint16x4_t {
-    let a: int8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_s8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u32_s8(a: int8x8_t) -> uint32x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_s8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u32_s8(a: int8x8_t) -> uint32x2_t {
-    let a: int8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_s8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u64_s8(a: int8x8_t) -> uint64x1_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_s8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u64_s8(a: int8x8_t) -> uint64x1_t {
-    let a: int8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_s8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_p8_s8(a: int8x8_t) -> poly8x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_s8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_p8_s8(a: int8x8_t) -> poly8x8_t {
-    let a: int8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_s8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_p16_s8(a: int8x8_t) -> poly16x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_s8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_p16_s8(a: int8x8_t) -> poly16x4_t {
-    let a: int8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_s8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_f32_s8(a: int8x16_t) -> float32x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_s8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_f32_s8(a: int8x16_t) -> float32x4_t {
-    let a: int8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_s8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s16_s8(a: int8x16_t) -> int16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_s8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s16_s8(a: int8x16_t) -> int16x8_t {
-    let a: int8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_s8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s32_s8(a: int8x16_t) -> int32x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_s8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s32_s8(a: int8x16_t) -> int32x4_t {
-    let a: int8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_s8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s64_s8(a: int8x16_t) -> int64x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_s8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s64_s8(a: int8x16_t) -> int64x2_t {
-    let a: int8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_s8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u8_s8(a: int8x16_t) -> uint8x16_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_s8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u8_s8(a: int8x16_t) -> uint8x16_t {
-    let a: int8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_s8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u16_s8(a: int8x16_t) -> uint16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_s8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u16_s8(a: int8x16_t) -> uint16x8_t {
-    let a: int8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_s8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u32_s8(a: int8x16_t) -> uint32x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_s8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u32_s8(a: int8x16_t) -> uint32x4_t {
-    let a: int8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_s8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u64_s8(a: int8x16_t) -> uint64x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_s8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u64_s8(a: int8x16_t) -> uint64x2_t {
-    let a: int8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_s8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_p8_s8(a: int8x16_t) -> poly8x16_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_s8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_p8_s8(a: int8x16_t) -> poly8x16_t {
-    let a: int8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_s8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_p16_s8(a: int8x16_t) -> poly16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_s8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_p16_s8(a: int8x16_t) -> poly16x8_t {
-    let a: int8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_s16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_f32_s16(a: int16x4_t) -> float32x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_s16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_f32_s16(a: int16x4_t) -> float32x2_t {
-    let a: int16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_s16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s8_s16(a: int16x4_t) -> int8x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_s16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s8_s16(a: int16x4_t) -> int8x8_t {
-    let a: int16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_s16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s32_s16(a: int16x4_t) -> int32x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_s16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s32_s16(a: int16x4_t) -> int32x2_t {
-    let a: int16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_s16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s64_s16(a: int16x4_t) -> int64x1_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_s16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s64_s16(a: int16x4_t) -> int64x1_t {
-    let a: int16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_s16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u8_s16(a: int16x4_t) -> uint8x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_s16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u8_s16(a: int16x4_t) -> uint8x8_t {
-    let a: int16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_s16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u16_s16(a: int16x4_t) -> uint16x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_s16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u16_s16(a: int16x4_t) -> uint16x4_t {
-    let a: int16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_s16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u32_s16(a: int16x4_t) -> uint32x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_s16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u32_s16(a: int16x4_t) -> uint32x2_t {
-    let a: int16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_s16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u64_s16(a: int16x4_t) -> uint64x1_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_s16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u64_s16(a: int16x4_t) -> uint64x1_t {
-    let a: int16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_s16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_p8_s16(a: int16x4_t) -> poly8x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_s16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_p8_s16(a: int16x4_t) -> poly8x8_t {
-    let a: int16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_s16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_p16_s16(a: int16x4_t) -> poly16x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_s16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_p16_s16(a: int16x4_t) -> poly16x4_t {
-    let a: int16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_s16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_f32_s16(a: int16x8_t) -> float32x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_s16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_f32_s16(a: int16x8_t) -> float32x4_t {
-    let a: int16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_s16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s8_s16(a: int16x8_t) -> int8x16_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_s16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s8_s16(a: int16x8_t) -> int8x16_t {
-    let a: int16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_s16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s32_s16(a: int16x8_t) -> int32x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_s16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s32_s16(a: int16x8_t) -> int32x4_t {
-    let a: int16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_s16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s64_s16(a: int16x8_t) -> int64x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_s16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s64_s16(a: int16x8_t) -> int64x2_t {
-    let a: int16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_s16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u8_s16(a: int16x8_t) -> uint8x16_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_s16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u8_s16(a: int16x8_t) -> uint8x16_t {
-    let a: int16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_s16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u16_s16(a: int16x8_t) -> uint16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_s16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u16_s16(a: int16x8_t) -> uint16x8_t {
-    let a: int16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_s16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u32_s16(a: int16x8_t) -> uint32x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_s16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u32_s16(a: int16x8_t) -> uint32x4_t {
-    let a: int16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_s16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u64_s16(a: int16x8_t) -> uint64x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_s16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u64_s16(a: int16x8_t) -> uint64x2_t {
-    let a: int16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_s16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_p8_s16(a: int16x8_t) -> poly8x16_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_s16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_p8_s16(a: int16x8_t) -> poly8x16_t {
-    let a: int16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_s16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_p16_s16(a: int16x8_t) -> poly16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_s16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_p16_s16(a: int16x8_t) -> poly16x8_t {
-    let a: int16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_s32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_f32_s32(a: int32x2_t) -> float32x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_s32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_f32_s32(a: int32x2_t) -> float32x2_t {
-    let a: int32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: float32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_s32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s8_s32(a: int32x2_t) -> int8x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_s32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s8_s32(a: int32x2_t) -> int8x8_t {
-    let a: int32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: int8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_s32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s16_s32(a: int32x2_t) -> int16x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_s32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s16_s32(a: int32x2_t) -> int16x4_t {
-    let a: int32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: int16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_s32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s64_s32(a: int32x2_t) -> int64x1_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_s32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s64_s32(a: int32x2_t) -> int64x1_t {
-    let a: int32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_s32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u8_s32(a: int32x2_t) -> uint8x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_s32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u8_s32(a: int32x2_t) -> uint8x8_t {
-    let a: int32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: uint8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_s32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u16_s32(a: int32x2_t) -> uint16x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_s32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u16_s32(a: int32x2_t) -> uint16x4_t {
-    let a: int32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: uint16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_s32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u32_s32(a: int32x2_t) -> uint32x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_s32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u32_s32(a: int32x2_t) -> uint32x2_t {
-    let a: int32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: uint32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_s32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u64_s32(a: int32x2_t) -> uint64x1_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_s32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u64_s32(a: int32x2_t) -> uint64x1_t {
-    let a: int32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_s32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_p8_s32(a: int32x2_t) -> poly8x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_s32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_p8_s32(a: int32x2_t) -> poly8x8_t {
-    let a: int32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: poly8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_s32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_p16_s32(a: int32x2_t) -> poly16x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_s32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_p16_s32(a: int32x2_t) -> poly16x4_t {
-    let a: int32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: poly16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_s32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_f32_s32(a: int32x4_t) -> float32x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_s32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_f32_s32(a: int32x4_t) -> float32x4_t {
-    let a: int32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_s32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s8_s32(a: int32x4_t) -> int8x16_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_s32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s8_s32(a: int32x4_t) -> int8x16_t {
-    let a: int32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_s32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s16_s32(a: int32x4_t) -> int16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_s32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s16_s32(a: int32x4_t) -> int16x8_t {
-    let a: int32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_s32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s64_s32(a: int32x4_t) -> int64x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_s32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s64_s32(a: int32x4_t) -> int64x2_t {
-    let a: int32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_s32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u8_s32(a: int32x4_t) -> uint8x16_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_s32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u8_s32(a: int32x4_t) -> uint8x16_t {
-    let a: int32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_s32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u16_s32(a: int32x4_t) -> uint16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_s32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u16_s32(a: int32x4_t) -> uint16x8_t {
-    let a: int32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_s32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u32_s32(a: int32x4_t) -> uint32x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_s32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u32_s32(a: int32x4_t) -> uint32x4_t {
-    let a: int32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_s32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u64_s32(a: int32x4_t) -> uint64x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_s32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u64_s32(a: int32x4_t) -> uint64x2_t {
-    let a: int32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_s32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_p8_s32(a: int32x4_t) -> poly8x16_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_s32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_p8_s32(a: int32x4_t) -> poly8x16_t {
-    let a: int32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_s32)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_p16_s32(a: int32x4_t) -> poly16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_s32)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_p16_s32(a: int32x4_t) -> poly16x8_t {
-    let a: int32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_s64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_f32_s64(a: int64x1_t) -> float32x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_s64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_f32_s64(a: int64x1_t) -> float32x2_t {
-    unsafe {
-        let ret_val: float32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_s64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s8_s64(a: int64x1_t) -> int8x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_s64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s8_s64(a: int64x1_t) -> int8x8_t {
-    unsafe {
-        let ret_val: int8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_s64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s16_s64(a: int64x1_t) -> int16x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_s64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s16_s64(a: int64x1_t) -> int16x4_t {
-    unsafe {
-        let ret_val: int16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_s64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s32_s64(a: int64x1_t) -> int32x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_s64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s32_s64(a: int64x1_t) -> int32x2_t {
-    unsafe {
-        let ret_val: int32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_s64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u8_s64(a: int64x1_t) -> uint8x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_s64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u8_s64(a: int64x1_t) -> uint8x8_t {
-    unsafe {
-        let ret_val: uint8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_s64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u16_s64(a: int64x1_t) -> uint16x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_s64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u16_s64(a: int64x1_t) -> uint16x4_t {
-    unsafe {
-        let ret_val: uint16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_s64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u32_s64(a: int64x1_t) -> uint32x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_s64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u32_s64(a: int64x1_t) -> uint32x2_t {
-    unsafe {
-        let ret_val: uint32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_s64)"]
-#[inline]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u64_s64(a: int64x1_t) -> uint64x1_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_s64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_p8_s64(a: int64x1_t) -> poly8x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_s64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_p8_s64(a: int64x1_t) -> poly8x8_t {
-    unsafe {
-        let ret_val: poly8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_s64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_p16_s64(a: int64x1_t) -> poly16x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_s64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_p16_s64(a: int64x1_t) -> poly16x4_t {
-    unsafe {
-        let ret_val: poly16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_s64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_f32_s64(a: int64x2_t) -> float32x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_s64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_f32_s64(a: int64x2_t) -> float32x4_t {
-    let a: int64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: float32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_s64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s8_s64(a: int64x2_t) -> int8x16_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_s64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s8_s64(a: int64x2_t) -> int8x16_t {
-    let a: int64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: int8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_s64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s16_s64(a: int64x2_t) -> int16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_s64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s16_s64(a: int64x2_t) -> int16x8_t {
-    let a: int64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: int16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_s64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s32_s64(a: int64x2_t) -> int32x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_s64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s32_s64(a: int64x2_t) -> int32x4_t {
-    let a: int64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: int32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_s64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u8_s64(a: int64x2_t) -> uint8x16_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_s64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u8_s64(a: int64x2_t) -> uint8x16_t {
-    let a: int64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: uint8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_s64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u16_s64(a: int64x2_t) -> uint16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_s64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u16_s64(a: int64x2_t) -> uint16x8_t {
-    let a: int64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: uint16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_s64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u32_s64(a: int64x2_t) -> uint32x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_s64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u32_s64(a: int64x2_t) -> uint32x4_t {
-    let a: int64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: uint32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_s64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u64_s64(a: int64x2_t) -> uint64x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_s64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u64_s64(a: int64x2_t) -> uint64x2_t {
-    let a: int64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: uint64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_s64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_p8_s64(a: int64x2_t) -> poly8x16_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_s64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_p8_s64(a: int64x2_t) -> poly8x16_t {
-    let a: int64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: poly8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_s64)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_p16_s64(a: int64x2_t) -> poly16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_s64)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_p16_s64(a: int64x2_t) -> poly16x8_t {
-    let a: int64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: poly16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_u8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_f32_u8(a: uint8x8_t) -> float32x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_u8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_f32_u8(a: uint8x8_t) -> float32x2_t {
-    let a: uint8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_u8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s8_u8(a: uint8x8_t) -> int8x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_u8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s8_u8(a: uint8x8_t) -> int8x8_t {
-    let a: uint8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_u8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s16_u8(a: uint8x8_t) -> int16x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_u8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s16_u8(a: uint8x8_t) -> int16x4_t {
-    let a: uint8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_u8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s32_u8(a: uint8x8_t) -> int32x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_u8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s32_u8(a: uint8x8_t) -> int32x2_t {
-    let a: uint8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_u8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s64_u8(a: uint8x8_t) -> int64x1_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_u8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s64_u8(a: uint8x8_t) -> int64x1_t {
-    let a: uint8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_u8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u16_u8(a: uint8x8_t) -> uint16x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_u8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u16_u8(a: uint8x8_t) -> uint16x4_t {
-    let a: uint8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_u8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u32_u8(a: uint8x8_t) -> uint32x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_u8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u32_u8(a: uint8x8_t) -> uint32x2_t {
-    let a: uint8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_u8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u64_u8(a: uint8x8_t) -> uint64x1_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_u8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u64_u8(a: uint8x8_t) -> uint64x1_t {
-    let a: uint8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_u8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_p8_u8(a: uint8x8_t) -> poly8x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_u8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_p8_u8(a: uint8x8_t) -> poly8x8_t {
-    let a: uint8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_u8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_p16_u8(a: uint8x8_t) -> poly16x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_u8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_p16_u8(a: uint8x8_t) -> poly16x4_t {
-    let a: uint8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_u8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_f32_u8(a: uint8x16_t) -> float32x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_u8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_f32_u8(a: uint8x16_t) -> float32x4_t {
-    let a: uint8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_u8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s8_u8(a: uint8x16_t) -> int8x16_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_u8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s8_u8(a: uint8x16_t) -> int8x16_t {
-    let a: uint8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_u8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s16_u8(a: uint8x16_t) -> int16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_u8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s16_u8(a: uint8x16_t) -> int16x8_t {
-    let a: uint8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_u8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s32_u8(a: uint8x16_t) -> int32x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_u8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s32_u8(a: uint8x16_t) -> int32x4_t {
-    let a: uint8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_u8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s64_u8(a: uint8x16_t) -> int64x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_u8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s64_u8(a: uint8x16_t) -> int64x2_t {
-    let a: uint8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_u8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u16_u8(a: uint8x16_t) -> uint16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_u8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u16_u8(a: uint8x16_t) -> uint16x8_t {
-    let a: uint8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_u8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u32_u8(a: uint8x16_t) -> uint32x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_u8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u32_u8(a: uint8x16_t) -> uint32x4_t {
-    let a: uint8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_u8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u64_u8(a: uint8x16_t) -> uint64x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_u8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u64_u8(a: uint8x16_t) -> uint64x2_t {
-    let a: uint8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_u8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_p8_u8(a: uint8x16_t) -> poly8x16_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_u8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_p8_u8(a: uint8x16_t) -> poly8x16_t {
-    let a: uint8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_u8)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_p16_u8(a: uint8x16_t) -> poly16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_u8)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_p16_u8(a: uint8x16_t) -> poly16x8_t {
-    let a: uint8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_u16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_f32_u16(a: uint16x4_t) -> float32x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_u16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_f32_u16(a: uint16x4_t) -> float32x2_t {
-    let a: uint16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_u16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s8_u16(a: uint16x4_t) -> int8x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_u16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s8_u16(a: uint16x4_t) -> int8x8_t {
-    let a: uint16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_u16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s16_u16(a: uint16x4_t) -> int16x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_u16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s16_u16(a: uint16x4_t) -> int16x4_t {
-    let a: uint16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_u16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s32_u16(a: uint16x4_t) -> int32x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_u16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s32_u16(a: uint16x4_t) -> int32x2_t {
-    let a: uint16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_u16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s64_u16(a: uint16x4_t) -> int64x1_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_u16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_s64_u16(a: uint16x4_t) -> int64x1_t {
-    let a: uint16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_u16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u8_u16(a: uint16x4_t) -> uint8x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_u16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u8_u16(a: uint16x4_t) -> uint8x8_t {
-    let a: uint16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_u16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u32_u16(a: uint16x4_t) -> uint32x2_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_u16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u32_u16(a: uint16x4_t) -> uint32x2_t {
-    let a: uint16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_u16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u64_u16(a: uint16x4_t) -> uint64x1_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_u16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_u64_u16(a: uint16x4_t) -> uint64x1_t {
-    let a: uint16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_u16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_p8_u16(a: uint16x4_t) -> poly8x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_u16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_p8_u16(a: uint16x4_t) -> poly8x8_t {
-    let a: uint16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_u16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_p16_u16(a: uint16x4_t) -> poly16x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_u16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpret_p16_u16(a: uint16x4_t) -> poly16x4_t {
-    let a: uint16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_u16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_f32_u16(a: uint16x8_t) -> float32x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_u16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_f32_u16(a: uint16x8_t) -> float32x4_t {
-    let a: uint16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_u16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s8_u16(a: uint16x8_t) -> int8x16_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_u16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s8_u16(a: uint16x8_t) -> int8x16_t {
-    let a: uint16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_u16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s16_u16(a: uint16x8_t) -> int16x8_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_u16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s16_u16(a: uint16x8_t) -> int16x8_t {
-    let a: uint16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_u16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s32_u16(a: uint16x8_t) -> int32x4_t {
-    unsafe { transmute(a) }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_u16)"]
-#[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
-#[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
-    assert_instr(nop)
-)]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s32_u16(a: uint16x8_t) -> int32x4_t {
-    let a: uint16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
-}
-#[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_u16)"]
-#[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_f16)"]
+#[inline]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
     assert_instr(nop)
 )]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s64_u16(a: uint16x8_t) -> int64x2_t {
+#[target_feature(enable = "neon,fp16")]
+#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
+pub fn vreinterpretq_p64_f16(a: float16x8_t) -> poly64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_u16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f16_p64)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
     assert_instr(nop)
 )]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_s64_u16(a: uint16x8_t) -> int64x2_t {
-    let a: uint16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+#[target_feature(enable = "neon,fp16")]
+#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
+pub fn vreinterpret_f16_p64(a: poly64x1_t) -> float16x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_u16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f16_p64)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
     assert_instr(nop)
 )]
-#[cfg_attr(
-    not(target_arch = "arm"),
-    stable(feature = "neon_intrinsics", since = "1.59.0")
-)]
-#[cfg_attr(
-    target_arch = "arm",
-    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
-)]
-pub fn vreinterpretq_u8_u16(a: uint16x8_t) -> uint8x16_t {
+#[target_feature(enable = "neon,fp16")]
+#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
+#[cfg(not(target_arch = "arm64ec"))]
+pub fn vreinterpretq_f16_p64(a: poly64x2_t) -> float16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_u16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_p128)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -50514,21 +42854,12 @@ pub fn vreinterpretq_u8_u16(a: uint16x8_t) -> uint8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u8_u16(a: uint16x8_t) -> uint8x16_t {
-    let a: uint16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
+pub fn vreinterpretq_f32_p128(a: p128) -> float32x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_u16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_f32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -50544,13 +42875,12 @@ pub fn vreinterpretq_u8_u16(a: uint16x8_t) -> uint8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u32_u16(a: uint16x8_t) -> uint32x4_t {
+pub fn vreinterpret_s8_f32(a: float32x2_t) -> int8x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_u16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_f32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -50566,17 +42896,12 @@ pub fn vreinterpretq_u32_u16(a: uint16x8_t) -> uint32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u32_u16(a: uint16x8_t) -> uint32x4_t {
-    let a: uint16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpret_s16_f32(a: float32x2_t) -> int16x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_u16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_f32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -50592,13 +42917,12 @@ pub fn vreinterpretq_u32_u16(a: uint16x8_t) -> uint32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u64_u16(a: uint16x8_t) -> uint64x2_t {
+pub fn vreinterpret_s32_f32(a: float32x2_t) -> int32x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_u16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_f32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -50614,17 +42938,12 @@ pub fn vreinterpretq_u64_u16(a: uint16x8_t) -> uint64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u64_u16(a: uint16x8_t) -> uint64x2_t {
-    let a: uint16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpret_s64_f32(a: float32x2_t) -> int64x1_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_u16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_f32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -50640,13 +42959,12 @@ pub fn vreinterpretq_u64_u16(a: uint16x8_t) -> uint64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p8_u16(a: uint16x8_t) -> poly8x16_t {
+pub fn vreinterpret_u8_f32(a: float32x2_t) -> uint8x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_u16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_f32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -50662,21 +42980,12 @@ pub fn vreinterpretq_p8_u16(a: uint16x8_t) -> poly8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p8_u16(a: uint16x8_t) -> poly8x16_t {
-    let a: uint16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
+pub fn vreinterpret_u16_f32(a: float32x2_t) -> uint16x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_u16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_f32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -50692,13 +43001,12 @@ pub fn vreinterpretq_p8_u16(a: uint16x8_t) -> poly8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p16_u16(a: uint16x8_t) -> poly16x8_t {
+pub fn vreinterpret_u32_f32(a: float32x2_t) -> uint32x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_u16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_f32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -50714,17 +43022,12 @@ pub fn vreinterpretq_p16_u16(a: uint16x8_t) -> poly16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p16_u16(a: uint16x8_t) -> poly16x8_t {
-    let a: uint16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpret_u64_f32(a: float32x2_t) -> uint64x1_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_f32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -50740,13 +43043,12 @@ pub fn vreinterpretq_p16_u16(a: uint16x8_t) -> poly16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_f32_u32(a: uint32x2_t) -> float32x2_t {
+pub fn vreinterpret_p8_f32(a: float32x2_t) -> poly8x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_f32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -50762,17 +43064,12 @@ pub fn vreinterpret_f32_u32(a: uint32x2_t) -> float32x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_f32_u32(a: uint32x2_t) -> float32x2_t {
-    let a: uint32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: float32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpret_p16_f32(a: float32x2_t) -> poly16x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_f32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -50788,13 +43085,12 @@ pub fn vreinterpret_f32_u32(a: uint32x2_t) -> float32x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s8_u32(a: uint32x2_t) -> int8x8_t {
+pub fn vreinterpretq_p128_f32(a: float32x4_t) -> p128 {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_f32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -50810,17 +43106,12 @@ pub fn vreinterpret_s8_u32(a: uint32x2_t) -> int8x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s8_u32(a: uint32x2_t) -> int8x8_t {
-    let a: uint32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: int8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpretq_s8_f32(a: float32x4_t) -> int8x16_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_f32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -50836,13 +43127,12 @@ pub fn vreinterpret_s8_u32(a: uint32x2_t) -> int8x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s16_u32(a: uint32x2_t) -> int16x4_t {
+pub fn vreinterpretq_s16_f32(a: float32x4_t) -> int16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_f32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -50858,17 +43148,12 @@ pub fn vreinterpret_s16_u32(a: uint32x2_t) -> int16x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s16_u32(a: uint32x2_t) -> int16x4_t {
-    let a: uint32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: int16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpretq_s32_f32(a: float32x4_t) -> int32x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_f32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -50884,13 +43169,12 @@ pub fn vreinterpret_s16_u32(a: uint32x2_t) -> int16x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s32_u32(a: uint32x2_t) -> int32x2_t {
+pub fn vreinterpretq_s64_f32(a: float32x4_t) -> int64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_f32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -50906,17 +43190,12 @@ pub fn vreinterpret_s32_u32(a: uint32x2_t) -> int32x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s32_u32(a: uint32x2_t) -> int32x2_t {
-    let a: uint32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: int32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpretq_u8_f32(a: float32x4_t) -> uint8x16_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_f32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -50932,13 +43211,12 @@ pub fn vreinterpret_s32_u32(a: uint32x2_t) -> int32x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s64_u32(a: uint32x2_t) -> int64x1_t {
+pub fn vreinterpretq_u16_f32(a: float32x4_t) -> uint16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_f32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -50954,14 +43232,12 @@ pub fn vreinterpret_s64_u32(a: uint32x2_t) -> int64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s64_u32(a: uint32x2_t) -> int64x1_t {
-    let a: uint32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
+pub fn vreinterpretq_u32_f32(a: float32x4_t) -> uint32x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_f32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -50977,13 +43253,12 @@ pub fn vreinterpret_s64_u32(a: uint32x2_t) -> int64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u8_u32(a: uint32x2_t) -> uint8x8_t {
+pub fn vreinterpretq_u64_f32(a: float32x4_t) -> uint64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_f32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -50999,17 +43274,12 @@ pub fn vreinterpret_u8_u32(a: uint32x2_t) -> uint8x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u8_u32(a: uint32x2_t) -> uint8x8_t {
-    let a: uint32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: uint8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpretq_p8_f32(a: float32x4_t) -> poly8x16_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_f32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51025,13 +43295,12 @@ pub fn vreinterpret_u8_u32(a: uint32x2_t) -> uint8x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u16_u32(a: uint32x2_t) -> uint16x4_t {
+pub fn vreinterpretq_p16_f32(a: float32x4_t) -> poly16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_s8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51047,17 +43316,12 @@ pub fn vreinterpret_u16_u32(a: uint32x2_t) -> uint16x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u16_u32(a: uint32x2_t) -> uint16x4_t {
-    let a: uint32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: uint16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpret_f32_s8(a: int8x8_t) -> float32x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_s8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51073,13 +43337,12 @@ pub fn vreinterpret_u16_u32(a: uint32x2_t) -> uint16x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u64_u32(a: uint32x2_t) -> uint64x1_t {
+pub fn vreinterpret_s16_s8(a: int8x8_t) -> int16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_s8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51095,14 +43358,12 @@ pub fn vreinterpret_u64_u32(a: uint32x2_t) -> uint64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u64_u32(a: uint32x2_t) -> uint64x1_t {
-    let a: uint32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
+pub fn vreinterpret_s32_s8(a: int8x8_t) -> int32x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_s8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51118,13 +43379,12 @@ pub fn vreinterpret_u64_u32(a: uint32x2_t) -> uint64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p8_u32(a: uint32x2_t) -> poly8x8_t {
+pub fn vreinterpret_s64_s8(a: int8x8_t) -> int64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_s8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51140,17 +43400,12 @@ pub fn vreinterpret_p8_u32(a: uint32x2_t) -> poly8x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p8_u32(a: uint32x2_t) -> poly8x8_t {
-    let a: uint32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: poly8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpret_u8_s8(a: int8x8_t) -> uint8x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_s8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51166,13 +43421,12 @@ pub fn vreinterpret_p8_u32(a: uint32x2_t) -> poly8x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p16_u32(a: uint32x2_t) -> poly16x4_t {
+pub fn vreinterpret_u16_s8(a: int8x8_t) -> uint16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_s8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51188,17 +43442,12 @@ pub fn vreinterpret_p16_u32(a: uint32x2_t) -> poly16x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p16_u32(a: uint32x2_t) -> poly16x4_t {
-    let a: uint32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: poly16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpret_u32_s8(a: int8x8_t) -> uint32x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_s8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51214,13 +43463,12 @@ pub fn vreinterpret_p16_u32(a: uint32x2_t) -> poly16x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_f32_u32(a: uint32x4_t) -> float32x4_t {
+pub fn vreinterpret_u64_s8(a: int8x8_t) -> uint64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_s8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51236,17 +43484,12 @@ pub fn vreinterpretq_f32_u32(a: uint32x4_t) -> float32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_f32_u32(a: uint32x4_t) -> float32x4_t {
-    let a: uint32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpret_p8_s8(a: int8x8_t) -> poly8x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_s8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51262,13 +43505,12 @@ pub fn vreinterpretq_f32_u32(a: uint32x4_t) -> float32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s8_u32(a: uint32x4_t) -> int8x16_t {
+pub fn vreinterpret_p16_s8(a: int8x8_t) -> poly16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_s8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51284,21 +43526,12 @@ pub fn vreinterpretq_s8_u32(a: uint32x4_t) -> int8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s8_u32(a: uint32x4_t) -> int8x16_t {
-    let a: uint32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
+pub fn vreinterpretq_f32_s8(a: int8x16_t) -> float32x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_s8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51314,13 +43547,12 @@ pub fn vreinterpretq_s8_u32(a: uint32x4_t) -> int8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s16_u32(a: uint32x4_t) -> int16x8_t {
+pub fn vreinterpretq_s16_s8(a: int8x16_t) -> int16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_s8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51336,17 +43568,12 @@ pub fn vreinterpretq_s16_u32(a: uint32x4_t) -> int16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s16_u32(a: uint32x4_t) -> int16x8_t {
-    let a: uint32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpretq_s32_s8(a: int8x16_t) -> int32x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_s8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51362,13 +43589,12 @@ pub fn vreinterpretq_s16_u32(a: uint32x4_t) -> int16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s32_u32(a: uint32x4_t) -> int32x4_t {
+pub fn vreinterpretq_s64_s8(a: int8x16_t) -> int64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_s8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51384,17 +43610,12 @@ pub fn vreinterpretq_s32_u32(a: uint32x4_t) -> int32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s32_u32(a: uint32x4_t) -> int32x4_t {
-    let a: uint32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpretq_u8_s8(a: int8x16_t) -> uint8x16_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_s8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51410,13 +43631,12 @@ pub fn vreinterpretq_s32_u32(a: uint32x4_t) -> int32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s64_u32(a: uint32x4_t) -> int64x2_t {
+pub fn vreinterpretq_u16_s8(a: int8x16_t) -> uint16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_s8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51432,17 +43652,12 @@ pub fn vreinterpretq_s64_u32(a: uint32x4_t) -> int64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s64_u32(a: uint32x4_t) -> int64x2_t {
-    let a: uint32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpretq_u32_s8(a: int8x16_t) -> uint32x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_s8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51458,13 +43673,12 @@ pub fn vreinterpretq_s64_u32(a: uint32x4_t) -> int64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u8_u32(a: uint32x4_t) -> uint8x16_t {
+pub fn vreinterpretq_u64_s8(a: int8x16_t) -> uint64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_s8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51480,21 +43694,12 @@ pub fn vreinterpretq_u8_u32(a: uint32x4_t) -> uint8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u8_u32(a: uint32x4_t) -> uint8x16_t {
-    let a: uint32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
+pub fn vreinterpretq_p8_s8(a: int8x16_t) -> poly8x16_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_s8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51510,13 +43715,12 @@ pub fn vreinterpretq_u8_u32(a: uint32x4_t) -> uint8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u16_u32(a: uint32x4_t) -> uint16x8_t {
+pub fn vreinterpretq_p16_s8(a: int8x16_t) -> poly16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_s16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51532,17 +43736,12 @@ pub fn vreinterpretq_u16_u32(a: uint32x4_t) -> uint16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u16_u32(a: uint32x4_t) -> uint16x8_t {
-    let a: uint32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpret_f32_s16(a: int16x4_t) -> float32x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_s16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51558,13 +43757,12 @@ pub fn vreinterpretq_u16_u32(a: uint32x4_t) -> uint16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u64_u32(a: uint32x4_t) -> uint64x2_t {
+pub fn vreinterpret_s8_s16(a: int16x4_t) -> int8x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_s16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51580,17 +43778,12 @@ pub fn vreinterpretq_u64_u32(a: uint32x4_t) -> uint64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u64_u32(a: uint32x4_t) -> uint64x2_t {
-    let a: uint32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpret_s32_s16(a: int16x4_t) -> int32x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_s16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51606,13 +43799,12 @@ pub fn vreinterpretq_u64_u32(a: uint32x4_t) -> uint64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p8_u32(a: uint32x4_t) -> poly8x16_t {
+pub fn vreinterpret_s64_s16(a: int16x4_t) -> int64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_s16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51628,21 +43820,12 @@ pub fn vreinterpretq_p8_u32(a: uint32x4_t) -> poly8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p8_u32(a: uint32x4_t) -> poly8x16_t {
-    let a: uint32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
+pub fn vreinterpret_u8_s16(a: int16x4_t) -> uint8x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_s16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51658,13 +43841,12 @@ pub fn vreinterpretq_p8_u32(a: uint32x4_t) -> poly8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p16_u32(a: uint32x4_t) -> poly16x8_t {
+pub fn vreinterpret_u16_s16(a: int16x4_t) -> uint16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_s16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51680,17 +43862,12 @@ pub fn vreinterpretq_p16_u32(a: uint32x4_t) -> poly16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p16_u32(a: uint32x4_t) -> poly16x8_t {
-    let a: uint32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpret_u32_s16(a: int16x4_t) -> uint32x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_s16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51706,13 +43883,12 @@ pub fn vreinterpretq_p16_u32(a: uint32x4_t) -> poly16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_f32_u64(a: uint64x1_t) -> float32x2_t {
+pub fn vreinterpret_u64_s16(a: int16x4_t) -> uint64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_s16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51728,16 +43904,12 @@ pub fn vreinterpret_f32_u64(a: uint64x1_t) -> float32x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_f32_u64(a: uint64x1_t) -> float32x2_t {
-    unsafe {
-        let ret_val: float32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpret_p8_s16(a: int16x4_t) -> poly8x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_s16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51753,13 +43925,12 @@ pub fn vreinterpret_f32_u64(a: uint64x1_t) -> float32x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s8_u64(a: uint64x1_t) -> int8x8_t {
+pub fn vreinterpret_p16_s16(a: int16x4_t) -> poly16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_s16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51775,16 +43946,12 @@ pub fn vreinterpret_s8_u64(a: uint64x1_t) -> int8x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s8_u64(a: uint64x1_t) -> int8x8_t {
-    unsafe {
-        let ret_val: int8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpretq_f32_s16(a: int16x8_t) -> float32x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_s16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51800,13 +43967,12 @@ pub fn vreinterpret_s8_u64(a: uint64x1_t) -> int8x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s16_u64(a: uint64x1_t) -> int16x4_t {
+pub fn vreinterpretq_s8_s16(a: int16x8_t) -> int8x16_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_s16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51822,16 +43988,12 @@ pub fn vreinterpret_s16_u64(a: uint64x1_t) -> int16x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s16_u64(a: uint64x1_t) -> int16x4_t {
-    unsafe {
-        let ret_val: int16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpretq_s32_s16(a: int16x8_t) -> int32x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_s16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51847,13 +44009,12 @@ pub fn vreinterpret_s16_u64(a: uint64x1_t) -> int16x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s32_u64(a: uint64x1_t) -> int32x2_t {
+pub fn vreinterpretq_s64_s16(a: int16x8_t) -> int64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_s16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51869,14 +44030,11 @@ pub fn vreinterpret_s32_u64(a: uint64x1_t) -> int32x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s32_u64(a: uint64x1_t) -> int32x2_t {
-    unsafe {
-        let ret_val: int32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpretq_u8_s16(a: int16x8_t) -> uint8x16_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_s16)"]
 #[inline]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
@@ -51893,13 +44051,12 @@ pub fn vreinterpret_s32_u64(a: uint64x1_t) -> int32x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s64_u64(a: uint64x1_t) -> int64x1_t {
+pub fn vreinterpretq_u16_s16(a: int16x8_t) -> uint16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_s16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51915,13 +44072,12 @@ pub fn vreinterpret_s64_u64(a: uint64x1_t) -> int64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u8_u64(a: uint64x1_t) -> uint8x8_t {
+pub fn vreinterpretq_u32_s16(a: int16x8_t) -> uint32x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_s16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51937,16 +44093,12 @@ pub fn vreinterpret_u8_u64(a: uint64x1_t) -> uint8x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u8_u64(a: uint64x1_t) -> uint8x8_t {
-    unsafe {
-        let ret_val: uint8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpretq_u64_s16(a: int16x8_t) -> uint64x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_s16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51962,13 +44114,12 @@ pub fn vreinterpret_u8_u64(a: uint64x1_t) -> uint8x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u16_u64(a: uint64x1_t) -> uint16x4_t {
+pub fn vreinterpretq_p8_s16(a: int16x8_t) -> poly8x16_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_s16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -51984,16 +44135,12 @@ pub fn vreinterpret_u16_u64(a: uint64x1_t) -> uint16x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u16_u64(a: uint64x1_t) -> uint16x4_t {
-    unsafe {
-        let ret_val: uint16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpretq_p16_s16(a: int16x8_t) -> poly16x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_s32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52009,13 +44156,12 @@ pub fn vreinterpret_u16_u64(a: uint64x1_t) -> uint16x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u32_u64(a: uint64x1_t) -> uint32x2_t {
+pub fn vreinterpret_f32_s32(a: int32x2_t) -> float32x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_s32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52031,16 +44177,12 @@ pub fn vreinterpret_u32_u64(a: uint64x1_t) -> uint32x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u32_u64(a: uint64x1_t) -> uint32x2_t {
-    unsafe {
-        let ret_val: uint32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpret_s8_s32(a: int32x2_t) -> int8x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_s32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52056,13 +44198,12 @@ pub fn vreinterpret_u32_u64(a: uint64x1_t) -> uint32x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p8_u64(a: uint64x1_t) -> poly8x8_t {
+pub fn vreinterpret_s16_s32(a: int32x2_t) -> int16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_s32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52078,16 +44219,12 @@ pub fn vreinterpret_p8_u64(a: uint64x1_t) -> poly8x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p8_u64(a: uint64x1_t) -> poly8x8_t {
-    unsafe {
-        let ret_val: poly8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpret_s64_s32(a: int32x2_t) -> int64x1_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_s32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52103,13 +44240,12 @@ pub fn vreinterpret_p8_u64(a: uint64x1_t) -> poly8x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p16_u64(a: uint64x1_t) -> poly16x4_t {
+pub fn vreinterpret_u8_s32(a: int32x2_t) -> uint8x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_s32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52125,16 +44261,12 @@ pub fn vreinterpret_p16_u64(a: uint64x1_t) -> poly16x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p16_u64(a: uint64x1_t) -> poly16x4_t {
-    unsafe {
-        let ret_val: poly16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpret_u16_s32(a: int32x2_t) -> uint16x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_s32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52150,13 +44282,12 @@ pub fn vreinterpret_p16_u64(a: uint64x1_t) -> poly16x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_f32_u64(a: uint64x2_t) -> float32x4_t {
+pub fn vreinterpret_u32_s32(a: int32x2_t) -> uint32x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_s32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52172,17 +44303,12 @@ pub fn vreinterpretq_f32_u64(a: uint64x2_t) -> float32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_f32_u64(a: uint64x2_t) -> float32x4_t {
-    let a: uint64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: float32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpret_u64_s32(a: int32x2_t) -> uint64x1_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_s32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52198,13 +44324,12 @@ pub fn vreinterpretq_f32_u64(a: uint64x2_t) -> float32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s8_u64(a: uint64x2_t) -> int8x16_t {
+pub fn vreinterpret_p8_s32(a: int32x2_t) -> poly8x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_s32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52220,21 +44345,12 @@ pub fn vreinterpretq_s8_u64(a: uint64x2_t) -> int8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s8_u64(a: uint64x2_t) -> int8x16_t {
-    let a: uint64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: int8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
+pub fn vreinterpret_p16_s32(a: int32x2_t) -> poly16x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_s32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52250,13 +44366,12 @@ pub fn vreinterpretq_s8_u64(a: uint64x2_t) -> int8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s16_u64(a: uint64x2_t) -> int16x8_t {
+pub fn vreinterpretq_f32_s32(a: int32x4_t) -> float32x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_s32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52272,17 +44387,12 @@ pub fn vreinterpretq_s16_u64(a: uint64x2_t) -> int16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s16_u64(a: uint64x2_t) -> int16x8_t {
-    let a: uint64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: int16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpretq_s8_s32(a: int32x4_t) -> int8x16_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_s32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52298,13 +44408,12 @@ pub fn vreinterpretq_s16_u64(a: uint64x2_t) -> int16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s32_u64(a: uint64x2_t) -> int32x4_t {
+pub fn vreinterpretq_s16_s32(a: int32x4_t) -> int16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_s32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52320,17 +44429,12 @@ pub fn vreinterpretq_s32_u64(a: uint64x2_t) -> int32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s32_u64(a: uint64x2_t) -> int32x4_t {
-    let a: uint64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: int32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpretq_s64_s32(a: int32x4_t) -> int64x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_s32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52346,13 +44450,12 @@ pub fn vreinterpretq_s32_u64(a: uint64x2_t) -> int32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s64_u64(a: uint64x2_t) -> int64x2_t {
+pub fn vreinterpretq_u8_s32(a: int32x4_t) -> uint8x16_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_s32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52368,17 +44471,12 @@ pub fn vreinterpretq_s64_u64(a: uint64x2_t) -> int64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s64_u64(a: uint64x2_t) -> int64x2_t {
-    let a: uint64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: int64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpretq_u16_s32(a: int32x4_t) -> uint16x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_s32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52394,13 +44492,12 @@ pub fn vreinterpretq_s64_u64(a: uint64x2_t) -> int64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u8_u64(a: uint64x2_t) -> uint8x16_t {
+pub fn vreinterpretq_u32_s32(a: int32x4_t) -> uint32x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_s32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52416,21 +44513,12 @@ pub fn vreinterpretq_u8_u64(a: uint64x2_t) -> uint8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u8_u64(a: uint64x2_t) -> uint8x16_t {
-    let a: uint64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: uint8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
+pub fn vreinterpretq_u64_s32(a: int32x4_t) -> uint64x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_s32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52446,13 +44534,12 @@ pub fn vreinterpretq_u8_u64(a: uint64x2_t) -> uint8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u16_u64(a: uint64x2_t) -> uint16x8_t {
+pub fn vreinterpretq_p8_s32(a: int32x4_t) -> poly8x16_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_s32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52468,17 +44555,12 @@ pub fn vreinterpretq_u16_u64(a: uint64x2_t) -> uint16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u16_u64(a: uint64x2_t) -> uint16x8_t {
-    let a: uint64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: uint16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpretq_p16_s32(a: int32x4_t) -> poly16x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_s64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52494,13 +44576,12 @@ pub fn vreinterpretq_u16_u64(a: uint64x2_t) -> uint16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u32_u64(a: uint64x2_t) -> uint32x4_t {
+pub fn vreinterpret_f32_s64(a: int64x1_t) -> float32x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_s64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52516,17 +44597,12 @@ pub fn vreinterpretq_u32_u64(a: uint64x2_t) -> uint32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u32_u64(a: uint64x2_t) -> uint32x4_t {
-    let a: uint64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: uint32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpret_s8_s64(a: int64x1_t) -> int8x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_s64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52542,13 +44618,12 @@ pub fn vreinterpretq_u32_u64(a: uint64x2_t) -> uint32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p8_u64(a: uint64x2_t) -> poly8x16_t {
+pub fn vreinterpret_s16_s64(a: int64x1_t) -> int16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_s64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52564,21 +44639,12 @@ pub fn vreinterpretq_p8_u64(a: uint64x2_t) -> poly8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p8_u64(a: uint64x2_t) -> poly8x16_t {
-    let a: uint64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: poly8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
+pub fn vreinterpret_s32_s64(a: int64x1_t) -> int32x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_s64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52594,13 +44660,12 @@ pub fn vreinterpretq_p8_u64(a: uint64x2_t) -> poly8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p16_u64(a: uint64x2_t) -> poly16x8_t {
+pub fn vreinterpret_u8_s64(a: int64x1_t) -> uint8x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_s64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52616,17 +44681,12 @@ pub fn vreinterpretq_p16_u64(a: uint64x2_t) -> poly16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p16_u64(a: uint64x2_t) -> poly16x8_t {
-    let a: uint64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: poly16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpret_u16_s64(a: int64x1_t) -> uint16x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_s64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52642,13 +44702,12 @@ pub fn vreinterpretq_p16_u64(a: uint64x2_t) -> poly16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_f32_p8(a: poly8x8_t) -> float32x2_t {
+pub fn vreinterpret_u32_s64(a: int64x1_t) -> uint32x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_s64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52664,17 +44723,12 @@ pub fn vreinterpret_f32_p8(a: poly8x8_t) -> float32x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_f32_p8(a: poly8x8_t) -> float32x2_t {
-    let a: poly8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpret_u64_s64(a: int64x1_t) -> uint64x1_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_s64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52690,13 +44744,12 @@ pub fn vreinterpret_f32_p8(a: poly8x8_t) -> float32x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s8_p8(a: poly8x8_t) -> int8x8_t {
+pub fn vreinterpret_p8_s64(a: int64x1_t) -> poly8x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_s64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52712,17 +44765,12 @@ pub fn vreinterpret_s8_p8(a: poly8x8_t) -> int8x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s8_p8(a: poly8x8_t) -> int8x8_t {
-    let a: poly8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpret_p16_s64(a: int64x1_t) -> poly16x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_s64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52738,13 +44786,12 @@ pub fn vreinterpret_s8_p8(a: poly8x8_t) -> int8x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s16_p8(a: poly8x8_t) -> int16x4_t {
+pub fn vreinterpretq_f32_s64(a: int64x2_t) -> float32x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_s64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52760,17 +44807,12 @@ pub fn vreinterpret_s16_p8(a: poly8x8_t) -> int16x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s16_p8(a: poly8x8_t) -> int16x4_t {
-    let a: poly8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpretq_s8_s64(a: int64x2_t) -> int8x16_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_s64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52786,13 +44828,12 @@ pub fn vreinterpret_s16_p8(a: poly8x8_t) -> int16x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s32_p8(a: poly8x8_t) -> int32x2_t {
+pub fn vreinterpretq_s16_s64(a: int64x2_t) -> int16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_s64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52808,17 +44849,12 @@ pub fn vreinterpret_s32_p8(a: poly8x8_t) -> int32x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s32_p8(a: poly8x8_t) -> int32x2_t {
-    let a: poly8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpretq_s32_s64(a: int64x2_t) -> int32x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_s64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52834,13 +44870,12 @@ pub fn vreinterpret_s32_p8(a: poly8x8_t) -> int32x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s64_p8(a: poly8x8_t) -> int64x1_t {
+pub fn vreinterpretq_u8_s64(a: int64x2_t) -> uint8x16_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_s64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52856,14 +44891,12 @@ pub fn vreinterpret_s64_p8(a: poly8x8_t) -> int64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s64_p8(a: poly8x8_t) -> int64x1_t {
-    let a: poly8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
+pub fn vreinterpretq_u16_s64(a: int64x2_t) -> uint16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_s64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52879,13 +44912,12 @@ pub fn vreinterpret_s64_p8(a: poly8x8_t) -> int64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u8_p8(a: poly8x8_t) -> uint8x8_t {
+pub fn vreinterpretq_u32_s64(a: int64x2_t) -> uint32x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_s64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52901,17 +44933,12 @@ pub fn vreinterpret_u8_p8(a: poly8x8_t) -> uint8x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u8_p8(a: poly8x8_t) -> uint8x8_t {
-    let a: poly8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpretq_u64_s64(a: int64x2_t) -> uint64x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_s64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52927,13 +44954,12 @@ pub fn vreinterpret_u8_p8(a: poly8x8_t) -> uint8x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u16_p8(a: poly8x8_t) -> uint16x4_t {
+pub fn vreinterpretq_p8_s64(a: int64x2_t) -> poly8x16_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_s64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52949,17 +44975,12 @@ pub fn vreinterpret_u16_p8(a: poly8x8_t) -> uint16x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u16_p8(a: poly8x8_t) -> uint16x4_t {
-    let a: poly8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpretq_p16_s64(a: int64x2_t) -> poly16x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_u8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52975,13 +44996,12 @@ pub fn vreinterpret_u16_p8(a: poly8x8_t) -> uint16x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u32_p8(a: poly8x8_t) -> uint32x2_t {
+pub fn vreinterpret_f32_u8(a: uint8x8_t) -> float32x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_u8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -52997,17 +45017,12 @@ pub fn vreinterpret_u32_p8(a: poly8x8_t) -> uint32x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u32_p8(a: poly8x8_t) -> uint32x2_t {
-    let a: poly8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpret_s8_u8(a: uint8x8_t) -> int8x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_u8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53023,13 +45038,12 @@ pub fn vreinterpret_u32_p8(a: poly8x8_t) -> uint32x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u64_p8(a: poly8x8_t) -> uint64x1_t {
+pub fn vreinterpret_s16_u8(a: uint8x8_t) -> int16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_u8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53045,14 +45059,12 @@ pub fn vreinterpret_u64_p8(a: poly8x8_t) -> uint64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u64_p8(a: poly8x8_t) -> uint64x1_t {
-    let a: poly8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
+pub fn vreinterpret_s32_u8(a: uint8x8_t) -> int32x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_u8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53068,13 +45080,12 @@ pub fn vreinterpret_u64_p8(a: poly8x8_t) -> uint64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p16_p8(a: poly8x8_t) -> poly16x4_t {
+pub fn vreinterpret_s64_u8(a: uint8x8_t) -> int64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_u8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53090,17 +45101,12 @@ pub fn vreinterpret_p16_p8(a: poly8x8_t) -> poly16x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p16_p8(a: poly8x8_t) -> poly16x4_t {
-    let a: poly8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpret_u16_u8(a: uint8x8_t) -> uint16x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_u8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53116,13 +45122,12 @@ pub fn vreinterpret_p16_p8(a: poly8x8_t) -> poly16x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_f32_p8(a: poly8x16_t) -> float32x4_t {
+pub fn vreinterpret_u32_u8(a: uint8x8_t) -> uint32x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_u8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53138,18 +45143,12 @@ pub fn vreinterpretq_f32_p8(a: poly8x16_t) -> float32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_f32_p8(a: poly8x16_t) -> float32x4_t {
-    let a: poly8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpret_u64_u8(a: uint8x8_t) -> uint64x1_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_u8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53165,13 +45164,12 @@ pub fn vreinterpretq_f32_p8(a: poly8x16_t) -> float32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s8_p8(a: poly8x16_t) -> int8x16_t {
+pub fn vreinterpret_p8_u8(a: uint8x8_t) -> poly8x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_u8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53187,22 +45185,12 @@ pub fn vreinterpretq_s8_p8(a: poly8x16_t) -> int8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s8_p8(a: poly8x16_t) -> int8x16_t {
-    let a: poly8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
+pub fn vreinterpret_p16_u8(a: uint8x8_t) -> poly16x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_u8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53218,13 +45206,12 @@ pub fn vreinterpretq_s8_p8(a: poly8x16_t) -> int8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s16_p8(a: poly8x16_t) -> int16x8_t {
+pub fn vreinterpretq_f32_u8(a: uint8x16_t) -> float32x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_u8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53240,18 +45227,12 @@ pub fn vreinterpretq_s16_p8(a: poly8x16_t) -> int16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s16_p8(a: poly8x16_t) -> int16x8_t {
-    let a: poly8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpretq_s8_u8(a: uint8x16_t) -> int8x16_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_u8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53267,13 +45248,12 @@ pub fn vreinterpretq_s16_p8(a: poly8x16_t) -> int16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s32_p8(a: poly8x16_t) -> int32x4_t {
+pub fn vreinterpretq_s16_u8(a: uint8x16_t) -> int16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_u8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53289,18 +45269,12 @@ pub fn vreinterpretq_s32_p8(a: poly8x16_t) -> int32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s32_p8(a: poly8x16_t) -> int32x4_t {
-    let a: poly8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpretq_s32_u8(a: uint8x16_t) -> int32x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_u8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53316,13 +45290,12 @@ pub fn vreinterpretq_s32_p8(a: poly8x16_t) -> int32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s64_p8(a: poly8x16_t) -> int64x2_t {
+pub fn vreinterpretq_s64_u8(a: uint8x16_t) -> int64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_u8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53338,18 +45311,12 @@ pub fn vreinterpretq_s64_p8(a: poly8x16_t) -> int64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s64_p8(a: poly8x16_t) -> int64x2_t {
-    let a: poly8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpretq_u16_u8(a: uint8x16_t) -> uint16x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_u8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53365,13 +45332,12 @@ pub fn vreinterpretq_s64_p8(a: poly8x16_t) -> int64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u8_p8(a: poly8x16_t) -> uint8x16_t {
+pub fn vreinterpretq_u32_u8(a: uint8x16_t) -> uint32x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_u8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53387,22 +45353,12 @@ pub fn vreinterpretq_u8_p8(a: poly8x16_t) -> uint8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u8_p8(a: poly8x16_t) -> uint8x16_t {
-    let a: poly8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
+pub fn vreinterpretq_u64_u8(a: uint8x16_t) -> uint64x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_u8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53418,13 +45374,12 @@ pub fn vreinterpretq_u8_p8(a: poly8x16_t) -> uint8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u16_p8(a: poly8x16_t) -> uint16x8_t {
+pub fn vreinterpretq_p8_u8(a: uint8x16_t) -> poly8x16_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_u8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53440,18 +45395,12 @@ pub fn vreinterpretq_u16_p8(a: poly8x16_t) -> uint16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u16_p8(a: poly8x16_t) -> uint16x8_t {
-    let a: poly8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpretq_p16_u8(a: uint8x16_t) -> poly16x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_u16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53467,13 +45416,12 @@ pub fn vreinterpretq_u16_p8(a: poly8x16_t) -> uint16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u32_p8(a: poly8x16_t) -> uint32x4_t {
+pub fn vreinterpret_f32_u16(a: uint16x4_t) -> float32x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_u16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53489,18 +45437,12 @@ pub fn vreinterpretq_u32_p8(a: poly8x16_t) -> uint32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u32_p8(a: poly8x16_t) -> uint32x4_t {
-    let a: poly8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpret_s8_u16(a: uint16x4_t) -> int8x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_u16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53516,13 +45458,12 @@ pub fn vreinterpretq_u32_p8(a: poly8x16_t) -> uint32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u64_p8(a: poly8x16_t) -> uint64x2_t {
+pub fn vreinterpret_s16_u16(a: uint16x4_t) -> int16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_u16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53538,18 +45479,12 @@ pub fn vreinterpretq_u64_p8(a: poly8x16_t) -> uint64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u64_p8(a: poly8x16_t) -> uint64x2_t {
-    let a: poly8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpret_s32_u16(a: uint16x4_t) -> int32x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_u16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53565,13 +45500,12 @@ pub fn vreinterpretq_u64_p8(a: poly8x16_t) -> uint64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p16_p8(a: poly8x16_t) -> poly16x8_t {
+pub fn vreinterpret_s64_u16(a: uint16x4_t) -> int64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_u16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53587,18 +45521,12 @@ pub fn vreinterpretq_p16_p8(a: poly8x16_t) -> poly16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p16_p8(a: poly8x16_t) -> poly16x8_t {
-    let a: poly8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpret_u8_u16(a: uint16x4_t) -> uint8x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_u16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53614,13 +45542,12 @@ pub fn vreinterpretq_p16_p8(a: poly8x16_t) -> poly16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_f32_p16(a: poly16x4_t) -> float32x2_t {
+pub fn vreinterpret_u32_u16(a: uint16x4_t) -> uint32x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_u16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53636,17 +45563,12 @@ pub fn vreinterpret_f32_p16(a: poly16x4_t) -> float32x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_f32_p16(a: poly16x4_t) -> float32x2_t {
-    let a: poly16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpret_u64_u16(a: uint16x4_t) -> uint64x1_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_u16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53662,13 +45584,12 @@ pub fn vreinterpret_f32_p16(a: poly16x4_t) -> float32x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s8_p16(a: poly16x4_t) -> int8x8_t {
+pub fn vreinterpret_p8_u16(a: uint16x4_t) -> poly8x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_u16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53684,17 +45605,12 @@ pub fn vreinterpret_s8_p16(a: poly16x4_t) -> int8x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s8_p16(a: poly16x4_t) -> int8x8_t {
-    let a: poly16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpret_p16_u16(a: uint16x4_t) -> poly16x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_u16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53710,13 +45626,12 @@ pub fn vreinterpret_s8_p16(a: poly16x4_t) -> int8x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s16_p16(a: poly16x4_t) -> int16x4_t {
+pub fn vreinterpretq_f32_u16(a: uint16x8_t) -> float32x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_u16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53732,17 +45647,12 @@ pub fn vreinterpret_s16_p16(a: poly16x4_t) -> int16x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s16_p16(a: poly16x4_t) -> int16x4_t {
-    let a: poly16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpretq_s8_u16(a: uint16x8_t) -> int8x16_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_u16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53758,13 +45668,12 @@ pub fn vreinterpret_s16_p16(a: poly16x4_t) -> int16x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s32_p16(a: poly16x4_t) -> int32x2_t {
+pub fn vreinterpretq_s16_u16(a: uint16x8_t) -> int16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_u16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53780,17 +45689,12 @@ pub fn vreinterpret_s32_p16(a: poly16x4_t) -> int32x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s32_p16(a: poly16x4_t) -> int32x2_t {
-    let a: poly16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpretq_s32_u16(a: uint16x8_t) -> int32x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_u16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53806,13 +45710,12 @@ pub fn vreinterpret_s32_p16(a: poly16x4_t) -> int32x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s64_p16(a: poly16x4_t) -> int64x1_t {
+pub fn vreinterpretq_s64_u16(a: uint16x8_t) -> int64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_u16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53828,14 +45731,12 @@ pub fn vreinterpret_s64_p16(a: poly16x4_t) -> int64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s64_p16(a: poly16x4_t) -> int64x1_t {
-    let a: poly16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
+pub fn vreinterpretq_u8_u16(a: uint16x8_t) -> uint8x16_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_u16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53851,13 +45752,12 @@ pub fn vreinterpret_s64_p16(a: poly16x4_t) -> int64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u8_p16(a: poly16x4_t) -> uint8x8_t {
+pub fn vreinterpretq_u32_u16(a: uint16x8_t) -> uint32x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_u16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53873,17 +45773,12 @@ pub fn vreinterpret_u8_p16(a: poly16x4_t) -> uint8x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u8_p16(a: poly16x4_t) -> uint8x8_t {
-    let a: poly16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpretq_u64_u16(a: uint16x8_t) -> uint64x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_u16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53899,13 +45794,12 @@ pub fn vreinterpret_u8_p16(a: poly16x4_t) -> uint8x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u16_p16(a: poly16x4_t) -> uint16x4_t {
+pub fn vreinterpretq_p8_u16(a: uint16x8_t) -> poly8x16_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_u16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53921,17 +45815,12 @@ pub fn vreinterpret_u16_p16(a: poly16x4_t) -> uint16x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u16_p16(a: poly16x4_t) -> uint16x4_t {
-    let a: poly16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpretq_p16_u16(a: uint16x8_t) -> poly16x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_u32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53947,13 +45836,12 @@ pub fn vreinterpret_u16_p16(a: poly16x4_t) -> uint16x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u32_p16(a: poly16x4_t) -> uint32x2_t {
+pub fn vreinterpret_f32_u32(a: uint32x2_t) -> float32x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_u32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53969,17 +45857,12 @@ pub fn vreinterpret_u32_p16(a: poly16x4_t) -> uint32x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u32_p16(a: poly16x4_t) -> uint32x2_t {
-    let a: poly16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpret_s8_u32(a: uint32x2_t) -> int8x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_u32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -53995,13 +45878,12 @@ pub fn vreinterpret_u32_p16(a: poly16x4_t) -> uint32x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u64_p16(a: poly16x4_t) -> uint64x1_t {
+pub fn vreinterpret_s16_u32(a: uint32x2_t) -> int16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_u32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -54017,14 +45899,12 @@ pub fn vreinterpret_u64_p16(a: poly16x4_t) -> uint64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u64_p16(a: poly16x4_t) -> uint64x1_t {
-    let a: poly16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
+pub fn vreinterpret_s32_u32(a: uint32x2_t) -> int32x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_u32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -54040,13 +45920,12 @@ pub fn vreinterpret_u64_p16(a: poly16x4_t) -> uint64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p8_p16(a: poly16x4_t) -> poly8x8_t {
+pub fn vreinterpret_s64_u32(a: uint32x2_t) -> int64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_u32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -54062,17 +45941,12 @@ pub fn vreinterpret_p8_p16(a: poly16x4_t) -> poly8x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p8_p16(a: poly16x4_t) -> poly8x8_t {
-    let a: poly16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpret_u8_u32(a: uint32x2_t) -> uint8x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_u32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -54088,13 +45962,12 @@ pub fn vreinterpret_p8_p16(a: poly16x4_t) -> poly8x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_f32_p16(a: poly16x8_t) -> float32x4_t {
+pub fn vreinterpret_u16_u32(a: uint32x2_t) -> uint16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_u32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -54110,17 +45983,12 @@ pub fn vreinterpretq_f32_p16(a: poly16x8_t) -> float32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_f32_p16(a: poly16x8_t) -> float32x4_t {
-    let a: poly16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: float32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpret_u64_u32(a: uint32x2_t) -> uint64x1_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_u32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -54136,13 +46004,12 @@ pub fn vreinterpretq_f32_p16(a: poly16x8_t) -> float32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s8_p16(a: poly16x8_t) -> int8x16_t {
+pub fn vreinterpret_p8_u32(a: uint32x2_t) -> poly8x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_u32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -54158,21 +46025,12 @@ pub fn vreinterpretq_s8_p16(a: poly16x8_t) -> int8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s8_p16(a: poly16x8_t) -> int8x16_t {
-    let a: poly16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
+pub fn vreinterpret_p16_u32(a: uint32x2_t) -> poly16x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_u32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -54188,13 +46046,12 @@ pub fn vreinterpretq_s8_p16(a: poly16x8_t) -> int8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s16_p16(a: poly16x8_t) -> int16x8_t {
+pub fn vreinterpretq_f32_u32(a: uint32x4_t) -> float32x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_u32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -54210,17 +46067,12 @@ pub fn vreinterpretq_s16_p16(a: poly16x8_t) -> int16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s16_p16(a: poly16x8_t) -> int16x8_t {
-    let a: poly16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpretq_s8_u32(a: uint32x4_t) -> int8x16_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_u32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -54236,13 +46088,12 @@ pub fn vreinterpretq_s16_p16(a: poly16x8_t) -> int16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s32_p16(a: poly16x8_t) -> int32x4_t {
+pub fn vreinterpretq_s16_u32(a: uint32x4_t) -> int16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_u32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -54258,17 +46109,12 @@ pub fn vreinterpretq_s32_p16(a: poly16x8_t) -> int32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s32_p16(a: poly16x8_t) -> int32x4_t {
-    let a: poly16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpretq_s32_u32(a: uint32x4_t) -> int32x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_u32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -54284,13 +46130,12 @@ pub fn vreinterpretq_s32_p16(a: poly16x8_t) -> int32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s64_p16(a: poly16x8_t) -> int64x2_t {
+pub fn vreinterpretq_s64_u32(a: uint32x4_t) -> int64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_u32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -54306,17 +46151,12 @@ pub fn vreinterpretq_s64_p16(a: poly16x8_t) -> int64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s64_p16(a: poly16x8_t) -> int64x2_t {
-    let a: poly16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: int64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpretq_u8_u32(a: uint32x4_t) -> uint8x16_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_u32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -54332,13 +46172,12 @@ pub fn vreinterpretq_s64_p16(a: poly16x8_t) -> int64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u8_p16(a: poly16x8_t) -> uint8x16_t {
+pub fn vreinterpretq_u16_u32(a: uint32x4_t) -> uint16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_u32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -54354,21 +46193,12 @@ pub fn vreinterpretq_u8_p16(a: poly16x8_t) -> uint8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u8_p16(a: poly16x8_t) -> uint8x16_t {
-    let a: poly16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
+pub fn vreinterpretq_u64_u32(a: uint32x4_t) -> uint64x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_u32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -54384,13 +46214,12 @@ pub fn vreinterpretq_u8_p16(a: poly16x8_t) -> uint8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u16_p16(a: poly16x8_t) -> uint16x8_t {
+pub fn vreinterpretq_p8_u32(a: uint32x4_t) -> poly8x16_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_u32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -54406,17 +46235,12 @@ pub fn vreinterpretq_u16_p16(a: poly16x8_t) -> uint16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u16_p16(a: poly16x8_t) -> uint16x8_t {
-    let a: poly16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpretq_p16_u32(a: uint32x4_t) -> poly16x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_u64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -54432,13 +46256,12 @@ pub fn vreinterpretq_u16_p16(a: poly16x8_t) -> uint16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u32_p16(a: poly16x8_t) -> uint32x4_t {
+pub fn vreinterpret_f32_u64(a: uint64x1_t) -> float32x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_u64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -54454,17 +46277,12 @@ pub fn vreinterpretq_u32_p16(a: poly16x8_t) -> uint32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u32_p16(a: poly16x8_t) -> uint32x4_t {
-    let a: poly16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpret_s8_u64(a: uint64x1_t) -> int8x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_u64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -54480,13 +46298,12 @@ pub fn vreinterpretq_u32_p16(a: poly16x8_t) -> uint32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u64_p16(a: poly16x8_t) -> uint64x2_t {
+pub fn vreinterpret_s16_u64(a: uint64x1_t) -> int16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_u64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -54502,17 +46319,12 @@ pub fn vreinterpretq_u64_p16(a: poly16x8_t) -> uint64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u64_p16(a: poly16x8_t) -> uint64x2_t {
-    let a: poly16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: uint64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpret_s32_u64(a: uint64x1_t) -> int32x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_u64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -54528,13 +46340,12 @@ pub fn vreinterpretq_u64_p16(a: poly16x8_t) -> uint64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p8_p16(a: poly16x8_t) -> poly8x16_t {
+pub fn vreinterpret_s64_u64(a: uint64x1_t) -> int64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_u64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -54550,23 +46361,14 @@ pub fn vreinterpretq_p8_p16(a: poly16x8_t) -> poly8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p8_p16(a: poly16x8_t) -> poly8x16_t {
-    let a: poly16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
+pub fn vreinterpret_u8_u64(a: uint64x1_t) -> uint8x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_p128)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_u64)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -54580,15 +46382,14 @@ pub fn vreinterpretq_p8_p16(a: poly16x8_t) -> poly8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s8_p128(a: p128) -> int8x16_t {
+pub fn vreinterpret_u16_u64(a: uint64x1_t) -> uint16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_p128)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_u64)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -54602,22 +46403,14 @@ pub fn vreinterpretq_s8_p128(a: p128) -> int8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s8_p128(a: p128) -> int8x16_t {
-    unsafe {
-        let ret_val: int8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
+pub fn vreinterpret_u32_u64(a: uint64x1_t) -> uint32x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_p128)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_u64)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -54631,15 +46424,14 @@ pub fn vreinterpretq_s8_p128(a: p128) -> int8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s16_p128(a: p128) -> int16x8_t {
+pub fn vreinterpret_p8_u64(a: uint64x1_t) -> poly8x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_p128)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_u64)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -54653,18 +46445,14 @@ pub fn vreinterpretq_s16_p128(a: p128) -> int16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s16_p128(a: p128) -> int16x8_t {
-    unsafe {
-        let ret_val: int16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpret_p16_u64(a: uint64x1_t) -> poly16x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_p128)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_u64)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -54678,15 +46466,14 @@ pub fn vreinterpretq_s16_p128(a: p128) -> int16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s32_p128(a: p128) -> int32x4_t {
+pub fn vreinterpretq_f32_u64(a: uint64x2_t) -> float32x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_p128)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_u64)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -54700,18 +46487,14 @@ pub fn vreinterpretq_s32_p128(a: p128) -> int32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s32_p128(a: p128) -> int32x4_t {
-    unsafe {
-        let ret_val: int32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpretq_s8_u64(a: uint64x2_t) -> int8x16_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_p128)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_u64)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -54725,15 +46508,14 @@ pub fn vreinterpretq_s32_p128(a: p128) -> int32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s64_p128(a: p128) -> int64x2_t {
+pub fn vreinterpretq_s16_u64(a: uint64x2_t) -> int16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_p128)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_u64)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -54747,18 +46529,14 @@ pub fn vreinterpretq_s64_p128(a: p128) -> int64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s64_p128(a: p128) -> int64x2_t {
-    unsafe {
-        let ret_val: int64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpretq_s32_u64(a: uint64x2_t) -> int32x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_p128)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_u64)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -54772,15 +46550,14 @@ pub fn vreinterpretq_s64_p128(a: p128) -> int64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u8_p128(a: p128) -> uint8x16_t {
+pub fn vreinterpretq_s64_u64(a: uint64x2_t) -> int64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_p128)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_u64)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -54794,22 +46571,14 @@ pub fn vreinterpretq_u8_p128(a: p128) -> uint8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u8_p128(a: p128) -> uint8x16_t {
-    unsafe {
-        let ret_val: uint8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
+pub fn vreinterpretq_u8_u64(a: uint64x2_t) -> uint8x16_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_p128)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_u64)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -54823,15 +46592,14 @@ pub fn vreinterpretq_u8_p128(a: p128) -> uint8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u16_p128(a: p128) -> uint16x8_t {
+pub fn vreinterpretq_u16_u64(a: uint64x2_t) -> uint16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_p128)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_u64)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -54845,18 +46613,14 @@ pub fn vreinterpretq_u16_p128(a: p128) -> uint16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u16_p128(a: p128) -> uint16x8_t {
-    unsafe {
-        let ret_val: uint16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpretq_u32_u64(a: uint64x2_t) -> uint32x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_p128)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_u64)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -54870,15 +46634,14 @@ pub fn vreinterpretq_u16_p128(a: p128) -> uint16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u32_p128(a: p128) -> uint32x4_t {
+pub fn vreinterpretq_p8_u64(a: uint64x2_t) -> poly8x16_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_p128)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_u64)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -54892,18 +46655,14 @@ pub fn vreinterpretq_u32_p128(a: p128) -> uint32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u32_p128(a: p128) -> uint32x4_t {
-    unsafe {
-        let ret_val: uint32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpretq_p16_u64(a: uint64x2_t) -> poly16x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_p128)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_p8)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -54917,15 +46676,14 @@ pub fn vreinterpretq_u32_p128(a: p128) -> uint32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u64_p128(a: p128) -> uint64x2_t {
+pub fn vreinterpret_f32_p8(a: poly8x8_t) -> float32x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_p128)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_p8)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -54939,18 +46697,14 @@ pub fn vreinterpretq_u64_p128(a: p128) -> uint64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u64_p128(a: p128) -> uint64x2_t {
-    unsafe {
-        let ret_val: uint64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpret_s8_p8(a: poly8x8_t) -> int8x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_p128)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_p8)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -54964,15 +46718,14 @@ pub fn vreinterpretq_u64_p128(a: p128) -> uint64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p8_p128(a: p128) -> poly8x16_t {
+pub fn vreinterpret_s16_p8(a: poly8x8_t) -> int16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_p128)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_p8)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -54986,22 +46739,14 @@ pub fn vreinterpretq_p8_p128(a: p128) -> poly8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p8_p128(a: p128) -> poly8x16_t {
-    unsafe {
-        let ret_val: poly8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
+pub fn vreinterpret_s32_p8(a: poly8x8_t) -> int32x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_p128)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_p8)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55015,15 +46760,14 @@ pub fn vreinterpretq_p8_p128(a: p128) -> poly8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p16_p128(a: p128) -> poly16x8_t {
+pub fn vreinterpret_s64_p8(a: poly8x8_t) -> int64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_p128)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_p8)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55037,18 +46781,14 @@ pub fn vreinterpretq_p16_p128(a: p128) -> poly16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p16_p128(a: p128) -> poly16x8_t {
-    unsafe {
-        let ret_val: poly16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpret_u8_p8(a: poly8x8_t) -> uint8x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_p128)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_p8)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55062,15 +46802,14 @@ pub fn vreinterpretq_p16_p128(a: p128) -> poly16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p64_p128(a: p128) -> poly64x2_t {
+pub fn vreinterpret_u16_p8(a: poly8x8_t) -> uint16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_p128)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_p8)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55084,18 +46823,14 @@ pub fn vreinterpretq_p64_p128(a: p128) -> poly64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p64_p128(a: p128) -> poly64x2_t {
-    unsafe {
-        let ret_val: poly64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpret_u32_p8(a: poly8x8_t) -> uint32x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_s8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_p8)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55109,15 +46844,14 @@ pub fn vreinterpretq_p64_p128(a: p128) -> poly64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p64_s8(a: int8x8_t) -> poly64x1_t {
+pub fn vreinterpret_u64_p8(a: poly8x8_t) -> uint64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_s8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_p8)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55131,16 +46865,14 @@ pub fn vreinterpret_p64_s8(a: int8x8_t) -> poly64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p64_s8(a: int8x8_t) -> poly64x1_t {
-    let a: int8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
+pub fn vreinterpret_p16_p8(a: poly8x8_t) -> poly16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_s8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_p8)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55154,15 +46886,14 @@ pub fn vreinterpret_p64_s8(a: int8x8_t) -> poly64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p128_s8(a: int8x16_t) -> p128 {
+pub fn vreinterpretq_f32_p8(a: poly8x16_t) -> float32x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_s8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_p8)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55176,17 +46907,14 @@ pub fn vreinterpretq_p128_s8(a: int8x16_t) -> p128 {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p128_s8(a: int8x16_t) -> p128 {
-    let a: int8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
+pub fn vreinterpretq_s8_p8(a: poly8x16_t) -> int8x16_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_s8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_p8)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55200,15 +46928,14 @@ pub fn vreinterpretq_p128_s8(a: int8x16_t) -> p128 {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p64_s8(a: int8x16_t) -> poly64x2_t {
+pub fn vreinterpretq_s16_p8(a: poly8x16_t) -> int16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_s8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_p8)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55222,20 +46949,14 @@ pub fn vreinterpretq_p64_s8(a: int8x16_t) -> poly64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p64_s8(a: int8x16_t) -> poly64x2_t {
-    let a: int8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpretq_s32_p8(a: poly8x16_t) -> int32x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_s16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_p8)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55249,15 +46970,14 @@ pub fn vreinterpretq_p64_s8(a: int8x16_t) -> poly64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p64_s16(a: int16x4_t) -> poly64x1_t {
+pub fn vreinterpretq_s64_p8(a: poly8x16_t) -> int64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_s16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_p8)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55271,16 +46991,14 @@ pub fn vreinterpret_p64_s16(a: int16x4_t) -> poly64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p64_s16(a: int16x4_t) -> poly64x1_t {
-    let a: int16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
+pub fn vreinterpretq_u8_p8(a: poly8x16_t) -> uint8x16_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_s16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_p8)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55294,15 +47012,14 @@ pub fn vreinterpret_p64_s16(a: int16x4_t) -> poly64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p128_s16(a: int16x8_t) -> p128 {
+pub fn vreinterpretq_u16_p8(a: poly8x16_t) -> uint16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_s16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_p8)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55316,16 +47033,14 @@ pub fn vreinterpretq_p128_s16(a: int16x8_t) -> p128 {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p128_s16(a: int16x8_t) -> p128 {
-    let a: int16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
+pub fn vreinterpretq_u32_p8(a: poly8x16_t) -> uint32x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_s16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_p8)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55339,15 +47054,14 @@ pub fn vreinterpretq_p128_s16(a: int16x8_t) -> p128 {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p64_s16(a: int16x8_t) -> poly64x2_t {
+pub fn vreinterpretq_u64_p8(a: poly8x16_t) -> uint64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_s16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_p8)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55361,19 +47075,14 @@ pub fn vreinterpretq_p64_s16(a: int16x8_t) -> poly64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p64_s16(a: int16x8_t) -> poly64x2_t {
-    let a: int16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpretq_p16_p8(a: poly8x16_t) -> poly16x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_s32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_f32_p16)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55387,15 +47096,14 @@ pub fn vreinterpretq_p64_s16(a: int16x8_t) -> poly64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p64_s32(a: int32x2_t) -> poly64x1_t {
+pub fn vreinterpret_f32_p16(a: poly16x4_t) -> float32x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_s32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_p16)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55409,16 +47117,14 @@ pub fn vreinterpret_p64_s32(a: int32x2_t) -> poly64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p64_s32(a: int32x2_t) -> poly64x1_t {
-    let a: int32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
+pub fn vreinterpret_s8_p16(a: poly16x4_t) -> int8x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_s32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_p16)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55432,15 +47138,14 @@ pub fn vreinterpret_p64_s32(a: int32x2_t) -> poly64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p128_s32(a: int32x4_t) -> p128 {
+pub fn vreinterpret_s16_p16(a: poly16x4_t) -> int16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_s32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_p16)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55454,16 +47159,14 @@ pub fn vreinterpretq_p128_s32(a: int32x4_t) -> p128 {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p128_s32(a: int32x4_t) -> p128 {
-    let a: int32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
+pub fn vreinterpret_s32_p16(a: poly16x4_t) -> int32x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_s32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s64_p16)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55477,15 +47180,14 @@ pub fn vreinterpretq_p128_s32(a: int32x4_t) -> p128 {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p64_s32(a: int32x4_t) -> poly64x2_t {
+pub fn vreinterpret_s64_p16(a: poly16x4_t) -> int64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_s32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_p16)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55499,19 +47201,14 @@ pub fn vreinterpretq_p64_s32(a: int32x4_t) -> poly64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p64_s32(a: int32x4_t) -> poly64x2_t {
-    let a: int32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpret_u8_p16(a: poly16x4_t) -> uint8x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_s64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_p16)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55525,15 +47222,14 @@ pub fn vreinterpretq_p64_s32(a: int32x4_t) -> poly64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p128_s64(a: int64x2_t) -> p128 {
+pub fn vreinterpret_u16_p16(a: poly16x4_t) -> uint16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_s64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_p16)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55547,16 +47243,14 @@ pub fn vreinterpretq_p128_s64(a: int64x2_t) -> p128 {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p128_s64(a: int64x2_t) -> p128 {
-    let a: int64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
+pub fn vreinterpret_u32_p16(a: poly16x4_t) -> uint32x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_u8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u64_p16)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55570,15 +47264,14 @@ pub fn vreinterpretq_p128_s64(a: int64x2_t) -> p128 {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p64_u8(a: uint8x8_t) -> poly64x1_t {
+pub fn vreinterpret_u64_p16(a: poly16x4_t) -> uint64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_u8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_p16)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55592,16 +47285,14 @@ pub fn vreinterpret_p64_u8(a: uint8x8_t) -> poly64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p64_u8(a: uint8x8_t) -> poly64x1_t {
-    let a: uint8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
+pub fn vreinterpret_p8_p16(a: poly16x4_t) -> poly8x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_u8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_f32_p16)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55615,15 +47306,14 @@ pub fn vreinterpret_p64_u8(a: uint8x8_t) -> poly64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p128_u8(a: uint8x16_t) -> p128 {
+pub fn vreinterpretq_f32_p16(a: poly16x8_t) -> float32x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_u8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_p16)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55637,17 +47327,14 @@ pub fn vreinterpretq_p128_u8(a: uint8x16_t) -> p128 {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p128_u8(a: uint8x16_t) -> p128 {
-    let a: uint8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
+pub fn vreinterpretq_s8_p16(a: poly16x8_t) -> int8x16_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_u8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_p16)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55661,15 +47348,14 @@ pub fn vreinterpretq_p128_u8(a: uint8x16_t) -> p128 {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p64_u8(a: uint8x16_t) -> poly64x2_t {
+pub fn vreinterpretq_s16_p16(a: poly16x8_t) -> int16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_u8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_p16)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55683,20 +47369,14 @@ pub fn vreinterpretq_p64_u8(a: uint8x16_t) -> poly64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p64_u8(a: uint8x16_t) -> poly64x2_t {
-    let a: uint8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpretq_s32_p16(a: poly16x8_t) -> int32x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_u16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_p16)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55710,15 +47390,14 @@ pub fn vreinterpretq_p64_u8(a: uint8x16_t) -> poly64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p64_u16(a: uint16x4_t) -> poly64x1_t {
+pub fn vreinterpretq_s64_p16(a: poly16x8_t) -> int64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_u16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_p16)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55732,16 +47411,14 @@ pub fn vreinterpret_p64_u16(a: uint16x4_t) -> poly64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p64_u16(a: uint16x4_t) -> poly64x1_t {
-    let a: uint16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
+pub fn vreinterpretq_u8_p16(a: poly16x8_t) -> uint8x16_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_u16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_p16)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55755,15 +47432,14 @@ pub fn vreinterpret_p64_u16(a: uint16x4_t) -> poly64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p128_u16(a: uint16x8_t) -> p128 {
+pub fn vreinterpretq_u16_p16(a: poly16x8_t) -> uint16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_u16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_p16)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55777,16 +47453,14 @@ pub fn vreinterpretq_p128_u16(a: uint16x8_t) -> p128 {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p128_u16(a: uint16x8_t) -> p128 {
-    let a: uint16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
+pub fn vreinterpretq_u32_p16(a: poly16x8_t) -> uint32x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_u16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_p16)"]
 #[inline]
-#[cfg(target_endian = "little")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55800,15 +47474,14 @@ pub fn vreinterpretq_p128_u16(a: uint16x8_t) -> p128 {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p64_u16(a: uint16x8_t) -> poly64x2_t {
+pub fn vreinterpretq_u64_p16(a: poly16x8_t) -> uint64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_u16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_p16)"]
 #[inline]
-#[cfg(target_endian = "big")]
-#[target_feature(enable = "neon,aes")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
 #[cfg_attr(
     all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
@@ -55822,17 +47495,12 @@ pub fn vreinterpretq_p64_u16(a: uint16x8_t) -> poly64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p64_u16(a: uint16x8_t) -> poly64x2_t {
-    let a: uint16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpretq_p8_p16(a: poly16x8_t) -> poly8x16_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_p128)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -55848,13 +47516,12 @@ pub fn vreinterpretq_p64_u16(a: uint16x8_t) -> poly64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p64_u32(a: uint32x2_t) -> poly64x1_t {
+pub fn vreinterpretq_s8_p128(a: p128) -> int8x16_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_p128)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -55870,14 +47537,12 @@ pub fn vreinterpret_p64_u32(a: uint32x2_t) -> poly64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p64_u32(a: uint32x2_t) -> poly64x1_t {
-    let a: uint32x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
+pub fn vreinterpretq_s16_p128(a: p128) -> int16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_p128)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -55893,13 +47558,12 @@ pub fn vreinterpret_p64_u32(a: uint32x2_t) -> poly64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p128_u32(a: uint32x4_t) -> p128 {
+pub fn vreinterpretq_s32_p128(a: p128) -> int32x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s64_p128)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -55915,14 +47579,12 @@ pub fn vreinterpretq_p128_u32(a: uint32x4_t) -> p128 {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p128_u32(a: uint32x4_t) -> p128 {
-    let a: uint32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
+pub fn vreinterpretq_s64_p128(a: p128) -> int64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_p128)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -55938,13 +47600,12 @@ pub fn vreinterpretq_p128_u32(a: uint32x4_t) -> p128 {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p64_u32(a: uint32x4_t) -> poly64x2_t {
+pub fn vreinterpretq_u8_p128(a: p128) -> uint8x16_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_u32)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_p128)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -55960,17 +47621,12 @@ pub fn vreinterpretq_p64_u32(a: uint32x4_t) -> poly64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p64_u32(a: uint32x4_t) -> poly64x2_t {
-    let a: uint32x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpretq_u16_p128(a: p128) -> uint16x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_p128)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -55986,13 +47642,12 @@ pub fn vreinterpretq_p64_u32(a: uint32x4_t) -> poly64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p128_u64(a: uint64x2_t) -> p128 {
+pub fn vreinterpretq_u32_p128(a: p128) -> uint32x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_u64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u64_p128)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56008,14 +47663,12 @@ pub fn vreinterpretq_p128_u64(a: uint64x2_t) -> p128 {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p128_u64(a: uint64x2_t) -> p128 {
-    let a: uint64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
+pub fn vreinterpretq_u64_p128(a: p128) -> uint64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_p128)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56031,13 +47684,12 @@ pub fn vreinterpretq_p128_u64(a: uint64x2_t) -> p128 {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p64_p8(a: poly8x8_t) -> poly64x1_t {
+pub fn vreinterpretq_p8_p128(a: p128) -> poly8x16_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_p128)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56053,14 +47705,12 @@ pub fn vreinterpret_p64_p8(a: poly8x8_t) -> poly64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p64_p8(a: poly8x8_t) -> poly64x1_t {
-    let a: poly8x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
+pub fn vreinterpretq_p16_p128(a: p128) -> poly16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_p128)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56076,13 +47726,12 @@ pub fn vreinterpret_p64_p8(a: poly8x8_t) -> poly64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p128_p8(a: poly8x16_t) -> p128 {
+pub fn vreinterpretq_p64_p128(a: p128) -> poly64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_s8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56098,15 +47747,12 @@ pub fn vreinterpretq_p128_p8(a: poly8x16_t) -> p128 {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p128_p8(a: poly8x16_t) -> p128 {
-    let a: poly8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
+pub fn vreinterpret_p64_s8(a: int8x8_t) -> poly64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_s8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56122,13 +47768,12 @@ pub fn vreinterpretq_p128_p8(a: poly8x16_t) -> p128 {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p64_p8(a: poly8x16_t) -> poly64x2_t {
+pub fn vreinterpretq_p128_s8(a: int8x16_t) -> p128 {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_p8)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_s8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56144,18 +47789,12 @@ pub fn vreinterpretq_p64_p8(a: poly8x16_t) -> poly64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p64_p8(a: poly8x16_t) -> poly64x2_t {
-    let a: poly8x16_t =
-        unsafe { simd_shuffle!(a, a, [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpretq_p64_s8(a: int8x16_t) -> poly64x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_s16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56171,13 +47810,12 @@ pub fn vreinterpretq_p64_p8(a: poly8x16_t) -> poly64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p64_p16(a: poly16x4_t) -> poly64x1_t {
+pub fn vreinterpret_p64_s16(a: int16x4_t) -> poly64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_s16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56193,14 +47831,12 @@ pub fn vreinterpret_p64_p16(a: poly16x4_t) -> poly64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p64_p16(a: poly16x4_t) -> poly64x1_t {
-    let a: poly16x4_t = unsafe { simd_shuffle!(a, a, [3, 2, 1, 0]) };
+pub fn vreinterpretq_p128_s16(a: int16x8_t) -> p128 {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_s16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56216,13 +47852,12 @@ pub fn vreinterpret_p64_p16(a: poly16x4_t) -> poly64x1_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p128_p16(a: poly16x8_t) -> p128 {
+pub fn vreinterpretq_p64_s16(a: int16x8_t) -> poly64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_s32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56238,14 +47873,12 @@ pub fn vreinterpretq_p128_p16(a: poly16x8_t) -> p128 {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p128_p16(a: poly16x8_t) -> p128 {
-    let a: poly16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
+pub fn vreinterpret_p64_s32(a: int32x2_t) -> poly64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_s32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56261,13 +47894,12 @@ pub fn vreinterpretq_p128_p16(a: poly16x8_t) -> p128 {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p64_p16(a: poly16x8_t) -> poly64x2_t {
+pub fn vreinterpretq_p128_s32(a: int32x4_t) -> p128 {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_p16)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_s32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56283,17 +47915,12 @@ pub fn vreinterpretq_p64_p16(a: poly16x8_t) -> poly64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p64_p16(a: poly16x8_t) -> poly64x2_t {
-    let a: poly16x8_t = unsafe { simd_shuffle!(a, a, [7, 6, 5, 4, 3, 2, 1, 0]) };
-    unsafe {
-        let ret_val: poly64x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpretq_p64_s32(a: int32x4_t) -> poly64x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_s64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56309,13 +47936,12 @@ pub fn vreinterpretq_p64_p16(a: poly16x8_t) -> poly64x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s8_p64(a: poly64x1_t) -> int8x8_t {
+pub fn vreinterpretq_p128_s64(a: int64x2_t) -> p128 {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_u8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56331,16 +47957,12 @@ pub fn vreinterpret_s8_p64(a: poly64x1_t) -> int8x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s8_p64(a: poly64x1_t) -> int8x8_t {
-    unsafe {
-        let ret_val: int8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpret_p64_u8(a: uint8x8_t) -> poly64x1_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_u8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56356,13 +47978,12 @@ pub fn vreinterpret_s8_p64(a: poly64x1_t) -> int8x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s16_p64(a: poly64x1_t) -> int16x4_t {
+pub fn vreinterpretq_p128_u8(a: uint8x16_t) -> p128 {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_u8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56378,16 +47999,12 @@ pub fn vreinterpret_s16_p64(a: poly64x1_t) -> int16x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s16_p64(a: poly64x1_t) -> int16x4_t {
-    unsafe {
-        let ret_val: int16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpretq_p64_u8(a: uint8x16_t) -> poly64x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_u16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56403,13 +48020,12 @@ pub fn vreinterpret_s16_p64(a: poly64x1_t) -> int16x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s32_p64(a: poly64x1_t) -> int32x2_t {
+pub fn vreinterpret_p64_u16(a: uint16x4_t) -> poly64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_u16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56425,16 +48041,12 @@ pub fn vreinterpret_s32_p64(a: poly64x1_t) -> int32x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_s32_p64(a: poly64x1_t) -> int32x2_t {
-    unsafe {
-        let ret_val: int32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpretq_p128_u16(a: uint16x8_t) -> p128 {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_u16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56450,13 +48062,12 @@ pub fn vreinterpret_s32_p64(a: poly64x1_t) -> int32x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u8_p64(a: poly64x1_t) -> uint8x8_t {
+pub fn vreinterpretq_p64_u16(a: uint16x8_t) -> poly64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_u32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56472,16 +48083,12 @@ pub fn vreinterpret_u8_p64(a: poly64x1_t) -> uint8x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u8_p64(a: poly64x1_t) -> uint8x8_t {
-    unsafe {
-        let ret_val: uint8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpret_p64_u32(a: uint32x2_t) -> poly64x1_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_u32)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56497,13 +48104,12 @@ pub fn vreinterpret_u8_p64(a: poly64x1_t) -> uint8x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u16_p64(a: poly64x1_t) -> uint16x4_t {
+pub fn vreinterpretq_p128_u32(a: uint32x4_t) -> p128 {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_u32)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56519,16 +48125,12 @@ pub fn vreinterpret_u16_p64(a: poly64x1_t) -> uint16x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u16_p64(a: poly64x1_t) -> uint16x4_t {
-    unsafe {
-        let ret_val: uint16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpretq_p64_u32(a: uint32x4_t) -> poly64x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_u64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56544,13 +48146,12 @@ pub fn vreinterpret_u16_p64(a: poly64x1_t) -> uint16x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u32_p64(a: poly64x1_t) -> uint32x2_t {
+pub fn vreinterpretq_p128_u64(a: uint64x2_t) -> p128 {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_p8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56566,16 +48167,12 @@ pub fn vreinterpret_u32_p64(a: poly64x1_t) -> uint32x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_u32_p64(a: poly64x1_t) -> uint32x2_t {
-    unsafe {
-        let ret_val: uint32x2_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [1, 0])
-    }
+pub fn vreinterpret_p64_p8(a: poly8x8_t) -> poly64x1_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_p8)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56591,13 +48188,12 @@ pub fn vreinterpret_u32_p64(a: poly64x1_t) -> uint32x2_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p8_p64(a: poly64x1_t) -> poly8x8_t {
+pub fn vreinterpretq_p128_p8(a: poly8x16_t) -> p128 {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_p8)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56613,16 +48209,12 @@ pub fn vreinterpret_p8_p64(a: poly64x1_t) -> poly8x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p8_p64(a: poly64x1_t) -> poly8x8_t {
-    unsafe {
-        let ret_val: poly8x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpretq_p64_p8(a: poly8x16_t) -> poly64x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p64_p16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56638,13 +48230,12 @@ pub fn vreinterpret_p8_p64(a: poly64x1_t) -> poly8x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p16_p64(a: poly64x1_t) -> poly16x4_t {
+pub fn vreinterpret_p64_p16(a: poly16x4_t) -> poly64x1_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_p16)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56660,16 +48251,12 @@ pub fn vreinterpret_p16_p64(a: poly64x1_t) -> poly16x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpret_p16_p64(a: poly64x1_t) -> poly16x4_t {
-    unsafe {
-        let ret_val: poly16x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpretq_p128_p16(a: poly16x8_t) -> p128 {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p64_p16)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56685,13 +48272,12 @@ pub fn vreinterpret_p16_p64(a: poly64x1_t) -> poly16x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p128_p64(a: poly64x2_t) -> p128 {
+pub fn vreinterpretq_p64_p16(a: poly16x8_t) -> poly64x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s8_p64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56707,14 +48293,12 @@ pub fn vreinterpretq_p128_p64(a: poly64x2_t) -> p128 {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p128_p64(a: poly64x2_t) -> p128 {
-    let a: poly64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
+pub fn vreinterpret_s8_p64(a: poly64x1_t) -> int8x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s16_p64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56730,13 +48314,12 @@ pub fn vreinterpretq_p128_p64(a: poly64x2_t) -> p128 {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s8_p64(a: poly64x2_t) -> int8x16_t {
+pub fn vreinterpret_s16_p64(a: poly64x1_t) -> int16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_s32_p64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56752,21 +48335,12 @@ pub fn vreinterpretq_s8_p64(a: poly64x2_t) -> int8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s8_p64(a: poly64x2_t) -> int8x16_t {
-    let a: poly64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: int8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
+pub fn vreinterpret_s32_p64(a: poly64x1_t) -> int32x2_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u8_p64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56782,13 +48356,12 @@ pub fn vreinterpretq_s8_p64(a: poly64x2_t) -> int8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s16_p64(a: poly64x2_t) -> int16x8_t {
+pub fn vreinterpret_u8_p64(a: poly64x1_t) -> uint8x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u16_p64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56804,17 +48377,12 @@ pub fn vreinterpretq_s16_p64(a: poly64x2_t) -> int16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s16_p64(a: poly64x2_t) -> int16x8_t {
-    let a: poly64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: int16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpret_u16_p64(a: poly64x1_t) -> uint16x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_u32_p64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56830,13 +48398,12 @@ pub fn vreinterpretq_s16_p64(a: poly64x2_t) -> int16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s32_p64(a: poly64x2_t) -> int32x4_t {
+pub fn vreinterpret_u32_p64(a: poly64x1_t) -> uint32x2_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p8_p64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56852,17 +48419,12 @@ pub fn vreinterpretq_s32_p64(a: poly64x2_t) -> int32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_s32_p64(a: poly64x2_t) -> int32x4_t {
-    let a: poly64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: int32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpret_p8_p64(a: poly64x1_t) -> poly8x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpret_p16_p64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56878,13 +48440,12 @@ pub fn vreinterpretq_s32_p64(a: poly64x2_t) -> int32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u8_p64(a: poly64x2_t) -> uint8x16_t {
+pub fn vreinterpret_p16_p64(a: poly64x1_t) -> poly16x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p128_p64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56900,21 +48461,12 @@ pub fn vreinterpretq_u8_p64(a: poly64x2_t) -> uint8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u8_p64(a: poly64x2_t) -> uint8x16_t {
-    let a: poly64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: uint8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
+pub fn vreinterpretq_p128_p64(a: poly64x2_t) -> p128 {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s8_p64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56930,13 +48482,12 @@ pub fn vreinterpretq_u8_p64(a: poly64x2_t) -> uint8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u16_p64(a: poly64x2_t) -> uint16x8_t {
+pub fn vreinterpretq_s8_p64(a: poly64x2_t) -> int8x16_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s16_p64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56952,17 +48503,12 @@ pub fn vreinterpretq_u16_p64(a: poly64x2_t) -> uint16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u16_p64(a: poly64x2_t) -> uint16x8_t {
-    let a: poly64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: uint16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+pub fn vreinterpretq_s16_p64(a: poly64x2_t) -> int16x8_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_s32_p64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -56978,13 +48524,12 @@ pub fn vreinterpretq_u16_p64(a: poly64x2_t) -> uint16x8_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u32_p64(a: poly64x2_t) -> uint32x4_t {
+pub fn vreinterpretq_s32_p64(a: poly64x2_t) -> int32x4_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u8_p64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -57000,17 +48545,12 @@ pub fn vreinterpretq_u32_p64(a: poly64x2_t) -> uint32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_u32_p64(a: poly64x2_t) -> uint32x4_t {
-    let a: poly64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: uint32x4_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [3, 2, 1, 0])
-    }
+pub fn vreinterpretq_u8_p64(a: poly64x2_t) -> uint8x16_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u16_p64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -57026,13 +48566,12 @@ pub fn vreinterpretq_u32_p64(a: poly64x2_t) -> uint32x4_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p8_p64(a: poly64x2_t) -> poly8x16_t {
+pub fn vreinterpretq_u16_p64(a: poly64x2_t) -> uint16x8_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_u32_p64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -57048,21 +48587,12 @@ pub fn vreinterpretq_p8_p64(a: poly64x2_t) -> poly8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p8_p64(a: poly64x2_t) -> poly8x16_t {
-    let a: poly64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: poly8x16_t = transmute(a);
-        simd_shuffle!(
-            ret_val,
-            ret_val,
-            [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-        )
-    }
+pub fn vreinterpretq_u32_p64(a: poly64x2_t) -> uint32x4_t {
+    unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
-#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_p64)"]
+#[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p8_p64)"]
 #[inline]
-#[cfg(target_endian = "little")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -57078,13 +48608,12 @@ pub fn vreinterpretq_p8_p64(a: poly64x2_t) -> poly8x16_t {
     target_arch = "arm",
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
-pub fn vreinterpretq_p16_p64(a: poly64x2_t) -> poly16x8_t {
+pub fn vreinterpretq_p8_p64(a: poly64x2_t) -> poly8x16_t {
     unsafe { transmute(a) }
 }
 #[doc = "Vector reinterpret cast operation"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vreinterpretq_p16_p64)"]
 #[inline]
-#[cfg(target_endian = "big")]
 #[target_feature(enable = "neon,aes")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v8"))]
 #[cfg_attr(all(test, target_arch = "arm"), assert_instr(nop))]
@@ -57101,11 +48630,7 @@ pub fn vreinterpretq_p16_p64(a: poly64x2_t) -> poly16x8_t {
     unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
 )]
 pub fn vreinterpretq_p16_p64(a: poly64x2_t) -> poly16x8_t {
-    let a: poly64x2_t = unsafe { simd_shuffle!(a, a, [1, 0]) };
-    unsafe {
-        let ret_val: poly16x8_t = transmute(a);
-        simd_shuffle!(ret_val, ret_val, [7, 6, 5, 4, 3, 2, 1, 0])
-    }
+    unsafe { transmute(a) }
 }
 #[doc = "Reversing vector elements (swap endianness)"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrev16_p8)"]
diff --git a/library/stdarch/crates/stdarch-gen-arm/spec/neon/aarch64.spec.yml b/library/stdarch/crates/stdarch-gen-arm/spec/neon/aarch64.spec.yml
index a1a837bc61064..ccdcea980e1b2 100644
--- a/library/stdarch/crates/stdarch-gen-arm/spec/neon/aarch64.spec.yml
+++ b/library/stdarch/crates/stdarch-gen-arm/spec/neon/aarch64.spec.yml
@@ -8781,6 +8781,7 @@ intrinsics:
       - [float64x1_t, float32x2_t]
       - [float32x4_t, float64x2_t]
       - [float64x2_t, float32x4_t]
+    big_endian_inverse: false
     compose:
       - FnCall: [transmute, [a]]
 
@@ -8801,6 +8802,7 @@ intrinsics:
       # q
       - [float64x2_t, float16x8_t]
       - [float16x8_t, float64x2_t]
+    big_endian_inverse: false
     compose:
       - FnCall: [transmute, [a]]
 
diff --git a/library/stdarch/crates/stdarch-gen-arm/spec/neon/arm_shared.spec.yml b/library/stdarch/crates/stdarch-gen-arm/spec/neon/arm_shared.spec.yml
index 43dd3b9031507..61a3a5853632c 100644
--- a/library/stdarch/crates/stdarch-gen-arm/spec/neon/arm_shared.spec.yml
+++ b/library/stdarch/crates/stdarch-gen-arm/spec/neon/arm_shared.spec.yml
@@ -8480,6 +8480,7 @@ intrinsics:
       - [poly16x8_t, p128]
       - [int8x16_t, p128]
       - [uint8x16_t, p128]
+    big_endian_inverse: false
     compose:
       - FnCall: [transmute, [a]]
 
@@ -8717,6 +8718,7 @@ intrinsics:
       - [poly8x16_t, float32x4_t]
       - [poly16x8_t, float32x4_t]
       - [p128, float32x4_t]
+    big_endian_inverse: false
     compose:
       - FnCall: [transmute, [a]]
 
@@ -8780,6 +8782,7 @@ intrinsics:
       - [float16x8_t, uint16x8_t]
       - [float16x8_t, uint32x4_t]
       - [float16x8_t, uint64x2_t]
+    big_endian_inverse: false
     compose:
       - FnCall: [transmute, [a]]
 
@@ -8804,6 +8807,7 @@ intrinsics:
       - [poly128_t, float16x8_t]
       - [float16x8_t, poly128_t]
       - [float16x8_t, poly64x2_t]
+    big_endian_inverse: false
     compose:
       - FnCall: [transmute, [a]]
 

From ec5375fc55802290738b710ae285e78244e141f5 Mon Sep 17 00:00:00 2001
From: Jonathan 'theJPster' Pallant <github@thejpster.org.uk>
Date: Thu, 11 Sep 2025 21:51:13 +0100
Subject: [PATCH 0822/1889] Add general arm-linux.md platform doc.

Covers all Arm Linux systems, and means that we can reduce the amount
of information required in the target specific pages to just the Tier
level, the maintainer, and any specific details for that target.
---
 src/doc/rustc/src/SUMMARY.md                  |   9 +-
 .../rustc/src/platform-support/arm-linux.md   | 217 ++++++++++++++++++
 .../armeb-unknown-linux-gnueabi.md            |   3 +
 .../armv5te-unknown-linux-gnueabi.md          |   3 +
 .../armv7-unknown-linux-uclibceabi.md         |   3 +
 .../armv7-unknown-linux-uclibceabihf.md       |   3 +
 6 files changed, 234 insertions(+), 4 deletions(-)
 create mode 100644 src/doc/rustc/src/platform-support/arm-linux.md

diff --git a/src/doc/rustc/src/SUMMARY.md b/src/doc/rustc/src/SUMMARY.md
index 8e378e53e518a..fc3f71b4a6a8a 100644
--- a/src/doc/rustc/src/SUMMARY.md
+++ b/src/doc/rustc/src/SUMMARY.md
@@ -51,7 +51,6 @@
     - [aarch64_be-unknown-none-softfloat](platform-support/aarch64_be-unknown-none-softfloat.md)
     - [aarch64_be-unknown-linux-musl](platform-support/aarch64_be-unknown-linux-musl.md)
     - [amdgcn-amd-amdhsa](platform-support/amdgcn-amd-amdhsa.md)
-    - [armeb-unknown-linux-gnueabi](platform-support/armeb-unknown-linux-gnueabi.md)
     - [arm-none-eabi](platform-support/arm-none-eabi.md)
       - [armv4t-none-eabi](platform-support/armv4t-none-eabi.md)
       - [armv5te-none-eabi](platform-support/armv5te-none-eabi.md)
@@ -62,12 +61,14 @@
       - [thumbv7m-none-eabi](./platform-support/thumbv7m-none-eabi.md)
       - [thumbv8m.base-none-eabi](./platform-support/thumbv8m.base-none-eabi.md)
       - [thumbv8m.main-none-eabi\*](./platform-support/thumbv8m.main-none-eabi.md)
-    - [armv5te-unknown-linux-gnueabi](platform-support/armv5te-unknown-linux-gnueabi.md)
+    - [arm\*-unknown-linux-\*](./platform-support/arm-linux.md)
+        - [armeb-unknown-linux-gnueabi](platform-support/armeb-unknown-linux-gnueabi.md)
+        - [armv5te-unknown-linux-gnueabi](platform-support/armv5te-unknown-linux-gnueabi.md)
+        - [armv7-unknown-linux-uclibceabi](platform-support/armv7-unknown-linux-uclibceabi.md)
+        - [armv7-unknown-linux-uclibceabihf](platform-support/armv7-unknown-linux-uclibceabihf.md)
     - [armv6k-nintendo-3ds](platform-support/armv6k-nintendo-3ds.md)
     - [armv7-rtems-eabihf](platform-support/armv7-rtems-eabihf.md)
     - [armv7-sony-vita-newlibeabihf](platform-support/armv7-sony-vita-newlibeabihf.md)
-    - [armv7-unknown-linux-uclibceabi](platform-support/armv7-unknown-linux-uclibceabi.md)
-    - [armv7-unknown-linux-uclibceabihf](platform-support/armv7-unknown-linux-uclibceabihf.md)
     - [armv7a-vex-v5](platform-support/armv7a-vex-v5.md)
     - [\*-android and \*-androideabi](platform-support/android.md)
     - [\*-linux-ohos](platform-support/openharmony.md)
diff --git a/src/doc/rustc/src/platform-support/arm-linux.md b/src/doc/rustc/src/platform-support/arm-linux.md
new file mode 100644
index 0000000000000..5f320762e9378
--- /dev/null
+++ b/src/doc/rustc/src/platform-support/arm-linux.md
@@ -0,0 +1,217 @@
+# Arm Linux support in Rust
+
+The Arm Architecture has been around since the mid-1980s, going through nine
+major revisions, many minor revisions, and spanning both 32-bith and 64-bit
+architectures. This page covers 32-bit Arm platforms that run some form of
+Linux (but not Android). Those targets are:
+
+* `arm-unknown-linux-gnueabi`
+* `arm-unknown-linux-gnueabihf`
+* `arm-unknown-linux-musleabi`
+* `arm-unknown-linux-musleabihf`
+* [`armeb-unknown-linux-gnueabi`](armeb-unknown-linux-gnueabi.md)
+* `armv4t-unknown-linux-gnueabi`
+* [`armv5te-unknown-linux-gnueabi`](armv5te-unknown-linux-gnueabi.md)
+* `armv5te-unknown-linux-musleabi`
+* `armv5te-unknown-linux-uclibceabi`
+* `armv7-unknown-linux-gnueabi`
+* `armv7-unknown-linux-gnueabihf`
+* `armv7-unknown-linux-musleabi`
+* `armv7-unknown-linux-musleabihf`
+* `armv7-unknown-linux-ohos`
+* [`armv7-unknown-linux-uclibceabi`](armv7-unknown-linux-uclibceabi.md)
+* [`armv7-unknown-linux-uclibceabihf`](armv7-unknown-linux-uclibceabihf.md)
+* `thumbv7neon-unknown-linux-gnueabihf`
+* `thumbv7neon-unknown-linux-musleabihf`
+
+Some of these targets have dedicated pages and some do not. This is largely
+due to historical accident, or the enthusiasm of the maintainers. This
+document attempts to cover all the targets, but only in broad terms.
+
+To make sense of this list, the architecture and ABI component of the
+`<architecture>-unknown-linux-<abi>` tuple will be discussed separately.
+
+The second part of the tuple is `unknown` because these systems don't come
+from any one specific vendor (like `powerpc-ibm-aix` or
+`aarch64-apple-darwin`). The third part is `linux`, because this page only
+discusses Linux targets.
+
+## Architecture Component
+
+* `arm`
+* `armeb`
+* `armv4t`
+* `armv5te`
+* `armv7`
+* `thumbv7neon`
+
+The architecture component simply called `arm` corresponds to the Armv6
+architecture - that is, version 6 of the Arm Architecture as defined in
+version 6 of the Arm Architecture Reference Manual (the Arm ARM). This was the
+last 'legacy' release of the Arm architecture, before they split into
+Application, Real-Time and Microcontroller profiles (leading to Armv7-A,
+Armv7-R and Armv7-M). Processors that implement the Armv6 architecture include
+the ARM1176JZF-S, as found in BCM2835 SoC that powers the Raspberry Pi Zero.
+Arm processors are generally fairly backwards compatible, especially for
+user-mode code, so code compiled for the `arm` architecture should also work
+on newer ARMv7-A systems, or even 64/32-bit Armv8-A systems.
+
+The `armeb` architecture component specifies an Armv6 processor running in Big
+Endian mode (`eb` is for big-endian - the letters are backwards because
+engineers used to little-endian systems perceive big-endian numbers to be
+written into memory backwards, and they thought it was funnier like that).
+Most Arm processors can operate in either little-endian or big-endian mode and
+little-endian mode is by far the most common. However, if for whatever reason
+you wish to store your Most Significant Bytes first, these targets are
+available. They just aren't terribly well tested, or compatible with most
+existing pre-compiled Arm libraries.
+
+Targets that start with `armv4t` are for processors implementing the Armv4T
+architecture from 1994. These include the ARM7TDMI, as found in the Nokia 6110
+brick-phone and the Game Boy Advance. The 'T' stands for *Thumb* and indicate
+that the processors can execute smaller 16-bit versions of some of the 32-bit
+Arm instructions. Because a Thumb is like a small version of an Arm.
+
+Targets that start with `armv5te` are for processors implementing the Armv5TE
+architecture. These are mostly from the ARM9 family, like the ARM946E-S found
+in the Nintendo DS. If you are programming an Arm machine from the early
+2000s, this might be what you need.
+
+The `armv7` is arguably a misnomer, and it should be `armv7a`. This is because
+it corresponds to the Application profile of Armv7 (i.e. Armv7-A), as opposed
+to the Real-Time or Microcontroller profile. Processors implementing this
+architecture include the Cortex-A7 and Cortex-A8.
+
+The `thumbv7neon` component indicates support for a processor that implements
+ARMv7-A (the same as `armv7`), it generates Thumb instructions (technically
+Thumb-2, also known as the T32 ISA) as opposed to Arm instructions (also known
+as the A32 ISA). These instructions are smaller, giving more code per KB of
+RAM, but may have a performance penalty if they take two instructions to do
+something Arm instructions could do in one. It's a complex trade-off and you
+should be doing benchmarks to work out which is better for you, if you
+strongly care about code size and/or performance. This component also enables
+support for Arm's SIMD extensions, known as Neon. These extensions will
+improve performance for certain kinds of repetitive operations.
+
+## ABI Component
+
+* `gnueabi`
+* `gnueabihf`
+* `musleabi`
+* `musleabihf`
+* `ohos`
+* `uclibceabi`
+* `uclibceabihf`
+
+You will need to select the appropriate ABI to match the system you want to be
+running this code on. For example, running `eabihf` code on an `eabi` system
+will not work correctly.
+
+The `gnueabi` ABI component indicates support for using the GNU C Library
+(glibc), and the Arm Embedded ABI (EABI). The EABI is a replacement of for the
+original ABI (now called the Old ABI or OABI), and it is the standard ABI for
+32-bit Arm systems. With this ABI, function parameters that are `f32` or `f64`
+are passed as if they were integers, instead of being passed via in FPU
+registers. Generally these targets also disable the use of the FPU entirely,
+although that isn't always true.
+
+The `gnueabihf` ABI component is like `gnueabi`, except that it support the
+'hard-float' of the EABI. That is, function parameters that are `f32` or `f64`
+are passed in FPU registers. Naturally, this makes the FPU mandatory.
+
+Most 'desktop' Linux distributions (Debian, Ubuntu, Fedora, etc) use the GNU C
+Library and so you should probably select either `gnueabi` or `gnueabihf`,
+depending on whether your distribution is using 'soft-float' (EABI) or
+'hard-float' (EABIHF). Debian happens to offer
+[both](https://wiki.debian.org/ArmEabiPort)
+[kinds](https://wiki.debian.org/ArmHardFloatPort).
+
+The `musleabi` and `musleabihf` ABI components offer support for the [musl C
+library](https://musl.libc.org/). This C library can be used to create 'static
+binaries' that have no run-time library requirements (a feature that that
+glibc does not support). There are soft-float (`eabi`) and hard-float
+(`eabihf`) variants, as per the `gnu*` targets above.
+
+The `uclibceabi` and `uclibceabihf` ABI components are for the [uClibc-ng C
+library](https://uclibc-ng.org/). This is sometimes used in light-weight
+embedded Linux distributions, like those created with
+[buildroot](https://www.buildroot.org/).
+
+## Cross Compilation
+
+Unfortunately, 32-bit Arm machines are generally not the fastest around, and
+they don't have much RAM. This means you are likely to be cross-compiling.
+
+To do this, you need to give Rust a suitable linker to use - one that knows
+the Arm architecture, and more importantly, knows where to find a suitable C
+Library to link against.
+
+To do that, you can add the `linker` property to your `.cargo/config.toml`.
+Typically you would refer to a suitable copy of GCC that has built as a
+cross-compiler, alongside a C library.
+
+```toml
+[target.arm-unknown-linux-gnueabi]
+linker = "arm-linux-gnueabi-gcc"
+```
+
+On Debian Linux, you could install such a cross-compilation toolchain with
+`apt install gcc-arm-linux-gnueabi`. For more exotic combinations, you might
+need to build a bespoke version of GCC using [crosstool-ng].
+
+[crosstool-ng]: https://github.com/crosstool-ng/crosstool-ng
+
+Note that for GCC, all 32-bit Arm architectures are handled in the same build
+- there are no separate Armv4T or Armv6 builds of GCC. The architecture is
+selected with flags, like `-march=armv6`, but they aren't required for the
+linker.
+
+Let's assume we are on some Debian machine, and we want to build a basic Arm
+Linux binary for a distribution using the GNU C Library, targeting Armv6 with
+a hard-float ABI. Such a binary should work on a Raspberry Pi, for example.
+The commands are:
+
+```bash
+sudo apt install -y gcc-arm-linux-gnueabihf
+rustup target add arm-unknown-linux-gnueabihf
+cargo new --bin armdemo
+cd armdemo
+mkdir .cargo
+cat > .cargo/config.toml << EOF
+[target.arm-unknown-linux-gnueabihf]
+linker = "arm-linux-gnueabihf-gcc"
+EOF
+cargo build --target=arm-unknown-linux-gnueabihf
+```
+
+This will give us our ARM Linux binary for the GNU C Library with a soft-float ABI:
+
+```console
+$ file ./target/arm-unknown-linux-gnueabi/debug/armdemo
+./target/arm-unknown-linux-gnueabi/debug/armdemo: ELF 32-bit LSB pie
+  executable, ARM, EABI5 version 1 (SYSV), dynamically linked, interpreter
+  /lib/ld-linux.so.3, BuildID[sha1]=dd0b9aa5ae876330fd4e2fcf393850f083ec7fcd,
+  for GNU/Linux 3.2.0, with debug_info, not stripped
+```
+
+If you are building C code as part of your Rust project, you may want to
+direct `cc-rs` to use an appropriate cross-compiler with the `CROSS_COMPILE`
+environment variable. You may also want to set the CFLAGS environment variable
+for the target. For example:
+
+```bash
+export CROSS_COMPILE=arm-linux-gnueabi
+export CFLAGS_arm_unknown_linux_gnueabi="-march=armv6"
+```
+
+(Note that the dashes (`-`) turn to underscores (`_`) to form the name of the
+CFLAGS environment variable)
+
+If you are building for a Tier 3 target using `-Zbuild-std` (on Nightly Rust),
+you need to set these variables as well:
+
+```bash
+export CXX_arm_unknown_linux_gnueabi=arm-linux-gnueabi-g++
+export CC_arm_unknown_linux_gnueabi=arm-linux-gnueabi-gcc
+cargo +nightly build -Zbuild-std --target=arm-unknown-linux-gnueabi
+```
diff --git a/src/doc/rustc/src/platform-support/armeb-unknown-linux-gnueabi.md b/src/doc/rustc/src/platform-support/armeb-unknown-linux-gnueabi.md
index 7c1c5db7076b6..cd0623f73a1db 100644
--- a/src/doc/rustc/src/platform-support/armeb-unknown-linux-gnueabi.md
+++ b/src/doc/rustc/src/platform-support/armeb-unknown-linux-gnueabi.md
@@ -3,6 +3,9 @@
 
 Target for cross-compiling Linux user-mode applications targeting the Arm BE8 architecture.
 
+See [`arm-linux`](arm-linux.md) for information applicable to all Arm Linux
+targets.
+
 ## Overview
 BE8 architecture retains the same little-endian ordered code-stream used by conventional little endian Arm systems, however the data accesses are in big-endian. BE8 is used primarily in high-performance networking applications where the ability to read packets in their native "Network Byte Order" is important (many network protocols transmit data in big-endian byte order for their wire formats).
 
diff --git a/src/doc/rustc/src/platform-support/armv5te-unknown-linux-gnueabi.md b/src/doc/rustc/src/platform-support/armv5te-unknown-linux-gnueabi.md
index 0aebbc34d400b..a924f476411df 100644
--- a/src/doc/rustc/src/platform-support/armv5te-unknown-linux-gnueabi.md
+++ b/src/doc/rustc/src/platform-support/armv5te-unknown-linux-gnueabi.md
@@ -5,6 +5,9 @@
 This target supports Linux programs with glibc on ARMv5TE CPUs without
 floating-point units.
 
+See [`arm-linux`](arm-linux.md) for information applicable to all Arm Linux
+targets.
+
 ## Target maintainers
 
 There are currently no formally documented target maintainers.
diff --git a/src/doc/rustc/src/platform-support/armv7-unknown-linux-uclibceabi.md b/src/doc/rustc/src/platform-support/armv7-unknown-linux-uclibceabi.md
index e553c49589de6..4ab0a07090a62 100644
--- a/src/doc/rustc/src/platform-support/armv7-unknown-linux-uclibceabi.md
+++ b/src/doc/rustc/src/platform-support/armv7-unknown-linux-uclibceabi.md
@@ -4,6 +4,9 @@
 
 This target supports Armv7-A softfloat CPUs and uses the uclibc-ng standard library. This is a common configuration on many consumer routers (e.g., Netgear R7000, Asus RT-AC68U).
 
+See [`arm-linux`](arm-linux.md) for information applicable to all Arm Linux
+targets.
+
 ## Target maintainers
 
 [@lancethepants](https://github.com/lancethepants)
diff --git a/src/doc/rustc/src/platform-support/armv7-unknown-linux-uclibceabihf.md b/src/doc/rustc/src/platform-support/armv7-unknown-linux-uclibceabihf.md
index 91f3ea886ccb5..9fb24906b4fc3 100644
--- a/src/doc/rustc/src/platform-support/armv7-unknown-linux-uclibceabihf.md
+++ b/src/doc/rustc/src/platform-support/armv7-unknown-linux-uclibceabihf.md
@@ -4,6 +4,9 @@
 
 This tier supports the Armv7-A processor running a Linux kernel and uClibc-ng standard library.  It provides full support for rust and the rust standard library.
 
+See [`arm-linux`](arm-linux.md) for information applicable to all Arm Linux
+targets.
+
 ## Target Maintainers
 
 [@skrap](https://github.com/skrap)

From 1621ce6a083b33298f83a00aa31633a30775b512 Mon Sep 17 00:00:00 2001
From: Jonathan 'theJPster' Pallant <github@thejpster.org.uk>
Date: Thu, 11 Sep 2025 22:04:35 +0100
Subject: [PATCH 0823/1889] Cleanups from review comments.

---
 src/doc/rustc/src/platform-support/aarch64-unknown-none.md | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/doc/rustc/src/platform-support/aarch64-unknown-none.md b/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
index f3c0764b5bf75..a9c72d8cc9d83 100644
--- a/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
+++ b/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
@@ -71,8 +71,8 @@ from the [Arm Developer Website][arm-gnu-toolchain], or possibly from your OS's
 package manager. To use it, add the following to your `.cargo/config.toml`:
 
 ```toml
-[target.<your-target>]
-linker = "arm-none-eabi-ld"
+[target.aarch64-unknown-none]
+linker = "aarch64-none-ld"
 ```
 
 The GNU linker can also be used by specifying `aarch64-none-gcc` as the
@@ -92,8 +92,7 @@ When using the hardfloat targets, the minimum floating-point features assumed
 are those of the `fp-armv8`, which excludes NEON SIMD support. If your
 processor supports a different set of floating-point features than the default
 expectations of `fp-armv8`, then these should also be enabled or disabled as
-needed with `-C target-feature=(+/-)`. For example,
-`-Ctarget-feature=+neon-fp-armv8`.
+needed with `-C target-feature=(+/-)`.
 
 [arm-gnu-toolchain]: https://developer.arm.com/Tools%20and%20Software/GNU%20Toolchain
 

From a0d1f5a3fb8b9554cb4ac5d0b8ffc75233a20dda Mon Sep 17 00:00:00 2001
From: Jonathan 'theJPster' Pallant <github@thejpster.org.uk>
Date: Thu, 11 Sep 2025 22:05:24 +0100
Subject: [PATCH 0824/1889] Insert missing word.

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

diff --git a/src/doc/rustc/src/platform-support/aarch64-unknown-none.md b/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
index a9c72d8cc9d83..bcdf4271b1279 100644
--- a/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
+++ b/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
@@ -106,8 +106,8 @@ run your code on.
 ## Start-up and Low-Level Code
 
 The [Rust Embedded Devices Working Group Arm Team] maintain the
-[`aarch64-cpu`], which may be useful for writing bare-metal code using this
-target.
+[`aarch64-cpu`] crate, which may be useful for writing bare-metal code using
+this target.
 
 The *TrustedFirmware* group also maintain [Rust crates for this
 target](https://github.com/ArmFirmwareCrates).

From 321a76b5f95325f20c9e88e87bfb4ddf536b6950 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Thu, 11 Sep 2025 23:52:04 +0200
Subject: [PATCH 0825/1889] c-variadic: test that unsupported c-variadic ABIs
 are reported correctly

---
 tests/ui/c-variadic/unsupported-abi.rs     | 123 ++++++++
 tests/ui/c-variadic/unsupported-abi.stderr | 345 +++++++++++++++++++++
 2 files changed, 468 insertions(+)
 create mode 100644 tests/ui/c-variadic/unsupported-abi.rs
 create mode 100644 tests/ui/c-variadic/unsupported-abi.stderr

diff --git a/tests/ui/c-variadic/unsupported-abi.rs b/tests/ui/c-variadic/unsupported-abi.rs
new file mode 100644
index 0000000000000..40179b164ce42
--- /dev/null
+++ b/tests/ui/c-variadic/unsupported-abi.rs
@@ -0,0 +1,123 @@
+//@ add-core-stubs
+//@ needs-llvm-components: x86
+//@ compile-flags: --target=i686-pc-windows-gnu --crate-type=rlib
+#![no_core]
+#![feature(no_core, lang_items, c_variadic)]
+
+// Test that ABIs for which C-variadics are not supported report an error.
+
+extern crate minicore;
+use minicore::*;
+
+#[rustfmt::skip]
+mod foreign {
+    extern "Rust"  { fn rust_foreign_explicit(_: ...); }
+    //~^ ERROR C-variadic functions with the "Rust" calling convention are not supported
+    extern "C"  { fn c_foreign(_: ...); }
+    extern "C-unwind"  { fn c_unwind_foreign(_: ...); }
+    extern "cdecl"  { fn cdecl_foreign(_: ...); }
+    extern "cdecl-unwind"  { fn cdecl_unwind_foreign(_: ...); }
+    extern "stdcall"  { fn stdcall_foreign(_: ...); }
+    //~^ ERROR C-variadic functions with the "stdcall" calling convention are not supported
+    extern "stdcall-unwind"  { fn stdcall_unwind_foreign(_: ...); }
+    //~^ ERROR C-variadic functions with the "stdcall-unwind" calling convention are not supported
+    extern "thiscall"  { fn thiscall_foreign(_: ...); }
+    //~^ ERROR C-variadic functions with the "thiscall" calling convention are not supported
+    extern "thiscall-unwind"  { fn thiscall_unwind_foreign(_: ...); }
+    //~^ ERROR C-variadic functions with the "thiscall-unwind" calling convention are not supported
+}
+
+#[lang = "va_list"]
+struct VaList(*mut u8);
+
+unsafe fn rust_free(_: ...) {}
+//~^ ERROR `...` is not supported for non-extern functions
+unsafe extern "Rust" fn rust_free_explicit(_: ...) {}
+//~^ ERROR `...` is not supported for `extern "Rust"` functions
+
+unsafe extern "C" fn c_free(_: ...) {}
+unsafe extern "C-unwind" fn c_unwind_free(_: ...) {}
+
+unsafe extern "cdecl" fn cdecl_free(_: ...) {}
+//~^ ERROR `...` is not supported for `extern "cdecl"` functions
+unsafe extern "cdecl-unwind" fn cdecl_unwind_free(_: ...) {}
+//~^ ERROR `...` is not supported for `extern "cdecl-unwind"` functions
+unsafe extern "stdcall" fn stdcall_free(_: ...) {}
+//~^ ERROR `...` is not supported for `extern "stdcall"` functions
+unsafe extern "stdcall-unwind" fn stdcall_unwind_free(_: ...) {}
+//~^ ERROR `...` is not supported for `extern "stdcall-unwind"` functions
+unsafe extern "thiscall" fn thiscall_free(_: ...) {}
+//~^ ERROR `...` is not supported for `extern "thiscall"` functions
+unsafe extern "thiscall-unwind" fn thiscall_unwind_free(_: ...) {}
+//~^ ERROR `...` is not supported for `extern "thiscall-unwind"` functions
+
+struct S;
+
+impl S {
+    unsafe fn rust_method(_: ...) {}
+    //~^ ERROR `...` is not supported for non-extern functions
+    unsafe extern "Rust" fn rust_method_explicit(_: ...) {}
+    //~^ ERROR `...` is not supported for `extern "Rust"` functions
+
+    unsafe extern "C" fn c_method(_: ...) {}
+    unsafe extern "C-unwind" fn c_unwind_method(_: ...) {}
+
+    unsafe extern "cdecl" fn cdecl_method(_: ...) {}
+    //~^ ERROR `...` is not supported for `extern "cdecl"` functions
+    unsafe extern "cdecl-unwind" fn cdecl_unwind_method(_: ...) {}
+    //~^ ERROR `...` is not supported for `extern "cdecl-unwind"` functions
+    unsafe extern "stdcall" fn stdcall_method(_: ...) {}
+    //~^ ERROR `...` is not supported for `extern "stdcall"` functions
+    unsafe extern "stdcall-unwind" fn stdcall_unwind_method(_: ...) {}
+    //~^ ERROR `...` is not supported for `extern "stdcall-unwind"` functions
+    unsafe extern "thiscall" fn thiscall_method(_: ...) {}
+    //~^ ERROR `...` is not supported for `extern "thiscall"` functions
+    unsafe extern "thiscall-unwind" fn thiscall_unwind_method(_: ...) {}
+    //~^ ERROR `...` is not supported for `extern "thiscall-unwind"` functions
+}
+
+trait T {
+    unsafe fn rust_trait_method(_: ...) {}
+    //~^ ERROR `...` is not supported for non-extern functions
+    unsafe extern "Rust" fn rust_trait_method_explicit(_: ...) {}
+    //~^ ERROR `...` is not supported for `extern "Rust"` functions
+
+    unsafe extern "C" fn c_trait_method(_: ...) {}
+    unsafe extern "C-unwind" fn c_unwind_trait_method(_: ...) {}
+
+    unsafe extern "cdecl" fn cdecl_trait_method(_: ...) {}
+    //~^ ERROR `...` is not supported for `extern "cdecl"` functions
+    unsafe extern "cdecl-unwind" fn cdecl_unwind_trait_method(_: ...) {}
+    //~^ ERROR `...` is not supported for `extern "cdecl-unwind"` functions
+    unsafe extern "stdcall" fn stdcall_trait_method(_: ...) {}
+    //~^ ERROR `...` is not supported for `extern "stdcall"` functions
+    unsafe extern "stdcall-unwind" fn stdcall_unwind_trait_method(_: ...) {}
+    //~^ ERROR `...` is not supported for `extern "stdcall-unwind"` functions
+    unsafe extern "thiscall" fn thiscall_trait_method(_: ...) {}
+    //~^ ERROR `...` is not supported for `extern "thiscall"` functions
+    unsafe extern "thiscall-unwind" fn thiscall_unwind_trait_method(_: ...) {}
+    //~^ ERROR `...` is not supported for `extern "thiscall-unwind"` functions
+}
+
+impl T for S {
+    unsafe fn rust_trait_method(_: ...) {}
+    //~^ ERROR `...` is not supported for non-extern functions
+    unsafe extern "Rust" fn rust_trait_method_explicit(_: ...) {}
+    //~^ ERROR `...` is not supported for `extern "Rust"` functions
+
+    unsafe extern "C" fn c_trait_method(_: ...) {}
+    unsafe extern "C-unwind" fn c_unwind_trait_method(_: ...) {}
+
+    unsafe extern "cdecl" fn cdecl_trait_method(_: ...) {}
+    //~^ ERROR `...` is not supported for `extern "cdecl"` functions
+    unsafe extern "cdecl-unwind" fn cdecl_unwind_trait_method(_: ...) {}
+    //~^ ERROR `...` is not supported for `extern "cdecl-unwind"` functions
+    unsafe extern "stdcall" fn stdcall_trait_method(_: ...) {}
+    //~^ ERROR `...` is not supported for `extern "stdcall"` functions
+    unsafe extern "stdcall-unwind" fn stdcall_unwind_trait_method(_: ...) {}
+    //~^ ERROR `...` is not supported for `extern "stdcall-unwind"` functions
+    unsafe extern "thiscall" fn thiscall_trait_method(_: ...) {}
+    //~^ ERROR `...` is not supported for `extern "thiscall"` functions
+    unsafe extern "thiscall-unwind" fn thiscall_unwind_trait_method(_: ...) {}
+    //~^ ERROR `...` is not supported for `extern "thiscall-unwind"` functions
+}
diff --git a/tests/ui/c-variadic/unsupported-abi.stderr b/tests/ui/c-variadic/unsupported-abi.stderr
new file mode 100644
index 0000000000000..daed91714065a
--- /dev/null
+++ b/tests/ui/c-variadic/unsupported-abi.stderr
@@ -0,0 +1,345 @@
+error: `...` is not supported for non-extern functions
+  --> $DIR/unsupported-abi.rs:33:21
+   |
+LL | unsafe fn rust_free(_: ...) {}
+   |                     ^^^^^^
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for `extern "Rust"` functions
+  --> $DIR/unsupported-abi.rs:35:44
+   |
+LL | unsafe extern "Rust" fn rust_free_explicit(_: ...) {}
+   |        -------------                       ^^^^^^
+   |        |
+   |        `extern "Rust"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for `extern "cdecl"` functions
+  --> $DIR/unsupported-abi.rs:41:37
+   |
+LL | unsafe extern "cdecl" fn cdecl_free(_: ...) {}
+   |        --------------               ^^^^^^
+   |        |
+   |        `extern "cdecl"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for `extern "cdecl-unwind"` functions
+  --> $DIR/unsupported-abi.rs:43:51
+   |
+LL | unsafe extern "cdecl-unwind" fn cdecl_unwind_free(_: ...) {}
+   |        ---------------------                      ^^^^^^
+   |        |
+   |        `extern "cdecl-unwind"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for `extern "stdcall"` functions
+  --> $DIR/unsupported-abi.rs:45:41
+   |
+LL | unsafe extern "stdcall" fn stdcall_free(_: ...) {}
+   |        ----------------                 ^^^^^^
+   |        |
+   |        `extern "stdcall"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for `extern "stdcall-unwind"` functions
+  --> $DIR/unsupported-abi.rs:47:55
+   |
+LL | unsafe extern "stdcall-unwind" fn stdcall_unwind_free(_: ...) {}
+   |        -----------------------                        ^^^^^^
+   |        |
+   |        `extern "stdcall-unwind"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for `extern "thiscall"` functions
+  --> $DIR/unsupported-abi.rs:49:43
+   |
+LL | unsafe extern "thiscall" fn thiscall_free(_: ...) {}
+   |        -----------------                  ^^^^^^
+   |        |
+   |        `extern "thiscall"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for `extern "thiscall-unwind"` functions
+  --> $DIR/unsupported-abi.rs:51:57
+   |
+LL | unsafe extern "thiscall-unwind" fn thiscall_unwind_free(_: ...) {}
+   |        ------------------------                         ^^^^^^
+   |        |
+   |        `extern "thiscall-unwind"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for non-extern functions
+  --> $DIR/unsupported-abi.rs:57:27
+   |
+LL |     unsafe fn rust_method(_: ...) {}
+   |                           ^^^^^^
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for `extern "Rust"` functions
+  --> $DIR/unsupported-abi.rs:59:50
+   |
+LL |     unsafe extern "Rust" fn rust_method_explicit(_: ...) {}
+   |            -------------                         ^^^^^^
+   |            |
+   |            `extern "Rust"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for `extern "cdecl"` functions
+  --> $DIR/unsupported-abi.rs:65:43
+   |
+LL |     unsafe extern "cdecl" fn cdecl_method(_: ...) {}
+   |            --------------                 ^^^^^^
+   |            |
+   |            `extern "cdecl"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for `extern "cdecl-unwind"` functions
+  --> $DIR/unsupported-abi.rs:67:57
+   |
+LL |     unsafe extern "cdecl-unwind" fn cdecl_unwind_method(_: ...) {}
+   |            ---------------------                        ^^^^^^
+   |            |
+   |            `extern "cdecl-unwind"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for `extern "stdcall"` functions
+  --> $DIR/unsupported-abi.rs:69:47
+   |
+LL |     unsafe extern "stdcall" fn stdcall_method(_: ...) {}
+   |            ----------------                   ^^^^^^
+   |            |
+   |            `extern "stdcall"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for `extern "stdcall-unwind"` functions
+  --> $DIR/unsupported-abi.rs:71:61
+   |
+LL |     unsafe extern "stdcall-unwind" fn stdcall_unwind_method(_: ...) {}
+   |            -----------------------                          ^^^^^^
+   |            |
+   |            `extern "stdcall-unwind"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for `extern "thiscall"` functions
+  --> $DIR/unsupported-abi.rs:73:49
+   |
+LL |     unsafe extern "thiscall" fn thiscall_method(_: ...) {}
+   |            -----------------                    ^^^^^^
+   |            |
+   |            `extern "thiscall"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for `extern "thiscall-unwind"` functions
+  --> $DIR/unsupported-abi.rs:75:63
+   |
+LL |     unsafe extern "thiscall-unwind" fn thiscall_unwind_method(_: ...) {}
+   |            ------------------------                           ^^^^^^
+   |            |
+   |            `extern "thiscall-unwind"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for non-extern functions
+  --> $DIR/unsupported-abi.rs:80:33
+   |
+LL |     unsafe fn rust_trait_method(_: ...) {}
+   |                                 ^^^^^^
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for `extern "Rust"` functions
+  --> $DIR/unsupported-abi.rs:82:56
+   |
+LL |     unsafe extern "Rust" fn rust_trait_method_explicit(_: ...) {}
+   |            -------------                               ^^^^^^
+   |            |
+   |            `extern "Rust"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for `extern "cdecl"` functions
+  --> $DIR/unsupported-abi.rs:88:49
+   |
+LL |     unsafe extern "cdecl" fn cdecl_trait_method(_: ...) {}
+   |            --------------                       ^^^^^^
+   |            |
+   |            `extern "cdecl"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for `extern "cdecl-unwind"` functions
+  --> $DIR/unsupported-abi.rs:90:63
+   |
+LL |     unsafe extern "cdecl-unwind" fn cdecl_unwind_trait_method(_: ...) {}
+   |            ---------------------                              ^^^^^^
+   |            |
+   |            `extern "cdecl-unwind"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for `extern "stdcall"` functions
+  --> $DIR/unsupported-abi.rs:92:53
+   |
+LL |     unsafe extern "stdcall" fn stdcall_trait_method(_: ...) {}
+   |            ----------------                         ^^^^^^
+   |            |
+   |            `extern "stdcall"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for `extern "stdcall-unwind"` functions
+  --> $DIR/unsupported-abi.rs:94:67
+   |
+LL |     unsafe extern "stdcall-unwind" fn stdcall_unwind_trait_method(_: ...) {}
+   |            -----------------------                                ^^^^^^
+   |            |
+   |            `extern "stdcall-unwind"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for `extern "thiscall"` functions
+  --> $DIR/unsupported-abi.rs:96:55
+   |
+LL |     unsafe extern "thiscall" fn thiscall_trait_method(_: ...) {}
+   |            -----------------                          ^^^^^^
+   |            |
+   |            `extern "thiscall"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for `extern "thiscall-unwind"` functions
+  --> $DIR/unsupported-abi.rs:98:69
+   |
+LL |     unsafe extern "thiscall-unwind" fn thiscall_unwind_trait_method(_: ...) {}
+   |            ------------------------                                 ^^^^^^
+   |            |
+   |            `extern "thiscall-unwind"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for non-extern functions
+  --> $DIR/unsupported-abi.rs:103:33
+   |
+LL |     unsafe fn rust_trait_method(_: ...) {}
+   |                                 ^^^^^^
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for `extern "Rust"` functions
+  --> $DIR/unsupported-abi.rs:105:56
+   |
+LL |     unsafe extern "Rust" fn rust_trait_method_explicit(_: ...) {}
+   |            -------------                               ^^^^^^
+   |            |
+   |            `extern "Rust"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for `extern "cdecl"` functions
+  --> $DIR/unsupported-abi.rs:111:49
+   |
+LL |     unsafe extern "cdecl" fn cdecl_trait_method(_: ...) {}
+   |            --------------                       ^^^^^^
+   |            |
+   |            `extern "cdecl"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for `extern "cdecl-unwind"` functions
+  --> $DIR/unsupported-abi.rs:113:63
+   |
+LL |     unsafe extern "cdecl-unwind" fn cdecl_unwind_trait_method(_: ...) {}
+   |            ---------------------                              ^^^^^^
+   |            |
+   |            `extern "cdecl-unwind"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for `extern "stdcall"` functions
+  --> $DIR/unsupported-abi.rs:115:53
+   |
+LL |     unsafe extern "stdcall" fn stdcall_trait_method(_: ...) {}
+   |            ----------------                         ^^^^^^
+   |            |
+   |            `extern "stdcall"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for `extern "stdcall-unwind"` functions
+  --> $DIR/unsupported-abi.rs:117:67
+   |
+LL |     unsafe extern "stdcall-unwind" fn stdcall_unwind_trait_method(_: ...) {}
+   |            -----------------------                                ^^^^^^
+   |            |
+   |            `extern "stdcall-unwind"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for `extern "thiscall"` functions
+  --> $DIR/unsupported-abi.rs:119:55
+   |
+LL |     unsafe extern "thiscall" fn thiscall_trait_method(_: ...) {}
+   |            -----------------                          ^^^^^^
+   |            |
+   |            `extern "thiscall"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: `...` is not supported for `extern "thiscall-unwind"` functions
+  --> $DIR/unsupported-abi.rs:121:69
+   |
+LL |     unsafe extern "thiscall-unwind" fn thiscall_unwind_trait_method(_: ...) {}
+   |            ------------------------                                 ^^^^^^
+   |            |
+   |            `extern "thiscall-unwind"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error[E0045]: C-variadic functions with the "Rust" calling convention are not supported
+  --> $DIR/unsupported-abi.rs:14:22
+   |
+LL |     extern "Rust"  { fn rust_foreign_explicit(_: ...); }
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ C-variadic function must have a compatible calling convention
+
+error[E0045]: C-variadic functions with the "stdcall" calling convention are not supported
+  --> $DIR/unsupported-abi.rs:20:25
+   |
+LL |     extern "stdcall"  { fn stdcall_foreign(_: ...); }
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ C-variadic function must have a compatible calling convention
+
+error[E0045]: C-variadic functions with the "stdcall-unwind" calling convention are not supported
+  --> $DIR/unsupported-abi.rs:22:32
+   |
+LL |     extern "stdcall-unwind"  { fn stdcall_unwind_foreign(_: ...); }
+   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ C-variadic function must have a compatible calling convention
+
+error[E0045]: C-variadic functions with the "thiscall" calling convention are not supported
+  --> $DIR/unsupported-abi.rs:24:26
+   |
+LL |     extern "thiscall"  { fn thiscall_foreign(_: ...); }
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ C-variadic function must have a compatible calling convention
+
+error[E0045]: C-variadic functions with the "thiscall-unwind" calling convention are not supported
+  --> $DIR/unsupported-abi.rs:26:33
+   |
+LL |     extern "thiscall-unwind"  { fn thiscall_unwind_foreign(_: ...); }
+   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ C-variadic function must have a compatible calling convention
+
+error: aborting due to 37 previous errors
+
+For more information about this error, try `rustc --explain E0045`.

From 43a6b1041819c5f5b70faf1ad5833400087dc1b0 Mon Sep 17 00:00:00 2001
From: IoaNNUwU <ioannxd@gmail.com>
Date: Fri, 12 Sep 2025 00:01:38 +0200
Subject: [PATCH 0826/1889] Use raw fmt str in format macro

---
 compiler/rustc_builtin_macros/src/format.rs   | 14 ++++--
 .../missing-format-specifiers-issue-68293.rs  | 29 +++++++++++
 ...ssing-format-specifiers-issue-68293.stderr | 49 ++++++++++++++++++-
 3 files changed, 87 insertions(+), 5 deletions(-)

diff --git a/compiler/rustc_builtin_macros/src/format.rs b/compiler/rustc_builtin_macros/src/format.rs
index a6c8e7d29cc7a..d70888205a51b 100644
--- a/compiler/rustc_builtin_macros/src/format.rs
+++ b/compiler/rustc_builtin_macros/src/format.rs
@@ -569,6 +569,7 @@ fn make_format_args(
             detect_foreign_fmt,
             str_style,
             fmt_str,
+            uncooked_fmt_str.1.as_str(),
             fmt_span,
         );
     }
@@ -650,6 +651,7 @@ fn report_missing_placeholders(
     detect_foreign_fmt: bool,
     str_style: Option<usize>,
     fmt_str: &str,
+    uncooked_fmt_str: &str,
     fmt_span: Span,
 ) {
     let mut diag = if let &[(span, named)] = &unused[..] {
@@ -773,16 +775,20 @@ fn report_missing_placeholders(
                 diag.note(format!("consider adding {} format specifiers", unused.len()));
             }
         } else {
-            let original_fmt_str =
-                if fmt_str.len() >= 1 { &fmt_str[..fmt_str.len() - 1] } else { "" };
-
             let msg = if unused.len() == 1 {
                 "a format specifier".to_string()
             } else {
                 format!("{} format specifiers", unused.len())
             };
 
-            let sugg = format!("\"{}{}\"", original_fmt_str, "{}".repeat(unused.len()));
+            let sugg = match str_style {
+                None => format!("\"{}{}\"", uncooked_fmt_str, "{}".repeat(unused.len())),
+                Some(n_hashes) => format!(
+                    "r{hashes}\"{uncooked_fmt_str}{fmt_specifiers}\"{hashes}",
+                    hashes = "#".repeat(n_hashes),
+                    fmt_specifiers = "{}".repeat(unused.len())
+                ),
+            };
             let msg = format!("format specifiers use curly braces, consider adding {msg}");
 
             diag.span_suggestion_verbose(fmt_span, msg, sugg, Applicability::MaybeIncorrect);
diff --git a/tests/ui/suggestions/missing-format-specifiers-issue-68293.rs b/tests/ui/suggestions/missing-format-specifiers-issue-68293.rs
index 29799624d7821..fbede7c41cb2e 100644
--- a/tests/ui/suggestions/missing-format-specifiers-issue-68293.rs
+++ b/tests/ui/suggestions/missing-format-specifiers-issue-68293.rs
@@ -32,4 +32,33 @@ fn missing_format_specifiers_multiple_unused_args() {
     //~| NOTE consider adding 2 format specifiers
 }
 
+fn unicode_unused_args() {
+    panic!("👆", "👆", 1);
+    //~^ ERROR multiple unused formatting arguments
+    //~| NOTE multiple missing formatting specifiers
+    //~| NOTE argument never used
+    //~| NOTE argument never used
+    //~| HELP format specifiers use curly braces, consider adding 2 format specifiers
+}
+
+fn raw_str_unused_arg() {
+    format_args!(r##"lJ𐏿Æ�.𐏿�"##, r#"r}J𐏿Æ" {}"#, 1);
+    //~^ ERROR multiple unused formatting arguments
+    //~| NOTE multiple missing formatting specifiers
+    //~| NOTE argument never used
+    //~| NOTE argument never used
+    //~| HELP format specifiers use curly braces, consider adding 2 format specifiers
+}
+
+fn valid_new_lines_unused_args() {
+    panic!("Expect 2 newlines
+
+", "👆", 1);
+    //~^ ERROR multiple unused formatting arguments
+    //~| NOTE argument never used
+    //~| NOTE argument never used
+    //~^^^^^^ NOTE multiple missing formatting specifiers
+    //~| HELP format specifiers use curly braces, consider adding 2 format specifiers
+}
+
 fn main() { }
diff --git a/tests/ui/suggestions/missing-format-specifiers-issue-68293.stderr b/tests/ui/suggestions/missing-format-specifiers-issue-68293.stderr
index 081409789f5a4..7e997241698c0 100644
--- a/tests/ui/suggestions/missing-format-specifiers-issue-68293.stderr
+++ b/tests/ui/suggestions/missing-format-specifiers-issue-68293.stderr
@@ -45,5 +45,52 @@ LL |     println!("list: {}", 1, 2, 3);
    |
    = note: consider adding 2 format specifiers
 
-error: aborting due to 4 previous errors
+error: multiple unused formatting arguments
+  --> $DIR/missing-format-specifiers-issue-68293.rs:36:17
+   |
+LL |     panic!("👆", "👆", 1);
+   |            ----  ^^^^  ^ argument never used
+   |            |     |
+   |            |     argument never used
+   |            multiple missing formatting specifiers
+   |
+help: format specifiers use curly braces, consider adding 2 format specifiers
+   |
+LL |     panic!("👆{}{}", "👆", 1);
+   |               ++++
+
+error: multiple unused formatting arguments
+  --> $DIR/missing-format-specifiers-issue-68293.rs:45:35
+   |
+LL |     format_args!(r##"lJ𐏿Æ�.𐏿�"##, r#"r}J𐏿Æ" {}"#, 1);
+   |                  ---------------  ^^^^^^^^^^^^^^  ^ argument never used
+   |                  |                |
+   |                  |                argument never used
+   |                  multiple missing formatting specifiers
+   |
+help: format specifiers use curly braces, consider adding 2 format specifiers
+   |
+LL |     format_args!(r##"lJ𐏿Æ�.𐏿�{}{}"##, r#"r}J𐏿Æ" {}"#, 1);
+   |                              ++++
+
+error: multiple unused formatting arguments
+  --> $DIR/missing-format-specifiers-issue-68293.rs:56:4
+   |
+LL |       panic!("Expect 2 newlines
+   |  ____________-
+LL | |
+LL | | ", "👆", 1);
+   | | -  ^^^^  ^ argument never used
+   | | |  |
+   | |_|  argument never used
+   |   multiple missing formatting specifiers
+   |
+help: format specifiers use curly braces, consider adding 2 format specifiers
+   |
+LL |     panic!("Expect 2 newlines
+LL |
+LL ~ {}{}", "👆", 1);
+   |
+
+error: aborting due to 7 previous errors
 

From 1793eec3535f971242637ff095aac9efdc98738b Mon Sep 17 00:00:00 2001
From: Josh Stone <jistone@redhat.com>
Date: Thu, 11 Sep 2025 15:11:16 -0700
Subject: [PATCH 0827/1889] test: remove an outdated normalization for rustc
 versions

These "you are using $RUSTC_VERSION" help messages were removed in
rust-lang/rust#142943, but rust-lang/rust#142681 started before that and
merged later, so its normalization is vestigial.
---
 tests/ui/feature-gates/feature-gate-sanitize.rs     | 1 -
 tests/ui/feature-gates/feature-gate-sanitize.stderr | 4 ++--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/tests/ui/feature-gates/feature-gate-sanitize.rs b/tests/ui/feature-gates/feature-gate-sanitize.rs
index 40098d93272cb..768417cfae8a8 100644
--- a/tests/ui/feature-gates/feature-gate-sanitize.rs
+++ b/tests/ui/feature-gates/feature-gate-sanitize.rs
@@ -1,4 +1,3 @@
-//@ normalize-stderr: "you are using [0-9]+\.[0-9]+\.[0-9]+(-[a-zA-Z0-9]+)?( \([^)]*\))?" -> "you are using $$RUSTC_VERSION"
 #![feature(no_sanitize)] //~ ERROR feature has been removed
 
 #[sanitize(address = "on")]
diff --git a/tests/ui/feature-gates/feature-gate-sanitize.stderr b/tests/ui/feature-gates/feature-gate-sanitize.stderr
index 7c38b351916ab..513999636a95c 100644
--- a/tests/ui/feature-gates/feature-gate-sanitize.stderr
+++ b/tests/ui/feature-gates/feature-gate-sanitize.stderr
@@ -1,5 +1,5 @@
 error[E0557]: feature has been removed
-  --> $DIR/feature-gate-sanitize.rs:2:12
+  --> $DIR/feature-gate-sanitize.rs:1:12
    |
 LL | #![feature(no_sanitize)]
    |            ^^^^^^^^^^^ feature has been removed
@@ -8,7 +8,7 @@ LL | #![feature(no_sanitize)]
    = note: renamed to sanitize(xyz = "on|off")
 
 error[E0658]: the `#[sanitize]` attribute is an experimental feature
-  --> $DIR/feature-gate-sanitize.rs:4:1
+  --> $DIR/feature-gate-sanitize.rs:3:1
    |
 LL | #[sanitize(address = "on")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^

From 88d7d20122e45f4167e262e6eda03fbf5383fb18 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Thu, 11 Sep 2025 15:48:44 -0700
Subject: [PATCH 0828/1889] Skip cleanups on unsupported targets

This commit is an update to the `AbortUnwindingCalls` MIR pass in the
compiler. Specifically a new boolean is added for "can this target
possibly unwind" and if that's `false` then terminators are all adjusted
to be unreachable/not present. The end result is that this fixes 140293
for wasm targets.

The motivation for this PR is that currently on WebAssembly targets the
usage of the `C-unwind` ABI can lead LLVM to either (a) emit
exception-handling instructions or (b) hit a LLVM-ICE-style codegen
error. WebAssembly as a base instruction set does not support unwinding
at all, and a later proposal to WebAssembly, the exception-handling
proposal, was what enabled this. This means that the current intent of
WebAssembly targets is that they maintain the baseline of "don't emit
exception-handling instructions unless enabled". The commit here is
intended to restore this behavior by skipping these instructions even
when `C-unwind` is present.

Exception-handling is a relatively tricky and also murky topic in
WebAssembly, however. There are two sets of instructions LLVM can emit
for WebAssembly exceptions, Rust's Emscripten target supports
exceptions, WASI targets do not, the LLVM flags to enable this are not
always obvious, and additionally this all touches on "changing
exception-handling behavior should be a target-level concern, not a
feature". Effectively WebAssembly's exception-handling integration into
Rust is not finalized at this time. The best idea at this time is that a
parallel set of targets will eventually be added which support
exceptions, but it's not clear if/when to do this. In the meantime the
goal is to keep existing targets working while still enabling
experimentation with exception-handling with `-Zbuild-std` and various
permutations of LLVM flags.

To that extent this commit does not blanket disable these landing pads
and cleanup routines for WebAssembly but instead checks to see if
panic=unwind is enabled or if `+exception-handling` is enabled. Tests
are updated here as well to account for this where, by default, using a
`C-unwind` ABI won't affect Rust codegen at all. If
`+exception-handling` is enabled, however, then Rust codegen will look
like native platforms where exceptions are caught and the program aborts.
More-or-less I've done my best to keep exceptions working on wasm where
it's possible to have them work, but turned them off where they're not
supposed to be emitted.
---
 .../src/abort_unwinding_calls.rs              | 37 +++++++++---
 compiler/rustc_span/src/symbol.rs             |  1 +
 .../unwind-abis/c-unwind-abi-panic-abort.rs   |  9 ++-
 tests/codegen-llvm/unwind-and-panic-abort.rs  |  9 ++-
 tests/codegen-llvm/wasm_exceptions.rs         | 57 +++++++++++++------
 5 files changed, 86 insertions(+), 27 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/abort_unwinding_calls.rs b/compiler/rustc_mir_transform/src/abort_unwinding_calls.rs
index 5bd6fdcf48577..35a21a2a83429 100644
--- a/compiler/rustc_mir_transform/src/abort_unwinding_calls.rs
+++ b/compiler/rustc_mir_transform/src/abort_unwinding_calls.rs
@@ -3,6 +3,7 @@ use rustc_ast::InlineAsmOptions;
 use rustc_middle::mir::*;
 use rustc_middle::span_bug;
 use rustc_middle::ty::{self, TyCtxt, layout};
+use rustc_span::sym;
 use rustc_target::spec::PanicStrategy;
 
 /// A pass that runs which is targeted at ensuring that codegen guarantees about
@@ -33,6 +34,19 @@ impl<'tcx> crate::MirPass<'tcx> for AbortUnwindingCalls {
             return;
         }
 
+        // Represent whether this compilation target fundamentally doesn't
+        // support unwinding at all at an ABI level. If this the target has no
+        // support for unwinding then cleanup actions, for example, are all
+        // unnecessary and can be considered unreachable.
+        //
+        // Currently this is only true for wasm targets on panic=abort when the
+        // `exception-handling` target feature is disabled. In such a
+        // configuration it's illegal to emit exception-related instructions so
+        // it's not possible to unwind.
+        let target_supports_unwinding = !(tcx.sess.target.is_like_wasm
+            && tcx.sess.panic_strategy() == PanicStrategy::Abort
+            && !tcx.asm_target_features(def_id).contains(&sym::exception_handling));
+
         // Here we test for this function itself whether its ABI allows
         // unwinding or not.
         let body_ty = tcx.type_of(def_id).skip_binder();
@@ -54,12 +68,18 @@ impl<'tcx> crate::MirPass<'tcx> for AbortUnwindingCalls {
             let Some(terminator) = &mut block.terminator else { continue };
             let span = terminator.source_info.span;
 
-            // If we see an `UnwindResume` terminator inside a function that cannot unwind, we need
-            // to replace it with `UnwindTerminate`.
-            if let TerminatorKind::UnwindResume = &terminator.kind
-                && !body_can_unwind
-            {
-                terminator.kind = TerminatorKind::UnwindTerminate(UnwindTerminateReason::Abi);
+            // If we see an `UnwindResume` terminator inside a function then:
+            //
+            // * If the target doesn't support unwinding at all, then this is an
+            //   unreachable block.
+            // * If the body cannot unwind, we need to replace it with
+            //   `UnwindTerminate`.
+            if let TerminatorKind::UnwindResume = &terminator.kind {
+                if !target_supports_unwinding {
+                    terminator.kind = TerminatorKind::Unreachable;
+                } else if !body_can_unwind {
+                    terminator.kind = TerminatorKind::UnwindTerminate(UnwindTerminateReason::Abi);
+                }
             }
 
             if block.is_cleanup {
@@ -93,8 +113,9 @@ impl<'tcx> crate::MirPass<'tcx> for AbortUnwindingCalls {
                 _ => continue,
             };
 
-            if !call_can_unwind {
-                // If this function call can't unwind, then there's no need for it
+            if !call_can_unwind || !target_supports_unwinding {
+                // If this function call can't unwind, or if the target doesn't
+                // support unwinding at all, then there's no need for it
                 // to have a landing pad. This means that we can remove any cleanup
                 // registered for it (and turn it into `UnwindAction::Unreachable`).
                 let cleanup = block.terminator_mut().unwind_mut().unwrap();
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index cdb0b5b58da6d..c9c3522131689 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -938,6 +938,7 @@ symbols! {
         ermsb_target_feature,
         exact_div,
         except,
+        exception_handling: "exception-handling",
         exchange_malloc,
         exclusive_range_pattern,
         exhaustive_integer_patterns,
diff --git a/tests/codegen-llvm/unwind-abis/c-unwind-abi-panic-abort.rs b/tests/codegen-llvm/unwind-abis/c-unwind-abi-panic-abort.rs
index 8d2745ba2f7ae..2ce1d1b2e00e6 100644
--- a/tests/codegen-llvm/unwind-abis/c-unwind-abi-panic-abort.rs
+++ b/tests/codegen-llvm/unwind-abis/c-unwind-abi-panic-abort.rs
@@ -1,4 +1,9 @@
 //@ compile-flags: -C panic=abort
+//@ revisions: NONWASM WASM WASMEXN
+//@ [NONWASM] ignore-wasm32
+//@ [WASM] only-wasm32
+//@ [WASMEXN] only-wasm32
+//@ [WASMEXN] compile-flags: -Ctarget-feature=+exception-handling
 
 // Test that `nounwind` attributes are also applied to extern `C-unwind` Rust functions
 // when the code is compiled with `panic=abort`.
@@ -9,7 +14,9 @@
 #[no_mangle]
 pub unsafe extern "C-unwind" fn rust_item_that_can_unwind() {
     // Handle both legacy and v0 symbol mangling.
-    // CHECK: call void @{{.*core9panicking19panic_cannot_unwind}}
+    // NONWASM: call void @{{.*core9panicking19panic_cannot_unwind}}
+    // WASMEXN: call void @{{.*core9panicking19panic_cannot_unwind}}
+    // WASM-NOT: call void @{{.*core9panicking19panic_cannot_unwind}}
     may_unwind();
 }
 
diff --git a/tests/codegen-llvm/unwind-and-panic-abort.rs b/tests/codegen-llvm/unwind-and-panic-abort.rs
index 8efa140058ad1..c2838be00afa2 100644
--- a/tests/codegen-llvm/unwind-and-panic-abort.rs
+++ b/tests/codegen-llvm/unwind-and-panic-abort.rs
@@ -1,4 +1,9 @@
 //@ compile-flags: -C panic=abort
+//@ revisions: NONWASM WASM WASMEXN
+//@ [NONWASM] ignore-wasm32
+//@ [WASM] only-wasm32
+//@ [WASMEXN] only-wasm32
+//@ [WASMEXN] compile-flags: -Ctarget-feature=+exception-handling
 
 #![crate_type = "lib"]
 
@@ -9,7 +14,9 @@ extern "C-unwind" {
 // CHECK: Function Attrs:{{.*}}nounwind
 // CHECK-NEXT: define{{.*}}void @foo
 // Handle both legacy and v0 symbol mangling.
-// CHECK: call void @{{.*core9panicking19panic_cannot_unwind}}
+// NONWASM: call void @{{.*core9panicking19panic_cannot_unwind}}
+// WASMEXN: call void @{{.*core9panicking19panic_cannot_unwind}}
+// WASM-NOT: call void @{{.*core9panicking19panic_cannot_unwind}}
 #[no_mangle]
 pub unsafe extern "C" fn foo() {
     bar();
diff --git a/tests/codegen-llvm/wasm_exceptions.rs b/tests/codegen-llvm/wasm_exceptions.rs
index 796b69b722b51..e718f599a3c2f 100644
--- a/tests/codegen-llvm/wasm_exceptions.rs
+++ b/tests/codegen-llvm/wasm_exceptions.rs
@@ -1,8 +1,9 @@
 //@ only-wasm32
-//@ compile-flags: -C panic=unwind -Z emscripten-wasm-eh
+//@ revisions: WASM WASMEXN
+//@ [WASMEXN] compile-flags: -C panic=unwind -Z emscripten-wasm-eh
 
 #![crate_type = "lib"]
-#![feature(core_intrinsics, wasm_exception_handling_intrinsics)]
+#![feature(core_intrinsics, wasm_exception_handling_intrinsics, link_llvm_intrinsics)]
 
 extern "C-unwind" {
     fn may_panic();
@@ -22,7 +23,8 @@ impl Drop for LogOnDrop {
     }
 }
 
-// CHECK-LABEL: @test_cleanup() {{.*}} @__gxx_wasm_personality_v0
+// WASM-LABEL: @test_cleanup() {{.*}}
+// WASMEXN-LABEL: @test_cleanup() {{.*}} @__gxx_wasm_personality_v0
 #[no_mangle]
 pub fn test_cleanup() {
     let _log_on_drop = LogOnDrop;
@@ -30,12 +32,16 @@ pub fn test_cleanup() {
         may_panic();
     }
 
-    // CHECK-NOT: call
-    // CHECK: invoke void @may_panic()
-    // CHECK: %cleanuppad = cleanuppad within none []
+    // WASMEXN-NOT: call
+    // WASMEXN: invoke void @may_panic()
+    // WASMEXN: %cleanuppad = cleanuppad within none []
+    //
+    // WASM: call void @may_panic()
+    // WASM-NOT: invoke void @may_panic()
 }
 
-// CHECK-LABEL: @test_rtry() {{.*}} @__gxx_wasm_personality_v0
+// WASM-LABEL: @test_rtry() {{.*}}
+// WASMEXN-LABEL: @test_rtry() {{.*}} @__gxx_wasm_personality_v0
 #[no_mangle]
 pub fn test_rtry() {
     unsafe {
@@ -51,23 +57,40 @@ pub fn test_rtry() {
         );
     }
 
-    // CHECK-NOT: call
-    // CHECK: invoke void @may_panic()
-    // CHECK: {{.*}} = catchswitch within none [label {{.*}}] unwind to caller
-    // CHECK: {{.*}} = catchpad within {{.*}} [ptr null]
-    // CHECK: catchret
+    // WASMEXN-NOT: call
+    // WASMEXN: invoke void @may_panic()
+    // WASMEXN: {{.*}} = catchswitch within none [label {{.*}}] unwind to caller
+    // WASMEXN: {{.*}} = catchpad within {{.*}} [ptr null]
+    // WASMEXN: catchret
+
+    // WASM: call void @may_panic()
+    // WASM-NOT: invoke void @may_panic()
+    // WASM-NOT: catchswitch
+    // WASM-NOT: catchpad
+    // WASM-NOT: catchret
 }
 
 // Make sure the intrinsic is not inferred as nounwind. This is a regression test for #132416.
-// CHECK-LABEL: @test_intrinsic() {{.*}} @__gxx_wasm_personality_v0
+//
+// Note that this test uses the raw `wasm_throw` intrinsic because the one from
+// libstd was built with `-Cpanic=abort` and it's technically not valid to use
+// when this crate is compiled with `-Cpanic=unwind`.
+//
+// WASMEXN-LABEL: @test_intrinsic() {{.*}} @__gxx_wasm_personality_v0
 #[no_mangle]
+#[cfg(wasmexn)]
 pub fn test_intrinsic() {
     let _log_on_drop = LogOnDrop;
+
+    unsafe extern "C-unwind" {
+        #[link_name = "llvm.wasm.throw"]
+        fn wasm_throw(tag: i32, ptr: *mut u8) -> !;
+    }
     unsafe {
-        core::arch::wasm32::throw::<0>(core::ptr::null_mut());
+        wasm_throw(0, core::ptr::null_mut());
     }
 
-    // CHECK-NOT: call
-    // CHECK: invoke void @llvm.wasm.throw(i32 noundef 0, ptr noundef null)
-    // CHECK: %cleanuppad = cleanuppad within none []
+    // WASMEXN-NOT: call
+    // WASMEXN: invoke void @llvm.wasm.throw(i32 noundef 0, ptr noundef null)
+    // WASMEXN: %cleanuppad = cleanuppad within none []
 }

From 4c849c73a4b49ffe3a96261d95b65df1421befd9 Mon Sep 17 00:00:00 2001
From: Fang He <hf.enigma@gmail.com>
Date: Fri, 12 Sep 2025 08:18:26 +0800
Subject: [PATCH 0829/1889] fix typo in comment

---
 library/std_detect/src/detect/os/linux/aarch64.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/std_detect/src/detect/os/linux/aarch64.rs b/library/std_detect/src/detect/os/linux/aarch64.rs
index c53dbf3fd9ba6..b733b8a9eb236 100644
--- a/library/std_detect/src/detect/os/linux/aarch64.rs
+++ b/library/std_detect/src/detect/os/linux/aarch64.rs
@@ -212,7 +212,7 @@ impl From<auxvec::AuxVec> for AtHwcap {
 
         // Hardware capabilities from bits 32 to 63 should only
         // be tested on LP64 targets with 64 bits `usize`.
-        // On ILP32 targets like `aarch64-unknown-linux-gun_ilp32`,
+        // On ILP32 targets like `aarch64-unknown-linux-gnu_ilp32`,
         // these hardware capabilities will default to `false`.
         // https://github.com/rust-lang/rust/issues/146230
         #[cfg(target_pointer_width = "64")]

From 066a9794dff5d2976f77cd54bac8d6ee8aaa6c6b Mon Sep 17 00:00:00 2001
From: yanglsh <yanglsh@shanghaitech.edu.cn>
Date: Mon, 25 Aug 2025 08:20:01 +0800
Subject: [PATCH 0830/1889] fix: `invalid_upcast_comparisons` wrongly unmangled
 macros

---
 clippy_lints/src/invalid_upcast_comparisons.rs | 13 +++++++++++--
 tests/ui/invalid_upcast_comparisons.rs         | 12 ++++++++++++
 tests/ui/invalid_upcast_comparisons.stderr     |  8 +++++++-
 3 files changed, 30 insertions(+), 3 deletions(-)

diff --git a/clippy_lints/src/invalid_upcast_comparisons.rs b/clippy_lints/src/invalid_upcast_comparisons.rs
index b0ecc5d52ddb8..1666e8e5ae324 100644
--- a/clippy_lints/src/invalid_upcast_comparisons.rs
+++ b/clippy_lints/src/invalid_upcast_comparisons.rs
@@ -1,3 +1,4 @@
+use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::layout::LayoutOf;
@@ -9,7 +10,7 @@ use clippy_utils::comparisons;
 use clippy_utils::comparisons::Rel;
 use clippy_utils::consts::{ConstEvalCtxt, FullInt};
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::source::snippet;
+use clippy_utils::source::snippet_with_context;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -69,13 +70,21 @@ fn numeric_cast_precast_bounds(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<
 
 fn err_upcast_comparison(cx: &LateContext<'_>, span: Span, expr: &Expr<'_>, always: bool) {
     if let ExprKind::Cast(cast_val, _) = expr.kind {
+        let mut applicability = Applicability::MachineApplicable;
+        let (cast_val_snip, _) = snippet_with_context(
+            cx,
+            cast_val.span,
+            expr.span.ctxt(),
+            "the expression",
+            &mut applicability,
+        );
         span_lint(
             cx,
             INVALID_UPCAST_COMPARISONS,
             span,
             format!(
                 "because of the numeric bounds on `{}` prior to casting, this expression is always {}",
-                snippet(cx, cast_val.span, "the expression"),
+                cast_val_snip,
                 if always { "true" } else { "false" },
             ),
         );
diff --git a/tests/ui/invalid_upcast_comparisons.rs b/tests/ui/invalid_upcast_comparisons.rs
index 4f3194869f430..88ecca65e1509 100644
--- a/tests/ui/invalid_upcast_comparisons.rs
+++ b/tests/ui/invalid_upcast_comparisons.rs
@@ -133,3 +133,15 @@ fn main() {
 
     -5 == (u32 as i32);
 }
+
+fn issue15662() {
+    macro_rules! add_one {
+        ($x:expr) => {
+            $x + 1
+        };
+    }
+
+    let x: u8 = 1;
+    (add_one!(x) as u32) > 300;
+    //~^ invalid_upcast_comparisons
+}
diff --git a/tests/ui/invalid_upcast_comparisons.stderr b/tests/ui/invalid_upcast_comparisons.stderr
index ef36f18eabc9a..cc042a7c4b01e 100644
--- a/tests/ui/invalid_upcast_comparisons.stderr
+++ b/tests/ui/invalid_upcast_comparisons.stderr
@@ -163,5 +163,11 @@ error: because of the numeric bounds on `u8` prior to casting, this expression i
 LL |     -5 >= (u8 as i32);
    |     ^^^^^^^^^^^^^^^^^
 
-error: aborting due to 27 previous errors
+error: because of the numeric bounds on `add_one!(x)` prior to casting, this expression is always false
+  --> tests/ui/invalid_upcast_comparisons.rs:145:5
+   |
+LL |     (add_one!(x) as u32) > 300;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 28 previous errors
 

From c7c2fdd80472a99ada62e14366c7916f823fe346 Mon Sep 17 00:00:00 2001
From: Martin Nordholts <martin.nordholts@codetale.se>
Date: Wed, 10 Sep 2025 05:59:02 +0200
Subject: [PATCH 0831/1889] ci: Increase `rust.debuginfo-level-tests` to `2` in
 `x86_64-gnu-debug` job

Simply to increase the scope of the testing.

Force debuginfo=0 for a handful of tests so that we can have CI prevent
regressing on more tests.
---
 src/ci/docker/host-x86_64/x86_64-gnu-debug/Dockerfile  |  2 +-
 .../ui/async-await/future-sizes/async-awaiting-fut.rs  |  2 ++
 tests/ui/async-await/future-sizes/large-arg.rs         |  2 ++
 .../collect-in-promoted-const.noopt.stderr             |  6 +++---
 .../collect-in-promoted-const.opt.stderr               | 10 +++++-----
 .../required-consts/collect-in-promoted-const.rs       |  2 ++
 tests/ui/print_type_sizes/async.rs                     |  2 ++
 7 files changed, 17 insertions(+), 9 deletions(-)

diff --git a/src/ci/docker/host-x86_64/x86_64-gnu-debug/Dockerfile b/src/ci/docker/host-x86_64/x86_64-gnu-debug/Dockerfile
index 7e6a59aaf898e..54b13c4397f47 100644
--- a/src/ci/docker/host-x86_64/x86_64-gnu-debug/Dockerfile
+++ b/src/ci/docker/host-x86_64/x86_64-gnu-debug/Dockerfile
@@ -38,7 +38,7 @@ ENV RUST_CONFIGURE_ARGS \
       --build=x86_64-unknown-linux-gnu \
       --enable-debug \
       --enable-lld \
-      --set rust.debuginfo-level-tests=1 \
+      --set rust.debuginfo-level-tests=2 \
       --set llvm.use-linker=lld \
       --set target.x86_64-unknown-linux-gnu.linker=clang \
       --set target.x86_64-unknown-linux-gnu.cc=clang \
diff --git a/tests/ui/async-await/future-sizes/async-awaiting-fut.rs b/tests/ui/async-await/future-sizes/async-awaiting-fut.rs
index b5f59069f85b6..7113f591630d1 100644
--- a/tests/ui/async-await/future-sizes/async-awaiting-fut.rs
+++ b/tests/ui/async-await/future-sizes/async-awaiting-fut.rs
@@ -1,3 +1,5 @@
+// FIXME(#61117): Respect debuginfo-level-tests, do not force debuginfo=0
+//@ compile-flags: -C debuginfo=0
 //@ compile-flags: -C panic=abort -Z print-type-sizes --crate-type lib
 //@ needs-deterministic-layouts
 //@ edition:2021
diff --git a/tests/ui/async-await/future-sizes/large-arg.rs b/tests/ui/async-await/future-sizes/large-arg.rs
index 809f7cf1f93c6..b05a2b7191512 100644
--- a/tests/ui/async-await/future-sizes/large-arg.rs
+++ b/tests/ui/async-await/future-sizes/large-arg.rs
@@ -1,3 +1,5 @@
+// FIXME(#61117): Respect debuginfo-level-tests, do not force debuginfo=0
+//@ compile-flags: -C debuginfo=0
 //@ compile-flags: -C panic=abort -Z print-type-sizes --crate-type=lib
 //@ needs-deterministic-layouts
 //@ edition: 2021
diff --git a/tests/ui/consts/required-consts/collect-in-promoted-const.noopt.stderr b/tests/ui/consts/required-consts/collect-in-promoted-const.noopt.stderr
index 67f5009c4ffcf..c1ae42b3939dc 100644
--- a/tests/ui/consts/required-consts/collect-in-promoted-const.noopt.stderr
+++ b/tests/ui/consts/required-consts/collect-in-promoted-const.noopt.stderr
@@ -1,17 +1,17 @@
 error[E0080]: evaluation panicked: explicit panic
-  --> $DIR/collect-in-promoted-const.rs:9:19
+  --> $DIR/collect-in-promoted-const.rs:11:19
    |
 LL |     const C: () = panic!();
    |                   ^^^^^^^^ evaluation of `Fail::<i32>::C` failed here
 
 note: erroneous constant encountered
-  --> $DIR/collect-in-promoted-const.rs:20:21
+  --> $DIR/collect-in-promoted-const.rs:22:21
    |
 LL |         let _val = &Fail::<T>::C;
    |                     ^^^^^^^^^^^^
 
 note: the above error was encountered while instantiating `fn f::<i32>`
-  --> $DIR/collect-in-promoted-const.rs:25:5
+  --> $DIR/collect-in-promoted-const.rs:27:5
    |
 LL |     f::<i32>();
    |     ^^^^^^^^^^
diff --git a/tests/ui/consts/required-consts/collect-in-promoted-const.opt.stderr b/tests/ui/consts/required-consts/collect-in-promoted-const.opt.stderr
index 5c3edf68d95f7..0d7ac48172c8c 100644
--- a/tests/ui/consts/required-consts/collect-in-promoted-const.opt.stderr
+++ b/tests/ui/consts/required-consts/collect-in-promoted-const.opt.stderr
@@ -1,23 +1,23 @@
 error[E0080]: evaluation panicked: explicit panic
-  --> $DIR/collect-in-promoted-const.rs:9:19
+  --> $DIR/collect-in-promoted-const.rs:11:19
    |
 LL |     const C: () = panic!();
    |                   ^^^^^^^^ evaluation of `Fail::<T>::C` failed here
 
 note: erroneous constant encountered
-  --> $DIR/collect-in-promoted-const.rs:20:21
+  --> $DIR/collect-in-promoted-const.rs:22:21
    |
 LL |         let _val = &Fail::<T>::C;
    |                     ^^^^^^^^^^^^
 
 error[E0080]: evaluation panicked: explicit panic
-  --> $DIR/collect-in-promoted-const.rs:9:19
+  --> $DIR/collect-in-promoted-const.rs:11:19
    |
 LL |     const C: () = panic!();
    |                   ^^^^^^^^ evaluation of `Fail::<i32>::C` failed here
 
 note: erroneous constant encountered
-  --> $DIR/collect-in-promoted-const.rs:20:21
+  --> $DIR/collect-in-promoted-const.rs:22:21
    |
 LL |         let _val = &Fail::<T>::C;
    |                     ^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL |         let _val = &Fail::<T>::C;
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 note: the above error was encountered while instantiating `fn f::<i32>`
-  --> $DIR/collect-in-promoted-const.rs:25:5
+  --> $DIR/collect-in-promoted-const.rs:27:5
    |
 LL |     f::<i32>();
    |     ^^^^^^^^^^
diff --git a/tests/ui/consts/required-consts/collect-in-promoted-const.rs b/tests/ui/consts/required-consts/collect-in-promoted-const.rs
index 25c8cb7e80490..498328abe2160 100644
--- a/tests/ui/consts/required-consts/collect-in-promoted-const.rs
+++ b/tests/ui/consts/required-consts/collect-in-promoted-const.rs
@@ -1,6 +1,8 @@
 //@revisions: noopt opt
 //@ build-fail
 //@[noopt] compile-flags: -Copt-level=0
+// FIXME(#61117): Respect debuginfo-level-tests, do not force debuginfo=0
+//@[opt] compile-flags: -C debuginfo=0
 //@[opt] compile-flags: -O
 //! Make sure we error on erroneous consts even if they get promoted.
 
diff --git a/tests/ui/print_type_sizes/async.rs b/tests/ui/print_type_sizes/async.rs
index 951e7cd1012cf..b6ec88426345b 100644
--- a/tests/ui/print_type_sizes/async.rs
+++ b/tests/ui/print_type_sizes/async.rs
@@ -1,3 +1,5 @@
+// FIXME(#61117): Respect debuginfo-level-tests, do not force debuginfo=0
+//@ compile-flags: -C debuginfo=0
 //@ compile-flags: -C panic=abort -Z print-type-sizes --crate-type lib
 //@ needs-deterministic-layouts
 //@ edition:2021

From 44edbc6d54e0bd3f9eea882ed5cd7646d6b79523 Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Fri, 12 Sep 2025 04:52:27 +0000
Subject: [PATCH 0832/1889] Prepare for merging from rust-lang/rust

This updates the rust-version file to 2a9bacf6187685931d52346a0ecff2e52bdc91cc.
---
 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 b71a0d219d778..b3f8a26875f40 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-f4665ab8368ad2e8a86d4390ae35c28bdd9561bb
+2a9bacf6187685931d52346a0ecff2e52bdc91cc

From 745b79097f5e0b22819dafc6dcc9a857dc7479d2 Mon Sep 17 00:00:00 2001
From: Teodoro Freund <tfreund95@gmail.com>
Date: Wed, 10 Sep 2025 08:03:53 +0100
Subject: [PATCH 0833/1889] Only suggest type in as_underscore when it's
 suggestable

---
 clippy_lints/src/casts/as_underscore.rs |  8 ++++----
 tests/ui/as_underscore_unfixable.rs     | 14 ++++++++++++++
 tests/ui/as_underscore_unfixable.stderr | 20 ++++++++++++++++++++
 3 files changed, 38 insertions(+), 4 deletions(-)
 create mode 100644 tests/ui/as_underscore_unfixable.rs
 create mode 100644 tests/ui/as_underscore_unfixable.stderr

diff --git a/clippy_lints/src/casts/as_underscore.rs b/clippy_lints/src/casts/as_underscore.rs
index 3ac486dd63fbb..a73e48e5fd5d1 100644
--- a/clippy_lints/src/casts/as_underscore.rs
+++ b/clippy_lints/src/casts/as_underscore.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Ty, TyKind};
 use rustc_lint::LateContext;
-use rustc_middle::ty;
+use rustc_middle::ty::IsSuggestable;
 
 use super::AS_UNDERSCORE;
 
@@ -10,15 +10,15 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, ty: &'tc
     if matches!(ty.kind, TyKind::Infer(())) {
         span_lint_and_then(cx, AS_UNDERSCORE, expr.span, "using `as _` conversion", |diag| {
             let ty_resolved = cx.typeck_results().expr_ty(expr);
-            if let ty::Error(_) = ty_resolved.kind() {
-                diag.help("consider giving the type explicitly");
-            } else {
+            if ty_resolved.is_suggestable(cx.tcx, true) {
                 diag.span_suggestion(
                     ty.span,
                     "consider giving the type explicitly",
                     ty_resolved,
                     Applicability::MachineApplicable,
                 );
+            } else {
+                diag.help("consider giving the type explicitly");
             }
         });
     }
diff --git a/tests/ui/as_underscore_unfixable.rs b/tests/ui/as_underscore_unfixable.rs
new file mode 100644
index 0000000000000..854feca7174fb
--- /dev/null
+++ b/tests/ui/as_underscore_unfixable.rs
@@ -0,0 +1,14 @@
+//@no-rustfix
+
+#![warn(clippy::as_underscore)]
+
+fn main() {
+    // From issue #15282
+    let f = async || ();
+    let _: Box<dyn FnOnce() -> _> = Box::new(f) as _;
+    //~^ as_underscore
+
+    let barr = || (|| ());
+    let _: Box<dyn Fn() -> _> = Box::new(barr) as _;
+    //~^ as_underscore
+}
diff --git a/tests/ui/as_underscore_unfixable.stderr b/tests/ui/as_underscore_unfixable.stderr
new file mode 100644
index 0000000000000..7385bea5c6501
--- /dev/null
+++ b/tests/ui/as_underscore_unfixable.stderr
@@ -0,0 +1,20 @@
+error: using `as _` conversion
+  --> tests/ui/as_underscore_unfixable.rs:8:37
+   |
+LL |     let _: Box<dyn FnOnce() -> _> = Box::new(f) as _;
+   |                                     ^^^^^^^^^^^^^^^^
+   |
+   = help: consider giving the type explicitly
+   = note: `-D clippy::as-underscore` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::as_underscore)]`
+
+error: using `as _` conversion
+  --> tests/ui/as_underscore_unfixable.rs:12:33
+   |
+LL |     let _: Box<dyn Fn() -> _> = Box::new(barr) as _;
+   |                                 ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider giving the type explicitly
+
+error: aborting due to 2 previous errors
+

From dbfa01b6a19ac62ba559e38c2b95ef26fd90ee39 Mon Sep 17 00:00:00 2001
From: klensy <klensy@users.noreply.github.com>
Date: Fri, 12 Sep 2025 12:03:09 +0300
Subject: [PATCH 0834/1889] remove outdated jsbackend leftovers

---
 compiler/rustc_llvm/build.rs   | 1 -
 compiler/rustc_llvm/src/lib.rs | 6 ------
 2 files changed, 7 deletions(-)

diff --git a/compiler/rustc_llvm/build.rs b/compiler/rustc_llvm/build.rs
index 9d21d0d22e3e5..2cfda7a5fb4b2 100644
--- a/compiler/rustc_llvm/build.rs
+++ b/compiler/rustc_llvm/build.rs
@@ -16,7 +16,6 @@ const OPTIONAL_COMPONENTS: &[&str] = &[
     "mips",
     "powerpc",
     "systemz",
-    "jsbackend",
     "webassembly",
     "msp430",
     "sparc",
diff --git a/compiler/rustc_llvm/src/lib.rs b/compiler/rustc_llvm/src/lib.rs
index ed5edeef1617d..14e94121d1cb8 100644
--- a/compiler/rustc_llvm/src/lib.rs
+++ b/compiler/rustc_llvm/src/lib.rs
@@ -179,12 +179,6 @@ pub fn initialize_available_targets() {
         LLVMInitializeSystemZAsmPrinter,
         LLVMInitializeSystemZAsmParser
     );
-    init_target!(
-        llvm_component = "jsbackend",
-        LLVMInitializeJSBackendTargetInfo,
-        LLVMInitializeJSBackendTarget,
-        LLVMInitializeJSBackendTargetMC
-    );
     init_target!(
         llvm_component = "msp430",
         LLVMInitializeMSP430TargetInfo,

From ff9b1c1d285821fabe3cbf904fc407d62d95fbdc Mon Sep 17 00:00:00 2001
From: Evgenii Zheltonozhskii <zheltonozhskiy@gmail.com>
Date: Fri, 12 Sep 2025 12:39:31 +0300
Subject: [PATCH 0835/1889] Constify Eq, Ord, PartialOrd

---
 library/core/src/any.rs                       |   3 +-
 library/core/src/array/equality.rs            |  46 +++--
 library/core/src/ascii/ascii_char.rs          |   3 +-
 library/core/src/cmp.rs                       | 162 ++++++++++++------
 library/core/src/convert/mod.rs               |   9 +-
 library/core/src/num/nonzero.rs               |  17 +-
 library/core/src/ops/control_flow.rs          |   3 +-
 library/core/src/option.rs                    |   9 +-
 library/core/src/range.rs                     |   6 +-
 library/core/src/result.rs                    |   3 +-
 library/core/src/slice/cmp.rs                 |  43 +++--
 library/core/src/str/traits.rs                |   3 +-
 library/core/src/tuple.rs                     |  12 +-
 library/coretests/tests/cmp.rs                |   6 +-
 library/coretests/tests/lib.rs                |   1 +
 tests/ui/consts/const_cmp_type_id.rs          |   5 +-
 tests/ui/consts/const_cmp_type_id.stderr      |   8 +-
 tests/ui/consts/fn_trait_refs.rs              |   3 +-
 tests/ui/consts/fn_trait_refs.stderr          |  22 ---
 .../traits/const-traits/const-impl-trait.rs   |   4 +-
 .../const-traits/const-impl-trait.stderr      |  17 --
 .../const_derives/derive-const-use.rs         |   3 +-
 .../const_derives/derive-const-use.stderr     |  11 --
 23 files changed, 226 insertions(+), 173 deletions(-)
 delete mode 100644 tests/ui/consts/fn_trait_refs.stderr
 delete mode 100644 tests/ui/traits/const-traits/const-impl-trait.stderr
 delete mode 100644 tests/ui/traits/const-traits/const_derives/derive-const-use.stderr

diff --git a/library/core/src/any.rs b/library/core/src/any.rs
index e7d9763d46ef5..76ea2d18a82f4 100644
--- a/library/core/src/any.rs
+++ b/library/core/src/any.rs
@@ -705,7 +705,8 @@ impl dyn Any + Send + Sync {
 ///     std::mem::forget(fake_one_ring);
 /// }
 /// ```
-#[derive(Clone, Copy, Eq, PartialOrd, Ord)]
+#[derive(Copy, PartialOrd, Ord)]
+#[derive_const(Clone, Eq)]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[lang = "type_id"]
 pub struct TypeId {
diff --git a/library/core/src/array/equality.rs b/library/core/src/array/equality.rs
index 1ad2cca64a347..c2c7ccf0daa23 100644
--- a/library/core/src/array/equality.rs
+++ b/library/core/src/array/equality.rs
@@ -1,9 +1,10 @@
 use crate::cmp::BytewiseEq;
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, U, const N: usize> PartialEq<[U; N]> for [T; N]
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<T, U, const N: usize> const PartialEq<[U; N]> for [T; N]
 where
-    T: PartialEq<U>,
+    T: [const] PartialEq<U>,
 {
     #[inline]
     fn eq(&self, other: &[U; N]) -> bool {
@@ -16,9 +17,10 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, U, const N: usize> PartialEq<[U]> for [T; N]
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<T, U, const N: usize> const PartialEq<[U]> for [T; N]
 where
-    T: PartialEq<U>,
+    T: [const] PartialEq<U>,
 {
     #[inline]
     fn eq(&self, other: &[U]) -> bool {
@@ -37,9 +39,10 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, U, const N: usize> PartialEq<[U; N]> for [T]
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<T, U, const N: usize> const PartialEq<[U; N]> for [T]
 where
-    T: PartialEq<U>,
+    T: [const] PartialEq<U>,
 {
     #[inline]
     fn eq(&self, other: &[U; N]) -> bool {
@@ -58,9 +61,10 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, U, const N: usize> PartialEq<&[U]> for [T; N]
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<T, U, const N: usize> const PartialEq<&[U]> for [T; N]
 where
-    T: PartialEq<U>,
+    T: [const] PartialEq<U>,
 {
     #[inline]
     fn eq(&self, other: &&[U]) -> bool {
@@ -73,9 +77,10 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, U, const N: usize> PartialEq<[U; N]> for &[T]
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<T, U, const N: usize> const PartialEq<[U; N]> for &[T]
 where
-    T: PartialEq<U>,
+    T: [const] PartialEq<U>,
 {
     #[inline]
     fn eq(&self, other: &[U; N]) -> bool {
@@ -88,9 +93,10 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, U, const N: usize> PartialEq<&mut [U]> for [T; N]
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<T, U, const N: usize> const PartialEq<&mut [U]> for [T; N]
 where
-    T: PartialEq<U>,
+    T: [const] PartialEq<U>,
 {
     #[inline]
     fn eq(&self, other: &&mut [U]) -> bool {
@@ -103,9 +109,10 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, U, const N: usize> PartialEq<[U; N]> for &mut [T]
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<T, U, const N: usize> const PartialEq<[U; N]> for &mut [T]
 where
-    T: PartialEq<U>,
+    T: [const] PartialEq<U>,
 {
     #[inline]
     fn eq(&self, other: &[U; N]) -> bool {
@@ -122,14 +129,18 @@ where
 // __impl_slice_eq2! { [A; $N], &'b mut [B; $N] }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Eq, const N: usize> Eq for [T; N] {}
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<T: [const] Eq, const N: usize> const Eq for [T; N] {}
 
+#[const_trait]
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
 trait SpecArrayEq<Other, const N: usize>: Sized {
     fn spec_eq(a: &[Self; N], b: &[Other; N]) -> bool;
     fn spec_ne(a: &[Self; N], b: &[Other; N]) -> bool;
 }
 
-impl<T: PartialEq<Other>, Other, const N: usize> SpecArrayEq<Other, N> for T {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<T: [const] PartialEq<Other>, Other, const N: usize> const SpecArrayEq<Other, N> for T {
     default fn spec_eq(a: &[Self; N], b: &[Other; N]) -> bool {
         a[..] == b[..]
     }
@@ -138,7 +149,8 @@ impl<T: PartialEq<Other>, Other, const N: usize> SpecArrayEq<Other, N> for T {
     }
 }
 
-impl<T: BytewiseEq<U>, U, const N: usize> SpecArrayEq<U, N> for T {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<T: [const] BytewiseEq<U>, U, const N: usize> const SpecArrayEq<U, N> for T {
     fn spec_eq(a: &[T; N], b: &[U; N]) -> bool {
         // SAFETY: Arrays are compared element-wise, and don't add any padding
         // between elements, so when the elements are `BytewiseEq`, we can
diff --git a/library/core/src/ascii/ascii_char.rs b/library/core/src/ascii/ascii_char.rs
index 49d540314a245..178af2c0e3b46 100644
--- a/library/core/src/ascii/ascii_char.rs
+++ b/library/core/src/ascii/ascii_char.rs
@@ -54,7 +54,8 @@ use crate::{assert_unsafe_precondition, fmt};
 /// [chart]: https://www.unicode.org/charts/PDF/U0000.pdf
 /// [NIST FIPS 1-2]: https://nvlpubs.nist.gov/nistpubs/Legacy/FIPS/fipspub1-2-1977.pdf
 /// [NamesList]: https://www.unicode.org/Public/15.0.0/ucd/NamesList.txt
-#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[derive(Copy, Hash)]
+#[derive_const(Clone, Eq, PartialEq, Ord, PartialOrd)]
 #[unstable(feature = "ascii_char", issue = "110998")]
 #[repr(u8)]
 pub enum AsciiChar {
diff --git a/library/core/src/cmp.rs b/library/core/src/cmp.rs
index 0812322f3fbb0..94536f25b4197 100644
--- a/library/core/src/cmp.rs
+++ b/library/core/src/cmp.rs
@@ -29,7 +29,7 @@ mod bytewise;
 pub(crate) use bytewise::BytewiseEq;
 
 use self::Ordering::*;
-use crate::marker::PointeeSized;
+use crate::marker::{Destruct, PointeeSized};
 use crate::ops::ControlFlow;
 
 /// Trait for comparisons using the equality operator.
@@ -334,7 +334,9 @@ pub macro PartialEq($item:item) {
 #[doc(alias = "!=")]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_diagnostic_item = "Eq"]
-pub trait Eq: PartialEq<Self> + PointeeSized {
+#[const_trait]
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+pub trait Eq: [const] PartialEq<Self> + PointeeSized {
     // this method is used solely by `impl Eq or #[derive(Eq)]` to assert that every component of a
     // type implements `Eq` itself. The current deriving infrastructure means doing this assertion
     // without using a method on this trait is nearly impossible.
@@ -380,8 +382,8 @@ pub struct AssertParamIsEq<T: Eq + PointeeSized> {
 ///
 /// assert_eq!(2.cmp(&1), Ordering::Greater);
 /// ```
-#[derive(Clone, Copy, Eq, PartialOrd, Ord, Debug, Hash)]
-#[derive_const(PartialEq)]
+#[derive(Copy, Debug, Hash)]
+#[derive_const(Clone, Eq, PartialOrd, Ord, PartialEq)]
 #[stable(feature = "rust1", since = "1.0.0")]
 // This is a lang item only so that `BinOp::Cmp` in MIR can return it.
 // It has no special behavior, but does require that the three variants
@@ -635,7 +637,11 @@ impl Ordering {
     #[inline]
     #[must_use]
     #[stable(feature = "ordering_chaining", since = "1.17.0")]
-    pub fn then_with<F: FnOnce() -> Ordering>(self, f: F) -> Ordering {
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    pub const fn then_with<F>(self, f: F) -> Ordering
+    where
+        F: [const] FnOnce() -> Ordering + [const] Destruct,
+    {
         match self {
             Equal => f(),
             _ => self,
@@ -659,13 +665,15 @@ impl Ordering {
 /// v.sort_by_key(|&num| (num > 3, Reverse(num)));
 /// assert_eq!(v, vec![3, 2, 1, 6, 5, 4]);
 /// ```
-#[derive(PartialEq, Eq, Debug, Copy, Default, Hash)]
+#[derive(Copy, Debug, Hash)]
+#[derive_const(PartialEq, Eq, Default)]
 #[stable(feature = "reverse_cmp_key", since = "1.19.0")]
 #[repr(transparent)]
 pub struct Reverse<T>(#[stable(feature = "reverse_cmp_key", since = "1.19.0")] pub T);
 
 #[stable(feature = "reverse_cmp_key", since = "1.19.0")]
-impl<T: PartialOrd> PartialOrd for Reverse<T> {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<T: [const] PartialOrd> const PartialOrd for Reverse<T> {
     #[inline]
     fn partial_cmp(&self, other: &Reverse<T>) -> Option<Ordering> {
         other.0.partial_cmp(&self.0)
@@ -690,7 +698,8 @@ impl<T: PartialOrd> PartialOrd for Reverse<T> {
 }
 
 #[stable(feature = "reverse_cmp_key", since = "1.19.0")]
-impl<T: Ord> Ord for Reverse<T> {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<T: [const] Ord> const Ord for Reverse<T> {
     #[inline]
     fn cmp(&self, other: &Reverse<T>) -> Ordering {
         other.0.cmp(&self.0)
@@ -957,7 +966,9 @@ impl<T: Clone> Clone for Reverse<T> {
 #[doc(alias = ">=")]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_diagnostic_item = "Ord"]
-pub trait Ord: Eq + PartialOrd<Self> + PointeeSized {
+#[const_trait]
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+pub trait Ord: [const] Eq + [const] PartialOrd<Self> + PointeeSized {
     /// This method returns an [`Ordering`] between `self` and `other`.
     ///
     /// By convention, `self.cmp(&other)` returns the ordering matching the expression
@@ -1011,7 +1022,7 @@ pub trait Ord: Eq + PartialOrd<Self> + PointeeSized {
     #[rustc_diagnostic_item = "cmp_ord_max"]
     fn max(self, other: Self) -> Self
     where
-        Self: Sized,
+        Self: Sized + [const] Destruct,
     {
         if other < self { self } else { other }
     }
@@ -1050,7 +1061,7 @@ pub trait Ord: Eq + PartialOrd<Self> + PointeeSized {
     #[rustc_diagnostic_item = "cmp_ord_min"]
     fn min(self, other: Self) -> Self
     where
-        Self: Sized,
+        Self: Sized + [const] Destruct,
     {
         if other < self { other } else { self }
     }
@@ -1076,7 +1087,7 @@ pub trait Ord: Eq + PartialOrd<Self> + PointeeSized {
     #[stable(feature = "clamp", since = "1.50.0")]
     fn clamp(self, min: Self, max: Self) -> Self
     where
-        Self: Sized,
+        Self: Sized + [const] Destruct,
     {
         assert!(min <= max);
         if self < min {
@@ -1341,6 +1352,8 @@ pub macro Ord($item:item) {
 )]
 #[rustc_diagnostic_item = "PartialOrd"]
 #[allow(multiple_supertrait_upcastable)] // FIXME(sized_hierarchy): remove this
+#[const_trait]
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
 pub trait PartialOrd<Rhs: PointeeSized = Self>: PartialEq<Rhs> + PointeeSized {
     /// This method returns an ordering between `self` and `other` values if one exists.
     ///
@@ -1481,13 +1494,14 @@ pub trait PartialOrd<Rhs: PointeeSized = Self>: PartialEq<Rhs> + PointeeSized {
     }
 }
 
-fn default_chaining_impl<T, U>(
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+const fn default_chaining_impl<T, U>(
     lhs: &T,
     rhs: &U,
-    p: impl FnOnce(Ordering) -> bool,
+    p: impl [const] FnOnce(Ordering) -> bool + [const] Destruct,
 ) -> ControlFlow<bool>
 where
-    T: PartialOrd<U> + PointeeSized,
+    T: [const] PartialOrd<U> + PointeeSized,
     U: PointeeSized,
 {
     // It's important that this only call `partial_cmp` once, not call `eq` then
@@ -1545,7 +1559,8 @@ pub macro PartialOrd($item:item) {
 #[must_use]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_diagnostic_item = "cmp_min"]
-pub fn min<T: Ord>(v1: T, v2: T) -> T {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+pub const fn min<T: [const] Ord + [const] Destruct>(v1: T, v2: T) -> T {
     v1.min(v2)
 }
 
@@ -1575,7 +1590,12 @@ pub fn min<T: Ord>(v1: T, v2: T) -> T {
 #[inline]
 #[must_use]
 #[stable(feature = "cmp_min_max_by", since = "1.53.0")]
-pub fn min_by<T, F: FnOnce(&T, &T) -> Ordering>(v1: T, v2: T, compare: F) -> T {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+pub const fn min_by<T: [const] Destruct, F: [const] FnOnce(&T, &T) -> Ordering>(
+    v1: T,
+    v2: T,
+    compare: F,
+) -> T {
     if compare(&v1, &v2).is_le() { v1 } else { v2 }
 }
 
@@ -1600,7 +1620,13 @@ pub fn min_by<T, F: FnOnce(&T, &T) -> Ordering>(v1: T, v2: T, compare: F) -> T {
 #[inline]
 #[must_use]
 #[stable(feature = "cmp_min_max_by", since = "1.53.0")]
-pub fn min_by_key<T, F: FnMut(&T) -> K, K: Ord>(v1: T, v2: T, mut f: F) -> T {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+pub const fn min_by_key<T, F, K>(v1: T, v2: T, mut f: F) -> T
+where
+    T: [const] Destruct,
+    F: [const] FnMut(&T) -> K + [const] Destruct,
+    K: [const] Ord + [const] Destruct,
+{
     if f(&v2) < f(&v1) { v2 } else { v1 }
 }
 
@@ -1640,7 +1666,8 @@ pub fn min_by_key<T, F: FnMut(&T) -> K, K: Ord>(v1: T, v2: T, mut f: F) -> T {
 #[must_use]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_diagnostic_item = "cmp_max"]
-pub fn max<T: Ord>(v1: T, v2: T) -> T {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+pub const fn max<T: [const] Ord + [const] Destruct>(v1: T, v2: T) -> T {
     v1.max(v2)
 }
 
@@ -1670,7 +1697,12 @@ pub fn max<T: Ord>(v1: T, v2: T) -> T {
 #[inline]
 #[must_use]
 #[stable(feature = "cmp_min_max_by", since = "1.53.0")]
-pub fn max_by<T, F: FnOnce(&T, &T) -> Ordering>(v1: T, v2: T, compare: F) -> T {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+pub const fn max_by<T: [const] Destruct, F: [const] FnOnce(&T, &T) -> Ordering>(
+    v1: T,
+    v2: T,
+    compare: F,
+) -> T {
     if compare(&v1, &v2).is_gt() { v1 } else { v2 }
 }
 
@@ -1695,7 +1727,13 @@ pub fn max_by<T, F: FnOnce(&T, &T) -> Ordering>(v1: T, v2: T, compare: F) -> T {
 #[inline]
 #[must_use]
 #[stable(feature = "cmp_min_max_by", since = "1.53.0")]
-pub fn max_by_key<T, F: FnMut(&T) -> K, K: Ord>(v1: T, v2: T, mut f: F) -> T {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+pub const fn max_by_key<T, F, K>(v1: T, v2: T, mut f: F) -> T
+where
+    T: [const] Destruct,
+    F: [const] FnMut(&T) -> K + [const] Destruct,
+    K: [const] Ord + [const] Destruct,
+{
     if f(&v2) < f(&v1) { v1 } else { v2 }
 }
 
@@ -1739,9 +1777,10 @@ pub fn max_by_key<T, F: FnMut(&T) -> K, K: Ord>(v1: T, v2: T, mut f: F) -> T {
 #[inline]
 #[must_use]
 #[unstable(feature = "cmp_minmax", issue = "115939")]
-pub fn minmax<T>(v1: T, v2: T) -> [T; 2]
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+pub const fn minmax<T>(v1: T, v2: T) -> [T; 2]
 where
-    T: Ord,
+    T: [const] Ord,
 {
     if v2 < v1 { [v2, v1] } else { [v1, v2] }
 }
@@ -1773,9 +1812,10 @@ where
 #[inline]
 #[must_use]
 #[unstable(feature = "cmp_minmax", issue = "115939")]
-pub fn minmax_by<T, F>(v1: T, v2: T, compare: F) -> [T; 2]
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+pub const fn minmax_by<T, F>(v1: T, v2: T, compare: F) -> [T; 2]
 where
-    F: FnOnce(&T, &T) -> Ordering,
+    F: [const] FnOnce(&T, &T) -> Ordering,
 {
     if compare(&v1, &v2).is_le() { [v1, v2] } else { [v2, v1] }
 }
@@ -1801,10 +1841,11 @@ where
 #[inline]
 #[must_use]
 #[unstable(feature = "cmp_minmax", issue = "115939")]
-pub fn minmax_by_key<T, F, K>(v1: T, v2: T, mut f: F) -> [T; 2]
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+pub const fn minmax_by_key<T, F, K>(v1: T, v2: T, mut f: F) -> [T; 2]
 where
-    F: FnMut(&T) -> K,
-    K: Ord,
+    F: [const] FnMut(&T) -> K + [const] Destruct,
+    K: [const] Ord + [const] Destruct,
 {
     if f(&v2) < f(&v1) { [v2, v1] } else { [v1, v2] }
 }
@@ -1830,7 +1871,8 @@ mod impls {
     }
 
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl PartialEq for () {
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    impl const PartialEq for () {
         #[inline]
         fn eq(&self, _other: &()) -> bool {
             true
@@ -1848,7 +1890,8 @@ mod impls {
     macro_rules! eq_impl {
         ($($t:ty)*) => ($(
             #[stable(feature = "rust1", since = "1.0.0")]
-            impl Eq for $t {}
+            #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+            impl const Eq for $t {}
         )*)
     }
 
@@ -1896,7 +1939,8 @@ mod impls {
     macro_rules! partial_ord_impl {
         ($($t:ty)*) => ($(
             #[stable(feature = "rust1", since = "1.0.0")]
-            impl PartialOrd for $t {
+            #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+            impl const PartialOrd for $t {
                 #[inline]
                 fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
                     match (*self <= *other, *self >= *other) {
@@ -1913,7 +1957,8 @@ mod impls {
     }
 
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl PartialOrd for () {
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    impl const PartialOrd for () {
         #[inline]
         fn partial_cmp(&self, _: &()) -> Option<Ordering> {
             Some(Equal)
@@ -1921,7 +1966,8 @@ mod impls {
     }
 
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl PartialOrd for bool {
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    impl const PartialOrd for bool {
         #[inline]
         fn partial_cmp(&self, other: &bool) -> Option<Ordering> {
             Some(self.cmp(other))
@@ -1935,7 +1981,8 @@ mod impls {
     macro_rules! ord_impl {
         ($($t:ty)*) => ($(
             #[stable(feature = "rust1", since = "1.0.0")]
-            impl PartialOrd for $t {
+            #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+            impl const PartialOrd for $t {
                 #[inline]
                 fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
                     Some(crate::intrinsics::three_way_compare(*self, *other))
@@ -1945,7 +1992,8 @@ mod impls {
             }
 
             #[stable(feature = "rust1", since = "1.0.0")]
-            impl Ord for $t {
+            #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+            impl const Ord for $t {
                 #[inline]
                 fn cmp(&self, other: &Self) -> Ordering {
                     crate::intrinsics::three_way_compare(*self, *other)
@@ -1955,7 +2003,8 @@ mod impls {
     }
 
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl Ord for () {
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    impl const Ord for () {
         #[inline]
         fn cmp(&self, _other: &()) -> Ordering {
             Equal
@@ -1963,7 +2012,8 @@ mod impls {
     }
 
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl Ord for bool {
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    impl const Ord for bool {
         #[inline]
         fn cmp(&self, other: &bool) -> Ordering {
             // Casting to i8's and converting the difference to an Ordering generates
@@ -1998,7 +2048,8 @@ mod impls {
     ord_impl! { char usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }
 
     #[unstable(feature = "never_type", issue = "35121")]
-    impl PartialEq for ! {
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    impl const PartialEq for ! {
         #[inline]
         fn eq(&self, _: &!) -> bool {
             *self
@@ -2006,10 +2057,12 @@ mod impls {
     }
 
     #[unstable(feature = "never_type", issue = "35121")]
-    impl Eq for ! {}
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    impl const Eq for ! {}
 
     #[unstable(feature = "never_type", issue = "35121")]
-    impl PartialOrd for ! {
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    impl const PartialOrd for ! {
         #[inline]
         fn partial_cmp(&self, _: &!) -> Option<Ordering> {
             *self
@@ -2017,7 +2070,8 @@ mod impls {
     }
 
     #[unstable(feature = "never_type", issue = "35121")]
-    impl Ord for ! {
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    impl const Ord for ! {
         #[inline]
         fn cmp(&self, _: &!) -> Ordering {
             *self
@@ -2042,9 +2096,10 @@ mod impls {
         }
     }
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl<A: PointeeSized, B: PointeeSized> PartialOrd<&B> for &A
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    impl<A: PointeeSized, B: PointeeSized> const PartialOrd<&B> for &A
     where
-        A: PartialOrd<B>,
+        A: [const] PartialOrd<B>,
     {
         #[inline]
         fn partial_cmp(&self, other: &&B) -> Option<Ordering> {
@@ -2084,9 +2139,10 @@ mod impls {
         }
     }
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl<A: PointeeSized> Ord for &A
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    impl<A: PointeeSized> const Ord for &A
     where
-        A: Ord,
+        A: [const] Ord,
     {
         #[inline]
         fn cmp(&self, other: &Self) -> Ordering {
@@ -2094,7 +2150,8 @@ mod impls {
         }
     }
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl<A: PointeeSized> Eq for &A where A: Eq {}
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    impl<A: PointeeSized> const Eq for &A where A: [const] Eq {}
 
     // &mut pointers
 
@@ -2114,9 +2171,10 @@ mod impls {
         }
     }
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl<A: PointeeSized, B: PointeeSized> PartialOrd<&mut B> for &mut A
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    impl<A: PointeeSized, B: PointeeSized> const PartialOrd<&mut B> for &mut A
     where
-        A: PartialOrd<B>,
+        A: [const] PartialOrd<B>,
     {
         #[inline]
         fn partial_cmp(&self, other: &&mut B) -> Option<Ordering> {
@@ -2156,9 +2214,10 @@ mod impls {
         }
     }
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl<A: PointeeSized> Ord for &mut A
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    impl<A: PointeeSized> const Ord for &mut A
     where
-        A: Ord,
+        A: [const] Ord,
     {
         #[inline]
         fn cmp(&self, other: &Self) -> Ordering {
@@ -2166,7 +2225,8 @@ mod impls {
         }
     }
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl<A: PointeeSized> Eq for &mut A where A: Eq {}
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    impl<A: PointeeSized> const Eq for &mut A where A: [const] Eq {}
 
     #[stable(feature = "rust1", since = "1.0.0")]
     #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
diff --git a/library/core/src/convert/mod.rs b/library/core/src/convert/mod.rs
index a3cfd85974a4f..89cda30c03036 100644
--- a/library/core/src/convert/mod.rs
+++ b/library/core/src/convert/mod.rs
@@ -963,17 +963,20 @@ impl const PartialEq for Infallible {
 }
 
 #[stable(feature = "convert_infallible", since = "1.34.0")]
-impl Eq for Infallible {}
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl const Eq for Infallible {}
 
 #[stable(feature = "convert_infallible", since = "1.34.0")]
-impl PartialOrd for Infallible {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl const PartialOrd for Infallible {
     fn partial_cmp(&self, _other: &Self) -> Option<crate::cmp::Ordering> {
         match *self {}
     }
 }
 
 #[stable(feature = "convert_infallible", since = "1.34.0")]
-impl Ord for Infallible {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl const Ord for Infallible {
     fn cmp(&self, _other: &Self) -> crate::cmp::Ordering {
         match *self {}
     }
diff --git a/library/core/src/num/nonzero.rs b/library/core/src/num/nonzero.rs
index 0f38081c355d1..1b7c28bb95aab 100644
--- a/library/core/src/num/nonzero.rs
+++ b/library/core/src/num/nonzero.rs
@@ -4,7 +4,7 @@ use super::{IntErrorKind, ParseIntError};
 use crate::clone::UseCloned;
 use crate::cmp::Ordering;
 use crate::hash::{Hash, Hasher};
-use crate::marker::{Freeze, StructuralPartialEq};
+use crate::marker::{Destruct, Freeze, StructuralPartialEq};
 use crate::ops::{BitOr, BitOrAssign, Div, DivAssign, Neg, Rem, RemAssign};
 use crate::panic::{RefUnwindSafe, UnwindSafe};
 use crate::str::FromStr;
@@ -220,12 +220,14 @@ where
 impl<T> StructuralPartialEq for NonZero<T> where T: ZeroablePrimitive + StructuralPartialEq {}
 
 #[stable(feature = "nonzero", since = "1.28.0")]
-impl<T> Eq for NonZero<T> where T: ZeroablePrimitive + Eq {}
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<T> const Eq for NonZero<T> where T: ZeroablePrimitive + [const] Eq {}
 
 #[stable(feature = "nonzero", since = "1.28.0")]
-impl<T> PartialOrd for NonZero<T>
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<T> const PartialOrd for NonZero<T>
 where
-    T: ZeroablePrimitive + PartialOrd,
+    T: ZeroablePrimitive + [const] PartialOrd,
 {
     #[inline]
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
@@ -254,9 +256,12 @@ where
 }
 
 #[stable(feature = "nonzero", since = "1.28.0")]
-impl<T> Ord for NonZero<T>
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<T> const Ord for NonZero<T>
 where
-    T: ZeroablePrimitive + Ord,
+    // FIXME(const_hack): the T: ~const Destruct should be inferred from the Self: ~const Destruct.
+    // See https://github.com/rust-lang/rust/issues/144207
+    T: ZeroablePrimitive + [const] Ord + [const] Destruct,
 {
     #[inline]
     fn cmp(&self, other: &Self) -> Ordering {
diff --git a/library/core/src/ops/control_flow.rs b/library/core/src/ops/control_flow.rs
index 73b74d53323fa..b760a7c4e21eb 100644
--- a/library/core/src/ops/control_flow.rs
+++ b/library/core/src/ops/control_flow.rs
@@ -83,7 +83,8 @@ use crate::{convert, ops};
 #[must_use]
 // ControlFlow should not implement PartialOrd or Ord, per RFC 3058:
 // https://rust-lang.github.io/rfcs/3058-try-trait-v2.html#traits-for-controlflow
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Copy, Debug, Hash)]
+#[derive_const(Clone, PartialEq, Eq)]
 pub enum ControlFlow<B, C = ()> {
     /// Move on to the next phase of the operation as normal.
     #[stable(feature = "control_flow_enum_type", since = "1.55.0")]
diff --git a/library/core/src/option.rs b/library/core/src/option.rs
index 198636c67d0b1..886d581b0a6b6 100644
--- a/library/core/src/option.rs
+++ b/library/core/src/option.rs
@@ -585,7 +585,8 @@ use crate::{cmp, convert, hint, mem, slice};
 
 /// The `Option` type. See [the module level documentation](self) for more.
 #[doc(search_unbox)]
-#[derive(Copy, Eq, Debug, Hash)]
+#[derive(Copy, Debug, Hash)]
+#[derive_const(Eq)]
 #[rustc_diagnostic_item = "Option"]
 #[lang = "Option"]
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -2363,7 +2364,8 @@ impl<T: [const] PartialEq> const PartialEq for Option<T> {
 // https://github.com/rust-lang/rust/issues/49892, although still
 // not optimal.
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: PartialOrd> PartialOrd for Option<T> {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<T: [const] PartialOrd> const PartialOrd for Option<T> {
     #[inline]
     fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
         match (self, other) {
@@ -2376,7 +2378,8 @@ impl<T: PartialOrd> PartialOrd for Option<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Ord> Ord for Option<T> {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<T: [const] Ord> const Ord for Option<T> {
     #[inline]
     fn cmp(&self, other: &Self) -> cmp::Ordering {
         match (self, other) {
diff --git a/library/core/src/range.rs b/library/core/src/range.rs
index 8c49123fdaf56..a096a8ceafc87 100644
--- a/library/core/src/range.rs
+++ b/library/core/src/range.rs
@@ -49,7 +49,8 @@ pub use crate::ops::{Bound, IntoBounds, OneSidedRange, RangeBounds, RangeFull, R
 /// assert_eq!(3 + 4 + 5, Range::from(3..6).into_iter().sum());
 /// ```
 #[lang = "RangeCopy"]
-#[derive(Clone, Copy, Default, PartialEq, Eq, Hash)]
+#[derive(Copy, Hash)]
+#[derive_const(Clone, Default, PartialEq, Eq)]
 #[unstable(feature = "new_range_api", issue = "125687")]
 pub struct Range<Idx> {
     /// The lower bound of the range (inclusive).
@@ -424,7 +425,8 @@ impl<T> const From<legacy::RangeInclusive<T>> for RangeInclusive<T> {
 /// assert_eq!(2 + 3 + 4, RangeFrom::from(2..).into_iter().take(3).sum());
 /// ```
 #[lang = "RangeFromCopy"]
-#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Copy, Hash)]
+#[derive_const(Clone, PartialEq, Eq)]
 #[unstable(feature = "new_range_api", issue = "125687")]
 pub struct RangeFrom<Idx> {
     /// The lower bound of the range (inclusive).
diff --git a/library/core/src/result.rs b/library/core/src/result.rs
index 7dffab9b316f6..5c1f64bfe14af 100644
--- a/library/core/src/result.rs
+++ b/library/core/src/result.rs
@@ -542,7 +542,8 @@ use crate::{convert, fmt, hint};
 ///
 /// See the [module documentation](self) for details.
 #[doc(search_unbox)]
-#[derive(Copy, PartialEq, PartialOrd, Eq, Ord, Debug, Hash)]
+#[derive(Copy, Debug, Hash)]
+#[derive_const(PartialEq, PartialOrd, Eq, Ord)]
 #[must_use = "this `Result` may be an `Err` variant, which should be handled"]
 #[rustc_diagnostic_item = "Result"]
 #[stable(feature = "rust1", since = "1.0.0")]
diff --git a/library/core/src/slice/cmp.rs b/library/core/src/slice/cmp.rs
index 0d80130698400..103630aba0f79 100644
--- a/library/core/src/slice/cmp.rs
+++ b/library/core/src/slice/cmp.rs
@@ -23,7 +23,8 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Eq> Eq for [T] {}
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<T: [const] Eq> const Eq for [T] {}
 
 /// Implements comparison of slices [lexicographically](Ord#lexicographical-comparison).
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -34,7 +35,7 @@ impl<T: Ord> Ord for [T] {
 }
 
 #[inline]
-fn as_underlying(x: ControlFlow<bool>) -> u8 {
+const fn as_underlying(x: ControlFlow<bool>) -> u8 {
     // SAFETY: This will only compile if `bool` and `ControlFlow<bool>` have the same
     // size (which isn't guaranteed but this is libcore). Because they have the same
     // size, it's a niched implementation, which in one byte means there can't be
@@ -154,12 +155,16 @@ where
 }
 
 #[doc(hidden)]
+#[const_trait]
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
 // intermediate trait for specialization of slice's PartialOrd
 trait SlicePartialOrd: Sized {
     fn partial_compare(left: &[Self], right: &[Self]) -> Option<Ordering>;
 }
 
 #[doc(hidden)]
+#[const_trait]
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
 // intermediate trait for specialization of slice's PartialOrd chaining methods
 trait SliceChain: Sized {
     fn chaining_lt(left: &[Self], right: &[Self]) -> ControlFlow<bool>;
@@ -231,14 +236,17 @@ where
 }
 */
 
-impl<A: AlwaysApplicableOrd> SlicePartialOrd for A {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<A: [const] AlwaysApplicableOrd> const SlicePartialOrd for A {
     fn partial_compare(left: &[A], right: &[A]) -> Option<Ordering> {
         Some(SliceOrd::compare(left, right))
     }
 }
 
 #[rustc_specialization_trait]
-trait AlwaysApplicableOrd: SliceOrd + Ord {}
+#[const_trait]
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+trait AlwaysApplicableOrd: [const] SliceOrd + [const] Ord {}
 
 macro_rules! always_applicable_ord {
     ($([$($p:tt)*] $t:ty,)*) => {
@@ -257,6 +265,8 @@ always_applicable_ord! {
 }
 
 #[doc(hidden)]
+#[const_trait]
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
 // intermediate trait for specialization of slice's Ord
 trait SliceOrd: Sized {
     fn compare(left: &[Self], right: &[Self]) -> Ordering;
@@ -282,17 +292,24 @@ impl<A: Ord> SliceOrd for A {
 /// * For every `x` and `y` of this type, `Ord(x, y)` must return the same
 ///   value as `Ord::cmp(transmute::<_, u8>(x), transmute::<_, u8>(y))`.
 #[rustc_specialization_trait]
-unsafe trait UnsignedBytewiseOrd: Ord {}
+#[const_trait]
+unsafe trait UnsignedBytewiseOrd: [const] Ord {}
 
-unsafe impl UnsignedBytewiseOrd for bool {}
-unsafe impl UnsignedBytewiseOrd for u8 {}
-unsafe impl UnsignedBytewiseOrd for NonZero<u8> {}
-unsafe impl UnsignedBytewiseOrd for Option<NonZero<u8>> {}
-unsafe impl UnsignedBytewiseOrd for ascii::Char {}
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+unsafe impl const UnsignedBytewiseOrd for bool {}
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+unsafe impl const UnsignedBytewiseOrd for u8 {}
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+unsafe impl const UnsignedBytewiseOrd for NonZero<u8> {}
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+unsafe impl const UnsignedBytewiseOrd for Option<NonZero<u8>> {}
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+unsafe impl const UnsignedBytewiseOrd for ascii::Char {}
 
 // `compare_bytes` compares a sequence of unsigned bytes lexicographically, so
 // use it if the requirements for `UnsignedBytewiseOrd` are fulfilled.
-impl<A: Ord + UnsignedBytewiseOrd> SliceOrd for A {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<A: [const] Ord + [const] UnsignedBytewiseOrd> const SliceOrd for A {
     #[inline]
     fn compare(left: &[Self], right: &[Self]) -> Ordering {
         // Since the length of a slice is always less than or equal to
@@ -317,7 +334,9 @@ impl<A: Ord + UnsignedBytewiseOrd> SliceOrd for A {
 }
 
 // Don't generate our own chaining loops for `memcmp`-able things either.
-impl<A: PartialOrd + UnsignedBytewiseOrd> SliceChain for A {
+
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<A: [const] PartialOrd + [const] UnsignedBytewiseOrd> const SliceChain for A {
     #[inline]
     fn chaining_lt(left: &[Self], right: &[Self]) -> ControlFlow<bool> {
         match SliceOrd::compare(left, right) {
diff --git a/library/core/src/str/traits.rs b/library/core/src/str/traits.rs
index 5adae62b7e65d..a7cc943994c53 100644
--- a/library/core/src/str/traits.rs
+++ b/library/core/src/str/traits.rs
@@ -32,7 +32,8 @@ impl const PartialEq for str {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl Eq for str {}
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl const Eq for str {}
 
 /// Implements comparison operations on strings.
 ///
diff --git a/library/core/src/tuple.rs b/library/core/src/tuple.rs
index 2cdee1803a9a2..3892f83107690 100644
--- a/library/core/src/tuple.rs
+++ b/library/core/src/tuple.rs
@@ -23,7 +23,8 @@ macro_rules! tuple_impls {
         maybe_tuple_doc! {
             $($T)+ @
             #[stable(feature = "rust1", since = "1.0.0")]
-            impl<$($T: PartialEq),+> PartialEq for ($($T,)+) {
+            #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+            impl<$($T: [const] PartialEq),+> const PartialEq for ($($T,)+) {
                 #[inline]
                 fn eq(&self, other: &($($T,)+)) -> bool {
                     $( ${ignore($T)} self.${index()} == other.${index()} )&&+
@@ -38,7 +39,8 @@ macro_rules! tuple_impls {
         maybe_tuple_doc! {
             $($T)+ @
             #[stable(feature = "rust1", since = "1.0.0")]
-            impl<$($T: Eq),+> Eq for ($($T,)+)
+            #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+            impl<$($T: [const] Eq),+> const Eq for ($($T,)+)
             {}
         }
 
@@ -66,7 +68,8 @@ macro_rules! tuple_impls {
         maybe_tuple_doc! {
             $($T)+ @
             #[stable(feature = "rust1", since = "1.0.0")]
-            impl<$($T: PartialOrd),+> PartialOrd for ($($T,)+)
+            #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+            impl<$($T: [const] PartialOrd),+> const PartialOrd for ($($T,)+)
             {
                 #[inline]
                 fn partial_cmp(&self, other: &($($T,)+)) -> Option<Ordering> {
@@ -110,7 +113,8 @@ macro_rules! tuple_impls {
         maybe_tuple_doc! {
             $($T)+ @
             #[stable(feature = "rust1", since = "1.0.0")]
-            impl<$($T: Ord),+> Ord for ($($T,)+)
+            #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+            impl<$($T: [const] Ord),+> const Ord for ($($T,)+)
             {
                 #[inline]
                 fn cmp(&self, other: &($($T,)+)) -> Ordering {
diff --git a/library/coretests/tests/cmp.rs b/library/coretests/tests/cmp.rs
index 6c4e2146f9148..55e35a4a7250e 100644
--- a/library/coretests/tests/cmp.rs
+++ b/library/coretests/tests/cmp.rs
@@ -215,19 +215,18 @@ fn cmp_default() {
     assert_eq!(Fool(false), Fool(true));
 }
 
-/* FIXME(#110395)
 mod const_cmp {
     use super::*;
 
     struct S(i32);
 
-    impl PartialEq for S {
+    impl const PartialEq for S {
         fn eq(&self, other: &Self) -> bool {
             self.0 == other.0
         }
     }
 
-    impl PartialOrd for S {
+    impl const PartialOrd for S {
         fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
             let ret = match (self.0, other.0) {
                 (a, b) if a > b => Ordering::Greater,
@@ -247,4 +246,3 @@ mod const_cmp {
     const _: () = assert!(S(0) < S(1));
     const _: () = assert!(S(1) > S(0));
 }
-*/
diff --git a/library/coretests/tests/lib.rs b/library/coretests/tests/lib.rs
index 1bdaa6965f64a..04fa0aeba6501 100644
--- a/library/coretests/tests/lib.rs
+++ b/library/coretests/tests/lib.rs
@@ -15,6 +15,7 @@
 #![feature(cfg_target_has_reliable_f16_f128)]
 #![feature(char_max_len)]
 #![feature(clone_to_uninit)]
+#![feature(const_cmp)]
 #![feature(const_convert)]
 #![feature(const_destruct)]
 #![feature(const_eval_select)]
diff --git a/tests/ui/consts/const_cmp_type_id.rs b/tests/ui/consts/const_cmp_type_id.rs
index ff44876c5c492..dc0701d3b1d6a 100644
--- a/tests/ui/consts/const_cmp_type_id.rs
+++ b/tests/ui/consts/const_cmp_type_id.rs
@@ -9,8 +9,7 @@ fn main() {
         assert!(TypeId::of::<u8>() == TypeId::of::<u8>());
         assert!(TypeId::of::<()>() != TypeId::of::<u8>());
         let _a = TypeId::of::<u8>() < TypeId::of::<u16>();
-        //~^ ERROR: cannot call non-const operator in constants
-        // can't assert `_a` because it is not deterministic
-        // FIXME(const_trait_impl) make it pass
+        //~^ ERROR: the trait bound `TypeId: const PartialOrd` is not satisfied
+        // FIXME(const_trait_impl) make it pass; requires const comparison of pointers (#53020)
     }
 }
diff --git a/tests/ui/consts/const_cmp_type_id.stderr b/tests/ui/consts/const_cmp_type_id.stderr
index 05b94caef79e6..62a1677c0d930 100644
--- a/tests/ui/consts/const_cmp_type_id.stderr
+++ b/tests/ui/consts/const_cmp_type_id.stderr
@@ -1,13 +1,9 @@
-error[E0015]: cannot call non-const operator in constants
+error[E0277]: the trait bound `TypeId: const PartialOrd` is not satisfied
   --> $DIR/const_cmp_type_id.rs:11:18
    |
 LL |         let _a = TypeId::of::<u8>() < TypeId::of::<u16>();
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: impl defined here, but it is not `const`
-  --> $SRC_DIR/core/src/any.rs:LL:COL
-   = note: calls in constants are limited to constant functions, tuple structs and tuple variants
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0015`.
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/consts/fn_trait_refs.rs b/tests/ui/consts/fn_trait_refs.rs
index e475c0a1b6fd1..e4a62e18c7b58 100644
--- a/tests/ui/consts/fn_trait_refs.rs
+++ b/tests/ui/consts/fn_trait_refs.rs
@@ -1,6 +1,5 @@
-//@ known-bug: #110395
+//@ check-pass
 
-#![feature(const_fn_trait_ref_impls)]
 #![feature(fn_traits)]
 #![feature(unboxed_closures)]
 #![feature(const_trait_impl)]
diff --git a/tests/ui/consts/fn_trait_refs.stderr b/tests/ui/consts/fn_trait_refs.stderr
deleted file mode 100644
index bbe0714801c45..0000000000000
--- a/tests/ui/consts/fn_trait_refs.stderr
+++ /dev/null
@@ -1,22 +0,0 @@
-error[E0635]: unknown feature `const_fn_trait_ref_impls`
-  --> $DIR/fn_trait_refs.rs:3:12
-   |
-LL | #![feature(const_fn_trait_ref_impls)]
-   |            ^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0277]: the trait bound `(i32, i32, i32): const PartialEq` is not satisfied
-  --> $DIR/fn_trait_refs.rs:71:17
-   |
-LL |         assert!(test_one == (1, 1, 1));
-   |                 ^^^^^^^^^^^^^^^^^^^^^
-
-error[E0277]: the trait bound `(i32, i32): const PartialEq` is not satisfied
-  --> $DIR/fn_trait_refs.rs:74:17
-   |
-LL |         assert!(test_two == (2, 2));
-   |                 ^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 3 previous errors
-
-Some errors have detailed explanations: E0277, E0635.
-For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/const-traits/const-impl-trait.rs b/tests/ui/traits/const-traits/const-impl-trait.rs
index da28d9a47c31e..c89aaa62d9922 100644
--- a/tests/ui/traits/const-traits/const-impl-trait.rs
+++ b/tests/ui/traits/const-traits/const-impl-trait.rs
@@ -1,7 +1,5 @@
+//@ check-pass
 //@ compile-flags: -Znext-solver
-//@ known-bug: #110395
-
-// Broken until `(): const PartialEq`
 
 #![allow(incomplete_features)]
 #![feature(const_trait_impl, const_cmp, const_destruct)]
diff --git a/tests/ui/traits/const-traits/const-impl-trait.stderr b/tests/ui/traits/const-traits/const-impl-trait.stderr
deleted file mode 100644
index cbb68d8c9839e..0000000000000
--- a/tests/ui/traits/const-traits/const-impl-trait.stderr
+++ /dev/null
@@ -1,17 +0,0 @@
-error[E0277]: the trait bound `(): const PartialEq` is not satisfied
-  --> $DIR/const-impl-trait.rs:34:17
-   |
-LL |     assert!(cmp(&()));
-   |             --- ^^^
-   |             |
-   |             required by a bound introduced by this call
-   |
-note: required by a bound in `cmp`
-  --> $DIR/const-impl-trait.rs:11:23
-   |
-LL | const fn cmp(a: &impl [const] PartialEq) -> bool {
-   |                       ^^^^^^^^^^^^^^^^^ required by this bound in `cmp`
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/const-traits/const_derives/derive-const-use.rs b/tests/ui/traits/const-traits/const_derives/derive-const-use.rs
index 1a3012de06f81..78c25ccd6e598 100644
--- a/tests/ui/traits/const-traits/const_derives/derive-const-use.rs
+++ b/tests/ui/traits/const-traits/const_derives/derive-const-use.rs
@@ -1,5 +1,4 @@
-//@ known-bug: #110395
-
+//@ check-pass
 #![feature(const_trait_impl, const_default, const_cmp, derive_const)]
 
 pub struct A;
diff --git a/tests/ui/traits/const-traits/const_derives/derive-const-use.stderr b/tests/ui/traits/const-traits/const_derives/derive-const-use.stderr
deleted file mode 100644
index 4ea11a0c7ed91..0000000000000
--- a/tests/ui/traits/const-traits/const_derives/derive-const-use.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-error[E0277]: the trait bound `(): [const] PartialEq` is not satisfied
-  --> $DIR/derive-const-use.rs:16:14
-   |
-LL | #[derive_const(Default, PartialEq)]
-   |                         --------- in this derive macro expansion
-LL | pub struct S((), A);
-   |              ^^
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.

From 889be7860b0a0cbe82615787d4823bd57af40040 Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Wed, 10 Sep 2025 11:52:26 +0200
Subject: [PATCH 0836/1889] sort array trait implementation suggestions
 correctly

---
 .../traits/fulfillment_errors.rs               | 18 +++++++++++++++---
 .../ui/consts/missing-larger-array-impl.stderr | 10 +++++-----
 .../issue-71394-no-from-impl.stderr            |  6 +++---
 3 files changed, 23 insertions(+), 11 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 c82043f022238..149f5e638b1ad 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
@@ -27,8 +27,8 @@ use rustc_middle::ty::print::{
     with_forced_trimmed_paths,
 };
 use rustc_middle::ty::{
-    self, TraitRef, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeSuperFoldable, TypeVisitableExt,
-    Upcast,
+    self, GenericArgKind, TraitRef, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeSuperFoldable,
+    TypeVisitableExt, Upcast,
 };
 use rustc_middle::{bug, span_bug};
 use rustc_span::{BytePos, DUMMY_SP, STDLIB_STABLE_CRATES, Span, Symbol, sym};
@@ -2316,7 +2316,19 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 cand
             })
             .collect();
-        impl_candidates.sort_by_key(|cand| (cand.similarity, cand.trait_ref.to_string()));
+        impl_candidates.sort_by_key(|cand| {
+            // When suggesting array types, sort them by the length of the array, not lexicographically (#135098)
+            let len = if let GenericArgKind::Type(ty) = cand.trait_ref.args[0].kind()
+                && let ty::Array(_, len) = ty.kind()
+            {
+                // Deprioritize suggestions for parameterized arrays.
+                len.try_to_target_usize(self.tcx).unwrap_or(u64::MAX)
+            } else {
+                0
+            };
+
+            (cand.similarity, len, cand.trait_ref.to_string())
+        });
         let mut impl_candidates: Vec<_> =
             impl_candidates.into_iter().map(|cand| cand.trait_ref).collect();
         impl_candidates.dedup();
diff --git a/tests/ui/consts/missing-larger-array-impl.stderr b/tests/ui/consts/missing-larger-array-impl.stderr
index ff4fa36d684c7..33d7a46339b2b 100644
--- a/tests/ui/consts/missing-larger-array-impl.stderr
+++ b/tests/ui/consts/missing-larger-array-impl.stderr
@@ -8,11 +8,11 @@ LL |     <[X; 35] as Default>::default();
              &[T]
              &mut [T]
              [T; 0]
-             [T; 10]
-             [T; 11]
-             [T; 12]
-             [T; 13]
-             [T; 14]
+             [T; 1]
+             [T; 2]
+             [T; 3]
+             [T; 4]
+             [T; 5]
            and 27 others
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/suggestions/issue-71394-no-from-impl.stderr b/tests/ui/suggestions/issue-71394-no-from-impl.stderr
index 31f8f1d455aba..9e068c311ae05 100644
--- a/tests/ui/suggestions/issue-71394-no-from-impl.stderr
+++ b/tests/ui/suggestions/issue-71394-no-from-impl.stderr
@@ -5,14 +5,14 @@ LL |     let _: &[i8] = data.into();
    |                         ^^^^ the trait `From<&[u8]>` is not implemented for `&[i8]`
    |
    = help: the following other types implement trait `From<T>`:
-             `[T; 10]` implements `From<(T, T, T, T, T, T, T, T, T, T)>`
-             `[T; 11]` implements `From<(T, T, T, T, T, T, T, T, T, T, T)>`
-             `[T; 12]` implements `From<(T, T, T, T, T, T, T, T, T, T, T, T)>`
              `[T; 1]` implements `From<(T,)>`
              `[T; 2]` implements `From<(T, T)>`
              `[T; 3]` implements `From<(T, T, T)>`
              `[T; 4]` implements `From<(T, T, T, T)>`
              `[T; 5]` implements `From<(T, T, T, T, T)>`
+             `[T; 6]` implements `From<(T, T, T, T, T, T)>`
+             `[T; 7]` implements `From<(T, T, T, T, T, T, T)>`
+             `[T; 8]` implements `From<(T, T, T, T, T, T, T, T)>`
            and 6 others
    = note: required for `&[u8]` to implement `Into<&[i8]>`
 

From fefc9793740e88585a28ed966100718df9dbe522 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=2E=20Neusch=C3=A4fer?= <j.ne@posteo.net>
Date: Fri, 12 Sep 2025 13:31:49 +0200
Subject: [PATCH 0837/1889] bootstrap: Show target in "No such target exists"
 message

This makes it a little easier to pinpoint the issue.
---
 src/bootstrap/src/core/sanity.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/bootstrap/src/core/sanity.rs b/src/bootstrap/src/core/sanity.rs
index 04cf63f1c6d44..68202500d9791 100644
--- a/src/bootstrap/src/core/sanity.rs
+++ b/src/bootstrap/src/core/sanity.rs
@@ -287,7 +287,7 @@ than building it.
 
             if !has_target {
                 panic!(
-                    "No such target exists in the target list,\n\
+                    "{target_str}: No such target exists in the target list,\n\
                      make sure to correctly specify the location \
                      of the JSON specification file \
                      for custom targets!\n\

From 8b5335cbba6f68b1e3727e1de6095d2e126f08e0 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 12 Sep 2025 13:34:22 +0200
Subject: [PATCH 0838/1889] disable broken parts of CI for now

---
 src/tools/miri/.github/workflows/ci.yml | 33 +++++++++++++------------
 1 file changed, 17 insertions(+), 16 deletions(-)

diff --git a/src/tools/miri/.github/workflows/ci.yml b/src/tools/miri/.github/workflows/ci.yml
index c0fed96d4e6e3..e1a948c92faa4 100644
--- a/src/tools/miri/.github/workflows/ci.yml
+++ b/src/tools/miri/.github/workflows/ci.yml
@@ -31,21 +31,22 @@ jobs:
             os: ubuntu-24.04-arm
             multiarch: armhf
             gcc_cross: arm-linux-gnueabihf
-          - host_target: riscv64gc-unknown-linux-gnu
-            os: ubuntu-latest
-            multiarch: riscv64
-            gcc_cross: riscv64-linux-gnu
-            qemu: true
-          - host_target: s390x-unknown-linux-gnu
-            os: ubuntu-latest
-            multiarch: s390x
-            gcc_cross: s390x-linux-gnu
-            qemu: true
-          - host_target: powerpc64le-unknown-linux-gnu
-            os: ubuntu-latest
-            multiarch: ppc64el
-            gcc_cross: powerpc64le-linux-gnu
-            qemu: true
+          # Disabled due to Ubuntu repo trouble
+          # - host_target: riscv64gc-unknown-linux-gnu
+          #   os: ubuntu-latest
+          #   multiarch: riscv64
+          #   gcc_cross: riscv64-linux-gnu
+          #   qemu: true
+          # - host_target: s390x-unknown-linux-gnu
+          #   os: ubuntu-latest
+          #   multiarch: s390x
+          #   gcc_cross: s390x-linux-gnu
+          #   qemu: true
+          # - host_target: powerpc64le-unknown-linux-gnu
+          #   os: ubuntu-latest
+          #   multiarch: ppc64el
+          #   gcc_cross: powerpc64le-linux-gnu
+          #   qemu: true
           - host_target: aarch64-apple-darwin
             os: macos-latest
           - host_target: i686-pc-windows-msvc
@@ -67,7 +68,7 @@ jobs:
       - name: install multiarch
         if: ${{ matrix.multiarch != '' }}
         run: |
-          # s390x, ppc64el need Ubuntu Ports to be in the mirror list
+          # s390x, ppc64el, riscv64 need Ubuntu Ports to be in the mirror list
           sudo bash -c "echo 'https://ports.ubuntu.com/	priority:4' >> /etc/apt/apt-mirrors.txt"
           # Add architecture
           sudo dpkg --add-architecture ${{ matrix.multiarch }}

From 221eb1f0d51a97ec6ccb67427635370797d37225 Mon Sep 17 00:00:00 2001
From: Tsukasa OI <floss_rust@irq.a4lg.com>
Date: Fri, 12 Sep 2025 11:50:25 +0000
Subject: [PATCH 0839/1889] intrinsic-test: Make Clippy happy

---
 library/stdarch/crates/intrinsic-test/src/arm/json_parser.rs | 2 +-
 library/stdarch/crates/intrinsic-test/src/common/gen_rust.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/library/stdarch/crates/intrinsic-test/src/arm/json_parser.rs b/library/stdarch/crates/intrinsic-test/src/arm/json_parser.rs
index b019abab21346..65c179ef0d083 100644
--- a/library/stdarch/crates/intrinsic-test/src/arm/json_parser.rs
+++ b/library/stdarch/crates/intrinsic-test/src/arm/json_parser.rs
@@ -113,7 +113,7 @@ fn json_to_intrinsic(
     Ok(Intrinsic {
         name,
         arguments,
-        results: results,
+        results,
         arch_tags: intr.architectures,
     })
 }
diff --git a/library/stdarch/crates/intrinsic-test/src/common/gen_rust.rs b/library/stdarch/crates/intrinsic-test/src/common/gen_rust.rs
index 312cbee692a56..c6b964a9ce4e4 100644
--- a/library/stdarch/crates/intrinsic-test/src/common/gen_rust.rs
+++ b/library/stdarch/crates/intrinsic-test/src/common/gen_rust.rs
@@ -253,7 +253,7 @@ pub fn generate_rust_test_loop<T: IntrinsicTypeDefinition>(
 }
 
 /// Generate the specializations (unique sequences of const-generic arguments) for this intrinsic.
-fn generate_rust_specializations<'a>(
+fn generate_rust_specializations(
     constraints: &mut impl Iterator<Item = impl Iterator<Item = i64>>,
 ) -> Vec<Vec<u8>> {
     let mut specializations = vec![vec![]];

From a3b7aad20f6ff2a4af0e96c543ac300650c97d5e Mon Sep 17 00:00:00 2001
From: Tsukasa OI <floss_rust@irq.a4lg.com>
Date: Fri, 12 Sep 2025 11:50:51 +0000
Subject: [PATCH 0840/1889] stdarch-gen-arm: Make Clippy happy

---
 library/stdarch/crates/stdarch-gen-arm/src/load_store_tests.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/stdarch/crates/stdarch-gen-arm/src/load_store_tests.rs b/library/stdarch/crates/stdarch-gen-arm/src/load_store_tests.rs
index 3f3bfed132c76..0f4de83dacb4a 100644
--- a/library/stdarch/crates/stdarch-gen-arm/src/load_store_tests.rs
+++ b/library/stdarch/crates/stdarch-gen-arm/src/load_store_tests.rs
@@ -85,7 +85,7 @@ pub fn generate_load_store_tests(
         TokenStream::from_str(&PREAMBLE).map_err(|e| format!("Preamble is invalid: {e}"))?;
     // Only output manual tests for the SVE set
     let manual_tests = match &load_intrinsics[0].target_features[..] {
-        [s] if s == "sve" => TokenStream::from_str(&MANUAL_TESTS)
+        [s] if s == "sve" => TokenStream::from_str(MANUAL_TESTS)
             .map_err(|e| format!("Manual tests are invalid: {e}"))?,
         _ => quote!(),
     };

From 05133f2115940aa581df8831031ea77c2c7c99c8 Mon Sep 17 00:00:00 2001
From: Tsukasa OI <floss_rust@irq.a4lg.com>
Date: Fri, 12 Sep 2025 11:51:38 +0000
Subject: [PATCH 0841/1889] examples: Make Clippy happy

---
 library/stdarch/examples/hex.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/library/stdarch/examples/hex.rs b/library/stdarch/examples/hex.rs
index 95ffbaf666cea..621f55bc0951f 100644
--- a/library/stdarch/examples/hex.rs
+++ b/library/stdarch/examples/hex.rs
@@ -22,7 +22,6 @@
 #![allow(
     clippy::unwrap_used,
     clippy::print_stdout,
-    clippy::unwrap_used,
     clippy::shadow_reuse,
     clippy::cast_possible_wrap,
     clippy::cast_ptr_alignment,

From 8a574ca862493b1977749e1a6e3fb85b9356fad7 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Fri, 12 Sep 2025 20:07:07 +0800
Subject: [PATCH 0842/1889] Fix extra semicolon before else in let-stmt

Example
---
```rust
fn main() {
    let x = if true {
        ()
    } $0 else {};
}
```

**Before this PR**:

```rust
fn main() {
    let x = if true {
        ()
    } else if $1 {
        $0
    }; else {};
}
```

**After this PR**:

```rust
fn main() {
    let x = if true {
        ()
    } else if $1 {
        $0
    } else {};
}
```
---
 .../ide-completion/src/completions/keyword.rs | 40 +++++++++++++++++++
 .../ide-completion/src/context/analysis.rs    | 12 +++++-
 2 files changed, 51 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/keyword.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/keyword.rs
index b3d770997ab0c..6162d98372839 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/keyword.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/keyword.rs
@@ -269,6 +269,46 @@ fn main() {
 "#,
         );
 
+        check_edit(
+            "else if",
+            r#"
+fn main() {
+    let x = if true {
+        ()
+    } $0 else {};
+}
+"#,
+            r#"
+fn main() {
+    let x = if true {
+        ()
+    } else if $1 {
+    $0
+} else {};
+}
+"#,
+        );
+
+        check_edit(
+            "else if",
+            r#"
+fn main() {
+    let x = if true {
+        ()
+    } $0 else if true {};
+}
+"#,
+            r#"
+fn main() {
+    let x = if true {
+        ()
+    } else if $1 {
+    $0
+} else if true {};
+}
+"#,
+        );
+
         check_edit(
             "else",
             r#"
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
index 33b98a33cabf6..b33a547dee972 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
@@ -970,6 +970,16 @@ fn classify_name_ref<'db>(
     let after_incomplete_let = |node: SyntaxNode| {
         prev_expr(node).and_then(|it| it.syntax().parent()).and_then(ast::LetStmt::cast)
     };
+    let before_else_kw = |node: &SyntaxNode| {
+        node.parent()
+            .and_then(ast::ExprStmt::cast)
+            .filter(|stmt| stmt.semicolon_token().is_none())
+            .and_then(|stmt| non_trivia_sibling(stmt.syntax().clone().into(), Direction::Next))
+            .and_then(NodeOrToken::into_node)
+            .filter(|next| next.kind() == SyntaxKind::ERROR)
+            .and_then(|next| next.first_token())
+            .is_some_and(|token| token.kind() == SyntaxKind::ELSE_KW)
+    };
 
     // We do not want to generate path completions when we are sandwiched between an item decl signature and its body.
     // ex. trait Foo $0 {}
@@ -1276,7 +1286,7 @@ fn classify_name_ref<'db>(
             .parent()
             .and_then(ast::LetStmt::cast)
             .is_some_and(|it| it.semicolon_token().is_none())
-            || after_incomplete_let && incomplete_expr_stmt.unwrap_or(true);
+            || after_incomplete_let && incomplete_expr_stmt.unwrap_or(true) && !before_else_kw(it);
         let in_value = it.parent().and_then(Either::<ast::LetStmt, ast::ArgList>::cast).is_some();
         let impl_ = fetch_immediate_impl(sema, original_file, expr.syntax());
 

From 225e8ff17b593c7621f639c7cd50de2d93c7aee0 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 12 Sep 2025 16:30:41 +0200
Subject: [PATCH 0843/1889] move _Unwind_RaiseException out of the frame_in_std
 section

---
 .../miri/src/shims/windows/foreign_items.rs   | 32 +++++++++----------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/tools/miri/src/shims/windows/foreign_items.rs b/src/tools/miri/src/shims/windows/foreign_items.rs
index 7b13f1d908073..c3ca01bbf3403 100644
--- a/src/tools/miri/src/shims/windows/foreign_items.rs
+++ b/src/tools/miri/src/shims/windows/foreign_items.rs
@@ -820,6 +820,22 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 this.write_int(length.strict_sub(1), dest)?;
             }
 
+            "_Unwind_RaiseException" => {
+                // This is not formally part of POSIX, but it is very wide-spread on POSIX systems.
+                // It was originally specified as part of the Itanium C++ ABI:
+                // https://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html#base-throw.
+                // MinGW implements _Unwind_RaiseException on top of SEH exceptions.
+                if this.tcx.sess.target.env != "gnu" {
+                    throw_unsup_format!(
+                        "`_Unwind_RaiseException` is not supported on non-MinGW Windows",
+                    );
+                }
+                // This function looks and behaves excatly like miri_start_unwind.
+                let [payload] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
+                this.handle_miri_start_unwind(payload)?;
+                return interp_ok(EmulateItemResult::NeedsUnwind);
+            }
+
             // 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.
             "GetProcessHeap" if this.frame_in_std() => {
@@ -880,22 +896,6 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 this.write_null(dest)?;
             }
 
-            "_Unwind_RaiseException" => {
-                // This is not formally part of POSIX, but it is very wide-spread on POSIX systems.
-                // It was originally specified as part of the Itanium C++ ABI:
-                // https://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html#base-throw.
-                // MinGW implements _Unwind_RaiseException on top of SEH exceptions.
-                if this.tcx.sess.target.env != "gnu" {
-                    throw_unsup_format!(
-                        "`_Unwind_RaiseException` is not supported on non-MinGW Windows",
-                    );
-                }
-                // This function looks and behaves excatly like miri_start_unwind.
-                let [payload] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
-                this.handle_miri_start_unwind(payload)?;
-                return interp_ok(EmulateItemResult::NeedsUnwind);
-            }
-
             _ => return interp_ok(EmulateItemResult::NotSupported),
         }
 

From baed55cceffaa3b5dd0754436b413fa9aef544af Mon Sep 17 00:00:00 2001
From: Zachary S <zasample18+github@gmail.com>
Date: Fri, 12 Sep 2025 09:49:41 -0500
Subject: [PATCH 0844/1889] Remove unreachable unsized arg handling in
 `store_fn_arg/store_arg` in codegen

---
 compiler/rustc_codegen_gcc/src/intrinsic/mod.rs |  9 ++-------
 compiler/rustc_codegen_llvm/src/abi.rs          | 11 +++--------
 2 files changed, 5 insertions(+), 15 deletions(-)

diff --git a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
index eb0a5336a1f13..84fa56cf90308 100644
--- a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
+++ b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
@@ -730,7 +730,7 @@ impl<'gcc, 'tcx> ArgAbiExt<'gcc, 'tcx> for ArgAbi<'tcx, Ty<'tcx>> {
         if self.is_sized_indirect() {
             OperandValue::Ref(PlaceValue::new_sized(val, self.layout.align.abi)).store(bx, dst)
         } else if self.is_unsized_indirect() {
-            bug!("unsized `ArgAbi` must be handled through `store_fn_arg`");
+            bug!("unsized `ArgAbi` cannot be stored");
         } else if let PassMode::Cast { ref cast, .. } = self.mode {
             // FIXME(eddyb): Figure out when the simpler Store is safe, clang
             // uses it for i16 -> {i8, i8}, but not for i24 -> {i8, i8, i8}.
@@ -797,12 +797,7 @@ impl<'gcc, 'tcx> ArgAbiExt<'gcc, 'tcx> for ArgAbi<'tcx, Ty<'tcx>> {
                 OperandValue::Pair(next(), next()).store(bx, dst);
             }
             PassMode::Indirect { meta_attrs: Some(_), .. } => {
-                let place_val = PlaceValue {
-                    llval: next(),
-                    llextra: Some(next()),
-                    align: self.layout.align.abi,
-                };
-                OperandValue::Ref(place_val).store(bx, dst);
+                bug!("unsized `ArgAbi` cannot be stored");
             }
             PassMode::Direct(_)
             | PassMode::Indirect { meta_attrs: None, .. }
diff --git a/compiler/rustc_codegen_llvm/src/abi.rs b/compiler/rustc_codegen_llvm/src/abi.rs
index ac7583f566687..11be704116790 100644
--- a/compiler/rustc_codegen_llvm/src/abi.rs
+++ b/compiler/rustc_codegen_llvm/src/abi.rs
@@ -215,9 +215,9 @@ impl<'ll, 'tcx> ArgAbiExt<'ll, 'tcx> for ArgAbi<'tcx, Ty<'tcx>> {
                 let align = attrs.pointee_align.unwrap_or(self.layout.align.abi);
                 OperandValue::Ref(PlaceValue::new_sized(val, align)).store(bx, dst);
             }
-            // Unsized indirect qrguments
+            // Unsized indirect arguments cannot be stored
             PassMode::Indirect { attrs: _, meta_attrs: Some(_), on_stack: _ } => {
-                bug!("unsized `ArgAbi` must be handled through `store_fn_arg`");
+                bug!("unsized `ArgAbi` cannot be stored");
             }
             PassMode::Cast { cast, pad_i32: _ } => {
                 // The ABI mandates that the value is passed as a different struct representation.
@@ -272,12 +272,7 @@ impl<'ll, 'tcx> ArgAbiExt<'ll, 'tcx> for ArgAbi<'tcx, Ty<'tcx>> {
                 OperandValue::Pair(next(), next()).store(bx, dst);
             }
             PassMode::Indirect { attrs: _, meta_attrs: Some(_), on_stack: _ } => {
-                let place_val = PlaceValue {
-                    llval: next(),
-                    llextra: Some(next()),
-                    align: self.layout.align.abi,
-                };
-                OperandValue::Ref(place_val).store(bx, dst);
+                bug!("unsized `ArgAbi` cannot be stored");
             }
             PassMode::Direct(_)
             | PassMode::Indirect { attrs: _, meta_attrs: None, on_stack: _ }

From 7a4b7287bb8c223870b423e4e7bf6b2cfc2531a7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Fri, 12 Sep 2025 16:50:41 +0200
Subject: [PATCH 0845/1889] Rename "crashes tests" to "crash tests"

---
 src/doc/rustc-dev-guide/src/fuzzing.md              | 7 ++++---
 src/doc/rustc-dev-guide/src/tests/best-practices.md | 4 ++--
 src/doc/rustc-dev-guide/src/tests/compiletest.md    | 8 ++++----
 3 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/fuzzing.md b/src/doc/rustc-dev-guide/src/fuzzing.md
index 3000537861778..cc98b49a97c68 100644
--- a/src/doc/rustc-dev-guide/src/fuzzing.md
+++ b/src/doc/rustc-dev-guide/src/fuzzing.md
@@ -90,14 +90,15 @@ Here are a few things you can do to help the Rust project after filing an ICE.
   triggering the ICE, such as syntax errors or borrow-checking errors
 - Minimize the test case (see below). If successful, you can label the
   issue with `S-has-mcve`. Otherwise, you can apply `E-needs-mcve`.
-- Add the minimal test case to the rust-lang/rust repo as a [crashes test].
+- Add the minimal test case to the rust-lang/rust repo as a [crash test].
   While you're at it, consider including other "untracked" crashes in your PR.
-  Please don't forget to mark your issue with `S-bug-has-test` afterwards.
+  Please don't forget to mark all relevant issues with `S-bug-has-test` once
+  your PR is merged.
 
 See also [applying and removing labels][labeling].
 
 [bisect]: https://rust-lang.github.io/cargo-bisect-rustc/
-[crashes test]: tests/compiletest.html#crashes-tests
+[crash test]: tests/compiletest.html#crash-tests
 [labeling]: https://forge.rust-lang.org/release/issue-triaging.html#applying-and-removing-labels
 
 ## Minimization
diff --git a/src/doc/rustc-dev-guide/src/tests/best-practices.md b/src/doc/rustc-dev-guide/src/tests/best-practices.md
index be00207e3fb93..7c26cdc66a03b 100644
--- a/src/doc/rustc-dev-guide/src/tests/best-practices.md
+++ b/src/doc/rustc-dev-guide/src/tests/best-practices.md
@@ -71,7 +71,7 @@ related tests.
 > //! Regression test for <https://github.com/rust-lang/rust/issues/123456>.
 > ```
 >
-> One exception to this rule is [crashes tests]: there it is canonical that
+> One exception to this rule is [crash tests]: there it is canonical that
 > tests are named only after issue numbers because its purpose is to track
 > snippets from which issues no longer ICE/crash, and they would either be
 > removed or converted into proper ui/other tests in the fix PRs.
@@ -199,4 +199,4 @@ See [LLVM FileCheck guide][FileCheck] for details.
 [compiletest directives]: ./directives.md
 [`run-make`]: ./compiletest.md#run-make-tests
 [FileCheck]: https://llvm.org/docs/CommandGuide/FileCheck.html
-[crashes tests]: ./compiletest.md#crashes-tests
+[crash tests]: ./compiletest.md#crash-tests
diff --git a/src/doc/rustc-dev-guide/src/tests/compiletest.md b/src/doc/rustc-dev-guide/src/tests/compiletest.md
index 4980ed845d6dd..a4db1b3eca193 100644
--- a/src/doc/rustc-dev-guide/src/tests/compiletest.md
+++ b/src/doc/rustc-dev-guide/src/tests/compiletest.md
@@ -72,7 +72,7 @@ The following test suites are available, with links for more information:
 | [`mir-opt`](#mir-opt-tests)               | Check MIR generation and optimizations                                                                              |
 | [`coverage`](#coverage-tests)             | Check coverage instrumentation                                                                                      |
 | [`coverage-run-rustdoc`](#coverage-tests) | `coverage` tests that also run instrumented doctests                                                                |
-| [`crashes`](#crashes-tests)               | Check that the compiler ICEs/panics/crashes on certain inputs to catch accidental fixes                             |
+| [`crashes`](#crash-tests)               | Check that the compiler ICEs/panics/crashes on certain inputs to catch accidental fixes                             |
 
 ### General purpose test suite
 
@@ -550,7 +550,7 @@ only running the main `coverage` suite.
 [`src/tools/coverage-dump`]: https://github.com/rust-lang/rust/tree/master/src/tools/coverage-dump
 [`tests/coverage-run-rustdoc`]: https://github.com/rust-lang/rust/tree/master/tests/coverage-run-rustdoc
 
-### Crashes tests
+### Crash tests
 
 [`tests/crashes`] serve as a collection of tests that are expected to cause the
 compiler to ICE, panic or crash in some other way, so that accidental fixes are
@@ -573,13 +573,13 @@ recommended to include test cases from several issues in a single PR.
 When you do so, each issue number should be noted in the file name (`12345.rs`
 should suffice) and also inside the file by means of a `//@ known-bug: #12345`
 directive. Please [label][labeling] the relevant issues with `S-bug-has-test`
-afterwards.
+once your PR is merged.
 
 If you happen to fix one of the crashes, please move it to a fitting
 subdirectory in `tests/ui` and give it a meaningful name. Please add a doc
 comment at the top of the file explaining why this test exists, even better if
 you can briefly explain how the example causes rustc to crash previously and
-what was done to prevent rustc to ICE/panic/crash.
+what was done to prevent rustc to ICE / panic / crash.
 
 Adding
 

From 260dd6f7ea7dec25c98ef6299bf1730c7dcf40b3 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 12 Sep 2025 17:04:59 +0200
Subject: [PATCH 0846/1889] make a basic hello world work on wasip2

---
 src/tools/miri/README.md                      |  2 +-
 src/tools/miri/ci/ci.sh                       |  2 +-
 .../miri/src/shims/wasi/foreign_items.rs      | 68 +++++++++++++++++++
 3 files changed, 70 insertions(+), 2 deletions(-)

diff --git a/src/tools/miri/README.md b/src/tools/miri/README.md
index 517aa343a6d4d..7094231b902f3 100644
--- a/src/tools/miri/README.md
+++ b/src/tools/miri/README.md
@@ -220,7 +220,7 @@ degree documented below):
   - `solaris` / `illumos`: maintained by @devnexen. Supports the entire test suite.
   - `freebsd`: maintained by @YohDeadfall and @LorrensP-2158466. Supports the entire test suite.
   - `android`: **maintainer wanted**. Support very incomplete, but a basic "hello world" works.
-  - `wasi`: **maintainer wanted**. Support very incomplete, not even standard output works, but an empty `main` function works.
+  - `wasi`: **maintainer wanted**. Support very incomplete, but a basic "hello world" works.
 - For targets on other operating systems, Miri might fail before even reaching the `main` function.
 
 However, even for targets that we do support, the degree of support for accessing platform APIs
diff --git a/src/tools/miri/ci/ci.sh b/src/tools/miri/ci/ci.sh
index 6356e33f61e84..bcc110f648b9b 100755
--- a/src/tools/miri/ci/ci.sh
+++ b/src/tools/miri/ci/ci.sh
@@ -153,7 +153,7 @@ case $HOST_TARGET in
     BASIC="empty_main integer heap_alloc libc-mem vec string btreemap" # ensures we have the basics: pre-main code, system allocator
     UNIX="hello 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=aarch64-linux-android  run_tests_minimal $BASIC $UNIX time hashmap random thread sync concurrency epoll eventfd
-    TEST_TARGET=wasm32-wasip2          run_tests_minimal $BASIC wasm
+    TEST_TARGET=wasm32-wasip2          run_tests_minimal $BASIC hello wasm
     TEST_TARGET=wasm32-unknown-unknown run_tests_minimal no_std empty_main wasm # this target doesn't really have std
     TEST_TARGET=thumbv7em-none-eabihf  run_tests_minimal no_std
     ;;
diff --git a/src/tools/miri/src/shims/wasi/foreign_items.rs b/src/tools/miri/src/shims/wasi/foreign_items.rs
index bfcdbd8130d84..ffc02dc986f9a 100644
--- a/src/tools/miri/src/shims/wasi/foreign_items.rs
+++ b/src/tools/miri/src/shims/wasi/foreign_items.rs
@@ -35,6 +35,74 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 this.write_pointer(res, dest)?;
             }
 
+            // Standard input/output
+            // FIXME: These shims are hacks that just get basic stdout/stderr working. We can't
+            // constrain them to "std" since std itself uses the wasi crate for this.
+            "get-stdout" => {
+                let [] =
+                    this.check_shim_sig(shim_sig!(extern "C" fn() -> i32), link_name, abi, args)?;
+                this.write_scalar(Scalar::from_i32(1), dest)?; // POSIX FD number for stdout
+            }
+            "get-stderr" => {
+                let [] =
+                    this.check_shim_sig(shim_sig!(extern "C" fn() -> i32), link_name, abi, args)?;
+                this.write_scalar(Scalar::from_i32(2), dest)?; // POSIX FD number for stderr
+            }
+            "[resource-drop]output-stream" => {
+                let [handle] =
+                    this.check_shim_sig(shim_sig!(extern "C" fn(i32) -> ()), link_name, abi, args)?;
+                let handle = this.read_scalar(handle)?.to_i32()?;
+
+                if !(handle == 1 || handle == 2) {
+                    throw_unsup_format!("wasm output-stream: unsupported handle");
+                }
+                // We don't actually close these FDs, so this is a NOP.
+            }
+            "[method]output-stream.blocking-write-and-flush" => {
+                let [handle, buf, len, ret_area] = this.check_shim_sig(
+                    shim_sig!(extern "C" fn(i32, *mut _, usize, *mut _) -> ()),
+                    link_name,
+                    abi,
+                    args,
+                )?;
+                let handle = this.read_scalar(handle)?.to_i32()?;
+                let buf = this.read_pointer(buf)?;
+                let len = this.read_target_usize(len)?;
+                let ret_area = this.read_pointer(ret_area)?;
+
+                if len > 4096 {
+                    throw_unsup_format!(
+                        "wasm output-stream.blocking-write-and-flush: buffer too big"
+                    );
+                }
+                let len = usize::try_from(len).unwrap();
+                let Some(fd) = this.machine.fds.get(handle) else {
+                    throw_unsup_format!(
+                        "wasm output-stream.blocking-write-and-flush: unsupported handle"
+                    );
+                };
+                fd.write(
+                    this.machine.communicate(),
+                    buf,
+                    len,
+                    this,
+                    callback!(
+                        @capture<'tcx> {
+                            len: usize,
+                            ret_area: Pointer,
+                        }
+                        |this, result: Result<usize, IoError>| {
+                            if !matches!(result, Ok(l) if l == len) {
+                                throw_unsup_format!("wasm output-stream.blocking-write-and-flush: returning errors is not supported");
+                            }
+                            // 0 in the first byte of the ret_area indicates success.
+                            let ret = this.ptr_to_mplace(ret_area, this.machine.layouts.u8);
+                            this.write_null(&ret)?;
+                            interp_ok(())
+                    }),
+                )?;
+            }
+
             _ => return interp_ok(EmulateItemResult::NotSupported),
         }
         interp_ok(EmulateItemResult::NeedsReturn)

From 5d8e41b656fa2802c8ab52d4c72ad67e8ff345c2 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 12 Sep 2025 17:16:38 +0200
Subject: [PATCH 0847/1889] Revert "Constify SystemTime methods"

This reverts commit 7ce620dd7c6fc3371290b40a1ea28146f0d37031.
The const-hacks introduces bugs, and they make the code harder to maintain.
Let's wait until we can constify these functions without changing their implementation.
---
 library/std/src/lib.rs                      |  5 ----
 library/std/src/sys/pal/hermit/time.rs      | 32 +++++++--------------
 library/std/src/sys/pal/sgx/time.rs         | 15 +++-------
 library/std/src/sys/pal/solid/time.rs       |  9 ++----
 library/std/src/sys/pal/uefi/time.rs        | 27 +++++------------
 library/std/src/sys/pal/unix/time.rs        | 30 ++++++-------------
 library/std/src/sys/pal/unsupported/time.rs | 15 +++-------
 library/std/src/sys/pal/wasip1/time.rs      | 25 +++++-----------
 library/std/src/sys/pal/windows/time.rs     | 30 +++++++------------
 library/std/src/sys/pal/xous/time.rs        | 15 +++-------
 library/std/src/time.rs                     | 30 ++++++-------------
 11 files changed, 68 insertions(+), 165 deletions(-)

diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index 5725816c6003c..33e3bf0c085da 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -284,7 +284,6 @@
 #![feature(core_float_math)]
 #![feature(decl_macro)]
 #![feature(deprecated_suggestion)]
-#![feature(derive_const)]
 #![feature(doc_cfg)]
 #![feature(doc_cfg_hide)]
 #![feature(doc_masked)]
@@ -332,11 +331,7 @@
 #![feature(cfg_select)]
 #![feature(char_internals)]
 #![feature(clone_to_uninit)]
-#![feature(const_cmp)]
 #![feature(const_convert)]
-#![feature(const_ops)]
-#![feature(const_option_ops)]
-#![feature(const_try)]
 #![feature(core_intrinsics)]
 #![feature(core_io_borrowed_buf)]
 #![feature(drop_guard)]
diff --git a/library/std/src/sys/pal/hermit/time.rs b/library/std/src/sys/pal/hermit/time.rs
index 89a427ab88ba9..f76a5f96c8750 100644
--- a/library/std/src/sys/pal/hermit/time.rs
+++ b/library/std/src/sys/pal/hermit/time.rs
@@ -25,15 +25,8 @@ impl Timespec {
         Timespec { t: timespec { tv_sec, tv_nsec } }
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    const fn sub_timespec(&self, other: &Timespec) -> Result<Duration, Duration> {
-        // FIXME: const PartialOrd
-        let mut cmp = self.t.tv_sec - other.t.tv_sec;
-        if cmp == 0 {
-            cmp = self.t.tv_nsec as i64 - other.t.tv_nsec as i64;
-        }
-
-        if cmp >= 0 {
+    fn sub_timespec(&self, other: &Timespec) -> Result<Duration, Duration> {
+        if self >= other {
             Ok(if self.t.tv_nsec >= other.t.tv_nsec {
                 Duration::new(
                     (self.t.tv_sec - other.t.tv_sec) as u64,
@@ -53,22 +46,20 @@ impl Timespec {
         }
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    const fn checked_add_duration(&self, other: &Duration) -> Option<Timespec> {
+    fn checked_add_duration(&self, other: &Duration) -> Option<Timespec> {
         let mut secs = self.t.tv_sec.checked_add_unsigned(other.as_secs())?;
 
         // Nano calculations can't overflow because nanos are <1B which fit
         // in a u32.
-        let mut nsec = other.subsec_nanos() + self.t.tv_nsec as u32;
-        if nsec >= NSEC_PER_SEC as u32 {
-            nsec -= NSEC_PER_SEC as u32;
+        let mut nsec = other.subsec_nanos() + u32::try_from(self.t.tv_nsec).unwrap();
+        if nsec >= NSEC_PER_SEC.try_into().unwrap() {
+            nsec -= u32::try_from(NSEC_PER_SEC).unwrap();
             secs = secs.checked_add(1)?;
         }
         Some(Timespec { t: timespec { tv_sec: secs, tv_nsec: nsec as _ } })
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    const fn checked_sub_duration(&self, other: &Duration) -> Option<Timespec> {
+    fn checked_sub_duration(&self, other: &Duration) -> Option<Timespec> {
         let mut secs = self.t.tv_sec.checked_sub_unsigned(other.as_secs())?;
 
         // Similar to above, nanos can't overflow.
@@ -222,18 +213,15 @@ impl SystemTime {
         SystemTime(time)
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
+    pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
         self.0.sub_timespec(&other.0)
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
+    pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_add_duration(other)?))
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_sub_duration(other)?))
     }
 }
diff --git a/library/std/src/sys/pal/sgx/time.rs b/library/std/src/sys/pal/sgx/time.rs
index 603dae952abd2..db4cf2804bf13 100644
--- a/library/std/src/sys/pal/sgx/time.rs
+++ b/library/std/src/sys/pal/sgx/time.rs
@@ -32,22 +32,15 @@ impl SystemTime {
         SystemTime(usercalls::insecure_time())
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
-        // FIXME: ok_or_else with const closures
-        match self.0.checked_sub(other.0) {
-            Some(duration) => Ok(duration),
-            None => Err(other.0 - self.0),
-        }
+    pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
+        self.0.checked_sub(other.0).ok_or_else(|| other.0 - self.0)
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
+    pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_add(*other)?))
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_sub(*other)?))
     }
 }
diff --git a/library/std/src/sys/pal/solid/time.rs b/library/std/src/sys/pal/solid/time.rs
index e35e60df1a0ad..c39d715c6a6f6 100644
--- a/library/std/src/sys/pal/solid/time.rs
+++ b/library/std/src/sys/pal/solid/time.rs
@@ -39,8 +39,7 @@ impl SystemTime {
         Self(t)
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
+    pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
         if self.0 >= other.0 {
             Ok(Duration::from_secs((self.0 as u64).wrapping_sub(other.0 as u64)))
         } else {
@@ -48,13 +47,11 @@ impl SystemTime {
         }
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
+    pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_add_unsigned(other.as_secs())?))
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_sub_unsigned(other.as_secs())?))
     }
 }
diff --git a/library/std/src/sys/pal/uefi/time.rs b/library/std/src/sys/pal/uefi/time.rs
index 36ce3f7ef962e..c6636626fd58a 100644
--- a/library/std/src/sys/pal/uefi/time.rs
+++ b/library/std/src/sys/pal/uefi/time.rs
@@ -80,32 +80,19 @@ impl SystemTime {
             .unwrap_or_else(|| panic!("time not implemented on this platform"))
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
-        // FIXME: ok_or_else with const closures
-        match self.0.checked_sub(other.0) {
-            Some(duration) => Ok(duration),
-            None => Err(other.0 - self.0),
-        }
+    pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
+        self.0.checked_sub(other.0).ok_or_else(|| other.0 - self.0)
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
-        let temp = self.0.checked_add(*other)?;
+    pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
+        let temp = Self(self.0.checked_add(*other)?);
 
         // Check if can be represented in UEFI
-        // FIXME: const PartialOrd
-        let mut cmp = temp.as_secs() - MAX_UEFI_TIME.0.as_secs();
-        if cmp == 0 {
-            cmp = temp.subsec_nanos() as u64 - MAX_UEFI_TIME.0.subsec_nanos() as u64;
-        }
-
-        if cmp <= 0 { Some(SystemTime(temp)) } else { None }
+        if temp <= MAX_UEFI_TIME { Some(temp) } else { None }
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
-        Some(SystemTime(self.0.checked_sub(*other)?))
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+        self.0.checked_sub(*other).map(Self)
     }
 }
 
diff --git a/library/std/src/sys/pal/unix/time.rs b/library/std/src/sys/pal/unix/time.rs
index 328fe0bc9603f..bd7f74fea6a9c 100644
--- a/library/std/src/sys/pal/unix/time.rs
+++ b/library/std/src/sys/pal/unix/time.rs
@@ -38,18 +38,15 @@ impl SystemTime {
         SystemTime { t: Timespec::now(libc::CLOCK_REALTIME) }
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
+    pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
         self.t.sub_timespec(&other.t)
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
+    pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime { t: self.t.checked_add_duration(other)? })
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime { t: self.t.checked_sub_duration(other)? })
     }
 }
@@ -136,15 +133,8 @@ impl Timespec {
         Timespec::new(t.tv_sec as i64, t.tv_nsec as i64).unwrap()
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn sub_timespec(&self, other: &Timespec) -> Result<Duration, Duration> {
-        // FIXME: const PartialOrd
-        let mut cmp = self.tv_sec - other.tv_sec;
-        if cmp == 0 {
-            cmp = self.tv_nsec.as_inner() as i64 - other.tv_nsec.as_inner() as i64;
-        }
-
-        if cmp >= 0 {
+    pub fn sub_timespec(&self, other: &Timespec) -> Result<Duration, Duration> {
+        if self >= other {
             // NOTE(eddyb) two aspects of this `if`-`else` are required for LLVM
             // to optimize it into a branchless form (see also #75545):
             //
@@ -179,8 +169,7 @@ impl Timespec {
         }
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn checked_add_duration(&self, other: &Duration) -> Option<Timespec> {
+    pub fn checked_add_duration(&self, other: &Duration) -> Option<Timespec> {
         let mut secs = self.tv_sec.checked_add_unsigned(other.as_secs())?;
 
         // Nano calculations can't overflow because nanos are <1B which fit
@@ -190,11 +179,10 @@ impl Timespec {
             nsec -= NSEC_PER_SEC as u32;
             secs = secs.checked_add(1)?;
         }
-        Some(unsafe { Timespec::new_unchecked(secs, nsec as i64) })
+        Some(unsafe { Timespec::new_unchecked(secs, nsec.into()) })
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn checked_sub_duration(&self, other: &Duration) -> Option<Timespec> {
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<Timespec> {
         let mut secs = self.tv_sec.checked_sub_unsigned(other.as_secs())?;
 
         // Similar to above, nanos can't overflow.
@@ -203,7 +191,7 @@ impl Timespec {
             nsec += NSEC_PER_SEC as i32;
             secs = secs.checked_sub(1)?;
         }
-        Some(unsafe { Timespec::new_unchecked(secs, nsec as i64) })
+        Some(unsafe { Timespec::new_unchecked(secs, nsec.into()) })
     }
 
     #[allow(dead_code)]
diff --git a/library/std/src/sys/pal/unsupported/time.rs b/library/std/src/sys/pal/unsupported/time.rs
index 0c38791704407..6d67b538a96bf 100644
--- a/library/std/src/sys/pal/unsupported/time.rs
+++ b/library/std/src/sys/pal/unsupported/time.rs
@@ -31,22 +31,15 @@ impl SystemTime {
         panic!("time not implemented on this platform")
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
-        // FIXME: ok_or_else with const closures
-        match self.0.checked_sub(other.0) {
-            Some(duration) => Ok(duration),
-            None => Err(other.0 - self.0),
-        }
+    pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
+        self.0.checked_sub(other.0).ok_or_else(|| other.0 - self.0)
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
+    pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_add(*other)?))
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_sub(*other)?))
     }
 }
diff --git a/library/std/src/sys/pal/wasip1/time.rs b/library/std/src/sys/pal/wasip1/time.rs
index 892661b312b2f..0d8d0b59ac14a 100644
--- a/library/std/src/sys/pal/wasip1/time.rs
+++ b/library/std/src/sys/pal/wasip1/time.rs
@@ -43,34 +43,23 @@ impl SystemTime {
         SystemTime(current_time(wasi::CLOCKID_REALTIME))
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn from_wasi_timestamp(ts: wasi::Timestamp) -> SystemTime {
+    pub fn from_wasi_timestamp(ts: wasi::Timestamp) -> SystemTime {
         SystemTime(Duration::from_nanos(ts))
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn to_wasi_timestamp(&self) -> Option<wasi::Timestamp> {
-        // FIXME: const TryInto
-        let ns = self.0.as_nanos();
-        if ns <= u64::MAX as u128 { Some(ns as u64) } else { None }
+    pub fn to_wasi_timestamp(&self) -> Option<wasi::Timestamp> {
+        self.0.as_nanos().try_into().ok()
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
-        // FIXME: ok_or_else with const closures
-        match self.0.checked_sub(other.0) {
-            Some(duration) => Ok(duration),
-            None => Err(other.0 - self.0),
-        }
+    pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
+        self.0.checked_sub(other.0).ok_or_else(|| other.0 - self.0)
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
+    pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_add(*other)?))
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_sub(*other)?))
     }
 }
diff --git a/library/std/src/sys/pal/windows/time.rs b/library/std/src/sys/pal/windows/time.rs
index f8f9a9fd81809..0d31b80e56afc 100644
--- a/library/std/src/sys/pal/windows/time.rs
+++ b/library/std/src/sys/pal/windows/time.rs
@@ -72,8 +72,7 @@ impl SystemTime {
         }
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    const fn from_intervals(intervals: i64) -> SystemTime {
+    fn from_intervals(intervals: i64) -> SystemTime {
         SystemTime {
             t: c::FILETIME {
                 dwLowDateTime: intervals as u32,
@@ -82,13 +81,11 @@ impl SystemTime {
         }
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    const fn intervals(&self) -> i64 {
+    fn intervals(&self) -> i64 {
         (self.t.dwLowDateTime as i64) | ((self.t.dwHighDateTime as i64) << 32)
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
+    pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
         let me = self.intervals();
         let other = other.intervals();
         if me >= other {
@@ -98,14 +95,12 @@ impl SystemTime {
         }
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
+    pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
         let intervals = self.intervals().checked_add(checked_dur2intervals(other)?)?;
         Some(SystemTime::from_intervals(intervals))
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
         let intervals = self.intervals().checked_sub(checked_dur2intervals(other)?)?;
         Some(SystemTime::from_intervals(intervals))
     }
@@ -155,18 +150,15 @@ impl Hash for SystemTime {
     }
 }
 
-#[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-const fn checked_dur2intervals(dur: &Duration) -> Option<i64> {
-    // FIXME: const TryInto
-    let secs = dur
-        .as_secs()
+fn checked_dur2intervals(dur: &Duration) -> Option<i64> {
+    dur.as_secs()
         .checked_mul(INTERVALS_PER_SEC)?
-        .checked_add(dur.subsec_nanos() as u64 / 100)?;
-    if secs <= i64::MAX as u64 { Some(secs.cast_signed()) } else { None }
+        .checked_add(dur.subsec_nanos() as u64 / 100)?
+        .try_into()
+        .ok()
 }
 
-#[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-const fn intervals2dur(intervals: u64) -> Duration {
+fn intervals2dur(intervals: u64) -> Duration {
     Duration::new(intervals / INTERVALS_PER_SEC, ((intervals % INTERVALS_PER_SEC) * 100) as u32)
 }
 
diff --git a/library/std/src/sys/pal/xous/time.rs b/library/std/src/sys/pal/xous/time.rs
index d737416436e68..ae8be81c0b7c5 100644
--- a/library/std/src/sys/pal/xous/time.rs
+++ b/library/std/src/sys/pal/xous/time.rs
@@ -43,22 +43,15 @@ impl SystemTime {
         SystemTime { 0: Duration::from_millis((upper as u64) << 32 | lower as u64) }
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
-        // FIXME: ok_or_else with const closures
-        match self.0.checked_sub(other.0) {
-            Some(duration) => Ok(duration),
-            None => Err(other.0 - self.0),
-        }
+    pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
+        self.0.checked_sub(other.0).ok_or_else(|| other.0 - self.0)
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
+    pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_add(*other)?))
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_sub(*other)?))
     }
 }
diff --git a/library/std/src/time.rs b/library/std/src/time.rs
index 84fbb4c2fe4b1..31187adb6feae 100644
--- a/library/std/src/time.rs
+++ b/library/std/src/time.rs
@@ -551,13 +551,8 @@ impl SystemTime {
     /// println!("{difference:?}");
     /// ```
     #[stable(feature = "time2", since = "1.8.0")]
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn duration_since(&self, earlier: SystemTime) -> Result<Duration, SystemTimeError> {
-        // FIXME: map_err in const
-        match self.0.sub_time(&earlier.0) {
-            Ok(time) => Ok(time),
-            Err(err) => Err(SystemTimeError(err)),
-        }
+    pub fn duration_since(&self, earlier: SystemTime) -> Result<Duration, SystemTimeError> {
+        self.0.sub_time(&earlier.0).map_err(SystemTimeError)
     }
 
     /// Returns the difference from this system time to the
@@ -594,8 +589,7 @@ impl SystemTime {
     /// `SystemTime` (which means it's inside the bounds of the underlying data structure), `None`
     /// otherwise.
     #[stable(feature = "time_checked_add", since = "1.34.0")]
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn checked_add(&self, duration: Duration) -> Option<SystemTime> {
+    pub fn checked_add(&self, duration: Duration) -> Option<SystemTime> {
         self.0.checked_add_duration(&duration).map(SystemTime)
     }
 
@@ -603,15 +597,13 @@ impl SystemTime {
     /// `SystemTime` (which means it's inside the bounds of the underlying data structure), `None`
     /// otherwise.
     #[stable(feature = "time_checked_add", since = "1.34.0")]
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn checked_sub(&self, duration: Duration) -> Option<SystemTime> {
+    pub fn checked_sub(&self, duration: Duration) -> Option<SystemTime> {
         self.0.checked_sub_duration(&duration).map(SystemTime)
     }
 }
 
 #[stable(feature = "time2", since = "1.8.0")]
-#[rustc_const_unstable(feature = "const_ops", issue = "143802")]
-impl const Add<Duration> for SystemTime {
+impl Add<Duration> for SystemTime {
     type Output = SystemTime;
 
     /// # Panics
@@ -624,16 +616,14 @@ impl const Add<Duration> for SystemTime {
 }
 
 #[stable(feature = "time_augmented_assignment", since = "1.9.0")]
-#[rustc_const_unstable(feature = "const_ops", issue = "143802")]
-impl const AddAssign<Duration> for SystemTime {
+impl AddAssign<Duration> for SystemTime {
     fn add_assign(&mut self, other: Duration) {
         *self = *self + other;
     }
 }
 
 #[stable(feature = "time2", since = "1.8.0")]
-#[rustc_const_unstable(feature = "const_ops", issue = "143802")]
-impl const Sub<Duration> for SystemTime {
+impl Sub<Duration> for SystemTime {
     type Output = SystemTime;
 
     fn sub(self, dur: Duration) -> SystemTime {
@@ -642,8 +632,7 @@ impl const Sub<Duration> for SystemTime {
 }
 
 #[stable(feature = "time_augmented_assignment", since = "1.9.0")]
-#[rustc_const_unstable(feature = "const_ops", issue = "143802")]
-impl const SubAssign<Duration> for SystemTime {
+impl SubAssign<Duration> for SystemTime {
     fn sub_assign(&mut self, other: Duration) {
         *self = *self - other;
     }
@@ -710,8 +699,7 @@ impl SystemTimeError {
     /// ```
     #[must_use]
     #[stable(feature = "time2", since = "1.8.0")]
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn duration(&self) -> Duration {
+    pub fn duration(&self) -> Duration {
         self.0
     }
 }

From a70d78a55286a85cf5e06958929f5a6071fa1c67 Mon Sep 17 00:00:00 2001
From: Patrick-6 <pamu99@gmx.ch>
Date: Fri, 14 Mar 2025 09:58:46 +0100
Subject: [PATCH 0848/1889] Implement more features for GenMC mode - Handling
 Compare-Exchange operations.   - Limitation: Compare-Exchange currently
 ignores possibility of spurious failures.   - Limitation: Compare-Exchange
 failure memory ordering is ignored.     - Upgrade compare-exchange success
 ordering to avoid reporting non-existent bugs. - Add warnings for GenMC mode
 for unsupported features. - Add a lot of tests, including translation of
 GenMC litmus tests and Loom tests. - Cleanup

---
 .../genmc-sys/cpp/include/MiriInterface.hpp   |  82 +++++++++----
 .../cpp/src/MiriInterface/EventHandling.cpp   |  65 +++++++++++
 .../genmc-sys/cpp/src/MiriInterface/Setup.cpp |   8 +-
 src/tools/miri/genmc-sys/src/lib.rs           |  25 ++++
 .../miri/src/concurrency/genmc/helper.rs      |  82 ++++++++++++-
 src/tools/miri/src/concurrency/genmc/mod.rs   | 109 +++++++++++++++---
 src/tools/miri/src/concurrency/genmc/run.rs   |   4 +-
 src/tools/miri/src/diagnostics.rs             |  26 +++++
 .../genmc/fail/data_race/mpu2_rels_rlx.rs     |  45 ++++++++
 .../genmc/fail/data_race/mpu2_rels_rlx.stderr |  19 +++
 .../fail/loom/store_buffering.genmc.stderr    |  13 +++
 .../loom/store_buffering.non_genmc.stderr     |  13 +++
 .../tests/genmc/fail/loom/store_buffering.rs  |  57 +++++++++
 .../atomics/cas_failure_ord_racy_key_init.rs  |  70 +++++++++++
 .../cas_failure_ord_racy_key_init.stderr      |  22 ++++
 .../tests/genmc/pass/atomics/cas_simple.rs    |  34 ++++++
 .../genmc/pass/atomics/cas_simple.stderr      |   2 +
 .../miri/tests/genmc/pass/litmus/IRIWish.rs   |   4 +-
 .../tests/genmc/pass/litmus/MPU2_rels_acqf.rs |  67 +++++++++++
 .../genmc/pass/litmus/MPU2_rels_acqf.stderr   |  38 ++++++
 .../miri/tests/genmc/pass/litmus/Z6_U.rs      |   7 +-
 .../miri/tests/genmc/pass/litmus/casdep.rs    |  37 ++++++
 .../tests/genmc/pass/litmus/casdep.stderr     |   2 +
 src/tools/miri/tests/genmc/pass/litmus/ccr.rs |  34 ++++++
 .../miri/tests/genmc/pass/litmus/ccr.stderr   |   2 +
 src/tools/miri/tests/genmc/pass/litmus/cii.rs |  35 ++++++
 .../miri/tests/genmc/pass/litmus/cii.stderr   |   2 +
 27 files changed, 850 insertions(+), 54 deletions(-)
 create mode 100644 src/tools/miri/tests/genmc/fail/data_race/mpu2_rels_rlx.rs
 create mode 100644 src/tools/miri/tests/genmc/fail/data_race/mpu2_rels_rlx.stderr
 create mode 100644 src/tools/miri/tests/genmc/fail/loom/store_buffering.genmc.stderr
 create mode 100644 src/tools/miri/tests/genmc/fail/loom/store_buffering.non_genmc.stderr
 create mode 100644 src/tools/miri/tests/genmc/fail/loom/store_buffering.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/atomics/cas_failure_ord_racy_key_init.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/atomics/cas_failure_ord_racy_key_init.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/atomics/cas_simple.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/atomics/cas_simple.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/MPU2_rels_acqf.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/MPU2_rels_acqf.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/casdep.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/casdep.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/ccr.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/ccr.stderr
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/cii.rs
 create mode 100644 src/tools/miri/tests/genmc/pass/litmus/cii.stderr

diff --git a/src/tools/miri/genmc-sys/cpp/include/MiriInterface.hpp b/src/tools/miri/genmc-sys/cpp/include/MiriInterface.hpp
index b076937584326..662eb0e173ca8 100644
--- a/src/tools/miri/genmc-sys/cpp/include/MiriInterface.hpp
+++ b/src/tools/miri/genmc-sys/cpp/include/MiriInterface.hpp
@@ -34,6 +34,7 @@ struct SchedulingResult;
 struct LoadResult;
 struct StoreResult;
 struct ReadModifyWriteResult;
+struct CompareExchangeResult;
 
 // GenMC uses `int` for its thread IDs.
 using ThreadId = int;
@@ -100,6 +101,17 @@ struct MiriGenmcShim : private GenMCDriver {
         GenmcScalar rhs_value,
         GenmcScalar old_val
     );
+    [[nodiscard]] CompareExchangeResult handle_compare_exchange(
+        ThreadId thread_id,
+        uint64_t address,
+        uint64_t size,
+        GenmcScalar expected_value,
+        GenmcScalar new_value,
+        GenmcScalar old_val,
+        MemOrdering success_ordering,
+        MemOrdering fail_load_ordering,
+        bool can_fail_spuriously
+    );
     [[nodiscard]] StoreResult handle_store(
         ThreadId thread_id,
         uint64_t address,
@@ -231,15 +243,15 @@ constexpr auto get_global_alloc_static_mask() -> uint64_t {
 namespace GenmcScalarExt {
 inline GenmcScalar uninit() {
     return GenmcScalar {
-        /* value: */ 0,
-        /* is_init: */ false,
+        .value = 0,
+        .is_init = false,
     };
 }
 
 inline GenmcScalar from_sval(SVal sval) {
     return GenmcScalar {
-        /* value: */ sval.get(),
-        /* is_init: */ true,
+        .value = sval.get(),
+        .is_init = true,
     };
 }
 
@@ -252,22 +264,22 @@ inline SVal to_sval(GenmcScalar scalar) {
 namespace LoadResultExt {
 inline LoadResult no_value() {
     return LoadResult {
-        /* error: */ std::unique_ptr<std::string>(nullptr),
-        /* has_value: */ false,
-        /* read_value: */ GenmcScalarExt::uninit(),
+        .error = std::unique_ptr<std::string>(nullptr),
+        .has_value = false,
+        .read_value = GenmcScalarExt::uninit(),
     };
 }
 
 inline LoadResult from_value(SVal read_value) {
-    return LoadResult { /* error: */ std::unique_ptr<std::string>(nullptr),
-                        /* has_value: */ true,
-                        /* read_value: */ GenmcScalarExt::from_sval(read_value) };
+    return LoadResult { .error = std::unique_ptr<std::string>(nullptr),
+                        .has_value = true,
+                        .read_value = GenmcScalarExt::from_sval(read_value) };
 }
 
 inline LoadResult from_error(std::unique_ptr<std::string> error) {
-    return LoadResult { /* error: */ std::move(error),
-                        /* has_value: */ false,
-                        /* read_value: */ GenmcScalarExt::uninit() };
+    return LoadResult { .error = std::move(error),
+                        .has_value = false,
+                        .read_value = GenmcScalarExt::uninit() };
 }
 } // namespace LoadResultExt
 
@@ -278,26 +290,50 @@ inline StoreResult ok(bool is_coherence_order_maximal_write) {
 }
 
 inline StoreResult from_error(std::unique_ptr<std::string> error) {
-    return StoreResult { /* error: */ std::move(error),
-                         /* is_coherence_order_maximal_write: */ false };
+    return StoreResult { .error = std::move(error), .is_coherence_order_maximal_write = false };
 }
 } // namespace StoreResultExt
 
 namespace ReadModifyWriteResultExt {
 inline ReadModifyWriteResult
 ok(SVal old_value, SVal new_value, bool is_coherence_order_maximal_write) {
-    return ReadModifyWriteResult { /* error: */ std::unique_ptr<std::string>(nullptr),
-                                   /* old_value: */ GenmcScalarExt::from_sval(old_value),
-                                   /* new_value: */ GenmcScalarExt::from_sval(new_value),
-                                   is_coherence_order_maximal_write };
+    return ReadModifyWriteResult { .error = std::unique_ptr<std::string>(nullptr),
+                                   .old_value = GenmcScalarExt::from_sval(old_value),
+                                   .new_value = GenmcScalarExt::from_sval(new_value),
+                                   .is_coherence_order_maximal_write =
+                                       is_coherence_order_maximal_write };
 }
 
 inline ReadModifyWriteResult from_error(std::unique_ptr<std::string> error) {
-    return ReadModifyWriteResult { /* error: */ std::move(error),
-                                   /* old_value: */ GenmcScalarExt::uninit(),
-                                   /* new_value: */ GenmcScalarExt::uninit(),
-                                   /* is_coherence_order_maximal_write: */ false };
+    return ReadModifyWriteResult { .error = std::move(error),
+                                   .old_value = GenmcScalarExt::uninit(),
+                                   .new_value = GenmcScalarExt::uninit(),
+                                   .is_coherence_order_maximal_write = false };
 }
 } // namespace ReadModifyWriteResultExt
 
+namespace CompareExchangeResultExt {
+inline CompareExchangeResult success(SVal old_value, bool is_coherence_order_maximal_write) {
+    return CompareExchangeResult { .error = nullptr,
+                                   .old_value = GenmcScalarExt::from_sval(old_value),
+                                   .is_success = true,
+                                   .is_coherence_order_maximal_write =
+                                       is_coherence_order_maximal_write };
+}
+
+inline CompareExchangeResult failure(SVal old_value) {
+    return CompareExchangeResult { .error = nullptr,
+                                   .old_value = GenmcScalarExt::from_sval(old_value),
+                                   .is_success = false,
+                                   .is_coherence_order_maximal_write = false };
+}
+
+inline CompareExchangeResult from_error(std::unique_ptr<std::string> error) {
+    return CompareExchangeResult { .error = std::move(error),
+                                   .old_value = GenmcScalarExt::uninit(),
+                                   .is_success = false,
+                                   .is_coherence_order_maximal_write = false };
+}
+} // namespace CompareExchangeResultExt
+
 #endif /* GENMC_MIRI_INTERFACE_HPP */
diff --git a/src/tools/miri/genmc-sys/cpp/src/MiriInterface/EventHandling.cpp b/src/tools/miri/genmc-sys/cpp/src/MiriInterface/EventHandling.cpp
index cd28e0d148f58..05c82641df948 100644
--- a/src/tools/miri/genmc-sys/cpp/src/MiriInterface/EventHandling.cpp
+++ b/src/tools/miri/genmc-sys/cpp/src/MiriInterface/EventHandling.cpp
@@ -155,6 +155,71 @@ void MiriGenmcShim::handle_fence(ThreadId thread_id, MemOrdering ord) {
     );
 }
 
+[[nodiscard]] auto MiriGenmcShim::handle_compare_exchange(
+    ThreadId thread_id,
+    uint64_t address,
+    uint64_t size,
+    GenmcScalar expected_value,
+    GenmcScalar new_value,
+    GenmcScalar old_val,
+    MemOrdering success_ordering,
+    MemOrdering fail_load_ordering,
+    bool can_fail_spuriously
+) -> CompareExchangeResult {
+    // NOTE: Both the store and load events should get the same `ordering`, it should not be split
+    // into a load and a store component. This means we can have for example `AcqRel` loads and
+    // stores, but this is intended for CAS operations.
+
+    // FIXME(GenMC): properly handle failure memory ordering.
+
+    auto expectedVal = GenmcScalarExt::to_sval(expected_value);
+    auto new_val = GenmcScalarExt::to_sval(new_value);
+
+    const auto load_ret = handle_load_reset_if_none<EventLabel::EventLabelKind::CasRead>(
+        thread_id,
+        success_ordering,
+        SAddr(address),
+        ASize(size),
+        AType::Unsigned, // The type is only used for printing.
+        expectedVal,
+        new_val
+    );
+    if (const auto* err = std::get_if<VerificationError>(&load_ret))
+        return CompareExchangeResultExt::from_error(format_error(*err));
+    const auto* ret_val = std::get_if<SVal>(&load_ret);
+    ERROR_ON(nullptr == ret_val, "Unimplemented: load returned unexpected result.");
+    const auto read_old_val = *ret_val;
+    if (read_old_val != expectedVal)
+        return CompareExchangeResultExt::failure(read_old_val);
+
+    // FIXME(GenMC): Add support for modelling spurious failures.
+
+    const auto storePos = inc_pos(thread_id);
+    const auto store_ret = GenMCDriver::handleStore<EventLabel::EventLabelKind::CasWrite>(
+        storePos,
+        success_ordering,
+        SAddr(address),
+        ASize(size),
+        AType::Unsigned, // The type is only used for printing.
+        new_val
+    );
+    if (const auto* err = std::get_if<VerificationError>(&store_ret))
+        return CompareExchangeResultExt::from_error(format_error(*err));
+    const auto* store_ret_val = std::get_if<std::monostate>(&store_ret);
+    ERROR_ON(
+        nullptr == store_ret_val,
+        "Unimplemented: compare-exchange store returned unexpected result."
+    );
+
+    // FIXME(genmc,mixed-accesses): Use the value that GenMC returns from handleStore (once
+    // available).
+    const auto& g = getExec().getGraph();
+    return CompareExchangeResultExt::success(
+        read_old_val,
+        /* is_coherence_order_maximal_write */ g.co_max(SAddr(address))->getPos() == storePos
+    );
+}
+
 /**** Memory (de)allocation ****/
 
 auto MiriGenmcShim::handle_malloc(ThreadId thread_id, uint64_t size, uint64_t alignment)
diff --git a/src/tools/miri/genmc-sys/cpp/src/MiriInterface/Setup.cpp b/src/tools/miri/genmc-sys/cpp/src/MiriInterface/Setup.cpp
index 5a53fee059216..a17a83aa06e13 100644
--- a/src/tools/miri/genmc-sys/cpp/src/MiriInterface/Setup.cpp
+++ b/src/tools/miri/genmc-sys/cpp/src/MiriInterface/Setup.cpp
@@ -152,10 +152,10 @@ static auto to_genmc_verbosity_level(const LogLevel log_level) -> VerbosityLevel
         // Miri already ensures that memory accesses are valid, so this check doesn't matter.
         // We check that the address is static, but skip checking if it is part of an actual
         // allocation.
-        /* isStaticallyAllocated: */ [](SAddr addr) { return addr.isStatic(); },
+        .isStaticallyAllocated = [](SAddr addr) { return addr.isStatic(); },
         // FIXME(genmc,error reporting): Once a proper a proper API for passing such information is
         // implemented in GenMC, Miri should use it to improve the produced error messages.
-        /* getStaticName: */ [](SAddr addr) { return "[UNKNOWN STATIC]"; },
+        .getStaticName = [](SAddr addr) { return "[UNKNOWN STATIC]"; },
         // This function is called to get the initial value stored at the given address.
         //
         // From a Miri perspective, this API doesn't work very well: most memory starts out
@@ -177,10 +177,10 @@ static auto to_genmc_verbosity_level(const LogLevel log_level) -> VerbosityLevel
         // FIXME(genmc): implement proper support for uninitialized memory in GenMC. Ideally, the
         // initial value getter would return an `optional<SVal>`, since the memory location may be
         // uninitialized.
-        /* initValGetter: */ [](const AAccess& a) { return SVal(0xDEAD); },
+        .initValGetter = [](const AAccess& a) { return SVal(0xDEAD); },
         // Miri serves non-atomic loads from its own memory and these GenMC checks are wrong in
         // that case. This should no longer be required with proper mixed-size access support.
-        /* skipUninitLoadChecks: */ [](MemOrdering ord) { return ord == MemOrdering::NotAtomic; },
+        .skipUninitLoadChecks = [](MemOrdering ord) { return ord == MemOrdering::NotAtomic; },
     };
     driver->setInterpCallbacks(std::move(interpreter_callbacks));
 
diff --git a/src/tools/miri/genmc-sys/src/lib.rs b/src/tools/miri/genmc-sys/src/lib.rs
index 1de4c4eb5e8e9..31bc2606adc01 100644
--- a/src/tools/miri/genmc-sys/src/lib.rs
+++ b/src/tools/miri/genmc-sys/src/lib.rs
@@ -198,6 +198,19 @@ mod ffi {
         is_coherence_order_maximal_write: bool,
     }
 
+    #[must_use]
+    #[derive(Debug)]
+    struct CompareExchangeResult {
+        /// If there was an error, it will be stored in `error`, otherwise it is `None`.
+        error: UniquePtr<CxxString>,
+        /// The value that was read by the compare-exchange.
+        old_value: GenmcScalar,
+        /// `true` if compare_exchange op was successful.
+        is_success: bool,
+        /// `true` if the write should also be reflected in Miri's memory representation.
+        is_coherence_order_maximal_write: bool,
+    }
+
     /**** These are GenMC types that we have to copy-paste here since cxx does not support
     "importing" externally defined C++ types. ****/
 
@@ -313,6 +326,18 @@ mod ffi {
             rhs_value: GenmcScalar,
             old_value: GenmcScalar,
         ) -> ReadModifyWriteResult;
+        fn handle_compare_exchange(
+            self: Pin<&mut MiriGenmcShim>,
+            thread_id: i32,
+            address: u64,
+            size: u64,
+            expected_value: GenmcScalar,
+            new_value: GenmcScalar,
+            old_value: GenmcScalar,
+            success_ordering: MemOrdering,
+            fail_load_ordering: MemOrdering,
+            can_fail_spuriously: bool,
+        ) -> CompareExchangeResult;
         fn handle_store(
             self: Pin<&mut MiriGenmcShim>,
             thread_id: i32,
diff --git a/src/tools/miri/src/concurrency/genmc/helper.rs b/src/tools/miri/src/concurrency/genmc/helper.rs
index 2a84ca2036676..48a5ec8bb2608 100644
--- a/src/tools/miri/src/concurrency/genmc/helper.rs
+++ b/src/tools/miri/src/concurrency/genmc/helper.rs
@@ -1,20 +1,52 @@
+use std::sync::RwLock;
+
 use genmc_sys::{MemOrdering, RMWBinOp};
 use rustc_abi::Size;
 use rustc_const_eval::interpret::{InterpResult, interp_ok};
+use rustc_data_structures::fx::FxHashSet;
 use rustc_middle::mir;
 use rustc_middle::ty::ScalarInt;
+use rustc_span::Span;
 use tracing::debug;
 
 use super::GenmcScalar;
+use crate::diagnostics::EvalContextExt;
 use crate::intrinsics::AtomicRmwOp;
 use crate::{
-    AtomicFenceOrd, AtomicReadOrd, AtomicRwOrd, AtomicWriteOrd, MiriInterpCx, Scalar,
-    throw_unsup_format,
+    AtomicFenceOrd, AtomicReadOrd, AtomicRwOrd, AtomicWriteOrd, InterpCx, MiriInterpCx,
+    MiriMachine, NonHaltingDiagnostic, Scalar, throw_unsup_format,
 };
 
 /// Maximum size memory access in bytes that GenMC supports.
 pub(super) const MAX_ACCESS_SIZE: u64 = 8;
 
+/// Type for storing spans for already emitted warnings.
+pub(super) type WarningCache = RwLock<FxHashSet<Span>>;
+
+#[derive(Default)]
+pub(super) struct Warnings {
+    pub(super) compare_exchange_failure_ordering: WarningCache,
+    pub(super) compare_exchange_weak: WarningCache,
+}
+
+/// Emit a warning if it hasn't already been reported for current span.
+pub(super) fn emit_warning<'tcx>(
+    ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
+    cache: &WarningCache,
+    diagnostic: impl FnOnce() -> NonHaltingDiagnostic,
+) {
+    let span = ecx.machine.current_span();
+    if cache.read().unwrap().contains(&span) {
+        return;
+    }
+    // This span has not yet been reported, so we insert it into the cache and report it.
+    let mut cache = cache.write().unwrap();
+    if cache.insert(span) {
+        // Some other thread may have added this span while we didn't hold the lock, so we only emit it if the insertions succeeded.
+        ecx.emit_diagnostic(diagnostic());
+    }
+}
+
 /// This function is used to split up a large memory access into aligned, non-overlapping chunks of a limited size.
 /// Returns an iterator over the chunks, yielding `(base address, size)` of each chunk, ordered by address.
 pub fn split_access(address: Size, size: Size) -> impl Iterator<Item = (u64, u64)> {
@@ -112,7 +144,53 @@ impl AtomicFenceOrd {
     }
 }
 
+/// Since GenMC ignores the failure memory ordering and Miri should not detect bugs that don't actually exist, we upgrade the success ordering if required.
+/// This means that Miri running in GenMC mode will not explore all possible executions allowed under the RC11 memory model.
+/// FIXME(genmc): remove this once GenMC properly supports the failure memory ordering.
+pub(super) fn maybe_upgrade_compare_exchange_success_orderings(
+    success: AtomicRwOrd,
+    failure: AtomicReadOrd,
+) -> AtomicRwOrd {
+    use AtomicReadOrd::*;
+    let (success_read, success_write) = success.split_memory_orderings();
+    let upgraded_success_read = match (success_read, failure) {
+        (_, SeqCst) | (SeqCst, _) => SeqCst,
+        (Acquire, _) | (_, Acquire) => Acquire,
+        (Relaxed, Relaxed) => Relaxed,
+    };
+    AtomicRwOrd::from_split_memory_orderings(upgraded_success_read, success_write)
+}
+
 impl AtomicRwOrd {
+    /// Split up an atomic read-write memory ordering into a separate read and write ordering.
+    pub(super) fn split_memory_orderings(self) -> (AtomicReadOrd, AtomicWriteOrd) {
+        match self {
+            AtomicRwOrd::Relaxed => (AtomicReadOrd::Relaxed, AtomicWriteOrd::Relaxed),
+            AtomicRwOrd::Acquire => (AtomicReadOrd::Acquire, AtomicWriteOrd::Relaxed),
+            AtomicRwOrd::Release => (AtomicReadOrd::Relaxed, AtomicWriteOrd::Release),
+            AtomicRwOrd::AcqRel => (AtomicReadOrd::Acquire, AtomicWriteOrd::Release),
+            AtomicRwOrd::SeqCst => (AtomicReadOrd::SeqCst, AtomicWriteOrd::SeqCst),
+        }
+    }
+
+    /// Split up an atomic read-write memory ordering into a separate read and write ordering.
+    fn from_split_memory_orderings(
+        read_ordering: AtomicReadOrd,
+        write_ordering: AtomicWriteOrd,
+    ) -> Self {
+        match (read_ordering, write_ordering) {
+            (AtomicReadOrd::Relaxed, AtomicWriteOrd::Relaxed) => AtomicRwOrd::Relaxed,
+            (AtomicReadOrd::Acquire, AtomicWriteOrd::Relaxed) => AtomicRwOrd::Acquire,
+            (AtomicReadOrd::Relaxed, AtomicWriteOrd::Release) => AtomicRwOrd::Release,
+            (AtomicReadOrd::Acquire, AtomicWriteOrd::Release) => AtomicRwOrd::AcqRel,
+            (AtomicReadOrd::SeqCst, AtomicWriteOrd::SeqCst) => AtomicRwOrd::SeqCst,
+            _ =>
+                panic!(
+                    "Unsupported memory ordering combination ({read_ordering:?}, {write_ordering:?})"
+                ),
+        }
+    }
+
     pub(super) fn to_genmc(self) -> MemOrdering {
         match self {
             AtomicRwOrd::Relaxed => MemOrdering::Relaxed,
diff --git a/src/tools/miri/src/concurrency/genmc/mod.rs b/src/tools/miri/src/concurrency/genmc/mod.rs
index c1da86c673364..7270c66810608 100644
--- a/src/tools/miri/src/concurrency/genmc/mod.rs
+++ b/src/tools/miri/src/concurrency/genmc/mod.rs
@@ -13,15 +13,16 @@ use tracing::{debug, info};
 
 use self::global_allocations::{EvalContextExt as _, GlobalAllocationHandler};
 use self::helper::{
-    MAX_ACCESS_SIZE, genmc_scalar_to_scalar, scalar_to_genmc_scalar, to_genmc_rmw_op,
+    MAX_ACCESS_SIZE, Warnings, emit_warning, genmc_scalar_to_scalar,
+    maybe_upgrade_compare_exchange_success_orderings, scalar_to_genmc_scalar, to_genmc_rmw_op,
 };
 use self::thread_id_map::ThreadIdMap;
 use crate::concurrency::genmc::helper::split_access;
 use crate::intrinsics::AtomicRmwOp;
 use crate::{
     AtomicFenceOrd, AtomicReadOrd, AtomicRwOrd, AtomicWriteOrd, MemoryKind, MiriConfig,
-    MiriMachine, MiriMemoryKind, Scalar, TerminationInfo, ThreadId, ThreadManager, VisitProvenance,
-    VisitWith,
+    MiriMachine, MiriMemoryKind, NonHaltingDiagnostic, Scalar, TerminationInfo, ThreadId,
+    ThreadManager, VisitProvenance, VisitWith,
 };
 
 mod config;
@@ -81,16 +82,22 @@ impl PerExecutionState {
     }
 }
 
-#[derive(Debug)]
 struct GlobalState {
     /// Keep track of global allocations, to ensure they keep the same address across different executions, even if the order of allocations changes.
     /// The `AllocId` for globals is stable across executions, so we can use it as an identifier.
     global_allocations: GlobalAllocationHandler,
+
+    /// Cache for which warnings have already been shown to the user.
+    /// `None` if warnings are disabled.
+    warning_cache: Option<Warnings>,
 }
 
 impl GlobalState {
-    fn new(target_usize_max: u64) -> Self {
-        Self { global_allocations: GlobalAllocationHandler::new(target_usize_max) }
+    fn new(target_usize_max: u64, print_warnings: bool) -> Self {
+        Self {
+            global_allocations: GlobalAllocationHandler::new(target_usize_max),
+            warning_cache: print_warnings.then(Default::default),
+        }
     }
 }
 
@@ -348,21 +355,91 @@ impl GenmcCtx {
     /// `old_value` is the value that a non-atomic load would read here, or `None` if the memory is uninitalized.
     pub(crate) fn atomic_compare_exchange<'tcx>(
         &self,
-        _ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
-        _address: Size,
-        _size: Size,
-        _expected_old_value: Scalar,
-        _new_value: Scalar,
-        _success: AtomicRwOrd,
-        _fail: AtomicReadOrd,
-        _can_fail_spuriously: bool,
-        _old_value: Scalar,
+        ecx: &InterpCx<'tcx, MiriMachine<'tcx>>,
+        address: Size,
+        size: Size,
+        expected_old_value: Scalar,
+        new_value: Scalar,
+        success: AtomicRwOrd,
+        fail: AtomicReadOrd,
+        can_fail_spuriously: bool,
+        old_value: Scalar,
     ) -> InterpResult<'tcx, (Scalar, Option<Scalar>, bool)> {
         assert!(
             !self.get_alloc_data_races(),
             "atomic compare-exchange with data race checking disabled."
         );
-        throw_unsup_format!("FIXME(genmc): Add support for atomic compare_exchange.")
+        assert_ne!(0, size.bytes());
+        assert!(
+            size.bytes() <= MAX_ACCESS_SIZE,
+            "GenMC currently does not support atomic accesses larger than {} bytes (got {} bytes)",
+            MAX_ACCESS_SIZE,
+            size.bytes()
+        );
+
+        // Upgrade the success memory ordering to equal the failure ordering, since GenMC currently ignores the failure ordering.
+        // FIXME(genmc): remove this once GenMC properly supports the failure memory ordering.
+        let upgraded_success_ordering =
+            maybe_upgrade_compare_exchange_success_orderings(success, fail);
+
+        if let Some(warning_cache) = &self.global_state.warning_cache {
+            // FIXME(genmc): remove once GenMC supports failure memory ordering in `compare_exchange`.
+            let (effective_failure_ordering, _) =
+                upgraded_success_ordering.split_memory_orderings();
+            // Return a warning if the actual orderings don't match the upgraded ones.
+            if success != upgraded_success_ordering || effective_failure_ordering != fail {
+                emit_warning(ecx, &warning_cache.compare_exchange_failure_ordering, || {
+                    NonHaltingDiagnostic::GenmcCompareExchangeOrderingMismatch {
+                        success_ordering: success,
+                        upgraded_success_ordering,
+                        failure_ordering: fail,
+                        effective_failure_ordering,
+                    }
+                });
+            }
+            // FIXME(genmc): remove once GenMC implements spurious failures for `compare_exchange_weak`.
+            if can_fail_spuriously {
+                emit_warning(ecx, &warning_cache.compare_exchange_weak, || {
+                    NonHaltingDiagnostic::GenmcCompareExchangeWeak
+                });
+            }
+        }
+
+        debug!(
+            "GenMC: atomic_compare_exchange, address: {address:?}, size: {size:?} (expect: {expected_old_value:?}, new: {new_value:?}, old_value: {old_value:?}, {success:?}, orderings: {fail:?}), can fail spuriously: {can_fail_spuriously}"
+        );
+
+        let thread_infos = self.exec_state.thread_id_manager.borrow();
+        let genmc_tid = thread_infos.get_genmc_tid(ecx.machine.threads.active_thread());
+
+        let cas_result = self.handle.borrow_mut().pin_mut().handle_compare_exchange(
+            genmc_tid,
+            address.bytes(),
+            size.bytes(),
+            scalar_to_genmc_scalar(ecx, expected_old_value)?,
+            scalar_to_genmc_scalar(ecx, new_value)?,
+            scalar_to_genmc_scalar(ecx, old_value)?,
+            upgraded_success_ordering.to_genmc(),
+            fail.to_genmc(),
+            can_fail_spuriously,
+        );
+
+        if let Some(error) = cas_result.error.as_ref() {
+            // FIXME(genmc): error handling
+            throw_ub_format!("{}", error.to_string_lossy());
+        }
+
+        let return_scalar = genmc_scalar_to_scalar(ecx, cas_result.old_value, size)?;
+        debug!(
+            "GenMC: atomic_compare_exchange: result: {cas_result:?}, returning scalar: {return_scalar:?}"
+        );
+        // The write can only be a co-maximal write if the CAS succeeded.
+        assert!(cas_result.is_success || !cas_result.is_coherence_order_maximal_write);
+        interp_ok((
+            return_scalar,
+            cas_result.is_coherence_order_maximal_write.then_some(new_value),
+            cas_result.is_success,
+        ))
     }
 
     /// Inform GenMC about a non-atomic memory load
diff --git a/src/tools/miri/src/concurrency/genmc/run.rs b/src/tools/miri/src/concurrency/genmc/run.rs
index 24d13e6375b11..7e4ed816a76a1 100644
--- a/src/tools/miri/src/concurrency/genmc/run.rs
+++ b/src/tools/miri/src/concurrency/genmc/run.rs
@@ -23,7 +23,9 @@ pub fn run_genmc_mode<'tcx>(
     // There exists only one `global_state` per full run in GenMC mode.
     // It is shared by all `GenmcCtx` in this run.
     // FIXME(genmc): implement multithreading once GenMC supports it.
-    let global_state = Arc::new(GlobalState::new(tcx.target_usize_max()));
+    // FIXME(genmc): disable warnings in estimation mode once it is added.
+    let global_state =
+        Arc::new(GlobalState::new(tcx.target_usize_max(), /* print_warnings */ true));
     let genmc_ctx = Rc::new(GenmcCtx::new(config, global_state));
 
     // `rep` is used to report the progress, Miri will panic on wrap-around.
diff --git a/src/tools/miri/src/diagnostics.rs b/src/tools/miri/src/diagnostics.rs
index 0842307caf9ab..15f7ccbabca6a 100644
--- a/src/tools/miri/src/diagnostics.rs
+++ b/src/tools/miri/src/diagnostics.rs
@@ -141,6 +141,13 @@ pub enum NonHaltingDiagnostic {
         ptr: Pointer,
     },
     ExternTypeReborrow,
+    GenmcCompareExchangeWeak,
+    GenmcCompareExchangeOrderingMismatch {
+        success_ordering: AtomicRwOrd,
+        upgraded_success_ordering: AtomicRwOrd,
+        failure_ordering: AtomicReadOrd,
+        effective_failure_ordering: AtomicReadOrd,
+    },
 }
 
 /// Level of Miri specific diagnostics
@@ -637,6 +644,8 @@ impl<'tcx> MiriMachine<'tcx> {
                 ("sharing memory with a native function".to_string(), DiagLevel::Warning),
             ExternTypeReborrow =>
                 ("reborrow of reference to `extern type`".to_string(), DiagLevel::Warning),
+            GenmcCompareExchangeWeak | GenmcCompareExchangeOrderingMismatch { .. } =>
+                ("GenMC might miss possible behaviors of this code".to_string(), DiagLevel::Warning),
             CreatedPointerTag(..)
             | PoppedPointerTag(..)
             | CreatedAlloc(..)
@@ -675,6 +684,23 @@ impl<'tcx> MiriMachine<'tcx> {
                 format!("weak memory emulation: outdated value returned from load at {ptr}"),
             ExternTypeReborrow =>
                 format!("reborrow of a reference to `extern type` is not properly supported"),
+            GenmcCompareExchangeWeak =>
+                "GenMC currently does not model spurious failures of `compare_exchange_weak`. Miri with GenMC might miss bugs related to spurious failures."
+                    .to_string(),
+            GenmcCompareExchangeOrderingMismatch {
+                success_ordering,
+                upgraded_success_ordering,
+                failure_ordering,
+                effective_failure_ordering,
+            } => {
+                let was_upgraded_msg = if success_ordering != upgraded_success_ordering {
+                    format!("Success ordering '{success_ordering:?}' was upgraded to '{upgraded_success_ordering:?}' to match failure ordering '{failure_ordering:?}'")
+                } else {
+                    assert_ne!(failure_ordering, effective_failure_ordering);
+                    format!("Due to success ordering '{success_ordering:?}', the failure ordering '{failure_ordering:?}' is treated like '{effective_failure_ordering:?}'")
+                };
+                format!("GenMC currently does not model the failure ordering for `compare_exchange`. {was_upgraded_msg}. Miri with GenMC might miss bugs related to this memory access.")
+            }
         };
 
         let notes = match &e {
diff --git a/src/tools/miri/tests/genmc/fail/data_race/mpu2_rels_rlx.rs b/src/tools/miri/tests/genmc/fail/data_race/mpu2_rels_rlx.rs
new file mode 100644
index 0000000000000..32954a643b34b
--- /dev/null
+++ b/src/tools/miri/tests/genmc/fail/data_race/mpu2_rels_rlx.rs
@@ -0,0 +1,45 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's test `wrong/racy/MPU2+rels+rlx`.
+// Test if Miri with GenMC can detect the data race on `X`.
+// The data race only occurs if thread 1 finishes, then threads 3 and 4 run, then thread 2.
+//
+// This data race is hard to detect for Miri without GenMC, requiring -Zmiri-many-seeds=0..1024 at the time this test was created.
+
+// FIXME(genmc): once Miri-GenMC error reporting is improved, ensure that it correctly points to the two spans involved in the data race.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering::*;
+
+use genmc::spawn_pthread_closure;
+static mut X: u64 = 0;
+static Y: AtomicUsize = AtomicUsize::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    unsafe {
+        let _t1 = spawn_pthread_closure(|| {
+            X = 1;
+            Y.store(0, Release);
+            Y.store(1, Relaxed);
+        });
+        let _t2 = spawn_pthread_closure(|| {
+            if Y.load(Relaxed) > 2 {
+                X = 2; //~ ERROR: Undefined Behavior: Non-atomic race
+            }
+        });
+        let _t3 = spawn_pthread_closure(|| {
+            let _ = Y.compare_exchange(2, 3, Relaxed, Relaxed);
+        });
+
+        let _t4 = spawn_pthread_closure(|| {
+            let _ = Y.compare_exchange(1, 2, Relaxed, Relaxed);
+        });
+    }
+    0
+}
diff --git a/src/tools/miri/tests/genmc/fail/data_race/mpu2_rels_rlx.stderr b/src/tools/miri/tests/genmc/fail/data_race/mpu2_rels_rlx.stderr
new file mode 100644
index 0000000000000..946d9a2124b88
--- /dev/null
+++ b/src/tools/miri/tests/genmc/fail/data_race/mpu2_rels_rlx.stderr
@@ -0,0 +1,19 @@
+error: Undefined Behavior: Non-atomic race
+  --> tests/genmc/fail/data_race/mpu2_rels_rlx.rs:LL:CC
+   |
+LL |                 X = 2;
+   |                 ^^^^^ Undefined Behavior occurred here
+   |
+   = 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 tests/genmc/fail/data_race/mpu2_rels_rlx.rs:LL:CC
+   = note: inside `<std::boxed::Box<{closure@tests/genmc/fail/data_race/mpu2_rels_rlx.rs:LL:CC}> as std::ops::FnOnce<()>>::call_once` at RUSTLIB/alloc/src/boxed.rs:LL:CC
+note: inside `genmc::spawn_pthread_closure::thread_func::<{closure@tests/genmc/fail/data_race/mpu2_rels_rlx.rs:LL:CC}>`
+  --> tests/genmc/fail/data_race/../../../utils/genmc.rs:LL:CC
+   |
+LL |         f();
+   |         ^^^
+
+error: aborting due to 1 previous error
+
diff --git a/src/tools/miri/tests/genmc/fail/loom/store_buffering.genmc.stderr b/src/tools/miri/tests/genmc/fail/loom/store_buffering.genmc.stderr
new file mode 100644
index 0000000000000..a6c3ed7055e75
--- /dev/null
+++ b/src/tools/miri/tests/genmc/fail/loom/store_buffering.genmc.stderr
@@ -0,0 +1,13 @@
+error: abnormal termination: the program aborted execution
+  --> tests/genmc/fail/loom/store_buffering.rs:LL:CC
+   |
+LL |             std::process::abort();
+   |             ^^^^^^^^^^^^^^^^^^^^^ abnormal termination occurred here
+   |
+   = note: BACKTRACE:
+   = note: inside `miri_start` at tests/genmc/fail/loom/store_buffering.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/genmc/fail/loom/store_buffering.non_genmc.stderr b/src/tools/miri/tests/genmc/fail/loom/store_buffering.non_genmc.stderr
new file mode 100644
index 0000000000000..a6c3ed7055e75
--- /dev/null
+++ b/src/tools/miri/tests/genmc/fail/loom/store_buffering.non_genmc.stderr
@@ -0,0 +1,13 @@
+error: abnormal termination: the program aborted execution
+  --> tests/genmc/fail/loom/store_buffering.rs:LL:CC
+   |
+LL |             std::process::abort();
+   |             ^^^^^^^^^^^^^^^^^^^^^ abnormal termination occurred here
+   |
+   = note: BACKTRACE:
+   = note: inside `miri_start` at tests/genmc/fail/loom/store_buffering.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/genmc/fail/loom/store_buffering.rs b/src/tools/miri/tests/genmc/fail/loom/store_buffering.rs
new file mode 100644
index 0000000000000..4955dfd8a77ad
--- /dev/null
+++ b/src/tools/miri/tests/genmc/fail/loom/store_buffering.rs
@@ -0,0 +1,57 @@
+//@ revisions: non_genmc genmc
+//@[genmc] compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) 2019 Carl Lerche
+
+// This is the test `store_buffering` from `loom/test/litmus.rs`, adapted for Miri-GenMC.
+// https://github.com/tokio-rs/loom/blob/dbf32b04bae821c64be44405a0bb72ca08741558/tests/litmus.rs
+
+// This test shows the comparison between running Miri with or without GenMC.
+// Without GenMC, Miri requires multiple iterations of the loop to detect the error.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    // For normal Miri, we need multiple repetitions, but GenMC should find the bug with only 1.
+    const REPS: usize = if cfg!(non_genmc) { 128 } else { 1 };
+    for _ in 0..REPS {
+        // New atomics every iterations, so they don't influence each other.
+        let x = AtomicUsize::new(0);
+        let y = AtomicUsize::new(0);
+
+        // FIXME(genmc,HACK): remove these initializing writes once Miri-GenMC supports mixed atomic-non-atomic accesses.
+        x.store(0, Relaxed);
+        y.store(0, Relaxed);
+
+        let mut a: usize = 1234;
+        let mut b: usize = 1234;
+        unsafe {
+            let ids = [
+                spawn_pthread_closure(|| {
+                    x.store(1, Relaxed);
+                    a = y.load(Relaxed)
+                }),
+                spawn_pthread_closure(|| {
+                    y.store(1, Relaxed);
+                    b = x.load(Relaxed)
+                }),
+            ];
+            join_pthreads(ids);
+        }
+        if (a, b) == (0, 0) {
+            std::process::abort(); //~ ERROR: abnormal termination
+        }
+    }
+
+    0
+}
diff --git a/src/tools/miri/tests/genmc/pass/atomics/cas_failure_ord_racy_key_init.rs b/src/tools/miri/tests/genmc/pass/atomics/cas_failure_ord_racy_key_init.rs
new file mode 100644
index 0000000000000..8a77d54a64f8b
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/atomics/cas_failure_ord_racy_key_init.rs
@@ -0,0 +1,70 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows -Zmiri-ignore-leaks
+
+// Adapted from: `impl LazyKey`, `fn lazy_init`: rust/library/std/src/sys/thread_local/key/racy.rs
+// Two threads race to initialize a key, which is just an index into an array in this test.
+// The (Acquire, Release) orderings on the compare_exchange prevent any data races for reading from `VALUES[key]`.
+
+// FIXME(genmc): GenMC does not model the failure ordering of compare_exchange currently.
+// Miri thus upgrades the success ordering to prevent showing any false data races in cases like this one.
+// Once GenMC supports the failure ordering, this test should work without the upgrading.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+const KEY_SENTVAL: usize = usize::MAX;
+
+static KEY: AtomicUsize = AtomicUsize::new(KEY_SENTVAL);
+
+static mut VALUES: [usize; 2] = [0, 0];
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    // FIXME(genmc,HACK): remove this initializing write once Miri-GenMC supports mixed atomic-non-atomic accesses.
+    KEY.store(KEY_SENTVAL, Relaxed);
+
+    unsafe {
+        let mut a = 0;
+        let mut b = 0;
+        let ids = [
+            spawn_pthread_closure(|| {
+                VALUES[0] = 42;
+                let key = get_or_init(0);
+                if key > 2 {
+                    std::process::abort();
+                }
+                a = VALUES[key];
+            }),
+            spawn_pthread_closure(|| {
+                VALUES[1] = 1234;
+                let key = get_or_init(1);
+                if key > 2 {
+                    std::process::abort();
+                }
+                b = VALUES[key];
+            }),
+        ];
+        join_pthreads(ids);
+        if a != b {
+            std::process::abort();
+        }
+    }
+    0
+}
+
+fn get_or_init(key: usize) -> usize {
+    match KEY.compare_exchange(KEY_SENTVAL, key, Release, Acquire) {
+        // The CAS succeeded, so we've created the actual key.
+        Ok(_) => key,
+        // If someone beat us to the punch, use their key instead.
+        // The `Acquire` failure ordering means we synchronized with the `Release` compare_exchange in the thread that wrote the other key.
+        // We can thus read from `VALUES[other_key]` without a data race.
+        Err(other_key) => other_key,
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/atomics/cas_failure_ord_racy_key_init.stderr b/src/tools/miri/tests/genmc/pass/atomics/cas_failure_ord_racy_key_init.stderr
new file mode 100644
index 0000000000000..d97b8b3d92f48
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/atomics/cas_failure_ord_racy_key_init.stderr
@@ -0,0 +1,22 @@
+warning: GenMC currently does not model the failure ordering for `compare_exchange`. Success ordering 'Release' was upgraded to 'AcqRel' to match failure ordering 'Acquire'. Miri with GenMC might miss bugs related to this memory access.
+  --> tests/genmc/pass/atomics/cas_failure_ord_racy_key_init.rs:LL:CC
+   |
+LL |     match KEY.compare_exchange(KEY_SENTVAL, key, Release, Acquire) {
+   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ GenMC might miss possible behaviors of this code
+   |
+   = note: BACKTRACE on thread `unnamed-ID`:
+   = note: inside `get_or_init` at tests/genmc/pass/atomics/cas_failure_ord_racy_key_init.rs:LL:CC
+note: inside closure
+  --> tests/genmc/pass/atomics/cas_failure_ord_racy_key_init.rs:LL:CC
+   |
+LL |                 let key = get_or_init(0);
+   |                           ^^^^^^^^^^^^^^
+   = note: inside `<std::boxed::Box<{closure@tests/genmc/pass/atomics/cas_failure_ord_racy_key_init.rs:LL:CC}> as std::ops::FnOnce<()>>::call_once` at RUSTLIB/alloc/src/boxed.rs:LL:CC
+note: inside `genmc::spawn_pthread_closure::thread_func::<{closure@tests/genmc/pass/atomics/cas_failure_ord_racy_key_init.rs:LL:CC}>`
+  --> tests/genmc/pass/atomics/../../../utils/genmc.rs:LL:CC
+   |
+LL |         f();
+   |         ^^^
+
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 2
diff --git a/src/tools/miri/tests/genmc/pass/atomics/cas_simple.rs b/src/tools/miri/tests/genmc/pass/atomics/cas_simple.rs
new file mode 100644
index 0000000000000..e32c7cdf80c43
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/atomics/cas_simple.rs
@@ -0,0 +1,34 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Test the basic functionality of compare_exchange.
+
+#![no_main]
+
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering::*;
+
+static VALUE: AtomicUsize = AtomicUsize::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    VALUE.store(1, SeqCst);
+
+    // Expect success:
+    if VALUE.compare_exchange(1, 2, SeqCst, SeqCst) != Ok(1) {
+        std::process::abort();
+    }
+    // New value should be written:
+    if 2 != VALUE.load(SeqCst) {
+        std::process::abort()
+    }
+
+    // Expect failure:
+    if VALUE.compare_exchange(1234, 42, SeqCst, SeqCst) != Err(2) {
+        std::process::abort();
+    }
+    // Value should be unchanged:
+    if 2 != VALUE.load(SeqCst) {
+        std::process::abort()
+    }
+    0
+}
diff --git a/src/tools/miri/tests/genmc/pass/atomics/cas_simple.stderr b/src/tools/miri/tests/genmc/pass/atomics/cas_simple.stderr
new file mode 100644
index 0000000000000..3b22247ee44cb
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/atomics/cas_simple.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 1
diff --git a/src/tools/miri/tests/genmc/pass/litmus/IRIWish.rs b/src/tools/miri/tests/genmc/pass/litmus/IRIWish.rs
index 163556dcc8975..c81573d59d1da 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/IRIWish.rs
+++ b/src/tools/miri/tests/genmc/pass/litmus/IRIWish.rs
@@ -57,9 +57,7 @@ fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
         join_pthreads(ids);
 
         // Print the values to check that we get all of them:
-        if writeln!(MiriStderr, "{results:?}").is_err() {
-            std::process::abort();
-        }
+        writeln!(MiriStderr, "{results:?}").unwrap_or_else(|_| std::process::abort());
 
         0
     }
diff --git a/src/tools/miri/tests/genmc/pass/litmus/MPU2_rels_acqf.rs b/src/tools/miri/tests/genmc/pass/litmus/MPU2_rels_acqf.rs
new file mode 100644
index 0000000000000..9bb156a99970f
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/MPU2_rels_acqf.rs
@@ -0,0 +1,67 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's "litmus/MPU2+rels+acqf" test.
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+#[path = "../../../utils/mod.rs"]
+mod utils;
+
+use std::fmt::Write;
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+use crate::utils::*;
+
+// Note: the GenMC equivalent of this test (genmc/tests/correct/litmus/MPU2+rels+acqf/mpu2+rels+acqf.c) uses non-atomic accesses for `X` with disabled race detection.
+static X: AtomicU64 = AtomicU64::new(0);
+static Y: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    // FIXME(genmc,HACK): remove these initializing writes once Miri-GenMC supports mixed atomic-non-atomic accesses.
+    X.store(0, Relaxed);
+    Y.store(0, Relaxed);
+
+    unsafe {
+        let mut a = Ok(1234);
+        let mut b = Ok(1234);
+        let mut c = 1234;
+        let ids = [
+            spawn_pthread_closure(|| {
+                X.store(1, Relaxed);
+
+                Y.store(0, Release);
+                Y.store(1, Relaxed);
+            }),
+            spawn_pthread_closure(|| {
+                a = Y.compare_exchange(2, 3, Relaxed, Relaxed);
+            }),
+            spawn_pthread_closure(|| {
+                b = Y.compare_exchange(1, 2, Relaxed, Relaxed);
+            }),
+            spawn_pthread_closure(|| {
+                c = Y.load(Acquire);
+                if c > 2 {
+                    std::sync::atomic::fence(Acquire);
+                    X.store(2, Relaxed);
+                }
+            }),
+        ];
+        join_pthreads(ids);
+
+        // Print the values to check that we get all of them:
+        writeln!(
+            MiriStderr,
+            "X={}, Y={}, a={a:?}, b={b:?}, c={c}",
+            X.load(Relaxed),
+            Y.load(Relaxed)
+        )
+        .unwrap_or_else(|_| std::process::abort());
+
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/MPU2_rels_acqf.stderr b/src/tools/miri/tests/genmc/pass/litmus/MPU2_rels_acqf.stderr
new file mode 100644
index 0000000000000..4551c00b0575d
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/MPU2_rels_acqf.stderr
@@ -0,0 +1,38 @@
+X=1, Y=2, a=Err(1), b=Ok(1), c=2
+X=1, Y=2, a=Err(1), b=Ok(1), c=1
+X=1, Y=2, a=Err(1), b=Ok(1), c=0
+X=1, Y=2, a=Err(1), b=Ok(1), c=0
+X=2, Y=3, a=Ok(2), b=Ok(1), c=3
+X=1, Y=3, a=Ok(2), b=Ok(1), c=3
+X=1, Y=3, a=Ok(2), b=Ok(1), c=2
+X=1, Y=3, a=Ok(2), b=Ok(1), c=1
+X=1, Y=3, a=Ok(2), b=Ok(1), c=0
+X=1, Y=3, a=Ok(2), b=Ok(1), c=0
+X=1, Y=1, a=Err(1), b=Err(0), c=1
+X=1, Y=1, a=Err(1), b=Err(0), c=0
+X=1, Y=1, a=Err(1), b=Err(0), c=0
+X=1, Y=1, a=Err(1), b=Err(0), c=1
+X=1, Y=1, a=Err(1), b=Err(0), c=0
+X=1, Y=1, a=Err(1), b=Err(0), c=0
+X=1, Y=2, a=Err(0), b=Ok(1), c=2
+X=1, Y=2, a=Err(0), b=Ok(1), c=1
+X=1, Y=2, a=Err(0), b=Ok(1), c=0
+X=1, Y=2, a=Err(0), b=Ok(1), c=0
+X=1, Y=1, a=Err(0), b=Err(0), c=1
+X=1, Y=1, a=Err(0), b=Err(0), c=0
+X=1, Y=1, a=Err(0), b=Err(0), c=0
+X=1, Y=1, a=Err(0), b=Err(0), c=1
+X=1, Y=1, a=Err(0), b=Err(0), c=0
+X=1, Y=1, a=Err(0), b=Err(0), c=0
+X=1, Y=2, a=Err(0), b=Ok(1), c=2
+X=1, Y=2, a=Err(0), b=Ok(1), c=1
+X=1, Y=2, a=Err(0), b=Ok(1), c=0
+X=1, Y=2, a=Err(0), b=Ok(1), c=0
+X=1, Y=1, a=Err(0), b=Err(0), c=1
+X=1, Y=1, a=Err(0), b=Err(0), c=0
+X=1, Y=1, a=Err(0), b=Err(0), c=0
+X=1, Y=1, a=Err(0), b=Err(0), c=1
+X=1, Y=1, a=Err(0), b=Err(0), c=0
+X=1, Y=1, a=Err(0), b=Err(0), c=0
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 36
diff --git a/src/tools/miri/tests/genmc/pass/litmus/Z6_U.rs b/src/tools/miri/tests/genmc/pass/litmus/Z6_U.rs
index ac5c3724254d6..f96679b23a5cd 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/Z6_U.rs
+++ b/src/tools/miri/tests/genmc/pass/litmus/Z6_U.rs
@@ -55,11 +55,8 @@ fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
         join_pthreads(ids);
 
         // Print the values to check that we get all of them:
-        if writeln!(MiriStderr, "a={a}, b={b}, X={}, Y={}", X.load(Relaxed), Y.load(Relaxed))
-            .is_err()
-        {
-            std::process::abort();
-        }
+        writeln!(MiriStderr, "a={a}, b={b}, X={}, Y={}", X.load(Relaxed), Y.load(Relaxed))
+            .unwrap_or_else(|_| std::process::abort());
         0
     }
 }
diff --git a/src/tools/miri/tests/genmc/pass/litmus/casdep.rs b/src/tools/miri/tests/genmc/pass/litmus/casdep.rs
new file mode 100644
index 0000000000000..c376d96b111cc
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/casdep.rs
@@ -0,0 +1,37 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's test "litmus/casdep".
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+static Y: AtomicU64 = AtomicU64::new(0);
+static Z: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    // FIXME(genmc,HACK): remove these initializing writes once Miri-GenMC supports mixed atomic-non-atomic accesses.
+    X.store(0, Relaxed);
+    Y.store(0, Relaxed);
+    Z.store(0, Relaxed);
+
+    unsafe {
+        spawn_pthread_closure(|| {
+            let a = X.load(Relaxed);
+            let _b = Y.compare_exchange(a, 1, Relaxed, Relaxed);
+            Z.store(a, Relaxed);
+        });
+        spawn_pthread_closure(|| {
+            Y.store(2, Relaxed);
+        });
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/casdep.stderr b/src/tools/miri/tests/genmc/pass/litmus/casdep.stderr
new file mode 100644
index 0000000000000..01701dfe6918a
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/casdep.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 2
diff --git a/src/tools/miri/tests/genmc/pass/litmus/ccr.rs b/src/tools/miri/tests/genmc/pass/litmus/ccr.rs
new file mode 100644
index 0000000000000..865895b4dcd96
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/ccr.rs
@@ -0,0 +1,34 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's test "litmus/ccr".
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    // FIXME(genmc,HACK): remove this initializing write once Miri-GenMC supports mixed atomic-non-atomic accesses.
+    X.store(0, Relaxed);
+
+    unsafe {
+        spawn_pthread_closure(|| {
+            let expected = 0;
+            let _ = X.compare_exchange(expected, 42, Relaxed, Relaxed);
+        });
+        spawn_pthread_closure(|| {
+            let expected = 0;
+            let _ = X.compare_exchange(expected, 17, Relaxed, Relaxed);
+            X.load(Relaxed);
+        });
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/ccr.stderr b/src/tools/miri/tests/genmc/pass/litmus/ccr.stderr
new file mode 100644
index 0000000000000..01701dfe6918a
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/ccr.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 2
diff --git a/src/tools/miri/tests/genmc/pass/litmus/cii.rs b/src/tools/miri/tests/genmc/pass/litmus/cii.rs
new file mode 100644
index 0000000000000..663c806e667c4
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/cii.rs
@@ -0,0 +1,35 @@
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+
+// Translated from GenMC's test "litmus/cii".
+
+#![no_main]
+
+#[path = "../../../utils/genmc.rs"]
+mod genmc;
+
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering::*;
+
+use crate::genmc::*;
+
+static X: AtomicU64 = AtomicU64::new(0);
+
+#[unsafe(no_mangle)]
+fn miri_start(_argc: isize, _argv: *const *const u8) -> isize {
+    // FIXME(genmc,HACK): remove this initializing write once Miri-GenMC supports mixed atomic-non-atomic accesses.
+    X.store(0, Relaxed);
+
+    unsafe {
+        spawn_pthread_closure(|| {
+            let expected = 1;
+            let _ = X.compare_exchange(expected, 2, Relaxed, Relaxed);
+        });
+        spawn_pthread_closure(|| {
+            X.fetch_add(1, Relaxed);
+        });
+        spawn_pthread_closure(|| {
+            X.fetch_add(1, Relaxed);
+        });
+        0
+    }
+}
diff --git a/src/tools/miri/tests/genmc/pass/litmus/cii.stderr b/src/tools/miri/tests/genmc/pass/litmus/cii.stderr
new file mode 100644
index 0000000000000..be75e68fde77d
--- /dev/null
+++ b/src/tools/miri/tests/genmc/pass/litmus/cii.stderr
@@ -0,0 +1,2 @@
+(GenMC) Verification complete. No errors were detected.
+Number of complete executions explored: 6

From 18059a0053d186ab47cde823dff64fe490bfbed0 Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Thu, 11 Sep 2025 15:11:25 -0500
Subject: [PATCH 0849/1889] Improve `core::alloc` coverage

---
 library/coretests/tests/alloc.rs | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/library/coretests/tests/alloc.rs b/library/coretests/tests/alloc.rs
index 72fdf82c1f8cf..a4af6fd32a11d 100644
--- a/library/coretests/tests/alloc.rs
+++ b/library/coretests/tests/alloc.rs
@@ -55,6 +55,30 @@ fn layout_array_edge_cases() {
     }
 }
 
+#[test]
+fn layout_errors() {
+    let layout = Layout::new::<[u8; 2]>();
+    // Should error if the alignment is not a power of two.
+    assert!(layout.align_to(3).is_err());
+
+    // The remaining assertions ensure that the methods error on arithmetic overflow as the
+    // alignment cannot overflow `isize`.
+    let size = layout.size();
+    let size_max = isize::MAX as usize;
+    let align_max = size_max / size;
+
+    assert!(layout.align_to(size_max + 1).is_err());
+
+    assert!(layout.repeat(align_max).is_ok());
+    assert!(layout.repeat(align_max + 1).is_err());
+
+    assert!(layout.repeat_packed(align_max).is_ok());
+    assert!(layout.repeat_packed(align_max + 1).is_err());
+
+    let next = Layout::from_size_align(size_max, 1).unwrap();
+    assert!(layout.extend(next).is_err());
+}
+
 #[test]
 fn layout_debug_shows_log2_of_alignment() {
     // `Debug` is not stable, but here's what it does right now

From 68a3adad2ae1a979b29325b434967e1801145d42 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sat, 16 Aug 2025 21:27:05 +0200
Subject: [PATCH 0850/1889] other clean-up

---
 .../src/functions/not_unsafe_ptr_arg_deref.rs |  4 ++--
 clippy_lints/src/matches/manual_utils.rs      |  4 ++--
 clippy_utils/src/ty/mod.rs                    | 23 ++++++++-----------
 3 files changed, 13 insertions(+), 18 deletions(-)

diff --git a/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs b/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
index 906bbd006d463..72f8795304055 100644
--- a/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
+++ b/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
@@ -4,7 +4,7 @@ use rustc_middle::ty;
 use rustc_span::def_id::LocalDefId;
 
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::ty::type_is_unsafe_function;
+use clippy_utils::ty::is_unsafe_fn;
 use clippy_utils::visitors::for_each_expr;
 use clippy_utils::{iter_input_pats, path_to_local};
 
@@ -51,7 +51,7 @@ fn check_raw_ptr<'tcx>(
             let typeck = cx.tcx.typeck_body(body.id());
             let _: Option<!> = for_each_expr(cx, body.value, |e| {
                 match e.kind {
-                    hir::ExprKind::Call(f, args) if type_is_unsafe_function(cx, typeck.expr_ty(f)) => {
+                    hir::ExprKind::Call(f, args) if is_unsafe_fn(cx, typeck.expr_ty(f)) => {
                         for arg in args {
                             check_arg(cx, &raw_ptrs, arg);
                         }
diff --git a/clippy_lints/src/matches/manual_utils.rs b/clippy_lints/src/matches/manual_utils.rs
index dbae71bbb1b06..c5cb1ce1b3fd2 100644
--- a/clippy_lints/src/matches/manual_utils.rs
+++ b/clippy_lints/src/matches/manual_utils.rs
@@ -2,7 +2,7 @@ use crate::map_unit_fn::OPTION_MAP_UNIT_FN;
 use crate::matches::MATCH_AS_REF;
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::{is_copy, is_type_diagnostic_item, peel_mid_ty_refs_is_mutable, type_is_unsafe_function};
+use clippy_utils::ty::{is_copy, is_type_diagnostic_item, is_unsafe_fn, peel_mid_ty_refs_is_mutable};
 use clippy_utils::{
     CaptureKind, can_move_expr_to_closure, expr_requires_coercion, is_else_clause, is_lint_allowed, is_res_lang_ctor,
     path_res, path_to_local_id, peel_blocks, peel_hir_expr_refs, peel_hir_expr_while,
@@ -191,7 +191,7 @@ fn can_pass_as_func<'tcx>(cx: &LateContext<'tcx>, binding: HirId, expr: &'tcx Ex
         ExprKind::Call(func, [arg])
             if path_to_local_id(arg, binding)
                 && cx.typeck_results().expr_adjustments(arg).is_empty()
-                && !type_is_unsafe_function(cx, cx.typeck_results().expr_ty(func).peel_refs()) =>
+                && !is_unsafe_fn(cx, cx.typeck_results().expr_ty(func).peel_refs()) =>
         {
             Some(func)
         },
diff --git a/clippy_utils/src/ty/mod.rs b/clippy_utils/src/ty/mod.rs
index 8e302f9d2ad12..ae6a4ae7fb2d6 100644
--- a/clippy_utils/src/ty/mod.rs
+++ b/clippy_utils/src/ty/mod.rs
@@ -43,13 +43,8 @@ pub use type_certainty::expr_type_is_certain;
 /// Lower a [`hir::Ty`] to a [`rustc_middle::ty::Ty`].
 pub fn ty_from_hir_ty<'tcx>(cx: &LateContext<'tcx>, hir_ty: &hir::Ty<'tcx>) -> Ty<'tcx> {
     cx.maybe_typeck_results()
-        .and_then(|results| {
-            if results.hir_owner == hir_ty.hir_id.owner {
-                results.node_type_opt(hir_ty.hir_id)
-            } else {
-                None
-            }
-        })
+        .filter(|results| results.hir_owner == hir_ty.hir_id.owner)
+        .and_then(|results| results.node_type_opt(hir_ty.hir_id))
         .unwrap_or_else(|| lower_ty(cx.tcx, hir_ty))
 }
 
@@ -475,6 +470,11 @@ pub fn needs_ordered_drop<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
     needs_ordered_drop_inner(cx, ty, &mut FxHashSet::default())
 }
 
+/// Returns `true` if `ty` denotes an `unsafe fn`.
+pub fn is_unsafe_fn<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+    ty.is_fn() && ty.fn_sig(cx.tcx).safety().is_unsafe()
+}
+
 /// 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) {
@@ -488,15 +488,10 @@ pub fn peel_mid_ty_refs_is_mutable(ty: Ty<'_>) -> (Ty<'_>, usize, Mutability) {
     f(ty, 0, Mutability::Mut)
 }
 
-/// Returns `true` if the given type is an `unsafe` function.
-pub fn type_is_unsafe_function<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-    ty.is_fn() && ty.fn_sig(cx.tcx).safety().is_unsafe()
-}
-
 /// Returns the base type for HIR references and pointers.
 pub fn walk_ptrs_hir_ty<'tcx>(ty: &'tcx hir::Ty<'tcx>) -> &'tcx hir::Ty<'tcx> {
-    match ty.kind {
-        TyKind::Ptr(ref mut_ty) | TyKind::Ref(_, ref mut_ty) => walk_ptrs_hir_ty(mut_ty.ty),
+    match &ty.kind {
+        TyKind::Ptr(mut_ty) | TyKind::Ref(_, mut_ty) => walk_ptrs_hir_ty(mut_ty.ty),
         _ => ty,
     }
 }

From 31c7e621c2067808f2a93942073e55971e4e9c3f Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sat, 16 Aug 2025 21:36:38 +0200
Subject: [PATCH 0851/1889] reorganize `peel_*_ty_refs` functions

- give `ty::walk_ptrs_hir_ty` a more standard name
  `peel_hir_ty_refs_and_ptrs`
- move it out of `ty`, since that's for `middle::ty::Ty`

- remove `ty::walk_ptrs_ty_depth` for equivalent `peel_middle_ty_refs`
- rename the latter into `ty::peel_and_count_ty_refs`
- incorporate mutability tracking (from
  `ty::peel_mid_ty_refs_is_mutable`) into that
---
 clippy_lints/src/dereference.rs               |  7 ++--
 clippy_lints/src/manual_abs_diff.rs           |  6 +--
 .../src/manual_slice_size_calculation.rs      |  3 +-
 clippy_lints/src/matches/manual_ok_err.rs     | 16 +++-----
 clippy_lints/src/matches/manual_utils.rs      |  7 ++--
 clippy_lints/src/matches/single_match.rs      |  8 ++--
 clippy_lints/src/methods/implicit_clone.rs    |  6 +--
 .../src/methods/inefficient_to_string.rs      |  4 +-
 clippy_lints/src/methods/mut_mutex_lock.rs    |  5 +--
 .../src/methods/unnecessary_to_owned.rs       | 13 +++---
 clippy_lints/src/methods/useless_asref.rs     |  6 +--
 clippy_lints/src/redundant_clone.rs           |  4 +-
 clippy_lints/src/redundant_slicing.rs         |  8 ++--
 clippy_lints/src/size_of_ref.rs               |  5 ++-
 clippy_lints/src/unused_peekable.rs           |  6 +--
 clippy_utils/src/lib.rs                       | 13 +++---
 clippy_utils/src/ty/mod.rs                    | 41 +++++--------------
 17 files changed, 66 insertions(+), 92 deletions(-)

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 9aa2f3cf0a5b7..9337816c80d9d 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1,10 +1,9 @@
 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::{adjust_derefs_manually_drop, implements_trait, is_manually_drop};
+use clippy_utils::ty::{adjust_derefs_manually_drop, implements_trait, is_manually_drop, peel_and_count_ty_refs};
 use clippy_utils::{
     DefinedTy, ExprUseNode, expr_use_ctxt, get_parent_expr, is_block_like, is_lint_allowed, path_to_local,
-    peel_middle_ty_refs,
 };
 use rustc_ast::util::parser::ExprPrecedence;
 use rustc_data_structures::fx::FxIndexMap;
@@ -942,7 +941,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_middle_ty_refs(ty);
+            let (_, ref_count, _) = peel_and_count_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.
@@ -1045,7 +1044,7 @@ fn report<'tcx>(
             if let ty::Ref(_, dst, _) = data.adjusted_ty.kind()
                 && dst.is_slice()
             {
-                let (src, n_src_refs) = peel_middle_ty_refs(ty);
+                let (src, n_src_refs, _) = peel_and_count_ty_refs(ty);
                 if n_src_refs >= 2 && src.is_array() {
                     return;
                 }
diff --git a/clippy_lints/src/manual_abs_diff.rs b/clippy_lints/src/manual_abs_diff.rs
index 288f27db8ca2c..5814b6815a1ea 100644
--- a/clippy_lints/src/manual_abs_diff.rs
+++ b/clippy_lints/src/manual_abs_diff.rs
@@ -4,8 +4,8 @@ use clippy_utils::higher::If;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::HasSession as _;
 use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{eq_expr_value, peel_blocks, peel_middle_ty_refs, span_contains_comment};
+use clippy_utils::ty::{is_type_diagnostic_item, peel_and_count_ty_refs};
+use clippy_utils::{eq_expr_value, peel_blocks, span_contains_comment};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -107,7 +107,7 @@ impl ManualAbsDiff {
             |ty| is_type_diagnostic_item(cx, ty, sym::Duration) && self.msrv.meets(cx, msrvs::DURATION_ABS_DIFF);
 
         let a_ty = cx.typeck_results().expr_ty(a).peel_refs();
-        let (b_ty, b_n_refs) = peel_middle_ty_refs(cx.typeck_results().expr_ty(b));
+        let (b_ty, b_n_refs, _) = peel_and_count_ty_refs(cx.typeck_results().expr_ty(b));
 
         (a_ty == b_ty && (is_int(a_ty) || is_duration(a_ty))).then_some((a_ty, b_n_refs))
     }
diff --git a/clippy_lints/src/manual_slice_size_calculation.rs b/clippy_lints/src/manual_slice_size_calculation.rs
index 0c09a47c96518..de12fa29d02cd 100644
--- a/clippy_lints/src/manual_slice_size_calculation.rs
+++ b/clippy_lints/src/manual_slice_size_calculation.rs
@@ -2,6 +2,7 @@ use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_context;
+use clippy_utils::ty::peel_and_count_ty_refs;
 use clippy_utils::{expr_or_init, is_in_const_context, std_or_core};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
@@ -102,7 +103,7 @@ fn simplify_half<'tcx>(
         && let ExprKind::MethodCall(method_path, receiver, [], _) = expr1.kind
         && method_path.ident.name == sym::len
         && let receiver_ty = cx.typeck_results().expr_ty(receiver)
-        && let (receiver_ty, refs_count) = clippy_utils::ty::walk_ptrs_ty_depth(receiver_ty)
+        && let (receiver_ty, refs_count, _) = peel_and_count_ty_refs(receiver_ty)
         && let ty::Slice(ty1) = receiver_ty.kind()
         // expr2 is `size_of::<T2>()`?
         && let ExprKind::Call(func, []) = expr2.kind
diff --git a/clippy_lints/src/matches/manual_ok_err.rs b/clippy_lints/src/matches/manual_ok_err.rs
index edbb556fd9766..a8490d6aa7d82 100644
--- a/clippy_lints/src/matches/manual_ok_err.rs
+++ b/clippy_lints/src/matches/manual_ok_err.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{indent_of, reindent_multiline};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::{option_arg_ty, peel_mid_ty_refs_is_mutable};
+use clippy_utils::ty::{option_arg_ty, peel_and_count_ty_refs};
 use clippy_utils::{get_parent_expr, is_res_lang_ctor, path_res, peel_blocks, span_contains_comment};
 use rustc_ast::{BindingMode, Mutability};
 use rustc_errors::Applicability;
@@ -135,15 +135,11 @@ fn apply_lint(cx: &LateContext<'_>, expr: &Expr<'_>, scrutinee: &Expr<'_>, is_ok
     let scrut = Sugg::hir_with_applicability(cx, scrutinee, "..", &mut app).maybe_paren();
 
     let scrutinee_ty = cx.typeck_results().expr_ty(scrutinee);
-    let (_, n_ref, mutability) = peel_mid_ty_refs_is_mutable(scrutinee_ty);
-    let prefix = if n_ref > 0 {
-        if mutability == Mutability::Mut {
-            ".as_mut()"
-        } else {
-            ".as_ref()"
-        }
-    } else {
-        ""
+    let (_, _, mutability) = peel_and_count_ty_refs(scrutinee_ty);
+    let prefix = match mutability {
+        Some(Mutability::Mut) => ".as_mut()",
+        Some(Mutability::Not) => ".as_ref()",
+        None => "",
     };
 
     let sugg = format!("{scrut}{prefix}.{method}()");
diff --git a/clippy_lints/src/matches/manual_utils.rs b/clippy_lints/src/matches/manual_utils.rs
index c5cb1ce1b3fd2..d4bfdb7e440d8 100644
--- a/clippy_lints/src/matches/manual_utils.rs
+++ b/clippy_lints/src/matches/manual_utils.rs
@@ -2,7 +2,7 @@ use crate::map_unit_fn::OPTION_MAP_UNIT_FN;
 use crate::matches::MATCH_AS_REF;
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::{is_copy, is_type_diagnostic_item, is_unsafe_fn, peel_mid_ty_refs_is_mutable};
+use clippy_utils::ty::{is_copy, is_type_diagnostic_item, is_unsafe_fn, peel_and_count_ty_refs};
 use clippy_utils::{
     CaptureKind, can_move_expr_to_closure, expr_requires_coercion, is_else_clause, is_lint_allowed, is_res_lang_ctor,
     path_res, path_to_local_id, peel_blocks, peel_hir_expr_refs, peel_hir_expr_while,
@@ -30,8 +30,9 @@ pub(super) fn check_with<'tcx, F>(
 where
     F: Fn(&LateContext<'tcx>, &'tcx Pat<'_>, &'tcx Expr<'_>, SyntaxContext) -> Option<SomeExpr<'tcx>>,
 {
-    let (scrutinee_ty, ty_ref_count, ty_mutability) =
-        peel_mid_ty_refs_is_mutable(cx.typeck_results().expr_ty(scrutinee));
+    let (scrutinee_ty, ty_ref_count, ty_mutability) = peel_and_count_ty_refs(cx.typeck_results().expr_ty(scrutinee));
+    let ty_mutability = ty_mutability.unwrap_or(Mutability::Mut);
+
     if !(is_type_diagnostic_item(cx, scrutinee_ty, sym::Option)
         && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::Option))
     {
diff --git a/clippy_lints/src/matches/single_match.rs b/clippy_lints/src/matches/single_match.rs
index bcf079b700703..83939d325794e 100644
--- a/clippy_lints/src/matches/single_match.rs
+++ b/clippy_lints/src/matches/single_match.rs
@@ -2,10 +2,8 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::{
     SpanRangeExt, expr_block, snippet, snippet_block_with_context, snippet_with_applicability, snippet_with_context,
 };
-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 clippy_utils::ty::{implements_trait, peel_and_count_ty_refs};
+use clippy_utils::{is_lint_allowed, is_unit_expr, peel_blocks, peel_hir_pat_refs, peel_n_hir_expr_refs};
 use core::ops::ControlFlow;
 use rustc_arena::DroplessArena;
 use rustc_errors::{Applicability, Diag};
@@ -133,7 +131,7 @@ fn report_single_pattern(
 
     let (pat, pat_ref_count) = peel_hir_pat_refs(arm.pat);
     let (msg, sugg) = if let PatKind::Expr(_) = pat.kind
-        && let (ty, ty_ref_count) = peel_middle_ty_refs(cx.typeck_results().expr_ty(ex))
+        && let (ty, ty_ref_count, _) = peel_and_count_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()
diff --git a/clippy_lints/src/methods/implicit_clone.rs b/clippy_lints/src/methods/implicit_clone.rs
index 8a976d1b4dc00..0ba84919395cc 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;
-use clippy_utils::{is_diag_item_method, is_diag_trait_item, peel_middle_ty_refs, sym};
+use clippy_utils::ty::{implements_trait, peel_and_count_ty_refs};
+use clippy_utils::{is_diag_item_method, is_diag_trait_item, sym};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -14,7 +14,7 @@ pub fn check(cx: &LateContext<'_>, method_name: Symbol, expr: &hir::Expr<'_>, re
         && 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_middle_ty_refs(input_type)
+        && let (input_type, ref_count, _) = peel_and_count_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/inefficient_to_string.rs b/clippy_lints/src/methods/inefficient_to_string.rs
index 4ed7de81ea3d0..47195fdd65f5f 100644
--- a/clippy_lints/src/methods/inefficient_to_string.rs
+++ b/clippy_lints/src/methods/inefficient_to_string.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::{is_type_lang_item, walk_ptrs_ty_depth};
+use clippy_utils::ty::{is_type_lang_item, peel_and_count_ty_refs};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -24,7 +24,7 @@ pub fn check(
         && let Some(args) = cx.typeck_results().node_args_opt(expr.hir_id)
         && let arg_ty = cx.typeck_results().expr_ty_adjusted(receiver)
         && let self_ty = args.type_at(0)
-        && let (deref_self_ty, deref_count) = walk_ptrs_ty_depth(self_ty)
+        && let (deref_self_ty, deref_count, _) = peel_and_count_ty_refs(self_ty)
         && deref_count >= 1
         && specializes_tostring(cx, deref_self_ty)
     {
diff --git a/clippy_lints/src/methods/mut_mutex_lock.rs b/clippy_lints/src/methods/mut_mutex_lock.rs
index 4235af882b0c7..9d2c5e6232d65 100644
--- a/clippy_lints/src/methods/mut_mutex_lock.rs
+++ b/clippy_lints/src/methods/mut_mutex_lock.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::expr_custom_deref_adjustment;
-use clippy_utils::ty::{is_type_diagnostic_item, peel_mid_ty_refs_is_mutable};
+use clippy_utils::ty::{is_type_diagnostic_item, peel_and_count_ty_refs};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability};
 use rustc_lint::LateContext;
@@ -10,8 +10,7 @@ use super::MUT_MUTEX_LOCK;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, ex: &'tcx Expr<'tcx>, recv: &'tcx Expr<'tcx>, name_span: Span) {
     if matches!(expr_custom_deref_adjustment(cx, recv), None | Some(Mutability::Mut))
-        && let (_, ref_depth, Mutability::Mut) = peel_mid_ty_refs_is_mutable(cx.typeck_results().expr_ty(recv))
-        && ref_depth >= 1
+        && let (_, _, Some(Mutability::Mut)) = peel_and_count_ty_refs(cx.typeck_results().expr_ty(recv))
         && let Some(method_id) = cx.typeck_results().type_dependent_def_id(ex.hir_id)
         && let Some(impl_id) = cx.tcx.impl_of_assoc(method_id)
         && is_type_diagnostic_item(cx, cx.tcx.type_of(impl_id).instantiate_identity(), sym::Mutex)
diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index c1f4904af7c48..640931a828998 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -3,11 +3,12 @@ use super::unnecessary_iter_cloned::{self, is_into_iter};
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::{SpanRangeExt, snippet};
-use clippy_utils::ty::{get_iterator_item_ty, implements_trait, is_copy, is_type_diagnostic_item, is_type_lang_item};
+use clippy_utils::ty::{
+    get_iterator_item_ty, implements_trait, is_copy, is_type_diagnostic_item, is_type_lang_item, peel_and_count_ty_refs,
+};
 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, is_expr_temporary_value, peel_middle_ty_refs,
-    return_ty, sym,
+    fn_def_id, get_parent_expr, is_diag_item_method, is_diag_trait_item, is_expr_temporary_value, return_ty, sym,
 };
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
@@ -119,8 +120,8 @@ fn check_addr_of_expr(
                 },
             ] = adjustments[..]
         && let receiver_ty = cx.typeck_results().expr_ty(receiver)
-        && let (target_ty, n_target_refs) = peel_middle_ty_refs(*target_ty)
-        && let (receiver_ty, n_receiver_refs) = peel_middle_ty_refs(receiver_ty)
+        && let (target_ty, n_target_refs, _) = peel_and_count_ty_refs(*target_ty)
+        && let (receiver_ty, n_receiver_refs, _) = peel_and_count_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
@@ -385,7 +386,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_middle_ty_refs(*input)
+        && let (input, n_refs, _) = peel_and_count_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 Some(meta_sized_def_id) = cx.tcx.lang_items().meta_sized_trait()
diff --git a/clippy_lints/src/methods/useless_asref.rs b/clippy_lints/src/methods/useless_asref.rs
index 38fad239f6799..e56f4b80d0172 100644
--- a/clippy_lints/src/methods/useless_asref.rs
+++ b/clippy_lints/src/methods/useless_asref.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::{implements_trait, should_call_clone_as_function, walk_ptrs_ty_depth};
+use clippy_utils::ty::{implements_trait, peel_and_count_ty_refs, should_call_clone_as_function};
 use clippy_utils::{get_parent_expr, is_diag_trait_item, path_to_local_id, peel_blocks, strip_pat_refs};
 use rustc_errors::Applicability;
 use rustc_hir::{self as hir, LangItem};
@@ -50,8 +50,8 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: Symbo
         // check if the type after `as_ref` or `as_mut` is the same as before
         let rcv_ty = cx.typeck_results().expr_ty(recvr);
         let res_ty = cx.typeck_results().expr_ty(expr);
-        let (base_res_ty, res_depth) = walk_ptrs_ty_depth(res_ty);
-        let (base_rcv_ty, rcv_depth) = walk_ptrs_ty_depth(rcv_ty);
+        let (base_res_ty, res_depth, _) = peel_and_count_ty_refs(res_ty);
+        let (base_rcv_ty, rcv_depth, _) = peel_and_count_ty_refs(rcv_ty);
         if base_rcv_ty == base_res_ty && rcv_depth >= res_depth {
             if let Some(parent) = get_parent_expr(cx, expr) {
                 // allow the `as_ref` or `as_mut` if it is followed by another method call
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 1d58cdd26d88d..de6766cbe94aa 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::{span_lint_hir, span_lint_hir_and_then};
 use clippy_utils::fn_has_unsatisfiable_preds;
 use clippy_utils::mir::{LocalUsage, PossibleBorrowerMap, visit_local_usage};
 use clippy_utils::source::SpanRangeExt;
-use clippy_utils::ty::{has_drop, is_copy, is_type_lang_item, walk_ptrs_ty_depth};
+use clippy_utils::ty::{has_drop, is_copy, is_type_lang_item, peel_and_count_ty_refs};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, FnDecl, LangItem, def_id};
@@ -263,7 +263,7 @@ fn is_call_with_ref_arg<'tcx>(
         && args.len() == 1
         && let mir::Operand::Move(mir::Place { local, .. }) = &args[0].node
         && let ty::FnDef(def_id, _) = *func.ty(mir, cx.tcx).kind()
-        && let (inner_ty, 1) = walk_ptrs_ty_depth(args[0].node.ty(mir, cx.tcx))
+        && let (inner_ty, 1, _) = peel_and_count_ty_refs(args[0].node.ty(mir, cx.tcx))
         && !is_copy(cx, inner_ty)
     {
         Some((def_id, *local, inner_ty, destination.as_local()?))
diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index 324a05cdcc0c8..a358eff2ce554 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_then;
+use clippy_utils::get_parent_expr;
 use clippy_utils::source::snippet_with_context;
-use clippy_utils::ty::is_type_lang_item;
-use clippy_utils::{get_parent_expr, peel_middle_ty_refs};
+use clippy_utils::ty::{is_type_lang_item, peel_and_count_ty_refs};
 use rustc_ast::util::parser::ExprPrecedence;
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, LangItem, Mutability};
@@ -82,8 +82,8 @@ 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_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 (expr_ty, expr_ref_count, _) = peel_and_count_ty_refs(cx.typeck_results().expr_ty(expr));
+            let (indexed_ty, indexed_ref_count, _) = peel_and_count_ty_refs(cx.typeck_results().expr_ty(indexed));
             let parent_expr = get_parent_expr(cx, expr);
             let needs_parens_for_prefix =
                 parent_expr.is_some_and(|parent| cx.precedence(parent) > ExprPrecedence::Prefix);
diff --git a/clippy_lints/src/size_of_ref.rs b/clippy_lints/src/size_of_ref.rs
index 60d923bcd77e7..606e852aae9e3 100644
--- a/clippy_lints/src/size_of_ref.rs
+++ b/clippy_lints/src/size_of_ref.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::{path_def_id, peel_middle_ty_refs};
+use clippy_utils::path_def_id;
+use clippy_utils::ty::peel_and_count_ty_refs;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
@@ -59,7 +60,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_middle_ty_refs(arg_ty).1 > 1
+            && peel_and_count_ty_refs(arg_ty).1 > 1
         {
             span_lint_and_help(
                 cx,
diff --git a/clippy_lints/src/unused_peekable.rs b/clippy_lints/src/unused_peekable.rs
index 1f5351e32aacf..5224b62e9fc71 100644
--- a/clippy_lints/src/unused_peekable.rs
+++ b/clippy_lints/src/unused_peekable.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_hir_and_then;
-use clippy_utils::ty::{is_type_diagnostic_item, peel_mid_ty_refs_is_mutable};
+use clippy_utils::ty::{is_type_diagnostic_item, peel_and_count_ty_refs};
 use clippy_utils::{fn_def_id, is_trait_method, path_to_local_id, peel_ref_operators, sym};
 use rustc_ast::Mutability;
 use rustc_hir::intravisit::{Visitor, walk_expr};
@@ -61,7 +61,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedPeekable {
                 && let Some(init) = local.init
                 && !init.span.from_expansion()
                 && let Some(ty) = cx.typeck_results().expr_ty_opt(init)
-                && let (ty, _, Mutability::Mut) = peel_mid_ty_refs_is_mutable(ty)
+                && let (ty, _, None | Some(Mutability::Mut)) = peel_and_count_ty_refs(ty)
                 && is_type_diagnostic_item(cx, ty, sym::IterPeekable)
             {
                 let mut vis = PeekableVisitor::new(cx, binding);
@@ -211,7 +211,7 @@ impl<'tcx> Visitor<'tcx> for PeekableVisitor<'_, 'tcx> {
 
 fn arg_is_mut_peekable(cx: &LateContext<'_>, arg: &Expr<'_>) -> bool {
     if let Some(ty) = cx.typeck_results().expr_ty_opt(arg)
-        && let (ty, _, Mutability::Mut) = peel_mid_ty_refs_is_mutable(ty)
+        && let (ty, _, None | Some(Mutability::Mut)) = peel_and_count_ty_refs(ty)
         && is_type_diagnostic_item(cx, ty, sym::IterPeekable)
     {
         true
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 14b64eb4d54e8..5223cd872a680 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -2380,15 +2380,12 @@ pub fn peel_hir_ty_refs<'a>(mut ty: &'a hir::Ty<'a>) -> (&'a hir::Ty<'a>, usize)
     }
 }
 
-/// Peels off all references on the type. Returns the underlying type and the number of references
-/// removed.
-pub fn peel_middle_ty_refs(mut ty: Ty<'_>) -> (Ty<'_>, usize) {
-    let mut count = 0;
-    while let rustc_ty::Ref(_, dest_ty, _) = ty.kind() {
-        ty = *dest_ty;
-        count += 1;
+/// Returns the base type for HIR references and pointers.
+pub fn peel_hir_ty_refs_and_ptrs<'tcx>(ty: &'tcx hir::Ty<'tcx>) -> &'tcx hir::Ty<'tcx> {
+    match &ty.kind {
+        TyKind::Ptr(mut_ty) | TyKind::Ref(_, mut_ty) => peel_hir_ty_refs_and_ptrs(mut_ty.ty),
+        _ => ty,
     }
-    (ty, count)
 }
 
 /// Removes `AddrOf` operators (`&`) or deref operators (`*`), but only if a reference type is
diff --git a/clippy_utils/src/ty/mod.rs b/clippy_utils/src/ty/mod.rs
index ae6a4ae7fb2d6..5991c36c5fe34 100644
--- a/clippy_utils/src/ty/mod.rs
+++ b/clippy_utils/src/ty/mod.rs
@@ -11,7 +11,7 @@ use rustc_hir as hir;
 use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
 use rustc_hir::def_id::DefId;
-use rustc_hir::{Expr, FnDecl, LangItem, TyKind, find_attr};
+use rustc_hir::{Expr, FnDecl, LangItem, find_attr};
 use rustc_hir_analysis::lower_ty;
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
@@ -476,36 +476,17 @@ pub fn is_unsafe_fn<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
 }
 
 /// 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) {
-    fn f(ty: Ty<'_>, count: usize, mutability: Mutability) -> (Ty<'_>, usize, Mutability) {
-        match ty.kind() {
-            ty::Ref(_, ty, Mutability::Mut) => f(*ty, count + 1, mutability),
-            ty::Ref(_, ty, Mutability::Not) => f(*ty, count + 1, Mutability::Not),
-            _ => (ty, count, mutability),
-        }
-    }
-    f(ty, 0, Mutability::Mut)
-}
-
-/// Returns the base type for HIR references and pointers.
-pub fn walk_ptrs_hir_ty<'tcx>(ty: &'tcx hir::Ty<'tcx>) -> &'tcx hir::Ty<'tcx> {
-    match &ty.kind {
-        TyKind::Ptr(mut_ty) | TyKind::Ref(_, mut_ty) => walk_ptrs_hir_ty(mut_ty.ty),
-        _ => ty,
-    }
-}
-
-/// Returns the base type for references and raw pointers, and count reference
-/// depth.
-pub fn walk_ptrs_ty_depth(ty: Ty<'_>) -> (Ty<'_>, usize) {
-    fn inner(ty: Ty<'_>, depth: usize) -> (Ty<'_>, usize) {
-        match ty.kind() {
-            ty::Ref(_, ty, _) => inner(*ty, depth + 1),
-            _ => (ty, depth),
-        }
+/// removed, and, if there were any such references, whether the pointer is ultimately mutable or
+/// not.
+pub fn peel_and_count_ty_refs(mut ty: Ty<'_>) -> (Ty<'_>, usize, Option<Mutability>) {
+    let mut count = 0;
+    let mut mutbl = None;
+    while let ty::Ref(_, dest_ty, m) = ty.kind() {
+        ty = *dest_ty;
+        count += 1;
+        mutbl.replace(mutbl.map_or(*m, |mutbl: Mutability| mutbl.min(*m)));
     }
-    inner(ty, 0)
+    (ty, count, mutbl)
 }
 
 /// Returns `true` if types `a` and `b` are same types having same `Const` generic args,

From 8938bb268d72deae0bb8a7a1eebe7563949ebc60 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 10 Sep 2025 13:50:11 +0200
Subject: [PATCH 0852/1889] clean-up tests

---
 tests/ui/multiple_unsafe_ops_per_block.rs     |  76 ++++++-----
 tests/ui/multiple_unsafe_ops_per_block.stderr | 124 +++++++++---------
 2 files changed, 99 insertions(+), 101 deletions(-)

diff --git a/tests/ui/multiple_unsafe_ops_per_block.rs b/tests/ui/multiple_unsafe_ops_per_block.rs
index 016fd89a7b7ac..8f5408010dc7f 100644
--- a/tests/ui/multiple_unsafe_ops_per_block.rs
+++ b/tests/ui/multiple_unsafe_ops_per_block.rs
@@ -1,10 +1,6 @@
 //@needs-asm-support
 //@aux-build:proc_macros.rs
-#![allow(unused)]
-#![allow(deref_nullptr)]
-#![allow(clippy::unnecessary_operation)]
-#![allow(dropping_copy_types)]
-#![allow(clippy::assign_op_pattern)]
+#![expect(clippy::unnecessary_operation, dropping_copy_types)]
 #![warn(clippy::multiple_unsafe_ops_per_block)]
 
 extern crate proc_macros;
@@ -105,17 +101,17 @@ fn correct3() {
     }
 }
 
-// tests from the issue (https://github.com/rust-lang/rust-clippy/issues/10064)
-
-unsafe fn read_char_bad(ptr: *const u8) -> char {
-    unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
-    //~^ multiple_unsafe_ops_per_block
-}
+fn issue10064() {
+    unsafe fn read_char_bad(ptr: *const u8) -> char {
+        unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
+        //~^ multiple_unsafe_ops_per_block
+    }
 
-// no lint
-unsafe fn read_char_good(ptr: *const u8) -> char {
-    let int_value = unsafe { *ptr.cast::<u32>() };
-    unsafe { core::char::from_u32_unchecked(int_value) }
+    // no lint
+    unsafe fn read_char_good(ptr: *const u8) -> char {
+        let int_value = unsafe { *ptr.cast::<u32>() };
+        unsafe { core::char::from_u32_unchecked(int_value) }
+    }
 }
 
 // no lint
@@ -126,39 +122,41 @@ fn issue10259() {
     });
 }
 
-fn _fn_ptr(x: unsafe fn()) {
-    unsafe {
-        //~^ multiple_unsafe_ops_per_block
-        x();
-        x();
+fn issue10367() {
+    fn fn_ptr(x: unsafe fn()) {
+        unsafe {
+            //~^ multiple_unsafe_ops_per_block
+            x();
+            x();
+        }
     }
-}
 
-fn _assoc_const() {
-    trait X {
-        const X: unsafe fn();
+    fn assoc_const() {
+        trait X {
+            const X: unsafe fn();
+        }
+        fn _f<T: X>() {
+            unsafe {
+                //~^ multiple_unsafe_ops_per_block
+                T::X();
+                T::X();
+            }
+        }
     }
-    fn _f<T: X>() {
+
+    fn field_fn_ptr(x: unsafe fn()) {
+        struct X(unsafe fn());
+        let x = X(x);
         unsafe {
             //~^ multiple_unsafe_ops_per_block
-            T::X();
-            T::X();
+            x.0();
+            x.0();
         }
     }
 }
 
-fn _field_fn_ptr(x: unsafe fn()) {
-    struct X(unsafe fn());
-    let x = X(x);
-    unsafe {
-        //~^ multiple_unsafe_ops_per_block
-        x.0();
-        x.0();
-    }
-}
-
-// await expands to an unsafe block with several operations, but this is fine.: #11312
-async fn await_desugaring_silent() {
+// await expands to an unsafe block with several operations, but this is fine.
+async fn issue11312() {
     async fn helper() {}
 
     helper().await;
diff --git a/tests/ui/multiple_unsafe_ops_per_block.stderr b/tests/ui/multiple_unsafe_ops_per_block.stderr
index 3130cecc25250..8955321871708 100644
--- a/tests/ui/multiple_unsafe_ops_per_block.stderr
+++ b/tests/ui/multiple_unsafe_ops_per_block.stderr
@@ -1,5 +1,5 @@
 error: this `unsafe` block contains 2 unsafe operations, expected only one
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:38:5
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:34:5
    |
 LL | /     unsafe {
 LL | |
@@ -9,12 +9,12 @@ LL | |     }
    | |_____^
    |
 note: modification of a mutable static occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:40:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:36:9
    |
 LL |         STATIC += 1;
    |         ^^^^^^^^^^^
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:41:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:37:9
    |
 LL |         not_very_safe();
    |         ^^^^^^^^^^^^^^^
@@ -22,7 +22,7 @@ LL |         not_very_safe();
    = help: to override `-D warnings` add `#[allow(clippy::multiple_unsafe_ops_per_block)]`
 
 error: this `unsafe` block contains 2 unsafe operations, expected only one
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:48:5
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:44:5
    |
 LL | /     unsafe {
 LL | |
@@ -32,18 +32,18 @@ LL | |     }
    | |_____^
    |
 note: union field access occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:50:14
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:46:14
    |
 LL |         drop(u.u);
    |              ^^^
 note: raw pointer dereference occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:51:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:47:9
    |
 LL |         *raw_ptr();
    |         ^^^^^^^^^^
 
 error: this `unsafe` block contains 3 unsafe operations, expected only one
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:56:5
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:52:5
    |
 LL | /     unsafe {
 LL | |
@@ -54,23 +54,23 @@ LL | |     }
    | |_____^
    |
 note: inline assembly used here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:58:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:54:9
    |
 LL |         asm!("nop");
    |         ^^^^^^^^^^^
 note: unsafe method call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:59:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:55:9
    |
 LL |         sample.not_very_safe();
    |         ^^^^^^^^^^^^^^^^^^^^^^
 note: modification of a mutable static occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:60:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:56:9
    |
 LL |         STATIC = 0;
    |         ^^^^^^^^^^
 
 error: this `unsafe` block contains 6 unsafe operations, expected only one
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:66:5
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:62:5
    |
 LL | /     unsafe {
 LL | |
@@ -82,115 +82,115 @@ LL | |     }
    | |_____^
    |
 note: union field access occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:68:14
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:64:14
    |
 LL |         drop(u.u);
    |              ^^^
 note: access of a mutable static occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:69:14
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:65:14
    |
 LL |         drop(STATIC);
    |              ^^^^^^
 note: unsafe method call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:70:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:66:9
    |
 LL |         sample.not_very_safe();
    |         ^^^^^^^^^^^^^^^^^^^^^^
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:71:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:67:9
    |
 LL |         not_very_safe();
    |         ^^^^^^^^^^^^^^^
 note: raw pointer dereference occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:72:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:68:9
    |
 LL |         *raw_ptr();
    |         ^^^^^^^^^^
 note: inline assembly used here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:73:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:69:9
    |
 LL |         asm!("nop");
    |         ^^^^^^^^^^^
 
 error: this `unsafe` block contains 2 unsafe operations, expected only one
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:111:5
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:106:9
    |
-LL |     unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:111:14
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:106:18
    |
-LL |     unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: raw pointer dereference occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:111:39
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:106:43
    |
-LL |     unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
-   |                                       ^^^^^^^^^^^^^^^^^^
+LL |         unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
+   |                                           ^^^^^^^^^^^^^^^^^^
 
 error: this `unsafe` block contains 2 unsafe operations, expected only one
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:130:5
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:127:9
    |
-LL | /     unsafe {
+LL | /         unsafe {
 LL | |
-LL | |         x();
-LL | |         x();
-LL | |     }
-   | |_____^
+LL | |             x();
+LL | |             x();
+LL | |         }
+   | |_________^
    |
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:132:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:129:13
    |
-LL |         x();
-   |         ^^^
+LL |             x();
+   |             ^^^
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:133:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:130:13
    |
-LL |         x();
-   |         ^^^
+LL |             x();
+   |             ^^^
 
 error: this `unsafe` block contains 2 unsafe operations, expected only one
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:142:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:139:13
    |
-LL | /         unsafe {
+LL | /             unsafe {
 LL | |
-LL | |             T::X();
-LL | |             T::X();
-LL | |         }
-   | |_________^
+LL | |                 T::X();
+LL | |                 T::X();
+LL | |             }
+   | |_____________^
    |
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:144:13
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:141:17
    |
-LL |             T::X();
-   |             ^^^^^^
+LL |                 T::X();
+   |                 ^^^^^^
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:145:13
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:142:17
    |
-LL |             T::X();
-   |             ^^^^^^
+LL |                 T::X();
+   |                 ^^^^^^
 
 error: this `unsafe` block contains 2 unsafe operations, expected only one
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:153:5
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:150:9
    |
-LL | /     unsafe {
+LL | /         unsafe {
 LL | |
-LL | |         x.0();
-LL | |         x.0();
-LL | |     }
-   | |_____^
+LL | |             x.0();
+LL | |             x.0();
+LL | |         }
+   | |_________^
    |
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:155:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:152:13
    |
-LL |         x.0();
-   |         ^^^^^
+LL |             x.0();
+   |             ^^^^^
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:156:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:153:13
    |
-LL |         x.0();
-   |         ^^^^^
+LL |             x.0();
+   |             ^^^^^
 
 error: aborting due to 8 previous errors
 

From 51e3b6238d66fb9f70f2750fed3a6ee2f610ce9d Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Fri, 12 Sep 2025 11:22:07 -0500
Subject: [PATCH 0853/1889] Improve `core::char` coverage

---
 library/coretests/tests/char.rs | 43 +++++++++++++++++++++++++++++++++
 library/coretests/tests/lib.rs  |  1 +
 2 files changed, 44 insertions(+)

diff --git a/library/coretests/tests/char.rs b/library/coretests/tests/char.rs
index 852f073bae187..6f94065b2d927 100644
--- a/library/coretests/tests/char.rs
+++ b/library/coretests/tests/char.rs
@@ -220,6 +220,7 @@ fn test_escape_default() {
     }
     assert_eq!(string('\n'), "\\n");
     assert_eq!(string('\r'), "\\r");
+    assert_eq!(string('\t'), "\\t");
     assert_eq!(string('\''), "\\'");
     assert_eq!(string('"'), "\\\"");
     assert_eq!(string(' '), " ");
@@ -417,3 +418,45 @@ fn eu_iterator_specializations() {
     check('\u{12340}');
     check('\u{10FFFF}');
 }
+
+#[test]
+#[should_panic]
+fn test_from_digit_radix_too_high() {
+    let _ = char::from_digit(0, 37);
+}
+
+#[test]
+fn test_from_digit_invalid_radix() {
+    assert!(char::from_digit(10, 9).is_none());
+}
+
+#[test]
+#[should_panic]
+fn test_to_digit_radix_too_low() {
+    let _ = 'a'.to_digit(1);
+}
+
+#[test]
+#[should_panic]
+fn test_to_digit_radix_too_high() {
+    let _ = 'a'.to_digit(37);
+}
+
+#[test]
+fn test_as_ascii_invalid() {
+    assert!('❤'.as_ascii().is_none());
+}
+
+#[test]
+#[should_panic]
+fn test_encode_utf8_raw_buffer_too_small() {
+    let mut buf = [0u8; 1];
+    let _ = char::encode_utf8_raw('ß'.into(), &mut buf);
+}
+
+#[test]
+#[should_panic]
+fn test_encode_utf16_raw_buffer_too_small() {
+    let mut buf = [0u16; 1];
+    let _ = char::encode_utf16_raw('𐐷'.into(), &mut buf);
+}
diff --git a/library/coretests/tests/lib.rs b/library/coretests/tests/lib.rs
index 1bdaa6965f64a..3b5334391ac9a 100644
--- a/library/coretests/tests/lib.rs
+++ b/library/coretests/tests/lib.rs
@@ -13,6 +13,7 @@
 #![feature(bool_to_result)]
 #![feature(bstr)]
 #![feature(cfg_target_has_reliable_f16_f128)]
+#![feature(char_internals)]
 #![feature(char_max_len)]
 #![feature(clone_to_uninit)]
 #![feature(const_convert)]

From da6d23b116471cdaccd60e8096c97cae259cc79e Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 10 Sep 2025 13:28:44 +0200
Subject: [PATCH 0854/1889] fix: ignore unsafe ops from `.await` desugaring

---
 .../src/multiple_unsafe_ops_per_block.rs      |   8 ++
 tests/ui/multiple_unsafe_ops_per_block.rs     |  49 ++++++-
 tests/ui/multiple_unsafe_ops_per_block.stderr | 123 +++++++++++++-----
 3 files changed, 149 insertions(+), 31 deletions(-)

diff --git a/clippy_lints/src/multiple_unsafe_ops_per_block.rs b/clippy_lints/src/multiple_unsafe_ops_per_block.rs
index c6c27e22b90e5..bc5e72270f4e3 100644
--- a/clippy_lints/src/multiple_unsafe_ops_per_block.rs
+++ b/clippy_lints/src/multiple_unsafe_ops_per_block.rs
@@ -1,3 +1,4 @@
+use clippy_utils::desugar_await;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::visitors::{Descend, Visitable, for_each_expr};
 use core::ops::ControlFlow::Continue;
@@ -97,6 +98,13 @@ fn collect_unsafe_exprs<'tcx>(
 ) {
     for_each_expr(cx, node, |expr| {
         match expr.kind {
+            // The `await` itself will desugar to two unsafe calls, but we should ignore those.
+            // Instead, check the expression that is `await`ed
+            _ if let Some(e) = desugar_await(expr) => {
+                collect_unsafe_exprs(cx, e, unsafe_ops);
+                return Continue(Descend::No);
+            },
+
             ExprKind::InlineAsm(_) => unsafe_ops.push(("inline assembly used here", expr.span)),
 
             ExprKind::Field(e, _) => {
diff --git a/tests/ui/multiple_unsafe_ops_per_block.rs b/tests/ui/multiple_unsafe_ops_per_block.rs
index 8f5408010dc7f..132673d5164ab 100644
--- a/tests/ui/multiple_unsafe_ops_per_block.rs
+++ b/tests/ui/multiple_unsafe_ops_per_block.rs
@@ -1,6 +1,10 @@
 //@needs-asm-support
 //@aux-build:proc_macros.rs
-#![expect(clippy::unnecessary_operation, dropping_copy_types)]
+#![expect(
+    dropping_copy_types,
+    clippy::unnecessary_operation,
+    clippy::unnecessary_literal_unwrap
+)]
 #![warn(clippy::multiple_unsafe_ops_per_block)]
 
 extern crate proc_macros;
@@ -162,4 +166,47 @@ async fn issue11312() {
     helper().await;
 }
 
+async fn issue13879() {
+    async fn foo() {}
+
+    // no lint: nothing unsafe beyond the `await` which we ignore
+    unsafe {
+        foo().await;
+    }
+
+    // no lint: only one unsafe call beyond the `await`
+    unsafe {
+        not_very_safe();
+        foo().await;
+    }
+
+    // lint: two unsafe calls beyond the `await`
+    unsafe {
+        //~^ multiple_unsafe_ops_per_block
+        not_very_safe();
+        STATIC += 1;
+        foo().await;
+    }
+
+    async unsafe fn foo_unchecked() {}
+
+    // no lint: only one unsafe call in the `await`ed expr
+    unsafe {
+        foo_unchecked().await;
+    }
+
+    // lint: one unsafe call in the `await`ed expr, and one outside
+    unsafe {
+        //~^ multiple_unsafe_ops_per_block
+        not_very_safe();
+        foo_unchecked().await;
+    }
+
+    // lint: two unsafe calls in the `await`ed expr
+    unsafe {
+        //~^ multiple_unsafe_ops_per_block
+        Some(foo_unchecked()).unwrap_unchecked().await;
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/multiple_unsafe_ops_per_block.stderr b/tests/ui/multiple_unsafe_ops_per_block.stderr
index 8955321871708..922a464c6b6ef 100644
--- a/tests/ui/multiple_unsafe_ops_per_block.stderr
+++ b/tests/ui/multiple_unsafe_ops_per_block.stderr
@@ -1,5 +1,5 @@
 error: this `unsafe` block contains 2 unsafe operations, expected only one
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:34:5
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:38:5
    |
 LL | /     unsafe {
 LL | |
@@ -9,12 +9,12 @@ LL | |     }
    | |_____^
    |
 note: modification of a mutable static occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:36:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:40:9
    |
 LL |         STATIC += 1;
    |         ^^^^^^^^^^^
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:37:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:41:9
    |
 LL |         not_very_safe();
    |         ^^^^^^^^^^^^^^^
@@ -22,7 +22,7 @@ LL |         not_very_safe();
    = help: to override `-D warnings` add `#[allow(clippy::multiple_unsafe_ops_per_block)]`
 
 error: this `unsafe` block contains 2 unsafe operations, expected only one
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:44:5
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:48:5
    |
 LL | /     unsafe {
 LL | |
@@ -32,18 +32,18 @@ LL | |     }
    | |_____^
    |
 note: union field access occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:46:14
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:50:14
    |
 LL |         drop(u.u);
    |              ^^^
 note: raw pointer dereference occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:47:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:51:9
    |
 LL |         *raw_ptr();
    |         ^^^^^^^^^^
 
 error: this `unsafe` block contains 3 unsafe operations, expected only one
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:52:5
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:56:5
    |
 LL | /     unsafe {
 LL | |
@@ -54,23 +54,23 @@ LL | |     }
    | |_____^
    |
 note: inline assembly used here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:54:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:58:9
    |
 LL |         asm!("nop");
    |         ^^^^^^^^^^^
 note: unsafe method call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:55:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:59:9
    |
 LL |         sample.not_very_safe();
    |         ^^^^^^^^^^^^^^^^^^^^^^
 note: modification of a mutable static occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:56:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:60:9
    |
 LL |         STATIC = 0;
    |         ^^^^^^^^^^
 
 error: this `unsafe` block contains 6 unsafe operations, expected only one
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:62:5
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:66:5
    |
 LL | /     unsafe {
 LL | |
@@ -82,55 +82,55 @@ LL | |     }
    | |_____^
    |
 note: union field access occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:64:14
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:68:14
    |
 LL |         drop(u.u);
    |              ^^^
 note: access of a mutable static occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:65:14
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:69:14
    |
 LL |         drop(STATIC);
    |              ^^^^^^
 note: unsafe method call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:66:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:70:9
    |
 LL |         sample.not_very_safe();
    |         ^^^^^^^^^^^^^^^^^^^^^^
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:67:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:71:9
    |
 LL |         not_very_safe();
    |         ^^^^^^^^^^^^^^^
 note: raw pointer dereference occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:68:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:72:9
    |
 LL |         *raw_ptr();
    |         ^^^^^^^^^^
 note: inline assembly used here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:69:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:73:9
    |
 LL |         asm!("nop");
    |         ^^^^^^^^^^^
 
 error: this `unsafe` block contains 2 unsafe operations, expected only one
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:106:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:110:9
    |
 LL |         unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:106:18
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:110:18
    |
 LL |         unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: raw pointer dereference occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:106:43
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:110:43
    |
 LL |         unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
    |                                           ^^^^^^^^^^^^^^^^^^
 
 error: this `unsafe` block contains 2 unsafe operations, expected only one
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:127:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:131:9
    |
 LL | /         unsafe {
 LL | |
@@ -140,18 +140,18 @@ LL | |         }
    | |_________^
    |
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:129:13
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:133:13
    |
 LL |             x();
    |             ^^^
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:130:13
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:134:13
    |
 LL |             x();
    |             ^^^
 
 error: this `unsafe` block contains 2 unsafe operations, expected only one
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:139:13
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:143:13
    |
 LL | /             unsafe {
 LL | |
@@ -161,18 +161,18 @@ LL | |             }
    | |_____________^
    |
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:141:17
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:145:17
    |
 LL |                 T::X();
    |                 ^^^^^^
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:142:17
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:146:17
    |
 LL |                 T::X();
    |                 ^^^^^^
 
 error: this `unsafe` block contains 2 unsafe operations, expected only one
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:150:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:154:9
    |
 LL | /         unsafe {
 LL | |
@@ -182,15 +182,78 @@ LL | |         }
    | |_________^
    |
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:152:13
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:156:13
    |
 LL |             x.0();
    |             ^^^^^
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:153:13
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:157:13
    |
 LL |             x.0();
    |             ^^^^^
 
-error: aborting due to 8 previous errors
+error: this `unsafe` block contains 2 unsafe operations, expected only one
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:184:5
+   |
+LL | /     unsafe {
+LL | |
+LL | |         not_very_safe();
+LL | |         STATIC += 1;
+LL | |         foo().await;
+LL | |     }
+   | |_____^
+   |
+note: unsafe function call occurs here
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:186:9
+   |
+LL |         not_very_safe();
+   |         ^^^^^^^^^^^^^^^
+note: modification of a mutable static occurs here
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:187:9
+   |
+LL |         STATIC += 1;
+   |         ^^^^^^^^^^^
+
+error: this `unsafe` block contains 2 unsafe operations, expected only one
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:199:5
+   |
+LL | /     unsafe {
+LL | |
+LL | |         not_very_safe();
+LL | |         foo_unchecked().await;
+LL | |     }
+   | |_____^
+   |
+note: unsafe function call occurs here
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:201:9
+   |
+LL |         not_very_safe();
+   |         ^^^^^^^^^^^^^^^
+note: unsafe function call occurs here
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:202:9
+   |
+LL |         foo_unchecked().await;
+   |         ^^^^^^^^^^^^^^^
+
+error: this `unsafe` block contains 2 unsafe operations, expected only one
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:206:5
+   |
+LL | /     unsafe {
+LL | |
+LL | |         Some(foo_unchecked()).unwrap_unchecked().await;
+LL | |     }
+   | |_____^
+   |
+note: unsafe method call occurs here
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:208:9
+   |
+LL |         Some(foo_unchecked()).unwrap_unchecked().await;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+note: unsafe function call occurs here
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:208:14
+   |
+LL |         Some(foo_unchecked()).unwrap_unchecked().await;
+   |              ^^^^^^^^^^^^^^^
+
+error: aborting due to 11 previous errors
 

From 2e652d7d13ff9f1944b92a4f20248a61a96fe71c Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Fri, 12 Sep 2025 11:34:54 -0500
Subject: [PATCH 0855/1889] Improve `core::fmt` coverage

---
 library/coretests/tests/fmt/builders.rs | 15 +++++++++++++
 library/coretests/tests/fmt/mod.rs      | 30 +++++++++++++++++++++++++
 library/coretests/tests/fmt/num.rs      |  6 +++++
 library/coretests/tests/lib.rs          |  1 +
 4 files changed, 52 insertions(+)

diff --git a/library/coretests/tests/fmt/builders.rs b/library/coretests/tests/fmt/builders.rs
index ba4801f5912b8..156eebb1e9d2e 100644
--- a/library/coretests/tests/fmt/builders.rs
+++ b/library/coretests/tests/fmt/builders.rs
@@ -173,6 +173,21 @@ mod debug_struct {
             format!("{Bar:#?}")
         );
     }
+
+    #[test]
+    fn test_field_with() {
+        struct Foo;
+        impl fmt::Debug for Foo {
+            fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+                fmt.debug_struct("Foo")
+                    .field_with("bar", |f| f.write_str("true"))
+                    .field_with("baz", |f| f.write_str("false"))
+                    .finish()
+            }
+        }
+
+        assert_eq!("Foo {\n    bar: true,\n    baz: false,\n}", format!("{Foo:#?}"))
+    }
 }
 
 mod debug_tuple {
diff --git a/library/coretests/tests/fmt/mod.rs b/library/coretests/tests/fmt/mod.rs
index 16f116d25901c..586e890befe0c 100644
--- a/library/coretests/tests/fmt/mod.rs
+++ b/library/coretests/tests/fmt/mod.rs
@@ -57,6 +57,36 @@ fn test_fmt_debug_of_raw_pointers() {
     check_fmt(vtable as *const dyn Debug, "Pointer { addr: ", ", metadata: DynMetadata(");
 }
 
+#[test]
+fn test_fmt_debug_of_mut_reference() {
+    let mut x: u32 = 0;
+
+    assert_eq!(format!("{:?}", &mut x), "0");
+}
+
+#[test]
+fn test_default_write_impls() {
+    use core::fmt::Write;
+
+    struct Buf(String);
+
+    impl Write for Buf {
+        fn write_str(&mut self, s: &str) -> core::fmt::Result {
+            self.0.write_str(s)
+        }
+    }
+
+    let mut buf = Buf(String::new());
+    buf.write_char('a').unwrap();
+
+    assert_eq!(buf.0, "a");
+
+    let mut buf = Buf(String::new());
+    buf.write_fmt(format_args!("a")).unwrap();
+
+    assert_eq!(buf.0, "a");
+}
+
 #[test]
 fn test_estimated_capacity() {
     assert_eq!(format_args!("").estimated_capacity(), 0);
diff --git a/library/coretests/tests/fmt/num.rs b/library/coretests/tests/fmt/num.rs
index 4c145b484ddd6..052b16db52147 100644
--- a/library/coretests/tests/fmt/num.rs
+++ b/library/coretests/tests/fmt/num.rs
@@ -323,3 +323,9 @@ fn test_format_debug_hex() {
     assert_eq!(format!("{:02x?}", b"Foo\0"), "[46, 6f, 6f, 00]");
     assert_eq!(format!("{:02X?}", b"Foo\0"), "[46, 6F, 6F, 00]");
 }
+
+#[test]
+#[should_panic = "Formatting argument out of range"]
+fn test_rt_width_too_long() {
+    let _ = format!("Hello {:width$}!", "x", width = u16::MAX as usize + 1);
+}
diff --git a/library/coretests/tests/lib.rs b/library/coretests/tests/lib.rs
index 1bdaa6965f64a..6f42f1832682a 100644
--- a/library/coretests/tests/lib.rs
+++ b/library/coretests/tests/lib.rs
@@ -31,6 +31,7 @@
 #![feature(core_private_bignum)]
 #![feature(core_private_diy_float)]
 #![feature(cstr_display)]
+#![feature(debug_closure_helpers)]
 #![feature(dec2flt)]
 #![feature(drop_guard)]
 #![feature(duration_constants)]

From e513ecc939b61f9020c511e4fc4daff892725cc9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Justus=20Fl=C3=BCgel?= <justusfluegel@gmail.com>
Date: Sun, 7 Sep 2025 15:18:47 +0200
Subject: [PATCH 0856/1889] Fix `explicit_deref_methods` triggering from within
 proc macros
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Justus Flügel <justusfluegel@gmail.com>
---
 clippy_lints/src/dereference.rs | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 9337816c80d9d..f82ea9844ed62 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -3,7 +3,8 @@ use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::has_enclosing_paren;
 use clippy_utils::ty::{adjust_derefs_manually_drop, implements_trait, is_manually_drop, peel_and_count_ty_refs};
 use clippy_utils::{
-    DefinedTy, ExprUseNode, expr_use_ctxt, get_parent_expr, is_block_like, is_lint_allowed, path_to_local,
+    DefinedTy, ExprUseNode, expr_use_ctxt, get_parent_expr, is_block_like, is_from_proc_macro, is_lint_allowed,
+    path_to_local,
 };
 use rustc_ast::util::parser::ExprPrecedence;
 use rustc_data_structures::fx::FxIndexMap;
@@ -260,6 +261,13 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
         };
         self.skip_expr = skip_expr;
 
+        if is_from_proc_macro(cx, expr) {
+            if let Some((state, data)) = self.state.take() {
+                report(cx, expr, state, data, cx.typeck_results());
+            }
+            return;
+        }
+
         match (self.state.take(), kind) {
             (None, kind) => {
                 let expr_ty = typeck.expr_ty(expr);

From 8f84324ec9d66ed8329331b4ade07ab7f4b124fa Mon Sep 17 00:00:00 2001
From: Valdemar Erk <valdemar@erk.dev>
Date: Wed, 10 Sep 2025 07:04:37 +0200
Subject: [PATCH 0857/1889] autofix for `rest_pat_in_fully_bound_structs`

---
 .../matches/rest_pat_in_fully_bound_struct.rs | 10 ++-
 .../ui/rest_pat_in_fully_bound_structs.fixed  | 61 +++++++++++++++++++
 .../ui/rest_pat_in_fully_bound_structs.stderr | 18 +++++-
 3 files changed, 83 insertions(+), 6 deletions(-)
 create mode 100644 tests/ui/rest_pat_in_fully_bound_structs.fixed

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 ae09c2e87d6b7..1130d82ab78f9 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
@@ -7,7 +7,7 @@ use super::REST_PAT_IN_FULLY_BOUND_STRUCTS;
 
 pub(crate) fn check(cx: &LateContext<'_>, pat: &Pat<'_>) {
     if !pat.span.from_expansion()
-        && let PatKind::Struct(QPath::Resolved(_, path), fields, Some(_)) = pat.kind
+        && let PatKind::Struct(QPath::Resolved(_, path), fields, Some(dotdot)) = pat.kind
         && let Some(def_id) = path.res.opt_def_id()
         && let ty = cx.tcx.type_of(def_id).instantiate_identity()
         && let ty::Adt(def, _) = ty.kind()
@@ -15,14 +15,18 @@ 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()
     {
-        #[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",
             |diag| {
-                diag.help("consider removing `..` from this binding");
+                diag.span_suggestion_verbose(
+                    dotdot,
+                    "consider removing `..` from this binding",
+                    "",
+                    rustc_errors::Applicability::MachineApplicable,
+                );
             },
         );
     }
diff --git a/tests/ui/rest_pat_in_fully_bound_structs.fixed b/tests/ui/rest_pat_in_fully_bound_structs.fixed
new file mode 100644
index 0000000000000..ac200b3b19b74
--- /dev/null
+++ b/tests/ui/rest_pat_in_fully_bound_structs.fixed
@@ -0,0 +1,61 @@
+#![warn(clippy::rest_pat_in_fully_bound_structs)]
+#![allow(clippy::struct_field_names)]
+
+struct A {
+    a: i32,
+    b: i64,
+    c: &'static str,
+}
+
+macro_rules! foo {
+    ($param:expr) => {
+        match $param {
+            A { a: 0, b: 0, c: "", .. } => {},
+            _ => {},
+        }
+    };
+}
+
+fn main() {
+    let a_struct = A { a: 5, b: 42, c: "A" };
+
+    match a_struct {
+        A { a: 5, b: 42, c: "",  } => {}, // Lint
+        //~^ rest_pat_in_fully_bound_structs
+        A { a: 0, b: 0, c: "",  } => {}, // Lint
+        //~^ rest_pat_in_fully_bound_structs
+        _ => {},
+    }
+
+    match a_struct {
+        A { a: 5, b: 42, .. } => {},
+        A { a: 0, b: 0, c: "",  } => {}, // Lint
+        //~^ rest_pat_in_fully_bound_structs
+        _ => {},
+    }
+
+    // No lint
+    match a_struct {
+        A { a: 5, .. } => {},
+        A { a: 0, b: 0, .. } => {},
+        _ => {},
+    }
+
+    // No lint
+    foo!(a_struct);
+
+    #[non_exhaustive]
+    struct B {
+        a: u32,
+        b: u32,
+        c: u64,
+    }
+
+    let b_struct = B { a: 5, b: 42, c: 342 };
+
+    match b_struct {
+        B { a: 5, b: 42, .. } => {},
+        B { a: 0, b: 0, c: 128, .. } => {}, // No Lint
+        _ => {},
+    }
+}
diff --git a/tests/ui/rest_pat_in_fully_bound_structs.stderr b/tests/ui/rest_pat_in_fully_bound_structs.stderr
index d048933ddb7bc..8a2da302b9ef2 100644
--- a/tests/ui/rest_pat_in_fully_bound_structs.stderr
+++ b/tests/ui/rest_pat_in_fully_bound_structs.stderr
@@ -4,9 +4,13 @@ error: unnecessary use of `..` pattern in struct binding. All fields were alread
 LL |         A { a: 5, b: 42, c: "", .. } => {}, // Lint
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: consider removing `..` from this binding
    = note: `-D clippy::rest-pat-in-fully-bound-structs` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::rest_pat_in_fully_bound_structs)]`
+help: consider removing `..` from this binding
+   |
+LL -         A { a: 5, b: 42, c: "", .. } => {}, // Lint
+LL +         A { a: 5, b: 42, c: "",  } => {}, // Lint
+   |
 
 error: unnecessary use of `..` pattern in struct binding. All fields were already bound
   --> tests/ui/rest_pat_in_fully_bound_structs.rs:25:9
@@ -14,7 +18,11 @@ error: unnecessary use of `..` pattern in struct binding. All fields were alread
 LL |         A { a: 0, b: 0, c: "", .. } => {}, // Lint
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: consider removing `..` from this binding
+help: consider removing `..` from this binding
+   |
+LL -         A { a: 0, b: 0, c: "", .. } => {}, // Lint
+LL +         A { a: 0, b: 0, c: "",  } => {}, // Lint
+   |
 
 error: unnecessary use of `..` pattern in struct binding. All fields were already bound
   --> tests/ui/rest_pat_in_fully_bound_structs.rs:32:9
@@ -22,7 +30,11 @@ error: unnecessary use of `..` pattern in struct binding. All fields were alread
 LL |         A { a: 0, b: 0, c: "", .. } => {}, // Lint
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: consider removing `..` from this binding
+help: consider removing `..` from this binding
+   |
+LL -         A { a: 0, b: 0, c: "", .. } => {}, // Lint
+LL +         A { a: 0, b: 0, c: "",  } => {}, // Lint
+   |
 
 error: aborting due to 3 previous errors
 

From dd4562a18f4a91e40ba701019af33ab80c1b2886 Mon Sep 17 00:00:00 2001
From: Augie Fackler <augie@google.com>
Date: Fri, 12 Sep 2025 14:31:08 -0400
Subject: [PATCH 0858/1889] tests: update new test to accept new lifetime
 format

Same change as rust-lang/rust@258915a55539593423c3d4c30f7b741f65c56e51,
just for a newly written test.
---
 tests/codegen-llvm/c-variadic-lifetime.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/codegen-llvm/c-variadic-lifetime.rs b/tests/codegen-llvm/c-variadic-lifetime.rs
index 5b2f8af18c817..c6d3602ef51a0 100644
--- a/tests/codegen-llvm/c-variadic-lifetime.rs
+++ b/tests/codegen-llvm/c-variadic-lifetime.rs
@@ -8,7 +8,7 @@
 
 #[unsafe(no_mangle)]
 unsafe extern "C" fn variadic(a: f64, mut args: ...) -> f64 {
-    // CHECK: call void @llvm.lifetime.start.p0(i64 {{[0-9]+}}, ptr nonnull %args)
+    // CHECK: call void @llvm.lifetime.start.p0({{(i64 [0-9]+, )?}}ptr nonnull %args)
     // CHECK: call void @llvm.va_start.p0(ptr nonnull %args)
 
     let b = args.arg::<f64>();
@@ -17,5 +17,5 @@ unsafe extern "C" fn variadic(a: f64, mut args: ...) -> f64 {
     a + b + c
 
     // CHECK: call void @llvm.va_end.p0(ptr nonnull %args)
-    // CHECK: call void @llvm.lifetime.end.p0(i64 {{[0-9]+}}, ptr nonnull %args)
+    // CHECK: call void @llvm.lifetime.end.p0({{(i64 [0-9]+, )?}}ptr nonnull %args)
 }

From a0bb9cc57db551289cba9fefde086e45cb82733f Mon Sep 17 00:00:00 2001
From: Noratrieb <48135649+Noratrieb@users.noreply.github.com>
Date: Sat, 26 Jul 2025 12:15:19 +0200
Subject: [PATCH 0859/1889] Introduce `target_spec_enum` macro to avoid
 duplication

With this macro we only need to enumerate every variant once. This saves
a lot of duplication already between the definition, the `FromStr` impl
and the `ToJson` impl.

It also enables us to do further things with it like JSON schema
generation.
---
 compiler/rustc_target/src/lib.rs      |  60 ++
 compiler/rustc_target/src/spec/mod.rs | 899 ++++++--------------------
 2 files changed, 244 insertions(+), 715 deletions(-)

diff --git a/compiler/rustc_target/src/lib.rs b/compiler/rustc_target/src/lib.rs
index 91657fef80326..c6a23745b04e7 100644
--- a/compiler/rustc_target/src/lib.rs
+++ b/compiler/rustc_target/src/lib.rs
@@ -72,3 +72,63 @@ fn find_relative_libdir(sysroot: &Path) -> std::borrow::Cow<'static, str> {
         Some(libdir) => libdir.into(),
     }
 }
+
+macro_rules! target_spec_enum {
+    (
+        $( #[$attr:meta] )*
+        pub enum $name:ident {
+            $(
+                $( #[$variant_attr:meta] )*
+                $variant:ident = $string:literal,
+            )*
+        }
+        parse_error_type = $parse_error_type:literal;
+    ) => {
+        $( #[$attr] )*
+        #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, PartialOrd, Ord)]
+        pub enum $name {
+            $(
+                $( #[$variant_attr] )*
+                $variant,
+            )*
+        }
+
+        impl FromStr for $name {
+            type Err = String;
+
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                Ok(match s {
+                    $( $string => Self::$variant, )*
+                    _ => {
+                        let all = [$( concat!("'", $string, "'") ),*].join(", ");
+                        return Err(format!("invalid {}: '{s}'. allowed values: {all}", $parse_error_type));
+                    }
+                })
+            }
+        }
+
+        impl $name {
+            pub fn desc(&self) -> &'static str {
+                match self {
+                    $( Self::$variant => $string, )*
+                }
+            }
+        }
+
+        impl crate::json::ToJson for $name {
+            fn to_json(&self) -> crate::json::Json {
+                self.desc().to_json()
+            }
+        }
+
+        crate::json::serde_deserialize_from_str!($name);
+
+
+        impl std::fmt::Display for $name {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                f.write_str(self.desc())
+            }
+        }
+    };
+}
+use target_spec_enum;
diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index 4d9f06c568bd3..239ac7bf5c4d1 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -183,50 +183,15 @@ impl LinkerFlavorCli {
     }
 }
 
-#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
-pub enum LldFlavor {
-    Wasm,
-    Ld64,
-    Ld,
-    Link,
-}
-
-impl LldFlavor {
-    pub fn as_str(&self) -> &'static str {
-        match self {
-            LldFlavor::Wasm => "wasm",
-            LldFlavor::Ld64 => "darwin",
-            LldFlavor::Ld => "gnu",
-            LldFlavor::Link => "link",
-        }
+crate::target_spec_enum! {
+    pub enum LldFlavor {
+        Wasm = "wasm",
+        Ld64 = "darwin",
+        Ld = "gnu",
+        Link = "link",
     }
-}
-
-impl FromStr for LldFlavor {
-    type Err = String;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(match s {
-            "darwin" => LldFlavor::Ld64,
-            "gnu" => LldFlavor::Ld,
-            "link" => LldFlavor::Link,
-            "wasm" => LldFlavor::Wasm,
-            _ => {
-                return Err(
-                    "invalid value for lld flavor: '{s}', expected one of 'darwin', 'gnu', 'link', 'wasm'"
-                        .into(),
-                );
-            }
-        })
-    }
-}
-
-crate::json::serde_deserialize_from_str!(LldFlavor);
 
-impl ToJson for LldFlavor {
-    fn to_json(&self) -> Json {
-        self.as_str().to_json()
-    }
+    parse_error_type = "LLD flavor";
 }
 
 impl LinkerFlavor {
@@ -823,10 +788,14 @@ impl LinkerFeatures {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Hash, Encodable, Decodable, HashStable_Generic)]
-pub enum PanicStrategy {
-    Unwind,
-    Abort,
+crate::target_spec_enum! {
+    #[derive(Encodable, Decodable, HashStable_Generic)]
+    pub enum PanicStrategy {
+        Unwind = "unwind",
+        Abort = "abort",
+    }
+
+    parse_error_type = "panic strategy";
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Hash, Encodable, Decodable, HashStable_Generic)]
@@ -838,13 +807,6 @@ pub enum OnBrokenPipe {
 }
 
 impl PanicStrategy {
-    pub fn desc(&self) -> &str {
-        match *self {
-            PanicStrategy::Unwind => "unwind",
-            PanicStrategy::Abort => "abort",
-        }
-    }
-
     pub const fn desc_symbol(&self) -> Symbol {
         match *self {
             PanicStrategy::Unwind => sym::unwind,
@@ -857,24 +819,16 @@ impl PanicStrategy {
     }
 }
 
-impl FromStr for PanicStrategy {
-    type Err = String;
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(match s {
-            "unwind" => PanicStrategy::Unwind,
-            "abort" => PanicStrategy::Abort,
-            _ => {
-                return Err(format!(
-                    "'{}' is not a valid value for \
-                    panic-strategy. Use 'unwind' or 'abort'.",
-                    s
-                ));
-            }
-        })
+crate::target_spec_enum! {
+    pub enum RelroLevel {
+        Full = "full",
+        Partial = "partial",
+        Off = "off",
+        None = "none",
     }
-}
 
-crate::json::serde_deserialize_from_str!(PanicStrategy);
+    parse_error_type = "relro level";
+}
 
 impl IntoDiagArg for PanicStrategy {
     fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
@@ -882,110 +836,16 @@ impl IntoDiagArg for PanicStrategy {
     }
 }
 
-impl ToJson for PanicStrategy {
-    fn to_json(&self) -> Json {
-        match *self {
-            PanicStrategy::Abort => "abort".to_json(),
-            PanicStrategy::Unwind => "unwind".to_json(),
-        }
+crate::target_spec_enum! {
+    pub enum SymbolVisibility {
+        Hidden = "hidden",
+        Protected = "protected",
+        Interposable = "interposable",
     }
-}
 
-#[derive(Clone, Copy, Debug, PartialEq, Hash)]
-pub enum RelroLevel {
-    Full,
-    Partial,
-    Off,
-    None,
+    parse_error_type = "symbol visibility";
 }
 
-impl RelroLevel {
-    pub fn desc(&self) -> &str {
-        match *self {
-            RelroLevel::Full => "full",
-            RelroLevel::Partial => "partial",
-            RelroLevel::Off => "off",
-            RelroLevel::None => "none",
-        }
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Hash)]
-pub enum SymbolVisibility {
-    Hidden,
-    Protected,
-    Interposable,
-}
-
-impl SymbolVisibility {
-    pub fn desc(&self) -> &str {
-        match *self {
-            SymbolVisibility::Hidden => "hidden",
-            SymbolVisibility::Protected => "protected",
-            SymbolVisibility::Interposable => "interposable",
-        }
-    }
-}
-
-impl FromStr for SymbolVisibility {
-    type Err = String;
-
-    fn from_str(s: &str) -> Result<SymbolVisibility, Self::Err> {
-        match s {
-            "hidden" => Ok(SymbolVisibility::Hidden),
-            "protected" => Ok(SymbolVisibility::Protected),
-            "interposable" => Ok(SymbolVisibility::Interposable),
-            _ => Err(format!(
-                "'{}' is not a valid value for \
-                    symbol-visibility. Use 'hidden', 'protected, or 'interposable'.",
-                s
-            )),
-        }
-    }
-}
-
-crate::json::serde_deserialize_from_str!(SymbolVisibility);
-
-impl ToJson for SymbolVisibility {
-    fn to_json(&self) -> Json {
-        match *self {
-            SymbolVisibility::Hidden => "hidden".to_json(),
-            SymbolVisibility::Protected => "protected".to_json(),
-            SymbolVisibility::Interposable => "interposable".to_json(),
-        }
-    }
-}
-
-impl FromStr for RelroLevel {
-    type Err = String;
-
-    fn from_str(s: &str) -> Result<RelroLevel, Self::Err> {
-        match s {
-            "full" => Ok(RelroLevel::Full),
-            "partial" => Ok(RelroLevel::Partial),
-            "off" => Ok(RelroLevel::Off),
-            "none" => Ok(RelroLevel::None),
-            _ => Err(format!(
-                "'{}' is not a valid value for \
-                        relro-level. Use 'full', 'partial, 'off', or 'none'.",
-                s
-            )),
-        }
-    }
-}
-
-crate::json::serde_deserialize_from_str!(RelroLevel);
-
-impl ToJson for RelroLevel {
-    fn to_json(&self) -> Json {
-        match *self {
-            RelroLevel::Full => "full".to_json(),
-            RelroLevel::Partial => "partial".to_json(),
-            RelroLevel::Off => "off".to_json(),
-            RelroLevel::None => "None".to_json(),
-        }
-    }
-}
 
 #[derive(Clone, Debug, PartialEq, Hash)]
 pub enum SmallDataThresholdSupport {
@@ -1026,76 +886,31 @@ impl ToJson for SmallDataThresholdSupport {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Hash)]
-pub enum MergeFunctions {
-    Disabled,
-    Trampolines,
-    Aliases,
-}
-
-impl MergeFunctions {
-    pub fn desc(&self) -> &str {
-        match *self {
-            MergeFunctions::Disabled => "disabled",
-            MergeFunctions::Trampolines => "trampolines",
-            MergeFunctions::Aliases => "aliases",
-        }
+crate::target_spec_enum! {
+    pub enum MergeFunctions {
+        Disabled = "disabled",
+        Trampolines = "trampolines",
+        Aliases = "aliases",
     }
-}
 
-impl FromStr for MergeFunctions {
-    type Err = String;
-
-    fn from_str(s: &str) -> Result<MergeFunctions, Self::Err> {
-        match s {
-            "disabled" => Ok(MergeFunctions::Disabled),
-            "trampolines" => Ok(MergeFunctions::Trampolines),
-            "aliases" => Ok(MergeFunctions::Aliases),
-            _ => Err(format!(
-                "'{}' is not a valid value for \
-                    merge-functions. Use 'disabled', \
-                    'trampolines', or 'aliases'.",
-                s
-            )),
-        }
-    }
+    parse_error_type = "value for merge-functions";
 }
 
-crate::json::serde_deserialize_from_str!(MergeFunctions);
-
-impl ToJson for MergeFunctions {
-    fn to_json(&self) -> Json {
-        match *self {
-            MergeFunctions::Disabled => "disabled".to_json(),
-            MergeFunctions::Trampolines => "trampolines".to_json(),
-            MergeFunctions::Aliases => "aliases".to_json(),
-        }
+crate::target_spec_enum! {
+    pub enum RelocModel {
+        Static = "static",
+        Pic = "pic",
+        Pie = "pie",
+        DynamicNoPic = "dynamic-no-pic",
+        Ropi = "ropi",
+        Rwpi = "rwpi",
+        RopiRwpi = "ropi-rwpi",
     }
-}
 
-#[derive(Clone, Copy, PartialEq, Hash, Debug)]
-pub enum RelocModel {
-    Static,
-    Pic,
-    Pie,
-    DynamicNoPic,
-    Ropi,
-    Rwpi,
-    RopiRwpi,
+    parse_error_type = "relocation model";
 }
 
 impl RelocModel {
-    pub fn desc(&self) -> &str {
-        match *self {
-            RelocModel::Static => "static",
-            RelocModel::Pic => "pic",
-            RelocModel::Pie => "pie",
-            RelocModel::DynamicNoPic => "dynamic-no-pic",
-            RelocModel::Ropi => "ropi",
-            RelocModel::Rwpi => "rwpi",
-            RelocModel::RopiRwpi => "ropi-rwpi",
-        }
-    }
     pub const fn desc_symbol(&self) -> Symbol {
         match *self {
             RelocModel::Static => kw::Static,
@@ -1121,236 +936,75 @@ impl RelocModel {
     }
 }
 
-impl FromStr for RelocModel {
-    type Err = String;
-
-    fn from_str(s: &str) -> Result<RelocModel, Self::Err> {
-        Ok(match s {
-            "static" => RelocModel::Static,
-            "pic" => RelocModel::Pic,
-            "pie" => RelocModel::Pie,
-            "dynamic-no-pic" => RelocModel::DynamicNoPic,
-            "ropi" => RelocModel::Ropi,
-            "rwpi" => RelocModel::Rwpi,
-            "ropi-rwpi" => RelocModel::RopiRwpi,
-            _ => {
-                return Err(format!(
-                    "invalid relocation model '{s}'.
-                        Run `rustc --print relocation-models` to \
-                        see the list of supported values.'"
-                ));
-            }
-        })
-    }
-}
-
-crate::json::serde_deserialize_from_str!(RelocModel);
-
-impl ToJson for RelocModel {
-    fn to_json(&self) -> Json {
-        self.desc().to_json()
+crate::target_spec_enum! {
+    pub enum CodeModel {
+        Tiny = "tiny",
+        Small = "small",
+        Kernel = "kernel",
+        Medium = "medium",
+        Large = "large",
     }
-}
 
-#[derive(Clone, Copy, PartialEq, Hash, Debug)]
-pub enum CodeModel {
-    Tiny,
-    Small,
-    Kernel,
-    Medium,
-    Large,
+    parse_error_type = "code model";
 }
 
-impl FromStr for CodeModel {
-    type Err = String;
-
-    fn from_str(s: &str) -> Result<CodeModel, Self::Err> {
-        Ok(match s {
-            "tiny" => CodeModel::Tiny,
-            "small" => CodeModel::Small,
-            "kernel" => CodeModel::Kernel,
-            "medium" => CodeModel::Medium,
-            "large" => CodeModel::Large,
-            _ => {
-                return Err(format!(
-                    "'{s}' is not a valid code model. \
-                        Run `rustc --print code-models` to \
-                        see the list of supported values."
-                ));
-            }
-        })
+crate::target_spec_enum! {
+    /// The float ABI setting to be configured in the LLVM target machine.
+    pub enum FloatAbi {
+        Soft = "soft",
+        Hard = "hard",
     }
-}
-
-crate::json::serde_deserialize_from_str!(CodeModel);
 
-impl ToJson for CodeModel {
-    fn to_json(&self) -> Json {
-        match *self {
-            CodeModel::Tiny => "tiny",
-            CodeModel::Small => "small",
-            CodeModel::Kernel => "kernel",
-            CodeModel::Medium => "medium",
-            CodeModel::Large => "large",
-        }
-        .to_json()
-    }
+    parse_error_type = "float abi";
 }
 
-/// The float ABI setting to be configured in the LLVM target machine.
-#[derive(Clone, Copy, PartialEq, Hash, Debug)]
-pub enum FloatAbi {
-    Soft,
-    Hard,
-}
-
-impl FromStr for FloatAbi {
-    type Err = String;
-
-    fn from_str(s: &str) -> Result<FloatAbi, Self::Err> {
-        Ok(match s {
-            "soft" => FloatAbi::Soft,
-            "hard" => FloatAbi::Hard,
-            _ => {
-                return Err(format!(
-                    "'{}' is not a valid value for \
-                        llvm-floatabi. Use 'soft' or 'hard'.",
-                    s
-                ));
-            }
-        })
-    }
-}
-
-crate::json::serde_deserialize_from_str!(FloatAbi);
-
-impl ToJson for FloatAbi {
-    fn to_json(&self) -> Json {
-        match *self {
-            FloatAbi::Soft => "soft",
-            FloatAbi::Hard => "hard",
-        }
-        .to_json()
+crate::target_spec_enum! {
+    /// The Rustc-specific variant of the ABI used for this target.
+    pub enum RustcAbi {
+        /// On x86-32 only: make use of SSE and SSE2 for ABI purposes.
+        X86Sse2 = "x86-sse2",
+        /// On x86-32/64 only: do not use any FPU or SIMD registers for the ABI.
+        X86Softfloat = "x86-softfloat",
     }
-}
 
-/// The Rustc-specific variant of the ABI used for this target.
-#[derive(Clone, Copy, PartialEq, Hash, Debug)]
-pub enum RustcAbi {
-    /// On x86-32 only: make use of SSE and SSE2 for ABI purposes.
-    X86Sse2,
-    /// On x86-32/64 only: do not use any FPU or SIMD registers for the ABI.
-    X86Softfloat,
-}
-
-impl FromStr for RustcAbi {
-    type Err = String;
-
-    fn from_str(s: &str) -> Result<RustcAbi, Self::Err> {
-        Ok(match s {
-            "x86-sse2" => RustcAbi::X86Sse2,
-            "x86-softfloat" => RustcAbi::X86Softfloat,
-            _ => {
-                return Err(format!(
-                    "'{s}' is not a valid value for rustc-abi. \
-                        Use 'x86-softfloat' or leave the field unset."
-                ));
-            }
-        })
-    }
+    parse_error_type = "rustc abi";
 }
 
-crate::json::serde_deserialize_from_str!(RustcAbi);
-
-impl ToJson for RustcAbi {
-    fn to_json(&self) -> Json {
-        match *self {
-            RustcAbi::X86Sse2 => "x86-sse2",
-            RustcAbi::X86Softfloat => "x86-softfloat",
-        }
-        .to_json()
+crate::target_spec_enum! {
+    pub enum TlsModel {
+        GeneralDynamic = "global-dynamic",
+        LocalDynamic = "local-dynamic",
+        InitialExec = "initial-exec",
+        LocalExec = "local-exec",
+        Emulated = "emulated",
     }
-}
-
-#[derive(Clone, Copy, PartialEq, Hash, Debug)]
-pub enum TlsModel {
-    GeneralDynamic,
-    LocalDynamic,
-    InitialExec,
-    LocalExec,
-    Emulated,
-}
-
-impl FromStr for TlsModel {
-    type Err = String;
 
-    fn from_str(s: &str) -> Result<TlsModel, Self::Err> {
-        Ok(match s {
-            // Note the difference "general" vs "global" difference. The model name is "general",
-            // but the user-facing option name is "global" for consistency with other compilers.
-            "global-dynamic" => TlsModel::GeneralDynamic,
-            "local-dynamic" => TlsModel::LocalDynamic,
-            "initial-exec" => TlsModel::InitialExec,
-            "local-exec" => TlsModel::LocalExec,
-            "emulated" => TlsModel::Emulated,
-            _ => {
-                return Err(format!(
-                    "'{s}' is not a valid TLS model. \
-                        Run `rustc --print tls-models` to \
-                        see the list of supported values."
-                ));
-            }
-        })
-    }
+    parse_error_type = "TLS model";
 }
 
-crate::json::serde_deserialize_from_str!(TlsModel);
-
-impl ToJson for TlsModel {
-    fn to_json(&self) -> Json {
-        match *self {
-            TlsModel::GeneralDynamic => "global-dynamic",
-            TlsModel::LocalDynamic => "local-dynamic",
-            TlsModel::InitialExec => "initial-exec",
-            TlsModel::LocalExec => "local-exec",
-            TlsModel::Emulated => "emulated",
-        }
-        .to_json()
+crate::target_spec_enum! {
+    /// Everything is flattened to a single enum to make the json encoding/decoding less annoying.
+    pub enum LinkOutputKind {
+        /// Dynamically linked non position-independent executable.
+        DynamicNoPicExe = "dynamic-nopic-exe",
+        /// Dynamically linked position-independent executable.
+        DynamicPicExe = "dynamic-pic-exe",
+        /// Statically linked non position-independent executable.
+        StaticNoPicExe = "static-nopic-exe",
+        /// Statically linked position-independent executable.
+        StaticPicExe = "static-pic-exe",
+        /// Regular dynamic library ("dynamically linked").
+        DynamicDylib = "dynamic-dylib",
+        /// Dynamic library with bundled libc ("statically linked").
+        StaticDylib = "static-dylib",
+        /// WASI module with a lifetime past the _initialize entry point
+        WasiReactorExe = "wasi-reactor-exe",
     }
-}
 
-/// Everything is flattened to a single enum to make the json encoding/decoding less annoying.
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)]
-pub enum LinkOutputKind {
-    /// Dynamically linked non position-independent executable.
-    DynamicNoPicExe,
-    /// Dynamically linked position-independent executable.
-    DynamicPicExe,
-    /// Statically linked non position-independent executable.
-    StaticNoPicExe,
-    /// Statically linked position-independent executable.
-    StaticPicExe,
-    /// Regular dynamic library ("dynamically linked").
-    DynamicDylib,
-    /// Dynamic library with bundled libc ("statically linked").
-    StaticDylib,
-    /// WASI module with a lifetime past the _initialize entry point
-    WasiReactorExe,
+    parse_error_type = "CRT object kind";
 }
 
 impl LinkOutputKind {
-    fn as_str(&self) -> &'static str {
-        match self {
-            LinkOutputKind::DynamicNoPicExe => "dynamic-nopic-exe",
-            LinkOutputKind::DynamicPicExe => "dynamic-pic-exe",
-            LinkOutputKind::StaticNoPicExe => "static-nopic-exe",
-            LinkOutputKind::StaticPicExe => "static-pic-exe",
-            LinkOutputKind::DynamicDylib => "dynamic-dylib",
-            LinkOutputKind::StaticDylib => "static-dylib",
-            LinkOutputKind::WasiReactorExe => "wasi-reactor-exe",
-        }
-    }
-
     pub fn can_link_dylib(self) -> bool {
         match self {
             LinkOutputKind::StaticNoPicExe | LinkOutputKind::StaticPicExe => false,
@@ -1363,166 +1017,59 @@ impl LinkOutputKind {
     }
 }
 
-impl FromStr for LinkOutputKind {
-    type Err = String;
-
-    fn from_str(s: &str) -> Result<LinkOutputKind, Self::Err> {
-        Ok(match s {
-            "dynamic-nopic-exe" => LinkOutputKind::DynamicNoPicExe,
-            "dynamic-pic-exe" => LinkOutputKind::DynamicPicExe,
-            "static-nopic-exe" => LinkOutputKind::StaticNoPicExe,
-            "static-pic-exe" => LinkOutputKind::StaticPicExe,
-            "dynamic-dylib" => LinkOutputKind::DynamicDylib,
-            "static-dylib" => LinkOutputKind::StaticDylib,
-            "wasi-reactor-exe" => LinkOutputKind::WasiReactorExe,
-            _ => {
-                return Err(format!(
-                    "invalid value for CRT object kind. \
-                        Use '(dynamic,static)-(nopic,pic)-exe' or \
-                        '(dynamic,static)-dylib' or 'wasi-reactor-exe'"
-                ));
-            }
-        })
-    }
-}
-
-crate::json::serde_deserialize_from_str!(LinkOutputKind);
-
-impl fmt::Display for LinkOutputKind {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str(self.as_str())
-    }
-}
-
 pub type LinkArgs = BTreeMap<LinkerFlavor, Vec<StaticCow<str>>>;
 pub type LinkArgsCli = BTreeMap<LinkerFlavorCli, Vec<StaticCow<str>>>;
 
-/// Which kind of debuginfo does the target use?
-///
-/// Useful in determining whether a target supports Split DWARF (a target with
-/// `DebuginfoKind::Dwarf` and supporting `SplitDebuginfo::Unpacked` for example).
-#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
-pub enum DebuginfoKind {
-    /// DWARF debuginfo (such as that used on `x86_64_unknown_linux_gnu`).
-    #[default]
-    Dwarf,
-    /// DWARF debuginfo in dSYM files (such as on Apple platforms).
-    DwarfDsym,
-    /// Program database files (such as on Windows).
-    Pdb,
-}
-
-impl DebuginfoKind {
-    fn as_str(&self) -> &'static str {
-        match self {
-            DebuginfoKind::Dwarf => "dwarf",
-            DebuginfoKind::DwarfDsym => "dwarf-dsym",
-            DebuginfoKind::Pdb => "pdb",
-        }
-    }
-}
-
-impl FromStr for DebuginfoKind {
-    type Err = String;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(match s {
-            "dwarf" => DebuginfoKind::Dwarf,
-            "dwarf-dsym" => DebuginfoKind::DwarfDsym,
-            "pdb" => DebuginfoKind::Pdb,
-            _ => {
-                return Err(format!(
-                    "'{s}' is not a valid value for debuginfo-kind. Use 'dwarf', \
-                        'dwarf-dsym' or 'pdb'."
-                ));
-            }
-        })
-    }
-}
-
-crate::json::serde_deserialize_from_str!(DebuginfoKind);
-
-impl ToJson for DebuginfoKind {
-    fn to_json(&self) -> Json {
-        self.as_str().to_json()
-    }
-}
-
-impl fmt::Display for DebuginfoKind {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str(self.as_str())
-    }
-}
-
-#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
-pub enum SplitDebuginfo {
-    /// Split debug-information is disabled, meaning that on supported platforms
-    /// you can find all debug information in the executable itself. This is
-    /// only supported for ELF effectively.
-    ///
-    /// * Windows - not supported
-    /// * macOS - don't run `dsymutil`
-    /// * ELF - `.debug_*` sections
-    #[default]
-    Off,
-
-    /// Split debug-information can be found in a "packed" location separate
-    /// from the final artifact. This is supported on all platforms.
+crate::target_spec_enum! {
+    /// Which kind of debuginfo does the target use?
     ///
-    /// * Windows - `*.pdb`
-    /// * macOS - `*.dSYM` (run `dsymutil`)
-    /// * ELF - `*.dwp` (run `thorin`)
-    Packed,
-
-    /// Split debug-information can be found in individual object files on the
-    /// filesystem. The main executable may point to the object files.
-    ///
-    /// * Windows - not supported
-    /// * macOS - supported, scattered object files
-    /// * ELF - supported, scattered `*.dwo` or `*.o` files (see `SplitDwarfKind`)
-    Unpacked,
-}
-
-impl SplitDebuginfo {
-    fn as_str(&self) -> &'static str {
-        match self {
-            SplitDebuginfo::Off => "off",
-            SplitDebuginfo::Packed => "packed",
-            SplitDebuginfo::Unpacked => "unpacked",
-        }
-    }
-}
-
-impl FromStr for SplitDebuginfo {
-    type Err = String;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(match s {
-            "off" => SplitDebuginfo::Off,
-            "unpacked" => SplitDebuginfo::Unpacked,
-            "packed" => SplitDebuginfo::Packed,
-            _ => {
-                return Err(format!(
-                    "'{s}' is not a valid value for \
-                        split-debuginfo. Use 'off', 'unpacked', or 'packed'.",
-                ));
-            }
-        })
-    }
-}
-
-crate::json::serde_deserialize_from_str!(SplitDebuginfo);
-
-impl ToJson for SplitDebuginfo {
-    fn to_json(&self) -> Json {
-        self.as_str().to_json()
-    }
-}
-
-impl fmt::Display for SplitDebuginfo {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str(self.as_str())
-    }
+    /// Useful in determining whether a target supports Split DWARF (a target with
+    /// `DebuginfoKind::Dwarf` and supporting `SplitDebuginfo::Unpacked` for example).
+    #[derive(Default)]
+    pub enum DebuginfoKind {
+        /// DWARF debuginfo (such as that used on `x86_64_unknown_linux_gnu`).
+        #[default]
+        Dwarf = "dwarf",
+        /// DWARF debuginfo in dSYM files (such as on Apple platforms).
+        DwarfDsym = "dwarf-dsym",
+        /// Program database files (such as on Windows).
+        Pdb = "pdb",
+    }
+
+    parse_error_type = "debuginfo kind";
+}
+
+crate::target_spec_enum! {
+    #[derive(Default)]
+    pub enum SplitDebuginfo {
+        /// Split debug-information is disabled, meaning that on supported platforms
+        /// you can find all debug information in the executable itself. This is
+        /// only supported for ELF effectively.
+        ///
+        /// * Windows - not supported
+        /// * macOS - don't run `dsymutil`
+        /// * ELF - `.debug_*` sections
+        #[default]
+        Off = "off",
+
+        /// Split debug-information can be found in a "packed" location separate
+        /// from the final artifact. This is supported on all platforms.
+        ///
+        /// * Windows - `*.pdb`
+        /// * macOS - `*.dSYM` (run `dsymutil`)
+        /// * ELF - `*.dwp` (run `thorin`)
+        Packed = "packed",
+
+        /// Split debug-information can be found in individual object files on the
+        /// filesystem. The main executable may point to the object files.
+        ///
+        /// * Windows - not supported
+        /// * macOS - supported, scattered object files
+        /// * ELF - supported, scattered `*.dwo` or `*.o` files (see `SplitDwarfKind`)
+        Unpacked = "unpacked",
+    }
+
+    parse_error_type = "split debuginfo";
 }
 
 into_diag_arg_using_display!(SplitDebuginfo);
@@ -1699,17 +1246,20 @@ impl ToJson for SanitizerSet {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Hash, Debug)]
-pub enum FramePointer {
-    /// Forces the machine code generator to always preserve the frame pointers.
-    Always,
-    /// Forces the machine code generator to preserve the frame pointers except for the leaf
-    /// functions (i.e. those that don't call other functions).
-    NonLeaf,
-    /// Allows the machine code generator to omit the frame pointers.
-    ///
-    /// This option does not guarantee that the frame pointers will be omitted.
-    MayOmit,
+crate::target_spec_enum! {
+    pub enum FramePointer {
+        /// Forces the machine code generator to always preserve the frame pointers.
+        Always = "always",
+        /// Forces the machine code generator to preserve the frame pointers except for the leaf
+        /// functions (i.e. those that don't call other functions).
+        NonLeaf = "non-leaf",
+        /// Allows the machine code generator to omit the frame pointers.
+        ///
+        /// This option does not guarantee that the frame pointers will be omitted.
+        MayOmit = "may-omit",
+    }
+
+    parse_error_type = "frame pointer";
 }
 
 impl FramePointer {
@@ -1726,93 +1276,43 @@ impl FramePointer {
     }
 }
 
-impl FromStr for FramePointer {
-    type Err = String;
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(match s {
-            "always" => Self::Always,
-            "non-leaf" => Self::NonLeaf,
-            "may-omit" => Self::MayOmit,
-            _ => return Err(format!("'{s}' is not a valid value for frame-pointer")),
-        })
-    }
-}
-
-crate::json::serde_deserialize_from_str!(FramePointer);
-
-impl ToJson for FramePointer {
-    fn to_json(&self) -> Json {
-        match *self {
-            Self::Always => "always",
-            Self::NonLeaf => "non-leaf",
-            Self::MayOmit => "may-omit",
-        }
-        .to_json()
-    }
-}
-
-/// Controls use of stack canaries.
-#[derive(Clone, Copy, Debug, PartialEq, Hash, Eq)]
-pub enum StackProtector {
-    /// Disable stack canary generation.
-    None,
+crate::target_spec_enum! {
+    /// Controls use of stack canaries.
+    pub enum StackProtector {
+        /// Disable stack canary generation.
+        None = "none",
 
-    /// On LLVM, mark all generated LLVM functions with the `ssp` attribute (see
-    /// llvm/docs/LangRef.rst). This triggers stack canary generation in
-    /// functions which contain an array of a byte-sized type with more than
-    /// eight elements.
-    Basic,
+        /// On LLVM, mark all generated LLVM functions with the `ssp` attribute (see
+        /// llvm/docs/LangRef.rst). This triggers stack canary generation in
+        /// functions which contain an array of a byte-sized type with more than
+        /// eight elements.
+        Basic = "basic",
 
-    /// On LLVM, mark all generated LLVM functions with the `sspstrong`
-    /// attribute (see llvm/docs/LangRef.rst). This triggers stack canary
-    /// generation in functions which either contain an array, or which take
-    /// the address of a local variable.
-    Strong,
+        /// On LLVM, mark all generated LLVM functions with the `sspstrong`
+        /// attribute (see llvm/docs/LangRef.rst). This triggers stack canary
+        /// generation in functions which either contain an array, or which take
+        /// the address of a local variable.
+        Strong = "strong",
 
-    /// Generate stack canaries in all functions.
-    All,
-}
-
-impl StackProtector {
-    fn as_str(&self) -> &'static str {
-        match self {
-            StackProtector::None => "none",
-            StackProtector::Basic => "basic",
-            StackProtector::Strong => "strong",
-            StackProtector::All => "all",
-        }
+        /// Generate stack canaries in all functions.
+        All = "all",
     }
-}
-
-impl FromStr for StackProtector {
-    type Err = ();
 
-    fn from_str(s: &str) -> Result<StackProtector, ()> {
-        Ok(match s {
-            "none" => StackProtector::None,
-            "basic" => StackProtector::Basic,
-            "strong" => StackProtector::Strong,
-            "all" => StackProtector::All,
-            _ => return Err(()),
-        })
-    }
-}
-
-impl fmt::Display for StackProtector {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str(self.as_str())
-    }
+    parse_error_type = "stack protector";
 }
 
 into_diag_arg_using_display!(StackProtector);
 
-#[derive(PartialEq, Clone, Debug)]
-pub enum BinaryFormat {
-    Coff,
-    Elf,
-    MachO,
-    Wasm,
-    Xcoff,
+crate::target_spec_enum! {
+    pub enum BinaryFormat {
+        Coff = "coff",
+        Elf = "elf",
+        MachO = "mach-o",
+        Wasm = "wasm",
+        Xcoff = "xcoff",
+    }
+
+    parse_error_type = "binary format";
 }
 
 impl BinaryFormat {
@@ -1828,37 +1328,6 @@ impl BinaryFormat {
     }
 }
 
-impl FromStr for BinaryFormat {
-    type Err = String;
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "coff" => Ok(Self::Coff),
-            "elf" => Ok(Self::Elf),
-            "mach-o" => Ok(Self::MachO),
-            "wasm" => Ok(Self::Wasm),
-            "xcoff" => Ok(Self::Xcoff),
-            _ => Err(format!(
-                "'{s}' is not a valid value for binary_format. \
-                    Use 'coff', 'elf', 'mach-o', 'wasm' or 'xcoff' "
-            )),
-        }
-    }
-}
-
-crate::json::serde_deserialize_from_str!(BinaryFormat);
-
-impl ToJson for BinaryFormat {
-    fn to_json(&self) -> Json {
-        match self {
-            Self::Coff => "coff",
-            Self::Elf => "elf",
-            Self::MachO => "mach-o",
-            Self::Wasm => "wasm",
-            Self::Xcoff => "xcoff",
-        }
-        .to_json()
-    }
-}
 
 impl ToJson for Align {
     fn to_json(&self) -> Json {

From 43d45ef2da29aa438c32b5c872bc7a367ef2a2ab Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Fri, 12 Sep 2025 11:32:51 -0700
Subject: [PATCH 0860/1889] rustdoc-search: reduce async machinery in value
 lookups

This commit is a mirrored change from stringdex that
makes `at()` not always return a promise, which is fine because
we can still `await` it.
---
 src/librustdoc/html/static/js/search.js      |  8 +-
 src/librustdoc/html/static/js/stringdex.d.ts |  2 +-
 src/librustdoc/html/static/js/stringdex.js   | 97 +++++++++++---------
 3 files changed, 57 insertions(+), 50 deletions(-)

diff --git a/src/librustdoc/html/static/js/search.js b/src/librustdoc/html/static/js/search.js
index 3b84ae2bed060..339b101d47111 100644
--- a/src/librustdoc/html/static/js/search.js
+++ b/src/librustdoc/html/static/js/search.js
@@ -1758,12 +1758,8 @@ class DocSearch {
         const l = crateNames.length;
         const names = [];
         for (let i = 0; i < l; ++i) {
-            names.push(crateNames.at(i).then(name => {
-                if (name === undefined) {
-                    return "";
-                }
-                return this.utf8decoder.decode(name);
-            }));
+            const name = await crateNames.at(i);
+            names.push(name === undefined ? "" : this.utf8decoder.decode(name));
         }
         return Promise.all(names);
     }
diff --git a/src/librustdoc/html/static/js/stringdex.d.ts b/src/librustdoc/html/static/js/stringdex.d.ts
index 2eb1fdf95d845..71c6bfdf48145 100644
--- a/src/librustdoc/html/static/js/stringdex.d.ts
+++ b/src/librustdoc/html/static/js/stringdex.d.ts
@@ -29,7 +29,7 @@ declare namespace stringdex {
      */
     interface DataColumn {
         isEmpty(id: number): boolean;
-        at(id: number): Promise<Uint8Array|undefined>;
+        at(id: number): Promise<Uint8Array>|Uint8Array|undefined;
         search(name: Uint8Array|string): Promise<Trie?>;
         searchLev(name: Uint8Array|string): AsyncGenerator<Trie>;
         length: number,
diff --git a/src/librustdoc/html/static/js/stringdex.js b/src/librustdoc/html/static/js/stringdex.js
index b7f605a10351d..4c4659628778d 100644
--- a/src/librustdoc/html/static/js/stringdex.js
+++ b/src/librustdoc/html/static/js/stringdex.js
@@ -2261,7 +2261,7 @@ function loadDatabase(hooks) {
             this.hashes = hashes;
             this.emptyset = emptyset;
             this.name = name;
-            /** @type {{"hash": Uint8Array, "data": Promise<Uint8Array[]>?, "end": number}[]} */
+            /** @type {{"hash": Uint8Array, "data": Uint8Array[]?, "end": number}[]} */
             this.buckets = [];
             this.bucket_keys = [];
             const l = counts.length;
@@ -2295,64 +2295,75 @@ function loadDatabase(hooks) {
         /**
          * Look up a cell by row ID.
          * @param {number} id
-         * @returns {Promise<Uint8Array|undefined>}
+         * @returns {Promise<Uint8Array>|Uint8Array|undefined}
          */
-        async at(id) {
+        at(id) {
             if (this.emptyset.contains(id)) {
-                return Promise.resolve(EMPTY_UINT8);
+                return EMPTY_UINT8;
             } else {
                 let idx = -1;
                 while (this.bucket_keys[idx + 1] <= id) {
                     idx += 1;
                 }
                 if (idx === -1 || idx >= this.bucket_keys.length) {
-                    return Promise.resolve(undefined);
+                    return undefined;
                 } else {
                     const start = this.bucket_keys[idx];
-                    const {hash, end} = this.buckets[idx];
+                    const bucket = this.buckets[idx];
                     let data = this.buckets[idx].data;
                     if (data === null) {
-                        const dataSansEmptysetOrig = await registry.dataLoadByNameAndHash(
-                            this.name,
-                            hash,
-                        );
-                        // After the `await` resolves, another task might fill
-                        // in the data. If so, we should use that.
-                        data = this.buckets[idx].data;
-                        if (data !== null) {
-                            return (await data)[id - start];
-                        }
-                        const dataSansEmptyset = [...dataSansEmptysetOrig];
-                        /** @type {(Uint8Array[])|null} */
-                        let dataWithEmptyset = null;
-                        let pos = start;
-                        let insertCount = 0;
-                        while (pos < end) {
-                            if (this.emptyset.contains(pos)) {
-                                if (dataWithEmptyset === null) {
-                                    dataWithEmptyset = dataSansEmptyset.splice(0, insertCount);
-                                } else if (insertCount !== 0) {
-                                    dataWithEmptyset.push(
-                                        ...dataSansEmptyset.splice(0, insertCount),
-                                    );
-                                }
-                                insertCount = 0;
-                                dataWithEmptyset.push(EMPTY_UINT8);
-                            } else {
-                                insertCount += 1;
-                            }
-                            pos += 1;
-                        }
-                        data = Promise.resolve(
-                            dataWithEmptyset === null ?
-                                dataSansEmptyset :
-                                dataWithEmptyset.concat(dataSansEmptyset),
+                        return this.atAsyncFetch(id, start, bucket);
+                    } else {
+                        return data[id - start];
+                    }
+                }
+            }
+        }
+        /**
+         * Look up a cell by row ID.
+         * @param {number} id
+         * @param {number} start
+         * @param {{hash: Uint8Array, data: Uint8Array[] | null, end: number}} bucket
+         * @returns {Promise<Uint8Array>}
+         */
+        async atAsyncFetch(id, start, bucket) {
+            const {hash, end} = bucket;
+            const dataSansEmptysetOrig = await registry.dataLoadByNameAndHash(
+                this.name,
+                hash,
+            );
+            // After the `await` resolves, another task might fill
+            // in the data. If so, we should use that.
+            let data = bucket.data;
+            if (data !== null) {
+                return data[id - start];
+            }
+            const dataSansEmptyset = [...dataSansEmptysetOrig];
+            /** @type {(Uint8Array[])|null} */
+            let dataWithEmptyset = null;
+            let pos = start;
+            let insertCount = 0;
+            while (pos < end) {
+                if (this.emptyset.contains(pos)) {
+                    if (dataWithEmptyset === null) {
+                        dataWithEmptyset = dataSansEmptyset.splice(0, insertCount);
+                    } else if (insertCount !== 0) {
+                        dataWithEmptyset.push(
+                            ...dataSansEmptyset.splice(0, insertCount),
                         );
-                        this.buckets[idx].data = data;
                     }
-                    return (await data)[id - start];
+                    insertCount = 0;
+                    dataWithEmptyset.push(EMPTY_UINT8);
+                } else {
+                    insertCount += 1;
                 }
+                pos += 1;
             }
+            data = dataWithEmptyset === null ?
+                dataSansEmptyset :
+                dataWithEmptyset.concat(dataSansEmptyset);
+            bucket.data = data;
+            return data[id - start];
         }
         /**
          * Search by exact substring

From 957fa10d50787a4c6c6d8a35be5af6bd43ba1770 Mon Sep 17 00:00:00 2001
From: Oneirical <manchot@videotron.ca>
Date: Wed, 20 Aug 2025 14:02:50 -0400
Subject: [PATCH 0861/1889] Add test batch 3

---
 .../invalid-self-parameter-type-56806.rs}     |  1 +
 .../invalid-self-parameter-type-56806.stderr} |  2 +-
 .../traits-associated-consts-ice-56870.rs}    |  1 +
 ...icate-associated-type-resolution-59326.rs} |  1 +
 ...mpl-trait-member-type-resolution-57399.rs} |  2 +-
 .../function-comparison-errors-59488.rs}      |  1 +
 .../function-comparison-errors-59488.stderr}  | 20 +++++++++----------
 .../boxed-value-matching-57741.rs}            |  1 +
 .../boxed-value-matching-57741.stderr}        |  4 ++--
 ...ferencing-boxed-enum-in-match-57741.fixed} |  1 +
 ...ereferencing-boxed-enum-in-match-57741.rs} |  1 +
 ...erencing-boxed-enum-in-match-57741.stderr} |  8 ++++----
 .../generic-typed-nested-closures-59494.rs}   |  1 +
 ...eneric-typed-nested-closures-59494.stderr} |  2 +-
 ...mono-item-collector-default-impl-58375.rs} |  1 +
 ...t-implementation-coherence-check-57162.rs} |  1 +
 .../oncecell-const-init-57781.rs}             |  1 +
 .../impl-copy-function-debuginfo-58463.rs}    |  1 +
 .../spurious-dyn-compat-errors-58734.rs}      |  1 +
 .../spurious-dyn-compat-errors-58734.stderr}  |  6 +++---
 ...ric-associated-type-deref-target-56237.rs} |  1 +
 .../hrtb-associated-type-leak-check-55731.rs} |  1 +
 ...b-associated-type-leak-check-55731.stderr} |  2 +-
 .../auxiliary/reexported-trait-56175.rs       | 17 ++++++++++++++++
 ...s-suggested-without-extern-crate-56175.rs} |  3 ++-
 ...ggested-without-extern-crate-56175.stderr} | 12 +++++------
 .../auxiliary/aux-57271-lib.rs}               |  0
 ...utually-recursive-infinite-types-57271.rs} |  7 ++++---
 ...lly-recursive-infinite-types-57271.stderr} |  2 +-
 tests/ui/issues/issue-56943.rs                |  8 --------
 .../raw-identifier-for-function-57198.rs}     |  1 +
 .../auxiliary/aux-56943.rs}                   |  0
 .../type-mismatch-in-extern-crate-56943.rs    |  9 +++++++++
 ...ype-mismatch-in-extern-crate-56943.stderr} |  6 +++---
 .../pub-use-handling-in-modules-56128.rs}     |  0
 .../invalid-variable-definition-55587.rs}     |  1 +
 .../invalid-variable-definition-55587.stderr} |  2 +-
 .../missing-type-in-scope-58712.rs}           |  1 +
 .../missing-type-in-scope-58712.stderr}       |  4 ++--
 .../park-timeout-wakeup-59020.rs}             |  1 +
 .../invalid-self-constructor-56835.rs}        |  1 +
 .../invalid-self-constructor-56835.stderr}    |  4 ++--
 ...tible-types-in-try-expression-59756.fixed} |  0
 ...mpatible-types-in-try-expression-59756.rs} |  1 +
 ...ible-types-in-try-expression-59756.stderr} |  2 +-
 .../negative-bound-not-supported-58857.rs}    |  1 +
 ...negative-bound-not-supported-58857.stderr} |  2 +-
 ...generic-trait-impl-aliased-array-58212.rs} |  1 +
 .../trait-object-lifetime-bounds-57156.rs}    |  1 +
 .../trait-objects-with-supertraits-56229.rs}  |  1 +
 ...onstructor-type-args-not-allowed-57924.rs} |  1 +
 ...ructor-type-args-not-allowed-57924.stderr} |  2 +-
 .../self-constructor-type-error-56199.rs}     |  1 +
 .../self-constructor-type-error-56199.stderr} |  8 ++++----
 54 files changed, 104 insertions(+), 57 deletions(-)
 rename tests/ui/{issues/issue-56806.rs => abi/invalid-self-parameter-type-56806.rs} (72%)
 rename tests/ui/{issues/issue-56806.stderr => abi/invalid-self-parameter-type-56806.stderr} (91%)
 rename tests/ui/{issues/issue-56870.rs => associated-consts/traits-associated-consts-ice-56870.rs} (93%)
 rename tests/ui/{issues/issue-59326.rs => associated-types/duplicate-associated-type-resolution-59326.rs} (89%)
 rename tests/ui/{issues/issue-57399-self-return-impl-trait.rs => associated-types/impl-trait-member-type-resolution-57399.rs} (81%)
 rename tests/ui/{issues/issue-59488.rs => binop/function-comparison-errors-59488.rs} (95%)
 rename tests/ui/{issues/issue-59488.stderr => binop/function-comparison-errors-59488.stderr} (84%)
 rename tests/ui/{issues/issue-57741-dereference-boxed-value/issue-57741-1.rs => box/boxed-value-matching-57741.rs} (89%)
 rename tests/ui/{issues/issue-57741-dereference-boxed-value/issue-57741-1.stderr => box/boxed-value-matching-57741.stderr} (88%)
 rename tests/ui/{issues/issue-57741-dereference-boxed-value/issue-57741.fixed => box/dereferencing-boxed-enum-in-match-57741.fixed} (92%)
 rename tests/ui/{issues/issue-57741-dereference-boxed-value/issue-57741.rs => box/dereferencing-boxed-enum-in-match-57741.rs} (92%)
 rename tests/ui/{issues/issue-57741-dereference-boxed-value/issue-57741.stderr => box/dereferencing-boxed-enum-in-match-57741.stderr} (87%)
 rename tests/ui/{issues/issue-59494.rs => closures/generic-typed-nested-closures-59494.rs} (91%)
 rename tests/ui/{issues/issue-59494.stderr => closures/generic-typed-nested-closures-59494.stderr} (83%)
 rename tests/ui/{issues/issue-58375-monomorphize-default-impls.rs => codegen/mono-item-collector-default-impl-58375.rs} (90%)
 rename tests/ui/{issues/issue-57162.rs => coherence/trait-implementation-coherence-check-57162.rs} (67%)
 rename tests/ui/{issues/issue-57781.rs => consts/oncecell-const-init-57781.rs} (86%)
 rename tests/ui/{issues/issue-58463.rs => debuginfo/impl-copy-function-debuginfo-58463.rs} (67%)
 rename tests/ui/{issues/issue-58734.rs => dyn-compatibility/spurious-dyn-compat-errors-58734.rs} (91%)
 rename tests/ui/{issues/issue-58734.stderr => dyn-compatibility/spurious-dyn-compat-errors-58734.stderr} (91%)
 rename tests/ui/{issues/issue-56237.rs => generics/generic-associated-type-deref-target-56237.rs} (77%)
 rename tests/ui/{issues/issue-55731.rs => higher-ranked/hrtb-associated-type-leak-check-55731.rs} (95%)
 rename tests/ui/{issues/issue-55731.stderr => higher-ranked/hrtb-associated-type-leak-check-55731.stderr} (90%)
 create mode 100644 tests/ui/imports/auxiliary/reexported-trait-56175.rs
 rename tests/ui/{issues/issue-56175.rs => imports/private-types-suggested-without-extern-crate-56175.rs} (59%)
 rename tests/ui/{issues/issue-56175.stderr => imports/private-types-suggested-without-extern-crate-56175.stderr} (82%)
 rename tests/ui/{issues/auxiliary/issue-57271-lib.rs => infinite/auxiliary/aux-57271-lib.rs} (100%)
 rename tests/ui/{issues/issue-57271.rs => infinite/mutually-recursive-infinite-types-57271.rs} (72%)
 rename tests/ui/{issues/issue-57271.stderr => infinite/mutually-recursive-infinite-types-57271.stderr} (92%)
 delete mode 100644 tests/ui/issues/issue-56943.rs
 rename tests/ui/{issues/issue-57198-pass.rs => keyword/raw-identifier-for-function-57198.rs} (60%)
 rename tests/ui/{issues/auxiliary/issue-56943.rs => mismatched_types/auxiliary/aux-56943.rs} (100%)
 create mode 100644 tests/ui/mismatched_types/type-mismatch-in-extern-crate-56943.rs
 rename tests/ui/{issues/issue-56943.stderr => mismatched_types/type-mismatch-in-extern-crate-56943.stderr} (54%)
 rename tests/ui/{issues/issue-56128.rs => modules/pub-use-handling-in-modules-56128.rs} (100%)
 rename tests/ui/{issues/issue-55587.rs => parser/invalid-variable-definition-55587.rs} (67%)
 rename tests/ui/{issues/issue-55587.stderr => parser/invalid-variable-definition-55587.stderr} (88%)
 rename tests/ui/{issues/issue-58712.rs => resolve/missing-type-in-scope-58712.rs} (84%)
 rename tests/ui/{issues/issue-58712.stderr => resolve/missing-type-in-scope-58712.stderr} (85%)
 rename tests/ui/{issues/issue-59020.rs => std/park-timeout-wakeup-59020.rs} (92%)
 rename tests/ui/{issues/issue-56835.rs => structs/invalid-self-constructor-56835.rs} (83%)
 rename tests/ui/{issues/issue-56835.stderr => structs/invalid-self-constructor-56835.stderr} (83%)
 rename tests/ui/{issues/issue-59756.fixed => suggestions/incompatible-types-in-try-expression-59756.fixed} (100%)
 rename tests/ui/{issues/issue-59756.rs => suggestions/incompatible-types-in-try-expression-59756.rs} (89%)
 rename tests/ui/{issues/issue-59756.stderr => suggestions/incompatible-types-in-try-expression-59756.stderr} (88%)
 rename tests/ui/{issues/issue-58857.rs => trait-bounds/negative-bound-not-supported-58857.rs} (71%)
 rename tests/ui/{issues/issue-58857.stderr => trait-bounds/negative-bound-not-supported-58857.stderr} (71%)
 rename tests/ui/{issues/issue-58212.rs => traits/generic-trait-impl-aliased-array-58212.rs} (82%)
 rename tests/ui/{issues/issue-57156.rs => traits/trait-object-lifetime-bounds-57156.rs} (88%)
 rename tests/ui/{issues/issue-56229.rs => traits/trait-objects-with-supertraits-56229.rs} (90%)
 rename tests/ui/{issues/issue-57924.rs => typeck/self-constructor-type-args-not-allowed-57924.rs} (78%)
 rename tests/ui/{issues/issue-57924.stderr => typeck/self-constructor-type-args-not-allowed-57924.stderr} (83%)
 rename tests/ui/{issues/issue-56199.rs => typeck/self-constructor-type-error-56199.rs} (91%)
 rename tests/ui/{issues/issue-56199.stderr => typeck/self-constructor-type-error-56199.stderr} (79%)

diff --git a/tests/ui/issues/issue-56806.rs b/tests/ui/abi/invalid-self-parameter-type-56806.rs
similarity index 72%
rename from tests/ui/issues/issue-56806.rs
rename to tests/ui/abi/invalid-self-parameter-type-56806.rs
index b1dac26d65a15..60229df300577 100644
--- a/tests/ui/issues/issue-56806.rs
+++ b/tests/ui/abi/invalid-self-parameter-type-56806.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/56806
 pub trait Trait {
     fn dyn_instead_of_self(self: Box<dyn Trait>);
     //~^ ERROR invalid `self` parameter type
diff --git a/tests/ui/issues/issue-56806.stderr b/tests/ui/abi/invalid-self-parameter-type-56806.stderr
similarity index 91%
rename from tests/ui/issues/issue-56806.stderr
rename to tests/ui/abi/invalid-self-parameter-type-56806.stderr
index ec50d863758db..ac249b8f10880 100644
--- a/tests/ui/issues/issue-56806.stderr
+++ b/tests/ui/abi/invalid-self-parameter-type-56806.stderr
@@ -1,5 +1,5 @@
 error[E0307]: invalid `self` parameter type: `Box<(dyn Trait + 'static)>`
-  --> $DIR/issue-56806.rs:2:34
+  --> $DIR/invalid-self-parameter-type-56806.rs:3:34
    |
 LL |     fn dyn_instead_of_self(self: Box<dyn Trait>);
    |                                  ^^^^^^^^^^^^^^
diff --git a/tests/ui/issues/issue-56870.rs b/tests/ui/associated-consts/traits-associated-consts-ice-56870.rs
similarity index 93%
rename from tests/ui/issues/issue-56870.rs
rename to tests/ui/associated-consts/traits-associated-consts-ice-56870.rs
index fc6deedd029f1..0c5a2b8477309 100644
--- a/tests/ui/issues/issue-56870.rs
+++ b/tests/ui/associated-consts/traits-associated-consts-ice-56870.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/56870
 //@ build-pass
 // Regression test for #56870: Internal compiler error (traits & associated consts)
 
diff --git a/tests/ui/issues/issue-59326.rs b/tests/ui/associated-types/duplicate-associated-type-resolution-59326.rs
similarity index 89%
rename from tests/ui/issues/issue-59326.rs
rename to tests/ui/associated-types/duplicate-associated-type-resolution-59326.rs
index e9634ad9fd8fe..0439e229e1493 100644
--- a/tests/ui/issues/issue-59326.rs
+++ b/tests/ui/associated-types/duplicate-associated-type-resolution-59326.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/59326
 //@ check-pass
 trait Service {
     type S;
diff --git a/tests/ui/issues/issue-57399-self-return-impl-trait.rs b/tests/ui/associated-types/impl-trait-member-type-resolution-57399.rs
similarity index 81%
rename from tests/ui/issues/issue-57399-self-return-impl-trait.rs
rename to tests/ui/associated-types/impl-trait-member-type-resolution-57399.rs
index bcf1b18a9ff43..3342dd0631a51 100644
--- a/tests/ui/issues/issue-57399-self-return-impl-trait.rs
+++ b/tests/ui/associated-types/impl-trait-member-type-resolution-57399.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/57399
 //@ check-pass
 
 trait T {
@@ -12,7 +13,6 @@ struct S<A> {
     a: A,
 }
 
-
 impl From<u32> for S<<i32 as T>::T> {
     fn from(a: u32) -> Self {
         Self { a }
diff --git a/tests/ui/issues/issue-59488.rs b/tests/ui/binop/function-comparison-errors-59488.rs
similarity index 95%
rename from tests/ui/issues/issue-59488.rs
rename to tests/ui/binop/function-comparison-errors-59488.rs
index 384501e3e5dfd..8ded781ef9547 100644
--- a/tests/ui/issues/issue-59488.rs
+++ b/tests/ui/binop/function-comparison-errors-59488.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/59488
 fn foo() -> i32 {
     42
 }
diff --git a/tests/ui/issues/issue-59488.stderr b/tests/ui/binop/function-comparison-errors-59488.stderr
similarity index 84%
rename from tests/ui/issues/issue-59488.stderr
rename to tests/ui/binop/function-comparison-errors-59488.stderr
index b6611ad63a810..615458bc45b40 100644
--- a/tests/ui/issues/issue-59488.stderr
+++ b/tests/ui/binop/function-comparison-errors-59488.stderr
@@ -1,5 +1,5 @@
 error[E0369]: binary operation `>` cannot be applied to type `fn() -> i32 {foo}`
-  --> $DIR/issue-59488.rs:14:9
+  --> $DIR/function-comparison-errors-59488.rs:15:9
    |
 LL |     foo > 12;
    |     --- ^ -- {integer}
@@ -12,7 +12,7 @@ LL |     foo() > 12;
    |        ++
 
 error[E0308]: mismatched types
-  --> $DIR/issue-59488.rs:14:11
+  --> $DIR/function-comparison-errors-59488.rs:15:11
    |
 LL |     foo > 12;
    |           ^^ expected fn item, found `i32`
@@ -21,7 +21,7 @@ LL |     foo > 12;
                  found type `i32`
 
 error[E0369]: binary operation `>` cannot be applied to type `fn(i64) -> i64 {bar}`
-  --> $DIR/issue-59488.rs:18:9
+  --> $DIR/function-comparison-errors-59488.rs:19:9
    |
 LL |     bar > 13;
    |     --- ^ -- {integer}
@@ -34,7 +34,7 @@ LL |     bar(/* i64 */) > 13;
    |        +++++++++++
 
 error[E0308]: mismatched types
-  --> $DIR/issue-59488.rs:18:11
+  --> $DIR/function-comparison-errors-59488.rs:19:11
    |
 LL |     bar > 13;
    |           ^^ expected fn item, found `i64`
@@ -43,7 +43,7 @@ LL |     bar > 13;
                  found type `i64`
 
 error[E0369]: binary operation `>` cannot be applied to type `fn() -> i32 {foo}`
-  --> $DIR/issue-59488.rs:22:9
+  --> $DIR/function-comparison-errors-59488.rs:23:9
    |
 LL |     foo > foo;
    |     --- ^ --- fn() -> i32 {foo}
@@ -56,7 +56,7 @@ LL |     foo() > foo();
    |        ++      ++
 
 error[E0369]: binary operation `>` cannot be applied to type `fn() -> i32 {foo}`
-  --> $DIR/issue-59488.rs:25:9
+  --> $DIR/function-comparison-errors-59488.rs:26:9
    |
 LL |     foo > bar;
    |     --- ^ --- fn(i64) -> i64 {bar}
@@ -64,7 +64,7 @@ LL |     foo > bar;
    |     fn() -> i32 {foo}
 
 error[E0308]: mismatched types
-  --> $DIR/issue-59488.rs:25:11
+  --> $DIR/function-comparison-errors-59488.rs:26:11
    |
 LL |     foo > bar;
    |           ^^^ expected fn item, found a different fn item
@@ -73,7 +73,7 @@ LL |     foo > bar;
               found fn item `fn(i64) -> i64 {bar}`
 
 error[E0369]: binary operation `==` cannot be applied to type `fn(usize) -> Foo {Foo::Bar}`
-  --> $DIR/issue-59488.rs:30:5
+  --> $DIR/function-comparison-errors-59488.rs:31:5
    |
 LL |     assert_eq!(Foo::Bar, i);
    |     ^^^^^^^^^^^^^^^^^^^^^^^
@@ -84,7 +84,7 @@ LL |     assert_eq!(Foo::Bar, i);
    = note: this error originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0277]: `fn(usize) -> Foo {Foo::Bar}` doesn't implement `Debug`
-  --> $DIR/issue-59488.rs:30:5
+  --> $DIR/function-comparison-errors-59488.rs:31:5
    |
 LL |     assert_eq!(Foo::Bar, i);
    |     ^^^^^^^^^^^^^^^^^^^^^^^ the trait `Debug` is not implemented for fn item `fn(usize) -> Foo {Foo::Bar}`
@@ -92,7 +92,7 @@ LL |     assert_eq!(Foo::Bar, i);
    = note: this error originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0277]: `fn(usize) -> Foo {Foo::Bar}` doesn't implement `Debug`
-  --> $DIR/issue-59488.rs:30:5
+  --> $DIR/function-comparison-errors-59488.rs:31:5
    |
 LL |     assert_eq!(Foo::Bar, i);
    |     ^^^^^^^^^^^^^^^^^^^^^^^ the trait `Debug` is not implemented for fn item `fn(usize) -> Foo {Foo::Bar}`
diff --git a/tests/ui/issues/issue-57741-dereference-boxed-value/issue-57741-1.rs b/tests/ui/box/boxed-value-matching-57741.rs
similarity index 89%
rename from tests/ui/issues/issue-57741-dereference-boxed-value/issue-57741-1.rs
rename to tests/ui/box/boxed-value-matching-57741.rs
index d0aae23b2fce6..7e2f089dad829 100644
--- a/tests/ui/issues/issue-57741-dereference-boxed-value/issue-57741-1.rs
+++ b/tests/ui/box/boxed-value-matching-57741.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/57741
 #![allow(warnings)]
 
 // This tests that the `help: consider dereferencing the boxed value` suggestion isn't made
diff --git a/tests/ui/issues/issue-57741-dereference-boxed-value/issue-57741-1.stderr b/tests/ui/box/boxed-value-matching-57741.stderr
similarity index 88%
rename from tests/ui/issues/issue-57741-dereference-boxed-value/issue-57741-1.stderr
rename to tests/ui/box/boxed-value-matching-57741.stderr
index 76f03bab6d157..33d7a6759adf5 100644
--- a/tests/ui/issues/issue-57741-dereference-boxed-value/issue-57741-1.stderr
+++ b/tests/ui/box/boxed-value-matching-57741.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/issue-57741-1.rs:14:9
+  --> $DIR/boxed-value-matching-57741.rs:15:9
    |
 LL |     let y = match x {
    |                   - this expression has type `Box<u32>`
@@ -10,7 +10,7 @@ LL |         S::A { a } | S::B { b: a } => a,
                 found enum `S`
 
 error[E0308]: mismatched types
-  --> $DIR/issue-57741-1.rs:14:22
+  --> $DIR/boxed-value-matching-57741.rs:15:22
    |
 LL |     let y = match x {
    |                   - this expression has type `Box<u32>`
diff --git a/tests/ui/issues/issue-57741-dereference-boxed-value/issue-57741.fixed b/tests/ui/box/dereferencing-boxed-enum-in-match-57741.fixed
similarity index 92%
rename from tests/ui/issues/issue-57741-dereference-boxed-value/issue-57741.fixed
rename to tests/ui/box/dereferencing-boxed-enum-in-match-57741.fixed
index 1823f0d3d4ccf..ee796b56272de 100644
--- a/tests/ui/issues/issue-57741-dereference-boxed-value/issue-57741.fixed
+++ b/tests/ui/box/dereferencing-boxed-enum-in-match-57741.fixed
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/57741
 //@ run-rustfix
 
 #![allow(warnings)]
diff --git a/tests/ui/issues/issue-57741-dereference-boxed-value/issue-57741.rs b/tests/ui/box/dereferencing-boxed-enum-in-match-57741.rs
similarity index 92%
rename from tests/ui/issues/issue-57741-dereference-boxed-value/issue-57741.rs
rename to tests/ui/box/dereferencing-boxed-enum-in-match-57741.rs
index 47ab91177e057..3a45a8b56ff1a 100644
--- a/tests/ui/issues/issue-57741-dereference-boxed-value/issue-57741.rs
+++ b/tests/ui/box/dereferencing-boxed-enum-in-match-57741.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/57741
 //@ run-rustfix
 
 #![allow(warnings)]
diff --git a/tests/ui/issues/issue-57741-dereference-boxed-value/issue-57741.stderr b/tests/ui/box/dereferencing-boxed-enum-in-match-57741.stderr
similarity index 87%
rename from tests/ui/issues/issue-57741-dereference-boxed-value/issue-57741.stderr
rename to tests/ui/box/dereferencing-boxed-enum-in-match-57741.stderr
index 62d83a5461484..c07387b21bd05 100644
--- a/tests/ui/issues/issue-57741-dereference-boxed-value/issue-57741.stderr
+++ b/tests/ui/box/dereferencing-boxed-enum-in-match-57741.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/issue-57741.rs:20:9
+  --> $DIR/dereferencing-boxed-enum-in-match-57741.rs:21:9
    |
 LL |     let y = match x {
    |                   - this expression has type `Box<T>`
@@ -14,7 +14,7 @@ LL |     let y = match *x {
    |                   +
 
 error[E0308]: mismatched types
-  --> $DIR/issue-57741.rs:20:19
+  --> $DIR/dereferencing-boxed-enum-in-match-57741.rs:21:19
    |
 LL |     let y = match x {
    |                   - this expression has type `Box<T>`
@@ -29,7 +29,7 @@ LL |     let y = match *x {
    |                   +
 
 error[E0308]: mismatched types
-  --> $DIR/issue-57741.rs:27:9
+  --> $DIR/dereferencing-boxed-enum-in-match-57741.rs:28:9
    |
 LL |     let y = match x {
    |                   - this expression has type `Box<S>`
@@ -44,7 +44,7 @@ LL |     let y = match *x {
    |                   +
 
 error[E0308]: mismatched types
-  --> $DIR/issue-57741.rs:27:22
+  --> $DIR/dereferencing-boxed-enum-in-match-57741.rs:28:22
    |
 LL |     let y = match x {
    |                   - this expression has type `Box<S>`
diff --git a/tests/ui/issues/issue-59494.rs b/tests/ui/closures/generic-typed-nested-closures-59494.rs
similarity index 91%
rename from tests/ui/issues/issue-59494.rs
rename to tests/ui/closures/generic-typed-nested-closures-59494.rs
index b4d50bd4ce795..04d7b00ff7fab 100644
--- a/tests/ui/issues/issue-59494.rs
+++ b/tests/ui/closures/generic-typed-nested-closures-59494.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/59494
 fn t7p<A, B, C>(f: impl Fn(B) -> C, g: impl Fn(A) -> B) -> impl Fn(A) -> C {
     move |a: A| -> C { f(g(a)) }
 }
diff --git a/tests/ui/issues/issue-59494.stderr b/tests/ui/closures/generic-typed-nested-closures-59494.stderr
similarity index 83%
rename from tests/ui/issues/issue-59494.stderr
rename to tests/ui/closures/generic-typed-nested-closures-59494.stderr
index 33d3e48c1aac8..9706fea82a300 100644
--- a/tests/ui/issues/issue-59494.stderr
+++ b/tests/ui/closures/generic-typed-nested-closures-59494.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/issue-59494.rs:20:40
+  --> $DIR/generic-typed-nested-closures-59494.rs:21:40
    |
 LL |     let t7 = |env| |a| |b| t7p(f, g)(((env, a), b));
    |                                        ^^^ cyclic type of infinite size
diff --git a/tests/ui/issues/issue-58375-monomorphize-default-impls.rs b/tests/ui/codegen/mono-item-collector-default-impl-58375.rs
similarity index 90%
rename from tests/ui/issues/issue-58375-monomorphize-default-impls.rs
rename to tests/ui/codegen/mono-item-collector-default-impl-58375.rs
index 769a1176edd36..f00e79e0dc5ab 100644
--- a/tests/ui/issues/issue-58375-monomorphize-default-impls.rs
+++ b/tests/ui/codegen/mono-item-collector-default-impl-58375.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/58375
 // Make sure that the mono-item collector does not crash when trying to
 // instantiate a default impl for DecodeUtf16<<u8 as A>::Item>
 // See https://github.com/rust-lang/rust/issues/58375
diff --git a/tests/ui/issues/issue-57162.rs b/tests/ui/coherence/trait-implementation-coherence-check-57162.rs
similarity index 67%
rename from tests/ui/issues/issue-57162.rs
rename to tests/ui/coherence/trait-implementation-coherence-check-57162.rs
index 5e62d0eb010bc..a57e827ca8bf5 100644
--- a/tests/ui/issues/issue-57162.rs
+++ b/tests/ui/coherence/trait-implementation-coherence-check-57162.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/57162
 //@ check-pass
 
 trait Foo {}
diff --git a/tests/ui/issues/issue-57781.rs b/tests/ui/consts/oncecell-const-init-57781.rs
similarity index 86%
rename from tests/ui/issues/issue-57781.rs
rename to tests/ui/consts/oncecell-const-init-57781.rs
index 7f0d2eda9bb84..27426ef25494e 100644
--- a/tests/ui/issues/issue-57781.rs
+++ b/tests/ui/consts/oncecell-const-init-57781.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/57781
 //@ run-pass
 
 use std::cell::UnsafeCell;
diff --git a/tests/ui/issues/issue-58463.rs b/tests/ui/debuginfo/impl-copy-function-debuginfo-58463.rs
similarity index 67%
rename from tests/ui/issues/issue-58463.rs
rename to tests/ui/debuginfo/impl-copy-function-debuginfo-58463.rs
index 6e4b909bc3835..72388c36ce487 100644
--- a/tests/ui/issues/issue-58463.rs
+++ b/tests/ui/debuginfo/impl-copy-function-debuginfo-58463.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/58463
 //@ run-pass
 //@ compile-flags:-C debuginfo=2
 
diff --git a/tests/ui/issues/issue-58734.rs b/tests/ui/dyn-compatibility/spurious-dyn-compat-errors-58734.rs
similarity index 91%
rename from tests/ui/issues/issue-58734.rs
rename to tests/ui/dyn-compatibility/spurious-dyn-compat-errors-58734.rs
index e5b371f5530dc..3e9ebb497a21b 100644
--- a/tests/ui/issues/issue-58734.rs
+++ b/tests/ui/dyn-compatibility/spurious-dyn-compat-errors-58734.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/58734
 trait Trait {
     fn exists(self) -> ();
 
diff --git a/tests/ui/issues/issue-58734.stderr b/tests/ui/dyn-compatibility/spurious-dyn-compat-errors-58734.stderr
similarity index 91%
rename from tests/ui/issues/issue-58734.stderr
rename to tests/ui/dyn-compatibility/spurious-dyn-compat-errors-58734.stderr
index 2336a94f1504d..140461283f368 100644
--- a/tests/ui/issues/issue-58734.stderr
+++ b/tests/ui/dyn-compatibility/spurious-dyn-compat-errors-58734.stderr
@@ -1,5 +1,5 @@
 warning: trait objects without an explicit `dyn` are deprecated
-  --> $DIR/issue-58734.rs:20:5
+  --> $DIR/spurious-dyn-compat-errors-58734.rs:21:5
    |
 LL |     Trait::nonexistent(());
    |     ^^^^^
@@ -13,14 +13,14 @@ LL |     <dyn Trait>::nonexistent(());
    |     ++++      +
 
 error[E0038]: the trait `Trait` is not dyn compatible
-  --> $DIR/issue-58734.rs:20:5
+  --> $DIR/spurious-dyn-compat-errors-58734.rs:21:5
    |
 LL |     Trait::nonexistent(());
    |     ^^^^^ `Trait` is not dyn compatible
    |
 note: for a trait to be dyn compatible it needs to allow building a vtable
       for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/issue-58734.rs:4:8
+  --> $DIR/spurious-dyn-compat-errors-58734.rs:5:8
    |
 LL | trait Trait {
    |       ----- this trait is not dyn compatible...
diff --git a/tests/ui/issues/issue-56237.rs b/tests/ui/generics/generic-associated-type-deref-target-56237.rs
similarity index 77%
rename from tests/ui/issues/issue-56237.rs
rename to tests/ui/generics/generic-associated-type-deref-target-56237.rs
index 3c0a235f3ec2c..2050ca377e8c1 100644
--- a/tests/ui/issues/issue-56237.rs
+++ b/tests/ui/generics/generic-associated-type-deref-target-56237.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/56237
 //@ run-pass
 
 use std::ops::Deref;
diff --git a/tests/ui/issues/issue-55731.rs b/tests/ui/higher-ranked/hrtb-associated-type-leak-check-55731.rs
similarity index 95%
rename from tests/ui/issues/issue-55731.rs
rename to tests/ui/higher-ranked/hrtb-associated-type-leak-check-55731.rs
index 7b4f4e2cd3b40..978abd9fcf5a3 100644
--- a/tests/ui/issues/issue-55731.rs
+++ b/tests/ui/higher-ranked/hrtb-associated-type-leak-check-55731.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/55731
 use std::marker::PhantomData;
 
 trait DistributedIterator {
diff --git a/tests/ui/issues/issue-55731.stderr b/tests/ui/higher-ranked/hrtb-associated-type-leak-check-55731.stderr
similarity index 90%
rename from tests/ui/issues/issue-55731.stderr
rename to tests/ui/higher-ranked/hrtb-associated-type-leak-check-55731.stderr
index 2c38041642d33..40ac1d9d041be 100644
--- a/tests/ui/issues/issue-55731.stderr
+++ b/tests/ui/higher-ranked/hrtb-associated-type-leak-check-55731.stderr
@@ -1,5 +1,5 @@
 error: implementation of `DistributedIteratorMulti` is not general enough
-  --> $DIR/issue-55731.rs:48:5
+  --> $DIR/hrtb-associated-type-leak-check-55731.rs:49:5
    |
 LL | /     multi(Map {
 LL | |         i: Cloned(PhantomData),
diff --git a/tests/ui/imports/auxiliary/reexported-trait-56175.rs b/tests/ui/imports/auxiliary/reexported-trait-56175.rs
new file mode 100644
index 0000000000000..51a991bef5959
--- /dev/null
+++ b/tests/ui/imports/auxiliary/reexported-trait-56175.rs
@@ -0,0 +1,17 @@
+mod private {
+    pub trait Trait {
+        fn trait_method(&self) {
+        }
+    }
+    pub trait TraitB {
+        fn trait_method_b(&self) {
+        }
+    }
+}
+
+pub struct FooStruct;
+pub use crate::private::Trait;
+impl crate::private::Trait for FooStruct {}
+
+pub use crate::private::TraitB as TraitBRename;
+impl crate::private::TraitB for FooStruct {}
diff --git a/tests/ui/issues/issue-56175.rs b/tests/ui/imports/private-types-suggested-without-extern-crate-56175.rs
similarity index 59%
rename from tests/ui/issues/issue-56175.rs
rename to tests/ui/imports/private-types-suggested-without-extern-crate-56175.rs
index daffe806a900c..ce001edad1b67 100644
--- a/tests/ui/issues/issue-56175.rs
+++ b/tests/ui/imports/private-types-suggested-without-extern-crate-56175.rs
@@ -1,5 +1,6 @@
+// https://github.com/rust-lang/rust/issues/56175
 //@ edition:2018
-//@ aux-crate:reexported_trait=reexported-trait.rs
+//@ aux-crate:reexported_trait=reexported-trait-56175.rs
 
 fn main() {
     reexported_trait::FooStruct.trait_method();
diff --git a/tests/ui/issues/issue-56175.stderr b/tests/ui/imports/private-types-suggested-without-extern-crate-56175.stderr
similarity index 82%
rename from tests/ui/issues/issue-56175.stderr
rename to tests/ui/imports/private-types-suggested-without-extern-crate-56175.stderr
index df4cd6ce8a700..1e8285c80ac34 100644
--- a/tests/ui/issues/issue-56175.stderr
+++ b/tests/ui/imports/private-types-suggested-without-extern-crate-56175.stderr
@@ -1,10 +1,10 @@
 error[E0599]: no method named `trait_method` found for struct `FooStruct` in the current scope
-  --> $DIR/issue-56175.rs:5:33
+  --> $DIR/private-types-suggested-without-extern-crate-56175.rs:6:33
    |
 LL |     reexported_trait::FooStruct.trait_method();
    |                                 ^^^^^^^^^^^^
    |
-  ::: $DIR/auxiliary/reexported-trait.rs:3:12
+  ::: $DIR/auxiliary/reexported-trait-56175.rs:3:12
    |
 LL |         fn trait_method(&self) {
    |            ------------ the method is available for `FooStruct` here
@@ -12,7 +12,7 @@ LL |         fn trait_method(&self) {
    = help: items from traits can only be used if the trait is in scope
 help: trait `Trait` which provides `trait_method` is implemented but not in scope; perhaps you want to import it
    |
-LL + use reexported_trait::Trait;
+LL + use reexported_trait_56175::Trait;
    |
 help: there is a method `trait_method_b` with a similar name
    |
@@ -20,12 +20,12 @@ LL |     reexported_trait::FooStruct.trait_method_b();
    |                                             ++
 
 error[E0599]: no method named `trait_method_b` found for struct `FooStruct` in the current scope
-  --> $DIR/issue-56175.rs:7:33
+  --> $DIR/private-types-suggested-without-extern-crate-56175.rs:8:33
    |
 LL |     reexported_trait::FooStruct.trait_method_b();
    |                                 ^^^^^^^^^^^^^^
    |
-  ::: $DIR/auxiliary/reexported-trait.rs:7:12
+  ::: $DIR/auxiliary/reexported-trait-56175.rs:7:12
    |
 LL |         fn trait_method_b(&self) {
    |            -------------- the method is available for `FooStruct` here
@@ -33,7 +33,7 @@ LL |         fn trait_method_b(&self) {
    = help: items from traits can only be used if the trait is in scope
 help: trait `TraitB` which provides `trait_method_b` is implemented but not in scope; perhaps you want to import it
    |
-LL + use reexported_trait::TraitBRename;
+LL + use reexported_trait_56175::TraitBRename;
    |
 help: there is a method `trait_method` with a similar name
    |
diff --git a/tests/ui/issues/auxiliary/issue-57271-lib.rs b/tests/ui/infinite/auxiliary/aux-57271-lib.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-57271-lib.rs
rename to tests/ui/infinite/auxiliary/aux-57271-lib.rs
diff --git a/tests/ui/issues/issue-57271.rs b/tests/ui/infinite/mutually-recursive-infinite-types-57271.rs
similarity index 72%
rename from tests/ui/issues/issue-57271.rs
rename to tests/ui/infinite/mutually-recursive-infinite-types-57271.rs
index 20d081ecb3ce6..cb20770b48690 100644
--- a/tests/ui/issues/issue-57271.rs
+++ b/tests/ui/infinite/mutually-recursive-infinite-types-57271.rs
@@ -1,8 +1,9 @@
-//@ aux-build:issue-57271-lib.rs
+// https://github.com/rust-lang/rust/issues/57271
+//@ aux-build:aux-57271-lib.rs
 
-extern crate issue_57271_lib;
+extern crate aux_57271_lib;
 
-use issue_57271_lib::BaseType;
+use aux_57271_lib::BaseType;
 
 pub enum ObjectType { //~ ERROR recursive types `ObjectType` and `TypeSignature` have infinite size
     Class(ClassTypeSignature),
diff --git a/tests/ui/issues/issue-57271.stderr b/tests/ui/infinite/mutually-recursive-infinite-types-57271.stderr
similarity index 92%
rename from tests/ui/issues/issue-57271.stderr
rename to tests/ui/infinite/mutually-recursive-infinite-types-57271.stderr
index a61419c61d74a..8bf1b470062bd 100644
--- a/tests/ui/issues/issue-57271.stderr
+++ b/tests/ui/infinite/mutually-recursive-infinite-types-57271.stderr
@@ -1,5 +1,5 @@
 error[E0072]: recursive types `ObjectType` and `TypeSignature` have infinite size
-  --> $DIR/issue-57271.rs:7:1
+  --> $DIR/mutually-recursive-infinite-types-57271.rs:8:1
    |
 LL | pub enum ObjectType {
    | ^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/issues/issue-56943.rs b/tests/ui/issues/issue-56943.rs
deleted file mode 100644
index 9664567ec9ea0..0000000000000
--- a/tests/ui/issues/issue-56943.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-//@ aux-build:issue-56943.rs
-
-extern crate issue_56943;
-
-fn main() {
-    let _: issue_56943::S = issue_56943::S2;
-    //~^ ERROR mismatched types [E0308]
-}
diff --git a/tests/ui/issues/issue-57198-pass.rs b/tests/ui/keyword/raw-identifier-for-function-57198.rs
similarity index 60%
rename from tests/ui/issues/issue-57198-pass.rs
rename to tests/ui/keyword/raw-identifier-for-function-57198.rs
index 06f30603c3169..41a0cbf4619d4 100644
--- a/tests/ui/issues/issue-57198-pass.rs
+++ b/tests/ui/keyword/raw-identifier-for-function-57198.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/57198
 //@ run-pass
 
 mod m {
diff --git a/tests/ui/issues/auxiliary/issue-56943.rs b/tests/ui/mismatched_types/auxiliary/aux-56943.rs
similarity index 100%
rename from tests/ui/issues/auxiliary/issue-56943.rs
rename to tests/ui/mismatched_types/auxiliary/aux-56943.rs
diff --git a/tests/ui/mismatched_types/type-mismatch-in-extern-crate-56943.rs b/tests/ui/mismatched_types/type-mismatch-in-extern-crate-56943.rs
new file mode 100644
index 0000000000000..9970b27c847b3
--- /dev/null
+++ b/tests/ui/mismatched_types/type-mismatch-in-extern-crate-56943.rs
@@ -0,0 +1,9 @@
+// https://github.com/rust-lang/rust/issues/56943
+//@ aux-build:aux-56943.rs
+
+extern crate aux_56943;
+
+fn main() {
+    let _: aux_56943::S = aux_56943::S2;
+    //~^ ERROR mismatched types [E0308]
+}
diff --git a/tests/ui/issues/issue-56943.stderr b/tests/ui/mismatched_types/type-mismatch-in-extern-crate-56943.stderr
similarity index 54%
rename from tests/ui/issues/issue-56943.stderr
rename to tests/ui/mismatched_types/type-mismatch-in-extern-crate-56943.stderr
index 60a2e92dc71b5..2315267701d14 100644
--- a/tests/ui/issues/issue-56943.stderr
+++ b/tests/ui/mismatched_types/type-mismatch-in-extern-crate-56943.stderr
@@ -1,8 +1,8 @@
 error[E0308]: mismatched types
-  --> $DIR/issue-56943.rs:6:29
+  --> $DIR/type-mismatch-in-extern-crate-56943.rs:7:27
    |
-LL |     let _: issue_56943::S = issue_56943::S2;
-   |            --------------   ^^^^^^^^^^^^^^^ expected `S`, found `S2`
+LL |     let _: aux_56943::S = aux_56943::S2;
+   |            ------------   ^^^^^^^^^^^^^ expected `S`, found `S2`
    |            |
    |            expected due to this
 
diff --git a/tests/ui/issues/issue-56128.rs b/tests/ui/modules/pub-use-handling-in-modules-56128.rs
similarity index 100%
rename from tests/ui/issues/issue-56128.rs
rename to tests/ui/modules/pub-use-handling-in-modules-56128.rs
diff --git a/tests/ui/issues/issue-55587.rs b/tests/ui/parser/invalid-variable-definition-55587.rs
similarity index 67%
rename from tests/ui/issues/issue-55587.rs
rename to tests/ui/parser/invalid-variable-definition-55587.rs
index d9100cf555b3c..f2c7c0a8e6c34 100644
--- a/tests/ui/issues/issue-55587.rs
+++ b/tests/ui/parser/invalid-variable-definition-55587.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/55587
 use std::path::Path;
 
 fn main() {
diff --git a/tests/ui/issues/issue-55587.stderr b/tests/ui/parser/invalid-variable-definition-55587.stderr
similarity index 88%
rename from tests/ui/issues/issue-55587.stderr
rename to tests/ui/parser/invalid-variable-definition-55587.stderr
index 7a5d0e281007f..08c951582e3f7 100644
--- a/tests/ui/issues/issue-55587.stderr
+++ b/tests/ui/parser/invalid-variable-definition-55587.stderr
@@ -1,5 +1,5 @@
 error[E0164]: expected tuple struct or tuple variant, found associated function `Path::new`
-  --> $DIR/issue-55587.rs:4:9
+  --> $DIR/invalid-variable-definition-55587.rs:5:9
    |
 LL |     let Path::new();
    |         ^^^^^^^^^^^ `fn` calls are not allowed in patterns
diff --git a/tests/ui/issues/issue-58712.rs b/tests/ui/resolve/missing-type-in-scope-58712.rs
similarity index 84%
rename from tests/ui/issues/issue-58712.rs
rename to tests/ui/resolve/missing-type-in-scope-58712.rs
index 930bec6889bce..b9ff74e426dfc 100644
--- a/tests/ui/issues/issue-58712.rs
+++ b/tests/ui/resolve/missing-type-in-scope-58712.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/58712
 struct AddrVec<H, A> {
     h: H,
     a: A,
diff --git a/tests/ui/issues/issue-58712.stderr b/tests/ui/resolve/missing-type-in-scope-58712.stderr
similarity index 85%
rename from tests/ui/issues/issue-58712.stderr
rename to tests/ui/resolve/missing-type-in-scope-58712.stderr
index f4bd4d1e826a0..d7e06eee856c9 100644
--- a/tests/ui/issues/issue-58712.stderr
+++ b/tests/ui/resolve/missing-type-in-scope-58712.stderr
@@ -1,5 +1,5 @@
 error[E0412]: cannot find type `DeviceId` in this scope
-  --> $DIR/issue-58712.rs:6:20
+  --> $DIR/missing-type-in-scope-58712.rs:7:20
    |
 LL | impl<H> AddrVec<H, DeviceId> {
    |                    ^^^^^^^^ not found in this scope
@@ -10,7 +10,7 @@ LL | impl<H, DeviceId> AddrVec<H, DeviceId> {
    |       ++++++++++
 
 error[E0412]: cannot find type `DeviceId` in this scope
-  --> $DIR/issue-58712.rs:8:29
+  --> $DIR/missing-type-in-scope-58712.rs:9:29
    |
 LL |     pub fn device(&self) -> DeviceId {
    |                             ^^^^^^^^ not found in this scope
diff --git a/tests/ui/issues/issue-59020.rs b/tests/ui/std/park-timeout-wakeup-59020.rs
similarity index 92%
rename from tests/ui/issues/issue-59020.rs
rename to tests/ui/std/park-timeout-wakeup-59020.rs
index 2a34ba52b8831..af530bb586c76 100644
--- a/tests/ui/issues/issue-59020.rs
+++ b/tests/ui/std/park-timeout-wakeup-59020.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/59020
 //@ edition:2018
 //@ run-pass
 //@ needs-threads
diff --git a/tests/ui/issues/issue-56835.rs b/tests/ui/structs/invalid-self-constructor-56835.rs
similarity index 83%
rename from tests/ui/issues/issue-56835.rs
rename to tests/ui/structs/invalid-self-constructor-56835.rs
index 7132d15ee5fbf..fd8763443f04a 100644
--- a/tests/ui/issues/issue-56835.rs
+++ b/tests/ui/structs/invalid-self-constructor-56835.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/56835
 pub struct Foo {}
 
 impl Foo {
diff --git a/tests/ui/issues/issue-56835.stderr b/tests/ui/structs/invalid-self-constructor-56835.stderr
similarity index 83%
rename from tests/ui/issues/issue-56835.stderr
rename to tests/ui/structs/invalid-self-constructor-56835.stderr
index e949ae7b32402..045781ec42bd2 100644
--- a/tests/ui/issues/issue-56835.stderr
+++ b/tests/ui/structs/invalid-self-constructor-56835.stderr
@@ -1,11 +1,11 @@
 error: the `Self` constructor can only be used with tuple or unit structs
-  --> $DIR/issue-56835.rs:4:12
+  --> $DIR/invalid-self-constructor-56835.rs:5:12
    |
 LL |     fn bar(Self(foo): Self) {}
    |            ^^^^^^^^^ help: use curly brackets: `Self { /* fields */ }`
 
 error[E0164]: expected tuple struct or tuple variant, found self constructor `Self`
-  --> $DIR/issue-56835.rs:4:12
+  --> $DIR/invalid-self-constructor-56835.rs:5:12
    |
 LL |     fn bar(Self(foo): Self) {}
    |            ^^^^^^^^^ not a tuple struct or tuple variant
diff --git a/tests/ui/issues/issue-59756.fixed b/tests/ui/suggestions/incompatible-types-in-try-expression-59756.fixed
similarity index 100%
rename from tests/ui/issues/issue-59756.fixed
rename to tests/ui/suggestions/incompatible-types-in-try-expression-59756.fixed
diff --git a/tests/ui/issues/issue-59756.rs b/tests/ui/suggestions/incompatible-types-in-try-expression-59756.rs
similarity index 89%
rename from tests/ui/issues/issue-59756.rs
rename to tests/ui/suggestions/incompatible-types-in-try-expression-59756.rs
index de349f43f464b..570aa7d373b7c 100644
--- a/tests/ui/issues/issue-59756.rs
+++ b/tests/ui/suggestions/incompatible-types-in-try-expression-59756.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/59756
 //@ run-rustfix
 //@ ignore-test (rustfix needs multiple suggestions)
 //
diff --git a/tests/ui/issues/issue-59756.stderr b/tests/ui/suggestions/incompatible-types-in-try-expression-59756.stderr
similarity index 88%
rename from tests/ui/issues/issue-59756.stderr
rename to tests/ui/suggestions/incompatible-types-in-try-expression-59756.stderr
index 27c07fecd5b50..7182109b5a02d 100644
--- a/tests/ui/issues/issue-59756.stderr
+++ b/tests/ui/suggestions/incompatible-types-in-try-expression-59756.stderr
@@ -1,5 +1,5 @@
 error[E0308]: try expression alternatives have incompatible types
-  --> $DIR/issue-59756.rs:13:5
+  --> $DIR/incompatible-types-in-try-expression-59756.rs:13:5
    |
 LL |     foo()?
    |     ^^^^^^ expected enum `std::result::Result`, found struct `A`
diff --git a/tests/ui/issues/issue-58857.rs b/tests/ui/trait-bounds/negative-bound-not-supported-58857.rs
similarity index 71%
rename from tests/ui/issues/issue-58857.rs
rename to tests/ui/trait-bounds/negative-bound-not-supported-58857.rs
index 4350d7e5b403b..0a0b70a216be6 100644
--- a/tests/ui/issues/issue-58857.rs
+++ b/tests/ui/trait-bounds/negative-bound-not-supported-58857.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/58857
 struct Conj<A> {a : A}
 trait Valid {}
 
diff --git a/tests/ui/issues/issue-58857.stderr b/tests/ui/trait-bounds/negative-bound-not-supported-58857.stderr
similarity index 71%
rename from tests/ui/issues/issue-58857.stderr
rename to tests/ui/trait-bounds/negative-bound-not-supported-58857.stderr
index ac70bc725e277..05347a891b4f1 100644
--- a/tests/ui/issues/issue-58857.stderr
+++ b/tests/ui/trait-bounds/negative-bound-not-supported-58857.stderr
@@ -1,5 +1,5 @@
 error: negative bounds are not supported
-  --> $DIR/issue-58857.rs:4:9
+  --> $DIR/negative-bound-not-supported-58857.rs:5:9
    |
 LL | impl<A: !Valid> Conj<A>{}
    |         ^
diff --git a/tests/ui/issues/issue-58212.rs b/tests/ui/traits/generic-trait-impl-aliased-array-58212.rs
similarity index 82%
rename from tests/ui/issues/issue-58212.rs
rename to tests/ui/traits/generic-trait-impl-aliased-array-58212.rs
index f266db603bf1c..a71194ba80643 100644
--- a/tests/ui/issues/issue-58212.rs
+++ b/tests/ui/traits/generic-trait-impl-aliased-array-58212.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/58212
 //@ check-pass
 
 trait FromUnchecked {
diff --git a/tests/ui/issues/issue-57156.rs b/tests/ui/traits/trait-object-lifetime-bounds-57156.rs
similarity index 88%
rename from tests/ui/issues/issue-57156.rs
rename to tests/ui/traits/trait-object-lifetime-bounds-57156.rs
index 12251509abd2d..8f5bef7fe13b9 100644
--- a/tests/ui/issues/issue-57156.rs
+++ b/tests/ui/traits/trait-object-lifetime-bounds-57156.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/57156
 //@ check-pass
 
 trait Foo<Args> {
diff --git a/tests/ui/issues/issue-56229.rs b/tests/ui/traits/trait-objects-with-supertraits-56229.rs
similarity index 90%
rename from tests/ui/issues/issue-56229.rs
rename to tests/ui/traits/trait-objects-with-supertraits-56229.rs
index 1c6dd72ed2dea..27cae968a6acd 100644
--- a/tests/ui/issues/issue-56229.rs
+++ b/tests/ui/traits/trait-objects-with-supertraits-56229.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/56229
 //@ check-pass
 
 trait Mirror {
diff --git a/tests/ui/issues/issue-57924.rs b/tests/ui/typeck/self-constructor-type-args-not-allowed-57924.rs
similarity index 78%
rename from tests/ui/issues/issue-57924.rs
rename to tests/ui/typeck/self-constructor-type-args-not-allowed-57924.rs
index 8846912a8ff79..2b3b11c3f380a 100644
--- a/tests/ui/issues/issue-57924.rs
+++ b/tests/ui/typeck/self-constructor-type-args-not-allowed-57924.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/57924
 pub struct Gcm<E>(E);
 
 impl<E> Gcm<E> {
diff --git a/tests/ui/issues/issue-57924.stderr b/tests/ui/typeck/self-constructor-type-args-not-allowed-57924.stderr
similarity index 83%
rename from tests/ui/issues/issue-57924.stderr
rename to tests/ui/typeck/self-constructor-type-args-not-allowed-57924.stderr
index 40435fd0f0a93..b5be5b39eb8fe 100644
--- a/tests/ui/issues/issue-57924.stderr
+++ b/tests/ui/typeck/self-constructor-type-args-not-allowed-57924.stderr
@@ -1,5 +1,5 @@
 error[E0109]: type arguments are not allowed on self constructor
-  --> $DIR/issue-57924.rs:5:16
+  --> $DIR/self-constructor-type-args-not-allowed-57924.rs:6:16
    |
 LL |         Self::<E>(e)
    |         ----   ^ type argument not allowed
diff --git a/tests/ui/issues/issue-56199.rs b/tests/ui/typeck/self-constructor-type-error-56199.rs
similarity index 91%
rename from tests/ui/issues/issue-56199.rs
rename to tests/ui/typeck/self-constructor-type-error-56199.rs
index ba11582a9d591..b08d69189807a 100644
--- a/tests/ui/issues/issue-56199.rs
+++ b/tests/ui/typeck/self-constructor-type-error-56199.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/56199
 enum Foo {}
 struct Bar {}
 
diff --git a/tests/ui/issues/issue-56199.stderr b/tests/ui/typeck/self-constructor-type-error-56199.stderr
similarity index 79%
rename from tests/ui/issues/issue-56199.stderr
rename to tests/ui/typeck/self-constructor-type-error-56199.stderr
index eb6d7005979f6..6e9d0fcd90c05 100644
--- a/tests/ui/issues/issue-56199.stderr
+++ b/tests/ui/typeck/self-constructor-type-error-56199.stderr
@@ -1,5 +1,5 @@
 error: the `Self` constructor can only be used with tuple or unit structs
-  --> $DIR/issue-56199.rs:6:17
+  --> $DIR/self-constructor-type-error-56199.rs:7:17
    |
 LL |         let _ = Self;
    |                 ^^^^
@@ -7,7 +7,7 @@ LL |         let _ = Self;
    = help: did you mean to use one of the enum's variants?
 
 error: the `Self` constructor can only be used with tuple or unit structs
-  --> $DIR/issue-56199.rs:8:17
+  --> $DIR/self-constructor-type-error-56199.rs:9:17
    |
 LL |         let _ = Self();
    |                 ^^^^^^
@@ -15,13 +15,13 @@ LL |         let _ = Self();
    = help: did you mean to use one of the enum's variants?
 
 error: the `Self` constructor can only be used with tuple or unit structs
-  --> $DIR/issue-56199.rs:15:17
+  --> $DIR/self-constructor-type-error-56199.rs:16:17
    |
 LL |         let _ = Self;
    |                 ^^^^ help: use curly brackets: `Self { /* fields */ }`
 
 error: the `Self` constructor can only be used with tuple or unit structs
-  --> $DIR/issue-56199.rs:17:17
+  --> $DIR/self-constructor-type-error-56199.rs:18:17
    |
 LL |         let _ = Self();
    |                 ^^^^^^ help: use curly brackets: `Self { /* fields */ }`

From f157ce994ea45e9faea9eff89c5f8b3d4ea77b6e Mon Sep 17 00:00:00 2001
From: Noratrieb <48135649+Noratrieb@users.noreply.github.com>
Date: Sat, 26 Jul 2025 12:39:31 +0200
Subject: [PATCH 0862/1889] Add --print target-spec-json-schema

This schema is helpful for people writing custom target spec JSON. It
can provide autocomplete in the editor, and also serves as documentation
when there are documentation comments on the structs, as `schemars` will
put them in the schema.
---
 Cargo.lock                                    | 63 +++++++++++++++++
 .../rustc_codegen_ssa/src/back/command.rs     |  2 +-
 compiler/rustc_driver_impl/src/lib.rs         |  4 ++
 compiler/rustc_session/src/config.rs          |  5 +-
 compiler/rustc_target/Cargo.toml              |  1 +
 compiler/rustc_target/src/lib.rs              |  2 +
 compiler/rustc_target/src/spec/json.rs        | 38 ++++++++--
 compiler/rustc_target/src/spec/mod.rs         | 70 ++++++++++++++++++-
 src/bootstrap/src/core/build_steps/dist.rs    | 24 +++++++
 src/bootstrap/src/utils/proc_macro_deps.rs    |  1 +
 src/doc/rustc/src/targets/custom.md           | 15 ++++
 src/tools/tidy/src/deps.rs                    |  6 ++
 .../help-diff.diff                            |  2 +-
 .../unstable-invalid-print-request-help.err   |  2 +-
 tests/run-make/rustc-help/help-v.stdout       |  2 +-
 tests/run-make/rustc-help/help.stdout         |  2 +-
 .../print-without-arg.stderr                  |  2 +-
 tests/ui/invalid-compile-flags/print.stderr   |  2 +-
 .../ui/print-request/print-lints-help.stderr  |  2 +-
 19 files changed, 229 insertions(+), 16 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 2dc6e8ff10320..4677d34d2a630 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1191,6 +1191,12 @@ version = "1.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8975ffdaa0ef3661bfe02dbdcc06c9f829dfafe6a3c474de366a8d5e44276921"
 
+[[package]]
+name = "dyn-clone"
+version = "1.0.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c7a8fb8a9fbf66c1f703fe16184d10ca0ee9d23be5b4436400408ba54a95005"
+
 [[package]]
 name = "either"
 version = "1.15.0"
@@ -3122,6 +3128,26 @@ dependencies = [
  "thiserror 2.0.15",
 ]
 
+[[package]]
+name = "ref-cast"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a0ae411dbe946a674d89546582cea4ba2bb8defac896622d6496f14c23ba5cf"
+dependencies = [
+ "ref-cast-impl",
+]
+
+[[package]]
+name = "ref-cast-impl"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1165225c21bff1f3bbce98f5a1f889949bc902d3575308cc7b0de30b4f6d27c7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
+
 [[package]]
 name = "regex"
 version = "1.11.1"
@@ -4577,6 +4603,7 @@ dependencies = [
  "rustc_macros",
  "rustc_serialize",
  "rustc_span",
+ "schemars",
  "serde",
  "serde_derive",
  "serde_json",
@@ -4900,6 +4927,31 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
+[[package]]
+name = "schemars"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82d20c4491bc164fa2f6c5d44565947a52ad80b9505d8e36f8d54c27c739fcd0"
+dependencies = [
+ "dyn-clone",
+ "ref-cast",
+ "schemars_derive",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "schemars_derive"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33d020396d1d138dc19f1165df7545479dcd58d93810dc5d646a16e55abefa80"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "serde_derive_internals",
+ "syn 2.0.106",
+]
+
 [[package]]
 name = "scoped-tls"
 version = "1.0.1"
@@ -4974,6 +5026,17 @@ dependencies = [
  "syn 2.0.106",
 ]
 
+[[package]]
+name = "serde_derive_internals"
+version = "0.29.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
+
 [[package]]
 name = "serde_json"
 version = "1.0.142"
diff --git a/compiler/rustc_codegen_ssa/src/back/command.rs b/compiler/rustc_codegen_ssa/src/back/command.rs
index 05351bd6ca379..7420f18aacb35 100644
--- a/compiler/rustc_codegen_ssa/src/back/command.rs
+++ b/compiler/rustc_codegen_ssa/src/back/command.rs
@@ -109,7 +109,7 @@ impl Command {
             }
             Program::Lld(ref p, flavor) => {
                 let mut c = process::Command::new(p);
-                c.arg("-flavor").arg(flavor.as_str());
+                c.arg("-flavor").arg(flavor.desc());
                 c
             }
         };
diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
index d00a4c3583403..4f875cf99ec21 100644
--- a/compiler/rustc_driver_impl/src/lib.rs
+++ b/compiler/rustc_driver_impl/src/lib.rs
@@ -668,6 +668,10 @@ fn print_crate_info(
             TargetSpecJson => {
                 println_info!("{}", serde_json::to_string_pretty(&sess.target.to_json()).unwrap());
             }
+            TargetSpecJsonSchema => {
+                let schema = rustc_target::spec::json_schema();
+                println_info!("{}", serde_json::to_string_pretty(&schema).unwrap());
+            }
             AllTargetSpecsJson => {
                 let mut targets = BTreeMap::new();
                 for name in rustc_target::spec::TARGETS {
diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs
index 9793d8091e2ab..297df7c2c9765 100644
--- a/compiler/rustc_session/src/config.rs
+++ b/compiler/rustc_session/src/config.rs
@@ -70,6 +70,7 @@ pub const PRINT_KINDS: &[(&str, PrintKind)] = &[
     ("target-libdir", PrintKind::TargetLibdir),
     ("target-list", PrintKind::TargetList),
     ("target-spec-json", PrintKind::TargetSpecJson),
+    ("target-spec-json-schema", PrintKind::TargetSpecJsonSchema),
     ("tls-models", PrintKind::TlsModels),
     // tidy-alphabetical-end
 ];
@@ -1043,6 +1044,7 @@ pub enum PrintKind {
     TargetLibdir,
     TargetList,
     TargetSpecJson,
+    TargetSpecJsonSchema,
     TlsModels,
     // tidy-alphabetical-end
 }
@@ -2323,7 +2325,8 @@ fn is_print_request_stable(print_kind: PrintKind) -> bool {
         | PrintKind::CheckCfg
         | PrintKind::CrateRootLintLevels
         | PrintKind::SupportedCrateTypes
-        | PrintKind::TargetSpecJson => false,
+        | PrintKind::TargetSpecJson
+        | PrintKind::TargetSpecJsonSchema => false,
         _ => true,
     }
 }
diff --git a/compiler/rustc_target/Cargo.toml b/compiler/rustc_target/Cargo.toml
index 7fabb227d9a59..ecdb6ab5a576c 100644
--- a/compiler/rustc_target/Cargo.toml
+++ b/compiler/rustc_target/Cargo.toml
@@ -14,6 +14,7 @@ rustc_fs_util = { path = "../rustc_fs_util" }
 rustc_macros = { path = "../rustc_macros" }
 rustc_serialize = { path = "../rustc_serialize" }
 rustc_span = { path = "../rustc_span" }
+schemars = "1.0.4"
 serde = "1.0.219"
 serde_derive = "1.0.219"
 serde_json = "1.0.59"
diff --git a/compiler/rustc_target/src/lib.rs b/compiler/rustc_target/src/lib.rs
index c6a23745b04e7..b3fe1fffccebc 100644
--- a/compiler/rustc_target/src/lib.rs
+++ b/compiler/rustc_target/src/lib.rs
@@ -86,9 +86,11 @@ macro_rules! target_spec_enum {
     ) => {
         $( #[$attr] )*
         #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, PartialOrd, Ord)]
+        #[derive(schemars::JsonSchema)]
         pub enum $name {
             $(
                 $( #[$variant_attr] )*
+                #[serde(rename = $string)] // for JSON schema generation only
                 $variant,
             )*
         }
diff --git a/compiler/rustc_target/src/spec/json.rs b/compiler/rustc_target/src/spec/json.rs
index e9ae5734d5b26..f236be92b3b60 100644
--- a/compiler/rustc_target/src/spec/json.rs
+++ b/compiler/rustc_target/src/spec/json.rs
@@ -408,12 +408,12 @@ impl ToJson for Target {
     }
 }
 
-#[derive(serde_derive::Deserialize)]
+#[derive(serde_derive::Deserialize, schemars::JsonSchema)]
 struct LinkSelfContainedComponentsWrapper {
     components: Vec<LinkSelfContainedComponents>,
 }
 
-#[derive(serde_derive::Deserialize)]
+#[derive(serde_derive::Deserialize, schemars::JsonSchema)]
 #[serde(untagged)]
 enum TargetFamiliesJson {
     Array(StaticCow<[StaticCow<str>]>),
@@ -429,6 +429,18 @@ impl FromStr for EndianWrapper {
     }
 }
 crate::json::serde_deserialize_from_str!(EndianWrapper);
+impl schemars::JsonSchema for EndianWrapper {
+    fn schema_name() -> std::borrow::Cow<'static, str> {
+        "Endian".into()
+    }
+    fn json_schema(_: &mut schemars::SchemaGenerator) -> schemars::Schema {
+        schemars::json_schema! ({
+            "type": "string",
+            "enum": ["big", "little"]
+        })
+        .into()
+    }
+}
 
 /// `ExternAbi` is in `rustc_abi`, which doesn't have access to the macro and serde.
 struct ExternAbiWrapper(rustc_abi::ExternAbi);
@@ -441,8 +453,22 @@ impl FromStr for ExternAbiWrapper {
     }
 }
 crate::json::serde_deserialize_from_str!(ExternAbiWrapper);
+impl schemars::JsonSchema for ExternAbiWrapper {
+    fn schema_name() -> std::borrow::Cow<'static, str> {
+        "ExternAbi".into()
+    }
+    fn json_schema(_: &mut schemars::SchemaGenerator) -> schemars::Schema {
+        let all =
+            rustc_abi::ExternAbi::ALL_VARIANTS.iter().map(|abi| abi.as_str()).collect::<Vec<_>>();
+        schemars::json_schema! ({
+            "type": "string",
+            "enum": all,
+        })
+        .into()
+    }
+}
 
-#[derive(serde_derive::Deserialize)]
+#[derive(serde_derive::Deserialize, schemars::JsonSchema)]
 struct TargetSpecJsonMetadata {
     description: Option<StaticCow<str>>,
     tier: Option<u64>,
@@ -450,7 +476,7 @@ struct TargetSpecJsonMetadata {
     std: Option<bool>,
 }
 
-#[derive(serde_derive::Deserialize)]
+#[derive(serde_derive::Deserialize, schemars::JsonSchema)]
 #[serde(rename_all = "kebab-case")]
 // Ensure that all unexpected fields get turned into errors.
 // This helps users stay up to date when the schema changes instead of silently
@@ -593,3 +619,7 @@ struct TargetSpecJson {
     supports_xray: Option<bool>,
     entry_abi: Option<ExternAbiWrapper>,
 }
+
+pub fn json_schema() -> schemars::Schema {
+    schemars::schema_for!(TargetSpecJson)
+}
diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index 239ac7bf5c4d1..07fb1ce63f7c4 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -70,6 +70,7 @@ mod json;
 pub use abi_map::{AbiMap, AbiMapping};
 pub use base::apple;
 pub use base::avr::ef_avr_arch;
+pub use json::json_schema;
 
 /// Linker is called through a C/C++ compiler.
 #[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
@@ -523,6 +524,20 @@ linker_flavor_cli_impls! {
 }
 
 crate::json::serde_deserialize_from_str!(LinkerFlavorCli);
+impl schemars::JsonSchema for LinkerFlavorCli {
+    fn schema_name() -> std::borrow::Cow<'static, str> {
+        "LinkerFlavor".into()
+    }
+    fn json_schema(_: &mut schemars::SchemaGenerator) -> schemars::Schema {
+        let all: Vec<&'static str> =
+            Self::all().iter().map(|flavor| flavor.desc()).collect::<Vec<_>>();
+        schemars::json_schema! ({
+            "type": "string",
+            "enum": all
+        })
+        .into()
+    }
+}
 
 impl ToJson for LinkerFlavorCli {
     fn to_json(&self) -> Json {
@@ -576,6 +591,18 @@ impl FromStr for LinkSelfContainedDefault {
 }
 
 crate::json::serde_deserialize_from_str!(LinkSelfContainedDefault);
+impl schemars::JsonSchema for LinkSelfContainedDefault {
+    fn schema_name() -> std::borrow::Cow<'static, str> {
+        "LinkSelfContainedDefault".into()
+    }
+    fn json_schema(_: &mut schemars::SchemaGenerator) -> schemars::Schema {
+        schemars::json_schema! ({
+            "type": "string",
+            "enum": ["false", "true", "wasm", "musl", "mingw"]
+        })
+        .into()
+    }
+}
 
 impl ToJson for LinkSelfContainedDefault {
     fn to_json(&self) -> Json {
@@ -708,6 +735,20 @@ impl FromStr for LinkSelfContainedComponents {
 }
 
 crate::json::serde_deserialize_from_str!(LinkSelfContainedComponents);
+impl schemars::JsonSchema for LinkSelfContainedComponents {
+    fn schema_name() -> std::borrow::Cow<'static, str> {
+        "LinkSelfContainedComponents".into()
+    }
+    fn json_schema(_: &mut schemars::SchemaGenerator) -> schemars::Schema {
+        let all =
+            Self::all_components().iter().map(|component| component.as_str()).collect::<Vec<_>>();
+        schemars::json_schema! ({
+            "type": "string",
+            "enum": all,
+        })
+        .into()
+    }
+}
 
 impl ToJson for LinkSelfContainedComponents {
     fn to_json(&self) -> Json {
@@ -846,7 +887,6 @@ crate::target_spec_enum! {
     parse_error_type = "symbol visibility";
 }
 
-
 #[derive(Clone, Debug, PartialEq, Hash)]
 pub enum SmallDataThresholdSupport {
     None,
@@ -874,6 +914,18 @@ impl FromStr for SmallDataThresholdSupport {
 }
 
 crate::json::serde_deserialize_from_str!(SmallDataThresholdSupport);
+impl schemars::JsonSchema for SmallDataThresholdSupport {
+    fn schema_name() -> std::borrow::Cow<'static, str> {
+        "SmallDataThresholdSupport".into()
+    }
+    fn json_schema(_: &mut schemars::SchemaGenerator) -> schemars::Schema {
+        schemars::json_schema! ({
+            "type": "string",
+            "pattern": r#"^none|default-for-arch|llvm-module-flag=.+|llvm-arg=.+$"#,
+        })
+        .into()
+    }
+}
 
 impl ToJson for SmallDataThresholdSupport {
     fn to_json(&self) -> Value {
@@ -1074,7 +1126,7 @@ crate::target_spec_enum! {
 
 into_diag_arg_using_display!(SplitDebuginfo);
 
-#[derive(Clone, Debug, PartialEq, Eq, serde_derive::Deserialize)]
+#[derive(Clone, Debug, PartialEq, Eq, serde_derive::Deserialize, schemars::JsonSchema)]
 #[serde(tag = "kind")]
 #[serde(rename_all = "kebab-case")]
 pub enum StackProbeType {
@@ -1235,6 +1287,19 @@ impl FromStr for SanitizerSet {
 }
 
 crate::json::serde_deserialize_from_str!(SanitizerSet);
+impl schemars::JsonSchema for SanitizerSet {
+    fn schema_name() -> std::borrow::Cow<'static, str> {
+        "SanitizerSet".into()
+    }
+    fn json_schema(_: &mut schemars::SchemaGenerator) -> schemars::Schema {
+        let all = Self::all().iter().map(|sanitizer| sanitizer.as_str()).collect::<Vec<_>>();
+        schemars::json_schema! ({
+            "type": "string",
+            "enum": all,
+        })
+        .into()
+    }
+}
 
 impl ToJson for SanitizerSet {
     fn to_json(&self) -> Json {
@@ -1328,7 +1393,6 @@ impl BinaryFormat {
     }
 }
 
-
 impl ToJson for Align {
     fn to_json(&self) -> Json {
         self.bits().to_json()
diff --git a/src/bootstrap/src/core/build_steps/dist.rs b/src/bootstrap/src/core/build_steps/dist.rs
index a5f0718bc01a4..99a1062109adc 100644
--- a/src/bootstrap/src/core/build_steps/dist.rs
+++ b/src/bootstrap/src/core/build_steps/dist.rs
@@ -590,6 +590,8 @@ impl Step for Rustc {
             // Debugger scripts
             builder.ensure(DebuggerScripts { sysroot: image.to_owned(), target });
 
+            generate_target_spec_json_schema(builder, image);
+
             // HTML copyright files
             let file_list = builder.ensure(super::run::GenerateCopyright);
             for file in file_list {
@@ -618,6 +620,28 @@ impl Step for Rustc {
     }
 }
 
+fn generate_target_spec_json_schema(builder: &Builder<'_>, sysroot: &Path) {
+    // Since we run rustc in bootstrap, we need to ensure that we use the host compiler.
+    // We do this by using the stage 1 compiler, which is always compiled for the host,
+    // even in a cross build.
+    let stage1_host = builder.compiler(1, builder.host_target);
+    let mut rustc = command(builder.rustc(stage1_host)).fail_fast();
+    rustc
+        .env("RUSTC_BOOTSTRAP", "1")
+        .args(["--print=target-spec-json-schema", "-Zunstable-options"]);
+    let schema = rustc.run_capture(builder).stdout();
+
+    let schema_dir = tmpdir(builder);
+    t!(fs::create_dir_all(&schema_dir));
+    let schema_file = schema_dir.join("target-spec-json-schema.json");
+    t!(std::fs::write(&schema_file, schema));
+
+    let dst = sysroot.join("etc");
+    t!(fs::create_dir_all(&dst));
+
+    builder.install(&schema_file, &dst, FileType::Regular);
+}
+
 /// Copies debugger scripts for `target` into the given compiler `sysroot`.
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub struct DebuggerScripts {
diff --git a/src/bootstrap/src/utils/proc_macro_deps.rs b/src/bootstrap/src/utils/proc_macro_deps.rs
index 777c8601aa1dc..db2369097d6ce 100644
--- a/src/bootstrap/src/utils/proc_macro_deps.rs
+++ b/src/bootstrap/src/utils/proc_macro_deps.rs
@@ -43,6 +43,7 @@ pub static CRATES: &[&str] = &[
     "rustc-hash",
     "self_cell",
     "serde",
+    "serde_derive_internals",
     "sha2",
     "smallvec",
     "stable_deref_trait",
diff --git a/src/doc/rustc/src/targets/custom.md b/src/doc/rustc/src/targets/custom.md
index 6c1494186a4ed..e1750e27f0b75 100644
--- a/src/doc/rustc/src/targets/custom.md
+++ b/src/doc/rustc/src/targets/custom.md
@@ -16,6 +16,21 @@ rustc +nightly -Z unstable-options --target=wasm32-unknown-unknown --print targe
 
 To use a custom target, see the (unstable) [`build-std` feature](../../cargo/reference/unstable.html#build-std) of `cargo`.
 
+<div class="warning">
+
+The target JSON properties are not stable and subject to change.
+Always pin your compiler version when using custom targets!
+
+</div>
+
+## JSON Schema
+
+`rustc` provides a JSON schema for the custom target JSON specification.
+Because the schema is subject to change, you should always use the schema from the version of rustc which you are passing the target to.
+
+It can be found in `etc/target-spec-json-schema.json` in the sysroot (`rustc --print sysroot`) or printed with `rustc +nightly -Zunstable-options --print target-spec-json-schema`.
+The existence and name of this schema is, just like the properties of the JSON specification, not stable and subject to change.
+
 ## Custom Target Lookup Path
 
 When `rustc` is given an option `--target=TARGET` (where `TARGET` is any string), it uses the following logic:
diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs
index 60347b2ea6456..a980476140077 100644
--- a/src/tools/tidy/src/deps.rs
+++ b/src/tools/tidy/src/deps.rs
@@ -267,6 +267,7 @@ const PERMITTED_RUSTC_DEPENDENCIES: &[&str] = &[
     "digest",
     "displaydoc",
     "dissimilar",
+    "dyn-clone",
     "either",
     "elsa",
     "ena",
@@ -346,6 +347,8 @@ const PERMITTED_RUSTC_DEPENDENCIES: &[&str] = &[
     "rand_xorshift", // dependency for doc-tests in rustc_thread_pool
     "rand_xoshiro",
     "redox_syscall",
+    "ref-cast",
+    "ref-cast-impl",
     "regex",
     "regex-automata",
     "regex-syntax",
@@ -357,11 +360,14 @@ const PERMITTED_RUSTC_DEPENDENCIES: &[&str] = &[
     "rustix",
     "ruzstd", // via object in thorin-dwp
     "ryu",
+    "schemars",
+    "schemars_derive",
     "scoped-tls",
     "scopeguard",
     "self_cell",
     "serde",
     "serde_derive",
+    "serde_derive_internals",
     "serde_json",
     "serde_path_to_error",
     "sha1",
diff --git a/tests/run-make/print-request-help-stable-unstable/help-diff.diff b/tests/run-make/print-request-help-stable-unstable/help-diff.diff
index 07eafca327108..044302a19a016 100644
--- a/tests/run-make/print-request-help-stable-unstable/help-diff.diff
+++ b/tests/run-make/print-request-help-stable-unstable/help-diff.diff
@@ -2,6 +2,6 @@
  error: unknown print request: `xxx`
    |
 -  = help: valid print requests are: `calling-conventions`, `cfg`, `code-models`, `crate-name`, `deployment-target`, `file-names`, `host-tuple`, `link-args`, `native-static-libs`, `relocation-models`, `split-debuginfo`, `stack-protector-strategies`, `sysroot`, `target-cpus`, `target-features`, `target-libdir`, `target-list`, `tls-models`
-+  = help: valid print requests are: `all-target-specs-json`, `calling-conventions`, `cfg`, `check-cfg`, `code-models`, `crate-name`, `crate-root-lint-levels`, `deployment-target`, `file-names`, `host-tuple`, `link-args`, `native-static-libs`, `relocation-models`, `split-debuginfo`, `stack-protector-strategies`, `supported-crate-types`, `sysroot`, `target-cpus`, `target-features`, `target-libdir`, `target-list`, `target-spec-json`, `tls-models`
++  = help: valid print requests are: `all-target-specs-json`, `calling-conventions`, `cfg`, `check-cfg`, `code-models`, `crate-name`, `crate-root-lint-levels`, `deployment-target`, `file-names`, `host-tuple`, `link-args`, `native-static-libs`, `relocation-models`, `split-debuginfo`, `stack-protector-strategies`, `supported-crate-types`, `sysroot`, `target-cpus`, `target-features`, `target-libdir`, `target-list`, `target-spec-json`, `target-spec-json-schema`, `tls-models`
    = help: for more information, see the rustc book: https://doc.rust-lang.org/rustc/command-line-arguments.html#--print-print-compiler-information
  
diff --git a/tests/run-make/print-request-help-stable-unstable/unstable-invalid-print-request-help.err b/tests/run-make/print-request-help-stable-unstable/unstable-invalid-print-request-help.err
index 50ef340e3dd02..cc6c3c909b366 100644
--- a/tests/run-make/print-request-help-stable-unstable/unstable-invalid-print-request-help.err
+++ b/tests/run-make/print-request-help-stable-unstable/unstable-invalid-print-request-help.err
@@ -1,5 +1,5 @@
 error: unknown print request: `xxx`
   |
-  = help: valid print requests are: `all-target-specs-json`, `calling-conventions`, `cfg`, `check-cfg`, `code-models`, `crate-name`, `crate-root-lint-levels`, `deployment-target`, `file-names`, `host-tuple`, `link-args`, `native-static-libs`, `relocation-models`, `split-debuginfo`, `stack-protector-strategies`, `supported-crate-types`, `sysroot`, `target-cpus`, `target-features`, `target-libdir`, `target-list`, `target-spec-json`, `tls-models`
+  = help: valid print requests are: `all-target-specs-json`, `calling-conventions`, `cfg`, `check-cfg`, `code-models`, `crate-name`, `crate-root-lint-levels`, `deployment-target`, `file-names`, `host-tuple`, `link-args`, `native-static-libs`, `relocation-models`, `split-debuginfo`, `stack-protector-strategies`, `supported-crate-types`, `sysroot`, `target-cpus`, `target-features`, `target-libdir`, `target-list`, `target-spec-json`, `target-spec-json-schema`, `tls-models`
   = help: for more information, see the rustc book: https://doc.rust-lang.org/rustc/command-line-arguments.html#--print-print-compiler-information
 
diff --git a/tests/run-make/rustc-help/help-v.stdout b/tests/run-make/rustc-help/help-v.stdout
index 3fc297fb08e7d..cd161c51ee3b9 100644
--- a/tests/run-make/rustc-help/help-v.stdout
+++ b/tests/run-make/rustc-help/help-v.stdout
@@ -43,7 +43,7 @@ Options:
         --print <INFO>[=<FILE>]
                         Compiler information to print on stdout (or to a file)
                         INFO may be one of
-                        <all-target-specs-json|calling-conventions|cfg|check-cfg|code-models|crate-name|crate-root-lint-levels|deployment-target|file-names|host-tuple|link-args|native-static-libs|relocation-models|split-debuginfo|stack-protector-strategies|supported-crate-types|sysroot|target-cpus|target-features|target-libdir|target-list|target-spec-json|tls-models>.
+                        <all-target-specs-json|calling-conventions|cfg|check-cfg|code-models|crate-name|crate-root-lint-levels|deployment-target|file-names|host-tuple|link-args|native-static-libs|relocation-models|split-debuginfo|stack-protector-strategies|supported-crate-types|sysroot|target-cpus|target-features|target-libdir|target-list|target-spec-json|target-spec-json-schema|tls-models>.
     -g                  Equivalent to -C debuginfo=2
     -O                  Equivalent to -C opt-level=3
     -o <FILENAME>       Write output to FILENAME
diff --git a/tests/run-make/rustc-help/help.stdout b/tests/run-make/rustc-help/help.stdout
index caffe28f49899..74ec083bdee7a 100644
--- a/tests/run-make/rustc-help/help.stdout
+++ b/tests/run-make/rustc-help/help.stdout
@@ -43,7 +43,7 @@ Options:
         --print <INFO>[=<FILE>]
                         Compiler information to print on stdout (or to a file)
                         INFO may be one of
-                        <all-target-specs-json|calling-conventions|cfg|check-cfg|code-models|crate-name|crate-root-lint-levels|deployment-target|file-names|host-tuple|link-args|native-static-libs|relocation-models|split-debuginfo|stack-protector-strategies|supported-crate-types|sysroot|target-cpus|target-features|target-libdir|target-list|target-spec-json|tls-models>.
+                        <all-target-specs-json|calling-conventions|cfg|check-cfg|code-models|crate-name|crate-root-lint-levels|deployment-target|file-names|host-tuple|link-args|native-static-libs|relocation-models|split-debuginfo|stack-protector-strategies|supported-crate-types|sysroot|target-cpus|target-features|target-libdir|target-list|target-spec-json|target-spec-json-schema|tls-models>.
     -g                  Equivalent to -C debuginfo=2
     -O                  Equivalent to -C opt-level=3
     -o <FILENAME>       Write output to FILENAME
diff --git a/tests/ui/invalid-compile-flags/print-without-arg.stderr b/tests/ui/invalid-compile-flags/print-without-arg.stderr
index 3048a59d0d00c..4163d4e060220 100644
--- a/tests/ui/invalid-compile-flags/print-without-arg.stderr
+++ b/tests/ui/invalid-compile-flags/print-without-arg.stderr
@@ -3,5 +3,5 @@ error: Argument to option 'print' missing
            --print <INFO>[=<FILE>]
                                Compiler information to print on stdout (or to a file)
                                INFO may be one of
-                               <all-target-specs-json|calling-conventions|cfg|check-cfg|code-models|crate-name|crate-root-lint-levels|deployment-target|file-names|host-tuple|link-args|native-static-libs|relocation-models|split-debuginfo|stack-protector-strategies|supported-crate-types|sysroot|target-cpus|target-features|target-libdir|target-list|target-spec-json|tls-models>.
+                               <all-target-specs-json|calling-conventions|cfg|check-cfg|code-models|crate-name|crate-root-lint-levels|deployment-target|file-names|host-tuple|link-args|native-static-libs|relocation-models|split-debuginfo|stack-protector-strategies|supported-crate-types|sysroot|target-cpus|target-features|target-libdir|target-list|target-spec-json|target-spec-json-schema|tls-models>.
 
diff --git a/tests/ui/invalid-compile-flags/print.stderr b/tests/ui/invalid-compile-flags/print.stderr
index e3374eb1e6e7e..e8adbfd87d761 100644
--- a/tests/ui/invalid-compile-flags/print.stderr
+++ b/tests/ui/invalid-compile-flags/print.stderr
@@ -1,5 +1,5 @@
 error: unknown print request: `yyyy`
   |
-  = help: valid print requests are: `all-target-specs-json`, `calling-conventions`, `cfg`, `check-cfg`, `code-models`, `crate-name`, `crate-root-lint-levels`, `deployment-target`, `file-names`, `host-tuple`, `link-args`, `native-static-libs`, `relocation-models`, `split-debuginfo`, `stack-protector-strategies`, `supported-crate-types`, `sysroot`, `target-cpus`, `target-features`, `target-libdir`, `target-list`, `target-spec-json`, `tls-models`
+  = help: valid print requests are: `all-target-specs-json`, `calling-conventions`, `cfg`, `check-cfg`, `code-models`, `crate-name`, `crate-root-lint-levels`, `deployment-target`, `file-names`, `host-tuple`, `link-args`, `native-static-libs`, `relocation-models`, `split-debuginfo`, `stack-protector-strategies`, `supported-crate-types`, `sysroot`, `target-cpus`, `target-features`, `target-libdir`, `target-list`, `target-spec-json`, `target-spec-json-schema`, `tls-models`
   = help: for more information, see the rustc book: https://doc.rust-lang.org/rustc/command-line-arguments.html#--print-print-compiler-information
 
diff --git a/tests/ui/print-request/print-lints-help.stderr b/tests/ui/print-request/print-lints-help.stderr
index bc48b2fa73cc7..297a3aa79e1f3 100644
--- a/tests/ui/print-request/print-lints-help.stderr
+++ b/tests/ui/print-request/print-lints-help.stderr
@@ -1,6 +1,6 @@
 error: unknown print request: `lints`
   |
-  = help: valid print requests are: `all-target-specs-json`, `calling-conventions`, `cfg`, `check-cfg`, `code-models`, `crate-name`, `crate-root-lint-levels`, `deployment-target`, `file-names`, `host-tuple`, `link-args`, `native-static-libs`, `relocation-models`, `split-debuginfo`, `stack-protector-strategies`, `supported-crate-types`, `sysroot`, `target-cpus`, `target-features`, `target-libdir`, `target-list`, `target-spec-json`, `tls-models`
+  = help: valid print requests are: `all-target-specs-json`, `calling-conventions`, `cfg`, `check-cfg`, `code-models`, `crate-name`, `crate-root-lint-levels`, `deployment-target`, `file-names`, `host-tuple`, `link-args`, `native-static-libs`, `relocation-models`, `split-debuginfo`, `stack-protector-strategies`, `supported-crate-types`, `sysroot`, `target-cpus`, `target-features`, `target-libdir`, `target-list`, `target-spec-json`, `target-spec-json-schema`, `tls-models`
   = help: use `-Whelp` to print a list of lints
   = help: for more information, see the rustc book: https://doc.rust-lang.org/rustc/command-line-arguments.html#--print-print-compiler-information
 

From 79643ad48a9cd72066d2683fb7744380bb286074 Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Fri, 12 Sep 2025 13:54:11 -0500
Subject: [PATCH 0863/1889] Improve `core::hash` coverage

---
 library/coretests/tests/hash/mod.rs | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/library/coretests/tests/hash/mod.rs b/library/coretests/tests/hash/mod.rs
index 1f10a4733b053..043a3ee742332 100644
--- a/library/coretests/tests/hash/mod.rs
+++ b/library/coretests/tests/hash/mod.rs
@@ -53,12 +53,14 @@ fn test_writer_hasher() {
     assert_eq!(hash(&5_u16), 5);
     assert_eq!(hash(&5_u32), 5);
     assert_eq!(hash(&5_u64), 5);
+    assert_eq!(hash(&5_u128), 5);
     assert_eq!(hash(&5_usize), 5);
 
     assert_eq!(hash(&5_i8), 5);
     assert_eq!(hash(&5_i16), 5);
     assert_eq!(hash(&5_i32), 5);
     assert_eq!(hash(&5_i64), 5);
+    assert_eq!(hash(&5_i128), 5);
     assert_eq!(hash(&5_isize), 5);
 
     assert_eq!(hash(&false), 0);
@@ -85,6 +87,17 @@ fn test_writer_hasher() {
     let ptr = ptr::without_provenance_mut::<i32>(5_usize);
     assert_eq!(hash(&ptr), 5);
 
+    // Use a newtype to test the `Hash::hash_slice` default implementation.
+    struct Byte(u8);
+
+    impl Hash for Byte {
+        fn hash<H: Hasher>(&self, state: &mut H) {
+            state.write_u8(self.0)
+        }
+    }
+
+    assert_eq!(hash(&[Byte(b'a')]), 97 + 1);
+
     if cfg!(miri) {
         // Miri cannot hash pointers
         return;

From 4383a4f73b0de8dd1d22ab5d3677f89a9d8a82b4 Mon Sep 17 00:00:00 2001
From: Jonathan 'theJPster' Pallant <github@thejpster.org.uk>
Date: Fri, 12 Sep 2025 20:26:41 +0100
Subject: [PATCH 0864/1889] Remove bullet points from the target maintainer
 list for the arm bare-metal targets

---
 src/doc/rustc/src/platform-support/aarch64-unknown-none.md    | 2 +-
 src/doc/rustc/src/platform-support/armebv7r-none-eabi.md      | 2 +-
 src/doc/rustc/src/platform-support/armv7a-none-eabi.md        | 2 +-
 src/doc/rustc/src/platform-support/armv7r-none-eabi.md        | 4 ++--
 src/doc/rustc/src/platform-support/armv8r-none-eabihf.md      | 4 ++--
 src/doc/rustc/src/platform-support/thumbv6m-none-eabi.md      | 2 +-
 src/doc/rustc/src/platform-support/thumbv7em-none-eabi.md     | 2 +-
 src/doc/rustc/src/platform-support/thumbv7m-none-eabi.md      | 2 +-
 src/doc/rustc/src/platform-support/thumbv8m.base-none-eabi.md | 2 +-
 src/doc/rustc/src/platform-support/thumbv8m.main-none-eabi.md | 2 +-
 10 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/doc/rustc/src/platform-support/aarch64-unknown-none.md b/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
index bcdf4271b1279..cc3a24ba04069 100644
--- a/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
+++ b/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
@@ -13,7 +13,7 @@ Processors in this family include the [Arm Cortex-A35, 53, 76, etc][aarch64-cpus
 
 ## Target maintainers
 
-* [Rust Embedded Devices Working Group Arm Team]
+[Rust Embedded Devices Working Group Arm Team]
 
 [Rust Embedded Devices Working Group Arm Team]: https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team
 
diff --git a/src/doc/rustc/src/platform-support/armebv7r-none-eabi.md b/src/doc/rustc/src/platform-support/armebv7r-none-eabi.md
index a5efd4adb9733..d5f828110f162 100644
--- a/src/doc/rustc/src/platform-support/armebv7r-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/armebv7r-none-eabi.md
@@ -19,7 +19,7 @@ See [`arm-none-eabi`](arm-none-eabi.md) for information applicable to all
 
 ## Target maintainers
 
-* [@chrisnc](https://github.com/chrisnc)
+[@chrisnc](https://github.com/chrisnc)
 
 ## Requirements
 
diff --git a/src/doc/rustc/src/platform-support/armv7a-none-eabi.md b/src/doc/rustc/src/platform-support/armv7a-none-eabi.md
index 77c463697bf6e..0646e7634d7ab 100644
--- a/src/doc/rustc/src/platform-support/armv7a-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/armv7a-none-eabi.md
@@ -18,7 +18,7 @@ See [`arm-none-eabi`](arm-none-eabi.md) for information applicable to all
 
 ## Target maintainers
 
-* [Rust Embedded Devices Working Group Arm Team]
+[Rust Embedded Devices Working Group Arm Team]
 
 [Rust Embedded Devices Working Group Arm Team]: https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team
 
diff --git a/src/doc/rustc/src/platform-support/armv7r-none-eabi.md b/src/doc/rustc/src/platform-support/armv7r-none-eabi.md
index 36980a36b19a1..9cda9c502543f 100644
--- a/src/doc/rustc/src/platform-support/armv7r-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/armv7r-none-eabi.md
@@ -14,8 +14,8 @@ See [`arm-none-eabi`](arm-none-eabi.md) for information applicable to all
 
 ## Target maintainers
 
-* [@chrisnc](https://github.com/chrisnc)
-* [Rust Embedded Devices Working Group Arm Team]
+[@chrisnc](https://github.com/chrisnc)
+[Rust Embedded Devices Working Group Arm Team]
 
 [Rust Embedded Devices Working Group Arm Team]: https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team
 
diff --git a/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md b/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md
index ed0102f48e081..eb7f8921ad0ef 100644
--- a/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md
+++ b/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md
@@ -16,8 +16,8 @@ See [`arm-none-eabi`](arm-none-eabi.md) for information applicable to all
 
 ## Target maintainers
 
-* [@chrisnc](https://github.com/chrisnc)
-* [Rust Embedded Devices Working Group Arm Team]
+[@chrisnc](https://github.com/chrisnc)
+[Rust Embedded Devices Working Group Arm Team]
 
 [Rust Embedded Devices Working Group Arm Team]: https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team
 
diff --git a/src/doc/rustc/src/platform-support/thumbv6m-none-eabi.md b/src/doc/rustc/src/platform-support/thumbv6m-none-eabi.md
index 746b84435479f..ca47d96cf65f0 100644
--- a/src/doc/rustc/src/platform-support/thumbv6m-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/thumbv6m-none-eabi.md
@@ -26,7 +26,7 @@ only option because there is no FPU support in [Armv6-M].
 
 ## Target maintainers
 
-* [Rust Embedded Devices Working Group Arm Team](https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team)
+[Rust Embedded Devices Working Group Arm Team](https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team)
 
 ## Target CPU and Target Feature options
 
diff --git a/src/doc/rustc/src/platform-support/thumbv7em-none-eabi.md b/src/doc/rustc/src/platform-support/thumbv7em-none-eabi.md
index 12e28265678c5..9de708cda2424 100644
--- a/src/doc/rustc/src/platform-support/thumbv7em-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/thumbv7em-none-eabi.md
@@ -21,7 +21,7 @@ See [`arm-none-eabi`](arm-none-eabi.md) for information applicable to all
 
 ## Target maintainers
 
-* [Rust Embedded Devices Working Group Arm Team](https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team)
+[Rust Embedded Devices Working Group Arm Team](https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team)
 
 ## Target CPU and Target Feature options
 
diff --git a/src/doc/rustc/src/platform-support/thumbv7m-none-eabi.md b/src/doc/rustc/src/platform-support/thumbv7m-none-eabi.md
index 03324b341d07f..05c9146e6d06e 100644
--- a/src/doc/rustc/src/platform-support/thumbv7m-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/thumbv7m-none-eabi.md
@@ -22,7 +22,7 @@ only option because there is no FPU support in [Armv7-M].
 
 ## Target maintainers
 
-* [Rust Embedded Devices Working Group Arm Team](https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team)
+[Rust Embedded Devices Working Group Arm Team](https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team)
 
 ## Target CPU and Target Feature options
 
diff --git a/src/doc/rustc/src/platform-support/thumbv8m.base-none-eabi.md b/src/doc/rustc/src/platform-support/thumbv8m.base-none-eabi.md
index 4a92e856466c0..92585f49bd854 100644
--- a/src/doc/rustc/src/platform-support/thumbv8m.base-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/thumbv8m.base-none-eabi.md
@@ -22,7 +22,7 @@ only option because there is no FPU support in [Armv8-M] Baseline.
 
 ## Target maintainers
 
-* [Rust Embedded Devices Working Group Arm Team](https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team)
+[Rust Embedded Devices Working Group Arm Team](https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team)
 
 ## Target CPU and Target Feature options
 
diff --git a/src/doc/rustc/src/platform-support/thumbv8m.main-none-eabi.md b/src/doc/rustc/src/platform-support/thumbv8m.main-none-eabi.md
index 9f85d08fa0acd..960cf31567d1e 100644
--- a/src/doc/rustc/src/platform-support/thumbv8m.main-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/thumbv8m.main-none-eabi.md
@@ -25,7 +25,7 @@ See [`arm-none-eabi`](arm-none-eabi.md) for information applicable to all
 
 ## Target maintainers
 
-* [Rust Embedded Devices Working Group Arm Team](https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team)
+[Rust Embedded Devices Working Group Arm Team](https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team)
 
 ## Target CPU and Target Feature options
 

From afe8f81c73244bcc33be39c9ea0f90f090ac14ce Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Fri, 12 Sep 2025 14:35:20 -0500
Subject: [PATCH 0865/1889] Improve `core::num` coverage

---
 library/coretests/tests/num/mod.rs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/library/coretests/tests/num/mod.rs b/library/coretests/tests/num/mod.rs
index 54e54f734f647..913f766ec1683 100644
--- a/library/coretests/tests/num/mod.rs
+++ b/library/coretests/tests/num/mod.rs
@@ -111,6 +111,13 @@ fn from_str_issue7588() {
     assert_eq!(s, None);
 }
 
+#[test]
+#[should_panic = "radix must lie in the range `[2, 36]`"]
+fn from_ascii_radix_panic() {
+    let radix = 1;
+    let _parsed = u64::from_str_radix("12345ABCD", radix);
+}
+
 #[test]
 fn test_int_from_str_overflow() {
     test_parse::<i8>("127", Ok(127));

From ea661e9353e5dfa2c37f45ad44e52d97d5006447 Mon Sep 17 00:00:00 2001
From: Jonathan 'theJPster' Pallant <github@thejpster.org.uk>
Date: Fri, 12 Sep 2025 20:38:00 +0100
Subject: [PATCH 0866/1889] Re-order and re-work the aarch64-unknown-none
 platform support page.

Removes a bunch of information that isn't, strictly speaking, target specific.
---
 .../platform-support/aarch64-unknown-none.md  | 77 ++++---------------
 1 file changed, 17 insertions(+), 60 deletions(-)

diff --git a/src/doc/rustc/src/platform-support/aarch64-unknown-none.md b/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
index cc3a24ba04069..25d99e4f0dea9 100644
--- a/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
+++ b/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
@@ -19,44 +19,19 @@ Processors in this family include the [Arm Cortex-A35, 53, 76, etc][aarch64-cpus
 
 ## Target CPU and Target Feature options
 
-It is possible to tell Rust (or LLVM) that you have a specific model of Arm
-processor, using the [`-Ctarget-cpu`][target-cpu] option. You can also control
-whether Rust (or LLVM) will include instructions that target optional hardware
-features, e.g. hardware floating-point, or Advanced SIMD operations, using
-[`-Ctarget-feature`][target-feature].
-
-It is important to note that selecting a *target-cpu* will typically enable
-*all* the optional features available from Arm on that model of CPU and your
-particular implementation of that CPU may not have those features available.
-In that case, you can use `-Ctarget-feature=-option` to turn off the specific
-CPU features you do not have available, leaving you with the optimized
-instruction scheduling and support for the features you do have. More details
-are available in the detailed target-specific documentation.
-
-<div class="warning">
-
-Many target-features are currently unstable and subject to change, and
-if you use them you should disassemble the compiler output and manually inspect
-it to ensure only appropriate instructions for your CPU have been generated.
-
-</div>
-
-If you wish to use the *target-cpu* and *target-feature* options, you can add
-them to your `.cargo/config.toml` file alongside any other flags your project
-uses (likely linker related ones):
+All AArch64 processors include an FPU. The difference between the `-none` and
+`-none-softfloat` targets is whether the FPU is used for passing function arguments.
+You may prefer the `-softfloat` target when writing a kernel or interfacing with
+pre-compiled binaries that use the soft-float ABI.
 
-```toml
-rustflags = [
-  # Usual Arm bare-metal linker setup
-  "-Clink-arg=-Tlink.x",
-  "-Clink-arg=--nmagic",
-  # tell Rust we have a Cortex-A72
-  "-Ctarget-cpu=cortex-a72",
-]
-
-[build]
-target = "aarch64-unknown-none"
-```
+When using the hardfloat targets, the minimum floating-point features assumed
+are those of the `fp-armv8`, which excludes NEON SIMD support. If your
+processor supports a different set of floating-point features than the default
+expectations of `fp-armv8`, then these should also be enabled or disabled as
+needed with `-C target-feature=(+/-)`. It is also possible to tell Rust (or
+LLVM) that you have a specific model of Arm processor, using the
+[`-Ctarget-cpu`][target-cpu] option. Doing so may change the default set of
+target-features enabled.
 
 [target-cpu]: https://doc.rust-lang.org/rustc/codegen-options/index.html#target-cpu
 [target-feature]: https://doc.rust-lang.org/rustc/codegen-options/index.html#target-feature
@@ -72,10 +47,10 @@ package manager. To use it, add the following to your `.cargo/config.toml`:
 
 ```toml
 [target.aarch64-unknown-none]
-linker = "aarch64-none-ld"
+linker = "aarch64-none-elf-ld"
 ```
 
-The GNU linker can also be used by specifying `aarch64-none-gcc` as the
+The GNU linker can also be used by specifying `aarch64-none-elf-gcc` as the
 linker. This is needed when using GCC's link time optimization.
 
 These targets don't provide a linker script, so you'll need to bring your own
@@ -83,25 +58,12 @@ according to the specific device you are using. Pass
 `-Clink-arg=-Tyour_script.ld` as a rustc argument to make the linker use
 `your_script.ld` during linking.
 
-All AArch64 processors include an FPU. The difference between the `-none` and
-`-none-softfloat` targets is whether the FPU is used for passing function arguments.
-You may prefer the `-softfloat` target when writing a kernel or interfacing with
-pre-compiled binaries that use the soft-float ABI.
-
-When using the hardfloat targets, the minimum floating-point features assumed
-are those of the `fp-armv8`, which excludes NEON SIMD support. If your
-processor supports a different set of floating-point features than the default
-expectations of `fp-armv8`, then these should also be enabled or disabled as
-needed with `-C target-feature=(+/-)`.
-
 [arm-gnu-toolchain]: https://developer.arm.com/Tools%20and%20Software/GNU%20Toolchain
 
-## Testing
-
-This is a cross-compiled target that you will need to emulate during testing.
+## Cross-compilation toolchains and C code
 
-The exact emulator that you'll need depends on the specific device you want to
-run your code on.
+This target supports C code compiled with the `aarch64-none-elf` target
+triple and a suitable `-march` or `-mcpu` flag.
 
 ## Start-up and Low-Level Code
 
@@ -113,8 +75,3 @@ The *TrustedFirmware* group also maintain [Rust crates for this
 target](https://github.com/ArmFirmwareCrates).
 
 [`aarch64-cpu`]: https://docs.rs/aarch64-cpu
-
-## Cross-compilation toolchains and C code
-
-This target supports C code compiled with the `aarch64-unknown-none` target
-triple and a suitable `-march` or `-mcpu` flag.

From 87ae4dbf5cc1e81db845c659583aa489d532ae8c Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Fri, 12 Sep 2025 14:41:26 -0500
Subject: [PATCH 0867/1889] Improve `core::ptr` coverage

---
 library/coretests/tests/ptr.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/library/coretests/tests/ptr.rs b/library/coretests/tests/ptr.rs
index f8774833d0a54..4d5138d539b95 100644
--- a/library/coretests/tests/ptr.rs
+++ b/library/coretests/tests/ptr.rs
@@ -489,6 +489,14 @@ fn is_aligned() {
     assert_ne!(ptr.is_aligned_to(8), ptr.wrapping_add(1).is_aligned_to(8));
 }
 
+#[test]
+#[should_panic = "is_aligned_to: align is not a power-of-two"]
+fn invalid_is_aligned() {
+    let data = 42;
+    let ptr: *const i32 = &data;
+    assert!(ptr.is_aligned_to(3));
+}
+
 #[test]
 fn offset_from() {
     let mut a = [0; 5];

From 4d273c4d91fc31b02c345f0dadea4a0b751f0238 Mon Sep 17 00:00:00 2001
From: Jonathan 'theJPster' Pallant <github@thejpster.org.uk>
Date: Fri, 12 Sep 2025 20:45:34 +0100
Subject: [PATCH 0868/1889] Fix two typos spotted in review

---
 src/doc/rustc/src/platform-support/arm-linux.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/doc/rustc/src/platform-support/arm-linux.md b/src/doc/rustc/src/platform-support/arm-linux.md
index 5f320762e9378..5f40743f3d070 100644
--- a/src/doc/rustc/src/platform-support/arm-linux.md
+++ b/src/doc/rustc/src/platform-support/arm-linux.md
@@ -108,7 +108,7 @@ running this code on. For example, running `eabihf` code on an `eabi` system
 will not work correctly.
 
 The `gnueabi` ABI component indicates support for using the GNU C Library
-(glibc), and the Arm Embedded ABI (EABI). The EABI is a replacement of for the
+(glibc), and the Arm Embedded ABI (EABI). The EABI is a replacement for the
 original ABI (now called the Old ABI or OABI), and it is the standard ABI for
 32-bit Arm systems. With this ABI, function parameters that are `f32` or `f64`
 are passed as if they were integers, instead of being passed via in FPU
@@ -128,9 +128,9 @@ depending on whether your distribution is using 'soft-float' (EABI) or
 
 The `musleabi` and `musleabihf` ABI components offer support for the [musl C
 library](https://musl.libc.org/). This C library can be used to create 'static
-binaries' that have no run-time library requirements (a feature that that
-glibc does not support). There are soft-float (`eabi`) and hard-float
-(`eabihf`) variants, as per the `gnu*` targets above.
+binaries' that have no run-time library requirements (a feature that glibc
+does not support). There are soft-float (`eabi`) and hard-float (`eabihf`)
+variants, as per the `gnu*` targets above.
 
 The `uclibceabi` and `uclibceabihf` ABI components are for the [uClibc-ng C
 library](https://uclibc-ng.org/). This is sometimes used in light-weight

From 16c218c57ff83c82ba58753c3a67f697e260adc1 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 15 Aug 2025 16:12:35 -0500
Subject: [PATCH 0869/1889] Introduce trait_item_of

---
 .../src/diagnostics/mutability_errors.rs         |  2 +-
 compiler/rustc_codegen_ssa/src/codegen_attrs.rs  | 16 ++++------------
 .../src/collect/predicates_of.rs                 |  5 ++---
 .../rustc_hir_analysis/src/collect/type_of.rs    |  4 ++--
 compiler/rustc_middle/src/ty/mod.rs              |  9 +++++++++
 compiler/rustc_passes/src/dead.rs                | 12 +++++-------
 .../src/cfi/typeid/itanium_cxx_abi/transform.rs  |  3 +--
 compiler/rustc_ty_utils/src/implied_bounds.rs    |  2 +-
 .../src/functions/renamed_function_params.rs     | 10 ++--------
 .../clippy_lints/src/only_used_in_recursion.rs   |  2 +-
 src/tools/clippy/clippy_lints/src/use_self.rs    |  3 +--
 11 files changed, 29 insertions(+), 39 deletions(-)

diff --git a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
index ea264c8064ad1..6d69040c711d9 100644
--- a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
@@ -716,7 +716,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
             return (false, false, None);
         };
 
-        let implemented_trait_item = self.infcx.tcx.associated_item(my_def).trait_item_def_id;
+        let implemented_trait_item = self.infcx.tcx.trait_item_of(my_def);
 
         (
             true,
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
index 008340e614de4..dc500c363f4a7 100644
--- a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
+++ b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -562,15 +562,6 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
     codegen_fn_attrs
 }
 
-/// If the provided DefId is a method in a trait impl, return the DefId of the method prototype.
-fn opt_trait_item(tcx: TyCtxt<'_>, def_id: DefId) -> Option<DefId> {
-    let impl_item = tcx.opt_associated_item(def_id)?;
-    match impl_item.container {
-        ty::AssocItemContainer::Impl => impl_item.trait_item_def_id,
-        _ => None,
-    }
-}
-
 fn disabled_sanitizers_for(tcx: TyCtxt<'_>, did: LocalDefId) -> SanitizerSet {
     // Backtrack to the crate root.
     let mut disabled = match tcx.opt_local_parent(did) {
@@ -600,14 +591,15 @@ fn disabled_sanitizers_for(tcx: TyCtxt<'_>, did: LocalDefId) -> SanitizerSet {
 /// Checks if the provided DefId is a method in a trait impl for a trait which has track_caller
 /// applied to the method prototype.
 fn should_inherit_track_caller(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
-    let Some(trait_item) = opt_trait_item(tcx, def_id) else { return false };
-    tcx.codegen_fn_attrs(trait_item).flags.intersects(CodegenFnAttrFlags::TRACK_CALLER)
+    tcx.trait_item_of(def_id).is_some_and(|id| {
+        tcx.codegen_fn_attrs(id).flags.intersects(CodegenFnAttrFlags::TRACK_CALLER)
+    })
 }
 
 /// If the provided DefId is a method in a trait impl, return the value of the `#[align]`
 /// attribute on the method prototype (if any).
 fn inherited_align<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Option<Align> {
-    tcx.codegen_fn_attrs(opt_trait_item(tcx, def_id)?).alignment
+    tcx.codegen_fn_attrs(tcx.trait_item_of(def_id)?).alignment
 }
 
 /// We now check the #\[rustc_autodiff\] attributes which we generated from the #[autodiff(...)]
diff --git a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
index 126ffabd448c7..dd3590f9ac5dc 100644
--- a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
@@ -111,9 +111,8 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
         }
 
         Some(ImplTraitInTraitData::Impl { fn_def_id }) => {
-            let assoc_item = tcx.associated_item(def_id);
-            let trait_assoc_predicates =
-                tcx.explicit_predicates_of(assoc_item.trait_item_def_id.unwrap());
+            let trait_item_def_id = tcx.trait_item_of(def_id).unwrap();
+            let trait_assoc_predicates = tcx.explicit_predicates_of(trait_item_def_id);
 
             let impl_assoc_identity_args = ty::GenericArgs::identity_for_item(tcx, def_id);
             let impl_def_id = tcx.parent(fn_def_id);
diff --git a/compiler/rustc_hir_analysis/src/collect/type_of.rs b/compiler/rustc_hir_analysis/src/collect/type_of.rs
index 62125c99d8021..a8af73717cd0c 100644
--- a/compiler/rustc_hir_analysis/src/collect/type_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/type_of.rs
@@ -125,8 +125,8 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<'_
         Some(ty::ImplTraitInTraitData::Impl { fn_def_id }) => {
             match tcx.collect_return_position_impl_trait_in_trait_tys(fn_def_id) {
                 Ok(map) => {
-                    let assoc_item = tcx.associated_item(def_id);
-                    return map[&assoc_item.trait_item_def_id.unwrap()];
+                    let trait_item_def_id = tcx.trait_item_of(def_id).unwrap();
+                    return map[&trait_item_def_id];
                 }
                 Err(_) => {
                     return ty::EarlyBinder::bind(Ty::new_error_with_message(
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index da17ec1f9f379..5a4ebfe28a4b5 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -1934,6 +1934,15 @@ impl<'tcx> TyCtxt<'tcx> {
         Some((parent, def_kind))
     }
 
+    /// Returns the trait item that is implemented by the given item `DefId`.
+    pub fn trait_item_of(self, def_id: impl IntoQueryParam<DefId>) -> Option<DefId> {
+        let assoc = self.opt_associated_item(def_id.into_query_param())?;
+        if assoc.container != AssocItemContainer::Impl {
+            return None;
+        }
+        assoc.trait_item_def_id
+    }
+
     /// If the given `DefId` is an associated item of a trait,
     /// returns the `DefId` of the trait; otherwise, returns `None`.
     pub fn trait_of_assoc(self, def_id: DefId) -> Option<DefId> {
diff --git a/compiler/rustc_passes/src/dead.rs b/compiler/rustc_passes/src/dead.rs
index fc33405d455b2..f36a7a5b184a7 100644
--- a/compiler/rustc_passes/src/dead.rs
+++ b/compiler/rustc_passes/src/dead.rs
@@ -484,13 +484,11 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
     fn check_impl_or_impl_item_live(&mut self, local_def_id: LocalDefId) -> bool {
         let (impl_block_id, trait_def_id) = match self.tcx.def_kind(local_def_id) {
             // assoc impl items of traits are live if the corresponding trait items are live
-            DefKind::AssocConst | DefKind::AssocTy | DefKind::AssocFn => (
-                self.tcx.local_parent(local_def_id),
-                self.tcx
-                    .associated_item(local_def_id)
-                    .trait_item_def_id
-                    .and_then(|def_id| def_id.as_local()),
-            ),
+            DefKind::AssocConst | DefKind::AssocTy | DefKind::AssocFn => {
+                let trait_item_id =
+                    self.tcx.trait_item_of(local_def_id).and_then(|def_id| def_id.as_local());
+                (self.tcx.local_parent(local_def_id), trait_item_id)
+            }
             // impl items are live if the corresponding traits are live
             DefKind::Impl { of_trait: true } => (
                 local_def_id,
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 d81fa062e0102..577a16a0d2573 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
@@ -469,8 +469,7 @@ fn implemented_method<'tcx>(
     let ancestor = if let Some(impl_id) = tcx.impl_of_assoc(instance.def_id()) {
         // Implementation in an `impl` block
         trait_ref = tcx.impl_trait_ref(impl_id)?;
-        let impl_method = tcx.associated_item(instance.def_id());
-        method_id = impl_method.trait_item_def_id?;
+        method_id = tcx.trait_item_of(instance.def_id())?;
         trait_method = tcx.associated_item(method_id);
         trait_id = trait_ref.skip_binder().def_id;
         impl_id
diff --git a/compiler/rustc_ty_utils/src/implied_bounds.rs b/compiler/rustc_ty_utils/src/implied_bounds.rs
index cdfb93c4e7d56..543f6a3ccf794 100644
--- a/compiler/rustc_ty_utils/src/implied_bounds.rs
+++ b/compiler/rustc_ty_utils/src/implied_bounds.rs
@@ -107,7 +107,7 @@ fn assumed_wf_types<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> &'tcx [(Ty<'
                 // the assumed wf types of the trait's RPITIT GAT.
                 ty::ImplTraitInTraitData::Impl { .. } => {
                     let impl_def_id = tcx.local_parent(def_id);
-                    let rpitit_def_id = tcx.associated_item(def_id).trait_item_def_id.unwrap();
+                    let rpitit_def_id = tcx.trait_item_of(def_id).unwrap();
                     let args = ty::GenericArgs::identity_for_item(tcx, def_id).rebase_onto(
                         tcx,
                         impl_def_id.to_def_id(),
diff --git a/src/tools/clippy/clippy_lints/src/functions/renamed_function_params.rs b/src/tools/clippy/clippy_lints/src/functions/renamed_function_params.rs
index f8e8f5544b993..e25611d48817a 100644
--- a/src/tools/clippy/clippy_lints/src/functions/renamed_function_params.rs
+++ b/src/tools/clippy/clippy_lints/src/functions/renamed_function_params.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_errors::{Applicability, MultiSpan};
-use rustc_hir::def_id::{DefId, DefIdSet};
-use rustc_hir::hir_id::OwnerId;
+use rustc_hir::def_id::DefIdSet;
 use rustc_hir::{Impl, ImplItem, ImplItemKind, ItemKind, Node, TraitRef};
 use rustc_lint::LateContext;
 use rustc_span::Span;
@@ -19,7 +18,7 @@ pub(super) fn check_impl_item(cx: &LateContext<'_>, item: &ImplItem<'_>, ignored
             of_trait: Some(of_trait),
             ..
         }) = &parent_item.kind
-        && let Some(did) = trait_item_def_id_of_impl(cx, item.owner_id)
+        && let Some(did) = cx.tcx.trait_item_of(item.owner_id)
         && !is_from_ignored_trait(&of_trait.trait_ref, ignored_traits)
     {
         let mut param_idents_iter = cx.tcx.hir_body_param_idents(body_id);
@@ -87,11 +86,6 @@ impl RenamedFnArgs {
     }
 }
 
-/// Get the [`trait_item_def_id`](ImplItemRef::trait_item_def_id) of a relevant impl item.
-fn trait_item_def_id_of_impl(cx: &LateContext<'_>, target: OwnerId) -> Option<DefId> {
-    cx.tcx.associated_item(target).trait_item_def_id
-}
-
 fn is_from_ignored_trait(of_trait: &TraitRef<'_>, ignored_traits: &DefIdSet) -> bool {
     of_trait
         .trait_def_id()
diff --git a/src/tools/clippy/clippy_lints/src/only_used_in_recursion.rs b/src/tools/clippy/clippy_lints/src/only_used_in_recursion.rs
index 809a6728e1280..c4cad592e3675 100644
--- a/src/tools/clippy/clippy_lints/src/only_used_in_recursion.rs
+++ b/src/tools/clippy/clippy_lints/src/only_used_in_recursion.rs
@@ -248,7 +248,7 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
                         .tcx
                         .impl_trait_ref(item.owner_id)
                         .map(EarlyBinder::instantiate_identity)
-                    && let Some(trait_item_id) = cx.tcx.associated_item(owner_id).trait_item_def_id
+                    && let Some(trait_item_id) = cx.tcx.trait_item_of(owner_id)
                 {
                     (
                         trait_item_id,
diff --git a/src/tools/clippy/clippy_lints/src/use_self.rs b/src/tools/clippy/clippy_lints/src/use_self.rs
index aeda864b7eb5e..8252e6d48694b 100644
--- a/src/tools/clippy/clippy_lints/src/use_self.rs
+++ b/src/tools/clippy/clippy_lints/src/use_self.rs
@@ -151,8 +151,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
             // trait, not in the impl of the trait.
             let trait_method = cx
                 .tcx
-                .associated_item(impl_item.owner_id)
-                .trait_item_def_id
+                .trait_item_of(impl_item.owner_id)
                 .expect("impl method matches a trait method");
             let trait_method_sig = cx.tcx.fn_sig(trait_method).instantiate_identity();
             let trait_method_sig = cx.tcx.instantiate_bound_regions_with_erased(trait_method_sig);

From 8d5078e0490f4a07afc86af60fd78f1f6dabdb4b Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 15 Aug 2025 16:12:35 -0500
Subject: [PATCH 0870/1889] Introduce trait_item_of

---
 clippy_lints/src/functions/renamed_function_params.rs | 10 ++--------
 clippy_lints/src/only_used_in_recursion.rs            |  2 +-
 clippy_lints/src/use_self.rs                          |  3 +--
 3 files changed, 4 insertions(+), 11 deletions(-)

diff --git a/clippy_lints/src/functions/renamed_function_params.rs b/clippy_lints/src/functions/renamed_function_params.rs
index f8e8f5544b993..e25611d48817a 100644
--- a/clippy_lints/src/functions/renamed_function_params.rs
+++ b/clippy_lints/src/functions/renamed_function_params.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_errors::{Applicability, MultiSpan};
-use rustc_hir::def_id::{DefId, DefIdSet};
-use rustc_hir::hir_id::OwnerId;
+use rustc_hir::def_id::DefIdSet;
 use rustc_hir::{Impl, ImplItem, ImplItemKind, ItemKind, Node, TraitRef};
 use rustc_lint::LateContext;
 use rustc_span::Span;
@@ -19,7 +18,7 @@ pub(super) fn check_impl_item(cx: &LateContext<'_>, item: &ImplItem<'_>, ignored
             of_trait: Some(of_trait),
             ..
         }) = &parent_item.kind
-        && let Some(did) = trait_item_def_id_of_impl(cx, item.owner_id)
+        && let Some(did) = cx.tcx.trait_item_of(item.owner_id)
         && !is_from_ignored_trait(&of_trait.trait_ref, ignored_traits)
     {
         let mut param_idents_iter = cx.tcx.hir_body_param_idents(body_id);
@@ -87,11 +86,6 @@ impl RenamedFnArgs {
     }
 }
 
-/// Get the [`trait_item_def_id`](ImplItemRef::trait_item_def_id) of a relevant impl item.
-fn trait_item_def_id_of_impl(cx: &LateContext<'_>, target: OwnerId) -> Option<DefId> {
-    cx.tcx.associated_item(target).trait_item_def_id
-}
-
 fn is_from_ignored_trait(of_trait: &TraitRef<'_>, ignored_traits: &DefIdSet) -> bool {
     of_trait
         .trait_def_id()
diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index 809a6728e1280..c4cad592e3675 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -248,7 +248,7 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
                         .tcx
                         .impl_trait_ref(item.owner_id)
                         .map(EarlyBinder::instantiate_identity)
-                    && let Some(trait_item_id) = cx.tcx.associated_item(owner_id).trait_item_def_id
+                    && let Some(trait_item_id) = cx.tcx.trait_item_of(owner_id)
                 {
                     (
                         trait_item_id,
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index aeda864b7eb5e..8252e6d48694b 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -151,8 +151,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
             // trait, not in the impl of the trait.
             let trait_method = cx
                 .tcx
-                .associated_item(impl_item.owner_id)
-                .trait_item_def_id
+                .trait_item_of(impl_item.owner_id)
                 .expect("impl method matches a trait method");
             let trait_method_sig = cx.tcx.fn_sig(trait_method).instantiate_identity();
             let trait_method_sig = cx.tcx.instantiate_bound_regions_with_erased(trait_method_sig);

From 5590e55b03722fb7da2d965478deb4b5d62bf97a Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 13 Aug 2025 14:14:37 -0500
Subject: [PATCH 0871/1889] Rename AssocItemContainer -> AssocContainer

---
 .../rustc_hir_analysis/src/check/check.rs     | 12 +++++------
 .../src/check/compare_impl_item.rs            |  8 ++++----
 .../rustc_hir_analysis/src/check/wfcheck.rs   |  8 +++-----
 .../rustc_hir_typeck/src/fn_ctxt/_impl.rs     |  4 ++--
 .../src/fn_ctxt/suggestions.rs                |  2 +-
 compiler/rustc_hir_typeck/src/lib.rs          |  2 +-
 compiler/rustc_hir_typeck/src/method/probe.rs |  8 ++++----
 compiler/rustc_lint/src/nonstandard_style.rs  |  4 ++--
 compiler/rustc_metadata/src/rmeta/encoder.rs  | 10 +++++-----
 compiler/rustc_metadata/src/rmeta/mod.rs      |  2 +-
 .../rustc_metadata/src/rmeta/parameterized.rs |  2 +-
 compiler/rustc_metadata/src/rmeta/table.rs    |  2 +-
 compiler/rustc_middle/src/query/erase.rs      |  2 +-
 compiler/rustc_middle/src/ty/assoc.rs         | 18 ++++++++---------
 compiler/rustc_middle/src/ty/instance.rs      |  2 +-
 compiler/rustc_middle/src/ty/mod.rs           |  4 ++--
 compiler/rustc_public/src/ty.rs               |  4 ++--
 .../src/unstable/convert/stable/ty.rs         | 10 +++++-----
 .../error_reporting/infer/note_and_explain.rs |  4 ++--
 .../src/error_reporting/traits/call_kind.rs   |  6 +++---
 .../traits/specialize/specialization_graph.rs |  2 +-
 compiler/rustc_ty_utils/src/assoc.rs          |  8 ++++----
 compiler/rustc_ty_utils/src/ty.rs             |  2 +-
 src/librustdoc/clean/mod.rs                   | 20 +++++++++----------
 src/librustdoc/clean/types.rs                 |  8 ++++----
 .../clippy/clippy_lints/src/missing_inline.rs |  6 +++---
 src/tools/clippy/clippy_utils/src/lib.rs      |  4 ++--
 27 files changed, 81 insertions(+), 83 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
index 08b344638dd59..3887c96fce634 100644
--- a/compiler/rustc_hir_analysis/src/check/check.rs
+++ b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -1009,8 +1009,8 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Result<(),
             res = res.and(check_associated_item(tcx, def_id));
             let assoc_item = tcx.associated_item(def_id);
             match assoc_item.container {
-                ty::AssocItemContainer::Impl => {}
-                ty::AssocItemContainer::Trait => {
+                ty::AssocContainer::Impl => {}
+                ty::AssocContainer::Trait => {
                     res = res.and(check_trait_item(tcx, def_id));
                 }
             }
@@ -1026,8 +1026,8 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Result<(),
             res = res.and(check_associated_item(tcx, def_id));
             let assoc_item = tcx.associated_item(def_id);
             match assoc_item.container {
-                ty::AssocItemContainer::Impl => {}
-                ty::AssocItemContainer::Trait => {
+                ty::AssocContainer::Impl => {}
+                ty::AssocContainer::Trait => {
                     res = res.and(check_trait_item(tcx, def_id));
                 }
             }
@@ -1043,8 +1043,8 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Result<(),
 
             let assoc_item = tcx.associated_item(def_id);
             let has_type = match assoc_item.container {
-                ty::AssocItemContainer::Impl => true,
-                ty::AssocItemContainer::Trait => {
+                ty::AssocContainer::Impl => true,
+                ty::AssocContainer::Trait => {
                     tcx.ensure_ok().explicit_item_bounds(def_id);
                     tcx.ensure_ok().explicit_item_self_bounds(def_id);
                     if tcx.is_conditionally_const(def_id) {
diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
index e482725619398..85cd8da2ca4d9 100644
--- a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
+++ b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
@@ -1449,8 +1449,8 @@ fn compare_self_type<'tcx>(
 
     let self_string = |method: ty::AssocItem| {
         let untransformed_self_ty = match method.container {
-            ty::AssocItemContainer::Impl => impl_trait_ref.self_ty(),
-            ty::AssocItemContainer::Trait => tcx.types.self_param,
+            ty::AssocContainer::Impl => impl_trait_ref.self_ty(),
+            ty::AssocContainer::Trait => tcx.types.self_param,
         };
         let self_arg_ty = tcx.fn_sig(method.def_id).instantiate_identity().input(0);
         let (infcx, param_env) = tcx
@@ -2458,8 +2458,8 @@ fn param_env_with_gat_bounds<'tcx>(
 
     for impl_ty in impl_tys_to_install {
         let trait_ty = match impl_ty.container {
-            ty::AssocItemContainer::Trait => impl_ty,
-            ty::AssocItemContainer::Impl => tcx.associated_item(impl_ty.trait_item_def_id.unwrap()),
+            ty::AssocContainer::Trait => impl_ty,
+            ty::AssocContainer::Impl => tcx.associated_item(impl_ty.trait_item_def_id.unwrap()),
         };
 
         let mut bound_vars: smallvec::SmallVec<[ty::BoundVariableKind; 8]> =
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
index 22a9446fd4cf1..21dc29a817245 100644
--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -948,10 +948,8 @@ pub(crate) fn check_associated_item(
             .coherent_trait(tcx.parent(item.trait_item_def_id.unwrap_or(item_id.into())))?;
 
         let self_ty = match item.container {
-            ty::AssocItemContainer::Trait => tcx.types.self_param,
-            ty::AssocItemContainer::Impl => {
-                tcx.type_of(item.container_id(tcx)).instantiate_identity()
-            }
+            ty::AssocContainer::Trait => tcx.types.self_param,
+            ty::AssocContainer::Impl => tcx.type_of(item.container_id(tcx)).instantiate_identity(),
         };
 
         let span = tcx.def_span(item_id);
@@ -978,7 +976,7 @@ pub(crate) fn check_associated_item(
                 check_method_receiver(wfcx, hir_sig, item, self_ty)
             }
             ty::AssocKind::Type { .. } => {
-                if let ty::AssocItemContainer::Trait = item.container {
+                if let ty::AssocContainer::Trait = item.container {
                     check_associated_type_bounds(wfcx, item, span)
                 }
                 if item.defaultness(tcx).has_value() {
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
index 0b3d50ff2199f..7b485acc8bd17 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -1021,7 +1021,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 let container_id = assoc_item.container_id(tcx);
                 debug!(?def_id, ?container, ?container_id);
                 match container {
-                    ty::AssocItemContainer::Trait => {
+                    ty::AssocContainer::Trait => {
                         if let Err(e) = callee::check_legal_trait_for_method_call(
                             tcx,
                             path_span,
@@ -1033,7 +1033,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             self.set_tainted_by_errors(e);
                         }
                     }
-                    ty::AssocItemContainer::Impl => {
+                    ty::AssocContainer::Impl => {
                         if segments.len() == 1 {
                             // `<T>::assoc` will end up here, and so
                             // can `T::assoc`. If this came from an
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
index d7ddbcc8b53b4..1998a1884b707 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
@@ -1882,7 +1882,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         if segment.ident.name == sym::clone
             && results.type_dependent_def_id(expr.hir_id).is_some_and(|did| {
                     let assoc_item = self.tcx.associated_item(did);
-                    assoc_item.container == ty::AssocItemContainer::Trait
+                    assoc_item.container == ty::AssocContainer::Trait
                         && assoc_item.container_id(self.tcx) == clone_trait_did
                 })
             // If that clone call hasn't already dereferenced the self type (i.e. don't give this
diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
index 129de32fd4adb..8ba6c25c07786 100644
--- a/compiler/rustc_hir_typeck/src/lib.rs
+++ b/compiler/rustc_hir_typeck/src/lib.rs
@@ -278,7 +278,7 @@ fn infer_type_if_missing<'tcx>(fcx: &FnCtxt<'_, 'tcx>, node: Node<'tcx>) -> Opti
     {
         if let Some(item) = tcx.opt_associated_item(def_id.into())
             && let ty::AssocKind::Const { .. } = item.kind
-            && let ty::AssocItemContainer::Impl = item.container
+            && let ty::AssocContainer::Impl = item.container
             && let Some(trait_item_def_id) = item.trait_item_def_id
         {
             let impl_def_id = item.container_id(tcx);
diff --git a/compiler/rustc_hir_typeck/src/method/probe.rs b/compiler/rustc_hir_typeck/src/method/probe.rs
index 52a8eff984b9b..a52ae354c533a 100644
--- a/compiler/rustc_hir_typeck/src/method/probe.rs
+++ b/compiler/rustc_hir_typeck/src/method/probe.rs
@@ -18,8 +18,8 @@ use rustc_middle::middle::stability;
 use rustc_middle::ty::elaborate::supertrait_def_ids;
 use rustc_middle::ty::fast_reject::{DeepRejectCtxt, TreatParams, simplify_type};
 use rustc_middle::ty::{
-    self, AssocItem, AssocItemContainer, GenericArgs, GenericArgsRef, GenericParamDefKind,
-    ParamEnvAnd, Ty, TyCtxt, TypeVisitableExt, Upcast,
+    self, AssocContainer, AssocItem, GenericArgs, GenericArgsRef, GenericParamDefKind, ParamEnvAnd,
+    Ty, TyCtxt, TypeVisitableExt, Upcast,
 };
 use rustc_middle::{bug, span_bug};
 use rustc_session::lint;
@@ -528,7 +528,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 ProbeScope::Single(def_id) => {
                     let item = self.tcx.associated_item(def_id);
                     // FIXME(fn_delegation): Delegation to inherent methods is not yet supported.
-                    assert_eq!(item.container, AssocItemContainer::Trait);
+                    assert_eq!(item.container, AssocContainer::Trait);
 
                     let trait_def_id = self.tcx.parent(def_id);
                     let trait_span = self.tcx.def_span(trait_def_id);
@@ -1702,7 +1702,7 @@ impl<'tcx> Pick<'tcx> {
                         tcx.def_path_str(self.item.def_id),
                     ));
                 }
-                (ty::AssocKind::Const { name }, ty::AssocItemContainer::Trait) => {
+                (ty::AssocKind::Const { name }, ty::AssocContainer::Trait) => {
                     let def_id = self.item.container_id(tcx);
                     lint.span_suggestion(
                         span,
diff --git a/compiler/rustc_lint/src/nonstandard_style.rs b/compiler/rustc_lint/src/nonstandard_style.rs
index 65075cfecfa49..7b8f17ef93ce6 100644
--- a/compiler/rustc_lint/src/nonstandard_style.rs
+++ b/compiler/rustc_lint/src/nonstandard_style.rs
@@ -30,8 +30,8 @@ pub(crate) enum MethodLateContext {
 pub(crate) fn method_context(cx: &LateContext<'_>, id: LocalDefId) -> MethodLateContext {
     let item = cx.tcx.associated_item(id);
     match item.container {
-        ty::AssocItemContainer::Trait => MethodLateContext::TraitAutoImpl,
-        ty::AssocItemContainer::Impl => match cx.tcx.impl_trait_ref(item.container_id(cx.tcx)) {
+        ty::AssocContainer::Trait => MethodLateContext::TraitAutoImpl,
+        ty::AssocContainer::Impl => match cx.tcx.impl_trait_ref(item.container_id(cx.tcx)) {
             Some(_) => MethodLateContext::TraitImpl,
             None => MethodLateContext::PlainImpl,
         },
diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
index a7e7e9985f4d4..0fb5b8fffd182 100644
--- a/compiler/rustc_metadata/src/rmeta/encoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -22,7 +22,7 @@ use rustc_middle::middle::dependency_format::Linkage;
 use rustc_middle::mir::interpret;
 use rustc_middle::query::Providers;
 use rustc_middle::traits::specialization_graph;
-use rustc_middle::ty::AssocItemContainer;
+use rustc_middle::ty::AssocContainer;
 use rustc_middle::ty::codec::TyEncoder;
 use rustc_middle::ty::fast_reject::{self, TreatParams};
 use rustc_middle::{bug, span_bug};
@@ -1254,8 +1254,8 @@ fn should_encode_type(tcx: TyCtxt<'_>, def_id: LocalDefId, def_kind: DefKind) ->
         DefKind::AssocTy => {
             let assoc_item = tcx.associated_item(def_id);
             match assoc_item.container {
-                ty::AssocItemContainer::Impl => true,
-                ty::AssocItemContainer::Trait => assoc_item.defaultness(tcx).has_value(),
+                ty::AssocContainer::Impl => true,
+                ty::AssocContainer::Trait => assoc_item.defaultness(tcx).has_value(),
             }
         }
         DefKind::TyParam => {
@@ -1729,7 +1729,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         self.tables.assoc_container.set_some(def_id.index, item.container);
 
         match item.container {
-            AssocItemContainer::Trait => {
+            AssocContainer::Trait => {
                 if item.is_type() {
                     self.encode_explicit_item_bounds(def_id);
                     self.encode_explicit_item_self_bounds(def_id);
@@ -1739,7 +1739,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                     }
                 }
             }
-            AssocItemContainer::Impl => {
+            AssocContainer::Impl => {
                 if let Some(trait_item_def_id) = item.trait_item_def_id {
                     self.tables.trait_item_def_id.set_some(def_id.index, trait_item_def_id.into());
                 }
diff --git a/compiler/rustc_metadata/src/rmeta/mod.rs b/compiler/rustc_metadata/src/rmeta/mod.rs
index 1f7d142d33000..a7b1f2c01dd18 100644
--- a/compiler/rustc_metadata/src/rmeta/mod.rs
+++ b/compiler/rustc_metadata/src/rmeta/mod.rs
@@ -459,7 +459,7 @@ define_tables! {
     def_keys: Table<DefIndex, LazyValue<DefKey>>,
     proc_macro_quoted_spans: Table<usize, LazyValue<Span>>,
     variant_data: Table<DefIndex, LazyValue<VariantData>>,
-    assoc_container: Table<DefIndex, ty::AssocItemContainer>,
+    assoc_container: Table<DefIndex, ty::AssocContainer>,
     macro_definition: Table<DefIndex, LazyValue<ast::DelimArgs>>,
     proc_macro: Table<DefIndex, MacroKind>,
     deduced_param_attrs: Table<DefIndex, LazyArray<DeducedParamAttrs>>,
diff --git a/compiler/rustc_metadata/src/rmeta/parameterized.rs b/compiler/rustc_metadata/src/rmeta/parameterized.rs
index 34180001f8044..4b2dc2c814e57 100644
--- a/compiler/rustc_metadata/src/rmeta/parameterized.rs
+++ b/compiler/rustc_metadata/src/rmeta/parameterized.rs
@@ -102,7 +102,7 @@ trivially_parameterized_over_tcx! {
     rustc_middle::middle::resolve_bound_vars::ObjectLifetimeDefault,
     rustc_middle::mir::ConstQualifs,
     rustc_middle::ty::AnonConstKind,
-    rustc_middle::ty::AssocItemContainer,
+    rustc_middle::ty::AssocContainer,
     rustc_middle::ty::AsyncDestructor,
     rustc_middle::ty::Asyncness,
     rustc_middle::ty::DeducedParamAttrs,
diff --git a/compiler/rustc_metadata/src/rmeta/table.rs b/compiler/rustc_metadata/src/rmeta/table.rs
index 2cb07a28a8ad2..36634bb39d806 100644
--- a/compiler/rustc_metadata/src/rmeta/table.rs
+++ b/compiler/rustc_metadata/src/rmeta/table.rs
@@ -222,7 +222,7 @@ fixed_size_enum! {
 }
 
 fixed_size_enum! {
-    ty::AssocItemContainer {
+    ty::AssocContainer {
         ( Trait )
         ( Impl  )
     }
diff --git a/compiler/rustc_middle/src/query/erase.rs b/compiler/rustc_middle/src/query/erase.rs
index bea2191c5601c..4c00b769237f3 100644
--- a/compiler/rustc_middle/src/query/erase.rs
+++ b/compiler/rustc_middle/src/query/erase.rs
@@ -318,7 +318,7 @@ trivial! {
     rustc_middle::traits::WellFormedLoc,
     rustc_middle::ty::adjustment::CoerceUnsizedInfo,
     rustc_middle::ty::AssocItem,
-    rustc_middle::ty::AssocItemContainer,
+    rustc_middle::ty::AssocContainer,
     rustc_middle::ty::Asyncness,
     rustc_middle::ty::AsyncDestructor,
     rustc_middle::ty::BoundVariableKind,
diff --git a/compiler/rustc_middle/src/ty/assoc.rs b/compiler/rustc_middle/src/ty/assoc.rs
index a902a8a61e5ab..8a2f62ce8335c 100644
--- a/compiler/rustc_middle/src/ty/assoc.rs
+++ b/compiler/rustc_middle/src/ty/assoc.rs
@@ -11,7 +11,7 @@ use super::{TyCtxt, Visibility};
 use crate::ty;
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug, HashStable, Hash, Encodable, Decodable)]
-pub enum AssocItemContainer {
+pub enum AssocContainer {
     Trait,
     Impl,
 }
@@ -21,7 +21,7 @@ pub enum AssocItemContainer {
 pub struct AssocItem {
     pub def_id: DefId,
     pub kind: AssocKind,
-    pub container: AssocItemContainer,
+    pub container: AssocContainer,
 
     /// If this is an item in an impl of a trait then this is the `DefId` of
     /// the associated item on the trait that this implements.
@@ -71,16 +71,16 @@ impl AssocItem {
     #[inline]
     pub fn trait_container(&self, tcx: TyCtxt<'_>) -> Option<DefId> {
         match self.container {
-            AssocItemContainer::Impl => None,
-            AssocItemContainer::Trait => Some(tcx.parent(self.def_id)),
+            AssocContainer::Impl => None,
+            AssocContainer::Trait => Some(tcx.parent(self.def_id)),
         }
     }
 
     #[inline]
     pub fn impl_container(&self, tcx: TyCtxt<'_>) -> Option<DefId> {
         match self.container {
-            AssocItemContainer::Impl => Some(tcx.parent(self.def_id)),
-            AssocItemContainer::Trait => None,
+            AssocContainer::Impl => Some(tcx.parent(self.def_id)),
+            AssocContainer::Trait => None,
         }
     }
 
@@ -157,10 +157,10 @@ impl AssocItem {
         }
 
         let def_id = match (self.container, self.trait_item_def_id) {
-            (AssocItemContainer::Trait, _) => self.def_id,
-            (AssocItemContainer::Impl, Some(trait_item_did)) => trait_item_did,
+            (AssocContainer::Trait, _) => self.def_id,
+            (AssocContainer::Impl, Some(trait_item_did)) => trait_item_did,
             // Inherent impl but this attr is only applied to trait assoc items.
-            (AssocItemContainer::Impl, None) => return true,
+            (AssocContainer::Impl, None) => return true,
         };
         find_attr!(tcx.get_all_attrs(def_id), AttributeKind::TypeConst(_))
     }
diff --git a/compiler/rustc_middle/src/ty/instance.rs b/compiler/rustc_middle/src/ty/instance.rs
index e76993e0542bd..ec2a23bfebeeb 100644
--- a/compiler/rustc_middle/src/ty/instance.rs
+++ b/compiler/rustc_middle/src/ty/instance.rs
@@ -683,7 +683,7 @@ impl<'tcx> Instance<'tcx> {
                     && !matches!(
                         tcx.opt_associated_item(def),
                         Some(ty::AssocItem {
-                            container: ty::AssocItemContainer::Trait,
+                            container: ty::AssocContainer::Trait,
                             ..
                         })
                     );
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 5a4ebfe28a4b5..a34bf9b52970a 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -1937,7 +1937,7 @@ impl<'tcx> TyCtxt<'tcx> {
     /// Returns the trait item that is implemented by the given item `DefId`.
     pub fn trait_item_of(self, def_id: impl IntoQueryParam<DefId>) -> Option<DefId> {
         let assoc = self.opt_associated_item(def_id.into_query_param())?;
-        if assoc.container != AssocItemContainer::Impl {
+        if assoc.container != AssocContainer::Impl {
             return None;
         }
         assoc.trait_item_def_id
@@ -2158,7 +2158,7 @@ impl<'tcx> TyCtxt<'tcx> {
         let Some(item) = self.opt_associated_item(def_id) else {
             return false;
         };
-        if item.container != ty::AssocItemContainer::Impl {
+        if item.container != ty::AssocContainer::Impl {
             return false;
         }
 
diff --git a/compiler/rustc_public/src/ty.rs b/compiler/rustc_public/src/ty.rs
index 1b5f0ed14299e..c7422051c3625 100644
--- a/compiler/rustc_public/src/ty.rs
+++ b/compiler/rustc_public/src/ty.rs
@@ -1612,7 +1612,7 @@ crate_def! {
 pub struct AssocItem {
     pub def_id: AssocDef,
     pub kind: AssocKind,
-    pub container: AssocItemContainer,
+    pub container: AssocContainer,
 
     /// If this is an item in an impl of a trait then this is the `DefId` of
     /// the associated item on the trait that this implements.
@@ -1636,7 +1636,7 @@ pub enum AssocKind {
 }
 
 #[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum AssocItemContainer {
+pub enum AssocContainer {
     Trait,
     Impl,
 }
diff --git a/compiler/rustc_public/src/unstable/convert/stable/ty.rs b/compiler/rustc_public/src/unstable/convert/stable/ty.rs
index 207038db40d6e..ace459e79dadf 100644
--- a/compiler/rustc_public/src/unstable/convert/stable/ty.rs
+++ b/compiler/rustc_public/src/unstable/convert/stable/ty.rs
@@ -1076,14 +1076,14 @@ impl<'tcx> Stable<'tcx> for ty::AssocKind {
     }
 }
 
-impl<'tcx> Stable<'tcx> for ty::AssocItemContainer {
-    type T = crate::ty::AssocItemContainer;
+impl<'tcx> Stable<'tcx> for ty::AssocContainer {
+    type T = crate::ty::AssocContainer;
 
     fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
-        use crate::ty::AssocItemContainer;
+        use crate::ty::AssocContainer;
         match self {
-            ty::AssocItemContainer::Trait => AssocItemContainer::Trait,
-            ty::AssocItemContainer::Impl => AssocItemContainer::Impl,
+            ty::AssocContainer::Trait => AssocContainer::Trait,
+            ty::AssocContainer::Impl => AssocContainer::Impl,
         }
     }
 }
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 e042ce84955e7..9fe685b2786ee 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
@@ -857,11 +857,11 @@ fn foo(&self) -> Self::T { String::new() }
                     && self.infcx.can_eq(param_env, assoc_ty, found)
                 {
                     let msg = match assoc_item.container {
-                        ty::AssocItemContainer::Trait => {
+                        ty::AssocContainer::Trait => {
                             "associated type defaults can't be assumed inside the \
                                             trait defining them"
                         }
-                        ty::AssocItemContainer::Impl => {
+                        ty::AssocContainer::Impl => {
                             "associated type is `default` and may be overridden"
                         }
                     };
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/call_kind.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/call_kind.rs
index 8a67e4ccd456f..c04a8b3d860e7 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/call_kind.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/call_kind.rs
@@ -5,7 +5,7 @@
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{LangItem, lang_items};
-use rustc_middle::ty::{AssocItemContainer, GenericArgsRef, Instance, Ty, TyCtxt, TypingEnv};
+use rustc_middle::ty::{AssocContainer, GenericArgsRef, Instance, Ty, TyCtxt, TypingEnv};
 use rustc_span::{DUMMY_SP, DesugaringKind, Ident, Span, sym};
 use tracing::debug;
 
@@ -76,8 +76,8 @@ pub fn call_kind<'tcx>(
     let parent = tcx.opt_associated_item(method_did).and_then(|assoc| {
         let container_id = assoc.container_id(tcx);
         match assoc.container {
-            AssocItemContainer::Impl => tcx.trait_id_of_impl(container_id),
-            AssocItemContainer::Trait => Some(container_id),
+            AssocContainer::Impl => tcx.trait_id_of_impl(container_id),
+            AssocContainer::Trait => Some(container_id),
         }
     });
 
diff --git a/compiler/rustc_trait_selection/src/traits/specialize/specialization_graph.rs b/compiler/rustc_trait_selection/src/traits/specialize/specialization_graph.rs
index 19eb85506b6fb..caaf8c2585d3a 100644
--- a/compiler/rustc_trait_selection/src/traits/specialize/specialization_graph.rs
+++ b/compiler/rustc_trait_selection/src/traits/specialize/specialization_graph.rs
@@ -387,7 +387,7 @@ pub(crate) fn assoc_def(
     if let Some(assoc_item) = ancestors.leaf_def(tcx, assoc_def_id) {
         // Ensure that the impl is constrained, otherwise projection may give us
         // bad unconstrained infer vars.
-        if assoc_item.item.container == ty::AssocItemContainer::Impl
+        if assoc_item.item.container == ty::AssocContainer::Impl
             && let Some(impl_def_id) = assoc_item.item.container_id(tcx).as_local()
         {
             tcx.ensure_ok().enforce_impl_non_lifetime_params_are_constrained(impl_def_id)?;
diff --git a/compiler/rustc_ty_utils/src/assoc.rs b/compiler/rustc_ty_utils/src/assoc.rs
index e9629e31482a2..8587c952b9158 100644
--- a/compiler/rustc_ty_utils/src/assoc.rs
+++ b/compiler/rustc_ty_utils/src/assoc.rs
@@ -101,7 +101,7 @@ fn associated_item_from_trait_item(
         kind,
         def_id: owner_id.to_def_id(),
         trait_item_def_id: Some(owner_id.to_def_id()),
-        container: ty::AssocItemContainer::Trait,
+        container: ty::AssocContainer::Trait,
     }
 }
 
@@ -122,7 +122,7 @@ fn associated_item_from_impl_item(tcx: TyCtxt<'_>, impl_item: &hir::ImplItem<'_>
         kind,
         def_id: owner_id.to_def_id(),
         trait_item_def_id: impl_item.trait_item_def_id,
-        container: ty::AssocItemContainer::Impl,
+        container: ty::AssocContainer::Impl,
     }
 }
 struct RPITVisitor<'a, 'tcx> {
@@ -257,7 +257,7 @@ fn associated_type_for_impl_trait_in_trait(
         },
         def_id,
         trait_item_def_id: None,
-        container: ty::AssocItemContainer::Trait,
+        container: ty::AssocContainer::Trait,
     });
 
     // Copy visility of the containing function.
@@ -323,7 +323,7 @@ fn associated_type_for_impl_trait_in_impl(
         },
         def_id,
         trait_item_def_id: Some(trait_assoc_def_id),
-        container: ty::AssocItemContainer::Impl,
+        container: ty::AssocContainer::Impl,
     });
 
     // Copy visility of the containing function.
diff --git a/compiler/rustc_ty_utils/src/ty.rs b/compiler/rustc_ty_utils/src/ty.rs
index b22c326b9f2ab..3151257153806 100644
--- a/compiler/rustc_ty_utils/src/ty.rs
+++ b/compiler/rustc_ty_utils/src/ty.rs
@@ -165,7 +165,7 @@ fn param_env(tcx: TyCtxt<'_>, def_id: DefId) -> ty::ParamEnv<'_> {
 
     if tcx.def_kind(def_id) == DefKind::AssocFn
         && let assoc_item = tcx.associated_item(def_id)
-        && assoc_item.container == ty::AssocItemContainer::Trait
+        && assoc_item.container == ty::AssocContainer::Trait
         && assoc_item.defaultness(tcx).has_value()
     {
         let sig = tcx.fn_sig(def_id).instantiate_identity();
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 93932936a2e0e..b98f174fbbfdc 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -1295,12 +1295,12 @@ pub(crate) fn clean_middle_assoc_item(assoc_item: &ty::AssocItem, cx: &mut DocCo
             simplify::move_bounds_to_generic_parameters(&mut generics);
 
             match assoc_item.container {
-                ty::AssocItemContainer::Impl => ImplAssocConstItem(Box::new(Constant {
+                ty::AssocContainer::Impl => ImplAssocConstItem(Box::new(Constant {
                     generics,
                     kind: ConstantKind::Extern { def_id: assoc_item.def_id },
                     type_: ty,
                 })),
-                ty::AssocItemContainer::Trait => {
+                ty::AssocContainer::Trait => {
                     if tcx.defaultness(assoc_item.def_id).has_value() {
                         ProvidedAssocConstItem(Box::new(Constant {
                             generics,
@@ -1318,10 +1318,10 @@ pub(crate) fn clean_middle_assoc_item(assoc_item: &ty::AssocItem, cx: &mut DocCo
 
             if has_self {
                 let self_ty = match assoc_item.container {
-                    ty::AssocItemContainer::Impl => {
+                    ty::AssocContainer::Impl => {
                         tcx.type_of(assoc_item.container_id(tcx)).instantiate_identity()
                     }
-                    ty::AssocItemContainer::Trait => tcx.types.self_param,
+                    ty::AssocContainer::Trait => tcx.types.self_param,
                 };
                 let self_param_ty =
                     tcx.fn_sig(assoc_item.def_id).instantiate_identity().input(0).skip_binder();
@@ -1338,13 +1338,13 @@ pub(crate) fn clean_middle_assoc_item(assoc_item: &ty::AssocItem, cx: &mut DocCo
             }
 
             let provided = match assoc_item.container {
-                ty::AssocItemContainer::Impl => true,
-                ty::AssocItemContainer::Trait => assoc_item.defaultness(tcx).has_value(),
+                ty::AssocContainer::Impl => true,
+                ty::AssocContainer::Trait => assoc_item.defaultness(tcx).has_value(),
             };
             if provided {
                 let defaultness = match assoc_item.container {
-                    ty::AssocItemContainer::Impl => Some(assoc_item.defaultness(tcx)),
-                    ty::AssocItemContainer::Trait => None,
+                    ty::AssocContainer::Impl => Some(assoc_item.defaultness(tcx)),
+                    ty::AssocContainer::Trait => None,
                 };
                 MethodItem(item, defaultness)
             } else {
@@ -1375,7 +1375,7 @@ pub(crate) fn clean_middle_assoc_item(assoc_item: &ty::AssocItem, cx: &mut DocCo
             }
 
             let mut predicates = tcx.explicit_predicates_of(assoc_item.def_id).predicates;
-            if let ty::AssocItemContainer::Trait = assoc_item.container {
+            if let ty::AssocContainer::Trait = assoc_item.container {
                 let bounds = tcx.explicit_item_bounds(assoc_item.def_id).iter_identity_copied();
                 predicates = tcx.arena.alloc_from_iter(bounds.chain(predicates.iter().copied()));
             }
@@ -1386,7 +1386,7 @@ pub(crate) fn clean_middle_assoc_item(assoc_item: &ty::AssocItem, cx: &mut DocCo
             );
             simplify::move_bounds_to_generic_parameters(&mut generics);
 
-            if let ty::AssocItemContainer::Trait = assoc_item.container {
+            if let ty::AssocContainer::Trait = assoc_item.container {
                 // Move bounds that are (likely) directly attached to the associated type
                 // from the where-clause to the associated type.
                 // There is no guarantee that this is what the user actually wrote but we have
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index dcd67cb7ebc77..84a5f239c8dd6 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -692,11 +692,11 @@ impl Item {
                 // won't be printing correct syntax plus the syntax is unstable.
                 match tcx.opt_associated_item(def_id) {
                     Some(ty::AssocItem {
-                        container: ty::AssocItemContainer::Impl,
+                        container: ty::AssocContainer::Impl,
                         trait_item_def_id: Some(_),
                         ..
                     })
-                    | Some(ty::AssocItem { container: ty::AssocItemContainer::Trait, .. }) => {
+                    | Some(ty::AssocItem { container: ty::AssocContainer::Trait, .. }) => {
                         hir::Constness::NotConst
                     }
                     None | Some(_) => hir::Constness::Const,
@@ -781,8 +781,8 @@ impl Item {
             | MethodItem(..) => {
                 let assoc_item = tcx.associated_item(def_id);
                 let is_trait_item = match assoc_item.container {
-                    ty::AssocItemContainer::Trait => true,
-                    ty::AssocItemContainer::Impl => {
+                    ty::AssocContainer::Trait => true,
+                    ty::AssocContainer::Impl => {
                         // Trait impl items always inherit the impl's visibility --
                         // we don't want to show `pub`.
                         tcx.impl_trait_ref(tcx.parent(assoc_item.def_id)).is_some()
diff --git a/src/tools/clippy/clippy_lints/src/missing_inline.rs b/src/tools/clippy/clippy_lints/src/missing_inline.rs
index 28555a6109001..490a59ca66d3e 100644
--- a/src/tools/clippy/clippy_lints/src/missing_inline.rs
+++ b/src/tools/clippy/clippy_lints/src/missing_inline.rs
@@ -3,7 +3,7 @@ use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{self as hir, Attribute, find_attr};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::ty::AssocItemContainer;
+use rustc_middle::ty::AssocContainer;
 use rustc_session::declare_lint_pass;
 use rustc_span::Span;
 
@@ -166,8 +166,8 @@ impl<'tcx> LateLintPass<'tcx> for MissingInline {
         let assoc_item = cx.tcx.associated_item(impl_item.owner_id);
         let container_id = assoc_item.container_id(cx.tcx);
         let trait_def_id = match assoc_item.container {
-            AssocItemContainer::Trait => Some(container_id),
-            AssocItemContainer::Impl => cx.tcx.impl_trait_ref(container_id).map(|t| t.skip_binder().def_id),
+            AssocContainer::Trait => Some(container_id),
+            AssocContainer::Impl => cx.tcx.impl_trait_ref(container_id).map(|t| t.skip_binder().def_id),
         };
 
         if let Some(trait_def_id) = trait_def_id
diff --git a/src/tools/clippy/clippy_utils/src/lib.rs b/src/tools/clippy/clippy_utils/src/lib.rs
index 14b64eb4d54e8..b806e3d8b1bf5 100644
--- a/src/tools/clippy/clippy_utils/src/lib.rs
+++ b/src/tools/clippy/clippy_utils/src/lib.rs
@@ -3250,8 +3250,8 @@ pub fn get_path_from_caller_to_method_type<'tcx>(
     let assoc_item = tcx.associated_item(method);
     let def_id = assoc_item.container_id(tcx);
     match assoc_item.container {
-        rustc_ty::AssocItemContainer::Trait => get_path_to_callee(tcx, from, def_id),
-        rustc_ty::AssocItemContainer::Impl => {
+        rustc_ty::AssocContainer::Trait => get_path_to_callee(tcx, from, def_id),
+        rustc_ty::AssocContainer::Impl => {
             let ty = tcx.type_of(def_id).instantiate_identity();
             get_path_to_ty(tcx, from, ty, args)
         },

From d419d51f934f8ab1fcdb82d6a446818d7d626aa0 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 13 Aug 2025 14:14:37 -0500
Subject: [PATCH 0872/1889] Rename AssocItemContainer -> AssocContainer

---
 clippy_lints/src/missing_inline.rs | 6 +++---
 clippy_utils/src/lib.rs            | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/clippy_lints/src/missing_inline.rs b/clippy_lints/src/missing_inline.rs
index 28555a6109001..490a59ca66d3e 100644
--- a/clippy_lints/src/missing_inline.rs
+++ b/clippy_lints/src/missing_inline.rs
@@ -3,7 +3,7 @@ use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{self as hir, Attribute, find_attr};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::ty::AssocItemContainer;
+use rustc_middle::ty::AssocContainer;
 use rustc_session::declare_lint_pass;
 use rustc_span::Span;
 
@@ -166,8 +166,8 @@ impl<'tcx> LateLintPass<'tcx> for MissingInline {
         let assoc_item = cx.tcx.associated_item(impl_item.owner_id);
         let container_id = assoc_item.container_id(cx.tcx);
         let trait_def_id = match assoc_item.container {
-            AssocItemContainer::Trait => Some(container_id),
-            AssocItemContainer::Impl => cx.tcx.impl_trait_ref(container_id).map(|t| t.skip_binder().def_id),
+            AssocContainer::Trait => Some(container_id),
+            AssocContainer::Impl => cx.tcx.impl_trait_ref(container_id).map(|t| t.skip_binder().def_id),
         };
 
         if let Some(trait_def_id) = trait_def_id
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 14b64eb4d54e8..b806e3d8b1bf5 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -3250,8 +3250,8 @@ pub fn get_path_from_caller_to_method_type<'tcx>(
     let assoc_item = tcx.associated_item(method);
     let def_id = assoc_item.container_id(tcx);
     match assoc_item.container {
-        rustc_ty::AssocItemContainer::Trait => get_path_to_callee(tcx, from, def_id),
-        rustc_ty::AssocItemContainer::Impl => {
+        rustc_ty::AssocContainer::Trait => get_path_to_callee(tcx, from, def_id),
+        rustc_ty::AssocContainer::Impl => {
             let ty = tcx.type_of(def_id).instantiate_identity();
             get_path_to_ty(tcx, from, ty, args)
         },

From 88a8bfcaf0398011b621a981483c288d1e3b64e2 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 5 Aug 2025 15:59:44 -0500
Subject: [PATCH 0873/1889] Introduce hir::ImplItemImplKind

---
 compiler/rustc_ast_lowering/src/item.rs       | 31 ++++++++++++------
 compiler/rustc_hir/src/hir.rs                 | 26 ++++++++++++---
 compiler/rustc_hir/src/intravisit.rs          | 11 ++++---
 .../rustc_hir_analysis/src/collect/type_of.rs |  2 +-
 compiler/rustc_lint/src/builtin.rs            |  7 ++--
 compiler/rustc_lint/src/nonstandard_style.rs  |  7 +---
 compiler/rustc_middle/src/ty/context.rs       | 26 ++++++---------
 compiler/rustc_passes/src/dead.rs             | 32 ++++++++-----------
 compiler/rustc_passes/src/stability.rs        |  3 +-
 .../src/error_reporting/traits/suggestions.rs |  2 +-
 compiler/rustc_ty_utils/src/assoc.rs          | 12 +++++--
 compiler/rustc_ty_utils/src/ty.rs             |  9 +++++-
 .../clippy_lints/src/disallowed_macros.rs     |  6 ++--
 .../clippy_lints/src/manual_async_fn.rs       | 12 ++++---
 .../clippy_lints/src/min_ident_chars.rs       |  6 ++--
 .../clippy_lints/src/missing_const_for_fn.rs  | 18 ++++++++---
 .../clippy_utils/src/check_proc_macro.rs      | 32 +++++++++----------
 17 files changed, 143 insertions(+), 99 deletions(-)

diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
index bb559bd892126..53351f91c46bc 100644
--- a/compiler/rustc_ast_lowering/src/item.rs
+++ b/compiler/rustc_ast_lowering/src/item.rs
@@ -5,7 +5,9 @@ use rustc_errors::{E0570, ErrorGuaranteed, struct_span_code_err};
 use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def::{DefKind, PerNS, Res};
 use rustc_hir::def_id::{CRATE_DEF_ID, LocalDefId};
-use rustc_hir::{self as hir, HirId, LifetimeSource, PredicateOrigin, Target, find_attr};
+use rustc_hir::{
+    self as hir, HirId, ImplItemImplKind, LifetimeSource, PredicateOrigin, Target, find_attr,
+};
 use rustc_index::{IndexSlice, IndexVec};
 use rustc_middle::span_bug;
 use rustc_middle::ty::{ResolverAstLowering, TyCtxt};
@@ -1117,20 +1119,31 @@ impl<'hir> LoweringContext<'_, 'hir> {
             }
         };
 
+        let span = self.lower_span(i.span);
         let item = hir::ImplItem {
             owner_id: hir_id.expect_owner(),
             ident: self.lower_ident(ident),
             generics,
+            impl_kind: if is_in_trait_impl {
+                ImplItemImplKind::Trait {
+                    defaultness,
+                    trait_item_def_id: self
+                        .resolver
+                        .get_partial_res(i.id)
+                        .and_then(|r| r.expect_full_res().opt_def_id())
+                        .ok_or_else(|| {
+                            self.dcx().span_delayed_bug(
+                                span,
+                                "could not resolve trait item being implemented",
+                            )
+                        }),
+                }
+            } else {
+                ImplItemImplKind::Inherent { vis_span: self.lower_span(i.vis.span) }
+            },
             kind,
-            vis_span: self.lower_span(i.vis.span),
-            span: self.lower_span(i.span),
-            defaultness,
+            span,
             has_delayed_lints: !self.delayed_lints.is_empty(),
-            trait_item_def_id: self
-                .resolver
-                .get_partial_res(i.id)
-                .map(|r| r.expect_full_res().opt_def_id())
-                .unwrap_or(None),
         };
         self.arena.alloc(item)
     }
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index 75551fe4c196a..493236718a86a 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -3220,12 +3220,21 @@ pub struct ImplItem<'hir> {
     pub owner_id: OwnerId,
     pub generics: &'hir Generics<'hir>,
     pub kind: ImplItemKind<'hir>,
-    pub defaultness: Defaultness,
+    pub impl_kind: ImplItemImplKind,
     pub span: Span,
-    pub vis_span: Span,
     pub has_delayed_lints: bool,
-    /// When we are in a trait impl, link to the trait-item's id.
-    pub trait_item_def_id: Option<DefId>,
+}
+
+#[derive(Debug, Clone, Copy, HashStable_Generic)]
+pub enum ImplItemImplKind {
+    Inherent {
+        vis_span: Span,
+    },
+    Trait {
+        defaultness: Defaultness,
+        /// Item in the trait that this item implements
+        trait_item_def_id: Result<DefId, ErrorGuaranteed>,
+    },
 }
 
 impl<'hir> ImplItem<'hir> {
@@ -3239,6 +3248,13 @@ impl<'hir> ImplItem<'hir> {
         ImplItemId { owner_id: self.owner_id }
     }
 
+    pub fn vis_span(&self) -> Option<Span> {
+        match self.impl_kind {
+            ImplItemImplKind::Trait { .. } => None,
+            ImplItemImplKind::Inherent { vis_span, .. } => Some(vis_span),
+        }
+    }
+
     expect_methods_self_kind! {
         expect_const, (&'hir Ty<'hir>, BodyId), ImplItemKind::Const(ty, body), (ty, *body);
         expect_fn,    (&FnSig<'hir>, BodyId),   ImplItemKind::Fn(ty, body),    (ty, *body);
@@ -4985,7 +5001,7 @@ mod size_asserts {
     static_assert_size!(GenericBound<'_>, 64);
     static_assert_size!(Generics<'_>, 56);
     static_assert_size!(Impl<'_>, 40);
-    static_assert_size!(ImplItem<'_>, 96);
+    static_assert_size!(ImplItem<'_>, 88);
     static_assert_size!(ImplItemKind<'_>, 40);
     static_assert_size!(Item<'_>, 88);
     static_assert_size!(ItemKind<'_>, 64);
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
index 25a7ae239f312..eb682f32111a5 100644
--- a/compiler/rustc_hir/src/intravisit.rs
+++ b/compiler/rustc_hir/src/intravisit.rs
@@ -1257,18 +1257,21 @@ pub fn walk_impl_item<'v, V: Visitor<'v>>(
         owner_id: _,
         ident,
         ref generics,
+        ref impl_kind,
         ref kind,
-        ref defaultness,
         span: _,
-        vis_span: _,
         has_delayed_lints: _,
-        trait_item_def_id: _,
     } = *impl_item;
 
     try_visit!(visitor.visit_ident(ident));
     try_visit!(visitor.visit_generics(generics));
-    try_visit!(visitor.visit_defaultness(defaultness));
     try_visit!(visitor.visit_id(impl_item.hir_id()));
+    match impl_kind {
+        ImplItemImplKind::Inherent { vis_span: _ } => {}
+        ImplItemImplKind::Trait { defaultness, trait_item_def_id: _ } => {
+            try_visit!(visitor.visit_defaultness(defaultness));
+        }
+    }
     match *kind {
         ImplItemKind::Const(ref ty, body) => {
             try_visit!(visitor.visit_ty_unambig(ty));
diff --git a/compiler/rustc_hir_analysis/src/collect/type_of.rs b/compiler/rustc_hir_analysis/src/collect/type_of.rs
index a8af73717cd0c..8cbf17162e321 100644
--- a/compiler/rustc_hir_analysis/src/collect/type_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/type_of.rs
@@ -198,7 +198,7 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<'_
                 }
             }
             ImplItemKind::Type(ty) => {
-                if tcx.impl_trait_ref(tcx.hir_get_parent_item(hir_id)).is_none() {
+                if let ImplItemImplKind::Inherent { .. } = item.impl_kind {
                     check_feature_inherent_assoc_ty(tcx, item.span);
                 }
 
diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs
index c3c0a34df710c..d4c83a0cca78b 100644
--- a/compiler/rustc_lint/src/builtin.rs
+++ b/compiler/rustc_lint/src/builtin.rs
@@ -29,7 +29,7 @@ use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{CRATE_DEF_ID, DefId, LocalDefId};
 use rustc_hir::intravisit::FnKind as HirFnKind;
-use rustc_hir::{Body, FnDecl, PatKind, PredicateOrigin, find_attr};
+use rustc_hir::{Body, FnDecl, ImplItemImplKind, PatKind, PredicateOrigin, find_attr};
 use rustc_middle::bug;
 use rustc_middle::lint::LevelAndSource;
 use rustc_middle::ty::layout::LayoutOf;
@@ -1321,9 +1321,8 @@ impl<'tcx> LateLintPass<'tcx> for UnreachablePub {
     }
 
     fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &hir::ImplItem<'_>) {
-        // Only lint inherent impl items.
-        if cx.tcx.associated_item(impl_item.owner_id).trait_item_def_id.is_none() {
-            self.perform_lint(cx, "item", impl_item.owner_id.def_id, impl_item.vis_span, false);
+        if let ImplItemImplKind::Inherent { vis_span } = impl_item.impl_kind {
+            self.perform_lint(cx, "item", impl_item.owner_id.def_id, vis_span, false);
         }
     }
 }
diff --git a/compiler/rustc_lint/src/nonstandard_style.rs b/compiler/rustc_lint/src/nonstandard_style.rs
index 7b8f17ef93ce6..7cdd82b66c181 100644
--- a/compiler/rustc_lint/src/nonstandard_style.rs
+++ b/compiler/rustc_lint/src/nonstandard_style.rs
@@ -38,11 +38,6 @@ pub(crate) fn method_context(cx: &LateContext<'_>, id: LocalDefId) -> MethodLate
     }
 }
 
-fn assoc_item_in_trait_impl(cx: &LateContext<'_>, ii: &hir::ImplItem<'_>) -> bool {
-    let item = cx.tcx.associated_item(ii.owner_id);
-    item.trait_item_def_id.is_some()
-}
-
 declare_lint! {
     /// The `non_camel_case_types` lint detects types, variants, traits and
     /// type parameters that don't have camel case names.
@@ -602,7 +597,7 @@ impl<'tcx> LateLintPass<'tcx> for NonUpperCaseGlobals {
 
     fn check_impl_item(&mut self, cx: &LateContext<'_>, ii: &hir::ImplItem<'_>) {
         if let hir::ImplItemKind::Const(..) = ii.kind
-            && !assoc_item_in_trait_impl(cx, ii)
+            && let hir::ImplItemImplKind::Inherent { .. } = ii.impl_kind
         {
             NonUpperCaseGlobals::check_upper_case(cx, "associated constant", None, &ii.ident);
         }
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 8ea767dccd3b8..79700d485c440 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -2276,7 +2276,16 @@ impl<'tcx> TyCtxt<'tcx> {
 
         let is_impl_item = match self.hir_node_by_def_id(suitable_region_binding_scope) {
             Node::Item(..) | Node::TraitItem(..) => false,
-            Node::ImplItem(..) => self.is_bound_region_in_impl_item(suitable_region_binding_scope),
+            Node::ImplItem(impl_item) => match impl_item.impl_kind {
+                // For now, we do not try to target impls of traits. This is
+                // because this message is going to suggest that the user
+                // change the fn signature, but they may not be free to do so,
+                // since the signature must match the trait.
+                //
+                // FIXME(#42706) -- in some cases, we could do better here.
+                hir::ImplItemImplKind::Trait { .. } => true,
+                _ => false,
+            },
             _ => false,
         };
 
@@ -2330,21 +2339,6 @@ impl<'tcx> TyCtxt<'tcx> {
         None
     }
 
-    /// Checks if the bound region is in Impl Item.
-    pub fn is_bound_region_in_impl_item(self, suitable_region_binding_scope: LocalDefId) -> bool {
-        let container_id = self.parent(suitable_region_binding_scope.to_def_id());
-        if self.impl_trait_ref(container_id).is_some() {
-            // For now, we do not try to target impls of traits. This is
-            // because this message is going to suggest that the user
-            // change the fn signature, but they may not be free to do so,
-            // since the signature must match the trait.
-            //
-            // FIXME(#42706) -- in some cases, we could do better here.
-            return true;
-        }
-        false
-    }
-
     /// Determines whether identifiers in the assembly have strict naming rules.
     /// Currently, only NVPTX* targets need it.
     pub fn has_strict_asm_symbol_naming(self) -> bool {
diff --git a/compiler/rustc_passes/src/dead.rs b/compiler/rustc_passes/src/dead.rs
index f36a7a5b184a7..3c2c9683a4d19 100644
--- a/compiler/rustc_passes/src/dead.rs
+++ b/compiler/rustc_passes/src/dead.rs
@@ -373,31 +373,27 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
     /// Automatically generated items marked with `rustc_trivial_field_reads`
     /// will be ignored for the purposes of dead code analysis (see PR #85200
     /// for discussion).
-    fn should_ignore_item(&mut self, def_id: DefId) -> bool {
-        if let Some(impl_of) = self.tcx.trait_impl_of_assoc(def_id) {
-            if !self.tcx.is_automatically_derived(impl_of) {
-                return false;
-            }
-
-            if let Some(trait_of) = self.tcx.trait_id_of_impl(impl_of)
-                && self.tcx.has_attr(trait_of, sym::rustc_trivial_field_reads)
+    fn should_ignore_impl_item(&mut self, impl_item: &hir::ImplItem<'_>) -> bool {
+        if let hir::ImplItemImplKind::Trait { .. } = impl_item.impl_kind
+            && let impl_of = self.tcx.parent(impl_item.owner_id.to_def_id())
+            && self.tcx.is_automatically_derived(impl_of)
+            && let trait_ref = self.tcx.impl_trait_ref(impl_of).unwrap().instantiate_identity()
+            && self.tcx.has_attr(trait_ref.def_id, sym::rustc_trivial_field_reads)
+        {
+            if let ty::Adt(adt_def, _) = trait_ref.self_ty().kind()
+                && let Some(adt_def_id) = adt_def.did().as_local()
             {
-                let trait_ref = self.tcx.impl_trait_ref(impl_of).unwrap().instantiate_identity();
-                if let ty::Adt(adt_def, _) = trait_ref.self_ty().kind()
-                    && let Some(adt_def_id) = adt_def.did().as_local()
-                {
-                    self.ignored_derived_traits.entry(adt_def_id).or_default().insert(trait_of);
-                }
-                return true;
+                self.ignored_derived_traits.entry(adt_def_id).or_default().insert(trait_ref.def_id);
             }
+            return true;
         }
 
         false
     }
 
     fn visit_node(&mut self, node: Node<'tcx>) {
-        if let Node::ImplItem(hir::ImplItem { owner_id, .. }) = node
-            && self.should_ignore_item(owner_id.to_def_id())
+        if let Node::ImplItem(impl_item) = node
+            && self.should_ignore_impl_item(impl_item)
         {
             return;
         }
@@ -439,7 +435,7 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
             }
             Node::ImplItem(impl_item) => {
                 let item = self.tcx.local_parent(impl_item.owner_id.def_id);
-                if self.tcx.impl_trait_ref(item).is_none() {
+                if let hir::ImplItemImplKind::Inherent { .. } = impl_item.impl_kind {
                     //// If it's a type whose items are live, then it's live, too.
                     //// This is done to handle the case where, for example, the static
                     //// method of a private type is used, but the type itself is never
diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
index 71650c6b9b937..7e11b7046d6c4 100644
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@@ -486,8 +486,7 @@ impl<'tcx> Visitor<'tcx> for MissingStabilityAnnotations<'tcx> {
 
     fn visit_impl_item(&mut self, ii: &'tcx hir::ImplItem<'tcx>) {
         self.check_compatible_stability(ii.owner_id.def_id);
-        let impl_def_id = self.tcx.hir_get_parent_item(ii.hir_id());
-        if self.tcx.impl_trait_ref(impl_def_id).is_none() {
+        if let hir::ImplItemImplKind::Inherent { .. } = ii.impl_kind {
             self.check_missing_stability(ii.owner_id.def_id);
             self.check_missing_const_stability(ii.owner_id.def_id);
         }
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 cb84d583e6e93..f2f840581cf02 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -421,7 +421,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 })
                 | hir::Node::ImplItem(hir::ImplItem {
                     generics,
-                    trait_item_def_id: None,
+                    impl_kind: hir::ImplItemImplKind::Inherent { .. },
                     kind: hir::ImplItemKind::Fn(..),
                     ..
                 }) if finder.can_suggest_bound(generics) => {
diff --git a/compiler/rustc_ty_utils/src/assoc.rs b/compiler/rustc_ty_utils/src/assoc.rs
index 8587c952b9158..7d257273c0a65 100644
--- a/compiler/rustc_ty_utils/src/assoc.rs
+++ b/compiler/rustc_ty_utils/src/assoc.rs
@@ -2,7 +2,7 @@ use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, DefIdMap, LocalDefId};
 use rustc_hir::definitions::{DefPathData, DisambiguatorState};
 use rustc_hir::intravisit::{self, Visitor};
-use rustc_hir::{self as hir, ItemKind};
+use rustc_hir::{self as hir, ImplItemImplKind, ItemKind};
 use rustc_middle::query::Providers;
 use rustc_middle::ty::{self, ImplTraitInTraitData, TyCtxt};
 use rustc_middle::{bug, span_bug};
@@ -121,8 +121,11 @@ fn associated_item_from_impl_item(tcx: TyCtxt<'_>, impl_item: &hir::ImplItem<'_>
     ty::AssocItem {
         kind,
         def_id: owner_id.to_def_id(),
-        trait_item_def_id: impl_item.trait_item_def_id,
         container: ty::AssocContainer::Impl,
+        trait_item_def_id: match impl_item.impl_kind {
+            ImplItemImplKind::Inherent { .. } => None,
+            ImplItemImplKind::Trait { trait_item_def_id, .. } => trait_item_def_id.ok(),
+        },
     }
 }
 struct RPITVisitor<'a, 'tcx> {
@@ -190,7 +193,10 @@ fn associated_types_for_impl_traits_in_trait_or_impl<'tcx>(
                     }
                     let did = item.owner_id.def_id.to_def_id();
                     let item = tcx.hir_impl_item(*item);
-                    let Some(trait_item_def_id) = item.trait_item_def_id else {
+                    let ImplItemImplKind::Trait {
+                        trait_item_def_id: Ok(trait_item_def_id), ..
+                    } = item.impl_kind
+                    else {
                         return Some((did, vec![]));
                     };
                     let iter = in_trait_def[&trait_item_def_id].iter().map(|&id| {
diff --git a/compiler/rustc_ty_utils/src/ty.rs b/compiler/rustc_ty_utils/src/ty.rs
index 3151257153806..b3f2bb6d4b5a3 100644
--- a/compiler/rustc_ty_utils/src/ty.rs
+++ b/compiler/rustc_ty_utils/src/ty.rs
@@ -88,8 +88,15 @@ fn defaultness(tcx: TyCtxt<'_>, def_id: LocalDefId) -> hir::Defaultness {
                 }),
             ..
         })
-        | hir::Node::ImplItem(hir::ImplItem { defaultness, .. })
+        | hir::Node::ImplItem(hir::ImplItem {
+            impl_kind: hir::ImplItemImplKind::Trait { defaultness, .. },
+            ..
+        })
         | hir::Node::TraitItem(hir::TraitItem { defaultness, .. }) => *defaultness,
+        hir::Node::ImplItem(hir::ImplItem {
+            impl_kind: hir::ImplItemImplKind::Inherent { .. },
+            ..
+        }) => hir::Defaultness::Final,
         node => {
             bug!("`defaultness` called on {:?}", node);
         }
diff --git a/src/tools/clippy/clippy_lints/src/disallowed_macros.rs b/src/tools/clippy/clippy_lints/src/disallowed_macros.rs
index 23e7c7251cf15..49cd2671dc003 100644
--- a/src/tools/clippy/clippy_lints/src/disallowed_macros.rs
+++ b/src/tools/clippy/clippy_lints/src/disallowed_macros.rs
@@ -8,7 +8,7 @@ use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::DefIdMap;
 use rustc_hir::{
-    AmbigArg, Expr, ExprKind, ForeignItem, HirId, ImplItem, Item, ItemKind, OwnerId, Pat, Path, Stmt, TraitItem, Ty,
+    AmbigArg, Expr, ExprKind, ForeignItem, HirId, ImplItem, ImplItemImplKind, Item, ItemKind, OwnerId, Pat, Path, Stmt, TraitItem, Ty,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::TyCtxt;
@@ -177,7 +177,9 @@ impl LateLintPass<'_> for DisallowedMacros {
 
     fn check_impl_item(&mut self, cx: &LateContext<'_>, item: &ImplItem<'_>) {
         self.check(cx, item.span, None);
-        self.check(cx, item.vis_span, None);
+        if let ImplItemImplKind::Inherent { vis_span, .. } = item.impl_kind {
+            self.check(cx, vis_span, None);
+        }
     }
 
     fn check_trait_item(&mut self, cx: &LateContext<'_>, item: &TraitItem<'_>) {
diff --git a/src/tools/clippy/clippy_lints/src/manual_async_fn.rs b/src/tools/clippy/clippy_lints/src/manual_async_fn.rs
index ba1ad599e1169..bee3b19b597c0 100644
--- a/src/tools/clippy/clippy_lints/src/manual_async_fn.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_async_fn.rs
@@ -4,7 +4,7 @@ use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
     Block, Body, Closure, ClosureKind, CoroutineDesugaring, CoroutineKind, CoroutineSource, Expr, ExprKind, FnDecl,
-    FnRetTy, GenericBound, ImplItem, Item, Node, OpaqueTy, TraitRef, Ty, TyKind,
+    FnRetTy, GenericBound, Node, OpaqueTy, TraitRef, Ty, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::middle::resolve_bound_vars::ResolvedArg;
@@ -60,8 +60,11 @@ impl<'tcx> LateLintPass<'tcx> for ManualAsyncFn {
             && let ExprKind::Block(block, _) = body.value.kind
             && block.stmts.is_empty()
             && let Some(closure_body) = desugared_async_block(cx, block)
-            && let Node::Item(Item {vis_span, ..}) | Node::ImplItem(ImplItem {vis_span, ..}) =
-                cx.tcx.hir_node_by_def_id(fn_def_id)
+            && let Some(vis_span_opt) = match cx.tcx.hir_node_by_def_id(fn_def_id) {
+                Node::Item(item) => Some(Some(item.vis_span)),
+                Node::ImplItem(impl_item) => Some(impl_item.vis_span()),
+                _ => None,
+            }
             && !span.from_expansion()
         {
             let header_span = span.with_hi(ret_ty.span.hi());
@@ -72,7 +75,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) = vis_span.get_source_text(cx)
+                    if let Some(vis_span) = vis_span_opt
+                        && 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_snip)) = suggested_ret(cx, output)
diff --git a/src/tools/clippy/clippy_lints/src/min_ident_chars.rs b/src/tools/clippy/clippy_lints/src/min_ident_chars.rs
index dbce29a86318c..6258e408217fc 100644
--- a/src/tools/clippy/clippy_lints/src/min_ident_chars.rs
+++ b/src/tools/clippy/clippy_lints/src/min_ident_chars.rs
@@ -5,8 +5,8 @@ use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::intravisit::{Visitor, walk_item, walk_trait_item};
 use rustc_hir::{
-    GenericParamKind, HirId, Impl, ImplItem, ImplItemKind, Item, ItemKind, ItemLocalId, Node, Pat, PatKind, TraitItem,
-    UsePath,
+    GenericParamKind, HirId, Impl, ImplItem, ImplItemImplKind, ImplItemKind, Item, ItemKind, ItemLocalId, Node, Pat,
+    PatKind, TraitItem, UsePath,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::impl_lint_pass;
@@ -256,7 +256,7 @@ fn is_not_in_trait_impl(cx: &LateContext<'_>, pat: &Pat<'_>, ident: Ident) -> bo
 }
 
 fn get_param_name(impl_item: &ImplItem<'_>, cx: &LateContext<'_>, ident: Ident) -> Option<Symbol> {
-    if let Some(trait_item_def_id) = impl_item.trait_item_def_id {
+    if let ImplItemImplKind::Trait { trait_item_def_id: Ok(trait_item_def_id), .. } = impl_item.impl_kind {
         let trait_param_names = cx.tcx.fn_arg_idents(trait_item_def_id);
 
         let ImplItemKind::Fn(_, body_id) = impl_item.kind else {
diff --git a/src/tools/clippy/clippy_lints/src/missing_const_for_fn.rs b/src/tools/clippy/clippy_lints/src/missing_const_for_fn.rs
index a6be7581c9a38..a63ad97862627 100644
--- a/src/tools/clippy/clippy_lints/src/missing_const_for_fn.rs
+++ b/src/tools/clippy/clippy_lints/src/missing_const_for_fn.rs
@@ -158,13 +158,23 @@ impl<'tcx> LateLintPass<'tcx> for MissingConstForFn {
         let mir = cx.tcx.optimized_mir(def_id);
 
         if let Ok(()) = is_min_const_fn(cx, mir, self.msrv)
-            && let hir::Node::Item(hir::Item { vis_span, .. }) | hir::Node::ImplItem(hir::ImplItem { vis_span, .. }) =
-                cx.tcx.hir_node_by_def_id(def_id)
+            && let node = cx.tcx.hir_node_by_def_id(def_id)
+            && let Some((item_span, vis_span_opt)) = match node {
+                hir::Node::Item(item) => Some((item.span, Some(item.vis_span))),
+                hir::Node::ImplItem(impl_item) => Some((impl_item.span, impl_item.vis_span())),
+                _ => None,
+            }
         {
-            let suggestion = if vis_span.is_empty() { "const " } else { " const" };
+            let (sugg_span, suggestion) = if let Some(vis_span) = vis_span_opt
+                && !vis_span.is_empty()
+            {
+                (vis_span.shrink_to_hi(), " const")
+            } else {
+                (item_span.shrink_to_lo(), "const ")
+            };
             span_lint_and_then(cx, MISSING_CONST_FOR_FN, span, "this could be a `const fn`", |diag| {
                 diag.span_suggestion_verbose(
-                    vis_span.shrink_to_hi(),
+                    sugg_span,
                     "make the function `const`",
                     suggestion,
                     Applicability::MachineApplicable,
diff --git a/src/tools/clippy/clippy_utils/src/check_proc_macro.rs b/src/tools/clippy/clippy_utils/src/check_proc_macro.rs
index c4a759e919b1b..1a25c90d735e4 100644
--- a/src/tools/clippy/clippy_utils/src/check_proc_macro.rs
+++ b/src/tools/clippy/clippy_utils/src/check_proc_macro.rs
@@ -19,7 +19,7 @@ use rustc_ast::token::CommentKind;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
     Block, BlockCheckMode, Body, Closure, Destination, Expr, ExprKind, FieldDef, FnHeader, FnRetTy, HirId, Impl,
-    ImplItem, ImplItemKind, IsAuto, Item, ItemKind, Lit, LoopSource, MatchSource, MutTy, Node, Path, QPath, Safety,
+    ImplItem, ImplItemImplKind, ImplItemKind, IsAuto, Item, ItemKind, Lit, LoopSource, MatchSource, MutTy, Node, Path, QPath, Safety,
     TraitImplHeader, TraitItem, TraitItemKind, Ty, TyKind, UnOp, UnsafeSource, Variant, VariantData, YieldSource,
 };
 use rustc_lint::{EarlyContext, LateContext, LintContext};
@@ -280,16 +280,17 @@ fn trait_item_search_pat(item: &TraitItem<'_>) -> (Pat, Pat) {
 }
 
 fn impl_item_search_pat(item: &ImplItem<'_>) -> (Pat, Pat) {
-    let (start_pat, end_pat) = match &item.kind {
+    let (mut start_pat, end_pat) = match &item.kind {
         ImplItemKind::Const(..) => (Pat::Str("const"), Pat::Str(";")),
         ImplItemKind::Type(..) => (Pat::Str("type"), Pat::Str(";")),
         ImplItemKind::Fn(sig, ..) => (fn_header_search_pat(sig.header), Pat::Str("")),
     };
-    if item.vis_span.is_empty() {
-        (start_pat, end_pat)
-    } else {
-        (Pat::Str("pub"), end_pat)
-    }
+    if let ImplItemImplKind::Inherent { vis_span, .. } = item.impl_kind
+        && !vis_span.is_empty()
+    {
+        start_pat = Pat::Str("pub");
+    };
+    (start_pat, end_pat)
 }
 
 fn field_def_search_pat(def: &FieldDef<'_>) -> (Pat, Pat) {
@@ -313,21 +314,20 @@ fn variant_search_pat(v: &Variant<'_>) -> (Pat, Pat) {
 }
 
 fn fn_kind_pat(tcx: TyCtxt<'_>, kind: &FnKind<'_>, body: &Body<'_>, hir_id: HirId) -> (Pat, Pat) {
-    let (start_pat, end_pat) = match kind {
+    let (mut start_pat, end_pat) = match kind {
         FnKind::ItemFn(.., header) => (fn_header_search_pat(*header), Pat::Str("")),
         FnKind::Method(.., sig) => (fn_header_search_pat(sig.header), Pat::Str("")),
         FnKind::Closure => return (Pat::Str(""), expr_search_pat(tcx, body.value).1),
     };
-    let start_pat = match tcx.hir_node(hir_id) {
-        Node::Item(Item { vis_span, .. }) | Node::ImplItem(ImplItem { vis_span, .. }) => {
-            if vis_span.is_empty() {
-                start_pat
-            } else {
-                Pat::Str("pub")
+    match tcx.hir_node(hir_id) {
+        Node::Item(Item { vis_span, .. })
+        | Node::ImplItem(ImplItem { impl_kind: ImplItemImplKind::Inherent { vis_span, .. }, .. }) => {
+            if !vis_span.is_empty() {
+                start_pat = Pat::Str("pub")
             }
         },
-        Node::TraitItem(_) => start_pat,
-        _ => Pat::Str(""),
+        Node::ImplItem(_) | Node::TraitItem(_) => {},
+        _ => start_pat = Pat::Str(""),
     };
     (start_pat, end_pat)
 }

From d734981f14d934fd0ffa55ad6a74688227899c5e Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 5 Aug 2025 15:59:44 -0500
Subject: [PATCH 0874/1889] Introduce hir::ImplItemImplKind

---
 clippy_lints/src/disallowed_macros.rs    |  6 +++--
 clippy_lints/src/manual_async_fn.rs      | 12 ++++++---
 clippy_lints/src/min_ident_chars.rs      |  6 ++---
 clippy_lints/src/missing_const_for_fn.rs | 18 ++++++++++---
 clippy_utils/src/check_proc_macro.rs     | 32 ++++++++++++------------
 5 files changed, 45 insertions(+), 29 deletions(-)

diff --git a/clippy_lints/src/disallowed_macros.rs b/clippy_lints/src/disallowed_macros.rs
index 23e7c7251cf15..49cd2671dc003 100644
--- a/clippy_lints/src/disallowed_macros.rs
+++ b/clippy_lints/src/disallowed_macros.rs
@@ -8,7 +8,7 @@ use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::DefIdMap;
 use rustc_hir::{
-    AmbigArg, Expr, ExprKind, ForeignItem, HirId, ImplItem, Item, ItemKind, OwnerId, Pat, Path, Stmt, TraitItem, Ty,
+    AmbigArg, Expr, ExprKind, ForeignItem, HirId, ImplItem, ImplItemImplKind, Item, ItemKind, OwnerId, Pat, Path, Stmt, TraitItem, Ty,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::TyCtxt;
@@ -177,7 +177,9 @@ impl LateLintPass<'_> for DisallowedMacros {
 
     fn check_impl_item(&mut self, cx: &LateContext<'_>, item: &ImplItem<'_>) {
         self.check(cx, item.span, None);
-        self.check(cx, item.vis_span, None);
+        if let ImplItemImplKind::Inherent { vis_span, .. } = item.impl_kind {
+            self.check(cx, vis_span, None);
+        }
     }
 
     fn check_trait_item(&mut self, cx: &LateContext<'_>, item: &TraitItem<'_>) {
diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index ba1ad599e1169..bee3b19b597c0 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -4,7 +4,7 @@ use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
     Block, Body, Closure, ClosureKind, CoroutineDesugaring, CoroutineKind, CoroutineSource, Expr, ExprKind, FnDecl,
-    FnRetTy, GenericBound, ImplItem, Item, Node, OpaqueTy, TraitRef, Ty, TyKind,
+    FnRetTy, GenericBound, Node, OpaqueTy, TraitRef, Ty, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::middle::resolve_bound_vars::ResolvedArg;
@@ -60,8 +60,11 @@ impl<'tcx> LateLintPass<'tcx> for ManualAsyncFn {
             && let ExprKind::Block(block, _) = body.value.kind
             && block.stmts.is_empty()
             && let Some(closure_body) = desugared_async_block(cx, block)
-            && let Node::Item(Item {vis_span, ..}) | Node::ImplItem(ImplItem {vis_span, ..}) =
-                cx.tcx.hir_node_by_def_id(fn_def_id)
+            && let Some(vis_span_opt) = match cx.tcx.hir_node_by_def_id(fn_def_id) {
+                Node::Item(item) => Some(Some(item.vis_span)),
+                Node::ImplItem(impl_item) => Some(impl_item.vis_span()),
+                _ => None,
+            }
             && !span.from_expansion()
         {
             let header_span = span.with_hi(ret_ty.span.hi());
@@ -72,7 +75,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) = vis_span.get_source_text(cx)
+                    if let Some(vis_span) = vis_span_opt
+                        && 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_snip)) = suggested_ret(cx, output)
diff --git a/clippy_lints/src/min_ident_chars.rs b/clippy_lints/src/min_ident_chars.rs
index dbce29a86318c..6258e408217fc 100644
--- a/clippy_lints/src/min_ident_chars.rs
+++ b/clippy_lints/src/min_ident_chars.rs
@@ -5,8 +5,8 @@ use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::intravisit::{Visitor, walk_item, walk_trait_item};
 use rustc_hir::{
-    GenericParamKind, HirId, Impl, ImplItem, ImplItemKind, Item, ItemKind, ItemLocalId, Node, Pat, PatKind, TraitItem,
-    UsePath,
+    GenericParamKind, HirId, Impl, ImplItem, ImplItemImplKind, ImplItemKind, Item, ItemKind, ItemLocalId, Node, Pat,
+    PatKind, TraitItem, UsePath,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::impl_lint_pass;
@@ -256,7 +256,7 @@ fn is_not_in_trait_impl(cx: &LateContext<'_>, pat: &Pat<'_>, ident: Ident) -> bo
 }
 
 fn get_param_name(impl_item: &ImplItem<'_>, cx: &LateContext<'_>, ident: Ident) -> Option<Symbol> {
-    if let Some(trait_item_def_id) = impl_item.trait_item_def_id {
+    if let ImplItemImplKind::Trait { trait_item_def_id: Ok(trait_item_def_id), .. } = impl_item.impl_kind {
         let trait_param_names = cx.tcx.fn_arg_idents(trait_item_def_id);
 
         let ImplItemKind::Fn(_, body_id) = impl_item.kind else {
diff --git a/clippy_lints/src/missing_const_for_fn.rs b/clippy_lints/src/missing_const_for_fn.rs
index a6be7581c9a38..a63ad97862627 100644
--- a/clippy_lints/src/missing_const_for_fn.rs
+++ b/clippy_lints/src/missing_const_for_fn.rs
@@ -158,13 +158,23 @@ impl<'tcx> LateLintPass<'tcx> for MissingConstForFn {
         let mir = cx.tcx.optimized_mir(def_id);
 
         if let Ok(()) = is_min_const_fn(cx, mir, self.msrv)
-            && let hir::Node::Item(hir::Item { vis_span, .. }) | hir::Node::ImplItem(hir::ImplItem { vis_span, .. }) =
-                cx.tcx.hir_node_by_def_id(def_id)
+            && let node = cx.tcx.hir_node_by_def_id(def_id)
+            && let Some((item_span, vis_span_opt)) = match node {
+                hir::Node::Item(item) => Some((item.span, Some(item.vis_span))),
+                hir::Node::ImplItem(impl_item) => Some((impl_item.span, impl_item.vis_span())),
+                _ => None,
+            }
         {
-            let suggestion = if vis_span.is_empty() { "const " } else { " const" };
+            let (sugg_span, suggestion) = if let Some(vis_span) = vis_span_opt
+                && !vis_span.is_empty()
+            {
+                (vis_span.shrink_to_hi(), " const")
+            } else {
+                (item_span.shrink_to_lo(), "const ")
+            };
             span_lint_and_then(cx, MISSING_CONST_FOR_FN, span, "this could be a `const fn`", |diag| {
                 diag.span_suggestion_verbose(
-                    vis_span.shrink_to_hi(),
+                    sugg_span,
                     "make the function `const`",
                     suggestion,
                     Applicability::MachineApplicable,
diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index c4a759e919b1b..1a25c90d735e4 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -19,7 +19,7 @@ use rustc_ast::token::CommentKind;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
     Block, BlockCheckMode, Body, Closure, Destination, Expr, ExprKind, FieldDef, FnHeader, FnRetTy, HirId, Impl,
-    ImplItem, ImplItemKind, IsAuto, Item, ItemKind, Lit, LoopSource, MatchSource, MutTy, Node, Path, QPath, Safety,
+    ImplItem, ImplItemImplKind, ImplItemKind, IsAuto, Item, ItemKind, Lit, LoopSource, MatchSource, MutTy, Node, Path, QPath, Safety,
     TraitImplHeader, TraitItem, TraitItemKind, Ty, TyKind, UnOp, UnsafeSource, Variant, VariantData, YieldSource,
 };
 use rustc_lint::{EarlyContext, LateContext, LintContext};
@@ -280,16 +280,17 @@ fn trait_item_search_pat(item: &TraitItem<'_>) -> (Pat, Pat) {
 }
 
 fn impl_item_search_pat(item: &ImplItem<'_>) -> (Pat, Pat) {
-    let (start_pat, end_pat) = match &item.kind {
+    let (mut start_pat, end_pat) = match &item.kind {
         ImplItemKind::Const(..) => (Pat::Str("const"), Pat::Str(";")),
         ImplItemKind::Type(..) => (Pat::Str("type"), Pat::Str(";")),
         ImplItemKind::Fn(sig, ..) => (fn_header_search_pat(sig.header), Pat::Str("")),
     };
-    if item.vis_span.is_empty() {
-        (start_pat, end_pat)
-    } else {
-        (Pat::Str("pub"), end_pat)
-    }
+    if let ImplItemImplKind::Inherent { vis_span, .. } = item.impl_kind
+        && !vis_span.is_empty()
+    {
+        start_pat = Pat::Str("pub");
+    };
+    (start_pat, end_pat)
 }
 
 fn field_def_search_pat(def: &FieldDef<'_>) -> (Pat, Pat) {
@@ -313,21 +314,20 @@ fn variant_search_pat(v: &Variant<'_>) -> (Pat, Pat) {
 }
 
 fn fn_kind_pat(tcx: TyCtxt<'_>, kind: &FnKind<'_>, body: &Body<'_>, hir_id: HirId) -> (Pat, Pat) {
-    let (start_pat, end_pat) = match kind {
+    let (mut start_pat, end_pat) = match kind {
         FnKind::ItemFn(.., header) => (fn_header_search_pat(*header), Pat::Str("")),
         FnKind::Method(.., sig) => (fn_header_search_pat(sig.header), Pat::Str("")),
         FnKind::Closure => return (Pat::Str(""), expr_search_pat(tcx, body.value).1),
     };
-    let start_pat = match tcx.hir_node(hir_id) {
-        Node::Item(Item { vis_span, .. }) | Node::ImplItem(ImplItem { vis_span, .. }) => {
-            if vis_span.is_empty() {
-                start_pat
-            } else {
-                Pat::Str("pub")
+    match tcx.hir_node(hir_id) {
+        Node::Item(Item { vis_span, .. })
+        | Node::ImplItem(ImplItem { impl_kind: ImplItemImplKind::Inherent { vis_span, .. }, .. }) => {
+            if !vis_span.is_empty() {
+                start_pat = Pat::Str("pub")
             }
         },
-        Node::TraitItem(_) => start_pat,
-        _ => Pat::Str(""),
+        Node::ImplItem(_) | Node::TraitItem(_) => {},
+        _ => start_pat = Pat::Str(""),
     };
     (start_pat, end_pat)
 }

From 9615ec7d108399501d7d48f4aeac46561ef31fc8 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 13 Aug 2025 15:24:19 -0500
Subject: [PATCH 0875/1889] Split AssocContainer::{InherentImpl,TraitImpl}

---
 .../rustc_hir_analysis/src/check/check.rs     | 15 +++---
 .../src/check/compare_impl_item.rs            | 14 ++++--
 .../rustc_hir_analysis/src/check/wfcheck.rs   |  7 +--
 .../rustc_hir_typeck/src/fn_ctxt/_impl.rs     |  2 +-
 .../rustc_hir_typeck/src/fn_ctxt/checks.rs    |  2 +-
 compiler/rustc_hir_typeck/src/lib.rs          |  3 +-
 compiler/rustc_hir_typeck/src/method/probe.rs |  2 +-
 compiler/rustc_lint/src/builtin.rs            | 13 +++--
 compiler/rustc_lint/src/nonstandard_style.rs  | 28 ++---------
 compiler/rustc_metadata/src/rmeta/decoder.rs  | 13 +----
 compiler/rustc_metadata/src/rmeta/encoder.rs  | 29 ++++-------
 compiler/rustc_metadata/src/rmeta/mod.rs      |  3 +-
 compiler/rustc_metadata/src/rmeta/table.rs    |  7 ---
 compiler/rustc_middle/src/ty/assoc.rs         | 50 ++++++++++++++-----
 compiler/rustc_middle/src/ty/instance.rs      | 41 +++++++--------
 compiler/rustc_middle/src/ty/mod.rs           | 15 ++----
 compiler/rustc_passes/src/stability.rs        |  4 +-
 compiler/rustc_public/src/ty.rs               |  8 ++-
 .../src/unstable/convert/stable/ty.rs         | 12 +++--
 .../error_reporting/infer/note_and_explain.rs |  2 +-
 .../src/error_reporting/infer/region.rs       |  7 +--
 .../src/error_reporting/traits/call_kind.rs   |  3 +-
 .../traits/specialize/specialization_graph.rs |  2 +-
 compiler/rustc_ty_utils/src/assoc.rs          | 29 ++++-------
 compiler/rustc_ty_utils/src/opaque_types.rs   |  2 +-
 src/librustdoc/clean/mod.rs                   | 20 ++++----
 src/librustdoc/clean/types.rs                 | 33 +++++-------
 .../clippy/clippy_lints/src/missing_doc.rs    | 11 ++--
 .../clippy/clippy_lints/src/missing_inline.rs |  3 +-
 .../clippy_lints/src/missing_trait_methods.rs |  2 +-
 src/tools/clippy/clippy_utils/src/lib.rs      |  2 +-
 .../post-analysis-user-facing-param-env.rs    |  1 -
 ...post-analysis-user-facing-param-env.stderr | 19 +------
 33 files changed, 174 insertions(+), 230 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
index 3887c96fce634..886ebddc75c97 100644
--- a/compiler/rustc_hir_analysis/src/check/check.rs
+++ b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -1009,7 +1009,7 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Result<(),
             res = res.and(check_associated_item(tcx, def_id));
             let assoc_item = tcx.associated_item(def_id);
             match assoc_item.container {
-                ty::AssocContainer::Impl => {}
+                ty::AssocContainer::InherentImpl | ty::AssocContainer::TraitImpl(_) => {}
                 ty::AssocContainer::Trait => {
                     res = res.and(check_trait_item(tcx, def_id));
                 }
@@ -1026,7 +1026,7 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Result<(),
             res = res.and(check_associated_item(tcx, def_id));
             let assoc_item = tcx.associated_item(def_id);
             match assoc_item.container {
-                ty::AssocContainer::Impl => {}
+                ty::AssocContainer::InherentImpl | ty::AssocContainer::TraitImpl(_) => {}
                 ty::AssocContainer::Trait => {
                     res = res.and(check_trait_item(tcx, def_id));
                 }
@@ -1043,7 +1043,7 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Result<(),
 
             let assoc_item = tcx.associated_item(def_id);
             let has_type = match assoc_item.container {
-                ty::AssocContainer::Impl => true,
+                ty::AssocContainer::InherentImpl | ty::AssocContainer::TraitImpl(_) => true,
                 ty::AssocContainer::Trait => {
                     tcx.ensure_ok().explicit_item_bounds(def_id);
                     tcx.ensure_ok().explicit_item_self_bounds(def_id);
@@ -1177,12 +1177,9 @@ fn check_impl_items_against_trait<'tcx>(
 
     for &impl_item in impl_item_refs {
         let ty_impl_item = tcx.associated_item(impl_item);
-        let ty_trait_item = if let Some(trait_item_id) = ty_impl_item.trait_item_def_id {
-            tcx.associated_item(trait_item_id)
-        } else {
-            // Checked in `associated_item`.
-            tcx.dcx().span_delayed_bug(tcx.def_span(impl_item), "missing associated item in trait");
-            continue;
+        let ty_trait_item = match ty_impl_item.expect_trait_impl() {
+            Ok(trait_item_id) => tcx.associated_item(trait_item_id),
+            Err(ErrorGuaranteed { .. }) => continue,
         };
 
         let res = tcx.ensure_ok().compare_impl_item(impl_item.expect_local());
diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
index 85cd8da2ca4d9..84fb09b739049 100644
--- a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
+++ b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
@@ -37,7 +37,7 @@ pub(super) fn compare_impl_item(
     impl_item_def_id: LocalDefId,
 ) -> Result<(), ErrorGuaranteed> {
     let impl_item = tcx.associated_item(impl_item_def_id);
-    let trait_item = tcx.associated_item(impl_item.trait_item_def_id.unwrap());
+    let trait_item = tcx.associated_item(impl_item.expect_trait_impl()?);
     let impl_trait_ref =
         tcx.impl_trait_ref(impl_item.container_id(tcx)).unwrap().instantiate_identity();
     debug!(?impl_trait_ref);
@@ -446,7 +446,7 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
     impl_m_def_id: LocalDefId,
 ) -> Result<&'tcx DefIdMap<ty::EarlyBinder<'tcx, Ty<'tcx>>>, ErrorGuaranteed> {
     let impl_m = tcx.associated_item(impl_m_def_id.to_def_id());
-    let trait_m = tcx.associated_item(impl_m.trait_item_def_id.unwrap());
+    let trait_m = tcx.associated_item(impl_m.expect_trait_impl()?);
     let impl_trait_ref =
         tcx.impl_trait_ref(tcx.parent(impl_m_def_id.to_def_id())).unwrap().instantiate_identity();
     // First, check a few of the same things as `compare_impl_method`,
@@ -1449,7 +1449,9 @@ fn compare_self_type<'tcx>(
 
     let self_string = |method: ty::AssocItem| {
         let untransformed_self_ty = match method.container {
-            ty::AssocContainer::Impl => impl_trait_ref.self_ty(),
+            ty::AssocContainer::InherentImpl | ty::AssocContainer::TraitImpl(_) => {
+                impl_trait_ref.self_ty()
+            }
             ty::AssocContainer::Trait => tcx.types.self_param,
         };
         let self_arg_ty = tcx.fn_sig(method.def_id).instantiate_identity().input(0);
@@ -2458,8 +2460,12 @@ fn param_env_with_gat_bounds<'tcx>(
 
     for impl_ty in impl_tys_to_install {
         let trait_ty = match impl_ty.container {
+            ty::AssocContainer::InherentImpl => bug!(),
             ty::AssocContainer::Trait => impl_ty,
-            ty::AssocContainer::Impl => tcx.associated_item(impl_ty.trait_item_def_id.unwrap()),
+            ty::AssocContainer::TraitImpl(Err(_)) => continue,
+            ty::AssocContainer::TraitImpl(Ok(trait_item_def_id)) => {
+                tcx.associated_item(trait_item_def_id)
+            }
         };
 
         let mut bound_vars: smallvec::SmallVec<[ty::BoundVariableKind; 8]> =
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
index 21dc29a817245..d33f1f3e12afe 100644
--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -944,12 +944,13 @@ pub(crate) fn check_associated_item(
 
         // Avoid bogus "type annotations needed `Foo: Bar`" errors on `impl Bar for Foo` in case
         // other `Foo` impls are incoherent.
-        tcx.ensure_ok()
-            .coherent_trait(tcx.parent(item.trait_item_def_id.unwrap_or(item_id.into())))?;
+        tcx.ensure_ok().coherent_trait(tcx.parent(item.trait_item_or_self()?))?;
 
         let self_ty = match item.container {
             ty::AssocContainer::Trait => tcx.types.self_param,
-            ty::AssocContainer::Impl => tcx.type_of(item.container_id(tcx)).instantiate_identity(),
+            ty::AssocContainer::InherentImpl | ty::AssocContainer::TraitImpl(_) => {
+                tcx.type_of(item.container_id(tcx)).instantiate_identity()
+            }
         };
 
         let span = tcx.def_span(item_id);
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
index 7b485acc8bd17..7370124e800da 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -1033,7 +1033,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             self.set_tainted_by_errors(e);
                         }
                     }
-                    ty::AssocContainer::Impl => {
+                    ty::AssocContainer::InherentImpl | ty::AssocContainer::TraitImpl(_) => {
                         if segments.len() == 1 {
                             // `<T>::assoc` will end up here, and so
                             // can `T::assoc`. If this came from an
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
index 94b635c41b4b2..44a6084ebd5ad 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -2354,7 +2354,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             // We want it to always point to the trait item.
             // If we're pointing at an inherent function, we don't need to do anything,
             // so we fetch the parent and verify if it's a trait item.
-            && let maybe_trait_item_def_id = assoc_item.trait_item_def_id.unwrap_or(def_id)
+            && let Ok(maybe_trait_item_def_id) = assoc_item.trait_item_or_self()
             && let maybe_trait_def_id = self.tcx.parent(maybe_trait_item_def_id)
             // Just an easy way to check "trait_def_id == Fn/FnMut/FnOnce"
             && let Some(call_kind) = self.tcx.fn_trait_kind_from_def_id(maybe_trait_def_id)
diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
index 8ba6c25c07786..7f5397a7926da 100644
--- a/compiler/rustc_hir_typeck/src/lib.rs
+++ b/compiler/rustc_hir_typeck/src/lib.rs
@@ -278,8 +278,7 @@ fn infer_type_if_missing<'tcx>(fcx: &FnCtxt<'_, 'tcx>, node: Node<'tcx>) -> Opti
     {
         if let Some(item) = tcx.opt_associated_item(def_id.into())
             && let ty::AssocKind::Const { .. } = item.kind
-            && let ty::AssocContainer::Impl = item.container
-            && let Some(trait_item_def_id) = item.trait_item_def_id
+            && let ty::AssocContainer::TraitImpl(Ok(trait_item_def_id)) = item.container
         {
             let impl_def_id = item.container_id(tcx);
             let impl_trait_ref = tcx.impl_trait_ref(impl_def_id).unwrap().instantiate_identity();
diff --git a/compiler/rustc_hir_typeck/src/method/probe.rs b/compiler/rustc_hir_typeck/src/method/probe.rs
index a52ae354c533a..4185f7f6996c8 100644
--- a/compiler/rustc_hir_typeck/src/method/probe.rs
+++ b/compiler/rustc_hir_typeck/src/method/probe.rs
@@ -1659,7 +1659,7 @@ impl<'tcx> Pick<'tcx> {
     /// Do not use for type checking.
     pub(crate) fn differs_from(&self, other: &Self) -> bool {
         let Self {
-            item: AssocItem { def_id, kind: _, container: _, trait_item_def_id: _ },
+            item: AssocItem { def_id, kind: _, container: _ },
             kind: _,
             import_ids: _,
             autoderefs: _,
diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs
index d4c83a0cca78b..75a0f89321b97 100644
--- a/compiler/rustc_lint/src/builtin.rs
+++ b/compiler/rustc_lint/src/builtin.rs
@@ -34,7 +34,7 @@ use rustc_middle::bug;
 use rustc_middle::lint::LevelAndSource;
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::ty::print::with_no_trimmed_paths;
-use rustc_middle::ty::{self, Ty, TyCtxt, TypeVisitableExt, Upcast, VariantDef};
+use rustc_middle::ty::{self, AssocContainer, Ty, TyCtxt, TypeVisitableExt, Upcast, VariantDef};
 use rustc_session::lint::FutureIncompatibilityReason;
 // hardwired lints from rustc_lint_defs
 pub use rustc_session::lint::builtin::*;
@@ -61,7 +61,6 @@ use crate::lints::{
     BuiltinUnreachablePub, BuiltinUnsafe, BuiltinUnstableFeatures, BuiltinUnusedDocComment,
     BuiltinUnusedDocCommentSub, BuiltinWhileTrue, InvalidAsmLabel,
 };
-use crate::nonstandard_style::{MethodLateContext, method_context};
 use crate::{
     EarlyContext, EarlyLintPass, LateContext, LateLintPass, Level, LintContext,
     fluent_generated as fluent,
@@ -469,14 +468,14 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
     }
 
     fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &hir::ImplItem<'_>) {
-        let context = method_context(cx, impl_item.owner_id.def_id);
+        let container = cx.tcx.associated_item(impl_item.owner_id.def_id).container;
 
-        match context {
+        match container {
             // If the method is an impl for a trait, don't doc.
-            MethodLateContext::TraitImpl => return,
-            MethodLateContext::TraitAutoImpl => {}
+            AssocContainer::TraitImpl(_) => return,
+            AssocContainer::Trait => {}
             // If the method is an impl for an item with docs_hidden, don't doc.
-            MethodLateContext::PlainImpl => {
+            AssocContainer::InherentImpl => {
                 let parent = cx.tcx.hir_get_parent_item(impl_item.hir_id());
                 let impl_ty = cx.tcx.type_of(parent).instantiate_identity();
                 let outerdef = match impl_ty.kind() {
diff --git a/compiler/rustc_lint/src/nonstandard_style.rs b/compiler/rustc_lint/src/nonstandard_style.rs
index 7cdd82b66c181..7f643a551bb70 100644
--- a/compiler/rustc_lint/src/nonstandard_style.rs
+++ b/compiler/rustc_lint/src/nonstandard_style.rs
@@ -7,7 +7,7 @@ use rustc_hir::def_id::DefId;
 use rustc_hir::intravisit::{FnKind, Visitor};
 use rustc_hir::{Attribute, GenericParamKind, PatExprKind, PatKind, find_attr};
 use rustc_middle::hir::nested_filter::All;
-use rustc_middle::ty;
+use rustc_middle::ty::AssocContainer;
 use rustc_session::config::CrateType;
 use rustc_session::{declare_lint, declare_lint_pass};
 use rustc_span::def_id::LocalDefId;
@@ -20,24 +20,6 @@ use crate::lints::{
 };
 use crate::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};
 
-#[derive(PartialEq)]
-pub(crate) enum MethodLateContext {
-    TraitAutoImpl,
-    TraitImpl,
-    PlainImpl,
-}
-
-pub(crate) fn method_context(cx: &LateContext<'_>, id: LocalDefId) -> MethodLateContext {
-    let item = cx.tcx.associated_item(id);
-    match item.container {
-        ty::AssocContainer::Trait => MethodLateContext::TraitAutoImpl,
-        ty::AssocContainer::Impl => match cx.tcx.impl_trait_ref(item.container_id(cx.tcx)) {
-            Some(_) => MethodLateContext::TraitImpl,
-            None => MethodLateContext::PlainImpl,
-        },
-    }
-}
-
 declare_lint! {
     /// The `non_camel_case_types` lint detects types, variants, traits and
     /// type parameters that don't have camel case names.
@@ -384,8 +366,8 @@ impl<'tcx> LateLintPass<'tcx> for NonSnakeCase {
         id: LocalDefId,
     ) {
         match &fk {
-            FnKind::Method(ident, sig, ..) => match method_context(cx, id) {
-                MethodLateContext::PlainImpl => {
+            FnKind::Method(ident, sig, ..) => match cx.tcx.associated_item(id).container {
+                AssocContainer::InherentImpl => {
                     if sig.header.abi != ExternAbi::Rust
                         && find_attr!(cx.tcx.get_all_attrs(id), AttributeKind::NoMangle(..))
                     {
@@ -393,10 +375,10 @@ impl<'tcx> LateLintPass<'tcx> for NonSnakeCase {
                     }
                     self.check_snake_case(cx, "method", ident);
                 }
-                MethodLateContext::TraitAutoImpl => {
+                AssocContainer::Trait => {
                     self.check_snake_case(cx, "trait method", ident);
                 }
-                _ => (),
+                AssocContainer::TraitImpl(_) => {}
             },
             FnKind::ItemFn(ident, _, header) => {
                 // Skip foreign-ABI #[no_mangle] functions (Issue #31924)
diff --git a/compiler/rustc_metadata/src/rmeta/decoder.rs b/compiler/rustc_metadata/src/rmeta/decoder.rs
index 110b26c62ef0c..0c8d1f32e991e 100644
--- a/compiler/rustc_metadata/src/rmeta/decoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/decoder.rs
@@ -1194,10 +1194,6 @@ impl<'a> CrateMetadataRef<'a> {
         self.root.tables.default_fields.get(self, id).map(|d| d.decode(self))
     }
 
-    fn get_trait_item_def_id(self, id: DefIndex) -> Option<DefId> {
-        self.root.tables.trait_item_def_id.get(self, id).map(|d| d.decode_from_cdata(self))
-    }
-
     fn get_expn_that_defined(self, id: DefIndex, sess: &Session) -> ExpnId {
         self.root
             .tables
@@ -1359,14 +1355,9 @@ impl<'a> CrateMetadataRef<'a> {
             }
             _ => bug!("cannot get associated-item of `{:?}`", self.def_key(id)),
         };
-        let container = self.root.tables.assoc_container.get(self, id).unwrap();
+        let container = self.root.tables.assoc_container.get(self, id).unwrap().decode(self);
 
-        ty::AssocItem {
-            kind,
-            def_id: self.local_def_id(id),
-            trait_item_def_id: self.get_trait_item_def_id(id),
-            container,
-        }
+        ty::AssocItem { kind, def_id: self.local_def_id(id), container }
     }
 
     fn get_ctor(self, node_id: DefIndex) -> Option<(CtorKind, DefId)> {
diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
index 0fb5b8fffd182..cb603705ce143 100644
--- a/compiler/rustc_metadata/src/rmeta/encoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -1254,7 +1254,7 @@ fn should_encode_type(tcx: TyCtxt<'_>, def_id: LocalDefId, def_kind: DefKind) ->
         DefKind::AssocTy => {
             let assoc_item = tcx.associated_item(def_id);
             match assoc_item.container {
-                ty::AssocContainer::Impl => true,
+                ty::AssocContainer::InherentImpl | ty::AssocContainer::TraitImpl(_) => true,
                 ty::AssocContainer::Trait => assoc_item.defaultness(tcx).has_value(),
             }
         }
@@ -1726,23 +1726,16 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         let item = tcx.associated_item(def_id);
 
         self.tables.defaultness.set_some(def_id.index, item.defaultness(tcx));
-        self.tables.assoc_container.set_some(def_id.index, item.container);
-
-        match item.container {
-            AssocContainer::Trait => {
-                if item.is_type() {
-                    self.encode_explicit_item_bounds(def_id);
-                    self.encode_explicit_item_self_bounds(def_id);
-                    if tcx.is_conditionally_const(def_id) {
-                        record_defaulted_array!(self.tables.explicit_implied_const_bounds[def_id]
-                            <- self.tcx.explicit_implied_const_bounds(def_id).skip_binder());
-                    }
-                }
-            }
-            AssocContainer::Impl => {
-                if let Some(trait_item_def_id) = item.trait_item_def_id {
-                    self.tables.trait_item_def_id.set_some(def_id.index, trait_item_def_id.into());
-                }
+        record!(self.tables.assoc_container[def_id] <- item.container);
+
+        if let AssocContainer::Trait = item.container
+            && item.is_type()
+        {
+            self.encode_explicit_item_bounds(def_id);
+            self.encode_explicit_item_self_bounds(def_id);
+            if tcx.is_conditionally_const(def_id) {
+                record_defaulted_array!(self.tables.explicit_implied_const_bounds[def_id]
+                    <- self.tcx.explicit_implied_const_bounds(def_id).skip_binder());
             }
         }
         if let ty::AssocKind::Type { data: ty::AssocTypeData::Rpitit(rpitit_info) } = item.kind {
diff --git a/compiler/rustc_metadata/src/rmeta/mod.rs b/compiler/rustc_metadata/src/rmeta/mod.rs
index a7b1f2c01dd18..720970bbaf93f 100644
--- a/compiler/rustc_metadata/src/rmeta/mod.rs
+++ b/compiler/rustc_metadata/src/rmeta/mod.rs
@@ -447,7 +447,6 @@ define_tables! {
     coroutine_by_move_body_def_id: Table<DefIndex, RawDefId>,
     eval_static_initializer: Table<DefIndex, LazyValue<mir::interpret::ConstAllocation<'static>>>,
     trait_def: Table<DefIndex, LazyValue<ty::TraitDef>>,
-    trait_item_def_id: Table<DefIndex, RawDefId>,
     expn_that_defined: Table<DefIndex, LazyValue<ExpnId>>,
     default_fields: Table<DefIndex, LazyValue<DefId>>,
     params_in_repr: Table<DefIndex, LazyValue<DenseBitSet<u32>>>,
@@ -459,7 +458,7 @@ define_tables! {
     def_keys: Table<DefIndex, LazyValue<DefKey>>,
     proc_macro_quoted_spans: Table<usize, LazyValue<Span>>,
     variant_data: Table<DefIndex, LazyValue<VariantData>>,
-    assoc_container: Table<DefIndex, ty::AssocContainer>,
+    assoc_container: Table<DefIndex, LazyValue<ty::AssocContainer>>,
     macro_definition: Table<DefIndex, LazyValue<ast::DelimArgs>>,
     proc_macro: Table<DefIndex, MacroKind>,
     deduced_param_attrs: Table<DefIndex, LazyArray<DeducedParamAttrs>>,
diff --git a/compiler/rustc_metadata/src/rmeta/table.rs b/compiler/rustc_metadata/src/rmeta/table.rs
index 36634bb39d806..a882ee4f2b92e 100644
--- a/compiler/rustc_metadata/src/rmeta/table.rs
+++ b/compiler/rustc_metadata/src/rmeta/table.rs
@@ -221,13 +221,6 @@ fixed_size_enum! {
     }
 }
 
-fixed_size_enum! {
-    ty::AssocContainer {
-        ( Trait )
-        ( Impl  )
-    }
-}
-
 fixed_size_enum! {
     MacroKind {
         ( Attr   )
diff --git a/compiler/rustc_middle/src/ty/assoc.rs b/compiler/rustc_middle/src/ty/assoc.rs
index 8a2f62ce8335c..60181783f9b18 100644
--- a/compiler/rustc_middle/src/ty/assoc.rs
+++ b/compiler/rustc_middle/src/ty/assoc.rs
@@ -5,7 +5,7 @@ use rustc_hir::def::{DefKind, Namespace};
 use rustc_hir::def_id::DefId;
 use rustc_hir::find_attr;
 use rustc_macros::{Decodable, Encodable, HashStable};
-use rustc_span::{Ident, Symbol};
+use rustc_span::{ErrorGuaranteed, Ident, Symbol};
 
 use super::{TyCtxt, Visibility};
 use crate::ty;
@@ -13,7 +13,9 @@ use crate::ty;
 #[derive(Clone, Copy, PartialEq, Eq, Debug, HashStable, Hash, Encodable, Decodable)]
 pub enum AssocContainer {
     Trait,
-    Impl,
+    InherentImpl,
+    /// The `DefId` points to the trait item being implemented.
+    TraitImpl(Result<DefId, ErrorGuaranteed>),
 }
 
 /// Information about an associated item
@@ -22,10 +24,6 @@ pub struct AssocItem {
     pub def_id: DefId,
     pub kind: AssocKind,
     pub container: AssocContainer,
-
-    /// If this is an item in an impl of a trait then this is the `DefId` of
-    /// the associated item on the trait that this implements.
-    pub trait_item_def_id: Option<DefId>,
 }
 
 impl AssocItem {
@@ -58,6 +56,30 @@ impl AssocItem {
         tcx.defaultness(self.def_id)
     }
 
+    pub fn expect_trait_impl(&self) -> Result<DefId, ErrorGuaranteed> {
+        let AssocContainer::TraitImpl(trait_item_id) = self.container else {
+            bug!("expected item to be in a trait impl: {:?}", self.def_id);
+        };
+        trait_item_id
+    }
+
+    /// If this is a trait impl item, returns the `DefId` of the trait item this implements.
+    /// Otherwise, returns `DefId` for self. Returns an Err in case the trait item was not
+    /// resolved successfully.
+    pub fn trait_item_or_self(&self) -> Result<DefId, ErrorGuaranteed> {
+        match self.container {
+            AssocContainer::TraitImpl(id) => id,
+            AssocContainer::Trait | AssocContainer::InherentImpl => Ok(self.def_id),
+        }
+    }
+
+    pub fn trait_item_def_id(&self) -> Option<DefId> {
+        match self.container {
+            AssocContainer::TraitImpl(Ok(id)) => Some(id),
+            _ => None,
+        }
+    }
+
     #[inline]
     pub fn visibility(&self, tcx: TyCtxt<'_>) -> Visibility<DefId> {
         tcx.visibility(self.def_id)
@@ -71,7 +93,7 @@ impl AssocItem {
     #[inline]
     pub fn trait_container(&self, tcx: TyCtxt<'_>) -> Option<DefId> {
         match self.container {
-            AssocContainer::Impl => None,
+            AssocContainer::InherentImpl | AssocContainer::TraitImpl(_) => None,
             AssocContainer::Trait => Some(tcx.parent(self.def_id)),
         }
     }
@@ -79,7 +101,9 @@ impl AssocItem {
     #[inline]
     pub fn impl_container(&self, tcx: TyCtxt<'_>) -> Option<DefId> {
         match self.container {
-            AssocContainer::Impl => Some(tcx.parent(self.def_id)),
+            AssocContainer::InherentImpl | AssocContainer::TraitImpl(_) => {
+                Some(tcx.parent(self.def_id))
+            }
             AssocContainer::Trait => None,
         }
     }
@@ -156,11 +180,11 @@ impl AssocItem {
             return false;
         }
 
-        let def_id = match (self.container, self.trait_item_def_id) {
-            (AssocContainer::Trait, _) => self.def_id,
-            (AssocContainer::Impl, Some(trait_item_did)) => trait_item_did,
-            // Inherent impl but this attr is only applied to trait assoc items.
-            (AssocContainer::Impl, None) => return true,
+        let def_id = match self.container {
+            AssocContainer::Trait => self.def_id,
+            AssocContainer::TraitImpl(Ok(trait_item_did)) => trait_item_did,
+            AssocContainer::TraitImpl(Err(_)) => return false,
+            AssocContainer::InherentImpl => return true,
         };
         find_attr!(tcx.get_all_attrs(def_id), AttributeKind::TypeConst(_))
     }
diff --git a/compiler/rustc_middle/src/ty/instance.rs b/compiler/rustc_middle/src/ty/instance.rs
index ec2a23bfebeeb..34ead91b4f6de 100644
--- a/compiler/rustc_middle/src/ty/instance.rs
+++ b/compiler/rustc_middle/src/ty/instance.rs
@@ -18,8 +18,8 @@ use crate::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use crate::ty::normalize_erasing_regions::NormalizationError;
 use crate::ty::print::{FmtPrinter, Print};
 use crate::ty::{
-    self, EarlyBinder, GenericArgs, GenericArgsRef, Ty, TyCtxt, TypeFoldable, TypeSuperVisitable,
-    TypeVisitable, TypeVisitableExt, TypeVisitor,
+    self, AssocContainer, EarlyBinder, GenericArgs, GenericArgsRef, Ty, TyCtxt, TypeFoldable,
+    TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor,
 };
 
 /// An `InstanceKind` along with the args that are needed to substitute the instance.
@@ -611,26 +611,23 @@ impl<'tcx> Instance<'tcx> {
                     debug!(" => fn pointer created for virtual call");
                     resolved.def = InstanceKind::ReifyShim(def_id, reason);
                 }
-                // Reify `Trait::method` implementations if KCFI is enabled
-                // FIXME(maurer) only reify it if it is a vtable-safe function
-                _ if tcx.sess.is_sanitizer_kcfi_enabled()
-                    && tcx
-                        .opt_associated_item(def_id)
-                        .and_then(|assoc| assoc.trait_item_def_id)
-                        .is_some() =>
-                {
-                    // If this function could also go in a vtable, we need to `ReifyShim` it with
-                    // KCFI because it can only attach one type per function.
-                    resolved.def = InstanceKind::ReifyShim(resolved.def_id(), reason)
-                }
-                // Reify `::call`-like method implementations if KCFI is enabled
-                _ if tcx.sess.is_sanitizer_kcfi_enabled()
-                    && tcx.is_closure_like(resolved.def_id()) =>
-                {
-                    // Reroute through a reify via the *unresolved* instance. The resolved one can't
-                    // be directly reified because it's closure-like. The reify can handle the
-                    // unresolved instance.
-                    resolved = Instance { def: InstanceKind::ReifyShim(def_id, reason), args }
+                _ if tcx.sess.is_sanitizer_kcfi_enabled() => {
+                    // Reify `::call`-like method implementations
+                    if tcx.is_closure_like(resolved.def_id()) {
+                        // Reroute through a reify via the *unresolved* instance. The resolved one can't
+                        // be directly reified because it's closure-like. The reify can handle the
+                        // unresolved instance.
+                        resolved = Instance { def: InstanceKind::ReifyShim(def_id, reason), args }
+                    // Reify `Trait::method` implementations
+                    // FIXME(maurer) only reify it if it is a vtable-safe function
+                    } else if let Some(assoc) = tcx.opt_associated_item(def_id)
+                        && let AssocContainer::Trait | AssocContainer::TraitImpl(Ok(_)) =
+                            assoc.container
+                    {
+                        // If this function could also go in a vtable, we need to `ReifyShim` it with
+                        // KCFI because it can only attach one type per function.
+                        resolved.def = InstanceKind::ReifyShim(resolved.def_id(), reason)
+                    }
                 }
                 _ => {}
             }
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index a34bf9b52970a..d4c001f625e11 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -1936,11 +1936,7 @@ impl<'tcx> TyCtxt<'tcx> {
 
     /// Returns the trait item that is implemented by the given item `DefId`.
     pub fn trait_item_of(self, def_id: impl IntoQueryParam<DefId>) -> Option<DefId> {
-        let assoc = self.opt_associated_item(def_id.into_query_param())?;
-        if assoc.container != AssocContainer::Impl {
-            return None;
-        }
-        assoc.trait_item_def_id
+        self.opt_associated_item(def_id.into_query_param())?.trait_item_def_id()
     }
 
     /// If the given `DefId` is an associated item of a trait,
@@ -2158,17 +2154,12 @@ impl<'tcx> TyCtxt<'tcx> {
         let Some(item) = self.opt_associated_item(def_id) else {
             return false;
         };
-        if item.container != ty::AssocContainer::Impl {
-            return false;
-        }
 
-        let Some(trait_item_def_id) = item.trait_item_def_id else {
+        let AssocContainer::TraitImpl(Ok(trait_item_def_id)) = item.container else {
             return false;
         };
 
-        return !self
-            .associated_types_for_impl_traits_in_associated_fn(trait_item_def_id)
-            .is_empty();
+        !self.associated_types_for_impl_traits_in_associated_fn(trait_item_def_id).is_empty()
     }
 }
 
diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
index 7e11b7046d6c4..2ee1bd0dfd1ec 100644
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@@ -21,8 +21,8 @@ use rustc_middle::middle::lib_features::{FeatureStability, LibFeatures};
 use rustc_middle::middle::privacy::EffectiveVisibilities;
 use rustc_middle::middle::stability::{AllowUnstable, Deprecated, DeprecationEntry, EvalResult};
 use rustc_middle::query::{LocalCrate, Providers};
-use rustc_middle::ty::TyCtxt;
 use rustc_middle::ty::print::with_no_trimmed_paths;
+use rustc_middle::ty::{AssocContainer, TyCtxt};
 use rustc_session::lint;
 use rustc_session::lint::builtin::{DEPRECATED, INEFFECTIVE_UNSTABLE_TRAIT_IMPL};
 use rustc_span::{Span, Symbol, sym};
@@ -710,7 +710,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'tcx> {
                 for impl_item_ref in items {
                     let impl_item = self.tcx.associated_item(impl_item_ref.owner_id);
 
-                    if let Some(def_id) = impl_item.trait_item_def_id {
+                    if let AssocContainer::TraitImpl(Ok(def_id)) = impl_item.container {
                         // Pass `None` to skip deprecation warnings.
                         self.tcx.check_stability(
                             def_id,
diff --git a/compiler/rustc_public/src/ty.rs b/compiler/rustc_public/src/ty.rs
index c7422051c3625..bcc77ff849da5 100644
--- a/compiler/rustc_public/src/ty.rs
+++ b/compiler/rustc_public/src/ty.rs
@@ -1613,10 +1613,6 @@ pub struct AssocItem {
     pub def_id: AssocDef,
     pub kind: AssocKind,
     pub container: AssocContainer,
-
-    /// If this is an item in an impl of a trait then this is the `DefId` of
-    /// the associated item on the trait that this implements.
-    pub trait_item_def_id: Option<AssocDef>,
 }
 
 #[derive(Clone, PartialEq, Debug, Eq, Serialize)]
@@ -1637,8 +1633,10 @@ pub enum AssocKind {
 
 #[derive(Clone, Debug, Eq, PartialEq, Serialize)]
 pub enum AssocContainer {
+    InherentImpl,
+    /// The `AssocDef` points to the trait item being implemented.
+    TraitImpl(AssocDef),
     Trait,
-    Impl,
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug, Hash, Serialize)]
diff --git a/compiler/rustc_public/src/unstable/convert/stable/ty.rs b/compiler/rustc_public/src/unstable/convert/stable/ty.rs
index ace459e79dadf..5131611eb02b3 100644
--- a/compiler/rustc_public/src/unstable/convert/stable/ty.rs
+++ b/compiler/rustc_public/src/unstable/convert/stable/ty.rs
@@ -1079,11 +1079,18 @@ impl<'tcx> Stable<'tcx> for ty::AssocKind {
 impl<'tcx> Stable<'tcx> for ty::AssocContainer {
     type T = crate::ty::AssocContainer;
 
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        _: &CompilerCtxt<'_, BridgeTys>,
+    ) -> Self::T {
         use crate::ty::AssocContainer;
         match self {
             ty::AssocContainer::Trait => AssocContainer::Trait,
-            ty::AssocContainer::Impl => AssocContainer::Impl,
+            ty::AssocContainer::InherentImpl => AssocContainer::InherentImpl,
+            ty::AssocContainer::TraitImpl(trait_item_id) => {
+                AssocContainer::TraitImpl(tables.assoc_def(trait_item_id.unwrap()))
+            }
         }
     }
 }
@@ -1100,7 +1107,6 @@ impl<'tcx> Stable<'tcx> for ty::AssocItem {
             def_id: tables.assoc_def(self.def_id),
             kind: self.kind.stable(tables, cx),
             container: self.container.stable(tables, cx),
-            trait_item_def_id: self.trait_item_def_id.map(|did| tables.assoc_def(did)),
         }
     }
 }
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 9fe685b2786ee..f997842a607f6 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
@@ -861,7 +861,7 @@ fn foo(&self) -> Self::T { String::new() }
                             "associated type defaults can't be assumed inside the \
                                             trait defining them"
                         }
-                        ty::AssocContainer::Impl => {
+                        ty::AssocContainer::InherentImpl | ty::AssocContainer::TraitImpl(_) => {
                             "associated type is `default` and may be overridden"
                         }
                     };
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 7369134420c67..518d4fe17e8f4 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/region.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/region.rs
@@ -571,13 +571,10 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         // but right now it's not really very smart when it comes to implicit `Sized`
         // predicates and bounds on the trait itself.
 
-        let Some(impl_def_id) = self.tcx.associated_item(impl_item_def_id).impl_container(self.tcx)
-        else {
-            return;
-        };
-        let Some(trait_ref) = self.tcx.impl_trait_ref(impl_def_id) else {
+        let Some(impl_def_id) = self.tcx.trait_impl_of_assoc(impl_item_def_id.to_def_id()) else {
             return;
         };
+        let trait_ref = self.tcx.impl_trait_ref(impl_def_id).unwrap();
         let trait_args = trait_ref
             .instantiate_identity()
             // Replace the explicit self type with `Self` for better suggestion rendering
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/call_kind.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/call_kind.rs
index c04a8b3d860e7..f54ebd76cab07 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/call_kind.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/call_kind.rs
@@ -76,7 +76,8 @@ pub fn call_kind<'tcx>(
     let parent = tcx.opt_associated_item(method_did).and_then(|assoc| {
         let container_id = assoc.container_id(tcx);
         match assoc.container {
-            AssocContainer::Impl => tcx.trait_id_of_impl(container_id),
+            AssocContainer::InherentImpl => None,
+            AssocContainer::TraitImpl(_) => tcx.trait_id_of_impl(container_id),
             AssocContainer::Trait => Some(container_id),
         }
     });
diff --git a/compiler/rustc_trait_selection/src/traits/specialize/specialization_graph.rs b/compiler/rustc_trait_selection/src/traits/specialize/specialization_graph.rs
index caaf8c2585d3a..4d0465777dd4d 100644
--- a/compiler/rustc_trait_selection/src/traits/specialize/specialization_graph.rs
+++ b/compiler/rustc_trait_selection/src/traits/specialize/specialization_graph.rs
@@ -387,7 +387,7 @@ pub(crate) fn assoc_def(
     if let Some(assoc_item) = ancestors.leaf_def(tcx, assoc_def_id) {
         // Ensure that the impl is constrained, otherwise projection may give us
         // bad unconstrained infer vars.
-        if assoc_item.item.container == ty::AssocContainer::Impl
+        if let ty::AssocContainer::TraitImpl(_) = assoc_item.item.container
             && let Some(impl_def_id) = assoc_item.item.container_id(tcx).as_local()
         {
             tcx.ensure_ok().enforce_impl_non_lifetime_params_are_constrained(impl_def_id)?;
diff --git a/compiler/rustc_ty_utils/src/assoc.rs b/compiler/rustc_ty_utils/src/assoc.rs
index 7d257273c0a65..84f52e7fc9d26 100644
--- a/compiler/rustc_ty_utils/src/assoc.rs
+++ b/compiler/rustc_ty_utils/src/assoc.rs
@@ -63,7 +63,7 @@ fn associated_items(tcx: TyCtxt<'_>, def_id: DefId) -> ty::AssocItems {
 fn impl_item_implementor_ids(tcx: TyCtxt<'_>, impl_id: DefId) -> DefIdMap<DefId> {
     tcx.associated_items(impl_id)
         .in_definition_order()
-        .filter_map(|item| item.trait_item_def_id.map(|trait_item| (trait_item, item.def_id)))
+        .filter_map(|item| item.trait_item_def_id().map(|trait_item| (trait_item, item.def_id)))
         .collect()
 }
 
@@ -97,12 +97,7 @@ fn associated_item_from_trait_item(
         }
     };
 
-    ty::AssocItem {
-        kind,
-        def_id: owner_id.to_def_id(),
-        trait_item_def_id: Some(owner_id.to_def_id()),
-        container: ty::AssocContainer::Trait,
-    }
+    ty::AssocItem { kind, def_id: owner_id.to_def_id(), container: ty::AssocContainer::Trait }
 }
 
 fn associated_item_from_impl_item(tcx: TyCtxt<'_>, impl_item: &hir::ImplItem<'_>) -> ty::AssocItem {
@@ -118,15 +113,13 @@ fn associated_item_from_impl_item(tcx: TyCtxt<'_>, impl_item: &hir::ImplItem<'_>
         }
     };
 
-    ty::AssocItem {
-        kind,
-        def_id: owner_id.to_def_id(),
-        container: ty::AssocContainer::Impl,
-        trait_item_def_id: match impl_item.impl_kind {
-            ImplItemImplKind::Inherent { .. } => None,
-            ImplItemImplKind::Trait { trait_item_def_id, .. } => trait_item_def_id.ok(),
-        },
-    }
+    let container = match impl_item.impl_kind {
+        ImplItemImplKind::Inherent { .. } => ty::AssocContainer::InherentImpl,
+        ImplItemImplKind::Trait { trait_item_def_id, .. } => {
+            ty::AssocContainer::TraitImpl(trait_item_def_id)
+        }
+    };
+    ty::AssocItem { kind, def_id: owner_id.to_def_id(), container }
 }
 struct RPITVisitor<'a, 'tcx> {
     tcx: TyCtxt<'tcx>,
@@ -262,7 +255,6 @@ fn associated_type_for_impl_trait_in_trait(
             }),
         },
         def_id,
-        trait_item_def_id: None,
         container: ty::AssocContainer::Trait,
     });
 
@@ -328,8 +320,7 @@ fn associated_type_for_impl_trait_in_impl(
             }),
         },
         def_id,
-        trait_item_def_id: Some(trait_assoc_def_id),
-        container: ty::AssocContainer::Impl,
+        container: ty::AssocContainer::TraitImpl(Ok(trait_assoc_def_id)),
     });
 
     // Copy visility of the containing function.
diff --git a/compiler/rustc_ty_utils/src/opaque_types.rs b/compiler/rustc_ty_utils/src/opaque_types.rs
index 4a7263d0ccd20..eb3236d30065c 100644
--- a/compiler/rustc_ty_utils/src/opaque_types.rs
+++ b/compiler/rustc_ty_utils/src/opaque_types.rs
@@ -245,7 +245,7 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for OpaqueTypeCollector<'tcx> {
 
                         for &assoc in self.tcx.associated_items(parent).in_definition_order() {
                             trace!(?assoc);
-                            if assoc.trait_item_def_id != Some(alias_ty.def_id) {
+                            if assoc.expect_trait_impl() != Ok(alias_ty.def_id) {
                                 continue;
                             }
 
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index b98f174fbbfdc..8c40e42562cf6 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -1295,11 +1295,13 @@ pub(crate) fn clean_middle_assoc_item(assoc_item: &ty::AssocItem, cx: &mut DocCo
             simplify::move_bounds_to_generic_parameters(&mut generics);
 
             match assoc_item.container {
-                ty::AssocContainer::Impl => ImplAssocConstItem(Box::new(Constant {
-                    generics,
-                    kind: ConstantKind::Extern { def_id: assoc_item.def_id },
-                    type_: ty,
-                })),
+                ty::AssocContainer::InherentImpl | ty::AssocContainer::TraitImpl(_) => {
+                    ImplAssocConstItem(Box::new(Constant {
+                        generics,
+                        kind: ConstantKind::Extern { def_id: assoc_item.def_id },
+                        type_: ty,
+                    }))
+                }
                 ty::AssocContainer::Trait => {
                     if tcx.defaultness(assoc_item.def_id).has_value() {
                         ProvidedAssocConstItem(Box::new(Constant {
@@ -1318,7 +1320,7 @@ pub(crate) fn clean_middle_assoc_item(assoc_item: &ty::AssocItem, cx: &mut DocCo
 
             if has_self {
                 let self_ty = match assoc_item.container {
-                    ty::AssocContainer::Impl => {
+                    ty::AssocContainer::InherentImpl | ty::AssocContainer::TraitImpl(_) => {
                         tcx.type_of(assoc_item.container_id(tcx)).instantiate_identity()
                     }
                     ty::AssocContainer::Trait => tcx.types.self_param,
@@ -1338,13 +1340,13 @@ pub(crate) fn clean_middle_assoc_item(assoc_item: &ty::AssocItem, cx: &mut DocCo
             }
 
             let provided = match assoc_item.container {
-                ty::AssocContainer::Impl => true,
+                ty::AssocContainer::InherentImpl | ty::AssocContainer::TraitImpl(_) => true,
                 ty::AssocContainer::Trait => assoc_item.defaultness(tcx).has_value(),
             };
             if provided {
                 let defaultness = match assoc_item.container {
-                    ty::AssocContainer::Impl => Some(assoc_item.defaultness(tcx)),
-                    ty::AssocContainer::Trait => None,
+                    ty::AssocContainer::TraitImpl(_) => Some(assoc_item.defaultness(tcx)),
+                    ty::AssocContainer::InherentImpl | ty::AssocContainer::Trait => None,
                 };
                 MethodItem(item, defaultness)
             } else {
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index 84a5f239c8dd6..bd3f4e9a6f2c8 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -690,16 +690,13 @@ impl Item {
                 // rustc's `is_const_fn` returns `true` for associated functions that have an `impl const` parent
                 // or that have a `const trait` parent. Do not display those as `const` in rustdoc because we
                 // won't be printing correct syntax plus the syntax is unstable.
-                match tcx.opt_associated_item(def_id) {
-                    Some(ty::AssocItem {
-                        container: ty::AssocContainer::Impl,
-                        trait_item_def_id: Some(_),
-                        ..
-                    })
-                    | Some(ty::AssocItem { container: ty::AssocContainer::Trait, .. }) => {
-                        hir::Constness::NotConst
-                    }
-                    None | Some(_) => hir::Constness::Const,
+                if let Some(assoc) = tcx.opt_associated_item(def_id)
+                    && let ty::AssocContainer::Trait | ty::AssocContainer::TraitImpl(_) =
+                        assoc.container
+                {
+                    hir::Constness::NotConst
+                } else {
+                    hir::Constness::Const
                 }
             } else {
                 hir::Constness::NotConst
@@ -779,17 +776,13 @@ impl Item {
             | RequiredAssocTypeItem(..)
             | RequiredMethodItem(..)
             | MethodItem(..) => {
-                let assoc_item = tcx.associated_item(def_id);
-                let is_trait_item = match assoc_item.container {
-                    ty::AssocContainer::Trait => true,
-                    ty::AssocContainer::Impl => {
-                        // Trait impl items always inherit the impl's visibility --
-                        // we don't want to show `pub`.
-                        tcx.impl_trait_ref(tcx.parent(assoc_item.def_id)).is_some()
+                match tcx.associated_item(def_id).container {
+                    // Trait impl items always inherit the impl's visibility --
+                    // we don't want to show `pub`.
+                    ty::AssocContainer::Trait | ty::AssocContainer::TraitImpl(_) => {
+                        return None;
                     }
-                };
-                if is_trait_item {
-                    return None;
+                    ty::AssocContainer::InherentImpl => {}
                 }
             }
             _ => {}
diff --git a/src/tools/clippy/clippy_lints/src/missing_doc.rs b/src/tools/clippy/clippy_lints/src/missing_doc.rs
index 7772051eb5c61..39b5964bd87b1 100644
--- a/src/tools/clippy/clippy_lints/src/missing_doc.rs
+++ b/src/tools/clippy/clippy_lints/src/missing_doc.rs
@@ -16,7 +16,7 @@ use rustc_hir::Attribute;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::LocalDefId;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::ty::Visibility;
+use rustc_middle::ty::{AssocContainer, Visibility};
 use rustc_session::impl_lint_pass;
 use rustc_span::def_id::CRATE_DEF_ID;
 use rustc_span::symbol::kw;
@@ -246,12 +246,11 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
 
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx hir::ImplItem<'_>) {
         // If the method is an impl for a trait, don't doc.
-        if let Some(cid) = cx.tcx.associated_item(impl_item.owner_id).impl_container(cx.tcx) {
-            if cx.tcx.impl_trait_ref(cid).is_some() {
+        match cx.tcx.associated_item(impl_item.owner_id).container {
+            AssocContainer::Trait | AssocContainer::TraitImpl(_) => {
                 note_prev_span_then_ret!(self.prev_span, impl_item.span);
-            }
-        } else {
-            note_prev_span_then_ret!(self.prev_span, impl_item.span);
+            },
+            AssocContainer::InherentImpl => {}
         }
 
         let (article, desc) = cx.tcx.article_and_description(impl_item.owner_id.to_def_id());
diff --git a/src/tools/clippy/clippy_lints/src/missing_inline.rs b/src/tools/clippy/clippy_lints/src/missing_inline.rs
index 490a59ca66d3e..6323e728666ce 100644
--- a/src/tools/clippy/clippy_lints/src/missing_inline.rs
+++ b/src/tools/clippy/clippy_lints/src/missing_inline.rs
@@ -167,7 +167,8 @@ impl<'tcx> LateLintPass<'tcx> for MissingInline {
         let container_id = assoc_item.container_id(cx.tcx);
         let trait_def_id = match assoc_item.container {
             AssocContainer::Trait => Some(container_id),
-            AssocContainer::Impl => cx.tcx.impl_trait_ref(container_id).map(|t| t.skip_binder().def_id),
+            AssocContainer::TraitImpl(_) => cx.tcx.impl_trait_ref(container_id).map(|t| t.skip_binder().def_id),
+            AssocContainer::InherentImpl => None,
         };
 
         if let Some(trait_def_id) = trait_def_id
diff --git a/src/tools/clippy/clippy_lints/src/missing_trait_methods.rs b/src/tools/clippy/clippy_lints/src/missing_trait_methods.rs
index 9cc93bf06531a..8e9400e9d583d 100644
--- a/src/tools/clippy/clippy_lints/src/missing_trait_methods.rs
+++ b/src/tools/clippy/clippy_lints/src/missing_trait_methods.rs
@@ -70,7 +70,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingTraitMethods {
                 .tcx
                 .associated_items(item.owner_id)
                 .in_definition_order()
-                .filter_map(|assoc_item| assoc_item.trait_item_def_id)
+                .filter_map(|assoc_item| assoc_item.expect_trait_impl().ok())
                 .collect();
 
             for assoc in cx
diff --git a/src/tools/clippy/clippy_utils/src/lib.rs b/src/tools/clippy/clippy_utils/src/lib.rs
index b806e3d8b1bf5..de45d65816628 100644
--- a/src/tools/clippy/clippy_utils/src/lib.rs
+++ b/src/tools/clippy/clippy_utils/src/lib.rs
@@ -3251,7 +3251,7 @@ pub fn get_path_from_caller_to_method_type<'tcx>(
     let def_id = assoc_item.container_id(tcx);
     match assoc_item.container {
         rustc_ty::AssocContainer::Trait => get_path_to_callee(tcx, from, def_id),
-        rustc_ty::AssocContainer::Impl => {
+        rustc_ty::AssocContainer::InherentImpl | rustc_ty::AssocContainer::TraitImpl(_) => {
             let ty = tcx.type_of(def_id).instantiate_identity();
             get_path_to_ty(tcx, from, ty, args)
         },
diff --git a/tests/ui/const-generics/generic_const_exprs/post-analysis-user-facing-param-env.rs b/tests/ui/const-generics/generic_const_exprs/post-analysis-user-facing-param-env.rs
index 478fa3706e8e2..9af351ec59f06 100644
--- a/tests/ui/const-generics/generic_const_exprs/post-analysis-user-facing-param-env.rs
+++ b/tests/ui/const-generics/generic_const_exprs/post-analysis-user-facing-param-env.rs
@@ -11,7 +11,6 @@ where
 {
     fn unimplemented(self, _: &Foo) -> Self::Output {
         //~^ ERROR method `unimplemented` is not a member of trait `std::ops::Add`
-        //~| ERROR type annotations needed
         loop {}
     }
 }
diff --git a/tests/ui/const-generics/generic_const_exprs/post-analysis-user-facing-param-env.stderr b/tests/ui/const-generics/generic_const_exprs/post-analysis-user-facing-param-env.stderr
index 29bbd23a46990..37eb895f9a8d9 100644
--- a/tests/ui/const-generics/generic_const_exprs/post-analysis-user-facing-param-env.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/post-analysis-user-facing-param-env.stderr
@@ -3,7 +3,6 @@ error[E0407]: method `unimplemented` is not a member of trait `std::ops::Add`
    |
 LL | /     fn unimplemented(self, _: &Foo) -> Self::Output {
 LL | |
-LL | |
 LL | |         loop {}
 LL | |     }
    | |_____^ not a member of trait `std::ops::Add`
@@ -39,21 +38,7 @@ LL | impl<'a, const NUM: usize> std::ops::Add<&'a Foo> for Foo
    = note: expressions using a const parameter must map each value to a distinct output value
    = note: proving the result of expressions other than the parameter are unique is not supported
 
-error[E0284]: type annotations needed
-  --> $DIR/post-analysis-user-facing-param-env.rs:12:40
-   |
-LL |     fn unimplemented(self, _: &Foo) -> Self::Output {
-   |                                        ^^^^^^^^^^^^ cannot infer the value of const parameter `NUM`
-   |
-note: required for `Foo` to implement `Add<&'a Foo>`
-  --> $DIR/post-analysis-user-facing-param-env.rs:6:28
-   |
-LL | impl<'a, const NUM: usize> std::ops::Add<&'a Foo> for Foo
-   |          ----------------  ^^^^^^^^^^^^^^^^^^^^^^     ^^^
-   |          |
-   |          unsatisfied trait bound introduced here
-
-error: aborting due to 4 previous errors; 1 warning emitted
+error: aborting due to 3 previous errors; 1 warning emitted
 
-Some errors have detailed explanations: E0046, E0207, E0284, E0407.
+Some errors have detailed explanations: E0046, E0207, E0407.
 For more information about an error, try `rustc --explain E0046`.

From 324c2141227b3e7d40b1250126396637bb7c530e Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 13 Aug 2025 15:24:19 -0500
Subject: [PATCH 0876/1889] Split AssocContainer::{InherentImpl,TraitImpl}

---
 clippy_lints/src/missing_doc.rs           | 11 +++++------
 clippy_lints/src/missing_inline.rs        |  3 ++-
 clippy_lints/src/missing_trait_methods.rs |  2 +-
 clippy_utils/src/lib.rs                   |  2 +-
 4 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs
index 7772051eb5c61..39b5964bd87b1 100644
--- a/clippy_lints/src/missing_doc.rs
+++ b/clippy_lints/src/missing_doc.rs
@@ -16,7 +16,7 @@ use rustc_hir::Attribute;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::LocalDefId;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::ty::Visibility;
+use rustc_middle::ty::{AssocContainer, Visibility};
 use rustc_session::impl_lint_pass;
 use rustc_span::def_id::CRATE_DEF_ID;
 use rustc_span::symbol::kw;
@@ -246,12 +246,11 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
 
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx hir::ImplItem<'_>) {
         // If the method is an impl for a trait, don't doc.
-        if let Some(cid) = cx.tcx.associated_item(impl_item.owner_id).impl_container(cx.tcx) {
-            if cx.tcx.impl_trait_ref(cid).is_some() {
+        match cx.tcx.associated_item(impl_item.owner_id).container {
+            AssocContainer::Trait | AssocContainer::TraitImpl(_) => {
                 note_prev_span_then_ret!(self.prev_span, impl_item.span);
-            }
-        } else {
-            note_prev_span_then_ret!(self.prev_span, impl_item.span);
+            },
+            AssocContainer::InherentImpl => {}
         }
 
         let (article, desc) = cx.tcx.article_and_description(impl_item.owner_id.to_def_id());
diff --git a/clippy_lints/src/missing_inline.rs b/clippy_lints/src/missing_inline.rs
index 490a59ca66d3e..6323e728666ce 100644
--- a/clippy_lints/src/missing_inline.rs
+++ b/clippy_lints/src/missing_inline.rs
@@ -167,7 +167,8 @@ impl<'tcx> LateLintPass<'tcx> for MissingInline {
         let container_id = assoc_item.container_id(cx.tcx);
         let trait_def_id = match assoc_item.container {
             AssocContainer::Trait => Some(container_id),
-            AssocContainer::Impl => cx.tcx.impl_trait_ref(container_id).map(|t| t.skip_binder().def_id),
+            AssocContainer::TraitImpl(_) => cx.tcx.impl_trait_ref(container_id).map(|t| t.skip_binder().def_id),
+            AssocContainer::InherentImpl => None,
         };
 
         if let Some(trait_def_id) = trait_def_id
diff --git a/clippy_lints/src/missing_trait_methods.rs b/clippy_lints/src/missing_trait_methods.rs
index 9cc93bf06531a..8e9400e9d583d 100644
--- a/clippy_lints/src/missing_trait_methods.rs
+++ b/clippy_lints/src/missing_trait_methods.rs
@@ -70,7 +70,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingTraitMethods {
                 .tcx
                 .associated_items(item.owner_id)
                 .in_definition_order()
-                .filter_map(|assoc_item| assoc_item.trait_item_def_id)
+                .filter_map(|assoc_item| assoc_item.expect_trait_impl().ok())
                 .collect();
 
             for assoc in cx
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index b806e3d8b1bf5..de45d65816628 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -3251,7 +3251,7 @@ pub fn get_path_from_caller_to_method_type<'tcx>(
     let def_id = assoc_item.container_id(tcx);
     match assoc_item.container {
         rustc_ty::AssocContainer::Trait => get_path_to_callee(tcx, from, def_id),
-        rustc_ty::AssocContainer::Impl => {
+        rustc_ty::AssocContainer::InherentImpl | rustc_ty::AssocContainer::TraitImpl(_) => {
             let ty = tcx.type_of(def_id).instantiate_identity();
             get_path_to_ty(tcx, from, ty, args)
         },

From b995a55cafcbcafec51aba6c567b32161fa9c2f1 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 13 Aug 2025 14:36:13 -0500
Subject: [PATCH 0877/1889] Don't store defaultness for inherent impl items

---
 compiler/rustc_metadata/src/rmeta/encoder.rs     | 5 ++++-
 compiler/rustc_middle/src/query/mod.rs           | 1 +
 compiler/rustc_middle/src/ty/assoc.rs            | 5 ++++-
 compiler/rustc_ty_utils/src/ty.rs                | 4 ----
 src/librustdoc/clean/mod.rs                      | 5 ++++-
 src/librustdoc/passes/collect_intra_doc_links.rs | 2 +-
 6 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
index cb603705ce143..db66938457f09 100644
--- a/compiler/rustc_metadata/src/rmeta/encoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -1725,7 +1725,10 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         let tcx = self.tcx;
         let item = tcx.associated_item(def_id);
 
-        self.tables.defaultness.set_some(def_id.index, item.defaultness(tcx));
+        if matches!(item.container, AssocContainer::Trait | AssocContainer::TraitImpl(_)) {
+            self.tables.defaultness.set_some(def_id.index, item.defaultness(tcx));
+        }
+
         record!(self.tables.assoc_container[def_id] <- item.container);
 
         if let AssocContainer::Trait = item.container
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 2aa32dfa0d825..0e645a3aae45b 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -1881,6 +1881,7 @@ rustc_queries! {
     }
 
     /// Returns whether the impl or associated function has the `default` keyword.
+    /// Note: This will ICE on inherent impl items. Consider using `AssocItem::defaultness`.
     query defaultness(def_id: DefId) -> hir::Defaultness {
         desc { |tcx| "looking up whether `{}` has `default`", tcx.def_path_str(def_id) }
         separate_provide_extern
diff --git a/compiler/rustc_middle/src/ty/assoc.rs b/compiler/rustc_middle/src/ty/assoc.rs
index 60181783f9b18..768646c763029 100644
--- a/compiler/rustc_middle/src/ty/assoc.rs
+++ b/compiler/rustc_middle/src/ty/assoc.rs
@@ -53,7 +53,10 @@ impl AssocItem {
     ///
     /// [`type_of`]: crate::ty::TyCtxt::type_of
     pub fn defaultness(&self, tcx: TyCtxt<'_>) -> hir::Defaultness {
-        tcx.defaultness(self.def_id)
+        match self.container {
+            AssocContainer::InherentImpl => hir::Defaultness::Final,
+            AssocContainer::Trait | AssocContainer::TraitImpl(_) => tcx.defaultness(self.def_id),
+        }
     }
 
     pub fn expect_trait_impl(&self) -> Result<DefId, ErrorGuaranteed> {
diff --git a/compiler/rustc_ty_utils/src/ty.rs b/compiler/rustc_ty_utils/src/ty.rs
index b3f2bb6d4b5a3..a5987757dc34d 100644
--- a/compiler/rustc_ty_utils/src/ty.rs
+++ b/compiler/rustc_ty_utils/src/ty.rs
@@ -93,10 +93,6 @@ fn defaultness(tcx: TyCtxt<'_>, def_id: LocalDefId) -> hir::Defaultness {
             ..
         })
         | hir::Node::TraitItem(hir::TraitItem { defaultness, .. }) => *defaultness,
-        hir::Node::ImplItem(hir::ImplItem {
-            impl_kind: hir::ImplItemImplKind::Inherent { .. },
-            ..
-        }) => hir::Defaultness::Final,
         node => {
             bug!("`defaultness` called on {:?}", node);
         }
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 8c40e42562cf6..5ccacafea0158 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -1256,7 +1256,10 @@ pub(crate) fn clean_impl_item<'tcx>(
             })),
             hir::ImplItemKind::Fn(ref sig, body) => {
                 let m = clean_function(cx, sig, impl_.generics, ParamsSrc::Body(body));
-                let defaultness = cx.tcx.defaultness(impl_.owner_id);
+                let defaultness = match impl_.impl_kind {
+                    hir::ImplItemImplKind::Inherent { .. } => hir::Defaultness::Final,
+                    hir::ImplItemImplKind::Trait { defaultness, .. } => defaultness,
+                };
                 MethodItem(m, Some(defaultness))
             }
             hir::ImplItemKind::Type(hir_ty) => {
diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs
index 719b7c6ab89c4..0da42f38251cc 100644
--- a/src/librustdoc/passes/collect_intra_doc_links.rs
+++ b/src/librustdoc/passes/collect_intra_doc_links.rs
@@ -210,7 +210,7 @@ impl UrlFragment {
             &UrlFragment::Item(def_id) => {
                 let kind = match tcx.def_kind(def_id) {
                     DefKind::AssocFn => {
-                        if tcx.defaultness(def_id).has_value() {
+                        if tcx.associated_item(def_id).defaultness(tcx).has_value() {
                             "method."
                         } else {
                             "tymethod."

From 277e845162299d533ce64a2a6dfa540d4f36fb30 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Fri, 12 Sep 2025 11:36:38 -0700
Subject: [PATCH 0878/1889] rustdoc-search: delay loading type name IDs until
 type search

This avoids blocking on these lookups, so name-based searches
return results more quickly.
---
 src/librustdoc/html/static/js/rustdoc.d.ts |  25 +-
 src/librustdoc/html/static/js/search.js    | 296 +++++++++++++++------
 src/librustdoc/html/static/js/stringdex.js |   2 +-
 3 files changed, 233 insertions(+), 90 deletions(-)

diff --git a/src/librustdoc/html/static/js/rustdoc.d.ts b/src/librustdoc/html/static/js/rustdoc.d.ts
index 938ccc7d2c32e..951eb2291b89e 100644
--- a/src/librustdoc/html/static/js/rustdoc.d.ts
+++ b/src/librustdoc/html/static/js/rustdoc.d.ts
@@ -348,7 +348,7 @@ declare namespace rustdoc {
         returned: rustdoc.QueryElement[],
         is_alias: boolean,
         alias?: string,
-        original?: rustdoc.Rlow,
+        item: rustdoc.Row,
     }
 
     /**
@@ -533,4 +533,27 @@ declare namespace rustdoc {
      * Generated by `render_call_locations` in `render/mod.rs`.
      */
     type ScrapedLoc = [[number, number], string, string]
+
+    /**
+     * Each of these identifiers are used specially by
+     * type-driven search. Most of them are lang items
+     * in the compiler.
+     */
+    type TypeNameIds = {
+        "typeNameIdOfOutput": number,
+        "typeNameIdOfFnPtr": number,
+        "typeNameIdOfFn": number,
+        "typeNameIdOfFnMut": number,
+        "typeNameIdOfFnOnce": number,
+        "typeNameIdOfArray": number,
+        "typeNameIdOfSlice": number,
+        "typeNameIdOfArrayOrSlice": number,
+        "typeNameIdOfTuple": number,
+        "typeNameIdOfUnit": number,
+        "typeNameIdOfTupleOrUnit": number,
+        "typeNameIdOfReference": number,
+        "typeNameIdOfPointer": number,
+        "typeNameIdOfHof": number,
+        "typeNameIdOfNever": number,
+    };
 }
diff --git a/src/librustdoc/html/static/js/search.js b/src/librustdoc/html/static/js/search.js
index 339b101d47111..482134933a61e 100644
--- a/src/librustdoc/html/static/js/search.js
+++ b/src/librustdoc/html/static/js/search.js
@@ -1190,17 +1190,6 @@ class DocSearch {
         this.rootPath = rootPath;
         this.database = database;
 
-        this.typeNameIdOfOutput = -1;
-        this.typeNameIdOfArray = -1;
-        this.typeNameIdOfSlice = -1;
-        this.typeNameIdOfArrayOrSlice = -1;
-        this.typeNameIdOfTuple = -1;
-        this.typeNameIdOfUnit = -1;
-        this.typeNameIdOfTupleOrUnit = -1;
-        this.typeNameIdOfReference = -1;
-        this.typeNameIdOfPointer = -1;
-        this.typeNameIdOfHof = -1;
-
         this.utf8decoder = new TextDecoder();
 
         /** @type {Map<number|null, rustdoc.FunctionType>} */
@@ -1208,14 +1197,49 @@ class DocSearch {
     }
 
     /**
-     * Load search index. If you do not call this function, `execQuery`
-     * will never fulfill.
+     * Load type name ID set.
+     *
+     * Each of these identifiers are used specially by
+     * type-driven search. Most of them are lang items
+     * in the compiler.
+     *
+     * Use this function, which caches the result, and not
+     * getTypeNameIdsAsync, which is an internal implementation
+     * detail for this.
+     *
+     * @return {Promise<rustdoc.TypeNameIds>|rustdoc.TypeNameIds}
      */
-    async buildIndex() {
+    getTypeNameIds() {
+        if (this.typeNameIds) {
+            return this.typeNameIds;
+        }
         const nn = this.database.getData("normalizedName");
         if (!nn) {
-            return;
+            return {
+                typeNameIdOfOutput: -1,
+                typeNameIdOfFnPtr: -1,
+                typeNameIdOfFn: -1,
+                typeNameIdOfFnMut: -1,
+                typeNameIdOfFnOnce: -1,
+                typeNameIdOfArray: -1,
+                typeNameIdOfSlice: -1,
+                typeNameIdOfArrayOrSlice: -1,
+                typeNameIdOfTuple: -1,
+                typeNameIdOfUnit: -1,
+                typeNameIdOfTupleOrUnit: -1,
+                typeNameIdOfReference: -1,
+                typeNameIdOfPointer: -1,
+                typeNameIdOfHof: -1,
+                typeNameIdOfNever: -1,
+            };
         }
+        return this.getTypeNameIdsAsync(nn);
+    }
+    /**
+     * @param {stringdex.DataColumn} nn
+     * @returns {Promise<rustdoc.TypeNameIds>}
+     */
+    async getTypeNameIdsAsync(nn) {
         // Each of these identifiers are used specially by
         // type-driven search.
         const [
@@ -1274,21 +1298,39 @@ class DocSearch {
             }
             return -1;
         };
-        this.typeNameIdOfOutput = await first(output, TY_ASSOCTYPE, "");
-        this.typeNameIdOfFnPtr = await first(fn, TY_PRIMITIVE, "");
-        this.typeNameIdOfFn = await first(fn, TY_TRAIT, "core::ops");
-        this.typeNameIdOfFnMut = await first(fnMut, TY_TRAIT, "core::ops");
-        this.typeNameIdOfFnOnce = await first(fnOnce, TY_TRAIT, "core::ops");
-        this.typeNameIdOfArray = await first(array, TY_PRIMITIVE, "");
-        this.typeNameIdOfSlice = await first(slice, TY_PRIMITIVE, "");
-        this.typeNameIdOfArrayOrSlice = await first(arrayOrSlice, TY_PRIMITIVE, "");
-        this.typeNameIdOfTuple = await first(tuple, TY_PRIMITIVE, "");
-        this.typeNameIdOfUnit = await first(unit, TY_PRIMITIVE, "");
-        this.typeNameIdOfTupleOrUnit = await first(tupleOrUnit, TY_PRIMITIVE, "");
-        this.typeNameIdOfReference = await first(reference, TY_PRIMITIVE, "");
-        this.typeNameIdOfPointer = await first(pointer, TY_PRIMITIVE, "");
-        this.typeNameIdOfHof = await first(hof, TY_PRIMITIVE, "");
-        this.typeNameIdOfNever = await first(never, TY_PRIMITIVE, "");
+        const typeNameIdOfOutput = await first(output, TY_ASSOCTYPE, "");
+        const typeNameIdOfFnPtr = await first(fn, TY_PRIMITIVE, "");
+        const typeNameIdOfFn = await first(fn, TY_TRAIT, "core::ops");
+        const typeNameIdOfFnMut = await first(fnMut, TY_TRAIT, "core::ops");
+        const typeNameIdOfFnOnce = await first(fnOnce, TY_TRAIT, "core::ops");
+        const typeNameIdOfArray = await first(array, TY_PRIMITIVE, "");
+        const typeNameIdOfSlice = await first(slice, TY_PRIMITIVE, "");
+        const typeNameIdOfArrayOrSlice = await first(arrayOrSlice, TY_PRIMITIVE, "");
+        const typeNameIdOfTuple = await first(tuple, TY_PRIMITIVE, "");
+        const typeNameIdOfUnit = await first(unit, TY_PRIMITIVE, "");
+        const typeNameIdOfTupleOrUnit = await first(tupleOrUnit, TY_PRIMITIVE, "");
+        const typeNameIdOfReference = await first(reference, TY_PRIMITIVE, "");
+        const typeNameIdOfPointer = await first(pointer, TY_PRIMITIVE, "");
+        const typeNameIdOfHof = await first(hof, TY_PRIMITIVE, "");
+        const typeNameIdOfNever = await first(never, TY_PRIMITIVE, "");
+        this.typeNameIds = {
+            typeNameIdOfOutput,
+            typeNameIdOfFnPtr,
+            typeNameIdOfFn,
+            typeNameIdOfFnMut,
+            typeNameIdOfFnOnce,
+            typeNameIdOfArray,
+            typeNameIdOfSlice,
+            typeNameIdOfArrayOrSlice,
+            typeNameIdOfTuple,
+            typeNameIdOfUnit,
+            typeNameIdOfTupleOrUnit,
+            typeNameIdOfReference,
+            typeNameIdOfPointer,
+            typeNameIdOfHof,
+            typeNameIdOfNever,
+        };
+        return this.typeNameIds;
     }
 
     /**
@@ -1816,6 +1858,9 @@ class DocSearch {
             modulePathData,
             exactModuleName,
             exactModulePathData,
+            parentName,
+            parentPath,
+            crate,
         ] = await Promise.all([
             entry && entry.modulePath !== null ? this.getName(entry.modulePath) : null,
             entry && entry.modulePath !== null ? this.getPathData(entry.modulePath) : null,
@@ -1825,6 +1870,13 @@ class DocSearch {
             entry && entry.exactModulePath !== null ?
                 this.getPathData(entry.exactModulePath) :
                 null,
+            entry && entry.parent !== null ?
+                this.getName(entry.parent) :
+                null,
+            entry && entry.parent !== null ?
+                this.getPathData(entry.parent) :
+                null,
+            entry ? nonnull(await this.getName(entry.krate)) : "",
         ]);
         const name = name_ === null ? "" : name_;
         const normalizedName = (name.indexOf("_") === -1 ?
@@ -1834,12 +1886,9 @@ class DocSearch {
             (modulePathData.modulePath === "" ?
                 moduleName :
                 `${modulePathData.modulePath}::${moduleName}`);
-        const [parentName, parentPath] = entry !== null && entry.parent !== null ?
-            await Promise.all([this.getName(entry.parent), this.getPathData(entry.parent)]) :
-            [null, null];
         return {
             id,
-            crate: entry ? nonnull(await this.getName(entry.krate)) : "",
+            crate,
             ty: entry ? entry.ty : nonnull(path).ty,
             name,
             normalizedName,
@@ -2144,6 +2193,7 @@ class DocSearch {
          * @returns {Promise<rustdoc.DisplayTypeSignature>}
          */
         const formatDisplayTypeSignature = async(obj, typeInfo, elems, returned) => {
+            const typeNameIds = await this.getTypeNameIds();
             const objType = obj.type;
             if (!objType) {
                 return {type: [], mappedNames: new Map(), whereClause: new Map()};
@@ -2169,10 +2219,12 @@ class DocSearch {
                                 return true;
                             },
                             0,
+                            typeNameIds,
                         );
                         return !!fnOutput;
                     },
                     0,
+                    typeNameIds,
                 );
             } else {
                 const highlighted = unifyFunctionTypes(
@@ -2185,6 +2237,7 @@ class DocSearch {
                         return true;
                     },
                     0,
+                    typeNameIds,
                 );
                 if (typeInfo === "elems") {
                     fnInputs = highlighted;
@@ -2264,7 +2317,7 @@ class DocSearch {
              * @returns {Promise<void>}
              */
             const writeHof = async(fnType, result) => {
-                const hofOutput = fnType.bindings.get(this.typeNameIdOfOutput) || [];
+                const hofOutput = fnType.bindings.get(typeNameIds.typeNameIdOfOutput) || [];
                 const hofInputs = fnType.generics;
                 pushText(fnType, result);
                 pushText({name: " (", highlighted: false}, result);
@@ -2305,11 +2358,14 @@ class DocSearch {
              * @returns {Promise<boolean>}
              */
             const writeSpecialPrimitive = async(fnType, result) => {
-                if (fnType.id === this.typeNameIdOfArray || fnType.id === this.typeNameIdOfSlice ||
-                    fnType.id === this.typeNameIdOfTuple || fnType.id === this.typeNameIdOfUnit) {
+                if (fnType.id === typeNameIds.typeNameIdOfArray ||
+                    fnType.id === typeNameIds.typeNameIdOfSlice ||
+                    fnType.id === typeNameIds.typeNameIdOfTuple ||
+                    fnType.id === typeNameIds.typeNameIdOfUnit
+                ) {
                     const [ob, sb] =
-                        fnType.id === this.typeNameIdOfArray ||
-                            fnType.id === this.typeNameIdOfSlice ?
+                        fnType.id === typeNameIds.typeNameIdOfArray ||
+                            fnType.id === typeNameIds.typeNameIdOfSlice ?
                         ["[", "]"] :
                         ["(", ")"];
                     pushText({ name: ob, highlighted: fnType.highlighted }, result);
@@ -2321,7 +2377,7 @@ class DocSearch {
                     );
                     pushText({ name: sb, highlighted: fnType.highlighted }, result);
                     return true;
-                } else if (fnType.id === this.typeNameIdOfReference) {
+                } else if (fnType.id === typeNameIds.typeNameIdOfReference) {
                     pushText({ name: "&", highlighted: fnType.highlighted }, result);
                     let prevHighlighted = false;
                     await onEachBtwnAsync(
@@ -2337,7 +2393,7 @@ class DocSearch {
                         }, result),
                     );
                     return true;
-                } else if (fnType.id === this.typeNameIdOfPointer) {
+                } else if (fnType.id === typeNameIds.typeNameIdOfPointer) {
                     pushText({ name: "*", highlighted: fnType.highlighted }, result);
                     if (fnType.generics.length < 2) {
                         pushText({ name: "const ", highlighted: fnType.highlighted }, result);
@@ -2357,14 +2413,14 @@ class DocSearch {
                     );
                     return true;
                 } else if (
-                    fnType.id === this.typeNameIdOfFn ||
-                    fnType.id === this.typeNameIdOfFnMut ||
-                    fnType.id === this.typeNameIdOfFnOnce ||
-                    fnType.id === this.typeNameIdOfFnPtr
+                    fnType.id === typeNameIds.typeNameIdOfFn ||
+                    fnType.id === typeNameIds.typeNameIdOfFnMut ||
+                    fnType.id === typeNameIds.typeNameIdOfFnOnce ||
+                    fnType.id === typeNameIds.typeNameIdOfFnPtr
                 ) {
                     await writeHof(fnType, result);
                     return true;
-                } else if (fnType.id === this.typeNameIdOfNever) {
+                } else if (fnType.id === typeNameIds.typeNameIdOfNever) {
                     pushText({ name: "!", highlighted: fnType.highlighted }, result);
                     return true;
                 }
@@ -2422,10 +2478,10 @@ class DocSearch {
                             return;
                         }
                     } else if (fnType.ty === TY_TRAIT && (
-                        fnType.id === this.typeNameIdOfFn ||
-                        fnType.id === this.typeNameIdOfFnMut ||
-                        fnType.id === this.typeNameIdOfFnOnce ||
-                        fnType.id === this.typeNameIdOfFnPtr
+                        fnType.id === typeNameIds.typeNameIdOfFn ||
+                        fnType.id === typeNameIds.typeNameIdOfFnMut ||
+                        fnType.id === typeNameIds.typeNameIdOfFnOnce ||
+                        fnType.id === typeNameIds.typeNameIdOfFnPtr
                     )) {
                         await writeHof(fnType, result);
                         return;
@@ -2536,7 +2592,7 @@ class DocSearch {
          * Add extra data to result objects, and filter items that have been
          * marked for removal.
          *
-         * @param {[rustdoc.PlainResultObject, rustdoc.Row][]} results
+         * @param {rustdoc.PlainResultObject[]} results
          * @param {"sig"|"elems"|"returned"|null} typeInfo
          * @param {Set<string>} duplicates
          * @returns {rustdoc.ResultObject[]}
@@ -2544,7 +2600,8 @@ class DocSearch {
         const transformResults = (results, typeInfo, duplicates) => {
             const out = [];
 
-            for (const [result, item] of results) {
+            for (const result of results) {
+                const item = result.item;
                 if (item.id !== -1) {
                     const res = buildHrefAndPath(item);
                     // many of these properties don't strictly need to be
@@ -2629,7 +2686,7 @@ class DocSearch {
                 const normalizedUserQuery = parsedQuery.userQuery.toLowerCase();
                 const isMixedCase = normalizedUserQuery !== userQuery;
                 /**
-                 * @type {[rustdoc.PlainResultObject, rustdoc.Row][]}
+                 * @type {rustdoc.PlainResultObject[]}
                  */
                 const result_list = [];
                 for (const result of results.values()) {
@@ -2637,23 +2694,22 @@ class DocSearch {
                         continue;
                     }
                     /**
-                     * @type {rustdoc.Row?}
+                     * @type {rustdoc.Row}
                      */
-                    const item = await this.getRow(result.id, typeInfo !== null);
-                    if (!item) {
-                        continue;
-                    }
+                    const item = result.item;
                     if (filterCrates !== null && item.crate !== filterCrates) {
                         continue;
                     }
                     if (item) {
-                        result_list.push([result, item]);
+                        result_list.push(result);
                     } else {
                         continue;
                     }
                 }
 
-                result_list.sort(([aaa, aai], [bbb, bbi]) => {
+                result_list.sort((aaa, bbb) => {
+                    const aai = aaa.item;
+                    const bbi = bbb.item;
                     /** @type {number} */
                     let a;
                     /** @type {number} */
@@ -2800,6 +2856,7 @@ class DocSearch {
          * @param {number} unboxingDepth
          *     - Limit checks that Ty matches Vec<Ty>,
          *       but not Vec<ParamEnvAnd<WithInfcx<ConstTy<Interner<Ty=Ty>>>>>
+         * @param {rustdoc.TypeNameIds} typeNameIds
          *
          * @return {rustdoc.HighlightedFunctionType[]|null}
          *     - Returns highlighted results if a match, null otherwise.
@@ -2811,6 +2868,7 @@ class DocSearch {
             mgensIn,
             solutionCb,
             unboxingDepth,
+            typeNameIds,
         ) {
             if (unboxingDepth >= UNBOXING_LIMIT) {
                 return null;
@@ -2833,7 +2891,12 @@ class DocSearch {
                 && queryElems[0].bindings.size === 0) {
                 const queryElem = queryElems[0];
                 for (const [i, fnType] of fnTypesIn.entries()) {
-                    if (!unifyFunctionTypeIsMatchCandidate(fnType, queryElem, mgens)) {
+                    if (!unifyFunctionTypeIsMatchCandidate(
+                        fnType,
+                        queryElem,
+                        mgens,
+                        typeNameIds,
+                    )) {
                         continue;
                     }
                     if (fnType.id !== null &&
@@ -2869,6 +2932,7 @@ class DocSearch {
                                 mgens ? new Map(mgens) : null,
                                 solutionCb,
                                 unboxingDepth,
+                                typeNameIds,
                             ) || fnType.generics,
                         });
                         return highlighted;
@@ -2881,6 +2945,7 @@ class DocSearch {
                         whereClause,
                         mgens,
                         unboxingDepth + 1,
+                        typeNameIds,
                     )) {
                         continue;
                     }
@@ -2894,6 +2959,7 @@ class DocSearch {
                             mgens,
                             solutionCb,
                             unboxingDepth + 1,
+                            typeNameIds,
                         );
                         if (highlightedGenerics) {
                             const highlighted = [...fnTypesIn];
@@ -2912,6 +2978,7 @@ class DocSearch {
                             mgens ? new Map(mgens) : null,
                             solutionCb,
                             unboxingDepth + 1,
+                            typeNameIds,
                         );
                         if (highlightedGenerics) {
                             const highlighted = [...fnTypesIn];
@@ -2956,7 +3023,12 @@ class DocSearch {
             let queryElemsTmp = null;
             for (let i = flast; i >= 0; i -= 1) {
                 const fnType = fnTypes[i];
-                if (!unifyFunctionTypeIsMatchCandidate(fnType, queryElem, mgens)) {
+                if (!unifyFunctionTypeIsMatchCandidate(
+                    fnType,
+                    queryElem,
+                    mgens,
+                    typeNameIds,
+                )) {
                     continue;
                 }
                 let mgensScratch;
@@ -3000,6 +3072,7 @@ class DocSearch {
                             whereClause,
                             mgensScratch,
                             unboxingDepth,
+                            typeNameIds,
                         );
                         if (!solution) {
                             return false;
@@ -3013,6 +3086,7 @@ class DocSearch {
                                 simplifiedMgens,
                                 solutionCb,
                                 unboxingDepth,
+                                typeNameIds,
                             );
                             if (unifiedGenerics !== null) {
                                 unifiedGenericsMgens = simplifiedMgens;
@@ -3022,6 +3096,7 @@ class DocSearch {
                         return false;
                     },
                     unboxingDepth,
+                    typeNameIds,
                 );
                 if (passesUnification) {
                     passesUnification.length = fl;
@@ -3038,6 +3113,7 @@ class DocSearch {
                                 unifiedGenericsMgens,
                                 solutionCb,
                                 unboxingDepth,
+                                typeNameIds,
                             // @ts-expect-error
                             ) : unifiedGenerics.splice(0, v.length)];
                         })),
@@ -3057,6 +3133,7 @@ class DocSearch {
                     whereClause,
                     mgens,
                     unboxingDepth + 1,
+                    typeNameIds,
                 )) {
                     continue;
                 }
@@ -3073,6 +3150,7 @@ class DocSearch {
                     mgens,
                     solutionCb,
                     unboxingDepth + 1,
+                    typeNameIds,
                 );
                 if (passesUnification) {
                     const highlightedGenerics = passesUnification.slice(
@@ -3113,6 +3191,7 @@ class DocSearch {
          * @param {number} unboxingDepth
          *     - Limit checks that Ty matches Vec<Ty>,
          *       but not Vec<ParamEnvAnd<WithInfcx<ConstTy<Interner<Ty=Ty>>>>>
+         * @param {rustdoc.TypeNameIds} typeNameIds
          *
          * @return {rustdoc.HighlightedFunctionType[]|null}
          *     - Returns highlighted results if a match, null otherwise.
@@ -3124,6 +3203,7 @@ class DocSearch {
             mgensIn,
             solutionCb,
             unboxingDepth,
+            typeNameIds,
         ) {
             if (unboxingDepth >= UNBOXING_LIMIT) {
                 return null;
@@ -3141,7 +3221,12 @@ class DocSearch {
             }
             const fnType = fnTypesIn[0];
             const queryElem = queryElems[0];
-            if (unifyFunctionTypeIsMatchCandidate(fnType, queryElem, mgens)) {
+            if (unifyFunctionTypeIsMatchCandidate(
+                fnType,
+                queryElem,
+                mgens,
+                typeNameIds,
+            )) {
                 if (fnType.id !== null &&
                     fnType.id < 0 &&
                     queryElem.id !== null &&
@@ -3159,6 +3244,7 @@ class DocSearch {
                             mgensScratch,
                             solutionCb,
                             unboxingDepth,
+                            typeNameIds,
                         );
                         if (fnTypesRemaining) {
                             const highlighted = [fnType, ...fnTypesRemaining];
@@ -3185,6 +3271,7 @@ class DocSearch {
                                 whereClause,
                                 mgensScratch,
                                 unboxingDepth,
+                                typeNameIds,
                             );
                             if (!solution) {
                                 return false;
@@ -3198,6 +3285,7 @@ class DocSearch {
                                     simplifiedMgens,
                                     solutionCb,
                                     unboxingDepth,
+                                    typeNameIds,
                                 );
                                 if (unifiedGenerics !== null) {
                                     return true;
@@ -3205,6 +3293,7 @@ class DocSearch {
                             }
                         },
                         unboxingDepth,
+                        typeNameIds,
                     );
                     if (fnTypesRemaining) {
                         const highlighted = [fnType, ...fnTypesRemaining];
@@ -3223,6 +3312,7 @@ class DocSearch {
                 whereClause,
                 mgens,
                 unboxingDepth + 1,
+                typeNameIds,
             )) {
                 let highlightedRemaining;
                 if (fnType.id !== null && fnType.id < 0) {
@@ -3244,6 +3334,7 @@ class DocSearch {
                                 mgensScratch,
                                 solutionCb,
                                 unboxingDepth,
+                                typeNameIds,
                             );
                             if (hl) {
                                 highlightedRemaining = hl;
@@ -3251,6 +3342,7 @@ class DocSearch {
                             return hl;
                         },
                         unboxingDepth + 1,
+                        typeNameIds,
                     );
                     if (highlightedGenerics) {
                         return [Object.assign({
@@ -3278,6 +3370,7 @@ class DocSearch {
                                 mgensScratch,
                                 solutionCb,
                                 unboxingDepth,
+                                typeNameIds,
                             );
                             if (hl) {
                                 highlightedRemaining = hl;
@@ -3285,6 +3378,7 @@ class DocSearch {
                             return hl;
                         },
                         unboxingDepth + 1,
+                        typeNameIds,
                     );
                     if (highlightedGenerics) {
                         return [Object.assign({}, fnType, {
@@ -3310,10 +3404,11 @@ class DocSearch {
          *
          * @param {rustdoc.FunctionType} fnType
          * @param {rustdoc.QueryElement} queryElem
+         * @param {rustdoc.TypeNameIds} typeNameIds
          * @param {Map<number,number>|null} mgensIn - Map query generics to function generics.
          * @returns {boolean}
          */
-        const unifyFunctionTypeIsMatchCandidate = (fnType, queryElem, mgensIn) => {
+        const unifyFunctionTypeIsMatchCandidate = (fnType, queryElem, mgensIn, typeNameIds) => {
             // type filters look like `trait:Read` or `enum:Result`
             if (!typePassesFilter(queryElem.typeFilter, fnType.ty)) {
                 return false;
@@ -3332,21 +3427,23 @@ class DocSearch {
             } else {
                 // For these special cases, matching code need added to the inverted index.
                 // search_index.rs -> convert_render_type does this
-                if (queryElem.id === this.typeNameIdOfArrayOrSlice &&
-                    (fnType.id === this.typeNameIdOfSlice || fnType.id === this.typeNameIdOfArray)
+                if (queryElem.id === typeNameIds.typeNameIdOfArrayOrSlice &&
+                    (fnType.id === typeNameIds.typeNameIdOfSlice ||
+                        fnType.id === typeNameIds.typeNameIdOfArray)
                 ) {
                     // [] matches primitive:array or primitive:slice
                     // if it matches, then we're fine, and this is an appropriate match candidate
-                } else if (queryElem.id === this.typeNameIdOfTupleOrUnit &&
-                    (fnType.id === this.typeNameIdOfTuple || fnType.id === this.typeNameIdOfUnit)
+                } else if (queryElem.id === typeNameIds.typeNameIdOfTupleOrUnit &&
+                    (fnType.id === typeNameIds.typeNameIdOfTuple ||
+                        fnType.id === typeNameIds.typeNameIdOfUnit)
                 ) {
                     // () matches primitive:tuple or primitive:unit
                     // if it matches, then we're fine, and this is an appropriate match candidate
-                } else if (queryElem.id === this.typeNameIdOfHof && (
-                    fnType.id === this.typeNameIdOfFn ||
-                    fnType.id === this.typeNameIdOfFnMut ||
-                    fnType.id === this.typeNameIdOfFnOnce ||
-                    fnType.id === this.typeNameIdOfFnPtr
+                } else if (queryElem.id === typeNameIds.typeNameIdOfHof && (
+                    fnType.id === typeNameIds.typeNameIdOfFn ||
+                    fnType.id === typeNameIds.typeNameIdOfFnMut ||
+                    fnType.id === typeNameIds.typeNameIdOfFnOnce ||
+                    fnType.id === typeNameIds.typeNameIdOfFnPtr
                 )) {
                     // -> matches fn, fnonce, and fnmut
                     // if it matches, then we're fine, and this is an appropriate match candidate
@@ -3410,6 +3507,7 @@ class DocSearch {
          * @param {Map<number,number>|null} mgensIn - Map query generics to function generics.
          *                                            Never modified.
          * @param {number} unboxingDepth
+         * @param {rustdoc.TypeNameIds} typeNameIds
          * @returns {false|{
          *     mgens: [Map<number,number>|null], simplifiedGenerics: rustdoc.FunctionType[]
          * }}
@@ -3420,6 +3518,7 @@ class DocSearch {
             whereClause,
             mgensIn,
             unboxingDepth,
+            typeNameIds,
         ) {
             if (fnType.bindings.size < queryElem.bindings.size) {
                 return false;
@@ -3451,6 +3550,7 @@ class DocSearch {
                                 return false;
                             },
                             unboxingDepth,
+                            typeNameIds,
                         );
                         return newSolutions;
                     });
@@ -3482,6 +3582,7 @@ class DocSearch {
          * @param {rustdoc.FunctionType[][]} whereClause - Trait bounds for generic items.
          * @param {Map<number,number>|null} mgens - Map query generics to function generics.
          * @param {number} unboxingDepth
+         * @param {rustdoc.TypeNameIds} typeNameIds
          * @returns {boolean}
          */
         function unifyFunctionTypeIsUnboxCandidate(
@@ -3490,6 +3591,7 @@ class DocSearch {
             whereClause,
             mgens,
             unboxingDepth,
+            typeNameIds,
         ) {
             if (unboxingDepth >= UNBOXING_LIMIT) {
                 return false;
@@ -3508,6 +3610,7 @@ class DocSearch {
                     whereClause,
                     mgens,
                     unboxingDepth,
+                    typeNameIds,
                 );
             } else if (fnType.unboxFlag &&
                 (fnType.generics.length > 0 || fnType.bindings.size > 0)) {
@@ -3521,6 +3624,7 @@ class DocSearch {
                     whereClause,
                     mgens,
                     unboxingDepth,
+                    typeNameIds,
                 );
             }
             return false;
@@ -3533,14 +3637,15 @@ class DocSearch {
          * @param {rustdoc.QueryElement[]} elems
          * @param {rustdoc.FunctionType[]} list    - A list of function types.
          * @param {rustdoc.FunctionType[][]} where_clause - Trait bounds for generic items.
+         * @param {rustdoc.TypeNameIds} typeNameIds
          */
-        function containsTypeFromQuery(elems, list, where_clause) {
+        function containsTypeFromQuery(elems, list, where_clause, typeNameIds) {
             if (!list) return false;
             for (const ty of elems) {
                 if (ty.id !== null && ty.id < 0) {
                     continue;
                 }
-                if (checkIfInList(list, ty, where_clause, null, 0)) {
+                if (checkIfInList(list, ty, where_clause, null, 0, typeNameIds)) {
                     return true;
                 }
             }
@@ -3556,12 +3661,13 @@ class DocSearch {
          * @param {rustdoc.FunctionType[][]} whereClause - Trait bounds for generic items.
          * @param {Map<number,number>|null} mgens - Map functions generics to query generics.
          * @param {number} unboxingDepth
+         * @param {rustdoc.TypeNameIds} typeNameIds
          *
          * @return {boolean} - Returns true if found, false otherwise.
          */
-        function checkIfInList(list, elem, whereClause, mgens, unboxingDepth) {
+        function checkIfInList(list, elem, whereClause, mgens, unboxingDepth, typeNameIds) {
             for (const entry of list) {
-                if (checkType(entry, elem, whereClause, mgens, unboxingDepth)) {
+                if (checkType(entry, elem, whereClause, mgens, unboxingDepth, typeNameIds)) {
                     return true;
                 }
             }
@@ -3576,11 +3682,12 @@ class DocSearch {
          * @param {rustdoc.QueryElement} elem          - The element from the parsed query.
          * @param {rustdoc.FunctionType[][]} whereClause - Trait bounds for generic items.
          * @param {Map<number,number>|null} mgens - Map query generics to function generics.
+         * @param {number} unboxingDepth
+         * @param {rustdoc.TypeNameIds} typeNameIds
          *
          * @return {boolean} - Returns true if the type matches, false otherwise.
          */
-        // @ts-expect-error
-        const checkType = (row, elem, whereClause, mgens, unboxingDepth) => {
+        const checkType = (row, elem, whereClause, mgens, unboxingDepth, typeNameIds) => {
             if (unboxingDepth >= UNBOXING_LIMIT) {
                 return false;
             }
@@ -3589,9 +3696,9 @@ class DocSearch {
                 row.generics.length === 0 && elem.generics.length === 0 &&
                 row.bindings.size === 0 && elem.bindings.size === 0 &&
                 // special case
-                elem.id !== this.typeNameIdOfArrayOrSlice &&
-                elem.id !== this.typeNameIdOfHof &&
-                elem.id !== this.typeNameIdOfTupleOrUnit
+                elem.id !== typeNameIds.typeNameIdOfArrayOrSlice &&
+                elem.id !== typeNameIds.typeNameIdOfHof &&
+                elem.id !== typeNameIds.typeNameIdOfTupleOrUnit
             ) {
                 return row.id === elem.id && typePassesFilter(elem.typeFilter, row.ty);
             } else {
@@ -3603,6 +3710,7 @@ class DocSearch {
                     mgens,
                     () => true,
                     unboxingDepth,
+                    typeNameIds,
                 );
             }
         };
@@ -3669,7 +3777,10 @@ class DocSearch {
         /**
          * Compute an "edit distance" that ignores missing path elements.
          * @param {string[]} contains search query path
-         * @param {rustdoc.Row} row indexed item
+         * @param {{
+         *     modulePath: string,
+         *     parent: { path: rustdoc.PathData, name: string}?,
+         * }} row indexed item
          * @returns {null|number} edit distance
          */
         function checkRowPath(contains, row) {
@@ -3748,7 +3859,7 @@ class DocSearch {
                         is_alias: true,
                         elems: [], // only used in type-based queries
                         returned: [], // only used in type-based queries
-                        original: await this.getRow(alias, false),
+                        item: nonnull(await this.getRow(alias, false)),
                     };
                 };
                 /**
@@ -3830,6 +3941,7 @@ class DocSearch {
                             elems: [], // only used in type-based queries
                             returned: [], // only used in type-based queries
                             is_alias: false,
+                            item: row,
                         } : null;
                     } else {
                         return {
@@ -3844,6 +3956,7 @@ class DocSearch {
                             elems: [], // only used in type-based queries
                             returned: [], // only used in type-based queries
                             is_alias: false,
+                            item: row,
                         };
                     }
                 };
@@ -4355,9 +4468,10 @@ class DocSearch {
                 };
 
                 // finally, we can do the actual unification loop
-                const [allInputs, allOutput] = await Promise.all([
+                const [allInputs, allOutput, typeNameIds] = await Promise.all([
                     unpackPostingsListAll(inputs, "invertedFunctionInputsIndex"),
                     unpackPostingsListAll(output, "invertedFunctionOutputIndex"),
+                    this.getTypeNameIds(),
                 ]);
                 let checkCounter = 0;
                 /**
@@ -4426,12 +4540,18 @@ class DocSearch {
                                             mgens,
                                             checkTypeMgensForConflict,
                                             0, // unboxing depth
+                                            typeNameIds,
                                         );
                                     },
                                     0, // unboxing depth
+                                    typeNameIds,
                                 )) {
                                     return null;
                                 }
+                                const item = await this.getRow(id, true);
+                                if (!item) {
+                                    return null;
+                                }
                                 const result = {
                                     id,
                                     dist: fnData.elemCount,
@@ -4440,8 +4560,9 @@ class DocSearch {
                                     elems: inputs,
                                     returned: output,
                                     is_alias: false,
+                                    item,
                                 };
-                                const entry = await this.getEntryData(id);
+                                const entry = item.entry;
                                 if ((entry && !isFnLikeTy(entry.ty)) ||
                                     (isReturnTypeQuery &&
                                         functionSignature &&
@@ -4449,6 +4570,7 @@ class DocSearch {
                                             output,
                                             functionSignature.inputs,
                                             functionSignature.where_clause,
+                                            typeNameIds,
                                         )
                                     )
                                 ) {
@@ -5269,7 +5391,6 @@ if (ROOT_PATH === null) {
 const database = await Stringdex.loadDatabase(hooks);
 if (typeof window !== "undefined") {
     docSearch = new DocSearch(ROOT_PATH, database);
-    await docSearch.buildIndex();
     onEachLazy(document.querySelectorAll(
         ".search-form.loading",
     ), form => {
@@ -5282,7 +5403,6 @@ if (typeof window !== "undefined") {
     }
 } else if (typeof exports !== "undefined") {
     docSearch = new DocSearch(ROOT_PATH, database);
-    await docSearch.buildIndex();
     return { docSearch, DocSearch };
 }
 };
diff --git a/src/librustdoc/html/static/js/stringdex.js b/src/librustdoc/html/static/js/stringdex.js
index 4c4659628778d..5bdc81e330efa 100644
--- a/src/librustdoc/html/static/js/stringdex.js
+++ b/src/librustdoc/html/static/js/stringdex.js
@@ -2310,7 +2310,7 @@ function loadDatabase(hooks) {
                 } else {
                     const start = this.bucket_keys[idx];
                     const bucket = this.buckets[idx];
-                    let data = this.buckets[idx].data;
+                    const data = this.buckets[idx].data;
                     if (data === null) {
                         return this.atAsyncFetch(id, start, bucket);
                     } else {

From 382c964f3ea97d81f75c9716645dcedf081b4f5d Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sat, 13 Sep 2025 00:28:46 +0200
Subject: [PATCH 0879/1889] small clean-up

---
 clippy_lints/src/lifetimes.rs | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 149ae5e710c1f..aac5d08fd37c8 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -745,7 +745,7 @@ fn report_elidable_impl_lifetimes<'tcx>(
     impl_: &'tcx Impl<'_>,
     map: &FxIndexMap<LocalDefId, Vec<Usage>>,
 ) {
-    let single_usages = map
+    let (elidable_lts, usages): (Vec<_>, Vec<_>) = map
         .iter()
         .filter_map(|(def_id, usages)| {
             if let [
@@ -762,14 +762,12 @@ fn report_elidable_impl_lifetimes<'tcx>(
                 None
             }
         })
-        .collect::<Vec<_>>();
+        .unzip();
 
-    if single_usages.is_empty() {
+    if elidable_lts.is_empty() {
         return;
     }
 
-    let (elidable_lts, usages): (Vec<_>, Vec<_>) = single_usages.into_iter().unzip();
-
     report_elidable_lifetimes(cx, impl_.generics, &elidable_lts, &usages, true);
 }
 
@@ -795,9 +793,7 @@ fn report_elidable_lifetimes(
         // In principle, the result of the call to `Node::ident` could be `unwrap`ped, as `DefId` should refer to a
         // `Node::GenericParam`.
         .filter_map(|&def_id| cx.tcx.hir_node_by_def_id(def_id).ident())
-        .map(|ident| ident.to_string())
-        .collect::<Vec<_>>()
-        .join(", ");
+        .format(", ");
 
     let elidable_usages: Vec<ElidableUsage> = usages
         .iter()

From ae57f08c1377b304b13fbb922438615d7692d65e Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Sat, 13 Sep 2025 04:52:19 +0000
Subject: [PATCH 0880/1889] Prepare for merging from rust-lang/rust

This updates the rust-version file to 4ba1cf9ade4c8e2fa10676a50ee34594eb161837.
---
 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 b3f8a26875f40..e5f0be9ac9551 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-2a9bacf6187685931d52346a0ecff2e52bdc91cc
+4ba1cf9ade4c8e2fa10676a50ee34594eb161837

From 2baa39e89f59da3b7bb2228ab6e66999063a6101 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 13 Sep 2025 10:41:59 +0200
Subject: [PATCH 0881/1889] also apply revert to wasip2

---
 library/std/src/sys/pal/wasip2/time.rs | 25 +++++++------------------
 1 file changed, 7 insertions(+), 18 deletions(-)

diff --git a/library/std/src/sys/pal/wasip2/time.rs b/library/std/src/sys/pal/wasip2/time.rs
index 980070e7b851e..434891839944d 100644
--- a/library/std/src/sys/pal/wasip2/time.rs
+++ b/library/std/src/sys/pal/wasip2/time.rs
@@ -36,34 +36,23 @@ impl SystemTime {
         SystemTime(Duration::new(now.seconds, now.nanoseconds))
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn from_wasi_timestamp(ts: wasi::Timestamp) -> SystemTime {
+    pub fn from_wasi_timestamp(ts: wasi::Timestamp) -> SystemTime {
         SystemTime(Duration::from_nanos(ts))
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn to_wasi_timestamp(&self) -> Option<wasi::Timestamp> {
-        // FIXME: const TryInto
-        let ns = self.0.as_nanos();
-        if ns <= u64::MAX as u128 { Some(ns as u64) } else { None }
+    pub fn to_wasi_timestamp(&self) -> Option<wasi::Timestamp> {
+        self.0.as_nanos().try_into().ok()
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
-        // FIXME: ok_or_else with const closures
-        match self.0.checked_sub(other.0) {
-            Some(duration) => Ok(duration),
-            None => Err(other.0 - self.0),
-        }
+    pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
+        self.0.checked_sub(other.0).ok_or_else(|| other.0 - self.0)
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
+    pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_add(*other)?))
     }
 
-    #[rustc_const_unstable(feature = "const_system_time", issue = "144517")]
-    pub const fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
         Some(SystemTime(self.0.checked_sub(*other)?))
     }
 }

From 25cf36ac78d1b88583f7a1125f9ddf67d8ef8eea Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sat, 13 Sep 2025 01:25:03 +0200
Subject: [PATCH 0882/1889] clean-up

- move tests to `ui-toml/`, since they all use `clippy.toml`
- remove the trait test case from `ref_option.rs`, because it's already
  covered by `ref_option_traits.rs`
---
 clippy_lints/src/functions/ref_option.rs      | 16 ++---
 .../ref_option/all/clippy.toml                |  0
 .../ref_option/private/clippy.toml            |  0
 .../ref_option/ref_option.all.fixed           | 22 ++----
 .../ref_option/ref_option.all.stderr          | 68 +++++--------------
 .../ref_option/ref_option.private.fixed       | 22 ++----
 .../ref_option/ref_option.private.stderr      | 44 ++++--------
 .../{ui => ui-toml}/ref_option/ref_option.rs  | 22 ++----
 .../ref_option/ref_option_traits.all.stderr   |  8 +--
 .../ref_option_traits.private.stderr          |  4 +-
 .../ref_option/ref_option_traits.rs           |  4 +-
 11 files changed, 58 insertions(+), 152 deletions(-)
 rename tests/{ui => ui-toml}/ref_option/all/clippy.toml (100%)
 rename tests/{ui => ui-toml}/ref_option/private/clippy.toml (100%)
 rename tests/{ui => ui-toml}/ref_option/ref_option.all.fixed (72%)
 rename tests/{ui => ui-toml}/ref_option/ref_option.all.stderr (62%)
 rename tests/{ui => ui-toml}/ref_option/ref_option.private.fixed (72%)
 rename tests/{ui => ui-toml}/ref_option/ref_option.private.stderr (63%)
 rename tests/{ui => ui-toml}/ref_option/ref_option.rs (72%)
 rename tests/{ui => ui-toml}/ref_option/ref_option_traits.all.stderr (85%)
 rename tests/{ui => ui-toml}/ref_option/ref_option_traits.private.stderr (86%)
 rename tests/{ui => ui-toml}/ref_option/ref_option_traits.rs (85%)

diff --git a/clippy_lints/src/functions/ref_option.rs b/clippy_lints/src/functions/ref_option.rs
index 106202d00d403..b4ae258ebbb32 100644
--- a/clippy_lints/src/functions/ref_option.rs
+++ b/clippy_lints/src/functions/ref_option.rs
@@ -2,22 +2,18 @@ use crate::functions::REF_OPTION;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_trait_impl_item;
 use clippy_utils::source::snippet;
-use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::ty::option_arg_ty;
 use rustc_errors::Applicability;
-use rustc_hir as hir;
 use rustc_hir::intravisit::FnKind;
-use rustc_hir::{FnDecl, HirId};
+use rustc_hir::{self as hir, FnDecl, HirId};
 use rustc_lint::LateContext;
-use rustc_middle::ty::{self, GenericArgKind, Mutability, Ty};
+use rustc_middle::ty::{self, Mutability, Ty};
+use rustc_span::Span;
 use rustc_span::def_id::LocalDefId;
-use rustc_span::{Span, sym};
 
-fn check_ty<'a>(cx: &LateContext<'a>, param: &rustc_hir::Ty<'a>, param_ty: Ty<'a>, fixes: &mut Vec<(Span, String)>) {
+fn check_ty<'a>(cx: &LateContext<'a>, param: &hir::Ty<'a>, param_ty: Ty<'a>, fixes: &mut Vec<(Span, String)>) {
     if let ty::Ref(_, opt_ty, Mutability::Not) = param_ty.kind()
-        && is_type_diagnostic_item(cx, *opt_ty, sym::Option)
-        && let ty::Adt(_, opt_gen_args) = opt_ty.kind()
-        && let [gen_arg] = opt_gen_args.as_slice()
-        && let GenericArgKind::Type(gen_ty) = gen_arg.kind()
+        && let Some(gen_ty) = option_arg_ty(cx, *opt_ty)
         && !gen_ty.is_ref()
         // Need to gen the original spans, so first parsing mid, and hir parsing afterward
         && let hir::TyKind::Ref(lifetime, hir::MutTy { ty, .. }) = param.kind
diff --git a/tests/ui/ref_option/all/clippy.toml b/tests/ui-toml/ref_option/all/clippy.toml
similarity index 100%
rename from tests/ui/ref_option/all/clippy.toml
rename to tests/ui-toml/ref_option/all/clippy.toml
diff --git a/tests/ui/ref_option/private/clippy.toml b/tests/ui-toml/ref_option/private/clippy.toml
similarity index 100%
rename from tests/ui/ref_option/private/clippy.toml
rename to tests/ui-toml/ref_option/private/clippy.toml
diff --git a/tests/ui/ref_option/ref_option.all.fixed b/tests/ui-toml/ref_option/ref_option.all.fixed
similarity index 72%
rename from tests/ui/ref_option/ref_option.all.fixed
rename to tests/ui-toml/ref_option/ref_option.all.fixed
index 4159e916f1995..102d4aaefff40 100644
--- a/tests/ui/ref_option/ref_option.all.fixed
+++ b/tests/ui-toml/ref_option/ref_option.all.fixed
@@ -1,6 +1,6 @@
 //@revisions: private all
-//@[private] rustc-env:CLIPPY_CONF_DIR=tests/ui/ref_option/private
-//@[all] rustc-env:CLIPPY_CONF_DIR=tests/ui/ref_option/all
+//@[private] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/ref_option/private
+//@[all] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/ref_option/all
 
 #![allow(unused, clippy::needless_lifetimes, clippy::borrowed_box)]
 #![warn(clippy::ref_option)]
@@ -11,11 +11,11 @@ fn opt_gen<T>(a: Option<&T>) {}
 //~^ ref_option
 fn opt_string(a: std::option::Option<&String>) {}
 //~^ ref_option
-fn ret_string<'a>(p: &'a str) -> Option<&'a u8> {
+fn ret_u8<'a>(p: &'a str) -> Option<&'a u8> {
     //~^ ref_option
     panic!()
 }
-fn ret_string_static() -> Option<&'static u8> {
+fn ret_u8_static() -> Option<&'static u8> {
     //~^ ref_option
     panic!()
 }
@@ -31,20 +31,6 @@ pub fn pub_opt_string(a: Option<&String>) {}
 pub fn pub_mult_string(a: Option<&String>, b: Option<&Vec<u8>>) {}
 //~[all]^ ref_option
 
-pub trait PubTrait {
-    fn pub_trait_opt(&self, a: Option<&Vec<u8>>);
-    //~[all]^ ref_option
-    fn pub_trait_ret(&self) -> Option<&Vec<u8>>;
-    //~[all]^ ref_option
-}
-
-trait PrivateTrait {
-    fn trait_opt(&self, a: Option<&String>);
-    //~^ ref_option
-    fn trait_ret(&self) -> Option<&String>;
-    //~^ ref_option
-}
-
 pub struct PubStruct;
 
 impl PubStruct {
diff --git a/tests/ui/ref_option/ref_option.all.stderr b/tests/ui-toml/ref_option/ref_option.all.stderr
similarity index 62%
rename from tests/ui/ref_option/ref_option.all.stderr
rename to tests/ui-toml/ref_option/ref_option.all.stderr
index bd43c28336eb3..efd7a6b7241f1 100644
--- a/tests/ui/ref_option/ref_option.all.stderr
+++ b/tests/ui-toml/ref_option/ref_option.all.stderr
@@ -1,5 +1,5 @@
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:8:1
+  --> tests/ui-toml/ref_option/ref_option.rs:8:1
    |
 LL | fn opt_u8(a: &Option<u8>) {}
    | ^^^^^^^^^^^^^-----------^^^^
@@ -10,7 +10,7 @@ LL | fn opt_u8(a: &Option<u8>) {}
    = help: to override `-D warnings` add `#[allow(clippy::ref_option)]`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:10:1
+  --> tests/ui-toml/ref_option/ref_option.rs:10:1
    |
 LL | fn opt_gen<T>(a: &Option<T>) {}
    | ^^^^^^^^^^^^^^^^^----------^^^^
@@ -18,7 +18,7 @@ LL | fn opt_gen<T>(a: &Option<T>) {}
    |                  help: change this to: `Option<&T>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:12:1
+  --> tests/ui-toml/ref_option/ref_option.rs:12:1
    |
 LL | fn opt_string(a: &std::option::Option<String>) {}
    | ^^^^^^^^^^^^^^^^^----------------------------^^^^
@@ -26,10 +26,10 @@ LL | fn opt_string(a: &std::option::Option<String>) {}
    |                  help: change this to: `std::option::Option<&String>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:14:1
+  --> tests/ui-toml/ref_option/ref_option.rs:14:1
    |
-LL |   fn ret_string<'a>(p: &'a str) -> &'a Option<u8> {
-   |   ^                                -------------- help: change this to: `Option<&'a u8>`
+LL |   fn ret_u8<'a>(p: &'a str) -> &'a Option<u8> {
+   |   ^                            -------------- help: change this to: `Option<&'a u8>`
    |  _|
    | |
 LL | |
@@ -38,10 +38,10 @@ LL | | }
    | |_^
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:18:1
+  --> tests/ui-toml/ref_option/ref_option.rs:18:1
    |
-LL |   fn ret_string_static() -> &'static Option<u8> {
-   |   ^                         ------------------- help: change this to: `Option<&'static u8>`
+LL |   fn ret_u8_static() -> &'static Option<u8> {
+   |   ^                     ------------------- help: change this to: `Option<&'static u8>`
    |  _|
    | |
 LL | |
@@ -50,7 +50,7 @@ LL | | }
    | |_^
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:22:1
+  --> tests/ui-toml/ref_option/ref_option.rs:22:1
    |
 LL | fn mult_string(a: &Option<String>, b: &Option<Vec<u8>>) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -62,7 +62,7 @@ LL + fn mult_string(a: Option<&String>, b: Option<&Vec<u8>>) {}
    |
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:24:1
+  --> tests/ui-toml/ref_option/ref_option.rs:24:1
    |
 LL |   fn ret_box<'a>() -> &'a Option<Box<u8>> {
    |   ^                   ------------------- help: change this to: `Option<&'a Box<u8>>`
@@ -74,7 +74,7 @@ LL | | }
    | |_^
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:29:1
+  --> tests/ui-toml/ref_option/ref_option.rs:29:1
    |
 LL | pub fn pub_opt_string(a: &Option<String>) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^---------------^^^^
@@ -82,7 +82,7 @@ LL | pub fn pub_opt_string(a: &Option<String>) {}
    |                          help: change this to: `Option<&String>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:31:1
+  --> tests/ui-toml/ref_option/ref_option.rs:31:1
    |
 LL | pub fn pub_mult_string(a: &Option<String>, b: &Option<Vec<u8>>) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -94,39 +94,7 @@ LL + pub fn pub_mult_string(a: Option<&String>, b: Option<&Vec<u8>>) {}
    |
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:35:5
-   |
-LL |     fn pub_trait_opt(&self, a: &Option<Vec<u8>>);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^----------------^^
-   |                                |
-   |                                help: change this to: `Option<&Vec<u8>>`
-
-error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:37:5
-   |
-LL |     fn pub_trait_ret(&self) -> &Option<Vec<u8>>;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^----------------^
-   |                                |
-   |                                help: change this to: `Option<&Vec<u8>>`
-
-error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:42:5
-   |
-LL |     fn trait_opt(&self, a: &Option<String>);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^^
-   |                            |
-   |                            help: change this to: `Option<&String>`
-
-error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:44:5
-   |
-LL |     fn trait_ret(&self) -> &Option<String>;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^
-   |                            |
-   |                            help: change this to: `Option<&String>`
-
-error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:51:5
+  --> tests/ui-toml/ref_option/ref_option.rs:37:5
    |
 LL |     pub fn pub_opt_params(&self, a: &Option<()>) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-----------^^^^
@@ -134,7 +102,7 @@ LL |     pub fn pub_opt_params(&self, a: &Option<()>) {}
    |                                     help: change this to: `Option<&()>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:53:5
+  --> tests/ui-toml/ref_option/ref_option.rs:39:5
    |
 LL |       pub fn pub_opt_ret(&self) -> &Option<String> {
    |       ^                            --------------- help: change this to: `Option<&String>`
@@ -146,7 +114,7 @@ LL | |     }
    | |_____^
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:58:5
+  --> tests/ui-toml/ref_option/ref_option.rs:44:5
    |
 LL |     fn private_opt_params(&self, a: &Option<()>) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-----------^^^^
@@ -154,7 +122,7 @@ LL |     fn private_opt_params(&self, a: &Option<()>) {}
    |                                     help: change this to: `Option<&()>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:60:5
+  --> tests/ui-toml/ref_option/ref_option.rs:46:5
    |
 LL |       fn private_opt_ret(&self) -> &Option<String> {
    |       ^                            --------------- help: change this to: `Option<&String>`
@@ -165,5 +133,5 @@ LL | |         panic!()
 LL | |     }
    | |_____^
 
-error: aborting due to 17 previous errors
+error: aborting due to 13 previous errors
 
diff --git a/tests/ui/ref_option/ref_option.private.fixed b/tests/ui-toml/ref_option/ref_option.private.fixed
similarity index 72%
rename from tests/ui/ref_option/ref_option.private.fixed
rename to tests/ui-toml/ref_option/ref_option.private.fixed
index 3b158befb926e..396188b6d4077 100644
--- a/tests/ui/ref_option/ref_option.private.fixed
+++ b/tests/ui-toml/ref_option/ref_option.private.fixed
@@ -1,6 +1,6 @@
 //@revisions: private all
-//@[private] rustc-env:CLIPPY_CONF_DIR=tests/ui/ref_option/private
-//@[all] rustc-env:CLIPPY_CONF_DIR=tests/ui/ref_option/all
+//@[private] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/ref_option/private
+//@[all] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/ref_option/all
 
 #![allow(unused, clippy::needless_lifetimes, clippy::borrowed_box)]
 #![warn(clippy::ref_option)]
@@ -11,11 +11,11 @@ fn opt_gen<T>(a: Option<&T>) {}
 //~^ ref_option
 fn opt_string(a: std::option::Option<&String>) {}
 //~^ ref_option
-fn ret_string<'a>(p: &'a str) -> Option<&'a u8> {
+fn ret_u8<'a>(p: &'a str) -> Option<&'a u8> {
     //~^ ref_option
     panic!()
 }
-fn ret_string_static() -> Option<&'static u8> {
+fn ret_u8_static() -> Option<&'static u8> {
     //~^ ref_option
     panic!()
 }
@@ -31,20 +31,6 @@ pub fn pub_opt_string(a: &Option<String>) {}
 pub fn pub_mult_string(a: &Option<String>, b: &Option<Vec<u8>>) {}
 //~[all]^ ref_option
 
-pub trait PubTrait {
-    fn pub_trait_opt(&self, a: &Option<Vec<u8>>);
-    //~[all]^ ref_option
-    fn pub_trait_ret(&self) -> &Option<Vec<u8>>;
-    //~[all]^ ref_option
-}
-
-trait PrivateTrait {
-    fn trait_opt(&self, a: Option<&String>);
-    //~^ ref_option
-    fn trait_ret(&self) -> Option<&String>;
-    //~^ ref_option
-}
-
 pub struct PubStruct;
 
 impl PubStruct {
diff --git a/tests/ui/ref_option/ref_option.private.stderr b/tests/ui-toml/ref_option/ref_option.private.stderr
similarity index 63%
rename from tests/ui/ref_option/ref_option.private.stderr
rename to tests/ui-toml/ref_option/ref_option.private.stderr
index 88c65e429d870..56f38c44f14c2 100644
--- a/tests/ui/ref_option/ref_option.private.stderr
+++ b/tests/ui-toml/ref_option/ref_option.private.stderr
@@ -1,5 +1,5 @@
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:8:1
+  --> tests/ui-toml/ref_option/ref_option.rs:8:1
    |
 LL | fn opt_u8(a: &Option<u8>) {}
    | ^^^^^^^^^^^^^-----------^^^^
@@ -10,7 +10,7 @@ LL | fn opt_u8(a: &Option<u8>) {}
    = help: to override `-D warnings` add `#[allow(clippy::ref_option)]`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:10:1
+  --> tests/ui-toml/ref_option/ref_option.rs:10:1
    |
 LL | fn opt_gen<T>(a: &Option<T>) {}
    | ^^^^^^^^^^^^^^^^^----------^^^^
@@ -18,7 +18,7 @@ LL | fn opt_gen<T>(a: &Option<T>) {}
    |                  help: change this to: `Option<&T>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:12:1
+  --> tests/ui-toml/ref_option/ref_option.rs:12:1
    |
 LL | fn opt_string(a: &std::option::Option<String>) {}
    | ^^^^^^^^^^^^^^^^^----------------------------^^^^
@@ -26,10 +26,10 @@ LL | fn opt_string(a: &std::option::Option<String>) {}
    |                  help: change this to: `std::option::Option<&String>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:14:1
+  --> tests/ui-toml/ref_option/ref_option.rs:14:1
    |
-LL |   fn ret_string<'a>(p: &'a str) -> &'a Option<u8> {
-   |   ^                                -------------- help: change this to: `Option<&'a u8>`
+LL |   fn ret_u8<'a>(p: &'a str) -> &'a Option<u8> {
+   |   ^                            -------------- help: change this to: `Option<&'a u8>`
    |  _|
    | |
 LL | |
@@ -38,10 +38,10 @@ LL | | }
    | |_^
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:18:1
+  --> tests/ui-toml/ref_option/ref_option.rs:18:1
    |
-LL |   fn ret_string_static() -> &'static Option<u8> {
-   |   ^                         ------------------- help: change this to: `Option<&'static u8>`
+LL |   fn ret_u8_static() -> &'static Option<u8> {
+   |   ^                     ------------------- help: change this to: `Option<&'static u8>`
    |  _|
    | |
 LL | |
@@ -50,7 +50,7 @@ LL | | }
    | |_^
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:22:1
+  --> tests/ui-toml/ref_option/ref_option.rs:22:1
    |
 LL | fn mult_string(a: &Option<String>, b: &Option<Vec<u8>>) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -62,7 +62,7 @@ LL + fn mult_string(a: Option<&String>, b: Option<&Vec<u8>>) {}
    |
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:24:1
+  --> tests/ui-toml/ref_option/ref_option.rs:24:1
    |
 LL |   fn ret_box<'a>() -> &'a Option<Box<u8>> {
    |   ^                   ------------------- help: change this to: `Option<&'a Box<u8>>`
@@ -74,23 +74,7 @@ LL | | }
    | |_^
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:42:5
-   |
-LL |     fn trait_opt(&self, a: &Option<String>);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^^
-   |                            |
-   |                            help: change this to: `Option<&String>`
-
-error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:44:5
-   |
-LL |     fn trait_ret(&self) -> &Option<String>;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^
-   |                            |
-   |                            help: change this to: `Option<&String>`
-
-error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:58:5
+  --> tests/ui-toml/ref_option/ref_option.rs:44:5
    |
 LL |     fn private_opt_params(&self, a: &Option<()>) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-----------^^^^
@@ -98,7 +82,7 @@ LL |     fn private_opt_params(&self, a: &Option<()>) {}
    |                                     help: change this to: `Option<&()>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:60:5
+  --> tests/ui-toml/ref_option/ref_option.rs:46:5
    |
 LL |       fn private_opt_ret(&self) -> &Option<String> {
    |       ^                            --------------- help: change this to: `Option<&String>`
@@ -109,5 +93,5 @@ LL | |         panic!()
 LL | |     }
    | |_____^
 
-error: aborting due to 11 previous errors
+error: aborting due to 9 previous errors
 
diff --git a/tests/ui/ref_option/ref_option.rs b/tests/ui-toml/ref_option/ref_option.rs
similarity index 72%
rename from tests/ui/ref_option/ref_option.rs
rename to tests/ui-toml/ref_option/ref_option.rs
index 35cd94174f8bc..7600c58ea7038 100644
--- a/tests/ui/ref_option/ref_option.rs
+++ b/tests/ui-toml/ref_option/ref_option.rs
@@ -1,6 +1,6 @@
 //@revisions: private all
-//@[private] rustc-env:CLIPPY_CONF_DIR=tests/ui/ref_option/private
-//@[all] rustc-env:CLIPPY_CONF_DIR=tests/ui/ref_option/all
+//@[private] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/ref_option/private
+//@[all] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/ref_option/all
 
 #![allow(unused, clippy::needless_lifetimes, clippy::borrowed_box)]
 #![warn(clippy::ref_option)]
@@ -11,11 +11,11 @@ fn opt_gen<T>(a: &Option<T>) {}
 //~^ ref_option
 fn opt_string(a: &std::option::Option<String>) {}
 //~^ ref_option
-fn ret_string<'a>(p: &'a str) -> &'a Option<u8> {
+fn ret_u8<'a>(p: &'a str) -> &'a Option<u8> {
     //~^ ref_option
     panic!()
 }
-fn ret_string_static() -> &'static Option<u8> {
+fn ret_u8_static() -> &'static Option<u8> {
     //~^ ref_option
     panic!()
 }
@@ -31,20 +31,6 @@ pub fn pub_opt_string(a: &Option<String>) {}
 pub fn pub_mult_string(a: &Option<String>, b: &Option<Vec<u8>>) {}
 //~[all]^ ref_option
 
-pub trait PubTrait {
-    fn pub_trait_opt(&self, a: &Option<Vec<u8>>);
-    //~[all]^ ref_option
-    fn pub_trait_ret(&self) -> &Option<Vec<u8>>;
-    //~[all]^ ref_option
-}
-
-trait PrivateTrait {
-    fn trait_opt(&self, a: &Option<String>);
-    //~^ ref_option
-    fn trait_ret(&self) -> &Option<String>;
-    //~^ ref_option
-}
-
 pub struct PubStruct;
 
 impl PubStruct {
diff --git a/tests/ui/ref_option/ref_option_traits.all.stderr b/tests/ui-toml/ref_option/ref_option_traits.all.stderr
similarity index 85%
rename from tests/ui/ref_option/ref_option_traits.all.stderr
rename to tests/ui-toml/ref_option/ref_option_traits.all.stderr
index 886bf2b034989..61017eba176e0 100644
--- a/tests/ui/ref_option/ref_option_traits.all.stderr
+++ b/tests/ui-toml/ref_option/ref_option_traits.all.stderr
@@ -1,5 +1,5 @@
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option_traits.rs:9:5
+  --> tests/ui-toml/ref_option/ref_option_traits.rs:9:5
    |
 LL |     fn pub_trait_opt(&self, a: &Option<Vec<u8>>);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^----------------^^
@@ -10,7 +10,7 @@ LL |     fn pub_trait_opt(&self, a: &Option<Vec<u8>>);
    = help: to override `-D warnings` add `#[allow(clippy::ref_option)]`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option_traits.rs:11:5
+  --> tests/ui-toml/ref_option/ref_option_traits.rs:11:5
    |
 LL |     fn pub_trait_ret(&self) -> &Option<Vec<u8>>;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^----------------^
@@ -18,7 +18,7 @@ LL |     fn pub_trait_ret(&self) -> &Option<Vec<u8>>;
    |                                help: change this to: `Option<&Vec<u8>>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option_traits.rs:16:5
+  --> tests/ui-toml/ref_option/ref_option_traits.rs:16:5
    |
 LL |     fn trait_opt(&self, a: &Option<String>);
    |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^^
@@ -26,7 +26,7 @@ LL |     fn trait_opt(&self, a: &Option<String>);
    |                            help: change this to: `Option<&String>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option_traits.rs:18:5
+  --> tests/ui-toml/ref_option/ref_option_traits.rs:18:5
    |
 LL |     fn trait_ret(&self) -> &Option<String>;
    |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^
diff --git a/tests/ui/ref_option/ref_option_traits.private.stderr b/tests/ui-toml/ref_option/ref_option_traits.private.stderr
similarity index 86%
rename from tests/ui/ref_option/ref_option_traits.private.stderr
rename to tests/ui-toml/ref_option/ref_option_traits.private.stderr
index cfab7fa5734c3..d7b0b6e9f8368 100644
--- a/tests/ui/ref_option/ref_option_traits.private.stderr
+++ b/tests/ui-toml/ref_option/ref_option_traits.private.stderr
@@ -1,5 +1,5 @@
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option_traits.rs:16:5
+  --> tests/ui-toml/ref_option/ref_option_traits.rs:16:5
    |
 LL |     fn trait_opt(&self, a: &Option<String>);
    |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^^
@@ -10,7 +10,7 @@ LL |     fn trait_opt(&self, a: &Option<String>);
    = help: to override `-D warnings` add `#[allow(clippy::ref_option)]`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option_traits.rs:18:5
+  --> tests/ui-toml/ref_option/ref_option_traits.rs:18:5
    |
 LL |     fn trait_ret(&self) -> &Option<String>;
    |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^
diff --git a/tests/ui/ref_option/ref_option_traits.rs b/tests/ui-toml/ref_option/ref_option_traits.rs
similarity index 85%
rename from tests/ui/ref_option/ref_option_traits.rs
rename to tests/ui-toml/ref_option/ref_option_traits.rs
index 4c773e84f8da8..c02d154b448f2 100644
--- a/tests/ui/ref_option/ref_option_traits.rs
+++ b/tests/ui-toml/ref_option/ref_option_traits.rs
@@ -1,7 +1,7 @@
 //@no-rustfix: fixes are only done to traits, not the impls
 //@revisions: private all
-//@[private] rustc-env:CLIPPY_CONF_DIR=tests/ui/ref_option/private
-//@[all] rustc-env:CLIPPY_CONF_DIR=tests/ui/ref_option/all
+//@[private] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/ref_option/private
+//@[all] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/ref_option/all
 
 #![warn(clippy::ref_option)]
 

From b901ba725ebb33d3bb3ff4d8438db74a615d9e23 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sat, 13 Sep 2025 01:24:18 +0200
Subject: [PATCH 0883/1889] fix(ref_option): don't lint in external and
 proc-macros

---
 clippy_lints/src/functions/ref_option.rs      | 32 +++++++++---
 tests/ui-toml/ref_option/ref_option.all.fixed | 49 +++++++++++++++++++
 .../ui-toml/ref_option/ref_option.all.stderr  | 26 +++++-----
 .../ref_option/ref_option.private.fixed       | 49 +++++++++++++++++++
 .../ref_option/ref_option.private.stderr      | 18 +++----
 tests/ui-toml/ref_option/ref_option.rs        | 49 +++++++++++++++++++
 .../ref_option/ref_option_traits.all.stderr   |  8 +--
 .../ref_option_traits.private.stderr          |  4 +-
 tests/ui-toml/ref_option/ref_option_traits.rs | 31 ++++++++++++
 9 files changed, 230 insertions(+), 36 deletions(-)

diff --git a/clippy_lints/src/functions/ref_option.rs b/clippy_lints/src/functions/ref_option.rs
index b4ae258ebbb32..5dc1b7269b761 100644
--- a/clippy_lints/src/functions/ref_option.rs
+++ b/clippy_lints/src/functions/ref_option.rs
@@ -1,18 +1,19 @@
 use crate::functions::REF_OPTION;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::is_trait_impl_item;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::option_arg_ty;
+use clippy_utils::{is_from_proc_macro, is_trait_impl_item};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{self as hir, FnDecl, HirId};
-use rustc_lint::LateContext;
+use rustc_lint::{LateContext, LintContext};
 use rustc_middle::ty::{self, Mutability, Ty};
 use rustc_span::Span;
 use rustc_span::def_id::LocalDefId;
 
 fn check_ty<'a>(cx: &LateContext<'a>, param: &hir::Ty<'a>, param_ty: Ty<'a>, fixes: &mut Vec<(Span, String)>) {
-    if let ty::Ref(_, opt_ty, Mutability::Not) = param_ty.kind()
+    if !param.span.in_external_macro(cx.sess().source_map())
+        && let ty::Ref(_, opt_ty, Mutability::Not) = param_ty.kind()
         && let Some(gen_ty) = option_arg_ty(cx, *opt_ty)
         && !gen_ty.is_ref()
         // Need to gen the original spans, so first parsing mid, and hir parsing afterward
@@ -23,6 +24,7 @@ fn check_ty<'a>(cx: &LateContext<'a>, param: &hir::Ty<'a>, param_ty: Ty<'a>, fix
             args: [hir::GenericArg::Type(opt_ty)],
             ..
         }) = last.args
+        && !is_from_proc_macro(cx, param)
     {
         let lifetime = snippet(cx, lifetime.ident.span, "..");
         fixes.push((
@@ -63,21 +65,24 @@ fn check_fn_sig<'a>(cx: &LateContext<'a>, decl: &FnDecl<'a>, span: Span, sig: ty
 #[allow(clippy::too_many_arguments)]
 pub(crate) fn check_fn<'a>(
     cx: &LateContext<'a>,
-    kind: FnKind<'_>,
+    kind: FnKind<'a>,
     decl: &FnDecl<'a>,
     span: Span,
     hir_id: HirId,
     def_id: LocalDefId,
-    body: &hir::Body<'_>,
+    body: &hir::Body<'a>,
     avoid_breaking_exported_api: bool,
 ) {
     if avoid_breaking_exported_api && cx.effective_visibilities.is_exported(def_id) {
         return;
     }
+    if span.in_external_macro(cx.sess().source_map()) {
+        return;
+    }
 
     if let FnKind::Closure = kind {
         // Compute the span of the closure parameters + return type if set
-        let span = if let hir::FnRetTy::Return(out_ty) = &decl.output {
+        let inputs_output_span = if let hir::FnRetTy::Return(out_ty) = &decl.output {
             if decl.inputs.is_empty() {
                 out_ty.span
             } else {
@@ -96,9 +101,18 @@ pub(crate) fn check_fn<'a>(
         };
         let sig = args.as_closure().sig().skip_binder();
 
-        check_fn_sig(cx, decl, span, sig);
+        if is_from_proc_macro(cx, &(&kind, body, hir_id, span)) {
+            return;
+        }
+
+        check_fn_sig(cx, decl, inputs_output_span, sig);
     } else if !is_trait_impl_item(cx, hir_id) {
         let sig = cx.tcx.fn_sig(def_id).instantiate_identity().skip_binder();
+
+        if is_from_proc_macro(cx, &(&kind, body, hir_id, span)) {
+            return;
+        }
+
         check_fn_sig(cx, decl, span, sig);
     }
 }
@@ -108,8 +122,10 @@ pub(super) fn check_trait_item<'a>(
     trait_item: &hir::TraitItem<'a>,
     avoid_breaking_exported_api: bool,
 ) {
-    if let hir::TraitItemKind::Fn(ref sig, _) = trait_item.kind
+    if !trait_item.span.in_external_macro(cx.sess().source_map())
+        && let hir::TraitItemKind::Fn(ref sig, _) = trait_item.kind
         && !(avoid_breaking_exported_api && cx.effective_visibilities.is_exported(trait_item.owner_id.def_id))
+        && !is_from_proc_macro(cx, trait_item)
     {
         let def_id = trait_item.owner_id.def_id;
         let ty_sig = cx.tcx.fn_sig(def_id).instantiate_identity().skip_binder();
diff --git a/tests/ui-toml/ref_option/ref_option.all.fixed b/tests/ui-toml/ref_option/ref_option.all.fixed
index 102d4aaefff40..f8f097e9a75e3 100644
--- a/tests/ui-toml/ref_option/ref_option.all.fixed
+++ b/tests/ui-toml/ref_option/ref_option.all.fixed
@@ -1,3 +1,4 @@
+//@aux-build:../../ui/auxiliary/proc_macros.rs
 //@revisions: private all
 //@[private] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/ref_option/private
 //@[all] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/ref_option/all
@@ -62,4 +63,52 @@ fn lambdas() {
     let x = |a: &Option<String>| -> &Option<String> { panic!() };
 }
 
+pub mod external {
+    proc_macros::external!(
+        fn opt_u8(a: &Option<u8>) {}
+        fn ret_u8<'a>(p: &'a str) -> &'a Option<u8> {
+            panic!()
+        }
+        pub fn pub_opt_u8(a: &Option<u8>) {}
+
+        pub struct PubStruct;
+        impl PubStruct {
+            pub fn pub_opt_params(&self, a: &Option<()>) {}
+            pub fn pub_opt_ret(&self) -> &Option<String> {
+                panic!()
+            }
+
+            fn private_opt_params(&self, a: &Option<()>) {}
+            fn private_opt_ret(&self) -> &Option<String> {
+                panic!()
+            }
+        }
+    );
+}
+
+pub mod proc_macros {
+    proc_macros::with_span!(
+        span
+
+        fn opt_u8(a: &Option<u8>) {}
+        fn ret_u8<'a>(p: &'a str) -> &'a Option<u8> {
+            panic!()
+        }
+        pub fn pub_opt_u8(a: &Option<u8>) {}
+
+        pub struct PubStruct;
+        impl PubStruct {
+            pub fn pub_opt_params(&self, a: &Option<()>) {}
+            pub fn pub_opt_ret(&self) -> &Option<String> {
+                panic!()
+            }
+
+            fn private_opt_params(&self, a: &Option<()>) {}
+            fn private_opt_ret(&self) -> &Option<String> {
+                panic!()
+            }
+        }
+    );
+}
+
 fn main() {}
diff --git a/tests/ui-toml/ref_option/ref_option.all.stderr b/tests/ui-toml/ref_option/ref_option.all.stderr
index efd7a6b7241f1..45ce105e03084 100644
--- a/tests/ui-toml/ref_option/ref_option.all.stderr
+++ b/tests/ui-toml/ref_option/ref_option.all.stderr
@@ -1,5 +1,5 @@
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui-toml/ref_option/ref_option.rs:8:1
+  --> tests/ui-toml/ref_option/ref_option.rs:9:1
    |
 LL | fn opt_u8(a: &Option<u8>) {}
    | ^^^^^^^^^^^^^-----------^^^^
@@ -10,7 +10,7 @@ LL | fn opt_u8(a: &Option<u8>) {}
    = help: to override `-D warnings` add `#[allow(clippy::ref_option)]`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui-toml/ref_option/ref_option.rs:10:1
+  --> tests/ui-toml/ref_option/ref_option.rs:11:1
    |
 LL | fn opt_gen<T>(a: &Option<T>) {}
    | ^^^^^^^^^^^^^^^^^----------^^^^
@@ -18,7 +18,7 @@ LL | fn opt_gen<T>(a: &Option<T>) {}
    |                  help: change this to: `Option<&T>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui-toml/ref_option/ref_option.rs:12:1
+  --> tests/ui-toml/ref_option/ref_option.rs:13:1
    |
 LL | fn opt_string(a: &std::option::Option<String>) {}
    | ^^^^^^^^^^^^^^^^^----------------------------^^^^
@@ -26,7 +26,7 @@ LL | fn opt_string(a: &std::option::Option<String>) {}
    |                  help: change this to: `std::option::Option<&String>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui-toml/ref_option/ref_option.rs:14:1
+  --> tests/ui-toml/ref_option/ref_option.rs:15:1
    |
 LL |   fn ret_u8<'a>(p: &'a str) -> &'a Option<u8> {
    |   ^                            -------------- help: change this to: `Option<&'a u8>`
@@ -38,7 +38,7 @@ LL | | }
    | |_^
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui-toml/ref_option/ref_option.rs:18:1
+  --> tests/ui-toml/ref_option/ref_option.rs:19:1
    |
 LL |   fn ret_u8_static() -> &'static Option<u8> {
    |   ^                     ------------------- help: change this to: `Option<&'static u8>`
@@ -50,7 +50,7 @@ LL | | }
    | |_^
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui-toml/ref_option/ref_option.rs:22:1
+  --> tests/ui-toml/ref_option/ref_option.rs:23:1
    |
 LL | fn mult_string(a: &Option<String>, b: &Option<Vec<u8>>) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -62,7 +62,7 @@ LL + fn mult_string(a: Option<&String>, b: Option<&Vec<u8>>) {}
    |
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui-toml/ref_option/ref_option.rs:24:1
+  --> tests/ui-toml/ref_option/ref_option.rs:25:1
    |
 LL |   fn ret_box<'a>() -> &'a Option<Box<u8>> {
    |   ^                   ------------------- help: change this to: `Option<&'a Box<u8>>`
@@ -74,7 +74,7 @@ LL | | }
    | |_^
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui-toml/ref_option/ref_option.rs:29:1
+  --> tests/ui-toml/ref_option/ref_option.rs:30:1
    |
 LL | pub fn pub_opt_string(a: &Option<String>) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^---------------^^^^
@@ -82,7 +82,7 @@ LL | pub fn pub_opt_string(a: &Option<String>) {}
    |                          help: change this to: `Option<&String>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui-toml/ref_option/ref_option.rs:31:1
+  --> tests/ui-toml/ref_option/ref_option.rs:32:1
    |
 LL | pub fn pub_mult_string(a: &Option<String>, b: &Option<Vec<u8>>) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -94,7 +94,7 @@ LL + pub fn pub_mult_string(a: Option<&String>, b: Option<&Vec<u8>>) {}
    |
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui-toml/ref_option/ref_option.rs:37:5
+  --> tests/ui-toml/ref_option/ref_option.rs:38:5
    |
 LL |     pub fn pub_opt_params(&self, a: &Option<()>) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-----------^^^^
@@ -102,7 +102,7 @@ LL |     pub fn pub_opt_params(&self, a: &Option<()>) {}
    |                                     help: change this to: `Option<&()>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui-toml/ref_option/ref_option.rs:39:5
+  --> tests/ui-toml/ref_option/ref_option.rs:40:5
    |
 LL |       pub fn pub_opt_ret(&self) -> &Option<String> {
    |       ^                            --------------- help: change this to: `Option<&String>`
@@ -114,7 +114,7 @@ LL | |     }
    | |_____^
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui-toml/ref_option/ref_option.rs:44:5
+  --> tests/ui-toml/ref_option/ref_option.rs:45:5
    |
 LL |     fn private_opt_params(&self, a: &Option<()>) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-----------^^^^
@@ -122,7 +122,7 @@ LL |     fn private_opt_params(&self, a: &Option<()>) {}
    |                                     help: change this to: `Option<&()>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui-toml/ref_option/ref_option.rs:46:5
+  --> tests/ui-toml/ref_option/ref_option.rs:47:5
    |
 LL |       fn private_opt_ret(&self) -> &Option<String> {
    |       ^                            --------------- help: change this to: `Option<&String>`
diff --git a/tests/ui-toml/ref_option/ref_option.private.fixed b/tests/ui-toml/ref_option/ref_option.private.fixed
index 396188b6d4077..4dd14a822067b 100644
--- a/tests/ui-toml/ref_option/ref_option.private.fixed
+++ b/tests/ui-toml/ref_option/ref_option.private.fixed
@@ -1,3 +1,4 @@
+//@aux-build:../../ui/auxiliary/proc_macros.rs
 //@revisions: private all
 //@[private] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/ref_option/private
 //@[all] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/ref_option/all
@@ -62,4 +63,52 @@ fn lambdas() {
     let x = |a: &Option<String>| -> &Option<String> { panic!() };
 }
 
+pub mod external {
+    proc_macros::external!(
+        fn opt_u8(a: &Option<u8>) {}
+        fn ret_u8<'a>(p: &'a str) -> &'a Option<u8> {
+            panic!()
+        }
+        pub fn pub_opt_u8(a: &Option<u8>) {}
+
+        pub struct PubStruct;
+        impl PubStruct {
+            pub fn pub_opt_params(&self, a: &Option<()>) {}
+            pub fn pub_opt_ret(&self) -> &Option<String> {
+                panic!()
+            }
+
+            fn private_opt_params(&self, a: &Option<()>) {}
+            fn private_opt_ret(&self) -> &Option<String> {
+                panic!()
+            }
+        }
+    );
+}
+
+pub mod proc_macros {
+    proc_macros::with_span!(
+        span
+
+        fn opt_u8(a: &Option<u8>) {}
+        fn ret_u8<'a>(p: &'a str) -> &'a Option<u8> {
+            panic!()
+        }
+        pub fn pub_opt_u8(a: &Option<u8>) {}
+
+        pub struct PubStruct;
+        impl PubStruct {
+            pub fn pub_opt_params(&self, a: &Option<()>) {}
+            pub fn pub_opt_ret(&self) -> &Option<String> {
+                panic!()
+            }
+
+            fn private_opt_params(&self, a: &Option<()>) {}
+            fn private_opt_ret(&self) -> &Option<String> {
+                panic!()
+            }
+        }
+    );
+}
+
 fn main() {}
diff --git a/tests/ui-toml/ref_option/ref_option.private.stderr b/tests/ui-toml/ref_option/ref_option.private.stderr
index 56f38c44f14c2..a63efd60a0368 100644
--- a/tests/ui-toml/ref_option/ref_option.private.stderr
+++ b/tests/ui-toml/ref_option/ref_option.private.stderr
@@ -1,5 +1,5 @@
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui-toml/ref_option/ref_option.rs:8:1
+  --> tests/ui-toml/ref_option/ref_option.rs:9:1
    |
 LL | fn opt_u8(a: &Option<u8>) {}
    | ^^^^^^^^^^^^^-----------^^^^
@@ -10,7 +10,7 @@ LL | fn opt_u8(a: &Option<u8>) {}
    = help: to override `-D warnings` add `#[allow(clippy::ref_option)]`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui-toml/ref_option/ref_option.rs:10:1
+  --> tests/ui-toml/ref_option/ref_option.rs:11:1
    |
 LL | fn opt_gen<T>(a: &Option<T>) {}
    | ^^^^^^^^^^^^^^^^^----------^^^^
@@ -18,7 +18,7 @@ LL | fn opt_gen<T>(a: &Option<T>) {}
    |                  help: change this to: `Option<&T>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui-toml/ref_option/ref_option.rs:12:1
+  --> tests/ui-toml/ref_option/ref_option.rs:13:1
    |
 LL | fn opt_string(a: &std::option::Option<String>) {}
    | ^^^^^^^^^^^^^^^^^----------------------------^^^^
@@ -26,7 +26,7 @@ LL | fn opt_string(a: &std::option::Option<String>) {}
    |                  help: change this to: `std::option::Option<&String>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui-toml/ref_option/ref_option.rs:14:1
+  --> tests/ui-toml/ref_option/ref_option.rs:15:1
    |
 LL |   fn ret_u8<'a>(p: &'a str) -> &'a Option<u8> {
    |   ^                            -------------- help: change this to: `Option<&'a u8>`
@@ -38,7 +38,7 @@ LL | | }
    | |_^
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui-toml/ref_option/ref_option.rs:18:1
+  --> tests/ui-toml/ref_option/ref_option.rs:19:1
    |
 LL |   fn ret_u8_static() -> &'static Option<u8> {
    |   ^                     ------------------- help: change this to: `Option<&'static u8>`
@@ -50,7 +50,7 @@ LL | | }
    | |_^
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui-toml/ref_option/ref_option.rs:22:1
+  --> tests/ui-toml/ref_option/ref_option.rs:23:1
    |
 LL | fn mult_string(a: &Option<String>, b: &Option<Vec<u8>>) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -62,7 +62,7 @@ LL + fn mult_string(a: Option<&String>, b: Option<&Vec<u8>>) {}
    |
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui-toml/ref_option/ref_option.rs:24:1
+  --> tests/ui-toml/ref_option/ref_option.rs:25:1
    |
 LL |   fn ret_box<'a>() -> &'a Option<Box<u8>> {
    |   ^                   ------------------- help: change this to: `Option<&'a Box<u8>>`
@@ -74,7 +74,7 @@ LL | | }
    | |_^
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui-toml/ref_option/ref_option.rs:44:5
+  --> tests/ui-toml/ref_option/ref_option.rs:45:5
    |
 LL |     fn private_opt_params(&self, a: &Option<()>) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-----------^^^^
@@ -82,7 +82,7 @@ LL |     fn private_opt_params(&self, a: &Option<()>) {}
    |                                     help: change this to: `Option<&()>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui-toml/ref_option/ref_option.rs:46:5
+  --> tests/ui-toml/ref_option/ref_option.rs:47:5
    |
 LL |       fn private_opt_ret(&self) -> &Option<String> {
    |       ^                            --------------- help: change this to: `Option<&String>`
diff --git a/tests/ui-toml/ref_option/ref_option.rs b/tests/ui-toml/ref_option/ref_option.rs
index 7600c58ea7038..8397c2213d172 100644
--- a/tests/ui-toml/ref_option/ref_option.rs
+++ b/tests/ui-toml/ref_option/ref_option.rs
@@ -1,3 +1,4 @@
+//@aux-build:../../ui/auxiliary/proc_macros.rs
 //@revisions: private all
 //@[private] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/ref_option/private
 //@[all] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/ref_option/all
@@ -62,4 +63,52 @@ fn lambdas() {
     let x = |a: &Option<String>| -> &Option<String> { panic!() };
 }
 
+pub mod external {
+    proc_macros::external!(
+        fn opt_u8(a: &Option<u8>) {}
+        fn ret_u8<'a>(p: &'a str) -> &'a Option<u8> {
+            panic!()
+        }
+        pub fn pub_opt_u8(a: &Option<u8>) {}
+
+        pub struct PubStruct;
+        impl PubStruct {
+            pub fn pub_opt_params(&self, a: &Option<()>) {}
+            pub fn pub_opt_ret(&self) -> &Option<String> {
+                panic!()
+            }
+
+            fn private_opt_params(&self, a: &Option<()>) {}
+            fn private_opt_ret(&self) -> &Option<String> {
+                panic!()
+            }
+        }
+    );
+}
+
+pub mod proc_macros {
+    proc_macros::with_span!(
+        span
+
+        fn opt_u8(a: &Option<u8>) {}
+        fn ret_u8<'a>(p: &'a str) -> &'a Option<u8> {
+            panic!()
+        }
+        pub fn pub_opt_u8(a: &Option<u8>) {}
+
+        pub struct PubStruct;
+        impl PubStruct {
+            pub fn pub_opt_params(&self, a: &Option<()>) {}
+            pub fn pub_opt_ret(&self) -> &Option<String> {
+                panic!()
+            }
+
+            fn private_opt_params(&self, a: &Option<()>) {}
+            fn private_opt_ret(&self) -> &Option<String> {
+                panic!()
+            }
+        }
+    );
+}
+
 fn main() {}
diff --git a/tests/ui-toml/ref_option/ref_option_traits.all.stderr b/tests/ui-toml/ref_option/ref_option_traits.all.stderr
index 61017eba176e0..602e148be6012 100644
--- a/tests/ui-toml/ref_option/ref_option_traits.all.stderr
+++ b/tests/ui-toml/ref_option/ref_option_traits.all.stderr
@@ -1,5 +1,5 @@
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui-toml/ref_option/ref_option_traits.rs:9:5
+  --> tests/ui-toml/ref_option/ref_option_traits.rs:10:5
    |
 LL |     fn pub_trait_opt(&self, a: &Option<Vec<u8>>);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^----------------^^
@@ -10,7 +10,7 @@ LL |     fn pub_trait_opt(&self, a: &Option<Vec<u8>>);
    = help: to override `-D warnings` add `#[allow(clippy::ref_option)]`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui-toml/ref_option/ref_option_traits.rs:11:5
+  --> tests/ui-toml/ref_option/ref_option_traits.rs:12:5
    |
 LL |     fn pub_trait_ret(&self) -> &Option<Vec<u8>>;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^----------------^
@@ -18,7 +18,7 @@ LL |     fn pub_trait_ret(&self) -> &Option<Vec<u8>>;
    |                                help: change this to: `Option<&Vec<u8>>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui-toml/ref_option/ref_option_traits.rs:16:5
+  --> tests/ui-toml/ref_option/ref_option_traits.rs:17:5
    |
 LL |     fn trait_opt(&self, a: &Option<String>);
    |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^^
@@ -26,7 +26,7 @@ LL |     fn trait_opt(&self, a: &Option<String>);
    |                            help: change this to: `Option<&String>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui-toml/ref_option/ref_option_traits.rs:18:5
+  --> tests/ui-toml/ref_option/ref_option_traits.rs:19:5
    |
 LL |     fn trait_ret(&self) -> &Option<String>;
    |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^
diff --git a/tests/ui-toml/ref_option/ref_option_traits.private.stderr b/tests/ui-toml/ref_option/ref_option_traits.private.stderr
index d7b0b6e9f8368..20bea400edfe6 100644
--- a/tests/ui-toml/ref_option/ref_option_traits.private.stderr
+++ b/tests/ui-toml/ref_option/ref_option_traits.private.stderr
@@ -1,5 +1,5 @@
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui-toml/ref_option/ref_option_traits.rs:16:5
+  --> tests/ui-toml/ref_option/ref_option_traits.rs:17:5
    |
 LL |     fn trait_opt(&self, a: &Option<String>);
    |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^^
@@ -10,7 +10,7 @@ LL |     fn trait_opt(&self, a: &Option<String>);
    = help: to override `-D warnings` add `#[allow(clippy::ref_option)]`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui-toml/ref_option/ref_option_traits.rs:18:5
+  --> tests/ui-toml/ref_option/ref_option_traits.rs:19:5
    |
 LL |     fn trait_ret(&self) -> &Option<String>;
    |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^
diff --git a/tests/ui-toml/ref_option/ref_option_traits.rs b/tests/ui-toml/ref_option/ref_option_traits.rs
index c02d154b448f2..e1477d7f8463d 100644
--- a/tests/ui-toml/ref_option/ref_option_traits.rs
+++ b/tests/ui-toml/ref_option/ref_option_traits.rs
@@ -1,4 +1,5 @@
 //@no-rustfix: fixes are only done to traits, not the impls
+//@aux-build:../../ui/auxiliary/proc_macros.rs
 //@revisions: private all
 //@[private] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/ref_option/private
 //@[all] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/ref_option/all
@@ -37,4 +38,34 @@ impl PrivateTrait for PrivateStruct {
     }
 }
 
+pub mod external {
+    proc_macros::external!(
+        pub trait PubTrait {
+            fn pub_trait_opt(&self, a: &Option<Vec<u8>>);
+            fn pub_trait_ret(&self) -> &Option<Vec<u8>>;
+        }
+
+        trait PrivateTrait {
+            fn trait_opt(&self, a: &Option<String>);
+            fn trait_ret(&self) -> &Option<String>;
+        }
+    );
+}
+
+pub mod proc_macros {
+    proc_macros::with_span!(
+        span
+
+        pub trait PubTrait {
+            fn pub_trait_opt(&self, a: &Option<Vec<u8>>);
+            fn pub_trait_ret(&self) -> &Option<Vec<u8>>;
+        }
+
+        trait PrivateTrait {
+            fn trait_opt(&self, a: &Option<String>);
+            fn trait_ret(&self) -> &Option<String>;
+        }
+    );
+}
+
 fn main() {}

From af82c3db6c7259860ffdbe1dfd44b305b7796988 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Tue, 9 Sep 2025 16:39:51 +0200
Subject: [PATCH 0884/1889] tiny clean-up

---
 clippy_lints/src/returns.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index e0c93153a77a8..a3e9e51bf12f0 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -162,9 +162,9 @@ impl RetReplacement<'_> {
 impl Display for RetReplacement<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::Empty => write!(f, ""),
-            Self::Block => write!(f, "{{}}"),
-            Self::Unit => write!(f, "()"),
+            Self::Empty => f.write_str(""),
+            Self::Block => f.write_str("{}"),
+            Self::Unit => f.write_str("()"),
             Self::NeedsPar(inner, _) => write!(f, "({inner})"),
             Self::Expr(inner, _) => write!(f, "{inner}"),
         }
@@ -228,7 +228,7 @@ impl<'tcx> LateLintPass<'tcx> for Return {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'_>) {
         // we need both a let-binding stmt and an expr
         if let Some(retexpr) = block.expr
-            && let Some(stmt) = block.stmts.iter().last()
+            && let Some(stmt) = block.stmts.last()
             && let StmtKind::Let(local) = &stmt.kind
             && local.ty.is_none()
             && cx.tcx.hir_attrs(local.hir_id).is_empty()
@@ -315,7 +315,7 @@ fn check_block_return<'tcx>(cx: &LateContext<'tcx>, expr_kind: &ExprKind<'tcx>,
     if let ExprKind::Block(block, _) = expr_kind {
         if let Some(block_expr) = block.expr {
             check_final_expr(cx, block_expr, semi_spans, RetReplacement::Empty, None);
-        } else if let Some(stmt) = block.stmts.iter().last() {
+        } else if let Some(stmt) = block.stmts.last() {
             match stmt.kind {
                 StmtKind::Expr(expr) => {
                     check_final_expr(cx, expr, semi_spans, RetReplacement::Empty, None);

From 51ee8d8f0ee821d8eae9c0b141f983413d6ad8d3 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Tue, 9 Sep 2025 16:01:00 +0200
Subject: [PATCH 0885/1889] split `returns` module

---
 clippy_lints/src/returns.rs                   | 513 ------------------
 clippy_lints/src/returns/let_and_return.rs    |  86 +++
 clippy_lints/src/returns/mod.rs               | 140 +++++
 clippy_lints/src/returns/needless_return.rs   | 260 +++++++++
 .../needless_return_with_question_mark.rs     |  60 ++
 tests/ui/track-diagnostics-clippy.stderr      |   2 +-
 6 files changed, 547 insertions(+), 514 deletions(-)
 delete mode 100644 clippy_lints/src/returns.rs
 create mode 100644 clippy_lints/src/returns/let_and_return.rs
 create mode 100644 clippy_lints/src/returns/mod.rs
 create mode 100644 clippy_lints/src/returns/needless_return.rs
 create mode 100644 clippy_lints/src/returns/needless_return_with_question_mark.rs

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
deleted file mode 100644
index a3e9e51bf12f0..0000000000000
--- a/clippy_lints/src/returns.rs
+++ /dev/null
@@ -1,513 +0,0 @@
-use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
-use clippy_utils::source::{SpanRangeExt, snippet_with_context};
-use clippy_utils::sugg::has_enclosing_paren;
-use clippy_utils::visitors::for_each_expr;
-use clippy_utils::{
-    binary_expr_needs_parentheses, fn_def_id, is_from_proc_macro, is_inside_let_else, is_res_lang_ctor,
-    leaks_droppable_temporary_with_limited_lifetime, path_res, path_to_local_id, span_contains_cfg,
-    span_find_starting_semi, sym,
-};
-use core::ops::ControlFlow;
-use rustc_ast::MetaItemInner;
-use rustc_errors::Applicability;
-use rustc_hir::LangItem::ResultErr;
-use rustc_hir::intravisit::FnKind;
-use rustc_hir::{
-    Block, Body, Expr, ExprKind, FnDecl, HirId, ItemKind, LangItem, MatchSource, Node, OwnerNode, PatKind, QPath, Stmt,
-    StmtKind,
-};
-use rustc_lint::{LateContext, LateLintPass, Level, LintContext};
-use rustc_middle::ty::adjustment::Adjust;
-use rustc_middle::ty::{self, GenericArgKind, Ty};
-use rustc_session::declare_lint_pass;
-use rustc_span::def_id::LocalDefId;
-use rustc_span::edition::Edition;
-use rustc_span::{BytePos, Pos, Span};
-use std::borrow::Cow;
-use std::fmt::Display;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `let`-bindings, which are subsequently
-    /// returned.
-    ///
-    /// ### Why is this bad?
-    /// It is just extraneous code. Remove it to make your code
-    /// more rusty.
-    ///
-    /// ### Known problems
-    /// In the case of some temporaries, e.g. locks, eliding the variable binding could lead
-    /// to deadlocks. See [this issue](https://github.com/rust-lang/rust/issues/37612).
-    /// This could become relevant if the code is later changed to use the code that would have been
-    /// bound without first assigning it to a let-binding.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// fn foo() -> String {
-    ///     let x = String::new();
-    ///     x
-    /// }
-    /// ```
-    /// instead, use
-    /// ```no_run
-    /// fn foo() -> String {
-    ///     String::new()
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub LET_AND_RETURN,
-    style,
-    "creating a let-binding and then immediately returning it like `let x = expr; x` at the end of a block"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for return statements at the end of a block.
-    ///
-    /// ### Why is this bad?
-    /// Removing the `return` and semicolon will make the code
-    /// more rusty.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// fn foo(x: usize) -> usize {
-    ///     return x;
-    /// }
-    /// ```
-    /// simplify to
-    /// ```no_run
-    /// fn foo(x: usize) -> usize {
-    ///     x
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub NEEDLESS_RETURN,
-    // This lint requires some special handling in `check_final_expr` for `#[expect]`.
-    // This handling needs to be updated if the group gets changed. This should also
-    // be caught by tests.
-    style,
-    "using a return statement like `return expr;` where an expression would suffice"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for return statements on `Err` paired with the `?` operator.
-    ///
-    /// ### Why is this bad?
-    /// The `return` is unnecessary.
-    ///
-    /// Returns may be used to add attributes to the return expression. Return
-    /// statements with attributes are therefore be accepted by this lint.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// fn foo(x: usize) -> Result<(), Box<dyn Error>> {
-    ///     if x == 0 {
-    ///         return Err(...)?;
-    ///     }
-    ///     Ok(())
-    /// }
-    /// ```
-    /// simplify to
-    /// ```rust,ignore
-    /// fn foo(x: usize) -> Result<(), Box<dyn Error>> {
-    ///     if x == 0 {
-    ///         Err(...)?;
-    ///     }
-    ///     Ok(())
-    /// }
-    /// ```
-    /// if paired with `try_err`, use instead:
-    /// ```rust,ignore
-    /// fn foo(x: usize) -> Result<(), Box<dyn Error>> {
-    ///     if x == 0 {
-    ///         return Err(...);
-    ///     }
-    ///     Ok(())
-    /// }
-    /// ```
-    #[clippy::version = "1.73.0"]
-    pub NEEDLESS_RETURN_WITH_QUESTION_MARK,
-    style,
-    "using a return statement like `return Err(expr)?;` where removing it would suffice"
-}
-
-#[derive(PartialEq, Eq)]
-enum RetReplacement<'tcx> {
-    Empty,
-    Block,
-    Unit,
-    NeedsPar(Cow<'tcx, str>, Applicability),
-    Expr(Cow<'tcx, str>, Applicability),
-}
-
-impl RetReplacement<'_> {
-    fn sugg_help(&self) -> &'static str {
-        match self {
-            Self::Empty | Self::Expr(..) => "remove `return`",
-            Self::Block => "replace `return` with an empty block",
-            Self::Unit => "replace `return` with a unit value",
-            Self::NeedsPar(..) => "remove `return` and wrap the sequence with parentheses",
-        }
-    }
-
-    fn applicability(&self) -> Applicability {
-        match self {
-            Self::Expr(_, ap) | Self::NeedsPar(_, ap) => *ap,
-            _ => Applicability::MachineApplicable,
-        }
-    }
-}
-
-impl Display for RetReplacement<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Empty => f.write_str(""),
-            Self::Block => f.write_str("{}"),
-            Self::Unit => f.write_str("()"),
-            Self::NeedsPar(inner, _) => write!(f, "({inner})"),
-            Self::Expr(inner, _) => write!(f, "{inner}"),
-        }
-    }
-}
-
-declare_lint_pass!(Return => [LET_AND_RETURN, NEEDLESS_RETURN, NEEDLESS_RETURN_WITH_QUESTION_MARK]);
-
-/// Checks if a return statement is "needed" in the middle of a block, or if it can be removed. This
-/// is the case when the enclosing block expression is coerced to some other type, which only works
-/// because of the never-ness of `return` expressions
-fn stmt_needs_never_type(cx: &LateContext<'_>, stmt_hir_id: HirId) -> bool {
-    cx.tcx
-        .hir_parent_iter(stmt_hir_id)
-        .find_map(|(_, node)| if let Node::Expr(expr) = node { Some(expr) } else { None })
-        .is_some_and(|e| {
-            cx.typeck_results()
-                .expr_adjustments(e)
-                .iter()
-                .any(|adjust| adjust.target != cx.tcx.types.unit && matches!(adjust.kind, Adjust::NeverToAny))
-        })
-}
-
-impl<'tcx> LateLintPass<'tcx> for Return {
-    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
-        if !stmt.span.in_external_macro(cx.sess().source_map())
-            && let StmtKind::Semi(expr) = stmt.kind
-            && let ExprKind::Ret(Some(ret)) = expr.kind
-            // return Err(...)? desugars to a match
-            // over a Err(...).branch()
-            // which breaks down to a branch call, with the callee being
-            // the constructor of the Err variant
-            && let ExprKind::Match(maybe_cons, _, MatchSource::TryDesugar(_)) = ret.kind
-            && let ExprKind::Call(_, [maybe_result_err]) = maybe_cons.kind
-            && let ExprKind::Call(maybe_constr, _) = maybe_result_err.kind
-            && is_res_lang_ctor(cx, path_res(cx, maybe_constr), ResultErr)
-
-            // Ensure this is not the final stmt, otherwise removing it would cause a compile error
-            && let OwnerNode::Item(item) = cx.tcx.hir_owner_node(cx.tcx.hir_get_parent_item(expr.hir_id))
-            && let ItemKind::Fn { body, .. } = item.kind
-            && let block = cx.tcx.hir_body(body).value
-            && let ExprKind::Block(block, _) = block.kind
-            && !is_inside_let_else(cx.tcx, expr)
-            && let [.., final_stmt] = block.stmts
-            && final_stmt.hir_id != stmt.hir_id
-            && !is_from_proc_macro(cx, expr)
-            && !stmt_needs_never_type(cx, stmt.hir_id)
-        {
-            span_lint_and_sugg(
-                cx,
-                NEEDLESS_RETURN_WITH_QUESTION_MARK,
-                expr.span.until(ret.span),
-                "unneeded `return` statement with `?` operator",
-                "remove it",
-                String::new(),
-                Applicability::MachineApplicable,
-            );
-        }
-    }
-
-    fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'_>) {
-        // we need both a let-binding stmt and an expr
-        if let Some(retexpr) = block.expr
-            && let Some(stmt) = block.stmts.last()
-            && let StmtKind::Let(local) = &stmt.kind
-            && local.ty.is_none()
-            && cx.tcx.hir_attrs(local.hir_id).is_empty()
-            && let Some(initexpr) = &local.init
-            && let PatKind::Binding(_, local_id, _, _) = local.pat.kind
-            && path_to_local_id(retexpr, local_id)
-            && (cx.sess().edition() >= Edition::Edition2024 || !last_statement_borrows(cx, initexpr))
-            && !initexpr.span.in_external_macro(cx.sess().source_map())
-            && !retexpr.span.in_external_macro(cx.sess().source_map())
-            && !local.span.from_expansion()
-            && !span_contains_cfg(cx, stmt.span.between(retexpr.span))
-        {
-            span_lint_hir_and_then(
-                cx,
-                LET_AND_RETURN,
-                retexpr.hir_id,
-                retexpr.span,
-                "returning the result of a `let` binding from a block",
-                |err| {
-                    err.span_label(local.span, "unnecessary `let` binding");
-
-                    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(&src) {
-                                format!("{src} as _")
-                            } else {
-                                format!("({src}) as _")
-                            }
-                        } else {
-                            src.to_owned()
-                        };
-                        err.multipart_suggestion(
-                            "return the expression directly",
-                            vec![(local.span, String::new()), (retexpr.span, sugg)],
-                            Applicability::MachineApplicable,
-                        );
-                    } else {
-                        err.span_help(initexpr.span, "this expression can be directly returned");
-                    }
-                },
-            );
-        }
-    }
-
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'tcx>,
-        kind: FnKind<'tcx>,
-        _: &'tcx FnDecl<'tcx>,
-        body: &'tcx Body<'tcx>,
-        sp: Span,
-        _: LocalDefId,
-    ) {
-        if sp.from_expansion() {
-            return;
-        }
-
-        match kind {
-            FnKind::Closure => {
-                // when returning without value in closure, replace this `return`
-                // with an empty block to prevent invalid suggestion (see #6501)
-                let replacement = if let ExprKind::Ret(None) = &body.value.kind {
-                    RetReplacement::Block
-                } else {
-                    RetReplacement::Empty
-                };
-                check_final_expr(cx, body.value, vec![], replacement, None);
-            },
-            FnKind::ItemFn(..) | FnKind::Method(..) => {
-                check_block_return(cx, &body.value.kind, sp, vec![]);
-            },
-        }
-    }
-}
-
-// if `expr` is a block, check if there are needless returns in it
-fn check_block_return<'tcx>(cx: &LateContext<'tcx>, expr_kind: &ExprKind<'tcx>, sp: Span, mut semi_spans: Vec<Span>) {
-    if let ExprKind::Block(block, _) = expr_kind {
-        if let Some(block_expr) = block.expr {
-            check_final_expr(cx, block_expr, semi_spans, RetReplacement::Empty, None);
-        } else if let Some(stmt) = block.stmts.last() {
-            match stmt.kind {
-                StmtKind::Expr(expr) => {
-                    check_final_expr(cx, expr, semi_spans, RetReplacement::Empty, None);
-                },
-                StmtKind::Semi(semi_expr) => {
-                    // Remove ending semicolons and any whitespace ' ' in between.
-                    // Without `return`, the suggestion might not compile if the semicolon is retained
-                    if let Some(semi_span) = stmt.span.trim_start(semi_expr.span) {
-                        let semi_span_to_remove =
-                            span_find_starting_semi(cx.sess().source_map(), semi_span.with_hi(sp.hi()));
-                        semi_spans.push(semi_span_to_remove);
-                    }
-                    check_final_expr(cx, semi_expr, semi_spans, RetReplacement::Empty, None);
-                },
-                _ => (),
-            }
-        }
-    }
-}
-
-fn check_final_expr<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx Expr<'tcx>,
-    semi_spans: Vec<Span>, /* containing all the places where we would need to remove semicolons if finding an
-                            * needless return */
-    replacement: RetReplacement<'tcx>,
-    match_ty_opt: Option<Ty<'_>>,
-) {
-    let peeled_drop_expr = expr.peel_drop_temps();
-    match &peeled_drop_expr.kind {
-        // simple return is always "bad"
-        ExprKind::Ret(inner) => {
-            // check if expr return nothing
-            let ret_span = if inner.is_none() && replacement == RetReplacement::Empty {
-                extend_span_to_previous_non_ws(cx, peeled_drop_expr.span)
-            } else {
-                peeled_drop_expr.span
-            };
-
-            let replacement = if let Some(inner_expr) = inner {
-                // if desugar of `do yeet`, don't lint
-                if let ExprKind::Call(path_expr, [_]) = inner_expr.kind
-                    && let ExprKind::Path(QPath::LangItem(LangItem::TryTraitFromYeet, ..)) = path_expr.kind
-                {
-                    return;
-                }
-
-                let mut applicability = Applicability::MachineApplicable;
-                let (snippet, _) = snippet_with_context(cx, inner_expr.span, ret_span.ctxt(), "..", &mut applicability);
-                if binary_expr_needs_parentheses(inner_expr) {
-                    RetReplacement::NeedsPar(snippet, applicability)
-                } else {
-                    RetReplacement::Expr(snippet, applicability)
-                }
-            } else {
-                match match_ty_opt {
-                    Some(match_ty) => {
-                        match match_ty.kind() {
-                            // If the code got till here with
-                            // tuple not getting detected before it,
-                            // then we are sure it's going to be Unit
-                            // type
-                            ty::Tuple(_) => RetReplacement::Unit,
-                            // We don't want to anything in this case
-                            // cause we can't predict what the user would
-                            // want here
-                            _ => return,
-                        }
-                    },
-                    None => replacement,
-                }
-            };
-
-            if inner.is_some_and(|inner| leaks_droppable_temporary_with_limited_lifetime(cx, inner)) {
-                return;
-            }
-
-            if ret_span.from_expansion() || is_from_proc_macro(cx, expr) {
-                return;
-            }
-
-            // 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 separately to
-            // actually fulfill the expectation (clippy::#12998)
-            match cx.tcx.hir_attrs(expr.hir_id) {
-                [] => {},
-                [attr] => {
-                    if matches!(Level::from_attr(attr), Some((Level::Expect, _)))
-                        && let metas = attr.meta_item_list()
-                        && let Some(lst) = metas
-                        && let [MetaItemInner::MetaItem(meta_item), ..] = lst.as_slice()
-                        && let [tool, lint_name] = meta_item.path.segments.as_slice()
-                        && tool.ident.name == sym::clippy
-                        && matches!(
-                            lint_name.ident.name,
-                            sym::needless_return | sym::style | sym::all | sym::warnings
-                        )
-                    {
-                        // This is an expectation of the `needless_return` lint
-                    } else {
-                        return;
-                    }
-                },
-                _ => return,
-            }
-
-            emit_return_lint(
-                cx,
-                peeled_drop_expr.span,
-                ret_span,
-                semi_spans,
-                &replacement,
-                expr.hir_id,
-            );
-        },
-        ExprKind::If(_, then, else_clause_opt) => {
-            check_block_return(cx, &then.kind, peeled_drop_expr.span, semi_spans.clone());
-            if let Some(else_clause) = else_clause_opt {
-                // The `RetReplacement` won't be used there as `else_clause` will be either a block or
-                // a `if` expression.
-                check_final_expr(cx, else_clause, semi_spans, RetReplacement::Empty, match_ty_opt);
-            }
-        },
-        // a match expr, check all arms
-        // an if/if let expr, check both exprs
-        // note, if without else is going to be a type checking error anyways
-        // (except for unit type functions) so we don't match it
-        ExprKind::Match(_, arms, MatchSource::Normal) => {
-            let match_ty = cx.typeck_results().expr_ty(peeled_drop_expr);
-            for arm in *arms {
-                check_final_expr(cx, arm.body, semi_spans.clone(), RetReplacement::Unit, Some(match_ty));
-            }
-        },
-        // if it's a whole block, check it
-        other_expr_kind => check_block_return(cx, other_expr_kind, peeled_drop_expr.span, semi_spans),
-    }
-}
-
-fn emit_return_lint(
-    cx: &LateContext<'_>,
-    lint_span: Span,
-    ret_span: Span,
-    semi_spans: Vec<Span>,
-    replacement: &RetReplacement<'_>,
-    at: HirId,
-) {
-    span_lint_hir_and_then(
-        cx,
-        NEEDLESS_RETURN,
-        at,
-        lint_span,
-        "unneeded `return` statement",
-        |diag| {
-            let suggestions = std::iter::once((ret_span, replacement.to_string()))
-                .chain(semi_spans.into_iter().map(|span| (span, String::new())))
-                .collect();
-
-            diag.multipart_suggestion_verbose(replacement.sugg_help(), suggestions, replacement.applicability());
-        },
-    );
-}
-
-fn last_statement_borrows<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
-    for_each_expr(cx, expr, |e| {
-        if let Some(def_id) = fn_def_id(cx, e)
-            && cx
-                .tcx
-                .fn_sig(def_id)
-                .instantiate_identity()
-                .skip_binder()
-                .output()
-                .walk()
-                .any(|arg| matches!(arg.kind(), GenericArgKind::Lifetime(re) if !re.is_static()))
-        {
-            ControlFlow::Break(())
-        } else {
-            ControlFlow::Continue(())
-        }
-    })
-    .is_some()
-}
-
-// Go backwards while encountering whitespace and extend the given Span to that point.
-fn extend_span_to_previous_non_ws(cx: &LateContext<'_>, sp: Span) -> Span {
-    if let Ok(prev_source) = cx.sess().source_map().span_to_prev_source(sp) {
-        let ws = [b' ', b'\t', b'\n'];
-        if let Some(non_ws_pos) = prev_source.bytes().rposition(|c| !ws.contains(&c)) {
-            let len = prev_source.len() - non_ws_pos - 1;
-            return sp.with_lo(sp.lo() - BytePos::from_usize(len));
-        }
-    }
-
-    sp
-}
diff --git a/clippy_lints/src/returns/let_and_return.rs b/clippy_lints/src/returns/let_and_return.rs
new file mode 100644
index 0000000000000..e2002fb36e5a6
--- /dev/null
+++ b/clippy_lints/src/returns/let_and_return.rs
@@ -0,0 +1,86 @@
+use clippy_utils::diagnostics::span_lint_hir_and_then;
+use clippy_utils::source::SpanRangeExt;
+use clippy_utils::sugg::has_enclosing_paren;
+use clippy_utils::visitors::for_each_expr;
+use clippy_utils::{binary_expr_needs_parentheses, fn_def_id, path_to_local_id, span_contains_cfg};
+use core::ops::ControlFlow;
+use rustc_errors::Applicability;
+use rustc_hir::{Block, Expr, PatKind, StmtKind};
+use rustc_lint::{LateContext, LintContext};
+use rustc_middle::ty::GenericArgKind;
+use rustc_span::edition::Edition;
+
+use super::LET_AND_RETURN;
+
+pub(super) fn check_block<'tcx>(cx: &LateContext<'tcx>, block: &'tcx Block<'_>) {
+    // we need both a let-binding stmt and an expr
+    if let Some(retexpr) = block.expr
+        && let Some(stmt) = block.stmts.last()
+        && let StmtKind::Let(local) = &stmt.kind
+        && local.ty.is_none()
+        && cx.tcx.hir_attrs(local.hir_id).is_empty()
+        && let Some(initexpr) = &local.init
+        && let PatKind::Binding(_, local_id, _, _) = local.pat.kind
+        && path_to_local_id(retexpr, local_id)
+        && (cx.sess().edition() >= Edition::Edition2024 || !last_statement_borrows(cx, initexpr))
+        && !initexpr.span.in_external_macro(cx.sess().source_map())
+        && !retexpr.span.in_external_macro(cx.sess().source_map())
+        && !local.span.from_expansion()
+        && !span_contains_cfg(cx, stmt.span.between(retexpr.span))
+    {
+        span_lint_hir_and_then(
+            cx,
+            LET_AND_RETURN,
+            retexpr.hir_id,
+            retexpr.span,
+            "returning the result of a `let` binding from a block",
+            |err| {
+                err.span_label(local.span, "unnecessary `let` binding");
+
+                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(&src) {
+                            format!("{src} as _")
+                        } else {
+                            format!("({src}) as _")
+                        }
+                    } else {
+                        src.to_owned()
+                    };
+                    err.multipart_suggestion(
+                        "return the expression directly",
+                        vec![(local.span, String::new()), (retexpr.span, sugg)],
+                        Applicability::MachineApplicable,
+                    );
+                } else {
+                    err.span_help(initexpr.span, "this expression can be directly returned");
+                }
+            },
+        );
+    }
+}
+fn last_statement_borrows<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+    for_each_expr(cx, expr, |e| {
+        if let Some(def_id) = fn_def_id(cx, e)
+            && cx
+                .tcx
+                .fn_sig(def_id)
+                .instantiate_identity()
+                .skip_binder()
+                .output()
+                .walk()
+                .any(|arg| matches!(arg.kind(), GenericArgKind::Lifetime(re) if !re.is_static()))
+        {
+            ControlFlow::Break(())
+        } else {
+            ControlFlow::Continue(())
+        }
+    })
+    .is_some()
+}
diff --git a/clippy_lints/src/returns/mod.rs b/clippy_lints/src/returns/mod.rs
new file mode 100644
index 0000000000000..47c6332b9b81d
--- /dev/null
+++ b/clippy_lints/src/returns/mod.rs
@@ -0,0 +1,140 @@
+use rustc_hir::intravisit::FnKind;
+use rustc_hir::{Block, Body, FnDecl, Stmt};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::declare_lint_pass;
+use rustc_span::Span;
+use rustc_span::def_id::LocalDefId;
+
+mod let_and_return;
+mod needless_return;
+mod needless_return_with_question_mark;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `let`-bindings, which are subsequently
+    /// returned.
+    ///
+    /// ### Why is this bad?
+    /// It is just extraneous code. Remove it to make your code
+    /// more rusty.
+    ///
+    /// ### Known problems
+    /// In the case of some temporaries, e.g. locks, eliding the variable binding could lead
+    /// to deadlocks. See [this issue](https://github.com/rust-lang/rust/issues/37612).
+    /// This could become relevant if the code is later changed to use the code that would have been
+    /// bound without first assigning it to a let-binding.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// fn foo() -> String {
+    ///     let x = String::new();
+    ///     x
+    /// }
+    /// ```
+    /// instead, use
+    /// ```no_run
+    /// fn foo() -> String {
+    ///     String::new()
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub LET_AND_RETURN,
+    style,
+    "creating a let-binding and then immediately returning it like `let x = expr; x` at the end of a block"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for return statements at the end of a block.
+    ///
+    /// ### Why is this bad?
+    /// Removing the `return` and semicolon will make the code
+    /// more rusty.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// fn foo(x: usize) -> usize {
+    ///     return x;
+    /// }
+    /// ```
+    /// simplify to
+    /// ```no_run
+    /// fn foo(x: usize) -> usize {
+    ///     x
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub NEEDLESS_RETURN,
+    // This lint requires some special handling in `check_final_expr` for `#[expect]`.
+    // This handling needs to be updated if the group gets changed. This should also
+    // be caught by tests.
+    style,
+    "using a return statement like `return expr;` where an expression would suffice"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for return statements on `Err` paired with the `?` operator.
+    ///
+    /// ### Why is this bad?
+    /// The `return` is unnecessary.
+    ///
+    /// Returns may be used to add attributes to the return expression. Return
+    /// statements with attributes are therefore be accepted by this lint.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// fn foo(x: usize) -> Result<(), Box<dyn Error>> {
+    ///     if x == 0 {
+    ///         return Err(...)?;
+    ///     }
+    ///     Ok(())
+    /// }
+    /// ```
+    /// simplify to
+    /// ```rust,ignore
+    /// fn foo(x: usize) -> Result<(), Box<dyn Error>> {
+    ///     if x == 0 {
+    ///         Err(...)?;
+    ///     }
+    ///     Ok(())
+    /// }
+    /// ```
+    /// if paired with `try_err`, use instead:
+    /// ```rust,ignore
+    /// fn foo(x: usize) -> Result<(), Box<dyn Error>> {
+    ///     if x == 0 {
+    ///         return Err(...);
+    ///     }
+    ///     Ok(())
+    /// }
+    /// ```
+    #[clippy::version = "1.73.0"]
+    pub NEEDLESS_RETURN_WITH_QUESTION_MARK,
+    style,
+    "using a return statement like `return Err(expr)?;` where removing it would suffice"
+}
+
+declare_lint_pass!(Return => [LET_AND_RETURN, NEEDLESS_RETURN, NEEDLESS_RETURN_WITH_QUESTION_MARK]);
+
+impl<'tcx> LateLintPass<'tcx> for Return {
+    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
+        needless_return_with_question_mark::check_stmt(cx, stmt);
+    }
+
+    fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'_>) {
+        let_and_return::check_block(cx, block);
+    }
+
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        kind: FnKind<'tcx>,
+        _: &'tcx FnDecl<'tcx>,
+        body: &'tcx Body<'tcx>,
+        sp: Span,
+        _: LocalDefId,
+    ) {
+        needless_return::check_fn(cx, kind, body, sp);
+    }
+}
diff --git a/clippy_lints/src/returns/needless_return.rs b/clippy_lints/src/returns/needless_return.rs
new file mode 100644
index 0000000000000..0a1ba7b5becaa
--- /dev/null
+++ b/clippy_lints/src/returns/needless_return.rs
@@ -0,0 +1,260 @@
+use clippy_utils::diagnostics::span_lint_hir_and_then;
+use clippy_utils::source::snippet_with_context;
+use clippy_utils::{
+    binary_expr_needs_parentheses, is_from_proc_macro, leaks_droppable_temporary_with_limited_lifetime,
+    span_find_starting_semi, sym,
+};
+use rustc_ast::MetaItemInner;
+use rustc_errors::Applicability;
+use rustc_hir::intravisit::FnKind;
+use rustc_hir::{Body, Expr, ExprKind, HirId, LangItem, MatchSource, QPath, StmtKind};
+use rustc_lint::{LateContext, Level, LintContext};
+use rustc_middle::ty::{self, Ty};
+use rustc_span::{BytePos, Pos, Span};
+use std::borrow::Cow;
+use std::fmt::Display;
+
+use super::NEEDLESS_RETURN;
+
+#[derive(PartialEq, Eq)]
+enum RetReplacement<'tcx> {
+    Empty,
+    Block,
+    Unit,
+    NeedsPar(Cow<'tcx, str>, Applicability),
+    Expr(Cow<'tcx, str>, Applicability),
+}
+
+impl RetReplacement<'_> {
+    fn sugg_help(&self) -> &'static str {
+        match self {
+            Self::Empty | Self::Expr(..) => "remove `return`",
+            Self::Block => "replace `return` with an empty block",
+            Self::Unit => "replace `return` with a unit value",
+            Self::NeedsPar(..) => "remove `return` and wrap the sequence with parentheses",
+        }
+    }
+
+    fn applicability(&self) -> Applicability {
+        match self {
+            Self::Expr(_, ap) | Self::NeedsPar(_, ap) => *ap,
+            _ => Applicability::MachineApplicable,
+        }
+    }
+}
+
+impl Display for RetReplacement<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Empty => f.write_str(""),
+            Self::Block => f.write_str("{}"),
+            Self::Unit => f.write_str("()"),
+            Self::NeedsPar(inner, _) => write!(f, "({inner})"),
+            Self::Expr(inner, _) => write!(f, "{inner}"),
+        }
+    }
+}
+
+pub(super) fn check_fn<'tcx>(cx: &LateContext<'tcx>, kind: FnKind<'tcx>, body: &'tcx Body<'tcx>, sp: Span) {
+    if sp.from_expansion() {
+        return;
+    }
+
+    match kind {
+        FnKind::Closure => {
+            // when returning without value in closure, replace this `return`
+            // with an empty block to prevent invalid suggestion (see #6501)
+            let replacement = if let ExprKind::Ret(None) = &body.value.kind {
+                RetReplacement::Block
+            } else {
+                RetReplacement::Empty
+            };
+            check_final_expr(cx, body.value, vec![], replacement, None);
+        },
+        FnKind::ItemFn(..) | FnKind::Method(..) => {
+            check_block_return(cx, &body.value.kind, sp, vec![]);
+        },
+    }
+}
+
+// if `expr` is a block, check if there are needless returns in it
+fn check_block_return<'tcx>(cx: &LateContext<'tcx>, expr_kind: &ExprKind<'tcx>, sp: Span, mut semi_spans: Vec<Span>) {
+    if let ExprKind::Block(block, _) = expr_kind {
+        if let Some(block_expr) = block.expr {
+            check_final_expr(cx, block_expr, semi_spans, RetReplacement::Empty, None);
+        } else if let Some(stmt) = block.stmts.last() {
+            match stmt.kind {
+                StmtKind::Expr(expr) => {
+                    check_final_expr(cx, expr, semi_spans, RetReplacement::Empty, None);
+                },
+                StmtKind::Semi(semi_expr) => {
+                    // Remove ending semicolons and any whitespace ' ' in between.
+                    // Without `return`, the suggestion might not compile if the semicolon is retained
+                    if let Some(semi_span) = stmt.span.trim_start(semi_expr.span) {
+                        let semi_span_to_remove =
+                            span_find_starting_semi(cx.sess().source_map(), semi_span.with_hi(sp.hi()));
+                        semi_spans.push(semi_span_to_remove);
+                    }
+                    check_final_expr(cx, semi_expr, semi_spans, RetReplacement::Empty, None);
+                },
+                _ => (),
+            }
+        }
+    }
+}
+
+fn check_final_expr<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    semi_spans: Vec<Span>, /* containing all the places where we would need to remove semicolons if finding an
+                            * needless return */
+    replacement: RetReplacement<'tcx>,
+    match_ty_opt: Option<Ty<'_>>,
+) {
+    let peeled_drop_expr = expr.peel_drop_temps();
+    match &peeled_drop_expr.kind {
+        // simple return is always "bad"
+        ExprKind::Ret(inner) => {
+            // check if expr return nothing
+            let ret_span = if inner.is_none() && replacement == RetReplacement::Empty {
+                extend_span_to_previous_non_ws(cx, peeled_drop_expr.span)
+            } else {
+                peeled_drop_expr.span
+            };
+
+            let replacement = if let Some(inner_expr) = inner {
+                // if desugar of `do yeet`, don't lint
+                if let ExprKind::Call(path_expr, [_]) = inner_expr.kind
+                    && let ExprKind::Path(QPath::LangItem(LangItem::TryTraitFromYeet, ..)) = path_expr.kind
+                {
+                    return;
+                }
+
+                let mut applicability = Applicability::MachineApplicable;
+                let (snippet, _) = snippet_with_context(cx, inner_expr.span, ret_span.ctxt(), "..", &mut applicability);
+                if binary_expr_needs_parentheses(inner_expr) {
+                    RetReplacement::NeedsPar(snippet, applicability)
+                } else {
+                    RetReplacement::Expr(snippet, applicability)
+                }
+            } else {
+                match match_ty_opt {
+                    Some(match_ty) => {
+                        match match_ty.kind() {
+                            // If the code got till here with
+                            // tuple not getting detected before it,
+                            // then we are sure it's going to be Unit
+                            // type
+                            ty::Tuple(_) => RetReplacement::Unit,
+                            // We don't want to anything in this case
+                            // cause we can't predict what the user would
+                            // want here
+                            _ => return,
+                        }
+                    },
+                    None => replacement,
+                }
+            };
+
+            if inner.is_some_and(|inner| leaks_droppable_temporary_with_limited_lifetime(cx, inner)) {
+                return;
+            }
+
+            if ret_span.from_expansion() || is_from_proc_macro(cx, expr) {
+                return;
+            }
+
+            // 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 separately to
+            // actually fulfill the expectation (clippy::#12998)
+            match cx.tcx.hir_attrs(expr.hir_id) {
+                [] => {},
+                [attr] => {
+                    if matches!(Level::from_attr(attr), Some((Level::Expect, _)))
+                        && let metas = attr.meta_item_list()
+                        && let Some(lst) = metas
+                        && let [MetaItemInner::MetaItem(meta_item), ..] = lst.as_slice()
+                        && let [tool, lint_name] = meta_item.path.segments.as_slice()
+                        && tool.ident.name == sym::clippy
+                        && matches!(
+                            lint_name.ident.name,
+                            sym::needless_return | sym::style | sym::all | sym::warnings
+                        )
+                    {
+                        // This is an expectation of the `needless_return` lint
+                    } else {
+                        return;
+                    }
+                },
+                _ => return,
+            }
+
+            emit_return_lint(
+                cx,
+                peeled_drop_expr.span,
+                ret_span,
+                semi_spans,
+                &replacement,
+                expr.hir_id,
+            );
+        },
+        ExprKind::If(_, then, else_clause_opt) => {
+            check_block_return(cx, &then.kind, peeled_drop_expr.span, semi_spans.clone());
+            if let Some(else_clause) = else_clause_opt {
+                // The `RetReplacement` won't be used there as `else_clause` will be either a block or
+                // a `if` expression.
+                check_final_expr(cx, else_clause, semi_spans, RetReplacement::Empty, match_ty_opt);
+            }
+        },
+        // a match expr, check all arms
+        // an if/if let expr, check both exprs
+        // note, if without else is going to be a type checking error anyways
+        // (except for unit type functions) so we don't match it
+        ExprKind::Match(_, arms, MatchSource::Normal) => {
+            let match_ty = cx.typeck_results().expr_ty(peeled_drop_expr);
+            for arm in *arms {
+                check_final_expr(cx, arm.body, semi_spans.clone(), RetReplacement::Unit, Some(match_ty));
+            }
+        },
+        // if it's a whole block, check it
+        other_expr_kind => check_block_return(cx, other_expr_kind, peeled_drop_expr.span, semi_spans),
+    }
+}
+
+fn emit_return_lint(
+    cx: &LateContext<'_>,
+    lint_span: Span,
+    ret_span: Span,
+    semi_spans: Vec<Span>,
+    replacement: &RetReplacement<'_>,
+    at: HirId,
+) {
+    span_lint_hir_and_then(
+        cx,
+        NEEDLESS_RETURN,
+        at,
+        lint_span,
+        "unneeded `return` statement",
+        |diag| {
+            let suggestions = std::iter::once((ret_span, replacement.to_string()))
+                .chain(semi_spans.into_iter().map(|span| (span, String::new())))
+                .collect();
+
+            diag.multipart_suggestion_verbose(replacement.sugg_help(), suggestions, replacement.applicability());
+        },
+    );
+}
+
+// Go backwards while encountering whitespace and extend the given Span to that point.
+fn extend_span_to_previous_non_ws(cx: &LateContext<'_>, sp: Span) -> Span {
+    if let Ok(prev_source) = cx.sess().source_map().span_to_prev_source(sp) {
+        let ws = [b' ', b'\t', b'\n'];
+        if let Some(non_ws_pos) = prev_source.bytes().rposition(|c| !ws.contains(&c)) {
+            let len = prev_source.len() - non_ws_pos - 1;
+            return sp.with_lo(sp.lo() - BytePos::from_usize(len));
+        }
+    }
+
+    sp
+}
diff --git a/clippy_lints/src/returns/needless_return_with_question_mark.rs b/clippy_lints/src/returns/needless_return_with_question_mark.rs
new file mode 100644
index 0000000000000..c05038cd1e50e
--- /dev/null
+++ b/clippy_lints/src/returns/needless_return_with_question_mark.rs
@@ -0,0 +1,60 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::{is_from_proc_macro, is_inside_let_else, is_res_lang_ctor, path_res};
+use rustc_errors::Applicability;
+use rustc_hir::LangItem::ResultErr;
+use rustc_hir::{ExprKind, HirId, ItemKind, MatchSource, Node, OwnerNode, Stmt, StmtKind};
+use rustc_lint::{LateContext, LintContext};
+use rustc_middle::ty::adjustment::Adjust;
+
+use super::NEEDLESS_RETURN_WITH_QUESTION_MARK;
+
+pub(super) fn check_stmt<'tcx>(cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
+    if !stmt.span.in_external_macro(cx.sess().source_map())
+        && let StmtKind::Semi(expr) = stmt.kind
+        && let ExprKind::Ret(Some(ret)) = expr.kind
+        // return Err(...)? desugars to a match
+        // over a Err(...).branch()
+        // which breaks down to a branch call, with the callee being
+        // the constructor of the Err variant
+        && let ExprKind::Match(maybe_cons, _, MatchSource::TryDesugar(_)) = ret.kind
+        && let ExprKind::Call(_, [maybe_result_err]) = maybe_cons.kind
+        && let ExprKind::Call(maybe_constr, _) = maybe_result_err.kind
+        && is_res_lang_ctor(cx, path_res(cx, maybe_constr), ResultErr)
+
+        // Ensure this is not the final stmt, otherwise removing it would cause a compile error
+        && let OwnerNode::Item(item) = cx.tcx.hir_owner_node(cx.tcx.hir_get_parent_item(expr.hir_id))
+        && let ItemKind::Fn { body, .. } = item.kind
+        && let block = cx.tcx.hir_body(body).value
+        && let ExprKind::Block(block, _) = block.kind
+        && !is_inside_let_else(cx.tcx, expr)
+        && let [.., final_stmt] = block.stmts
+        && final_stmt.hir_id != stmt.hir_id
+        && !is_from_proc_macro(cx, expr)
+        && !stmt_needs_never_type(cx, stmt.hir_id)
+    {
+        span_lint_and_sugg(
+            cx,
+            NEEDLESS_RETURN_WITH_QUESTION_MARK,
+            expr.span.until(ret.span),
+            "unneeded `return` statement with `?` operator",
+            "remove it",
+            String::new(),
+            Applicability::MachineApplicable,
+        );
+    }
+}
+
+/// Checks if a return statement is "needed" in the middle of a block, or if it can be removed.
+/// This is the case when the enclosing block expression is coerced to some other type,
+/// which only works because of the never-ness of `return` expressions
+fn stmt_needs_never_type(cx: &LateContext<'_>, stmt_hir_id: HirId) -> bool {
+    cx.tcx
+        .hir_parent_iter(stmt_hir_id)
+        .find_map(|(_, node)| if let Node::Expr(expr) = node { Some(expr) } else { None })
+        .is_some_and(|e| {
+            cx.typeck_results()
+                .expr_adjustments(e)
+                .iter()
+                .any(|adjust| adjust.target != cx.tcx.types.unit && matches!(adjust.kind, Adjust::NeverToAny))
+        })
+}
diff --git a/tests/ui/track-diagnostics-clippy.stderr b/tests/ui/track-diagnostics-clippy.stderr
index d5533877b4515..3ceb501463b77 100644
--- a/tests/ui/track-diagnostics-clippy.stderr
+++ b/tests/ui/track-diagnostics-clippy.stderr
@@ -16,7 +16,7 @@ LL |         let d = 42;
 LL |         d
    |         ^
    |
-   = note: -Ztrack-diagnostics: created at clippy_lints/src/returns.rs:LL:CC
+   = note: -Ztrack-diagnostics: created at clippy_lints/src/returns/let_and_return.rs:LL:CC
    = note: `-D clippy::let-and-return` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::let_and_return)]`
 help: return the expression directly

From a48c8e337d1717ceeaa930a0a804374aa2e66419 Mon Sep 17 00:00:00 2001
From: Martin Nordholts <martin.nordholts@codetale.se>
Date: Sat, 13 Sep 2025 11:24:51 +0200
Subject: [PATCH 0886/1889] compiletest: Fix `--exact` test filtering
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This fix only changes the behavior when using `--exact` test filtering,
which was quite broken. Before this fix, the following runs 0 tests:

    $ ./x test tests/run-make/crate-loading -- --exact
    running 0 tests
    test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 431 filtered out; finished in 24.95µs

With the fix the desired test is run:

    $ ./x test tests/run-make/crate-loading -- --exact
    running 1 tests
    test [run-make] tests/run-make/crate-loading ... ok

Without `--exact` the set of run tests is unchanged. This still runs
"too many" tests

    $ ./x test tests/run-make/crate-loading
    running 3 tests
    test [run-make] tests/run-make/crate-loading-crate-depends-on-itself ... ok
    test [run-make] tests/run-make/crate-loading-multiple-candidates ... ok
    test [run-make] tests/run-make/crate-loading ... ok

This still runs the one and only right test:

    $ ./x test tests/ui/lint/unused/unused-allocation.rs
    running 1 tests
    test [ui] tests/ui/lint/unused/unused-allocation.rs ... ok
---
 src/tools/compiletest/src/directives.rs       |  9 ++++-
 src/tools/compiletest/src/directives/tests.rs |  8 ++--
 src/tools/compiletest/src/executor.rs         | 11 +++++-
 src/tools/compiletest/src/lib.rs              | 37 ++++++++++++++++---
 4 files changed, 54 insertions(+), 11 deletions(-)

diff --git a/src/tools/compiletest/src/directives.rs b/src/tools/compiletest/src/directives.rs
index 857953072c436..1277fd225eb66 100644
--- a/src/tools/compiletest/src/directives.rs
+++ b/src/tools/compiletest/src/directives.rs
@@ -1446,6 +1446,7 @@ pub(crate) fn make_test_description<R: Read>(
     cache: &DirectivesCache,
     name: String,
     path: &Utf8Path,
+    filterable_path: &Utf8Path,
     src: R,
     test_revision: Option<&str>,
     poisoned: &mut bool,
@@ -1520,7 +1521,13 @@ pub(crate) fn make_test_description<R: Read>(
         _ => ShouldPanic::No,
     };
 
-    CollectedTestDesc { name, ignore, ignore_message, should_panic }
+    CollectedTestDesc {
+        name,
+        filterable_path: filterable_path.to_owned(),
+        ignore,
+        ignore_message,
+        should_panic,
+    }
 }
 
 fn ignore_cdb(config: &Config, line: &str) -> IgnoreDecision {
diff --git a/src/tools/compiletest/src/directives/tests.rs b/src/tools/compiletest/src/directives/tests.rs
index 33a02eb29fd53..16cf76be9a53f 100644
--- a/src/tools/compiletest/src/directives/tests.rs
+++ b/src/tools/compiletest/src/directives/tests.rs
@@ -14,6 +14,7 @@ fn make_test_description<R: Read>(
     config: &Config,
     name: String,
     path: &Utf8Path,
+    filterable_path: &Utf8Path,
     src: R,
     revision: Option<&str>,
 ) -> CollectedTestDesc {
@@ -24,6 +25,7 @@ fn make_test_description<R: Read>(
         &cache,
         name,
         path,
+        filterable_path,
         src,
         revision,
         &mut poisoned,
@@ -221,7 +223,7 @@ fn parse_rs(config: &Config, contents: &str) -> EarlyProps {
 fn check_ignore(config: &Config, contents: &str) -> bool {
     let tn = String::new();
     let p = Utf8Path::new("a.rs");
-    let d = make_test_description(&config, tn, p, std::io::Cursor::new(contents), None);
+    let d = make_test_description(&config, tn, p, p, std::io::Cursor::new(contents), None);
     d.ignore
 }
 
@@ -231,9 +233,9 @@ fn should_fail() {
     let tn = String::new();
     let p = Utf8Path::new("a.rs");
 
-    let d = make_test_description(&config, tn.clone(), p, std::io::Cursor::new(""), None);
+    let d = make_test_description(&config, tn.clone(), p, p, std::io::Cursor::new(""), None);
     assert_eq!(d.should_panic, ShouldPanic::No);
-    let d = make_test_description(&config, tn, p, std::io::Cursor::new("//@ should-fail"), None);
+    let d = make_test_description(&config, tn, p, p, std::io::Cursor::new("//@ should-fail"), None);
     assert_eq!(d.should_panic, ShouldPanic::Yes);
 }
 
diff --git a/src/tools/compiletest/src/executor.rs b/src/tools/compiletest/src/executor.rs
index b0dc24798b6cd..37cc17351d5fe 100644
--- a/src/tools/compiletest/src/executor.rs
+++ b/src/tools/compiletest/src/executor.rs
@@ -12,6 +12,8 @@ use std::num::NonZero;
 use std::sync::{Arc, Mutex, mpsc};
 use std::{env, hint, io, mem, panic, thread};
 
+use camino::Utf8PathBuf;
+
 use crate::common::{Config, TestPaths};
 use crate::output_capture::{self, ConsoleOut};
 use crate::panic_hook;
@@ -293,8 +295,12 @@ fn filter_tests(opts: &Config, tests: Vec<CollectedTest>) -> Vec<CollectedTest>
     let mut filtered = tests;
 
     let matches_filter = |test: &CollectedTest, filter_str: &str| {
-        let test_name = &test.desc.name;
-        if opts.filter_exact { test_name == filter_str } else { test_name.contains(filter_str) }
+        let filterable_path = test.desc.filterable_path.as_str();
+        if opts.filter_exact {
+            filterable_path == filter_str
+        } else {
+            filterable_path.contains(filter_str)
+        }
     };
 
     // Remove tests that don't match the test filter
@@ -339,6 +345,7 @@ pub(crate) struct CollectedTest {
 /// Information that was historically needed to create a libtest `TestDesc`.
 pub(crate) struct CollectedTestDesc {
     pub(crate) name: String,
+    pub(crate) filterable_path: Utf8PathBuf,
     pub(crate) ignore: bool,
     pub(crate) ignore_message: Option<Cow<'static, str>>,
     pub(crate) should_panic: ShouldPanic,
diff --git a/src/tools/compiletest/src/lib.rs b/src/tools/compiletest/src/lib.rs
index f647f96a9bf34..5e349a20ed284 100644
--- a/src/tools/compiletest/src/lib.rs
+++ b/src/tools/compiletest/src/lib.rs
@@ -317,11 +317,17 @@ pub fn parse_config(args: Vec<String>) -> Config {
             .free
             .iter()
             .map(|f| {
+                // Here `f` is relative to `./tests/run-make`. So if you run
+                //
+                //   ./x test tests/run-make/crate-loading
+                //
+                //  then `f` is "crate-loading".
                 let path = Utf8Path::new(f);
                 let mut iter = path.iter().skip(1);
 
-                // We skip the test folder and check if the user passed `rmake.rs`.
                 if iter.next().is_some_and(|s| s == "rmake.rs") && iter.next().is_none() {
+                    // Strip the "rmake.rs" suffix. For example, if `f` is
+                    // "crate-loading/rmake.rs" then this gives us "crate-loading".
                     path.parent().unwrap().to_string()
                 } else {
                     f.to_string()
@@ -329,6 +335,12 @@ pub fn parse_config(args: Vec<String>) -> Config {
             })
             .collect::<Vec<_>>()
     } else {
+        // Note that the filters are relative to the root dir of the different test
+        // suites. For example, with:
+        //
+        //   ./x test tests/ui/lint/unused
+        //
+        // the filter is "lint/unused".
         matches.free.clone()
     };
     let compare_mode = matches.opt_str("compare-mode").map(|s| {
@@ -911,7 +923,8 @@ fn make_test(cx: &TestCollectorCx, collector: &mut TestCollector, testpaths: &Te
     collector.tests.extend(revisions.into_iter().map(|revision| {
         // Create a test name and description to hand over to the executor.
         let src_file = fs::File::open(&test_path).expect("open test file to parse ignores");
-        let test_name = make_test_name(&cx.config, testpaths, revision);
+        let (test_name, filterable_path) =
+            make_test_name_and_filterable_path(&cx.config, testpaths, revision);
         // Create a description struct for the test/revision.
         // This is where `ignore-*`/`only-*`/`needs-*` directives are handled,
         // because they historically needed to set the libtest ignored flag.
@@ -920,6 +933,7 @@ fn make_test(cx: &TestCollectorCx, collector: &mut TestCollector, testpaths: &Te
             &cx.cache,
             test_name,
             &test_path,
+            &filterable_path,
             src_file,
             revision,
             &mut collector.poisoned,
@@ -1072,7 +1086,11 @@ impl Stamp {
 }
 
 /// Creates a name for this test/revision that can be handed over to the executor.
-fn make_test_name(config: &Config, testpaths: &TestPaths, revision: Option<&str>) -> String {
+fn make_test_name_and_filterable_path(
+    config: &Config,
+    testpaths: &TestPaths,
+    revision: Option<&str>,
+) -> (String, Utf8PathBuf) {
     // Print the name of the file, relative to the sources root.
     let path = testpaths.file.strip_prefix(&config.src_root).unwrap();
     let debugger = match config.debugger {
@@ -1084,14 +1102,23 @@ fn make_test_name(config: &Config, testpaths: &TestPaths, revision: Option<&str>
         None => String::new(),
     };
 
-    format!(
+    let name = format!(
         "[{}{}{}] {}{}",
         config.mode,
         debugger,
         mode_suffix,
         path,
         revision.map_or("".to_string(), |rev| format!("#{}", rev))
-    )
+    );
+
+    // `path` is the full path from the repo root like, `tests/ui/foo/bar.rs`.
+    // Filtering is applied without the `tests/ui/` part, so strip that off.
+    // First strip off "tests" to make sure we don't have some unexpected path.
+    let mut filterable_path = path.strip_prefix("tests").unwrap().to_owned();
+    // Now strip off e.g. "ui" or "run-make" component.
+    filterable_path = filterable_path.components().skip(1).collect();
+
+    (name, filterable_path)
 }
 
 /// Checks that test discovery didn't find any tests whose name stem is a prefix

From 6f3f1f3aa71c1d8dfdb86ff47255979bcfdb5cda Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sat, 13 Sep 2025 11:11:48 +0200
Subject: [PATCH 0887/1889] fix(needless_return): FP with `cfg`d code after
 `return`

---
 clippy_lints/src/returns/needless_return.rs | 11 ++++++++++-
 tests/ui/needless_return.fixed              |  7 +++++++
 tests/ui/needless_return.rs                 |  7 +++++++
 3 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/clippy_lints/src/returns/needless_return.rs b/clippy_lints/src/returns/needless_return.rs
index 0a1ba7b5becaa..04739fc1b22ad 100644
--- a/clippy_lints/src/returns/needless_return.rs
+++ b/clippy_lints/src/returns/needless_return.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::{
     binary_expr_needs_parentheses, is_from_proc_macro, leaks_droppable_temporary_with_limited_lifetime,
-    span_find_starting_semi, sym,
+    span_contains_cfg, span_find_starting_semi, sym,
 };
 use rustc_ast::MetaItemInner;
 use rustc_errors::Applicability;
@@ -83,6 +83,15 @@ fn check_block_return<'tcx>(cx: &LateContext<'tcx>, expr_kind: &ExprKind<'tcx>,
         if let Some(block_expr) = block.expr {
             check_final_expr(cx, block_expr, semi_spans, RetReplacement::Empty, None);
         } else if let Some(stmt) = block.stmts.last() {
+            if span_contains_cfg(
+                cx,
+                Span::between(
+                    stmt.span,
+                    cx.sess().source_map().end_point(block.span), // the closing brace of the block
+                ),
+            ) {
+                return;
+            }
             match stmt.kind {
                 StmtKind::Expr(expr) => {
                     check_final_expr(cx, expr, semi_spans, RetReplacement::Empty, None);
diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index d571b97f51946..f5f8bb21e815b 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -517,3 +517,10 @@ mod else_ifs {
         }
     }
 }
+
+fn issue14474() -> u64 {
+    return 456;
+
+    #[cfg(false)]
+    123
+}
diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs
index 2e4348ea338c0..495516c1c2e5d 100644
--- a/tests/ui/needless_return.rs
+++ b/tests/ui/needless_return.rs
@@ -526,3 +526,10 @@ mod else_ifs {
         }
     }
 }
+
+fn issue14474() -> u64 {
+    return 456;
+
+    #[cfg(false)]
+    123
+}

From d3b3bb9bb2e87da215ce68a6dadba35b3c9e81e0 Mon Sep 17 00:00:00 2001
From: Michele Sessa <62351258+mikysett@users.noreply.github.com>
Date: Sat, 13 Sep 2025 15:03:29 +0200
Subject: [PATCH 0888/1889] Fix small typo in check-cfg.md

---
 src/doc/rustc/src/check-cfg.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc/src/check-cfg.md b/src/doc/rustc/src/check-cfg.md
index 00add2651ae8b..4caeaa106b495 100644
--- a/src/doc/rustc/src/check-cfg.md
+++ b/src/doc/rustc/src/check-cfg.md
@@ -134,7 +134,7 @@ As of `2025-01-02T`, the list of known names is as follows:
  - `unix`
  - `windows`
 
-> Starting with 1.85.0, the `test` cfg is consider to be a "userspace" config
+> Starting with 1.85.0, the `test` cfg is considered to be a "userspace" config
 > despite being also set by `rustc` and should be managed by the build system itself.
 
 Like with `values(any())`, well known names checking can be disabled by passing `cfg(any())`

From fd851204993a2f41dd7a835cf0604d5fe16a118c Mon Sep 17 00:00:00 2001
From: Mark Rousskov <mark.simulacrum@gmail.com>
Date: Sat, 13 Sep 2025 10:09:15 -0400
Subject: [PATCH 0889/1889] Bump version to 1.92.0

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

diff --git a/src/version b/src/version
index 6979a6c0661bf..7f229af964764 100644
--- a/src/version
+++ b/src/version
@@ -1 +1 @@
-1.91.0
+1.92.0

From 365189ef4f508e4645de7607052884b8e7f413a3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Fri, 12 Sep 2025 13:54:15 -0700
Subject: [PATCH 0890/1889] update fixme in compare_method_predicate_entailment
 resulting from review of EII

---
 .../rustc_hir_analysis/src/check/compare_impl_item.rs | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
index e482725619398..222fe7b5932fd 100644
--- a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
+++ b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
@@ -298,14 +298,9 @@ fn compare_method_predicate_entailment<'tcx>(
     // compatible with that of the trait method. We do this by
     // checking that `impl_fty <: trait_fty`.
     //
-    // FIXME. Unfortunately, this doesn't quite work right now because
-    // associated type normalization is not integrated into subtype
-    // checks. For the comparison to be valid, we need to
-    // normalize the associated types in the impl/trait methods
-    // first. However, because function types bind regions, just
-    // calling `FnCtxt::normalize` would have no effect on
-    // any associated types appearing in the fn arguments or return
-    // type.
+    // FIXME: We manually instantiate the trait method here as we need
+    // to manually compute its implied bounds. Otherwise this could just
+    // be `ocx.sub(impl_sig, trait_sig)`.
 
     let mut wf_tys = FxIndexSet::default();
 

From 3d0eda7af8699b3a9dc51dc339d7d5faae753e97 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Fri, 22 Aug 2025 01:38:58 +0000
Subject: [PATCH 0891/1889] Introduce ValueSet.

---
 Cargo.lock                              |   1 +
 compiler/rustc_mir_transform/Cargo.toml |   1 +
 compiler/rustc_mir_transform/src/gvn.rs | 117 +++++++++++++++++++-----
 3 files changed, 98 insertions(+), 21 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 4677d34d2a630..328641de1e0c2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4235,6 +4235,7 @@ name = "rustc_mir_transform"
 version = "0.0.0"
 dependencies = [
  "either",
+ "hashbrown",
  "itertools",
  "rustc_abi",
  "rustc_arena",
diff --git a/compiler/rustc_mir_transform/Cargo.toml b/compiler/rustc_mir_transform/Cargo.toml
index 08c43a4648c67..511c1960e40b4 100644
--- a/compiler/rustc_mir_transform/Cargo.toml
+++ b/compiler/rustc_mir_transform/Cargo.toml
@@ -6,6 +6,7 @@ edition = "2024"
 [dependencies]
 # tidy-alphabetical-start
 either = "1"
+hashbrown = "0.15"
 itertools = "0.12"
 rustc_abi = { path = "../rustc_abi" }
 rustc_arena = { path = "../rustc_arena" }
diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index bf6aa800d20f4..3765dc5c92aef 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -85,8 +85,10 @@
 //! that contain `AllocId`s.
 
 use std::borrow::Cow;
+use std::hash::{Hash, Hasher};
 
 use either::Either;
+use hashbrown::hash_table::{Entry, HashTable};
 use itertools::Itertools as _;
 use rustc_abi::{self as abi, BackendRepr, FIRST_VARIANT, FieldIdx, Primitive, Size, VariantIdx};
 use rustc_const_eval::const_eval::DummyMachine;
@@ -94,7 +96,7 @@ use rustc_const_eval::interpret::{
     ImmTy, Immediate, InterpCx, MemPlaceMeta, MemoryKind, OpTy, Projectable, Scalar,
     intern_const_alloc_for_constprop,
 };
-use rustc_data_structures::fx::{FxIndexSet, MutableValues};
+use rustc_data_structures::fx::FxHasher;
 use rustc_data_structures::graph::dominators::Dominators;
 use rustc_hir::def::DefKind;
 use rustc_index::bit_set::DenseBitSet;
@@ -152,6 +154,7 @@ impl<'tcx> crate::MirPass<'tcx> for GVN {
 }
 
 newtype_index! {
+    #[debug_format = "_v{}"]
     struct VnIndex {}
 }
 
@@ -213,6 +216,89 @@ enum Value<'tcx> {
     },
 }
 
+/// Stores and deduplicates pairs of `(Value, Ty)` into in `VnIndex` numbered values.
+///
+/// This data structure is mostly a partial reimplementation of `FxIndexMap<VnIndex, (Value, Ty)>`.
+/// We do not use a regular `FxIndexMap` to skip hashing values that are unique by construction,
+/// like opaque values, address with provenance and non-deterministic constants.
+struct ValueSet<'tcx> {
+    indices: HashTable<VnIndex>,
+    hashes: IndexVec<VnIndex, u64>,
+    values: IndexVec<VnIndex, Value<'tcx>>,
+    types: IndexVec<VnIndex, Ty<'tcx>>,
+    /// Counter to generate different values.
+    next_opaque: usize,
+}
+
+impl<'tcx> ValueSet<'tcx> {
+    fn new(num_values: usize) -> ValueSet<'tcx> {
+        ValueSet {
+            indices: HashTable::with_capacity(num_values),
+            hashes: IndexVec::with_capacity(num_values),
+            values: IndexVec::with_capacity(num_values),
+            types: IndexVec::with_capacity(num_values),
+            next_opaque: 1,
+        }
+    }
+
+    /// Insert a `(Value, Ty)` pair to be deduplicated.
+    /// Returns `true` as second tuple field if this value did not exist previously.
+    #[allow(rustc::pass_by_value)] // closures take `&VnIndex`
+    fn insert(&mut self, ty: Ty<'tcx>, value: Value<'tcx>) -> (VnIndex, bool) {
+        let hash: u64 = {
+            let mut h = FxHasher::default();
+            value.hash(&mut h);
+            ty.hash(&mut h);
+            h.finish()
+        };
+
+        let eq = |index: &VnIndex| self.values[*index] == value && self.types[*index] == ty;
+        let hasher = |index: &VnIndex| self.hashes[*index];
+        match self.indices.entry(hash, eq, hasher) {
+            Entry::Occupied(entry) => {
+                let index = *entry.get();
+                (index, false)
+            }
+            Entry::Vacant(entry) => {
+                let index = self.hashes.push(hash);
+                entry.insert(index);
+                let _index = self.values.push(value);
+                debug_assert_eq!(index, _index);
+                let _index = self.types.push(ty);
+                debug_assert_eq!(index, _index);
+                (index, true)
+            }
+        }
+    }
+
+    /// Increment the opaque index counter return a new unique value.
+    #[inline]
+    fn next_opaque(&mut self) -> usize {
+        let next_opaque = self.next_opaque;
+        self.next_opaque += 1;
+        next_opaque
+    }
+
+    /// Return the `Value` associated with the given `VnIndex`.
+    #[inline]
+    fn value(&self, index: VnIndex) -> &Value<'tcx> {
+        &self.values[index]
+    }
+
+    /// Return the type associated with the given `VnIndex`.
+    #[inline]
+    fn ty(&self, index: VnIndex) -> Ty<'tcx> {
+        self.types[index]
+    }
+
+    /// Replace the value associated with `index` with an opaque value.
+    #[inline]
+    fn forget(&mut self, index: VnIndex) {
+        let opaque = self.next_opaque();
+        self.values[index] = Value::Opaque(opaque);
+    }
+}
+
 struct VnState<'body, 'tcx> {
     tcx: TyCtxt<'tcx>,
     ecx: InterpCx<'tcx, DummyMachine>,
@@ -223,11 +309,9 @@ struct VnState<'body, 'tcx> {
     /// Locals that are assigned that value.
     // This vector does not hold all the values of `VnIndex` that we create.
     rev_locals: IndexVec<VnIndex, SmallVec<[Local; 1]>>,
-    values: FxIndexSet<(Value<'tcx>, Ty<'tcx>)>,
+    values: ValueSet<'tcx>,
     /// Values evaluated as constants if possible.
     evaluated: IndexVec<VnIndex, Option<OpTy<'tcx>>>,
-    /// Counter to generate different values.
-    next_opaque: usize,
     /// Cache the deref values.
     derefs: Vec<VnIndex>,
     ssa: &'body SsaLocals,
@@ -258,9 +342,8 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             is_coroutine: body.coroutine.is_some(),
             locals: IndexVec::from_elem(None, local_decls),
             rev_locals: IndexVec::with_capacity(num_values),
-            values: FxIndexSet::with_capacity_and_hasher(num_values, Default::default()),
+            values: ValueSet::new(num_values),
             evaluated: IndexVec::with_capacity(num_values),
-            next_opaque: 1,
             derefs: Vec::new(),
             ssa,
             dominators,
@@ -274,8 +357,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
 
     #[instrument(level = "trace", skip(self), ret)]
     fn insert(&mut self, ty: Ty<'tcx>, value: Value<'tcx>) -> VnIndex {
-        let (index, new) = self.values.insert_full((value, ty));
-        let index = VnIndex::from_usize(index);
+        let (index, new) = self.values.insert(ty, value);
         if new {
             // Grow `evaluated` and `rev_locals` here to amortize the allocations.
             let evaluated = self.eval_to_const(index);
@@ -287,17 +369,11 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
         index
     }
 
-    fn next_opaque(&mut self) -> usize {
-        let next_opaque = self.next_opaque;
-        self.next_opaque += 1;
-        next_opaque
-    }
-
     /// Create a new `Value` for which we have no information at all, except that it is distinct
     /// from all the others.
     #[instrument(level = "trace", skip(self), ret)]
     fn new_opaque(&mut self, ty: Ty<'tcx>) -> VnIndex {
-        let value = Value::Opaque(self.next_opaque());
+        let value = Value::Opaque(self.values.next_opaque());
         self.insert(ty, value)
     }
 
@@ -311,18 +387,18 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             }
             AddressKind::Address(mutbl) => Ty::new_ptr(self.tcx, pty, mutbl.to_mutbl_lossy()),
         };
-        let value = Value::Address { place, kind, provenance: self.next_opaque() };
+        let value = Value::Address { place, kind, provenance: self.values.next_opaque() };
         self.insert(ty, value)
     }
 
     #[inline]
     fn get(&self, index: VnIndex) -> &Value<'tcx> {
-        &self.values.get_index(index.as_usize()).unwrap().0
+        self.values.value(index)
     }
 
     #[inline]
     fn ty(&self, index: VnIndex) -> Ty<'tcx> {
-        self.values.get_index(index.as_usize()).unwrap().1
+        self.values.ty(index)
     }
 
     /// Record that `local` is assigned `value`. `local` must be SSA.
@@ -340,7 +416,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
         } else {
             // Multiple mentions of this constant will yield different values,
             // so assign a different `disambiguator` to ensure they do not get the same `VnIndex`.
-            let disambiguator = self.next_opaque();
+            let disambiguator = self.values.next_opaque();
             // `disambiguator: 0` means deterministic.
             debug_assert_ne!(disambiguator, 0);
             disambiguator
@@ -374,8 +450,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
 
     fn invalidate_derefs(&mut self) {
         for deref in std::mem::take(&mut self.derefs) {
-            let opaque = self.next_opaque();
-            self.values.get_index_mut2(deref.index()).unwrap().0 = Value::Opaque(opaque);
+            self.values.forget(deref);
         }
     }
 

From 7f34f6e25f143d5c8495aca9ddafb32a87b02303 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Fri, 22 Aug 2025 01:50:21 +0000
Subject: [PATCH 0892/1889] Do not hash opaques in GVN.

---
 compiler/rustc_mir_transform/src/gvn.rs | 129 +++++++++++++++++-------
 1 file changed, 90 insertions(+), 39 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index 3765dc5c92aef..93b60aacbbaca 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -100,7 +100,7 @@ use rustc_data_structures::fx::FxHasher;
 use rustc_data_structures::graph::dominators::Dominators;
 use rustc_hir::def::DefKind;
 use rustc_index::bit_set::DenseBitSet;
-use rustc_index::{IndexVec, newtype_index};
+use rustc_index::{Idx, IndexVec, newtype_index};
 use rustc_middle::bug;
 use rustc_middle::mir::interpret::GlobalAlloc;
 use rustc_middle::mir::visit::*;
@@ -158,6 +158,14 @@ newtype_index! {
     struct VnIndex {}
 }
 
+newtype_index! {
+    /// Counter type to ensure that all unique values are created using `insert_unique`.
+    #[debug_format = "_o{}"]
+    struct VnOpaque {
+        const DETERMINISTIC = 0;
+    }
+}
+
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 enum AddressKind {
     Ref(BorrowKind),
@@ -169,14 +177,14 @@ enum Value<'tcx> {
     // Root values.
     /// Used to represent values we know nothing about.
     /// The `usize` is a counter incremented by `new_opaque`.
-    Opaque(usize),
+    Opaque(VnOpaque),
     /// Evaluated or unevaluated constant value.
     Constant {
         value: Const<'tcx>,
         /// Some constants do not have a deterministic value. To avoid merging two instances of the
         /// same `Const`, we assign them an additional integer index.
-        // `disambiguator` is 0 iff the constant is deterministic.
-        disambiguator: usize,
+        // `disambiguator` is `DETERMINISTIC` iff the constant is deterministic.
+        disambiguator: VnOpaque,
     },
     /// An aggregate value, either tuple/closure/struct/enum.
     /// This does not contain unions, as we cannot reason with the value.
@@ -195,7 +203,7 @@ enum Value<'tcx> {
         place: Place<'tcx>,
         kind: AddressKind,
         /// Give each borrow and pointer a different provenance, so we don't merge them.
-        provenance: usize,
+        provenance: VnOpaque,
     },
 
     // Extractions.
@@ -227,7 +235,7 @@ struct ValueSet<'tcx> {
     values: IndexVec<VnIndex, Value<'tcx>>,
     types: IndexVec<VnIndex, Ty<'tcx>>,
     /// Counter to generate different values.
-    next_opaque: usize,
+    next_opaque: VnOpaque,
 }
 
 impl<'tcx> ValueSet<'tcx> {
@@ -237,14 +245,45 @@ impl<'tcx> ValueSet<'tcx> {
             hashes: IndexVec::with_capacity(num_values),
             values: IndexVec::with_capacity(num_values),
             types: IndexVec::with_capacity(num_values),
-            next_opaque: 1,
+            // The first opaque is 1, as 0 means deterministic constant.
+            next_opaque: VnOpaque::from_u32(1),
         }
     }
 
+    /// Insert a `(Value, Ty)` pair without hashing or deduplication.
+    #[inline]
+    fn insert_unique(
+        &mut self,
+        ty: Ty<'tcx>,
+        value: impl FnOnce(VnOpaque) -> Value<'tcx>,
+    ) -> VnIndex {
+        let value = value(self.next_opaque);
+        self.next_opaque.increment_by(1);
+
+        debug_assert!(match value {
+            Value::Opaque(_) | Value::Address { .. } => true,
+            Value::Constant { disambiguator, .. } => disambiguator != DETERMINISTIC,
+            _ => false,
+        });
+
+        let index = self.hashes.push(0);
+        let _index = self.types.push(ty);
+        debug_assert_eq!(index, _index);
+        let _index = self.values.push(value);
+        debug_assert_eq!(index, _index);
+        index
+    }
+
     /// Insert a `(Value, Ty)` pair to be deduplicated.
     /// Returns `true` as second tuple field if this value did not exist previously.
     #[allow(rustc::pass_by_value)] // closures take `&VnIndex`
     fn insert(&mut self, ty: Ty<'tcx>, value: Value<'tcx>) -> (VnIndex, bool) {
+        debug_assert!(match value {
+            Value::Opaque(_) | Value::Address { .. } => false,
+            Value::Constant { disambiguator, .. } => disambiguator == DETERMINISTIC,
+            _ => true,
+        });
+
         let hash: u64 = {
             let mut h = FxHasher::default();
             value.hash(&mut h);
@@ -271,14 +310,6 @@ impl<'tcx> ValueSet<'tcx> {
         }
     }
 
-    /// Increment the opaque index counter return a new unique value.
-    #[inline]
-    fn next_opaque(&mut self) -> usize {
-        let next_opaque = self.next_opaque;
-        self.next_opaque += 1;
-        next_opaque
-    }
-
     /// Return the `Value` associated with the given `VnIndex`.
     #[inline]
     fn value(&self, index: VnIndex) -> &Value<'tcx> {
@@ -294,8 +325,8 @@ impl<'tcx> ValueSet<'tcx> {
     /// Replace the value associated with `index` with an opaque value.
     #[inline]
     fn forget(&mut self, index: VnIndex) {
-        let opaque = self.next_opaque();
-        self.values[index] = Value::Opaque(opaque);
+        self.values[index] = Value::Opaque(self.next_opaque);
+        self.next_opaque.increment_by(1);
     }
 }
 
@@ -373,8 +404,12 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
     /// from all the others.
     #[instrument(level = "trace", skip(self), ret)]
     fn new_opaque(&mut self, ty: Ty<'tcx>) -> VnIndex {
-        let value = Value::Opaque(self.values.next_opaque());
-        self.insert(ty, value)
+        let index = self.values.insert_unique(ty, Value::Opaque);
+        let _index = self.evaluated.push(None);
+        debug_assert_eq!(index, _index);
+        let _index = self.rev_locals.push(SmallVec::new());
+        debug_assert_eq!(index, _index);
+        index
     }
 
     /// Create a new `Value::Address` distinct from all the others.
@@ -387,8 +422,39 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             }
             AddressKind::Address(mutbl) => Ty::new_ptr(self.tcx, pty, mutbl.to_mutbl_lossy()),
         };
-        let value = Value::Address { place, kind, provenance: self.values.next_opaque() };
-        self.insert(ty, value)
+        let index =
+            self.values.insert_unique(ty, |provenance| Value::Address { place, kind, provenance });
+        let evaluated = self.eval_to_const(index);
+        let _index = self.evaluated.push(evaluated);
+        debug_assert_eq!(index, _index);
+        let _index = self.rev_locals.push(SmallVec::new());
+        debug_assert_eq!(index, _index);
+        index
+    }
+
+    #[instrument(level = "trace", skip(self), ret)]
+    fn insert_constant(&mut self, value: Const<'tcx>) -> VnIndex {
+        let (index, new) = if value.is_deterministic() {
+            // The constant is deterministic, no need to disambiguate.
+            let constant = Value::Constant { value, disambiguator: DETERMINISTIC };
+            self.values.insert(value.ty(), constant)
+        } else {
+            // Multiple mentions of this constant will yield different values,
+            // so assign a different `disambiguator` to ensure they do not get the same `VnIndex`.
+            let index = self.values.insert_unique(value.ty(), |disambiguator| {
+                debug_assert_ne!(disambiguator, DETERMINISTIC);
+                Value::Constant { value, disambiguator }
+            });
+            (index, true)
+        };
+        if new {
+            let evaluated = self.eval_to_const(index);
+            let _index = self.evaluated.push(evaluated);
+            debug_assert_eq!(index, _index);
+            let _index = self.rev_locals.push(SmallVec::new());
+            debug_assert_eq!(index, _index);
+        }
+        index
     }
 
     #[inline]
@@ -409,33 +475,18 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
         self.rev_locals[value].push(local);
     }
 
-    fn insert_constant(&mut self, value: Const<'tcx>) -> VnIndex {
-        let disambiguator = if value.is_deterministic() {
-            // The constant is deterministic, no need to disambiguate.
-            0
-        } else {
-            // Multiple mentions of this constant will yield different values,
-            // so assign a different `disambiguator` to ensure they do not get the same `VnIndex`.
-            let disambiguator = self.values.next_opaque();
-            // `disambiguator: 0` means deterministic.
-            debug_assert_ne!(disambiguator, 0);
-            disambiguator
-        };
-        self.insert(value.ty(), Value::Constant { value, disambiguator })
-    }
-
     fn insert_bool(&mut self, flag: bool) -> VnIndex {
         // Booleans are deterministic.
         let value = Const::from_bool(self.tcx, flag);
         debug_assert!(value.is_deterministic());
-        self.insert(self.tcx.types.bool, Value::Constant { value, disambiguator: 0 })
+        self.insert(self.tcx.types.bool, Value::Constant { value, disambiguator: DETERMINISTIC })
     }
 
     fn insert_scalar(&mut self, ty: Ty<'tcx>, scalar: Scalar) -> VnIndex {
         // Scalars are deterministic.
         let value = Const::from_scalar(self.tcx, scalar, ty);
         debug_assert!(value.is_deterministic());
-        self.insert(ty, Value::Constant { value, disambiguator: 0 })
+        self.insert(ty, Value::Constant { value, disambiguator: DETERMINISTIC })
     }
 
     fn insert_tuple(&mut self, ty: Ty<'tcx>, values: Vec<VnIndex>) -> VnIndex {
@@ -1680,7 +1731,7 @@ impl<'tcx> VnState<'_, 'tcx> {
         // This was already constant in MIR, do not change it. If the constant is not
         // deterministic, adding an additional mention of it in MIR will not give the same value as
         // the former mention.
-        if let Value::Constant { value, disambiguator: 0 } = *self.get(index) {
+        if let Value::Constant { value, disambiguator: DETERMINISTIC } = *self.get(index) {
             debug_assert!(value.is_deterministic());
             return Some(ConstOperand { span: DUMMY_SP, user_ty: None, const_: value });
         }

From 0a911ec97f9ce39eb52dd3e5da6232e733cdee47 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Tue, 9 Sep 2025 01:37:48 +0000
Subject: [PATCH 0893/1889] Stop counting opaques.

---
 compiler/rustc_mir_transform/src/gvn.rs | 49 ++++++++++++-------------
 1 file changed, 24 insertions(+), 25 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index 93b60aacbbaca..f8b3e5c6f8794 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -100,7 +100,7 @@ use rustc_data_structures::fx::FxHasher;
 use rustc_data_structures::graph::dominators::Dominators;
 use rustc_hir::def::DefKind;
 use rustc_index::bit_set::DenseBitSet;
-use rustc_index::{Idx, IndexVec, newtype_index};
+use rustc_index::{IndexVec, newtype_index};
 use rustc_middle::bug;
 use rustc_middle::mir::interpret::GlobalAlloc;
 use rustc_middle::mir::visit::*;
@@ -158,11 +158,16 @@ newtype_index! {
     struct VnIndex {}
 }
 
-newtype_index! {
-    /// Counter type to ensure that all unique values are created using `insert_unique`.
-    #[debug_format = "_o{}"]
-    struct VnOpaque {
-        const DETERMINISTIC = 0;
+#[derive(Copy, Clone, Debug, Eq)]
+struct VnOpaque;
+impl PartialEq for VnOpaque {
+    fn eq(&self, _: &VnOpaque) -> bool {
+        unreachable!()
+    }
+}
+impl Hash for VnOpaque {
+    fn hash<T: Hasher>(&self, _: &mut T) {
+        unreachable!()
     }
 }
 
@@ -183,8 +188,8 @@ enum Value<'tcx> {
         value: Const<'tcx>,
         /// Some constants do not have a deterministic value. To avoid merging two instances of the
         /// same `Const`, we assign them an additional integer index.
-        // `disambiguator` is `DETERMINISTIC` iff the constant is deterministic.
-        disambiguator: VnOpaque,
+        // `disambiguator` is `None` iff the constant is deterministic.
+        disambiguator: Option<VnOpaque>,
     },
     /// An aggregate value, either tuple/closure/struct/enum.
     /// This does not contain unions, as we cannot reason with the value.
@@ -234,8 +239,6 @@ struct ValueSet<'tcx> {
     hashes: IndexVec<VnIndex, u64>,
     values: IndexVec<VnIndex, Value<'tcx>>,
     types: IndexVec<VnIndex, Ty<'tcx>>,
-    /// Counter to generate different values.
-    next_opaque: VnOpaque,
 }
 
 impl<'tcx> ValueSet<'tcx> {
@@ -245,8 +248,6 @@ impl<'tcx> ValueSet<'tcx> {
             hashes: IndexVec::with_capacity(num_values),
             values: IndexVec::with_capacity(num_values),
             types: IndexVec::with_capacity(num_values),
-            // The first opaque is 1, as 0 means deterministic constant.
-            next_opaque: VnOpaque::from_u32(1),
         }
     }
 
@@ -257,12 +258,11 @@ impl<'tcx> ValueSet<'tcx> {
         ty: Ty<'tcx>,
         value: impl FnOnce(VnOpaque) -> Value<'tcx>,
     ) -> VnIndex {
-        let value = value(self.next_opaque);
-        self.next_opaque.increment_by(1);
+        let value = value(VnOpaque);
 
         debug_assert!(match value {
             Value::Opaque(_) | Value::Address { .. } => true,
-            Value::Constant { disambiguator, .. } => disambiguator != DETERMINISTIC,
+            Value::Constant { disambiguator, .. } => disambiguator.is_some(),
             _ => false,
         });
 
@@ -280,7 +280,7 @@ impl<'tcx> ValueSet<'tcx> {
     fn insert(&mut self, ty: Ty<'tcx>, value: Value<'tcx>) -> (VnIndex, bool) {
         debug_assert!(match value {
             Value::Opaque(_) | Value::Address { .. } => false,
-            Value::Constant { disambiguator, .. } => disambiguator == DETERMINISTIC,
+            Value::Constant { disambiguator, .. } => disambiguator.is_none(),
             _ => true,
         });
 
@@ -325,8 +325,7 @@ impl<'tcx> ValueSet<'tcx> {
     /// Replace the value associated with `index` with an opaque value.
     #[inline]
     fn forget(&mut self, index: VnIndex) {
-        self.values[index] = Value::Opaque(self.next_opaque);
-        self.next_opaque.increment_by(1);
+        self.values[index] = Value::Opaque(VnOpaque);
     }
 }
 
@@ -436,14 +435,14 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
     fn insert_constant(&mut self, value: Const<'tcx>) -> VnIndex {
         let (index, new) = if value.is_deterministic() {
             // The constant is deterministic, no need to disambiguate.
-            let constant = Value::Constant { value, disambiguator: DETERMINISTIC };
+            let constant = Value::Constant { value, disambiguator: None };
             self.values.insert(value.ty(), constant)
         } else {
             // Multiple mentions of this constant will yield different values,
             // so assign a different `disambiguator` to ensure they do not get the same `VnIndex`.
-            let index = self.values.insert_unique(value.ty(), |disambiguator| {
-                debug_assert_ne!(disambiguator, DETERMINISTIC);
-                Value::Constant { value, disambiguator }
+            let index = self.values.insert_unique(value.ty(), |disambiguator| Value::Constant {
+                value,
+                disambiguator: Some(disambiguator),
             });
             (index, true)
         };
@@ -479,14 +478,14 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
         // Booleans are deterministic.
         let value = Const::from_bool(self.tcx, flag);
         debug_assert!(value.is_deterministic());
-        self.insert(self.tcx.types.bool, Value::Constant { value, disambiguator: DETERMINISTIC })
+        self.insert(self.tcx.types.bool, Value::Constant { value, disambiguator: None })
     }
 
     fn insert_scalar(&mut self, ty: Ty<'tcx>, scalar: Scalar) -> VnIndex {
         // Scalars are deterministic.
         let value = Const::from_scalar(self.tcx, scalar, ty);
         debug_assert!(value.is_deterministic());
-        self.insert(ty, Value::Constant { value, disambiguator: DETERMINISTIC })
+        self.insert(ty, Value::Constant { value, disambiguator: None })
     }
 
     fn insert_tuple(&mut self, ty: Ty<'tcx>, values: Vec<VnIndex>) -> VnIndex {
@@ -1731,7 +1730,7 @@ impl<'tcx> VnState<'_, 'tcx> {
         // This was already constant in MIR, do not change it. If the constant is not
         // deterministic, adding an additional mention of it in MIR will not give the same value as
         // the former mention.
-        if let Value::Constant { value, disambiguator: DETERMINISTIC } = *self.get(index) {
+        if let Value::Constant { value, disambiguator: None } = *self.get(index) {
             debug_assert!(value.is_deterministic());
             return Some(ConstOperand { span: DUMMY_SP, user_ty: None, const_: value });
         }

From d51aec7781186ae0a7ac1073f672d08729d32f6a Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Sat, 13 Sep 2025 17:36:46 +0000
Subject: [PATCH 0894/1889] Add test.

---
 ...ap.DestinationPropagation.panic-abort.diff | 21 ++++++++
 ...p.DestinationPropagation.panic-unwind.diff | 21 ++++++++
 tests/mir-opt/dest-prop/aggregate.rs          | 49 +++++++++++++++++++
 ...ap.DestinationPropagation.panic-abort.diff | 22 +++++++++
 ...p.DestinationPropagation.panic-unwind.diff | 22 +++++++++
 5 files changed, 135 insertions(+)
 create mode 100644 tests/mir-opt/dest-prop/aggregate.rewrap.DestinationPropagation.panic-abort.diff
 create mode 100644 tests/mir-opt/dest-prop/aggregate.rewrap.DestinationPropagation.panic-unwind.diff
 create mode 100644 tests/mir-opt/dest-prop/aggregate.rs
 create mode 100644 tests/mir-opt/dest-prop/aggregate.swap.DestinationPropagation.panic-abort.diff
 create mode 100644 tests/mir-opt/dest-prop/aggregate.swap.DestinationPropagation.panic-unwind.diff

diff --git a/tests/mir-opt/dest-prop/aggregate.rewrap.DestinationPropagation.panic-abort.diff b/tests/mir-opt/dest-prop/aggregate.rewrap.DestinationPropagation.panic-abort.diff
new file mode 100644
index 0000000000000..876c871cddde0
--- /dev/null
+++ b/tests/mir-opt/dest-prop/aggregate.rewrap.DestinationPropagation.panic-abort.diff
@@ -0,0 +1,21 @@
+- // MIR for `rewrap` before DestinationPropagation
++ // MIR for `rewrap` after DestinationPropagation
+  
+  fn rewrap() -> (u8,) {
+      let mut _0: (u8,);
+      let mut _1: (u8,);
+      let mut _2: (u8,);
+  
+      bb0: {
+-         (_1.0: u8) = const 0_u8;
+-         _0 = copy _1;
+-         _2 = (copy (_0.0: u8),);
+-         _0 = copy _2;
++         (_0.0: u8) = const 0_u8;
++         nop;
++         _0 = (copy (_0.0: u8),);
++         nop;
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/dest-prop/aggregate.rewrap.DestinationPropagation.panic-unwind.diff b/tests/mir-opt/dest-prop/aggregate.rewrap.DestinationPropagation.panic-unwind.diff
new file mode 100644
index 0000000000000..876c871cddde0
--- /dev/null
+++ b/tests/mir-opt/dest-prop/aggregate.rewrap.DestinationPropagation.panic-unwind.diff
@@ -0,0 +1,21 @@
+- // MIR for `rewrap` before DestinationPropagation
++ // MIR for `rewrap` after DestinationPropagation
+  
+  fn rewrap() -> (u8,) {
+      let mut _0: (u8,);
+      let mut _1: (u8,);
+      let mut _2: (u8,);
+  
+      bb0: {
+-         (_1.0: u8) = const 0_u8;
+-         _0 = copy _1;
+-         _2 = (copy (_0.0: u8),);
+-         _0 = copy _2;
++         (_0.0: u8) = const 0_u8;
++         nop;
++         _0 = (copy (_0.0: u8),);
++         nop;
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/dest-prop/aggregate.rs b/tests/mir-opt/dest-prop/aggregate.rs
new file mode 100644
index 0000000000000..3c14d1f94f690
--- /dev/null
+++ b/tests/mir-opt/dest-prop/aggregate.rs
@@ -0,0 +1,49 @@
+//@ test-mir-pass: DestinationPropagation
+// EMIT_MIR_FOR_EACH_PANIC_STRATEGY
+
+#![feature(custom_mir, core_intrinsics)]
+#![allow(internal_features)]
+
+use std::intrinsics::mir::*;
+use std::mem::MaybeUninit;
+
+fn dump_var<T>(_: T) {}
+
+// EMIT_MIR aggregate.rewrap.DestinationPropagation.diff
+#[custom_mir(dialect = "runtime")]
+fn rewrap() -> (u8,) {
+    // CHECK-LABEL: fn rewrap(
+    // CHECK: (_0.0: u8) = const 0_u8;
+    // CHECK: _0 = (copy (_0.0: u8),);
+    mir! {
+        let _1: (u8,);
+        let _2: (u8,);
+        {
+            _1.0 = 0;
+            RET = _1;
+            _2 = (RET.0, );
+            RET = _2;
+            Return()
+        }
+    }
+}
+
+// EMIT_MIR aggregate.swap.DestinationPropagation.diff
+#[custom_mir(dialect = "runtime")]
+fn swap() -> (MaybeUninit<[u8; 10]>, MaybeUninit<[u8; 10]>) {
+    // CHECK-LABEL: fn swap(
+    // CHECK: _0 = const
+    // CHECK: _0 = (copy (_0.1: {{.*}}), copy (_0.0: {{.*}}));
+    mir! {
+        let _1: (MaybeUninit<[u8; 10]>, MaybeUninit<[u8; 10]>);
+        let _2: (MaybeUninit<[u8; 10]>, MaybeUninit<[u8; 10]>);
+        let _3: ();
+        {
+            _1 = const { (MaybeUninit::new([0; 10]), MaybeUninit::new([1; 10])) };
+            _2 = _1;
+            _1 = (_2.1, _2.0);
+            RET = _1;
+            Return()
+        }
+    }
+}
diff --git a/tests/mir-opt/dest-prop/aggregate.swap.DestinationPropagation.panic-abort.diff b/tests/mir-opt/dest-prop/aggregate.swap.DestinationPropagation.panic-abort.diff
new file mode 100644
index 0000000000000..53849573f134c
--- /dev/null
+++ b/tests/mir-opt/dest-prop/aggregate.swap.DestinationPropagation.panic-abort.diff
@@ -0,0 +1,22 @@
+- // MIR for `swap` before DestinationPropagation
++ // MIR for `swap` after DestinationPropagation
+  
+  fn swap() -> (MaybeUninit<[u8; 10]>, MaybeUninit<[u8; 10]>) {
+      let mut _0: (std::mem::MaybeUninit<[u8; 10]>, std::mem::MaybeUninit<[u8; 10]>);
+      let mut _1: (std::mem::MaybeUninit<[u8; 10]>, std::mem::MaybeUninit<[u8; 10]>);
+      let mut _2: (std::mem::MaybeUninit<[u8; 10]>, std::mem::MaybeUninit<[u8; 10]>);
+      let mut _3: ();
+  
+      bb0: {
+-         _1 = const swap::{constant#6};
+-         _2 = copy _1;
+-         _1 = (copy (_2.1: std::mem::MaybeUninit<[u8; 10]>), copy (_2.0: std::mem::MaybeUninit<[u8; 10]>));
+-         _0 = copy _1;
++         _0 = const swap::{constant#6};
++         nop;
++         _0 = (copy (_0.1: std::mem::MaybeUninit<[u8; 10]>), copy (_0.0: std::mem::MaybeUninit<[u8; 10]>));
++         nop;
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/dest-prop/aggregate.swap.DestinationPropagation.panic-unwind.diff b/tests/mir-opt/dest-prop/aggregate.swap.DestinationPropagation.panic-unwind.diff
new file mode 100644
index 0000000000000..53849573f134c
--- /dev/null
+++ b/tests/mir-opt/dest-prop/aggregate.swap.DestinationPropagation.panic-unwind.diff
@@ -0,0 +1,22 @@
+- // MIR for `swap` before DestinationPropagation
++ // MIR for `swap` after DestinationPropagation
+  
+  fn swap() -> (MaybeUninit<[u8; 10]>, MaybeUninit<[u8; 10]>) {
+      let mut _0: (std::mem::MaybeUninit<[u8; 10]>, std::mem::MaybeUninit<[u8; 10]>);
+      let mut _1: (std::mem::MaybeUninit<[u8; 10]>, std::mem::MaybeUninit<[u8; 10]>);
+      let mut _2: (std::mem::MaybeUninit<[u8; 10]>, std::mem::MaybeUninit<[u8; 10]>);
+      let mut _3: ();
+  
+      bb0: {
+-         _1 = const swap::{constant#6};
+-         _2 = copy _1;
+-         _1 = (copy (_2.1: std::mem::MaybeUninit<[u8; 10]>), copy (_2.0: std::mem::MaybeUninit<[u8; 10]>));
+-         _0 = copy _1;
++         _0 = const swap::{constant#6};
++         nop;
++         _0 = (copy (_0.1: std::mem::MaybeUninit<[u8; 10]>), copy (_0.0: std::mem::MaybeUninit<[u8; 10]>));
++         nop;
+          return;
+      }
+  }
+  

From cc9225406c75a854a9c91bd9f75ed2cbe9cee4c4 Mon Sep 17 00:00:00 2001
From: Maybe Waffle <waffle.lapkin@gmail.com>
Date: Wed, 10 May 2023 09:19:31 +0000
Subject: [PATCH 0895/1889] Document `become` keyword

---
 library/std/src/keyword_docs.rs | 99 +++++++++++++++++++++++++++++++++
 1 file changed, 99 insertions(+)

diff --git a/library/std/src/keyword_docs.rs b/library/std/src/keyword_docs.rs
index 1c55824ab9061..dc35b05b75026 100644
--- a/library/std/src/keyword_docs.rs
+++ b/library/std/src/keyword_docs.rs
@@ -1257,6 +1257,105 @@ mod ref_keyword {}
 /// [`async`]: ../std/keyword.async.html
 mod return_keyword {}
 
+#[doc(keyword = "become")]
+//
+/// Perform a tail-call of a function.
+///
+/// <div class="warning">
+///
+/// `feature(explicit_tail_calls)` is currently incomplete and may not work properly.
+/// </div>
+///
+/// When tail calling a function, instead of its stack frame being added to the
+/// stack, the stack frame of the caller is directly replaced with the callee's.
+/// This means that as long as a loop in a call graph only uses tail calls, the
+/// stack growth will be bounded.
+///
+/// This is useful for writing functional-style code (since it prevents recursion
+/// from exhausting resources) or for code optimization (since a tail call
+/// *might* be cheaper than a normal call, tail calls can be used in a similar
+/// manner to computed goto).
+///
+/// Example of using `become` to implement functional-style `fold`:
+/// ```
+/// #![feature(explicit_tail_calls)]
+/// #![expect(incomplete_features)]
+///
+/// fn fold<T: Copy, S>(slice: &[T], init: S, f: impl Fn(S, T) -> S) -> S {
+///     match slice {
+///         // without `become`, on big inputs this could easily overflow the
+///         // stack. using a tail call guarantees that the stack will not grow unboundedly
+///         [first, rest @ ..] => become fold(rest, f(init, *first), f),
+///         [] => init,
+///     }
+/// }
+/// ```
+///
+/// Compilers can already perform "tail call optimization" -- they can replace normal
+/// calls with tail calls, although there are no guarantees that this will be done.
+/// However, to perform TCO, the call needs to be the last thing that happens
+/// in the functions and be returned from it. This requirement is often broken
+/// by drop code for locals, which is run after computing the return expression:
+///
+/// ```
+/// fn example() {
+///     let string = "meow".to_owned();
+///     println!("{string}");
+///     return help(); // this is *not* the last thing that happens in `example`...
+/// }
+///
+/// // ... because it is desugared to this:
+/// fn example_desugared() {
+///     let string = "meow".to_owned();
+///     println!("{string}");
+///     let tmp = help();
+///     drop(string);
+///     return tmp;
+/// }
+///
+/// fn help() {}
+/// ```
+///
+/// For this reason, `become` also changes the drop order, such that locals are
+/// dropped *before* evaluating the call.
+///
+/// In order to guarantee that the compiler can perform a tail call, `become`
+/// currently has these requirements:
+/// 1. callee and caller must have the same ABI, arguments, and return type
+/// 2. callee and caller must not have varargs
+/// 3. callee and caller must not be marked with `#[track_caller]`
+/// 4. callee and caller cannot be a closure
+///    (unless it's coerced to a function pointer)
+///
+/// It is possible to tail-call a function pointer:
+/// ```
+/// #![feature(explicit_tail_calls)]
+/// #![expect(incomplete_features)]
+///
+/// #[derive(Copy, Clone)]
+/// enum Inst { Inc, Dec }
+///
+/// fn dispatch(stream: &[Inst], state: u32) -> u32 {
+///     const TABLE: &[fn(&[Inst], u32) -> u32] = &[increment, decrement];
+///     match stream {
+///         [inst, rest @ ..] => become TABLE[*inst as usize](rest, state),
+///         [] => state,
+///     }
+/// }
+///
+/// fn increment(stream: &[Inst], state: u32) -> u32 {
+///     become dispatch(stream, state + 1)
+/// }
+///
+/// fn decrement(stream: &[Inst], state: u32) -> u32 {
+///     become dispatch(stream, state - 1)
+/// }
+///
+/// let program = &[Inst::Inc, Inst::Inc, Inst::Dec, Inst::Inc];
+/// assert_eq!(dispatch(program, 0), 2);
+/// ```
+mod become_keyword {}
+
 #[doc(keyword = "self")]
 //
 /// The receiver of a method, or the current module.

From f13c8c21925d8226811fefaceacd414c9d8f35d9 Mon Sep 17 00:00:00 2001
From: Waffle Lapkin <waffle.lapkin@gmail.com>
Date: Sat, 13 Sep 2025 19:44:06 +0200
Subject: [PATCH 0896/1889] fixup `become` kw documentation wrt
 `#[track_caller]`

---
 library/std/src/keyword_docs.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/library/std/src/keyword_docs.rs b/library/std/src/keyword_docs.rs
index dc35b05b75026..7ff4af8ede84b 100644
--- a/library/std/src/keyword_docs.rs
+++ b/library/std/src/keyword_docs.rs
@@ -1323,7 +1323,10 @@ mod return_keyword {}
 /// currently has these requirements:
 /// 1. callee and caller must have the same ABI, arguments, and return type
 /// 2. callee and caller must not have varargs
-/// 3. callee and caller must not be marked with `#[track_caller]`
+/// 3. caller must not be marked with `#[track_caller]`
+///    - callee is allowed to be marked with `#[track_caller]` as otherwise
+///      adding `#[track_caller]` would be a breaking change. if callee is
+///      marked with `#[track_caller]` a tail call is not guaranteed.
 /// 4. callee and caller cannot be a closure
 ///    (unless it's coerced to a function pointer)
 ///

From aee7d703c58b68611785684bbb8e402c1471992b Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Sat, 13 Sep 2025 18:07:22 +0000
Subject: [PATCH 0897/1889] Mark reads in statements to avoid overlapping
 assingments.

---
 compiler/rustc_mir_transform/src/dest_prop.rs | 29 ++++++++++++-------
 ...ap.DestinationPropagation.panic-abort.diff |  6 ++--
 ...p.DestinationPropagation.panic-unwind.diff |  6 ++--
 tests/mir-opt/dest-prop/aggregate.rs          |  6 ++--
 ...ap.DestinationPropagation.panic-abort.diff |  4 +--
 ...p.DestinationPropagation.panic-unwind.diff |  4 +--
 6 files changed, 31 insertions(+), 24 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/dest_prop.rs b/compiler/rustc_mir_transform/src/dest_prop.rs
index 9ba2d274691de..7e6f39881b8b8 100644
--- a/compiler/rustc_mir_transform/src/dest_prop.rs
+++ b/compiler/rustc_mir_transform/src/dest_prop.rs
@@ -567,13 +567,15 @@ fn save_as_intervals<'tcx>(
         // the written-to locals as live in the second half of the statement.
         // We also ensure that operands read by terminators conflict with writes by that terminator.
         // For instance a function call may read args after having written to the destination.
-        VisitPlacesWith(|place, ctxt| match DefUse::for_place(place, ctxt) {
-            DefUse::Def | DefUse::Use | DefUse::PartialWrite => {
-                if let Some(relevant) = relevant.shrink[place.local] {
-                    values.insert(relevant, twostep);
+        VisitPlacesWith(|place: Place<'tcx>, ctxt| {
+            if let Some(relevant) = relevant.shrink[place.local] {
+                match DefUse::for_place(place, ctxt) {
+                    DefUse::Def | DefUse::Use | DefUse::PartialWrite => {
+                        values.insert(relevant, twostep);
+                    }
+                    DefUse::NonUse => {}
                 }
             }
-            DefUse::NonUse => {}
         })
         .visit_terminator(term, loc);
 
@@ -590,13 +592,20 @@ fn save_as_intervals<'tcx>(
             append_at(&mut values, &state, twostep);
             // Ensure we have a non-zero live range even for dead stores. This is done by marking
             // all the written-to locals as live in the second half of the statement.
-            VisitPlacesWith(|place, ctxt| match DefUse::for_place(place, ctxt) {
-                DefUse::Def | DefUse::PartialWrite => {
-                    if let Some(relevant) = relevant.shrink[place.local] {
-                        values.insert(relevant, twostep);
+            let is_simple_assignment =
+                matches!(stmt.kind, StatementKind::Assign(box (_, Rvalue::Use(_))));
+            VisitPlacesWith(|place: Place<'tcx>, ctxt| {
+                if let Some(relevant) = relevant.shrink[place.local] {
+                    match DefUse::for_place(place, ctxt) {
+                        DefUse::Def | DefUse::PartialWrite => {
+                            values.insert(relevant, twostep);
+                        }
+                        DefUse::Use if !is_simple_assignment => {
+                            values.insert(relevant, twostep);
+                        }
+                        DefUse::Use | DefUse::NonUse => {}
                     }
                 }
-                DefUse::Use | DefUse::NonUse => {}
             })
             .visit_statement(stmt, loc);
 
diff --git a/tests/mir-opt/dest-prop/aggregate.rewrap.DestinationPropagation.panic-abort.diff b/tests/mir-opt/dest-prop/aggregate.rewrap.DestinationPropagation.panic-abort.diff
index 876c871cddde0..e80660f176b7b 100644
--- a/tests/mir-opt/dest-prop/aggregate.rewrap.DestinationPropagation.panic-abort.diff
+++ b/tests/mir-opt/dest-prop/aggregate.rewrap.DestinationPropagation.panic-abort.diff
@@ -9,12 +9,10 @@
       bb0: {
 -         (_1.0: u8) = const 0_u8;
 -         _0 = copy _1;
--         _2 = (copy (_0.0: u8),);
--         _0 = copy _2;
 +         (_0.0: u8) = const 0_u8;
 +         nop;
-+         _0 = (copy (_0.0: u8),);
-+         nop;
+          _2 = (copy (_0.0: u8),);
+          _0 = copy _2;
           return;
       }
   }
diff --git a/tests/mir-opt/dest-prop/aggregate.rewrap.DestinationPropagation.panic-unwind.diff b/tests/mir-opt/dest-prop/aggregate.rewrap.DestinationPropagation.panic-unwind.diff
index 876c871cddde0..e80660f176b7b 100644
--- a/tests/mir-opt/dest-prop/aggregate.rewrap.DestinationPropagation.panic-unwind.diff
+++ b/tests/mir-opt/dest-prop/aggregate.rewrap.DestinationPropagation.panic-unwind.diff
@@ -9,12 +9,10 @@
       bb0: {
 -         (_1.0: u8) = const 0_u8;
 -         _0 = copy _1;
--         _2 = (copy (_0.0: u8),);
--         _0 = copy _2;
 +         (_0.0: u8) = const 0_u8;
 +         nop;
-+         _0 = (copy (_0.0: u8),);
-+         nop;
+          _2 = (copy (_0.0: u8),);
+          _0 = copy _2;
           return;
       }
   }
diff --git a/tests/mir-opt/dest-prop/aggregate.rs b/tests/mir-opt/dest-prop/aggregate.rs
index 3c14d1f94f690..636852159eb4c 100644
--- a/tests/mir-opt/dest-prop/aggregate.rs
+++ b/tests/mir-opt/dest-prop/aggregate.rs
@@ -14,7 +14,8 @@ fn dump_var<T>(_: T) {}
 fn rewrap() -> (u8,) {
     // CHECK-LABEL: fn rewrap(
     // CHECK: (_0.0: u8) = const 0_u8;
-    // CHECK: _0 = (copy (_0.0: u8),);
+    // CHECK: _2 = (copy (_0.0: u8),);
+    // CHECK: _0 = copy _2;
     mir! {
         let _1: (u8,);
         let _2: (u8,);
@@ -33,7 +34,8 @@ fn rewrap() -> (u8,) {
 fn swap() -> (MaybeUninit<[u8; 10]>, MaybeUninit<[u8; 10]>) {
     // CHECK-LABEL: fn swap(
     // CHECK: _0 = const
-    // CHECK: _0 = (copy (_0.1: {{.*}}), copy (_0.0: {{.*}}));
+    // CHECK: _2 = copy _0;
+    // CHECK: _0 = (copy (_2.1: {{.*}}), copy (_2.0: {{.*}}));
     mir! {
         let _1: (MaybeUninit<[u8; 10]>, MaybeUninit<[u8; 10]>);
         let _2: (MaybeUninit<[u8; 10]>, MaybeUninit<[u8; 10]>);
diff --git a/tests/mir-opt/dest-prop/aggregate.swap.DestinationPropagation.panic-abort.diff b/tests/mir-opt/dest-prop/aggregate.swap.DestinationPropagation.panic-abort.diff
index 53849573f134c..3aaad3aaf6920 100644
--- a/tests/mir-opt/dest-prop/aggregate.swap.DestinationPropagation.panic-abort.diff
+++ b/tests/mir-opt/dest-prop/aggregate.swap.DestinationPropagation.panic-abort.diff
@@ -13,8 +13,8 @@
 -         _1 = (copy (_2.1: std::mem::MaybeUninit<[u8; 10]>), copy (_2.0: std::mem::MaybeUninit<[u8; 10]>));
 -         _0 = copy _1;
 +         _0 = const swap::{constant#6};
-+         nop;
-+         _0 = (copy (_0.1: std::mem::MaybeUninit<[u8; 10]>), copy (_0.0: std::mem::MaybeUninit<[u8; 10]>));
++         _2 = copy _0;
++         _0 = (copy (_2.1: std::mem::MaybeUninit<[u8; 10]>), copy (_2.0: std::mem::MaybeUninit<[u8; 10]>));
 +         nop;
           return;
       }
diff --git a/tests/mir-opt/dest-prop/aggregate.swap.DestinationPropagation.panic-unwind.diff b/tests/mir-opt/dest-prop/aggregate.swap.DestinationPropagation.panic-unwind.diff
index 53849573f134c..3aaad3aaf6920 100644
--- a/tests/mir-opt/dest-prop/aggregate.swap.DestinationPropagation.panic-unwind.diff
+++ b/tests/mir-opt/dest-prop/aggregate.swap.DestinationPropagation.panic-unwind.diff
@@ -13,8 +13,8 @@
 -         _1 = (copy (_2.1: std::mem::MaybeUninit<[u8; 10]>), copy (_2.0: std::mem::MaybeUninit<[u8; 10]>));
 -         _0 = copy _1;
 +         _0 = const swap::{constant#6};
-+         nop;
-+         _0 = (copy (_0.1: std::mem::MaybeUninit<[u8; 10]>), copy (_0.0: std::mem::MaybeUninit<[u8; 10]>));
++         _2 = copy _0;
++         _0 = (copy (_2.1: std::mem::MaybeUninit<[u8; 10]>), copy (_2.0: std::mem::MaybeUninit<[u8; 10]>));
 +         nop;
           return;
       }

From f21d3fbce96b956283bdda0557fb73604a0fd489 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 13 Sep 2025 20:13:37 +0200
Subject: [PATCH 0898/1889] fix Condvar::wait_timeout docs

---
 library/std/src/sync/nonpoison/condvar.rs | 9 ++++-----
 library/std/src/sync/poison/condvar.rs    | 9 ++++-----
 2 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/library/std/src/sync/nonpoison/condvar.rs b/library/std/src/sync/nonpoison/condvar.rs
index 49afdd878182f..994fc6816a0d0 100644
--- a/library/std/src/sync/nonpoison/condvar.rs
+++ b/library/std/src/sync/nonpoison/condvar.rs
@@ -198,11 +198,10 @@ impl Condvar {
     /// the system time. This function is susceptible to spurious wakeups.
     /// Condition variables normally have a boolean predicate associated with
     /// them, and the predicate must always be checked each time this function
-    /// returns to protect against spurious wakeups. Additionally, it is
-    /// typically desirable for the timeout to not exceed some duration in
-    /// spite of spurious wakes, thus the sleep-duration is decremented by the
-    /// amount slept. Alternatively, use the `wait_timeout_while` method
-    /// to wait with a timeout while a predicate is true.
+    /// returns to protect against spurious wakeups.  Furthermore, since the timeout
+    /// is given relative to the moment this function is called, it needs to be adjusted
+    /// when this function is called in a loop. The [`wait_timeout_while`] method
+    /// lets you wait with a timeout while a predicate is true, taking care of all these concerns.
     ///
     /// The returned [`WaitTimeoutResult`] value indicates if the timeout is
     /// known to have elapsed.
diff --git a/library/std/src/sync/poison/condvar.rs b/library/std/src/sync/poison/condvar.rs
index 5dc2b510f3a2b..de625a6cc5f63 100644
--- a/library/std/src/sync/poison/condvar.rs
+++ b/library/std/src/sync/poison/condvar.rs
@@ -269,11 +269,10 @@ impl Condvar {
     /// the system time. This function is susceptible to spurious wakeups.
     /// Condition variables normally have a boolean predicate associated with
     /// them, and the predicate must always be checked each time this function
-    /// returns to protect against spurious wakeups. Additionally, it is
-    /// typically desirable for the timeout to not exceed some duration in
-    /// spite of spurious wakes, thus the sleep-duration is decremented by the
-    /// amount slept. Alternatively, use the `wait_timeout_while` method
-    /// to wait with a timeout while a predicate is true.
+    /// returns to protect against spurious wakeups. Furthermore, since the timeout
+    /// is given relative to the moment this function is called, it needs to be adjusted
+    /// when this function is called in a loop. The [`wait_timeout_while`] method
+    /// lets you wait with a timeout while a predicate is true, taking care of all these concerns.
     ///
     /// The returned [`WaitTimeoutResult`] value indicates if the timeout is
     /// known to have elapsed.

From 996962243670f15a88910f5c52b30fbc7b409138 Mon Sep 17 00:00:00 2001
From: Mads Marquart <mads@marquart.dk>
Date: Sat, 13 Sep 2025 20:16:58 +0200
Subject: [PATCH 0899/1889] Improve the documentation around ZERO_AR_DATE

---
 compiler/rustc_target/src/spec/base/apple/mod.rs | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/compiler/rustc_target/src/spec/base/apple/mod.rs b/compiler/rustc_target/src/spec/base/apple/mod.rs
index ecc7426416059..39e604bcce7ce 100644
--- a/compiler/rustc_target/src/spec/base/apple/mod.rs
+++ b/compiler/rustc_target/src/spec/base/apple/mod.rs
@@ -158,12 +158,22 @@ pub(crate) fn base(
             SplitDebuginfo::Off,
         ]),
 
+        // Tell the linker that we would like it to avoid irreproducible binaries.
+        //
         // This environment variable is pretty magical but is intended for
         // producing deterministic builds. This was first discovered to be used
         // by the `ar` tool as a way to control whether or not mtime entries in
-        // the archive headers were set to zero or not. It appears that
-        // eventually the linker got updated to do the same thing and now reads
-        // this environment variable too in recent versions.
+        // the archive headers were set to zero or not.
+        //
+        // In `ld64-351.8`, shipped with Xcode 9.3, the linker was updated to
+        // read this flag too. Linker versions that don't support this flag
+        // may embed modification timestamps in binaries (especially in debug
+        // information).
+        //
+        // A cleaner alternative would be to pass the `-reproducible` flag,
+        // though that is only supported since `ld64-819.6` shipped with Xcode
+        // 14, which is too new for our minimum supported version:
+        // https://doc.rust-lang.org/rustc/platform-support/apple-darwin.html#host-tooling
         //
         // For some more info see the commentary on #47086
         link_env: Cow::Borrowed(&[(Cow::Borrowed("ZERO_AR_DATE"), Cow::Borrowed("1"))]),

From afd324aa2c64bb40d4f6236e56855010591a7e90 Mon Sep 17 00:00:00 2001
From: Jonathan 'theJPster' Pallant <github@thejpster.org.uk>
Date: Sat, 13 Sep 2025 19:25:44 +0100
Subject: [PATCH 0900/1889] Note that these targets are bare-metal.

This is important to note, as it affects how easy it is to build a
binary, and that `#![no_std]` is mandatory.

A different PR should probably add this to all the other platform pages.
---
 src/doc/rustc/src/platform-support/aarch64-unknown-none.md   | 3 ++-
 src/doc/rustc/src/platform-support/armebv7r-none-eabi.md     | 3 ++-
 src/doc/rustc/src/platform-support/armv4t-none-eabi.md       | 3 ++-
 src/doc/rustc/src/platform-support/armv5te-none-eabi.md      | 3 ++-
 src/doc/rustc/src/platform-support/armv7a-none-eabi.md       | 5 +++--
 src/doc/rustc/src/platform-support/armv7r-none-eabi.md       | 3 ++-
 src/doc/rustc/src/platform-support/armv8r-none-eabihf.md     | 3 ++-
 src/doc/rustc/src/platform-support/thumbv6m-none-eabi.md     | 3 ++-
 src/doc/rustc/src/platform-support/thumbv7em-none-eabi.md    | 3 ++-
 src/doc/rustc/src/platform-support/thumbv7m-none-eabi.md     | 3 ++-
 .../rustc/src/platform-support/thumbv8m.base-none-eabi.md    | 3 ++-
 .../rustc/src/platform-support/thumbv8m.main-none-eabi.md    | 3 ++-
 12 files changed, 25 insertions(+), 13 deletions(-)

diff --git a/src/doc/rustc/src/platform-support/aarch64-unknown-none.md b/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
index 25d99e4f0dea9..7e18e8c157f74 100644
--- a/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
+++ b/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
@@ -1,6 +1,7 @@
 # `aarch64-unknown-none` and `aarch64-unknown-none-softfloat`
 
-**Tier: 2**
+* **Tier: 2**
+* **Library Support:** core and alloc (bare-metal, `#![no_std]`)
 
 Bare-metal targets for CPUs in the Armv8-A architecture family, running in AArch64 mode.
 
diff --git a/src/doc/rustc/src/platform-support/armebv7r-none-eabi.md b/src/doc/rustc/src/platform-support/armebv7r-none-eabi.md
index d5f828110f162..3e90319c373e4 100644
--- a/src/doc/rustc/src/platform-support/armebv7r-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/armebv7r-none-eabi.md
@@ -1,6 +1,7 @@
 # `armebv7r-none-eabi` and `armebv7r-none-eabihf`
 
-**Tier: 2**
+* **Tier: 2**
+* **Library Support:** core and alloc (bare-metal, `#![no_std]`)
 
 Bare-metal target for CPUs in the Armv7-R architecture family running in Big
 Endian mode. These processors support dual ARM/Thumb mode, with ARM mode as
diff --git a/src/doc/rustc/src/platform-support/armv4t-none-eabi.md b/src/doc/rustc/src/platform-support/armv4t-none-eabi.md
index 56f919e2a12b3..c6d88762fb1b7 100644
--- a/src/doc/rustc/src/platform-support/armv4t-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/armv4t-none-eabi.md
@@ -1,6 +1,7 @@
 # armv4t-none-eabi / thumbv4t-none-eabi
 
-Tier 3
+* **Tier:  3**
+* **Library Support:** core and alloc (bare-metal, `#![no_std]`)
 
 These two targets are part of the [`arm-none-eabi`](arm-none-eabi.md) target
 group, and all the information there applies.
diff --git a/src/doc/rustc/src/platform-support/armv5te-none-eabi.md b/src/doc/rustc/src/platform-support/armv5te-none-eabi.md
index 22287972b7eb9..e9f34d4ede8a1 100644
--- a/src/doc/rustc/src/platform-support/armv5te-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/armv5te-none-eabi.md
@@ -1,6 +1,7 @@
 # `armv5te-none-eabi`
 
-**Tier: 3**
+* **Tier: 3**
+* **Library Support:** core and alloc (bare-metal, `#![no_std]`)
 
 Bare-metal target for any cpu in the Armv5TE architecture family, supporting
 ARM/Thumb code interworking (aka `A32`/`T32`), with `A32` code as the default code
diff --git a/src/doc/rustc/src/platform-support/armv7a-none-eabi.md b/src/doc/rustc/src/platform-support/armv7a-none-eabi.md
index 0646e7634d7ab..3dadda86a5f54 100644
--- a/src/doc/rustc/src/platform-support/armv7a-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/armv7a-none-eabi.md
@@ -1,7 +1,8 @@
 # `armv7a-none-eabi` and `armv7a-none-eabihf`
 
-**Tier: 2** for `armv7a-none-eabi`
-**Tier: 3** for `armv7a-none-eabihf`
+* **Tier: 2** for `armv7a-none-eabi`
+* **Tier: 3** for `armv7a-none-eabihf`
+* **Library Support:** core and alloc (bare-metal, `#![no_std]`)
 
 Bare-metal target for CPUs in the Armv7-A architecture family, supporting
 dual ARM/Thumb mode, with ARM mode as the default.
diff --git a/src/doc/rustc/src/platform-support/armv7r-none-eabi.md b/src/doc/rustc/src/platform-support/armv7r-none-eabi.md
index 9cda9c502543f..c1252b4a4bf57 100644
--- a/src/doc/rustc/src/platform-support/armv7r-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/armv7r-none-eabi.md
@@ -1,6 +1,7 @@
 # `armv7r-none-eabi` and `armv7r-none-eabihf`
 
-**Tier: 2**
+* **Tier: 2**
+* **Library Support:** core and alloc (bare-metal, `#![no_std]`)
 
 Bare-metal target for CPUs in the Armv7-R architecture family, supporting
 dual ARM/Thumb mode, with ARM mode as the default.
diff --git a/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md b/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md
index eb7f8921ad0ef..0d5a36c3ee2d6 100644
--- a/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md
+++ b/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md
@@ -1,6 +1,7 @@
 # `armv8r-none-eabihf`
 
-**Tier: 3**
+* **Tier: 3**
+* **Library Support:** core and alloc (bare-metal, `#![no_std]`)
 
 Bare-metal target for CPUs in the Armv8-R architecture family, supporting
 dual ARM/Thumb mode, with ARM mode as the default.
diff --git a/src/doc/rustc/src/platform-support/thumbv6m-none-eabi.md b/src/doc/rustc/src/platform-support/thumbv6m-none-eabi.md
index ca47d96cf65f0..d4bd0b0945acf 100644
--- a/src/doc/rustc/src/platform-support/thumbv6m-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/thumbv6m-none-eabi.md
@@ -1,6 +1,7 @@
 # `thumbv6m-none-eabi`
 
-**Tier: 2**
+* **Tier: 2**
+* **Library Support:** core and alloc (bare-metal, `#![no_std]`)
 
 Bare-metal target for CPUs in the [Armv6-M] architecture family, supporting a
 subset of the [T32 ISA][t32-isa].
diff --git a/src/doc/rustc/src/platform-support/thumbv7em-none-eabi.md b/src/doc/rustc/src/platform-support/thumbv7em-none-eabi.md
index 9de708cda2424..98dcf9bd3968a 100644
--- a/src/doc/rustc/src/platform-support/thumbv7em-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/thumbv7em-none-eabi.md
@@ -1,6 +1,7 @@
 # `thumbv7em-none-eabi` and `thumbv7em-none-eabihf`
 
-**Tier: 2**
+* **Tier: 2**
+* **Library Support:** core and alloc (bare-metal, `#![no_std]`)
 
 Bare-metal target for CPUs in the [Armv7E-M] architecture family, supporting a
 subset of the [T32 ISA][t32-isa].
diff --git a/src/doc/rustc/src/platform-support/thumbv7m-none-eabi.md b/src/doc/rustc/src/platform-support/thumbv7m-none-eabi.md
index 05c9146e6d06e..d8f3970c8bfab 100644
--- a/src/doc/rustc/src/platform-support/thumbv7m-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/thumbv7m-none-eabi.md
@@ -1,6 +1,7 @@
 # `thumbv7m-none-eabi`
 
-**Tier: 2**
+* **Tier: 2**
+* **Library Support:** core and alloc (bare-metal, `#![no_std]`)
 
 Bare-metal target for CPUs in the [Armv7-M] architecture family, supporting a
 subset of the [T32 ISA][t32-isa].
diff --git a/src/doc/rustc/src/platform-support/thumbv8m.base-none-eabi.md b/src/doc/rustc/src/platform-support/thumbv8m.base-none-eabi.md
index 92585f49bd854..b16d450275df5 100644
--- a/src/doc/rustc/src/platform-support/thumbv8m.base-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/thumbv8m.base-none-eabi.md
@@ -1,6 +1,7 @@
 # `thumbv8m.base-none-eabi`
 
-**Tier: 2**
+* **Tier: 2**
+* **Library Support:** core and alloc (bare-metal, `#![no_std]`)
 
 Bare-metal target for CPUs in the Baseline [Armv8-M] architecture family,
 supporting a subset of the [T32 ISA][t32-isa].
diff --git a/src/doc/rustc/src/platform-support/thumbv8m.main-none-eabi.md b/src/doc/rustc/src/platform-support/thumbv8m.main-none-eabi.md
index 960cf31567d1e..a2d515d07ea0d 100644
--- a/src/doc/rustc/src/platform-support/thumbv8m.main-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/thumbv8m.main-none-eabi.md
@@ -1,6 +1,7 @@
 # `thumbv8m.main-none-eabi` and `thumbv8m.main-none-eabihf`
 
-**Tier: 2**
+* **Tier: 2**
+* **Library Support:** core and alloc (bare-metal, `#![no_std]`)
 
 Bare-metal target for CPUs in the Mainline [Armv8-M] architecture family,
 supporting a subset of the [T32 ISA][t32-isa].

From cd196aa72a638b627ecdcfd3495b986300af83f1 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sat, 13 Sep 2025 18:27:10 +0200
Subject: [PATCH 0901/1889] Implement `Debug` for `SourceText`

This is useful for using it with `dbg!()`.
---
 clippy_utils/src/source.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/clippy_utils/src/source.rs b/clippy_utils/src/source.rs
index e675291b6f3a7..638d329031231 100644
--- a/clippy_utils/src/source.rs
+++ b/clippy_utils/src/source.rs
@@ -215,6 +215,11 @@ impl fmt::Display for SourceText {
         self.as_str().fmt(f)
     }
 }
+impl fmt::Debug for SourceText {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.as_str().fmt(f)
+    }
+}
 
 fn get_source_range(sm: &SourceMap, sp: Range<BytePos>) -> Option<SourceFileRange> {
     let start = sm.lookup_byte_offset(sp.start);

From 61a35937861cae48b9ade326f75c00e387e6376a Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Thu, 11 Sep 2025 23:58:52 +0200
Subject: [PATCH 0902/1889] c-variadic: document `core::ffi::VaArgSafe`

and document `VaList::arg`.
---
 library/core/src/ffi/va_list.rs | 29 +++++++++++++++++++++++------
 1 file changed, 23 insertions(+), 6 deletions(-)

diff --git a/library/core/src/ffi/va_list.rs b/library/core/src/ffi/va_list.rs
index 88ad11977774d..643bd95df846d 100644
--- a/library/core/src/ffi/va_list.rs
+++ b/library/core/src/ffi/va_list.rs
@@ -202,18 +202,23 @@ mod sealed {
     impl<T> Sealed for *const T {}
 }
 
-/// Trait which permits the allowed types to be used with [`VaListImpl::arg`].
+/// Types that are valid to read using [`VaListImpl::arg`].
 ///
 /// # Safety
 ///
-/// This trait must only be implemented for types that C passes as varargs without implicit promotion.
+/// The standard library implements this trait for primitive types that are
+/// expected to have a variable argument application-binary interface (ABI) on all
+/// platforms.
 ///
-/// In C varargs, integers smaller than [`c_int`] and floats smaller than [`c_double`]
-/// are implicitly promoted to [`c_int`] and [`c_double`] respectively. Implementing this trait for
-/// types that are subject to this promotion rule is invalid.
+/// When C passes variable arguments, integers smaller than [`c_int`] and floats smaller
+/// than [`c_double`] are implicitly promoted to [`c_int`] and [`c_double`] respectively.
+/// Implementing this trait for types that are subject to this promotion rule is invalid.
 ///
 /// [`c_int`]: core::ffi::c_int
 /// [`c_double`]: core::ffi::c_double
+// We may unseal this trait in the future, but currently our `va_arg` implementations don't support
+// types with an alignment larger than 8, or with a non-scalar layout. Inline assembly can be used
+// to accept unsupported types in the meantime.
 pub unsafe trait VaArgSafe: sealed::Sealed {}
 
 // i8 and i16 are implicitly promoted to c_int in C, and cannot implement `VaArgSafe`.
@@ -233,7 +238,19 @@ unsafe impl<T> VaArgSafe for *mut T {}
 unsafe impl<T> VaArgSafe for *const T {}
 
 impl<'f> VaListImpl<'f> {
-    /// Advance to the next arg.
+    /// Advance to and read the next variable argument.
+    ///
+    /// # Safety
+    ///
+    /// This function is only sound to call when the next variable argument:
+    ///
+    /// - has a type that is ABI-compatible with the type `T`
+    /// - has a value that is a properly initialized value of type `T`
+    ///
+    /// Calling this function with an incompatible type, an invalid value, or when there
+    /// are no more variable arguments, is unsound.
+    ///
+    /// [valid]: https://doc.rust-lang.org/nightly/nomicon/what-unsafe-does.html
     #[inline]
     pub unsafe fn arg<T: VaArgSafe>(&mut self) -> T {
         // SAFETY: the caller must uphold the safety contract for `va_arg`.

From a84bb32e05d7dfa069ead63e90816e1833f107c9 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sat, 13 Sep 2025 20:49:21 +0200
Subject: [PATCH 0903/1889] c-variadic: test `...` with naked functions

---
 tests/ui/c-variadic/naked.rs | 40 ++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 tests/ui/c-variadic/naked.rs

diff --git a/tests/ui/c-variadic/naked.rs b/tests/ui/c-variadic/naked.rs
new file mode 100644
index 0000000000000..46b59395485c5
--- /dev/null
+++ b/tests/ui/c-variadic/naked.rs
@@ -0,0 +1,40 @@
+//@ run-pass
+//@ only-x86_64
+//@ only-linux
+#![feature(c_variadic)]
+
+#[repr(C)]
+#[derive(Debug, PartialEq)]
+struct Data(i32, f64);
+
+#[unsafe(naked)]
+unsafe extern "C" fn c_variadic(_: ...) -> Data {
+    // This assembly was generated with GCC, because clang/LLVM is unable to
+    // optimize out the spilling of all registers to the stack.
+    core::arch::naked_asm!(
+        "        sub     rsp, 96",
+        "        mov     QWORD PTR [rsp-88], rdi",
+        "        test    al, al",
+        "        je      .L7",
+        "        movaps  XMMWORD PTR [rsp-40], xmm0",
+        ".L7:",
+        "        lea     rax, [rsp+104]",
+        "        mov     rcx, QWORD PTR [rsp-40]",
+        "        mov     DWORD PTR [rsp-112], 0",
+        "        mov     QWORD PTR [rsp-104], rax",
+        "        lea     rax, [rsp-88]",
+        "        mov     QWORD PTR [rsp-96], rax",
+        "        movq    xmm0, rcx",
+        "        mov     eax, DWORD PTR [rsp-88]",
+        "        mov     DWORD PTR [rsp-108], 48",
+        "        add     rsp, 96",
+        "        ret",
+    )
+}
+
+fn main() {
+    unsafe {
+        assert_eq!(c_variadic(1, 2.0), Data(1, 2.0));
+        assert_eq!(c_variadic(123, 4.56), Data(123, 4.56));
+    }
+}

From d28c31a60069d6c6019341edd2b2b26d903f081c Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sat, 13 Sep 2025 20:50:56 +0200
Subject: [PATCH 0904/1889] c-variadic: check that c-variadic functions cannot
 be tail-called

as far as I can see this was not tested, though the error message was already implemented
---
 tests/ui/explicit-tail-calls/c-variadic.rs     | 14 ++++++++++++++
 tests/ui/explicit-tail-calls/c-variadic.stderr |  8 ++++++++
 2 files changed, 22 insertions(+)
 create mode 100644 tests/ui/explicit-tail-calls/c-variadic.rs
 create mode 100644 tests/ui/explicit-tail-calls/c-variadic.stderr

diff --git a/tests/ui/explicit-tail-calls/c-variadic.rs b/tests/ui/explicit-tail-calls/c-variadic.rs
new file mode 100644
index 0000000000000..e6eebe4228e52
--- /dev/null
+++ b/tests/ui/explicit-tail-calls/c-variadic.rs
@@ -0,0 +1,14 @@
+#![expect(incomplete_features)]
+#![feature(c_variadic, explicit_tail_calls)]
+#![allow(unused)]
+
+unsafe extern "C" fn foo(mut ap: ...) -> u32 {
+    ap.arg::<u32>()
+}
+
+extern "C" fn bar() -> u32 {
+    unsafe { become foo(1, 2, 3) }
+    //~^ ERROR c-variadic functions can't be tail-called
+}
+
+fn main() {}
diff --git a/tests/ui/explicit-tail-calls/c-variadic.stderr b/tests/ui/explicit-tail-calls/c-variadic.stderr
new file mode 100644
index 0000000000000..5293339d21881
--- /dev/null
+++ b/tests/ui/explicit-tail-calls/c-variadic.stderr
@@ -0,0 +1,8 @@
+error: c-variadic functions can't be tail-called
+  --> $DIR/c-variadic.rs:10:14
+   |
+LL |     unsafe { become foo(1, 2, 3) }
+   |              ^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+

From a107ea18af5274c3f7e82fa917f3bda6eeb591fe Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sat, 13 Sep 2025 20:53:42 +0200
Subject: [PATCH 0905/1889] c-variadic: check that inline attributes are
 accepted on c-variadic functions

they don't do anything, because LLVM is unable to inline c-variadic functions (on most targets, anyway)
---
 tests/codegen-llvm/cffi/c-variadic-inline.rs | 47 ++++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 tests/codegen-llvm/cffi/c-variadic-inline.rs

diff --git a/tests/codegen-llvm/cffi/c-variadic-inline.rs b/tests/codegen-llvm/cffi/c-variadic-inline.rs
new file mode 100644
index 0000000000000..369b7e571cabb
--- /dev/null
+++ b/tests/codegen-llvm/cffi/c-variadic-inline.rs
@@ -0,0 +1,47 @@
+//@ compile-flags: -C opt-level=3
+#![feature(c_variadic)]
+
+// Test that the inline attributes are accepted on C-variadic functions.
+//
+// Currently LLVM is unable to inline C-variadic functions, but that is valid because despite
+// the name even `#[inline(always)]` is just a hint.
+
+#[inline(always)]
+unsafe extern "C" fn inline_always(mut ap: ...) -> u32 {
+    ap.arg::<u32>()
+}
+
+#[inline]
+unsafe extern "C" fn inline(mut ap: ...) -> u32 {
+    ap.arg::<u32>()
+}
+
+#[inline(never)]
+unsafe extern "C" fn inline_never(mut ap: ...) -> u32 {
+    ap.arg::<u32>()
+}
+
+#[cold]
+unsafe extern "C" fn cold(mut ap: ...) -> u32 {
+    ap.arg::<u32>()
+}
+
+#[unsafe(no_mangle)]
+#[inline(never)]
+fn helper() {
+    // CHECK-LABEL: helper
+    // CHECK-LABEL: call c_variadic_inline::inline_always
+    // CHECK-LABEL: call c_variadic_inline::inline
+    // CHECK-LABEL: call c_variadic_inline::inline_never
+    // CHECK-LABEL: call c_variadic_inline::cold
+    unsafe {
+        inline_always(1);
+        inline(2);
+        inline_never(3);
+        cold(4);
+    }
+}
+
+fn main() {
+    helper()
+}

From 1ebf69d1b1a94e99c01680514571c41d0b864c15 Mon Sep 17 00:00:00 2001
From: Jo Bates <29763794+jbatez@users.noreply.github.com>
Date: Wed, 4 Jun 2025 19:49:13 -0700
Subject: [PATCH 0906/1889] initial implementation of the darwin_objc unstable
 feature

---
 compiler/rustc_attr_parsing/messages.ftl      |   8 +
 .../src/attributes/codegen_attrs.rs           |  69 +++++-
 compiler/rustc_attr_parsing/src/context.rs    |   6 +-
 .../src/session_diagnostics.rs                |  28 +++
 compiler/rustc_codegen_llvm/src/base.rs       |  24 +-
 compiler/rustc_codegen_llvm/src/common.rs     |  14 ++
 compiler/rustc_codegen_llvm/src/consts.rs     | 226 +++++++++++++++++-
 compiler/rustc_codegen_llvm/src/context.rs    |  81 ++++++-
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs   |   1 +
 compiler/rustc_codegen_llvm/src/llvm/mod.rs   |   4 +
 .../rustc_codegen_ssa/src/codegen_attrs.rs    |   6 +
 compiler/rustc_feature/src/builtin_attrs.rs   |   8 +
 .../rustc_hir/src/attrs/data_structures.rs    |   6 +
 .../rustc_hir/src/attrs/encode_cross_crate.rs |   2 +
 .../src/middle/codegen_fn_attrs.rs            |   6 +
 compiler/rustc_passes/src/check_attr.rs       |   2 +
 compiler/rustc_span/src/symbol.rs             |   2 +
 library/core/src/lib.rs                       |   1 +
 library/core/src/os/darwin/mod.rs             |  19 ++
 library/core/src/os/darwin/objc.rs            | 113 +++++++++
 library/core/src/os/mod.rs                    |  24 ++
 library/std/src/os/darwin/mod.rs              |   2 +
 library/std/src/os/darwin/objc.rs             |  13 +
 src/tools/tidy/src/pal.rs                     |   1 +
 .../codegen-llvm/auxiliary/darwin_objc_aux.rs |  27 +++
 tests/codegen-llvm/darwin-no-objc.rs          |  52 ++++
 tests/codegen-llvm/darwin-objc-abi-v1.rs      | 100 ++++++++
 tests/codegen-llvm/darwin-objc-abi-v2.rs      | 185 ++++++++++++++
 tests/codegen-llvm/darwin-objc-cross-crate.rs |  58 +++++
 tests/ui/README.md                            |   6 +
 tests/ui/darwin-objc/darwin-objc-bad-arg.rs   |  36 +++
 .../ui/darwin-objc/darwin-objc-bad-arg.stderr |  50 ++++
 tests/ui/darwin-objc/darwin-objc-bad-const.rs |  17 ++
 .../darwin-objc/darwin-objc-bad-const.stderr  |  19 ++
 tests/ui/darwin-objc/darwin-objc-bad-ref.rs   |  31 +++
 .../ui/darwin-objc/darwin-objc-bad-ref.stderr |  39 +++
 .../darwin-objc/darwin-objc-class-selector.rs |  31 +++
 tests/ui/darwin-objc/darwin-objc-class.rs     |  39 +++
 tests/ui/darwin-objc/darwin-objc-selector.rs  |  36 +++
 39 files changed, 1381 insertions(+), 11 deletions(-)
 create mode 100644 library/core/src/os/darwin/mod.rs
 create mode 100644 library/core/src/os/darwin/objc.rs
 create mode 100644 library/core/src/os/mod.rs
 create mode 100644 library/std/src/os/darwin/objc.rs
 create mode 100644 tests/codegen-llvm/auxiliary/darwin_objc_aux.rs
 create mode 100644 tests/codegen-llvm/darwin-no-objc.rs
 create mode 100644 tests/codegen-llvm/darwin-objc-abi-v1.rs
 create mode 100644 tests/codegen-llvm/darwin-objc-abi-v2.rs
 create mode 100644 tests/codegen-llvm/darwin-objc-cross-crate.rs
 create mode 100644 tests/ui/darwin-objc/darwin-objc-bad-arg.rs
 create mode 100644 tests/ui/darwin-objc/darwin-objc-bad-arg.stderr
 create mode 100644 tests/ui/darwin-objc/darwin-objc-bad-const.rs
 create mode 100644 tests/ui/darwin-objc/darwin-objc-bad-const.stderr
 create mode 100644 tests/ui/darwin-objc/darwin-objc-bad-ref.rs
 create mode 100644 tests/ui/darwin-objc/darwin-objc-bad-ref.stderr
 create mode 100644 tests/ui/darwin-objc/darwin-objc-class-selector.rs
 create mode 100644 tests/ui/darwin-objc/darwin-objc-class.rs
 create mode 100644 tests/ui/darwin-objc/darwin-objc-selector.rs

diff --git a/compiler/rustc_attr_parsing/messages.ftl b/compiler/rustc_attr_parsing/messages.ftl
index 839a5d23c3b4d..81ec17077c13c 100644
--- a/compiler/rustc_attr_parsing/messages.ftl
+++ b/compiler/rustc_attr_parsing/messages.ftl
@@ -122,6 +122,14 @@ attr_parsing_null_on_export = `export_name` may not contain null characters
 
 attr_parsing_null_on_link_section = `link_section` may not contain null characters
 
+attr_parsing_null_on_objc_class = `objc::class!` may not contain null characters
+
+attr_parsing_null_on_objc_selector = `objc::selector!` may not contain null characters
+
+attr_parsing_objc_class_expected_string_literal = `objc::class!` expected a string literal
+
+attr_parsing_objc_selector_expected_string_literal = `objc::selector!` expected a string literal
+
 attr_parsing_repr_ident =
     meta item in `repr` must be an identifier
 
diff --git a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
index d5d51f2e79ab8..262b8213977b3 100644
--- a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
@@ -2,7 +2,10 @@ use rustc_hir::attrs::{CoverageAttrKind, OptimizeAttr, SanitizerSet, UsedBy};
 use rustc_session::parse::feature_err;
 
 use super::prelude::*;
-use crate::session_diagnostics::{NakedFunctionIncompatibleAttribute, NullOnExport};
+use crate::session_diagnostics::{
+    NakedFunctionIncompatibleAttribute, NullOnExport, NullOnObjcClass, NullOnObjcSelector,
+    ObjcClassExpectedStringLiteral, ObjcSelectorExpectedStringLiteral,
+};
 
 pub(crate) struct OptimizeParser;
 
@@ -150,6 +153,70 @@ impl<S: Stage> SingleAttributeParser<S> for ExportNameParser {
     }
 }
 
+pub(crate) struct ObjcClassParser;
+
+impl<S: Stage> SingleAttributeParser<S> for ObjcClassParser {
+    const PATH: &[rustc_span::Symbol] = &[sym::rustc_objc_class];
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const ALLOWED_TARGETS: AllowedTargets =
+        AllowedTargets::AllowList(&[Allow(Target::ForeignStatic)]);
+    const TEMPLATE: AttributeTemplate = template!(NameValueStr: "ClassName");
+
+    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
+        let Some(nv) = args.name_value() else {
+            cx.expected_name_value(cx.attr_span, None);
+            return None;
+        };
+        let Some(classname) = nv.value_as_str() else {
+            // `#[rustc_objc_class = ...]` is expected to be used as an implementatioin detail
+            // inside a standard library macro, but `cx.expected_string_literal` exposes too much.
+            // Use a custom error message instead.
+            cx.emit_err(ObjcClassExpectedStringLiteral { span: nv.value_span });
+            return None;
+        };
+        if classname.as_str().contains('\0') {
+            // `#[rustc_objc_class = ...]` will be converted to a null-terminated string,
+            // so it may not contain any null characters.
+            cx.emit_err(NullOnObjcClass { span: nv.value_span });
+            return None;
+        }
+        Some(AttributeKind::ObjcClass { classname, span: cx.attr_span })
+    }
+}
+
+pub(crate) struct ObjcSelectorParser;
+
+impl<S: Stage> SingleAttributeParser<S> for ObjcSelectorParser {
+    const PATH: &[rustc_span::Symbol] = &[sym::rustc_objc_selector];
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const ALLOWED_TARGETS: AllowedTargets =
+        AllowedTargets::AllowList(&[Allow(Target::ForeignStatic)]);
+    const TEMPLATE: AttributeTemplate = template!(NameValueStr: "methodName");
+
+    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
+        let Some(nv) = args.name_value() else {
+            cx.expected_name_value(cx.attr_span, None);
+            return None;
+        };
+        let Some(methname) = nv.value_as_str() else {
+            // `#[rustc_objc_selector = ...]` is expected to be used as an implementatioin detail
+            // inside a standard library macro, but `cx.expected_string_literal` exposes too much.
+            // Use a custom error message instead.
+            cx.emit_err(ObjcSelectorExpectedStringLiteral { span: nv.value_span });
+            return None;
+        };
+        if methname.as_str().contains('\0') {
+            // `#[rustc_objc_selector = ...]` will be converted to a null-terminated string,
+            // so it may not contain any null characters.
+            cx.emit_err(NullOnObjcSelector { span: nv.value_span });
+            return None;
+        }
+        Some(AttributeKind::ObjcSelector { methname, span: cx.attr_span })
+    }
+}
+
 #[derive(Default)]
 pub(crate) struct NakedParser {
     span: Option<Span>,
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index b3ab1d3edd6d2..6c940e3dcaf99 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -20,8 +20,8 @@ use crate::attributes::allow_unstable::{
 use crate::attributes::body::CoroutineParser;
 use crate::attributes::codegen_attrs::{
     ColdParser, CoverageParser, ExportNameParser, ForceTargetFeatureParser, NakedParser,
-    NoMangleParser, OptimizeParser, SanitizeParser, TargetFeatureParser, TrackCallerParser,
-    UsedParser,
+    NoMangleParser, ObjcClassParser, ObjcSelectorParser, OptimizeParser, SanitizeParser,
+    TargetFeatureParser, TrackCallerParser, UsedParser,
 };
 use crate::attributes::confusables::ConfusablesParser;
 use crate::attributes::crate_level::{
@@ -187,6 +187,8 @@ attribute_parsers!(
         Single<LinkageParser>,
         Single<MoveSizeLimitParser>,
         Single<MustUseParser>,
+        Single<ObjcClassParser>,
+        Single<ObjcSelectorParser>,
         Single<OptimizeParser>,
         Single<PathAttributeParser>,
         Single<PatternComplexityLimitParser>,
diff --git a/compiler/rustc_attr_parsing/src/session_diagnostics.rs b/compiler/rustc_attr_parsing/src/session_diagnostics.rs
index 32ea9005a97d0..2c2b14c8a68bc 100644
--- a/compiler/rustc_attr_parsing/src/session_diagnostics.rs
+++ b/compiler/rustc_attr_parsing/src/session_diagnostics.rs
@@ -459,6 +459,34 @@ pub(crate) struct NullOnLinkSection {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(attr_parsing_null_on_objc_class)]
+pub(crate) struct NullOnObjcClass {
+    #[primary_span]
+    pub span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(attr_parsing_null_on_objc_selector)]
+pub(crate) struct NullOnObjcSelector {
+    #[primary_span]
+    pub span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(attr_parsing_objc_class_expected_string_literal)]
+pub(crate) struct ObjcClassExpectedStringLiteral {
+    #[primary_span]
+    pub span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(attr_parsing_objc_selector_expected_string_literal)]
+pub(crate) struct ObjcSelectorExpectedStringLiteral {
+    #[primary_span]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(attr_parsing_stability_outside_std, code = E0734)]
 pub(crate) struct StabilityOutsideStd {
diff --git a/compiler/rustc_codegen_llvm/src/base.rs b/compiler/rustc_codegen_llvm/src/base.rs
index 9cc5d8dbc21cf..978134cc32b1c 100644
--- a/compiler/rustc_codegen_llvm/src/base.rs
+++ b/compiler/rustc_codegen_llvm/src/base.rs
@@ -109,18 +109,36 @@ pub(crate) fn compile_codegen_unit(
                 attributes::apply_to_llfn(entry, llvm::AttributePlace::Function, &attrs);
             }
 
+            // Define Objective-C module info and module flags. Note, the module info will
+            // also be added to the `llvm.compiler.used` variable, created later.
+            //
+            // These are only necessary when we need the linker to do its Objective-C-specific
+            // magic. We could theoretically do it unconditionally, but at a slight cost to linker
+            // performance in the common case where it's unnecessary.
+            if !cx.objc_classrefs.borrow().is_empty() || !cx.objc_selrefs.borrow().is_empty() {
+                if cx.objc_abi_version() == 1 {
+                    cx.define_objc_module_info();
+                }
+                cx.add_objc_module_flags();
+            }
+
             // Finalize code coverage by injecting the coverage map. Note, the coverage map will
             // also be added to the `llvm.compiler.used` variable, created next.
             if cx.sess().instrument_coverage() {
                 cx.coverageinfo_finalize();
             }
 
-            // Create the llvm.used and llvm.compiler.used variables.
+            // Create the llvm.used variable.
             if !cx.used_statics.is_empty() {
                 cx.create_used_variable_impl(c"llvm.used", &cx.used_statics);
             }
-            if !cx.compiler_used_statics.is_empty() {
-                cx.create_used_variable_impl(c"llvm.compiler.used", &cx.compiler_used_statics);
+
+            // Create the llvm.compiler.used variable.
+            {
+                let compiler_used_statics = cx.compiler_used_statics.borrow();
+                if !compiler_used_statics.is_empty() {
+                    cx.create_used_variable_impl(c"llvm.compiler.used", &compiler_used_statics);
+                }
             }
 
             // Run replace-all-uses-with for statics that need it. This must
diff --git a/compiler/rustc_codegen_llvm/src/common.rs b/compiler/rustc_codegen_llvm/src/common.rs
index 11b79a7fe68c6..aa2df46329f22 100644
--- a/compiler/rustc_codegen_llvm/src/common.rs
+++ b/compiler/rustc_codegen_llvm/src/common.rs
@@ -108,6 +108,10 @@ impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX> {
         bytes_in_context(self.llcx(), bytes)
     }
 
+    pub(crate) fn null_terminate_const_bytes(&self, bytes: &[u8]) -> &'ll Value {
+        null_terminate_bytes_in_context(self.llcx(), bytes)
+    }
+
     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");
@@ -381,6 +385,16 @@ pub(crate) fn bytes_in_context<'ll>(llcx: &'ll llvm::Context, bytes: &[u8]) -> &
     }
 }
 
+pub(crate) fn null_terminate_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(), FALSE)
+    }
+}
+
 pub(crate) fn named_struct<'ll>(ty: &'ll Type, elts: &[&'ll Value]) -> &'ll Value {
     let len = c_uint::try_from(elts.len()).expect("LLVMConstStructInContext elements len overflow");
     unsafe { llvm::LLVMConstNamedStruct(ty, elts.as_ptr(), len) }
diff --git a/compiler/rustc_codegen_llvm/src/consts.rs b/compiler/rustc_codegen_llvm/src/consts.rs
index dc9bb743560dd..a110ecbb75d95 100644
--- a/compiler/rustc_codegen_llvm/src/consts.rs
+++ b/compiler/rustc_codegen_llvm/src/consts.rs
@@ -16,6 +16,7 @@ use rustc_middle::mir::mono::MonoItem;
 use rustc_middle::ty::layout::{HasTypingEnv, LayoutOf};
 use rustc_middle::ty::{self, Instance};
 use rustc_middle::{bug, span_bug};
+use rustc_span::Symbol;
 use tracing::{debug, instrument, trace};
 
 use crate::common::CodegenCx;
@@ -331,6 +332,10 @@ impl<'ll> CodegenCx<'ll, '_> {
             }
 
             g
+        } else if let Some(classname) = fn_attrs.objc_class {
+            self.get_objc_classref(classname)
+        } else if let Some(methname) = fn_attrs.objc_selector {
+            self.get_objc_selref(methname)
         } else {
             check_and_apply_linkage(self, fn_attrs, llty, sym, def_id)
         };
@@ -543,8 +548,225 @@ impl<'ll> CodegenCx<'ll, '_> {
 
     /// Add a global value to a list to be stored in the `llvm.compiler.used` variable,
     /// an array of ptr.
-    pub(crate) fn add_compiler_used_global(&mut self, global: &'ll Value) {
-        self.compiler_used_statics.push(global);
+    pub(crate) fn add_compiler_used_global(&self, global: &'ll Value) {
+        self.compiler_used_statics.borrow_mut().push(global);
+    }
+
+    // We do our best here to match what Clang does when compiling Objective-C natively.
+    // See Clang's `CGObjCCommonMac::CreateCStringLiteral`:
+    // https://github.com/llvm/llvm-project/blob/llvmorg-20.1.8/clang/lib/CodeGen/CGObjCMac.cpp#L4134
+    fn define_objc_classname(&self, classname: &str) -> &'ll Value {
+        assert_eq!(self.objc_abi_version(), 1);
+
+        let llval = self.null_terminate_const_bytes(classname.as_bytes());
+        let llty = self.val_ty(llval);
+        let sym = self.generate_local_symbol_name("OBJC_CLASS_NAME_");
+        let g = self.define_global(&sym, llty).unwrap_or_else(|| {
+            bug!("symbol `{}` is already defined", sym);
+        });
+        set_global_alignment(self, g, self.tcx.data_layout.i8_align.abi);
+        llvm::set_initializer(g, llval);
+        llvm::set_linkage(g, llvm::Linkage::PrivateLinkage);
+        llvm::set_section(g, c"__TEXT,__cstring,cstring_literals");
+        llvm::LLVMSetGlobalConstant(g, llvm::TRUE);
+        llvm::LLVMSetUnnamedAddress(g, llvm::UnnamedAddr::Global);
+        self.add_compiler_used_global(g);
+
+        g
+    }
+
+    // We do our best here to match what Clang does when compiling Objective-C natively.
+    // See Clang's `ObjCNonFragileABITypesHelper`:
+    // https://github.com/llvm/llvm-project/blob/llvmorg-20.1.8/clang/lib/CodeGen/CGObjCMac.cpp#L6052
+    fn get_objc_class_t(&self) -> &'ll Type {
+        if let Some(class_t) = self.objc_class_t.get() {
+            return class_t;
+        }
+
+        assert_eq!(self.objc_abi_version(), 2);
+
+        // struct _class_t {
+        //     struct _class_t* isa;
+        //     struct _class_t* const superclass;
+        //     void* cache;
+        //     IMP* vtable;
+        //     struct class_ro_t* ro;
+        // }
+
+        let class_t = self.type_named_struct("struct._class_t");
+        let els = [self.type_ptr(); 5];
+        let packed = false;
+        self.set_struct_body(class_t, &els, packed);
+
+        self.objc_class_t.set(Some(class_t));
+        class_t
+    }
+
+    // We do our best here to match what Clang does when compiling Objective-C natively. We
+    // deduplicate references within a CGU, but we need a reference definition in each referencing
+    // CGU. All attempts at using external references to a single reference definition result in
+    // linker errors.
+    fn get_objc_classref(&self, classname: Symbol) -> &'ll Value {
+        let mut classrefs = self.objc_classrefs.borrow_mut();
+        if let Some(classref) = classrefs.get(&classname).copied() {
+            return classref;
+        }
+
+        let g = match self.objc_abi_version() {
+            1 => {
+                // See Clang's `CGObjCMac::EmitClassRefFromId`:
+                // https://github.com/llvm/llvm-project/blob/llvmorg-20.1.8/clang/lib/CodeGen/CGObjCMac.cpp#L5205
+                let llval = self.define_objc_classname(classname.as_str());
+                let llty = self.type_ptr();
+                let sym = self.generate_local_symbol_name("OBJC_CLASS_REFERENCES_");
+                let g = self.define_global(&sym, llty).unwrap_or_else(|| {
+                    bug!("symbol `{}` is already defined", sym);
+                });
+                set_global_alignment(self, g, self.tcx.data_layout.pointer_align().abi);
+                llvm::set_initializer(g, llval);
+                llvm::set_linkage(g, llvm::Linkage::PrivateLinkage);
+                llvm::set_section(g, c"__OBJC,__cls_refs,literal_pointers,no_dead_strip");
+                self.add_compiler_used_global(g);
+                g
+            }
+            2 => {
+                // See Clang's `CGObjCNonFragileABIMac::EmitClassRefFromId`:
+                // https://github.com/llvm/llvm-project/blob/llvmorg-20.1.8/clang/lib/CodeGen/CGObjCMac.cpp#L7423
+                let llval = {
+                    let extern_sym = format!("OBJC_CLASS_$_{}", classname.as_str());
+                    let extern_llty = self.get_objc_class_t();
+                    self.declare_global(&extern_sym, extern_llty)
+                };
+                let llty = self.type_ptr();
+                let sym = self.generate_local_symbol_name("OBJC_CLASSLIST_REFERENCES_$_");
+                let g = self.define_global(&sym, llty).unwrap_or_else(|| {
+                    bug!("symbol `{}` is already defined", sym);
+                });
+                set_global_alignment(self, g, self.tcx.data_layout.pointer_align().abi);
+                llvm::set_initializer(g, llval);
+                llvm::set_linkage(g, llvm::Linkage::InternalLinkage);
+                llvm::set_section(g, c"__DATA,__objc_classrefs,regular,no_dead_strip");
+                self.add_compiler_used_global(g);
+                g
+            }
+            _ => unreachable!(),
+        };
+
+        classrefs.insert(classname, g);
+        g
+    }
+
+    // We do our best here to match what Clang does when compiling Objective-C natively. We
+    // deduplicate references within a CGU, but we need a reference definition in each referencing
+    // CGU. All attempts at using external references to a single reference definition result in
+    // linker errors.
+    //
+    // Newer versions of Apple Clang generate calls to `@"objc_msgSend$methname"` selector stub
+    // functions. We don't currently do that. The code we generate is closer to what Apple Clang
+    // generates with the `-fno-objc-msgsend-selector-stubs` option.
+    fn get_objc_selref(&self, methname: Symbol) -> &'ll Value {
+        let mut selrefs = self.objc_selrefs.borrow_mut();
+        if let Some(selref) = selrefs.get(&methname).copied() {
+            return selref;
+        }
+
+        let abi_version = self.objc_abi_version();
+
+        // See Clang's `CGObjCCommonMac::CreateCStringLiteral`:
+        // https://github.com/llvm/llvm-project/blob/llvmorg-20.1.8/clang/lib/CodeGen/CGObjCMac.cpp#L4134
+        let methname_llval = self.null_terminate_const_bytes(methname.as_str().as_bytes());
+        let methname_llty = self.val_ty(methname_llval);
+        let methname_sym = self.generate_local_symbol_name("OBJC_METH_VAR_NAME_");
+        let methname_g = self.define_global(&methname_sym, methname_llty).unwrap_or_else(|| {
+            bug!("symbol `{}` is already defined", methname_sym);
+        });
+        set_global_alignment(self, methname_g, self.tcx.data_layout.i8_align.abi);
+        llvm::set_initializer(methname_g, methname_llval);
+        llvm::set_linkage(methname_g, llvm::Linkage::PrivateLinkage);
+        llvm::set_section(
+            methname_g,
+            match abi_version {
+                1 => c"__TEXT,__cstring,cstring_literals",
+                2 => c"__TEXT,__objc_methname,cstring_literals",
+                _ => unreachable!(),
+            },
+        );
+        llvm::LLVMSetGlobalConstant(methname_g, llvm::TRUE);
+        llvm::LLVMSetUnnamedAddress(methname_g, llvm::UnnamedAddr::Global);
+        self.add_compiler_used_global(methname_g);
+
+        // See Clang's `CGObjCMac::EmitSelectorAddr`:
+        // https://github.com/llvm/llvm-project/blob/llvmorg-20.1.8/clang/lib/CodeGen/CGObjCMac.cpp#L5243
+        // And Clang's `CGObjCNonFragileABIMac::EmitSelectorAddr`:
+        // https://github.com/llvm/llvm-project/blob/llvmorg-20.1.8/clang/lib/CodeGen/CGObjCMac.cpp#L7586
+        let selref_llval = methname_g;
+        let selref_llty = self.type_ptr();
+        let selref_sym = self.generate_local_symbol_name("OBJC_SELECTOR_REFERENCES_");
+        let selref_g = self.define_global(&selref_sym, selref_llty).unwrap_or_else(|| {
+            bug!("symbol `{}` is already defined", selref_sym);
+        });
+        set_global_alignment(self, selref_g, self.tcx.data_layout.pointer_align().abi);
+        llvm::set_initializer(selref_g, selref_llval);
+        llvm::set_externally_initialized(selref_g, true);
+        llvm::set_linkage(
+            selref_g,
+            match abi_version {
+                1 => llvm::Linkage::PrivateLinkage,
+                2 => llvm::Linkage::InternalLinkage,
+                _ => unreachable!(),
+            },
+        );
+        llvm::set_section(
+            selref_g,
+            match abi_version {
+                1 => c"__OBJC,__message_refs,literal_pointers,no_dead_strip",
+                2 => c"__DATA,__objc_selrefs,literal_pointers,no_dead_strip",
+                _ => unreachable!(),
+            },
+        );
+        self.add_compiler_used_global(selref_g);
+
+        selrefs.insert(methname, selref_g);
+        selref_g
+    }
+
+    // We do our best here to match what Clang does when compiling Objective-C natively.
+    // See Clang's `ObjCTypesHelper`:
+    // https://github.com/llvm/llvm-project/blob/llvmorg-20.1.8/clang/lib/CodeGen/CGObjCMac.cpp#L5936
+    // And Clang's `CGObjCMac::EmitModuleInfo`:
+    // https://github.com/llvm/llvm-project/blob/llvmorg-20.1.8/clang/lib/CodeGen/CGObjCMac.cpp#L5151
+    pub(crate) fn define_objc_module_info(&mut self) {
+        assert_eq!(self.objc_abi_version(), 1);
+
+        // struct _objc_module {
+        //     long version;                // Hardcoded to 7 in Clang.
+        //     long size;                   // sizeof(struct _objc_module)
+        //     char* name;                  // Hardcoded to classname "" in Clang.
+        //     struct _objc_symtab* symtab; // Null without class or category definitions.
+        //  }
+
+        let llty = self.type_named_struct("struct._objc_module");
+        let i32_llty = self.type_i32();
+        let ptr_llty = self.type_ptr();
+        let packed = false;
+        self.set_struct_body(llty, &[i32_llty, i32_llty, ptr_llty, ptr_llty], packed);
+
+        let version = self.const_uint(i32_llty, 7);
+        let size = self.const_uint(i32_llty, 16);
+        let name = self.define_objc_classname("");
+        let symtab = self.const_null(ptr_llty);
+        let llval = crate::common::named_struct(llty, &[version, size, name, symtab]);
+
+        let sym = "OBJC_MODULES";
+        let g = self.define_global(&sym, llty).unwrap_or_else(|| {
+            bug!("symbol `{}` is already defined", sym);
+        });
+        set_global_alignment(self, g, self.tcx.data_layout.pointer_align().abi);
+        llvm::set_initializer(g, llval);
+        llvm::set_linkage(g, llvm::Linkage::PrivateLinkage);
+        llvm::set_section(g, c"__OBJC,__module_info,regular,no_dead_strip");
+
+        self.add_compiler_used_global(g);
     }
 }
 
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index a69fa54a54a4d..2f309d4694cef 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -26,7 +26,7 @@ use rustc_session::config::{
     BranchProtection, CFGuard, CFProtection, CrateType, DebugInfo, FunctionReturn, PAuthKey, PacRet,
 };
 use rustc_span::source_map::Spanned;
-use rustc_span::{DUMMY_SP, Span};
+use rustc_span::{DUMMY_SP, Span, Symbol};
 use rustc_symbol_mangling::mangle_internal_symbol;
 use rustc_target::spec::{HasTargetSpec, RelocModel, SmallDataThresholdSupport, Target, TlsModel};
 use smallvec::SmallVec;
@@ -119,7 +119,7 @@ pub(crate) struct FullCx<'ll, 'tcx> {
 
     /// Statics that will be placed in the llvm.compiler.used variable
     /// See <https://llvm.org/docs/LangRef.html#the-llvm-compiler-used-global-variable> for details
-    pub compiler_used_statics: Vec<&'ll Value>,
+    pub compiler_used_statics: RefCell<Vec<&'ll Value>>,
 
     /// Mapping of non-scalar types to llvm types.
     pub type_lowering: RefCell<FxHashMap<(Ty<'tcx>, Option<VariantIdx>), &'ll Type>>,
@@ -146,6 +146,15 @@ pub(crate) struct FullCx<'ll, 'tcx> {
     /// `global_asm!` needs to be able to find this new global so that it can
     /// compute the correct mangled symbol name to insert into the asm.
     pub renamed_statics: RefCell<FxHashMap<DefId, &'ll Value>>,
+
+    /// Cached Objective-C class type
+    pub objc_class_t: Cell<Option<&'ll Type>>,
+
+    /// Cache of Objective-C class references
+    pub objc_classrefs: RefCell<FxHashMap<Symbol, &'ll Value>>,
+
+    /// Cache of Objective-C selector references
+    pub objc_selrefs: RefCell<FxHashMap<Symbol, &'ll Value>>,
 }
 
 fn to_llvm_tls_model(tls_model: TlsModel) -> llvm::ThreadLocalMode {
@@ -644,7 +653,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
                 const_globals: Default::default(),
                 statics_to_rauw: RefCell::new(Vec::new()),
                 used_statics: Vec::new(),
-                compiler_used_statics: Vec::new(),
+                compiler_used_statics: Default::default(),
                 type_lowering: Default::default(),
                 scalar_lltypes: Default::default(),
                 coverage_cx,
@@ -655,6 +664,9 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
                 intrinsics: Default::default(),
                 local_gen_sym_counter: Cell::new(0),
                 renamed_statics: Default::default(),
+                objc_class_t: Cell::new(None),
+                objc_classrefs: Default::default(),
+                objc_selrefs: Default::default(),
             },
             PhantomData,
         )
@@ -679,6 +691,69 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
         llvm::set_linkage(g, llvm::Linkage::AppendingLinkage);
         llvm::set_section(g, c"llvm.metadata");
     }
+
+    /// The Objective-C ABI that is used.
+    ///
+    /// This corresponds to the `-fobjc-abi-version=` flag in Clang / GCC.
+    pub(crate) fn objc_abi_version(&self) -> u32 {
+        assert!(self.tcx.sess.target.is_like_darwin);
+        if self.tcx.sess.target.arch == "x86" && self.tcx.sess.target.os == "macos" {
+            // 32-bit x86 macOS uses ABI version 1 (a.k.a. the "fragile ABI").
+            1
+        } else {
+            // All other Darwin-like targets we support use ABI version 2
+            // (a.k.a the "non-fragile ABI").
+            2
+        }
+    }
+
+    // We do our best here to match what Clang does when compiling Objective-C natively.
+    // See Clang's `CGObjCCommonMac::EmitImageInfo`:
+    // https://github.com/llvm/llvm-project/blob/llvmorg-20.1.8/clang/lib/CodeGen/CGObjCMac.cpp#L5085
+    pub(crate) fn add_objc_module_flags(&self) {
+        let abi_version = self.objc_abi_version();
+
+        llvm::add_module_flag_u32(
+            self.llmod,
+            llvm::ModuleFlagMergeBehavior::Error,
+            "Objective-C Version",
+            abi_version,
+        );
+
+        llvm::add_module_flag_u32(
+            self.llmod,
+            llvm::ModuleFlagMergeBehavior::Error,
+            "Objective-C Image Info Version",
+            0,
+        );
+
+        llvm::add_module_flag_str(
+            self.llmod,
+            llvm::ModuleFlagMergeBehavior::Error,
+            "Objective-C Image Info Section",
+            match abi_version {
+                1 => "__OBJC,__image_info,regular",
+                2 => "__DATA,__objc_imageinfo,regular,no_dead_strip",
+                _ => unreachable!(),
+            },
+        );
+
+        if self.tcx.sess.target.env == "sim" {
+            llvm::add_module_flag_u32(
+                self.llmod,
+                llvm::ModuleFlagMergeBehavior::Error,
+                "Objective-C Is Simulated",
+                1 << 5,
+            );
+        }
+
+        llvm::add_module_flag_u32(
+            self.llmod,
+            llvm::ModuleFlagMergeBehavior::Error,
+            "Objective-C Class Properties",
+            1 << 6,
+        );
+    }
 }
 impl<'ll> SimpleCx<'ll> {
     pub(crate) fn get_type_of_global(&self, val: &'ll Value) -> &'ll Type {
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 0679f55ab7f08..e125aba6afc75 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -1237,6 +1237,7 @@ unsafe extern "C" {
     pub(crate) safe fn LLVMSetGlobalConstant(GlobalVar: &Value, IsConstant: Bool);
     pub(crate) safe fn LLVMSetTailCall(CallInst: &Value, IsTailCall: Bool);
     pub(crate) safe fn LLVMSetTailCallKind(CallInst: &Value, kind: TailCallKind);
+    pub(crate) safe fn LLVMSetExternallyInitialized(GlobalVar: &Value, IsExtInit: Bool);
 
     // Operations on attributes
     pub(crate) fn LLVMCreateStringAttribute(
diff --git a/compiler/rustc_codegen_llvm/src/llvm/mod.rs b/compiler/rustc_codegen_llvm/src/llvm/mod.rs
index d6974e22c85c5..1115d82fa85d3 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/mod.rs
@@ -258,6 +258,10 @@ pub(crate) fn set_alignment(llglobal: &Value, align: Align) {
     }
 }
 
+pub(crate) fn set_externally_initialized(llglobal: &Value, is_ext_init: bool) {
+    LLVMSetExternallyInitialized(llglobal, is_ext_init.to_llvm_bool());
+}
+
 /// Get the `name`d comdat from `llmod` and assign it to `llglobal`.
 ///
 /// Inserts the comdat into `llmod` if it does not exist.
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
index dc500c363f4a7..32ae810ecc892 100644
--- a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
+++ b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -296,6 +296,12 @@ fn process_builtin_attrs(
                 AttributeKind::Sanitize { span, .. } => {
                     interesting_spans.sanitize = Some(*span);
                 }
+                AttributeKind::ObjcClass { classname, .. } => {
+                    codegen_fn_attrs.objc_class = Some(*classname);
+                }
+                AttributeKind::ObjcSelector { methname, .. } => {
+                    codegen_fn_attrs.objc_selector = Some(*methname);
+                }
                 _ => {}
             }
         }
diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs
index 129ab7eccb577..99d6e93faa9ef 100644
--- a/compiler/rustc_feature/src/builtin_attrs.rs
+++ b/compiler/rustc_feature/src/builtin_attrs.rs
@@ -1057,6 +1057,14 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         rustc_std_internal_symbol, Normal, template!(Word), WarnFollowing,
         EncodeCrossCrate::No,
     ),
+    rustc_attr!(
+        rustc_objc_class, Normal, template!(NameValueStr: "ClassName"), ErrorPreceding,
+        EncodeCrossCrate::No,
+    ),
+    rustc_attr!(
+        rustc_objc_selector, Normal, template!(NameValueStr: "methodName"), ErrorPreceding,
+        EncodeCrossCrate::No,
+    ),
 
     // ==========================================================================
     // Internal attributes, Macro related:
diff --git a/compiler/rustc_hir/src/attrs/data_structures.rs b/compiler/rustc_hir/src/attrs/data_structures.rs
index ea11a99efbc35..04b144abd03df 100644
--- a/compiler/rustc_hir/src/attrs/data_structures.rs
+++ b/compiler/rustc_hir/src/attrs/data_structures.rs
@@ -594,6 +594,12 @@ pub enum AttributeKind {
     /// Represents `#[non_exhaustive]`
     NonExhaustive(Span),
 
+    /// Represents `#[rustc_objc_class]`
+    ObjcClass { classname: Symbol, span: Span },
+
+    /// Represents `#[rustc_objc_selector]`
+    ObjcSelector { methname: Symbol, span: Span },
+
     /// Represents `#[optimize(size|speed)]`
     Optimize(OptimizeAttr, Span),
 
diff --git a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
index 55521c1585402..cb4feeb05f1a0 100644
--- a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
+++ b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
@@ -69,6 +69,8 @@ impl AttributeKind {
             NoMangle(..) => Yes, // Needed for rustdoc
             NoStd(..) => No,
             NonExhaustive(..) => Yes, // Needed for rustdoc
+            ObjcClass { .. } => No,
+            ObjcSelector { .. } => No,
             Optimize(..) => No,
             ParenSugar(..) => No,
             PassByValue(..) => Yes,
diff --git a/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs b/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
index 8b4503073b0de..f0d96c6ac8981 100644
--- a/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
+++ b/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
@@ -69,6 +69,10 @@ pub struct CodegenFnAttrs {
     /// The `#[patchable_function_entry(...)]` attribute. Indicates how many nops should be around
     /// the function entry.
     pub patchable_function_entry: Option<PatchableFunctionEntry>,
+    /// The `#[rustc_objc_class = "..."]` attribute.
+    pub objc_class: Option<Symbol>,
+    /// The `#[rustc_objc_selector = "..."]` attribute.
+    pub objc_selector: Option<Symbol>,
 }
 
 #[derive(Copy, Clone, Debug, TyEncodable, TyDecodable, HashStable, PartialEq, Eq)]
@@ -185,6 +189,8 @@ impl CodegenFnAttrs {
             instruction_set: None,
             alignment: None,
             patchable_function_entry: None,
+            objc_class: None,
+            objc_selector: None,
         }
     }
 
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 2562d2e0b83c5..60f575cb84415 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -276,6 +276,8 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::PatternComplexityLimit { .. }
                     | AttributeKind::NoCore { .. }
                     | AttributeKind::NoStd { .. }
+                    | AttributeKind::ObjcClass { .. }
+                    | AttributeKind::ObjcSelector { .. }
                 ) => { /* do nothing  */ }
                 Attribute::Unparsed(attr_item) => {
                     style = Some(attr_item.style);
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index cdb0b5b58da6d..668e80a26b44e 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1917,6 +1917,8 @@ symbols! {
         rustc_no_mir_inline,
         rustc_nonnull_optimization_guaranteed,
         rustc_nounwind,
+        rustc_objc_class,
+        rustc_objc_selector,
         rustc_object_lifetime_default,
         rustc_on_unimplemented,
         rustc_outlives,
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 86a68e18b0af4..5d52bfb1b125f 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -313,6 +313,7 @@ pub mod io;
 pub mod iter;
 pub mod net;
 pub mod option;
+pub mod os;
 pub mod panic;
 pub mod panicking;
 #[unstable(feature = "pattern_type_macro", issue = "123646")]
diff --git a/library/core/src/os/darwin/mod.rs b/library/core/src/os/darwin/mod.rs
new file mode 100644
index 0000000000000..8426d82b8ce3e
--- /dev/null
+++ b/library/core/src/os/darwin/mod.rs
@@ -0,0 +1,19 @@
+//! Platform-specific extensions to `core` for Darwin / Apple platforms.
+//!
+//! This is available on the following operating systems:
+//! - macOS
+//! - iOS
+//! - tvOS
+//! - watchOS
+//! - visionOS
+//!
+//! Note: This module is called "Darwin" as that's the name of the underlying
+//! core OS of the above operating systems, but it should not be confused with
+//! the `-darwin` suffix in the `x86_64-apple-darwin` and
+//! `aarch64-apple-darwin` target names, which are mostly named that way for
+//! legacy reasons.
+
+#![unstable(feature = "darwin_objc", issue = "145496")]
+#![doc(cfg(target_vendor = "apple"))]
+
+pub mod objc;
diff --git a/library/core/src/os/darwin/objc.rs b/library/core/src/os/darwin/objc.rs
new file mode 100644
index 0000000000000..928cb54e82c79
--- /dev/null
+++ b/library/core/src/os/darwin/objc.rs
@@ -0,0 +1,113 @@
+//! Defines types and macros for Objective-C interoperability.
+
+#![unstable(feature = "darwin_objc", issue = "145496")]
+#![allow(nonstandard_style)]
+
+use crate::fmt;
+
+/// Equivalent to Objective-C’s `struct objc_class` type.
+#[cfg_attr(not(doc), repr(u8))] // An implementation detail we don't want to show up in rustdoc
+pub enum objc_class {
+    #[unstable(
+        feature = "objc_class_variant",
+        reason = "temporary implementation detail",
+        issue = "none"
+    )]
+    #[doc(hidden)]
+    __variant1,
+    #[unstable(
+        feature = "objc_class_variant",
+        reason = "temporary implementation detail",
+        issue = "none"
+    )]
+    #[doc(hidden)]
+    __variant2,
+}
+
+impl fmt::Debug for objc_class {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("objc_class").finish()
+    }
+}
+
+/// Equivalent to Objective-C’s `struct objc_selector` type.
+#[cfg_attr(not(doc), repr(u8))] // An implementation detail we don't want to show up in rustdoc
+pub enum objc_selector {
+    #[unstable(
+        feature = "objc_selector_variant",
+        reason = "temporary implementation detail",
+        issue = "none"
+    )]
+    #[doc(hidden)]
+    __variant1,
+    #[unstable(
+        feature = "objc_selector_variant",
+        reason = "temporary implementation detail",
+        issue = "none"
+    )]
+    #[doc(hidden)]
+    __variant2,
+}
+
+impl fmt::Debug for objc_selector {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("objc_selector").finish()
+    }
+}
+
+/// Equivalent to Objective-C’s `Class` type.
+pub type Class = *mut objc_class;
+
+/// Equivalent to Objective-C’s `SEL` type.
+pub type SEL = *mut objc_selector;
+
+/// Gets a reference to an Objective-C class.
+///
+/// This macro will yield an expression of type [`Class`] for the given class name string literal.
+///
+/// # Example
+///
+/// ```no_run
+/// #![feature(darwin_objc)]
+/// use core::os::darwin::objc;
+///
+/// let string_class = objc::class!("NSString");
+/// ```
+#[allow_internal_unstable(rustc_attrs)]
+pub macro class($classname:expr) {{
+    // Since static Objective-C class references actually end up with multiple definitions
+    // across dylib boundaries, we only expose the value of the static and don't provide a way to
+    // get the address of or a reference to the static.
+    unsafe extern "C" {
+        #[rustc_objc_class = $classname]
+        safe static VAL: $crate::os::darwin::objc::Class;
+    }
+    VAL
+}}
+
+/// Gets a reference to an Objective-C selector.
+///
+/// This macro will yield an expression of type [`SEL`] for the given method name string literal.
+///
+/// It is similar to Objective-C’s `@selector` directive.
+///
+/// # Examples
+///
+/// ```no_run
+/// #![feature(darwin_objc)]
+/// use core::os::darwin::objc;
+///
+/// let alloc_sel = objc::selector!("alloc");
+/// let init_sel = objc::selector!("initWithCString:encoding:");
+/// ```
+#[allow_internal_unstable(rustc_attrs)]
+pub macro selector($methname:expr) {{
+    // Since static Objective-C selector references actually end up with multiple definitions
+    // across dylib boundaries, we only expose the value of the static and don't provide a way to
+    // get the address of or a reference to the static.
+    unsafe extern "C" {
+        #[rustc_objc_selector = $methname]
+        safe static VAL: $crate::os::darwin::objc::SEL;
+    }
+    VAL
+}}
diff --git a/library/core/src/os/mod.rs b/library/core/src/os/mod.rs
new file mode 100644
index 0000000000000..897f59f530ed0
--- /dev/null
+++ b/library/core/src/os/mod.rs
@@ -0,0 +1,24 @@
+//! OS-specific functionality.
+
+#![unstable(feature = "darwin_objc", issue = "145496")]
+
+#[cfg(all(
+    doc,
+    any(
+        all(target_arch = "wasm32", not(target_os = "wasi")),
+        all(target_vendor = "fortanix", target_env = "sgx")
+    )
+))]
+#[unstable(issue = "none", feature = "std_internals")]
+pub mod darwin {}
+
+// darwin
+#[cfg(not(all(
+    doc,
+    any(
+        all(target_arch = "wasm32", not(target_os = "wasi")),
+        all(target_vendor = "fortanix", target_env = "sgx")
+    )
+)))]
+#[cfg(any(target_vendor = "apple", doc))]
+pub mod darwin;
diff --git a/library/std/src/os/darwin/mod.rs b/library/std/src/os/darwin/mod.rs
index 3b1bd974fa313..ff184f477fb0e 100644
--- a/library/std/src/os/darwin/mod.rs
+++ b/library/std/src/os/darwin/mod.rs
@@ -17,6 +17,8 @@
 #![doc(cfg(target_vendor = "apple"))]
 
 pub mod fs;
+pub mod objc;
+
 // deprecated, but used for public reexport under `std::os::unix::raw`, as
 // well as `std::os::macos`/`std::os::ios`, because those modules precede the
 // decision to remove these.
diff --git a/library/std/src/os/darwin/objc.rs b/library/std/src/os/darwin/objc.rs
new file mode 100644
index 0000000000000..a4b31fee7c582
--- /dev/null
+++ b/library/std/src/os/darwin/objc.rs
@@ -0,0 +1,13 @@
+//! Defines types and macros for Objective-C interoperability.
+//!
+//! This module re-exports all the items in [`core::os::darwin::objc`].
+//!
+//! [`core::os::darwin::objc`]: ../../../../core/os/darwin/objc/index.html "mod core::os::darwin::objc"
+
+#![unstable(feature = "darwin_objc", issue = "145496")]
+
+// We can't generate an intra-doc link for this automatically since `core::os::darwin` isn't
+// compiled into `core` on every platform even though it's documented on every platform.
+// We just link to it directly in the module documentation above instead.
+#[cfg(not(doc))]
+pub use core::os::darwin::objc::*;
diff --git a/src/tools/tidy/src/pal.rs b/src/tools/tidy/src/pal.rs
index 5b8b44429bbc0..991ad55809cc3 100644
--- a/src/tools/tidy/src/pal.rs
+++ b/src/tools/tidy/src/pal.rs
@@ -53,6 +53,7 @@ const EXCEPTION_PATHS: &[&str] = &[
     // core::ffi contains platform-specific type and linkage configuration
     "library/core/src/ffi/mod.rs",
     "library/core/src/ffi/primitives.rs",
+    "library/core/src/os", // Platform-specific public interfaces
     "library/std/src/sys", // Platform-specific code for std lives here.
     "library/std/src/os",  // Platform-specific public interfaces
     // Temporary `std` exceptions
diff --git a/tests/codegen-llvm/auxiliary/darwin_objc_aux.rs b/tests/codegen-llvm/auxiliary/darwin_objc_aux.rs
new file mode 100644
index 0000000000000..3c35d003c8af6
--- /dev/null
+++ b/tests/codegen-llvm/auxiliary/darwin_objc_aux.rs
@@ -0,0 +1,27 @@
+#![crate_type = "lib"]
+#![feature(darwin_objc)]
+
+use std::os::darwin::objc;
+
+#[link(name = "Foundation", kind = "framework")]
+unsafe extern "C" {}
+
+#[inline(always)]
+pub fn inline_get_object_class() -> objc::Class {
+    objc::class!("NSObject")
+}
+
+#[inline(always)]
+pub fn inline_get_alloc_selector() -> objc::SEL {
+    objc::selector!("alloc")
+}
+
+#[inline(never)]
+pub fn never_inline_get_string_class() -> objc::Class {
+    objc::class!("NSString")
+}
+
+#[inline(never)]
+pub fn never_inline_get_init_selector() -> objc::SEL {
+    objc::selector!("init")
+}
diff --git a/tests/codegen-llvm/darwin-no-objc.rs b/tests/codegen-llvm/darwin-no-objc.rs
new file mode 100644
index 0000000000000..fda3671fb6d84
--- /dev/null
+++ b/tests/codegen-llvm/darwin-no-objc.rs
@@ -0,0 +1,52 @@
+// Test that we don't generate Objective-C definitions or image info unnecessarily.
+
+//@ add-core-stubs
+//@ revisions: i686_apple_darwin
+//@ [i686_apple_darwin] compile-flags: --target i686-apple-darwin
+//@ [i686_apple_darwin] needs-llvm-components: x86
+//@ revisions: x86_64_macos
+//@ [x86_64_macos] compile-flags: --target x86_64-apple-darwin
+//@ [x86_64_macos] needs-llvm-components: x86
+//@ revisions: aarch64_macos
+//@ [aarch64_macos] compile-flags: --target aarch64-apple-darwin
+//@ [aarch64_macos] needs-llvm-components: aarch64
+//@ revisions: i386_ios
+//@ [i386_ios] compile-flags: --target i386-apple-ios
+//@ [i386_ios] needs-llvm-components: x86
+//@ revisions: x86_64_ios
+//@ [x86_64_ios] compile-flags: --target x86_64-apple-ios
+//@ [x86_64_ios] needs-llvm-components: x86
+//@ revisions: armv7s_ios
+//@ [armv7s_ios] compile-flags: --target armv7s-apple-ios
+//@ [armv7s_ios] needs-llvm-components: arm
+//@ revisions: aarch64_ios
+//@ [aarch64_ios] compile-flags: --target aarch64-apple-ios
+//@ [aarch64_ios] needs-llvm-components: aarch64
+//@ revisions: aarch64_ios_sim
+//@ [aarch64_ios_sim] compile-flags: --target aarch64-apple-ios-sim
+//@ [aarch64_ios_sim] needs-llvm-components: aarch64
+
+#![crate_type = "lib"]
+#![feature(no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+#[no_mangle]
+pub fn foo() {}
+
+// CHECK-NOT: %struct._class_t
+// CHECK-NOT: %struct._objc_module
+// CHECK-NOT: @OBJC_CLASS_NAME_
+// CHECK-NOT: @"OBJC_CLASS_$_{{[0-9A-Z_a-z]+}}"
+// CHECK-NOT: @"OBJC_CLASSLIST_REFERENCES_$_.{{[0-9]+}}"
+// CHECK-NOT: @OBJC_METH_VAR_NAME_
+// CHECK-NOT: @OBJC_SELECTOR_REFERENCES_
+// CHECK-NOT: @OBJC_MODULES
+
+// CHECK-NOT: !"Objective-C Version"
+// CHECK-NOT: !"Objective-C Image Info Version"
+// CHECK-NOT: !"Objective-C Image Info Section"
+// CHECK-NOT: !"Objective-C Is Simulated"
+// CHECK-NOT: !"Objective-C Class Properties"
diff --git a/tests/codegen-llvm/darwin-objc-abi-v1.rs b/tests/codegen-llvm/darwin-objc-abi-v1.rs
new file mode 100644
index 0000000000000..0fc1de9332ac4
--- /dev/null
+++ b/tests/codegen-llvm/darwin-objc-abi-v1.rs
@@ -0,0 +1,100 @@
+// ignore-tidy-linelength
+//@ add-core-stubs
+//@ revisions: i686_apple_darwin
+//@ [i686_apple_darwin] compile-flags: --target i686-apple-darwin
+//@ [i686_apple_darwin] needs-llvm-components: x86
+
+#![crate_type = "lib"]
+#![feature(no_core, lang_items, rustc_attrs)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+#[no_mangle]
+pub fn get_class() -> *mut () {
+    unsafe extern "C" {
+        #[rustc_objc_class = "MyClass"]
+        safe static VAL: *mut ();
+    }
+    VAL
+}
+
+#[no_mangle]
+pub fn get_class_again() -> *mut () {
+    // Codegen should de-duplicate this class with the one from get_class above.
+    unsafe extern "C" {
+        #[rustc_objc_class = "MyClass"]
+        safe static VAL: *mut ();
+    }
+    VAL
+}
+
+#[no_mangle]
+pub fn get_selector() -> *mut () {
+    unsafe extern "C" {
+        #[rustc_objc_selector = "myMethod"]
+        safe static VAL: *mut ();
+    }
+    VAL
+}
+
+#[no_mangle]
+pub fn get_selector_again() -> *mut () {
+    // Codegen should de-duplicate this selector with the one from get_selector above.
+    unsafe extern "C" {
+        #[rustc_objc_selector = "myMethod"]
+        safe static VAL: *mut ();
+    }
+    VAL
+}
+
+#[no_mangle]
+pub fn get_other_class() -> *mut () {
+    unsafe extern "C" {
+        #[rustc_objc_class = "OtherClass"]
+        safe static VAL: *mut ();
+    }
+    VAL
+}
+
+#[no_mangle]
+pub fn get_other_selector() -> *mut () {
+    unsafe extern "C" {
+        #[rustc_objc_selector = "otherMethod"]
+        safe static VAL: *mut ();
+    }
+    VAL
+}
+
+// CHECK: %struct._objc_module = type { i32, i32, ptr, ptr }
+
+// CHECK: @OBJC_CLASS_NAME_.{{[0-9]+}} = private unnamed_addr constant [8 x i8] c"MyClass\00", section "__TEXT,__cstring,cstring_literals", align 1
+// CHECK: @OBJC_CLASS_REFERENCES_.{{[0-9]+}} = private global ptr @OBJC_CLASS_NAME_.{{[0-9]+}}, section "__OBJC,__cls_refs,literal_pointers,no_dead_strip", align 4
+// CHECK-NOT: @OBJC_CLASS_NAME_
+// CHECK-NOT: @OBJC_CLASS_REFERENCES_
+
+// CHECK: @OBJC_METH_VAR_NAME_.{{[0-9]+}} = private unnamed_addr constant [9 x i8] c"myMethod\00", section "__TEXT,__cstring,cstring_literals", align 1
+// CHECK: @OBJC_SELECTOR_REFERENCES_.{{[0-9]+}} = private externally_initialized global ptr @OBJC_METH_VAR_NAME_.{{[0-9]+}}, section "__OBJC,__message_refs,literal_pointers,no_dead_strip", align 4
+// CHECK-NOT: @OBJC_METH_VAR_NAME_
+// CHECK-NOT: @OBJC_SELECTOR_REFERENCES_
+
+// CHECK: @OBJC_CLASS_NAME_.{{[0-9]+}} = private unnamed_addr constant [11 x i8] c"OtherClass\00", section "__TEXT,__cstring,cstring_literals", align 1
+// CHECK: @OBJC_CLASS_REFERENCES_.{{[0-9]+}} = private global ptr @OBJC_CLASS_NAME_.{{[0-9]+}}, section "__OBJC,__cls_refs,literal_pointers,no_dead_strip", align 4
+
+// CHECK: @OBJC_METH_VAR_NAME_.{{[0-9]+}} = private unnamed_addr constant [12 x i8] c"otherMethod\00", section "__TEXT,__cstring,cstring_literals", align 1
+// CHECK: @OBJC_SELECTOR_REFERENCES_.{{[0-9]+}} = private externally_initialized global ptr @OBJC_METH_VAR_NAME_.{{[0-9]+}}, section "__OBJC,__message_refs,literal_pointers,no_dead_strip", align 4
+
+// CHECK: @OBJC_CLASS_NAME_.{{[0-9]+}} = private unnamed_addr constant [1 x i8] zeroinitializer, section "__TEXT,__cstring,cstring_literals", align 1
+// CHECK: @OBJC_MODULES = private global %struct._objc_module { i32 7, i32 16, ptr @OBJC_CLASS_NAME_.{{[0-9]+}}, ptr null }, section "__OBJC,__module_info,regular,no_dead_strip", align 4
+
+// CHECK: load ptr, ptr @OBJC_CLASS_REFERENCES_.{{[0-9]+}}, align 4
+// CHECK: load ptr, ptr @OBJC_SELECTOR_REFERENCES_.{{[0-9]+}}, align 4
+// CHECK: load ptr, ptr @OBJC_CLASS_REFERENCES_.{{[0-9]+}}, align 4
+// CHECK: load ptr, ptr @OBJC_SELECTOR_REFERENCES_.{{[0-9]+}}, align 4
+
+// CHECK: !{{[0-9]+}} = !{i32 1, !"Objective-C Version", i32 1}
+// CHECK: !{{[0-9]+}} = !{i32 1, !"Objective-C Image Info Version", i32 0}
+// CHECK: !{{[0-9]+}} = !{i32 1, !"Objective-C Image Info Section", !"__OBJC,__image_info,regular"}
+// CHECK-NOT: !{{[0-9]+}} = !{i32 1, !"Objective-C Is Simulated", i32 32}
+// CHECK: !{{[0-9]+}} = !{i32 1, !"Objective-C Class Properties", i32 64}
diff --git a/tests/codegen-llvm/darwin-objc-abi-v2.rs b/tests/codegen-llvm/darwin-objc-abi-v2.rs
new file mode 100644
index 0000000000000..f142371d5825b
--- /dev/null
+++ b/tests/codegen-llvm/darwin-objc-abi-v2.rs
@@ -0,0 +1,185 @@
+// ignore-tidy-linelength
+//@ add-core-stubs
+//@ revisions: x86_64_macos
+//@ [x86_64_macos] compile-flags: --target x86_64-apple-darwin
+//@ [x86_64_macos] needs-llvm-components: x86
+//@ revisions: aarch64_macos
+//@ [aarch64_macos] compile-flags: --target aarch64-apple-darwin
+//@ [aarch64_macos] needs-llvm-components: aarch64
+//@ revisions: i386_ios
+//@ [i386_ios] compile-flags: --target i386-apple-ios
+//@ [i386_ios] needs-llvm-components: x86
+//@ revisions: x86_64_ios
+//@ [x86_64_ios] compile-flags: --target x86_64-apple-ios
+//@ [x86_64_ios] needs-llvm-components: x86
+//@ revisions: armv7s_ios
+//@ [armv7s_ios] compile-flags: --target armv7s-apple-ios
+//@ [armv7s_ios] needs-llvm-components: arm
+//@ revisions: aarch64_ios
+//@ [aarch64_ios] compile-flags: --target aarch64-apple-ios
+//@ [aarch64_ios] needs-llvm-components: aarch64
+//@ revisions: aarch64_ios_sim
+//@ [aarch64_ios_sim] compile-flags: --target aarch64-apple-ios-sim
+//@ [aarch64_ios_sim] needs-llvm-components: aarch64
+
+#![crate_type = "lib"]
+#![feature(no_core, lang_items, rustc_attrs)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+#[no_mangle]
+pub fn get_class() -> *mut () {
+    unsafe extern "C" {
+        #[rustc_objc_class = "MyClass"]
+        safe static VAL: *mut ();
+    }
+    VAL
+}
+
+#[no_mangle]
+pub fn get_class_again() -> *mut () {
+    // Codegen should de-duplicate this class with the one from get_class above.
+    unsafe extern "C" {
+        #[rustc_objc_class = "MyClass"]
+        safe static VAL: *mut ();
+    }
+    VAL
+}
+
+#[no_mangle]
+pub fn get_selector() -> *mut () {
+    unsafe extern "C" {
+        #[rustc_objc_selector = "myMethod"]
+        safe static VAL: *mut ();
+    }
+    VAL
+}
+
+#[no_mangle]
+pub fn get_selector_again() -> *mut () {
+    // Codegen should de-duplicate this selector with the one from get_selector above.
+    unsafe extern "C" {
+        #[rustc_objc_selector = "myMethod"]
+        safe static VAL: *mut ();
+    }
+    VAL
+}
+
+#[no_mangle]
+pub fn get_other_class() -> *mut () {
+    unsafe extern "C" {
+        #[rustc_objc_class = "OtherClass"]
+        safe static VAL: *mut ();
+    }
+    VAL
+}
+
+#[no_mangle]
+pub fn get_other_selector() -> *mut () {
+    unsafe extern "C" {
+        #[rustc_objc_selector = "otherMethod"]
+        safe static VAL: *mut ();
+    }
+    VAL
+}
+
+// CHECK: %struct._class_t = type { ptr, ptr, ptr, ptr, ptr }
+
+// CHECK: @"OBJC_CLASS_$_MyClass" = external global %struct._class_t
+// CHECK: @"OBJC_CLASSLIST_REFERENCES_$_.{{[0-9]+}}" = internal global ptr @"OBJC_CLASS_$_MyClass", section "__DATA,__objc_classrefs,regular,no_dead_strip",
+// x86_64_macos-SAME: align 8
+// aarch64_macos-SAME: align 8
+// i386_ios-SAME: align 4
+// x86_64_ios-SAME: align 8
+// armv7s_ios-SAME: align 4
+// aarch64_ios-SAME: align 8
+// aarch64_ios_sim-SAME: align 8
+// CHECK-NOT: @"OBJC_CLASS_$_MyClass"
+// CHECK-NOT: @"OBJC_CLASSLIST_REFERENCES_$_
+
+// CHECK: @OBJC_METH_VAR_NAME_.{{[0-9]+}} = private unnamed_addr constant [9 x i8] c"myMethod\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+// CHECK: @OBJC_SELECTOR_REFERENCES_.{{[0-9]+}} = internal externally_initialized global ptr @OBJC_METH_VAR_NAME_.{{[0-9]+}}, section "__DATA,__objc_selrefs,literal_pointers,no_dead_strip",
+// x86_64_macos-SAME: align 8
+// aarch64_macos-SAME: align 8
+// i386_ios-SAME: align 4
+// x86_64_ios-SAME: align 8
+// armv7s_ios-SAME: align 4
+// aarch64_ios-SAME: align 8
+// aarch64_ios_sim-SAME: align 8
+// CHECK-NOT: @OBJC_METH_VAR_NAME_
+// CHECK-NOT: @OBJC_SELECTOR_REFERENCES_
+
+// CHECK: @"OBJC_CLASS_$_OtherClass" = external global %struct._class_t
+// CHECK: @"OBJC_CLASSLIST_REFERENCES_$_.{{[0-9]+}}" = internal global ptr @"OBJC_CLASS_$_OtherClass", section "__DATA,__objc_classrefs,regular,no_dead_strip",
+// x86_64_macos-SAME: align 8
+// aarch64_macos-SAME: align 8
+// i386_ios-SAME: align 4
+// x86_64_ios-SAME: align 8
+// armv7s_ios-SAME: align 4
+// aarch64_ios-SAME: align 8
+// aarch64_ios_sim-SAME: align 8
+
+// CHECK: @OBJC_METH_VAR_NAME_.{{[0-9]+}} = private unnamed_addr constant [12 x i8] c"otherMethod\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+// CHECK: @OBJC_SELECTOR_REFERENCES_.{{[0-9]+}} = internal externally_initialized global ptr @OBJC_METH_VAR_NAME_.{{[0-9]+}}, section "__DATA,__objc_selrefs,literal_pointers,no_dead_strip",
+// x86_64_macos-SAME: align 8
+// aarch64_macos-SAME: align 8
+// i386_ios-SAME: align 4
+// x86_64_ios-SAME: align 8
+// armv7s_ios-SAME: align 4
+// aarch64_ios-SAME: align 8
+// aarch64_ios_sim-SAME: align 8
+
+// CHECK-NOT: @OBJC_CLASS_NAME_
+// CHECK-NOT: @OBJC_MODULES
+
+// CHECK: load ptr, ptr @"OBJC_CLASSLIST_REFERENCES_$_.{{[0-9]+}}",
+// x86_64_macos-SAME: align 8
+// aarch64_macos-SAME: align 8
+// i386_ios-SAME: align 4
+// x86_64_ios-SAME: align 8
+// armv7s_ios-SAME: align 4
+// aarch64_ios-SAME: align 8
+// aarch64_ios_sim-SAME: align 8
+
+// CHECK: load ptr, ptr @OBJC_SELECTOR_REFERENCES_.{{[0-9]+}},
+// x86_64_macos-SAME: align 8
+// aarch64_macos-SAME: align 8
+// i386_ios-SAME: align 4
+// x86_64_ios-SAME: align 8
+// armv7s_ios-SAME: align 4
+// aarch64_ios-SAME: align 8
+// aarch64_ios_sim-SAME: align 8
+
+// CHECK: load ptr, ptr @"OBJC_CLASSLIST_REFERENCES_$_.{{[0-9]+}}",
+// x86_64_macos-SAME: align 8
+// aarch64_macos-SAME: align 8
+// i386_ios-SAME: align 4
+// x86_64_ios-SAME: align 8
+// armv7s_ios-SAME: align 4
+// aarch64_ios-SAME: align 8
+// aarch64_ios_sim-SAME: align 8
+
+// CHECK: load ptr, ptr @OBJC_SELECTOR_REFERENCES_.{{[0-9]+}},
+// x86_64_macos-SAME: align 8
+// aarch64_macos-SAME: align 8
+// i386_ios-SAME: align 4
+// x86_64_ios-SAME: align 8
+// armv7s_ios-SAME: align 4
+// aarch64_ios-SAME: align 8
+// aarch64_ios_sim-SAME: align 8
+
+// CHECK: !{{[0-9]+}} = !{i32 1, !"Objective-C Version", i32 2}
+// CHECK: !{{[0-9]+}} = !{i32 1, !"Objective-C Image Info Version", i32 0}
+// CHECK: !{{[0-9]+}} = !{i32 1, !"Objective-C Image Info Section", !"__DATA,__objc_imageinfo,regular,no_dead_strip"}
+
+// x86_64_macos-NOT: !{{[0-9]+}} = !{i32 1, !"Objective-C Is Simulated", i32 32}
+// aarch64_macos-NOT: !{{[0-9]+}} = !{i32 1, !"Objective-C Is Simulated", i32 32}
+// i386_ios: !{{[0-9]+}} = !{i32 1, !"Objective-C Is Simulated", i32 32}
+// x86_64_ios: !{{[0-9]+}} = !{i32 1, !"Objective-C Is Simulated", i32 32}
+// armv7s_ios-NOT: !{{[0-9]+}} = !{i32 1, !"Objective-C Is Simulated", i32 32}
+// aarch64_ios-NOT: !{{[0-9]+}} = !{i32 1, !"Objective-C Is Simulated", i32 32}
+// aarch64_ios_sim: !{{[0-9]+}} = !{i32 1, !"Objective-C Is Simulated", i32 32}
+
+// CHECK: !{{[0-9]+}} = !{i32 1, !"Objective-C Class Properties", i32 64}
diff --git a/tests/codegen-llvm/darwin-objc-cross-crate.rs b/tests/codegen-llvm/darwin-objc-cross-crate.rs
new file mode 100644
index 0000000000000..74ad9a27346d1
--- /dev/null
+++ b/tests/codegen-llvm/darwin-objc-cross-crate.rs
@@ -0,0 +1,58 @@
+// Test that Objective-C class and selector references inlined across crates
+// get defined in this CGU but non-inline references don't.
+
+// ignore-tidy-linelength
+//@ aux-build: darwin_objc_aux.rs
+//@ revisions: x86_64_macos aarch64_macos
+//@ [x86_64_macos] only-x86_64-apple-darwin
+//@ [aarch64_macos] only-aarch64-apple-darwin
+
+#![crate_type = "lib"]
+#![feature(darwin_objc)]
+
+use std::os::darwin::objc;
+
+extern crate darwin_objc_aux as aux;
+
+#[no_mangle]
+pub fn get_object_class() -> objc::Class {
+    aux::inline_get_object_class()
+}
+
+#[no_mangle]
+pub fn get_alloc_selector() -> objc::SEL {
+    aux::inline_get_alloc_selector()
+}
+
+#[no_mangle]
+pub fn get_string_class() -> objc::Class {
+    aux::never_inline_get_string_class()
+}
+
+#[no_mangle]
+pub fn get_init_selector() -> objc::SEL {
+    aux::never_inline_get_init_selector()
+}
+
+// CHECK: %struct._class_t = type { ptr, ptr, ptr, ptr, ptr }
+
+// CHECK: @"OBJC_CLASS_$_NSObject" = external global %struct._class_t
+// CHECK: @"OBJC_CLASSLIST_REFERENCES_$_.{{[0-9]+}}" = internal global ptr @"OBJC_CLASS_$_NSObject", section "__DATA,__objc_classrefs,regular,no_dead_strip", align 8
+
+// CHECK: @OBJC_METH_VAR_NAME_.{{[0-9]+}} = private unnamed_addr constant [6 x i8] c"alloc\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+// CHECK: @OBJC_SELECTOR_REFERENCES_.{{[0-9]+}} = internal externally_initialized global ptr @OBJC_METH_VAR_NAME_.{{[0-9]+}}, section "__DATA,__objc_selrefs,literal_pointers,no_dead_strip", align 8
+
+// CHECK-NOT: @"OBJC_CLASS_$_NSString" = external global %struct._class_t
+// CHECK-NOT: @"OBJC_CLASSLIST_REFERENCES_$_.{{[0-9]+}}" = internal global ptr @"OBJC_CLASS_$_NSString"
+
+// CHECK-NOT: @OBJC_METH_VAR_NAME_.{{[0-9]+}} = private unnamed_addr constant [5 x i8] c"init\00"
+// CHECK-NOT: @OBJC_SELECTOR_REFERENCES_.{{[0-9]+}} = internal externally_initialized global ptr @OBJC_METH_VAR_NAME_.{{[0-9]+}}
+
+// CHECK: load ptr, ptr @"OBJC_CLASSLIST_REFERENCES_$_.{{[0-9]+}}", align 8
+// CHECK: load ptr, ptr @OBJC_SELECTOR_REFERENCES_.{{[0-9]+}}, align 8
+
+// CHECK: !{{[0-9]+}} = !{i32 1, !"Objective-C Version", i32 2}
+// CHECK: !{{[0-9]+}} = !{i32 1, !"Objective-C Image Info Version", i32 0}
+// CHECK: !{{[0-9]+}} = !{i32 1, !"Objective-C Image Info Section", !"__DATA,__objc_imageinfo,regular,no_dead_strip"}
+// CHECK-NOT: !{{[0-9]+}} = !{i32 1, !"Objective-C Is Simulated", i32 32}
+// CHECK: !{{[0-9]+}} = !{i32 1, !"Objective-C Class Properties", i32 64}
diff --git a/tests/ui/README.md b/tests/ui/README.md
index 66c1bb905a792..3b28ef694dd30 100644
--- a/tests/ui/README.md
+++ b/tests/ui/README.md
@@ -350,6 +350,12 @@ Tests for FFI with C varargs (`va_list`).
 
 Tests for detection and handling of cyclic trait dependencies.
 
+## `tests/ui/darwin-objc/`: Darwin Objective-C
+
+Tests exercising `#![feature(darwin_objc)]`.
+
+See [Tracking Issue for `darwin_objc` #145496](https://github.com/rust-lang/rust/issues/145496).
+
 ## `tests/ui/dataflow_const_prop/`
 
 Contains a single regression test for const prop in `SwitchInt` pass crashing when `ptr2int` transmute is involved.
diff --git a/tests/ui/darwin-objc/darwin-objc-bad-arg.rs b/tests/ui/darwin-objc/darwin-objc-bad-arg.rs
new file mode 100644
index 0000000000000..70eb83aa052d1
--- /dev/null
+++ b/tests/ui/darwin-objc/darwin-objc-bad-arg.rs
@@ -0,0 +1,36 @@
+// Test that `objc::class!` and `objc::selector!` only take string literals.
+
+//@ edition: 2024
+//@ only-apple
+
+#![feature(darwin_objc)]
+
+use std::os::darwin::objc;
+
+pub fn main() {
+    let s = "NSObject";
+    objc::class!(s);
+    //~^ ERROR attribute value must be a literal
+
+    objc::class!(NSObject);
+    //~^ ERROR attribute value must be a literal
+
+    objc::class!(123);
+    //~^ ERROR `objc::class!` expected a string literal
+
+    objc::class!("NSObject\0");
+    //~^ ERROR `objc::class!` may not contain null characters
+
+    let s = "alloc";
+    objc::selector!(s);
+    //~^ ERROR attribute value must be a literal
+
+    objc::selector!(alloc);
+    //~^ ERROR attribute value must be a literal
+
+    objc::selector!(123);
+    //~^ ERROR `objc::selector!` expected a string literal
+
+    objc::selector!("alloc\0");
+    //~^ ERROR `objc::selector!` may not contain null characters
+}
diff --git a/tests/ui/darwin-objc/darwin-objc-bad-arg.stderr b/tests/ui/darwin-objc/darwin-objc-bad-arg.stderr
new file mode 100644
index 0000000000000..99eeb27e30c1b
--- /dev/null
+++ b/tests/ui/darwin-objc/darwin-objc-bad-arg.stderr
@@ -0,0 +1,50 @@
+error: attribute value must be a literal
+  --> $DIR/darwin-objc-bad-arg.rs:12:18
+   |
+LL |     objc::class!(s);
+   |                  ^
+
+error: attribute value must be a literal
+  --> $DIR/darwin-objc-bad-arg.rs:15:18
+   |
+LL |     objc::class!(NSObject);
+   |                  ^^^^^^^^
+
+error: `objc::class!` expected a string literal
+  --> $DIR/darwin-objc-bad-arg.rs:18:18
+   |
+LL |     objc::class!(123);
+   |                  ^^^
+
+error: `objc::class!` may not contain null characters
+  --> $DIR/darwin-objc-bad-arg.rs:21:18
+   |
+LL |     objc::class!("NSObject\0");
+   |                  ^^^^^^^^^^^^
+
+error: attribute value must be a literal
+  --> $DIR/darwin-objc-bad-arg.rs:25:21
+   |
+LL |     objc::selector!(s);
+   |                     ^
+
+error: attribute value must be a literal
+  --> $DIR/darwin-objc-bad-arg.rs:28:21
+   |
+LL |     objc::selector!(alloc);
+   |                     ^^^^^
+
+error: `objc::selector!` expected a string literal
+  --> $DIR/darwin-objc-bad-arg.rs:31:21
+   |
+LL |     objc::selector!(123);
+   |                     ^^^
+
+error: `objc::selector!` may not contain null characters
+  --> $DIR/darwin-objc-bad-arg.rs:34:21
+   |
+LL |     objc::selector!("alloc\0");
+   |                     ^^^^^^^^^
+
+error: aborting due to 8 previous errors
+
diff --git a/tests/ui/darwin-objc/darwin-objc-bad-const.rs b/tests/ui/darwin-objc/darwin-objc-bad-const.rs
new file mode 100644
index 0000000000000..ccf28697b482a
--- /dev/null
+++ b/tests/ui/darwin-objc/darwin-objc-bad-const.rs
@@ -0,0 +1,17 @@
+// Test that `objc::class!` and `objc::selector!` aren't `const` expressions.
+// The system gives them their final values at dynamic load time.
+
+//@ edition: 2024
+//@ only-apple
+
+#![feature(darwin_objc)]
+
+use std::os::darwin::objc;
+
+pub const CLASS: objc::Class = objc::class!("NSObject");
+//~^ ERROR cannot access extern static `CLASS::VAL` [E0080]
+
+pub const SELECTOR: objc::SEL = objc::selector!("alloc");
+//~^ ERROR cannot access extern static `SELECTOR::VAL` [E0080]
+
+pub fn main() {}
diff --git a/tests/ui/darwin-objc/darwin-objc-bad-const.stderr b/tests/ui/darwin-objc/darwin-objc-bad-const.stderr
new file mode 100644
index 0000000000000..43d0b7d761f17
--- /dev/null
+++ b/tests/ui/darwin-objc/darwin-objc-bad-const.stderr
@@ -0,0 +1,19 @@
+error[E0080]: cannot access extern static `CLASS::VAL`
+  --> $DIR/darwin-objc-bad-const.rs:11:32
+   |
+LL | pub const CLASS: objc::Class = objc::class!("NSObject");
+   |                                ^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `CLASS` failed here
+   |
+   = note: this error originates in the macro `objc::class` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0080]: cannot access extern static `SELECTOR::VAL`
+  --> $DIR/darwin-objc-bad-const.rs:14:33
+   |
+LL | pub const SELECTOR: objc::SEL = objc::selector!("alloc");
+   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `SELECTOR` failed here
+   |
+   = note: this error originates in the macro `objc::selector` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/darwin-objc/darwin-objc-bad-ref.rs b/tests/ui/darwin-objc/darwin-objc-bad-ref.rs
new file mode 100644
index 0000000000000..fb1437366dd43
--- /dev/null
+++ b/tests/ui/darwin-objc/darwin-objc-bad-ref.rs
@@ -0,0 +1,31 @@
+// Test that `objc::class!` and `objc::selector!` can't be returned by reference.
+// A single instance may have multiple addresses (e.g. across dylib boundaries).
+
+//@ edition: 2024
+//@ only-apple
+
+#![feature(darwin_objc)]
+
+use std::os::darwin::objc;
+
+pub fn class_ref<'a>() -> &'a objc::Class {
+    &objc::class!("NSObject")
+    //~^ ERROR cannot return reference to temporary value [E0515]
+}
+
+pub fn class_ref_static() -> &'static objc::Class {
+    &objc::class!("NSObject")
+    //~^ ERROR cannot return reference to temporary value [E0515]
+}
+
+pub fn selector_ref<'a>() -> &'a objc::SEL {
+    &objc::selector!("alloc")
+    //~^ ERROR cannot return reference to temporary value [E0515]
+}
+
+pub fn selector_ref_static() -> &'static objc::SEL {
+    &objc::selector!("alloc")
+    //~^ ERROR cannot return reference to temporary value [E0515]
+}
+
+pub fn main() {}
diff --git a/tests/ui/darwin-objc/darwin-objc-bad-ref.stderr b/tests/ui/darwin-objc/darwin-objc-bad-ref.stderr
new file mode 100644
index 0000000000000..b09e6a75c844d
--- /dev/null
+++ b/tests/ui/darwin-objc/darwin-objc-bad-ref.stderr
@@ -0,0 +1,39 @@
+error[E0515]: cannot return reference to temporary value
+  --> $DIR/darwin-objc-bad-ref.rs:12:5
+   |
+LL |     &objc::class!("NSObject")
+   |     ^------------------------
+   |     ||
+   |     |temporary value created here
+   |     returns a reference to data owned by the current function
+
+error[E0515]: cannot return reference to temporary value
+  --> $DIR/darwin-objc-bad-ref.rs:17:5
+   |
+LL |     &objc::class!("NSObject")
+   |     ^------------------------
+   |     ||
+   |     |temporary value created here
+   |     returns a reference to data owned by the current function
+
+error[E0515]: cannot return reference to temporary value
+  --> $DIR/darwin-objc-bad-ref.rs:22:5
+   |
+LL |     &objc::selector!("alloc")
+   |     ^------------------------
+   |     ||
+   |     |temporary value created here
+   |     returns a reference to data owned by the current function
+
+error[E0515]: cannot return reference to temporary value
+  --> $DIR/darwin-objc-bad-ref.rs:27:5
+   |
+LL |     &objc::selector!("alloc")
+   |     ^------------------------
+   |     ||
+   |     |temporary value created here
+   |     returns a reference to data owned by the current function
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0515`.
diff --git a/tests/ui/darwin-objc/darwin-objc-class-selector.rs b/tests/ui/darwin-objc/darwin-objc-class-selector.rs
new file mode 100644
index 0000000000000..b9a2fc3634f46
--- /dev/null
+++ b/tests/ui/darwin-objc/darwin-objc-class-selector.rs
@@ -0,0 +1,31 @@
+// Call `[NSObject class]` using `objc::class!` and `objc::selector!`.
+
+//@ edition: 2024
+//@ only-apple
+//@ run-pass
+
+#![feature(darwin_objc)]
+
+use std::mem::transmute;
+use std::os::darwin::objc;
+
+#[link(name = "Foundation", kind = "framework")]
+unsafe extern "C" {}
+
+#[link(name = "objc", kind = "dylib")]
+unsafe extern "C" {
+    unsafe fn objc_msgSend();
+}
+
+fn main() {
+    let msg_send_fn = unsafe {
+        transmute::<
+            unsafe extern "C" fn(),
+            unsafe extern "C" fn(objc::Class, objc::SEL) -> objc::Class,
+        >(objc_msgSend)
+    };
+    let static_sel = objc::selector!("class");
+    let static_class = objc::class!("NSObject");
+    let runtime_class = unsafe { msg_send_fn(static_class, static_sel) };
+    assert_eq!(static_class, runtime_class);
+}
diff --git a/tests/ui/darwin-objc/darwin-objc-class.rs b/tests/ui/darwin-objc/darwin-objc-class.rs
new file mode 100644
index 0000000000000..851149d872683
--- /dev/null
+++ b/tests/ui/darwin-objc/darwin-objc-class.rs
@@ -0,0 +1,39 @@
+// Test that `objc::class!` returns the same thing as `objc_lookUpClass`.
+
+//@ edition: 2024
+//@ only-apple
+//@ run-pass
+
+#![feature(darwin_objc)]
+
+use std::ffi::c_char;
+use std::os::darwin::objc;
+
+#[link(name = "Foundation", kind = "framework")]
+unsafe extern "C" {}
+
+#[link(name = "objc")]
+unsafe extern "C" {
+    fn objc_lookUpClass(methname: *const c_char) -> objc::Class;
+}
+
+fn get_object_class() -> objc::Class {
+    objc::class!("NSObject")
+}
+
+fn lookup_object_class() -> objc::Class {
+    unsafe { objc_lookUpClass(c"NSObject".as_ptr()) }
+}
+
+fn get_string_class() -> objc::Class {
+    objc::class!("NSString")
+}
+
+fn lookup_string_class() -> objc::Class {
+    unsafe { objc_lookUpClass(c"NSString".as_ptr()) }
+}
+
+fn main() {
+    assert_eq!(get_object_class(), lookup_object_class());
+    assert_eq!(get_string_class(), lookup_string_class());
+}
diff --git a/tests/ui/darwin-objc/darwin-objc-selector.rs b/tests/ui/darwin-objc/darwin-objc-selector.rs
new file mode 100644
index 0000000000000..008ae4c4ca457
--- /dev/null
+++ b/tests/ui/darwin-objc/darwin-objc-selector.rs
@@ -0,0 +1,36 @@
+// Test that `objc::selector!` returns the same thing as `sel_registerName`.
+
+//@ edition: 2024
+//@ only-apple
+//@ run-pass
+
+#![feature(darwin_objc)]
+
+use std::ffi::c_char;
+use std::os::darwin::objc;
+
+#[link(name = "objc")]
+unsafe extern "C" {
+    fn sel_registerName(methname: *const c_char) -> objc::SEL;
+}
+
+fn get_alloc_selector() -> objc::SEL {
+    objc::selector!("alloc")
+}
+
+fn register_alloc_selector() -> objc::SEL {
+    unsafe { sel_registerName(c"alloc".as_ptr()) }
+}
+
+fn get_init_selector() -> objc::SEL {
+    objc::selector!("initWithCString:encoding:")
+}
+
+fn register_init_selector() -> objc::SEL {
+    unsafe { sel_registerName(c"initWithCString:encoding:".as_ptr()) }
+}
+
+fn main() {
+    assert_eq!(get_alloc_selector(), register_alloc_selector());
+    assert_eq!(get_init_selector(), register_init_selector());
+}

From 15f6d2e8d276ba908dfa05e55eeb629373024f57 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Sun, 14 Sep 2025 01:12:34 +0200
Subject: [PATCH 0907/1889] rustdoc: Move HTML-specific attr rendering code
 into HTML rendering mod

These functions used to be shared with the JSON backend but nowadays they
aren't.
---
 src/librustdoc/clean/types.rs     | 112 ------------------
 src/librustdoc/html/render/mod.rs | 181 +++++++++++++++++++++++-------
 2 files changed, 143 insertions(+), 150 deletions(-)

diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index dcd67cb7ebc77..53ae8afc027d0 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -801,50 +801,6 @@ impl Item {
         Some(tcx.visibility(def_id))
     }
 
-    /// Get a list of attributes excluding `#[repr]` to display.
-    ///
-    /// Only used by the HTML output-format.
-    fn attributes_without_repr(&self) -> Vec<String> {
-        self.attrs
-            .other_attrs
-            .iter()
-            .filter_map(|attr| match attr {
-                hir::Attribute::Parsed(AttributeKind::LinkSection { name, .. }) => {
-                    Some(format!("#[unsafe(link_section = \"{name}\")]"))
-                }
-                hir::Attribute::Parsed(AttributeKind::NoMangle(..)) => {
-                    Some("#[unsafe(no_mangle)]".to_string())
-                }
-                hir::Attribute::Parsed(AttributeKind::ExportName { name, .. }) => {
-                    Some(format!("#[unsafe(export_name = \"{name}\")]"))
-                }
-                hir::Attribute::Parsed(AttributeKind::NonExhaustive(..)) => {
-                    Some("#[non_exhaustive]".to_string())
-                }
-                _ => None,
-            })
-            .collect()
-    }
-
-    /// Get a list of attributes to display on this item.
-    ///
-    /// Only used by the HTML output-format.
-    pub(crate) fn attributes(&self, tcx: TyCtxt<'_>, cache: &Cache) -> Vec<String> {
-        let mut attrs = self.attributes_without_repr();
-
-        if let Some(repr_attr) = self.repr(tcx, cache) {
-            attrs.push(repr_attr);
-        }
-        attrs
-    }
-
-    /// Returns a stringified `#[repr(...)]` attribute.
-    ///
-    /// Only used by the HTML output-format.
-    pub(crate) fn repr(&self, tcx: TyCtxt<'_>, cache: &Cache) -> Option<String> {
-        repr_attributes(tcx, cache, self.def_id()?, self.type_())
-    }
-
     pub fn is_doc_hidden(&self) -> bool {
         self.attrs.is_doc_hidden()
     }
@@ -854,74 +810,6 @@ impl Item {
     }
 }
 
-/// Return a string representing the `#[repr]` attribute if present.
-///
-/// Only used by the HTML output-format.
-pub(crate) fn repr_attributes(
-    tcx: TyCtxt<'_>,
-    cache: &Cache,
-    def_id: DefId,
-    item_type: ItemType,
-) -> Option<String> {
-    use rustc_abi::IntegerType;
-
-    if !matches!(item_type, ItemType::Struct | ItemType::Enum | ItemType::Union) {
-        return None;
-    }
-    let adt = tcx.adt_def(def_id);
-    let repr = adt.repr();
-    let mut out = Vec::new();
-    if repr.c() {
-        out.push("C");
-    }
-    if repr.transparent() {
-        // Render `repr(transparent)` iff the non-1-ZST field is public or at least one
-        // field is public in case all fields are 1-ZST fields.
-        let render_transparent = cache.document_private
-            || adt
-                .all_fields()
-                .find(|field| {
-                    let ty = field.ty(tcx, ty::GenericArgs::identity_for_item(tcx, field.did));
-                    tcx.layout_of(ty::TypingEnv::post_analysis(tcx, field.did).as_query_input(ty))
-                        .is_ok_and(|layout| !layout.is_1zst())
-                })
-                .map_or_else(
-                    || adt.all_fields().any(|field| field.vis.is_public()),
-                    |field| field.vis.is_public(),
-                );
-
-        if render_transparent {
-            out.push("transparent");
-        }
-    }
-    if repr.simd() {
-        out.push("simd");
-    }
-    let pack_s;
-    if let Some(pack) = repr.pack {
-        pack_s = format!("packed({})", pack.bytes());
-        out.push(&pack_s);
-    }
-    let align_s;
-    if let Some(align) = repr.align {
-        align_s = format!("align({})", align.bytes());
-        out.push(&align_s);
-    }
-    let int_s;
-    if let Some(int) = repr.int {
-        int_s = match int {
-            IntegerType::Pointer(is_signed) => {
-                format!("{}size", if is_signed { 'i' } else { 'u' })
-            }
-            IntegerType::Fixed(size, is_signed) => {
-                format!("{}{}", if is_signed { 'i' } else { 'u' }, size.size().bytes() * 8)
-            }
-        };
-        out.push(&int_s);
-    }
-    if !out.is_empty() { Some(format!("#[repr({})]", out.join(", "))) } else { None }
-}
-
 #[derive(Clone, Debug)]
 pub(crate) enum ItemKind {
     ExternCrateItem {
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index b4ef47d1e2694..cc2744e48c8f6 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -51,7 +51,8 @@ use askama::Template;
 use itertools::Either;
 use rustc_ast::join_path_syms;
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
-use rustc_hir::attrs::{DeprecatedSince, Deprecation};
+use rustc_hir as hir;
+use rustc_hir::attrs::{AttributeKind, DeprecatedSince, Deprecation};
 use rustc_hir::def_id::{DefId, DefIdSet};
 use rustc_hir::{ConstStability, Mutability, RustcVersion, StabilityLevel, StableSince};
 use rustc_middle::ty::print::PrintTraitRefExt;
@@ -1310,43 +1311,6 @@ fn render_assoc_item(
     })
 }
 
-struct CodeAttribute(String);
-
-fn render_code_attribute(prefix: &str, code_attr: CodeAttribute, w: &mut impl fmt::Write) {
-    write!(
-        w,
-        "<div class=\"code-attribute\">{prefix}{attr}</div>",
-        prefix = prefix,
-        attr = code_attr.0
-    )
-    .unwrap();
-}
-
-// When an attribute is rendered inside a <code> tag, it is formatted using
-// a div to produce a newline after it.
-fn render_attributes_in_code(
-    w: &mut impl fmt::Write,
-    it: &clean::Item,
-    prefix: &str,
-    cx: &Context<'_>,
-) {
-    for attr in it.attributes(cx.tcx(), cx.cache()) {
-        render_code_attribute(prefix, CodeAttribute(attr), w);
-    }
-}
-
-/// used for type aliases to only render their `repr` attribute.
-fn render_repr_attributes_in_code(
-    w: &mut impl fmt::Write,
-    cx: &Context<'_>,
-    def_id: DefId,
-    item_type: ItemType,
-) {
-    if let Some(repr) = clean::repr_attributes(cx.tcx(), cx.cache(), def_id, item_type) {
-        render_code_attribute("", CodeAttribute(repr), w);
-    }
-}
-
 #[derive(Copy, Clone)]
 enum AssocItemLink<'a> {
     Anchor(Option<&'a str>),
@@ -2959,3 +2923,144 @@ fn render_call_locations<W: fmt::Write>(
 
     w.write_str("</div>")
 }
+
+struct CodeAttribute(String);
+
+fn render_code_attribute(prefix: &str, code_attr: CodeAttribute, w: &mut impl fmt::Write) {
+    write!(
+        w,
+        "<div class=\"code-attribute\">{prefix}{attr}</div>",
+        prefix = prefix,
+        attr = code_attr.0
+    )
+    .unwrap();
+}
+
+// When an attribute is rendered inside a <code> tag, it is formatted using
+// a div to produce a newline after it.
+fn render_attributes_in_code(
+    w: &mut impl fmt::Write,
+    item: &clean::Item,
+    prefix: &str,
+    cx: &Context<'_>,
+) {
+    for attr in attributes(item, cx.tcx(), cx.cache()) {
+        render_code_attribute(prefix, CodeAttribute(attr), w);
+    }
+}
+
+/// used for type aliases to only render their `repr` attribute.
+fn render_repr_attributes_in_code(
+    w: &mut impl fmt::Write,
+    cx: &Context<'_>,
+    def_id: DefId,
+    item_type: ItemType,
+) {
+    if let Some(repr) = repr_attributes(cx.tcx(), cx.cache(), def_id, item_type) {
+        render_code_attribute("", CodeAttribute(repr), w);
+    }
+}
+
+/// Get a list of attributes excluding `#[repr]` to display.
+fn attributes_without_repr(item: &clean::Item) -> Vec<String> {
+    item.attrs
+        .other_attrs
+        .iter()
+        .filter_map(|attr| match attr {
+            hir::Attribute::Parsed(AttributeKind::LinkSection { name, .. }) => {
+                Some(format!("#[unsafe(link_section = \"{name}\")]"))
+            }
+            hir::Attribute::Parsed(AttributeKind::NoMangle(..)) => {
+                Some("#[unsafe(no_mangle)]".to_string())
+            }
+            hir::Attribute::Parsed(AttributeKind::ExportName { name, .. }) => {
+                Some(format!("#[unsafe(export_name = \"{name}\")]"))
+            }
+            hir::Attribute::Parsed(AttributeKind::NonExhaustive(..)) => {
+                Some("#[non_exhaustive]".to_string())
+            }
+            _ => None,
+        })
+        .collect()
+}
+
+/// Get a list of attributes to display on this item.
+fn attributes(item: &clean::Item, tcx: TyCtxt<'_>, cache: &Cache) -> Vec<String> {
+    let mut attrs = attributes_without_repr(item);
+
+    if let Some(repr_attr) = repr(item, tcx, cache) {
+        attrs.push(repr_attr);
+    }
+    attrs
+}
+
+/// Returns a stringified `#[repr(...)]` attribute.
+fn repr(item: &clean::Item, tcx: TyCtxt<'_>, cache: &Cache) -> Option<String> {
+    repr_attributes(tcx, cache, item.def_id()?, item.type_())
+}
+
+/// Return a string representing the `#[repr]` attribute if present.
+pub(crate) fn repr_attributes(
+    tcx: TyCtxt<'_>,
+    cache: &Cache,
+    def_id: DefId,
+    item_type: ItemType,
+) -> Option<String> {
+    use rustc_abi::IntegerType;
+
+    if !matches!(item_type, ItemType::Struct | ItemType::Enum | ItemType::Union) {
+        return None;
+    }
+    let adt = tcx.adt_def(def_id);
+    let repr = adt.repr();
+    let mut out = Vec::new();
+    if repr.c() {
+        out.push("C");
+    }
+    if repr.transparent() {
+        // Render `repr(transparent)` iff the non-1-ZST field is public or at least one
+        // field is public in case all fields are 1-ZST fields.
+        let render_transparent = cache.document_private
+            || adt
+                .all_fields()
+                .find(|field| {
+                    let ty = field.ty(tcx, ty::GenericArgs::identity_for_item(tcx, field.did));
+                    tcx.layout_of(ty::TypingEnv::post_analysis(tcx, field.did).as_query_input(ty))
+                        .is_ok_and(|layout| !layout.is_1zst())
+                })
+                .map_or_else(
+                    || adt.all_fields().any(|field| field.vis.is_public()),
+                    |field| field.vis.is_public(),
+                );
+
+        if render_transparent {
+            out.push("transparent");
+        }
+    }
+    if repr.simd() {
+        out.push("simd");
+    }
+    let pack_s;
+    if let Some(pack) = repr.pack {
+        pack_s = format!("packed({})", pack.bytes());
+        out.push(&pack_s);
+    }
+    let align_s;
+    if let Some(align) = repr.align {
+        align_s = format!("align({})", align.bytes());
+        out.push(&align_s);
+    }
+    let int_s;
+    if let Some(int) = repr.int {
+        int_s = match int {
+            IntegerType::Pointer(is_signed) => {
+                format!("{}size", if is_signed { 'i' } else { 'u' })
+            }
+            IntegerType::Fixed(size, is_signed) => {
+                format!("{}{}", if is_signed { 'i' } else { 'u' }, size.size().bytes() * 8)
+            }
+        };
+        out.push(&int_s);
+    }
+    if !out.is_empty() { Some(format!("#[repr({})]", out.join(", "))) } else { None }
+}

From 16c720645cac29e71cc897374bb462fab42a8682 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sun, 14 Sep 2025 14:37:10 +1000
Subject: [PATCH 0908/1889] Note some previous attempts to change the Default
 impl for `[T; 0]`

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

diff --git a/library/core/src/array/mod.rs b/library/core/src/array/mod.rs
index d14419a23a1d8..d713e575b58d3 100644
--- a/library/core/src/array/mod.rs
+++ b/library/core/src/array/mod.rs
@@ -472,6 +472,11 @@ impl<T: Copy> SpecArrayClone for T {
 // The Default impls cannot be done with const generics because `[T; 0]` doesn't
 // require Default to be implemented, and having different impl blocks for
 // different numbers isn't supported yet.
+//
+// Trying to improve the `[T; 0]` situation has proven to be difficult.
+// Please see these issues for more context on past attempts and crater runs:
+// - https://github.com/rust-lang/rust/issues/61415
+// - https://github.com/rust-lang/rust/pull/145457
 
 macro_rules! array_impl_default {
     {$n:expr, $t:ident $($ts:ident)*} => {

From 3a784d9d1f292707000cdfce9072c876480471e4 Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Sun, 14 Sep 2025 04:52:56 +0000
Subject: [PATCH 0909/1889] Prepare for merging from rust-lang/rust

This updates the rust-version file to a015919e54c60b1b2bec7a98dec478cfc4a48f4e.
---
 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 e5f0be9ac9551..8315eb30f9431 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-4ba1cf9ade4c8e2fa10676a50ee34594eb161837
+a015919e54c60b1b2bec7a98dec478cfc4a48f4e

From 8df078a3f0071b311be2449407ae523f89ca6a33 Mon Sep 17 00:00:00 2001
From: Tsukasa OI <floss_rust@irq.a4lg.com>
Date: Sat, 13 Sep 2025 21:59:39 +0000
Subject: [PATCH 0910/1889] RISC-V: Improvements of inline assembly uses

This commit performs various improvements (better register allocation,
less register clobbering on the worst case and better readability) of
RISC-V inline assembly use cases.

Note that it does not change the `p` module (which defines the "P"
extension draft instructions but very likely to change).

1.  Use `lateout` as possible.
    Unlike `out(reg)` and `in(reg)` pair, `lateout(reg)` and `in(reg)`
    can share the same register because they state that the late-output
    register is written after all the reads are performed.
    It can improve register allocation.
2.  Add `preserves_flags` option as possible.
    While RISC-V doesn't have _regular_ condition codes, RISC-V inline
    assembly in the Rust language assumes that some registers
    (mainly vector state registers) may be overwritten by default.
    By adding `preserves_flags` to the intrinsics corresponding
    instructions without overwriting them, it can minimize register
    clobbering on the worst case.
3.  Use trailing semicolon.
    As `asm!` declares an action and it doesn't return a value by
    itself, it would be better to have trailing semicolon to denote that
    an `asm!` call is effectively a statement.
4.  Make most of `asm!` calls multi-lined.
    `rustfmt` makes some simple (yet long) `asm!` calls multi-lined but
    it does not perform formatting of complex `asm!` calls with inputs
    and/or outputs.  To keep consistency, it makes most of the `asm!`
    calls multi-lined.
---
 .../crates/core_arch/src/riscv64/mod.rs       |  21 +-
 .../crates/core_arch/src/riscv_shared/mod.rs  | 245 ++++++++++++++----
 2 files changed, 215 insertions(+), 51 deletions(-)

diff --git a/library/stdarch/crates/core_arch/src/riscv64/mod.rs b/library/stdarch/crates/core_arch/src/riscv64/mod.rs
index 0e860f6f2ad2f..a7efc0c7f58a1 100644
--- a/library/stdarch/crates/core_arch/src/riscv64/mod.rs
+++ b/library/stdarch/crates/core_arch/src/riscv64/mod.rs
@@ -20,7 +20,12 @@ pub use zk::*;
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hlv_wu(src: *const u32) -> u32 {
     let value: u32;
-    asm!(".insn i 0x73, 0x4, {}, {}, 0x681", out(reg) value, in(reg) src, options(readonly, nostack));
+    asm!(
+        ".insn i 0x73, 0x4, {}, {}, 0x681",
+        lateout(reg) value,
+        in(reg) src,
+        options(readonly, nostack, preserves_flags)
+    );
     value
 }
 
@@ -38,7 +43,12 @@ pub unsafe fn hlv_wu(src: *const u32) -> u32 {
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hlv_d(src: *const i64) -> i64 {
     let value: i64;
-    asm!(".insn i 0x73, 0x4, {}, {}, 0x6C0", out(reg) value, in(reg) src, options(readonly, nostack));
+    asm!(
+        ".insn i 0x73, 0x4, {}, {}, 0x6C0",
+        lateout(reg) value,
+        in(reg) src,
+        options(readonly, nostack, preserves_flags)
+    );
     value
 }
 
@@ -53,5 +63,10 @@ pub unsafe fn hlv_d(src: *const i64) -> i64 {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hsv_d(dst: *mut i64, src: i64) {
-    asm!(".insn r 0x73, 0x4, 0x37, x0, {}, {}", in(reg) dst, in(reg) src, options(nostack));
+    asm!(
+        ".insn r 0x73, 0x4, 0x37, x0, {}, {}",
+        in(reg) dst,
+        in(reg) src,
+        options(nostack, preserves_flags)
+    );
 }
diff --git a/library/stdarch/crates/core_arch/src/riscv_shared/mod.rs b/library/stdarch/crates/core_arch/src/riscv_shared/mod.rs
index 3ce24324de2e7..1bd147a64808c 100644
--- a/library/stdarch/crates/core_arch/src/riscv_shared/mod.rs
+++ b/library/stdarch/crates/core_arch/src/riscv_shared/mod.rs
@@ -44,7 +44,12 @@ use crate::arch::asm;
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub fn pause() {
-    unsafe { asm!(".insn i 0x0F, 0, x0, x0, 0x010", options(nomem, nostack)) }
+    unsafe {
+        asm!(
+            ".insn i 0x0F, 0, x0, x0, 0x010",
+            options(nomem, nostack, preserves_flags)
+        );
+    }
 }
 
 /// Generates the `NOP` instruction
@@ -54,7 +59,9 @@ pub fn pause() {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub fn nop() {
-    unsafe { asm!("nop", options(nomem, nostack)) }
+    unsafe {
+        asm!("nop", options(nomem, nostack, preserves_flags));
+    }
 }
 
 /// Generates the `WFI` instruction
@@ -65,7 +72,7 @@ pub fn nop() {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn wfi() {
-    asm!("wfi", options(nomem, nostack))
+    asm!("wfi", options(nomem, nostack, preserves_flags));
 }
 
 /// Generates the `FENCE.I` instruction
@@ -78,7 +85,7 @@ pub unsafe fn wfi() {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn fence_i() {
-    asm!("fence.i", options(nostack))
+    asm!("fence.i", options(nostack, preserves_flags));
 }
 
 /// Supervisor memory management fence for given virtual address and address space
@@ -92,7 +99,7 @@ pub unsafe fn fence_i() {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn sfence_vma(vaddr: usize, asid: usize) {
-    asm!("sfence.vma {}, {}", in(reg) vaddr, in(reg) asid, options(nostack))
+    asm!("sfence.vma {}, {}", in(reg) vaddr, in(reg) asid, options(nostack, preserves_flags));
 }
 
 /// Supervisor memory management fence for given virtual address
@@ -104,7 +111,7 @@ pub unsafe fn sfence_vma(vaddr: usize, asid: usize) {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn sfence_vma_vaddr(vaddr: usize) {
-    asm!("sfence.vma {}, x0", in(reg) vaddr, options(nostack))
+    asm!("sfence.vma {}, x0", in(reg) vaddr, options(nostack, preserves_flags));
 }
 
 /// Supervisor memory management fence for given address space
@@ -118,7 +125,7 @@ pub unsafe fn sfence_vma_vaddr(vaddr: usize) {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn sfence_vma_asid(asid: usize) {
-    asm!("sfence.vma x0, {}", in(reg) asid, options(nostack))
+    asm!("sfence.vma x0, {}", in(reg) asid, options(nostack, preserves_flags));
 }
 
 /// Supervisor memory management fence for all address spaces and virtual addresses
@@ -129,7 +136,7 @@ pub unsafe fn sfence_vma_asid(asid: usize) {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn sfence_vma_all() {
-    asm!("sfence.vma", options(nostack))
+    asm!("sfence.vma", options(nostack, preserves_flags));
 }
 
 /// Invalidate supervisor translation cache for given virtual address and address space
@@ -139,8 +146,13 @@ pub unsafe fn sfence_vma_all() {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn sinval_vma(vaddr: usize, asid: usize) {
-    // asm!("sinval.vma {}, {}", in(reg) vaddr, in(reg) asid, options(nostack))
-    asm!(".insn r 0x73, 0, 0x0B, x0, {}, {}", in(reg) vaddr, in(reg) asid, options(nostack))
+    // asm!("sinval.vma {}, {}", in(reg) vaddr, in(reg) asid, options(nostack, preserves_flags));
+    asm!(
+        ".insn r 0x73, 0, 0x0B, x0, {}, {}",
+        in(reg) vaddr,
+        in(reg) asid,
+        options(nostack, preserves_flags)
+    );
 }
 
 /// Invalidate supervisor translation cache for given virtual address
@@ -150,7 +162,11 @@ pub unsafe fn sinval_vma(vaddr: usize, asid: usize) {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn sinval_vma_vaddr(vaddr: usize) {
-    asm!(".insn r 0x73, 0, 0x0B, x0, {}, x0", in(reg) vaddr, options(nostack))
+    asm!(
+        ".insn r 0x73, 0, 0x0B, x0, {}, x0",
+        in(reg) vaddr,
+        options(nostack, preserves_flags)
+    );
 }
 
 /// Invalidate supervisor translation cache for given address space
@@ -160,7 +176,11 @@ pub unsafe fn sinval_vma_vaddr(vaddr: usize) {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn sinval_vma_asid(asid: usize) {
-    asm!(".insn r 0x73, 0, 0x0B, x0, x0, {}", in(reg) asid, options(nostack))
+    asm!(
+        ".insn r 0x73, 0, 0x0B, x0, x0, {}",
+        in(reg) asid,
+        options(nostack, preserves_flags)
+    );
 }
 
 /// Invalidate supervisor translation cache for all address spaces and virtual addresses
@@ -170,7 +190,10 @@ pub unsafe fn sinval_vma_asid(asid: usize) {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn sinval_vma_all() {
-    asm!(".insn r 0x73, 0, 0x0B, x0, x0, x0", options(nostack))
+    asm!(
+        ".insn r 0x73, 0, 0x0B, x0, x0, x0",
+        options(nostack, preserves_flags)
+    );
 }
 
 /// Generates the `SFENCE.W.INVAL` instruction
@@ -180,8 +203,11 @@ pub unsafe fn sinval_vma_all() {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn sfence_w_inval() {
-    // asm!("sfence.w.inval", options(nostack))
-    asm!(".insn i 0x73, 0, x0, x0, 0x180", options(nostack))
+    // asm!("sfence.w.inval", options(nostack, preserves_flags));
+    asm!(
+        ".insn i 0x73, 0, x0, x0, 0x180",
+        options(nostack, preserves_flags)
+    );
 }
 
 /// Generates the `SFENCE.INVAL.IR` instruction
@@ -191,8 +217,11 @@ pub unsafe fn sfence_w_inval() {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn sfence_inval_ir() {
-    // asm!("sfence.inval.ir", options(nostack))
-    asm!(".insn i 0x73, 0, x0, x0, 0x181", options(nostack))
+    // asm!("sfence.inval.ir", options(nostack, preserves_flags));
+    asm!(
+        ".insn i 0x73, 0, x0, x0, 0x181",
+        options(nostack, preserves_flags)
+    );
 }
 
 /// Loads virtual machine memory by signed byte integer
@@ -207,7 +236,12 @@ pub unsafe fn sfence_inval_ir() {
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hlv_b(src: *const i8) -> i8 {
     let value: i8;
-    asm!(".insn i 0x73, 0x4, {}, {}, 0x600", out(reg) value, in(reg) src, options(readonly, nostack));
+    asm!(
+        ".insn i 0x73, 0x4, {}, {}, 0x600",
+        lateout(reg) value,
+        in(reg) src,
+        options(readonly, nostack, preserves_flags)
+    );
     value
 }
 
@@ -223,7 +257,12 @@ pub unsafe fn hlv_b(src: *const i8) -> i8 {
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hlv_bu(src: *const u8) -> u8 {
     let value: u8;
-    asm!(".insn i 0x73, 0x4, {}, {}, 0x601", out(reg) value, in(reg) src, options(readonly, nostack));
+    asm!(
+        ".insn i 0x73, 0x4, {}, {}, 0x601",
+        lateout(reg) value,
+        in(reg) src,
+        options(readonly, nostack, preserves_flags)
+    );
     value
 }
 
@@ -239,7 +278,12 @@ pub unsafe fn hlv_bu(src: *const u8) -> u8 {
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hlv_h(src: *const i16) -> i16 {
     let value: i16;
-    asm!(".insn i 0x73, 0x4, {}, {}, 0x640", out(reg) value, in(reg) src, options(readonly, nostack));
+    asm!(
+        ".insn i 0x73, 0x4, {}, {}, 0x640",
+        lateout(reg) value,
+        in(reg) src,
+        options(readonly, nostack, preserves_flags)
+    );
     value
 }
 
@@ -255,7 +299,12 @@ pub unsafe fn hlv_h(src: *const i16) -> i16 {
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hlv_hu(src: *const u16) -> u16 {
     let value: u16;
-    asm!(".insn i 0x73, 0x4, {}, {}, 0x641", out(reg) value, in(reg) src, options(readonly, nostack));
+    asm!(
+        ".insn i 0x73, 0x4, {}, {}, 0x641",
+        lateout(reg) value,
+        in(reg) src,
+        options(readonly, nostack, preserves_flags)
+    );
     value
 }
 
@@ -271,7 +320,12 @@ pub unsafe fn hlv_hu(src: *const u16) -> u16 {
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hlvx_hu(src: *const u16) -> u16 {
     let insn: u16;
-    asm!(".insn i 0x73, 0x4, {}, {}, 0x643", out(reg) insn, in(reg) src, options(readonly, nostack));
+    asm!(
+        ".insn i 0x73, 0x4, {}, {}, 0x643",
+        lateout(reg) insn,
+        in(reg) src,
+        options(readonly, nostack, preserves_flags)
+    );
     insn
 }
 
@@ -287,7 +341,12 @@ pub unsafe fn hlvx_hu(src: *const u16) -> u16 {
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hlv_w(src: *const i32) -> i32 {
     let value: i32;
-    asm!(".insn i 0x73, 0x4, {}, {}, 0x680", out(reg) value, in(reg) src, options(readonly, nostack));
+    asm!(
+        ".insn i 0x73, 0x4, {}, {}, 0x680",
+        lateout(reg) value,
+        in(reg) src,
+        options(readonly, nostack, preserves_flags)
+    );
     value
 }
 
@@ -303,7 +362,12 @@ pub unsafe fn hlv_w(src: *const i32) -> i32 {
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hlvx_wu(src: *const u32) -> u32 {
     let insn: u32;
-    asm!(".insn i 0x73, 0x4, {}, {}, 0x683", out(reg) insn, in(reg) src, options(readonly, nostack));
+    asm!(
+        ".insn i 0x73, 0x4, {}, {}, 0x683",
+        lateout(reg) insn,
+        in(reg) src,
+        options(readonly, nostack, preserves_flags)
+    );
     insn
 }
 
@@ -318,7 +382,12 @@ pub unsafe fn hlvx_wu(src: *const u32) -> u32 {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hsv_b(dst: *mut i8, src: i8) {
-    asm!(".insn r 0x73, 0x4, 0x31, x0, {}, {}", in(reg) dst, in(reg) src, options(nostack));
+    asm!(
+        ".insn r 0x73, 0x4, 0x31, x0, {}, {}",
+        in(reg) dst,
+        in(reg) src,
+        options(nostack, preserves_flags)
+    );
 }
 
 /// Stores virtual machine memory by half integer
@@ -332,7 +401,12 @@ pub unsafe fn hsv_b(dst: *mut i8, src: i8) {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hsv_h(dst: *mut i16, src: i16) {
-    asm!(".insn r 0x73, 0x4, 0x33, x0, {}, {}", in(reg) dst, in(reg) src, options(nostack));
+    asm!(
+        ".insn r 0x73, 0x4, 0x33, x0, {}, {}",
+        in(reg) dst,
+        in(reg) src,
+        options(nostack, preserves_flags)
+    );
 }
 
 /// Stores virtual machine memory by word integer
@@ -346,7 +420,12 @@ pub unsafe fn hsv_h(dst: *mut i16, src: i16) {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hsv_w(dst: *mut i32, src: i32) {
-    asm!(".insn r 0x73, 0x4, 0x35, x0, {}, {}", in(reg) dst, in(reg) src, options(nostack));
+    asm!(
+        ".insn r 0x73, 0x4, 0x35, x0, {}, {}",
+        in(reg) dst,
+        in(reg) src,
+        options(nostack, preserves_flags)
+    );
 }
 
 /// Hypervisor memory management fence for given guest virtual address and guest address space
@@ -360,8 +439,13 @@ pub unsafe fn hsv_w(dst: *mut i32, src: i32) {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hfence_vvma(vaddr: usize, asid: usize) {
-    // asm!("hfence.vvma {}, {}", in(reg) vaddr, in(reg) asid)
-    asm!(".insn r 0x73, 0, 0x11, x0, {}, {}", in(reg) vaddr, in(reg) asid, options(nostack))
+    // asm!("hfence.vvma {}, {}", in(reg) vaddr, in(reg) asid, options(nostack, preserves_flags));
+    asm!(
+        ".insn r 0x73, 0, 0x11, x0, {}, {}",
+        in(reg) vaddr,
+        in(reg) asid,
+        options(nostack, preserves_flags)
+    );
 }
 
 /// Hypervisor memory management fence for given guest virtual address
@@ -375,7 +459,11 @@ pub unsafe fn hfence_vvma(vaddr: usize, asid: usize) {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hfence_vvma_vaddr(vaddr: usize) {
-    asm!(".insn r 0x73, 0, 0x11, x0, {}, x0", in(reg) vaddr, options(nostack))
+    asm!(
+        ".insn r 0x73, 0, 0x11, x0, {}, x0",
+        in(reg) vaddr,
+        options(nostack, preserves_flags)
+    );
 }
 
 /// Hypervisor memory management fence for given guest address space
@@ -389,7 +477,11 @@ pub unsafe fn hfence_vvma_vaddr(vaddr: usize) {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hfence_vvma_asid(asid: usize) {
-    asm!(".insn r 0x73, 0, 0x11, x0, x0, {}", in(reg) asid, options(nostack))
+    asm!(
+        ".insn r 0x73, 0, 0x11, x0, x0, {}",
+        in(reg) asid,
+        options(nostack, preserves_flags)
+    );
 }
 
 /// Hypervisor memory management fence for all guest address spaces and guest virtual addresses
@@ -403,7 +495,10 @@ pub unsafe fn hfence_vvma_asid(asid: usize) {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hfence_vvma_all() {
-    asm!(".insn r 0x73, 0, 0x11, x0, x0, x0", options(nostack))
+    asm!(
+        ".insn r 0x73, 0, 0x11, x0, x0, x0",
+        options(nostack, preserves_flags)
+    );
 }
 
 /// Hypervisor memory management fence for guest physical address and virtual machine
@@ -416,8 +511,13 @@ pub unsafe fn hfence_vvma_all() {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hfence_gvma(gaddr: usize, vmid: usize) {
-    // asm!("hfence.gvma {}, {}", in(reg) gaddr, in(reg) vmid, options(nostack))
-    asm!(".insn r 0x73, 0, 0x31, x0, {}, {}", in(reg) gaddr, in(reg) vmid, options(nostack))
+    // asm!("hfence.gvma {}, {}", in(reg) gaddr, in(reg) vmid, options(nostack, preserves_flags));
+    asm!(
+        ".insn r 0x73, 0, 0x31, x0, {}, {}",
+        in(reg) gaddr,
+        in(reg) vmid,
+        options(nostack, preserves_flags)
+    );
 }
 
 /// Hypervisor memory management fence for guest physical address
@@ -429,7 +529,11 @@ pub unsafe fn hfence_gvma(gaddr: usize, vmid: usize) {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hfence_gvma_gaddr(gaddr: usize) {
-    asm!(".insn r 0x73, 0, 0x31, x0, {}, x0", in(reg) gaddr, options(nostack))
+    asm!(
+        ".insn r 0x73, 0, 0x31, x0, {}, x0",
+        in(reg) gaddr,
+        options(nostack, preserves_flags)
+    );
 }
 
 /// Hypervisor memory management fence for given virtual machine
@@ -441,7 +545,11 @@ pub unsafe fn hfence_gvma_gaddr(gaddr: usize) {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hfence_gvma_vmid(vmid: usize) {
-    asm!(".insn r 0x73, 0, 0x31, x0, x0, {}", in(reg) vmid, options(nostack))
+    asm!(
+        ".insn r 0x73, 0, 0x31, x0, x0, {}",
+        in(reg) vmid,
+        options(nostack, preserves_flags)
+    );
 }
 
 /// Hypervisor memory management fence for all virtual machines and guest physical addresses
@@ -453,7 +561,10 @@ pub unsafe fn hfence_gvma_vmid(vmid: usize) {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hfence_gvma_all() {
-    asm!(".insn r 0x73, 0, 0x31, x0, x0, x0", options(nostack))
+    asm!(
+        ".insn r 0x73, 0, 0x31, x0, x0, x0",
+        options(nostack, preserves_flags)
+    );
 }
 
 /// Invalidate hypervisor translation cache for given guest virtual address and guest address space
@@ -465,8 +576,13 @@ pub unsafe fn hfence_gvma_all() {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hinval_vvma(vaddr: usize, asid: usize) {
-    // asm!("hinval.vvma {}, {}", in(reg) vaddr, in(reg) asid, options(nostack))
-    asm!(".insn r 0x73, 0, 0x13, x0, {}, {}", in(reg) vaddr, in(reg) asid, options(nostack))
+    // asm!("hinval.vvma {}, {}", in(reg) vaddr, in(reg) asid, options(nostack, preserves_flags));
+    asm!(
+        ".insn r 0x73, 0, 0x13, x0, {}, {}",
+        in(reg) vaddr,
+        in(reg) asid,
+        options(nostack, preserves_flags)
+    );
 }
 
 /// Invalidate hypervisor translation cache for given guest virtual address
@@ -478,7 +594,11 @@ pub unsafe fn hinval_vvma(vaddr: usize, asid: usize) {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hinval_vvma_vaddr(vaddr: usize) {
-    asm!(".insn r 0x73, 0, 0x13, x0, {}, x0", in(reg) vaddr, options(nostack))
+    asm!(
+        ".insn r 0x73, 0, 0x13, x0, {}, x0",
+        in(reg) vaddr,
+        options(nostack, preserves_flags)
+    );
 }
 
 /// Invalidate hypervisor translation cache for given guest address space
@@ -490,7 +610,11 @@ pub unsafe fn hinval_vvma_vaddr(vaddr: usize) {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hinval_vvma_asid(asid: usize) {
-    asm!(".insn r 0x73, 0, 0x13, x0, x0, {}", in(reg) asid, options(nostack))
+    asm!(
+        ".insn r 0x73, 0, 0x13, x0, x0, {}",
+        in(reg) asid,
+        options(nostack, preserves_flags)
+    );
 }
 
 /// Invalidate hypervisor translation cache for all guest address spaces and guest virtual addresses
@@ -502,7 +626,10 @@ pub unsafe fn hinval_vvma_asid(asid: usize) {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hinval_vvma_all() {
-    asm!(".insn r 0x73, 0, 0x13, x0, x0, x0", options(nostack))
+    asm!(
+        ".insn r 0x73, 0, 0x13, x0, x0, x0",
+        options(nostack, preserves_flags)
+    );
 }
 
 /// Invalidate hypervisor translation cache for guest physical address and virtual machine
@@ -515,8 +642,13 @@ pub unsafe fn hinval_vvma_all() {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hinval_gvma(gaddr: usize, vmid: usize) {
-    // asm!("hinval.gvma {}, {}", in(reg) gaddr, in(reg) vmid, options(nostack))
-    asm!(".insn r 0x73, 0, 0x33, x0, {}, {}", in(reg) gaddr, in(reg) vmid, options(nostack))
+    // asm!("hinval.gvma {}, {}", in(reg) gaddr, in(reg) vmid, options(nostack, preserves_flags));
+    asm!(
+        ".insn r 0x73, 0, 0x33, x0, {}, {}",
+        in(reg) gaddr,
+        in(reg) vmid,
+        options(nostack, preserves_flags)
+    );
 }
 
 /// Invalidate hypervisor translation cache for guest physical address
@@ -528,7 +660,11 @@ pub unsafe fn hinval_gvma(gaddr: usize, vmid: usize) {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hinval_gvma_gaddr(gaddr: usize) {
-    asm!(".insn r 0x73, 0, 0x33, x0, {}, x0", in(reg) gaddr, options(nostack))
+    asm!(
+        ".insn r 0x73, 0, 0x33, x0, {}, x0",
+        in(reg) gaddr,
+        options(nostack, preserves_flags)
+    );
 }
 
 /// Invalidate hypervisor translation cache for given virtual machine
@@ -540,7 +676,11 @@ pub unsafe fn hinval_gvma_gaddr(gaddr: usize) {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hinval_gvma_vmid(vmid: usize) {
-    asm!(".insn r 0x73, 0, 0x33, x0, x0, {}", in(reg) vmid, options(nostack))
+    asm!(
+        ".insn r 0x73, 0, 0x33, x0, x0, {}",
+        in(reg) vmid,
+        options(nostack, preserves_flags)
+    );
 }
 
 /// Invalidate hypervisor translation cache for all virtual machines and guest physical addresses
@@ -552,7 +692,10 @@ pub unsafe fn hinval_gvma_vmid(vmid: usize) {
 #[inline]
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub unsafe fn hinval_gvma_all() {
-    asm!(".insn r 0x73, 0, 0x33, x0, x0, x0", options(nostack))
+    asm!(
+        ".insn r 0x73, 0, 0x33, x0, x0, x0",
+        options(nostack, preserves_flags)
+    );
 }
 
 /// Reads the floating-point rounding mode register `frm`
@@ -574,6 +717,12 @@ pub unsafe fn hinval_gvma_all() {
 #[unstable(feature = "riscv_ext_intrinsics", issue = "114544")]
 pub fn frrm() -> u32 {
     let value: u32;
-    unsafe { asm!("frrm {}", out(reg) value, options(nomem, nostack)) };
+    unsafe {
+        asm!(
+            "frrm {}",
+            out(reg) value,
+            options(nomem, nostack, preserves_flags)
+        );
+    }
     value
 }

From f56eb060479e6dcb386f7a67fa9f13ae3c31e6f7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Wed, 10 Sep 2025 11:01:34 -0700
Subject: [PATCH 0911/1889] merge crate-level into ALLOWED_TARGETS

---
 .../src/attributes/crate_level.rs             | 40 ++++---------------
 .../rustc_attr_parsing/src/attributes/mod.rs  | 18 +--------
 .../src/attributes/prelude.rs                 |  2 +-
 .../src/attributes/traits.rs                  |  5 +--
 compiler/rustc_attr_parsing/src/context.rs    |  4 +-
 compiler/rustc_attr_parsing/src/interface.rs  |  1 -
 .../rustc_attr_parsing/src/target_checking.rs | 15 +++++--
 7 files changed, 23 insertions(+), 62 deletions(-)

diff --git a/compiler/rustc_attr_parsing/src/attributes/crate_level.rs b/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
index 0b2c05482bfaa..4611de4445997 100644
--- a/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
@@ -43,11 +43,7 @@ impl<S: Stage> SingleAttributeParser<S> for CrateNameParser {
     const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "name");
-    const TYPE: AttributeType = AttributeType::CrateLevel;
-
-    // because it's a crate-level attribute, we already warn about it.
-    // Putting target limitations here would give duplicate warnings
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
         let ArgParser::NameValue(n) = args else {
@@ -76,11 +72,7 @@ impl<S: Stage> SingleAttributeParser<S> for RecursionLimitParser {
     const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N", "https://doc.rust-lang.org/reference/attributes/limits.html#the-recursion_limit-attribute");
-    const TYPE: AttributeType = AttributeType::CrateLevel;
-
-    // because it's a crate-level attribute, we already warn about it.
-    // Putting target limitations here would give duplicate warnings
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
         let ArgParser::NameValue(nv) = args else {
@@ -103,11 +95,7 @@ impl<S: Stage> SingleAttributeParser<S> for MoveSizeLimitParser {
     const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N");
-    const TYPE: AttributeType = AttributeType::CrateLevel;
-
-    // because it's a crate-level attribute, we already warn about it.
-    // Putting target limitations here would give duplicate warnings
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
         let ArgParser::NameValue(nv) = args else {
@@ -130,11 +118,7 @@ impl<S: Stage> SingleAttributeParser<S> for TypeLengthLimitParser {
     const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N");
-    const TYPE: AttributeType = AttributeType::CrateLevel;
-
-    // because it's a crate-level attribute, we already warn about it.
-    // Putting target limitations here would give duplicate warnings
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
         let ArgParser::NameValue(nv) = args else {
@@ -157,11 +141,7 @@ impl<S: Stage> SingleAttributeParser<S> for PatternComplexityLimitParser {
     const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N");
-    const TYPE: AttributeType = AttributeType::CrateLevel;
-
-    // because it's a crate-level attribute, we already warn about it.
-    // Putting target limitations here would give duplicate warnings
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
         let ArgParser::NameValue(nv) = args else {
@@ -182,11 +162,8 @@ pub(crate) struct NoCoreParser;
 impl<S: Stage> NoArgsAttributeParser<S> for NoCoreParser {
     const PATH: &[Symbol] = &[sym::no_core];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
-    // because it's a crate-level attribute, we already warn about it.
-    // Putting target limitations here would give duplicate warnings
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::NoCore;
-    const TYPE: AttributeType = AttributeType::CrateLevel;
 }
 
 pub(crate) struct NoStdParser;
@@ -194,9 +171,6 @@ pub(crate) struct NoStdParser;
 impl<S: Stage> NoArgsAttributeParser<S> for NoStdParser {
     const PATH: &[Symbol] = &[sym::no_std];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
-    // because it's a crate-level attribute, we already warn about it.
-    // Putting target limitations here would give duplicate warnings
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::NoStd;
-    const TYPE: AttributeType = AttributeType::CrateLevel;
 }
diff --git a/compiler/rustc_attr_parsing/src/attributes/mod.rs b/compiler/rustc_attr_parsing/src/attributes/mod.rs
index 043bc925eac9f..4ed13d239b9d6 100644
--- a/compiler/rustc_attr_parsing/src/attributes/mod.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/mod.rs
@@ -12,15 +12,11 @@
 //! - [`CombineAttributeParser`](crate::attributes::CombineAttributeParser): makes it easy to implement an attribute which should combine the
 //! contents of attributes, if an attribute appear multiple times in a list
 //!
-//! By default, attributes are allowed anywhere. When adding an attribute that should only be used
-//! at the crate root, consider setting the `TYPE` in the parser trait to
-//! [`AttributeType::CrateLevel`](rustc_feature::AttributeType::CrateLevel).
-//!
 //! Attributes should be added to `crate::context::ATTRIBUTE_PARSERS` to be parsed.
 
 use std::marker::PhantomData;
 
-use rustc_feature::{AttributeTemplate, AttributeType, template};
+use rustc_feature::{AttributeTemplate, template};
 use rustc_hir::attrs::AttributeKind;
 use rustc_span::{Span, Symbol};
 use thin_vec::ThinVec;
@@ -89,11 +85,8 @@ pub(crate) trait AttributeParser<S: Stage>: Default + 'static {
     ///
     /// If an attribute has this symbol, the `accept` function will be called on it.
     const ATTRIBUTES: AcceptMapping<Self, S>;
-
     const ALLOWED_TARGETS: AllowedTargets;
 
-    const TYPE: AttributeType = AttributeType::Normal;
-
     /// The parser has gotten a chance to accept the attributes on an item,
     /// here it can produce an attribute.
     ///
@@ -135,8 +128,6 @@ pub(crate) trait SingleAttributeParser<S: Stage>: 'static {
     /// The template this attribute parser should implement. Used for diagnostics.
     const TEMPLATE: AttributeTemplate;
 
-    const TYPE: AttributeType = AttributeType::Normal;
-
     /// Converts a single syntactical attribute to a single semantic attribute, or [`AttributeKind`]
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind>;
 }
@@ -183,8 +174,6 @@ impl<T: SingleAttributeParser<S>, S: Stage> AttributeParser<S> for Single<T, S>
     )];
     const ALLOWED_TARGETS: AllowedTargets = T::ALLOWED_TARGETS;
 
-    const TYPE: AttributeType = T::TYPE;
-
     fn finalize(self, _cx: &FinalizeContext<'_, '_, S>) -> Option<AttributeKind> {
         Some(self.1?.0)
     }
@@ -269,7 +258,6 @@ pub(crate) trait NoArgsAttributeParser<S: Stage>: 'static {
     const PATH: &[Symbol];
     const ON_DUPLICATE: OnDuplicate<S>;
     const ALLOWED_TARGETS: AllowedTargets;
-    const TYPE: AttributeType = AttributeType::Normal;
 
     /// Create the [`AttributeKind`] given attribute's [`Span`].
     const CREATE: fn(Span) -> AttributeKind;
@@ -289,7 +277,6 @@ impl<T: NoArgsAttributeParser<S>, S: Stage> SingleAttributeParser<S> for Without
     const ON_DUPLICATE: OnDuplicate<S> = T::ON_DUPLICATE;
     const ALLOWED_TARGETS: AllowedTargets = T::ALLOWED_TARGETS;
     const TEMPLATE: AttributeTemplate = template!(Word);
-    const TYPE: AttributeType = T::TYPE;
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
         if let Err(span) = args.no_args() {
@@ -323,8 +310,6 @@ pub(crate) trait CombineAttributeParser<S: Stage>: 'static {
     /// The template this attribute parser should implement. Used for diagnostics.
     const TEMPLATE: AttributeTemplate;
 
-    const TYPE: AttributeType = AttributeType::Normal;
-
     /// Converts a single syntactical attribute to a number of elements of the semantic attribute, or [`AttributeKind`]
     fn extend<'c>(
         cx: &'c mut AcceptContext<'_, '_, S>,
@@ -360,7 +345,6 @@ impl<T: CombineAttributeParser<S>, S: Stage> AttributeParser<S> for Combine<T, S
             group.items.extend(T::extend(cx, args))
         })];
     const ALLOWED_TARGETS: AllowedTargets = T::ALLOWED_TARGETS;
-    const TYPE: AttributeType = T::TYPE;
 
     fn finalize(self, _cx: &FinalizeContext<'_, '_, S>) -> Option<AttributeKind> {
         if let Some(first_span) = self.first_span {
diff --git a/compiler/rustc_attr_parsing/src/attributes/prelude.rs b/compiler/rustc_attr_parsing/src/attributes/prelude.rs
index 8f040ffb9d41c..980366b5c372f 100644
--- a/compiler/rustc_attr_parsing/src/attributes/prelude.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/prelude.rs
@@ -1,6 +1,6 @@
 // data structures
 #[doc(hidden)]
-pub(super) use rustc_feature::{AttributeTemplate, AttributeType, template};
+pub(super) use rustc_feature::{AttributeTemplate, template};
 #[doc(hidden)]
 pub(super) use rustc_hir::attrs::AttributeKind;
 #[doc(hidden)]
diff --git a/compiler/rustc_attr_parsing/src/attributes/traits.rs b/compiler/rustc_attr_parsing/src/attributes/traits.rs
index fbd9a480fbb6e..c756bce96e28f 100644
--- a/compiler/rustc_attr_parsing/src/attributes/traits.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/traits.rs
@@ -1,7 +1,5 @@
 use std::mem;
 
-use rustc_feature::AttributeType;
-
 use super::prelude::*;
 use crate::attributes::{
     AttributeOrder, NoArgsAttributeParser, OnDuplicate, SingleAttributeParser,
@@ -155,8 +153,7 @@ pub(crate) struct CoherenceIsCoreParser;
 impl<S: Stage> NoArgsAttributeParser<S> for CoherenceIsCoreParser {
     const PATH: &[Symbol] = &[sym::rustc_coherence_is_core];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
-    const TYPE: AttributeType = AttributeType::CrateLevel;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::CoherenceIsCore;
 }
 
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index b3ab1d3edd6d2..d7998048be5af 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -6,7 +6,7 @@ use std::sync::LazyLock;
 use private::Sealed;
 use rustc_ast::{AttrStyle, CRATE_NODE_ID, MetaItemLit, NodeId};
 use rustc_errors::{Diag, Diagnostic, Level};
-use rustc_feature::{AttributeTemplate, AttributeType};
+use rustc_feature::AttributeTemplate;
 use rustc_hir::attrs::AttributeKind;
 use rustc_hir::lints::{AttributeLint, AttributeLintKind};
 use rustc_hir::{AttrPath, CRATE_HIR_ID, HirId};
@@ -83,7 +83,6 @@ pub(super) struct GroupTypeInnerAccept<S: Stage> {
     pub(super) template: AttributeTemplate,
     pub(super) accept_fn: AcceptFn<S>,
     pub(super) allowed_targets: AllowedTargets,
-    pub(super) attribute_type: AttributeType,
 }
 
 type AcceptFn<S> =
@@ -133,7 +132,6 @@ macro_rules! attribute_parsers {
                                 })
                             }),
                             allowed_targets: <$names as crate::attributes::AttributeParser<$stage>>::ALLOWED_TARGETS,
-                            attribute_type: <$names as crate::attributes::AttributeParser<$stage>>::TYPE,
                         });
                     }
 
diff --git a/compiler/rustc_attr_parsing/src/interface.rs b/compiler/rustc_attr_parsing/src/interface.rs
index 0fe3c209421fd..8f2de4af14e00 100644
--- a/compiler/rustc_attr_parsing/src/interface.rs
+++ b/compiler/rustc_attr_parsing/src/interface.rs
@@ -272,7 +272,6 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
 
                             (accept.accept_fn)(&mut cx, args);
                             if !matches!(cx.stage.should_emit(), ShouldEmit::Nothing) {
-                                Self::check_type(accept.attribute_type, target, &mut cx);
                                 Self::check_target(&accept.allowed_targets, target, &mut cx);
                             }
                         }
diff --git a/compiler/rustc_attr_parsing/src/target_checking.rs b/compiler/rustc_attr_parsing/src/target_checking.rs
index edc496b460cf8..c52253699b51c 100644
--- a/compiler/rustc_attr_parsing/src/target_checking.rs
+++ b/compiler/rustc_attr_parsing/src/target_checking.rs
@@ -2,7 +2,7 @@ use std::borrow::Cow;
 
 use rustc_ast::AttrStyle;
 use rustc_errors::DiagArgValue;
-use rustc_feature::{AttributeType, Features};
+use rustc_feature::Features;
 use rustc_hir::lints::AttributeLintKind;
 use rustc_hir::{MethodKind, Target};
 
@@ -14,6 +14,11 @@ use crate::session_diagnostics::InvalidTarget;
 pub(crate) enum AllowedTargets {
     AllowList(&'static [Policy]),
     AllowListWarnRest(&'static [Policy]),
+    /// Special, and not the same as `AllowList(&[Allow(Target::Crate)])`.
+    /// For crate-level attributes we emit a specific set of lints to warn
+    /// people about accidentally not using them on the crate.
+    /// Only use this for attributes that are *exclusively* valid at the crate level.
+    CrateLevel,
 }
 
 pub(crate) enum AllowedResult {
@@ -43,6 +48,7 @@ impl AllowedTargets {
                     AllowedResult::Warn
                 }
             }
+            AllowedTargets::CrateLevel => AllowedResult::Allowed,
         }
     }
 
@@ -50,6 +56,7 @@ impl AllowedTargets {
         match self {
             AllowedTargets::AllowList(list) => list,
             AllowedTargets::AllowListWarnRest(list) => list,
+            AllowedTargets::CrateLevel => ALL_TARGETS,
         }
         .iter()
         .filter_map(|target| match target {
@@ -74,6 +81,8 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
         target: Target,
         cx: &mut AcceptContext<'_, 'sess, S>,
     ) {
+        Self::check_type(matches!(allowed_targets, AllowedTargets::CrateLevel), target, cx);
+
         match allowed_targets.is_allowed(target) {
             AllowedResult::Allowed => {}
             AllowedResult::Warn => {
@@ -109,7 +118,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
     }
 
     pub(crate) fn check_type(
-        attribute_type: AttributeType,
+        crate_level: bool,
         target: Target,
         cx: &mut AcceptContext<'_, 'sess, S>,
     ) {
@@ -119,7 +128,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
             return;
         }
 
-        if attribute_type != AttributeType::CrateLevel {
+        if !crate_level {
             return;
         }
 

From d8cc5757ba92085c4fe19e86c4293bb619b2385f Mon Sep 17 00:00:00 2001
From: Laine Taffin Altman <alexanderaltman@me.com>
Date: Tue, 9 Sep 2025 22:27:37 -0700
Subject: [PATCH 0912/1889] std_detect Darwin AArch64: add new-style detection
 for FEAT_CRC32

Now that this feature has a standard identifier, Darwin has started exposing it accordingly, in addition to the existing less-standard way.  Check both, and enable the `crc` feature if either identifier for it is present to ensure backwards and forwards compatibility.
---
 library/std_detect/src/detect/os/darwin/aarch64.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/library/std_detect/src/detect/os/darwin/aarch64.rs b/library/std_detect/src/detect/os/darwin/aarch64.rs
index f5409361d93b9..89521c1c6afb7 100644
--- a/library/std_detect/src/detect/os/darwin/aarch64.rs
+++ b/library/std_detect/src/detect/os/darwin/aarch64.rs
@@ -37,12 +37,13 @@ pub(crate) fn detect_features() -> cache::Initializer {
     // Armv8.0 features not using the standard identifiers
     let fp = _sysctlbyname(c"hw.optional.floatingpoint");
     let asimd = _sysctlbyname(c"hw.optional.AdvSIMD");
-    let crc = _sysctlbyname(c"hw.optional.armv8_crc32");
+    let crc_old = _sysctlbyname(c"hw.optional.armv8_crc32");
 
     // Armv8 and Armv9 features using the standard identifiers
     let aes = _sysctlbyname(c"hw.optional.arm.FEAT_AES");
     let bf16 = _sysctlbyname(c"hw.optional.arm.FEAT_BF16");
     let bti = _sysctlbyname(c"hw.optional.arm.FEAT_BTI");
+    let crc = _sysctlbyname(c"hw.optional.arm.FEAT_CRC32");
     let cssc = _sysctlbyname(c"hw.optional.arm.FEAT_CSSC");
     let dit = _sysctlbyname(c"hw.optional.arm.FEAT_DIT");
     let dpb = _sysctlbyname(c"hw.optional.arm.FEAT_DPB");
@@ -111,7 +112,7 @@ pub(crate) fn detect_features() -> cache::Initializer {
     enable_feature(Feature::asimd, asimd);
     enable_feature(Feature::bf16, bf16);
     enable_feature(Feature::bti, bti);
-    enable_feature(Feature::crc, crc);
+    enable_feature(Feature::crc, crc_old || crc);
     enable_feature(Feature::cssc, cssc);
     enable_feature(Feature::dit, dit);
     enable_feature(Feature::dotprod, dotprod);

From edc87e301b7eee22331b147dcfac2f855fdfb03a Mon Sep 17 00:00:00 2001
From: Laine Taffin Altman <alexanderaltman@me.com>
Date: Sat, 13 Sep 2025 23:18:16 -0700
Subject: [PATCH 0913/1889] std_detect Darwin AArch64: re-alphabetize

---
 library/std_detect/src/detect/os/darwin/aarch64.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/library/std_detect/src/detect/os/darwin/aarch64.rs b/library/std_detect/src/detect/os/darwin/aarch64.rs
index 89521c1c6afb7..7d9229592aaaf 100644
--- a/library/std_detect/src/detect/os/darwin/aarch64.rs
+++ b/library/std_detect/src/detect/os/darwin/aarch64.rs
@@ -46,16 +46,16 @@ pub(crate) fn detect_features() -> cache::Initializer {
     let crc = _sysctlbyname(c"hw.optional.arm.FEAT_CRC32");
     let cssc = _sysctlbyname(c"hw.optional.arm.FEAT_CSSC");
     let dit = _sysctlbyname(c"hw.optional.arm.FEAT_DIT");
+    let dotprod = _sysctlbyname(c"hw.optional.arm.FEAT_DotProd");
     let dpb = _sysctlbyname(c"hw.optional.arm.FEAT_DPB");
     let dpb2 = _sysctlbyname(c"hw.optional.arm.FEAT_DPB2");
-    let dotprod = _sysctlbyname(c"hw.optional.arm.FEAT_DotProd");
     let ecv = _sysctlbyname(c"hw.optional.arm.FEAT_ECV");
     let fcma = _sysctlbyname(c"hw.optional.arm.FEAT_FCMA");
     let fhm = _sysctlbyname(c"hw.optional.arm.FEAT_FHM");
-    let fp16 = _sysctlbyname(c"hw.optional.arm.FEAT_FP16");
-    let frintts = _sysctlbyname(c"hw.optional.arm.FEAT_FRINTTS");
     let flagm = _sysctlbyname(c"hw.optional.arm.FEAT_FlagM");
     let flagm2 = _sysctlbyname(c"hw.optional.arm.FEAT_FlagM2");
+    let fp16 = _sysctlbyname(c"hw.optional.arm.FEAT_FP16");
+    let frintts = _sysctlbyname(c"hw.optional.arm.FEAT_FRINTTS");
     let hbc = _sysctlbyname(c"hw.optional.arm.FEAT_HBC");
     let i8mm = _sysctlbyname(c"hw.optional.arm.FEAT_I8MM");
     let jsconv = _sysctlbyname(c"hw.optional.arm.FEAT_JSCVT");

From d49f6a789ffe4b498fca1f6e173ea5ab727477a6 Mon Sep 17 00:00:00 2001
From: Laine Taffin Altman <alexanderaltman@me.com>
Date: Sat, 13 Sep 2025 23:24:16 -0700
Subject: [PATCH 0914/1889] std_detect Darwin AArch64: synchronize features

Brings the list of checkable features up to date with the initial release of macOS 26 "Tahoe".
---
 library/std_detect/src/detect/os/darwin/aarch64.rs | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/library/std_detect/src/detect/os/darwin/aarch64.rs b/library/std_detect/src/detect/os/darwin/aarch64.rs
index 7d9229592aaaf..8c9fd9647b8a2 100644
--- a/library/std_detect/src/detect/os/darwin/aarch64.rs
+++ b/library/std_detect/src/detect/os/darwin/aarch64.rs
@@ -63,6 +63,8 @@ pub(crate) fn detect_features() -> cache::Initializer {
     let rcpc2 = _sysctlbyname(c"hw.optional.arm.FEAT_LRCPC2");
     let lse = _sysctlbyname(c"hw.optional.arm.FEAT_LSE");
     let lse2 = _sysctlbyname(c"hw.optional.arm.FEAT_LSE2");
+    let mte = _sysctlbyname(c"hw.optional.arm.FEAT_MTE");
+    let mte2 = _sysctlbyname(c"hw.optional.arm.FEAT_MTE2");
     let pauth = _sysctlbyname(c"hw.optional.arm.FEAT_PAuth");
     let pmull = _sysctlbyname(c"hw.optional.arm.FEAT_PMULL");
     let rdm = _sysctlbyname(c"hw.optional.arm.FEAT_RDM");
@@ -73,6 +75,7 @@ pub(crate) fn detect_features() -> cache::Initializer {
     let sha512 = _sysctlbyname(c"hw.optional.arm.FEAT_SHA512");
     let sme = _sysctlbyname(c"hw.optional.arm.FEAT_SME");
     let sme2 = _sysctlbyname(c"hw.optional.arm.FEAT_SME2");
+    let sme2p1 = _sysctlbyname(c"hw.optional.arm.FEAT_SME2p1");
     let sme_f64f64 = _sysctlbyname(c"hw.optional.arm.FEAT_SME_F64F64");
     let sme_i16i64 = _sysctlbyname(c"hw.optional.arm.FEAT_SME_I16I64");
     let ssbs = _sysctlbyname(c"hw.optional.arm.FEAT_SSBS");
@@ -88,6 +91,12 @@ pub(crate) fn detect_features() -> cache::Initializer {
     let ebf16 = _sysctlbyname(c"hw.optional.arm.FEAT_EBF16");
     let fpac = _sysctlbyname(c"hw.optional.arm.FEAT_FPAC");
     let fpaccombine = _sysctlbyname(c"hw.optional.arm.FEAT_FPACCOMBINE");
+    let mte_async = _sysctlbyname(c"hw.optional.arm.FEAT_MTE_ASYNC");
+    let mte_canonical_tags = _sysctlbyname(c"hw.optional.arm.FEAT_MTE_CANONICAL_TAGS");
+    let mte_no_address_tags = _sysctlbyname(c"hw.optional.arm.FEAT_MTE_NO_ADDRESS_TAGS");
+    let mte_store_only = _sysctlbyname(c"hw.optional.arm.FEAT_MTE_STORE_ONLY");
+    let mte3 = _sysctlbyname(c"hw.optional.arm.FEAT_MTE3");
+    let mte4 = _sysctlbyname(c"hw.optional.arm.FEAT_MTE4");
     let pacimp = _sysctlbyname(c"hw.optional.arm.FEAT_PACIMP");
     let pauth2 = _sysctlbyname(c"hw.optional.arm.FEAT_PAuth2");
     let rpres = _sysctlbyname(c"hw.optional.arm.FEAT_RPRES");
@@ -131,6 +140,7 @@ pub(crate) fn detect_features() -> cache::Initializer {
     enable_feature(Feature::jsconv, jsconv);
     enable_feature(Feature::lse, lse);
     enable_feature(Feature::lse2, lse2);
+    enable_feature(Feature::mte, mte && mte2);
     enable_feature(Feature::paca, pauth);
     enable_feature(Feature::pacg, pauth);
     enable_feature(Feature::pmull, aes && pmull);
@@ -142,6 +152,7 @@ pub(crate) fn detect_features() -> cache::Initializer {
     enable_feature(Feature::sha3, sha512 && sha3 && asimd);
     enable_feature(Feature::sme, sme);
     enable_feature(Feature::sme2, sme2);
+    enable_feature(Feature::sme2p1, sme2p1);
     enable_feature(Feature::sme_f64f64, sme_f64f64);
     enable_feature(Feature::sme_i16i64, sme_i16i64);
     enable_feature(Feature::ssbs, ssbs);

From 074bff027e09e35b929a09ba834c68546e4a1194 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sun, 14 Sep 2025 08:56:40 +0200
Subject: [PATCH 0915/1889] Remove unnecessary `#![allow]` in test

---
 tests/ui/never_loop_fixable.fixed | 2 +-
 tests/ui/never_loop_fixable.rs    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/ui/never_loop_fixable.fixed b/tests/ui/never_loop_fixable.fixed
index 00c2af93a28ff..5bc9ff1bb4df0 100644
--- a/tests/ui/never_loop_fixable.fixed
+++ b/tests/ui/never_loop_fixable.fixed
@@ -1,4 +1,4 @@
-#![allow(clippy::iter_next_slice, clippy::needless_return, clippy::redundant_pattern_matching)]
+#![allow(clippy::iter_next_slice, clippy::needless_return)]
 
 fn no_break_or_continue_loop() {
     if let Some(i) = [1, 2, 3].iter().next() {
diff --git a/tests/ui/never_loop_fixable.rs b/tests/ui/never_loop_fixable.rs
index de85599f094d6..9782bc107e9a6 100644
--- a/tests/ui/never_loop_fixable.rs
+++ b/tests/ui/never_loop_fixable.rs
@@ -1,4 +1,4 @@
-#![allow(clippy::iter_next_slice, clippy::needless_return, clippy::redundant_pattern_matching)]
+#![allow(clippy::iter_next_slice, clippy::needless_return)]
 
 fn no_break_or_continue_loop() {
     for i in [1, 2, 3].iter() {

From b92330b7b87ba86abccd6b4f4298652a9cbed606 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sat, 30 Aug 2025 18:08:50 +0200
Subject: [PATCH 0916/1889] fix `nonstandard_macro_braces`: suggest trailing
 semicolon when needed

---
 clippy_lints/src/nonstandard_macro_braces.rs  | 91 +++++++++++++------
 .../conf_nonstandard_macro_braces.fixed       |  8 ++
 .../conf_nonstandard_macro_braces.rs          |  8 ++
 .../conf_nonstandard_macro_braces.stderr      |  8 +-
 4 files changed, 87 insertions(+), 28 deletions(-)

diff --git a/clippy_lints/src/nonstandard_macro_braces.rs b/clippy_lints/src/nonstandard_macro_braces.rs
index 83f7d9319697b..3a8a4dd0c7137 100644
--- a/clippy_lints/src/nonstandard_macro_braces.rs
+++ b/clippy_lints/src/nonstandard_macro_braces.rs
@@ -16,8 +16,8 @@ declare_clippy_lint! {
     /// Checks that common macros are used with consistent bracing.
     ///
     /// ### Why is this bad?
-    /// This is mostly a consistency lint although using () or []
-    /// doesn't give you a semicolon in item position, which can be unexpected.
+    /// Having non-conventional braces on well-stablished macros can be confusing
+    /// when debugging, and they bring incosistencies with the rest of the ecosystem.
     ///
     /// ### Example
     /// ```no_run
@@ -33,8 +33,12 @@ declare_clippy_lint! {
     "check consistent use of braces in macro"
 }
 
-/// The (callsite span, (open brace, close brace), source snippet)
-type MacroInfo = (Span, (char, char), SourceText);
+struct MacroInfo {
+    callsite_span: Span,
+    callsite_snippet: SourceText,
+    old_open_brace: char,
+    braces: (char, char),
+}
 
 pub struct MacroBraces {
     macro_braces: FxHashMap<String, (char, char)>,
@@ -54,30 +58,58 @@ impl_lint_pass!(MacroBraces => [NONSTANDARD_MACRO_BRACES]);
 
 impl EarlyLintPass for MacroBraces {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &ast::Item) {
-        if let Some((span, braces, snip)) = is_offending_macro(cx, item.span, self) {
-            emit_help(cx, &snip, braces, span);
-            self.done.insert(span);
+        if let Some(MacroInfo {
+            callsite_span,
+            callsite_snippet,
+            braces,
+            ..
+        }) = is_offending_macro(cx, item.span, self)
+        {
+            emit_help(cx, &callsite_snippet, braces, callsite_span, false);
+            self.done.insert(callsite_span);
         }
     }
 
     fn check_stmt(&mut self, cx: &EarlyContext<'_>, stmt: &ast::Stmt) {
-        if let Some((span, braces, snip)) = is_offending_macro(cx, stmt.span, self) {
-            emit_help(cx, &snip, braces, span);
-            self.done.insert(span);
+        if let Some(MacroInfo {
+            callsite_span,
+            callsite_snippet,
+            braces,
+            old_open_brace,
+        }) = is_offending_macro(cx, stmt.span, self)
+        {
+            // if we turn `macro!{}` into `macro!()`/`macro![]`, we'll no longer get the implicit
+            // trailing semicolon, see #9913
+            // NOTE: `stmt.kind != StmtKind::MacCall` because `EarlyLintPass` happens after macro expansion
+            let add_semi = matches!(stmt.kind, ast::StmtKind::Expr(..)) && old_open_brace == '{';
+            emit_help(cx, &callsite_snippet, braces, callsite_span, add_semi);
+            self.done.insert(callsite_span);
         }
     }
 
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &ast::Expr) {
-        if let Some((span, braces, snip)) = is_offending_macro(cx, expr.span, self) {
-            emit_help(cx, &snip, braces, span);
-            self.done.insert(span);
+        if let Some(MacroInfo {
+            callsite_span,
+            callsite_snippet,
+            braces,
+            ..
+        }) = is_offending_macro(cx, expr.span, self)
+        {
+            emit_help(cx, &callsite_snippet, braces, callsite_span, false);
+            self.done.insert(callsite_span);
         }
     }
 
     fn check_ty(&mut self, cx: &EarlyContext<'_>, ty: &ast::Ty) {
-        if let Some((span, braces, snip)) = is_offending_macro(cx, ty.span, self) {
-            emit_help(cx, &snip, braces, span);
-            self.done.insert(span);
+        if let Some(MacroInfo {
+            callsite_span,
+            braces,
+            callsite_snippet,
+            ..
+        }) = is_offending_macro(cx, ty.span, self)
+        {
+            emit_help(cx, &callsite_snippet, braces, callsite_span, false);
+            self.done.insert(callsite_span);
         }
     }
 }
@@ -90,39 +122,44 @@ fn is_offending_macro(cx: &EarlyContext<'_>, span: Span, mac_braces: &MacroBrace
                 .last()
                 .is_some_and(|e| e.macro_def_id.is_some_and(DefId::is_local))
     };
-    let span_call_site = span.ctxt().outer_expn_data().call_site;
+    let callsite_span = span.ctxt().outer_expn_data().call_site;
     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) = span_call_site.get_source_text(cx)
+        && let Some(snip) = callsite_span.get_source_text(cx)
         // we must check only invocation sites
         // https://github.com/rust-lang/rust-clippy/issues/7422
-        && snip.starts_with(&format!("{name}!"))
+        && let Some(macro_args_str) = snip.strip_prefix(name).and_then(|snip| snip.strip_prefix('!'))
+        && let Some(old_open_brace @ ('{' | '(' | '[')) = macro_args_str.trim_start().chars().next()
+        && old_open_brace != braces.0
         && unnested_or_local()
-        // make formatting consistent
-        && let c = snip.replace(' ', "")
-        && !c.starts_with(&format!("{name}!{}", braces.0))
-        && !mac_braces.done.contains(&span_call_site)
+        && !mac_braces.done.contains(&callsite_span)
     {
-        Some((span_call_site, braces, snip))
+        Some(MacroInfo {
+            callsite_span,
+            callsite_snippet: snip,
+            old_open_brace,
+            braces,
+        })
     } else {
         None
     }
 }
 
-fn emit_help(cx: &EarlyContext<'_>, snip: &str, (open, close): (char, char), span: Span) {
+fn emit_help(cx: &EarlyContext<'_>, snip: &str, (open, close): (char, char), span: Span, add_semi: bool) {
+    let semi = if add_semi { ";" } else { "" };
     if let Some((macro_name, macro_args_str)) = snip.split_once('!') {
         let mut macro_args = macro_args_str.trim().to_string();
         // now remove the wrong braces
-        macro_args.remove(0);
         macro_args.pop();
+        macro_args.remove(0);
         span_lint_and_sugg(
             cx,
             NONSTANDARD_MACRO_BRACES,
             span,
             format!("use of irregular braces for `{macro_name}!` macro"),
             "consider writing",
-            format!("{macro_name}!{open}{macro_args}{close}"),
+            format!("{macro_name}!{open}{macro_args}{close}{semi}"),
             Applicability::MachineApplicable,
         );
     }
diff --git a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.fixed b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.fixed
index 8da607ec65842..419e62f92f469 100644
--- a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.fixed
+++ b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.fixed
@@ -67,3 +67,11 @@ fn main() {
 
     printlnfoo!["test if printlnfoo is triggered by println"];
 }
+
+#[rustfmt::skip]
+#[expect(clippy::no_effect)]
+fn issue9913() {
+    println!("hello world");
+    [0]; // separate statement, not indexing into the result of println.
+    //~^^ nonstandard_macro_braces
+}
diff --git a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
index e35844a209fa5..b0bbced4ea3c2 100644
--- a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
+++ b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
@@ -67,3 +67,11 @@ fn main() {
 
     printlnfoo!["test if printlnfoo is triggered by println"];
 }
+
+#[rustfmt::skip]
+#[expect(clippy::no_effect)]
+fn issue9913() {
+    println! {"hello world"}
+    [0]; // separate statement, not indexing into the result of println.
+    //~^^ nonstandard_macro_braces
+}
diff --git a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr
index fda6addc7aa35..87325f05c9bcd 100644
--- a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr
+++ b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr
@@ -54,5 +54,11 @@ error: use of irregular braces for `eprint!` macro
 LL |     eprint!("test if user config overrides defaults");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `eprint!["test if user config overrides defaults"]`
 
-error: aborting due to 8 previous errors
+error: use of irregular braces for `println!` macro
+  --> tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs:74:5
+   |
+LL |     println! {"hello world"}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `println!("hello world");`
+
+error: aborting due to 9 previous errors
 

From 215c936aa0abd6a11daa8c4313f391163f15d6b8 Mon Sep 17 00:00:00 2001
From: Jonathan 'theJPster' Pallant <github@thejpster.org.uk>
Date: Sun, 7 Sep 2025 18:39:36 +0100
Subject: [PATCH 0917/1889] Promote armv7a-none-eabihf to Tier 2

This is the target for 32-bit Cortex-A bare-metal, when using the FPU.

The target is well tested by the Embedded Devices Working Group, and the
soft-float target (armv7a-none-eabi) is already Tier 2.
---
 compiler/rustc_target/src/spec/targets/armv7a_none_eabihf.rs | 2 +-
 src/doc/rustc/src/platform-support.md                        | 2 +-
 src/doc/rustc/src/platform-support/armv7a-none-eabi.md       | 3 +--
 3 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_target/src/spec/targets/armv7a_none_eabihf.rs b/compiler/rustc_target/src/spec/targets/armv7a_none_eabihf.rs
index df3a76599a753..217a79d4571e9 100644
--- a/compiler/rustc_target/src/spec/targets/armv7a_none_eabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7a_none_eabihf.rs
@@ -30,7 +30,7 @@ pub(crate) fn target() -> Target {
         llvm_target: "armv7a-none-eabihf".into(),
         metadata: TargetMetadata {
             description: Some("Bare Armv7-A, hardfloat".into()),
-            tier: Some(3),
+            tier: Some(2),
             host_tools: Some(false),
             std: Some(false),
         },
diff --git a/src/doc/rustc/src/platform-support.md b/src/doc/rustc/src/platform-support.md
index e5e46f7263751..a0a228cad2a0f 100644
--- a/src/doc/rustc/src/platform-support.md
+++ b/src/doc/rustc/src/platform-support.md
@@ -165,6 +165,7 @@ target | std | notes
 `armv7-unknown-linux-musleabi` | ✓ | Armv7-A Linux with musl 1.2.3
 `armv7-unknown-linux-musleabihf` | ✓ | Armv7-A Linux with musl 1.2.3, hardfloat
 [`armv7a-none-eabi`](platform-support/armv7a-none-eabi.md) | * | Bare Armv7-A
+[`armv7a-none-eabihf`](platform-support/armv7a-none-eabi.md) | * |  | Bare Armv7-A, hardfloat
 [`armv7r-none-eabi`](platform-support/armv7r-none-eabi.md) | * | Bare Armv7-R
 [`armv7r-none-eabihf`](platform-support/armv7r-none-eabi.md) | * | Bare Armv7-R, hardfloat
 `i586-unknown-linux-gnu` | ✓ | 32-bit Linux (kernel 3.2+, glibc 2.17, original Pentium) [^x86_32-floats-x87]
@@ -300,7 +301,6 @@ target | std | host | notes
 [`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
-[`armv7a-none-eabihf`](platform-support/arm-none-eabi.md) | * |  | Bare Armv7-A, hardfloat
 [`armv7a-vex-v5`](platform-support/armv7a-vex-v5.md) | ? |  | Armv7-A Cortex-A9 VEX V5 Brain, VEXos
 [`armv7k-apple-watchos`](platform-support/apple-watchos.md) | ✓ |  | Armv7-A Apple WatchOS
 [`armv7s-apple-ios`](platform-support/apple-ios.md) | ✓ |  | Armv7-A Apple-A6 Apple iOS
diff --git a/src/doc/rustc/src/platform-support/armv7a-none-eabi.md b/src/doc/rustc/src/platform-support/armv7a-none-eabi.md
index 3dadda86a5f54..4eeee6ae2c907 100644
--- a/src/doc/rustc/src/platform-support/armv7a-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/armv7a-none-eabi.md
@@ -1,7 +1,6 @@
 # `armv7a-none-eabi` and `armv7a-none-eabihf`
 
-* **Tier: 2** for `armv7a-none-eabi`
-* **Tier: 3** for `armv7a-none-eabihf`
+* **Tier: 2**
 * **Library Support:** core and alloc (bare-metal, `#![no_std]`)
 
 Bare-metal target for CPUs in the Armv7-A architecture family, supporting

From 89a5bb618050813e681fadea739a71fb6e629f24 Mon Sep 17 00:00:00 2001
From: Jonathan 'theJPster' Pallant <github@thejpster.org.uk>
Date: Sun, 7 Sep 2025 18:37:38 +0100
Subject: [PATCH 0918/1889] Raise armv8r-none-eabihf to Tier 2

This is the target for supporting Arm Cortex-R52 bare-metal systems,
which are common in safety-critical systems.
---
 src/doc/rustc/src/platform-support.md                    | 2 +-
 src/doc/rustc/src/platform-support/armv8r-none-eabihf.md | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/doc/rustc/src/platform-support.md b/src/doc/rustc/src/platform-support.md
index e5e46f7263751..6fb1c78d3f31e 100644
--- a/src/doc/rustc/src/platform-support.md
+++ b/src/doc/rustc/src/platform-support.md
@@ -167,6 +167,7 @@ target | std | notes
 [`armv7a-none-eabi`](platform-support/armv7a-none-eabi.md) | * | Bare Armv7-A
 [`armv7r-none-eabi`](platform-support/armv7r-none-eabi.md) | * | Bare Armv7-R
 [`armv7r-none-eabihf`](platform-support/armv7r-none-eabi.md) | * | Bare Armv7-R, hardfloat
+[`armv8r-none-eabihf`](platform-support/armv8r-none-eabihf.md) | * |  | Bare Armv8-R, hardfloat
 `i586-unknown-linux-gnu` | ✓ | 32-bit Linux (kernel 3.2+, glibc 2.17, original Pentium) [^x86_32-floats-x87]
 `i586-unknown-linux-musl` | ✓ | 32-bit Linux (musl 1.2.3, original Pentium) [^x86_32-floats-x87]
 [`i686-linux-android`](platform-support/android.md) | ✓ | 32-bit x86 Android ([Pentium 4 plus various extensions](https://developer.android.com/ndk/guides/abis.html#x86)) [^x86_32-floats-return-ABI]
@@ -304,7 +305,6 @@ target | std | host | notes
 [`armv7a-vex-v5`](platform-support/armv7a-vex-v5.md) | ? |  | Armv7-A Cortex-A9 VEX V5 Brain, VEXos
 [`armv7k-apple-watchos`](platform-support/apple-watchos.md) | ✓ |  | Armv7-A Apple WatchOS
 [`armv7s-apple-ios`](platform-support/apple-ios.md) | ✓ |  | Armv7-A Apple-A6 Apple iOS
-[`armv8r-none-eabihf`](platform-support/armv8r-none-eabihf.md) | * |  | Bare Armv8-R, hardfloat
 [`armv7a-nuttx-eabi`](platform-support/nuttx.md) | ✓ |  | ARMv7-A with NuttX
 [`armv7a-nuttx-eabihf`](platform-support/nuttx.md) | ✓ |  | ARMv7-A with NuttX, hardfloat
 [`avr-none`](platform-support/avr-none.md) | * |  | AVR; requires `-Zbuild-std=core` and `-Ctarget-cpu=...`
diff --git a/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md b/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md
index 0d5a36c3ee2d6..47186fdb2cdb8 100644
--- a/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md
+++ b/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md
@@ -1,6 +1,6 @@
 # `armv8r-none-eabihf`
 
-* **Tier: 3**
+* **Tier: 2**
 * **Library Support:** core and alloc (bare-metal, `#![no_std]`)
 
 Bare-metal target for CPUs in the Armv8-R architecture family, supporting

From bfddf29524878bb4ca9b43ab1912b440f3023c43 Mon Sep 17 00:00:00 2001
From: Jonathan 'theJPster' Pallant <github@thejpster.org.uk>
Date: Sat, 13 Sep 2025 20:16:32 +0100
Subject: [PATCH 0919/1889] Update target spec to say Tier 2.

---
 compiler/rustc_target/src/spec/targets/armv8r_none_eabihf.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_target/src/spec/targets/armv8r_none_eabihf.rs b/compiler/rustc_target/src/spec/targets/armv8r_none_eabihf.rs
index 8cf1ff9575168..d6e3a03bbba8b 100644
--- a/compiler/rustc_target/src/spec/targets/armv8r_none_eabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/armv8r_none_eabihf.rs
@@ -10,7 +10,7 @@ pub(crate) fn target() -> Target {
         llvm_target: "armv8r-none-eabihf".into(),
         metadata: TargetMetadata {
             description: Some("Bare Armv8-R, hardfloat".into()),
-            tier: Some(3),
+            tier: Some(2),
             host_tools: Some(false),
             std: Some(false),
         },

From 430d3532662fe309f3893ac2680775c1a5db0c41 Mon Sep 17 00:00:00 2001
From: Jonathan 'theJPster' Pallant <github@thejpster.org.uk>
Date: Sun, 7 Sep 2025 18:36:15 +0100
Subject: [PATCH 0920/1889] Drop armebv7r-none-eabi* to Tier 3

These targets are not widely used, and are difficult to test because
qemu-system-arm cannot emulate them.
---
 compiler/rustc_target/src/spec/targets/armebv7r_none_eabi.rs  | 2 +-
 .../rustc_target/src/spec/targets/armebv7r_none_eabihf.rs     | 2 +-
 src/doc/rustc/src/platform-support.md                         | 4 ++--
 src/doc/rustc/src/platform-support/armebv7r-none-eabi.md      | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/compiler/rustc_target/src/spec/targets/armebv7r_none_eabi.rs b/compiler/rustc_target/src/spec/targets/armebv7r_none_eabi.rs
index d227d63c4a346..0ae7cd7a3773d 100644
--- a/compiler/rustc_target/src/spec/targets/armebv7r_none_eabi.rs
+++ b/compiler/rustc_target/src/spec/targets/armebv7r_none_eabi.rs
@@ -12,7 +12,7 @@ pub(crate) fn target() -> Target {
         llvm_target: "armebv7r-none-eabi".into(),
         metadata: TargetMetadata {
             description: Some("Bare Armv7-R, Big Endian".into()),
-            tier: Some(2),
+            tier: Some(3),
             host_tools: Some(false),
             std: Some(false),
         },
diff --git a/compiler/rustc_target/src/spec/targets/armebv7r_none_eabihf.rs b/compiler/rustc_target/src/spec/targets/armebv7r_none_eabihf.rs
index c373afb914e3a..71ffd8baed57b 100644
--- a/compiler/rustc_target/src/spec/targets/armebv7r_none_eabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/armebv7r_none_eabihf.rs
@@ -12,7 +12,7 @@ pub(crate) fn target() -> Target {
         llvm_target: "armebv7r-none-eabihf".into(),
         metadata: TargetMetadata {
             description: Some("Bare Armv7-R, Big Endian, hardfloat".into()),
-            tier: Some(2),
+            tier: Some(3),
             host_tools: Some(false),
             std: Some(false),
         },
diff --git a/src/doc/rustc/src/platform-support.md b/src/doc/rustc/src/platform-support.md
index e5e46f7263751..3f8e753334e79 100644
--- a/src/doc/rustc/src/platform-support.md
+++ b/src/doc/rustc/src/platform-support.md
@@ -156,8 +156,6 @@ target | std | notes
 `arm-unknown-linux-musleabi` | ✓ | Armv6 Linux with musl 1.2.3
 `arm-unknown-linux-musleabihf` | ✓ | Armv6 Linux with musl 1.2.3, hardfloat
 [`arm64ec-pc-windows-msvc`](platform-support/arm64ec-pc-windows-msvc.md) | ✓ | Arm64EC Windows MSVC
-[`armebv7r-none-eabi`](platform-support/armebv7r-none-eabi.md) | * | Bare Armv7-R, Big Endian
-[`armebv7r-none-eabihf`](platform-support/armebv7r-none-eabi.md) | * | Bare Armv7-R, Big Endian, hardfloat
 [`armv5te-unknown-linux-gnueabi`](platform-support/armv5te-unknown-linux-gnueabi.md) | ✓ | Armv5TE Linux (kernel 4.4+, glibc 2.23)
 `armv5te-unknown-linux-musleabi` | ✓ | Armv5TE Linux with musl 1.2.3
 [`armv7-linux-androideabi`](platform-support/android.md) | ✓ | Armv7-A Android
@@ -283,6 +281,8 @@ target | std | host | notes
 [`arm64e-apple-ios`](platform-support/arm64e-apple-ios.md) | ✓ | | ARM64e Apple iOS
 [`arm64e-apple-tvos`](platform-support/arm64e-apple-tvos.md)  | ✓ | | ARM64e Apple tvOS
 [`armeb-unknown-linux-gnueabi`](platform-support/armeb-unknown-linux-gnueabi.md) | ✓ | ? | Arm BE8 the default Arm big-endian architecture since [Armv6](https://developer.arm.com/documentation/101754/0616/armlink-Reference/armlink-Command-line-Options/--be8?lang=en).
+[`armebv7r-none-eabi`](platform-support/armebv7r-none-eabi.md) | * | Bare Armv7-R, Big Endian
+[`armebv7r-none-eabihf`](platform-support/armebv7r-none-eabi.md) | * | Bare Armv7-R, Big Endian, hardfloat
 [`armv4t-none-eabi`](platform-support/armv4t-none-eabi.md) | * |  | Bare Armv4T
 `armv4t-unknown-linux-gnueabi` | ? |  | Armv4T Linux
 [`armv5te-none-eabi`](platform-support/armv5te-none-eabi.md) | * |  | Bare Armv5TE
diff --git a/src/doc/rustc/src/platform-support/armebv7r-none-eabi.md b/src/doc/rustc/src/platform-support/armebv7r-none-eabi.md
index 3e90319c373e4..d5c676ea9a4c0 100644
--- a/src/doc/rustc/src/platform-support/armebv7r-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/armebv7r-none-eabi.md
@@ -1,6 +1,6 @@
 # `armebv7r-none-eabi` and `armebv7r-none-eabihf`
 
-* **Tier: 2**
+* **Tier: 3**
 * **Library Support:** core and alloc (bare-metal, `#![no_std]`)
 
 Bare-metal target for CPUs in the Armv7-R architecture family running in Big

From 619a6964c757e9e94253fa6618fb03519ad2b55e Mon Sep 17 00:00:00 2001
From: omskscream <golovkov93@gmail.com>
Date: Sat, 13 Sep 2025 22:41:43 +0300
Subject: [PATCH 0921/1889] clean up issue-2284 (core marker trait name
 shadowing)

---
 tests/ui/issues/issue-2284.rs                 | 13 ------------
 .../core-marker-name-shadowing-issue-2284.rs  | 21 +++++++++++++++++++
 2 files changed, 21 insertions(+), 13 deletions(-)
 delete mode 100644 tests/ui/issues/issue-2284.rs
 create mode 100644 tests/ui/traits/core-marker-name-shadowing-issue-2284.rs

diff --git a/tests/ui/issues/issue-2284.rs b/tests/ui/issues/issue-2284.rs
deleted file mode 100644
index 358331ecd9a4c..0000000000000
--- a/tests/ui/issues/issue-2284.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ run-pass
-#![allow(dead_code)]
-
-trait Send {
-    fn f(&self);
-}
-
-fn f<T:Send>(t: T) {
-    t.f();
-}
-
-pub fn main() {
-}
diff --git a/tests/ui/traits/core-marker-name-shadowing-issue-2284.rs b/tests/ui/traits/core-marker-name-shadowing-issue-2284.rs
new file mode 100644
index 0000000000000..e5d083ac8c3fb
--- /dev/null
+++ b/tests/ui/traits/core-marker-name-shadowing-issue-2284.rs
@@ -0,0 +1,21 @@
+//@ run-pass
+#![allow(dead_code)]
+
+//! Tests that user-defined trait is prioritized in compile time over
+//! the core::marker trait with the same name, allowing shadowing core traits.
+//!
+//! # Context
+//! Original issue: https://github.com/rust-lang/rust/issues/2284
+//! Original fix pull request: https://github.com/rust-lang/rust/pull/3792
+
+
+trait Send {
+    fn f(&self);
+}
+
+fn f<T:Send>(t: T) {
+    t.f();
+}
+
+pub fn main() {
+}

From 05a5c7d0a104d3c3efbccb0aaf01b51495ad3080 Mon Sep 17 00:00:00 2001
From: omskscream <golovkov93@gmail.com>
Date: Sat, 13 Sep 2025 23:43:20 +0300
Subject: [PATCH 0922/1889] clean up issue-19479 (assoc type from another
 trait)

---
 .../assoc-type-via-another-trait-issue-19479.rs}            | 6 ++++++
 1 file changed, 6 insertions(+)
 rename tests/ui/{issues/issue-19479.rs => traits/associated_type_bound/assoc-type-via-another-trait-issue-19479.rs} (50%)

diff --git a/tests/ui/issues/issue-19479.rs b/tests/ui/traits/associated_type_bound/assoc-type-via-another-trait-issue-19479.rs
similarity index 50%
rename from tests/ui/issues/issue-19479.rs
rename to tests/ui/traits/associated_type_bound/assoc-type-via-another-trait-issue-19479.rs
index ed586b7655028..f17a89bcb5f42 100644
--- a/tests/ui/issues/issue-19479.rs
+++ b/tests/ui/traits/associated_type_bound/assoc-type-via-another-trait-issue-19479.rs
@@ -1,5 +1,11 @@
 //@ check-pass
 
+//! Tests that it's possible to define an associated type in a trait
+//! using an associated type from type parameter bound trait in a blanket implementation.
+//!
+//! # Context
+//! Original issue: https://github.com/rust-lang/rust/issues/19479
+
 trait Base {
     fn dummy(&self) { }
 }

From 8ee3a08b871f8b24075f67eda06330f7005cd435 Mon Sep 17 00:00:00 2001
From: omskscream <golovkov93@gmail.com>
Date: Sat, 13 Sep 2025 23:56:55 +0300
Subject: [PATCH 0923/1889] clean up issue-18088 (operator from supertrait)

---
 tests/ui/issues/issue-18088.rs                      |  8 --------
 .../inheritance/supertrait-operator-issue-18088.rs  | 13 +++++++++++++
 2 files changed, 13 insertions(+), 8 deletions(-)
 delete mode 100644 tests/ui/issues/issue-18088.rs
 create mode 100644 tests/ui/traits/inheritance/supertrait-operator-issue-18088.rs

diff --git a/tests/ui/issues/issue-18088.rs b/tests/ui/issues/issue-18088.rs
deleted file mode 100644
index ba198884c639f..0000000000000
--- a/tests/ui/issues/issue-18088.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-//@ check-pass
-
-pub trait Indexable<T>: std::ops::Index<usize, Output = T> {
-    fn index2(&self, i: usize) -> &T {
-        &self[i]
-    }
-}
-fn main() {}
diff --git a/tests/ui/traits/inheritance/supertrait-operator-issue-18088.rs b/tests/ui/traits/inheritance/supertrait-operator-issue-18088.rs
new file mode 100644
index 0000000000000..8bd45cd54a445
--- /dev/null
+++ b/tests/ui/traits/inheritance/supertrait-operator-issue-18088.rs
@@ -0,0 +1,13 @@
+//@ check-pass
+
+//! Tests that operators from supertrait are available directly on `self` for an inheritor trait.
+//!
+//! # Context
+//! Original issue: https://github.com/rust-lang/rust/issues/18088
+
+pub trait Indexable<T>: std::ops::Index<usize, Output = T> {
+    fn index2(&self, i: usize) -> &T {
+        &self[i]
+    }
+}
+fn main() {}

From 22aecd3001038d0ac00ecd06985e2b0abc57e6dc Mon Sep 17 00:00:00 2001
From: omskscream <golovkov93@gmail.com>
Date: Sun, 14 Sep 2025 01:18:18 +0300
Subject: [PATCH 0924/1889] clean up issue-21950 (dyn trait cast without assoc
 type at the cast)

---
 tests/ui/issues/issue-21950.rs                | 12 ------------
 ...-as-dyn-trait-wo-assoc-type-issue-21950.rs | 19 +++++++++++++++++++
 ...yn-trait-wo-assoc-type-issue-21950.stderr} |  2 +-
 3 files changed, 20 insertions(+), 13 deletions(-)
 delete mode 100644 tests/ui/issues/issue-21950.rs
 create mode 100644 tests/ui/traits/cast-as-dyn-trait-wo-assoc-type-issue-21950.rs
 rename tests/ui/{issues/issue-21950.stderr => traits/cast-as-dyn-trait-wo-assoc-type-issue-21950.stderr} (85%)

diff --git a/tests/ui/issues/issue-21950.rs b/tests/ui/issues/issue-21950.rs
deleted file mode 100644
index 7a85ac91bca0f..0000000000000
--- a/tests/ui/issues/issue-21950.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-trait Add<Rhs=Self> {
-    type Output;
-}
-
-impl Add for i32 {
-    type Output = i32;
-}
-
-fn main() {
-    let x = &10 as &dyn Add;
-    //~^ ERROR E0191
-}
diff --git a/tests/ui/traits/cast-as-dyn-trait-wo-assoc-type-issue-21950.rs b/tests/ui/traits/cast-as-dyn-trait-wo-assoc-type-issue-21950.rs
new file mode 100644
index 0000000000000..3c3815054502f
--- /dev/null
+++ b/tests/ui/traits/cast-as-dyn-trait-wo-assoc-type-issue-21950.rs
@@ -0,0 +1,19 @@
+//! Tests that compiler yields error E0191 when value with existing trait implementation
+//! is cast as same `dyn` trait without specifying associated type at the cast.
+//!
+//! # Context
+//! Original issue: https://github.com/rust-lang/rust/issues/21950
+
+trait Add<Rhs=Self> {
+    type Output;
+}
+
+impl Add for i32 {
+    type Output = i32;
+}
+
+fn main() {
+    let x = &10 as &dyn Add<i32, Output = i32>; //OK
+    let x = &10 as &dyn Add;
+    //~^ ERROR E0191
+}
diff --git a/tests/ui/issues/issue-21950.stderr b/tests/ui/traits/cast-as-dyn-trait-wo-assoc-type-issue-21950.stderr
similarity index 85%
rename from tests/ui/issues/issue-21950.stderr
rename to tests/ui/traits/cast-as-dyn-trait-wo-assoc-type-issue-21950.stderr
index 24230cfe17f3d..5f4974e6f237d 100644
--- a/tests/ui/issues/issue-21950.stderr
+++ b/tests/ui/traits/cast-as-dyn-trait-wo-assoc-type-issue-21950.stderr
@@ -1,5 +1,5 @@
 error[E0191]: the value of the associated type `Output` in `Add` must be specified
-  --> $DIR/issue-21950.rs:10:25
+  --> $DIR/cast-as-dyn-trait-wo-assoc-type-issue-21950.rs:17:25
    |
 LL |     type Output;
    |     ----------- `Output` defined here

From 25881bfc3400005b047c8eb553fb7bb2fab25950 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Fri, 12 Sep 2025 18:56:52 +0200
Subject: [PATCH 0925/1889] fix(elidable_lifetime_names): avoid overlapping
 spans in suggestions

---
 clippy_lints/src/lifetimes.rs           |  97 ++++++++++++----
 tests/ui/crashes/ice-15666.fixed        |   6 +
 tests/ui/crashes/ice-15666.rs           |   6 +
 tests/ui/crashes/ice-15666.stderr       |  16 +++
 tests/ui/elidable_lifetime_names.fixed  |  82 +++++++++++++
 tests/ui/elidable_lifetime_names.rs     |  82 +++++++++++++
 tests/ui/elidable_lifetime_names.stderr | 146 +++++++++++++++++++++++-
 7 files changed, 412 insertions(+), 23 deletions(-)
 create mode 100644 tests/ui/crashes/ice-15666.fixed
 create mode 100644 tests/ui/crashes/ice-15666.rs
 create mode 100644 tests/ui/crashes/ice-15666.stderr

diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index aac5d08fd37c8..d8b186b6787d1 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -856,36 +856,89 @@ fn elision_suggestions(
         .filter(|param| !param.is_elided_lifetime() && !param.is_impl_trait())
         .collect::<Vec<_>>();
 
-    let mut suggestions = if elidable_lts.len() == explicit_params.len() {
+    if !elidable_lts
+        .iter()
+        .all(|lt| explicit_params.iter().any(|param| param.def_id == *lt))
+    {
+        return None;
+    }
+
+    let mut suggestions = if elidable_lts.is_empty() {
+        vec![]
+    } else if elidable_lts.len() == explicit_params.len() {
         // if all the params are elided remove the whole generic block
         //
         // fn x<'a>() {}
         //     ^^^^
         vec![(generics.span, String::new())]
     } else {
-        elidable_lts
-            .iter()
-            .map(|&id| {
-                let pos = explicit_params.iter().position(|param| param.def_id == id)?;
-                let param = explicit_params.get(pos)?;
-
-                let span = if let Some(next) = explicit_params.get(pos + 1) {
-                    // fn x<'prev, 'a, 'next>() {}
-                    //             ^^^^
-                    param.span.until(next.span)
+        match &explicit_params[..] {
+            // no params, nothing to elide
+            [] => unreachable!("handled by `elidable_lts.is_empty()`"),
+            [param] => {
+                if elidable_lts.contains(&param.def_id) {
+                    unreachable!("handled by `elidable_lts.len() == explicit_params.len()`")
                 } else {
-                    // `pos` should be at least 1 here, because the param in position 0 would either have a `next`
-                    // param or would have taken the `elidable_lts.len() == explicit_params.len()` branch.
-                    let prev = explicit_params.get(pos - 1)?;
-
-                    // fn x<'prev, 'a>() {}
-                    //           ^^^^
-                    param.span.with_lo(prev.span.hi())
+                    unreachable!("handled by `elidable_lts.is_empty()`")
+                }
+            },
+            [_, _, ..] => {
+                // Given a list like `<'a, 'b, 'c, 'd, ..>`,
+                //
+                // If there is a cluster of elidable lifetimes at the beginning, say `'a` and `'b`, we should
+                // suggest removing them _and_ the trailing comma. The span for that is `a.span.until(c.span)`:
+                // <'a, 'b, 'c, 'd, ..> => <'a, 'b, 'c, 'd, ..>
+                //  ^^  ^^                  ^^^^^^^^
+                //
+                // And since we know that `'c` isn't elidable--otherwise it would've been in the cluster--we can go
+                // over all the lifetimes after it, and for each elidable one, add a suggestion spanning the
+                // lifetime itself and the comma before, because each individual suggestion is guaranteed to leave
+                // the list valid:
+                // <.., 'c, 'd, 'e, 'f, 'g, ..> => <.., 'c, 'd, 'e, 'f, 'g, ..>
+                //          ^^      ^^  ^^                ^^^^    ^^^^^^^^
+                //
+                // In case there is no such starting cluster, we only need to do the second part of the algorithm:
+                // <'a, 'b, 'c, 'd, 'e, 'f, 'g, ..> => <'a, 'b , 'c, 'd, 'e, 'f, 'g, ..>
+                //      ^^  ^^      ^^  ^^                ^^^^^^^^^    ^^^^^^^^
+
+                // Split off the starting cluster
+                // TODO: use `slice::split_once` once stabilized (github.com/rust-lang/rust/issues/112811):
+                // ```
+                // let Some(split) = explicit_params.split_once(|param| !elidable_lts.contains(&param.def_id)) else {
+                //     // there were no lifetime param that couldn't be elided
+                //     unreachable!("handled by `elidable_lts.len() == explicit_params.len()`")
+                // };
+                // match split { /* .. */ }
+                // ```
+                let Some(split_pos) = explicit_params
+                    .iter()
+                    .position(|param| !elidable_lts.contains(&param.def_id))
+                else {
+                    // there were no lifetime param that couldn't be elided
+                    unreachable!("handled by `elidable_lts.len() == explicit_params.len()`")
                 };
-
-                Some((span, String::new()))
-            })
-            .collect::<Option<Vec<_>>>()?
+                let split = explicit_params
+                    .split_at_checked(split_pos)
+                    .expect("got `split_pos` from `position` on the same Vec");
+
+                match split {
+                    ([..], []) => unreachable!("handled by `elidable_lts.len() == explicit_params.len()`"),
+                    ([], [_]) => unreachable!("handled by `explicit_params.len() == 1`"),
+                    (cluster, rest @ [rest_first, ..]) => {
+                        // the span for the cluster
+                        (cluster.first().map(|fw| fw.span.until(rest_first.span)).into_iter())
+                            // the span for the remaining lifetimes (calculations independent of the cluster)
+                            .chain(
+                                rest.array_windows()
+                                    .filter(|[_, curr]| elidable_lts.contains(&curr.def_id))
+                                    .map(|[prev, curr]| curr.span.with_lo(prev.span.hi())),
+                            )
+                            .map(|sp| (sp, String::new()))
+                            .collect()
+                    },
+                }
+            },
+        }
     };
 
     suggestions.extend(usages.iter().map(|&usage| {
diff --git a/tests/ui/crashes/ice-15666.fixed b/tests/ui/crashes/ice-15666.fixed
new file mode 100644
index 0000000000000..53b618765c0f0
--- /dev/null
+++ b/tests/ui/crashes/ice-15666.fixed
@@ -0,0 +1,6 @@
+#![warn(clippy::elidable_lifetime_names)]
+
+struct UnitVariantAccess<'a, 'b, 's>(&'a &'b &'s ());
+trait Trait<'de> {}
+impl<'de> Trait<'de> for UnitVariantAccess<'_, 'de, '_> {}
+//~^ elidable_lifetime_names
diff --git a/tests/ui/crashes/ice-15666.rs b/tests/ui/crashes/ice-15666.rs
new file mode 100644
index 0000000000000..1414b3d2035e4
--- /dev/null
+++ b/tests/ui/crashes/ice-15666.rs
@@ -0,0 +1,6 @@
+#![warn(clippy::elidable_lifetime_names)]
+
+struct UnitVariantAccess<'a, 'b, 's>(&'a &'b &'s ());
+trait Trait<'de> {}
+impl<'de, 'a, 's> Trait<'de> for UnitVariantAccess<'a, 'de, 's> {}
+//~^ elidable_lifetime_names
diff --git a/tests/ui/crashes/ice-15666.stderr b/tests/ui/crashes/ice-15666.stderr
new file mode 100644
index 0000000000000..b417c09b5c65a
--- /dev/null
+++ b/tests/ui/crashes/ice-15666.stderr
@@ -0,0 +1,16 @@
+error: the following explicit lifetimes could be elided: 'a, 's
+  --> tests/ui/crashes/ice-15666.rs:5:11
+   |
+LL | impl<'de, 'a, 's> Trait<'de> for UnitVariantAccess<'a, 'de, 's> {}
+   |           ^^  ^^                                   ^^       ^^
+   |
+   = note: `-D clippy::elidable-lifetime-names` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::elidable_lifetime_names)]`
+help: elide the lifetimes
+   |
+LL - impl<'de, 'a, 's> Trait<'de> for UnitVariantAccess<'a, 'de, 's> {}
+LL + impl<'de> Trait<'de> for UnitVariantAccess<'_, 'de, '_> {}
+   |
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/elidable_lifetime_names.fixed b/tests/ui/elidable_lifetime_names.fixed
index abeee5c4cef34..a6c4cb7a36a8d 100644
--- a/tests/ui/elidable_lifetime_names.fixed
+++ b/tests/ui/elidable_lifetime_names.fixed
@@ -192,3 +192,85 @@ mod issue13923 {
         x.b
     }
 }
+
+fn issue15666_original() {
+    struct UnitVariantAccess<'a, 'b, 's>(&'a &'b &'s ());
+
+    trait Trait<'de> {}
+
+    //~v elidable_lifetime_names
+    impl<'de> Trait<'de> for UnitVariantAccess<'_, 'de, '_> {}
+    //        ^^  ^^                                   ^^       ^^
+}
+
+#[allow(clippy::upper_case_acronyms)]
+fn issue15666() {
+    struct S1<'a>(&'a ());
+    struct S2<'a, 'b>(&'a &'b ());
+    struct S3<'a, 'b, 'c>(&'a &'b &'c ());
+
+    trait T {}
+    trait TA<'a> {}
+    trait TB<'b> {}
+    trait TC<'c> {}
+    trait TAB<'a, 'b> {}
+    trait TAC<'a, 'c> {}
+    trait TBC<'b, 'c> {}
+    trait TABC<'a, 'b, 'c> {}
+
+    // 1 lifetime
+
+    impl<'a> TA<'a> for S1<'a> {}
+
+    //~v elidable_lifetime_names
+    impl T for S1<'_> {}
+    //   ^^
+
+    // 2 lifetimes
+
+    impl<'a, 'b> TAB<'a, 'b> for S2<'a, 'b> {}
+
+    //~v elidable_lifetime_names
+    impl<'a> TA<'a> for S2<'a, '_> {}
+    //       ^^
+
+    //~v elidable_lifetime_names
+    impl<'b> TB<'b> for S2<'_, 'b> {}
+    //   ^^
+
+    //~v elidable_lifetime_names
+    impl T for S2<'_, '_> {}
+    //   ^^  ^^
+
+    // 3 lifetimes
+
+    impl<'a, 'b, 'c> TABC<'a, 'b, 'c> for S3<'a, 'b, 'c> {}
+
+    //~v elidable_lifetime_names
+    impl<'a, 'b> TAB<'a, 'b> for S3<'a, 'b, '_> {}
+    //           ^^
+
+    //~v elidable_lifetime_names
+    impl<'a, 'c> TAC<'a, 'c> for S3<'a, '_, 'c> {}
+    //       ^^
+
+    //~v elidable_lifetime_names
+    impl<'a> TA<'a> for S3<'a, '_, '_> {}
+    //       ^^  ^^
+
+    //~v elidable_lifetime_names
+    impl<'b, 'c> TBC<'b, 'c> for S3<'_, 'b, 'c> {}
+    //   ^^
+
+    //~v elidable_lifetime_names
+    impl<'b> TB<'b> for S3<'_, 'b, '_> {}
+    //   ^^      ^^
+
+    //~v elidable_lifetime_names
+    impl<'c> TC<'c> for S3<'_, '_, 'c> {}
+    //   ^^  ^^
+
+    //~v elidable_lifetime_names
+    impl T for S3<'_, '_, '_> {}
+    //   ^^  ^^  ^^
+}
diff --git a/tests/ui/elidable_lifetime_names.rs b/tests/ui/elidable_lifetime_names.rs
index fae3577a8e960..e08056b2fb56b 100644
--- a/tests/ui/elidable_lifetime_names.rs
+++ b/tests/ui/elidable_lifetime_names.rs
@@ -192,3 +192,85 @@ mod issue13923 {
         x.b
     }
 }
+
+fn issue15666_original() {
+    struct UnitVariantAccess<'a, 'b, 's>(&'a &'b &'s ());
+
+    trait Trait<'de> {}
+
+    //~v elidable_lifetime_names
+    impl<'de, 'a, 's> Trait<'de> for UnitVariantAccess<'a, 'de, 's> {}
+    //        ^^  ^^                                   ^^       ^^
+}
+
+#[allow(clippy::upper_case_acronyms)]
+fn issue15666() {
+    struct S1<'a>(&'a ());
+    struct S2<'a, 'b>(&'a &'b ());
+    struct S3<'a, 'b, 'c>(&'a &'b &'c ());
+
+    trait T {}
+    trait TA<'a> {}
+    trait TB<'b> {}
+    trait TC<'c> {}
+    trait TAB<'a, 'b> {}
+    trait TAC<'a, 'c> {}
+    trait TBC<'b, 'c> {}
+    trait TABC<'a, 'b, 'c> {}
+
+    // 1 lifetime
+
+    impl<'a> TA<'a> for S1<'a> {}
+
+    //~v elidable_lifetime_names
+    impl<'a> T for S1<'a> {}
+    //   ^^
+
+    // 2 lifetimes
+
+    impl<'a, 'b> TAB<'a, 'b> for S2<'a, 'b> {}
+
+    //~v elidable_lifetime_names
+    impl<'a, 'b> TA<'a> for S2<'a, 'b> {}
+    //       ^^
+
+    //~v elidable_lifetime_names
+    impl<'a, 'b> TB<'b> for S2<'a, 'b> {}
+    //   ^^
+
+    //~v elidable_lifetime_names
+    impl<'a, 'b> T for S2<'a, 'b> {}
+    //   ^^  ^^
+
+    // 3 lifetimes
+
+    impl<'a, 'b, 'c> TABC<'a, 'b, 'c> for S3<'a, 'b, 'c> {}
+
+    //~v elidable_lifetime_names
+    impl<'a, 'b, 'c> TAB<'a, 'b> for S3<'a, 'b, 'c> {}
+    //           ^^
+
+    //~v elidable_lifetime_names
+    impl<'a, 'b, 'c> TAC<'a, 'c> for S3<'a, 'b, 'c> {}
+    //       ^^
+
+    //~v elidable_lifetime_names
+    impl<'a, 'b, 'c> TA<'a> for S3<'a, 'b, 'c> {}
+    //       ^^  ^^
+
+    //~v elidable_lifetime_names
+    impl<'a, 'b, 'c> TBC<'b, 'c> for S3<'a, 'b, 'c> {}
+    //   ^^
+
+    //~v elidable_lifetime_names
+    impl<'a, 'b, 'c> TB<'b> for S3<'a, 'b, 'c> {}
+    //   ^^      ^^
+
+    //~v elidable_lifetime_names
+    impl<'a, 'b, 'c> TC<'c> for S3<'a, 'b, 'c> {}
+    //   ^^  ^^
+
+    //~v elidable_lifetime_names
+    impl<'a, 'b, 'c> T for S3<'a, 'b, 'c> {}
+    //   ^^  ^^  ^^
+}
diff --git a/tests/ui/elidable_lifetime_names.stderr b/tests/ui/elidable_lifetime_names.stderr
index a60dfc697564e..03fe383b8f67f 100644
--- a/tests/ui/elidable_lifetime_names.stderr
+++ b/tests/ui/elidable_lifetime_names.stderr
@@ -158,5 +158,149 @@ LL |             o: &'t str,
 LL ~         ) -> Content<'t, '_> {
    |
 
-error: aborting due to 12 previous errors
+error: the following explicit lifetimes could be elided: 'a, 's
+  --> tests/ui/elidable_lifetime_names.rs:202:15
+   |
+LL |     impl<'de, 'a, 's> Trait<'de> for UnitVariantAccess<'a, 'de, 's> {}
+   |               ^^  ^^                                   ^^       ^^
+   |
+help: elide the lifetimes
+   |
+LL -     impl<'de, 'a, 's> Trait<'de> for UnitVariantAccess<'a, 'de, 's> {}
+LL +     impl<'de> Trait<'de> for UnitVariantAccess<'_, 'de, '_> {}
+   |
+
+error: the following explicit lifetimes could be elided: 'a
+  --> tests/ui/elidable_lifetime_names.rs:226:10
+   |
+LL |     impl<'a> T for S1<'a> {}
+   |          ^^           ^^
+   |
+help: elide the lifetimes
+   |
+LL -     impl<'a> T for S1<'a> {}
+LL +     impl T for S1<'_> {}
+   |
+
+error: the following explicit lifetimes could be elided: 'b
+  --> tests/ui/elidable_lifetime_names.rs:234:14
+   |
+LL |     impl<'a, 'b> TA<'a> for S2<'a, 'b> {}
+   |              ^^                    ^^
+   |
+help: elide the lifetimes
+   |
+LL -     impl<'a, 'b> TA<'a> for S2<'a, 'b> {}
+LL +     impl<'a> TA<'a> for S2<'a, '_> {}
+   |
+
+error: the following explicit lifetimes could be elided: 'a
+  --> tests/ui/elidable_lifetime_names.rs:238:10
+   |
+LL |     impl<'a, 'b> TB<'b> for S2<'a, 'b> {}
+   |          ^^                    ^^
+   |
+help: elide the lifetimes
+   |
+LL -     impl<'a, 'b> TB<'b> for S2<'a, 'b> {}
+LL +     impl<'b> TB<'b> for S2<'_, 'b> {}
+   |
+
+error: the following explicit lifetimes could be elided: 'a, 'b
+  --> tests/ui/elidable_lifetime_names.rs:242:10
+   |
+LL |     impl<'a, 'b> T for S2<'a, 'b> {}
+   |          ^^  ^^           ^^  ^^
+   |
+help: elide the lifetimes
+   |
+LL -     impl<'a, 'b> T for S2<'a, 'b> {}
+LL +     impl T for S2<'_, '_> {}
+   |
+
+error: the following explicit lifetimes could be elided: 'c
+  --> tests/ui/elidable_lifetime_names.rs:250:18
+   |
+LL |     impl<'a, 'b, 'c> TAB<'a, 'b> for S3<'a, 'b, 'c> {}
+   |                  ^^                             ^^
+   |
+help: elide the lifetimes
+   |
+LL -     impl<'a, 'b, 'c> TAB<'a, 'b> for S3<'a, 'b, 'c> {}
+LL +     impl<'a, 'b> TAB<'a, 'b> for S3<'a, 'b, '_> {}
+   |
+
+error: the following explicit lifetimes could be elided: 'b
+  --> tests/ui/elidable_lifetime_names.rs:254:14
+   |
+LL |     impl<'a, 'b, 'c> TAC<'a, 'c> for S3<'a, 'b, 'c> {}
+   |              ^^                             ^^
+   |
+help: elide the lifetimes
+   |
+LL -     impl<'a, 'b, 'c> TAC<'a, 'c> for S3<'a, 'b, 'c> {}
+LL +     impl<'a, 'c> TAC<'a, 'c> for S3<'a, '_, 'c> {}
+   |
+
+error: the following explicit lifetimes could be elided: 'b, 'c
+  --> tests/ui/elidable_lifetime_names.rs:258:14
+   |
+LL |     impl<'a, 'b, 'c> TA<'a> for S3<'a, 'b, 'c> {}
+   |              ^^  ^^                    ^^  ^^
+   |
+help: elide the lifetimes
+   |
+LL -     impl<'a, 'b, 'c> TA<'a> for S3<'a, 'b, 'c> {}
+LL +     impl<'a> TA<'a> for S3<'a, '_, '_> {}
+   |
+
+error: the following explicit lifetimes could be elided: 'a
+  --> tests/ui/elidable_lifetime_names.rs:262:10
+   |
+LL |     impl<'a, 'b, 'c> TBC<'b, 'c> for S3<'a, 'b, 'c> {}
+   |          ^^                             ^^
+   |
+help: elide the lifetimes
+   |
+LL -     impl<'a, 'b, 'c> TBC<'b, 'c> for S3<'a, 'b, 'c> {}
+LL +     impl<'b, 'c> TBC<'b, 'c> for S3<'_, 'b, 'c> {}
+   |
+
+error: the following explicit lifetimes could be elided: 'a, 'c
+  --> tests/ui/elidable_lifetime_names.rs:266:10
+   |
+LL |     impl<'a, 'b, 'c> TB<'b> for S3<'a, 'b, 'c> {}
+   |          ^^      ^^                ^^      ^^
+   |
+help: elide the lifetimes
+   |
+LL -     impl<'a, 'b, 'c> TB<'b> for S3<'a, 'b, 'c> {}
+LL +     impl<'b> TB<'b> for S3<'_, 'b, '_> {}
+   |
+
+error: the following explicit lifetimes could be elided: 'a, 'b
+  --> tests/ui/elidable_lifetime_names.rs:270:10
+   |
+LL |     impl<'a, 'b, 'c> TC<'c> for S3<'a, 'b, 'c> {}
+   |          ^^  ^^                    ^^  ^^
+   |
+help: elide the lifetimes
+   |
+LL -     impl<'a, 'b, 'c> TC<'c> for S3<'a, 'b, 'c> {}
+LL +     impl<'c> TC<'c> for S3<'_, '_, 'c> {}
+   |
+
+error: the following explicit lifetimes could be elided: 'a, 'b, 'c
+  --> tests/ui/elidable_lifetime_names.rs:274:10
+   |
+LL |     impl<'a, 'b, 'c> T for S3<'a, 'b, 'c> {}
+   |          ^^  ^^  ^^           ^^  ^^  ^^
+   |
+help: elide the lifetimes
+   |
+LL -     impl<'a, 'b, 'c> T for S3<'a, 'b, 'c> {}
+LL +     impl T for S3<'_, '_, '_> {}
+   |
+
+error: aborting due to 24 previous errors
 

From 05156f4e8b1c0e0ef6eedcf99cfedf142c8f56fb Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Mon, 8 Sep 2025 21:59:03 +0200
Subject: [PATCH 0926/1889] clean-up `single_match` a bit

---
 clippy_lints/src/matches/single_match.rs | 27 +++++++++++++-----------
 tests/ui/single_match.fixed              |  5 +++--
 tests/ui/single_match.rs                 |  5 +++--
 tests/ui/single_match.stderr             | 20 +++++++++---------
 4 files changed, 31 insertions(+), 26 deletions(-)

diff --git a/clippy_lints/src/matches/single_match.rs b/clippy_lints/src/matches/single_match.rs
index bcf079b700703..0470b5443d189 100644
--- a/clippy_lints/src/matches/single_match.rs
+++ b/clippy_lints/src/matches/single_match.rs
@@ -24,17 +24,16 @@ 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_range(cx)
-        && let Some(text) = ff.as_str()
-    {
-        text.as_bytes().windows(2).any(|w| w == b"//" || w == b"/*")
-    } else {
-        false
-    }
+    span.check_source_text(cx, |text| text.as_bytes().windows(2).any(|w| w == b"//" || w == b"/*"))
 }
 
-#[rustfmt::skip]
-pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, ex: &'tcx Expr<'_>, arms: &'tcx [Arm<'_>], expr: &'tcx Expr<'_>, contains_comments: bool) {
+pub(crate) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    ex: &'tcx Expr<'_>,
+    arms: &'tcx [Arm<'_>],
+    expr: &'tcx Expr<'_>,
+    contains_comments: bool,
+) {
     if let [arm1, arm2] = arms
         && !arms.iter().any(|arm| arm.guard.is_some() || arm.pat.span.from_expansion())
         && !expr.span.from_expansion()
@@ -226,13 +225,13 @@ enum PatState<'a> {
     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.
+    /// This is not used for `Option` since it uses the current pattern to track its 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 pattern on its 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.
     ///
@@ -380,7 +379,11 @@ impl<'a> PatState<'a> {
                 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 =>
+                // `pat` looks like `(sub_pat)`, without a `..` -- has only one sub-pattern
+                if pos.as_opt_usize().is_none()
+                    // `pat` looks like `(sub_pat, ..)` or `(.., sub_pat)`, but its type is a unary tuple,
+                    // so it still only has one sub-pattern
+                    || cx.typeck.pat_ty(pat).tuple_fields().len() == 1 =>
             {
                 self.add_pat(cx, sub_pat)
             },
diff --git a/tests/ui/single_match.fixed b/tests/ui/single_match.fixed
index db5107600ee6d..03982b069e675 100644
--- a/tests/ui/single_match.fixed
+++ b/tests/ui/single_match.fixed
@@ -218,7 +218,7 @@ fn main() {
     };
 }
 
-fn issue_10808(bar: Option<i32>) {
+fn issue10808(bar: Option<i32>) {
     if let Some(v) = bar { unsafe {
         let r = &v as *const i32;
         println!("{}", *r);
@@ -330,6 +330,7 @@ pub struct Data([u8; 4]);
 const DATA: Data = Data([1, 2, 3, 4]);
 const CONST_I32: i32 = 1;
 
+// https://github.com/rust-lang/rust-clippy/issues/13012
 fn irrefutable_match() {
     println!();
     //~^^^^ single_match
@@ -367,7 +368,7 @@ fn irrefutable_match() {
     //~| NOTE: you might want to preserve the comments from inside the `match`
 }
 
-fn issue_14493() {
+fn issue14493() {
     macro_rules! mac {
         (some) => {
             Some(42)
diff --git a/tests/ui/single_match.rs b/tests/ui/single_match.rs
index a367b94c4ca6b..e28128e35adab 100644
--- a/tests/ui/single_match.rs
+++ b/tests/ui/single_match.rs
@@ -269,7 +269,7 @@ fn main() {
     };
 }
 
-fn issue_10808(bar: Option<i32>) {
+fn issue10808(bar: Option<i32>) {
     match bar {
         Some(v) => unsafe {
             let r = &v as *const i32;
@@ -397,6 +397,7 @@ pub struct Data([u8; 4]);
 const DATA: Data = Data([1, 2, 3, 4]);
 const CONST_I32: i32 = 1;
 
+// https://github.com/rust-lang/rust-clippy/issues/13012
 fn irrefutable_match() {
     match DATA {
         DATA => println!(),
@@ -462,7 +463,7 @@ fn irrefutable_match() {
     //~| NOTE: you might want to preserve the comments from inside the `match`
 }
 
-fn issue_14493() {
+fn issue14493() {
     macro_rules! mac {
         (some) => {
             Some(42)
diff --git a/tests/ui/single_match.stderr b/tests/ui/single_match.stderr
index 1a4edc45c928d..ba8bc5af5a608 100644
--- a/tests/ui/single_match.stderr
+++ b/tests/ui/single_match.stderr
@@ -225,7 +225,7 @@ LL | |     }
    | |_____^ help: try: `if &s[0..3] == b"foo" { println!() }`
 
 error: this pattern is irrefutable, `match` is useless
-  --> tests/ui/single_match.rs:401:5
+  --> tests/ui/single_match.rs:402:5
    |
 LL | /     match DATA {
 LL | |         DATA => println!(),
@@ -234,7 +234,7 @@ LL | |     }
    | |_____^ help: try: `println!();`
 
 error: this pattern is irrefutable, `match` is useless
-  --> tests/ui/single_match.rs:407:5
+  --> tests/ui/single_match.rs:408:5
    |
 LL | /     match CONST_I32 {
 LL | |         CONST_I32 => println!(),
@@ -243,7 +243,7 @@ LL | |     }
    | |_____^ help: try: `println!();`
 
 error: this pattern is irrefutable, `match` is useless
-  --> tests/ui/single_match.rs:414:5
+  --> tests/ui/single_match.rs:415:5
    |
 LL | /     match i {
 LL | |         i => {
@@ -263,7 +263,7 @@ LL +     }
    |
 
 error: this pattern is irrefutable, `match` is useless
-  --> tests/ui/single_match.rs:423:5
+  --> tests/ui/single_match.rs:424:5
    |
 LL | /     match i {
 LL | |         i => {},
@@ -272,7 +272,7 @@ LL | |     }
    | |_____^ help: `match` expression can be removed
 
 error: this pattern is irrefutable, `match` is useless
-  --> tests/ui/single_match.rs:429:5
+  --> tests/ui/single_match.rs:430:5
    |
 LL | /     match i {
 LL | |         i => (),
@@ -281,7 +281,7 @@ LL | |     }
    | |_____^ help: `match` expression can be removed
 
 error: this pattern is irrefutable, `match` is useless
-  --> tests/ui/single_match.rs:435:5
+  --> tests/ui/single_match.rs:436:5
    |
 LL | /     match CONST_I32 {
 LL | |         CONST_I32 => println!(),
@@ -290,7 +290,7 @@ LL | |     }
    | |_____^ help: try: `println!();`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> tests/ui/single_match.rs:443:5
+  --> tests/ui/single_match.rs:444:5
    |
 LL | /     match x.pop() {
 LL | |         // bla
@@ -302,7 +302,7 @@ LL | |     }
    = note: you might want to preserve the comments from inside the `match`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> tests/ui/single_match.rs:452:5
+  --> tests/ui/single_match.rs:453:5
    |
 LL | /     match x.pop() {
 LL | |         // bla
@@ -322,7 +322,7 @@ LL +     }
    |
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> tests/ui/single_match.rs:478:5
+  --> tests/ui/single_match.rs:479:5
    |
 LL | /     match mac!(some) {
 LL | |         Some(u) => println!("{u}"),
@@ -331,7 +331,7 @@ LL | |     }
    | |_____^ help: try: `if let Some(u) = mac!(some) { println!("{u}") }`
 
 error: you seem to be trying to use `match` for an equality check. Consider using `if`
-  --> tests/ui/single_match.rs:486:5
+  --> tests/ui/single_match.rs:487:5
    |
 LL | /     match mac!(str) {
 LL | |         "foo" => println!("eq"),

From 7791178805c1bccd2696c123ba5e5e4c896cf7d6 Mon Sep 17 00:00:00 2001
From: Lucas Baumann <dev@lucasbaumann.de>
Date: Sun, 14 Sep 2025 12:11:58 +0200
Subject: [PATCH 0927/1889] fix 404 link

---
 src/doc/rustc/src/target-tier-policy.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc/src/target-tier-policy.md b/src/doc/rustc/src/target-tier-policy.md
index 28d3dc32a63ee..f6b78eed24fc4 100644
--- a/src/doc/rustc/src/target-tier-policy.md
+++ b/src/doc/rustc/src/target-tier-policy.md
@@ -701,4 +701,4 @@ RFC process, with approval by the compiler and infra teams. Any such proposal
 will be communicated widely to the Rust community, both when initially proposed
 and before being dropped from a stable release.
 
-[MCP]: https://forge.rust-lang.org/compiler/mcp.html
+[MCP]: https://forge.rust-lang.org/compiler/proposals-and-stabilization.html#how-do-i-submit-an-mcp

From 2e816736efaebf1f4666efac1817bcccd78a3e52 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Tue, 26 Aug 2025 14:24:22 +0200
Subject: [PATCH 0928/1889] Move more early buffered lints to dyn lint
 diagnostics (1/N)

---
 compiler/rustc_builtin_macros/messages.ftl    | 11 ++++
 compiler/rustc_builtin_macros/src/asm.rs      |  5 +-
 compiler/rustc_builtin_macros/src/errors.rs   | 22 ++++++-
 .../rustc_builtin_macros/src/source_util.rs   |  3 +-
 .../rustc_builtin_macros/src/test_harness.rs  |  3 +-
 compiler/rustc_builtin_macros/src/util.rs     |  3 +-
 compiler/rustc_expand/messages.ftl            | 14 ++++-
 compiler/rustc_expand/src/config.rs           |  3 +-
 compiler/rustc_expand/src/errors.rs           | 42 ++++++++++++-
 compiler/rustc_expand/src/mbe/macro_check.rs  | 45 +++++++++-----
 compiler/rustc_expand/src/mbe/transcribe.rs   |  6 +-
 compiler/rustc_lint/messages.ftl              | 31 ----------
 compiler/rustc_lint/src/early/diagnostics.rs  | 41 ------------
 compiler/rustc_lint/src/lints.rs              | 62 +------------------
 compiler/rustc_lint_defs/src/lib.rs           | 18 +-----
 compiler/rustc_resolve/messages.ftl           |  6 ++
 compiler/rustc_resolve/src/diagnostics.rs     |  2 +-
 compiler/rustc_resolve/src/errors.rs          | 18 +++++-
 compiler/rustc_resolve/src/ident.rs           |  3 +-
 .../issue-61053-duplicate-binder.stderr       |  4 +-
 20 files changed, 150 insertions(+), 192 deletions(-)

diff --git a/compiler/rustc_builtin_macros/messages.ftl b/compiler/rustc_builtin_macros/messages.ftl
index 358c0d3db460f..7c1a5f44e165d 100644
--- a/compiler/rustc_builtin_macros/messages.ftl
+++ b/compiler/rustc_builtin_macros/messages.ftl
@@ -64,6 +64,11 @@ builtin_macros_autodiff_ty_activity = {$act} can not be used for this type
 builtin_macros_autodiff_unknown_activity = did not recognize Activity: `{$act}`
 
 builtin_macros_autodiff_width = autodiff width must fit u32, but is {$width}
+
+builtin_macros_avoid_att_syntax = avoid using `.att_syntax`, prefer using `options(att_syntax)` instead
+
+builtin_macros_avoid_intel_syntax = avoid using `.intel_syntax`, Intel syntax is the default
+
 builtin_macros_bad_derive_target = `derive` may only be applied to `struct`s, `enum`s and `union`s
     .label = not applicable here
     .label2 = not a `struct`, `enum` or `union`
@@ -138,6 +143,8 @@ builtin_macros_derive_path_args_list = traits in `#[derive(...)]` don't accept a
 builtin_macros_derive_path_args_value = traits in `#[derive(...)]` don't accept values
     .suggestion = remove the value
 
+builtin_macros_duplicate_macro_attribute = duplicated attribute
+
 builtin_macros_env_not_defined = environment variable `{$var}` not defined at compile time
     .cargo = Cargo sets build script variables at run time. Use `std::env::var({$var_expr})` instead
     .custom = use `std::env::var({$var_expr})` to read the variable at run time
@@ -231,6 +238,8 @@ builtin_macros_derive_from_wrong_field_count = `#[derive(From)]` used on a struc
 
 builtin_macros_derive_from_usage_note = `#[derive(From)]` can only be used on structs with exactly one field
 
+builtin_macros_incomplete_include = include macro expected single expression in source
+
 builtin_macros_multiple_default_attrs = multiple `#[default]` attributes
     .note = only one `#[default]` attribute is needed
     .label = `#[default]` used here
@@ -294,3 +303,5 @@ builtin_macros_unexpected_lit = expected path to a trait, found literal
     .label = not a trait
     .str_lit = try using `#[derive({$sym})]`
     .other = for example, write `#[derive(Debug)]` for `Debug`
+
+builtin_macros_unnameable_test_items = cannot test inner items
diff --git a/compiler/rustc_builtin_macros/src/asm.rs b/compiler/rustc_builtin_macros/src/asm.rs
index 86b8e1ff8dbb4..ae62b5ea2a097 100644
--- a/compiler/rustc_builtin_macros/src/asm.rs
+++ b/compiler/rustc_builtin_macros/src/asm.rs
@@ -1,4 +1,3 @@
-use lint::BuiltinLintDiag;
 use rustc_ast::tokenstream::TokenStream;
 use rustc_ast::{AsmMacro, token};
 use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
@@ -352,7 +351,7 @@ fn expand_preparsed_asm(
                     lint::builtin::BAD_ASM_STYLE,
                     find_span(".intel_syntax"),
                     ecx.current_expansion.lint_node_id,
-                    BuiltinLintDiag::AvoidUsingIntelSyntax,
+                    errors::AvoidIntelSyntax,
                 );
             }
             if template_str.contains(".att_syntax") {
@@ -360,7 +359,7 @@ fn expand_preparsed_asm(
                     lint::builtin::BAD_ASM_STYLE,
                     find_span(".att_syntax"),
                     ecx.current_expansion.lint_node_id,
-                    BuiltinLintDiag::AvoidUsingAttSyntax,
+                    errors::AvoidAttSyntax,
                 );
             }
         }
diff --git a/compiler/rustc_builtin_macros/src/errors.rs b/compiler/rustc_builtin_macros/src/errors.rs
index 54e8f7503377f..0993fdc5be453 100644
--- a/compiler/rustc_builtin_macros/src/errors.rs
+++ b/compiler/rustc_builtin_macros/src/errors.rs
@@ -3,9 +3,29 @@ use rustc_errors::{
     Diag, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level, MultiSpan, SingleLabelManySpans,
     Subdiagnostic,
 };
-use rustc_macros::{Diagnostic, Subdiagnostic};
+use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
 use rustc_span::{Ident, Span, Symbol};
 
+#[derive(LintDiagnostic)]
+#[diag(builtin_macros_avoid_intel_syntax)]
+pub(crate) struct AvoidIntelSyntax;
+
+#[derive(LintDiagnostic)]
+#[diag(builtin_macros_avoid_att_syntax)]
+pub(crate) struct AvoidAttSyntax;
+
+#[derive(LintDiagnostic)]
+#[diag(builtin_macros_incomplete_include)]
+pub(crate) struct IncompleteInclude;
+
+#[derive(LintDiagnostic)]
+#[diag(builtin_macros_unnameable_test_items)]
+pub(crate) struct UnnameableTestItems;
+
+#[derive(LintDiagnostic)]
+#[diag(builtin_macros_duplicate_macro_attribute)]
+pub(crate) struct DuplicateMacroAttribute;
+
 #[derive(Diagnostic)]
 #[diag(builtin_macros_requires_cfg_pattern)]
 pub(crate) struct RequiresCfgPattern {
diff --git a/compiler/rustc_builtin_macros/src/source_util.rs b/compiler/rustc_builtin_macros/src/source_util.rs
index 11b868f81a976..16adaab15c525 100644
--- a/compiler/rustc_builtin_macros/src/source_util.rs
+++ b/compiler/rustc_builtin_macros/src/source_util.rs
@@ -12,7 +12,6 @@ use rustc_expand::base::{
     DummyResult, ExpandResult, ExtCtxt, MacEager, MacResult, MacroExpanderResult, resolve_path,
 };
 use rustc_expand::module::DirOwnership;
-use rustc_lint_defs::BuiltinLintDiag;
 use rustc_parse::lexer::StripTokens;
 use rustc_parse::parser::ForceCollect;
 use rustc_parse::{new_parser_from_file, unwrap_or_emit_fatal, utf8_error};
@@ -159,7 +158,7 @@ pub(crate) fn expand_include<'cx>(
                     INCOMPLETE_INCLUDE,
                     p.token.span,
                     self.node_id,
-                    BuiltinLintDiag::IncompleteInclude,
+                    errors::IncompleteInclude,
                 );
             }
             Some(expr)
diff --git a/compiler/rustc_builtin_macros/src/test_harness.rs b/compiler/rustc_builtin_macros/src/test_harness.rs
index a9d91f77560a7..51089e5a1d3f1 100644
--- a/compiler/rustc_builtin_macros/src/test_harness.rs
+++ b/compiler/rustc_builtin_macros/src/test_harness.rs
@@ -11,7 +11,6 @@ use rustc_errors::DiagCtxtHandle;
 use rustc_expand::base::{ExtCtxt, ResolverExpand};
 use rustc_expand::expand::{AstFragment, ExpansionConfig};
 use rustc_feature::Features;
-use rustc_lint_defs::BuiltinLintDiag;
 use rustc_session::Session;
 use rustc_session::lint::builtin::UNNAMEABLE_TEST_ITEMS;
 use rustc_span::hygiene::{AstPass, SyntaxContext, Transparency};
@@ -165,7 +164,7 @@ impl<'a> Visitor<'a> for InnerItemLinter<'_> {
                 UNNAMEABLE_TEST_ITEMS,
                 attr.span,
                 i.id,
-                BuiltinLintDiag::UnnameableTestItems,
+                errors::UnnameableTestItems,
             );
         }
     }
diff --git a/compiler/rustc_builtin_macros/src/util.rs b/compiler/rustc_builtin_macros/src/util.rs
index 3a4585d5be9d1..e26f31dce67bd 100644
--- a/compiler/rustc_builtin_macros/src/util.rs
+++ b/compiler/rustc_builtin_macros/src/util.rs
@@ -5,7 +5,6 @@ use rustc_errors::{Applicability, Diag, ErrorGuaranteed};
 use rustc_expand::base::{Annotatable, ExpandResult, ExtCtxt};
 use rustc_expand::expand::AstFragment;
 use rustc_feature::AttributeTemplate;
-use rustc_lint_defs::BuiltinLintDiag;
 use rustc_lint_defs::builtin::DUPLICATE_MACRO_ATTRIBUTES;
 use rustc_parse::{exp, parser};
 use rustc_session::errors::report_lit_error;
@@ -49,7 +48,7 @@ pub(crate) fn warn_on_duplicate_attribute(ecx: &ExtCtxt<'_>, item: &Annotatable,
                 DUPLICATE_MACRO_ATTRIBUTES,
                 attr.span,
                 ecx.current_expansion.lint_node_id,
-                BuiltinLintDiag::DuplicateMacroAttribute,
+                errors::DuplicateMacroAttribute,
             );
         }
     }
diff --git a/compiler/rustc_expand/messages.ftl b/compiler/rustc_expand/messages.ftl
index 61ba716d082b0..fc50ac6e3bfeb 100644
--- a/compiler/rustc_expand/messages.ftl
+++ b/compiler/rustc_expand/messages.ftl
@@ -3,6 +3,8 @@ expand_attributes_on_expressions_experimental =
     .help_outer_doc = `///` is used for outer documentation comments; for a plain comment, use `//`
     .help_inner_doc = `//!` is used for inner documentation comments; for a plain comment, use `//` by removing the `!` or inserting a space in between them: `// !`
 
+expand_cfg_attr_no_attributes = `#[cfg_attr]` does not expand to any attributes
+
 expand_collapse_debuginfo_illegal =
     illegal value for attribute #[collapse_debuginfo(no|external|yes)]
 
@@ -89,6 +91,13 @@ expand_malformed_feature_attribute =
     malformed `feature` attribute input
     .expected = expected just one word
 
+expand_metavar_still_repeating = variable `{$ident}` is still repeating at this depth
+    .label = expected repetition
+
+expand_metavariable_wrong_operator = meta-variable repeats with different Kleene operator
+    .binder_label = expected repetition
+    .occurrence_label = conflicting repetition
+
 expand_meta_var_dif_seq_matchers = {$msg}
 
 expand_missing_fragment_specifier = missing fragment specifier
@@ -176,11 +185,10 @@ expand_resolve_relative_path =
 
 expand_trace_macro = trace_macro
 
+expand_unknown_macro_variable = unknown macro variable `{$name}`
+
 expand_unsupported_key_value =
     key-value macro attributes are not supported
 
-expand_var_still_repeating =
-    variable `{$ident}` is still repeating at this depth
-
 expand_wrong_fragment_kind =
     non-{$kind} macro in {$kind} position: {$name}
diff --git a/compiler/rustc_expand/src/config.rs b/compiler/rustc_expand/src/config.rs
index 15419ab7423f4..2925e337071ca 100644
--- a/compiler/rustc_expand/src/config.rs
+++ b/compiler/rustc_expand/src/config.rs
@@ -21,7 +21,6 @@ use rustc_feature::{
     ACCEPTED_LANG_FEATURES, AttributeSafety, EnabledLangFeature, EnabledLibFeature, Features,
     REMOVED_LANG_FEATURES, UNSTABLE_LANG_FEATURES,
 };
-use rustc_lint_defs::BuiltinLintDiag;
 use rustc_session::Session;
 use rustc_session::parse::feature_err;
 use rustc_span::{STDLIB_STABLE_CRATES, Span, Symbol, sym};
@@ -315,7 +314,7 @@ impl<'a> StripUnconfigured<'a> {
                 rustc_lint_defs::builtin::UNUSED_ATTRIBUTES,
                 cfg_attr.span,
                 ast::CRATE_NODE_ID,
-                BuiltinLintDiag::CfgAttrNoAttributes,
+                crate::errors::CfgAttrNoAttributes,
             );
         }
 
diff --git a/compiler/rustc_expand/src/errors.rs b/compiler/rustc_expand/src/errors.rs
index 6eb5cd65846eb..a939dadaf2fcd 100644
--- a/compiler/rustc_expand/src/errors.rs
+++ b/compiler/rustc_expand/src/errors.rs
@@ -3,9 +3,13 @@ use std::borrow::Cow;
 use rustc_ast::ast;
 use rustc_errors::codes::*;
 use rustc_hir::limit::Limit;
-use rustc_macros::{Diagnostic, Subdiagnostic};
+use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
 use rustc_span::{Ident, MacroRulesNormalizedIdent, Span, Symbol};
 
+#[derive(LintDiagnostic)]
+#[diag(expand_cfg_attr_no_attributes)]
+pub(crate) struct CfgAttrNoAttributes;
+
 #[derive(Diagnostic)]
 #[diag(expand_expr_repeat_no_syntax_vars)]
 pub(crate) struct NoSyntaxVarsExprRepeat {
@@ -28,13 +32,30 @@ pub(crate) struct CountRepetitionMisplaced {
 }
 
 #[derive(Diagnostic)]
-#[diag(expand_var_still_repeating)]
-pub(crate) struct VarStillRepeating {
+#[diag(expand_metavar_still_repeating)]
+pub(crate) struct MacroVarStillRepeating {
     #[primary_span]
     pub span: Span,
     pub ident: MacroRulesNormalizedIdent,
 }
 
+#[derive(LintDiagnostic)]
+#[diag(expand_metavar_still_repeating)]
+pub(crate) struct MetaVarStillRepeatingLint {
+    #[label]
+    pub label: Span,
+    pub ident: MacroRulesNormalizedIdent,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(expand_metavariable_wrong_operator)]
+pub(crate) struct MetaVariableWrongOperator {
+    #[label(expand_binder_label)]
+    pub binder: Span,
+    #[label(expand_occurrence_label)]
+    pub occurrence: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(expand_meta_var_dif_seq_matchers)]
 pub(crate) struct MetaVarsDifSeqMatchers {
@@ -43,6 +64,12 @@ pub(crate) struct MetaVarsDifSeqMatchers {
     pub msg: String,
 }
 
+#[derive(LintDiagnostic)]
+#[diag(expand_unknown_macro_variable)]
+pub(crate) struct UnknownMacroVariable {
+    pub name: MacroRulesNormalizedIdent,
+}
+
 #[derive(Diagnostic)]
 #[diag(expand_resolve_relative_path)]
 pub(crate) struct ResolveRelativePath {
@@ -345,6 +372,15 @@ pub(crate) struct DuplicateMatcherBinding {
     pub prev: Span,
 }
 
+#[derive(LintDiagnostic)]
+#[diag(expand_duplicate_matcher_binding)]
+pub(crate) struct DuplicateMatcherBindingLint {
+    #[label]
+    pub span: Span,
+    #[label(expand_label2)]
+    pub prev: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(expand_missing_fragment_specifier)]
 #[note]
diff --git a/compiler/rustc_expand/src/mbe/macro_check.rs b/compiler/rustc_expand/src/mbe/macro_check.rs
index faeae1f494e65..ebd6e887f7d28 100644
--- a/compiler/rustc_expand/src/mbe/macro_check.rs
+++ b/compiler/rustc_expand/src/mbe/macro_check.rs
@@ -108,8 +108,7 @@
 use rustc_ast::token::{Delimiter, IdentIsRaw, Token, TokenKind};
 use rustc_ast::{DUMMY_NODE_ID, NodeId};
 use rustc_data_structures::fx::FxHashMap;
-use rustc_errors::MultiSpan;
-use rustc_lint_defs::BuiltinLintDiag;
+use rustc_errors::DecorateDiagCompat;
 use rustc_session::lint::builtin::META_VARIABLE_MISUSE;
 use rustc_session::parse::ParseSess;
 use rustc_span::{ErrorGuaranteed, MacroRulesNormalizedIdent, Span, kw};
@@ -245,9 +244,12 @@ fn check_binders(
             // There are 3 possibilities:
             if let Some(prev_info) = binders.get(&name) {
                 // 1. The meta-variable is already bound in the current LHS: This is an error.
-                let mut span = MultiSpan::from_span(span);
-                span.push_span_label(prev_info.span, "previous declaration");
-                buffer_lint(psess, span, node_id, BuiltinLintDiag::DuplicateMatcherBinding);
+                buffer_lint(
+                    psess,
+                    span,
+                    node_id,
+                    errors::DuplicateMatcherBindingLint { span, prev: prev_info.span },
+                );
             } else if get_binder_info(macros, binders, name).is_none() {
                 // 2. The meta-variable is free: This is a binder.
                 binders.insert(name, BinderInfo { span, ops: ops.into() });
@@ -579,7 +581,7 @@ fn check_ops_is_prefix(
             return;
         }
     }
-    buffer_lint(psess, span.into(), node_id, BuiltinLintDiag::UnknownMacroVariable(name));
+    buffer_lint(psess, span, node_id, errors::UnknownMacroVariable { name });
 }
 
 /// Returns whether `binder_ops` is a prefix of `occurrence_ops`.
@@ -604,29 +606,42 @@ fn ops_is_prefix(
     psess: &ParseSess,
     node_id: NodeId,
     span: Span,
-    name: MacroRulesNormalizedIdent,
+    ident: MacroRulesNormalizedIdent,
     binder_ops: &[KleeneToken],
     occurrence_ops: &[KleeneToken],
 ) {
     for (i, binder) in binder_ops.iter().enumerate() {
         if i >= occurrence_ops.len() {
-            let mut span = MultiSpan::from_span(span);
-            span.push_span_label(binder.span, "expected repetition");
-            buffer_lint(psess, span, node_id, BuiltinLintDiag::MetaVariableStillRepeating(name));
+            buffer_lint(
+                psess,
+                span,
+                node_id,
+                errors::MetaVarStillRepeatingLint { label: binder.span, ident },
+            );
             return;
         }
         let occurrence = &occurrence_ops[i];
         if occurrence.op != binder.op {
-            let mut span = MultiSpan::from_span(span);
-            span.push_span_label(binder.span, "expected repetition");
-            span.push_span_label(occurrence.span, "conflicting repetition");
-            buffer_lint(psess, span, node_id, BuiltinLintDiag::MetaVariableWrongOperator);
+            buffer_lint(
+                psess,
+                span,
+                node_id,
+                errors::MetaVariableWrongOperator {
+                    binder: binder.span,
+                    occurrence: occurrence.span,
+                },
+            );
             return;
         }
     }
 }
 
-fn buffer_lint(psess: &ParseSess, span: MultiSpan, node_id: NodeId, diag: BuiltinLintDiag) {
+fn buffer_lint(
+    psess: &ParseSess,
+    span: Span,
+    node_id: NodeId,
+    diag: impl Into<DecorateDiagCompat>,
+) {
     // Macros loaded from other crates have dummy node ids.
     if node_id != DUMMY_NODE_ID {
         psess.buffer_lint(META_VARIABLE_MISUSE, span, node_id, diag);
diff --git a/compiler/rustc_expand/src/mbe/transcribe.rs b/compiler/rustc_expand/src/mbe/transcribe.rs
index ed8aa71d59dda..6a3f1f62c91e1 100644
--- a/compiler/rustc_expand/src/mbe/transcribe.rs
+++ b/compiler/rustc_expand/src/mbe/transcribe.rs
@@ -17,8 +17,8 @@ use rustc_span::{
 use smallvec::{SmallVec, smallvec};
 
 use crate::errors::{
-    CountRepetitionMisplaced, MetaVarsDifSeqMatchers, MustRepeatOnce, MveUnrecognizedVar,
-    NoSyntaxVarsExprRepeat, VarStillRepeating,
+    CountRepetitionMisplaced, MacroVarStillRepeating, MetaVarsDifSeqMatchers, MustRepeatOnce,
+    MveUnrecognizedVar, NoSyntaxVarsExprRepeat,
 };
 use crate::mbe::macro_parser::NamedMatch;
 use crate::mbe::macro_parser::NamedMatch::*;
@@ -483,7 +483,7 @@ fn transcribe_metavar<'tx>(
         }
         MatchedSeq(..) => {
             // We were unable to descend far enough. This is an error.
-            return Err(dcx.create_err(VarStillRepeating { span: sp, ident }));
+            return Err(dcx.create_err(MacroVarStillRepeating { span: sp, ident }));
         }
     };
 
diff --git a/compiler/rustc_lint/messages.ftl b/compiler/rustc_lint/messages.ftl
index 417e5a97069c3..5a60a4f48d9db 100644
--- a/compiler/rustc_lint/messages.ftl
+++ b/compiler/rustc_lint/messages.ftl
@@ -40,12 +40,6 @@ lint_atomic_ordering_load = atomic loads cannot have `Release` or `AcqRel` order
 lint_atomic_ordering_store = atomic stores cannot have `Acquire` or `AcqRel` ordering
     .help = consider using ordering modes `Release`, `SeqCst` or `Relaxed`
 
-lint_avoid_att_syntax =
-    avoid using `.att_syntax`, prefer using `options(att_syntax)` instead
-
-lint_avoid_intel_syntax =
-    avoid using `.intel_syntax`, Intel syntax is the default
-
 lint_bad_attribute_argument = bad attribute argument
 
 lint_bad_opt_access = {$msg}
@@ -190,9 +184,6 @@ lint_builtin_while_true = denote infinite loops with `loop {"{"} ... {"}"}`
 lint_byte_slice_in_packed_struct_with_derive = {$ty} slice in a packed struct that derives a built-in trait
     .help = consider implementing the trait by hand, or remove the `packed` attribute
 
-lint_cfg_attr_no_attributes =
-    `#[cfg_attr]` does not expand to any attributes
-
 lint_check_name_unknown_tool = unknown lint tool: `{$tool_name}`
 
 lint_closure_returning_async_block = closure returning async block can be made into an async closure
@@ -249,11 +240,6 @@ lint_dropping_copy_types = calls to `std::mem::drop` with a value that implement
 lint_dropping_references = calls to `std::mem::drop` with a reference instead of an owned value does nothing
     .label = argument has type `{$arg_ty}`
 
-lint_duplicate_macro_attribute =
-    duplicated attribute
-
-lint_duplicate_matcher_binding = duplicate matcher binding
-
 lint_enum_intrinsics_mem_discriminant =
     the return value of `mem::discriminant` is unspecified when called with a non-enum type
     .note = the argument to `discriminant` should be a reference to an enum, but it was passed a reference to a `{$ty_param}`, which is not an enum
@@ -409,9 +395,6 @@ lint_improper_ctypes_union_layout_help = consider adding a `#[repr(C)]` or `#[re
 lint_improper_ctypes_union_layout_reason = this union has unspecified layout
 lint_improper_ctypes_union_non_exhaustive = this union is non-exhaustive
 
-lint_incomplete_include =
-    include macro expected single expression in source
-
 lint_invalid_asm_label_binary = avoid using labels containing only the digits `0` and `1` in inline assembly
     .label = use a different label that doesn't start with `0` or `1`
     .help = start numbering with `2` instead
@@ -476,9 +459,6 @@ lint_legacy_derive_helpers = derive helper attribute is used before it is introd
 lint_lintpass_by_hand = implementing `LintPass` by hand
     .help = try using `declare_lint_pass!` or `impl_lint_pass!` instead
 
-lint_macro_expanded_macro_exports_accessed_by_absolute_paths = macro-expanded `macro_export` macros from the current crate cannot be referred to by absolute paths
-    .note = the macro is defined here
-
 lint_macro_expr_fragment_specifier_2024_migration =
     the `expr` fragment specifier will accept more expressions in the 2024 edition
     .suggestion = to keep the existing behavior, use the `expr_2021` fragment specifier
@@ -499,10 +479,6 @@ lint_map_unit_fn = `Iterator::map` call that discard the iterator's values
     .map_label = after this call to map, the resulting iterator is `impl Iterator<Item = ()>`, which means the only information carried by the iterator is the number of items
     .suggestion = you might have meant to use `Iterator::for_each`
 
-lint_metavariable_still_repeating = variable `{$name}` is still repeating at this depth
-
-lint_metavariable_wrong_operator = meta-variable repeats with different Kleene operator
-
 lint_mismatched_lifetime_syntaxes_eliding_while_named =
     eliding a lifetime that's named elsewhere is confusing
 
@@ -719,9 +695,6 @@ lint_pattern_in_foreign = patterns aren't allowed in foreign function declaratio
 lint_private_extern_crate_reexport = extern crate `{$ident}` is private and cannot be re-exported
     .suggestion = consider making the `extern crate` item publicly accessible
 
-lint_proc_macro_derive_resolution_fallback = cannot find {$ns_descr} `{$ident}` in this scope
-    .label = names from parent modules are not accessible without an explicit import
-
 lint_query_instability = using `{$query}` can result in unstable query results
     .note = if you believe this case to be fine, allow this lint and add a comment explaining your rationale
 
@@ -935,13 +908,9 @@ lint_unknown_lint =
         *[false] did you mean: `{$replace}`
     }
 
-lint_unknown_macro_variable = unknown macro variable `{$name}`
-
 lint_unknown_tool_in_scoped_lint = unknown tool name `{$tool_name}` found in scoped lint: `{$tool_name}::{$lint_name}`
     .help = add `#![register_tool({$tool_name})]` to the crate root
 
-lint_unnameable_test_items = cannot test inner items
-
 lint_unnecessary_qualification = unnecessary qualification
     .suggestion = remove the unnecessary path segments
 
diff --git a/compiler/rustc_lint/src/early/diagnostics.rs b/compiler/rustc_lint/src/early/diagnostics.rs
index 7300490b838b0..4463586515ec1 100644
--- a/compiler/rustc_lint/src/early/diagnostics.rs
+++ b/compiler/rustc_lint/src/early/diagnostics.rs
@@ -64,17 +64,6 @@ pub fn decorate_builtin_lint(
             }
             .decorate_lint(diag);
         }
-        BuiltinLintDiag::ProcMacroDeriveResolutionFallback {
-            span: macro_span,
-            ns_descr,
-            ident,
-        } => lints::ProcMacroDeriveResolutionFallback { span: macro_span, ns_descr, ident }
-            .decorate_lint(diag),
-        BuiltinLintDiag::MacroExpandedMacroExportsAccessedByAbsolutePaths(span_def) => {
-            lints::MacroExpandedMacroExportsAccessedByAbsolutePaths { definition: span_def }
-                .decorate_lint(diag)
-        }
-
         BuiltinLintDiag::ElidedLifetimesInPaths(n, path_span, incl_angl_brckt, insertion_span) => {
             lints::ElidedLifetimesInPaths {
                 subdiag: elided_lifetime_in_path_suggestion(
@@ -398,36 +387,6 @@ pub fn decorate_builtin_lint(
         BuiltinLintDiag::UnstableFeature(msg) => {
             lints::UnstableFeature { msg }.decorate_lint(diag);
         }
-        BuiltinLintDiag::AvoidUsingIntelSyntax => {
-            lints::AvoidIntelSyntax.decorate_lint(diag);
-        }
-        BuiltinLintDiag::AvoidUsingAttSyntax => {
-            lints::AvoidAttSyntax.decorate_lint(diag);
-        }
-        BuiltinLintDiag::IncompleteInclude => {
-            lints::IncompleteInclude.decorate_lint(diag);
-        }
-        BuiltinLintDiag::UnnameableTestItems => {
-            lints::UnnameableTestItems.decorate_lint(diag);
-        }
-        BuiltinLintDiag::DuplicateMacroAttribute => {
-            lints::DuplicateMacroAttribute.decorate_lint(diag);
-        }
-        BuiltinLintDiag::CfgAttrNoAttributes => {
-            lints::CfgAttrNoAttributes.decorate_lint(diag);
-        }
-        BuiltinLintDiag::MetaVariableStillRepeating(name) => {
-            lints::MetaVariableStillRepeating { name }.decorate_lint(diag);
-        }
-        BuiltinLintDiag::MetaVariableWrongOperator => {
-            lints::MetaVariableWrongOperator.decorate_lint(diag);
-        }
-        BuiltinLintDiag::DuplicateMatcherBinding => {
-            lints::DuplicateMatcherBinding.decorate_lint(diag);
-        }
-        BuiltinLintDiag::UnknownMacroVariable(name) => {
-            lints::UnknownMacroVariable { name }.decorate_lint(diag);
-        }
         BuiltinLintDiag::UnusedCrateDependency { extern_crate, local_crate } => {
             lints::UnusedCrateDependency { extern_crate, local_crate }.decorate_lint(diag)
         }
diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
index 56d65ed08f9e3..1c13fadeef968 100644
--- a/compiler/rustc_lint/src/lints.rs
+++ b/compiler/rustc_lint/src/lints.rs
@@ -17,7 +17,7 @@ use rustc_middle::ty::{Clause, PolyExistentialTraitRef, Ty, TyCtxt};
 use rustc_session::Session;
 use rustc_session::lint::AmbiguityErrorDiag;
 use rustc_span::edition::Edition;
-use rustc_span::{Ident, MacroRulesNormalizedIdent, Span, Symbol, sym};
+use rustc_span::{Ident, Span, Symbol, sym};
 
 use crate::builtin::{InitError, ShorthandAssocTyCollector, TypeAliasBounds};
 use crate::errors::{OverruledAttributeSub, RequestedLevel};
@@ -2585,50 +2585,6 @@ impl<'a> LintDiagnostic<'a, ()> for UnstableFeature {
     }
 }
 
-#[derive(LintDiagnostic)]
-#[diag(lint_avoid_intel_syntax)]
-pub(crate) struct AvoidIntelSyntax;
-
-#[derive(LintDiagnostic)]
-#[diag(lint_avoid_att_syntax)]
-pub(crate) struct AvoidAttSyntax;
-
-#[derive(LintDiagnostic)]
-#[diag(lint_incomplete_include)]
-pub(crate) struct IncompleteInclude;
-
-#[derive(LintDiagnostic)]
-#[diag(lint_unnameable_test_items)]
-pub(crate) struct UnnameableTestItems;
-
-#[derive(LintDiagnostic)]
-#[diag(lint_duplicate_macro_attribute)]
-pub(crate) struct DuplicateMacroAttribute;
-
-#[derive(LintDiagnostic)]
-#[diag(lint_cfg_attr_no_attributes)]
-pub(crate) struct CfgAttrNoAttributes;
-
-#[derive(LintDiagnostic)]
-#[diag(lint_metavariable_still_repeating)]
-pub(crate) struct MetaVariableStillRepeating {
-    pub name: MacroRulesNormalizedIdent,
-}
-
-#[derive(LintDiagnostic)]
-#[diag(lint_metavariable_wrong_operator)]
-pub(crate) struct MetaVariableWrongOperator;
-
-#[derive(LintDiagnostic)]
-#[diag(lint_duplicate_matcher_binding)]
-pub(crate) struct DuplicateMatcherBinding;
-
-#[derive(LintDiagnostic)]
-#[diag(lint_unknown_macro_variable)]
-pub(crate) struct UnknownMacroVariable {
-    pub name: MacroRulesNormalizedIdent,
-}
-
 #[derive(LintDiagnostic)]
 #[diag(lint_unused_crate_dependency)]
 #[help]
@@ -2714,22 +2670,6 @@ pub(crate) struct AbsPathWithModuleSugg {
     pub replacement: String,
 }
 
-#[derive(LintDiagnostic)]
-#[diag(lint_proc_macro_derive_resolution_fallback)]
-pub(crate) struct ProcMacroDeriveResolutionFallback {
-    #[label]
-    pub span: Span,
-    pub ns_descr: &'static str,
-    pub ident: Ident,
-}
-
-#[derive(LintDiagnostic)]
-#[diag(lint_macro_expanded_macro_exports_accessed_by_absolute_paths)]
-pub(crate) struct MacroExpandedMacroExportsAccessedByAbsolutePaths {
-    #[note]
-    pub definition: Span,
-}
-
 #[derive(LintDiagnostic)]
 #[diag(lint_hidden_lifetime_parameters)]
 pub(crate) struct ElidedLifetimesInPaths {
diff --git a/compiler/rustc_lint_defs/src/lib.rs b/compiler/rustc_lint_defs/src/lib.rs
index 2e84233e5a569..77c17c6c1e39e 100644
--- a/compiler/rustc_lint_defs/src/lib.rs
+++ b/compiler/rustc_lint_defs/src/lib.rs
@@ -11,7 +11,7 @@ use rustc_hir_id::{HashStableContext, HirId, ItemLocalId};
 use rustc_macros::{Decodable, Encodable, HashStable_Generic};
 use rustc_span::def_id::DefPathHash;
 pub use rustc_span::edition::Edition;
-use rustc_span::{Ident, MacroRulesNormalizedIdent, Span, Symbol, sym};
+use rustc_span::{Ident, Span, Symbol, sym};
 use serde::{Deserialize, Serialize};
 
 pub use self::Level::*;
@@ -620,12 +620,6 @@ pub enum DeprecatedSinceKind {
 #[derive(Debug)]
 pub enum BuiltinLintDiag {
     AbsPathWithModule(Span),
-    ProcMacroDeriveResolutionFallback {
-        span: Span,
-        ns_descr: &'static str,
-        ident: Ident,
-    },
-    MacroExpandedMacroExportsAccessedByAbsolutePaths(Span),
     ElidedLifetimesInPaths(usize, Span, bool, Span),
     UnknownCrateTypes {
         span: Span,
@@ -774,16 +768,6 @@ pub enum BuiltinLintDiag {
     UnusedMacroDefinition(Symbol),
     MacroRuleNeverUsed(usize, Symbol),
     UnstableFeature(DiagMessage),
-    AvoidUsingIntelSyntax,
-    AvoidUsingAttSyntax,
-    IncompleteInclude,
-    UnnameableTestItems,
-    DuplicateMacroAttribute,
-    CfgAttrNoAttributes,
-    MetaVariableStillRepeating(MacroRulesNormalizedIdent),
-    MetaVariableWrongOperator,
-    DuplicateMatcherBinding,
-    UnknownMacroVariable(MacroRulesNormalizedIdent),
     UnusedCrateDependency {
         extern_crate: Symbol,
         local_crate: Symbol,
diff --git a/compiler/rustc_resolve/messages.ftl b/compiler/rustc_resolve/messages.ftl
index 0e566e20a124d..1c0e5ad65b3ab 100644
--- a/compiler/rustc_resolve/messages.ftl
+++ b/compiler/rustc_resolve/messages.ftl
@@ -260,6 +260,9 @@ resolve_macro_defined_later =
 resolve_macro_expanded_extern_crate_cannot_shadow_extern_arguments =
     macro-expanded `extern crate` items cannot shadow names passed with `--extern`
 
+resolve_macro_expanded_macro_exports_accessed_by_absolute_paths = macro-expanded `macro_export` macros from the current crate cannot be referred to by absolute paths
+    .note = the macro is defined here
+
 resolve_macro_expected_found =
     expected {$expected}, found {$found} `{$macro_path}`
     .label = not {$article} {$expected}
@@ -339,6 +342,9 @@ resolve_param_in_ty_of_const_param =
 
 resolve_pattern_doesnt_bind_name = pattern doesn't bind `{$name}`
 
+resolve_proc_macro_derive_resolution_fallback = cannot find {$ns_descr} `{$ident}` in this scope
+    .label = names from parent modules are not accessible without an explicit import
+
 resolve_proc_macro_same_crate = can't use a procedural macro from the same crate that defines it
     .help = you can define integration tests in a directory named `tests`
 
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index 689e713ef46dd..236ab1f09d35f 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -138,7 +138,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 MACRO_EXPANDED_MACRO_EXPORTS_ACCESSED_BY_ABSOLUTE_PATHS,
                 CRATE_NODE_ID,
                 span_use,
-                BuiltinLintDiag::MacroExpandedMacroExportsAccessedByAbsolutePaths(span_def),
+                errors::MacroExpandedMacroExportsAccessedByAbsolutePaths { definition: span_def },
             );
         }
 
diff --git a/compiler/rustc_resolve/src/errors.rs b/compiler/rustc_resolve/src/errors.rs
index 72be94e58db93..fb77b9ca1d31f 100644
--- a/compiler/rustc_resolve/src/errors.rs
+++ b/compiler/rustc_resolve/src/errors.rs
@@ -3,7 +3,7 @@ use rustc_errors::{
     Applicability, Diag, ElidedLifetimeInPathSubdiag, EmissionGuarantee, IntoDiagArg, MultiSpan,
     Subdiagnostic,
 };
-use rustc_macros::{Diagnostic, Subdiagnostic};
+use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
 use rustc_span::{Ident, Span, Symbol};
 
 use crate::late::PatternSource;
@@ -566,6 +566,22 @@ pub(crate) struct ProcMacroSameCrate {
     pub(crate) is_test: bool,
 }
 
+#[derive(LintDiagnostic)]
+#[diag(resolve_proc_macro_derive_resolution_fallback)]
+pub(crate) struct ProcMacroDeriveResolutionFallback {
+    #[label]
+    pub span: Span,
+    pub ns_descr: &'static str,
+    pub ident: Ident,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(resolve_macro_expanded_macro_exports_accessed_by_absolute_paths)]
+pub(crate) struct MacroExpandedMacroExportsAccessedByAbsolutePaths {
+    #[note]
+    pub definition: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(resolve_imported_crate)]
 pub(crate) struct CrateImported {
diff --git a/compiler/rustc_resolve/src/ident.rs b/compiler/rustc_resolve/src/ident.rs
index bc06a22757113..35051675fd8dc 100644
--- a/compiler/rustc_resolve/src/ident.rs
+++ b/compiler/rustc_resolve/src/ident.rs
@@ -4,7 +4,6 @@ use rustc_ast::{self as ast, NodeId};
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir::def::{DefKind, MacroKinds, Namespace, NonMacroAttrKind, PartialRes, PerNS};
 use rustc_middle::bug;
-use rustc_session::lint::BuiltinLintDiag;
 use rustc_session::lint::builtin::PROC_MACRO_DERIVE_RESOLUTION_FALLBACK;
 use rustc_session::parse::feature_err;
 use rustc_span::hygiene::{ExpnId, ExpnKind, LocalExpnId, MacroKind, SyntaxContext};
@@ -520,7 +519,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                                         PROC_MACRO_DERIVE_RESOLUTION_FALLBACK,
                                         lint_id,
                                         orig_ident.span,
-                                        BuiltinLintDiag::ProcMacroDeriveResolutionFallback {
+                                        errors::ProcMacroDeriveResolutionFallback {
                                             span: orig_ident.span,
                                             ns_descr: ns.descr(),
                                             ident,
diff --git a/tests/ui/macros/issue-61053-duplicate-binder.stderr b/tests/ui/macros/issue-61053-duplicate-binder.stderr
index 7c7cb26b4071e..1ecbc3f86d0de 100644
--- a/tests/ui/macros/issue-61053-duplicate-binder.stderr
+++ b/tests/ui/macros/issue-61053-duplicate-binder.stderr
@@ -2,9 +2,9 @@ error: duplicate matcher binding
   --> $DIR/issue-61053-duplicate-binder.rs:7:20
    |
 LL |             ($x:tt $x:tt) => { $x };
-   |              --    ^^
+   |              --    ^^ duplicate binding
    |              |
-   |              previous declaration
+   |              previous binding
    |
 note: the lint level is defined here
   --> $DIR/issue-61053-duplicate-binder.rs:1:9

From 31c0d96cb604ead17afeb09062d10cc019de9560 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Wed, 27 Aug 2025 14:11:32 +0200
Subject: [PATCH 0929/1889] Move more early buffered lints to dyn lint
 diagnostics (2/N)

---
 compiler/rustc_ast_passes/messages.ftl        |  4 +++
 .../rustc_ast_passes/src/ast_validation.rs    |  2 +-
 compiler/rustc_ast_passes/src/errors.rs       |  7 +++++
 compiler/rustc_expand/messages.ftl            |  4 +++
 compiler/rustc_expand/src/errors.rs           |  8 +++++
 compiler/rustc_expand/src/expand.rs           |  2 +-
 compiler/rustc_lint/messages.ftl              | 14 ---------
 compiler/rustc_lint/src/early/diagnostics.rs  | 13 --------
 compiler/rustc_lint/src/lints.rs              | 31 -------------------
 compiler/rustc_lint_defs/src/lib.rs           |  9 ------
 compiler/rustc_resolve/messages.ftl           |  7 +++++
 compiler/rustc_resolve/src/check_unused.rs    |  2 +-
 compiler/rustc_resolve/src/errors.rs          | 16 ++++++++++
 compiler/rustc_resolve/src/macros.rs          |  2 +-
 14 files changed, 50 insertions(+), 71 deletions(-)

diff --git a/compiler/rustc_ast_passes/messages.ftl b/compiler/rustc_ast_passes/messages.ftl
index 8dcf3e3aa3882..e5405a7ad910c 100644
--- a/compiler/rustc_ast_passes/messages.ftl
+++ b/compiler/rustc_ast_passes/messages.ftl
@@ -216,6 +216,10 @@ ast_passes_match_arm_with_no_body =
     .suggestion = add a body after the pattern
 
 ast_passes_missing_unsafe_on_extern = extern blocks must be unsafe
+    .suggestion = needs `unsafe` before the extern keyword
+
+ast_passes_missing_unsafe_on_extern_lint = extern blocks should be unsafe
+    .suggestion = needs `unsafe` before the extern keyword
 
 ast_passes_module_nonascii = trying to load file for module `{$name}` with non-ascii identifier name
     .help = consider using the `#[path]` attribute to specify filesystem path
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index a6ef89b553db4..dc221c2fb1abc 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -1131,7 +1131,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                             MISSING_UNSAFE_ON_EXTERN,
                             item.id,
                             item.span,
-                            BuiltinLintDiag::MissingUnsafeOnExtern {
+                            errors::MissingUnsafeOnExternLint {
                                 suggestion: item.span.shrink_to_lo(),
                             },
                         );
diff --git a/compiler/rustc_ast_passes/src/errors.rs b/compiler/rustc_ast_passes/src/errors.rs
index ae805042c549f..e09ca5b81c80c 100644
--- a/compiler/rustc_ast_passes/src/errors.rs
+++ b/compiler/rustc_ast_passes/src/errors.rs
@@ -523,6 +523,13 @@ pub(crate) struct MissingUnsafeOnExtern {
     pub span: Span,
 }
 
+#[derive(LintDiagnostic)]
+#[diag(ast_passes_missing_unsafe_on_extern_lint)]
+pub(crate) struct MissingUnsafeOnExternLint {
+    #[suggestion(code = "unsafe ", applicability = "machine-applicable")]
+    pub suggestion: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(ast_passes_fieldless_union)]
 pub(crate) struct FieldlessUnion {
diff --git a/compiler/rustc_expand/messages.ftl b/compiler/rustc_expand/messages.ftl
index fc50ac6e3bfeb..f82ef96e9c75f 100644
--- a/compiler/rustc_expand/messages.ftl
+++ b/compiler/rustc_expand/messages.ftl
@@ -80,6 +80,10 @@ expand_macro_body_stability =
     .label = invalid body stability attribute
     .label2 = body stability attribute affects this macro
 
+expand_macro_call_unused_doc_comment = unused doc comment
+    .label = rustdoc does not generate documentation for macro invocations
+    .help = to document an item produced by a macro, the macro must produce the documentation as part of its expansion
+
 expand_macro_const_stability =
     macros cannot have const stability attributes
     .label = invalid const stability attribute
diff --git a/compiler/rustc_expand/src/errors.rs b/compiler/rustc_expand/src/errors.rs
index a939dadaf2fcd..06c029482dfe6 100644
--- a/compiler/rustc_expand/src/errors.rs
+++ b/compiler/rustc_expand/src/errors.rs
@@ -537,3 +537,11 @@ pub(crate) struct MacroArgsBadDelimSugg {
     #[suggestion_part(code = ")")]
     pub close: Span,
 }
+
+#[derive(LintDiagnostic)]
+#[diag(expand_macro_call_unused_doc_comment)]
+#[help]
+pub(crate) struct MacroCallUnusedDocComment {
+    #[label]
+    pub span: Span,
+}
diff --git a/compiler/rustc_expand/src/expand.rs b/compiler/rustc_expand/src/expand.rs
index 38e057d2776e4..cda38cd7ae61b 100644
--- a/compiler/rustc_expand/src/expand.rs
+++ b/compiler/rustc_expand/src/expand.rs
@@ -2183,7 +2183,7 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
                     UNUSED_DOC_COMMENTS,
                     current_span,
                     self.cx.current_expansion.lint_node_id,
-                    BuiltinLintDiag::UnusedDocComment(attr.span),
+                    crate::errors::MacroCallUnusedDocComment { span: attr.span },
                 );
             } else if rustc_attr_parsing::is_builtin_attr(attr)
                 && !AttributeParser::<Early>::is_parsed_attribute(&attr.path())
diff --git a/compiler/rustc_lint/messages.ftl b/compiler/rustc_lint/messages.ftl
index 5a60a4f48d9db..68bef1772c0e3 100644
--- a/compiler/rustc_lint/messages.ftl
+++ b/compiler/rustc_lint/messages.ftl
@@ -453,9 +453,6 @@ lint_int_to_ptr_transmutes = transmuting an integer to a pointer creates a point
     .suggestion_with_exposed_provenance = use `std::ptr::with_exposed_provenance{$suffix}` instead to use a previously exposed provenance
     .suggestion_without_provenance_mut = if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
 
-lint_legacy_derive_helpers = derive helper attribute is used before it is introduced
-    .label = the attribute is introduced here
-
 lint_lintpass_by_hand = implementing `LintPass` by hand
     .help = try using `declare_lint_pass!` or `impl_lint_pass!` instead
 
@@ -524,9 +521,6 @@ lint_mismatched_lifetime_syntaxes_suggestion_mixed =
 lint_mismatched_lifetime_syntaxes_suggestion_mixed_only_paths =
     use `'_` for type paths
 
-lint_missing_unsafe_on_extern = extern blocks should be unsafe
-    .suggestion = needs `unsafe` before the extern keyword
-
 lint_mixed_script_confusables =
     the usage of Script Group `{$set}` in this crate consists solely of mixed script confusables
     .includes_note = the usage includes {$includes}
@@ -962,14 +956,6 @@ lint_unused_def = unused {$pre}`{$def}`{$post} that must be used
 lint_unused_delim = unnecessary {$delim} around {$item}
     .suggestion = remove these {$delim}
 
-lint_unused_doc_comment = unused doc comment
-    .label = rustdoc does not generate documentation for macro invocations
-    .help = to document an item produced by a macro, the macro must produce the documentation as part of its expansion
-
-lint_unused_extern_crate = unused extern crate
-    .label = unused
-    .suggestion = remove the unused `extern crate`
-
 lint_unused_import_braces = braces around {$node} is unnecessary
 
 lint_unused_imports = {$num_snippets ->
diff --git a/compiler/rustc_lint/src/early/diagnostics.rs b/compiler/rustc_lint/src/early/diagnostics.rs
index 4463586515ec1..eb5c89660e1ff 100644
--- a/compiler/rustc_lint/src/early/diagnostics.rs
+++ b/compiler/rustc_lint/src/early/diagnostics.rs
@@ -135,9 +135,6 @@ pub fn decorate_builtin_lint(
             stability::Deprecated { sub, kind: "macro".to_owned(), path, note, since_kind }
                 .decorate_lint(diag);
         }
-        BuiltinLintDiag::UnusedDocComment(attr_span) => {
-            lints::UnusedDocComment { span: attr_span }.decorate_lint(diag);
-        }
         BuiltinLintDiag::PatternsInFnsWithoutBody { span: remove_span, ident, is_foreign } => {
             let sub = lints::PatternsInFnsWithoutBodySub { ident, span: remove_span };
             if is_foreign {
@@ -147,9 +144,6 @@ pub fn decorate_builtin_lint(
             }
             .decorate_lint(diag);
         }
-        BuiltinLintDiag::LegacyDeriveHelpers(label_span) => {
-            lints::LegacyDeriveHelpers { span: label_span }.decorate_lint(diag);
-        }
         BuiltinLintDiag::OrPatternsBackCompat(suggestion_span, suggestion) => {
             lints::OrPatternsBackCompat { span: suggestion_span, suggestion }.decorate_lint(diag);
         }
@@ -210,9 +204,6 @@ pub fn decorate_builtin_lint(
             };
             lints::DeprecatedWhereClauseLocation { suggestion }.decorate_lint(diag);
         }
-        BuiltinLintDiag::MissingUnsafeOnExtern { suggestion } => {
-            lints::MissingUnsafeOnExtern { suggestion }.decorate_lint(diag);
-        }
         BuiltinLintDiag::SingleUseLifetime {
             param_span,
             use_span: Some((use_span, elide)),
@@ -242,7 +233,6 @@ pub fn decorate_builtin_lint(
                 .decorate_lint(diag);
         }
         BuiltinLintDiag::SingleUseLifetime { use_span: None, deletion_span, ident, .. } => {
-            debug!(?deletion_span);
             lints::UnusedLifetime { deletion_span, ident }.decorate_lint(diag);
         }
         BuiltinLintDiag::NamedArgumentUsedPositionally {
@@ -283,9 +273,6 @@ pub fn decorate_builtin_lint(
         BuiltinLintDiag::ByteSliceInPackedStructWithDerive { ty } => {
             lints::ByteSliceInPackedStructWithDerive { ty }.decorate_lint(diag);
         }
-        BuiltinLintDiag::UnusedExternCrate { span, removal_span } => {
-            lints::UnusedExternCrate { span, removal_span }.decorate_lint(diag);
-        }
         BuiltinLintDiag::ExternCrateNotIdiomatic { vis_span, ident_span } => {
             let suggestion_span = vis_span.between(ident_span);
             let code = if vis_span.is_empty() { "use " } else { " use " };
diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
index 1c13fadeef968..c084e8605f782 100644
--- a/compiler/rustc_lint/src/lints.rs
+++ b/compiler/rustc_lint/src/lints.rs
@@ -2749,14 +2749,6 @@ pub(crate) enum RedundantImportSub {
     DefinedPrelude(#[primary_span] Span),
 }
 
-#[derive(LintDiagnostic)]
-#[diag(lint_unused_doc_comment)]
-#[help]
-pub(crate) struct UnusedDocComment {
-    #[label]
-    pub span: Span,
-}
-
 #[derive(LintDiagnostic)]
 pub(crate) enum PatternsInFnsWithoutBody {
     #[diag(lint_pattern_in_foreign)]
@@ -2780,13 +2772,6 @@ pub(crate) struct PatternsInFnsWithoutBodySub {
     pub ident: Ident,
 }
 
-#[derive(LintDiagnostic)]
-#[diag(lint_legacy_derive_helpers)]
-pub(crate) struct LegacyDeriveHelpers {
-    #[label]
-    pub span: Span,
-}
-
 #[derive(LintDiagnostic)]
 #[diag(lint_or_patterns_back_compat)]
 pub(crate) struct OrPatternsBackCompat {
@@ -2878,13 +2863,6 @@ pub(crate) enum DeprecatedWhereClauseLocationSugg {
     },
 }
 
-#[derive(LintDiagnostic)]
-#[diag(lint_missing_unsafe_on_extern)]
-pub(crate) struct MissingUnsafeOnExtern {
-    #[suggestion(code = "unsafe ", applicability = "machine-applicable")]
-    pub suggestion: Span,
-}
-
 #[derive(LintDiagnostic)]
 #[diag(lint_single_use_lifetime)]
 pub(crate) struct SingleUseLifetime {
@@ -2940,15 +2918,6 @@ pub(crate) struct ByteSliceInPackedStructWithDerive {
     pub ty: String,
 }
 
-#[derive(LintDiagnostic)]
-#[diag(lint_unused_extern_crate)]
-pub(crate) struct UnusedExternCrate {
-    #[label]
-    pub span: Span,
-    #[suggestion(code = "", applicability = "machine-applicable", style = "verbose")]
-    pub removal_span: Span,
-}
-
 #[derive(LintDiagnostic)]
 #[diag(lint_extern_crate_not_idiomatic)]
 pub(crate) struct ExternCrateNotIdiomatic {
diff --git a/compiler/rustc_lint_defs/src/lib.rs b/compiler/rustc_lint_defs/src/lib.rs
index 77c17c6c1e39e..50c3bcf0434bc 100644
--- a/compiler/rustc_lint_defs/src/lib.rs
+++ b/compiler/rustc_lint_defs/src/lib.rs
@@ -640,7 +640,6 @@ pub enum BuiltinLintDiag {
         path: String,
         since_kind: DeprecatedSinceKind,
     },
-    UnusedDocComment(Span),
     UnusedBuiltinAttribute {
         attr_name: Symbol,
         macro_name: String,
@@ -652,7 +651,6 @@ pub enum BuiltinLintDiag {
         ident: Ident,
         is_foreign: bool,
     },
-    LegacyDeriveHelpers(Span),
     OrPatternsBackCompat(Span, String),
     ReservedPrefix(Span, String),
     /// `'r#` in edition < 2021.
@@ -668,9 +666,6 @@ pub enum BuiltinLintDiag {
     UnexpectedCfgName((Symbol, Span), Option<(Symbol, Span)>),
     UnexpectedCfgValue((Symbol, Span), Option<(Symbol, Span)>),
     DeprecatedWhereclauseLocation(Span, Option<(Span, String)>),
-    MissingUnsafeOnExtern {
-        suggestion: Span,
-    },
     SingleUseLifetime {
         /// Span of the parameter which declares this lifetime.
         param_span: Span,
@@ -699,10 +694,6 @@ pub enum BuiltinLintDiag {
         // FIXME: enum of byte/string
         ty: String,
     },
-    UnusedExternCrate {
-        span: Span,
-        removal_span: Span,
-    },
     ExternCrateNotIdiomatic {
         vis_span: Span,
         ident_span: Span,
diff --git a/compiler/rustc_resolve/messages.ftl b/compiler/rustc_resolve/messages.ftl
index 1c0e5ad65b3ab..32833f5e8d9b3 100644
--- a/compiler/rustc_resolve/messages.ftl
+++ b/compiler/rustc_resolve/messages.ftl
@@ -231,6 +231,9 @@ resolve_item_was_cfg_out = the item is gated here
 resolve_label_with_similar_name_reachable =
     a label with a similar name is reachable
 
+resolve_legacy_derive_helpers = derive helper attribute is used before it is introduced
+    .label = the attribute is introduced here
+
 resolve_lending_iterator_report_error =
     associated type `Iterator::Item` is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
     .note = you can't create an `Iterator` that borrows each `Item` from itself, but you can instead create a new type that borrows your existing type and implement `Iterator` for that new type
@@ -471,6 +474,10 @@ resolve_unreachable_label_suggestion_use_similarly_named =
 resolve_unreachable_label_with_similar_name_exists =
     a label with a similar name exists but is unreachable
 
+resolve_unused_extern_crate = unused extern crate
+    .label = unused
+    .suggestion = remove the unused `extern crate`
+
 resolve_variable_bound_with_different_mode =
     variable `{$variable_name}` is bound inconsistently across alternatives separated by `|`
     .label = bound in different ways
diff --git a/compiler/rustc_resolve/src/check_unused.rs b/compiler/rustc_resolve/src/check_unused.rs
index 50a1ad23a5462..a80cd7540afaf 100644
--- a/compiler/rustc_resolve/src/check_unused.rs
+++ b/compiler/rustc_resolve/src/check_unused.rs
@@ -169,7 +169,7 @@ impl<'a, 'ra, 'tcx> UnusedImportCheckVisitor<'a, 'ra, 'tcx> {
                         UNUSED_EXTERN_CRATES,
                         extern_crate.id,
                         span,
-                        BuiltinLintDiag::UnusedExternCrate {
+                        crate::errors::UnusedExternCrate {
                             span: extern_crate.span,
                             removal_span: extern_crate.span_with_attributes,
                         },
diff --git a/compiler/rustc_resolve/src/errors.rs b/compiler/rustc_resolve/src/errors.rs
index fb77b9ca1d31f..6b36906c86532 100644
--- a/compiler/rustc_resolve/src/errors.rs
+++ b/compiler/rustc_resolve/src/errors.rs
@@ -1292,3 +1292,19 @@ pub(crate) struct TraitImplMismatch {
     #[label(resolve_trait_impl_mismatch_label_item)]
     pub(crate) trait_item_span: Span,
 }
+
+#[derive(LintDiagnostic)]
+#[diag(resolve_legacy_derive_helpers)]
+pub(crate) struct LegacyDeriveHelpers {
+    #[label]
+    pub span: Span,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(resolve_unused_extern_crate)]
+pub(crate) struct UnusedExternCrate {
+    #[label]
+    pub span: Span,
+    #[suggestion(code = "", applicability = "machine-applicable", style = "verbose")]
+    pub removal_span: Span,
+}
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs
index 5fa87b4cd9b68..d3e98ef839b0b 100644
--- a/compiler/rustc_resolve/src/macros.rs
+++ b/compiler/rustc_resolve/src/macros.rs
@@ -979,7 +979,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                             LEGACY_DERIVE_HELPERS,
                             node_id,
                             ident.span,
-                            BuiltinLintDiag::LegacyDeriveHelpers(binding.span),
+                            errors::LegacyDeriveHelpers { span: binding.span },
                         );
                     }
                 }

From 379b181fe698108d61ac05bad328e14567739304 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Wed, 27 Aug 2025 14:11:41 +0200
Subject: [PATCH 0930/1889] Remove a dead early lint

Dropped in favor a hard error in RUST-127907.
---
 compiler/rustc_lint/messages.ftl             | 3 ---
 compiler/rustc_lint/src/early/diagnostics.rs | 3 ---
 compiler/rustc_lint/src/lints.rs             | 8 --------
 compiler/rustc_lint_defs/src/lib.rs          | 4 ----
 4 files changed, 18 deletions(-)

diff --git a/compiler/rustc_lint/messages.ftl b/compiler/rustc_lint/messages.ftl
index 68bef1772c0e3..e348ae2c57458 100644
--- a/compiler/rustc_lint/messages.ftl
+++ b/compiler/rustc_lint/messages.ftl
@@ -181,9 +181,6 @@ lint_builtin_unused_doc_comment = unused doc comment
 lint_builtin_while_true = denote infinite loops with `loop {"{"} ... {"}"}`
     .suggestion = use `loop`
 
-lint_byte_slice_in_packed_struct_with_derive = {$ty} slice in a packed struct that derives a built-in trait
-    .help = consider implementing the trait by hand, or remove the `packed` attribute
-
 lint_check_name_unknown_tool = unknown lint tool: `{$tool_name}`
 
 lint_closure_returning_async_block = closure returning async block can be made into an async closure
diff --git a/compiler/rustc_lint/src/early/diagnostics.rs b/compiler/rustc_lint/src/early/diagnostics.rs
index eb5c89660e1ff..4039888993860 100644
--- a/compiler/rustc_lint/src/early/diagnostics.rs
+++ b/compiler/rustc_lint/src/early/diagnostics.rs
@@ -270,9 +270,6 @@ pub fn decorate_builtin_lint(
             }
             .decorate_lint(diag);
         }
-        BuiltinLintDiag::ByteSliceInPackedStructWithDerive { ty } => {
-            lints::ByteSliceInPackedStructWithDerive { ty }.decorate_lint(diag);
-        }
         BuiltinLintDiag::ExternCrateNotIdiomatic { vis_span, ident_span } => {
             let suggestion_span = vis_span.between(ident_span);
             let code = if vis_span.is_empty() { "use " } else { " use " };
diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
index c084e8605f782..64875ee4e8a1f 100644
--- a/compiler/rustc_lint/src/lints.rs
+++ b/compiler/rustc_lint/src/lints.rs
@@ -2910,14 +2910,6 @@ pub(crate) struct NamedArgumentUsedPositionally {
     pub named_arg_name: String,
 }
 
-#[derive(LintDiagnostic)]
-#[diag(lint_byte_slice_in_packed_struct_with_derive)]
-#[help]
-pub(crate) struct ByteSliceInPackedStructWithDerive {
-    // FIXME: make this translatable
-    pub ty: String,
-}
-
 #[derive(LintDiagnostic)]
 #[diag(lint_extern_crate_not_idiomatic)]
 pub(crate) struct ExternCrateNotIdiomatic {
diff --git a/compiler/rustc_lint_defs/src/lib.rs b/compiler/rustc_lint_defs/src/lib.rs
index 50c3bcf0434bc..0b4b5015aca5e 100644
--- a/compiler/rustc_lint_defs/src/lib.rs
+++ b/compiler/rustc_lint_defs/src/lib.rs
@@ -690,10 +690,6 @@ pub enum BuiltinLintDiag {
         /// Indicates if the named argument is used as a width/precision for formatting
         is_formatting_arg: bool,
     },
-    ByteSliceInPackedStructWithDerive {
-        // FIXME: enum of byte/string
-        ty: String,
-    },
     ExternCrateNotIdiomatic {
         vis_span: Span,
         ident_span: Span,

From 27a180a31a10bad8d5116146459a49a16b4f3866 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Wed, 27 Aug 2025 15:07:14 +0200
Subject: [PATCH 0931/1889] Move more early buffered lints to dyn lint
 diagnostics (3/N)

---
 compiler/rustc_lint/messages.ftl             | 11 ----------
 compiler/rustc_lint/src/early/diagnostics.rs |  8 --------
 compiler/rustc_lint/src/lints.rs             | 21 --------------------
 compiler/rustc_lint_defs/src/lib.rs          |  8 --------
 compiler/rustc_resolve/messages.ftl          | 11 ++++++++++
 compiler/rustc_resolve/src/check_unused.rs   |  4 ++--
 compiler/rustc_resolve/src/errors.rs         | 21 ++++++++++++++++++++
 compiler/rustc_resolve/src/imports.rs        |  6 +++---
 compiler/rustc_resolve/src/late.rs           |  4 ++--
 9 files changed, 39 insertions(+), 55 deletions(-)

diff --git a/compiler/rustc_lint/messages.ftl b/compiler/rustc_lint/messages.ftl
index e348ae2c57458..c11e59ca05882 100644
--- a/compiler/rustc_lint/messages.ftl
+++ b/compiler/rustc_lint/messages.ftl
@@ -460,10 +460,6 @@ lint_macro_is_private = macro `{$ident}` is private
 
 lint_macro_rule_never_used = rule #{$n} of macro `{$name}` is never used
 
-lint_macro_use_deprecated =
-    applying the `#[macro_use]` attribute to an `extern crate` item is deprecated
-    .help = remove it and import macros at use sites with a `use` item instead
-
 lint_malformed_attribute = malformed lint attribute input
 
 lint_map_unit_fn = `Iterator::map` call that discard the iterator's values
@@ -726,9 +722,6 @@ lint_redundant_semicolons_suggestion = remove {$multiple_semicolons ->
         *[false] this semicolon
     }
 
-lint_reexport_private_dependency =
-    {$kind} `{$name}` from private dependency '{$krate}' is re-exported
-
 lint_remove_mut_from_pattern = remove `mut` from the parameter
 
 lint_removed_lint = lint `{$name}` has been removed: {$reason}
@@ -966,15 +959,11 @@ lint_unused_imports = {$num_snippets ->
         }
     .help = if this is a test module, consider adding a `#[cfg(test)]` to the containing module
 
-lint_unused_label = unused label
-
 lint_unused_lifetime = lifetime parameter `{$ident}` never used
     .suggestion = elide the unused lifetime
 
 lint_unused_macro_definition = unused macro definition: `{$name}`
 
-lint_unused_macro_use = unused `#[macro_use]` import
-
 lint_unused_op = unused {$op} that must be used
     .label = the {$op} produces a value
     .suggestion = use `let _ = ...` to ignore the resulting value
diff --git a/compiler/rustc_lint/src/early/diagnostics.rs b/compiler/rustc_lint/src/early/diagnostics.rs
index 4039888993860..e8daf3e46b870 100644
--- a/compiler/rustc_lint/src/early/diagnostics.rs
+++ b/compiler/rustc_lint/src/early/diagnostics.rs
@@ -308,9 +308,6 @@ pub fn decorate_builtin_lint(
             }
             .decorate_lint(diag);
         }
-        BuiltinLintDiag::ReexportPrivateDependency { name, kind, krate } => {
-            lints::ReexportPrivateDependency { name, kind, krate }.decorate_lint(diag);
-        }
         BuiltinLintDiag::UnusedQualifications { removal_span } => {
             lints::UnusedQualifications { removal_span }.decorate_lint(diag);
         }
@@ -350,15 +347,10 @@ pub fn decorate_builtin_lint(
             });
             lints::UnknownDiagnosticAttribute { typo }.decorate_lint(diag);
         }
-        BuiltinLintDiag::MacroUseDeprecated => {
-            lints::MacroUseDeprecated.decorate_lint(diag);
-        }
-        BuiltinLintDiag::UnusedMacroUse => lints::UnusedMacroUse.decorate_lint(diag),
         BuiltinLintDiag::PrivateExternCrateReexport { source: ident, extern_crate_span } => {
             lints::PrivateExternCrateReexport { ident, sugg: extern_crate_span.shrink_to_lo() }
                 .decorate_lint(diag);
         }
-        BuiltinLintDiag::UnusedLabel => lints::UnusedLabel.decorate_lint(diag),
         BuiltinLintDiag::MacroIsPrivate(ident) => {
             lints::MacroIsPrivate { ident }.decorate_lint(diag);
         }
diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
index 64875ee4e8a1f..7c375a98f9e9d 100644
--- a/compiler/rustc_lint/src/lints.rs
+++ b/compiler/rustc_lint/src/lints.rs
@@ -2535,15 +2535,6 @@ pub(crate) mod unexpected_cfg_value {
     }
 }
 
-#[derive(LintDiagnostic)]
-#[diag(lint_macro_use_deprecated)]
-#[help]
-pub(crate) struct MacroUseDeprecated;
-
-#[derive(LintDiagnostic)]
-#[diag(lint_unused_macro_use)]
-pub(crate) struct UnusedMacroUse;
-
 #[derive(LintDiagnostic)]
 #[diag(lint_private_extern_crate_reexport, code = E0365)]
 pub(crate) struct PrivateExternCrateReexport {
@@ -2552,10 +2543,6 @@ pub(crate) struct PrivateExternCrateReexport {
     pub sugg: Span,
 }
 
-#[derive(LintDiagnostic)]
-#[diag(lint_unused_label)]
-pub(crate) struct UnusedLabel;
-
 #[derive(LintDiagnostic)]
 #[diag(lint_macro_is_private)]
 pub(crate) struct MacroIsPrivate {
@@ -2957,14 +2944,6 @@ pub(crate) struct HiddenGlobReexports {
     pub namespace: String,
 }
 
-#[derive(LintDiagnostic)]
-#[diag(lint_reexport_private_dependency)]
-pub(crate) struct ReexportPrivateDependency {
-    pub name: String,
-    pub kind: String,
-    pub krate: Symbol,
-}
-
 #[derive(LintDiagnostic)]
 #[diag(lint_unnecessary_qualification)]
 pub(crate) struct UnusedQualifications {
diff --git a/compiler/rustc_lint_defs/src/lib.rs b/compiler/rustc_lint_defs/src/lib.rs
index 0b4b5015aca5e..239b03edfaf00 100644
--- a/compiler/rustc_lint_defs/src/lib.rs
+++ b/compiler/rustc_lint_defs/src/lib.rs
@@ -717,11 +717,6 @@ pub enum BuiltinLintDiag {
         /// The local binding that shadows the glob reexport.
         private_item_span: Span,
     },
-    ReexportPrivateDependency {
-        name: String,
-        kind: String,
-        krate: Symbol,
-    },
     UnusedQualifications {
         /// The span of the unnecessarily-qualified path to remove.
         removal_span: Span,
@@ -744,13 +739,10 @@ pub enum BuiltinLintDiag {
         span: Span,
         typo_name: Option<Symbol>,
     },
-    MacroUseDeprecated,
-    UnusedMacroUse,
     PrivateExternCrateReexport {
         source: Ident,
         extern_crate_span: Span,
     },
-    UnusedLabel,
     MacroIsPrivate(Ident),
     UnusedMacroDefinition(Symbol),
     MacroRuleNeverUsed(usize, Symbol),
diff --git a/compiler/rustc_resolve/messages.ftl b/compiler/rustc_resolve/messages.ftl
index 32833f5e8d9b3..cc8fbc18b7377 100644
--- a/compiler/rustc_resolve/messages.ftl
+++ b/compiler/rustc_resolve/messages.ftl
@@ -274,6 +274,10 @@ resolve_macro_extern_deprecated =
     `#[macro_escape]` is a deprecated synonym for `#[macro_use]`
     .help = try an outer attribute: `#[macro_use]`
 
+resolve_macro_use_deprecated =
+    applying the `#[macro_use]` attribute to an `extern crate` item is deprecated
+    .help = remove it and import macros at use sites with a `use` item instead
+
 resolve_macro_use_extern_crate_self = `#[macro_use]` is not supported on `extern crate self`
 
 resolve_macro_use_name_already_in_use =
@@ -357,6 +361,9 @@ resolve_reexport_of_crate_public =
 resolve_reexport_of_private =
     re-export of private `{$ident}`
 
+resolve_reexport_private_dependency =
+    {$kind} `{$name}` from private dependency '{$krate}' is re-exported
+
 resolve_relative_2018 =
     relative paths are not supported in visibilities in 2018 edition or later
     .suggestion = try
@@ -478,6 +485,10 @@ resolve_unused_extern_crate = unused extern crate
     .label = unused
     .suggestion = remove the unused `extern crate`
 
+resolve_unused_label = unused label
+
+resolve_unused_macro_use = unused `#[macro_use]` import
+
 resolve_variable_bound_with_different_mode =
     variable `{$variable_name}` is bound inconsistently across alternatives separated by `|`
     .label = bound in different ways
diff --git a/compiler/rustc_resolve/src/check_unused.rs b/compiler/rustc_resolve/src/check_unused.rs
index a80cd7540afaf..95f979a3fed33 100644
--- a/compiler/rustc_resolve/src/check_unused.rs
+++ b/compiler/rustc_resolve/src/check_unused.rs
@@ -406,7 +406,7 @@ impl Resolver<'_, '_> {
                                 MACRO_USE_EXTERN_CRATE,
                                 import.root_id,
                                 import.span,
-                                BuiltinLintDiag::MacroUseDeprecated,
+                                crate::errors::MacroUseDeprecated,
                             );
                         }
                     }
@@ -427,7 +427,7 @@ impl Resolver<'_, '_> {
                         UNUSED_IMPORTS,
                         import.root_id,
                         import.span,
-                        BuiltinLintDiag::UnusedMacroUse,
+                        crate::errors::UnusedMacroUse,
                     );
                 }
                 _ => {}
diff --git a/compiler/rustc_resolve/src/errors.rs b/compiler/rustc_resolve/src/errors.rs
index 6b36906c86532..f0ea97ba8a0c0 100644
--- a/compiler/rustc_resolve/src/errors.rs
+++ b/compiler/rustc_resolve/src/errors.rs
@@ -1308,3 +1308,24 @@ pub(crate) struct UnusedExternCrate {
     #[suggestion(code = "", applicability = "machine-applicable", style = "verbose")]
     pub removal_span: Span,
 }
+
+#[derive(LintDiagnostic)]
+#[diag(resolve_reexport_private_dependency)]
+pub(crate) struct ReexportPrivateDependency {
+    pub name: Symbol,
+    pub kind: &'static str,
+    pub krate: Symbol,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(resolve_unused_label)]
+pub(crate) struct UnusedLabel;
+
+#[derive(LintDiagnostic)]
+#[diag(resolve_unused_macro_use)]
+pub(crate) struct UnusedMacroUse;
+
+#[derive(LintDiagnostic)]
+#[diag(resolve_macro_use_deprecated)]
+#[help]
+pub(crate) struct MacroUseDeprecated;
diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
index d7fc028287ff5..33c2c7436d1b7 100644
--- a/compiler/rustc_resolve/src/imports.rs
+++ b/compiler/rustc_resolve/src/imports.rs
@@ -720,9 +720,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         EXPORTED_PRIVATE_DEPENDENCIES,
                         binding_id,
                         binding.span,
-                        BuiltinLintDiag::ReexportPrivateDependency {
-                            kind: binding.res().descr().to_string(),
-                            name: key.ident.name.to_string(),
+                        crate::errors::ReexportPrivateDependency {
+                            name: key.ident.name,
+                            kind: binding.res().descr(),
                             krate: self.tcx.crate_name(reexported_def_id.krate),
                         },
                     );
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
index 521fef2b9d432..4d4acc60ca804 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/compiler/rustc_resolve/src/late.rs
@@ -29,7 +29,7 @@ use rustc_middle::middle::resolve_bound_vars::Set1;
 use rustc_middle::ty::{DelegationFnSig, Visibility};
 use rustc_middle::{bug, span_bug};
 use rustc_session::config::{CrateType, ResolveDocLinks};
-use rustc_session::lint::{self, BuiltinLintDiag};
+use rustc_session::lint;
 use rustc_session::parse::feature_err;
 use rustc_span::source_map::{Spanned, respan};
 use rustc_span::{BytePos, Ident, Span, Symbol, SyntaxContext, kw, sym};
@@ -5225,7 +5225,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 lint::builtin::UNUSED_LABELS,
                 *id,
                 *span,
-                BuiltinLintDiag::UnusedLabel,
+                errors::UnusedLabel,
             );
         }
     }

From ec7ad59789138871418362d9592b1e848bab4053 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Sun, 14 Sep 2025 06:03:22 +0200
Subject: [PATCH 0932/1889] Move more early buffered lints to dyn lint
 diagnostics (4/N)

---
 compiler/rustc_expand/messages.ftl           | 11 +++++
 compiler/rustc_expand/src/errors.rs          | 28 +++++++++++++
 compiler/rustc_expand/src/expand.rs          |  3 +-
 compiler/rustc_expand/src/mbe/macro_rules.rs |  5 +--
 compiler/rustc_interface/messages.ftl        |  3 ++
 compiler/rustc_interface/src/errors.rs       | 17 +++++++-
 compiler/rustc_interface/src/util.rs         |  8 ++--
 compiler/rustc_lint/messages.ftl             | 14 -------
 compiler/rustc_lint/src/early/diagnostics.rs | 19 ---------
 compiler/rustc_lint/src/lints.rs             | 44 --------------------
 compiler/rustc_lint_defs/src/lib.rs          | 12 ------
 11 files changed, 66 insertions(+), 98 deletions(-)

diff --git a/compiler/rustc_expand/messages.ftl b/compiler/rustc_expand/messages.ftl
index f82ef96e9c75f..47c00bff5c950 100644
--- a/compiler/rustc_expand/messages.ftl
+++ b/compiler/rustc_expand/messages.ftl
@@ -160,6 +160,9 @@ expand_mve_unrecognized_var =
 expand_non_inline_modules_in_proc_macro_input_are_unstable =
     non-inline modules in proc macro input are unstable
 
+expand_or_patterns_back_compat = the meaning of the `pat` fragment specifier is changing in Rust 2021, which may affect this macro
+    .suggestion = use pat_param to preserve semantics
+
 expand_proc_macro_back_compat = using an old version of `{$crate_name}`
     .note = older versions of the `{$crate_name}` crate no longer compile; please update to `{$crate_name}` v{$fixed_version}, or switch to one of the `{$crate_name}` alternatives
 
@@ -189,8 +192,16 @@ expand_resolve_relative_path =
 
 expand_trace_macro = trace_macro
 
+expand_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}`
+
 expand_unknown_macro_variable = unknown macro variable `{$name}`
 
+expand_unused_builtin_attribute = unused attribute `{$attr_name}`
+    .note = the built-in attribute `{$attr_name}` will be ignored, since it's applied to the macro invocation `{$macro_name}`
+    .suggestion = remove the attribute
+
 expand_unsupported_key_value =
     key-value macro attributes are not supported
 
diff --git a/compiler/rustc_expand/src/errors.rs b/compiler/rustc_expand/src/errors.rs
index 06c029482dfe6..c37c2d88d9cd2 100644
--- a/compiler/rustc_expand/src/errors.rs
+++ b/compiler/rustc_expand/src/errors.rs
@@ -545,3 +545,31 @@ pub(crate) struct MacroCallUnusedDocComment {
     #[label]
     pub span: Span,
 }
+
+#[derive(LintDiagnostic)]
+#[diag(expand_or_patterns_back_compat)]
+pub(crate) struct OrPatternsBackCompat {
+    #[suggestion(code = "{suggestion}", applicability = "machine-applicable")]
+    pub span: Span,
+    pub suggestion: String,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(expand_trailing_semi_macro)]
+pub(crate) struct TrailingMacro {
+    #[note(expand_note1)]
+    #[note(expand_note2)]
+    pub is_trailing: bool,
+    pub name: Ident,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(expand_unused_builtin_attribute)]
+pub(crate) struct UnusedBuiltinAttribute {
+    #[note]
+    pub invoc_span: Span,
+    pub attr_name: Symbol,
+    pub macro_name: String,
+    #[suggestion(code = "", applicability = "machine-applicable", style = "tool-only")]
+    pub attr_span: Span,
+}
diff --git a/compiler/rustc_expand/src/expand.rs b/compiler/rustc_expand/src/expand.rs
index cda38cd7ae61b..4c0e0bbfe26d1 100644
--- a/compiler/rustc_expand/src/expand.rs
+++ b/compiler/rustc_expand/src/expand.rs
@@ -25,7 +25,6 @@ use rustc_parse::parser::{
     token_descr,
 };
 use rustc_session::Session;
-use rustc_session::lint::BuiltinLintDiag;
 use rustc_session::lint::builtin::{UNUSED_ATTRIBUTES, UNUSED_DOC_COMMENTS};
 use rustc_session::parse::feature_err;
 use rustc_span::hygiene::SyntaxContext;
@@ -2196,7 +2195,7 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
                         UNUSED_ATTRIBUTES,
                         attr.span,
                         self.cx.current_expansion.lint_node_id,
-                        BuiltinLintDiag::UnusedBuiltinAttribute {
+                        crate::errors::UnusedBuiltinAttribute {
                             attr_name,
                             macro_name: pprust::path_to_string(&call.path),
                             invoc_span: call.path.span,
diff --git a/compiler/rustc_expand/src/mbe/macro_rules.rs b/compiler/rustc_expand/src/mbe/macro_rules.rs
index 8b43f852b2638..946265eba8bdb 100644
--- a/compiler/rustc_expand/src/mbe/macro_rules.rs
+++ b/compiler/rustc_expand/src/mbe/macro_rules.rs
@@ -17,7 +17,6 @@ use rustc_hir as hir;
 use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def::MacroKinds;
 use rustc_hir::find_attr;
-use rustc_lint_defs::BuiltinLintDiag;
 use rustc_lint_defs::builtin::{
     RUST_2021_INCOMPATIBLE_OR_PATTERNS, SEMICOLON_IN_EXPRESSIONS_FROM_MACROS,
 };
@@ -90,7 +89,7 @@ impl<'a> ParserAnyMacro<'a> {
                     SEMICOLON_IN_EXPRESSIONS_FROM_MACROS,
                     parser.token.span,
                     lint_node_id,
-                    BuiltinLintDiag::TrailingMacro(is_trailing_mac, macro_ident),
+                    errors::TrailingMacro { is_trailing: is_trailing_mac, name: macro_ident },
                 );
             }
             parser.bump();
@@ -1425,7 +1424,7 @@ fn check_matcher_core<'tt>(
                             RUST_2021_INCOMPATIBLE_OR_PATTERNS,
                             span,
                             ast::CRATE_NODE_ID,
-                            BuiltinLintDiag::OrPatternsBackCompat(span, suggestion),
+                            errors::OrPatternsBackCompat { span, suggestion },
                         );
                     }
                     match is_in_follow(next_token, kind) {
diff --git a/compiler/rustc_interface/messages.ftl b/compiler/rustc_interface/messages.ftl
index d83b18cbc2df6..6f6666f8c76fa 100644
--- a/compiler/rustc_interface/messages.ftl
+++ b/compiler/rustc_interface/messages.ftl
@@ -30,6 +30,9 @@ interface_ignoring_out_dir = ignoring --out-dir flag due to -o flag
 interface_input_file_would_be_overwritten =
     the input file "{$path}" would be overwritten by the generated executable
 
+interface_invalid_crate_type_value = invalid `crate_type` value
+    .suggestion = did you mean
+
 interface_mixed_bin_crate =
     cannot mix `bin` crate type with others
 
diff --git a/compiler/rustc_interface/src/errors.rs b/compiler/rustc_interface/src/errors.rs
index d1082eaf6173c..727e09c7562b5 100644
--- a/compiler/rustc_interface/src/errors.rs
+++ b/compiler/rustc_interface/src/errors.rs
@@ -1,7 +1,7 @@
 use std::io;
 use std::path::Path;
 
-use rustc_macros::Diagnostic;
+use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
 use rustc_span::{Span, Symbol};
 
 #[derive(Diagnostic)]
@@ -108,3 +108,18 @@ pub(crate) struct AbiRequiredTargetFeature<'a> {
     pub feature: &'a str,
     pub enabled: &'a str,
 }
+
+#[derive(LintDiagnostic)]
+#[diag(interface_invalid_crate_type_value)]
+pub(crate) struct UnknownCrateTypes {
+    #[subdiagnostic]
+    pub sugg: Option<UnknownCrateTypesSub>,
+}
+
+#[derive(Subdiagnostic)]
+#[suggestion(interface_suggestion, code = r#""{snippet}""#, applicability = "maybe-incorrect")]
+pub(crate) struct UnknownCrateTypesSub {
+    #[primary_span]
+    pub span: Span,
+    pub snippet: Symbol,
+}
diff --git a/compiler/rustc_interface/src/util.rs b/compiler/rustc_interface/src/util.rs
index 04006f3e446c1..061c764e619a3 100644
--- a/compiler/rustc_interface/src/util.rs
+++ b/compiler/rustc_interface/src/util.rs
@@ -13,9 +13,8 @@ use rustc_errors::LintBuffer;
 use rustc_metadata::{DylibError, load_symbol_from_dylib};
 use rustc_middle::ty::CurrentGcx;
 use rustc_session::config::{Cfg, OutFileName, OutputFilenames, OutputTypes, Sysroot, host_tuple};
-use rustc_session::lint::{self, BuiltinLintDiag};
 use rustc_session::output::{CRATE_TYPES, categorize_crate_type};
-use rustc_session::{EarlyDiagCtxt, Session, filesearch};
+use rustc_session::{EarlyDiagCtxt, Session, filesearch, lint};
 use rustc_span::edit_distance::find_best_match_for_name;
 use rustc_span::edition::Edition;
 use rustc_span::source_map::SourceMapInputs;
@@ -468,7 +467,10 @@ pub(crate) fn check_attr_crate_type(
                         lint::builtin::UNKNOWN_CRATE_TYPES,
                         ast::CRATE_NODE_ID,
                         span,
-                        BuiltinLintDiag::UnknownCrateTypes { span, candidate },
+                        errors::UnknownCrateTypes {
+                            sugg: candidate
+                                .map(|cand| errors::UnknownCrateTypesSub { span, snippet: cand }),
+                        },
                     );
                 }
             } else {
diff --git a/compiler/rustc_lint/messages.ftl b/compiler/rustc_lint/messages.ftl
index c11e59ca05882..5b98c9fafaad4 100644
--- a/compiler/rustc_lint/messages.ftl
+++ b/compiler/rustc_lint/messages.ftl
@@ -407,9 +407,6 @@ lint_invalid_asm_label_named = avoid using named labels in inline assembly
     .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
 lint_invalid_asm_label_no_span = the label may be declared in the expansion of a macro
 
-lint_invalid_crate_type_value = invalid `crate_type` value
-    .suggestion = did you mean
-
 # FIXME: we should ordinalize $valid_up_to when we add support for doing so
 lint_invalid_from_utf8_checked = calls to `{$method}` with an invalid literal always return an error
     .label = the literal was valid UTF-8 up to the {$valid_up_to} bytes
@@ -637,9 +634,6 @@ lint_opaque_hidden_inferred_bound = opaque type `{$ty}` does not satisfy its ass
 
 lint_opaque_hidden_inferred_bound_sugg = add this bound
 
-lint_or_patterns_back_compat = the meaning of the `pat` fragment specifier is changing in Rust 2021, which may affect this macro
-    .suggestion = use pat_param to preserve semantics
-
 lint_out_of_scope_macro_calls = cannot find macro `{$path}` in the current scope when looking from {$location}
     .label = not found from {$location}
     .help = import `macro_rules` with `use` to make it callable above its definition
@@ -783,10 +777,6 @@ lint_symbol_intern_string_literal = using `Symbol::intern` on a string literal
 lint_too_large_char_cast = value exceeds maximum `char` value
     .note = maximum valid `char` value is `0x10FFFF`
 
-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}`
-
 lint_ty_qualified = usage of qualified `ty::{$ty}`
     .suggestion = try importing it and using it unqualified
 
@@ -917,10 +907,6 @@ lint_untranslatable_diag = diagnostics should be created using translatable mess
 lint_unused_allocation = unnecessary allocation, use `&` instead
 lint_unused_allocation_mut = unnecessary allocation, use `&mut` instead
 
-lint_unused_builtin_attribute = unused attribute `{$attr_name}`
-    .note = the built-in attribute `{$attr_name}` will be ignored, since it's applied to the macro invocation `{$macro_name}`
-    .suggestion = remove the attribute
-
 lint_unused_closure =
     unused {$pre}{$count ->
         [one] closure
diff --git a/compiler/rustc_lint/src/early/diagnostics.rs b/compiler/rustc_lint/src/early/diagnostics.rs
index e8daf3e46b870..9029ee0447110 100644
--- a/compiler/rustc_lint/src/early/diagnostics.rs
+++ b/compiler/rustc_lint/src/early/diagnostics.rs
@@ -76,10 +76,6 @@ pub fn decorate_builtin_lint(
             }
             .decorate_lint(diag);
         }
-        BuiltinLintDiag::UnknownCrateTypes { span, candidate } => {
-            let sugg = candidate.map(|candidate| lints::UnknownCrateTypesSub { span, candidate });
-            lints::UnknownCrateTypes { sugg }.decorate_lint(diag);
-        }
         BuiltinLintDiag::UnusedImports {
             remove_whole_use,
             num_to_remove,
@@ -144,9 +140,6 @@ pub fn decorate_builtin_lint(
             }
             .decorate_lint(diag);
         }
-        BuiltinLintDiag::OrPatternsBackCompat(suggestion_span, suggestion) => {
-            lints::OrPatternsBackCompat { span: suggestion_span, suggestion }.decorate_lint(diag);
-        }
         BuiltinLintDiag::ReservedPrefix(label_span, prefix) => {
             lints::ReservedPrefix {
                 label: label_span,
@@ -166,18 +159,6 @@ pub fn decorate_builtin_lint(
                 lints::ReservedMultihash { suggestion }.decorate_lint(diag);
             }
         }
-        BuiltinLintDiag::UnusedBuiltinAttribute {
-            attr_name,
-            macro_name,
-            invoc_span,
-            attr_span,
-        } => {
-            lints::UnusedBuiltinAttribute { invoc_span, attr_name, macro_name, attr_span }
-                .decorate_lint(diag);
-        }
-        BuiltinLintDiag::TrailingMacro(is_trailing, name) => {
-            lints::TrailingMacro { is_trailing, name }.decorate_lint(diag);
-        }
         BuiltinLintDiag::BreakWithLabelAndLoop(sugg_span) => {
             lints::BreakWithLabelAndLoop {
                 sub: lints::BreakWithLabelAndLoopSub {
diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
index 7c375a98f9e9d..b7312484de5cd 100644
--- a/compiler/rustc_lint/src/lints.rs
+++ b/compiler/rustc_lint/src/lints.rs
@@ -2664,21 +2664,6 @@ pub(crate) struct ElidedLifetimesInPaths {
     pub subdiag: ElidedLifetimeInPathSubdiag,
 }
 
-#[derive(LintDiagnostic)]
-#[diag(lint_invalid_crate_type_value)]
-pub(crate) struct UnknownCrateTypes {
-    #[subdiagnostic]
-    pub sugg: Option<UnknownCrateTypesSub>,
-}
-
-#[derive(Subdiagnostic)]
-#[suggestion(lint_suggestion, code = r#""{candidate}""#, applicability = "maybe-incorrect")]
-pub(crate) struct UnknownCrateTypesSub {
-    #[primary_span]
-    pub span: Span,
-    pub candidate: Symbol,
-}
-
 #[derive(LintDiagnostic)]
 #[diag(lint_unused_imports)]
 pub(crate) struct UnusedImports {
@@ -2759,14 +2744,6 @@ pub(crate) struct PatternsInFnsWithoutBodySub {
     pub ident: Ident,
 }
 
-#[derive(LintDiagnostic)]
-#[diag(lint_or_patterns_back_compat)]
-pub(crate) struct OrPatternsBackCompat {
-    #[suggestion(code = "{suggestion}", applicability = "machine-applicable")]
-    pub span: Span,
-    pub suggestion: String,
-}
-
 #[derive(LintDiagnostic)]
 #[diag(lint_reserved_prefix)]
 pub(crate) struct ReservedPrefix {
@@ -2787,27 +2764,6 @@ pub(crate) struct RawPrefix {
     pub suggestion: Span,
 }
 
-#[derive(LintDiagnostic)]
-#[diag(lint_unused_builtin_attribute)]
-pub(crate) struct UnusedBuiltinAttribute {
-    #[note]
-    pub invoc_span: Span,
-    pub attr_name: Symbol,
-    pub macro_name: String,
-    #[suggestion(code = "", applicability = "machine-applicable", style = "tool-only")]
-    pub attr_span: Span,
-}
-
-#[derive(LintDiagnostic)]
-#[diag(lint_trailing_semi_macro)]
-pub(crate) struct TrailingMacro {
-    #[note(lint_note1)]
-    #[note(lint_note2)]
-    pub is_trailing: bool,
-
-    pub name: Ident,
-}
-
 #[derive(LintDiagnostic)]
 #[diag(lint_break_with_label_and_loop)]
 pub(crate) struct BreakWithLabelAndLoop {
diff --git a/compiler/rustc_lint_defs/src/lib.rs b/compiler/rustc_lint_defs/src/lib.rs
index 239b03edfaf00..40a818a3c9dc7 100644
--- a/compiler/rustc_lint_defs/src/lib.rs
+++ b/compiler/rustc_lint_defs/src/lib.rs
@@ -621,10 +621,6 @@ pub enum DeprecatedSinceKind {
 pub enum BuiltinLintDiag {
     AbsPathWithModule(Span),
     ElidedLifetimesInPaths(usize, Span, bool, Span),
-    UnknownCrateTypes {
-        span: Span,
-        candidate: Option<Symbol>,
-    },
     UnusedImports {
         remove_whole_use: bool,
         num_to_remove: usize,
@@ -640,18 +636,11 @@ pub enum BuiltinLintDiag {
         path: String,
         since_kind: DeprecatedSinceKind,
     },
-    UnusedBuiltinAttribute {
-        attr_name: Symbol,
-        macro_name: String,
-        invoc_span: Span,
-        attr_span: Span,
-    },
     PatternsInFnsWithoutBody {
         span: Span,
         ident: Ident,
         is_foreign: bool,
     },
-    OrPatternsBackCompat(Span, String),
     ReservedPrefix(Span, String),
     /// `'r#` in edition < 2021.
     RawPrefix(Span),
@@ -660,7 +649,6 @@ pub enum BuiltinLintDiag {
         is_string: bool,
         suggestion: Span,
     },
-    TrailingMacro(bool, Ident),
     BreakWithLabelAndLoop(Span),
     UnicodeTextFlow(Span, String),
     UnexpectedCfgName((Symbol, Span), Option<(Symbol, Span)>),

From 9f850ceb33b2f55084362dddd2396db8469779bd Mon Sep 17 00:00:00 2001
From: Shoyu Vanilla <modulo641@gmail.com>
Date: Fri, 12 Sep 2025 01:59:39 +0900
Subject: [PATCH 0933/1889] fix: Infinite loop while elaborting predicates

---
 .../crates/hir-ty/src/dyn_compatibility.rs    |  3 ++
 .../hir-ty/src/dyn_compatibility/tests.rs     |  3 +-
 .../crates/hir-ty/src/lower_nextsolver.rs     |  3 ++
 .../crates/hir-ty/src/next_solver/interner.rs | 23 +++++++++++++-
 .../hir-ty/src/tests/regression/new_solver.rs | 31 +++++++++++++++++++
 5 files changed, 61 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
index d4b3751cf5666..b87c998217741 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
@@ -138,6 +138,9 @@ pub fn generics_require_sized_self(db: &dyn HirDatabase, def: GenericDefId) -> b
 
     let interner = DbInterner::new_with(db, Some(krate), None);
     let predicates = db.generic_predicates_ns(def);
+    // FIXME: We should use `explicit_predicates_of` here, which hasn't been implemented to
+    // rust-analyzer yet
+    // https://github.com/rust-lang/rust/blob/ddaf12390d3ffb7d5ba74491a48f3cd528e5d777/compiler/rustc_hir_analysis/src/collect/predicates_of.rs#L490
     elaborate::elaborate(interner, predicates.iter().copied()).any(|pred| {
         match pred.kind().skip_binder() {
             ClauseKind::Trait(trait_pred) => {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility/tests.rs
index 4ffa455084971..04a9ba79921ad 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility/tests.rs
@@ -253,7 +253,8 @@ trait Bar<T> {
 trait Baz : Bar<Self> {
 }
 "#,
-        [("Bar", vec![]), ("Baz", vec![SizedSelf, SelfReferential])],
+        // FIXME: We should also report `SizedSelf` here
+        [("Bar", vec![]), ("Baz", vec![SelfReferential])],
     );
 }
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
index c6a8fa81edff5..5c29befe123cf 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
@@ -1358,6 +1358,9 @@ where
         }
     }
 
+    // FIXME: rustc gathers more predicates by recursing through resulting trait predicates.
+    // See https://github.com/rust-lang/rust/blob/76c5ed2847cdb26ef2822a3a165d710f6b772217/compiler/rustc_hir_analysis/src/collect/predicates_of.rs#L689-L715
+
     (
         GenericPredicates(predicates.is_empty().not().then(|| predicates.into())),
         create_diagnostics(ctx.diagnostics),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
index 0f512fdaf8687..7b6e8a1073d78 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
@@ -5,7 +5,7 @@ use base_db::Crate;
 use chalk_ir::{ProgramClauseImplication, SeparatorTraitRef, Variances};
 use hir_def::lang_item::LangItem;
 use hir_def::signatures::{FieldData, FnFlags, ImplFlags, StructFlags, TraitFlags};
-use hir_def::{AdtId, BlockId, TypeAliasId, VariantId};
+use hir_def::{AdtId, BlockId, GenericDefId, TypeAliasId, VariantId};
 use hir_def::{AttrDefId, Lookup};
 use hir_def::{CallableDefId, EnumVariantId, ItemContainerId, StructId, UnionId};
 use intern::sym::non_exhaustive;
@@ -1334,6 +1334,13 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
             .db()
             .generic_predicates_ns(def_id.0.into())
             .iter()
+            .filter(|p| match p.kind().skip_binder() {
+                rustc_type_ir::ClauseKind::Trait(tr) => match tr.self_ty().kind() {
+                    rustc_type_ir::TyKind::Param(param) => param.index == 0,
+                    _ => false,
+                },
+                _ => true,
+            })
             .cloned()
             .map(|p| (p, Span::dummy()))
             .collect();
@@ -1345,10 +1352,24 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
         self,
         def_id: Self::DefId,
     ) -> EarlyBinder<Self, impl IntoIterator<Item = (Self::Clause, Self::Span)>> {
+        fn is_self_or_assoc(ty: Ty<'_>) -> bool {
+            match ty.kind() {
+                rustc_type_ir::TyKind::Param(param) => param.index == 0,
+                rustc_type_ir::TyKind::Alias(rustc_type_ir::AliasTyKind::Projection, alias) => {
+                    is_self_or_assoc(alias.self_ty())
+                }
+                _ => false,
+            }
+        }
+
         let predicates: Vec<(Clause<'db>, Span)> = self
             .db()
             .generic_predicates_ns(def_id.try_into().unwrap())
             .iter()
+            .filter(|p| match p.kind().skip_binder() {
+                rustc_type_ir::ClauseKind::Trait(tr) => is_self_or_assoc(tr.self_ty()),
+                _ => true,
+            })
             .cloned()
             .map(|p| (p, Span::dummy()))
             .collect();
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
index 4df788638a315..595f285bd930e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
@@ -116,3 +116,34 @@ fn main() {
         "#]],
     );
 }
+
+#[test]
+fn no_infinite_loop_on_super_predicates_elaboration() {
+    check_infer(
+        r#"
+//- minicore: sized
+trait DimMax<Other: Dimension> {
+    type Output: Dimension;
+}
+
+trait Dimension: DimMax<<Self as Dimension>:: Smaller, Output = Self> {
+    type Smaller: Dimension;
+}
+
+fn test<T, U>(t: T)
+where
+    T: DimMax<U>,
+    U: Dimension,
+{
+    let t: <T as DimMax<U>>::Output = loop {};
+}
+"#,
+        expect![[r#"
+            182..183 't': T
+            230..280 '{     ... {}; }': ()
+            240..241 't': <T as DimMax<U>>::Output
+            270..277 'loop {}': !
+            275..277 '{}': ()
+        "#]],
+    )
+}

From df04be8cf744b500b5972fdc76898a96067d5517 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Sun, 14 Sep 2025 13:18:19 +0000
Subject: [PATCH 0934/1889] Comment.

---
 compiler/rustc_mir_transform/src/gvn.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index f8b3e5c6f8794..fc0a03b1aab52 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -154,19 +154,25 @@ impl<'tcx> crate::MirPass<'tcx> for GVN {
 }
 
 newtype_index! {
+    /// This represents a `Value` in the symbolic execution.
     #[debug_format = "_v{}"]
     struct VnIndex {}
 }
 
+/// Marker type to forbid hashing and comparing opaque values.
+/// This struct should only be constructed by `ValueSet::insert_unique` to ensure we use that
+/// method to create non-unifiable values. It will ICE if used in `ValueSet::insert`.
 #[derive(Copy, Clone, Debug, Eq)]
 struct VnOpaque;
 impl PartialEq for VnOpaque {
     fn eq(&self, _: &VnOpaque) -> bool {
+        // ICE if we try to compare unique values
         unreachable!()
     }
 }
 impl Hash for VnOpaque {
     fn hash<T: Hasher>(&self, _: &mut T) {
+        // ICE if we try to hash unique values
         unreachable!()
     }
 }
@@ -191,6 +197,8 @@ enum Value<'tcx> {
         // `disambiguator` is `None` iff the constant is deterministic.
         disambiguator: Option<VnOpaque>,
     },
+
+    // Aggregates.
     /// An aggregate value, either tuple/closure/struct/enum.
     /// This does not contain unions, as we cannot reason with the value.
     Aggregate(VariantIdx, Vec<VnIndex>),
@@ -252,6 +260,7 @@ impl<'tcx> ValueSet<'tcx> {
     }
 
     /// Insert a `(Value, Ty)` pair without hashing or deduplication.
+    /// This always creates a new `VnIndex`.
     #[inline]
     fn insert_unique(
         &mut self,

From 8811344f22e0c015aaa45367b6462e3ecdcb22b5 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Sun, 14 Sep 2025 13:04:53 +0000
Subject: [PATCH 0935/1889] Elaborate comment.

---
 compiler/rustc_mir_transform/src/dest_prop.rs | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/dest_prop.rs b/compiler/rustc_mir_transform/src/dest_prop.rs
index 7e6f39881b8b8..b9ab0a9feee65 100644
--- a/compiler/rustc_mir_transform/src/dest_prop.rs
+++ b/compiler/rustc_mir_transform/src/dest_prop.rs
@@ -590,8 +590,12 @@ fn save_as_intervals<'tcx>(
             twostep = TwoStepIndex::from_u32(twostep.as_u32() + 1);
             debug_assert_eq!(twostep, two_step_loc(loc, Effect::After));
             append_at(&mut values, &state, twostep);
-            // Ensure we have a non-zero live range even for dead stores. This is done by marking
-            // all the written-to locals as live in the second half of the statement.
+            // Like terminators, ensure we have a non-zero live range even for dead stores.
+            // Some rvalues interleave reads and writes, for instance `Rvalue::Aggregate`, see
+            // https://github.com/rust-lang/rust/issues/146383. By precaution, treat statements
+            // as behaving so by default.
+            // We make an exception for simple assignments `_a.stuff = {copy|move} _b.stuff`,
+            // as marking `_b` live here would prevent unification.
             let is_simple_assignment =
                 matches!(stmt.kind, StatementKind::Assign(box (_, Rvalue::Use(_))));
             VisitPlacesWith(|place: Place<'tcx>, ctxt| {

From f981739fcfdbe3e69d5fd630c4390a33ffc41035 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Thu, 4 Sep 2025 22:55:50 +0200
Subject: [PATCH 0936/1889] refactor `ptr_offset_with_cast`

---
 clippy_lints/src/declared_lints.rs            |   2 +-
 clippy_lints/src/lib.rs                       |   2 -
 clippy_lints/src/methods/mod.rs               |  49 +++++-
 .../src/methods/ptr_offset_with_cast.rs       |  82 ++++++++++
 clippy_lints/src/ptr_offset_with_cast.rs      | 151 ------------------
 clippy_utils/src/msrvs.rs                     |   2 +-
 tests/ui/ptr_offset_with_cast.fixed           |  22 ++-
 tests/ui/ptr_offset_with_cast.rs              |  22 ++-
 tests/ui/ptr_offset_with_cast.stderr          |  41 ++++-
 9 files changed, 209 insertions(+), 164 deletions(-)
 create mode 100644 clippy_lints/src/methods/ptr_offset_with_cast.rs
 delete mode 100644 clippy_lints/src/ptr_offset_with_cast.rs

diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index d0c7443a4a4b9..8d576c2263f05 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -448,6 +448,7 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::methods::OR_THEN_UNWRAP_INFO,
     crate::methods::PATH_BUF_PUSH_OVERWRITE_INFO,
     crate::methods::PATH_ENDS_WITH_EXT_INFO,
+    crate::methods::PTR_OFFSET_WITH_CAST_INFO,
     crate::methods::RANGE_ZIP_WITH_LEN_INFO,
     crate::methods::READONLY_WRITE_LOCK_INFO,
     crate::methods::READ_LINE_WITHOUT_TRIM_INFO,
@@ -625,7 +626,6 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::ptr::MUT_FROM_REF_INFO,
     crate::ptr::PTR_ARG_INFO,
     crate::ptr::PTR_EQ_INFO,
-    crate::ptr_offset_with_cast::PTR_OFFSET_WITH_CAST_INFO,
     crate::pub_underscore_fields::PUB_UNDERSCORE_FIELDS_INFO,
     crate::pub_use::PUB_USE_INFO,
     crate::question_mark::QUESTION_MARK_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 0d7931aae765c..d152082851795 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -302,7 +302,6 @@ mod permissions_set_readonly_false;
 mod pointers_in_nomem_asm_block;
 mod precedence;
 mod ptr;
-mod ptr_offset_with_cast;
 mod pub_underscore_fields;
 mod pub_use;
 mod question_mark;
@@ -592,7 +591,6 @@ pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Co
     store.register_late_pass(|_| Box::new(unwrap::Unwrap));
     store.register_late_pass(move |_| Box::new(indexing_slicing::IndexingSlicing::new(conf)));
     store.register_late_pass(move |tcx| Box::new(non_copy_const::NonCopyConst::new(tcx, conf)));
-    store.register_late_pass(|_| Box::new(ptr_offset_with_cast::PtrOffsetWithCast));
     store.register_late_pass(|_| Box::new(redundant_clone::RedundantClone));
     store.register_late_pass(|_| Box::new(slow_vector_initialization::SlowVectorInit));
     store.register_late_pass(move |_| Box::new(unnecessary_wraps::UnnecessaryWraps::new(conf)));
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 49ca81dafc280..d06b0ed64bdc2 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -91,6 +91,7 @@ mod or_fun_call;
 mod or_then_unwrap;
 mod path_buf_push_overwrite;
 mod path_ends_with_ext;
+mod ptr_offset_with_cast;
 mod range_zip_with_len;
 mod read_line_without_trim;
 mod readonly_write_lock;
@@ -1725,6 +1726,43 @@ declare_clippy_lint! {
     "Check for offset calculations on raw pointers to zero-sized types"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of the `offset` pointer method with a `usize` casted to an
+    /// `isize`.
+    ///
+    /// ### Why is this bad?
+    /// If we’re always increasing the pointer address, we can avoid the numeric
+    /// cast by using the `add` method instead.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let vec = vec![b'a', b'b', b'c'];
+    /// let ptr = vec.as_ptr();
+    /// let offset = 1_usize;
+    ///
+    /// unsafe {
+    ///     ptr.offset(offset as isize);
+    /// }
+    /// ```
+    ///
+    /// Could be written:
+    ///
+    /// ```no_run
+    /// let vec = vec![b'a', b'b', b'c'];
+    /// let ptr = vec.as_ptr();
+    /// let offset = 1_usize;
+    ///
+    /// unsafe {
+    ///     ptr.add(offset);
+    /// }
+    /// ```
+    #[clippy::version = "1.30.0"]
+    pub PTR_OFFSET_WITH_CAST,
+    complexity,
+    "unneeded pointer offset cast"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for `FileType::is_file()`.
@@ -4665,6 +4703,7 @@ impl_lint_pass!(Methods => [
     UNINIT_ASSUMED_INIT,
     MANUAL_SATURATING_ARITHMETIC,
     ZST_OFFSET,
+    PTR_OFFSET_WITH_CAST,
     FILETYPE_IS_FILE,
     OPTION_AS_REF_DEREF,
     UNNECESSARY_LAZY_EVALUATIONS,
@@ -4960,10 +4999,7 @@ impl Methods {
         // Handle method calls whose receiver and arguments may not come from expansion
         if let Some((name, recv, args, span, call_span)) = method_call(expr) {
             match (name, args) {
-                (
-                    sym::add | sym::offset | sym::sub | sym::wrapping_offset | sym::wrapping_add | sym::wrapping_sub,
-                    [_arg],
-                ) => {
+                (sym::add | sym::sub | sym::wrapping_add | sym::wrapping_sub, [_arg]) => {
                     zst_offset::check(cx, expr, recv);
                 },
                 (sym::all, [arg]) => {
@@ -5334,6 +5370,11 @@ impl Methods {
                     },
                     _ => iter_nth_zero::check(cx, expr, recv, n_arg),
                 },
+                (sym::offset | sym::wrapping_offset, [arg]) => {
+                    zst_offset::check(cx, expr, recv);
+
+                    ptr_offset_with_cast::check(cx, name, expr, recv, arg, self.msrv);
+                },
                 (sym::ok_or_else, [arg]) => {
                     unnecessary_lazy_eval::check(cx, expr, recv, arg, "ok_or");
                 },
diff --git a/clippy_lints/src/methods/ptr_offset_with_cast.rs b/clippy_lints/src/methods/ptr_offset_with_cast.rs
new file mode 100644
index 0000000000000..d19d3b8eb89d9
--- /dev/null
+++ b/clippy_lints/src/methods/ptr_offset_with_cast.rs
@@ -0,0 +1,82 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::sym;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_span::Symbol;
+use std::fmt;
+
+use super::PTR_OFFSET_WITH_CAST;
+
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    method: Symbol,
+    expr: &Expr<'_>,
+    recv: &Expr<'_>,
+    arg: &Expr<'_>,
+    msrv: Msrv,
+) {
+    // `pointer::add` and `pointer::wrapping_add` are only stable since 1.26.0. These functions
+    // became const-stable in 1.61.0, the same version that `pointer::offset` became const-stable.
+    if !msrv.meets(cx, msrvs::POINTER_ADD_SUB_METHODS) {
+        return;
+    }
+
+    let method = match method {
+        sym::offset => Method::Offset,
+        sym::wrapping_offset => Method::WrappingOffset,
+        _ => return,
+    };
+
+    if !cx.typeck_results().expr_ty_adjusted(recv).is_raw_ptr() {
+        return;
+    }
+
+    // Check if the argument to the method call is a cast from usize.
+    let cast_lhs_expr = match arg.kind {
+        ExprKind::Cast(lhs, _) if cx.typeck_results().expr_ty(lhs).is_usize() => lhs,
+        _ => return,
+    };
+
+    let ExprKind::MethodCall(method_name, _, _, _) = expr.kind else {
+        return;
+    };
+
+    let msg = format!("use of `{method}` with a `usize` casted to an `isize`");
+    span_lint_and_then(cx, PTR_OFFSET_WITH_CAST, expr.span, msg, |diag| {
+        diag.multipart_suggestion(
+            format!("use `{}` instead", method.suggestion()),
+            vec![
+                (method_name.ident.span, method.suggestion().to_string()),
+                (arg.span.with_lo(cast_lhs_expr.span.hi()), String::new()),
+            ],
+            Applicability::MachineApplicable,
+        );
+    });
+}
+
+#[derive(Copy, Clone)]
+enum Method {
+    Offset,
+    WrappingOffset,
+}
+
+impl Method {
+    #[must_use]
+    fn suggestion(self) -> &'static str {
+        match self {
+            Self::Offset => "add",
+            Self::WrappingOffset => "wrapping_add",
+        }
+    }
+}
+
+impl fmt::Display for Method {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Offset => write!(f, "offset"),
+            Self::WrappingOffset => write!(f, "wrapping_offset"),
+        }
+    }
+}
diff --git a/clippy_lints/src/ptr_offset_with_cast.rs b/clippy_lints/src/ptr_offset_with_cast.rs
deleted file mode 100644
index d8d813f9846d5..0000000000000
--- a/clippy_lints/src/ptr_offset_with_cast.rs
+++ /dev/null
@@ -1,151 +0,0 @@
-use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
-use clippy_utils::source::SpanRangeExt;
-use clippy_utils::sym;
-use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::declare_lint_pass;
-use std::fmt;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of the `offset` pointer method with a `usize` casted to an
-    /// `isize`.
-    ///
-    /// ### Why is this bad?
-    /// If we’re always increasing the pointer address, we can avoid the numeric
-    /// cast by using the `add` method instead.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let vec = vec![b'a', b'b', b'c'];
-    /// let ptr = vec.as_ptr();
-    /// let offset = 1_usize;
-    ///
-    /// unsafe {
-    ///     ptr.offset(offset as isize);
-    /// }
-    /// ```
-    ///
-    /// Could be written:
-    ///
-    /// ```no_run
-    /// let vec = vec![b'a', b'b', b'c'];
-    /// let ptr = vec.as_ptr();
-    /// let offset = 1_usize;
-    ///
-    /// unsafe {
-    ///     ptr.add(offset);
-    /// }
-    /// ```
-    #[clippy::version = "1.30.0"]
-    pub PTR_OFFSET_WITH_CAST,
-    complexity,
-    "unneeded pointer offset cast"
-}
-
-declare_lint_pass!(PtrOffsetWithCast => [PTR_OFFSET_WITH_CAST]);
-
-impl<'tcx> LateLintPass<'tcx> for PtrOffsetWithCast {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        // Check if the expressions is a ptr.offset or ptr.wrapping_offset method call
-        let Some((receiver_expr, arg_expr, method)) = expr_as_ptr_offset_call(cx, expr) else {
-            return;
-        };
-
-        // Check if the argument to the method call is a cast from usize
-        let Some(cast_lhs_expr) = expr_as_cast_from_usize(cx, arg_expr) else {
-            return;
-        };
-
-        let msg = format!("use of `{method}` with a `usize` casted to an `isize`");
-        if let Some(sugg) = build_suggestion(cx, method, receiver_expr, cast_lhs_expr) {
-            span_lint_and_sugg(
-                cx,
-                PTR_OFFSET_WITH_CAST,
-                expr.span,
-                msg,
-                "try",
-                sugg,
-                Applicability::MachineApplicable,
-            );
-        } else {
-            span_lint(cx, PTR_OFFSET_WITH_CAST, expr.span, msg);
-        }
-    }
-}
-
-// If the given expression is a cast from a usize, return the lhs of the cast
-fn expr_as_cast_from_usize<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
-    if let ExprKind::Cast(cast_lhs_expr, _) = expr.kind
-        && is_expr_ty_usize(cx, cast_lhs_expr)
-    {
-        return Some(cast_lhs_expr);
-    }
-    None
-}
-
-// If the given expression is a ptr::offset  or ptr::wrapping_offset method call, return the
-// receiver, the arg of the method call, and the method.
-fn expr_as_ptr_offset_call<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx Expr<'_>,
-) -> Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>, Method)> {
-    if let ExprKind::MethodCall(path_segment, arg_0, [arg_1], _) = &expr.kind
-        && is_expr_ty_raw_ptr(cx, arg_0)
-    {
-        if path_segment.ident.name == sym::offset {
-            return Some((arg_0, arg_1, Method::Offset));
-        }
-        if path_segment.ident.name == sym::wrapping_offset {
-            return Some((arg_0, arg_1, Method::WrappingOffset));
-        }
-    }
-    None
-}
-
-// Is the type of the expression a usize?
-fn is_expr_ty_usize(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    cx.typeck_results().expr_ty(expr) == cx.tcx.types.usize
-}
-
-// Is the type of the expression a raw pointer?
-fn is_expr_ty_raw_ptr(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    cx.typeck_results().expr_ty(expr).is_raw_ptr()
-}
-
-fn build_suggestion(
-    cx: &LateContext<'_>,
-    method: Method,
-    receiver_expr: &Expr<'_>,
-    cast_lhs_expr: &Expr<'_>,
-) -> Option<String> {
-    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()))
-}
-
-#[derive(Copy, Clone)]
-enum Method {
-    Offset,
-    WrappingOffset,
-}
-
-impl Method {
-    #[must_use]
-    fn suggestion(self) -> &'static str {
-        match self {
-            Self::Offset => "add",
-            Self::WrappingOffset => "wrapping_add",
-        }
-    }
-}
-
-impl fmt::Display for Method {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Offset => write!(f, "offset"),
-            Self::WrappingOffset => write!(f, "wrapping_offset"),
-        }
-    }
-}
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 896d607fbcdd9..21dff28d5650f 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -73,7 +73,7 @@ msrv_aliases! {
     1,29,0 { ITER_FLATTEN }
     1,28,0 { FROM_BOOL, REPEAT_WITH, SLICE_FROM_REF }
     1,27,0 { ITERATOR_TRY_FOLD }
-    1,26,0 { RANGE_INCLUSIVE, STRING_RETAIN }
+    1,26,0 { RANGE_INCLUSIVE, STRING_RETAIN, POINTER_ADD_SUB_METHODS }
     1,24,0 { IS_ASCII_DIGIT, PTR_NULL }
     1,18,0 { HASH_MAP_RETAIN, HASH_SET_RETAIN }
     1,17,0 { FIELD_INIT_SHORTHAND, STATIC_IN_CONST, EXPECT_ERR }
diff --git a/tests/ui/ptr_offset_with_cast.fixed b/tests/ui/ptr_offset_with_cast.fixed
index 4fe9dcf46c357..42d1abeaa05a6 100644
--- a/tests/ui/ptr_offset_with_cast.fixed
+++ b/tests/ui/ptr_offset_with_cast.fixed
@@ -1,4 +1,4 @@
-#![allow(clippy::unnecessary_cast, clippy::useless_vec)]
+#![expect(clippy::unnecessary_cast, clippy::useless_vec, clippy::needless_borrow)]
 
 fn main() {
     let vec = vec![b'a', b'b', b'c'];
@@ -18,5 +18,25 @@ fn main() {
         //~^ ptr_offset_with_cast
         let _ = ptr.wrapping_offset(offset_isize as isize);
         let _ = ptr.wrapping_offset(offset_u8 as isize);
+
+        let _ = S.offset(offset_usize as isize);
+        let _ = S.wrapping_offset(offset_usize as isize);
+
+        let _ = (&ptr).add(offset_usize);
+        //~^ ptr_offset_with_cast
+        let _ = (&ptr).wrapping_add(offset_usize);
+        //~^ ptr_offset_with_cast
+    }
+}
+
+#[derive(Clone, Copy)]
+struct S;
+
+impl S {
+    fn offset(self, _: isize) -> Self {
+        self
+    }
+    fn wrapping_offset(self, _: isize) -> Self {
+        self
     }
 }
diff --git a/tests/ui/ptr_offset_with_cast.rs b/tests/ui/ptr_offset_with_cast.rs
index a1fb892733d35..6d06a6af1fa2d 100644
--- a/tests/ui/ptr_offset_with_cast.rs
+++ b/tests/ui/ptr_offset_with_cast.rs
@@ -1,4 +1,4 @@
-#![allow(clippy::unnecessary_cast, clippy::useless_vec)]
+#![expect(clippy::unnecessary_cast, clippy::useless_vec, clippy::needless_borrow)]
 
 fn main() {
     let vec = vec![b'a', b'b', b'c'];
@@ -18,5 +18,25 @@ fn main() {
         //~^ ptr_offset_with_cast
         let _ = ptr.wrapping_offset(offset_isize as isize);
         let _ = ptr.wrapping_offset(offset_u8 as isize);
+
+        let _ = S.offset(offset_usize as isize);
+        let _ = S.wrapping_offset(offset_usize as isize);
+
+        let _ = (&ptr).offset(offset_usize as isize);
+        //~^ ptr_offset_with_cast
+        let _ = (&ptr).wrapping_offset(offset_usize as isize);
+        //~^ ptr_offset_with_cast
+    }
+}
+
+#[derive(Clone, Copy)]
+struct S;
+
+impl S {
+    fn offset(self, _: isize) -> Self {
+        self
+    }
+    fn wrapping_offset(self, _: isize) -> Self {
+        self
     }
 }
diff --git a/tests/ui/ptr_offset_with_cast.stderr b/tests/ui/ptr_offset_with_cast.stderr
index dcd5e027d1829..022b3286c93b7 100644
--- a/tests/ui/ptr_offset_with_cast.stderr
+++ b/tests/ui/ptr_offset_with_cast.stderr
@@ -2,16 +2,51 @@ error: use of `offset` with a `usize` casted to an `isize`
   --> tests/ui/ptr_offset_with_cast.rs:12:17
    |
 LL |         let _ = ptr.offset(offset_usize as isize);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `ptr.add(offset_usize)`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::ptr-offset-with-cast` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::ptr_offset_with_cast)]`
+help: use `add` instead
+   |
+LL -         let _ = ptr.offset(offset_usize as isize);
+LL +         let _ = ptr.add(offset_usize);
+   |
 
 error: use of `wrapping_offset` with a `usize` casted to an `isize`
   --> tests/ui/ptr_offset_with_cast.rs:17:17
    |
 LL |         let _ = ptr.wrapping_offset(offset_usize as isize);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `ptr.wrapping_add(offset_usize)`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `wrapping_add` instead
+   |
+LL -         let _ = ptr.wrapping_offset(offset_usize as isize);
+LL +         let _ = ptr.wrapping_add(offset_usize);
+   |
+
+error: use of `offset` with a `usize` casted to an `isize`
+  --> tests/ui/ptr_offset_with_cast.rs:25:17
+   |
+LL |         let _ = (&ptr).offset(offset_usize as isize);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `add` instead
+   |
+LL -         let _ = (&ptr).offset(offset_usize as isize);
+LL +         let _ = (&ptr).add(offset_usize);
+   |
+
+error: use of `wrapping_offset` with a `usize` casted to an `isize`
+  --> tests/ui/ptr_offset_with_cast.rs:27:17
+   |
+LL |         let _ = (&ptr).wrapping_offset(offset_usize as isize);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `wrapping_add` instead
+   |
+LL -         let _ = (&ptr).wrapping_offset(offset_usize as isize);
+LL +         let _ = (&ptr).wrapping_add(offset_usize);
+   |
 
-error: aborting due to 2 previous errors
+error: aborting due to 4 previous errors
 

From ce859d7713dbca1b2a3dff17ccc4d4a0598bffbf Mon Sep 17 00:00:00 2001
From: Sidney Cammeresi <sac@cheesecake.org>
Date: Sun, 14 Sep 2025 08:06:11 -0700
Subject: [PATCH 0937/1889] Switch `std::vec::PeekMut::pop` from self to this
 parameter.

Since PeekMut implements Deref, it shouldn't have any methods of its
own.

See also: `std::collections::binary_heap::PeekMut::pop`
---
 .mailmap                          | 1 +
 library/alloc/src/vec/peek_mut.rs | 4 ++--
 library/alloctests/tests/vec.rs   | 4 ++--
 3 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/.mailmap b/.mailmap
index 6e3eed1226e0c..0f7bc5e38bd10 100644
--- a/.mailmap
+++ b/.mailmap
@@ -609,6 +609,7 @@ Shohei Wada <pc@wada314.jp>
 Shotaro Yamada <sinkuu@sinkuu.xyz>
 Shotaro Yamada <sinkuu@sinkuu.xyz> <sinkuu@users.noreply.github.com>
 Shyam Sundar B <shyambaskaran@outlook.com>
+Sidney Cammeresi <sac@cheesecake.org> <sac@readyset.io>
 Simon Barber-Dueck <sbarberdueck@gmail.com> Simon BD <simon@server>
 Simon Sapin <simon@exyr.org> <simon.sapin@exyr.org>
 Simonas Kazlauskas <git@kazlauskas.me> Simonas Kazlauskas <github@kazlauskas.me>
diff --git a/library/alloc/src/vec/peek_mut.rs b/library/alloc/src/vec/peek_mut.rs
index c0dd941ed3933..caeaf2799d733 100644
--- a/library/alloc/src/vec/peek_mut.rs
+++ b/library/alloc/src/vec/peek_mut.rs
@@ -29,9 +29,9 @@ impl<'a, T> PeekMut<'a, T> {
 
     /// Removes the peeked value from the vector and returns it.
     #[unstable(feature = "vec_peek_mut", issue = "122742")]
-    pub fn pop(self) -> T {
+    pub fn pop(this: Self) -> T {
         // SAFETY: PeekMut is only constructed if the vec is non-empty
-        unsafe { self.vec.pop().unwrap_unchecked() }
+        unsafe { this.vec.pop().unwrap_unchecked() }
     }
 }
 
diff --git a/library/alloctests/tests/vec.rs b/library/alloctests/tests/vec.rs
index 00f640cd17ea4..404eb49e1ea9c 100644
--- a/library/alloctests/tests/vec.rs
+++ b/library/alloctests/tests/vec.rs
@@ -15,7 +15,7 @@ use std::ops::Bound::*;
 use std::panic::{AssertUnwindSafe, catch_unwind};
 use std::rc::Rc;
 use std::sync::atomic::{AtomicU32, Ordering};
-use std::vec::{Drain, IntoIter};
+use std::vec::{Drain, IntoIter, PeekMut};
 
 use crate::testing::macros::struct_with_counted_drop;
 
@@ -2647,7 +2647,7 @@ fn test_peek_mut() {
         assert_eq!(*p, 2);
         *p = 0;
         assert_eq!(*p, 0);
-        p.pop();
+        PeekMut::pop(p);
         assert_eq!(vec.len(), 1);
     } else {
         unreachable!()

From 8af66386660b17ec85a34705f8a475fd0874ac70 Mon Sep 17 00:00:00 2001
From: Alexey Semenyuk <alexsemenyuk88@gmail.com>
Date: Sat, 13 Sep 2025 14:01:24 +0500
Subject: [PATCH 0938/1889] Changelog for Clippy 1.90

---
 CHANGELOG.md | 147 ++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 146 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index eb2a76a818369..4a9be02143722 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,7 +6,152 @@ document.
 
 ## Unreleased / Beta / In Rust Nightly
 
-[4ef75291...master](https://github.com/rust-lang/rust-clippy/compare/4ef75291...master)
+[e9b7045...master](https://github.com/rust-lang/rust-clippy/compare/e9b7045...master)
+
+## Rust 1.90
+
+Current stable, released 2025-09-18
+
+[View all 118 merged pull requests](https://github.com/rust-lang/rust-clippy/pulls?q=merged%3A2025-06-13T15%3A55%3A04Z..2025-07-25T13%3A24%3A00Z+base%3Amaster)
+
+Note: This Clippy release does not introduce many new lints and is focused entirely on bug fixes — see
+[#15086](https://github.com/rust-lang/rust-clippy/issues/15086) for more details.
+
+## New Lints
+
+* Added [`manual_is_multiple_of`] to `complexity` [#14292](https://github.com/rust-lang/rust-clippy/pull/14292)
+* Added [`doc_broken_link`] to `pedantic` [#13696](https://github.com/rust-lang/rust-clippy/pull/13696)
+
+### Moves and Deprecations
+
+* Move [`uninlined_format_args`] to `pedantic` (from `style`, now allow-by-default) [#15287](https://github.com/rust-lang/rust-clippy/pull/15287)
+
+### Enhancements
+
+* [`or_fun_call`] now lints `Option::get_or_insert`, `Result::map_or`, `Option/Result::and` methods 
+  [#15071](https://github.com/rust-lang/rust-clippy/pull/15071) 
+  [#15073](https://github.com/rust-lang/rust-clippy/pull/15073) 
+  [#15074](https://github.com/rust-lang/rust-clippy/pull/15074)
+* [`incompatible_msrv`] now recognizes types exceeding MSRV 
+  [#15296](https://github.com/rust-lang/rust-clippy/pull/15296)
+* [`incompatible_msrv`] now checks the right MSRV when in a `const` context 
+  [#15297](https://github.com/rust-lang/rust-clippy/pull/15297)
+* [`zero_ptr`] now lints in `const` context as well 
+  [#15152](https://github.com/rust-lang/rust-clippy/pull/15152)
+* [`map_identity`],[`flat_map_identity`] now recognizes `|[x, y]| [x, y]` as an identity function
+  [#15229](https://github.com/rust-lang/rust-clippy/pull/15229)
+* [`exit`] no longer fails on the main function when using `--test` or `--all-targets` flag 
+  [#15222](https://github.com/rust-lang/rust-clippy/pull/15222)
+
+### False Positive Fixes
+
+* [`if_then_some_else_none`] fixed FP when require type coercion
+  [#15267](https://github.com/rust-lang/rust-clippy/pull/15267)
+* [`module_name_repetitions`] fixed FP on exported macros
+  [#15319](https://github.com/rust-lang/rust-clippy/pull/15319)
+* [`unused_async`] fixed FP on function with `todo!`
+  [#15308](https://github.com/rust-lang/rust-clippy/pull/15308)
+* [`useless_attribute`] fixed FP when using `#[expect(redundant_imports)]` and similar lint attributes 
+  on `use` statements
+  [#15318](https://github.com/rust-lang/rust-clippy/pull/15318)
+* [`pattern_type_mismatch`] fixed FP in external macro
+  [#15306](https://github.com/rust-lang/rust-clippy/pull/15306)
+* [`large_enum_variant`] fixed FP by not suggesting `Box` in `no_std` mode
+  [#15241](https://github.com/rust-lang/rust-clippy/pull/15241)
+* [`missing_inline_in_public_items`] fixed FP on functions with `extern`
+  [#15313](https://github.com/rust-lang/rust-clippy/pull/15313)
+* [`needless_range_loop`] fixed FP on array literals
+  [#15314](https://github.com/rust-lang/rust-clippy/pull/15314)
+* [`ptr_as_ptr`] fixed wrong suggestions with turbo fish
+  [#15289](https://github.com/rust-lang/rust-clippy/pull/15289)
+* [`range_plus_one`], [`range_minus_one`] fixed FP by restricting lint to cases where it is safe 
+  to switch the range type
+  [#14432](https://github.com/rust-lang/rust-clippy/pull/14432)
+* [`ptr_arg`] fixed FP with underscore binding to `&T` or `&mut T` argument
+  [#15105](https://github.com/rust-lang/rust-clippy/pull/15105)
+* [`unsafe_derive_deserialize`] fixed FP caused by the standard library's `pin!()` macro
+  [#15137](https://github.com/rust-lang/rust-clippy/pull/15137)
+* [`unused_trait_names`] fixed FP in macros
+  [#14947](https://github.com/rust-lang/rust-clippy/pull/14947)
+* [`expect_fun_call`] fixed invalid suggestions
+  [#15122](https://github.com/rust-lang/rust-clippy/pull/15122)
+* [`manual_is_multiple_of`] fixed various false positives
+  [#15205](https://github.com/rust-lang/rust-clippy/pull/15205)
+* [`manual_assert`] fixed wrong suggestions for macros
+  [#15264](https://github.com/rust-lang/rust-clippy/pull/15264)
+* [`expect_used`] fixed false negative when meeting `Option::ok().expect`
+  [#15253](https://github.com/rust-lang/rust-clippy/pull/15253)
+* [`manual_abs_diff`] fixed wrong suggestions behind refs
+  [#15265](https://github.com/rust-lang/rust-clippy/pull/15265)
+* [`approx_constant`] fixed FP with overly precise literals and non trivially formatted numerals
+  [#15236](https://github.com/rust-lang/rust-clippy/pull/15236)
+* [`arithmetic_side_effects`] fixed FP on `NonZeroU*.get() - 1`
+  [#15238](https://github.com/rust-lang/rust-clippy/pull/15238)
+* [`legacy_numeric_constants`] fixed suggestion when call is inside parentheses
+  [#15191](https://github.com/rust-lang/rust-clippy/pull/15191)
+* [`manual_is_variant_and`] fixed inverted suggestions that could lead to code with different semantics
+  [#15206](https://github.com/rust-lang/rust-clippy/pull/15206)
+* [`unnecessary_map_or`] fixed FP by not proposing to replace `map_or` call when types wouldn't be correct
+  [#15181](https://github.com/rust-lang/rust-clippy/pull/15181)
+* [`return_and_then`] fixed FP in case of a partially used expression
+  [#15115](https://github.com/rust-lang/rust-clippy/pull/15115)
+* [`manual_let_else`] fixed FP with binding subpattern with unused name
+  [#15118](https://github.com/rust-lang/rust-clippy/pull/15118)
+* [`suboptimal_flops`] fixed FP with ambiguous float types in mul_add suggestions
+  [#15133](https://github.com/rust-lang/rust-clippy/pull/15133)
+* [`borrow_as_ptr`] fixed FP by not removing cast to trait object pointer
+  [#15145](https://github.com/rust-lang/rust-clippy/pull/15145)
+* [`unnecessary_operation`] fixed FP by not removing casts if they are useful to type the expression
+  [#15182](https://github.com/rust-lang/rust-clippy/pull/15182)
+* [`empty_loop`] fixed FP on intrinsic function declaration
+  [#15201](https://github.com/rust-lang/rust-clippy/pull/15201)
+* [`doc_nested_refdefs`] fixed FP where task lists are reported as refdefs
+  [#15146](https://github.com/rust-lang/rust-clippy/pull/15146)
+* [`std_instead_of_core`] fixed FP when not all items come from the new crate
+  [#15165](https://github.com/rust-lang/rust-clippy/pull/15165)
+* [`swap_with_temporary`] fixed FP leading to different semantics being suggested
+  [#15172](https://github.com/rust-lang/rust-clippy/pull/15172)
+* [`cast_possible_truncation`] fixed FP by not giving suggestions inside const context
+  [#15164](https://github.com/rust-lang/rust-clippy/pull/15164)
+* [`missing_panics_doc`] fixed FP by allowing unwrap() and expect()s in const-only contexts
+  [#15170](https://github.com/rust-lang/rust-clippy/pull/15170)
+* [`disallowed_script_idents`] fixed FP on identifiers with `_`
+  [#15123](https://github.com/rust-lang/rust-clippy/pull/15123)
+* [`wildcard_enum_match_arm`] fixed wrong suggestions with raw identifiers
+  [#15093](https://github.com/rust-lang/rust-clippy/pull/15093)
+* [`borrow_deref_ref`] fixed FP by not proposing replacing a reborrow when the reborrow is itself mutably borrowed
+  [#14967](https://github.com/rust-lang/rust-clippy/pull/14967)
+* [`manual_ok_err`] fixed wrong suggestions with references
+  [#15053](https://github.com/rust-lang/rust-clippy/pull/15053)
+* [`identity_op`] fixed FP when encountering `Default::default()`
+  [#15028](https://github.com/rust-lang/rust-clippy/pull/15028)
+* [`exhaustive_structs`] fixed FP on structs with default valued field
+  [#15022](https://github.com/rust-lang/rust-clippy/pull/15022)
+* [`collapsible_else_if`] fixed FP on conditionally compiled stmt
+  [#14906](https://github.com/rust-lang/rust-clippy/pull/14906)
+* [`missing_const_for_fn`] fixed FP by checking MSRV before emitting lint on function containing 
+  non-`Sized` trait bounds
+  [#15080](https://github.com/rust-lang/rust-clippy/pull/15080)
+* [`question_mark`] fixed FP when else branch of let-else contains `#[cfg]`
+  [#15082](https://github.com/rust-lang/rust-clippy/pull/15082)
+
+### ICE Fixes
+
+* [`single_match`] fixed ICE with deref patterns and string literals 
+  [#15124](https://github.com/rust-lang/rust-clippy/pull/15124)
+* [`needless_doctest_main`] fixed panic when doctest is invalid
+  [#15052](https://github.com/rust-lang/rust-clippy/pull/15052)
+* [`zero_sized_map_values`] do not attempt to compute size of a type with escaping lifetimes
+  [#15434](https://github.com/rust-lang/rust-clippy/pull/15434)
+
+### Documentation Improvements
+
+* [`manual_is_variant_and`] improved documentation to include equality comparison patterns 
+  [#15239](https://github.com/rust-lang/rust-clippy/pull/15239)
+* [`uninlined_format_args`] improved documentation with example of how to fix a `{:?}` parameter
+  [#15228](https://github.com/rust-lang/rust-clippy/pull/15228)
+* [`undocumented_unsafe_blocks`] improved documentation wording 
+  [#15213](https://github.com/rust-lang/rust-clippy/pull/15213)
 
 ## Rust 1.89
 

From 572b42346482472736723fe433b417fe32a01800 Mon Sep 17 00:00:00 2001
From: Alan Somers <asomers@gmail.com>
Date: Sun, 14 Sep 2025 11:33:11 -0600
Subject: [PATCH 0939/1889] On FreeBSD, use readdir instead of readdir_r

readdir_r has the same problems on FreeBSD as it does on other
platforms: it assumes a fixed NAME_MAX.  And readdir has the same
thread-safety guarantee as it does on other platforms: it's safe as long
as only one thread tries to read from the directory stream at a given
time.

Furthermore, readdir_r is likely to be removed for FreeBSD 16, so we
should stop using it now.
---
 library/std/src/sys/fs/unix.rs | 120 +++++++++++++++++----------------
 1 file changed, 63 insertions(+), 57 deletions(-)

diff --git a/library/std/src/sys/fs/unix.rs b/library/std/src/sys/fs/unix.rs
index dfd6ce56a7682..33a1e7ff5e40e 100644
--- a/library/std/src/sys/fs/unix.rs
+++ b/library/std/src/sys/fs/unix.rs
@@ -21,29 +21,31 @@ use libc::fstatat as fstatat64;
 #[cfg(any(all(target_os = "linux", not(target_env = "musl")), target_os = "hurd"))]
 use libc::fstatat64;
 #[cfg(any(
+    target_os = "aix",
     target_os = "android",
-    target_os = "solaris",
+    target_os = "freebsd",
     target_os = "fuchsia",
-    target_os = "redox",
     target_os = "illumos",
-    target_os = "aix",
     target_os = "nto",
+    target_os = "redox",
+    target_os = "solaris",
     target_os = "vita",
     all(target_os = "linux", target_env = "musl"),
 ))]
 use libc::readdir as readdir64;
 #[cfg(not(any(
+    target_os = "aix",
     target_os = "android",
-    target_os = "linux",
-    target_os = "solaris",
+    target_os = "freebsd",
+    target_os = "fuchsia",
+    target_os = "hurd",
     target_os = "illumos",
     target_os = "l4re",
-    target_os = "fuchsia",
-    target_os = "redox",
-    target_os = "aix",
+    target_os = "linux",
     target_os = "nto",
+    target_os = "redox",
+    target_os = "solaris",
     target_os = "vita",
-    target_os = "hurd",
 )))]
 use libc::readdir_r as readdir64_r;
 #[cfg(any(all(target_os = "linux", not(target_env = "musl")), target_os = "hurd"))]
@@ -271,16 +273,17 @@ unsafe impl Send for Dir {}
 unsafe impl Sync for Dir {}
 
 #[cfg(any(
+    target_os = "aix",
     target_os = "android",
-    target_os = "linux",
-    target_os = "solaris",
-    target_os = "illumos",
+    target_os = "freebsd",
     target_os = "fuchsia",
-    target_os = "redox",
-    target_os = "aix",
+    target_os = "hurd",
+    target_os = "illumos",
+    target_os = "linux",
     target_os = "nto",
+    target_os = "redox",
+    target_os = "solaris",
     target_os = "vita",
-    target_os = "hurd",
 ))]
 pub struct DirEntry {
     dir: Arc<InnerReadDir>,
@@ -295,16 +298,17 @@ pub struct DirEntry {
 // we're not using the immediate `d_name` on these targets. Keeping this as an
 // `entry` field in `DirEntry` helps reduce the `cfg` boilerplate elsewhere.
 #[cfg(any(
+    target_os = "aix",
     target_os = "android",
-    target_os = "linux",
-    target_os = "solaris",
-    target_os = "illumos",
+    target_os = "freebsd",
     target_os = "fuchsia",
-    target_os = "redox",
-    target_os = "aix",
+    target_os = "hurd",
+    target_os = "illumos",
+    target_os = "linux",
     target_os = "nto",
+    target_os = "redox",
+    target_os = "solaris",
     target_os = "vita",
-    target_os = "hurd",
 ))]
 struct dirent64_min {
     d_ino: u64,
@@ -319,16 +323,17 @@ struct dirent64_min {
 }
 
 #[cfg(not(any(
+    target_os = "aix",
     target_os = "android",
-    target_os = "linux",
-    target_os = "solaris",
-    target_os = "illumos",
+    target_os = "freebsd",
     target_os = "fuchsia",
-    target_os = "redox",
-    target_os = "aix",
+    target_os = "hurd",
+    target_os = "illumos",
+    target_os = "linux",
     target_os = "nto",
+    target_os = "redox",
+    target_os = "solaris",
     target_os = "vita",
-    target_os = "hurd",
 )))]
 pub struct DirEntry {
     dir: Arc<InnerReadDir>,
@@ -698,16 +703,17 @@ impl Iterator for ReadDir {
     type Item = io::Result<DirEntry>;
 
     #[cfg(any(
+        target_os = "aix",
         target_os = "android",
-        target_os = "linux",
-        target_os = "solaris",
+        target_os = "freebsd",
         target_os = "fuchsia",
-        target_os = "redox",
+        target_os = "hurd",
         target_os = "illumos",
-        target_os = "aix",
+        target_os = "linux",
         target_os = "nto",
+        target_os = "redox",
+        target_os = "solaris",
         target_os = "vita",
-        target_os = "hurd",
     ))]
     fn next(&mut self) -> Option<io::Result<DirEntry>> {
         use crate::sys::os::{errno, set_errno};
@@ -768,6 +774,9 @@ impl Iterator for ReadDir {
                 // only access those bytes.
                 #[cfg(not(target_os = "vita"))]
                 let entry = dirent64_min {
+                    #[cfg(target_os = "freebsd")]
+                    d_ino: (*entry_ptr).d_fileno,
+                    #[cfg(not(target_os = "freebsd"))]
                     d_ino: (*entry_ptr).d_ino as u64,
                     #[cfg(not(any(
                         target_os = "solaris",
@@ -791,16 +800,17 @@ impl Iterator for ReadDir {
     }
 
     #[cfg(not(any(
+        target_os = "aix",
         target_os = "android",
-        target_os = "linux",
-        target_os = "solaris",
+        target_os = "freebsd",
         target_os = "fuchsia",
-        target_os = "redox",
+        target_os = "hurd",
         target_os = "illumos",
-        target_os = "aix",
+        target_os = "linux",
         target_os = "nto",
+        target_os = "redox",
+        target_os = "solaris",
         target_os = "vita",
-        target_os = "hurd",
     )))]
     fn next(&mut self) -> Option<io::Result<DirEntry>> {
         if self.end_of_stream {
@@ -970,36 +980,32 @@ impl DirEntry {
     }
 
     #[cfg(any(
-        target_os = "linux",
+        target_os = "aix",
+        target_os = "android",
         target_os = "cygwin",
         target_os = "emscripten",
-        target_os = "android",
-        target_os = "solaris",
-        target_os = "illumos",
-        target_os = "haiku",
-        target_os = "l4re",
-        target_os = "fuchsia",
-        target_os = "redox",
-        target_os = "vxworks",
         target_os = "espidf",
+        target_os = "freebsd",
+        target_os = "fuchsia",
+        target_os = "haiku",
         target_os = "horizon",
-        target_os = "vita",
-        target_os = "aix",
-        target_os = "nto",
         target_os = "hurd",
+        target_os = "illumos",
+        target_os = "l4re",
+        target_os = "linux",
+        target_os = "nto",
+        target_os = "redox",
         target_os = "rtems",
+        target_os = "solaris",
+        target_os = "vita",
+        target_os = "vxworks",
         target_vendor = "apple",
     ))]
     pub fn ino(&self) -> u64 {
         self.entry.d_ino as u64
     }
 
-    #[cfg(any(
-        target_os = "freebsd",
-        target_os = "openbsd",
-        target_os = "netbsd",
-        target_os = "dragonfly"
-    ))]
+    #[cfg(any(target_os = "openbsd", target_os = "netbsd", target_os = "dragonfly"))]
     pub fn ino(&self) -> u64 {
         self.entry.d_fileno as u64
     }
@@ -1014,7 +1020,6 @@ impl DirEntry {
     #[cfg(any(
         target_os = "netbsd",
         target_os = "openbsd",
-        target_os = "freebsd",
         target_os = "dragonfly",
         target_vendor = "apple",
     ))]
@@ -1030,7 +1035,6 @@ impl DirEntry {
     #[cfg(not(any(
         target_os = "netbsd",
         target_os = "openbsd",
-        target_os = "freebsd",
         target_os = "dragonfly",
         target_vendor = "apple",
     )))]
@@ -1040,6 +1044,7 @@ impl DirEntry {
 
     #[cfg(not(any(
         target_os = "android",
+        target_os = "freebsd",
         target_os = "linux",
         target_os = "solaris",
         target_os = "illumos",
@@ -1055,6 +1060,7 @@ impl DirEntry {
     }
     #[cfg(any(
         target_os = "android",
+        target_os = "freebsd",
         target_os = "linux",
         target_os = "solaris",
         target_os = "illumos",

From 5025bfa1466488a879bd83f8a022362970182ce4 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Wed, 10 Sep 2025 20:34:02 +0300
Subject: [PATCH 0940/1889] Improve `rust-analyzer diagnostics`

In my experience the `processing <module>` messages make it harder to search for the actual diagnostics, so remove them and instead print the filename only if there is a diagnostic.

Also allow choosing the minimum severity.
---
 .../rust-analyzer/src/cli/diagnostics.rs      | 46 +++++++++++++------
 .../crates/rust-analyzer/src/cli/flags.rs     | 24 ++++++++++
 2 files changed, 56 insertions(+), 14 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/diagnostics.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/diagnostics.rs
index 7b12cb14009ff..82590c8e707fa 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/diagnostics.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/diagnostics.rs
@@ -9,7 +9,7 @@ use ide::{AnalysisHost, AssistResolveStrategy, Diagnostic, DiagnosticsConfig, Se
 use ide_db::{LineIndexDatabase, base_db::SourceDatabase};
 use load_cargo::{LoadCargoConfig, ProcMacroServerChoice, load_workspace_at};
 
-use crate::cli::flags;
+use crate::cli::{flags, progress_report::ProgressReport};
 
 impl flags::Diagnostics {
     pub fn run(self) -> anyhow::Result<()> {
@@ -50,23 +50,26 @@ impl flags::Diagnostics {
 
         let mut found_error = false;
         let mut visited_files = FxHashSet::default();
-
-        let work = all_modules(db).into_iter().filter(|module| {
-            let file_id = module.definition_source_file_id(db).original_file(db);
-            let source_root = db.file_source_root(file_id.file_id(db)).source_root_id(db);
-            let source_root = db.source_root(source_root).source_root(db);
-            !source_root.is_library
-        });
-
+        let min_severity = self.severity.unwrap_or(flags::Severity::Weak);
+
+        let work = all_modules(db)
+            .into_iter()
+            .filter(|module| {
+                let file_id = module.definition_source_file_id(db).original_file(db);
+                let source_root = db.file_source_root(file_id.file_id(db)).source_root_id(db);
+                let source_root = db.source_root(source_root).source_root(db);
+                !source_root.is_library
+            })
+            .collect::<Vec<_>>();
+
+        let mut bar = ProgressReport::new(work.len());
         for module in work {
             let file_id = module.definition_source_file_id(db).original_file(db);
             if !visited_files.contains(&file_id) {
+                let message = format!("processing {}", _vfs.file_path(file_id.file_id(db)));
+                bar.set_message(move || message.clone());
                 let crate_name =
                     module.krate().display_name(db).as_deref().unwrap_or(&sym::unknown).to_owned();
-                println!(
-                    "processing crate: {crate_name}, module: {}",
-                    _vfs.file_path(file_id.file_id(db))
-                );
                 for diagnostic in analysis
                     .full_diagnostics(
                         &DiagnosticsConfig::test_sample(),
@@ -75,6 +78,16 @@ impl flags::Diagnostics {
                     )
                     .unwrap()
                 {
+                    let severity = match diagnostic.severity {
+                        Severity::Error => flags::Severity::Error,
+                        Severity::Warning => flags::Severity::Warning,
+                        Severity::WeakWarning => flags::Severity::Weak,
+                        Severity::Allow => continue,
+                    };
+                    if severity < min_severity {
+                        continue;
+                    }
+
                     if matches!(diagnostic.severity, Severity::Error) {
                         found_error = true;
                     }
@@ -83,12 +96,17 @@ impl flags::Diagnostics {
                     let line_index = db.line_index(range.file_id);
                     let start = line_index.line_col(range.range.start());
                     let end = line_index.line_col(range.range.end());
-                    println!("{severity:?} {code:?} from {start:?} to {end:?}: {message}");
+                    bar.println(format!(
+                        "at crate {crate_name}, file {}: {severity:?} {code:?} from {start:?} to {end:?}: {message}",
+                        _vfs.file_path(file_id.file_id(db))
+                    ));
                 }
 
                 visited_files.insert(file_id);
             }
+            bar.inc(1);
         }
+        bar.finish_and_clear();
 
         println!();
         println!("diagnostic scan complete");
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/flags.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/flags.rs
index 16f351272b691..75030bedfca3f 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/flags.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/flags.rs
@@ -124,6 +124,9 @@ xflags::xflags! {
             optional --disable-proc-macros
             /// Run the proc-macro-srv binary at the specified path.
             optional --proc-macro-srv path: PathBuf
+
+            /// The minimum severity.
+            optional --severity severity: Severity
         }
 
         /// Report unresolved references
@@ -281,6 +284,7 @@ pub struct Diagnostics {
     pub disable_build_scripts: bool,
     pub disable_proc_macros: bool,
     pub proc_macro_srv: Option<PathBuf>,
+    pub severity: Option<Severity>,
 }
 
 #[derive(Debug)]
@@ -376,3 +380,23 @@ impl FromStr for OutputFormat {
         }
     }
 }
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub enum Severity {
+    Weak,
+    Warning,
+    Error,
+}
+
+impl FromStr for Severity {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match &*s.to_ascii_lowercase() {
+            "weak" => Ok(Self::Weak),
+            "warning" => Ok(Self::Warning),
+            "error" => Ok(Self::Error),
+            _ => Err(format!("unknown severity `{s}`")),
+        }
+    }
+}

From 927c4c03194da284404985747c2cad25fa1f5066 Mon Sep 17 00:00:00 2001
From: Jules Bertholet <julesbertholet@quoi.xyz>
Date: Sun, 14 Sep 2025 17:55:33 -0400
Subject: [PATCH 0941/1889] Fix typo in error message

---
 compiler/rustc_middle/messages.ftl                          | 2 +-
 tests/ui/consts/const_refs_to_static_fail.stderr            | 2 +-
 tests/ui/consts/const_refs_to_static_fail_invalid.stderr    | 4 ++--
 .../ui/consts/miri_unleashed/const_refers_to_static.stderr  | 2 +-
 .../const_refers_to_static_cross_crate.stderr               | 6 +++---
 5 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/compiler/rustc_middle/messages.ftl b/compiler/rustc_middle/messages.ftl
index 69adb2fe3919f..279ab9a9d8fbe 100644
--- a/compiler/rustc_middle/messages.ftl
+++ b/compiler/rustc_middle/messages.ftl
@@ -84,7 +84,7 @@ middle_failed_writing_file =
 # Note: We only mention patterns here since the error can only occur with references, and those
 # are forbidden in const generics.
 middle_invalid_const_in_valtree = constant {$global_const_id} cannot be used as pattern
-    .note = constants that reference mutable or external memory cannot be used as pattern
+    .note = constants that reference mutable or external memory cannot be used as patterns
 
 middle_layout_cycle =
     a cycle occurred during layout computation
diff --git a/tests/ui/consts/const_refs_to_static_fail.stderr b/tests/ui/consts/const_refs_to_static_fail.stderr
index c567b3e0ce1f4..2bb6d2b8fef7c 100644
--- a/tests/ui/consts/const_refs_to_static_fail.stderr
+++ b/tests/ui/consts/const_refs_to_static_fail.stderr
@@ -16,7 +16,7 @@ error: constant BAD_PATTERN cannot be used as pattern
 LL |         BAD_PATTERN => {},
    |         ^^^^^^^^^^^
    |
-   = note: constants that reference mutable or external memory cannot be used as pattern
+   = note: constants that reference mutable or external memory cannot be used as patterns
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/consts/const_refs_to_static_fail_invalid.stderr b/tests/ui/consts/const_refs_to_static_fail_invalid.stderr
index f9088c318a621..226a9de285dc3 100644
--- a/tests/ui/consts/const_refs_to_static_fail_invalid.stderr
+++ b/tests/ui/consts/const_refs_to_static_fail_invalid.stderr
@@ -15,7 +15,7 @@ error: constant extern_::C cannot be used as pattern
 LL |         C => {}
    |         ^
    |
-   = note: constants that reference mutable or external memory cannot be used as pattern
+   = note: constants that reference mutable or external memory cannot be used as patterns
 
 error: constant mutable::C cannot be used as pattern
   --> $DIR/const_refs_to_static_fail_invalid.rs:42:9
@@ -23,7 +23,7 @@ error: constant mutable::C cannot be used as pattern
 LL |         C => {}
    |         ^
    |
-   = note: constants that reference mutable or external memory cannot be used as pattern
+   = note: constants that reference mutable or external memory cannot be used as patterns
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/consts/miri_unleashed/const_refers_to_static.stderr b/tests/ui/consts/miri_unleashed/const_refers_to_static.stderr
index 6b70a211a72cc..5b8797c511627 100644
--- a/tests/ui/consts/miri_unleashed/const_refers_to_static.stderr
+++ b/tests/ui/consts/miri_unleashed/const_refers_to_static.stderr
@@ -22,7 +22,7 @@ error: constant REF_INTERIOR_MUT cannot be used as pattern
 LL |         REF_INTERIOR_MUT => {},
    |         ^^^^^^^^^^^^^^^^
    |
-   = note: constants that reference mutable or external memory cannot be used as pattern
+   = note: constants that reference mutable or external memory cannot be used as patterns
 
 warning: skipping const checks
    |
diff --git a/tests/ui/consts/miri_unleashed/const_refers_to_static_cross_crate.stderr b/tests/ui/consts/miri_unleashed/const_refers_to_static_cross_crate.stderr
index d753506cc94e3..c2b730375f2c2 100644
--- a/tests/ui/consts/miri_unleashed/const_refers_to_static_cross_crate.stderr
+++ b/tests/ui/consts/miri_unleashed/const_refers_to_static_cross_crate.stderr
@@ -10,7 +10,7 @@ error: constant SLICE_MUT cannot be used as pattern
 LL |         SLICE_MUT => true,
    |         ^^^^^^^^^
    |
-   = note: constants that reference mutable or external memory cannot be used as pattern
+   = note: constants that reference mutable or external memory cannot be used as patterns
 
 error: constant U8_MUT cannot be used as pattern
   --> $DIR/const_refers_to_static_cross_crate.rs:44:9
@@ -18,7 +18,7 @@ error: constant U8_MUT cannot be used as pattern
 LL |         U8_MUT => true,
    |         ^^^^^^
    |
-   = note: constants that reference mutable or external memory cannot be used as pattern
+   = note: constants that reference mutable or external memory cannot be used as patterns
 
 error: constant U8_MUT2 cannot be used as pattern
   --> $DIR/const_refers_to_static_cross_crate.rs:53:9
@@ -26,7 +26,7 @@ error: constant U8_MUT2 cannot be used as pattern
 LL |         U8_MUT2 => true,
    |         ^^^^^^^
    |
-   = note: constants that reference mutable or external memory cannot be used as pattern
+   = note: constants that reference mutable or external memory cannot be used as patterns
 
 error: aborting due to 4 previous errors
 

From 37d058fa048acd6bf385677f7cdb1e020ceb0769 Mon Sep 17 00:00:00 2001
From: clubby789 <jamie@hill-daniel.co.uk>
Date: Sun, 14 Sep 2025 23:03:56 +0100
Subject: [PATCH 0942/1889] tidy: Remove `WorkspaceInfo` constructor

---
 src/tools/tidy/src/deps.rs | 150 ++++++++++++++++++++++---------------
 1 file changed, 90 insertions(+), 60 deletions(-)

diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs
index 290f0ea313419..8092a8000cf58 100644
--- a/src/tools/tidy/src/deps.rs
+++ b/src/tools/tidy/src/deps.rs
@@ -63,71 +63,101 @@ pub(crate) struct WorkspaceInfo<'a> {
     pub(crate) submodules: &'a [&'a str],
 }
 
-impl<'a> WorkspaceInfo<'a> {
-    const fn new(
-        path: &'a str,
-        exceptions: ExceptionList,
-        crates_and_deps: Option<(&'a [&str], &'a [&str], ListLocation)>,
-        submodules: &'a [&str],
-    ) -> Self {
-        Self { path, exceptions, crates_and_deps, submodules }
-    }
-}
-
 /// The workspaces to check for licensing and optionally permitted dependencies.
 // FIXME auto detect all cargo workspaces
 pub(crate) const WORKSPACES: &[WorkspaceInfo<'static>] = &[
     // The root workspace has to be first for check_rustfix to work.
-    WorkspaceInfo::new(
-        ".",
-        EXCEPTIONS,
-        Some((&["rustc-main"], PERMITTED_RUSTC_DEPENDENCIES, PERMITTED_RUSTC_DEPS_LOCATION)),
-        &[],
-    ),
-    WorkspaceInfo::new(
-        "library",
-        EXCEPTIONS_STDLIB,
-        Some((&["sysroot"], PERMITTED_STDLIB_DEPENDENCIES, PERMITTED_STDLIB_DEPS_LOCATION)),
-        &[],
-    ),
-    // Outside of the alphabetical section because rustfmt formats it using multiple lines.
-    WorkspaceInfo::new(
-        "compiler/rustc_codegen_cranelift",
-        EXCEPTIONS_CRANELIFT,
-        Some((
-            &["rustc_codegen_cranelift"],
-            PERMITTED_CRANELIFT_DEPENDENCIES,
-            PERMITTED_CRANELIFT_DEPS_LOCATION,
+    WorkspaceInfo {
+        path: ".",
+        exceptions: EXCEPTIONS,
+        crates_and_deps: Some((
+            &["rustc-main"],
+            PERMITTED_RUSTC_DEPENDENCIES,
+            PERMITTED_RUSTC_DEPS_LOCATION,
         )),
-        &[],
-    ),
-    // tidy-alphabetical-start
-    WorkspaceInfo::new("compiler/rustc_codegen_gcc", EXCEPTIONS_GCC, None, &[]),
-    WorkspaceInfo::new("src/bootstrap", EXCEPTIONS_BOOTSTRAP, None, &[]),
-    WorkspaceInfo::new("src/tools/cargo", EXCEPTIONS_CARGO, None, &["src/tools/cargo"]),
-    //WorkspaceInfo::new("src/tools/miri/test-cargo-miri", &[], None), // FIXME uncomment once all deps are vendored
-    //WorkspaceInfo::new("src/tools/miri/test_dependencies", &[], None), // FIXME uncomment once all deps are vendored
-    WorkspaceInfo::new("src/tools/rust-analyzer", EXCEPTIONS_RUST_ANALYZER, None, &[]),
-    WorkspaceInfo::new(
-        "src/tools/rustbook",
-        EXCEPTIONS_RUSTBOOK,
-        None,
-        &["src/doc/book", "src/doc/reference"],
-    ),
-    WorkspaceInfo::new(
-        "src/tools/rustc-perf",
-        EXCEPTIONS_RUSTC_PERF,
-        None,
-        &["src/tools/rustc-perf"],
-    ),
-    WorkspaceInfo::new("src/tools/test-float-parse", EXCEPTIONS, None, &[]),
-    WorkspaceInfo::new(
-        "tests/run-make-cargo/uefi-qemu/uefi_qemu_test",
-        EXCEPTIONS_UEFI_QEMU_TEST,
-        None,
-        &[],
-    ),
-    // tidy-alphabetical-end
+        submodules: &[],
+    },
+    WorkspaceInfo {
+        path: "library",
+        exceptions: EXCEPTIONS_STDLIB,
+        crates_and_deps: Some((
+            &["sysroot"],
+            PERMITTED_STDLIB_DEPENDENCIES,
+            PERMITTED_STDLIB_DEPS_LOCATION,
+        )),
+        submodules: &[],
+    },
+    {
+        WorkspaceInfo {
+            path: "compiler/rustc_codegen_cranelift",
+            exceptions: EXCEPTIONS_CRANELIFT,
+            crates_and_deps: Some((
+                &["rustc_codegen_cranelift"],
+                PERMITTED_CRANELIFT_DEPENDENCIES,
+                PERMITTED_CRANELIFT_DEPS_LOCATION,
+            )),
+            submodules: &[],
+        }
+    },
+    WorkspaceInfo {
+        path: "compiler/rustc_codegen_gcc",
+        exceptions: EXCEPTIONS_GCC,
+        crates_and_deps: None,
+        submodules: &[],
+    },
+    WorkspaceInfo {
+        path: "src/bootstrap",
+        exceptions: EXCEPTIONS_BOOTSTRAP,
+        crates_and_deps: None,
+        submodules: &[],
+    },
+    WorkspaceInfo {
+        path: "src/tools/cargo",
+        exceptions: EXCEPTIONS_CARGO,
+        crates_and_deps: None,
+        submodules: &["src/tools/cargo"],
+    },
+    // FIXME uncomment once all deps are vendored
+    //  WorkspaceInfo {
+    //      path: "src/tools/miri/test-cargo-miri",
+    //      crates_and_deps: None
+    //      submodules: &[],
+    //  },
+    // WorkspaceInfo {
+    //      path: "src/tools/miri/test_dependencies",
+    //      crates_and_deps: None,
+    //      submodules: &[],
+    //  }
+    WorkspaceInfo {
+        path: "src/tools/rust-analyzer",
+        exceptions: EXCEPTIONS_RUST_ANALYZER,
+        crates_and_deps: None,
+        submodules: &[],
+    },
+    WorkspaceInfo {
+        path: "src/tools/rustbook",
+        exceptions: EXCEPTIONS_RUSTBOOK,
+        crates_and_deps: None,
+        submodules: &["src/doc/book", "src/doc/reference"],
+    },
+    WorkspaceInfo {
+        path: "src/tools/rustc-perf",
+        exceptions: EXCEPTIONS_RUSTC_PERF,
+        crates_and_deps: None,
+        submodules: &["src/tools/rustc-perf"],
+    },
+    WorkspaceInfo {
+        path: "src/tools/test-float-parse",
+        exceptions: EXCEPTIONS,
+        crates_and_deps: None,
+        submodules: &[],
+    },
+    WorkspaceInfo {
+        path: "tests/run-make-cargo/uefi-qemu/uefi_qemu_test",
+        exceptions: EXCEPTIONS_UEFI_QEMU_TEST,
+        crates_and_deps: None,
+        submodules: &[],
+    },
 ];
 
 /// These are exceptions to Rust's permissive licensing policy, and

From b92ad97f1d8d458de880daea3826d8db30717a0e Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Sun, 14 Sep 2025 18:26:29 -0500
Subject: [PATCH 0943/1889] bootstrap.py: disable incremental build for
 bootstrap in CI

---
 src/bootstrap/bootstrap.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/bootstrap/bootstrap.py b/src/bootstrap/bootstrap.py
index 2ece53eb0cc99..e017cfe6aefbf 100644
--- a/src/bootstrap/bootstrap.py
+++ b/src/bootstrap/bootstrap.py
@@ -1039,6 +1039,9 @@ def build_bootstrap_cmd(self, env):
         # See also: <https://github.com/rust-lang/rust/issues/70208>.
         if "CARGO_BUILD_TARGET" in env:
             del env["CARGO_BUILD_TARGET"]
+        # if in CI, don't use incremental build when building bootstrap.
+        if "GITHUB_ACTIONS" in env:
+            env["CARGO_INCREMENTAL"] = "0"
         env["CARGO_TARGET_DIR"] = build_dir
         env["RUSTC"] = self.rustc()
         env["LD_LIBRARY_PATH"] = (

From 5ebdec5ac2908b0bae42adbe451beeadbe8fa5de Mon Sep 17 00:00:00 2001
From: Tsukasa OI <floss_rust@irq.a4lg.com>
Date: Mon, 15 Sep 2025 02:16:34 +0000
Subject: [PATCH 0944/1889] rustc_codegen_llvm: Adjust RISC-V inline assembly's
 clobber list

Despite that the `fflags` register (representing floating point
exception flags) is stated as a flag register in the reference, it's not
in the default clobber list of the RISC-V inline assembly and it would
be better to fix it.
---
 compiler/rustc_codegen_llvm/src/asm.rs   | 1 +
 tests/codegen-llvm/asm/riscv-clobbers.rs | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_codegen_llvm/src/asm.rs b/compiler/rustc_codegen_llvm/src/asm.rs
index 38c1d3b53e87c..b79176e909818 100644
--- a/compiler/rustc_codegen_llvm/src/asm.rs
+++ b/compiler/rustc_codegen_llvm/src/asm.rs
@@ -240,6 +240,7 @@ impl<'ll, 'tcx> AsmBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                 }
                 InlineAsmArch::RiscV32 | InlineAsmArch::RiscV64 => {
                     constraints.extend_from_slice(&[
+                        "~{fflags}".to_string(),
                         "~{vtype}".to_string(),
                         "~{vl}".to_string(),
                         "~{vxsat}".to_string(),
diff --git a/tests/codegen-llvm/asm/riscv-clobbers.rs b/tests/codegen-llvm/asm/riscv-clobbers.rs
index e55b6731098e7..0f235ddcdcc85 100644
--- a/tests/codegen-llvm/asm/riscv-clobbers.rs
+++ b/tests/codegen-llvm/asm/riscv-clobbers.rs
@@ -17,7 +17,7 @@ extern crate minicore;
 use minicore::*;
 
 // CHECK-LABEL: @flags_clobber
-// CHECK: call void asm sideeffect "", "~{vtype},~{vl},~{vxsat},~{vxrm}"()
+// CHECK: call void asm sideeffect "", "~{fflags},~{vtype},~{vl},~{vxsat},~{vxrm}"()
 #[no_mangle]
 pub unsafe fn flags_clobber() {
     asm!("", options(nostack, nomem));

From 55b8d4e6ffc220db78b928aacc274423631134f7 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Mon, 15 Sep 2025 07:56:35 +0300
Subject: [PATCH 0945/1889] Don't mark unknown type as implementing every
 notable trait

Because the new solver, will return "yes" for them (which is a good thing).
---
 .../rust-analyzer/crates/ide/src/hover.rs     |  6 +++++
 .../crates/ide/src/hover/tests.rs             | 23 +++++++++++++++++++
 2 files changed, 29 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/ide/src/hover.rs b/src/tools/rust-analyzer/crates/ide/src/hover.rs
index 3f52303d74e48..03b9b3677511c 100644
--- a/src/tools/rust-analyzer/crates/ide/src/hover.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/hover.rs
@@ -483,6 +483,12 @@ fn notable_traits<'db>(
     db: &'db RootDatabase,
     ty: &hir::Type<'db>,
 ) -> Vec<(hir::Trait, Vec<(Option<hir::Type<'db>>, hir::Name)>)> {
+    if ty.is_unknown() {
+        // The trait solver returns "yes" to the question whether the error type
+        // impls any trait, and we don't want to show it as having any notable trait.
+        return Vec::new();
+    }
+
     db.notable_traits_in_deps(ty.krate(db).into())
         .iter()
         .flat_map(|it| &**it)
diff --git a/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs b/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
index 58d8a7edbe042..a88c0c9866e5f 100644
--- a/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
@@ -11097,3 +11097,26 @@ impl Enum<'_, Borrowed> {
         "#]],
     );
 }
+
+#[test]
+fn unknown_should_not_implement_notable_traits() {
+    check(
+        r#"
+//- minicore: future, iterator
+fn foo() {
+    let x$0;
+}
+    "#,
+        expect![[r#"
+            *x*
+
+            ```rust
+            let x: {unknown}
+            ```
+
+            ---
+
+            no Drop
+        "#]],
+    );
+}

From 91f32ed1803b7164446f386c5844718e963aeb0c Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Mon, 15 Sep 2025 08:25:17 +0300
Subject: [PATCH 0946/1889] Add regression tests to some
 S-blocked-on-new-solver issues

That were fixed by the migration.
---
 .../hir-ty/src/tests/regression/new_solver.rs | 126 ++++++++++++++++++
 .../crates/test-utils/src/minicore.rs         |  12 +-
 2 files changed, 137 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
index 595f285bd930e..f559230fee394 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
@@ -2,6 +2,132 @@ use expect_test::expect;
 
 use crate::tests::{check_infer, check_no_mismatches};
 
+#[test]
+fn regression_20365() {
+    check_infer(
+        r#"
+//- minicore: iterator
+struct Vec<T>(T);
+struct IntoIter<T>(T);
+impl<T> IntoIterator for Vec<T> {
+    type IntoIter = IntoIter<T>;
+    type Item = T;
+}
+impl<T> Iterator for IntoIter<T> {
+    type Item = T;
+}
+
+fn f<T: Space>(a: Vec<u8>) {
+    let iter = a.into_iter();
+}
+
+pub trait Space: IntoIterator {
+    type Ty: Space;
+}
+impl Space for [u8; 1] {
+    type Ty = Self;
+}
+    "#,
+        expect![[r#"
+            201..202 'a': Vec<u8>
+            213..246 '{     ...r(); }': ()
+            223..227 'iter': IntoIter<u8>
+            230..231 'a': Vec<u8>
+            230..243 'a.into_iter()': IntoIter<u8>
+        "#]],
+    );
+}
+
+#[test]
+fn regression_19971() {
+    check_infer(
+        r#"
+//- minicore: pointee
+fn make<T>(_thin: *const (), _meta: core::ptr::DynMetadata<T>) -> *const T
+where
+    T: core::ptr::Pointee<Metadata = core::ptr::DynMetadata<T>> + ?Sized,
+{
+    loop {}
+}
+trait Foo {
+    fn foo(&self) -> i32 {
+        loop {}
+    }
+}
+
+fn test() -> i32 {
+    struct F {}
+    impl Foo for F {}
+    let meta = core::ptr::metadata(0 as *const F as *const dyn Foo);
+
+    let f = F {};
+    let fat_ptr = make(&f as *const F as *const (), meta); // <-- infers type as `*const {unknown}`
+
+    let fat_ref = unsafe { &*fat_ptr }; // <-- infers type as `&{unknown}`
+    fat_ref.foo() // cannot 'go to definition' on `foo`
+}
+
+    "#,
+        expect![[r#"
+            11..16 '_thin': *const ()
+            29..34 '_meta': DynMetadata<T>
+            155..170 '{     loop {} }': *const T
+            161..168 'loop {}': !
+            166..168 '{}': ()
+            195..199 'self': &'? Self
+            208..231 '{     ...     }': i32
+            218..225 'loop {}': !
+            223..225 '{}': ()
+            252..613 '{     ...foo` }': i32
+            300..304 'meta': DynMetadata<dyn Foo + '?>
+            307..326 'core::...tadata': fn metadata<dyn Foo + '?>(*const (dyn Foo + '?)) -> <dyn Foo + '? as Pointee>::Metadata
+            307..359 'core::...n Foo)': DynMetadata<dyn Foo + '?>
+            327..328 '0': usize
+            327..340 '0 as *const F': *const F
+            327..358 '0 as *...yn Foo': *const (dyn Foo + '?)
+            370..371 'f': F
+            374..378 'F {}': F
+            388..395 'fat_ptr': *const (dyn Foo + '?)
+            398..402 'make': fn make<dyn Foo + '?>(*const (), DynMetadata<dyn Foo + '?>) -> *const (dyn Foo + '?)
+            398..437 'make(&... meta)': *const (dyn Foo + '?)
+            403..405 '&f': &'? F
+            403..417 '&f as *const F': *const F
+            403..430 '&f as ...nst ()': *const ()
+            404..405 'f': F
+            432..436 'meta': DynMetadata<dyn Foo + '?>
+            489..496 'fat_ref': &'? (dyn Foo + '?)
+            499..519 'unsafe..._ptr }': &'? (dyn Foo + '?)
+            508..517 '&*fat_ptr': &'? (dyn Foo + '?)
+            509..517 '*fat_ptr': dyn Foo + '?
+            510..517 'fat_ptr': *const (dyn Foo + '?)
+            560..567 'fat_ref': &'? (dyn Foo + '?)
+            560..573 'fat_ref.foo()': i32
+        "#]],
+    );
+}
+
+#[test]
+fn regression_19752() {
+    check_no_mismatches(
+        r#"
+//- minicore: sized, copy
+trait T1<T: T2>: Sized + Copy {
+    fn a(self, other: Self) -> Self {
+        other
+    }
+
+    fn b(&mut self, other: Self) {
+        *self = self.a(other);
+    }
+}
+
+trait T2: Sized {
+    type T1: T1<Self>;
+}
+    "#,
+    );
+}
+
 #[test]
 fn opaque_generics() {
     check_infer(
diff --git a/src/tools/rust-analyzer/crates/test-utils/src/minicore.rs b/src/tools/rust-analyzer/crates/test-utils/src/minicore.rs
index 26e0f46705b9e..7c3e7fea1bdef 100644
--- a/src/tools/rust-analyzer/crates/test-utils/src/minicore.rs
+++ b/src/tools/rust-analyzer/crates/test-utils/src/minicore.rs
@@ -55,7 +55,7 @@
 //!     panic: fmt
 //!     phantom_data:
 //!     pin:
-//!     pointee: copy, send, sync, ord, hash, unpin
+//!     pointee: copy, send, sync, ord, hash, unpin, phantom_data
 //!     range:
 //!     receiver: deref
 //!     result:
@@ -504,6 +504,16 @@ pub mod ptr {
         #[lang = "metadata_type"]
         type Metadata: Copy + Send + Sync + Ord + Hash + Unpin;
     }
+
+    #[lang = "dyn_metadata"]
+    pub struct DynMetadata<Dyn: PointeeSized> {
+        _phantom: crate::marker::PhantomData<Dyn>,
+    }
+
+    pub const fn metadata<T: PointeeSized>(ptr: *const T) -> <T as Pointee>::Metadata {
+        loop {}
+    }
+
     // endregion:pointee
     // region:non_null
     #[rustc_layout_scalar_valid_range_start(1)]

From f40e71c9de3d5d1075fa9fd94fccdd6126ae1ad4 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Mon, 15 Sep 2025 08:50:08 +0300
Subject: [PATCH 0947/1889] Add Regression Test For The One And The Only Issue
 #5514

---
 .../hir-ty/src/tests/regression/new_solver.rs | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
index f559230fee394..82d670cef2b0e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
@@ -128,6 +128,40 @@ trait T2: Sized {
     );
 }
 
+#[test]
+fn regression_type_checker_does_not_eagerly_select_predicates_from_where_clauses() {
+    // This was a very long standing issue (#5514) with a lot of duplicates, that was
+    // fixed by the switch to the new trait solver, so it deserves a long name and a
+    // honorable mention.
+    check_infer(
+        r#"
+//- minicore: from
+
+struct Foo;
+impl Foo {
+    fn method(self) -> i32 { 0 }
+}
+
+fn f<T: Into<Foo>>(u: T) {
+    let x = u.into();
+    x.method();
+}
+    "#,
+        expect![[r#"
+            38..42 'self': Foo
+            51..56 '{ 0 }': i32
+            53..54 '0': i32
+            79..80 'u': T
+            85..126 '{     ...d(); }': ()
+            95..96 'x': Foo
+            99..100 'u': T
+            99..107 'u.into()': Foo
+            113..114 'x': Foo
+            113..123 'x.method()': i32
+        "#]],
+    );
+}
+
 #[test]
 fn opaque_generics() {
     check_infer(

From 96f8dbe1b33691a949b23a005581b66c6f7e4cbf Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Mon, 15 Sep 2025 16:36:00 +1000
Subject: [PATCH 0948/1889] compiletest: Enable new-output-capture by default

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

diff --git a/src/tools/compiletest/src/lib.rs b/src/tools/compiletest/src/lib.rs
index f647f96a9bf34..17a60ace80460 100644
--- a/src/tools/compiletest/src/lib.rs
+++ b/src/tools/compiletest/src/lib.rs
@@ -472,7 +472,7 @@ pub fn parse_config(args: Vec<String>) -> Config {
             let value = matches
                 .opt_str("new-output-capture")
                 .or_else(|| env::var("COMPILETEST_NEW_OUTPUT_CAPTURE").ok())
-                .unwrap_or_else(|| "off".to_owned());
+                .unwrap_or_else(|| "on".to_owned());
             parse_bool_option(&value)
                 .unwrap_or_else(|| panic!("unknown `--new-output-capture` value `{value}` given"))
         },

From 7b0b0bbefa8d0dd3ff3e1698c76db247e8641fe6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Mon, 15 Sep 2025 09:45:19 +0200
Subject: [PATCH 0949/1889] Clarify that backtick escaping doesn't work for
 `@bors try jobs`

---
 src/doc/rustc-dev-guide/src/tests/ci.md | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/tests/ci.md b/src/doc/rustc-dev-guide/src/tests/ci.md
index a8cc959124ff6..a32edd7240117 100644
--- a/src/doc/rustc-dev-guide/src/tests/ci.md
+++ b/src/doc/rustc-dev-guide/src/tests/ci.md
@@ -151,8 +151,9 @@ which can be used in one of two ways:
 
 Each job pattern can either be an exact name of a job or a glob pattern that matches multiple jobs,
 for example `*msvc*` or `*-alt`. You can start at most 20 jobs in a single try build. When using
-glob patterns, you might want to wrap them in backticks (`` ` ``) to avoid GitHub rendering
-the pattern as Markdown.
+glob patterns in the PR description, you can wrap them in backticks (`` ` ``) to avoid GitHub rendering
+the pattern as Markdown if it contains e.g. an asterisk. Note that this escaping will not work when using
+the `@bors jobs=` parameter.
 
 The job pattern needs to match one or more jobs defined in the `auto` or `optional` sections
 of [`jobs.yml`]:

From f6a7da8673de4a87e8e882ff533904274396726b Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Mon, 15 Sep 2025 10:48:26 +0300
Subject: [PATCH 0950/1889] Add a testing guide

---
 .../rust-analyzer/docs/book/src/SUMMARY.md    |   1 +
 .../docs/book/src/contributing/testing.md     | 106 ++++++++++++++++++
 2 files changed, 107 insertions(+)
 create mode 100644 src/tools/rust-analyzer/docs/book/src/contributing/testing.md

diff --git a/src/tools/rust-analyzer/docs/book/src/SUMMARY.md b/src/tools/rust-analyzer/docs/book/src/SUMMARY.md
index dffdae94a6e86..3fb46d59a4a50 100644
--- a/src/tools/rust-analyzer/docs/book/src/SUMMARY.md
+++ b/src/tools/rust-analyzer/docs/book/src/SUMMARY.md
@@ -23,3 +23,4 @@
   - [Setup](contributing/setup.md)
   - [Style](contributing/style.md)
   - [Syntax](contributing/syntax.md)
+  - [Writing Tests](contributing/testing.md)
diff --git a/src/tools/rust-analyzer/docs/book/src/contributing/testing.md b/src/tools/rust-analyzer/docs/book/src/contributing/testing.md
new file mode 100644
index 0000000000000..ccee9b847b6e1
--- /dev/null
+++ b/src/tools/rust-analyzer/docs/book/src/contributing/testing.md
@@ -0,0 +1,106 @@
+rust-analyzer's testing is based on *snapshot tests*: a test is a piece of input text, usually a Rust code, and some output text. There is then some testing helper that runs the feature on the input text and compares the result to the output text.
+
+rust-analyzer uses a combination of the crate [`expect-test`](https://docs.rs/expect-test) and a custom testing framework.
+
+This all may sound too abstract, so let's demonstrate with an example.
+
+Type inference tests are located at `crates/hir-ty/src/tests`. There are various test helpers you can use. One of the simplest is `check_no_mismatches()`: it is given a piece of Rust code (we'll talk more about Rust code in tests later) and asserts that there are no type mismatches in it, that is, one type was expected but another was found (for example, `let x: () = 1` is a type mismatch). Note that we determine type mismatches via rust-analyzer's own analysis, not via the compiler (this is what we are testing, after all), which means there are often missed mismatches and sometimes bogus ones as well.
+
+For example, the following test will fail:
+```rust
+#[test]
+fn this_will_fail() {
+    check_no_mismatches(
+        r#"
+fn main() {
+    let x: () = 1;
+}
+    "#,
+    );
+}
+```
+
+Sometimes we want to check more that there are no type mismatches. For that we use other helpers. For example, often we want to assert that the type of some expression is some specific type. For that we use the `check_types()` function. It takes a Rust code string with custom annotation, that are common in our test suite. The general scheme of annotation is:
+
+ - `$0` marks a position. What to do with it is determined by the testing helper. Commonly it denotes the cursor position in IDE tests (for example, hover).
+ - `$0...$0` marks a range, commonly a selection in IDE tests.
+ - `^...^`, commonly seen in a comment (`// ^^^^`), labels the line above. For example, the following will attach the label `hey` to the range of the variable name `cool`:
+
+    ```rust
+    let cool;
+     // ^^^^ hey
+    ```
+
+`check_types()` uses labels to assert type: when you attach a label to a range, `check_types()` assert that the type of this range will be what written in the label.
+
+It's all too abstract without an example:
+```rust
+#[test]
+fn my_test() {
+    check_types(
+        r#"
+fn main() {
+    let x = 1;
+     // ^ i32
+}
+    "#,
+    );
+}
+```
+Here, we assert that the type of the variable `x` is `i32`. Which is true, of course, so the test will pass.
+
+Oftentimes it is convenient to assert the types of all of the expressions at once, and that brings us to the last kind of test. It uses `expect-test` to match an output text:
+```rust
+#[test]
+fn my_test() {
+    check_infer(
+        r#"
+fn main() {
+    let x = 1;
+}
+    "#,
+        expect![[r#"
+            10..28 '{     ...= 1; }': ()
+            20..21 'x': i32
+            24..25 '1': i32
+        "#]],
+    );
+}
+```
+The text inside the `expect![[]]` is determined by the helper, `check_infer()` in this case. For `check_infer()`, each line is a range in the source code (the range is counted in bytes and the source is trimmed, indentation is stripped), next to it there is the text in that range, or some part of it with `...` if it's too long, and finally comes the type of that range.
+
+The important feature of `expect-test` is that it allows easy update of the expectation. Say you changed something in the code, maybe fixed a bug, and the output in `expect![[]]` needs to change. Or maybe you are writing it from scratch. Writing it by hand is very tedious and prone to mistakes. But `expect-trait` has a magic. You can set the environment variable `UPDATE_EXPECT=1`, then run the test, and it will update automatically! Some editors (e.g. VSCode) make it even more convenient: on them, on the top of every test that uses `expect-test`, next to the usual `Run | Debug` buttons, rust-analyzer also shows an `Update Expect` button. Clicking it will run that test in updating mode.
+
+## Rust code in the tests
+
+The first thing that you probably already noticed is that the Rust code in the tests is syntax highlighted! In fact, it even uses semantic highlighting. rust-analyzer highlights strings "as if" they contain Rust code if they are passed to a parameter marked `#[rust_analyzer::rust_fixture]`, and rust-analyzer test helpers do that (in fact, this was designed for them).
+
+The syntax highlighting is very important, not just because it's nice to the eye: it's very easy to make mistakes in test code, and debugging that can be very hard. Often the test will just fail, printing an `{unknown}` type, and you'll have no clue what's going wrong. The syntax is the clue; if something isn't highlighted correctly, that probably means there is an error (there is one exception to this, which we'll discuss later). You can even set the semantic highlighting tag `unresolved_reference` to e.g. red, so you will see such things clearly.
+
+Still, often you won't know what's going wrong. Why you can't fix the test, or worse, you expect it to fail but it doesn't. You can try the code on a real IDE to be sure it works. Later we'll give some tips to fix the test.
+
+### The fixture
+
+The Rust code in a test is not, a fact, a single Rust file. It has a mini-language that allows you to express multiple files, multiple crates, different configs, and more. All options are documented in `crates/test-utils/src/fixture.rs`, but here are some of the common ones:
+
+ - `//- minicore: flag1, flag2, ...`. This is by far the most common flag. Tests in rust-analyzer don't have access by default to any other type - not `Option`, not `Iterator`, not even `Sized`. This flag allows you to include parts of the `crates/test-utils/src/minicore.rs` file, which mimics `core`. All possible flags are listed at the top of `minicore` along with the flags they imply, then later you can see by `// region:flag` and `// endregion:flag` what code each flag enables.
+ - `// /path/to/file.rs crate:crate deps:dep_a,dep_b`. The first component is the filename of the code that follows (until the next file). It is required, but only if you supply this line. Other components in this line are optional. They include `crate:crate_name`, to start a new crate, or `deps:dep_a,dep_b`, to declare dependencies between crates. You can also declare modules as usual in Rust - just name your paths `/foo.rs` or `/foo/mod.rs`, declare `mod foo` and that's it!
+
+So the following snippet:
+```rust
+//- minicore: sized, fn
+// /lib.rs crate:foo
+pub mod bar;
+// /bar.rs
+pub struct Bar;
+// /main.rs crate:main deps:foo
+use foo::Bar;
+```
+Declares two crates `foo` and `main` where `main` depends on `foo`, with dependency in `Sized` and the `FnX` traits from `core`, and a module of `foo` called `bar`.
+
+And as promised, here are some tips to make your test work:
+
+ - If you use some type/trait, you must *always* include it in `minicore`. Note - not all types from core/std are available there, you can add new (under flags) if you need. And import them if they are not in the prelude.
+ - If you use unsized types (`dyn Trait`/slices), you may want to include some or all of the following `minicore` flags: `sized`, `unsize`, `coerce_unsized`, `dispatch_from_dyn`.
+ - If you use closures, consider including the `fn` minicore flag. Async closures need the `async_fn` flag.
+ - `sized` is commonly needed, consider adding it if you're stuck.

From 8265748da82be9909909930b191ead719cc760eb Mon Sep 17 00:00:00 2001
From: Maksim Bondarenkov <maksapple2306@gmail.com>
Date: Mon, 15 Sep 2025 11:07:07 +0300
Subject: [PATCH 0951/1889] opt-dist: don't set `RUST_LOG=collector=debug`

see [Zulip
discussion](https://rust-lang.zulipchat.com/#narrow/channel/122651-general/topic/opt-dist.3A.20do.20not.20set.20RUST_LOG.3Dcollector.3Ddebug.20forcefully)
---
 src/tools/opt-dist/src/training.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/tools/opt-dist/src/training.rs b/src/tools/opt-dist/src/training.rs
index 4f9352d11b12c..b3e95e087e3f1 100644
--- a/src/tools/opt-dist/src/training.rs
+++ b/src/tools/opt-dist/src/training.rs
@@ -39,7 +39,6 @@ fn init_compiler_benchmarks(
         "--exact-match",
         crates.join(",").as_str(),
     ])
-    .env("RUST_LOG", "collector=debug")
     .env("RUSTC", env.rustc_stage_0().as_str())
     .env("RUSTC_BOOTSTRAP", "1")
     .workdir(&env.rustc_perf_dir());

From b919a5f5183afb876b5206b3b23b249183cb313c Mon Sep 17 00:00:00 2001
From: tiif <pekyuan@gmail.com>
Date: Mon, 15 Sep 2025 08:57:22 +0000
Subject: [PATCH 0952/1889] Remove UnsizedConstParamTy trait and make it into
 an unstable impl

---
 .../src/deriving/bounds.rs                    | 39 -------------------
 compiler/rustc_builtin_macros/src/lib.rs      |  1 -
 compiler/rustc_hir/src/lang_items.rs          |  1 -
 .../rustc_hir_analysis/src/check/wfcheck.rs   | 13 +------
 .../src/coherence/builtin.rs                  | 15 ++-----
 library/core/src/marker.rs                    | 33 +++-------------
 library/core/src/mem/transmutability.rs       |  6 +--
 library/core/src/tuple.rs                     | 10 +----
 8 files changed, 14 insertions(+), 104 deletions(-)

diff --git a/compiler/rustc_builtin_macros/src/deriving/bounds.rs b/compiler/rustc_builtin_macros/src/deriving/bounds.rs
index dd8f0e46a0e03..63342880b0941 100644
--- a/compiler/rustc_builtin_macros/src/deriving/bounds.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/bounds.rs
@@ -51,43 +51,4 @@ pub(crate) fn expand_deriving_const_param_ty(
     };
 
     trait_def.expand(cx, mitem, item, push);
-
-    let trait_def = TraitDef {
-        span,
-        path: path_std!(marker::UnsizedConstParamTy),
-        skip_path_as_bound: false,
-        needs_copy_as_bound_if_packed: false,
-        additional_bounds: vec![ty::Ty::Path(path_std!(cmp::Eq))],
-        supports_unions: false,
-        methods: Vec::new(),
-        associated_types: Vec::new(),
-        is_const,
-        is_staged_api_crate: cx.ecfg.features.staged_api(),
-    };
-
-    trait_def.expand(cx, mitem, item, push);
-}
-
-pub(crate) fn expand_deriving_unsized_const_param_ty(
-    cx: &ExtCtxt<'_>,
-    span: Span,
-    mitem: &MetaItem,
-    item: &Annotatable,
-    push: &mut dyn FnMut(Annotatable),
-    is_const: bool,
-) {
-    let trait_def = TraitDef {
-        span,
-        path: path_std!(marker::UnsizedConstParamTy),
-        skip_path_as_bound: false,
-        needs_copy_as_bound_if_packed: false,
-        additional_bounds: vec![ty::Ty::Path(path_std!(cmp::Eq))],
-        supports_unions: false,
-        methods: Vec::new(),
-        associated_types: Vec::new(),
-        is_const,
-        is_staged_api_crate: cx.ecfg.features.staged_api(),
-    };
-
-    trait_def.expand(cx, mitem, item, push);
 }
diff --git a/compiler/rustc_builtin_macros/src/lib.rs b/compiler/rustc_builtin_macros/src/lib.rs
index 1bcea95fbb7b0..4541e2cd3b41d 100644
--- a/compiler/rustc_builtin_macros/src/lib.rs
+++ b/compiler/rustc_builtin_macros/src/lib.rs
@@ -129,7 +129,6 @@ pub fn register_builtin_macros(resolver: &mut dyn ResolverExpand) {
         Clone: clone::expand_deriving_clone,
         Copy: bounds::expand_deriving_copy,
         ConstParamTy: bounds::expand_deriving_const_param_ty,
-        UnsizedConstParamTy: bounds::expand_deriving_unsized_const_param_ty,
         Debug: debug::expand_deriving_debug,
         Default: default::expand_deriving_default,
         Eq: eq::expand_deriving_eq,
diff --git a/compiler/rustc_hir/src/lang_items.rs b/compiler/rustc_hir/src/lang_items.rs
index 67d2f15d41472..2e099a97b65be 100644
--- a/compiler/rustc_hir/src/lang_items.rs
+++ b/compiler/rustc_hir/src/lang_items.rs
@@ -370,7 +370,6 @@ language_item_table! {
     CoercePointeeValidated, sym::coerce_pointee_validated, coerce_pointee_validated_trait, Target::Trait,     GenericRequirement::Exact(0);
 
     ConstParamTy,            sym::const_param_ty,      const_param_ty_trait,       Target::Trait,          GenericRequirement::Exact(0);
-    UnsizedConstParamTy,     sym::unsized_const_param_ty, unsized_const_param_ty_trait, Target::Trait, GenericRequirement::Exact(0);
 
     Poll,                    sym::Poll,                poll,                       Target::Enum,           GenericRequirement::None;
     PollReady,               sym::Ready,               poll_ready_variant,         Target::Variant,        GenericRequirement::None;
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
index 22a9446fd4cf1..6270fb24ba709 100644
--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -819,17 +819,7 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &ty::GenericParamDef) -> Result<(), Er
             let span = tcx.def_span(param.def_id);
             let def_id = param.def_id.expect_local();
 
-            if tcx.features().unsized_const_params() {
-                enter_wf_checking_ctxt(tcx, tcx.local_parent(def_id), |wfcx| {
-                    wfcx.register_bound(
-                        ObligationCause::new(span, def_id, ObligationCauseCode::ConstParam(ty)),
-                        wfcx.param_env,
-                        ty,
-                        tcx.require_lang_item(LangItem::UnsizedConstParamTy, span),
-                    );
-                    Ok(())
-                })
-            } else if tcx.features().adt_const_params() {
+            if tcx.features().adt_const_params() {
                 enter_wf_checking_ctxt(tcx, tcx.local_parent(def_id), |wfcx| {
                     wfcx.register_bound(
                         ObligationCause::new(span, def_id, ObligationCauseCode::ConstParam(ty)),
@@ -880,7 +870,6 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &ty::GenericParamDef) -> Result<(), Er
                     tcx,
                     tcx.param_env(param.def_id),
                     ty,
-                    LangItem::ConstParamTy,
                     cause,
                 ) {
                     // Can never implement `ConstParamTy`, don't suggest anything.
diff --git a/compiler/rustc_hir_analysis/src/coherence/builtin.rs b/compiler/rustc_hir_analysis/src/coherence/builtin.rs
index 32b175611ceb5..0b9a01d6042f1 100644
--- a/compiler/rustc_hir_analysis/src/coherence/builtin.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/builtin.rs
@@ -1,7 +1,6 @@
 //! Check properties that are required by built-in traits and set
 //! up data structures required by type-checking/codegen.
 
-use std::assert_matches::assert_matches;
 use std::collections::BTreeMap;
 
 use rustc_data_structures::fx::FxHashSet;
@@ -40,10 +39,7 @@ pub(super) fn check_trait<'tcx>(
     checker.check(lang_items.async_drop_trait(), visit_implementation_of_drop)?;
     checker.check(lang_items.copy_trait(), visit_implementation_of_copy)?;
     checker.check(lang_items.const_param_ty_trait(), |checker| {
-        visit_implementation_of_const_param_ty(checker, LangItem::ConstParamTy)
-    })?;
-    checker.check(lang_items.unsized_const_param_ty_trait(), |checker| {
-        visit_implementation_of_const_param_ty(checker, LangItem::UnsizedConstParamTy)
+        visit_implementation_of_const_param_ty(checker)
     })?;
     checker.check(lang_items.coerce_unsized_trait(), visit_implementation_of_coerce_unsized)?;
     checker
@@ -138,12 +134,7 @@ fn visit_implementation_of_copy(checker: &Checker<'_>) -> Result<(), ErrorGuaran
     }
 }
 
-fn visit_implementation_of_const_param_ty(
-    checker: &Checker<'_>,
-    kind: LangItem,
-) -> Result<(), ErrorGuaranteed> {
-    assert_matches!(kind, LangItem::ConstParamTy | LangItem::UnsizedConstParamTy);
-
+fn visit_implementation_of_const_param_ty(checker: &Checker<'_>) -> Result<(), ErrorGuaranteed> {
     let tcx = checker.tcx;
     let header = checker.impl_header;
     let impl_did = checker.impl_def_id;
@@ -157,7 +148,7 @@ fn visit_implementation_of_const_param_ty(
     }
 
     let cause = traits::ObligationCause::misc(DUMMY_SP, impl_did);
-    match type_allowed_to_implement_const_param_ty(tcx, param_env, self_type, kind, cause) {
+    match type_allowed_to_implement_const_param_ty(tcx, param_env, self_type, cause) {
         Ok(()) => Ok(()),
         Err(ConstParamTyImplementationError::InfrigingFields(fields)) => {
             let span = tcx.hir_expect_item(impl_did).expect_impl().self_ty.span;
diff --git a/library/core/src/marker.rs b/library/core/src/marker.rs
index d03d7a43469a7..1c100312a9a33 100644
--- a/library/core/src/marker.rs
+++ b/library/core/src/marker.rs
@@ -1083,7 +1083,7 @@ pub trait Tuple {}
 // We name this differently than the derive macro so that the `adt_const_params` can
 // be used independently of `unsized_const_params` without requiring a full path
 // to the derive macro every time it is used. This should be renamed on stabilization.
-pub trait ConstParamTy_: UnsizedConstParamTy + StructuralPartialEq + Eq {}
+pub trait ConstParamTy_: StructuralPartialEq + Eq {}
 
 /// Derive macro generating an impl of the trait `ConstParamTy`.
 #[rustc_builtin_macro]
@@ -1093,23 +1093,6 @@ pub macro ConstParamTy($item:item) {
     /* compiler built-in */
 }
 
-#[lang = "unsized_const_param_ty"]
-#[unstable(feature = "unsized_const_params", issue = "95174")]
-#[diagnostic::on_unimplemented(message = "`{Self}` can't be used as a const parameter type")]
-/// A marker for types which can be used as types of `const` generic parameters.
-///
-/// Equivalent to [`ConstParamTy_`] except that this is used by
-/// the `unsized_const_params` to allow for fake unstable impls.
-pub trait UnsizedConstParamTy: StructuralPartialEq + Eq {}
-
-/// Derive macro generating an impl of the trait `ConstParamTy`.
-#[rustc_builtin_macro]
-#[allow_internal_unstable(unsized_const_params)]
-#[unstable(feature = "unsized_const_params", issue = "95174")]
-pub macro UnsizedConstParamTy($item:item) {
-    /* compiler built-in */
-}
-
 // FIXME(adt_const_params): handle `ty::FnDef`/`ty::Closure`
 marker_impls! {
     #[unstable(feature = "adt_const_params", issue = "95174")]
@@ -1124,17 +1107,11 @@ marker_impls! {
 
 marker_impls! {
     #[unstable(feature = "unsized_const_params", issue = "95174")]
-    UnsizedConstParamTy for
-        usize, u8, u16, u32, u64, u128,
-        isize, i8, i16, i32, i64, i128,
-        bool,
-        char,
-        (),
-        {T: UnsizedConstParamTy, const N: usize} [T; N],
-
+    #[unstable_feature_bound(unsized_const_params)]
+    ConstParamTy_ for
         str,
-        {T: UnsizedConstParamTy} [T],
-        {T: UnsizedConstParamTy + ?Sized} &T,
+        {T: ConstParamTy_} [T],
+        {T: ConstParamTy_ + ?Sized} &T,
 }
 
 /// A common trait implemented by all function pointers.
diff --git a/library/core/src/mem/transmutability.rs b/library/core/src/mem/transmutability.rs
index 782b826448a32..f36cb8cddb837 100644
--- a/library/core/src/mem/transmutability.rs
+++ b/library/core/src/mem/transmutability.rs
@@ -1,4 +1,4 @@
-use crate::marker::{ConstParamTy_, UnsizedConstParamTy};
+use crate::marker::ConstParamTy_;
 
 /// Marks that `Src` is transmutable into `Self`.
 ///
@@ -83,6 +83,7 @@ use crate::marker::{ConstParamTy_, UnsizedConstParamTy};
 /// Furthermore, stability does not imply portability. For example, the size of
 /// `usize` is stable, but not portable.
 #[unstable(feature = "transmutability", issue = "99571")]
+#[unstable_feature_bound(transmutability)]
 #[lang = "transmute_trait"]
 #[rustc_deny_explicit_impl]
 #[rustc_do_not_implement_via_object]
@@ -288,9 +289,8 @@ pub struct Assume {
 }
 
 #[unstable(feature = "transmutability", issue = "99571")]
+#[unstable_feature_bound(transmutability)]
 impl ConstParamTy_ for Assume {}
-#[unstable(feature = "transmutability", issue = "99571")]
-impl UnsizedConstParamTy for Assume {}
 
 impl Assume {
     /// With this, [`TransmuteFrom`] does not assume you have ensured any safety
diff --git a/library/core/src/tuple.rs b/library/core/src/tuple.rs
index 3892f83107690..c57a8d81ade18 100644
--- a/library/core/src/tuple.rs
+++ b/library/core/src/tuple.rs
@@ -1,7 +1,7 @@
 // See core/src/primitive_docs.rs for documentation.
 
 use crate::cmp::Ordering::{self, *};
-use crate::marker::{ConstParamTy_, StructuralPartialEq, UnsizedConstParamTy};
+use crate::marker::{ConstParamTy_, StructuralPartialEq};
 use crate::ops::ControlFlow::{self, Break, Continue};
 
 // Recursive macro for implementing n-ary tuple functions and operations
@@ -47,17 +47,11 @@ macro_rules! tuple_impls {
         maybe_tuple_doc! {
             $($T)+ @
             #[unstable(feature = "adt_const_params", issue = "95174")]
+            #[unstable_feature_bound(unsized_const_params)]
             impl<$($T: ConstParamTy_),+> ConstParamTy_ for ($($T,)+)
             {}
         }
 
-        maybe_tuple_doc! {
-            $($T)+ @
-            #[unstable(feature = "unsized_const_params", issue = "95174")]
-            impl<$($T: UnsizedConstParamTy),+> UnsizedConstParamTy for ($($T,)+)
-            {}
-        }
-
         maybe_tuple_doc! {
             $($T)+ @
             #[unstable(feature = "structural_match", issue = "31434")]

From 1a02cd531d6b5ff154078208daf7816b1657f389 Mon Sep 17 00:00:00 2001
From: tiif <pekyuan@gmail.com>
Date: Mon, 15 Sep 2025 08:59:19 +0000
Subject: [PATCH 0953/1889] Add check to make sure ConstParamTy impls of
 certain types are gated with #[unstable_feature_bound(unsized_const_params)]

---
 .../rustc_trait_selection/src/traits/misc.rs  | 38 +++++++++++--------
 1 file changed, 23 insertions(+), 15 deletions(-)

diff --git a/compiler/rustc_trait_selection/src/traits/misc.rs b/compiler/rustc_trait_selection/src/traits/misc.rs
index 393f458bea273..4c25882daa92f 100644
--- a/compiler/rustc_trait_selection/src/traits/misc.rs
+++ b/compiler/rustc_trait_selection/src/traits/misc.rs
@@ -1,15 +1,14 @@
 //! Miscellaneous type-system utilities that are too small to deserve their own modules.
 
-use std::assert_matches::assert_matches;
-
 use hir::LangItem;
 use rustc_ast::Mutability;
 use rustc_hir as hir;
 use rustc_infer::infer::{RegionResolutionError, TyCtxtInferExt};
 use rustc_middle::ty::{self, AdtDef, Ty, TyCtxt, TypeVisitableExt, TypingMode};
+use rustc_span::sym;
 
 use crate::regions::InferCtxtRegionExt;
-use crate::traits::{self, FulfillmentError, ObligationCause};
+use crate::traits::{self, FulfillmentError, Obligation, ObligationCause};
 
 pub enum CopyImplementationError<'tcx> {
     InfringingFields(Vec<(&'tcx ty::FieldDef, Ty<'tcx>, InfringingFieldsReason<'tcx>)>),
@@ -98,10 +97,9 @@ pub fn type_allowed_to_implement_const_param_ty<'tcx>(
     tcx: TyCtxt<'tcx>,
     param_env: ty::ParamEnv<'tcx>,
     self_type: Ty<'tcx>,
-    lang_item: LangItem,
     parent_cause: ObligationCause<'tcx>,
 ) -> Result<(), ConstParamTyImplementationError<'tcx>> {
-    assert_matches!(lang_item, LangItem::ConstParamTy | LangItem::UnsizedConstParamTy);
+    let mut need_unstable_feature_bound = false;
 
     let inner_tys: Vec<_> = match *self_type.kind() {
         // Trivially okay as these types are all:
@@ -112,18 +110,14 @@ pub fn type_allowed_to_implement_const_param_ty<'tcx>(
 
         // Handle types gated under `feature(unsized_const_params)`
         // FIXME(unsized_const_params): Make `const N: [u8]` work then forbid references
-        ty::Slice(inner_ty) | ty::Ref(_, inner_ty, Mutability::Not)
-            if lang_item == LangItem::UnsizedConstParamTy =>
-        {
+        ty::Slice(inner_ty) | ty::Ref(_, inner_ty, Mutability::Not) => {
+            need_unstable_feature_bound = true;
             vec![inner_ty]
         }
-        ty::Str if lang_item == LangItem::UnsizedConstParamTy => {
+        ty::Str => {
+            need_unstable_feature_bound = true;
             vec![Ty::new_slice(tcx, tcx.types.u8)]
         }
-        ty::Str | ty::Slice(..) | ty::Ref(_, _, Mutability::Not) => {
-            return Err(ConstParamTyImplementationError::UnsizedConstParamsFeatureRequired);
-        }
-
         ty::Array(inner_ty, _) => vec![inner_ty],
 
         // `str` morally acts like a newtype around `[u8]`
@@ -137,7 +131,7 @@ pub fn type_allowed_to_implement_const_param_ty<'tcx>(
                 adt,
                 args,
                 parent_cause.clone(),
-                lang_item,
+                LangItem::ConstParamTy,
             )
             .map_err(ConstParamTyImplementationError::InfrigingFields)?;
 
@@ -153,11 +147,25 @@ pub fn type_allowed_to_implement_const_param_ty<'tcx>(
         let infcx = tcx.infer_ctxt().build(TypingMode::non_body_analysis());
         let ocx = traits::ObligationCtxt::new_with_diagnostics(&infcx);
 
+        // Make sure impls certain types are gated with #[unstable_feature_bound(unsized_const_params)]
+        if need_unstable_feature_bound {
+            ocx.register_obligation(Obligation::new(
+                tcx,
+                parent_cause.clone(),
+                param_env,
+                ty::ClauseKind::UnstableFeature(sym::unsized_const_params),
+            ));
+
+            if !ocx.select_all_or_error().is_empty() {
+                return Err(ConstParamTyImplementationError::UnsizedConstParamsFeatureRequired);
+            }
+        }
+
         ocx.register_bound(
             parent_cause.clone(),
             param_env,
             inner_ty,
-            tcx.require_lang_item(lang_item, parent_cause.span),
+            tcx.require_lang_item(LangItem::ConstParamTy, parent_cause.span),
         );
 
         let errors = ocx.select_all_or_error();

From 0bd2ee3a0c260894eb92f5f0f5f8dd56182cda3f Mon Sep 17 00:00:00 2001
From: tiif <pekyuan@gmail.com>
Date: Mon, 15 Sep 2025 09:01:22 +0000
Subject: [PATCH 0954/1889] Fix the testcases to not use UnsizedConstParamTy

---
 .../auxiliary/unsized_const_param.rs          |  2 +-
 .../adt_const_params/const_param_ty_bad.rs    |  2 +-
 .../const_param_ty_bad.stderr                 | 42 ++++++-------
 .../const_param_ty_dyn_compatibility.rs       |  5 +-
 .../const_param_ty_dyn_compatibility.stderr   | 19 +-----
 ...nst_param_ty_generic_bounds_do_not_hold.rs |  2 +-
 ...param_ty_generic_bounds_do_not_hold.stderr | 24 +++----
 .../adt_const_params/const_param_ty_good.rs   |  8 +--
 .../const_param_ty_impl_bad_field.rs          |  4 +-
 .../const_param_ty_impl_bad_field.stderr      | 10 +--
 .../const_param_ty_impl_no_structural_eq.rs   |  8 +--
 ...onst_param_ty_impl_no_structural_eq.stderr | 28 ++++-----
 .../const_param_ty_impl_union.rs              |  4 +-
 .../const_param_ty_impl_union.stderr          | 10 +--
 .../nested_bad_const_param_ty.rs              |  3 -
 .../nested_bad_const_param_ty.stderr          | 63 +++----------------
 .../non_valtreeable_const_arg-2.stderr        |  6 +-
 .../reference_pointee_is_const_param-1.rs     |  4 +-
 .../reference_pointee_is_const_param-1.stderr |  6 +-
 .../reference_pointee_is_const_param-2.rs     |  4 +-
 .../reference_pointee_is_const_param-2.stderr |  6 +-
 .../trait_objects_as_a_const_generic.rs       |  4 +-
 .../trait_objects_as_a_const_generic.stderr   |  6 +-
 .../adt_const_params/unsized_field-1.rs       |  5 +-
 .../adt_const_params/unsized_field-1.stderr   | 28 +++++++--
 .../adt_const_params/unsized_field-2.rs       | 14 -----
 .../adt_const_params/unsized_field-2.stderr   | 27 --------
 .../unsizing-wfcheck-issue-126272.rs          |  1 -
 .../unsizing-wfcheck-issue-126272.stderr      | 51 +++++++--------
 ...const-param-with-additional-obligations.rs |  4 +-
 .../no_const_param_ty_bound.stderr            |  2 +-
 tests/ui/const-generics/issue-66451.rs        |  6 +-
 .../issues/issue-63322-forbid-dyn.full.stderr |  2 +-
 ...nst-param-mismatch.adt_const_params.stderr | 22 ++++---
 tests/ui/const-generics/slice-const-param.rs  |  2 +-
 ...m-static-reference.adt_const_params.stderr | 12 ++--
 .../transmute-const-param-static-reference.rs |  2 +-
 .../symbol_mangling_v0_str.rs                 |  4 +-
 .../feature-gate-unsized-const-params.rs      | 10 +--
 .../feature-gate-unsized-const-params.stderr  | 19 +++---
 .../ui/layout/thaw-transmute-invalid-enum.rs  |  1 +
 .../layout/thaw-transmute-invalid-enum.stderr | 19 ++++--
 .../const-generics-structural-demangling.rs   |  8 +--
 43 files changed, 218 insertions(+), 291 deletions(-)
 delete mode 100644 tests/ui/const-generics/adt_const_params/unsized_field-2.rs
 delete mode 100644 tests/ui/const-generics/adt_const_params/unsized_field-2.stderr

diff --git a/tests/ui/const-generics/adt_const_params/auxiliary/unsized_const_param.rs b/tests/ui/const-generics/adt_const_params/auxiliary/unsized_const_param.rs
index e2ba459f8dd33..1bfd7c3465613 100644
--- a/tests/ui/const-generics/adt_const_params/auxiliary/unsized_const_param.rs
+++ b/tests/ui/const-generics/adt_const_params/auxiliary/unsized_const_param.rs
@@ -1,6 +1,6 @@
 #![feature(adt_const_params, unsized_const_params)]
 
-#[derive(std::marker::UnsizedConstParamTy, Eq, PartialEq)]
+#[derive(std::marker::ConstParamTy, Eq, PartialEq)]
 pub struct Foo([u8]);
 
 #[derive(std::marker::ConstParamTy, Eq, PartialEq)]
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_bad.rs b/tests/ui/const-generics/adt_const_params/const_param_ty_bad.rs
index 35539193a2787..d482e7fad06d2 100644
--- a/tests/ui/const-generics/adt_const_params/const_param_ty_bad.rs
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_bad.rs
@@ -1,7 +1,7 @@
 #![allow(incomplete_features)]
 #![feature(adt_const_params, unsized_const_params)]
 
-fn check(_: impl std::marker::UnsizedConstParamTy) {}
+fn check(_: impl std::marker::ConstParamTy_) {}
 
 fn main() {
     check(main); //~ error: `fn() {main}` can't be used as a const parameter type
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_bad.stderr b/tests/ui/const-generics/adt_const_params/const_param_ty_bad.stderr
index c05584ef909ac..ff514f5608f19 100644
--- a/tests/ui/const-generics/adt_const_params/const_param_ty_bad.stderr
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_bad.stderr
@@ -2,15 +2,15 @@ error[E0277]: `fn() {main}` can't be used as a const parameter type
   --> $DIR/const_param_ty_bad.rs:7:11
    |
 LL |     check(main);
-   |     ----- ^^^^ the trait `UnsizedConstParamTy` is not implemented for fn item `fn() {main}`
+   |     ----- ^^^^ the trait `ConstParamTy_` is not implemented for fn item `fn() {main}`
    |     |
    |     required by a bound introduced by this call
    |
 note: required by a bound in `check`
   --> $DIR/const_param_ty_bad.rs:4:18
    |
-LL | fn check(_: impl std::marker::UnsizedConstParamTy) {}
-   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
+LL | fn check(_: impl std::marker::ConstParamTy_) {}
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
 help: use parentheses to call this function
    |
 LL |     check(main());
@@ -24,12 +24,12 @@ LL |     check(|| {});
    |     |
    |     required by a bound introduced by this call
    |
-   = help: the trait `UnsizedConstParamTy` is not implemented for closure `{closure@$DIR/const_param_ty_bad.rs:8:11: 8:13}`
+   = help: the trait `ConstParamTy_` is not implemented for closure `{closure@$DIR/const_param_ty_bad.rs:8:11: 8:13}`
 note: required by a bound in `check`
   --> $DIR/const_param_ty_bad.rs:4:18
    |
-LL | fn check(_: impl std::marker::UnsizedConstParamTy) {}
-   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
+LL | fn check(_: impl std::marker::ConstParamTy_) {}
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
 help: use parentheses to call this closure
    |
 LL -     check(|| {});
@@ -40,15 +40,15 @@ error[E0277]: `fn()` can't be used as a const parameter type
   --> $DIR/const_param_ty_bad.rs:9:11
    |
 LL |     check(main as fn());
-   |     ----- ^^^^^^^^^^^^ the trait `UnsizedConstParamTy` is not implemented for `fn()`
+   |     ----- ^^^^^^^^^^^^ the trait `ConstParamTy_` is not implemented for `fn()`
    |     |
    |     required by a bound introduced by this call
    |
 note: required by a bound in `check`
   --> $DIR/const_param_ty_bad.rs:4:18
    |
-LL | fn check(_: impl std::marker::UnsizedConstParamTy) {}
-   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
+LL | fn check(_: impl std::marker::ConstParamTy_) {}
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
 help: use parentheses to call this function pointer
    |
 LL |     check(main as fn()());
@@ -58,16 +58,16 @@ error[E0277]: `&mut ()` can't be used as a const parameter type
   --> $DIR/const_param_ty_bad.rs:10:11
    |
 LL |     check(&mut ());
-   |     ----- ^^^^^^^ the trait `UnsizedConstParamTy` is not implemented for `&mut ()`
+   |     ----- ^^^^^^^ the trait `ConstParamTy_` is not implemented for `&mut ()`
    |     |
    |     required by a bound introduced by this call
    |
-   = note: `UnsizedConstParamTy` is implemented for `&()`, but not for `&mut ()`
+   = note: `ConstParamTy_` is implemented for `&()`, but not for `&mut ()`
 note: required by a bound in `check`
   --> $DIR/const_param_ty_bad.rs:4:18
    |
-LL | fn check(_: impl std::marker::UnsizedConstParamTy) {}
-   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
+LL | fn check(_: impl std::marker::ConstParamTy_) {}
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
 help: consider removing the leading `&`-reference
    |
 LL -     check(&mut ());
@@ -78,31 +78,31 @@ error[E0277]: `*mut ()` can't be used as a const parameter type
   --> $DIR/const_param_ty_bad.rs:11:11
    |
 LL |     check(&mut () as *mut ());
-   |     ----- ^^^^^^^^^^^^^^^^^^ the trait `UnsizedConstParamTy` is not implemented for `*mut ()`
+   |     ----- ^^^^^^^^^^^^^^^^^^ the trait `ConstParamTy_` is not implemented for `*mut ()`
    |     |
    |     required by a bound introduced by this call
    |
-   = help: the trait `UnsizedConstParamTy` is implemented for `()`
+   = help: the trait `ConstParamTy_` is implemented for `()`
 note: required by a bound in `check`
   --> $DIR/const_param_ty_bad.rs:4:18
    |
-LL | fn check(_: impl std::marker::UnsizedConstParamTy) {}
-   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
+LL | fn check(_: impl std::marker::ConstParamTy_) {}
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
 
 error[E0277]: `*const ()` can't be used as a const parameter type
   --> $DIR/const_param_ty_bad.rs:12:11
    |
 LL |     check(&() as *const ());
-   |     ----- ^^^^^^^^^^^^^^^^ the trait `UnsizedConstParamTy` is not implemented for `*const ()`
+   |     ----- ^^^^^^^^^^^^^^^^ the trait `ConstParamTy_` is not implemented for `*const ()`
    |     |
    |     required by a bound introduced by this call
    |
-   = help: the trait `UnsizedConstParamTy` is implemented for `()`
+   = help: the trait `ConstParamTy_` is implemented for `()`
 note: required by a bound in `check`
   --> $DIR/const_param_ty_bad.rs:4:18
    |
-LL | fn check(_: impl std::marker::UnsizedConstParamTy) {}
-   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
+LL | fn check(_: impl std::marker::ConstParamTy_) {}
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
 
 error: aborting due to 6 previous errors
 
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_dyn_compatibility.rs b/tests/ui/const-generics/adt_const_params/const_param_ty_dyn_compatibility.rs
index 6a553c2e08540..2fcf872c99aaf 100644
--- a/tests/ui/const-generics/adt_const_params/const_param_ty_dyn_compatibility.rs
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_dyn_compatibility.rs
@@ -1,12 +1,9 @@
 #![feature(adt_const_params, unsized_const_params)]
 #![allow(incomplete_features)]
 
-use std::marker::{ConstParamTy_, UnsizedConstParamTy};
+use std::marker::ConstParamTy_;
 
 fn foo(a: &dyn ConstParamTy_) {}
 //~^ ERROR: the trait `ConstParamTy_`
 
-fn bar(a: &dyn UnsizedConstParamTy) {}
-//~^ ERROR: the trait `UnsizedConstParamTy`
-
 fn main() {}
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_dyn_compatibility.stderr b/tests/ui/const-generics/adt_const_params/const_param_ty_dyn_compatibility.stderr
index c71ec24dda330..ce695ff66d58c 100644
--- a/tests/ui/const-generics/adt_const_params/const_param_ty_dyn_compatibility.stderr
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_dyn_compatibility.stderr
@@ -15,23 +15,6 @@ LL - fn foo(a: &dyn ConstParamTy_) {}
 LL + fn foo(a: &impl ConstParamTy_) {}
    |
 
-error[E0038]: the trait `UnsizedConstParamTy` is not dyn compatible
-  --> $DIR/const_param_ty_dyn_compatibility.rs:9:16
-   |
-LL | fn bar(a: &dyn UnsizedConstParamTy) {}
-   |                ^^^^^^^^^^^^^^^^^^^ `UnsizedConstParamTy` is not dyn compatible
-   |
-note: for a trait to be dyn compatible it needs to allow building a vtable
-      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $SRC_DIR/core/src/cmp.rs:LL:COL
-   |
-   = note: the trait is not dyn compatible because it uses `Self` as a type parameter
-help: consider using an opaque type instead
-   |
-LL - fn bar(a: &dyn UnsizedConstParamTy) {}
-LL + fn bar(a: &impl UnsizedConstParamTy) {}
-   |
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_generic_bounds_do_not_hold.rs b/tests/ui/const-generics/adt_const_params/const_param_ty_generic_bounds_do_not_hold.rs
index 7ffdafa33e938..a86d74275de8a 100644
--- a/tests/ui/const-generics/adt_const_params/const_param_ty_generic_bounds_do_not_hold.rs
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_generic_bounds_do_not_hold.rs
@@ -4,7 +4,7 @@
 #[derive(PartialEq, Eq)]
 struct NotParam;
 
-fn check<T: std::marker::UnsizedConstParamTy + ?Sized>() {}
+fn check<T: std::marker::ConstParamTy_ + ?Sized>() {}
 
 fn main() {
     check::<&NotParam>(); //~ error: `NotParam` can't be used as a const parameter type
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_generic_bounds_do_not_hold.stderr b/tests/ui/const-generics/adt_const_params/const_param_ty_generic_bounds_do_not_hold.stderr
index 158e76630f3a3..ca2aa3adcb7a6 100644
--- a/tests/ui/const-generics/adt_const_params/const_param_ty_generic_bounds_do_not_hold.stderr
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_generic_bounds_do_not_hold.stderr
@@ -4,17 +4,17 @@ error[E0277]: `NotParam` can't be used as a const parameter type
 LL |     check::<&NotParam>();
    |             ^^^^^^^^^ unsatisfied trait bound
    |
-help: the trait `UnsizedConstParamTy` is not implemented for `NotParam`
+help: the trait `ConstParamTy_` is not implemented for `NotParam`
   --> $DIR/const_param_ty_generic_bounds_do_not_hold.rs:5:1
    |
 LL | struct NotParam;
    | ^^^^^^^^^^^^^^^
-   = note: required for `&NotParam` to implement `UnsizedConstParamTy`
+   = note: required for `&NotParam` to implement `ConstParamTy_`
 note: required by a bound in `check`
   --> $DIR/const_param_ty_generic_bounds_do_not_hold.rs:7:13
    |
-LL | fn check<T: std::marker::UnsizedConstParamTy + ?Sized>() {}
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
+LL | fn check<T: std::marker::ConstParamTy_ + ?Sized>() {}
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
 
 error[E0277]: `NotParam` can't be used as a const parameter type
   --> $DIR/const_param_ty_generic_bounds_do_not_hold.rs:11:13
@@ -22,17 +22,17 @@ error[E0277]: `NotParam` can't be used as a const parameter type
 LL |     check::<[NotParam]>();
    |             ^^^^^^^^^^ unsatisfied trait bound
    |
-help: the trait `UnsizedConstParamTy` is not implemented for `NotParam`
+help: the trait `ConstParamTy_` is not implemented for `NotParam`
   --> $DIR/const_param_ty_generic_bounds_do_not_hold.rs:5:1
    |
 LL | struct NotParam;
    | ^^^^^^^^^^^^^^^
-   = note: required for `[NotParam]` to implement `UnsizedConstParamTy`
+   = note: required for `[NotParam]` to implement `ConstParamTy_`
 note: required by a bound in `check`
   --> $DIR/const_param_ty_generic_bounds_do_not_hold.rs:7:13
    |
-LL | fn check<T: std::marker::UnsizedConstParamTy + ?Sized>() {}
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
+LL | fn check<T: std::marker::ConstParamTy_ + ?Sized>() {}
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
 
 error[E0277]: `NotParam` can't be used as a const parameter type
   --> $DIR/const_param_ty_generic_bounds_do_not_hold.rs:12:13
@@ -40,17 +40,17 @@ error[E0277]: `NotParam` can't be used as a const parameter type
 LL |     check::<[NotParam; 17]>();
    |             ^^^^^^^^^^^^^^ unsatisfied trait bound
    |
-help: the trait `UnsizedConstParamTy` is not implemented for `NotParam`
+help: the trait `ConstParamTy_` is not implemented for `NotParam`
   --> $DIR/const_param_ty_generic_bounds_do_not_hold.rs:5:1
    |
 LL | struct NotParam;
    | ^^^^^^^^^^^^^^^
-   = note: required for `[NotParam; 17]` to implement `UnsizedConstParamTy`
+   = note: required for `[NotParam; 17]` to implement `ConstParamTy_`
 note: required by a bound in `check`
   --> $DIR/const_param_ty_generic_bounds_do_not_hold.rs:7:13
    |
-LL | fn check<T: std::marker::UnsizedConstParamTy + ?Sized>() {}
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
+LL | fn check<T: std::marker::ConstParamTy_ + ?Sized>() {}
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_good.rs b/tests/ui/const-generics/adt_const_params/const_param_ty_good.rs
index 98a8eb6ee950d..24bbc5a9a2389 100644
--- a/tests/ui/const-generics/adt_const_params/const_param_ty_good.rs
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_good.rs
@@ -3,7 +3,7 @@
 #![feature(adt_const_params, unsized_const_params)]
 #![allow(incomplete_features)]
 
-use std::marker::UnsizedConstParamTy;
+use std::marker::{ConstParamTy, ConstParamTy_};
 
 #[derive(PartialEq, Eq)]
 struct S<T> {
@@ -11,15 +11,15 @@ struct S<T> {
     gen: T,
 }
 
-impl<T: UnsizedConstParamTy> UnsizedConstParamTy for S<T> {}
+impl<T: ConstParamTy_> ConstParamTy_ for S<T> {}
 
-#[derive(PartialEq, Eq, UnsizedConstParamTy)]
+#[derive(PartialEq, Eq, ConstParamTy)]
 struct D<T> {
     field: u8,
     gen: T,
 }
 
-fn check<T: UnsizedConstParamTy + ?Sized>() {}
+fn check<T: ConstParamTy_ + ?Sized>() {}
 
 fn main() {
     check::<u8>();
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_impl_bad_field.rs b/tests/ui/const-generics/adt_const_params/const_param_ty_impl_bad_field.rs
index 8b3d0546010dc..0614ea97b1add 100644
--- a/tests/ui/const-generics/adt_const_params/const_param_ty_impl_bad_field.rs
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_impl_bad_field.rs
@@ -7,10 +7,10 @@ struct NotParam;
 #[derive(PartialEq, Eq)]
 struct CantParam(NotParam);
 
-impl std::marker::UnsizedConstParamTy for CantParam {}
+impl std::marker::ConstParamTy_ for CantParam {}
 //~^ error: the trait `ConstParamTy_` cannot be implemented for this type
 
-#[derive(std::marker::UnsizedConstParamTy, Eq, PartialEq)]
+#[derive(std::marker::ConstParamTy, Eq, PartialEq)]
 //~^ error: the trait `ConstParamTy_` cannot be implemented for this type
 struct CantParamDerive(NotParam);
 
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_impl_bad_field.stderr b/tests/ui/const-generics/adt_const_params/const_param_ty_impl_bad_field.stderr
index a4e5736d83429..fd1836802c4ae 100644
--- a/tests/ui/const-generics/adt_const_params/const_param_ty_impl_bad_field.stderr
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_impl_bad_field.stderr
@@ -1,17 +1,17 @@
 error[E0204]: the trait `ConstParamTy_` cannot be implemented for this type
-  --> $DIR/const_param_ty_impl_bad_field.rs:10:43
+  --> $DIR/const_param_ty_impl_bad_field.rs:10:37
    |
 LL | struct CantParam(NotParam);
    |                  -------- this field does not implement `ConstParamTy_`
 LL |
-LL | impl std::marker::UnsizedConstParamTy for CantParam {}
-   |                                           ^^^^^^^^^
+LL | impl std::marker::ConstParamTy_ for CantParam {}
+   |                                     ^^^^^^^^^
 
 error[E0204]: the trait `ConstParamTy_` cannot be implemented for this type
   --> $DIR/const_param_ty_impl_bad_field.rs:13:10
    |
-LL | #[derive(std::marker::UnsizedConstParamTy, Eq, PartialEq)]
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #[derive(std::marker::ConstParamTy, Eq, PartialEq)]
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^
 LL |
 LL | struct CantParamDerive(NotParam);
    |                        -------- this field does not implement `ConstParamTy_`
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_impl_no_structural_eq.rs b/tests/ui/const-generics/adt_const_params/const_param_ty_impl_no_structural_eq.rs
index e743b78fd134b..a1c8eccfb095f 100644
--- a/tests/ui/const-generics/adt_const_params/const_param_ty_impl_no_structural_eq.rs
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_impl_no_structural_eq.rs
@@ -3,20 +3,20 @@
 
 #[derive(PartialEq, Eq)]
 struct ImplementsConstParamTy;
-impl std::marker::UnsizedConstParamTy for ImplementsConstParamTy {}
+impl std::marker::ConstParamTy_ for ImplementsConstParamTy {}
 
 struct CantParam(ImplementsConstParamTy);
 
-impl std::marker::UnsizedConstParamTy for CantParam {}
+impl std::marker::ConstParamTy_ for CantParam {}
 //~^ error: the type `CantParam` does not `#[derive(PartialEq)]`
 //~| ERROR the trait bound `CantParam: Eq` is not satisfied
 
-#[derive(std::marker::UnsizedConstParamTy)]
+#[derive(std::marker::ConstParamTy)]
 //~^ error: the type `CantParamDerive` does not `#[derive(PartialEq)]`
 //~| ERROR the trait bound `CantParamDerive: Eq` is not satisfied
 struct CantParamDerive(ImplementsConstParamTy);
 
-fn check<T: std::marker::UnsizedConstParamTy>() {}
+fn check<T: std::marker::ConstParamTy_>() {}
 
 fn main() {
     check::<ImplementsConstParamTy>();
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_impl_no_structural_eq.stderr b/tests/ui/const-generics/adt_const_params/const_param_ty_impl_no_structural_eq.stderr
index d3141381db8cf..c6b791ed9674a 100644
--- a/tests/ui/const-generics/adt_const_params/const_param_ty_impl_no_structural_eq.stderr
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_impl_no_structural_eq.stderr
@@ -1,10 +1,10 @@
 error[E0277]: the trait bound `CantParam: Eq` is not satisfied
-  --> $DIR/const_param_ty_impl_no_structural_eq.rs:10:43
+  --> $DIR/const_param_ty_impl_no_structural_eq.rs:10:37
    |
-LL | impl std::marker::UnsizedConstParamTy for CantParam {}
-   |                                           ^^^^^^^^^ the trait `Eq` is not implemented for `CantParam`
+LL | impl std::marker::ConstParamTy_ for CantParam {}
+   |                                     ^^^^^^^^^ the trait `Eq` is not implemented for `CantParam`
    |
-note: required by a bound in `UnsizedConstParamTy`
+note: required by a bound in `ConstParamTy_`
   --> $SRC_DIR/core/src/marker.rs:LL:COL
 help: consider annotating `CantParam` with `#[derive(Eq)]`
    |
@@ -13,26 +13,26 @@ LL | struct CantParam(ImplementsConstParamTy);
    |
 
 error[E0277]: the type `CantParam` does not `#[derive(PartialEq)]`
-  --> $DIR/const_param_ty_impl_no_structural_eq.rs:10:43
+  --> $DIR/const_param_ty_impl_no_structural_eq.rs:10:37
    |
-LL | impl std::marker::UnsizedConstParamTy for CantParam {}
-   |                                           ^^^^^^^^^ unsatisfied trait bound
+LL | impl std::marker::ConstParamTy_ for CantParam {}
+   |                                     ^^^^^^^^^ unsatisfied trait bound
    |
 help: the trait `StructuralPartialEq` is not implemented for `CantParam`
   --> $DIR/const_param_ty_impl_no_structural_eq.rs:8:1
    |
 LL | struct CantParam(ImplementsConstParamTy);
    | ^^^^^^^^^^^^^^^^
-note: required by a bound in `UnsizedConstParamTy`
+note: required by a bound in `ConstParamTy_`
   --> $SRC_DIR/core/src/marker.rs:LL:COL
 
 error[E0277]: the trait bound `CantParamDerive: Eq` is not satisfied
   --> $DIR/const_param_ty_impl_no_structural_eq.rs:14:10
    |
-LL | #[derive(std::marker::UnsizedConstParamTy)]
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Eq` is not implemented for `CantParamDerive`
+LL | #[derive(std::marker::ConstParamTy)]
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Eq` is not implemented for `CantParamDerive`
    |
-note: required by a bound in `UnsizedConstParamTy`
+note: required by a bound in `ConstParamTy_`
   --> $SRC_DIR/core/src/marker.rs:LL:COL
 help: consider annotating `CantParamDerive` with `#[derive(Eq)]`
    |
@@ -43,15 +43,15 @@ LL | struct CantParamDerive(ImplementsConstParamTy);
 error[E0277]: the type `CantParamDerive` does not `#[derive(PartialEq)]`
   --> $DIR/const_param_ty_impl_no_structural_eq.rs:14:10
    |
-LL | #[derive(std::marker::UnsizedConstParamTy)]
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ unsatisfied trait bound
+LL | #[derive(std::marker::ConstParamTy)]
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^ unsatisfied trait bound
    |
 help: the trait `StructuralPartialEq` is not implemented for `CantParamDerive`
   --> $DIR/const_param_ty_impl_no_structural_eq.rs:17:1
    |
 LL | struct CantParamDerive(ImplementsConstParamTy);
    | ^^^^^^^^^^^^^^^^^^^^^^
-note: required by a bound in `UnsizedConstParamTy`
+note: required by a bound in `ConstParamTy_`
   --> $SRC_DIR/core/src/marker.rs:LL:COL
 
 error: aborting due to 4 previous errors
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_impl_union.rs b/tests/ui/const-generics/adt_const_params/const_param_ty_impl_union.rs
index 236b3bc162aaa..0c9b12805f757 100644
--- a/tests/ui/const-generics/adt_const_params/const_param_ty_impl_union.rs
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_impl_union.rs
@@ -12,10 +12,10 @@ impl PartialEq for Union {
 }
 impl Eq for Union {}
 
-impl std::marker::UnsizedConstParamTy for Union {}
+impl std::marker::ConstParamTy_ for Union {}
 //~^ ERROR the trait `ConstParamTy` may not be implemented for this type
 
-#[derive(std::marker::UnsizedConstParamTy)]
+#[derive(std::marker::ConstParamTy)]
 //~^ ERROR this trait cannot be derived for unions
 union UnionDerive {
     a: u8,
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_impl_union.stderr b/tests/ui/const-generics/adt_const_params/const_param_ty_impl_union.stderr
index 837c289c9248f..cc2147b49aea5 100644
--- a/tests/ui/const-generics/adt_const_params/const_param_ty_impl_union.stderr
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_impl_union.stderr
@@ -1,14 +1,14 @@
 error: this trait cannot be derived for unions
   --> $DIR/const_param_ty_impl_union.rs:18:10
    |
-LL | #[derive(std::marker::UnsizedConstParamTy)]
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #[derive(std::marker::ConstParamTy)]
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the trait `ConstParamTy` may not be implemented for this type
-  --> $DIR/const_param_ty_impl_union.rs:15:43
+  --> $DIR/const_param_ty_impl_union.rs:15:37
    |
-LL | impl std::marker::UnsizedConstParamTy for Union {}
-   |                                           ^^^^^ type is not a structure or enumeration
+LL | impl std::marker::ConstParamTy_ for Union {}
+   |                                     ^^^^^ type is not a structure or enumeration
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/const-generics/adt_const_params/nested_bad_const_param_ty.rs b/tests/ui/const-generics/adt_const_params/nested_bad_const_param_ty.rs
index 34ea143d25462..d42ef90e1b180 100644
--- a/tests/ui/const-generics/adt_const_params/nested_bad_const_param_ty.rs
+++ b/tests/ui/const-generics/adt_const_params/nested_bad_const_param_ty.rs
@@ -5,17 +5,14 @@ use std::marker::ConstParamTy;
 
 #[derive(ConstParamTy)]
 //~^ ERROR the trait `ConstParamTy_` cannot be implemented for this ty
-//~| ERROR the trait `ConstParamTy_` cannot be implemented for this ty
 struct Foo([*const u8; 1]);
 
 #[derive(ConstParamTy)]
 //~^ ERROR the trait `ConstParamTy_` cannot be implemented for this ty
-//~| ERROR the trait `ConstParamTy_` cannot be implemented for this ty
 struct Foo2([*mut u8; 1]);
 
 #[derive(ConstParamTy)]
 //~^ ERROR the trait `ConstParamTy_` cannot be implemented for this ty
-//~| ERROR the trait `ConstParamTy_` cannot be implemented for this ty
 struct Foo3([fn(); 1]);
 
 fn main() {}
diff --git a/tests/ui/const-generics/adt_const_params/nested_bad_const_param_ty.stderr b/tests/ui/const-generics/adt_const_params/nested_bad_const_param_ty.stderr
index 6b8d2394a8618..442ec6b96cefa 100644
--- a/tests/ui/const-generics/adt_const_params/nested_bad_const_param_ty.stderr
+++ b/tests/ui/const-generics/adt_const_params/nested_bad_const_param_ty.stderr
@@ -3,91 +3,46 @@ error[E0204]: the trait `ConstParamTy_` cannot be implemented for this type
    |
 LL | #[derive(ConstParamTy)]
    |          ^^^^^^^^^^^^
-...
+LL |
 LL | struct Foo([*const u8; 1]);
    |            -------------- this field does not implement `ConstParamTy_`
    |
 note: the `ConstParamTy_` impl for `[*const u8; 1]` requires that `*const u8: ConstParamTy_`
-  --> $DIR/nested_bad_const_param_ty.rs:9:12
+  --> $DIR/nested_bad_const_param_ty.rs:8:12
    |
 LL | struct Foo([*const u8; 1]);
    |            ^^^^^^^^^^^^^^
 
 error[E0204]: the trait `ConstParamTy_` cannot be implemented for this type
-  --> $DIR/nested_bad_const_param_ty.rs:11:10
+  --> $DIR/nested_bad_const_param_ty.rs:10:10
    |
 LL | #[derive(ConstParamTy)]
    |          ^^^^^^^^^^^^
-...
+LL |
 LL | struct Foo2([*mut u8; 1]);
    |             ------------ this field does not implement `ConstParamTy_`
    |
 note: the `ConstParamTy_` impl for `[*mut u8; 1]` requires that `*mut u8: ConstParamTy_`
-  --> $DIR/nested_bad_const_param_ty.rs:14:13
+  --> $DIR/nested_bad_const_param_ty.rs:12:13
    |
 LL | struct Foo2([*mut u8; 1]);
    |             ^^^^^^^^^^^^
 
 error[E0204]: the trait `ConstParamTy_` cannot be implemented for this type
-  --> $DIR/nested_bad_const_param_ty.rs:16:10
+  --> $DIR/nested_bad_const_param_ty.rs:14:10
    |
 LL | #[derive(ConstParamTy)]
    |          ^^^^^^^^^^^^
-...
+LL |
 LL | struct Foo3([fn(); 1]);
    |             --------- this field does not implement `ConstParamTy_`
    |
 note: the `ConstParamTy_` impl for `[fn(); 1]` requires that `fn(): ConstParamTy_`
-  --> $DIR/nested_bad_const_param_ty.rs:19:13
+  --> $DIR/nested_bad_const_param_ty.rs:16:13
    |
 LL | struct Foo3([fn(); 1]);
    |             ^^^^^^^^^
 
-error[E0204]: the trait `ConstParamTy_` cannot be implemented for this type
-  --> $DIR/nested_bad_const_param_ty.rs:6:10
-   |
-LL | #[derive(ConstParamTy)]
-   |          ^^^^^^^^^^^^
-...
-LL | struct Foo([*const u8; 1]);
-   |            -------------- this field does not implement `ConstParamTy_`
-   |
-note: the `ConstParamTy_` impl for `[*const u8; 1]` requires that `*const u8: UnsizedConstParamTy`
-  --> $DIR/nested_bad_const_param_ty.rs:9:12
-   |
-LL | struct Foo([*const u8; 1]);
-   |            ^^^^^^^^^^^^^^
-
-error[E0204]: the trait `ConstParamTy_` cannot be implemented for this type
-  --> $DIR/nested_bad_const_param_ty.rs:11:10
-   |
-LL | #[derive(ConstParamTy)]
-   |          ^^^^^^^^^^^^
-...
-LL | struct Foo2([*mut u8; 1]);
-   |             ------------ this field does not implement `ConstParamTy_`
-   |
-note: the `ConstParamTy_` impl for `[*mut u8; 1]` requires that `*mut u8: UnsizedConstParamTy`
-  --> $DIR/nested_bad_const_param_ty.rs:14:13
-   |
-LL | struct Foo2([*mut u8; 1]);
-   |             ^^^^^^^^^^^^
-
-error[E0204]: the trait `ConstParamTy_` cannot be implemented for this type
-  --> $DIR/nested_bad_const_param_ty.rs:16:10
-   |
-LL | #[derive(ConstParamTy)]
-   |          ^^^^^^^^^^^^
-...
-LL | struct Foo3([fn(); 1]);
-   |             --------- this field does not implement `ConstParamTy_`
-   |
-note: the `ConstParamTy_` impl for `[fn(); 1]` requires that `fn(): UnsizedConstParamTy`
-  --> $DIR/nested_bad_const_param_ty.rs:19:13
-   |
-LL | struct Foo3([fn(); 1]);
-   |             ^^^^^^^^^
-
-error: aborting due to 6 previous errors
+error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0204`.
diff --git a/tests/ui/const-generics/adt_const_params/non_valtreeable_const_arg-2.stderr b/tests/ui/const-generics/adt_const_params/non_valtreeable_const_arg-2.stderr
index b13f76eabadbc..72dfda50ea5ca 100644
--- a/tests/ui/const-generics/adt_const_params/non_valtreeable_const_arg-2.stderr
+++ b/tests/ui/const-generics/adt_const_params/non_valtreeable_const_arg-2.stderr
@@ -9,11 +9,13 @@ help: you might be missing a const parameter
 LL | impl<const bar: /* Type */> Wrapper<{ bar() }> {
    |     +++++++++++++++++++++++
 
-error[E0741]: using function pointers as const generic parameters is forbidden
+error: using function pointers as const generic parameters is forbidden
   --> $DIR/non_valtreeable_const_arg-2.rs:8:25
    |
 LL | struct Wrapper<const F: fn()>;
    |                         ^^^^
+   |
+   = note: the only supported types are integers, `bool`, and `char`
 
 error[E0599]: the function or associated item `call` exists for struct `Wrapper<function>`, but its trait bounds were not satisfied
   --> $DIR/non_valtreeable_const_arg-2.rs:17:26
@@ -35,5 +37,5 @@ note: the trait `Fn` must be implemented
 
 error: aborting due to 3 previous errors
 
-Some errors have detailed explanations: E0425, E0599, E0741.
+Some errors have detailed explanations: E0425, E0599.
 For more information about an error, try `rustc --explain E0425`.
diff --git a/tests/ui/const-generics/adt_const_params/reference_pointee_is_const_param-1.rs b/tests/ui/const-generics/adt_const_params/reference_pointee_is_const_param-1.rs
index a1ee1c4cdd585..937acf2e6bb63 100644
--- a/tests/ui/const-generics/adt_const_params/reference_pointee_is_const_param-1.rs
+++ b/tests/ui/const-generics/adt_const_params/reference_pointee_is_const_param-1.rs
@@ -1,11 +1,11 @@
 #![feature(adt_const_params, unsized_const_params)]
 #![allow(incomplete_features)]
 
-use std::marker::UnsizedConstParamTy;
+use std::marker::ConstParamTy_;
 
 struct Foo;
 
-impl UnsizedConstParamTy for &'static Foo {}
+impl ConstParamTy_ for &'static Foo {}
 //~^ ERROR: the trait `ConstParamTy_` cannot be implemented for this type
 
 fn main() {}
diff --git a/tests/ui/const-generics/adt_const_params/reference_pointee_is_const_param-1.stderr b/tests/ui/const-generics/adt_const_params/reference_pointee_is_const_param-1.stderr
index 5ca8e6c75167f..b977cf5d44e09 100644
--- a/tests/ui/const-generics/adt_const_params/reference_pointee_is_const_param-1.stderr
+++ b/tests/ui/const-generics/adt_const_params/reference_pointee_is_const_param-1.stderr
@@ -1,8 +1,8 @@
 error[E0204]: the trait `ConstParamTy_` cannot be implemented for this type
-  --> $DIR/reference_pointee_is_const_param-1.rs:8:30
+  --> $DIR/reference_pointee_is_const_param-1.rs:8:24
    |
-LL | impl UnsizedConstParamTy for &'static Foo {}
-   |                              ^^^^^^^^^^^^ this field does not implement `ConstParamTy_`
+LL | impl ConstParamTy_ for &'static Foo {}
+   |                        ^^^^^^^^^^^^ this field does not implement `ConstParamTy_`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/adt_const_params/reference_pointee_is_const_param-2.rs b/tests/ui/const-generics/adt_const_params/reference_pointee_is_const_param-2.rs
index ac1b522f469e1..605fed26c9c3c 100644
--- a/tests/ui/const-generics/adt_const_params/reference_pointee_is_const_param-2.rs
+++ b/tests/ui/const-generics/adt_const_params/reference_pointee_is_const_param-2.rs
@@ -3,12 +3,12 @@
 
 // Regression test for #119299
 
-use std::marker::UnsizedConstParamTy;
+use std::marker::ConstParamTy_;
 
 #[derive(Eq, PartialEq)]
 struct ConstStrU(*const u8, usize);
 
-impl UnsizedConstParamTy for &'static ConstStrU {}
+impl ConstParamTy_ for &'static ConstStrU {}
 //~^ ERROR: the trait `ConstParamTy_` cannot be implemented for this type
 
 impl ConstStrU {
diff --git a/tests/ui/const-generics/adt_const_params/reference_pointee_is_const_param-2.stderr b/tests/ui/const-generics/adt_const_params/reference_pointee_is_const_param-2.stderr
index 5e5f6cc642d33..0fe92f253a05e 100644
--- a/tests/ui/const-generics/adt_const_params/reference_pointee_is_const_param-2.stderr
+++ b/tests/ui/const-generics/adt_const_params/reference_pointee_is_const_param-2.stderr
@@ -1,8 +1,8 @@
 error[E0204]: the trait `ConstParamTy_` cannot be implemented for this type
-  --> $DIR/reference_pointee_is_const_param-2.rs:11:30
+  --> $DIR/reference_pointee_is_const_param-2.rs:11:24
    |
-LL | impl UnsizedConstParamTy for &'static ConstStrU {}
-   |                              ^^^^^^^^^^^^^^^^^^ this field does not implement `ConstParamTy_`
+LL | impl ConstParamTy_ for &'static ConstStrU {}
+   |                        ^^^^^^^^^^^^^^^^^^ this field does not implement `ConstParamTy_`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/adt_const_params/trait_objects_as_a_const_generic.rs b/tests/ui/const-generics/adt_const_params/trait_objects_as_a_const_generic.rs
index b0934508399d5..0fe86adb291dd 100644
--- a/tests/ui/const-generics/adt_const_params/trait_objects_as_a_const_generic.rs
+++ b/tests/ui/const-generics/adt_const_params/trait_objects_as_a_const_generic.rs
@@ -1,11 +1,11 @@
 #![feature(adt_const_params, unsized_const_params)]
 #![allow(incomplete_features)]
 
-use std::marker::UnsizedConstParamTy;
+use std::marker::ConstParamTy_;
 
 trait Trait {}
 
-impl UnsizedConstParamTy for dyn Trait {}
+impl ConstParamTy_ for dyn Trait {}
 //~^ ERROR: the trait `ConstParamTy` may not be implemented for this type
 
 fn foo<const N: dyn Trait>() {}
diff --git a/tests/ui/const-generics/adt_const_params/trait_objects_as_a_const_generic.stderr b/tests/ui/const-generics/adt_const_params/trait_objects_as_a_const_generic.stderr
index 9933ba6e335b7..67c6314e2975b 100644
--- a/tests/ui/const-generics/adt_const_params/trait_objects_as_a_const_generic.stderr
+++ b/tests/ui/const-generics/adt_const_params/trait_objects_as_a_const_generic.stderr
@@ -1,8 +1,8 @@
 error: the trait `ConstParamTy` may not be implemented for this type
-  --> $DIR/trait_objects_as_a_const_generic.rs:8:30
+  --> $DIR/trait_objects_as_a_const_generic.rs:8:24
    |
-LL | impl UnsizedConstParamTy for dyn Trait {}
-   |                              ^^^^^^^^^ type is not a structure or enumeration
+LL | impl ConstParamTy_ for dyn Trait {}
+   |                        ^^^^^^^^^ type is not a structure or enumeration
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/adt_const_params/unsized_field-1.rs b/tests/ui/const-generics/adt_const_params/unsized_field-1.rs
index f6e5bd6e355da..5db031cb900fc 100644
--- a/tests/ui/const-generics/adt_const_params/unsized_field-1.rs
+++ b/tests/ui/const-generics/adt_const_params/unsized_field-1.rs
@@ -14,7 +14,10 @@ struct A([u8]);
 struct B(&'static [u8]);
 
 #[derive(ConstParamTy, Eq, PartialEq)]
-//~^ ERROR: the trait `ConstParamTy_` cannot be implemented for this type
 struct C(unsized_const_param::Foo);
 
+#[derive(std::marker::ConstParamTy, Eq, PartialEq)]
+//~^ ERROR: the trait `ConstParamTy_` cannot be implemented for this type
+struct D(unsized_const_param::GenericNotUnsizedParam<&'static [u8]>);
+
 fn main() {}
diff --git a/tests/ui/const-generics/adt_const_params/unsized_field-1.stderr b/tests/ui/const-generics/adt_const_params/unsized_field-1.stderr
index 3089b30bd76d1..a5ae5c726da86 100644
--- a/tests/ui/const-generics/adt_const_params/unsized_field-1.stderr
+++ b/tests/ui/const-generics/adt_const_params/unsized_field-1.stderr
@@ -6,6 +6,12 @@ LL | #[derive(ConstParamTy, Eq, PartialEq)]
 LL |
 LL | struct A([u8]);
    |          ---- this field does not implement `ConstParamTy_`
+   |
+note: the `ConstParamTy_` impl for `[u8]` requires that `unstable feature: `unsized_const_params``
+  --> $DIR/unsized_field-1.rs:10:10
+   |
+LL | struct A([u8]);
+   |          ^^^^
 
 error[E0204]: the trait `ConstParamTy_` cannot be implemented for this type
   --> $DIR/unsized_field-1.rs:12:10
@@ -15,15 +21,27 @@ LL | #[derive(ConstParamTy, Eq, PartialEq)]
 LL |
 LL | struct B(&'static [u8]);
    |          ------------- this field does not implement `ConstParamTy_`
+   |
+note: the `ConstParamTy_` impl for `&'static [u8]` requires that `unstable feature: `unsized_const_params``
+  --> $DIR/unsized_field-1.rs:14:10
+   |
+LL | struct B(&'static [u8]);
+   |          ^^^^^^^^^^^^^
 
 error[E0204]: the trait `ConstParamTy_` cannot be implemented for this type
-  --> $DIR/unsized_field-1.rs:16:10
+  --> $DIR/unsized_field-1.rs:19:10
    |
-LL | #[derive(ConstParamTy, Eq, PartialEq)]
-   |          ^^^^^^^^^^^^
+LL | #[derive(std::marker::ConstParamTy, Eq, PartialEq)]
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^
 LL |
-LL | struct C(unsized_const_param::Foo);
-   |          ------------------------ this field does not implement `ConstParamTy_`
+LL | struct D(unsized_const_param::GenericNotUnsizedParam<&'static [u8]>);
+   |          ---------------------------------------------------------- this field does not implement `ConstParamTy_`
+   |
+note: the `ConstParamTy_` impl for `GenericNotUnsizedParam<&'static [u8]>` requires that `unstable feature: `unsized_const_params``
+  --> $DIR/unsized_field-1.rs:21:10
+   |
+LL | struct D(unsized_const_param::GenericNotUnsizedParam<&'static [u8]>);
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/const-generics/adt_const_params/unsized_field-2.rs b/tests/ui/const-generics/adt_const_params/unsized_field-2.rs
deleted file mode 100644
index e4a3a481b4e37..0000000000000
--- a/tests/ui/const-generics/adt_const_params/unsized_field-2.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//@ aux-build:unsized_const_param.rs
-#![feature(adt_const_params, unsized_const_params)]
-//~^ WARN: the feature `unsized_const_params` is incomplete
-
-extern crate unsized_const_param;
-
-#[derive(std::marker::ConstParamTy, Eq, PartialEq)]
-//~^ ERROR: the trait `ConstParamTy_` cannot be implemented for this type
-struct A(unsized_const_param::GenericNotUnsizedParam<&'static [u8]>);
-
-#[derive(std::marker::UnsizedConstParamTy, Eq, PartialEq)]
-struct B(unsized_const_param::GenericNotUnsizedParam<&'static [u8]>);
-
-fn main() {}
diff --git a/tests/ui/const-generics/adt_const_params/unsized_field-2.stderr b/tests/ui/const-generics/adt_const_params/unsized_field-2.stderr
deleted file mode 100644
index cef70ca0463bd..0000000000000
--- a/tests/ui/const-generics/adt_const_params/unsized_field-2.stderr
+++ /dev/null
@@ -1,27 +0,0 @@
-warning: the feature `unsized_const_params` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/unsized_field-2.rs:2:30
-   |
-LL | #![feature(adt_const_params, unsized_const_params)]
-   |                              ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #95174 <https://github.com/rust-lang/rust/issues/95174> for more information
-   = note: `#[warn(incomplete_features)]` on by default
-
-error[E0204]: the trait `ConstParamTy_` cannot be implemented for this type
-  --> $DIR/unsized_field-2.rs:7:10
-   |
-LL | #[derive(std::marker::ConstParamTy, Eq, PartialEq)]
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^
-LL |
-LL | struct A(unsized_const_param::GenericNotUnsizedParam<&'static [u8]>);
-   |          ---------------------------------------------------------- this field does not implement `ConstParamTy_`
-   |
-note: the `ConstParamTy_` impl for `GenericNotUnsizedParam<&'static [u8]>` requires that `&'static [u8]: ConstParamTy_`
-  --> $DIR/unsized_field-2.rs:9:10
-   |
-LL | struct A(unsized_const_param::GenericNotUnsizedParam<&'static [u8]>);
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 1 previous error; 1 warning emitted
-
-For more information about this error, try `rustc --explain E0204`.
diff --git a/tests/ui/const-generics/adt_const_params/unsizing-wfcheck-issue-126272.rs b/tests/ui/const-generics/adt_const_params/unsizing-wfcheck-issue-126272.rs
index 311f507d3c7f4..500e8e22b0e3d 100644
--- a/tests/ui/const-generics/adt_const_params/unsizing-wfcheck-issue-126272.rs
+++ b/tests/ui/const-generics/adt_const_params/unsizing-wfcheck-issue-126272.rs
@@ -7,7 +7,6 @@ use std::marker::ConstParamTy;
 
 #[derive(Debug, PartialEq, Eq, ConstParamTy)]
 //~^ ERROR the trait `ConstParamTy_`
-//~| ERROR the trait `ConstParamTy_`
 struct Foo {
     nested: &'static Bar<dyn std::fmt::Debug>,
     //~^ ERROR the size for values
diff --git a/tests/ui/const-generics/adt_const_params/unsizing-wfcheck-issue-126272.stderr b/tests/ui/const-generics/adt_const_params/unsizing-wfcheck-issue-126272.stderr
index 992a27c1c0e90..d4aeb91999c6b 100644
--- a/tests/ui/const-generics/adt_const_params/unsizing-wfcheck-issue-126272.stderr
+++ b/tests/ui/const-generics/adt_const_params/unsizing-wfcheck-issue-126272.stderr
@@ -1,17 +1,17 @@
 error[E0277]: the size for values of type `(dyn Debug + 'static)` cannot be known at compilation time
-  --> $DIR/unsizing-wfcheck-issue-126272.rs:12:13
+  --> $DIR/unsizing-wfcheck-issue-126272.rs:11:13
    |
 LL |     nested: &'static Bar<dyn std::fmt::Debug>,
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `Sized` is not implemented for `(dyn Debug + 'static)`
 note: required by an implicit `Sized` bound in `Bar`
-  --> $DIR/unsizing-wfcheck-issue-126272.rs:21:12
+  --> $DIR/unsizing-wfcheck-issue-126272.rs:20:12
    |
 LL | struct Bar<T>(T);
    |            ^ required by the implicit `Sized` requirement on this type parameter in `Bar`
 help: you could relax the implicit `Sized` bound on `T` if it were used through indirection like `&T` or `Box<T>`
-  --> $DIR/unsizing-wfcheck-issue-126272.rs:21:12
+  --> $DIR/unsizing-wfcheck-issue-126272.rs:20:12
    |
 LL | struct Bar<T>(T);
    |            ^  - ...if indirection were used here: `Box<T>`
@@ -26,34 +26,25 @@ LL | #[derive(Debug, PartialEq, Eq, ConstParamTy)]
 ...
 LL |     nested: &'static Bar<dyn std::fmt::Debug>,
    |     ----------------------------------------- this field does not implement `ConstParamTy_`
-
-error[E0204]: the trait `ConstParamTy_` cannot be implemented for this type
-  --> $DIR/unsizing-wfcheck-issue-126272.rs:8:32
    |
-LL | #[derive(Debug, PartialEq, Eq, ConstParamTy)]
-   |                                ^^^^^^^^^^^^
-...
-LL |     nested: &'static Bar<dyn std::fmt::Debug>,
-   |     ----------------------------------------- this field does not implement `ConstParamTy_`
-   |
-note: the `ConstParamTy_` impl for `&'static Bar<(dyn Debug + 'static)>` requires that `(dyn Debug + 'static): Eq`
-  --> $DIR/unsizing-wfcheck-issue-126272.rs:12:13
+note: the `ConstParamTy_` impl for `&'static Bar<(dyn Debug + 'static)>` requires that `(dyn Debug + 'static): ConstParamTy_`
+  --> $DIR/unsizing-wfcheck-issue-126272.rs:11:13
    |
 LL |     nested: &'static Bar<dyn std::fmt::Debug>,
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-note: the `ConstParamTy_` impl for `&'static Bar<(dyn Debug + 'static)>` requires that `(dyn Debug + 'static): Sized`
-  --> $DIR/unsizing-wfcheck-issue-126272.rs:12:13
+note: the `ConstParamTy_` impl for `&'static Bar<(dyn Debug + 'static)>` requires that `(dyn Debug + 'static): Eq`
+  --> $DIR/unsizing-wfcheck-issue-126272.rs:11:13
    |
 LL |     nested: &'static Bar<dyn std::fmt::Debug>,
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-note: the `ConstParamTy_` impl for `&'static Bar<(dyn Debug + 'static)>` requires that `(dyn Debug + 'static): UnsizedConstParamTy`
-  --> $DIR/unsizing-wfcheck-issue-126272.rs:12:13
+note: the `ConstParamTy_` impl for `&'static Bar<(dyn Debug + 'static)>` requires that `(dyn Debug + 'static): Sized`
+  --> $DIR/unsizing-wfcheck-issue-126272.rs:11:13
    |
 LL |     nested: &'static Bar<dyn std::fmt::Debug>,
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0277]: the size for values of type `(dyn Debug + 'static)` cannot be known at compilation time
-  --> $DIR/unsizing-wfcheck-issue-126272.rs:12:5
+  --> $DIR/unsizing-wfcheck-issue-126272.rs:11:5
    |
 LL | #[derive(Debug, PartialEq, Eq, ConstParamTy)]
    |          ----- in this derive macro expansion
@@ -64,7 +55,7 @@ LL |     nested: &'static Bar<dyn std::fmt::Debug>,
    = help: the trait `Sized` is not implemented for `(dyn Debug + 'static)`
    = help: the trait `Debug` is implemented for `Bar<T>`
 note: required for `Bar<(dyn Debug + 'static)>` to implement `Debug`
-  --> $DIR/unsizing-wfcheck-issue-126272.rs:20:10
+  --> $DIR/unsizing-wfcheck-issue-126272.rs:19:10
    |
 LL | #[derive(Debug, PartialEq, Eq, ConstParamTy)]
    |          ^^^^^
@@ -75,7 +66,7 @@ LL | struct Bar<T>(T);
    = note: required for the cast from `&&&'static Bar<(dyn Debug + 'static)>` to `&dyn Debug`
 
 error[E0369]: binary operation `==` cannot be applied to type `&Bar<dyn Debug>`
-  --> $DIR/unsizing-wfcheck-issue-126272.rs:12:5
+  --> $DIR/unsizing-wfcheck-issue-126272.rs:11:5
    |
 LL | #[derive(Debug, PartialEq, Eq, ConstParamTy)]
    |                 --------- in this derive macro expansion
@@ -84,7 +75,7 @@ LL |     nested: &'static Bar<dyn std::fmt::Debug>,
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0277]: the trait bound `dyn Debug: Eq` is not satisfied
-  --> $DIR/unsizing-wfcheck-issue-126272.rs:12:5
+  --> $DIR/unsizing-wfcheck-issue-126272.rs:11:5
    |
 LL | #[derive(Debug, PartialEq, Eq, ConstParamTy)]
    |                            -- in this derive macro expansion
@@ -94,7 +85,7 @@ LL |     nested: &'static Bar<dyn std::fmt::Debug>,
    |
    = help: the trait `Eq` is implemented for `Bar<T>`
 note: required for `Bar<dyn Debug>` to implement `Eq`
-  --> $DIR/unsizing-wfcheck-issue-126272.rs:20:28
+  --> $DIR/unsizing-wfcheck-issue-126272.rs:19:28
    |
 LL | #[derive(Debug, PartialEq, Eq, ConstParamTy)]
    |                            ^^ unsatisfied trait bound introduced in this `derive` macro
@@ -104,7 +95,7 @@ note: required by a bound in `AssertParamIsEq`
   --> $SRC_DIR/core/src/cmp.rs:LL:COL
 
 error[E0277]: the size for values of type `dyn Debug` cannot be known at compilation time
-  --> $DIR/unsizing-wfcheck-issue-126272.rs:12:5
+  --> $DIR/unsizing-wfcheck-issue-126272.rs:11:5
    |
 LL | #[derive(Debug, PartialEq, Eq, ConstParamTy)]
    |                            -- in this derive macro expansion
@@ -114,12 +105,12 @@ LL |     nested: &'static Bar<dyn std::fmt::Debug>,
    |
    = help: the trait `Sized` is not implemented for `dyn Debug`
 note: required by an implicit `Sized` bound in `Bar`
-  --> $DIR/unsizing-wfcheck-issue-126272.rs:21:12
+  --> $DIR/unsizing-wfcheck-issue-126272.rs:20:12
    |
 LL | struct Bar<T>(T);
    |            ^ required by the implicit `Sized` requirement on this type parameter in `Bar`
 help: you could relax the implicit `Sized` bound on `T` if it were used through indirection like `&T` or `Box<T>`
-  --> $DIR/unsizing-wfcheck-issue-126272.rs:21:12
+  --> $DIR/unsizing-wfcheck-issue-126272.rs:20:12
    |
 LL | struct Bar<T>(T);
    |            ^  - ...if indirection were used here: `Box<T>`
@@ -127,26 +118,26 @@ LL | struct Bar<T>(T);
    |            this could be changed to `T: ?Sized`...
 
 error[E0277]: the size for values of type `(dyn Debug + 'static)` cannot be known at compilation time
-  --> $DIR/unsizing-wfcheck-issue-126272.rs:26:33
+  --> $DIR/unsizing-wfcheck-issue-126272.rs:25:33
    |
 LL |     let x: Test<{ Foo { nested: &Bar(4) } }> = Test;
    |                                 ^^^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `Sized` is not implemented for `(dyn Debug + 'static)`
 note: required by an implicit `Sized` bound in `Bar`
-  --> $DIR/unsizing-wfcheck-issue-126272.rs:21:12
+  --> $DIR/unsizing-wfcheck-issue-126272.rs:20:12
    |
 LL | struct Bar<T>(T);
    |            ^ required by the implicit `Sized` requirement on this type parameter in `Bar`
 help: you could relax the implicit `Sized` bound on `T` if it were used through indirection like `&T` or `Box<T>`
-  --> $DIR/unsizing-wfcheck-issue-126272.rs:21:12
+  --> $DIR/unsizing-wfcheck-issue-126272.rs:20:12
    |
 LL | struct Bar<T>(T);
    |            ^  - ...if indirection were used here: `Box<T>`
    |            |
    |            this could be changed to `T: ?Sized`...
 
-error: aborting due to 8 previous errors
+error: aborting due to 7 previous errors
 
 Some errors have detailed explanations: E0204, E0277, E0369.
 For more information about an error, try `rustc --explain E0204`.
diff --git a/tests/ui/const-generics/const-param-with-additional-obligations.rs b/tests/ui/const-generics/const-param-with-additional-obligations.rs
index 98097e86c7dfe..5110f95d5bf9a 100644
--- a/tests/ui/const-generics/const-param-with-additional-obligations.rs
+++ b/tests/ui/const-generics/const-param-with-additional-obligations.rs
@@ -1,14 +1,14 @@
 #![feature(adt_const_params, unsized_const_params)]
 #![allow(incomplete_features)]
 
-use std::marker::UnsizedConstParamTy;
+use std::marker::ConstParamTy_;
 
 #[derive(Eq, PartialEq)]
 struct Foo<T>(T);
 
 trait Other {}
 
-impl<T> UnsizedConstParamTy for Foo<T> where T: Other + UnsizedConstParamTy {}
+impl<T> ConstParamTy_ for Foo<T> where T: Other + ConstParamTy_ {}
 
 fn foo<const N: Foo<u8>>() {}
 //~^ ERROR `Foo<u8>` must implement `ConstParamTy` to be used as the type of a const generic parameter
diff --git a/tests/ui/const-generics/generic_const_parameter_types/no_const_param_ty_bound.stderr b/tests/ui/const-generics/generic_const_parameter_types/no_const_param_ty_bound.stderr
index 4ea323f4a5c85..1eacc28b2625e 100644
--- a/tests/ui/const-generics/generic_const_parameter_types/no_const_param_ty_bound.stderr
+++ b/tests/ui/const-generics/generic_const_parameter_types/no_const_param_ty_bound.stderr
@@ -4,7 +4,7 @@ error[E0741]: `[T; N]` can't be used as a const parameter type
 LL | struct UsesType<T, const N: usize, const M: [T; N]>(PhantomData<T>);
    |                                             ^^^^^^
    |
-   = note: `T` must implement `UnsizedConstParamTy`, but it does not
+   = note: `T` must implement `ConstParamTy_`, but it does not
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issue-66451.rs b/tests/ui/const-generics/issue-66451.rs
index 0b8693e0e675d..9ce7658586ad1 100644
--- a/tests/ui/const-generics/issue-66451.rs
+++ b/tests/ui/const-generics/issue-66451.rs
@@ -1,15 +1,15 @@
 #![feature(adt_const_params, unsized_const_params)]
 #![allow(incomplete_features)]
 
-use std::marker::UnsizedConstParamTy;
+use std::marker::ConstParamTy;
 
-#[derive(Debug, PartialEq, Eq, UnsizedConstParamTy)]
+#[derive(Debug, PartialEq, Eq, ConstParamTy)]
 struct Foo {
     value: i32,
     nested: &'static Bar<i32>,
 }
 
-#[derive(Debug, PartialEq, Eq, UnsizedConstParamTy)]
+#[derive(Debug, PartialEq, Eq, ConstParamTy)]
 struct Bar<T>(T);
 
 struct Test<const F: Foo>;
diff --git a/tests/ui/const-generics/issues/issue-63322-forbid-dyn.full.stderr b/tests/ui/const-generics/issues/issue-63322-forbid-dyn.full.stderr
index 8ea96428deb3b..1301ca92f015c 100644
--- a/tests/ui/const-generics/issues/issue-63322-forbid-dyn.full.stderr
+++ b/tests/ui/const-generics/issues/issue-63322-forbid-dyn.full.stderr
@@ -4,7 +4,7 @@ error[E0741]: `&'static (dyn A + 'static)` can't be used as a const parameter ty
 LL | fn test<const T: &'static dyn A>() {
    |                  ^^^^^^^^^^^^^^
    |
-   = note: `(dyn A + 'static)` must implement `UnsizedConstParamTy`, but it does not
+   = note: `(dyn A + 'static)` must implement `ConstParamTy_`, but it does not
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/slice-const-param-mismatch.adt_const_params.stderr b/tests/ui/const-generics/slice-const-param-mismatch.adt_const_params.stderr
index bcb2bd255dab9..d970b12df6a1d 100644
--- a/tests/ui/const-generics/slice-const-param-mismatch.adt_const_params.stderr
+++ b/tests/ui/const-generics/slice-const-param-mismatch.adt_const_params.stderr
@@ -1,14 +1,22 @@
-error[E0741]: `&'static str` can't be used as a const parameter type
-  --> $DIR/slice-const-param-mismatch.rs:8:29
+error[E0658]: use of unstable library feature `unsized_const_params`
+  --> $DIR/slice-const-param-mismatch.rs:8:20
    |
 LL | struct ConstString<const T: &'static str>;
-   |                             ^^^^^^^^^^^^
+   |                    ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: add `#![feature(unsized_const_params)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+   = note: required for `&'static str` to implement `ConstParamTy_`
 
-error[E0741]: `&'static [u8]` can't be used as a const parameter type
-  --> $DIR/slice-const-param-mismatch.rs:11:28
+error[E0658]: use of unstable library feature `unsized_const_params`
+  --> $DIR/slice-const-param-mismatch.rs:11:19
    |
 LL | struct ConstBytes<const T: &'static [u8]>;
-   |                            ^^^^^^^^^^^^^
+   |                   ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: add `#![feature(unsized_const_params)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+   = note: required for `&'static [u8]` to implement `ConstParamTy_`
 
 error[E0308]: mismatched types
   --> $DIR/slice-const-param-mismatch.rs:17:35
@@ -45,5 +53,5 @@ LL |     let _: ConstBytes<b"AAA"> = ConstBytes::<b"BBB">;
 
 error: aborting due to 5 previous errors
 
-Some errors have detailed explanations: E0308, E0741.
+Some errors have detailed explanations: E0308, E0658.
 For more information about an error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/slice-const-param.rs b/tests/ui/const-generics/slice-const-param.rs
index 1c5088b528355..8b5e934149e42 100644
--- a/tests/ui/const-generics/slice-const-param.rs
+++ b/tests/ui/const-generics/slice-const-param.rs
@@ -12,7 +12,7 @@ pub fn function_with_bytes<const BYTES: &'static [u8]>() -> &'static [u8] {
 }
 
 // Also check the codepaths for custom DST
-#[derive(std::marker::UnsizedConstParamTy, PartialEq, Eq)]
+#[derive(std::marker::ConstParamTy, PartialEq, Eq)]
 struct MyStr(str);
 
 fn function_with_my_str<const S: &'static MyStr>() -> &'static MyStr {
diff --git a/tests/ui/const-generics/transmute-const-param-static-reference.adt_const_params.stderr b/tests/ui/const-generics/transmute-const-param-static-reference.adt_const_params.stderr
index 7a936ced0305a..c2351c707d7bf 100644
--- a/tests/ui/const-generics/transmute-const-param-static-reference.adt_const_params.stderr
+++ b/tests/ui/const-generics/transmute-const-param-static-reference.adt_const_params.stderr
@@ -1,9 +1,13 @@
-error[E0741]: `&'static ()` can't be used as a const parameter type
-  --> $DIR/transmute-const-param-static-reference.rs:9:23
+error[E0658]: use of unstable library feature `unsized_const_params`
+  --> $DIR/transmute-const-param-static-reference.rs:9:14
    |
 LL | struct Const<const P: &'static ()>;
-   |                       ^^^^^^^^^^^
+   |              ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: add `#![feature(unsized_const_params)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+   = note: required for `&'static ()` to implement `ConstParamTy_`
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0741`.
+For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/const-generics/transmute-const-param-static-reference.rs b/tests/ui/const-generics/transmute-const-param-static-reference.rs
index 0b47fd31eaf69..bf164bdadb0e0 100644
--- a/tests/ui/const-generics/transmute-const-param-static-reference.rs
+++ b/tests/ui/const-generics/transmute-const-param-static-reference.rs
@@ -8,7 +8,7 @@
 
 struct Const<const P: &'static ()>;
 //[min]~^ ERROR `&'static ()` is forbidden as the type of a const generic parameter
-//[adt_const_params]~^^ ERROR `&'static ()` can't be used as a const parameter type
+//[adt_const_params]~^^ ERROR use of unstable library feature `unsized_const_params`
 
 fn main() {
     const A: &'static () = unsafe { std::mem::transmute(10 as *const ()) };
diff --git a/tests/ui/const-generics/unsized_const_params/symbol_mangling_v0_str.rs b/tests/ui/const-generics/unsized_const_params/symbol_mangling_v0_str.rs
index 359126f125167..429c401af1f55 100644
--- a/tests/ui/const-generics/unsized_const_params/symbol_mangling_v0_str.rs
+++ b/tests/ui/const-generics/unsized_const_params/symbol_mangling_v0_str.rs
@@ -1,13 +1,13 @@
 //@ check-pass
 //@ compile-flags: -Csymbol-mangling-version=v0
 #![allow(incomplete_features)]
-#![feature(unsized_const_params)]
+#![feature(adt_const_params, unsized_const_params)]
 
 // Regression test for #116303
 
 #[derive(PartialEq, Eq)]
 struct MyStr(str);
-impl std::marker::UnsizedConstParamTy for MyStr {}
+impl std::marker::ConstParamTy_ for MyStr {}
 
 fn function_with_my_str<const S: &'static MyStr>() -> &'static MyStr {
     S
diff --git a/tests/ui/feature-gates/feature-gate-unsized-const-params.rs b/tests/ui/feature-gates/feature-gate-unsized-const-params.rs
index d088d382377cf..56eebbd53c914 100644
--- a/tests/ui/feature-gates/feature-gate-unsized-const-params.rs
+++ b/tests/ui/feature-gates/feature-gate-unsized-const-params.rs
@@ -1,6 +1,8 @@
-struct Foo<const N: [u8]>;
-//~^ ERROR: `[u8]` is forbidden as the type of a const generic parameter
-//~| HELP: add `#![feature(adt_const_params)]` to the crate
-//~| HELP: add `#![feature(unsized_const_params)]` to the crate
+#![feature(adt_const_params)]
+
+struct Bar(u8);
+
+struct Foo<const N: Bar>;
+//~^ ERROR: `Bar` must implement `ConstParamTy` to be used as the type of a const generic parameter
 
 fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-unsized-const-params.stderr b/tests/ui/feature-gates/feature-gate-unsized-const-params.stderr
index 85ca2f59cb639..d4f7d45ea323f 100644
--- a/tests/ui/feature-gates/feature-gate-unsized-const-params.stderr
+++ b/tests/ui/feature-gates/feature-gate-unsized-const-params.stderr
@@ -1,18 +1,15 @@
-error: `[u8]` is forbidden as the type of a const generic parameter
-  --> $DIR/feature-gate-unsized-const-params.rs:1:21
+error[E0741]: `Bar` must implement `ConstParamTy` to be used as the type of a const generic parameter
+  --> $DIR/feature-gate-unsized-const-params.rs:5:21
    |
-LL | struct Foo<const N: [u8]>;
-   |                     ^^^^
+LL | struct Foo<const N: Bar>;
+   |                     ^^^
    |
-   = note: the only supported types are integers, `bool`, and `char`
-help: add `#![feature(adt_const_params)]` to the crate attributes to enable more complex and user defined types
+help: add `#[derive(ConstParamTy, PartialEq, Eq)]` to the struct
    |
-LL + #![feature(adt_const_params)]
-   |
-help: add `#![feature(unsized_const_params)]` to the crate attributes to enable references to implement the `ConstParamTy` trait
-   |
-LL + #![feature(unsized_const_params)]
+LL - struct Bar(u8);
+LL + #[derive(ConstParamTy, PartialEq, Eq)]
    |
 
 error: aborting due to 1 previous error
 
+For more information about this error, try `rustc --explain E0741`.
diff --git a/tests/ui/layout/thaw-transmute-invalid-enum.rs b/tests/ui/layout/thaw-transmute-invalid-enum.rs
index a7c2e1a86de7b..20fc8d463594b 100644
--- a/tests/ui/layout/thaw-transmute-invalid-enum.rs
+++ b/tests/ui/layout/thaw-transmute-invalid-enum.rs
@@ -9,6 +9,7 @@ mod assert {
     where
         Dst: TransmuteFrom<Src>,
         //~^ ERROR: use of unstable library feature `transmutability`
+        //~^^ ERROR: use of unstable library feature `transmutability`
     {
     }
 }
diff --git a/tests/ui/layout/thaw-transmute-invalid-enum.stderr b/tests/ui/layout/thaw-transmute-invalid-enum.stderr
index d12fc4694e0ab..2b89159c26336 100644
--- a/tests/ui/layout/thaw-transmute-invalid-enum.stderr
+++ b/tests/ui/layout/thaw-transmute-invalid-enum.stderr
@@ -1,5 +1,5 @@
 error[E0412]: cannot find type `Subset` in this scope
-  --> $DIR/thaw-transmute-invalid-enum.rs:34:41
+  --> $DIR/thaw-transmute-invalid-enum.rs:35:41
    |
 LL |     assert::is_transmutable::<Superset, Subset>();
    |                                         ^^^^^^ not found in this scope
@@ -10,7 +10,7 @@ LL | fn test<Subset>() {
    |        ++++++++
 
 error[E0517]: attribute should be applied to a struct or union
-  --> $DIR/thaw-transmute-invalid-enum.rs:21:11
+  --> $DIR/thaw-transmute-invalid-enum.rs:22:11
    |
 LL |   #[repr(C, packed(2))]
    |             ^^^^^^^^^
@@ -50,8 +50,19 @@ LL |         Dst: TransmuteFrom<Src>,
    = help: add `#![feature(transmutability)]` 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 `transmutability`
+  --> $DIR/thaw-transmute-invalid-enum.rs:10:14
+   |
+LL |         Dst: TransmuteFrom<Src>,
+   |              ^^^^^^^^^^^^^^^^^^
+   |
+   = help: add `#![feature(transmutability)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+note: required by a bound in `TransmuteFrom`
+  --> $SRC_DIR/core/src/mem/transmutability.rs:LL:COL
+
 error[E0740]: field must implement `Copy` or be wrapped in `ManuallyDrop<...>` to be used in a union
-  --> $DIR/thaw-transmute-invalid-enum.rs:29:9
+  --> $DIR/thaw-transmute-invalid-enum.rs:30:9
    |
 LL |         a: Ox00,
    |         ^^^^^^^
@@ -62,7 +73,7 @@ help: wrap the field type in `ManuallyDrop<...>`
 LL |         a: std::mem::ManuallyDrop<Ox00>,
    |            +++++++++++++++++++++++    +
 
-error: aborting due to 6 previous errors
+error: aborting due to 7 previous errors
 
 Some errors have detailed explanations: E0412, E0517, E0658, E0740.
 For more information about an error, try `rustc --explain E0412`.
diff --git a/tests/ui/symbol-names/const-generics-structural-demangling.rs b/tests/ui/symbol-names/const-generics-structural-demangling.rs
index 06e3ce51fa6aa..0b4af61f99101 100644
--- a/tests/ui/symbol-names/const-generics-structural-demangling.rs
+++ b/tests/ui/symbol-names/const-generics-structural-demangling.rs
@@ -6,7 +6,7 @@
 #![feature(adt_const_params, unsized_const_params, decl_macro, rustc_attrs)]
 #![allow(incomplete_features)]
 
-use std::marker::UnsizedConstParamTy;
+use std::marker::ConstParamTy;
 
 pub struct RefByte<const RB: &'static u8>;
 
@@ -42,7 +42,7 @@ pub struct TupleByteBool<const TBB: (u8, bool)>;
 //~| ERROR demangling-alt(<c::TupleByteBool<{(1, false)}>>)
 impl TupleByteBool<{ (1, false) }> {}
 
-#[derive(PartialEq, Eq, UnsizedConstParamTy)]
+#[derive(PartialEq, Eq, ConstParamTy)]
 pub enum MyOption<T> {
     Some(T),
     None,
@@ -66,7 +66,7 @@ impl OptionUsize<{ MyOption::None }> {}
 //~| ERROR demangling-alt(<c::OptionUsize<{c::MyOption::<usize>::Some(0)}>>)
 impl OptionUsize<{ MyOption::Some(0) }> {}
 
-#[derive(PartialEq, Eq, UnsizedConstParamTy)]
+#[derive(PartialEq, Eq, ConstParamTy)]
 pub struct Foo {
     s: &'static str,
     ch: char,
@@ -83,7 +83,7 @@ impl Foo_<{ Foo { s: "abc", ch: 'x', slice: &[1, 2, 3] } }> {}
 // NOTE(eddyb) this tests specifically the use of disambiguators in field names,
 // using macros 2.0 hygiene to create a `struct` with conflicting field names.
 macro duplicate_field_name_test($x:ident) {
-    #[derive(PartialEq, Eq, UnsizedConstParamTy)]
+    #[derive(PartialEq, Eq, ConstParamTy)]
     pub struct Bar {
         $x: u8,
         x: u16,

From 1c30399ceae2400e266660a8f98a7504c284fda1 Mon Sep 17 00:00:00 2001
From: tiif <pekyuan@gmail.com>
Date: Mon, 15 Sep 2025 09:02:12 +0000
Subject: [PATCH 0955/1889] Add documentation for select_where_possible and
 select_all_or_error

---
 compiler/rustc_infer/src/traits/engine.rs | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_infer/src/traits/engine.rs b/compiler/rustc_infer/src/traits/engine.rs
index 9a66bd0574c9d..4a252719694d5 100644
--- a/compiler/rustc_infer/src/traits/engine.rs
+++ b/compiler/rustc_infer/src/traits/engine.rs
@@ -72,12 +72,27 @@ pub trait TraitEngine<'tcx, E: 'tcx>: 'tcx {
             self.register_predicate_obligation(infcx, obligation);
         }
     }
-
+    /// Go over the list of pending obligations and try to evaluate them.
+    ///
+    /// For each result:
+    /// Ok: remove the obligation from the list
+    /// Ambiguous: leave the obligation in the list to be evaluated later
+    /// Err: remove the obligation from the list and return an error
+    ///
+    /// Returns a list of errors from obligations that evaluated to Err.
     #[must_use]
     fn select_where_possible(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<E>;
 
     fn collect_remaining_errors(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<E>;
 
+    /// Evaluate all pending obligations, return error if they can't be evaluated.
+    ///
+    /// For each result:
+    /// Ok: remove the obligation from the list
+    /// Ambiguous: remove the obligation from the list and return an error
+    /// Err: remove the obligation from the list and return an error
+    ///
+    /// Returns a list of errors from obligations that evaluated to Ambiguous or Err.
     #[must_use]
     fn select_all_or_error(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<E> {
         let errors = self.select_where_possible(infcx);

From 9405e76431374e25077b374ed0cd9c920a1c0f4f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@osdyne.com>
Date: Mon, 15 Sep 2025 02:53:29 -0700
Subject: [PATCH 0956/1889] Detect attempt to use var-args in closure

```
error: unexpected `...`
  --> $DIR/varargs-in-closure-isnt-supported.rs:5:20
   |
LL |     let mut lol = |...| ();
   |                    ^^^ not a valid pattern
   |
   = note: C-variadic type `...` is not allowed here
```
---
 compiler/rustc_parse/messages.ftl             |  1 +
 compiler/rustc_parse/src/errors.rs            |  4 ++-
 compiler/rustc_parse/src/parser/pat.rs        | 27 +++++++++++++------
 .../varargs-in-closure-isnt-supported.rs      | 11 ++++++++
 .../varargs-in-closure-isnt-supported.stderr  | 22 +++++++++++++++
 5 files changed, 56 insertions(+), 9 deletions(-)
 create mode 100644 tests/ui/closures/varargs-in-closure-isnt-supported.rs
 create mode 100644 tests/ui/closures/varargs-in-closure-isnt-supported.stderr

diff --git a/compiler/rustc_parse/messages.ftl b/compiler/rustc_parse/messages.ftl
index 72cd75f6d8943..6d9521c7d2be0 100644
--- a/compiler/rustc_parse/messages.ftl
+++ b/compiler/rustc_parse/messages.ftl
@@ -189,6 +189,7 @@ parse_dotdotdot = unexpected token: `...`
 parse_dotdotdot_rest_pattern = unexpected `...`
     .label = not a valid pattern
     .suggestion = for a rest pattern, use `..` instead of `...`
+    .note = C-variadic type `...` is not allowed here
 
 parse_double_colon_in_bound = expected `:` followed by trait or lifetime
     .suggestion = use single colon
diff --git a/compiler/rustc_parse/src/errors.rs b/compiler/rustc_parse/src/errors.rs
index 00ca5acd84d51..2b107fe35d592 100644
--- a/compiler/rustc_parse/src/errors.rs
+++ b/compiler/rustc_parse/src/errors.rs
@@ -2723,7 +2723,9 @@ pub(crate) struct DotDotDotRestPattern {
     #[label]
     pub span: Span,
     #[suggestion(style = "verbose", code = "", applicability = "machine-applicable")]
-    pub suggestion: Span,
+    pub suggestion: Option<Span>,
+    #[note]
+    pub var_args: Option<()>,
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_parse/src/parser/pat.rs b/compiler/rustc_parse/src/parser/pat.rs
index c4d30b3d32832..fda19d62bc774 100644
--- a/compiler/rustc_parse/src/parser/pat.rs
+++ b/compiler/rustc_parse/src/parser/pat.rs
@@ -756,7 +756,7 @@ impl<'a> Parser<'a> {
             self.bump(); // `..`
             PatKind::Rest
         } else if self.check(exp!(DotDotDot)) && !self.is_pat_range_end_start(1) {
-            self.recover_dotdotdot_rest_pat(lo)
+            self.recover_dotdotdot_rest_pat(lo, expected)
         } else if let Some(form) = self.parse_range_end() {
             self.parse_pat_range_to(form)? // `..=X`, `...X`, or `..X`.
         } else if self.eat(exp!(Bang)) {
@@ -886,16 +886,27 @@ impl<'a> Parser<'a> {
 
     /// Recover from a typoed `...` pattern that was encountered
     /// Ref: Issue #70388
-    fn recover_dotdotdot_rest_pat(&mut self, lo: Span) -> PatKind {
+    fn recover_dotdotdot_rest_pat(&mut self, lo: Span, expected: Option<Expected>) -> PatKind {
         // A typoed rest pattern `...`.
         self.bump(); // `...`
 
-        // The user probably mistook `...` for a rest pattern `..`.
-        self.dcx().emit_err(DotDotDotRestPattern {
-            span: lo,
-            suggestion: lo.with_lo(lo.hi() - BytePos(1)),
-        });
-        PatKind::Rest
+        if let Some(Expected::ParameterName) = expected {
+            // We have `...` in a closure argument, likely meant to be var-arg, which aren't
+            // supported in closures (#146489).
+            PatKind::Err(self.dcx().emit_err(DotDotDotRestPattern {
+                span: lo,
+                suggestion: None,
+                var_args: Some(()),
+            }))
+        } else {
+            // The user probably mistook `...` for a rest pattern `..`.
+            self.dcx().emit_err(DotDotDotRestPattern {
+                span: lo,
+                suggestion: Some(lo.with_lo(lo.hi() - BytePos(1))),
+                var_args: None,
+            });
+            PatKind::Rest
+        }
     }
 
     /// Try to recover the more general form `intersect ::= $pat_lhs @ $pat_rhs`.
diff --git a/tests/ui/closures/varargs-in-closure-isnt-supported.rs b/tests/ui/closures/varargs-in-closure-isnt-supported.rs
new file mode 100644
index 0000000000000..5dff69194f90e
--- /dev/null
+++ b/tests/ui/closures/varargs-in-closure-isnt-supported.rs
@@ -0,0 +1,11 @@
+// var-args are not supported in closures, ensure we don't misdirect people (#146489)
+#![feature(c_variadic)]
+
+unsafe extern "C" fn thats_not_a_pattern(mut ap: ...) -> u32 {
+    let mut lol = |...| (); //~ ERROR: unexpected `...`
+    unsafe { ap.arg::<u32>() } //~^ NOTE: C-variadic type `...` is not allowed here
+    //~| ERROR: type annotations needed
+    //~| NOTE: not a valid pattern
+}
+
+fn main() {}
diff --git a/tests/ui/closures/varargs-in-closure-isnt-supported.stderr b/tests/ui/closures/varargs-in-closure-isnt-supported.stderr
new file mode 100644
index 0000000000000..4f66ff59af127
--- /dev/null
+++ b/tests/ui/closures/varargs-in-closure-isnt-supported.stderr
@@ -0,0 +1,22 @@
+error: unexpected `...`
+  --> $DIR/varargs-in-closure-isnt-supported.rs:5:20
+   |
+LL |     let mut lol = |...| ();
+   |                    ^^^ not a valid pattern
+   |
+   = note: C-variadic type `...` is not allowed here
+
+error[E0282]: type annotations needed
+  --> $DIR/varargs-in-closure-isnt-supported.rs:5:20
+   |
+LL |     let mut lol = |...| ();
+   |                    ^^^
+   |
+help: consider giving this closure parameter an explicit type
+   |
+LL |     let mut lol = |...: /* Type */| ();
+   |                       ++++++++++++
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0282`.

From 0e290e4228e90720b4b3e263f95250db7046cdd2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@osdyne.com>
Date: Mon, 15 Sep 2025 03:06:16 -0700
Subject: [PATCH 0957/1889] Silence inference error on `PatKind::Err`

---
 .../src/error_reporting/infer/need_type_info.rs    | 10 ++++++++--
 .../closures/varargs-in-closure-isnt-supported.rs  |  1 -
 .../varargs-in-closure-isnt-supported.stderr       | 14 +-------------
 3 files changed, 9 insertions(+), 16 deletions(-)

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 edab530590b2a..94772be16be20 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
@@ -4,7 +4,7 @@ use std::path::PathBuf;
 
 use rustc_errors::codes::*;
 use rustc_errors::{Diag, IntoDiagArg};
-use rustc_hir as hir;
+use rustc_hir::{self as hir, PatKind};
 use rustc_hir::def::{CtorOf, DefKind, Namespace, Res};
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::intravisit::{self, Visitor};
@@ -512,7 +512,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     type_name: ty_to_string(self, ty, def_id),
                 });
             }
-            InferSourceKind::ClosureArg { insert_span, ty } => {
+            InferSourceKind::ClosureArg { insert_span, ty, .. } => {
                 infer_subdiags.push(SourceKindSubdiag::LetLike {
                     span: insert_span,
                     name: String::new(),
@@ -652,6 +652,10 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             }),
         };
         *err.long_ty_path() = long_ty_path;
+        if let InferSourceKind::ClosureArg { kind: PatKind::Err(_), .. } = kind {
+            // We will have already emitted an error about this pattern.
+            err.downgrade_to_delayed_bug();
+        }
         err
     }
 }
@@ -673,6 +677,7 @@ enum InferSourceKind<'tcx> {
     ClosureArg {
         insert_span: Span,
         ty: Ty<'tcx>,
+        kind: PatKind<'tcx>,
     },
     GenericArg {
         insert_span: Span,
@@ -1197,6 +1202,7 @@ impl<'a, 'tcx> Visitor<'tcx> for FindInferSourceVisitor<'a, 'tcx> {
                     kind: InferSourceKind::ClosureArg {
                         insert_span: param.pat.span.shrink_to_hi(),
                         ty: param_ty,
+                        kind: param.pat.kind,
                     },
                 })
             }
diff --git a/tests/ui/closures/varargs-in-closure-isnt-supported.rs b/tests/ui/closures/varargs-in-closure-isnt-supported.rs
index 5dff69194f90e..4de78bef14d30 100644
--- a/tests/ui/closures/varargs-in-closure-isnt-supported.rs
+++ b/tests/ui/closures/varargs-in-closure-isnt-supported.rs
@@ -4,7 +4,6 @@
 unsafe extern "C" fn thats_not_a_pattern(mut ap: ...) -> u32 {
     let mut lol = |...| (); //~ ERROR: unexpected `...`
     unsafe { ap.arg::<u32>() } //~^ NOTE: C-variadic type `...` is not allowed here
-    //~| ERROR: type annotations needed
     //~| NOTE: not a valid pattern
 }
 
diff --git a/tests/ui/closures/varargs-in-closure-isnt-supported.stderr b/tests/ui/closures/varargs-in-closure-isnt-supported.stderr
index 4f66ff59af127..a645741a52771 100644
--- a/tests/ui/closures/varargs-in-closure-isnt-supported.stderr
+++ b/tests/ui/closures/varargs-in-closure-isnt-supported.stderr
@@ -6,17 +6,5 @@ LL |     let mut lol = |...| ();
    |
    = note: C-variadic type `...` is not allowed here
 
-error[E0282]: type annotations needed
-  --> $DIR/varargs-in-closure-isnt-supported.rs:5:20
-   |
-LL |     let mut lol = |...| ();
-   |                    ^^^
-   |
-help: consider giving this closure parameter an explicit type
-   |
-LL |     let mut lol = |...: /* Type */| ();
-   |                       ++++++++++++
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0282`.

From a84c8deb1f61e020e026e1fa53bc613426da8fdb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@osdyne.com>
Date: Mon, 15 Sep 2025 03:10:27 -0700
Subject: [PATCH 0958/1889] Fix existing test

---
 tests/ui/c-variadic/no-closure.rs     |  3 +--
 tests/ui/c-variadic/no-closure.stderr | 18 +++---------------
 2 files changed, 4 insertions(+), 17 deletions(-)

diff --git a/tests/ui/c-variadic/no-closure.rs b/tests/ui/c-variadic/no-closure.rs
index c0b77786e8b4a..a5b791fbca800 100644
--- a/tests/ui/c-variadic/no-closure.rs
+++ b/tests/ui/c-variadic/no-closure.rs
@@ -8,8 +8,7 @@ const F: extern "C" fn(...) = |_: ...| {};
 
 fn foo() {
     let f = |...| {};
-    //~^ ERROR: `..` patterns are not allowed here
-    //~| ERROR: unexpected `...`
+    //~^ ERROR: unexpected `...`
 
     let f = |_: ...| {};
     //~^ ERROR C-variadic type `...` may not be nested inside another type
diff --git a/tests/ui/c-variadic/no-closure.stderr b/tests/ui/c-variadic/no-closure.stderr
index 77bd106bb9519..ad635a29ab486 100644
--- a/tests/ui/c-variadic/no-closure.stderr
+++ b/tests/ui/c-variadic/no-closure.stderr
@@ -10,26 +10,14 @@ error: unexpected `...`
 LL |     let f = |...| {};
    |              ^^^ not a valid pattern
    |
-help: for a rest pattern, use `..` instead of `...`
-   |
-LL -     let f = |...| {};
-LL +     let f = |..| {};
-   |
+   = note: C-variadic type `...` is not allowed here
 
 error[E0743]: C-variadic type `...` may not be nested inside another type
-  --> $DIR/no-closure.rs:14:17
+  --> $DIR/no-closure.rs:13:17
    |
 LL |     let f = |_: ...| {};
    |                 ^^^
 
-error: `..` patterns are not allowed here
-  --> $DIR/no-closure.rs:10:14
-   |
-LL |     let f = |...| {};
-   |              ^^^
-   |
-   = note: only allowed in tuple, tuple struct, and slice patterns
-
-error: aborting due to 4 previous errors
+error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0743`.

From dcc62e7e58083dabec40464e4b1bcc9788b70ecb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Mon, 15 Sep 2025 12:32:03 +0200
Subject: [PATCH 0959/1889] Only run Cranelift dist test on nightly

---
 tests/ui/dist/cranelift-x86_64-unknown-linux-gnu-dist.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/ui/dist/cranelift-x86_64-unknown-linux-gnu-dist.rs b/tests/ui/dist/cranelift-x86_64-unknown-linux-gnu-dist.rs
index 198f8d1bc10c1..6d12ab1e4cf6f 100644
--- a/tests/ui/dist/cranelift-x86_64-unknown-linux-gnu-dist.rs
+++ b/tests/ui/dist/cranelift-x86_64-unknown-linux-gnu-dist.rs
@@ -2,6 +2,7 @@
 // dist artifacts.
 
 //@ only-dist
+//@ only-nightly (cranelift is not stable yet)
 //@ only-x86_64-unknown-linux-gnu
 //@ compile-flags: -Z codegen-backend=cranelift
 //@ run-pass

From c92dee244dcca49c1eed99a768749e433f17e112 Mon Sep 17 00:00:00 2001
From: Boxy Uwu <rust@boxyuwu.dev>
Date: Wed, 10 Sep 2025 11:27:36 +0100
Subject: [PATCH 0960/1889] Add relnotes 1.90

---
 RELEASES.md | 126 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 126 insertions(+)

diff --git a/RELEASES.md b/RELEASES.md
index 33abe45ce4629..2b65d070d5fd1 100644
--- a/RELEASES.md
+++ b/RELEASES.md
@@ -1,3 +1,129 @@
+Version 1.90 (2025-09-18)
+==========================
+
+<a id="1.90-Language"></a>
+
+Language
+--------
+- [Split up the `unknown_or_malformed_diagnostic_attributes` lint](https://github.com/rust-lang/rust/pull/140717). This lint has been split up into four finer-grained lints, with `unknown_or_malformed_diagnostic_attributes` now being the lint group that contains these lints:
+    1. `unknown_diagnostic_attributes`: unknown to the current compiler
+    2. `misplaced_diagnostic_attributes`: placed on the wrong item
+    3. `malformed_diagnostic_attributes`: malformed attribute syntax or options
+    4. `malformed_diagnostic_format_literals`: malformed format string literal
+- [Allow constants whose final value has references to mutable/external memory, but reject such constants as patterns](https://github.com/rust-lang/rust/pull/140942)
+- [Allow volatile access to non-Rust memory, including address 0](https://github.com/rust-lang/rust/pull/141260)
+
+
+<a id="1.90-Compiler"></a>
+
+Compiler
+--------
+- [Use `lld` by default on `x86_64-unknown-linux-gnu`](https://github.com/rust-lang/rust/pull/140525).
+- [Tier 3 `musl` targets now link dynamically by default](https://github.com/rust-lang/rust/pull/144410). Affected targets:
+    - `mips64-unknown-linux-muslabi64`
+    - `powerpc64-unknown-linux-musl`
+    - `powerpc-unknown-linux-musl`
+    - `powerpc-unknown-linux-muslspe`
+    - `riscv32gc-unknown-linux-musl`
+    - `s390x-unknown-linux-musl`
+    - `thumbv7neon-unknown-linux-musleabihf`
+
+
+<a id="1.90-Platform-Support"></a>
+
+Platform Support
+----------------
+- [Demote `x86_64-apple-darwin` to Tier 2 with host tools](https://github.com/rust-lang/rust/pull/145252)
+
+
+Refer to Rust's [platform support page][platform-support-doc]
+for more information on Rust's tiered platform support.
+
+[platform-support-doc]: https://doc.rust-lang.org/rustc/platform-support.html
+
+<a id="1.90-Libraries"></a>
+
+Libraries
+---------
+- [Stabilize `u*::{checked,overflowing,saturating,wrapping}_sub_signed`](https://github.com/rust-lang/rust/issues/126043)
+- [Allow comparisons between `CStr`, `CString`, and `Cow<CStr>`](https://github.com/rust-lang/rust/pull/137268)
+- [Remove some unsized tuple impls since unsized tuples can't be constructed](https://github.com/rust-lang/rust/pull/138340)
+- [Set `MSG_NOSIGNAL` for `UnixStream`](https://github.com/rust-lang/rust/pull/140005)
+- [`proc_macro::Ident::new` now supports `$crate`.](https://github.com/rust-lang/rust/pull/141996)
+- [Guarantee the pointer returned from `Thread::into_raw` has at least 8 bytes of alignment](https://github.com/rust-lang/rust/pull/143859)
+
+
+<a id="1.90-Stabilized-APIs"></a>
+
+Stabilized APIs
+---------------
+
+- [`u{n}::checked_sub_signed`](https://doc.rust-lang.org/stable/std/primitive.usize.html#method.checked_sub_signed)
+- [`u{n}::overflowing_sub_signed`](https://doc.rust-lang.org/stable/std/primitive.usize.html#method.overflowing_sub_signed)
+- [`u{n}::saturating_sub_signed`](https://doc.rust-lang.org/stable/std/primitive.usize.html#method.saturating_sub_signed)
+- [`u{n}::wrapping_sub_signed`](https://doc.rust-lang.org/stable/std/primitive.usize.html#method.wrapping_sub_signed)
+- [`impl Copy for IntErrorKind`](https://doc.rust-lang.org/stable/std/num/enum.IntErrorKind.html#impl-Copy-for-IntErrorKind)
+- [`impl Hash for IntErrorKind`](https://doc.rust-lang.org/stable/std/num/enum.IntErrorKind.html#impl-Hash-for-IntErrorKind)
+- [`impl PartialEq<&CStr> for CStr`](https://doc.rust-lang.org/stable/std/ffi/struct.CStr.html#impl-PartialEq%3C%26CStr%3E-for-CStr)
+- [`impl PartialEq<CString> for CStr`](https://doc.rust-lang.org/stable/std/ffi/struct.CStr.html#impl-PartialEq%3CCString%3E-for-CStr)
+- [`impl PartialEq<Cow<CStr>> for CStr`](https://doc.rust-lang.org/stable/std/ffi/struct.CStr.html#impl-PartialEq%3CCow%3C'_,+CStr%3E%3E-for-CStr)
+- [`impl PartialEq<&CStr> for CString`](https://doc.rust-lang.org/stable/std/ffi/struct.CString.html#impl-PartialEq%3C%26CStr%3E-for-CString)
+- [`impl PartialEq<CStr> for CString`](https://doc.rust-lang.org/stable/std/ffi/struct.CString.html#impl-PartialEq%3CCStr%3E-for-CString)
+- [`impl PartialEq<Cow<CStr>> for CString`](https://doc.rust-lang.org/stable/std/ffi/struct.CString.html#impl-PartialEq%3CCow%3C'_,+CStr%3E%3E-for-CString)
+- [`impl PartialEq<&CStr> for Cow<CStr>`](https://doc.rust-lang.org/stable/std/borrow/enum.Cow.html#impl-PartialEq%3C%26CStr%3E-for-Cow%3C'_,+CStr%3E)
+- [`impl PartialEq<CStr> for Cow<CStr>`](https://doc.rust-lang.org/stable/std/borrow/enum.Cow.html#impl-PartialEq%3CCStr%3E-for-Cow%3C'_,+CStr%3E)
+- [`impl PartialEq<CString> for Cow<CStr>`](https://doc.rust-lang.org/stable/std/borrow/enum.Cow.html#impl-PartialEq%3CCString%3E-for-Cow%3C'_,+CStr%3E)
+
+
+These previously stable APIs are now stable in const contexts:
+
+- [`<[T]>::reverse`](https://doc.rust-lang.org/stable/std/primitive.slice.html#method.reverse)
+- [`f32::floor`](https://doc.rust-lang.org/stable/std/primitive.f32.html#method.floor)
+- [`f32::ceil`](https://doc.rust-lang.org/stable/std/primitive.f32.html#method.ceil)
+- [`f32::trunc`](https://doc.rust-lang.org/stable/std/primitive.f32.html#method.trunc)
+- [`f32::fract`](https://doc.rust-lang.org/stable/std/primitive.f32.html#method.fract)
+- [`f32::round`](https://doc.rust-lang.org/stable/std/primitive.f32.html#method.round)
+- [`f32::round_ties_even`](https://doc.rust-lang.org/stable/std/primitive.f32.html#method.round_ties_even)
+- [`f64::floor`](https://doc.rust-lang.org/stable/std/primitive.f64.html#method.floor)
+- [`f64::ceil`](https://doc.rust-lang.org/stable/std/primitive.f64.html#method.ceil)
+- [`f64::trunc`](https://doc.rust-lang.org/stable/std/primitive.f64.html#method.trunc)
+- [`f64::fract`](https://doc.rust-lang.org/stable/std/primitive.f64.html#method.fract)
+- [`f64::round`](https://doc.rust-lang.org/stable/std/primitive.f64.html#method.round)
+- [`f64::round_ties_even`](https://doc.rust-lang.org/stable/std/primitive.f64.html#method.round_ties_even)
+
+
+<a id="1.90-Cargo"></a>
+
+Cargo
+-----
+- [Add `http.proxy-cainfo` config for proxy certs](https://github.com/rust-lang/cargo/pull/15374/)
+- [Use `gix` for `cargo package`](https://github.com/rust-lang/cargo/pull/15534/)
+- [feat(publish): Stabilize multi-package publishing](https://github.com/rust-lang/cargo/pull/15636/)
+
+<a id="1.90-Rustdoc"></a>
+
+Rustdoc
+-----
+- [Add ways to collapse all impl blocks](https://github.com/rust-lang/rust/pull/141663). Previously the "Summary" button and "-" keyboard shortcut would never collapse `impl` blocks, now they do when shift is held
+- [Display unsafe attributes with `unsafe()` wrappers](https://github.com/rust-lang/rust/pull/143662)
+
+
+<a id="1.90-Compatibility-Notes"></a>
+
+Compatibility Notes
+-------------------
+- [Use `lld` by default on `x86_64-unknown-linux-gnu`](https://github.com/rust-lang/rust/pull/140525).
+  See also <https://blog.rust-lang.org/2025/09/01/rust-lld-on-1.90.0-stable/>.
+- [Make `core::iter::Fuse`'s `Default` impl construct `I::default()` internally as promised in the docs instead of always being empty](https://github.com/rust-lang/rust/pull/140985)
+- [Set `MSG_NOSIGNAL` for `UnixStream`](https://github.com/rust-lang/rust/pull/140005)
+  This may change program behavior but results in the same behavior as other primitives (e.g., stdout, network sockets).
+  Programs relying on signals to terminate them should update handling of sockets to handle errors on write by exiting.
+- [On Unix `std::env::home_dir` will use the fallback if the `HOME` environment variable is empty](https://github.com/rust-lang/rust/pull/141840)
+- We now [reject unsupported `extern "{abi}"`s consistently in all positions](https://github.com/rust-lang/rust/pull/142134). This primarily affects the use of implementing traits on an `extern "{abi}"` function pointer, like `extern "stdcall" fn()`, on a platform that doesn't support that, like aarch64-unknown-linux-gnu. Direct usage of these unsupported ABI strings by declaring or defining functions was already rejected, so this is only a change for consistency.
+- [const-eval: error when initializing a static writes to that static](https://github.com/rust-lang/rust/pull/143084)
+- [Check that the `proc_macro_derive` macro has correct arguments when applied to the crate root](https://github.com/rust-lang/rust/pull/143607)
+
+
 Version 1.89.0 (2025-08-07)
 ==========================
 

From 53b58b3afdc1d3b069c8b73230abf68878196f75 Mon Sep 17 00:00:00 2001
From: Jens Reidel <adrian@travitia.xyz>
Date: Mon, 15 Sep 2025 14:31:43 +0200
Subject: [PATCH 0961/1889] tests/run-make: Update list of statically linked
 musl targets

All of the tier 3 targets in the list now link dynamically by default
(except mips64el-unknown-linux-muslabi64, I overlooked that one).

Adjust the list of targets expected to link statically accordingly.

Signed-off-by: Jens Reidel <adrian@travitia.xyz>
---
 tests/run-make/musl-default-linking/rmake.rs | 10 +---------
 1 file changed, 1 insertion(+), 9 deletions(-)

diff --git a/tests/run-make/musl-default-linking/rmake.rs b/tests/run-make/musl-default-linking/rmake.rs
index 7bb54e2739c9d..1b30c538b5e30 100644
--- a/tests/run-make/musl-default-linking/rmake.rs
+++ b/tests/run-make/musl-default-linking/rmake.rs
@@ -4,7 +4,7 @@ use run_make_support::{rustc, serde_json};
 // Per https://github.com/rust-lang/compiler-team/issues/422,
 // we should be trying to move these targets to dynamically link
 // musl libc by default.
-//@ needs-llvm-components: aarch64 arm mips powerpc riscv systemz x86
+//@ needs-llvm-components: aarch64 arm mips powerpc x86
 static LEGACY_STATIC_LINKING_TARGETS: &[&'static str] = &[
     "aarch64-unknown-linux-musl",
     "arm-unknown-linux-musleabi",
@@ -14,16 +14,8 @@ static LEGACY_STATIC_LINKING_TARGETS: &[&'static str] = &[
     "armv7-unknown-linux-musleabihf",
     "i586-unknown-linux-musl",
     "i686-unknown-linux-musl",
-    "mips64-unknown-linux-musl",
-    "mips64-unknown-linux-muslabi64",
     "mips64el-unknown-linux-muslabi64",
-    "powerpc-unknown-linux-musl",
-    "powerpc-unknown-linux-muslspe",
-    "powerpc64-unknown-linux-musl",
     "powerpc64le-unknown-linux-musl",
-    "riscv32gc-unknown-linux-musl",
-    "s390x-unknown-linux-musl",
-    "thumbv7neon-unknown-linux-musleabihf",
     "x86_64-unknown-linux-musl",
 ];
 

From 7299e8fc4db506bb5ec3990e22b611c45df2f13d Mon Sep 17 00:00:00 2001
From: tiif <pekyuan@gmail.com>
Date: Mon, 15 Sep 2025 14:15:29 +0000
Subject: [PATCH 0962/1889] Fix feature gate tests

---
 .../feature-gate-adt_const_params.rs          |  6 +++++-
 .../feature-gate-adt_const_params.stderr      | 12 ++++--------
 .../feature-gate-unsized-const-params.rs      | 10 ++++------
 .../feature-gate-unsized-const-params.stderr  | 19 +++++++++++--------
 4 files changed, 24 insertions(+), 23 deletions(-)

diff --git a/tests/ui/feature-gates/feature-gate-adt_const_params.rs b/tests/ui/feature-gates/feature-gate-adt_const_params.rs
index 8a3bcf25963f1..7efa529c55791 100644
--- a/tests/ui/feature-gates/feature-gate-adt_const_params.rs
+++ b/tests/ui/feature-gates/feature-gate-adt_const_params.rs
@@ -1,2 +1,6 @@
-struct Foo<const NAME: &'static str>; //~ ERROR `&'static str` is forbidden
+struct Bar(u8);
+
+struct Foo<const N: Bar>;
+//~^ ERROR: `Bar` is forbidden as the type of a const generic parameter
+
 fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-adt_const_params.stderr b/tests/ui/feature-gates/feature-gate-adt_const_params.stderr
index 18d514f8cb5f8..7ea91a8f4c2bf 100644
--- a/tests/ui/feature-gates/feature-gate-adt_const_params.stderr
+++ b/tests/ui/feature-gates/feature-gate-adt_const_params.stderr
@@ -1,18 +1,14 @@
-error: `&'static str` is forbidden as the type of a const generic parameter
-  --> $DIR/feature-gate-adt_const_params.rs:1:24
+error: `Bar` is forbidden as the type of a const generic parameter
+  --> $DIR/feature-gate-adt_const_params.rs:3:21
    |
-LL | struct Foo<const NAME: &'static str>;
-   |                        ^^^^^^^^^^^^
+LL | struct Foo<const N: Bar>;
+   |                     ^^^
    |
    = note: the only supported types are integers, `bool`, and `char`
 help: add `#![feature(adt_const_params)]` to the crate attributes to enable more complex and user defined types
    |
 LL + #![feature(adt_const_params)]
    |
-help: add `#![feature(unsized_const_params)]` to the crate attributes to enable references to implement the `ConstParamTy` trait
-   |
-LL + #![feature(unsized_const_params)]
-   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/feature-gates/feature-gate-unsized-const-params.rs b/tests/ui/feature-gates/feature-gate-unsized-const-params.rs
index 56eebbd53c914..d088d382377cf 100644
--- a/tests/ui/feature-gates/feature-gate-unsized-const-params.rs
+++ b/tests/ui/feature-gates/feature-gate-unsized-const-params.rs
@@ -1,8 +1,6 @@
-#![feature(adt_const_params)]
-
-struct Bar(u8);
-
-struct Foo<const N: Bar>;
-//~^ ERROR: `Bar` must implement `ConstParamTy` to be used as the type of a const generic parameter
+struct Foo<const N: [u8]>;
+//~^ ERROR: `[u8]` is forbidden as the type of a const generic parameter
+//~| HELP: add `#![feature(adt_const_params)]` to the crate
+//~| HELP: add `#![feature(unsized_const_params)]` to the crate
 
 fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-unsized-const-params.stderr b/tests/ui/feature-gates/feature-gate-unsized-const-params.stderr
index d4f7d45ea323f..85ca2f59cb639 100644
--- a/tests/ui/feature-gates/feature-gate-unsized-const-params.stderr
+++ b/tests/ui/feature-gates/feature-gate-unsized-const-params.stderr
@@ -1,15 +1,18 @@
-error[E0741]: `Bar` must implement `ConstParamTy` to be used as the type of a const generic parameter
-  --> $DIR/feature-gate-unsized-const-params.rs:5:21
+error: `[u8]` is forbidden as the type of a const generic parameter
+  --> $DIR/feature-gate-unsized-const-params.rs:1:21
    |
-LL | struct Foo<const N: Bar>;
-   |                     ^^^
+LL | struct Foo<const N: [u8]>;
+   |                     ^^^^
    |
-help: add `#[derive(ConstParamTy, PartialEq, Eq)]` to the struct
+   = note: the only supported types are integers, `bool`, and `char`
+help: add `#![feature(adt_const_params)]` to the crate attributes to enable more complex and user defined types
    |
-LL - struct Bar(u8);
-LL + #[derive(ConstParamTy, PartialEq, Eq)]
+LL + #![feature(adt_const_params)]
+   |
+help: add `#![feature(unsized_const_params)]` to the crate attributes to enable references to implement the `ConstParamTy` trait
+   |
+LL + #![feature(unsized_const_params)]
    |
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0741`.

From 9cbf1a5502b81399d522a4224cb012df7e1166a6 Mon Sep 17 00:00:00 2001
From: Sasha Pourcelot <sasha.pourcelot@protonmail.com>
Date: Sat, 23 Aug 2025 19:20:38 +0200
Subject: [PATCH 0963/1889] Split `FnCtxt::report_args_error` into subfunctions

---
 .../rustc_hir_typeck/src/fn_ctxt/checks.rs    | 4208 +++++++++--------
 1 file changed, 2282 insertions(+), 1926 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
index 94b635c41b4b2..22bd7e1d23e15 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -1,3 +1,4 @@
+use std::ops::Deref;
 use std::{fmt, iter, mem};
 
 use itertools::Itertools;
@@ -7,7 +8,7 @@ use rustc_errors::{Applicability, Diag, ErrorGuaranteed, MultiSpan, a_or_an, lis
 use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
 use rustc_hir::def_id::DefId;
 use rustc_hir::intravisit::Visitor;
-use rustc_hir::{ExprKind, HirId, LangItem, Node, QPath};
+use rustc_hir::{Expr, ExprKind, HirId, LangItem, Node, QPath};
 use rustc_hir_analysis::check::potentially_plural_count;
 use rustc_hir_analysis::hir_ty_lowering::{HirTyLowerer, PermitVariants};
 use rustc_index::IndexVec;
@@ -565,358 +566,27 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         tuple_arguments: TupleArgumentsFlag,
     ) -> ErrorGuaranteed {
         // Next, let's construct the error
-        let (error_span, call_ident, full_call_span, call_name, is_method) = match &call_expr.kind {
-            hir::ExprKind::Call(
-                hir::Expr { hir_id, span, kind: hir::ExprKind::Path(qpath), .. },
-                _,
-            ) => {
-                if let Res::Def(DefKind::Ctor(of, _), _) =
-                    self.typeck_results.borrow().qpath_res(qpath, *hir_id)
-                {
-                    let name = match of {
-                        CtorOf::Struct => "struct",
-                        CtorOf::Variant => "enum variant",
-                    };
-                    (call_span, None, *span, name, false)
-                } else {
-                    (call_span, None, *span, "function", false)
-                }
-            }
-            hir::ExprKind::Call(hir::Expr { span, .. }, _) => {
-                (call_span, None, *span, "function", false)
-            }
-            hir::ExprKind::MethodCall(path_segment, _, _, span) => {
-                let ident_span = path_segment.ident.span;
-                let ident_span = if let Some(args) = path_segment.args {
-                    ident_span.with_hi(args.span_ext.hi())
-                } else {
-                    ident_span
-                };
-                (*span, Some(path_segment.ident), ident_span, "method", true)
-            }
-            k => span_bug!(call_span, "checking argument types on a non-call: `{:?}`", k),
-        };
-        let args_span = error_span.trim_start(full_call_span).unwrap_or(error_span);
-
-        // Don't print if it has error types or is just plain `_`
-        fn has_error_or_infer<'tcx>(tys: impl IntoIterator<Item = Ty<'tcx>>) -> bool {
-            tys.into_iter().any(|ty| ty.references_error() || ty.is_ty_var())
-        }
-
-        let tcx = self.tcx;
-
-        // Get the argument span in the context of the call span so that
-        // suggestions and labels are (more) correct when an arg is a
-        // macro invocation.
-        let normalize_span = |span: Span| -> Span {
-            let normalized_span = span.find_ancestor_inside_same_ctxt(error_span).unwrap_or(span);
-            // Sometimes macros mess up the spans, so do not normalize the
-            // arg span to equal the error span, because that's less useful
-            // than pointing out the arg expr in the wrong context.
-            if normalized_span.source_equal(error_span) { span } else { normalized_span }
-        };
-
-        // Precompute the provided types and spans, since that's all we typically need for below
-        let provided_arg_tys: IndexVec<ProvidedIdx, (Ty<'tcx>, Span)> = provided_args
-            .iter()
-            .map(|expr| {
-                let ty = self
-                    .typeck_results
-                    .borrow()
-                    .expr_ty_adjusted_opt(*expr)
-                    .unwrap_or_else(|| Ty::new_misc_error(tcx));
-                (self.resolve_vars_if_possible(ty), normalize_span(expr.span))
-            })
-            .collect();
-        let callee_expr = match &call_expr.peel_blocks().kind {
-            hir::ExprKind::Call(callee, _) => Some(*callee),
-            hir::ExprKind::MethodCall(_, receiver, ..) => {
-                if let Some((DefKind::AssocFn, def_id)) =
-                    self.typeck_results.borrow().type_dependent_def(call_expr.hir_id)
-                    && let Some(assoc) = tcx.opt_associated_item(def_id)
-                    && assoc.is_method()
-                {
-                    Some(*receiver)
-                } else {
-                    None
-                }
-            }
-            _ => None,
-        };
-        let callee_ty = callee_expr
-            .and_then(|callee_expr| self.typeck_results.borrow().expr_ty_adjusted_opt(callee_expr));
-
-        // Obtain another method on `Self` that have similar name.
-        let similar_assoc = |call_name: Ident| -> Option<(ty::AssocItem, ty::FnSig<'_>)> {
-            if let Some(callee_ty) = callee_ty
-                && let Ok(Some(assoc)) = self.probe_op(
-                    call_name.span,
-                    MethodCall,
-                    Some(call_name),
-                    None,
-                    IsSuggestion(true),
-                    callee_ty.peel_refs(),
-                    callee_expr.unwrap().hir_id,
-                    TraitsInScope,
-                    |mut ctxt| ctxt.probe_for_similar_candidate(),
-                )
-                && assoc.is_method()
-            {
-                let args = self.infcx.fresh_args_for_item(call_name.span, assoc.def_id);
-                let fn_sig = tcx.fn_sig(assoc.def_id).instantiate(tcx, args);
-
-                self.instantiate_binder_with_fresh_vars(
-                    call_name.span,
-                    BoundRegionConversionTime::FnCall,
-                    fn_sig,
-                );
-            }
-            None
-        };
-
-        let suggest_confusable = |err: &mut Diag<'_>| {
-            let Some(call_name) = call_ident else {
-                return;
-            };
-            let Some(callee_ty) = callee_ty else {
-                return;
-            };
-            let input_types: Vec<Ty<'_>> = provided_arg_tys.iter().map(|(ty, _)| *ty).collect();
-            // Check for other methods in the following order
-            //  - methods marked as `rustc_confusables` with the provided arguments
-            //  - methods with the same argument type/count and short levenshtein distance
-            //  - methods marked as `rustc_confusables` (done)
-            //  - methods with short levenshtein distance
-
-            // Look for commonly confusable method names considering arguments.
-            if let Some(_name) = self.confusable_method_name(
-                err,
-                callee_ty.peel_refs(),
-                call_name,
-                Some(input_types.clone()),
-            ) {
-                return;
-            }
-            // Look for method names with short levenshtein distance, considering arguments.
-            if let Some((assoc, fn_sig)) = similar_assoc(call_name)
-                && fn_sig.inputs()[1..]
-                    .iter()
-                    .zip(input_types.iter())
-                    .all(|(expected, found)| self.may_coerce(*expected, *found))
-                && fn_sig.inputs()[1..].len() == input_types.len()
-            {
-                let assoc_name = assoc.name();
-                err.span_suggestion_verbose(
-                    call_name.span,
-                    format!("you might have meant to use `{}`", assoc_name),
-                    assoc_name,
-                    Applicability::MaybeIncorrect,
-                );
-                return;
-            }
-            // Look for commonly confusable method names disregarding arguments.
-            if let Some(_name) =
-                self.confusable_method_name(err, callee_ty.peel_refs(), call_name, None)
-            {
-                return;
-            }
-            // Look for similarly named methods with levenshtein distance with the right
-            // number of arguments.
-            if let Some((assoc, fn_sig)) = similar_assoc(call_name)
-                && fn_sig.inputs()[1..].len() == input_types.len()
-            {
-                err.span_note(
-                    tcx.def_span(assoc.def_id),
-                    format!(
-                        "there's is a method with similar name `{}`, but the arguments don't match",
-                        assoc.name(),
-                    ),
-                );
-                return;
-            }
-            // Fallthrough: look for similarly named methods with levenshtein distance.
-            if let Some((assoc, _)) = similar_assoc(call_name) {
-                err.span_note(
-                    tcx.def_span(assoc.def_id),
-                    format!(
-                        "there's is a method with similar name `{}`, but their argument count \
-                         doesn't match",
-                        assoc.name(),
-                    ),
-                );
-                return;
-            }
-        };
-        // A "softer" version of the `demand_compatible`, which checks types without persisting them,
-        // and treats error types differently
-        // This will allow us to "probe" for other argument orders that would likely have been correct
-        let check_compatible = |provided_idx: ProvidedIdx, expected_idx: ExpectedIdx| {
-            if provided_idx.as_usize() == expected_idx.as_usize() {
-                return compatibility_diagonal[provided_idx].clone();
-            }
-
-            let (formal_input_ty, expected_input_ty) = formal_and_expected_inputs[expected_idx];
-            // If either is an error type, we defy the usual convention and consider them to *not* be
-            // coercible. This prevents our error message heuristic from trying to pass errors into
-            // every argument.
-            if (formal_input_ty, expected_input_ty).references_error() {
-                return Compatibility::Incompatible(None);
-            }
-
-            let (arg_ty, arg_span) = provided_arg_tys[provided_idx];
-
-            let expectation = Expectation::rvalue_hint(self, expected_input_ty);
-            let coerced_ty = expectation.only_has_type(self).unwrap_or(formal_input_ty);
-            let can_coerce = self.may_coerce(arg_ty, coerced_ty);
-            if !can_coerce {
-                return Compatibility::Incompatible(Some(ty::error::TypeError::Sorts(
-                    ty::error::ExpectedFound::new(coerced_ty, arg_ty),
-                )));
-            }
-
-            // Using probe here, since we don't want this subtyping to affect inference.
-            let subtyping_error = self.probe(|_| {
-                self.at(&self.misc(arg_span), self.param_env)
-                    .sup(DefineOpaqueTypes::Yes, formal_input_ty, coerced_ty)
-                    .err()
-            });
-
-            // Same as above: if either the coerce type or the checked type is an error type,
-            // consider them *not* compatible.
-            let references_error = (coerced_ty, arg_ty).references_error();
-            match (references_error, subtyping_error) {
-                (false, None) => Compatibility::Compatible,
-                (_, subtyping_error) => Compatibility::Incompatible(subtyping_error),
-            }
-        };
 
-        let mk_trace = |span, (formal_ty, expected_ty), provided_ty| {
-            let mismatched_ty = if expected_ty == provided_ty {
-                // If expected == provided, then we must have failed to sup
-                // the formal type. Avoid printing out "expected Ty, found Ty"
-                // in that case.
-                formal_ty
-            } else {
-                expected_ty
-            };
-            TypeTrace::types(&self.misc(span), mismatched_ty, provided_ty)
-        };
-
-        // The algorithm here is inspired by levenshtein distance and longest common subsequence.
-        // We'll try to detect 4 different types of mistakes:
-        // - An extra parameter has been provided that doesn't satisfy *any* of the other inputs
-        // - An input is missing, which isn't satisfied by *any* of the other arguments
-        // - Some number of arguments have been provided in the wrong order
-        // - A type is straight up invalid
-
-        // First, let's find the errors
-        let (mut errors, matched_inputs) =
-            ArgMatrix::new(provided_args.len(), formal_and_expected_inputs.len(), check_compatible)
-                .find_errors();
+        let mut fn_call_diag_ctxt = FnCallDiagCtxt::new(
+            self,
+            compatibility_diagonal,
+            formal_and_expected_inputs,
+            provided_args,
+            c_variadic,
+            err_code,
+            fn_def_id,
+            call_span,
+            call_expr,
+            tuple_arguments,
+        );
 
         // First, check if we just need to wrap some arguments in a tuple.
-        if let Some((mismatch_idx, terr)) =
-            compatibility_diagonal.iter_enumerated().find_map(|(i, c)| {
-                if let Compatibility::Incompatible(Some(terr)) = c {
-                    Some((i, *terr))
-                } else {
-                    None
-                }
-            })
-        {
-            // Is the first bad expected argument a tuple?
-            // Do we have as many extra provided arguments as the tuple's length?
-            // If so, we might have just forgotten to wrap some args in a tuple.
-            if let Some(ty::Tuple(tys)) =
-                formal_and_expected_inputs.get(mismatch_idx.to_expected_idx()).map(|tys| tys.1.kind())
-                // If the tuple is unit, we're not actually wrapping any arguments.
-                && !tys.is_empty()
-                && provided_arg_tys.len() == formal_and_expected_inputs.len() - 1 + tys.len()
-            {
-                // Wrap up the N provided arguments starting at this position in a tuple.
-                let provided_args_to_tuple = &provided_arg_tys[mismatch_idx..];
-                let (provided_args_to_tuple, provided_args_after_tuple) =
-                    provided_args_to_tuple.split_at(tys.len());
-                let provided_as_tuple =
-                    Ty::new_tup_from_iter(tcx, provided_args_to_tuple.iter().map(|&(ty, _)| ty));
-
-                let mut satisfied = true;
-                // Check if the newly wrapped tuple + rest of the arguments are compatible.
-                for ((_, expected_ty), provided_ty) in std::iter::zip(
-                    formal_and_expected_inputs[mismatch_idx.to_expected_idx()..].iter(),
-                    [provided_as_tuple]
-                        .into_iter()
-                        .chain(provided_args_after_tuple.iter().map(|&(ty, _)| ty)),
-                ) {
-                    if !self.may_coerce(provided_ty, *expected_ty) {
-                        satisfied = false;
-                        break;
-                    }
-                }
+        if let Some(err) = fn_call_diag_ctxt.check_wrap_args_in_tuple() {
+            return err;
+        }
 
-                // If they're compatible, suggest wrapping in an arg, and we're done!
-                // Take some care with spans, so we don't suggest wrapping a macro's
-                // innards in parenthesis, for example.
-                if satisfied
-                    && let &[(_, hi @ lo)] | &[(_, lo), .., (_, hi)] = provided_args_to_tuple
-                {
-                    let mut err;
-                    if tys.len() == 1 {
-                        // A tuple wrap suggestion actually occurs within,
-                        // so don't do anything special here.
-                        err = self.err_ctxt().report_and_explain_type_error(
-                            mk_trace(
-                                lo,
-                                formal_and_expected_inputs[mismatch_idx.to_expected_idx()],
-                                provided_arg_tys[mismatch_idx].0,
-                            ),
-                            self.param_env,
-                            terr,
-                        );
-                        err.span_label(
-                            full_call_span,
-                            format!("arguments to this {call_name} are incorrect"),
-                        );
-                    } else {
-                        err = self.dcx().struct_span_err(
-                            full_call_span,
-                            format!(
-                                "{call_name} takes {}{} but {} {} supplied",
-                                if c_variadic { "at least " } else { "" },
-                                potentially_plural_count(
-                                    formal_and_expected_inputs.len(),
-                                    "argument"
-                                ),
-                                potentially_plural_count(provided_args.len(), "argument"),
-                                pluralize!("was", provided_args.len())
-                            ),
-                        );
-                        err.code(err_code.to_owned());
-                        err.multipart_suggestion_verbose(
-                            "wrap these arguments in parentheses to construct a tuple",
-                            vec![
-                                (lo.shrink_to_lo(), "(".to_string()),
-                                (hi.shrink_to_hi(), ")".to_string()),
-                            ],
-                            Applicability::MachineApplicable,
-                        );
-                    };
-                    self.label_fn_like(
-                        &mut err,
-                        fn_def_id,
-                        callee_ty,
-                        call_expr,
-                        None,
-                        Some(mismatch_idx.as_usize()),
-                        &matched_inputs,
-                        &formal_and_expected_inputs,
-                        is_method,
-                        tuple_arguments,
-                    );
-                    suggest_confusable(&mut err);
-                    return err.emit();
-                }
-            }
+        if let Some(fallback_error) = fn_call_diag_ctxt.ensure_has_errors() {
+            return fallback_error;
         }
 
         // Okay, so here's where it gets complicated in regards to what errors
@@ -926,1067 +596,423 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         //   2) Valid but incorrect arguments
         //   3) Invalid arguments
         //      - Currently I think this only comes up with `CyclicTy`
-        //
+
         // We first need to go through, remove those from (3) and emit those
         // as their own error, particularly since they're error code and
         // message is special. From what I can tell, we *must* emit these
         // here (vs somewhere prior to this function) since the arguments
         // become invalid *because* of how they get used in the function.
         // It is what it is.
-
-        if errors.is_empty() {
-            if cfg!(debug_assertions) {
-                span_bug!(error_span, "expected errors from argument matrix");
-            } else {
-                let mut err =
-                    self.dcx().create_err(errors::ArgMismatchIndeterminate { span: error_span });
-                suggest_confusable(&mut err);
-                return err.emit();
-            }
+        if let Some(err) = fn_call_diag_ctxt.filter_out_invalid_arguments()
+            && fn_call_diag_ctxt.errors.is_empty()
+        {
+            // We're done if we found errors, but we already emitted them.
+            return err;
         }
 
-        let detect_dotdot = |err: &mut Diag<'_>, ty: Ty<'_>, expr: &hir::Expr<'_>| {
-            if let ty::Adt(adt, _) = ty.kind()
-                && self.tcx().is_lang_item(adt.did(), hir::LangItem::RangeFull)
-                && let hir::ExprKind::Struct(
-                    hir::QPath::LangItem(hir::LangItem::RangeFull, _),
-                    [],
-                    _,
-                ) = expr.kind
-            {
-                // We have `Foo(a, .., c)`, where the user might be trying to use the "rest" syntax
-                // from default field values, which is not supported on tuples.
-                let explanation = if self.tcx.features().default_field_values() {
-                    "this is only supported on non-tuple struct literals"
-                } else if self.tcx.sess.is_nightly_build() {
-                    "this is only supported on non-tuple struct literals when \
-                     `#![feature(default_field_values)]` is enabled"
-                } else {
-                    "this is not supported"
-                };
-                let msg = format!(
-                    "you might have meant to use `..` to skip providing a value for \
-                     expected fields, but {explanation}; it is instead interpreted as a \
-                     `std::ops::RangeFull` literal",
-                );
-                err.span_help(expr.span, msg);
-            }
-        };
-
-        let mut reported = None;
-        errors.retain(|error| {
-            let Error::Invalid(provided_idx, expected_idx, Compatibility::Incompatible(Some(e))) =
-                error
-            else {
-                return true;
-            };
-            let (provided_ty, provided_span) = provided_arg_tys[*provided_idx];
-            let trace =
-                mk_trace(provided_span, formal_and_expected_inputs[*expected_idx], provided_ty);
-            if !matches!(trace.cause.as_failure_code(*e), FailureCode::Error0308) {
-                let mut err =
-                    self.err_ctxt().report_and_explain_type_error(trace, self.param_env, *e);
-                suggest_confusable(&mut err);
-                reported = Some(err.emit());
-                return false;
-            }
-            true
-        });
+        assert!(!fn_call_diag_ctxt.errors.is_empty());
 
-        // We're done if we found errors, but we already emitted them.
-        if let Some(reported) = reported
-            && errors.is_empty()
-        {
-            return reported;
+        // Last special case: if there is only one "Incompatible" error, just emit that
+        if let Some(err) = fn_call_diag_ctxt.check_single_incompatible() {
+            return err;
         }
-        assert!(!errors.is_empty());
 
         // Okay, now that we've emitted the special errors separately, we
         // are only left missing/extra/swapped and mismatched arguments, both
         // can be collated pretty easily if needed.
 
-        // Next special case: if there is only one "Incompatible" error, just emit that
-        if let &[
-            Error::Invalid(provided_idx, expected_idx, Compatibility::Incompatible(Some(err))),
-        ] = &errors[..]
-        {
-            let (formal_ty, expected_ty) = formal_and_expected_inputs[expected_idx];
-            let (provided_ty, provided_arg_span) = provided_arg_tys[provided_idx];
-            let trace = mk_trace(provided_arg_span, (formal_ty, expected_ty), provided_ty);
-            let mut err = self.err_ctxt().report_and_explain_type_error(trace, self.param_env, err);
-            self.emit_coerce_suggestions(
-                &mut err,
-                provided_args[provided_idx],
-                provided_ty,
-                Expectation::rvalue_hint(self, expected_ty)
-                    .only_has_type(self)
-                    .unwrap_or(formal_ty),
-                None,
-                None,
-            );
-            err.span_label(full_call_span, format!("arguments to this {call_name} are incorrect"));
+        // Special case, we found an extra argument is provided, which is very common in practice.
+        // but there is a obviously better removing suggestion compared to the current one,
+        // try to find the argument with Error type, if we removed it all the types will become good,
+        // then we will replace the current suggestion.
+        fn_call_diag_ctxt.maybe_optimize_extra_arg_suggestion();
 
-            self.label_generic_mismatches(
-                &mut err,
-                fn_def_id,
-                &matched_inputs,
-                &provided_arg_tys,
-                &formal_and_expected_inputs,
-                is_method,
-            );
+        let mut err = fn_call_diag_ctxt.initial_final_diagnostic();
+        fn_call_diag_ctxt.suggest_confusable(&mut err);
 
-            if let hir::ExprKind::MethodCall(_, rcvr, _, _) = call_expr.kind
-                && provided_idx.as_usize() == expected_idx.as_usize()
-            {
-                self.note_source_of_type_mismatch_constraint(
-                    &mut err,
-                    rcvr,
-                    crate::demand::TypeMismatchSource::Arg {
-                        call_expr,
-                        incompatible_arg: provided_idx.as_usize(),
-                    },
-                );
-            }
+        // As we encounter issues, keep track of what we want to provide for the suggestion.
 
-            self.suggest_ptr_null_mut(
-                expected_ty,
-                provided_ty,
-                provided_args[provided_idx],
-                &mut err,
-            );
+        let (mut suggestions, labels, suggestion_text) =
+            fn_call_diag_ctxt.labels_and_suggestion_text(&mut err);
 
-            self.suggest_deref_unwrap_or(
-                &mut err,
-                callee_ty,
-                call_ident,
-                expected_ty,
-                provided_ty,
-                provided_args[provided_idx],
-                is_method,
-            );
+        fn_call_diag_ctxt.label_generic_mismatches(&mut err);
+        fn_call_diag_ctxt.append_arguments_changes(&mut suggestions);
 
-            // Call out where the function is defined
-            self.label_fn_like(
-                &mut err,
-                fn_def_id,
-                callee_ty,
-                call_expr,
-                Some(expected_ty),
-                Some(expected_idx.as_usize()),
-                &matched_inputs,
-                &formal_and_expected_inputs,
-                is_method,
-                tuple_arguments,
-            );
-            suggest_confusable(&mut err);
-            detect_dotdot(&mut err, provided_ty, provided_args[provided_idx]);
-            return err.emit();
+        // If we have less than 5 things to say, it would be useful to call out exactly what's wrong
+        if labels.len() <= 5 {
+            for (span, label) in labels {
+                err.span_label(span, label);
+            }
         }
 
-        // Special case, we found an extra argument is provided, which is very common in practice.
-        // but there is a obviously better removing suggestion compared to the current one,
-        // try to find the argument with Error type, if we removed it all the types will become good,
-        // then we will replace the current suggestion.
-        if let [Error::Extra(provided_idx)] = &errors[..] {
-            let remove_idx_is_perfect = |idx: usize| -> bool {
-                let removed_arg_tys = provided_arg_tys
-                    .iter()
-                    .enumerate()
-                    .filter_map(|(j, arg)| if idx == j { None } else { Some(arg) })
-                    .collect::<IndexVec<ProvidedIdx, _>>();
-                std::iter::zip(formal_and_expected_inputs.iter(), removed_arg_tys.iter()).all(
-                    |((expected_ty, _), (provided_ty, _))| {
-                        !provided_ty.references_error()
-                            && self.may_coerce(*provided_ty, *expected_ty)
-                    },
-                )
-            };
+        // Call out where the function is defined
+        fn_call_diag_ctxt.label_fn_like(
+            &mut err,
+            fn_def_id,
+            fn_call_diag_ctxt.callee_ty,
+            call_expr,
+            None,
+            None,
+            &fn_call_diag_ctxt.matched_inputs,
+            &fn_call_diag_ctxt.formal_and_expected_inputs,
+            fn_call_diag_ctxt.call_metadata.is_method,
+            tuple_arguments,
+        );
 
-            if !remove_idx_is_perfect(provided_idx.as_usize()) {
-                if let Some(i) = (0..provided_args.len()).find(|&i| remove_idx_is_perfect(i)) {
-                    errors = vec![Error::Extra(ProvidedIdx::from_usize(i))];
-                }
-            }
+        // And add a suggestion block for all of the parameters
+        if let Some(suggestion_message) =
+            FnCallDiagCtxt::format_suggestion_text(&mut err, suggestions, suggestion_text)
+            && !fn_call_diag_ctxt.call_is_in_macro()
+        {
+            let (suggestion_span, suggestion_code) = fn_call_diag_ctxt.suggestion_code();
+
+            err.span_suggestion_verbose(
+                suggestion_span,
+                suggestion_message,
+                suggestion_code,
+                Applicability::HasPlaceholders,
+            );
         }
 
-        let mut err = if formal_and_expected_inputs.len() == provided_args.len() {
-            struct_span_code_err!(
-                self.dcx(),
-                full_call_span,
-                E0308,
-                "arguments to this {} are incorrect",
-                call_name,
-            )
-        } else {
-            self.dcx()
-                .struct_span_err(
-                    full_call_span,
-                    format!(
-                        "this {} takes {}{} but {} {} supplied",
-                        call_name,
-                        if c_variadic { "at least " } else { "" },
-                        potentially_plural_count(formal_and_expected_inputs.len(), "argument"),
-                        potentially_plural_count(provided_args.len(), "argument"),
-                        pluralize!("was", provided_args.len())
-                    ),
-                )
-                .with_code(err_code.to_owned())
-        };
+        err.emit()
+    }
 
-        suggest_confusable(&mut err);
-        // As we encounter issues, keep track of what we want to provide for the suggestion
-        let mut labels = vec![];
-        // If there is a single error, we give a specific suggestion; otherwise, we change to
-        // "did you mean" with the suggested function call
-        enum SuggestionText {
-            None,
-            Provide(bool),
-            Remove(bool),
-            Swap,
-            Reorder,
-            DidYouMean,
+    fn suggest_ptr_null_mut(
+        &self,
+        expected_ty: Ty<'tcx>,
+        provided_ty: Ty<'tcx>,
+        arg: &hir::Expr<'tcx>,
+        err: &mut Diag<'_>,
+    ) {
+        if let ty::RawPtr(_, hir::Mutability::Mut) = expected_ty.kind()
+            && let ty::RawPtr(_, hir::Mutability::Not) = provided_ty.kind()
+            && let hir::ExprKind::Call(callee, _) = arg.kind
+            && let hir::ExprKind::Path(hir::QPath::Resolved(_, path)) = callee.kind
+            && let Res::Def(_, def_id) = path.res
+            && self.tcx.get_diagnostic_item(sym::ptr_null) == Some(def_id)
+        {
+            // The user provided `ptr::null()`, but the function expects
+            // `ptr::null_mut()`.
+            err.subdiagnostic(SuggestPtrNullMut { span: arg.span });
         }
-        let mut suggestion_text = SuggestionText::None;
+    }
 
-        let ty_to_snippet = |ty: Ty<'tcx>, expected_idx: ExpectedIdx| {
-            if ty.is_unit() {
-                "()".to_string()
-            } else if ty.is_suggestable(tcx, false) {
-                format!("/* {ty} */")
-            } else if let Some(fn_def_id) = fn_def_id
-                && self.tcx.def_kind(fn_def_id).is_fn_like()
-                && let self_implicit =
-                    matches!(call_expr.kind, hir::ExprKind::MethodCall(..)) as usize
-                && let Some(Some(arg)) =
-                    self.tcx.fn_arg_idents(fn_def_id).get(expected_idx.as_usize() + self_implicit)
-                && arg.name != kw::SelfLower
-            {
-                format!("/* {} */", arg.name)
-            } else {
-                "/* value */".to_string()
-            }
-        };
+    // AST fragment checking
+    pub(in super::super) fn check_expr_lit(
+        &self,
+        lit: &hir::Lit,
+        expected: Expectation<'tcx>,
+    ) -> Ty<'tcx> {
+        let tcx = self.tcx;
 
-        let mut errors = errors.into_iter().peekable();
-        let mut only_extras_so_far = errors
-            .peek()
-            .is_some_and(|first| matches!(first, Error::Extra(arg_idx) if arg_idx.index() == 0));
-        let mut prev_extra_idx = None;
-        let mut suggestions = vec![];
-        while let Some(error) = errors.next() {
-            only_extras_so_far &= matches!(error, Error::Extra(_));
+        match lit.node {
+            ast::LitKind::Str(..) => Ty::new_static_str(tcx),
+            ast::LitKind::ByteStr(ref v, _) => Ty::new_imm_ref(
+                tcx,
+                tcx.lifetimes.re_static,
+                Ty::new_array(tcx, tcx.types.u8, v.as_byte_str().len() as u64),
+            ),
+            ast::LitKind::Byte(_) => tcx.types.u8,
+            ast::LitKind::Char(_) => tcx.types.char,
+            ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => Ty::new_int(tcx, t),
+            ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => Ty::new_uint(tcx, t),
+            ast::LitKind::Int(i, ast::LitIntType::Unsuffixed) => {
+                let opt_ty = expected.to_option(self).and_then(|ty| match ty.kind() {
+                    ty::Int(_) | ty::Uint(_) => Some(ty),
+                    // These exist to direct casts like `0x61 as char` to use
+                    // the right integer type to cast from, instead of falling back to
+                    // i32 due to no further constraints.
+                    ty::Char => Some(tcx.types.u8),
+                    ty::RawPtr(..) => Some(tcx.types.usize),
+                    ty::FnDef(..) | ty::FnPtr(..) => Some(tcx.types.usize),
+                    &ty::Pat(base, _) if base.is_integral() => {
+                        let layout = tcx
+                            .layout_of(self.typing_env(self.param_env).as_query_input(ty))
+                            .ok()?;
+                        assert!(!layout.uninhabited);
 
-            match error {
-                Error::Invalid(provided_idx, expected_idx, compatibility) => {
-                    let (formal_ty, expected_ty) = formal_and_expected_inputs[expected_idx];
-                    let (provided_ty, provided_span) = provided_arg_tys[provided_idx];
-                    if let Compatibility::Incompatible(error) = compatibility {
-                        let trace = mk_trace(provided_span, (formal_ty, expected_ty), provided_ty);
-                        if let Some(e) = error {
-                            self.err_ctxt().note_type_err(
-                                &mut err,
-                                &trace.cause,
-                                None,
-                                Some(self.param_env.and(trace.values)),
-                                e,
-                                true,
-                                None,
-                            );
+                        match layout.backend_repr {
+                            rustc_abi::BackendRepr::Scalar(scalar) => {
+                                scalar.valid_range(&tcx).contains(u128::from(i.get())).then_some(ty)
+                            }
+                            _ => unreachable!(),
                         }
                     }
+                    _ => None,
+                });
+                opt_ty.unwrap_or_else(|| self.next_int_var())
+            }
+            ast::LitKind::Float(_, ast::LitFloatType::Suffixed(t)) => Ty::new_float(tcx, t),
+            ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) => {
+                let opt_ty = expected.to_option(self).and_then(|ty| match ty.kind() {
+                    ty::Float(_) => Some(ty),
+                    _ => None,
+                });
+                opt_ty.unwrap_or_else(|| self.next_float_var())
+            }
+            ast::LitKind::Bool(_) => tcx.types.bool,
+            ast::LitKind::CStr(_, _) => Ty::new_imm_ref(
+                tcx,
+                tcx.lifetimes.re_static,
+                tcx.type_of(tcx.require_lang_item(hir::LangItem::CStr, lit.span)).skip_binder(),
+            ),
+            ast::LitKind::Err(guar) => Ty::new_error(tcx, guar),
+        }
+    }
 
-                    self.emit_coerce_suggestions(
-                        &mut err,
-                        provided_args[provided_idx],
-                        provided_ty,
-                        Expectation::rvalue_hint(self, expected_ty)
-                            .only_has_type(self)
-                            .unwrap_or(formal_ty),
-                        None,
-                        None,
-                    );
-                    detect_dotdot(&mut err, provided_ty, provided_args[provided_idx]);
+    pub(crate) fn check_struct_path(
+        &self,
+        qpath: &QPath<'tcx>,
+        hir_id: HirId,
+    ) -> Result<(&'tcx ty::VariantDef, Ty<'tcx>), ErrorGuaranteed> {
+        let path_span = qpath.span();
+        let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
+        let variant = match def {
+            Res::Err => {
+                let guar =
+                    self.dcx().span_delayed_bug(path_span, "`Res::Err` but no error emitted");
+                self.set_tainted_by_errors(guar);
+                return Err(guar);
+            }
+            Res::Def(DefKind::Variant, _) => match ty.normalized.ty_adt_def() {
+                Some(adt) => {
+                    Some((adt.variant_of_res(def), adt.did(), Self::user_args_for_adt(ty)))
                 }
-                Error::Extra(arg_idx) => {
-                    let (provided_ty, provided_span) = provided_arg_tys[arg_idx];
-                    let provided_ty_name = if !has_error_or_infer([provided_ty]) {
-                        // FIXME: not suggestable, use something else
-                        format!(" of type `{provided_ty}`")
-                    } else {
-                        "".to_string()
-                    };
-                    let idx = if provided_arg_tys.len() == 1 {
-                        "".to_string()
-                    } else {
-                        format!(" #{}", arg_idx.as_usize() + 1)
-                    };
-                    labels.push((
-                        provided_span,
-                        format!("unexpected argument{idx}{provided_ty_name}"),
-                    ));
-                    let mut span = provided_span;
-                    if span.can_be_used_for_suggestions()
-                        && error_span.can_be_used_for_suggestions()
-                    {
-                        if arg_idx.index() > 0
-                            && let Some((_, prev)) =
-                                provided_arg_tys.get(ProvidedIdx::from_usize(arg_idx.index() - 1))
-                        {
-                            // Include previous comma
-                            span = prev.shrink_to_hi().to(span);
-                        }
-
-                        // Is last argument for deletion in a row starting from the 0-th argument?
-                        // Then delete the next comma, so we are not left with `f(, ...)`
-                        //
-                        //     fn f() {}
-                        //   - f(0, 1,)
-                        //   + f()
-                        let trim_next_comma = match errors.peek() {
-                            Some(Error::Extra(provided_idx))
-                                if only_extras_so_far
-                                    && provided_idx.index() > arg_idx.index() + 1 =>
-                            // If the next Error::Extra ("next") doesn't next to current ("current"),
-                            // fn foo(_: (), _: u32) {}
-                            // - foo("current", (), 1u32, "next")
-                            // + foo((), 1u32)
-                            // If the previous error is not a `Error::Extra`, then do not trim the next comma
-                            // - foo((), "current", 42u32, "next")
-                            // + foo((), 42u32)
-                            {
-                                prev_extra_idx.is_none_or(|prev_extra_idx| {
-                                    prev_extra_idx + 1 == arg_idx.index()
-                                })
-                            }
-                            // If no error left, we need to delete the next comma
-                            None if only_extras_so_far => true,
-                            // Not sure if other error type need to be handled as well
-                            _ => false,
-                        };
+                _ => bug!("unexpected type: {:?}", ty.normalized),
+            },
+            Res::Def(
+                DefKind::Struct | DefKind::Union | DefKind::TyAlias { .. } | DefKind::AssocTy,
+                _,
+            )
+            | Res::SelfTyParam { .. }
+            | Res::SelfTyAlias { .. } => match ty.normalized.ty_adt_def() {
+                Some(adt) if !adt.is_enum() => {
+                    Some((adt.non_enum_variant(), adt.did(), Self::user_args_for_adt(ty)))
+                }
+                _ => None,
+            },
+            _ => bug!("unexpected definition: {:?}", def),
+        };
 
-                        if trim_next_comma {
-                            let next = provided_arg_tys
-                                .get(arg_idx + 1)
-                                .map(|&(_, sp)| sp)
-                                .unwrap_or_else(|| {
-                                    // Try to move before `)`. Note that `)` here is not necessarily
-                                    // the latin right paren, it could be a Unicode-confusable that
-                                    // looks like a `)`, so we must not use `- BytePos(1)`
-                                    // manipulations here.
-                                    self.tcx().sess.source_map().end_point(call_expr.span)
-                                });
+        if let Some((variant, did, ty::UserArgs { args, user_self_ty })) = variant {
+            debug!("check_struct_path: did={:?} args={:?}", did, args);
 
-                            // Include next comma
-                            span = span.until(next);
-                        }
+            // Register type annotation.
+            self.write_user_type_annotation_from_args(hir_id, did, args, user_self_ty);
 
-                        suggestions.push((span, String::new()));
+            // Check bounds on type arguments used in the path.
+            self.add_required_obligations_for_hir(path_span, did, args, hir_id);
 
-                        suggestion_text = match suggestion_text {
-                            SuggestionText::None => SuggestionText::Remove(false),
-                            SuggestionText::Remove(_) => SuggestionText::Remove(true),
-                            _ => SuggestionText::DidYouMean,
-                        };
-                        prev_extra_idx = Some(arg_idx.index())
-                    }
-                    detect_dotdot(&mut err, provided_ty, provided_args[arg_idx]);
+            Ok((variant, ty.normalized))
+        } else {
+            Err(match *ty.normalized.kind() {
+                ty::Error(guar) => {
+                    // E0071 might be caused by a spelling error, which will have
+                    // already caused an error message and probably a suggestion
+                    // elsewhere. Refrain from emitting more unhelpful errors here
+                    // (issue #88844).
+                    guar
                 }
-                Error::Missing(expected_idx) => {
-                    // If there are multiple missing arguments adjacent to each other,
-                    // then we can provide a single error.
+                _ => struct_span_code_err!(
+                    self.dcx(),
+                    path_span,
+                    E0071,
+                    "expected struct, variant or union type, found {}",
+                    ty.normalized.sort_string(self.tcx)
+                )
+                .with_span_label(path_span, "not a struct")
+                .emit(),
+            })
+        }
+    }
 
-                    let mut missing_idxs = vec![expected_idx];
-                    while let Some(e) = errors.next_if(|e| {
-                        matches!(e, Error::Missing(next_expected_idx)
-                            if *next_expected_idx == *missing_idxs.last().unwrap() + 1)
-                    }) {
-                        match e {
-                            Error::Missing(expected_idx) => missing_idxs.push(expected_idx),
-                            _ => unreachable!(
-                                "control flow ensures that we should always get an `Error::Missing`"
-                            ),
-                        }
-                    }
+    fn check_decl_initializer(
+        &self,
+        hir_id: HirId,
+        pat: &'tcx hir::Pat<'tcx>,
+        init: &'tcx hir::Expr<'tcx>,
+    ) -> Ty<'tcx> {
+        // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
+        // for #42640 (default match binding modes).
+        //
+        // See #44848.
+        let ref_bindings = pat.contains_explicit_ref_binding();
 
-                    // NOTE: Because we might be re-arranging arguments, might have extra
-                    // arguments, etc. it's hard to *really* know where we should provide
-                    // this error label, so as a heuristic, we point to the provided arg, or
-                    // to the call if the missing inputs pass the provided args.
-                    match &missing_idxs[..] {
-                        &[expected_idx] => {
-                            let (_, input_ty) = formal_and_expected_inputs[expected_idx];
-                            let span = if let Some((_, arg_span)) =
-                                provided_arg_tys.get(expected_idx.to_provided_idx())
-                            {
-                                *arg_span
-                            } else {
-                                args_span
-                            };
-                            let rendered = if !has_error_or_infer([input_ty]) {
-                                format!(" of type `{input_ty}`")
-                            } else {
-                                "".to_string()
-                            };
-                            labels.push((
-                                span,
-                                format!(
-                                    "argument #{}{rendered} is missing",
-                                    expected_idx.as_usize() + 1
-                                ),
-                            ));
+        let local_ty = self.local_ty(init.span, hir_id);
+        if let Some(m) = ref_bindings {
+            // Somewhat subtle: if we have a `ref` binding in the pattern,
+            // we want to avoid introducing coercions for the RHS. This is
+            // both because it helps preserve sanity and, in the case of
+            // ref mut, for soundness (issue #23116). In particular, in
+            // the latter case, we need to be clear that the type of the
+            // referent for the reference that results is *equal to* the
+            // type of the place it is referencing, and not some
+            // supertype thereof.
+            let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
+            if let Err(mut diag) = self.demand_eqtype_diag(init.span, local_ty, init_ty) {
+                self.emit_type_mismatch_suggestions(
+                    &mut diag,
+                    init.peel_drop_temps(),
+                    init_ty,
+                    local_ty,
+                    None,
+                    None,
+                );
+                diag.emit();
+            }
+            init_ty
+        } else {
+            self.check_expr_coercible_to_type(init, local_ty, None)
+        }
+    }
 
-                            suggestion_text = match suggestion_text {
-                                SuggestionText::None => SuggestionText::Provide(false),
-                                SuggestionText::Provide(_) => SuggestionText::Provide(true),
-                                _ => SuggestionText::DidYouMean,
-                            };
-                        }
-                        &[first_idx, second_idx] => {
-                            let (_, first_expected_ty) = formal_and_expected_inputs[first_idx];
-                            let (_, second_expected_ty) = formal_and_expected_inputs[second_idx];
-                            let span = if let (Some((_, first_span)), Some((_, second_span))) = (
-                                provided_arg_tys.get(first_idx.to_provided_idx()),
-                                provided_arg_tys.get(second_idx.to_provided_idx()),
-                            ) {
-                                first_span.to(*second_span)
-                            } else {
-                                args_span
-                            };
-                            let rendered =
-                                if !has_error_or_infer([first_expected_ty, second_expected_ty]) {
-                                    format!(
-                                        " of type `{first_expected_ty}` and `{second_expected_ty}`"
-                                    )
-                                } else {
-                                    "".to_string()
-                                };
-                            labels.push((span, format!("two arguments{rendered} are missing")));
-                            suggestion_text = match suggestion_text {
-                                SuggestionText::None | SuggestionText::Provide(_) => {
-                                    SuggestionText::Provide(true)
-                                }
-                                _ => SuggestionText::DidYouMean,
-                            };
-                        }
-                        &[first_idx, second_idx, third_idx] => {
-                            let (_, first_expected_ty) = formal_and_expected_inputs[first_idx];
-                            let (_, second_expected_ty) = formal_and_expected_inputs[second_idx];
-                            let (_, third_expected_ty) = formal_and_expected_inputs[third_idx];
-                            let span = if let (Some((_, first_span)), Some((_, third_span))) = (
-                                provided_arg_tys.get(first_idx.to_provided_idx()),
-                                provided_arg_tys.get(third_idx.to_provided_idx()),
-                            ) {
-                                first_span.to(*third_span)
-                            } else {
-                                args_span
-                            };
-                            let rendered = if !has_error_or_infer([
-                                first_expected_ty,
-                                second_expected_ty,
-                                third_expected_ty,
-                            ]) {
-                                format!(
-                                    " of type `{first_expected_ty}`, `{second_expected_ty}`, and `{third_expected_ty}`"
-                                )
-                            } else {
-                                "".to_string()
-                            };
-                            labels.push((span, format!("three arguments{rendered} are missing")));
-                            suggestion_text = match suggestion_text {
-                                SuggestionText::None | SuggestionText::Provide(_) => {
-                                    SuggestionText::Provide(true)
-                                }
-                                _ => SuggestionText::DidYouMean,
-                            };
-                        }
-                        missing_idxs => {
-                            let first_idx = *missing_idxs.first().unwrap();
-                            let last_idx = *missing_idxs.last().unwrap();
-                            // NOTE: Because we might be re-arranging arguments, might have extra arguments, etc.
-                            // It's hard to *really* know where we should provide this error label, so this is a
-                            // decent heuristic
-                            let span = if let (Some((_, first_span)), Some((_, last_span))) = (
-                                provided_arg_tys.get(first_idx.to_provided_idx()),
-                                provided_arg_tys.get(last_idx.to_provided_idx()),
-                            ) {
-                                first_span.to(*last_span)
-                            } else {
-                                args_span
-                            };
-                            labels.push((span, "multiple arguments are missing".to_string()));
-                            suggestion_text = match suggestion_text {
-                                SuggestionText::None | SuggestionText::Provide(_) => {
-                                    SuggestionText::Provide(true)
-                                }
-                                _ => SuggestionText::DidYouMean,
-                            };
-                        }
-                    }
-                }
-                Error::Swap(
-                    first_provided_idx,
-                    second_provided_idx,
-                    first_expected_idx,
-                    second_expected_idx,
-                ) => {
-                    let (first_provided_ty, first_span) = provided_arg_tys[first_provided_idx];
-                    let (_, first_expected_ty) = formal_and_expected_inputs[first_expected_idx];
-                    let first_provided_ty_name = if !has_error_or_infer([first_provided_ty]) {
-                        format!(", found `{first_provided_ty}`")
-                    } else {
-                        String::new()
-                    };
-                    labels.push((
-                        first_span,
-                        format!("expected `{first_expected_ty}`{first_provided_ty_name}"),
-                    ));
+    pub(in super::super) fn check_decl(&self, decl: Declaration<'tcx>) -> Ty<'tcx> {
+        // Determine and write the type which we'll check the pattern against.
+        let decl_ty = self.local_ty(decl.span, decl.hir_id);
 
-                    let (second_provided_ty, second_span) = provided_arg_tys[second_provided_idx];
-                    let (_, second_expected_ty) = formal_and_expected_inputs[second_expected_idx];
-                    let second_provided_ty_name = if !has_error_or_infer([second_provided_ty]) {
-                        format!(", found `{second_provided_ty}`")
-                    } else {
-                        String::new()
-                    };
-                    labels.push((
-                        second_span,
-                        format!("expected `{second_expected_ty}`{second_provided_ty_name}"),
-                    ));
+        // Type check the initializer.
+        if let Some(ref init) = decl.init {
+            let init_ty = self.check_decl_initializer(decl.hir_id, decl.pat, init);
+            self.overwrite_local_ty_if_err(decl.hir_id, decl.pat, init_ty);
+        }
 
-                    suggestion_text = match suggestion_text {
-                        SuggestionText::None => SuggestionText::Swap,
-                        _ => SuggestionText::DidYouMean,
-                    };
-                }
-                Error::Permutation(args) => {
-                    for (dst_arg, dest_input) in args {
-                        let (_, expected_ty) = formal_and_expected_inputs[dst_arg];
-                        let (provided_ty, provided_span) = provided_arg_tys[dest_input];
-                        let provided_ty_name = if !has_error_or_infer([provided_ty]) {
-                            format!(", found `{provided_ty}`")
-                        } else {
-                            String::new()
-                        };
-                        labels.push((
-                            provided_span,
-                            format!("expected `{expected_ty}`{provided_ty_name}"),
-                        ));
-                    }
+        // Does the expected pattern type originate from an expression and what is the span?
+        let (origin_expr, ty_span) = match (decl.ty, decl.init) {
+            (Some(ty), _) => (None, Some(ty.span)), // Bias towards the explicit user type.
+            (_, Some(init)) => {
+                (Some(init), Some(init.span.find_ancestor_inside(decl.span).unwrap_or(init.span)))
+            } // No explicit type; so use the scrutinee.
+            _ => (None, None), // We have `let $pat;`, so the expected type is unconstrained.
+        };
 
-                    suggestion_text = match suggestion_text {
-                        SuggestionText::None => SuggestionText::Reorder,
-                        _ => SuggestionText::DidYouMean,
-                    };
-                }
+        // Type check the pattern. Override if necessary to avoid knock-on errors.
+        self.check_pat_top(decl.pat, decl_ty, ty_span, origin_expr, Some(decl.origin));
+        let pat_ty = self.node_ty(decl.pat.hir_id);
+        self.overwrite_local_ty_if_err(decl.hir_id, decl.pat, pat_ty);
+
+        if let Some(blk) = decl.origin.try_get_else() {
+            let previous_diverges = self.diverges.get();
+            let else_ty = self.check_expr_block(blk, NoExpectation);
+            let cause = self.cause(blk.span, ObligationCauseCode::LetElse);
+            if let Err(err) = self.demand_eqtype_with_origin(&cause, self.tcx.types.never, else_ty)
+            {
+                err.emit();
             }
+            self.diverges.set(previous_diverges);
         }
+        decl_ty
+    }
 
-        self.label_generic_mismatches(
-            &mut err,
-            fn_def_id,
-            &matched_inputs,
-            &provided_arg_tys,
-            &formal_and_expected_inputs,
-            is_method,
-        );
+    /// Type check a `let` statement.
+    fn check_decl_local(&self, local: &'tcx hir::LetStmt<'tcx>) {
+        GatherLocalsVisitor::gather_from_local(self, local);
 
-        // Incorporate the argument changes in the removal suggestion.
-        // When a type is *missing*, and the rest are additional, we want to suggest these with a
-        // multipart suggestion, but in order to do so we need to figure out *where* the arg that
-        // was provided but had the wrong type should go, because when looking at `expected_idx`
-        // that is the position in the argument list in the definition, while `provided_idx` will
-        // not be present. So we have to look at what the *last* provided position was, and point
-        // one after to suggest the replacement. FIXME(estebank): This is hacky, and there's
-        // probably a better more involved change we can make to make this work.
-        // For example, if we have
-        // ```
-        // fn foo(i32, &'static str) {}
-        // foo((), (), ());
-        // ```
-        // what should be suggested is
-        // ```
-        // foo(/* i32 */, /* &str */);
-        // ```
-        // which includes the replacement of the first two `()` for the correct type, and the
-        // removal of the last `()`.
-        let mut prev = -1;
-        for (expected_idx, provided_idx) in matched_inputs.iter_enumerated() {
-            // We want to point not at the *current* argument expression index, but rather at the
-            // index position where it *should have been*, which is *after* the previous one.
-            if let Some(provided_idx) = provided_idx {
-                prev = provided_idx.index() as i64;
-                continue;
-            }
-            let idx = ProvidedIdx::from_usize((prev + 1) as usize);
-            if let Some((_, arg_span)) = provided_arg_tys.get(idx) {
-                prev += 1;
-                // There is a type that was *not* found anywhere, so it isn't a move, but a
-                // replacement and we look at what type it should have been. This will allow us
-                // To suggest a multipart suggestion when encountering `foo(1, "")` where the def
-                // was `fn foo(())`.
-                let (_, expected_ty) = formal_and_expected_inputs[expected_idx];
-                suggestions.push((*arg_span, ty_to_snippet(expected_ty, expected_idx)));
-            }
+        let ty = self.check_decl(local.into());
+        self.write_ty(local.hir_id, ty);
+        if local.pat.is_never_pattern() {
+            self.diverges.set(Diverges::Always {
+                span: local.pat.span,
+                custom_note: Some("any code following a never pattern is unreachable"),
+            });
         }
+    }
 
-        // If we have less than 5 things to say, it would be useful to call out exactly what's wrong
-        if labels.len() <= 5 {
-            for (span, label) in labels {
-                err.span_label(span, label);
-            }
+    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,
+            hir::StmtKind::Let(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
         }
 
-        // Call out where the function is defined
-        self.label_fn_like(
-            &mut err,
-            fn_def_id,
-            callee_ty,
-            call_expr,
-            None,
-            None,
-            &matched_inputs,
-            &formal_and_expected_inputs,
-            is_method,
-            tuple_arguments,
-        );
+        self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
 
-        // And add a suggestion block for all of the parameters
-        let suggestion_text = match suggestion_text {
-            SuggestionText::None => None,
-            SuggestionText::Provide(plural) => {
-                Some(format!("provide the argument{}", if plural { "s" } else { "" }))
-            }
-            SuggestionText::Remove(plural) => {
-                err.multipart_suggestion_verbose(
-                    format!("remove the extra argument{}", if plural { "s" } else { "" }),
-                    suggestions,
-                    Applicability::HasPlaceholders,
-                );
-                None
-            }
-            SuggestionText::Swap => Some("swap these arguments".to_string()),
-            SuggestionText::Reorder => Some("reorder these arguments".to_string()),
-            SuggestionText::DidYouMean => Some("did you mean".to_string()),
-        };
-        if let Some(suggestion_text) = suggestion_text
-            && !full_call_span.in_external_macro(self.sess().source_map())
-        {
-            let source_map = self.sess().source_map();
-            let suggestion_span = if let Some(args_span) = error_span.trim_start(full_call_span) {
-                // Span of the braces, e.g. `(a, b, c)`.
-                args_span
-            } else {
-                // The arg span of a function call that wasn't even given braces
-                // like what might happen with delegation reuse.
-                // e.g. `reuse HasSelf::method;` should suggest `reuse HasSelf::method($args);`.
-                full_call_span.shrink_to_hi()
-            };
+        // Hide the outer diverging flags.
+        let old_diverges = self.diverges.replace(Diverges::Maybe);
 
-            // Controls how the arguments should be listed in the suggestion.
-            enum ArgumentsFormatting {
-                SingleLine,
-                Multiline { fallback_indent: String, brace_indent: String },
+        match stmt.kind {
+            hir::StmtKind::Let(l) => {
+                self.check_decl_local(l);
             }
-            let arguments_formatting = {
-                let mut provided_inputs = matched_inputs.iter().filter_map(|a| *a);
-                if let Some(brace_indent) = source_map.indentation_before(suggestion_span)
-                    && let Some(first_idx) = provided_inputs.by_ref().next()
-                    && let Some(last_idx) = provided_inputs.by_ref().next()
-                    && let (_, first_span) = provided_arg_tys[first_idx]
-                    && let (_, last_span) = provided_arg_tys[last_idx]
-                    && source_map.is_multiline(first_span.to(last_span))
-                    && let Some(fallback_indent) = source_map.indentation_before(first_span)
-                {
-                    ArgumentsFormatting::Multiline { fallback_indent, brace_indent }
-                } else {
-                    ArgumentsFormatting::SingleLine
-                }
-            };
-
-            let mut suggestion = "(".to_owned();
-            let mut needs_comma = false;
-            for (expected_idx, provided_idx) in matched_inputs.iter_enumerated() {
-                if needs_comma {
-                    suggestion += ",";
-                }
-                match &arguments_formatting {
-                    ArgumentsFormatting::SingleLine if needs_comma => suggestion += " ",
-                    ArgumentsFormatting::SingleLine => {}
-                    ArgumentsFormatting::Multiline { .. } => suggestion += "\n",
-                }
-                needs_comma = true;
-                let (suggestion_span, suggestion_text) = if let Some(provided_idx) = provided_idx
-                    && let (_, provided_span) = provided_arg_tys[*provided_idx]
-                    && let Ok(arg_text) = source_map.span_to_snippet(provided_span)
-                {
-                    (Some(provided_span), arg_text)
-                } else {
-                    // Propose a placeholder of the correct type
-                    let (_, expected_ty) = formal_and_expected_inputs[expected_idx];
-                    (None, ty_to_snippet(expected_ty, expected_idx))
-                };
-                if let ArgumentsFormatting::Multiline { fallback_indent, .. } =
-                    &arguments_formatting
-                {
-                    let indent = suggestion_span
-                        .and_then(|span| source_map.indentation_before(span))
-                        .unwrap_or_else(|| fallback_indent.clone());
-                    suggestion += &indent;
-                }
-                suggestion += &suggestion_text;
+            // Ignore for now.
+            hir::StmtKind::Item(_) => {}
+            hir::StmtKind::Expr(ref expr) => {
+                // Check with expected type of `()`.
+                self.check_expr_has_type_or_error(expr, self.tcx.types.unit, |err| {
+                    if self.is_next_stmt_expr_continuation(stmt.hir_id)
+                        && let hir::ExprKind::Match(..) | hir::ExprKind::If(..) = expr.kind
+                    {
+                        // We have something like `match () { _ => true } && true`. Suggest
+                        // wrapping in parentheses. We find the statement or expression
+                        // following the `match` (`&& true`) and see if it is something that
+                        // can reasonably be interpreted as a binop following an expression.
+                        err.multipart_suggestion(
+                            "parentheses are required to parse this as an expression",
+                            vec![
+                                (expr.span.shrink_to_lo(), "(".to_string()),
+                                (expr.span.shrink_to_hi(), ")".to_string()),
+                            ],
+                            Applicability::MachineApplicable,
+                        );
+                    } else if expr.can_have_side_effects() {
+                        self.suggest_semicolon_at_end(expr.span, err);
+                    }
+                });
             }
-            if let ArgumentsFormatting::Multiline { brace_indent, .. } = arguments_formatting {
-                suggestion += ",\n";
-                suggestion += &brace_indent;
+            hir::StmtKind::Semi(expr) => {
+                let ty = self.check_expr(expr);
+                self.check_place_expr_if_unsized(ty, expr);
             }
-            suggestion += ")";
-            err.span_suggestion_verbose(
-                suggestion_span,
-                suggestion_text,
-                suggestion,
-                Applicability::HasPlaceholders,
-            );
         }
 
-        err.emit()
+        // Combine the diverging and `has_error` flags.
+        self.diverges.set(self.diverges.get() | old_diverges);
     }
 
-    fn suggest_ptr_null_mut(
-        &self,
-        expected_ty: Ty<'tcx>,
-        provided_ty: Ty<'tcx>,
-        arg: &hir::Expr<'tcx>,
-        err: &mut Diag<'_>,
-    ) {
-        if let ty::RawPtr(_, hir::Mutability::Mut) = expected_ty.kind()
-            && let ty::RawPtr(_, hir::Mutability::Not) = provided_ty.kind()
-            && let hir::ExprKind::Call(callee, _) = arg.kind
-            && let hir::ExprKind::Path(hir::QPath::Resolved(_, path)) = callee.kind
-            && let Res::Def(_, def_id) = path.res
-            && self.tcx.get_diagnostic_item(sym::ptr_null) == Some(def_id)
-        {
-            // The user provided `ptr::null()`, but the function expects
-            // `ptr::null_mut()`.
-            err.subdiagnostic(SuggestPtrNullMut { span: arg.span });
+    pub(crate) fn check_block_no_value(&self, blk: &'tcx hir::Block<'tcx>) {
+        let unit = self.tcx.types.unit;
+        let ty = self.check_expr_block(blk, ExpectHasType(unit));
+
+        // if the block produces a `!` value, that can always be
+        // (effectively) coerced to unit.
+        if !ty.is_never() {
+            self.demand_suptype(blk.span, unit, ty);
         }
     }
 
-    // AST fragment checking
-    pub(in super::super) fn check_expr_lit(
+    pub(in super::super) fn check_expr_block(
         &self,
-        lit: &hir::Lit,
+        blk: &'tcx hir::Block<'tcx>,
         expected: Expectation<'tcx>,
     ) -> Ty<'tcx> {
-        let tcx = self.tcx;
+        // In some cases, blocks have just one exit, but other blocks
+        // can be targeted by multiple breaks. This can happen both
+        // with labeled blocks as well as when we desugar
+        // a `try { ... }` expression.
+        //
+        // Example 1:
+        //
+        //    'a: { if true { break 'a Err(()); } Ok(()) }
+        //
+        // Here we would wind up with two coercions, one from
+        // `Err(())` and the other from the tail expression
+        // `Ok(())`. If the tail expression is omitted, that's a
+        // "forced unit" -- unless the block diverges, in which
+        // case we can ignore the tail expression (e.g., `'a: {
+        // break 'a 22; }` would not force the type of the block
+        // to be `()`).
+        let coerce_to_ty = expected.coercion_target_type(self, blk.span);
+        let coerce = if blk.targeted_by_break {
+            CoerceMany::new(coerce_to_ty)
+        } else {
+            CoerceMany::with_coercion_sites(coerce_to_ty, blk.expr.as_slice())
+        };
 
-        match lit.node {
-            ast::LitKind::Str(..) => Ty::new_static_str(tcx),
-            ast::LitKind::ByteStr(ref v, _) => Ty::new_imm_ref(
-                tcx,
-                tcx.lifetimes.re_static,
-                Ty::new_array(tcx, tcx.types.u8, v.as_byte_str().len() as u64),
-            ),
-            ast::LitKind::Byte(_) => tcx.types.u8,
-            ast::LitKind::Char(_) => tcx.types.char,
-            ast::LitKind::Int(_, ast::LitIntType::Signed(t)) => Ty::new_int(tcx, t),
-            ast::LitKind::Int(_, ast::LitIntType::Unsigned(t)) => Ty::new_uint(tcx, t),
-            ast::LitKind::Int(i, ast::LitIntType::Unsuffixed) => {
-                let opt_ty = expected.to_option(self).and_then(|ty| match ty.kind() {
-                    ty::Int(_) | ty::Uint(_) => Some(ty),
-                    // These exist to direct casts like `0x61 as char` to use
-                    // the right integer type to cast from, instead of falling back to
-                    // i32 due to no further constraints.
-                    ty::Char => Some(tcx.types.u8),
-                    ty::RawPtr(..) => Some(tcx.types.usize),
-                    ty::FnDef(..) | ty::FnPtr(..) => Some(tcx.types.usize),
-                    &ty::Pat(base, _) if base.is_integral() => {
-                        let layout = tcx
-                            .layout_of(self.typing_env(self.param_env).as_query_input(ty))
-                            .ok()?;
-                        assert!(!layout.uninhabited);
+        let prev_diverges = self.diverges.get();
+        let ctxt = BreakableCtxt { coerce: Some(coerce), may_break: false };
 
-                        match layout.backend_repr {
-                            rustc_abi::BackendRepr::Scalar(scalar) => {
-                                scalar.valid_range(&tcx).contains(u128::from(i.get())).then_some(ty)
-                            }
-                            _ => unreachable!(),
-                        }
-                    }
-                    _ => None,
-                });
-                opt_ty.unwrap_or_else(|| self.next_int_var())
-            }
-            ast::LitKind::Float(_, ast::LitFloatType::Suffixed(t)) => Ty::new_float(tcx, t),
-            ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) => {
-                let opt_ty = expected.to_option(self).and_then(|ty| match ty.kind() {
-                    ty::Float(_) => Some(ty),
-                    _ => None,
-                });
-                opt_ty.unwrap_or_else(|| self.next_float_var())
-            }
-            ast::LitKind::Bool(_) => tcx.types.bool,
-            ast::LitKind::CStr(_, _) => Ty::new_imm_ref(
-                tcx,
-                tcx.lifetimes.re_static,
-                tcx.type_of(tcx.require_lang_item(hir::LangItem::CStr, lit.span)).skip_binder(),
-            ),
-            ast::LitKind::Err(guar) => Ty::new_error(tcx, guar),
-        }
-    }
-
-    pub(crate) fn check_struct_path(
-        &self,
-        qpath: &QPath<'tcx>,
-        hir_id: HirId,
-    ) -> Result<(&'tcx ty::VariantDef, Ty<'tcx>), ErrorGuaranteed> {
-        let path_span = qpath.span();
-        let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
-        let variant = match def {
-            Res::Err => {
-                let guar =
-                    self.dcx().span_delayed_bug(path_span, "`Res::Err` but no error emitted");
-                self.set_tainted_by_errors(guar);
-                return Err(guar);
-            }
-            Res::Def(DefKind::Variant, _) => match ty.normalized.ty_adt_def() {
-                Some(adt) => {
-                    Some((adt.variant_of_res(def), adt.did(), Self::user_args_for_adt(ty)))
-                }
-                _ => bug!("unexpected type: {:?}", ty.normalized),
-            },
-            Res::Def(
-                DefKind::Struct | DefKind::Union | DefKind::TyAlias { .. } | DefKind::AssocTy,
-                _,
-            )
-            | Res::SelfTyParam { .. }
-            | Res::SelfTyAlias { .. } => match ty.normalized.ty_adt_def() {
-                Some(adt) if !adt.is_enum() => {
-                    Some((adt.non_enum_variant(), adt.did(), Self::user_args_for_adt(ty)))
-                }
-                _ => None,
-            },
-            _ => bug!("unexpected definition: {:?}", def),
-        };
-
-        if let Some((variant, did, ty::UserArgs { args, user_self_ty })) = variant {
-            debug!("check_struct_path: did={:?} args={:?}", did, args);
-
-            // Register type annotation.
-            self.write_user_type_annotation_from_args(hir_id, did, args, user_self_ty);
-
-            // Check bounds on type arguments used in the path.
-            self.add_required_obligations_for_hir(path_span, did, args, hir_id);
-
-            Ok((variant, ty.normalized))
-        } else {
-            Err(match *ty.normalized.kind() {
-                ty::Error(guar) => {
-                    // E0071 might be caused by a spelling error, which will have
-                    // already caused an error message and probably a suggestion
-                    // elsewhere. Refrain from emitting more unhelpful errors here
-                    // (issue #88844).
-                    guar
-                }
-                _ => struct_span_code_err!(
-                    self.dcx(),
-                    path_span,
-                    E0071,
-                    "expected struct, variant or union type, found {}",
-                    ty.normalized.sort_string(self.tcx)
-                )
-                .with_span_label(path_span, "not a struct")
-                .emit(),
-            })
-        }
-    }
-
-    fn check_decl_initializer(
-        &self,
-        hir_id: HirId,
-        pat: &'tcx hir::Pat<'tcx>,
-        init: &'tcx hir::Expr<'tcx>,
-    ) -> Ty<'tcx> {
-        // FIXME(tschottdorf): `contains_explicit_ref_binding()` must be removed
-        // for #42640 (default match binding modes).
-        //
-        // See #44848.
-        let ref_bindings = pat.contains_explicit_ref_binding();
-
-        let local_ty = self.local_ty(init.span, hir_id);
-        if let Some(m) = ref_bindings {
-            // Somewhat subtle: if we have a `ref` binding in the pattern,
-            // we want to avoid introducing coercions for the RHS. This is
-            // both because it helps preserve sanity and, in the case of
-            // ref mut, for soundness (issue #23116). In particular, in
-            // the latter case, we need to be clear that the type of the
-            // referent for the reference that results is *equal to* the
-            // type of the place it is referencing, and not some
-            // supertype thereof.
-            let init_ty = self.check_expr_with_needs(init, Needs::maybe_mut_place(m));
-            if let Err(mut diag) = self.demand_eqtype_diag(init.span, local_ty, init_ty) {
-                self.emit_type_mismatch_suggestions(
-                    &mut diag,
-                    init.peel_drop_temps(),
-                    init_ty,
-                    local_ty,
-                    None,
-                    None,
-                );
-                diag.emit();
-            }
-            init_ty
-        } else {
-            self.check_expr_coercible_to_type(init, local_ty, None)
-        }
-    }
-
-    pub(in super::super) fn check_decl(&self, decl: Declaration<'tcx>) -> Ty<'tcx> {
-        // Determine and write the type which we'll check the pattern against.
-        let decl_ty = self.local_ty(decl.span, decl.hir_id);
-
-        // Type check the initializer.
-        if let Some(ref init) = decl.init {
-            let init_ty = self.check_decl_initializer(decl.hir_id, decl.pat, init);
-            self.overwrite_local_ty_if_err(decl.hir_id, decl.pat, init_ty);
-        }
-
-        // Does the expected pattern type originate from an expression and what is the span?
-        let (origin_expr, ty_span) = match (decl.ty, decl.init) {
-            (Some(ty), _) => (None, Some(ty.span)), // Bias towards the explicit user type.
-            (_, Some(init)) => {
-                (Some(init), Some(init.span.find_ancestor_inside(decl.span).unwrap_or(init.span)))
-            } // No explicit type; so use the scrutinee.
-            _ => (None, None), // We have `let $pat;`, so the expected type is unconstrained.
-        };
-
-        // Type check the pattern. Override if necessary to avoid knock-on errors.
-        self.check_pat_top(decl.pat, decl_ty, ty_span, origin_expr, Some(decl.origin));
-        let pat_ty = self.node_ty(decl.pat.hir_id);
-        self.overwrite_local_ty_if_err(decl.hir_id, decl.pat, pat_ty);
-
-        if let Some(blk) = decl.origin.try_get_else() {
-            let previous_diverges = self.diverges.get();
-            let else_ty = self.check_expr_block(blk, NoExpectation);
-            let cause = self.cause(blk.span, ObligationCauseCode::LetElse);
-            if let Err(err) = self.demand_eqtype_with_origin(&cause, self.tcx.types.never, else_ty)
-            {
-                err.emit();
-            }
-            self.diverges.set(previous_diverges);
-        }
-        decl_ty
-    }
-
-    /// Type check a `let` statement.
-    fn check_decl_local(&self, local: &'tcx hir::LetStmt<'tcx>) {
-        GatherLocalsVisitor::gather_from_local(self, local);
-
-        let ty = self.check_decl(local.into());
-        self.write_ty(local.hir_id, ty);
-        if local.pat.is_never_pattern() {
-            self.diverges.set(Diverges::Always {
-                span: local.pat.span,
-                custom_note: Some("any code following a never pattern is unreachable"),
-            });
-        }
-    }
-
-    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,
-            hir::StmtKind::Let(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
-        }
-
-        self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
-
-        // Hide the outer diverging flags.
-        let old_diverges = self.diverges.replace(Diverges::Maybe);
-
-        match stmt.kind {
-            hir::StmtKind::Let(l) => {
-                self.check_decl_local(l);
-            }
-            // Ignore for now.
-            hir::StmtKind::Item(_) => {}
-            hir::StmtKind::Expr(ref expr) => {
-                // Check with expected type of `()`.
-                self.check_expr_has_type_or_error(expr, self.tcx.types.unit, |err| {
-                    if self.is_next_stmt_expr_continuation(stmt.hir_id)
-                        && let hir::ExprKind::Match(..) | hir::ExprKind::If(..) = expr.kind
-                    {
-                        // We have something like `match () { _ => true } && true`. Suggest
-                        // wrapping in parentheses. We find the statement or expression
-                        // following the `match` (`&& true`) and see if it is something that
-                        // can reasonably be interpreted as a binop following an expression.
-                        err.multipart_suggestion(
-                            "parentheses are required to parse this as an expression",
-                            vec![
-                                (expr.span.shrink_to_lo(), "(".to_string()),
-                                (expr.span.shrink_to_hi(), ")".to_string()),
-                            ],
-                            Applicability::MachineApplicable,
-                        );
-                    } else if expr.can_have_side_effects() {
-                        self.suggest_semicolon_at_end(expr.span, err);
-                    }
-                });
-            }
-            hir::StmtKind::Semi(expr) => {
-                let ty = self.check_expr(expr);
-                self.check_place_expr_if_unsized(ty, expr);
-            }
-        }
-
-        // Combine the diverging and `has_error` flags.
-        self.diverges.set(self.diverges.get() | old_diverges);
-    }
-
-    pub(crate) fn check_block_no_value(&self, blk: &'tcx hir::Block<'tcx>) {
-        let unit = self.tcx.types.unit;
-        let ty = self.check_expr_block(blk, ExpectHasType(unit));
-
-        // if the block produces a `!` value, that can always be
-        // (effectively) coerced to unit.
-        if !ty.is_never() {
-            self.demand_suptype(blk.span, unit, ty);
-        }
-    }
-
-    pub(in super::super) fn check_expr_block(
-        &self,
-        blk: &'tcx hir::Block<'tcx>,
-        expected: Expectation<'tcx>,
-    ) -> Ty<'tcx> {
-        // In some cases, blocks have just one exit, but other blocks
-        // can be targeted by multiple breaks. This can happen both
-        // with labeled blocks as well as when we desugar
-        // a `try { ... }` expression.
-        //
-        // Example 1:
-        //
-        //    'a: { if true { break 'a Err(()); } Ok(()) }
-        //
-        // Here we would wind up with two coercions, one from
-        // `Err(())` and the other from the tail expression
-        // `Ok(())`. If the tail expression is omitted, that's a
-        // "forced unit" -- unless the block diverges, in which
-        // case we can ignore the tail expression (e.g., `'a: {
-        // break 'a 22; }` would not force the type of the block
-        // to be `()`).
-        let coerce_to_ty = expected.coercion_target_type(self, blk.span);
-        let coerce = if blk.targeted_by_break {
-            CoerceMany::new(coerce_to_ty)
-        } else {
-            CoerceMany::with_coercion_sites(coerce_to_ty, blk.expr.as_slice())
-        };
-
-        let prev_diverges = self.diverges.get();
-        let ctxt = BreakableCtxt { coerce: Some(coerce), may_break: false };
-
-        let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
-            for s in blk.stmts {
-                self.check_stmt(s);
+        let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
+            for s in blk.stmts {
+                self.check_stmt(s);
             }
 
             // check the tail expression **without** holding the
@@ -2139,700 +1165,2030 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             self.diverges.set(prev_diverges);
         }
 
-        let ty = ctxt.coerce.unwrap().complete(self);
-
-        self.write_ty(blk.hir_id, ty);
+        let ty = ctxt.coerce.unwrap().complete(self);
+
+        self.write_ty(blk.hir_id, ty);
+
+        ty
+    }
+
+    fn parent_item_span(&self, id: HirId) -> Option<Span> {
+        let node = self.tcx.hir_node_by_def_id(self.tcx.hir_get_parent_item(id).def_id);
+        match node {
+            Node::Item(&hir::Item { kind: hir::ItemKind::Fn { body: body_id, .. }, .. })
+            | Node::ImplItem(&hir::ImplItem { kind: hir::ImplItemKind::Fn(_, body_id), .. }) => {
+                let body = self.tcx.hir_body(body_id);
+                if let ExprKind::Block(block, _) = &body.value.kind {
+                    return Some(block.span);
+                }
+            }
+            _ => {}
+        }
+        None
+    }
+
+    /// If `expr` is a `match` expression that has only one non-`!` arm, use that arm's tail
+    /// expression's `Span`, otherwise return `expr.span`. This is done to give better errors
+    /// when given code like the following:
+    /// ```text
+    /// if false { return 0i32; } else { 1u32 }
+    /// //                               ^^^^ point at this instead of the whole `if` expression
+    /// ```
+    fn get_expr_coercion_span(&self, expr: &hir::Expr<'_>) -> rustc_span::Span {
+        let check_in_progress = |elem: &hir::Expr<'_>| {
+            self.typeck_results.borrow().node_type_opt(elem.hir_id).filter(|ty| !ty.is_never()).map(
+                |_| match elem.kind {
+                    // Point at the tail expression when possible.
+                    hir::ExprKind::Block(block, _) => block.expr.map_or(block.span, |e| e.span),
+                    _ => elem.span,
+                },
+            )
+        };
+
+        if let hir::ExprKind::If(_, _, Some(el)) = expr.kind
+            && let Some(rslt) = check_in_progress(el)
+        {
+            return rslt;
+        }
+
+        if let hir::ExprKind::Match(_, arms, _) = expr.kind {
+            let mut iter = arms.iter().filter_map(|arm| check_in_progress(arm.body));
+            if let Some(span) = iter.next() {
+                if iter.next().is_none() {
+                    return span;
+                }
+            }
+        }
+
+        expr.span
+    }
+
+    fn overwrite_local_ty_if_err(&self, hir_id: HirId, pat: &'tcx hir::Pat<'tcx>, ty: Ty<'tcx>) {
+        if let Err(guar) = ty.error_reported() {
+            struct OverwritePatternsWithError {
+                pat_hir_ids: Vec<hir::HirId>,
+            }
+            impl<'tcx> Visitor<'tcx> for OverwritePatternsWithError {
+                fn visit_pat(&mut self, p: &'tcx hir::Pat<'tcx>) {
+                    self.pat_hir_ids.push(p.hir_id);
+                    hir::intravisit::walk_pat(self, p);
+                }
+            }
+            // Override the types everywhere with `err()` to avoid knock on errors.
+            let err = Ty::new_error(self.tcx, guar);
+            self.write_ty(hir_id, err);
+            self.write_ty(pat.hir_id, err);
+            let mut visitor = OverwritePatternsWithError { pat_hir_ids: vec![] };
+            hir::intravisit::walk_pat(&mut visitor, pat);
+            // Mark all the subpatterns as `{type error}` as well. This allows errors for specific
+            // subpatterns to be silenced.
+            for hir_id in visitor.pat_hir_ids {
+                self.write_ty(hir_id, err);
+            }
+            self.locals.borrow_mut().insert(hir_id, err);
+            self.locals.borrow_mut().insert(pat.hir_id, err);
+        }
+    }
+
+    // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
+    // The newly resolved definition is written into `type_dependent_defs`.
+    fn finish_resolving_struct_path(
+        &self,
+        qpath: &QPath<'tcx>,
+        path_span: Span,
+        hir_id: HirId,
+    ) -> (Res, LoweredTy<'tcx>) {
+        match *qpath {
+            QPath::Resolved(ref maybe_qself, path) => {
+                let self_ty = maybe_qself.as_ref().map(|qself| self.lower_ty(qself).raw);
+                let ty = self.lowerer().lower_resolved_ty_path(
+                    self_ty,
+                    path,
+                    hir_id,
+                    PermitVariants::Yes,
+                );
+                (path.res, LoweredTy::from_raw(self, path_span, ty))
+            }
+            QPath::TypeRelative(hir_self_ty, segment) => {
+                let self_ty = self.lower_ty(hir_self_ty);
+
+                let result = self.lowerer().lower_type_relative_ty_path(
+                    self_ty.raw,
+                    hir_self_ty,
+                    segment,
+                    hir_id,
+                    path_span,
+                    PermitVariants::Yes,
+                );
+                let ty = result
+                    .map(|(ty, _, _)| ty)
+                    .unwrap_or_else(|guar| Ty::new_error(self.tcx(), guar));
+                let ty = LoweredTy::from_raw(self, path_span, ty);
+                let result = result.map(|(_, kind, def_id)| (kind, def_id));
+
+                // Write back the new resolution.
+                self.write_resolution(hir_id, result);
+
+                (result.map_or(Res::Err, |(kind, def_id)| Res::Def(kind, def_id)), ty)
+            }
+            QPath::LangItem(lang_item, span) => {
+                let (res, ty) = self.resolve_lang_item_path(lang_item, span, hir_id);
+                (res, LoweredTy::from_raw(self, path_span, ty))
+            }
+        }
+    }
+
+    /// Given a vector of fulfillment errors, try to adjust the spans of the
+    /// errors to more accurately point at the cause of the failure.
+    ///
+    /// This applies to calls, methods, and struct expressions. This will also
+    /// try to deduplicate errors that are due to the same cause but might
+    /// have been created with different [`ObligationCause`][traits::ObligationCause]s.
+    pub(super) fn adjust_fulfillment_errors_for_expr_obligation(
+        &self,
+        errors: &mut Vec<traits::FulfillmentError<'tcx>>,
+    ) {
+        // Store a mapping from `(Span, Predicate) -> ObligationCause`, so that
+        // other errors that have the same span and predicate can also get fixed,
+        // even if their `ObligationCauseCode` isn't an `Expr*Obligation` kind.
+        // This is important since if we adjust one span but not the other, then
+        // we will have "duplicated" the error on the UI side.
+        let mut remap_cause = FxIndexSet::default();
+        let mut not_adjusted = vec![];
+
+        for error in errors {
+            let before_span = error.obligation.cause.span;
+            if self.adjust_fulfillment_error_for_expr_obligation(error)
+                || before_span != error.obligation.cause.span
+            {
+                remap_cause.insert((
+                    before_span,
+                    error.obligation.predicate,
+                    error.obligation.cause.clone(),
+                ));
+            } else {
+                // If it failed to be adjusted once around, it may be adjusted
+                // via the "remap cause" mapping the second time...
+                not_adjusted.push(error);
+            }
+        }
+
+        // Adjust any other errors that come from other cause codes, when these
+        // errors are of the same predicate as one we successfully adjusted, and
+        // when their spans overlap (suggesting they're due to the same root cause).
+        //
+        // This is because due to normalization, we often register duplicate
+        // obligations with misc obligations that are basically impossible to
+        // line back up with a useful WhereClauseInExpr.
+        for error in not_adjusted {
+            for (span, predicate, cause) in &remap_cause {
+                if *predicate == error.obligation.predicate
+                    && span.contains(error.obligation.cause.span)
+                {
+                    error.obligation.cause = cause.clone();
+                    continue;
+                }
+            }
+        }
+    }
+
+    fn label_fn_like(
+        &self,
+        err: &mut Diag<'_>,
+        callable_def_id: Option<DefId>,
+        callee_ty: Option<Ty<'tcx>>,
+        call_expr: &'tcx hir::Expr<'tcx>,
+        expected_ty: Option<Ty<'tcx>>,
+        // A specific argument should be labeled, instead of all of them
+        expected_idx: Option<usize>,
+        matched_inputs: &IndexVec<ExpectedIdx, Option<ProvidedIdx>>,
+        formal_and_expected_inputs: &IndexVec<ExpectedIdx, (Ty<'tcx>, Ty<'tcx>)>,
+        is_method: bool,
+        tuple_arguments: TupleArgumentsFlag,
+    ) {
+        let Some(mut def_id) = callable_def_id else {
+            return;
+        };
+
+        // If we're calling a method of a Fn/FnMut/FnOnce trait object implicitly
+        // (eg invoking a closure) we want to point at the underlying callable,
+        // not the method implicitly invoked (eg call_once).
+        // TupleArguments is set only when this is an implicit call (my_closure(...)) rather than explicit (my_closure.call(...))
+        if tuple_arguments == TupleArguments
+            && let Some(assoc_item) = self.tcx.opt_associated_item(def_id)
+            // Since this is an associated item, it might point at either an impl or a trait item.
+            // We want it to always point to the trait item.
+            // If we're pointing at an inherent function, we don't need to do anything,
+            // so we fetch the parent and verify if it's a trait item.
+            && let maybe_trait_item_def_id = assoc_item.trait_item_def_id.unwrap_or(def_id)
+            && let maybe_trait_def_id = self.tcx.parent(maybe_trait_item_def_id)
+            // Just an easy way to check "trait_def_id == Fn/FnMut/FnOnce"
+            && let Some(call_kind) = self.tcx.fn_trait_kind_from_def_id(maybe_trait_def_id)
+            && let Some(callee_ty) = callee_ty
+        {
+            let callee_ty = callee_ty.peel_refs();
+            match *callee_ty.kind() {
+                ty::Param(param) => {
+                    let param = self.tcx.generics_of(self.body_id).type_param(param, self.tcx);
+                    if param.kind.is_synthetic() {
+                        // if it's `impl Fn() -> ..` then just fall down to the def-id based logic
+                        def_id = param.def_id;
+                    } else {
+                        // Otherwise, find the predicate that makes this generic callable,
+                        // and point at that.
+                        let instantiated = self
+                            .tcx
+                            .explicit_predicates_of(self.body_id)
+                            .instantiate_identity(self.tcx);
+                        // FIXME(compiler-errors): This could be problematic if something has two
+                        // fn-like predicates with different args, but callable types really never
+                        // do that, so it's OK.
+                        for (predicate, span) in instantiated {
+                            if let ty::ClauseKind::Trait(pred) = predicate.kind().skip_binder()
+                                && pred.self_ty().peel_refs() == callee_ty
+                                && self.tcx.is_fn_trait(pred.def_id())
+                            {
+                                err.span_note(span, "callable defined here");
+                                return;
+                            }
+                        }
+                    }
+                }
+                ty::Alias(ty::Opaque, ty::AliasTy { def_id: new_def_id, .. })
+                | ty::Closure(new_def_id, _)
+                | ty::FnDef(new_def_id, _) => {
+                    def_id = new_def_id;
+                }
+                _ => {
+                    // Look for a user-provided impl of a `Fn` trait, and point to it.
+                    let new_def_id = self.probe(|_| {
+                        let trait_ref = ty::TraitRef::new(
+                            self.tcx,
+                            self.tcx.fn_trait_kind_to_def_id(call_kind)?,
+                            [callee_ty, self.next_ty_var(DUMMY_SP)],
+                        );
+                        let obligation = traits::Obligation::new(
+                            self.tcx,
+                            traits::ObligationCause::dummy(),
+                            self.param_env,
+                            trait_ref,
+                        );
+                        match SelectionContext::new(self).select(&obligation) {
+                            Ok(Some(traits::ImplSource::UserDefined(impl_source))) => {
+                                Some(impl_source.impl_def_id)
+                            }
+                            _ => None,
+                        }
+                    });
+                    if let Some(new_def_id) = new_def_id {
+                        def_id = new_def_id;
+                    } else {
+                        return;
+                    }
+                }
+            }
+        }
+
+        if let Some(def_span) = self.tcx.def_ident_span(def_id)
+            && !def_span.is_dummy()
+        {
+            let mut spans: MultiSpan = def_span.into();
+            if let Some((params_with_generics, hir_generics)) =
+                self.get_hir_param_info(def_id, is_method)
+            {
+                struct MismatchedParam<'a> {
+                    idx: ExpectedIdx,
+                    generic: GenericIdx,
+                    param: &'a FnParam<'a>,
+                    deps: SmallVec<[ExpectedIdx; 4]>,
+                }
+
+                debug_assert_eq!(params_with_generics.len(), matched_inputs.len());
+                // Gather all mismatched parameters with generics.
+                let mut mismatched_params = Vec::<MismatchedParam<'_>>::new();
+                if let Some(expected_idx) = expected_idx {
+                    let expected_idx = ExpectedIdx::from_usize(expected_idx);
+                    let &(expected_generic, ref expected_param) =
+                        &params_with_generics[expected_idx];
+                    if let Some(expected_generic) = expected_generic {
+                        mismatched_params.push(MismatchedParam {
+                            idx: expected_idx,
+                            generic: expected_generic,
+                            param: expected_param,
+                            deps: SmallVec::new(),
+                        });
+                    } else {
+                        // Still mark the mismatched parameter
+                        spans.push_span_label(expected_param.span(), "");
+                    }
+                } else {
+                    mismatched_params.extend(
+                        params_with_generics.iter_enumerated().zip(matched_inputs).filter_map(
+                            |((idx, &(generic, ref param)), matched_idx)| {
+                                if matched_idx.is_some() {
+                                    None
+                                } else if let Some(generic) = generic {
+                                    Some(MismatchedParam {
+                                        idx,
+                                        generic,
+                                        param,
+                                        deps: SmallVec::new(),
+                                    })
+                                } else {
+                                    // Still mark mismatched parameters
+                                    spans.push_span_label(param.span(), "");
+                                    None
+                                }
+                            },
+                        ),
+                    );
+                }
+
+                if !mismatched_params.is_empty() {
+                    // For each mismatched parameter, create a two-way link to each matched parameter
+                    // of the same type.
+                    let mut dependants = IndexVec::<ExpectedIdx, _>::from_fn_n(
+                        |_| SmallVec::<[u32; 4]>::new(),
+                        params_with_generics.len(),
+                    );
+                    let mut generic_uses = IndexVec::<GenericIdx, _>::from_fn_n(
+                        |_| SmallVec::<[ExpectedIdx; 4]>::new(),
+                        hir_generics.params.len(),
+                    );
+                    for (idx, param) in mismatched_params.iter_mut().enumerate() {
+                        for ((other_idx, &(other_generic, _)), &other_matched_idx) in
+                            params_with_generics.iter_enumerated().zip(matched_inputs)
+                        {
+                            if other_generic == Some(param.generic) && other_matched_idx.is_some() {
+                                generic_uses[param.generic].extend([param.idx, other_idx]);
+                                dependants[other_idx].push(idx as u32);
+                                param.deps.push(other_idx);
+                            }
+                        }
+                    }
+
+                    // Highlight each mismatched type along with a note about which other parameters
+                    // the type depends on (if any).
+                    for param in &mismatched_params {
+                        if let Some(deps_list) = listify(&param.deps, |&dep| {
+                            params_with_generics[dep].1.display(dep.as_usize()).to_string()
+                        }) {
+                            spans.push_span_label(
+                                param.param.span(),
+                                format!(
+                                    "this parameter needs to match the {} type of {deps_list}",
+                                    self.resolve_vars_if_possible(
+                                        formal_and_expected_inputs[param.deps[0]].1
+                                    )
+                                    .sort_string(self.tcx),
+                                ),
+                            );
+                        } else {
+                            // Still mark mismatched parameters
+                            spans.push_span_label(param.param.span(), "");
+                        }
+                    }
+                    // Highlight each parameter being depended on for a generic type.
+                    for ((&(_, param), deps), &(_, expected_ty)) in
+                        params_with_generics.iter().zip(&dependants).zip(formal_and_expected_inputs)
+                    {
+                        if let Some(deps_list) = listify(deps, |&dep| {
+                            let param = &mismatched_params[dep as usize];
+                            param.param.display(param.idx.as_usize()).to_string()
+                        }) {
+                            spans.push_span_label(
+                                param.span(),
+                                format!(
+                                    "{deps_list} need{} to match the {} type of this parameter",
+                                    pluralize!((deps.len() != 1) as u32),
+                                    self.resolve_vars_if_possible(expected_ty)
+                                        .sort_string(self.tcx),
+                                ),
+                            );
+                        }
+                    }
+                    // Highlight each generic parameter in use.
+                    for (param, uses) in hir_generics.params.iter().zip(&mut generic_uses) {
+                        uses.sort();
+                        uses.dedup();
+                        if let Some(param_list) = listify(uses, |&idx| {
+                            params_with_generics[idx].1.display(idx.as_usize()).to_string()
+                        }) {
+                            spans.push_span_label(
+                                param.span,
+                                format!(
+                                    "{param_list} {} reference this parameter `{}`",
+                                    if uses.len() == 2 { "both" } else { "all" },
+                                    param.name.ident().name,
+                                ),
+                            );
+                        }
+                    }
+                }
+            }
+            err.span_note(spans, format!("{} defined here", self.tcx.def_descr(def_id)));
+        } else if let Some(hir::Node::Expr(e)) = self.tcx.hir_get_if_local(def_id)
+            && let hir::ExprKind::Closure(hir::Closure { body, .. }) = &e.kind
+        {
+            let param = expected_idx
+                .and_then(|expected_idx| self.tcx.hir_body(*body).params.get(expected_idx));
+            let (kind, span) = if let Some(param) = param {
+                // Try to find earlier invocations of this closure to find if the type mismatch
+                // is because of inference. If we find one, point at them.
+                let mut call_finder = FindClosureArg { tcx: self.tcx, calls: vec![] };
+                let parent_def_id = self.tcx.hir_get_parent_item(call_expr.hir_id).def_id;
+                match self.tcx.hir_node_by_def_id(parent_def_id) {
+                    hir::Node::Item(item) => call_finder.visit_item(item),
+                    hir::Node::TraitItem(item) => call_finder.visit_trait_item(item),
+                    hir::Node::ImplItem(item) => call_finder.visit_impl_item(item),
+                    _ => {}
+                }
+                let typeck = self.typeck_results.borrow();
+                for (rcvr, args) in call_finder.calls {
+                    if rcvr.hir_id.owner == typeck.hir_owner
+                        && let Some(rcvr_ty) = typeck.node_type_opt(rcvr.hir_id)
+                        && let ty::Closure(call_def_id, _) = rcvr_ty.kind()
+                        && def_id == *call_def_id
+                        && let Some(idx) = expected_idx
+                        && let Some(arg) = args.get(idx)
+                        && let Some(arg_ty) = typeck.node_type_opt(arg.hir_id)
+                        && let Some(expected_ty) = expected_ty
+                        && self.can_eq(self.param_env, arg_ty, expected_ty)
+                    {
+                        let mut sp: MultiSpan = vec![arg.span].into();
+                        sp.push_span_label(
+                            arg.span,
+                            format!("expected because this argument is of type `{arg_ty}`"),
+                        );
+                        sp.push_span_label(rcvr.span, "in this closure call");
+                        err.span_note(
+                            sp,
+                            format!(
+                                "expected because the closure was earlier called with an \
+                                argument of type `{arg_ty}`",
+                            ),
+                        );
+                        break;
+                    }
+                }
+
+                ("closure parameter", param.span)
+            } else {
+                ("closure", self.tcx.def_span(def_id))
+            };
+            err.span_note(span, format!("{kind} defined here"));
+        } else {
+            err.span_note(
+                self.tcx.def_span(def_id),
+                format!("{} defined here", self.tcx.def_descr(def_id)),
+            );
+        }
+    }
+
+    fn label_generic_mismatches(
+        &self,
+        err: &mut Diag<'_>,
+        callable_def_id: Option<DefId>,
+        matched_inputs: &IndexVec<ExpectedIdx, Option<ProvidedIdx>>,
+        provided_arg_tys: &IndexVec<ProvidedIdx, (Ty<'tcx>, Span)>,
+        formal_and_expected_inputs: &IndexVec<ExpectedIdx, (Ty<'tcx>, Ty<'tcx>)>,
+        is_method: bool,
+    ) {
+        let Some(def_id) = callable_def_id else {
+            return;
+        };
+
+        if let Some((params_with_generics, _)) = self.get_hir_param_info(def_id, is_method) {
+            debug_assert_eq!(params_with_generics.len(), matched_inputs.len());
+            for (idx, (generic_param, _)) in params_with_generics.iter_enumerated() {
+                if matched_inputs[idx].is_none() {
+                    continue;
+                }
+
+                let Some((_, matched_arg_span)) = provided_arg_tys.get(idx.to_provided_idx())
+                else {
+                    continue;
+                };
+
+                let Some(generic_param) = generic_param else {
+                    continue;
+                };
+
+                let idxs_matched = params_with_generics
+                    .iter_enumerated()
+                    .filter(|&(other_idx, (other_generic_param, _))| {
+                        if other_idx == idx {
+                            return false;
+                        }
+                        let Some(other_generic_param) = other_generic_param else {
+                            return false;
+                        };
+                        if matched_inputs[other_idx].is_some() {
+                            return false;
+                        }
+                        other_generic_param == generic_param
+                    })
+                    .count();
+
+                if idxs_matched == 0 {
+                    continue;
+                }
+
+                let expected_display_type = self
+                    .resolve_vars_if_possible(formal_and_expected_inputs[idx].1)
+                    .sort_string(self.tcx);
+                let label = if idxs_matched == params_with_generics.len() - 1 {
+                    format!(
+                        "expected all arguments to be this {} type because they need to match the type of this parameter",
+                        expected_display_type
+                    )
+                } else {
+                    format!(
+                        "expected some other arguments to be {} {} type to match the type of this parameter",
+                        a_or_an(&expected_display_type),
+                        expected_display_type,
+                    )
+                };
+
+                err.span_label(*matched_arg_span, label);
+            }
+        }
+    }
+
+    /// Returns the parameters of a function, with their generic parameters if those are the full
+    /// type of that parameter.
+    ///
+    /// Returns `None` if the body is not a named function (e.g. a closure).
+    fn get_hir_param_info(
+        &self,
+        def_id: DefId,
+        is_method: bool,
+    ) -> Option<(IndexVec<ExpectedIdx, (Option<GenericIdx>, FnParam<'_>)>, &hir::Generics<'_>)>
+    {
+        let (sig, generics, body_id, params) = match self.tcx.hir_get_if_local(def_id)? {
+            hir::Node::TraitItem(&hir::TraitItem {
+                generics,
+                kind: hir::TraitItemKind::Fn(sig, trait_fn),
+                ..
+            }) => match trait_fn {
+                hir::TraitFn::Required(params) => (sig, generics, None, Some(params)),
+                hir::TraitFn::Provided(body) => (sig, generics, Some(body), None),
+            },
+            hir::Node::ImplItem(&hir::ImplItem {
+                generics,
+                kind: hir::ImplItemKind::Fn(sig, body),
+                ..
+            })
+            | hir::Node::Item(&hir::Item {
+                kind: hir::ItemKind::Fn { sig, generics, body, .. },
+                ..
+            }) => (sig, generics, Some(body), None),
+            hir::Node::ForeignItem(&hir::ForeignItem {
+                kind: hir::ForeignItemKind::Fn(sig, params, generics),
+                ..
+            }) => (sig, generics, None, Some(params)),
+            _ => return None,
+        };
+
+        // Make sure to remove both the receiver and variadic argument. Both are removed
+        // when matching parameter types.
+        let fn_inputs = sig.decl.inputs.get(is_method as usize..)?.iter().map(|param| {
+            if let hir::TyKind::Path(QPath::Resolved(
+                _,
+                &hir::Path { res: Res::Def(_, res_def_id), .. },
+            )) = param.kind
+            {
+                generics
+                    .params
+                    .iter()
+                    .position(|param| param.def_id.to_def_id() == res_def_id)
+                    .map(GenericIdx::from_usize)
+            } else {
+                None
+            }
+        });
+        match (body_id, params) {
+            (Some(_), Some(_)) | (None, None) => unreachable!(),
+            (Some(body), None) => {
+                let params = self.tcx.hir_body(body).params;
+                let params =
+                    params.get(is_method as usize..params.len() - sig.decl.c_variadic as usize)?;
+                debug_assert_eq!(params.len(), fn_inputs.len());
+                Some((
+                    fn_inputs.zip(params.iter().map(|param| FnParam::Param(param))).collect(),
+                    generics,
+                ))
+            }
+            (None, Some(params)) => {
+                let params =
+                    params.get(is_method as usize..params.len() - sig.decl.c_variadic as usize)?;
+                debug_assert_eq!(params.len(), fn_inputs.len());
+                Some((
+                    fn_inputs.zip(params.iter().map(|&ident| FnParam::Ident(ident))).collect(),
+                    generics,
+                ))
+            }
+        }
+    }
+}
+
+struct FindClosureArg<'tcx> {
+    tcx: TyCtxt<'tcx>,
+    calls: Vec<(&'tcx hir::Expr<'tcx>, &'tcx [hir::Expr<'tcx>])>,
+}
+
+impl<'tcx> Visitor<'tcx> for FindClosureArg<'tcx> {
+    type NestedFilter = rustc_middle::hir::nested_filter::All;
+
+    fn maybe_tcx(&mut self) -> Self::MaybeTyCtxt {
+        self.tcx
+    }
+
+    fn visit_expr(&mut self, ex: &'tcx hir::Expr<'tcx>) {
+        if let hir::ExprKind::Call(rcvr, args) = ex.kind {
+            self.calls.push((rcvr, args));
+        }
+        hir::intravisit::walk_expr(self, ex);
+    }
+}
+
+#[derive(Clone, Copy)]
+enum FnParam<'hir> {
+    Param(&'hir hir::Param<'hir>),
+    Ident(Option<Ident>),
+}
 
-        ty
+impl FnParam<'_> {
+    fn span(&self) -> Span {
+        match self {
+            Self::Param(param) => param.span,
+            Self::Ident(ident) => {
+                if let Some(ident) = ident {
+                    ident.span
+                } else {
+                    DUMMY_SP
+                }
+            }
+        }
     }
 
-    fn parent_item_span(&self, id: HirId) -> Option<Span> {
-        let node = self.tcx.hir_node_by_def_id(self.tcx.hir_get_parent_item(id).def_id);
-        match node {
-            Node::Item(&hir::Item { kind: hir::ItemKind::Fn { body: body_id, .. }, .. })
-            | Node::ImplItem(&hir::ImplItem { kind: hir::ImplItemKind::Fn(_, body_id), .. }) => {
-                let body = self.tcx.hir_body(body_id);
-                if let ExprKind::Block(block, _) = &body.value.kind {
-                    return Some(block.span);
+    fn display(&self, idx: usize) -> impl '_ + fmt::Display {
+        struct D<'a>(FnParam<'a>, usize);
+        impl fmt::Display for D<'_> {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                // A "unique" param name is one that (a) exists, and (b) is guaranteed to be unique
+                // among the parameters, i.e. `_` does not count.
+                let unique_name = match self.0 {
+                    FnParam::Param(param)
+                        if let hir::PatKind::Binding(_, _, ident, _) = param.pat.kind =>
+                    {
+                        Some(ident.name)
+                    }
+                    FnParam::Ident(ident)
+                        if let Some(ident) = ident
+                            && ident.name != kw::Underscore =>
+                    {
+                        Some(ident.name)
+                    }
+                    _ => None,
+                };
+                if let Some(unique_name) = unique_name {
+                    write!(f, "`{unique_name}`")
+                } else {
+                    write!(f, "parameter #{}", self.1 + 1)
                 }
             }
-            _ => {}
         }
-        None
+        D(*self, idx)
     }
+}
 
-    /// If `expr` is a `match` expression that has only one non-`!` arm, use that arm's tail
-    /// expression's `Span`, otherwise return `expr.span`. This is done to give better errors
-    /// when given code like the following:
-    /// ```text
-    /// if false { return 0i32; } else { 1u32 }
-    /// //                               ^^^^ point at this instead of the whole `if` expression
-    /// ```
-    fn get_expr_coercion_span(&self, expr: &hir::Expr<'_>) -> rustc_span::Span {
-        let check_in_progress = |elem: &hir::Expr<'_>| {
-            self.typeck_results.borrow().node_type_opt(elem.hir_id).filter(|ty| !ty.is_never()).map(
-                |_| match elem.kind {
-                    // Point at the tail expression when possible.
-                    hir::ExprKind::Block(block, _) => block.expr.map_or(block.span, |e| e.span),
-                    _ => elem.span,
-                },
-            )
-        };
+struct FnCallDiagCtxt<'a, 'b, 'tcx> {
+    arg_matching_ctxt: ArgMatchingCtxt<'a, 'b, 'tcx>,
+    errors: Vec<Error<'tcx>>,
+    matched_inputs: IndexVec<ExpectedIdx, Option<ProvidedIdx>>,
+}
 
-        if let hir::ExprKind::If(_, _, Some(el)) = expr.kind
-            && let Some(rslt) = check_in_progress(el)
-        {
-            return rslt;
-        }
+impl<'a, 'b, 'tcx> Deref for FnCallDiagCtxt<'a, 'b, 'tcx> {
+    type Target = ArgMatchingCtxt<'a, 'b, 'tcx>;
 
-        if let hir::ExprKind::Match(_, arms, _) = expr.kind {
-            let mut iter = arms.iter().filter_map(|arm| check_in_progress(arm.body));
-            if let Some(span) = iter.next() {
-                if iter.next().is_none() {
-                    return span;
-                }
-            }
-        }
+    fn deref(&self) -> &Self::Target {
+        &self.arg_matching_ctxt
+    }
+}
 
-        expr.span
+// Controls how the arguments should be listed in the suggestion.
+enum ArgumentsFormatting {
+    SingleLine,
+    Multiline { fallback_indent: String, brace_indent: String },
+}
+
+impl<'a, 'b, 'tcx> FnCallDiagCtxt<'a, 'b, 'tcx> {
+    fn new(
+        arg: &'a FnCtxt<'b, 'tcx>,
+        compatibility_diagonal: IndexVec<ProvidedIdx, Compatibility<'tcx>>,
+        formal_and_expected_inputs: IndexVec<ExpectedIdx, (Ty<'tcx>, Ty<'tcx>)>,
+        provided_args: IndexVec<ProvidedIdx, &'tcx Expr<'tcx>>,
+        c_variadic: bool,
+        err_code: ErrCode,
+        fn_def_id: Option<DefId>,
+        call_span: Span,
+        call_expr: &'tcx Expr<'tcx>,
+        tuple_arguments: TupleArgumentsFlag,
+    ) -> Self {
+        let arg_matching_ctxt = ArgMatchingCtxt::new(
+            arg,
+            compatibility_diagonal,
+            formal_and_expected_inputs,
+            provided_args,
+            c_variadic,
+            err_code,
+            fn_def_id,
+            call_span,
+            call_expr,
+            tuple_arguments,
+        );
+
+        // The algorithm here is inspired by levenshtein distance and longest common subsequence.
+        // We'll try to detect 4 different types of mistakes:
+        // - An extra parameter has been provided that doesn't satisfy *any* of the other inputs
+        // - An input is missing, which isn't satisfied by *any* of the other arguments
+        // - Some number of arguments have been provided in the wrong order
+        // - A type is straight up invalid
+        let (errors, matched_inputs) = ArgMatrix::new(
+            arg_matching_ctxt.provided_args.len(),
+            arg_matching_ctxt.formal_and_expected_inputs.len(),
+            |provided, expected| arg_matching_ctxt.check_compatible(provided, expected),
+        )
+        .find_errors();
+
+        FnCallDiagCtxt { arg_matching_ctxt, errors, matched_inputs }
     }
 
-    fn overwrite_local_ty_if_err(&self, hir_id: HirId, pat: &'tcx hir::Pat<'tcx>, ty: Ty<'tcx>) {
-        if let Err(guar) = ty.error_reported() {
-            struct OverwritePatternsWithError {
-                pat_hir_ids: Vec<hir::HirId>,
-            }
-            impl<'tcx> Visitor<'tcx> for OverwritePatternsWithError {
-                fn visit_pat(&mut self, p: &'tcx hir::Pat<'tcx>) {
-                    self.pat_hir_ids.push(p.hir_id);
-                    hir::intravisit::walk_pat(self, p);
+    fn check_wrap_args_in_tuple(&self) -> Option<ErrorGuaranteed> {
+        if let Some((mismatch_idx, terr)) = self.first_incompatible_error() {
+            // Is the first bad expected argument a tuple?
+            // Do we have as many extra provided arguments as the tuple's length?
+            // If so, we might have just forgotten to wrap some args in a tuple.
+            if let Some(ty::Tuple(tys)) =
+               self.formal_and_expected_inputs.get(mismatch_idx.to_expected_idx()).map(|tys| tys.1.kind())
+                // If the tuple is unit, we're not actually wrapping any arguments.
+                && !tys.is_empty()
+                && self.provided_arg_tys.len() == self.formal_and_expected_inputs.len() - 1 + tys.len()
+            {
+                // Wrap up the N provided arguments starting at this position in a tuple.
+                let provided_args_to_tuple = &self.provided_arg_tys[mismatch_idx..];
+                let (provided_args_to_tuple, provided_args_after_tuple) =
+                    provided_args_to_tuple.split_at(tys.len());
+                let provided_as_tuple = Ty::new_tup_from_iter(
+                    self.tcx,
+                    provided_args_to_tuple.iter().map(|&(ty, _)| ty),
+                );
+
+                let mut satisfied = true;
+                // Check if the newly wrapped tuple + rest of the arguments are compatible.
+                for ((_, expected_ty), provided_ty) in std::iter::zip(
+                    self.formal_and_expected_inputs[mismatch_idx.to_expected_idx()..].iter(),
+                    [provided_as_tuple]
+                        .into_iter()
+                        .chain(provided_args_after_tuple.iter().map(|&(ty, _)| ty)),
+                ) {
+                    if !self.may_coerce(provided_ty, *expected_ty) {
+                        satisfied = false;
+                        break;
+                    }
                 }
+
+                // If they're compatible, suggest wrapping in an arg, and we're done!
+                // Take some care with spans, so we don't suggest wrapping a macro's
+                // innards in parenthesis, for example.
+                if satisfied
+                    && let &[(_, hi @ lo)] | &[(_, lo), .., (_, hi)] = provided_args_to_tuple
+                {
+                    let mut err;
+                    if tys.len() == 1 {
+                        // A tuple wrap suggestion actually occurs within,
+                        // so don't do anything special here.
+                        err = self.err_ctxt().report_and_explain_type_error(
+                            self.arg_matching_ctxt.args_ctxt.call_ctxt.mk_trace(
+                                lo,
+                                self.formal_and_expected_inputs[mismatch_idx.to_expected_idx()],
+                                self.provided_arg_tys[mismatch_idx].0,
+                            ),
+                            self.param_env,
+                            terr,
+                        );
+                        let call_name = self.call_metadata.call_name;
+                        err.span_label(
+                            self.call_metadata.full_call_span,
+                            format!("arguments to this {call_name} are incorrect"),
+                        );
+                    } else {
+                        let call_name = self.call_metadata.call_name;
+                        err = self.dcx().struct_span_err(
+                            self.arg_matching_ctxt.args_ctxt.call_metadata.full_call_span,
+                            format!(
+                                "{call_name} takes {}{} but {} {} supplied",
+                                if self.c_variadic { "at least " } else { "" },
+                                potentially_plural_count(
+                                    self.formal_and_expected_inputs.len(),
+                                    "argument"
+                                ),
+                                potentially_plural_count(self.provided_args.len(), "argument"),
+                                pluralize!("was", self.provided_args.len())
+                            ),
+                        );
+                        err.code(self.err_code.to_owned());
+                        err.multipart_suggestion_verbose(
+                            "wrap these arguments in parentheses to construct a tuple",
+                            vec![
+                                (lo.shrink_to_lo(), "(".to_string()),
+                                (hi.shrink_to_hi(), ")".to_string()),
+                            ],
+                            Applicability::MachineApplicable,
+                        );
+                    };
+                    self.arg_matching_ctxt.args_ctxt.call_ctxt.fn_ctxt.label_fn_like(
+                        &mut err,
+                        self.fn_def_id,
+                        self.callee_ty,
+                        self.call_expr,
+                        None,
+                        Some(mismatch_idx.as_usize()),
+                        &self.matched_inputs,
+                        &self.formal_and_expected_inputs,
+                        self.call_metadata.is_method,
+                        self.tuple_arguments,
+                    );
+                    self.suggest_confusable(&mut err);
+                    Some(err.emit())
+                } else {
+                    None
+                }
+            } else {
+                None
             }
-            // Override the types everywhere with `err()` to avoid knock on errors.
-            let err = Ty::new_error(self.tcx, guar);
-            self.write_ty(hir_id, err);
-            self.write_ty(pat.hir_id, err);
-            let mut visitor = OverwritePatternsWithError { pat_hir_ids: vec![] };
-            hir::intravisit::walk_pat(&mut visitor, pat);
-            // Mark all the subpatterns as `{type error}` as well. This allows errors for specific
-            // subpatterns to be silenced.
-            for hir_id in visitor.pat_hir_ids {
-                self.write_ty(hir_id, err);
-            }
-            self.locals.borrow_mut().insert(hir_id, err);
-            self.locals.borrow_mut().insert(pat.hir_id, err);
+        } else {
+            None
         }
     }
 
-    // Finish resolving a path in a struct expression or pattern `S::A { .. }` if necessary.
-    // The newly resolved definition is written into `type_dependent_defs`.
-    fn finish_resolving_struct_path(
-        &self,
-        qpath: &QPath<'tcx>,
-        path_span: Span,
-        hir_id: HirId,
-    ) -> (Res, LoweredTy<'tcx>) {
-        match *qpath {
-            QPath::Resolved(ref maybe_qself, path) => {
-                let self_ty = maybe_qself.as_ref().map(|qself| self.lower_ty(qself).raw);
-                let ty = self.lowerer().lower_resolved_ty_path(
-                    self_ty,
-                    path,
-                    hir_id,
-                    PermitVariants::Yes,
-                );
-                (path.res, LoweredTy::from_raw(self, path_span, ty))
+    fn ensure_has_errors(&self) -> Option<ErrorGuaranteed> {
+        if self.errors.is_empty() {
+            if cfg!(debug_assertions) {
+                span_bug!(self.call_metadata.error_span, "expected errors from argument matrix");
+            } else {
+                let mut err = self.dcx().create_err(errors::ArgMismatchIndeterminate {
+                    span: self.call_metadata.error_span,
+                });
+                self.arg_matching_ctxt.suggest_confusable(&mut err);
+                return Some(err.emit());
             }
-            QPath::TypeRelative(hir_self_ty, segment) => {
-                let self_ty = self.lower_ty(hir_self_ty);
+        }
 
-                let result = self.lowerer().lower_type_relative_ty_path(
-                    self_ty.raw,
-                    hir_self_ty,
-                    segment,
-                    hir_id,
-                    path_span,
-                    PermitVariants::Yes,
-                );
-                let ty = result
-                    .map(|(ty, _, _)| ty)
-                    .unwrap_or_else(|guar| Ty::new_error(self.tcx(), guar));
-                let ty = LoweredTy::from_raw(self, path_span, ty);
-                let result = result.map(|(_, kind, def_id)| (kind, def_id));
+        None
+    }
 
-                // Write back the new resolution.
-                self.write_resolution(hir_id, result);
+    fn detect_dotdot(&self, err: &mut Diag<'_>, ty: Ty<'tcx>, expr: &hir::Expr<'tcx>) {
+        if let ty::Adt(adt, _) = ty.kind()
+            && self.tcx().is_lang_item(adt.did(), hir::LangItem::RangeFull)
+            && let hir::ExprKind::Struct(hir::QPath::LangItem(hir::LangItem::RangeFull, _), [], _) =
+                expr.kind
+        {
+            // We have `Foo(a, .., c)`, where the user might be trying to use the "rest" syntax
+            // from default field values, which is not supported on tuples.
+            let explanation = if self.tcx.features().default_field_values() {
+                "this is only supported on non-tuple struct literals"
+            } else if self.tcx.sess.is_nightly_build() {
+                "this is only supported on non-tuple struct literals when \
+                 `#![feature(default_field_values)]` is enabled"
+            } else {
+                "this is not supported"
+            };
+            let msg = format!(
+                "you might have meant to use `..` to skip providing a value for \
+                 expected fields, but {explanation}; it is instead interpreted as a \
+                 `std::ops::RangeFull` literal",
+            );
+            err.span_help(expr.span, msg);
+        }
+    }
 
-                (result.map_or(Res::Err, |(kind, def_id)| Res::Def(kind, def_id)), ty)
-            }
-            QPath::LangItem(lang_item, span) => {
-                let (res, ty) = self.resolve_lang_item_path(lang_item, span, hir_id);
-                (res, LoweredTy::from_raw(self, path_span, ty))
+    fn filter_out_invalid_arguments(&mut self) -> Option<ErrorGuaranteed> {
+        let mut reported = None;
+
+        self.errors.retain(|error| {
+            let Error::Invalid(provided_idx, expected_idx, Compatibility::Incompatible(Some(e))) =
+                error
+            else {
+                return true;
+            };
+            let (provided_ty, provided_span) =
+                self.arg_matching_ctxt.provided_arg_tys[*provided_idx];
+            let trace = self.arg_matching_ctxt.mk_trace(
+                provided_span,
+                self.arg_matching_ctxt.formal_and_expected_inputs[*expected_idx],
+                provided_ty,
+            );
+            if !matches!(trace.cause.as_failure_code(*e), FailureCode::Error0308) {
+                let mut err = self.arg_matching_ctxt.err_ctxt().report_and_explain_type_error(
+                    trace,
+                    self.arg_matching_ctxt.param_env,
+                    *e,
+                );
+                self.arg_matching_ctxt.suggest_confusable(&mut err);
+                reported = Some(err.emit());
+                return false;
             }
-        }
+            true
+        });
+
+        reported
     }
 
-    /// Given a vector of fulfillment errors, try to adjust the spans of the
-    /// errors to more accurately point at the cause of the failure.
-    ///
-    /// This applies to calls, methods, and struct expressions. This will also
-    /// try to deduplicate errors that are due to the same cause but might
-    /// have been created with different [`ObligationCause`][traits::ObligationCause]s.
-    pub(super) fn adjust_fulfillment_errors_for_expr_obligation(
-        &self,
-        errors: &mut Vec<traits::FulfillmentError<'tcx>>,
-    ) {
-        // Store a mapping from `(Span, Predicate) -> ObligationCause`, so that
-        // other errors that have the same span and predicate can also get fixed,
-        // even if their `ObligationCauseCode` isn't an `Expr*Obligation` kind.
-        // This is important since if we adjust one span but not the other, then
-        // we will have "duplicated" the error on the UI side.
-        let mut remap_cause = FxIndexSet::default();
-        let mut not_adjusted = vec![];
+    fn check_single_incompatible(&self) -> Option<ErrorGuaranteed> {
+        if let &[
+            Error::Invalid(provided_idx, expected_idx, Compatibility::Incompatible(Some(err))),
+        ] = &self.errors[..]
+        {
+            let (formal_ty, expected_ty) = self.formal_and_expected_inputs[expected_idx];
+            let (provided_ty, provided_arg_span) = self.provided_arg_tys[provided_idx];
+            let trace = self.mk_trace(provided_arg_span, (formal_ty, expected_ty), provided_ty);
+            let mut err = self.err_ctxt().report_and_explain_type_error(trace, self.param_env, err);
+            self.emit_coerce_suggestions(
+                &mut err,
+                self.provided_args[provided_idx],
+                provided_ty,
+                Expectation::rvalue_hint(self.fn_ctxt, expected_ty)
+                    .only_has_type(self.fn_ctxt)
+                    .unwrap_or(formal_ty),
+                None,
+                None,
+            );
+            let call_name = self.call_metadata.call_name;
+            err.span_label(
+                self.call_metadata.full_call_span,
+                format!("arguments to this {call_name} are incorrect"),
+            );
 
-        for error in errors {
-            let before_span = error.obligation.cause.span;
-            if self.adjust_fulfillment_error_for_expr_obligation(error)
-                || before_span != error.obligation.cause.span
+            self.fn_ctxt.label_generic_mismatches(
+                &mut err,
+                self.fn_def_id,
+                &self.matched_inputs,
+                &self.provided_arg_tys,
+                &self.formal_and_expected_inputs,
+                self.call_metadata.is_method,
+            );
+
+            if let hir::ExprKind::MethodCall(_, rcvr, _, _) =
+                self.arg_matching_ctxt.args_ctxt.call_ctxt.call_expr.kind
+                && provided_idx.as_usize() == expected_idx.as_usize()
             {
-                remap_cause.insert((
-                    before_span,
-                    error.obligation.predicate,
-                    error.obligation.cause.clone(),
-                ));
-            } else {
-                // If it failed to be adjusted once around, it may be adjusted
-                // via the "remap cause" mapping the second time...
-                not_adjusted.push(error);
+                self.note_source_of_type_mismatch_constraint(
+                    &mut err,
+                    rcvr,
+                    crate::demand::TypeMismatchSource::Arg {
+                        call_expr: self.call_expr,
+                        incompatible_arg: provided_idx.as_usize(),
+                    },
+                );
             }
+
+            self.suggest_ptr_null_mut(
+                expected_ty,
+                provided_ty,
+                self.provided_args[provided_idx],
+                &mut err,
+            );
+
+            self.suggest_deref_unwrap_or(
+                &mut err,
+                self.callee_ty,
+                self.call_metadata.call_ident,
+                expected_ty,
+                provided_ty,
+                self.provided_args[provided_idx],
+                self.call_metadata.is_method,
+            );
+
+            // Call out where the function is defined
+            self.label_fn_like(
+                &mut err,
+                self.fn_def_id,
+                self.callee_ty,
+                self.call_expr,
+                Some(expected_ty),
+                Some(expected_idx.as_usize()),
+                &self.matched_inputs,
+                &self.formal_and_expected_inputs,
+                self.call_metadata.is_method,
+                self.tuple_arguments,
+            );
+            self.arg_matching_ctxt.suggest_confusable(&mut err);
+            self.detect_dotdot(&mut err, provided_ty, self.provided_args[provided_idx]);
+            return Some(err.emit());
         }
 
-        // Adjust any other errors that come from other cause codes, when these
-        // errors are of the same predicate as one we successfully adjusted, and
-        // when their spans overlap (suggesting they're due to the same root cause).
-        //
-        // This is because due to normalization, we often register duplicate
-        // obligations with misc obligations that are basically impossible to
-        // line back up with a useful WhereClauseInExpr.
-        for error in not_adjusted {
-            for (span, predicate, cause) in &remap_cause {
-                if *predicate == error.obligation.predicate
-                    && span.contains(error.obligation.cause.span)
+        None
+    }
+
+    fn maybe_optimize_extra_arg_suggestion(&mut self) {
+        if let [Error::Extra(provided_idx)] = &self.errors[..] {
+            if !self.remove_idx_is_perfect(provided_idx.as_usize()) {
+                if let Some(i) = (0..self.args_ctxt.call_ctxt.provided_args.len())
+                    .find(|&i| self.remove_idx_is_perfect(i))
                 {
-                    error.obligation.cause = cause.clone();
-                    continue;
+                    self.errors = vec![Error::Extra(ProvidedIdx::from_usize(i))];
                 }
             }
         }
     }
 
-    fn label_fn_like(
+    fn initial_final_diagnostic(&self) -> Diag<'_> {
+        if self.formal_and_expected_inputs.len() == self.provided_args.len() {
+            struct_span_code_err!(
+                self.dcx(),
+                self.call_metadata.full_call_span,
+                E0308,
+                "arguments to this {} are incorrect",
+                self.call_metadata.call_name,
+            )
+        } else {
+            self.arg_matching_ctxt
+                .dcx()
+                .struct_span_err(
+                    self.call_metadata.full_call_span,
+                    format!(
+                        "this {} takes {}{} but {} {} supplied",
+                        self.call_metadata.call_name,
+                        if self.c_variadic { "at least " } else { "" },
+                        potentially_plural_count(self.formal_and_expected_inputs.len(), "argument"),
+                        potentially_plural_count(self.provided_args.len(), "argument"),
+                        pluralize!("was", self.provided_args.len())
+                    ),
+                )
+                .with_code(self.err_code.to_owned())
+        }
+    }
+
+    fn labels_and_suggestion_text(
         &self,
         err: &mut Diag<'_>,
-        callable_def_id: Option<DefId>,
-        callee_ty: Option<Ty<'tcx>>,
-        call_expr: &'tcx hir::Expr<'tcx>,
-        expected_ty: Option<Ty<'tcx>>,
-        // A specific argument should be labeled, instead of all of them
-        expected_idx: Option<usize>,
-        matched_inputs: &IndexVec<ExpectedIdx, Option<ProvidedIdx>>,
-        formal_and_expected_inputs: &IndexVec<ExpectedIdx, (Ty<'tcx>, Ty<'tcx>)>,
-        is_method: bool,
-        tuple_arguments: TupleArgumentsFlag,
-    ) {
-        let Some(mut def_id) = callable_def_id else {
-            return;
-        };
+    ) -> (Vec<(Span, String)>, Vec<(Span, String)>, SuggestionText) {
+        // Don't print if it has error types or is just plain `_`
+        fn has_error_or_infer<'tcx>(tys: impl IntoIterator<Item = Ty<'tcx>>) -> bool {
+            tys.into_iter().any(|ty| ty.references_error() || ty.is_ty_var())
+        }
 
-        // If we're calling a method of a Fn/FnMut/FnOnce trait object implicitly
-        // (eg invoking a closure) we want to point at the underlying callable,
-        // not the method implicitly invoked (eg call_once).
-        // TupleArguments is set only when this is an implicit call (my_closure(...)) rather than explicit (my_closure.call(...))
-        if tuple_arguments == TupleArguments
-            && let Some(assoc_item) = self.tcx.opt_associated_item(def_id)
-            // Since this is an associated item, it might point at either an impl or a trait item.
-            // We want it to always point to the trait item.
-            // If we're pointing at an inherent function, we don't need to do anything,
-            // so we fetch the parent and verify if it's a trait item.
-            && let maybe_trait_item_def_id = assoc_item.trait_item_def_id.unwrap_or(def_id)
-            && let maybe_trait_def_id = self.tcx.parent(maybe_trait_item_def_id)
-            // Just an easy way to check "trait_def_id == Fn/FnMut/FnOnce"
-            && let Some(call_kind) = self.tcx.fn_trait_kind_from_def_id(maybe_trait_def_id)
-            && let Some(callee_ty) = callee_ty
-        {
-            let callee_ty = callee_ty.peel_refs();
-            match *callee_ty.kind() {
-                ty::Param(param) => {
-                    let param = self.tcx.generics_of(self.body_id).type_param(param, self.tcx);
-                    if param.kind.is_synthetic() {
-                        // if it's `impl Fn() -> ..` then just fall down to the def-id based logic
-                        def_id = param.def_id;
-                    } else {
-                        // Otherwise, find the predicate that makes this generic callable,
-                        // and point at that.
-                        let instantiated = self
-                            .tcx
-                            .explicit_predicates_of(self.body_id)
-                            .instantiate_identity(self.tcx);
-                        // FIXME(compiler-errors): This could be problematic if something has two
-                        // fn-like predicates with different args, but callable types really never
-                        // do that, so it's OK.
-                        for (predicate, span) in instantiated {
-                            if let ty::ClauseKind::Trait(pred) = predicate.kind().skip_binder()
-                                && pred.self_ty().peel_refs() == callee_ty
-                                && self.tcx.is_fn_trait(pred.def_id())
-                            {
-                                err.span_note(span, "callable defined here");
-                                return;
-                            }
+        let mut labels = Vec::new();
+        let mut suggestion_text = SuggestionText::None;
+
+        let mut errors = self.errors.iter().peekable();
+        let mut only_extras_so_far = errors
+            .peek()
+            .is_some_and(|first| matches!(first, Error::Extra(arg_idx) if arg_idx.index() == 0));
+        let mut prev_extra_idx = None;
+        let mut suggestions = vec![];
+        while let Some(error) = errors.next() {
+            only_extras_so_far &= matches!(error, Error::Extra(_));
+
+            match error {
+                Error::Invalid(provided_idx, expected_idx, compatibility) => {
+                    let (formal_ty, expected_ty) =
+                        self.arg_matching_ctxt.args_ctxt.call_ctxt.formal_and_expected_inputs
+                            [*expected_idx];
+                    let (provided_ty, provided_span) =
+                        self.arg_matching_ctxt.provided_arg_tys[*provided_idx];
+                    if let Compatibility::Incompatible(error) = compatibility {
+                        let trace = self.arg_matching_ctxt.args_ctxt.call_ctxt.mk_trace(
+                            provided_span,
+                            (formal_ty, expected_ty),
+                            provided_ty,
+                        );
+                        if let Some(e) = error {
+                            self.err_ctxt().note_type_err(
+                                err,
+                                &trace.cause,
+                                None,
+                                Some(self.param_env.and(trace.values)),
+                                *e,
+                                true,
+                                None,
+                            );
                         }
                     }
+
+                    self.emit_coerce_suggestions(
+                        err,
+                        self.provided_args[*provided_idx],
+                        provided_ty,
+                        Expectation::rvalue_hint(self.fn_ctxt, expected_ty)
+                            .only_has_type(self.fn_ctxt)
+                            .unwrap_or(formal_ty),
+                        None,
+                        None,
+                    );
+                    self.detect_dotdot(err, provided_ty, self.provided_args[*provided_idx]);
                 }
-                ty::Alias(ty::Opaque, ty::AliasTy { def_id: new_def_id, .. })
-                | ty::Closure(new_def_id, _)
-                | ty::FnDef(new_def_id, _) => {
-                    def_id = new_def_id;
-                }
-                _ => {
-                    // Look for a user-provided impl of a `Fn` trait, and point to it.
-                    let new_def_id = self.probe(|_| {
-                        let trait_ref = ty::TraitRef::new(
-                            self.tcx,
-                            self.tcx.fn_trait_kind_to_def_id(call_kind)?,
-                            [callee_ty, self.next_ty_var(DUMMY_SP)],
-                        );
-                        let obligation = traits::Obligation::new(
-                            self.tcx,
-                            traits::ObligationCause::dummy(),
-                            self.param_env,
-                            trait_ref,
-                        );
-                        match SelectionContext::new(self).select(&obligation) {
-                            Ok(Some(traits::ImplSource::UserDefined(impl_source))) => {
-                                Some(impl_source.impl_def_id)
+                Error::Extra(arg_idx) => {
+                    let (provided_ty, provided_span) = self.provided_arg_tys[*arg_idx];
+                    let provided_ty_name = if !has_error_or_infer([provided_ty]) {
+                        // FIXME: not suggestable, use something else
+                        format!(" of type `{provided_ty}`")
+                    } else {
+                        "".to_string()
+                    };
+                    let idx = if self.provided_arg_tys.len() == 1 {
+                        "".to_string()
+                    } else {
+                        format!(" #{}", arg_idx.as_usize() + 1)
+                    };
+                    labels.push((
+                        provided_span,
+                        format!("unexpected argument{idx}{provided_ty_name}"),
+                    ));
+                    let mut span = provided_span;
+                    if span.can_be_used_for_suggestions()
+                        && self.call_metadata.error_span.can_be_used_for_suggestions()
+                    {
+                        if arg_idx.index() > 0
+                            && let Some((_, prev)) = self
+                                .provided_arg_tys
+                                .get(ProvidedIdx::from_usize(arg_idx.index() - 1))
+                        {
+                            // Include previous comma
+                            span = prev.shrink_to_hi().to(span);
+                        }
+
+                        // Is last argument for deletion in a row starting from the 0-th argument?
+                        // Then delete the next comma, so we are not left with `f(, ...)`
+                        //
+                        //     fn f() {}
+                        //   - f(0, 1,)
+                        //   + f()
+                        let trim_next_comma = match errors.peek() {
+                            Some(Error::Extra(provided_idx))
+                                if only_extras_so_far
+                                    && provided_idx.index() > arg_idx.index() + 1 =>
+                            // If the next Error::Extra ("next") doesn't next to current ("current"),
+                            // fn foo(_: (), _: u32) {}
+                            // - foo("current", (), 1u32, "next")
+                            // + foo((), 1u32)
+                            // If the previous error is not a `Error::Extra`, then do not trim the next comma
+                            // - foo((), "current", 42u32, "next")
+                            // + foo((), 42u32)
+                            {
+                                prev_extra_idx.is_none_or(|prev_extra_idx| {
+                                    prev_extra_idx + 1 == arg_idx.index()
+                                })
                             }
-                            _ => None,
+                            // If no error left, we need to delete the next comma
+                            None if only_extras_so_far => true,
+                            // Not sure if other error type need to be handled as well
+                            _ => false,
+                        };
+
+                        if trim_next_comma {
+                            let next = self
+                                .provided_arg_tys
+                                .get(*arg_idx + 1)
+                                .map(|&(_, sp)| sp)
+                                .unwrap_or_else(|| {
+                                    // Try to move before `)`. Note that `)` here is not necessarily
+                                    // the latin right paren, it could be a Unicode-confusable that
+                                    // looks like a `)`, so we must not use `- BytePos(1)`
+                                    // manipulations here.
+                                    self.arg_matching_ctxt
+                                        .tcx()
+                                        .sess
+                                        .source_map()
+                                        .end_point(self.call_expr.span)
+                                });
+
+                            // Include next comma
+                            span = span.until(next);
                         }
-                    });
-                    if let Some(new_def_id) = new_def_id {
-                        def_id = new_def_id;
-                    } else {
-                        return;
-                    }
-                }
-            }
-        }
 
-        if let Some(def_span) = self.tcx.def_ident_span(def_id)
-            && !def_span.is_dummy()
-        {
-            let mut spans: MultiSpan = def_span.into();
-            if let Some((params_with_generics, hir_generics)) =
-                self.get_hir_param_info(def_id, is_method)
-            {
-                struct MismatchedParam<'a> {
-                    idx: ExpectedIdx,
-                    generic: GenericIdx,
-                    param: &'a FnParam<'a>,
-                    deps: SmallVec<[ExpectedIdx; 4]>,
-                }
+                        suggestions.push((span, String::new()));
 
-                debug_assert_eq!(params_with_generics.len(), matched_inputs.len());
-                // Gather all mismatched parameters with generics.
-                let mut mismatched_params = Vec::<MismatchedParam<'_>>::new();
-                if let Some(expected_idx) = expected_idx {
-                    let expected_idx = ExpectedIdx::from_usize(expected_idx);
-                    let &(expected_generic, ref expected_param) =
-                        &params_with_generics[expected_idx];
-                    if let Some(expected_generic) = expected_generic {
-                        mismatched_params.push(MismatchedParam {
-                            idx: expected_idx,
-                            generic: expected_generic,
-                            param: expected_param,
-                            deps: SmallVec::new(),
-                        });
-                    } else {
-                        // Still mark the mismatched parameter
-                        spans.push_span_label(expected_param.span(), "");
+                        suggestion_text = match suggestion_text {
+                            SuggestionText::None => SuggestionText::Remove(false),
+                            SuggestionText::Remove(_) => SuggestionText::Remove(true),
+                            _ => SuggestionText::DidYouMean,
+                        };
+                        prev_extra_idx = Some(arg_idx.index())
                     }
-                } else {
-                    mismatched_params.extend(
-                        params_with_generics.iter_enumerated().zip(matched_inputs).filter_map(
-                            |((idx, &(generic, ref param)), matched_idx)| {
-                                if matched_idx.is_some() {
-                                    None
-                                } else if let Some(generic) = generic {
-                                    Some(MismatchedParam {
-                                        idx,
-                                        generic,
-                                        param,
-                                        deps: SmallVec::new(),
-                                    })
-                                } else {
-                                    // Still mark mismatched parameters
-                                    spans.push_span_label(param.span(), "");
-                                    None
-                                }
-                            },
-                        ),
-                    );
+                    self.detect_dotdot(err, provided_ty, self.provided_args[*arg_idx]);
                 }
+                Error::Missing(expected_idx) => {
+                    // If there are multiple missing arguments adjacent to each other,
+                    // then we can provide a single error.
 
-                if !mismatched_params.is_empty() {
-                    // For each mismatched parameter, create a two-way link to each matched parameter
-                    // of the same type.
-                    let mut dependants = IndexVec::<ExpectedIdx, _>::from_fn_n(
-                        |_| SmallVec::<[u32; 4]>::new(),
-                        params_with_generics.len(),
-                    );
-                    let mut generic_uses = IndexVec::<GenericIdx, _>::from_fn_n(
-                        |_| SmallVec::<[ExpectedIdx; 4]>::new(),
-                        hir_generics.params.len(),
-                    );
-                    for (idx, param) in mismatched_params.iter_mut().enumerate() {
-                        for ((other_idx, &(other_generic, _)), &other_matched_idx) in
-                            params_with_generics.iter_enumerated().zip(matched_inputs)
-                        {
-                            if other_generic == Some(param.generic) && other_matched_idx.is_some() {
-                                generic_uses[param.generic].extend([param.idx, other_idx]);
-                                dependants[other_idx].push(idx as u32);
-                                param.deps.push(other_idx);
-                            }
+                    let mut missing_idxs = vec![*expected_idx];
+                    while let Some(e) = errors.next_if(|e| {
+                        matches!(e, Error::Missing(next_expected_idx)
+                            if *next_expected_idx == *missing_idxs.last().unwrap() + 1)
+                    }) {
+                        match e {
+                            Error::Missing(expected_idx) => missing_idxs.push(*expected_idx),
+                            _ => unreachable!(
+                                "control flow ensures that we should always get an `Error::Missing`"
+                            ),
                         }
                     }
 
-                    // Highlight each mismatched type along with a note about which other parameters
-                    // the type depends on (if any).
-                    for param in &mismatched_params {
-                        if let Some(deps_list) = listify(&param.deps, |&dep| {
-                            params_with_generics[dep].1.display(dep.as_usize()).to_string()
-                        }) {
-                            spans.push_span_label(
-                                param.param.span(),
+                    // NOTE: Because we might be re-arranging arguments, might have extra
+                    // arguments, etc. it's hard to *really* know where we should provide
+                    // this error label, so as a heuristic, we point to the provided arg, or
+                    // to the call if the missing inputs pass the provided args.
+                    match &missing_idxs[..] {
+                        &[expected_idx] => {
+                            let (_, input_ty) = self.formal_and_expected_inputs[expected_idx];
+                            let span = if let Some((_, arg_span)) =
+                                self.provided_arg_tys.get(expected_idx.to_provided_idx())
+                            {
+                                *arg_span
+                            } else {
+                                self.args_span
+                            };
+                            let rendered = if !has_error_or_infer([input_ty]) {
+                                format!(" of type `{input_ty}`")
+                            } else {
+                                "".to_string()
+                            };
+                            labels.push((
+                                span,
                                 format!(
-                                    "this parameter needs to match the {} type of {deps_list}",
-                                    self.resolve_vars_if_possible(
-                                        formal_and_expected_inputs[param.deps[0]].1
-                                    )
-                                    .sort_string(self.tcx),
+                                    "argument #{}{rendered} is missing",
+                                    expected_idx.as_usize() + 1
                                 ),
-                            );
-                        } else {
-                            // Still mark mismatched parameters
-                            spans.push_span_label(param.param.span(), "");
+                            ));
+
+                            suggestion_text = match suggestion_text {
+                                SuggestionText::None => SuggestionText::Provide(false),
+                                SuggestionText::Provide(_) => SuggestionText::Provide(true),
+                                _ => SuggestionText::DidYouMean,
+                            };
                         }
-                    }
-                    // Highlight each parameter being depended on for a generic type.
-                    for ((&(_, param), deps), &(_, expected_ty)) in
-                        params_with_generics.iter().zip(&dependants).zip(formal_and_expected_inputs)
-                    {
-                        if let Some(deps_list) = listify(deps, |&dep| {
-                            let param = &mismatched_params[dep as usize];
-                            param.param.display(param.idx.as_usize()).to_string()
-                        }) {
-                            spans.push_span_label(
-                                param.span(),
-                                format!(
-                                    "{deps_list} need{} to match the {} type of this parameter",
-                                    pluralize!((deps.len() != 1) as u32),
-                                    self.resolve_vars_if_possible(expected_ty)
-                                        .sort_string(self.tcx),
-                                ),
-                            );
+                        &[first_idx, second_idx] => {
+                            let (_, first_expected_ty) = self.formal_and_expected_inputs[first_idx];
+                            let (_, second_expected_ty) =
+                                self.formal_and_expected_inputs[second_idx];
+                            let span = if let (Some((_, first_span)), Some((_, second_span))) = (
+                                self.provided_arg_tys.get(first_idx.to_provided_idx()),
+                                self.provided_arg_tys.get(second_idx.to_provided_idx()),
+                            ) {
+                                first_span.to(*second_span)
+                            } else {
+                                self.args_span
+                            };
+                            let rendered =
+                                if !has_error_or_infer([first_expected_ty, second_expected_ty]) {
+                                    format!(
+                                        " of type `{first_expected_ty}` and `{second_expected_ty}`"
+                                    )
+                                } else {
+                                    "".to_string()
+                                };
+                            labels.push((span, format!("two arguments{rendered} are missing")));
+                            suggestion_text = match suggestion_text {
+                                SuggestionText::None | SuggestionText::Provide(_) => {
+                                    SuggestionText::Provide(true)
+                                }
+                                _ => SuggestionText::DidYouMean,
+                            };
                         }
-                    }
-                    // Highlight each generic parameter in use.
-                    for (param, uses) in hir_generics.params.iter().zip(&mut generic_uses) {
-                        uses.sort();
-                        uses.dedup();
-                        if let Some(param_list) = listify(uses, |&idx| {
-                            params_with_generics[idx].1.display(idx.as_usize()).to_string()
-                        }) {
-                            spans.push_span_label(
-                                param.span,
+                        &[first_idx, second_idx, third_idx] => {
+                            let (_, first_expected_ty) = self.formal_and_expected_inputs[first_idx];
+                            let (_, second_expected_ty) =
+                                self.formal_and_expected_inputs[second_idx];
+                            let (_, third_expected_ty) = self.formal_and_expected_inputs[third_idx];
+                            let span = if let (Some((_, first_span)), Some((_, third_span))) = (
+                                self.provided_arg_tys.get(first_idx.to_provided_idx()),
+                                self.provided_arg_tys.get(third_idx.to_provided_idx()),
+                            ) {
+                                first_span.to(*third_span)
+                            } else {
+                                self.args_span
+                            };
+                            let rendered = if !has_error_or_infer([
+                                first_expected_ty,
+                                second_expected_ty,
+                                third_expected_ty,
+                            ]) {
                                 format!(
-                                    "{param_list} {} reference this parameter `{}`",
-                                    if uses.len() == 2 { "both" } else { "all" },
-                                    param.name.ident().name,
-                                ),
-                            );
+                                    " of type `{first_expected_ty}`, `{second_expected_ty}`, and `{third_expected_ty}`"
+                                )
+                            } else {
+                                "".to_string()
+                            };
+                            labels.push((span, format!("three arguments{rendered} are missing")));
+                            suggestion_text = match suggestion_text {
+                                SuggestionText::None | SuggestionText::Provide(_) => {
+                                    SuggestionText::Provide(true)
+                                }
+                                _ => SuggestionText::DidYouMean,
+                            };
+                        }
+                        missing_idxs => {
+                            let first_idx = *missing_idxs.first().unwrap();
+                            let last_idx = *missing_idxs.last().unwrap();
+                            // NOTE: Because we might be re-arranging arguments, might have extra arguments, etc.
+                            // It's hard to *really* know where we should provide this error label, so this is a
+                            // decent heuristic
+                            let span = if let (Some((_, first_span)), Some((_, last_span))) = (
+                                self.provided_arg_tys.get(first_idx.to_provided_idx()),
+                                self.provided_arg_tys.get(last_idx.to_provided_idx()),
+                            ) {
+                                first_span.to(*last_span)
+                            } else {
+                                self.args_span
+                            };
+                            labels.push((span, "multiple arguments are missing".to_string()));
+                            suggestion_text = match suggestion_text {
+                                SuggestionText::None | SuggestionText::Provide(_) => {
+                                    SuggestionText::Provide(true)
+                                }
+                                _ => SuggestionText::DidYouMean,
+                            };
                         }
                     }
                 }
-            }
-            err.span_note(spans, format!("{} defined here", self.tcx.def_descr(def_id)));
-        } else if let Some(hir::Node::Expr(e)) = self.tcx.hir_get_if_local(def_id)
-            && let hir::ExprKind::Closure(hir::Closure { body, .. }) = &e.kind
-        {
-            let param = expected_idx
-                .and_then(|expected_idx| self.tcx.hir_body(*body).params.get(expected_idx));
-            let (kind, span) = if let Some(param) = param {
-                // Try to find earlier invocations of this closure to find if the type mismatch
-                // is because of inference. If we find one, point at them.
-                let mut call_finder = FindClosureArg { tcx: self.tcx, calls: vec![] };
-                let parent_def_id = self.tcx.hir_get_parent_item(call_expr.hir_id).def_id;
-                match self.tcx.hir_node_by_def_id(parent_def_id) {
-                    hir::Node::Item(item) => call_finder.visit_item(item),
-                    hir::Node::TraitItem(item) => call_finder.visit_trait_item(item),
-                    hir::Node::ImplItem(item) => call_finder.visit_impl_item(item),
-                    _ => {}
+                Error::Swap(
+                    first_provided_idx,
+                    second_provided_idx,
+                    first_expected_idx,
+                    second_expected_idx,
+                ) => {
+                    let (first_provided_ty, first_span) =
+                        self.provided_arg_tys[*first_provided_idx];
+                    let (_, first_expected_ty) =
+                        self.formal_and_expected_inputs[*first_expected_idx];
+                    let first_provided_ty_name = if !has_error_or_infer([first_provided_ty]) {
+                        format!(", found `{first_provided_ty}`")
+                    } else {
+                        String::new()
+                    };
+                    labels.push((
+                        first_span,
+                        format!("expected `{first_expected_ty}`{first_provided_ty_name}"),
+                    ));
+
+                    let (second_provided_ty, second_span) =
+                        self.provided_arg_tys[*second_provided_idx];
+                    let (_, second_expected_ty) =
+                        self.formal_and_expected_inputs[*second_expected_idx];
+                    let second_provided_ty_name = if !has_error_or_infer([second_provided_ty]) {
+                        format!(", found `{second_provided_ty}`")
+                    } else {
+                        String::new()
+                    };
+                    labels.push((
+                        second_span,
+                        format!("expected `{second_expected_ty}`{second_provided_ty_name}"),
+                    ));
+
+                    suggestion_text = match suggestion_text {
+                        SuggestionText::None => SuggestionText::Swap,
+                        _ => SuggestionText::DidYouMean,
+                    };
                 }
-                let typeck = self.typeck_results.borrow();
-                for (rcvr, args) in call_finder.calls {
-                    if rcvr.hir_id.owner == typeck.hir_owner
-                        && let Some(rcvr_ty) = typeck.node_type_opt(rcvr.hir_id)
-                        && let ty::Closure(call_def_id, _) = rcvr_ty.kind()
-                        && def_id == *call_def_id
-                        && let Some(idx) = expected_idx
-                        && let Some(arg) = args.get(idx)
-                        && let Some(arg_ty) = typeck.node_type_opt(arg.hir_id)
-                        && let Some(expected_ty) = expected_ty
-                        && self.can_eq(self.param_env, arg_ty, expected_ty)
-                    {
-                        let mut sp: MultiSpan = vec![arg.span].into();
-                        sp.push_span_label(
-                            arg.span,
-                            format!("expected because this argument is of type `{arg_ty}`"),
-                        );
-                        sp.push_span_label(rcvr.span, "in this closure call");
-                        err.span_note(
-                            sp,
-                            format!(
-                                "expected because the closure was earlier called with an \
-                                argument of type `{arg_ty}`",
-                            ),
-                        );
-                        break;
+                Error::Permutation(args) => {
+                    for (dst_arg, dest_input) in args {
+                        let (_, expected_ty) = self.formal_and_expected_inputs[*dst_arg];
+                        let (provided_ty, provided_span) = self.provided_arg_tys[*dest_input];
+                        let provided_ty_name = if !has_error_or_infer([provided_ty]) {
+                            format!(", found `{provided_ty}`")
+                        } else {
+                            String::new()
+                        };
+                        labels.push((
+                            provided_span,
+                            format!("expected `{expected_ty}`{provided_ty_name}"),
+                        ));
                     }
+
+                    suggestion_text = match suggestion_text {
+                        SuggestionText::None => SuggestionText::Reorder,
+                        _ => SuggestionText::DidYouMean,
+                    };
                 }
+            }
+        }
 
-                ("closure parameter", param.span)
-            } else {
-                ("closure", self.tcx.def_span(def_id))
-            };
-            err.span_note(span, format!("{kind} defined here"));
-        } else {
-            err.span_note(
-                self.tcx.def_span(def_id),
-                format!("{} defined here", self.tcx.def_descr(def_id)),
-            );
+        (suggestions, labels, suggestion_text)
+    }
+
+    fn label_generic_mismatches(&self, err: &mut Diag<'b>) {
+        self.fn_ctxt.label_generic_mismatches(
+            err,
+            self.fn_def_id,
+            &self.matched_inputs,
+            &self.provided_arg_tys,
+            &self.formal_and_expected_inputs,
+            self.call_metadata.is_method,
+        );
+    }
+
+    /// Incorporate the argument changes in the removal suggestion.
+    ///
+    /// When a type is *missing*, and the rest are additional, we want to suggest these with a
+    /// multipart suggestion, but in order to do so we need to figure out *where* the arg that
+    /// was provided but had the wrong type should go, because when looking at `expected_idx`
+    /// that is the position in the argument list in the definition, while `provided_idx` will
+    /// not be present. So we have to look at what the *last* provided position was, and point
+    /// one after to suggest the replacement.
+    fn append_arguments_changes(&self, suggestions: &mut Vec<(Span, String)>) {
+        // FIXME(estebank): This is hacky, and there's
+        // probably a better more involved change we can make to make this work.
+        // For example, if we have
+        // ```
+        // fn foo(i32, &'static str) {}
+        // foo((), (), ());
+        // ```
+        // what should be suggested is
+        // ```
+        // foo(/* i32 */, /* &str */);
+        // ```
+        // which includes the replacement of the first two `()` for the correct type, and the
+        // removal of the last `()`.
+
+        let mut prev = -1;
+        for (expected_idx, provided_idx) in self.matched_inputs.iter_enumerated() {
+            // We want to point not at the *current* argument expression index, but rather at the
+            // index position where it *should have been*, which is *after* the previous one.
+            if let Some(provided_idx) = provided_idx {
+                prev = provided_idx.index() as i64;
+                continue;
+            }
+            let idx = ProvidedIdx::from_usize((prev + 1) as usize);
+            if let Some((_, arg_span)) = self.provided_arg_tys.get(idx) {
+                prev += 1;
+                // There is a type that was *not* found anywhere, so it isn't a move, but a
+                // replacement and we look at what type it should have been. This will allow us
+                // To suggest a multipart suggestion when encountering `foo(1, "")` where the def
+                // was `fn foo(())`.
+                let (_, expected_ty) = self.formal_and_expected_inputs[expected_idx];
+                suggestions.push((*arg_span, self.ty_to_snippet(expected_ty, expected_idx)));
+            }
         }
     }
 
-    fn label_generic_mismatches(
-        &self,
+    fn format_suggestion_text(
         err: &mut Diag<'_>,
-        callable_def_id: Option<DefId>,
-        matched_inputs: &IndexVec<ExpectedIdx, Option<ProvidedIdx>>,
-        provided_arg_tys: &IndexVec<ProvidedIdx, (Ty<'tcx>, Span)>,
-        formal_and_expected_inputs: &IndexVec<ExpectedIdx, (Ty<'tcx>, Ty<'tcx>)>,
-        is_method: bool,
-    ) {
-        let Some(def_id) = callable_def_id else {
-            return;
+        suggestions: Vec<(Span, String)>,
+        suggestion_text: SuggestionText,
+    ) -> Option<String> {
+        let suggestion_text = match suggestion_text {
+            SuggestionText::None => None,
+            SuggestionText::Provide(plural) => {
+                Some(format!("provide the argument{}", if plural { "s" } else { "" }))
+            }
+            SuggestionText::Remove(plural) => {
+                err.multipart_suggestion_verbose(
+                    format!("remove the extra argument{}", if plural { "s" } else { "" }),
+                    suggestions,
+                    Applicability::HasPlaceholders,
+                );
+                None
+            }
+            SuggestionText::Swap => Some("swap these arguments".to_string()),
+            SuggestionText::Reorder => Some("reorder these arguments".to_string()),
+            SuggestionText::DidYouMean => Some("did you mean".to_string()),
         };
+        suggestion_text
+    }
 
-        if let Some((params_with_generics, _)) = self.get_hir_param_info(def_id, is_method) {
-            debug_assert_eq!(params_with_generics.len(), matched_inputs.len());
-            for (idx, (generic_param, _)) in params_with_generics.iter_enumerated() {
-                if matched_inputs[idx].is_none() {
-                    continue;
-                }
+    fn arguments_formatting(&self, suggestion_span: Span) -> ArgumentsFormatting {
+        let source_map = self.sess().source_map();
+        let mut provided_inputs = self.matched_inputs.iter().filter_map(|a| *a);
+        if let Some(brace_indent) = source_map.indentation_before(suggestion_span)
+            && let Some(first_idx) = provided_inputs.by_ref().next()
+            && let Some(last_idx) = provided_inputs.by_ref().next()
+            && let (_, first_span) = self.provided_arg_tys[first_idx]
+            && let (_, last_span) = self.provided_arg_tys[last_idx]
+            && source_map.is_multiline(first_span.to(last_span))
+            && let Some(fallback_indent) = source_map.indentation_before(first_span)
+        {
+            ArgumentsFormatting::Multiline { fallback_indent, brace_indent }
+        } else {
+            ArgumentsFormatting::SingleLine
+        }
+    }
 
-                let Some((_, matched_arg_span)) = provided_arg_tys.get(idx.to_provided_idx())
-                else {
-                    continue;
-                };
+    fn suggestion_code(&self) -> (Span, String) {
+        let source_map = self.sess().source_map();
+        let suggestion_span = if let Some(args_span) =
+            self.call_metadata.error_span.trim_start(self.call_metadata.full_call_span)
+        {
+            // Span of the braces, e.g. `(a, b, c)`.
+            args_span
+        } else {
+            // The arg span of a function call that wasn't even given braces
+            // like what might happen with delegation reuse.
+            // e.g. `reuse HasSelf::method;` should suggest `reuse HasSelf::method($args);`.
+            self.call_metadata.full_call_span.shrink_to_hi()
+        };
 
-                let Some(generic_param) = generic_param else {
-                    continue;
-                };
+        let arguments_formatting = self.arguments_formatting(suggestion_span);
 
-                let idxs_matched = params_with_generics
-                    .iter_enumerated()
-                    .filter(|&(other_idx, (other_generic_param, _))| {
-                        if other_idx == idx {
-                            return false;
-                        }
-                        let Some(other_generic_param) = other_generic_param else {
-                            return false;
-                        };
-                        if matched_inputs[other_idx].is_some() {
-                            return false;
-                        }
-                        other_generic_param == generic_param
-                    })
-                    .count();
+        let mut suggestion = "(".to_owned();
+        let mut needs_comma = false;
+        for (expected_idx, provided_idx) in self.matched_inputs.iter_enumerated() {
+            if needs_comma {
+                suggestion += ",";
+            }
+            match &arguments_formatting {
+                ArgumentsFormatting::SingleLine if needs_comma => suggestion += " ",
+                ArgumentsFormatting::SingleLine => {}
+                ArgumentsFormatting::Multiline { .. } => suggestion += "\n",
+            }
+            needs_comma = true;
+            let (suggestion_span, suggestion_text) = if let Some(provided_idx) = provided_idx
+                && let (_, provided_span) = self.provided_arg_tys[*provided_idx]
+                && let Ok(arg_text) = source_map.span_to_snippet(provided_span)
+            {
+                (Some(provided_span), arg_text)
+            } else {
+                // Propose a placeholder of the correct type
+                let (_, expected_ty) = self.formal_and_expected_inputs[expected_idx];
+                (None, self.ty_to_snippet(expected_ty, expected_idx))
+            };
+            if let ArgumentsFormatting::Multiline { fallback_indent, .. } = &arguments_formatting {
+                let indent = suggestion_span
+                    .and_then(|span| source_map.indentation_before(span))
+                    .unwrap_or_else(|| fallback_indent.clone());
+                suggestion += &indent;
+            }
+            suggestion += &suggestion_text;
+        }
+        if let ArgumentsFormatting::Multiline { brace_indent, .. } = arguments_formatting {
+            suggestion += ",\n";
+            suggestion += &brace_indent;
+        }
+        suggestion += ")";
 
-                if idxs_matched == 0 {
-                    continue;
-                }
+        (suggestion_span, suggestion)
+    }
+}
 
-                let expected_display_type = self
-                    .resolve_vars_if_possible(formal_and_expected_inputs[idx].1)
-                    .sort_string(self.tcx);
-                let label = if idxs_matched == params_with_generics.len() - 1 {
-                    format!(
-                        "expected all arguments to be this {} type because they need to match the type of this parameter",
-                        expected_display_type
-                    )
-                } else {
-                    format!(
-                        "expected some other arguments to be {} {} type to match the type of this parameter",
-                        a_or_an(&expected_display_type),
-                        expected_display_type,
-                    )
-                };
+struct ArgMatchingCtxt<'a, 'b, 'tcx> {
+    args_ctxt: ArgsCtxt<'a, 'b, 'tcx>,
+    provided_arg_tys: IndexVec<ProvidedIdx, (Ty<'tcx>, Span)>,
+}
+
+impl<'a, 'b, 'tcx> Deref for ArgMatchingCtxt<'a, 'b, 'tcx> {
+    type Target = ArgsCtxt<'a, 'b, 'tcx>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.args_ctxt
+    }
+}
+
+impl<'a, 'b, 'tcx> ArgMatchingCtxt<'a, 'b, 'tcx> {
+    fn new(
+        arg: &'a FnCtxt<'b, 'tcx>,
+        compatibility_diagonal: IndexVec<ProvidedIdx, Compatibility<'tcx>>,
+        formal_and_expected_inputs: IndexVec<ExpectedIdx, (Ty<'tcx>, Ty<'tcx>)>,
+        provided_args: IndexVec<ProvidedIdx, &'tcx Expr<'tcx>>,
+        c_variadic: bool,
+        err_code: ErrCode,
+        fn_def_id: Option<DefId>,
+        call_span: Span,
+        call_expr: &'tcx Expr<'tcx>,
+        tuple_arguments: TupleArgumentsFlag,
+    ) -> Self {
+        let args_ctxt = ArgsCtxt::new(
+            arg,
+            compatibility_diagonal,
+            formal_and_expected_inputs,
+            provided_args,
+            c_variadic,
+            err_code,
+            fn_def_id,
+            call_span,
+            call_expr,
+            tuple_arguments,
+        );
+        let provided_arg_tys = args_ctxt.provided_arg_tys();
 
-                err.span_label(*matched_arg_span, label);
-            }
+        ArgMatchingCtxt { args_ctxt, provided_arg_tys }
+    }
+
+    fn suggest_confusable(&self, err: &mut Diag<'_>) {
+        let Some(call_name) = self.call_metadata.call_ident else {
+            return;
+        };
+        let Some(callee_ty) = self.callee_ty else {
+            return;
+        };
+        let input_types: Vec<Ty<'_>> = self.provided_arg_tys.iter().map(|(ty, _)| *ty).collect();
+
+        // Check for other methods in the following order
+        //  - methods marked as `rustc_confusables` with the provided arguments
+        //  - methods with the same argument type/count and short levenshtein distance
+        //  - methods marked as `rustc_confusables` (done)
+        //  - methods with short levenshtein distance
+
+        // Look for commonly confusable method names considering arguments.
+        if let Some(_name) = self.confusable_method_name(
+            err,
+            callee_ty.peel_refs(),
+            call_name,
+            Some(input_types.clone()),
+        ) {
+            return;
+        }
+        // Look for method names with short levenshtein distance, considering arguments.
+        if let Some((assoc, fn_sig)) = self.similar_assoc(call_name)
+            && fn_sig.inputs()[1..]
+                .iter()
+                .zip(input_types.iter())
+                .all(|(expected, found)| self.may_coerce(*expected, *found))
+            && fn_sig.inputs()[1..].len() == input_types.len()
+        {
+            let assoc_name = assoc.name();
+            err.span_suggestion_verbose(
+                call_name.span,
+                format!("you might have meant to use `{}`", assoc_name),
+                assoc_name,
+                Applicability::MaybeIncorrect,
+            );
+            return;
         }
     }
 
-    /// Returns the parameters of a function, with their generic parameters if those are the full
-    /// type of that parameter.
-    ///
-    /// Returns `None` if the body is not a named function (e.g. a closure).
-    fn get_hir_param_info(
+    /// A "softer" version of the `demand_compatible`, which checks types without persisting them,
+    /// and treats error types differently
+    /// This will allow us to "probe" for other argument orders that would likely have been correct
+    fn check_compatible(
         &self,
-        def_id: DefId,
-        is_method: bool,
-    ) -> Option<(IndexVec<ExpectedIdx, (Option<GenericIdx>, FnParam<'_>)>, &hir::Generics<'_>)>
-    {
-        let (sig, generics, body_id, params) = match self.tcx.hir_get_if_local(def_id)? {
-            hir::Node::TraitItem(&hir::TraitItem {
-                generics,
-                kind: hir::TraitItemKind::Fn(sig, trait_fn),
-                ..
-            }) => match trait_fn {
-                hir::TraitFn::Required(params) => (sig, generics, None, Some(params)),
-                hir::TraitFn::Provided(body) => (sig, generics, Some(body), None),
-            },
-            hir::Node::ImplItem(&hir::ImplItem {
-                generics,
-                kind: hir::ImplItemKind::Fn(sig, body),
-                ..
-            })
-            | hir::Node::Item(&hir::Item {
-                kind: hir::ItemKind::Fn { sig, generics, body, .. },
-                ..
-            }) => (sig, generics, Some(body), None),
-            hir::Node::ForeignItem(&hir::ForeignItem {
-                kind: hir::ForeignItemKind::Fn(sig, params, generics),
-                ..
-            }) => (sig, generics, None, Some(params)),
-            _ => return None,
-        };
+        provided_idx: ProvidedIdx,
+        expected_idx: ExpectedIdx,
+    ) -> Compatibility<'tcx> {
+        if provided_idx.as_usize() == expected_idx.as_usize() {
+            return self.compatibility_diagonal[provided_idx].clone();
+        }
 
-        // Make sure to remove both the receiver and variadic argument. Both are removed
-        // when matching parameter types.
-        let fn_inputs = sig.decl.inputs.get(is_method as usize..)?.iter().map(|param| {
-            if let hir::TyKind::Path(QPath::Resolved(
-                _,
-                &hir::Path { res: Res::Def(_, res_def_id), .. },
-            )) = param.kind
-            {
-                generics
-                    .params
-                    .iter()
-                    .position(|param| param.def_id.to_def_id() == res_def_id)
-                    .map(GenericIdx::from_usize)
-            } else {
-                None
-            }
+        let (formal_input_ty, expected_input_ty) = self.formal_and_expected_inputs[expected_idx];
+        // If either is an error type, we defy the usual convention and consider them to *not* be
+        // coercible. This prevents our error message heuristic from trying to pass errors into
+        // every argument.
+        if (formal_input_ty, expected_input_ty).references_error() {
+            return Compatibility::Incompatible(None);
+        }
+
+        let (arg_ty, arg_span) = self.provided_arg_tys[provided_idx];
+
+        let expectation = Expectation::rvalue_hint(self.fn_ctxt, expected_input_ty);
+        let coerced_ty = expectation.only_has_type(self.fn_ctxt).unwrap_or(formal_input_ty);
+        let can_coerce = self.may_coerce(arg_ty, coerced_ty);
+        if !can_coerce {
+            return Compatibility::Incompatible(Some(ty::error::TypeError::Sorts(
+                ty::error::ExpectedFound::new(coerced_ty, arg_ty),
+            )));
+        }
+
+        // Using probe here, since we don't want this subtyping to affect inference.
+        let subtyping_error = self.probe(|_| {
+            self.at(&self.misc(arg_span), self.param_env)
+                .sup(DefineOpaqueTypes::Yes, formal_input_ty, coerced_ty)
+                .err()
         });
-        match (body_id, params) {
-            (Some(_), Some(_)) | (None, None) => unreachable!(),
-            (Some(body), None) => {
-                let params = self.tcx.hir_body(body).params;
-                let params =
-                    params.get(is_method as usize..params.len() - sig.decl.c_variadic as usize)?;
-                debug_assert_eq!(params.len(), fn_inputs.len());
-                Some((
-                    fn_inputs.zip(params.iter().map(|param| FnParam::Param(param))).collect(),
-                    generics,
-                ))
-            }
-            (None, Some(params)) => {
-                let params =
-                    params.get(is_method as usize..params.len() - sig.decl.c_variadic as usize)?;
-                debug_assert_eq!(params.len(), fn_inputs.len());
-                Some((
-                    fn_inputs.zip(params.iter().map(|&ident| FnParam::Ident(ident))).collect(),
-                    generics,
-                ))
-            }
+
+        // Same as above: if either the coerce type or the checked type is an error type,
+        // consider them *not* compatible.
+        let references_error = (coerced_ty, arg_ty).references_error();
+        match (references_error, subtyping_error) {
+            (false, None) => Compatibility::Compatible,
+            (_, subtyping_error) => Compatibility::Incompatible(subtyping_error),
         }
     }
+
+    fn remove_idx_is_perfect(&self, idx: usize) -> bool {
+        let removed_arg_tys = self
+            .provided_arg_tys
+            .iter()
+            .enumerate()
+            .filter_map(|(j, arg)| if idx == j { None } else { Some(arg) })
+            .collect::<IndexVec<ProvidedIdx, _>>();
+        std::iter::zip(self.formal_and_expected_inputs.iter(), removed_arg_tys.iter()).all(
+            |((expected_ty, _), (provided_ty, _))| {
+                !provided_ty.references_error() && self.may_coerce(*provided_ty, *expected_ty)
+            },
+        )
+    }
 }
 
-struct FindClosureArg<'tcx> {
-    tcx: TyCtxt<'tcx>,
-    calls: Vec<(&'tcx hir::Expr<'tcx>, &'tcx [hir::Expr<'tcx>])>,
+struct ArgsCtxt<'a, 'b, 'tcx> {
+    call_ctxt: CallCtxt<'a, 'b, 'tcx>,
+    call_metadata: CallMetadata,
+    args_span: Span,
 }
 
-impl<'tcx> Visitor<'tcx> for FindClosureArg<'tcx> {
-    type NestedFilter = rustc_middle::hir::nested_filter::All;
+impl<'a, 'b, 'tcx> Deref for ArgsCtxt<'a, 'b, 'tcx> {
+    type Target = CallCtxt<'a, 'b, 'tcx>;
 
-    fn maybe_tcx(&mut self) -> Self::MaybeTyCtxt {
-        self.tcx
+    fn deref(&self) -> &Self::Target {
+        &self.call_ctxt
     }
+}
 
-    fn visit_expr(&mut self, ex: &'tcx hir::Expr<'tcx>) {
-        if let hir::ExprKind::Call(rcvr, args) = ex.kind {
-            self.calls.push((rcvr, args));
+impl<'a, 'b, 'tcx> ArgsCtxt<'a, 'b, 'tcx> {
+    fn new(
+        arg: &'a FnCtxt<'b, 'tcx>,
+        compatibility_diagonal: IndexVec<ProvidedIdx, Compatibility<'tcx>>,
+        formal_and_expected_inputs: IndexVec<ExpectedIdx, (Ty<'tcx>, Ty<'tcx>)>,
+        provided_args: IndexVec<ProvidedIdx, &'tcx Expr<'tcx>>,
+        c_variadic: bool,
+        err_code: ErrCode,
+        fn_def_id: Option<DefId>,
+        call_span: Span,
+        call_expr: &'tcx Expr<'tcx>,
+        tuple_arguments: TupleArgumentsFlag,
+    ) -> Self {
+        let call_ctxt: CallCtxt<'_, '_, '_> = CallCtxt::new(
+            arg,
+            compatibility_diagonal,
+            formal_and_expected_inputs,
+            provided_args,
+            c_variadic,
+            err_code,
+            fn_def_id,
+            call_span,
+            call_expr,
+            tuple_arguments,
+        );
+
+        let call_metadata = call_ctxt.call_metadata();
+        let args_span = call_metadata
+            .error_span
+            .trim_start(call_metadata.full_call_span)
+            .unwrap_or(call_metadata.error_span);
+
+        ArgsCtxt { args_span, call_metadata, call_ctxt }
+    }
+
+    /// Get the argument span in the context of the call span so that
+    /// suggestions and labels are (more) correct when an arg is a
+    /// macro invocation.
+    fn normalize_span(&self, span: Span) -> Span {
+        let normalized_span =
+            span.find_ancestor_inside_same_ctxt(self.call_metadata.error_span).unwrap_or(span);
+        // Sometimes macros mess up the spans, so do not normalize the
+        // arg span to equal the error span, because that's less useful
+        // than pointing out the arg expr in the wrong context.
+        if normalized_span.source_equal(self.call_metadata.error_span) {
+            span
+        } else {
+            normalized_span
         }
-        hir::intravisit::walk_expr(self, ex);
+    }
+
+    /// Computes the provided types and spans.
+    fn provided_arg_tys(&self) -> IndexVec<ProvidedIdx, (Ty<'tcx>, Span)> {
+        self.call_ctxt
+            .provided_args
+            .iter()
+            .map(|expr| {
+                let ty = self
+                    .call_ctxt
+                    .fn_ctxt
+                    .typeck_results
+                    .borrow()
+                    .expr_ty_adjusted_opt(*expr)
+                    .unwrap_or_else(|| Ty::new_misc_error(self.call_ctxt.fn_ctxt.tcx));
+                (
+                    self.call_ctxt.fn_ctxt.resolve_vars_if_possible(ty),
+                    self.normalize_span(expr.span),
+                )
+            })
+            .collect()
+    }
+
+    // Obtain another method on `Self` that have similar name.
+    fn similar_assoc(&self, call_name: Ident) -> Option<(ty::AssocItem, ty::FnSig<'tcx>)> {
+        if let Some(callee_ty) = self.call_ctxt.callee_ty
+            && let Ok(Some(assoc)) = self.call_ctxt.fn_ctxt.probe_op(
+                call_name.span,
+                MethodCall,
+                Some(call_name),
+                None,
+                IsSuggestion(true),
+                callee_ty.peel_refs(),
+                self.call_ctxt.callee_expr.unwrap().hir_id,
+                TraitsInScope,
+                |mut ctxt| ctxt.probe_for_similar_candidate(),
+            )
+            && assoc.is_method()
+        {
+            let args =
+                self.call_ctxt.fn_ctxt.infcx.fresh_args_for_item(call_name.span, assoc.def_id);
+            let fn_sig = self
+                .call_ctxt
+                .fn_ctxt
+                .tcx
+                .fn_sig(assoc.def_id)
+                .instantiate(self.call_ctxt.fn_ctxt.tcx, args);
+
+            self.call_ctxt.fn_ctxt.instantiate_binder_with_fresh_vars(
+                call_name.span,
+                BoundRegionConversionTime::FnCall,
+                fn_sig,
+            );
+        }
+        None
+    }
+
+    fn call_is_in_macro(&self) -> bool {
+        self.call_metadata.full_call_span.in_external_macro(self.sess().source_map())
     }
 }
 
-#[derive(Clone, Copy)]
-enum FnParam<'hir> {
-    Param(&'hir hir::Param<'hir>),
-    Ident(Option<Ident>),
+struct CallMetadata {
+    error_span: Span,
+    call_ident: Option<Ident>,
+    full_call_span: Span,
+    call_name: &'static str,
+    is_method: bool,
 }
 
-impl FnParam<'_> {
-    fn span(&self) -> Span {
-        match self {
-            Self::Param(param) => param.span,
-            Self::Ident(ident) => {
-                if let Some(ident) = ident {
-                    ident.span
+struct CallCtxt<'a, 'b, 'tcx> {
+    fn_ctxt: &'a FnCtxt<'b, 'tcx>,
+    compatibility_diagonal: IndexVec<ProvidedIdx, Compatibility<'tcx>>,
+    formal_and_expected_inputs: IndexVec<ExpectedIdx, (Ty<'tcx>, Ty<'tcx>)>,
+    provided_args: IndexVec<ProvidedIdx, &'tcx hir::Expr<'tcx>>,
+    c_variadic: bool,
+    err_code: ErrCode,
+    fn_def_id: Option<DefId>,
+    call_span: Span,
+    call_expr: &'tcx hir::Expr<'tcx>,
+    tuple_arguments: TupleArgumentsFlag,
+    callee_expr: Option<&'tcx Expr<'tcx>>,
+    callee_ty: Option<Ty<'tcx>>,
+}
+
+impl<'a, 'b, 'tcx> Deref for CallCtxt<'a, 'b, 'tcx> {
+    type Target = &'a FnCtxt<'b, 'tcx>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.fn_ctxt
+    }
+}
+
+impl<'a, 'b, 'tcx> CallCtxt<'a, 'b, 'tcx> {
+    fn new(
+        fn_ctxt: &'a FnCtxt<'b, 'tcx>,
+        compatibility_diagonal: IndexVec<ProvidedIdx, Compatibility<'tcx>>,
+        formal_and_expected_inputs: IndexVec<ExpectedIdx, (Ty<'tcx>, Ty<'tcx>)>,
+        provided_args: IndexVec<ProvidedIdx, &'tcx hir::Expr<'tcx>>,
+        c_variadic: bool,
+        err_code: ErrCode,
+        fn_def_id: Option<DefId>,
+        call_span: Span,
+        call_expr: &'tcx hir::Expr<'tcx>,
+        tuple_arguments: TupleArgumentsFlag,
+    ) -> CallCtxt<'a, 'b, 'tcx> {
+        let callee_expr = match &call_expr.peel_blocks().kind {
+            hir::ExprKind::Call(callee, _) => Some(*callee),
+            hir::ExprKind::MethodCall(_, receiver, ..) => {
+                if let Some((DefKind::AssocFn, def_id)) =
+                    fn_ctxt.typeck_results.borrow().type_dependent_def(call_expr.hir_id)
+                    && let Some(assoc) = fn_ctxt.tcx.opt_associated_item(def_id)
+                    && assoc.is_method()
+                {
+                    Some(*receiver)
                 } else {
-                    DUMMY_SP
+                    None
                 }
             }
+            _ => None,
+        };
+
+        let callee_ty = callee_expr.and_then(|callee_expr| {
+            fn_ctxt.typeck_results.borrow().expr_ty_adjusted_opt(callee_expr)
+        });
+
+        CallCtxt {
+            fn_ctxt,
+            compatibility_diagonal,
+            formal_and_expected_inputs,
+            provided_args,
+            c_variadic,
+            err_code,
+            fn_def_id,
+            call_span,
+            call_expr,
+            tuple_arguments,
+            callee_expr,
+            callee_ty,
         }
     }
 
-    fn display(&self, idx: usize) -> impl '_ + fmt::Display {
-        struct D<'a>(FnParam<'a>, usize);
-        impl fmt::Display for D<'_> {
-            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                // A "unique" param name is one that (a) exists, and (b) is guaranteed to be unique
-                // among the parameters, i.e. `_` does not count.
-                let unique_name = match self.0 {
-                    FnParam::Param(param)
-                        if let hir::PatKind::Binding(_, _, ident, _) = param.pat.kind =>
-                    {
-                        Some(ident.name)
+    fn call_metadata(&self) -> CallMetadata {
+        match &self.call_expr.kind {
+            hir::ExprKind::Call(
+                hir::Expr { hir_id, span, kind: hir::ExprKind::Path(qpath), .. },
+                _,
+            ) => {
+                if let Res::Def(DefKind::Ctor(of, _), _) =
+                    self.typeck_results.borrow().qpath_res(qpath, *hir_id)
+                {
+                    let name = match of {
+                        CtorOf::Struct => "struct",
+                        CtorOf::Variant => "enum variant",
+                    };
+                    CallMetadata {
+                        error_span: self.call_span,
+                        call_ident: None,
+                        full_call_span: *span,
+                        call_name: name,
+                        is_method: false,
                     }
-                    FnParam::Ident(ident)
-                        if let Some(ident) = ident
-                            && ident.name != kw::Underscore =>
-                    {
-                        Some(ident.name)
+                } else {
+                    CallMetadata {
+                        error_span: self.call_span,
+                        call_ident: None,
+                        full_call_span: *span,
+                        call_name: "function",
+                        is_method: false,
                     }
-                    _ => None,
-                };
-                if let Some(unique_name) = unique_name {
-                    write!(f, "`{unique_name}`")
+                }
+            }
+            hir::ExprKind::Call(hir::Expr { span, .. }, _) => CallMetadata {
+                error_span: self.call_span,
+                call_ident: None,
+                full_call_span: *span,
+                call_name: "function",
+                is_method: false,
+            },
+            hir::ExprKind::MethodCall(path_segment, _, _, span) => {
+                let ident_span = path_segment.ident.span;
+                let ident_span = if let Some(args) = path_segment.args {
+                    ident_span.with_hi(args.span_ext.hi())
                 } else {
-                    write!(f, "parameter #{}", self.1 + 1)
+                    ident_span
+                };
+                CallMetadata {
+                    error_span: *span,
+                    call_ident: Some(path_segment.ident),
+                    full_call_span: ident_span,
+                    call_name: "method",
+                    is_method: true,
                 }
             }
+            k => span_bug!(self.call_span, "checking argument types on a non-call: `{:?}`", k),
+        }
+    }
+
+    fn mk_trace(
+        &self,
+        span: Span,
+        (formal_ty, expected_ty): (Ty<'tcx>, Ty<'tcx>),
+        provided_ty: Ty<'tcx>,
+    ) -> TypeTrace<'tcx> {
+        let mismatched_ty = if expected_ty == provided_ty {
+            // If expected == provided, then we must have failed to sup
+            // the formal type. Avoid printing out "expected Ty, found Ty"
+            // in that case.
+            formal_ty
+        } else {
+            expected_ty
+        };
+        TypeTrace::types(&self.misc(span), mismatched_ty, provided_ty)
+    }
+
+    fn ty_to_snippet(&self, ty: Ty<'tcx>, expected_idx: ExpectedIdx) -> String {
+        if ty.is_unit() {
+            "()".to_string()
+        } else if ty.is_suggestable(self.tcx, false) {
+            format!("/* {ty} */")
+        } else if let Some(fn_def_id) = self.fn_def_id
+            && self.tcx.def_kind(fn_def_id).is_fn_like()
+            && let self_implicit =
+                matches!(self.call_expr.kind, hir::ExprKind::MethodCall(..)) as usize
+            && let Some(Some(arg)) =
+                self.tcx.fn_arg_idents(fn_def_id).get(expected_idx.as_usize() + self_implicit)
+            && arg.name != kw::SelfLower
+        {
+            format!("/* {} */", arg.name)
+        } else {
+            "/* value */".to_string()
         }
-        D(*self, idx)
     }
+
+    fn first_incompatible_error(&self) -> Option<(ProvidedIdx, TypeError<'tcx>)> {
+        self.compatibility_diagonal.iter_enumerated().find_map(|(i, c)| {
+            if let Compatibility::Incompatible(Some(terr)) = c { Some((i, *terr)) } else { None }
+        })
+    }
+}
+
+enum SuggestionText {
+    None,
+    Provide(bool),
+    Remove(bool),
+    Swap,
+    Reorder,
+    DidYouMean,
 }

From 1991779bd4a0a8d8905b6644b06aa317dde353ac Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Mon, 15 Sep 2025 15:31:56 +0000
Subject: [PATCH 0964/1889] Make llvm_enzyme a regular cargo feature

This makes it clearer that it is set by the build system rather than by
the rustc that compiles the current rustc. It also avoids bootstrap
needing to pass --check-cfg llvm_enzyme to rustc.
---
 compiler/rustc/Cargo.toml                          | 1 +
 compiler/rustc_builtin_macros/Cargo.toml           | 5 +++++
 compiler/rustc_builtin_macros/src/autodiff.rs      | 3 ++-
 compiler/rustc_codegen_llvm/Cargo.toml             | 1 +
 compiler/rustc_codegen_llvm/src/back/lto.rs        | 2 +-
 compiler/rustc_codegen_llvm/src/back/write.rs      | 6 ++++--
 compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs | 8 ++++----
 compiler/rustc_driver_impl/Cargo.toml              | 1 +
 compiler/rustc_interface/Cargo.toml                | 1 +
 src/bootstrap/src/core/build_steps/compile.rs      | 4 ----
 src/bootstrap/src/lib.rs                           | 6 +++---
 11 files changed, 23 insertions(+), 15 deletions(-)

diff --git a/compiler/rustc/Cargo.toml b/compiler/rustc/Cargo.toml
index e3214d1ab9cec..9ef8fa75062a2 100644
--- a/compiler/rustc/Cargo.toml
+++ b/compiler/rustc/Cargo.toml
@@ -30,6 +30,7 @@ features = ['unprefixed_malloc_on_supported_platforms']
 check_only = ['rustc_driver_impl/check_only']
 jemalloc = ['dep:tikv-jemalloc-sys']
 llvm = ['rustc_driver_impl/llvm']
+llvm_enzyme = ['rustc_driver_impl/llvm_enzyme']
 max_level_info = ['rustc_driver_impl/max_level_info']
 rustc_randomized_layouts = ['rustc_driver_impl/rustc_randomized_layouts']
 # tidy-alphabetical-end
diff --git a/compiler/rustc_builtin_macros/Cargo.toml b/compiler/rustc_builtin_macros/Cargo.toml
index e56b9e641a10b..ce9a3ce3f248e 100644
--- a/compiler/rustc_builtin_macros/Cargo.toml
+++ b/compiler/rustc_builtin_macros/Cargo.toml
@@ -33,3 +33,8 @@ smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
 thin-vec = "0.2.12"
 tracing = "0.1"
 # tidy-alphabetical-end
+
+[features]
+# tidy-alphabetical-start
+llvm_enzyme = []
+# tidy-alphabetical-end
diff --git a/compiler/rustc_builtin_macros/src/autodiff.rs b/compiler/rustc_builtin_macros/src/autodiff.rs
index 48d0795af5ee2..f4a923797e2d3 100644
--- a/compiler/rustc_builtin_macros/src/autodiff.rs
+++ b/compiler/rustc_builtin_macros/src/autodiff.rs
@@ -209,7 +209,8 @@ mod llvm_enzyme {
         mut item: Annotatable,
         mode: DiffMode,
     ) -> Vec<Annotatable> {
-        if cfg!(not(llvm_enzyme)) {
+        // FIXME(bjorn3) maybe have the backend directly tell if autodiff is supported?
+        if cfg!(not(feature = "llvm_enzyme")) {
             ecx.sess.dcx().emit_err(errors::AutoDiffSupportNotBuild { span: meta_item.span });
             return vec![item];
         }
diff --git a/compiler/rustc_codegen_llvm/Cargo.toml b/compiler/rustc_codegen_llvm/Cargo.toml
index 2d11628250cd2..67bd1e59bb0c2 100644
--- a/compiler/rustc_codegen_llvm/Cargo.toml
+++ b/compiler/rustc_codegen_llvm/Cargo.toml
@@ -46,5 +46,6 @@ tracing = "0.1"
 [features]
 # tidy-alphabetical-start
 check_only = ["rustc_llvm/check_only"]
+llvm_enzyme = []
 # tidy-alphabetical-end
 
diff --git a/compiler/rustc_codegen_llvm/src/back/lto.rs b/compiler/rustc_codegen_llvm/src/back/lto.rs
index f571716d9dd9f..78107d95e5a70 100644
--- a/compiler/rustc_codegen_llvm/src/back/lto.rs
+++ b/compiler/rustc_codegen_llvm/src/back/lto.rs
@@ -617,7 +617,7 @@ pub(crate) fn run_pass_manager(
         crate::builder::gpu_offload::handle_gpu_code(cgcx, &cx);
     }
 
-    if cfg!(llvm_enzyme) && enable_ad && !thin {
+    if cfg!(feature = "llvm_enzyme") && enable_ad && !thin {
         let opt_stage = llvm::OptStage::FatLTO;
         let stage = write::AutodiffStage::PostAD;
         if !config.autodiff.contains(&config::AutoDiff::NoPostopt) {
diff --git a/compiler/rustc_codegen_llvm/src/back/write.rs b/compiler/rustc_codegen_llvm/src/back/write.rs
index 423f0da48781a..bda81fbd19e82 100644
--- a/compiler/rustc_codegen_llvm/src/back/write.rs
+++ b/compiler/rustc_codegen_llvm/src/back/write.rs
@@ -574,7 +574,8 @@ pub(crate) unsafe fn llvm_optimize(
     // FIXME(ZuseZ4): In a future update we could figure out how to only optimize individual functions getting
     // differentiated.
 
-    let consider_ad = cfg!(llvm_enzyme) && config.autodiff.contains(&config::AutoDiff::Enable);
+    let consider_ad =
+        cfg!(feature = "llvm_enzyme") && config.autodiff.contains(&config::AutoDiff::Enable);
     let run_enzyme = autodiff_stage == AutodiffStage::DuringAD;
     let print_before_enzyme = config.autodiff.contains(&config::AutoDiff::PrintModBefore);
     let print_after_enzyme = config.autodiff.contains(&config::AutoDiff::PrintModAfter);
@@ -740,7 +741,8 @@ pub(crate) fn optimize(
 
         // If we know that we will later run AD, then we disable vectorization and loop unrolling.
         // Otherwise we pretend AD is already done and run the normal opt pipeline (=PostAD).
-        let consider_ad = cfg!(llvm_enzyme) && config.autodiff.contains(&config::AutoDiff::Enable);
+        let consider_ad =
+            cfg!(feature = "llvm_enzyme") && config.autodiff.contains(&config::AutoDiff::Enable);
         let autodiff_stage = if consider_ad { AutodiffStage::PreAD } else { AutodiffStage::PostAD };
         // The embedded bitcode is used to run LTO/ThinLTO.
         // The bitcode obtained during the `codegen` phase is no longer suitable for performing LTO.
diff --git a/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
index 56d756e52cce1..695435eb6daa7 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
@@ -59,10 +59,10 @@ pub(crate) enum LLVMRustVerifierFailureAction {
     LLVMReturnStatusAction = 2,
 }
 
-#[cfg(llvm_enzyme)]
+#[cfg(feature = "llvm_enzyme")]
 pub(crate) use self::Enzyme_AD::*;
 
-#[cfg(llvm_enzyme)]
+#[cfg(feature = "llvm_enzyme")]
 pub(crate) mod Enzyme_AD {
     use std::ffi::{CString, c_char};
 
@@ -134,10 +134,10 @@ pub(crate) mod Enzyme_AD {
     }
 }
 
-#[cfg(not(llvm_enzyme))]
+#[cfg(not(feature = "llvm_enzyme"))]
 pub(crate) use self::Fallback_AD::*;
 
-#[cfg(not(llvm_enzyme))]
+#[cfg(not(feature = "llvm_enzyme"))]
 pub(crate) mod Fallback_AD {
     #![allow(unused_variables)]
 
diff --git a/compiler/rustc_driver_impl/Cargo.toml b/compiler/rustc_driver_impl/Cargo.toml
index ae1dbd2cf5148..46efa50cff364 100644
--- a/compiler/rustc_driver_impl/Cargo.toml
+++ b/compiler/rustc_driver_impl/Cargo.toml
@@ -74,6 +74,7 @@ ctrlc = "3.4.4"
 # tidy-alphabetical-start
 check_only = ['rustc_interface/check_only']
 llvm = ['rustc_interface/llvm']
+llvm_enzyme = ['rustc_interface/llvm_enzyme']
 max_level_info = ['rustc_log/max_level_info']
 rustc_randomized_layouts = [
     'rustc_index/rustc_randomized_layouts',
diff --git a/compiler/rustc_interface/Cargo.toml b/compiler/rustc_interface/Cargo.toml
index 473ac5e0cea4a..f0836c47740a2 100644
--- a/compiler/rustc_interface/Cargo.toml
+++ b/compiler/rustc_interface/Cargo.toml
@@ -58,4 +58,5 @@ rustc_abi = { path = "../rustc_abi" }
 # tidy-alphabetical-start
 check_only = ['rustc_codegen_llvm?/check_only']
 llvm = ['dep:rustc_codegen_llvm']
+llvm_enzyme = ['rustc_builtin_macros/llvm_enzyme', 'rustc_codegen_llvm/llvm_enzyme']
 # tidy-alphabetical-end
diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index 1458b0beefa85..14104d7d1d783 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -1357,10 +1357,6 @@ pub fn rustc_cargo_env(builder: &Builder<'_>, cargo: &mut Cargo, target: TargetS
         cargo.env("RUSTC_VERIFY_LLVM_IR", "1");
     }
 
-    if builder.config.llvm_enzyme {
-        cargo.rustflag("--cfg=llvm_enzyme");
-    }
-
     // These conditionals represent a tension between three forces:
     // - For non-check builds, we need to define some LLVM-related environment
     //   variables, requiring LLVM to have been built.
diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs
index a2aeed20948e5..e953fe2945e48 100644
--- a/src/bootstrap/src/lib.rs
+++ b/src/bootstrap/src/lib.rs
@@ -87,9 +87,6 @@ const EXTRA_CHECK_CFGS: &[(Option<Mode>, &str, Option<&[&'static str]>)] = &[
     (Some(Mode::Codegen), "bootstrap", None),
     (Some(Mode::ToolRustcPrivate), "bootstrap", None),
     (Some(Mode::ToolStd), "bootstrap", None),
-    (Some(Mode::Rustc), "llvm_enzyme", None),
-    (Some(Mode::Codegen), "llvm_enzyme", None),
-    (Some(Mode::ToolRustcPrivate), "llvm_enzyme", None),
     (Some(Mode::ToolRustcPrivate), "rust_analyzer", None),
     (Some(Mode::ToolStd), "rust_analyzer", None),
     // Any library specific cfgs like `target_os`, `target_arch` should be put in
@@ -869,6 +866,9 @@ impl Build {
         if (self.config.llvm_enabled(target) || kind == Kind::Check) && check("llvm") {
             features.push("llvm");
         }
+        if self.config.llvm_enzyme {
+            features.push("llvm_enzyme");
+        }
         // keep in sync with `bootstrap/compile.rs:rustc_cargo_env`
         if self.config.rust_randomize_layout && check("rustc_randomized_layouts") {
             features.push("rustc_randomized_layouts");

From 2d76bb1f23be5da37199e632ad2473f245db4a5f Mon Sep 17 00:00:00 2001
From: Nathaniel McCallum <nathaniel@mccallum.life>
Date: Fri, 12 Sep 2025 18:30:02 -0400
Subject: [PATCH 0965/1889] replace some `#[const_trait]` with `const trait`

---
 library/core/src/cmp.rs | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/library/core/src/cmp.rs b/library/core/src/cmp.rs
index 94536f25b4197..95896ab144187 100644
--- a/library/core/src/cmp.rs
+++ b/library/core/src/cmp.rs
@@ -334,9 +334,8 @@ pub macro PartialEq($item:item) {
 #[doc(alias = "!=")]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_diagnostic_item = "Eq"]
-#[const_trait]
 #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
-pub trait Eq: [const] PartialEq<Self> + PointeeSized {
+pub const trait Eq: [const] PartialEq<Self> + PointeeSized {
     // this method is used solely by `impl Eq or #[derive(Eq)]` to assert that every component of a
     // type implements `Eq` itself. The current deriving infrastructure means doing this assertion
     // without using a method on this trait is nearly impossible.
@@ -966,9 +965,8 @@ impl<T: Clone> Clone for Reverse<T> {
 #[doc(alias = ">=")]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_diagnostic_item = "Ord"]
-#[const_trait]
 #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
-pub trait Ord: [const] Eq + [const] PartialOrd<Self> + PointeeSized {
+pub const trait Ord: [const] Eq + [const] PartialOrd<Self> + PointeeSized {
     /// This method returns an [`Ordering`] between `self` and `other`.
     ///
     /// By convention, `self.cmp(&other)` returns the ordering matching the expression
@@ -1352,9 +1350,8 @@ pub macro Ord($item:item) {
 )]
 #[rustc_diagnostic_item = "PartialOrd"]
 #[allow(multiple_supertrait_upcastable)] // FIXME(sized_hierarchy): remove this
-#[const_trait]
 #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
-pub trait PartialOrd<Rhs: PointeeSized = Self>: PartialEq<Rhs> + PointeeSized {
+pub const trait PartialOrd<Rhs: PointeeSized = Self>: PartialEq<Rhs> + PointeeSized {
     /// This method returns an ordering between `self` and `other` values if one exists.
     ///
     /// # Examples

From 4e286122d9a9dfcc1ae33c3959a3e8fd325f324b Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Mon, 15 Sep 2025 05:21:30 +0300
Subject: [PATCH 0966/1889] Port a bunch of stuff from rustc and fix a bunch of
 type mismatches/diagnostics

This started from porting coercion, but ended with porting much more.
---
 .../crates/hir-def/src/signatures.rs          |   19 +
 .../crates/hir-ty/src/autoderef.rs            |  373 ++-
 .../crates/hir-ty/src/builder.rs              |   47 +-
 .../crates/hir-ty/src/chalk_ext.rs            |    2 +-
 .../rust-analyzer/crates/hir-ty/src/db.rs     |    8 +
 .../hir-ty/src/diagnostics/unsafe_check.rs    |    5 +-
 .../crates/hir-ty/src/display.rs              |   45 +-
 .../rust-analyzer/crates/hir-ty/src/drop.rs   |    2 +-
 .../rust-analyzer/crates/hir-ty/src/infer.rs  |  194 +-
 .../crates/hir-ty/src/infer/autoderef.rs      |   54 +
 .../crates/hir-ty/src/infer/cast.rs           |  156 +-
 .../crates/hir-ty/src/infer/closure.rs        | 2287 +++++------------
 .../hir-ty/src/infer/closure/analysis.rs      | 1298 ++++++++++
 .../crates/hir-ty/src/infer/coerce.rs         | 1992 +++++++++-----
 .../crates/hir-ty/src/infer/expr.rs           |  675 +++--
 .../crates/hir-ty/src/infer/pat.rs            |   31 +-
 .../crates/hir-ty/src/infer/unify.rs          |  612 +++--
 .../rust-analyzer/crates/hir-ty/src/layout.rs |    7 +-
 .../rust-analyzer/crates/hir-ty/src/lib.rs    |    6 +-
 .../crates/hir-ty/src/lower_nextsolver.rs     |  106 +
 .../crates/hir-ty/src/method_resolution.rs    |   47 +-
 .../crates/hir-ty/src/mir/borrowck.rs         |    9 +-
 .../crates/hir-ty/src/mir/eval.rs             |    6 +-
 .../crates/hir-ty/src/mir/eval/shim.rs        |   15 +-
 .../crates/hir-ty/src/mir/eval/tests.rs       |  144 +-
 .../crates/hir-ty/src/mir/lower.rs            |    2 +-
 .../crates/hir-ty/src/next_solver.rs          |    8 +-
 .../crates/hir-ty/src/next_solver/consts.rs   |   47 +-
 .../crates/hir-ty/src/next_solver/def_id.rs   |   60 +-
 .../crates/hir-ty/src/next_solver/fulfill.rs  |  151 +-
 .../hir-ty/src/next_solver/fulfill/errors.rs  | 1332 ++++++++++
 .../hir-ty/src/next_solver/generic_arg.rs     |   45 +-
 .../crates/hir-ty/src/next_solver/infer/at.rs |   32 +-
 .../hir-ty/src/next_solver/infer/mod.rs       |    6 +
 .../infer/region_constraints/mod.rs           |   53 +-
 .../next_solver/infer/relate/generalize.rs    |    2 +-
 .../src/next_solver/infer/relate/lattice.rs   |  269 ++
 .../src/next_solver/infer/relate/mod.rs       |    1 +
 .../hir-ty/src/next_solver/infer/select.rs    |  334 +++
 .../src/next_solver/infer/snapshot/fudge.rs   |  263 ++
 .../src/next_solver/infer/snapshot/mod.rs     |    1 +
 .../next_solver/infer/snapshot/undo_log.rs    |    4 +
 .../hir-ty/src/next_solver/infer/traits.rs    |  108 +-
 .../src/next_solver/infer/type_variable.rs    |   15 +-
 .../crates/hir-ty/src/next_solver/inspect.rs  |  501 ++++
 .../crates/hir-ty/src/next_solver/interner.rs |   88 +-
 .../crates/hir-ty/src/next_solver/mapping.rs  |   37 +
 .../solve_normalize.rs => normalize.rs}       |   66 +-
 .../hir-ty/src/next_solver/obligation_ctxt.rs |  203 ++
 .../hir-ty/src/next_solver/predicate.rs       |   52 +-
 .../crates/hir-ty/src/next_solver/project.rs  |    3 -
 .../crates/hir-ty/src/next_solver/solver.rs   |   16 +-
 .../src/next_solver/structural_normalize.rs   |   57 +
 .../crates/hir-ty/src/next_solver/ty.rs       |   87 +-
 .../crates/hir-ty/src/next_solver/util.rs     |    6 +-
 .../crates/hir-ty/src/target_feature.rs       |    2 +-
 .../crates/hir-ty/src/tests/coercion.rs       |   42 +-
 .../crates/hir-ty/src/tests/diagnostics.rs    |    1 -
 .../crates/hir-ty/src/tests/incremental.rs    |    8 +-
 .../crates/hir-ty/src/tests/macros.rs         |   34 +-
 .../hir-ty/src/tests/method_resolution.rs     |   63 +-
 .../crates/hir-ty/src/tests/never_type.rs     |   24 +-
 .../crates/hir-ty/src/tests/opaque_types.rs   |    1 +
 .../crates/hir-ty/src/tests/patterns.rs       |   38 +-
 .../crates/hir-ty/src/tests/regression.rs     |  242 +-
 .../hir-ty/src/tests/regression/new_solver.rs |  111 +
 .../crates/hir-ty/src/tests/simple.rs         |   98 +-
 .../crates/hir-ty/src/tests/traits.rs         |  357 +--
 .../rust-analyzer/crates/hir-ty/src/traits.rs |    5 -
 .../rust-analyzer/crates/hir-ty/src/utils.rs  |  108 +-
 .../crates/hir-ty/src/variance.rs             |   57 +-
 src/tools/rust-analyzer/crates/hir/src/lib.rs |    8 +-
 .../src/handlers/convert_closure_to_fn.rs     |    7 +-
 .../src/handlers/extract_function.rs          |    2 +-
 .../ide-completion/src/completions/dot.rs     |    4 +-
 .../ide-completion/src/tests/expression.rs    |    3 +-
 .../src/handlers/typed_hole.rs                |    2 +-
 .../src/handlers/unresolved_method.rs         |   24 +-
 .../crates/ide/src/hover/tests.rs             |   14 +-
 .../crates/ide/src/inlay_hints/bind_pat.rs    |   16 +-
 .../crates/intern/src/symbol/symbols.rs       |    1 +
 .../rust-analyzer/tests/slow-tests/main.rs    |    4 +-
 .../crates/test-utils/src/minicore.rs         |   28 +-
 src/tools/rust-analyzer/xtask/src/tidy.rs     |    9 +
 84 files changed, 9358 insertions(+), 3944 deletions(-)
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/infer/autoderef.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/infer/closure/analysis.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill/errors.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/relate/lattice.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/select.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/snapshot/fudge.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/inspect.rs
 rename src/tools/rust-analyzer/crates/hir-ty/src/next_solver/{project/solve_normalize.rs => normalize.rs} (87%)
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/obligation_ctxt.rs
 delete mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/project.rs
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/structural_normalize.rs

diff --git a/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs b/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
index bf72fafeae724..47638610ed734 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
@@ -489,6 +489,7 @@ bitflags! {
         const HAS_TARGET_FEATURE = 1 << 9;
         const DEPRECATED_SAFE_2024 = 1 << 10;
         const EXPLICIT_SAFE = 1 << 11;
+        const RUSTC_INTRINSIC = 1 << 12;
     }
 }
 
@@ -522,6 +523,9 @@ impl FunctionSignature {
         if attrs.by_key(sym::target_feature).exists() {
             flags.insert(FnFlags::HAS_TARGET_FEATURE);
         }
+        if attrs.by_key(sym::rustc_intrinsic).exists() {
+            flags.insert(FnFlags::RUSTC_INTRINSIC);
+        }
         let legacy_const_generics_indices = attrs.rustc_legacy_const_generics();
 
         let source = loc.source(db);
@@ -617,6 +621,21 @@ impl FunctionSignature {
     pub fn has_target_feature(&self) -> bool {
         self.flags.contains(FnFlags::HAS_TARGET_FEATURE)
     }
+
+    pub fn is_intrinsic(db: &dyn DefDatabase, id: FunctionId) -> bool {
+        let data = db.function_signature(id);
+        data.flags.contains(FnFlags::RUSTC_INTRINSIC)
+            // Keep this around for a bit until extern "rustc-intrinsic" abis are no longer used
+            || match &data.abi {
+                Some(abi) => *abi == sym::rust_dash_intrinsic,
+                None => match id.lookup(db).container {
+                    ItemContainerId::ExternBlockId(block) => {
+                        block.abi(db) == Some(sym::rust_dash_intrinsic)
+                    }
+                    _ => false,
+                },
+            }
+    }
 }
 
 bitflags! {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs b/src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs
index 82696a5c94daf..fd60ffcf24b0a 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs
@@ -3,27 +3,28 @@
 //! reference to a type with the field `bar`. This is an approximation of the
 //! logic in rustc (which lives in rustc_hir_analysis/check/autoderef.rs).
 
-use std::mem;
+use std::fmt;
 
-use chalk_ir::cast::Cast;
-use hir_def::lang_item::LangItem;
-use hir_expand::name::Name;
-use intern::sym;
+use hir_def::{TypeAliasId, lang_item::LangItem};
+use rustc_type_ir::inherent::{IntoKind, Ty as _};
+use tracing::debug;
 use triomphe::Arc;
 
+use crate::next_solver::infer::InferOk;
 use crate::{
-    Canonical, Goal, Interner, ProjectionTyExt, TraitEnvironment, Ty, TyBuilder, TyKind,
-    db::HirDatabase, infer::unify::InferenceTable, next_solver::mapping::ChalkToNextSolver,
+    TraitEnvironment,
+    db::HirDatabase,
+    infer::unify::InferenceTable,
+    next_solver::{
+        Ty, TyKind,
+        infer::traits::{ObligationCause, PredicateObligations},
+        mapping::{ChalkToNextSolver, NextSolverToChalk},
+        obligation_ctxt::ObligationCtxt,
+    },
 };
 
 const AUTODEREF_RECURSION_LIMIT: usize = 20;
 
-#[derive(Debug)]
-pub(crate) enum AutoderefKind {
-    Builtin,
-    Overloaded,
-}
-
 /// Returns types that `ty` transitively dereferences to. This function is only meant to be used
 /// outside `hir-ty`.
 ///
@@ -34,16 +35,17 @@ pub(crate) enum AutoderefKind {
 pub fn autoderef(
     db: &dyn HirDatabase,
     env: Arc<TraitEnvironment>,
-    ty: Canonical<Ty>,
-) -> impl Iterator<Item = Ty> {
+    ty: crate::Canonical<crate::Ty>,
+) -> impl Iterator<Item = crate::Ty> {
     let mut table = InferenceTable::new(db, env);
+    let interner = table.interner;
     let ty = table.instantiate_canonical(ty);
-    let mut autoderef = Autoderef::new_no_tracking(&mut table, ty, false, false);
+    let mut autoderef = Autoderef::new_no_tracking(&mut table, ty.to_nextsolver(interner));
     let mut v = Vec::new();
     while let Some((ty, _steps)) = autoderef.next() {
         // `ty` may contain unresolved inference variables. Since there's no chance they would be
         // resolved, just replace with fallback type.
-        let resolved = autoderef.table.resolve_completely(ty);
+        let resolved = autoderef.table.resolve_completely(ty.to_chalk(interner));
 
         // If the deref chain contains a cycle (e.g. `A` derefs to `B` and `B` derefs to `A`), we
         // would revisit some already visited types. Stop here to avoid duplication.
@@ -59,178 +61,267 @@ pub fn autoderef(
     v.into_iter()
 }
 
-trait TrackAutoderefSteps {
+pub(crate) trait TrackAutoderefSteps<'db>: Default + fmt::Debug {
     fn len(&self) -> usize;
-    fn push(&mut self, kind: AutoderefKind, ty: &Ty);
+    fn push(&mut self, ty: Ty<'db>, kind: AutoderefKind);
 }
 
-impl TrackAutoderefSteps for usize {
+impl<'db> TrackAutoderefSteps<'db> for usize {
     fn len(&self) -> usize {
         *self
     }
-    fn push(&mut self, _: AutoderefKind, _: &Ty) {
+    fn push(&mut self, _: Ty<'db>, _: AutoderefKind) {
         *self += 1;
     }
 }
-impl TrackAutoderefSteps for Vec<(AutoderefKind, Ty)> {
+impl<'db> TrackAutoderefSteps<'db> for Vec<(Ty<'db>, AutoderefKind)> {
     fn len(&self) -> usize {
         self.len()
     }
-    fn push(&mut self, kind: AutoderefKind, ty: &Ty) {
-        self.push((kind, ty.clone()));
+    fn push(&mut self, ty: Ty<'db>, kind: AutoderefKind) {
+        self.push((ty, kind));
     }
 }
 
-#[derive(Debug)]
-pub(crate) struct Autoderef<'table, 'db, T = Vec<(AutoderefKind, Ty)>> {
-    pub(crate) table: &'table mut InferenceTable<'db>,
-    ty: Ty,
-    at_start: bool,
-    steps: T,
-    explicit: bool,
-    use_receiver_trait: bool,
+#[derive(Copy, Clone, Debug)]
+pub(crate) enum AutoderefKind {
+    /// A true pointer type, such as `&T` and `*mut T`.
+    Builtin,
+    /// A type which must dispatch to a `Deref` implementation.
+    Overloaded,
 }
 
-impl<'table, 'db> Autoderef<'table, 'db> {
-    pub(crate) fn new(
-        table: &'table mut InferenceTable<'db>,
-        ty: Ty,
-        explicit: bool,
-        use_receiver_trait: bool,
-    ) -> Self {
-        let ty = table.structurally_resolve_type(&ty);
-        Autoderef { table, ty, at_start: true, steps: Vec::new(), explicit, use_receiver_trait }
-    }
-
-    pub(crate) fn steps(&self) -> &[(AutoderefKind, Ty)] {
-        &self.steps
-    }
+struct AutoderefSnapshot<'db, Steps> {
+    at_start: bool,
+    reached_recursion_limit: bool,
+    steps: Steps,
+    cur_ty: Ty<'db>,
+    obligations: PredicateObligations<'db>,
 }
 
-impl<'table, 'db> Autoderef<'table, 'db, usize> {
-    pub(crate) fn new_no_tracking(
-        table: &'table mut InferenceTable<'db>,
-        ty: Ty,
-        explicit: bool,
-        use_receiver_trait: bool,
-    ) -> Self {
-        let ty = table.structurally_resolve_type(&ty);
-        Autoderef { table, ty, at_start: true, steps: 0, explicit, use_receiver_trait }
-    }
+#[derive(Clone, Copy)]
+struct AutoderefTraits {
+    trait_target: TypeAliasId,
 }
 
-#[allow(private_bounds)]
-impl<T: TrackAutoderefSteps> Autoderef<'_, '_, T> {
-    pub(crate) fn step_count(&self) -> usize {
-        self.steps.len()
-    }
+/// Recursively dereference a type, considering both built-in
+/// dereferences (`*`) and the `Deref` trait.
+/// Although called `Autoderef` it can be configured to use the
+/// `Receiver` trait instead of the `Deref` trait.
+pub(crate) struct Autoderef<'a, 'db, Steps = Vec<(Ty<'db>, AutoderefKind)>> {
+    // Meta infos:
+    pub(crate) table: &'a mut InferenceTable<'db>,
+    traits: Option<AutoderefTraits>,
 
-    pub(crate) fn final_ty(&self) -> Ty {
-        self.ty.clone()
-    }
+    // Current state:
+    state: AutoderefSnapshot<'db, Steps>,
+
+    // Configurations:
+    include_raw_pointers: bool,
+    use_receiver_trait: bool,
 }
 
-impl<T: TrackAutoderefSteps> Iterator for Autoderef<'_, '_, T> {
-    type Item = (Ty, usize);
+impl<'a, 'db, Steps: TrackAutoderefSteps<'db>> Iterator for Autoderef<'a, 'db, Steps> {
+    type Item = (Ty<'db>, usize);
 
-    #[tracing::instrument(skip_all)]
     fn next(&mut self) -> Option<Self::Item> {
-        if mem::take(&mut self.at_start) {
-            return Some((self.ty.clone(), 0));
+        debug!("autoderef: steps={:?}, cur_ty={:?}", self.state.steps, self.state.cur_ty);
+        if self.state.at_start {
+            self.state.at_start = false;
+            debug!("autoderef stage #0 is {:?}", self.state.cur_ty);
+            return Some((self.state.cur_ty, 0));
         }
 
-        if self.steps.len() > AUTODEREF_RECURSION_LIMIT {
+        // If we have reached the recursion limit, error gracefully.
+        if self.state.steps.len() >= AUTODEREF_RECURSION_LIMIT {
+            self.state.reached_recursion_limit = true;
             return None;
         }
 
-        let (kind, new_ty) =
-            autoderef_step(self.table, self.ty.clone(), self.explicit, self.use_receiver_trait)?;
+        if self.state.cur_ty.is_ty_var() {
+            return None;
+        }
+
+        // Otherwise, deref if type is derefable:
+        // NOTE: in the case of self.use_receiver_trait = true, you might think it would
+        // be better to skip this clause and use the Overloaded case only, since &T
+        // and &mut T implement Receiver. But built-in derefs apply equally to Receiver
+        // and Deref, and this has benefits for const and the emitted MIR.
+        let (kind, new_ty) = if let Some(ty) =
+            self.state.cur_ty.builtin_deref(self.table.db, self.include_raw_pointers)
+        {
+            debug_assert_eq!(ty, self.table.infer_ctxt.resolve_vars_if_possible(ty));
+            // NOTE: we may still need to normalize the built-in deref in case
+            // we have some type like `&<Ty as Trait>::Assoc`, since users of
+            // autoderef expect this type to have been structurally normalized.
+            if let TyKind::Alias(..) = ty.kind() {
+                let (normalized_ty, obligations) = structurally_normalize_ty(self.table, ty)?;
+                self.state.obligations.extend(obligations);
+                (AutoderefKind::Builtin, normalized_ty)
+            } else {
+                (AutoderefKind::Builtin, ty)
+            }
+        } else if let Some(ty) = self.overloaded_deref_ty(self.state.cur_ty) {
+            // The overloaded deref check already normalizes the pointee type.
+            (AutoderefKind::Overloaded, ty)
+        } else {
+            return None;
+        };
 
-        self.steps.push(kind, &self.ty);
-        self.ty = new_ty;
+        self.state.steps.push(self.state.cur_ty, kind);
+        debug!(
+            "autoderef stage #{:?} is {:?} from {:?}",
+            self.step_count(),
+            new_ty,
+            (self.state.cur_ty, kind)
+        );
+        self.state.cur_ty = new_ty;
 
-        Some((self.ty.clone(), self.step_count()))
+        Some((self.state.cur_ty, self.step_count()))
     }
 }
 
-pub(crate) fn autoderef_step(
-    table: &mut InferenceTable<'_>,
-    ty: Ty,
-    explicit: bool,
-    use_receiver_trait: bool,
-) -> Option<(AutoderefKind, Ty)> {
-    if let Some(derefed) = builtin_deref(table.db, &ty, explicit) {
-        Some((AutoderefKind::Builtin, table.structurally_resolve_type(derefed)))
-    } else {
-        Some((AutoderefKind::Overloaded, deref_by_trait(table, ty, use_receiver_trait)?))
+impl<'a, 'db> Autoderef<'a, 'db> {
+    pub(crate) fn new(table: &'a mut InferenceTable<'db>, base_ty: Ty<'db>) -> Self {
+        Self::new_impl(table, base_ty)
     }
 }
 
-pub(crate) fn builtin_deref<'ty>(
-    db: &dyn HirDatabase,
-    ty: &'ty Ty,
-    explicit: bool,
-) -> Option<&'ty Ty> {
-    match ty.kind(Interner) {
-        TyKind::Ref(.., ty) => Some(ty),
-        TyKind::Raw(.., ty) if explicit => Some(ty),
-        &TyKind::Adt(chalk_ir::AdtId(adt), ref substs) if crate::lang_items::is_box(db, adt) => {
-            substs.at(Interner, 0).ty(Interner)
-        }
-        _ => None,
+impl<'a, 'db> Autoderef<'a, 'db, usize> {
+    pub(crate) fn new_no_tracking(table: &'a mut InferenceTable<'db>, base_ty: Ty<'db>) -> Self {
+        Self::new_impl(table, base_ty)
     }
 }
 
-pub(crate) fn deref_by_trait(
-    table @ &mut InferenceTable { db, .. }: &mut InferenceTable<'_>,
-    ty: Ty,
-    use_receiver_trait: bool,
-) -> Option<Ty> {
-    let _p = tracing::info_span!("deref_by_trait").entered();
-    if table.structurally_resolve_type(&ty).inference_var(Interner).is_some() {
-        // don't try to deref unknown variables
-        return None;
+impl<'a, 'db, Steps: TrackAutoderefSteps<'db>> Autoderef<'a, 'db, Steps> {
+    fn new_impl(table: &'a mut InferenceTable<'db>, base_ty: Ty<'db>) -> Self {
+        Autoderef {
+            state: AutoderefSnapshot {
+                steps: Steps::default(),
+                cur_ty: table.infer_ctxt.resolve_vars_if_possible(base_ty),
+                obligations: PredicateObligations::new(),
+                at_start: true,
+                reached_recursion_limit: false,
+            },
+            table,
+            traits: None,
+            include_raw_pointers: false,
+            use_receiver_trait: false,
+        }
     }
 
-    let trait_id = || {
-        // FIXME: Remove the `false` once `Receiver` needs to be stabilized, doing so will
-        // effectively bump the MSRV of rust-analyzer to 1.84 due to 1.83 and below lacking the
-        // blanked impl on `Deref`.
-        #[expect(clippy::overly_complex_bool_expr)]
-        if use_receiver_trait
-            && false
-            && let Some(receiver) = LangItem::Receiver.resolve_trait(db, table.trait_env.krate)
-        {
-            return Some(receiver);
+    fn autoderef_traits(&mut self) -> Option<AutoderefTraits> {
+        match &mut self.traits {
+            Some(it) => Some(*it),
+            None => {
+                let traits = if self.use_receiver_trait {
+                    AutoderefTraits {
+                        trait_target: LangItem::ReceiverTarget
+                            .resolve_type_alias(self.table.db, self.table.trait_env.krate)
+                            .or_else(|| {
+                                LangItem::DerefTarget
+                                    .resolve_type_alias(self.table.db, self.table.trait_env.krate)
+                            })?,
+                    }
+                } else {
+                    AutoderefTraits {
+                        trait_target: LangItem::DerefTarget
+                            .resolve_type_alias(self.table.db, self.table.trait_env.krate)?,
+                    }
+                };
+                Some(*self.traits.insert(traits))
+            }
         }
-        // Old rustc versions might not have `Receiver` trait.
-        // Fallback to `Deref` if they don't
-        LangItem::Deref.resolve_trait(db, table.trait_env.krate)
-    };
-    let trait_id = trait_id()?;
-    let target =
-        trait_id.trait_items(db).associated_type_by_name(&Name::new_symbol_root(sym::Target))?;
-
-    let projection = {
-        let b = TyBuilder::subst_for_def(db, trait_id, None);
-        if b.remaining() != 1 {
-            // the Target type + Deref trait should only have one generic parameter,
-            // namely Deref's Self type
-            return None;
-        }
-        let deref_subst = b.push(ty).build();
-        TyBuilder::assoc_type_projection(db, target, Some(deref_subst)).build()
-    };
+    }
+
+    fn overloaded_deref_ty(&mut self, ty: Ty<'db>) -> Option<Ty<'db>> {
+        debug!("overloaded_deref_ty({:?})", ty);
+        let interner = self.table.interner;
+
+        // <ty as Deref>, or whatever the equivalent trait is that we've been asked to walk.
+        let AutoderefTraits { trait_target } = self.autoderef_traits()?;
+
+        let (normalized_ty, obligations) = structurally_normalize_ty(
+            self.table,
+            Ty::new_projection(interner, trait_target.into(), [ty]),
+        )?;
+        debug!("overloaded_deref_ty({:?}) = ({:?}, {:?})", ty, normalized_ty, obligations);
+        self.state.obligations.extend(obligations);
 
-    // Check that the type implements Deref at all
-    let trait_ref = projection.trait_ref(db);
-    let implements_goal: Goal = trait_ref.cast(Interner);
-    if table.try_obligation(implements_goal.clone()).no_solution() {
+        Some(self.table.infer_ctxt.resolve_vars_if_possible(normalized_ty))
+    }
+
+    /// Returns the final type we ended up with, which may be an unresolved
+    /// inference variable.
+    pub(crate) fn final_ty(&self) -> Ty<'db> {
+        self.state.cur_ty
+    }
+
+    pub(crate) fn step_count(&self) -> usize {
+        self.state.steps.len()
+    }
+
+    pub(crate) fn take_obligations(&mut self) -> PredicateObligations<'db> {
+        std::mem::take(&mut self.state.obligations)
+    }
+
+    pub(crate) fn steps(&self) -> &Steps {
+        &self.state.steps
+    }
+
+    #[expect(dead_code)]
+    pub(crate) fn reached_recursion_limit(&self) -> bool {
+        self.state.reached_recursion_limit
+    }
+
+    /// also dereference through raw pointer types
+    /// e.g., assuming ptr_to_Foo is the type `*const Foo`
+    /// fcx.autoderef(span, ptr_to_Foo)  => [*const Foo]
+    /// fcx.autoderef(span, ptr_to_Foo).include_raw_ptrs() => [*const Foo, Foo]
+    pub(crate) fn include_raw_pointers(mut self) -> Self {
+        self.include_raw_pointers = true;
+        self
+    }
+
+    /// Use `core::ops::Receiver` and `core::ops::Receiver::Target` as
+    /// the trait and associated type to iterate, instead of
+    /// `core::ops::Deref` and `core::ops::Deref::Target`
+    pub(crate) fn use_receiver_trait(mut self) -> Self {
+        self.use_receiver_trait = true;
+        self
+    }
+}
+
+fn structurally_normalize_ty<'db>(
+    table: &InferenceTable<'db>,
+    ty: Ty<'db>,
+) -> Option<(Ty<'db>, PredicateObligations<'db>)> {
+    let mut ocx = ObligationCtxt::new(&table.infer_ctxt);
+    let Ok(normalized_ty) =
+        ocx.structurally_normalize_ty(&ObligationCause::misc(), table.param_env, ty)
+    else {
+        // We shouldn't have errors here in the old solver, except for
+        // evaluate/fulfill mismatches, but that's not a reason for an ICE.
         return None;
+    };
+    let errors = ocx.select_where_possible();
+    if !errors.is_empty() {
+        unreachable!();
     }
 
-    table.register_obligation(implements_goal.to_nextsolver(table.interner));
+    Some((normalized_ty, ocx.into_pending_obligations()))
+}
+
+pub(crate) fn overloaded_deref_ty<'db>(
+    table: &InferenceTable<'db>,
+    ty: Ty<'db>,
+) -> Option<InferOk<'db, Ty<'db>>> {
+    let interner = table.interner;
+
+    let trait_target = LangItem::DerefTarget.resolve_type_alias(table.db, table.trait_env.krate)?;
+
+    let (normalized_ty, obligations) =
+        structurally_normalize_ty(table, Ty::new_projection(interner, trait_target.into(), [ty]))?;
 
-    let result = table.normalize_projection_ty(projection);
-    Some(table.structurally_resolve_type(&result))
+    Some(InferOk { value: normalized_ty, obligations })
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/builder.rs b/src/tools/rust-analyzer/crates/hir-ty/src/builder.rs
index 8af8fb73f344e..3755175cf5163 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/builder.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/builder.rs
@@ -1,16 +1,12 @@
 //! `TyBuilder`, a helper for building instances of `Ty` and related types.
 
-use std::iter;
-
 use chalk_ir::{
     AdtId, DebruijnIndex, Scalar,
     cast::{Cast, CastTo, Caster},
     fold::TypeFoldable,
     interner::HasInterner,
 };
-use hir_def::{
-    DefWithBodyId, GenericDefId, GenericParamId, TraitId, TypeAliasId, builtin_type::BuiltinType,
-};
+use hir_def::{GenericDefId, GenericParamId, TraitId, TypeAliasId, builtin_type::BuiltinType};
 use smallvec::SmallVec;
 
 use crate::{
@@ -246,47 +242,6 @@ impl TyBuilder<()> {
         TyBuilder::new((), params, parent_subst)
     }
 
-    /// Creates a `TyBuilder` to build `Substitution` for a coroutine defined in `parent`.
-    ///
-    /// A coroutine's substitution consists of:
-    /// - resume type of coroutine
-    /// - yield type of coroutine ([`Coroutine::Yield`](std::ops::Coroutine::Yield))
-    /// - return type of coroutine ([`Coroutine::Return`](std::ops::Coroutine::Return))
-    /// - generic parameters in scope on `parent`
-    ///
-    /// in this order.
-    ///
-    /// This method prepopulates the builder with placeholder substitution of `parent`, so you
-    /// should only push exactly 3 `GenericArg`s before building.
-    pub fn subst_for_coroutine(db: &dyn HirDatabase, parent: DefWithBodyId) -> TyBuilder<()> {
-        let parent_subst =
-            parent.as_generic_def_id(db).map(|p| generics(db, p).placeholder_subst(db));
-        // These represent resume type, yield type, and return type of coroutine.
-        let params = std::iter::repeat_n(ParamKind::Type, 3).collect();
-        TyBuilder::new((), params, parent_subst)
-    }
-
-    pub fn subst_for_closure(
-        db: &dyn HirDatabase,
-        parent: DefWithBodyId,
-        sig_ty: Ty,
-    ) -> Substitution {
-        let sig_ty = sig_ty.cast(Interner);
-        let self_subst = iter::once(&sig_ty);
-        let Some(parent) = parent.as_generic_def_id(db) else {
-            return Substitution::from_iter(Interner, self_subst);
-        };
-        Substitution::from_iter(
-            Interner,
-            generics(db, parent)
-                .placeholder_subst(db)
-                .iter(Interner)
-                .chain(self_subst)
-                .cloned()
-                .collect::<Vec<_>>(),
-        )
-    }
-
     pub fn build(self) -> Substitution {
         let ((), subst) = self.build_internal();
         subst
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/chalk_ext.rs b/src/tools/rust-analyzer/crates/hir-ty/src/chalk_ext.rs
index 9f0ea14a8063d..1faf9f66dc547 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/chalk_ext.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/chalk_ext.rs
@@ -210,7 +210,7 @@ impl TyExt for Ty {
         match self.kind(Interner) {
             TyKind::Function(fn_ptr) => Some(CallableSig::from_fn_ptr(fn_ptr)),
             TyKind::FnDef(def, parameters) => Some(CallableSig::from_def(db, *def, parameters)),
-            TyKind::Closure(.., substs) => ClosureSubst(substs).sig_ty().callable_sig(db),
+            TyKind::Closure(.., substs) => ClosureSubst(substs).sig_ty(db).callable_sig(db),
             _ => None,
         }
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
index 0aec2b9dec7bc..448fc4aede037 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
@@ -283,6 +283,14 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
         def: TyDefId,
     ) -> crate::next_solver::EarlyBinder<'db, crate::next_solver::Ty<'db>>;
 
+    /// Returns the type of the value of the given constant, or `None` if the `ValueTyDefId` is
+    /// a `StructId` or `EnumVariantId` with a record constructor.
+    #[salsa::invoke(crate::lower_nextsolver::value_ty_query)]
+    fn value_ty_ns<'db>(
+        &'db self,
+        def: ValueTyDefId,
+    ) -> Option<crate::next_solver::EarlyBinder<'db, crate::next_solver::Ty<'db>>>;
+
     #[salsa::invoke(crate::lower_nextsolver::type_for_type_alias_with_diagnostics_query)]
     #[salsa::cycle(cycle_result = crate::lower_nextsolver::type_for_type_alias_with_diagnostics_cycle_result)]
     fn type_for_type_alias_with_diagnostics_ns<'db>(
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs
index 64c4cdeaddf31..3f04b72c2fc68 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs
@@ -14,6 +14,7 @@ use hir_def::{
 };
 use span::Edition;
 
+use crate::utils::TargetFeatureIsSafeInTarget;
 use crate::{
     InferenceResult, Interner, TargetFeatures, TyExt, TyKind,
     db::HirDatabase,
@@ -147,7 +148,7 @@ struct UnsafeVisitor<'db> {
     edition: Edition,
     /// On some targets (WASM), calling safe functions with `#[target_feature]` is always safe, even when
     /// the target feature is not enabled. This flag encodes that.
-    target_feature_is_safe: bool,
+    target_feature_is_safe: TargetFeatureIsSafeInTarget,
 }
 
 impl<'db> UnsafeVisitor<'db> {
@@ -167,7 +168,7 @@ impl<'db> UnsafeVisitor<'db> {
         let edition = krate.data(db).edition;
         let target_feature_is_safe = match &krate.workspace_data(db).target {
             Ok(target) => target_feature_is_safe_in_target(target),
-            Err(_) => false,
+            Err(_) => TargetFeatureIsSafeInTarget::No,
         };
         Self {
             db,
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 ea8bdf8bcbae4..7418e3bbeb49d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
@@ -38,14 +38,16 @@ use rustc_apfloat::{
 };
 use rustc_hash::FxHashSet;
 use rustc_type_ir::{
-    AliasTyKind, RegionKind,
-    inherent::{AdtDef, IntoKind, SliceLike},
+    AliasTyKind, CoroutineArgsParts, RegionKind,
+    inherent::{AdtDef, GenericArgs as _, IntoKind, SliceLike},
 };
 use smallvec::SmallVec;
 use span::Edition;
 use stdx::never;
 use triomphe::Arc;
 
+use crate::next_solver::infer::DbInternerInferExt;
+use crate::next_solver::infer::traits::ObligationCause;
 use crate::{
     AliasEq, AliasTy, Binders, CallableDefId, CallableSig, ConcreteConst, Const, ConstScalar,
     ConstValue, DomainGoal, FnAbi, GenericArg, ImplTraitId, Interner, Lifetime, LifetimeData,
@@ -789,11 +791,11 @@ fn render_const_scalar_ns(
 ) -> Result<(), HirDisplayError> {
     let trait_env = TraitEnvironment::empty(f.krate());
     let interner = DbInterner::new_with(f.db, Some(trait_env.krate), trait_env.block);
-    let ty = crate::next_solver::project::solve_normalize::normalize(
-        interner,
-        trait_env.env.to_nextsolver(interner),
-        ty,
-    );
+    let infcx = interner.infer_ctxt().build(rustc_type_ir::TypingMode::PostAnalysis);
+    let ty = infcx
+        .at(&ObligationCause::new(), trait_env.env.to_nextsolver(interner))
+        .deeply_normalize(ty)
+        .unwrap_or(ty);
     render_const_scalar_inner(f, b, memory_map, ty, trait_env)
 }
 
@@ -1556,7 +1558,7 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                     }
                     _ => (),
                 }
-                let sig = ClosureSubst(&substs).sig_ty().callable_sig(db);
+                let sig = ClosureSubst(&substs).sig_ty(db).callable_sig(db);
                 if let Some(sig) = sig {
                     let InternedClosure(def, _) = db.lookup_intern_closure(id);
                     let infer = db.infer(def);
@@ -1696,26 +1698,17 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                         DisplaySourceCodeError::Coroutine,
                     ));
                 }
-                let subst = convert_args_for_result(interner, subst.as_slice());
-                let subst = subst.as_slice(Interner);
-                let a: Option<SmallVec<[&Ty; 3]>> = subst
-                    .get(subst.len() - 3..)
-                    .and_then(|args| args.iter().map(|arg| arg.ty(Interner)).collect());
+                let CoroutineArgsParts { resume_ty, yield_ty, return_ty, .. } =
+                    subst.split_coroutine_args();
+                write!(f, "|")?;
+                resume_ty.hir_fmt(f)?;
+                write!(f, "|")?;
 
-                if let Some([resume_ty, yield_ty, ret_ty]) = a.as_deref() {
-                    write!(f, "|")?;
-                    resume_ty.hir_fmt(f)?;
-                    write!(f, "|")?;
+                write!(f, " yields ")?;
+                yield_ty.hir_fmt(f)?;
 
-                    write!(f, " yields ")?;
-                    yield_ty.hir_fmt(f)?;
-
-                    write!(f, " -> ")?;
-                    ret_ty.hir_fmt(f)?;
-                } else {
-                    // This *should* be unreachable, but fallback just in case.
-                    write!(f, "{{coroutine}}")?;
-                }
+                write!(f, " -> ")?;
+                return_ty.hir_fmt(f)?;
             }
             TyKind::CoroutineWitness(..) => write!(f, "{{coroutine witness}}")?,
             TyKind::Pat(_, _) => write!(f, "{{pat}}")?,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/drop.rs b/src/tools/rust-analyzer/crates/hir-ty/src/drop.rs
index a7e942d92442c..f5c2f41069ea0 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/drop.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/drop.rs
@@ -120,7 +120,7 @@ pub(crate) fn has_drop_glue(db: &dyn HirDatabase, ty: Ty, env: Arc<TraitEnvironm
             let env = db.trait_environment_for_body(owner);
             captures
                 .iter()
-                .map(|capture| db.has_drop_glue(capture.ty(subst), env.clone()))
+                .map(|capture| db.has_drop_glue(capture.ty(db, subst), env.clone()))
                 .max()
                 .unwrap_or(DropGlue::None)
         }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
index 3d91a2558f0b1..017119781a709 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
@@ -13,6 +13,7 @@
 //! to certain types. To record this, we use the union-find implementation from
 //! the `ena` crate, which is extracted from rustc.
 
+mod autoderef;
 pub(crate) mod cast;
 pub(crate) mod closure;
 mod coerce;
@@ -25,6 +26,7 @@ pub(crate) mod unify;
 
 use std::{cell::OnceCell, convert::identity, iter, ops::Index};
 
+use base_db::Crate;
 use chalk_ir::{
     DebruijnIndex, Mutability, Safety, Scalar, TyKind, TypeFlags, Variance,
     cast::Cast,
@@ -54,27 +56,30 @@ use rustc_hash::{FxHashMap, FxHashSet};
 use stdx::{always, never};
 use triomphe::Arc;
 
-use crate::next_solver::DbInterner;
-use crate::next_solver::mapping::NextSolverToChalk;
+use crate::db::InternedClosureId;
 use crate::{
     AliasEq, AliasTy, Binders, ClosureId, Const, DomainGoal, GenericArg, ImplTraitId, ImplTraitIdx,
     IncorrectGenericsLenKind, Interner, Lifetime, OpaqueTyId, ParamLoweringMode,
-    PathLoweringDiagnostic, ProjectionTy, Substitution, TraitEnvironment, Ty, TyBuilder, TyExt,
+    PathLoweringDiagnostic, ProjectionTy, Substitution, TargetFeatures, TraitEnvironment, Ty,
+    TyBuilder, TyExt,
     db::HirDatabase,
     fold_tys,
     generics::Generics,
     infer::{
-        coerce::CoerceMany,
+        coerce::{CoerceMany, DynamicCoerceMany},
         diagnostics::{Diagnostics, InferenceTyLoweringContext as TyLoweringContext},
         expr::ExprIsRead,
         unify::InferenceTable,
     },
     lower::{ImplTraitLoweringMode, LifetimeElisionKind, diagnostics::TyLoweringDiagnostic},
     mir::MirSpan,
-    next_solver::{self, mapping::ChalkToNextSolver},
+    next_solver::{
+        self, DbInterner,
+        mapping::{ChalkToNextSolver, NextSolverToChalk},
+    },
     static_lifetime, to_assoc_type_id,
     traits::FnTrait,
-    utils::UnevaluatedConstEvaluatorFolder,
+    utils::{TargetFeatureIsSafeInTarget, UnevaluatedConstEvaluatorFolder},
 };
 
 // This lint has a false positive here. See the link below for details.
@@ -86,7 +91,7 @@ pub use coerce::could_coerce;
 pub use unify::{could_unify, could_unify_deeply};
 
 use cast::{CastCheck, CastError};
-pub(crate) use closure::{CaptureKind, CapturedItem, CapturedItemWithoutTy};
+pub(crate) use closure::analysis::{CaptureKind, CapturedItem, CapturedItemWithoutTy};
 
 /// The entry point of type inference.
 pub(crate) fn infer_query(db: &dyn HirDatabase, def: DefWithBodyId) -> Arc<InferenceResult> {
@@ -159,7 +164,7 @@ pub(crate) fn normalize(db: &dyn HirDatabase, trait_env: Arc<TraitEnvironment>,
     let mut table = unify::InferenceTable::new(db, trait_env);
 
     let ty_with_vars = table.normalize_associated_types_in(ty);
-    table.resolve_obligations_as_possible();
+    table.select_obligations_where_possible();
     table.propagate_diverging_flag();
     table.resolve_completely(ty_with_vars)
 }
@@ -183,18 +188,14 @@ impl BindingMode {
     }
 }
 
+// FIXME: Remove this `InferOk`, switch all code to the second one, that uses `Obligation` instead of `Goal`.
 #[derive(Debug)]
 pub(crate) struct InferOk<'db, T> {
+    #[allow(dead_code)]
     value: T,
     goals: Vec<next_solver::Goal<'db, next_solver::Predicate<'db>>>,
 }
 
-impl<'db, T> InferOk<'db, T> {
-    fn map<U>(self, f: impl FnOnce(T) -> U) -> InferOk<'db, U> {
-        InferOk { value: f(self.value), goals: self.goals }
-    }
-}
-
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum InferenceTyDiagnosticSource {
     /// Diagnostics that come from types in the body.
@@ -378,6 +379,26 @@ impl Adjustment {
     }
 }
 
+/// At least for initial deployment, we want to limit two-phase borrows to
+/// only a few specific cases. Right now, those are mostly "things that desugar"
+/// into method calls:
+/// - using `x.some_method()` syntax, where some_method takes `&mut self`,
+/// - using `Foo::some_method(&mut x, ...)` syntax,
+/// - binary assignment operators (`+=`, `-=`, `*=`, etc.).
+///
+/// Anything else should be rejected until generalized two-phase borrow support
+/// is implemented. Right now, dataflow can't handle the general case where there
+/// is more than one use of a mutable borrow, and we don't want to accept too much
+/// new code via two-phase borrows, so we try to limit where we create two-phase
+/// capable mutable borrows.
+/// See #49434 for tracking.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub(crate) enum AllowTwoPhase {
+    // FIXME: We should use this when appropriate.
+    Yes,
+    No,
+}
+
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum Adjust {
     /// Go from ! to any type.
@@ -393,8 +414,6 @@ pub enum Adjust {
 /// call, with the signature `&'a T -> &'a U` or `&'a mut T -> &'a mut U`.
 /// The target type is `U` in both cases, with the region and mutability
 /// being those shared by both the receiver and the returned reference.
-///
-/// Mutability is `None` when we are not sure.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct OverloadedDeref(pub Option<Mutability>);
 
@@ -656,6 +675,7 @@ pub(crate) struct InferenceContext<'db> {
     /// Generally you should not resolve things via this resolver. Instead create a TyLoweringContext
     /// and resolve the path via its methods. This will ensure proper error reporting.
     pub(crate) resolver: Resolver<'db>,
+    target_features: OnceCell<(TargetFeatures, TargetFeatureIsSafeInTarget)>,
     generic_def: GenericDefId,
     generics: OnceCell<Generics>,
     table: unify::InferenceTable<'db>,
@@ -673,11 +693,11 @@ pub(crate) struct InferenceContext<'db> {
     /// If `Some`, this stores coercion information for returned
     /// expressions. If `None`, this is in a context where return is
     /// inappropriate, such as a const expression.
-    return_coercion: Option<CoerceMany>,
+    return_coercion: Option<DynamicCoerceMany<'db>>,
     /// The resume type and the yield type, respectively, of the coroutine being inferred.
     resume_yield_tys: Option<(Ty, Ty)>,
     diverges: Diverges,
-    breakables: Vec<BreakableContext>,
+    breakables: Vec<BreakableContext<'db>>,
 
     /// Whether we are inside the pattern of a destructuring assignment.
     inside_assignment: bool,
@@ -692,21 +712,21 @@ pub(crate) struct InferenceContext<'db> {
     /// We do that because sometimes we truncate projections (when a closure captures
     /// both `a.b` and `a.b.c`), and we want to provide accurate spans in this case.
     current_capture_span_stack: Vec<MirSpan>,
-    current_closure: Option<ClosureId>,
+    current_closure: Option<InternedClosureId>,
     /// Stores the list of closure ids that need to be analyzed before this closure. See the
     /// comment on `InferenceContext::sort_closures`
-    closure_dependencies: FxHashMap<ClosureId, Vec<ClosureId>>,
-    deferred_closures: FxHashMap<ClosureId, Vec<(Ty, Ty, Vec<Ty>, ExprId)>>,
+    closure_dependencies: FxHashMap<InternedClosureId, Vec<InternedClosureId>>,
+    deferred_closures: FxHashMap<InternedClosureId, Vec<(Ty, Ty, Vec<Ty>, ExprId)>>,
 
     diagnostics: Diagnostics,
 }
 
 #[derive(Clone, Debug)]
-struct BreakableContext {
+struct BreakableContext<'db> {
     /// Whether this context contains at least one break expression.
     may_break: bool,
     /// The coercion target of the context.
-    coerce: Option<CoerceMany>,
+    coerce: Option<DynamicCoerceMany<'db>>,
     /// The optional label of the context.
     label: Option<LabelId>,
     kind: BreakableKind,
@@ -721,10 +741,10 @@ enum BreakableKind {
     Border,
 }
 
-fn find_breakable(
-    ctxs: &mut [BreakableContext],
+fn find_breakable<'a, 'db>(
+    ctxs: &'a mut [BreakableContext<'db>],
     label: Option<LabelId>,
-) -> Option<&mut BreakableContext> {
+) -> Option<&'a mut BreakableContext<'db>> {
     let mut ctxs = ctxs
         .iter_mut()
         .rev()
@@ -735,10 +755,10 @@ fn find_breakable(
     }
 }
 
-fn find_continuable(
-    ctxs: &mut [BreakableContext],
+fn find_continuable<'a, 'db>(
+    ctxs: &'a mut [BreakableContext<'db>],
     label: Option<LabelId>,
-) -> Option<&mut BreakableContext> {
+) -> Option<&'a mut BreakableContext<'db>> {
     match label {
         Some(_) => find_breakable(ctxs, label).filter(|it| matches!(it.kind, BreakableKind::Loop)),
         None => find_breakable(ctxs, label),
@@ -759,6 +779,7 @@ impl<'db> InferenceContext<'db> {
     ) -> Self {
         let trait_env = db.trait_environment_for_body(owner);
         InferenceContext {
+            target_features: OnceCell::new(),
             generics: OnceCell::new(),
             result: InferenceResult::default(),
             table: unify::InferenceTable::new(db, trait_env),
@@ -794,18 +815,56 @@ impl<'db> InferenceContext<'db> {
         self.generics.get_or_init(|| crate::generics::generics(self.db, self.generic_def))
     }
 
+    #[inline]
+    fn krate(&self) -> Crate {
+        self.resolver.krate()
+    }
+
+    fn target_features<'a>(
+        db: &dyn HirDatabase,
+        target_features: &'a OnceCell<(TargetFeatures, TargetFeatureIsSafeInTarget)>,
+        owner: DefWithBodyId,
+        krate: Crate,
+    ) -> (&'a TargetFeatures, TargetFeatureIsSafeInTarget) {
+        let (target_features, target_feature_is_safe) = target_features.get_or_init(|| {
+            let target_features = match owner {
+                DefWithBodyId::FunctionId(id) => TargetFeatures::from_attrs(&db.attrs(id.into())),
+                _ => TargetFeatures::default(),
+            };
+            let target_feature_is_safe = match &krate.workspace_data(db).target {
+                Ok(target) => crate::utils::target_feature_is_safe_in_target(target),
+                Err(_) => TargetFeatureIsSafeInTarget::No,
+            };
+            (target_features, target_feature_is_safe)
+        });
+        (target_features, *target_feature_is_safe)
+    }
+
+    #[inline]
+    pub(crate) fn set_tainted_by_errors(&mut self) {
+        self.result.has_errors = true;
+    }
+
     // FIXME: This function should be private in module. It is currently only used in the consteval, since we need
     // `InferenceResult` in the middle of inference. See the fixme comment in `consteval::eval_to_const`. If you
     // used this function for another workaround, mention it here. If you really need this function and believe that
     // there is no problem in it being `pub(crate)`, remove this comment.
-    pub(crate) fn resolve_all(self) -> InferenceResult {
+    pub(crate) fn resolve_all(mut self) -> InferenceResult {
+        self.table.select_obligations_where_possible();
+        self.table.fallback_if_possible();
+
+        // Comment from rustc:
+        // Even though coercion casts provide type hints, we check casts after fallback for
+        // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
+        let cast_checks = std::mem::take(&mut self.deferred_cast_checks);
+        for mut cast in cast_checks.into_iter() {
+            if let Err(diag) = cast.check(&mut self) {
+                self.diagnostics.push(diag);
+            }
+        }
+
         let InferenceContext {
-            mut table,
-            mut result,
-            mut deferred_cast_checks,
-            tuple_field_accesses_rev,
-            diagnostics,
-            ..
+            mut table, mut result, tuple_field_accesses_rev, diagnostics, ..
         } = self;
         let mut diagnostics = diagnostics.finish();
         // Destructure every single field so whenever new fields are added to `InferenceResult` we
@@ -831,31 +890,12 @@ impl<'db> InferenceContext<'db> {
             closure_info: _,
             mutated_bindings_in_closure: _,
             tuple_field_access_types: _,
-            coercion_casts,
+            coercion_casts: _,
             diagnostics: _,
         } = &mut result;
-        table.resolve_obligations_as_possible();
-        table.fallback_if_possible();
-
-        // Comment from rustc:
-        // Even though coercion casts provide type hints, we check casts after fallback for
-        // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
-        let mut apply_adjustments = |expr, adj: Vec<_>| {
-            expr_adjustments.insert(expr, adj.into_boxed_slice());
-        };
-        let mut set_coercion_cast = |expr| {
-            coercion_casts.insert(expr);
-        };
-        for cast in deferred_cast_checks.iter_mut() {
-            if let Err(diag) =
-                cast.check(&mut table, &mut apply_adjustments, &mut set_coercion_cast)
-            {
-                diagnostics.push(diag);
-            }
-        }
 
         // FIXME resolve obligations as well (use Guidance if necessary)
-        table.resolve_obligations_as_possible();
+        table.select_obligations_where_possible();
 
         // make sure diverging type variables are marked as such
         table.propagate_diverging_flag();
@@ -1081,7 +1121,8 @@ impl<'db> InferenceContext<'db> {
         };
 
         self.return_ty = self.process_user_written_ty(return_ty);
-        self.return_coercion = Some(CoerceMany::new(self.return_ty.clone()));
+        self.return_coercion =
+            Some(CoerceMany::new(self.return_ty.to_nextsolver(self.table.interner)));
 
         // Functions might be defining usage sites of TAITs.
         // To define an TAITs, that TAIT must appear in the function's signatures.
@@ -1117,8 +1158,12 @@ impl<'db> InferenceContext<'db> {
         fold_tys(
             t,
             |ty, _| {
+                let ty = self.table.structurally_resolve_type(&ty);
                 let opaque_ty_id = match ty.kind(Interner) {
-                    TyKind::OpaqueType(opaque_ty_id, _) => *opaque_ty_id,
+                    TyKind::OpaqueType(opaque_ty_id, _)
+                    | TyKind::Alias(AliasTy::Opaque(crate::OpaqueTy { opaque_ty_id, .. })) => {
+                        *opaque_ty_id
+                    }
                     _ => return ty,
                 };
                 let (impl_traits, idx) =
@@ -1214,9 +1259,11 @@ impl<'db> InferenceContext<'db> {
                 ty: &chalk_ir::Ty<Interner>,
                 outer_binder: DebruijnIndex,
             ) -> std::ops::ControlFlow<Self::BreakTy> {
-                let ty = self.table.resolve_ty_shallow(ty);
+                let ty = self.table.structurally_resolve_type(ty);
 
-                if let TyKind::OpaqueType(id, _) = ty.kind(Interner)
+                if let TyKind::OpaqueType(id, _)
+                | TyKind::Alias(AliasTy::Opaque(crate::OpaqueTy { opaque_ty_id: id, .. })) =
+                    ty.kind(Interner)
                     && let ImplTraitId::TypeAliasImplTrait(alias_id, _) =
                         self.db.lookup_intern_impl_trait_id((*id).into())
                 {
@@ -1361,6 +1408,13 @@ impl<'db> InferenceContext<'db> {
         }
     }
 
+    fn write_pat_adj(&mut self, pat: PatId, adjustments: Box<[Ty]>) {
+        if adjustments.is_empty() {
+            return;
+        }
+        self.result.pat_adjustments.entry(pat).or_default().extend(adjustments);
+    }
+
     fn write_method_resolution(&mut self, expr: ExprId, func: FunctionId, subst: Substitution) {
         self.result.method_resolutions.insert(expr, (func, subst));
     }
@@ -1587,24 +1641,14 @@ impl<'db> InferenceContext<'db> {
         self.table.process_remote_user_written_ty(ty)
     }
 
-    /// Recurses through the given type, normalizing associated types mentioned
-    /// in it by replacing them by type variables and registering obligations to
-    /// resolve later. This should be done once for every type we get from some
-    /// type annotation (e.g. from a let type annotation, field type or function
-    /// call). `make_ty` handles this already, but e.g. for field types we need
-    /// to do it as well.
-    fn normalize_associated_types_in<T, U>(&mut self, ty: T) -> T
-    where
-        T: HasInterner<Interner = Interner> + TypeFoldable<Interner> + ChalkToNextSolver<'db, U>,
-        U: NextSolverToChalk<'db, T> + rustc_type_ir::TypeFoldable<DbInterner<'db>>,
-    {
-        self.table.normalize_associated_types_in(ty)
-    }
-
     fn resolve_ty_shallow(&mut self, ty: &Ty) -> Ty {
         self.table.resolve_ty_shallow(ty)
     }
 
+    fn shallow_resolve(&self, ty: crate::next_solver::Ty<'db>) -> crate::next_solver::Ty<'db> {
+        self.table.shallow_resolve(ty)
+    }
+
     fn resolve_associated_type(&mut self, inner_ty: Ty, assoc_ty: Option<TypeAliasId>) -> Ty {
         self.resolve_associated_type_with_params(inner_ty, assoc_ty, &[])
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/autoderef.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/autoderef.rs
new file mode 100644
index 0000000000000..77b1ae6a94a46
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/autoderef.rs
@@ -0,0 +1,54 @@
+//! Autoderef helpers for inference.
+
+use std::iter;
+
+use crate::{
+    Adjust, Adjustment, OverloadedDeref,
+    autoderef::{Autoderef, AutoderefKind},
+    infer::unify::InferenceTable,
+    next_solver::{
+        Ty,
+        infer::{InferOk, traits::PredicateObligations},
+        mapping::NextSolverToChalk,
+    },
+};
+
+impl<'db> InferenceTable<'db> {
+    pub(crate) fn autoderef(&mut self, base_ty: Ty<'db>) -> Autoderef<'_, 'db> {
+        Autoderef::new(self, base_ty)
+    }
+}
+
+impl<'db> Autoderef<'_, 'db> {
+    /// Returns the adjustment steps.
+    pub(crate) fn adjust_steps(mut self) -> Vec<Adjustment> {
+        let infer_ok = self.adjust_steps_as_infer_ok();
+        self.table.register_infer_ok(infer_ok)
+    }
+
+    pub(crate) fn adjust_steps_as_infer_ok(&mut self) -> InferOk<'db, Vec<Adjustment>> {
+        let steps = self.steps();
+        if steps.is_empty() {
+            return InferOk { obligations: PredicateObligations::new(), value: vec![] };
+        }
+
+        let targets = steps.iter().skip(1).map(|&(ty, _)| ty).chain(iter::once(self.final_ty()));
+        let steps: Vec<_> = steps
+            .iter()
+            .map(|&(_source, kind)| {
+                if let AutoderefKind::Overloaded = kind {
+                    Some(OverloadedDeref(Some(chalk_ir::Mutability::Not)))
+                } else {
+                    None
+                }
+            })
+            .zip(targets)
+            .map(|(autoderef, target)| Adjustment {
+                kind: Adjust::Deref(autoderef),
+                target: target.to_chalk(self.table.interner),
+            })
+            .collect();
+
+        InferOk { obligations: self.take_obligations(), value: steps }
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs
index bc3ee3c4c54d9..4cd6144a14cba 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/cast.rs
@@ -4,12 +4,14 @@ use chalk_ir::{Mutability, Scalar, TyVariableKind, UintTy};
 use hir_def::{AdtId, hir::ExprId, signatures::TraitFlags};
 use stdx::never;
 
+use crate::infer::coerce::CoerceNever;
 use crate::{
-    Adjustment, Binders, DynTy, InferenceDiagnostic, Interner, PlaceholderIndex,
-    QuantifiedWhereClauses, Ty, TyExt, TyKind, TypeFlags, WhereClause,
+    Binders, DynTy, InferenceDiagnostic, Interner, PlaceholderIndex, QuantifiedWhereClauses, Ty,
+    TyExt, TyKind, TypeFlags, WhereClause,
     db::HirDatabase,
     from_chalk_trait_id,
-    infer::{coerce::CoerceNever, unify::InferenceTable},
+    infer::{AllowTwoPhase, InferenceContext},
+    next_solver::mapping::ChalkToNextSolver,
 };
 
 #[derive(Debug)]
@@ -93,23 +95,25 @@ impl CastCheck {
         Self { expr, source_expr, expr_ty, cast_ty }
     }
 
-    pub(super) fn check<F, G>(
+    pub(super) fn check(
         &mut self,
-        table: &mut InferenceTable<'_>,
-        apply_adjustments: &mut F,
-        set_coercion_cast: &mut G,
-    ) -> Result<(), InferenceDiagnostic>
-    where
-        F: FnMut(ExprId, Vec<Adjustment>),
-        G: FnMut(ExprId),
-    {
-        self.expr_ty = table.eagerly_normalize_and_resolve_shallow_in(self.expr_ty.clone());
-        self.cast_ty = table.eagerly_normalize_and_resolve_shallow_in(self.cast_ty.clone());
+        ctx: &mut InferenceContext<'_>,
+    ) -> Result<(), InferenceDiagnostic> {
+        self.expr_ty = ctx.table.eagerly_normalize_and_resolve_shallow_in(self.expr_ty.clone());
+        self.cast_ty = ctx.table.eagerly_normalize_and_resolve_shallow_in(self.cast_ty.clone());
 
         // This should always come first so that we apply the coercion, which impacts infer vars.
-        if let Ok((adj, _)) = table.coerce(&self.expr_ty, &self.cast_ty, CoerceNever::Yes) {
-            apply_adjustments(self.source_expr, adj);
-            set_coercion_cast(self.source_expr);
+        if ctx
+            .coerce(
+                self.source_expr.into(),
+                self.expr_ty.to_nextsolver(ctx.table.interner),
+                self.cast_ty.to_nextsolver(ctx.table.interner),
+                AllowTwoPhase::No,
+                CoerceNever::Yes,
+            )
+            .is_ok()
+        {
+            ctx.result.coercion_casts.insert(self.source_expr);
             return Ok(());
         }
 
@@ -118,7 +122,7 @@ impl CastCheck {
         }
 
         if !self.cast_ty.data(Interner).flags.contains(TypeFlags::HAS_TY_INFER)
-            && !table.is_sized(&self.cast_ty)
+            && !ctx.table.is_sized(&self.cast_ty)
         {
             return Err(InferenceDiagnostic::CastToUnsized {
                 expr: self.expr,
@@ -133,30 +137,31 @@ impl CastCheck {
             return Ok(());
         }
 
-        self.do_check(table, apply_adjustments)
+        self.do_check(ctx)
             .map_err(|e| e.into_diagnostic(self.expr, self.expr_ty.clone(), self.cast_ty.clone()))
     }
 
-    fn do_check<F>(
-        &self,
-        table: &mut InferenceTable<'_>,
-        apply_adjustments: &mut F,
-    ) -> Result<(), CastError>
-    where
-        F: FnMut(ExprId, Vec<Adjustment>),
-    {
+    fn do_check(&self, ctx: &mut InferenceContext<'_>) -> Result<(), CastError> {
         let (t_from, t_cast) = match (
-            CastTy::from_ty(table.db, &self.expr_ty),
-            CastTy::from_ty(table.db, &self.cast_ty),
+            CastTy::from_ty(ctx.db, &self.expr_ty),
+            CastTy::from_ty(ctx.db, &self.cast_ty),
         ) {
             (Some(t_from), Some(t_cast)) => (t_from, t_cast),
             (None, Some(t_cast)) => match self.expr_ty.kind(Interner) {
                 TyKind::FnDef(..) => {
-                    let sig = self.expr_ty.callable_sig(table.db).expect("FnDef had no sig");
-                    let sig = table.eagerly_normalize_and_resolve_shallow_in(sig);
+                    let sig = self.expr_ty.callable_sig(ctx.db).expect("FnDef had no sig");
+                    let sig = ctx.table.eagerly_normalize_and_resolve_shallow_in(sig);
                     let fn_ptr = TyKind::Function(sig.to_fn_ptr()).intern(Interner);
-                    if let Ok((adj, _)) = table.coerce(&self.expr_ty, &fn_ptr, CoerceNever::Yes) {
-                        apply_adjustments(self.source_expr, adj);
+                    if ctx
+                        .coerce(
+                            self.source_expr.into(),
+                            self.expr_ty.to_nextsolver(ctx.table.interner),
+                            fn_ptr.to_nextsolver(ctx.table.interner),
+                            AllowTwoPhase::No,
+                            CoerceNever::Yes,
+                        )
+                        .is_ok()
+                    {
                     } else {
                         return Err(CastError::IllegalCast);
                     }
@@ -176,11 +181,11 @@ impl CastCheck {
                         },
                         // array-ptr-cast
                         CastTy::Ptr(t, m) => {
-                            let t = table.eagerly_normalize_and_resolve_shallow_in(t);
-                            if !table.is_sized(&t) {
+                            let t = ctx.table.eagerly_normalize_and_resolve_shallow_in(t);
+                            if !ctx.table.is_sized(&t) {
                                 return Err(CastError::IllegalCast);
                             }
-                            self.check_ref_cast(table, inner_ty, *mutbl, &t, m, apply_adjustments)
+                            self.check_ref_cast(ctx, inner_ty, *mutbl, &t, m)
                         }
                         _ => Err(CastError::NonScalar),
                     };
@@ -202,12 +207,10 @@ impl CastCheck {
             }
             (CastTy::Int(Int::Bool | Int::CEnum | Int::Char) | CastTy::Float, CastTy::Ptr(..))
             | (CastTy::Ptr(..) | CastTy::FnPtr, CastTy::Float) => Err(CastError::IllegalCast),
-            (CastTy::Ptr(src, _), CastTy::Ptr(dst, _)) => {
-                self.check_ptr_ptr_cast(table, &src, &dst)
-            }
-            (CastTy::Ptr(src, _), CastTy::Int(_)) => self.check_ptr_addr_cast(table, &src),
-            (CastTy::Int(_), CastTy::Ptr(dst, _)) => self.check_addr_ptr_cast(table, &dst),
-            (CastTy::FnPtr, CastTy::Ptr(dst, _)) => self.check_fptr_ptr_cast(table, &dst),
+            (CastTy::Ptr(src, _), CastTy::Ptr(dst, _)) => self.check_ptr_ptr_cast(ctx, &src, &dst),
+            (CastTy::Ptr(src, _), CastTy::Int(_)) => self.check_ptr_addr_cast(ctx, &src),
+            (CastTy::Int(_), CastTy::Ptr(dst, _)) => self.check_addr_ptr_cast(ctx, &dst),
+            (CastTy::FnPtr, CastTy::Ptr(dst, _)) => self.check_fptr_ptr_cast(ctx, &dst),
             (CastTy::Int(Int::CEnum), CastTy::Int(_)) => Ok(()),
             (CastTy::Int(Int::Char | Int::Bool), CastTy::Int(_)) => Ok(()),
             (CastTy::Int(_) | CastTy::Float, CastTy::Int(_) | CastTy::Float) => Ok(()),
@@ -215,26 +218,30 @@ impl CastCheck {
         }
     }
 
-    fn check_ref_cast<F>(
+    fn check_ref_cast(
         &self,
-        table: &mut InferenceTable<'_>,
+        ctx: &mut InferenceContext<'_>,
         t_expr: &Ty,
         m_expr: Mutability,
         t_cast: &Ty,
         m_cast: Mutability,
-        apply_adjustments: &mut F,
-    ) -> Result<(), CastError>
-    where
-        F: FnMut(ExprId, Vec<Adjustment>),
-    {
+    ) -> Result<(), CastError> {
         // Mutability order is opposite to rustc. `Mut < Not`
         if m_expr <= m_cast
             && let TyKind::Array(ety, _) = t_expr.kind(Interner)
         {
             // Coerce to a raw pointer so that we generate RawPtr in MIR.
             let array_ptr_type = TyKind::Raw(m_expr, t_expr.clone()).intern(Interner);
-            if let Ok((adj, _)) = table.coerce(&self.expr_ty, &array_ptr_type, CoerceNever::Yes) {
-                apply_adjustments(self.source_expr, adj);
+            if ctx
+                .coerce(
+                    self.source_expr.into(),
+                    self.expr_ty.to_nextsolver(ctx.table.interner),
+                    array_ptr_type.to_nextsolver(ctx.table.interner),
+                    AllowTwoPhase::No,
+                    CoerceNever::Yes,
+                )
+                .is_ok()
+            {
             } else {
                 never!(
                     "could not cast from reference to array to pointer to array ({:?} to {:?})",
@@ -245,7 +252,16 @@ impl CastCheck {
 
             // This is a less strict condition than rustc's `demand_eqtype`,
             // but false negative is better than false positive
-            if table.coerce(ety, t_cast, CoerceNever::Yes).is_ok() {
+            if ctx
+                .coerce(
+                    self.source_expr.into(),
+                    ety.to_nextsolver(ctx.table.interner),
+                    t_cast.to_nextsolver(ctx.table.interner),
+                    AllowTwoPhase::No,
+                    CoerceNever::Yes,
+                )
+                .is_ok()
+            {
                 return Ok(());
             }
         }
@@ -255,12 +271,12 @@ impl CastCheck {
 
     fn check_ptr_ptr_cast(
         &self,
-        table: &mut InferenceTable<'_>,
+        ctx: &mut InferenceContext<'_>,
         src: &Ty,
         dst: &Ty,
     ) -> Result<(), CastError> {
-        let src_kind = pointer_kind(src, table).map_err(|_| CastError::Unknown)?;
-        let dst_kind = pointer_kind(dst, table).map_err(|_| CastError::Unknown)?;
+        let src_kind = pointer_kind(src, ctx).map_err(|_| CastError::Unknown)?;
+        let dst_kind = pointer_kind(dst, ctx).map_err(|_| CastError::Unknown)?;
 
         match (src_kind, dst_kind) {
             (Some(PointerKind::Error), _) | (_, Some(PointerKind::Error)) => Ok(()),
@@ -285,9 +301,9 @@ impl CastCheck {
                             return Ok(());
                         }
                         let src_principal =
-                            table.db.trait_signature(from_chalk_trait_id(src_principal));
+                            ctx.db.trait_signature(from_chalk_trait_id(src_principal));
                         let dst_principal =
-                            table.db.trait_signature(from_chalk_trait_id(dst_principal));
+                            ctx.db.trait_signature(from_chalk_trait_id(dst_principal));
                         if src_principal.flags.contains(TraitFlags::AUTO)
                             && dst_principal.flags.contains(TraitFlags::AUTO)
                         {
@@ -306,10 +322,10 @@ impl CastCheck {
 
     fn check_ptr_addr_cast(
         &self,
-        table: &mut InferenceTable<'_>,
+        ctx: &mut InferenceContext<'_>,
         expr_ty: &Ty,
     ) -> Result<(), CastError> {
-        match pointer_kind(expr_ty, table).map_err(|_| CastError::Unknown)? {
+        match pointer_kind(expr_ty, ctx).map_err(|_| CastError::Unknown)? {
             // None => Err(CastError::UnknownExprPtrKind),
             None => Ok(()),
             Some(PointerKind::Error) => Ok(()),
@@ -320,10 +336,10 @@ impl CastCheck {
 
     fn check_addr_ptr_cast(
         &self,
-        table: &mut InferenceTable<'_>,
+        ctx: &mut InferenceContext<'_>,
         cast_ty: &Ty,
     ) -> Result<(), CastError> {
-        match pointer_kind(cast_ty, table).map_err(|_| CastError::Unknown)? {
+        match pointer_kind(cast_ty, ctx).map_err(|_| CastError::Unknown)? {
             // None => Err(CastError::UnknownCastPtrKind),
             None => Ok(()),
             Some(PointerKind::Error) => Ok(()),
@@ -336,10 +352,10 @@ impl CastCheck {
 
     fn check_fptr_ptr_cast(
         &self,
-        table: &mut InferenceTable<'_>,
+        ctx: &mut InferenceContext<'_>,
         cast_ty: &Ty,
     ) -> Result<(), CastError> {
-        match pointer_kind(cast_ty, table).map_err(|_| CastError::Unknown)? {
+        match pointer_kind(cast_ty, ctx).map_err(|_| CastError::Unknown)? {
             // None => Err(CastError::UnknownCastPtrKind),
             None => Ok(()),
             Some(PointerKind::Error) => Ok(()),
@@ -362,10 +378,10 @@ enum PointerKind {
     Error,
 }
 
-fn pointer_kind(ty: &Ty, table: &mut InferenceTable<'_>) -> Result<Option<PointerKind>, ()> {
-    let ty = table.eagerly_normalize_and_resolve_shallow_in(ty.clone());
+fn pointer_kind(ty: &Ty, ctx: &mut InferenceContext<'_>) -> Result<Option<PointerKind>, ()> {
+    let ty = ctx.table.eagerly_normalize_and_resolve_shallow_in(ty.clone());
 
-    if table.is_sized(&ty) {
+    if ctx.table.is_sized(&ty) {
         return Ok(Some(PointerKind::Thin));
     }
 
@@ -378,11 +394,11 @@ fn pointer_kind(ty: &Ty, table: &mut InferenceTable<'_>) -> Result<Option<Pointe
                 return Err(());
             };
 
-            let struct_data = id.fields(table.db);
+            let struct_data = id.fields(ctx.db);
             if let Some((last_field, _)) = struct_data.fields().iter().last() {
                 let last_field_ty =
-                    table.db.field_types(id.into())[last_field].clone().substitute(Interner, subst);
-                pointer_kind(&last_field_ty, table)
+                    ctx.db.field_types(id.into())[last_field].clone().substitute(Interner, subst);
+                pointer_kind(&last_field_ty, ctx)
             } else {
                 Ok(Some(PointerKind::Thin))
             }
@@ -390,7 +406,7 @@ fn pointer_kind(ty: &Ty, table: &mut InferenceTable<'_>) -> Result<Option<Pointe
         TyKind::Tuple(_, subst) => {
             match subst.iter(Interner).last().and_then(|arg| arg.ty(Interner)) {
                 None => Ok(Some(PointerKind::Thin)),
-                Some(ty) => pointer_kind(ty, table),
+                Some(ty) => pointer_kind(ty, ctx),
             }
         }
         TyKind::Foreign(_) => Ok(Some(PointerKind::Thin)),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
index fd7e5a6a0e121..1d5d8dd13edd4 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
@@ -1,143 +1,168 @@
 //! Inference of closure parameter types based on the closure's expected type.
 
-use std::{cmp, convert::Infallible, mem, ops::ControlFlow};
+pub(crate) mod analysis;
+
+use std::ops::ControlFlow;
+use std::{iter, mem};
 
-use chalk_ir::{
-    BoundVar, DebruijnIndex, FnSubst, GenericArg, Mutability, TyKind,
-    cast::Cast,
-    fold::{FallibleTypeFolder, Shift, TypeFoldable},
-    visit::{TypeSuperVisitable, TypeVisitable, TypeVisitor},
-};
-use either::Either;
 use hir_def::{
-    DefWithBodyId, FieldId, HasModule, TupleFieldId, TupleId, VariantId,
-    expr_store::path::Path,
-    hir::{
-        Array, AsmOperand, BinaryOp, BindingId, CaptureBy, ClosureKind, Expr, ExprId, ExprOrPatId,
-        Pat, PatId, Statement, UnaryOp,
-    },
-    item_tree::FieldsShape,
+    TraitId,
+    hir::{ClosureKind, ExprId, PatId},
     lang_item::LangItem,
-    resolver::ValueNs,
     type_ref::TypeRefId,
 };
-use hir_def::{ItemContainerId, Lookup, TraitId};
-use hir_expand::name::Name;
-use intern::sym;
-use rustc_hash::{FxHashMap, FxHashSet};
-use smallvec::{SmallVec, smallvec};
-use stdx::{format_to, never};
-use syntax::utils::is_raw_identifier;
+use rustc_type_ir::{
+    ClosureArgs, ClosureArgsParts, CoroutineArgs, CoroutineArgsParts, Interner, TypeSuperVisitable,
+    TypeVisitable, TypeVisitableExt, TypeVisitor,
+    inherent::{BoundExistentialPredicates, GenericArgs as _, IntoKind, SliceLike, Ty as _},
+};
+use tracing::debug;
 
+use crate::traits::FnTrait;
 use crate::{
-    Adjust, Adjustment, AliasEq, AliasTy, Binders, BindingMode, ClosureId, DynTy, DynTyExt, FnAbi,
-    FnPointer, FnSig, Interner, OpaqueTy, ProjectionTy, ProjectionTyExt, Substitution, Ty,
-    TyBuilder, TyExt, WhereClause,
-    db::{HirDatabase, InternedClosure, InternedCoroutine},
-    error_lifetime, from_assoc_type_id, from_chalk_trait_id, from_placeholder_idx,
-    generics::Generics,
-    infer::{BreakableKind, CoerceMany, Diverges, coerce::CoerceNever},
-    make_binders,
-    mir::{BorrowKind, MirSpan, MutBorrowKind, ProjectionElem},
-    next_solver::mapping::ChalkToNextSolver,
-    to_assoc_type_id,
-    traits::FnTrait,
-    utils::{self, elaborate_clause_supertraits},
+    FnAbi,
+    db::{InternedClosure, InternedCoroutine},
+    infer::{BreakableKind, Diverges, coerce::CoerceMany},
+    next_solver::{
+        AliasTy, Binder, ClauseKind, DbInterner, ErrorGuaranteed, FnSig, GenericArgs, PolyFnSig,
+        PolyProjectionPredicate, Predicate, PredicateKind, SolverDefId, Ty, TyKind,
+        abi::Safety,
+        infer::{
+            BoundRegionConversionTime, DefineOpaqueTypes, InferOk, InferResult,
+            traits::{ObligationCause, PredicateObligations},
+        },
+        mapping::{ChalkToNextSolver, NextSolverToChalk},
+        util::explicit_item_bounds,
+    },
 };
 
 use super::{Expectation, InferenceContext};
 
 #[derive(Debug)]
-pub(super) struct ClosureSignature {
-    pub(super) ret_ty: Ty,
-    pub(super) expected_sig: FnPointer,
+struct ClosureSignatures<'tcx> {
+    /// The signature users of the closure see.
+    bound_sig: PolyFnSig<'tcx>,
+    /// The signature within the function body.
+    /// This mostly differs in the sense that lifetimes are now early bound and any
+    /// opaque types from the signature expectation are overridden in case there are
+    /// explicit hidden types written by the user in the closure signature.
+    liberated_sig: FnSig<'tcx>,
 }
 
 impl<'db> InferenceContext<'db> {
     pub(super) fn infer_closure(
         &mut self,
-        body: &ExprId,
+        body: ExprId,
         args: &[PatId],
-        ret_type: &Option<TypeRefId>,
+        ret_type: Option<TypeRefId>,
         arg_types: &[Option<TypeRefId>],
         closure_kind: ClosureKind,
         tgt_expr: ExprId,
         expected: &Expectation,
-    ) -> Ty {
+    ) -> crate::Ty {
         assert_eq!(args.len(), arg_types.len());
 
+        let interner = self.table.interner;
         let (expected_sig, expected_kind) = match expected.to_option(&mut self.table) {
-            Some(expected_ty) => self.deduce_closure_signature(&expected_ty, closure_kind),
+            Some(expected_ty) => {
+                self.deduce_closure_signature(expected_ty.to_nextsolver(interner), closure_kind)
+            }
             None => (None, None),
         };
 
-        let ClosureSignature { expected_sig: mut bound_sig, ret_ty: body_ret_ty } =
-            self.sig_of_closure(body, ret_type, arg_types, closure_kind, expected_sig);
-        bound_sig.substitution.0 = self
-            .normalize_associated_types_in::<_, crate::next_solver::GenericArgs<'db>>(
-                bound_sig.substitution.0,
-            );
-        let bound_sig = bound_sig;
-        let sig_ty = TyKind::Function(bound_sig.clone()).intern(Interner);
+        let ClosureSignatures { bound_sig, liberated_sig } =
+            self.sig_of_closure(arg_types, ret_type, expected_sig);
+        let body_ret_ty = bound_sig.output().skip_binder();
+        let sig_ty = Ty::new_fn_ptr(interner, bound_sig);
 
+        let parent_args = GenericArgs::identity_for_item(interner, self.generic_def.into());
         let (id, ty, resume_yield_tys) = match closure_kind {
             ClosureKind::Coroutine(_) => {
-                let sig_tys = bound_sig.substitution.0.as_slice(Interner);
-                // FIXME: report error when there are more than 1 parameter.
-                let resume_ty = match sig_tys.first() {
-                    // When `sig_tys.len() == 1` the first type is the return type, not the
-                    // first parameter type.
-                    Some(ty) if sig_tys.len() > 1 => ty.assert_ty_ref(Interner).clone(),
-                    _ => self.result.standard_types.unit.clone(),
+                let yield_ty = self.table.next_ty_var();
+                let resume_ty = liberated_sig
+                    .inputs()
+                    .get(0)
+                    .unwrap_or(self.result.standard_types.unit.to_nextsolver(interner));
+
+                // FIXME: Infer the upvars later.
+                let parts = CoroutineArgsParts {
+                    parent_args,
+                    kind_ty: Ty::new_unit(interner),
+                    resume_ty,
+                    yield_ty,
+                    return_ty: body_ret_ty,
+                    tupled_upvars_ty: Ty::new_unit(interner),
                 };
-                let yield_ty = self.table.new_type_var();
-
-                let subst = TyBuilder::subst_for_coroutine(self.db, self.owner)
-                    .push(resume_ty.clone())
-                    .push(yield_ty.clone())
-                    .push(body_ret_ty.clone())
-                    .build();
 
                 let coroutine_id =
                     self.db.intern_coroutine(InternedCoroutine(self.owner, tgt_expr)).into();
-                let coroutine_ty = TyKind::Coroutine(coroutine_id, subst).intern(Interner);
+                let coroutine_ty = Ty::new_coroutine(
+                    interner,
+                    coroutine_id,
+                    CoroutineArgs::new(interner, parts).args,
+                );
 
-                (None, coroutine_ty, Some((resume_ty, yield_ty)))
+                (
+                    None,
+                    coroutine_ty,
+                    Some((resume_ty.to_chalk(interner), yield_ty.to_chalk(interner))),
+                )
             }
+            // FIXME(next-solver): `ClosureKind::Async` should really be a separate arm that creates a `CoroutineClosure`.
+            // But for now we treat it as a closure.
             ClosureKind::Closure | ClosureKind::Async => {
-                let closure_id =
-                    self.db.intern_closure(InternedClosure(self.owner, tgt_expr)).into();
-                let closure_ty = TyKind::Closure(
-                    closure_id,
-                    TyBuilder::subst_for_closure(self.db, self.owner, sig_ty.clone()),
-                )
-                .intern(Interner);
+                let closure_id = self.db.intern_closure(InternedClosure(self.owner, tgt_expr));
+                match expected_kind {
+                    Some(kind) => {
+                        self.result.closure_info.insert(
+                            closure_id.into(),
+                            (
+                                Vec::new(),
+                                match kind {
+                                    rustc_type_ir::ClosureKind::Fn => FnTrait::Fn,
+                                    rustc_type_ir::ClosureKind::FnMut => FnTrait::FnMut,
+                                    rustc_type_ir::ClosureKind::FnOnce => FnTrait::FnOnce,
+                                },
+                            ),
+                        );
+                    }
+                    None => {}
+                };
+                // FIXME: Infer the kind and the upvars later when needed.
+                let parts = ClosureArgsParts {
+                    parent_args,
+                    closure_kind_ty: Ty::from_closure_kind(
+                        interner,
+                        expected_kind.unwrap_or(rustc_type_ir::ClosureKind::Fn),
+                    ),
+                    closure_sig_as_fn_ptr_ty: sig_ty,
+                    tupled_upvars_ty: Ty::new_unit(interner),
+                };
+                let closure_ty = Ty::new_closure(
+                    interner,
+                    closure_id.into(),
+                    ClosureArgs::new(interner, parts).args,
+                );
                 self.deferred_closures.entry(closure_id).or_default();
                 self.add_current_closure_dependency(closure_id);
                 (Some(closure_id), closure_ty, None)
             }
         };
 
-        // Eagerly try to relate the closure type with the expected
-        // type, otherwise we often won't have enough information to
-        // infer the body.
-        self.deduce_closure_type_from_expectations(tgt_expr, &ty, &sig_ty, expected, expected_kind);
-
         // Now go through the argument patterns
-        for (arg_pat, arg_ty) in args.iter().zip(bound_sig.substitution.0.as_slice(Interner).iter())
-        {
-            self.infer_top_pat(*arg_pat, arg_ty.assert_ty_ref(Interner), None);
+        for (arg_pat, arg_ty) in args.iter().zip(bound_sig.skip_binder().inputs()) {
+            self.infer_top_pat(*arg_pat, &arg_ty.to_chalk(interner), None);
         }
 
         // FIXME: lift these out into a struct
         let prev_diverges = mem::replace(&mut self.diverges, Diverges::Maybe);
         let prev_closure = mem::replace(&mut self.current_closure, id);
-        let prev_ret_ty = mem::replace(&mut self.return_ty, body_ret_ty.clone());
+        let prev_ret_ty = mem::replace(&mut self.return_ty, body_ret_ty.to_chalk(interner));
         let prev_ret_coercion = self.return_coercion.replace(CoerceMany::new(body_ret_ty));
         let prev_resume_yield_tys = mem::replace(&mut self.resume_yield_tys, resume_yield_tys);
 
         self.with_breakable_ctx(BreakableKind::Border, None, None, |this| {
-            this.infer_return(*body);
+            this.infer_return(body);
         });
 
         self.diverges = prev_diverges;
@@ -146,1696 +171,644 @@ impl<'db> InferenceContext<'db> {
         self.current_closure = prev_closure;
         self.resume_yield_tys = prev_resume_yield_tys;
 
-        self.table.normalize_associated_types_in(ty)
+        ty.to_chalk(interner)
     }
 
-    // This function handles both closures and coroutines.
-    pub(super) fn deduce_closure_type_from_expectations(
-        &mut self,
-        closure_expr: ExprId,
-        closure_ty: &Ty,
-        sig_ty: &Ty,
-        expectation: &Expectation,
-        expected_kind: Option<FnTrait>,
-    ) {
-        let expected_ty = match expectation.to_option(&mut self.table) {
-            Some(ty) => ty,
-            None => return,
-        };
-
-        match (closure_ty.kind(Interner), expected_kind) {
-            (TyKind::Closure(closure_id, _), Some(closure_kind)) => {
-                self.result
-                    .closure_info
-                    .entry(*closure_id)
-                    .or_insert_with(|| (Vec::new(), closure_kind));
-            }
-            _ => {}
-        }
-
-        // Deduction from where-clauses in scope, as well as fn-pointer coercion are handled here.
-        let _ = self.coerce(Some(closure_expr), closure_ty, &expected_ty, CoerceNever::Yes);
-
-        // Coroutines are not Fn* so return early.
-        if matches!(closure_ty.kind(Interner), TyKind::Coroutine(..)) {
-            return;
+    fn fn_trait_kind_from_def_id(&self, trait_id: TraitId) -> Option<rustc_type_ir::ClosureKind> {
+        let lang_item = self.db.lang_attr(trait_id.into())?;
+        match lang_item {
+            LangItem::Fn => Some(rustc_type_ir::ClosureKind::Fn),
+            LangItem::FnMut => Some(rustc_type_ir::ClosureKind::FnMut),
+            LangItem::FnOnce => Some(rustc_type_ir::ClosureKind::FnOnce),
+            _ => None,
         }
+    }
 
-        // Deduction based on the expected `dyn Fn` is done separately.
-        if let TyKind::Dyn(dyn_ty) = expected_ty.kind(Interner)
-            && let Some(sig) = self.deduce_sig_from_dyn_ty(dyn_ty)
-        {
-            let expected_sig_ty = TyKind::Function(sig).intern(Interner);
-
-            self.unify(sig_ty, &expected_sig_ty);
+    fn async_fn_trait_kind_from_def_id(
+        &self,
+        trait_id: TraitId,
+    ) -> Option<rustc_type_ir::ClosureKind> {
+        let lang_item = self.db.lang_attr(trait_id.into())?;
+        match lang_item {
+            LangItem::AsyncFn => Some(rustc_type_ir::ClosureKind::Fn),
+            LangItem::AsyncFnMut => Some(rustc_type_ir::ClosureKind::FnMut),
+            LangItem::AsyncFnOnce => Some(rustc_type_ir::ClosureKind::FnOnce),
+            _ => None,
         }
     }
 
-    // Closure kind deductions are mostly from `rustc_hir_typeck/src/closure.rs`.
-    // Might need to port closure sig deductions too.
-    pub(super) fn deduce_closure_signature(
+    /// Given the expected type, figures out what it can about this closure we
+    /// are about to type check:
+    fn deduce_closure_signature(
         &mut self,
-        expected_ty: &Ty,
+        expected_ty: Ty<'db>,
         closure_kind: ClosureKind,
-    ) -> (Option<FnSubst<Interner>>, Option<FnTrait>) {
-        match expected_ty.kind(Interner) {
-            TyKind::Alias(AliasTy::Opaque(OpaqueTy { .. })) | TyKind::OpaqueType(..) => {
-                let clauses = expected_ty.impl_trait_bounds(self.db).into_iter().flatten().map(
-                    |b: chalk_ir::Binders<chalk_ir::WhereClause<Interner>>| {
-                        b.into_value_and_skipped_binders().0
-                    },
-                );
-                self.deduce_closure_kind_from_predicate_clauses(expected_ty, clauses, closure_kind)
-            }
-            TyKind::Dyn(dyn_ty) => {
-                let sig =
-                    dyn_ty.bounds.skip_binders().as_slice(Interner).iter().find_map(|bound| {
-                        if let WhereClause::AliasEq(AliasEq {
-                            alias: AliasTy::Projection(projection_ty),
-                            ty: projected_ty,
-                        }) = bound.skip_binders()
-                            && let Some(sig) = self.deduce_sig_from_projection(
-                                closure_kind,
-                                projection_ty,
-                                projected_ty,
-                            )
-                        {
-                            return Some(sig);
-                        }
-                        None
-                    });
-
-                let kind = dyn_ty.principal().and_then(|principal_trait_ref| {
-                    self.fn_trait_kind_from_trait_id(from_chalk_trait_id(
-                        principal_trait_ref.skip_binders().skip_binders().trait_id,
-                    ))
+    ) -> (Option<PolyFnSig<'db>>, Option<rustc_type_ir::ClosureKind>) {
+        match expected_ty.kind() {
+            TyKind::Alias(rustc_type_ir::Opaque, AliasTy { def_id, args, .. }) => self
+                .deduce_closure_signature_from_predicates(
+                    expected_ty,
+                    closure_kind,
+                    explicit_item_bounds(self.table.interner, def_id)
+                        .iter_instantiated(self.table.interner, args)
+                        .map(|clause| clause.as_predicate()),
+                ),
+            TyKind::Dynamic(object_type, ..) => {
+                let sig = object_type.projection_bounds().into_iter().find_map(|pb| {
+                    let pb =
+                        pb.with_self_ty(self.table.interner, Ty::new_unit(self.table.interner));
+                    self.deduce_sig_from_projection(closure_kind, pb)
                 });
-
+                let kind = object_type
+                    .principal_def_id()
+                    .and_then(|did| self.fn_trait_kind_from_def_id(did.0));
                 (sig, kind)
             }
-            TyKind::InferenceVar(ty, chalk_ir::TyVariableKind::General) => {
-                let clauses = self.clauses_for_self_ty(*ty);
-                self.deduce_closure_kind_from_predicate_clauses(
-                    expected_ty,
-                    clauses.into_iter(),
+            TyKind::Infer(rustc_type_ir::TyVar(vid)) => self
+                .deduce_closure_signature_from_predicates(
+                    Ty::new_var(self.table.interner, self.table.infer_ctxt.root_var(vid)),
                     closure_kind,
-                )
-            }
-            TyKind::Function(fn_ptr) => match closure_kind {
-                ClosureKind::Closure => (Some(fn_ptr.substitution.clone()), Some(FnTrait::Fn)),
-                ClosureKind::Async | ClosureKind::Coroutine(_) => (None, None),
+                    self.table.obligations_for_self_ty(vid).into_iter().map(|obl| obl.predicate),
+                ),
+            TyKind::FnPtr(sig_tys, hdr) => match closure_kind {
+                ClosureKind::Closure => {
+                    let expected_sig = sig_tys.with(hdr);
+                    (Some(expected_sig), Some(rustc_type_ir::ClosureKind::Fn))
+                }
+                ClosureKind::Coroutine(_) | ClosureKind::Async => (None, None),
             },
             _ => (None, None),
         }
     }
 
-    fn deduce_closure_kind_from_predicate_clauses(
+    fn deduce_closure_signature_from_predicates(
         &mut self,
-        expected_ty: &Ty,
-        clauses: impl DoubleEndedIterator<Item = WhereClause>,
+        expected_ty: Ty<'db>,
         closure_kind: ClosureKind,
-    ) -> (Option<FnSubst<Interner>>, Option<FnTrait>) {
+        predicates: impl DoubleEndedIterator<Item = Predicate<'db>>,
+    ) -> (Option<PolyFnSig<'db>>, Option<rustc_type_ir::ClosureKind>) {
         let mut expected_sig = None;
         let mut expected_kind = None;
 
-        for clause in elaborate_clause_supertraits(self.db, clauses.rev()) {
+        for pred in rustc_type_ir::elaborate::elaborate(
+            self.table.interner,
+            // Reverse the obligations here, since `elaborate_*` uses a stack,
+            // and we want to keep inference generally in the same order of
+            // the registered obligations.
+            predicates.rev(),
+        )
+        // We only care about self bounds
+        .filter_only_self()
+        {
+            debug!(?pred);
+            let bound_predicate = pred.kind();
+
+            // Given a Projection predicate, we can potentially infer
+            // the complete signature.
             if expected_sig.is_none()
-                && let WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(projection), ty }) =
-                    &clause
+                && let PredicateKind::Clause(ClauseKind::Projection(proj_predicate)) =
+                    bound_predicate.skip_binder()
             {
-                let inferred_sig = self.deduce_sig_from_projection(closure_kind, projection, ty);
+                let inferred_sig = self.deduce_sig_from_projection(
+                    closure_kind,
+                    bound_predicate.rebind(proj_predicate),
+                );
+
                 // Make sure that we didn't infer a signature that mentions itself.
                 // This can happen when we elaborate certain supertrait bounds that
-                // mention projections containing the `Self` type. See rust-lang/rust#105401.
-                struct MentionsTy<'a> {
-                    expected_ty: &'a Ty,
+                // mention projections containing the `Self` type. See #105401.
+                struct MentionsTy<'db> {
+                    expected_ty: Ty<'db>,
                 }
-                impl TypeVisitor<Interner> for MentionsTy<'_> {
-                    type BreakTy = ();
-
-                    fn interner(&self) -> Interner {
-                        Interner
-                    }
+                impl<'db> TypeVisitor<DbInterner<'db>> for MentionsTy<'db> {
+                    type Result = ControlFlow<()>;
 
-                    fn as_dyn(
-                        &mut self,
-                    ) -> &mut dyn TypeVisitor<Interner, BreakTy = Self::BreakTy>
-                    {
-                        self
-                    }
-
-                    fn visit_ty(&mut self, t: &Ty, db: chalk_ir::DebruijnIndex) -> ControlFlow<()> {
+                    fn visit_ty(&mut self, t: Ty<'db>) -> Self::Result {
                         if t == self.expected_ty {
                             ControlFlow::Break(())
                         } else {
-                            t.super_visit_with(self, db)
+                            t.super_visit_with(self)
                         }
                     }
                 }
-                if inferred_sig
-                    .visit_with(&mut MentionsTy { expected_ty }, chalk_ir::DebruijnIndex::INNERMOST)
-                    .is_continue()
-                {
-                    expected_sig = inferred_sig;
-                }
-            }
 
-            let trait_id = match clause {
-                WhereClause::AliasEq(AliasEq {
-                    alias: AliasTy::Projection(projection), ..
-                }) => projection.trait_(self.db),
-                WhereClause::Implemented(trait_ref) => from_chalk_trait_id(trait_ref.trait_id),
-                _ => continue,
-            };
-            if let Some(closure_kind) = self.fn_trait_kind_from_trait_id(trait_id) {
-                // always use the closure kind that is more permissive.
-                match (expected_kind, closure_kind) {
-                    (None, _) => expected_kind = Some(closure_kind),
-                    (Some(FnTrait::FnMut), FnTrait::Fn) => expected_kind = Some(FnTrait::Fn),
-                    (Some(FnTrait::FnOnce), FnTrait::Fn | FnTrait::FnMut) => {
-                        expected_kind = Some(closure_kind)
+                // Don't infer a closure signature from a goal that names the closure type as this will
+                // (almost always) lead to occurs check errors later in type checking.
+                if let Some(inferred_sig) = inferred_sig {
+                    // In the new solver it is difficult to explicitly normalize the inferred signature as we
+                    // would have to manually handle universes and rewriting bound vars and placeholders back
+                    // and forth.
+                    //
+                    // Instead we take advantage of the fact that we relating an inference variable with an alias
+                    // will only instantiate the variable if the alias is rigid(*not quite). Concretely we:
+                    // - Create some new variable `?sig`
+                    // - Equate `?sig` with the unnormalized signature, e.g. `fn(<Foo<?x> as Trait>::Assoc)`
+                    // - Depending on whether `<Foo<?x> as Trait>::Assoc` is rigid, ambiguous or normalizeable,
+                    //   we will either wind up with `?sig=<Foo<?x> as Trait>::Assoc/?y/ConcreteTy` respectively.
+                    //
+                    // *: In cases where there are ambiguous aliases in the signature that make use of bound vars
+                    //    they will wind up present in `?sig` even though they are non-rigid.
+                    //
+                    //    This is a bit weird and means we may wind up discarding the goal due to it naming `expected_ty`
+                    //    even though the normalized form may not name `expected_ty`. However, this matches the existing
+                    //    behaviour of the old solver and would be technically a breaking change to fix.
+                    let generalized_fnptr_sig = self.table.next_ty_var();
+                    let inferred_fnptr_sig = Ty::new_fn_ptr(self.table.interner, inferred_sig);
+                    // FIXME: Report diagnostics.
+                    _ = self
+                        .table
+                        .infer_ctxt
+                        .at(&ObligationCause::new(), self.table.param_env)
+                        .eq(DefineOpaqueTypes::Yes, inferred_fnptr_sig, generalized_fnptr_sig)
+                        .map(|infer_ok| self.table.register_infer_ok(infer_ok));
+
+                    let resolved_sig =
+                        self.table.infer_ctxt.resolve_vars_if_possible(generalized_fnptr_sig);
+
+                    if resolved_sig.visit_with(&mut MentionsTy { expected_ty }).is_continue() {
+                        expected_sig = Some(resolved_sig.fn_sig(self.table.interner));
                     }
-                    _ => {}
+                } else if inferred_sig.visit_with(&mut MentionsTy { expected_ty }).is_continue() {
+                    expected_sig = inferred_sig;
                 }
             }
-        }
-
-        (expected_sig, expected_kind)
-    }
-
-    fn deduce_sig_from_dyn_ty(&self, dyn_ty: &DynTy) -> Option<FnPointer> {
-        // Search for a predicate like `<$self as FnX<Args>>::Output == Ret`
 
-        let fn_traits: SmallVec<[TraitId; 3]> =
-            utils::fn_traits(self.db, self.owner.module(self.db).krate()).collect();
-
-        let self_ty = self.result.standard_types.unknown.clone();
-        let bounds = dyn_ty.bounds.clone().substitute(Interner, &[self_ty.cast(Interner)]);
-        for bound in bounds.iter(Interner) {
-            // NOTE(skip_binders): the extracted types are rebound by the returned `FnPointer`
-            if let WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(projection), ty }) =
-                bound.skip_binders()
-            {
-                let trait_ =
-                    match from_assoc_type_id(projection.associated_ty_id).lookup(self.db).container
-                    {
-                        ItemContainerId::TraitId(t) => t,
-                        _ => panic!("associated type not in trait"),
-                    };
-                if !fn_traits.contains(&trait_) {
-                    return None;
+            // Even if we can't infer the full signature, we may be able to
+            // infer the kind. This can occur when we elaborate a predicate
+            // like `F : Fn<A>`. Note that due to subtyping we could encounter
+            // many viable options, so pick the most restrictive.
+            let trait_def_id = match bound_predicate.skip_binder() {
+                PredicateKind::Clause(ClauseKind::Projection(data)) => {
+                    Some(data.projection_term.trait_def_id(self.table.interner).0)
                 }
+                PredicateKind::Clause(ClauseKind::Trait(data)) => Some(data.def_id().0),
+                _ => None,
+            };
+
+            if let Some(trait_def_id) = trait_def_id {
+                let found_kind = match closure_kind {
+                    ClosureKind::Closure => self.fn_trait_kind_from_def_id(trait_def_id),
+                    ClosureKind::Async => self
+                        .async_fn_trait_kind_from_def_id(trait_def_id)
+                        .or_else(|| self.fn_trait_kind_from_def_id(trait_def_id)),
+                    _ => None,
+                };
 
-                // Skip `Self`, get the type argument.
-                let arg = projection.substitution.as_slice(Interner).get(1)?;
-                if let Some(subst) = arg.ty(Interner)?.as_tuple() {
-                    let generic_args = subst.as_slice(Interner);
-                    let mut sig_tys = Vec::with_capacity(generic_args.len() + 1);
-                    for arg in generic_args {
-                        sig_tys.push(arg.ty(Interner)?.clone());
+                if let Some(found_kind) = found_kind {
+                    // always use the closure kind that is more permissive.
+                    match (expected_kind, found_kind) {
+                        (None, _) => expected_kind = Some(found_kind),
+                        (
+                            Some(rustc_type_ir::ClosureKind::FnMut),
+                            rustc_type_ir::ClosureKind::Fn,
+                        ) => expected_kind = Some(rustc_type_ir::ClosureKind::Fn),
+                        (
+                            Some(rustc_type_ir::ClosureKind::FnOnce),
+                            rustc_type_ir::ClosureKind::Fn | rustc_type_ir::ClosureKind::FnMut,
+                        ) => expected_kind = Some(found_kind),
+                        _ => {}
                     }
-                    sig_tys.push(ty.clone());
-
-                    cov_mark::hit!(dyn_fn_param_informs_call_site_closure_signature);
-                    return Some(FnPointer {
-                        num_binders: bound.len(Interner),
-                        sig: FnSig {
-                            abi: FnAbi::RustCall,
-                            safety: chalk_ir::Safety::Safe,
-                            variadic: false,
-                        },
-                        substitution: FnSubst(Substitution::from_iter(Interner, sig_tys)),
-                    });
                 }
             }
         }
 
-        None
+        (expected_sig, expected_kind)
     }
 
+    /// Given a projection like "<F as Fn(X)>::Result == Y", we can deduce
+    /// everything we need to know about a closure or coroutine.
+    ///
+    /// The `cause_span` should be the span that caused us to
+    /// have this expected signature, or `None` if we can't readily
+    /// know that.
     fn deduce_sig_from_projection(
         &mut self,
         closure_kind: ClosureKind,
-        projection_ty: &ProjectionTy,
-        projected_ty: &Ty,
-    ) -> Option<FnSubst<Interner>> {
-        let container =
-            from_assoc_type_id(projection_ty.associated_ty_id).lookup(self.db).container;
-        let trait_ = match container {
-            hir_def::ItemContainerId::TraitId(trait_) => trait_,
-            _ => return None,
-        };
+        projection: PolyProjectionPredicate<'db>,
+    ) -> Option<PolyFnSig<'db>> {
+        let SolverDefId::TypeAliasId(def_id) = projection.item_def_id() else { unreachable!() };
+        let lang_item = self.db.lang_attr(def_id.into());
 
         // For now, we only do signature deduction based off of the `Fn` and `AsyncFn` traits,
         // for closures and async closures, respectively.
-        let fn_trait_kind = self.fn_trait_kind_from_trait_id(trait_)?;
-        if !matches!(closure_kind, ClosureKind::Closure | ClosureKind::Async) {
-            return None;
-        }
-        if fn_trait_kind.is_async() {
-            // If the expected trait is `AsyncFn(...) -> X`, we don't know what the return type is,
-            // but we do know it must implement `Future<Output = X>`.
-            self.extract_async_fn_sig_from_projection(projection_ty, projected_ty)
-        } else {
-            self.extract_sig_from_projection(projection_ty, projected_ty)
+        match closure_kind {
+            ClosureKind::Closure if lang_item == Some(LangItem::FnOnceOutput) => {
+                self.extract_sig_from_projection(projection)
+            }
+            ClosureKind::Async if lang_item == Some(LangItem::AsyncFnOnceOutput) => {
+                self.extract_sig_from_projection(projection)
+            }
+            // It's possible we've passed the closure to a (somewhat out-of-fashion)
+            // `F: FnOnce() -> Fut, Fut: Future<Output = T>` style bound. Let's still
+            // guide inference here, since it's beneficial for the user.
+            ClosureKind::Async if lang_item == Some(LangItem::FnOnceOutput) => {
+                self.extract_sig_from_projection_and_future_bound(projection)
+            }
+            _ => None,
         }
     }
 
+    /// Given an `FnOnce::Output` or `AsyncFn::Output` projection, extract the args
+    /// and return type to infer a [`ty::PolyFnSig`] for the closure.
     fn extract_sig_from_projection(
         &self,
-        projection_ty: &ProjectionTy,
-        projected_ty: &Ty,
-    ) -> Option<FnSubst<Interner>> {
-        let arg_param_ty = projection_ty.substitution.as_slice(Interner)[1].assert_ty_ref(Interner);
-
-        let TyKind::Tuple(_, input_tys) = arg_param_ty.kind(Interner) else {
-            return None;
-        };
+        projection: PolyProjectionPredicate<'db>,
+    ) -> Option<PolyFnSig<'db>> {
+        let projection = self.table.infer_ctxt.resolve_vars_if_possible(projection);
 
-        let ret_param_ty = projected_ty;
+        let arg_param_ty = projection.skip_binder().projection_term.args.type_at(1);
+        debug!(?arg_param_ty);
 
-        Some(FnSubst(Substitution::from_iter(
-            Interner,
-            input_tys.iter(Interner).map(|t| t.cast(Interner)).chain(Some(GenericArg::new(
-                Interner,
-                chalk_ir::GenericArgData::Ty(ret_param_ty.clone()),
-            ))),
-        )))
-    }
-
-    fn extract_async_fn_sig_from_projection(
-        &mut self,
-        projection_ty: &ProjectionTy,
-        projected_ty: &Ty,
-    ) -> Option<FnSubst<Interner>> {
-        let arg_param_ty = projection_ty.substitution.as_slice(Interner)[1].assert_ty_ref(Interner);
-
-        let TyKind::Tuple(_, input_tys) = arg_param_ty.kind(Interner) else {
+        let TyKind::Tuple(input_tys) = arg_param_ty.kind() else {
             return None;
         };
 
-        let ret_param_future_output = projected_ty;
-        let ret_param_future = self.table.new_type_var();
-        let future_output =
-            LangItem::FutureOutput.resolve_type_alias(self.db, self.resolver.krate())?;
-        let future_projection = crate::AliasTy::Projection(crate::ProjectionTy {
-            associated_ty_id: to_assoc_type_id(future_output),
-            substitution: Substitution::from1(Interner, ret_param_future.clone()),
-        });
-        let goal: crate::Goal =
-            crate::AliasEq { alias: future_projection, ty: ret_param_future_output.clone() }
-                .cast(Interner);
-        self.table.register_obligation(goal.to_nextsolver(self.table.interner));
-
-        Some(FnSubst(Substitution::from_iter(
-            Interner,
-            input_tys.iter(Interner).map(|t| t.cast(Interner)).chain(Some(GenericArg::new(
-                Interner,
-                chalk_ir::GenericArgData::Ty(ret_param_future),
-            ))),
-        )))
-    }
+        // Since this is a return parameter type it is safe to unwrap.
+        let ret_param_ty = projection.skip_binder().term.expect_type();
+        debug!(?ret_param_ty);
+
+        let sig = projection.rebind(self.table.interner.mk_fn_sig(
+            input_tys,
+            ret_param_ty,
+            false,
+            Safety::Safe,
+            FnAbi::Rust,
+        ));
 
-    fn fn_trait_kind_from_trait_id(&self, trait_id: hir_def::TraitId) -> Option<FnTrait> {
-        FnTrait::from_lang_item(self.db.lang_attr(trait_id.into())?)
+        Some(sig)
     }
 
-    fn supplied_sig_of_closure(
+    /// When an async closure is passed to a function that has a "two-part" `Fn`
+    /// and `Future` trait bound, like:
+    ///
+    /// ```rust
+    /// use std::future::Future;
+    ///
+    /// fn not_exactly_an_async_closure<F, Fut>(_f: F)
+    /// where
+    ///     F: FnOnce(String, u32) -> Fut,
+    ///     Fut: Future<Output = i32>,
+    /// {}
+    /// ```
+    ///
+    /// The we want to be able to extract the signature to guide inference in the async
+    /// closure. We will have two projection predicates registered in this case. First,
+    /// 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(
         &mut self,
-        body: &ExprId,
-        ret_type: &Option<TypeRefId>,
-        arg_types: &[Option<TypeRefId>],
-        closure_kind: ClosureKind,
-    ) -> ClosureSignature {
-        let mut sig_tys = Vec::with_capacity(arg_types.len() + 1);
-
-        // collect explicitly written argument types
-        for arg_type in arg_types.iter() {
-            let arg_ty = match arg_type {
-                // FIXME: I think rustc actually lowers closure params with `LifetimeElisionKind::AnonymousCreateParameter`
-                // (but the return type with infer).
-                Some(type_ref) => self.make_body_ty(*type_ref),
-                None => self.table.new_type_var(),
-            };
-            sig_tys.push(arg_ty);
-        }
+        projection: PolyProjectionPredicate<'db>,
+    ) -> Option<PolyFnSig<'db>> {
+        let projection = self.table.infer_ctxt.resolve_vars_if_possible(projection);
 
-        // add return type
-        let ret_ty = match ret_type {
-            Some(type_ref) => self.make_body_ty(*type_ref),
-            None => self.table.new_type_var(),
-        };
-        if let ClosureKind::Async = closure_kind {
-            sig_tys.push(self.lower_async_block_type_impl_trait(ret_ty.clone(), *body));
-        } else {
-            sig_tys.push(ret_ty.clone());
-        }
+        let arg_param_ty = projection.skip_binder().projection_term.args.type_at(1);
+        debug!(?arg_param_ty);
 
-        let expected_sig = FnPointer {
-            num_binders: 0,
-            sig: FnSig { abi: FnAbi::RustCall, safety: chalk_ir::Safety::Safe, variadic: false },
-            substitution: FnSubst(
-                Substitution::from_iter(Interner, sig_tys.iter().cloned()).shifted_in(Interner),
-            ),
+        let TyKind::Tuple(input_tys) = arg_param_ty.kind() else {
+            return None;
         };
 
-        ClosureSignature { ret_ty, expected_sig }
-    }
+        // If the return type is a type variable, look for bounds on it.
+        // We could theoretically support other kinds of return types here,
+        // but none of them would be useful, since async closures return
+        // concrete anonymous future types, and their futures are not coerced
+        // into any other type within the body of the async closure.
+        let TyKind::Infer(rustc_type_ir::TyVar(return_vid)) =
+            projection.skip_binder().term.expect_type().kind()
+        else {
+            return None;
+        };
 
-    /// The return type is the signature of the closure, and the return type
-    /// *as represented inside the body* (so, for async closures, the `Output` ty)
-    pub(super) fn sig_of_closure(
+        // FIXME: We may want to elaborate here, though I assume this will be exceedingly rare.
+        let mut return_ty = None;
+        for bound in self.table.obligations_for_self_ty(return_vid) {
+            if let PredicateKind::Clause(ClauseKind::Projection(ret_projection)) =
+                bound.predicate.kind().skip_binder()
+                && let ret_projection = bound.predicate.kind().rebind(ret_projection)
+                && let Some(ret_projection) = ret_projection.no_bound_vars()
+                && let SolverDefId::TypeAliasId(assoc_type) = ret_projection.def_id()
+                && self.db.lang_attr(assoc_type.into()) == Some(LangItem::FutureOutput)
+            {
+                return_ty = Some(ret_projection.term.expect_type());
+                break;
+            }
+        }
+
+        // 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.table.next_ty_var());
+
+        let sig = projection.rebind(self.table.interner.mk_fn_sig(
+            input_tys,
+            return_ty,
+            false,
+            Safety::Safe,
+            FnAbi::Rust,
+        ));
+
+        Some(sig)
+    }
+
+    fn sig_of_closure(
         &mut self,
-        body: &ExprId,
-        ret_type: &Option<TypeRefId>,
-        arg_types: &[Option<TypeRefId>],
-        closure_kind: ClosureKind,
-        expected_sig: Option<FnSubst<Interner>>,
-    ) -> ClosureSignature {
+        decl_inputs: &[Option<TypeRefId>],
+        decl_output: Option<TypeRefId>,
+        expected_sig: Option<PolyFnSig<'db>>,
+    ) -> ClosureSignatures<'db> {
         if let Some(e) = expected_sig {
-            self.sig_of_closure_with_expectation(body, ret_type, arg_types, closure_kind, e)
+            self.sig_of_closure_with_expectation(decl_inputs, decl_output, e)
         } else {
-            self.sig_of_closure_no_expectation(body, ret_type, arg_types, closure_kind)
+            self.sig_of_closure_no_expectation(decl_inputs, decl_output)
         }
     }
 
+    /// If there is no expected signature, then we will convert the
+    /// types that the user gave into a signature.
     fn sig_of_closure_no_expectation(
         &mut self,
-        body: &ExprId,
-        ret_type: &Option<TypeRefId>,
-        arg_types: &[Option<TypeRefId>],
-        closure_kind: ClosureKind,
-    ) -> ClosureSignature {
-        self.supplied_sig_of_closure(body, ret_type, arg_types, closure_kind)
-    }
-
-    fn sig_of_closure_with_expectation(
-        &mut self,
-        body: &ExprId,
-        ret_type: &Option<TypeRefId>,
-        arg_types: &[Option<TypeRefId>],
-        closure_kind: ClosureKind,
-        expected_sig: FnSubst<Interner>,
-    ) -> ClosureSignature {
-        let expected_sig = FnPointer {
-            num_binders: 0,
-            sig: FnSig { abi: FnAbi::RustCall, safety: chalk_ir::Safety::Safe, variadic: false },
-            substitution: expected_sig,
-        };
-
-        // If the expected signature does not match the actual arg types,
-        // then just return the expected signature
-        if expected_sig.substitution.0.len(Interner) != arg_types.len() + 1 {
-            let ret_ty = match ret_type {
-                Some(type_ref) => self.make_body_ty(*type_ref),
-                None => self.table.new_type_var(),
-            };
-            return ClosureSignature { expected_sig, ret_ty };
-        }
-
-        self.merge_supplied_sig_with_expectation(
-            body,
-            ret_type,
-            arg_types,
-            closure_kind,
-            expected_sig,
-        )
-    }
-
-    fn merge_supplied_sig_with_expectation(
-        &mut self,
-        body: &ExprId,
-        ret_type: &Option<TypeRefId>,
-        arg_types: &[Option<TypeRefId>],
-        closure_kind: ClosureKind,
-        expected_sig: FnPointer,
-    ) -> ClosureSignature {
-        let supplied_sig = self.supplied_sig_of_closure(body, ret_type, arg_types, closure_kind);
-
-        let snapshot = self.table.snapshot();
-        if !self.table.unify::<_, crate::next_solver::GenericArgs<'_>>(
-            &expected_sig.substitution.0,
-            &supplied_sig.expected_sig.substitution.0,
-        ) {
-            self.table.rollback_to(snapshot);
-        }
-
-        supplied_sig
-    }
-}
-
-// The below functions handle capture and closure kind (Fn, FnMut, ..)
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub(crate) struct HirPlace {
-    pub(crate) local: BindingId,
-    pub(crate) projections: Vec<ProjectionElem<Infallible, Ty>>,
-}
-
-impl HirPlace {
-    fn ty(&self, ctx: &mut InferenceContext<'_>) -> Ty {
-        let mut ty = ctx.table.resolve_completely(ctx.result[self.local].clone());
-        for p in &self.projections {
-            ty = p.projected_ty(
-                ty,
-                ctx.db,
-                |_, _, _| {
-                    unreachable!("Closure field only happens in MIR");
-                },
-                ctx.owner.module(ctx.db).krate(),
-            );
-        }
-        ty
-    }
+        decl_inputs: &[Option<TypeRefId>],
+        decl_output: Option<TypeRefId>,
+    ) -> ClosureSignatures<'db> {
+        let bound_sig = self.supplied_sig_of_closure(decl_inputs, decl_output);
 
-    fn capture_kind_of_truncated_place(
-        &self,
-        mut current_capture: CaptureKind,
-        len: usize,
-    ) -> CaptureKind {
-        if let CaptureKind::ByRef(BorrowKind::Mut {
-            kind: MutBorrowKind::Default | MutBorrowKind::TwoPhasedBorrow,
-        }) = current_capture
-            && self.projections[len..].contains(&ProjectionElem::Deref)
-        {
-            current_capture =
-                CaptureKind::ByRef(BorrowKind::Mut { kind: MutBorrowKind::ClosureCapture });
-        }
-        current_capture
+        self.closure_sigs(bound_sig)
     }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-pub enum CaptureKind {
-    ByRef(BorrowKind),
-    ByValue,
-}
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct CapturedItem {
-    pub(crate) place: HirPlace,
-    pub(crate) kind: CaptureKind,
-    /// The inner vec is the stacks; the outer vec is for each capture reference.
+    /// Invoked to compute the signature of a closure expression. This
+    /// combines any user-provided type annotations (e.g., `|x: u32|
+    /// -> u32 { .. }`) with the expected signature.
     ///
-    /// Even though we always report only the last span (i.e. the most inclusive span),
-    /// we need to keep them all, since when a closure occurs inside a closure, we
-    /// copy all captures of the inner closure to the outer closure, and then we may
-    /// truncate them, and we want the correct span to be reported.
-    span_stacks: SmallVec<[SmallVec<[MirSpan; 3]>; 3]>,
-    pub(crate) ty: Binders<Ty>,
-}
-
-impl CapturedItem {
-    pub fn local(&self) -> BindingId {
-        self.place.local
-    }
-
-    /// Returns whether this place has any field (aka. non-deref) projections.
-    pub fn has_field_projections(&self) -> bool {
-        self.place.projections.iter().any(|it| !matches!(it, ProjectionElem::Deref))
-    }
-
-    pub fn ty(&self, subst: &Substitution) -> Ty {
-        self.ty.clone().substitute(Interner, utils::ClosureSubst(subst).parent_subst())
-    }
-
-    pub fn kind(&self) -> CaptureKind {
-        self.kind
-    }
-
-    pub fn spans(&self) -> SmallVec<[MirSpan; 3]> {
-        self.span_stacks.iter().map(|stack| *stack.last().expect("empty span stack")).collect()
-    }
-
-    /// Converts the place to a name that can be inserted into source code.
-    pub fn place_to_name(&self, owner: DefWithBodyId, db: &dyn HirDatabase) -> String {
-        let body = db.body(owner);
-        let mut result = body[self.place.local].name.as_str().to_owned();
-        for proj in &self.place.projections {
-            match proj {
-                ProjectionElem::Deref => {}
-                ProjectionElem::Field(Either::Left(f)) => {
-                    let variant_data = f.parent.fields(db);
-                    match variant_data.shape {
-                        FieldsShape::Record => {
-                            result.push('_');
-                            result.push_str(variant_data.fields()[f.local_id].name.as_str())
-                        }
-                        FieldsShape::Tuple => {
-                            let index =
-                                variant_data.fields().iter().position(|it| it.0 == f.local_id);
-                            if let Some(index) = index {
-                                format_to!(result, "_{index}");
-                            }
-                        }
-                        FieldsShape::Unit => {}
-                    }
-                }
-                ProjectionElem::Field(Either::Right(f)) => format_to!(result, "_{}", f.index),
-                &ProjectionElem::ClosureField(field) => format_to!(result, "_{field}"),
-                ProjectionElem::Index(_)
-                | ProjectionElem::ConstantIndex { .. }
-                | ProjectionElem::Subslice { .. }
-                | ProjectionElem::OpaqueCast(_) => {
-                    never!("Not happen in closure capture");
-                    continue;
-                }
-            }
-        }
-        if is_raw_identifier(&result, owner.module(db).krate().data(db).edition) {
-            result.insert_str(0, "r#");
-        }
-        result
-    }
-
-    pub fn display_place_source_code(&self, owner: DefWithBodyId, db: &dyn HirDatabase) -> String {
-        let body = db.body(owner);
-        let krate = owner.krate(db);
-        let edition = krate.data(db).edition;
-        let mut result = body[self.place.local].name.display(db, edition).to_string();
-        for proj in &self.place.projections {
-            match proj {
-                // In source code autoderef kicks in.
-                ProjectionElem::Deref => {}
-                ProjectionElem::Field(Either::Left(f)) => {
-                    let variant_data = f.parent.fields(db);
-                    match variant_data.shape {
-                        FieldsShape::Record => format_to!(
-                            result,
-                            ".{}",
-                            variant_data.fields()[f.local_id].name.display(db, edition)
-                        ),
-                        FieldsShape::Tuple => format_to!(
-                            result,
-                            ".{}",
-                            variant_data
-                                .fields()
-                                .iter()
-                                .position(|it| it.0 == f.local_id)
-                                .unwrap_or_default()
-                        ),
-                        FieldsShape::Unit => {}
-                    }
-                }
-                ProjectionElem::Field(Either::Right(f)) => {
-                    let field = f.index;
-                    format_to!(result, ".{field}");
-                }
-                &ProjectionElem::ClosureField(field) => {
-                    format_to!(result, ".{field}");
-                }
-                ProjectionElem::Index(_)
-                | ProjectionElem::ConstantIndex { .. }
-                | ProjectionElem::Subslice { .. }
-                | ProjectionElem::OpaqueCast(_) => {
-                    never!("Not happen in closure capture");
-                    continue;
-                }
-            }
-        }
-        let final_derefs_count = self
-            .place
-            .projections
-            .iter()
-            .rev()
-            .take_while(|proj| matches!(proj, ProjectionElem::Deref))
-            .count();
-        result.insert_str(0, &"*".repeat(final_derefs_count));
-        result
-    }
-
-    pub fn display_place(&self, owner: DefWithBodyId, db: &dyn HirDatabase) -> String {
-        let body = db.body(owner);
-        let krate = owner.krate(db);
-        let edition = krate.data(db).edition;
-        let mut result = body[self.place.local].name.display(db, edition).to_string();
-        let mut field_need_paren = false;
-        for proj in &self.place.projections {
-            match proj {
-                ProjectionElem::Deref => {
-                    result = format!("*{result}");
-                    field_need_paren = true;
-                }
-                ProjectionElem::Field(Either::Left(f)) => {
-                    if field_need_paren {
-                        result = format!("({result})");
-                    }
-                    let variant_data = f.parent.fields(db);
-                    let field = match variant_data.shape {
-                        FieldsShape::Record => {
-                            variant_data.fields()[f.local_id].name.as_str().to_owned()
-                        }
-                        FieldsShape::Tuple => variant_data
-                            .fields()
-                            .iter()
-                            .position(|it| it.0 == f.local_id)
-                            .unwrap_or_default()
-                            .to_string(),
-                        FieldsShape::Unit => "[missing field]".to_owned(),
-                    };
-                    result = format!("{result}.{field}");
-                    field_need_paren = false;
-                }
-                ProjectionElem::Field(Either::Right(f)) => {
-                    let field = f.index;
-                    if field_need_paren {
-                        result = format!("({result})");
-                    }
-                    result = format!("{result}.{field}");
-                    field_need_paren = false;
-                }
-                &ProjectionElem::ClosureField(field) => {
-                    if field_need_paren {
-                        result = format!("({result})");
-                    }
-                    result = format!("{result}.{field}");
-                    field_need_paren = false;
-                }
-                ProjectionElem::Index(_)
-                | ProjectionElem::ConstantIndex { .. }
-                | ProjectionElem::Subslice { .. }
-                | ProjectionElem::OpaqueCast(_) => {
-                    never!("Not happen in closure capture");
-                    continue;
-                }
-            }
-        }
-        result
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct CapturedItemWithoutTy {
-    pub(crate) place: HirPlace,
-    pub(crate) kind: CaptureKind,
-    /// The inner vec is the stacks; the outer vec is for each capture reference.
-    pub(crate) span_stacks: SmallVec<[SmallVec<[MirSpan; 3]>; 3]>,
-}
-
-impl CapturedItemWithoutTy {
-    fn with_ty(self, ctx: &mut InferenceContext<'_>) -> CapturedItem {
-        let ty = self.place.ty(ctx);
-        let ty = match &self.kind {
-            CaptureKind::ByValue => ty,
-            CaptureKind::ByRef(bk) => {
-                let m = match bk {
-                    BorrowKind::Mut { .. } => Mutability::Mut,
-                    _ => Mutability::Not,
-                };
-                TyKind::Ref(m, error_lifetime(), ty).intern(Interner)
-            }
-        };
-        return CapturedItem {
-            place: self.place,
-            kind: self.kind,
-            span_stacks: self.span_stacks,
-            ty: replace_placeholder_with_binder(ctx, ty),
-        };
-
-        fn replace_placeholder_with_binder(ctx: &mut InferenceContext<'_>, ty: Ty) -> Binders<Ty> {
-            struct Filler<'a> {
-                db: &'a dyn HirDatabase,
-                generics: &'a Generics,
-            }
-            impl FallibleTypeFolder<Interner> for Filler<'_> {
-                type Error = ();
-
-                fn as_dyn(&mut self) -> &mut dyn FallibleTypeFolder<Interner, Error = Self::Error> {
-                    self
-                }
-
-                fn interner(&self) -> Interner {
-                    Interner
-                }
-
-                fn try_fold_free_placeholder_const(
-                    &mut self,
-                    ty: chalk_ir::Ty<Interner>,
-                    idx: chalk_ir::PlaceholderIndex,
-                    outer_binder: DebruijnIndex,
-                ) -> Result<chalk_ir::Const<Interner>, Self::Error> {
-                    let x = from_placeholder_idx(self.db, idx).0;
-                    let Some(idx) = self.generics.type_or_const_param_idx(x) else {
-                        return Err(());
-                    };
-                    Ok(BoundVar::new(outer_binder, idx).to_const(Interner, ty))
-                }
-
-                fn try_fold_free_placeholder_ty(
-                    &mut self,
-                    idx: chalk_ir::PlaceholderIndex,
-                    outer_binder: DebruijnIndex,
-                ) -> std::result::Result<Ty, Self::Error> {
-                    let x = from_placeholder_idx(self.db, idx).0;
-                    let Some(idx) = self.generics.type_or_const_param_idx(x) else {
-                        return Err(());
-                    };
-                    Ok(BoundVar::new(outer_binder, idx).to_ty(Interner))
-                }
-            }
-            let filler = &mut Filler { db: ctx.db, generics: ctx.generics() };
-            let result = ty.clone().try_fold_with(filler, DebruijnIndex::INNERMOST).unwrap_or(ty);
-            make_binders(ctx.db, filler.generics, result)
-        }
-    }
-}
-
-impl InferenceContext<'_> {
-    fn place_of_expr(&mut self, tgt_expr: ExprId) -> Option<HirPlace> {
-        let r = self.place_of_expr_without_adjust(tgt_expr)?;
-        let adjustments =
-            self.result.expr_adjustments.get(&tgt_expr).map(|it| &**it).unwrap_or_default();
-        apply_adjusts_to_place(&mut self.current_capture_span_stack, r, adjustments)
-    }
-
-    /// Pushes the span into `current_capture_span_stack`, *without clearing it first*.
-    fn path_place(&mut self, path: &Path, id: ExprOrPatId) -> Option<HirPlace> {
-        if path.type_anchor().is_some() {
-            return None;
-        }
-        let hygiene = self.body.expr_or_pat_path_hygiene(id);
-        self.resolver.resolve_path_in_value_ns_fully(self.db, path, hygiene).and_then(|result| {
-            match result {
-                ValueNs::LocalBinding(binding) => {
-                    let mir_span = match id {
-                        ExprOrPatId::ExprId(id) => MirSpan::ExprId(id),
-                        ExprOrPatId::PatId(id) => MirSpan::PatId(id),
-                    };
-                    self.current_capture_span_stack.push(mir_span);
-                    Some(HirPlace { local: binding, projections: Vec::new() })
-                }
-                _ => None,
-            }
-        })
-    }
+    /// The approach is as follows:
+    ///
+    /// - Let `S` be the (higher-ranked) signature that we derive from the user's annotations.
+    /// - Let `E` be the (higher-ranked) signature that we derive from the expectations, if any.
+    ///   - If we have no expectation `E`, then the signature of the closure is `S`.
+    ///   - Otherwise, the signature of the closure is E. Moreover:
+    ///     - Skolemize the late-bound regions in `E`, yielding `E'`.
+    ///     - Instantiate all the late-bound regions bound in the closure within `S`
+    ///       with fresh (existential) variables, yielding `S'`
+    ///     - Require that `E' = S'`
+    ///       - We could use some kind of subtyping relationship here,
+    ///         I imagine, but equality is easier and works fine for
+    ///         our purposes.
+    ///
+    /// The key intuition here is that the user's types must be valid
+    /// from "the inside" of the closure, but the expectation
+    /// ultimately drives the overall signature.
+    ///
+    /// # Examples
+    ///
+    /// ```ignore (illustrative)
+    /// fn with_closure<F>(_: F)
+    ///   where F: Fn(&u32) -> &u32 { .. }
+    ///
+    /// with_closure(|x: &u32| { ... })
+    /// ```
+    ///
+    /// Here:
+    /// - E would be `fn(&u32) -> &u32`.
+    /// - S would be `fn(&u32) -> ?T`
+    /// - E' is `&'!0 u32 -> &'!0 u32`
+    /// - S' is `&'?0 u32 -> ?T`
+    ///
+    /// S' can be unified with E' with `['?0 = '!0, ?T = &'!10 u32]`.
+    ///
+    /// # Arguments
+    ///
+    /// - `expr_def_id`: the `LocalDefId` of the closure expression
+    /// - `decl`: the HIR declaration of the closure
+    /// - `body`: the body of the closure
+    /// - `expected_sig`: the expected signature (if any). Note that
+    ///   this is missing a binder: that is, there may be late-bound
+    ///   regions with depth 1, which are bound then by the closure.
+    fn sig_of_closure_with_expectation(
+        &mut self,
+        decl_inputs: &[Option<TypeRefId>],
+        decl_output: Option<TypeRefId>,
+        expected_sig: PolyFnSig<'db>,
+    ) -> ClosureSignatures<'db> {
+        // Watch out for some surprises and just ignore the
+        // expectation if things don't see to match up with what we
+        // expect.
+        if expected_sig.c_variadic() {
+            return self.sig_of_closure_no_expectation(decl_inputs, decl_output);
+        } else if expected_sig.skip_binder().inputs_and_output.len() != decl_inputs.len() + 1 {
+            return self
+                .sig_of_closure_with_mismatched_number_of_arguments(decl_inputs, decl_output);
+        }
+
+        // Create a `PolyFnSig`. Note the oddity that late bound
+        // regions appearing free in `expected_sig` are now bound up
+        // in this binder we are creating.
+        assert!(!expected_sig.skip_binder().has_vars_bound_above(rustc_type_ir::INNERMOST));
+        let bound_sig = expected_sig.map_bound(|sig| {
+            self.table.interner.mk_fn_sig(
+                sig.inputs(),
+                sig.output(),
+                sig.c_variadic,
+                Safety::Safe,
+                FnAbi::RustCall,
+            )
+        });
 
-    /// Changes `current_capture_span_stack` to contain the stack of spans for this expr.
-    fn place_of_expr_without_adjust(&mut self, tgt_expr: ExprId) -> Option<HirPlace> {
-        self.current_capture_span_stack.clear();
-        match &self.body[tgt_expr] {
-            Expr::Path(p) => {
-                let resolver_guard =
-                    self.resolver.update_to_inner_scope(self.db, self.owner, tgt_expr);
-                let result = self.path_place(p, tgt_expr.into());
-                self.resolver.reset_to_guard(resolver_guard);
-                return result;
-            }
-            Expr::Field { expr, name: _ } => {
-                let mut place = self.place_of_expr(*expr)?;
-                let field = self.result.field_resolution(tgt_expr)?;
-                self.current_capture_span_stack.push(MirSpan::ExprId(tgt_expr));
-                place.projections.push(ProjectionElem::Field(field));
-                return Some(place);
-            }
-            Expr::UnaryOp { expr, op: UnaryOp::Deref } => {
-                if matches!(
-                    self.expr_ty_after_adjustments(*expr).kind(Interner),
-                    TyKind::Ref(..) | TyKind::Raw(..)
-                ) {
-                    let mut place = self.place_of_expr(*expr)?;
-                    self.current_capture_span_stack.push(MirSpan::ExprId(tgt_expr));
-                    place.projections.push(ProjectionElem::Deref);
-                    return Some(place);
-                }
-            }
-            _ => (),
-        }
-        None
-    }
+        // `deduce_expectations_from_expected_type` introduces
+        // late-bound lifetimes defined elsewhere, which we now
+        // anonymize away, so as not to confuse the user.
+        let bound_sig = self.table.interner.anonymize_bound_vars(bound_sig);
 
-    fn push_capture(&mut self, place: HirPlace, kind: CaptureKind) {
-        self.current_captures.push(CapturedItemWithoutTy {
-            place,
-            kind,
-            span_stacks: smallvec![self.current_capture_span_stack.iter().copied().collect()],
-        });
-    }
+        let closure_sigs = self.closure_sigs(bound_sig);
 
-    fn truncate_capture_spans(&self, capture: &mut CapturedItemWithoutTy, mut truncate_to: usize) {
-        // The first span is the identifier, and it must always remain.
-        truncate_to += 1;
-        for span_stack in &mut capture.span_stacks {
-            let mut remained = truncate_to;
-            let mut actual_truncate_to = 0;
-            for &span in &*span_stack {
-                actual_truncate_to += 1;
-                if !span.is_ref_span(self.body) {
-                    remained -= 1;
-                    if remained == 0 {
-                        break;
-                    }
-                }
-            }
-            if actual_truncate_to < span_stack.len()
-                && span_stack[actual_truncate_to].is_ref_span(self.body)
-            {
-                // Include the ref operator if there is one, we will fix it later (in `strip_captures_ref_span()`) if it's incorrect.
-                actual_truncate_to += 1;
-            }
-            span_stack.truncate(actual_truncate_to);
+        // Up till this point, we have ignored the annotations that the user
+        // gave. This function will check that they unify successfully.
+        // Along the way, it also writes out entries for types that the user
+        // wrote into our typeck results, which are then later used by the privacy
+        // check.
+        match self.merge_supplied_sig_with_expectation(decl_inputs, decl_output, closure_sigs) {
+            Ok(infer_ok) => self.table.register_infer_ok(infer_ok),
+            Err(_) => self.sig_of_closure_no_expectation(decl_inputs, decl_output),
         }
     }
 
-    fn ref_expr(&mut self, expr: ExprId, place: Option<HirPlace>) {
-        if let Some(place) = place {
-            self.add_capture(place, CaptureKind::ByRef(BorrowKind::Shared));
-        }
-        self.walk_expr(expr);
-    }
+    fn sig_of_closure_with_mismatched_number_of_arguments(
+        &mut self,
+        decl_inputs: &[Option<TypeRefId>],
+        decl_output: Option<TypeRefId>,
+    ) -> ClosureSignatures<'db> {
+        let error_sig = self.error_sig_of_closure(decl_inputs, decl_output);
 
-    fn add_capture(&mut self, place: HirPlace, kind: CaptureKind) {
-        if self.is_upvar(&place) {
-            self.push_capture(place, kind);
-        }
+        self.closure_sigs(error_sig)
     }
 
-    fn mutate_path_pat(&mut self, path: &Path, id: PatId) {
-        if let Some(place) = self.path_place(path, id.into()) {
-            self.add_capture(
-                place,
-                CaptureKind::ByRef(BorrowKind::Mut { kind: MutBorrowKind::Default }),
+    /// Enforce the user's types against the expectation. See
+    /// `sig_of_closure_with_expectation` for details on the overall
+    /// strategy.
+    fn merge_supplied_sig_with_expectation(
+        &mut self,
+        decl_inputs: &[Option<TypeRefId>],
+        decl_output: Option<TypeRefId>,
+        mut expected_sigs: ClosureSignatures<'db>,
+    ) -> InferResult<'db, ClosureSignatures<'db>> {
+        // Get the signature S that the user gave.
+        //
+        // (See comment on `sig_of_closure_with_expectation` for the
+        // meaning of these letters.)
+        let supplied_sig = self.supplied_sig_of_closure(decl_inputs, decl_output);
+
+        debug!(?supplied_sig);
+
+        // FIXME(#45727): As discussed in [this comment][c1], naively
+        // forcing equality here actually results in suboptimal error
+        // messages in some cases. For now, if there would have been
+        // an obvious error, we fallback to declaring the type of the
+        // closure to be the one the user gave, which allows other
+        // error message code to trigger.
+        //
+        // However, I think [there is potential to do even better
+        // here][c2], since in *this* code we have the precise span of
+        // the type parameter in question in hand when we report the
+        // error.
+        //
+        // [c1]: https://github.com/rust-lang/rust/pull/45072#issuecomment-341089706
+        // [c2]: https://github.com/rust-lang/rust/pull/45072#issuecomment-341096796
+        self.table.commit_if_ok(|table| {
+            let mut all_obligations = PredicateObligations::new();
+            let supplied_sig = table.infer_ctxt.instantiate_binder_with_fresh_vars(
+                BoundRegionConversionTime::FnCall,
+                supplied_sig,
             );
-            self.current_capture_span_stack.pop(); // Remove the pattern span.
-        }
-    }
 
-    fn mutate_expr(&mut self, expr: ExprId, place: Option<HirPlace>) {
-        if let Some(place) = place {
-            self.add_capture(
-                place,
-                CaptureKind::ByRef(BorrowKind::Mut { kind: MutBorrowKind::Default }),
+            // The liberated version of this signature should be a subtype
+            // of the liberated form of the expectation.
+            for (supplied_ty, expected_ty) in
+                iter::zip(supplied_sig.inputs(), expected_sigs.liberated_sig.inputs())
+            {
+                // Check that E' = S'.
+                let cause = ObligationCause::new();
+                let InferOk { value: (), obligations } = table
+                    .infer_ctxt
+                    .at(&cause, table.param_env)
+                    .eq(DefineOpaqueTypes::Yes, expected_ty, supplied_ty)?;
+                all_obligations.extend(obligations);
+            }
+
+            let supplied_output_ty = supplied_sig.output();
+            let cause = ObligationCause::new();
+            let InferOk { value: (), obligations } =
+                table.infer_ctxt.at(&cause, table.param_env).eq(
+                    DefineOpaqueTypes::Yes,
+                    expected_sigs.liberated_sig.output(),
+                    supplied_output_ty,
+                )?;
+            all_obligations.extend(obligations);
+
+            let inputs = supplied_sig
+                .inputs()
+                .into_iter()
+                .map(|ty| table.infer_ctxt.resolve_vars_if_possible(ty));
+
+            expected_sigs.liberated_sig = table.interner.mk_fn_sig(
+                inputs,
+                supplied_output_ty,
+                expected_sigs.liberated_sig.c_variadic,
+                Safety::Safe,
+                FnAbi::RustCall,
             );
-        }
-        self.walk_expr(expr);
-    }
 
-    fn consume_expr(&mut self, expr: ExprId) {
-        if let Some(place) = self.place_of_expr(expr) {
-            self.consume_place(place);
-        }
-        self.walk_expr(expr);
+            Ok(InferOk { value: expected_sigs, obligations: all_obligations })
+        })
     }
 
-    fn consume_place(&mut self, place: HirPlace) {
-        if self.is_upvar(&place) {
-            let ty = place.ty(self);
-            let kind = if self.is_ty_copy(ty) {
-                CaptureKind::ByRef(BorrowKind::Shared)
-            } else {
-                CaptureKind::ByValue
-            };
-            self.push_capture(place, kind);
-        }
-    }
+    /// If there is no expected signature, then we will convert the
+    /// types that the user gave into a signature.
+    ///
+    /// Also, record this closure signature for later.
+    fn supplied_sig_of_closure(
+        &mut self,
+        decl_inputs: &[Option<TypeRefId>],
+        decl_output: Option<TypeRefId>,
+    ) -> PolyFnSig<'db> {
+        let interner = self.table.interner;
 
-    fn walk_expr_with_adjust(&mut self, tgt_expr: ExprId, adjustment: &[Adjustment]) {
-        if let Some((last, rest)) = adjustment.split_last() {
-            match &last.kind {
-                Adjust::NeverToAny | Adjust::Deref(None) | Adjust::Pointer(_) => {
-                    self.walk_expr_with_adjust(tgt_expr, rest)
-                }
-                Adjust::Deref(Some(m)) => match m.0 {
-                    Some(m) => {
-                        self.ref_capture_with_adjusts(m, tgt_expr, rest);
-                    }
-                    None => unreachable!(),
-                },
-                Adjust::Borrow(b) => {
-                    self.ref_capture_with_adjusts(b.mutability(), tgt_expr, rest);
-                }
+        let supplied_return = match decl_output {
+            Some(output) => {
+                let output = self.make_body_ty(output);
+                self.process_user_written_ty(output).to_nextsolver(interner)
             }
-        } else {
-            self.walk_expr_without_adjust(tgt_expr);
-        }
-    }
-
-    fn ref_capture_with_adjusts(&mut self, m: Mutability, tgt_expr: ExprId, rest: &[Adjustment]) {
-        let capture_kind = match m {
-            Mutability::Mut => CaptureKind::ByRef(BorrowKind::Mut { kind: MutBorrowKind::Default }),
-            Mutability::Not => CaptureKind::ByRef(BorrowKind::Shared),
+            None => self.table.next_ty_var(),
         };
-        if let Some(place) = self.place_of_expr_without_adjust(tgt_expr)
-            && let Some(place) =
-                apply_adjusts_to_place(&mut self.current_capture_span_stack, place, rest)
-        {
-            self.add_capture(place, capture_kind);
-        }
-        self.walk_expr_with_adjust(tgt_expr, rest);
-    }
-
-    fn walk_expr(&mut self, tgt_expr: ExprId) {
-        if let Some(it) = self.result.expr_adjustments.get_mut(&tgt_expr) {
-            // FIXME: this take is completely unneeded, and just is here to make borrow checker
-            // happy. Remove it if you can.
-            let x_taken = mem::take(it);
-            self.walk_expr_with_adjust(tgt_expr, &x_taken);
-            *self.result.expr_adjustments.get_mut(&tgt_expr).unwrap() = x_taken;
-        } else {
-            self.walk_expr_without_adjust(tgt_expr);
-        }
-    }
-
-    fn walk_expr_without_adjust(&mut self, tgt_expr: ExprId) {
-        match &self.body[tgt_expr] {
-            Expr::OffsetOf(_) => (),
-            Expr::InlineAsm(e) => e.operands.iter().for_each(|(_, op)| match op {
-                AsmOperand::In { expr, .. }
-                | AsmOperand::Out { expr: Some(expr), .. }
-                | AsmOperand::InOut { expr, .. } => self.walk_expr_without_adjust(*expr),
-                AsmOperand::SplitInOut { in_expr, out_expr, .. } => {
-                    self.walk_expr_without_adjust(*in_expr);
-                    if let Some(out_expr) = out_expr {
-                        self.walk_expr_without_adjust(*out_expr);
-                    }
-                }
-                AsmOperand::Out { expr: None, .. }
-                | AsmOperand::Const(_)
-                | AsmOperand::Label(_)
-                | AsmOperand::Sym(_) => (),
-            }),
-            Expr::If { condition, then_branch, else_branch } => {
-                self.consume_expr(*condition);
-                self.consume_expr(*then_branch);
-                if let &Some(expr) = else_branch {
-                    self.consume_expr(expr);
-                }
-            }
-            Expr::Async { statements, tail, .. }
-            | Expr::Unsafe { statements, tail, .. }
-            | Expr::Block { statements, tail, .. } => {
-                for s in statements.iter() {
-                    match s {
-                        Statement::Let { pat, type_ref: _, initializer, else_branch } => {
-                            if let Some(else_branch) = else_branch {
-                                self.consume_expr(*else_branch);
-                            }
-                            if let Some(initializer) = initializer {
-                                if else_branch.is_some() {
-                                    self.consume_expr(*initializer);
-                                } else {
-                                    self.walk_expr(*initializer);
-                                }
-                                if let Some(place) = self.place_of_expr(*initializer) {
-                                    self.consume_with_pat(place, *pat);
-                                }
-                            }
-                        }
-                        Statement::Expr { expr, has_semi: _ } => {
-                            self.consume_expr(*expr);
-                        }
-                        Statement::Item(_) => (),
-                    }
-                }
-                if let Some(tail) = tail {
-                    self.consume_expr(*tail);
-                }
-            }
-            Expr::Call { callee, args } => {
-                self.consume_expr(*callee);
-                self.consume_exprs(args.iter().copied());
-            }
-            Expr::MethodCall { receiver, args, .. } => {
-                self.consume_expr(*receiver);
-                self.consume_exprs(args.iter().copied());
-            }
-            Expr::Match { expr, arms } => {
-                for arm in arms.iter() {
-                    self.consume_expr(arm.expr);
-                    if let Some(guard) = arm.guard {
-                        self.consume_expr(guard);
-                    }
-                }
-                self.walk_expr(*expr);
-                if let Some(discr_place) = self.place_of_expr(*expr)
-                    && self.is_upvar(&discr_place)
-                {
-                    let mut capture_mode = None;
-                    for arm in arms.iter() {
-                        self.walk_pat(&mut capture_mode, arm.pat);
-                    }
-                    if let Some(c) = capture_mode {
-                        self.push_capture(discr_place, c);
-                    }
-                }
-            }
-            Expr::Break { expr, label: _ }
-            | Expr::Return { expr }
-            | Expr::Yield { expr }
-            | Expr::Yeet { expr } => {
-                if let &Some(expr) = expr {
-                    self.consume_expr(expr);
-                }
-            }
-            &Expr::Become { expr } => {
-                self.consume_expr(expr);
-            }
-            Expr::RecordLit { fields, spread, .. } => {
-                if let &Some(expr) = spread {
-                    self.consume_expr(expr);
-                }
-                self.consume_exprs(fields.iter().map(|it| it.expr));
-            }
-            Expr::Field { expr, name: _ } => self.select_from_expr(*expr),
-            Expr::UnaryOp { expr, op: UnaryOp::Deref } => {
-                if matches!(
-                    self.expr_ty_after_adjustments(*expr).kind(Interner),
-                    TyKind::Ref(..) | TyKind::Raw(..)
-                ) {
-                    self.select_from_expr(*expr);
-                } else if let Some((f, _)) = self.result.method_resolution(tgt_expr) {
-                    let mutability = 'b: {
-                        if let Some(deref_trait) =
-                            self.resolve_lang_item(LangItem::DerefMut).and_then(|it| it.as_trait())
-                            && let Some(deref_fn) = deref_trait
-                                .trait_items(self.db)
-                                .method_by_name(&Name::new_symbol_root(sym::deref_mut))
-                        {
-                            break 'b deref_fn == f;
-                        }
-                        false
-                    };
-                    let place = self.place_of_expr(*expr);
-                    if mutability {
-                        self.mutate_expr(*expr, place);
-                    } else {
-                        self.ref_expr(*expr, place);
-                    }
-                } else {
-                    self.select_from_expr(*expr);
-                }
-            }
-            Expr::Let { pat, expr } => {
-                self.walk_expr(*expr);
-                if let Some(place) = self.place_of_expr(*expr) {
-                    self.consume_with_pat(place, *pat);
-                }
-            }
-            Expr::UnaryOp { expr, op: _ }
-            | Expr::Array(Array::Repeat { initializer: expr, repeat: _ })
-            | Expr::Await { expr }
-            | Expr::Loop { body: expr, label: _ }
-            | Expr::Box { expr }
-            | Expr::Cast { expr, type_ref: _ } => {
-                self.consume_expr(*expr);
-            }
-            Expr::Ref { expr, rawness: _, mutability } => {
-                // We need to do this before we push the span so the order will be correct.
-                let place = self.place_of_expr(*expr);
-                self.current_capture_span_stack.push(MirSpan::ExprId(tgt_expr));
-                match mutability {
-                    hir_def::type_ref::Mutability::Shared => self.ref_expr(*expr, place),
-                    hir_def::type_ref::Mutability::Mut => self.mutate_expr(*expr, place),
-                }
-            }
-            Expr::BinaryOp { lhs, rhs, op } => {
-                let Some(op) = op else {
-                    return;
-                };
-                if matches!(op, BinaryOp::Assignment { .. }) {
-                    let place = self.place_of_expr(*lhs);
-                    self.mutate_expr(*lhs, place);
-                    self.consume_expr(*rhs);
-                    return;
-                }
-                self.consume_expr(*lhs);
-                self.consume_expr(*rhs);
-            }
-            Expr::Range { lhs, rhs, range_type: _ } => {
-                if let &Some(expr) = lhs {
-                    self.consume_expr(expr);
-                }
-                if let &Some(expr) = rhs {
-                    self.consume_expr(expr);
-                }
-            }
-            Expr::Index { base, index } => {
-                self.select_from_expr(*base);
-                self.consume_expr(*index);
-            }
-            Expr::Closure { .. } => {
-                let ty = self.expr_ty(tgt_expr);
-                let TyKind::Closure(id, _) = ty.kind(Interner) else {
-                    never!("closure type is always closure");
-                    return;
-                };
-                let (captures, _) =
-                    self.result.closure_info.get(id).expect(
-                        "We sort closures, so we should always have data for inner closures",
-                    );
-                let mut cc = mem::take(&mut self.current_captures);
-                cc.extend(captures.iter().filter(|it| self.is_upvar(&it.place)).map(|it| {
-                    CapturedItemWithoutTy {
-                        place: it.place.clone(),
-                        kind: it.kind,
-                        span_stacks: it.span_stacks.clone(),
-                    }
-                }));
-                self.current_captures = cc;
-            }
-            Expr::Array(Array::ElementList { elements: exprs }) | Expr::Tuple { exprs } => {
-                self.consume_exprs(exprs.iter().copied())
-            }
-            &Expr::Assignment { target, value } => {
-                self.walk_expr(value);
-                let resolver_guard =
-                    self.resolver.update_to_inner_scope(self.db, self.owner, tgt_expr);
-                match self.place_of_expr(value) {
-                    Some(rhs_place) => {
-                        self.inside_assignment = true;
-                        self.consume_with_pat(rhs_place, target);
-                        self.inside_assignment = false;
-                    }
-                    None => self.body.walk_pats(target, &mut |pat| match &self.body[pat] {
-                        Pat::Path(path) => self.mutate_path_pat(path, pat),
-                        &Pat::Expr(expr) => {
-                            let place = self.place_of_expr(expr);
-                            self.mutate_expr(expr, place);
-                        }
-                        _ => {}
-                    }),
-                }
-                self.resolver.reset_to_guard(resolver_guard);
-            }
-
-            Expr::Missing
-            | Expr::Continue { .. }
-            | Expr::Path(_)
-            | Expr::Literal(_)
-            | Expr::Const(_)
-            | Expr::Underscore => (),
-        }
-    }
-
-    fn walk_pat(&mut self, result: &mut Option<CaptureKind>, pat: PatId) {
-        let mut update_result = |ck: CaptureKind| match result {
-            Some(r) => {
-                *r = cmp::max(*r, ck);
+        // First, convert the types that the user supplied (if any).
+        let supplied_arguments = decl_inputs.iter().map(|&input| match input {
+            Some(input) => {
+                let input = self.make_body_ty(input);
+                self.process_user_written_ty(input).to_nextsolver(interner)
             }
-            None => *result = Some(ck),
-        };
+            None => self.table.next_ty_var(),
+        });
 
-        self.walk_pat_inner(
-            pat,
-            &mut update_result,
-            BorrowKind::Mut { kind: MutBorrowKind::Default },
-        );
+        Binder::dummy(interner.mk_fn_sig(
+            supplied_arguments,
+            supplied_return,
+            false,
+            Safety::Safe,
+            FnAbi::RustCall,
+        ))
     }
 
-    fn walk_pat_inner(
+    /// Converts the types that the user supplied, in case that doing
+    /// so should yield an error, but returns back a signature where
+    /// all parameters are of type `ty::Error`.
+    fn error_sig_of_closure(
         &mut self,
-        p: PatId,
-        update_result: &mut impl FnMut(CaptureKind),
-        mut for_mut: BorrowKind,
-    ) {
-        match &self.body[p] {
-            Pat::Ref { .. }
-            | Pat::Box { .. }
-            | Pat::Missing
-            | Pat::Wild
-            | Pat::Tuple { .. }
-            | Pat::Expr(_)
-            | Pat::Or(_) => (),
-            Pat::TupleStruct { .. } | Pat::Record { .. } => {
-                if let Some(variant) = self.result.variant_resolution_for_pat(p) {
-                    let adt = variant.adt_id(self.db);
-                    let is_multivariant = match adt {
-                        hir_def::AdtId::EnumId(e) => e.enum_variants(self.db).variants.len() != 1,
-                        _ => false,
-                    };
-                    if is_multivariant {
-                        update_result(CaptureKind::ByRef(BorrowKind::Shared));
-                    }
-                }
-            }
-            Pat::Slice { .. }
-            | Pat::ConstBlock(_)
-            | Pat::Path(_)
-            | Pat::Lit(_)
-            | Pat::Range { .. } => {
-                update_result(CaptureKind::ByRef(BorrowKind::Shared));
-            }
-            Pat::Bind { id, .. } => match self.result.binding_modes[p] {
-                crate::BindingMode::Move => {
-                    if self.is_ty_copy(self.result.type_of_binding[*id].clone()) {
-                        update_result(CaptureKind::ByRef(BorrowKind::Shared));
-                    } else {
-                        update_result(CaptureKind::ByValue);
-                    }
-                }
-                crate::BindingMode::Ref(r) => match r {
-                    Mutability::Mut => update_result(CaptureKind::ByRef(for_mut)),
-                    Mutability::Not => update_result(CaptureKind::ByRef(BorrowKind::Shared)),
-                },
-            },
-        }
-        if self.result.pat_adjustments.get(&p).is_some_and(|it| !it.is_empty()) {
-            for_mut = BorrowKind::Mut { kind: MutBorrowKind::ClosureCapture };
-        }
-        self.body.walk_pats_shallow(p, |p| self.walk_pat_inner(p, update_result, for_mut));
-    }
-
-    fn expr_ty(&self, expr: ExprId) -> Ty {
-        self.result[expr].clone()
-    }
-
-    fn expr_ty_after_adjustments(&self, e: ExprId) -> Ty {
-        let mut ty = None;
-        if let Some(it) = self.result.expr_adjustments.get(&e)
-            && let Some(it) = it.last()
-        {
-            ty = Some(it.target.clone());
-        }
-        ty.unwrap_or_else(|| self.expr_ty(e))
-    }
-
-    fn is_upvar(&self, place: &HirPlace) -> bool {
-        if let Some(c) = self.current_closure {
-            let InternedClosure(_, root) = self.db.lookup_intern_closure(c.into());
-            return self.body.is_binding_upvar(place.local, root);
-        }
-        false
-    }
-
-    fn is_ty_copy(&mut self, ty: Ty) -> bool {
-        if let TyKind::Closure(id, _) = ty.kind(Interner) {
-            // FIXME: We handle closure as a special case, since chalk consider every closure as copy. We
-            // should probably let chalk know which closures are copy, but I don't know how doing it
-            // without creating query cycles.
-            return self.result.closure_info.get(id).map(|it| it.1 == FnTrait::Fn).unwrap_or(true);
-        }
-        self.table.resolve_completely(ty).is_copy(self.db, self.owner)
-    }
-
-    fn select_from_expr(&mut self, expr: ExprId) {
-        self.walk_expr(expr);
-    }
-
-    fn restrict_precision_for_unsafe(&mut self) {
-        // FIXME: Borrow checker problems without this.
-        let mut current_captures = std::mem::take(&mut self.current_captures);
-        for capture in &mut current_captures {
-            let mut ty = self.table.resolve_completely(self.result[capture.place.local].clone());
-            if ty.as_raw_ptr().is_some() || ty.is_union() {
-                capture.kind = CaptureKind::ByRef(BorrowKind::Shared);
-                self.truncate_capture_spans(capture, 0);
-                capture.place.projections.truncate(0);
-                continue;
-            }
-            for (i, p) in capture.place.projections.iter().enumerate() {
-                ty = p.projected_ty(
-                    ty,
-                    self.db,
-                    |_, _, _| {
-                        unreachable!("Closure field only happens in MIR");
-                    },
-                    self.owner.module(self.db).krate(),
-                );
-                if ty.as_raw_ptr().is_some() || ty.is_union() {
-                    capture.kind = CaptureKind::ByRef(BorrowKind::Shared);
-                    self.truncate_capture_spans(capture, i + 1);
-                    capture.place.projections.truncate(i + 1);
-                    break;
-                }
-            }
-        }
-        self.current_captures = current_captures;
-    }
+        decl_inputs: &[Option<TypeRefId>],
+        decl_output: Option<TypeRefId>,
+    ) -> PolyFnSig<'db> {
+        let interner = self.table.interner;
+        let err_ty = Ty::new_error(interner, ErrorGuaranteed);
 
-    fn adjust_for_move_closure(&mut self) {
-        // FIXME: Borrow checker won't allow without this.
-        let mut current_captures = std::mem::take(&mut self.current_captures);
-        for capture in &mut current_captures {
-            if let Some(first_deref) =
-                capture.place.projections.iter().position(|proj| *proj == ProjectionElem::Deref)
-            {
-                self.truncate_capture_spans(capture, first_deref);
-                capture.place.projections.truncate(first_deref);
-            }
-            capture.kind = CaptureKind::ByValue;
+        if let Some(output) = decl_output {
+            self.make_body_ty(output);
         }
-        self.current_captures = current_captures;
-    }
-
-    fn minimize_captures(&mut self) {
-        self.current_captures.sort_unstable_by_key(|it| it.place.projections.len());
-        let mut hash_map = FxHashMap::<HirPlace, usize>::default();
-        let result = mem::take(&mut self.current_captures);
-        for mut item in result {
-            let mut lookup_place = HirPlace { local: item.place.local, projections: vec![] };
-            let mut it = item.place.projections.iter();
-            let prev_index = loop {
-                if let Some(k) = hash_map.get(&lookup_place) {
-                    break Some(*k);
-                }
-                match it.next() {
-                    Some(it) => {
-                        lookup_place.projections.push(it.clone());
-                    }
-                    None => break None,
-                }
-            };
-            match prev_index {
-                Some(p) => {
-                    let prev_projections_len = self.current_captures[p].place.projections.len();
-                    self.truncate_capture_spans(&mut item, prev_projections_len);
-                    self.current_captures[p].span_stacks.extend(item.span_stacks);
-                    let len = self.current_captures[p].place.projections.len();
-                    let kind_after_truncate =
-                        item.place.capture_kind_of_truncated_place(item.kind, len);
-                    self.current_captures[p].kind =
-                        cmp::max(kind_after_truncate, self.current_captures[p].kind);
-                }
-                None => {
-                    hash_map.insert(item.place.clone(), self.current_captures.len());
-                    self.current_captures.push(item);
-                }
+        let supplied_arguments = decl_inputs.iter().map(|&input| match input {
+            Some(input) => {
+                self.make_body_ty(input);
+                err_ty
             }
-        }
-    }
-
-    fn consume_with_pat(&mut self, mut place: HirPlace, tgt_pat: PatId) {
-        let adjustments_count =
-            self.result.pat_adjustments.get(&tgt_pat).map(|it| it.len()).unwrap_or_default();
-        place.projections.extend((0..adjustments_count).map(|_| ProjectionElem::Deref));
-        self.current_capture_span_stack
-            .extend((0..adjustments_count).map(|_| MirSpan::PatId(tgt_pat)));
-        'reset_span_stack: {
-            match &self.body[tgt_pat] {
-                Pat::Missing | Pat::Wild => (),
-                Pat::Tuple { args, ellipsis } => {
-                    let (al, ar) = args.split_at(ellipsis.map_or(args.len(), |it| it as usize));
-                    let field_count = match self.result[tgt_pat].kind(Interner) {
-                        TyKind::Tuple(_, s) => s.len(Interner),
-                        _ => break 'reset_span_stack,
-                    };
-                    let fields = 0..field_count;
-                    let it = al.iter().zip(fields.clone()).chain(ar.iter().rev().zip(fields.rev()));
-                    for (&arg, i) in it {
-                        let mut p = place.clone();
-                        self.current_capture_span_stack.push(MirSpan::PatId(arg));
-                        p.projections.push(ProjectionElem::Field(Either::Right(TupleFieldId {
-                            tuple: TupleId(!0), // dummy this, as its unused anyways
-                            index: i as u32,
-                        })));
-                        self.consume_with_pat(p, arg);
-                        self.current_capture_span_stack.pop();
-                    }
-                }
-                Pat::Or(pats) => {
-                    for pat in pats.iter() {
-                        self.consume_with_pat(place.clone(), *pat);
-                    }
-                }
-                Pat::Record { args, .. } => {
-                    let Some(variant) = self.result.variant_resolution_for_pat(tgt_pat) else {
-                        break 'reset_span_stack;
-                    };
-                    match variant {
-                        VariantId::EnumVariantId(_) | VariantId::UnionId(_) => {
-                            self.consume_place(place)
-                        }
-                        VariantId::StructId(s) => {
-                            let vd = s.fields(self.db);
-                            for field_pat in args.iter() {
-                                let arg = field_pat.pat;
-                                let Some(local_id) = vd.field(&field_pat.name) else {
-                                    continue;
-                                };
-                                let mut p = place.clone();
-                                self.current_capture_span_stack.push(MirSpan::PatId(arg));
-                                p.projections.push(ProjectionElem::Field(Either::Left(FieldId {
-                                    parent: variant,
-                                    local_id,
-                                })));
-                                self.consume_with_pat(p, arg);
-                                self.current_capture_span_stack.pop();
-                            }
-                        }
-                    }
-                }
-                Pat::Range { .. } | Pat::Slice { .. } | Pat::ConstBlock(_) | Pat::Lit(_) => {
-                    self.consume_place(place)
-                }
-                Pat::Path(path) => {
-                    if self.inside_assignment {
-                        self.mutate_path_pat(path, tgt_pat);
-                    }
-                    self.consume_place(place);
-                }
-                &Pat::Bind { id, subpat: _ } => {
-                    let mode = self.result.binding_modes[tgt_pat];
-                    let capture_kind = match mode {
-                        BindingMode::Move => {
-                            self.consume_place(place);
-                            break 'reset_span_stack;
-                        }
-                        BindingMode::Ref(Mutability::Not) => BorrowKind::Shared,
-                        BindingMode::Ref(Mutability::Mut) => {
-                            BorrowKind::Mut { kind: MutBorrowKind::Default }
-                        }
-                    };
-                    self.current_capture_span_stack.push(MirSpan::BindingId(id));
-                    self.add_capture(place, CaptureKind::ByRef(capture_kind));
-                    self.current_capture_span_stack.pop();
-                }
-                Pat::TupleStruct { path: _, args, ellipsis } => {
-                    let Some(variant) = self.result.variant_resolution_for_pat(tgt_pat) else {
-                        break 'reset_span_stack;
-                    };
-                    match variant {
-                        VariantId::EnumVariantId(_) | VariantId::UnionId(_) => {
-                            self.consume_place(place)
-                        }
-                        VariantId::StructId(s) => {
-                            let vd = s.fields(self.db);
-                            let (al, ar) =
-                                args.split_at(ellipsis.map_or(args.len(), |it| it as usize));
-                            let fields = vd.fields().iter();
-                            let it = al
-                                .iter()
-                                .zip(fields.clone())
-                                .chain(ar.iter().rev().zip(fields.rev()));
-                            for (&arg, (i, _)) in it {
-                                let mut p = place.clone();
-                                self.current_capture_span_stack.push(MirSpan::PatId(arg));
-                                p.projections.push(ProjectionElem::Field(Either::Left(FieldId {
-                                    parent: variant,
-                                    local_id: i,
-                                })));
-                                self.consume_with_pat(p, arg);
-                                self.current_capture_span_stack.pop();
-                            }
-                        }
-                    }
-                }
-                Pat::Ref { pat, mutability: _ } => {
-                    self.current_capture_span_stack.push(MirSpan::PatId(tgt_pat));
-                    place.projections.push(ProjectionElem::Deref);
-                    self.consume_with_pat(place, *pat);
-                    self.current_capture_span_stack.pop();
-                }
-                Pat::Box { .. } => (), // not supported
-                &Pat::Expr(expr) => {
-                    self.consume_place(place);
-                    let pat_capture_span_stack = mem::take(&mut self.current_capture_span_stack);
-                    let old_inside_assignment = mem::replace(&mut self.inside_assignment, false);
-                    let lhs_place = self.place_of_expr(expr);
-                    self.mutate_expr(expr, lhs_place);
-                    self.inside_assignment = old_inside_assignment;
-                    self.current_capture_span_stack = pat_capture_span_stack;
-                }
-            }
-        }
-        self.current_capture_span_stack
-            .truncate(self.current_capture_span_stack.len() - adjustments_count);
-    }
-
-    fn consume_exprs(&mut self, exprs: impl Iterator<Item = ExprId>) {
-        for expr in exprs {
-            self.consume_expr(expr);
-        }
-    }
-
-    fn closure_kind(&self) -> FnTrait {
-        let mut r = FnTrait::Fn;
-        for it in &self.current_captures {
-            r = cmp::min(
-                r,
-                match &it.kind {
-                    CaptureKind::ByRef(BorrowKind::Mut { .. }) => FnTrait::FnMut,
-                    CaptureKind::ByRef(BorrowKind::Shallow | BorrowKind::Shared) => FnTrait::Fn,
-                    CaptureKind::ByValue => FnTrait::FnOnce,
-                },
-            )
-        }
-        r
-    }
+            None => err_ty,
+        });
 
-    fn analyze_closure(&mut self, closure: ClosureId) -> FnTrait {
-        let InternedClosure(_, root) = self.db.lookup_intern_closure(closure.into());
-        self.current_closure = Some(closure);
-        let Expr::Closure { body, capture_by, .. } = &self.body[root] else {
-            unreachable!("Closure expression id is always closure");
-        };
-        self.consume_expr(*body);
-        for item in &self.current_captures {
-            if matches!(
-                item.kind,
-                CaptureKind::ByRef(BorrowKind::Mut {
-                    kind: MutBorrowKind::Default | MutBorrowKind::TwoPhasedBorrow
-                })
-            ) && !item.place.projections.contains(&ProjectionElem::Deref)
-            {
-                // FIXME: remove the `mutated_bindings_in_closure` completely and add proper fake reads in
-                // MIR. I didn't do that due duplicate diagnostics.
-                self.result.mutated_bindings_in_closure.insert(item.place.local);
-            }
-        }
-        self.restrict_precision_for_unsafe();
-        // `closure_kind` should be done before adjust_for_move_closure
-        // If there exists pre-deduced kind of a closure, use it instead of one determined by capture, as rustc does.
-        // rustc also does diagnostics here if the latter is not a subtype of the former.
-        let closure_kind = self
-            .result
-            .closure_info
-            .get(&closure)
-            .map_or_else(|| self.closure_kind(), |info| info.1);
-        match capture_by {
-            CaptureBy::Value => self.adjust_for_move_closure(),
-            CaptureBy::Ref => (),
-        }
-        self.minimize_captures();
-        self.strip_captures_ref_span();
-        let result = mem::take(&mut self.current_captures);
-        let captures = result.into_iter().map(|it| it.with_ty(self)).collect::<Vec<_>>();
-        self.result.closure_info.insert(closure, (captures, closure_kind));
-        closure_kind
-    }
+        let result = Binder::dummy(interner.mk_fn_sig(
+            supplied_arguments,
+            err_ty,
+            false,
+            Safety::Safe,
+            FnAbi::RustCall,
+        ));
 
-    fn strip_captures_ref_span(&mut self) {
-        // FIXME: Borrow checker won't allow without this.
-        let mut captures = std::mem::take(&mut self.current_captures);
-        for capture in &mut captures {
-            if matches!(capture.kind, CaptureKind::ByValue) {
-                for span_stack in &mut capture.span_stacks {
-                    if span_stack[span_stack.len() - 1].is_ref_span(self.body) {
-                        span_stack.truncate(span_stack.len() - 1);
-                    }
-                }
-            }
-        }
-        self.current_captures = captures;
-    }
+        debug!("supplied_sig_of_closure: result={:?}", result);
 
-    pub(crate) fn infer_closures(&mut self) {
-        let deferred_closures = self.sort_closures();
-        for (closure, exprs) in deferred_closures.into_iter().rev() {
-            self.current_captures = vec![];
-            let kind = self.analyze_closure(closure);
-
-            for (derefed_callee, callee_ty, params, expr) in exprs {
-                if let &Expr::Call { callee, .. } = &self.body[expr] {
-                    let mut adjustments =
-                        self.result.expr_adjustments.remove(&callee).unwrap_or_default().into_vec();
-                    self.write_fn_trait_method_resolution(
-                        kind,
-                        &derefed_callee,
-                        &mut adjustments,
-                        &callee_ty,
-                        &params,
-                        expr,
-                    );
-                    self.result.expr_adjustments.insert(callee, adjustments.into_boxed_slice());
-                }
-            }
-        }
-    }
-
-    /// We want to analyze some closures before others, to have a correct analysis:
-    /// * We should analyze nested closures before the parent, since the parent should capture some of
-    ///   the things that its children captures.
-    /// * If a closure calls another closure, we need to analyze the callee, to find out how we should
-    ///   capture it (e.g. by move for FnOnce)
-    ///
-    /// These dependencies are collected in the main inference. We do a topological sort in this function. It
-    /// will consume the `deferred_closures` field and return its content in a sorted vector.
-    fn sort_closures(&mut self) -> Vec<(ClosureId, Vec<(Ty, Ty, Vec<Ty>, ExprId)>)> {
-        let mut deferred_closures = mem::take(&mut self.deferred_closures);
-        let mut dependents_count: FxHashMap<ClosureId, usize> =
-            deferred_closures.keys().map(|it| (*it, 0)).collect();
-        for deps in self.closure_dependencies.values() {
-            for dep in deps {
-                *dependents_count.entry(*dep).or_default() += 1;
-            }
-        }
-        let mut queue: Vec<_> =
-            deferred_closures.keys().copied().filter(|it| dependents_count[it] == 0).collect();
-        let mut result = vec![];
-        while let Some(it) = queue.pop() {
-            if let Some(d) = deferred_closures.remove(&it) {
-                result.push((it, d));
-            }
-            for dep in self.closure_dependencies.get(&it).into_iter().flat_map(|it| it.iter()) {
-                let cnt = dependents_count.get_mut(dep).unwrap();
-                *cnt -= 1;
-                if *cnt == 0 {
-                    queue.push(*dep);
-                }
-            }
-        }
-        assert!(deferred_closures.is_empty(), "we should have analyzed all closures");
         result
     }
 
-    pub(super) fn add_current_closure_dependency(&mut self, dep: ClosureId) {
-        if let Some(c) = self.current_closure
-            && !dep_creates_cycle(&self.closure_dependencies, &mut FxHashSet::default(), c, dep)
-        {
-            self.closure_dependencies.entry(c).or_default().push(dep);
-        }
-
-        fn dep_creates_cycle(
-            closure_dependencies: &FxHashMap<ClosureId, Vec<ClosureId>>,
-            visited: &mut FxHashSet<ClosureId>,
-            from: ClosureId,
-            to: ClosureId,
-        ) -> bool {
-            if !visited.insert(from) {
-                return false;
-            }
-
-            if from == to {
-                return true;
-            }
-
-            if let Some(deps) = closure_dependencies.get(&to) {
-                for dep in deps {
-                    if dep_creates_cycle(closure_dependencies, visited, from, *dep) {
-                        return true;
-                    }
-                }
-            }
-
-            false
-        }
-    }
-}
-
-/// Call this only when the last span in the stack isn't a split.
-fn apply_adjusts_to_place(
-    current_capture_span_stack: &mut Vec<MirSpan>,
-    mut r: HirPlace,
-    adjustments: &[Adjustment],
-) -> Option<HirPlace> {
-    let span = *current_capture_span_stack.last().expect("empty capture span stack");
-    for adj in adjustments {
-        match &adj.kind {
-            Adjust::Deref(None) => {
-                current_capture_span_stack.push(span);
-                r.projections.push(ProjectionElem::Deref);
-            }
-            _ => return None,
-        }
+    fn closure_sigs(&self, bound_sig: PolyFnSig<'db>) -> ClosureSignatures<'db> {
+        let liberated_sig = bound_sig.skip_binder();
+        // FIXME: When we lower HRTB we'll need to actually liberate regions here.
+        ClosureSignatures { bound_sig, liberated_sig }
     }
-    Some(r)
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure/analysis.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure/analysis.rs
new file mode 100644
index 0000000000000..fd14b9e2de571
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure/analysis.rs
@@ -0,0 +1,1298 @@
+//! Post-inference closure analysis: captures and closure kind.
+
+use std::{cmp, convert::Infallible, mem};
+
+use chalk_ir::{
+    BoundVar, DebruijnIndex, Mutability, TyKind,
+    fold::{FallibleTypeFolder, TypeFoldable},
+};
+use either::Either;
+use hir_def::{
+    DefWithBodyId, FieldId, HasModule, TupleFieldId, TupleId, VariantId,
+    expr_store::path::Path,
+    hir::{
+        Array, AsmOperand, BinaryOp, BindingId, CaptureBy, Expr, ExprId, ExprOrPatId, Pat, PatId,
+        Statement, UnaryOp,
+    },
+    item_tree::FieldsShape,
+    lang_item::LangItem,
+    resolver::ValueNs,
+};
+use hir_expand::name::Name;
+use intern::sym;
+use rustc_hash::{FxHashMap, FxHashSet};
+use smallvec::{SmallVec, smallvec};
+use stdx::{format_to, never};
+use syntax::utils::is_raw_identifier;
+
+use crate::db::InternedClosureId;
+use crate::infer::InferenceContext;
+use crate::{
+    Adjust, Adjustment, Binders, BindingMode, ClosureId, Interner, Substitution, Ty, TyExt,
+    db::{HirDatabase, InternedClosure},
+    error_lifetime, from_placeholder_idx,
+    generics::Generics,
+    make_binders,
+    mir::{BorrowKind, MirSpan, MutBorrowKind, ProjectionElem},
+    traits::FnTrait,
+    utils,
+};
+
+// The below functions handle capture and closure kind (Fn, FnMut, ..)
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub(crate) struct HirPlace {
+    pub(crate) local: BindingId,
+    pub(crate) projections: Vec<ProjectionElem<Infallible, Ty>>,
+}
+
+impl HirPlace {
+    fn ty(&self, ctx: &mut InferenceContext<'_>) -> Ty {
+        let mut ty = ctx.table.resolve_completely(ctx.result[self.local].clone());
+        for p in &self.projections {
+            ty = p.projected_ty(
+                ty,
+                ctx.db,
+                |_, _, _| {
+                    unreachable!("Closure field only happens in MIR");
+                },
+                ctx.owner.module(ctx.db).krate(),
+            );
+        }
+        ty
+    }
+
+    fn capture_kind_of_truncated_place(
+        &self,
+        mut current_capture: CaptureKind,
+        len: usize,
+    ) -> CaptureKind {
+        if let CaptureKind::ByRef(BorrowKind::Mut {
+            kind: MutBorrowKind::Default | MutBorrowKind::TwoPhasedBorrow,
+        }) = current_capture
+            && self.projections[len..].contains(&ProjectionElem::Deref)
+        {
+            current_capture =
+                CaptureKind::ByRef(BorrowKind::Mut { kind: MutBorrowKind::ClosureCapture });
+        }
+        current_capture
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub enum CaptureKind {
+    ByRef(BorrowKind),
+    ByValue,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CapturedItem {
+    pub(crate) place: HirPlace,
+    pub(crate) kind: CaptureKind,
+    /// The inner vec is the stacks; the outer vec is for each capture reference.
+    ///
+    /// Even though we always report only the last span (i.e. the most inclusive span),
+    /// we need to keep them all, since when a closure occurs inside a closure, we
+    /// copy all captures of the inner closure to the outer closure, and then we may
+    /// truncate them, and we want the correct span to be reported.
+    span_stacks: SmallVec<[SmallVec<[MirSpan; 3]>; 3]>,
+    pub(crate) ty: Binders<Ty>,
+}
+
+impl CapturedItem {
+    pub fn local(&self) -> BindingId {
+        self.place.local
+    }
+
+    /// Returns whether this place has any field (aka. non-deref) projections.
+    pub fn has_field_projections(&self) -> bool {
+        self.place.projections.iter().any(|it| !matches!(it, ProjectionElem::Deref))
+    }
+
+    pub fn ty(&self, db: &dyn HirDatabase, subst: &Substitution) -> Ty {
+        self.ty.clone().substitute(Interner, &utils::ClosureSubst(subst).parent_subst(db))
+    }
+
+    pub fn kind(&self) -> CaptureKind {
+        self.kind
+    }
+
+    pub fn spans(&self) -> SmallVec<[MirSpan; 3]> {
+        self.span_stacks.iter().map(|stack| *stack.last().expect("empty span stack")).collect()
+    }
+
+    /// Converts the place to a name that can be inserted into source code.
+    pub fn place_to_name(&self, owner: DefWithBodyId, db: &dyn HirDatabase) -> String {
+        let body = db.body(owner);
+        let mut result = body[self.place.local].name.as_str().to_owned();
+        for proj in &self.place.projections {
+            match proj {
+                ProjectionElem::Deref => {}
+                ProjectionElem::Field(Either::Left(f)) => {
+                    let variant_data = f.parent.fields(db);
+                    match variant_data.shape {
+                        FieldsShape::Record => {
+                            result.push('_');
+                            result.push_str(variant_data.fields()[f.local_id].name.as_str())
+                        }
+                        FieldsShape::Tuple => {
+                            let index =
+                                variant_data.fields().iter().position(|it| it.0 == f.local_id);
+                            if let Some(index) = index {
+                                format_to!(result, "_{index}");
+                            }
+                        }
+                        FieldsShape::Unit => {}
+                    }
+                }
+                ProjectionElem::Field(Either::Right(f)) => format_to!(result, "_{}", f.index),
+                &ProjectionElem::ClosureField(field) => format_to!(result, "_{field}"),
+                ProjectionElem::Index(_)
+                | ProjectionElem::ConstantIndex { .. }
+                | ProjectionElem::Subslice { .. }
+                | ProjectionElem::OpaqueCast(_) => {
+                    never!("Not happen in closure capture");
+                    continue;
+                }
+            }
+        }
+        if is_raw_identifier(&result, owner.module(db).krate().data(db).edition) {
+            result.insert_str(0, "r#");
+        }
+        result
+    }
+
+    pub fn display_place_source_code(&self, owner: DefWithBodyId, db: &dyn HirDatabase) -> String {
+        let body = db.body(owner);
+        let krate = owner.krate(db);
+        let edition = krate.data(db).edition;
+        let mut result = body[self.place.local].name.display(db, edition).to_string();
+        for proj in &self.place.projections {
+            match proj {
+                // In source code autoderef kicks in.
+                ProjectionElem::Deref => {}
+                ProjectionElem::Field(Either::Left(f)) => {
+                    let variant_data = f.parent.fields(db);
+                    match variant_data.shape {
+                        FieldsShape::Record => format_to!(
+                            result,
+                            ".{}",
+                            variant_data.fields()[f.local_id].name.display(db, edition)
+                        ),
+                        FieldsShape::Tuple => format_to!(
+                            result,
+                            ".{}",
+                            variant_data
+                                .fields()
+                                .iter()
+                                .position(|it| it.0 == f.local_id)
+                                .unwrap_or_default()
+                        ),
+                        FieldsShape::Unit => {}
+                    }
+                }
+                ProjectionElem::Field(Either::Right(f)) => {
+                    let field = f.index;
+                    format_to!(result, ".{field}");
+                }
+                &ProjectionElem::ClosureField(field) => {
+                    format_to!(result, ".{field}");
+                }
+                ProjectionElem::Index(_)
+                | ProjectionElem::ConstantIndex { .. }
+                | ProjectionElem::Subslice { .. }
+                | ProjectionElem::OpaqueCast(_) => {
+                    never!("Not happen in closure capture");
+                    continue;
+                }
+            }
+        }
+        let final_derefs_count = self
+            .place
+            .projections
+            .iter()
+            .rev()
+            .take_while(|proj| matches!(proj, ProjectionElem::Deref))
+            .count();
+        result.insert_str(0, &"*".repeat(final_derefs_count));
+        result
+    }
+
+    pub fn display_place(&self, owner: DefWithBodyId, db: &dyn HirDatabase) -> String {
+        let body = db.body(owner);
+        let krate = owner.krate(db);
+        let edition = krate.data(db).edition;
+        let mut result = body[self.place.local].name.display(db, edition).to_string();
+        let mut field_need_paren = false;
+        for proj in &self.place.projections {
+            match proj {
+                ProjectionElem::Deref => {
+                    result = format!("*{result}");
+                    field_need_paren = true;
+                }
+                ProjectionElem::Field(Either::Left(f)) => {
+                    if field_need_paren {
+                        result = format!("({result})");
+                    }
+                    let variant_data = f.parent.fields(db);
+                    let field = match variant_data.shape {
+                        FieldsShape::Record => {
+                            variant_data.fields()[f.local_id].name.as_str().to_owned()
+                        }
+                        FieldsShape::Tuple => variant_data
+                            .fields()
+                            .iter()
+                            .position(|it| it.0 == f.local_id)
+                            .unwrap_or_default()
+                            .to_string(),
+                        FieldsShape::Unit => "[missing field]".to_owned(),
+                    };
+                    result = format!("{result}.{field}");
+                    field_need_paren = false;
+                }
+                ProjectionElem::Field(Either::Right(f)) => {
+                    let field = f.index;
+                    if field_need_paren {
+                        result = format!("({result})");
+                    }
+                    result = format!("{result}.{field}");
+                    field_need_paren = false;
+                }
+                &ProjectionElem::ClosureField(field) => {
+                    if field_need_paren {
+                        result = format!("({result})");
+                    }
+                    result = format!("{result}.{field}");
+                    field_need_paren = false;
+                }
+                ProjectionElem::Index(_)
+                | ProjectionElem::ConstantIndex { .. }
+                | ProjectionElem::Subslice { .. }
+                | ProjectionElem::OpaqueCast(_) => {
+                    never!("Not happen in closure capture");
+                    continue;
+                }
+            }
+        }
+        result
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct CapturedItemWithoutTy {
+    pub(crate) place: HirPlace,
+    pub(crate) kind: CaptureKind,
+    /// The inner vec is the stacks; the outer vec is for each capture reference.
+    pub(crate) span_stacks: SmallVec<[SmallVec<[MirSpan; 3]>; 3]>,
+}
+
+impl CapturedItemWithoutTy {
+    fn with_ty(self, ctx: &mut InferenceContext<'_>) -> CapturedItem {
+        let ty = self.place.ty(ctx);
+        let ty = match &self.kind {
+            CaptureKind::ByValue => ty,
+            CaptureKind::ByRef(bk) => {
+                let m = match bk {
+                    BorrowKind::Mut { .. } => Mutability::Mut,
+                    _ => Mutability::Not,
+                };
+                TyKind::Ref(m, error_lifetime(), ty).intern(Interner)
+            }
+        };
+        return CapturedItem {
+            place: self.place,
+            kind: self.kind,
+            span_stacks: self.span_stacks,
+            ty: replace_placeholder_with_binder(ctx, ty),
+        };
+
+        fn replace_placeholder_with_binder(ctx: &mut InferenceContext<'_>, ty: Ty) -> Binders<Ty> {
+            struct Filler<'a> {
+                db: &'a dyn HirDatabase,
+                generics: &'a Generics,
+            }
+            impl FallibleTypeFolder<Interner> for Filler<'_> {
+                type Error = ();
+
+                fn as_dyn(&mut self) -> &mut dyn FallibleTypeFolder<Interner, Error = Self::Error> {
+                    self
+                }
+
+                fn interner(&self) -> Interner {
+                    Interner
+                }
+
+                fn try_fold_free_placeholder_const(
+                    &mut self,
+                    ty: chalk_ir::Ty<Interner>,
+                    idx: chalk_ir::PlaceholderIndex,
+                    outer_binder: DebruijnIndex,
+                ) -> Result<chalk_ir::Const<Interner>, Self::Error> {
+                    let x = from_placeholder_idx(self.db, idx).0;
+                    let Some(idx) = self.generics.type_or_const_param_idx(x) else {
+                        return Err(());
+                    };
+                    Ok(BoundVar::new(outer_binder, idx).to_const(Interner, ty))
+                }
+
+                fn try_fold_free_placeholder_ty(
+                    &mut self,
+                    idx: chalk_ir::PlaceholderIndex,
+                    outer_binder: DebruijnIndex,
+                ) -> std::result::Result<Ty, Self::Error> {
+                    let x = from_placeholder_idx(self.db, idx).0;
+                    let Some(idx) = self.generics.type_or_const_param_idx(x) else {
+                        return Err(());
+                    };
+                    Ok(BoundVar::new(outer_binder, idx).to_ty(Interner))
+                }
+            }
+            let filler = &mut Filler { db: ctx.db, generics: ctx.generics() };
+            let result = ty.clone().try_fold_with(filler, DebruijnIndex::INNERMOST).unwrap_or(ty);
+            make_binders(ctx.db, filler.generics, result)
+        }
+    }
+}
+
+impl InferenceContext<'_> {
+    fn place_of_expr(&mut self, tgt_expr: ExprId) -> Option<HirPlace> {
+        let r = self.place_of_expr_without_adjust(tgt_expr)?;
+        let adjustments =
+            self.result.expr_adjustments.get(&tgt_expr).map(|it| &**it).unwrap_or_default();
+        apply_adjusts_to_place(&mut self.current_capture_span_stack, r, adjustments)
+    }
+
+    /// Pushes the span into `current_capture_span_stack`, *without clearing it first*.
+    fn path_place(&mut self, path: &Path, id: ExprOrPatId) -> Option<HirPlace> {
+        if path.type_anchor().is_some() {
+            return None;
+        }
+        let hygiene = self.body.expr_or_pat_path_hygiene(id);
+        self.resolver.resolve_path_in_value_ns_fully(self.db, path, hygiene).and_then(|result| {
+            match result {
+                ValueNs::LocalBinding(binding) => {
+                    let mir_span = match id {
+                        ExprOrPatId::ExprId(id) => MirSpan::ExprId(id),
+                        ExprOrPatId::PatId(id) => MirSpan::PatId(id),
+                    };
+                    self.current_capture_span_stack.push(mir_span);
+                    Some(HirPlace { local: binding, projections: Vec::new() })
+                }
+                _ => None,
+            }
+        })
+    }
+
+    /// Changes `current_capture_span_stack` to contain the stack of spans for this expr.
+    fn place_of_expr_without_adjust(&mut self, tgt_expr: ExprId) -> Option<HirPlace> {
+        self.current_capture_span_stack.clear();
+        match &self.body[tgt_expr] {
+            Expr::Path(p) => {
+                let resolver_guard =
+                    self.resolver.update_to_inner_scope(self.db, self.owner, tgt_expr);
+                let result = self.path_place(p, tgt_expr.into());
+                self.resolver.reset_to_guard(resolver_guard);
+                return result;
+            }
+            Expr::Field { expr, name: _ } => {
+                let mut place = self.place_of_expr(*expr)?;
+                let field = self.result.field_resolution(tgt_expr)?;
+                self.current_capture_span_stack.push(MirSpan::ExprId(tgt_expr));
+                place.projections.push(ProjectionElem::Field(field));
+                return Some(place);
+            }
+            Expr::UnaryOp { expr, op: UnaryOp::Deref } => {
+                if matches!(
+                    self.expr_ty_after_adjustments(*expr).kind(Interner),
+                    TyKind::Ref(..) | TyKind::Raw(..)
+                ) {
+                    let mut place = self.place_of_expr(*expr)?;
+                    self.current_capture_span_stack.push(MirSpan::ExprId(tgt_expr));
+                    place.projections.push(ProjectionElem::Deref);
+                    return Some(place);
+                }
+            }
+            _ => (),
+        }
+        None
+    }
+
+    fn push_capture(&mut self, place: HirPlace, kind: CaptureKind) {
+        self.current_captures.push(CapturedItemWithoutTy {
+            place,
+            kind,
+            span_stacks: smallvec![self.current_capture_span_stack.iter().copied().collect()],
+        });
+    }
+
+    fn truncate_capture_spans(&self, capture: &mut CapturedItemWithoutTy, mut truncate_to: usize) {
+        // The first span is the identifier, and it must always remain.
+        truncate_to += 1;
+        for span_stack in &mut capture.span_stacks {
+            let mut remained = truncate_to;
+            let mut actual_truncate_to = 0;
+            for &span in &*span_stack {
+                actual_truncate_to += 1;
+                if !span.is_ref_span(self.body) {
+                    remained -= 1;
+                    if remained == 0 {
+                        break;
+                    }
+                }
+            }
+            if actual_truncate_to < span_stack.len()
+                && span_stack[actual_truncate_to].is_ref_span(self.body)
+            {
+                // Include the ref operator if there is one, we will fix it later (in `strip_captures_ref_span()`) if it's incorrect.
+                actual_truncate_to += 1;
+            }
+            span_stack.truncate(actual_truncate_to);
+        }
+    }
+
+    fn ref_expr(&mut self, expr: ExprId, place: Option<HirPlace>) {
+        if let Some(place) = place {
+            self.add_capture(place, CaptureKind::ByRef(BorrowKind::Shared));
+        }
+        self.walk_expr(expr);
+    }
+
+    fn add_capture(&mut self, place: HirPlace, kind: CaptureKind) {
+        if self.is_upvar(&place) {
+            self.push_capture(place, kind);
+        }
+    }
+
+    fn mutate_path_pat(&mut self, path: &Path, id: PatId) {
+        if let Some(place) = self.path_place(path, id.into()) {
+            self.add_capture(
+                place,
+                CaptureKind::ByRef(BorrowKind::Mut { kind: MutBorrowKind::Default }),
+            );
+            self.current_capture_span_stack.pop(); // Remove the pattern span.
+        }
+    }
+
+    fn mutate_expr(&mut self, expr: ExprId, place: Option<HirPlace>) {
+        if let Some(place) = place {
+            self.add_capture(
+                place,
+                CaptureKind::ByRef(BorrowKind::Mut { kind: MutBorrowKind::Default }),
+            );
+        }
+        self.walk_expr(expr);
+    }
+
+    fn consume_expr(&mut self, expr: ExprId) {
+        if let Some(place) = self.place_of_expr(expr) {
+            self.consume_place(place);
+        }
+        self.walk_expr(expr);
+    }
+
+    fn consume_place(&mut self, place: HirPlace) {
+        if self.is_upvar(&place) {
+            let ty = place.ty(self);
+            let kind = if self.is_ty_copy(ty) {
+                CaptureKind::ByRef(BorrowKind::Shared)
+            } else {
+                CaptureKind::ByValue
+            };
+            self.push_capture(place, kind);
+        }
+    }
+
+    fn walk_expr_with_adjust(&mut self, tgt_expr: ExprId, adjustment: &[Adjustment]) {
+        if let Some((last, rest)) = adjustment.split_last() {
+            match &last.kind {
+                Adjust::NeverToAny | Adjust::Deref(None) | Adjust::Pointer(_) => {
+                    self.walk_expr_with_adjust(tgt_expr, rest)
+                }
+                Adjust::Deref(Some(m)) => match m.0 {
+                    Some(m) => {
+                        self.ref_capture_with_adjusts(m, tgt_expr, rest);
+                    }
+                    None => unreachable!(),
+                },
+                Adjust::Borrow(b) => {
+                    self.ref_capture_with_adjusts(b.mutability(), tgt_expr, rest);
+                }
+            }
+        } else {
+            self.walk_expr_without_adjust(tgt_expr);
+        }
+    }
+
+    fn ref_capture_with_adjusts(&mut self, m: Mutability, tgt_expr: ExprId, rest: &[Adjustment]) {
+        let capture_kind = match m {
+            Mutability::Mut => CaptureKind::ByRef(BorrowKind::Mut { kind: MutBorrowKind::Default }),
+            Mutability::Not => CaptureKind::ByRef(BorrowKind::Shared),
+        };
+        if let Some(place) = self.place_of_expr_without_adjust(tgt_expr)
+            && let Some(place) =
+                apply_adjusts_to_place(&mut self.current_capture_span_stack, place, rest)
+        {
+            self.add_capture(place, capture_kind);
+        }
+        self.walk_expr_with_adjust(tgt_expr, rest);
+    }
+
+    fn walk_expr(&mut self, tgt_expr: ExprId) {
+        if let Some(it) = self.result.expr_adjustments.get_mut(&tgt_expr) {
+            // FIXME: this take is completely unneeded, and just is here to make borrow checker
+            // happy. Remove it if you can.
+            let x_taken = mem::take(it);
+            self.walk_expr_with_adjust(tgt_expr, &x_taken);
+            *self.result.expr_adjustments.get_mut(&tgt_expr).unwrap() = x_taken;
+        } else {
+            self.walk_expr_without_adjust(tgt_expr);
+        }
+    }
+
+    fn walk_expr_without_adjust(&mut self, tgt_expr: ExprId) {
+        match &self.body[tgt_expr] {
+            Expr::OffsetOf(_) => (),
+            Expr::InlineAsm(e) => e.operands.iter().for_each(|(_, op)| match op {
+                AsmOperand::In { expr, .. }
+                | AsmOperand::Out { expr: Some(expr), .. }
+                | AsmOperand::InOut { expr, .. } => self.walk_expr_without_adjust(*expr),
+                AsmOperand::SplitInOut { in_expr, out_expr, .. } => {
+                    self.walk_expr_without_adjust(*in_expr);
+                    if let Some(out_expr) = out_expr {
+                        self.walk_expr_without_adjust(*out_expr);
+                    }
+                }
+                AsmOperand::Out { expr: None, .. }
+                | AsmOperand::Const(_)
+                | AsmOperand::Label(_)
+                | AsmOperand::Sym(_) => (),
+            }),
+            Expr::If { condition, then_branch, else_branch } => {
+                self.consume_expr(*condition);
+                self.consume_expr(*then_branch);
+                if let &Some(expr) = else_branch {
+                    self.consume_expr(expr);
+                }
+            }
+            Expr::Async { statements, tail, .. }
+            | Expr::Unsafe { statements, tail, .. }
+            | Expr::Block { statements, tail, .. } => {
+                for s in statements.iter() {
+                    match s {
+                        Statement::Let { pat, type_ref: _, initializer, else_branch } => {
+                            if let Some(else_branch) = else_branch {
+                                self.consume_expr(*else_branch);
+                            }
+                            if let Some(initializer) = initializer {
+                                if else_branch.is_some() {
+                                    self.consume_expr(*initializer);
+                                } else {
+                                    self.walk_expr(*initializer);
+                                }
+                                if let Some(place) = self.place_of_expr(*initializer) {
+                                    self.consume_with_pat(place, *pat);
+                                }
+                            }
+                        }
+                        Statement::Expr { expr, has_semi: _ } => {
+                            self.consume_expr(*expr);
+                        }
+                        Statement::Item(_) => (),
+                    }
+                }
+                if let Some(tail) = tail {
+                    self.consume_expr(*tail);
+                }
+            }
+            Expr::Call { callee, args } => {
+                self.consume_expr(*callee);
+                self.consume_exprs(args.iter().copied());
+            }
+            Expr::MethodCall { receiver, args, .. } => {
+                self.consume_expr(*receiver);
+                self.consume_exprs(args.iter().copied());
+            }
+            Expr::Match { expr, arms } => {
+                for arm in arms.iter() {
+                    self.consume_expr(arm.expr);
+                    if let Some(guard) = arm.guard {
+                        self.consume_expr(guard);
+                    }
+                }
+                self.walk_expr(*expr);
+                if let Some(discr_place) = self.place_of_expr(*expr)
+                    && self.is_upvar(&discr_place)
+                {
+                    let mut capture_mode = None;
+                    for arm in arms.iter() {
+                        self.walk_pat(&mut capture_mode, arm.pat);
+                    }
+                    if let Some(c) = capture_mode {
+                        self.push_capture(discr_place, c);
+                    }
+                }
+            }
+            Expr::Break { expr, label: _ }
+            | Expr::Return { expr }
+            | Expr::Yield { expr }
+            | Expr::Yeet { expr } => {
+                if let &Some(expr) = expr {
+                    self.consume_expr(expr);
+                }
+            }
+            &Expr::Become { expr } => {
+                self.consume_expr(expr);
+            }
+            Expr::RecordLit { fields, spread, .. } => {
+                if let &Some(expr) = spread {
+                    self.consume_expr(expr);
+                }
+                self.consume_exprs(fields.iter().map(|it| it.expr));
+            }
+            Expr::Field { expr, name: _ } => self.select_from_expr(*expr),
+            Expr::UnaryOp { expr, op: UnaryOp::Deref } => {
+                if matches!(
+                    self.expr_ty_after_adjustments(*expr).kind(Interner),
+                    TyKind::Ref(..) | TyKind::Raw(..)
+                ) {
+                    self.select_from_expr(*expr);
+                } else if let Some((f, _)) = self.result.method_resolution(tgt_expr) {
+                    let mutability = 'b: {
+                        if let Some(deref_trait) =
+                            self.resolve_lang_item(LangItem::DerefMut).and_then(|it| it.as_trait())
+                            && let Some(deref_fn) = deref_trait
+                                .trait_items(self.db)
+                                .method_by_name(&Name::new_symbol_root(sym::deref_mut))
+                        {
+                            break 'b deref_fn == f;
+                        }
+                        false
+                    };
+                    let place = self.place_of_expr(*expr);
+                    if mutability {
+                        self.mutate_expr(*expr, place);
+                    } else {
+                        self.ref_expr(*expr, place);
+                    }
+                } else {
+                    self.select_from_expr(*expr);
+                }
+            }
+            Expr::Let { pat, expr } => {
+                self.walk_expr(*expr);
+                if let Some(place) = self.place_of_expr(*expr) {
+                    self.consume_with_pat(place, *pat);
+                }
+            }
+            Expr::UnaryOp { expr, op: _ }
+            | Expr::Array(Array::Repeat { initializer: expr, repeat: _ })
+            | Expr::Await { expr }
+            | Expr::Loop { body: expr, label: _ }
+            | Expr::Box { expr }
+            | Expr::Cast { expr, type_ref: _ } => {
+                self.consume_expr(*expr);
+            }
+            Expr::Ref { expr, rawness: _, mutability } => {
+                // We need to do this before we push the span so the order will be correct.
+                let place = self.place_of_expr(*expr);
+                self.current_capture_span_stack.push(MirSpan::ExprId(tgt_expr));
+                match mutability {
+                    hir_def::type_ref::Mutability::Shared => self.ref_expr(*expr, place),
+                    hir_def::type_ref::Mutability::Mut => self.mutate_expr(*expr, place),
+                }
+            }
+            Expr::BinaryOp { lhs, rhs, op } => {
+                let Some(op) = op else {
+                    return;
+                };
+                if matches!(op, BinaryOp::Assignment { .. }) {
+                    let place = self.place_of_expr(*lhs);
+                    self.mutate_expr(*lhs, place);
+                    self.consume_expr(*rhs);
+                    return;
+                }
+                self.consume_expr(*lhs);
+                self.consume_expr(*rhs);
+            }
+            Expr::Range { lhs, rhs, range_type: _ } => {
+                if let &Some(expr) = lhs {
+                    self.consume_expr(expr);
+                }
+                if let &Some(expr) = rhs {
+                    self.consume_expr(expr);
+                }
+            }
+            Expr::Index { base, index } => {
+                self.select_from_expr(*base);
+                self.consume_expr(*index);
+            }
+            Expr::Closure { .. } => {
+                let ty = self.expr_ty(tgt_expr);
+                let TyKind::Closure(id, _) = ty.kind(Interner) else {
+                    never!("closure type is always closure");
+                    return;
+                };
+                let (captures, _) =
+                    self.result.closure_info.get(id).expect(
+                        "We sort closures, so we should always have data for inner closures",
+                    );
+                let mut cc = mem::take(&mut self.current_captures);
+                cc.extend(captures.iter().filter(|it| self.is_upvar(&it.place)).map(|it| {
+                    CapturedItemWithoutTy {
+                        place: it.place.clone(),
+                        kind: it.kind,
+                        span_stacks: it.span_stacks.clone(),
+                    }
+                }));
+                self.current_captures = cc;
+            }
+            Expr::Array(Array::ElementList { elements: exprs }) | Expr::Tuple { exprs } => {
+                self.consume_exprs(exprs.iter().copied())
+            }
+            &Expr::Assignment { target, value } => {
+                self.walk_expr(value);
+                let resolver_guard =
+                    self.resolver.update_to_inner_scope(self.db, self.owner, tgt_expr);
+                match self.place_of_expr(value) {
+                    Some(rhs_place) => {
+                        self.inside_assignment = true;
+                        self.consume_with_pat(rhs_place, target);
+                        self.inside_assignment = false;
+                    }
+                    None => self.body.walk_pats(target, &mut |pat| match &self.body[pat] {
+                        Pat::Path(path) => self.mutate_path_pat(path, pat),
+                        &Pat::Expr(expr) => {
+                            let place = self.place_of_expr(expr);
+                            self.mutate_expr(expr, place);
+                        }
+                        _ => {}
+                    }),
+                }
+                self.resolver.reset_to_guard(resolver_guard);
+            }
+
+            Expr::Missing
+            | Expr::Continue { .. }
+            | Expr::Path(_)
+            | Expr::Literal(_)
+            | Expr::Const(_)
+            | Expr::Underscore => (),
+        }
+    }
+
+    fn walk_pat(&mut self, result: &mut Option<CaptureKind>, pat: PatId) {
+        let mut update_result = |ck: CaptureKind| match result {
+            Some(r) => {
+                *r = cmp::max(*r, ck);
+            }
+            None => *result = Some(ck),
+        };
+
+        self.walk_pat_inner(
+            pat,
+            &mut update_result,
+            BorrowKind::Mut { kind: MutBorrowKind::Default },
+        );
+    }
+
+    fn walk_pat_inner(
+        &mut self,
+        p: PatId,
+        update_result: &mut impl FnMut(CaptureKind),
+        mut for_mut: BorrowKind,
+    ) {
+        match &self.body[p] {
+            Pat::Ref { .. }
+            | Pat::Box { .. }
+            | Pat::Missing
+            | Pat::Wild
+            | Pat::Tuple { .. }
+            | Pat::Expr(_)
+            | Pat::Or(_) => (),
+            Pat::TupleStruct { .. } | Pat::Record { .. } => {
+                if let Some(variant) = self.result.variant_resolution_for_pat(p) {
+                    let adt = variant.adt_id(self.db);
+                    let is_multivariant = match adt {
+                        hir_def::AdtId::EnumId(e) => e.enum_variants(self.db).variants.len() != 1,
+                        _ => false,
+                    };
+                    if is_multivariant {
+                        update_result(CaptureKind::ByRef(BorrowKind::Shared));
+                    }
+                }
+            }
+            Pat::Slice { .. }
+            | Pat::ConstBlock(_)
+            | Pat::Path(_)
+            | Pat::Lit(_)
+            | Pat::Range { .. } => {
+                update_result(CaptureKind::ByRef(BorrowKind::Shared));
+            }
+            Pat::Bind { id, .. } => match self.result.binding_modes[p] {
+                crate::BindingMode::Move => {
+                    if self.is_ty_copy(self.result.type_of_binding[*id].clone()) {
+                        update_result(CaptureKind::ByRef(BorrowKind::Shared));
+                    } else {
+                        update_result(CaptureKind::ByValue);
+                    }
+                }
+                crate::BindingMode::Ref(r) => match r {
+                    Mutability::Mut => update_result(CaptureKind::ByRef(for_mut)),
+                    Mutability::Not => update_result(CaptureKind::ByRef(BorrowKind::Shared)),
+                },
+            },
+        }
+        if self.result.pat_adjustments.get(&p).is_some_and(|it| !it.is_empty()) {
+            for_mut = BorrowKind::Mut { kind: MutBorrowKind::ClosureCapture };
+        }
+        self.body.walk_pats_shallow(p, |p| self.walk_pat_inner(p, update_result, for_mut));
+    }
+
+    fn expr_ty(&self, expr: ExprId) -> Ty {
+        self.result[expr].clone()
+    }
+
+    fn expr_ty_after_adjustments(&self, e: ExprId) -> Ty {
+        let mut ty = None;
+        if let Some(it) = self.result.expr_adjustments.get(&e)
+            && let Some(it) = it.last()
+        {
+            ty = Some(it.target.clone());
+        }
+        ty.unwrap_or_else(|| self.expr_ty(e))
+    }
+
+    fn is_upvar(&self, place: &HirPlace) -> bool {
+        if let Some(c) = self.current_closure {
+            let InternedClosure(_, root) = self.db.lookup_intern_closure(c);
+            return self.body.is_binding_upvar(place.local, root);
+        }
+        false
+    }
+
+    fn is_ty_copy(&mut self, ty: Ty) -> bool {
+        if let TyKind::Closure(id, _) = ty.kind(Interner) {
+            // FIXME: We handle closure as a special case, since chalk consider every closure as copy. We
+            // should probably let chalk know which closures are copy, but I don't know how doing it
+            // without creating query cycles.
+            return self.result.closure_info.get(id).map(|it| it.1 == FnTrait::Fn).unwrap_or(true);
+        }
+        self.table.resolve_completely(ty).is_copy(self.db, self.owner)
+    }
+
+    fn select_from_expr(&mut self, expr: ExprId) {
+        self.walk_expr(expr);
+    }
+
+    fn restrict_precision_for_unsafe(&mut self) {
+        // FIXME: Borrow checker problems without this.
+        let mut current_captures = std::mem::take(&mut self.current_captures);
+        for capture in &mut current_captures {
+            let mut ty = self.table.resolve_completely(self.result[capture.place.local].clone());
+            if ty.as_raw_ptr().is_some() || ty.is_union() {
+                capture.kind = CaptureKind::ByRef(BorrowKind::Shared);
+                self.truncate_capture_spans(capture, 0);
+                capture.place.projections.truncate(0);
+                continue;
+            }
+            for (i, p) in capture.place.projections.iter().enumerate() {
+                ty = p.projected_ty(
+                    ty,
+                    self.db,
+                    |_, _, _| {
+                        unreachable!("Closure field only happens in MIR");
+                    },
+                    self.owner.module(self.db).krate(),
+                );
+                if ty.as_raw_ptr().is_some() || ty.is_union() {
+                    capture.kind = CaptureKind::ByRef(BorrowKind::Shared);
+                    self.truncate_capture_spans(capture, i + 1);
+                    capture.place.projections.truncate(i + 1);
+                    break;
+                }
+            }
+        }
+        self.current_captures = current_captures;
+    }
+
+    fn adjust_for_move_closure(&mut self) {
+        // FIXME: Borrow checker won't allow without this.
+        let mut current_captures = std::mem::take(&mut self.current_captures);
+        for capture in &mut current_captures {
+            if let Some(first_deref) =
+                capture.place.projections.iter().position(|proj| *proj == ProjectionElem::Deref)
+            {
+                self.truncate_capture_spans(capture, first_deref);
+                capture.place.projections.truncate(first_deref);
+            }
+            capture.kind = CaptureKind::ByValue;
+        }
+        self.current_captures = current_captures;
+    }
+
+    fn minimize_captures(&mut self) {
+        self.current_captures.sort_unstable_by_key(|it| it.place.projections.len());
+        let mut hash_map = FxHashMap::<HirPlace, usize>::default();
+        let result = mem::take(&mut self.current_captures);
+        for mut item in result {
+            let mut lookup_place = HirPlace { local: item.place.local, projections: vec![] };
+            let mut it = item.place.projections.iter();
+            let prev_index = loop {
+                if let Some(k) = hash_map.get(&lookup_place) {
+                    break Some(*k);
+                }
+                match it.next() {
+                    Some(it) => {
+                        lookup_place.projections.push(it.clone());
+                    }
+                    None => break None,
+                }
+            };
+            match prev_index {
+                Some(p) => {
+                    let prev_projections_len = self.current_captures[p].place.projections.len();
+                    self.truncate_capture_spans(&mut item, prev_projections_len);
+                    self.current_captures[p].span_stacks.extend(item.span_stacks);
+                    let len = self.current_captures[p].place.projections.len();
+                    let kind_after_truncate =
+                        item.place.capture_kind_of_truncated_place(item.kind, len);
+                    self.current_captures[p].kind =
+                        cmp::max(kind_after_truncate, self.current_captures[p].kind);
+                }
+                None => {
+                    hash_map.insert(item.place.clone(), self.current_captures.len());
+                    self.current_captures.push(item);
+                }
+            }
+        }
+    }
+
+    fn consume_with_pat(&mut self, mut place: HirPlace, tgt_pat: PatId) {
+        let adjustments_count =
+            self.result.pat_adjustments.get(&tgt_pat).map(|it| it.len()).unwrap_or_default();
+        place.projections.extend((0..adjustments_count).map(|_| ProjectionElem::Deref));
+        self.current_capture_span_stack
+            .extend((0..adjustments_count).map(|_| MirSpan::PatId(tgt_pat)));
+        'reset_span_stack: {
+            match &self.body[tgt_pat] {
+                Pat::Missing | Pat::Wild => (),
+                Pat::Tuple { args, ellipsis } => {
+                    let (al, ar) = args.split_at(ellipsis.map_or(args.len(), |it| it as usize));
+                    let field_count = match self.result[tgt_pat].kind(Interner) {
+                        TyKind::Tuple(_, s) => s.len(Interner),
+                        _ => break 'reset_span_stack,
+                    };
+                    let fields = 0..field_count;
+                    let it = al.iter().zip(fields.clone()).chain(ar.iter().rev().zip(fields.rev()));
+                    for (&arg, i) in it {
+                        let mut p = place.clone();
+                        self.current_capture_span_stack.push(MirSpan::PatId(arg));
+                        p.projections.push(ProjectionElem::Field(Either::Right(TupleFieldId {
+                            tuple: TupleId(!0), // dummy this, as its unused anyways
+                            index: i as u32,
+                        })));
+                        self.consume_with_pat(p, arg);
+                        self.current_capture_span_stack.pop();
+                    }
+                }
+                Pat::Or(pats) => {
+                    for pat in pats.iter() {
+                        self.consume_with_pat(place.clone(), *pat);
+                    }
+                }
+                Pat::Record { args, .. } => {
+                    let Some(variant) = self.result.variant_resolution_for_pat(tgt_pat) else {
+                        break 'reset_span_stack;
+                    };
+                    match variant {
+                        VariantId::EnumVariantId(_) | VariantId::UnionId(_) => {
+                            self.consume_place(place)
+                        }
+                        VariantId::StructId(s) => {
+                            let vd = s.fields(self.db);
+                            for field_pat in args.iter() {
+                                let arg = field_pat.pat;
+                                let Some(local_id) = vd.field(&field_pat.name) else {
+                                    continue;
+                                };
+                                let mut p = place.clone();
+                                self.current_capture_span_stack.push(MirSpan::PatId(arg));
+                                p.projections.push(ProjectionElem::Field(Either::Left(FieldId {
+                                    parent: variant,
+                                    local_id,
+                                })));
+                                self.consume_with_pat(p, arg);
+                                self.current_capture_span_stack.pop();
+                            }
+                        }
+                    }
+                }
+                Pat::Range { .. } | Pat::Slice { .. } | Pat::ConstBlock(_) | Pat::Lit(_) => {
+                    self.consume_place(place)
+                }
+                Pat::Path(path) => {
+                    if self.inside_assignment {
+                        self.mutate_path_pat(path, tgt_pat);
+                    }
+                    self.consume_place(place);
+                }
+                &Pat::Bind { id, subpat: _ } => {
+                    let mode = self.result.binding_modes[tgt_pat];
+                    let capture_kind = match mode {
+                        BindingMode::Move => {
+                            self.consume_place(place);
+                            break 'reset_span_stack;
+                        }
+                        BindingMode::Ref(Mutability::Not) => BorrowKind::Shared,
+                        BindingMode::Ref(Mutability::Mut) => {
+                            BorrowKind::Mut { kind: MutBorrowKind::Default }
+                        }
+                    };
+                    self.current_capture_span_stack.push(MirSpan::BindingId(id));
+                    self.add_capture(place, CaptureKind::ByRef(capture_kind));
+                    self.current_capture_span_stack.pop();
+                }
+                Pat::TupleStruct { path: _, args, ellipsis } => {
+                    let Some(variant) = self.result.variant_resolution_for_pat(tgt_pat) else {
+                        break 'reset_span_stack;
+                    };
+                    match variant {
+                        VariantId::EnumVariantId(_) | VariantId::UnionId(_) => {
+                            self.consume_place(place)
+                        }
+                        VariantId::StructId(s) => {
+                            let vd = s.fields(self.db);
+                            let (al, ar) =
+                                args.split_at(ellipsis.map_or(args.len(), |it| it as usize));
+                            let fields = vd.fields().iter();
+                            let it = al
+                                .iter()
+                                .zip(fields.clone())
+                                .chain(ar.iter().rev().zip(fields.rev()));
+                            for (&arg, (i, _)) in it {
+                                let mut p = place.clone();
+                                self.current_capture_span_stack.push(MirSpan::PatId(arg));
+                                p.projections.push(ProjectionElem::Field(Either::Left(FieldId {
+                                    parent: variant,
+                                    local_id: i,
+                                })));
+                                self.consume_with_pat(p, arg);
+                                self.current_capture_span_stack.pop();
+                            }
+                        }
+                    }
+                }
+                Pat::Ref { pat, mutability: _ } => {
+                    self.current_capture_span_stack.push(MirSpan::PatId(tgt_pat));
+                    place.projections.push(ProjectionElem::Deref);
+                    self.consume_with_pat(place, *pat);
+                    self.current_capture_span_stack.pop();
+                }
+                Pat::Box { .. } => (), // not supported
+                &Pat::Expr(expr) => {
+                    self.consume_place(place);
+                    let pat_capture_span_stack = mem::take(&mut self.current_capture_span_stack);
+                    let old_inside_assignment = mem::replace(&mut self.inside_assignment, false);
+                    let lhs_place = self.place_of_expr(expr);
+                    self.mutate_expr(expr, lhs_place);
+                    self.inside_assignment = old_inside_assignment;
+                    self.current_capture_span_stack = pat_capture_span_stack;
+                }
+            }
+        }
+        self.current_capture_span_stack
+            .truncate(self.current_capture_span_stack.len() - adjustments_count);
+    }
+
+    fn consume_exprs(&mut self, exprs: impl Iterator<Item = ExprId>) {
+        for expr in exprs {
+            self.consume_expr(expr);
+        }
+    }
+
+    fn closure_kind(&self) -> FnTrait {
+        let mut r = FnTrait::Fn;
+        for it in &self.current_captures {
+            r = cmp::min(
+                r,
+                match &it.kind {
+                    CaptureKind::ByRef(BorrowKind::Mut { .. }) => FnTrait::FnMut,
+                    CaptureKind::ByRef(BorrowKind::Shallow | BorrowKind::Shared) => FnTrait::Fn,
+                    CaptureKind::ByValue => FnTrait::FnOnce,
+                },
+            )
+        }
+        r
+    }
+
+    fn analyze_closure(&mut self, closure: ClosureId) -> FnTrait {
+        let InternedClosure(_, root) = self.db.lookup_intern_closure(closure.into());
+        self.current_closure = Some(closure.into());
+        let Expr::Closure { body, capture_by, .. } = &self.body[root] else {
+            unreachable!("Closure expression id is always closure");
+        };
+        self.consume_expr(*body);
+        for item in &self.current_captures {
+            if matches!(
+                item.kind,
+                CaptureKind::ByRef(BorrowKind::Mut {
+                    kind: MutBorrowKind::Default | MutBorrowKind::TwoPhasedBorrow
+                })
+            ) && !item.place.projections.contains(&ProjectionElem::Deref)
+            {
+                // FIXME: remove the `mutated_bindings_in_closure` completely and add proper fake reads in
+                // MIR. I didn't do that due duplicate diagnostics.
+                self.result.mutated_bindings_in_closure.insert(item.place.local);
+            }
+        }
+        self.restrict_precision_for_unsafe();
+        // `closure_kind` should be done before adjust_for_move_closure
+        // If there exists pre-deduced kind of a closure, use it instead of one determined by capture, as rustc does.
+        // rustc also does diagnostics here if the latter is not a subtype of the former.
+        let closure_kind = self
+            .result
+            .closure_info
+            .get(&closure)
+            .map_or_else(|| self.closure_kind(), |info| info.1);
+        match capture_by {
+            CaptureBy::Value => self.adjust_for_move_closure(),
+            CaptureBy::Ref => (),
+        }
+        self.minimize_captures();
+        self.strip_captures_ref_span();
+        let result = mem::take(&mut self.current_captures);
+        let captures = result.into_iter().map(|it| it.with_ty(self)).collect::<Vec<_>>();
+        self.result.closure_info.insert(closure, (captures, closure_kind));
+        closure_kind
+    }
+
+    fn strip_captures_ref_span(&mut self) {
+        // FIXME: Borrow checker won't allow without this.
+        let mut captures = std::mem::take(&mut self.current_captures);
+        for capture in &mut captures {
+            if matches!(capture.kind, CaptureKind::ByValue) {
+                for span_stack in &mut capture.span_stacks {
+                    if span_stack[span_stack.len() - 1].is_ref_span(self.body) {
+                        span_stack.truncate(span_stack.len() - 1);
+                    }
+                }
+            }
+        }
+        self.current_captures = captures;
+    }
+
+    pub(crate) fn infer_closures(&mut self) {
+        let deferred_closures = self.sort_closures();
+        for (closure, exprs) in deferred_closures.into_iter().rev() {
+            self.current_captures = vec![];
+            let kind = self.analyze_closure(closure);
+
+            for (derefed_callee, callee_ty, params, expr) in exprs {
+                if let &Expr::Call { callee, .. } = &self.body[expr] {
+                    let mut adjustments =
+                        self.result.expr_adjustments.remove(&callee).unwrap_or_default().into_vec();
+                    self.write_fn_trait_method_resolution(
+                        kind,
+                        &derefed_callee,
+                        &mut adjustments,
+                        &callee_ty,
+                        &params,
+                        expr,
+                    );
+                    self.result.expr_adjustments.insert(callee, adjustments.into_boxed_slice());
+                }
+            }
+        }
+    }
+
+    /// We want to analyze some closures before others, to have a correct analysis:
+    /// * We should analyze nested closures before the parent, since the parent should capture some of
+    ///   the things that its children captures.
+    /// * If a closure calls another closure, we need to analyze the callee, to find out how we should
+    ///   capture it (e.g. by move for FnOnce)
+    ///
+    /// These dependencies are collected in the main inference. We do a topological sort in this function. It
+    /// will consume the `deferred_closures` field and return its content in a sorted vector.
+    fn sort_closures(&mut self) -> Vec<(ClosureId, Vec<(Ty, Ty, Vec<Ty>, ExprId)>)> {
+        let mut deferred_closures = mem::take(&mut self.deferred_closures);
+        let mut dependents_count: FxHashMap<ClosureId, usize> =
+            deferred_closures.keys().map(|it| ((*it).into(), 0)).collect();
+        for deps in self.closure_dependencies.values() {
+            for dep in deps {
+                *dependents_count.entry((*dep).into()).or_default() += 1;
+            }
+        }
+        let mut queue: Vec<_> = deferred_closures
+            .keys()
+            .copied()
+            .filter(|&it| dependents_count[&it.into()] == 0)
+            .collect();
+        let mut result = vec![];
+        while let Some(it) = queue.pop() {
+            if let Some(d) = deferred_closures.remove(&it) {
+                result.push((it.into(), d));
+            }
+            for &dep in self.closure_dependencies.get(&it).into_iter().flat_map(|it| it.iter()) {
+                let cnt = dependents_count.get_mut(&dep.into()).unwrap();
+                *cnt -= 1;
+                if *cnt == 0 {
+                    queue.push(dep);
+                }
+            }
+        }
+        assert!(deferred_closures.is_empty(), "we should have analyzed all closures");
+        result
+    }
+
+    pub(crate) fn add_current_closure_dependency(&mut self, dep: InternedClosureId) {
+        if let Some(c) = self.current_closure
+            && !dep_creates_cycle(&self.closure_dependencies, &mut FxHashSet::default(), c, dep)
+        {
+            self.closure_dependencies.entry(c).or_default().push(dep);
+        }
+
+        fn dep_creates_cycle(
+            closure_dependencies: &FxHashMap<InternedClosureId, Vec<InternedClosureId>>,
+            visited: &mut FxHashSet<InternedClosureId>,
+            from: InternedClosureId,
+            to: InternedClosureId,
+        ) -> bool {
+            if !visited.insert(from) {
+                return false;
+            }
+
+            if from == to {
+                return true;
+            }
+
+            if let Some(deps) = closure_dependencies.get(&to) {
+                for dep in deps {
+                    if dep_creates_cycle(closure_dependencies, visited, from, *dep) {
+                        return true;
+                    }
+                }
+            }
+
+            false
+        }
+    }
+}
+
+/// Call this only when the last span in the stack isn't a split.
+fn apply_adjusts_to_place(
+    current_capture_span_stack: &mut Vec<MirSpan>,
+    mut r: HirPlace,
+    adjustments: &[Adjustment],
+) -> Option<HirPlace> {
+    let span = *current_capture_span_stack.last().expect("empty capture span stack");
+    for adj in adjustments {
+        match &adj.kind {
+            Adjust::Deref(None) => {
+                current_capture_span_stack.push(span);
+                r.projections.push(ProjectionElem::Deref);
+            }
+            _ => return None,
+        }
+    }
+    Some(r)
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
index df516662bfd37..88b10e87e531e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
@@ -1,452 +1,388 @@
-//! Coercion logic. Coercions are certain type conversions that can implicitly
-//! happen in certain places, e.g. weakening `&mut` to `&` or deref coercions
-//! like going from `&Vec<T>` to `&[T]`.
+//! # Type Coercion
 //!
-//! See <https://doc.rust-lang.org/nomicon/coercions.html> and
-//! `rustc_hir_analysis/check/coercion.rs`.
-
-use std::iter;
-
-use chalk_ir::{BoundVar, Mutability, TyKind, TyVariableKind, cast::Cast};
-use hir_def::{hir::ExprId, lang_item::LangItem};
-use rustc_type_ir::solve::Certainty;
-use stdx::always;
+//! Under certain circumstances we will coerce from one type to another,
+//! for example by auto-borrowing. This occurs in situations where the
+//! compiler has a firm 'expected type' that was supplied from the user,
+//! and where the actual type is similar to that expected type in purpose
+//! but not in representation (so actual subtyping is inappropriate).
+//!
+//! ## Reborrowing
+//!
+//! Note that if we are expecting a reference, we will *reborrow*
+//! even if the argument provided was already a reference. This is
+//! useful for freezing mut things (that is, when the expected type is &T
+//! but you have &mut T) and also for avoiding the linearity
+//! of mut things (when the expected is &mut T and you have &mut T). See
+//! the various `tests/ui/coerce/*.rs` tests for
+//! examples of where this is useful.
+//!
+//! ## Subtle note
+//!
+//! When inferring the generic arguments of functions, the argument
+//! order is relevant, which can lead to the following edge case:
+//!
+//! ```ignore (illustrative)
+//! fn foo<T>(a: T, b: T) {
+//!     // ...
+//! }
+//!
+//! foo(&7i32, &mut 7i32);
+//! // This compiles, as we first infer `T` to be `&i32`,
+//! // and then coerce `&mut 7i32` to `&7i32`.
+//!
+//! foo(&mut 7i32, &7i32);
+//! // This does not compile, as we first infer `T` to be `&mut i32`
+//! // and are then unable to coerce `&7i32` to `&mut i32`.
+//! ```
+
+use chalk_ir::cast::Cast;
+use hir_def::{
+    CallableDefId,
+    hir::{ExprId, ExprOrPatId},
+    lang_item::LangItem,
+    signatures::FunctionSignature,
+};
+use intern::sym;
+use rustc_ast_ir::Mutability;
+use rustc_type_ir::{
+    TypeAndMut,
+    error::TypeError,
+    inherent::{IntoKind, Safety, Ty as _},
+};
+use smallvec::{SmallVec, smallvec};
+use tracing::{debug, instrument};
 use triomphe::Arc;
 
 use crate::{
-    Canonical, FnAbi, FnPointer, FnSig, Goal, Interner, Lifetime, Substitution, TraitEnvironment,
-    Ty, TyBuilder, TyExt,
-    autoderef::{Autoderef, AutoderefKind},
-    db::HirDatabase,
-    infer::{
-        Adjust, Adjustment, AutoBorrow, InferOk, InferenceContext, OverloadedDeref, PointerCast,
-        TypeError, TypeMismatch,
+    Adjust, Adjustment, AutoBorrow, Interner, PointerCast, TargetFeatures, TraitEnvironment,
+    autoderef::Autoderef,
+    db::{HirDatabase, InternedClosureId},
+    infer::{AllowTwoPhase, InferenceContext, TypeMismatch, unify::InferenceTable},
+    next_solver::{
+        Binder, CallableIdWrapper, ClauseKind, CoercePredicate, DbInterner, ErrorGuaranteed,
+        GenericArgs, PolyFnSig, PredicateKind, Region, SolverDefId, TraitRef, Ty, TyKind,
+        infer::{
+            DefineOpaqueTypes, InferCtxt, InferOk, InferResult,
+            relate::RelateResult,
+            select::{ImplSource, SelectionError},
+            traits::{Obligation, ObligationCause, PredicateObligation, PredicateObligations},
+        },
+        mapping::{ChalkToNextSolver, NextSolverToChalk},
+        obligation_ctxt::ObligationCtxt,
     },
-    next_solver,
-    utils::ClosureSubst,
+    utils::TargetFeatureIsSafeInTarget,
 };
 
-use super::unify::InferenceTable;
-
-pub(crate) type CoerceResult<'db> = Result<InferOk<'db, (Vec<Adjustment>, Ty)>, TypeError>;
-
-/// Do not require any adjustments, i.e. coerce `x -> x`.
-fn identity(_: Ty) -> Vec<Adjustment> {
-    vec![]
+struct Coerce<'a, 'b, 'db> {
+    table: &'a mut InferenceTable<'db>,
+    has_errors: &'a mut bool,
+    target_features: &'a mut dyn FnMut() -> (&'b TargetFeatures, TargetFeatureIsSafeInTarget),
+    use_lub: bool,
+    /// Determines whether or not allow_two_phase_borrow is set on any
+    /// autoref adjustments we create while coercing. We don't want to
+    /// allow deref coercions to create two-phase borrows, at least initially,
+    /// but we do need two-phase borrows for function argument reborrows.
+    /// See rust#47489 and rust#48598
+    /// See docs on the "AllowTwoPhase" type for a more detailed discussion
+    allow_two_phase: AllowTwoPhase,
+    /// Whether we allow `NeverToAny` coercions. This is unsound if we're
+    /// coercing a place expression without it counting as a read in the MIR.
+    /// This is a side-effect of HIR not really having a great distinction
+    /// between places and values.
+    coerce_never: bool,
+    cause: ObligationCause,
 }
 
-fn simple(kind: Adjust) -> impl FnOnce(Ty) -> Vec<Adjustment> {
-    move |target| vec![Adjustment { kind, target }]
+type CoerceResult<'db> = InferResult<'db, (Vec<Adjustment>, Ty<'db>)>;
+
+/// Coercing a mutable reference to an immutable works, while
+/// coercing `&T` to `&mut T` should be forbidden.
+fn coerce_mutbls<'db>(from_mutbl: Mutability, to_mutbl: Mutability) -> RelateResult<'db, ()> {
+    if from_mutbl >= to_mutbl { Ok(()) } else { Err(TypeError::Mutability) }
 }
 
 /// This always returns `Ok(...)`.
 fn success<'db>(
     adj: Vec<Adjustment>,
-    target: Ty,
-    goals: Vec<next_solver::Goal<'db, next_solver::Predicate<'db>>>,
+    target: Ty<'db>,
+    obligations: PredicateObligations<'db>,
 ) -> CoerceResult<'db> {
-    Ok(InferOk { goals, value: (adj, target) })
-}
-
-pub(super) enum CoercionCause {
-    // FIXME: Make better use of this. Right now things like return and break without a value
-    // use it to point to themselves, causing us to report a mismatch on those expressions even
-    // though technically they themselves are `!`
-    Expr(ExprId),
-}
-
-#[derive(Clone, Debug)]
-pub(super) struct CoerceMany {
-    expected_ty: Ty,
-    final_ty: Option<Ty>,
-    expressions: Vec<ExprId>,
+    Ok(InferOk { value: (adj, target), obligations })
 }
 
-impl CoerceMany {
-    pub(super) fn new(expected: Ty) -> Self {
-        CoerceMany { expected_ty: expected, final_ty: None, expressions: vec![] }
-    }
-
-    /// Returns the "expected type" with which this coercion was
-    /// constructed. This represents the "downward propagated" type
-    /// that was given to us at the start of typing whatever construct
-    /// we are typing (e.g., the match expression).
-    ///
-    /// Typically, this is used as the expected type when
-    /// type-checking each of the alternative expressions whose types
-    /// we are trying to merge.
-    pub(super) fn expected_ty(&self) -> Ty {
-        self.expected_ty.clone()
-    }
-
-    /// Returns the current "merged type", representing our best-guess
-    /// 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(super) fn merged_ty(&self) -> Ty {
-        self.final_ty.clone().unwrap_or_else(|| self.expected_ty.clone())
+impl<'a, 'b, 'db> Coerce<'a, 'b, 'db> {
+    #[inline]
+    fn set_tainted_by_errors(&mut self) {
+        *self.has_errors = true;
     }
 
-    pub(super) fn complete(self, ctx: &mut InferenceContext<'_>) -> Ty {
-        if let Some(final_ty) = self.final_ty {
-            final_ty
-        } else {
-            ctx.result.standard_types.never.clone()
-        }
+    #[inline]
+    fn interner(&self) -> DbInterner<'db> {
+        self.table.interner
     }
 
-    pub(super) fn coerce_forced_unit(
-        &mut self,
-        ctx: &mut InferenceContext<'_>,
-        cause: CoercionCause,
-    ) {
-        self.coerce(ctx, None, &ctx.result.standard_types.unit.clone(), cause)
+    #[inline]
+    fn infer_ctxt(&self) -> &InferCtxt<'db> {
+        &self.table.infer_ctxt
     }
 
-    /// Merge two types from different branches, with possible coercion.
-    ///
-    /// Mostly this means trying to coerce one to the other, but
-    ///  - if we have two function types for different functions or closures, we need to
-    ///    coerce both to function pointers;
-    ///  - if we were concerned with lifetime subtyping, we'd need to look for a
-    ///    least upper bound.
-    pub(super) fn coerce<'db>(
+    pub(crate) fn commit_if_ok<T, E>(
         &mut self,
-        ctx: &mut InferenceContext<'db>,
-        expr: Option<ExprId>,
-        expr_ty: &Ty,
-        cause: CoercionCause,
-    ) {
-        let expr_ty = ctx.resolve_ty_shallow(expr_ty);
-        self.expected_ty = ctx.resolve_ty_shallow(&self.expected_ty);
-
-        // Special case: two function types. Try to coerce both to
-        // pointers to have a chance at getting a match. See
-        // https://github.com/rust-lang/rust/blob/7b805396bf46dce972692a6846ce2ad8481c5f85/src/librustc_typeck/check/coercion.rs#L877-L916
-        let sig = match (self.merged_ty().kind(Interner), expr_ty.kind(Interner)) {
-            (TyKind::FnDef(x, _), TyKind::FnDef(y, _))
-                if x == y && ctx.table.unify(&self.merged_ty(), &expr_ty) =>
-            {
-                None
-            }
-            (TyKind::Closure(x, _), TyKind::Closure(y, _)) if x == y => None,
-            (TyKind::FnDef(..) | TyKind::Closure(..), TyKind::FnDef(..) | TyKind::Closure(..)) => {
-                // FIXME: we're ignoring safety here. To be more correct, if we have one FnDef and one Closure,
-                // we should be coercing the closure to a fn pointer of the safety of the FnDef
-                cov_mark::hit!(coerce_fn_reification);
-                let sig =
-                    self.merged_ty().callable_sig(ctx.db).expect("FnDef without callable sig");
-                Some(sig)
-            }
-            _ => None,
-        };
-        if let Some(sig) = sig {
-            let target_ty = TyKind::Function(sig.to_fn_ptr()).intern(Interner);
-            let result1 = ctx.table.coerce_inner(self.merged_ty(), &target_ty, CoerceNever::Yes);
-            let result2 = ctx.table.coerce_inner(expr_ty.clone(), &target_ty, CoerceNever::Yes);
-            if let (Ok(result1), Ok(result2)) = (result1, result2) {
-                ctx.table.register_infer_ok(InferOk { value: (), goals: result1.goals });
-                for &e in &self.expressions {
-                    ctx.write_expr_adj(e, result1.value.0.clone().into_boxed_slice());
-                }
-                ctx.table.register_infer_ok(InferOk { value: (), goals: result2.goals });
-                if let Some(expr) = expr {
-                    ctx.write_expr_adj(expr, result2.value.0.into_boxed_slice());
-                    self.expressions.push(expr);
-                }
-                return self.final_ty = Some(target_ty);
+        f: impl FnOnce(&mut Self) -> Result<T, E>,
+    ) -> Result<T, E> {
+        let snapshot = self.table.snapshot();
+        let result = f(self);
+        match result {
+            Ok(_) => {}
+            Err(_) => {
+                self.table.rollback_to(snapshot);
             }
         }
+        result
+    }
 
-        // It might not seem like it, but order is important here: If the expected
-        // type is a type variable and the new one is `!`, trying it the other
-        // way around first would mean we make the type variable `!`, instead of
-        // just marking it as possibly diverging.
-        //
-        // - [Comment from rustc](https://github.com/rust-lang/rust/blob/5ff18d0eaefd1bd9ab8ec33dab2404a44e7631ed/compiler/rustc_hir_typeck/src/coercion.rs#L1334-L1335)
-        // First try to coerce the new expression to the type of the previous ones,
-        // but only if the new expression has no coercion already applied to it.
-        if expr.is_none_or(|expr| !ctx.result.expr_adjustments.contains_key(&expr))
-            && let Ok(res) = ctx.coerce(expr, &expr_ty, &self.merged_ty(), CoerceNever::Yes)
-        {
-            self.final_ty = Some(res);
-            if let Some(expr) = expr {
-                self.expressions.push(expr);
-            }
-            return;
-        }
+    fn unify_raw(&mut self, a: Ty<'db>, b: Ty<'db>) -> InferResult<'db, Ty<'db>> {
+        debug!("unify(a: {:?}, b: {:?}, use_lub: {})", a, b, self.use_lub);
+        self.commit_if_ok(|this| {
+            let at = this.infer_ctxt().at(&this.cause, this.table.param_env);
 
-        if let Ok((adjustments, res)) =
-            ctx.coerce_inner(&self.merged_ty(), &expr_ty, CoerceNever::Yes)
-        {
-            self.final_ty = Some(res);
-            for &e in &self.expressions {
-                ctx.write_expr_adj(e, adjustments.clone().into_boxed_slice());
-            }
-        } else {
-            match cause {
-                CoercionCause::Expr(id) => {
-                    ctx.result.type_mismatches.insert(
-                        id.into(),
-                        TypeMismatch { expected: self.merged_ty(), actual: expr_ty.clone() },
-                    );
+            let res = if this.use_lub {
+                at.lub(b, a)
+            } else {
+                at.sup(DefineOpaqueTypes::Yes, b, a)
+                    .map(|InferOk { value: (), obligations }| InferOk { value: b, obligations })
+            };
+
+            // In the new solver, lazy norm may allow us to shallowly equate
+            // more types, but we emit possibly impossible-to-satisfy obligations.
+            // Filter these cases out to make sure our coercion is more accurate.
+            match res {
+                Ok(InferOk { value, obligations }) => {
+                    let mut ocx = ObligationCtxt::new(this.infer_ctxt());
+                    ocx.register_obligations(obligations);
+                    if ocx.select_where_possible().is_empty() {
+                        Ok(InferOk { value, obligations: ocx.into_pending_obligations() })
+                    } else {
+                        Err(TypeError::Mismatch)
+                    }
                 }
+                res => res,
             }
-            cov_mark::hit!(coerce_merge_fail_fallback);
-        }
-        if let Some(expr) = expr {
-            self.expressions.push(expr);
-        }
+        })
     }
-}
-
-pub fn could_coerce(
-    db: &dyn HirDatabase,
-    env: Arc<TraitEnvironment>,
-    tys: &Canonical<(Ty, Ty)>,
-) -> bool {
-    coerce(db, env, tys).is_ok()
-}
-
-pub(crate) fn coerce(
-    db: &dyn HirDatabase,
-    env: Arc<TraitEnvironment>,
-    tys: &Canonical<(Ty, Ty)>,
-) -> Result<(Vec<Adjustment>, Ty), TypeError> {
-    let mut table = InferenceTable::new(db, env);
-    let vars = table.fresh_subst(tys.binders.as_slice(Interner));
-    let ty1_with_vars = vars.apply(tys.value.0.clone(), Interner);
-    let ty2_with_vars = vars.apply(tys.value.1.clone(), Interner);
-    let (adjustments, ty) = table.coerce(&ty1_with_vars, &ty2_with_vars, CoerceNever::Yes)?;
-    // default any type vars that weren't unified back to their original bound vars
-    // (kind of hacky)
-    let find_var = |iv| {
-        vars.iter(Interner).position(|v| match v.interned() {
-            chalk_ir::GenericArgData::Ty(ty) => ty.inference_var(Interner),
-            chalk_ir::GenericArgData::Lifetime(lt) => lt.inference_var(Interner),
-            chalk_ir::GenericArgData::Const(c) => c.inference_var(Interner),
-        } == Some(iv))
-    };
-    let fallback = |iv, kind, default, binder| match kind {
-        chalk_ir::VariableKind::Ty(_ty_kind) => find_var(iv)
-            .map_or(default, |i| BoundVar::new(binder, i).to_ty(Interner).cast(Interner)),
-        chalk_ir::VariableKind::Lifetime => find_var(iv)
-            .map_or(default, |i| BoundVar::new(binder, i).to_lifetime(Interner).cast(Interner)),
-        chalk_ir::VariableKind::Const(ty) => find_var(iv)
-            .map_or(default, |i| BoundVar::new(binder, i).to_const(Interner, ty).cast(Interner)),
-    };
-    // FIXME also map the types in the adjustments
-    Ok((adjustments, table.resolve_with_fallback(ty, &fallback)))
-}
 
-#[derive(Clone, Copy, PartialEq, Eq)]
-pub(crate) enum CoerceNever {
-    Yes,
-    No,
-}
-
-impl InferenceContext<'_> {
-    /// Unify two types, but may coerce the first one to the second one
-    /// using "implicit coercion rules" if needed.
-    pub(super) fn coerce(
-        &mut self,
-        expr: Option<ExprId>,
-        from_ty: &Ty,
-        to_ty: &Ty,
-        // [Comment from rustc](https://github.com/rust-lang/rust/blob/4cc494bbfe9911d24f3ee521f98d5c6bb7e3ffe8/compiler/rustc_hir_typeck/src/coercion.rs#L85-L89)
-        // Whether we allow `NeverToAny` coercions. This is unsound if we're
-        // coercing a place expression without it counting as a read in the MIR.
-        // This is a side-effect of HIR not really having a great distinction
-        // between places and values.
-        coerce_never: CoerceNever,
-    ) -> Result<Ty, TypeError> {
-        let (adjustments, ty) = self.coerce_inner(from_ty, to_ty, coerce_never)?;
-        if let Some(expr) = expr {
-            self.write_expr_adj(expr, adjustments.into_boxed_slice());
-        }
-        Ok(ty)
+    /// Unify two types (using sub or lub).
+    fn unify(&mut self, a: Ty<'db>, b: Ty<'db>) -> CoerceResult<'db> {
+        self.unify_raw(a, b)
+            .and_then(|InferOk { value: ty, obligations }| success(vec![], ty, obligations))
     }
 
-    fn coerce_inner(
+    /// Unify two types (using sub or lub) and produce a specific coercion.
+    fn unify_and(
         &mut self,
-        from_ty: &Ty,
-        to_ty: &Ty,
-        coerce_never: CoerceNever,
-    ) -> Result<(Vec<Adjustment>, Ty), TypeError> {
-        let from_ty = self.resolve_ty_shallow(from_ty);
-        let to_ty = self.resolve_ty_shallow(to_ty);
-        self.table.coerce(&from_ty, &to_ty, coerce_never)
+        a: Ty<'db>,
+        b: Ty<'db>,
+        adjustments: impl IntoIterator<Item = Adjustment>,
+        final_adjustment: Adjust,
+    ) -> CoerceResult<'db> {
+        self.unify_raw(a, b).and_then(|InferOk { value: ty, obligations }| {
+            success(
+                adjustments
+                    .into_iter()
+                    .chain(std::iter::once(Adjustment {
+                        target: ty.to_chalk(self.interner()),
+                        kind: final_adjustment,
+                    }))
+                    .collect(),
+                ty,
+                obligations,
+            )
+        })
     }
-}
 
-impl<'db> InferenceTable<'db> {
-    /// Unify two types, but may coerce the first one to the second one
-    /// using "implicit coercion rules" if needed.
-    pub(crate) fn coerce(
-        &mut self,
-        from_ty: &Ty,
-        to_ty: &Ty,
-        coerce_never: CoerceNever,
-    ) -> Result<(Vec<Adjustment>, Ty), TypeError> {
-        let from_ty = self.structurally_resolve_type(from_ty);
-        let to_ty = self.structurally_resolve_type(to_ty);
-        match self.coerce_inner(from_ty, &to_ty, coerce_never) {
-            Ok(InferOk { value: (adjustments, ty), goals }) => {
-                self.register_infer_ok(InferOk { value: (), goals });
-                Ok((adjustments, ty))
-            }
-            Err(e) => {
-                // FIXME deal with error
-                Err(e)
+    #[instrument(skip(self))]
+    fn coerce(&mut self, a: Ty<'db>, b: Ty<'db>) -> CoerceResult<'db> {
+        // First, remove any resolved type variables (at the top level, at least):
+        let a = self.table.shallow_resolve(a);
+        let b = self.table.shallow_resolve(b);
+        debug!("Coerce.tys({:?} => {:?})", a, b);
+
+        // Coercing from `!` to any type is allowed:
+        if a.is_never() {
+            // If we're coercing into an inference var, mark it as possibly diverging.
+            // FIXME: rustc does this differently.
+            if let TyKind::Infer(rustc_type_ir::TyVar(b)) = b.kind() {
+                self.table.set_diverging(b.as_u32().into(), chalk_ir::TyVariableKind::General);
             }
-        }
-    }
 
-    fn coerce_inner(
-        &mut self,
-        from_ty: Ty,
-        to_ty: &Ty,
-        coerce_never: CoerceNever,
-    ) -> CoerceResult<'db> {
-        if from_ty.is_never() {
-            if let TyKind::InferenceVar(tv, TyVariableKind::General) = to_ty.kind(Interner) {
-                self.set_diverging(*tv, TyVariableKind::General);
-            }
-            if coerce_never == CoerceNever::Yes {
-                // Subtle: If we are coercing from `!` to `?T`, where `?T` is an unbound
-                // type variable, we want `?T` to fallback to `!` if not
-                // otherwise constrained. An example where this arises:
-                //
-                //     let _: Option<?T> = Some({ return; });
-                //
-                // here, we would coerce from `!` to `?T`.
-                return success(simple(Adjust::NeverToAny)(to_ty.clone()), to_ty.clone(), vec![]);
+            if self.coerce_never {
+                return success(
+                    vec![Adjustment {
+                        kind: Adjust::NeverToAny,
+                        target: b.to_chalk(self.interner()),
+                    }],
+                    b,
+                    PredicateObligations::new(),
+                );
             } else {
-                return self.unify_and(&from_ty, to_ty, identity);
+                // Otherwise the only coercion we can do is unification.
+                return self.unify(a, b);
             }
         }
 
         // If we are coercing into a TAIT, coerce into its proxy inference var, instead.
-        let mut to_ty = to_ty;
-        let _to;
-        if let Some(tait_table) = &self.tait_coercion_table
-            && let TyKind::OpaqueType(opaque_ty_id, _) = to_ty.kind(Interner)
-            && !matches!(from_ty.kind(Interner), TyKind::InferenceVar(..) | TyKind::OpaqueType(..))
-            && let Some(ty) = tait_table.get(opaque_ty_id)
+        // FIXME(next-solver): This should not be here. This is not how rustc does thing, and it also not allows us
+        // to normalize opaques defined in our scopes. Instead, we should properly register
+        // `TypingMode::Analysis::defining_opaque_types_and_generators`, and rely on the solver to reveal
+        // them for us (we'll also need some global-like registry for the values, something we cannot
+        // really implement, therefore we can really support only RPITs and ITIAT or the new `#[define_opaque]`
+        // TAIT, not the old global TAIT).
+        let mut b = b;
+        if let Some(tait_table) = &self.table.tait_coercion_table
+            && let TyKind::Alias(rustc_type_ir::Opaque, opaque_ty) = b.kind()
+            && let SolverDefId::InternedOpaqueTyId(opaque_ty_id) = opaque_ty.def_id
+            && !matches!(a.kind(), TyKind::Infer(..) | TyKind::Alias(rustc_type_ir::Opaque, _))
+            && let Some(ty) = tait_table.get(&opaque_ty_id.into())
         {
-            _to = ty.clone();
-            to_ty = &_to;
+            b = ty.to_nextsolver(self.interner());
+            b = self.table.shallow_resolve(b);
+        }
+        let b = b;
+
+        // Coercing *from* an unresolved inference variable means that
+        // we have no information about the source type. This will always
+        // ultimately fall back to some form of subtyping.
+        if a.is_infer() {
+            return self.coerce_from_inference_variable(a, b);
         }
 
         // Consider coercing the subtype to a DST
-        if let Ok(ret) = self.try_coerce_unsized(&from_ty, to_ty) {
-            return Ok(ret);
+        //
+        // NOTE: this is wrapped in a `commit_if_ok` because it creates
+        // a "spurious" type variable, and we don't want to have that
+        // type variable in memory if the coercion fails.
+        let unsize = self.commit_if_ok(|this| this.coerce_unsized(a, b));
+        match unsize {
+            Ok(_) => {
+                debug!("coerce: unsize successful");
+                return unsize;
+            }
+            Err(error) => {
+                debug!(?error, "coerce: unsize failed");
+            }
         }
 
-        // Examine the supertype and consider auto-borrowing.
-        match to_ty.kind(Interner) {
-            TyKind::Raw(mt, _) => return self.coerce_ptr(from_ty, to_ty, *mt),
-            TyKind::Ref(mt, lt, _) => return self.coerce_ref(from_ty, to_ty, *mt, lt),
+        // Examine the supertype and consider type-specific coercions, such
+        // as auto-borrowing, coercing pointer mutability, a `dyn*` coercion,
+        // or pin-ergonomics.
+        match b.kind() {
+            TyKind::RawPtr(_, b_mutbl) => {
+                return self.coerce_raw_ptr(a, b, b_mutbl);
+            }
+            TyKind::Ref(r_b, _, mutbl_b) => {
+                return self.coerce_borrowed_pointer(a, b, r_b, mutbl_b);
+            }
             _ => {}
         }
 
-        match from_ty.kind(Interner) {
+        match a.kind() {
             TyKind::FnDef(..) => {
                 // Function items are coercible to any closure
                 // type; function pointers are not (that would
                 // require double indirection).
                 // Additionally, we permit coercion of function
                 // items to drop the unsafe qualifier.
-                self.coerce_from_fn_item(from_ty, to_ty)
+                self.coerce_from_fn_item(a, b)
             }
-            TyKind::Function(from_fn_ptr) => {
+            TyKind::FnPtr(a_sig_tys, a_hdr) => {
                 // We permit coercion of fn pointers to drop the
                 // unsafe qualifier.
-                self.coerce_from_fn_pointer(from_ty.clone(), from_fn_ptr, to_ty)
+                self.coerce_from_fn_pointer(a_sig_tys.with(a_hdr), b)
             }
-            TyKind::Closure(_, from_substs) => {
+            TyKind::Closure(closure_def_id_a, args_a) => {
                 // Non-capturing closures are coercible to
                 // function pointers or unsafe function pointers.
                 // It cannot convert closures that require unsafe.
-                self.coerce_closure_to_fn(from_ty.clone(), from_substs, to_ty)
+                self.coerce_closure_to_fn(a, closure_def_id_a.0, args_a, b)
             }
             _ => {
                 // Otherwise, just use unification rules.
-                self.unify_and(&from_ty, to_ty, identity)
+                self.unify(a, b)
             }
         }
     }
 
-    /// Unify two types (using sub or lub) and produce a specific coercion.
-    fn unify_and<F>(&mut self, t1: &Ty, t2: &Ty, f: F) -> CoerceResult<'db>
-    where
-        F: FnOnce(Ty) -> Vec<Adjustment>,
-    {
-        self.try_unify(t1, t2)
-            .and_then(|InferOk { goals, .. }| success(f(t1.clone()), t1.clone(), goals))
-    }
-
-    fn coerce_ptr(&mut self, from_ty: Ty, to_ty: &Ty, to_mt: Mutability) -> CoerceResult<'db> {
-        let (is_ref, from_mt, from_inner) = match from_ty.kind(Interner) {
-            TyKind::Ref(mt, _, ty) => (true, mt, ty),
-            TyKind::Raw(mt, ty) => (false, mt, ty),
-            _ => return self.unify_and(&from_ty, to_ty, identity),
-        };
-
-        coerce_mutabilities(*from_mt, to_mt)?;
-
-        // Check that the types which they point at are compatible.
-        let from_raw = TyKind::Raw(to_mt, from_inner.clone()).intern(Interner);
+    /// Coercing *from* an inference variable. In this case, we have no information
+    /// about the source type, so we can't really do a true coercion and we always
+    /// fall back to subtyping (`unify_and`).
+    fn coerce_from_inference_variable(&mut self, a: Ty<'db>, b: Ty<'db>) -> CoerceResult<'db> {
+        debug!("coerce_from_inference_variable(a={:?}, b={:?})", a, b);
+        debug_assert!(a.is_infer() && self.table.shallow_resolve(a) == a);
+        debug_assert!(self.table.shallow_resolve(b) == b);
+
+        if b.is_infer() {
+            // Two unresolved type variables: create a `Coerce` predicate.
+            let target_ty = if self.use_lub { self.table.next_ty_var() } else { b };
+
+            let mut obligations = PredicateObligations::with_capacity(2);
+            for &source_ty in &[a, b] {
+                if source_ty != target_ty {
+                    obligations.push(Obligation::new(
+                        self.interner(),
+                        self.cause.clone(),
+                        self.table.param_env,
+                        Binder::dummy(PredicateKind::Coerce(CoercePredicate {
+                            a: source_ty,
+                            b: target_ty,
+                        })),
+                    ));
+                }
+            }
 
-        // Although references and raw ptrs have the same
-        // representation, we still register an Adjust::DerefRef so that
-        // regionck knows that the region for `a` must be valid here.
-        if is_ref {
-            self.unify_and(&from_raw, to_ty, |target| {
-                vec![
-                    Adjustment { kind: Adjust::Deref(None), target: from_inner.clone() },
-                    Adjustment { kind: Adjust::Borrow(AutoBorrow::RawPtr(to_mt)), target },
-                ]
-            })
-        } else if *from_mt != to_mt {
-            self.unify_and(
-                &from_raw,
-                to_ty,
-                simple(Adjust::Pointer(PointerCast::MutToConstPointer)),
-            )
+            debug!(
+                "coerce_from_inference_variable: two inference variables, target_ty={:?}, obligations={:?}",
+                target_ty, obligations
+            );
+            success(vec![], target_ty, obligations)
         } else {
-            self.unify_and(&from_raw, to_ty, identity)
+            // One unresolved type variable: just apply subtyping, we may be able
+            // to do something useful.
+            self.unify(a, b)
         }
     }
 
     /// Reborrows `&mut A` to `&mut B` and `&(mut) A` to `&B`.
     /// To match `A` with `B`, autoderef will be performed,
     /// calling `deref`/`deref_mut` where necessary.
-    fn coerce_ref(
+    fn coerce_borrowed_pointer(
         &mut self,
-        from_ty: Ty,
-        to_ty: &Ty,
-        to_mt: Mutability,
-        to_lt: &Lifetime,
+        a: Ty<'db>,
+        b: Ty<'db>,
+        r_b: Region<'db>,
+        mutbl_b: Mutability,
     ) -> CoerceResult<'db> {
-        let (_from_lt, from_mt) = match from_ty.kind(Interner) {
-            TyKind::Ref(mt, lt, _) => {
-                coerce_mutabilities(*mt, to_mt)?;
-                (lt.clone(), *mt) // clone is probably not good?
+        debug!("coerce_borrowed_pointer(a={:?}, b={:?})", a, b);
+        debug_assert!(self.table.shallow_resolve(a) == a);
+        debug_assert!(self.table.shallow_resolve(b) == b);
+
+        // If we have a parameter of type `&M T_a` and the value
+        // provided is `expr`, we will be adding an implicit borrow,
+        // meaning that we convert `f(expr)` to `f(&M *expr)`. Therefore,
+        // to type check, we will construct the type that `&M*expr` would
+        // yield.
+
+        let (r_a, mt_a) = match a.kind() {
+            TyKind::Ref(r_a, ty, mutbl) => {
+                let mt_a = TypeAndMut::<DbInterner<'db>> { ty, mutbl };
+                coerce_mutbls(mt_a.mutbl, mutbl_b)?;
+                (r_a, mt_a)
             }
-            _ => return self.unify_and(&from_ty, to_ty, identity),
+            _ => return self.unify(a, b),
         };
 
-        // NOTE: this code is mostly copied and adapted from rustc, and
-        // currently more complicated than necessary, carrying errors around
-        // etc.. This complication will become necessary when we actually track
-        // details of coercion errors though, so I think it's useful to leave
-        // the structure like it is.
-
-        let snapshot = self.snapshot();
-
-        let mut autoderef = Autoderef::new(self, from_ty.clone(), false, false);
         let mut first_error = None;
+        let mut r_borrow_var = None;
+        let mut autoderef = Autoderef::new(self.table, a);
         let mut found = None;
 
         while let Some((referent_ty, autoderefs)) = autoderef.next() {
@@ -456,7 +392,7 @@ impl<'db> InferenceTable<'db> {
                 continue;
             }
 
-            // At this point, we have deref'd `a` to `referent_ty`.  So
+            // At this point, we have deref'd `a` to `referent_ty`. So
             // imagine we are coercing from `&'a mut Vec<T>` to `&'b mut [T]`.
             // In the autoderef loop for `&'a mut Vec<T>`, we would get
             // three callbacks:
@@ -478,11 +414,85 @@ impl<'db> InferenceTable<'db> {
             // compare those. Note that this means we use the target
             // mutability [1], since it may be that we are coercing
             // from `&mut T` to `&U`.
-            let lt = to_lt; // FIXME: Involve rustc LUB and SUB flag checks
-            let derefd_from_ty = TyKind::Ref(to_mt, lt.clone(), referent_ty).intern(Interner);
-            match autoderef.table.try_unify(&derefd_from_ty, to_ty) {
-                Ok(result) => {
-                    found = Some(result.map(|()| derefd_from_ty));
+            //
+            // One fine point concerns the region that we use. We
+            // choose the region such that the region of the final
+            // type that results from `unify` will be the region we
+            // want for the autoref:
+            //
+            // - if in sub mode, that means we want to use `'b` (the
+            //   region from the target reference) for both
+            //   pointers [2]. This is because sub mode (somewhat
+            //   arbitrarily) returns the subtype region. In the case
+            //   where we are coercing to a target type, we know we
+            //   want to use that target type region (`'b`) because --
+            //   for the program to type-check -- it must be the
+            //   smaller of the two.
+            //   - One fine point. It may be surprising that we can
+            //     use `'b` without relating `'a` and `'b`. The reason
+            //     that this is ok is that what we produce is
+            //     effectively a `&'b *x` expression (if you could
+            //     annotate the region of a borrow), and regionck has
+            //     code that adds edges from the region of a borrow
+            //     (`'b`, here) into the regions in the borrowed
+            //     expression (`*x`, here). (Search for "link".)
+            // - if in lub mode, things can get fairly complicated. The
+            //   easiest thing is just to make a fresh
+            //   region variable [4], which effectively means we defer
+            //   the decision to region inference (and regionck, which will add
+            //   some more edges to this variable). However, this can wind up
+            //   creating a crippling number of variables in some cases --
+            //   e.g., #32278 -- so we optimize one particular case [3].
+            //   Let me try to explain with some examples:
+            //   - The "running example" above represents the simple case,
+            //     where we have one `&` reference at the outer level and
+            //     ownership all the rest of the way down. In this case,
+            //     we want `LUB('a, 'b)` as the resulting region.
+            //   - However, if there are nested borrows, that region is
+            //     too strong. Consider a coercion from `&'a &'x Rc<T>` to
+            //     `&'b T`. In this case, `'a` is actually irrelevant.
+            //     The pointer we want is `LUB('x, 'b`). If we choose `LUB('a,'b)`
+            //     we get spurious errors (`ui/regions-lub-ref-ref-rc.rs`).
+            //     (The errors actually show up in borrowck, typically, because
+            //     this extra edge causes the region `'a` to be inferred to something
+            //     too big, which then results in borrowck errors.)
+            //   - We could track the innermost shared reference, but there is already
+            //     code in regionck that has the job of creating links between
+            //     the region of a borrow and the regions in the thing being
+            //     borrowed (here, `'a` and `'x`), and it knows how to handle
+            //     all the various cases. So instead we just make a region variable
+            //     and let regionck figure it out.
+            let r = if !self.use_lub {
+                r_b // [2] above
+            } else if autoderefs == 1 {
+                r_a // [3] above
+            } else {
+                if r_borrow_var.is_none() {
+                    // create var lazily, at most once
+                    let r = autoderef.table.next_region_var();
+                    r_borrow_var = Some(r); // [4] above
+                }
+                r_borrow_var.unwrap()
+            };
+            let derefd_ty_a = Ty::new_ref(
+                autoderef.table.interner,
+                r,
+                referent_ty,
+                mutbl_b, // [1] above
+            );
+            // We need to construct a new `Coerce` because of lifetimes.
+            let mut coerce = Coerce {
+                table: autoderef.table,
+                has_errors: self.has_errors,
+                target_features: self.target_features,
+                use_lub: self.use_lub,
+                allow_two_phase: self.allow_two_phase,
+                coerce_never: self.coerce_never,
+                cause: self.cause.clone(),
+            };
+            match coerce.unify_raw(derefd_ty_a, b) {
+                Ok(ok) => {
+                    found = Some(ok);
                     break;
                 }
                 Err(err) => {
@@ -498,18 +508,24 @@ impl<'db> InferenceTable<'db> {
         // (e.g., in example above, the failure from relating `Vec<T>`
         // to the target type), since that should be the least
         // confusing.
-        let InferOk { value: ty, goals } = match found {
-            Some(d) => d,
-            None => {
-                self.rollback_to(snapshot);
-                let err = first_error.expect("coerce_borrowed_pointer had no error");
-                return Err(err);
+        let Some(InferOk { value: ty, mut obligations }) = found else {
+            if let Some(first_error) = first_error {
+                debug!("coerce_borrowed_pointer: failed with err = {:?}", first_error);
+                return Err(first_error);
+            } else {
+                // This may happen in the new trait solver since autoderef requires
+                // the pointee to be structurally normalizable, or else it'll just bail.
+                // So when we have a type like `&<not well formed>`, then we get no
+                // autoderef steps (even though there should be at least one). That means
+                // we get no type mismatches, since the loop above just exits early.
+                return Err(TypeError::Mismatch);
             }
         };
-        if ty == from_ty && from_mt == Mutability::Not && autoderef.step_count() == 1 {
+
+        if ty == a && mt_a.mutbl.is_not() && autoderef.step_count() == 1 {
             // As a special case, if we would produce `&'a *x`, that's
             // a total no-op. We end up with the type `&'a T` just as
-            // we started with.  In that case, just skip it
+            // we started with. In that case, just skip it
             // altogether. This is just an optimization.
             //
             // Note that for `&mut`, we DO want to reborrow --
@@ -518,259 +534,1091 @@ impl<'db> InferenceTable<'db> {
             // `self.x` both have `&mut `type would be a move of
             // `self.x`, but we auto-coerce it to `foo(&mut *self.x)`,
             // which is a borrow.
-            always!(to_mt == Mutability::Not); // can only coerce &T -> &U
-            return success(vec![], ty, goals);
+            assert!(mutbl_b.is_not()); // can only coerce &T -> &U
+            return success(vec![], ty, obligations);
         }
 
-        let mut adjustments = auto_deref_adjust_steps(&autoderef);
+        let InferOk { value: mut adjustments, obligations: o } =
+            autoderef.adjust_steps_as_infer_ok();
+        obligations.extend(o);
+
+        // Now apply the autoref. We have to extract the region out of
+        // the final ref type we got.
+        let TyKind::Ref(region, _, _) = ty.kind() else {
+            panic!("expected a ref type, got {:?}", ty);
+        };
         adjustments.push(Adjustment {
-            kind: Adjust::Borrow(AutoBorrow::Ref(to_lt.clone(), to_mt)),
-            target: ty.clone(),
+            kind: Adjust::Borrow(AutoBorrow::Ref(
+                region.to_chalk(self.interner()),
+                mutbl_b.to_chalk(self.interner()),
+            )),
+            target: ty.to_chalk(self.interner()),
         });
 
-        success(adjustments, ty, goals)
+        debug!("coerce_borrowed_pointer: succeeded ty={:?} adjustments={:?}", ty, adjustments);
+
+        success(adjustments, ty, obligations)
     }
 
-    /// Attempts to coerce from the type of a Rust function item into a function pointer.
-    fn coerce_from_fn_item(&mut self, from_ty: Ty, to_ty: &Ty) -> CoerceResult<'db> {
-        match to_ty.kind(Interner) {
-            TyKind::Function(_) => {
-                let from_sig = from_ty.callable_sig(self.db).expect("FnDef had no sig");
-
-                // FIXME check ABI: Intrinsics are not coercible to function pointers
-                // FIXME Safe `#[target_feature]` functions are not assignable to safe fn pointers (RFC 2396)
-
-                // FIXME rustc normalizes assoc types in the sig here, not sure if necessary
-
-                let from_sig = from_sig.to_fn_ptr();
-                let from_fn_pointer = TyKind::Function(from_sig.clone()).intern(Interner);
-                let ok = self.coerce_from_safe_fn(
-                    from_fn_pointer.clone(),
-                    &from_sig,
-                    to_ty,
-                    |unsafe_ty| {
-                        vec![
-                            Adjustment {
-                                kind: Adjust::Pointer(PointerCast::ReifyFnPointer),
-                                target: from_fn_pointer,
-                            },
-                            Adjustment {
-                                kind: Adjust::Pointer(PointerCast::UnsafeFnPointer),
-                                target: unsafe_ty,
-                            },
-                        ]
+    /// Performs [unsized coercion] by emulating a fulfillment loop on a
+    /// `CoerceUnsized` goal until all `CoerceUnsized` and `Unsize` goals
+    /// are successfully selected.
+    ///
+    /// [unsized coercion](https://doc.rust-lang.org/reference/type-coercions.html#unsized-coercions)
+    #[instrument(skip(self), level = "debug")]
+    fn coerce_unsized(&mut self, source: Ty<'db>, target: Ty<'db>) -> CoerceResult<'db> {
+        debug!(?source, ?target);
+        debug_assert!(self.table.shallow_resolve(source) == source);
+        debug_assert!(self.table.shallow_resolve(target) == target);
+
+        // We don't apply any coercions incase either the source or target
+        // aren't sufficiently well known but tend to instead just equate
+        // them both.
+        if source.is_infer() {
+            debug!("coerce_unsized: source is a TyVar, bailing out");
+            return Err(TypeError::Mismatch);
+        }
+        if target.is_infer() {
+            debug!("coerce_unsized: target is a TyVar, bailing out");
+            return Err(TypeError::Mismatch);
+        }
+
+        // This is an optimization because coercion is one of the most common
+        // operations that we do in typeck, since it happens at every assignment
+        // and call arg (among other positions).
+        //
+        // These targets are known to never be RHS in `LHS: CoerceUnsized<RHS>`.
+        // That's because these are built-in types for which a core-provided impl
+        // doesn't exist, and for which a user-written impl is invalid.
+        //
+        // This is technically incomplete when users write impossible bounds like
+        // `where T: CoerceUnsized<usize>`, for example, but that trait is unstable
+        // and coercion is allowed to be incomplete. The only case where this matters
+        // is impossible bounds.
+        //
+        // Note that some of these types implement `LHS: Unsize<RHS>`, but they
+        // do not implement *`CoerceUnsized`* which is the root obligation of the
+        // check below.
+        match target.kind() {
+            TyKind::Bool
+            | TyKind::Char
+            | TyKind::Int(_)
+            | TyKind::Uint(_)
+            | TyKind::Float(_)
+            | TyKind::Infer(rustc_type_ir::IntVar(_) | rustc_type_ir::FloatVar(_))
+            | TyKind::Str
+            | TyKind::Array(_, _)
+            | TyKind::Slice(_)
+            | TyKind::FnDef(_, _)
+            | TyKind::FnPtr(_, _)
+            | TyKind::Dynamic(_, _, _)
+            | TyKind::Closure(_, _)
+            | TyKind::CoroutineClosure(_, _)
+            | TyKind::Coroutine(_, _)
+            | TyKind::CoroutineWitness(_, _)
+            | TyKind::Never
+            | TyKind::Tuple(_) => return Err(TypeError::Mismatch),
+            _ => {}
+        }
+        // Additionally, we ignore `&str -> &str` coercions, which happen very
+        // commonly since strings are one of the most used argument types in Rust,
+        // we do coercions when type checking call expressions.
+        if let TyKind::Ref(_, source_pointee, Mutability::Not) = source.kind()
+            && source_pointee.is_str()
+            && let TyKind::Ref(_, target_pointee, Mutability::Not) = target.kind()
+            && target_pointee.is_str()
+        {
+            return Err(TypeError::Mismatch);
+        }
+
+        let traits = (
+            LangItem::Unsize.resolve_trait(self.table.db, self.table.trait_env.krate),
+            LangItem::CoerceUnsized.resolve_trait(self.table.db, self.table.trait_env.krate),
+        );
+        let (Some(unsize_did), Some(coerce_unsized_did)) = traits else {
+            debug!("missing Unsize or CoerceUnsized traits");
+            return Err(TypeError::Mismatch);
+        };
+
+        // Note, we want to avoid unnecessary unsizing. We don't want to coerce to
+        // a DST unless we have to. This currently comes out in the wash since
+        // we can't unify [T] with U. But to properly support DST, we need to allow
+        // that, at which point we will need extra checks on the target here.
+
+        // Handle reborrows before selecting `Source: CoerceUnsized<Target>`.
+        let reborrow = match (source.kind(), target.kind()) {
+            (TyKind::Ref(_, ty_a, mutbl_a), TyKind::Ref(_, _, mutbl_b)) => {
+                coerce_mutbls(mutbl_a, mutbl_b)?;
+
+                let r_borrow = self.table.next_region_var();
+
+                // We don't allow two-phase borrows here, at least for initial
+                // implementation. If it happens that this coercion is a function argument,
+                // the reborrow in coerce_borrowed_ptr will pick it up.
+                // let mutbl = AutoBorrowMutability::new(mutbl_b, AllowTwoPhase::No);
+                let mutbl = mutbl_b.to_chalk(self.interner());
+
+                Some((
+                    Adjustment {
+                        kind: Adjust::Deref(None),
+                        target: ty_a.to_chalk(self.interner()),
+                    },
+                    Adjustment {
+                        kind: Adjust::Borrow(AutoBorrow::Ref(
+                            r_borrow.to_chalk(self.interner()),
+                            mutbl,
+                        )),
+                        target: Ty::new_ref(self.interner(), r_borrow, ty_a, mutbl_b)
+                            .to_chalk(self.interner()),
                     },
-                    simple(Adjust::Pointer(PointerCast::ReifyFnPointer)),
-                )?;
+                ))
+            }
+            (TyKind::Ref(_, ty_a, mt_a), TyKind::RawPtr(_, mt_b)) => {
+                coerce_mutbls(mt_a, mt_b)?;
 
-                Ok(ok)
+                Some((
+                    Adjustment {
+                        kind: Adjust::Deref(None),
+                        target: ty_a.to_chalk(self.interner()),
+                    },
+                    Adjustment {
+                        kind: Adjust::Borrow(AutoBorrow::RawPtr(mt_b.to_chalk(self.interner()))),
+                        target: Ty::new_ptr(self.interner(), ty_a, mt_b).to_chalk(self.interner()),
+                    },
+                ))
+            }
+            _ => None,
+        };
+        let coerce_source =
+            reborrow.as_ref().map_or(source, |(_, r)| r.target.to_nextsolver(self.interner()));
+
+        // Setup either a subtyping or a LUB relationship between
+        // the `CoerceUnsized` target type and the expected type.
+        // We only have the latter, so we use an inference variable
+        // for the former and let type inference do the rest.
+        let coerce_target = self.table.next_ty_var();
+
+        let mut coercion = self.unify_and(
+            coerce_target,
+            target,
+            reborrow.into_iter().flat_map(|(deref, autoref)| [deref, autoref]),
+            Adjust::Pointer(PointerCast::Unsize),
+        )?;
+
+        // Create an obligation for `Source: CoerceUnsized<Target>`.
+        let cause = self.cause.clone();
+
+        // Use a FIFO queue for this custom fulfillment procedure.
+        //
+        // A Vec (or SmallVec) is not a natural choice for a queue. However,
+        // this code path is hot, and this queue usually has a max length of 1
+        // and almost never more than 3. By using a SmallVec we avoid an
+        // allocation, at the (very small) cost of (occasionally) having to
+        // shift subsequent elements down when removing the front element.
+        let mut queue: SmallVec<[PredicateObligation<'db>; 4]> = smallvec![Obligation::new(
+            self.interner(),
+            cause,
+            self.table.param_env,
+            TraitRef::new(
+                self.interner(),
+                coerce_unsized_did.into(),
+                [coerce_source, coerce_target]
+            )
+        )];
+        // Keep resolving `CoerceUnsized` and `Unsize` predicates to avoid
+        // emitting a coercion in cases like `Foo<$1>` -> `Foo<$2>`, where
+        // inference might unify those two inner type variables later.
+        let traits = [coerce_unsized_did, unsize_did];
+        while !queue.is_empty() {
+            let obligation = queue.remove(0);
+            let trait_pred = match obligation.predicate.kind().no_bound_vars() {
+                Some(PredicateKind::Clause(ClauseKind::Trait(trait_pred)))
+                    if traits.contains(&trait_pred.def_id().0) =>
+                {
+                    self.infer_ctxt().resolve_vars_if_possible(trait_pred)
+                }
+                // Eagerly process alias-relate obligations in new trait solver,
+                // since these can be emitted in the process of solving trait goals,
+                // but we need to constrain vars before processing goals mentioning
+                // them.
+                Some(PredicateKind::AliasRelate(..)) => {
+                    let mut ocx = ObligationCtxt::new(self.infer_ctxt());
+                    ocx.register_obligation(obligation);
+                    if !ocx.select_where_possible().is_empty() {
+                        return Err(TypeError::Mismatch);
+                    }
+                    coercion.obligations.extend(ocx.into_pending_obligations());
+                    continue;
+                }
+                _ => {
+                    coercion.obligations.push(obligation);
+                    continue;
+                }
+            };
+            debug!("coerce_unsized resolve step: {:?}", trait_pred);
+            match self.infer_ctxt().select(&obligation.with(self.interner(), trait_pred)) {
+                // Uncertain or unimplemented.
+                Ok(None) => {
+                    if trait_pred.def_id().0 == unsize_did {
+                        let self_ty = trait_pred.self_ty();
+                        let unsize_ty = trait_pred.trait_ref.args.inner()[1].expect_ty();
+                        debug!("coerce_unsized: ambiguous unsize case for {:?}", trait_pred);
+                        match (self_ty.kind(), unsize_ty.kind()) {
+                            (TyKind::Infer(rustc_type_ir::TyVar(v)), TyKind::Dynamic(..))
+                                if self.table.type_var_is_sized(v) =>
+                            {
+                                debug!("coerce_unsized: have sized infer {:?}", v);
+                                coercion.obligations.push(obligation);
+                                // `$0: Unsize<dyn Trait>` where we know that `$0: Sized`, try going
+                                // for unsizing.
+                            }
+                            _ => {
+                                // Some other case for `$0: Unsize<Something>`. Note that we
+                                // hit this case even if `Something` is a sized type, so just
+                                // don't do the coercion.
+                                debug!("coerce_unsized: ambiguous unsize");
+                                return Err(TypeError::Mismatch);
+                            }
+                        }
+                    } else {
+                        debug!("coerce_unsized: early return - ambiguous");
+                        if !coerce_source.references_non_lt_error()
+                            && !coerce_target.references_non_lt_error()
+                        {
+                            // rustc always early-returns here, even when the types contains errors. However not bailing
+                            // improves error recovery, and while we don't implement generic consts properly, it also helps
+                            // correct code.
+                            return Err(TypeError::Mismatch);
+                        }
+                    }
+                }
+                Err(SelectionError::Unimplemented) => {
+                    debug!("coerce_unsized: early return - can't prove obligation");
+                    return Err(TypeError::Mismatch);
+                }
+
+                Err(SelectionError::TraitDynIncompatible(_)) => {
+                    // Dyn compatibility errors in coercion will *always* be due to the
+                    // fact that the RHS of the coercion is a non-dyn compatible `dyn Trait`
+                    // written in source somewhere (otherwise we will never have lowered
+                    // the dyn trait from HIR to middle).
+                    //
+                    // There's no reason to emit yet another dyn compatibility error,
+                    // especially since the span will differ slightly and thus not be
+                    // deduplicated at all!
+                    self.set_tainted_by_errors();
+                }
+                Err(_err) => {
+                    // FIXME: Report an error:
+                    // let guar = self.err_ctxt().report_selection_error(
+                    //     obligation.clone(),
+                    //     &obligation,
+                    //     &err,
+                    // );
+                    self.set_tainted_by_errors();
+                    // Treat this like an obligation and follow through
+                    // with the unsizing - the lack of a coercion should
+                    // be silent, as it causes a type mismatch later.
+                }
+
+                Ok(Some(ImplSource::UserDefined(impl_source))) => {
+                    queue.extend(impl_source.nested);
+                }
+                Ok(Some(impl_source)) => queue.extend(impl_source.nested_obligations()),
             }
-            _ => self.unify_and(&from_ty, to_ty, identity),
         }
+
+        Ok(coercion)
     }
 
-    fn coerce_from_fn_pointer(
+    fn coerce_from_safe_fn(
         &mut self,
-        from_ty: Ty,
-        from_f: &FnPointer,
-        to_ty: &Ty,
+        fn_ty_a: PolyFnSig<'db>,
+        b: Ty<'db>,
+        adjustment: Option<Adjust>,
     ) -> CoerceResult<'db> {
-        self.coerce_from_safe_fn(
-            from_ty,
-            from_f,
-            to_ty,
-            simple(Adjust::Pointer(PointerCast::UnsafeFnPointer)),
-            identity,
-        )
+        debug_assert!(self.table.shallow_resolve(b) == b);
+
+        self.commit_if_ok(|this| {
+            if let TyKind::FnPtr(_, hdr_b) = b.kind()
+                && fn_ty_a.safety().is_safe()
+                && !hdr_b.safety.is_safe()
+            {
+                let unsafe_a = Ty::safe_to_unsafe_fn_ty(this.interner(), fn_ty_a);
+                this.unify_and(
+                    unsafe_a,
+                    b,
+                    adjustment.map(|kind| Adjustment {
+                        kind,
+                        target: Ty::new_fn_ptr(this.interner(), fn_ty_a).to_chalk(this.interner()),
+                    }),
+                    Adjust::Pointer(PointerCast::UnsafeFnPointer),
+                )
+            } else {
+                let a = Ty::new_fn_ptr(this.interner(), fn_ty_a);
+                match adjustment {
+                    Some(adjust) => this.unify_and(a, b, [], adjust),
+                    None => this.unify(a, b),
+                }
+            }
+        })
     }
 
-    fn coerce_from_safe_fn<F, G>(
-        &mut self,
-        from_ty: Ty,
-        from_fn_ptr: &FnPointer,
-        to_ty: &Ty,
-        to_unsafe: F,
-        normal: G,
-    ) -> CoerceResult<'db>
-    where
-        F: FnOnce(Ty) -> Vec<Adjustment>,
-        G: FnOnce(Ty) -> Vec<Adjustment>,
-    {
-        if let TyKind::Function(to_fn_ptr) = to_ty.kind(Interner)
-            && let (chalk_ir::Safety::Safe, chalk_ir::Safety::Unsafe) =
-                (from_fn_ptr.sig.safety, to_fn_ptr.sig.safety)
-        {
-            let from_unsafe =
-                TyKind::Function(safe_to_unsafe_fn_ty(from_fn_ptr.clone())).intern(Interner);
-            return self.unify_and(&from_unsafe, to_ty, to_unsafe);
+    fn coerce_from_fn_pointer(&mut self, fn_ty_a: PolyFnSig<'db>, b: Ty<'db>) -> CoerceResult<'db> {
+        debug!(?fn_ty_a, ?b, "coerce_from_fn_pointer");
+        debug_assert!(self.table.shallow_resolve(b) == b);
+
+        self.coerce_from_safe_fn(fn_ty_a, b, None)
+    }
+
+    fn coerce_from_fn_item(&mut self, a: Ty<'db>, b: Ty<'db>) -> CoerceResult<'db> {
+        debug!("coerce_from_fn_item(a={:?}, b={:?})", a, b);
+        debug_assert!(self.table.shallow_resolve(a) == a);
+        debug_assert!(self.table.shallow_resolve(b) == b);
+
+        match b.kind() {
+            TyKind::FnPtr(_, b_hdr) => {
+                let a_sig = a.fn_sig(self.interner());
+                if let TyKind::FnDef(def_id, _) = a.kind() {
+                    // Intrinsics are not coercible to function pointers
+                    if let CallableDefId::FunctionId(def_id) = def_id.0 {
+                        if FunctionSignature::is_intrinsic(self.table.db, def_id) {
+                            return Err(TypeError::IntrinsicCast);
+                        }
+
+                        let attrs = self.table.db.attrs(def_id.into());
+                        if attrs.by_key(sym::rustc_force_inline).exists() {
+                            return Err(TypeError::ForceInlineCast);
+                        }
+
+                        if b_hdr.safety.is_safe() && attrs.by_key(sym::target_feature).exists() {
+                            let fn_target_features =
+                                TargetFeatures::from_attrs_no_implications(&attrs);
+                            // Allow the coercion if the current function has all the features that would be
+                            // needed to call the coercee safely.
+                            let (target_features, target_feature_is_safe) =
+                                (self.target_features)();
+                            if target_feature_is_safe == TargetFeatureIsSafeInTarget::No
+                                && !target_features.enabled.is_superset(&fn_target_features.enabled)
+                            {
+                                return Err(TypeError::TargetFeatureCast(
+                                    CallableIdWrapper(def_id.into()).into(),
+                                ));
+                            }
+                        }
+                    }
+                }
+
+                self.coerce_from_safe_fn(
+                    a_sig,
+                    b,
+                    Some(Adjust::Pointer(PointerCast::ReifyFnPointer)),
+                )
+            }
+            _ => self.unify(a, b),
         }
-        self.unify_and(&from_ty, to_ty, normal)
     }
 
-    /// Attempts to coerce from the type of a non-capturing closure into a
-    /// function pointer.
+    /// Attempts to coerce from the type of a non-capturing closure
+    /// into a function pointer.
     fn coerce_closure_to_fn(
         &mut self,
-        from_ty: Ty,
-        from_substs: &Substitution,
-        to_ty: &Ty,
+        a: Ty<'db>,
+        _closure_def_id_a: InternedClosureId,
+        args_a: GenericArgs<'db>,
+        b: Ty<'db>,
     ) -> CoerceResult<'db> {
-        match to_ty.kind(Interner) {
-            // if from_substs is non-capturing (FIXME)
-            TyKind::Function(fn_ty) => {
+        debug_assert!(self.table.shallow_resolve(a) == a);
+        debug_assert!(self.table.shallow_resolve(b) == b);
+
+        match b.kind() {
+            // FIXME: We need to have an `upvars_mentioned()` query:
+            // At this point we haven't done capture analysis, which means
+            // that the ClosureArgs just contains an inference variable instead
+            // of tuple of captured types.
+            //
+            // 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.
+            TyKind::FnPtr(_, hdr) =>
+            // if self
+            //     .db
+            //     .upvars_mentioned(closure_def_id_a.expect_local())
+            //     .is_none_or(|u| u.is_empty()) =>
+            {
                 // We coerce the closure, which has fn type
                 //     `extern "rust-call" fn((arg0,arg1,...)) -> _`
                 // to
                 //     `fn(arg0,arg1,...) -> _`
                 // or
                 //     `unsafe fn(arg0,arg1,...) -> _`
-                let safety = fn_ty.sig.safety;
-                let pointer_ty = coerce_closure_fn_ty(from_substs, safety);
+                let safety = hdr.safety;
+                let closure_sig = args_a.closure_sig_untupled().map_bound(|mut sig| {
+                    sig.safety = hdr.safety;
+                    sig
+                });
+                let pointer_ty = Ty::new_fn_ptr(self.interner(), closure_sig);
+                debug!("coerce_closure_to_fn(a={:?}, b={:?}, pty={:?})", a, b, pointer_ty);
                 self.unify_and(
-                    &pointer_ty,
-                    to_ty,
-                    simple(Adjust::Pointer(PointerCast::ClosureFnPointer(safety))),
+                    pointer_ty,
+                    b,
+                    [],
+                    Adjust::Pointer(PointerCast::ClosureFnPointer(
+                        safety.to_chalk(self.interner()),
+                    )),
                 )
             }
-            _ => self.unify_and(&from_ty, to_ty, identity),
+            _ => self.unify(a, b),
         }
     }
 
-    /// Coerce a type using `from_ty: CoerceUnsized<ty_ty>`
-    ///
-    /// See: <https://doc.rust-lang.org/nightly/std/marker/trait.CoerceUnsized.html>
-    fn try_coerce_unsized(&mut self, from_ty: &Ty, to_ty: &Ty) -> CoerceResult<'db> {
-        // These 'if' statements require some explanation.
-        // The `CoerceUnsized` trait is special - it is only
-        // possible to write `impl CoerceUnsized<B> for A` where
-        // A and B have 'matching' fields. This rules out the following
-        // two types of blanket impls:
-        //
-        // `impl<T> CoerceUnsized<T> for SomeType`
-        // `impl<T> CoerceUnsized<SomeType> for T`
-        //
-        // Both of these trigger a special `CoerceUnsized`-related error (E0376)
-        //
-        // We can take advantage of this fact to avoid performing unnecessary work.
-        // If either `source` or `target` is a type variable, then any applicable impl
-        // would need to be generic over the self-type (`impl<T> CoerceUnsized<SomeType> for T`)
-        // or generic over the `CoerceUnsized` type parameter (`impl<T> CoerceUnsized<T> for
-        // SomeType`).
-        //
-        // However, these are exactly the kinds of impls which are forbidden by
-        // the compiler! Therefore, we can be sure that coercion will always fail
-        // when either the source or target type is a type variable. This allows us
-        // to skip performing any trait selection, and immediately bail out.
-        if from_ty.is_ty_var() {
-            return Err(TypeError);
+    fn coerce_raw_ptr(&mut self, a: Ty<'db>, b: Ty<'db>, mutbl_b: Mutability) -> CoerceResult<'db> {
+        debug!("coerce_raw_ptr(a={:?}, b={:?})", a, b);
+        debug_assert!(self.table.shallow_resolve(a) == a);
+        debug_assert!(self.table.shallow_resolve(b) == b);
+
+        let (is_ref, mt_a) = match a.kind() {
+            TyKind::Ref(_, ty, mutbl) => (true, TypeAndMut::<DbInterner<'db>> { ty, mutbl }),
+            TyKind::RawPtr(ty, mutbl) => (false, TypeAndMut { ty, mutbl }),
+            _ => return self.unify(a, b),
+        };
+        coerce_mutbls(mt_a.mutbl, mutbl_b)?;
+
+        // Check that the types which they point at are compatible.
+        let a_raw = Ty::new_ptr(self.interner(), mt_a.ty, mutbl_b);
+        // Although references and raw ptrs have the same
+        // representation, we still register an Adjust::DerefRef so that
+        // regionck knows that the region for `a` must be valid here.
+        if is_ref {
+            self.unify_and(
+                a_raw,
+                b,
+                [Adjustment {
+                    kind: Adjust::Deref(None),
+                    target: mt_a.ty.to_chalk(self.interner()),
+                }],
+                Adjust::Borrow(AutoBorrow::RawPtr(mutbl_b.to_chalk(self.interner()))),
+            )
+        } else if mt_a.mutbl != mutbl_b {
+            self.unify_and(a_raw, b, [], Adjust::Pointer(PointerCast::MutToConstPointer))
+        } else {
+            self.unify(a_raw, b)
         }
-        if to_ty.is_ty_var() {
-            return Err(TypeError);
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum CoerceNever {
+    No,
+    Yes,
+}
+
+impl<'db> InferenceContext<'db> {
+    /// Attempt to coerce an expression to a type, and return the
+    /// adjusted type of the expression, if successful.
+    /// Adjustments are only recorded if the coercion succeeded.
+    /// The expressions *must not* have any preexisting adjustments.
+    pub(crate) fn coerce(
+        &mut self,
+        expr: ExprOrPatId,
+        expr_ty: Ty<'db>,
+        mut target: Ty<'db>,
+        allow_two_phase: AllowTwoPhase,
+        coerce_never: CoerceNever,
+    ) -> RelateResult<'db, Ty<'db>> {
+        let source = self.table.try_structurally_resolve_type(expr_ty);
+        target = self.table.try_structurally_resolve_type(target);
+        debug!("coercion::try({:?}: {:?} -> {:?})", expr, source, target);
+
+        let cause = ObligationCause::new();
+        let krate = self.krate();
+        let mut coerce = Coerce {
+            table: &mut self.table,
+            has_errors: &mut self.result.has_errors,
+            cause,
+            allow_two_phase,
+            coerce_never: matches!(coerce_never, CoerceNever::Yes),
+            use_lub: false,
+            target_features: &mut || {
+                Self::target_features(self.db, &self.target_features, self.owner, krate)
+            },
+        };
+        let ok = coerce.commit_if_ok(|coerce| coerce.coerce(source, target))?;
+
+        let (adjustments, _) = self.table.register_infer_ok(ok);
+        match expr {
+            ExprOrPatId::ExprId(expr) => self.write_expr_adj(expr, adjustments.into_boxed_slice()),
+            ExprOrPatId::PatId(pat) => self
+                .write_pat_adj(pat, adjustments.into_iter().map(|adjust| adjust.target).collect()),
         }
+        Ok(target)
+    }
 
-        // Handle reborrows before trying to solve `Source: CoerceUnsized<Target>`.
-        let reborrow = match (from_ty.kind(Interner), to_ty.kind(Interner)) {
-            (TyKind::Ref(from_mt, _, from_inner), &TyKind::Ref(to_mt, _, _)) => {
-                coerce_mutabilities(*from_mt, to_mt)?;
+    /// Given some expressions, their known unified type and another expression,
+    /// tries to unify the types, potentially inserting coercions on any of the
+    /// provided expressions and returns their LUB (aka "common supertype").
+    ///
+    /// This is really an internal helper. From outside the coercion
+    /// module, you should instantiate a `CoerceMany` instance.
+    fn try_find_coercion_lub(
+        &mut self,
+        exprs: &[ExprId],
+        prev_ty: Ty<'db>,
+        new: ExprId,
+        new_ty: Ty<'db>,
+    ) -> RelateResult<'db, Ty<'db>> {
+        let prev_ty = self.table.try_structurally_resolve_type(prev_ty);
+        let new_ty = self.table.try_structurally_resolve_type(new_ty);
+        debug!(
+            "coercion::try_find_coercion_lub({:?}, {:?}, exprs={:?} exprs)",
+            prev_ty,
+            new_ty,
+            exprs.len()
+        );
+
+        // The following check fixes #88097, where the compiler erroneously
+        // attempted to coerce a closure type to itself via a function pointer.
+        if prev_ty == new_ty {
+            return Ok(prev_ty);
+        }
 
-                let lt = self.new_lifetime_var();
-                Some((
-                    Adjustment { kind: Adjust::Deref(None), target: from_inner.clone() },
-                    Adjustment {
-                        kind: Adjust::Borrow(AutoBorrow::Ref(lt.clone(), to_mt)),
-                        target: TyKind::Ref(to_mt, lt, from_inner.clone()).intern(Interner),
-                    },
-                ))
+        let is_force_inline = |ty: Ty<'db>| {
+            if let TyKind::FnDef(CallableIdWrapper(CallableDefId::FunctionId(did)), _) = ty.kind() {
+                self.db.attrs(did.into()).by_key(sym::rustc_force_inline).exists()
+            } else {
+                false
             }
-            (TyKind::Ref(from_mt, _, from_inner), &TyKind::Raw(to_mt, _)) => {
-                coerce_mutabilities(*from_mt, to_mt)?;
+        };
+        if is_force_inline(prev_ty) || is_force_inline(new_ty) {
+            return Err(TypeError::ForceInlineCast);
+        }
 
-                Some((
-                    Adjustment { kind: Adjust::Deref(None), target: from_inner.clone() },
-                    Adjustment {
-                        kind: Adjust::Borrow(AutoBorrow::RawPtr(to_mt)),
-                        target: TyKind::Raw(to_mt, from_inner.clone()).intern(Interner),
-                    },
-                ))
+        // Special-case that coercion alone cannot handle:
+        // Function items or non-capturing closures of differing IDs or GenericArgs.
+        let (a_sig, b_sig) = {
+            let is_capturing_closure = |_ty: Ty<'db>| {
+                // FIXME:
+                // if let TyKind::Closure(closure_def_id, _args) = ty.kind() {
+                //     self.db.upvars_mentioned(closure_def_id.expect_local()).is_some()
+                // } else {
+                //     false
+                // }
+                false
+            };
+            if is_capturing_closure(prev_ty) || is_capturing_closure(new_ty) {
+                (None, None)
+            } else {
+                match (prev_ty.kind(), new_ty.kind()) {
+                    (TyKind::FnDef(..), TyKind::FnDef(..)) => {
+                        // Don't reify if the function types have a LUB, i.e., they
+                        // are the same function and their parameters have a LUB.
+                        match self.table.commit_if_ok(|table| {
+                            // We need to eagerly handle nested obligations due to lazy norm.
+                            let mut ocx = ObligationCtxt::new(&table.infer_ctxt);
+                            let value =
+                                ocx.lub(&ObligationCause::new(), table.param_env, prev_ty, new_ty)?;
+                            if ocx.select_where_possible().is_empty() {
+                                Ok(InferOk { value, obligations: ocx.into_pending_obligations() })
+                            } else {
+                                Err(TypeError::Mismatch)
+                            }
+                        }) {
+                            // We have a LUB of prev_ty and new_ty, just return it.
+                            Ok(ok) => return Ok(self.table.register_infer_ok(ok)),
+                            Err(_) => (
+                                Some(prev_ty.fn_sig(self.table.interner)),
+                                Some(new_ty.fn_sig(self.table.interner)),
+                            ),
+                        }
+                    }
+                    (TyKind::Closure(_, args), TyKind::FnDef(..)) => {
+                        let b_sig = new_ty.fn_sig(self.table.interner);
+                        let a_sig = args.closure_sig_untupled().map_bound(|mut sig| {
+                            sig.safety = b_sig.safety();
+                            sig
+                        });
+                        (Some(a_sig), Some(b_sig))
+                    }
+                    (TyKind::FnDef(..), TyKind::Closure(_, args)) => {
+                        let a_sig = prev_ty.fn_sig(self.table.interner);
+                        let b_sig = args.closure_sig_untupled().map_bound(|mut sig| {
+                            sig.safety = a_sig.safety();
+                            sig
+                        });
+                        (Some(a_sig), Some(b_sig))
+                    }
+                    (TyKind::Closure(_, args_a), TyKind::Closure(_, args_b)) => {
+                        (Some(args_a.closure_sig_untupled()), Some(args_b.closure_sig_untupled()))
+                    }
+                    _ => (None, None),
+                }
             }
-            _ => None,
         };
-        let coerce_from =
-            reborrow.as_ref().map_or_else(|| from_ty.clone(), |(_, adj)| adj.target.clone());
+        if let (Some(a_sig), Some(b_sig)) = (a_sig, b_sig) {
+            // The signature must match.
+            let sig = self
+                .table
+                .infer_ctxt
+                .at(&ObligationCause::new(), self.table.param_env)
+                .lub(a_sig, b_sig)
+                .map(|ok| self.table.register_infer_ok(ok))?;
+
+            // Reify both sides and return the reified fn pointer type.
+            let fn_ptr = Ty::new_fn_ptr(self.table.interner, sig);
+            let prev_adjustment = match prev_ty.kind() {
+                TyKind::Closure(..) => Adjust::Pointer(PointerCast::ClosureFnPointer(
+                    a_sig.safety().to_chalk(self.table.interner),
+                )),
+                TyKind::FnDef(..) => Adjust::Pointer(PointerCast::ReifyFnPointer),
+                _ => panic!("should not try to coerce a {prev_ty:?} to a fn pointer"),
+            };
+            let next_adjustment = match new_ty.kind() {
+                TyKind::Closure(..) => Adjust::Pointer(PointerCast::ClosureFnPointer(
+                    b_sig.safety().to_chalk(self.table.interner),
+                )),
+                TyKind::FnDef(..) => Adjust::Pointer(PointerCast::ReifyFnPointer),
+                _ => panic!("should not try to coerce a {new_ty:?} to a fn pointer"),
+            };
+            for &expr in exprs {
+                self.write_expr_adj(
+                    expr,
+                    Box::new([Adjustment {
+                        kind: prev_adjustment.clone(),
+                        target: fn_ptr.to_chalk(self.table.interner),
+                    }]),
+                );
+            }
+            self.write_expr_adj(
+                new,
+                Box::new([Adjustment {
+                    kind: next_adjustment,
+                    target: fn_ptr.to_chalk(self.table.interner),
+                }]),
+            );
+            return Ok(fn_ptr);
+        }
 
-        let krate = self.trait_env.krate;
-        let coerce_unsized_trait = match LangItem::CoerceUnsized.resolve_trait(self.db, krate) {
-            Some(trait_) => trait_,
-            _ => return Err(TypeError),
+        // Configure a Coerce instance to compute the LUB.
+        // We don't allow two-phase borrows on any autorefs this creates since we
+        // probably aren't processing function arguments here and even if we were,
+        // they're going to get autorefed again anyway and we can apply 2-phase borrows
+        // at that time.
+        //
+        // NOTE: we set `coerce_never` to `true` here because coercion LUBs only
+        // operate on values and not places, so a never coercion is valid.
+        let krate = self.krate();
+        let mut coerce = Coerce {
+            table: &mut self.table,
+            has_errors: &mut self.result.has_errors,
+            cause: ObligationCause::new(),
+            allow_two_phase: AllowTwoPhase::No,
+            coerce_never: true,
+            use_lub: true,
+            target_features: &mut || {
+                Self::target_features(self.db, &self.target_features, self.owner, krate)
+            },
         };
 
-        let coerce_unsized_tref = {
-            let b = TyBuilder::trait_ref(self.db, coerce_unsized_trait);
-            if b.remaining() != 2 {
-                // The CoerceUnsized trait should have two generic params: Self and T.
-                return Err(TypeError);
+        // First try to coerce the new expression to the type of the previous ones,
+        // but only if the new expression has no coercion already applied to it.
+        let mut first_error = None;
+        if !self.result.expr_adjustments.contains_key(&new) {
+            let result = coerce.commit_if_ok(|coerce| coerce.coerce(new_ty, prev_ty));
+            match result {
+                Ok(ok) => {
+                    let (adjustments, target) = self.table.register_infer_ok(ok);
+                    self.write_expr_adj(new, adjustments.into_boxed_slice());
+                    debug!(
+                        "coercion::try_find_coercion_lub: was able to coerce from new type {:?} to previous type {:?} ({:?})",
+                        new_ty, prev_ty, target
+                    );
+                    return Ok(target);
+                }
+                Err(e) => first_error = Some(e),
             }
-            b.push(coerce_from).push(to_ty.clone()).build()
-        };
+        }
+
+        match coerce.commit_if_ok(|coerce| coerce.coerce(prev_ty, new_ty)) {
+            Err(_) => {
+                // Avoid giving strange errors on failed attempts.
+                if let Some(e) = first_error {
+                    Err(e)
+                } else {
+                    Err(self
+                        .table
+                        .commit_if_ok(|table| {
+                            table
+                                .infer_ctxt
+                                .at(&ObligationCause::new(), table.param_env)
+                                .lub(prev_ty, new_ty)
+                        })
+                        .unwrap_err())
+                }
+            }
+            Ok(ok) => {
+                let (adjustments, target) = self.table.register_infer_ok(ok);
+                for &expr in exprs {
+                    self.write_expr_adj(expr, adjustments.as_slice().into());
+                }
+                debug!(
+                    "coercion::try_find_coercion_lub: was able to coerce previous type {:?} to new type {:?} ({:?})",
+                    prev_ty, new_ty, target
+                );
+                Ok(target)
+            }
+        }
+    }
+}
 
-        let goal: Goal = coerce_unsized_tref.cast(Interner);
+/// CoerceMany encapsulates the pattern you should use when you have
+/// many expressions that are all getting coerced to a common
+/// type. This arises, for example, when you have a match (the result
+/// of each arm is coerced to a common type). It also arises in less
+/// obvious places, such as when you have many `break foo` expressions
+/// that target the same loop, or the various `return` expressions in
+/// a function.
+///
+/// The basic protocol is as follows:
+///
+/// - Instantiate the `CoerceMany` with an initial `expected_ty`.
+///   This will also serve as the "starting LUB". The expectation is
+///   that this type is something which all of the expressions *must*
+///   be coercible to. Use a fresh type variable if needed.
+/// - For each expression whose result is to be coerced, invoke `coerce()` with.
+///   - In some cases we wish to coerce "non-expressions" whose types are implicitly
+///     unit. This happens for example if you have a `break` with no expression,
+///     or an `if` with no `else`. In that case, invoke `coerce_forced_unit()`.
+///   - `coerce()` and `coerce_forced_unit()` may report errors. They hide this
+///     from you so that you don't have to worry your pretty head about it.
+///     But if an error is reported, the final type will be `err`.
+///   - Invoking `coerce()` may cause us to go and adjust the "adjustments" on
+///     previously coerced expressions.
+/// - When all done, invoke `complete()`. This will return the LUB of
+///   all your expressions.
+///   - WARNING: I don't believe this final type is guaranteed to be
+///     related to your initial `expected_ty` in any particular way,
+///     although it will typically be a subtype, so you should check it.
+///   - Invoking `complete()` may cause us to go and adjust the "adjustments" on
+///     previously coerced expressions.
+///
+/// Example:
+///
+/// ```ignore (illustrative)
+/// let mut coerce = CoerceMany::new(expected_ty);
+/// for expr in exprs {
+///     let expr_ty = fcx.check_expr_with_expectation(expr, expected);
+///     coerce.coerce(fcx, &cause, expr, expr_ty);
+/// }
+/// let final_ty = coerce.complete(fcx);
+/// ```
+#[derive(Debug, Clone)]
+pub(crate) struct CoerceMany<'db, 'exprs> {
+    expected_ty: Ty<'db>,
+    final_ty: Option<Ty<'db>>,
+    expressions: Expressions<'exprs>,
+    pushed: usize,
+}
 
-        self.commit_if_ok(|table| match table.solve_obligation(goal) {
-            Ok(Certainty::Yes) => Ok(()),
-            _ => Err(TypeError),
-        })?;
+/// The type of a `CoerceMany` that is storing up the expressions into
+/// a buffer. We use this for things like `break`.
+pub(crate) type DynamicCoerceMany<'db> = CoerceMany<'db, 'db>;
 
-        let unsize =
-            Adjustment { kind: Adjust::Pointer(PointerCast::Unsize), target: to_ty.clone() };
-        let adjustments = match reborrow {
-            None => vec![unsize],
-            Some((deref, autoref)) => vec![deref, autoref, unsize],
-        };
-        success(adjustments, to_ty.clone(), vec![])
-    }
+#[derive(Debug, Clone)]
+enum Expressions<'exprs> {
+    Dynamic(SmallVec<[ExprId; 4]>),
+    UpFront(&'exprs [ExprId]),
 }
 
-fn coerce_closure_fn_ty(closure_substs: &Substitution, safety: chalk_ir::Safety) -> Ty {
-    let closure_sig = ClosureSubst(closure_substs).sig_ty().clone();
-    match closure_sig.kind(Interner) {
-        TyKind::Function(fn_ty) => TyKind::Function(FnPointer {
-            num_binders: fn_ty.num_binders,
-            sig: FnSig { safety, abi: FnAbi::Rust, variadic: fn_ty.sig.variadic },
-            substitution: fn_ty.substitution.clone(),
-        })
-        .intern(Interner),
-        _ => TyKind::Error.intern(Interner),
+impl<'db, 'exprs> CoerceMany<'db, 'exprs> {
+    /// 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(crate) fn new(expected_ty: Ty<'db>) -> Self {
+        Self::make(expected_ty, Expressions::Dynamic(SmallVec::new()))
     }
-}
 
-fn safe_to_unsafe_fn_ty(fn_ty: FnPointer) -> FnPointer {
-    FnPointer {
-        num_binders: fn_ty.num_binders,
-        sig: FnSig { safety: chalk_ir::Safety::Unsafe, ..fn_ty.sig },
-        substitution: fn_ty.substitution,
+    /// As an optimization, you can create a `CoerceMany` with a
+    /// preexisting slice of expressions. In this case, you are
+    /// 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(crate) fn with_coercion_sites(
+        expected_ty: Ty<'db>,
+        coercion_sites: &'exprs [ExprId],
+    ) -> Self {
+        Self::make(expected_ty, Expressions::UpFront(coercion_sites))
+    }
+
+    fn make(expected_ty: Ty<'db>, expressions: Expressions<'exprs>) -> Self {
+        CoerceMany { expected_ty, final_ty: None, expressions, pushed: 0 }
+    }
+
+    /// Returns the "expected type" with which this coercion was
+    /// constructed. This represents the "downward propagated" type
+    /// that was given to us at the start of typing whatever construct
+    /// we are typing (e.g., the match expression).
+    ///
+    /// Typically, this is used as the expected type when
+    /// type-checking each of the alternative expressions whose types
+    /// we are trying to merge.
+    pub(crate) fn expected_ty(&self) -> Ty<'db> {
+        self.expected_ty
+    }
+
+    /// Returns the current "merged type", representing our best-guess
+    /// 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(crate) fn merged_ty(&self) -> Ty<'db> {
+        self.final_ty.unwrap_or(self.expected_ty)
     }
-}
 
-fn coerce_mutabilities(from: Mutability, to: Mutability) -> Result<(), TypeError> {
-    match (from, to) {
-        (Mutability::Mut, Mutability::Mut | Mutability::Not)
-        | (Mutability::Not, Mutability::Not) => Ok(()),
-        (Mutability::Not, Mutability::Mut) => Err(TypeError),
+    /// Indicates that the value generated by `expression`, which is
+    /// of type `expression_ty`, is one of the possibilities that we
+    /// could coerce from. This will record `expression`, and later
+    /// calls to `coerce` may come back and add adjustments and things
+    /// if necessary.
+    pub(crate) fn coerce(
+        &mut self,
+        icx: &mut InferenceContext<'db>,
+        cause: &ObligationCause,
+        expression: ExprId,
+        expression_ty: Ty<'db>,
+    ) {
+        self.coerce_inner(icx, cause, expression, expression_ty, false, false)
+    }
+
+    /// Indicates that one of the inputs is a "forced unit". This
+    /// occurs in a case like `if foo { ... };`, where the missing else
+    /// generates a "forced unit". Another example is a `loop { break;
+    /// }`, where the `break` has no argument expression. We treat
+    /// these cases slightly differently for error-reporting
+    /// purposes. Note that these tend to correspond to cases where
+    /// the `()` expression is implicit in the source, and hence we do
+    /// not take an expression argument.
+    ///
+    /// 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(crate) fn coerce_forced_unit(
+        &mut self,
+        icx: &mut InferenceContext<'db>,
+        expr: ExprId,
+        cause: &ObligationCause,
+        label_unit_as_expected: bool,
+    ) {
+        self.coerce_inner(
+            icx,
+            cause,
+            expr,
+            icx.result.standard_types.unit.to_nextsolver(icx.table.interner),
+            true,
+            label_unit_as_expected,
+        )
+    }
+
+    /// The inner coercion "engine". If `expression` is `None`, this
+    /// is a forced-unit case, and hence `expression_ty` must be
+    /// `Nil`.
+    pub(crate) fn coerce_inner(
+        &mut self,
+        icx: &mut InferenceContext<'db>,
+        cause: &ObligationCause,
+        expression: ExprId,
+        mut expression_ty: Ty<'db>,
+        force_unit: bool,
+        label_expression_as_expected: bool,
+    ) {
+        // Incorporate whatever type inference information we have
+        // until now; in principle we might also want to process
+        // pending obligations, but doing so should only improve
+        // compatibility (hopefully that is true) by helping us
+        // uncover never types better.
+        if expression_ty.is_ty_var() {
+            expression_ty = icx.shallow_resolve(expression_ty);
+        }
+
+        let (expected, found) = if label_expression_as_expected {
+            // In the case where this is a "forced unit", like
+            // `break`, we want to call the `()` "expected"
+            // since it is implied by the syntax.
+            // (Note: not all force-units work this way.)"
+            (expression_ty, self.merged_ty())
+        } else {
+            // Otherwise, the "expected" type for error
+            // reporting is the current unification type,
+            // which is basically the LUB of the expressions
+            // we've seen so far (combined with the expected
+            // type)
+            (self.merged_ty(), expression_ty)
+        };
+
+        // Handle the actual type unification etc.
+        let result = if !force_unit {
+            if self.pushed == 0 {
+                // Special-case the first expression we are coercing.
+                // To be honest, I'm not entirely sure why we do this.
+                // We don't allow two-phase borrows, see comment in try_find_coercion_lub for why
+                icx.coerce(
+                    expression.into(),
+                    expression_ty,
+                    self.expected_ty,
+                    AllowTwoPhase::No,
+                    CoerceNever::Yes,
+                )
+            } else {
+                match self.expressions {
+                    Expressions::Dynamic(ref exprs) => icx.try_find_coercion_lub(
+                        exprs,
+                        self.merged_ty(),
+                        expression,
+                        expression_ty,
+                    ),
+                    Expressions::UpFront(coercion_sites) => icx.try_find_coercion_lub(
+                        &coercion_sites[0..self.pushed],
+                        self.merged_ty(),
+                        expression,
+                        expression_ty,
+                    ),
+                }
+            }
+        } else {
+            // this is a hack for cases where we default to `()` because
+            // the expression etc has been omitted from the source. An
+            // example is an `if let` without an else:
+            //
+            //     if let Some(x) = ... { }
+            //
+            // we wind up with a second match arm that is like `_ =>
+            // ()`. That is the case we are considering here. We take
+            // a different path to get the right "expected, found"
+            // message and so forth (and because we know that
+            // `expression_ty` will be unit).
+            //
+            // Another example is `break` with no argument expression.
+            assert!(expression_ty.is_unit(), "if let hack without unit type");
+            icx.table
+                .infer_ctxt
+                .at(cause, icx.table.param_env)
+                .eq(
+                    // needed for tests/ui/type-alias-impl-trait/issue-65679-inst-opaque-ty-from-val-twice.rs
+                    DefineOpaqueTypes::Yes,
+                    expected,
+                    found,
+                )
+                .map(|infer_ok| {
+                    icx.table.register_infer_ok(infer_ok);
+                    expression_ty
+                })
+        };
+
+        debug!(?result);
+        match result {
+            Ok(v) => {
+                self.final_ty = Some(v);
+                match self.expressions {
+                    Expressions::Dynamic(ref mut buffer) => buffer.push(expression),
+                    Expressions::UpFront(coercion_sites) => {
+                        // if the user gave us an array to validate, check that we got
+                        // the next expression in the list, as expected
+                        assert_eq!(coercion_sites[self.pushed], expression);
+                    }
+                }
+            }
+            Err(_coercion_error) => {
+                // Mark that we've failed to coerce the types here to suppress
+                // any superfluous errors we might encounter while trying to
+                // emit or provide suggestions on how to fix the initial error.
+                icx.set_tainted_by_errors();
+
+                self.final_ty = Some(Ty::new_error(icx.table.interner, ErrorGuaranteed));
+
+                icx.result.type_mismatches.insert(
+                    expression.into(),
+                    if label_expression_as_expected {
+                        TypeMismatch {
+                            expected: found.to_chalk(icx.table.interner),
+                            actual: expected.to_chalk(icx.table.interner),
+                        }
+                    } else {
+                        TypeMismatch {
+                            expected: expected.to_chalk(icx.table.interner),
+                            actual: found.to_chalk(icx.table.interner),
+                        }
+                    },
+                );
+            }
+        }
+
+        self.pushed += 1;
+    }
+
+    pub(crate) fn complete(self, icx: &mut InferenceContext<'db>) -> Ty<'db> {
+        if let Some(final_ty) = self.final_ty {
+            final_ty
+        } else {
+            // If we only had inputs that were of type `!` (or no
+            // inputs at all), then the final type is `!`.
+            assert_eq!(self.pushed, 0);
+            icx.result.standard_types.never.to_nextsolver(icx.table.interner)
+        }
     }
 }
 
-pub(super) fn auto_deref_adjust_steps(autoderef: &Autoderef<'_, '_>) -> Vec<Adjustment> {
-    let steps = autoderef.steps();
-    let targets =
-        steps.iter().skip(1).map(|(_, ty)| ty.clone()).chain(iter::once(autoderef.final_ty()));
-    steps
-        .iter()
-        .map(|(kind, _source)| match kind {
-            // We do not know what kind of deref we require at this point yet
-            AutoderefKind::Overloaded => Some(OverloadedDeref(None)),
-            AutoderefKind::Builtin => None,
-        })
-        .zip(targets)
-        .map(|(autoderef, target)| Adjustment { kind: Adjust::Deref(autoderef), target })
-        .collect()
+pub fn could_coerce(
+    db: &dyn HirDatabase,
+    env: Arc<TraitEnvironment>,
+    tys: &crate::Canonical<(crate::Ty, crate::Ty)>,
+) -> bool {
+    coerce(db, env, tys).is_ok()
+}
+
+fn coerce<'db>(
+    db: &'db dyn HirDatabase,
+    env: Arc<TraitEnvironment>,
+    tys: &crate::Canonical<(crate::Ty, crate::Ty)>,
+) -> Result<(Vec<Adjustment>, crate::Ty), TypeError<DbInterner<'db>>> {
+    let mut table = InferenceTable::new(db, env);
+    let vars = table.fresh_subst(tys.binders.as_slice(Interner));
+    let ty1_with_vars = vars.apply(tys.value.0.clone(), Interner);
+    let ty2_with_vars = vars.apply(tys.value.1.clone(), Interner);
+
+    let cause = ObligationCause::new();
+    // FIXME: Target features.
+    let target_features = TargetFeatures::default();
+    let mut coerce = Coerce {
+        table: &mut table,
+        has_errors: &mut false,
+        cause,
+        allow_two_phase: AllowTwoPhase::No,
+        coerce_never: true,
+        use_lub: false,
+        target_features: &mut || (&target_features, TargetFeatureIsSafeInTarget::No),
+    };
+    let InferOk { value: (adjustments, ty), obligations } = coerce.coerce(
+        ty1_with_vars.to_nextsolver(coerce.table.interner),
+        ty2_with_vars.to_nextsolver(coerce.table.interner),
+    )?;
+    table.register_predicates(obligations);
+
+    // default any type vars that weren't unified back to their original bound vars
+    // (kind of hacky)
+    let find_var = |iv| {
+        vars.iter(Interner).position(|v| match v.interned() {
+            chalk_ir::GenericArgData::Ty(ty) => ty.inference_var(Interner),
+            chalk_ir::GenericArgData::Lifetime(lt) => lt.inference_var(Interner),
+            chalk_ir::GenericArgData::Const(c) => c.inference_var(Interner),
+        } == Some(iv))
+    };
+    let fallback = |iv, kind, default, binder| match kind {
+        chalk_ir::VariableKind::Ty(_ty_kind) => find_var(iv)
+            .map_or(default, |i| crate::BoundVar::new(binder, i).to_ty(Interner).cast(Interner)),
+        chalk_ir::VariableKind::Lifetime => find_var(iv).map_or(default, |i| {
+            crate::BoundVar::new(binder, i).to_lifetime(Interner).cast(Interner)
+        }),
+        chalk_ir::VariableKind::Const(ty) => find_var(iv).map_or(default, |i| {
+            crate::BoundVar::new(binder, i).to_const(Interner, ty).cast(Interner)
+        }),
+    };
+    // FIXME also map the types in the adjustments
+    Ok((adjustments, table.resolve_with_fallback(ty.to_chalk(table.interner), &fallback)))
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
index 0a58ea11bb871..c5a51dfc4cf92 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
@@ -1,12 +1,10 @@
 //! Type inference for expressions.
 
-use std::{
-    iter::{repeat, repeat_with},
-    mem,
-};
+use std::{iter::repeat_with, mem};
 
 use chalk_ir::{DebruijnIndex, Mutability, TyVariableKind, cast::Cast};
 use either::Either;
+use hir_def::hir::ClosureKind;
 use hir_def::{
     BlockId, FieldId, GenericDefId, GenericParamId, ItemContainerId, Lookup, TupleFieldId, TupleId,
     expr_store::path::{GenericArg, GenericArgs, Path},
@@ -19,19 +17,23 @@ use hir_def::{
 };
 use hir_expand::name::Name;
 use intern::sym;
+use rustc_type_ir::inherent::{AdtDef, IntoKind, SliceLike, Ty as _};
 use stdx::always;
 use syntax::ast::RangeOp;
+use tracing::debug;
 
+use crate::autoderef::overloaded_deref_ty;
+use crate::next_solver::ErrorGuaranteed;
+use crate::next_solver::infer::DefineOpaqueTypes;
+use crate::next_solver::obligation_ctxt::ObligationCtxt;
 use crate::{
     Adjust, Adjustment, AdtId, AutoBorrow, Binders, CallableDefId, CallableSig, DeclContext,
     DeclOrigin, IncorrectGenericsLenKind, Interner, LifetimeElisionKind, Rawness, Scalar,
-    Substitution, TraitEnvironment, TraitRef, Ty, TyBuilder, TyExt, TyKind,
-    autoderef::{Autoderef, builtin_deref, deref_by_trait},
-    consteval,
+    Substitution, TraitEnvironment, TraitRef, Ty, TyBuilder, TyExt, TyKind, consteval,
     generics::generics,
     infer::{
-        BreakableKind,
-        coerce::{CoerceMany, CoerceNever, CoercionCause},
+        AllowTwoPhase, BreakableKind,
+        coerce::{CoerceMany, CoerceNever},
         find_continuable,
         pat::contains_explicit_ref_binding,
     },
@@ -42,7 +44,10 @@ use crate::{
     },
     mapping::{ToChalk, from_chalk},
     method_resolution::{self, VisibleFromModule},
-    next_solver::mapping::ChalkToNextSolver,
+    next_solver::{
+        infer::traits::ObligationCause,
+        mapping::{ChalkToNextSolver, NextSolverToChalk},
+    },
     primitive::{self, UintTy},
     static_lifetime, to_chalk_trait_id,
     traits::FnTrait,
@@ -50,7 +55,7 @@ use crate::{
 
 use super::{
     BreakableContext, Diverges, Expectation, InferenceContext, InferenceDiagnostic, TypeMismatch,
-    cast::CastCheck, coerce::auto_deref_adjust_steps, find_breakable,
+    cast::CastCheck, find_breakable,
 };
 
 #[derive(Clone, Copy, PartialEq, Eq)]
@@ -59,7 +64,7 @@ pub(crate) enum ExprIsRead {
     No,
 }
 
-impl InferenceContext<'_> {
+impl<'db> InferenceContext<'db> {
     pub(crate) fn infer_expr(
         &mut self,
         tgt_expr: ExprId,
@@ -98,8 +103,14 @@ impl InferenceContext<'_> {
             } else {
                 CoerceNever::No
             };
-            match self.coerce(Some(expr), &ty, &target, coerce_never) {
-                Ok(res) => res,
+            match self.coerce(
+                expr.into(),
+                ty.to_nextsolver(self.table.interner),
+                target.to_nextsolver(self.table.interner),
+                AllowTwoPhase::No,
+                coerce_never,
+            ) {
+                Ok(res) => res.to_chalk(self.table.interner),
                 Err(_) => {
                     self.result.type_mismatches.insert(
                         expr.into(),
@@ -260,8 +271,15 @@ impl InferenceContext<'_> {
             }
 
             if let Some(target) = expected.only_has_type(&mut self.table) {
-                self.coerce(Some(expr), &ty, &target, CoerceNever::Yes)
-                    .expect("never-to-any coercion should always succeed")
+                self.coerce(
+                    expr.into(),
+                    ty.to_nextsolver(self.table.interner),
+                    target.to_nextsolver(self.table.interner),
+                    AllowTwoPhase::No,
+                    CoerceNever::Yes,
+                )
+                .expect("never-to-any coercion should always succeed")
+                .to_chalk(self.table.interner)
             } else {
                 ty
             }
@@ -304,27 +322,41 @@ impl InferenceContext<'_> {
 
                 let then_ty = self.infer_expr_inner(then_branch, expected, ExprIsRead::Yes);
                 let then_diverges = mem::replace(&mut self.diverges, Diverges::Maybe);
-                let mut coerce = CoerceMany::new(expected.coercion_target_type(&mut self.table));
-                coerce.coerce(self, Some(then_branch), &then_ty, CoercionCause::Expr(then_branch));
+                let mut coercion_sites = [then_branch, tgt_expr];
+                if let Some(else_branch) = else_branch {
+                    coercion_sites[1] = else_branch;
+                }
+                let mut coerce = CoerceMany::with_coercion_sites(
+                    expected
+                        .coercion_target_type(&mut self.table)
+                        .to_nextsolver(self.table.interner),
+                    &coercion_sites,
+                );
+                coerce.coerce(
+                    self,
+                    &ObligationCause::new(),
+                    then_branch,
+                    then_ty.to_nextsolver(self.table.interner),
+                );
                 match else_branch {
                     Some(else_branch) => {
                         let else_ty = self.infer_expr_inner(else_branch, expected, ExprIsRead::Yes);
                         let else_diverges = mem::replace(&mut self.diverges, Diverges::Maybe);
                         coerce.coerce(
                             self,
-                            Some(else_branch),
-                            &else_ty,
-                            CoercionCause::Expr(else_branch),
+                            &ObligationCause::new(),
+                            else_branch,
+                            else_ty.to_nextsolver(self.table.interner),
                         );
                         self.diverges = condition_diverges | then_diverges & else_diverges;
                     }
                     None => {
-                        coerce.coerce_forced_unit(self, CoercionCause::Expr(tgt_expr));
+                        coerce.coerce_forced_unit(self, tgt_expr, &ObligationCause::new(), true);
                         self.diverges = condition_diverges;
                     }
                 }
 
-                coerce.complete(self)
+                coerce.complete(self).to_chalk(self.table.interner)
             }
             &Expr::Let { pat, expr } => {
                 let child_is_read = if self.pat_guaranteed_to_constitute_read_for_never(pat) {
@@ -377,7 +409,15 @@ impl InferenceContext<'_> {
                 }
             }
             Expr::Closure { body, args, ret_type, arg_types, closure_kind, capture_by: _ } => self
-                .infer_closure(body, args, ret_type, arg_types, *closure_kind, tgt_expr, expected),
+                .infer_closure(
+                    *body,
+                    args,
+                    *ret_type,
+                    arg_types,
+                    *closure_kind,
+                    tgt_expr,
+                    expected,
+                ),
             Expr::Call { callee, args, .. } => self.infer_call(tgt_expr, *callee, args, expected),
             Expr::MethodCall { receiver, args, method_name, generic_args } => self
                 .infer_method_call(
@@ -416,7 +456,7 @@ impl InferenceContext<'_> {
                         }
                         _ => self.table.new_type_var(),
                     };
-                    let mut coerce = CoerceMany::new(result_ty);
+                    let mut coerce = CoerceMany::new(result_ty.to_nextsolver(self.table.interner));
 
                     for arm in arms.iter() {
                         if let Some(guard_expr) = arm.guard {
@@ -431,12 +471,17 @@ impl InferenceContext<'_> {
 
                         let arm_ty = self.infer_expr_inner(arm.expr, &expected, ExprIsRead::Yes);
                         all_arms_diverge &= self.diverges;
-                        coerce.coerce(self, Some(arm.expr), &arm_ty, CoercionCause::Expr(arm.expr));
+                        coerce.coerce(
+                            self,
+                            &ObligationCause::new(),
+                            arm.expr,
+                            arm_ty.to_nextsolver(self.table.interner),
+                        );
                     }
 
                     self.diverges = matchee_diverges | all_arms_diverge;
 
-                    coerce.complete(self)
+                    coerce.complete(self).to_chalk(self.table.interner)
                 }
             }
             Expr::Path(p) => self.infer_expr_path(p, tgt_expr.into(), tgt_expr),
@@ -454,7 +499,7 @@ impl InferenceContext<'_> {
                 let val_ty = if let Some(expr) = expr {
                     let opt_coerce_to = match find_breakable(&mut self.breakables, label) {
                         Some(ctxt) => match &ctxt.coerce {
-                            Some(coerce) => coerce.expected_ty(),
+                            Some(coerce) => coerce.expected_ty().to_chalk(self.table.interner),
                             None => {
                                 self.push_diagnostic(InferenceDiagnostic::BreakOutsideOfLoop {
                                     expr: tgt_expr,
@@ -478,11 +523,12 @@ impl InferenceContext<'_> {
                 match find_breakable(&mut self.breakables, label) {
                     Some(ctxt) => match ctxt.coerce.take() {
                         Some(mut coerce) => {
-                            let cause = match expr {
-                                Some(expr) => CoercionCause::Expr(expr),
-                                None => CoercionCause::Expr(tgt_expr),
-                            };
-                            coerce.coerce(self, expr, &val_ty, cause);
+                            coerce.coerce(
+                                self,
+                                &ObligationCause::new(),
+                                expr.unwrap_or(tgt_expr),
+                                val_ty.to_nextsolver(self.table.interner),
+                            );
 
                             // Avoiding borrowck
                             let ctxt = find_breakable(&mut self.breakables, label)
@@ -514,7 +560,13 @@ impl InferenceContext<'_> {
                         );
                     } else {
                         let unit = self.result.standard_types.unit.clone();
-                        let _ = self.coerce(Some(tgt_expr), &unit, &yield_ty, CoerceNever::Yes);
+                        let _ = self.coerce(
+                            tgt_expr.into(),
+                            unit.to_nextsolver(self.table.interner),
+                            yield_ty.to_nextsolver(self.table.interner),
+                            AllowTwoPhase::No,
+                            CoerceNever::Yes,
+                        );
                     }
                     resume_ty
                 } else {
@@ -670,11 +722,23 @@ impl InferenceContext<'_> {
                                 Substitution::empty(Interner),
                             );
                         }
-                        if let Some(derefed) = builtin_deref(self.table.db, &inner_ty, true) {
-                            self.table.structurally_resolve_type(derefed)
+                        if let Some(derefed) =
+                            inner_ty.to_nextsolver(self.table.interner).builtin_deref(self.db, true)
+                        {
+                            self.table
+                                .structurally_resolve_type(&derefed.to_chalk(self.table.interner))
                         } else {
-                            deref_by_trait(&mut self.table, inner_ty, false)
-                                .unwrap_or_else(|| self.err_ty())
+                            let infer_ok = overloaded_deref_ty(
+                                &self.table,
+                                inner_ty.to_nextsolver(self.table.interner),
+                            );
+                            match infer_ok {
+                                Some(infer_ok) => self
+                                    .table
+                                    .register_infer_ok(infer_ok)
+                                    .to_chalk(self.table.interner),
+                                None => self.err_ty(),
+                            }
                         }
                     }
                     UnaryOp::Neg => {
@@ -1010,11 +1074,23 @@ impl InferenceContext<'_> {
                                     CallableSig::from_def(this.db, *def, parameters).to_fn_ptr(),
                                 )
                                 .intern(Interner);
-                                _ = this.coerce(Some(expr), &ty, &fnptr_ty, CoerceNever::Yes);
+                                _ = this.coerce(
+                                    expr.into(),
+                                    ty.to_nextsolver(this.table.interner),
+                                    fnptr_ty.to_nextsolver(this.table.interner),
+                                    AllowTwoPhase::No,
+                                    CoerceNever::Yes,
+                                );
                             }
                             TyKind::Ref(mutbl, _, base_ty) => {
                                 let ptr_ty = TyKind::Raw(*mutbl, base_ty.clone()).intern(Interner);
-                                _ = this.coerce(Some(expr), &ty, &ptr_ty, CoerceNever::Yes);
+                                _ = this.coerce(
+                                    expr.into(),
+                                    ty.to_nextsolver(this.table.interner),
+                                    ptr_ty.to_nextsolver(this.table.interner),
+                                    AllowTwoPhase::No,
+                                    CoerceNever::Yes,
+                                );
                             }
                             _ => {}
                         }
@@ -1092,15 +1168,23 @@ impl InferenceContext<'_> {
         let ret_ty = self.table.new_type_var();
         let prev_diverges = mem::replace(&mut self.diverges, Diverges::Maybe);
         let prev_ret_ty = mem::replace(&mut self.return_ty, ret_ty.clone());
-        let prev_ret_coercion = self.return_coercion.replace(CoerceMany::new(ret_ty.clone()));
+        let prev_ret_coercion = self
+            .return_coercion
+            .replace(CoerceMany::new(ret_ty.to_nextsolver(self.table.interner)));
 
         // FIXME: We should handle async blocks like we handle closures
         let expected = &Expectation::has_type(ret_ty);
         let (_, inner_ty) = self.with_breakable_ctx(BreakableKind::Border, None, None, |this| {
             let ty = this.infer_block(tgt_expr, *id, statements, *tail, None, expected);
             if let Some(target) = expected.only_has_type(&mut this.table) {
-                match this.coerce(Some(tgt_expr), &ty, &target, CoerceNever::Yes) {
-                    Ok(res) => res,
+                match this.coerce(
+                    tgt_expr.into(),
+                    ty.to_nextsolver(this.table.interner),
+                    target.to_nextsolver(this.table.interner),
+                    AllowTwoPhase::No,
+                    CoerceNever::Yes,
+                ) {
+                    Ok(res) => res.to_chalk(this.table.interner),
                     Err(_) => {
                         this.result.type_mismatches.insert(
                             tgt_expr.into(),
@@ -1209,13 +1293,21 @@ impl InferenceContext<'_> {
                 (elem_ty, consteval::usize_const(self.db, Some(0), krate))
             }
             Array::ElementList { elements, .. } => {
-                let mut coerce = CoerceMany::new(elem_ty);
+                let mut coerce = CoerceMany::with_coercion_sites(
+                    elem_ty.to_nextsolver(self.table.interner),
+                    elements,
+                );
                 for &expr in elements.iter() {
                     let cur_elem_ty = self.infer_expr_inner(expr, &expected, ExprIsRead::Yes);
-                    coerce.coerce(self, Some(expr), &cur_elem_ty, CoercionCause::Expr(expr));
+                    coerce.coerce(
+                        self,
+                        &ObligationCause::new(),
+                        expr,
+                        cur_elem_ty.to_nextsolver(self.table.interner),
+                    );
                 }
                 (
-                    coerce.complete(self),
+                    coerce.complete(self).to_chalk(self.table.interner),
                     consteval::usize_const(self.db, Some(elements.len() as u128), krate),
                 )
             }
@@ -1254,11 +1346,17 @@ impl InferenceContext<'_> {
             .return_coercion
             .as_mut()
             .expect("infer_return called outside function body")
-            .expected_ty();
+            .expected_ty()
+            .to_chalk(self.table.interner);
         let return_expr_ty =
             self.infer_expr_inner(expr, &Expectation::HasType(ret_ty), ExprIsRead::Yes);
         let mut coerce_many = self.return_coercion.take().unwrap();
-        coerce_many.coerce(self, Some(expr), &return_expr_ty, CoercionCause::Expr(expr));
+        coerce_many.coerce(
+            self,
+            &ObligationCause::new(),
+            expr,
+            return_expr_ty.to_nextsolver(self.table.interner),
+        );
         self.return_coercion = Some(coerce_many);
     }
 
@@ -1269,7 +1367,7 @@ impl InferenceContext<'_> {
                     self.infer_return(expr);
                 } else {
                     let mut coerce = self.return_coercion.take().unwrap();
-                    coerce.coerce_forced_unit(self, CoercionCause::Expr(ret));
+                    coerce.coerce_forced_unit(self, ret, &ObligationCause::new(), true);
                     self.return_coercion = Some(coerce);
                 }
             }
@@ -1286,7 +1384,7 @@ impl InferenceContext<'_> {
     fn infer_expr_become(&mut self, expr: ExprId) -> Ty {
         match &self.return_coercion {
             Some(return_coercion) => {
-                let ret_ty = return_coercion.expected_ty();
+                let ret_ty = return_coercion.expected_ty().to_chalk(self.table.interner);
 
                 let call_expr_ty = self.infer_expr_inner(
                     expr,
@@ -1540,9 +1638,10 @@ impl InferenceContext<'_> {
                         };
                         if this
                             .coerce(
-                                Some(expr),
-                                &this.result.standard_types.unit.clone(),
-                                &t,
+                                expr.into(),
+                                this.result.standard_types.unit.to_nextsolver(this.table.interner),
+                                t.to_nextsolver(this.table.interner),
+                                AllowTwoPhase::No,
                                 coerce_never,
                             )
                             .is_err()
@@ -1563,6 +1662,7 @@ impl InferenceContext<'_> {
             });
         self.resolver.reset_to_guard(g);
         if let Some(prev_env) = prev_env {
+            self.table.param_env = prev_env.env.to_nextsolver(self.table.interner);
             self.table.trait_env = prev_env;
         }
 
@@ -1574,50 +1674,49 @@ impl InferenceContext<'_> {
         receiver_ty: &Ty,
         name: &Name,
     ) -> Option<(Ty, Either<FieldId, TupleFieldId>, Vec<Adjustment>, bool)> {
-        let mut autoderef = Autoderef::new(&mut self.table, receiver_ty.clone(), false, false);
+        let interner = self.table.interner;
+        let mut autoderef = self.table.autoderef(receiver_ty.to_nextsolver(self.table.interner));
         let mut private_field = None;
         let res = autoderef.by_ref().find_map(|(derefed_ty, _)| {
-            let (field_id, parameters) = match derefed_ty.kind(Interner) {
-                TyKind::Tuple(_, substs) => {
+            let (field_id, parameters) = match derefed_ty.kind() {
+                crate::next_solver::TyKind::Tuple(substs) => {
                     return name.as_tuple_index().and_then(|idx| {
-                        substs
-                            .as_slice(Interner)
-                            .get(idx)
-                            .map(|a| a.assert_ty_ref(Interner))
-                            .cloned()
-                            .map(|ty| {
-                                (
-                                    Either::Right(TupleFieldId {
-                                        tuple: TupleId(
-                                            self.tuple_field_accesses_rev
-                                                .insert_full(substs.clone())
-                                                .0
-                                                as u32,
-                                        ),
-                                        index: idx as u32,
-                                    }),
-                                    ty,
-                                )
-                            })
+                        substs.as_slice().get(idx).copied().map(|ty| {
+                            (
+                                Either::Right(TupleFieldId {
+                                    tuple: TupleId(
+                                        self.tuple_field_accesses_rev
+                                            .insert_full(substs.to_chalk(interner))
+                                            .0 as u32,
+                                    ),
+                                    index: idx as u32,
+                                }),
+                                ty.to_chalk(interner),
+                            )
+                        })
                     });
                 }
-                &TyKind::Adt(AdtId(hir_def::AdtId::StructId(s)), ref parameters) => {
-                    let local_id = s.fields(self.db).field(name)?;
-                    let field = FieldId { parent: s.into(), local_id };
-                    (field, parameters.clone())
-                }
-                &TyKind::Adt(AdtId(hir_def::AdtId::UnionId(u)), ref parameters) => {
-                    let local_id = u.fields(self.db).field(name)?;
-                    let field = FieldId { parent: u.into(), local_id };
-                    (field, parameters.clone())
-                }
+                crate::next_solver::TyKind::Adt(adt, parameters) => match adt.def_id().0 {
+                    hir_def::AdtId::StructId(s) => {
+                        let local_id = s.fields(self.db).field(name)?;
+                        let field = FieldId { parent: s.into(), local_id };
+                        (field, parameters)
+                    }
+                    hir_def::AdtId::UnionId(u) => {
+                        let local_id = u.fields(self.db).field(name)?;
+                        let field = FieldId { parent: u.into(), local_id };
+                        (field, parameters)
+                    }
+                    hir_def::AdtId::EnumId(_) => return None,
+                },
                 _ => return None,
             };
+            let parameters: crate::Substitution = parameters.to_chalk(interner);
             let is_visible = self.db.field_visibilities(field_id.parent)[field_id.local_id]
                 .is_visible_from(self.db, self.resolver.module());
             if !is_visible {
                 if private_field.is_none() {
-                    private_field = Some((field_id, parameters));
+                    private_field = Some((field_id, parameters.clone()));
                 }
                 return None;
             }
@@ -1629,14 +1728,14 @@ impl InferenceContext<'_> {
 
         Some(match res {
             Some((field_id, ty)) => {
-                let adjustments = auto_deref_adjust_steps(&autoderef);
+                let adjustments = autoderef.adjust_steps();
                 let ty = self.process_remote_user_written_ty(ty);
 
                 (ty, field_id, adjustments, true)
             }
             None => {
                 let (field_id, subst) = private_field?;
-                let adjustments = auto_deref_adjust_steps(&autoderef);
+                let adjustments = autoderef.adjust_steps();
                 let ty = self.db.field_types(field_id.parent)[field_id.local_id]
                     .clone()
                     .substitute(Interner, &subst);
@@ -1725,11 +1824,13 @@ impl InferenceContext<'_> {
         expected: &Expectation,
     ) -> Ty {
         let callee_ty = self.infer_expr(callee, &Expectation::none(), ExprIsRead::Yes);
-        let mut derefs = Autoderef::new(&mut self.table, callee_ty.clone(), false, true);
+        let interner = self.table.interner;
+        let mut derefs = self.table.autoderef(callee_ty.to_nextsolver(interner));
         let (res, derefed_callee) = loop {
             let Some((callee_deref_ty, _)) = derefs.next() else {
                 break (None, callee_ty.clone());
             };
+            let callee_deref_ty = callee_deref_ty.to_chalk(interner);
             if let Some(res) = derefs.table.callable_sig(&callee_deref_ty, args.len()) {
                 break (Some(res), callee_deref_ty);
             }
@@ -1740,28 +1841,30 @@ impl InferenceContext<'_> {
             derefed_callee.callable_sig(self.db).is_some_and(|sig| sig.is_varargs) || res.is_none();
         let (param_tys, ret_ty) = match res {
             Some((func, params, ret_ty)) => {
-                let mut adjustments = auto_deref_adjust_steps(&derefs);
-                if let TyKind::Closure(c, _) =
-                    self.table.resolve_completely(callee_ty.clone()).kind(Interner)
-                {
-                    self.add_current_closure_dependency(*c);
-                    self.deferred_closures.entry(*c).or_default().push((
-                        derefed_callee.clone(),
-                        callee_ty.clone(),
-                        params.clone(),
-                        tgt_expr,
-                    ));
-                }
+                let params_chalk =
+                    params.iter().map(|param| param.to_chalk(interner)).collect::<Vec<_>>();
+                let mut adjustments = derefs.adjust_steps();
                 if let Some(fn_x) = func {
                     self.write_fn_trait_method_resolution(
                         fn_x,
                         &derefed_callee,
                         &mut adjustments,
                         &callee_ty,
-                        &params,
+                        &params_chalk,
                         tgt_expr,
                     );
                 }
+                if let &TyKind::Closure(c, _) =
+                    self.table.resolve_completely(callee_ty.clone()).kind(Interner)
+                {
+                    self.add_current_closure_dependency(c.into());
+                    self.deferred_closures.entry(c.into()).or_default().push((
+                        derefed_callee.clone(),
+                        callee_ty.clone(),
+                        params_chalk,
+                        tgt_expr,
+                    ));
+                }
                 self.write_expr_adj(callee, adjustments.into_boxed_slice());
                 (params, ret_ty)
             }
@@ -1770,7 +1873,7 @@ impl InferenceContext<'_> {
                     call_expr: tgt_expr,
                     found: callee_ty.clone(),
                 });
-                (Vec::new(), self.err_ty())
+                (Vec::new(), crate::next_solver::Ty::new_error(interner, ErrorGuaranteed))
             }
         };
         let indices_to_skip = self.check_legacy_const_generics(derefed_callee, args);
@@ -1791,29 +1894,24 @@ impl InferenceContext<'_> {
         tgt_expr: ExprId,
         args: &[ExprId],
         callee_ty: Ty,
-        param_tys: &[Ty],
-        ret_ty: Ty,
+        param_tys: &[crate::next_solver::Ty<'db>],
+        ret_ty: crate::next_solver::Ty<'db>,
         indices_to_skip: &[u32],
         is_varargs: bool,
         expected: &Expectation,
     ) -> Ty {
         self.register_obligations_for_call(&callee_ty);
 
-        let expected_inputs = self.expected_inputs_for_expected_output(
-            expected,
-            ret_ty.clone(),
-            param_tys.to_owned(),
-        );
-
         self.check_call_arguments(
             tgt_expr,
-            args,
-            &expected_inputs,
             param_tys,
+            ret_ty,
+            expected,
+            args,
             indices_to_skip,
             is_varargs,
         );
-        self.normalize_associated_types_in(ret_ty)
+        self.table.normalize_associated_types_in_ns(ret_ty).to_chalk(self.table.interner)
     }
 
     fn infer_method_call(
@@ -1826,6 +1924,21 @@ impl InferenceContext<'_> {
         expected: &Expectation,
     ) -> Ty {
         let receiver_ty = self.infer_expr_inner(receiver, &Expectation::none(), ExprIsRead::Yes);
+        let receiver_ty = self.table.structurally_resolve_type(&receiver_ty);
+
+        if matches!(
+            receiver_ty.kind(Interner),
+            TyKind::Error | TyKind::InferenceVar(_, TyVariableKind::General)
+        ) {
+            // Don't probe on error type, or on a fully unresolved infer var.
+            // FIXME: Emit an error if we're probing on an infer var (type annotations needed).
+            for &arg in args {
+                // Make sure we infer and record the arguments.
+                self.infer_expr_no_expect(arg, ExprIsRead::Yes);
+            }
+            return receiver_ty;
+        }
+
         let canonicalized_receiver =
             self.canonicalize(receiver_ty.clone().to_nextsolver(self.table.interner));
 
@@ -1918,14 +2031,21 @@ impl InferenceContext<'_> {
                         tgt_expr,
                         args,
                         callee_ty,
-                        sig.params().get(strip_first as usize..).unwrap_or(&[]),
-                        sig.ret().clone(),
+                        &sig.params()
+                            .get(strip_first as usize..)
+                            .unwrap_or(&[])
+                            .iter()
+                            .map(|param| param.to_nextsolver(self.table.interner))
+                            .collect::<Vec<_>>(),
+                        sig.ret().to_nextsolver(self.table.interner),
                         &[],
                         true,
                         expected,
                     ),
                     None => {
-                        self.check_call_arguments(tgt_expr, args, &[], &[], &[], true);
+                        for &arg in args.iter() {
+                            self.infer_expr_no_expect(arg, ExprIsRead::Yes);
+                        }
                         self.err_ty()
                     }
                 }
@@ -1944,151 +2064,252 @@ impl InferenceContext<'_> {
     ) -> Ty {
         let method_ty = method_ty.substitute(Interner, &substs);
         self.register_obligations_for_call(&method_ty);
+        let interner = self.table.interner;
         let ((formal_receiver_ty, param_tys), ret_ty, is_varargs) =
             match method_ty.callable_sig(self.db) {
                 Some(sig) => (
                     if !sig.params().is_empty() {
-                        (sig.params()[0].clone(), sig.params()[1..].to_vec())
+                        (
+                            sig.params()[0].to_nextsolver(interner),
+                            sig.params()[1..]
+                                .iter()
+                                .map(|param| param.to_nextsolver(interner))
+                                .collect(),
+                        )
                     } else {
-                        (self.err_ty(), Vec::new())
+                        (crate::next_solver::Ty::new_error(interner, ErrorGuaranteed), Vec::new())
                     },
-                    sig.ret().clone(),
+                    sig.ret().to_nextsolver(interner),
                     sig.is_varargs,
                 ),
                 None => {
-                    let formal_receiver_ty = self.table.new_type_var();
-                    let ret_ty = self.table.new_type_var();
+                    let formal_receiver_ty = self.table.next_ty_var();
+                    let ret_ty = self.table.next_ty_var();
                     ((formal_receiver_ty, Vec::new()), ret_ty, true)
                 }
             };
-        self.unify(&formal_receiver_ty, &receiver_ty);
-
-        let expected_inputs =
-            self.expected_inputs_for_expected_output(expected, ret_ty.clone(), param_tys.clone());
+        self.table.unify_ns(formal_receiver_ty, receiver_ty.to_nextsolver(interner));
 
-        self.check_call_arguments(tgt_expr, args, &expected_inputs, &param_tys, &[], is_varargs);
-        self.normalize_associated_types_in(ret_ty)
+        self.check_call_arguments(tgt_expr, &param_tys, ret_ty, expected, args, &[], is_varargs);
+        self.table.normalize_associated_types_in_ns(ret_ty).to_chalk(interner)
     }
 
-    fn expected_inputs_for_expected_output(
+    /// Generic function that factors out common logic from function calls,
+    /// method calls and overloaded operators.
+    pub(in super::super) fn check_call_arguments(
         &mut self,
-        expected_output: &Expectation,
-        output: Ty,
-        inputs: Vec<Ty>,
-    ) -> Vec<Ty> {
-        if let Some(expected_ty) = expected_output.only_has_type(&mut self.table) {
-            self.table.fudge_inference(|table| {
-                if table.try_unify(&expected_ty, &output).is_ok() {
-                    table.resolve_with_fallback(inputs, &|var, kind, _, _| match kind {
-                        chalk_ir::VariableKind::Ty(tk) => var.to_ty(Interner, tk).cast(Interner),
-                        chalk_ir::VariableKind::Lifetime => {
-                            var.to_lifetime(Interner).cast(Interner)
-                        }
-                        chalk_ir::VariableKind::Const(ty) => {
-                            var.to_const(Interner, ty).cast(Interner)
+        call_expr: ExprId,
+        // Types (as defined in the *signature* of the target function)
+        formal_input_tys: &[crate::next_solver::Ty<'db>],
+        formal_output: crate::next_solver::Ty<'db>,
+        // Expected output from the parent expression or statement
+        expectation: &Expectation,
+        // The expressions for each provided argument
+        provided_args: &[ExprId],
+        skip_indices: &[u32],
+        // Whether the function is variadic, for example when imported from C
+        c_variadic: bool,
+    ) {
+        let interner = self.table.interner;
+
+        // First, let's unify the formal method signature with the expectation eagerly.
+        // We use this to guide coercion inference; it's output is "fudged" which means
+        // any remaining type variables are assigned to new, unrelated variables. This
+        // is because the inference guidance here is only speculative.
+        let formal_output = self.table.resolve_vars_with_obligations(formal_output);
+        let expected_input_tys: Option<Vec<_>> = expectation
+            .only_has_type(&mut self.table)
+            .and_then(|expected_output| {
+                self.table
+                    .infer_ctxt
+                    .fudge_inference_if_ok(|| {
+                        let mut ocx = ObligationCtxt::new(&self.table.infer_ctxt);
+
+                        // Attempt to apply a subtyping relationship between the formal
+                        // return type (likely containing type variables if the function
+                        // is polymorphic) and the expected return type.
+                        // No argument expectations are produced if unification fails.
+                        let origin = ObligationCause::new();
+                        ocx.sup(
+                            &origin,
+                            self.table.param_env,
+                            expected_output.to_nextsolver(interner),
+                            formal_output,
+                        )?;
+                        if !ocx.select_where_possible().is_empty() {
+                            return Err(crate::next_solver::TypeError::Mismatch);
                         }
+
+                        // Record all the argument types, with the args
+                        // produced from the above subtyping unification.
+                        Ok(Some(
+                            formal_input_tys
+                                .iter()
+                                .map(|&ty| self.table.infer_ctxt.resolve_vars_if_possible(ty))
+                                .collect(),
+                        ))
                     })
-                } else {
-                    Vec::new()
-                }
+                    .ok()
             })
+            .unwrap_or_default();
+
+        // If there are no external expectations at the call site, just use the types from the function defn
+        let expected_input_tys = if let Some(expected_input_tys) = &expected_input_tys {
+            assert_eq!(expected_input_tys.len(), formal_input_tys.len());
+            expected_input_tys
         } else {
-            Vec::new()
-        }
-    }
+            formal_input_tys
+        };
 
-    fn check_call_arguments(
-        &mut self,
-        expr: ExprId,
-        args: &[ExprId],
-        expected_inputs: &[Ty],
-        param_tys: &[Ty],
-        skip_indices: &[u32],
-        ignore_arg_param_mismatch: bool,
-    ) {
-        let arg_count_mismatch =
-            !ignore_arg_param_mismatch && args.len() != param_tys.len() + skip_indices.len();
-        if arg_count_mismatch {
+        let minimum_input_count = expected_input_tys.len();
+        let provided_arg_count = provided_args.len() - skip_indices.len();
+
+        // Keep track of whether we *could possibly* be satisfied, i.e. whether we're on the happy path
+        // if the wrong number of arguments were supplied, we CAN'T be satisfied,
+        // and if we're c_variadic, the supplied arguments must be >= the minimum count from the function
+        // otherwise, they need to be identical, because rust doesn't currently support variadic functions
+        let args_count_matches = if c_variadic {
+            provided_arg_count >= minimum_input_count
+        } else {
+            provided_arg_count == minimum_input_count
+        };
+
+        if !args_count_matches {
             self.push_diagnostic(InferenceDiagnostic::MismatchedArgCount {
-                call_expr: expr,
-                expected: param_tys.len() + skip_indices.len(),
-                found: args.len(),
+                call_expr,
+                expected: expected_input_tys.len() + skip_indices.len(),
+                found: provided_args.len(),
             });
+        }
+
+        // We introduce a helper function to demand that a given argument satisfy a given input
+        // This is more complicated than just checking type equality, as arguments could be coerced
+        // This version writes those types back so further type checking uses the narrowed types
+        let demand_compatible = |this: &mut InferenceContext<'db>, idx| {
+            let formal_input_ty: crate::next_solver::Ty<'db> = formal_input_tys[idx];
+            let expected_input_ty: crate::next_solver::Ty<'db> = expected_input_tys[idx];
+            let provided_arg = provided_args[idx];
+
+            debug!("checking argument {}: {:?} = {:?}", idx, provided_arg, formal_input_ty);
+
+            // We're on the happy path here, so we'll do a more involved check and write back types
+            // To check compatibility, we'll do 3 things:
+            // 1. Unify the provided argument with the expected type
+            let expectation = Expectation::rvalue_hint(this, expected_input_ty.to_chalk(interner));
+
+            let checked_ty = this
+                .infer_expr_inner(provided_arg, &expectation, ExprIsRead::Yes)
+                .to_nextsolver(interner);
+
+            // 2. Coerce to the most detailed type that could be coerced
+            //    to, which is `expected_ty` if `rvalue_hint` returns an
+            //    `ExpectHasType(expected_ty)`, or the `formal_ty` otherwise.
+            let coerced_ty = expectation
+                .only_has_type(&mut this.table)
+                .map(|it| it.to_nextsolver(interner))
+                .unwrap_or(formal_input_ty);
+
+            // Cause selection errors caused by resolving a single argument to point at the
+            // argument and not the call. This lets us customize the span pointed to in the
+            // fulfillment error to be more accurate.
+            let coerced_ty = this.table.resolve_vars_with_obligations(coerced_ty);
+
+            let coerce_never = if this
+                .expr_guaranteed_to_constitute_read_for_never(provided_arg, ExprIsRead::Yes)
+            {
+                CoerceNever::Yes
+            } else {
+                CoerceNever::No
+            };
+            let coerce_error = this
+                .coerce(
+                    provided_arg.into(),
+                    checked_ty,
+                    coerced_ty,
+                    AllowTwoPhase::Yes,
+                    coerce_never,
+                )
+                .err();
+            if coerce_error.is_some() {
+                return Err((coerce_error, coerced_ty, checked_ty));
+            }
+
+            // 3. Check if the formal type is actually equal to the checked one
+            //    and register any such obligations for future type checks.
+            let formal_ty_error = this
+                .table
+                .infer_ctxt
+                .at(&ObligationCause::new(), this.table.param_env)
+                .eq(DefineOpaqueTypes::Yes, formal_input_ty, coerced_ty);
+
+            // If neither check failed, the types are compatible
+            match formal_ty_error {
+                Ok(crate::next_solver::infer::InferOk { obligations, value: () }) => {
+                    this.table.register_predicates(obligations);
+                    Ok(())
+                }
+                Err(err) => Err((Some(err), coerced_ty, checked_ty)),
+            }
         };
 
-        // Quoting https://github.com/rust-lang/rust/blob/6ef275e6c3cb1384ec78128eceeb4963ff788dca/src/librustc_typeck/check/mod.rs#L3325 --
+        // Check the arguments.
         // We do this in a pretty awful way: first we type-check any arguments
         // that are not closures, then we type-check the closures. This is so
         // that we have more information about the types of arguments when we
         // type-check the functions. This isn't really the right way to do this.
         for check_closures in [false, true] {
-            let mut skip_indices = skip_indices.iter().copied().fuse().peekable();
-            let param_iter = param_tys.iter().cloned().chain(repeat(self.err_ty()));
-            let expected_iter = expected_inputs
-                .iter()
-                .cloned()
-                .chain(param_iter.clone().skip(expected_inputs.len()));
-            for (idx, ((&arg, param_ty), expected_ty)) in
-                args.iter().zip(param_iter).zip(expected_iter).enumerate()
-            {
-                let is_closure = matches!(&self.body[arg], Expr::Closure { .. });
-                if is_closure != check_closures {
+            // More awful hacks: before we check argument types, try to do
+            // an "opportunistic" trait resolution of any trait bounds on
+            // the call. This helps coercions.
+            if check_closures {
+                self.table.select_obligations_where_possible();
+            }
+
+            let mut skip_indices = skip_indices.iter().copied();
+            // Check each argument, to satisfy the input it was provided for
+            // Visually, we're traveling down the diagonal of the compatibility matrix
+            for (idx, arg) in provided_args.iter().enumerate() {
+                if skip_indices.clone().next() == Some(idx as u32) {
+                    skip_indices.next();
                     continue;
                 }
 
-                while skip_indices.peek().is_some_and(|&i| i < idx as u32) {
-                    skip_indices.next();
+                // For this check, we do *not* want to treat async coroutine closures (async blocks)
+                // as proper closures. Doing so would regress type inference when feeding
+                // the return value of an argument-position async block to an argument-position
+                // closure wrapped in a block.
+                // See <https://github.com/rust-lang/rust/issues/112225>.
+                let is_closure = if let Expr::Closure { closure_kind, .. } = self.body[*arg] {
+                    !matches!(closure_kind, ClosureKind::Coroutine(_))
+                } else {
+                    false
+                };
+                if is_closure != check_closures {
+                    continue;
                 }
-                if skip_indices.peek().copied() == Some(idx as u32) {
+
+                if idx >= minimum_input_count {
+                    // Make sure we've checked this expr at least once.
+                    self.infer_expr_no_expect(*arg, ExprIsRead::Yes);
                     continue;
                 }
 
-                // the difference between param_ty and expected here is that
-                // expected is the parameter when the expected *return* type is
-                // taken into account. So in `let _: &[i32] = identity(&[1, 2])`
-                // the expected type is already `&[i32]`, whereas param_ty is
-                // still an unbound type variable. We don't always want to force
-                // the parameter to coerce to the expected type (for example in
-                // `coerce_unsize_expected_type_4`).
-                let param_ty = self.normalize_associated_types_in(param_ty);
-                let expected_ty = self.normalize_associated_types_in(expected_ty);
-                let expected = Expectation::rvalue_hint(self, expected_ty);
-                // infer with the expected type we have...
-                let ty = self.infer_expr_inner(arg, &expected, ExprIsRead::Yes);
-
-                // then coerce to either the expected type or just the formal parameter type
-                let coercion_target = if let Some(ty) = expected.only_has_type(&mut self.table) {
-                    // if we are coercing to the expectation, unify with the
-                    // formal parameter type to connect everything
-                    self.unify(&ty, &param_ty);
-                    ty
-                } else {
-                    param_ty
-                };
-                // The function signature may contain some unknown types, so we need to insert
-                // type vars here to avoid type mismatch false positive.
-                let coercion_target = self.insert_type_vars(coercion_target);
-
-                // Any expression that produces a value of type `!` must have diverged,
-                // unless it's a place expression that isn't being read from, in which case
-                // diverging would be unsound since we may never actually read the `!`.
-                // e.g. `let _ = *never_ptr;` with `never_ptr: *const !`.
-                let coerce_never =
-                    if self.expr_guaranteed_to_constitute_read_for_never(arg, ExprIsRead::Yes) {
-                        CoerceNever::Yes
-                    } else {
-                        CoerceNever::No
-                    };
-                if self.coerce(Some(arg), &ty, &coercion_target, coerce_never).is_err()
-                    && !arg_count_mismatch
+                if let Err((_error, expected, found)) = demand_compatible(self, idx)
+                    && args_count_matches
                 {
+                    // Don't report type mismatches if there is a mismatch in args count.
                     self.result.type_mismatches.insert(
-                        arg.into(),
-                        TypeMismatch { expected: coercion_target, actual: ty.clone() },
+                        (*arg).into(),
+                        TypeMismatch {
+                            expected: expected.to_chalk(interner),
+                            actual: found.to_chalk(interner),
+                        },
                     );
                 }
             }
         }
+
+        if !args_count_matches {}
     }
 
     fn substs_for_method_call(
@@ -2448,10 +2669,22 @@ impl InferenceContext<'_> {
         cb: impl FnOnce(&mut Self) -> T,
     ) -> (Option<Ty>, T) {
         self.breakables.push({
-            BreakableContext { kind, may_break: false, coerce: ty.map(CoerceMany::new), label }
+            BreakableContext {
+                kind,
+                may_break: false,
+                coerce: ty.map(|ty| CoerceMany::new(ty.to_nextsolver(self.table.interner))),
+                label,
+            }
         });
         let res = cb(self);
         let ctx = self.breakables.pop().expect("breakable stack broken");
-        (if ctx.may_break { ctx.coerce.map(|ctx| ctx.complete(self)) } else { None }, res)
+        (
+            if ctx.may_break {
+                ctx.coerce.map(|ctx| ctx.complete(self).to_chalk(self.table.interner))
+            } else {
+                None
+            },
+            res,
+        )
     }
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/pat.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/pat.rs
index 6781bc84d1c11..6e11fa942bdfb 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/pat.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/pat.rs
@@ -10,6 +10,8 @@ use hir_def::{
 use hir_expand::name::Name;
 use stdx::TupleExt;
 
+use crate::infer::AllowTwoPhase;
+use crate::next_solver::mapping::{ChalkToNextSolver, NextSolverToChalk};
 use crate::{
     DeclContext, DeclOrigin, InferenceDiagnostic, Interner, Mutability, Scalar, Substitution, Ty,
     TyBuilder, TyExt, TyKind,
@@ -303,16 +305,15 @@ impl InferenceContext<'_> {
             Pat::Path(path) => {
                 let ty = self.infer_path(path, pat.into()).unwrap_or_else(|| self.err_ty());
                 let ty_inserted_vars = self.insert_type_vars_shallow(ty.clone());
-                match self.table.coerce(&expected, &ty_inserted_vars, CoerceNever::Yes) {
-                    Ok((adjustments, coerced_ty)) => {
-                        if !adjustments.is_empty() {
-                            self.result
-                                .pat_adjustments
-                                .entry(pat)
-                                .or_default()
-                                .extend(adjustments.into_iter().map(|adjust| adjust.target));
-                        }
-                        self.write_pat_ty(pat, coerced_ty);
+                match self.coerce(
+                    pat.into(),
+                    expected.to_nextsolver(self.table.interner),
+                    ty_inserted_vars.to_nextsolver(self.table.interner),
+                    AllowTwoPhase::No,
+                    CoerceNever::Yes,
+                ) {
+                    Ok(coerced_ty) => {
+                        self.write_pat_ty(pat, coerced_ty.to_chalk(self.table.interner));
                         return self.pat_ty_after_adjustment(pat);
                     }
                     Err(_) => {
@@ -387,8 +388,14 @@ impl InferenceContext<'_> {
                 );
                 // We are returning early to avoid the unifiability check below.
                 let lhs_ty = self.insert_type_vars_shallow(result);
-                let ty = match self.coerce(None, &expected, &lhs_ty, CoerceNever::Yes) {
-                    Ok(ty) => ty,
+                let ty = match self.coerce(
+                    pat.into(),
+                    expected.to_nextsolver(self.table.interner),
+                    lhs_ty.to_nextsolver(self.table.interner),
+                    AllowTwoPhase::No,
+                    CoerceNever::Yes,
+                ) {
+                    Ok(ty) => ty.to_chalk(self.table.interner),
                     Err(_) => {
                         self.result.type_mismatches.insert(
                             pat.into(),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
index 19b83d3c212df..77eaf83eec73d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
@@ -1,6 +1,6 @@
 //! Unification and canonicalization logic.
 
-use std::{fmt, mem};
+use std::fmt;
 
 use chalk_ir::{
     CanonicalVarKind, FloatTy, IntTy, TyVariableKind, cast::Cast, fold::TypeFoldable,
@@ -11,31 +11,37 @@ use hir_def::{AdtId, lang_item::LangItem};
 use hir_expand::name::Name;
 use intern::sym;
 use rustc_hash::{FxHashMap, FxHashSet};
-use rustc_next_trait_solver::solve::HasChanged;
-use rustc_type_ir::inherent::IntoKind;
+use rustc_type_ir::inherent::Ty as _;
 use rustc_type_ir::{
-    AliasRelationDirection, FloatVid, IntVid, TyVid,
-    inherent::{Span, Term as _},
+    FloatVid, IntVid, TyVid, TypeVisitableExt,
+    inherent::{IntoKind, Span, Term as _},
     relate::{Relate, solver_relating::RelateExt},
-    solve::{Certainty, NoSolution},
+    solve::{Certainty, GoalSource, NoSolution},
 };
-use rustc_type_ir::{TypeSuperFoldable, TypeVisitableExt};
 use smallvec::SmallVec;
 use triomphe::Arc;
 
-use super::{InferOk, InferResult, InferenceContext, TypeError};
+use super::{InferResult, InferenceContext, TypeError};
+use crate::next_solver::ErrorGuaranteed;
 use crate::{
-    AliasEq, AliasTy, BoundVar, Canonical, Const, ConstValue, DebruijnIndex, DomainGoal,
-    GenericArg, GenericArgData, Goal, GoalData, InEnvironment, InferenceVar, Interner, Lifetime,
-    OpaqueTyId, ParamKind, ProjectionTy, ProjectionTyExt, Scalar, Substitution, TraitEnvironment,
-    TraitRef, Ty, TyBuilder, TyExt, TyKind, VariableKind, WhereClause,
+    AliasTy, BoundVar, Canonical, Const, ConstValue, DebruijnIndex, GenericArg, GenericArgData,
+    Goal, GoalData, InEnvironment, InferenceVar, Interner, Lifetime, OpaqueTyId, ParamKind,
+    ProjectionTy, Scalar, Substitution, TraitEnvironment, TraitRef, Ty, TyBuilder, TyExt, TyKind,
+    VariableKind, WhereClause,
     consteval::unknown_const,
     db::HirDatabase,
     fold_generic_args, fold_tys_and_consts,
+    next_solver::infer::InferOk,
     next_solver::{
-        self, Binder, DbInterner, Predicate, PredicateKind, SolverDefIds, Term,
-        infer::{DbInternerInferExt, InferCtxt, snapshot::CombinedSnapshot},
-        mapping::{ChalkToNextSolver, InferenceVarExt, NextSolverToChalk},
+        self, ClauseKind, DbInterner, ParamEnv, Predicate, PredicateKind, SolverDefIds, Term,
+        fulfill::FulfillmentCtxt,
+        infer::{
+            DbInternerInferExt, InferCtxt,
+            snapshot::CombinedSnapshot,
+            traits::{Obligation, ObligationCause},
+        },
+        inspect::{InspectConfig, InspectGoal, ProofTreeVisitor},
+        mapping::{ChalkToNextSolver, NextSolverToChalk},
     },
     to_chalk_trait_id,
     traits::{
@@ -50,43 +56,64 @@ impl<'db> InferenceContext<'db> {
     {
         self.table.canonicalize(t)
     }
+}
 
-    pub(super) fn clauses_for_self_ty(
-        &mut self,
-        self_ty: InferenceVar,
-    ) -> SmallVec<[WhereClause; 4]> {
-        self.table.resolve_obligations_as_possible();
-
-        let root = InferenceVar::from_vid(self.table.infer_ctxt.root_var(self_ty.to_vid()));
-        let pending_obligations = mem::take(&mut self.table.pending_obligations);
-        let obligations = pending_obligations
-            .iter()
-            .filter_map(|obligation| match obligation.to_chalk(self.table.interner).goal.data(Interner) {
-                GoalData::DomainGoal(DomainGoal::Holds(clause)) => {
-                    let ty = match clause {
-                        WhereClause::AliasEq(AliasEq {
-                            alias: AliasTy::Projection(projection),
-                            ..
-                        }) => projection.self_type_parameter(self.db),
-                        WhereClause::Implemented(trait_ref) => {
-                            trait_ref.self_type_parameter(Interner)
-                        }
-                        WhereClause::TypeOutlives(to) => to.ty.clone(),
-                        _ => return None,
-                    };
-                    let ty = self.resolve_ty_shallow(&ty);
-                    if matches!(ty.kind(Interner), TyKind::InferenceVar(iv, TyVariableKind::General) if *iv == root) {
-                        Some(clause.clone())
-                    } else {
-                        None
-                    }
-                }
-                _ => None,
-            })
-            .collect();
-        self.table.pending_obligations = pending_obligations;
+struct NestedObligationsForSelfTy<'a, 'db> {
+    ctx: &'a InferenceTable<'db>,
+    self_ty: TyVid,
+    root_cause: &'a ObligationCause,
+    obligations_for_self_ty: &'a mut SmallVec<[Obligation<'db, Predicate<'db>>; 4]>,
+}
 
-        obligations
+impl<'a, 'db> ProofTreeVisitor<'db> for NestedObligationsForSelfTy<'a, 'db> {
+    type Result = ();
+
+    fn config(&self) -> InspectConfig {
+        // Using an intentionally low depth to minimize the chance of future
+        // breaking changes in case we adapt the approach later on. This also
+        // avoids any hangs for exponentially growing proof trees.
+        InspectConfig { max_depth: 5 }
+    }
+
+    fn visit_goal(&mut self, inspect_goal: &InspectGoal<'_, 'db>) {
+        // No need to walk into goal subtrees that certainly hold, since they
+        // wouldn't then be stalled on an infer var.
+        if inspect_goal.result() == Ok(Certainty::Yes) {
+            return;
+        }
+
+        let db = self.ctx.interner;
+        let goal = inspect_goal.goal();
+        if self.ctx.predicate_has_self_ty(goal.predicate, self.self_ty)
+            // We do not push the instantiated forms of goals as it would cause any
+            // aliases referencing bound vars to go from having escaping bound vars to
+            // being able to be normalized to an inference variable.
+            //
+            // This is mostly just a hack as arbitrary nested goals could still contain
+            // such aliases while having a different `GoalSource`. Closure signature inference
+            // however can't really handle *every* higher ranked `Fn` goal also being present
+            // in the form of `?c: Fn<(<?x as Trait<'!a>>::Assoc)`.
+            //
+            // This also just better matches the behaviour of the old solver where we do not
+            // encounter instantiated forms of goals, only nested goals that referred to bound
+            // vars from instantiated goals.
+            && !matches!(inspect_goal.source(), GoalSource::InstantiateHigherRanked)
+        {
+            self.obligations_for_self_ty.push(Obligation::new(
+                db,
+                self.root_cause.clone(),
+                goal.param_env,
+                goal.predicate,
+            ));
+        }
+
+        // If there's a unique way to prove a given goal, recurse into
+        // that candidate. This means that for `impl<F: FnOnce(u32)> Trait<F> for () {}`
+        // and a `(): Trait<?0>` goal we recurse into the impl and look at
+        // the nested `?0: FnOnce(u32)` goal.
+        if let Some(candidate) = inspect_goal.unique_applicable_candidate() {
+            candidate.visit_nested_no_probe(self)
+        }
     }
 }
 
@@ -119,7 +146,7 @@ pub fn could_unify_deeply(
     let ty2_with_vars = vars.apply(tys.value.1.clone(), Interner);
     let ty1_with_vars = table.normalize_associated_types_in(ty1_with_vars);
     let ty2_with_vars = table.normalize_associated_types_in(ty2_with_vars);
-    table.resolve_obligations_as_possible();
+    table.select_obligations_where_possible();
     table.propagate_diverging_flag();
     let ty1_with_vars = table.resolve_completely(ty1_with_vars);
     let ty2_with_vars = table.resolve_completely(ty2_with_vars);
@@ -186,35 +213,117 @@ bitflags::bitflags! {
 }
 
 #[derive(Clone)]
-pub(crate) struct InferenceTable<'a> {
-    pub(crate) db: &'a dyn HirDatabase,
-    pub(crate) interner: DbInterner<'a>,
+pub(crate) struct InferenceTable<'db> {
+    pub(crate) db: &'db dyn HirDatabase,
+    pub(crate) interner: DbInterner<'db>,
     pub(crate) trait_env: Arc<TraitEnvironment>,
+    pub(crate) param_env: ParamEnv<'db>,
     pub(crate) tait_coercion_table: Option<FxHashMap<OpaqueTyId, Ty>>,
-    pub(crate) infer_ctxt: InferCtxt<'a>,
+    pub(crate) infer_ctxt: InferCtxt<'db>,
     diverging_tys: FxHashSet<Ty>,
-    pending_obligations: Vec<next_solver::Goal<'a, next_solver::Predicate<'a>>>,
+    pub(super) fulfillment_cx: FulfillmentCtxt<'db>,
 }
 
-pub(crate) struct InferenceTableSnapshot<'a> {
+pub(crate) struct InferenceTableSnapshot<'db> {
     ctxt_snapshot: CombinedSnapshot,
+    obligations: FulfillmentCtxt<'db>,
     diverging_tys: FxHashSet<Ty>,
-    pending_obligations: Vec<next_solver::Goal<'a, next_solver::Predicate<'a>>>,
 }
 
-impl<'a> InferenceTable<'a> {
-    pub(crate) fn new(db: &'a dyn HirDatabase, trait_env: Arc<TraitEnvironment>) -> Self {
+impl<'db> InferenceTable<'db> {
+    pub(crate) fn new(db: &'db dyn HirDatabase, trait_env: Arc<TraitEnvironment>) -> Self {
         let interner = DbInterner::new_with(db, Some(trait_env.krate), trait_env.block);
+        let infer_ctxt = interner.infer_ctxt().build(rustc_type_ir::TypingMode::Analysis {
+            defining_opaque_types_and_generators: SolverDefIds::new_from_iter(interner, []),
+        });
         InferenceTable {
             db,
             interner,
+            param_env: trait_env.env.to_nextsolver(interner),
             trait_env,
             tait_coercion_table: None,
-            infer_ctxt: interner.infer_ctxt().build(rustc_type_ir::TypingMode::Analysis {
-                defining_opaque_types_and_generators: SolverDefIds::new_from_iter(interner, []),
-            }),
+            fulfillment_cx: FulfillmentCtxt::new(&infer_ctxt),
+            infer_ctxt,
             diverging_tys: FxHashSet::default(),
-            pending_obligations: Vec::new(),
+        }
+    }
+
+    pub(crate) fn type_var_is_sized(&self, self_ty: TyVid) -> bool {
+        let Some(sized_did) = LangItem::Sized.resolve_trait(self.db, self.trait_env.krate) else {
+            return true;
+        };
+        self.obligations_for_self_ty(self_ty).into_iter().any(|obligation| {
+            match obligation.predicate.kind().skip_binder() {
+                crate::next_solver::PredicateKind::Clause(
+                    crate::next_solver::ClauseKind::Trait(data),
+                ) => data.def_id().0 == sized_did,
+                _ => false,
+            }
+        })
+    }
+
+    pub(super) fn obligations_for_self_ty(
+        &self,
+        self_ty: TyVid,
+    ) -> SmallVec<[Obligation<'db, Predicate<'db>>; 4]> {
+        let obligations = self.fulfillment_cx.pending_obligations();
+        let mut obligations_for_self_ty = SmallVec::new();
+        for obligation in obligations {
+            let mut visitor = NestedObligationsForSelfTy {
+                ctx: self,
+                self_ty,
+                obligations_for_self_ty: &mut obligations_for_self_ty,
+                root_cause: &obligation.cause,
+            };
+
+            let goal = obligation.as_goal();
+            self.infer_ctxt.visit_proof_tree(goal, &mut visitor);
+        }
+
+        obligations_for_self_ty.retain_mut(|obligation| {
+            obligation.predicate = self.infer_ctxt.resolve_vars_if_possible(obligation.predicate);
+            !obligation.predicate.has_placeholders()
+        });
+        obligations_for_self_ty
+    }
+
+    fn predicate_has_self_ty(&self, predicate: Predicate<'db>, expected_vid: TyVid) -> bool {
+        match predicate.kind().skip_binder() {
+            PredicateKind::Clause(ClauseKind::Trait(data)) => {
+                self.type_matches_expected_vid(expected_vid, data.self_ty())
+            }
+            PredicateKind::Clause(ClauseKind::Projection(data)) => {
+                self.type_matches_expected_vid(expected_vid, data.projection_term.self_ty())
+            }
+            PredicateKind::Clause(ClauseKind::ConstArgHasType(..))
+            | PredicateKind::Subtype(..)
+            | PredicateKind::Coerce(..)
+            | PredicateKind::Clause(ClauseKind::RegionOutlives(..))
+            | PredicateKind::Clause(ClauseKind::TypeOutlives(..))
+            | PredicateKind::Clause(ClauseKind::WellFormed(..))
+            | PredicateKind::DynCompatible(..)
+            | PredicateKind::NormalizesTo(..)
+            | PredicateKind::AliasRelate(..)
+            | PredicateKind::Clause(ClauseKind::ConstEvaluatable(..))
+            | PredicateKind::ConstEquate(..)
+            | PredicateKind::Clause(ClauseKind::HostEffect(..))
+            | PredicateKind::Clause(ClauseKind::UnstableFeature(_))
+            | PredicateKind::Ambiguous => false,
+        }
+    }
+
+    fn type_matches_expected_vid(
+        &self,
+        expected_vid: TyVid,
+        ty: crate::next_solver::Ty<'db>,
+    ) -> bool {
+        let ty = self.shallow_resolve(ty);
+
+        match ty.kind() {
+            crate::next_solver::TyKind::Infer(rustc_type_ir::TyVar(found_vid)) => {
+                self.infer_ctxt.root_var(expected_vid) == self.infer_ctxt.root_var(found_vid)
+            }
+            _ => false,
         }
     }
 
@@ -288,13 +397,13 @@ impl<'a> InferenceTable<'a> {
         .intern(Interner)
     }
 
-    pub(crate) fn canonicalize<T>(&mut self, t: T) -> rustc_type_ir::Canonical<DbInterner<'a>, T>
+    pub(crate) fn canonicalize<T>(&mut self, t: T) -> rustc_type_ir::Canonical<DbInterner<'db>, T>
     where
-        T: rustc_type_ir::TypeFoldable<DbInterner<'a>>,
+        T: rustc_type_ir::TypeFoldable<DbInterner<'db>>,
     {
         // try to resolve obligations before canonicalizing, since this might
         // result in new knowledge about variables
-        self.resolve_obligations_as_possible();
+        self.select_obligations_where_possible();
         self.infer_ctxt.canonicalize_response(t)
     }
 
@@ -306,19 +415,24 @@ impl<'a> InferenceTable<'a> {
     /// to do it as well.
     pub(crate) fn normalize_associated_types_in<T, U>(&mut self, ty: T) -> T
     where
-        T: ChalkToNextSolver<'a, U>,
-        U: NextSolverToChalk<'a, T> + rustc_type_ir::TypeFoldable<DbInterner<'a>>,
+        T: ChalkToNextSolver<'db, U>,
+        U: NextSolverToChalk<'db, T> + rustc_type_ir::TypeFoldable<DbInterner<'db>>,
     {
         self.normalize_associated_types_in_ns(ty.to_nextsolver(self.interner))
             .to_chalk(self.interner)
     }
 
+    // FIXME: We should get rid of this method. We cannot deeply normalize during inference, only when finishing.
+    // Inference should use shallow normalization (`try_structurally_resolve_type()`) only, when needed.
     pub(crate) fn normalize_associated_types_in_ns<T>(&mut self, ty: T) -> T
     where
-        T: rustc_type_ir::TypeFoldable<DbInterner<'a>>,
+        T: rustc_type_ir::TypeFoldable<DbInterner<'db>> + Clone,
     {
         let ty = self.resolve_vars_with_obligations(ty);
-        ty.fold_with(&mut Normalizer { table: self })
+        self.infer_ctxt
+            .at(&ObligationCause::new(), self.param_env)
+            .deeply_normalize(ty.clone())
+            .unwrap_or(ty)
     }
 
     /// Works almost same as [`Self::normalize_associated_types_in`], but this also resolves shallow
@@ -388,8 +502,8 @@ impl<'a> InferenceTable<'a> {
 
     pub(crate) fn normalize_alias_ty(
         &mut self,
-        alias: crate::next_solver::Ty<'a>,
-    ) -> crate::next_solver::Ty<'a> {
+        alias: crate::next_solver::Ty<'db>,
+    ) -> crate::next_solver::Ty<'db> {
         let infer_term = self.infer_ctxt.next_ty_var();
         let obligation = crate::next_solver::Predicate::new(
             self.interner,
@@ -430,6 +544,10 @@ impl<'a> InferenceTable<'a> {
         self.new_var(TyVariableKind::General, false)
     }
 
+    pub(crate) fn next_ty_var(&mut self) -> crate::next_solver::Ty<'db> {
+        self.infer_ctxt.next_ty_var()
+    }
+
     pub(crate) fn new_integer_var(&mut self) -> Ty {
         self.new_var(TyVariableKind::Integer, false)
     }
@@ -454,6 +572,10 @@ impl<'a> InferenceTable<'a> {
         var.to_lifetime(Interner)
     }
 
+    pub(crate) fn next_region_var(&mut self) -> crate::next_solver::Region<'db> {
+        self.infer_ctxt.next_region_var()
+    }
+
     pub(crate) fn resolve_with_fallback<T>(
         &mut self,
         t: T,
@@ -488,10 +610,10 @@ impl<'a> InferenceTable<'a> {
 
     pub(crate) fn instantiate_canonical_ns<T>(
         &mut self,
-        canonical: rustc_type_ir::Canonical<DbInterner<'a>, T>,
+        canonical: rustc_type_ir::Canonical<DbInterner<'db>, T>,
     ) -> T
     where
-        T: rustc_type_ir::TypeFoldable<DbInterner<'a>>,
+        T: rustc_type_ir::TypeFoldable<DbInterner<'db>>,
     {
         self.infer_ctxt.instantiate_canonical(&canonical).0
     }
@@ -513,8 +635,8 @@ impl<'a> InferenceTable<'a> {
 
     pub(crate) fn resolve_completely<T, U>(&mut self, t: T) -> T
     where
-        T: HasInterner<Interner = Interner> + TypeFoldable<Interner> + ChalkToNextSolver<'a, U>,
-        U: NextSolverToChalk<'a, T> + rustc_type_ir::TypeFoldable<DbInterner<'a>>,
+        T: HasInterner<Interner = Interner> + TypeFoldable<Interner> + ChalkToNextSolver<'db, U>,
+        U: NextSolverToChalk<'db, T> + rustc_type_ir::TypeFoldable<DbInterner<'db>>,
     {
         let t = self.resolve_with_fallback(t, &|_, _, d, _| d);
         let t = self.normalize_associated_types_in(t);
@@ -566,7 +688,7 @@ impl<'a> InferenceTable<'a> {
     }
 
     /// Unify two relatable values (e.g. `Ty`) and register new trait goals that arise from that.
-    pub(crate) fn unify<T: ChalkToNextSolver<'a, U>, U: Relate<DbInterner<'a>>>(
+    pub(crate) fn unify<T: ChalkToNextSolver<'db, U>, U: Relate<DbInterner<'db>>>(
         &mut self,
         ty1: &T,
         ty2: &T,
@@ -575,12 +697,20 @@ impl<'a> InferenceTable<'a> {
             Ok(r) => r,
             Err(_) => return false,
         };
-        self.register_infer_ok(result);
+        self.register_obligations(result.goals);
+        true
+    }
+
+    pub(crate) fn unify_ns<T: Relate<DbInterner<'db>>>(&mut self, lhs: T, rhs: T) -> bool {
+        let Ok(infer_ok) = self.try_unify_ns(lhs, rhs) else {
+            return false;
+        };
+        self.register_obligations(infer_ok.goals);
         true
     }
 
     /// Unify two relatable values (e.g. `Ty`) and check whether trait goals which arise from that could be fulfilled
-    pub(crate) fn unify_deeply<T: ChalkToNextSolver<'a, U>, U: Relate<DbInterner<'a>>>(
+    pub(crate) fn unify_deeply<T: ChalkToNextSolver<'db, U>, U: Relate<DbInterner<'db>>>(
         &mut self,
         ty1: &T,
         ty2: &T,
@@ -596,18 +726,27 @@ impl<'a> InferenceTable<'a> {
 
     /// Unify two relatable values (e.g. `Ty`) and return new trait goals arising from it, so the
     /// caller needs to deal with them.
-    pub(crate) fn try_unify<T: ChalkToNextSolver<'a, U>, U: Relate<DbInterner<'a>>>(
+    pub(crate) fn try_unify<T: ChalkToNextSolver<'db, U>, U: Relate<DbInterner<'db>>>(
         &mut self,
         t1: &T,
         t2: &T,
-    ) -> InferResult<'a, ()> {
-        let param_env = self.trait_env.env.to_nextsolver(self.interner);
+    ) -> InferResult<'db, ()> {
         let lhs = t1.to_nextsolver(self.interner);
         let rhs = t2.to_nextsolver(self.interner);
+        self.try_unify_ns(lhs, rhs)
+    }
+
+    /// Unify two relatable values (e.g. `Ty`) and return new trait goals arising from it, so the
+    /// caller needs to deal with them.
+    pub(crate) fn try_unify_ns<T: Relate<DbInterner<'db>>>(
+        &mut self,
+        lhs: T,
+        rhs: T,
+    ) -> InferResult<'db, ()> {
         let variance = rustc_type_ir::Variance::Invariant;
         let span = crate::next_solver::Span::dummy();
-        match self.infer_ctxt.relate(param_env, lhs, variance, rhs, span) {
-            Ok(goals) => Ok(InferOk { goals, value: () }),
+        match self.infer_ctxt.relate(self.param_env, lhs, variance, rhs, span) {
+            Ok(goals) => Ok(crate::infer::InferOk { goals, value: () }),
             Err(_) => Err(TypeError),
         }
     }
@@ -616,17 +755,19 @@ impl<'a> InferenceTable<'a> {
     /// otherwise, return ty.
     #[tracing::instrument(skip(self))]
     pub(crate) fn resolve_ty_shallow(&mut self, ty: &Ty) -> Ty {
-        if !ty.data(Interner).flags.intersects(chalk_ir::TypeFlags::HAS_FREE_LOCAL_NAMES) {
-            return ty.clone();
-        }
-        self.infer_ctxt
-            .resolve_vars_if_possible(ty.to_nextsolver(self.interner))
-            .to_chalk(self.interner)
+        self.shallow_resolve(ty.to_nextsolver(self.interner)).to_chalk(self.interner)
+    }
+
+    pub(crate) fn shallow_resolve(
+        &self,
+        ty: crate::next_solver::Ty<'db>,
+    ) -> crate::next_solver::Ty<'db> {
+        self.infer_ctxt.shallow_resolve(ty)
     }
 
     pub(crate) fn resolve_vars_with_obligations<T>(&mut self, t: T) -> T
     where
-        T: rustc_type_ir::TypeFoldable<DbInterner<'a>>,
+        T: rustc_type_ir::TypeFoldable<DbInterner<'db>>,
     {
         use rustc_type_ir::TypeVisitableExt;
 
@@ -640,7 +781,7 @@ impl<'a> InferenceTable<'a> {
             return t;
         }
 
-        self.resolve_obligations_as_possible();
+        self.select_obligations_where_possible();
         self.infer_ctxt.resolve_vars_if_possible(t)
     }
 
@@ -659,42 +800,58 @@ impl<'a> InferenceTable<'a> {
             .to_chalk(self.interner)
     }
 
-    fn structurally_normalize_term(&mut self, term: Term<'a>) -> Term<'a> {
-        if term.to_alias_term().is_none() {
-            return term;
-        }
-
-        let new_infer = self.infer_ctxt.next_term_var_of_kind(term);
+    fn structurally_normalize_term(&mut self, term: Term<'db>) -> Term<'db> {
+        self.infer_ctxt
+            .at(&ObligationCause::new(), self.param_env)
+            .structurally_normalize_term(term, &mut self.fulfillment_cx)
+            .unwrap_or(term)
+    }
 
-        self.register_obligation(Predicate::new(
-            self.interner,
-            Binder::dummy(PredicateKind::AliasRelate(
-                term,
-                new_infer,
-                AliasRelationDirection::Equate,
-            )),
-        ));
-        self.resolve_obligations_as_possible();
-        let res = self.infer_ctxt.resolve_vars_if_possible(new_infer);
-        if res == new_infer { term } else { res }
+    /// Try to resolve `ty` to a structural type, normalizing aliases.
+    ///
+    /// In case there is still ambiguity, the returned type may be an inference
+    /// variable. This is different from `structurally_resolve_type` which errors
+    /// in this case.
+    pub(crate) fn try_structurally_resolve_type(
+        &mut self,
+        ty: crate::next_solver::Ty<'db>,
+    ) -> crate::next_solver::Ty<'db> {
+        if let crate::next_solver::TyKind::Alias(..) = ty.kind() {
+            // We need to use a separate variable here as otherwise the temporary for
+            // `self.fulfillment_cx.borrow_mut()` is alive in the `Err` branch, resulting
+            // in a reentrant borrow, causing an ICE.
+            let result = self
+                .infer_ctxt
+                .at(&ObligationCause::misc(), self.param_env)
+                .structurally_normalize_ty(ty, &mut self.fulfillment_cx);
+            match result {
+                Ok(normalized_ty) => normalized_ty,
+                Err(_errors) => crate::next_solver::Ty::new_error(self.interner, ErrorGuaranteed),
+            }
+        } else {
+            self.resolve_vars_with_obligations(ty)
+        }
     }
 
-    pub(crate) fn snapshot(&mut self) -> InferenceTableSnapshot<'a> {
+    pub(crate) fn snapshot(&mut self) -> InferenceTableSnapshot<'db> {
         let ctxt_snapshot = self.infer_ctxt.start_snapshot();
         let diverging_tys = self.diverging_tys.clone();
-        let pending_obligations = self.pending_obligations.clone();
-        InferenceTableSnapshot { ctxt_snapshot, pending_obligations, diverging_tys }
+        let obligations = self.fulfillment_cx.clone();
+        InferenceTableSnapshot { ctxt_snapshot, diverging_tys, obligations }
     }
 
     #[tracing::instrument(skip_all)]
-    pub(crate) fn rollback_to(&mut self, snapshot: InferenceTableSnapshot<'a>) {
+    pub(crate) fn rollback_to(&mut self, snapshot: InferenceTableSnapshot<'db>) {
         self.infer_ctxt.rollback_to(snapshot.ctxt_snapshot);
         self.diverging_tys = snapshot.diverging_tys;
-        self.pending_obligations = snapshot.pending_obligations;
+        self.fulfillment_cx = snapshot.obligations;
     }
 
     #[tracing::instrument(skip_all)]
-    pub(crate) fn run_in_snapshot<T>(&mut self, f: impl FnOnce(&mut InferenceTable<'_>) -> T) -> T {
+    pub(crate) fn run_in_snapshot<T>(
+        &mut self,
+        f: impl FnOnce(&mut InferenceTable<'db>) -> T,
+    ) -> T {
         let snapshot = self.snapshot();
         let result = f(self);
         self.rollback_to(snapshot);
@@ -703,7 +860,7 @@ impl<'a> InferenceTable<'a> {
 
     pub(crate) fn commit_if_ok<T, E>(
         &mut self,
-        f: impl FnOnce(&mut InferenceTable<'_>) -> Result<T, E>,
+        f: impl FnOnce(&mut InferenceTable<'db>) -> Result<T, E>,
     ) -> Result<T, E> {
         let snapshot = self.snapshot();
         let result = f(self);
@@ -735,7 +892,7 @@ impl<'a> InferenceTable<'a> {
         result.map(|m| m.1)
     }
 
-    pub(crate) fn register_obligation(&mut self, predicate: Predicate<'a>) {
+    pub(crate) fn register_obligation(&mut self, predicate: Predicate<'db>) {
         let goal = next_solver::Goal {
             param_env: self.trait_env.env.to_nextsolver(self.interner),
             predicate,
@@ -746,7 +903,7 @@ impl<'a> InferenceTable<'a> {
     #[tracing::instrument(level = "debug", skip(self))]
     fn register_obligation_in_env(
         &mut self,
-        goal: next_solver::Goal<'a, next_solver::Predicate<'a>>,
+        goal: next_solver::Goal<'db, next_solver::Predicate<'db>>,
     ) {
         let result = next_trait_solve_in_ctxt(&self.infer_ctxt, goal);
         tracing::debug!(?result);
@@ -754,119 +911,68 @@ impl<'a> InferenceTable<'a> {
             Ok((_, Certainty::Yes)) => {}
             Err(rustc_type_ir::solve::NoSolution) => {}
             Ok((_, Certainty::Maybe(_))) => {
-                self.pending_obligations.push(goal);
+                self.fulfillment_cx.register_predicate_obligation(
+                    &self.infer_ctxt,
+                    Obligation::new(
+                        self.interner,
+                        ObligationCause::new(),
+                        goal.param_env,
+                        goal.predicate,
+                    ),
+                );
             }
         }
     }
 
-    pub(crate) fn register_infer_ok<T>(&mut self, infer_ok: InferOk<'a, T>) {
-        infer_ok.goals.into_iter().for_each(|goal| self.register_obligation_in_env(goal));
+    pub(crate) fn register_infer_ok<T>(&mut self, infer_ok: InferOk<'db, T>) -> T {
+        let InferOk { value, obligations } = infer_ok;
+        self.register_predicates(obligations);
+        value
     }
 
-    pub(crate) fn resolve_obligations_as_possible(&mut self) {
-        let _span = tracing::info_span!("resolve_obligations_as_possible").entered();
-        let mut changed = true;
-        while mem::take(&mut changed) {
-            let mut obligations = mem::take(&mut self.pending_obligations);
-
-            for goal in obligations.drain(..) {
-                tracing::debug!(obligation = ?goal);
-
-                let result = next_trait_solve_in_ctxt(&self.infer_ctxt, goal);
-                let (has_changed, certainty) = match result {
-                    Ok(result) => result,
-                    Err(_) => {
-                        continue;
-                    }
-                };
-
-                if matches!(has_changed, HasChanged::Yes) {
-                    changed = true;
-                }
+    pub(crate) fn register_obligations(
+        &mut self,
+        obligations: Vec<crate::next_solver::Goal<'db, crate::next_solver::Predicate<'db>>>,
+    ) {
+        obligations.into_iter().for_each(|goal| self.register_obligation_in_env(goal));
+    }
 
-                match certainty {
-                    Certainty::Yes => {}
-                    Certainty::Maybe(_) => self.pending_obligations.push(goal),
-                }
-            }
-        }
+    pub(crate) fn select_obligations_where_possible(&mut self) {
+        self.fulfillment_cx.select_where_possible(&self.infer_ctxt);
     }
 
-    pub(crate) fn fudge_inference<T: TypeFoldable<Interner>>(
+    pub(super) fn register_predicate(
         &mut self,
-        f: impl FnOnce(&mut Self) -> T,
-    ) -> T {
-        use chalk_ir::fold::TypeFolder;
-
-        #[derive(chalk_derive::FallibleTypeFolder)]
-        #[has_interner(Interner)]
-        struct VarFudger<'a, 'b> {
-            table: &'a mut InferenceTable<'b>,
-            highest_known_var: InferenceVar,
+        obligation: crate::next_solver::infer::traits::PredicateObligation<'db>,
+    ) {
+        if obligation.has_escaping_bound_vars() {
+            panic!("escaping bound vars in predicate {:?}", obligation);
         }
-        impl TypeFolder<Interner> for VarFudger<'_, '_> {
-            fn as_dyn(&mut self) -> &mut dyn TypeFolder<Interner> {
-                self
-            }
-
-            fn interner(&self) -> Interner {
-                Interner
-            }
-
-            fn fold_inference_ty(
-                &mut self,
-                var: chalk_ir::InferenceVar,
-                kind: TyVariableKind,
-                _outer_binder: chalk_ir::DebruijnIndex,
-            ) -> chalk_ir::Ty<Interner> {
-                if var < self.highest_known_var {
-                    var.to_ty(Interner, kind)
-                } else {
-                    self.table.new_type_var()
-                }
-            }
-
-            fn fold_inference_lifetime(
-                &mut self,
-                var: chalk_ir::InferenceVar,
-                _outer_binder: chalk_ir::DebruijnIndex,
-            ) -> chalk_ir::Lifetime<Interner> {
-                if var < self.highest_known_var {
-                    var.to_lifetime(Interner)
-                } else {
-                    self.table.new_lifetime_var()
-                }
-            }
 
-            fn fold_inference_const(
-                &mut self,
-                ty: chalk_ir::Ty<Interner>,
-                var: chalk_ir::InferenceVar,
-                _outer_binder: chalk_ir::DebruijnIndex,
-            ) -> chalk_ir::Const<Interner> {
-                if var < self.highest_known_var {
-                    var.to_const(Interner, ty)
-                } else {
-                    self.table.new_const_var(ty)
-                }
-            }
-        }
+        self.fulfillment_cx.register_predicate_obligation(&self.infer_ctxt, obligation);
+    }
 
-        let snapshot = self.snapshot();
-        let highest_known_var = self.new_type_var().inference_var(Interner).expect("inference_var");
-        let result = f(self);
-        self.rollback_to(snapshot);
-        result
-            .fold_with(&mut VarFudger { table: self, highest_known_var }, DebruijnIndex::INNERMOST)
+    pub(super) fn register_predicates<I>(&mut self, obligations: I)
+    where
+        I: IntoIterator<Item = crate::next_solver::infer::traits::PredicateObligation<'db>>,
+    {
+        obligations.into_iter().for_each(|obligation| {
+            self.register_predicate(obligation);
+        });
     }
 
     pub(crate) fn callable_sig(
         &mut self,
         ty: &Ty,
         num_args: usize,
-    ) -> Option<(Option<FnTrait>, Vec<Ty>, Ty)> {
+    ) -> Option<(Option<FnTrait>, Vec<crate::next_solver::Ty<'db>>, crate::next_solver::Ty<'db>)>
+    {
         match ty.callable_sig(self.db) {
-            Some(sig) => Some((None, sig.params().to_vec(), sig.ret().clone())),
+            Some(sig) => Some((
+                None,
+                sig.params().iter().map(|param| param.to_nextsolver(self.interner)).collect(),
+                sig.ret().to_nextsolver(self.interner),
+            )),
             None => {
                 let (f, args_ty, return_ty) = self.callable_sig_from_fn_trait(ty, num_args)?;
                 Some((Some(f), args_ty, return_ty))
@@ -878,7 +984,7 @@ impl<'a> InferenceTable<'a> {
         &mut self,
         ty: &Ty,
         num_args: usize,
-    ) -> Option<(FnTrait, Vec<Ty>, Ty)> {
+    ) -> Option<(FnTrait, Vec<crate::next_solver::Ty<'db>>, crate::next_solver::Ty<'db>)> {
         for (fn_trait_name, output_assoc_name, subtraits) in [
             (FnTrait::FnOnce, sym::Output, &[FnTrait::Fn, FnTrait::FnMut][..]),
             (FnTrait::AsyncFnMut, sym::CallRefFuture, &[FnTrait::AsyncFn]),
@@ -898,7 +1004,7 @@ impl<'a> InferenceTable<'a> {
                         ParamKind::Lifetime => unreachable!("Tuple with lifetime parameter"),
                         ParamKind::Const(_) => unreachable!("Tuple with const parameter"),
                     };
-                    arg_tys.push(arg.clone());
+                    arg_tys.push(arg.to_nextsolver(self.interner));
                     arg.cast(Interner)
                 })
                 .build();
@@ -920,7 +1026,8 @@ impl<'a> InferenceTable<'a> {
             let goal: Goal = trait_ref.clone().cast(Interner);
             if !self.try_obligation(goal.clone()).no_solution() {
                 self.register_obligation(goal.to_nextsolver(self.interner));
-                let return_ty = self.normalize_projection_ty(projection);
+                let return_ty =
+                    self.normalize_projection_ty(projection).to_nextsolver(self.interner);
                 for &fn_x in subtraits {
                     let fn_x_trait = fn_x.get_id(self.db, krate)?;
                     trait_ref.trait_id = to_chalk_trait_id(fn_x_trait);
@@ -969,8 +1076,8 @@ impl<'a> InferenceTable<'a> {
     /// Whenever you lower a user-written type, you should call this.
     pub(crate) fn process_user_written_ty<T, U>(&mut self, ty: T) -> T
     where
-        T: HasInterner<Interner = Interner> + TypeFoldable<Interner> + ChalkToNextSolver<'a, U>,
-        U: NextSolverToChalk<'a, T> + rustc_type_ir::TypeFoldable<DbInterner<'a>>,
+        T: HasInterner<Interner = Interner> + TypeFoldable<Interner> + ChalkToNextSolver<'db, U>,
+        U: NextSolverToChalk<'db, T> + rustc_type_ir::TypeFoldable<DbInterner<'db>>,
     {
         self.process_remote_user_written_ty(ty)
         // FIXME: Register a well-formed obligation.
@@ -980,13 +1087,14 @@ impl<'a> InferenceTable<'a> {
     /// while `process_user_written_ty()` should (but doesn't currently).
     pub(crate) fn process_remote_user_written_ty<T, U>(&mut self, ty: T) -> T
     where
-        T: HasInterner<Interner = Interner> + TypeFoldable<Interner> + ChalkToNextSolver<'a, U>,
-        U: NextSolverToChalk<'a, T> + rustc_type_ir::TypeFoldable<DbInterner<'a>>,
+        T: HasInterner<Interner = Interner> + TypeFoldable<Interner> + ChalkToNextSolver<'db, U>,
+        U: NextSolverToChalk<'db, T> + rustc_type_ir::TypeFoldable<DbInterner<'db>>,
     {
         let ty = self.insert_type_vars(ty);
         // See https://github.com/rust-lang/rust/blob/cdb45c87e2cd43495379f7e867e3cc15dcee9f93/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs#L487-L495:
         // Even though the new solver only lazily normalizes usually, here we eagerly normalize so that not everything needs
         // to normalize before inspecting the `TyKind`.
+        // FIXME(next-solver): We should not deeply normalize here, only shallowly.
         self.normalize_associated_types_in(ty)
     }
 
@@ -1074,7 +1182,10 @@ impl<'a> InferenceTable<'a> {
 
 impl fmt::Debug for InferenceTable<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("InferenceTable").finish()
+        f.debug_struct("InferenceTable")
+            .field("name", &self.infer_ctxt.inner.borrow().type_variable_storage)
+            .field("fulfillment_cx", &self.fulfillment_cx)
+            .finish()
     }
 }
 
@@ -1091,7 +1202,7 @@ mod resolve {
     };
     use rustc_type_ir::{FloatVid, IntVid, TyVid};
 
-    #[derive(Copy, Clone, PartialEq, Eq)]
+    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
     pub(super) enum VarKind {
         Ty(TyVariableKind),
         Const,
@@ -1264,62 +1375,3 @@ mod resolve {
         }
     }
 }
-
-/// This expects its input to be resolved.
-struct Normalizer<'a, 'b> {
-    table: &'a mut InferenceTable<'b>,
-}
-
-impl<'db> Normalizer<'_, 'db> {
-    fn normalize_alias_term(
-        &mut self,
-        alias_term: crate::next_solver::Term<'db>,
-    ) -> crate::next_solver::Term<'db> {
-        let infer_term = self.table.infer_ctxt.next_term_var_of_kind(alias_term);
-        let obligation = crate::next_solver::Predicate::new(
-            self.table.interner,
-            crate::next_solver::Binder::dummy(crate::next_solver::PredicateKind::AliasRelate(
-                alias_term,
-                infer_term,
-                rustc_type_ir::AliasRelationDirection::Equate,
-            )),
-        );
-        self.table.register_obligation(obligation);
-        let term = self.table.resolve_vars_with_obligations(infer_term);
-        // Now normalize the result, because maybe it contains more aliases.
-        match term {
-            Term::Ty(term) => term.super_fold_with(self).into(),
-            Term::Const(term) => term.super_fold_with(self).into(),
-        }
-    }
-}
-
-impl<'db> rustc_type_ir::TypeFolder<DbInterner<'db>> for Normalizer<'_, 'db> {
-    fn cx(&self) -> DbInterner<'db> {
-        self.table.interner
-    }
-
-    fn fold_ty(&mut self, ty: crate::next_solver::Ty<'db>) -> crate::next_solver::Ty<'db> {
-        if !ty.has_aliases() {
-            return ty;
-        }
-
-        let crate::next_solver::TyKind::Alias(..) = ty.kind() else {
-            return ty.super_fold_with(self);
-        };
-        // FIXME: Handle escaping bound vars by replacing them with placeholders (relevant to when we handle HRTB only).
-        self.normalize_alias_term(ty.into()).expect_type()
-    }
-
-    fn fold_const(&mut self, ct: crate::next_solver::Const<'db>) -> crate::next_solver::Const<'db> {
-        if !ct.has_aliases() {
-            return ct;
-        }
-
-        let crate::next_solver::ConstKind::Unevaluated(..) = ct.kind() else {
-            return ct.super_fold_with(self);
-        };
-        // FIXME: Handle escaping bound vars by replacing them with placeholders (relevant to when we handle HRTB only).
-        self.normalize_alias_term(ct.into()).expect_const()
-    }
-}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
index 2020a8b34b4f9..f21673c732e40 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
@@ -28,7 +28,6 @@ use crate::{
         DbInterner, GenericArgs, ParamEnv, Ty, TyKind, TypingMode,
         infer::{DbInternerInferExt, traits::ObligationCause},
         mapping::{ChalkToNextSolver, convert_args_for_result},
-        project::solve_normalize::deeply_normalize,
     },
 };
 
@@ -172,7 +171,7 @@ pub fn layout_of_ty_query<'db>(
     let cx = LayoutCx::new(dl);
     let infer_ctxt = interner.infer_ctxt().build(TypingMode::PostAnalysis);
     let cause = ObligationCause::dummy();
-    let ty = deeply_normalize(infer_ctxt.at(&cause, ParamEnv::empty()), ty).unwrap_or(ty);
+    let ty = infer_ctxt.at(&cause, ParamEnv::empty()).deeply_normalize(ty).unwrap_or(ty);
     let result = match ty.kind() {
         TyKind::Adt(def, args) => {
             match def.inner().id {
@@ -335,8 +334,8 @@ pub fn layout_of_ty_query<'db>(
                         .clone()
                         .substitute(
                             Interner,
-                            ClosureSubst(&convert_args_for_result(interner, args.inner()))
-                                .parent_subst(),
+                            &ClosureSubst(&convert_args_for_result(interner, args.inner()))
+                                .parent_subst(db),
                         )
                         .to_nextsolver(interner);
                     db.layout_of_ty(ty, trait_env.clone())
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 02fdbf0ebf0df..3d3cbeaf4b2d5 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
@@ -115,7 +115,7 @@ pub use infer::{
     Adjust, Adjustment, AutoBorrow, BindingMode, InferenceDiagnostic, InferenceResult,
     InferenceTyDiagnosticSource, OverloadedDeref, PointerCast,
     cast::CastError,
-    closure::{CaptureKind, CapturedItem},
+    closure::analysis::{CaptureKind, CapturedItem},
     could_coerce, could_unify, could_unify_deeply,
 };
 pub use interner::Interner;
@@ -133,8 +133,8 @@ pub use method_resolution::check_orphan_rules;
 pub use target_feature::TargetFeatures;
 pub use traits::TraitEnvironment;
 pub use utils::{
-    Unsafety, all_super_traits, direct_super_traits, is_fn_unsafe_to_call,
-    target_feature_is_safe_in_target,
+    TargetFeatureIsSafeInTarget, Unsafety, all_super_traits, direct_super_traits,
+    is_fn_unsafe_to_call, target_feature_is_safe_in_target,
 };
 pub use variance::Variance;
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
index 5c29befe123cf..2292e5c99413e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
@@ -17,6 +17,7 @@ use std::{
 
 use base_db::Crate;
 use either::Either;
+use hir_def::item_tree::FieldsShape;
 use hir_def::{
     AdtId, AssocItemId, CallableDefId, ConstParamId, EnumVariantId, FunctionId, GenericDefId,
     GenericParamId, ImplId, ItemContainerId, LocalFieldId, Lookup, StructId, TraitId, TypeAliasId,
@@ -34,6 +35,7 @@ use hir_def::{
         TraitRef as HirTraitRef, TypeBound, TypeRef, TypeRefId,
     },
 };
+use hir_def::{ConstId, StaticId};
 use hir_expand::name::Name;
 use intern::sym;
 use la_arena::{Arena, ArenaMap, Idx};
@@ -53,6 +55,7 @@ use smallvec::{SmallVec, smallvec};
 use stdx::never;
 use triomphe::Arc;
 
+use crate::ValueTyDefId;
 use crate::{
     FnAbi, ImplTraitId, Interner, ParamKind, TyDefId, TyLoweringDiagnostic,
     TyLoweringDiagnosticKind,
@@ -206,6 +209,10 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
         }
     }
 
+    pub(crate) fn set_lifetime_elision(&mut self, lifetime_elision: LifetimeElisionKind<'db>) {
+        self.lifetime_elision = lifetime_elision;
+    }
+
     pub(crate) fn with_debruijn<T>(
         &mut self,
         debruijn: DebruijnIndex,
@@ -958,6 +965,105 @@ pub(crate) fn ty_query<'db>(db: &'db dyn HirDatabase, def: TyDefId) -> EarlyBind
     }
 }
 
+/// Build the declared type of a function. This should not need to look at the
+/// function body.
+fn type_for_fn<'db>(db: &'db dyn HirDatabase, def: FunctionId) -> EarlyBinder<'db, Ty<'db>> {
+    let interner = DbInterner::new_with(db, None, None);
+    EarlyBinder::bind(Ty::new_fn_def(
+        interner,
+        CallableDefId::FunctionId(def).into(),
+        GenericArgs::identity_for_item(interner, def.into()),
+    ))
+}
+
+/// Build the declared type of a const.
+fn type_for_const<'db>(db: &'db dyn HirDatabase, def: ConstId) -> EarlyBinder<'db, Ty<'db>> {
+    let resolver = def.resolver(db);
+    let data = db.const_signature(def);
+    let parent = def.loc(db).container;
+    let mut ctx = TyLoweringContext::new(
+        db,
+        &resolver,
+        &data.store,
+        def.into(),
+        LifetimeElisionKind::AnonymousReportError,
+    );
+    ctx.set_lifetime_elision(LifetimeElisionKind::for_const(ctx.interner, parent));
+    EarlyBinder::bind(ctx.lower_ty(data.type_ref))
+}
+
+/// Build the declared type of a static.
+fn type_for_static<'db>(db: &'db dyn HirDatabase, def: StaticId) -> EarlyBinder<'db, Ty<'db>> {
+    let resolver = def.resolver(db);
+    let module = resolver.module();
+    let interner = DbInterner::new_with(db, Some(module.krate()), module.containing_block());
+    let data = db.static_signature(def);
+    let parent = def.loc(db).container;
+    let mut ctx = TyLoweringContext::new(
+        db,
+        &resolver,
+        &data.store,
+        def.into(),
+        LifetimeElisionKind::AnonymousReportError,
+    );
+    ctx.set_lifetime_elision(LifetimeElisionKind::Elided(Region::new_static(ctx.interner)));
+    EarlyBinder::bind(ctx.lower_ty(data.type_ref))
+}
+
+/// Build the type of a tuple struct constructor.
+fn type_for_struct_constructor<'db>(
+    db: &'db dyn HirDatabase,
+    def: StructId,
+) -> Option<EarlyBinder<'db, Ty<'db>>> {
+    let struct_data = def.fields(db);
+    match struct_data.shape {
+        FieldsShape::Record => None,
+        FieldsShape::Unit => Some(type_for_adt(db, def.into())),
+        FieldsShape::Tuple => {
+            let interner = DbInterner::new_with(db, None, None);
+            Some(EarlyBinder::bind(Ty::new_fn_def(
+                interner,
+                CallableDefId::StructId(def).into(),
+                GenericArgs::identity_for_item(interner, def.into()),
+            )))
+        }
+    }
+}
+
+/// Build the type of a tuple enum variant constructor.
+fn type_for_enum_variant_constructor<'db>(
+    db: &'db dyn HirDatabase,
+    def: EnumVariantId,
+) -> Option<EarlyBinder<'db, Ty<'db>>> {
+    let struct_data = def.fields(db);
+    match struct_data.shape {
+        FieldsShape::Record => None,
+        FieldsShape::Unit => Some(type_for_adt(db, def.loc(db).parent.into())),
+        FieldsShape::Tuple => {
+            let interner = DbInterner::new_with(db, None, None);
+            Some(EarlyBinder::bind(Ty::new_fn_def(
+                interner,
+                CallableDefId::EnumVariantId(def).into(),
+                GenericArgs::identity_for_item(interner, def.loc(db).parent.into()),
+            )))
+        }
+    }
+}
+
+pub(crate) fn value_ty_query<'db>(
+    db: &'db dyn HirDatabase,
+    def: ValueTyDefId,
+) -> Option<EarlyBinder<'db, Ty<'db>>> {
+    match def {
+        ValueTyDefId::FunctionId(it) => Some(type_for_fn(db, it)),
+        ValueTyDefId::StructId(it) => type_for_struct_constructor(db, it),
+        ValueTyDefId::UnionId(it) => Some(type_for_adt(db, it.into())),
+        ValueTyDefId::EnumVariantId(it) => type_for_enum_variant_constructor(db, it),
+        ValueTyDefId::ConstId(it) => Some(type_for_const(db, it)),
+        ValueTyDefId::StaticId(it) => Some(type_for_static(db, it)),
+    }
+}
+
 pub(crate) fn type_for_type_alias_with_diagnostics_query<'db>(
     db: &'db dyn HirDatabase,
     t: TypeAliasId,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
index ac85bf7950723..a4427517a10b8 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
@@ -24,7 +24,7 @@ use triomphe::Arc;
 use crate::{
     AdtId, Canonical, CanonicalVarKinds, DebruijnIndex, DynTyExt, ForeignDefId, GenericArgData,
     Goal, InEnvironment, Interner, Mutability, Scalar, Substitution, TraitEnvironment, TraitRef,
-    TraitRefExt, Ty, TyBuilder, TyExt, TyKind, TyVariableKind, VariableKind, WhereClause,
+    TraitRefExt, Ty, TyBuilder, TyExt, TyKind, VariableKind, WhereClause,
     autoderef::{self, AutoderefKind},
     db::HirDatabase,
     from_chalk_trait_id, from_foreign_def_id,
@@ -622,18 +622,23 @@ pub struct ReceiverAdjustments {
 }
 
 impl ReceiverAdjustments {
-    pub(crate) fn apply(&self, table: &mut InferenceTable<'_>, ty: Ty) -> (Ty, Vec<Adjustment>) {
-        let mut ty = table.structurally_resolve_type(&ty);
+    pub(crate) fn apply(
+        &self,
+        table: &mut InferenceTable<'_>,
+        mut ty: Ty,
+    ) -> (Ty, Vec<Adjustment>) {
         let mut adjust = Vec::new();
+        let mut autoderef = table.autoderef(ty.to_nextsolver(table.interner));
+        autoderef.next();
         for _ in 0..self.autoderefs {
-            match autoderef::autoderef_step(table, ty.clone(), true, false) {
+            match autoderef.next() {
                 None => {
                     never!("autoderef not possible for {:?}", ty);
                     ty = TyKind::Error.intern(Interner);
                     break;
                 }
-                Some((kind, new_ty)) => {
-                    ty = new_ty.clone();
+                Some((new_ty, _)) => {
+                    ty = new_ty.to_chalk(autoderef.table.interner);
                     let mutbl = match self.autoref {
                         Some(AutorefOrPtrAdjustment::Autoref(m)) => Some(m),
                         Some(AutorefOrPtrAdjustment::ToConstPtr) => Some(Mutability::Not),
@@ -641,11 +646,11 @@ impl ReceiverAdjustments {
                         None => None,
                     };
                     adjust.push(Adjustment {
-                        kind: Adjust::Deref(match kind {
+                        kind: Adjust::Deref(match autoderef.steps().last().unwrap().1 {
                             AutoderefKind::Overloaded => Some(OverloadedDeref(mutbl)),
                             AutoderefKind::Builtin => None,
                         }),
-                        target: new_ty,
+                        target: ty.clone(),
                     });
                 }
             }
@@ -1282,17 +1287,20 @@ fn iterate_method_candidates_by_receiver<'db>(
     name: Option<&Name>,
     callback: &mut dyn MethodCandidateCallback,
 ) -> ControlFlow<()> {
+    let interner = table.interner;
     let receiver_ty = table.instantiate_canonical_ns(receiver_ty);
-    let receiver_ty: crate::Ty = receiver_ty.to_chalk(table.interner);
+    let receiver_ty: crate::Ty = receiver_ty.to_chalk(interner);
     // We're looking for methods with *receiver* type receiver_ty. These could
     // be found in any of the derefs of receiver_ty, so we have to go through
     // that, including raw derefs.
     table.run_in_snapshot(|table| {
         let mut autoderef =
-            autoderef::Autoderef::new_no_tracking(table, receiver_ty.clone(), true, true);
+            autoderef::Autoderef::new_no_tracking(table, receiver_ty.to_nextsolver(interner))
+                .include_raw_pointers()
+                .use_receiver_trait();
         while let Some((self_ty, _)) = autoderef.next() {
             iterate_inherent_methods(
-                &self_ty,
+                &self_ty.to_chalk(interner),
                 autoderef.table,
                 name,
                 Some(&receiver_ty),
@@ -1308,15 +1316,18 @@ fn iterate_method_candidates_by_receiver<'db>(
     })?;
     table.run_in_snapshot(|table| {
         let mut autoderef =
-            autoderef::Autoderef::new_no_tracking(table, receiver_ty.clone(), true, true);
+            autoderef::Autoderef::new_no_tracking(table, receiver_ty.to_nextsolver(interner))
+                .include_raw_pointers()
+                .use_receiver_trait();
         while let Some((self_ty, _)) = autoderef.next() {
-            if matches!(self_ty.kind(Interner), TyKind::InferenceVar(_, TyVariableKind::General)) {
+            if matches!(self_ty.kind(), crate::next_solver::TyKind::Infer(rustc_type_ir::TyVar(_)))
+            {
                 // don't try to resolve methods on unknown types
                 return ControlFlow::Continue(());
             }
 
             iterate_trait_method_candidates(
-                &self_ty,
+                &self_ty.to_chalk(interner),
                 autoderef.table,
                 traits_in_scope,
                 name,
@@ -1760,7 +1771,8 @@ fn is_valid_trait_method_candidate(
                         for pred in infer_ok.into_obligations() {
                             ctxt.register_predicate_obligation(&table.infer_ctxt, pred);
                         }
-                        check_that!(ctxt.select_all_or_error(&table.infer_ctxt).is_empty());
+                        // FIXME: Are we doing this correctly? Probably better to follow rustc more closely.
+                        check_that!(ctxt.select_where_possible(&table.infer_ctxt).is_empty());
                     }
 
                     check_that!(table.unify(receiver_ty, &expected_receiver));
@@ -1937,11 +1949,10 @@ fn autoderef_method_receiver<'db>(
 ) -> Vec<(next_solver::Canonical<'db, crate::next_solver::Ty<'db>>, ReceiverAdjustments)> {
     let interner = table.interner;
     let mut deref_chain = Vec::new();
-    let mut autoderef =
-        autoderef::Autoderef::new_no_tracking(table, ty.to_chalk(interner), false, true);
+    let mut autoderef = autoderef::Autoderef::new_no_tracking(table, ty).use_receiver_trait();
     while let Some((ty, derefs)) = autoderef.next() {
         deref_chain.push((
-            autoderef.table.canonicalize(ty.to_nextsolver(interner)),
+            autoderef.table.canonicalize(ty),
             ReceiverAdjustments { autoref: None, autoderefs: derefs, unsize_array: false },
         ));
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/borrowck.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/borrowck.rs
index 52df851c30d13..2c09fb9a89e78 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/borrowck.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/borrowck.rs
@@ -113,8 +113,13 @@ fn make_fetch_closure_field(
         let InternedClosure(def, _) = db.lookup_intern_closure(c.into());
         let infer = db.infer(def);
         let (captures, _) = infer.closure_info(&c);
-        let parent_subst = ClosureSubst(subst).parent_subst();
-        captures.get(f).expect("broken closure field").ty.clone().substitute(Interner, parent_subst)
+        let parent_subst = ClosureSubst(subst).parent_subst(db);
+        captures
+            .get(f)
+            .expect("broken closure field")
+            .ty
+            .clone()
+            .substitute(Interner, &parent_subst)
     }
 }
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
index cddd1fb7be526..6f950b8022c98 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
@@ -712,13 +712,13 @@ impl<'db> Evaluator<'db> {
                 let InternedClosure(def, _) = self.db.lookup_intern_closure(c.into());
                 let infer = self.db.infer(def);
                 let (captures, _) = infer.closure_info(&c);
-                let parent_subst = ClosureSubst(subst).parent_subst();
+                let parent_subst = ClosureSubst(subst).parent_subst(self.db);
                 captures
                     .get(f)
                     .expect("broken closure field")
                     .ty
                     .clone()
-                    .substitute(Interner, parent_subst)
+                    .substitute(Interner, &parent_subst)
             },
             self.crate_id,
         );
@@ -2772,7 +2772,7 @@ impl<'db> Evaluator<'db> {
             TyKind::Closure(closure, subst) => self.exec_closure(
                 *closure,
                 func_data,
-                &Substitution::from_iter(Interner, ClosureSubst(subst).parent_subst()),
+                &ClosureSubst(subst).parent_subst(self.db),
                 destination,
                 &args[1..],
                 locals,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs
index e27d334d2a991..f67778b0f12f3 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs
@@ -4,6 +4,7 @@
 use std::cmp::{self, Ordering};
 
 use chalk_ir::TyKind;
+use hir_def::signatures::FunctionSignature;
 use hir_def::{
     CrateRootModuleId,
     builtin_type::{BuiltinInt, BuiltinUint},
@@ -63,17 +64,7 @@ impl Evaluator<'_> {
 
         let function_data = self.db.function_signature(def);
         let attrs = self.db.attrs(def.into());
-        let is_intrinsic = attrs.by_key(sym::rustc_intrinsic).exists()
-            // Keep this around for a bit until extern "rustc-intrinsic" abis are no longer used
-            || (match &function_data.abi {
-                Some(abi) => *abi == sym::rust_dash_intrinsic,
-                None => match def.lookup(self.db).container {
-                    hir_def::ItemContainerId::ExternBlockId(block) => {
-                        block.abi(self.db) == Some(sym::rust_dash_intrinsic)
-                    }
-                    _ => false,
-                },
-            });
+        let is_intrinsic = FunctionSignature::is_intrinsic(self.db, def);
 
         if is_intrinsic {
             return self.exec_intrinsic(
@@ -194,7 +185,7 @@ impl Evaluator<'_> {
                 let infer = self.db.infer(closure_owner);
                 let (captures, _) = infer.closure_info(id);
                 let layout = self.layout(self_ty.to_nextsolver(interner))?;
-                let ty_iter = captures.iter().map(|c| c.ty(subst));
+                let ty_iter = captures.iter().map(|c| c.ty(self.db, subst));
                 self.exec_clone_for_fields(ty_iter, layout, addr, def, locals, destination, span)?;
             }
             TyKind::Tuple(_, subst) => {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/tests.rs
index 5a56d99fbaa29..2a6e3a147a7d7 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/tests.rs
@@ -12,34 +12,37 @@ use crate::{
 use super::{MirEvalError, interpret_mir};
 
 fn eval_main(db: &TestDB, file_id: EditionedFileId) -> Result<(String, String), MirEvalError> {
-    let module_id = db.module_for_file(file_id.file_id(db));
-    let def_map = module_id.def_map(db);
-    let scope = &def_map[module_id.local_id].scope;
-    let func_id = scope
-        .declarations()
-        .find_map(|x| match x {
-            hir_def::ModuleDefId::FunctionId(x) => {
-                if db.function_signature(x).name.display(db, Edition::CURRENT).to_string() == "main"
-                {
-                    Some(x)
-                } else {
-                    None
+    salsa::attach(db, || {
+        let module_id = db.module_for_file(file_id.file_id(db));
+        let def_map = module_id.def_map(db);
+        let scope = &def_map[module_id.local_id].scope;
+        let func_id = scope
+            .declarations()
+            .find_map(|x| match x {
+                hir_def::ModuleDefId::FunctionId(x) => {
+                    if db.function_signature(x).name.display(db, Edition::CURRENT).to_string()
+                        == "main"
+                    {
+                        Some(x)
+                    } else {
+                        None
+                    }
                 }
-            }
-            _ => None,
-        })
-        .expect("no main function found");
-    let body = db
-        .monomorphized_mir_body(
-            func_id.into(),
-            Substitution::empty(Interner),
-            db.trait_environment(func_id.into()),
-        )
-        .map_err(|e| MirEvalError::MirLowerError(func_id, e))?;
-
-    let (result, output) = salsa::attach(db, || interpret_mir(db, body, false, None))?;
-    result?;
-    Ok((output.stdout().into_owned(), output.stderr().into_owned()))
+                _ => None,
+            })
+            .expect("no main function found");
+        let body = db
+            .monomorphized_mir_body(
+                func_id.into(),
+                Substitution::empty(Interner),
+                db.trait_environment(func_id.into()),
+            )
+            .map_err(|e| MirEvalError::MirLowerError(func_id, e))?;
+
+        let (result, output) = interpret_mir(db, body, false, None)?;
+        result?;
+        Ok((output.stdout().into_owned(), output.stderr().into_owned()))
+    })
 }
 
 fn check_pass(#[rust_analyzer::rust_fixture] ra_fixture: &str) {
@@ -53,43 +56,60 @@ fn check_pass_and_stdio(
 ) {
     let _tracing = setup_tracing();
     let (db, file_ids) = TestDB::with_many_files(ra_fixture);
-    let file_id = *file_ids.last().unwrap();
-    let x = eval_main(&db, file_id);
-    match x {
-        Err(e) => {
-            let mut err = String::new();
-            let line_index = |size: TextSize| {
-                let mut size = u32::from(size) as usize;
-                let lines = ra_fixture.lines().enumerate();
-                for (i, l) in lines {
-                    if let Some(x) = size.checked_sub(l.len()) {
-                        size = x;
-                    } else {
-                        return (i, size);
+    salsa::attach(&db, || {
+        let file_id = *file_ids.last().unwrap();
+        let x = eval_main(&db, file_id);
+        match x {
+            Err(e) => {
+                let mut err = String::new();
+                let line_index = |size: TextSize| {
+                    let mut size = u32::from(size) as usize;
+                    let lines = ra_fixture.lines().enumerate();
+                    for (i, l) in lines {
+                        if let Some(x) = size.checked_sub(l.len()) {
+                            size = x;
+                        } else {
+                            return (i, size);
+                        }
                     }
-                }
-                (usize::MAX, size)
-            };
-            let span_formatter = |file, range: TextRange| {
-                format!("{:?} {:?}..{:?}", file, line_index(range.start()), line_index(range.end()))
-            };
-            let krate = db.module_for_file(file_id.file_id(&db)).krate();
-            e.pretty_print(&mut err, &db, span_formatter, DisplayTarget::from_crate(&db, krate))
+                    (usize::MAX, size)
+                };
+                let span_formatter = |file, range: TextRange| {
+                    format!(
+                        "{:?} {:?}..{:?}",
+                        file,
+                        line_index(range.start()),
+                        line_index(range.end())
+                    )
+                };
+                let krate = db.module_for_file(file_id.file_id(&db)).krate();
+                e.pretty_print(
+                    &mut err,
+                    &db,
+                    span_formatter,
+                    DisplayTarget::from_crate(&db, krate),
+                )
                 .unwrap();
-            panic!("Error in interpreting: {err}");
-        }
-        Ok((stdout, stderr)) => {
-            assert_eq!(stdout, expected_stdout);
-            assert_eq!(stderr, expected_stderr);
+                panic!("Error in interpreting: {err}");
+            }
+            Ok((stdout, stderr)) => {
+                assert_eq!(stdout, expected_stdout);
+                assert_eq!(stderr, expected_stderr);
+            }
         }
-    }
+    })
 }
 
 fn check_panic(#[rust_analyzer::rust_fixture] ra_fixture: &str, expected_panic: &str) {
     let (db, file_ids) = TestDB::with_many_files(ra_fixture);
-    let file_id = *file_ids.last().unwrap();
-    let e = eval_main(&db, file_id).unwrap_err();
-    assert_eq!(e.is_panic().unwrap_or_else(|| panic!("unexpected error: {e:?}")), expected_panic);
+    salsa::attach(&db, || {
+        let file_id = *file_ids.last().unwrap();
+        let e = eval_main(&db, file_id).unwrap_err();
+        assert_eq!(
+            e.is_panic().unwrap_or_else(|| panic!("unexpected error: {e:?}")),
+            expected_panic
+        );
+    })
 }
 
 fn check_error_with(
@@ -97,9 +117,11 @@ fn check_error_with(
     expect_err: impl FnOnce(MirEvalError) -> bool,
 ) {
     let (db, file_ids) = TestDB::with_many_files(ra_fixture);
-    let file_id = *file_ids.last().unwrap();
-    let e = eval_main(&db, file_id).unwrap_err();
-    assert!(expect_err(e));
+    salsa::attach(&db, || {
+        let file_id = *file_ids.last().unwrap();
+        let e = eval_main(&db, file_id).unwrap_err();
+        assert!(expect_err(e));
+    })
 }
 
 #[test]
@@ -492,7 +514,7 @@ fn main() {
 fn from_fn() {
     check_pass(
         r#"
-//- minicore: fn, iterator
+//- minicore: fn, iterator, sized
 struct FromFn<F>(F);
 
 impl<T, F: FnMut() -> Option<T>> Iterator for FromFn<F> {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
index 45a1131e33399..50e416a66a64b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
@@ -2065,7 +2065,7 @@ pub fn mir_body_for_closure_query(
         },
     });
     ctx.result.param_locals.push(closure_local);
-    let Some(sig) = ClosureSubst(substs).sig_ty().callable_sig(db) else {
+    let Some(sig) = ClosureSubst(substs).sig_ty(db).callable_sig(db) else {
         implementation_error!("closure has not callable sig");
     };
     let resolver_guard = ctx.resolver.update_to_inner_scope(db, owner, expr);
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver.rs
index 0225deebe4f31..34d8b649c981b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver.rs
@@ -9,14 +9,17 @@ pub mod fulfill;
 mod generic_arg;
 pub mod generics;
 pub mod infer;
+pub(crate) mod inspect;
 pub mod interner;
 mod ir_print;
 pub mod mapping;
+mod normalize;
+pub mod obligation_ctxt;
 mod opaques;
 pub mod predicate;
-pub(crate) mod project;
 mod region;
 mod solver;
+mod structural_normalize;
 mod ty;
 pub mod util;
 
@@ -37,8 +40,11 @@ pub type CanonicalVarValues<'db> = rustc_type_ir::CanonicalVarValues<DbInterner<
 pub type CanonicalVarKind<'db> = rustc_type_ir::CanonicalVarKind<DbInterner<'db>>;
 pub type CanonicalQueryInput<'db, V> = rustc_type_ir::CanonicalQueryInput<DbInterner<'db>, V>;
 pub type AliasTy<'db> = rustc_type_ir::AliasTy<DbInterner<'db>>;
+pub type FnSig<'db> = rustc_type_ir::FnSig<DbInterner<'db>>;
 pub type PolyFnSig<'db> = Binder<'db, rustc_type_ir::FnSig<DbInterner<'db>>>;
 pub type TypingMode<'db> = rustc_type_ir::TypingMode<DbInterner<'db>>;
+pub type TypeError<'db> = rustc_type_ir::error::TypeError<DbInterner<'db>>;
+pub type QueryResult<'db> = rustc_type_ir::solve::QueryResult<DbInterner<'db>>;
 
 pub type FxIndexMap<K, V> =
     indexmap::IndexMap<K, V, std::hash::BuildHasherDefault<rustc_hash::FxHasher>>;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs
index 23789b06e828b..0b3582051bc07 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs
@@ -4,16 +4,19 @@ use std::hash::Hash;
 
 use hir_def::{ConstParamId, TypeOrConstParamId};
 use intern::{Interned, Symbol};
-use rustc_ast_ir::try_visit;
-use rustc_ast_ir::visit::VisitorResult;
+use rustc_ast_ir::{try_visit, visit::VisitorResult};
 use rustc_type_ir::{
     BoundVar, FlagComputation, Flags, TypeFoldable, TypeSuperFoldable, TypeSuperVisitable,
-    TypeVisitable, WithCachedTypeInfo,
-    inherent::{IntoKind, PlaceholderLike},
+    TypeVisitable, TypeVisitableExt, WithCachedTypeInfo,
+    inherent::{IntoKind, ParamEnv as _, PlaceholderLike, SliceLike},
     relate::Relate,
 };
 
-use crate::{ConstScalar, MemoryMap, interner::InternedWrapperNoDebug};
+use crate::{
+    ConstScalar, MemoryMap,
+    interner::InternedWrapperNoDebug,
+    next_solver::{ClauseKind, ParamEnv},
+};
 
 use super::{BoundVarKind, DbInterner, ErrorGuaranteed, GenericArgs, Placeholder, Ty};
 
@@ -96,6 +99,40 @@ impl std::fmt::Debug for ParamConst {
     }
 }
 
+impl ParamConst {
+    pub fn find_const_ty_from_env<'db>(self, env: ParamEnv<'db>) -> Ty<'db> {
+        let mut candidates = env.caller_bounds().iter().filter_map(|clause| {
+            // `ConstArgHasType` are never desugared to be higher ranked.
+            match clause.kind().skip_binder() {
+                ClauseKind::ConstArgHasType(param_ct, ty) => {
+                    assert!(!(param_ct, ty).has_escaping_bound_vars());
+
+                    match param_ct.kind() {
+                        ConstKind::Param(param_ct) if param_ct.index == self.index => Some(ty),
+                        _ => None,
+                    }
+                }
+                _ => None,
+            }
+        });
+
+        // N.B. it may be tempting to fix ICEs by making this function return
+        // `Option<Ty<'db>>` instead of `Ty<'db>`; however, this is generally
+        // considered to be a bandaid solution, since it hides more important
+        // underlying issues with how we construct generics and predicates of
+        // items. It's advised to fix the underlying issue rather than trying
+        // to modify this function.
+        let ty = candidates.next().unwrap_or_else(|| {
+            panic!("cannot find `{self:?}` in param-env: {env:#?}");
+        });
+        assert!(
+            candidates.next().is_none(),
+            "did not expect duplicate `ConstParamHasTy` for `{self:?}` in param-env: {env:#?}"
+        );
+        ty
+    }
+}
+
 /// A type-level constant value.
 ///
 /// Represents a typed, fully evaluated constant.
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
index a9c572d3f34ee..1ae59beca2728 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/def_id.rs
@@ -17,7 +17,7 @@ pub enum Ctor {
     Enum(EnumVariantId),
 }
 
-#[derive(Debug, PartialOrd, Ord, Clone, Copy, PartialEq, Eq, Hash, salsa::Supertype)]
+#[derive(PartialOrd, Ord, Clone, Copy, PartialEq, Eq, Hash, salsa::Supertype)]
 pub enum SolverDefId {
     AdtId(AdtId),
     ConstId(ConstId),
@@ -32,6 +32,64 @@ pub enum SolverDefId {
     Ctor(Ctor),
 }
 
+impl std::fmt::Debug for SolverDefId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let interner = DbInterner::conjure();
+        let db = interner.db;
+        match *self {
+            SolverDefId::AdtId(AdtId::StructId(id)) => {
+                f.debug_tuple("AdtId").field(&db.struct_signature(id).name.as_str()).finish()
+            }
+            SolverDefId::AdtId(AdtId::EnumId(id)) => {
+                f.debug_tuple("AdtId").field(&db.enum_signature(id).name.as_str()).finish()
+            }
+            SolverDefId::AdtId(AdtId::UnionId(id)) => {
+                f.debug_tuple("AdtId").field(&db.union_signature(id).name.as_str()).finish()
+            }
+            SolverDefId::ConstId(id) => f
+                .debug_tuple("ConstId")
+                .field(&db.const_signature(id).name.as_ref().map_or("_", |name| name.as_str()))
+                .finish(),
+            SolverDefId::FunctionId(id) => {
+                f.debug_tuple("FunctionId").field(&db.function_signature(id).name.as_str()).finish()
+            }
+            SolverDefId::ImplId(id) => f.debug_tuple("ImplId").field(&id).finish(),
+            SolverDefId::StaticId(id) => {
+                f.debug_tuple("StaticId").field(&db.static_signature(id).name.as_str()).finish()
+            }
+            SolverDefId::TraitId(id) => {
+                f.debug_tuple("TraitId").field(&db.trait_signature(id).name.as_str()).finish()
+            }
+            SolverDefId::TypeAliasId(id) => f
+                .debug_tuple("TypeAliasId")
+                .field(&db.type_alias_signature(id).name.as_str())
+                .finish(),
+            SolverDefId::InternedClosureId(id) => {
+                f.debug_tuple("InternedClosureId").field(&id).finish()
+            }
+            SolverDefId::InternedCoroutineId(id) => {
+                f.debug_tuple("InternedCoroutineId").field(&id).finish()
+            }
+            SolverDefId::InternedOpaqueTyId(id) => {
+                f.debug_tuple("InternedOpaqueTyId").field(&id).finish()
+            }
+            SolverDefId::Ctor(Ctor::Struct(id)) => {
+                f.debug_tuple("Ctor").field(&db.struct_signature(id).name.as_str()).finish()
+            }
+            SolverDefId::Ctor(Ctor::Enum(id)) => {
+                let parent_enum = id.loc(db).parent;
+                f.debug_tuple("Ctor")
+                    .field(&format_args!(
+                        "\"{}::{}\"",
+                        db.enum_signature(parent_enum).name.as_str(),
+                        parent_enum.enum_variants(db).variant_name_by_id(id).unwrap().as_str()
+                    ))
+                    .finish()
+            }
+        }
+    }
+}
+
 impl_from!(
     AdtId(StructId, EnumId, UnionId),
     ConstId,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill.rs
index 4258f4c7ac68b..a8183ab422792 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill.rs
@@ -1,21 +1,28 @@
 //! Fulfill loop for next-solver.
 
-use std::marker::PhantomData;
-use std::mem;
-use std::ops::ControlFlow;
-use std::vec::ExtractIf;
-
-use rustc_next_trait_solver::delegate::SolverDelegate;
-use rustc_next_trait_solver::solve::{
-    GoalEvaluation, GoalStalledOn, HasChanged, SolverDelegateEvalExt,
+mod errors;
+
+use std::{marker::PhantomData, mem, ops::ControlFlow, vec::ExtractIf};
+
+use rustc_hash::FxHashSet;
+use rustc_next_trait_solver::{
+    delegate::SolverDelegate,
+    solve::{GoalEvaluation, GoalStalledOn, HasChanged, SolverDelegateEvalExt},
+};
+use rustc_type_ir::{
+    Interner, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor,
+    inherent::{IntoKind, Span as _},
+    solve::{Certainty, NoSolution},
 };
-use rustc_type_ir::Interner;
-use rustc_type_ir::inherent::Span as _;
-use rustc_type_ir::solve::{Certainty, NoSolution};
 
-use crate::next_solver::infer::InferCtxt;
-use crate::next_solver::infer::traits::{PredicateObligation, PredicateObligations};
-use crate::next_solver::{DbInterner, SolverContext, Span, TypingMode};
+use crate::next_solver::{
+    DbInterner, SolverContext, SolverDefId, Span, Ty, TyKind, TypingMode,
+    infer::{
+        InferCtxt,
+        traits::{PredicateObligation, PredicateObligations},
+    },
+    inspect::ProofTreeVisitor,
+};
 
 type PendingObligations<'db> =
     Vec<(PredicateObligation<'db>, Option<GoalStalledOn<DbInterner<'db>>>)>;
@@ -31,6 +38,7 @@ type PendingObligations<'db> =
 ///
 /// It is also likely that we want to use slightly different datastructures
 /// here as this will have to deal with far more root goals than `evaluate_all`.
+#[derive(Debug, Clone)]
 pub struct FulfillmentCtxt<'db> {
     obligations: ObligationStorage<'db>,
 
@@ -41,7 +49,7 @@ pub struct FulfillmentCtxt<'db> {
     usable_in_snapshot: usize,
 }
 
-#[derive(Default, Debug)]
+#[derive(Default, Debug, Clone)]
 struct ObligationStorage<'db> {
     /// Obligations which resulted in an overflow in fulfillment itself.
     ///
@@ -123,10 +131,21 @@ impl<'db> FulfillmentCtxt<'db> {
         infcx: &InferCtxt<'db>,
         obligation: PredicateObligation<'db>,
     ) {
-        assert_eq!(self.usable_in_snapshot, infcx.num_open_snapshots());
+        // FIXME: See the comment in `select_where_possible()`.
+        // assert_eq!(self.usable_in_snapshot, infcx.num_open_snapshots());
         self.obligations.register(obligation, None);
     }
 
+    pub(crate) fn register_predicate_obligations(
+        &mut self,
+        infcx: &InferCtxt<'db>,
+        obligations: impl IntoIterator<Item = PredicateObligation<'db>>,
+    ) {
+        // FIXME: See the comment in `select_where_possible()`.
+        // assert_eq!(self.usable_in_snapshot, infcx.num_open_snapshots());
+        obligations.into_iter().for_each(|obligation| self.obligations.register(obligation, None));
+    }
+
     pub(crate) fn collect_remaining_errors(
         &mut self,
         infcx: &InferCtxt<'db>,
@@ -143,7 +162,11 @@ impl<'db> FulfillmentCtxt<'db> {
         &mut self,
         infcx: &InferCtxt<'db>,
     ) -> Vec<NextSolverError<'db>> {
-        assert_eq!(self.usable_in_snapshot, infcx.num_open_snapshots());
+        // FIXME(next-solver): We should bring this assertion back. Currently it panics because
+        // there are places which use `InferenceTable` and open a snapshot and register obligations
+        // and select. They should use a different `ObligationCtxt` instead. Then we'll be also able
+        // to not put the obligations queue in `InferenceTable`'s snapshots.
+        // assert_eq!(self.usable_in_snapshot, infcx.num_open_snapshots());
         let mut errors = Vec::new();
         loop {
             let mut any_changed = false;
@@ -216,9 +239,94 @@ impl<'db> FulfillmentCtxt<'db> {
         self.obligations.has_pending_obligations()
     }
 
-    fn pending_obligations(&self) -> PredicateObligations<'db> {
+    pub(crate) fn pending_obligations(&self) -> PredicateObligations<'db> {
         self.obligations.clone_pending()
     }
+
+    pub(crate) fn drain_stalled_obligations_for_coroutines(
+        &mut self,
+        infcx: &InferCtxt<'db>,
+    ) -> PredicateObligations<'db> {
+        let stalled_coroutines = match infcx.typing_mode() {
+            TypingMode::Analysis { defining_opaque_types_and_generators } => {
+                defining_opaque_types_and_generators
+            }
+            TypingMode::Coherence
+            | TypingMode::Borrowck { defining_opaque_types: _ }
+            | TypingMode::PostBorrowckAnalysis { defined_opaque_types: _ }
+            | TypingMode::PostAnalysis => return Default::default(),
+        };
+        let stalled_coroutines = stalled_coroutines.inner();
+
+        if stalled_coroutines.is_empty() {
+            return Default::default();
+        }
+
+        self.obligations
+            .drain_pending(|obl| {
+                infcx.probe(|_| {
+                    infcx
+                        .visit_proof_tree(
+                            obl.as_goal(),
+                            &mut StalledOnCoroutines {
+                                stalled_coroutines,
+                                cache: Default::default(),
+                            },
+                        )
+                        .is_break()
+                })
+            })
+            .into_iter()
+            .map(|(o, _)| o)
+            .collect()
+    }
+}
+
+/// Detect if a goal is stalled on a coroutine that is owned by the current typeck root.
+///
+/// This function can (erroneously) fail to detect a predicate, i.e. it doesn't need to
+/// be complete. However, this will lead to ambiguity errors, so we want to make it
+/// accurate.
+///
+/// This function can be also return false positives, which will lead to poor diagnostics
+/// so we want to keep this visitor *precise* too.
+pub struct StalledOnCoroutines<'a, 'db> {
+    pub stalled_coroutines: &'a [SolverDefId],
+    pub cache: FxHashSet<Ty<'db>>,
+}
+
+impl<'db> ProofTreeVisitor<'db> for StalledOnCoroutines<'_, 'db> {
+    type Result = ControlFlow<()>;
+
+    fn visit_goal(&mut self, inspect_goal: &super::inspect::InspectGoal<'_, 'db>) -> Self::Result {
+        inspect_goal.goal().predicate.visit_with(self)?;
+
+        if let Some(candidate) = inspect_goal.unique_applicable_candidate() {
+            candidate.visit_nested_no_probe(self)
+        } else {
+            ControlFlow::Continue(())
+        }
+    }
+}
+
+impl<'db> TypeVisitor<DbInterner<'db>> for StalledOnCoroutines<'_, 'db> {
+    type Result = ControlFlow<()>;
+
+    fn visit_ty(&mut self, ty: Ty<'db>) -> Self::Result {
+        if !self.cache.insert(ty) {
+            return ControlFlow::Continue(());
+        }
+
+        if let TyKind::Coroutine(def_id, _) = ty.kind()
+            && self.stalled_coroutines.contains(&def_id.into())
+        {
+            ControlFlow::Break(())
+        } else if ty.has_coroutines() {
+            ty.super_visit_with(self)
+        } else {
+            ControlFlow::Continue(())
+        }
+    }
 }
 
 #[derive(Debug)]
@@ -227,3 +335,10 @@ pub enum NextSolverError<'db> {
     Ambiguity(PredicateObligation<'db>),
     Overflow(PredicateObligation<'db>),
 }
+
+impl NextSolverError<'_> {
+    #[inline]
+    pub fn is_true_error(&self) -> bool {
+        matches!(self, NextSolverError::TrueError(_))
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill/errors.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill/errors.rs
new file mode 100644
index 0000000000000..6cd9e55acf0e7
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill/errors.rs
@@ -0,0 +1,1332 @@
+//! Trait solving error diagnosis and reporting.
+//!
+//! This code isn't used by rust-analyzer (it should, but then it'll probably be better to re-port it from rustc).
+//! It's only there because without it, debugging trait solver errors is a nightmare.
+
+use std::{fmt::Debug, ops::ControlFlow};
+
+use rustc_next_trait_solver::solve::{GoalEvaluation, SolverDelegateEvalExt};
+use rustc_type_ir::{
+    AliasRelationDirection, AliasTermKind, HostEffectPredicate, Interner, PredicatePolarity,
+    error::ExpectedFound,
+    inherent::{IntoKind, PlaceholderConst, SliceLike, Span as _},
+    lang_items::SolverTraitLangItem,
+    solve::{CandidateSource, Certainty, GoalSource, MaybeCause, NoSolution},
+};
+use tracing::{instrument, trace};
+
+use crate::next_solver::{
+    AliasTerm, Binder, ClauseKind, Const, ConstKind, DbInterner, PolyTraitPredicate, PredicateKind,
+    SolverContext, SolverDefId, Span, Term, TraitPredicate, Ty, TyKind, TypeError,
+    fulfill::NextSolverError,
+    infer::{
+        InferCtxt,
+        select::SelectionError,
+        traits::{Obligation, ObligationCause, PredicateObligation, PredicateObligations},
+    },
+    inspect::{self, ProofTreeVisitor},
+    normalize::deeply_normalize_for_diagnostics,
+};
+
+#[derive(Debug)]
+pub struct FulfillmentError<'db> {
+    pub obligation: PredicateObligation<'db>,
+    pub code: FulfillmentErrorCode<'db>,
+    /// Diagnostics only: the 'root' obligation which resulted in
+    /// the failure to process `obligation`. This is the obligation
+    /// that was initially passed to `register_predicate_obligation`
+    pub root_obligation: PredicateObligation<'db>,
+}
+
+impl<'db> FulfillmentError<'db> {
+    pub fn new(
+        obligation: PredicateObligation<'db>,
+        code: FulfillmentErrorCode<'db>,
+        root_obligation: PredicateObligation<'db>,
+    ) -> FulfillmentError<'db> {
+        FulfillmentError { obligation, code, root_obligation }
+    }
+
+    pub fn is_true_error(&self) -> bool {
+        match self.code {
+            FulfillmentErrorCode::Select(_)
+            | FulfillmentErrorCode::Project(_)
+            | FulfillmentErrorCode::Subtype(_, _)
+            | FulfillmentErrorCode::ConstEquate(_, _) => true,
+            FulfillmentErrorCode::Cycle(_) | FulfillmentErrorCode::Ambiguity { overflow: _ } => {
+                false
+            }
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum FulfillmentErrorCode<'db> {
+    /// Inherently impossible to fulfill; this trait is implemented if and only
+    /// if it is already implemented.
+    Cycle(PredicateObligations<'db>),
+    Select(SelectionError<'db>),
+    Project(MismatchedProjectionTypes<'db>),
+    Subtype(ExpectedFound<Ty<'db>>, TypeError<'db>), // always comes from a SubtypePredicate
+    ConstEquate(ExpectedFound<Const<'db>>, TypeError<'db>),
+    Ambiguity {
+        /// Overflow is only `Some(suggest_recursion_limit)` when using the next generation
+        /// trait solver `-Znext-solver`. With the old solver overflow is eagerly handled by
+        /// emitting a fatal error instead.
+        overflow: Option<bool>,
+    },
+}
+
+#[derive(Debug, Clone)]
+pub struct MismatchedProjectionTypes<'db> {
+    pub err: TypeError<'db>,
+}
+
+pub(super) fn fulfillment_error_for_no_solution<'db>(
+    infcx: &InferCtxt<'db>,
+    root_obligation: PredicateObligation<'db>,
+) -> FulfillmentError<'db> {
+    let obligation = find_best_leaf_obligation(infcx, &root_obligation, false);
+
+    let code = match obligation.predicate.kind().skip_binder() {
+        PredicateKind::Clause(ClauseKind::Projection(_)) => {
+            FulfillmentErrorCode::Project(
+                // FIXME: This could be a `Sorts` if the term is a type
+                MismatchedProjectionTypes { err: TypeError::Mismatch },
+            )
+        }
+        PredicateKind::Clause(ClauseKind::ConstArgHasType(ct, expected_ty)) => {
+            let ct_ty = match ct.kind() {
+                ConstKind::Unevaluated(uv) => {
+                    infcx.interner.type_of(uv.def).instantiate(infcx.interner, uv.args)
+                }
+                ConstKind::Param(param_ct) => param_ct.find_const_ty_from_env(obligation.param_env),
+                ConstKind::Value(cv) => cv.ty,
+                kind => panic!(
+                    "ConstArgHasWrongType failed but we don't know how to compute type for {kind:?}"
+                ),
+            };
+            FulfillmentErrorCode::Select(SelectionError::ConstArgHasWrongType {
+                ct,
+                ct_ty,
+                expected_ty,
+            })
+        }
+        PredicateKind::NormalizesTo(..) => {
+            FulfillmentErrorCode::Project(MismatchedProjectionTypes { err: TypeError::Mismatch })
+        }
+        PredicateKind::AliasRelate(_, _, _) => {
+            FulfillmentErrorCode::Project(MismatchedProjectionTypes { err: TypeError::Mismatch })
+        }
+        PredicateKind::Subtype(pred) => {
+            let (a, b) = infcx.enter_forall_and_leak_universe(
+                obligation.predicate.kind().rebind((pred.a, pred.b)),
+            );
+            let expected_found = ExpectedFound::new(a, b);
+            FulfillmentErrorCode::Subtype(expected_found, TypeError::Sorts(expected_found))
+        }
+        PredicateKind::Coerce(pred) => {
+            let (a, b) = infcx.enter_forall_and_leak_universe(
+                obligation.predicate.kind().rebind((pred.a, pred.b)),
+            );
+            let expected_found = ExpectedFound::new(b, a);
+            FulfillmentErrorCode::Subtype(expected_found, TypeError::Sorts(expected_found))
+        }
+        PredicateKind::Clause(_) | PredicateKind::DynCompatible(_) | PredicateKind::Ambiguous => {
+            FulfillmentErrorCode::Select(SelectionError::Unimplemented)
+        }
+        PredicateKind::ConstEquate(..) => {
+            panic!("unexpected goal: {obligation:?}")
+        }
+    };
+
+    FulfillmentError { obligation, code, root_obligation }
+}
+
+pub(super) fn fulfillment_error_for_stalled<'db>(
+    infcx: &InferCtxt<'db>,
+    root_obligation: PredicateObligation<'db>,
+) -> FulfillmentError<'db> {
+    let (code, refine_obligation) = infcx.probe(|_| {
+        match <&SolverContext<'db>>::from(infcx).evaluate_root_goal(
+            root_obligation.as_goal(),
+            Span::dummy(),
+            None,
+        ) {
+            Ok(GoalEvaluation { certainty: Certainty::Maybe(MaybeCause::Ambiguity), .. }) => {
+                (FulfillmentErrorCode::Ambiguity { overflow: None }, true)
+            }
+            Ok(GoalEvaluation {
+                certainty:
+                    Certainty::Maybe(MaybeCause::Overflow {
+                        suggest_increasing_limit,
+                        keep_constraints: _,
+                    }),
+                ..
+            }) => (
+                FulfillmentErrorCode::Ambiguity { overflow: Some(suggest_increasing_limit) },
+                // Don't look into overflows because we treat overflows weirdly anyways.
+                // We discard the inference constraints from overflowing goals, so
+                // recomputing the goal again during `find_best_leaf_obligation` may apply
+                // inference guidance that makes other goals go from ambig -> pass, for example.
+                //
+                // FIXME: We should probably just look into overflows here.
+                false,
+            ),
+            Ok(GoalEvaluation { certainty: Certainty::Yes, .. }) => {
+                panic!(
+                    "did not expect successful goal when collecting ambiguity errors for `{:?}`",
+                    infcx.resolve_vars_if_possible(root_obligation.predicate),
+                )
+            }
+            Err(_) => {
+                panic!(
+                    "did not expect selection error when collecting ambiguity errors for `{:?}`",
+                    infcx.resolve_vars_if_possible(root_obligation.predicate),
+                )
+            }
+        }
+    });
+
+    FulfillmentError {
+        obligation: if refine_obligation {
+            find_best_leaf_obligation(infcx, &root_obligation, true)
+        } else {
+            root_obligation.clone()
+        },
+        code,
+        root_obligation,
+    }
+}
+
+pub(super) fn fulfillment_error_for_overflow<'db>(
+    infcx: &InferCtxt<'db>,
+    root_obligation: PredicateObligation<'db>,
+) -> FulfillmentError<'db> {
+    FulfillmentError {
+        obligation: find_best_leaf_obligation(infcx, &root_obligation, true),
+        code: FulfillmentErrorCode::Ambiguity { overflow: Some(true) },
+        root_obligation,
+    }
+}
+
+#[instrument(level = "debug", skip(infcx), ret)]
+fn find_best_leaf_obligation<'db>(
+    infcx: &InferCtxt<'db>,
+    obligation: &PredicateObligation<'db>,
+    consider_ambiguities: bool,
+) -> PredicateObligation<'db> {
+    let obligation = infcx.resolve_vars_if_possible(obligation.clone());
+    // FIXME: we use a probe here as the `BestObligation` visitor does not
+    // check whether it uses candidates which get shadowed by where-bounds.
+    //
+    // We should probably fix the visitor to not do so instead, as this also
+    // means the leaf obligation may be incorrect.
+    let obligation = infcx
+        .fudge_inference_if_ok(|| {
+            infcx
+                .visit_proof_tree(
+                    obligation.as_goal(),
+                    &mut BestObligation { obligation: obligation.clone(), consider_ambiguities },
+                )
+                .break_value()
+                .ok_or(())
+        })
+        .unwrap_or(obligation);
+    deeply_normalize_for_diagnostics(infcx, obligation.param_env, obligation)
+}
+
+struct BestObligation<'db> {
+    obligation: PredicateObligation<'db>,
+    consider_ambiguities: bool,
+}
+
+impl<'db> BestObligation<'db> {
+    fn with_derived_obligation(
+        &mut self,
+        derived_obligation: PredicateObligation<'db>,
+        and_then: impl FnOnce(&mut Self) -> <Self as ProofTreeVisitor<'db>>::Result,
+    ) -> <Self as ProofTreeVisitor<'db>>::Result {
+        let old_obligation = std::mem::replace(&mut self.obligation, derived_obligation);
+        let res = and_then(self);
+        self.obligation = old_obligation;
+        res
+    }
+
+    /// Filter out the candidates that aren't interesting to visit for the
+    /// purposes of reporting errors. For ambiguities, we only consider
+    /// candidates that may hold. For errors, we only consider candidates that
+    /// *don't* hold and which have impl-where clauses that also don't hold.
+    fn non_trivial_candidates<'a>(
+        &self,
+        goal: &'a inspect::InspectGoal<'a, 'db>,
+    ) -> Vec<inspect::InspectCandidate<'a, 'db>> {
+        let mut candidates = goal.candidates();
+        match self.consider_ambiguities {
+            true => {
+                // If we have an ambiguous obligation, we must consider *all* candidates
+                // that hold, or else we may guide inference causing other goals to go
+                // from ambig -> pass/fail.
+                candidates.retain(|candidate| candidate.result().is_ok());
+            }
+            false => {
+                // We always handle rigid alias candidates separately as we may not add them for
+                // aliases whose trait bound doesn't hold.
+                candidates.retain(|c| !matches!(c.kind(), inspect::ProbeKind::RigidAlias { .. }));
+                // If we have >1 candidate, one may still be due to "boring" reasons, like
+                // an alias-relate that failed to hold when deeply evaluated. We really
+                // don't care about reasons like this.
+                if candidates.len() > 1 {
+                    candidates.retain(|candidate| {
+                        goal.infcx().probe(|_| {
+                            candidate.instantiate_nested_goals().iter().any(|nested_goal| {
+                                matches!(
+                                    nested_goal.source(),
+                                    GoalSource::ImplWhereBound
+                                        | GoalSource::AliasBoundConstCondition
+                                        | GoalSource::InstantiateHigherRanked
+                                        | GoalSource::AliasWellFormed
+                                ) && nested_goal.result().is_err()
+                            })
+                        })
+                    });
+                }
+            }
+        }
+
+        candidates
+    }
+
+    /// HACK: We walk the nested obligations for a well-formed arg manually,
+    /// since there's nontrivial logic in `wf.rs` to set up an obligation cause.
+    /// Ideally we'd be able to track this better.
+    fn visit_well_formed_goal(
+        &mut self,
+        candidate: &inspect::InspectCandidate<'_, 'db>,
+        term: Term<'db>,
+    ) -> ControlFlow<PredicateObligation<'db>> {
+        let infcx = candidate.goal().infcx();
+        let param_env = candidate.goal().goal().param_env;
+
+        for obligation in wf::unnormalized_obligations(infcx, param_env, term).into_iter().flatten()
+        {
+            let nested_goal = candidate
+                .instantiate_proof_tree_for_nested_goal(GoalSource::Misc, obligation.as_goal());
+            // Skip nested goals that aren't the *reason* for our goal's failure.
+            match (self.consider_ambiguities, nested_goal.result()) {
+                (true, Ok(Certainty::Maybe(MaybeCause::Ambiguity))) | (false, Err(_)) => {}
+                _ => continue,
+            }
+
+            self.with_derived_obligation(obligation, |this| nested_goal.visit_with(this))?;
+        }
+
+        ControlFlow::Break(self.obligation.clone())
+    }
+
+    /// If a normalization of an associated item or a trait goal fails without trying any
+    /// candidates it's likely that normalizing its self type failed. We manually detect
+    /// such cases here.
+    fn detect_error_in_self_ty_normalization(
+        &mut self,
+        goal: &inspect::InspectGoal<'_, 'db>,
+        self_ty: Ty<'db>,
+    ) -> ControlFlow<PredicateObligation<'db>> {
+        assert!(!self.consider_ambiguities);
+        let interner = goal.infcx().interner;
+        if let TyKind::Alias(..) = self_ty.kind() {
+            let infer_term = goal.infcx().next_ty_var();
+            let pred = PredicateKind::AliasRelate(
+                self_ty.into(),
+                infer_term.into(),
+                AliasRelationDirection::Equate,
+            );
+            let obligation = Obligation::new(
+                interner,
+                self.obligation.cause.clone(),
+                goal.goal().param_env,
+                pred,
+            );
+            self.with_derived_obligation(obligation, |this| {
+                goal.infcx().visit_proof_tree_at_depth(
+                    goal.goal().with(interner, pred),
+                    goal.depth() + 1,
+                    this,
+                )
+            })
+        } else {
+            ControlFlow::Continue(())
+        }
+    }
+
+    /// When a higher-ranked projection goal fails, check that the corresponding
+    /// higher-ranked trait goal holds or not. This is because the process of
+    /// instantiating and then re-canonicalizing the binder of the projection goal
+    /// forces us to be unable to see that the leak check failed in the nested
+    /// `NormalizesTo` goal, so we don't fall back to the rigid projection check
+    /// that should catch when a projection goal fails due to an unsatisfied trait
+    /// goal.
+    fn detect_trait_error_in_higher_ranked_projection(
+        &mut self,
+        goal: &inspect::InspectGoal<'_, 'db>,
+    ) -> ControlFlow<PredicateObligation<'db>> {
+        let interner = goal.infcx().interner;
+        if let Some(projection_clause) = goal.goal().predicate.as_projection_clause()
+            && !projection_clause.bound_vars().is_empty()
+        {
+            let pred = projection_clause.map_bound(|proj| proj.projection_term.trait_ref(interner));
+            let obligation = Obligation::new(
+                interner,
+                self.obligation.cause.clone(),
+                goal.goal().param_env,
+                deeply_normalize_for_diagnostics(goal.infcx(), goal.goal().param_env, pred),
+            );
+            self.with_derived_obligation(obligation, |this| {
+                goal.infcx().visit_proof_tree_at_depth(
+                    goal.goal().with(interner, pred),
+                    goal.depth() + 1,
+                    this,
+                )
+            })
+        } else {
+            ControlFlow::Continue(())
+        }
+    }
+
+    /// It is likely that `NormalizesTo` failed without any applicable candidates
+    /// because the alias is not well-formed.
+    ///
+    /// As we only enter `RigidAlias` candidates if the trait bound of the associated type
+    /// holds, we discard these candidates in `non_trivial_candidates` and always manually
+    /// check this here.
+    fn detect_non_well_formed_assoc_item(
+        &mut self,
+        goal: &inspect::InspectGoal<'_, 'db>,
+        alias: AliasTerm<'db>,
+    ) -> ControlFlow<PredicateObligation<'db>> {
+        let interner = goal.infcx().interner;
+        let obligation = Obligation::new(
+            interner,
+            self.obligation.cause.clone(),
+            goal.goal().param_env,
+            alias.trait_ref(interner),
+        );
+        self.with_derived_obligation(obligation, |this| {
+            goal.infcx().visit_proof_tree_at_depth(
+                goal.goal().with(interner, alias.trait_ref(interner)),
+                goal.depth() + 1,
+                this,
+            )
+        })
+    }
+
+    /// If we have no candidates, then it's likely that there is a
+    /// non-well-formed alias in the goal.
+    fn detect_error_from_empty_candidates(
+        &mut self,
+        goal: &inspect::InspectGoal<'_, 'db>,
+    ) -> ControlFlow<PredicateObligation<'db>> {
+        let interner = goal.infcx().interner;
+        let pred_kind = goal.goal().predicate.kind();
+
+        match pred_kind.no_bound_vars() {
+            Some(PredicateKind::Clause(ClauseKind::Trait(pred))) => {
+                self.detect_error_in_self_ty_normalization(goal, pred.self_ty())?;
+            }
+            Some(PredicateKind::NormalizesTo(pred)) => {
+                if let AliasTermKind::ProjectionTy | AliasTermKind::ProjectionConst =
+                    pred.alias.kind(interner)
+                {
+                    self.detect_error_in_self_ty_normalization(goal, pred.alias.self_ty())?;
+                    self.detect_non_well_formed_assoc_item(goal, pred.alias)?;
+                }
+            }
+            Some(_) | None => {}
+        }
+
+        ControlFlow::Break(self.obligation.clone())
+    }
+}
+
+impl<'db> ProofTreeVisitor<'db> for BestObligation<'db> {
+    type Result = ControlFlow<PredicateObligation<'db>>;
+
+    #[instrument(level = "trace", skip(self, goal), fields(goal = ?goal.goal()))]
+    fn visit_goal(&mut self, goal: &inspect::InspectGoal<'_, 'db>) -> Self::Result {
+        let interner = goal.infcx().interner;
+        // Skip goals that aren't the *reason* for our goal's failure.
+        match (self.consider_ambiguities, goal.result()) {
+            (true, Ok(Certainty::Maybe(MaybeCause::Ambiguity))) | (false, Err(_)) => {}
+            _ => return ControlFlow::Continue(()),
+        }
+
+        let pred = goal.goal().predicate;
+
+        let candidates = self.non_trivial_candidates(goal);
+        let candidate = match candidates.as_slice() {
+            [candidate] => candidate,
+            [] => return self.detect_error_from_empty_candidates(goal),
+            _ => return ControlFlow::Break(self.obligation.clone()),
+        };
+
+        // // Don't walk into impls that have `do_not_recommend`.
+        // if let inspect::ProbeKind::TraitCandidate {
+        //     source: CandidateSource::Impl(impl_def_id),
+        //     result: _,
+        // } = candidate.kind()
+        //     && interner.do_not_recommend_impl(impl_def_id)
+        // {
+        //     trace!("#[do_not_recommend] -> exit");
+        //     return ControlFlow::Break(self.obligation.clone());
+        // }
+
+        // FIXME: Also, what about considering >1 layer up the stack? May be necessary
+        // for normalizes-to.
+        let child_mode = match pred.kind().skip_binder() {
+            PredicateKind::Clause(ClauseKind::Trait(trait_pred)) => {
+                ChildMode::Trait(pred.kind().rebind(trait_pred))
+            }
+            PredicateKind::Clause(ClauseKind::HostEffect(host_pred)) => {
+                ChildMode::Host(pred.kind().rebind(host_pred))
+            }
+            PredicateKind::NormalizesTo(normalizes_to)
+                if matches!(
+                    normalizes_to.alias.kind(interner),
+                    AliasTermKind::ProjectionTy | AliasTermKind::ProjectionConst
+                ) =>
+            {
+                ChildMode::Trait(pred.kind().rebind(TraitPredicate {
+                    trait_ref: normalizes_to.alias.trait_ref(interner),
+                    polarity: PredicatePolarity::Positive,
+                }))
+            }
+            PredicateKind::Clause(ClauseKind::WellFormed(term)) => {
+                return self.visit_well_formed_goal(candidate, term);
+            }
+            _ => ChildMode::PassThrough,
+        };
+
+        let nested_goals = candidate.instantiate_nested_goals();
+
+        // If the candidate requires some `T: FnPtr` bound which does not hold should not be treated as
+        // an actual candidate, instead we should treat them as if the impl was never considered to
+        // have potentially applied. As if `impl<A, R> Trait for for<..> fn(..A) -> R` was written
+        // instead of `impl<T: FnPtr> Trait for T`.
+        //
+        // We do this as a separate loop so that we do not choose to tell the user about some nested
+        // goal before we encounter a `T: FnPtr` nested goal.
+        for nested_goal in &nested_goals {
+            if let Some(poly_trait_pred) = nested_goal.goal().predicate.as_trait_clause()
+                && interner
+                    .is_trait_lang_item(poly_trait_pred.def_id(), SolverTraitLangItem::FnPtrTrait)
+                && let Err(NoSolution) = nested_goal.result()
+            {
+                return ControlFlow::Break(self.obligation.clone());
+            }
+        }
+
+        let mut impl_where_bound_count = 0;
+        for nested_goal in nested_goals {
+            trace!(nested_goal = ?(nested_goal.goal(), nested_goal.source(), nested_goal.result()));
+
+            let nested_pred = nested_goal.goal().predicate;
+
+            let make_obligation = || Obligation {
+                cause: ObligationCause::dummy(),
+                param_env: nested_goal.goal().param_env,
+                predicate: nested_pred,
+                recursion_depth: self.obligation.recursion_depth + 1,
+            };
+
+            let obligation;
+            match (child_mode, nested_goal.source()) {
+                (
+                    ChildMode::Trait(_) | ChildMode::Host(_),
+                    GoalSource::Misc | GoalSource::TypeRelating | GoalSource::NormalizeGoal(_),
+                ) => {
+                    continue;
+                }
+                (ChildMode::Trait(parent_trait_pred), GoalSource::ImplWhereBound) => {
+                    obligation = make_obligation();
+                    impl_where_bound_count += 1;
+                }
+                (
+                    ChildMode::Host(parent_host_pred),
+                    GoalSource::ImplWhereBound | GoalSource::AliasBoundConstCondition,
+                ) => {
+                    obligation = make_obligation();
+                    impl_where_bound_count += 1;
+                }
+                // Skip over a higher-ranked predicate.
+                (_, GoalSource::InstantiateHigherRanked) => {
+                    obligation = self.obligation.clone();
+                }
+                (ChildMode::PassThrough, _)
+                | (_, GoalSource::AliasWellFormed | GoalSource::AliasBoundConstCondition) => {
+                    obligation = make_obligation();
+                }
+            }
+
+            self.with_derived_obligation(obligation, |this| nested_goal.visit_with(this))?;
+        }
+
+        // alias-relate may fail because the lhs or rhs can't be normalized,
+        // and therefore is treated as rigid.
+        if let Some(PredicateKind::AliasRelate(lhs, rhs, _)) = pred.kind().no_bound_vars() {
+            goal.infcx().visit_proof_tree_at_depth(
+                goal.goal().with(interner, ClauseKind::WellFormed(lhs)),
+                goal.depth() + 1,
+                self,
+            )?;
+            goal.infcx().visit_proof_tree_at_depth(
+                goal.goal().with(interner, ClauseKind::WellFormed(rhs)),
+                goal.depth() + 1,
+                self,
+            )?;
+        }
+
+        self.detect_trait_error_in_higher_ranked_projection(goal)?;
+
+        ControlFlow::Break(self.obligation.clone())
+    }
+}
+
+#[derive(Debug, Copy, Clone)]
+enum ChildMode<'db> {
+    // Try to derive an `ObligationCause::{ImplDerived,BuiltinDerived}`,
+    // and skip all `GoalSource::Misc`, which represent useless obligations
+    // such as alias-eq which may not hold.
+    Trait(PolyTraitPredicate<'db>),
+    // Try to derive an `ObligationCause::{ImplDerived,BuiltinDerived}`,
+    // and skip all `GoalSource::Misc`, which represent useless obligations
+    // such as alias-eq which may not hold.
+    Host(Binder<'db, HostEffectPredicate<DbInterner<'db>>>),
+    // Skip trying to derive an `ObligationCause` from this obligation, and
+    // report *all* sub-obligations as if they came directly from the parent
+    // obligation.
+    PassThrough,
+}
+
+impl<'db> NextSolverError<'db> {
+    pub fn to_debuggable_error(&self, infcx: &InferCtxt<'db>) -> FulfillmentError<'db> {
+        match self {
+            NextSolverError::TrueError(obligation) => {
+                fulfillment_error_for_no_solution(infcx, obligation.clone())
+            }
+            NextSolverError::Ambiguity(obligation) => {
+                fulfillment_error_for_stalled(infcx, obligation.clone())
+            }
+            NextSolverError::Overflow(obligation) => {
+                fulfillment_error_for_overflow(infcx, obligation.clone())
+            }
+        }
+    }
+}
+
+mod wf {
+    use std::iter;
+
+    use hir_def::ItemContainerId;
+    use rustc_type_ir::inherent::{
+        AdtDef, BoundExistentialPredicates, GenericArg, GenericArgs as _, IntoKind, SliceLike,
+        Term as _, Ty as _,
+    };
+    use rustc_type_ir::lang_items::SolverTraitLangItem;
+    use rustc_type_ir::{
+        Interner, PredicatePolarity, TypeSuperVisitable, TypeVisitable, TypeVisitableExt,
+        TypeVisitor,
+    };
+    use tracing::{debug, instrument, trace};
+
+    use crate::next_solver::infer::InferCtxt;
+    use crate::next_solver::infer::traits::{
+        Obligation, ObligationCause, PredicateObligation, PredicateObligations,
+    };
+    use crate::next_solver::{
+        AliasTerm, Binder, ClauseKind, Const, ConstKind, Ctor, DbInterner, ExistentialPredicate,
+        GenericArgs, ParamEnv, Predicate, PredicateKind, Region, SolverDefId, Term, TraitPredicate,
+        TraitRef, Ty, TyKind,
+    };
+
+    /// Compute the predicates that are required for a type to be well-formed.
+    ///
+    /// This is only intended to be used in the new solver, since it does not
+    /// take into account recursion depth or proper error-reporting spans.
+    pub fn unnormalized_obligations<'db>(
+        infcx: &InferCtxt<'db>,
+        param_env: ParamEnv<'db>,
+        term: Term<'db>,
+    ) -> Option<PredicateObligations<'db>> {
+        debug_assert_eq!(term, infcx.resolve_vars_if_possible(term));
+
+        // However, if `arg` IS an unresolved inference variable, returns `None`,
+        // because we are not able to make any progress at all. This is to prevent
+        // cycles where we say "?0 is WF if ?0 is WF".
+        if term.is_infer() {
+            return None;
+        }
+
+        let mut wf =
+            WfPredicates { infcx, param_env, out: PredicateObligations::new(), recursion_depth: 0 };
+        wf.add_wf_preds_for_term(term);
+        Some(wf.out)
+    }
+
+    struct WfPredicates<'a, 'db> {
+        infcx: &'a InferCtxt<'db>,
+        param_env: ParamEnv<'db>,
+        out: PredicateObligations<'db>,
+        recursion_depth: usize,
+    }
+
+    /// Controls whether we "elaborate" supertraits and so forth on the WF
+    /// predicates. This is a kind of hack to address #43784. The
+    /// underlying problem in that issue was a trait structure like:
+    ///
+    /// ```ignore (illustrative)
+    /// trait Foo: Copy { }
+    /// trait Bar: Foo { }
+    /// impl<T: Bar> Foo for T { }
+    /// impl<T> Bar for T { }
+    /// ```
+    ///
+    /// Here, in the `Foo` impl, we will check that `T: Copy` holds -- but
+    /// we decide that this is true because `T: Bar` is in the
+    /// where-clauses (and we can elaborate that to include `T:
+    /// Copy`). This wouldn't be a problem, except that when we check the
+    /// `Bar` impl, we decide that `T: Foo` must hold because of the `Foo`
+    /// impl. And so nowhere did we check that `T: Copy` holds!
+    ///
+    /// To resolve this, we elaborate the WF requirements that must be
+    /// proven when checking impls. This means that (e.g.) the `impl Bar
+    /// for T` will be forced to prove not only that `T: Foo` but also `T:
+    /// Copy` (which it won't be able to do, because there is no `Copy`
+    /// impl for `T`).
+    #[derive(Debug, PartialEq, Eq, Copy, Clone)]
+    enum Elaborate {
+        All,
+        None,
+    }
+
+    impl<'a, 'db> WfPredicates<'a, 'db> {
+        fn interner(&self) -> DbInterner<'db> {
+            self.infcx.interner
+        }
+
+        /// Pushes the obligations required for `trait_ref` to be WF into `self.out`.
+        fn add_wf_preds_for_trait_pred(
+            &mut self,
+            trait_pred: TraitPredicate<'db>,
+            elaborate: Elaborate,
+        ) {
+            let tcx = self.interner();
+            let trait_ref = trait_pred.trait_ref;
+
+            // Negative trait predicates don't require supertraits to hold, just
+            // that their args are WF.
+            if trait_pred.polarity == PredicatePolarity::Negative {
+                self.add_wf_preds_for_negative_trait_pred(trait_ref);
+                return;
+            }
+
+            // if the trait predicate is not const, the wf obligations should not be const as well.
+            let obligations = self.nominal_obligations(trait_ref.def_id.0.into(), trait_ref.args);
+
+            debug!("compute_trait_pred obligations {:?}", obligations);
+            let param_env = self.param_env;
+            let depth = self.recursion_depth;
+
+            let extend = |PredicateObligation { predicate, mut cause, .. }| {
+                Obligation::with_depth(tcx, cause, depth, param_env, predicate)
+            };
+
+            if let Elaborate::All = elaborate {
+                let implied_obligations = rustc_type_ir::elaborate::elaborate(tcx, obligations);
+                let implied_obligations = implied_obligations.map(extend);
+                self.out.extend(implied_obligations);
+            } else {
+                self.out.extend(obligations);
+            }
+
+            self.out.extend(
+                trait_ref
+                    .args
+                    .iter()
+                    .enumerate()
+                    .filter_map(|(i, arg)| arg.as_term().map(|t| (i, t)))
+                    .filter(|(_, term)| !term.has_escaping_bound_vars())
+                    .map(|(i, term)| {
+                        let mut cause = ObligationCause::misc();
+                        // The first arg is the self ty - use the correct span for it.
+                        Obligation::with_depth(
+                            tcx,
+                            cause,
+                            depth,
+                            param_env,
+                            ClauseKind::WellFormed(term),
+                        )
+                    }),
+            );
+        }
+
+        // Compute the obligations that are required for `trait_ref` to be WF,
+        // given that it is a *negative* trait predicate.
+        fn add_wf_preds_for_negative_trait_pred(&mut self, trait_ref: TraitRef<'db>) {
+            for arg in trait_ref.args {
+                if let Some(term) = arg.as_term() {
+                    self.add_wf_preds_for_term(term);
+                }
+            }
+        }
+
+        /// Pushes the obligations required for an alias (except inherent) to be WF
+        /// into `self.out`.
+        fn add_wf_preds_for_alias_term(&mut self, data: AliasTerm<'db>) {
+            // A projection is well-formed if
+            //
+            // (a) its predicates hold (*)
+            // (b) its args are wf
+            //
+            // (*) The predicates of an associated type include the predicates of
+            //     the trait that it's contained in. For example, given
+            //
+            // trait A<T>: Clone {
+            //     type X where T: Copy;
+            // }
+            //
+            // The predicates of `<() as A<i32>>::X` are:
+            // [
+            //     `(): Sized`
+            //     `(): Clone`
+            //     `(): A<i32>`
+            //     `i32: Sized`
+            //     `i32: Clone`
+            //     `i32: Copy`
+            // ]
+            let obligations = self.nominal_obligations(data.def_id, data.args);
+            self.out.extend(obligations);
+
+            self.add_wf_preds_for_projection_args(data.args);
+        }
+
+        fn add_wf_preds_for_projection_args(&mut self, args: GenericArgs<'db>) {
+            let tcx = self.interner();
+            let cause = ObligationCause::new();
+            let param_env = self.param_env;
+            let depth = self.recursion_depth;
+
+            self.out.extend(
+                args.iter()
+                    .filter_map(|arg| arg.as_term())
+                    .filter(|term| !term.has_escaping_bound_vars())
+                    .map(|term| {
+                        Obligation::with_depth(
+                            tcx,
+                            cause.clone(),
+                            depth,
+                            param_env,
+                            ClauseKind::WellFormed(term),
+                        )
+                    }),
+            );
+        }
+
+        fn require_sized(&mut self, subty: Ty<'db>) {
+            if !subty.has_escaping_bound_vars() {
+                let cause = ObligationCause::new();
+                let trait_ref = TraitRef::new(
+                    self.interner(),
+                    self.interner().require_trait_lang_item(SolverTraitLangItem::Sized),
+                    [subty],
+                );
+                self.out.push(Obligation::with_depth(
+                    self.interner(),
+                    cause,
+                    self.recursion_depth,
+                    self.param_env,
+                    Binder::dummy(trait_ref),
+                ));
+            }
+        }
+
+        /// Pushes all the predicates needed to validate that `term` is WF into `out`.
+        #[instrument(level = "debug", skip(self))]
+        fn add_wf_preds_for_term(&mut self, term: Term<'db>) {
+            term.visit_with(self);
+            debug!(?self.out);
+        }
+
+        #[instrument(level = "debug", skip(self))]
+        fn nominal_obligations(
+            &mut self,
+            def_id: SolverDefId,
+            args: GenericArgs<'db>,
+        ) -> PredicateObligations<'db> {
+            // PERF: `Sized`'s predicates include `MetaSized`, but both are compiler implemented marker
+            // traits, so `MetaSized` will always be WF if `Sized` is WF and vice-versa. Determining
+            // the nominal obligations of `Sized` would in-effect just elaborate `MetaSized` and make
+            // the compiler do a bunch of work needlessly.
+            if let SolverDefId::TraitId(def_id) = def_id
+                && self.interner().is_trait_lang_item(def_id.into(), SolverTraitLangItem::Sized)
+            {
+                return Default::default();
+            }
+
+            self.interner()
+                .predicates_of(def_id)
+                .iter_instantiated(self.interner(), args)
+                .map(|pred| {
+                    let cause = ObligationCause::new();
+                    Obligation::with_depth(
+                        self.interner(),
+                        cause,
+                        self.recursion_depth,
+                        self.param_env,
+                        pred,
+                    )
+                })
+                .filter(|pred| !pred.has_escaping_bound_vars())
+                .collect()
+        }
+
+        fn add_wf_preds_for_dyn_ty(
+            &mut self,
+            ty: Ty<'db>,
+            data: &[Binder<'db, ExistentialPredicate<'db>>],
+            region: Region<'db>,
+        ) {
+            // Imagine a type like this:
+            //
+            //     trait Foo { }
+            //     trait Bar<'c> : 'c { }
+            //
+            //     &'b (Foo+'c+Bar<'d>)
+            //         ^
+            //
+            // In this case, the following relationships must hold:
+            //
+            //     'b <= 'c
+            //     'd <= 'c
+            //
+            // The first conditions is due to the normal region pointer
+            // rules, which say that a reference cannot outlive its
+            // referent.
+            //
+            // The final condition may be a bit surprising. In particular,
+            // you may expect that it would have been `'c <= 'd`, since
+            // usually lifetimes of outer things are conservative
+            // approximations for inner things. However, it works somewhat
+            // differently with trait objects: here the idea is that if the
+            // user specifies a region bound (`'c`, in this case) it is the
+            // "master bound" that *implies* that bounds from other traits are
+            // all met. (Remember that *all bounds* in a type like
+            // `Foo+Bar+Zed` must be met, not just one, hence if we write
+            // `Foo<'x>+Bar<'y>`, we know that the type outlives *both* 'x and
+            // 'y.)
+            //
+            // Note: in fact we only permit builtin traits, not `Bar<'d>`, I
+            // am looking forward to the future here.
+            if !data.has_escaping_bound_vars() && !region.has_escaping_bound_vars() {
+                let implicit_bounds = object_region_bounds(self.interner(), data);
+
+                let explicit_bound = region;
+
+                self.out.reserve(implicit_bounds.len());
+                for implicit_bound in implicit_bounds {
+                    let cause = ObligationCause::new();
+                    let outlives = Binder::dummy(rustc_type_ir::OutlivesPredicate(
+                        explicit_bound,
+                        implicit_bound,
+                    ));
+                    self.out.push(Obligation::with_depth(
+                        self.interner(),
+                        cause,
+                        self.recursion_depth,
+                        self.param_env,
+                        outlives,
+                    ));
+                }
+
+                // We don't add any wf predicates corresponding to the trait ref's generic arguments
+                // which allows code like this to compile:
+                // ```rust
+                // trait Trait<T: Sized> {}
+                // fn foo(_: &dyn Trait<[u32]>) {}
+                // ```
+            }
+        }
+    }
+
+    impl<'a, 'db> TypeVisitor<DbInterner<'db>> for WfPredicates<'a, 'db> {
+        type Result = ();
+
+        fn visit_ty(&mut self, t: Ty<'db>) -> Self::Result {
+            debug!("wf bounds for t={:?} t.kind={:#?}", t, t.kind());
+
+            let tcx = self.interner();
+
+            match t.kind() {
+                TyKind::Bool
+                | TyKind::Char
+                | TyKind::Int(..)
+                | TyKind::Uint(..)
+                | TyKind::Float(..)
+                | TyKind::Error(_)
+                | TyKind::Str
+                | TyKind::CoroutineWitness(..)
+                | TyKind::Never
+                | TyKind::Param(_)
+                | TyKind::Bound(..)
+                | TyKind::Placeholder(..)
+                | TyKind::Foreign(..) => {
+                    // WfScalar, WfParameter, etc
+                }
+
+                // Can only infer to `TyKind::Int(_) | TyKind::Uint(_)`.
+                TyKind::Infer(rustc_type_ir::IntVar(_)) => {}
+
+                // Can only infer to `TyKind::Float(_)`.
+                TyKind::Infer(rustc_type_ir::FloatVar(_)) => {}
+
+                TyKind::Slice(subty) => {
+                    self.require_sized(subty);
+                }
+
+                TyKind::Array(subty, len) => {
+                    self.require_sized(subty);
+                    // Note that the len being WF is implicitly checked while visiting.
+                    // Here we just check that it's of type usize.
+                    let cause = ObligationCause::new();
+                    self.out.push(Obligation::with_depth(
+                        tcx,
+                        cause,
+                        self.recursion_depth,
+                        self.param_env,
+                        Binder::dummy(PredicateKind::Clause(ClauseKind::ConstArgHasType(
+                            len,
+                            Ty::new_unit(self.interner()),
+                        ))),
+                    ));
+                }
+
+                TyKind::Pat(base_ty, pat) => {
+                    self.require_sized(base_ty);
+                }
+
+                TyKind::Tuple(tys) => {
+                    if let Some((_last, rest)) = tys.split_last() {
+                        for &elem in rest {
+                            self.require_sized(elem);
+                        }
+                    }
+                }
+
+                TyKind::RawPtr(_, _) => {
+                    // Simple cases that are WF if their type args are WF.
+                }
+
+                TyKind::Alias(
+                    rustc_type_ir::Projection | rustc_type_ir::Opaque | rustc_type_ir::Free,
+                    data,
+                ) => {
+                    let obligations = self.nominal_obligations(data.def_id, data.args);
+                    self.out.extend(obligations);
+                }
+                TyKind::Alias(rustc_type_ir::Inherent, data) => {
+                    return;
+                }
+
+                TyKind::Adt(def, args) => {
+                    // WfNominalType
+                    let obligations = self.nominal_obligations(def.def_id().0.into(), args);
+                    self.out.extend(obligations);
+                }
+
+                TyKind::FnDef(did, args) => {
+                    // HACK: Check the return type of function definitions for
+                    // well-formedness to mostly fix #84533. This is still not
+                    // perfect and there may be ways to abuse the fact that we
+                    // ignore requirements with escaping bound vars. That's a
+                    // more general issue however.
+                    let fn_sig = tcx.fn_sig(did).instantiate(tcx, args);
+                    fn_sig.output().skip_binder().visit_with(self);
+
+                    let did = match did.0 {
+                        hir_def::CallableDefId::FunctionId(id) => id.into(),
+                        hir_def::CallableDefId::StructId(id) => SolverDefId::Ctor(Ctor::Struct(id)),
+                        hir_def::CallableDefId::EnumVariantId(id) => {
+                            SolverDefId::Ctor(Ctor::Enum(id))
+                        }
+                    };
+                    let obligations = self.nominal_obligations(did, args);
+                    self.out.extend(obligations);
+                }
+
+                TyKind::Ref(r, rty, _) => {
+                    // WfReference
+                    if !r.has_escaping_bound_vars() && !rty.has_escaping_bound_vars() {
+                        let cause = ObligationCause::new();
+                        self.out.push(Obligation::with_depth(
+                            tcx,
+                            cause,
+                            self.recursion_depth,
+                            self.param_env,
+                            Binder::dummy(PredicateKind::Clause(ClauseKind::TypeOutlives(
+                                rustc_type_ir::OutlivesPredicate(rty, r),
+                            ))),
+                        ));
+                    }
+                }
+
+                TyKind::Coroutine(did, args, ..) => {
+                    // Walk ALL the types in the coroutine: this will
+                    // include the upvar types as well as the yield
+                    // type. Note that this is mildly distinct from
+                    // the closure case, where we have to be careful
+                    // about the signature of the closure. We don't
+                    // have the problem of implied bounds here since
+                    // coroutines don't take arguments.
+                    let obligations = self.nominal_obligations(did.0.into(), args);
+                    self.out.extend(obligations);
+                }
+
+                TyKind::Closure(did, args) => {
+                    // Note that we cannot skip the generic types
+                    // types. Normally, within the fn
+                    // body where they are created, the generics will
+                    // always be WF, and outside of that fn body we
+                    // are not directly inspecting closure types
+                    // anyway, except via auto trait matching (which
+                    // only inspects the upvar types).
+                    // But when a closure is part of a type-alias-impl-trait
+                    // then the function that created the defining site may
+                    // have had more bounds available than the type alias
+                    // specifies. This may cause us to have a closure in the
+                    // hidden type that is not actually well formed and
+                    // can cause compiler crashes when the user abuses unsafe
+                    // code to procure such a closure.
+                    // See tests/ui/type-alias-impl-trait/wf_check_closures.rs
+                    let obligations = self.nominal_obligations(did.0.into(), args);
+                    self.out.extend(obligations);
+                    // Only check the upvar types for WF, not the rest
+                    // of the types within. This is needed because we
+                    // capture the signature and it may not be WF
+                    // without the implied bounds. Consider a closure
+                    // like `|x: &'a T|` -- it may be that `T: 'a` is
+                    // not known to hold in the creator's context (and
+                    // indeed the closure may not be invoked by its
+                    // creator, but rather turned to someone who *can*
+                    // verify that).
+                    //
+                    // The special treatment of closures here really
+                    // ought not to be necessary either; the problem
+                    // is related to #25860 -- there is no way for us
+                    // to express a fn type complete with the implied
+                    // bounds that it is assuming. I think in reality
+                    // the WF rules around fn are a bit messed up, and
+                    // that is the rot problem: `fn(&'a T)` should
+                    // probably always be WF, because it should be
+                    // shorthand for something like `where(T: 'a) {
+                    // fn(&'a T) }`, as discussed in #25860.
+                    let upvars = args.as_closure().tupled_upvars_ty();
+                    return upvars.visit_with(self);
+                }
+
+                TyKind::CoroutineClosure(did, args) => {
+                    // See the above comments. The same apply to coroutine-closures.
+                    let obligations = self.nominal_obligations(did.0.into(), args);
+                    self.out.extend(obligations);
+                    let upvars = args.as_coroutine_closure().tupled_upvars_ty();
+                    return upvars.visit_with(self);
+                }
+
+                TyKind::FnPtr(..) => {
+                    // Let the visitor iterate into the argument/return
+                    // types appearing in the fn signature.
+                }
+                TyKind::UnsafeBinder(ty) => {}
+
+                TyKind::Dynamic(data, r, _) => {
+                    // WfObject
+                    //
+                    // Here, we defer WF checking due to higher-ranked
+                    // regions. This is perhaps not ideal.
+                    self.add_wf_preds_for_dyn_ty(t, data.as_slice(), r);
+
+                    // FIXME(#27579) RFC also considers adding trait
+                    // obligations that don't refer to Self and
+                    // checking those
+                    if let Some(principal) = data.principal_def_id() {
+                        self.out.push(Obligation::with_depth(
+                            tcx,
+                            ObligationCause::new(),
+                            self.recursion_depth,
+                            self.param_env,
+                            Binder::dummy(PredicateKind::DynCompatible(principal)),
+                        ));
+                    }
+                }
+
+                // Inference variables are the complicated case, since we don't
+                // know what type they are. We do two things:
+                //
+                // 1. Check if they have been resolved, and if so proceed with
+                //    THAT type.
+                // 2. If not, we've at least simplified things (e.g., we went
+                //    from `Vec?0>: WF` to `?0: WF`), so we can
+                //    register a pending obligation and keep
+                //    moving. (Goal is that an "inductive hypothesis"
+                //    is satisfied to ensure termination.)
+                // See also the comment on `fn obligations`, describing cycle
+                // prevention, which happens before this can be reached.
+                TyKind::Infer(_) => {
+                    let cause = ObligationCause::new();
+                    self.out.push(Obligation::with_depth(
+                        tcx,
+                        cause,
+                        self.recursion_depth,
+                        self.param_env,
+                        Binder::dummy(PredicateKind::Clause(ClauseKind::WellFormed(t.into()))),
+                    ));
+                }
+            }
+
+            t.super_visit_with(self)
+        }
+
+        fn visit_const(&mut self, c: Const<'db>) -> Self::Result {
+            let tcx = self.interner();
+
+            match c.kind() {
+                ConstKind::Unevaluated(uv) => {
+                    if !c.has_escaping_bound_vars() {
+                        let predicate =
+                            Binder::dummy(PredicateKind::Clause(ClauseKind::ConstEvaluatable(c)));
+                        let cause = ObligationCause::new();
+                        self.out.push(Obligation::with_depth(
+                            tcx,
+                            cause,
+                            self.recursion_depth,
+                            self.param_env,
+                            predicate,
+                        ));
+
+                        if let SolverDefId::ConstId(uv_def) = uv.def
+                            && let ItemContainerId::ImplId(impl_) =
+                                uv_def.loc(self.interner().db).container
+                            && self.interner().db.impl_signature(impl_).target_trait.is_none()
+                        {
+                            return; // Subtree is handled by above function
+                        } else {
+                            let obligations = self.nominal_obligations(uv.def, uv.args);
+                            self.out.extend(obligations);
+                        }
+                    }
+                }
+                ConstKind::Infer(_) => {
+                    let cause = ObligationCause::new();
+
+                    self.out.push(Obligation::with_depth(
+                        tcx,
+                        cause,
+                        self.recursion_depth,
+                        self.param_env,
+                        Binder::dummy(PredicateKind::Clause(ClauseKind::WellFormed(c.into()))),
+                    ));
+                }
+                ConstKind::Expr(_) => {
+                    // FIXME(generic_const_exprs): this doesn't verify that given `Expr(N + 1)` the
+                    // trait bound `typeof(N): Add<typeof(1)>` holds. This is currently unnecessary
+                    // as `ConstKind::Expr` is only produced via normalization of `ConstKind::Unevaluated`
+                    // which means that the `DefId` would have been typeck'd elsewhere. However in
+                    // the future we may allow directly lowering to `ConstKind::Expr` in which case
+                    // we would not be proving bounds we should.
+
+                    let predicate =
+                        Binder::dummy(PredicateKind::Clause(ClauseKind::ConstEvaluatable(c)));
+                    let cause = ObligationCause::new();
+                    self.out.push(Obligation::with_depth(
+                        tcx,
+                        cause,
+                        self.recursion_depth,
+                        self.param_env,
+                        predicate,
+                    ));
+                }
+
+                ConstKind::Error(_)
+                | ConstKind::Param(_)
+                | ConstKind::Bound(..)
+                | ConstKind::Placeholder(..) => {
+                    // These variants are trivially WF, so nothing to do here.
+                }
+                ConstKind::Value(..) => {
+                    // FIXME: Enforce that values are structurally-matchable.
+                }
+            }
+
+            c.super_visit_with(self)
+        }
+
+        fn visit_predicate(&mut self, _p: Predicate<'db>) -> Self::Result {
+            panic!("predicate should not be checked for well-formedness");
+        }
+    }
+
+    /// Given an object type like `SomeTrait + Send`, computes the lifetime
+    /// bounds that must hold on the elided self type. These are derived
+    /// from the declarations of `SomeTrait`, `Send`, and friends -- if
+    /// they declare `trait SomeTrait : 'static`, for example, then
+    /// `'static` would appear in the list.
+    ///
+    /// N.B., in some cases, particularly around higher-ranked bounds,
+    /// this function returns a kind of conservative approximation.
+    /// That is, all regions returned by this function are definitely
+    /// required, but there may be other region bounds that are not
+    /// returned, as well as requirements like `for<'a> T: 'a`.
+    ///
+    /// Requires that trait definitions have been processed so that we can
+    /// elaborate predicates and walk supertraits.
+    pub fn object_region_bounds<'db>(
+        interner: DbInterner<'db>,
+        existential_predicates: &[Binder<'db, ExistentialPredicate<'db>>],
+    ) -> Vec<Region<'db>> {
+        let erased_self_ty = Ty::new_unit(interner);
+
+        let predicates = existential_predicates
+            .iter()
+            .map(|predicate| predicate.with_self_ty(interner, erased_self_ty));
+
+        rustc_type_ir::elaborate::elaborate(interner, predicates)
+            .filter_map(|pred| {
+                debug!(?pred);
+                match pred.kind().skip_binder() {
+                    ClauseKind::TypeOutlives(rustc_type_ir::OutlivesPredicate(ref t, ref r)) => {
+                        // Search for a bound of the form `erased_self_ty
+                        // : 'a`, but be wary of something like `for<'a>
+                        // erased_self_ty : 'a` (we interpret a
+                        // higher-ranked bound like that as 'static,
+                        // though at present the code in `fulfill.rs`
+                        // considers such bounds to be unsatisfiable, so
+                        // it's kind of a moot point since you could never
+                        // construct such an object, but this seems
+                        // correct even if that code changes).
+                        if t == &erased_self_ty && !r.has_escaping_bound_vars() {
+                            Some(*r)
+                        } else {
+                            None
+                        }
+                    }
+                    ClauseKind::Trait(_)
+                    | ClauseKind::HostEffect(..)
+                    | ClauseKind::RegionOutlives(_)
+                    | ClauseKind::Projection(_)
+                    | ClauseKind::ConstArgHasType(_, _)
+                    | ClauseKind::WellFormed(_)
+                    | ClauseKind::UnstableFeature(_)
+                    | ClauseKind::ConstEvaluatable(_) => None,
+                }
+            })
+            .collect()
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generic_arg.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generic_arg.rs
index 4e124d07d2b38..097bb85cbd491 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generic_arg.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/generic_arg.rs
@@ -6,12 +6,15 @@ use rustc_type_ir::{
     ClosureArgs, CollectAndApply, ConstVid, CoroutineArgs, CoroutineClosureArgs, FnSig, FnSigTys,
     GenericArgKind, IntTy, Interner, TermKind, TyKind, TyVid, TypeFoldable, TypeVisitable,
     Variance,
-    inherent::{GenericArg as _, GenericsOf, IntoKind, SliceLike, Term as _, Ty as _},
+    inherent::{
+        GenericArg as _, GenericArgs as _, GenericsOf, IntoKind, SliceLike, Term as _, Ty as _,
+    },
     relate::{Relate, VarianceDiagInfo},
 };
 use smallvec::SmallVec;
 
 use crate::db::HirDatabase;
+use crate::next_solver::{Binder, PolyFnSig};
 
 use super::{
     Const, DbInterner, EarlyParamRegion, ErrorGuaranteed, ParamConst, Region, SolverDefId, Ty, Tys,
@@ -240,6 +243,34 @@ impl<'db> GenericArgs<'db> {
             args.push(kind);
         }
     }
+
+    pub fn closure_sig_untupled(self) -> PolyFnSig<'db> {
+        let TyKind::FnPtr(inputs_and_output, hdr) =
+            self.split_closure_args_untupled().closure_sig_as_fn_ptr_ty.kind()
+        else {
+            unreachable!("not a function pointer")
+        };
+        inputs_and_output.with(hdr)
+    }
+
+    /// A "sensible" `.split_closure_args()`, where the arguments are not in a tuple.
+    pub fn split_closure_args_untupled(self) -> rustc_type_ir::ClosureArgsParts<DbInterner<'db>> {
+        // FIXME: should use `ClosureSubst` when possible
+        match self.inner().as_slice() {
+            [parent_args @ .., closure_kind_ty, sig_ty, tupled_upvars_ty] => {
+                let interner = DbInterner::conjure();
+                rustc_type_ir::ClosureArgsParts {
+                    parent_args: GenericArgs::new_from_iter(interner, parent_args.iter().cloned()),
+                    closure_sig_as_fn_ptr_ty: sig_ty.expect_ty(),
+                    closure_kind_ty: closure_kind_ty.expect_ty(),
+                    tupled_upvars_ty: tupled_upvars_ty.expect_ty(),
+                }
+            }
+            _ => {
+                unreachable!("unexpected closure sig");
+            }
+        }
+    }
 }
 
 impl<'db> rustc_type_ir::relate::Relate<DbInterner<'db>> for GenericArgs<'db> {
@@ -329,7 +360,7 @@ impl<'db> rustc_type_ir::inherent::GenericArgs<DbInterner<'db>> for GenericArgs<
     fn split_closure_args(self) -> rustc_type_ir::ClosureArgsParts<DbInterner<'db>> {
         // FIXME: should use `ClosureSubst` when possible
         match self.inner().as_slice() {
-            [parent_args @ .., sig_ty] => {
+            [parent_args @ .., closure_kind_ty, sig_ty, tupled_upvars_ty] => {
                 let interner = DbInterner::conjure();
                 // This is stupid, but the next solver expects the first input to actually be a tuple
                 let sig_ty = match sig_ty.expect_ty().kind() {
@@ -354,8 +385,8 @@ impl<'db> rustc_type_ir::inherent::GenericArgs<DbInterner<'db>> for GenericArgs<
                 rustc_type_ir::ClosureArgsParts {
                     parent_args: GenericArgs::new_from_iter(interner, parent_args.iter().cloned()),
                     closure_sig_as_fn_ptr_ty: sig_ty,
-                    closure_kind_ty: Ty::new(interner, TyKind::Int(IntTy::I8)),
-                    tupled_upvars_ty: Ty::new_unit(interner),
+                    closure_kind_ty: closure_kind_ty.expect_ty(),
+                    tupled_upvars_ty: tupled_upvars_ty.expect_ty(),
                 }
             }
             _ => {
@@ -392,14 +423,14 @@ impl<'db> rustc_type_ir::inherent::GenericArgs<DbInterner<'db>> for GenericArgs<
     fn split_coroutine_args(self) -> rustc_type_ir::CoroutineArgsParts<DbInterner<'db>> {
         let interner = DbInterner::conjure();
         match self.inner().as_slice() {
-            [parent_args @ .., resume_ty, yield_ty, return_ty] => {
+            [parent_args @ .., kind_ty, resume_ty, yield_ty, return_ty, tupled_upvars_ty] => {
                 rustc_type_ir::CoroutineArgsParts {
                     parent_args: GenericArgs::new_from_iter(interner, parent_args.iter().cloned()),
-                    kind_ty: Ty::new_unit(interner),
+                    kind_ty: kind_ty.expect_ty(),
                     resume_ty: resume_ty.expect_ty(),
                     yield_ty: yield_ty.expect_ty(),
                     return_ty: return_ty.expect_ty(),
-                    tupled_upvars_ty: Ty::new_unit(interner),
+                    tupled_upvars_ty: tupled_upvars_ty.expect_ty(),
                 }
             }
             _ => panic!("GenericArgs were likely not for a Coroutine."),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/at.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/at.rs
index d64c7ed626eb2..8dfffe0d365e7 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/at.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/at.rs
@@ -26,7 +26,7 @@
 //! things. (That system should probably be refactored.)
 
 use rustc_type_ir::{
-    FnSig, GenericArgKind, TypingMode, Variance,
+    FnSig, GenericArgKind, TypeFoldable, TypingMode, Variance,
     error::ExpectedFound,
     inherent::{IntoKind, Span as _},
     relate::{Relate, TypeRelation, solver_relating::RelateExt},
@@ -36,6 +36,8 @@ use crate::next_solver::{
     AliasTerm, AliasTy, Binder, Const, DbInterner, GenericArg, Goal, ParamEnv,
     PolyExistentialProjection, PolyExistentialTraitRef, PolyFnSig, Predicate, Region, Span, Term,
     TraitRef, Ty,
+    fulfill::{FulfillmentCtxt, NextSolverError},
+    infer::relate::lattice::{LatticeOp, LatticeOpKind},
 };
 
 use super::{
@@ -210,6 +212,34 @@ impl<'a, 'db> At<'a, 'db> {
         }
     }
 
+    /// Deeply normalizes `value`, replacing all aliases which can by normalized in
+    /// the current environment. This errors in case normalization fails or is ambiguous.
+    pub fn deeply_normalize<T>(self, value: T) -> Result<T, Vec<NextSolverError<'db>>>
+    where
+        T: TypeFoldable<DbInterner<'db>>,
+    {
+        crate::next_solver::normalize::deeply_normalize(self, value)
+    }
+
+    /// Computes the least-upper-bound, or mutual supertype, of two
+    /// values. The order of the arguments doesn't matter, but since
+    /// this can result in an error (e.g., if asked to compute LUB of
+    /// u32 and i32), it is meaningful to call one of them the
+    /// "expected type".
+    pub fn lub<T>(self, expected: T, actual: T) -> InferResult<'db, T>
+    where
+        T: ToTrace<'db>,
+    {
+        let mut op = LatticeOp::new(
+            self.infcx,
+            ToTrace::to_trace(self.cause, expected, actual),
+            self.param_env,
+            LatticeOpKind::Lub,
+        );
+        let value = op.relate(expected, actual)?;
+        Ok(InferOk { value, obligations: op.into_obligations() })
+    }
+
     fn goals_to_obligations(&self, goals: Vec<Goal<'db, Predicate<'db>>>) -> InferOk<'db, ()> {
         InferOk {
             value: (),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs
index ce6c941287325..8e922abacb206 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/mod.rs
@@ -2,6 +2,7 @@
 
 use std::cell::{Cell, RefCell};
 use std::fmt;
+use std::ops::Range;
 use std::sync::Arc;
 
 pub use BoundRegionConversionTime::*;
@@ -55,6 +56,7 @@ mod opaque_types;
 pub mod region_constraints;
 pub mod relate;
 pub mod resolve;
+pub(crate) mod select;
 pub(crate) mod snapshot;
 pub(crate) mod traits;
 mod type_variable;
@@ -81,6 +83,10 @@ pub(crate) type UnificationTable<'a, 'db, T> = ut::UnificationTable<
     ut::InPlace<T, &'a mut ut::UnificationStorage<T>, &'a mut InferCtxtUndoLogs<'db>>,
 >;
 
+fn iter_idx_range<T: From<u32> + Into<u32>>(range: Range<T>) -> impl Iterator<Item = T> {
+    (range.start.into()..range.end.into()).map(Into::into)
+}
+
 /// This type contains all the things within `InferCtxt` that sit within a
 /// `RefCell` and are involved with taking/rolling back snapshots. Snapshot
 /// operations are hot enough that we want only one call to `borrow_mut` per
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/region_constraints/mod.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/region_constraints/mod.rs
index 50549694c3f23..7f15a467b3e87 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/region_constraints/mod.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/region_constraints/mod.rs
@@ -22,7 +22,7 @@ use crate::next_solver::{
     AliasTy, Binder, DbInterner, OpaqueTypeKey, ParamTy, PlaceholderTy, Region, Ty,
 };
 
-#[derive(Clone, Default)]
+#[derive(Debug, Clone, Default)]
 pub struct RegionConstraintStorage<'db> {
     /// For each `RegionVid`, the corresponding `RegionVariableOrigin`.
     pub(super) var_infos: IndexVec<RegionVid, RegionVariableInfo>,
@@ -239,7 +239,7 @@ pub struct VerifyIfEq<'db> {
     pub bound: Region<'db>,
 }
 
-#[derive(Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub(crate) struct TwoRegions<'db> {
     a: Region<'db>,
     b: Region<'db>,
@@ -458,6 +458,44 @@ impl<'db> RegionConstraintCollector<'db, '_> {
         }
     }
 
+    pub(super) fn lub_regions(
+        &mut self,
+        db: DbInterner<'db>,
+        a: Region<'db>,
+        b: Region<'db>,
+    ) -> Region<'db> {
+        // cannot add constraints once regions are resolved
+        debug!("RegionConstraintCollector: lub_regions({:?}, {:?})", a, b);
+        #[expect(clippy::if_same_then_else)]
+        if a.is_static() || b.is_static() {
+            a // nothing lives longer than static
+        } else if a == b {
+            a // LUB(a,a) = a
+        } else {
+            self.combine_vars(db, Lub, a, b)
+        }
+    }
+
+    pub(super) fn glb_regions(
+        &mut self,
+        db: DbInterner<'db>,
+        a: Region<'db>,
+        b: Region<'db>,
+    ) -> Region<'db> {
+        // cannot add constraints once regions are resolved
+        debug!("RegionConstraintCollector: glb_regions({:?}, {:?})", a, b);
+        #[expect(clippy::if_same_then_else)]
+        if a.is_static() {
+            b // static lives longer than everything else
+        } else if b.is_static() {
+            a // static lives longer than everything else
+        } else if a == b {
+            a // GLB(a,a) = a
+        } else {
+            self.combine_vars(db, Glb, a, b)
+        }
+    }
+
     /// Resolves a region var to its value in the unification table, if it exists.
     /// Otherwise, it is resolved to the root `ReVar` in the table.
     pub fn opportunistic_resolve_var(
@@ -531,6 +569,17 @@ impl<'db> RegionConstraintCollector<'db, '_> {
         }
     }
 
+    pub fn vars_since_snapshot(&self, value_count: usize) -> Range<RegionVid> {
+        RegionVid::from(value_count)..RegionVid::from(self.storage.unification_table.len())
+    }
+
+    /// See `InferCtxt::region_constraints_added_in_snapshot`.
+    pub fn region_constraints_added_in_snapshot(&self, mark: &Snapshot) -> bool {
+        self.undo_log
+            .region_constraints_in_snapshot(mark)
+            .any(|elt| matches!(elt, AddConstraint(_)))
+    }
+
     #[inline]
     fn unification_table_mut(&mut self) -> super::UnificationTable<'_, 'db, RegionVidKey<'db>> {
         ut::UnificationTable::with_log(&mut self.storage.unification_table, self.undo_log)
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/relate/generalize.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/relate/generalize.rs
index de336c69b3180..7e2735db3b77a 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/relate/generalize.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/relate/generalize.rs
@@ -350,7 +350,7 @@ impl<'db> Generalizer<'_, 'db> {
         // with inference variables can cause incorrect ambiguity.
         //
         // cc trait-system-refactor-initiative#110
-        if self.infcx.next_trait_solver() && !alias.has_escaping_bound_vars() && !self.in_alias {
+        if !alias.has_escaping_bound_vars() && !self.in_alias {
             return Ok(self.next_ty_var_for_alias());
         }
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/relate/lattice.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/relate/lattice.rs
new file mode 100644
index 0000000000000..c7f771ffe37f7
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/relate/lattice.rs
@@ -0,0 +1,269 @@
+//! # Lattice variables
+//!
+//! Generic code for operating on [lattices] of inference variables
+//! that are characterized by an upper- and lower-bound.
+//!
+//! The code is defined quite generically so that it can be
+//! applied both to type variables, which represent types being inferred,
+//! and fn variables, which represent function types being inferred.
+//! (It may eventually be applied to their types as well.)
+//! In some cases, the functions are also generic with respect to the
+//! operation on the lattice (GLB vs LUB).
+//!
+//! ## Note
+//!
+//! Although all the functions are generic, for simplicity, comments in the source code
+//! generally refer to type variables and the LUB operation.
+//!
+//! [lattices]: https://en.wikipedia.org/wiki/Lattice_(order)
+
+use rustc_type_ir::{
+    AliasRelationDirection, TypeVisitableExt, Upcast, Variance,
+    inherent::{IntoKind, Span as _},
+    relate::{
+        Relate, StructurallyRelateAliases, TypeRelation, VarianceDiagInfo,
+        combine::{PredicateEmittingRelation, super_combine_consts, super_combine_tys},
+    },
+};
+
+use crate::next_solver::{
+    AliasTy, Binder, Const, DbInterner, Goal, ParamEnv, Predicate, PredicateKind, Region, Span, Ty,
+    TyKind,
+    infer::{
+        DefineOpaqueTypes, InferCtxt, TypeTrace,
+        relate::RelateResult,
+        traits::{Obligation, PredicateObligations},
+    },
+};
+
+#[derive(Clone, Copy)]
+pub(crate) enum LatticeOpKind {
+    Glb,
+    Lub,
+}
+
+impl LatticeOpKind {
+    fn invert(self) -> Self {
+        match self {
+            LatticeOpKind::Glb => LatticeOpKind::Lub,
+            LatticeOpKind::Lub => LatticeOpKind::Glb,
+        }
+    }
+}
+
+/// A greatest lower bound" (common subtype) or least upper bound (common supertype).
+pub(crate) struct LatticeOp<'infcx, 'db> {
+    infcx: &'infcx InferCtxt<'db>,
+    // Immutable fields
+    trace: TypeTrace<'db>,
+    param_env: ParamEnv<'db>,
+    // Mutable fields
+    kind: LatticeOpKind,
+    obligations: PredicateObligations<'db>,
+}
+
+impl<'infcx, 'db> LatticeOp<'infcx, 'db> {
+    pub(crate) fn new(
+        infcx: &'infcx InferCtxt<'db>,
+        trace: TypeTrace<'db>,
+        param_env: ParamEnv<'db>,
+        kind: LatticeOpKind,
+    ) -> LatticeOp<'infcx, 'db> {
+        LatticeOp { infcx, trace, param_env, kind, obligations: PredicateObligations::new() }
+    }
+
+    pub(crate) fn into_obligations(self) -> PredicateObligations<'db> {
+        self.obligations
+    }
+}
+
+impl<'db> TypeRelation<DbInterner<'db>> for LatticeOp<'_, 'db> {
+    fn cx(&self) -> DbInterner<'db> {
+        self.infcx.interner
+    }
+
+    fn relate_with_variance<T: Relate<DbInterner<'db>>>(
+        &mut self,
+        variance: Variance,
+        _info: VarianceDiagInfo<DbInterner<'db>>,
+        a: T,
+        b: T,
+    ) -> RelateResult<'db, T> {
+        match variance {
+            Variance::Invariant => {
+                self.obligations.extend(
+                    self.infcx
+                        .at(&self.trace.cause, self.param_env)
+                        .eq_trace(DefineOpaqueTypes::Yes, self.trace.clone(), a, b)?
+                        .into_obligations(),
+                );
+                Ok(a)
+            }
+            Variance::Covariant => self.relate(a, b),
+            // FIXME(#41044) -- not correct, need test
+            Variance::Bivariant => Ok(a),
+            Variance::Contravariant => {
+                self.kind = self.kind.invert();
+                let res = self.relate(a, b);
+                self.kind = self.kind.invert();
+                res
+            }
+        }
+    }
+
+    /// Relates two types using a given lattice.
+    fn tys(&mut self, a: Ty<'db>, b: Ty<'db>) -> RelateResult<'db, Ty<'db>> {
+        if a == b {
+            return Ok(a);
+        }
+
+        let infcx = self.infcx;
+
+        let a = infcx.shallow_resolve(a);
+        let b = infcx.shallow_resolve(b);
+
+        match (a.kind(), b.kind()) {
+            // If one side is known to be a variable and one is not,
+            // create a variable (`v`) to represent the LUB. Make sure to
+            // relate `v` to the non-type-variable first (by passing it
+            // first to `relate_bound`). Otherwise, we would produce a
+            // subtype obligation that must then be processed.
+            //
+            // Example: if the LHS is a type variable, and RHS is
+            // `Box<i32>`, then we current compare `v` to the RHS first,
+            // which will instantiate `v` with `Box<i32>`. Then when `v`
+            // is compared to the LHS, we instantiate LHS with `Box<i32>`.
+            // But if we did in reverse order, we would create a `v <:
+            // LHS` (or vice versa) constraint and then instantiate
+            // `v`. This would require further processing to achieve same
+            // end-result; in particular, this screws up some of the logic
+            // in coercion, which expects LUB to figure out that the LHS
+            // is (e.g.) `Box<i32>`. A more obvious solution might be to
+            // iterate on the subtype obligations that are returned, but I
+            // think this suffices. -nmatsakis
+            (TyKind::Infer(rustc_type_ir::TyVar(..)), _) => {
+                let v = infcx.next_ty_var();
+                self.relate_bound(v, b, a)?;
+                Ok(v)
+            }
+            (_, TyKind::Infer(rustc_type_ir::TyVar(..))) => {
+                let v = infcx.next_ty_var();
+                self.relate_bound(v, a, b)?;
+                Ok(v)
+            }
+
+            (
+                TyKind::Alias(rustc_type_ir::Opaque, AliasTy { def_id: a_def_id, .. }),
+                TyKind::Alias(rustc_type_ir::Opaque, AliasTy { def_id: b_def_id, .. }),
+            ) if a_def_id == b_def_id => super_combine_tys(infcx, self, a, b),
+
+            _ => super_combine_tys(infcx, self, a, b),
+        }
+    }
+
+    fn regions(&mut self, a: Region<'db>, b: Region<'db>) -> RelateResult<'db, Region<'db>> {
+        let mut inner = self.infcx.inner.borrow_mut();
+        let mut constraints = inner.unwrap_region_constraints();
+        Ok(match self.kind {
+            // GLB(&'static u8, &'a u8) == &RegionLUB('static, 'a) u8 == &'static u8
+            LatticeOpKind::Glb => constraints.lub_regions(self.cx(), a, b),
+
+            // LUB(&'static u8, &'a u8) == &RegionGLB('static, 'a) u8 == &'a u8
+            LatticeOpKind::Lub => constraints.glb_regions(self.cx(), a, b),
+        })
+    }
+
+    fn consts(&mut self, a: Const<'db>, b: Const<'db>) -> RelateResult<'db, Const<'db>> {
+        super_combine_consts(self.infcx, self, a, b)
+    }
+
+    fn binders<T>(
+        &mut self,
+        a: Binder<'db, T>,
+        b: Binder<'db, T>,
+    ) -> RelateResult<'db, Binder<'db, T>>
+    where
+        T: Relate<DbInterner<'db>>,
+    {
+        // GLB/LUB of a binder and itself is just itself
+        if a == b {
+            return Ok(a);
+        }
+
+        if a.skip_binder().has_escaping_bound_vars() || b.skip_binder().has_escaping_bound_vars() {
+            // When higher-ranked types are involved, computing the GLB/LUB is
+            // very challenging, switch to invariance. This is obviously
+            // overly conservative but works ok in practice.
+            self.relate_with_variance(Variance::Invariant, VarianceDiagInfo::default(), a, b)?;
+            Ok(a)
+        } else {
+            Ok(Binder::dummy(self.relate(a.skip_binder(), b.skip_binder())?))
+        }
+    }
+}
+
+impl<'infcx, 'db> LatticeOp<'infcx, 'db> {
+    // Relates the type `v` to `a` and `b` such that `v` represents
+    // the LUB/GLB of `a` and `b` as appropriate.
+    //
+    // Subtle hack: ordering *may* be significant here. This method
+    // relates `v` to `a` first, which may help us to avoid unnecessary
+    // type variable obligations. See caller for details.
+    fn relate_bound(&mut self, v: Ty<'db>, a: Ty<'db>, b: Ty<'db>) -> RelateResult<'db, ()> {
+        let at = self.infcx.at(&self.trace.cause, self.param_env);
+        match self.kind {
+            LatticeOpKind::Glb => {
+                self.obligations.extend(at.sub(DefineOpaqueTypes::Yes, v, a)?.into_obligations());
+                self.obligations.extend(at.sub(DefineOpaqueTypes::Yes, v, b)?.into_obligations());
+            }
+            LatticeOpKind::Lub => {
+                self.obligations.extend(at.sub(DefineOpaqueTypes::Yes, a, v)?.into_obligations());
+                self.obligations.extend(at.sub(DefineOpaqueTypes::Yes, b, v)?.into_obligations());
+            }
+        }
+        Ok(())
+    }
+}
+
+impl<'db> PredicateEmittingRelation<InferCtxt<'db>> for LatticeOp<'_, 'db> {
+    fn span(&self) -> Span {
+        Span::dummy()
+    }
+
+    fn structurally_relate_aliases(&self) -> StructurallyRelateAliases {
+        StructurallyRelateAliases::No
+    }
+
+    fn param_env(&self) -> ParamEnv<'db> {
+        self.param_env
+    }
+
+    fn register_predicates(
+        &mut self,
+        preds: impl IntoIterator<Item: Upcast<DbInterner<'db>, Predicate<'db>>>,
+    ) {
+        self.obligations.extend(preds.into_iter().map(|pred| {
+            Obligation::new(self.infcx.interner, self.trace.cause.clone(), self.param_env, pred)
+        }))
+    }
+
+    fn register_goals(&mut self, goals: impl IntoIterator<Item = Goal<'db, Predicate<'db>>>) {
+        self.obligations.extend(goals.into_iter().map(|goal| {
+            Obligation::new(
+                self.infcx.interner,
+                self.trace.cause.clone(),
+                goal.param_env,
+                goal.predicate,
+            )
+        }))
+    }
+
+    fn register_alias_relate_predicate(&mut self, a: Ty<'db>, b: Ty<'db>) {
+        self.register_predicates([Binder::dummy(PredicateKind::AliasRelate(
+            a.into(),
+            b.into(),
+            // FIXME(deferred_projection_equality): This isn't right, I think?
+            AliasRelationDirection::Equate,
+        ))]);
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/relate/mod.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/relate/mod.rs
index 836ae39dc5253..0cc1cf756a9c2 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/relate/mod.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/relate/mod.rs
@@ -9,5 +9,6 @@ use crate::next_solver::DbInterner;
 
 mod generalize;
 mod higher_ranked;
+pub(crate) mod lattice;
 
 pub type RelateResult<'db, T> = rustc_type_ir::relate::RelateResult<DbInterner<'db>, T>;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/select.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/select.rs
new file mode 100644
index 0000000000000..d656d94f4f91e
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/select.rs
@@ -0,0 +1,334 @@
+use std::ops::ControlFlow;
+
+use hir_def::{ImplId, TraitId};
+use rustc_type_ir::{
+    Interner,
+    solve::{BuiltinImplSource, CandidateSource, Certainty, inspect::ProbeKind},
+};
+
+use crate::{
+    db::InternedOpaqueTyId,
+    next_solver::{
+        Const, ErrorGuaranteed, GenericArgs, Goal, TraitRef, Ty, TypeError,
+        infer::{
+            InferCtxt,
+            traits::{Obligation, ObligationCause, PredicateObligation, TraitObligation},
+        },
+        inspect::{InspectCandidate, InspectGoal, ProofTreeVisitor},
+    },
+};
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum SelectionError<'db> {
+    /// The trait is not implemented.
+    Unimplemented,
+    /// After a closure impl has selected, its "outputs" were evaluated
+    /// (which for closures includes the "input" type params) and they
+    /// didn't resolve. See `confirm_poly_trait_refs` for more.
+    SignatureMismatch(Box<SignatureMismatchData<'db>>),
+    /// The trait pointed by `DefId` is dyn-incompatible.
+    TraitDynIncompatible(TraitId),
+    /// A given constant couldn't be evaluated.
+    NotConstEvaluatable(NotConstEvaluatable),
+    /// Exceeded the recursion depth during type projection.
+    Overflow(OverflowError),
+    /// Computing an opaque type's hidden type caused an error (e.g. a cycle error).
+    /// We can thus not know whether the hidden type implements an auto trait, so
+    /// we should not presume anything about it.
+    OpaqueTypeAutoTraitLeakageUnknown(InternedOpaqueTyId),
+    /// Error for a `ConstArgHasType` goal
+    ConstArgHasWrongType { ct: Const<'db>, ct_ty: Ty<'db>, expected_ty: Ty<'db> },
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub enum NotConstEvaluatable {
+    Error(ErrorGuaranteed),
+    MentionsInfer,
+    MentionsParam,
+}
+
+/// Indicates that trait evaluation caused overflow and in which pass.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum OverflowError {
+    Error(ErrorGuaranteed),
+    Canonical,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct SignatureMismatchData<'db> {
+    pub found_trait_ref: TraitRef<'db>,
+    pub expected_trait_ref: TraitRef<'db>,
+    pub terr: TypeError<'db>,
+}
+
+/// When performing resolution, it is typically the case that there
+/// can be one of three outcomes:
+///
+/// - `Ok(Some(r))`: success occurred with result `r`
+/// - `Ok(None)`: could not definitely determine anything, usually due
+///   to inconclusive type inference.
+/// - `Err(e)`: error `e` occurred
+pub type SelectionResult<'db, T> = Result<Option<T>, SelectionError<'db>>;
+
+/// Given the successful resolution of an obligation, the `ImplSource`
+/// indicates where the impl comes from.
+///
+/// For example, the obligation may be satisfied by a specific impl (case A),
+/// or it may be relative to some bound that is in scope (case B).
+///
+/// ```ignore (illustrative)
+/// impl<T:Clone> Clone<T> for Option<T> { ... } // Impl_1
+/// impl<T:Clone> Clone<T> for Box<T> { ... }    // Impl_2
+/// impl Clone for i32 { ... }                   // Impl_3
+///
+/// fn foo<T: Clone>(concrete: Option<Box<i32>>, param: T, mixed: Option<T>) {
+///     // Case A: ImplSource points at a specific impl. Only possible when
+///     // type is concretely known. If the impl itself has bounded
+///     // type parameters, ImplSource will carry resolutions for those as well:
+///     concrete.clone(); // ImplSource(Impl_1, [ImplSource(Impl_2, [ImplSource(Impl_3)])])
+///
+///     // Case B: ImplSource must be provided by caller. This applies when
+///     // type is a type parameter.
+///     param.clone();    // ImplSource::Param
+///
+///     // Case C: A mix of cases A and B.
+///     mixed.clone();    // ImplSource(Impl_1, [ImplSource::Param])
+/// }
+/// ```
+///
+/// ### The type parameter `N`
+///
+/// See explanation on `ImplSourceUserDefinedData`.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum ImplSource<'db, N> {
+    /// ImplSource identifying a particular impl.
+    UserDefined(ImplSourceUserDefinedData<'db, N>),
+
+    /// Successful resolution to an obligation provided by the caller
+    /// for some type parameter. The `Vec<N>` represents the
+    /// obligations incurred from normalizing the where-clause (if
+    /// any).
+    Param(Vec<N>),
+
+    /// Successful resolution for a builtin impl.
+    Builtin(BuiltinImplSource, Vec<N>),
+}
+
+impl<'db, N> ImplSource<'db, N> {
+    pub fn nested_obligations(self) -> Vec<N> {
+        match self {
+            ImplSource::UserDefined(i) => i.nested,
+            ImplSource::Param(n) | ImplSource::Builtin(_, n) => n,
+        }
+    }
+
+    pub fn borrow_nested_obligations(&self) -> &[N] {
+        match self {
+            ImplSource::UserDefined(i) => &i.nested,
+            ImplSource::Param(n) | ImplSource::Builtin(_, n) => n,
+        }
+    }
+
+    pub fn borrow_nested_obligations_mut(&mut self) -> &mut [N] {
+        match self {
+            ImplSource::UserDefined(i) => &mut i.nested,
+            ImplSource::Param(n) | ImplSource::Builtin(_, n) => n,
+        }
+    }
+
+    pub fn map<M, F>(self, f: F) -> ImplSource<'db, M>
+    where
+        F: FnMut(N) -> M,
+    {
+        match self {
+            ImplSource::UserDefined(i) => ImplSource::UserDefined(ImplSourceUserDefinedData {
+                impl_def_id: i.impl_def_id,
+                args: i.args,
+                nested: i.nested.into_iter().map(f).collect(),
+            }),
+            ImplSource::Param(n) => ImplSource::Param(n.into_iter().map(f).collect()),
+            ImplSource::Builtin(source, n) => {
+                ImplSource::Builtin(source, n.into_iter().map(f).collect())
+            }
+        }
+    }
+}
+
+/// Identifies a particular impl in the source, along with a set of
+/// generic parameters from the impl's type/lifetime parameters. The
+/// `nested` vector corresponds to the nested obligations attached to
+/// the impl's type parameters.
+///
+/// The type parameter `N` indicates the type used for "nested
+/// obligations" that are required by the impl. During type-check, this
+/// is `Obligation`, as one might expect. During codegen, however, this
+/// is `()`, because codegen only requires a shallow resolution of an
+/// impl, and nested obligations are satisfied later.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ImplSourceUserDefinedData<'db, N> {
+    pub impl_def_id: ImplId,
+    pub args: GenericArgs<'db>,
+    pub nested: Vec<N>,
+}
+
+pub type Selection<'db> = ImplSource<'db, PredicateObligation<'db>>;
+
+impl<'db> InferCtxt<'db> {
+    pub(crate) fn select(
+        &self,
+        obligation: &TraitObligation<'db>,
+    ) -> SelectionResult<'db, Selection<'db>> {
+        self.visit_proof_tree(
+            Goal::new(self.interner, obligation.param_env, obligation.predicate),
+            &mut Select {},
+        )
+        .break_value()
+        .unwrap()
+    }
+}
+
+struct Select {}
+
+impl<'db> ProofTreeVisitor<'db> for Select {
+    type Result = ControlFlow<SelectionResult<'db, Selection<'db>>>;
+
+    fn visit_goal(&mut self, goal: &InspectGoal<'_, 'db>) -> Self::Result {
+        let mut candidates = goal.candidates();
+        candidates.retain(|cand| cand.result().is_ok());
+
+        // No candidates -- not implemented.
+        if candidates.is_empty() {
+            return ControlFlow::Break(Err(SelectionError::Unimplemented));
+        }
+
+        // One candidate, no need to winnow.
+        if candidates.len() == 1 {
+            return ControlFlow::Break(Ok(to_selection(candidates.into_iter().next().unwrap())));
+        }
+
+        // Don't winnow until `Certainty::Yes` -- we don't need to winnow until
+        // codegen, and only on the good path.
+        if matches!(goal.result().unwrap(), Certainty::Maybe(..)) {
+            return ControlFlow::Break(Ok(None));
+        }
+
+        // We need to winnow. See comments on `candidate_should_be_dropped_in_favor_of`.
+        let mut i = 0;
+        while i < candidates.len() {
+            let should_drop_i = (0..candidates.len())
+                .filter(|&j| i != j)
+                .any(|j| candidate_should_be_dropped_in_favor_of(&candidates[i], &candidates[j]));
+            if should_drop_i {
+                candidates.swap_remove(i);
+            } else {
+                i += 1;
+                if i > 1 {
+                    return ControlFlow::Break(Ok(None));
+                }
+            }
+        }
+
+        ControlFlow::Break(Ok(to_selection(candidates.into_iter().next().unwrap())))
+    }
+}
+
+/// This is a lot more limited than the old solver's equivalent method. This may lead to more `Ok(None)`
+/// results when selecting traits in polymorphic contexts, but we should never rely on the lack of ambiguity,
+/// and should always just gracefully fail here. We shouldn't rely on this incompleteness.
+fn candidate_should_be_dropped_in_favor_of<'db>(
+    victim: &InspectCandidate<'_, 'db>,
+    other: &InspectCandidate<'_, 'db>,
+) -> bool {
+    // Don't winnow until `Certainty::Yes` -- we don't need to winnow until
+    // codegen, and only on the good path.
+    if matches!(other.result().unwrap(), Certainty::Maybe(..)) {
+        return false;
+    }
+
+    let ProbeKind::TraitCandidate { source: victim_source, result: _ } = victim.kind() else {
+        return false;
+    };
+    let ProbeKind::TraitCandidate { source: other_source, result: _ } = other.kind() else {
+        return false;
+    };
+
+    match (victim_source, other_source) {
+        (_, CandidateSource::CoherenceUnknowable) | (CandidateSource::CoherenceUnknowable, _) => {
+            panic!("should not have assembled a CoherenceUnknowable candidate")
+        }
+
+        // In the old trait solver, we arbitrarily choose lower vtable candidates
+        // over higher ones.
+        (
+            CandidateSource::BuiltinImpl(BuiltinImplSource::Object(a)),
+            CandidateSource::BuiltinImpl(BuiltinImplSource::Object(b)),
+        ) => a >= b,
+        (
+            CandidateSource::BuiltinImpl(BuiltinImplSource::TraitUpcasting(a)),
+            CandidateSource::BuiltinImpl(BuiltinImplSource::TraitUpcasting(b)),
+        ) => a >= b,
+        // Prefer dyn candidates over non-dyn candidates. This is necessary to
+        // handle the unsoundness between `impl<T: ?Sized> Any for T` and `dyn Any: Any`.
+        (
+            CandidateSource::Impl(_) | CandidateSource::ParamEnv(_) | CandidateSource::AliasBound,
+            CandidateSource::BuiltinImpl(BuiltinImplSource::Object { .. }),
+        ) => true,
+
+        // Prefer specializing candidates over specialized candidates.
+        (CandidateSource::Impl(victim_def_id), CandidateSource::Impl(other_def_id)) => {
+            victim.goal().infcx().interner.impl_specializes(other_def_id, victim_def_id)
+        }
+
+        _ => false,
+    }
+}
+
+fn to_selection<'db>(cand: InspectCandidate<'_, 'db>) -> Option<Selection<'db>> {
+    if let Certainty::Maybe(..) = cand.shallow_certainty() {
+        return None;
+    }
+
+    let nested = match cand.result().expect("expected positive result") {
+        Certainty::Yes => Vec::new(),
+        Certainty::Maybe(_) => cand
+            .instantiate_nested_goals()
+            .into_iter()
+            .map(|nested| {
+                Obligation::new(
+                    nested.infcx().interner,
+                    ObligationCause::dummy(),
+                    nested.goal().param_env,
+                    nested.goal().predicate,
+                )
+            })
+            .collect(),
+    };
+
+    Some(match cand.kind() {
+        ProbeKind::TraitCandidate { source, result: _ } => match source {
+            CandidateSource::Impl(impl_def_id) => {
+                // FIXME: Remove this in favor of storing this in the tree
+                // For impl candidates, we do the rematch manually to compute the args.
+                ImplSource::UserDefined(ImplSourceUserDefinedData {
+                    impl_def_id: impl_def_id.0,
+                    args: cand.instantiate_impl_args(),
+                    nested,
+                })
+            }
+            CandidateSource::BuiltinImpl(builtin) => ImplSource::Builtin(builtin, nested),
+            CandidateSource::ParamEnv(_) | CandidateSource::AliasBound => ImplSource::Param(nested),
+            CandidateSource::CoherenceUnknowable => {
+                panic!("didn't expect to select an unknowable candidate")
+            }
+        },
+        ProbeKind::NormalizedSelfTyAssembly
+        | ProbeKind::UnsizeAssembly
+        | ProbeKind::ProjectionCompatibility
+        | ProbeKind::OpaqueTypeStorageLookup { result: _ }
+        | ProbeKind::Root { result: _ }
+        | ProbeKind::ShadowedEnvProbing
+        | ProbeKind::RigidAlias { result: _ } => {
+            panic!("didn't expect to assemble trait candidate from {:#?}", cand.kind())
+        }
+    })
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/snapshot/fudge.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/snapshot/fudge.rs
new file mode 100644
index 0000000000000..74353574e3298
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/snapshot/fudge.rs
@@ -0,0 +1,263 @@
+use std::ops::Range;
+
+use ena::{
+    snapshot_vec as sv,
+    unify::{self as ut, UnifyKey},
+};
+use rustc_type_ir::{
+    ConstVid, FloatVid, IntVid, RegionKind, RegionVid, TyVid, TypeFoldable, TypeFolder,
+    TypeSuperFoldable, TypeVisitableExt, inherent::IntoKind,
+};
+
+use crate::next_solver::{
+    Const, ConstKind, DbInterner, Region, Ty, TyKind,
+    infer::{
+        InferCtxt, UnificationTable, iter_idx_range,
+        snapshot::VariableLengths,
+        type_variable::TypeVariableOrigin,
+        unify_key::{ConstVariableOrigin, ConstVariableValue, ConstVidKey},
+    },
+};
+
+fn vars_since_snapshot<'db, T>(
+    table: &UnificationTable<'_, 'db, T>,
+    snapshot_var_len: usize,
+) -> Range<T>
+where
+    T: UnifyKey,
+    super::UndoLog<'db>: From<sv::UndoLog<ut::Delegate<T>>>,
+{
+    T::from_index(snapshot_var_len as u32)..T::from_index(table.len() as u32)
+}
+
+fn const_vars_since_snapshot<'db>(
+    table: &mut UnificationTable<'_, 'db, ConstVidKey<'db>>,
+    snapshot_var_len: usize,
+) -> (Range<ConstVid>, Vec<ConstVariableOrigin>) {
+    let range = vars_since_snapshot(table, snapshot_var_len);
+    let range = range.start.vid..range.end.vid;
+
+    (
+        range.clone(),
+        iter_idx_range(range)
+            .map(|index| match table.probe_value(index) {
+                ConstVariableValue::Known { value: _ } => {
+                    ConstVariableOrigin { param_def_id: None }
+                }
+                ConstVariableValue::Unknown { origin, universe: _ } => origin,
+            })
+            .collect(),
+    )
+}
+
+impl<'db> InferCtxt<'db> {
+    /// This rather funky routine is used while processing expected
+    /// types. What happens here is that we want to propagate a
+    /// coercion through the return type of a fn to its
+    /// argument. Consider the type of `Option::Some`, which is
+    /// basically `for<T> fn(T) -> Option<T>`. So if we have an
+    /// expression `Some(&[1, 2, 3])`, and that has the expected type
+    /// `Option<&[u32]>`, we would like to type check `&[1, 2, 3]`
+    /// with the expectation of `&[u32]`. This will cause us to coerce
+    /// from `&[u32; 3]` to `&[u32]` and make the users life more
+    /// pleasant.
+    ///
+    /// The way we do this is using `fudge_inference_if_ok`. What the
+    /// routine actually does is to start a snapshot and execute the
+    /// closure `f`. In our example above, what this closure will do
+    /// is to unify the expectation (`Option<&[u32]>`) with the actual
+    /// return type (`Option<?T>`, where `?T` represents the variable
+    /// instantiated for `T`). This will cause `?T` to be unified
+    /// with `&?a [u32]`, where `?a` is a fresh lifetime variable. The
+    /// input type (`?T`) is then returned by `f()`.
+    ///
+    /// At this point, `fudge_inference_if_ok` will normalize all type
+    /// variables, converting `?T` to `&?a [u32]` and end the
+    /// snapshot. The problem is that we can't just return this type
+    /// out, because it references the region variable `?a`, and that
+    /// region variable was popped when we popped the snapshot.
+    ///
+    /// So what we do is to keep a list (`region_vars`, in the code below)
+    /// of region variables created during the snapshot (here, `?a`). We
+    /// fold the return value and replace any such regions with a *new*
+    /// region variable (e.g., `?b`) and return the result (`&?b [u32]`).
+    /// This can then be used as the expectation for the fn argument.
+    ///
+    /// The important point here is that, for soundness purposes, the
+    /// regions in question are not particularly important. We will
+    /// use the expected types to guide coercions, but we will still
+    /// type-check the resulting types from those coercions against
+    /// the actual types (`?T`, `Option<?T>`) -- and remember that
+    /// after the snapshot is popped, the variable `?T` is no longer
+    /// unified.
+    pub fn fudge_inference_if_ok<T, E, F>(&self, f: F) -> Result<T, E>
+    where
+        F: FnOnce() -> Result<T, E>,
+        T: TypeFoldable<DbInterner<'db>>,
+    {
+        let variable_lengths = self.variable_lengths();
+        let (snapshot_vars, value) = self.probe(|_| {
+            let value = f()?;
+            // At this point, `value` could in principle refer
+            // to inference variables that have been created during
+            // the snapshot. Once we exit `probe()`, those are
+            // going to be popped, so we will have to
+            // eliminate any references to them.
+            let snapshot_vars = SnapshotVarData::new(self, variable_lengths);
+            Ok((snapshot_vars, self.resolve_vars_if_possible(value)))
+        })?;
+
+        // At this point, we need to replace any of the now-popped
+        // type/region variables that appear in `value` with a fresh
+        // variable of the appropriate kind. We can't do this during
+        // the probe because they would just get popped then too. =)
+        Ok(self.fudge_inference(snapshot_vars, value))
+    }
+
+    fn fudge_inference<T: TypeFoldable<DbInterner<'db>>>(
+        &self,
+        snapshot_vars: SnapshotVarData,
+        value: T,
+    ) -> T {
+        // Micro-optimization: if no variables have been created, then
+        // `value` can't refer to any of them. =) So we can just return it.
+        if snapshot_vars.is_empty() {
+            value
+        } else {
+            value.fold_with(&mut InferenceFudger { infcx: self, snapshot_vars })
+        }
+    }
+}
+
+struct SnapshotVarData {
+    region_vars: Range<RegionVid>,
+    type_vars: (Range<TyVid>, Vec<TypeVariableOrigin>),
+    int_vars: Range<IntVid>,
+    float_vars: Range<FloatVid>,
+    const_vars: (Range<ConstVid>, Vec<ConstVariableOrigin>),
+}
+
+impl SnapshotVarData {
+    fn new(infcx: &InferCtxt<'_>, vars_pre_snapshot: VariableLengths) -> SnapshotVarData {
+        let mut inner = infcx.inner.borrow_mut();
+        let region_vars = inner
+            .unwrap_region_constraints()
+            .vars_since_snapshot(vars_pre_snapshot.region_constraints_len);
+        let type_vars = inner.type_variables().vars_since_snapshot(vars_pre_snapshot.type_var_len);
+        let int_vars =
+            vars_since_snapshot(&inner.int_unification_table(), vars_pre_snapshot.int_var_len);
+        let float_vars =
+            vars_since_snapshot(&inner.float_unification_table(), vars_pre_snapshot.float_var_len);
+
+        let const_vars = const_vars_since_snapshot(
+            &mut inner.const_unification_table(),
+            vars_pre_snapshot.const_var_len,
+        );
+        SnapshotVarData { region_vars, type_vars, int_vars, float_vars, const_vars }
+    }
+
+    fn is_empty(&self) -> bool {
+        let SnapshotVarData { region_vars, type_vars, int_vars, float_vars, const_vars } = self;
+        region_vars.is_empty()
+            && type_vars.0.is_empty()
+            && int_vars.is_empty()
+            && float_vars.is_empty()
+            && const_vars.0.is_empty()
+    }
+}
+
+struct InferenceFudger<'a, 'db> {
+    infcx: &'a InferCtxt<'db>,
+    snapshot_vars: SnapshotVarData,
+}
+
+impl<'a, 'db> TypeFolder<DbInterner<'db>> for InferenceFudger<'a, 'db> {
+    fn cx(&self) -> DbInterner<'db> {
+        self.infcx.interner
+    }
+
+    fn fold_ty(&mut self, ty: Ty<'db>) -> Ty<'db> {
+        if let TyKind::Infer(infer_ty) = ty.kind() {
+            match infer_ty {
+                rustc_type_ir::TyVar(vid) => {
+                    if self.snapshot_vars.type_vars.0.contains(&vid) {
+                        // This variable was created during the fudging.
+                        // Recreate it with a fresh variable here.
+                        let idx = vid.as_usize() - self.snapshot_vars.type_vars.0.start.as_usize();
+                        let origin = self.snapshot_vars.type_vars.1[idx];
+                        self.infcx.next_ty_var_with_origin(origin)
+                    } else {
+                        // This variable was created before the
+                        // "fudging". Since we refresh all type
+                        // variables to their binding anyhow, we know
+                        // that it is unbound, so we can just return
+                        // it.
+                        debug_assert!(
+                            self.infcx.inner.borrow_mut().type_variables().probe(vid).is_unknown()
+                        );
+                        ty
+                    }
+                }
+                rustc_type_ir::IntVar(vid) => {
+                    if self.snapshot_vars.int_vars.contains(&vid) {
+                        self.infcx.next_int_var()
+                    } else {
+                        ty
+                    }
+                }
+                rustc_type_ir::FloatVar(vid) => {
+                    if self.snapshot_vars.float_vars.contains(&vid) {
+                        self.infcx.next_float_var()
+                    } else {
+                        ty
+                    }
+                }
+                rustc_type_ir::FreshTy(_)
+                | rustc_type_ir::FreshIntTy(_)
+                | rustc_type_ir::FreshFloatTy(_) => {
+                    unreachable!("unexpected fresh infcx var")
+                }
+            }
+        } else if ty.has_infer() {
+            ty.super_fold_with(self)
+        } else {
+            ty
+        }
+    }
+
+    fn fold_region(&mut self, r: Region<'db>) -> Region<'db> {
+        if let RegionKind::ReVar(vid) = r.kind() {
+            if self.snapshot_vars.region_vars.contains(&vid) {
+                let idx = vid.index() - self.snapshot_vars.region_vars.start.index();
+                self.infcx.next_region_var()
+            } else {
+                r
+            }
+        } else {
+            r
+        }
+    }
+
+    fn fold_const(&mut self, ct: Const<'db>) -> Const<'db> {
+        if let ConstKind::Infer(infer_ct) = ct.kind() {
+            match infer_ct {
+                rustc_type_ir::InferConst::Var(vid) => {
+                    if self.snapshot_vars.const_vars.0.contains(&vid) {
+                        let idx = vid.index() - self.snapshot_vars.const_vars.0.start.index();
+                        let origin = self.snapshot_vars.const_vars.1[idx];
+                        self.infcx.next_const_var_with_origin(origin)
+                    } else {
+                        ct
+                    }
+                }
+                rustc_type_ir::InferConst::Fresh(_) => {
+                    unreachable!("unexpected fresh infcx var")
+                }
+            }
+        } else if ct.has_infer() {
+            ct.super_fold_with(self)
+        } else {
+            ct
+        }
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/snapshot/mod.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/snapshot/mod.rs
index 8c7dfb25e07f9..7b9ca96c51406 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/snapshot/mod.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/snapshot/mod.rs
@@ -7,6 +7,7 @@ use tracing::{debug, instrument};
 use super::InferCtxt;
 use super::region_constraints::RegionSnapshot;
 
+mod fudge;
 pub(crate) mod undo_log;
 
 use undo_log::{Snapshot, UndoLog};
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/snapshot/undo_log.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/snapshot/undo_log.rs
index 28ae56f4ee70a..05a1013b3fbd5 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/snapshot/undo_log.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/snapshot/undo_log.rs
@@ -178,6 +178,10 @@ impl<'db> InferCtxtUndoLogs<'db> {
         })
     }
 
+    pub(crate) fn opaque_types_in_snapshot(&self, s: &Snapshot) -> bool {
+        self.logs[s.undo_len..].iter().any(|log| matches!(log, UndoLog::OpaqueTypes(..)))
+    }
+
     fn assert_open_snapshot(&self, snapshot: &Snapshot) {
         // Failures here may indicate a failure to follow a stack discipline.
         assert!(self.logs.len() >= snapshot.undo_len);
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/traits.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/traits.rs
index f1df806ab3187..68aa12d7bb0cb 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/traits.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/traits.rs
@@ -7,14 +7,16 @@ use std::{
     hash::{Hash, Hasher},
 };
 
+use rustc_type_ir::elaborate::Elaboratable;
 use rustc_type_ir::{
     PredicatePolarity, Upcast,
     solve::{Certainty, NoSolution},
 };
+use rustc_type_ir::{TypeFoldable, TypeVisitable};
 
 use crate::next_solver::{
-    Binder, DbInterner, Goal, ParamEnv, PolyTraitPredicate, Predicate, SolverDefId, TraitPredicate,
-    Ty,
+    Binder, Clause, DbInterner, Goal, ParamEnv, PolyTraitPredicate, Predicate, SolverDefId, Span,
+    TraitPredicate, Ty,
 };
 
 use super::InferCtxt;
@@ -29,24 +31,29 @@ use super::InferCtxt;
 /// only live for a short period of time.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct ObligationCause {
-    /// The ID of the fn body that triggered this obligation. This is
-    /// used for region obligations to determine the precise
-    /// environment in which the region obligation should be evaluated
-    /// (in particular, closures can add new assumptions). See the
-    /// field `region_obligations` of the `FulfillmentContext` for more
-    /// information.
-    pub body_id: Option<SolverDefId>,
+    // FIXME: This should contain an `ExprId`/`PatId` etc., and a cause code. But for now we
+    // don't report trait solving diagnostics, so this is irrelevant.
+    _private: (),
 }
 
 impl ObligationCause {
+    #[expect(
+        clippy::new_without_default,
+        reason = "`new` is temporary, eventually we will provide span etc. here"
+    )]
     #[inline]
-    pub fn new(body_id: SolverDefId) -> ObligationCause {
-        ObligationCause { body_id: Some(body_id) }
+    pub fn new() -> ObligationCause {
+        ObligationCause { _private: () }
     }
 
-    #[inline(always)]
+    #[inline]
     pub fn dummy() -> ObligationCause {
-        ObligationCause { body_id: None }
+        ObligationCause::new()
+    }
+
+    #[inline]
+    pub fn misc() -> ObligationCause {
+        ObligationCause::new()
     }
 }
 
@@ -75,6 +82,72 @@ pub struct Obligation<'db, T> {
     pub recursion_depth: usize,
 }
 
+/// For [`Obligation`], a sub-obligation is combined with the current obligation's
+/// param-env and cause code.
+impl<'db> Elaboratable<DbInterner<'db>> for PredicateObligation<'db> {
+    fn predicate(&self) -> Predicate<'db> {
+        self.predicate
+    }
+
+    fn child(&self, clause: Clause<'db>) -> Self {
+        Obligation {
+            cause: self.cause.clone(),
+            param_env: self.param_env,
+            recursion_depth: 0,
+            predicate: clause.as_predicate(),
+        }
+    }
+
+    fn child_with_derived_cause(
+        &self,
+        clause: Clause<'db>,
+        span: Span,
+        parent_trait_pred: PolyTraitPredicate<'db>,
+        index: usize,
+    ) -> Self {
+        let cause = ObligationCause::new();
+        Obligation {
+            cause,
+            param_env: self.param_env,
+            recursion_depth: 0,
+            predicate: clause.as_predicate(),
+        }
+    }
+}
+
+impl<'db, T: TypeVisitable<DbInterner<'db>>> TypeVisitable<DbInterner<'db>> for Obligation<'db, T> {
+    fn visit_with<V: rustc_type_ir::TypeVisitor<DbInterner<'db>>>(
+        &self,
+        visitor: &mut V,
+    ) -> V::Result {
+        rustc_ast_ir::try_visit!(self.param_env.visit_with(visitor));
+        self.predicate.visit_with(visitor)
+    }
+}
+
+impl<'db, T: TypeFoldable<DbInterner<'db>>> TypeFoldable<DbInterner<'db>> for Obligation<'db, T> {
+    fn try_fold_with<F: rustc_type_ir::FallibleTypeFolder<DbInterner<'db>>>(
+        self,
+        folder: &mut F,
+    ) -> Result<Self, F::Error> {
+        Ok(Obligation {
+            cause: self.cause.clone(),
+            param_env: self.param_env.try_fold_with(folder)?,
+            predicate: self.predicate.try_fold_with(folder)?,
+            recursion_depth: self.recursion_depth,
+        })
+    }
+
+    fn fold_with<F: rustc_type_ir::TypeFolder<DbInterner<'db>>>(self, folder: &mut F) -> Self {
+        Obligation {
+            cause: self.cause.clone(),
+            param_env: self.param_env.fold_with(folder),
+            predicate: self.predicate.fold_with(folder),
+            recursion_depth: self.recursion_depth,
+        }
+    }
+}
+
 impl<'db, T: Copy> Obligation<'db, T> {
     pub fn as_goal(&self) -> Goal<'db, T> {
         Goal { param_env: self.param_env, predicate: self.predicate }
@@ -156,15 +229,6 @@ impl<'db, O> Obligation<'db, O> {
         Obligation { cause, param_env, recursion_depth, predicate }
     }
 
-    pub fn misc(
-        tcx: DbInterner<'db>,
-        body_id: SolverDefId,
-        param_env: ParamEnv<'db>,
-        trait_ref: impl Upcast<DbInterner<'db>, O>,
-    ) -> Obligation<'db, O> {
-        Obligation::new(tcx, ObligationCause::new(body_id), param_env, trait_ref)
-    }
-
     pub fn with<P>(
         &self,
         tcx: DbInterner<'db>,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/type_variable.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/type_variable.rs
index b640039af625b..29e7b883c93bf 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/type_variable.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/type_variable.rs
@@ -15,7 +15,7 @@ use tracing::debug;
 
 use crate::next_solver::SolverDefId;
 use crate::next_solver::Ty;
-use crate::next_solver::infer::InferCtxtUndoLogs;
+use crate::next_solver::infer::{InferCtxtUndoLogs, iter_idx_range};
 
 /// Represents a single undo-able action that affects a type inference variable.
 #[derive(Clone)]
@@ -59,7 +59,7 @@ impl<'tcx> Rollback<UndoLog<'tcx>> for TypeVariableStorage<'tcx> {
     }
 }
 
-#[derive(Clone, Default)]
+#[derive(Debug, Clone, Default)]
 pub(crate) struct TypeVariableStorage<'db> {
     /// The origins of each type variable.
     values: IndexVec<TyVid, TypeVariableData>,
@@ -102,7 +102,7 @@ pub struct TypeVariableOrigin {
     pub param_def_id: Option<SolverDefId>,
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub(crate) struct TypeVariableData {
     origin: TypeVariableOrigin,
 }
@@ -267,6 +267,15 @@ impl<'db> TypeVariableTable<'_, 'db> {
         self.storage.sub_unification_table.with_log(self.undo_log)
     }
 
+    /// Returns a range of the type variables created during the snapshot.
+    pub(crate) fn vars_since_snapshot(
+        &mut self,
+        value_count: usize,
+    ) -> (Range<TyVid>, Vec<TypeVariableOrigin>) {
+        let range = TyVid::from_usize(value_count)..TyVid::from_usize(self.num_vars());
+        (range.clone(), iter_idx_range(range).map(|index| self.var_origin(index)).collect())
+    }
+
     /// Returns indices of all variables that are not yet
     /// instantiated.
     pub(crate) fn unresolved_variables(&mut self) -> Vec<TyVid> {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/inspect.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/inspect.rs
new file mode 100644
index 0000000000000..cab3c69118f64
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/inspect.rs
@@ -0,0 +1,501 @@
+pub use ra_ap_rustc_next_trait_solver::solve::inspect::*;
+
+use rustc_ast_ir::try_visit;
+use rustc_next_trait_solver::{
+    resolve::eager_resolve_vars,
+    solve::{
+        SolverDelegateEvalExt,
+        inspect::{self, instantiate_canonical_state},
+    },
+};
+use rustc_type_ir::{
+    VisitorResult,
+    inherent::{IntoKind, Span as _},
+    solve::{Certainty, GoalSource, MaybeCause, NoSolution},
+};
+
+use crate::next_solver::{
+    DbInterner, GenericArg, GenericArgs, Goal, NormalizesTo, ParamEnv, Predicate, PredicateKind,
+    QueryResult, SolverContext, Span, Term,
+    fulfill::NextSolverError,
+    infer::{
+        InferCtxt,
+        traits::{Obligation, ObligationCause},
+    },
+    obligation_ctxt::ObligationCtxt,
+};
+
+pub struct InspectConfig {
+    pub max_depth: usize,
+}
+
+pub struct InspectGoal<'a, 'db> {
+    infcx: &'a SolverContext<'db>,
+    depth: usize,
+    orig_values: Vec<GenericArg<'db>>,
+    goal: Goal<'db, Predicate<'db>>,
+    result: Result<Certainty, NoSolution>,
+    final_revision: inspect::Probe<DbInterner<'db>>,
+    normalizes_to_term_hack: Option<NormalizesToTermHack<'db>>,
+    source: GoalSource,
+}
+
+impl<'a, 'db> std::fmt::Debug for InspectGoal<'a, 'db> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("InspectGoal")
+            .field("depth", &self.depth)
+            .field("orig_values", &self.orig_values)
+            .field("goal", &self.goal)
+            .field("result", &self.result)
+            .field("final_revision", &self.final_revision)
+            .field("normalizes_to_term_hack", &self.normalizes_to_term_hack)
+            .field("source", &self.source)
+            .finish()
+    }
+}
+
+impl<'a, 'db> std::fmt::Debug for InspectCandidate<'a, 'db> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("InspectCandidate")
+            .field("kind", &self.kind)
+            .field("steps", &self.steps)
+            .field("final_state", &self.final_state)
+            .field("result", &self.result)
+            .field("shallow_certainty", &self.shallow_certainty)
+            .finish()
+    }
+}
+
+/// The expected term of a `NormalizesTo` goal gets replaced
+/// with an unconstrained inference variable when computing
+/// `NormalizesTo` goals and we return the nested goals to the
+/// caller, who also equates the actual term with the expected.
+///
+/// This is an implementation detail of the trait solver and
+/// not something we want to leak to users. We therefore
+/// treat `NormalizesTo` goals as if they apply the expected
+/// type at the end of each candidate.
+#[derive(Debug, Copy, Clone)]
+struct NormalizesToTermHack<'db> {
+    term: Term<'db>,
+    unconstrained_term: Term<'db>,
+}
+
+impl<'db> NormalizesToTermHack<'db> {
+    /// Relate the `term` with the new `unconstrained_term` created
+    /// when computing the proof tree for this `NormalizesTo` goals.
+    /// This handles nested obligations.
+    fn constrain_and(
+        &self,
+        infcx: &InferCtxt<'db>,
+        param_env: ParamEnv<'db>,
+        f: impl FnOnce(&mut ObligationCtxt<'_, 'db>),
+    ) -> Result<Certainty, NoSolution> {
+        let mut ocx = ObligationCtxt::new(infcx);
+        ocx.eq(&ObligationCause::dummy(), param_env, self.term, self.unconstrained_term)?;
+        f(&mut ocx);
+        let errors = ocx.select_all_or_error();
+        if errors.is_empty() {
+            Ok(Certainty::Yes)
+        } else if errors.iter().all(|e| !matches!(e, NextSolverError::TrueError(_))) {
+            Ok(Certainty::AMBIGUOUS)
+        } else {
+            Err(NoSolution)
+        }
+    }
+}
+
+pub struct InspectCandidate<'a, 'db> {
+    goal: &'a InspectGoal<'a, 'db>,
+    kind: inspect::ProbeKind<DbInterner<'db>>,
+    steps: Vec<&'a inspect::ProbeStep<DbInterner<'db>>>,
+    final_state: inspect::CanonicalState<DbInterner<'db>, ()>,
+    result: QueryResult<'db>,
+    shallow_certainty: Certainty,
+}
+
+impl<'a, 'db> InspectCandidate<'a, 'db> {
+    pub fn kind(&self) -> inspect::ProbeKind<DbInterner<'db>> {
+        self.kind
+    }
+
+    pub fn result(&self) -> Result<Certainty, NoSolution> {
+        self.result.map(|c| c.value.certainty)
+    }
+
+    pub fn goal(&self) -> &'a InspectGoal<'a, 'db> {
+        self.goal
+    }
+
+    /// Certainty passed into `evaluate_added_goals_and_make_canonical_response`.
+    ///
+    /// If this certainty is `Yes`, then we must be confident that the candidate
+    /// must hold iff it's nested goals hold. This is not true if the certainty is
+    /// `Maybe(..)`, which suggests we forced ambiguity instead.
+    ///
+    /// This is *not* the certainty of the candidate's full nested evaluation, which
+    /// can be accessed with [`Self::result`] instead.
+    pub fn shallow_certainty(&self) -> Certainty {
+        self.shallow_certainty
+    }
+
+    /// Visit all nested goals of this candidate without rolling
+    /// back their inference constraints. This function modifies
+    /// the state of the `infcx`.
+    pub fn visit_nested_no_probe<V: ProofTreeVisitor<'db>>(&self, visitor: &mut V) -> V::Result {
+        for goal in self.instantiate_nested_goals() {
+            try_visit!(goal.visit_with(visitor));
+        }
+
+        V::Result::output()
+    }
+
+    /// Instantiate the nested goals for the candidate without rolling back their
+    /// inference constraints. This function modifies the state of the `infcx`.
+    ///
+    /// See [`Self::instantiate_impl_args`] if you need the impl args too.
+    pub fn instantiate_nested_goals(&self) -> Vec<InspectGoal<'a, 'db>> {
+        let infcx = self.goal.infcx;
+        let param_env = self.goal.goal.param_env;
+        let mut orig_values = self.goal.orig_values.to_vec();
+
+        let mut instantiated_goals = vec![];
+        for step in &self.steps {
+            match **step {
+                inspect::ProbeStep::AddGoal(source, goal) => instantiated_goals.push((
+                    source,
+                    instantiate_canonical_state(
+                        infcx,
+                        Span::dummy(),
+                        param_env,
+                        &mut orig_values,
+                        goal,
+                    ),
+                )),
+                inspect::ProbeStep::RecordImplArgs { .. } => {}
+                inspect::ProbeStep::MakeCanonicalResponse { .. }
+                | inspect::ProbeStep::NestedProbe(_) => unreachable!(),
+            }
+        }
+
+        let () = instantiate_canonical_state(
+            infcx,
+            Span::dummy(),
+            param_env,
+            &mut orig_values,
+            self.final_state,
+        );
+
+        if let Some(term_hack) = &self.goal.normalizes_to_term_hack {
+            // FIXME: We ignore the expected term of `NormalizesTo` goals
+            // when computing the result of its candidates. This is
+            // scuffed.
+            let _ = term_hack.constrain_and(infcx, param_env, |_| {});
+        }
+
+        instantiated_goals
+            .into_iter()
+            .map(|(source, goal)| self.instantiate_proof_tree_for_nested_goal(source, goal))
+            .collect()
+    }
+
+    /// Instantiate the args of an impl if this candidate came from a
+    /// `CandidateSource::Impl`. This function modifies the state of the
+    /// `infcx`.
+    pub fn instantiate_impl_args(&self) -> GenericArgs<'db> {
+        let infcx = self.goal.infcx;
+        let param_env = self.goal.goal.param_env;
+        let mut orig_values = self.goal.orig_values.to_vec();
+
+        for step in &self.steps {
+            match **step {
+                inspect::ProbeStep::RecordImplArgs { impl_args } => {
+                    let impl_args = instantiate_canonical_state(
+                        infcx,
+                        Span::dummy(),
+                        param_env,
+                        &mut orig_values,
+                        impl_args,
+                    );
+
+                    let () = instantiate_canonical_state(
+                        infcx,
+                        Span::dummy(),
+                        param_env,
+                        &mut orig_values,
+                        self.final_state,
+                    );
+
+                    // No reason we couldn't support this, but we don't need to for select.
+                    assert!(
+                        self.goal.normalizes_to_term_hack.is_none(),
+                        "cannot use `instantiate_impl_args` with a `NormalizesTo` goal"
+                    );
+
+                    return eager_resolve_vars(infcx, impl_args);
+                }
+                inspect::ProbeStep::AddGoal(..) => {}
+                inspect::ProbeStep::MakeCanonicalResponse { .. }
+                | inspect::ProbeStep::NestedProbe(_) => unreachable!(),
+            }
+        }
+
+        panic!("expected impl args probe step for `instantiate_impl_args`");
+    }
+
+    pub fn instantiate_proof_tree_for_nested_goal(
+        &self,
+        source: GoalSource,
+        goal: Goal<'db, Predicate<'db>>,
+    ) -> InspectGoal<'a, 'db> {
+        let infcx = self.goal.infcx;
+        match goal.predicate.kind().no_bound_vars() {
+            Some(PredicateKind::NormalizesTo(NormalizesTo { alias, term })) => {
+                let unconstrained_term = infcx.next_term_var_of_kind(term);
+                let goal =
+                    goal.with(infcx.interner, NormalizesTo { alias, term: unconstrained_term });
+                // We have to use a `probe` here as evaluating a `NormalizesTo` can constrain the
+                // expected term. This means that candidates which only fail due to nested goals
+                // and which normalize to a different term then the final result could ICE: when
+                // building their proof tree, the expected term was unconstrained, but when
+                // instantiating the candidate it is already constrained to the result of another
+                // candidate.
+                let normalizes_to_term_hack = NormalizesToTermHack { term, unconstrained_term };
+                let (proof_tree, nested_goals_result) = infcx.probe(|_| {
+                    // Here, if we have any nested goals, then we make sure to apply them
+                    // considering the constrained RHS, and pass the resulting certainty to
+                    // `InspectGoal::new` so that the goal has the right result (and maintains
+                    // the impression that we don't do this normalizes-to infer hack at all).
+                    let (nested, proof_tree) =
+                        infcx.evaluate_root_goal_for_proof_tree(goal, Span::dummy());
+                    let nested_goals_result = nested.and_then(|nested| {
+                        normalizes_to_term_hack.constrain_and(
+                            infcx,
+                            proof_tree.uncanonicalized_goal.param_env,
+                            |ocx| {
+                                ocx.register_obligations(nested.0.into_iter().map(|(_, goal)| {
+                                    Obligation::new(
+                                        infcx.interner,
+                                        ObligationCause::dummy(),
+                                        goal.param_env,
+                                        goal.predicate,
+                                    )
+                                }));
+                            },
+                        )
+                    });
+                    (proof_tree, nested_goals_result)
+                });
+                InspectGoal::new(
+                    infcx,
+                    self.goal.depth + 1,
+                    proof_tree,
+                    Some((normalizes_to_term_hack, nested_goals_result)),
+                    source,
+                )
+            }
+            _ => {
+                // We're using a probe here as evaluating a goal could constrain
+                // inference variables by choosing one candidate. If we then recurse
+                // into another candidate who ends up with different inference
+                // constraints, we get an ICE if we already applied the constraints
+                // from the chosen candidate.
+                let proof_tree =
+                    infcx.probe(|_| infcx.evaluate_root_goal_for_proof_tree(goal, Span::dummy()).1);
+                InspectGoal::new(infcx, self.goal.depth + 1, proof_tree, None, source)
+            }
+        }
+    }
+
+    /// Visit all nested goals of this candidate, rolling back
+    /// all inference constraints.
+    pub fn visit_nested_in_probe<V: ProofTreeVisitor<'db>>(&self, visitor: &mut V) -> V::Result {
+        self.goal.infcx.probe(|_| self.visit_nested_no_probe(visitor))
+    }
+}
+
+impl<'a, 'db> InspectGoal<'a, 'db> {
+    pub fn infcx(&self) -> &'a InferCtxt<'db> {
+        self.infcx
+    }
+
+    pub fn goal(&self) -> Goal<'db, Predicate<'db>> {
+        self.goal
+    }
+
+    pub fn result(&self) -> Result<Certainty, NoSolution> {
+        self.result
+    }
+
+    pub fn source(&self) -> GoalSource {
+        self.source
+    }
+
+    pub fn depth(&self) -> usize {
+        self.depth
+    }
+
+    fn candidates_recur(
+        &'a self,
+        candidates: &mut Vec<InspectCandidate<'a, 'db>>,
+        steps: &mut Vec<&'a inspect::ProbeStep<DbInterner<'db>>>,
+        probe: &'a inspect::Probe<DbInterner<'db>>,
+    ) {
+        let mut shallow_certainty = None;
+        for step in &probe.steps {
+            match *step {
+                inspect::ProbeStep::AddGoal(..) | inspect::ProbeStep::RecordImplArgs { .. } => {
+                    steps.push(step)
+                }
+                inspect::ProbeStep::MakeCanonicalResponse { shallow_certainty: c } => {
+                    assert!(matches!(
+                        shallow_certainty.replace(c),
+                        None | Some(Certainty::Maybe(MaybeCause::Ambiguity))
+                    ));
+                }
+                inspect::ProbeStep::NestedProbe(ref probe) => {
+                    match probe.kind {
+                        // These never assemble candidates for the goal we're trying to solve.
+                        inspect::ProbeKind::ProjectionCompatibility
+                        | inspect::ProbeKind::ShadowedEnvProbing => continue,
+
+                        inspect::ProbeKind::NormalizedSelfTyAssembly
+                        | inspect::ProbeKind::UnsizeAssembly
+                        | inspect::ProbeKind::Root { .. }
+                        | inspect::ProbeKind::TraitCandidate { .. }
+                        | inspect::ProbeKind::OpaqueTypeStorageLookup { .. }
+                        | inspect::ProbeKind::RigidAlias { .. } => {
+                            // Nested probes have to prove goals added in their parent
+                            // but do not leak them, so we truncate the added goals
+                            // afterwards.
+                            let num_steps = steps.len();
+                            self.candidates_recur(candidates, steps, probe);
+                            steps.truncate(num_steps);
+                        }
+                    }
+                }
+            }
+        }
+
+        match probe.kind {
+            inspect::ProbeKind::ProjectionCompatibility
+            | inspect::ProbeKind::ShadowedEnvProbing => {
+                panic!()
+            }
+
+            inspect::ProbeKind::NormalizedSelfTyAssembly | inspect::ProbeKind::UnsizeAssembly => {}
+
+            // We add a candidate even for the root evaluation if there
+            // is only one way to prove a given goal, e.g. for `WellFormed`.
+            inspect::ProbeKind::Root { result }
+            | inspect::ProbeKind::TraitCandidate { source: _, result }
+            | inspect::ProbeKind::OpaqueTypeStorageLookup { result }
+            | inspect::ProbeKind::RigidAlias { result } => {
+                // We only add a candidate if `shallow_certainty` was set, which means
+                // that we ended up calling `evaluate_added_goals_and_make_canonical_response`.
+                if let Some(shallow_certainty) = shallow_certainty {
+                    candidates.push(InspectCandidate {
+                        goal: self,
+                        kind: probe.kind,
+                        steps: steps.clone(),
+                        final_state: probe.final_state,
+                        shallow_certainty,
+                        result,
+                    });
+                }
+            }
+        }
+    }
+
+    pub fn candidates(&'a self) -> Vec<InspectCandidate<'a, 'db>> {
+        let mut candidates = vec![];
+        let mut nested_goals = vec![];
+        self.candidates_recur(&mut candidates, &mut nested_goals, &self.final_revision);
+        candidates
+    }
+
+    /// Returns the single candidate applicable for the current goal, if it exists.
+    ///
+    /// Returns `None` if there are either no or multiple applicable candidates.
+    pub fn unique_applicable_candidate(&'a self) -> Option<InspectCandidate<'a, 'db>> {
+        // FIXME(-Znext-solver): This does not handle impl candidates
+        // hidden by env candidates.
+        let mut candidates = self.candidates();
+        candidates.retain(|c| c.result().is_ok());
+        candidates.pop().filter(|_| candidates.is_empty())
+    }
+
+    fn new(
+        infcx: &'a InferCtxt<'db>,
+        depth: usize,
+        root: inspect::GoalEvaluation<DbInterner<'db>>,
+        term_hack_and_nested_certainty: Option<(
+            NormalizesToTermHack<'db>,
+            Result<Certainty, NoSolution>,
+        )>,
+        source: GoalSource,
+    ) -> Self {
+        let infcx = <&SolverContext<'db>>::from(infcx);
+
+        let inspect::GoalEvaluation { uncanonicalized_goal, orig_values, final_revision, result } =
+            root;
+        // If there's a normalizes-to goal, AND the evaluation result with the result of
+        // constraining the normalizes-to RHS and computing the nested goals.
+        let result = result.and_then(|ok| {
+            let nested_goals_certainty =
+                term_hack_and_nested_certainty.map_or(Ok(Certainty::Yes), |(_, c)| c)?;
+            Ok(ok.value.certainty.and(nested_goals_certainty))
+        });
+
+        InspectGoal {
+            infcx,
+            depth,
+            orig_values,
+            goal: eager_resolve_vars(infcx, uncanonicalized_goal),
+            result,
+            final_revision,
+            normalizes_to_term_hack: term_hack_and_nested_certainty.map(|(n, _)| n),
+            source,
+        }
+    }
+
+    pub(crate) fn visit_with<V: ProofTreeVisitor<'db>>(&self, visitor: &mut V) -> V::Result {
+        if self.depth < visitor.config().max_depth {
+            try_visit!(visitor.visit_goal(self));
+        }
+
+        V::Result::output()
+    }
+}
+
+/// The public API to interact with proof trees.
+pub trait ProofTreeVisitor<'db> {
+    type Result: VisitorResult;
+
+    fn config(&self) -> InspectConfig {
+        InspectConfig { max_depth: 10 }
+    }
+
+    fn visit_goal(&mut self, goal: &InspectGoal<'_, 'db>) -> Self::Result;
+}
+
+impl<'db> InferCtxt<'db> {
+    pub(crate) fn visit_proof_tree<V: ProofTreeVisitor<'db>>(
+        &self,
+        goal: Goal<'db, Predicate<'db>>,
+        visitor: &mut V,
+    ) -> V::Result {
+        self.visit_proof_tree_at_depth(goal, 0, visitor)
+    }
+
+    pub(crate) fn visit_proof_tree_at_depth<V: ProofTreeVisitor<'db>>(
+        &self,
+        goal: Goal<'db, Predicate<'db>>,
+        depth: usize,
+        visitor: &mut V,
+    ) -> V::Result {
+        let (_, proof_tree) = <&SolverContext<'db>>::from(self)
+            .evaluate_root_goal_for_proof_tree(goal, Span::dummy());
+        visitor.visit_goal(&InspectGoal::new(self, depth, proof_tree, None, GoalSource::Misc))
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
index 7b6e8a1073d78..8f731b06fa197 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
@@ -48,8 +48,8 @@ use crate::next_solver::infer::InferCtxt;
 use crate::next_solver::util::{ContainsTypeErrors, explicit_item_bounds, for_trait_impls};
 use crate::next_solver::{
     AdtIdWrapper, BoundConst, CallableIdWrapper, CanonicalVarKind, ClosureIdWrapper,
-    CoroutineIdWrapper, FxIndexMap, ImplIdWrapper, InternedWrapperNoDebug, RegionAssumptions,
-    SolverContext, SolverDefIds, TraitIdWrapper, TypeAliasIdWrapper,
+    CoroutineIdWrapper, Ctor, FnSig, FxIndexMap, ImplIdWrapper, InternedWrapperNoDebug,
+    RegionAssumptions, SolverContext, SolverDefIds, TraitIdWrapper, TypeAliasIdWrapper,
 };
 use crate::{ConstScalar, FnAbi, Interner, db::HirDatabase};
 
@@ -1055,60 +1055,62 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
     }
 
     fn variances_of(self, def_id: Self::DefId) -> Self::VariancesOf {
-        match def_id {
-            SolverDefId::FunctionId(def_id) => VariancesOf::new_from_iter(
-                self,
-                self.db()
-                    .variances_of(hir_def::GenericDefId::FunctionId(def_id))
-                    .as_deref()
-                    .unwrap_or_default()
-                    .iter()
-                    .map(|v| v.to_nextsolver(self)),
-            ),
-            SolverDefId::AdtId(def_id) => VariancesOf::new_from_iter(
-                self,
-                self.db()
-                    .variances_of(hir_def::GenericDefId::AdtId(def_id))
-                    .as_deref()
-                    .unwrap_or_default()
-                    .iter()
-                    .map(|v| v.to_nextsolver(self)),
-            ),
+        let generic_def = match def_id {
+            SolverDefId::FunctionId(def_id) => def_id.into(),
+            SolverDefId::AdtId(def_id) => def_id.into(),
+            SolverDefId::Ctor(Ctor::Struct(def_id)) => def_id.into(),
+            SolverDefId::Ctor(Ctor::Enum(def_id)) => def_id.loc(self.db).parent.into(),
             SolverDefId::InternedOpaqueTyId(_def_id) => {
                 // FIXME(next-solver): track variances
                 //
                 // We compute them based on the only `Ty` level info in rustc,
                 // move `variances_of_opaque` into `rustc_next_trait_solver` for reuse.
-                VariancesOf::new_from_iter(
+                return VariancesOf::new_from_iter(
                     self,
                     (0..self.generics_of(def_id).count()).map(|_| Variance::Invariant),
-                )
+                );
             }
-            _ => VariancesOf::new_from_iter(self, []),
-        }
+            _ => return VariancesOf::new_from_iter(self, []),
+        };
+        VariancesOf::new_from_iter(
+            self,
+            self.db()
+                .variances_of(generic_def)
+                .as_deref()
+                .unwrap_or_default()
+                .iter()
+                .map(|v| v.to_nextsolver(self)),
+        )
     }
 
     fn type_of(self, def_id: Self::DefId) -> EarlyBinder<Self, Self::Ty> {
-        let def_id = match def_id {
+        match def_id {
             SolverDefId::TypeAliasId(id) => {
                 use hir_def::Lookup;
                 match id.lookup(self.db()).container {
                     ItemContainerId::ImplId(it) => it,
                     _ => panic!("assoc ty value should be in impl"),
                 };
-                crate::TyDefId::TypeAliasId(id)
+                self.db().ty_ns(id.into())
             }
-            SolverDefId::AdtId(id) => crate::TyDefId::AdtId(id),
+            SolverDefId::AdtId(id) => self.db().ty_ns(id.into()),
             // FIXME(next-solver): This uses the types of `query mir_borrowck` in rustc.
             //
             // We currently always use the type from HIR typeck which ignores regions. This
             // should be fine.
-            SolverDefId::InternedOpaqueTyId(_) => {
-                return self.type_of_opaque_hir_typeck(def_id);
+            SolverDefId::InternedOpaqueTyId(_) => self.type_of_opaque_hir_typeck(def_id),
+            SolverDefId::FunctionId(id) => self.db.value_ty_ns(id.into()).unwrap(),
+            SolverDefId::Ctor(id) => {
+                let id = match id {
+                    Ctor::Struct(id) => id.into(),
+                    Ctor::Enum(id) => id.into(),
+                };
+                self.db
+                    .value_ty_ns(id)
+                    .expect("`SolverDefId::Ctor` should have a function-like ctor")
             }
             _ => panic!("Unexpected def_id `{def_id:?}` provided for `type_of`"),
-        };
-        self.db().ty_ns(def_id)
+        }
     }
 
     fn adt_def(self, def_id: Self::AdtId) -> Self::AdtDef {
@@ -1998,6 +2000,28 @@ impl<'db> DbInterner<'db> {
     ) -> T {
         self.replace_escaping_bound_vars_uncached(value.skip_binder(), delegate)
     }
+
+    pub fn mk_fn_sig<I>(
+        self,
+        inputs: I,
+        output: Ty<'db>,
+        c_variadic: bool,
+        safety: Safety,
+        abi: FnAbi,
+    ) -> FnSig<'db>
+    where
+        I: IntoIterator<Item = Ty<'db>>,
+    {
+        FnSig {
+            inputs_and_output: Tys::new_from_iter(
+                self,
+                inputs.into_iter().chain(std::iter::once(output)),
+            ),
+            c_variadic,
+            safety,
+            abi,
+        }
+    }
 }
 
 macro_rules! TrivialTypeTraversalImpls {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
index eb2cc69167d0d..d8a86ea083e08 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
@@ -147,6 +147,24 @@ pub trait NextSolverToChalk<'db, Out> {
     fn to_chalk(self, interner: DbInterner<'db>) -> Out;
 }
 
+impl NextSolverToChalk<'_, chalk_ir::Mutability> for rustc_ast_ir::Mutability {
+    fn to_chalk(self, interner: DbInterner<'_>) -> chalk_ir::Mutability {
+        match self {
+            rustc_ast_ir::Mutability::Not => chalk_ir::Mutability::Not,
+            rustc_ast_ir::Mutability::Mut => chalk_ir::Mutability::Mut,
+        }
+    }
+}
+
+impl NextSolverToChalk<'_, chalk_ir::Safety> for crate::next_solver::abi::Safety {
+    fn to_chalk(self, interner: DbInterner<'_>) -> chalk_ir::Safety {
+        match self {
+            crate::next_solver::abi::Safety::Unsafe => chalk_ir::Safety::Unsafe,
+            crate::next_solver::abi::Safety::Safe => chalk_ir::Safety::Safe,
+        }
+    }
+}
+
 impl<'db> ChalkToNextSolver<'db, Ty<'db>> for chalk_ir::Ty<Interner> {
     fn to_nextsolver(&self, interner: DbInterner<'db>) -> Ty<'db> {
         Ty::new(
@@ -617,6 +635,15 @@ impl<'db> ChalkToNextSolver<'db, Tys<'db>> for chalk_ir::Substitution<Interner>
     }
 }
 
+impl<'db> NextSolverToChalk<'db, crate::Substitution> for Tys<'db> {
+    fn to_chalk(self, interner: DbInterner<'db>) -> crate::Substitution {
+        Substitution::from_iter(
+            Interner,
+            self.inner().iter().map(|ty| ty.to_chalk(interner).cast(Interner)),
+        )
+    }
+}
+
 impl<'db> ChalkToNextSolver<'db, rustc_type_ir::DebruijnIndex> for chalk_ir::DebruijnIndex {
     fn to_nextsolver(&self, _interner: DbInterner<'db>) -> rustc_type_ir::DebruijnIndex {
         rustc_type_ir::DebruijnIndex::from_u32(self.depth())
@@ -859,6 +886,16 @@ impl<'db> NextSolverToChalk<'db, chalk_ir::Goal<Interner>> for Predicate<'db> {
     }
 }
 
+impl<'db> NextSolverToChalk<'db, crate::ProjectionTy> for crate::next_solver::AliasTy<'db> {
+    fn to_chalk(self, interner: DbInterner<'db>) -> crate::ProjectionTy {
+        let SolverDefId::TypeAliasId(assoc_id) = self.def_id else { unreachable!() };
+        crate::ProjectionTy {
+            associated_ty_id: to_assoc_type_id(assoc_id),
+            substitution: self.args.to_chalk(interner),
+        }
+    }
+}
+
 impl<'db> ChalkToNextSolver<'db, ParamEnv<'db>> for chalk_ir::Environment<Interner> {
     fn to_nextsolver(&self, interner: DbInterner<'db>) -> ParamEnv<'db> {
         let clauses = Clauses::new_from_iter(
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/project/solve_normalize.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/normalize.rs
similarity index 87%
rename from src/tools/rust-analyzer/crates/hir-ty/src/next_solver/project/solve_normalize.rs
rename to src/tools/rust-analyzer/crates/hir-ty/src/next_solver/normalize.rs
index 42c238febf6f6..41cb4884404f1 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/project/solve_normalize.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/normalize.rs
@@ -1,35 +1,23 @@
-//! Normalization within a next-solver infer context.
-
-use std::fmt::Debug;
-
 use rustc_next_trait_solver::placeholder::BoundVarReplacer;
 use rustc_type_ir::{
     AliasRelationDirection, FallibleTypeFolder, Flags, Interner, TermKind, TypeFoldable,
     TypeFolder, TypeSuperFoldable, TypeVisitableExt, UniverseIndex,
-    inherent::{IntoKind, Span as _, Term as _},
+    inherent::{IntoKind, Term as _},
 };
 
+use crate::next_solver::SolverDefId;
 use crate::next_solver::{
-    Binder, Const, ConstKind, DbInterner, Goal, ParamEnv, Predicate, PredicateKind, Span, Term, Ty,
-    TyKind, TypingMode,
+    Binder, Const, ConstKind, DbInterner, Goal, ParamEnv, Predicate, PredicateKind, Term, Ty,
+    TyKind,
     fulfill::{FulfillmentCtxt, NextSolverError},
     infer::{
-        DbInternerInferExt, InferCtxt,
+        InferCtxt,
         at::At,
         traits::{Obligation, ObligationCause},
     },
     util::PlaceholderReplacer,
 };
 
-pub fn normalize<'db, T>(interner: DbInterner<'db>, param_env: ParamEnv<'db>, value: T) -> T
-where
-    T: TypeFoldable<DbInterner<'db>>,
-{
-    let infer_ctxt = interner.infer_ctxt().build(TypingMode::non_body_analysis());
-    let cause = ObligationCause::dummy();
-    deeply_normalize(infer_ctxt.at(&cause, param_env), value.clone()).unwrap_or(value)
-}
-
 /// Deeply normalize all aliases in `value`. This does not handle inference and expects
 /// its input to be already fully resolved.
 pub fn deeply_normalize<'db, T>(at: At<'_, 'db>, value: T) -> Result<T, Vec<NextSolverError<'db>>>
@@ -81,10 +69,16 @@ where
     T: TypeFoldable<DbInterner<'db>>,
 {
     let fulfill_cx = FulfillmentCtxt::new(at.infcx);
-    let mut folder = NormalizationFolder { at, fulfill_cx, depth: 0, universes };
+    let mut folder = NormalizationFolder {
+        at,
+        fulfill_cx,
+        depth: 0,
+        universes,
+        stalled_coroutine_goals: vec![],
+    };
     let value = value.try_fold_with(&mut folder)?;
     let errors = folder.fulfill_cx.select_all_or_error(at.infcx);
-    if errors.is_empty() { Ok((value, vec![])) } else { Err(errors) }
+    if errors.is_empty() { Ok((value, folder.stalled_coroutine_goals)) } else { Err(errors) }
 }
 
 struct NormalizationFolder<'me, 'db> {
@@ -92,6 +86,7 @@ struct NormalizationFolder<'me, 'db> {
     fulfill_cx: FulfillmentCtxt<'db>,
     depth: usize,
     universes: Vec<Option<UniverseIndex>>,
+    stalled_coroutine_goals: Vec<Goal<'db, Predicate<'db>>>,
 }
 
 impl<'db> NormalizationFolder<'_, 'db> {
@@ -100,22 +95,30 @@ impl<'db> NormalizationFolder<'_, 'db> {
         alias_term: Term<'db>,
     ) -> Result<Term<'db>, Vec<NextSolverError<'db>>> {
         let infcx = self.at.infcx;
-        let tcx = infcx.interner;
-        let recursion_limit = tcx.recursion_limit();
-        if self.depth > recursion_limit {
-            return Err(vec![]);
-        }
+        let interner = infcx.interner;
+        let recursion_limit = interner.recursion_limit();
 
         self.depth += 1;
 
         let infer_term = infcx.next_term_var_of_kind(alias_term);
         let obligation = Obligation::new(
-            tcx,
+            interner,
             self.at.cause.clone(),
             self.at.param_env,
             PredicateKind::AliasRelate(alias_term, infer_term, AliasRelationDirection::Equate),
         );
 
+        if self.depth > recursion_limit {
+            //     let term = alias_term.to_alias_term().unwrap();
+            //     self.at.infcx.err_ctxt().report_overflow_error(
+            //         OverflowCause::DeeplyNormalize(term),
+            //         self.at.cause.span,
+            //         true,
+            //         |_| {},
+            //     );
+            return Err(vec![NextSolverError::Overflow(obligation)]);
+        }
+
         self.fulfill_cx.register_predicate_obligation(infcx, obligation);
         self.select_all_and_stall_coroutine_predicates()?;
 
@@ -140,6 +143,13 @@ impl<'db> NormalizationFolder<'_, 'db> {
             return Err(errors);
         }
 
+        self.stalled_coroutine_goals.extend(
+            self.fulfill_cx
+                .drain_stalled_obligations_for_coroutines(self.at.infcx)
+                .into_iter()
+                .map(|obl| obl.as_goal()),
+        );
+
         let errors = self.fulfill_cx.collect_remaining_errors(self.at.infcx);
         if !errors.is_empty() {
             return Err(errors);
@@ -166,7 +176,6 @@ impl<'db> FallibleTypeFolder<DbInterner<'db>> for NormalizationFolder<'_, 'db> {
         Ok(t)
     }
 
-    #[tracing::instrument(level = "trace", skip(self), ret)]
     fn try_fold_ty(&mut self, ty: Ty<'db>) -> Result<Ty<'db>, Self::Error> {
         let infcx = self.at.infcx;
         debug_assert_eq!(ty, infcx.shallow_resolve(ty));
@@ -193,7 +202,6 @@ impl<'db> FallibleTypeFolder<DbInterner<'db>> for NormalizationFolder<'_, 'db> {
         }
     }
 
-    #[tracing::instrument(level = "trace", skip(self), ret)]
     fn try_fold_const(&mut self, ct: Const<'db>) -> Result<Const<'db>, Self::Error> {
         let infcx = self.at.infcx;
         debug_assert_eq!(ct, infcx.shallow_resolve_const(ct));
@@ -232,8 +240,8 @@ pub(crate) fn deeply_normalize_for_diagnostics<'db, T: TypeFoldable<DbInterner<'
     })
 }
 
-struct DeeplyNormalizeForDiagnosticsFolder<'a, 'db> {
-    at: At<'a, 'db>,
+struct DeeplyNormalizeForDiagnosticsFolder<'a, 'tcx> {
+    at: At<'a, 'tcx>,
 }
 
 impl<'db> TypeFolder<DbInterner<'db>> for DeeplyNormalizeForDiagnosticsFolder<'_, 'db> {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/obligation_ctxt.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/obligation_ctxt.rs
new file mode 100644
index 0000000000000..8e2dc0dec4ed3
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/obligation_ctxt.rs
@@ -0,0 +1,203 @@
+use hir_def::TraitId;
+use rustc_type_ir::relate::Relate;
+use rustc_type_ir::{TypeFoldable, Upcast, Variance};
+
+use crate::next_solver::fulfill::{FulfillmentCtxt, NextSolverError};
+use crate::next_solver::infer::at::ToTrace;
+use crate::next_solver::infer::traits::{
+    Obligation, ObligationCause, PredicateObligation, PredicateObligations,
+};
+use crate::next_solver::infer::{DefineOpaqueTypes, InferCtxt, InferOk, TypeTrace};
+use crate::next_solver::{Const, DbInterner, ParamEnv, Term, TraitRef, Ty, TypeError};
+
+/// Used if you want to have pleasant experience when dealing
+/// with obligations outside of hir or mir typeck.
+pub struct ObligationCtxt<'a, 'db> {
+    pub infcx: &'a InferCtxt<'db>,
+    engine: FulfillmentCtxt<'db>,
+}
+
+impl<'a, 'db> ObligationCtxt<'a, 'db> {
+    pub fn new(infcx: &'a InferCtxt<'db>) -> Self {
+        Self { infcx, engine: FulfillmentCtxt::new(infcx) }
+    }
+}
+
+impl<'a, 'db> ObligationCtxt<'a, 'db> {
+    pub fn register_obligation(&mut self, obligation: PredicateObligation<'db>) {
+        self.engine.register_predicate_obligation(self.infcx, obligation);
+    }
+
+    pub fn register_obligations(
+        &mut self,
+        obligations: impl IntoIterator<Item = PredicateObligation<'db>>,
+    ) {
+        self.engine.register_predicate_obligations(self.infcx, obligations);
+    }
+
+    pub fn register_infer_ok_obligations<T>(&mut self, infer_ok: InferOk<'db, T>) -> T {
+        let InferOk { value, obligations } = infer_ok;
+        self.register_obligations(obligations);
+        value
+    }
+
+    /// Requires that `ty` must implement the trait with `def_id` in
+    /// the given environment. This trait must not have any type
+    /// parameters (except for `Self`).
+    pub fn register_bound(
+        &mut self,
+        cause: ObligationCause,
+        param_env: ParamEnv<'db>,
+        ty: Ty<'db>,
+        def_id: TraitId,
+    ) {
+        let trait_ref = TraitRef::new(self.infcx.interner, def_id.into(), [ty]);
+        self.register_obligation(Obligation {
+            cause,
+            recursion_depth: 0,
+            param_env,
+            predicate: trait_ref.upcast(self.infcx.interner),
+        });
+    }
+
+    pub fn eq<T: ToTrace<'db>>(
+        &mut self,
+        cause: &ObligationCause,
+        param_env: ParamEnv<'db>,
+        expected: T,
+        actual: T,
+    ) -> Result<(), TypeError<'db>> {
+        self.infcx
+            .at(cause, param_env)
+            .eq(DefineOpaqueTypes::Yes, expected, actual)
+            .map(|infer_ok| self.register_infer_ok_obligations(infer_ok))
+    }
+
+    pub fn eq_trace<T: Relate<DbInterner<'db>>>(
+        &mut self,
+        cause: &ObligationCause,
+        param_env: ParamEnv<'db>,
+        trace: TypeTrace<'db>,
+        expected: T,
+        actual: T,
+    ) -> Result<(), TypeError<'db>> {
+        self.infcx
+            .at(cause, param_env)
+            .eq_trace(DefineOpaqueTypes::Yes, trace, expected, actual)
+            .map(|infer_ok| self.register_infer_ok_obligations(infer_ok))
+    }
+
+    /// Checks whether `expected` is a subtype of `actual`: `expected <: actual`.
+    pub fn sub<T: ToTrace<'db>>(
+        &mut self,
+        cause: &ObligationCause,
+        param_env: ParamEnv<'db>,
+        expected: T,
+        actual: T,
+    ) -> Result<(), TypeError<'db>> {
+        self.infcx
+            .at(cause, param_env)
+            .sub(DefineOpaqueTypes::Yes, expected, actual)
+            .map(|infer_ok| self.register_infer_ok_obligations(infer_ok))
+    }
+
+    pub fn relate<T: ToTrace<'db>>(
+        &mut self,
+        cause: &ObligationCause,
+        param_env: ParamEnv<'db>,
+        variance: Variance,
+        expected: T,
+        actual: T,
+    ) -> Result<(), TypeError<'db>> {
+        self.infcx
+            .at(cause, param_env)
+            .relate(DefineOpaqueTypes::Yes, expected, variance, actual)
+            .map(|infer_ok| self.register_infer_ok_obligations(infer_ok))
+    }
+
+    /// Checks whether `expected` is a supertype of `actual`: `expected :> actual`.
+    pub fn sup<T: ToTrace<'db>>(
+        &mut self,
+        cause: &ObligationCause,
+        param_env: ParamEnv<'db>,
+        expected: T,
+        actual: T,
+    ) -> Result<(), TypeError<'db>> {
+        self.infcx
+            .at(cause, param_env)
+            .sup(DefineOpaqueTypes::Yes, expected, actual)
+            .map(|infer_ok| self.register_infer_ok_obligations(infer_ok))
+    }
+
+    /// Computes the least-upper-bound, or mutual supertype, of two values.
+    pub fn lub<T: ToTrace<'db>>(
+        &mut self,
+        cause: &ObligationCause,
+        param_env: ParamEnv<'db>,
+        expected: T,
+        actual: T,
+    ) -> Result<T, TypeError<'db>> {
+        self.infcx
+            .at(cause, param_env)
+            .lub(expected, actual)
+            .map(|infer_ok| self.register_infer_ok_obligations(infer_ok))
+    }
+
+    #[must_use]
+    pub fn select_where_possible(&mut self) -> Vec<NextSolverError<'db>> {
+        self.engine.select_where_possible(self.infcx)
+    }
+
+    #[must_use]
+    pub fn select_all_or_error(&mut self) -> Vec<NextSolverError<'db>> {
+        self.engine.select_all_or_error(self.infcx)
+    }
+
+    /// Returns the not-yet-processed and stalled obligations from the
+    /// `ObligationCtxt`.
+    ///
+    /// Takes ownership of the context as doing operations such as
+    /// [`ObligationCtxt::eq`] afterwards will result in other obligations
+    /// getting ignored. You can make a new `ObligationCtxt` if this
+    /// needs to be done in a loop, for example.
+    #[must_use]
+    pub fn into_pending_obligations(self) -> PredicateObligations<'db> {
+        self.engine.pending_obligations()
+    }
+
+    pub fn deeply_normalize<T: TypeFoldable<DbInterner<'db>>>(
+        &self,
+        cause: &ObligationCause,
+        param_env: ParamEnv<'db>,
+        value: T,
+    ) -> Result<T, Vec<NextSolverError<'db>>> {
+        self.infcx.at(cause, param_env).deeply_normalize(value)
+    }
+
+    pub fn structurally_normalize_ty(
+        &mut self,
+        cause: &ObligationCause,
+        param_env: ParamEnv<'db>,
+        value: Ty<'db>,
+    ) -> Result<Ty<'db>, Vec<NextSolverError<'db>>> {
+        self.infcx.at(cause, param_env).structurally_normalize_ty(value, &mut self.engine)
+    }
+
+    pub fn structurally_normalize_const(
+        &mut self,
+        cause: &ObligationCause,
+        param_env: ParamEnv<'db>,
+        value: Const<'db>,
+    ) -> Result<Const<'db>, Vec<NextSolverError<'db>>> {
+        self.infcx.at(cause, param_env).structurally_normalize_const(value, &mut self.engine)
+    }
+
+    pub fn structurally_normalize_term(
+        &mut self,
+        cause: &ObligationCause,
+        param_env: ParamEnv<'db>,
+        value: Term<'db>,
+    ) -> Result<Term<'db>, Vec<NextSolverError<'db>>> {
+        self.infcx.at(cause, param_env).structurally_normalize_term(value, &mut self.engine)
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/predicate.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/predicate.rs
index c86d3a4aadb22..99b1354b6335f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/predicate.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/predicate.rs
@@ -262,28 +262,6 @@ impl<'db> Predicate<'db> {
 
         Some(Predicate::new(DbInterner::conjure(), kind))
     }
-
-    pub fn as_trait_clause(self) -> Option<PolyTraitPredicate<'db>> {
-        let predicate = self.kind();
-        match predicate.skip_binder() {
-            PredicateKind::Clause(ClauseKind::Trait(t)) => Some(predicate.rebind(t)),
-            PredicateKind::Clause(ClauseKind::Projection(..))
-            | PredicateKind::Clause(ClauseKind::HostEffect(..))
-            | PredicateKind::Clause(ClauseKind::ConstArgHasType(..))
-            | PredicateKind::Clause(ClauseKind::UnstableFeature(_))
-            | PredicateKind::NormalizesTo(..)
-            | PredicateKind::AliasRelate(..)
-            | PredicateKind::Subtype(..)
-            | PredicateKind::Coerce(..)
-            | PredicateKind::Clause(ClauseKind::RegionOutlives(..))
-            | PredicateKind::Clause(ClauseKind::WellFormed(..))
-            | PredicateKind::DynCompatible(..)
-            | PredicateKind::Clause(ClauseKind::TypeOutlives(..))
-            | PredicateKind::Clause(ClauseKind::ConstEvaluatable(..))
-            | PredicateKind::ConstEquate(..)
-            | PredicateKind::Ambiguous => None,
-        }
-    }
 }
 
 // FIXME: should make a "header" in interned_vec
@@ -693,6 +671,12 @@ impl<'db> UpcastFrom<DbInterner<'db>, ty::OutlivesPredicate<DbInterner<'db>, Reg
     }
 }
 
+impl<'db> UpcastFrom<DbInterner<'db>, PolyRegionOutlivesPredicate<'db>> for Predicate<'db> {
+    fn upcast_from(from: PolyRegionOutlivesPredicate<'db>, tcx: DbInterner<'db>) -> Self {
+        from.map_bound(|p| PredicateKind::Clause(ClauseKind::RegionOutlives(p))).upcast(tcx)
+    }
+}
+
 impl<'db> rustc_type_ir::inherent::Predicate<DbInterner<'db>> for Predicate<'db> {
     fn as_clause(self) -> Option<<DbInterner<'db> as rustc_type_ir::Interner>::Clause> {
         match self.kind().skip_binder() {
@@ -730,6 +714,30 @@ impl<'db> rustc_type_ir::inherent::Predicate<DbInterner<'db>> for Predicate<'db>
 }
 
 impl<'db> Predicate<'db> {
+    pub fn as_trait_clause(self) -> Option<PolyTraitPredicate<'db>> {
+        let predicate = self.kind();
+        match predicate.skip_binder() {
+            PredicateKind::Clause(ClauseKind::Trait(t)) => Some(predicate.rebind(t)),
+            _ => None,
+        }
+    }
+
+    pub fn as_projection_clause(self) -> Option<PolyProjectionPredicate<'db>> {
+        let predicate = self.kind();
+        match predicate.skip_binder() {
+            PredicateKind::Clause(ClauseKind::Projection(t)) => Some(predicate.rebind(t)),
+            _ => None,
+        }
+    }
+
+    /// Matches a `PredicateKind::Clause` and turns it into a `Clause`, otherwise returns `None`.
+    pub fn as_clause(self) -> Option<Clause<'db>> {
+        match self.kind().skip_binder() {
+            PredicateKind::Clause(..) => Some(self.expect_clause()),
+            _ => None,
+        }
+    }
+
     /// Assert that the predicate is a clause.
     pub fn expect_clause(self) -> Clause<'db> {
         match self.kind().skip_binder() {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/project.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/project.rs
deleted file mode 100644
index e57808728ae96..0000000000000
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/project.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-//! Projection code for next-solver.
-
-pub(crate) mod solve_normalize;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
index c7591c0c77966..946e57e6cb741 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
@@ -2,6 +2,7 @@
 
 use hir_def::{AssocItemId, GeneralConstId, TypeAliasId};
 use rustc_next_trait_solver::delegate::SolverDelegate;
+use rustc_type_ir::GenericArgKind;
 use rustc_type_ir::lang_items::SolverTraitLangItem;
 use rustc_type_ir::{
     InferCtxtLike, Interner, PredicatePolarity, TypeFlags, TypeVisitableExt, UniverseIndex,
@@ -65,12 +66,12 @@ impl<'db> SolverDelegate for SolverContext<'db> {
         (SolverContext(infcx), value, vars)
     }
 
-    fn fresh_var_for_kind_with_span(
-        &self,
-        arg: <Self::Interner as rustc_type_ir::Interner>::GenericArg,
-        span: <Self::Interner as rustc_type_ir::Interner>::Span,
-    ) -> <Self::Interner as rustc_type_ir::Interner>::GenericArg {
-        unimplemented!()
+    fn fresh_var_for_kind_with_span(&self, arg: GenericArg<'db>, span: Span) -> GenericArg<'db> {
+        match arg.kind() {
+            GenericArgKind::Lifetime(_) => self.next_region_var().into(),
+            GenericArgKind::Type(_) => self.next_ty_var().into(),
+            GenericArgKind::Const(_) => self.next_const_var().into(),
+        }
     }
 
     fn leak_check(
@@ -92,7 +93,8 @@ impl<'db> SolverDelegate for SolverContext<'db> {
             >,
         >,
     > {
-        unimplemented!()
+        // FIXME(next-solver):
+        None
     }
 
     fn make_deduplicated_outlives_constraints(
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/structural_normalize.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/structural_normalize.rs
new file mode 100644
index 0000000000000..18859d8b79707
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/structural_normalize.rs
@@ -0,0 +1,57 @@
+use rustc_type_ir::{AliasRelationDirection, inherent::Term as _};
+
+use crate::next_solver::{
+    Const, PredicateKind, Term, Ty,
+    fulfill::{FulfillmentCtxt, NextSolverError},
+    infer::{at::At, traits::Obligation},
+};
+
+impl<'db> At<'_, 'db> {
+    pub(crate) fn structurally_normalize_ty(
+        &self,
+        ty: Ty<'db>,
+        fulfill_cx: &mut FulfillmentCtxt<'db>,
+    ) -> Result<Ty<'db>, Vec<NextSolverError<'db>>> {
+        self.structurally_normalize_term(ty.into(), fulfill_cx).map(|term| term.expect_type())
+    }
+
+    pub(crate) fn structurally_normalize_const(
+        &self,
+        ct: Const<'db>,
+        fulfill_cx: &mut FulfillmentCtxt<'db>,
+    ) -> Result<Const<'db>, Vec<NextSolverError<'db>>> {
+        self.structurally_normalize_term(ct.into(), fulfill_cx).map(|term| term.expect_const())
+    }
+
+    pub(crate) fn structurally_normalize_term(
+        &self,
+        term: Term<'db>,
+        fulfill_cx: &mut FulfillmentCtxt<'db>,
+    ) -> Result<Term<'db>, Vec<NextSolverError<'db>>> {
+        assert!(!term.is_infer(), "should have resolved vars before calling");
+
+        if term.to_alias_term().is_none() {
+            return Ok(term);
+        }
+
+        let new_infer = self.infcx.next_term_var_of_kind(term);
+
+        // We simply emit an `alias-eq` goal here, since that will take care of
+        // normalizing the LHS of the projection until it is a rigid projection
+        // (or a not-yet-defined opaque in scope).
+        let obligation = Obligation::new(
+            self.infcx.interner,
+            self.cause.clone(),
+            self.param_env,
+            PredicateKind::AliasRelate(term, new_infer, AliasRelationDirection::Equate),
+        );
+
+        fulfill_cx.register_predicate_obligation(self.infcx, obligation);
+        let errors = fulfill_cx.select_where_possible(self.infcx);
+        if !errors.is_empty() {
+            return Err(errors);
+        }
+
+        Ok(self.infcx.resolve_vars_if_possible(new_infer))
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
index e1c29160ad1ae..e6c444d0d6bed 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
@@ -1,17 +1,19 @@
 //! Things related to tys in the next-trait-solver.
 
+use std::iter;
+use std::ops::ControlFlow;
+
 use hir_def::{GenericDefId, TypeOrConstParamId, TypeParamId};
 use intern::{Interned, Symbol, sym};
 use rustc_abi::{Float, Integer, Size};
 use rustc_ast_ir::{Mutability, try_visit, visit::VisitorResult};
-use rustc_type_ir::Interner;
 use rustc_type_ir::{
-    BoundVar, ClosureKind, FlagComputation, Flags, FloatTy, FloatVid, InferTy, IntTy, IntVid,
-    TypeFoldable, TypeSuperFoldable, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, UintTy,
-    WithCachedTypeInfo,
+    BoundVar, ClosureKind, CollectAndApply, FlagComputation, Flags, FloatTy, FloatVid, InferTy,
+    IntTy, IntVid, Interner, TypeFoldable, TypeSuperFoldable, TypeSuperVisitable, TypeVisitable,
+    TypeVisitableExt, TypeVisitor, UintTy, WithCachedTypeInfo,
     inherent::{
-        AdtDef, BoundVarLike, GenericArgs as _, IntoKind, ParamLike, PlaceholderLike, SliceLike,
-        Ty as _,
+        Abi, AdtDef, BoundVarLike, Const as _, GenericArgs as _, IntoKind, ParamLike,
+        PlaceholderLike, Safety as _, SliceLike, Ty as _,
     },
     relate::Relate,
     solve::SizedTraitKind,
@@ -20,13 +22,16 @@ use rustc_type_ir::{
 use salsa::plumbing::{AsId, FromId};
 use smallvec::SmallVec;
 
-use crate::next_solver::{
-    CallableIdWrapper, ClosureIdWrapper, CoroutineIdWrapper, GenericArg, TypeAliasIdWrapper,
-};
 use crate::{
+    FnAbi,
     db::HirDatabase,
     interner::InternedWrapperNoDebug,
-    next_solver::util::{CoroutineArgsExt, IntegerTypeExt},
+    next_solver::{
+        CallableIdWrapper, ClosureIdWrapper, Const, CoroutineIdWrapper, FnSig, GenericArg,
+        PolyFnSig, TypeAliasIdWrapper,
+        abi::Safety,
+        util::{CoroutineArgsExt, IntegerTypeExt},
+    },
 };
 
 use super::{
@@ -310,6 +315,68 @@ impl<'db> Ty<'db> {
             | TyKind::Error(_) => false,
         }
     }
+
+    #[inline]
+    pub fn is_never(self) -> bool {
+        matches!(self.kind(), TyKind::Never)
+    }
+
+    #[inline]
+    pub fn is_infer(self) -> bool {
+        matches!(self.kind(), TyKind::Infer(..))
+    }
+
+    #[inline]
+    pub fn is_str(self) -> bool {
+        matches!(self.kind(), TyKind::Str)
+    }
+
+    #[inline]
+    pub fn is_unit(self) -> bool {
+        matches!(self.kind(), TyKind::Tuple(tys) if tys.inner().is_empty())
+    }
+
+    /// Given a `fn` type, returns an equivalent `unsafe fn` type;
+    /// that is, a `fn` type that is equivalent in every way for being
+    /// unsafe.
+    pub fn safe_to_unsafe_fn_ty(interner: DbInterner<'db>, sig: PolyFnSig<'db>) -> Ty<'db> {
+        assert!(sig.safety().is_safe());
+        Ty::new_fn_ptr(interner, sig.map_bound(|sig| FnSig { safety: Safety::Unsafe, ..sig }))
+    }
+
+    /// Returns the type of `*ty`.
+    ///
+    /// The parameter `explicit` indicates if this is an *explicit* dereference.
+    /// Some types -- notably raw ptrs -- can only be dereferenced explicitly.
+    pub fn builtin_deref(self, db: &dyn HirDatabase, explicit: bool) -> Option<Ty<'db>> {
+        match self.kind() {
+            TyKind::Adt(adt, substs) if crate::lang_items::is_box(db, adt.def_id().0) => {
+                Some(substs.as_slice()[0].expect_ty())
+            }
+            TyKind::Ref(_, ty, _) => Some(ty),
+            TyKind::RawPtr(ty, _) if explicit => Some(ty),
+            _ => None,
+        }
+    }
+
+    /// Whether the type contains some non-lifetime, aka. type or const, error type.
+    pub fn references_non_lt_error(self) -> bool {
+        self.references_error() && self.visit_with(&mut ReferencesNonLifetimeError).is_break()
+    }
+}
+
+struct ReferencesNonLifetimeError;
+
+impl<'db> TypeVisitor<DbInterner<'db>> for ReferencesNonLifetimeError {
+    type Result = ControlFlow<()>;
+
+    fn visit_ty(&mut self, ty: Ty<'db>) -> Self::Result {
+        if ty.is_ty_error() { ControlFlow::Break(()) } else { ty.super_visit_with(self) }
+    }
+
+    fn visit_const(&mut self, c: Const<'db>) -> Self::Result {
+        if c.is_ct_error() { ControlFlow::Break(()) } else { c.super_visit_with(self) }
+    }
 }
 
 impl<'db> std::fmt::Debug for Ty<'db> {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/util.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/util.rs
index 97d3ea72c93cb..a50f20a565ee2 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/util.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/util.rs
@@ -409,8 +409,7 @@ pub(crate) fn for_trait_impls(
     // Note: Since we're using `impls_for_trait` and `impl_provided_for`,
     // only impls where the trait can be resolved should ever reach Chalk.
     // `impl_datum` relies on that and will panic if the trait can't be resolved.
-    let in_deps = db.trait_impls_in_deps(krate);
-    let in_self = db.trait_impls_in_crate(krate);
+    let in_self_and_deps = db.trait_impls_in_deps(krate);
     let trait_module = trait_id.module(db);
     let type_module = match self_ty_fp {
         Some(TyFingerprint::Adt(adt_id)) => Some(adt_id.module(db)),
@@ -435,8 +434,7 @@ pub(crate) fn for_trait_impls(
         });
     })
     .filter_map(|block_id| db.trait_impls_in_block(block_id));
-    f(&in_self)?;
-    for it in in_deps.iter().map(ops::Deref::deref) {
+    for it in in_self_and_deps.iter().map(ops::Deref::deref) {
         f(it)?;
     }
     for it in block_impls {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/target_feature.rs b/src/tools/rust-analyzer/crates/hir-ty/src/target_feature.rs
index 9d1238701bcfa..0a8ed2cf0cabd 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/target_feature.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/target_feature.rs
@@ -7,7 +7,7 @@ use hir_def::tt;
 use intern::{Symbol, sym};
 use rustc_hash::{FxHashMap, FxHashSet};
 
-#[derive(Debug, Default)]
+#[derive(Debug, Default, Clone)]
 pub struct TargetFeatures {
     pub(crate) enabled: FxHashSet<Symbol>,
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/coercion.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/coercion.rs
index 7ec5231a7341a..1735f550b8ad7 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/coercion.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/coercion.rs
@@ -177,21 +177,23 @@ fn test(i: i32) {
 
 #[test]
 fn coerce_merge_one_by_one1() {
-    cov_mark::check!(coerce_merge_fail_fallback);
-
     check(
         r"
 fn test() {
     let t = &mut 1;
     let x = match 1 {
         1 => t as *mut i32,
-           //^^^^^^^^^^^^^ adjustments: Pointer(MutToConstPointer)
+           //^ adjustments: Deref(None), Borrow(RawPtr(Mut))
+        _ => t as *const i32,
+    };
+    x;
+ // ^ type: *const i32
+    let x = match 1 {
+        1 => t as *mut i32,
         2 => t as &i32,
            //^^^^^^^^^ expected *mut i32, got &'? i32
         _ => t as *const i32,
     };
-    x;
-  //^ type: *const i32
 
 }
         ",
@@ -276,17 +278,19 @@ fn test() {
 fn coerce_autoderef_implication_1() {
     check_no_mismatches(
         r"
-//- minicore: deref
-struct Foo<T>;
+//- minicore: deref, phantom_data
+use core::marker::PhantomData;
+
+struct Foo<T>(PhantomData<T>);
 impl core::ops::Deref for Foo<u32> { type Target = (); }
 
 fn takes_ref_foo<T>(x: &Foo<T>) {}
 fn test() {
-    let foo = Foo;
+    let foo = Foo(PhantomData);
       //^^^ type: Foo<{unknown}>
     takes_ref_foo(&foo);
 
-    let foo = Foo;
+    let foo = Foo(PhantomData);
       //^^^ type: Foo<u32>
     let _: &() = &foo;
 }",
@@ -297,16 +301,18 @@ fn test() {
 fn coerce_autoderef_implication_2() {
     check(
         r"
-//- minicore: deref
-struct Foo<T>;
+//- minicore: deref, phantom_data
+use core::marker::PhantomData;
+
+struct Foo<T>(PhantomData<T>);
 impl core::ops::Deref for Foo<u32> { type Target = (); }
 
 fn takes_ref_foo<T>(x: &Foo<T>) {}
 fn test() {
-    let foo = Foo;
+    let foo = Foo(PhantomData);
       //^^^ type: Foo<{unknown}>
-    let _: &u32 = &Foo;
-                //^^^^ expected &'? u32, got &'? Foo<{unknown}>
+    let _: &u32 = &Foo(PhantomData);
+                //^^^^^^^^^^^^^^^^^ expected &'? u32, got &'? Foo<{unknown}>
 }",
     );
 }
@@ -409,8 +415,6 @@ fn test() {
 
 #[test]
 fn coerce_fn_items_in_match_arms() {
-    cov_mark::check!(coerce_fn_reification);
-
     check_no_mismatches(
         r"
 fn foo1(x: u32) -> isize { 1 }
@@ -683,9 +687,9 @@ fn coerce_unsize_expected_type_2() {
     check_no_mismatches(
         r#"
 //- minicore: coerce_unsized
-struct InFile<T>;
+struct InFile<T>(T);
 impl<T> InFile<T> {
-    fn with_value<U>(self, value: U) -> InFile<U> { InFile }
+    fn with_value<U>(self, value: U) -> InFile<U> { InFile(loop {}) }
 }
 struct RecordField;
 trait AstNode {}
@@ -694,7 +698,7 @@ impl AstNode for RecordField {}
 fn takes_dyn(it: InFile<&dyn AstNode>) {}
 
 fn test() {
-    let x: InFile<()> = InFile;
+    let x: InFile<()> = InFile(());
     let n = &RecordField;
     takes_dyn(x.with_value(n));
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/diagnostics.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/diagnostics.rs
index 855034117c0d7..f257aa1b6e602 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/diagnostics.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/diagnostics.rs
@@ -89,7 +89,6 @@ fn test(x: bool) {
       //^^^^ expected (), got &'static str
     }
     match x { true => true, false => 0 }
-  //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected (), got bool
                                    //^ expected bool, got i32
     ()
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
index d79639b93727b..c0b930e5e1231 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
@@ -48,7 +48,6 @@ fn foo() -> i32 {
                 "expr_scopes_shim",
                 "lang_item",
                 "crate_lang_items",
-                "lang_item",
             ]
         "#]],
     );
@@ -138,7 +137,6 @@ fn baz() -> i32 {
                 "crate_lang_items",
                 "attrs_shim",
                 "attrs_shim",
-                "lang_item",
                 "infer_shim",
                 "function_signature_shim",
                 "function_signature_with_source_map_shim",
@@ -588,8 +586,8 @@ fn main() {
                 "crate_lang_items",
                 "attrs_shim",
                 "attrs_shim",
-                "return_type_impl_traits_shim",
                 "generic_predicates_ns_shim",
+                "return_type_impl_traits_shim",
                 "infer_shim",
                 "function_signature_shim",
                 "function_signature_with_source_map_shim",
@@ -602,6 +600,7 @@ fn main() {
                 "VariantFields::firewall_",
                 "VariantFields::query_",
                 "lang_item",
+                "lang_item",
                 "inherent_impls_in_crate_shim",
                 "impl_signature_shim",
                 "impl_signature_with_source_map_shim",
@@ -616,7 +615,6 @@ fn main() {
                 "generic_predicates_ns_shim",
                 "value_ty_shim",
                 "generic_predicates_shim",
-                "lang_item",
             ]
         "#]],
     );
@@ -688,8 +686,8 @@ fn main() {
                 "attrs_shim",
                 "attrs_shim",
                 "attrs_shim",
-                "return_type_impl_traits_shim",
                 "generic_predicates_ns_shim",
+                "return_type_impl_traits_shim",
                 "infer_shim",
                 "function_signature_with_source_map_shim",
                 "expr_scopes_shim",
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/macros.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/macros.rs
index 5d088e40cdeda..25b938c7078aa 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/macros.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/macros.rs
@@ -194,15 +194,15 @@ fn expr_macro_def_expanded_in_various_places() {
             !0..6 '1isize': isize
             !0..6 '1isize': isize
             !0..6 '1isize': isize
-            39..442 '{     ...!(); }': ()
+            39..442 '{     ...!(); }': {unknown}
             73..94 'spam!(...am!())': {unknown}
             100..119 'for _ ...!() {}': fn into_iter<isize>(isize) -> <isize as IntoIterator>::IntoIter
-            100..119 'for _ ...!() {}': {unknown}
+            100..119 'for _ ...!() {}': <isize as IntoIterator>::IntoIter
             100..119 'for _ ...!() {}': !
-            100..119 'for _ ...!() {}': {unknown}
-            100..119 'for _ ...!() {}': &'? mut {unknown}
+            100..119 'for _ ...!() {}': <isize as IntoIterator>::IntoIter
+            100..119 'for _ ...!() {}': &'? mut <isize as IntoIterator>::IntoIter
             100..119 'for _ ...!() {}': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
-            100..119 'for _ ...!() {}': Option<{unknown}>
+            100..119 'for _ ...!() {}': Option<<{unknown} as Iterator>::Item>
             100..119 'for _ ...!() {}': ()
             100..119 'for _ ...!() {}': ()
             100..119 'for _ ...!() {}': ()
@@ -288,15 +288,15 @@ fn expr_macro_rules_expanded_in_various_places() {
             !0..6 '1isize': isize
             !0..6 '1isize': isize
             !0..6 '1isize': isize
-            53..456 '{     ...!(); }': ()
+            53..456 '{     ...!(); }': {unknown}
             87..108 'spam!(...am!())': {unknown}
             114..133 'for _ ...!() {}': fn into_iter<isize>(isize) -> <isize as IntoIterator>::IntoIter
-            114..133 'for _ ...!() {}': {unknown}
+            114..133 'for _ ...!() {}': <isize as IntoIterator>::IntoIter
             114..133 'for _ ...!() {}': !
-            114..133 'for _ ...!() {}': {unknown}
-            114..133 'for _ ...!() {}': &'? mut {unknown}
+            114..133 'for _ ...!() {}': <isize as IntoIterator>::IntoIter
+            114..133 'for _ ...!() {}': &'? mut <isize as IntoIterator>::IntoIter
             114..133 'for _ ...!() {}': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
-            114..133 'for _ ...!() {}': Option<{unknown}>
+            114..133 'for _ ...!() {}': Option<<{unknown} as Iterator>::Item>
             114..133 'for _ ...!() {}': ()
             114..133 'for _ ...!() {}': ()
             114..133 'for _ ...!() {}': ()
@@ -707,7 +707,7 @@ fn infer_builtin_macros_file() {
         expect![[r#"
             !0..6 '"file"': &'static str
             63..87 '{     ...!(); }': ()
-            73..74 'x': &'static str
+            73..74 'x': &'? str
         "#]],
     );
 }
@@ -745,7 +745,7 @@ fn infer_builtin_macros_concat() {
         expect![[r#"
             !0..13 '"helloworld!"': &'static str
             65..121 '{     ...")); }': ()
-            75..76 'x': &'static str
+            75..76 'x': &'? str
         "#]],
     );
 }
@@ -822,7 +822,7 @@ macro_rules! include_str {() => {}}
 fn main() {
     let a = include_str!("foo.rs");
     a;
-} //^ &'static str
+} //^ &'? str
 
 //- /foo.rs
 hello
@@ -849,7 +849,7 @@ macro_rules! m {
 fn main() {
     let a = include_str!(m!(".rs"));
     a;
-} //^ &'static str
+} //^ &'? str
 
 //- /foo.rs
 hello
@@ -964,7 +964,7 @@ fn infer_builtin_macros_concat_with_lazy() {
         expect![[r#"
             !0..13 '"helloworld!"': &'static str
             103..160 '{     ...")); }': ()
-            113..114 'x': &'static str
+            113..114 'x': &'? str
         "#]],
     );
 }
@@ -979,7 +979,7 @@ fn infer_builtin_macros_env() {
 
         fn main() {
             let x = env!("foo");
-              //^ &'static str
+              //^ &'? str
         }
         "#,
     );
@@ -993,7 +993,7 @@ fn infer_builtin_macros_option_env() {
 //- /main.rs env:foo=bar
 fn main() {
     let x = option_env!("foo");
-      //^ Option<&'static str>
+      //^ Option<&'? str>
 }
         "#,
     );
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs
index d50daf0f0d5be..b14ce35aa99c8 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs
@@ -578,17 +578,17 @@ fn infer_trait_assoc_method_generics_3() {
         trait Trait<T> {
             fn make() -> (Self, T);
         }
-        struct S<T>;
+        struct S<T>(T);
         impl Trait<i64> for S<i32> {}
         fn test() {
             let a = S::make();
         }
         "#,
         expect![[r#"
-            100..126 '{     ...e(); }': ()
-            110..111 'a': (S<i32>, i64)
-            114..121 'S::make': fn make<S<i32>, i64>() -> (S<i32>, i64)
-            114..123 'S::make()': (S<i32>, i64)
+            103..129 '{     ...e(); }': ()
+            113..114 'a': (S<i32>, i64)
+            117..124 'S::make': fn make<S<i32>, i64>() -> (S<i32>, i64)
+            117..126 'S::make()': (S<i32>, i64)
         "#]],
     );
 }
@@ -600,7 +600,7 @@ fn infer_trait_assoc_method_generics_4() {
         trait Trait<T> {
             fn make() -> (Self, T);
         }
-        struct S<T>;
+        struct S<T>(T);
         impl Trait<i64> for S<u64> {}
         impl Trait<i32> for S<u32> {}
         fn test() {
@@ -609,13 +609,13 @@ fn infer_trait_assoc_method_generics_4() {
         }
         "#,
         expect![[r#"
-            130..202 '{     ...e(); }': ()
-            140..141 'a': (S<u64>, i64)
-            157..164 'S::make': fn make<S<u64>, i64>() -> (S<u64>, i64)
-            157..166 'S::make()': (S<u64>, i64)
-            176..177 'b': (S<u32>, i32)
-            190..197 'S::make': fn make<S<u32>, i32>() -> (S<u32>, i32)
-            190..199 'S::make()': (S<u32>, i32)
+            133..205 '{     ...e(); }': ()
+            143..144 'a': (S<u64>, i64)
+            160..167 'S::make': fn make<S<u64>, i64>() -> (S<u64>, i64)
+            160..169 'S::make()': (S<u64>, i64)
+            179..180 'b': (S<u32>, i32)
+            193..200 'S::make': fn make<S<u32>, i32>() -> (S<u32>, i32)
+            193..202 'S::make()': (S<u32>, i32)
         "#]],
     );
 }
@@ -627,7 +627,7 @@ fn infer_trait_assoc_method_generics_5() {
         trait Trait<T> {
             fn make<U>() -> (Self, T, U);
         }
-        struct S<T>;
+        struct S<T>(T);
         impl Trait<i64> for S<u64> {}
         fn test() {
             let a = <S as Trait<i64>>::make::<u8>();
@@ -635,13 +635,13 @@ fn infer_trait_assoc_method_generics_5() {
         }
         "#,
         expect![[r#"
-            106..210 '{     ...>(); }': ()
-            116..117 'a': (S<u64>, i64, u8)
-            120..149 '<S as ...::<u8>': fn make<S<u64>, i64, u8>() -> (S<u64>, i64, u8)
-            120..151 '<S as ...<u8>()': (S<u64>, i64, u8)
-            161..162 'b': (S<u64>, i64, u8)
-            181..205 'Trait:...::<u8>': fn make<S<u64>, i64, u8>() -> (S<u64>, i64, u8)
-            181..207 'Trait:...<u8>()': (S<u64>, i64, u8)
+            109..213 '{     ...>(); }': ()
+            119..120 'a': (S<u64>, i64, u8)
+            123..152 '<S as ...::<u8>': fn make<S<u64>, i64, u8>() -> (S<u64>, i64, u8)
+            123..154 '<S as ...<u8>()': (S<u64>, i64, u8)
+            164..165 'b': (S<u64>, i64, u8)
+            184..208 'Trait:...::<u8>': fn make<S<u64>, i64, u8>() -> (S<u64>, i64, u8)
+            184..210 'Trait:...<u8>()': (S<u64>, i64, u8)
         "#]],
     );
 }
@@ -1107,6 +1107,9 @@ fn method_resolution_slow() {
     // this can get quite slow if we set the solver size limit too high
     check_types(
         r#"
+//- minicore: phantom_data
+use core::marker::PhantomData;
+
 trait SendX {}
 
 struct S1; impl SendX for S1 {}
@@ -1115,17 +1118,17 @@ struct U1;
 
 trait Trait { fn method(self); }
 
-struct X1<A, B> {}
+struct X1<A, B>(PhantomData<(A, B)>);
 impl<A, B> SendX for X1<A, B> where A: SendX, B: SendX {}
 
-struct S<B, C> {}
+struct S<B, C>(PhantomData<(B, C)>);
 
 trait FnX {}
 
 impl<B, C> Trait for S<B, C> where C: FnX, B: SendX {}
 
-fn test() { (S {}).method(); }
-          //^^^^^^^^^^^^^^^ ()
+fn test() { (S(PhantomData)).method(); }
+          //^^^^^^^^^^^^^^^^^^^^^^^^^ ()
 "#,
     );
 }
@@ -1187,11 +1190,11 @@ fn test() {
             89..109 '{     ...     }': bool
             99..103 'true': bool
             123..167 '{     ...o(); }': ()
-            133..134 's': &'static S
-            137..151 'unsafe { f() }': &'static S
+            133..134 's': &'? S
+            137..151 'unsafe { f() }': &'? S
             146..147 'f': fn f() -> &'static S
             146..149 'f()': &'static S
-            157..158 's': &'static S
+            157..158 's': &'? S
             157..164 's.foo()': bool
         "#]],
     );
@@ -2191,9 +2194,9 @@ impl Receiver for Bar {
 fn main() {
     let bar = Bar;
     let _v1 = bar.foo1();
-      //^^^ type: {unknown}
+      //^^^ type: i32
     let _v2 = bar.foo2();
-      //^^^ type: {unknown}
+      //^^^ type: bool
 }
 "#,
     );
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/never_type.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/never_type.rs
index 6a9135622deb6..af5290d720356 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/never_type.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/never_type.rs
@@ -14,6 +14,8 @@ fn test() {
     );
 }
 
+// FIXME(next-solver): The never type fallback implemented in r-a no longer works properly because of
+// `Coerce` predicates. We should reimplement fallback like rustc.
 #[test]
 fn infer_never2() {
     check_types(
@@ -24,7 +26,7 @@ fn test() {
     let a = gen();
     if false { a } else { loop {} };
     a;
-} //^ !
+} //^ {unknown}
 "#,
     );
 }
@@ -39,7 +41,7 @@ fn test() {
     let a = gen();
     if false { loop {} } else { a };
     a;
-  //^ !
+  //^ {unknown}
 }
 "#,
     );
@@ -54,7 +56,7 @@ enum Option<T> { None, Some(T) }
 fn test() {
     let a = if true { Option::None } else { Option::Some(return) };
     a;
-} //^ Option<!>
+} //^ Option<{unknown}>
 "#,
     );
 }
@@ -104,7 +106,7 @@ enum Option<T> { None, Some(T) }
 fn test() {
     let a = if true { Option::None } else { Option::Some(return) };
     a;
-  //^ Option<&'static str>
+  //^ Option<&'? str>
     match 42 {
         42 => a,
         _ => Option::Some("str"),
@@ -218,7 +220,7 @@ fn test(a: i32) {
         _ => loop {},
     };
     i;
-} //^ !
+} //^ {unknown}
 "#,
     );
 }
@@ -362,12 +364,12 @@ fn diverging_expression_3_break() {
             140..141 'x': u32
             149..175 '{ for ...; }; }': u32
             151..172 'for a ...eak; }': fn into_iter<{unknown}>({unknown}) -> <{unknown} as IntoIterator>::IntoIter
-            151..172 'for a ...eak; }': {unknown}
+            151..172 'for a ...eak; }': <{unknown} as IntoIterator>::IntoIter
             151..172 'for a ...eak; }': !
             151..172 'for a ...eak; }': {unknown}
             151..172 'for a ...eak; }': &'? mut {unknown}
             151..172 'for a ...eak; }': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
-            151..172 'for a ...eak; }': Option<{unknown}>
+            151..172 'for a ...eak; }': Option<<{unknown} as Iterator>::Item>
             151..172 'for a ...eak; }': ()
             151..172 'for a ...eak; }': ()
             151..172 'for a ...eak; }': ()
@@ -379,12 +381,12 @@ fn diverging_expression_3_break() {
             226..227 'x': u32
             235..253 '{ for ... {}; }': u32
             237..250 'for a in b {}': fn into_iter<{unknown}>({unknown}) -> <{unknown} as IntoIterator>::IntoIter
-            237..250 'for a in b {}': {unknown}
+            237..250 'for a in b {}': <{unknown} as IntoIterator>::IntoIter
             237..250 'for a in b {}': !
             237..250 'for a in b {}': {unknown}
             237..250 'for a in b {}': &'? mut {unknown}
             237..250 'for a in b {}': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
-            237..250 'for a in b {}': Option<{unknown}>
+            237..250 'for a in b {}': Option<<{unknown} as Iterator>::Item>
             237..250 'for a in b {}': ()
             237..250 'for a in b {}': ()
             237..250 'for a in b {}': ()
@@ -395,12 +397,12 @@ fn diverging_expression_3_break() {
             304..305 'x': u32
             313..340 '{ for ...; }; }': u32
             315..337 'for a ...urn; }': fn into_iter<{unknown}>({unknown}) -> <{unknown} as IntoIterator>::IntoIter
-            315..337 'for a ...urn; }': {unknown}
+            315..337 'for a ...urn; }': <{unknown} as IntoIterator>::IntoIter
             315..337 'for a ...urn; }': !
             315..337 'for a ...urn; }': {unknown}
             315..337 'for a ...urn; }': &'? mut {unknown}
             315..337 'for a ...urn; }': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
-            315..337 'for a ...urn; }': Option<{unknown}>
+            315..337 'for a ...urn; }': Option<<{unknown} as Iterator>::Item>
             315..337 'for a ...urn; }': ()
             315..337 'for a ...urn; }': ()
             315..337 'for a ...urn; }': ()
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/opaque_types.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/opaque_types.rs
index 256ca7defb78a..40e4c28fcc0b9 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/opaque_types.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/opaque_types.rs
@@ -158,6 +158,7 @@ static ALIAS: i32 = {
             191..193 '_a': impl Trait + ?Sized
             205..211 'Struct': Struct
             217..218 '5': i32
+            205..211: expected impl Trait + ?Sized, got Struct
         "#]],
     )
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/patterns.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/patterns.rs
index 02cb03706919b..607daada42eb1 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/patterns.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/patterns.rs
@@ -41,19 +41,19 @@ fn infer_pattern() {
             47..48 'x': &'? i32
             58..59 'a': i32
             62..63 'z': i32
-            73..79 '(c, d)': (i32, &'static str)
+            73..79 '(c, d)': (i32, &'? str)
             74..75 'c': i32
-            77..78 'd': &'static str
-            82..94 '(1, "hello")': (i32, &'static str)
+            77..78 'd': &'? str
+            82..94 '(1, "hello")': (i32, &'? str)
             83..84 '1': i32
             86..93 '"hello"': &'static str
             101..151 'for (e...     }': fn into_iter<{unknown}>({unknown}) -> <{unknown} as IntoIterator>::IntoIter
-            101..151 'for (e...     }': {unknown}
+            101..151 'for (e...     }': <{unknown} as IntoIterator>::IntoIter
             101..151 'for (e...     }': !
             101..151 'for (e...     }': {unknown}
             101..151 'for (e...     }': &'? mut {unknown}
             101..151 'for (e...     }': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
-            101..151 'for (e...     }': Option<({unknown}, {unknown})>
+            101..151 'for (e...     }': Option<<{unknown} as Iterator>::Item>
             101..151 'for (e...     }': ()
             101..151 'for (e...     }': ()
             101..151 'for (e...     }': ()
@@ -653,7 +653,7 @@ fn infer_generics_in_patterns() {
 fn infer_const_pattern() {
     check(
         r#"
-enum Option<T> { None }
+enum Option<T> { None, Some(T) }
 use Option::None;
 struct Foo;
 const Bar: usize = 1;
@@ -719,28 +719,28 @@ fn test() {
             51..58 'loop {}': !
             56..58 '{}': ()
             72..171 '{     ... x); }': ()
-            78..81 'foo': fn foo<&'? (i32, &'static str), i32, impl FnOnce(&'? (i32, &'static str)) -> i32>(&'? (i32, &'static str), impl FnOnce(&'? (i32, &'static str)) -> i32) -> i32
+            78..81 'foo': fn foo<&'? (i32, &'? str), i32, impl FnOnce(&'? (i32, &'? str)) -> i32>(&'? (i32, &'? str), impl FnOnce(&'? (i32, &'? str)) -> i32) -> i32
             78..105 'foo(&(...y)| x)': i32
-            82..91 '&(1, "a")': &'? (i32, &'static str)
-            83..91 '(1, "a")': (i32, &'static str)
+            82..91 '&(1, "a")': &'? (i32, &'? str)
+            83..91 '(1, "a")': (i32, &'? str)
             84..85 '1': i32
             87..90 '"a"': &'static str
-            93..104 '|&(x, y)| x': impl FnOnce(&'? (i32, &'static str)) -> i32
-            94..101 '&(x, y)': &'? (i32, &'static str)
-            95..101 '(x, y)': (i32, &'static str)
+            93..104 '|&(x, y)| x': impl FnOnce(&'? (i32, &'? str)) -> i32
+            94..101 '&(x, y)': &'? (i32, &'? str)
+            95..101 '(x, y)': (i32, &'? str)
             96..97 'x': i32
-            99..100 'y': &'static str
+            99..100 'y': &'? str
             103..104 'x': i32
-            142..145 'foo': fn foo<&'? (i32, &'static str), &'? i32, impl FnOnce(&'? (i32, &'static str)) -> &'? i32>(&'? (i32, &'static str), impl FnOnce(&'? (i32, &'static str)) -> &'? i32) -> &'? i32
+            142..145 'foo': fn foo<&'? (i32, &'? str), &'? i32, impl FnOnce(&'? (i32, &'? str)) -> &'? i32>(&'? (i32, &'? str), impl FnOnce(&'? (i32, &'? str)) -> &'? i32) -> &'? i32
             142..168 'foo(&(...y)| x)': &'? i32
-            146..155 '&(1, "a")': &'? (i32, &'static str)
-            147..155 '(1, "a")': (i32, &'static str)
+            146..155 '&(1, "a")': &'? (i32, &'? str)
+            147..155 '(1, "a")': (i32, &'? str)
             148..149 '1': i32
             151..154 '"a"': &'static str
-            157..167 '|(x, y)| x': impl FnOnce(&'? (i32, &'static str)) -> &'? i32
-            158..164 '(x, y)': (i32, &'static str)
+            157..167 '|(x, y)| x': impl FnOnce(&'? (i32, &'? str)) -> &'? i32
+            158..164 '(x, y)': (i32, &'? str)
             159..160 'x': &'? i32
-            162..163 'y': &'? &'static str
+            162..163 'y': &'? &'? str
             166..167 'x': &'? i32
         "#]],
     );
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
index 6a3f2286215f4..2ba1e2341b297 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
@@ -88,6 +88,7 @@ fn bug_651() {
 
 #[test]
 fn recursive_vars() {
+    // FIXME: This isn't nice, but I guess as long as we don't hang/crash that's fine?
     check_infer(
         r#"
         fn test() {
@@ -97,12 +98,12 @@ fn recursive_vars() {
         "#,
         expect![[r#"
             10..47 '{     ...&y]; }': ()
-            20..21 'y': {unknown}
-            24..31 'unknown': {unknown}
-            37..44 '[y, &y]': [{unknown}; 2]
-            38..39 'y': {unknown}
-            41..43 '&y': &'? {unknown}
-            42..43 'y': {unknown}
+            20..21 'y': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
+            24..31 'unknown': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
+            37..44 '[y, &y]': [&'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}; 2]
+            38..39 'y': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
+            41..43 '&y': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
+            42..43 'y': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
         "#]],
     );
 }
@@ -119,19 +120,19 @@ fn recursive_vars_2() {
         "#,
         expect![[r#"
             10..79 '{     ...x)]; }': ()
-            20..21 'x': &'? {unknown}
-            24..31 'unknown': &'? {unknown}
-            41..42 'y': {unknown}
-            45..52 'unknown': {unknown}
-            58..76 '[(x, y..., &x)]': [(&'? {unknown}, {unknown}); 2]
-            59..65 '(x, y)': (&'? {unknown}, {unknown})
-            60..61 'x': &'? {unknown}
-            63..64 'y': {unknown}
-            67..75 '(&y, &x)': (&'? {unknown}, {unknown})
-            68..70 '&y': &'? {unknown}
-            69..70 'y': {unknown}
-            72..74 '&x': &'? &'? {unknown}
-            73..74 'x': &'? {unknown}
+            20..21 'x': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
+            24..31 'unknown': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
+            41..42 'y': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
+            45..52 'unknown': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
+            58..76 '[(x, y..., &x)]': [(&'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}, &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}); 2]
+            59..65 '(x, y)': (&'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}, &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown})
+            60..61 'x': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
+            63..64 'y': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
+            67..75 '(&y, &x)': (&'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}, &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown})
+            68..70 '&y': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
+            69..70 'y': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
+            72..74 '&x': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
+            73..74 'x': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
         "#]],
     );
 }
@@ -268,37 +269,37 @@ fn infer_std_crash_5() {
         expect![[r#"
             26..322 '{     ...   } }': ()
             32..320 'for co...     }': fn into_iter<{unknown}>({unknown}) -> <{unknown} as IntoIterator>::IntoIter
-            32..320 'for co...     }': {unknown}
+            32..320 'for co...     }': <{unknown} as IntoIterator>::IntoIter
             32..320 'for co...     }': !
             32..320 'for co...     }': {unknown}
             32..320 'for co...     }': &'? mut {unknown}
             32..320 'for co...     }': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
-            32..320 'for co...     }': Option<{unknown}>
+            32..320 'for co...     }': Option<<{unknown} as Iterator>::Item>
             32..320 'for co...     }': ()
             32..320 'for co...     }': ()
             32..320 'for co...     }': ()
             32..320 'for co...     }': ()
-            36..43 'content': {unknown}
+            36..43 'content': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
             47..60 'doesnt_matter': {unknown}
             61..320 '{     ...     }': ()
-            75..79 'name': &'? {unknown}
-            82..166 'if doe...     }': &'? {unknown}
+            75..79 'name': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
+            82..166 'if doe...     }': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
             85..98 'doesnt_matter': bool
-            99..128 '{     ...     }': &'? {unknown}
-            113..118 'first': &'? {unknown}
-            134..166 '{     ...     }': &'? {unknown}
-            148..156 '&content': &'? {unknown}
-            149..156 'content': {unknown}
-            181..188 'content': &'? {unknown}
-            191..313 'if ICE...     }': &'? {unknown}
-            194..231 'ICE_RE..._VALUE': {unknown}
+            99..128 '{     ...     }': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
+            113..118 'first': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
+            134..166 '{     ...     }': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
+            148..156 '&content': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
+            149..156 'content': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
+            181..188 'content': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
+            191..313 'if ICE...     }': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
+            194..231 'ICE_RE..._VALUE': bool
             194..247 'ICE_RE...&name)': bool
-            241..246 '&name': &'? &'? {unknown}
-            242..246 'name': &'? {unknown}
-            248..276 '{     ...     }': &'? {unknown}
-            262..266 'name': &'? {unknown}
-            282..313 '{     ...     }': {unknown}
-            296..303 'content': {unknown}
+            241..246 '&name': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
+            242..246 'name': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
+            248..276 '{     ...     }': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
+            262..266 'name': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
+            282..313 '{     ...     }': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
+            296..303 'content': &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? &'? {unknown}
         "#]],
     );
 }
@@ -394,7 +395,7 @@ fn issue_2669() {
         r#"
         trait A {}
         trait Write {}
-        struct Response<T> {}
+        struct Response<T>(T);
 
         trait D {
             fn foo();
@@ -410,13 +411,13 @@ fn issue_2669() {
         }
         "#,
         expect![[r#"
-            119..214 '{     ...     }': ()
-            129..132 'end': fn end<{unknown}>()
-            129..134 'end()': ()
-            163..208 '{     ...     }': ()
-            181..183 '_x': !
-            190..197 'loop {}': !
-            195..197 '{}': ()
+            120..215 '{     ...     }': ()
+            130..133 'end': fn end<{unknown}>()
+            130..135 'end()': ()
+            164..209 '{     ...     }': ()
+            182..184 '_x': !
+            191..198 'loop {}': !
+            196..198 '{}': ()
         "#]],
     )
 }
@@ -628,7 +629,7 @@ fn issue_4053_diesel_where_clauses() {
             65..69 'self': Self
             267..271 'self': Self
             466..470 'self': SelectStatement<F, S, D, W, O, LOf, {unknown}, {unknown}>
-            488..522 '{     ...     }': ()
+            488..522 '{     ...     }': <SelectStatement<F, S, D, W, O, LOf, {unknown}, {unknown}> as BoxedDsl<DB>>::Output
             498..502 'self': SelectStatement<F, S, D, W, O, LOf, {unknown}, {unknown}>
             498..508 'self.order': O
             498..515 'self.o...into()': dyn QueryFragment<DB> + '?
@@ -799,7 +800,7 @@ fn issue_4966() {
 
         struct Map<F> { f: F }
 
-        struct Vec<T> {}
+        struct Vec<T> { p: *mut T }
 
         impl<T> core::ops::Deref for Vec<T> {
             type Target = [T];
@@ -818,23 +819,23 @@ fn issue_4966() {
         }
         "#,
         expect![[r#"
-            225..229 'iter': T
-            244..246 '{}': Vec<A>
-            258..402 '{     ...r(); }': ()
-            268..273 'inner': Map<impl Fn(&'? f64) -> f64>
-            276..300 'Map { ... 0.0 }': Map<impl Fn(&'? f64) -> f64>
-            285..298 '|_: &f64| 0.0': impl Fn(&'? f64) -> f64
-            286..287 '_': &'? f64
-            295..298 '0.0': f64
-            311..317 'repeat': Repeat<Map<impl Fn(&'? f64) -> f64>>
-            320..345 'Repeat...nner }': Repeat<Map<impl Fn(&'? f64) -> f64>>
-            338..343 'inner': Map<impl Fn(&'? f64) -> f64>
-            356..359 'vec': Vec<{unknown}>
-            362..371 'from_iter': fn from_iter<{unknown}, Repeat<Map<impl Fn(&'? f64) -> f64>>>(Repeat<Map<impl Fn(&'? f64) -> f64>>) -> Vec<{unknown}>
-            362..379 'from_i...epeat)': Vec<{unknown}>
-            372..378 'repeat': Repeat<Map<impl Fn(&'? f64) -> f64>>
-            386..389 'vec': Vec<{unknown}>
-            386..399 'vec.foo_bar()': {unknown}
+            236..240 'iter': T
+            255..257 '{}': Vec<A>
+            269..413 '{     ...r(); }': ()
+            279..284 'inner': Map<impl Fn(&'? f64) -> f64>
+            287..311 'Map { ... 0.0 }': Map<impl Fn(&'? f64) -> f64>
+            296..309 '|_: &f64| 0.0': impl Fn(&'? f64) -> f64
+            297..298 '_': &'? f64
+            306..309 '0.0': f64
+            322..328 'repeat': Repeat<Map<impl Fn(&'? f64) -> f64>>
+            331..356 'Repeat...nner }': Repeat<Map<impl Fn(&'? f64) -> f64>>
+            349..354 'inner': Map<impl Fn(&'? f64) -> f64>
+            367..370 'vec': Vec<{unknown}>
+            373..382 'from_iter': fn from_iter<{unknown}, Repeat<Map<impl Fn(&'? f64) -> f64>>>(Repeat<Map<impl Fn(&'? f64) -> f64>>) -> Vec<{unknown}>
+            373..390 'from_i...epeat)': Vec<{unknown}>
+            383..389 'repeat': Repeat<Map<impl Fn(&'? f64) -> f64>>
+            397..400 'vec': Vec<{unknown}>
+            397..410 'vec.foo_bar()': {unknown}
         "#]],
     );
 }
@@ -843,37 +844,40 @@ fn issue_4966() {
 fn issue_6628() {
     check_infer(
         r#"
-//- minicore: fn
-struct S<T>();
+//- minicore: fn, phantom_data
+use core::marker::PhantomData;
+
+struct S<T>(PhantomData<T>);
 impl<T> S<T> {
     fn f(&self, _t: T) {}
     fn g<F: FnOnce(&T)>(&self, _f: F) {}
 }
 fn main() {
-    let s = S();
+    let s = S(PhantomData);
     s.g(|_x| {});
     s.f(10);
 }
 "#,
         expect![[r#"
-            40..44 'self': &'? S<T>
-            46..48 '_t': T
-            53..55 '{}': ()
-            81..85 'self': &'? S<T>
-            87..89 '_f': F
-            94..96 '{}': ()
-            109..160 '{     ...10); }': ()
-            119..120 's': S<i32>
-            123..124 'S': fn S<i32>() -> S<i32>
-            123..126 'S()': S<i32>
-            132..133 's': S<i32>
-            132..144 's.g(|_x| {})': ()
-            136..143 '|_x| {}': impl FnOnce(&'? i32)
-            137..139 '_x': &'? i32
-            141..143 '{}': ()
-            150..151 's': S<i32>
-            150..157 's.f(10)': ()
-            154..156 '10': i32
+            86..90 'self': &'? S<T>
+            92..94 '_t': T
+            99..101 '{}': ()
+            127..131 'self': &'? S<T>
+            133..135 '_f': F
+            140..142 '{}': ()
+            155..217 '{     ...10); }': ()
+            165..166 's': S<i32>
+            169..170 'S': fn S<i32>(PhantomData<i32>) -> S<i32>
+            169..183 'S(PhantomData)': S<i32>
+            171..182 'PhantomData': PhantomData<i32>
+            189..190 's': S<i32>
+            189..201 's.g(|_x| {})': ()
+            193..200 '|_x| {}': impl FnOnce(&'? i32)
+            194..196 '_x': &'? i32
+            198..200 '{}': ()
+            207..208 's': S<i32>
+            207..214 's.f(10)': ()
+            211..213 '10': i32
         "#]],
     );
 }
@@ -931,7 +935,7 @@ fn lifetime_from_chalk_during_deref() {
     check_types(
         r#"
 //- minicore: deref
-struct Box<T: ?Sized> {}
+struct Box<T: ?Sized>(T);
 impl<T: ?Sized> core::ops::Deref for Box<T> {
     type Target = T;
 
@@ -964,6 +968,9 @@ fn clone_iter<T>(s: Iter<T>) {
 fn issue_8686() {
     check_infer(
         r#"
+//- minicore: phantom_data
+use core::marker::PhantomData;
+
 pub trait Try: FromResidual {
     type Output;
     type Residual;
@@ -972,28 +979,32 @@ pub trait FromResidual<R = <Self as Try>::Residual> {
      fn from_residual(residual: R) -> Self;
 }
 
-struct ControlFlow<B, C>;
+struct ControlFlow<B, C>(PhantomData<(B, C)>);
 impl<B, C> Try for ControlFlow<B, C> {
     type Output = C;
     type Residual = ControlFlow<B, !>;
 }
 impl<B, C> FromResidual for ControlFlow<B, C> {
-    fn from_residual(r: ControlFlow<B, !>) -> Self { ControlFlow }
+    fn from_residual(r: ControlFlow<B, !>) -> Self { ControlFlow(PhantomData) }
 }
 
 fn test() {
-    ControlFlow::from_residual(ControlFlow::<u32, !>);
+    ControlFlow::from_residual(ControlFlow::<u32, !>(PhantomData));
 }
         "#,
         expect![[r#"
-            144..152 'residual': R
-            365..366 'r': ControlFlow<B, !>
-            395..410 '{ ControlFlow }': ControlFlow<B, C>
-            397..408 'ControlFlow': ControlFlow<B, C>
-            424..482 '{     ...!>); }': ()
-            430..456 'Contro...sidual': fn from_residual<ControlFlow<u32, {unknown}>, ControlFlow<u32, !>>(ControlFlow<u32, !>) -> ControlFlow<u32, {unknown}>
-            430..479 'Contro...2, !>)': ControlFlow<u32, {unknown}>
-            457..478 'Contro...32, !>': ControlFlow<u32, !>
+            176..184 'residual': R
+            418..419 'r': ControlFlow<B, !>
+            448..476 '{ Cont...ata) }': ControlFlow<B, C>
+            450..461 'ControlFlow': fn ControlFlow<B, C>(PhantomData<(B, C)>) -> ControlFlow<B, C>
+            450..474 'Contro...mData)': ControlFlow<B, C>
+            462..473 'PhantomData': PhantomData<(B, C)>
+            490..561 '{     ...a)); }': ()
+            496..522 'Contro...sidual': fn from_residual<ControlFlow<u32, {unknown}>, ControlFlow<u32, !>>(ControlFlow<u32, !>) -> ControlFlow<u32, {unknown}>
+            496..558 'Contro...Data))': ControlFlow<u32, {unknown}>
+            523..544 'Contro...32, !>': fn ControlFlow<u32, !>(PhantomData<(u32, !)>) -> ControlFlow<u32, !>
+            523..557 'Contro...mData)': ControlFlow<u32, !>
+            545..556 'PhantomData': PhantomData<(u32, !)>
         "#]],
     );
 }
@@ -1052,12 +1063,13 @@ fn impl_trait_in_option_9530() {
     check_types(
         r#"
 //- minicore: sized
-struct Option<T>;
+struct Option<T>(T);
 impl<T> Option<T> {
     fn unwrap(self) -> T { loop {} }
 }
-fn make() -> Option<impl Copy> { Option }
+fn make() -> Option<impl Copy> { Option(()) }
 trait Copy {}
+impl Copy for () {}
 fn test() {
     let o = make();
     o.unwrap();
@@ -1163,9 +1175,9 @@ pub trait BitView {
 
 pub struct Lsb0;
 
-pub struct BitArray<V: BitView> { }
+pub struct BitArray<V: BitView>(V);
 
-pub struct BitSlice<T> { }
+pub struct BitSlice<T>(T);
 
 impl<V: BitView> core::ops::Deref for BitArray<V> {
     type Target = BitSlice<V::Store>;
@@ -1243,12 +1255,12 @@ fn test() {
         expect![[r#"
             10..68 '{     ...   } }': ()
             16..66 'for _ ...     }': fn into_iter<()>(()) -> <() as IntoIterator>::IntoIter
-            16..66 'for _ ...     }': {unknown}
+            16..66 'for _ ...     }': <() as IntoIterator>::IntoIter
             16..66 'for _ ...     }': !
-            16..66 'for _ ...     }': {unknown}
-            16..66 'for _ ...     }': &'? mut {unknown}
+            16..66 'for _ ...     }': <() as IntoIterator>::IntoIter
+            16..66 'for _ ...     }': &'? mut <() as IntoIterator>::IntoIter
             16..66 'for _ ...     }': fn next<{unknown}>(&'? mut {unknown}) -> Option<<{unknown} as Iterator>::Item>
-            16..66 'for _ ...     }': Option<{unknown}>
+            16..66 'for _ ...     }': Option<<{unknown} as Iterator>::Item>
             16..66 'for _ ...     }': ()
             16..66 'for _ ...     }': ()
             16..66 'for _ ...     }': ()
@@ -1779,7 +1791,7 @@ fn regression_14844() {
         r#"
 pub type Ty = Unknown;
 
-pub struct Inner<T>();
+pub struct Inner<T>(T);
 
 pub struct Outer {
     pub inner: Inner<Ty>,
@@ -1787,7 +1799,7 @@ pub struct Outer {
 
 fn main() {
     _ = Outer {
-        inner: Inner::<i32>(),
+        inner: Inner::<i32>(0),
     };
 }
         "#,
@@ -1939,7 +1951,7 @@ fn main() {
     Alias::Braced;
   //^^^^^^^^^^^^^ {unknown}
     let Alias::Braced = loop {};
-      //^^^^^^^^^^^^^ !
+      //^^^^^^^^^^^^^ {unknown}
   let Alias::Braced(..) = loop {};
     //^^^^^^^^^^^^^^^^^ Enum
 
@@ -2017,12 +2029,12 @@ fn tait_async_stack_overflow_17199() {
 fn lifetime_params_move_param_defaults() {
     check_types(
         r#"
-pub struct Thing<'s, T = u32>;
+pub struct Thing<'s, T = u32>(&'s T);
 
 impl <'s> Thing<'s> {
     pub fn new() -> Thing<'s> {
-        Thing
-      //^^^^^ Thing<'?, u32>
+        Thing(&0)
+      //^^^^^^^^^ Thing<'?, u32>
     }
 }
 
@@ -2042,11 +2054,11 @@ fn issue_17734() {
         r#"
 fn test() {
     let x = S::foo::<'static, &()>(&S);
-     // ^ Wrap<'static, ()>
+     // ^ Wrap<'?, ()>
     let x = S::foo::<&()>(&S);
      // ^ Wrap<'?, ()>
     let x = S.foo::<'static, &()>();
-     // ^ Wrap<'static, ()>
+     // ^ Wrap<'?, ()>
     let x = S.foo::<&()>();
      // ^ Wrap<'?, ()>
 }
@@ -2059,7 +2071,7 @@ impl S {
     }
 }
 
-struct Wrap<'a, T>(T);
+struct Wrap<'a, T>(&'a T);
 trait Trait<'a> {
     type Proj;
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
index 82d670cef2b0e..ead79a8f5b90b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
@@ -307,3 +307,114 @@ where
         "#]],
     )
 }
+
+#[test]
+fn fn_coercion() {
+    check_no_mismatches(
+        r#"
+fn foo() {
+    let _is_suffix_start: fn(&(usize, char)) -> bool = match true {
+        true => |(_, c)| *c == ' ',
+        _ => |(_, c)| *c == 'v',
+    };
+}
+    "#,
+    );
+}
+
+#[test]
+fn coercion_with_errors() {
+    check_no_mismatches(
+        r#"
+//- minicore: unsize, coerce_unsized
+fn foo(_v: i32) -> [u8; _] { loop {} }
+fn bar(_v: &[u8]) {}
+
+fn main() {
+    bar(&foo());
+}
+    "#,
+    );
+}
+
+#[test]
+fn another_20654_case() {
+    check_no_mismatches(
+        r#"
+//- minicore: sized, unsize, coerce_unsized, dispatch_from_dyn, fn
+struct Region<'db>(&'db ());
+
+trait TypeFoldable<I: Interner> {}
+
+trait Interner {
+    type Region;
+    type GenericArg;
+}
+
+struct DbInterner<'db>(&'db ());
+impl<'db> Interner for DbInterner<'db> {
+    type Region = Region<'db>;
+    type GenericArg = GenericArg<'db>;
+}
+
+trait GenericArgExt<I: Interner<GenericArg = Self>> {
+    fn expect_region(&self) -> I::Region {
+        loop {}
+    }
+}
+impl<'db> GenericArgExt<DbInterner<'db>> for GenericArg<'db> {}
+
+enum GenericArg<'db> {
+    Region(Region<'db>),
+}
+
+fn foo<'db, T: TypeFoldable<DbInterner<'db>>>(arg: GenericArg<'db>) {
+    let regions = &mut || arg.expect_region();
+    let f: &'_ mut (dyn FnMut() -> Region<'db> + '_) = regions;
+}
+    "#,
+    );
+}
+
+#[test]
+fn trait_solving_with_error() {
+    check_infer(
+        r#"
+//- minicore: size_of
+struct Vec<T>(T);
+
+trait Foo {
+    type Item;
+    fn to_vec(self) -> Vec<Self::Item> {
+        loop {}
+    }
+}
+
+impl<'a, T, const N: usize> Foo for &'a [T; N] {
+    type Item = T;
+}
+
+fn to_bytes() -> [u8; _] {
+    loop {}
+}
+
+fn foo() {
+    let _x = to_bytes().to_vec();
+}
+    "#,
+        expect![[r#"
+            60..64 'self': Self
+            85..108 '{     ...     }': Vec<<Self as Foo>::Item>
+            95..102 'loop {}': !
+            100..102 '{}': ()
+            208..223 '{     loop {} }': [u8; _]
+            214..221 'loop {}': !
+            219..221 '{}': ()
+            234..271 '{     ...c(); }': ()
+            244..246 '_x': {unknown}
+            249..257 'to_bytes': fn to_bytes() -> [u8; _]
+            249..259 'to_bytes()': [u8; _]
+            249..268 'to_byt..._vec()': Vec<<[u8; _] as Foo>::Item>
+        "#]],
+    );
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/simple.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/simple.rs
index 60ad0f49c6ab0..9d02a44c37c97 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/simple.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/simple.rs
@@ -439,11 +439,11 @@ h";
             256..260 'true': bool
             274..370 'r#"   ...    "#': &'static str
             384..394 'br#"yolo"#': &'static [u8; 4]
-            412..413 'a': &'static [u8; 4]
+            412..413 'a': &'? [u8; 4]
             416..440 'b"a\x2...    c"': &'static [u8; 4]
-            458..459 'b': &'static [u8; 4]
+            458..459 'b': &'? [u8; 4]
             462..470 'br"g\ h"': &'static [u8; 4]
-            488..489 'c': &'static [u8; 6]
+            488..489 'c': &'? [u8; 6]
             492..504 'br#"x"\"yb"#': &'static [u8; 6]
         "##]],
     );
@@ -1124,13 +1124,13 @@ fn infer_tuple() {
             116..122 '(c, x)': ((isize, &'? str), &'? str)
             117..118 'c': (isize, &'? str)
             120..121 'x': &'? str
-            132..133 'e': (i32, &'static str)
-            136..144 '(1, "e")': (i32, &'static str)
+            132..133 'e': (i32, &'? str)
+            136..144 '(1, "e")': (i32, &'? str)
             137..138 '1': i32
             140..143 '"e"': &'static str
-            154..155 'f': ((i32, &'static str), &'static str)
-            158..166 '(e, "d")': ((i32, &'static str), &'static str)
-            159..160 'e': (i32, &'static str)
+            154..155 'f': ((i32, &'? str), &'? str)
+            158..166 '(e, "d")': ((i32, &'? str), &'? str)
+            159..160 'e': (i32, &'? str)
             162..165 '"d"': &'static str
         "#]],
     );
@@ -1201,8 +1201,8 @@ fn infer_array() {
             209..215 '[1, 2]': [i32; 2]
             210..211 '1': i32
             213..214 '2': i32
-            225..226 'i': [&'static str; 2]
-            229..239 '["a", "b"]': [&'static str; 2]
+            225..226 'i': [&'? str; 2]
+            229..239 '["a", "b"]': [&'? str; 2]
             230..233 '"a"': &'static str
             235..238 '"b"': &'static str
             250..251 'b': [[&'? str; 1]; 2]
@@ -1283,11 +1283,11 @@ fn infer_tuple_struct_generics() {
             92..93 'A': fn A<u128>(u128) -> A<u128>
             92..101 'A(42u128)': A<u128>
             94..100 '42u128': u128
-            107..111 'Some': fn Some<&'static str>(&'static str) -> Option<&'static str>
-            107..116 'Some("x")': Option<&'static str>
+            107..111 'Some': fn Some<&'? str>(&'? str) -> Option<&'? str>
+            107..116 'Some("x")': Option<&'? str>
             112..115 '"x"': &'static str
-            122..134 'Option::Some': fn Some<&'static str>(&'static str) -> Option<&'static str>
-            122..139 'Option...e("x")': Option<&'static str>
+            122..134 'Option::Some': fn Some<&'? str>(&'? str) -> Option<&'? str>
+            122..139 'Option...e("x")': Option<&'? str>
             135..138 '"x"': &'static str
             145..149 'None': Option<{unknown}>
             159..160 'x': Option<i64>
@@ -1946,9 +1946,9 @@ fn closure_return_inferred() {
         "#,
         expect![[r#"
             16..46 '{     ..." }; }': u32
-            26..27 'x': impl Fn() -> &'static str
-            30..43 '|| { "test" }': impl Fn() -> &'static str
-            33..43 '{ "test" }': &'static str
+            26..27 'x': impl Fn() -> &'? str
+            30..43 '|| { "test" }': impl Fn() -> &'? str
+            33..43 '{ "test" }': &'? str
             35..41 '"test"': &'static str
         "#]],
     );
@@ -1983,10 +1983,10 @@ fn test() {
             70..71 'v': i64
             78..80 '{}': ()
             91..362 '{     ...   } }': ()
-            101..106 'mut g': |usize| yields i64 -> &'static str
-            109..218 '|r| { ...     }': |usize| yields i64 -> &'static str
+            101..106 'mut g': |usize| yields i64 -> &'? str
+            109..218 '|r| { ...     }': |usize| yields i64 -> &'? str
             110..111 'r': usize
-            113..218 '{     ...     }': &'static str
+            113..218 '{     ...     }': &'? str
             127..128 'a': usize
             131..138 'yield 0': usize
             137..138 '0': i64
@@ -1998,20 +1998,20 @@ fn test() {
             187..188 '2': i64
             198..212 '"return value"': &'static str
             225..360 'match ...     }': ()
-            231..239 'Pin::new': fn new<&'? mut |usize| yields i64 -> &'static str>(&'? mut |usize| yields i64 -> &'static str) -> Pin<&'? mut |usize| yields i64 -> &'static str>
-            231..247 'Pin::n...mut g)': Pin<&'? mut |usize| yields i64 -> &'static str>
-            231..262 'Pin::n...usize)': CoroutineState<i64, &'static str>
-            240..246 '&mut g': &'? mut |usize| yields i64 -> &'static str
-            245..246 'g': |usize| yields i64 -> &'static str
+            231..239 'Pin::new': fn new<&'? mut |usize| yields i64 -> &'? str>(&'? mut |usize| yields i64 -> &'? str) -> Pin<&'? mut |usize| yields i64 -> &'? str>
+            231..247 'Pin::n...mut g)': Pin<&'? mut |usize| yields i64 -> &'? str>
+            231..262 'Pin::n...usize)': CoroutineState<i64, &'? str>
+            240..246 '&mut g': &'? mut |usize| yields i64 -> &'? str
+            245..246 'g': |usize| yields i64 -> &'? str
             255..261 '0usize': usize
-            273..299 'Corout...ded(y)': CoroutineState<i64, &'static str>
+            273..299 'Corout...ded(y)': CoroutineState<i64, &'? str>
             297..298 'y': i64
             303..312 '{ f(y); }': ()
             305..306 'f': fn f(i64)
             305..309 'f(y)': ()
             307..308 'y': i64
-            321..348 'Corout...ete(r)': CoroutineState<i64, &'static str>
-            346..347 'r': &'static str
+            321..348 'Corout...ete(r)': CoroutineState<i64, &'? str>
+            346..347 'r': &'? str
             352..354 '{}': ()
         "#]],
     );
@@ -2707,11 +2707,11 @@ unsafe impl Allocator for Global {}
 
 #[lang = "owned_box"]
 #[fundamental]
-pub struct Box<T: ?Sized, A: Allocator = Global>;
+pub struct Box<T: ?Sized, A: Allocator = Global>(T, A);
 
 impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Box<U, A>> for Box<T, A> {}
 
-pub struct Vec<T, A: Allocator = Global> {}
+pub struct Vec<T, A: Allocator = Global>(T, A);
 
 #[lang = "slice"]
 impl<T> [T] {}
@@ -2734,22 +2734,22 @@ struct Astruct;
 impl B for Astruct {}
 "#,
         expect![[r#"
-            604..608 'self': Box<[T], A>
-            637..669 '{     ...     }': Vec<T, A>
-            683..853 '{     ...])); }': ()
-            693..696 'vec': Vec<i32, Global>
-            699..714 '<[_]>::into_vec': fn into_vec<i32, Global>(Box<[i32], Global>) -> Vec<i32, Global>
-            699..745 '<[_]>:...i32]))': Vec<i32, Global>
-            715..744 '#[rust...1i32])': Box<[i32; 1], Global>
-            737..743 '[1i32]': [i32; 1]
-            738..742 '1i32': i32
-            755..756 'v': Vec<Box<dyn B + '?, Global>, Global>
-            776..793 '<[_]> ...to_vec': fn into_vec<Box<dyn B + '?, Global>, Global>(Box<[Box<dyn B + '?, Global>], Global>) -> Vec<Box<dyn B + '?, Global>, Global>
-            776..850 '<[_]> ...ct)]))': Vec<Box<dyn B + '?, Global>, Global>
-            794..849 '#[rust...uct)])': Box<[Box<dyn B + '?, Global>; 1], Global>
-            816..848 '[#[rus...ruct)]': [Box<dyn B + '?, Global>; 1]
-            817..847 '#[rust...truct)': Box<Astruct, Global>
-            839..846 'Astruct': Astruct
+            614..618 'self': Box<[T], A>
+            647..679 '{     ...     }': Vec<T, A>
+            693..863 '{     ...])); }': ()
+            703..706 'vec': Vec<i32, Global>
+            709..724 '<[_]>::into_vec': fn into_vec<i32, Global>(Box<[i32], Global>) -> Vec<i32, Global>
+            709..755 '<[_]>:...i32]))': Vec<i32, Global>
+            725..754 '#[rust...1i32])': Box<[i32; 1], Global>
+            747..753 '[1i32]': [i32; 1]
+            748..752 '1i32': i32
+            765..766 'v': Vec<Box<dyn B + '?, Global>, Global>
+            786..803 '<[_]> ...to_vec': fn into_vec<Box<dyn B + '?, Global>, Global>(Box<[Box<dyn B + '?, Global>], Global>) -> Vec<Box<dyn B + '?, Global>, Global>
+            786..860 '<[_]> ...ct)]))': Vec<Box<dyn B + '?, Global>, Global>
+            804..859 '#[rust...uct)])': Box<[Box<dyn B + '?, Global>; 1], Global>
+            826..858 '[#[rus...ruct)]': [Box<dyn B + '?, Global>; 1]
+            827..857 '#[rust...truct)': Box<Astruct, Global>
+            849..856 'Astruct': Astruct
         "#]],
     )
 }
@@ -3889,9 +3889,9 @@ fn main() {
             74..75 'f': F
             80..82 '{}': ()
             94..191 '{     ... }); }': ()
-            100..113 'async_closure': fn async_closure<impl AsyncFnOnce(i32) -> impl Future<Output = ()>>(impl AsyncFnOnce(i32) -> impl Future<Output = ()>)
+            100..113 'async_closure': fn async_closure<impl FnOnce(i32)>(impl FnOnce(i32))
             100..147 'async_...    })': ()
-            114..146 'async ...     }': impl AsyncFnOnce(i32) -> impl Future<Output = ()>
+            114..146 'async ...     }': impl FnOnce(i32)
             121..124 'arg': i32
             126..146 '{     ...     }': ()
             136..139 'arg': i32
@@ -3924,7 +3924,7 @@ fn foo<T: Bar>() {
         expect![[r#"
             110..127 '{     ...z(); }': ()
             116..122 'T::baz': fn baz<T>() -> <{unknown} as Foo>::Gat<'?>
-            116..124 'T::baz()': {unknown}
+            116..124 'T::baz()': <{unknown} as Foo>::Gat<'?>
         "#]],
     );
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
index 22332fdc2b8aa..41f8d4ed555f2 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
@@ -85,6 +85,7 @@ async fn test() {
 }
 
 #[test]
+#[ignore = "FIXME(next-solver): fix async closures"]
 fn infer_async_closure() {
     check_types(
         r#"
@@ -164,16 +165,16 @@ unsafe impl Allocator for Global {}
 
 #[lang = "owned_box"]
 #[fundamental]
-pub struct Box<T: ?Sized, A: Allocator = Global>(T);
+pub struct Box<T: ?Sized, A: Allocator = Global>(T, A);
 
 impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Box<U, A>> for Box<T, A> {}
 
 fn send() ->  Box<dyn Future<Output = ()> + Send + 'static>{
-    Box(async move {})
+    Box(async move {}, Global)
 }
 
 fn not_send() -> Box<dyn Future<Output = ()> + 'static> {
-    Box(async move {})
+    Box(async move {}, Global)
 }
     "#,
     );
@@ -248,15 +249,15 @@ fn test() {
     v.push("foo");
     for x in v {
         x;
-    } //^ &'static str
+    } //^ &'? str
 }
 
 //- /alloc.rs crate:alloc
 #![no_std]
 pub mod collections {
-    pub struct Vec<T> {}
+    pub struct Vec<T> { p: *const T }
     impl<T> Vec<T> {
-        pub fn new() -> Self { Vec {} }
+        pub fn new() -> Self { Vec { p: 0 as _ } }
         pub fn push(&mut self, t: T) { }
     }
 
@@ -722,8 +723,8 @@ fn deref_trait_with_inference_var() {
     check_types(
         r#"
 //- minicore: deref
-struct Arc<T: ?Sized>;
-fn new_arc<T: ?Sized>() -> Arc<T> { Arc }
+struct Arc<T: ?Sized>(T);
+fn new_arc<T: ?Sized>() -> Arc<T> { loop {} }
 impl<T: ?Sized> core::ops::Deref for Arc<T> {
     type Target = T;
 }
@@ -785,13 +786,15 @@ fn test(s: Arc<S>) {
 fn deref_trait_with_implicit_sized_requirement_on_inference_var() {
     check_types(
         r#"
-//- minicore: deref
-struct Foo<T>;
+//- minicore: deref, phantom_data
+use core::marker::PhantomData;
+
+struct Foo<T>(PhantomData<T>);
 impl<T> core::ops::Deref for Foo<T> {
     type Target = ();
 }
 fn test() {
-    let foo = Foo;
+    let foo = Foo(PhantomData);
     *foo;
   //^^^^ ()
     let _: Foo<u8> = foo;
@@ -1456,7 +1459,7 @@ trait Trait<T> {
     fn foo2(&self) -> i64;
 }
 
-struct Box<T: ?Sized> {}
+struct Box<T: ?Sized>(*const T);
 impl<T: ?Sized> core::ops::Deref for Box<T> {
     type Target = T;
 }
@@ -1477,27 +1480,27 @@ fn test(x: Box<dyn Trait<u64>>, y: &dyn Trait<u64>) {
         expect![[r#"
             29..33 'self': &'? Self
             54..58 'self': &'? Self
-            198..200 '{}': Box<dyn Trait<u64> + '?>
-            210..211 'x': Box<dyn Trait<u64> + '?>
-            234..235 'y': &'? (dyn Trait<u64> + '?)
-            254..371 '{     ...2(); }': ()
-            260..261 'x': Box<dyn Trait<u64> + '?>
-            267..268 'y': &'? (dyn Trait<u64> + '?)
-            278..279 'z': Box<dyn Trait<u64> + '?>
-            282..285 'bar': fn bar() -> Box<dyn Trait<u64> + '?>
-            282..287 'bar()': Box<dyn Trait<u64> + '?>
-            293..294 'x': Box<dyn Trait<u64> + '?>
-            293..300 'x.foo()': u64
-            306..307 'y': &'? (dyn Trait<u64> + '?)
-            306..313 'y.foo()': u64
-            319..320 'z': Box<dyn Trait<u64> + '?>
-            319..326 'z.foo()': u64
-            332..333 'x': Box<dyn Trait<u64> + '?>
-            332..340 'x.foo2()': i64
-            346..347 'y': &'? (dyn Trait<u64> + '?)
-            346..354 'y.foo2()': i64
-            360..361 'z': Box<dyn Trait<u64> + '?>
-            360..368 'z.foo2()': i64
+            206..208 '{}': Box<dyn Trait<u64> + '?>
+            218..219 'x': Box<dyn Trait<u64> + '?>
+            242..243 'y': &'? (dyn Trait<u64> + '?)
+            262..379 '{     ...2(); }': ()
+            268..269 'x': Box<dyn Trait<u64> + '?>
+            275..276 'y': &'? (dyn Trait<u64> + '?)
+            286..287 'z': Box<dyn Trait<u64> + '?>
+            290..293 'bar': fn bar() -> Box<dyn Trait<u64> + '?>
+            290..295 'bar()': Box<dyn Trait<u64> + '?>
+            301..302 'x': Box<dyn Trait<u64> + '?>
+            301..308 'x.foo()': u64
+            314..315 'y': &'? (dyn Trait<u64> + '?)
+            314..321 'y.foo()': u64
+            327..328 'z': Box<dyn Trait<u64> + '?>
+            327..334 'z.foo()': u64
+            340..341 'x': Box<dyn Trait<u64> + '?>
+            340..348 'x.foo2()': i64
+            354..355 'y': &'? (dyn Trait<u64> + '?)
+            354..362 'y.foo2()': i64
+            368..369 'z': Box<dyn Trait<u64> + '?>
+            368..376 'z.foo2()': i64
         "#]],
     );
 }
@@ -1674,7 +1677,9 @@ fn test(x: (impl Trait + UnknownTrait)) {
 fn assoc_type_bindings() {
     check_infer(
         r#"
-//- minicore: sized
+//- minicore: sized, phantom_data
+use core::marker::PhantomData;
+
 trait Trait {
     type Type;
 }
@@ -1683,7 +1688,7 @@ fn get<T: Trait>(t: T) -> <T as Trait>::Type {}
 fn get2<U, T: Trait<Type = U>>(t: T) -> U {}
 fn set<T: Trait<Type = u64>>(t: T) -> T {t}
 
-struct S<T>;
+struct S<T>(PhantomData<T>);
 impl<T> Trait for S<T> { type Type = T; }
 
 fn test<T: Trait<Type = u32>>(x: T, y: impl Trait<Type = i64>) {
@@ -1691,46 +1696,52 @@ fn test<T: Trait<Type = u32>>(x: T, y: impl Trait<Type = i64>) {
     get2(x);
     get(y);
     get2(y);
-    get(set(S));
-    get2(set(S));
-    get2(S::<usize>);
+    get(set(S(PhantomData)));
+    get2(set(S(PhantomData)));
+    get2(S::<usize>(PhantomData));
 }"#,
         expect![[r#"
-            49..50 't': T
-            77..79 '{}': <T as Trait>::Type
-            111..112 't': T
-            122..124 '{}': U
-            154..155 't': T
-            165..168 '{t}': T
-            166..167 't': T
-            256..257 'x': T
-            262..263 'y': impl Trait<Type = i64>
-            289..399 '{     ...e>); }': ()
-            295..298 'get': fn get<T>(T) -> <T as Trait>::Type
-            295..301 'get(x)': u32
-            299..300 'x': T
-            307..311 'get2': fn get2<u32, T>(T) -> u32
-            307..314 'get2(x)': u32
-            312..313 'x': T
-            320..323 'get': fn get<impl Trait<Type = i64>>(impl Trait<Type = i64>) -> <impl Trait<Type = i64> as Trait>::Type
-            320..326 'get(y)': i64
-            324..325 'y': impl Trait<Type = i64>
-            332..336 'get2': fn get2<i64, impl Trait<Type = i64>>(impl Trait<Type = i64>) -> i64
-            332..339 'get2(y)': i64
-            337..338 'y': impl Trait<Type = i64>
-            345..348 'get': fn get<S<u64>>(S<u64>) -> <S<u64> as Trait>::Type
-            345..356 'get(set(S))': u64
-            349..352 'set': fn set<S<u64>>(S<u64>) -> S<u64>
-            349..355 'set(S)': S<u64>
-            353..354 'S': S<u64>
-            362..366 'get2': fn get2<u64, S<u64>>(S<u64>) -> u64
-            362..374 'get2(set(S))': u64
-            367..370 'set': fn set<S<u64>>(S<u64>) -> S<u64>
-            367..373 'set(S)': S<u64>
-            371..372 'S': S<u64>
-            380..384 'get2': fn get2<usize, S<usize>>(S<usize>) -> usize
-            380..396 'get2(S...size>)': usize
-            385..395 'S::<usize>': S<usize>
+            81..82 't': T
+            109..111 '{}': <T as Trait>::Type
+            143..144 't': T
+            154..156 '{}': U
+            186..187 't': T
+            197..200 '{t}': T
+            198..199 't': T
+            304..305 'x': T
+            310..311 'y': impl Trait<Type = i64>
+            337..486 '{     ...a)); }': ()
+            343..346 'get': fn get<T>(T) -> <T as Trait>::Type
+            343..349 'get(x)': u32
+            347..348 'x': T
+            355..359 'get2': fn get2<u32, T>(T) -> u32
+            355..362 'get2(x)': u32
+            360..361 'x': T
+            368..371 'get': fn get<impl Trait<Type = i64>>(impl Trait<Type = i64>) -> <impl Trait<Type = i64> as Trait>::Type
+            368..374 'get(y)': i64
+            372..373 'y': impl Trait<Type = i64>
+            380..384 'get2': fn get2<i64, impl Trait<Type = i64>>(impl Trait<Type = i64>) -> i64
+            380..387 'get2(y)': i64
+            385..386 'y': impl Trait<Type = i64>
+            393..396 'get': fn get<S<u64>>(S<u64>) -> <S<u64> as Trait>::Type
+            393..417 'get(se...ata)))': u64
+            397..400 'set': fn set<S<u64>>(S<u64>) -> S<u64>
+            397..416 'set(S(...Data))': S<u64>
+            401..402 'S': fn S<u64>(PhantomData<u64>) -> S<u64>
+            401..415 'S(PhantomData)': S<u64>
+            403..414 'PhantomData': PhantomData<u64>
+            423..427 'get2': fn get2<u64, S<u64>>(S<u64>) -> u64
+            423..448 'get2(s...ata)))': u64
+            428..431 'set': fn set<S<u64>>(S<u64>) -> S<u64>
+            428..447 'set(S(...Data))': S<u64>
+            432..433 'S': fn S<u64>(PhantomData<u64>) -> S<u64>
+            432..446 'S(PhantomData)': S<u64>
+            434..445 'PhantomData': PhantomData<u64>
+            454..458 'get2': fn get2<usize, S<usize>>(S<usize>) -> usize
+            454..483 'get2(S...Data))': usize
+            459..469 'S::<usize>': fn S<usize>(PhantomData<usize>) -> S<usize>
+            459..482 'S::<us...mData)': S<usize>
+            470..481 'PhantomData': PhantomData<usize>
         "#]],
     );
 }
@@ -1747,7 +1758,7 @@ pub enum RustLanguage {}
 impl Language for RustLanguage {
     type Kind = SyntaxKind;
 }
-struct SyntaxNode<L> {}
+struct SyntaxNode<L>(L);
 fn foo() -> impl Iterator<Item = SyntaxNode<RustLanguage>> {}
 
 trait Clone {
@@ -1886,31 +1897,36 @@ fn super_trait_cycle() {
 fn super_trait_assoc_type_bounds() {
     check_infer(
         r#"
+//- minicore: phantom_data
+use core::marker::PhantomData;
+
 trait SuperTrait { type Type; }
 trait Trait where Self: SuperTrait {}
 
 fn get2<U, T: Trait<Type = U>>(t: T) -> U {}
 fn set<T: Trait<Type = u64>>(t: T) -> T {t}
 
-struct S<T>;
+struct S<T>(PhantomData<T>);
 impl<T> SuperTrait for S<T> { type Type = T; }
 impl<T> Trait for S<T> {}
 
 fn test() {
-    get2(set(S));
+    get2(set(S(PhantomData)));
 }"#,
         expect![[r#"
-            102..103 't': T
-            113..115 '{}': U
-            145..146 't': T
-            156..159 '{t}': T
-            157..158 't': T
-            258..279 '{     ...S)); }': ()
-            264..268 'get2': fn get2<u64, S<u64>>(S<u64>) -> u64
-            264..276 'get2(set(S))': u64
-            269..272 'set': fn set<S<u64>>(S<u64>) -> S<u64>
-            269..275 'set(S)': S<u64>
-            273..274 'S': S<u64>
+            134..135 't': T
+            145..147 '{}': U
+            177..178 't': T
+            188..191 '{t}': T
+            189..190 't': T
+            306..340 '{     ...))); }': ()
+            312..316 'get2': fn get2<u64, S<u64>>(S<u64>) -> u64
+            312..337 'get2(s...ata)))': u64
+            317..320 'set': fn set<S<u64>>(S<u64>) -> S<u64>
+            317..336 'set(S(...Data))': S<u64>
+            321..322 'S': fn S<u64>(PhantomData<u64>) -> S<u64>
+            321..335 'S(PhantomData)': S<u64>
+            323..334 'PhantomData': PhantomData<u64>
         "#]],
     );
 }
@@ -2000,7 +2016,7 @@ impl Foo {
     fn foo(&self) -> usize {}
 }
 
-struct Lazy<T, F = fn() -> T>(F);
+struct Lazy<T, F = fn() -> T>(T, F);
 
 impl<T, F> Lazy<T, F> {
     pub fn new(f: F) -> Lazy<T, F> {}
@@ -2014,7 +2030,7 @@ fn test() {
     let lazy1: Lazy<Foo, _> = Lazy::new(|| Foo);
     let r1 = lazy1.foo();
 
-    fn make_foo_fn() -> Foo {}
+fn make_foo_fn() -> Foo {}
     let make_foo_fn_ptr: fn() -> Foo = make_foo_fn;
     let lazy2: Lazy<Foo, _> = Lazy::new(make_foo_fn_ptr);
     let r2 = lazy2.foo();
@@ -2022,27 +2038,27 @@ fn test() {
         expect![[r#"
             36..40 'self': &'? Foo
             51..53 '{}': usize
-            131..132 'f': F
-            151..153 '{}': Lazy<T, F>
-            251..497 '{     ...o(); }': ()
-            261..266 'lazy1': Lazy<Foo, impl Fn() -> Foo>
-            283..292 'Lazy::new': fn new<Foo, impl Fn() -> Foo>(impl Fn() -> Foo) -> Lazy<Foo, impl Fn() -> Foo>
-            283..300 'Lazy::...| Foo)': Lazy<Foo, impl Fn() -> Foo>
-            293..299 '|| Foo': impl Fn() -> Foo
-            296..299 'Foo': Foo
-            310..312 'r1': usize
-            315..320 'lazy1': Lazy<Foo, impl Fn() -> Foo>
-            315..326 'lazy1.foo()': usize
-            368..383 'make_foo_fn_ptr': fn() -> Foo
-            399..410 'make_foo_fn': fn make_foo_fn() -> Foo
-            420..425 'lazy2': Lazy<Foo, fn() -> Foo>
-            442..451 'Lazy::new': fn new<Foo, fn() -> Foo>(fn() -> Foo) -> Lazy<Foo, fn() -> Foo>
-            442..468 'Lazy::...n_ptr)': Lazy<Foo, fn() -> Foo>
-            452..467 'make_foo_fn_ptr': fn() -> Foo
-            478..480 'r2': usize
-            483..488 'lazy2': Lazy<Foo, fn() -> Foo>
-            483..494 'lazy2.foo()': usize
-            357..359 '{}': Foo
+            134..135 'f': F
+            154..156 '{}': Lazy<T, F>
+            254..496 '{     ...o(); }': ()
+            264..269 'lazy1': Lazy<Foo, impl Fn() -> Foo>
+            286..295 'Lazy::new': fn new<Foo, impl Fn() -> Foo>(impl Fn() -> Foo) -> Lazy<Foo, impl Fn() -> Foo>
+            286..303 'Lazy::...| Foo)': Lazy<Foo, impl Fn() -> Foo>
+            296..302 '|| Foo': impl Fn() -> Foo
+            299..302 'Foo': Foo
+            313..315 'r1': usize
+            318..323 'lazy1': Lazy<Foo, impl Fn() -> Foo>
+            318..329 'lazy1.foo()': usize
+            367..382 'make_foo_fn_ptr': fn() -> Foo
+            398..409 'make_foo_fn': fn make_foo_fn() -> Foo
+            419..424 'lazy2': Lazy<Foo, fn() -> Foo>
+            441..450 'Lazy::new': fn new<Foo, fn() -> Foo>(fn() -> Foo) -> Lazy<Foo, fn() -> Foo>
+            441..467 'Lazy::...n_ptr)': Lazy<Foo, fn() -> Foo>
+            451..466 'make_foo_fn_ptr': fn() -> Foo
+            477..479 'r2': usize
+            482..487 'lazy2': Lazy<Foo, fn() -> Foo>
+            482..493 'lazy2.foo()': usize
+            356..358 '{}': Foo
         "#]],
     );
 }
@@ -2341,7 +2357,7 @@ trait Fold<I: Interner, TI = I> {
     type Result;
 }
 
-struct Ty<I: Interner> {}
+struct Ty<I: Interner>(I);
 impl<I: Interner, TI: Interner> Fold<I, TI> for Ty<I> {
     type Result = Ty<TI>;
 }
@@ -2383,17 +2399,20 @@ fn test() {
 fn trait_impl_self_ty_cycle() {
     check_types(
         r#"
+//- minicore: phantom_data
+use core::marker::PhantomData;
+
 trait Trait {
    fn foo(&self);
 }
 
-struct S<T>;
+struct S<T>(T);
 
 impl Trait for S<Self> {}
 
 fn test() {
-    S.foo();
-} //^^^^^^^ {unknown}
+    S(PhantomData).foo();
+} //^^^^^^^^^^^^^^^^^^^^ {unknown}
 "#,
     );
 }
@@ -2743,7 +2762,7 @@ fn dyn_trait_through_chalk() {
     check_types(
         r#"
 //- minicore: deref, unsize, dispatch_from_dyn
-struct Box<T: ?Sized> {}
+struct Box<T: ?Sized>(*const T);
 impl<T: ?Sized> core::ops::Deref for Box<T> {
     type Target = T;
 }
@@ -2802,7 +2821,7 @@ pub trait IntoIterator {
     fn into_iter(self) -> Self::IntoIter;
 }
 
-pub struct FilterMap<I, F> { }
+pub struct FilterMap<I, F>(I, F);
 impl<B, I: Iterator, F> Iterator for FilterMap<I, F>
 where
     F: FnMut(I::Item) -> Option<B>,
@@ -2820,7 +2839,7 @@ impl<I: Iterator> IntoIterator for I {
     }
 }
 
-struct Vec<T> {}
+struct Vec<T>(T);
 impl<T> Vec<T> {
     fn new() -> Self { loop {} }
 }
@@ -2830,7 +2849,7 @@ impl<T> IntoIterator for Vec<T> {
     type IntoIter = IntoIter<T>;
 }
 
-pub struct IntoIter<T> { }
+pub struct IntoIter<T>(T);
 impl<T> Iterator for IntoIter<T> {
     type Item = T;
 }
@@ -2852,35 +2871,35 @@ fn main() {
             242..249 'loop {}': !
             247..249 '{}': ()
             360..364 'self': Self
-            689..693 'self': I
-            700..720 '{     ...     }': I
-            710..714 'self': I
-            779..790 '{ loop {} }': Vec<T>
-            781..788 'loop {}': !
-            786..788 '{}': ()
-            977..1104 '{     ... }); }': ()
-            983..998 'Vec::<i32>::new': fn new<i32>() -> Vec<i32>
-            983..1000 'Vec::<...:new()': Vec<i32>
-            983..1012 'Vec::<...iter()': IntoIter<i32>
-            983..1075 'Vec::<...one })': FilterMap<IntoIter<i32>, impl FnMut(i32) -> Option<u32>>
-            983..1101 'Vec::<... y; })': ()
-            1029..1074 '|x| if...None }': impl FnMut(i32) -> Option<u32>
-            1030..1031 'x': i32
-            1033..1074 'if x >...None }': Option<u32>
-            1036..1037 'x': i32
-            1036..1041 'x > 0': bool
-            1040..1041 '0': i32
-            1042..1060 '{ Some...u32) }': Option<u32>
-            1044..1048 'Some': fn Some<u32>(u32) -> Option<u32>
-            1044..1058 'Some(x as u32)': Option<u32>
-            1049..1050 'x': i32
-            1049..1057 'x as u32': u32
-            1066..1074 '{ None }': Option<u32>
-            1068..1072 'None': Option<u32>
-            1090..1100 '|y| { y; }': impl FnMut(u32)
-            1091..1092 'y': u32
-            1094..1100 '{ y; }': ()
-            1096..1097 'y': u32
+            692..696 'self': I
+            703..723 '{     ...     }': I
+            713..717 'self': I
+            783..794 '{ loop {} }': Vec<T>
+            785..792 'loop {}': !
+            790..792 '{}': ()
+            981..1108 '{     ... }); }': ()
+            987..1002 'Vec::<i32>::new': fn new<i32>() -> Vec<i32>
+            987..1004 'Vec::<...:new()': Vec<i32>
+            987..1016 'Vec::<...iter()': IntoIter<i32>
+            987..1079 'Vec::<...one })': FilterMap<IntoIter<i32>, impl FnMut(i32) -> Option<u32>>
+            987..1105 'Vec::<... y; })': ()
+            1033..1078 '|x| if...None }': impl FnMut(i32) -> Option<u32>
+            1034..1035 'x': i32
+            1037..1078 'if x >...None }': Option<u32>
+            1040..1041 'x': i32
+            1040..1045 'x > 0': bool
+            1044..1045 '0': i32
+            1046..1064 '{ Some...u32) }': Option<u32>
+            1048..1052 'Some': fn Some<u32>(u32) -> Option<u32>
+            1048..1062 'Some(x as u32)': Option<u32>
+            1053..1054 'x': i32
+            1053..1061 'x as u32': u32
+            1070..1078 '{ None }': Option<u32>
+            1072..1076 'None': Option<u32>
+            1094..1104 '|y| { y; }': impl FnMut(u32)
+            1095..1096 'y': u32
+            1098..1104 '{ y; }': ()
+            1100..1101 'y': u32
         "#]],
     );
 }
@@ -3134,7 +3153,6 @@ fn foo() {
 
 #[test]
 fn dyn_fn_param_informs_call_site_closure_signature() {
-    cov_mark::check!(dyn_fn_param_informs_call_site_closure_signature);
     check_types(
         r#"
 //- minicore: fn, coerce_unsized, dispatch_from_dyn
@@ -3617,7 +3635,7 @@ impl Add<&i32> for i32 { type Output = i32 }
 impl Add<u32> for u32 { type Output = u32 }
 impl Add<&u32> for u32 { type Output = u32 }
 
-struct V<T>;
+struct V<T>(T);
 impl<T> V<T> {
     fn default() -> Self { loop {} }
     fn get(&self, _: &T) -> &T { loop {} }
@@ -3646,7 +3664,7 @@ impl Add<&i32> for i32 { type Output = i32; }
 // fallback to integer type variable for `42`.
 impl Add<&()> for i32 { type Output = (); }
 
-struct V<T>;
+struct V<T>(T);
 impl<T> V<T> {
     fn default() -> Self { loop {} }
     fn get(&self) -> &T { loop {} }
@@ -4213,21 +4231,21 @@ fn f<T>(v: impl Trait) {
 }
 fn g<'a, T: 'a>(v: impl Trait<Assoc<T> = &'a T>) {
     let a = v.get::<T>();
-      //^ &'a T
+      //^ &'? T
     let a = v.get::<()>();
       //^ <impl Trait<Assoc<T> = &'a T> as Trait>::Assoc<()>
 }
 fn h<'a>(v: impl Trait<Assoc<i32> = &'a i32> + Trait<Assoc<i64> = &'a i64>) {
     let a = v.get::<i32>();
-      //^ &'a i32
+      //^ &'? i32
     let a = v.get::<i64>();
-      //^ &'a i64
+      //^ &'? i64
 }
 fn i<'a>(v: impl Trait<Assoc<i32> = &'a i32, Assoc<i64> = &'a i64>) {
     let a = v.get::<i32>();
-      //^ &'a i32
+      //^ &'? i32
     let a = v.get::<i64>();
-      //^ &'a i64
+      //^ &'? i64
 }
     "#,
     );
@@ -4257,8 +4275,8 @@ fn f<'a>(v: &dyn Trait<Assoc<i32> = &'a i32>) {
             127..128 'v': &'? (dyn Trait<Assoc<i32> = &'a i32> + '?)
             164..195 '{     ...f(); }': ()
             170..171 'v': &'? (dyn Trait<Assoc<i32> = &'a i32> + '?)
-            170..184 'v.get::<i32>()': {unknown}
-            170..192 'v.get:...eref()': &'? {unknown}
+            170..184 'v.get::<i32>()': <dyn Trait<Assoc<i32> = &'a i32> + '? as Trait>::Assoc<i32>
+            170..192 'v.get:...eref()': {unknown}
         "#]],
     );
 }
@@ -4485,7 +4503,9 @@ impl Trait for () {
 fn derive_macro_bounds() {
     check_types(
         r#"
-        //- minicore: clone, derive
+        //- minicore: clone, derive, phantom_data
+        use core::marker::PhantomData;
+
         #[derive(Clone)]
         struct Copy;
         struct NotCopy;
@@ -4508,7 +4528,7 @@ fn derive_macro_bounds() {
         struct AssocGeneric3<T: Tr>(Generic<T::Assoc>);
 
         #[derive(Clone)]
-        struct Vec<T>();
+        struct Vec<T>(PhantomData<T>);
 
         #[derive(Clone)]
         struct R1(Vec<R2>);
@@ -4532,9 +4552,9 @@ fn derive_macro_bounds() {
             let x: &AssocGeneric3<Copy> = &AssocGeneric3(Generic(NotCopy));
             let x = x.clone();
               //^ &'? AssocGeneric3<Copy>
-            let x = (&R1(Vec())).clone();
+            let x = (&R1(Vec(PhantomData))).clone();
               //^ R1
-            let x = (&R2(R1(Vec()))).clone();
+            let x = (&R2(R1(Vec(PhantomData)))).clone();
               //^ R2
         }
         "#,
@@ -4624,8 +4644,10 @@ fn ttt() {
 fn infer_borrow() {
     check_types(
         r#"
-//- minicore: index
-pub struct SomeMap<K>;
+//- minicore: index, phantom_data
+use core::marker::PhantomData;
+
+pub struct SomeMap<K>(PhantomData<K>);
 
 pub trait Borrow<Borrowed: ?Sized> {
     fn borrow(&self) -> &Borrowed;
@@ -4658,7 +4680,7 @@ impl<K> core::ops::IndexMut<K> for SomeMap<K> {
 }
 
 fn foo() {
-    let mut map = SomeMap;
+    let mut map = SomeMap(PhantomData);
     map["a"] = ();
     map;
   //^^^ SomeMap<&'static str>
@@ -4908,6 +4930,7 @@ fn main() {
 
 #[test]
 fn async_fn_return_type() {
+    // FIXME(next-solver): Async closures are lowered as closures currently. We should fix that.
     check_infer(
         r#"
 //- minicore: async_fn
@@ -4925,9 +4948,9 @@ fn main() {
             46..53 'loop {}': !
             51..53 '{}': ()
             67..97 '{     ...()); }': ()
-            73..76 'foo': fn foo<impl AsyncFn() -> impl Future<Output = ()>, ()>(impl AsyncFn() -> impl Future<Output = ()>)
+            73..76 'foo': fn foo<impl Fn(), ()>(impl Fn())
             73..94 'foo(as...|| ())': ()
-            77..93 'async ... || ()': impl AsyncFn() -> impl Future<Output = ()>
+            77..93 'async ... || ()': impl Fn()
             91..93 '()': ()
         "#]],
     );
@@ -5020,7 +5043,7 @@ fn main() {
             223..227 'iter': Box<dyn Iterator<Item = &'? [u8]> + 'static>
             273..280 'loop {}': !
             278..280 '{}': ()
-            290..291 '_': Box<dyn Iterator<Item = &'? [u8]> + 'static>
+            290..291 '_': Box<dyn Iterator<Item = &'? [u8]> + '?>
             294..298 'iter': Box<dyn Iterator<Item = &'? [u8]> + 'static>
             294..310 'iter.i...iter()': Box<dyn Iterator<Item = &'? [u8]> + 'static>
             152..156 'self': &'? mut Box<I>
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs b/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
index a6377243ed984..d73d7da4b9b98 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
@@ -428,9 +428,4 @@ impl FnTrait {
     pub fn get_id(self, db: &dyn HirDatabase, krate: Crate) -> Option<TraitId> {
         self.lang_item().resolve_trait(db, krate)
     }
-
-    #[inline]
-    pub(crate) fn is_async(self) -> bool {
-        matches!(self, FnTrait::AsyncFn | FnTrait::AsyncFnMut | FnTrait::AsyncFnOnce)
-    }
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/utils.rs b/src/tools/rust-analyzer/crates/hir-ty/src/utils.rs
index 07679d2a119d3..427c4bb68423d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/utils.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/utils.rs
@@ -20,14 +20,14 @@ use hir_expand::name::Name;
 use intern::sym;
 use rustc_abi::TargetDataLayout;
 use rustc_hash::FxHashSet;
-use rustc_type_ir::inherent::{IntoKind, SliceLike};
+use rustc_type_ir::inherent::{GenericArgs, IntoKind, SliceLike};
 use smallvec::{SmallVec, smallvec};
 use span::Edition;
-use stdx::never;
 
+use crate::next_solver::mapping::NextSolverToChalk;
 use crate::{
-    ChalkTraitId, Const, ConstScalar, GenericArg, Interner, Substitution, TargetFeatures, TraitRef,
-    TraitRefExt, Ty, WhereClause,
+    ChalkTraitId, Const, ConstScalar, Interner, Substitution, TargetFeatures, TraitRef,
+    TraitRefExt, Ty,
     consteval::unknown_const,
     db::HirDatabase,
     layout::{Layout, TagEncoding},
@@ -120,52 +120,6 @@ impl Iterator for SuperTraits<'_> {
     }
 }
 
-pub(super) fn elaborate_clause_supertraits(
-    db: &dyn HirDatabase,
-    clauses: impl Iterator<Item = WhereClause>,
-) -> ClauseElaborator<'_> {
-    let mut elaborator = ClauseElaborator { db, stack: Vec::new(), seen: FxHashSet::default() };
-    elaborator.extend_deduped(clauses);
-
-    elaborator
-}
-
-pub(super) struct ClauseElaborator<'a> {
-    db: &'a dyn HirDatabase,
-    stack: Vec<WhereClause>,
-    seen: FxHashSet<WhereClause>,
-}
-
-impl ClauseElaborator<'_> {
-    fn extend_deduped(&mut self, clauses: impl IntoIterator<Item = WhereClause>) {
-        self.stack.extend(clauses.into_iter().filter(|c| self.seen.insert(c.clone())))
-    }
-
-    fn elaborate_supertrait(&mut self, clause: &WhereClause) {
-        if let WhereClause::Implemented(trait_ref) = clause {
-            direct_super_trait_refs(self.db, trait_ref, |t| {
-                let clause = WhereClause::Implemented(t);
-                if self.seen.insert(clause.clone()) {
-                    self.stack.push(clause);
-                }
-            });
-        }
-    }
-}
-
-impl Iterator for ClauseElaborator<'_> {
-    type Item = WhereClause;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if let Some(next) = self.stack.pop() {
-            self.elaborate_supertrait(&next);
-            Some(next)
-        } else {
-            None
-        }
-    }
-}
-
 fn direct_super_traits_cb(db: &dyn DefDatabase, trait_: TraitId, cb: impl FnMut(TraitId)) {
     let resolver = LazyCell::new(|| trait_.resolver(db));
     let (generic_params, store) = db.generic_params_and_store(trait_.into());
@@ -239,34 +193,25 @@ pub(super) fn associated_type_by_name_including_super_traits(
     })
 }
 
-/// It is a bit different from the rustc equivalent. Currently it stores:
-/// - 0..n-1: generics of the parent
-/// - n: the function signature, encoded as a function pointer type
-///
-/// and it doesn't store the closure types and fields.
-///
-/// Codes should not assume this ordering, and should always use methods available
-/// on this struct for retrieving, and `TyBuilder::substs_for_closure` for creating.
 pub(crate) struct ClosureSubst<'a>(pub(crate) &'a Substitution);
 
 impl<'a> ClosureSubst<'a> {
-    pub(crate) fn parent_subst(&self) -> &'a [GenericArg] {
-        match self.0.as_slice(Interner) {
-            [x @ .., _] => x,
-            _ => {
-                never!("Closure missing parameter");
-                &[]
-            }
-        }
+    pub(crate) fn parent_subst(&self, db: &dyn HirDatabase) -> Substitution {
+        let interner = DbInterner::new_with(db, None, None);
+        let subst =
+            <Substitution as ChalkToNextSolver<crate::next_solver::GenericArgs<'_>>>::to_nextsolver(
+                self.0, interner,
+            );
+        subst.split_closure_args().parent_args.to_chalk(interner)
     }
 
-    pub(crate) fn sig_ty(&self) -> &'a Ty {
-        match self.0.as_slice(Interner) {
-            [.., x] => x.assert_ty_ref(Interner),
-            _ => {
-                unreachable!("Closure missing sig_ty parameter");
-            }
-        }
+    pub(crate) fn sig_ty(&self, db: &dyn HirDatabase) -> Ty {
+        let interner = DbInterner::new_with(db, None, None);
+        let subst =
+            <Substitution as ChalkToNextSolver<crate::next_solver::GenericArgs<'_>>>::to_nextsolver(
+                self.0, interner,
+            );
+        subst.split_closure_args_untupled().closure_sig_as_fn_ptr_ty.to_chalk(interner)
     }
 }
 
@@ -278,8 +223,17 @@ pub enum Unsafety {
     DeprecatedSafe2024,
 }
 
-pub fn target_feature_is_safe_in_target(target: &TargetData) -> bool {
-    matches!(target.arch, target::Arch::Wasm32 | target::Arch::Wasm64)
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TargetFeatureIsSafeInTarget {
+    No,
+    Yes,
+}
+
+pub fn target_feature_is_safe_in_target(target: &TargetData) -> TargetFeatureIsSafeInTarget {
+    match target.arch {
+        target::Arch::Wasm32 | target::Arch::Wasm64 => TargetFeatureIsSafeInTarget::Yes,
+        _ => TargetFeatureIsSafeInTarget::No,
+    }
 }
 
 pub fn is_fn_unsafe_to_call(
@@ -287,14 +241,14 @@ pub fn is_fn_unsafe_to_call(
     func: FunctionId,
     caller_target_features: &TargetFeatures,
     call_edition: Edition,
-    target_feature_is_safe: bool,
+    target_feature_is_safe: TargetFeatureIsSafeInTarget,
 ) -> Unsafety {
     let data = db.function_signature(func);
     if data.is_unsafe() {
         return Unsafety::Unsafe;
     }
 
-    if data.has_target_feature() && !target_feature_is_safe {
+    if data.has_target_feature() && target_feature_is_safe == TargetFeatureIsSafeInTarget::No {
         // RFC 2396 <https://rust-lang.github.io/rfcs/2396-target-feature-1.1.html>.
         let callee_target_features =
             TargetFeatures::from_attrs_no_implications(&db.attrs(func.into()));
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/variance.rs b/src/tools/rust-analyzer/crates/hir-ty/src/variance.rs
index a1ebff04bbd47..8593dba301b85 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/variance.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/variance.rs
@@ -49,7 +49,23 @@ pub(crate) fn variances_of(db: &dyn HirDatabase, def: GenericDefId) -> Option<Ar
     if count == 0 {
         return None;
     }
-    let variances = Context { generics, variances: vec![Variance::Bivariant; count], db }.solve();
+    let mut variances =
+        Context { generics, variances: vec![Variance::Bivariant; count], db }.solve();
+
+    // FIXME(next-solver): This is *not* the correct behavior. I don't know if it has an actual effect,
+    // since bivariance is prohibited in Rust, but rustc definitely does not fallback bivariance.
+    // So why do we do this? Because, with the new solver, the effects of bivariance are catastrophic:
+    // it leads to not relating types properly, and to very, very hard to debug bugs (speaking from experience).
+    // Furthermore, our variance infra is known to not handle cycles properly. Therefore, at least until we fix
+    // cycles, and perhaps forever at least for out tests, not allowing bivariance makes sense.
+    // Why specifically invariance? I don't have a strong reason, mainly that invariance is a stronger relationship
+    // (therefore, less room for mistakes) and that IMO incorrect covariance can be more problematic that incorrect
+    // bivariance, at least while we don't handle lifetimes anyway.
+    for variance in &mut variances {
+        if *variance == Variance::Bivariant {
+            *variance = Variance::Invariant;
+        }
+    }
 
     variances.is_empty().not().then(|| Arc::from_iter(variances))
 }
@@ -73,7 +89,8 @@ pub(crate) fn variances_of_cycle_initial(
     if count == 0 {
         return None;
     }
-    Some(Arc::from(vec![Variance::Bivariant; count]))
+    // FIXME(next-solver): Returns `Invariance` and not `Bivariance` here, see the comment in the main query.
+    Some(Arc::from(vec![Variance::Invariant; count]))
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
@@ -581,8 +598,8 @@ struct Other<'a> {
 }
 "#,
             expect![[r#"
-                Hello['a: bivariant]
-                Other['a: bivariant]
+                Hello['a: invariant]
+                Other['a: invariant]
             "#]],
         );
     }
@@ -601,7 +618,7 @@ struct Foo<T: Trait> { //~ ERROR [T: o]
 }
 "#,
             expect![[r#"
-                Foo[T: bivariant]
+                Foo[T: invariant]
             "#]],
         );
     }
@@ -683,9 +700,9 @@ struct TestBox<U,T:Getter<U>+Setter<U>> { //~ ERROR [U: *, T: +]
                 get[Self: contravariant, T: covariant]
                 get[Self: contravariant, T: contravariant]
                 TestStruct[U: covariant, T: covariant]
-                TestEnum[U: bivariant, T: covariant]
-                TestContraStruct[U: bivariant, T: covariant]
-                TestBox[U: bivariant, T: covariant]
+                TestEnum[U: invariant, T: covariant]
+                TestContraStruct[U: invariant, T: covariant]
+                TestBox[U: invariant, T: covariant]
             "#]],
         );
     }
@@ -805,8 +822,8 @@ enum SomeEnum<'a> { Nothing } //~ ERROR parameter `'a` is never used
 trait SomeTrait<'a> { fn foo(&self); } // OK on traits.
 "#,
             expect![[r#"
-                SomeStruct['a: bivariant]
-                SomeEnum['a: bivariant]
+                SomeStruct['a: invariant]
+                SomeEnum['a: invariant]
                 foo[Self: contravariant, 'a: invariant]
             "#]],
         );
@@ -834,14 +851,14 @@ struct DoubleNothing<T> {
 
 "#,
             expect![[r#"
-                SomeStruct[A: bivariant]
-                SomeEnum[A: bivariant]
-                ListCell[T: bivariant]
-                SelfTyAlias[T: bivariant]
-                WithBounds[T: bivariant]
-                WithWhereBounds[T: bivariant]
-                WithOutlivesBounds[T: bivariant]
-                DoubleNothing[T: bivariant]
+                SomeStruct[A: invariant]
+                SomeEnum[A: invariant]
+                ListCell[T: invariant]
+                SelfTyAlias[T: invariant]
+                WithBounds[T: invariant]
+                WithWhereBounds[T: invariant]
+                WithOutlivesBounds[T: invariant]
+                DoubleNothing[T: invariant]
             "#]],
         );
     }
@@ -952,7 +969,7 @@ struct S3<T>(S<T, T>);
 "#,
             expect![[r#"
                 S[T: covariant]
-                S2[T: bivariant]
+                S2[T: invariant]
                 S3[T: covariant]
             "#]],
         );
@@ -965,7 +982,7 @@ struct S3<T>(S<T, T>);
 struct FixedPoint<T, U, V>(&'static FixedPoint<(), T, U>, V);
 "#,
             expect![[r#"
-                FixedPoint[T: bivariant, U: bivariant, V: bivariant]
+                FixedPoint[T: invariant, U: invariant, V: invariant]
             "#]],
         );
     }
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index bd9360f30f165..3083b56515628 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -2549,11 +2549,13 @@ impl Function {
                 let target_feature_is_safe_in_target =
                     match &caller.krate(db).id.workspace_data(db).target {
                         Ok(target) => hir_ty::target_feature_is_safe_in_target(target),
-                        Err(_) => false,
+                        Err(_) => hir_ty::TargetFeatureIsSafeInTarget::No,
                     };
                 (target_features, target_feature_is_safe_in_target)
             })
-            .unwrap_or_else(|| (hir_ty::TargetFeatures::default(), false));
+            .unwrap_or_else(|| {
+                (hir_ty::TargetFeatures::default(), hir_ty::TargetFeatureIsSafeInTarget::No)
+            });
         matches!(
             hir_ty::is_fn_unsafe_to_call(
                 db,
@@ -4660,7 +4662,7 @@ impl Closure {
             .iter()
             .map(|capture| Type {
                 env: db.trait_environment_for_body(owner),
-                ty: capture.ty(&self.subst),
+                ty: capture.ty(db, &self.subst),
                 _pd: PhantomCovariantLifetime::new(),
             })
             .collect()
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_closure_to_fn.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_closure_to_fn.rs
index 5f526ec899404..3dd435d9423b2 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_closure_to_fn.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_closure_to_fn.rs
@@ -805,6 +805,7 @@ impl A {
         );
     }
 
+    #[ignore = "FIXME(next-solver): Fix async closures"]
     #[test]
     fn replaces_async_closure_with_async_fn() {
         check_assist(
@@ -1066,7 +1067,7 @@ fn foo() {
             r#"
 fn foo() {
     let (mut a, b) = (0.1, "abc");
-    fn closure(p1: i32, p2: &mut bool, a: &mut f64, b: &&'static str) {
+    fn closure(p1: i32, p2: &mut bool, a: &mut f64, b: &&str) {
         *a = 1.2;
         let c = *b;
     }
@@ -1098,7 +1099,7 @@ fn foo() {
             r#"
 fn foo() {
     let (mut a, b) = (0.1, "abc");
-    fn closure(p1: i32, p2: &mut bool, a: &mut f64, b: &&'static str) {
+    fn closure(p1: i32, p2: &mut bool, a: &mut f64, b: &&str) {
         let _: &mut bool = p2;
         *a = 1.2;
         let c = *b;
@@ -1136,7 +1137,7 @@ fn foo() {
             r#"
 fn foo() {
     let (mut a, b) = (0.1, "abc");
-    fn closure(p1: i32, p2: &mut bool, a: &mut f64, b: &&'static str) {
+    fn closure(p1: i32, p2: &mut bool, a: &mut f64, b: &&str) {
         let _: &mut bool = p2;
         *a = 1.2;
         let c = *b;
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_function.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_function.rs
index d88e3311bd7bf..3685cc904e947 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_function.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_function.rs
@@ -5043,7 +5043,7 @@ fn main() {
     fun_name(bar);
 }
 
-fn $0fun_name(bar: &'static str) {
+fn $0fun_name(bar: &str) {
     m!(bar);
 }
 "#,
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/dot.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/dot.rs
index b9ef68cc2d2a3..8b4f315ac5733 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/dot.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/dot.rs
@@ -1501,7 +1501,9 @@ fn main() {
     bar.$0
 }
 "#,
-            expect![[r#""#]],
+            expect![[r#"
+                me foo() fn(self: Bar)
+            "#]],
         );
     }
 
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs b/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
index 79137104b568d..5cc72ef845bf5 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
@@ -2011,7 +2011,7 @@ fn main() {
             en Enum                      Enum
             fn function()                fn()
             fn main()                    fn()
-            lc variable          &'static str
+            lc variable                  &str
             ma helper!(…) macro_rules! helper
             ma m!(…)           macro_rules! m
             ma makro!(…)   macro_rules! makro
@@ -2486,6 +2486,7 @@ fn bar() {
             md rust_2024 (use core::prelude::rust_2024)
             tt Clone
             tt Copy
+            tt FromIterator
             tt IntoIterator
             tt Iterator
             ta Result (use core::fmt::Result)
diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/typed_hole.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/typed_hole.rs
index 8d42770269057..542ac215f1cc6 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/typed_hole.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/typed_hole.rs
@@ -152,7 +152,7 @@ fn main() {
 fn main() {
     let mut x = t();
     x = _;
-      //^ 💡 error: invalid `_` expression, expected type `&'static str`
+      //^ 💡 error: invalid `_` expression, expected type `&str`
     x = "";
 }
 fn t<T>() -> T { loop {} }
diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/unresolved_method.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/unresolved_method.rs
index dcca85d4db33e..bd5d134348e27 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/unresolved_method.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/unresolved_method.rs
@@ -268,7 +268,7 @@ impl<T, U> A<T, U> {
 }
 fn main() {
     let a = A {a: 0, b: ""};
-    A::<i32, &'static str>::foo();
+    A::<i32, &str>::foo();
 }
 "#,
         );
@@ -351,4 +351,26 @@ fn foo() {
 "#,
         );
     }
+
+    #[test]
+    fn iter_collect() {
+        check_diagnostics(
+            r#"
+//- minicore: unsize, coerce_unsized, iterator, iterators, sized
+struct Map<K, V>(K, V);
+impl<K, V> FromIterator<(K, V)> for Map<K, V> {
+    fn from_iter<T: IntoIterator<Item = (K, V)>>(_iter: T) -> Self {
+        loop {}
+    }
+}
+
+fn foo() -> Map<i32, &'static [&'static str]> {
+    [
+        (123, &["abc", "def"] as _),
+        (456, &["ghi"] as _),
+    ].into_iter().collect()
+}
+        "#,
+        );
+    }
 }
diff --git a/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs b/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
index a88c0c9866e5f..b623e51ee45e5 100644
--- a/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
@@ -7195,7 +7195,7 @@ fn foo() {
 "#,
         expect![[r#"
             ```rust
-            &'static str
+            &str
             ```"#]],
     );
 }
@@ -8459,7 +8459,7 @@ format_args!("{aaaaa$0}");
             *aaaaa*
 
             ```rust
-            let aaaaa: &'static str
+            let aaaaa: &str
             ```
         "#]],
     );
@@ -8479,7 +8479,7 @@ format_args!("{$0aaaaa}");
             *aaaaa*
 
             ```rust
-            let aaaaa: &'static str
+            let aaaaa: &str
             ```
         "#]],
     );
@@ -8499,7 +8499,7 @@ format_args!(r"{$0aaaaa}");
             *aaaaa*
 
             ```rust
-            let aaaaa: &'static str
+            let aaaaa: &str
             ```
         "#]],
     );
@@ -8524,7 +8524,7 @@ foo!(r"{$0aaaaa}");
             *aaaaa*
 
             ```rust
-            let aaaaa: &'static str
+            let aaaaa: &str
             ```
         "#]],
     );
@@ -10168,7 +10168,7 @@ fn baz() {
 
             ---
 
-            `U` = `i32`, `T` = `&'static str`
+            `U` = `i32`, `T` = `&str`
         "#]],
     );
 }
@@ -10261,7 +10261,7 @@ fn bar() {
 
             ---
 
-            `T` = `i8`, `U` = `&'static str`
+            `T` = `i8`, `U` = `&str`
         "#]],
     );
 }
diff --git a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/bind_pat.rs b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/bind_pat.rs
index 7a4af4f7549c6..104740cbbf74a 100644
--- a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/bind_pat.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/bind_pat.rs
@@ -378,9 +378,9 @@ fn main() {
     let foo = foo3();
      // ^^^ impl Fn(f64, f64) -> u32
     let foo = foo4();
-     // ^^^ &'static dyn Fn(f64, f64) -> u32
+     // ^^^ &dyn Fn(f64, f64) -> u32
     let foo = foo5();
-     // ^^^ &'static dyn Fn(&dyn Fn(f64, f64) -> u32, f64) -> u32
+     // ^^^ &dyn Fn(&dyn Fn(f64, f64) -> u32, f64) -> u32
     let foo = foo6();
      // ^^^ impl Fn(f64, f64) -> u32
     let foo = foo7();
@@ -411,7 +411,7 @@ fn main() {
     let foo = foo3();
      // ^^^ impl Fn(f64, f64) -> u32
     let foo = foo4();
-     // ^^^ &'static dyn Fn(f64, f64) -> u32
+     // ^^^ &dyn Fn(f64, f64) -> u32
     let foo = foo5();
     let foo = foo6();
     let foo = foo7();
@@ -526,7 +526,7 @@ fn main() {
           //^^^^ i32
     let _ = 22;
     let test = "test";
-      //^^^^ &'static str
+      //^^^^ &str
     let test = InnerStruct {};
       //^^^^ InnerStruct
 
@@ -616,12 +616,12 @@ impl<T> Iterator for IntoIter<T> {
 
 fn main() {
     let mut data = Vec::new();
-          //^^^^ Vec<&'static str>
+          //^^^^ Vec<&str>
     data.push("foo");
     for i in data {
-      //^ &'static str
+      //^ &str
       let z = i;
-        //^ &'static str
+        //^ &str
     }
 }
 "#,
@@ -1015,7 +1015,7 @@ fn test<T>(t: T) {
 "#,
             expect![[r#"
                 fn test<T>(t: T) {
-                    let f = |a: i32, b: &'static str, c: T| {};
+                    let f = |a: i32, b: &str, c: T| {};
                     let result: () = f(42, "", t);
                 }
             "#]],
diff --git a/src/tools/rust-analyzer/crates/intern/src/symbol/symbols.rs b/src/tools/rust-analyzer/crates/intern/src/symbol/symbols.rs
index 983ed3684a4f6..1db4f8ecd6bab 100644
--- a/src/tools/rust-analyzer/crates/intern/src/symbol/symbols.rs
+++ b/src/tools/rust-analyzer/crates/intern/src/symbol/symbols.rs
@@ -437,6 +437,7 @@ define_symbols! {
     rustc_safe_intrinsic,
     rustc_skip_array_during_method_dispatch,
     rustc_skip_during_method_dispatch,
+    rustc_force_inline,
     semitransparent,
     shl_assign,
     shl,
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/tests/slow-tests/main.rs b/src/tools/rust-analyzer/crates/rust-analyzer/tests/slow-tests/main.rs
index 1b940c70da66b..8a04bc7798f8b 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/tests/slow-tests/main.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/tests/slow-tests/main.rs
@@ -1061,7 +1061,7 @@ fn main() {
         ),
         work_done_progress_params: Default::default(),
     });
-    assert!(res.to_string().contains("&'static str"));
+    assert!(res.to_string().contains("&str"));
 
     let res = server.send_request::<HoverRequest>(HoverParams {
         text_document_position_params: TextDocumentPositionParams::new(
@@ -1070,7 +1070,7 @@ fn main() {
         ),
         work_done_progress_params: Default::default(),
     });
-    assert!(res.to_string().contains("&'static str"));
+    assert!(res.to_string().contains("&str"));
 
     server.request::<GotoTypeDefinition>(
         GotoDefinitionParams {
diff --git a/src/tools/rust-analyzer/crates/test-utils/src/minicore.rs b/src/tools/rust-analyzer/crates/test-utils/src/minicore.rs
index 7c3e7fea1bdef..696928b522f94 100644
--- a/src/tools/rust-analyzer/crates/test-utils/src/minicore.rs
+++ b/src/tools/rust-analyzer/crates/test-utils/src/minicore.rs
@@ -169,6 +169,17 @@ pub mod marker {
     // region:phantom_data
     #[lang = "phantom_data"]
     pub struct PhantomData<T: PointeeSized>;
+
+    // region:clone
+    impl<T: PointeeSized> Clone for PhantomData<T> {
+        fn clone(&self) -> Self { Self }
+    }
+    // endregion:clone
+
+    // region:copy
+    impl<T: PointeeSized> Copy for PhantomData<T> {}
+    // endregion:copy
+
     // endregion:phantom_data
 
     // region:discriminant
@@ -1147,7 +1158,7 @@ pub mod fmt {
 
     pub struct Error;
     pub type Result = crate::result::Result<(), Error>;
-    pub struct Formatter<'a>;
+    pub struct Formatter<'a>(&'a ());
     pub struct DebugTuple;
     pub struct DebugStruct;
     impl Formatter<'_> {
@@ -1620,6 +1631,12 @@ pub mod iter {
                 {
                     loop {}
                 }
+                fn collect<B: FromIterator<Self::Item>>(self) -> B
+                where
+                    Self: Sized,
+                {
+                    loop {}
+                }
                 // endregion:iterators
             }
             impl<I: Iterator + PointeeSized> Iterator for &mut I {
@@ -1689,10 +1706,13 @@ pub mod iter {
                     loop {}
                 }
             }
+            pub trait FromIterator<A>: Sized {
+                fn from_iter<T: IntoIterator<Item = A>>(iter: T) -> Self;
+            }
         }
-        pub use self::collect::IntoIterator;
+        pub use self::collect::{IntoIterator, FromIterator};
     }
-    pub use self::traits::{IntoIterator, Iterator};
+    pub use self::traits::{IntoIterator, FromIterator, Iterator};
 }
 // endregion:iterator
 
@@ -1988,7 +2008,7 @@ pub mod prelude {
             convert::AsRef,                          // :as_ref
             convert::{From, Into, TryFrom, TryInto}, // :from
             default::Default,                        // :default
-            iter::{IntoIterator, Iterator},          // :iterator
+            iter::{IntoIterator, Iterator, FromIterator}, // :iterator
             macros::builtin::{derive, derive_const}, // :derive
             marker::Copy,                            // :copy
             marker::Send,                            // :send
diff --git a/src/tools/rust-analyzer/xtask/src/tidy.rs b/src/tools/rust-analyzer/xtask/src/tidy.rs
index f91192b0076ba..0462835f0675a 100644
--- a/src/tools/rust-analyzer/xtask/src/tidy.rs
+++ b/src/tools/rust-analyzer/xtask/src/tidy.rs
@@ -235,6 +235,10 @@ impl TidyDocs {
             return;
         }
 
+        if is_ported_from_rustc(path, &["crates/hir-ty/src/next_solver"]) {
+            return;
+        }
+
         let first_line = match text.lines().next() {
             Some(it) => it,
             None => return,
@@ -290,6 +294,11 @@ fn is_exclude_dir(p: &Path, dirs_to_exclude: &[&str]) -> bool {
         .any(|it| dirs_to_exclude.contains(&it))
 }
 
+fn is_ported_from_rustc(p: &Path, dirs_to_exclude: &[&str]) -> bool {
+    let p = p.strip_prefix(project_root()).unwrap();
+    dirs_to_exclude.iter().any(|exclude| p.starts_with(exclude))
+}
+
 #[derive(Default)]
 struct TidyMarks {
     hits: HashSet<String>,

From bf73aac8cbdfeff983dce44b883993be2ae89151 Mon Sep 17 00:00:00 2001
From: Martin Nordholts <martin.nordholts@codetale.se>
Date: Mon, 15 Sep 2025 18:34:02 +0200
Subject: [PATCH 0967/1889] compiletest: Make `./x test --test-args ...` work
 again

It accidentally broke with a48c8e337d1. The intention of that commit was
to keep existing behavior if `--exact` is not used, but it had a bug.
This commit fixes that bug.
---
 src/tools/compiletest/src/executor.rs | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/tools/compiletest/src/executor.rs b/src/tools/compiletest/src/executor.rs
index 37cc17351d5fe..c8e13d4457383 100644
--- a/src/tools/compiletest/src/executor.rs
+++ b/src/tools/compiletest/src/executor.rs
@@ -295,11 +295,14 @@ fn filter_tests(opts: &Config, tests: Vec<CollectedTest>) -> Vec<CollectedTest>
     let mut filtered = tests;
 
     let matches_filter = |test: &CollectedTest, filter_str: &str| {
-        let filterable_path = test.desc.filterable_path.as_str();
         if opts.filter_exact {
-            filterable_path == filter_str
+            // When `--exact` is used we must use `filterable_path` to get
+            // reasonable filtering behavior.
+            test.desc.filterable_path.as_str() == filter_str
         } else {
-            filterable_path.contains(filter_str)
+            // For compatibility we use the name (which includes the full path)
+            // if `--exact` is not used.
+            test.desc.name.contains(filter_str)
         }
     };
 

From 487cdbc07d4bc73b8c52c7a35a99d2e0a64c6f55 Mon Sep 17 00:00:00 2001
From: Shoyu Vanilla <modulo641@gmail.com>
Date: Tue, 16 Sep 2025 01:44:00 +0900
Subject: [PATCH 0968/1889] fix: More precise clause filtering for
 `explicit_*_predicates_of`

---
 .../crates/hir-ty/src/next_solver/interner.rs | 26 ++++++++++++++-----
 1 file changed, 20 insertions(+), 6 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
index 7b6e8a1073d78..76d10f7dcc503 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
@@ -1330,16 +1330,23 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
         self,
         def_id: Self::TraitId,
     ) -> EarlyBinder<Self, impl IntoIterator<Item = (Self::Clause, Self::Span)>> {
+        let is_self = |ty: Ty<'db>| match ty.kind() {
+            rustc_type_ir::TyKind::Param(param) => param.index == 0,
+            _ => false,
+        };
+
         let predicates: Vec<(Clause<'db>, Span)> = self
             .db()
             .generic_predicates_ns(def_id.0.into())
             .iter()
             .filter(|p| match p.kind().skip_binder() {
-                rustc_type_ir::ClauseKind::Trait(tr) => match tr.self_ty().kind() {
-                    rustc_type_ir::TyKind::Param(param) => param.index == 0,
-                    _ => false,
-                },
-                _ => true,
+                // rustc has the following assertion:
+                // https://github.com/rust-lang/rust/blob/52618eb338609df44978b0ca4451ab7941fd1c7a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs#L525-L608
+                rustc_type_ir::ClauseKind::Trait(it) => is_self(it.self_ty()),
+                rustc_type_ir::ClauseKind::TypeOutlives(it) => is_self(it.0),
+                rustc_type_ir::ClauseKind::Projection(it) => is_self(it.self_ty()),
+                rustc_type_ir::ClauseKind::HostEffect(it) => is_self(it.self_ty()),
+                _ => false,
             })
             .cloned()
             .map(|p| (p, Span::dummy()))
@@ -1367,7 +1374,14 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
             .generic_predicates_ns(def_id.try_into().unwrap())
             .iter()
             .filter(|p| match p.kind().skip_binder() {
-                rustc_type_ir::ClauseKind::Trait(tr) => is_self_or_assoc(tr.self_ty()),
+                rustc_type_ir::ClauseKind::Trait(it) => is_self_or_assoc(it.self_ty()),
+                rustc_type_ir::ClauseKind::TypeOutlives(it) => is_self_or_assoc(it.0),
+                rustc_type_ir::ClauseKind::Projection(it) => is_self_or_assoc(it.self_ty()),
+                rustc_type_ir::ClauseKind::HostEffect(it) => is_self_or_assoc(it.self_ty()),
+                // FIXME: Not sure is this correct to allow other clauses but we might replace
+                // `generic_predicates_ns` query here with something closer to rustc's
+                // `implied_bounds_with_filter`, which is more granular lowering than this
+                // "lower at once and then filter" implementation.
                 _ => true,
             })
             .cloned()

From c4da39cca328e1aaabb513f20d32c55bbbc49057 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Mon, 15 Sep 2025 18:48:57 +0200
Subject: [PATCH 0969/1889] Recognize canonical `?` pattern with `Result`

---
 clippy_lints/src/question_mark.rs | 21 +++++--
 tests/ui/question_mark.fixed      | 14 ++++-
 tests/ui/question_mark.rs         | 26 ++++++++-
 tests/ui/question_mark.stderr     | 92 ++++++++++++++++++++-----------
 4 files changed, 113 insertions(+), 40 deletions(-)

diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index de12a25b03dff..4aa100a50e053 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -8,9 +8,9 @@ use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use clippy_utils::{
-    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_res, path_to_local, path_to_local_id, peel_blocks, peel_blocks_with_stmt,
-    span_contains_cfg, span_contains_comment, sym,
+    eq_expr_value, fn_def_id_with_node_args, 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_res, path_to_local, path_to_local_id,
+    peel_blocks, peel_blocks_with_stmt, span_contains_cfg, span_contains_comment, sym,
 };
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{self, OptionNone, OptionSome, ResultErr, ResultOk};
@@ -393,8 +393,8 @@ fn check_arm_is_none_or_err<'tcx>(cx: &LateContext<'tcx>, mode: TryMode, arm: &A
                 && let ExprKind::Ret(Some(wrapped_ret_expr)) = arm_body.kind
                 && let ExprKind::Call(ok_ctor, [ret_expr]) = wrapped_ret_expr.kind
                 && is_res_lang_ctor(cx, path_res(cx, ok_ctor), ResultErr)
-                // check `...` is `val` from binding
-                && path_to_local_id(ret_expr, ok_val)
+                // check if `...` is `val` from binding or `val.into()`
+                && is_local_or_local_into(cx, ret_expr, ok_val)
             {
                 true
             } else {
@@ -417,6 +417,17 @@ fn check_arm_is_none_or_err<'tcx>(cx: &LateContext<'tcx>, mode: TryMode, arm: &A
     }
 }
 
+/// Check if `expr` is `val` or `val.into()`
+fn is_local_or_local_into(cx: &LateContext<'_>, expr: &Expr<'_>, val: HirId) -> bool {
+    let is_into_call = fn_def_id_with_node_args(cx, expr)
+        .and_then(|(fn_def_id, _)| cx.tcx.trait_of_assoc(fn_def_id))
+        .is_some_and(|trait_def_id| cx.tcx.is_diagnostic_item(sym::Into, trait_def_id));
+    match expr.kind {
+        ExprKind::MethodCall(_, recv, [], _) | ExprKind::Call(_, [recv]) => is_into_call && path_to_local_id(recv, val),
+        _ => path_to_local_id(expr, val),
+    }
+}
+
 fn check_arms_are_try<'tcx>(cx: &LateContext<'tcx>, mode: TryMode, arm1: &Arm<'tcx>, arm2: &Arm<'tcx>) -> bool {
     (check_arm_is_some_or_ok(cx, mode, arm1) && check_arm_is_none_or_err(cx, mode, arm2))
         || (check_arm_is_some_or_ok(cx, mode, arm2) && check_arm_is_none_or_err(cx, mode, arm1))
diff --git a/tests/ui/question_mark.fixed b/tests/ui/question_mark.fixed
index 8d6f5fbadca56..ac81b324c2049 100644
--- a/tests/ui/question_mark.fixed
+++ b/tests/ui/question_mark.fixed
@@ -1,6 +1,4 @@
 #![feature(try_blocks)]
-#![allow(unreachable_code)]
-#![allow(dead_code)]
 #![allow(clippy::unnecessary_wraps)]
 
 use std::sync::MutexGuard;
@@ -465,3 +463,15 @@ fn issue_13642(x: Option<i32>) -> Option<()> {
 
     None
 }
+
+fn issue_15679() -> Result<i32, String> {
+    let some_result: Result<i32, &'static str> = todo!();
+
+    some_result?;
+
+    some_result?;
+
+    some_result?;
+
+    Ok(0)
+}
diff --git a/tests/ui/question_mark.rs b/tests/ui/question_mark.rs
index f13eee29c113c..b5866dac6b8f6 100644
--- a/tests/ui/question_mark.rs
+++ b/tests/ui/question_mark.rs
@@ -1,6 +1,4 @@
 #![feature(try_blocks)]
-#![allow(unreachable_code)]
-#![allow(dead_code)]
 #![allow(clippy::unnecessary_wraps)]
 
 use std::sync::MutexGuard;
@@ -561,3 +559,27 @@ fn issue_13642(x: Option<i32>) -> Option<()> {
 
     None
 }
+
+fn issue_15679() -> Result<i32, String> {
+    let some_result: Result<i32, &'static str> = todo!();
+
+    match some_result {
+        //~^ question_mark
+        Ok(val) => val,
+        Err(err) => return Err(err.into()),
+    };
+
+    match some_result {
+        //~^ question_mark
+        Ok(val) => val,
+        Err(err) => return Err(Into::into(err)),
+    };
+
+    match some_result {
+        //~^ question_mark
+        Ok(val) => val,
+        Err(err) => return Err(<&str as Into<String>>::into(err)),
+    };
+
+    Ok(0)
+}
diff --git a/tests/ui/question_mark.stderr b/tests/ui/question_mark.stderr
index d8ce4420aeeb6..1ecd936292e55 100644
--- a/tests/ui/question_mark.stderr
+++ b/tests/ui/question_mark.stderr
@@ -1,5 +1,5 @@
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:9:5
+  --> tests/ui/question_mark.rs:7:5
    |
 LL | /     if a.is_none() {
 LL | |
@@ -11,7 +11,7 @@ LL | |     }
    = help: to override `-D warnings` add `#[allow(clippy::question_mark)]`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:55:9
+  --> tests/ui/question_mark.rs:53:9
    |
 LL | /         if (self.opt).is_none() {
 LL | |
@@ -20,7 +20,7 @@ LL | |         }
    | |_________^ help: replace it with: `(self.opt)?;`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:60:9
+  --> tests/ui/question_mark.rs:58:9
    |
 LL | /         if self.opt.is_none() {
 LL | |
@@ -29,7 +29,7 @@ LL | |         }
    | |_________^ help: replace it with: `self.opt?;`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:65:17
+  --> tests/ui/question_mark.rs:63:17
    |
 LL |           let _ = if self.opt.is_none() {
    |  _________________^
@@ -41,7 +41,7 @@ LL | |         };
    | |_________^ help: replace it with: `Some(self.opt?)`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:72:17
+  --> tests/ui/question_mark.rs:70:17
    |
 LL |           let _ = if let Some(x) = self.opt {
    |  _________________^
@@ -53,7 +53,7 @@ LL | |         };
    | |_________^ help: replace it with: `self.opt?`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:90:9
+  --> tests/ui/question_mark.rs:88:9
    |
 LL | /         if self.opt.is_none() {
 LL | |
@@ -62,7 +62,7 @@ LL | |         }
    | |_________^ help: replace it with: `self.opt.as_ref()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:99:9
+  --> tests/ui/question_mark.rs:97:9
    |
 LL | /         if self.opt.is_none() {
 LL | |
@@ -71,7 +71,7 @@ LL | |         }
    | |_________^ help: replace it with: `self.opt.as_ref()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:108:9
+  --> tests/ui/question_mark.rs:106:9
    |
 LL | /         if self.opt.is_none() {
 LL | |
@@ -80,7 +80,7 @@ LL | |         }
    | |_________^ help: replace it with: `self.opt.as_ref()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:116:26
+  --> tests/ui/question_mark.rs:114:26
    |
 LL |           let v: &Vec<_> = if let Some(ref v) = self.opt {
    |  __________________________^
@@ -92,7 +92,7 @@ LL | |         };
    | |_________^ help: replace it with: `self.opt.as_ref()?`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:127:17
+  --> tests/ui/question_mark.rs:125:17
    |
 LL |           let v = if let Some(v) = self.opt {
    |  _________________^
@@ -104,7 +104,7 @@ LL | |         };
    | |_________^ help: replace it with: `self.opt?`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:149:5
+  --> tests/ui/question_mark.rs:147:5
    |
 LL | /     if f().is_none() {
 LL | |
@@ -113,7 +113,7 @@ LL | |     }
    | |_____^ help: replace it with: `f()?;`
 
 error: this `match` expression can be replaced with `?`
-  --> tests/ui/question_mark.rs:154:16
+  --> tests/ui/question_mark.rs:152:16
    |
 LL |       let _val = match f() {
    |  ________________^
@@ -124,7 +124,7 @@ LL | |     };
    | |_____^ help: try instead: `f()?`
 
 error: this `match` expression can be replaced with `?`
-  --> tests/ui/question_mark.rs:165:5
+  --> tests/ui/question_mark.rs:163:5
    |
 LL | /     match f() {
 LL | |
@@ -134,7 +134,7 @@ LL | |     };
    | |_____^ help: try instead: `f()?`
 
 error: this `match` expression can be replaced with `?`
-  --> tests/ui/question_mark.rs:171:5
+  --> tests/ui/question_mark.rs:169:5
    |
 LL | /     match opt_none!() {
 LL | |
@@ -144,13 +144,13 @@ LL | |     };
    | |_____^ help: try instead: `opt_none!()?`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:198:13
+  --> tests/ui/question_mark.rs:196:13
    |
 LL |     let _ = if let Ok(x) = x { x } else { return x };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `x?`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:201:5
+  --> tests/ui/question_mark.rs:199:5
    |
 LL | /     if x.is_err() {
 LL | |
@@ -159,7 +159,7 @@ LL | |     }
    | |_____^ help: replace it with: `x?;`
 
 error: this `match` expression can be replaced with `?`
-  --> tests/ui/question_mark.rs:206:16
+  --> tests/ui/question_mark.rs:204:16
    |
 LL |       let _val = match func_returning_result() {
    |  ________________^
@@ -170,7 +170,7 @@ LL | |     };
    | |_____^ help: try instead: `func_returning_result()?`
 
 error: this `match` expression can be replaced with `?`
-  --> tests/ui/question_mark.rs:212:5
+  --> tests/ui/question_mark.rs:210:5
    |
 LL | /     match func_returning_result() {
 LL | |
@@ -180,7 +180,7 @@ LL | |     };
    | |_____^ help: try instead: `func_returning_result()?`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:304:5
+  --> tests/ui/question_mark.rs:302:5
    |
 LL | /     if let Err(err) = func_returning_result() {
 LL | |
@@ -189,7 +189,7 @@ LL | |     }
    | |_____^ help: replace it with: `func_returning_result()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:312:5
+  --> tests/ui/question_mark.rs:310:5
    |
 LL | /     if let Err(err) = func_returning_result() {
 LL | |
@@ -198,7 +198,7 @@ LL | |     }
    | |_____^ help: replace it with: `func_returning_result()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:395:13
+  --> tests/ui/question_mark.rs:393:13
    |
 LL | /             if a.is_none() {
 LL | |
@@ -208,7 +208,7 @@ LL | |             }
    | |_____________^ help: replace it with: `a?;`
 
 error: this `let...else` may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:456:5
+  --> tests/ui/question_mark.rs:454:5
    |
 LL | /     let Some(v) = bar.foo.owned.clone() else {
 LL | |         return None;
@@ -216,7 +216,7 @@ LL | |     };
    | |______^ help: replace it with: `let v = bar.foo.owned.clone()?;`
 
 error: this `let...else` may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:471:5
+  --> tests/ui/question_mark.rs:469:5
    |
 LL | /     let Some(ref x) = foo.opt_x else {
 LL | |         return None;
@@ -224,7 +224,7 @@ LL | |     };
    | |______^ help: replace it with: `let x = foo.opt_x.as_ref()?;`
 
 error: this `let...else` may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:481:5
+  --> tests/ui/question_mark.rs:479:5
    |
 LL | /     let Some(ref mut x) = foo.opt_x else {
 LL | |         return None;
@@ -232,7 +232,7 @@ LL | |     };
    | |______^ help: replace it with: `let x = foo.opt_x.as_mut()?;`
 
 error: this `let...else` may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:492:5
+  --> tests/ui/question_mark.rs:490:5
    |
 LL | /     let Some(ref x @ ref y) = foo.opt_x else {
 LL | |         return None;
@@ -240,7 +240,7 @@ LL | |     };
    | |______^ help: replace it with: `let x @ y = foo.opt_x.as_ref()?;`
 
 error: this `let...else` may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:496:5
+  --> tests/ui/question_mark.rs:494:5
    |
 LL | /     let Some(ref x @ WrapperStructWithString(_)) = bar else {
 LL | |         return None;
@@ -248,7 +248,7 @@ LL | |     };
    | |______^ help: replace it with: `let x @ &WrapperStructWithString(_) = bar.as_ref()?;`
 
 error: this `let...else` may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:500:5
+  --> tests/ui/question_mark.rs:498:5
    |
 LL | /     let Some(ref mut x @ WrapperStructWithString(_)) = bar else {
 LL | |         return None;
@@ -256,7 +256,7 @@ LL | |     };
    | |______^ help: replace it with: `let x @ &mut WrapperStructWithString(_) = bar.as_mut()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:522:5
+  --> tests/ui/question_mark.rs:520:5
    |
 LL | /     if arg.is_none() {
 LL | |
@@ -265,7 +265,7 @@ LL | |     }
    | |_____^ help: replace it with: `arg?;`
 
 error: this `match` expression can be replaced with `?`
-  --> tests/ui/question_mark.rs:526:15
+  --> tests/ui/question_mark.rs:524:15
    |
 LL |       let val = match arg {
    |  _______________^
@@ -276,12 +276,42 @@ LL | |     };
    | |_____^ help: try instead: `arg?`
 
 error: this `let...else` may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:536:5
+  --> tests/ui/question_mark.rs:534:5
    |
 LL | /     let Some(a) = *a else {
 LL | |         return None;
 LL | |     };
    | |______^ help: replace it with: `let a = (*a)?;`
 
-error: aborting due to 30 previous errors
+error: this `match` expression can be replaced with `?`
+  --> tests/ui/question_mark.rs:566:5
+   |
+LL | /     match some_result {
+LL | |
+LL | |         Ok(val) => val,
+LL | |         Err(err) => return Err(err.into()),
+LL | |     };
+   | |_____^ help: try instead: `some_result?`
+
+error: this `match` expression can be replaced with `?`
+  --> tests/ui/question_mark.rs:572:5
+   |
+LL | /     match some_result {
+LL | |
+LL | |         Ok(val) => val,
+LL | |         Err(err) => return Err(Into::into(err)),
+LL | |     };
+   | |_____^ help: try instead: `some_result?`
+
+error: this `match` expression can be replaced with `?`
+  --> tests/ui/question_mark.rs:578:5
+   |
+LL | /     match some_result {
+LL | |
+LL | |         Ok(val) => val,
+LL | |         Err(err) => return Err(<&str as Into<String>>::into(err)),
+LL | |     };
+   | |_____^ help: try instead: `some_result?`
+
+error: aborting due to 33 previous errors
 

From c8663eec6a667ae6e7571297cb15192425311c33 Mon Sep 17 00:00:00 2001
From: Aapo Alasuutari <aapo.alasuutari@gmail.com>
Date: Fri, 29 Aug 2025 23:29:46 +0300
Subject: [PATCH 0970/1889] Introduce CoerceShared lang item and trait

---
 compiler/rustc_hir/src/lang_items.rs | 1 +
 compiler/rustc_span/src/symbol.rs    | 1 +
 library/core/src/marker.rs           | 9 +++++++++
 3 files changed, 11 insertions(+)

diff --git a/compiler/rustc_hir/src/lang_items.rs b/compiler/rustc_hir/src/lang_items.rs
index 67d2f15d41472..889b16a7a2bb6 100644
--- a/compiler/rustc_hir/src/lang_items.rs
+++ b/compiler/rustc_hir/src/lang_items.rs
@@ -441,6 +441,7 @@ language_item_table! {
 
     // Reborrowing related lang-items
     Reborrow,                sym::reborrow,            reborrow,                   Target::Trait,          GenericRequirement::Exact(0);
+    CoerceShared,            sym::coerce_shared,       coerce_shared,              Target::Trait,          GenericRequirement::Exact(0);
 }
 
 /// The requirement imposed on the generics of a lang item
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index cdb0b5b58da6d..882abf7bcc977 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -679,6 +679,7 @@ symbols! {
         cmpxchg16b_target_feature,
         cmse_nonsecure_entry,
         coerce_pointee_validated,
+        coerce_shared,
         coerce_unsized,
         cold,
         cold_path,
diff --git a/library/core/src/marker.rs b/library/core/src/marker.rs
index d03d7a43469a7..8541a5b91cdde 100644
--- a/library/core/src/marker.rs
+++ b/library/core/src/marker.rs
@@ -1372,3 +1372,12 @@ pub trait CoercePointeeValidated {
 pub trait Reborrow {
     // Empty.
 }
+
+/// Allows reborrowable value to be reborrowed as shared, creating a copy of
+/// that disables the source for writes for the lifetime of the copy.
+#[lang = "coerce_shared"]
+#[unstable(feature = "reborrow", issue = "145612")]
+pub trait CoerceShared: Reborrow {
+    /// The type of this value when reborrowed as shared.
+    type Target: Copy;
+}

From fce8c13f77bcbebfea4461536be828d7136b8c1a Mon Sep 17 00:00:00 2001
From: Aapo Alasuutari <aapo.alasuutari@gmail.com>
Date: Fri, 29 Aug 2025 23:35:07 +0300
Subject: [PATCH 0971/1889] Add reborrow CoerceShared feature gate test

---
 .../feature-gate-reborrow-coerce-shared.rs          |  3 +++
 .../feature-gate-reborrow-coerce-shared.stderr      | 13 +++++++++++++
 2 files changed, 16 insertions(+)
 create mode 100644 tests/ui/feature-gates/feature-gate-reborrow-coerce-shared.rs
 create mode 100644 tests/ui/feature-gates/feature-gate-reborrow-coerce-shared.stderr

diff --git a/tests/ui/feature-gates/feature-gate-reborrow-coerce-shared.rs b/tests/ui/feature-gates/feature-gate-reborrow-coerce-shared.rs
new file mode 100644
index 0000000000000..48a14959d8d64
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-reborrow-coerce-shared.rs
@@ -0,0 +1,3 @@
+use std::marker::CoerceShared; //~ ERROR  use of unstable library feature `reborrow`
+
+fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-reborrow-coerce-shared.stderr b/tests/ui/feature-gates/feature-gate-reborrow-coerce-shared.stderr
new file mode 100644
index 0000000000000..c4c5e06778af3
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-reborrow-coerce-shared.stderr
@@ -0,0 +1,13 @@
+error[E0658]: use of unstable library feature `reborrow`
+  --> $DIR/feature-gate-reborrow-coerce-shared.rs:1:5
+   |
+LL | use std::marker::CoerceShared;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #145612 <https://github.com/rust-lang/rust/issues/145612> for more information
+   = help: add `#![feature(reborrow)]` 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`.

From 35bae9df1dfb164de7be95180a0982312128d559 Mon Sep 17 00:00:00 2001
From: Aapo Alasuutari <aapo.alasuutari@gmail.com>
Date: Sat, 30 Aug 2025 21:16:56 +0300
Subject: [PATCH 0972/1889] Introduce basic Reborrow tests

---
 tests/ui/reborrow/custom_mut.rs               | 13 +++++++++
 tests/ui/reborrow/custom_mut.stderr           | 29 +++++++++++++++++++
 tests/ui/reborrow/custom_mut_coerce_shared.rs | 28 ++++++++++++++++++
 .../reborrow/custom_mut_coerce_shared.stderr  | 19 ++++++++++++
 tests/ui/reborrow/option_mut.rs               |  7 +++++
 tests/ui/reborrow/option_mut.stderr           | 21 ++++++++++++++
 tests/ui/reborrow/option_mut_coerce_shared.rs | 11 +++++++
 .../reborrow/option_mut_coerce_shared.stderr  | 23 +++++++++++++++
 tests/ui/reborrow/pin_mut.rs                  | 10 +++++++
 tests/ui/reborrow/pin_mut.stderr              | 21 ++++++++++++++
 tests/ui/reborrow/pin_mut_coerce_shared.rs    | 14 +++++++++
 .../ui/reborrow/pin_mut_coerce_shared.stderr  | 19 ++++++++++++
 12 files changed, 215 insertions(+)
 create mode 100644 tests/ui/reborrow/custom_mut.rs
 create mode 100644 tests/ui/reborrow/custom_mut.stderr
 create mode 100644 tests/ui/reborrow/custom_mut_coerce_shared.rs
 create mode 100644 tests/ui/reborrow/custom_mut_coerce_shared.stderr
 create mode 100644 tests/ui/reborrow/option_mut.rs
 create mode 100644 tests/ui/reborrow/option_mut.stderr
 create mode 100644 tests/ui/reborrow/option_mut_coerce_shared.rs
 create mode 100644 tests/ui/reborrow/option_mut_coerce_shared.stderr
 create mode 100644 tests/ui/reborrow/pin_mut.rs
 create mode 100644 tests/ui/reborrow/pin_mut.stderr
 create mode 100644 tests/ui/reborrow/pin_mut_coerce_shared.rs
 create mode 100644 tests/ui/reborrow/pin_mut_coerce_shared.stderr

diff --git a/tests/ui/reborrow/custom_mut.rs b/tests/ui/reborrow/custom_mut.rs
new file mode 100644
index 0000000000000..b55a5e6faa3dc
--- /dev/null
+++ b/tests/ui/reborrow/custom_mut.rs
@@ -0,0 +1,13 @@
+#![feature(reborrow)]
+use std::marker::Reborrow;
+
+struct CustomMut<'a, T>(&'a mut T);
+impl<'a, T> Reborrow for CustomMut<'a, T> {}
+
+fn method(a: CustomMut<'_, ()>) {}
+
+fn main() {
+    let a = CustomMut(&mut ());
+    let _ = method(a);
+    let _ = method(a); //~ERROR use of moved value: `a`
+}
diff --git a/tests/ui/reborrow/custom_mut.stderr b/tests/ui/reborrow/custom_mut.stderr
new file mode 100644
index 0000000000000..3b3f47b62d6fa
--- /dev/null
+++ b/tests/ui/reborrow/custom_mut.stderr
@@ -0,0 +1,29 @@
+error[E0382]: use of moved value: `a`
+  --> $DIR/custom_mut.rs:12:20
+   |
+LL |     let a = CustomMut(&mut ());
+   |         - move occurs because `a` has type `CustomMut<'_, ()>`, which does not implement the `Copy` trait
+LL |     let _ = method(a);
+   |                    - value moved here
+LL |     let _ = method(a);
+   |                    ^ value used here after move
+   |
+note: consider changing this parameter type in function `method` to borrow instead if owning the value isn't necessary
+  --> $DIR/custom_mut.rs:7:14
+   |
+LL | fn method(a: CustomMut<'_, ()>) {}
+   |    ------    ^^^^^^^^^^^^^^^^^ this parameter takes ownership of the value
+   |    |
+   |    in this function
+note: if `CustomMut<'_, ()>` implemented `Clone`, you could clone the value
+  --> $DIR/custom_mut.rs:4:1
+   |
+LL | struct CustomMut<'a, T>(&'a mut T);
+   | ^^^^^^^^^^^^^^^^^^^^^^^ consider implementing `Clone` for this type
+...
+LL |     let _ = method(a);
+   |                    - you could clone this value
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/reborrow/custom_mut_coerce_shared.rs b/tests/ui/reborrow/custom_mut_coerce_shared.rs
new file mode 100644
index 0000000000000..b292b5b073ce8
--- /dev/null
+++ b/tests/ui/reborrow/custom_mut_coerce_shared.rs
@@ -0,0 +1,28 @@
+#![feature(reborrow)]
+use std::marker::{Reborrow, CoerceShared};
+
+struct CustomMut<'a, T>(&'a mut T);
+impl<'a, T> Reborrow for CustomMut<'a, T> {}
+impl<'a, T> CoerceShared for CustomMut<'a, T> {
+    type Target = CustomRef<'a, T>;
+}
+
+struct CustomRef<'a, T>(&'a T);
+
+impl<'a, T> Clone for CustomRef<'a, T> {
+    fn clone(&self) -> Self {
+        Self(self.0)
+    }
+}
+impl<'a, T> Copy for CustomRef<'a, T> {}
+
+fn method(a: CustomRef<'_, ()>) {}  //~NOTE function defined here
+
+fn main() {
+    let a = CustomMut(&mut ());
+    method(a);
+    //~^ ERROR mismatched types
+    //~| NOTE expected `CustomRef<'_, ()>`, found `CustomMut<'_, ()>`
+    //~| NOTE arguments to this function are incorrect
+    //~| NOTE expected struct `CustomRef<'_, ()>`
+}
diff --git a/tests/ui/reborrow/custom_mut_coerce_shared.stderr b/tests/ui/reborrow/custom_mut_coerce_shared.stderr
new file mode 100644
index 0000000000000..508651badc0a4
--- /dev/null
+++ b/tests/ui/reborrow/custom_mut_coerce_shared.stderr
@@ -0,0 +1,19 @@
+error[E0308]: mismatched types
+  --> $DIR/custom_mut_coerce_shared.rs:23:12
+   |
+LL |     method(a);
+   |     ------ ^ expected `CustomRef<'_, ()>`, found `CustomMut<'_, ()>`
+   |     |
+   |     arguments to this function are incorrect
+   |
+   = note: expected struct `CustomRef<'_, ()>`
+              found struct `CustomMut<'_, ()>`
+note: function defined here
+  --> $DIR/custom_mut_coerce_shared.rs:19:4
+   |
+LL | fn method(a: CustomRef<'_, ()>) {}
+   |    ^^^^^^ --------------------
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/reborrow/option_mut.rs b/tests/ui/reborrow/option_mut.rs
new file mode 100644
index 0000000000000..60b7145a7b2e3
--- /dev/null
+++ b/tests/ui/reborrow/option_mut.rs
@@ -0,0 +1,7 @@
+fn method(a: Option<& mut ()>) {}
+
+fn main() {
+    let a = Some(&mut ());
+    let _ = method(a);
+    let _ = method(a); //~ERROR use of moved value: `a`
+}
diff --git a/tests/ui/reborrow/option_mut.stderr b/tests/ui/reborrow/option_mut.stderr
new file mode 100644
index 0000000000000..497319d2e9035
--- /dev/null
+++ b/tests/ui/reborrow/option_mut.stderr
@@ -0,0 +1,21 @@
+error[E0382]: use of moved value: `a`
+  --> $DIR/option_mut.rs:6:20
+   |
+LL |     let a = Some(&mut ());
+   |         - move occurs because `a` has type `Option<&mut ()>`, which does not implement the `Copy` trait
+LL |     let _ = method(a);
+   |                    - value moved here
+LL |     let _ = method(a);
+   |                    ^ value used here after move
+   |
+note: consider changing this parameter type in function `method` to borrow instead if owning the value isn't necessary
+  --> $DIR/option_mut.rs:1:14
+   |
+LL | fn method(a: Option<& mut ()>) {}
+   |    ------    ^^^^^^^^^^^^^^^^ this parameter takes ownership of the value
+   |    |
+   |    in this function
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/reborrow/option_mut_coerce_shared.rs b/tests/ui/reborrow/option_mut_coerce_shared.rs
new file mode 100644
index 0000000000000..95d33ed94dd71
--- /dev/null
+++ b/tests/ui/reborrow/option_mut_coerce_shared.rs
@@ -0,0 +1,11 @@
+fn method(a: Option<&()>) {}  //~NOTE function defined here
+
+fn main() {
+    let a = Some(&mut ());
+    method(a);
+    //~^ ERROR mismatched types
+    //~| NOTE arguments to this function are incorrect
+    //~| NOTE types differ in mutability
+    //~| NOTE expected enum `Option<&()>`
+    //~| NOTE    found enum `Option<&mut ()>`
+}
diff --git a/tests/ui/reborrow/option_mut_coerce_shared.stderr b/tests/ui/reborrow/option_mut_coerce_shared.stderr
new file mode 100644
index 0000000000000..6ca1a2374610e
--- /dev/null
+++ b/tests/ui/reborrow/option_mut_coerce_shared.stderr
@@ -0,0 +1,23 @@
+error[E0308]: mismatched types
+  --> $DIR/option_mut_coerce_shared.rs:5:12
+   |
+LL |     method(a);
+   |     ------ ^ types differ in mutability
+   |     |
+   |     arguments to this function are incorrect
+   |
+   = note: expected enum `Option<&()>`
+              found enum `Option<&mut ()>`
+note: function defined here
+  --> $DIR/option_mut_coerce_shared.rs:1:4
+   |
+LL | fn method(a: Option<&()>) {}
+   |    ^^^^^^ --------------
+help: try using `.as_deref()` to convert `Option<&mut ()>` to `Option<&()>`
+   |
+LL |     method(a.as_deref());
+   |             +++++++++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/reborrow/pin_mut.rs b/tests/ui/reborrow/pin_mut.rs
new file mode 100644
index 0000000000000..966106969943a
--- /dev/null
+++ b/tests/ui/reborrow/pin_mut.rs
@@ -0,0 +1,10 @@
+use std::pin::Pin;
+
+fn method(a: Pin<& mut ()>) {}
+
+fn main() {
+    let a = &mut ();
+    let a = Pin::new(a);
+    let _ = method(a);
+    let _ = method(a); //~ERROR use of moved value: `a`
+}
diff --git a/tests/ui/reborrow/pin_mut.stderr b/tests/ui/reborrow/pin_mut.stderr
new file mode 100644
index 0000000000000..8a10e2d9af269
--- /dev/null
+++ b/tests/ui/reborrow/pin_mut.stderr
@@ -0,0 +1,21 @@
+error[E0382]: use of moved value: `a`
+  --> $DIR/pin_mut.rs:9:20
+   |
+LL |     let a = Pin::new(a);
+   |         - move occurs because `a` has type `Pin<&mut ()>`, which does not implement the `Copy` trait
+LL |     let _ = method(a);
+   |                    - value moved here
+LL |     let _ = method(a);
+   |                    ^ value used here after move
+   |
+note: consider changing this parameter type in function `method` to borrow instead if owning the value isn't necessary
+  --> $DIR/pin_mut.rs:3:14
+   |
+LL | fn method(a: Pin<& mut ()>) {}
+   |    ------    ^^^^^^^^^^^^^ this parameter takes ownership of the value
+   |    |
+   |    in this function
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/reborrow/pin_mut_coerce_shared.rs b/tests/ui/reborrow/pin_mut_coerce_shared.rs
new file mode 100644
index 0000000000000..fd529195fe01e
--- /dev/null
+++ b/tests/ui/reborrow/pin_mut_coerce_shared.rs
@@ -0,0 +1,14 @@
+use std::pin::Pin;
+
+fn method(a: Pin<&()>) {}  //~NOTE function defined here
+
+fn main() {
+    let a = &mut ();
+    let a = Pin::new(a);
+    method(a);
+    //~^ ERROR mismatched types
+    //~| NOTE arguments to this function are incorrect
+    //~| NOTE types differ in mutability
+    //~| NOTE expected struct `Pin<&()>`
+    //~| NOTE    found struct `Pin<&mut ()>`
+}
diff --git a/tests/ui/reborrow/pin_mut_coerce_shared.stderr b/tests/ui/reborrow/pin_mut_coerce_shared.stderr
new file mode 100644
index 0000000000000..74ecf4de4c785
--- /dev/null
+++ b/tests/ui/reborrow/pin_mut_coerce_shared.stderr
@@ -0,0 +1,19 @@
+error[E0308]: mismatched types
+  --> $DIR/pin_mut_coerce_shared.rs:8:12
+   |
+LL |     method(a);
+   |     ------ ^ types differ in mutability
+   |     |
+   |     arguments to this function are incorrect
+   |
+   = note: expected struct `Pin<&()>`
+              found struct `Pin<&mut ()>`
+note: function defined here
+  --> $DIR/pin_mut_coerce_shared.rs:3:4
+   |
+LL | fn method(a: Pin<&()>) {}
+   |    ^^^^^^ -----------
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0308`.

From 2adaa5dae2b9b63a50fa0200650aeee918cb76fb Mon Sep 17 00:00:00 2001
From: Jynn Nelson <jynn.nelson@ferrous-systems.com>
Date: Mon, 15 Sep 2025 10:33:39 -0700
Subject: [PATCH 0973/1889] Bump rustfix 0.8.1 -> 0.8.7

This commit can be replicated by running
`cargo update -p rustfix --precise 0.8.7 && x test ui --bless`.

---

The reasons this affects UI tests is as follows:
- The UI test suite runs rustc with
    `-Z deduplicate-diagnostics=no --error-format=json`,
  which means that rustc emits multiple errors containing identical
  suggestions. That caused the weird-looking code that had multiple `X: Copy` suggestions.
- Those suggestions are interpreted not by rustc itself, but by the
  `rustfix` library, maintained by cargo but published as a separate
  crates.io library and used by compiletest.
- Sometime between rustfix 0.8.1 and 0.8.7 (probably in cargo 14747, but
  it's hard to tell because rustfix's versioning doesn't match cargo's),
  rustfix got smarter and stopped applying duplicate suggestions.

Update rustfix to match cargo's behavior. Ideally, we would always share
a version of rustfix between cargo and rustc (perhaps with a path
dependency?), to make sure we are testing the behavior we ship. But for
now, just manually update it to match.

Note that the latest version of rustfix published to crates.io is 0.9.1,
not 0.8.7. But 0.9.1 is not the version used in cargo, which is 0.9.3.
Rather than trying to match versions exactly, I just updated rustfix to
the latest in the 0.8 branch.
---
 Cargo.lock                                                    | 4 ++--
 .../associated-types/associated-types-for-unimpl-trait.fixed  | 2 +-
 tests/ui/lifetimes/issue-105507.fixed                         | 2 +-
 tests/ui/parser/expr-as-stmt.fixed                            | 4 ++--
 .../ui/suggestions/missing-bound-in-derive-copy-impl-2.fixed  | 2 +-
 .../ui/suggestions/missing-bound-in-derive-copy-impl-3.fixed  | 2 +-
 tests/ui/suggestions/trait-impl-bound-suggestions.fixed       | 4 ++--
 7 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 4677d34d2a630..d39cfefea0c77 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4817,9 +4817,9 @@ dependencies = [
 
 [[package]]
 name = "rustfix"
-version = "0.8.1"
+version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81864b097046da5df3758fdc6e4822bbb70afa06317e8ca45ea1b51cb8c5e5a4"
+checksum = "82fa69b198d894d84e23afde8e9ab2af4400b2cba20d6bf2b428a8b01c222c5a"
 dependencies = [
  "serde",
  "serde_json",
diff --git a/tests/ui/associated-types/associated-types-for-unimpl-trait.fixed b/tests/ui/associated-types/associated-types-for-unimpl-trait.fixed
index bce6148f9e199..ae4d0107aee52 100644
--- a/tests/ui/associated-types/associated-types-for-unimpl-trait.fixed
+++ b/tests/ui/associated-types/associated-types-for-unimpl-trait.fixed
@@ -8,7 +8,7 @@ trait Get {
 }
 
 trait Other {
-    fn uhoh<U: Get>(&self, foo: U, bar: <Self as Get>::Value) where Self: Sized, Self: Get, Self: Get {}
+    fn uhoh<U: Get>(&self, foo: U, bar: <Self as Get>::Value) where Self: Sized, Self: Get {}
     //~^ ERROR the trait bound `Self: Get` is not satisfied
     //~| ERROR the trait bound `Self: Get` is not satisfied
 }
diff --git a/tests/ui/lifetimes/issue-105507.fixed b/tests/ui/lifetimes/issue-105507.fixed
index 46d4f14a2457e..a3c4e5784b872 100644
--- a/tests/ui/lifetimes/issue-105507.fixed
+++ b/tests/ui/lifetimes/issue-105507.fixed
@@ -31,7 +31,7 @@ impl<T> ProjectedMyTrait for T
 
 fn require_trait<T: MyTrait>(_: T) {}
 
-fn foo<T : MyTrait + 'static + 'static, U : MyTrait + 'static + 'static>(wrap: Wrapper<'_, Option<T>>, wrap1: Wrapper<'_, Option<U>>) {
+fn foo<T : MyTrait + 'static, U : MyTrait + 'static>(wrap: Wrapper<'_, Option<T>>, wrap1: Wrapper<'_, Option<U>>) {
     //~^ HELP consider restricting the type parameter to the `'static` lifetime
     //~| HELP consider restricting the type parameter to the `'static` lifetime
     require_trait(wrap);
diff --git a/tests/ui/parser/expr-as-stmt.fixed b/tests/ui/parser/expr-as-stmt.fixed
index bfae55047ed1b..b3a491200ed10 100644
--- a/tests/ui/parser/expr-as-stmt.fixed
+++ b/tests/ui/parser/expr-as-stmt.fixed
@@ -66,7 +66,7 @@ fn asteroids() -> impl FnOnce() -> bool {
 
 // https://github.com/rust-lang/rust/issues/105179
 fn r#match() -> i32 {
-    ((match () { () => 1 })) + match () { () => 1 } //~ ERROR expected expression, found `+`
+    (match () { () => 1 }) + match () { () => 1 } //~ ERROR expected expression, found `+`
     //~^ ERROR mismatched types
 }
 
@@ -82,7 +82,7 @@ fn matches() -> bool {
     (match () { _ => true }) && match () { _ => true }; //~ ERROR mismatched types
     //~^ ERROR expected `;`, found keyword `match`
     (match () { _ => true }) && true; //~ ERROR mismatched types
-    ((match () { _ => true })) && true //~ ERROR mismatched types
+    (match () { _ => true }) && true //~ ERROR mismatched types
     //~^ ERROR mismatched types
 }
 fn main() {}
diff --git a/tests/ui/suggestions/missing-bound-in-derive-copy-impl-2.fixed b/tests/ui/suggestions/missing-bound-in-derive-copy-impl-2.fixed
index 99433f7332042..8a2be310e0d81 100644
--- a/tests/ui/suggestions/missing-bound-in-derive-copy-impl-2.fixed
+++ b/tests/ui/suggestions/missing-bound-in-derive-copy-impl-2.fixed
@@ -8,7 +8,7 @@ pub struct Vector2<T: Debug + Copy + Clone> {
 }
 
 #[derive(Debug, Copy, Clone)]
-pub struct AABB<K: Debug + std::marker::Copy + std::marker::Copy + std::marker::Copy + std::marker::Copy> {
+pub struct AABB<K: Debug + std::marker::Copy> {
     pub loc: Vector2<K>, //~ ERROR the trait bound `K: Copy` is not satisfied
     //~^ ERROR the trait bound `K: Copy` is not satisfied
     //~| ERROR the trait bound `K: Copy` is not satisfied
diff --git a/tests/ui/suggestions/missing-bound-in-derive-copy-impl-3.fixed b/tests/ui/suggestions/missing-bound-in-derive-copy-impl-3.fixed
index 6da3e351ffbdd..74df1d7c7cfdd 100644
--- a/tests/ui/suggestions/missing-bound-in-derive-copy-impl-3.fixed
+++ b/tests/ui/suggestions/missing-bound-in-derive-copy-impl-3.fixed
@@ -8,7 +8,7 @@ pub struct Vector2<T: Debug + Copy + Clone>{
 }
 
 #[derive(Debug, Copy, Clone)] //~ ERROR the trait `Copy` cannot be implemented for this type
-pub struct AABB<K: Copy + Debug + std::fmt::Debug + std::fmt::Debug + std::fmt::Debug>{
+pub struct AABB<K: Copy + Debug + std::fmt::Debug>{
     pub loc: Vector2<K>, //~ ERROR `K` doesn't implement `Debug`
     //~^ ERROR `K` doesn't implement `Debug`
     pub size: Vector2<K> //~ ERROR `K` doesn't implement `Debug`
diff --git a/tests/ui/suggestions/trait-impl-bound-suggestions.fixed b/tests/ui/suggestions/trait-impl-bound-suggestions.fixed
index 9d3168f5acd68..49793b4b6f47e 100644
--- a/tests/ui/suggestions/trait-impl-bound-suggestions.fixed
+++ b/tests/ui/suggestions/trait-impl-bound-suggestions.fixed
@@ -10,7 +10,7 @@ struct ConstrainedStruct<X: Copy> {
 }
 
 #[allow(dead_code)]
-trait InsufficientlyConstrainedGeneric<X=()> where Self: Sized, X: std::marker::Copy, X: std::marker::Copy {
+trait InsufficientlyConstrainedGeneric<X=()> where Self: Sized, X: std::marker::Copy {
     fn return_the_constrained_type(&self, x: X) -> ConstrainedStruct<X> {
         //~^ ERROR the trait bound `X: Copy` is not satisfied
         ConstrainedStruct { x }
@@ -20,7 +20,7 @@ trait InsufficientlyConstrainedGeneric<X=()> where Self: Sized, X: std::marker::
 
 // Regression test for #120838
 #[allow(dead_code)]
-trait InsufficientlyConstrainedGenericWithEmptyWhere<X=()> where Self: Sized, X: std::marker::Copy, X: std::marker::Copy {
+trait InsufficientlyConstrainedGenericWithEmptyWhere<X=()> where Self: Sized, X: std::marker::Copy {
     fn return_the_constrained_type(&self, x: X) -> ConstrainedStruct<X> {
         //~^ ERROR the trait bound `X: Copy` is not satisfied
         ConstrainedStruct { x }

From c4a87eb62cd74e31e5d3889741a76a4bb2a48ed6 Mon Sep 17 00:00:00 2001
From: Aapo Alasuutari <aapo.alasuutari@gmail.com>
Date: Mon, 15 Sep 2025 20:32:06 +0300
Subject: [PATCH 0974/1889] fix: Move CoerceShared into ops

---
 library/core/src/marker.rs                             |  9 ---------
 library/core/src/ops/mod.rs                            |  3 +++
 library/core/src/ops/reborrow.rs                       | 10 ++++++++++
 .../feature-gate-reborrow-coerce-shared.rs             |  2 +-
 .../feature-gate-reborrow-coerce-shared.stderr         |  4 ++--
 tests/ui/reborrow/custom_mut_coerce_shared.rs          |  3 ++-
 tests/ui/reborrow/custom_mut_coerce_shared.stderr      |  4 ++--
 7 files changed, 20 insertions(+), 15 deletions(-)
 create mode 100644 library/core/src/ops/reborrow.rs

diff --git a/library/core/src/marker.rs b/library/core/src/marker.rs
index 8541a5b91cdde..d03d7a43469a7 100644
--- a/library/core/src/marker.rs
+++ b/library/core/src/marker.rs
@@ -1372,12 +1372,3 @@ pub trait CoercePointeeValidated {
 pub trait Reborrow {
     // Empty.
 }
-
-/// Allows reborrowable value to be reborrowed as shared, creating a copy of
-/// that disables the source for writes for the lifetime of the copy.
-#[lang = "coerce_shared"]
-#[unstable(feature = "reborrow", issue = "145612")]
-pub trait CoerceShared: Reborrow {
-    /// The type of this value when reborrowed as shared.
-    type Target: Copy;
-}
diff --git a/library/core/src/ops/mod.rs b/library/core/src/ops/mod.rs
index 87dd873fdb57d..9814f5d5795c6 100644
--- a/library/core/src/ops/mod.rs
+++ b/library/core/src/ops/mod.rs
@@ -149,6 +149,7 @@ mod function;
 mod index;
 mod index_range;
 mod range;
+mod reborrow;
 mod try_trait;
 mod unsize;
 
@@ -189,6 +190,8 @@ pub use self::range::{Bound, RangeBounds, RangeInclusive, RangeToInclusive};
 pub use self::range::{OneSidedRange, OneSidedRangeBound};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use self::range::{Range, RangeFrom, RangeFull, RangeTo};
+#[unstable(feature = "reborrow", issue = "145612")]
+pub use self::reborrow::CoerceShared;
 #[unstable(feature = "try_trait_v2_residual", issue = "91285")]
 pub use self::try_trait::Residual;
 #[unstable(feature = "try_trait_v2_yeet", issue = "96374")]
diff --git a/library/core/src/ops/reborrow.rs b/library/core/src/ops/reborrow.rs
new file mode 100644
index 0000000000000..90288f766d502
--- /dev/null
+++ b/library/core/src/ops/reborrow.rs
@@ -0,0 +1,10 @@
+use crate::marker::Reborrow;
+
+/// Allows reborrowable value to be reborrowed as shared, creating a copy
+/// that disables the source for writes for the lifetime of the copy.
+#[lang = "coerce_shared"]
+#[unstable(feature = "reborrow", issue = "145612")]
+pub trait CoerceShared: Reborrow {
+    /// The type of this value when reborrowed as shared.
+    type Target: Copy;
+}
diff --git a/tests/ui/feature-gates/feature-gate-reborrow-coerce-shared.rs b/tests/ui/feature-gates/feature-gate-reborrow-coerce-shared.rs
index 48a14959d8d64..c8ca453708912 100644
--- a/tests/ui/feature-gates/feature-gate-reborrow-coerce-shared.rs
+++ b/tests/ui/feature-gates/feature-gate-reborrow-coerce-shared.rs
@@ -1,3 +1,3 @@
-use std::marker::CoerceShared; //~ ERROR  use of unstable library feature `reborrow`
+use std::ops::CoerceShared; //~ ERROR  use of unstable library feature `reborrow`
 
 fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-reborrow-coerce-shared.stderr b/tests/ui/feature-gates/feature-gate-reborrow-coerce-shared.stderr
index c4c5e06778af3..dbbbcdf2fd57d 100644
--- a/tests/ui/feature-gates/feature-gate-reborrow-coerce-shared.stderr
+++ b/tests/ui/feature-gates/feature-gate-reborrow-coerce-shared.stderr
@@ -1,8 +1,8 @@
 error[E0658]: use of unstable library feature `reborrow`
   --> $DIR/feature-gate-reborrow-coerce-shared.rs:1:5
    |
-LL | use std::marker::CoerceShared;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | use std::ops::CoerceShared;
+   |     ^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: see issue #145612 <https://github.com/rust-lang/rust/issues/145612> for more information
    = help: add `#![feature(reborrow)]` to the crate attributes to enable
diff --git a/tests/ui/reborrow/custom_mut_coerce_shared.rs b/tests/ui/reborrow/custom_mut_coerce_shared.rs
index b292b5b073ce8..28d802aabffe5 100644
--- a/tests/ui/reborrow/custom_mut_coerce_shared.rs
+++ b/tests/ui/reborrow/custom_mut_coerce_shared.rs
@@ -1,5 +1,6 @@
 #![feature(reborrow)]
-use std::marker::{Reborrow, CoerceShared};
+use std::marker::Reborrow;
+use std::ops::CoerceShared;
 
 struct CustomMut<'a, T>(&'a mut T);
 impl<'a, T> Reborrow for CustomMut<'a, T> {}
diff --git a/tests/ui/reborrow/custom_mut_coerce_shared.stderr b/tests/ui/reborrow/custom_mut_coerce_shared.stderr
index 508651badc0a4..90d8a98160543 100644
--- a/tests/ui/reborrow/custom_mut_coerce_shared.stderr
+++ b/tests/ui/reborrow/custom_mut_coerce_shared.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/custom_mut_coerce_shared.rs:23:12
+  --> $DIR/custom_mut_coerce_shared.rs:24:12
    |
 LL |     method(a);
    |     ------ ^ expected `CustomRef<'_, ()>`, found `CustomMut<'_, ()>`
@@ -9,7 +9,7 @@ LL |     method(a);
    = note: expected struct `CustomRef<'_, ()>`
               found struct `CustomMut<'_, ()>`
 note: function defined here
-  --> $DIR/custom_mut_coerce_shared.rs:19:4
+  --> $DIR/custom_mut_coerce_shared.rs:20:4
    |
 LL | fn method(a: CustomRef<'_, ()>) {}
    |    ^^^^^^ --------------------

From 001f8e3e1ad9b5739c6ec2f63c7b52ebd5d68006 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Mon, 15 Sep 2025 20:22:21 +0200
Subject: [PATCH 0975/1889] Update src/tests/ci.md

Co-authored-by: Ralf Jung <post@ralfj.de>
---
 src/doc/rustc-dev-guide/src/tests/ci.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/src/tests/ci.md b/src/doc/rustc-dev-guide/src/tests/ci.md
index a32edd7240117..d9fc2324d8bf6 100644
--- a/src/doc/rustc-dev-guide/src/tests/ci.md
+++ b/src/doc/rustc-dev-guide/src/tests/ci.md
@@ -151,7 +151,7 @@ which can be used in one of two ways:
 
 Each job pattern can either be an exact name of a job or a glob pattern that matches multiple jobs,
 for example `*msvc*` or `*-alt`. You can start at most 20 jobs in a single try build. When using
-glob patterns in the PR description, you can wrap them in backticks (`` ` ``) to avoid GitHub rendering
+glob patterns in the PR description, you can (but do not have to) wrap them in backticks (`` ` ``) to avoid GitHub rendering
 the pattern as Markdown if it contains e.g. an asterisk. Note that this escaping will not work when using
 the `@bors jobs=` parameter.
 

From b8cb80cf80572e9d287445af16608b68ec436099 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Mon, 15 Sep 2025 13:38:04 -0500
Subject: [PATCH 0976/1889] improve internal bootstrap docs

---
 src/bootstrap/README.md                    | 15 +++++++++++++++
 src/bootstrap/src/core/build_steps/tool.rs |  5 +++++
 2 files changed, 20 insertions(+)

diff --git a/src/bootstrap/README.md b/src/bootstrap/README.md
index 2965174b45bcc..12e09cb07dbb2 100644
--- a/src/bootstrap/README.md
+++ b/src/bootstrap/README.md
@@ -63,6 +63,21 @@ build/
     debug/
     release/
 
+  # Build directory for various tools like `typos` that are only ever
+  # built for the host system, and always with stage0 cargo.
+  misc-tools/
+    bin/
+    target/
+
+  # Directory where js dependencies like tsc and eslint are stored.
+  node_modules/
+    .bin/
+
+  # Copy of package.json and package-lock.json, because npm requires these
+  # to be in the same directory as `node_modules`.
+  package.json
+  package-lock.json
+
   # Output of the dist-related steps like dist-std, dist-rustc, and dist-docs
   dist/
 
diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
index dcc4898cae16a..4f096d50ea5c3 100644
--- a/src/bootstrap/src/core/build_steps/tool.rs
+++ b/src/bootstrap/src/core/build_steps/tool.rs
@@ -394,6 +394,9 @@ macro_rules! bootstrap_tool {
         }
 
         impl<'a> Builder<'a> {
+            /// Ensure a tool is built, then get the path to its executable.
+            ///
+            /// The actual building, if any, will be handled via [`ToolBuild`].
             pub fn tool_exe(&self, tool: Tool) -> PathBuf {
                 match tool {
                     $(Tool::$name =>
@@ -1552,6 +1555,8 @@ pub const TEST_FLOAT_PARSE_ALLOW_FEATURES: &str = "f16,cfg_target_has_reliable_f
 impl Builder<'_> {
     /// Gets a `BootstrapCommand` which is ready to run `tool` in `stage` built for
     /// `host`.
+    ///
+    /// This also ensures that the given tool is built (using [`ToolBuild`]).
     pub fn tool_cmd(&self, tool: Tool) -> BootstrapCommand {
         let mut cmd = command(self.tool_exe(tool));
         let compiler = self.compiler(0, self.config.host_target);

From 29ca09be09a88f359adc7879e2592f36f6c74a64 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Mon, 15 Sep 2025 14:42:44 -0500
Subject: [PATCH 0977/1889] bootstrap: lower verbosity of cargo to one less
 than bootstrap's

the main thing this does is eliminate the "Fresh ..." output when
`--verbose` is only passed once.
---
 src/bootstrap/bootstrap.py                 | 3 ++-
 src/bootstrap/src/core/build_steps/test.rs | 3 ---
 src/bootstrap/src/core/builder/cargo.rs    | 7 ++++---
 3 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/src/bootstrap/bootstrap.py b/src/bootstrap/bootstrap.py
index 2ece53eb0cc99..41c8ef17f0b57 100644
--- a/src/bootstrap/bootstrap.py
+++ b/src/bootstrap/bootstrap.py
@@ -1145,7 +1145,8 @@ def build_bootstrap_cmd(self, env):
             os.path.join(self.rust_root, "src/bootstrap/Cargo.toml"),
             "-Zroot-dir=" + self.rust_root,
         ]
-        args.extend("--verbose" for _ in range(self.verbose))
+        # verbose cargo output is very noisy, so only enable it with -vv
+        args.extend("--verbose" for _ in range(self.verbose - 1))
 
         if "BOOTSTRAP_TRACING" in env:
             args.append("--features=tracing")
diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index 723ba80eaf827..e7f5879b5f51a 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -3418,9 +3418,6 @@ impl Step for TierCheck {
         );
         cargo.arg(builder.src.join("src/doc/rustc/src/platform-support.md"));
         cargo.arg(builder.rustc(self.test_compiler));
-        if builder.is_verbose() {
-            cargo.arg("--verbose");
-        }
 
         let _guard = builder.msg_test(
             "platform support check",
diff --git a/src/bootstrap/src/core/builder/cargo.rs b/src/bootstrap/src/core/builder/cargo.rs
index 924bb4adb42d0..8e65ec7ce50ad 100644
--- a/src/bootstrap/src/core/builder/cargo.rs
+++ b/src/bootstrap/src/core/builder/cargo.rs
@@ -1133,7 +1133,7 @@ impl Builder<'_> {
             cargo.env("RUSTC_BACKTRACE_ON_ICE", "1");
         }
 
-        if self.is_verbose() {
+        if self.is_verbose_than(1) {
             // This provides very useful logs especially when debugging build cache-related stuff.
             cargo.env("CARGO_LOG", "cargo::core::compiler::fingerprint=info");
         }
@@ -1275,8 +1275,9 @@ impl Builder<'_> {
             cargo.env("WINAPI_NO_BUNDLED_LIBRARIES", "1");
         }
 
-        for _ in 0..self.verbosity {
-            cargo.arg("-v");
+        // verbose cargo output is very noisy, so only enable it with -vv
+        for _ in 0..self.verbosity.saturating_sub(1) {
+            cargo.arg("--verbose");
         }
 
         match (mode, self.config.rust_codegen_units_std, self.config.rust_codegen_units) {

From fa7e474f9ca755ac102debcf6cd0ce77313ee0bf Mon Sep 17 00:00:00 2001
From: ash <ashkernel02@gmail.com>
Date: Mon, 15 Sep 2025 13:55:20 -0600
Subject: [PATCH 0978/1889] remove FIXME from `has_significant_drop`, replaced
 with checking non_region_infer

---
 compiler/rustc_middle/src/ty/util.rs   |  9 +--------
 tests/ui/type-inference/has_sigdrop.rs | 18 ++++++++++++++++++
 2 files changed, 19 insertions(+), 8 deletions(-)
 create mode 100644 tests/ui/type-inference/has_sigdrop.rs

diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs
index 029586a9c554c..b79b67c5927b0 100644
--- a/compiler/rustc_middle/src/ty/util.rs
+++ b/compiler/rustc_middle/src/ty/util.rs
@@ -1359,6 +1359,7 @@ impl<'tcx> Ty<'tcx> {
     /// 2229 drop reorder migration analysis.
     #[inline]
     pub fn has_significant_drop(self, tcx: TyCtxt<'tcx>, typing_env: ty::TypingEnv<'tcx>) -> bool {
+        assert!(!self.has_non_region_infer());
         // Avoid querying in simple cases.
         match needs_drop_components(tcx, self) {
             Err(AlwaysRequiresDrop) => true,
@@ -1371,14 +1372,6 @@ impl<'tcx> Ty<'tcx> {
                     _ => self,
                 };
 
-                // FIXME(#86868): We should be canonicalizing, or else moving this to a method of inference
-                // context, or *something* like that, but for now just avoid passing inference
-                // variables to queries that can't cope with them. Instead, conservatively
-                // return "true" (may change drop order).
-                if query_ty.has_infer() {
-                    return true;
-                }
-
                 // This doesn't depend on regions, so try to minimize distinct
                 // query keys used.
                 let erased = tcx.normalize_erasing_regions(typing_env, query_ty);
diff --git a/tests/ui/type-inference/has_sigdrop.rs b/tests/ui/type-inference/has_sigdrop.rs
new file mode 100644
index 0000000000000..c3d835cfe16f8
--- /dev/null
+++ b/tests/ui/type-inference/has_sigdrop.rs
@@ -0,0 +1,18 @@
+//@ run-pass
+// Inference, canonicalization, and significant drops should work nicely together.
+// Related issue: #86868
+
+#[clippy::has_significant_drop]
+struct DropGuy {}
+
+fn creator() -> DropGuy {
+    DropGuy {}
+}
+
+fn dropper() {
+    let _ = creator();
+}
+
+fn main() {
+    dropper();
+}

From d58061e6131f6141985faadb6794af540f81b1db Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Tue, 16 Sep 2025 01:22:10 +0000
Subject: [PATCH 0979/1889] Restrict simple assignment condition.

---
 compiler/rustc_mir_transform/src/dest_prop.rs | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/dest_prop.rs b/compiler/rustc_mir_transform/src/dest_prop.rs
index b9ab0a9feee65..c57483a681140 100644
--- a/compiler/rustc_mir_transform/src/dest_prop.rs
+++ b/compiler/rustc_mir_transform/src/dest_prop.rs
@@ -596,8 +596,14 @@ fn save_as_intervals<'tcx>(
             // as behaving so by default.
             // We make an exception for simple assignments `_a.stuff = {copy|move} _b.stuff`,
             // as marking `_b` live here would prevent unification.
-            let is_simple_assignment =
-                matches!(stmt.kind, StatementKind::Assign(box (_, Rvalue::Use(_))));
+            let is_simple_assignment = match stmt.kind {
+                StatementKind::Assign(box (
+                    lhs,
+                    Rvalue::CopyForDeref(rhs)
+                    | Rvalue::Use(Operand::Copy(rhs) | Operand::Move(rhs)),
+                )) => lhs.projection == rhs.projection,
+                _ => false,
+            };
             VisitPlacesWith(|place: Place<'tcx>, ctxt| {
                 if let Some(relevant) = relevant.shrink[place.local] {
                     match DefUse::for_place(place, ctxt) {

From 9e2f9edd7f79c1e11339277bfb83a0c888740438 Mon Sep 17 00:00:00 2001
From: Jules Bertholet <julesbertholet@quoi.xyz>
Date: Mon, 15 Sep 2025 21:43:13 -0400
Subject: [PATCH 0980/1889] =?UTF-8?q?Don=E2=80=99t=20suggest=20foreign=20`?=
 =?UTF-8?q?doc(hidden)`=20types=20in=20E0277=20diagnostics?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../traits/fulfillment_errors.rs              | 17 ++++++-
 tests/ui/proc-macro/quote/not-quotable.stderr |  4 +-
 .../ui/suggestions/auxiliary/hidden-struct.rs | 26 +++++++++--
 .../dont-suggest-foreign-doc-hidden.rs        | 18 ++++++--
 .../dont-suggest-foreign-doc-hidden.stderr    | 44 ++++++++++++++++---
 5 files changed, 94 insertions(+), 15 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 149f5e638b1ad..dff846cfc0af3 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
@@ -1894,6 +1894,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         other: bool,
         param_env: ty::ParamEnv<'tcx>,
     ) -> bool {
+        let parent_map = self.tcx.visible_parent_map(());
         let alternative_candidates = |def_id: DefId| {
             let mut impl_candidates: Vec<_> = self
                 .tcx
@@ -1918,7 +1919,21 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         // FIXME(compiler-errors): This could be generalized, both to
                         // be more granular, and probably look past other `#[fundamental]`
                         // types, too.
-                        self.tcx.visibility(def.did()).is_accessible_from(body_def_id, self.tcx)
+                        let mut did = def.did();
+                        if self.tcx.visibility(did).is_accessible_from(body_def_id, self.tcx) {
+                            // don't suggest foreign `#[doc(hidden)]` types
+                            if !did.is_local() {
+                                while let Some(parent) = parent_map.get(&did) {
+                                    if self.tcx.is_doc_hidden(did) {
+                                        return false;
+                                    }
+                                    did = *parent;
+                                }
+                            }
+                            true
+                        } else {
+                            false
+                        }
                     } else {
                         true
                     }
diff --git a/tests/ui/proc-macro/quote/not-quotable.stderr b/tests/ui/proc-macro/quote/not-quotable.stderr
index d1c3d06f2b661..62a02638e548b 100644
--- a/tests/ui/proc-macro/quote/not-quotable.stderr
+++ b/tests/ui/proc-macro/quote/not-quotable.stderr
@@ -15,8 +15,8 @@ LL |     let _ = quote! { $ip };
              Cow<'_, T>
              Option<T>
              Rc<T>
-             RepInterp<T>
-           and 25 others
+             bool
+           and 24 others
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/auxiliary/hidden-struct.rs b/tests/ui/suggestions/auxiliary/hidden-struct.rs
index 30d69acac2097..1f495a9f2224a 100644
--- a/tests/ui/suggestions/auxiliary/hidden-struct.rs
+++ b/tests/ui/suggestions/auxiliary/hidden-struct.rs
@@ -1,3 +1,5 @@
+// `Foo` and `Bar` should not be suggested in diagnostics of dependents
+
 #[doc(hidden)]
 pub mod hidden {
     pub struct Foo;
@@ -5,13 +7,29 @@ pub mod hidden {
 
 pub mod hidden1 {
     #[doc(hidden)]
-    pub struct Foo;
+    pub struct Bar;
 }
 
+// `Baz` and `Quux` *should* be suggested in diagnostics of dependents
 
 #[doc(hidden)]
-pub(crate) mod hidden2 {
-    pub struct Bar;
+pub mod hidden2 {
+    pub struct Baz;
+}
+
+pub use hidden2::Baz;
+
+#[doc(hidden)]
+pub(crate) mod hidden3 {
+    pub struct Quux;
 }
 
-pub use hidden2::Bar;
+pub use hidden3::Quux;
+
+pub trait Marker {}
+
+impl Marker for Option<u32> {}
+impl Marker for hidden::Foo {}
+impl Marker for hidden1::Bar {}
+impl Marker for Baz {}
+impl Marker for Quux {}
diff --git a/tests/ui/suggestions/dont-suggest-foreign-doc-hidden.rs b/tests/ui/suggestions/dont-suggest-foreign-doc-hidden.rs
index 281975dcc2f3b..a83e496f2703d 100644
--- a/tests/ui/suggestions/dont-suggest-foreign-doc-hidden.rs
+++ b/tests/ui/suggestions/dont-suggest-foreign-doc-hidden.rs
@@ -1,5 +1,4 @@
 //@ aux-build:hidden-struct.rs
-//@ compile-flags: --crate-type lib
 
 extern crate hidden_struct;
 
@@ -9,7 +8,20 @@ mod local {
 }
 
 pub fn test(_: Foo) {}
-//~^ ERROR cannot find type `Foo` in this scope
+//~^ ERROR [E0412]
 
 pub fn test2(_: Bar) {}
-//~^ ERROR cannot find type `Bar` in this scope
+//~^ ERROR [E0412]
+
+pub fn test3(_: Baz) {}
+//~^ ERROR [E0412]
+
+pub fn test4(_: Quux) {}
+//~^ ERROR [E0412]
+
+fn test5<T: hidden_struct::Marker>() {}
+
+fn main() {
+    test5::<i32>();
+    //~^ ERROR [E0277]
+}
diff --git a/tests/ui/suggestions/dont-suggest-foreign-doc-hidden.stderr b/tests/ui/suggestions/dont-suggest-foreign-doc-hidden.stderr
index 7fb4d95ff9bf5..7036708756d6c 100644
--- a/tests/ui/suggestions/dont-suggest-foreign-doc-hidden.stderr
+++ b/tests/ui/suggestions/dont-suggest-foreign-doc-hidden.stderr
@@ -1,5 +1,5 @@
 error[E0412]: cannot find type `Foo` in this scope
-  --> $DIR/dont-suggest-foreign-doc-hidden.rs:11:16
+  --> $DIR/dont-suggest-foreign-doc-hidden.rs:10:16
    |
 LL | pub fn test(_: Foo) {}
    |                ^^^ not found in this scope
@@ -10,16 +10,50 @@ LL + use local::Foo;
    |
 
 error[E0412]: cannot find type `Bar` in this scope
-  --> $DIR/dont-suggest-foreign-doc-hidden.rs:14:17
+  --> $DIR/dont-suggest-foreign-doc-hidden.rs:13:17
    |
 LL | pub fn test2(_: Bar) {}
    |                 ^^^ not found in this scope
+
+error[E0412]: cannot find type `Baz` in this scope
+  --> $DIR/dont-suggest-foreign-doc-hidden.rs:16:17
+   |
+LL | pub fn test3(_: Baz) {}
+   |                 ^^^ not found in this scope
    |
 help: consider importing this struct
    |
-LL + use hidden_struct::Bar;
+LL + use hidden_struct::Baz;
+   |
+
+error[E0412]: cannot find type `Quux` in this scope
+  --> $DIR/dont-suggest-foreign-doc-hidden.rs:19:17
+   |
+LL | pub fn test4(_: Quux) {}
+   |                 ^^^^ not found in this scope
+   |
+help: consider importing this struct
+   |
+LL + use hidden_struct::Quux;
+   |
+
+error[E0277]: the trait bound `i32: Marker` is not satisfied
+  --> $DIR/dont-suggest-foreign-doc-hidden.rs:25:13
+   |
+LL |     test5::<i32>();
+   |             ^^^ the trait `Marker` is not implemented for `i32`
+   |
+   = help: the following other types implement trait `Marker`:
+             Baz
+             Option<u32>
+             Quux
+note: required by a bound in `test5`
+  --> $DIR/dont-suggest-foreign-doc-hidden.rs:22:13
    |
+LL | fn test5<T: hidden_struct::Marker>() {}
+   |             ^^^^^^^^^^^^^^^^^^^^^ required by this bound in `test5`
 
-error: aborting due to 2 previous errors
+error: aborting due to 5 previous errors
 
-For more information about this error, try `rustc --explain E0412`.
+Some errors have detailed explanations: E0277, E0412.
+For more information about an error, try `rustc --explain E0277`.

From 181bd119d07022db19b184ac23a796daa0e45246 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukas@zed.dev>
Date: Fri, 5 Sep 2025 08:25:28 +0200
Subject: [PATCH 0981/1889] fix: Fix expand macro recursively not working
 correctly for nested macro calls

---
 .../crates/ide/src/expand_macro.rs            | 95 ++++++++++---------
 1 file changed, 49 insertions(+), 46 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide/src/expand_macro.rs b/src/tools/rust-analyzer/crates/ide/src/expand_macro.rs
index ad84eacfb3e88..094a4a7036c40 100644
--- a/src/tools/rust-analyzer/crates/ide/src/expand_macro.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/expand_macro.rs
@@ -1,5 +1,5 @@
 use hir::db::ExpandDatabase;
-use hir::{ExpandResult, InFile, InRealFile, Semantics};
+use hir::{ExpandResult, InFile, Semantics};
 use ide_db::{
     FileId, RootDatabase, base_db::Crate, helpers::pick_best_token,
     syntax_helpers::prettify_macro_expansion,
@@ -87,52 +87,55 @@ pub(crate) fn expand_macro(db: &RootDatabase, position: FilePosition) -> Option<
         return derive;
     }
 
-    let mut anc = sema
-        .descend_token_into_include_expansion(InRealFile::new(file_id, tok))
-        .value
-        .parent_ancestors();
-    let mut span_map = SpanMap::empty();
-    let mut error = String::new();
-    let (name, expanded, kind) = loop {
-        let node = anc.next()?;
-
-        if let Some(item) = ast::Item::cast(node.clone())
-            && let Some(def) = sema.resolve_attr_macro_call(&item)
-        {
-            break (
-                def.name(db).display(db, file_id.edition(db)).to_string(),
-                expand_macro_recur(&sema, &item, &mut error, &mut span_map, TextSize::new(0))?,
-                SyntaxKind::MACRO_ITEMS,
-            );
-        }
-        if let Some(mac) = ast::MacroCall::cast(node) {
-            let mut name = mac.path()?.segment()?.name_ref()?.to_string();
-            name.push('!');
-            let syntax_kind =
-                mac.syntax().parent().map(|it| it.kind()).unwrap_or(SyntaxKind::MACRO_ITEMS);
-            break (
-                name,
-                expand_macro_recur(
-                    &sema,
-                    &ast::Item::MacroCall(mac),
-                    &mut error,
-                    &mut span_map,
-                    TextSize::new(0),
-                )?,
-                syntax_kind,
-            );
-        }
-    };
+    let syntax_token = sema.descend_into_macros_exact(tok);
+    'tokens: for syntax_token in syntax_token {
+        let mut anc = syntax_token.parent_ancestors();
+        let mut span_map = SpanMap::empty();
+        let mut error = String::new();
+        let (name, expanded, kind) = loop {
+            let Some(node) = anc.next() else {
+                continue 'tokens;
+            };
+
+            if let Some(item) = ast::Item::cast(node.clone())
+                && let Some(def) = sema.resolve_attr_macro_call(&item)
+            {
+                break (
+                    def.name(db).display(db, file_id.edition(db)).to_string(),
+                    expand_macro_recur(&sema, &item, &mut error, &mut span_map, TextSize::new(0))?,
+                    SyntaxKind::MACRO_ITEMS,
+                );
+            }
+            if let Some(mac) = ast::MacroCall::cast(node) {
+                let mut name = mac.path()?.segment()?.name_ref()?.to_string();
+                name.push('!');
+                let syntax_kind =
+                    mac.syntax().parent().map(|it| it.kind()).unwrap_or(SyntaxKind::MACRO_ITEMS);
+                break (
+                    name,
+                    expand_macro_recur(
+                        &sema,
+                        &ast::Item::MacroCall(mac),
+                        &mut error,
+                        &mut span_map,
+                        TextSize::new(0),
+                    )?,
+                    syntax_kind,
+                );
+            }
+        };
 
-    // FIXME:
-    // macro expansion may lose all white space information
-    // But we hope someday we can use ra_fmt for that
-    let mut expansion = format(db, kind, position.file_id, expanded, &span_map, krate);
+        // FIXME:
+        // macro expansion may lose all white space information
+        // But we hope someday we can use ra_fmt for that
+        let mut expansion = format(db, kind, position.file_id, expanded, &span_map, krate);
 
-    if !error.is_empty() {
-        expansion.insert_str(0, &format!("Expansion had errors:{error}\n\n"));
+        if !error.is_empty() {
+            expansion.insert_str(0, &format!("Expansion had errors:{error}\n\n"));
+        }
+        return Some(ExpandedMacro { name, expansion });
     }
-    Some(ExpandedMacro { name, expansion })
+    None
 }
 
 fn expand_macro_recur(
@@ -752,8 +755,8 @@ fn test() {
 }
     "#,
             expect![[r#"
-                my_concat!
-                "<>hi""#]],
+                concat!
+                "<>""#]],
         );
     }
 

From 8a9ec5dd0dbf81e6337fb272aa0b90cf6e8d5655 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukas@zed.dev>
Date: Sat, 23 Aug 2025 09:00:35 +0200
Subject: [PATCH 0982/1889] fix: Only compute unstable paths on nightly
 toolchains for IDE features

---
 .../crates/hir-def/src/find_path.rs           |  8 ++--
 .../rust-analyzer/crates/hir-def/src/lib.rs   |  2 +-
 .../crates/hir-ty/src/display.rs              |  4 +-
 src/tools/rust-analyzer/crates/hir/src/lib.rs |  6 +--
 .../rust-analyzer/crates/hir/src/semantics.rs |  7 ++++
 .../crates/hir/src/term_search/expr.rs        | 10 ++---
 .../crates/ide-assists/src/assist_config.rs   | 18 +++++++--
 .../src/handlers/add_missing_match_arms.rs    |  7 ++--
 .../src/handlers/convert_bool_to_enum.rs      | 37 ++++++++++---------
 .../src/handlers/convert_into_to_from.rs      |  2 +-
 .../convert_tuple_return_type_to_struct.rs    |  3 +-
 .../handlers/destructure_struct_binding.rs    |  3 +-
 .../src/handlers/extract_function.rs          |  3 +-
 .../extract_struct_from_enum_variant.rs       |  3 +-
 .../src/handlers/generate_deref.rs            |  8 ++--
 .../ide-assists/src/handlers/generate_new.rs  |  3 +-
 .../generate_single_field_struct_from.rs      |  7 +---
 .../src/handlers/qualify_method_call.rs       |  3 +-
 .../replace_derive_with_manual_impl.rs        |  3 +-
 .../replace_qualified_name_with_use.rs        |  9 ++---
 .../ide-assists/src/handlers/term_search.rs   |  2 +-
 .../src/handlers/toggle_async_sugar.rs        |  7 +---
 .../crates/ide-completion/src/completions.rs  |  2 +-
 .../ide-completion/src/completions/expr.rs    |  4 +-
 .../src/completions/flyimport.rs              |  6 +--
 .../ide-completion/src/completions/postfix.rs |  2 +-
 .../crates/ide-completion/src/config.rs       | 19 ++++++++--
 .../crates/ide-completion/src/render.rs       |  2 +-
 .../crates/ide-completion/src/snippet.rs      |  2 +-
 .../ide-db/src/imports/import_assets.rs       | 21 ++++++++++-
 .../crates/ide-db/src/path_transform.rs       | 10 ++---
 .../src/handlers/json_is_not_rust.rs          |  4 +-
 .../src/handlers/missing_fields.rs            |  4 +-
 .../src/handlers/typed_hole.rs                |  4 +-
 .../crates/ide-ssr/src/matching.rs            |  4 +-
 .../rust-analyzer/src/cli/analysis_stats.rs   |  6 +--
 36 files changed, 144 insertions(+), 101 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-def/src/find_path.rs b/src/tools/rust-analyzer/crates/hir-def/src/find_path.rs
index faa0ef8ceec7b..e8a6ebcffa0a5 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/find_path.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/find_path.rs
@@ -12,7 +12,7 @@ use intern::sym;
 use rustc_hash::FxHashSet;
 
 use crate::{
-    ImportPathConfig, ModuleDefId, ModuleId,
+    FindPathConfig, ModuleDefId, ModuleId,
     db::DefDatabase,
     item_scope::ItemInNs,
     nameres::DefMap,
@@ -27,7 +27,7 @@ pub fn find_path(
     from: ModuleId,
     mut prefix_kind: PrefixKind,
     ignore_local_imports: bool,
-    mut cfg: ImportPathConfig,
+    mut cfg: FindPathConfig,
 ) -> Option<ModPath> {
     let _p = tracing::info_span!("find_path").entered();
 
@@ -96,7 +96,7 @@ impl PrefixKind {
 struct FindPathCtx<'db> {
     db: &'db dyn DefDatabase,
     prefix: PrefixKind,
-    cfg: ImportPathConfig,
+    cfg: FindPathConfig,
     ignore_local_imports: bool,
     is_std_item: bool,
     from: ModuleId,
@@ -718,7 +718,7 @@ mod tests {
                 module,
                 prefix,
                 ignore_local_imports,
-                ImportPathConfig { prefer_no_std, prefer_prelude, prefer_absolute, allow_unstable },
+                FindPathConfig { prefer_no_std, prefer_prelude, prefer_absolute, allow_unstable },
             );
             format_to!(
                 res,
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/lib.rs b/src/tools/rust-analyzer/crates/hir-def/src/lib.rs
index 1f5b1e023702f..301d4cca0666c 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/lib.rs
@@ -101,7 +101,7 @@ use crate::{
 type FxIndexMap<K, V> = indexmap::IndexMap<K, V, rustc_hash::FxBuildHasher>;
 /// A wrapper around three booleans
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Copy)]
-pub struct ImportPathConfig {
+pub struct FindPathConfig {
     /// If true, prefer to unconditionally use imports of the `core` and `alloc` crate
     /// over the std.
     pub prefer_no_std: bool,
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 ae0113fcbd7f0..f3691b2e4f7e8 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
@@ -11,7 +11,7 @@ use base_db::Crate;
 use chalk_ir::{BoundVar, Safety, TyKind};
 use either::Either;
 use hir_def::{
-    GeneralConstId, GenericDefId, HasModule, ImportPathConfig, LocalFieldId, Lookup, ModuleDefId,
+    FindPathConfig, GeneralConstId, GenericDefId, HasModule, LocalFieldId, Lookup, ModuleDefId,
     ModuleId, TraitId,
     db::DefDatabase,
     expr_store::{ExpressionStore, path::Path},
@@ -1433,7 +1433,7 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                             PrefixKind::Plain,
                             false,
                             // FIXME: no_std Cfg?
-                            ImportPathConfig {
+                            FindPathConfig {
                                 prefer_no_std: false,
                                 prefer_prelude: true,
                                 prefer_absolute: false,
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index f03f542e5bce3..4d1d8e2b15a9e 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -130,7 +130,7 @@ pub use {
     cfg::{CfgAtom, CfgExpr, CfgOptions},
     hir_def::{
         Complete,
-        ImportPathConfig,
+        FindPathConfig,
         attr::{AttrSourceMap, Attrs, AttrsWithOwner},
         find_path::PrefixKind,
         import_map,
@@ -957,7 +957,7 @@ impl Module {
         self,
         db: &dyn DefDatabase,
         item: impl Into<ItemInNs>,
-        cfg: ImportPathConfig,
+        cfg: FindPathConfig,
     ) -> Option<ModPath> {
         hir_def::find_path::find_path(
             db,
@@ -976,7 +976,7 @@ impl Module {
         db: &dyn DefDatabase,
         item: impl Into<ItemInNs>,
         prefix_kind: PrefixKind,
-        cfg: ImportPathConfig,
+        cfg: FindPathConfig,
     ) -> Option<ModPath> {
         hir_def::find_path::find_path(db, item.into().into(), self.into(), prefix_kind, true, cfg)
     }
diff --git a/src/tools/rust-analyzer/crates/hir/src/semantics.rs b/src/tools/rust-analyzer/crates/hir/src/semantics.rs
index 6d6e08100b044..84f01da72f069 100644
--- a/src/tools/rust-analyzer/crates/hir/src/semantics.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/semantics.rs
@@ -302,6 +302,13 @@ impl<DB: HirDatabase + ?Sized> Semantics<'_, DB> {
         self.imp.hir_file_to_module_defs(file.into())
     }
 
+    pub fn is_nightly(&self, krate: Crate) -> bool {
+        let toolchain = self.db.toolchain_channel(krate.into());
+        // `toolchain == None` means we're in some detached files. Since we have no information on
+        // the toolchain being used, let's just allow unstable items to be listed.
+        matches!(toolchain, Some(base_db::ReleaseChannel::Nightly) | None)
+    }
+
     pub fn to_adt_def(&self, a: &ast::Adt) -> Option<Adt> {
         self.imp.to_def(a)
     }
diff --git a/src/tools/rust-analyzer/crates/hir/src/term_search/expr.rs b/src/tools/rust-analyzer/crates/hir/src/term_search/expr.rs
index 78f534d014b90..e56f9e91e3f33 100644
--- a/src/tools/rust-analyzer/crates/hir/src/term_search/expr.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/term_search/expr.rs
@@ -1,6 +1,6 @@
 //! Type tree for term search
 
-use hir_def::ImportPathConfig;
+use hir_def::FindPathConfig;
 use hir_expand::mod_path::ModPath;
 use hir_ty::{
     db::HirDatabase,
@@ -18,7 +18,7 @@ use crate::{
 fn mod_item_path(
     sema_scope: &SemanticsScope<'_>,
     def: &ModuleDef,
-    cfg: ImportPathConfig,
+    cfg: FindPathConfig,
 ) -> Option<ModPath> {
     let db = sema_scope.db;
     let m = sema_scope.module();
@@ -29,7 +29,7 @@ fn mod_item_path(
 fn mod_item_path_str(
     sema_scope: &SemanticsScope<'_>,
     def: &ModuleDef,
-    cfg: ImportPathConfig,
+    cfg: FindPathConfig,
     edition: Edition,
 ) -> Result<String, DisplaySourceCodeError> {
     let path = mod_item_path(sema_scope, def, cfg);
@@ -103,7 +103,7 @@ impl<'db> Expr<'db> {
         &self,
         sema_scope: &SemanticsScope<'db>,
         many_formatter: &mut dyn FnMut(&Type<'db>) -> String,
-        cfg: ImportPathConfig,
+        cfg: FindPathConfig,
         display_target: DisplayTarget,
     ) -> Result<String, DisplaySourceCodeError> {
         let db = sema_scope.db;
@@ -380,7 +380,7 @@ impl<'db> Expr<'db> {
 fn container_name(
     container: AssocItemContainer,
     sema_scope: &SemanticsScope<'_>,
-    cfg: ImportPathConfig,
+    cfg: FindPathConfig,
     edition: Edition,
     display_target: DisplayTarget,
 ) -> Result<String, DisplaySourceCodeError> {
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/assist_config.rs b/src/tools/rust-analyzer/crates/ide-assists/src/assist_config.rs
index 57ced8d8534b2..597d035ebd857 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/assist_config.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/assist_config.rs
@@ -4,8 +4,12 @@
 //! module, and we use to statically check that we only produce snippet
 //! assists if we are allowed to.
 
-use hir::ImportPathConfig;
-use ide_db::{SnippetCap, assists::ExprFillDefaultMode, imports::insert_use::InsertUseConfig};
+use hir::FindPathConfig;
+use ide_db::{
+    SnippetCap,
+    assists::ExprFillDefaultMode,
+    imports::{import_assets::ImportPathConfig, insert_use::InsertUseConfig},
+};
 
 use crate::AssistKind;
 
@@ -31,7 +35,15 @@ impl AssistConfig {
             prefer_no_std: self.prefer_no_std,
             prefer_prelude: self.prefer_prelude,
             prefer_absolute: self.prefer_absolute,
-            allow_unstable: true,
+        }
+    }
+
+    pub fn find_path_confg(&self, allow_unstable: bool) -> FindPathConfig {
+        FindPathConfig {
+            prefer_no_std: self.prefer_no_std,
+            prefer_prelude: self.prefer_prelude,
+            prefer_absolute: self.prefer_absolute,
+            allow_unstable,
         }
     }
 }
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs
index 1ece7ddab101e..4d3212c515f28 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs
@@ -1,7 +1,7 @@
 use std::iter::{self, Peekable};
 
 use either::Either;
-use hir::{Adt, AsAssocItem, Crate, HasAttrs, ImportPathConfig, ModuleDef, Semantics, sym};
+use hir::{Adt, AsAssocItem, Crate, FindPathConfig, HasAttrs, ModuleDef, Semantics, sym};
 use ide_db::RootDatabase;
 use ide_db::assists::ExprFillDefaultMode;
 use ide_db::syntax_helpers::suggest_name;
@@ -76,12 +76,11 @@ pub(crate) fn add_missing_match_arms(acc: &mut Assists, ctx: &AssistContext<'_>)
         .filter(|pat| !matches!(pat, Pat::WildcardPat(_)))
         .collect();
 
-    let cfg = ctx.config.import_path_config();
-
     let make = SyntaxFactory::with_mappings();
 
     let scope = ctx.sema.scope(expr.syntax())?;
     let module = scope.module();
+    let cfg = ctx.config.find_path_confg(ctx.sema.is_nightly(scope.krate()));
     let self_ty = if ctx.config.prefer_self_ty {
         scope
             .containing_function()
@@ -498,7 +497,7 @@ fn build_pat(
     make: &SyntaxFactory,
     module: hir::Module,
     var: ExtendedVariant,
-    cfg: ImportPathConfig,
+    cfg: FindPathConfig,
 ) -> Option<ast::Pat> {
     let db = ctx.db();
     match var {
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_bool_to_enum.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_bool_to_enum.rs
index c208c8bf789a0..80445578fcef9 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_bool_to_enum.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_bool_to_enum.rs
@@ -329,8 +329,6 @@ fn augment_references_with_imports(
 ) -> Vec<FileReferenceWithImport> {
     let mut visited_modules = FxHashSet::default();
 
-    let cfg = ctx.config.import_path_config();
-
     let edition = target_module.krate().edition(ctx.db());
     references
         .into_iter()
@@ -345,22 +343,27 @@ fn augment_references_with_imports(
             {
                 visited_modules.insert(ref_module);
 
-                let import_scope = ImportScope::find_insert_use_container(name.syntax(), &ctx.sema);
-                let path = ref_module
-                    .find_use_path(
-                        ctx.sema.db,
-                        ModuleDef::Module(*target_module),
-                        ctx.config.insert_use.prefix_kind,
-                        cfg,
-                    )
-                    .map(|mod_path| {
-                        make::path_concat(
-                            mod_path_to_ast(&mod_path, edition),
-                            make::path_from_text("Bool"),
-                        )
-                    });
+                ImportScope::find_insert_use_container(name.syntax(), &ctx.sema).and_then(
+                    |import_scope| {
+                        let cfg =
+                            ctx.config.find_path_confg(ctx.sema.is_nightly(target_module.krate()));
+                        let path = ref_module
+                            .find_use_path(
+                                ctx.sema.db,
+                                ModuleDef::Module(*target_module),
+                                ctx.config.insert_use.prefix_kind,
+                                cfg,
+                            )
+                            .map(|mod_path| {
+                                make::path_concat(
+                                    mod_path_to_ast(&mod_path, edition),
+                                    make::path_from_text("Bool"),
+                                )
+                            })?;
 
-                import_scope.zip(path)
+                        Some((import_scope, path))
+                    },
+                )
             } else {
                 None
             };
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_into_to_from.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_into_to_from.rs
index 3d9cde0e0a67c..3a464a3dc6aae 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_into_to_from.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_into_to_from.rs
@@ -43,7 +43,7 @@ pub(crate) fn convert_into_to_from(acc: &mut Assists, ctx: &AssistContext<'_>) -
         return None;
     }
 
-    let cfg = ctx.config.import_path_config();
+    let cfg = ctx.config.find_path_confg(ctx.sema.is_nightly(module.krate()));
 
     let src_type_path = {
         let src_type_path = src_type.syntax().descendants().find_map(ast::Path::cast)?;
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_tuple_return_type_to_struct.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_tuple_return_type_to_struct.rs
index 247c1011589bb..80ffb4db3e84d 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_tuple_return_type_to_struct.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_tuple_return_type_to_struct.rs
@@ -184,8 +184,6 @@ fn augment_references_with_imports(
 ) -> Vec<(ast::NameLike, Option<(ImportScope, ast::Path)>)> {
     let mut visited_modules = FxHashSet::default();
 
-    let cfg = ctx.config.import_path_config();
-
     references
         .iter()
         .filter_map(|FileReference { name, .. }| {
@@ -201,6 +199,7 @@ fn augment_references_with_imports(
             {
                 visited_modules.insert(ref_module);
 
+                let cfg = ctx.config.find_path_confg(ctx.sema.is_nightly(ref_module.krate()));
                 let import_scope =
                     ImportScope::find_insert_use_container(new_name.syntax(), &ctx.sema);
                 let path = ref_module
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_struct_binding.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_struct_binding.rs
index b8c647ac8b71d..397327cb4ff8c 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_struct_binding.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_struct_binding.rs
@@ -86,9 +86,8 @@ fn collect_data(ident_pat: ast::IdentPat, ctx: &AssistContext<'_>) -> Option<Str
     let ty = ctx.sema.type_of_binding_in_pat(&ident_pat)?;
     let hir::Adt::Struct(struct_type) = ty.strip_references().as_adt()? else { return None };
 
-    let cfg = ctx.config.import_path_config();
-
     let module = ctx.sema.scope(ident_pat.syntax())?.module();
+    let cfg = ctx.config.find_path_confg(ctx.sema.is_nightly(module.krate()));
     let struct_def = hir::ModuleDef::from(struct_type);
     let kind = struct_type.kind(ctx.db());
     let struct_def_path = module.find_path(ctx.db(), struct_def, cfg)?;
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_function.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_function.rs
index d88e3311bd7bf..e79ce567d332e 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_function.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_function.rs
@@ -209,11 +209,12 @@ pub(crate) fn extract_function(acc: &mut Assists, ctx: &AssistContext<'_>) -> Op
                     FamousDefs(&ctx.sema, module.krate()).core_ops_ControlFlow();
 
                 if let Some(control_flow_enum) = control_flow_enum {
+                    let cfg = ctx.config.find_path_confg(ctx.sema.is_nightly(module.krate()));
                     let mod_path = module.find_use_path(
                         ctx.sema.db,
                         ModuleDef::from(control_flow_enum),
                         ctx.config.insert_use.prefix_kind,
-                        ctx.config.import_path_config(),
+                        cfg,
                     );
 
                     if let Some(mod_path) = mod_path {
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs
index c56d0b3de5d6a..a5467e760bf39 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -400,11 +400,12 @@ fn process_references(
             let segment = builder.make_mut(segment);
             let scope_node = builder.make_syntax_mut(scope_node);
             if !visited_modules.contains(&module) {
+                let cfg = ctx.config.find_path_confg(ctx.sema.is_nightly(module.krate()));
                 let mod_path = module.find_use_path(
                     ctx.sema.db,
                     *enum_module_def,
                     ctx.config.insert_use.prefix_kind,
-                    ctx.config.import_path_config(),
+                    cfg,
                 );
                 if let Some(mut mod_path) = mod_path {
                     mod_path.pop_segment();
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_deref.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_deref.rs
index 55a09c5d775d2..a1fc2c6023597 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_deref.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_deref.rs
@@ -57,9 +57,9 @@ fn generate_record_deref(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<(
     };
 
     let module = ctx.sema.to_def(&strukt)?.module(ctx.db());
+    let cfg = ctx.config.find_path_confg(ctx.sema.is_nightly(module.krate()));
     let trait_ = deref_type_to_generate.to_trait(&ctx.sema, module.krate())?;
-    let trait_path =
-        module.find_path(ctx.db(), ModuleDef::Trait(trait_), ctx.config.import_path_config())?;
+    let trait_path = module.find_path(ctx.db(), ModuleDef::Trait(trait_), cfg)?;
 
     let field_type = field.ty()?;
     let field_name = field.name()?;
@@ -99,9 +99,9 @@ fn generate_tuple_deref(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()
     };
 
     let module = ctx.sema.to_def(&strukt)?.module(ctx.db());
+    let cfg = ctx.config.find_path_confg(ctx.sema.is_nightly(module.krate()));
     let trait_ = deref_type_to_generate.to_trait(&ctx.sema, module.krate())?;
-    let trait_path =
-        module.find_path(ctx.db(), ModuleDef::Trait(trait_), ctx.config.import_path_config())?;
+    let trait_path = module.find_path(ctx.db(), ModuleDef::Trait(trait_), cfg)?;
 
     let field_type = field.ty()?;
     let target = field.syntax().text_range();
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_new.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_new.rs
index ac4a54a89ef1f..9760fd62aab4f 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_new.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_new.rs
@@ -77,10 +77,11 @@ pub(crate) fn generate_new(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option
 
                 let item_in_ns = hir::ItemInNs::from(hir::ModuleDef::from(ty.as_adt()?));
 
+                let cfg = ctx.config.find_path_confg(ctx.sema.is_nightly(current_module.krate()));
                 let type_path = current_module.find_path(
                     ctx.sema.db,
                     item_for_path_search(ctx.sema.db, item_in_ns)?,
-                    ctx.config.import_path_config(),
+                    cfg,
                 )?;
 
                 let edition = current_module.krate().edition(ctx.db());
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_single_field_struct_from.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_single_field_struct_from.rs
index 943795d40d551..cad14d929648a 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_single_field_struct_from.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_single_field_struct_from.rs
@@ -169,6 +169,7 @@ fn make_constructors(
     types: &[ast::Type],
 ) -> Vec<Option<ast::Expr>> {
     let (db, sema) = (ctx.db(), &ctx.sema);
+    let cfg = ctx.config.find_path_confg(ctx.sema.is_nightly(module.krate()));
     types
         .iter()
         .map(|ty| {
@@ -179,11 +180,7 @@ fn make_constructors(
             let item_in_ns = ModuleDef::Adt(ty.as_adt()?).into();
             let edition = module.krate().edition(db);
 
-            let ty_path = module.find_path(
-                db,
-                item_for_path_search(db, item_in_ns)?,
-                ctx.config.import_path_config(),
-            )?;
+            let ty_path = module.find_path(db, item_for_path_search(db, item_in_ns)?, cfg)?;
 
             use_trivial_constructor(db, mod_path_to_ast(&ty_path, edition), &ty, edition)
         })
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/qualify_method_call.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/qualify_method_call.rs
index 985121780b1ab..e4494f0492ece 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/qualify_method_call.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/qualify_method_call.rs
@@ -45,10 +45,11 @@ pub(crate) fn qualify_method_call(acc: &mut Assists, ctx: &AssistContext<'_>) ->
     let current_edition = current_module.krate().edition(ctx.db());
     let target_module_def = ModuleDef::from(resolved_call);
     let item_in_ns = ItemInNs::from(target_module_def);
+    let cfg = ctx.config.find_path_confg(ctx.sema.is_nightly(current_module.krate()));
     let receiver_path = current_module.find_path(
         ctx.sema.db,
         item_for_path_search(ctx.sema.db, item_in_ns)?,
-        ctx.config.import_path_config(),
+        cfg,
     )?;
 
     let qualify_candidate = QualifyCandidate::ImplMethod(ctx.sema.db, call, resolved_call);
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_derive_with_manual_impl.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_derive_with_manual_impl.rs
index 175f261317058..25c5593007bcb 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_derive_with_manual_impl.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_derive_with_manual_impl.rs
@@ -71,6 +71,7 @@ pub(crate) fn replace_derive_with_manual_impl(
     let current_module = ctx.sema.scope(adt.syntax())?.module();
     let current_crate = current_module.krate();
     let current_edition = current_crate.edition(ctx.db());
+    let cfg = ctx.config.find_path_confg(ctx.sema.is_nightly(current_crate));
 
     let found_traits = items_locator::items_with_name(
         ctx.db(),
@@ -84,7 +85,7 @@ pub(crate) fn replace_derive_with_manual_impl(
     })
     .flat_map(|trait_| {
         current_module
-            .find_path(ctx.sema.db, hir::ModuleDef::Trait(trait_), ctx.config.import_path_config())
+            .find_path(ctx.sema.db, hir::ModuleDef::Trait(trait_), cfg)
             .as_ref()
             .map(|path| mod_path_to_ast(path, current_edition))
             .zip(Some(trait_))
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_qualified_name_with_use.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_qualified_name_with_use.rs
index 9f742131e5cb4..5fc4d7a6170de 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_qualified_name_with_use.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_qualified_name_with_use.rs
@@ -63,12 +63,9 @@ pub(crate) fn replace_qualified_name_with_use(
     );
     let path_to_qualifier = starts_with_name_ref
         .then(|| {
-            ctx.sema.scope(original_path.syntax())?.module().find_use_path(
-                ctx.sema.db,
-                module,
-                ctx.config.insert_use.prefix_kind,
-                ctx.config.import_path_config(),
-            )
+            let mod_ = ctx.sema.scope(original_path.syntax())?.module();
+            let cfg = ctx.config.find_path_confg(ctx.sema.is_nightly(mod_.krate()));
+            mod_.find_use_path(ctx.sema.db, module, ctx.config.insert_use.prefix_kind, cfg)
         })
         .flatten();
 
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/term_search.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/term_search.rs
index 6527d3706e217..209d3f08eb888 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/term_search.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/term_search.rs
@@ -55,7 +55,7 @@ pub(crate) fn term_search(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<
             path.gen_source_code(
                 &scope,
                 &mut formatter,
-                ctx.config.import_path_config(),
+                ctx.config.find_path_confg(ctx.sema.is_nightly(scope.module().krate())),
                 scope.krate().to_display_target(ctx.db()),
             )
             .ok()
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/toggle_async_sugar.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/toggle_async_sugar.rs
index eed070cb07dd6..aed66d3d8344c 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/toggle_async_sugar.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/toggle_async_sugar.rs
@@ -132,12 +132,9 @@ pub(crate) fn desugar_async_into_impl_future(
 
     let scope = ctx.sema.scope(function.syntax())?;
     let module = scope.module();
+    let cfg = ctx.config.find_path_confg(ctx.sema.is_nightly(module.krate()));
     let future_trait = FamousDefs(&ctx.sema, scope.krate()).core_future_Future()?;
-    let trait_path = module.find_path(
-        ctx.db(),
-        ModuleDef::Trait(future_trait),
-        ctx.config.import_path_config(),
-    )?;
+    let trait_path = module.find_path(ctx.db(), ModuleDef::Trait(future_trait), cfg)?;
     let edition = scope.krate().edition(ctx.db());
     let trait_path = trait_path.display(ctx.db(), edition);
 
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions.rs
index 11d26228ba201..e36e0e5704581 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions.rs
@@ -654,7 +654,7 @@ fn enum_variants_with_paths(
         if let Some(path) = ctx.module.find_path(
             ctx.db,
             hir::ModuleDef::from(variant),
-            ctx.config.import_path_config(ctx.is_nightly),
+            ctx.config.find_path_config(ctx.is_nightly),
         ) {
             // Variants with trivial paths are already added by the existing completion logic,
             // so we should avoid adding these twice
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/expr.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/expr.rs
index 1972f166134a4..a5b8a0b1ceb6b 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/expr.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/expr.rs
@@ -254,7 +254,7 @@ pub(crate) fn complete_expr_path(
                             .find_path(
                                 ctx.db,
                                 hir::ModuleDef::from(strukt),
-                                ctx.config.import_path_config(ctx.is_nightly),
+                                ctx.config.find_path_config(ctx.is_nightly),
                             )
                             .filter(|it| it.len() > 1);
 
@@ -276,7 +276,7 @@ pub(crate) fn complete_expr_path(
                             .find_path(
                                 ctx.db,
                                 hir::ModuleDef::from(un),
-                                ctx.config.import_path_config(ctx.is_nightly),
+                                ctx.config.find_path_config(ctx.is_nightly),
                             )
                             .filter(|it| it.len() > 1);
 
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/flyimport.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/flyimport.rs
index dad8a76de87df..d1e05a4359f19 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/flyimport.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/flyimport.rs
@@ -257,7 +257,7 @@ fn import_on_the_fly(
     };
     let user_input_lowercased = potential_import_name.to_lowercase();
 
-    let import_cfg = ctx.config.import_path_config(ctx.is_nightly);
+    let import_cfg = ctx.config.import_path_config();
 
     import_assets
         .search_for_imports(&ctx.sema, import_cfg, ctx.config.insert_use.prefix_kind)
@@ -304,7 +304,7 @@ fn import_on_the_fly_pat_(
         ItemInNs::Values(def) => matches!(def, hir::ModuleDef::Const(_)),
     };
     let user_input_lowercased = potential_import_name.to_lowercase();
-    let cfg = ctx.config.import_path_config(ctx.is_nightly);
+    let cfg = ctx.config.import_path_config();
 
     import_assets
         .search_for_imports(&ctx.sema, cfg, ctx.config.insert_use.prefix_kind)
@@ -346,7 +346,7 @@ fn import_on_the_fly_method(
 
     let user_input_lowercased = potential_import_name.to_lowercase();
 
-    let cfg = ctx.config.import_path_config(ctx.is_nightly);
+    let cfg = ctx.config.import_path_config();
 
     import_assets
         .search_for_imports(&ctx.sema, cfg, ctx.config.insert_use.prefix_kind)
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/postfix.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/postfix.rs
index 0058611a61539..d355fdbe0739c 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/postfix.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/postfix.rs
@@ -63,7 +63,7 @@ pub(crate) fn complete_postfix(
         None => return,
     };
 
-    let cfg = ctx.config.import_path_config(ctx.is_nightly);
+    let cfg = ctx.config.find_path_config(ctx.is_nightly);
 
     if let Some(drop_trait) = ctx.famous_defs().core_ops_Drop()
         && receiver_ty.impls_trait(ctx.db, drop_trait, &[])
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/config.rs b/src/tools/rust-analyzer/crates/ide-completion/src/config.rs
index 844fce5ef8019..b7367cb62f099 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/config.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/config.rs
@@ -4,8 +4,11 @@
 //! module, and we use to statically check that we only produce snippet
 //! completions if we are allowed to.
 
-use hir::ImportPathConfig;
-use ide_db::{SnippetCap, imports::insert_use::InsertUseConfig};
+use hir::FindPathConfig;
+use ide_db::{
+    SnippetCap,
+    imports::{import_assets::ImportPathConfig, insert_use::InsertUseConfig},
+};
 
 use crate::{CompletionFieldsToResolve, snippet::Snippet};
 
@@ -59,12 +62,20 @@ impl CompletionConfig<'_> {
             .flat_map(|snip| snip.prefix_triggers.iter().map(move |trigger| (&**trigger, snip)))
     }
 
-    pub fn import_path_config(&self, allow_unstable: bool) -> ImportPathConfig {
-        ImportPathConfig {
+    pub fn find_path_config(&self, allow_unstable: bool) -> FindPathConfig {
+        FindPathConfig {
             prefer_no_std: self.prefer_no_std,
             prefer_prelude: self.prefer_prelude,
             prefer_absolute: self.prefer_absolute,
             allow_unstable,
         }
     }
+
+    pub fn import_path_config(&self) -> ImportPathConfig {
+        ImportPathConfig {
+            prefer_no_std: self.prefer_no_std,
+            prefer_prelude: self.prefer_prelude,
+            prefer_absolute: self.prefer_absolute,
+        }
+    }
 }
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/render.rs b/src/tools/rust-analyzer/crates/ide-completion/src/render.rs
index 7d23f9d14c66f..dbf68dbe33afe 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/render.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/render.rs
@@ -299,7 +299,7 @@ pub(crate) fn render_expr(
             .unwrap_or_else(|| String::from("..."))
     };
 
-    let cfg = ctx.config.import_path_config(ctx.is_nightly);
+    let cfg = ctx.config.find_path_config(ctx.is_nightly);
 
     let label =
         expr.gen_source_code(&ctx.scope, &mut label_formatter, cfg, ctx.display_target).ok()?;
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/snippet.rs b/src/tools/rust-analyzer/crates/ide-completion/src/snippet.rs
index 9dc0c0234dc56..d326098f94071 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/snippet.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/snippet.rs
@@ -164,7 +164,7 @@ impl Snippet {
 }
 
 fn import_edits(ctx: &CompletionContext<'_>, requires: &[ModPath]) -> Option<Vec<LocatedImport>> {
-    let import_cfg = ctx.config.import_path_config(ctx.is_nightly);
+    let import_cfg = ctx.config.find_path_config(ctx.is_nightly);
 
     let resolve = |import| {
         let item = ctx.scope.resolve_mod_path(import).next()?;
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/imports/import_assets.rs b/src/tools/rust-analyzer/crates/ide-db/src/imports/import_assets.rs
index 1012f993344fe..0c235c8d9a57a 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/imports/import_assets.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/imports/import_assets.rs
@@ -3,7 +3,7 @@
 use std::ops::ControlFlow;
 
 use hir::{
-    AsAssocItem, AssocItem, AssocItemContainer, Complete, Crate, HasCrate, ImportPathConfig,
+    AsAssocItem, AssocItem, AssocItemContainer, Complete, Crate, FindPathConfig, HasCrate,
     ItemInNs, ModPath, Module, ModuleDef, Name, PathResolution, PrefixKind, ScopeDef, Semantics,
     SemanticsScope, Trait, TyFingerprint, Type, db::HirDatabase,
 };
@@ -19,6 +19,17 @@ use crate::{
     items_locator::{self, AssocSearchMode, DEFAULT_QUERY_SEARCH_LIMIT},
 };
 
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Copy)]
+pub struct ImportPathConfig {
+    /// If true, prefer to unconditionally use imports of the `core` and `alloc` crate
+    /// over the std.
+    pub prefer_no_std: bool,
+    /// If true, prefer import paths containing a prelude module.
+    pub prefer_prelude: bool,
+    /// If true, prefer abs path (starting with `::`) where it is available.
+    pub prefer_absolute: bool,
+}
+
 /// A candidate for import, derived during various IDE activities:
 /// * completion with imports on the fly proposals
 /// * completion edit resolve requests
@@ -296,6 +307,12 @@ impl<'db> ImportAssets<'db> {
             Some(it) => it,
             None => return <FxIndexSet<_>>::default().into_iter(),
         };
+        let cfg = FindPathConfig {
+            prefer_no_std: cfg.prefer_no_std,
+            prefer_prelude: cfg.prefer_prelude,
+            prefer_absolute: cfg.prefer_absolute,
+            allow_unstable: sema.is_nightly(scope.krate()),
+        };
         let db = sema.db;
         let krate = self.module_with_candidate.krate();
         let scope_definitions = self.scope_definitions(sema);
@@ -698,7 +715,7 @@ fn get_mod_path(
     item_to_search: ItemInNs,
     module_with_candidate: &Module,
     prefixed: Option<PrefixKind>,
-    cfg: ImportPathConfig,
+    cfg: FindPathConfig,
 ) -> Option<ModPath> {
     if let Some(prefix_kind) = prefixed {
         module_with_candidate.find_use_path(db, item_to_search, prefix_kind, cfg)
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/path_transform.rs b/src/tools/rust-analyzer/crates/ide-db/src/path_transform.rs
index a76a0551dd8db..4a27035afd091 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/path_transform.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/path_transform.rs
@@ -3,7 +3,7 @@
 use crate::helpers::mod_path_to_ast;
 use either::Either;
 use hir::{
-    AsAssocItem, HirDisplay, HirFileId, ImportPathConfig, ModuleDef, SemanticsScope,
+    AsAssocItem, FindPathConfig, HirDisplay, HirFileId, ModuleDef, SemanticsScope,
     prettify_macro_expansion,
 };
 use itertools::Itertools;
@@ -392,7 +392,7 @@ impl Ctx<'_> {
                             parent.segment()?.name_ref()?,
                         )
                         .and_then(|trait_ref| {
-                            let cfg = ImportPathConfig {
+                            let cfg = FindPathConfig {
                                 prefer_no_std: false,
                                 prefer_prelude: true,
                                 prefer_absolute: false,
@@ -452,7 +452,7 @@ impl Ctx<'_> {
                     return None;
                 }
 
-                let cfg = ImportPathConfig {
+                let cfg = FindPathConfig {
                     prefer_no_std: false,
                     prefer_prelude: true,
                     prefer_absolute: false,
@@ -501,7 +501,7 @@ impl Ctx<'_> {
                 if let Some(adt) = ty.as_adt()
                     && let ast::Type::PathType(path_ty) = &ast_ty
                 {
-                    let cfg = ImportPathConfig {
+                    let cfg = FindPathConfig {
                         prefer_no_std: false,
                         prefer_prelude: true,
                         prefer_absolute: false,
@@ -546,7 +546,7 @@ impl Ctx<'_> {
 
         match resolution {
             hir::PathResolution::Def(def) if def.as_assoc_item(self.source_scope.db).is_none() => {
-                let cfg = ImportPathConfig {
+                let cfg = FindPathConfig {
                     prefer_no_std: false,
                     prefer_prelude: true,
                     prefer_absolute: false,
diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/json_is_not_rust.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/json_is_not_rust.rs
index 742d614bc5673..2dfc2bb56595c 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/json_is_not_rust.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/json_is_not_rust.rs
@@ -1,7 +1,7 @@
 //! This diagnostic provides an assist for creating a struct definition from a JSON
 //! example.
 
-use hir::{ImportPathConfig, PathResolution, Semantics};
+use hir::{FindPathConfig, PathResolution, Semantics};
 use ide_db::text_edit::TextEdit;
 use ide_db::{
     EditionedFileId, FileRange, FxHashMap, RootDatabase,
@@ -141,7 +141,7 @@ pub(crate) fn json_in_items(
                         let scope = scb.make_import_scope_mut(import_scope);
                         let current_module = semantics_scope.module();
 
-                        let cfg = ImportPathConfig {
+                        let cfg = FindPathConfig {
                             prefer_no_std: config.prefer_no_std,
                             prefer_prelude: config.prefer_prelude,
                             prefer_absolute: config.prefer_absolute,
diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_fields.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_fields.rs
index 893bfca6a1298..49f925e2e0c93 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_fields.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_fields.rs
@@ -1,6 +1,6 @@
 use either::Either;
 use hir::{
-    AssocItem, HirDisplay, ImportPathConfig, InFile, Type,
+    AssocItem, FindPathConfig, HirDisplay, InFile, Type,
     db::{ExpandDatabase, HirDatabase},
     sym,
 };
@@ -132,7 +132,7 @@ fn fixes(ctx: &DiagnosticsContext<'_>, d: &hir::MissingFields) -> Option<Vec<Ass
                         let type_path = current_module?.find_path(
                             ctx.sema.db,
                             item_for_path_search(ctx.sema.db, item_in_ns)?,
-                            ImportPathConfig {
+                            FindPathConfig {
                                 prefer_no_std: ctx.config.prefer_no_std,
                                 prefer_prelude: ctx.config.prefer_prelude,
                                 prefer_absolute: ctx.config.prefer_absolute,
diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/typed_hole.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/typed_hole.rs
index 8d42770269057..c29e525cec286 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/typed_hole.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/typed_hole.rs
@@ -1,7 +1,7 @@
 use std::ops::Not;
 
 use hir::{
-    ClosureStyle, HirDisplay, ImportPathConfig,
+    ClosureStyle, FindPathConfig, HirDisplay,
     db::ExpandDatabase,
     term_search::{TermSearchConfig, TermSearchCtx, term_search},
 };
@@ -73,7 +73,7 @@ fn fixes(ctx: &DiagnosticsContext<'_>, d: &hir::TypedHole<'_>) -> Option<Vec<Ass
             path.gen_source_code(
                 &scope,
                 &mut formatter,
-                ImportPathConfig {
+                FindPathConfig {
                     prefer_no_std: ctx.config.prefer_no_std,
                     prefer_prelude: ctx.config.prefer_prelude,
                     prefer_absolute: ctx.config.prefer_absolute,
diff --git a/src/tools/rust-analyzer/crates/ide-ssr/src/matching.rs b/src/tools/rust-analyzer/crates/ide-ssr/src/matching.rs
index f21132c297ee8..595f0bb5fa8af 100644
--- a/src/tools/rust-analyzer/crates/ide-ssr/src/matching.rs
+++ b/src/tools/rust-analyzer/crates/ide-ssr/src/matching.rs
@@ -6,7 +6,7 @@ use crate::{
     parsing::{Constraint, NodeKind, Placeholder, Var},
     resolving::{ResolvedPattern, ResolvedRule, UfcsCallInfo},
 };
-use hir::{FileRange, ImportPathConfig, Semantics};
+use hir::{FileRange, FindPathConfig, Semantics};
 use ide_db::{FxHashMap, base_db::RootQueryDb};
 use std::{cell::Cell, iter::Peekable};
 use syntax::{
@@ -661,7 +661,7 @@ impl Match {
             .module();
         for (path, resolved_path) in &template.resolved_paths {
             if let hir::PathResolution::Def(module_def) = resolved_path.resolution {
-                let cfg = ImportPathConfig {
+                let cfg = FindPathConfig {
                     prefer_no_std: false,
                     prefer_prelude: true,
                     prefer_absolute: false,
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
index 6c0aa19f57482..17bf504bc1711 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -10,8 +10,8 @@ use std::{
 
 use cfg::{CfgAtom, CfgDiff};
 use hir::{
-    Adt, AssocItem, Crate, DefWithBody, HasCrate, HasSource, HirDisplay, ImportPathConfig,
-    ModuleDef, Name,
+    Adt, AssocItem, Crate, DefWithBody, FindPathConfig, HasCrate, HasSource, HirDisplay, ModuleDef,
+    Name,
     db::{DefDatabase, ExpandDatabase, HirDatabase},
     next_solver::{DbInterner, GenericArgs},
 };
@@ -538,7 +538,7 @@ impl flags::AnalysisStats {
                         .gen_source_code(
                             &scope,
                             &mut formatter,
-                            ImportPathConfig {
+                            FindPathConfig {
                                 prefer_no_std: false,
                                 prefer_prelude: true,
                                 prefer_absolute: false,

From 9699d357988310919b2af51fce838d3119d45323 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukas@zed.dev>
Date: Thu, 7 Aug 2025 15:24:39 +0200
Subject: [PATCH 0983/1889] Workaround lsp-types typo

---
 .../crates/rust-analyzer/src/bin/main.rs            | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/bin/main.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/bin/main.rs
index ab045e0bf9ff1..9bcf835b4cca7 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/bin/main.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/bin/main.rs
@@ -208,13 +208,24 @@ fn run_server() -> anyhow::Result<()> {
     tracing::info!("InitializeParams: {}", initialize_params);
     let lsp_types::InitializeParams {
         root_uri,
-        capabilities,
+        mut capabilities,
         workspace_folders,
         initialization_options,
         client_info,
         ..
     } = from_json::<lsp_types::InitializeParams>("InitializeParams", &initialize_params)?;
 
+    // lsp-types has a typo in the `/capabilities/workspace/diagnostics` field, its typoed as `diagnostic`
+    if let Some(val) = initialize_params.pointer("/capabilities/workspace/diagnostics") {
+        if let Ok(diag_caps) = from_json::<lsp_types::DiagnosticWorkspaceClientCapabilities>(
+            "DiagnosticWorkspaceClientCapabilities",
+            val,
+        ) {
+            tracing::info!("Patching lsp-types workspace diagnostics capabilities: {diag_caps:#?}");
+            capabilities.workspace.get_or_insert_default().diagnostic.get_or_insert(diag_caps);
+        }
+    }
+
     let root_path = match root_uri
         .and_then(|it| it.to_file_path().ok())
         .map(patch_path_prefix)

From fd28cc8a1b2496ac9717d7185a40af123aaefafb Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukas@zed.dev>
Date: Thu, 7 Aug 2025 15:24:39 +0200
Subject: [PATCH 0984/1889] Add more workaround hacks for incorrect startup
 diagnostics

---
 .../crates/rust-analyzer/src/bin/main.rs             | 12 ++++++------
 .../crates/rust-analyzer/src/global_state.rs         |  5 +++++
 .../crates/rust-analyzer/src/handlers/dispatch.rs    |  2 +-
 .../rust-analyzer/crates/rust-analyzer/src/reload.rs |  5 ++++-
 4 files changed, 16 insertions(+), 8 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/bin/main.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/bin/main.rs
index 9bcf835b4cca7..e80f2953505f6 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/bin/main.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/bin/main.rs
@@ -216,14 +216,14 @@ fn run_server() -> anyhow::Result<()> {
     } = from_json::<lsp_types::InitializeParams>("InitializeParams", &initialize_params)?;
 
     // lsp-types has a typo in the `/capabilities/workspace/diagnostics` field, its typoed as `diagnostic`
-    if let Some(val) = initialize_params.pointer("/capabilities/workspace/diagnostics") {
-        if let Ok(diag_caps) = from_json::<lsp_types::DiagnosticWorkspaceClientCapabilities>(
+    if let Some(val) = initialize_params.pointer("/capabilities/workspace/diagnostics")
+        && let Ok(diag_caps) = from_json::<lsp_types::DiagnosticWorkspaceClientCapabilities>(
             "DiagnosticWorkspaceClientCapabilities",
             val,
-        ) {
-            tracing::info!("Patching lsp-types workspace diagnostics capabilities: {diag_caps:#?}");
-            capabilities.workspace.get_or_insert_default().diagnostic.get_or_insert(diag_caps);
-        }
+        )
+    {
+        tracing::info!("Patching lsp-types workspace diagnostics capabilities: {diag_caps:#?}");
+        capabilities.workspace.get_or_insert_default().diagnostic.get_or_insert(diag_caps);
     }
 
     let root_path = match root_uri
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/global_state.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/global_state.rs
index 2f1afba3634ef..89d6fb8edc2e6 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/global_state.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/global_state.rs
@@ -183,6 +183,10 @@ pub(crate) struct GlobalState {
     /// this queue should run only *after* [`GlobalState::process_changes`] has
     /// been called.
     pub(crate) deferred_task_queue: TaskQueue,
+    /// HACK: Workaround for https://github.com/rust-lang/rust-analyzer/issues/19709
+    /// This is marked true if we failed to load a crate root file at crate graph creation,
+    /// which will usually end up causing a bunch of incorrect diagnostics on startup.
+    pub(crate) incomplete_crate_graph: bool,
 }
 
 /// An immutable snapshot of the world's state at a point in time.
@@ -298,6 +302,7 @@ impl GlobalState {
             discover_workspace_queue: OpQueue::default(),
 
             deferred_task_queue: task_queue,
+            incomplete_crate_graph: false,
         };
         // Apply any required database inputs from the config.
         this.update_configuration(config);
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/dispatch.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/dispatch.rs
index b25245dd884a4..10bbb0bb31d99 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/dispatch.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/dispatch.rs
@@ -141,7 +141,7 @@ impl RequestDispatcher<'_> {
                 Result: Serialize,
             > + 'static,
     {
-        if !self.global_state.vfs_done {
+        if !self.global_state.vfs_done || self.global_state.incomplete_crate_graph {
             if let Some(lsp_server::Request { id, .. }) =
                 self.req.take_if(|it| it.method == R::METHOD)
             {
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/reload.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/reload.rs
index a8a54930c6e5e..c15496b3f6cd2 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/reload.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/reload.rs
@@ -741,13 +741,16 @@ impl GlobalState {
             })
             .collect();
 
+        self.incomplete_crate_graph = false;
         let (crate_graph, proc_macro_paths) = {
             // Create crate graph from all the workspaces
             let vfs = &self.vfs.read().0;
             let load = |path: &AbsPath| {
                 let vfs_path = vfs::VfsPath::from(path.to_path_buf());
                 self.crate_graph_file_dependencies.insert(vfs_path.clone());
-                vfs.file_id(&vfs_path).and_then(|(file_id, excluded)| {
+                let file_id = vfs.file_id(&vfs_path);
+                self.incomplete_crate_graph |= file_id.is_none();
+                file_id.and_then(|(file_id, excluded)| {
                     (excluded == vfs::FileExcluded::No).then_some(file_id)
                 })
             };

From d66fb4910fb7e87b7e17477ae147854adf76b0dd Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 5 Sep 2025 21:35:58 -0500
Subject: [PATCH 0985/1889] Suggest removing Box::new

---
 .../src/fn_ctxt/suggestions.rs                | 22 +++++++++++++++++++
 tests/ui/coercion/coerce-block-tail.stderr    |  7 +++---
 .../ui/coercion/coerce-box-new-to-unboxed.rs  |  4 ++++
 .../coercion/coerce-box-new-to-unboxed.stderr | 19 ++++++++++++++++
 4 files changed, 49 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/coercion/coerce-box-new-to-unboxed.rs
 create mode 100644 tests/ui/coercion/coerce-box-new-to-unboxed.stderr

diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
index aca3840712e79..a12bc05793439 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
@@ -2955,6 +2955,28 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         )
                     {
                         let deref_kind = if checked_ty.is_box() {
+                            // detect Box::new(..)
+                            if let ExprKind::Call(box_new, [_]) = expr.kind
+                                && let ExprKind::Path(qpath) = &box_new.kind
+                                && let Res::Def(DefKind::AssocFn, fn_id) =
+                                    self.typeck_results.borrow().qpath_res(qpath, box_new.hir_id)
+                                && let Some(impl_id) = self.tcx.inherent_impl_of_assoc(fn_id)
+                                && self.tcx.type_of(impl_id).skip_binder().is_box()
+                                && self.tcx.item_name(fn_id) == sym::new
+                            {
+                                let l_paren = self.tcx.sess.source_map().next_point(box_new.span);
+                                let r_paren = self.tcx.sess.source_map().end_point(expr.span);
+                                return Some((
+                                    vec![
+                                        (box_new.span.to(l_paren), String::new()),
+                                        (r_paren, String::new()),
+                                    ],
+                                    "consider removing the Box".to_string(),
+                                    Applicability::MachineApplicable,
+                                    false,
+                                    false,
+                                ));
+                            }
                             "unboxing the value"
                         } else if checked_ty.is_ref() {
                             "dereferencing the borrow"
diff --git a/tests/ui/coercion/coerce-block-tail.stderr b/tests/ui/coercion/coerce-block-tail.stderr
index 1301f3b7813ed..b358401b7062b 100644
--- a/tests/ui/coercion/coerce-block-tail.stderr
+++ b/tests/ui/coercion/coerce-block-tail.stderr
@@ -6,10 +6,11 @@ LL |     let _: &i32 = & { Box::new(1i32) };
    |
    = note: expected type `i32`
             found struct `Box<i32>`
-help: consider unboxing the value
+help: consider removing the Box
+   |
+LL -     let _: &i32 = & { Box::new(1i32) };
+LL +     let _: &i32 = & { 1i32 };
    |
-LL |     let _: &i32 = & { *Box::new(1i32) };
-   |                       +
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/coercion/coerce-box-new-to-unboxed.rs b/tests/ui/coercion/coerce-box-new-to-unboxed.rs
new file mode 100644
index 0000000000000..63ff0fc4e2381
--- /dev/null
+++ b/tests/ui/coercion/coerce-box-new-to-unboxed.rs
@@ -0,0 +1,4 @@
+fn main() {
+    let _: String = Box::new(String::new());
+    //~^ ERROR mismatched types
+}
diff --git a/tests/ui/coercion/coerce-box-new-to-unboxed.stderr b/tests/ui/coercion/coerce-box-new-to-unboxed.stderr
new file mode 100644
index 0000000000000..bdd962686e4b4
--- /dev/null
+++ b/tests/ui/coercion/coerce-box-new-to-unboxed.stderr
@@ -0,0 +1,19 @@
+error[E0308]: mismatched types
+  --> $DIR/coerce-box-new-to-unboxed.rs:2:21
+   |
+LL |     let _: String = Box::new(String::new());
+   |            ------   ^^^^^^^^^^^^^^^^^^^^^^^ expected `String`, found `Box<String>`
+   |            |
+   |            expected due to this
+   |
+   = note: expected struct `String`
+              found struct `Box<String>`
+help: consider removing the Box
+   |
+LL -     let _: String = Box::new(String::new());
+LL +     let _: String = String::new();
+   |
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0308`.

From 8b752cb37d646118c46f7739ae965b8e9c9a9b03 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sun, 14 Sep 2025 21:14:37 +0200
Subject: [PATCH 0986/1889] fix issue with `cmse-nonsecure-entry` ABI being
 both async and c-variadic

---
 .../src/hir_ty_lowering/cmse.rs               |  6 ++
 tests/crashes/132142.rs                       |  3 -
 .../cmse-nonsecure-entry/c-variadic.rs        | 69 +++++++++++++++++++
 .../cmse-nonsecure-entry/c-variadic.stderr    | 28 ++++++++
 .../cmse-nonsecure-entry/generics.rs          |  7 +-
 .../cmse-nonsecure-entry/generics.stderr      | 18 +----
 6 files changed, 105 insertions(+), 26 deletions(-)
 delete mode 100644 tests/crashes/132142.rs
 create mode 100644 tests/ui/cmse-nonsecure/cmse-nonsecure-entry/c-variadic.rs
 create mode 100644 tests/ui/cmse-nonsecure/cmse-nonsecure-entry/c-variadic.stderr

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 5088c63702e60..7867c1c3b4857 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
@@ -85,6 +85,12 @@ pub(crate) fn validate_cmse_abi<'tcx>(
                 return;
             };
 
+            // An `extern "cmse-nonsecure-entry"` function cannot be c-variadic. We run
+            // into https://github.com/rust-lang/rust/issues/132142 if we don't explicitly bail.
+            if decl.c_variadic {
+                return;
+            }
+
             match is_valid_cmse_inputs(tcx, fn_sig) {
                 Ok(Ok(())) => {}
                 Ok(Err(index)) => {
diff --git a/tests/crashes/132142.rs b/tests/crashes/132142.rs
deleted file mode 100644
index 813bf0bf0a8e5..0000000000000
--- a/tests/crashes/132142.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-//@ known-bug: #132142
-
-async extern "cmse-nonsecure-entry" fn fun(...) {}
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/c-variadic.rs b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/c-variadic.rs
new file mode 100644
index 0000000000000..9317ab5cd2756
--- /dev/null
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/c-variadic.rs
@@ -0,0 +1,69 @@
+//@ add-core-stubs
+//@ edition: 2018
+//@ compile-flags: --target thumbv8m.main-none-eabi --crate-type lib
+//@ needs-llvm-components: arm
+#![feature(cmse_nonsecure_entry, c_variadic, no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+#[lang = "va_list"]
+struct VaList(*mut u8);
+
+unsafe extern "cmse-nonsecure-entry" fn c_variadic(_: u32, _: ...) {
+    //~^ ERROR `...` is not supported for `extern "cmse-nonsecure-entry"` functions
+}
+
+// A regression test for https://github.com/rust-lang/rust/issues/132142
+async unsafe extern "cmse-nonsecure-entry" fn async_and_c_variadic(_: ...) {
+    //~^ ERROR `...` is not supported for `extern "cmse-nonsecure-entry"` functions
+    //~| ERROR functions cannot be both `async` and C-variadic
+}
+
+// Below are the lang items that are required for a program that defines an `async` function.
+// Without them, the ICE that is tested for here is not reached for this target. For now they are in
+// this file, but they may be moved into `minicore` if/when other `#[no_core]` tests want to use
+// them.
+
+// NOTE: in `core` this type uses `NonNull`.
+#[lang = "ResumeTy"]
+pub struct ResumeTy(*mut Context<'static>);
+
+#[lang = "future_trait"]
+pub trait Future {
+    /// The type of value produced on completion.
+    #[lang = "future_output"]
+    type Output;
+
+    // NOTE: misses the `poll` method.
+}
+
+#[lang = "async_drop"]
+pub trait AsyncDrop {
+    // NOTE: misses the `drop` method.
+}
+
+#[lang = "Poll"]
+pub enum Poll<T> {
+    #[lang = "Ready"]
+    Ready(T),
+
+    #[lang = "Pending"]
+    Pending,
+}
+
+#[lang = "Context"]
+pub struct Context<'a> {
+    // NOTE: misses a bunch of fields.
+    _marker: PhantomData<fn(&'a ()) -> &'a ()>,
+}
+
+#[lang = "get_context"]
+pub unsafe fn get_context<'a, 'b>(cx: ResumeTy) -> &'a mut Context<'b> {
+    // NOTE: the actual implementation looks different.
+    mem::transmute(cx.0)
+}
+
+#[lang = "pin"]
+pub struct Pin<T>(T);
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/c-variadic.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/c-variadic.stderr
new file mode 100644
index 0000000000000..948f8f5747b0e
--- /dev/null
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/c-variadic.stderr
@@ -0,0 +1,28 @@
+error: `...` is not supported for `extern "cmse-nonsecure-entry"` functions
+  --> $DIR/c-variadic.rs:14:60
+   |
+LL | unsafe extern "cmse-nonsecure-entry" fn c_variadic(_: u32, _: ...) {
+   |        -----------------------------                       ^^^^^^
+   |        |
+   |        `extern "cmse-nonsecure-entry"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: functions cannot be both `async` and C-variadic
+  --> $DIR/c-variadic.rs:19:1
+   |
+LL | async unsafe extern "cmse-nonsecure-entry" fn async_and_c_variadic(_: ...) {
+   | ^^^^^ `async` because of this                                      ^^^^^^ C-variadic because of this
+
+error: `...` is not supported for `extern "cmse-nonsecure-entry"` functions
+  --> $DIR/c-variadic.rs:19:68
+   |
+LL | async unsafe extern "cmse-nonsecure-entry" fn async_and_c_variadic(_: ...) {
+   |              -----------------------------                         ^^^^^^
+   |              |
+   |              `extern "cmse-nonsecure-entry"` because of this
+   |
+   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs
index eb6f4a323655b..aee01e25ddc4f 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs
@@ -1,7 +1,7 @@
 //@ add-core-stubs
 //@ compile-flags: --target thumbv8m.main-none-eabi --crate-type lib
 //@ needs-llvm-components: arm
-#![feature(cmse_nonsecure_entry, c_variadic, no_core, lang_items)]
+#![feature(cmse_nonsecure_entry, no_core, lang_items)]
 #![no_core]
 
 extern crate minicore;
@@ -65,8 +65,3 @@ extern "cmse-nonsecure-entry" fn wrapped_trait_object(x: WrapperTransparent) ->
     //~^ ERROR return value of `"cmse-nonsecure-entry"` function too large to pass via registers [E0798]
     x
 }
-
-unsafe extern "cmse-nonsecure-entry" fn c_variadic(_: u32, _: ...) {
-    //~^ ERROR `...` is not supported for `extern "cmse-nonsecure-entry"` functions
-    //~| ERROR requires `va_list` lang_item
-}
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr
index 8937def9428cf..df1a910704378 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr
@@ -1,13 +1,3 @@
-error: `...` is not supported for `extern "cmse-nonsecure-entry"` functions
-  --> $DIR/generics.rs:69:60
-   |
-LL | unsafe extern "cmse-nonsecure-entry" fn c_variadic(_: u32, _: ...) {
-   |        -----------------------------                       ^^^^^^
-   |        |
-   |        `extern "cmse-nonsecure-entry"` because of this
-   |
-   = help: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
-
 error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
   --> $DIR/generics.rs:30:1
    |
@@ -71,12 +61,6 @@ LL | extern "cmse-nonsecure-entry" fn wrapped_trait_object(x: WrapperTransparent
    = note: functions with the `"cmse-nonsecure-entry"` ABI must pass their result via the available return registers
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
-error: requires `va_list` lang_item
-  --> $DIR/generics.rs:69:60
-   |
-LL | unsafe extern "cmse-nonsecure-entry" fn c_variadic(_: u32, _: ...) {
-   |                                                            ^^^^^^
-
-error: aborting due to 9 previous errors
+error: aborting due to 7 previous errors
 
 For more information about this error, try `rustc --explain E0798`.

From 593a9c98aef3819f727f2fc9fa8abe58ea784d07 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Tue, 9 Sep 2025 22:45:29 +0200
Subject: [PATCH 0987/1889] fix(collapsible{,_else}_if): respect `#[expect]` on
 inner `if`

---
 clippy_lints/src/collapsible_if.rs            | 73 +++++++++++++------
 clippy_utils/src/sym.rs                       |  2 +
 .../collapsible_if/collapsible_else_if.fixed  | 19 ++++-
 .../collapsible_if/collapsible_else_if.rs     | 19 ++++-
 tests/ui/collapsible_else_if.fixed            | 27 +++++++
 tests/ui/collapsible_else_if.rs               | 27 +++++++
 tests/ui/collapsible_else_if.stderr           |  2 +-
 tests/ui/collapsible_else_if_unfixable.rs     | 22 ++++++
 tests/ui/collapsible_else_if_unfixable.stderr | 17 +++++
 tests/ui/collapsible_if.fixed                 | 18 +++++
 tests/ui/collapsible_if.rs                    | 18 +++++
 tests/ui/collapsible_if.stderr                |  2 +-
 tests/ui/collapsible_if_unfixable.rs          | 20 +++++
 tests/ui/collapsible_if_unfixable.stderr      | 17 +++++
 14 files changed, 256 insertions(+), 27 deletions(-)
 create mode 100644 tests/ui/collapsible_else_if_unfixable.rs
 create mode 100644 tests/ui/collapsible_else_if_unfixable.stderr
 create mode 100644 tests/ui/collapsible_if_unfixable.rs
 create mode 100644 tests/ui/collapsible_if_unfixable.stderr

diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index ad610fbd8d2c3..b239c20ab4d89 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -1,16 +1,16 @@
 use clippy_config::Conf;
-use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::{IntoSpan as _, SpanRangeExt, snippet, snippet_block_with_applicability};
-use clippy_utils::{span_contains_non_whitespace, tokenize_with_text};
-use rustc_ast::BinOpKind;
+use clippy_utils::{span_contains_non_whitespace, sym, tokenize_with_text};
+use rustc_ast::{BinOpKind, MetaItemInner};
 use rustc_errors::Applicability;
 use rustc_hir::{Block, Expr, ExprKind, StmtKind};
 use rustc_lexer::TokenKind;
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, Level};
 use rustc_session::impl_lint_pass;
 use rustc_span::source_map::SourceMap;
-use rustc_span::{BytePos, Span};
+use rustc_span::{BytePos, Span, Symbol};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -95,14 +95,14 @@ impl CollapsibleIf {
 
     fn check_collapsible_else_if(&self, cx: &LateContext<'_>, then_span: Span, else_block: &Block<'_>) {
         if let Some(else_) = expr_block(else_block)
-            && cx.tcx.hir_attrs(else_.hir_id).is_empty()
             && !else_.span.from_expansion()
             && let ExprKind::If(else_if_cond, ..) = else_.kind
-            && !block_starts_with_significant_tokens(cx, else_block, else_, self.lint_commented_code)
+            && self.check_significant_tokens_and_expect_attrs(cx, else_block, else_, sym::collapsible_else_if)
         {
-            span_lint_and_then(
+            span_lint_hir_and_then(
                 cx,
                 COLLAPSIBLE_ELSE_IF,
+                else_.hir_id,
                 else_block.span,
                 "this `else { if .. }` block can be collapsed",
                 |diag| {
@@ -166,15 +166,15 @@ impl CollapsibleIf {
 
     fn check_collapsible_if_if(&self, cx: &LateContext<'_>, expr: &Expr<'_>, check: &Expr<'_>, then: &Block<'_>) {
         if let Some(inner) = expr_block(then)
-            && cx.tcx.hir_attrs(inner.hir_id).is_empty()
             && let ExprKind::If(check_inner, _, None) = &inner.kind
             && self.eligible_condition(cx, check_inner)
             && expr.span.eq_ctxt(inner.span)
-            && !block_starts_with_significant_tokens(cx, then, inner, self.lint_commented_code)
+            && self.check_significant_tokens_and_expect_attrs(cx, then, inner, sym::collapsible_if)
         {
-            span_lint_and_then(
+            span_lint_hir_and_then(
                 cx,
                 COLLAPSIBLE_IF,
+                inner.hir_id,
                 expr.span,
                 "this `if` statement can be collapsed",
                 |diag| {
@@ -219,6 +219,45 @@ impl CollapsibleIf {
         !matches!(cond.kind, ExprKind::Let(..))
             || (cx.tcx.sess.edition().at_least_rust_2024() && self.msrv.meets(cx, msrvs::LET_CHAINS))
     }
+
+    // Check that nothing significant can be found between the initial `{` of `inner_if` and
+    // the beginning of `inner_if_expr`...
+    //
+    // Unless it's only an `#[expect(clippy::collapsible{,_else}_if)]` attribute, in which case we
+    // _do_ need to lint, in order to actually fulfill its expectation (#13365)
+    fn check_significant_tokens_and_expect_attrs(
+        &self,
+        cx: &LateContext<'_>,
+        inner_if: &Block<'_>,
+        inner_if_expr: &Expr<'_>,
+        expected_lint_name: Symbol,
+    ) -> bool {
+        match cx.tcx.hir_attrs(inner_if_expr.hir_id) {
+            [] => {
+                // There aren't any attributes, so just check for significant tokens
+                let span = inner_if.span.split_at(1).1.until(inner_if_expr.span);
+                !span_contains_non_whitespace(cx, span, self.lint_commented_code)
+            },
+
+            [attr]
+                if matches!(Level::from_attr(attr), Some((Level::Expect, _)))
+                    && let Some(metas) = attr.meta_item_list()
+                    && let Some(MetaItemInner::MetaItem(meta_item)) = metas.first()
+                    && let [tool, lint_name] = meta_item.path.segments.as_slice()
+                    && tool.ident.name == sym::clippy
+                    && [expected_lint_name, sym::style, sym::all].contains(&lint_name.ident.name) =>
+            {
+                // There is an `expect` attribute -- check that there is no _other_ significant text
+                let span_before_attr = inner_if.span.split_at(1).1.until(attr.span());
+                let span_after_attr = attr.span().between(inner_if_expr.span);
+                !span_contains_non_whitespace(cx, span_before_attr, self.lint_commented_code)
+                    && !span_contains_non_whitespace(cx, span_after_attr, self.lint_commented_code)
+            },
+
+            // There are other attributes, which are significant tokens -- check failed
+            _ => false,
+        }
+    }
 }
 
 impl_lint_pass!(CollapsibleIf => [COLLAPSIBLE_IF, COLLAPSIBLE_ELSE_IF]);
@@ -242,18 +281,6 @@ impl LateLintPass<'_> for CollapsibleIf {
     }
 }
 
-// Check that nothing significant can be found but whitespaces between the initial `{` of `block`
-// and the beginning of `stop_at`.
-fn block_starts_with_significant_tokens(
-    cx: &LateContext<'_>,
-    block: &Block<'_>,
-    stop_at: &Expr<'_>,
-    lint_commented_code: bool,
-) -> bool {
-    let span = block.span.split_at(1).1.until(stop_at.span);
-    span_contains_non_whitespace(cx, span, lint_commented_code)
-}
-
 /// If `block` is a block with either one expression or a statement containing an expression,
 /// return the expression. We don't peel blocks recursively, as extra blocks might be intentional.
 fn expr_block<'tcx>(block: &Block<'tcx>) -> Option<&'tcx Expr<'tcx>> {
diff --git a/clippy_utils/src/sym.rs b/clippy_utils/src/sym.rs
index 278101ac27f96..463711195bb0c 100644
--- a/clippy_utils/src/sym.rs
+++ b/clippy_utils/src/sym.rs
@@ -111,6 +111,8 @@ generate! {
     clone_into,
     cloned,
     cognitive_complexity,
+    collapsible_else_if,
+    collapsible_if,
     collect,
     const_ptr,
     contains,
diff --git a/tests/ui-toml/collapsible_if/collapsible_else_if.fixed b/tests/ui-toml/collapsible_if/collapsible_else_if.fixed
index 0dc0fc230c8de..ec45dfd2033ad 100644
--- a/tests/ui-toml/collapsible_if/collapsible_else_if.fixed
+++ b/tests/ui-toml/collapsible_if/collapsible_else_if.fixed
@@ -1,7 +1,7 @@
 #![allow(clippy::eq_op, clippy::nonminimal_bool)]
+#![warn(clippy::collapsible_if)]
 
 #[rustfmt::skip]
-#[warn(clippy::collapsible_if)]
 fn main() {
     let (x, y) = ("hello", "world");
 
@@ -48,3 +48,20 @@ fn main() {
         }
     //~^^^^^^ collapsible_else_if
 }
+
+fn issue_13365() {
+    // the comments don't stop us from linting, so the the `expect` *will* be fulfilled
+    if true {
+    } else {
+        // some other text before
+        #[expect(clippy::collapsible_else_if)]
+        if false {}
+    }
+
+    if true {
+    } else {
+        #[expect(clippy::collapsible_else_if)]
+        // some other text after
+        if false {}
+    }
+}
diff --git a/tests/ui-toml/collapsible_if/collapsible_else_if.rs b/tests/ui-toml/collapsible_if/collapsible_else_if.rs
index 8344c122f16c8..54315a3c32bf9 100644
--- a/tests/ui-toml/collapsible_if/collapsible_else_if.rs
+++ b/tests/ui-toml/collapsible_if/collapsible_else_if.rs
@@ -1,7 +1,7 @@
 #![allow(clippy::eq_op, clippy::nonminimal_bool)]
+#![warn(clippy::collapsible_if)]
 
 #[rustfmt::skip]
-#[warn(clippy::collapsible_if)]
 fn main() {
     let (x, y) = ("hello", "world");
 
@@ -53,3 +53,20 @@ fn main() {
     }
     //~^^^^^^ collapsible_else_if
 }
+
+fn issue_13365() {
+    // the comments don't stop us from linting, so the the `expect` *will* be fulfilled
+    if true {
+    } else {
+        // some other text before
+        #[expect(clippy::collapsible_else_if)]
+        if false {}
+    }
+
+    if true {
+    } else {
+        #[expect(clippy::collapsible_else_if)]
+        // some other text after
+        if false {}
+    }
+}
diff --git a/tests/ui/collapsible_else_if.fixed b/tests/ui/collapsible_else_if.fixed
index 3d709fe9b8e0e..da958f76a5ca0 100644
--- a/tests/ui/collapsible_else_if.fixed
+++ b/tests/ui/collapsible_else_if.fixed
@@ -87,6 +87,33 @@ fn issue_7318() {
     //~^^^ collapsible_else_if
 }
 
+fn issue_13365() {
+    // all the `expect`s that we should fulfill
+    if true {
+    } else {
+        #[expect(clippy::collapsible_else_if)]
+        if false {}
+    }
+
+    if true {
+    } else {
+        #[expect(clippy::style)]
+        if false {}
+    }
+
+    if true {
+    } else {
+        #[expect(clippy::all)]
+        if false {}
+    }
+
+    if true {
+    } else {
+        #[expect(warnings)]
+        if false {}
+    }
+}
+
 fn issue14799() {
     use std::ops::ControlFlow;
 
diff --git a/tests/ui/collapsible_else_if.rs b/tests/ui/collapsible_else_if.rs
index 51868e039086f..06af49f2f6f3b 100644
--- a/tests/ui/collapsible_else_if.rs
+++ b/tests/ui/collapsible_else_if.rs
@@ -103,6 +103,33 @@ fn issue_7318() {
     //~^^^ collapsible_else_if
 }
 
+fn issue_13365() {
+    // all the `expect`s that we should fulfill
+    if true {
+    } else {
+        #[expect(clippy::collapsible_else_if)]
+        if false {}
+    }
+
+    if true {
+    } else {
+        #[expect(clippy::style)]
+        if false {}
+    }
+
+    if true {
+    } else {
+        #[expect(clippy::all)]
+        if false {}
+    }
+
+    if true {
+    } else {
+        #[expect(warnings)]
+        if false {}
+    }
+}
+
 fn issue14799() {
     use std::ops::ControlFlow;
 
diff --git a/tests/ui/collapsible_else_if.stderr b/tests/ui/collapsible_else_if.stderr
index 1a7bcec7fd5df..ce1da593a8e93 100644
--- a/tests/ui/collapsible_else_if.stderr
+++ b/tests/ui/collapsible_else_if.stderr
@@ -151,7 +151,7 @@ LL | |     }
    | |_____^ help: collapse nested if block: `if false {}`
 
 error: this `else { if .. }` block can be collapsed
-  --> tests/ui/collapsible_else_if.rs:130:12
+  --> tests/ui/collapsible_else_if.rs:157:12
    |
 LL |       } else {
    |  ____________^
diff --git a/tests/ui/collapsible_else_if_unfixable.rs b/tests/ui/collapsible_else_if_unfixable.rs
new file mode 100644
index 0000000000000..e5c18cf3ba901
--- /dev/null
+++ b/tests/ui/collapsible_else_if_unfixable.rs
@@ -0,0 +1,22 @@
+//@no-rustfix
+#![warn(clippy::collapsible_else_if)]
+
+fn issue_13365() {
+    // in the following examples, we won't lint because of the comments,
+    // so the the `expect` will be unfulfilled
+    if true {
+    } else {
+        // some other text before
+        #[expect(clippy::collapsible_else_if)]
+        if false {}
+    }
+    //~^^^ ERROR: this lint expectation is unfulfilled
+
+    if true {
+    } else {
+        #[expect(clippy::collapsible_else_if)]
+        // some other text after
+        if false {}
+    }
+    //~^^^^ ERROR: this lint expectation is unfulfilled
+}
diff --git a/tests/ui/collapsible_else_if_unfixable.stderr b/tests/ui/collapsible_else_if_unfixable.stderr
new file mode 100644
index 0000000000000..b461ceba6de7f
--- /dev/null
+++ b/tests/ui/collapsible_else_if_unfixable.stderr
@@ -0,0 +1,17 @@
+error: this lint expectation is unfulfilled
+  --> tests/ui/collapsible_else_if_unfixable.rs:10:18
+   |
+LL |         #[expect(clippy::collapsible_else_if)]
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D unfulfilled-lint-expectations` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(unfulfilled_lint_expectations)]`
+
+error: this lint expectation is unfulfilled
+  --> tests/ui/collapsible_else_if_unfixable.rs:17:18
+   |
+LL |         #[expect(clippy::collapsible_else_if)]
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/collapsible_if.fixed b/tests/ui/collapsible_if.fixed
index 78354c2d7cf88..ca9d02ff2d4f8 100644
--- a/tests/ui/collapsible_if.fixed
+++ b/tests/ui/collapsible_if.fixed
@@ -144,6 +144,24 @@ fn layout_check() -> u32 {
     //~^^^^^ collapsible_if
 }
 
+fn issue13365() {
+    // all the `expect`s that we should fulfill
+    if true {
+        #[expect(clippy::collapsible_if)]
+        if true {}
+    }
+
+    if true {
+        #[expect(clippy::style)]
+        if true {}
+    }
+
+    if true {
+        #[expect(clippy::all)]
+        if true {}
+    }
+}
+
 fn issue14722() {
     let x = if true {
         Some(1)
diff --git a/tests/ui/collapsible_if.rs b/tests/ui/collapsible_if.rs
index 5d9afa109569d..9ac68ecd4cac0 100644
--- a/tests/ui/collapsible_if.rs
+++ b/tests/ui/collapsible_if.rs
@@ -154,6 +154,24 @@ fn layout_check() -> u32 {
     //~^^^^^ collapsible_if
 }
 
+fn issue13365() {
+    // all the `expect`s that we should fulfill
+    if true {
+        #[expect(clippy::collapsible_if)]
+        if true {}
+    }
+
+    if true {
+        #[expect(clippy::style)]
+        if true {}
+    }
+
+    if true {
+        #[expect(clippy::all)]
+        if true {}
+    }
+}
+
 fn issue14722() {
     let x = if true {
         Some(1)
diff --git a/tests/ui/collapsible_if.stderr b/tests/ui/collapsible_if.stderr
index a685cc2e9291d..b1f26630f529b 100644
--- a/tests/ui/collapsible_if.stderr
+++ b/tests/ui/collapsible_if.stderr
@@ -191,7 +191,7 @@ LL ~     ; 3
    |
 
 error: this `if` statement can be collapsed
-  --> tests/ui/collapsible_if.rs:178:5
+  --> tests/ui/collapsible_if.rs:196:5
    |
 LL | /     if true {
 LL | |         (if true {
diff --git a/tests/ui/collapsible_if_unfixable.rs b/tests/ui/collapsible_if_unfixable.rs
new file mode 100644
index 0000000000000..643520ac0f5d9
--- /dev/null
+++ b/tests/ui/collapsible_if_unfixable.rs
@@ -0,0 +1,20 @@
+//@ no-rustfix
+#![warn(clippy::collapsible_if)]
+
+fn issue13365() {
+    // in the following examples, we won't lint because of the comments,
+    // so the the `expect` will be unfulfilled
+    if true {
+        // don't collapsible because of this comment
+        #[expect(clippy::collapsible_if)]
+        if true {}
+    }
+    //~^^^ ERROR: this lint expectation is unfulfilled
+
+    if true {
+        #[expect(clippy::collapsible_if)]
+        // don't collapsible because of this comment
+        if true {}
+    }
+    //~^^^^ ERROR: this lint expectation is unfulfilled
+}
diff --git a/tests/ui/collapsible_if_unfixable.stderr b/tests/ui/collapsible_if_unfixable.stderr
new file mode 100644
index 0000000000000..64c8fb8da2b44
--- /dev/null
+++ b/tests/ui/collapsible_if_unfixable.stderr
@@ -0,0 +1,17 @@
+error: this lint expectation is unfulfilled
+  --> tests/ui/collapsible_if_unfixable.rs:9:18
+   |
+LL |         #[expect(clippy::collapsible_if)]
+   |                  ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D unfulfilled-lint-expectations` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(unfulfilled_lint_expectations)]`
+
+error: this lint expectation is unfulfilled
+  --> tests/ui/collapsible_if_unfixable.rs:15:18
+   |
+LL |         #[expect(clippy::collapsible_if)]
+   |                  ^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+

From d23909d4d8aa2431df5ebc2fdeb2d967cd3c286d Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 16 Sep 2025 08:48:30 +0200
Subject: [PATCH 0988/1889] rustup

---
 src/tools/miri/rust-version           | 2 +-
 src/tools/miri/tests/pass/shims/fs.rs | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/tools/miri/rust-version b/src/tools/miri/rust-version
index 8315eb30f9431..f27677cd50388 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-a015919e54c60b1b2bec7a98dec478cfc4a48f4e
+9d82de19dfae60e55c291f5f28e28cfc2c1b9630
diff --git a/src/tools/miri/tests/pass/shims/fs.rs b/src/tools/miri/tests/pass/shims/fs.rs
index 022dcc5dcbafa..0748007b3c058 100644
--- a/src/tools/miri/tests/pass/shims/fs.rs
+++ b/src/tools/miri/tests/pass/shims/fs.rs
@@ -28,7 +28,8 @@ fn main() {
     test_from_raw_os_error();
     test_file_clone();
     // Windows file handling is very incomplete.
-    if cfg!(not(windows)) {
+    // FIXME: read_dir broken on FreeBSD (https://github.com/rust-lang/miri/issues/4587)
+    if cfg!(not(windows)) && !cfg!(target_os = "freebsd") {
         test_file_set_len();
         test_file_sync();
         test_rename();

From 929c9335ddcaf8e59f5b56c986fd58a3310fdac0 Mon Sep 17 00:00:00 2001
From: Haidong Zhang <zhanghaidong@uniontech.com>
Date: Tue, 9 Sep 2025 18:10:24 +0800
Subject: [PATCH 0989/1889] Add parallel-frontend-threads to bootstrap.toml and
 enable multi-threaded parallel compilation

---
 bootstrap.example.toml                     | 8 ++++++++
 src/bootstrap/configure.py                 | 5 +++++
 src/bootstrap/src/core/builder/cargo.rs    | 6 ++++++
 src/bootstrap/src/core/config/config.rs    | 5 ++++-
 src/bootstrap/src/core/config/toml/rust.rs | 2 ++
 src/bootstrap/src/utils/change_tracker.rs  | 5 +++++
 6 files changed, 30 insertions(+), 1 deletion(-)

diff --git a/bootstrap.example.toml b/bootstrap.example.toml
index eac9395779798..51529751dd58f 100644
--- a/bootstrap.example.toml
+++ b/bootstrap.example.toml
@@ -859,6 +859,14 @@
 # Trigger a `DebugBreak` after an internal compiler error during bootstrap on Windows
 #rust.break-on-ice = true
 
+# Set the number of threads for the compiler frontend used during compilation of Rust code (passed to `-Zthreads`).
+# The valid options are:
+# 0 - Set the number of threads according to the detected number of threads of the host system
+# 1 - Use a single thread for compilation of Rust code (the default)
+# N - Number of threads used for compilation of Rust code
+#
+#rust.parallel-frontend-threads = 1
+
 # =============================================================================
 # Distribution options
 #
diff --git a/src/bootstrap/configure.py b/src/bootstrap/configure.py
index b05a5cc8b818c..1915986be28c5 100755
--- a/src/bootstrap/configure.py
+++ b/src/bootstrap/configure.py
@@ -340,6 +340,11 @@ def v(*args):
     "don't truncate options when printing them in this configure script",
 )
 v("set", None, "set arbitrary key/value pairs in TOML configuration")
+v(
+    "parallel-frontend-threads",
+    "rust.parallel-frontend-threads",
+    "number of parallel threads for rustc compilation",
+)
 
 
 def p(msg):
diff --git a/src/bootstrap/src/core/builder/cargo.rs b/src/bootstrap/src/core/builder/cargo.rs
index 924bb4adb42d0..7c24378f0bb5c 100644
--- a/src/bootstrap/src/core/builder/cargo.rs
+++ b/src/bootstrap/src/core/builder/cargo.rs
@@ -679,6 +679,12 @@ impl Builder<'_> {
         // cargo would implicitly add it, it was discover that sometimes bootstrap only use
         // `rustflags` without `cargo` making it required.
         rustflags.arg("-Zunstable-options");
+
+        // Add parallel frontend threads configuration
+        if let Some(threads) = self.config.rust_parallel_frontend_threads {
+            rustflags.arg(&format!("-Zthreads={threads}"));
+        }
+
         for (restricted_mode, name, values) in EXTRA_CHECK_CFGS {
             if restricted_mode.is_none() || *restricted_mode == Some(mode) {
                 rustflags.arg(&check_cfg_arg(name, *values));
diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index 678a9b6395228..585bf5f870cbb 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -191,7 +191,6 @@ pub struct Config {
     pub rust_optimize: RustOptimize,
     pub rust_codegen_units: Option<u32>,
     pub rust_codegen_units_std: Option<u32>,
-
     pub rustc_debug_assertions: bool,
     pub std_debug_assertions: bool,
     pub tools_debug_assertions: bool,
@@ -222,6 +221,8 @@ pub struct Config {
     pub rust_validate_mir_opts: Option<u32>,
     pub rust_std_features: BTreeSet<String>,
     pub rust_break_on_ice: bool,
+    pub rust_parallel_frontend_threads: Option<u32>,
+
     pub llvm_profile_use: Option<String>,
     pub llvm_profile_generate: bool,
     pub llvm_libunwind_default: Option<LlvmLibunwind>,
@@ -534,6 +535,7 @@ impl Config {
             backtrace_on_ice: rust_backtrace_on_ice,
             verify_llvm_ir: rust_verify_llvm_ir,
             thin_lto_import_instr_limit: rust_thin_lto_import_instr_limit,
+            parallel_frontend_threads: rust_parallel_frontend_threads,
             remap_debuginfo: rust_remap_debuginfo,
             jemalloc: rust_jemalloc,
             test_compare_mode: rust_test_compare_mode,
@@ -1298,6 +1300,7 @@ impl Config {
             rust_overflow_checks_std: rust_overflow_checks_std
                 .or(rust_overflow_checks)
                 .unwrap_or(rust_debug == Some(true)),
+            rust_parallel_frontend_threads: rust_parallel_frontend_threads.map(threads_from_config),
             rust_profile_generate: flags_rust_profile_generate.or(rust_profile_generate),
             rust_profile_use: flags_rust_profile_use.or(rust_profile_use),
             rust_randomize_layout: rust_randomize_layout.unwrap_or(false),
diff --git a/src/bootstrap/src/core/config/toml/rust.rs b/src/bootstrap/src/core/config/toml/rust.rs
index 4832a1d37b777..e5987d7040aaf 100644
--- a/src/bootstrap/src/core/config/toml/rust.rs
+++ b/src/bootstrap/src/core/config/toml/rust.rs
@@ -66,6 +66,7 @@ define_config! {
         validate_mir_opts: Option<u32> = "validate-mir-opts",
         std_features: Option<BTreeSet<String>> = "std-features",
         break_on_ice: Option<bool> = "break-on-ice",
+        parallel_frontend_threads: Option<u32> = "parallel-frontend-threads",
     }
 }
 
@@ -357,6 +358,7 @@ pub fn check_incompatible_options_for_ci_rustc(
         validate_mir_opts: _,
         frame_pointers: _,
         break_on_ice: _,
+        parallel_frontend_threads: _,
     } = ci_rust_config;
 
     // There are two kinds of checks for CI rustc incompatible options:
diff --git a/src/bootstrap/src/utils/change_tracker.rs b/src/bootstrap/src/utils/change_tracker.rs
index 03b39882e30af..2c48cebd2df05 100644
--- a/src/bootstrap/src/utils/change_tracker.rs
+++ b/src/bootstrap/src/utils/change_tracker.rs
@@ -546,4 +546,9 @@ pub const CONFIG_CHANGE_HISTORY: &[ChangeInfo] = &[
         severity: ChangeSeverity::Info,
         summary: "The default value of the `gcc.download-ci-gcc` option has been changed to `true`.",
     },
+    ChangeInfo {
+        change_id: 146458,
+        severity: ChangeSeverity::Info,
+        summary: "There is now a bootstrap option called `rust.parallel-frontend-threads`, which can be used to set the number of threads for the compiler frontend used during compilation of Rust code.",
+    },
 ];

From c89b6a955c9e16c7c96714cea7945945caadcc79 Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Wed, 10 Sep 2025 12:40:29 +0000
Subject: [PATCH 0990/1889] Iterator repeat: no infinite loop for `last` and
 `count`

---
 library/core/src/iter/sources/repeat.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/library/core/src/iter/sources/repeat.rs b/library/core/src/iter/sources/repeat.rs
index c4f5a483e5c2a..4bcd5b16aea6a 100644
--- a/library/core/src/iter/sources/repeat.rs
+++ b/library/core/src/iter/sources/repeat.rs
@@ -9,7 +9,7 @@ use crate::num::NonZero;
 /// [`Iterator::take()`], in order to make them finite.
 ///
 /// Use [`str::repeat()`] instead of this function if you just want to repeat
-/// a char/string `n`th times.
+/// a char/string `n` times.
 ///
 /// If the element type of the iterator you need does not implement `Clone`,
 /// or if you do not want to keep the repeated element in memory, you can
@@ -98,11 +98,12 @@ impl<A: Clone> Iterator for Repeat<A> {
     }
 
     fn last(self) -> Option<A> {
-        loop {}
+        Some(self.element)
     }
 
+    #[track_caller]
     fn count(self) -> usize {
-        loop {}
+        panic!("iterator is infinite");
     }
 }
 

From 1ae720a52dd6a3ed5a375d183aea5330de49eb42 Mon Sep 17 00:00:00 2001
From: Joe Birr-Pixton <jpixton@gmail.com>
Date: Tue, 16 Sep 2025 11:51:19 +0100
Subject: [PATCH 0991/1889] Fix spelling of "adaptor"

These docs are in en_US, so "adapter" is the correct spelling
(and indeed used in the next line.)
---
 library/std/src/io/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/std/src/io/mod.rs b/library/std/src/io/mod.rs
index ff0e29e04c251..a45edd08e8ccc 100644
--- a/library/std/src/io/mod.rs
+++ b/library/std/src/io/mod.rs
@@ -1081,7 +1081,7 @@ pub trait Read {
         default_read_buf_exact(self, cursor)
     }
 
-    /// Creates a "by reference" adaptor for this instance of `Read`.
+    /// Creates a "by reference" adapter for this instance of `Read`.
     ///
     /// The returned adapter also implements `Read` and will simply borrow this
     /// current reader.

From 325ceef018030f922840a10741d194b4223ecc59 Mon Sep 17 00:00:00 2001
From: Joe Birr-Pixton <jpixton@gmail.com>
Date: Tue, 16 Sep 2025 11:52:43 +0100
Subject: [PATCH 0992/1889] Fix other uses of "adaptor"

---
 library/core/src/iter/adapters/flatten.rs                       | 2 +-
 tests/ui/iterators/issue-58952-filter-type-length.rs            | 2 +-
 .../traits/next-solver/typeck/normalize-in-upvar-collection.rs  | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/library/core/src/iter/adapters/flatten.rs b/library/core/src/iter/adapters/flatten.rs
index a820045521b9f..c50f07ff6bb66 100644
--- a/library/core/src/iter/adapters/flatten.rs
+++ b/library/core/src/iter/adapters/flatten.rs
@@ -779,7 +779,7 @@ impl<T> OneShot for result::IterMut<'_, T> {}
 impl<T> OneShot for Empty<T> {}
 impl<T> OneShot for array::IntoIter<T, 0> {}
 
-// These adaptors never increase the number of items.
+// These adapters never increase the number of items.
 // (There are more possible, but for now this matches BoundedSize above.)
 impl<I: OneShot> OneShot for Cloned<I> {}
 impl<I: OneShot> OneShot for Copied<I> {}
diff --git a/tests/ui/iterators/issue-58952-filter-type-length.rs b/tests/ui/iterators/issue-58952-filter-type-length.rs
index 6730865b6c7f7..525a2e39a913c 100644
--- a/tests/ui/iterators/issue-58952-filter-type-length.rs
+++ b/tests/ui/iterators/issue-58952-filter-type-length.rs
@@ -2,7 +2,7 @@
 
 //! This snippet causes the type length to blowup exponentially,
 //! so check that we don't accidentally exceed the type length limit.
-// FIXME: Once the size of iterator adaptors is further reduced,
+// FIXME: Once the size of iterator adapters is further reduced,
 // increase the complexity of this test.
 use std::collections::VecDeque;
 
diff --git a/tests/ui/traits/next-solver/typeck/normalize-in-upvar-collection.rs b/tests/ui/traits/next-solver/typeck/normalize-in-upvar-collection.rs
index 6567f2752404a..2f108daf1e5ab 100644
--- a/tests/ui/traits/next-solver/typeck/normalize-in-upvar-collection.rs
+++ b/tests/ui/traits/next-solver/typeck/normalize-in-upvar-collection.rs
@@ -1,7 +1,7 @@
 //@ compile-flags: -Znext-solver
 //@ check-pass
 
-// Fixes a regression in icu_provider_adaptors where we weren't normalizing the
+// Fixes a regression in icu_provider_adapters where we weren't normalizing the
 // return type of a function type before performing a `Ty::builtin_deref` call,
 // leading to an ICE.
 

From 9991ec282f3ff08c895e4a5262259139fe689953 Mon Sep 17 00:00:00 2001
From: Mu001999 <mu001999@outlook.com>
Date: Sun, 9 Mar 2025 18:25:57 +0800
Subject: [PATCH 0993/1889] Keep space if expr follows identifier when lint
 unused parens

---
 compiler/rustc_lint/src/unused.rs             |  8 +++++
 .../ui/lint/unused_parens_follow_ident.fixed  | 17 ++++++++++
 tests/ui/lint/unused_parens_follow_ident.rs   | 17 ++++++++++
 .../ui/lint/unused_parens_follow_ident.stderr | 31 +++++++++++++++++++
 4 files changed, 73 insertions(+)
 create mode 100644 tests/ui/lint/unused_parens_follow_ident.fixed
 create mode 100644 tests/ui/lint/unused_parens_follow_ident.rs
 create mode 100644 tests/ui/lint/unused_parens_follow_ident.stderr

diff --git a/compiler/rustc_lint/src/unused.rs b/compiler/rustc_lint/src/unused.rs
index 22d89d2461273..edbbfba4f3461 100644
--- a/compiler/rustc_lint/src/unused.rs
+++ b/compiler/rustc_lint/src/unused.rs
@@ -843,6 +843,10 @@ trait UnusedDelimLint {
                 && !snip.ends_with(' ')
             {
                 " "
+            } else if let Ok(snip) = sm.span_to_prev_source(value_span)
+                && snip.ends_with(|c: char| c.is_alphanumeric())
+            {
+                " "
             } else {
                 ""
             };
@@ -852,6 +856,10 @@ trait UnusedDelimLint {
                 && !snip.starts_with(' ')
             {
                 " "
+            } else if let Ok(snip) = sm.span_to_prev_source(value_span)
+                && snip.starts_with(|c: char| c.is_alphanumeric())
+            {
+                " "
             } else {
                 ""
             };
diff --git a/tests/ui/lint/unused_parens_follow_ident.fixed b/tests/ui/lint/unused_parens_follow_ident.fixed
new file mode 100644
index 0000000000000..e61b287e5a648
--- /dev/null
+++ b/tests/ui/lint/unused_parens_follow_ident.fixed
@@ -0,0 +1,17 @@
+//@ run-rustfix
+
+#![deny(unused_parens)]
+
+macro_rules! wrap {
+    ($name:ident $arg:expr) => {
+        $name($arg);
+    };
+}
+
+fn main() {
+    wrap!(unary routine()); //~ ERROR unnecessary parentheses around function argument
+    wrap!(unary routine()); //~ ERROR unnecessary parentheses around function argument
+}
+
+fn unary(_: ()) {}
+fn routine() {}
diff --git a/tests/ui/lint/unused_parens_follow_ident.rs b/tests/ui/lint/unused_parens_follow_ident.rs
new file mode 100644
index 0000000000000..32a163345b2cc
--- /dev/null
+++ b/tests/ui/lint/unused_parens_follow_ident.rs
@@ -0,0 +1,17 @@
+//@ run-rustfix
+
+#![deny(unused_parens)]
+
+macro_rules! wrap {
+    ($name:ident $arg:expr) => {
+        $name($arg);
+    };
+}
+
+fn main() {
+    wrap!(unary(routine())); //~ ERROR unnecessary parentheses around function argument
+    wrap!(unary (routine())); //~ ERROR unnecessary parentheses around function argument
+}
+
+fn unary(_: ()) {}
+fn routine() {}
diff --git a/tests/ui/lint/unused_parens_follow_ident.stderr b/tests/ui/lint/unused_parens_follow_ident.stderr
new file mode 100644
index 0000000000000..ce7bb26778c0d
--- /dev/null
+++ b/tests/ui/lint/unused_parens_follow_ident.stderr
@@ -0,0 +1,31 @@
+error: unnecessary parentheses around function argument
+  --> $DIR/unused_parens_follow_ident.rs:12:16
+   |
+LL |     wrap!(unary(routine()));
+   |                ^         ^
+   |
+note: the lint level is defined here
+  --> $DIR/unused_parens_follow_ident.rs:3:9
+   |
+LL | #![deny(unused_parens)]
+   |         ^^^^^^^^^^^^^
+help: remove these parentheses
+   |
+LL -     wrap!(unary(routine()));
+LL +     wrap!(unary routine());
+   |
+
+error: unnecessary parentheses around function argument
+  --> $DIR/unused_parens_follow_ident.rs:13:17
+   |
+LL |     wrap!(unary (routine()));
+   |                 ^         ^
+   |
+help: remove these parentheses
+   |
+LL -     wrap!(unary (routine()));
+LL +     wrap!(unary routine());
+   |
+
+error: aborting due to 2 previous errors
+

From 79c9f6ee9b3229279ffdaa0515c7b0320c0b0737 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 16 Sep 2025 21:36:45 +1000
Subject: [PATCH 0994/1889] Stop using `as_c_char_ptr` for coverage-related
 bindings

---
 .../rustc_codegen_llvm/src/coverageinfo/llvm_cov.rs  |  7 +++----
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs          | 12 +++++++++---
 2 files changed, 12 insertions(+), 7 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/coverageinfo/llvm_cov.rs b/compiler/rustc_codegen_llvm/src/coverageinfo/llvm_cov.rs
index bc4f6bb6a82bc..2aa3dec813173 100644
--- a/compiler/rustc_codegen_llvm/src/coverageinfo/llvm_cov.rs
+++ b/compiler/rustc_codegen_llvm/src/coverageinfo/llvm_cov.rs
@@ -2,7 +2,6 @@
 
 use std::ffi::CString;
 
-use crate::common::AsCCharPtr;
 use crate::coverageinfo::ffi;
 use crate::llvm;
 
@@ -34,7 +33,7 @@ pub(crate) fn create_pgo_func_name_var<'ll>(
     unsafe {
         llvm::LLVMRustCoverageCreatePGOFuncNameVar(
             llfn,
-            mangled_fn_name.as_c_char_ptr(),
+            mangled_fn_name.as_ptr(),
             mangled_fn_name.len(),
         )
     }
@@ -44,7 +43,7 @@ pub(crate) fn write_filenames_to_buffer(filenames: &[impl AsRef<str>]) -> Vec<u8
     let (pointers, lengths) = filenames
         .into_iter()
         .map(AsRef::as_ref)
-        .map(|s: &str| (s.as_c_char_ptr(), s.len()))
+        .map(|s: &str| (s.as_ptr(), s.len()))
         .unzip::<_, _, Vec<_>, Vec<_>>();
 
     llvm::build_byte_buffer(|buffer| unsafe {
@@ -89,7 +88,7 @@ pub(crate) fn write_function_mappings_to_buffer(
 /// Hashes some bytes into a 64-bit hash, via LLVM's `IndexedInstrProf::ComputeHash`,
 /// as required for parts of the LLVM coverage mapping format.
 pub(crate) fn hash_bytes(bytes: &[u8]) -> u64 {
-    unsafe { llvm::LLVMRustCoverageHashBytes(bytes.as_c_char_ptr(), bytes.len()) }
+    unsafe { llvm::LLVMRustCoverageHashBytes(bytes.as_ptr(), bytes.len()) }
 }
 
 /// Returns LLVM's `coverage::CovMapVersion::CurrentVersion` (CoverageMapping.h)
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 0679f55ab7f08..52c24169f893a 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -2080,8 +2080,11 @@ unsafe extern "C" {
         ConstraintsLen: size_t,
     ) -> bool;
 
+    /// A list of pointer-length strings is passed as two pointer-length slices,
+    /// one slice containing pointers and one slice containing their corresponding
+    /// lengths. The implementation will check that both slices have the same length.
     pub(crate) fn LLVMRustCoverageWriteFilenamesToBuffer(
-        Filenames: *const *const c_char,
+        Filenames: *const *const c_uchar, // See "PTR_LEN_STR".
         FilenamesLen: size_t,
         Lengths: *const size_t,
         LengthsLen: size_t,
@@ -2104,10 +2107,13 @@ unsafe extern "C" {
 
     pub(crate) fn LLVMRustCoverageCreatePGOFuncNameVar(
         F: &Value,
-        FuncName: *const c_char,
+        FuncName: *const c_uchar, // See "PTR_LEN_STR".
         FuncNameLen: size_t,
     ) -> &Value;
-    pub(crate) fn LLVMRustCoverageHashBytes(Bytes: *const c_char, NumBytes: size_t) -> u64;
+    pub(crate) fn LLVMRustCoverageHashBytes(
+        Bytes: *const c_uchar, // See "PTR_LEN_STR".
+        NumBytes: size_t,
+    ) -> u64;
 
     pub(crate) fn LLVMRustCoverageWriteCovmapSectionNameToString(M: &Module, OutStr: &RustString);
 

From 06a7460455284aca27fbf65505c385e3dc275da3 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 16 Sep 2025 21:44:40 +1000
Subject: [PATCH 0995/1889] Mark some coverage-related bindings as safe

---
 .../src/coverageinfo/llvm_cov.rs                 |  8 ++++----
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs      | 16 ++++++++++------
 2 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/coverageinfo/llvm_cov.rs b/compiler/rustc_codegen_llvm/src/coverageinfo/llvm_cov.rs
index 2aa3dec813173..d50eb533ffdbb 100644
--- a/compiler/rustc_codegen_llvm/src/coverageinfo/llvm_cov.rs
+++ b/compiler/rustc_codegen_llvm/src/coverageinfo/llvm_cov.rs
@@ -6,21 +6,21 @@ use crate::coverageinfo::ffi;
 use crate::llvm;
 
 pub(crate) fn covmap_var_name() -> CString {
-    CString::new(llvm::build_byte_buffer(|s| unsafe {
+    CString::new(llvm::build_byte_buffer(|s| {
         llvm::LLVMRustCoverageWriteCovmapVarNameToString(s);
     }))
     .expect("covmap variable name should not contain NUL")
 }
 
 pub(crate) fn covmap_section_name(llmod: &llvm::Module) -> CString {
-    CString::new(llvm::build_byte_buffer(|s| unsafe {
+    CString::new(llvm::build_byte_buffer(|s| {
         llvm::LLVMRustCoverageWriteCovmapSectionNameToString(llmod, s);
     }))
     .expect("covmap section name should not contain NUL")
 }
 
 pub(crate) fn covfun_section_name(llmod: &llvm::Module) -> CString {
-    CString::new(llvm::build_byte_buffer(|s| unsafe {
+    CString::new(llvm::build_byte_buffer(|s| {
         llvm::LLVMRustCoverageWriteCovfunSectionNameToString(llmod, s);
     }))
     .expect("covfun section name should not contain NUL")
@@ -95,5 +95,5 @@ pub(crate) fn hash_bytes(bytes: &[u8]) -> u64 {
 /// as a raw numeric value. For historical reasons, the numeric value is 1 less
 /// than the number in the version's name, so `Version7` is actually `6u32`.
 pub(crate) fn mapping_version() -> u32 {
-    unsafe { llvm::LLVMRustCoverageMappingVersion() }
+    llvm::LLVMRustCoverageMappingVersion()
 }
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 52c24169f893a..74251cd2b4949 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -2115,13 +2115,17 @@ unsafe extern "C" {
         NumBytes: size_t,
     ) -> u64;
 
-    pub(crate) fn LLVMRustCoverageWriteCovmapSectionNameToString(M: &Module, OutStr: &RustString);
-
-    pub(crate) fn LLVMRustCoverageWriteCovfunSectionNameToString(M: &Module, OutStr: &RustString);
-
-    pub(crate) fn LLVMRustCoverageWriteCovmapVarNameToString(OutStr: &RustString);
+    pub(crate) safe fn LLVMRustCoverageWriteCovmapSectionNameToString(
+        M: &Module,
+        OutStr: &RustString,
+    );
+    pub(crate) safe fn LLVMRustCoverageWriteCovfunSectionNameToString(
+        M: &Module,
+        OutStr: &RustString,
+    );
+    pub(crate) safe fn LLVMRustCoverageWriteCovmapVarNameToString(OutStr: &RustString);
 
-    pub(crate) fn LLVMRustCoverageMappingVersion() -> u32;
+    pub(crate) safe fn LLVMRustCoverageMappingVersion() -> u32;
     pub(crate) fn LLVMRustDebugMetadataVersion() -> u32;
     pub(crate) fn LLVMRustVersionMajor() -> u32;
     pub(crate) fn LLVMRustVersionMinor() -> u32;

From 1a1510816a69844fb3611efdc53acee07a55cebb Mon Sep 17 00:00:00 2001
From: Jeremy Smart <jeremy3141592@gmail.com>
Date: Thu, 11 Sep 2025 09:13:44 -0400
Subject: [PATCH 0996/1889] handle const generics, ?Sized, early bound
 lifetimes

---
 compiler/rustc_hir_analysis/src/check/mod.rs  | 44 ++++++++++++++-----
 .../apitit-unimplemented-method.rs            |  5 ++-
 .../apitit-unimplemented-method.stderr        | 10 +++--
 tests/ui/suggestions/auxiliary/dep.rs         | 14 +++++-
 4 files changed, 56 insertions(+), 17 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/check/mod.rs b/compiler/rustc_hir_analysis/src/check/mod.rs
index 63d0f400aefc4..e70d5505aae36 100644
--- a/compiler/rustc_hir_analysis/src/check/mod.rs
+++ b/compiler/rustc_hir_analysis/src/check/mod.rs
@@ -70,6 +70,7 @@ pub mod intrinsic;
 mod region;
 pub mod wfcheck;
 
+use std::borrow::Cow;
 use std::num::NonZero;
 
 pub use check::{check_abi, check_custom_abi};
@@ -86,7 +87,7 @@ use rustc_middle::query::Providers;
 use rustc_middle::ty::error::{ExpectedFound, TypeError};
 use rustc_middle::ty::print::with_types_for_signature;
 use rustc_middle::ty::{
-    self, GenericArgs, GenericArgsRef, GenericParamDefKind, Ty, TyCtxt, TypingMode,
+    self, GenericArgs, GenericArgsRef, OutlivesPredicate, Region, Ty, TyCtxt, TypingMode,
 };
 use rustc_middle::{bug, span_bug};
 use rustc_session::parse::feature_err;
@@ -335,6 +336,7 @@ fn bounds_from_generic_predicates<'tcx>(
     assoc: ty::AssocItem,
 ) -> (String, String) {
     let mut types: FxIndexMap<Ty<'tcx>, Vec<DefId>> = FxIndexMap::default();
+    let mut regions: FxIndexMap<Region<'tcx>, Vec<Region<'tcx>>> = FxIndexMap::default();
     let mut projections = vec![];
     for (predicate, _) in predicates {
         debug!("predicate {:?}", predicate);
@@ -351,20 +353,23 @@ fn bounds_from_generic_predicates<'tcx>(
             ty::ClauseKind::Projection(projection_pred) => {
                 projections.push(bound_predicate.rebind(projection_pred));
             }
+            ty::ClauseKind::RegionOutlives(OutlivesPredicate(a, b)) => {
+                regions.entry(a).or_default().push(b);
+            }
             _ => {}
         }
     }
 
     let mut where_clauses = vec![];
     let generics = tcx.generics_of(assoc.def_id);
-    let types_str = generics
+    let params = generics
         .own_params
         .iter()
-        .filter(|p| matches!(p.kind, GenericParamDefKind::Type { synthetic: false, .. }))
-        .map(|p| {
-            // we just checked that it's a type, so the unwrap can't fail
-            let ty = tcx.mk_param_from_def(p).as_type().unwrap();
-            if let Some(bounds) = types.get(&ty) {
+        .filter(|p| !p.kind.is_synthetic())
+        .map(|p| match tcx.mk_param_from_def(p).kind() {
+            ty::GenericArgKind::Type(ty) => {
+                let bounds =
+                    types.get(&ty).map(Cow::Borrowed).unwrap_or_else(|| Cow::Owned(Vec::new()));
                 let mut bounds_str = vec![];
                 for bound in bounds.iter().copied() {
                     let mut projections_str = vec![];
@@ -377,7 +382,11 @@ fn bounds_from_generic_predicates<'tcx>(
                             projections_str.push(format!("{} = {}", name, p.term));
                         }
                     }
-                    let bound_def_path = tcx.def_path_str(bound);
+                    let bound_def_path = if tcx.is_lang_item(bound, LangItem::MetaSized) {
+                        String::from("?Sized")
+                    } else {
+                        tcx.def_path_str(bound)
+                    };
                     if projections_str.is_empty() {
                         where_clauses.push(format!("{}: {}", ty, bound_def_path));
                     } else {
@@ -393,8 +402,21 @@ fn bounds_from_generic_predicates<'tcx>(
                 } else {
                     format!("{}: {}", ty, bounds_str.join(" + "))
                 }
-            } else {
-                ty.to_string()
+            }
+            ty::GenericArgKind::Const(ct) => {
+                format!("const {ct}: {}", tcx.type_of(p.def_id).skip_binder())
+            }
+            ty::GenericArgKind::Lifetime(region) => {
+                if let Some(v) = regions.get(&region)
+                    && !v.is_empty()
+                {
+                    format!(
+                        "{region}: {}",
+                        v.into_iter().map(Region::to_string).collect::<Vec<_>>().join(" + ")
+                    )
+                } else {
+                    region.to_string()
+                }
             }
         })
         .collect::<Vec<_>>();
@@ -409,7 +431,7 @@ fn bounds_from_generic_predicates<'tcx>(
     }
 
     let generics =
-        if types_str.is_empty() { "".to_string() } else { format!("<{}>", types_str.join(", ")) };
+        if params.is_empty() { "".to_string() } else { format!("<{}>", params.join(", ")) };
 
     let where_clauses = if where_clauses.is_empty() {
         "".to_string()
diff --git a/tests/ui/suggestions/apitit-unimplemented-method.rs b/tests/ui/suggestions/apitit-unimplemented-method.rs
index b182e1939b3e3..c0cd709e2300a 100644
--- a/tests/ui/suggestions/apitit-unimplemented-method.rs
+++ b/tests/ui/suggestions/apitit-unimplemented-method.rs
@@ -4,9 +4,12 @@ extern crate dep;
 use dep::*;
 
 struct Local;
+
 impl Trait for Local {}
 //~^ ERROR not all trait items implemented
 //~| HELP implement the missing item: `fn foo(_: impl Sized) { todo!() }`
-//~| HELP implement the missing item: `fn bar<T>(_: impl Sized) { todo!() }`
+//~| HELP implement the missing item: `fn bar<T>(_: impl Sized) where Foo<T>: MetaSized { todo!() }`
+//~| HELP implement the missing item: `fn baz<const N: usize>() { todo!() }`
+//~| HELP implement the missing item: `fn quux<'a: 'b, 'b, T>() where T: ?Sized { todo!() }`
 
 fn main() {}
diff --git a/tests/ui/suggestions/apitit-unimplemented-method.stderr b/tests/ui/suggestions/apitit-unimplemented-method.stderr
index b309a64e95829..1f2e0ea2cad94 100644
--- a/tests/ui/suggestions/apitit-unimplemented-method.stderr
+++ b/tests/ui/suggestions/apitit-unimplemented-method.stderr
@@ -1,11 +1,13 @@
-error[E0046]: not all trait items implemented, missing: `foo`, `bar`
-  --> $DIR/apitit-unimplemented-method.rs:7:1
+error[E0046]: not all trait items implemented, missing: `foo`, `bar`, `baz`, `quux`
+  --> $DIR/apitit-unimplemented-method.rs:8:1
    |
 LL | impl Trait for Local {}
-   | ^^^^^^^^^^^^^^^^^^^^ missing `foo`, `bar` in implementation
+   | ^^^^^^^^^^^^^^^^^^^^ missing `foo`, `bar`, `baz`, `quux` in implementation
    |
    = help: implement the missing item: `fn foo(_: impl Sized) { todo!() }`
-   = help: implement the missing item: `fn bar<T>(_: impl Sized) { todo!() }`
+   = help: implement the missing item: `fn bar<T>(_: impl Sized) where Foo<T>: MetaSized { todo!() }`
+   = help: implement the missing item: `fn baz<const N: usize>() { todo!() }`
+   = help: implement the missing item: `fn quux<'a: 'b, 'b, T>() where T: ?Sized { todo!() }`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/auxiliary/dep.rs b/tests/ui/suggestions/auxiliary/dep.rs
index ac0de418313c0..c28c8b8a52f51 100644
--- a/tests/ui/suggestions/auxiliary/dep.rs
+++ b/tests/ui/suggestions/auxiliary/dep.rs
@@ -1,4 +1,16 @@
+#![feature(sized_hierarchy)]
+
+use std::marker::MetaSized;
+
+pub struct Foo<T> {
+    inner: T,
+}
+
 pub trait Trait {
     fn foo(_: impl Sized);
-    fn bar<T>(_: impl Sized);
+    fn bar<T>(_: impl Sized)
+    where
+        Foo<T>: MetaSized;
+    fn baz<'a, const N: usize>();
+    fn quux<'a: 'b, 'b, T: ?Sized>();
 }

From e652f97c6b71d485473c98bb0e5be1328db9bc45 Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Fri, 12 Sep 2025 11:10:45 -0500
Subject: [PATCH 0997/1889] Improve `core::ascii` coverage

---
 library/coretests/tests/ascii.rs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/library/coretests/tests/ascii.rs b/library/coretests/tests/ascii.rs
index ce09ee507f11f..297aa114e006d 100644
--- a/library/coretests/tests/ascii.rs
+++ b/library/coretests/tests/ascii.rs
@@ -505,3 +505,10 @@ fn test_escape_ascii_iter() {
     let _ = it.advance_back_by(4);
     assert_eq!(it.to_string(), r#"fastpath\xffremainder"#);
 }
+
+#[test]
+fn test_invalid_u8() {
+    for c in 128..=255 {
+        assert_eq!(core::ascii::Char::from_u8(c), None);
+    }
+}

From 94d3a8cb913da5823768710c0373c58bc5e1dce7 Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Fri, 12 Sep 2025 14:26:25 -0500
Subject: [PATCH 0998/1889] Improve `core::sync::atomic` coverage

---
 library/coretests/tests/atomic.rs | 244 +++++++++++++++++++++++++++++-
 1 file changed, 240 insertions(+), 4 deletions(-)

diff --git a/library/coretests/tests/atomic.rs b/library/coretests/tests/atomic.rs
index b1ab443aa6e5e..d888bd0f55a11 100644
--- a/library/coretests/tests/atomic.rs
+++ b/library/coretests/tests/atomic.rs
@@ -11,6 +11,38 @@ fn bool_() {
     assert_eq!(a.compare_exchange(false, true, SeqCst, SeqCst), Ok(false));
 }
 
+#[test]
+#[should_panic = "there is no such thing as an acquire store"]
+fn store_illegal_rt_store_acquire_ordering() {
+    let a = AtomicBool::new(false);
+    let ord = Ordering::Acquire;
+    a.store(true, ord);
+}
+
+#[test]
+#[should_panic = "there is no such thing as an acquire-release store"]
+fn store_illegal_rt_store_acq_rel_ordering() {
+    let a = AtomicBool::new(false);
+    let ord = Ordering::AcqRel;
+    a.store(true, ord);
+}
+
+#[test]
+#[should_panic = "there is no such thing as a release load"]
+fn store_illegal_rt_load_release_ordering() {
+    let a = AtomicBool::new(false);
+    let ord = Ordering::Release;
+    a.load(ord);
+}
+
+#[test]
+#[should_panic = "there is no such thing as an acquire-release load"]
+fn store_illegal_rt_load_acq_rel_ordering() {
+    let a = AtomicBool::new(false);
+    let ord = Ordering::AcqRel;
+    a.load(ord);
+}
+
 #[test]
 fn bool_and() {
     let a = AtomicBool::new(true);
@@ -283,25 +315,229 @@ fn atomic_compare_exchange() {
     static ATOMIC: AtomicIsize = AtomicIsize::new(0);
 
     ATOMIC.compare_exchange(0, 1, Relaxed, Relaxed).ok();
+    ATOMIC.compare_exchange(0, 1, Relaxed, Acquire).ok();
+    ATOMIC.compare_exchange(0, 1, Relaxed, SeqCst).ok();
     ATOMIC.compare_exchange(0, 1, Acquire, Relaxed).ok();
+    ATOMIC.compare_exchange(0, 1, Acquire, Acquire).ok();
+    ATOMIC.compare_exchange(0, 1, Acquire, SeqCst).ok();
     ATOMIC.compare_exchange(0, 1, Release, Relaxed).ok();
+    ATOMIC.compare_exchange(0, 1, Release, Acquire).ok();
+    ATOMIC.compare_exchange(0, 1, Release, SeqCst).ok();
     ATOMIC.compare_exchange(0, 1, AcqRel, Relaxed).ok();
-    ATOMIC.compare_exchange(0, 1, SeqCst, Relaxed).ok();
-    ATOMIC.compare_exchange(0, 1, Acquire, Acquire).ok();
     ATOMIC.compare_exchange(0, 1, AcqRel, Acquire).ok();
+    ATOMIC.compare_exchange(0, 1, AcqRel, SeqCst).ok();
+    ATOMIC.compare_exchange(0, 1, SeqCst, Relaxed).ok();
     ATOMIC.compare_exchange(0, 1, SeqCst, Acquire).ok();
     ATOMIC.compare_exchange(0, 1, SeqCst, SeqCst).ok();
     ATOMIC.compare_exchange_weak(0, 1, Relaxed, Relaxed).ok();
+    ATOMIC.compare_exchange_weak(0, 1, Relaxed, Acquire).ok();
+    ATOMIC.compare_exchange_weak(0, 1, Relaxed, SeqCst).ok();
     ATOMIC.compare_exchange_weak(0, 1, Acquire, Relaxed).ok();
+    ATOMIC.compare_exchange_weak(0, 1, Acquire, Acquire).ok();
+    ATOMIC.compare_exchange_weak(0, 1, Acquire, SeqCst).ok();
     ATOMIC.compare_exchange_weak(0, 1, Release, Relaxed).ok();
+    ATOMIC.compare_exchange_weak(0, 1, Release, Acquire).ok();
+    ATOMIC.compare_exchange_weak(0, 1, Release, SeqCst).ok();
     ATOMIC.compare_exchange_weak(0, 1, AcqRel, Relaxed).ok();
-    ATOMIC.compare_exchange_weak(0, 1, SeqCst, Relaxed).ok();
-    ATOMIC.compare_exchange_weak(0, 1, Acquire, Acquire).ok();
     ATOMIC.compare_exchange_weak(0, 1, AcqRel, Acquire).ok();
+    ATOMIC.compare_exchange_weak(0, 1, AcqRel, SeqCst).ok();
+    ATOMIC.compare_exchange_weak(0, 1, SeqCst, Relaxed).ok();
     ATOMIC.compare_exchange_weak(0, 1, SeqCst, Acquire).ok();
     ATOMIC.compare_exchange_weak(0, 1, SeqCst, SeqCst).ok();
 }
 
+#[test]
+#[should_panic = "there is no such thing as an acquire-release failure ordering"]
+fn atomic_compare_exchange_illegal_acq_rel() {
+    use Ordering::*;
+
+    static ATOMIC: AtomicIsize = AtomicIsize::new(0);
+
+    let failure = AcqRel;
+
+    ATOMIC.compare_exchange(0, 1, Relaxed, failure).ok();
+}
+
+#[test]
+#[should_panic = "there is no such thing as a release failure ordering"]
+fn atomic_compare_exchange_illegal_release() {
+    use Ordering::*;
+
+    static ATOMIC: AtomicIsize = AtomicIsize::new(0);
+
+    let failure = Release;
+
+    ATOMIC.compare_exchange(0, 1, Relaxed, failure).ok();
+}
+
+#[test]
+#[should_panic = "there is no such thing as an acquire-release failure ordering"]
+fn atomic_compare_exchange_weak_illegal_acq_rel() {
+    use Ordering::*;
+
+    static ATOMIC: AtomicIsize = AtomicIsize::new(0);
+
+    let failure = AcqRel;
+
+    ATOMIC.compare_exchange_weak(0, 1, Relaxed, failure).ok();
+}
+
+#[test]
+#[should_panic = "there is no such thing as a release failure ordering"]
+fn atomic_compare_exchange_weak_illegal_release() {
+    use Ordering::*;
+
+    static ATOMIC: AtomicIsize = AtomicIsize::new(0);
+
+    let failure = Release;
+
+    ATOMIC.compare_exchange_weak(0, 1, Relaxed, failure).ok();
+}
+
+#[test]
+fn atomic_swap() {
+    use Ordering::*;
+
+    static ATOMIC: AtomicBool = AtomicBool::new(false);
+
+    assert_eq!(ATOMIC.swap(true, Relaxed), false);
+    assert_eq!(ATOMIC.swap(false, Acquire), true);
+    assert_eq!(ATOMIC.swap(true, Release), false);
+    assert_eq!(ATOMIC.swap(false, AcqRel), true);
+    assert_eq!(ATOMIC.swap(true, SeqCst), false);
+}
+
+#[test]
+fn atomic_add() {
+    use Ordering::*;
+
+    static ATOMIC: AtomicU8 = AtomicU8::new(0);
+
+    assert_eq!(ATOMIC.fetch_add(1, Relaxed), 0);
+    assert_eq!(ATOMIC.fetch_add(1, Acquire), 1);
+    assert_eq!(ATOMIC.fetch_add(1, Release), 2);
+    assert_eq!(ATOMIC.fetch_add(1, AcqRel), 3);
+    assert_eq!(ATOMIC.fetch_add(1, SeqCst), 4);
+    assert_eq!(ATOMIC.load(Relaxed), 5);
+}
+
+#[test]
+fn atomic_sub() {
+    use Ordering::*;
+
+    static ATOMIC: AtomicU8 = AtomicU8::new(5);
+
+    assert_eq!(ATOMIC.fetch_sub(1, Relaxed), 5);
+    assert_eq!(ATOMIC.fetch_sub(1, Acquire), 4);
+    assert_eq!(ATOMIC.fetch_sub(1, Release), 3);
+    assert_eq!(ATOMIC.fetch_sub(1, AcqRel), 2);
+    assert_eq!(ATOMIC.fetch_sub(1, SeqCst), 1);
+    assert_eq!(ATOMIC.load(Relaxed), 0);
+}
+
+#[test]
+fn atomic_and_or() {
+    use Ordering::*;
+
+    static ATOMIC: AtomicBool = AtomicBool::new(false);
+
+    assert_eq!(ATOMIC.fetch_or(true, Relaxed), false);
+    assert_eq!(ATOMIC.fetch_and(false, Relaxed), true);
+    assert_eq!(ATOMIC.fetch_or(true, Acquire), false);
+    assert_eq!(ATOMIC.fetch_and(false, Acquire), true);
+    assert_eq!(ATOMIC.fetch_or(true, Release), false);
+    assert_eq!(ATOMIC.fetch_and(false, Release), true);
+    assert_eq!(ATOMIC.fetch_or(true, AcqRel), false);
+    assert_eq!(ATOMIC.fetch_and(false, AcqRel), true);
+    assert_eq!(ATOMIC.fetch_or(true, SeqCst), false);
+    assert_eq!(ATOMIC.fetch_and(false, SeqCst), true);
+    assert_eq!(ATOMIC.load(Relaxed), false);
+}
+
+#[test]
+fn atomic_nand() {
+    use Ordering::*;
+
+    static ATOMIC: AtomicU8 = AtomicU8::new(0x13);
+
+    assert_eq!(ATOMIC.fetch_nand(0x13, Relaxed), 0x13);
+    assert_eq!(ATOMIC.fetch_nand(0xec, Acquire), 0xec);
+    assert_eq!(ATOMIC.fetch_nand(0x13, Release), 0x13);
+    assert_eq!(ATOMIC.fetch_nand(0xec, AcqRel), 0xec);
+    assert_eq!(ATOMIC.fetch_nand(0x13, SeqCst), 0x13);
+    assert_eq!(ATOMIC.load(Relaxed), 0xec);
+}
+
+#[test]
+fn atomic_xor() {
+    use Ordering::*;
+
+    static ATOMIC: AtomicBool = AtomicBool::new(false);
+
+    assert_eq!(ATOMIC.fetch_xor(true, Relaxed), false);
+    assert_eq!(ATOMIC.fetch_xor(true, Acquire), true);
+    assert_eq!(ATOMIC.fetch_xor(true, Release), false);
+    assert_eq!(ATOMIC.fetch_xor(true, AcqRel), true);
+    assert_eq!(ATOMIC.fetch_xor(true, SeqCst), false);
+    assert_eq!(ATOMIC.load(Relaxed), true);
+}
+
+#[test]
+fn atomic_max() {
+    use Ordering::*;
+
+    static ATOMIC: AtomicI8 = AtomicI8::new(0);
+
+    assert_eq!(ATOMIC.fetch_max(1, Relaxed), 0);
+    assert_eq!(ATOMIC.fetch_max(2, Acquire), 1);
+    assert_eq!(ATOMIC.fetch_max(3, Release), 2);
+    assert_eq!(ATOMIC.fetch_max(4, AcqRel), 3);
+    assert_eq!(ATOMIC.fetch_max(5, SeqCst), 4);
+    assert_eq!(ATOMIC.load(Relaxed), 5);
+}
+
+#[test]
+fn atomic_umax() {
+    use Ordering::*;
+
+    static ATOMIC: AtomicU8 = AtomicU8::new(0);
+
+    assert_eq!(ATOMIC.fetch_max(1, Relaxed), 0);
+    assert_eq!(ATOMIC.fetch_max(2, Acquire), 1);
+    assert_eq!(ATOMIC.fetch_max(3, Release), 2);
+    assert_eq!(ATOMIC.fetch_max(4, AcqRel), 3);
+    assert_eq!(ATOMIC.fetch_max(5, SeqCst), 4);
+    assert_eq!(ATOMIC.load(Relaxed), 5);
+}
+
+#[test]
+fn atomic_min() {
+    use Ordering::*;
+
+    static ATOMIC: AtomicI8 = AtomicI8::new(5);
+
+    assert_eq!(ATOMIC.fetch_min(4, Relaxed), 5);
+    assert_eq!(ATOMIC.fetch_min(3, Acquire), 4);
+    assert_eq!(ATOMIC.fetch_min(2, Release), 3);
+    assert_eq!(ATOMIC.fetch_min(1, AcqRel), 2);
+    assert_eq!(ATOMIC.fetch_min(0, SeqCst), 1);
+    assert_eq!(ATOMIC.load(Relaxed), 0);
+}
+
+#[test]
+fn atomic_umin() {
+    use Ordering::*;
+
+    static ATOMIC: AtomicU8 = AtomicU8::new(5);
+
+    assert_eq!(ATOMIC.fetch_min(4, Relaxed), 5);
+    assert_eq!(ATOMIC.fetch_min(3, Acquire), 4);
+    assert_eq!(ATOMIC.fetch_min(2, Release), 3);
+    assert_eq!(ATOMIC.fetch_min(1, AcqRel), 2);
+    assert_eq!(ATOMIC.fetch_min(0, SeqCst), 1);
+    assert_eq!(ATOMIC.load(Relaxed), 0);
+}
+
 /* FIXME(#110395)
 #[test]
 fn atomic_const_from() {

From a535042e80a38196a58c27a8c95552546affe5dc Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 16 Sep 2025 04:42:27 +0200
Subject: [PATCH 0999/1889] Do not run ui test if options specific to llvm are
 used when another codegen backend is used

---
 src/tools/compiletest/src/common.rs           |  4 ++++
 src/tools/compiletest/src/directives/needs.rs | 13 ++++++++-----
 2 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
index 143ccdcb9e520..6da102b1b5f11 100644
--- a/src/tools/compiletest/src/common.rs
+++ b/src/tools/compiletest/src/common.rs
@@ -203,6 +203,10 @@ impl CodegenBackend {
             Self::Llvm => "llvm",
         }
     }
+
+    pub fn is_llvm(self) -> bool {
+        matches!(self, Self::Llvm)
+    }
 }
 
 /// Configuration for `compiletest` *per invocation*.
diff --git a/src/tools/compiletest/src/directives/needs.rs b/src/tools/compiletest/src/directives/needs.rs
index ee46f4c70cb8c..3b7a9478717f4 100644
--- a/src/tools/compiletest/src/directives/needs.rs
+++ b/src/tools/compiletest/src/directives/needs.rs
@@ -81,8 +81,8 @@ pub(super) fn handle_needs(
         },
         Need {
             name: "needs-enzyme",
-            condition: config.has_enzyme,
-            ignore_reason: "ignored when LLVM Enzyme is disabled",
+            condition: config.has_enzyme && config.default_codegen_backend.is_llvm(),
+            ignore_reason: "ignored when LLVM Enzyme is disabled or LLVM is not the default codegen backend",
         },
         Need {
             name: "needs-run-enabled",
@@ -161,8 +161,8 @@ pub(super) fn handle_needs(
         },
         Need {
             name: "needs-llvm-zstd",
-            condition: cache.llvm_zstd,
-            ignore_reason: "ignored if LLVM wasn't build with zstd for ELF section compression",
+            condition: cache.llvm_zstd && config.default_codegen_backend.is_llvm(),
+            ignore_reason: "ignored if LLVM wasn't build with zstd for ELF section compression or LLVM is not the default codegen backend",
         },
         Need {
             name: "needs-rustc-debug-assertions",
@@ -279,7 +279,10 @@ pub(super) fn handle_needs(
 
     // Handled elsewhere.
     if name == "needs-llvm-components" {
-        return IgnoreDecision::Continue;
+        if config.default_codegen_backend.is_llvm() {
+            return IgnoreDecision::Continue;
+        }
+        return IgnoreDecision::Ignore { reason: "LLVM specific test".into() };
     }
 
     let mut found_valid = false;

From 6912631d3ead427848a559ef5af66ab6f30e79ed Mon Sep 17 00:00:00 2001
From: Tawan Muadmuenwai <modhanami@gmail.com>
Date: Mon, 15 Sep 2025 21:24:57 +0700
Subject: [PATCH 1000/1889] Add span for struct tail recursion limit error

---
 .../src/type_check/canonical.rs               | 16 ++++---
 .../src/const_eval/valtrees.rs                |  2 +
 compiler/rustc_hir_typeck/src/expectation.rs  |  9 +++-
 .../rustc_hir_typeck/src/fn_ctxt/_impl.rs     |  1 +
 compiler/rustc_middle/src/error.rs            |  2 +
 compiler/rustc_middle/src/ty/layout.rs        |  2 +
 compiler/rustc_middle/src/ty/sty.rs           |  3 +-
 compiler/rustc_middle/src/ty/util.rs          | 17 +++++--
 .../src/traits/project.rs                     |  1 +
 compiler/rustc_ty_utils/src/layout.rs         | 46 ++++++++++---------
 compiler/rustc_ty_utils/src/ty.rs             |  1 +
 .../ui/did_you_mean/recursion_limit_deref.rs  |  7 +--
 .../did_you_mean/recursion_limit_deref.stderr | 18 ++++++--
 ...te-instantiation-struct-tail-ice-114484.rs | 28 +++++------
 ...nstantiation-struct-tail-ice-114484.stderr |  8 ++--
 tests/ui/infinite/infinite-struct.rs          |  3 +-
 tests/ui/infinite/infinite-struct.stderr      |  6 ++-
 .../invalid/issue-114435-layout-type-err.rs   |  3 +-
 .../solver-cycles/129541-recursive-struct.rs  |  3 +-
 19 files changed, 111 insertions(+), 65 deletions(-)

diff --git a/compiler/rustc_borrowck/src/type_check/canonical.rs b/compiler/rustc_borrowck/src/type_check/canonical.rs
index 2627ed899a933..aece0bda34692 100644
--- a/compiler/rustc_borrowck/src/type_check/canonical.rs
+++ b/compiler/rustc_borrowck/src/type_check/canonical.rs
@@ -230,8 +230,14 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         location: impl NormalizeLocation,
     ) -> Ty<'tcx> {
         let tcx = self.tcx();
+        let body = self.body;
+
+        let cause = ObligationCause::misc(
+            location.to_locations().span(body),
+            body.source.def_id().expect_local(),
+        );
+
         if self.infcx.next_trait_solver() {
-            let body = self.body;
             let param_env = self.infcx.param_env;
             // FIXME: Make this into a real type op?
             self.fully_perform_op(
@@ -241,10 +247,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                     |ocx| {
                         let structurally_normalize = |ty| {
                             ocx.structurally_normalize_ty(
-                                &ObligationCause::misc(
-                                    location.to_locations().span(body),
-                                    body.source.def_id().expect_local(),
-                                ),
+                                &cause,
                                 param_env,
                                 ty,
                             )
@@ -253,6 +256,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
 
                         let tail = tcx.struct_tail_raw(
                             ty,
+                            &cause,
                             structurally_normalize,
                             || {},
                         );
@@ -265,7 +269,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             .unwrap_or_else(|guar| Ty::new_error(tcx, guar))
         } else {
             let mut normalize = |ty| self.normalize(ty, location);
-            let tail = tcx.struct_tail_raw(ty, &mut normalize, || {});
+            let tail = tcx.struct_tail_raw(ty, &cause, &mut normalize, || {});
             normalize(tail)
         }
     }
diff --git a/compiler/rustc_const_eval/src/const_eval/valtrees.rs b/compiler/rustc_const_eval/src/const_eval/valtrees.rs
index 37c6c4a61d8d6..7c41258ebfe5f 100644
--- a/compiler/rustc_const_eval/src/const_eval/valtrees.rs
+++ b/compiler/rustc_const_eval/src/const_eval/valtrees.rs
@@ -1,6 +1,7 @@
 use rustc_abi::{BackendRepr, FieldIdx, VariantIdx};
 use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_middle::mir::interpret::{EvalToValTreeResult, GlobalId, ValTreeCreationError};
+use rustc_middle::traits::ObligationCause;
 use rustc_middle::ty::layout::{LayoutCx, TyAndLayout};
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_middle::{bug, mir};
@@ -196,6 +197,7 @@ fn reconstruct_place_meta<'tcx>(
     // Traverse the type, and update `last_valtree` as we go.
     let tail = tcx.struct_tail_raw(
         layout.ty,
+        &ObligationCause::dummy(),
         |ty| ty,
         || {
             let branches = last_valtree.unwrap_branch();
diff --git a/compiler/rustc_hir_typeck/src/expectation.rs b/compiler/rustc_hir_typeck/src/expectation.rs
index 6d95b6917e296..2fbea5b61cfc6 100644
--- a/compiler/rustc_hir_typeck/src/expectation.rs
+++ b/compiler/rustc_hir_typeck/src/expectation.rs
@@ -1,3 +1,4 @@
+use rustc_middle::traits::ObligationCause;
 use rustc_middle::ty::{self, Ty};
 use rustc_span::Span;
 
@@ -74,8 +75,14 @@ impl<'a, 'tcx> Expectation<'tcx> {
     /// See the test case `test/ui/coerce-expect-unsized.rs` and #20169
     /// for examples of where this comes up,.
     pub(super) fn rvalue_hint(fcx: &FnCtxt<'a, 'tcx>, ty: Ty<'tcx>) -> Expectation<'tcx> {
+        let span = match ty.kind() {
+            ty::Adt(adt_def, _) => fcx.tcx.def_span(adt_def.did()),
+            _ => fcx.tcx.def_span(fcx.body_id),
+        };
+        let cause = ObligationCause::misc(span, fcx.body_id);
+
         // FIXME: This is not right, even in the old solver...
-        match fcx.tcx.struct_tail_raw(ty, |ty| ty, || {}).kind() {
+        match fcx.tcx.struct_tail_raw(ty, &cause, |ty| ty, || {}).kind() {
             ty::Slice(_) | ty::Str | ty::Dynamic(..) => ExpectRvalueLikeUnsized(ty),
             _ => ExpectHasType(ty),
         }
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
index 7370124e800da..4563159314d15 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -424,6 +424,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         if !ty.references_error() {
             let tail = self.tcx.struct_tail_raw(
                 ty,
+                &self.misc(span),
                 |ty| {
                     if self.next_trait_solver() {
                         self.try_structurally_resolve_type(span, ty)
diff --git a/compiler/rustc_middle/src/error.rs b/compiler/rustc_middle/src/error.rs
index dad402ec69616..e3e1393b5f9ae 100644
--- a/compiler/rustc_middle/src/error.rs
+++ b/compiler/rustc_middle/src/error.rs
@@ -71,6 +71,8 @@ pub enum TypeMismatchReason {
 #[diag(middle_recursion_limit_reached)]
 #[help]
 pub(crate) struct RecursionLimitReached<'tcx> {
+    #[primary_span]
+    pub span: Span,
     pub ty: Ty<'tcx>,
     pub suggested_limit: rustc_hir::limit::Limit,
 }
diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs
index 2114d080dfa43..572d7e037b79a 100644
--- a/compiler/rustc_middle/src/ty/layout.rs
+++ b/compiler/rustc_middle/src/ty/layout.rs
@@ -22,6 +22,7 @@ use {rustc_abi as abi, rustc_hir as hir};
 
 use crate::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use crate::query::TyCtxtAt;
+use crate::traits::ObligationCause;
 use crate::ty::normalize_erasing_regions::NormalizationError;
 use crate::ty::{self, CoroutineArgsExt, Ty, TyCtxt, TypeVisitableExt};
 
@@ -384,6 +385,7 @@ impl<'tcx> SizeSkeleton<'tcx> {
 
                 let tail = tcx.struct_tail_raw(
                     pointee,
+                    &ObligationCause::dummy(),
                     |ty| match tcx.try_normalize_erasing_regions(typing_env, ty) {
                         Ok(ty) => ty,
                         Err(e) => Ty::new_error_with_message(
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
index 755fc68d86f34..ea07f5c18dd12 100644
--- a/compiler/rustc_middle/src/ty/sty.rs
+++ b/compiler/rustc_middle/src/ty/sty.rs
@@ -23,6 +23,7 @@ use ty::util::IntTypeExt;
 
 use super::GenericParamDefKind;
 use crate::infer::canonical::Canonical;
+use crate::traits::ObligationCause;
 use crate::ty::InferTy::*;
 use crate::ty::{
     self, AdtDef, BoundRegionKind, Discr, GenericArg, GenericArgs, GenericArgsRef, List, ParamEnv,
@@ -1640,7 +1641,7 @@ impl<'tcx> Ty<'tcx> {
         tcx: TyCtxt<'tcx>,
         normalize: impl FnMut(Ty<'tcx>) -> Ty<'tcx>,
     ) -> Result<Ty<'tcx>, Ty<'tcx>> {
-        let tail = tcx.struct_tail_raw(self, normalize, || {});
+        let tail = tcx.struct_tail_raw(self, &ObligationCause::dummy(), normalize, || {});
         match tail.kind() {
             // Sized types
             ty::Infer(ty::IntVar(_) | ty::FloatVar(_))
diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs
index 029586a9c554c..9e95a2c3cb37d 100644
--- a/compiler/rustc_middle/src/ty/util.rs
+++ b/compiler/rustc_middle/src/ty/util.rs
@@ -24,6 +24,7 @@ use super::TypingEnv;
 use crate::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use crate::mir;
 use crate::query::Providers;
+use crate::traits::ObligationCause;
 use crate::ty::layout::{FloatExt, IntegerExt};
 use crate::ty::{
     self, Asyncness, FallibleTypeFolder, GenericArgKind, GenericArgsRef, Ty, TyCtxt, TypeFoldable,
@@ -216,7 +217,12 @@ impl<'tcx> TyCtxt<'tcx> {
         typing_env: ty::TypingEnv<'tcx>,
     ) -> Ty<'tcx> {
         let tcx = self;
-        tcx.struct_tail_raw(ty, |ty| tcx.normalize_erasing_regions(typing_env, ty), || {})
+        tcx.struct_tail_raw(
+            ty,
+            &ObligationCause::dummy(),
+            |ty| tcx.normalize_erasing_regions(typing_env, ty),
+            || {},
+        )
     }
 
     /// Returns true if a type has metadata.
@@ -248,6 +254,7 @@ impl<'tcx> TyCtxt<'tcx> {
     pub fn struct_tail_raw(
         self,
         mut ty: Ty<'tcx>,
+        cause: &ObligationCause<'tcx>,
         mut normalize: impl FnMut(Ty<'tcx>) -> Ty<'tcx>,
         // This is currently used to allow us to walk a ValTree
         // in lockstep with the type in order to get the ValTree branch that
@@ -261,9 +268,11 @@ impl<'tcx> TyCtxt<'tcx> {
                     Limit(0) => Limit(2),
                     limit => limit * 2,
                 };
-                let reported = self
-                    .dcx()
-                    .emit_err(crate::error::RecursionLimitReached { ty, suggested_limit });
+                let reported = self.dcx().emit_err(crate::error::RecursionLimitReached {
+                    span: cause.span,
+                    ty,
+                    suggested_limit,
+                });
                 return Ty::new_error(self, reported);
             }
             match *ty.kind() {
diff --git a/compiler/rustc_trait_selection/src/traits/project.rs b/compiler/rustc_trait_selection/src/traits/project.rs
index 884d53732fe2a..042d6def84c33 100644
--- a/compiler/rustc_trait_selection/src/traits/project.rs
+++ b/compiler/rustc_trait_selection/src/traits/project.rs
@@ -1057,6 +1057,7 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
                     Some(LangItem::PointeeTrait) => {
                         let tail = selcx.tcx().struct_tail_raw(
                             self_ty,
+                            &obligation.cause,
                             |ty| {
                                 // We throw away any obligations we get from this, since we normalize
                                 // and confirm these obligations once again during confirmation
diff --git a/compiler/rustc_ty_utils/src/layout.rs b/compiler/rustc_ty_utils/src/layout.rs
index 79f7e228e2adc..c48d167011639 100644
--- a/compiler/rustc_ty_utils/src/layout.rs
+++ b/compiler/rustc_ty_utils/src/layout.rs
@@ -10,6 +10,7 @@ use rustc_hashes::Hash64;
 use rustc_index::IndexVec;
 use rustc_middle::bug;
 use rustc_middle::query::Providers;
+use rustc_middle::traits::ObligationCause;
 use rustc_middle::ty::layout::{
     FloatExt, HasTyCtxt, IntegerExt, LayoutCx, LayoutError, LayoutOf, TyAndLayout,
 };
@@ -390,30 +391,31 @@ fn layout_of_uncached<'tcx>(
 
             let metadata = if let Some(metadata_def_id) = tcx.lang_items().metadata_type() {
                 let pointee_metadata = Ty::new_projection(tcx, metadata_def_id, [pointee]);
-                let metadata_ty =
-                    match tcx.try_normalize_erasing_regions(cx.typing_env, pointee_metadata) {
-                        Ok(metadata_ty) => metadata_ty,
-                        Err(mut err) => {
-                            // Usually `<Ty as Pointee>::Metadata` can't be normalized because
-                            // its struct tail cannot be normalized either, so try to get a
-                            // more descriptive layout error here, which will lead to less confusing
-                            // diagnostics.
-                            //
-                            // We use the raw struct tail function here to get the first tail
-                            // that is an alias, which is likely the cause of the normalization
-                            // error.
-                            match tcx.try_normalize_erasing_regions(
-                                cx.typing_env,
-                                tcx.struct_tail_raw(pointee, |ty| ty, || {}),
-                            ) {
-                                Ok(_) => {}
-                                Err(better_err) => {
-                                    err = better_err;
-                                }
+                let metadata_ty = match tcx
+                    .try_normalize_erasing_regions(cx.typing_env, pointee_metadata)
+                {
+                    Ok(metadata_ty) => metadata_ty,
+                    Err(mut err) => {
+                        // Usually `<Ty as Pointee>::Metadata` can't be normalized because
+                        // its struct tail cannot be normalized either, so try to get a
+                        // more descriptive layout error here, which will lead to less confusing
+                        // diagnostics.
+                        //
+                        // We use the raw struct tail function here to get the first tail
+                        // that is an alias, which is likely the cause of the normalization
+                        // error.
+                        match tcx.try_normalize_erasing_regions(
+                            cx.typing_env,
+                            tcx.struct_tail_raw(pointee, &ObligationCause::dummy(), |ty| ty, || {}),
+                        ) {
+                            Ok(_) => {}
+                            Err(better_err) => {
+                                err = better_err;
                             }
-                            return Err(error(cx, LayoutError::NormalizationFailure(pointee, err)));
                         }
-                    };
+                        return Err(error(cx, LayoutError::NormalizationFailure(pointee, err)));
+                    }
+                };
 
                 let metadata_layout = cx.layout_of(metadata_ty)?;
                 // If the metadata is a 1-zst, then the pointer is thin.
diff --git a/compiler/rustc_ty_utils/src/ty.rs b/compiler/rustc_ty_utils/src/ty.rs
index a5987757dc34d..64e62e173876f 100644
--- a/compiler/rustc_ty_utils/src/ty.rs
+++ b/compiler/rustc_ty_utils/src/ty.rs
@@ -353,6 +353,7 @@ fn impl_self_is_guaranteed_unsized<'tcx>(tcx: TyCtxt<'tcx>, impl_def_id: DefId)
 
     let tail = tcx.struct_tail_raw(
         tcx.type_of(impl_def_id).instantiate_identity(),
+        &cause,
         |ty| {
             ocx.structurally_normalize_ty(&cause, param_env, ty).unwrap_or_else(|_| {
                 Ty::new_error_with_message(
diff --git a/tests/ui/did_you_mean/recursion_limit_deref.rs b/tests/ui/did_you_mean/recursion_limit_deref.rs
index e53007388af25..3ae956b751d84 100644
--- a/tests/ui/did_you_mean/recursion_limit_deref.rs
+++ b/tests/ui/did_you_mean/recursion_limit_deref.rs
@@ -1,3 +1,6 @@
+//~ ERROR reached the recursion limit finding the struct tail for `K`
+//~| ERROR reached the recursion limit finding the struct tail for `Bottom`
+
 // Test that the recursion limit can be changed and that the compiler
 // suggests a fix. In this case, we have a long chain of Deref impls
 // which will cause an overflow during the autoderef loop.
@@ -9,6 +12,7 @@
 macro_rules! link {
     ($outer:ident, $inner:ident) => {
         struct $outer($inner);
+        //~^ ERROR reached the recursion limit finding the struct tail for `Bottom`
 
         impl $outer {
             fn new() -> $outer {
@@ -51,6 +55,3 @@ fn main() {
     let x: &Bottom = &t; //~ ERROR mismatched types
     //~^ error recursion limit
 }
-
-//~? ERROR reached the recursion limit finding the struct tail for `K`
-//~? ERROR reached the recursion limit finding the struct tail for `Bottom`
diff --git a/tests/ui/did_you_mean/recursion_limit_deref.stderr b/tests/ui/did_you_mean/recursion_limit_deref.stderr
index 23341ec6bdc27..faa85dc5ae98c 100644
--- a/tests/ui/did_you_mean/recursion_limit_deref.stderr
+++ b/tests/ui/did_you_mean/recursion_limit_deref.stderr
@@ -6,8 +6,20 @@ error: reached the recursion limit finding the struct tail for `Bottom`
    |
    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "20"]`
 
+error: reached the recursion limit finding the struct tail for `Bottom`
+  --> $DIR/recursion_limit_deref.rs:14:9
+   |
+LL |         struct $outer($inner);
+   |         ^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | link!(A, B);
+   | ----------- in this macro invocation
+   |
+   = help: consider increasing the recursion limit by adding a `#![recursion_limit = "20"]`
+   = note: this error originates in the macro `link` (in Nightly builds, run with -Z macro-backtrace for more info)
+
 error[E0055]: reached the recursion limit while auto-dereferencing `J`
-  --> $DIR/recursion_limit_deref.rs:51:22
+  --> $DIR/recursion_limit_deref.rs:55:22
    |
 LL |     let x: &Bottom = &t;
    |                      ^^ deref recursion limit reached
@@ -15,7 +27,7 @@ LL |     let x: &Bottom = &t;
    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "20"]` attribute to your crate (`recursion_limit_deref`)
 
 error[E0308]: mismatched types
-  --> $DIR/recursion_limit_deref.rs:51:22
+  --> $DIR/recursion_limit_deref.rs:55:22
    |
 LL |     let x: &Bottom = &t;
    |            -------   ^^ expected `&Bottom`, found `&Top`
@@ -25,7 +37,7 @@ LL |     let x: &Bottom = &t;
    = note: expected reference `&Bottom`
               found reference `&Top`
 
-error: aborting due to 4 previous errors
+error: aborting due to 5 previous errors
 
 Some errors have detailed explanations: E0055, E0308.
 For more information about an error, try `rustc --explain E0055`.
diff --git a/tests/ui/infinite/infinite-instantiation-struct-tail-ice-114484.rs b/tests/ui/infinite/infinite-instantiation-struct-tail-ice-114484.rs
index f7117368ece7b..b8ea353df9385 100644
--- a/tests/ui/infinite/infinite-instantiation-struct-tail-ice-114484.rs
+++ b/tests/ui/infinite/infinite-instantiation-struct-tail-ice-114484.rs
@@ -1,4 +1,17 @@
-//~ ERROR reached the recursion limit while instantiating `<VirtualWrapper<
+//~ ERROR reached the recursion limit finding the struct tail for `[u8; 256]`
+//~| ERROR reached the recursion limit finding the struct tail for `[u8; 256]`
+//~| ERROR reached the recursion limit finding the struct tail for `[u8; 256]`
+//~| ERROR reached the recursion limit finding the struct tail for `[u8; 256]`
+//~| ERROR reached the recursion limit finding the struct tail for `SomeData<256>`
+//~| ERROR reached the recursion limit finding the struct tail for `SomeData<256>`
+//~| ERROR reached the recursion limit finding the struct tail for `SomeData<256>`
+//~| ERROR reached the recursion limit finding the struct tail for `SomeData<256>`
+//~| ERROR reached the recursion limit finding the struct tail for `VirtualWrapper<SomeData<256>, 0>`
+//~| ERROR reached the recursion limit finding the struct tail for `VirtualWrapper<SomeData<256>, 0>`
+//~| ERROR reached the recursion limit finding the struct tail for `VirtualWrapper<SomeData<256>, 0>`
+//~| ERROR reached the recursion limit finding the struct tail for `VirtualWrapper<SomeData<256>, 0>`
+//~| ERROR reached the recursion limit while instantiating `<VirtualWrapper<..., 1> as MyTrait>::virtualize`
+
 //@ build-fail
 //@ compile-flags: --diagnostic-width=100 -Zwrite-long-types-to-disk=yes
 
@@ -72,16 +85,3 @@ fn main() {
     let test = SomeData([0; 256]);
     test.virtualize();
 }
-
-//~? ERROR reached the recursion limit finding the struct tail for `[u8; 256]`
-//~? ERROR reached the recursion limit finding the struct tail for `[u8; 256]`
-//~? ERROR reached the recursion limit finding the struct tail for `[u8; 256]`
-//~? ERROR reached the recursion limit finding the struct tail for `[u8; 256]`
-//~? ERROR reached the recursion limit finding the struct tail for `SomeData<256>`
-//~? ERROR reached the recursion limit finding the struct tail for `SomeData<256>`
-//~? ERROR reached the recursion limit finding the struct tail for `SomeData<256>`
-//~? ERROR reached the recursion limit finding the struct tail for `SomeData<256>`
-//~? ERROR reached the recursion limit finding the struct tail for `VirtualWrapper<SomeData<256>, 0>`
-//~? ERROR reached the recursion limit finding the struct tail for `VirtualWrapper<SomeData<256>, 0>`
-//~? ERROR reached the recursion limit finding the struct tail for `VirtualWrapper<SomeData<256>, 0>`
-//~? ERROR reached the recursion limit finding the struct tail for `VirtualWrapper<SomeData<256>, 0>`
diff --git a/tests/ui/infinite/infinite-instantiation-struct-tail-ice-114484.stderr b/tests/ui/infinite/infinite-instantiation-struct-tail-ice-114484.stderr
index faf9cbe2318c4..deccc88e64fa5 100644
--- a/tests/ui/infinite/infinite-instantiation-struct-tail-ice-114484.stderr
+++ b/tests/ui/infinite/infinite-instantiation-struct-tail-ice-114484.stderr
@@ -18,7 +18,7 @@ error: reached the recursion limit finding the struct tail for `[u8; 256]`
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 note: the above error was encountered while instantiating `fn virtualize_my_trait::<VirtualWrapper<..., 1>>`
-  --> $DIR/infinite-instantiation-struct-tail-ice-114484.rs:25:18
+  --> $DIR/infinite-instantiation-struct-tail-ice-114484.rs:38:18
    |
 LL |         unsafe { virtualize_my_trait(L, self) }
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -46,7 +46,7 @@ error: reached the recursion limit finding the struct tail for `SomeData<256>`
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 note: the above error was encountered while instantiating `fn virtualize_my_trait::<VirtualWrapper<..., 1>>`
-  --> $DIR/infinite-instantiation-struct-tail-ice-114484.rs:25:18
+  --> $DIR/infinite-instantiation-struct-tail-ice-114484.rs:38:18
    |
 LL |         unsafe { virtualize_my_trait(L, self) }
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -74,7 +74,7 @@ error: reached the recursion limit finding the struct tail for `VirtualWrapper<S
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 note: the above error was encountered while instantiating `fn virtualize_my_trait::<VirtualWrapper<..., 1>>`
-  --> $DIR/infinite-instantiation-struct-tail-ice-114484.rs:25:18
+  --> $DIR/infinite-instantiation-struct-tail-ice-114484.rs:38:18
    |
 LL |         unsafe { virtualize_my_trait(L, self) }
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL |         unsafe { virtualize_my_trait(L, self) }
 error: reached the recursion limit while instantiating `<VirtualWrapper<..., 1> as MyTrait>::virtualize`
    |
 note: `<VirtualWrapper<T, L> as MyTrait>::virtualize` defined here
-  --> $DIR/infinite-instantiation-struct-tail-ice-114484.rs:24:5
+  --> $DIR/infinite-instantiation-struct-tail-ice-114484.rs:37:5
    |
 LL |     fn virtualize(&self) -> &dyn MyTrait {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/infinite/infinite-struct.rs b/tests/ui/infinite/infinite-struct.rs
index fd47a4ec9cc6a..d784455824604 100644
--- a/tests/ui/infinite/infinite-struct.rs
+++ b/tests/ui/infinite/infinite-struct.rs
@@ -1,6 +1,7 @@
 struct Take(Take);
 //~^ ERROR has infinite size
 //~| ERROR cycle
+//~| ERROR reached the recursion limit finding the struct tail for `Take`
 
 // check that we don't hang trying to find the tail of a recursive struct (#79437)
 fn foo() -> Take {
@@ -15,5 +16,3 @@ struct Foo { //~ ERROR has infinite size
 struct Bar<T>([T; 1]);
 
 fn main() {}
-
-//~? ERROR reached the recursion limit finding the struct tail for `Take`
diff --git a/tests/ui/infinite/infinite-struct.stderr b/tests/ui/infinite/infinite-struct.stderr
index 5896aec399dc4..0d1ec4989aa53 100644
--- a/tests/ui/infinite/infinite-struct.stderr
+++ b/tests/ui/infinite/infinite-struct.stderr
@@ -10,7 +10,7 @@ LL | struct Take(Box<Take>);
    |             ++++    +
 
 error[E0072]: recursive type `Foo` has infinite size
-  --> $DIR/infinite-struct.rs:11:1
+  --> $DIR/infinite-struct.rs:12:1
    |
 LL | struct Foo {
    | ^^^^^^^^^^
@@ -23,6 +23,10 @@ LL |     x: Bar<Box<Foo>>,
    |            ++++   +
 
 error: reached the recursion limit finding the struct tail for `Take`
+  --> $DIR/infinite-struct.rs:1:1
+   |
+LL | struct Take(Take);
+   | ^^^^^^^^^^^
    |
    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]`
 
diff --git a/tests/ui/invalid/issue-114435-layout-type-err.rs b/tests/ui/invalid/issue-114435-layout-type-err.rs
index 07f310478d3c9..ae04759af5df2 100644
--- a/tests/ui/invalid/issue-114435-layout-type-err.rs
+++ b/tests/ui/invalid/issue-114435-layout-type-err.rs
@@ -1,3 +1,4 @@
+//~ ERROR reached the recursion limit finding the struct tail for `Bottom`
 //@ check-fail
 //@ compile-flags: --crate-type lib -Cdebuginfo=2
 
@@ -40,5 +41,3 @@ link!(J, K);
 link!(K, Bottom);
 
 fn main() {}
-
-//~? ERROR reached the recursion limit finding the struct tail for `Bottom`
diff --git a/tests/ui/traits/solver-cycles/129541-recursive-struct.rs b/tests/ui/traits/solver-cycles/129541-recursive-struct.rs
index 723179302e30a..c5c2c27b28267 100644
--- a/tests/ui/traits/solver-cycles/129541-recursive-struct.rs
+++ b/tests/ui/traits/solver-cycles/129541-recursive-struct.rs
@@ -1,3 +1,4 @@
+//~ ERROR reached the recursion limit finding the struct tail for `<[Hello] as Normalize>::Assoc`
 // Regression test for #129541
 
 //@ revisions: unique_curr unique_next multiple_curr multiple_next
@@ -24,5 +25,3 @@ struct Hello {
 }
 
 fn main() {}
-
-//~? ERROR reached the recursion limit finding the struct tail for `<[Hello] as Normalize>::Assoc`

From 9c423796bbbb989bac15524d78cdc6d46641e5da Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Mon, 15 Sep 2025 16:31:32 -0500
Subject: [PATCH 1001/1889] bootstrap: emit hint if a config key is used in the
 wrong section

---
 src/bootstrap/src/core/config/config.rs | 109 +++++++++++++++++++++---
 1 file changed, 98 insertions(+), 11 deletions(-)

diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index 678a9b6395228..0213047f3a140 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -1853,13 +1853,7 @@ fn load_toml_config(
         } else {
             toml_path.clone()
         });
-        (
-            get_toml(&toml_path).unwrap_or_else(|e| {
-                eprintln!("ERROR: Failed to parse '{}': {e}", toml_path.display());
-                exit!(2);
-            }),
-            path,
-        )
+        (get_toml(&toml_path).unwrap_or_else(|e| bad_config(&toml_path, e)), path)
     } else {
         (TomlConfig::default(), None)
     }
@@ -1892,10 +1886,8 @@ fn postprocess_toml(
             .unwrap()
             .join(include_path);
 
-        let included_toml = get_toml(&include_path).unwrap_or_else(|e| {
-            eprintln!("ERROR: Failed to parse '{}': {e}", include_path.display());
-            exit!(2);
-        });
+        let included_toml =
+            get_toml(&include_path).unwrap_or_else(|e| bad_config(&include_path, e));
         toml.merge(
             Some(include_path),
             &mut Default::default(),
@@ -2398,3 +2390,98 @@ pub(crate) fn read_file_by_commit<'a>(
     git.arg("show").arg(format!("{commit}:{}", file.to_str().unwrap()));
     git.run_capture_stdout(dwn_ctx.exec_ctx).stdout()
 }
+
+fn bad_config(toml_path: &Path, e: toml::de::Error) -> ! {
+    eprintln!("ERROR: Failed to parse '{}': {e}", toml_path.display());
+    let e_s = e.to_string();
+    if e_s.contains("unknown field")
+        && let Some(field_name) = e_s.split("`").nth(1)
+        && let sections = find_correct_section_for_field(field_name)
+        && !sections.is_empty()
+    {
+        if sections.len() == 1 {
+            match sections[0] {
+                WouldBeValidFor::TopLevel { is_section } => {
+                    if is_section {
+                        eprintln!(
+                            "hint: section name `{field_name}` used as a key within a section"
+                        );
+                    } else {
+                        eprintln!("hint: try using `{field_name}` as a top level key");
+                    }
+                }
+                WouldBeValidFor::Section(section) => {
+                    eprintln!("hint: try moving `{field_name}` to the `{section}` section")
+                }
+            }
+        } else {
+            eprintln!(
+                "hint: `{field_name}` would be valid {}",
+                join_oxford_comma(sections.iter(), "or"),
+            );
+        }
+    }
+
+    exit!(2);
+}
+
+#[derive(Copy, Clone, Debug)]
+enum WouldBeValidFor {
+    TopLevel { is_section: bool },
+    Section(&'static str),
+}
+
+fn join_oxford_comma(
+    mut parts: impl ExactSizeIterator<Item = impl std::fmt::Display>,
+    conj: &str,
+) -> String {
+    use std::fmt::Write;
+    let mut out = String::new();
+
+    assert!(parts.len() > 1);
+    while let Some(part) = parts.next() {
+        if parts.len() == 0 {
+            write!(&mut out, "{conj} {part}")
+        } else {
+            write!(&mut out, "{part}, ")
+        }
+        .unwrap();
+    }
+    out
+}
+
+impl std::fmt::Display for WouldBeValidFor {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::TopLevel { .. } => write!(f, "at top level"),
+            Self::Section(section_name) => write!(f, "in section `{section_name}`"),
+        }
+    }
+}
+
+fn find_correct_section_for_field(field_name: &str) -> Vec<WouldBeValidFor> {
+    let sections = ["build", "install", "llvm", "gcc", "rust", "dist"];
+    sections
+        .iter()
+        .map(Some)
+        .chain([None])
+        .filter_map(|section_name| {
+            let dummy_config_str = if let Some(section_name) = section_name {
+                format!("{section_name}.{field_name} = 0\n")
+            } else {
+                format!("{field_name} = 0\n")
+            };
+            let is_unknown_field = toml::from_str::<toml::Value>(&dummy_config_str)
+                .and_then(TomlConfig::deserialize)
+                .err()
+                .is_some_and(|e| e.to_string().contains("unknown field"));
+            if is_unknown_field {
+                None
+            } else {
+                Some(section_name.copied().map(WouldBeValidFor::Section).unwrap_or_else(|| {
+                    WouldBeValidFor::TopLevel { is_section: sections.contains(&field_name) }
+                }))
+            }
+        })
+        .collect()
+}

From 91cf067f7174eac7ec0492e829bcbb844d4471d7 Mon Sep 17 00:00:00 2001
From: Martin Nordholts <martin.nordholts@codetale.se>
Date: Mon, 15 Sep 2025 19:57:08 +0200
Subject: [PATCH 1002/1889] ci: x86_64-gnu-tools: Add `--test-args` regression
 test

---
 src/ci/docker/host-x86_64/x86_64-gnu-tools/checktools.sh | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/ci/docker/host-x86_64/x86_64-gnu-tools/checktools.sh b/src/ci/docker/host-x86_64/x86_64-gnu-tools/checktools.sh
index ff9fedad6567d..14cf63b94d481 100755
--- a/src/ci/docker/host-x86_64/x86_64-gnu-tools/checktools.sh
+++ b/src/ci/docker/host-x86_64/x86_64-gnu-tools/checktools.sh
@@ -30,3 +30,10 @@ cat /tmp/toolstate/toolstates.json
 python3 "$X_PY" test --stage 2 check-tools
 python3 "$X_PY" test --stage 2 src/tools/clippy
 python3 "$X_PY" test --stage 2 src/tools/rustfmt
+
+# The below is a regression test for https://github.com/rust-lang/rust/pull/146501#issuecomment-3292608398.
+# The bug caused 0 tests to run. By grepping on that 1 test is run we prevent regressing.
+# Any test can be used. We arbitrarily chose `tests/ui/lint/unused/unused-result.rs`.
+python3 "$X_PY" test tests/ui --test-args tests/ui/lint/unused/unused-result.rs --force-rerun |
+grep --fixed-strings 'test result: ok. 1 passed; 0 failed; 0 ignored;' ||
+( echo "ERROR: --test-args functionality is broken" && exit 1 )

From c916e8886b3a1c6f32daf467c1c3d8316e35a6df Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@osdyne.com>
Date: Tue, 16 Sep 2025 11:08:43 -0700
Subject: [PATCH 1003/1889] fmt

---
 .../src/error_reporting/infer/need_type_info.rs              | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

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 94772be16be20..75283dc4ffaa6 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
@@ -4,11 +4,12 @@ use std::path::PathBuf;
 
 use rustc_errors::codes::*;
 use rustc_errors::{Diag, IntoDiagArg};
-use rustc_hir::{self as hir, PatKind};
 use rustc_hir::def::{CtorOf, DefKind, Namespace, Res};
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::intravisit::{self, Visitor};
-use rustc_hir::{Body, Closure, Expr, ExprKind, FnRetTy, HirId, LetStmt, LocalSource};
+use rustc_hir::{
+    self as hir, Body, Closure, Expr, ExprKind, FnRetTy, HirId, LetStmt, LocalSource, PatKind,
+};
 use rustc_middle::bug;
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow};

From ed85f9846da9abfad09bb5732bc18d6c39fbc9f9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@osdyne.com>
Date: Tue, 16 Sep 2025 11:21:29 -0700
Subject: [PATCH 1004/1889] remove redundant test

---
 tests/ui/closures/varargs-in-closure-isnt-supported.rs | 10 ----------
 .../closures/varargs-in-closure-isnt-supported.stderr  | 10 ----------
 2 files changed, 20 deletions(-)
 delete mode 100644 tests/ui/closures/varargs-in-closure-isnt-supported.rs
 delete mode 100644 tests/ui/closures/varargs-in-closure-isnt-supported.stderr

diff --git a/tests/ui/closures/varargs-in-closure-isnt-supported.rs b/tests/ui/closures/varargs-in-closure-isnt-supported.rs
deleted file mode 100644
index 4de78bef14d30..0000000000000
--- a/tests/ui/closures/varargs-in-closure-isnt-supported.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-// var-args are not supported in closures, ensure we don't misdirect people (#146489)
-#![feature(c_variadic)]
-
-unsafe extern "C" fn thats_not_a_pattern(mut ap: ...) -> u32 {
-    let mut lol = |...| (); //~ ERROR: unexpected `...`
-    unsafe { ap.arg::<u32>() } //~^ NOTE: C-variadic type `...` is not allowed here
-    //~| NOTE: not a valid pattern
-}
-
-fn main() {}
diff --git a/tests/ui/closures/varargs-in-closure-isnt-supported.stderr b/tests/ui/closures/varargs-in-closure-isnt-supported.stderr
deleted file mode 100644
index a645741a52771..0000000000000
--- a/tests/ui/closures/varargs-in-closure-isnt-supported.stderr
+++ /dev/null
@@ -1,10 +0,0 @@
-error: unexpected `...`
-  --> $DIR/varargs-in-closure-isnt-supported.rs:5:20
-   |
-LL |     let mut lol = |...| ();
-   |                    ^^^ not a valid pattern
-   |
-   = note: C-variadic type `...` is not allowed here
-
-error: aborting due to 1 previous error
-

From f71f75669563cc9fb74c629937046c1f13d3698e Mon Sep 17 00:00:00 2001
From: Shoyu Vanilla <modulo641@gmail.com>
Date: Wed, 17 Sep 2025 03:03:00 +0900
Subject: [PATCH 1005/1889] Fix "sync-from-ra" for `rust-lang/rust`

---
 src/tools/rust-analyzer/crates/hir-ty/src/lib.rs         | 3 +++
 src/tools/rust-analyzer/crates/hir-ty/src/next_solver.rs | 3 +++
 2 files changed, 6 insertions(+)

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 02fdbf0ebf0df..37d5347fe7ea1 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
@@ -39,6 +39,9 @@ extern crate rustc_next_trait_solver;
 #[cfg(not(feature = "in-rust-tree"))]
 extern crate ra_ap_rustc_next_trait_solver as rustc_next_trait_solver;
 
+#[cfg(feature = "in-rust-tree")]
+extern crate rustc_data_structures as ena;
+
 mod builder;
 mod chalk_db;
 mod chalk_ext;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver.rs
index 0225deebe4f31..99a501b05341c 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver.rs
@@ -40,5 +40,8 @@ pub type AliasTy<'db> = rustc_type_ir::AliasTy<DbInterner<'db>>;
 pub type PolyFnSig<'db> = Binder<'db, rustc_type_ir::FnSig<DbInterner<'db>>>;
 pub type TypingMode<'db> = rustc_type_ir::TypingMode<DbInterner<'db>>;
 
+#[cfg(feature = "in-rust-tree")]
+use rustc_data_structure::sorted_map::index_map as indexmap;
+
 pub type FxIndexMap<K, V> =
     indexmap::IndexMap<K, V, std::hash::BuildHasherDefault<rustc_hash::FxHasher>>;

From 8306a2f02e6c56447ff05b19b4b73c5c861e34fd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@osdyne.com>
Date: Tue, 16 Sep 2025 11:24:51 -0700
Subject: [PATCH 1006/1889] Reword note

---
 compiler/rustc_parse/messages.ftl     | 2 +-
 tests/ui/c-variadic/no-closure.stderr | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_parse/messages.ftl b/compiler/rustc_parse/messages.ftl
index 6d9521c7d2be0..3a4c9348b3275 100644
--- a/compiler/rustc_parse/messages.ftl
+++ b/compiler/rustc_parse/messages.ftl
@@ -189,7 +189,7 @@ parse_dotdotdot = unexpected token: `...`
 parse_dotdotdot_rest_pattern = unexpected `...`
     .label = not a valid pattern
     .suggestion = for a rest pattern, use `..` instead of `...`
-    .note = C-variadic type `...` is not allowed here
+    .note = only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
 
 parse_double_colon_in_bound = expected `:` followed by trait or lifetime
     .suggestion = use single colon
diff --git a/tests/ui/c-variadic/no-closure.stderr b/tests/ui/c-variadic/no-closure.stderr
index ad635a29ab486..4b553c215979a 100644
--- a/tests/ui/c-variadic/no-closure.stderr
+++ b/tests/ui/c-variadic/no-closure.stderr
@@ -10,7 +10,7 @@ error: unexpected `...`
 LL |     let f = |...| {};
    |              ^^^ not a valid pattern
    |
-   = note: C-variadic type `...` is not allowed here
+   = note: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
 
 error[E0743]: C-variadic type `...` may not be nested inside another type
   --> $DIR/no-closure.rs:13:17

From 401857aaa1e21df49e0d013b9856ab6dbe34870b Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Tue, 16 Sep 2025 20:20:02 +0200
Subject: [PATCH 1007/1889] cmse: fix 'region variables should not be hashed'

---
 .../src/hir_ty_lowering/cmse.rs               |  1 +
 .../undeclared-lifetime.rs                    | 20 +++++++++++++++++++
 .../undeclared-lifetime.stderr                | 19 ++++++++++++++++++
 3 files changed, 40 insertions(+)
 create mode 100644 tests/ui/cmse-nonsecure/cmse-nonsecure-call/undeclared-lifetime.rs
 create mode 100644 tests/ui/cmse-nonsecure/cmse-nonsecure-call/undeclared-lifetime.stderr

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 5088c63702e60..ae9558cae3b96 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
@@ -128,6 +128,7 @@ fn is_valid_cmse_inputs<'tcx>(
 
     // this type is only used for layout computation, which does not rely on regions
     let fn_sig = tcx.instantiate_bound_regions_with_erased(fn_sig);
+    let fn_sig = tcx.erase_and_anonymize_regions(fn_sig);
 
     for (index, ty) in fn_sig.inputs().iter().enumerate() {
         let layout = tcx.layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(*ty))?;
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/undeclared-lifetime.rs b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/undeclared-lifetime.rs
new file mode 100644
index 0000000000000..5fa5b74c0c0b9
--- /dev/null
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/undeclared-lifetime.rs
@@ -0,0 +1,20 @@
+//@ add-core-stubs
+//@ compile-flags: --target thumbv8m.main-none-eabi --crate-type lib -Cincremental=true
+//@ needs-llvm-components: arm
+#![feature(abi_cmse_nonsecure_call, no_core)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// A regression test for https://github.com/rust-lang/rust/issues/131639.
+// NOTE: -Cincremental=true was required for triggering the bug.
+
+fn foo() {
+    id::<extern "cmse-nonsecure-call" fn(&'a ())>(PhantomData);
+    //~^ ERROR use of undeclared lifetime name `'a`
+}
+
+fn id<T>(x: PhantomData<T>) -> PhantomData<T> {
+    x
+}
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/undeclared-lifetime.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/undeclared-lifetime.stderr
new file mode 100644
index 0000000000000..4aca17e73544d
--- /dev/null
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/undeclared-lifetime.stderr
@@ -0,0 +1,19 @@
+error[E0261]: use of undeclared lifetime name `'a`
+  --> $DIR/undeclared-lifetime.rs:14:43
+   |
+LL |     id::<extern "cmse-nonsecure-call" fn(&'a ())>(PhantomData);
+   |                                           ^^ undeclared lifetime
+   |
+   = note: for more information on higher-ranked polymorphism, visit https://doc.rust-lang.org/nomicon/hrtb.html
+help: consider making the type lifetime-generic with a new `'a` lifetime
+   |
+LL |     id::<for<'a> extern "cmse-nonsecure-call" fn(&'a ())>(PhantomData);
+   |          +++++++
+help: consider introducing lifetime `'a` here
+   |
+LL | fn foo<'a>() {
+   |       ++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0261`.

From e9270e3cba3da56d4d83ed74f648e53b041cb263 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@osdyne.com>
Date: Tue, 16 Sep 2025 11:38:08 -0700
Subject: [PATCH 1008/1889] Detect top-level `...` in argument type

When writing something like the expression `|_: ...| {}`, we now detect the `...` during parsing explicitly instead of relying on the detection in `parse_ty_common` so that we don't talk about "nested `...` are not supported".

```
error: unexpected `...`
  --> $DIR/no-closure.rs:6:35
   |
LL | const F: extern "C" fn(...) = |_: ...| {};
   |                                   ^^^
   |
   = note: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
```
---
 compiler/rustc_parse/messages.ftl     |  3 +++
 compiler/rustc_parse/src/errors.rs    |  8 ++++++++
 compiler/rustc_parse/src/parser/ty.rs | 13 +++++++++++--
 tests/ui/c-variadic/no-closure.rs     |  8 ++++++--
 tests/ui/c-variadic/no-closure.stderr | 13 ++++++++-----
 5 files changed, 36 insertions(+), 9 deletions(-)

diff --git a/compiler/rustc_parse/messages.ftl b/compiler/rustc_parse/messages.ftl
index 3a4c9348b3275..f83cf645f829d 100644
--- a/compiler/rustc_parse/messages.ftl
+++ b/compiler/rustc_parse/messages.ftl
@@ -191,6 +191,9 @@ parse_dotdotdot_rest_pattern = unexpected `...`
     .suggestion = for a rest pattern, use `..` instead of `...`
     .note = only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
 
+parse_dotdotdot_rest_type = unexpected `...`
+    .note = only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
+
 parse_double_colon_in_bound = expected `:` followed by trait or lifetime
     .suggestion = use single colon
 
diff --git a/compiler/rustc_parse/src/errors.rs b/compiler/rustc_parse/src/errors.rs
index 2b107fe35d592..1abeee6fe433e 100644
--- a/compiler/rustc_parse/src/errors.rs
+++ b/compiler/rustc_parse/src/errors.rs
@@ -3032,6 +3032,14 @@ pub(crate) struct NestedCVariadicType {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(parse_dotdotdot_rest_type)]
+#[note]
+pub(crate) struct InvalidCVariadicType {
+    #[primary_span]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(parse_invalid_dyn_keyword)]
 #[help]
diff --git a/compiler/rustc_parse/src/parser/ty.rs b/compiler/rustc_parse/src/parser/ty.rs
index 23aaafac934ee..65347496599d7 100644
--- a/compiler/rustc_parse/src/parser/ty.rs
+++ b/compiler/rustc_parse/src/parser/ty.rs
@@ -15,8 +15,8 @@ use super::{Parser, PathStyle, SeqSep, TokenType, Trailing};
 use crate::errors::{
     self, AttributeOnEmptyType, AttributeOnType, DynAfterMut, ExpectedFnPathFoundFnKeyword,
     ExpectedMutOrConstInRawPointerType, FnPtrWithGenerics, FnPtrWithGenericsSugg,
-    HelpUseLatestEdition, InvalidDynKeyword, LifetimeAfterMut, NeedPlusAfterTraitObjectLifetime,
-    NestedCVariadicType, ReturnTypesUseThinArrow,
+    HelpUseLatestEdition, InvalidCVariadicType, InvalidDynKeyword, LifetimeAfterMut,
+    NeedPlusAfterTraitObjectLifetime, NestedCVariadicType, ReturnTypesUseThinArrow,
 };
 use crate::parser::item::FrontMatterParsingMode;
 use crate::parser::{FnContext, FnParseMode};
@@ -106,6 +106,15 @@ fn can_begin_dyn_bound_in_edition_2015(t: &Token) -> bool {
 impl<'a> Parser<'a> {
     /// Parses a type.
     pub fn parse_ty(&mut self) -> PResult<'a, Box<Ty>> {
+        if self.token == token::DotDotDot {
+            // We special case this so that we don't talk about "nested C-variadics" in types.
+            // We still pass in `AllowCVariadic::No` so that `parse_ty_common` can complain about
+            // things like `Vec<...>`.
+            let span = self.token.span;
+            self.bump();
+            let kind = TyKind::Err(self.dcx().emit_err(InvalidCVariadicType { span }));
+            return Ok(self.mk_ty(span, kind));
+        }
         // Make sure deeply nested types don't overflow the stack.
         ensure_sufficient_stack(|| {
             self.parse_ty_common(
diff --git a/tests/ui/c-variadic/no-closure.rs b/tests/ui/c-variadic/no-closure.rs
index a5b791fbca800..830ed962a8c4a 100644
--- a/tests/ui/c-variadic/no-closure.rs
+++ b/tests/ui/c-variadic/no-closure.rs
@@ -4,13 +4,17 @@
 // Check that `...` in closures is rejected.
 
 const F: extern "C" fn(...) = |_: ...| {};
-//~^ ERROR C-variadic type `...` may not be nested inside another type
+//~^ ERROR: unexpected `...`
+//~| NOTE: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
 
 fn foo() {
     let f = |...| {};
     //~^ ERROR: unexpected `...`
+    //~| NOTE: not a valid pattern
+    //~| NOTE: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
 
     let f = |_: ...| {};
-    //~^ ERROR C-variadic type `...` may not be nested inside another type
+    //~^ ERROR: unexpected `...`
+    //~| NOTE: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
     f(1i64)
 }
diff --git a/tests/ui/c-variadic/no-closure.stderr b/tests/ui/c-variadic/no-closure.stderr
index 4b553c215979a..0946c4632e6e4 100644
--- a/tests/ui/c-variadic/no-closure.stderr
+++ b/tests/ui/c-variadic/no-closure.stderr
@@ -1,23 +1,26 @@
-error[E0743]: C-variadic type `...` may not be nested inside another type
+error: unexpected `...`
   --> $DIR/no-closure.rs:6:35
    |
 LL | const F: extern "C" fn(...) = |_: ...| {};
    |                                   ^^^
+   |
+   = note: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
 
 error: unexpected `...`
-  --> $DIR/no-closure.rs:10:14
+  --> $DIR/no-closure.rs:11:14
    |
 LL |     let f = |...| {};
    |              ^^^ not a valid pattern
    |
    = note: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
 
-error[E0743]: C-variadic type `...` may not be nested inside another type
-  --> $DIR/no-closure.rs:13:17
+error: unexpected `...`
+  --> $DIR/no-closure.rs:16:17
    |
 LL |     let f = |_: ...| {};
    |                 ^^^
+   |
+   = note: only `extern "C"` and `extern "C-unwind"` functions may have a C variable argument list
 
 error: aborting due to 3 previous errors
 
-For more information about this error, try `rustc --explain E0743`.

From 580b4891aa23c0625539bf5ee55270f27af09072 Mon Sep 17 00:00:00 2001
From: Josh Stone <jistone@redhat.com>
Date: Thu, 7 Aug 2025 14:29:00 -0700
Subject: [PATCH 1009/1889] Update the minimum external LLVM to 20

---
 compiler/rustc_codegen_llvm/src/builder.rs    |   9 +-
 compiler/rustc_codegen_llvm/src/context.rs    |  29 ----
 compiler/rustc_codegen_llvm/src/llvm_util.rs  |  57 +------
 compiler/rustc_codegen_ssa/src/mir/rvalue.rs  |  30 +---
 .../rustc_codegen_ssa/src/traits/builder.rs   |  38 ++++-
 .../rustc_llvm/llvm-wrapper/PassWrapper.cpp   | 140 ++++--------------
 src/bootstrap/src/core/build_steps/llvm.rs    |   4 +-
 src/ci/docker/README.md                       |   8 +-
 .../Dockerfile                                |   8 +-
 .../host-x86_64/x86_64-gnu-llvm-19/Dockerfile |  66 ---------
 src/ci/github-actions/jobs.yml                |  35 +----
 .../riscv-soft-abi-with-float-features.rs     |  10 +-
 tests/assembly-llvm/x86_64-bigint-helpers.rs  |   1 -
 tests/assembly-llvm/x86_64-cmp.rs             |  78 +++-------
 .../comparison-operators-2-struct.rs          |   1 -
 .../comparison-operators-2-tuple.rs           |   1 -
 tests/codegen-llvm/enum/enum-aggregate.rs     |   1 -
 .../codegen-llvm/enum/enum-discriminant-eq.rs |   1 -
 tests/codegen-llvm/integer-cmp.rs             |  36 +----
 .../intrinsics/three_way_compare.rs           |   1 -
 .../issues/and-masked-comparison-131162.rs    |   1 -
 tests/codegen-llvm/issues/issue-101082.rs     |   1 -
 tests/codegen-llvm/issues/issue-129795.rs     |   1 -
 .../iter-max-no-unwrap-failed-129583.rs       |   1 -
 .../issues/looping-over-ne-bytes-133528.rs    |   1 -
 tests/codegen-llvm/option-niche-eq.rs         |   1 -
 .../slice-last-elements-optimization.rs       |   1 -
 tests/codegen-llvm/swap-small-types.rs        |   1 -
 tests/codegen-llvm/try_question_mark_nop.rs   |  31 ++--
 tests/codegen-llvm/union-aggregate.rs         |   1 -
 tests/ui/abi/sparcv8plus-llvm19.rs            |  42 ------
 tests/ui/abi/sparcv8plus-llvm19.sparc.stderr  |   8 -
 .../sparcv8plus-llvm19.sparc_cpu_v9.stderr    |   8 -
 ...-llvm19.sparc_cpu_v9_feature_v8plus.stderr |   8 -
 ...cv8plus-llvm19.sparc_feature_v8plus.stderr |   8 -
 .../abi/sparcv8plus-llvm19.sparcv8plus.stderr |   8 -
 tests/ui/abi/sparcv8plus.rs                   |   1 -
 tests/ui/abi/sparcv8plus.sparc.stderr         |   2 +-
 tests/ui/abi/sparcv8plus.sparc_cpu_v9.stderr  |   2 +-
 ...cv8plus.sparc_cpu_v9_feature_v8plus.stderr |   2 +-
 .../sparcv8plus.sparc_feature_v8plus.stderr   |   2 +-
 tests/ui/abi/sparcv8plus.sparcv8plus.stderr   |   2 +-
 .../bad-reg.loongarch32_ilp32d.stderr         |  12 +-
 .../bad-reg.loongarch32_ilp32s.stderr         |  20 +--
 .../bad-reg.loongarch64_lp64d.stderr          |  12 +-
 .../bad-reg.loongarch64_lp64s.stderr          |  20 +--
 tests/ui/asm/loongarch/bad-reg.rs             |   1 -
 47 files changed, 157 insertions(+), 595 deletions(-)
 rename src/ci/docker/host-aarch64/{aarch64-gnu-llvm-19 => aarch64-gnu-llvm-20}/Dockerfile (92%)
 delete mode 100644 src/ci/docker/host-x86_64/x86_64-gnu-llvm-19/Dockerfile
 delete mode 100644 tests/ui/abi/sparcv8plus-llvm19.rs
 delete mode 100644 tests/ui/abi/sparcv8plus-llvm19.sparc.stderr
 delete mode 100644 tests/ui/abi/sparcv8plus-llvm19.sparc_cpu_v9.stderr
 delete mode 100644 tests/ui/abi/sparcv8plus-llvm19.sparc_cpu_v9_feature_v8plus.stderr
 delete mode 100644 tests/ui/abi/sparcv8plus-llvm19.sparc_feature_v8plus.stderr
 delete mode 100644 tests/ui/abi/sparcv8plus-llvm19.sparcv8plus.stderr

diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
index 7d0691366e602..0f17cc9063a87 100644
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -1091,16 +1091,11 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         ty: Ty<'tcx>,
         lhs: Self::Value,
         rhs: Self::Value,
-    ) -> Option<Self::Value> {
-        // FIXME: See comment on the definition of `three_way_compare`.
-        if crate::llvm_util::get_version() < (20, 0, 0) {
-            return None;
-        }
-
+    ) -> Self::Value {
         let size = ty.primitive_size(self.tcx);
         let name = if ty.is_signed() { "llvm.scmp" } else { "llvm.ucmp" };
 
-        Some(self.call_intrinsic(name, &[self.type_i8(), self.type_ix(size.bits())], &[lhs, rhs]))
+        self.call_intrinsic(name, &[self.type_i8(), self.type_ix(size.bits())], &[lhs, rhs])
     }
 
     /* Miscellaneous instructions */
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index a69fa54a54a4d..5f4385c9c6a20 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -172,35 +172,6 @@ pub(crate) unsafe fn create_module<'ll>(
     let mut target_data_layout = sess.target.data_layout.to_string();
     let llvm_version = llvm_util::get_version();
 
-    if llvm_version < (20, 0, 0) {
-        if sess.target.arch == "aarch64" || sess.target.arch.starts_with("arm64") {
-            // LLVM 20 defines three additional address spaces for alternate
-            // pointer kinds used in Windows.
-            // See https://github.com/llvm/llvm-project/pull/111879
-            target_data_layout =
-                target_data_layout.replace("-p270:32:32-p271:32:32-p272:64:64", "");
-        }
-        if sess.target.arch.starts_with("sparc") {
-            // LLVM 20 updates the sparc layout to correctly align 128 bit integers to 128 bit.
-            // See https://github.com/llvm/llvm-project/pull/106951
-            target_data_layout = target_data_layout.replace("-i128:128", "");
-        }
-        if sess.target.arch.starts_with("mips64") {
-            // LLVM 20 updates the mips64 layout to correctly align 128 bit integers to 128 bit.
-            // See https://github.com/llvm/llvm-project/pull/112084
-            target_data_layout = target_data_layout.replace("-i128:128", "");
-        }
-        if sess.target.arch.starts_with("powerpc64") {
-            // LLVM 20 updates the powerpc64 layout to correctly align 128 bit integers to 128 bit.
-            // See https://github.com/llvm/llvm-project/pull/118004
-            target_data_layout = target_data_layout.replace("-i128:128", "");
-        }
-        if sess.target.arch.starts_with("wasm32") || sess.target.arch.starts_with("wasm64") {
-            // LLVM 20 updates the wasm(32|64) layout to correctly align 128 bit integers to 128 bit.
-            // See https://github.com/llvm/llvm-project/pull/119204
-            target_data_layout = target_data_layout.replace("-i128:128", "");
-        }
-    }
     if llvm_version < (21, 0, 0) {
         if sess.target.arch == "nvptx64" {
             // LLVM 21 updated the default layout on nvptx: https://github.com/llvm/llvm-project/pull/124961
diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index d927ffd78c298..8461c8b03d5a4 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -246,9 +246,6 @@ pub(crate) fn to_llvm_features<'a>(sess: &Session, s: &'a str) -> Option<LLVMFea
         ("aarch64", "pmuv3") => Some(LLVMFeature::new("perfmon")),
         ("aarch64", "paca") => Some(LLVMFeature::new("pauth")),
         ("aarch64", "pacg") => Some(LLVMFeature::new("pauth")),
-        // Before LLVM 20 those two features were packaged together as b16b16
-        ("aarch64", "sve-b16b16") if get_version().0 < 20 => Some(LLVMFeature::new("b16b16")),
-        ("aarch64", "sme-b16b16") if get_version().0 < 20 => Some(LLVMFeature::new("b16b16")),
         ("aarch64", "flagm2") => Some(LLVMFeature::new("altnzcv")),
         // Rust ties fp and neon together.
         ("aarch64", "neon") => Some(LLVMFeature::with_dependencies(
@@ -262,57 +259,17 @@ pub(crate) fn to_llvm_features<'a>(sess: &Session, s: &'a str) -> Option<LLVMFea
         // Filter out features that are not supported by the current LLVM version
         ("aarch64", "fpmr") => None, // only existed in 18
         ("arm", "fp16") => Some(LLVMFeature::new("fullfp16")),
-        // NVPTX targets added in LLVM 20
-        ("nvptx64", "sm_100") if get_version().0 < 20 => None,
-        ("nvptx64", "sm_100a") if get_version().0 < 20 => None,
-        ("nvptx64", "sm_101") if get_version().0 < 20 => None,
-        ("nvptx64", "sm_101a") if get_version().0 < 20 => None,
-        ("nvptx64", "sm_120") if get_version().0 < 20 => None,
-        ("nvptx64", "sm_120a") if get_version().0 < 20 => None,
-        ("nvptx64", "ptx86") if get_version().0 < 20 => None,
-        ("nvptx64", "ptx87") if get_version().0 < 20 => None,
         // Filter out features that are not supported by the current LLVM version
-        ("loongarch64", "div32" | "lam-bh" | "lamcas" | "ld-seq-sa" | "scq")
-            if get_version().0 < 20 =>
-        {
-            None
-        }
         ("loongarch32" | "loongarch64", "32s") if get_version().0 < 21 => None,
-        // Filter out features that are not supported by the current LLVM version
-        ("riscv32" | "riscv64", "zacas" | "rva23u64" | "supm") if get_version().0 < 20 => None,
-        (
-            "s390x",
-            "message-security-assist-extension12"
-            | "concurrent-functions"
-            | "miscellaneous-extensions-4"
-            | "vector-enhancements-3"
-            | "vector-packed-decimal-enhancement-3",
-        ) if get_version().0 < 20 => None,
         // Enable the evex512 target feature if an avx512 target feature is enabled.
         ("x86", s) if s.starts_with("avx512") => Some(LLVMFeature::with_dependencies(
             s,
             smallvec![TargetFeatureFoldStrength::EnableOnly("evex512")],
         )),
-        // Support for `wide-arithmetic` will first land in LLVM 20 as part of
-        // llvm/llvm-project#111598
-        ("wasm32" | "wasm64", "wide-arithmetic") if get_version() < (20, 0, 0) => None,
         ("sparc", "leoncasa") => Some(LLVMFeature::new("hasleoncasa")),
-        // In LLVM 19, there is no `v8plus` feature and `v9` means "SPARC-V9 instruction available and SPARC-V8+ ABI used".
-        // https://github.com/llvm/llvm-project/blob/llvmorg-19.1.0/llvm/lib/Target/Sparc/MCTargetDesc/SparcELFObjectWriter.cpp#L27-L28
-        // Before LLVM 19, there was no `v8plus` feature and `v9` means "SPARC-V9 instruction available".
-        // https://github.com/llvm/llvm-project/blob/llvmorg-18.1.0/llvm/lib/Target/Sparc/MCTargetDesc/SparcELFObjectWriter.cpp#L26
-        ("sparc", "v8plus") if get_version().0 == 19 => Some(LLVMFeature::new("v9")),
         ("powerpc", "power8-crypto") => Some(LLVMFeature::new("crypto")),
-        // These new `amx` variants and `movrs` were introduced in LLVM20
-        ("x86", "amx-avx512" | "amx-fp8" | "amx-movrs" | "amx-tf32" | "amx-transpose")
-            if get_version().0 < 20 =>
-        {
-            None
-        }
-        ("x86", "movrs") if get_version().0 < 20 => None,
         ("x86", "avx10.1") => Some(LLVMFeature::new("avx10.1-512")),
-        ("x86", "avx10.2") if get_version().0 < 20 => None,
-        ("x86", "avx10.2") if get_version().0 >= 20 => Some(LLVMFeature::new("avx10.2-512")),
+        ("x86", "avx10.2") => Some(LLVMFeature::new("avx10.2-512")),
         ("x86", "apxf") => Some(LLVMFeature::with_dependencies(
             "egpr",
             smallvec![
@@ -716,17 +673,7 @@ pub(crate) fn global_llvm_features(
     };
 
     // Features implied by an implicit or explicit `--target`.
-    features.extend(
-        sess.target
-            .features
-            .split(',')
-            .filter(|v| !v.is_empty())
-            // Drop +v8plus feature introduced in LLVM 20.
-            // (Hard-coded target features do not go through `to_llvm_feature` since they already
-            // are LLVM feature names, hence we need a special case here.)
-            .filter(|v| *v != "+v8plus" || get_version() >= (20, 0, 0))
-            .map(String::from),
-    );
+    features.extend(sess.target.features.split(',').filter(|v| !v.is_empty()).map(String::from));
 
     if wants_wasm_eh(sess) && sess.panic_strategy() == PanicStrategy::Unwind {
         features.push("+exception-handling".into());
diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
index f8755874014d3..4c9bb7cf8a8f9 100644
--- a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -901,36 +901,8 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 }
             }
             mir::BinOp::Cmp => {
-                use std::cmp::Ordering;
                 assert!(!is_float);
-                if let Some(value) = bx.three_way_compare(lhs_ty, lhs, rhs) {
-                    return value;
-                }
-                let pred = |op| base::bin_op_to_icmp_predicate(op, is_signed);
-                if bx.cx().tcx().sess.opts.optimize == OptLevel::No {
-                    // FIXME: This actually generates tighter assembly, and is a classic trick
-                    // <https://graphics.stanford.edu/~seander/bithacks.html#CopyIntegerSign>
-                    // However, as of 2023-11 it optimizes worse in things like derived
-                    // `PartialOrd`, so only use it in debug for now. Once LLVM can handle it
-                    // better (see <https://github.com/llvm/llvm-project/issues/73417>), it'll
-                    // be worth trying it in optimized builds as well.
-                    let is_gt = bx.icmp(pred(mir::BinOp::Gt), lhs, rhs);
-                    let gtext = bx.zext(is_gt, bx.type_i8());
-                    let is_lt = bx.icmp(pred(mir::BinOp::Lt), lhs, rhs);
-                    let ltext = bx.zext(is_lt, bx.type_i8());
-                    bx.unchecked_ssub(gtext, ltext)
-                } else {
-                    // These operations are those expected by `tests/codegen-llvm/integer-cmp.rs`,
-                    // from <https://github.com/rust-lang/rust/pull/63767>.
-                    let is_lt = bx.icmp(pred(mir::BinOp::Lt), lhs, rhs);
-                    let is_ne = bx.icmp(pred(mir::BinOp::Ne), lhs, rhs);
-                    let ge = bx.select(
-                        is_ne,
-                        bx.cx().const_i8(Ordering::Greater as i8),
-                        bx.cx().const_i8(Ordering::Equal as i8),
-                    );
-                    bx.select(is_lt, bx.cx().const_i8(Ordering::Less as i8), ge)
-                }
+                bx.three_way_compare(lhs_ty, lhs, rhs)
             }
             mir::BinOp::AddWithOverflow
             | mir::BinOp::SubWithOverflow
diff --git a/compiler/rustc_codegen_ssa/src/traits/builder.rs b/compiler/rustc_codegen_ssa/src/traits/builder.rs
index f417d1a7bf724..422fa715de109 100644
--- a/compiler/rustc_codegen_ssa/src/traits/builder.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/builder.rs
@@ -3,6 +3,7 @@ use std::ops::Deref;
 
 use rustc_abi::{Align, Scalar, Size, WrappingRange};
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrs;
+use rustc_middle::mir;
 use rustc_middle::ty::layout::{FnAbiOf, LayoutOf, TyAndLayout};
 use rustc_middle::ty::{AtomicOrdering, Instance, Ty};
 use rustc_session::config::OptLevel;
@@ -405,15 +406,38 @@ pub trait BuilderMethods<'a, 'tcx>:
     fn fcmp(&mut self, op: RealPredicate, lhs: Self::Value, rhs: Self::Value) -> Self::Value;
 
     /// Returns `-1` if `lhs < rhs`, `0` if `lhs == rhs`, and `1` if `lhs > rhs`.
-    // FIXME: Move the default implementation from `codegen_scalar_binop` into this method and
-    // remove the `Option` return once LLVM 20 is the minimum version.
     fn three_way_compare(
         &mut self,
-        _ty: Ty<'tcx>,
-        _lhs: Self::Value,
-        _rhs: Self::Value,
-    ) -> Option<Self::Value> {
-        None
+        ty: Ty<'tcx>,
+        lhs: Self::Value,
+        rhs: Self::Value,
+    ) -> Self::Value {
+        use std::cmp::Ordering;
+        let pred = |op| crate::base::bin_op_to_icmp_predicate(op, ty.is_signed());
+        if self.cx().sess().opts.optimize == OptLevel::No {
+            // FIXME: This actually generates tighter assembly, and is a classic trick
+            // <https://graphics.stanford.edu/~seander/bithacks.html#CopyIntegerSign>
+            // However, as of 2023-11 it optimizes worse in things like derived
+            // `PartialOrd`, so only use it in debug for now. Once LLVM can handle it
+            // better (see <https://github.com/llvm/llvm-project/issues/73417>), it'll
+            // be worth trying it in optimized builds as well.
+            let is_gt = self.icmp(pred(mir::BinOp::Gt), lhs, rhs);
+            let gtext = self.zext(is_gt, self.type_i8());
+            let is_lt = self.icmp(pred(mir::BinOp::Lt), lhs, rhs);
+            let ltext = self.zext(is_lt, self.type_i8());
+            self.unchecked_ssub(gtext, ltext)
+        } else {
+            // These operations are those expected by `tests/codegen-llvm/integer-cmp.rs`,
+            // from <https://github.com/rust-lang/rust/pull/63767>.
+            let is_lt = self.icmp(pred(mir::BinOp::Lt), lhs, rhs);
+            let is_ne = self.icmp(pred(mir::BinOp::Ne), lhs, rhs);
+            let ge = self.select(
+                is_ne,
+                self.cx().const_i8(Ordering::Greater as i8),
+                self.cx().const_i8(Ordering::Equal as i8),
+            );
+            self.select(is_lt, self.cx().const_i8(Ordering::Less as i8), ge)
+        }
     }
 
     fn memcpy(
diff --git a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
index 91d11ba317a61..ab5d5c03e817a 100644
--- a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
@@ -344,7 +344,6 @@ extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
   Options.EmitStackSizeSection = EmitStackSizeSection;
 
   if (ArgsCstrBuff != nullptr) {
-#if LLVM_VERSION_GE(20, 0)
     size_t buffer_offset = 0;
     assert(ArgsCstrBuff[ArgsCstrBuffLen - 1] == '\0');
     auto Arg0 = std::string(ArgsCstrBuff);
@@ -362,33 +361,6 @@ extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
     OS.flush();
     Options.MCOptions.Argv0 = Arg0;
     Options.MCOptions.CommandlineArgs = CommandlineArgs;
-#else
-    size_t buffer_offset = 0;
-    assert(ArgsCstrBuff[ArgsCstrBuffLen - 1] == '\0');
-
-    const size_t arg0_len = std::strlen(ArgsCstrBuff);
-    char *arg0 = new char[arg0_len + 1];
-    memcpy(arg0, ArgsCstrBuff, arg0_len);
-    arg0[arg0_len] = '\0';
-    buffer_offset += arg0_len + 1;
-
-    const size_t num_cmd_arg_strings = std::count(
-        &ArgsCstrBuff[buffer_offset], &ArgsCstrBuff[ArgsCstrBuffLen], '\0');
-
-    std::string *cmd_arg_strings = new std::string[num_cmd_arg_strings];
-    for (size_t i = 0; i < num_cmd_arg_strings; ++i) {
-      assert(buffer_offset < ArgsCstrBuffLen);
-      const size_t len = std::strlen(ArgsCstrBuff + buffer_offset);
-      cmd_arg_strings[i] = std::string(&ArgsCstrBuff[buffer_offset], len);
-      buffer_offset += len + 1;
-    }
-
-    assert(buffer_offset == ArgsCstrBuffLen);
-
-    Options.MCOptions.Argv0 = arg0;
-    Options.MCOptions.CommandLineArgs =
-        llvm::ArrayRef<std::string>(cmd_arg_strings, num_cmd_arg_strings);
-#endif
   }
 
 #if LLVM_VERSION_GE(21, 0)
@@ -402,12 +374,6 @@ extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
 }
 
 extern "C" void LLVMRustDisposeTargetMachine(LLVMTargetMachineRef TM) {
-#if LLVM_VERSION_LT(20, 0)
-  MCTargetOptions &MCOptions = unwrap(TM)->Options.MCOptions;
-  delete[] MCOptions.Argv0;
-  delete[] MCOptions.CommandLineArgs.data();
-#endif
-
   delete unwrap(TM);
 }
 
@@ -688,14 +654,9 @@ extern "C" LLVMRustResult LLVMRustOptimize(
   // the PassBuilder does not create a pipeline.
   std::vector<std::function<void(ModulePassManager &, OptimizationLevel)>>
       PipelineStartEPCallbacks;
-#if LLVM_VERSION_GE(20, 0)
   std::vector<std::function<void(ModulePassManager &, OptimizationLevel,
                                  ThinOrFullLTOPhase)>>
       OptimizerLastEPCallbacks;
-#else
-  std::vector<std::function<void(ModulePassManager &, OptimizationLevel)>>
-      OptimizerLastEPCallbacks;
-#endif
 
   if (!IsLinkerPluginLTO && SanitizerOptions && SanitizerOptions->SanitizeCFI &&
       !NoPrepopulatePasses) {
@@ -747,12 +708,8 @@ extern "C" LLVMRustResult LLVMRustOptimize(
           SanitizerOptions->SanitizeDataFlowABIList +
               SanitizerOptions->SanitizeDataFlowABIListLen);
       OptimizerLastEPCallbacks.push_back(
-#if LLVM_VERSION_GE(20, 0)
           [ABIListFiles](ModulePassManager &MPM, OptimizationLevel Level,
                          ThinOrFullLTOPhase phase) {
-#else
-          [ABIListFiles](ModulePassManager &MPM, OptimizationLevel Level) {
-#endif
             MPM.addPass(DataFlowSanitizerPass(ABIListFiles));
           });
     }
@@ -763,66 +720,48 @@ extern "C" LLVMRustResult LLVMRustOptimize(
           SanitizerOptions->SanitizeMemoryRecover,
           /*CompileKernel=*/false,
           /*EagerChecks=*/true);
-      OptimizerLastEPCallbacks.push_back(
-#if LLVM_VERSION_GE(20, 0)
-          [Options](ModulePassManager &MPM, OptimizationLevel Level,
-                    ThinOrFullLTOPhase phase) {
-#else
-          [Options](ModulePassManager &MPM, OptimizationLevel Level) {
-#endif
-            MPM.addPass(MemorySanitizerPass(Options));
-          });
+      OptimizerLastEPCallbacks.push_back([Options](ModulePassManager &MPM,
+                                                   OptimizationLevel Level,
+                                                   ThinOrFullLTOPhase phase) {
+        MPM.addPass(MemorySanitizerPass(Options));
+      });
     }
 
     if (SanitizerOptions->SanitizeThread) {
-      OptimizerLastEPCallbacks.push_back(
-#if LLVM_VERSION_GE(20, 0)
-          [](ModulePassManager &MPM, OptimizationLevel Level,
-             ThinOrFullLTOPhase phase) {
-#else
-          [](ModulePassManager &MPM, OptimizationLevel Level) {
-#endif
-            MPM.addPass(ModuleThreadSanitizerPass());
-            MPM.addPass(
-                createModuleToFunctionPassAdaptor(ThreadSanitizerPass()));
-          });
+      OptimizerLastEPCallbacks.push_back([](ModulePassManager &MPM,
+                                            OptimizationLevel Level,
+                                            ThinOrFullLTOPhase phase) {
+        MPM.addPass(ModuleThreadSanitizerPass());
+        MPM.addPass(createModuleToFunctionPassAdaptor(ThreadSanitizerPass()));
+      });
     }
 
     if (SanitizerOptions->SanitizeAddress ||
         SanitizerOptions->SanitizeKernelAddress) {
-      OptimizerLastEPCallbacks.push_back(
-#if LLVM_VERSION_GE(20, 0)
-          [SanitizerOptions, TM](ModulePassManager &MPM,
-                                 OptimizationLevel Level,
-                                 ThinOrFullLTOPhase phase) {
-#else
-          [SanitizerOptions, TM](ModulePassManager &MPM,
-                                 OptimizationLevel Level) {
-#endif
-            auto CompileKernel = SanitizerOptions->SanitizeKernelAddress;
-            AddressSanitizerOptions opts = AddressSanitizerOptions{
-                CompileKernel,
-                SanitizerOptions->SanitizeAddressRecover ||
-                    SanitizerOptions->SanitizeKernelAddressRecover,
-                /*UseAfterScope=*/true,
-                AsanDetectStackUseAfterReturnMode::Runtime,
-            };
-            MPM.addPass(AddressSanitizerPass(
-                opts,
-                /*UseGlobalGC*/ true,
-                // UseOdrIndicator should be false on windows machines
-                // https://reviews.llvm.org/D137227
-                !TM->getTargetTriple().isOSWindows()));
-          });
+      OptimizerLastEPCallbacks.push_back([SanitizerOptions,
+                                          TM](ModulePassManager &MPM,
+                                              OptimizationLevel Level,
+                                              ThinOrFullLTOPhase phase) {
+        auto CompileKernel = SanitizerOptions->SanitizeKernelAddress;
+        AddressSanitizerOptions opts = AddressSanitizerOptions{
+            CompileKernel,
+            SanitizerOptions->SanitizeAddressRecover ||
+                SanitizerOptions->SanitizeKernelAddressRecover,
+            /*UseAfterScope=*/true,
+            AsanDetectStackUseAfterReturnMode::Runtime,
+        };
+        MPM.addPass(
+            AddressSanitizerPass(opts,
+                                 /*UseGlobalGC*/ true,
+                                 // UseOdrIndicator should be false on windows
+                                 // machines https://reviews.llvm.org/D137227
+                                 !TM->getTargetTriple().isOSWindows()));
+      });
     }
     if (SanitizerOptions->SanitizeHWAddress) {
       OptimizerLastEPCallbacks.push_back(
-#if LLVM_VERSION_GE(20, 0)
           [SanitizerOptions](ModulePassManager &MPM, OptimizationLevel Level,
                              ThinOrFullLTOPhase phase) {
-#else
-          [SanitizerOptions](ModulePassManager &MPM, OptimizationLevel Level) {
-#endif
             HWAddressSanitizerOptions opts(
                 /*CompileKernel=*/false,
                 SanitizerOptions->SanitizeHWAddressRecover,
@@ -904,11 +843,7 @@ extern "C" LLVMRustResult LLVMRustOptimize(
     for (const auto &C : PipelineStartEPCallbacks)
       C(MPM, OptLevel);
     for (const auto &C : OptimizerLastEPCallbacks)
-#if LLVM_VERSION_GE(20, 0)
       C(MPM, OptLevel, ThinOrFullLTOPhase::None);
-#else
-      C(MPM, OptLevel);
-#endif
   }
 
   if (ExtraPassesLen) {
@@ -1185,11 +1120,7 @@ struct LLVMRustThinLTOData {
 
   // Not 100% sure what these are, but they impact what's internalized and
   // what's inlined across modules, I believe.
-#if LLVM_VERSION_GE(20, 0)
   FunctionImporter::ImportListsTy ImportLists;
-#else
-  DenseMap<StringRef, FunctionImporter::ImportMapTy> ImportLists;
-#endif
   DenseMap<StringRef, FunctionImporter::ExportSetTy> ExportLists;
   DenseMap<StringRef, GVSummaryMapTy> ModuleToDefinedGVSummaries;
   StringMap<std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>> ResolvedODR;
@@ -1531,13 +1462,8 @@ 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
 #if LLVM_VERSION_GE(21, 0)
@@ -1556,15 +1482,9 @@ extern "C" void LLVMRustComputeLTOCacheKey(RustStringRef KeyOut,
         GlobalValue::getGUID(GlobalValue::dropLLVMManglingEscape(Name)));
 #endif
 
-#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
 
   auto OS = RawRustStringOstream(KeyOut);
   OS << Key.str();
diff --git a/src/bootstrap/src/core/build_steps/llvm.rs b/src/bootstrap/src/core/build_steps/llvm.rs
index 83ed7430c397e..d43d261ad6c3f 100644
--- a/src/bootstrap/src/core/build_steps/llvm.rs
+++ b/src/bootstrap/src/core/build_steps/llvm.rs
@@ -619,11 +619,11 @@ fn check_llvm_version(builder: &Builder<'_>, llvm_config: &Path) {
     let version = get_llvm_version(builder, llvm_config);
     let mut parts = version.split('.').take(2).filter_map(|s| s.parse::<u32>().ok());
     if let (Some(major), Some(_minor)) = (parts.next(), parts.next())
-        && major >= 19
+        && major >= 20
     {
         return;
     }
-    panic!("\n\nbad LLVM version: {version}, need >=19\n\n")
+    panic!("\n\nbad LLVM version: {version}, need >=20\n\n")
 }
 
 fn configure_cmake(
diff --git a/src/ci/docker/README.md b/src/ci/docker/README.md
index 488a6a2bce122..4ee02e9bf0055 100644
--- a/src/ci/docker/README.md
+++ b/src/ci/docker/README.md
@@ -14,9 +14,9 @@ To run a specific CI job locally, you can use the `citool` Rust crate:
 cargo run --manifest-path src/ci/citool/Cargo.toml run-local <job-name>
 ```
 
-For example, to run the `x86_64-gnu-llvm-19-1` job:
+For example, to run the `x86_64-gnu-llvm-20-1` job:
 ```
-cargo run --manifest-path src/ci/citool/Cargo.toml run-local x86_64-gnu-llvm-19-1
+cargo run --manifest-path src/ci/citool/Cargo.toml run-local x86_64-gnu-llvm-20-1
 ```
 
 The job will output artifacts in an `obj/<image-name>` dir at the root of a repository. Note
@@ -27,10 +27,10 @@ Docker image executed in the given CI job.
 while locally, to the `obj/<image-name>` directory. This is primarily to prevent
 strange linker errors when using multiple Docker images.
 
-For some Linux workflows (for example `x86_64-gnu-llvm-19-N`), the process is more involved. You will need to see which script is executed for the given workflow inside the [`jobs.yml`](../github-actions/jobs.yml) file and pass it through the `DOCKER_SCRIPT` environment variable. For example, to reproduce the `x86_64-gnu-llvm-19-3` workflow, you can run the following script:
+For some Linux workflows (for example `x86_64-gnu-llvm-20-N`), the process is more involved. You will need to see which script is executed for the given workflow inside the [`jobs.yml`](../github-actions/jobs.yml) file and pass it through the `DOCKER_SCRIPT` environment variable. For example, to reproduce the `x86_64-gnu-llvm-20-3` workflow, you can run the following script:
 
 ```
-DOCKER_SCRIPT=x86_64-gnu-llvm3.sh ./src/ci/docker/run.sh x86_64-gnu-llvm-19
+DOCKER_SCRIPT=x86_64-gnu-llvm3.sh ./src/ci/docker/run.sh x86_64-gnu-llvm-20
 ```
 
 ## Local Development
diff --git a/src/ci/docker/host-aarch64/aarch64-gnu-llvm-19/Dockerfile b/src/ci/docker/host-aarch64/aarch64-gnu-llvm-20/Dockerfile
similarity index 92%
rename from src/ci/docker/host-aarch64/aarch64-gnu-llvm-19/Dockerfile
rename to src/ci/docker/host-aarch64/aarch64-gnu-llvm-20/Dockerfile
index e73fbe506f788..adbb1f03378a6 100644
--- a/src/ci/docker/host-aarch64/aarch64-gnu-llvm-19/Dockerfile
+++ b/src/ci/docker/host-aarch64/aarch64-gnu-llvm-20/Dockerfile
@@ -1,4 +1,4 @@
-FROM ubuntu:24.10
+FROM ubuntu:25.04
 
 ARG DEBIAN_FRONTEND=noninteractive
 
@@ -15,8 +15,8 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
   cmake \
   sudo \
   gdb \
-  llvm-19-tools \
-  llvm-19-dev \
+  llvm-20-tools \
+  llvm-20-dev \
   libedit-dev \
   libssl-dev \
   pkg-config \
@@ -43,7 +43,7 @@ ENV EXTERNAL_LLVM 1
 # Using llvm-link-shared due to libffi issues -- see #34486
 ENV RUST_CONFIGURE_ARGS \
       --build=aarch64-unknown-linux-gnu \
-      --llvm-root=/usr/lib/llvm-19 \
+      --llvm-root=/usr/lib/llvm-20 \
       --enable-llvm-link-shared \
       --set rust.randomize-layout=true \
       --set rust.thin-lto-import-instr-limit=10
diff --git a/src/ci/docker/host-x86_64/x86_64-gnu-llvm-19/Dockerfile b/src/ci/docker/host-x86_64/x86_64-gnu-llvm-19/Dockerfile
deleted file mode 100644
index 5cba7c564f164..0000000000000
--- a/src/ci/docker/host-x86_64/x86_64-gnu-llvm-19/Dockerfile
+++ /dev/null
@@ -1,66 +0,0 @@
-FROM ubuntu:24.10
-
-ARG DEBIAN_FRONTEND=noninteractive
-
-RUN apt-get update && apt-get install -y --no-install-recommends \
-  bzip2 \
-  g++ \
-  gcc-multilib \
-  make \
-  ninja-build \
-  file \
-  curl \
-  ca-certificates \
-  python3 \
-  git \
-  cmake \
-  sudo \
-  gdb \
-  llvm-19-tools \
-  llvm-19-dev \
-  libedit-dev \
-  libssl-dev \
-  pkg-config \
-  zlib1g-dev \
-  xz-utils \
-  nodejs \
-  mingw-w64 \
-  # libgccjit dependencies
-  flex \
-  libmpfr-dev \
-  libgmp-dev \
-  libmpc3 \
-  libmpc-dev \
-  && rm -rf /var/lib/apt/lists/*
-
-# Install powershell (universal package) so we can test x.ps1 on Linux
-# FIXME: need a "universal" version that supports libicu74, but for now it still works to ignore that dep.
-RUN curl -sL "https://github.com/PowerShell/PowerShell/releases/download/v7.3.1/powershell_7.3.1-1.deb_amd64.deb" > powershell.deb && \
-    dpkg --ignore-depends=libicu72 -i powershell.deb && \
-    rm -f powershell.deb
-
-COPY scripts/sccache.sh /scripts/
-RUN sh /scripts/sccache.sh
-
-# We are disabling CI LLVM since this builder is intentionally using a host
-# LLVM, rather than the typical src/llvm-project LLVM.
-ENV NO_DOWNLOAD_CI_LLVM 1
-ENV EXTERNAL_LLVM 1
-
-# Using llvm-link-shared due to libffi issues -- see #34486
-ENV RUST_CONFIGURE_ARGS \
-      --build=x86_64-unknown-linux-gnu \
-      --llvm-root=/usr/lib/llvm-19 \
-      --enable-llvm-link-shared \
-      --set rust.randomize-layout=true \
-      --set rust.thin-lto-import-instr-limit=10
-
-COPY scripts/shared.sh /scripts/
-
-COPY scripts/x86_64-gnu-llvm.sh /scripts/
-COPY scripts/x86_64-gnu-llvm2.sh /scripts/
-COPY scripts/x86_64-gnu-llvm3.sh /scripts/
-COPY scripts/stage_2_test_set1.sh /scripts/
-COPY scripts/stage_2_test_set2.sh /scripts/
-
-ENV SCRIPT "Must specify DOCKER_SCRIPT for this image"
diff --git a/src/ci/github-actions/jobs.yml b/src/ci/github-actions/jobs.yml
index 35b9456d37d2f..b3e3fe7d96aab 100644
--- a/src/ci/github-actions/jobs.yml
+++ b/src/ci/github-actions/jobs.yml
@@ -122,19 +122,19 @@ pr:
       # tidy. This speeds up the PR CI job by ~1 minute.
       SKIP_SUBMODULES: src/gcc
     <<: *job-linux-4c
-  - name: x86_64-gnu-llvm-19
+  - name: x86_64-gnu-llvm-20
     env:
       ENABLE_GCC_CODEGEN: "1"
       DOCKER_SCRIPT: x86_64-gnu-llvm.sh
     <<: *job-linux-4c
-  - name: aarch64-gnu-llvm-19-1
+  - name: aarch64-gnu-llvm-20-1
     env:
-      IMAGE: aarch64-gnu-llvm-19
+      IMAGE: aarch64-gnu-llvm-20
       DOCKER_SCRIPT: stage_2_test_set1.sh
     <<: *job-aarch64-linux
-  - name: aarch64-gnu-llvm-19-2
+  - name: aarch64-gnu-llvm-20-2
     env:
-      IMAGE: aarch64-gnu-llvm-19
+      IMAGE: aarch64-gnu-llvm-20
       DOCKER_SCRIPT: stage_2_test_set2.sh
     <<: *job-aarch64-linux
   - name: x86_64-gnu-tools
@@ -397,31 +397,6 @@ auto:
       DOCKER_SCRIPT: x86_64-gnu-llvm3.sh
     <<: *job-linux-4c
 
-  # The x86_64-gnu-llvm-19 job is split into multiple jobs to run tests in parallel.
-  # x86_64-gnu-llvm-19-1 skips tests that run in x86_64-gnu-llvm-19-{2,3}.
-  - name: x86_64-gnu-llvm-19-1
-    env:
-      RUST_BACKTRACE: 1
-      IMAGE: x86_64-gnu-llvm-19
-      DOCKER_SCRIPT: stage_2_test_set2.sh
-    <<: *job-linux-4c
-
-  # Skip tests that run in x86_64-gnu-llvm-19-{1,3}
-  - name: x86_64-gnu-llvm-19-2
-    env:
-      RUST_BACKTRACE: 1
-      IMAGE: x86_64-gnu-llvm-19
-      DOCKER_SCRIPT: x86_64-gnu-llvm2.sh
-    <<: *job-linux-4c
-
-  # Skip tests that run in x86_64-gnu-llvm-19-{1,2}
-  - name: x86_64-gnu-llvm-19-3
-    env:
-      RUST_BACKTRACE: 1
-      IMAGE: x86_64-gnu-llvm-19
-      DOCKER_SCRIPT: x86_64-gnu-llvm3.sh
-    <<: *job-linux-4c
-
   - name: x86_64-gnu-nopt
     <<: *job-linux-4c
 
diff --git a/tests/assembly-llvm/riscv-soft-abi-with-float-features.rs b/tests/assembly-llvm/riscv-soft-abi-with-float-features.rs
index 72cbd3841c123..085ea9facd065 100644
--- a/tests/assembly-llvm/riscv-soft-abi-with-float-features.rs
+++ b/tests/assembly-llvm/riscv-soft-abi-with-float-features.rs
@@ -2,9 +2,6 @@
 //@ assembly-output: emit-asm
 //@ compile-flags: --target riscv64imac-unknown-none-elf -Ctarget-feature=+f,+d
 //@ needs-llvm-components: riscv
-//@ revisions: LLVM-PRE-20 LLVM-POST-20
-//@ [LLVM-PRE-20] max-llvm-major-version: 19
-//@ [LLVM-POST-20] min-llvm-version: 20
 
 #![feature(no_core, lang_items, f16)]
 #![crate_type = "lib"]
@@ -28,11 +25,8 @@ pub extern "C" fn read_f16(x: &f16) -> f16 {
 // CHECK-LABEL: read_f32
 #[no_mangle]
 pub extern "C" fn read_f32(x: &f32) -> f32 {
-    // LLVM-PRE-20: flw fa5, 0(a0)
-    // LLVM-PRE-20-NEXT: fmv.x.w a0, fa5
-    // LLVM-PRE-20-NEXT: ret
-    // LLVM-POST-20: lw a0, 0(a0)
-    // LLVM-POST-20-NEXT: ret
+    // CHECK: lw a0, 0(a0)
+    // CHECK-NEXT: ret
     *x
 }
 
diff --git a/tests/assembly-llvm/x86_64-bigint-helpers.rs b/tests/assembly-llvm/x86_64-bigint-helpers.rs
index c5efda58fd668..64aa025723856 100644
--- a/tests/assembly-llvm/x86_64-bigint-helpers.rs
+++ b/tests/assembly-llvm/x86_64-bigint-helpers.rs
@@ -2,7 +2,6 @@
 //@ assembly-output: emit-asm
 //@ compile-flags: --crate-type=lib -Copt-level=3 -C target-cpu=x86-64-v4
 //@ compile-flags: -C llvm-args=-x86-asm-syntax=intel
-//@ min-llvm-version: 20
 
 #![no_std]
 #![feature(bigint_helper_methods)]
diff --git a/tests/assembly-llvm/x86_64-cmp.rs b/tests/assembly-llvm/x86_64-cmp.rs
index 26c9013d96fc5..7e87171991d4d 100644
--- a/tests/assembly-llvm/x86_64-cmp.rs
+++ b/tests/assembly-llvm/x86_64-cmp.rs
@@ -1,12 +1,6 @@
-//@ revisions: LLVM-PRE-20-DEBUG LLVM-20-DEBUG LLVM-PRE-20-OPTIM LLVM-20-OPTIM
-//@ [LLVM-PRE-20-DEBUG] compile-flags: -C opt-level=0
-//@ [LLVM-PRE-20-DEBUG] max-llvm-major-version: 19
-//@ [LLVM-20-DEBUG] compile-flags: -C opt-level=0
-//@ [LLVM-20-DEBUG] min-llvm-version: 20
-//@ [LLVM-PRE-20-OPTIM] compile-flags: -C opt-level=3
-//@ [LLVM-PRE-20-OPTIM] max-llvm-major-version: 19
-//@ [LLVM-20-OPTIM] compile-flags: -C opt-level=3
-//@ [LLVM-20-OPTIM] min-llvm-version: 20
+//@ revisions: DEBUG OPTIM
+//@ [DEBUG] compile-flags: -C opt-level=0
+//@ [OPTIM] compile-flags: -C opt-level=3
 //@ assembly-output: emit-asm
 //@ compile-flags: --crate-type=lib -C llvm-args=-x86-asm-syntax=intel
 //@ only-x86_64
@@ -19,61 +13,31 @@ use std::intrinsics::three_way_compare;
 #[no_mangle]
 // CHECK-LABEL: signed_cmp:
 pub fn signed_cmp(a: i16, b: i16) -> std::cmp::Ordering {
-    // LLVM-PRE-20-DEBUG: cmp
-    // LLVM-PRE-20-DEBUG: setg
-    // LLVM-PRE-20-DEBUG: and
-    // LLVM-PRE-20-DEBUG: cmp
-    // LLVM-PRE-20-DEBUG: setl
-    // LLVM-PRE-20-DEBUG: and
-    // LLVM-PRE-20-DEBUG: sub
+    // DEBUG: sub
+    // DEBUG: setl
+    // DEBUG: setg
+    // DEBUG: sub
+    // DEBUG: ret
     //
-    // LLVM-20-DEBUG: sub
-    // LLVM-20-DEBUG: setl
-    // LLVM-20-DEBUG: setg
-    // LLVM-20-DEBUG: sub
-    // LLVM-20-DEBUG: 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
+    // OPTIM: cmp
+    // OPTIM: setl
+    // OPTIM: setg
+    // OPTIM: sub
+    // OPTIM: ret
     three_way_compare(a, b)
 }
 
 #[no_mangle]
 // CHECK-LABEL: unsigned_cmp:
 pub fn unsigned_cmp(a: u16, b: u16) -> std::cmp::Ordering {
-    // LLVM-PRE-20-DEBUG: cmp
-    // LLVM-PRE-20-DEBUG: seta
-    // LLVM-PRE-20-DEBUG: and
-    // LLVM-PRE-20-DEBUG: cmp
-    // LLVM-PRE-20-DEBUG: setb
-    // LLVM-PRE-20-DEBUG: and
-    // LLVM-PRE-20-DEBUG: sub
-    //
-    // LLVM-20-DEBUG: sub
-    // LLVM-20-DEBUG: seta
-    // LLVM-20-DEBUG: sbb
-    // LLVM-20-DEBUG: 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
+    // DEBUG: sub
+    // DEBUG: seta
+    // DEBUG: sbb
+    // DEBUG: ret
     //
-    // LLVM-20-OPTIM: cmp
-    // LLVM-20-OPTIM: seta
-    // LLVM-20-OPTIM: sbb
-    // LLVM-20-OPTIM: ret
+    // OPTIM: cmp
+    // OPTIM: seta
+    // OPTIM: sbb
+    // OPTIM: ret
     three_way_compare(a, b)
 }
diff --git a/tests/codegen-llvm/comparison-operators-2-struct.rs b/tests/codegen-llvm/comparison-operators-2-struct.rs
index e179066ebfd72..d44f92f511b64 100644
--- a/tests/codegen-llvm/comparison-operators-2-struct.rs
+++ b/tests/codegen-llvm/comparison-operators-2-struct.rs
@@ -1,5 +1,4 @@
 //@ compile-flags: -C opt-level=1
-//@ min-llvm-version: 20
 
 // The `derive(PartialOrd)` for a 2-field type doesn't override `lt`/`le`/`gt`/`ge`.
 // This double-checks that the `Option<Ordering>` intermediate values used
diff --git a/tests/codegen-llvm/comparison-operators-2-tuple.rs b/tests/codegen-llvm/comparison-operators-2-tuple.rs
index 6a7e489c82dd9..37a7c5dfdaf04 100644
--- a/tests/codegen-llvm/comparison-operators-2-tuple.rs
+++ b/tests/codegen-llvm/comparison-operators-2-tuple.rs
@@ -1,5 +1,4 @@
 //@ compile-flags: -C opt-level=1 -Z merge-functions=disabled
-//@ min-llvm-version: 20
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/enum/enum-aggregate.rs b/tests/codegen-llvm/enum/enum-aggregate.rs
index f58d7ef12b661..7d450a89e2e3c 100644
--- a/tests/codegen-llvm/enum/enum-aggregate.rs
+++ b/tests/codegen-llvm/enum/enum-aggregate.rs
@@ -1,5 +1,4 @@
 //@ compile-flags: -Copt-level=0 -Cno-prepopulate-passes
-//@ min-llvm-version: 19
 //@ only-64bit
 
 #![crate_type = "lib"]
diff --git a/tests/codegen-llvm/enum/enum-discriminant-eq.rs b/tests/codegen-llvm/enum/enum-discriminant-eq.rs
index a1ab5e5c6e2ec..68cd58643e84e 100644
--- a/tests/codegen-llvm/enum/enum-discriminant-eq.rs
+++ b/tests/codegen-llvm/enum/enum-discriminant-eq.rs
@@ -1,5 +1,4 @@
 //@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
-//@ min-llvm-version: 20
 //@ only-64bit
 //@ revisions: LLVM20 LLVM21
 //@ [LLVM21] min-llvm-version: 21
diff --git a/tests/codegen-llvm/integer-cmp.rs b/tests/codegen-llvm/integer-cmp.rs
index 812fa8e4a4244..2233a575f8e70 100644
--- a/tests/codegen-llvm/integer-cmp.rs
+++ b/tests/codegen-llvm/integer-cmp.rs
@@ -1,9 +1,6 @@
 // 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] max-llvm-major-version: 19
 //@ compile-flags: -C opt-level=3 -Zmerge-functions=disabled
 
 #![crate_type = "lib"]
@@ -13,50 +10,29 @@ use std::cmp::Ordering;
 // CHECK-LABEL: @cmp_signed
 #[no_mangle]
 pub fn cmp_signed(a: i64, b: i64) -> Ordering {
-    // llvm-20: call{{.*}} i8 @llvm.scmp.i8.i64
-    // llvm-pre-20: icmp slt
-    // llvm-pre-20: icmp ne
-    // llvm-pre-20: zext i1
-    // llvm-pre-20: select i1
+    // CHECK: call{{.*}} i8 @llvm.scmp.i8.i64
     a.cmp(&b)
 }
 
 // CHECK-LABEL: @cmp_unsigned
 #[no_mangle]
 pub fn cmp_unsigned(a: u32, b: u32) -> Ordering {
-    // llvm-20: call{{.*}} i8 @llvm.ucmp.i8.i32
-    // llvm-pre-20: icmp ult
-    // llvm-pre-20: icmp ne
-    // llvm-pre-20: zext i1
-    // llvm-pre-20: select i1
+    // CHECK: call{{.*}} i8 @llvm.ucmp.i8.i32
     a.cmp(&b)
 }
 
 // CHECK-LABEL: @cmp_char
 #[no_mangle]
 pub fn cmp_char(a: char, b: char) -> Ordering {
-    // llvm-20: call{{.*}} i8 @llvm.ucmp.i8.i32
-    // llvm-pre-20: icmp ult
-    // llvm-pre-20: icmp ne
-    // llvm-pre-20: zext i1
-    // llvm-pre-20: select i1
+    // CHECK: call{{.*}} i8 @llvm.ucmp.i8.i32
     a.cmp(&b)
 }
 
 // CHECK-LABEL: @cmp_tuple
 #[no_mangle]
 pub fn cmp_tuple(a: (i16, u16), b: (i16, u16)) -> Ordering {
-    // llvm-20-DAG: call{{.*}} i8 @llvm.ucmp.i8.i16
-    // llvm-20-DAG: call{{.*}} i8 @llvm.scmp.i8.i16
-    // llvm-20: ret i8
-    // llvm-pre-20: icmp slt
-    // llvm-pre-20: icmp ne
-    // llvm-pre-20: zext i1
-    // llvm-pre-20: select i1
-    // llvm-pre-20: icmp ult
-    // llvm-pre-20: icmp ne
-    // llvm-pre-20: zext i1
-    // llvm-pre-20: select i1
-    // llvm-pre-20: select i1
+    // CHECK-DAG: call{{.*}} i8 @llvm.ucmp.i8.i16
+    // CHECK-DAG: call{{.*}} i8 @llvm.scmp.i8.i16
+    // CHECK: ret i8
     a.cmp(&b)
 }
diff --git a/tests/codegen-llvm/intrinsics/three_way_compare.rs b/tests/codegen-llvm/intrinsics/three_way_compare.rs
index 95fcb636f7cab..89bf69561e9a1 100644
--- a/tests/codegen-llvm/intrinsics/three_way_compare.rs
+++ b/tests/codegen-llvm/intrinsics/three_way_compare.rs
@@ -2,7 +2,6 @@
 //@ [DEBUG] compile-flags: -C opt-level=0
 //@ [OPTIM] compile-flags: -C opt-level=3
 //@ compile-flags: -C no-prepopulate-passes
-//@ min-llvm-version: 20
 
 #![crate_type = "lib"]
 #![feature(core_intrinsics)]
diff --git a/tests/codegen-llvm/issues/and-masked-comparison-131162.rs b/tests/codegen-llvm/issues/and-masked-comparison-131162.rs
index bdf021092fda4..fc4b0341a31bc 100644
--- a/tests/codegen-llvm/issues/and-masked-comparison-131162.rs
+++ b/tests/codegen-llvm/issues/and-masked-comparison-131162.rs
@@ -1,5 +1,4 @@
 //@ compile-flags: -Copt-level=3
-//@ min-llvm-version: 20
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/issues/issue-101082.rs b/tests/codegen-llvm/issues/issue-101082.rs
index 8d15921ddb4e1..0c1f90f951a72 100644
--- a/tests/codegen-llvm/issues/issue-101082.rs
+++ b/tests/codegen-llvm/issues/issue-101082.rs
@@ -1,6 +1,5 @@
 //@ compile-flags: -Copt-level=3
 //@ revisions: host x86-64 x86-64-v3
-//@ min-llvm-version: 20
 
 //@[host] ignore-x86_64
 
diff --git a/tests/codegen-llvm/issues/issue-129795.rs b/tests/codegen-llvm/issues/issue-129795.rs
index dc64ee35c97e5..7a928389fab2d 100644
--- a/tests/codegen-llvm/issues/issue-129795.rs
+++ b/tests/codegen-llvm/issues/issue-129795.rs
@@ -1,5 +1,4 @@
 //@ compile-flags: -Copt-level=3
-//@ min-llvm-version: 20
 #![crate_type = "lib"]
 
 // Ensure that a modulo operation with an operand that is known to be
diff --git a/tests/codegen-llvm/issues/iter-max-no-unwrap-failed-129583.rs b/tests/codegen-llvm/issues/iter-max-no-unwrap-failed-129583.rs
index 4d3fa4993ef72..4c4eebeabb5fa 100644
--- a/tests/codegen-llvm/issues/iter-max-no-unwrap-failed-129583.rs
+++ b/tests/codegen-llvm/issues/iter-max-no-unwrap-failed-129583.rs
@@ -3,7 +3,6 @@
 // use a larger value to prevent unrolling.
 
 //@ compile-flags: -Copt-level=3
-//@ min-llvm-version: 20
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen-llvm/issues/looping-over-ne-bytes-133528.rs b/tests/codegen-llvm/issues/looping-over-ne-bytes-133528.rs
index 35acf765d690c..b686f8c4b3acb 100644
--- a/tests/codegen-llvm/issues/looping-over-ne-bytes-133528.rs
+++ b/tests/codegen-llvm/issues/looping-over-ne-bytes-133528.rs
@@ -1,5 +1,4 @@
 //@ compile-flags: -Copt-level=3
-//@ min-llvm-version: 20
 #![crate_type = "lib"]
 
 /// Ensure the function is properly optimized
diff --git a/tests/codegen-llvm/option-niche-eq.rs b/tests/codegen-llvm/option-niche-eq.rs
index 3900cb79aa2ab..e9c3fa2407e7e 100644
--- a/tests/codegen-llvm/option-niche-eq.rs
+++ b/tests/codegen-llvm/option-niche-eq.rs
@@ -1,5 +1,4 @@
 //@ revisions: REGULAR LLVM21
-//@ min-llvm-version: 20
 //@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
 //@ [LLVM21] min-llvm-version: 21
 #![crate_type = "lib"]
diff --git a/tests/codegen-llvm/slice-last-elements-optimization.rs b/tests/codegen-llvm/slice-last-elements-optimization.rs
index d982cda709d47..77fc1d21cd908 100644
--- a/tests/codegen-llvm/slice-last-elements-optimization.rs
+++ b/tests/codegen-llvm/slice-last-elements-optimization.rs
@@ -1,5 +1,4 @@
 //@ compile-flags: -Copt-level=3
-//@ min-llvm-version: 20
 #![crate_type = "lib"]
 
 // This test verifies that LLVM 20 properly optimizes the bounds check
diff --git a/tests/codegen-llvm/swap-small-types.rs b/tests/codegen-llvm/swap-small-types.rs
index 7aa613ae9c227..0799ff76331d3 100644
--- a/tests/codegen-llvm/swap-small-types.rs
+++ b/tests/codegen-llvm/swap-small-types.rs
@@ -1,6 +1,5 @@
 //@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
 //@ only-x86_64
-//@ min-llvm-version: 20
 //@ ignore-std-debug-assertions (`ptr::swap_nonoverlapping` has one which blocks some optimizations)
 
 #![crate_type = "lib"]
diff --git a/tests/codegen-llvm/try_question_mark_nop.rs b/tests/codegen-llvm/try_question_mark_nop.rs
index 398c9a580bc30..a09fa0a49019d 100644
--- a/tests/codegen-llvm/try_question_mark_nop.rs
+++ b/tests/codegen-llvm/try_question_mark_nop.rs
@@ -1,9 +1,6 @@
 //@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
 //@ edition: 2021
 //@ only-x86_64
-//@ revisions: NINETEEN TWENTY
-//@[NINETEEN] exact-llvm-major-version: 19
-//@[TWENTY] min-llvm-version: 20
 
 #![crate_type = "lib"]
 #![feature(try_blocks)]
@@ -17,13 +14,9 @@ pub fn option_nop_match_32(x: Option<u32>) -> Option<u32> {
     // CHECK: start:
     // CHECK-NEXT: [[TRUNC:%.*]] = trunc nuw i32 %0 to i1
 
-    // NINETEEN-NEXT: [[SELECT:%.*]] = select i1 [[TRUNC]], i32 %0, i32 0
-    // NINETEEN-NEXT: [[REG2:%.*]] = insertvalue { i32, i32 } poison, i32 [[SELECT]], 0
-    // NINETEEN-NEXT: [[REG3:%.*]] = insertvalue { i32, i32 } [[REG2]], i32 %1, 1
-
-    // TWENTY-NEXT: [[SELECT:%.*]] = select i1 [[TRUNC]], i32 %1, i32 undef
-    // TWENTY-NEXT: [[REG2:%.*]] = insertvalue { i32, i32 } poison, i32 %0, 0
-    // TWENTY-NEXT: [[REG3:%.*]] = insertvalue { i32, i32 } [[REG2]], i32 [[SELECT]], 1
+    // CHECK-NEXT: [[SELECT:%.*]] = select i1 [[TRUNC]], i32 %1, i32 undef
+    // CHECK-NEXT: [[REG2:%.*]] = insertvalue { i32, i32 } poison, i32 %0, 0
+    // CHECK-NEXT: [[REG3:%.*]] = insertvalue { i32, i32 } [[REG2]], i32 [[SELECT]], 1
 
     // CHECK-NEXT: ret { i32, i32 } [[REG3]]
     match x {
@@ -36,8 +29,8 @@ pub fn option_nop_match_32(x: Option<u32>) -> Option<u32> {
 #[no_mangle]
 pub fn option_nop_traits_32(x: Option<u32>) -> Option<u32> {
     // CHECK: start:
-    // TWENTY-NEXT: %[[IS_SOME:.+]] = trunc nuw i32 %0 to i1
-    // TWENTY-NEXT: select i1 %[[IS_SOME]], i32 %1, i32 undef
+    // CHECK-NEXT: %[[IS_SOME:.+]] = trunc nuw i32 %0 to i1
+    // CHECK-NEXT: select i1 %[[IS_SOME]], i32 %1, i32 undef
     // CHECK-NEXT: insertvalue { i32, i32 }
     // CHECK-NEXT: insertvalue { i32, i32 }
     // CHECK-NEXT: ret { i32, i32 }
@@ -96,13 +89,9 @@ pub fn option_nop_match_64(x: Option<u64>) -> Option<u64> {
     // CHECK: start:
     // CHECK-NEXT: [[TRUNC:%.*]] = trunc nuw i64 %0 to i1
 
-    // NINETEEN-NEXT: [[SELECT:%.*]] = select i1 [[TRUNC]], i64 %0, i64 0
-    // NINETEEN-NEXT: [[REG2:%.*]] = insertvalue { i64, i64 } poison, i64 [[SELECT]], 0
-    // NINETEEN-NEXT: [[REG3:%.*]] = insertvalue { i64, i64 } [[REG2]], i64 %1, 1
-
-    // TWENTY-NEXT: [[SELECT:%.*]] = select i1 [[TRUNC]], i64 %1, i64 undef
-    // TWENTY-NEXT: [[REG2:%.*]] = insertvalue { i64, i64 } poison, i64 %0, 0
-    // TWENTY-NEXT: [[REG3:%.*]] = insertvalue { i64, i64 } [[REG2]], i64 [[SELECT]], 1
+    // CHECK-NEXT: [[SELECT:%.*]] = select i1 [[TRUNC]], i64 %1, i64 undef
+    // CHECK-NEXT: [[REG2:%.*]] = insertvalue { i64, i64 } poison, i64 %0, 0
+    // CHECK-NEXT: [[REG3:%.*]] = insertvalue { i64, i64 } [[REG2]], i64 [[SELECT]], 1
 
     // CHECK-NEXT: ret { i64, i64 } [[REG3]]
     match x {
@@ -115,8 +104,8 @@ pub fn option_nop_match_64(x: Option<u64>) -> Option<u64> {
 #[no_mangle]
 pub fn option_nop_traits_64(x: Option<u64>) -> Option<u64> {
     // CHECK: start:
-    // TWENTY-NEXT: %[[TRUNC:[0-9]+]] = trunc nuw i64 %0 to i1
-    // TWENTY-NEXT: %[[SEL:\.[0-9]+]] = select i1 %[[TRUNC]], i64 %1, i64 undef
+    // CHECK-NEXT: %[[TRUNC:[0-9]+]] = trunc nuw i64 %0 to i1
+    // CHECK-NEXT: %[[SEL:\.[0-9]+]] = select i1 %[[TRUNC]], i64 %1, i64 undef
     // CHECK-NEXT: insertvalue { i64, i64 }
     // CHECK-NEXT: insertvalue { i64, i64 }
     // CHECK-NEXT: ret { i64, i64 }
diff --git a/tests/codegen-llvm/union-aggregate.rs b/tests/codegen-llvm/union-aggregate.rs
index aac66c5dcdd9f..7faa66804feaa 100644
--- a/tests/codegen-llvm/union-aggregate.rs
+++ b/tests/codegen-llvm/union-aggregate.rs
@@ -1,5 +1,4 @@
 //@ compile-flags: -Copt-level=0 -Cno-prepopulate-passes
-//@ min-llvm-version: 19
 //@ only-64bit
 
 #![crate_type = "lib"]
diff --git a/tests/ui/abi/sparcv8plus-llvm19.rs b/tests/ui/abi/sparcv8plus-llvm19.rs
deleted file mode 100644
index 3d6d8568b6e5a..0000000000000
--- a/tests/ui/abi/sparcv8plus-llvm19.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-//@ add-core-stubs
-//@ revisions: sparc sparcv8plus sparc_cpu_v9 sparc_feature_v8plus sparc_cpu_v9_feature_v8plus
-//@[sparc] compile-flags: --target sparc-unknown-none-elf
-//@[sparc] needs-llvm-components: sparc
-//@[sparcv8plus] compile-flags: --target sparc-unknown-linux-gnu
-//@[sparcv8plus] needs-llvm-components: sparc
-//@[sparc_cpu_v9] compile-flags: --target sparc-unknown-none-elf -C target-cpu=v9
-//@[sparc_cpu_v9] needs-llvm-components: sparc
-//@[sparc_feature_v8plus] compile-flags: --target sparc-unknown-none-elf -C target-feature=+v8plus
-//@[sparc_feature_v8plus] needs-llvm-components: sparc
-//@[sparc_cpu_v9_feature_v8plus] compile-flags: --target sparc-unknown-none-elf -C target-cpu=v9 -C target-feature=+v8plus
-//@[sparc_cpu_v9_feature_v8plus] needs-llvm-components: sparc
-//@ exact-llvm-major-version: 19
-
-#![crate_type = "rlib"]
-#![feature(no_core, rustc_attrs, lang_items)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-#[rustc_builtin_macro]
-macro_rules! compile_error {
-    () => {};
-}
-
-#[cfg(all(not(target_feature = "v8plus"), not(target_feature = "v9")))]
-compile_error!("-v8plus,-v9");
-//[sparc]~^ ERROR -v8plus,-v9
-
-// FIXME: sparc_cpu_v9 should be in "-v8plus,+v9" group (fixed in LLVM 20)
-#[cfg(all(target_feature = "v8plus", target_feature = "v9"))]
-compile_error!("+v8plus,+v9");
-//[sparcv8plus,sparc_cpu_v9_feature_v8plus,sparc_cpu_v9]~^ ERROR +v8plus,+v9
-
-// FIXME: should be rejected
-#[cfg(all(target_feature = "v8plus", not(target_feature = "v9")))]
-compile_error!("+v8plus,-v9 (FIXME)");
-//[sparc_feature_v8plus]~^ ERROR +v8plus,-v9 (FIXME)
-
-#[cfg(all(not(target_feature = "v8plus"), target_feature = "v9"))]
-compile_error!("-v8plus,+v9");
diff --git a/tests/ui/abi/sparcv8plus-llvm19.sparc.stderr b/tests/ui/abi/sparcv8plus-llvm19.sparc.stderr
deleted file mode 100644
index d3462ae87d338..0000000000000
--- a/tests/ui/abi/sparcv8plus-llvm19.sparc.stderr
+++ /dev/null
@@ -1,8 +0,0 @@
-error: -v8plus,-v9
-  --> $DIR/sparcv8plus-llvm19.rs:28:1
-   |
-LL | compile_error!("-v8plus,-v9");
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 1 previous error
-
diff --git a/tests/ui/abi/sparcv8plus-llvm19.sparc_cpu_v9.stderr b/tests/ui/abi/sparcv8plus-llvm19.sparc_cpu_v9.stderr
deleted file mode 100644
index 9891aec94b860..0000000000000
--- a/tests/ui/abi/sparcv8plus-llvm19.sparc_cpu_v9.stderr
+++ /dev/null
@@ -1,8 +0,0 @@
-error: +v8plus,+v9
-  --> $DIR/sparcv8plus-llvm19.rs:33:1
-   |
-LL | compile_error!("+v8plus,+v9");
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 1 previous error
-
diff --git a/tests/ui/abi/sparcv8plus-llvm19.sparc_cpu_v9_feature_v8plus.stderr b/tests/ui/abi/sparcv8plus-llvm19.sparc_cpu_v9_feature_v8plus.stderr
deleted file mode 100644
index 9891aec94b860..0000000000000
--- a/tests/ui/abi/sparcv8plus-llvm19.sparc_cpu_v9_feature_v8plus.stderr
+++ /dev/null
@@ -1,8 +0,0 @@
-error: +v8plus,+v9
-  --> $DIR/sparcv8plus-llvm19.rs:33:1
-   |
-LL | compile_error!("+v8plus,+v9");
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 1 previous error
-
diff --git a/tests/ui/abi/sparcv8plus-llvm19.sparc_feature_v8plus.stderr b/tests/ui/abi/sparcv8plus-llvm19.sparc_feature_v8plus.stderr
deleted file mode 100644
index dbcdb8ed121b3..0000000000000
--- a/tests/ui/abi/sparcv8plus-llvm19.sparc_feature_v8plus.stderr
+++ /dev/null
@@ -1,8 +0,0 @@
-error: +v8plus,-v9 (FIXME)
-  --> $DIR/sparcv8plus-llvm19.rs:38:1
-   |
-LL | compile_error!("+v8plus,-v9 (FIXME)");
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 1 previous error
-
diff --git a/tests/ui/abi/sparcv8plus-llvm19.sparcv8plus.stderr b/tests/ui/abi/sparcv8plus-llvm19.sparcv8plus.stderr
deleted file mode 100644
index 9891aec94b860..0000000000000
--- a/tests/ui/abi/sparcv8plus-llvm19.sparcv8plus.stderr
+++ /dev/null
@@ -1,8 +0,0 @@
-error: +v8plus,+v9
-  --> $DIR/sparcv8plus-llvm19.rs:33:1
-   |
-LL | compile_error!("+v8plus,+v9");
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 1 previous error
-
diff --git a/tests/ui/abi/sparcv8plus.rs b/tests/ui/abi/sparcv8plus.rs
index 6c17f72183862..ba4fb6f7108d4 100644
--- a/tests/ui/abi/sparcv8plus.rs
+++ b/tests/ui/abi/sparcv8plus.rs
@@ -10,7 +10,6 @@
 //@[sparc_feature_v8plus] needs-llvm-components: sparc
 //@[sparc_cpu_v9_feature_v8plus] compile-flags: --target sparc-unknown-none-elf -C target-cpu=v9 -C target-feature=+v8plus
 //@[sparc_cpu_v9_feature_v8plus] needs-llvm-components: sparc
-//@ min-llvm-version: 20
 
 #![crate_type = "rlib"]
 #![feature(no_core, rustc_attrs, lang_items)]
diff --git a/tests/ui/abi/sparcv8plus.sparc.stderr b/tests/ui/abi/sparcv8plus.sparc.stderr
index e2aa89a927317..e31dbd344d6f4 100644
--- a/tests/ui/abi/sparcv8plus.sparc.stderr
+++ b/tests/ui/abi/sparcv8plus.sparc.stderr
@@ -1,5 +1,5 @@
 error: -v8plus,-v9
-  --> $DIR/sparcv8plus.rs:28:1
+  --> $DIR/sparcv8plus.rs:27:1
    |
 LL | compile_error!("-v8plus,-v9");
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/abi/sparcv8plus.sparc_cpu_v9.stderr b/tests/ui/abi/sparcv8plus.sparc_cpu_v9.stderr
index 2c5699f2dec2b..a1a8383cbe704 100644
--- a/tests/ui/abi/sparcv8plus.sparc_cpu_v9.stderr
+++ b/tests/ui/abi/sparcv8plus.sparc_cpu_v9.stderr
@@ -1,5 +1,5 @@
 error: -v8plus,+v9
-  --> $DIR/sparcv8plus.rs:41:1
+  --> $DIR/sparcv8plus.rs:40:1
    |
 LL | compile_error!("-v8plus,+v9");
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/abi/sparcv8plus.sparc_cpu_v9_feature_v8plus.stderr b/tests/ui/abi/sparcv8plus.sparc_cpu_v9_feature_v8plus.stderr
index 4b96e4421f9f9..c633ee26c5141 100644
--- a/tests/ui/abi/sparcv8plus.sparc_cpu_v9_feature_v8plus.stderr
+++ b/tests/ui/abi/sparcv8plus.sparc_cpu_v9_feature_v8plus.stderr
@@ -1,5 +1,5 @@
 error: +v8plus,+v9
-  --> $DIR/sparcv8plus.rs:32:1
+  --> $DIR/sparcv8plus.rs:31:1
    |
 LL | compile_error!("+v8plus,+v9");
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/abi/sparcv8plus.sparc_feature_v8plus.stderr b/tests/ui/abi/sparcv8plus.sparc_feature_v8plus.stderr
index dfdec88961beb..bad8adc159967 100644
--- a/tests/ui/abi/sparcv8plus.sparc_feature_v8plus.stderr
+++ b/tests/ui/abi/sparcv8plus.sparc_feature_v8plus.stderr
@@ -1,5 +1,5 @@
 error: +v8plus,-v9 (FIXME)
-  --> $DIR/sparcv8plus.rs:37:1
+  --> $DIR/sparcv8plus.rs:36:1
    |
 LL | compile_error!("+v8plus,-v9 (FIXME)");
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/abi/sparcv8plus.sparcv8plus.stderr b/tests/ui/abi/sparcv8plus.sparcv8plus.stderr
index 4b96e4421f9f9..c633ee26c5141 100644
--- a/tests/ui/abi/sparcv8plus.sparcv8plus.stderr
+++ b/tests/ui/abi/sparcv8plus.sparcv8plus.stderr
@@ -1,5 +1,5 @@
 error: +v8plus,+v9
-  --> $DIR/sparcv8plus.rs:32:1
+  --> $DIR/sparcv8plus.rs:31:1
    |
 LL | compile_error!("+v8plus,+v9");
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/asm/loongarch/bad-reg.loongarch32_ilp32d.stderr b/tests/ui/asm/loongarch/bad-reg.loongarch32_ilp32d.stderr
index 8742d4bd82cd5..c67c913d2a60d 100644
--- a/tests/ui/asm/loongarch/bad-reg.loongarch32_ilp32d.stderr
+++ b/tests/ui/asm/loongarch/bad-reg.loongarch32_ilp32d.stderr
@@ -1,35 +1,35 @@
 error: invalid register `$r0`: constant zero cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:27:18
+  --> $DIR/bad-reg.rs:26:18
    |
 LL |         asm!("", out("$r0") _);
    |                  ^^^^^^^^^^^^
 
 error: invalid register `$tp`: reserved for TLS
-  --> $DIR/bad-reg.rs:29:18
+  --> $DIR/bad-reg.rs:28:18
    |
 LL |         asm!("", out("$tp") _);
    |                  ^^^^^^^^^^^^
 
 error: invalid register `$sp`: the stack pointer cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:31:18
+  --> $DIR/bad-reg.rs:30:18
    |
 LL |         asm!("", out("$sp") _);
    |                  ^^^^^^^^^^^^
 
 error: invalid register `$r21`: reserved by the ABI
-  --> $DIR/bad-reg.rs:33:18
+  --> $DIR/bad-reg.rs:32:18
    |
 LL |         asm!("", out("$r21") _);
    |                  ^^^^^^^^^^^^^
 
 error: invalid register `$fp`: the frame pointer cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:35:18
+  --> $DIR/bad-reg.rs:34:18
    |
 LL |         asm!("", out("$fp") _);
    |                  ^^^^^^^^^^^^
 
 error: invalid register `$r31`: $r31 is used internally by LLVM and cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:37:18
+  --> $DIR/bad-reg.rs:36:18
    |
 LL |         asm!("", out("$r31") _);
    |                  ^^^^^^^^^^^^^
diff --git a/tests/ui/asm/loongarch/bad-reg.loongarch32_ilp32s.stderr b/tests/ui/asm/loongarch/bad-reg.loongarch32_ilp32s.stderr
index e6cb6e40c701d..99c071919acfa 100644
--- a/tests/ui/asm/loongarch/bad-reg.loongarch32_ilp32s.stderr
+++ b/tests/ui/asm/loongarch/bad-reg.loongarch32_ilp32s.stderr
@@ -1,59 +1,59 @@
 error: invalid register `$r0`: constant zero cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:27:18
+  --> $DIR/bad-reg.rs:26:18
    |
 LL |         asm!("", out("$r0") _);
    |                  ^^^^^^^^^^^^
 
 error: invalid register `$tp`: reserved for TLS
-  --> $DIR/bad-reg.rs:29:18
+  --> $DIR/bad-reg.rs:28:18
    |
 LL |         asm!("", out("$tp") _);
    |                  ^^^^^^^^^^^^
 
 error: invalid register `$sp`: the stack pointer cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:31:18
+  --> $DIR/bad-reg.rs:30:18
    |
 LL |         asm!("", out("$sp") _);
    |                  ^^^^^^^^^^^^
 
 error: invalid register `$r21`: reserved by the ABI
-  --> $DIR/bad-reg.rs:33:18
+  --> $DIR/bad-reg.rs:32:18
    |
 LL |         asm!("", out("$r21") _);
    |                  ^^^^^^^^^^^^^
 
 error: invalid register `$fp`: the frame pointer cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:35:18
+  --> $DIR/bad-reg.rs:34:18
    |
 LL |         asm!("", out("$fp") _);
    |                  ^^^^^^^^^^^^
 
 error: invalid register `$r31`: $r31 is used internally by LLVM and cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:37:18
+  --> $DIR/bad-reg.rs:36:18
    |
 LL |         asm!("", out("$r31") _);
    |                  ^^^^^^^^^^^^^
 
 error: register class `freg` requires at least one of the following target features: d, f
-  --> $DIR/bad-reg.rs:41:26
+  --> $DIR/bad-reg.rs:40:26
    |
 LL |         asm!("/* {} */", in(freg) f);
    |                          ^^^^^^^^^^
 
 error: register class `freg` requires at least one of the following target features: d, f
-  --> $DIR/bad-reg.rs:43:26
+  --> $DIR/bad-reg.rs:42:26
    |
 LL |         asm!("/* {} */", out(freg) _);
    |                          ^^^^^^^^^^^
 
 error: register class `freg` requires at least one of the following target features: d, f
-  --> $DIR/bad-reg.rs:45:26
+  --> $DIR/bad-reg.rs:44:26
    |
 LL |         asm!("/* {} */", in(freg) d);
    |                          ^^^^^^^^^^
 
 error: register class `freg` requires at least one of the following target features: d, f
-  --> $DIR/bad-reg.rs:47:26
+  --> $DIR/bad-reg.rs:46:26
    |
 LL |         asm!("/* {} */", out(freg) d);
    |                          ^^^^^^^^^^^
diff --git a/tests/ui/asm/loongarch/bad-reg.loongarch64_lp64d.stderr b/tests/ui/asm/loongarch/bad-reg.loongarch64_lp64d.stderr
index 8742d4bd82cd5..c67c913d2a60d 100644
--- a/tests/ui/asm/loongarch/bad-reg.loongarch64_lp64d.stderr
+++ b/tests/ui/asm/loongarch/bad-reg.loongarch64_lp64d.stderr
@@ -1,35 +1,35 @@
 error: invalid register `$r0`: constant zero cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:27:18
+  --> $DIR/bad-reg.rs:26:18
    |
 LL |         asm!("", out("$r0") _);
    |                  ^^^^^^^^^^^^
 
 error: invalid register `$tp`: reserved for TLS
-  --> $DIR/bad-reg.rs:29:18
+  --> $DIR/bad-reg.rs:28:18
    |
 LL |         asm!("", out("$tp") _);
    |                  ^^^^^^^^^^^^
 
 error: invalid register `$sp`: the stack pointer cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:31:18
+  --> $DIR/bad-reg.rs:30:18
    |
 LL |         asm!("", out("$sp") _);
    |                  ^^^^^^^^^^^^
 
 error: invalid register `$r21`: reserved by the ABI
-  --> $DIR/bad-reg.rs:33:18
+  --> $DIR/bad-reg.rs:32:18
    |
 LL |         asm!("", out("$r21") _);
    |                  ^^^^^^^^^^^^^
 
 error: invalid register `$fp`: the frame pointer cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:35:18
+  --> $DIR/bad-reg.rs:34:18
    |
 LL |         asm!("", out("$fp") _);
    |                  ^^^^^^^^^^^^
 
 error: invalid register `$r31`: $r31 is used internally by LLVM and cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:37:18
+  --> $DIR/bad-reg.rs:36:18
    |
 LL |         asm!("", out("$r31") _);
    |                  ^^^^^^^^^^^^^
diff --git a/tests/ui/asm/loongarch/bad-reg.loongarch64_lp64s.stderr b/tests/ui/asm/loongarch/bad-reg.loongarch64_lp64s.stderr
index e6cb6e40c701d..99c071919acfa 100644
--- a/tests/ui/asm/loongarch/bad-reg.loongarch64_lp64s.stderr
+++ b/tests/ui/asm/loongarch/bad-reg.loongarch64_lp64s.stderr
@@ -1,59 +1,59 @@
 error: invalid register `$r0`: constant zero cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:27:18
+  --> $DIR/bad-reg.rs:26:18
    |
 LL |         asm!("", out("$r0") _);
    |                  ^^^^^^^^^^^^
 
 error: invalid register `$tp`: reserved for TLS
-  --> $DIR/bad-reg.rs:29:18
+  --> $DIR/bad-reg.rs:28:18
    |
 LL |         asm!("", out("$tp") _);
    |                  ^^^^^^^^^^^^
 
 error: invalid register `$sp`: the stack pointer cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:31:18
+  --> $DIR/bad-reg.rs:30:18
    |
 LL |         asm!("", out("$sp") _);
    |                  ^^^^^^^^^^^^
 
 error: invalid register `$r21`: reserved by the ABI
-  --> $DIR/bad-reg.rs:33:18
+  --> $DIR/bad-reg.rs:32:18
    |
 LL |         asm!("", out("$r21") _);
    |                  ^^^^^^^^^^^^^
 
 error: invalid register `$fp`: the frame pointer cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:35:18
+  --> $DIR/bad-reg.rs:34:18
    |
 LL |         asm!("", out("$fp") _);
    |                  ^^^^^^^^^^^^
 
 error: invalid register `$r31`: $r31 is used internally by LLVM and cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:37:18
+  --> $DIR/bad-reg.rs:36:18
    |
 LL |         asm!("", out("$r31") _);
    |                  ^^^^^^^^^^^^^
 
 error: register class `freg` requires at least one of the following target features: d, f
-  --> $DIR/bad-reg.rs:41:26
+  --> $DIR/bad-reg.rs:40:26
    |
 LL |         asm!("/* {} */", in(freg) f);
    |                          ^^^^^^^^^^
 
 error: register class `freg` requires at least one of the following target features: d, f
-  --> $DIR/bad-reg.rs:43:26
+  --> $DIR/bad-reg.rs:42:26
    |
 LL |         asm!("/* {} */", out(freg) _);
    |                          ^^^^^^^^^^^
 
 error: register class `freg` requires at least one of the following target features: d, f
-  --> $DIR/bad-reg.rs:45:26
+  --> $DIR/bad-reg.rs:44:26
    |
 LL |         asm!("/* {} */", in(freg) d);
    |                          ^^^^^^^^^^
 
 error: register class `freg` requires at least one of the following target features: d, f
-  --> $DIR/bad-reg.rs:47:26
+  --> $DIR/bad-reg.rs:46:26
    |
 LL |         asm!("/* {} */", out(freg) d);
    |                          ^^^^^^^^^^^
diff --git a/tests/ui/asm/loongarch/bad-reg.rs b/tests/ui/asm/loongarch/bad-reg.rs
index 0d3eba07f14da..cca37dd2e8e8b 100644
--- a/tests/ui/asm/loongarch/bad-reg.rs
+++ b/tests/ui/asm/loongarch/bad-reg.rs
@@ -1,7 +1,6 @@
 //@ add-core-stubs
 //@ needs-asm-support
 //@ revisions: loongarch32_ilp32d loongarch32_ilp32s loongarch64_lp64d loongarch64_lp64s
-//@ min-llvm-version: 20
 //@[loongarch32_ilp32d] compile-flags: --target loongarch32-unknown-none
 //@[loongarch32_ilp32d] needs-llvm-components: loongarch
 //@[loongarch32_ilp32s] compile-flags: --target loongarch32-unknown-none-softfloat

From e54602c5bbb6abc272eef6c795dcc01e755ab75f Mon Sep 17 00:00:00 2001
From: Josh Stone <jistone@redhat.com>
Date: Fri, 8 Aug 2025 13:59:06 -0700
Subject: [PATCH 1010/1889] Merge similar output checks in
 assembly-llvm/x86_64-cmp

---
 tests/assembly-llvm/x86_64-cmp.rs | 23 +++++++----------------
 1 file changed, 7 insertions(+), 16 deletions(-)

diff --git a/tests/assembly-llvm/x86_64-cmp.rs b/tests/assembly-llvm/x86_64-cmp.rs
index 7e87171991d4d..1f1fe7fd00520 100644
--- a/tests/assembly-llvm/x86_64-cmp.rs
+++ b/tests/assembly-llvm/x86_64-cmp.rs
@@ -14,16 +14,11 @@ use std::intrinsics::three_way_compare;
 // CHECK-LABEL: signed_cmp:
 pub fn signed_cmp(a: i16, b: i16) -> std::cmp::Ordering {
     // DEBUG: sub
-    // DEBUG: setl
-    // DEBUG: setg
-    // DEBUG: sub
-    // DEBUG: ret
-    //
     // OPTIM: cmp
-    // OPTIM: setl
-    // OPTIM: setg
-    // OPTIM: sub
-    // OPTIM: ret
+    // CHECK: setl
+    // CHECK: setg
+    // CHECK: sub
+    // CHECK: ret
     three_way_compare(a, b)
 }
 
@@ -31,13 +26,9 @@ pub fn signed_cmp(a: i16, b: i16) -> std::cmp::Ordering {
 // CHECK-LABEL: unsigned_cmp:
 pub fn unsigned_cmp(a: u16, b: u16) -> std::cmp::Ordering {
     // DEBUG: sub
-    // DEBUG: seta
-    // DEBUG: sbb
-    // DEBUG: ret
-    //
     // OPTIM: cmp
-    // OPTIM: seta
-    // OPTIM: sbb
-    // OPTIM: ret
+    // CHECK: seta
+    // CHECK: sbb
+    // CHECK: ret
     three_way_compare(a, b)
 }

From 88bef496465112850185fd1c46de1e250b271fa3 Mon Sep 17 00:00:00 2001
From: Josh Stone <jistone@redhat.com>
Date: Fri, 8 Aug 2025 14:20:56 -0700
Subject: [PATCH 1011/1889] Update the FIXME comments in the generic
 three_way_compare

---
 .../rustc_codegen_ssa/src/traits/builder.rs   | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/traits/builder.rs b/compiler/rustc_codegen_ssa/src/traits/builder.rs
index 422fa715de109..4a5694e97fa20 100644
--- a/compiler/rustc_codegen_ssa/src/traits/builder.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/builder.rs
@@ -412,23 +412,26 @@ pub trait BuilderMethods<'a, 'tcx>:
         lhs: Self::Value,
         rhs: Self::Value,
     ) -> Self::Value {
+        // FIXME: This implementation was designed around LLVM's ability to optimize, but `cg_llvm`
+        // overrides this to just use `@llvm.scmp`/`ucmp` since LLVM 20. This default impl should be
+        // reevaluated with respect to the remaining backends like cg_gcc, whether they might use
+        // specialized implementations as well, or continue to use a generic implementation here.
         use std::cmp::Ordering;
         let pred = |op| crate::base::bin_op_to_icmp_predicate(op, ty.is_signed());
         if self.cx().sess().opts.optimize == OptLevel::No {
-            // FIXME: This actually generates tighter assembly, and is a classic trick
-            // <https://graphics.stanford.edu/~seander/bithacks.html#CopyIntegerSign>
-            // However, as of 2023-11 it optimizes worse in things like derived
-            // `PartialOrd`, so only use it in debug for now. Once LLVM can handle it
-            // better (see <https://github.com/llvm/llvm-project/issues/73417>), it'll
-            // be worth trying it in optimized builds as well.
+            // This actually generates tighter assembly, and is a classic trick:
+            // <https://graphics.stanford.edu/~seander/bithacks.html#CopyIntegerSign>.
+            // However, as of 2023-11 it optimized worse in LLVM in things like derived
+            // `PartialOrd`, so we were only using it in debug. Since LLVM now uses its own
+            // intrinsics, it may be be worth trying it in optimized builds for other backends.
             let is_gt = self.icmp(pred(mir::BinOp::Gt), lhs, rhs);
             let gtext = self.zext(is_gt, self.type_i8());
             let is_lt = self.icmp(pred(mir::BinOp::Lt), lhs, rhs);
             let ltext = self.zext(is_lt, self.type_i8());
             self.unchecked_ssub(gtext, ltext)
         } else {
-            // These operations are those expected by `tests/codegen-llvm/integer-cmp.rs`,
-            // from <https://github.com/rust-lang/rust/pull/63767>.
+            // These operations were better optimized by LLVM, before `@llvm.scmp`/`ucmp` in 20.
+            // See <https://github.com/rust-lang/rust/pull/63767>.
             let is_lt = self.icmp(pred(mir::BinOp::Lt), lhs, rhs);
             let is_ne = self.icmp(pred(mir::BinOp::Ne), lhs, rhs);
             let ge = self.select(

From b79a4bfad66dea3a8b6bc90985cb65378288fe07 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Tue, 16 Sep 2025 21:51:39 +0200
Subject: [PATCH 1012/1889] Do not use `git -C dir`
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Older versions of git (≤ 1.8.5) do not support the `-C dir` global
option. Use the `cwd` optional argument when using Python's
`subprocess` functionality instead.
---
 src/bootstrap/bootstrap.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/bootstrap/bootstrap.py b/src/bootstrap/bootstrap.py
index 19e87f9c29317..effd33d288fa6 100644
--- a/src/bootstrap/bootstrap.py
+++ b/src/bootstrap/bootstrap.py
@@ -1193,8 +1193,6 @@ def get_latest_commit(self):
             return "<commit>"
         cmd = [
             "git",
-            "-C",
-            repo_path,
             "rev-list",
             "--author",
             author_email,
@@ -1202,7 +1200,9 @@ def get_latest_commit(self):
             "HEAD",
         ]
         try:
-            commit = subprocess.check_output(cmd, universal_newlines=True).strip()
+            commit = subprocess.check_output(
+                cmd, universal_newlines=True, cwd=repo_path
+            ).strip()
             return commit or "<commit>"
         except subprocess.CalledProcessError:
             return "<commit>"

From d81872a97145f35766b9885d6d88e8077d0eaf59 Mon Sep 17 00:00:00 2001
From: T <simp4t7@gmail.com>
Date: Fri, 12 Sep 2025 01:53:11 +0000
Subject: [PATCH 1013/1889] add Readme.md to tidy

update Readme

add info about githooks and bootstrap.toml

add info about config and remove linting specific files

add link to rustc-dev-guide
---
 src/doc/rustc-dev-guide/src/tests/intro.md |   4 +-
 src/tools/tidy/Readme.md                   | 112 +++++++++++++++++++++
 2 files changed, 115 insertions(+), 1 deletion(-)
 create mode 100644 src/tools/tidy/Readme.md

diff --git a/src/doc/rustc-dev-guide/src/tests/intro.md b/src/doc/rustc-dev-guide/src/tests/intro.md
index b90c16d602c31..4fa63b83b17fb 100644
--- a/src/doc/rustc-dev-guide/src/tests/intro.md
+++ b/src/doc/rustc-dev-guide/src/tests/intro.md
@@ -70,10 +70,12 @@ package tests:
 
 Tidy is a custom tool used for validating source code style and formatting
 conventions, such as rejecting long lines. There is more information in the
-[section on coding conventions](../conventions.md#formatting).
+[section on coding conventions](../conventions.md#formatting) or the [Tidy Readme].
 
 > Examples: `./x test tidy`
 
+[Tidy Readme]: https://github.com/rust-lang/rust/blob/master/src/tools/tidy/Readme.md
+
 
 ### Formatting
 
diff --git a/src/tools/tidy/Readme.md b/src/tools/tidy/Readme.md
new file mode 100644
index 0000000000000..fc9dc6350e92d
--- /dev/null
+++ b/src/tools/tidy/Readme.md
@@ -0,0 +1,112 @@
+# Tidy
+Tidy is the Rust project's custom internal linter and a crucial part of our testing and continuous integration (CI) infrastructure. It is designed to enforce a consistent style and formatting across the entire codebase, but its role extends beyond simple linting. Tidy also helps with infrastructure, policy, and documentation, ensuring the project remains organized, functional, and... tidy.
+
+This document will cover how to use tidy, the specific checks tidy performs, and using tidy directives to manage its behavior. By understanding and utilizing tidy, you can help us maintain the high standards of the Rust project.
+## Tidy Checks
+### Style and Code Quality
+These lints focus on enforcing consistent formatting, style, and general code health.
+* [`alphabetical`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/alphabetical/index.html): Checks that lists are sorted alphabetically
+* [`style`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/style/index.html): Check to enforce various stylistic guidelines on the Rust codebase.
+* [`filenames`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/filenames/index.html): Check to prevent invalid characters in file names.
+* [`pal`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/pal/index.html): Check to enforce rules about platform-specific code in std.
+* [`target_policy`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/target_policy/index.html): Check for target tier policy compliance.
+* [`error_codes`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/error_codes/index.html): Check to ensure error codes are properly documented and tested.
+
+### Infrastructure
+These checks focus on the integrity of the project's dependencies, internal tools, and documentation.
+* [`bins`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/bins/index.html): Prevent stray binaries from being checked into the source tree.
+* [`fluent_alphabetical`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/fluent_alphabetical/index.html) / [`fluent_period`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/fluent_period/index.html) / [`fluent_used`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/fluent_used/index.html): Various checks related to [Fluent](https://github.com/projectfluent) for localization and natural language translation.
+* [`deps`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/deps/index.html) / [`extdeps`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/extdeps/index.html): Check for valid licenses and sources for external dependencies.
+* [`gcc_submodule`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/gcc_submodule/index.html): Check that the `src/gcc` submodule version is valid.
+* [`triagebot`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/triagebot/index.html): Check to ensure paths mentioned in `triagebot.toml` exist in the project.
+* [`x_version`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/x_version/index.html): Validates the current version of the `x` tool.
+
+* [`edition`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/edition/index.html) / [`features`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/features/index.html): Check for a valid Rust edition and proper ordering of unstable features.
+* [`rustdoc_css_themes`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/rustdoc_css_themes/index.html) / [`rustdoc_templates`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/rustdoc_templates/index.html): Verify that Rust documentation templates and themes are correct.
+* [`unstable_book`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/unstable_book/index.html): Synchronizes the unstable book with unstable features.
+### Testing
+These checks ensure that tests are correctly structured, cleaned up, and free of common errors.
+* [`tests_placement`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/tests_placement/index.html) / [`unit_tests`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/unit_tests/index.html): Verify that tests are located in the correct directories and are not using improper attributes.
+* [`known_bug`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/known_bug/index.html) / [`unknown_revision`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/unknown_revision/index.html): Ensure that test directives and annotations are used correctly.
+* [`debug_artifacts`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/debug_artifacts/index.html) / [`mir_opt_tests`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/mir_opt_tests/index.html): Prevent unnecessary artifacts and stale files in test directories.
+* [`tests_revision_unpaired_stdout_stderr`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/tests_revision_unpaired_stdout_stderr/index.html) / [`ui_tests`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/ui_tests/index.html): Check for unpaired or stray test output files.
+* [`target_specific_tests`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/target_specific_tests/index.html): Check to ensure that all target specific tests (those that require a --target flag) also require the pre-requisite LLVM components to run.
+* [`rustdoc_gui_tests`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/rustdoc_gui_tests/index.html): Checks that rustdoc gui tests start with a small description
+* [`rustdoc_json`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/rustdoc_json/index.html): Verify that `FORMAT_VERSION` is in sync with `rust-json-types`.
+## Using Tidy
+
+Tidy is used in a number of different ways.
+* Every time `./x test` is used tidy will run automatically.
+
+* On every pull request, tidy will run automatically during CI checks.
+* Optionally, with the use of git-hooks, tidy can run locally on every push. This can be setup with `./x setup`. See the [rustc-dev-guide](https://rustc-dev-guide.rust-lang.org/building/suggested.html#installing-a-pre-push-hook) for more information.
+
+You can run tidy manually with:
+
+`./x test tidy`
+
+To first run the relevant formatter and then run tidy you can add `--bless`.
+
+`./x test tidy --bless`
+### Extra Checks
+[`extra_checks`](https://doc.rust-lang.org/nightly/nightly-rustc/tidy/extra_checks/index.html) are optional checks primarily focused on other file types and programming languages.
+
+Example usage:
+
+`./x test tidy --extra-checks=py,cpp,js,spellcheck`
+
+All options for `--extra-checks`:
+* `cpp`, `cpp:fmt`
+* `py`, `py:lint`, `py:fmt`
+* `js`, `js:lint`, `js:fmt`, `js:typecheck`
+* `shell`, `shell:lint`
+* `spellcheck`
+
+Default values for tidy's `extra-checks` can be set in `bootstrap.toml`. For example, `build.tidy-extra-checks = "js,py"`.
+
+Any argument without a suffix (eg. `py` or `js`) will include all possible checks. For example, `--extra-checks=js` is the same as `extra-checks=js:lint,js:fmt,js:typecheck`.
+
+Any argument can be prefixed with `auto:` to only run if relevant files are modified (eg. `--extra-checks=auto:py`).
+
+A specific configuration file or folder can be passed to tidy after a double dash (`--extra-checks=py -- foo.py`)
+
+## Tidy Directives
+
+Tidy directives are special comments that help tidy operate.
+
+Tidy directives can be used in the following types of comments:
+* `// `
+* `# `
+* `/* {...} */`
+* `<!-- {...} -->`
+
+You might find yourself needing to ignore a specific tidy style check and can do so with:
+* `ignore-tidy-cr`
+* `ignore-tidy-undocumented-unsafe`
+* `ignore-tidy-tab`
+* `ignore-tidy-linelength`
+* `ignore-tidy-filelength`
+
+* `ignore-tidy-end-whitespace`
+* `ignore-tidy-trailing-newlines`
+* `ignore-tidy-leading-newlines`
+* `ignore-tidy-copyright`
+* `ignore-tidy-dbg`
+* `ignore-tidy-odd-backticks`
+* `ignore-tidy-todo`
+
+Some checks, like `alphabetical`, require a tidy directive to use:
+```
+// tidy-alphabetical-start
+fn aaa() {}
+fn eee() {}
+fn z() {}
+// tidy-alphabetical-end
+```
+<!--ignore-tidy-todo-->While not exactly a tidy directive, // TODO will fail tidy and make sure you can't merge a PR with unfinished work.
+
+### Test Specific Directives
+
+`target-specific-tests` can be ignored with `// ignore-tidy-target-specific-tests`
+
+Tidy's `unknown_revision` check can be suppressed by adding the revision name to `//@ unused-revision-names:{revision}` or with `//@ unused-revision-names:*`.

From a4e8d6d79d52da36f92d9e10b3fee5e024c55ade Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Tue, 16 Sep 2025 17:25:31 -0400
Subject: [PATCH 1014/1889] Update cargo submodule

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

diff --git a/src/tools/cargo b/src/tools/cargo
index 24bb93c388fb8..966f94733bbc9 160000
--- a/src/tools/cargo
+++ b/src/tools/cargo
@@ -1 +1 @@
-Subproject commit 24bb93c388fb8c211a37986539f24a819dc669d3
+Subproject commit 966f94733bbc94ca51ff9f1e4c49ad250ebbdc50

From 44c1a00a2f9929cff1641b18f4c2b5f2d2833e3e Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Sun, 30 Apr 2023 20:48:29 +0000
Subject: [PATCH 1015/1889] Enable DestinationPropagation by default.

---
 compiler/rustc_mir_transform/src/dest_prop.rs |  10 +-
 compiler/rustc_mir_transform/src/lib.rs       |   4 +-
 compiler/rustc_mir_transform/src/nrvo.rs      | 234 -----------------
 ...o.DestinationPropagation.panic-abort.diff} |  31 +--
 ....DestinationPropagation.panic-unwind.diff} |  31 +--
 .../nrvo_borrowed.rs}                         |   4 +-
 .../{ => dest-prop}/nrvo_miscompile_111005.rs |   7 +-
 ..._111005.wrong.DestinationPropagation.diff} |   7 +-
 tests/mir-opt/pre-codegen/checked_ops.rs      |   3 +-
 ...b_at_home.PreCodegen.after.panic-abort.mir |   6 +-
 ..._at_home.PreCodegen.after.panic-unwind.mir |   6 +-
 .../derived_ord.demo_le.PreCodegen.after.mir  |  35 ++-
 tests/mir-opt/pre-codegen/derived_ord.rs      |   5 +-
 ....{impl#0}-partial_cmp.PreCodegen.after.mir |  32 ++-
 ...ward_loop.PreCodegen.after.panic-abort.mir |  68 +++--
 ...ard_loop.PreCodegen.after.panic-unwind.mir |  68 +++--
 ...ated_loop.PreCodegen.after.panic-abort.mir | 240 ++++++++----------
 ...ted_loop.PreCodegen.after.panic-unwind.mir |  70 +++--
 ...ward_loop.PreCodegen.after.panic-abort.mir | 182 ++++++-------
 ...ard_loop.PreCodegen.after.panic-unwind.mir | 182 ++++++-------
 ...ange_loop.PreCodegen.after.panic-abort.mir |  54 ++--
 ...nge_loop.PreCodegen.after.panic-unwind.mir |  54 ++--
 ...erse_loop.PreCodegen.after.panic-abort.mir |  72 +++---
 ...rse_loop.PreCodegen.after.panic-unwind.mir |  72 +++---
 ...e_ord.demo_ge_partial.PreCodegen.after.mir |  18 +-
 ...ple_ord.demo_le_total.PreCodegen.after.mir |  18 +-
 26 files changed, 590 insertions(+), 923 deletions(-)
 delete mode 100644 compiler/rustc_mir_transform/src/nrvo.rs
 rename tests/mir-opt/{nrvo_simple.nrvo.RenameReturnPlace.panic-abort.diff => dest-prop/nrvo_borrowed.nrvo.DestinationPropagation.panic-abort.diff} (52%)
 rename tests/mir-opt/{nrvo_simple.nrvo.RenameReturnPlace.panic-unwind.diff => dest-prop/nrvo_borrowed.nrvo.DestinationPropagation.panic-unwind.diff} (52%)
 rename tests/mir-opt/{nrvo_simple.rs => dest-prop/nrvo_borrowed.rs} (69%)
 rename tests/mir-opt/{ => dest-prop}/nrvo_miscompile_111005.rs (75%)
 rename tests/mir-opt/{nrvo_miscompile_111005.wrong.RenameReturnPlace.diff => dest-prop/nrvo_miscompile_111005.wrong.DestinationPropagation.diff} (61%)

diff --git a/compiler/rustc_mir_transform/src/dest_prop.rs b/compiler/rustc_mir_transform/src/dest_prop.rs
index c57483a681140..abd1cd4e35ac0 100644
--- a/compiler/rustc_mir_transform/src/dest_prop.rs
+++ b/compiler/rustc_mir_transform/src/dest_prop.rs
@@ -153,15 +153,7 @@ pub(super) struct DestinationPropagation;
 
 impl<'tcx> crate::MirPass<'tcx> for DestinationPropagation {
     fn is_enabled(&self, sess: &rustc_session::Session) -> bool {
-        // For now, only run at MIR opt level 3. Two things need to be changed before this can be
-        // turned on by default:
-        //  1. Because of the overeager removal of storage statements, this can cause stack space
-        //     regressions. This opt is not the place to fix this though, it's a more general
-        //     problem in MIR.
-        //  2. Despite being an overall perf improvement, this still causes a 30% regression in
-        //     keccak. We can temporarily fix this by bounding function size, but in the long term
-        //     we should fix this by being smarter about invalidating analysis results.
-        sess.mir_opt_level() >= 3
+        sess.mir_opt_level() >= 2
     }
 
     #[tracing::instrument(level = "trace", skip(self, tcx, body))]
diff --git a/compiler/rustc_mir_transform/src/lib.rs b/compiler/rustc_mir_transform/src/lib.rs
index 1663dfa744f42..9ff7e0b550030 100644
--- a/compiler/rustc_mir_transform/src/lib.rs
+++ b/compiler/rustc_mir_transform/src/lib.rs
@@ -156,7 +156,6 @@ declare_passes! {
     mod match_branches : MatchBranchSimplification;
     mod mentioned_items : MentionedItems;
     mod multiple_return_terminators : MultipleReturnTerminators;
-    mod nrvo : RenameReturnPlace;
     mod post_drop_elaboration : CheckLiveDrops;
     mod prettify : ReorderBasicBlocks, ReorderLocals;
     mod promote_consts : PromoteTemps;
@@ -715,7 +714,6 @@ pub(crate) fn run_optimization_passes<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'
             &jump_threading::JumpThreading,
             &early_otherwise_branch::EarlyOtherwiseBranch,
             &simplify_comparison_integral::SimplifyComparisonIntegral,
-            &dest_prop::DestinationPropagation,
             &o1(simplify_branches::SimplifyConstCondition::Final),
             &o1(remove_noop_landing_pads::RemoveNoopLandingPads),
             &o1(simplify::SimplifyCfg::Final),
@@ -723,7 +721,7 @@ pub(crate) fn run_optimization_passes<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'
             &strip_debuginfo::StripDebugInfo,
             &copy_prop::CopyProp,
             &dead_store_elimination::DeadStoreElimination::Final,
-            &nrvo::RenameReturnPlace,
+            &dest_prop::DestinationPropagation,
             &simplify::SimplifyLocals::Final,
             &multiple_return_terminators::MultipleReturnTerminators,
             &large_enums::EnumSizeOpt { discrepancy: 128 },
diff --git a/compiler/rustc_mir_transform/src/nrvo.rs b/compiler/rustc_mir_transform/src/nrvo.rs
deleted file mode 100644
index 965002aae04c7..0000000000000
--- a/compiler/rustc_mir_transform/src/nrvo.rs
+++ /dev/null
@@ -1,234 +0,0 @@
-//! See the docs for [`RenameReturnPlace`].
-
-use rustc_hir::Mutability;
-use rustc_index::bit_set::DenseBitSet;
-use rustc_middle::bug;
-use rustc_middle::mir::visit::{MutVisitor, NonUseContext, PlaceContext, Visitor};
-use rustc_middle::mir::{self, BasicBlock, Local, Location};
-use rustc_middle::ty::TyCtxt;
-use tracing::{debug, trace};
-
-/// This pass looks for MIR that always copies the same local into the return place and eliminates
-/// the copy by renaming all uses of that local to `_0`.
-///
-/// This allows LLVM to perform an optimization similar to the named return value optimization
-/// (NRVO) that is guaranteed in C++. This avoids a stack allocation and `memcpy` for the
-/// relatively common pattern of allocating a buffer on the stack, mutating it, and returning it by
-/// value like so:
-///
-/// ```rust
-/// fn foo(init: fn(&mut [u8; 1024])) -> [u8; 1024] {
-///     let mut buf = [0; 1024];
-///     init(&mut buf);
-///     buf
-/// }
-/// ```
-///
-/// For now, this pass is very simple and only capable of eliminating a single copy. A more general
-/// version of copy propagation, such as the one based on non-overlapping live ranges in [#47954] and
-/// [#71003], could yield even more benefits.
-///
-/// [#47954]: https://github.com/rust-lang/rust/pull/47954
-/// [#71003]: https://github.com/rust-lang/rust/pull/71003
-pub(super) struct RenameReturnPlace;
-
-impl<'tcx> crate::MirPass<'tcx> for RenameReturnPlace {
-    fn is_enabled(&self, sess: &rustc_session::Session) -> bool {
-        // unsound: #111005
-        sess.mir_opt_level() > 0 && sess.opts.unstable_opts.unsound_mir_opts
-    }
-
-    fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut mir::Body<'tcx>) {
-        let def_id = body.source.def_id();
-        let Some(returned_local) = local_eligible_for_nrvo(body) else {
-            debug!("`{:?}` was ineligible for NRVO", def_id);
-            return;
-        };
-
-        debug!(
-            "`{:?}` was eligible for NRVO, making {:?} the return place",
-            def_id, returned_local
-        );
-
-        RenameToReturnPlace { tcx, to_rename: returned_local }.visit_body_preserves_cfg(body);
-
-        // Clean up the `NOP`s we inserted for statements made useless by our renaming.
-        for block_data in body.basic_blocks.as_mut_preserves_cfg() {
-            block_data.statements.retain(|stmt| stmt.kind != mir::StatementKind::Nop);
-        }
-
-        // Overwrite the debuginfo of `_0` with that of the renamed local.
-        let (renamed_decl, ret_decl) =
-            body.local_decls.pick2_mut(returned_local, mir::RETURN_PLACE);
-
-        // Sometimes, the return place is assigned a local of a different but coercible type, for
-        // example `&mut T` instead of `&T`. Overwriting the `LocalInfo` for the return place means
-        // its type may no longer match the return type of its function. This doesn't cause a
-        // problem in codegen because these two types are layout-compatible, but may be unexpected.
-        debug!("_0: {:?} = {:?}: {:?}", ret_decl.ty, returned_local, renamed_decl.ty);
-        ret_decl.clone_from(renamed_decl);
-
-        // The return place is always mutable.
-        ret_decl.mutability = Mutability::Mut;
-    }
-
-    fn is_required(&self) -> bool {
-        false
-    }
-}
-
-/// MIR that is eligible for the NRVO must fulfill two conditions:
-///   1. The return place must not be read prior to the `Return` terminator.
-///   2. A simple assignment of a whole local to the return place (e.g., `_0 = _1`) must be the
-///      only definition of the return place reaching the `Return` terminator.
-///
-/// If the MIR fulfills both these conditions, this function returns the `Local` that is assigned
-/// to the return place along all possible paths through the control-flow graph.
-fn local_eligible_for_nrvo(body: &mir::Body<'_>) -> Option<Local> {
-    if IsReturnPlaceRead::run(body) {
-        return None;
-    }
-
-    let mut copied_to_return_place = None;
-    for block in body.basic_blocks.indices() {
-        // Look for blocks with a `Return` terminator.
-        if !matches!(body[block].terminator().kind, mir::TerminatorKind::Return) {
-            continue;
-        }
-
-        // Look for an assignment of a single local to the return place prior to the `Return`.
-        let returned_local = find_local_assigned_to_return_place(block, body)?;
-        match body.local_kind(returned_local) {
-            // FIXME: Can we do this for arguments as well?
-            mir::LocalKind::Arg => return None,
-
-            mir::LocalKind::ReturnPointer => bug!("Return place was assigned to itself?"),
-            mir::LocalKind::Temp => {}
-        }
-
-        // If multiple different locals are copied to the return place. We can't pick a
-        // single one to rename.
-        if copied_to_return_place.is_some_and(|old| old != returned_local) {
-            return None;
-        }
-
-        copied_to_return_place = Some(returned_local);
-    }
-
-    copied_to_return_place
-}
-
-fn find_local_assigned_to_return_place(start: BasicBlock, body: &mir::Body<'_>) -> Option<Local> {
-    let mut block = start;
-    let mut seen = DenseBitSet::new_empty(body.basic_blocks.len());
-
-    // Iterate as long as `block` has exactly one predecessor that we have not yet visited.
-    while seen.insert(block) {
-        trace!("Looking for assignments to `_0` in {:?}", block);
-
-        let local = body[block].statements.iter().rev().find_map(as_local_assigned_to_return_place);
-        if local.is_some() {
-            return local;
-        }
-
-        match body.basic_blocks.predecessors()[block].as_slice() {
-            &[pred] => block = pred,
-            _ => return None,
-        }
-    }
-
-    None
-}
-
-// If this statement is an assignment of an unprojected local to the return place,
-// return that local.
-fn as_local_assigned_to_return_place(stmt: &mir::Statement<'_>) -> Option<Local> {
-    if let mir::StatementKind::Assign(box (lhs, rhs)) = &stmt.kind {
-        if lhs.as_local() == Some(mir::RETURN_PLACE) {
-            if let mir::Rvalue::Use(mir::Operand::Copy(rhs) | mir::Operand::Move(rhs)) = rhs {
-                return rhs.as_local();
-            }
-        }
-    }
-
-    None
-}
-
-struct RenameToReturnPlace<'tcx> {
-    to_rename: Local,
-    tcx: TyCtxt<'tcx>,
-}
-
-/// Replaces all uses of `self.to_rename` with `_0`.
-impl<'tcx> MutVisitor<'tcx> for RenameToReturnPlace<'tcx> {
-    fn tcx(&self) -> TyCtxt<'tcx> {
-        self.tcx
-    }
-
-    fn visit_statement(&mut self, stmt: &mut mir::Statement<'tcx>, loc: Location) {
-        // Remove assignments of the local being replaced to the return place, since it is now the
-        // return place:
-        //     _0 = _1
-        if as_local_assigned_to_return_place(stmt) == Some(self.to_rename) {
-            stmt.kind = mir::StatementKind::Nop;
-            return;
-        }
-
-        // Remove storage annotations for the local being replaced:
-        //     StorageLive(_1)
-        if let mir::StatementKind::StorageLive(local) | mir::StatementKind::StorageDead(local) =
-            stmt.kind
-        {
-            if local == self.to_rename {
-                stmt.kind = mir::StatementKind::Nop;
-                return;
-            }
-        }
-
-        self.super_statement(stmt, loc)
-    }
-
-    fn visit_terminator(&mut self, terminator: &mut mir::Terminator<'tcx>, loc: Location) {
-        // Ignore the implicit "use" of the return place in a `Return` statement.
-        if let mir::TerminatorKind::Return = terminator.kind {
-            return;
-        }
-
-        self.super_terminator(terminator, loc);
-    }
-
-    fn visit_local(&mut self, l: &mut Local, ctxt: PlaceContext, _: Location) {
-        if *l == mir::RETURN_PLACE {
-            assert_eq!(ctxt, PlaceContext::NonUse(NonUseContext::VarDebugInfo));
-        } else if *l == self.to_rename {
-            *l = mir::RETURN_PLACE;
-        }
-    }
-}
-
-struct IsReturnPlaceRead(bool);
-
-impl IsReturnPlaceRead {
-    fn run(body: &mir::Body<'_>) -> bool {
-        let mut vis = IsReturnPlaceRead(false);
-        vis.visit_body(body);
-        vis.0
-    }
-}
-
-impl<'tcx> Visitor<'tcx> for IsReturnPlaceRead {
-    fn visit_local(&mut self, l: Local, ctxt: PlaceContext, _: Location) {
-        if l == mir::RETURN_PLACE && ctxt.is_use() && !ctxt.is_place_assignment() {
-            self.0 = true;
-        }
-    }
-
-    fn visit_terminator(&mut self, terminator: &mir::Terminator<'tcx>, loc: Location) {
-        // Ignore the implicit "use" of the return place in a `Return` statement.
-        if let mir::TerminatorKind::Return = terminator.kind {
-            return;
-        }
-
-        self.super_terminator(terminator, loc);
-    }
-}
diff --git a/tests/mir-opt/nrvo_simple.nrvo.RenameReturnPlace.panic-abort.diff b/tests/mir-opt/dest-prop/nrvo_borrowed.nrvo.DestinationPropagation.panic-abort.diff
similarity index 52%
rename from tests/mir-opt/nrvo_simple.nrvo.RenameReturnPlace.panic-abort.diff
rename to tests/mir-opt/dest-prop/nrvo_borrowed.nrvo.DestinationPropagation.panic-abort.diff
index 6dce3ec5303d7..e9fbcf20a7228 100644
--- a/tests/mir-opt/nrvo_simple.nrvo.RenameReturnPlace.panic-abort.diff
+++ b/tests/mir-opt/dest-prop/nrvo_borrowed.nrvo.DestinationPropagation.panic-abort.diff
@@ -1,5 +1,5 @@
-- // MIR for `nrvo` before RenameReturnPlace
-+ // MIR for `nrvo` after RenameReturnPlace
+- // MIR for `nrvo` before DestinationPropagation
++ // MIR for `nrvo` after DestinationPropagation
   
   fn nrvo(_1: for<'a> fn(&'a mut [u8; 1024])) -> [u8; 1024] {
       debug init => _1;
@@ -10,32 +10,33 @@
       let mut _5: &mut [u8; 1024];
       let mut _6: &mut [u8; 1024];
       scope 1 {
--         debug buf => _2;
-+         debug buf => _0;
+          debug buf => _2;
       }
   
       bb0: {
--         StorageLive(_2);
--         _2 = [const 0_u8; 1024];
-+         _0 = [const 0_u8; 1024];
+          StorageLive(_2);
+          _2 = [const 0_u8; 1024];
           StorageLive(_3);
-          StorageLive(_4);
-          _4 = copy _1;
+-         StorageLive(_4);
+-         _4 = copy _1;
++         nop;
++         nop;
           StorageLive(_5);
           StorageLive(_6);
--         _6 = &mut _2;
-+         _6 = &mut _0;
+          _6 = &mut _2;
           _5 = &mut (*_6);
-          _3 = move _4(move _5) -> [return: bb1, unwind unreachable];
+-         _3 = move _4(move _5) -> [return: bb1, unwind unreachable];
++         _3 = move _1(move _5) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
           StorageDead(_5);
-          StorageDead(_4);
+-         StorageDead(_4);
++         nop;
           StorageDead(_6);
           StorageDead(_3);
--         _0 = copy _2;
--         StorageDead(_2);
+          _0 = copy _2;
+          StorageDead(_2);
           return;
       }
   }
diff --git a/tests/mir-opt/nrvo_simple.nrvo.RenameReturnPlace.panic-unwind.diff b/tests/mir-opt/dest-prop/nrvo_borrowed.nrvo.DestinationPropagation.panic-unwind.diff
similarity index 52%
rename from tests/mir-opt/nrvo_simple.nrvo.RenameReturnPlace.panic-unwind.diff
rename to tests/mir-opt/dest-prop/nrvo_borrowed.nrvo.DestinationPropagation.panic-unwind.diff
index 54cbe2871f15a..95d5fe1b9304b 100644
--- a/tests/mir-opt/nrvo_simple.nrvo.RenameReturnPlace.panic-unwind.diff
+++ b/tests/mir-opt/dest-prop/nrvo_borrowed.nrvo.DestinationPropagation.panic-unwind.diff
@@ -1,5 +1,5 @@
-- // MIR for `nrvo` before RenameReturnPlace
-+ // MIR for `nrvo` after RenameReturnPlace
+- // MIR for `nrvo` before DestinationPropagation
++ // MIR for `nrvo` after DestinationPropagation
   
   fn nrvo(_1: for<'a> fn(&'a mut [u8; 1024])) -> [u8; 1024] {
       debug init => _1;
@@ -10,32 +10,33 @@
       let mut _5: &mut [u8; 1024];
       let mut _6: &mut [u8; 1024];
       scope 1 {
--         debug buf => _2;
-+         debug buf => _0;
+          debug buf => _2;
       }
   
       bb0: {
--         StorageLive(_2);
--         _2 = [const 0_u8; 1024];
-+         _0 = [const 0_u8; 1024];
+          StorageLive(_2);
+          _2 = [const 0_u8; 1024];
           StorageLive(_3);
-          StorageLive(_4);
-          _4 = copy _1;
+-         StorageLive(_4);
+-         _4 = copy _1;
++         nop;
++         nop;
           StorageLive(_5);
           StorageLive(_6);
--         _6 = &mut _2;
-+         _6 = &mut _0;
+          _6 = &mut _2;
           _5 = &mut (*_6);
-          _3 = move _4(move _5) -> [return: bb1, unwind continue];
+-         _3 = move _4(move _5) -> [return: bb1, unwind continue];
++         _3 = move _1(move _5) -> [return: bb1, unwind continue];
       }
   
       bb1: {
           StorageDead(_5);
-          StorageDead(_4);
+-         StorageDead(_4);
++         nop;
           StorageDead(_6);
           StorageDead(_3);
--         _0 = copy _2;
--         StorageDead(_2);
+          _0 = copy _2;
+          StorageDead(_2);
           return;
       }
   }
diff --git a/tests/mir-opt/nrvo_simple.rs b/tests/mir-opt/dest-prop/nrvo_borrowed.rs
similarity index 69%
rename from tests/mir-opt/nrvo_simple.rs
rename to tests/mir-opt/dest-prop/nrvo_borrowed.rs
index df540472e1ccb..6f3076d4c13e9 100644
--- a/tests/mir-opt/nrvo_simple.rs
+++ b/tests/mir-opt/dest-prop/nrvo_borrowed.rs
@@ -1,8 +1,8 @@
 // skip-filecheck
 // EMIT_MIR_FOR_EACH_PANIC_STRATEGY
-//@ test-mir-pass: RenameReturnPlace
+//@ test-mir-pass: DestinationPropagation
 
-// EMIT_MIR nrvo_simple.nrvo.RenameReturnPlace.diff
+// EMIT_MIR nrvo_borrowed.nrvo.DestinationPropagation.diff
 fn nrvo(init: fn(&mut [u8; 1024])) -> [u8; 1024] {
     let mut buf = [0; 1024];
     init(&mut buf);
diff --git a/tests/mir-opt/nrvo_miscompile_111005.rs b/tests/mir-opt/dest-prop/nrvo_miscompile_111005.rs
similarity index 75%
rename from tests/mir-opt/nrvo_miscompile_111005.rs
rename to tests/mir-opt/dest-prop/nrvo_miscompile_111005.rs
index 131f7b8f6f991..17e6450278ac6 100644
--- a/tests/mir-opt/nrvo_miscompile_111005.rs
+++ b/tests/mir-opt/dest-prop/nrvo_miscompile_111005.rs
@@ -1,18 +1,17 @@
 // This is a miscompilation, #111005 to track
 
-//@ test-mir-pass: RenameReturnPlace
+//@ test-mir-pass: DestinationPropagation
 
 #![feature(custom_mir, core_intrinsics)]
 extern crate core;
 use core::intrinsics::mir::*;
 
-// EMIT_MIR nrvo_miscompile_111005.wrong.RenameReturnPlace.diff
+// EMIT_MIR nrvo_miscompile_111005.wrong.DestinationPropagation.diff
 #[custom_mir(dialect = "runtime", phase = "initial")]
 pub fn wrong(arg: char) -> char {
     // CHECK-LABEL: fn wrong(
     // CHECK: _0 = copy _1;
-    // FIXME: This is wrong:
-    // CHECK-NEXT: _0 = const 'b';
+    // CHECK-NEXT: _1 = const 'b';
     // CHECK-NEXT: return;
     mir! {
         {
diff --git a/tests/mir-opt/nrvo_miscompile_111005.wrong.RenameReturnPlace.diff b/tests/mir-opt/dest-prop/nrvo_miscompile_111005.wrong.DestinationPropagation.diff
similarity index 61%
rename from tests/mir-opt/nrvo_miscompile_111005.wrong.RenameReturnPlace.diff
rename to tests/mir-opt/dest-prop/nrvo_miscompile_111005.wrong.DestinationPropagation.diff
index d248c76f261b6..60cf9236f6c2a 100644
--- a/tests/mir-opt/nrvo_miscompile_111005.wrong.RenameReturnPlace.diff
+++ b/tests/mir-opt/dest-prop/nrvo_miscompile_111005.wrong.DestinationPropagation.diff
@@ -1,5 +1,5 @@
-- // MIR for `wrong` before RenameReturnPlace
-+ // MIR for `wrong` after RenameReturnPlace
+- // MIR for `wrong` before DestinationPropagation
++ // MIR for `wrong` after DestinationPropagation
   
   fn wrong(_1: char) -> char {
       let mut _0: char;
@@ -9,8 +9,9 @@
 -         _2 = copy _1;
 -         _0 = copy _2;
 -         _2 = const 'b';
++         nop;
 +         _0 = copy _1;
-+         _0 = const 'b';
++         _1 = const 'b';
           return;
       }
   }
diff --git a/tests/mir-opt/pre-codegen/checked_ops.rs b/tests/mir-opt/pre-codegen/checked_ops.rs
index 8fd340503f548..dfbc0f4a1108d 100644
--- a/tests/mir-opt/pre-codegen/checked_ops.rs
+++ b/tests/mir-opt/pre-codegen/checked_ops.rs
@@ -44,8 +44,7 @@ pub fn saturating_sub_at_home(lhs: u32, rhs: u32) -> u32 {
     // CHECK-LABEL: fn saturating_sub_at_home
     // CHECK: [[DELTA:_[0-9]+]] = SubUnchecked(copy _1, copy _2)
     // CHECK: [[TEMP1:_.+]] = Option::<u32>::Some({{move|copy}} [[DELTA]]);
-    // CHECK: [[TEMP2:_.+]] = {{move|copy}} (([[TEMP1]] as Some).0: u32);
-    // CHECK: _0 = {{move|copy}} [[TEMP2]];
+    // CHECK: _0 = {{move|copy}} (([[TEMP1]] as Some).0: u32);
     u32::checked_sub(lhs, rhs).unwrap_or(0)
 }
 
diff --git a/tests/mir-opt/pre-codegen/checked_ops.saturating_sub_at_home.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/checked_ops.saturating_sub_at_home.PreCodegen.after.panic-abort.mir
index 5b4fdeda85731..dc7567b57e70a 100644
--- a/tests/mir-opt/pre-codegen/checked_ops.saturating_sub_at_home.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/checked_ops.saturating_sub_at_home.PreCodegen.after.panic-abort.mir
@@ -10,7 +10,6 @@ fn saturating_sub_at_home(_1: u32, _2: u32) -> u32 {
         let mut _4: u32;
     }
     scope 2 (inlined Option::<u32>::unwrap_or) {
-        let _6: u32;
         scope 3 {
         }
     }
@@ -28,10 +27,7 @@ fn saturating_sub_at_home(_1: u32, _2: u32) -> u32 {
         _5 = Option::<u32>::Some(move _4);
         StorageDead(_4);
         StorageDead(_3);
-        StorageLive(_6);
-        _6 = move ((_5 as Some).0: u32);
-        _0 = move _6;
-        StorageDead(_6);
+        _0 = move ((_5 as Some).0: u32);
         goto -> bb3;
     }
 
diff --git a/tests/mir-opt/pre-codegen/checked_ops.saturating_sub_at_home.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/checked_ops.saturating_sub_at_home.PreCodegen.after.panic-unwind.mir
index 5b4fdeda85731..dc7567b57e70a 100644
--- a/tests/mir-opt/pre-codegen/checked_ops.saturating_sub_at_home.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/checked_ops.saturating_sub_at_home.PreCodegen.after.panic-unwind.mir
@@ -10,7 +10,6 @@ fn saturating_sub_at_home(_1: u32, _2: u32) -> u32 {
         let mut _4: u32;
     }
     scope 2 (inlined Option::<u32>::unwrap_or) {
-        let _6: u32;
         scope 3 {
         }
     }
@@ -28,10 +27,7 @@ fn saturating_sub_at_home(_1: u32, _2: u32) -> u32 {
         _5 = Option::<u32>::Some(move _4);
         StorageDead(_4);
         StorageDead(_3);
-        StorageLive(_6);
-        _6 = move ((_5 as Some).0: u32);
-        _0 = move _6;
-        StorageDead(_6);
+        _0 = move ((_5 as Some).0: u32);
         goto -> bb3;
     }
 
diff --git a/tests/mir-opt/pre-codegen/derived_ord.demo_le.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/derived_ord.demo_le.PreCodegen.after.mir
index 8746cb0899166..e235fa35c0238 100644
--- a/tests/mir-opt/pre-codegen/derived_ord.demo_le.PreCodegen.after.mir
+++ b/tests/mir-opt/pre-codegen/derived_ord.demo_le.PreCodegen.after.mir
@@ -5,8 +5,9 @@ fn demo_le(_1: &MultiField, _2: &MultiField) -> bool {
     debug b => _2;
     let mut _0: bool;
     scope 1 (inlined <MultiField as PartialOrd>::le) {
-        let mut _11: std::option::Option<std::cmp::Ordering>;
+        let mut _6: std::option::Option<std::cmp::Ordering>;
         scope 2 (inlined Option::<std::cmp::Ordering>::is_some_and::<fn(std::cmp::Ordering) -> bool {std::cmp::Ordering::is_le}>) {
+            let mut _11: isize;
             let _12: std::cmp::Ordering;
             scope 3 {
                 scope 4 (inlined <fn(std::cmp::Ordering) -> bool {std::cmp::Ordering::is_le} as FnOnce<(std::cmp::Ordering,)>>::call_once - shim(fn(std::cmp::Ordering) -> bool {std::cmp::Ordering::is_le})) {
@@ -19,7 +20,6 @@ fn demo_le(_1: &MultiField, _2: &MultiField) -> bool {
             }
         }
         scope 7 (inlined <MultiField as PartialOrd>::partial_cmp) {
-            let mut _6: std::option::Option<std::cmp::Ordering>;
             let mut _7: i8;
             scope 8 {
             }
@@ -38,9 +38,8 @@ fn demo_le(_1: &MultiField, _2: &MultiField) -> bool {
 
     bb0: {
         StorageLive(_12);
-        StorageLive(_11);
-        StorageLive(_5);
         StorageLive(_6);
+        StorageLive(_5);
         StorageLive(_7);
         StorageLive(_3);
         _3 = copy ((*_1).0: char);
@@ -63,30 +62,44 @@ fn demo_le(_1: &MultiField, _2: &MultiField) -> bool {
         _10 = Cmp(move _8, move _9);
         StorageDead(_9);
         StorageDead(_8);
-        _11 = Option::<std::cmp::Ordering>::Some(move _10);
+        _6 = Option::<std::cmp::Ordering>::Some(move _10);
         StorageDead(_10);
         StorageDead(_7);
-        StorageDead(_6);
         StorageDead(_5);
-        goto -> bb3;
+        StorageLive(_11);
+        goto -> bb4;
     }
 
     bb2: {
-        _11 = copy _6;
         StorageDead(_7);
-        StorageDead(_6);
         StorageDead(_5);
-        goto -> bb3;
+        StorageLive(_11);
+        _11 = discriminant(_6);
+        switchInt(move _11) -> [0: bb3, 1: bb4, otherwise: bb6];
     }
 
     bb3: {
-        _12 = move ((_11 as Some).0: std::cmp::Ordering);
+        _0 = const false;
+        goto -> bb5;
+    }
+
+    bb4: {
+        _12 = move ((_6 as Some).0: std::cmp::Ordering);
         StorageLive(_13);
         _13 = discriminant(_12);
         _0 = Le(move _13, const 0_i8);
         StorageDead(_13);
+        goto -> bb5;
+    }
+
+    bb5: {
         StorageDead(_11);
+        StorageDead(_6);
         StorageDead(_12);
         return;
     }
+
+    bb6: {
+        unreachable;
+    }
 }
diff --git a/tests/mir-opt/pre-codegen/derived_ord.rs b/tests/mir-opt/pre-codegen/derived_ord.rs
index 73ae923a6cb9c..823e0f6d09c2b 100644
--- a/tests/mir-opt/pre-codegen/derived_ord.rs
+++ b/tests/mir-opt/pre-codegen/derived_ord.rs
@@ -25,7 +25,10 @@ pub fn demo_le(a: &MultiField, b: &MultiField) -> bool {
     // CHECK: Cmp(move [[A1]], move [[B1]]);
 
     // CHECK: [[D1:_[0-9]+]] = discriminant({{.+}});
-    // CHECK: _0 = Le(move [[D1]], const 0_i8);
+    // CHECK: switchInt(move [[D1]]) -> [0: bb{{[0-9]+}}, 1: bb{{[0-9]+}}, otherwise: bb{{[0-9]+}}];
+
+    // CHECK: [[D2:_[0-9]+]] = discriminant({{.+}});
+    // CHECK: _0 = Le(move [[D2]], const 0_i8);
     *a <= *b
 }
 
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 de25eebee77ff..5993bd79d274c 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
@@ -4,10 +4,9 @@ fn <impl at $DIR/derived_ord.rs:5:10: 5:20>::partial_cmp(_1: &MultiField, _2: &M
     debug self => _1;
     debug other => _2;
     let mut _0: std::option::Option<std::cmp::Ordering>;
-    let mut _6: std::option::Option<std::cmp::Ordering>;
-    let mut _7: i8;
+    let mut _6: i8;
     scope 1 {
-        debug cmp => _6;
+        debug cmp => _0;
     }
     scope 2 (inlined std::cmp::impls::<impl PartialOrd for char>::partial_cmp) {
         let mut _3: char;
@@ -15,9 +14,9 @@ fn <impl at $DIR/derived_ord.rs:5:10: 5:20>::partial_cmp(_1: &MultiField, _2: &M
         let mut _5: std::cmp::Ordering;
     }
     scope 3 (inlined std::cmp::impls::<impl PartialOrd for i16>::partial_cmp) {
+        let mut _7: i16;
         let mut _8: i16;
-        let mut _9: i16;
-        let mut _10: std::cmp::Ordering;
+        let mut _9: std::cmp::Ordering;
     }
 
     bb0: {
@@ -28,27 +27,26 @@ fn <impl at $DIR/derived_ord.rs:5:10: 5:20>::partial_cmp(_1: &MultiField, _2: &M
         _5 = Cmp(move _3, move _4);
         StorageDead(_4);
         StorageDead(_3);
-        _6 = Option::<std::cmp::Ordering>::Some(copy _5);
-        _7 = discriminant(_5);
-        switchInt(move _7) -> [0: bb1, otherwise: bb2];
+        _0 = Option::<std::cmp::Ordering>::Some(copy _5);
+        _6 = discriminant(_5);
+        switchInt(move _6) -> [0: bb1, otherwise: bb2];
     }
 
     bb1: {
-        StorageLive(_10);
-        StorageLive(_8);
-        _8 = copy ((*_1).1: i16);
         StorageLive(_9);
-        _9 = copy ((*_2).1: i16);
-        _10 = Cmp(move _8, move _9);
-        StorageDead(_9);
+        StorageLive(_7);
+        _7 = copy ((*_1).1: i16);
+        StorageLive(_8);
+        _8 = copy ((*_2).1: i16);
+        _9 = Cmp(move _7, move _8);
         StorageDead(_8);
-        _0 = Option::<std::cmp::Ordering>::Some(move _10);
-        StorageDead(_10);
+        StorageDead(_7);
+        _0 = Option::<std::cmp::Ordering>::Some(move _9);
+        StorageDead(_9);
         goto -> bb3;
     }
 
     bb2: {
-        _0 = copy _6;
         goto -> bb3;
     }
 
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 dfe618612ab96..03a52b82b49b1 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
@@ -5,23 +5,21 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () {
     debug end => _2;
     debug f => _3;
     let mut _0: ();
-    let mut _4: u32;
-    let mut _9: std::option::Option<u32>;
-    let mut _11: &impl Fn(u32);
-    let mut _12: (u32,);
-    let _13: ();
+    let mut _7: std::option::Option<u32>;
+    let mut _9: &impl Fn(u32);
+    let mut _10: (u32,);
+    let _11: ();
     scope 1 {
-        debug ((iter: std::ops::Range<u32>).0: u32) => _4;
+        debug ((iter: std::ops::Range<u32>).0: u32) => _1;
         debug ((iter: std::ops::Range<u32>).1: u32) => _2;
-        let _10: u32;
+        let _8: u32;
         scope 2 {
-            debug x => _10;
+            debug x => _8;
         }
         scope 4 (inlined iter::range::<impl Iterator for std::ops::Range<u32>>::next) {
             scope 5 (inlined <std::ops::Range<u32> as iter::range::RangeIteratorImpl>::spec_next) {
-                let mut _6: bool;
-                let _7: u32;
-                let mut _8: u32;
+                let mut _5: bool;
+                let _6: u32;
                 scope 6 {
                     scope 8 (inlined <u32 as Step>::forward_unchecked) {
                         scope 9 (inlined #[track_caller] core::num::<impl u32>::unchecked_add) {
@@ -33,7 +31,7 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () {
                     }
                 }
                 scope 7 (inlined std::cmp::impls::<impl PartialOrd for u32>::lt) {
-                    let mut _5: u32;
+                    let mut _4: u32;
                 }
             }
         }
@@ -42,25 +40,22 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () {
     }
 
     bb0: {
-        StorageLive(_4);
-        _4 = copy _1;
         goto -> bb1;
     }
 
     bb1: {
-        StorageLive(_9);
-        StorageLive(_6);
+        StorageLive(_7);
         StorageLive(_5);
-        _5 = copy _4;
-        _6 = Lt(move _5, copy _2);
-        StorageDead(_5);
-        switchInt(move _6) -> [0: bb2, otherwise: bb4];
+        StorageLive(_4);
+        _4 = copy _1;
+        _5 = Lt(move _4, copy _2);
+        StorageDead(_4);
+        switchInt(move _5) -> [0: bb2, otherwise: bb4];
     }
 
     bb2: {
-        StorageDead(_6);
-        StorageDead(_9);
-        StorageDead(_4);
+        StorageDead(_5);
+        StorageDead(_7);
         drop(_3) -> [return: bb3, unwind unreachable];
     }
 
@@ -69,25 +64,22 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () {
     }
 
     bb4: {
-        _7 = copy _4;
-        StorageLive(_8);
-        _8 = AddUnchecked(copy _7, const 1_u32);
-        _4 = move _8;
-        StorageDead(_8);
-        _9 = Option::<u32>::Some(copy _7);
-        StorageDead(_6);
-        _10 = copy ((_9 as Some).0: u32);
-        StorageLive(_11);
-        _11 = &_3;
-        StorageLive(_12);
-        _12 = (copy _10,);
-        _13 = <impl Fn(u32) as Fn<(u32,)>>::call(move _11, move _12) -> [return: bb5, unwind unreachable];
+        _6 = copy _1;
+        _1 = AddUnchecked(copy _6, const 1_u32);
+        _7 = Option::<u32>::Some(copy _6);
+        StorageDead(_5);
+        _8 = copy ((_7 as Some).0: u32);
+        StorageLive(_9);
+        _9 = &_3;
+        StorageLive(_10);
+        _10 = (copy _8,);
+        _11 = <impl Fn(u32) as Fn<(u32,)>>::call(move _9, move _10) -> [return: bb5, unwind unreachable];
     }
 
     bb5: {
-        StorageDead(_12);
-        StorageDead(_11);
+        StorageDead(_10);
         StorageDead(_9);
+        StorageDead(_7);
         goto -> bb1;
     }
 }
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 e0fcfcaffc59a..3b09f33e73338 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
@@ -5,23 +5,21 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () {
     debug end => _2;
     debug f => _3;
     let mut _0: ();
-    let mut _4: u32;
-    let mut _9: std::option::Option<u32>;
-    let mut _11: &impl Fn(u32);
-    let mut _12: (u32,);
-    let _13: ();
+    let mut _7: std::option::Option<u32>;
+    let mut _9: &impl Fn(u32);
+    let mut _10: (u32,);
+    let _11: ();
     scope 1 {
-        debug ((iter: std::ops::Range<u32>).0: u32) => _4;
+        debug ((iter: std::ops::Range<u32>).0: u32) => _1;
         debug ((iter: std::ops::Range<u32>).1: u32) => _2;
-        let _10: u32;
+        let _8: u32;
         scope 2 {
-            debug x => _10;
+            debug x => _8;
         }
         scope 4 (inlined iter::range::<impl Iterator for std::ops::Range<u32>>::next) {
             scope 5 (inlined <std::ops::Range<u32> as iter::range::RangeIteratorImpl>::spec_next) {
-                let mut _6: bool;
-                let _7: u32;
-                let mut _8: u32;
+                let mut _5: bool;
+                let _6: u32;
                 scope 6 {
                     scope 8 (inlined <u32 as Step>::forward_unchecked) {
                         scope 9 (inlined #[track_caller] core::num::<impl u32>::unchecked_add) {
@@ -33,7 +31,7 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () {
                     }
                 }
                 scope 7 (inlined std::cmp::impls::<impl PartialOrd for u32>::lt) {
-                    let mut _5: u32;
+                    let mut _4: u32;
                 }
             }
         }
@@ -42,25 +40,22 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () {
     }
 
     bb0: {
-        StorageLive(_4);
-        _4 = copy _1;
         goto -> bb1;
     }
 
     bb1: {
-        StorageLive(_9);
-        StorageLive(_6);
+        StorageLive(_7);
         StorageLive(_5);
-        _5 = copy _4;
-        _6 = Lt(move _5, copy _2);
-        StorageDead(_5);
-        switchInt(move _6) -> [0: bb2, otherwise: bb4];
+        StorageLive(_4);
+        _4 = copy _1;
+        _5 = Lt(move _4, copy _2);
+        StorageDead(_4);
+        switchInt(move _5) -> [0: bb2, otherwise: bb4];
     }
 
     bb2: {
-        StorageDead(_6);
-        StorageDead(_9);
-        StorageDead(_4);
+        StorageDead(_5);
+        StorageDead(_7);
         drop(_3) -> [return: bb3, unwind continue];
     }
 
@@ -69,25 +64,22 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () {
     }
 
     bb4: {
-        _7 = copy _4;
-        StorageLive(_8);
-        _8 = AddUnchecked(copy _7, const 1_u32);
-        _4 = move _8;
-        StorageDead(_8);
-        _9 = Option::<u32>::Some(copy _7);
-        StorageDead(_6);
-        _10 = copy ((_9 as Some).0: u32);
-        StorageLive(_11);
-        _11 = &_3;
-        StorageLive(_12);
-        _12 = (copy _10,);
-        _13 = <impl Fn(u32) as Fn<(u32,)>>::call(move _11, move _12) -> [return: bb5, unwind: bb6];
+        _6 = copy _1;
+        _1 = AddUnchecked(copy _6, const 1_u32);
+        _7 = Option::<u32>::Some(copy _6);
+        StorageDead(_5);
+        _8 = copy ((_7 as Some).0: u32);
+        StorageLive(_9);
+        _9 = &_3;
+        StorageLive(_10);
+        _10 = (copy _8,);
+        _11 = <impl Fn(u32) as Fn<(u32,)>>::call(move _9, move _10) -> [return: bb5, unwind: bb6];
     }
 
     bb5: {
-        StorageDead(_12);
-        StorageDead(_11);
+        StorageDead(_10);
         StorageDead(_9);
+        StorageDead(_7);
         goto -> bb1;
     }
 
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 72b39a7f6a87b..104987b0fdda9 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
@@ -4,30 +4,28 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     debug slice => _1;
     debug f => _2;
     let mut _0: ();
-    let mut _11: std::ptr::NonNull<T>;
-    let mut _12: *const T;
-    let mut _13: usize;
-    let mut _32: std::option::Option<(usize, &T)>;
-    let mut _35: &impl Fn(usize, &T);
-    let mut _36: (usize, &T);
-    let _37: ();
+    let mut _10: usize;
+    let mut _28: std::option::Option<(usize, &T)>;
+    let mut _31: &impl Fn(usize, &T);
+    let mut _32: (usize, &T);
+    let _33: ();
     scope 1 {
-        debug (((iter: Enumerate<std::slice::Iter<'_, T>>).0: std::slice::Iter<'_, T>).0: std::ptr::NonNull<T>) => _11;
-        debug (((iter: Enumerate<std::slice::Iter<'_, T>>).0: std::slice::Iter<'_, T>).1: *const T) => _12;
+        debug (((iter: Enumerate<std::slice::Iter<'_, T>>).0: std::slice::Iter<'_, T>).0: std::ptr::NonNull<T>) => _6;
+        debug (((iter: Enumerate<std::slice::Iter<'_, T>>).0: std::slice::Iter<'_, T>).1: *const T) => _9;
         debug (((iter: Enumerate<std::slice::Iter<'_, T>>).0: std::slice::Iter<'_, T>).2: std::marker::PhantomData<&T>) => const ZeroSized: PhantomData<&T>;
-        debug ((iter: Enumerate<std::slice::Iter<'_, T>>).1: usize) => _13;
-        let _33: usize;
-        let _34: &T;
+        debug ((iter: Enumerate<std::slice::Iter<'_, T>>).1: usize) => _10;
+        let _29: usize;
+        let _30: &T;
         scope 2 {
-            debug i => _33;
-            debug x => _34;
+            debug i => _29;
+            debug x => _30;
         }
         scope 18 (inlined <Enumerate<std::slice::Iter<'_, T>> as Iterator>::next) {
-            let mut _27: std::option::Option<&T>;
-            let mut _30: (usize, bool);
-            let mut _31: (usize, &T);
+            let mut _23: std::option::Option<&T>;
+            let mut _26: (usize, bool);
+            let mut _27: (usize, &T);
             scope 19 {
-                let _29: usize;
+                let _25: usize;
                 scope 24 {
                 }
             }
@@ -42,21 +40,21 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
                 }
             }
             scope 25 (inlined <Option<&T> as Try>::branch) {
-                let _28: &T;
+                let _24: &T;
                 scope 26 {
                 }
             }
             scope 28 (inlined <std::slice::Iter<'_, T> as Iterator>::next) {
-                let _14: std::ptr::NonNull<T>;
-                let _16: std::ptr::NonNull<T>;
-                let mut _19: bool;
-                let mut _22: std::ptr::NonNull<T>;
-                let mut _24: usize;
-                let _26: &T;
+                let mut _6: std::ptr::NonNull<T>;
+                let _11: std::ptr::NonNull<T>;
+                let _13: std::ptr::NonNull<T>;
+                let mut _16: bool;
+                let mut _20: usize;
+                let _22: &T;
                 scope 29 {
-                    let _15: *const T;
+                    let _12: *const T;
                     scope 30 {
-                        let _23: usize;
+                        let _19: usize;
                         scope 31 {
                             scope 34 (inlined #[track_caller] core::num::<impl usize>::unchecked_sub) {
                                 scope 35 (inlined core::ub_checks::check_language_ub) {
@@ -72,21 +70,21 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
                             }
                         }
                         scope 38 (inlined <NonNull<T> as PartialEq>::eq) {
-                            let mut _17: *mut T;
-                            let mut _18: *mut T;
+                            let mut _14: *mut T;
+                            let mut _15: *mut T;
                             scope 39 (inlined NonNull::<T>::as_ptr) {
                             }
                             scope 40 (inlined NonNull::<T>::as_ptr) {
                             }
                         }
                         scope 41 (inlined NonNull::<T>::add) {
-                            let mut _20: *const T;
-                            let mut _21: *const T;
+                            let mut _17: *const T;
+                            let mut _18: *const T;
                             scope 42 (inlined NonNull::<T>::as_ptr) {
                             }
                         }
                         scope 43 (inlined NonNull::<T>::as_ref::<'_>) {
-                            let _25: *const T;
+                            let _21: *const T;
                             scope 44 (inlined NonNull::<T>::as_ptr) {
                             }
                             scope 45 (inlined std::ptr::mut_ptr::<impl *mut T>::cast_const) {
@@ -102,9 +100,7 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
             let _3: usize;
             let mut _7: *mut T;
             let mut _8: *mut T;
-            let mut _10: *const T;
             scope 5 {
-                let _6: std::ptr::NonNull<T>;
                 scope 6 {
                     let _9: *const T;
                     scope 7 {
@@ -145,7 +141,6 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
         _5 = copy _4 as *const T (PtrToPtr);
         _6 = NonNull::<T> { pointer: copy _5 };
         StorageDead(_5);
-        StorageLive(_9);
         switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
     }
 
@@ -166,97 +161,86 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb3: {
-        _10 = copy _9;
-        StorageDead(_9);
         StorageDead(_4);
         StorageDead(_3);
-        StorageLive(_11);
-        StorageLive(_12);
-        StorageLive(_13);
-        _11 = copy _6;
-        _12 = copy _10;
-        _13 = const 0_usize;
+        StorageLive(_10);
+        _10 = const 0_usize;
         goto -> bb4;
     }
 
     bb4: {
-        StorageLive(_32);
-        StorageLive(_29);
-        StorageLive(_30);
-        StorageLive(_27);
-        StorageLive(_14);
-        StorageLive(_15);
-        StorageLive(_23);
-        StorageLive(_24);
-        StorageLive(_16);
+        StorageLive(_28);
+        StorageLive(_25);
         StorageLive(_26);
-        _14 = copy _11;
-        _15 = copy _12;
+        StorageLive(_23);
+        StorageLive(_11);
+        StorageLive(_12);
+        StorageLive(_19);
+        StorageLive(_20);
+        StorageLive(_13);
+        StorageLive(_22);
+        _11 = copy _6;
+        _12 = copy _9;
         switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb5, otherwise: bb8];
     }
 
     bb5: {
-        StorageLive(_19);
-        _16 = copy _15 as std::ptr::NonNull<T> (Transmute);
-        StorageLive(_17);
-        _17 = copy _14 as *mut T (Transmute);
-        StorageLive(_18);
-        _18 = copy _16 as *mut T (Transmute);
-        _19 = Eq(copy _17, copy _18);
-        StorageDead(_18);
-        StorageDead(_17);
-        switchInt(move _19) -> [0: bb6, otherwise: bb7];
+        StorageLive(_16);
+        _13 = copy _12 as std::ptr::NonNull<T> (Transmute);
+        StorageLive(_14);
+        _14 = copy _11 as *mut T (Transmute);
+        StorageLive(_15);
+        _15 = copy _13 as *mut T (Transmute);
+        _16 = Eq(copy _14, copy _15);
+        StorageDead(_15);
+        StorageDead(_14);
+        switchInt(move _16) -> [0: bb6, otherwise: bb7];
     }
 
     bb6: {
-        StorageDead(_19);
-        StorageLive(_22);
-        StorageLive(_21);
-        StorageLive(_20);
-        _20 = copy _14 as *const T (Transmute);
-        _21 = Offset(copy _20, const 1_usize);
-        StorageDead(_20);
-        _22 = NonNull::<T> { pointer: copy _21 };
-        StorageDead(_21);
-        _11 = move _22;
-        StorageDead(_22);
+        StorageDead(_16);
+        StorageLive(_18);
+        StorageLive(_17);
+        _17 = copy _11 as *const T (Transmute);
+        _18 = Offset(copy _17, const 1_usize);
+        StorageDead(_17);
+        _6 = NonNull::<T> { pointer: copy _18 };
+        StorageDead(_18);
         goto -> bb13;
     }
 
     bb7: {
-        StorageDead(_19);
-        StorageDead(_26);
         StorageDead(_16);
-        StorageDead(_24);
-        StorageDead(_23);
-        StorageDead(_15);
-        StorageDead(_14);
+        StorageDead(_22);
+        StorageDead(_13);
+        StorageDead(_20);
+        StorageDead(_19);
+        StorageDead(_12);
+        StorageDead(_11);
         goto -> bb10;
     }
 
     bb8: {
-        _23 = copy _15 as usize (Transmute);
-        switchInt(copy _23) -> [0: bb9, otherwise: bb12];
+        _19 = copy _12 as usize (Transmute);
+        switchInt(copy _19) -> [0: bb9, otherwise: bb12];
     }
 
     bb9: {
-        StorageDead(_26);
-        StorageDead(_16);
-        StorageDead(_24);
-        StorageDead(_23);
-        StorageDead(_15);
-        StorageDead(_14);
+        StorageDead(_22);
+        StorageDead(_13);
+        StorageDead(_20);
+        StorageDead(_19);
+        StorageDead(_12);
+        StorageDead(_11);
         goto -> bb10;
     }
 
     bb10: {
-        StorageDead(_27);
-        StorageDead(_30);
-        StorageDead(_29);
-        StorageDead(_32);
-        StorageDead(_11);
-        StorageDead(_12);
-        StorageDead(_13);
+        StorageDead(_23);
+        StorageDead(_26);
+        StorageDead(_25);
+        StorageDead(_28);
+        StorageDead(_10);
         drop(_2) -> [return: bb11, unwind unreachable];
     }
 
@@ -265,51 +249,51 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb12: {
-        _24 = SubUnchecked(copy _23, const 1_usize);
-        _12 = copy _24 as *const T (Transmute);
+        _20 = SubUnchecked(copy _19, const 1_usize);
+        _9 = copy _20 as *const T (Transmute);
         goto -> bb13;
     }
 
     bb13: {
-        StorageLive(_25);
-        _25 = copy _14 as *const T (Transmute);
-        _26 = &(*_25);
-        StorageDead(_25);
-        _27 = Option::<&T>::Some(copy _26);
-        StorageDead(_26);
-        StorageDead(_16);
-        StorageDead(_24);
+        StorageLive(_21);
+        _21 = copy _11 as *const T (Transmute);
+        _22 = &(*_21);
+        StorageDead(_21);
+        _23 = Option::<&T>::Some(copy _22);
+        StorageDead(_22);
+        StorageDead(_13);
+        StorageDead(_20);
+        StorageDead(_19);
+        StorageDead(_12);
+        StorageDead(_11);
+        _24 = copy ((_23 as Some).0: &T);
         StorageDead(_23);
-        StorageDead(_15);
-        StorageDead(_14);
-        _28 = copy ((_27 as Some).0: &T);
-        StorageDead(_27);
-        _29 = copy _13;
-        _30 = AddWithOverflow(copy _13, const 1_usize);
-        assert(!move (_30.1: bool), "attempt to compute `{} + {}`, which would overflow", copy _13, const 1_usize) -> [success: bb14, unwind unreachable];
+        _25 = copy _10;
+        _26 = AddWithOverflow(copy _10, const 1_usize);
+        assert(!move (_26.1: bool), "attempt to compute `{} + {}`, which would overflow", copy _10, const 1_usize) -> [success: bb14, unwind unreachable];
     }
 
     bb14: {
-        _13 = move (_30.0: usize);
+        _10 = move (_26.0: usize);
+        StorageLive(_27);
+        _27 = (copy _25, copy _24);
+        _28 = Option::<(usize, &T)>::Some(move _27);
+        StorageDead(_27);
+        StorageDead(_26);
+        StorageDead(_25);
+        _29 = copy (((_28 as Some).0: (usize, &T)).0: usize);
+        _30 = copy (((_28 as Some).0: (usize, &T)).1: &T);
         StorageLive(_31);
-        _31 = (copy _29, copy _28);
-        _32 = Option::<(usize, &T)>::Some(move _31);
-        StorageDead(_31);
-        StorageDead(_30);
-        StorageDead(_29);
-        _33 = copy (((_32 as Some).0: (usize, &T)).0: usize);
-        _34 = copy (((_32 as Some).0: (usize, &T)).1: &T);
-        StorageLive(_35);
-        _35 = &_2;
-        StorageLive(_36);
-        _36 = (copy _33, copy _34);
-        _37 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _35, move _36) -> [return: bb15, unwind unreachable];
+        _31 = &_2;
+        StorageLive(_32);
+        _32 = (copy _29, copy _30);
+        _33 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _31, move _32) -> [return: bb15, unwind unreachable];
     }
 
     bb15: {
-        StorageDead(_36);
-        StorageDead(_35);
         StorageDead(_32);
+        StorageDead(_31);
+        StorageDead(_28);
         goto -> bb4;
     }
 }
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 42aa152ec99d6..28b12cdf36755 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
@@ -4,22 +4,22 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     debug slice => _1;
     debug f => _2;
     let mut _0: ();
-    let mut _11: std::slice::Iter<'_, T>;
+    let mut _10: std::slice::Iter<'_, T>;
+    let mut _11: std::iter::Enumerate<std::slice::Iter<'_, T>>;
     let mut _12: std::iter::Enumerate<std::slice::Iter<'_, T>>;
-    let mut _13: std::iter::Enumerate<std::slice::Iter<'_, T>>;
-    let mut _14: &mut std::iter::Enumerate<std::slice::Iter<'_, T>>;
-    let mut _15: std::option::Option<(usize, &T)>;
-    let mut _16: isize;
-    let mut _19: &impl Fn(usize, &T);
-    let mut _20: (usize, &T);
-    let _21: ();
+    let mut _13: &mut std::iter::Enumerate<std::slice::Iter<'_, T>>;
+    let mut _14: std::option::Option<(usize, &T)>;
+    let mut _15: isize;
+    let mut _18: &impl Fn(usize, &T);
+    let mut _19: (usize, &T);
+    let _20: ();
     scope 1 {
-        debug iter => _13;
-        let _17: usize;
-        let _18: &T;
+        debug iter => _12;
+        let _16: usize;
+        let _17: &T;
         scope 2 {
-            debug i => _17;
-            debug x => _18;
+            debug i => _16;
+            debug x => _17;
         }
     }
     scope 3 (inlined core::slice::<impl [T]>::iter) {
@@ -27,7 +27,6 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
             let _3: usize;
             let mut _7: *mut T;
             let mut _8: *mut T;
-            let mut _10: *const T;
             scope 5 {
                 let _6: std::ptr::NonNull<T>;
                 scope 6 {
@@ -62,9 +61,10 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb0: {
-        StorageLive(_11);
+        StorageLive(_10);
         StorageLive(_3);
         StorageLive(_6);
+        StorageLive(_9);
         StorageLive(_4);
         _3 = PtrMetadata(copy _1);
         _4 = &raw const (*_1);
@@ -72,7 +72,6 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
         _5 = copy _4 as *const T (PtrToPtr);
         _6 = NonNull::<T> { pointer: copy _5 };
         StorageDead(_5);
-        StorageLive(_9);
         switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
     }
 
@@ -93,33 +92,30 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb3: {
-        StorageLive(_10);
-        _10 = copy _9;
-        _11 = std::slice::Iter::<'_, T> { ptr: copy _6, end_or_len: copy _10, _marker: const ZeroSized: PhantomData<&T> };
-        StorageDead(_10);
-        StorageDead(_9);
+        _10 = std::slice::Iter::<'_, T> { ptr: copy _6, end_or_len: copy _9, _marker: const ZeroSized: PhantomData<&T> };
         StorageDead(_4);
+        StorageDead(_9);
         StorageDead(_6);
         StorageDead(_3);
-        _12 = Enumerate::<std::slice::Iter<'_, T>> { iter: copy _11, count: const 0_usize };
-        StorageDead(_11);
-        StorageLive(_13);
-        _13 = copy _12;
+        _11 = Enumerate::<std::slice::Iter<'_, T>> { iter: copy _10, count: const 0_usize };
+        StorageDead(_10);
+        StorageLive(_12);
+        _12 = copy _11;
         goto -> bb4;
     }
 
     bb4: {
-        _14 = &mut _13;
-        _15 = <Enumerate<std::slice::Iter<'_, T>> as Iterator>::next(move _14) -> [return: bb5, unwind: bb11];
+        _13 = &mut _12;
+        _14 = <Enumerate<std::slice::Iter<'_, T>> as Iterator>::next(move _13) -> [return: bb5, unwind: bb11];
     }
 
     bb5: {
-        _16 = discriminant(_15);
-        switchInt(move _16) -> [0: bb6, 1: bb8, otherwise: bb10];
+        _15 = discriminant(_14);
+        switchInt(move _15) -> [0: bb6, 1: bb8, otherwise: bb10];
     }
 
     bb6: {
-        StorageDead(_13);
+        StorageDead(_12);
         drop(_2) -> [return: bb7, unwind continue];
     }
 
@@ -128,18 +124,18 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb8: {
-        _17 = copy (((_15 as Some).0: (usize, &T)).0: usize);
-        _18 = copy (((_15 as Some).0: (usize, &T)).1: &T);
+        _16 = copy (((_14 as Some).0: (usize, &T)).0: usize);
+        _17 = copy (((_14 as Some).0: (usize, &T)).1: &T);
+        StorageLive(_18);
+        _18 = &_2;
         StorageLive(_19);
-        _19 = &_2;
-        StorageLive(_20);
-        _20 = copy ((_15 as Some).0: (usize, &T));
-        _21 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _19, move _20) -> [return: bb9, unwind: bb11];
+        _19 = copy ((_14 as Some).0: (usize, &T));
+        _20 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _18, move _19) -> [return: bb9, unwind: bb11];
     }
 
     bb9: {
-        StorageDead(_20);
         StorageDead(_19);
+        StorageDead(_18);
         goto -> bb4;
     }
 
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 0d65640ec9b14..4d0e3548e7d6b 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
@@ -4,31 +4,29 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     debug slice => _1;
     debug f => _2;
     let mut _0: ();
-    let mut _11: std::ptr::NonNull<T>;
-    let mut _12: *const T;
-    let mut _26: std::option::Option<&T>;
-    let mut _28: &impl Fn(&T);
-    let mut _29: (&T,);
-    let _30: ();
+    let mut _22: std::option::Option<&T>;
+    let mut _24: &impl Fn(&T);
+    let mut _25: (&T,);
+    let _26: ();
     scope 1 {
-        debug ((iter: std::slice::Iter<'_, T>).0: std::ptr::NonNull<T>) => _11;
-        debug ((iter: std::slice::Iter<'_, T>).1: *const T) => _12;
+        debug ((iter: std::slice::Iter<'_, T>).0: std::ptr::NonNull<T>) => _6;
+        debug ((iter: std::slice::Iter<'_, T>).1: *const T) => _9;
         debug ((iter: std::slice::Iter<'_, T>).2: std::marker::PhantomData<&T>) => const ZeroSized: PhantomData<&T>;
-        let _27: &T;
+        let _23: &T;
         scope 2 {
-            debug x => _27;
+            debug x => _23;
         }
         scope 16 (inlined <std::slice::Iter<'_, T> as Iterator>::next) {
-            let _13: std::ptr::NonNull<T>;
-            let _15: std::ptr::NonNull<T>;
-            let mut _18: bool;
-            let mut _21: std::ptr::NonNull<T>;
-            let mut _23: usize;
-            let _25: &T;
+            let mut _6: std::ptr::NonNull<T>;
+            let _10: std::ptr::NonNull<T>;
+            let _12: std::ptr::NonNull<T>;
+            let mut _15: bool;
+            let mut _19: usize;
+            let _21: &T;
             scope 17 {
-                let _14: *const T;
+                let _11: *const T;
                 scope 18 {
-                    let _22: usize;
+                    let _18: usize;
                     scope 19 {
                         scope 22 (inlined #[track_caller] core::num::<impl usize>::unchecked_sub) {
                             scope 23 (inlined core::ub_checks::check_language_ub) {
@@ -44,21 +42,21 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
                         }
                     }
                     scope 26 (inlined <NonNull<T> as PartialEq>::eq) {
-                        let mut _16: *mut T;
-                        let mut _17: *mut T;
+                        let mut _13: *mut T;
+                        let mut _14: *mut T;
                         scope 27 (inlined NonNull::<T>::as_ptr) {
                         }
                         scope 28 (inlined NonNull::<T>::as_ptr) {
                         }
                     }
                     scope 29 (inlined NonNull::<T>::add) {
-                        let mut _19: *const T;
-                        let mut _20: *const T;
+                        let mut _16: *const T;
+                        let mut _17: *const T;
                         scope 30 (inlined NonNull::<T>::as_ptr) {
                         }
                     }
                     scope 31 (inlined NonNull::<T>::as_ref::<'_>) {
-                        let _24: *const T;
+                        let _20: *const T;
                         scope 32 (inlined NonNull::<T>::as_ptr) {
                         }
                         scope 33 (inlined std::ptr::mut_ptr::<impl *mut T>::cast_const) {
@@ -73,9 +71,7 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
             let _3: usize;
             let mut _7: *mut T;
             let mut _8: *mut T;
-            let mut _10: *const T;
             scope 5 {
-                let _6: std::ptr::NonNull<T>;
                 scope 6 {
                     let _9: *const T;
                     scope 7 {
@@ -112,7 +108,6 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         _5 = copy _4 as *const T (PtrToPtr);
         _6 = NonNull::<T> { pointer: copy _5 };
         StorageDead(_5);
-        StorageLive(_9);
         switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
     }
 
@@ -133,88 +128,77 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb3: {
-        _10 = copy _9;
-        StorageDead(_9);
         StorageDead(_4);
         StorageDead(_3);
-        StorageLive(_11);
-        StorageLive(_12);
-        _11 = copy _6;
-        _12 = copy _10;
         goto -> bb4;
     }
 
     bb4: {
-        StorageLive(_26);
-        StorageLive(_13);
-        StorageLive(_14);
         StorageLive(_22);
-        StorageLive(_23);
-        StorageLive(_15);
-        StorageLive(_25);
-        _13 = copy _11;
-        _14 = copy _12;
+        StorageLive(_10);
+        StorageLive(_11);
+        StorageLive(_18);
+        StorageLive(_19);
+        StorageLive(_12);
+        StorageLive(_21);
+        _10 = copy _6;
+        _11 = copy _9;
         switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb5, otherwise: bb8];
     }
 
     bb5: {
-        StorageLive(_18);
-        _15 = copy _14 as std::ptr::NonNull<T> (Transmute);
-        StorageLive(_16);
-        _16 = copy _13 as *mut T (Transmute);
-        StorageLive(_17);
-        _17 = copy _15 as *mut T (Transmute);
-        _18 = Eq(copy _16, copy _17);
-        StorageDead(_17);
-        StorageDead(_16);
-        switchInt(move _18) -> [0: bb6, otherwise: bb7];
+        StorageLive(_15);
+        _12 = copy _11 as std::ptr::NonNull<T> (Transmute);
+        StorageLive(_13);
+        _13 = copy _10 as *mut T (Transmute);
+        StorageLive(_14);
+        _14 = copy _12 as *mut T (Transmute);
+        _15 = Eq(copy _13, copy _14);
+        StorageDead(_14);
+        StorageDead(_13);
+        switchInt(move _15) -> [0: bb6, otherwise: bb7];
     }
 
     bb6: {
-        StorageDead(_18);
-        StorageLive(_21);
-        StorageLive(_20);
-        StorageLive(_19);
-        _19 = copy _13 as *const T (Transmute);
-        _20 = Offset(copy _19, const 1_usize);
-        StorageDead(_19);
-        _21 = NonNull::<T> { pointer: copy _20 };
-        StorageDead(_20);
-        _11 = move _21;
-        StorageDead(_21);
+        StorageDead(_15);
+        StorageLive(_17);
+        StorageLive(_16);
+        _16 = copy _10 as *const T (Transmute);
+        _17 = Offset(copy _16, const 1_usize);
+        StorageDead(_16);
+        _6 = NonNull::<T> { pointer: copy _17 };
+        StorageDead(_17);
         goto -> bb13;
     }
 
     bb7: {
-        StorageDead(_18);
-        StorageDead(_25);
         StorageDead(_15);
-        StorageDead(_23);
-        StorageDead(_22);
-        StorageDead(_14);
-        StorageDead(_13);
+        StorageDead(_21);
+        StorageDead(_12);
+        StorageDead(_19);
+        StorageDead(_18);
+        StorageDead(_11);
+        StorageDead(_10);
         goto -> bb10;
     }
 
     bb8: {
-        _22 = copy _14 as usize (Transmute);
-        switchInt(copy _22) -> [0: bb9, otherwise: bb12];
+        _18 = copy _11 as usize (Transmute);
+        switchInt(copy _18) -> [0: bb9, otherwise: bb12];
     }
 
     bb9: {
-        StorageDead(_25);
-        StorageDead(_15);
-        StorageDead(_23);
-        StorageDead(_22);
-        StorageDead(_14);
-        StorageDead(_13);
+        StorageDead(_21);
+        StorageDead(_12);
+        StorageDead(_19);
+        StorageDead(_18);
+        StorageDead(_11);
+        StorageDead(_10);
         goto -> bb10;
     }
 
     bb10: {
-        StorageDead(_26);
-        StorageDead(_11);
-        StorageDead(_12);
+        StorageDead(_22);
         drop(_2) -> [return: bb11, unwind unreachable];
     }
 
@@ -223,35 +207,35 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb12: {
-        _23 = SubUnchecked(copy _22, const 1_usize);
-        _12 = copy _23 as *const T (Transmute);
+        _19 = SubUnchecked(copy _18, const 1_usize);
+        _9 = copy _19 as *const T (Transmute);
         goto -> bb13;
     }
 
     bb13: {
+        StorageLive(_20);
+        _20 = copy _10 as *const T (Transmute);
+        _21 = &(*_20);
+        StorageDead(_20);
+        _22 = Option::<&T>::Some(copy _21);
+        StorageDead(_21);
+        StorageDead(_12);
+        StorageDead(_19);
+        StorageDead(_18);
+        StorageDead(_11);
+        StorageDead(_10);
+        _23 = copy ((_22 as Some).0: &T);
         StorageLive(_24);
-        _24 = copy _13 as *const T (Transmute);
-        _25 = &(*_24);
-        StorageDead(_24);
-        _26 = Option::<&T>::Some(copy _25);
-        StorageDead(_25);
-        StorageDead(_15);
-        StorageDead(_23);
-        StorageDead(_22);
-        StorageDead(_14);
-        StorageDead(_13);
-        _27 = copy ((_26 as Some).0: &T);
-        StorageLive(_28);
-        _28 = &_2;
-        StorageLive(_29);
-        _29 = (copy _27,);
-        _30 = <impl Fn(&T) as Fn<(&T,)>>::call(move _28, move _29) -> [return: bb14, unwind unreachable];
+        _24 = &_2;
+        StorageLive(_25);
+        _25 = (copy _23,);
+        _26 = <impl Fn(&T) as Fn<(&T,)>>::call(move _24, move _25) -> [return: bb14, unwind unreachable];
     }
 
     bb14: {
-        StorageDead(_29);
-        StorageDead(_28);
-        StorageDead(_26);
+        StorageDead(_25);
+        StorageDead(_24);
+        StorageDead(_22);
         goto -> bb4;
     }
 }
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 02efb193474d6..2b5d8c27d7109 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
@@ -4,31 +4,29 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     debug slice => _1;
     debug f => _2;
     let mut _0: ();
-    let mut _11: std::ptr::NonNull<T>;
-    let mut _12: *const T;
-    let mut _26: std::option::Option<&T>;
-    let mut _28: &impl Fn(&T);
-    let mut _29: (&T,);
-    let _30: ();
+    let mut _22: std::option::Option<&T>;
+    let mut _24: &impl Fn(&T);
+    let mut _25: (&T,);
+    let _26: ();
     scope 1 {
-        debug ((iter: std::slice::Iter<'_, T>).0: std::ptr::NonNull<T>) => _11;
-        debug ((iter: std::slice::Iter<'_, T>).1: *const T) => _12;
+        debug ((iter: std::slice::Iter<'_, T>).0: std::ptr::NonNull<T>) => _6;
+        debug ((iter: std::slice::Iter<'_, T>).1: *const T) => _9;
         debug ((iter: std::slice::Iter<'_, T>).2: std::marker::PhantomData<&T>) => const ZeroSized: PhantomData<&T>;
-        let _27: &T;
+        let _23: &T;
         scope 2 {
-            debug x => _27;
+            debug x => _23;
         }
         scope 16 (inlined <std::slice::Iter<'_, T> as Iterator>::next) {
-            let _13: std::ptr::NonNull<T>;
-            let _15: std::ptr::NonNull<T>;
-            let mut _18: bool;
-            let mut _21: std::ptr::NonNull<T>;
-            let mut _23: usize;
-            let _25: &T;
+            let mut _6: std::ptr::NonNull<T>;
+            let _10: std::ptr::NonNull<T>;
+            let _12: std::ptr::NonNull<T>;
+            let mut _15: bool;
+            let mut _19: usize;
+            let _21: &T;
             scope 17 {
-                let _14: *const T;
+                let _11: *const T;
                 scope 18 {
-                    let _22: usize;
+                    let _18: usize;
                     scope 19 {
                         scope 22 (inlined #[track_caller] core::num::<impl usize>::unchecked_sub) {
                             scope 23 (inlined core::ub_checks::check_language_ub) {
@@ -44,21 +42,21 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
                         }
                     }
                     scope 26 (inlined <NonNull<T> as PartialEq>::eq) {
-                        let mut _16: *mut T;
-                        let mut _17: *mut T;
+                        let mut _13: *mut T;
+                        let mut _14: *mut T;
                         scope 27 (inlined NonNull::<T>::as_ptr) {
                         }
                         scope 28 (inlined NonNull::<T>::as_ptr) {
                         }
                     }
                     scope 29 (inlined NonNull::<T>::add) {
-                        let mut _19: *const T;
-                        let mut _20: *const T;
+                        let mut _16: *const T;
+                        let mut _17: *const T;
                         scope 30 (inlined NonNull::<T>::as_ptr) {
                         }
                     }
                     scope 31 (inlined NonNull::<T>::as_ref::<'_>) {
-                        let _24: *const T;
+                        let _20: *const T;
                         scope 32 (inlined NonNull::<T>::as_ptr) {
                         }
                         scope 33 (inlined std::ptr::mut_ptr::<impl *mut T>::cast_const) {
@@ -73,9 +71,7 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
             let _3: usize;
             let mut _7: *mut T;
             let mut _8: *mut T;
-            let mut _10: *const T;
             scope 5 {
-                let _6: std::ptr::NonNull<T>;
                 scope 6 {
                     let _9: *const T;
                     scope 7 {
@@ -112,7 +108,6 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         _5 = copy _4 as *const T (PtrToPtr);
         _6 = NonNull::<T> { pointer: copy _5 };
         StorageDead(_5);
-        StorageLive(_9);
         switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
     }
 
@@ -133,88 +128,77 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb3: {
-        _10 = copy _9;
-        StorageDead(_9);
         StorageDead(_4);
         StorageDead(_3);
-        StorageLive(_11);
-        StorageLive(_12);
-        _11 = copy _6;
-        _12 = copy _10;
         goto -> bb4;
     }
 
     bb4: {
-        StorageLive(_26);
-        StorageLive(_13);
-        StorageLive(_14);
         StorageLive(_22);
-        StorageLive(_23);
-        StorageLive(_15);
-        StorageLive(_25);
-        _13 = copy _11;
-        _14 = copy _12;
+        StorageLive(_10);
+        StorageLive(_11);
+        StorageLive(_18);
+        StorageLive(_19);
+        StorageLive(_12);
+        StorageLive(_21);
+        _10 = copy _6;
+        _11 = copy _9;
         switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb5, otherwise: bb8];
     }
 
     bb5: {
-        StorageLive(_18);
-        _15 = copy _14 as std::ptr::NonNull<T> (Transmute);
-        StorageLive(_16);
-        _16 = copy _13 as *mut T (Transmute);
-        StorageLive(_17);
-        _17 = copy _15 as *mut T (Transmute);
-        _18 = Eq(copy _16, copy _17);
-        StorageDead(_17);
-        StorageDead(_16);
-        switchInt(move _18) -> [0: bb6, otherwise: bb7];
+        StorageLive(_15);
+        _12 = copy _11 as std::ptr::NonNull<T> (Transmute);
+        StorageLive(_13);
+        _13 = copy _10 as *mut T (Transmute);
+        StorageLive(_14);
+        _14 = copy _12 as *mut T (Transmute);
+        _15 = Eq(copy _13, copy _14);
+        StorageDead(_14);
+        StorageDead(_13);
+        switchInt(move _15) -> [0: bb6, otherwise: bb7];
     }
 
     bb6: {
-        StorageDead(_18);
-        StorageLive(_21);
-        StorageLive(_20);
-        StorageLive(_19);
-        _19 = copy _13 as *const T (Transmute);
-        _20 = Offset(copy _19, const 1_usize);
-        StorageDead(_19);
-        _21 = NonNull::<T> { pointer: copy _20 };
-        StorageDead(_20);
-        _11 = move _21;
-        StorageDead(_21);
+        StorageDead(_15);
+        StorageLive(_17);
+        StorageLive(_16);
+        _16 = copy _10 as *const T (Transmute);
+        _17 = Offset(copy _16, const 1_usize);
+        StorageDead(_16);
+        _6 = NonNull::<T> { pointer: copy _17 };
+        StorageDead(_17);
         goto -> bb13;
     }
 
     bb7: {
-        StorageDead(_18);
-        StorageDead(_25);
         StorageDead(_15);
-        StorageDead(_23);
-        StorageDead(_22);
-        StorageDead(_14);
-        StorageDead(_13);
+        StorageDead(_21);
+        StorageDead(_12);
+        StorageDead(_19);
+        StorageDead(_18);
+        StorageDead(_11);
+        StorageDead(_10);
         goto -> bb10;
     }
 
     bb8: {
-        _22 = copy _14 as usize (Transmute);
-        switchInt(copy _22) -> [0: bb9, otherwise: bb12];
+        _18 = copy _11 as usize (Transmute);
+        switchInt(copy _18) -> [0: bb9, otherwise: bb12];
     }
 
     bb9: {
-        StorageDead(_25);
-        StorageDead(_15);
-        StorageDead(_23);
-        StorageDead(_22);
-        StorageDead(_14);
-        StorageDead(_13);
+        StorageDead(_21);
+        StorageDead(_12);
+        StorageDead(_19);
+        StorageDead(_18);
+        StorageDead(_11);
+        StorageDead(_10);
         goto -> bb10;
     }
 
     bb10: {
-        StorageDead(_26);
-        StorageDead(_11);
-        StorageDead(_12);
+        StorageDead(_22);
         drop(_2) -> [return: bb11, unwind continue];
     }
 
@@ -223,35 +207,35 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb12: {
-        _23 = SubUnchecked(copy _22, const 1_usize);
-        _12 = copy _23 as *const T (Transmute);
+        _19 = SubUnchecked(copy _18, const 1_usize);
+        _9 = copy _19 as *const T (Transmute);
         goto -> bb13;
     }
 
     bb13: {
+        StorageLive(_20);
+        _20 = copy _10 as *const T (Transmute);
+        _21 = &(*_20);
+        StorageDead(_20);
+        _22 = Option::<&T>::Some(copy _21);
+        StorageDead(_21);
+        StorageDead(_12);
+        StorageDead(_19);
+        StorageDead(_18);
+        StorageDead(_11);
+        StorageDead(_10);
+        _23 = copy ((_22 as Some).0: &T);
         StorageLive(_24);
-        _24 = copy _13 as *const T (Transmute);
-        _25 = &(*_24);
-        StorageDead(_24);
-        _26 = Option::<&T>::Some(copy _25);
-        StorageDead(_25);
-        StorageDead(_15);
-        StorageDead(_23);
-        StorageDead(_22);
-        StorageDead(_14);
-        StorageDead(_13);
-        _27 = copy ((_26 as Some).0: &T);
-        StorageLive(_28);
-        _28 = &_2;
-        StorageLive(_29);
-        _29 = (copy _27,);
-        _30 = <impl Fn(&T) as Fn<(&T,)>>::call(move _28, move _29) -> [return: bb14, unwind: bb15];
+        _24 = &_2;
+        StorageLive(_25);
+        _25 = (copy _23,);
+        _26 = <impl Fn(&T) as Fn<(&T,)>>::call(move _24, move _25) -> [return: bb14, unwind: bb15];
     }
 
     bb14: {
-        StorageDead(_29);
-        StorageDead(_28);
-        StorageDead(_26);
+        StorageDead(_25);
+        StorageDead(_24);
+        StorageDead(_22);
         goto -> bb4;
     }
 
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 41e273151eca4..145375990710b 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
@@ -5,28 +5,27 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     debug f => _2;
     let mut _0: ();
     let mut _3: usize;
-    let mut _4: usize;
-    let mut _9: std::option::Option<usize>;
-    let mut _11: bool;
-    let mut _13: &impl Fn(usize, &T);
-    let mut _14: (usize, &T);
-    let _15: ();
+    let mut _8: std::option::Option<usize>;
+    let mut _10: bool;
+    let mut _12: &impl Fn(usize, &T);
+    let mut _13: (usize, &T);
+    let _14: ();
     scope 1 {
         debug ((iter: std::ops::Range<usize>).0: usize) => _4;
         debug ((iter: std::ops::Range<usize>).1: usize) => _3;
-        let _10: usize;
+        let _9: usize;
         scope 2 {
-            debug i => _10;
-            let _12: &T;
+            debug i => _9;
+            let _11: &T;
             scope 3 {
-                debug x => _12;
+                debug x => _11;
             }
         }
         scope 5 (inlined iter::range::<impl Iterator for std::ops::Range<usize>>::next) {
             scope 6 (inlined <std::ops::Range<usize> as iter::range::RangeIteratorImpl>::spec_next) {
+                let mut _4: usize;
                 let mut _6: bool;
                 let _7: usize;
-                let mut _8: usize;
                 scope 7 {
                     scope 9 (inlined <usize as Step>::forward_unchecked) {
                         scope 10 (inlined #[track_caller] core::num::<impl usize>::unchecked_add) {
@@ -48,13 +47,12 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
 
     bb0: {
         _3 = PtrMetadata(copy _1);
-        StorageLive(_4);
         _4 = const 0_usize;
         goto -> bb1;
     }
 
     bb1: {
-        StorageLive(_9);
+        StorageLive(_8);
         StorageLive(_6);
         StorageLive(_5);
         _5 = copy _4;
@@ -65,8 +63,7 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
 
     bb2: {
         StorageDead(_6);
-        StorageDead(_9);
-        StorageDead(_4);
+        StorageDead(_8);
         drop(_2) -> [return: bb3, unwind unreachable];
     }
 
@@ -76,30 +73,27 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
 
     bb4: {
         _7 = copy _4;
-        StorageLive(_8);
-        _8 = AddUnchecked(copy _7, const 1_usize);
-        _4 = move _8;
-        StorageDead(_8);
-        _9 = Option::<usize>::Some(copy _7);
+        _4 = AddUnchecked(copy _7, const 1_usize);
+        _8 = Option::<usize>::Some(copy _7);
         StorageDead(_6);
-        _10 = copy ((_9 as Some).0: usize);
-        _11 = Lt(copy _10, copy _3);
-        assert(move _11, "index out of bounds: the length is {} but the index is {}", copy _3, copy _10) -> [success: bb5, unwind unreachable];
+        _9 = copy ((_8 as Some).0: usize);
+        _10 = Lt(copy _9, copy _3);
+        assert(move _10, "index out of bounds: the length is {} but the index is {}", copy _3, copy _9) -> [success: bb5, unwind unreachable];
     }
 
     bb5: {
-        _12 = &(*_1)[_10];
+        _11 = &(*_1)[_9];
+        StorageLive(_12);
+        _12 = &_2;
         StorageLive(_13);
-        _13 = &_2;
-        StorageLive(_14);
-        _14 = (copy _10, copy _12);
-        _15 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _13, move _14) -> [return: bb6, unwind unreachable];
+        _13 = (copy _9, copy _11);
+        _14 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _12, move _13) -> [return: bb6, unwind unreachable];
     }
 
     bb6: {
-        StorageDead(_14);
         StorageDead(_13);
-        StorageDead(_9);
+        StorageDead(_12);
+        StorageDead(_8);
         goto -> bb1;
     }
 }
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 ec781c1480c74..8e573ef488fce 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
@@ -5,28 +5,27 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     debug f => _2;
     let mut _0: ();
     let mut _3: usize;
-    let mut _4: usize;
-    let mut _9: std::option::Option<usize>;
-    let mut _11: bool;
-    let mut _13: &impl Fn(usize, &T);
-    let mut _14: (usize, &T);
-    let _15: ();
+    let mut _8: std::option::Option<usize>;
+    let mut _10: bool;
+    let mut _12: &impl Fn(usize, &T);
+    let mut _13: (usize, &T);
+    let _14: ();
     scope 1 {
         debug ((iter: std::ops::Range<usize>).0: usize) => _4;
         debug ((iter: std::ops::Range<usize>).1: usize) => _3;
-        let _10: usize;
+        let _9: usize;
         scope 2 {
-            debug i => _10;
-            let _12: &T;
+            debug i => _9;
+            let _11: &T;
             scope 3 {
-                debug x => _12;
+                debug x => _11;
             }
         }
         scope 5 (inlined iter::range::<impl Iterator for std::ops::Range<usize>>::next) {
             scope 6 (inlined <std::ops::Range<usize> as iter::range::RangeIteratorImpl>::spec_next) {
+                let mut _4: usize;
                 let mut _6: bool;
                 let _7: usize;
-                let mut _8: usize;
                 scope 7 {
                     scope 9 (inlined <usize as Step>::forward_unchecked) {
                         scope 10 (inlined #[track_caller] core::num::<impl usize>::unchecked_add) {
@@ -48,13 +47,12 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
 
     bb0: {
         _3 = PtrMetadata(copy _1);
-        StorageLive(_4);
         _4 = const 0_usize;
         goto -> bb1;
     }
 
     bb1: {
-        StorageLive(_9);
+        StorageLive(_8);
         StorageLive(_6);
         StorageLive(_5);
         _5 = copy _4;
@@ -65,8 +63,7 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
 
     bb2: {
         StorageDead(_6);
-        StorageDead(_9);
-        StorageDead(_4);
+        StorageDead(_8);
         drop(_2) -> [return: bb3, unwind continue];
     }
 
@@ -76,30 +73,27 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
 
     bb4: {
         _7 = copy _4;
-        StorageLive(_8);
-        _8 = AddUnchecked(copy _7, const 1_usize);
-        _4 = move _8;
-        StorageDead(_8);
-        _9 = Option::<usize>::Some(copy _7);
+        _4 = AddUnchecked(copy _7, const 1_usize);
+        _8 = Option::<usize>::Some(copy _7);
         StorageDead(_6);
-        _10 = copy ((_9 as Some).0: usize);
-        _11 = Lt(copy _10, copy _3);
-        assert(move _11, "index out of bounds: the length is {} but the index is {}", copy _3, copy _10) -> [success: bb5, unwind: bb7];
+        _9 = copy ((_8 as Some).0: usize);
+        _10 = Lt(copy _9, copy _3);
+        assert(move _10, "index out of bounds: the length is {} but the index is {}", copy _3, copy _9) -> [success: bb5, unwind: bb7];
     }
 
     bb5: {
-        _12 = &(*_1)[_10];
+        _11 = &(*_1)[_9];
+        StorageLive(_12);
+        _12 = &_2;
         StorageLive(_13);
-        _13 = &_2;
-        StorageLive(_14);
-        _14 = (copy _10, copy _12);
-        _15 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _13, move _14) -> [return: bb6, unwind: bb7];
+        _13 = (copy _9, copy _11);
+        _14 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _12, move _13) -> [return: bb6, unwind: bb7];
     }
 
     bb6: {
-        StorageDead(_14);
         StorageDead(_13);
-        StorageDead(_9);
+        StorageDead(_12);
+        StorageDead(_8);
         goto -> bb1;
     }
 
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 ee638be7d7ac2..0adf268d766dd 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
@@ -4,22 +4,22 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     debug slice => _1;
     debug f => _2;
     let mut _0: ();
-    let mut _11: std::slice::Iter<'_, T>;
+    let mut _10: std::slice::Iter<'_, T>;
+    let mut _11: std::iter::Rev<std::slice::Iter<'_, T>>;
     let mut _12: std::iter::Rev<std::slice::Iter<'_, T>>;
-    let mut _13: std::iter::Rev<std::slice::Iter<'_, T>>;
-    let mut _15: std::option::Option<&T>;
-    let mut _16: isize;
-    let mut _18: &impl Fn(&T);
-    let mut _19: (&T,);
-    let _20: ();
+    let mut _14: std::option::Option<&T>;
+    let mut _15: isize;
+    let mut _17: &impl Fn(&T);
+    let mut _18: (&T,);
+    let _19: ();
     scope 1 {
-        debug iter => _13;
-        let _17: &T;
+        debug iter => _12;
+        let _16: &T;
         scope 2 {
-            debug x => _17;
+            debug x => _16;
         }
         scope 18 (inlined <Rev<std::slice::Iter<'_, T>> as Iterator>::next) {
-            let mut _14: &mut std::slice::Iter<'_, T>;
+            let mut _13: &mut std::slice::Iter<'_, T>;
         }
     }
     scope 3 (inlined core::slice::<impl [T]>::iter) {
@@ -27,7 +27,6 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
             let _3: usize;
             let mut _7: *mut T;
             let mut _8: *mut T;
-            let mut _10: *const T;
             scope 5 {
                 let _6: std::ptr::NonNull<T>;
                 scope 6 {
@@ -62,9 +61,10 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb0: {
-        StorageLive(_11);
+        StorageLive(_10);
         StorageLive(_3);
         StorageLive(_6);
+        StorageLive(_9);
         StorageLive(_4);
         _3 = PtrMetadata(copy _1);
         _4 = &raw const (*_1);
@@ -72,7 +72,6 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         _5 = copy _4 as *const T (PtrToPtr);
         _6 = NonNull::<T> { pointer: copy _5 };
         StorageDead(_5);
-        StorageLive(_9);
         switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
     }
 
@@ -93,37 +92,34 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb3: {
-        StorageLive(_10);
-        _10 = copy _9;
-        _11 = std::slice::Iter::<'_, T> { ptr: copy _6, end_or_len: copy _10, _marker: const ZeroSized: PhantomData<&T> };
-        StorageDead(_10);
-        StorageDead(_9);
+        _10 = std::slice::Iter::<'_, T> { ptr: copy _6, end_or_len: copy _9, _marker: const ZeroSized: PhantomData<&T> };
         StorageDead(_4);
+        StorageDead(_9);
         StorageDead(_6);
         StorageDead(_3);
-        _12 = Rev::<std::slice::Iter<'_, T>> { iter: copy _11 };
-        StorageDead(_11);
-        StorageLive(_13);
-        _13 = copy _12;
+        _11 = Rev::<std::slice::Iter<'_, T>> { iter: copy _10 };
+        StorageDead(_10);
+        StorageLive(_12);
+        _12 = copy _11;
         goto -> bb4;
     }
 
     bb4: {
-        StorageLive(_15);
         StorageLive(_14);
-        _14 = &mut (_13.0: std::slice::Iter<'_, T>);
-        _15 = <std::slice::Iter<'_, T> as DoubleEndedIterator>::next_back(move _14) -> [return: bb5, unwind unreachable];
+        StorageLive(_13);
+        _13 = &mut (_12.0: std::slice::Iter<'_, T>);
+        _14 = <std::slice::Iter<'_, T> as DoubleEndedIterator>::next_back(move _13) -> [return: bb5, unwind unreachable];
     }
 
     bb5: {
-        StorageDead(_14);
-        _16 = discriminant(_15);
-        switchInt(move _16) -> [0: bb6, 1: bb8, otherwise: bb10];
+        StorageDead(_13);
+        _15 = discriminant(_14);
+        switchInt(move _15) -> [0: bb6, 1: bb8, otherwise: bb10];
     }
 
     bb6: {
-        StorageDead(_15);
-        StorageDead(_13);
+        StorageDead(_14);
+        StorageDead(_12);
         drop(_2) -> [return: bb7, unwind unreachable];
     }
 
@@ -132,18 +128,18 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb8: {
-        _17 = copy ((_15 as Some).0: &T);
+        _16 = copy ((_14 as Some).0: &T);
+        StorageLive(_17);
+        _17 = &_2;
         StorageLive(_18);
-        _18 = &_2;
-        StorageLive(_19);
-        _19 = (copy _17,);
-        _20 = <impl Fn(&T) as Fn<(&T,)>>::call(move _18, move _19) -> [return: bb9, unwind unreachable];
+        _18 = (copy _16,);
+        _19 = <impl Fn(&T) as Fn<(&T,)>>::call(move _17, move _18) -> [return: bb9, unwind unreachable];
     }
 
     bb9: {
-        StorageDead(_19);
         StorageDead(_18);
-        StorageDead(_15);
+        StorageDead(_17);
+        StorageDead(_14);
         goto -> bb4;
     }
 
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 aee29d4d4fef9..cb0d640d445bb 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
@@ -4,22 +4,22 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     debug slice => _1;
     debug f => _2;
     let mut _0: ();
-    let mut _11: std::slice::Iter<'_, T>;
+    let mut _10: std::slice::Iter<'_, T>;
+    let mut _11: std::iter::Rev<std::slice::Iter<'_, T>>;
     let mut _12: std::iter::Rev<std::slice::Iter<'_, T>>;
-    let mut _13: std::iter::Rev<std::slice::Iter<'_, T>>;
-    let mut _15: std::option::Option<&T>;
-    let mut _16: isize;
-    let mut _18: &impl Fn(&T);
-    let mut _19: (&T,);
-    let _20: ();
+    let mut _14: std::option::Option<&T>;
+    let mut _15: isize;
+    let mut _17: &impl Fn(&T);
+    let mut _18: (&T,);
+    let _19: ();
     scope 1 {
-        debug iter => _13;
-        let _17: &T;
+        debug iter => _12;
+        let _16: &T;
         scope 2 {
-            debug x => _17;
+            debug x => _16;
         }
         scope 18 (inlined <Rev<std::slice::Iter<'_, T>> as Iterator>::next) {
-            let mut _14: &mut std::slice::Iter<'_, T>;
+            let mut _13: &mut std::slice::Iter<'_, T>;
         }
     }
     scope 3 (inlined core::slice::<impl [T]>::iter) {
@@ -27,7 +27,6 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
             let _3: usize;
             let mut _7: *mut T;
             let mut _8: *mut T;
-            let mut _10: *const T;
             scope 5 {
                 let _6: std::ptr::NonNull<T>;
                 scope 6 {
@@ -62,9 +61,10 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb0: {
-        StorageLive(_11);
+        StorageLive(_10);
         StorageLive(_3);
         StorageLive(_6);
+        StorageLive(_9);
         StorageLive(_4);
         _3 = PtrMetadata(copy _1);
         _4 = &raw const (*_1);
@@ -72,7 +72,6 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         _5 = copy _4 as *const T (PtrToPtr);
         _6 = NonNull::<T> { pointer: copy _5 };
         StorageDead(_5);
-        StorageLive(_9);
         switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
     }
 
@@ -93,37 +92,34 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb3: {
-        StorageLive(_10);
-        _10 = copy _9;
-        _11 = std::slice::Iter::<'_, T> { ptr: copy _6, end_or_len: copy _10, _marker: const ZeroSized: PhantomData<&T> };
-        StorageDead(_10);
-        StorageDead(_9);
+        _10 = std::slice::Iter::<'_, T> { ptr: copy _6, end_or_len: copy _9, _marker: const ZeroSized: PhantomData<&T> };
         StorageDead(_4);
+        StorageDead(_9);
         StorageDead(_6);
         StorageDead(_3);
-        _12 = Rev::<std::slice::Iter<'_, T>> { iter: copy _11 };
-        StorageDead(_11);
-        StorageLive(_13);
-        _13 = copy _12;
+        _11 = Rev::<std::slice::Iter<'_, T>> { iter: copy _10 };
+        StorageDead(_10);
+        StorageLive(_12);
+        _12 = copy _11;
         goto -> bb4;
     }
 
     bb4: {
-        StorageLive(_15);
         StorageLive(_14);
-        _14 = &mut (_13.0: std::slice::Iter<'_, T>);
-        _15 = <std::slice::Iter<'_, T> as DoubleEndedIterator>::next_back(move _14) -> [return: bb5, unwind: bb11];
+        StorageLive(_13);
+        _13 = &mut (_12.0: std::slice::Iter<'_, T>);
+        _14 = <std::slice::Iter<'_, T> as DoubleEndedIterator>::next_back(move _13) -> [return: bb5, unwind: bb11];
     }
 
     bb5: {
-        StorageDead(_14);
-        _16 = discriminant(_15);
-        switchInt(move _16) -> [0: bb6, 1: bb8, otherwise: bb10];
+        StorageDead(_13);
+        _15 = discriminant(_14);
+        switchInt(move _15) -> [0: bb6, 1: bb8, otherwise: bb10];
     }
 
     bb6: {
-        StorageDead(_15);
-        StorageDead(_13);
+        StorageDead(_14);
+        StorageDead(_12);
         drop(_2) -> [return: bb7, unwind continue];
     }
 
@@ -132,18 +128,18 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb8: {
-        _17 = copy ((_15 as Some).0: &T);
+        _16 = copy ((_14 as Some).0: &T);
+        StorageLive(_17);
+        _17 = &_2;
         StorageLive(_18);
-        _18 = &_2;
-        StorageLive(_19);
-        _19 = (copy _17,);
-        _20 = <impl Fn(&T) as Fn<(&T,)>>::call(move _18, move _19) -> [return: bb9, unwind: bb11];
+        _18 = (copy _16,);
+        _19 = <impl Fn(&T) as Fn<(&T,)>>::call(move _17, move _18) -> [return: bb9, unwind: bb11];
     }
 
     bb9: {
-        StorageDead(_19);
         StorageDead(_18);
-        StorageDead(_15);
+        StorageDead(_17);
+        StorageDead(_14);
         goto -> bb4;
     }
 
diff --git a/tests/mir-opt/pre-codegen/tuple_ord.demo_ge_partial.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/tuple_ord.demo_ge_partial.PreCodegen.after.mir
index c4d0e318b58dc..29bfe962974cf 100644
--- a/tests/mir-opt/pre-codegen/tuple_ord.demo_ge_partial.PreCodegen.after.mir
+++ b/tests/mir-opt/pre-codegen/tuple_ord.demo_ge_partial.PreCodegen.after.mir
@@ -7,7 +7,6 @@ fn demo_ge_partial(_1: &(f32, f32), _2: &(f32, f32)) -> bool {
     scope 1 (inlined std::cmp::impls::<impl PartialOrd for &(f32, f32)>::ge) {
         scope 2 (inlined core::tuple::<impl PartialOrd for (f32, f32)>::ge) {
             let mut _7: std::ops::ControlFlow<bool>;
-            let _8: bool;
             scope 3 {
             }
             scope 4 (inlined std::cmp::impls::<impl PartialOrd for f32>::__chaining_ge) {
@@ -19,8 +18,8 @@ fn demo_ge_partial(_1: &(f32, f32), _2: &(f32, f32)) -> bool {
                 }
             }
             scope 6 (inlined std::cmp::impls::<impl PartialOrd for f32>::ge) {
+                let mut _8: f32;
                 let mut _9: f32;
-                let mut _10: f32;
             }
         }
     }
@@ -44,10 +43,7 @@ fn demo_ge_partial(_1: &(f32, f32), _2: &(f32, f32)) -> bool {
         StorageDead(_5);
         StorageDead(_4);
         StorageDead(_3);
-        StorageLive(_8);
-        _8 = copy ((_7 as Break).0: bool);
-        _0 = copy _8;
-        StorageDead(_8);
+        _0 = copy ((_7 as Break).0: bool);
         goto -> bb3;
     }
 
@@ -55,13 +51,13 @@ fn demo_ge_partial(_1: &(f32, f32), _2: &(f32, f32)) -> bool {
         StorageDead(_5);
         StorageDead(_4);
         StorageDead(_3);
+        StorageLive(_8);
+        _8 = copy ((*_1).1: f32);
         StorageLive(_9);
-        _9 = copy ((*_1).1: f32);
-        StorageLive(_10);
-        _10 = copy ((*_2).1: f32);
-        _0 = Ge(move _9, move _10);
-        StorageDead(_10);
+        _9 = copy ((*_2).1: f32);
+        _0 = Ge(move _8, move _9);
         StorageDead(_9);
+        StorageDead(_8);
         goto -> bb3;
     }
 
diff --git a/tests/mir-opt/pre-codegen/tuple_ord.demo_le_total.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/tuple_ord.demo_le_total.PreCodegen.after.mir
index 44df8b279935b..7678c92a1f0c6 100644
--- a/tests/mir-opt/pre-codegen/tuple_ord.demo_le_total.PreCodegen.after.mir
+++ b/tests/mir-opt/pre-codegen/tuple_ord.demo_le_total.PreCodegen.after.mir
@@ -7,7 +7,6 @@ fn demo_le_total(_1: &(u16, i16), _2: &(u16, i16)) -> bool {
     scope 1 (inlined std::cmp::impls::<impl PartialOrd for &(u16, i16)>::le) {
         scope 2 (inlined core::tuple::<impl PartialOrd for (u16, i16)>::le) {
             let mut _7: std::ops::ControlFlow<bool>;
-            let _8: bool;
             scope 3 {
             }
             scope 4 (inlined std::cmp::impls::<impl PartialOrd for u16>::__chaining_le) {
@@ -19,8 +18,8 @@ fn demo_le_total(_1: &(u16, i16), _2: &(u16, i16)) -> bool {
                 }
             }
             scope 6 (inlined std::cmp::impls::<impl PartialOrd for i16>::le) {
+                let mut _8: i16;
                 let mut _9: i16;
-                let mut _10: i16;
             }
         }
     }
@@ -44,10 +43,7 @@ fn demo_le_total(_1: &(u16, i16), _2: &(u16, i16)) -> bool {
         StorageDead(_5);
         StorageDead(_4);
         StorageDead(_3);
-        StorageLive(_8);
-        _8 = copy ((_7 as Break).0: bool);
-        _0 = copy _8;
-        StorageDead(_8);
+        _0 = copy ((_7 as Break).0: bool);
         goto -> bb3;
     }
 
@@ -55,13 +51,13 @@ fn demo_le_total(_1: &(u16, i16), _2: &(u16, i16)) -> bool {
         StorageDead(_5);
         StorageDead(_4);
         StorageDead(_3);
+        StorageLive(_8);
+        _8 = copy ((*_1).1: i16);
         StorageLive(_9);
-        _9 = copy ((*_1).1: i16);
-        StorageLive(_10);
-        _10 = copy ((*_2).1: i16);
-        _0 = Le(move _9, move _10);
-        StorageDead(_10);
+        _9 = copy ((*_2).1: i16);
+        _0 = Le(move _8, move _9);
         StorageDead(_9);
+        StorageDead(_8);
         goto -> bb3;
     }
 

From 19e5286c806978e094328559d172f9d7e4e8885f Mon Sep 17 00:00:00 2001
From: galileocap <galileocapp@gmail.com>
Date: Tue, 16 Sep 2025 19:20:39 -0300
Subject: [PATCH 1016/1889] Fix `unnecessary_unwrap` false negative when
 unwrapping a known value inside a macro call

Fixes https://github.com/rust-lang/rust-clippy/issues/12295

changelog: [`unnecessary_unwrap`]: Fix false negative when unwrapping a known value inside a macro call
---
 clippy_lints/src/unwrap.rs                    |  1 +
 .../ui/checked_unwrap/simple_conditionals.rs  | 22 ++++++++++++
 .../checked_unwrap/simple_conditionals.stderr | 36 ++++++++++++++++++-
 3 files changed, 58 insertions(+), 1 deletion(-)

diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index 490da4f1e037a..34dfe5b6546fa 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -292,6 +292,7 @@ impl<'tcx> Visitor<'tcx> for UnwrappableVariablesVisitor<'_, 'tcx> {
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
         // Shouldn't lint when `expr` is in macro.
         if expr.span.in_external_macro(self.cx.tcx.sess.source_map()) {
+            walk_expr(self, expr);
             return;
         }
         // Skip checking inside closures since they are visited through `Unwrap::check_fn()` already.
diff --git a/tests/ui/checked_unwrap/simple_conditionals.rs b/tests/ui/checked_unwrap/simple_conditionals.rs
index 785b2473c0530..bba264080b406 100644
--- a/tests/ui/checked_unwrap/simple_conditionals.rs
+++ b/tests/ui/checked_unwrap/simple_conditionals.rs
@@ -273,6 +273,28 @@ const ISSUE14763: fn(Option<String>) = |x| {
     }
 };
 
+fn issue12295() {
+    let option = Some(());
+
+    if option.is_some() {
+        println!("{:?}", option.unwrap());
+        //~^ unnecessary_unwrap
+    } else {
+        println!("{:?}", option.unwrap());
+        //~^ panicking_unwrap
+    }
+
+    let result = Ok::<(), ()>(());
+
+    if result.is_ok() {
+        println!("{:?}", result.unwrap());
+        //~^ unnecessary_unwrap
+    } else {
+        println!("{:?}", result.unwrap());
+        //~^ panicking_unwrap
+    }
+}
+
 fn check_expect() {
     let x = Some(());
     if x.is_some() {
diff --git a/tests/ui/checked_unwrap/simple_conditionals.stderr b/tests/ui/checked_unwrap/simple_conditionals.stderr
index 939b509d85c91..2007a85954137 100644
--- a/tests/ui/checked_unwrap/simple_conditionals.stderr
+++ b/tests/ui/checked_unwrap/simple_conditionals.stderr
@@ -322,6 +322,40 @@ LL |         if x.is_some() {
 LL |             _ = x.unwrap();
    |                 ^^^^^^^^^^
 
+error: called `unwrap` on `option` after checking its variant with `is_some`
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:280:26
+   |
+LL |     if option.is_some() {
+   |     ------------------- help: try: `if let Some(<item>) = option`
+LL |         println!("{:?}", option.unwrap());
+   |                          ^^^^^^^^^^^^^^^
+
+error: this call to `unwrap()` will always panic
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:283:26
+   |
+LL |     if option.is_some() {
+   |        ---------------- because of this check
+...
+LL |         println!("{:?}", option.unwrap());
+   |                          ^^^^^^^^^^^^^^^
+
+error: called `unwrap` on `result` after checking its variant with `is_ok`
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:290:26
+   |
+LL |     if result.is_ok() {
+   |     ----------------- help: try: `if let Ok(<item>) = result`
+LL |         println!("{:?}", result.unwrap());
+   |                          ^^^^^^^^^^^^^^^
+
+error: this call to `unwrap()` will always panic
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:293:26
+   |
+LL |     if result.is_ok() {
+   |        -------------- because of this check
+...
+LL |         println!("{:?}", result.unwrap());
+   |                          ^^^^^^^^^^^^^^^
+
 error: creating a shared reference to mutable static
   --> tests/ui/checked_unwrap/simple_conditionals.rs:183:12
    |
@@ -332,5 +366,5 @@ LL |         if X.is_some() {
    = note: shared references to mutable statics are dangerous; it's undefined behavior if the static is mutated or if a mutable reference is created for it while the shared reference lives
    = note: `#[deny(static_mut_refs)]` (part of `#[deny(rust_2024_compatibility)]`) on by default
 
-error: aborting due to 36 previous errors
+error: aborting due to 40 previous errors
 

From 53b91ea87fe4b430c33bd22dfdaaa6289bf9466a Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Sun, 14 Sep 2025 22:29:04 +0000
Subject: [PATCH 1017/1889] Remove Rvalue::Len.

---
 compiler/rustc_borrowck/src/lib.rs            |  3 +-
 .../src/polonius/legacy/loan_invalidations.rs |  9 +-
 compiler/rustc_borrowck/src/type_check/mod.rs |  2 -
 compiler/rustc_codegen_cranelift/src/base.rs  |  6 --
 compiler/rustc_codegen_ssa/src/mir/rvalue.rs  | 25 +-----
 .../src/check_consts/check.rs                 |  3 +-
 .../src/check_consts/qualifs.rs               |  4 +-
 .../src/check_consts/resolver.rs              |  1 -
 .../rustc_const_eval/src/interpret/step.rs    |  8 +-
 compiler/rustc_middle/src/mir/pretty.rs       |  1 -
 compiler/rustc_middle/src/mir/statement.rs    |  2 -
 compiler/rustc_middle/src/mir/syntax.rs       | 10 ---
 compiler/rustc_middle/src/mir/visit.rs        |  8 --
 .../src/builder/custom/parse/instruction.rs   |  6 +-
 .../src/builder/expr/as_place.rs              |  2 +-
 .../src/builder/matches/test.rs               |  3 +-
 .../src/impls/borrowed_locals.rs              |  1 -
 .../src/move_paths/builder.rs                 |  1 -
 .../src/dataflow_const_prop.rs                | 38 ++++-----
 compiler/rustc_mir_transform/src/gvn.rs       | 77 +++++------------
 .../src/known_panics_lint.rs                  | 15 ----
 .../rustc_mir_transform/src/promote_consts.rs |  4 +-
 compiler/rustc_mir_transform/src/validate.rs  |  8 --
 .../src/unstable/convert/stable/mir.rs        |  1 -
 compiler/rustc_span/src/symbol.rs             |  1 +
 library/core/src/intrinsics/mir.rs            |  8 +-
 .../clippy_utils/src/qualify_min_const_fn.rs  |  2 +-
 .../custom/arrays.arrays.built.after.mir      | 10 ++-
 tests/mir-opt/building/custom/arrays.rs       |  4 +-
 ...n.DataflowConstProp.32bit.panic-abort.diff | 77 +++++++++++++++++
 ....DataflowConstProp.32bit.panic-unwind.diff | 77 +++++++++++++++++
 ...n.DataflowConstProp.64bit.panic-abort.diff | 77 +++++++++++++++++
 ....DataflowConstProp.64bit.panic-unwind.diff | 77 +++++++++++++++++
 .../mir-opt/dataflow-const-prop/slice_len.rs  | 34 ++++++++
 .../gvn.array_len.GVN.panic-abort.diff        |  6 +-
 .../gvn.array_len.GVN.panic-unwind.diff       |  6 +-
 ...implify-after-simplifycfg.panic-abort.diff | 71 ++++++++++++++++
 ...mplify-after-simplifycfg.panic-unwind.diff | 71 ++++++++++++++++
 .../mir-opt/instsimplify/combine_array_len.rs | 15 ++++
 ...implifyComparisonIntegral.panic-abort.diff | 32 +++----
 ...mplifyComparisonIntegral.panic-unwind.diff | 32 +++----
 ...ray_len.array_len_raw.GVN.panic-abort.diff |  6 +-
 ...ay_len.array_len_raw.GVN.panic-unwind.diff |  6 +-
 ...en.array_len_reborrow.GVN.panic-abort.diff |  6 +-
 ...n.array_len_reborrow.GVN.panic-unwind.diff |  6 +-
 ...e_prop.debuginfo.ReferencePropagation.diff | 85 ++++++++++---------
 46 files changed, 656 insertions(+), 291 deletions(-)
 create mode 100644 tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.32bit.panic-abort.diff
 create mode 100644 tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.32bit.panic-unwind.diff
 create mode 100644 tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.64bit.panic-abort.diff
 create mode 100644 tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.64bit.panic-unwind.diff
 create mode 100644 tests/mir-opt/dataflow-const-prop/slice_len.rs
 create mode 100644 tests/mir-opt/instsimplify/combine_array_len.norm2.InstSimplify-after-simplifycfg.panic-abort.diff
 create mode 100644 tests/mir-opt/instsimplify/combine_array_len.norm2.InstSimplify-after-simplifycfg.panic-unwind.diff
 create mode 100644 tests/mir-opt/instsimplify/combine_array_len.rs

diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs
index 5d2dda8b0e7cc..f196bd04d0e8f 100644
--- a/compiler/rustc_borrowck/src/lib.rs
+++ b/compiler/rustc_borrowck/src/lib.rs
@@ -1557,9 +1557,8 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                 );
             }
 
-            &(Rvalue::Len(place) | Rvalue::Discriminant(place)) => {
+            &Rvalue::Discriminant(place) => {
                 let af = match *rvalue {
-                    Rvalue::Len(..) => Some(ArtificialField::ArrayLength),
                     Rvalue::Discriminant(..) => None,
                     _ => unreachable!(),
                 };
diff --git a/compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs b/compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs
index 99dd0b2dd4664..c2ad6fcb4b799 100644
--- a/compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs
+++ b/compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs
@@ -306,16 +306,11 @@ impl<'a, 'tcx> LoanInvalidationsGenerator<'a, 'tcx> {
                 self.consume_operand(location, op);
             }
 
-            &(Rvalue::Len(place) | Rvalue::Discriminant(place)) => {
-                let af = match rvalue {
-                    Rvalue::Len(..) => Some(ArtificialField::ArrayLength),
-                    Rvalue::Discriminant(..) => None,
-                    _ => unreachable!(),
-                };
+            &Rvalue::Discriminant(place) => {
                 self.access_place(
                     location,
                     place,
-                    (Shallow(af), Read(ReadKind::Copy)),
+                    (Shallow(None), Read(ReadKind::Copy)),
                     LocalMutationIsAllowed::No,
                 );
             }
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
index 8c5447fe1e9e7..dcedf0b153221 100644
--- a/compiler/rustc_borrowck/src/type_check/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -1631,7 +1631,6 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
             | Rvalue::BinaryOp(..)
             | Rvalue::RawPtr(..)
             | Rvalue::ThreadLocalRef(..)
-            | Rvalue::Len(..)
             | Rvalue::Discriminant(..)
             | Rvalue::NullaryOp(NullOp::OffsetOf(..), _) => {}
         }
@@ -2201,7 +2200,6 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             | Rvalue::Repeat(..)
             | Rvalue::Ref(..)
             | Rvalue::RawPtr(..)
-            | Rvalue::Len(..)
             | Rvalue::Cast(..)
             | Rvalue::ShallowInitBox(..)
             | Rvalue::BinaryOp(..)
diff --git a/compiler/rustc_codegen_cranelift/src/base.rs b/compiler/rustc_codegen_cranelift/src/base.rs
index 3a28dd7e73cb3..41e11e1de6163 100644
--- a/compiler/rustc_codegen_cranelift/src/base.rs
+++ b/compiler/rustc_codegen_cranelift/src/base.rs
@@ -834,12 +834,6 @@ fn codegen_stmt<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, cur_block: Block, stmt:
                         fx.bcx.ins().nop();
                     }
                 }
-                Rvalue::Len(place) => {
-                    let place = codegen_place(fx, place);
-                    let usize_layout = fx.layout_of(fx.tcx.types.usize);
-                    let len = codegen_array_len(fx, place);
-                    lval.write_cvalue(fx, CValue::by_val(len, usize_layout));
-                }
                 Rvalue::ShallowInitBox(ref operand, content_ty) => {
                     let content_ty = fx.monomorphize(content_ty);
                     let box_layout = fx.layout_of(Ty::new_box(fx.tcx, content_ty));
diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
index f8755874014d3..c30e6a505058d 100644
--- a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -7,9 +7,9 @@ use rustc_middle::{bug, mir, span_bug};
 use rustc_session::config::OptLevel;
 use tracing::{debug, instrument};
 
+use super::FunctionCx;
 use super::operand::{OperandRef, OperandRefBuilder, OperandValue};
 use super::place::{PlaceRef, PlaceValue, codegen_tag_value};
-use super::{FunctionCx, LocalRef};
 use crate::common::{IntPredicate, TypeKind};
 use crate::traits::*;
 use crate::{MemFlags, base};
@@ -510,14 +510,6 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 self.codegen_place_to_pointer(bx, place, mk_ptr)
             }
 
-            mir::Rvalue::Len(place) => {
-                let size = self.evaluate_array_len(bx, place);
-                OperandRef {
-                    val: OperandValue::Immediate(size),
-                    layout: bx.cx().layout_of(bx.tcx().types.usize),
-                }
-            }
-
             mir::Rvalue::BinaryOp(op_with_overflow, box (ref lhs, ref rhs))
                 if let Some(op) = op_with_overflow.overflowing_to_wrapping() =>
             {
@@ -749,21 +741,6 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         }
     }
 
-    fn evaluate_array_len(&mut self, bx: &mut Bx, place: mir::Place<'tcx>) -> Bx::Value {
-        // ZST are passed as operands and require special handling
-        // because codegen_place() panics if Local is operand.
-        if let Some(index) = place.as_local()
-            && let LocalRef::Operand(op) = self.locals[index]
-            && let ty::Array(_, n) = op.layout.ty.kind()
-        {
-            let n = n.try_to_target_usize(bx.tcx()).expect("expected monomorphic const in codegen");
-            return bx.cx().const_usize(n);
-        }
-        // use common size calculation for non zero-sized types
-        let cg_value = self.codegen_place(bx, place.as_ref());
-        cg_value.len(bx.cx())
-    }
-
     /// Codegen an `Rvalue::RawPtr` or `Rvalue::Ref`
     fn codegen_place_to_pointer(
         &mut self,
diff --git a/compiler/rustc_const_eval/src/check_consts/check.rs b/compiler/rustc_const_eval/src/check_consts/check.rs
index ca707b50d50d9..3397bd9a68e4c 100644
--- a/compiler/rustc_const_eval/src/check_consts/check.rs
+++ b/compiler/rustc_const_eval/src/check_consts/check.rs
@@ -573,8 +573,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
             Rvalue::Use(_)
             | Rvalue::CopyForDeref(..)
             | Rvalue::Repeat(..)
-            | Rvalue::Discriminant(..)
-            | Rvalue::Len(_) => {}
+            | Rvalue::Discriminant(..) => {}
 
             Rvalue::Aggregate(kind, ..) => {
                 if let AggregateKind::Coroutine(def_id, ..) = kind.as_ref()
diff --git a/compiler/rustc_const_eval/src/check_consts/qualifs.rs b/compiler/rustc_const_eval/src/check_consts/qualifs.rs
index faf41f1658b70..34d1fdd8c8694 100644
--- a/compiler/rustc_const_eval/src/check_consts/qualifs.rs
+++ b/compiler/rustc_const_eval/src/check_consts/qualifs.rs
@@ -232,9 +232,7 @@ where
             Q::in_any_value_of_ty(cx, rvalue.ty(cx.body, cx.tcx))
         }
 
-        Rvalue::Discriminant(place) | Rvalue::Len(place) => {
-            in_place::<Q, _>(cx, in_local, place.as_ref())
-        }
+        Rvalue::Discriminant(place) => in_place::<Q, _>(cx, in_local, place.as_ref()),
 
         Rvalue::CopyForDeref(place) => in_place::<Q, _>(cx, in_local, place.as_ref()),
 
diff --git a/compiler/rustc_const_eval/src/check_consts/resolver.rs b/compiler/rustc_const_eval/src/check_consts/resolver.rs
index d98e5027e4d6b..664dda8701a63 100644
--- a/compiler/rustc_const_eval/src/check_consts/resolver.rs
+++ b/compiler/rustc_const_eval/src/check_consts/resolver.rs
@@ -197,7 +197,6 @@ where
             | mir::Rvalue::CopyForDeref(..)
             | mir::Rvalue::ThreadLocalRef(..)
             | mir::Rvalue::Repeat(..)
-            | mir::Rvalue::Len(..)
             | mir::Rvalue::BinaryOp(..)
             | mir::Rvalue::NullaryOp(..)
             | mir::Rvalue::UnaryOp(..)
diff --git a/compiler/rustc_const_eval/src/interpret/step.rs b/compiler/rustc_const_eval/src/interpret/step.rs
index 46950d60f8c78..923e00ad4cf1a 100644
--- a/compiler/rustc_const_eval/src/interpret/step.rs
+++ b/compiler/rustc_const_eval/src/interpret/step.rs
@@ -17,7 +17,7 @@ use tracing::{info, instrument, trace};
 
 use super::{
     FnArg, FnVal, ImmTy, Immediate, InterpCx, InterpResult, Machine, MemPlaceMeta, PlaceTy,
-    Projectable, Scalar, interp_ok, throw_ub, throw_unsup_format,
+    Projectable, interp_ok, throw_ub, throw_unsup_format,
 };
 use crate::interpret::EnteredTraceSpan;
 use crate::{enter_trace_span, util};
@@ -225,12 +225,6 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 self.write_repeat(operand, &dest)?;
             }
 
-            Len(place) => {
-                let src = self.eval_place(place)?;
-                let len = src.len(self)?;
-                self.write_scalar(Scalar::from_target_usize(len, self), &dest)?;
-            }
-
             Ref(_, borrow_kind, place) => {
                 let src = self.eval_place(place)?;
                 let place = self.force_allocation(&src)?;
diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
index f9d0a5f0a3b66..96148fd5b9269 100644
--- a/compiler/rustc_middle/src/mir/pretty.rs
+++ b/compiler/rustc_middle/src/mir/pretty.rs
@@ -1062,7 +1062,6 @@ impl<'tcx> Debug for Rvalue<'tcx> {
                 pretty_print_const(b, fmt, false)?;
                 write!(fmt, "]")
             }
-            Len(ref a) => write!(fmt, "Len({a:?})"),
             Cast(ref kind, ref place, ref ty) => {
                 with_no_trimmed_paths!(write!(fmt, "{place:?} as {ty} ({kind:?})"))
             }
diff --git a/compiler/rustc_middle/src/mir/statement.rs b/compiler/rustc_middle/src/mir/statement.rs
index ec2a8e86077d0..28294b47e90f2 100644
--- a/compiler/rustc_middle/src/mir/statement.rs
+++ b/compiler/rustc_middle/src/mir/statement.rs
@@ -697,7 +697,6 @@ impl<'tcx> Rvalue<'tcx> {
             | Rvalue::Ref(_, _, _)
             | Rvalue::ThreadLocalRef(_)
             | Rvalue::RawPtr(_, _)
-            | Rvalue::Len(_)
             | Rvalue::Cast(
                 CastKind::IntToInt
                 | CastKind::FloatToInt
@@ -739,7 +738,6 @@ impl<'tcx> Rvalue<'tcx> {
                 let place_ty = place.ty(local_decls, tcx).ty;
                 Ty::new_ptr(tcx, place_ty, kind.to_mutbl_lossy())
             }
-            Rvalue::Len(..) => tcx.types.usize,
             Rvalue::Cast(.., ty) => ty,
             Rvalue::BinaryOp(op, box (ref lhs, ref rhs)) => {
                 let lhs_ty = lhs.ty(local_decls, tcx);
diff --git a/compiler/rustc_middle/src/mir/syntax.rs b/compiler/rustc_middle/src/mir/syntax.rs
index d402ea4b04f9c..e6c8512564edc 100644
--- a/compiler/rustc_middle/src/mir/syntax.rs
+++ b/compiler/rustc_middle/src/mir/syntax.rs
@@ -1407,16 +1407,6 @@ pub enum Rvalue<'tcx> {
     /// model.
     RawPtr(RawPtrKind, Place<'tcx>),
 
-    /// Yields the length of the place, as a `usize`.
-    ///
-    /// If the type of the place is an array, this is the array length. For slices (`[T]`, not
-    /// `&[T]`) this accesses the place's metadata to determine the length. This rvalue is
-    /// ill-formed for places of other types.
-    ///
-    /// This cannot be a `UnOp(PtrMetadata, _)` because that expects a value, and we only
-    /// have a place, and `UnOp(PtrMetadata, RawPtr(place))` is not a thing.
-    Len(Place<'tcx>),
-
     /// Performs essentially all of the casts that can be performed via `as`.
     ///
     /// This allows for casts from/to a variety of types.
diff --git a/compiler/rustc_middle/src/mir/visit.rs b/compiler/rustc_middle/src/mir/visit.rs
index b498b7b8912cc..07a15b3cd18a7 100644
--- a/compiler/rustc_middle/src/mir/visit.rs
+++ b/compiler/rustc_middle/src/mir/visit.rs
@@ -717,14 +717,6 @@ macro_rules! make_mir_visitor {
                         self.visit_place(path, ctx, location);
                     }
 
-                    Rvalue::Len(path) => {
-                        self.visit_place(
-                            path,
-                            PlaceContext::NonMutatingUse(NonMutatingUseContext::Inspect),
-                            location
-                        );
-                    }
-
                     Rvalue::Cast(_cast_kind, operand, ty) => {
                         self.visit_operand(operand, location);
                         self.visit_ty($(& $mutability)? *ty, TyContext::Location(location));
diff --git a/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs b/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs
index 41d3aefcbe6b5..54490e0050902 100644
--- a/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs
+++ b/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs
@@ -229,6 +229,11 @@ impl<'a, 'tcx> ParseCtxt<'a, 'tcx> {
                 let source = self.parse_operand(args[0])?;
                 Ok(Rvalue::Cast(CastKind::PtrToPtr, source, expr.ty))
             },
+            @call(mir_cast_unsize, args) => {
+                let source = self.parse_operand(args[0])?;
+                let kind = CastKind::PointerCoercion(ty::adjustment::PointerCoercion::Unsize, CoercionSource::AsCast);
+                Ok(Rvalue::Cast(kind, source, expr.ty))
+            },
             @call(mir_checked, args) => {
                 parse_by_kind!(self, args[0], _, "binary op",
                     ExprKind::Binary { op, lhs, rhs } => {
@@ -247,7 +252,6 @@ impl<'a, 'tcx> ParseCtxt<'a, 'tcx> {
                 let offset = self.parse_operand(args[1])?;
                 Ok(Rvalue::BinaryOp(BinOp::Offset, Box::new((ptr, offset))))
             },
-            @call(mir_len, args) => Ok(Rvalue::Len(self.parse_place(args[0])?)),
             @call(mir_ptr_metadata, args) => Ok(Rvalue::UnaryOp(UnOp::PtrMetadata, self.parse_operand(args[0])?)),
             @call(mir_copy_for_deref, args) => Ok(Rvalue::CopyForDeref(self.parse_place(args[0])?)),
             ExprKind::Borrow { borrow_kind, arg } => Ok(
diff --git a/compiler/rustc_mir_build/src/builder/expr/as_place.rs b/compiler/rustc_mir_build/src/builder/expr/as_place.rs
index 7c851ec465bdc..5a6bd2f413c2d 100644
--- a/compiler/rustc_mir_build/src/builder/expr/as_place.rs
+++ b/compiler/rustc_mir_build/src/builder/expr/as_place.rs
@@ -663,7 +663,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     ///
     /// For arrays it'll be `Operand::Constant` with the actual length;
     /// For slices it'll be `Operand::Move` of a local using `PtrMetadata`.
-    fn len_of_slice_or_array(
+    pub(in crate::builder) fn len_of_slice_or_array(
         &mut self,
         block: BasicBlock,
         place: Place<'tcx>,
diff --git a/compiler/rustc_mir_build/src/builder/matches/test.rs b/compiler/rustc_mir_build/src/builder/matches/test.rs
index d03794fe2d584..1b6d96e49f0c1 100644
--- a/compiler/rustc_mir_build/src/builder/matches/test.rs
+++ b/compiler/rustc_mir_build/src/builder/matches/test.rs
@@ -309,7 +309,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 let actual = self.temp(usize_ty, test.span);
 
                 // actual = len(place)
-                self.cfg.push_assign(block, source_info, actual, Rvalue::Len(place));
+                let length_op = self.len_of_slice_or_array(block, place, test.span, source_info);
+                self.cfg.push_assign(block, source_info, actual, Rvalue::Use(length_op));
 
                 // expected = <N>
                 let expected = self.push_usize(block, source_info, len);
diff --git a/compiler/rustc_mir_dataflow/src/impls/borrowed_locals.rs b/compiler/rustc_mir_dataflow/src/impls/borrowed_locals.rs
index 9abb83434321d..a4e4e30a8bb6c 100644
--- a/compiler/rustc_mir_dataflow/src/impls/borrowed_locals.rs
+++ b/compiler/rustc_mir_dataflow/src/impls/borrowed_locals.rs
@@ -91,7 +91,6 @@ where
             | Rvalue::Use(..)
             | Rvalue::ThreadLocalRef(..)
             | Rvalue::Repeat(..)
-            | Rvalue::Len(..)
             | Rvalue::BinaryOp(..)
             | Rvalue::NullaryOp(..)
             | Rvalue::UnaryOp(..)
diff --git a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
index 48718cad597a8..f38bb44582400 100644
--- a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
+++ b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
@@ -413,7 +413,6 @@ impl<'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> MoveDataBuilder<'a, 'tcx, F> {
             Rvalue::Ref(..)
             | Rvalue::RawPtr(..)
             | Rvalue::Discriminant(..)
-            | Rvalue::Len(..)
             | Rvalue::NullaryOp(
                 NullOp::SizeOf
                 | NullOp::AlignOf
diff --git a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
index fe53de31f7583..5c984984d3cc3 100644
--- a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
+++ b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
@@ -412,18 +412,6 @@ impl<'a, 'tcx> ConstAnalysis<'a, 'tcx> {
         state: &mut State<FlatSet<Scalar>>,
     ) -> ValueOrPlace<FlatSet<Scalar>> {
         let val = match rvalue {
-            Rvalue::Len(place) => {
-                let place_ty = place.ty(self.local_decls, self.tcx);
-                if let ty::Array(_, len) = place_ty.ty.kind() {
-                    Const::Ty(self.tcx.types.usize, *len)
-                        .try_eval_scalar(self.tcx, self.typing_env)
-                        .map_or(FlatSet::Top, FlatSet::Elem)
-                } else if let [ProjectionElem::Deref] = place.projection[..] {
-                    state.get_len(place.local.into(), &self.map)
-                } else {
-                    FlatSet::Top
-                }
-            }
             Rvalue::Cast(CastKind::IntToInt | CastKind::IntToFloat, operand, ty) => {
                 let Ok(layout) = self.tcx.layout_of(self.typing_env.as_query_input(*ty)) else {
                     return ValueOrPlace::Value(FlatSet::Top);
@@ -465,15 +453,23 @@ impl<'a, 'tcx> ConstAnalysis<'a, 'tcx> {
                 let (val, _overflow) = self.binary_op(state, *op, left, right);
                 val
             }
-            Rvalue::UnaryOp(op, operand) => match self.eval_operand(operand, state) {
-                FlatSet::Elem(value) => self
-                    .ecx
-                    .unary_op(*op, &value)
-                    .discard_err()
-                    .map_or(FlatSet::Top, |val| self.wrap_immediate(*val)),
-                FlatSet::Bottom => FlatSet::Bottom,
-                FlatSet::Top => FlatSet::Top,
-            },
+            Rvalue::UnaryOp(op, operand) => {
+                if let UnOp::PtrMetadata = op
+                    && let Some(place) = operand.place()
+                    && let Some(len) = self.map.find_len(place.as_ref())
+                {
+                    return ValueOrPlace::Place(len);
+                }
+                match self.eval_operand(operand, state) {
+                    FlatSet::Elem(value) => self
+                        .ecx
+                        .unary_op(*op, &value)
+                        .discard_err()
+                        .map_or(FlatSet::Top, |val| self.wrap_immediate(*val)),
+                    FlatSet::Bottom => FlatSet::Bottom,
+                    FlatSet::Top => FlatSet::Top,
+                }
+            }
             Rvalue::NullaryOp(null_op, ty) => {
                 let Ok(layout) = self.tcx.layout_of(self.typing_env.as_query_input(*ty)) else {
                     return ValueOrPlace::Value(FlatSet::Top);
diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index bf6aa800d20f4..30e68a3f65058 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -200,8 +200,6 @@ enum Value<'tcx> {
     Projection(VnIndex, ProjectionElem<VnIndex, ()>),
     /// Discriminant of the given value.
     Discriminant(VnIndex),
-    /// Length of an array or slice.
-    Len(VnIndex),
 
     // Operations.
     NullaryOp(NullOp<'tcx>, Ty<'tcx>),
@@ -477,11 +475,6 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                     self.ecx.discriminant_for_variant(base.layout.ty, variant).discard_err()?;
                 discr_value.into()
             }
-            Len(slice) => {
-                let slice = self.evaluated[slice].as_ref()?;
-                let len = slice.len(&self.ecx).discard_err()?;
-                ImmTy::from_uint(len, ty).into()
-            }
             NullaryOp(null_op, arg_ty) => {
                 let arg_layout = self.ecx.layout_of(arg_ty).ok()?;
                 if let NullOp::SizeOf | NullOp::AlignOf = null_op
@@ -841,7 +834,6 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             }
 
             // Operations.
-            Rvalue::Len(ref mut place) => return self.simplify_len(place, location),
             Rvalue::Cast(ref mut kind, ref mut value, to) => {
                 return self.simplify_cast(kind, value, to, location);
             }
@@ -1049,7 +1041,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
         if op == UnOp::PtrMetadata {
             let mut was_updated = false;
             loop {
-                match self.get(arg_index) {
+                arg_index = match self.get(arg_index) {
                     // Pointer casts that preserve metadata, such as
                     // `*const [i32]` <-> `*mut [i32]` <-> `*mut [f32]`.
                     // It's critical that this not eliminate cases like
@@ -1061,9 +1053,19 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                     Value::Cast { kind: CastKind::PtrToPtr, value: inner }
                         if self.pointers_have_same_metadata(self.ty(*inner), arg_ty) =>
                     {
-                        arg_index = *inner;
-                        was_updated = true;
-                        continue;
+                        *inner
+                    }
+
+                    // We have an unsizing cast, which assigns the length to wide pointer metadata.
+                    Value::Cast {
+                        kind: CastKind::PointerCoercion(ty::adjustment::PointerCoercion::Unsize, _),
+                        value: from,
+                    } if let Some(from) = self.ty(*from).builtin_deref(true)
+                        && let ty::Array(_, len) = from.kind()
+                        && let Some(to) = self.ty(arg_index).builtin_deref(true)
+                        && let ty::Slice(..) = to.kind() =>
+                    {
+                        return Some(self.insert_constant(Const::Ty(self.tcx.types.usize, *len)));
                     }
 
                     // `&mut *p`, `&raw *p`, etc don't change metadata.
@@ -1072,18 +1074,16 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                             place.as_ref()
                             && let Some(local_index) = self.locals[local] =>
                     {
-                        arg_index = local_index;
-                        was_updated = true;
-                        continue;
+                        local_index
                     }
 
-                    _ => {
-                        if was_updated && let Some(op) = self.try_as_operand(arg_index, location) {
-                            *arg_op = op;
-                        }
-                        break;
-                    }
-                }
+                    _ => break,
+                };
+                was_updated = true;
+            }
+
+            if was_updated && let Some(op) = self.try_as_operand(arg_index, location) {
+                *arg_op = op;
             }
         }
 
@@ -1407,39 +1407,6 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
         Some(self.insert(to, Value::Cast { kind, value }))
     }
 
-    fn simplify_len(&mut self, place: &mut Place<'tcx>, location: Location) -> Option<VnIndex> {
-        // Trivial case: we are fetching a statically known length.
-        let place_ty = place.ty(self.local_decls, self.tcx).ty;
-        if let ty::Array(_, len) = place_ty.kind() {
-            return Some(self.insert_constant(Const::Ty(self.tcx.types.usize, *len)));
-        }
-
-        let mut inner = self.simplify_place_value(place, location)?;
-
-        // The length information is stored in the wide pointer.
-        // Reborrowing copies length information from one pointer to the other.
-        while let Value::Address { place: borrowed, .. } = self.get(inner)
-            && let [PlaceElem::Deref] = borrowed.projection[..]
-            && let Some(borrowed) = self.locals[borrowed.local]
-        {
-            inner = borrowed;
-        }
-
-        // We have an unsizing cast, which assigns the length to wide pointer metadata.
-        if let Value::Cast { kind, value: from } = self.get(inner)
-            && let CastKind::PointerCoercion(ty::adjustment::PointerCoercion::Unsize, _) = kind
-            && let Some(from) = self.ty(*from).builtin_deref(true)
-            && let ty::Array(_, len) = from.kind()
-            && let Some(to) = self.ty(inner).builtin_deref(true)
-            && let ty::Slice(..) = to.kind()
-        {
-            return Some(self.insert_constant(Const::Ty(self.tcx.types.usize, *len)));
-        }
-
-        // Fallback: a symbolic `Len`.
-        Some(self.insert(self.tcx.types.usize, Value::Len(inner)))
-    }
-
     fn pointers_have_same_metadata(&self, left_ptr_ty: Ty<'tcx>, right_ptr_ty: Ty<'tcx>) -> bool {
         let left_meta_ty = left_ptr_ty.pointee_metadata_ty_or_projection(self.tcx);
         let right_meta_ty = right_ptr_ty.pointee_metadata_ty_or_projection(self.tcx);
diff --git a/compiler/rustc_mir_transform/src/known_panics_lint.rs b/compiler/rustc_mir_transform/src/known_panics_lint.rs
index 481c794190925..aaacc5866a2ae 100644
--- a/compiler/rustc_mir_transform/src/known_panics_lint.rs
+++ b/compiler/rustc_mir_transform/src/known_panics_lint.rs
@@ -441,7 +441,6 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
             | Rvalue::Use(..)
             | Rvalue::CopyForDeref(..)
             | Rvalue::Repeat(..)
-            | Rvalue::Len(..)
             | Rvalue::Cast(..)
             | Rvalue::ShallowInitBox(..)
             | Rvalue::Discriminant(..)
@@ -604,20 +603,6 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
                 return None;
             }
 
-            Len(place) => {
-                let len = if let ty::Array(_, n) = place.ty(self.local_decls(), self.tcx).ty.kind()
-                {
-                    n.try_to_target_usize(self.tcx)?
-                } else {
-                    match self.get_const(place)? {
-                        Value::Immediate(src) => src.len(&self.ecx).discard_err()?,
-                        Value::Aggregate { fields, .. } => fields.len() as u64,
-                        Value::Uninit => return None,
-                    }
-                };
-                ImmTy::from_scalar(Scalar::from_target_usize(len, self), layout).into()
-            }
-
             Ref(..) | RawPtr(..) => return None,
 
             NullaryOp(ref null_op, ty) => {
diff --git a/compiler/rustc_mir_transform/src/promote_consts.rs b/compiler/rustc_mir_transform/src/promote_consts.rs
index 9ea2eb4f25d91..a0b0c8c990f33 100644
--- a/compiler/rustc_mir_transform/src/promote_consts.rs
+++ b/compiler/rustc_mir_transform/src/promote_consts.rs
@@ -437,9 +437,7 @@ impl<'tcx> Validator<'_, 'tcx> {
                 self.validate_operand(op)?
             }
 
-            Rvalue::Discriminant(place) | Rvalue::Len(place) => {
-                self.validate_place(place.as_ref())?
-            }
+            Rvalue::Discriminant(place) => self.validate_place(place.as_ref())?,
 
             Rvalue::ThreadLocalRef(_) => return Err(Unpromotable),
 
diff --git a/compiler/rustc_mir_transform/src/validate.rs b/compiler/rustc_mir_transform/src/validate.rs
index 99e4782e4700c..c8a9a88dc3fe3 100644
--- a/compiler/rustc_mir_transform/src/validate.rs
+++ b/compiler/rustc_mir_transform/src/validate.rs
@@ -1064,14 +1064,6 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                 }
             }
             Rvalue::Ref(..) => {}
-            Rvalue::Len(p) => {
-                let pty = p.ty(&self.body.local_decls, self.tcx).ty;
-                check_kinds!(
-                    pty,
-                    "Cannot compute length of non-array type {:?}",
-                    ty::Array(..) | ty::Slice(..)
-                );
-            }
             Rvalue::BinaryOp(op, vals) => {
                 use BinOp::*;
                 let a = vals.0.ty(&self.body.local_decls, self.tcx);
diff --git a/compiler/rustc_public/src/unstable/convert/stable/mir.rs b/compiler/rustc_public/src/unstable/convert/stable/mir.rs
index be8ee80bed3c0..b10af6526ead5 100644
--- a/compiler/rustc_public/src/unstable/convert/stable/mir.rs
+++ b/compiler/rustc_public/src/unstable/convert/stable/mir.rs
@@ -215,7 +215,6 @@ impl<'tcx> Stable<'tcx> for mir::Rvalue<'tcx> {
                 mutability.stable(tables, cx),
                 place.stable(tables, cx),
             ),
-            Len(place) => crate::mir::Rvalue::Len(place.stable(tables, cx)),
             Cast(cast_kind, op, ty) => crate::mir::Rvalue::Cast(
                 cast_kind.stable(tables, cx),
                 op.stable(tables, cx),
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index cdb0b5b58da6d..16b8b46f97cf3 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1413,6 +1413,7 @@ symbols! {
         mir_call,
         mir_cast_ptr_to_ptr,
         mir_cast_transmute,
+        mir_cast_unsize,
         mir_checked,
         mir_copy_for_deref,
         mir_debuginfo,
diff --git a/library/core/src/intrinsics/mir.rs b/library/core/src/intrinsics/mir.rs
index 55dcf7cd47e97..c4bd10e606aab 100644
--- a/library/core/src/intrinsics/mir.rs
+++ b/library/core/src/intrinsics/mir.rs
@@ -401,7 +401,6 @@ define!("mir_storage_dead", fn StorageDead<T>(local: T));
 define!("mir_assume", fn Assume(operand: bool));
 define!("mir_deinit", fn Deinit<T>(place: T));
 define!("mir_checked", fn Checked<T>(binop: T) -> (T, bool));
-define!("mir_len", fn Len<T>(place: T) -> usize);
 define!(
     "mir_ptr_metadata",
     fn PtrMetadata<P: ?Sized>(place: *const P) -> <P as ::core::ptr::Pointee>::Metadata
@@ -491,6 +490,13 @@ define!(
     /// This allows bypassing normal validation to generate strange casts.
     fn CastPtrToPtr<T, U>(operand: T) -> U
 );
+define!(
+    "mir_cast_unsize",
+    /// Emits a `CastKind::PointerCoercion(Unsize)` cast.
+    ///
+    /// This allows bypassing normal validation to generate strange casts.
+    fn CastUnsize<T, U>(operand: T) -> U
+);
 define!(
     "mir_make_place",
     #[doc(hidden)]
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 68f0b5ea25589..40fd2cdeb86fd 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
@@ -126,7 +126,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::RawPtr(_, place) => {
+        Rvalue::Discriminant(place) | Rvalue::Ref(_, _, place) | Rvalue::RawPtr(_, place) => {
             check_place(cx, *place, span, body, msrv)
         },
         Rvalue::CopyForDeref(place) => check_place(cx, *place, span, body, msrv),
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 30d11e31e4d4e..f9f24c8eabe4d 100644
--- a/tests/mir-opt/building/custom/arrays.arrays.built.after.mir
+++ b/tests/mir-opt/building/custom/arrays.arrays.built.after.mir
@@ -3,12 +3,16 @@
 fn arrays() -> usize {
     let mut _0: usize;
     let mut _1: [i32; C];
-    let mut _2: usize;
+    let mut _2: *const [i32; C];
+    let mut _3: *const [i32];
+    let mut _4: usize;
 
     bb0: {
         _1 = [const 5_i32; C];
-        _2 = Len(_1);
-        _0 = copy _2;
+        _2 = &raw const _1;
+        _3 = copy _2 as *const [i32] (PointerCoercion(Unsize, AsCast));
+        _4 = PtrMetadata(copy _3);
+        _0 = copy _4;
         return;
     }
 }
diff --git a/tests/mir-opt/building/custom/arrays.rs b/tests/mir-opt/building/custom/arrays.rs
index 4bd6f93e11340..e9cdded4a0e68 100644
--- a/tests/mir-opt/building/custom/arrays.rs
+++ b/tests/mir-opt/building/custom/arrays.rs
@@ -10,7 +10,9 @@ fn arrays<const C: usize>() -> usize {
     mir! {
         {
             let x = [5_i32; C];
-            let c = Len(x);
+            let y = &raw const x;
+            let z = CastUnsize::<_, *const [i32]>(y);
+            let c = PtrMetadata(z);
             RET = c;
             Return()
         }
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
new file mode 100644
index 0000000000000..fd9ef54fe775f
--- /dev/null
+++ b/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.32bit.panic-abort.diff
@@ -0,0 +1,77 @@
+- // MIR for `main` before DataflowConstProp
++ // MIR for `main` after DataflowConstProp
+  
+  fn main() -> () {
+      let mut _0: ();
+      let _1: u32;
+      let mut _2: &[u32];
+      let mut _3: &[u32; 3];
+      let _4: &[u32; 3];
+      let _5: [u32; 3];
+      let _6: usize;
+      let mut _7: usize;
+      let mut _8: bool;
+      let mut _10: &[u32];
+      let _11: usize;
+      let mut _12: usize;
+      let mut _13: bool;
+      let mut _14: &[u32; 3];
+      scope 1 {
+          debug local => _1;
+          let _9: u32;
+          scope 2 {
+              debug constant => _9;
+          }
+      }
+  
+      bb0: {
+          StorageLive(_1);
+          StorageLive(_2);
+          StorageLive(_3);
+          StorageLive(_4);
+          _14 = const main::promoted[0];
+          _4 = copy _14;
+          _3 = copy _4;
+          _2 = move _3 as &[u32] (PointerCoercion(Unsize, AsCast));
+          StorageDead(_3);
+          StorageLive(_6);
+          _6 = const 1_usize;
+-         _7 = PtrMetadata(copy _2);
+-         _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 = copy (*_2)[_6];
++         _1 = copy (*_2)[1 of 2];
+          StorageDead(_6);
+          StorageDead(_4);
+          StorageDead(_2);
+          StorageLive(_9);
+          StorageLive(_10);
+          _10 = const main::SLICE;
+          StorageLive(_11);
+          _11 = const 1_usize;
+-         _12 = PtrMetadata(copy _10);
+-         _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 = copy (*_10)[_11];
++         _9 = copy (*_10)[1 of 2];
+          StorageDead(_11);
+          StorageDead(_10);
+          _0 = const ();
+          StorageDead(_9);
+          StorageDead(_1);
+          return;
+      }
+  }
+  
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
new file mode 100644
index 0000000000000..1fec08c256201
--- /dev/null
+++ b/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.32bit.panic-unwind.diff
@@ -0,0 +1,77 @@
+- // MIR for `main` before DataflowConstProp
++ // MIR for `main` after DataflowConstProp
+  
+  fn main() -> () {
+      let mut _0: ();
+      let _1: u32;
+      let mut _2: &[u32];
+      let mut _3: &[u32; 3];
+      let _4: &[u32; 3];
+      let _5: [u32; 3];
+      let _6: usize;
+      let mut _7: usize;
+      let mut _8: bool;
+      let mut _10: &[u32];
+      let _11: usize;
+      let mut _12: usize;
+      let mut _13: bool;
+      let mut _14: &[u32; 3];
+      scope 1 {
+          debug local => _1;
+          let _9: u32;
+          scope 2 {
+              debug constant => _9;
+          }
+      }
+  
+      bb0: {
+          StorageLive(_1);
+          StorageLive(_2);
+          StorageLive(_3);
+          StorageLive(_4);
+          _14 = const main::promoted[0];
+          _4 = copy _14;
+          _3 = copy _4;
+          _2 = move _3 as &[u32] (PointerCoercion(Unsize, AsCast));
+          StorageDead(_3);
+          StorageLive(_6);
+          _6 = const 1_usize;
+-         _7 = PtrMetadata(copy _2);
+-         _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 = copy (*_2)[_6];
++         _1 = copy (*_2)[1 of 2];
+          StorageDead(_6);
+          StorageDead(_4);
+          StorageDead(_2);
+          StorageLive(_9);
+          StorageLive(_10);
+          _10 = const main::SLICE;
+          StorageLive(_11);
+          _11 = const 1_usize;
+-         _12 = PtrMetadata(copy _10);
+-         _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 = copy (*_10)[_11];
++         _9 = copy (*_10)[1 of 2];
+          StorageDead(_11);
+          StorageDead(_10);
+          _0 = const ();
+          StorageDead(_9);
+          StorageDead(_1);
+          return;
+      }
+  }
+  
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
new file mode 100644
index 0000000000000..fd9ef54fe775f
--- /dev/null
+++ b/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.64bit.panic-abort.diff
@@ -0,0 +1,77 @@
+- // MIR for `main` before DataflowConstProp
++ // MIR for `main` after DataflowConstProp
+  
+  fn main() -> () {
+      let mut _0: ();
+      let _1: u32;
+      let mut _2: &[u32];
+      let mut _3: &[u32; 3];
+      let _4: &[u32; 3];
+      let _5: [u32; 3];
+      let _6: usize;
+      let mut _7: usize;
+      let mut _8: bool;
+      let mut _10: &[u32];
+      let _11: usize;
+      let mut _12: usize;
+      let mut _13: bool;
+      let mut _14: &[u32; 3];
+      scope 1 {
+          debug local => _1;
+          let _9: u32;
+          scope 2 {
+              debug constant => _9;
+          }
+      }
+  
+      bb0: {
+          StorageLive(_1);
+          StorageLive(_2);
+          StorageLive(_3);
+          StorageLive(_4);
+          _14 = const main::promoted[0];
+          _4 = copy _14;
+          _3 = copy _4;
+          _2 = move _3 as &[u32] (PointerCoercion(Unsize, AsCast));
+          StorageDead(_3);
+          StorageLive(_6);
+          _6 = const 1_usize;
+-         _7 = PtrMetadata(copy _2);
+-         _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 = copy (*_2)[_6];
++         _1 = copy (*_2)[1 of 2];
+          StorageDead(_6);
+          StorageDead(_4);
+          StorageDead(_2);
+          StorageLive(_9);
+          StorageLive(_10);
+          _10 = const main::SLICE;
+          StorageLive(_11);
+          _11 = const 1_usize;
+-         _12 = PtrMetadata(copy _10);
+-         _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 = copy (*_10)[_11];
++         _9 = copy (*_10)[1 of 2];
+          StorageDead(_11);
+          StorageDead(_10);
+          _0 = const ();
+          StorageDead(_9);
+          StorageDead(_1);
+          return;
+      }
+  }
+  
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
new file mode 100644
index 0000000000000..1fec08c256201
--- /dev/null
+++ b/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.64bit.panic-unwind.diff
@@ -0,0 +1,77 @@
+- // MIR for `main` before DataflowConstProp
++ // MIR for `main` after DataflowConstProp
+  
+  fn main() -> () {
+      let mut _0: ();
+      let _1: u32;
+      let mut _2: &[u32];
+      let mut _3: &[u32; 3];
+      let _4: &[u32; 3];
+      let _5: [u32; 3];
+      let _6: usize;
+      let mut _7: usize;
+      let mut _8: bool;
+      let mut _10: &[u32];
+      let _11: usize;
+      let mut _12: usize;
+      let mut _13: bool;
+      let mut _14: &[u32; 3];
+      scope 1 {
+          debug local => _1;
+          let _9: u32;
+          scope 2 {
+              debug constant => _9;
+          }
+      }
+  
+      bb0: {
+          StorageLive(_1);
+          StorageLive(_2);
+          StorageLive(_3);
+          StorageLive(_4);
+          _14 = const main::promoted[0];
+          _4 = copy _14;
+          _3 = copy _4;
+          _2 = move _3 as &[u32] (PointerCoercion(Unsize, AsCast));
+          StorageDead(_3);
+          StorageLive(_6);
+          _6 = const 1_usize;
+-         _7 = PtrMetadata(copy _2);
+-         _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 = copy (*_2)[_6];
++         _1 = copy (*_2)[1 of 2];
+          StorageDead(_6);
+          StorageDead(_4);
+          StorageDead(_2);
+          StorageLive(_9);
+          StorageLive(_10);
+          _10 = const main::SLICE;
+          StorageLive(_11);
+          _11 = const 1_usize;
+-         _12 = PtrMetadata(copy _10);
+-         _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 = copy (*_10)[_11];
++         _9 = copy (*_10)[1 of 2];
+          StorageDead(_11);
+          StorageDead(_10);
+          _0 = const ();
+          StorageDead(_9);
+          StorageDead(_1);
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/dataflow-const-prop/slice_len.rs b/tests/mir-opt/dataflow-const-prop/slice_len.rs
new file mode 100644
index 0000000000000..e0e68f9fde54a
--- /dev/null
+++ b/tests/mir-opt/dataflow-const-prop/slice_len.rs
@@ -0,0 +1,34 @@
+// EMIT_MIR_FOR_EACH_PANIC_STRATEGY
+//@ test-mir-pass: DataflowConstProp
+//@ compile-flags: -Zmir-enable-passes=+InstSimplify-after-simplifycfg
+// EMIT_MIR_FOR_EACH_BIT_WIDTH
+
+// EMIT_MIR slice_len.main.DataflowConstProp.diff
+
+// CHECK-LABEL: fn main(
+fn main() {
+    // CHECK: debug local => [[local:_.*]];
+    // CHECK: debug constant => [[constant:_.*]];
+
+    // CHECK-NOT: {{_.*}} = Len(
+    // CHECK-NOT: {{_.*}} = Lt(
+    // CHECK-NOT: assert(move _
+    // CHECK: {{_.*}} = const 3_usize;
+    // CHECK: {{_.*}} = const true;
+    // CHECK: assert(const true,
+
+    // CHECK: [[local]] = copy (*{{_.*}})[1 of 2];
+    let local = (&[1u32, 2, 3] as &[u32])[1];
+
+    // CHECK-NOT: {{_.*}} = Len(
+    // CHECK-NOT: {{_.*}} = Lt(
+    // CHECK-NOT: assert(move _
+    const SLICE: &[u32] = &[1, 2, 3];
+    // CHECK: {{_.*}} = const 3_usize;
+    // CHECK: {{_.*}} = const true;
+    // CHECK: assert(const true,
+
+    // CHECK-NOT: [[constant]] = {{copy|move}} (*{{_.*}})[_
+    // CHECK: [[constant]] = copy (*{{_.*}})[1 of 2];
+    let constant = SLICE[1];
+}
diff --git a/tests/mir-opt/gvn.array_len.GVN.panic-abort.diff b/tests/mir-opt/gvn.array_len.GVN.panic-abort.diff
index 0d0477fe7729f..59b65a52f4ee6 100644
--- a/tests/mir-opt/gvn.array_len.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.array_len.GVN.panic-abort.diff
@@ -12,8 +12,7 @@
       }
   
       bb0: {
--         StorageLive(_2);
-+         nop;
+          StorageLive(_2);
           StorageLive(_3);
           _3 = &(*_1);
           _2 = move _3 as &[i32] (PointerCoercion(Unsize, Implicit));
@@ -23,8 +22,7 @@
 -         _0 = PtrMetadata(move _4);
 +         _0 = const 42_usize;
           StorageDead(_4);
--         StorageDead(_2);
-+         nop;
+          StorageDead(_2);
           return;
       }
   }
diff --git a/tests/mir-opt/gvn.array_len.GVN.panic-unwind.diff b/tests/mir-opt/gvn.array_len.GVN.panic-unwind.diff
index 0d0477fe7729f..59b65a52f4ee6 100644
--- a/tests/mir-opt/gvn.array_len.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.array_len.GVN.panic-unwind.diff
@@ -12,8 +12,7 @@
       }
   
       bb0: {
--         StorageLive(_2);
-+         nop;
+          StorageLive(_2);
           StorageLive(_3);
           _3 = &(*_1);
           _2 = move _3 as &[i32] (PointerCoercion(Unsize, Implicit));
@@ -23,8 +22,7 @@
 -         _0 = PtrMetadata(move _4);
 +         _0 = const 42_usize;
           StorageDead(_4);
--         StorageDead(_2);
-+         nop;
+          StorageDead(_2);
           return;
       }
   }
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
new file mode 100644
index 0000000000000..feba0fe7c4a21
--- /dev/null
+++ b/tests/mir-opt/instsimplify/combine_array_len.norm2.InstSimplify-after-simplifycfg.panic-abort.diff
@@ -0,0 +1,71 @@
+- // MIR for `norm2` before InstSimplify-after-simplifycfg
++ // MIR for `norm2` after InstSimplify-after-simplifycfg
+  
+  fn norm2(_1: [f32; 2]) -> f32 {
+      debug x => _1;
+      let mut _0: f32;
+      let _2: f32;
+      let _3: usize;
+      let mut _4: bool;
+      let _6: usize;
+      let mut _7: bool;
+      let mut _8: f32;
+      let mut _9: f32;
+      let mut _10: f32;
+      let mut _11: f32;
+      let mut _12: f32;
+      let mut _13: f32;
+      scope 1 {
+          debug a => _2;
+          let _5: f32;
+          scope 2 {
+              debug b => _5;
+          }
+      }
+  
+      bb0: {
+          StorageLive(_2);
+          StorageLive(_3);
+          _3 = const 0_usize;
+          _4 = Lt(copy _3, const 2_usize);
+          assert(move _4, "index out of bounds: the length is {} but the index is {}", const 2_usize, copy _3) -> [success: bb1, unwind unreachable];
+      }
+  
+      bb1: {
+          _2 = copy _1[_3];
+          StorageDead(_3);
+          StorageLive(_5);
+          StorageLive(_6);
+          _6 = const 1_usize;
+          _7 = Lt(copy _6, const 2_usize);
+          assert(move _7, "index out of bounds: the length is {} but the index is {}", const 2_usize, copy _6) -> [success: bb2, unwind unreachable];
+      }
+  
+      bb2: {
+          _5 = copy _1[_6];
+          StorageDead(_6);
+          StorageLive(_8);
+          StorageLive(_9);
+          _9 = copy _2;
+          StorageLive(_10);
+          _10 = copy _2;
+          _8 = Mul(move _9, move _10);
+          StorageDead(_10);
+          StorageDead(_9);
+          StorageLive(_11);
+          StorageLive(_12);
+          _12 = copy _5;
+          StorageLive(_13);
+          _13 = copy _5;
+          _11 = Mul(move _12, move _13);
+          StorageDead(_13);
+          StorageDead(_12);
+          _0 = Add(move _8, move _11);
+          StorageDead(_11);
+          StorageDead(_8);
+          StorageDead(_5);
+          StorageDead(_2);
+          return;
+      }
+  }
+  
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
new file mode 100644
index 0000000000000..0ccf6a825c49a
--- /dev/null
+++ b/tests/mir-opt/instsimplify/combine_array_len.norm2.InstSimplify-after-simplifycfg.panic-unwind.diff
@@ -0,0 +1,71 @@
+- // MIR for `norm2` before InstSimplify-after-simplifycfg
++ // MIR for `norm2` after InstSimplify-after-simplifycfg
+  
+  fn norm2(_1: [f32; 2]) -> f32 {
+      debug x => _1;
+      let mut _0: f32;
+      let _2: f32;
+      let _3: usize;
+      let mut _4: bool;
+      let _6: usize;
+      let mut _7: bool;
+      let mut _8: f32;
+      let mut _9: f32;
+      let mut _10: f32;
+      let mut _11: f32;
+      let mut _12: f32;
+      let mut _13: f32;
+      scope 1 {
+          debug a => _2;
+          let _5: f32;
+          scope 2 {
+              debug b => _5;
+          }
+      }
+  
+      bb0: {
+          StorageLive(_2);
+          StorageLive(_3);
+          _3 = const 0_usize;
+          _4 = Lt(copy _3, const 2_usize);
+          assert(move _4, "index out of bounds: the length is {} but the index is {}", const 2_usize, copy _3) -> [success: bb1, unwind continue];
+      }
+  
+      bb1: {
+          _2 = copy _1[_3];
+          StorageDead(_3);
+          StorageLive(_5);
+          StorageLive(_6);
+          _6 = const 1_usize;
+          _7 = Lt(copy _6, const 2_usize);
+          assert(move _7, "index out of bounds: the length is {} but the index is {}", const 2_usize, copy _6) -> [success: bb2, unwind continue];
+      }
+  
+      bb2: {
+          _5 = copy _1[_6];
+          StorageDead(_6);
+          StorageLive(_8);
+          StorageLive(_9);
+          _9 = copy _2;
+          StorageLive(_10);
+          _10 = copy _2;
+          _8 = Mul(move _9, move _10);
+          StorageDead(_10);
+          StorageDead(_9);
+          StorageLive(_11);
+          StorageLive(_12);
+          _12 = copy _5;
+          StorageLive(_13);
+          _13 = copy _5;
+          _11 = Mul(move _12, move _13);
+          StorageDead(_13);
+          StorageDead(_12);
+          _0 = Add(move _8, move _11);
+          StorageDead(_11);
+          StorageDead(_8);
+          StorageDead(_5);
+          StorageDead(_2);
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/instsimplify/combine_array_len.rs b/tests/mir-opt/instsimplify/combine_array_len.rs
new file mode 100644
index 0000000000000..91f43f75689de
--- /dev/null
+++ b/tests/mir-opt/instsimplify/combine_array_len.rs
@@ -0,0 +1,15 @@
+// EMIT_MIR_FOR_EACH_PANIC_STRATEGY
+//@ test-mir-pass: InstSimplify-after-simplifycfg
+
+// EMIT_MIR combine_array_len.norm2.InstSimplify-after-simplifycfg.diff
+fn norm2(x: [f32; 2]) -> f32 {
+    // CHECK-LABEL: fn norm2(
+    // CHECK-NOT: Len(
+    let a = x[0];
+    let b = x[1];
+    a * a + b * b
+}
+
+fn main() {
+    assert_eq!(norm2([3.0, 4.0]), 5.0 * 5.0);
+}
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 08dee3697e072..5cf36b9aebf2f 100644
--- a/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff
+++ b/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff
@@ -7,18 +7,16 @@
       let _2: &[T];
       let _3: &[T; 3];
       let _4: [T; 3];
-      let mut _5: usize;
-      let mut _6: bool;
-      let mut _10: !;
+      let mut _8: !;
       scope 1 {
           debug v => _2;
+          let _5: &T;
+          let _6: &T;
           let _7: &T;
-          let _8: &T;
-          let _9: &T;
           scope 2 {
-              debug v1 => _7;
-              debug v2 => _8;
-              debug v3 => _9;
+              debug v1 => _5;
+              debug v2 => _6;
+              debug v3 => _7;
           }
       }
   
@@ -27,25 +25,23 @@
           _4 = [copy _1, copy _1, copy _1];
           _3 = &_4;
           _2 = copy _3 as &[T] (PointerCoercion(Unsize, Implicit));
-          nop;
-          nop;
           goto -> bb2;
       }
   
       bb1: {
-          _10 = core::panicking::panic(const "internal error: entered unreachable code") -> unwind unreachable;
+          _8 = core::panicking::panic(const "internal error: entered unreachable code") -> unwind unreachable;
       }
   
       bb2: {
+          StorageLive(_5);
+          _5 = &(*_2)[0 of 3];
+          StorageLive(_6);
+          _6 = &(*_2)[1 of 3];
           StorageLive(_7);
-          _7 = &(*_2)[0 of 3];
-          StorageLive(_8);
-          _8 = &(*_2)[1 of 3];
-          StorageLive(_9);
-          _9 = &(*_2)[2 of 3];
-          StorageDead(_9);
-          StorageDead(_8);
+          _7 = &(*_2)[2 of 3];
           StorageDead(_7);
+          StorageDead(_6);
+          StorageDead(_5);
           StorageDead(_4);
           return;
       }
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 aa44a2ad532be..0598a3aa3f19a 100644
--- a/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff
+++ b/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff
@@ -7,18 +7,16 @@
       let _2: &[T];
       let _3: &[T; 3];
       let _4: [T; 3];
-      let mut _5: usize;
-      let mut _6: bool;
-      let mut _10: !;
+      let mut _8: !;
       scope 1 {
           debug v => _2;
+          let _5: &T;
+          let _6: &T;
           let _7: &T;
-          let _8: &T;
-          let _9: &T;
           scope 2 {
-              debug v1 => _7;
-              debug v2 => _8;
-              debug v3 => _9;
+              debug v1 => _5;
+              debug v2 => _6;
+              debug v3 => _7;
           }
       }
   
@@ -27,25 +25,23 @@
           _4 = [copy _1, copy _1, copy _1];
           _3 = &_4;
           _2 = copy _3 as &[T] (PointerCoercion(Unsize, Implicit));
-          nop;
-          nop;
           goto -> bb2;
       }
   
       bb1: {
-          _10 = core::panicking::panic(const "internal error: entered unreachable code") -> unwind continue;
+          _8 = core::panicking::panic(const "internal error: entered unreachable code") -> unwind continue;
       }
   
       bb2: {
+          StorageLive(_5);
+          _5 = &(*_2)[0 of 3];
+          StorageLive(_6);
+          _6 = &(*_2)[1 of 3];
           StorageLive(_7);
-          _7 = &(*_2)[0 of 3];
-          StorageLive(_8);
-          _8 = &(*_2)[1 of 3];
-          StorageLive(_9);
-          _9 = &(*_2)[2 of 3];
-          StorageDead(_9);
-          StorageDead(_8);
+          _7 = &(*_2)[2 of 3];
           StorageDead(_7);
+          StorageDead(_6);
+          StorageDead(_5);
           StorageDead(_4);
           return;
       }
diff --git a/tests/mir-opt/lower_array_len.array_len_raw.GVN.panic-abort.diff b/tests/mir-opt/lower_array_len.array_len_raw.GVN.panic-abort.diff
index 180a7db029794..714a12804e692 100644
--- a/tests/mir-opt/lower_array_len.array_len_raw.GVN.panic-abort.diff
+++ b/tests/mir-opt/lower_array_len.array_len_raw.GVN.panic-abort.diff
@@ -18,8 +18,7 @@
       }
   
       bb0: {
--         StorageLive(_2);
-+         nop;
+          StorageLive(_2);
           StorageLive(_3);
           StorageLive(_4);
           _4 = &_1;
@@ -41,8 +40,7 @@
       bb1: {
           StorageDead(_6);
           StorageDead(_5);
--         StorageDead(_2);
-+         nop;
+          StorageDead(_2);
           StorageDead(_7);
           return;
       }
diff --git a/tests/mir-opt/lower_array_len.array_len_raw.GVN.panic-unwind.diff b/tests/mir-opt/lower_array_len.array_len_raw.GVN.panic-unwind.diff
index 180a7db029794..714a12804e692 100644
--- a/tests/mir-opt/lower_array_len.array_len_raw.GVN.panic-unwind.diff
+++ b/tests/mir-opt/lower_array_len.array_len_raw.GVN.panic-unwind.diff
@@ -18,8 +18,7 @@
       }
   
       bb0: {
--         StorageLive(_2);
-+         nop;
+          StorageLive(_2);
           StorageLive(_3);
           StorageLive(_4);
           _4 = &_1;
@@ -41,8 +40,7 @@
       bb1: {
           StorageDead(_6);
           StorageDead(_5);
--         StorageDead(_2);
-+         nop;
+          StorageDead(_2);
           StorageDead(_7);
           return;
       }
diff --git a/tests/mir-opt/lower_array_len.array_len_reborrow.GVN.panic-abort.diff b/tests/mir-opt/lower_array_len.array_len_reborrow.GVN.panic-abort.diff
index 49964f8b49e26..b236b22f067d8 100644
--- a/tests/mir-opt/lower_array_len.array_len_reborrow.GVN.panic-abort.diff
+++ b/tests/mir-opt/lower_array_len.array_len_reborrow.GVN.panic-abort.diff
@@ -17,8 +17,7 @@
       }
   
       bb0: {
--         StorageLive(_2);
-+         nop;
+          StorageLive(_2);
           StorageLive(_3);
           StorageLive(_4);
           _4 = &mut _1;
@@ -38,8 +37,7 @@
       bb1: {
           StorageDead(_6);
           StorageDead(_5);
--         StorageDead(_2);
-+         nop;
+          StorageDead(_2);
           return;
       }
   }
diff --git a/tests/mir-opt/lower_array_len.array_len_reborrow.GVN.panic-unwind.diff b/tests/mir-opt/lower_array_len.array_len_reborrow.GVN.panic-unwind.diff
index 49964f8b49e26..b236b22f067d8 100644
--- a/tests/mir-opt/lower_array_len.array_len_reborrow.GVN.panic-unwind.diff
+++ b/tests/mir-opt/lower_array_len.array_len_reborrow.GVN.panic-unwind.diff
@@ -17,8 +17,7 @@
       }
   
       bb0: {
--         StorageLive(_2);
-+         nop;
+          StorageLive(_2);
           StorageLive(_3);
           StorageLive(_4);
           _4 = &mut _1;
@@ -38,8 +37,7 @@
       bb1: {
           StorageDead(_6);
           StorageDead(_5);
--         StorageDead(_2);
-+         nop;
+          StorageDead(_2);
           return;
       }
   }
diff --git a/tests/mir-opt/reference_prop.debuginfo.ReferencePropagation.diff b/tests/mir-opt/reference_prop.debuginfo.ReferencePropagation.diff
index 3da795b61f948..375b6096d88d8 100644
--- a/tests/mir-opt/reference_prop.debuginfo.ReferencePropagation.diff
+++ b/tests/mir-opt/reference_prop.debuginfo.ReferencePropagation.diff
@@ -17,14 +17,15 @@
       let mut _15: std::ops::RangeFull;
       let mut _16: usize;
       let mut _17: usize;
-      let mut _18: bool;
-      let _23: &&mut u8;
-      let _24: &mut u8;
-      let mut _25: debuginfo::T;
+      let mut _18: usize;
+      let mut _19: bool;
+      let _24: &&mut u8;
+      let _25: &mut u8;
+      let mut _26: debuginfo::T;
       scope 1 {
           debug ref_mut_u8 => _1;
           let _3: &u8;
-          let mut _28: &debuginfo::T;
+          let mut _29: &debuginfo::T;
           scope 2 {
               debug field => _3;
               let _5: &u8;
@@ -32,22 +33,22 @@
 -                 debug reborrow => _5;
 +                 debug reborrow => _1;
                   let _9: &i32;
-                  let _22: &&&mut u8;
-                  let mut _27: &std::option::Option<i32>;
+                  let _23: &&&mut u8;
+                  let mut _28: &std::option::Option<i32>;
                   scope 4 {
                       debug variant_field => _9;
                   }
                   scope 5 {
-                      debug constant_index => _19;
-                      debug subslice => _20;
-                      debug constant_index_from_end => _21;
-                      let _19: &i32;
-                      let _20: &[i32];
-                      let _21: &i32;
-                      let mut _26: &[i32; 10];
+                      debug constant_index => _20;
+                      debug subslice => _21;
+                      debug constant_index_from_end => _22;
+                      let _20: &i32;
+                      let _21: &[i32];
+                      let _22: &i32;
+                      let mut _27: &[i32; 10];
                   }
                   scope 6 {
-                      debug multiple_borrow => _22;
+                      debug multiple_borrow => _23;
                   }
               }
           }
@@ -59,8 +60,8 @@
           _2 = const 5_u8;
           _1 = &mut _2;
           StorageLive(_3);
-          _28 = const debuginfo::promoted[2];
-          _3 = &((*_28).0: u8);
+          _29 = const debuginfo::promoted[2];
+          _3 = &((*_29).0: u8);
 -         StorageLive(_5);
 -         _5 = &(*_1);
 -         StorageLive(_6);
@@ -76,8 +77,8 @@
   
       bb2: {
           StorageLive(_9);
-          _27 = const debuginfo::promoted[1];
-          _9 = &(((*_27) as Some).0: i32);
+          _28 = const debuginfo::promoted[1];
+          _9 = &(((*_28) as Some).0: i32);
 -         _6 = const ();
           StorageDead(_9);
           goto -> bb4;
@@ -92,11 +93,11 @@
           StorageDead(_7);
 -         StorageDead(_6);
 -         StorageLive(_10);
--         StorageLive(_11);
+          StorageLive(_11);
 -         StorageLive(_12);
           StorageLive(_13);
-          _26 = const debuginfo::promoted[0];
-          _13 = &(*_26);
+          _27 = const debuginfo::promoted[0];
+          _13 = &(*_27);
           StorageLive(_15);
           _15 = RangeFull;
 -         _12 = <[i32; 10] as Index<RangeFull>>::index(move _13, move _15) -> [return: bb5, unwind continue];
@@ -106,28 +107,28 @@
       bb5: {
           StorageDead(_15);
           StorageDead(_13);
--         _11 = &(*_12);
--         _16 = Len((*_11));
-+         _16 = Len((*_12));
-          _17 = const 3_usize;
-          _18 = Ge(move _16, move _17);
-          switchInt(move _18) -> [0: bb7, otherwise: bb6];
+          _11 = &(*_12);
+          _17 = PtrMetadata(copy _11);
+          _16 = move _17;
+          _18 = const 3_usize;
+          _19 = Ge(move _16, move _18);
+          switchInt(move _19) -> [0: bb7, otherwise: bb6];
       }
   
       bb6: {
-          StorageLive(_19);
--         _19 = &(*_11)[1 of 3];
-+         _19 = &(*_12)[1 of 3];
           StorageLive(_20);
--         _20 = &(*_11)[2:-1];
-+         _20 = &(*_12)[2:-1];
+-         _20 = &(*_11)[1 of 3];
++         _20 = &(*_12)[1 of 3];
           StorageLive(_21);
--         _21 = &(*_11)[-1 of 3];
+-         _21 = &(*_11)[2:-1];
++         _21 = &(*_12)[2:-1];
+          StorageLive(_22);
+-         _22 = &(*_11)[-1 of 3];
 -         _10 = const ();
-+         _21 = &(*_12)[-1 of 3];
++         _22 = &(*_12)[-1 of 3];
+          StorageDead(_22);
           StorageDead(_21);
           StorageDead(_20);
-          StorageDead(_19);
           goto -> bb8;
       }
   
@@ -138,21 +139,21 @@
   
       bb8: {
 -         StorageDead(_12);
--         StorageDead(_11);
+          StorageDead(_11);
 -         StorageDead(_10);
-          StorageLive(_22);
           StorageLive(_23);
           StorageLive(_24);
           StorageLive(_25);
-          _25 = T(const 6_u8);
-          _24 = &mut (_25.0: u8);
+          StorageLive(_26);
+          _26 = T(const 6_u8);
+          _25 = &mut (_26.0: u8);
+          _24 = &_25;
           _23 = &_24;
-          _22 = &_23;
           _0 = const ();
+          StorageDead(_26);
           StorageDead(_25);
           StorageDead(_24);
           StorageDead(_23);
-          StorageDead(_22);
 -         StorageDead(_5);
           StorageDead(_3);
           StorageDead(_2);

From f018b46558c2c4049cf26bd88d562eefa69ff336 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Tue, 16 Sep 2025 01:45:06 +0000
Subject: [PATCH 1018/1889] Update docs.

---
 library/core/src/intrinsics/mir.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/library/core/src/intrinsics/mir.rs b/library/core/src/intrinsics/mir.rs
index c4bd10e606aab..a800ef1cb9375 100644
--- a/library/core/src/intrinsics/mir.rs
+++ b/library/core/src/intrinsics/mir.rs
@@ -233,7 +233,8 @@
 //!
 //!  - Operands implicitly convert to `Use` rvalues.
 //!  - `&`, `&mut`, `addr_of!`, and `addr_of_mut!` all work to create their associated rvalue.
-//!  - [`Discriminant`], [`Len`], and [`CopyForDeref`] have associated functions.
+//!  - [`CopyForDeref`], [`CastTransmute`], [`CastPtrToPtr`], [`CastUnsize`], and [`Discriminant`]
+//!    have associated functions.
 //!  - Unary and binary operations use their normal Rust syntax - `a * b`, `!c`, etc.
 //!  - The binary operation `Offset` can be created via [`Offset`].
 //!  - Checked binary operations are represented by wrapping the associated binop in [`Checked`].

From 4516fee8cbcbc6e85e4da34614aaa579315563c7 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Sun, 14 Sep 2025 22:29:04 +0000
Subject: [PATCH 1019/1889] Remove Rvalue::Len.

---
 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 68f0b5ea25589..40fd2cdeb86fd 100644
--- a/clippy_utils/src/qualify_min_const_fn.rs
+++ b/clippy_utils/src/qualify_min_const_fn.rs
@@ -126,7 +126,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::RawPtr(_, place) => {
+        Rvalue::Discriminant(place) | Rvalue::Ref(_, _, place) | Rvalue::RawPtr(_, place) => {
             check_place(cx, *place, span, body, msrv)
         },
         Rvalue::CopyForDeref(place) => check_place(cx, *place, span, body, msrv),

From de73af9ec47552dcade86e4ebc4edb8a68fddd2e Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Tue, 16 Sep 2025 22:44:35 +0000
Subject: [PATCH 1020/1889] Add test.

---
 ...onst_array_len.built.after.panic-abort.mir | 155 ++++++++++++++++++
 ...nst_array_len.built.after.panic-unwind.mir | 155 ++++++++++++++++++
 tests/mir-opt/building/match/array_len.rs     |  31 ++++
 ..._len.slice_len.built.after.panic-abort.mir | 115 +++++++++++++
 ...len.slice_len.built.after.panic-unwind.mir | 115 +++++++++++++
 ...implify-after-simplifycfg.panic-abort.diff |  71 ++++++++
 ...mplify-after-simplifycfg.panic-unwind.diff |  71 ++++++++
 .../mir-opt/instsimplify/combine_array_len.rs |  12 +-
 8 files changed, 724 insertions(+), 1 deletion(-)
 create mode 100644 tests/mir-opt/building/match/array_len.const_array_len.built.after.panic-abort.mir
 create mode 100644 tests/mir-opt/building/match/array_len.const_array_len.built.after.panic-unwind.mir
 create mode 100644 tests/mir-opt/building/match/array_len.rs
 create mode 100644 tests/mir-opt/building/match/array_len.slice_len.built.after.panic-abort.mir
 create mode 100644 tests/mir-opt/building/match/array_len.slice_len.built.after.panic-unwind.mir
 create mode 100644 tests/mir-opt/instsimplify/combine_array_len.normN.InstSimplify-after-simplifycfg.panic-abort.diff
 create mode 100644 tests/mir-opt/instsimplify/combine_array_len.normN.InstSimplify-after-simplifycfg.panic-unwind.diff

diff --git a/tests/mir-opt/building/match/array_len.const_array_len.built.after.panic-abort.mir b/tests/mir-opt/building/match/array_len.const_array_len.built.after.panic-abort.mir
new file mode 100644
index 0000000000000..8d16f074b1e34
--- /dev/null
+++ b/tests/mir-opt/building/match/array_len.const_array_len.built.after.panic-abort.mir
@@ -0,0 +1,155 @@
+// MIR for `const_array_len` after built
+
+fn const_array_len(_1: [T; 5]) -> () {
+    debug x => _1;
+    let mut _0: ();
+    let _6: ();
+    let mut _7: T;
+    let _8: ();
+    let mut _9: T;
+    let _10: ();
+    let mut _11: [T; 2];
+    let _12: ();
+    let mut _13: T;
+    scope 1 {
+        debug a => _2;
+        debug b => _3;
+        debug rest => _4;
+        debug e => _5;
+        let _2: T;
+        let _3: T;
+        let _4: [T; 2];
+        let _5: T;
+    }
+
+    bb0: {
+        PlaceMention(_1);
+        falseEdge -> [real: bb2, imaginary: bb1];
+    }
+
+    bb1: {
+        goto -> bb7;
+    }
+
+    bb2: {
+        StorageLive(_2);
+        _2 = move _1[0 of 5];
+        StorageLive(_3);
+        _3 = move _1[1 of 5];
+        StorageLive(_4);
+        _4 = move _1[2..4];
+        StorageLive(_5);
+        _5 = move _1[4 of 5];
+        StorageLive(_6);
+        StorageLive(_7);
+        _7 = move _2;
+        _6 = opaque::<T>(move _7) -> [return: bb3, unwind: bb17];
+    }
+
+    bb3: {
+        StorageDead(_7);
+        StorageDead(_6);
+        StorageLive(_8);
+        StorageLive(_9);
+        _9 = move _3;
+        _8 = opaque::<T>(move _9) -> [return: bb4, unwind: bb16];
+    }
+
+    bb4: {
+        StorageDead(_9);
+        StorageDead(_8);
+        StorageLive(_10);
+        StorageLive(_11);
+        _11 = move _4;
+        _10 = opaque::<[T; 2]>(move _11) -> [return: bb5, unwind: bb15];
+    }
+
+    bb5: {
+        StorageDead(_11);
+        StorageDead(_10);
+        StorageLive(_12);
+        StorageLive(_13);
+        _13 = move _5;
+        _12 = opaque::<T>(move _13) -> [return: bb6, unwind: bb14];
+    }
+
+    bb6: {
+        StorageDead(_13);
+        StorageDead(_12);
+        _0 = const ();
+        drop(_5) -> [return: bb8, unwind: bb19];
+    }
+
+    bb7: {
+        _0 = const ();
+        goto -> bb12;
+    }
+
+    bb8: {
+        StorageDead(_5);
+        drop(_4) -> [return: bb9, unwind: bb20];
+    }
+
+    bb9: {
+        StorageDead(_4);
+        drop(_3) -> [return: bb10, unwind: bb21];
+    }
+
+    bb10: {
+        StorageDead(_3);
+        drop(_2) -> [return: bb11, unwind: bb22];
+    }
+
+    bb11: {
+        StorageDead(_2);
+        goto -> bb12;
+    }
+
+    bb12: {
+        drop(_1) -> [return: bb13, unwind: bb23];
+    }
+
+    bb13: {
+        return;
+    }
+
+    bb14 (cleanup): {
+        drop(_13) -> [return: bb18, unwind terminate(cleanup)];
+    }
+
+    bb15 (cleanup): {
+        drop(_11) -> [return: bb18, unwind terminate(cleanup)];
+    }
+
+    bb16 (cleanup): {
+        drop(_9) -> [return: bb18, unwind terminate(cleanup)];
+    }
+
+    bb17 (cleanup): {
+        drop(_7) -> [return: bb18, unwind terminate(cleanup)];
+    }
+
+    bb18 (cleanup): {
+        drop(_5) -> [return: bb19, unwind terminate(cleanup)];
+    }
+
+    bb19 (cleanup): {
+        drop(_4) -> [return: bb20, unwind terminate(cleanup)];
+    }
+
+    bb20 (cleanup): {
+        drop(_3) -> [return: bb21, unwind terminate(cleanup)];
+    }
+
+    bb21 (cleanup): {
+        drop(_2) -> [return: bb22, unwind terminate(cleanup)];
+    }
+
+    bb22 (cleanup): {
+        drop(_1) -> [return: bb23, unwind terminate(cleanup)];
+    }
+
+    bb23 (cleanup): {
+        resume;
+    }
+}
diff --git a/tests/mir-opt/building/match/array_len.const_array_len.built.after.panic-unwind.mir b/tests/mir-opt/building/match/array_len.const_array_len.built.after.panic-unwind.mir
new file mode 100644
index 0000000000000..8d16f074b1e34
--- /dev/null
+++ b/tests/mir-opt/building/match/array_len.const_array_len.built.after.panic-unwind.mir
@@ -0,0 +1,155 @@
+// MIR for `const_array_len` after built
+
+fn const_array_len(_1: [T; 5]) -> () {
+    debug x => _1;
+    let mut _0: ();
+    let _6: ();
+    let mut _7: T;
+    let _8: ();
+    let mut _9: T;
+    let _10: ();
+    let mut _11: [T; 2];
+    let _12: ();
+    let mut _13: T;
+    scope 1 {
+        debug a => _2;
+        debug b => _3;
+        debug rest => _4;
+        debug e => _5;
+        let _2: T;
+        let _3: T;
+        let _4: [T; 2];
+        let _5: T;
+    }
+
+    bb0: {
+        PlaceMention(_1);
+        falseEdge -> [real: bb2, imaginary: bb1];
+    }
+
+    bb1: {
+        goto -> bb7;
+    }
+
+    bb2: {
+        StorageLive(_2);
+        _2 = move _1[0 of 5];
+        StorageLive(_3);
+        _3 = move _1[1 of 5];
+        StorageLive(_4);
+        _4 = move _1[2..4];
+        StorageLive(_5);
+        _5 = move _1[4 of 5];
+        StorageLive(_6);
+        StorageLive(_7);
+        _7 = move _2;
+        _6 = opaque::<T>(move _7) -> [return: bb3, unwind: bb17];
+    }
+
+    bb3: {
+        StorageDead(_7);
+        StorageDead(_6);
+        StorageLive(_8);
+        StorageLive(_9);
+        _9 = move _3;
+        _8 = opaque::<T>(move _9) -> [return: bb4, unwind: bb16];
+    }
+
+    bb4: {
+        StorageDead(_9);
+        StorageDead(_8);
+        StorageLive(_10);
+        StorageLive(_11);
+        _11 = move _4;
+        _10 = opaque::<[T; 2]>(move _11) -> [return: bb5, unwind: bb15];
+    }
+
+    bb5: {
+        StorageDead(_11);
+        StorageDead(_10);
+        StorageLive(_12);
+        StorageLive(_13);
+        _13 = move _5;
+        _12 = opaque::<T>(move _13) -> [return: bb6, unwind: bb14];
+    }
+
+    bb6: {
+        StorageDead(_13);
+        StorageDead(_12);
+        _0 = const ();
+        drop(_5) -> [return: bb8, unwind: bb19];
+    }
+
+    bb7: {
+        _0 = const ();
+        goto -> bb12;
+    }
+
+    bb8: {
+        StorageDead(_5);
+        drop(_4) -> [return: bb9, unwind: bb20];
+    }
+
+    bb9: {
+        StorageDead(_4);
+        drop(_3) -> [return: bb10, unwind: bb21];
+    }
+
+    bb10: {
+        StorageDead(_3);
+        drop(_2) -> [return: bb11, unwind: bb22];
+    }
+
+    bb11: {
+        StorageDead(_2);
+        goto -> bb12;
+    }
+
+    bb12: {
+        drop(_1) -> [return: bb13, unwind: bb23];
+    }
+
+    bb13: {
+        return;
+    }
+
+    bb14 (cleanup): {
+        drop(_13) -> [return: bb18, unwind terminate(cleanup)];
+    }
+
+    bb15 (cleanup): {
+        drop(_11) -> [return: bb18, unwind terminate(cleanup)];
+    }
+
+    bb16 (cleanup): {
+        drop(_9) -> [return: bb18, unwind terminate(cleanup)];
+    }
+
+    bb17 (cleanup): {
+        drop(_7) -> [return: bb18, unwind terminate(cleanup)];
+    }
+
+    bb18 (cleanup): {
+        drop(_5) -> [return: bb19, unwind terminate(cleanup)];
+    }
+
+    bb19 (cleanup): {
+        drop(_4) -> [return: bb20, unwind terminate(cleanup)];
+    }
+
+    bb20 (cleanup): {
+        drop(_3) -> [return: bb21, unwind terminate(cleanup)];
+    }
+
+    bb21 (cleanup): {
+        drop(_2) -> [return: bb22, unwind terminate(cleanup)];
+    }
+
+    bb22 (cleanup): {
+        drop(_1) -> [return: bb23, unwind terminate(cleanup)];
+    }
+
+    bb23 (cleanup): {
+        resume;
+    }
+}
diff --git a/tests/mir-opt/building/match/array_len.rs b/tests/mir-opt/building/match/array_len.rs
new file mode 100644
index 0000000000000..0d889ada9b602
--- /dev/null
+++ b/tests/mir-opt/building/match/array_len.rs
@@ -0,0 +1,31 @@
+// EMIT_MIR_FOR_EACH_PANIC_STRATEGY
+//@ compile-flags: -Zmir-opt-level=0
+
+fn opaque<T>(x: T) {}
+
+// EMIT_MIR array_len.const_array_len.built.after.mir
+fn const_array_len<T>(x: [T; 5]) {
+    // CHECK-LABEL: fn const_array_len(
+    // CHECK-NOT: Len
+    // CHECK-NOT: PtrMetadata
+    // CHECK: = const 5_usize;
+    if let [a, b, rest @ .., e] = x {
+        opaque(a);
+        opaque(b);
+        opaque(rest);
+        opaque(e);
+    }
+}
+
+// EMIT_MIR array_len.slice_len.built.after.mir
+fn slice_len<T>(x: &[T]) {
+    // CHECK-LABEL: fn slice_len(
+    // CHECK-NOT: Len
+    // CHECK: = PtrMetadata(copy _1);
+    if let [a, b, rest @ .., e] = x {
+        opaque(a);
+        opaque(b);
+        opaque(rest);
+        opaque(e);
+    }
+}
diff --git a/tests/mir-opt/building/match/array_len.slice_len.built.after.panic-abort.mir b/tests/mir-opt/building/match/array_len.slice_len.built.after.panic-abort.mir
new file mode 100644
index 0000000000000..d73f5a1b6f716
--- /dev/null
+++ b/tests/mir-opt/building/match/array_len.slice_len.built.after.panic-abort.mir
@@ -0,0 +1,115 @@
+// MIR for `slice_len` after built
+
+fn slice_len(_1: &[T]) -> () {
+    debug x => _1;
+    let mut _0: ();
+    let mut _2: usize;
+    let mut _3: usize;
+    let mut _4: usize;
+    let mut _5: bool;
+    let _10: ();
+    let mut _11: &T;
+    let _12: ();
+    let mut _13: &T;
+    let _14: ();
+    let mut _15: &[T];
+    let _16: ();
+    let mut _17: &T;
+    scope 1 {
+        debug a => _6;
+        debug b => _7;
+        debug rest => _8;
+        debug e => _9;
+        let _6: &T;
+        let _7: &T;
+        let _8: &[T];
+        let _9: &T;
+    }
+
+    bb0: {
+        PlaceMention(_1);
+        _3 = PtrMetadata(copy _1);
+        _2 = move _3;
+        _4 = const 3_usize;
+        _5 = Ge(move _2, move _4);
+        switchInt(move _5) -> [0: bb1, otherwise: bb2];
+    }
+
+    bb1: {
+        goto -> bb9;
+    }
+
+    bb2: {
+        falseEdge -> [real: bb4, imaginary: bb1];
+    }
+
+    bb3: {
+        goto -> bb1;
+    }
+
+    bb4: {
+        StorageLive(_6);
+        _6 = &(*_1)[0 of 3];
+        StorageLive(_7);
+        _7 = &(*_1)[1 of 3];
+        StorageLive(_8);
+        _8 = &(*_1)[2:-1];
+        StorageLive(_9);
+        _9 = &(*_1)[-1 of 3];
+        StorageLive(_10);
+        StorageLive(_11);
+        _11 = copy _6;
+        _10 = opaque::<&T>(move _11) -> [return: bb5, unwind: bb11];
+    }
+
+    bb5: {
+        StorageDead(_11);
+        StorageDead(_10);
+        StorageLive(_12);
+        StorageLive(_13);
+        _13 = copy _7;
+        _12 = opaque::<&T>(move _13) -> [return: bb6, unwind: bb11];
+    }
+
+    bb6: {
+        StorageDead(_13);
+        StorageDead(_12);
+        StorageLive(_14);
+        StorageLive(_15);
+        _15 = copy _8;
+        _14 = opaque::<&[T]>(move _15) -> [return: bb7, unwind: bb11];
+    }
+
+    bb7: {
+        StorageDead(_15);
+        StorageDead(_14);
+        StorageLive(_16);
+        StorageLive(_17);
+        _17 = copy _9;
+        _16 = opaque::<&T>(move _17) -> [return: bb8, unwind: bb11];
+    }
+
+    bb8: {
+        StorageDead(_17);
+        StorageDead(_16);
+        _0 = const ();
+        StorageDead(_9);
+        StorageDead(_8);
+        StorageDead(_7);
+        StorageDead(_6);
+        goto -> bb10;
+    }
+
+    bb9: {
+        _0 = const ();
+        goto -> bb10;
+    }
+
+    bb10: {
+        return;
+    }
+
+    bb11 (cleanup): {
+        resume;
+    }
+}
diff --git a/tests/mir-opt/building/match/array_len.slice_len.built.after.panic-unwind.mir b/tests/mir-opt/building/match/array_len.slice_len.built.after.panic-unwind.mir
new file mode 100644
index 0000000000000..d73f5a1b6f716
--- /dev/null
+++ b/tests/mir-opt/building/match/array_len.slice_len.built.after.panic-unwind.mir
@@ -0,0 +1,115 @@
+// MIR for `slice_len` after built
+
+fn slice_len(_1: &[T]) -> () {
+    debug x => _1;
+    let mut _0: ();
+    let mut _2: usize;
+    let mut _3: usize;
+    let mut _4: usize;
+    let mut _5: bool;
+    let _10: ();
+    let mut _11: &T;
+    let _12: ();
+    let mut _13: &T;
+    let _14: ();
+    let mut _15: &[T];
+    let _16: ();
+    let mut _17: &T;
+    scope 1 {
+        debug a => _6;
+        debug b => _7;
+        debug rest => _8;
+        debug e => _9;
+        let _6: &T;
+        let _7: &T;
+        let _8: &[T];
+        let _9: &T;
+    }
+
+    bb0: {
+        PlaceMention(_1);
+        _3 = PtrMetadata(copy _1);
+        _2 = move _3;
+        _4 = const 3_usize;
+        _5 = Ge(move _2, move _4);
+        switchInt(move _5) -> [0: bb1, otherwise: bb2];
+    }
+
+    bb1: {
+        goto -> bb9;
+    }
+
+    bb2: {
+        falseEdge -> [real: bb4, imaginary: bb1];
+    }
+
+    bb3: {
+        goto -> bb1;
+    }
+
+    bb4: {
+        StorageLive(_6);
+        _6 = &(*_1)[0 of 3];
+        StorageLive(_7);
+        _7 = &(*_1)[1 of 3];
+        StorageLive(_8);
+        _8 = &(*_1)[2:-1];
+        StorageLive(_9);
+        _9 = &(*_1)[-1 of 3];
+        StorageLive(_10);
+        StorageLive(_11);
+        _11 = copy _6;
+        _10 = opaque::<&T>(move _11) -> [return: bb5, unwind: bb11];
+    }
+
+    bb5: {
+        StorageDead(_11);
+        StorageDead(_10);
+        StorageLive(_12);
+        StorageLive(_13);
+        _13 = copy _7;
+        _12 = opaque::<&T>(move _13) -> [return: bb6, unwind: bb11];
+    }
+
+    bb6: {
+        StorageDead(_13);
+        StorageDead(_12);
+        StorageLive(_14);
+        StorageLive(_15);
+        _15 = copy _8;
+        _14 = opaque::<&[T]>(move _15) -> [return: bb7, unwind: bb11];
+    }
+
+    bb7: {
+        StorageDead(_15);
+        StorageDead(_14);
+        StorageLive(_16);
+        StorageLive(_17);
+        _17 = copy _9;
+        _16 = opaque::<&T>(move _17) -> [return: bb8, unwind: bb11];
+    }
+
+    bb8: {
+        StorageDead(_17);
+        StorageDead(_16);
+        _0 = const ();
+        StorageDead(_9);
+        StorageDead(_8);
+        StorageDead(_7);
+        StorageDead(_6);
+        goto -> bb10;
+    }
+
+    bb9: {
+        _0 = const ();
+        goto -> bb10;
+    }
+
+    bb10: {
+        return;
+    }
+
+    bb11 (cleanup): {
+        resume;
+    }
+}
diff --git a/tests/mir-opt/instsimplify/combine_array_len.normN.InstSimplify-after-simplifycfg.panic-abort.diff b/tests/mir-opt/instsimplify/combine_array_len.normN.InstSimplify-after-simplifycfg.panic-abort.diff
new file mode 100644
index 0000000000000..e9cb2c5817720
--- /dev/null
+++ b/tests/mir-opt/instsimplify/combine_array_len.normN.InstSimplify-after-simplifycfg.panic-abort.diff
@@ -0,0 +1,71 @@
+- // MIR for `normN` before InstSimplify-after-simplifycfg
++ // MIR for `normN` after InstSimplify-after-simplifycfg
+  
+  fn normN(_1: [f32; N]) -> f32 {
+      debug x => _1;
+      let mut _0: f32;
+      let _2: f32;
+      let _3: usize;
+      let mut _4: bool;
+      let _6: usize;
+      let mut _7: bool;
+      let mut _8: f32;
+      let mut _9: f32;
+      let mut _10: f32;
+      let mut _11: f32;
+      let mut _12: f32;
+      let mut _13: f32;
+      scope 1 {
+          debug a => _2;
+          let _5: f32;
+          scope 2 {
+              debug b => _5;
+          }
+      }
+  
+      bb0: {
+          StorageLive(_2);
+          StorageLive(_3);
+          _3 = const 0_usize;
+          _4 = Lt(copy _3, const N);
+          assert(move _4, "index out of bounds: the length is {} but the index is {}", const N, copy _3) -> [success: bb1, unwind unreachable];
+      }
+  
+      bb1: {
+          _2 = copy _1[_3];
+          StorageDead(_3);
+          StorageLive(_5);
+          StorageLive(_6);
+          _6 = const 1_usize;
+          _7 = Lt(copy _6, const N);
+          assert(move _7, "index out of bounds: the length is {} but the index is {}", const N, copy _6) -> [success: bb2, unwind unreachable];
+      }
+  
+      bb2: {
+          _5 = copy _1[_6];
+          StorageDead(_6);
+          StorageLive(_8);
+          StorageLive(_9);
+          _9 = copy _2;
+          StorageLive(_10);
+          _10 = copy _2;
+          _8 = Mul(move _9, move _10);
+          StorageDead(_10);
+          StorageDead(_9);
+          StorageLive(_11);
+          StorageLive(_12);
+          _12 = copy _5;
+          StorageLive(_13);
+          _13 = copy _5;
+          _11 = Mul(move _12, move _13);
+          StorageDead(_13);
+          StorageDead(_12);
+          _0 = Add(move _8, move _11);
+          StorageDead(_11);
+          StorageDead(_8);
+          StorageDead(_5);
+          StorageDead(_2);
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/instsimplify/combine_array_len.normN.InstSimplify-after-simplifycfg.panic-unwind.diff b/tests/mir-opt/instsimplify/combine_array_len.normN.InstSimplify-after-simplifycfg.panic-unwind.diff
new file mode 100644
index 0000000000000..0ddc70f2003e8
--- /dev/null
+++ b/tests/mir-opt/instsimplify/combine_array_len.normN.InstSimplify-after-simplifycfg.panic-unwind.diff
@@ -0,0 +1,71 @@
+- // MIR for `normN` before InstSimplify-after-simplifycfg
++ // MIR for `normN` after InstSimplify-after-simplifycfg
+  
+  fn normN(_1: [f32; N]) -> f32 {
+      debug x => _1;
+      let mut _0: f32;
+      let _2: f32;
+      let _3: usize;
+      let mut _4: bool;
+      let _6: usize;
+      let mut _7: bool;
+      let mut _8: f32;
+      let mut _9: f32;
+      let mut _10: f32;
+      let mut _11: f32;
+      let mut _12: f32;
+      let mut _13: f32;
+      scope 1 {
+          debug a => _2;
+          let _5: f32;
+          scope 2 {
+              debug b => _5;
+          }
+      }
+  
+      bb0: {
+          StorageLive(_2);
+          StorageLive(_3);
+          _3 = const 0_usize;
+          _4 = Lt(copy _3, const N);
+          assert(move _4, "index out of bounds: the length is {} but the index is {}", const N, copy _3) -> [success: bb1, unwind continue];
+      }
+  
+      bb1: {
+          _2 = copy _1[_3];
+          StorageDead(_3);
+          StorageLive(_5);
+          StorageLive(_6);
+          _6 = const 1_usize;
+          _7 = Lt(copy _6, const N);
+          assert(move _7, "index out of bounds: the length is {} but the index is {}", const N, copy _6) -> [success: bb2, unwind continue];
+      }
+  
+      bb2: {
+          _5 = copy _1[_6];
+          StorageDead(_6);
+          StorageLive(_8);
+          StorageLive(_9);
+          _9 = copy _2;
+          StorageLive(_10);
+          _10 = copy _2;
+          _8 = Mul(move _9, move _10);
+          StorageDead(_10);
+          StorageDead(_9);
+          StorageLive(_11);
+          StorageLive(_12);
+          _12 = copy _5;
+          StorageLive(_13);
+          _13 = copy _5;
+          _11 = Mul(move _12, move _13);
+          StorageDead(_13);
+          StorageDead(_12);
+          _0 = Add(move _8, move _11);
+          StorageDead(_11);
+          StorageDead(_8);
+          StorageDead(_5);
+          StorageDead(_2);
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/instsimplify/combine_array_len.rs b/tests/mir-opt/instsimplify/combine_array_len.rs
index 91f43f75689de..1c4d42d3bbe82 100644
--- a/tests/mir-opt/instsimplify/combine_array_len.rs
+++ b/tests/mir-opt/instsimplify/combine_array_len.rs
@@ -4,7 +4,16 @@
 // EMIT_MIR combine_array_len.norm2.InstSimplify-after-simplifycfg.diff
 fn norm2(x: [f32; 2]) -> f32 {
     // CHECK-LABEL: fn norm2(
-    // CHECK-NOT: Len(
+    // CHECK-NOT: PtrMetadata(
+    let a = x[0];
+    let b = x[1];
+    a * a + b * b
+}
+
+// EMIT_MIR combine_array_len.normN.InstSimplify-after-simplifycfg.diff
+fn normN<const N: usize>(x: [f32; N]) -> f32 {
+    // CHECK-LABEL: fn normN(
+    // CHECK-NOT: PtrMetadata(
     let a = x[0];
     let b = x[1];
     a * a + b * b
@@ -12,4 +21,5 @@ fn norm2(x: [f32; 2]) -> f32 {
 
 fn main() {
     assert_eq!(norm2([3.0, 4.0]), 5.0 * 5.0);
+    assert_eq!(normN([3.0, 4.0]), 5.0 * 5.0);
 }

From 40d879a47f940a8a6219ded487ce1298ecafe271 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Sun, 14 Sep 2025 19:08:16 +0000
Subject: [PATCH 1021/1889] Add test.

---
 compiler/rustc_middle/src/mir/mod.rs          |   2 +-
 compiler/rustc_middle/src/mir/query.rs        |   2 +-
 ...await.b-{closure#0}.coroutine_resume.0.mir |  12 +-
 ....main-{closure#0}.StateTransform.after.mir | 208 ++++++++++++++++++
 ....main-{closure#1}.StateTransform.after.mir | 208 ++++++++++++++++++
 tests/mir-opt/building/coroutine.rs           |  26 +++
 ...ny.main-{closure#0}.coroutine_resume.0.mir |   6 +-
 7 files changed, 453 insertions(+), 11 deletions(-)
 create mode 100644 tests/mir-opt/building/coroutine.main-{closure#0}.StateTransform.after.mir
 create mode 100644 tests/mir-opt/building/coroutine.main-{closure#1}.StateTransform.after.mir
 create mode 100644 tests/mir-opt/building/coroutine.rs

diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs
index da2245b12d2c2..28142382b130b 100644
--- a/compiler/rustc_middle/src/mir/mod.rs
+++ b/compiler/rustc_middle/src/mir/mod.rs
@@ -471,7 +471,7 @@ impl<'tcx> Body<'tcx> {
 
     /// Returns an iterator over all function arguments.
     #[inline]
-    pub fn args_iter(&self) -> impl Iterator<Item = Local> + ExactSizeIterator {
+    pub fn args_iter(&self) -> impl Iterator<Item = Local> + ExactSizeIterator + use<> {
         (1..self.arg_count + 1).map(Local::new)
     }
 
diff --git a/compiler/rustc_middle/src/mir/query.rs b/compiler/rustc_middle/src/mir/query.rs
index 466b9c7a3c23a..a509c40c89cd6 100644
--- a/compiler/rustc_middle/src/mir/query.rs
+++ b/compiler/rustc_middle/src/mir/query.rs
@@ -17,7 +17,7 @@ use crate::ty::{self, CoroutineArgsExt, OpaqueHiddenType, Ty};
 rustc_index::newtype_index! {
     #[derive(HashStable)]
     #[encodable]
-    #[debug_format = "_{}"]
+    #[debug_format = "_s{}"]
     pub struct CoroutineSavedLocal {}
 }
 
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 9bff257e06392..945d6299e4373 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
@@ -1,7 +1,7 @@
 // MIR for `b::{closure#0}` 0 coroutine_resume
 /* coroutine_layout = CoroutineLayout {
     field_tys: {
-        _0: CoroutineSavedTy {
+        _s0: CoroutineSavedTy {
             ty: Coroutine(
                 DefId(0:5 ~ async_await[ccf8]::a::{closure#0}),
                 [
@@ -18,7 +18,7 @@
             },
             ignore_for_traits: false,
         },
-        _1: CoroutineSavedTy {
+        _s1: CoroutineSavedTy {
             ty: Coroutine(
                 DefId(0:5 ~ async_await[ccf8]::a::{closure#0}),
                 [
@@ -40,12 +40,12 @@
         Unresumed(0): [],
         Returned (1): [],
         Panicked (2): [],
-        Suspend0 (3): [_0],
-        Suspend1 (4): [_1],
+        Suspend0 (3): [_s0],
+        Suspend1 (4): [_s1],
     },
     storage_conflicts: BitMatrix(2x2) {
-        (_0, _0),
-        (_1, _1),
+        (_s0, _s0),
+        (_s1, _s1),
     },
 } */
 
diff --git a/tests/mir-opt/building/coroutine.main-{closure#0}.StateTransform.after.mir b/tests/mir-opt/building/coroutine.main-{closure#0}.StateTransform.after.mir
new file mode 100644
index 0000000000000..349cfa89838de
--- /dev/null
+++ b/tests/mir-opt/building/coroutine.main-{closure#0}.StateTransform.after.mir
@@ -0,0 +1,208 @@
+// MIR for `main::{closure#0}` after StateTransform
+/* coroutine_layout = CoroutineLayout {
+    field_tys: {
+        _s0: CoroutineSavedTy {
+            ty: std::string::String,
+            source_info: SourceInfo {
+                span: $DIR/coroutine.rs:17:32: 17:35 (#0),
+                scope: scope[0],
+            },
+            ignore_for_traits: false,
+        },
+    },
+    variant_fields: {
+        Unresumed(0): [],
+        Returned (1): [],
+        Panicked (2): [],
+        Suspend0 (3): [_s0],
+        Suspend1 (4): [_s0],
+    },
+    storage_conflicts: BitMatrix(1x1) {
+        (_s0, _s0),
+    },
+} */
+
+fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:17:31: 17:44}>, _2: String) -> CoroutineState<(&str, String, &Location<'_>), ()> {
+    debug arg => (((*(_1.0: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44})) as variant#4).0: std::string::String);
+    let mut _0: std::ops::CoroutineState<(&str, std::string::String, &std::panic::Location<'_>), ()>;
+    let _3: std::string::String;
+    let mut _4: (&str, std::string::String, &std::panic::Location<'_>);
+    let mut _5: std::string::String;
+    let mut _6: &std::string::String;
+    let mut _7: &std::panic::Location<'_>;
+    let _8: std::string::String;
+    let mut _9: (&str, std::string::String, &std::panic::Location<'_>);
+    let mut _10: &str;
+    let _11: &str;
+    let mut _12: std::string::String;
+    let mut _13: &std::string::String;
+    let mut _14: &std::panic::Location<'_>;
+    let _15: &std::panic::Location<'_>;
+    let mut _16: ();
+    let _17: std::string::String;
+    let mut _18: u32;
+    let mut _19: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44};
+    let mut _20: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44};
+    let mut _21: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44};
+    let mut _22: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44};
+    let mut _23: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44};
+    let mut _24: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44};
+    let mut _25: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44};
+    let mut _26: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44};
+
+    bb0: {
+        _19 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44});
+        _18 = discriminant((*_19));
+        switchInt(move _18) -> [0: bb1, 1: bb19, 3: bb17, 4: bb18, otherwise: bb20];
+    }
+
+    bb1: {
+        _20 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44});
+        (((*_20) as variant#4).0: std::string::String) = move _2;
+        StorageLive(_3);
+        StorageLive(_4);
+        StorageLive(_5);
+        StorageLive(_6);
+        _21 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44});
+        _6 = &(((*_21) as variant#4).0: std::string::String);
+        _5 = <String as Clone>::clone(move _6) -> [return: bb2, unwind unreachable];
+    }
+
+    bb2: {
+        StorageDead(_6);
+        StorageLive(_7);
+        _7 = Location::<'_>::caller() -> [return: bb3, unwind unreachable];
+    }
+
+    bb3: {
+        _4 = (const "first", move _5, move _7);
+        StorageDead(_7);
+        goto -> bb4;
+    }
+
+    bb4: {
+        StorageDead(_5);
+        _0 = CoroutineState::<(&str, String, &Location<'_>), ()>::Yielded(move _4);
+        StorageDead(_3);
+        StorageDead(_4);
+        _22 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44});
+        discriminant((*_22)) = 3;
+        return;
+    }
+
+    bb5: {
+        goto -> bb6;
+    }
+
+    bb6: {
+        StorageDead(_4);
+        drop(_3) -> [return: bb7, unwind unreachable];
+    }
+
+    bb7: {
+        StorageDead(_3);
+        StorageLive(_8);
+        StorageLive(_9);
+        StorageLive(_10);
+        StorageLive(_11);
+        _11 = const "second";
+        _10 = &(*_11);
+        StorageLive(_12);
+        StorageLive(_13);
+        _23 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44});
+        _13 = &(((*_23) as variant#4).0: std::string::String);
+        _12 = <String as Clone>::clone(move _13) -> [return: bb8, unwind unreachable];
+    }
+
+    bb8: {
+        StorageDead(_13);
+        StorageLive(_14);
+        StorageLive(_15);
+        _15 = Location::<'_>::caller() -> [return: bb9, unwind unreachable];
+    }
+
+    bb9: {
+        _14 = &(*_15);
+        _9 = (move _10, move _12, move _14);
+        StorageDead(_14);
+        goto -> bb10;
+    }
+
+    bb10: {
+        StorageDead(_12);
+        StorageDead(_10);
+        _0 = CoroutineState::<(&str, String, &Location<'_>), ()>::Yielded(move _9);
+        StorageDead(_8);
+        StorageDead(_9);
+        StorageDead(_11);
+        StorageDead(_15);
+        _24 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44});
+        discriminant((*_24)) = 4;
+        return;
+    }
+
+    bb11: {
+        goto -> bb12;
+    }
+
+    bb12: {
+        StorageDead(_9);
+        drop(_8) -> [return: bb13, unwind unreachable];
+    }
+
+    bb13: {
+        StorageDead(_15);
+        StorageDead(_11);
+        StorageDead(_8);
+        _16 = const ();
+        _25 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44});
+        drop((((*_25) as variant#4).0: std::string::String)) -> [return: bb14, unwind unreachable];
+    }
+
+    bb14: {
+        goto -> bb16;
+    }
+
+    bb15: {
+        _0 = CoroutineState::<(&str, String, &Location<'_>), ()>::Complete(move _16);
+        _26 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44});
+        discriminant((*_26)) = 1;
+        return;
+    }
+
+    bb16: {
+        goto -> bb15;
+    }
+
+    bb17: {
+        StorageLive(_3);
+        StorageLive(_4);
+        _3 = move _2;
+        goto -> bb5;
+    }
+
+    bb18: {
+        StorageLive(_8);
+        StorageLive(_9);
+        StorageLive(_11);
+        StorageLive(_15);
+        _8 = move _2;
+        goto -> bb11;
+    }
+
+    bb19: {
+        assert(const false, "coroutine resumed after completion") -> [success: bb19, unwind unreachable];
+    }
+
+    bb20: {
+        unreachable;
+    }
+}
+
+ALLOC0 (size: 6, align: 1) {
+    73 65 63 6f 6e 64                               │ second
+}
+
+ALLOC1 (size: 5, align: 1) {
+    66 69 72 73 74                                  │ first
+}
diff --git a/tests/mir-opt/building/coroutine.main-{closure#1}.StateTransform.after.mir b/tests/mir-opt/building/coroutine.main-{closure#1}.StateTransform.after.mir
new file mode 100644
index 0000000000000..dd8fb41896361
--- /dev/null
+++ b/tests/mir-opt/building/coroutine.main-{closure#1}.StateTransform.after.mir
@@ -0,0 +1,208 @@
+// MIR for `main::{closure#1}` after StateTransform
+/* coroutine_layout = CoroutineLayout {
+    field_tys: {
+        _s0: CoroutineSavedTy {
+            ty: std::string::String,
+            source_info: SourceInfo {
+                span: $DIR/coroutine.rs:22:54: 22:57 (#0),
+                scope: scope[0],
+            },
+            ignore_for_traits: false,
+        },
+    },
+    variant_fields: {
+        Unresumed(0): [],
+        Returned (1): [],
+        Panicked (2): [],
+        Suspend0 (3): [_s0],
+        Suspend1 (4): [_s0],
+    },
+    storage_conflicts: BitMatrix(1x1) {
+        (_s0, _s0),
+    },
+} */
+
+fn main::{closure#1}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:22:53: 22:66}>, _2: String) -> CoroutineState<(&str, String, &Location<'_>), ()> {
+    debug arg => (((*(_1.0: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66})) as variant#4).0: std::string::String);
+    let mut _0: std::ops::CoroutineState<(&str, std::string::String, &std::panic::Location<'_>), ()>;
+    let _3: std::string::String;
+    let mut _4: (&str, std::string::String, &std::panic::Location<'_>);
+    let mut _5: std::string::String;
+    let mut _6: &std::string::String;
+    let mut _7: &std::panic::Location<'_>;
+    let _8: std::string::String;
+    let mut _9: (&str, std::string::String, &std::panic::Location<'_>);
+    let mut _10: &str;
+    let _11: &str;
+    let mut _12: std::string::String;
+    let mut _13: &std::string::String;
+    let mut _14: &std::panic::Location<'_>;
+    let _15: &std::panic::Location<'_>;
+    let mut _16: ();
+    let _17: std::string::String;
+    let mut _18: u32;
+    let mut _19: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66};
+    let mut _20: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66};
+    let mut _21: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66};
+    let mut _22: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66};
+    let mut _23: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66};
+    let mut _24: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66};
+    let mut _25: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66};
+    let mut _26: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66};
+
+    bb0: {
+        _19 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66});
+        _18 = discriminant((*_19));
+        switchInt(move _18) -> [0: bb1, 1: bb19, 3: bb17, 4: bb18, otherwise: bb20];
+    }
+
+    bb1: {
+        _20 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66});
+        (((*_20) as variant#4).0: std::string::String) = move _2;
+        StorageLive(_3);
+        StorageLive(_4);
+        StorageLive(_5);
+        StorageLive(_6);
+        _21 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66});
+        _6 = &(((*_21) as variant#4).0: std::string::String);
+        _5 = <String as Clone>::clone(move _6) -> [return: bb2, unwind unreachable];
+    }
+
+    bb2: {
+        StorageDead(_6);
+        StorageLive(_7);
+        _7 = Location::<'_>::caller() -> [return: bb3, unwind unreachable];
+    }
+
+    bb3: {
+        _4 = (const "first", move _5, move _7);
+        StorageDead(_7);
+        goto -> bb4;
+    }
+
+    bb4: {
+        StorageDead(_5);
+        _0 = CoroutineState::<(&str, String, &Location<'_>), ()>::Yielded(move _4);
+        StorageDead(_3);
+        StorageDead(_4);
+        _22 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66});
+        discriminant((*_22)) = 3;
+        return;
+    }
+
+    bb5: {
+        goto -> bb6;
+    }
+
+    bb6: {
+        StorageDead(_4);
+        drop(_3) -> [return: bb7, unwind unreachable];
+    }
+
+    bb7: {
+        StorageDead(_3);
+        StorageLive(_8);
+        StorageLive(_9);
+        StorageLive(_10);
+        StorageLive(_11);
+        _11 = const "second";
+        _10 = &(*_11);
+        StorageLive(_12);
+        StorageLive(_13);
+        _23 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66});
+        _13 = &(((*_23) as variant#4).0: std::string::String);
+        _12 = <String as Clone>::clone(move _13) -> [return: bb8, unwind unreachable];
+    }
+
+    bb8: {
+        StorageDead(_13);
+        StorageLive(_14);
+        StorageLive(_15);
+        _15 = Location::<'_>::caller() -> [return: bb9, unwind unreachable];
+    }
+
+    bb9: {
+        _14 = &(*_15);
+        _9 = (move _10, move _12, move _14);
+        StorageDead(_14);
+        goto -> bb10;
+    }
+
+    bb10: {
+        StorageDead(_12);
+        StorageDead(_10);
+        _0 = CoroutineState::<(&str, String, &Location<'_>), ()>::Yielded(move _9);
+        StorageDead(_8);
+        StorageDead(_9);
+        StorageDead(_11);
+        StorageDead(_15);
+        _24 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66});
+        discriminant((*_24)) = 4;
+        return;
+    }
+
+    bb11: {
+        goto -> bb12;
+    }
+
+    bb12: {
+        StorageDead(_9);
+        drop(_8) -> [return: bb13, unwind unreachable];
+    }
+
+    bb13: {
+        StorageDead(_15);
+        StorageDead(_11);
+        StorageDead(_8);
+        _16 = const ();
+        _25 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66});
+        drop((((*_25) as variant#4).0: std::string::String)) -> [return: bb14, unwind unreachable];
+    }
+
+    bb14: {
+        goto -> bb16;
+    }
+
+    bb15: {
+        _0 = CoroutineState::<(&str, String, &Location<'_>), ()>::Complete(move _16);
+        _26 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66});
+        discriminant((*_26)) = 1;
+        return;
+    }
+
+    bb16: {
+        goto -> bb15;
+    }
+
+    bb17: {
+        StorageLive(_3);
+        StorageLive(_4);
+        _3 = move _2;
+        goto -> bb5;
+    }
+
+    bb18: {
+        StorageLive(_8);
+        StorageLive(_9);
+        StorageLive(_11);
+        StorageLive(_15);
+        _8 = move _2;
+        goto -> bb11;
+    }
+
+    bb19: {
+        assert(const false, "coroutine resumed after completion") -> [success: bb19, unwind unreachable];
+    }
+
+    bb20: {
+        unreachable;
+    }
+}
+
+ALLOC0 (size: 6, align: 1) {
+    73 65 63 6f 6e 64                               │ second
+}
+
+ALLOC1 (size: 5, align: 1) {
+    66 69 72 73 74                                  │ first
+}
diff --git a/tests/mir-opt/building/coroutine.rs b/tests/mir-opt/building/coroutine.rs
new file mode 100644
index 0000000000000..4b3310f7dd8bf
--- /dev/null
+++ b/tests/mir-opt/building/coroutine.rs
@@ -0,0 +1,26 @@
+// skip-filecheck
+//@ edition:2024
+//@ compile-flags: -Zmir-opt-level=0 -C panic=abort
+
+#![feature(stmt_expr_attributes)]
+#![feature(closure_track_caller)]
+#![feature(coroutine_trait)]
+#![feature(coroutines)]
+
+use std::ops::{Coroutine, CoroutineState};
+use std::pin::Pin;
+use std::panic::Location;
+
+// EMIT_MIR coroutine.main-{closure#0}.StateTransform.after.mir
+// EMIT_MIR coroutine.main-{closure#1}.StateTransform.after.mir
+fn main() {
+    let simple = #[coroutine] |arg: String| {
+        yield ("first", arg.clone(), Location::caller());
+        yield ("second", arg.clone(), Location::caller());
+    };
+
+    let track_caller = #[track_caller] #[coroutine] |arg: String| {
+        yield ("first", arg.clone(), Location::caller());
+        yield ("second", arg.clone(), Location::caller());
+    };
+}
diff --git a/tests/mir-opt/coroutine_tiny.main-{closure#0}.coroutine_resume.0.mir b/tests/mir-opt/coroutine_tiny.main-{closure#0}.coroutine_resume.0.mir
index f8b3f68d21e63..83159b5055acc 100644
--- a/tests/mir-opt/coroutine_tiny.main-{closure#0}.coroutine_resume.0.mir
+++ b/tests/mir-opt/coroutine_tiny.main-{closure#0}.coroutine_resume.0.mir
@@ -1,7 +1,7 @@
 // MIR for `main::{closure#0}` 0 coroutine_resume
 /* coroutine_layout = CoroutineLayout {
     field_tys: {
-        _0: CoroutineSavedTy {
+        _s0: CoroutineSavedTy {
             ty: HasDrop,
             source_info: SourceInfo {
                 span: $DIR/coroutine_tiny.rs:22:13: 22:15 (#0),
@@ -14,10 +14,10 @@
         Unresumed(0): [],
         Returned (1): [],
         Panicked (2): [],
-        Suspend0 (3): [_0],
+        Suspend0 (3): [_s0],
     },
     storage_conflicts: BitMatrix(1x1) {
-        (_0, _0),
+        (_s0, _s0),
     },
 } */
 

From fe3a784ef23603180efef1501d80b265663fdec2 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Sun, 14 Sep 2025 15:15:49 +0000
Subject: [PATCH 1022/1889] Do not renumber resume local.

---
 compiler/rustc_mir_transform/src/coroutine.rs |  47 +++----
 ...#0}.coroutine_drop_async.0.panic-abort.mir |   9 +-
 ...0}.coroutine_drop_async.0.panic-unwind.mir |   9 +-
 ...await.a-{closure#0}.coroutine_resume.0.mir |  10 +-
 ...await.b-{closure#0}.coroutine_resume.0.mir |  18 ++-
 ....main-{closure#0}.StateTransform.after.mir |  59 +++++----
 ....main-{closure#1}.StateTransform.after.mir |  59 +++++----
 tests/mir-opt/building/coroutine.rs           |   9 +-
 ...losure#0}.coroutine_drop.0.panic-abort.mir |   7 +-
 ...osure#0}.coroutine_drop.0.panic-unwind.mir |   7 +-
 ...ny.main-{closure#0}.coroutine_resume.0.mir |  10 +-
 ...y.run2-{closure#0}.Inline.panic-abort.diff | 114 ++++++++--------
 ....run2-{closure#0}.Inline.panic-unwind.diff | 122 +++++++++---------
 13 files changed, 228 insertions(+), 252 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/coroutine.rs b/compiler/rustc_mir_transform/src/coroutine.rs
index 4603c695dedd5..08316aaed3b42 100644
--- a/compiler/rustc_mir_transform/src/coroutine.rs
+++ b/compiler/rustc_mir_transform/src/coroutine.rs
@@ -1340,14 +1340,13 @@ fn create_cases<'tcx>(
                     }
                 }
 
-                if operation == Operation::Resume {
+                if operation == Operation::Resume && point.resume_arg != CTX_ARG.into() {
                     // Move the resume argument to the destination place of the `Yield` terminator
-                    let resume_arg = CTX_ARG;
                     statements.push(Statement::new(
                         source_info,
                         StatementKind::Assign(Box::new((
                             point.resume_arg,
-                            Rvalue::Use(Operand::Move(resume_arg.into())),
+                            Rvalue::Use(Operand::Move(CTX_ARG.into())),
                         ))),
                     ));
                 }
@@ -1439,7 +1438,10 @@ fn check_field_tys_sized<'tcx>(
 }
 
 impl<'tcx> crate::MirPass<'tcx> for StateTransform {
+    #[instrument(level = "debug", skip(self, tcx, body), ret)]
     fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
+        debug!(def_id = ?body.source.def_id());
+
         let Some(old_yield_ty) = body.yield_ty() else {
             // This only applies to coroutines
             return;
@@ -1518,31 +1520,7 @@ impl<'tcx> crate::MirPass<'tcx> for StateTransform {
             cleanup_async_drops(body);
         }
 
-        // We also replace the resume argument and insert an `Assign`.
-        // This is needed because the resume argument `_2` might be live across a `yield`, in which
-        // case there is no `Assign` to it that the transform can turn into a store to the coroutine
-        // state. After the yield the slot in the coroutine state would then be uninitialized.
-        let resume_local = CTX_ARG;
-        let resume_ty = body.local_decls[resume_local].ty;
-        let old_resume_local = replace_local(resume_local, resume_ty, body, tcx);
-
-        // When first entering the coroutine, move the resume argument into its old local
-        // (which is now a generator interior).
-        let source_info = SourceInfo::outermost(body.span);
-        let stmts = &mut body.basic_blocks_mut()[START_BLOCK].statements;
-        stmts.insert(
-            0,
-            Statement::new(
-                source_info,
-                StatementKind::Assign(Box::new((
-                    old_resume_local.into(),
-                    Rvalue::Use(Operand::Move(resume_local.into())),
-                ))),
-            ),
-        );
-
         let always_live_locals = always_storage_live_locals(body);
-
         let movable = coroutine_kind.movability() == hir::Movability::Movable;
         let liveness_info =
             locals_live_across_suspend_points(tcx, body, &always_live_locals, movable);
@@ -1583,6 +1561,21 @@ impl<'tcx> crate::MirPass<'tcx> for StateTransform {
         };
         transform.visit_body(body);
 
+        // MIR parameters are not explicitly assigned-to when entering the MIR body.
+        // If we want to save their values inside the coroutine state, we need to do so explicitly.
+        let source_info = SourceInfo::outermost(body.span);
+        let args_iter = body.args_iter();
+        body.basic_blocks.as_mut()[START_BLOCK].statements.splice(
+            0..0,
+            args_iter.filter_map(|local| {
+                let (ty, variant_index, idx) = transform.remap[local]?;
+                let lhs = transform.make_field(variant_index, idx, ty);
+                let rhs = Rvalue::Use(Operand::Move(local.into()));
+                let assign = StatementKind::Assign(Box::new((lhs, rhs)));
+                Some(Statement::new(source_info, assign))
+            }),
+        );
+
         // Update our MIR struct to reflect the changes we've made
         body.arg_count = 2; // self, resume arg
         body.spread_arg = None;
diff --git a/tests/mir-opt/async_drop_live_dead.a-{closure#0}.coroutine_drop_async.0.panic-abort.mir b/tests/mir-opt/async_drop_live_dead.a-{closure#0}.coroutine_drop_async.0.panic-abort.mir
index 347e4119cd0e0..050aac7c3ff05 100644
--- a/tests/mir-opt/async_drop_live_dead.a-{closure#0}.coroutine_drop_async.0.panic-abort.mir
+++ b/tests/mir-opt/async_drop_live_dead.a-{closure#0}.coroutine_drop_async.0.panic-abort.mir
@@ -1,7 +1,7 @@
 // MIR for `a::{closure#0}` 0 coroutine_drop_async
 
 fn a::{closure#0}(_1: Pin<&mut {async fn body of a<T>()}>, _2: &mut Context<'_>) -> Poll<()> {
-    debug _task_context => _19;
+    debug _task_context => _2;
     debug x => ((*(_1.0: &mut {async fn body of a<T>()})).0: T);
     let mut _0: std::task::Poll<()>;
     let _3: T;
@@ -20,15 +20,14 @@ fn a::{closure#0}(_1: Pin<&mut {async fn body of a<T>()}>, _2: &mut Context<'_>)
     let mut _16: &mut impl std::future::Future<Output = ()>;
     let mut _17: std::pin::Pin<&mut impl std::future::Future<Output = ()>>;
     let mut _18: isize;
-    let mut _19: &mut std::task::Context<'_>;
-    let mut _20: u32;
+    let mut _19: u32;
     scope 1 {
         debug x => (((*(_1.0: &mut {async fn body of a<T>()})) as variant#4).0: T);
     }
 
     bb0: {
-        _20 = discriminant((*(_1.0: &mut {async fn body of a<T>()})));
-        switchInt(move _20) -> [0: bb9, 3: bb12, 4: bb13, otherwise: bb14];
+        _19 = discriminant((*(_1.0: &mut {async fn body of a<T>()})));
+        switchInt(move _19) -> [0: bb9, 3: bb12, 4: bb13, otherwise: bb14];
     }
 
     bb1: {
diff --git a/tests/mir-opt/async_drop_live_dead.a-{closure#0}.coroutine_drop_async.0.panic-unwind.mir b/tests/mir-opt/async_drop_live_dead.a-{closure#0}.coroutine_drop_async.0.panic-unwind.mir
index b1cf5373f9191..796e95ff3d825 100644
--- a/tests/mir-opt/async_drop_live_dead.a-{closure#0}.coroutine_drop_async.0.panic-unwind.mir
+++ b/tests/mir-opt/async_drop_live_dead.a-{closure#0}.coroutine_drop_async.0.panic-unwind.mir
@@ -1,7 +1,7 @@
 // MIR for `a::{closure#0}` 0 coroutine_drop_async
 
 fn a::{closure#0}(_1: Pin<&mut {async fn body of a<T>()}>, _2: &mut Context<'_>) -> Poll<()> {
-    debug _task_context => _19;
+    debug _task_context => _2;
     debug x => ((*(_1.0: &mut {async fn body of a<T>()})).0: T);
     let mut _0: std::task::Poll<()>;
     let _3: T;
@@ -20,15 +20,14 @@ fn a::{closure#0}(_1: Pin<&mut {async fn body of a<T>()}>, _2: &mut Context<'_>)
     let mut _16: &mut impl std::future::Future<Output = ()>;
     let mut _17: std::pin::Pin<&mut impl std::future::Future<Output = ()>>;
     let mut _18: isize;
-    let mut _19: &mut std::task::Context<'_>;
-    let mut _20: u32;
+    let mut _19: u32;
     scope 1 {
         debug x => (((*(_1.0: &mut {async fn body of a<T>()})) as variant#4).0: T);
     }
 
     bb0: {
-        _20 = discriminant((*(_1.0: &mut {async fn body of a<T>()})));
-        switchInt(move _20) -> [0: bb12, 2: bb18, 3: bb16, 4: bb17, otherwise: bb19];
+        _19 = discriminant((*(_1.0: &mut {async fn body of a<T>()})));
+        switchInt(move _19) -> [0: bb12, 2: bb18, 3: bb16, 4: bb17, otherwise: bb19];
     }
 
     bb1: {
diff --git a/tests/mir-opt/building/async_await.a-{closure#0}.coroutine_resume.0.mir b/tests/mir-opt/building/async_await.a-{closure#0}.coroutine_resume.0.mir
index 7480324b17791..2e2876cb3fcf2 100644
--- a/tests/mir-opt/building/async_await.a-{closure#0}.coroutine_resume.0.mir
+++ b/tests/mir-opt/building/async_await.a-{closure#0}.coroutine_resume.0.mir
@@ -10,19 +10,17 @@
 } */
 
 fn a::{closure#0}(_1: Pin<&mut {async fn body of a()}>, _2: &mut Context<'_>) -> Poll<()> {
-    debug _task_context => _4;
+    debug _task_context => _2;
     let mut _0: std::task::Poll<()>;
     let mut _3: ();
-    let mut _4: &mut std::task::Context<'_>;
-    let mut _5: u32;
+    let mut _4: u32;
 
     bb0: {
-        _5 = discriminant((*(_1.0: &mut {async fn body of a()})));
-        switchInt(move _5) -> [0: bb1, 1: bb4, otherwise: bb5];
+        _4 = discriminant((*(_1.0: &mut {async fn body of a()})));
+        switchInt(move _4) -> [0: bb1, 1: bb4, otherwise: bb5];
     }
 
     bb1: {
-        _4 = move _2;
         _3 = const ();
         goto -> bb3;
     }
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 945d6299e4373..20fc4112ef288 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
@@ -50,7 +50,7 @@
 } */
 
 fn b::{closure#0}(_1: Pin<&mut {async fn body of b()}>, _2: &mut Context<'_>) -> Poll<()> {
-    debug _task_context => _38;
+    debug _task_context => _2;
     let mut _0: std::task::Poll<()>;
     let _3: ();
     let mut _4: {async fn body of a()};
@@ -85,8 +85,7 @@ fn b::{closure#0}(_1: Pin<&mut {async fn body of b()}>, _2: &mut Context<'_>) ->
     let mut _35: &mut std::task::Context<'_>;
     let mut _36: ();
     let mut _37: ();
-    let mut _38: &mut std::task::Context<'_>;
-    let mut _39: u32;
+    let mut _38: u32;
     scope 1 {
         debug __awaitee => (((*(_1.0: &mut {async fn body of b()})) as variant#3).0: {async fn body of a()});
         let _17: ();
@@ -103,12 +102,11 @@ fn b::{closure#0}(_1: Pin<&mut {async fn body of b()}>, _2: &mut Context<'_>) ->
     }
 
     bb0: {
-        _39 = discriminant((*(_1.0: &mut {async fn body of b()})));
-        switchInt(move _39) -> [0: bb1, 1: bb29, 3: bb27, 4: bb28, otherwise: bb8];
+        _38 = discriminant((*(_1.0: &mut {async fn body of b()})));
+        switchInt(move _38) -> [0: bb1, 1: bb29, 3: bb27, 4: bb28, otherwise: bb8];
     }
 
     bb1: {
-        _38 = move _2;
         StorageLive(_3);
         StorageLive(_4);
         StorageLive(_5);
@@ -143,7 +141,7 @@ fn b::{closure#0}(_1: Pin<&mut {async fn body of b()}>, _2: &mut Context<'_>) ->
         StorageLive(_13);
         StorageLive(_14);
         StorageLive(_15);
-        _15 = copy _38;
+        _15 = copy _2;
         _14 = move _15;
         goto -> bb6;
     }
@@ -198,7 +196,7 @@ fn b::{closure#0}(_1: Pin<&mut {async fn body of b()}>, _2: &mut Context<'_>) ->
 
     bb11: {
         StorageDead(_20);
-        _38 = move _19;
+        _2 = move _19;
         StorageDead(_19);
         _7 = const ();
         goto -> bb4;
@@ -245,7 +243,7 @@ fn b::{closure#0}(_1: Pin<&mut {async fn body of b()}>, _2: &mut Context<'_>) ->
         StorageLive(_29);
         StorageLive(_30);
         StorageLive(_31);
-        _31 = copy _38;
+        _31 = copy _2;
         _30 = move _31;
         goto -> bb18;
     }
@@ -295,7 +293,7 @@ fn b::{closure#0}(_1: Pin<&mut {async fn body of b()}>, _2: &mut Context<'_>) ->
 
     bb22: {
         StorageDead(_36);
-        _38 = move _35;
+        _2 = move _35;
         StorageDead(_35);
         _7 = const ();
         goto -> bb16;
diff --git a/tests/mir-opt/building/coroutine.main-{closure#0}.StateTransform.after.mir b/tests/mir-opt/building/coroutine.main-{closure#0}.StateTransform.after.mir
index 349cfa89838de..d8fdb446135b3 100644
--- a/tests/mir-opt/building/coroutine.main-{closure#0}.StateTransform.after.mir
+++ b/tests/mir-opt/building/coroutine.main-{closure#0}.StateTransform.after.mir
@@ -4,7 +4,7 @@
         _s0: CoroutineSavedTy {
             ty: std::string::String,
             source_info: SourceInfo {
-                span: $DIR/coroutine.rs:17:32: 17:35 (#0),
+                span: $DIR/coroutine.rs:18:6: 18:9 (#0),
                 scope: scope[0],
             },
             ignore_for_traits: false,
@@ -22,8 +22,8 @@
     },
 } */
 
-fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:17:31: 17:44}>, _2: String) -> CoroutineState<(&str, String, &Location<'_>), ()> {
-    debug arg => (((*(_1.0: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44})) as variant#4).0: std::string::String);
+fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:18:5: 18:18}>, _2: String) -> CoroutineState<(&str, String, &Location<'_>), ()> {
+    debug arg => (((*(_1.0: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18})) as variant#4).0: std::string::String);
     let mut _0: std::ops::CoroutineState<(&str, std::string::String, &std::panic::Location<'_>), ()>;
     let _3: std::string::String;
     let mut _4: (&str, std::string::String, &std::panic::Location<'_>);
@@ -39,32 +39,31 @@ fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:17:31: 17:44}>, _
     let mut _14: &std::panic::Location<'_>;
     let _15: &std::panic::Location<'_>;
     let mut _16: ();
-    let _17: std::string::String;
-    let mut _18: u32;
-    let mut _19: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44};
-    let mut _20: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44};
-    let mut _21: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44};
-    let mut _22: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44};
-    let mut _23: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44};
-    let mut _24: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44};
-    let mut _25: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44};
-    let mut _26: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44};
+    let mut _17: u32;
+    let mut _18: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18};
+    let mut _19: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18};
+    let mut _20: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18};
+    let mut _21: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18};
+    let mut _22: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18};
+    let mut _23: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18};
+    let mut _24: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18};
+    let mut _25: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18};
 
     bb0: {
-        _19 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44});
-        _18 = discriminant((*_19));
-        switchInt(move _18) -> [0: bb1, 1: bb19, 3: bb17, 4: bb18, otherwise: bb20];
+        _18 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18});
+        _17 = discriminant((*_18));
+        switchInt(move _17) -> [0: bb1, 1: bb19, 3: bb17, 4: bb18, otherwise: bb20];
     }
 
     bb1: {
-        _20 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44});
-        (((*_20) as variant#4).0: std::string::String) = move _2;
+        _19 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18});
+        (((*_19) as variant#4).0: std::string::String) = move _2;
         StorageLive(_3);
         StorageLive(_4);
         StorageLive(_5);
         StorageLive(_6);
-        _21 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44});
-        _6 = &(((*_21) as variant#4).0: std::string::String);
+        _20 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18});
+        _6 = &(((*_20) as variant#4).0: std::string::String);
         _5 = <String as Clone>::clone(move _6) -> [return: bb2, unwind unreachable];
     }
 
@@ -85,8 +84,8 @@ fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:17:31: 17:44}>, _
         _0 = CoroutineState::<(&str, String, &Location<'_>), ()>::Yielded(move _4);
         StorageDead(_3);
         StorageDead(_4);
-        _22 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44});
-        discriminant((*_22)) = 3;
+        _21 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18});
+        discriminant((*_21)) = 3;
         return;
     }
 
@@ -109,8 +108,8 @@ fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:17:31: 17:44}>, _
         _10 = &(*_11);
         StorageLive(_12);
         StorageLive(_13);
-        _23 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44});
-        _13 = &(((*_23) as variant#4).0: std::string::String);
+        _22 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18});
+        _13 = &(((*_22) as variant#4).0: std::string::String);
         _12 = <String as Clone>::clone(move _13) -> [return: bb8, unwind unreachable];
     }
 
@@ -136,8 +135,8 @@ fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:17:31: 17:44}>, _
         StorageDead(_9);
         StorageDead(_11);
         StorageDead(_15);
-        _24 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44});
-        discriminant((*_24)) = 4;
+        _23 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18});
+        discriminant((*_23)) = 4;
         return;
     }
 
@@ -155,8 +154,8 @@ fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:17:31: 17:44}>, _
         StorageDead(_11);
         StorageDead(_8);
         _16 = const ();
-        _25 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44});
-        drop((((*_25) as variant#4).0: std::string::String)) -> [return: bb14, unwind unreachable];
+        _24 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18});
+        drop((((*_24) as variant#4).0: std::string::String)) -> [return: bb14, unwind unreachable];
     }
 
     bb14: {
@@ -165,8 +164,8 @@ fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:17:31: 17:44}>, _
 
     bb15: {
         _0 = CoroutineState::<(&str, String, &Location<'_>), ()>::Complete(move _16);
-        _26 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:17:31: 17:44});
-        discriminant((*_26)) = 1;
+        _25 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18});
+        discriminant((*_25)) = 1;
         return;
     }
 
diff --git a/tests/mir-opt/building/coroutine.main-{closure#1}.StateTransform.after.mir b/tests/mir-opt/building/coroutine.main-{closure#1}.StateTransform.after.mir
index dd8fb41896361..dd17afad656b8 100644
--- a/tests/mir-opt/building/coroutine.main-{closure#1}.StateTransform.after.mir
+++ b/tests/mir-opt/building/coroutine.main-{closure#1}.StateTransform.after.mir
@@ -4,7 +4,7 @@
         _s0: CoroutineSavedTy {
             ty: std::string::String,
             source_info: SourceInfo {
-                span: $DIR/coroutine.rs:22:54: 22:57 (#0),
+                span: $DIR/coroutine.rs:25:6: 25:9 (#0),
                 scope: scope[0],
             },
             ignore_for_traits: false,
@@ -22,8 +22,8 @@
     },
 } */
 
-fn main::{closure#1}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:22:53: 22:66}>, _2: String) -> CoroutineState<(&str, String, &Location<'_>), ()> {
-    debug arg => (((*(_1.0: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66})) as variant#4).0: std::string::String);
+fn main::{closure#1}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:25:5: 25:18}>, _2: String) -> CoroutineState<(&str, String, &Location<'_>), ()> {
+    debug arg => (((*(_1.0: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18})) as variant#4).0: std::string::String);
     let mut _0: std::ops::CoroutineState<(&str, std::string::String, &std::panic::Location<'_>), ()>;
     let _3: std::string::String;
     let mut _4: (&str, std::string::String, &std::panic::Location<'_>);
@@ -39,32 +39,31 @@ fn main::{closure#1}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:22:53: 22:66}>, _
     let mut _14: &std::panic::Location<'_>;
     let _15: &std::panic::Location<'_>;
     let mut _16: ();
-    let _17: std::string::String;
-    let mut _18: u32;
-    let mut _19: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66};
-    let mut _20: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66};
-    let mut _21: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66};
-    let mut _22: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66};
-    let mut _23: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66};
-    let mut _24: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66};
-    let mut _25: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66};
-    let mut _26: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66};
+    let mut _17: u32;
+    let mut _18: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18};
+    let mut _19: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18};
+    let mut _20: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18};
+    let mut _21: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18};
+    let mut _22: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18};
+    let mut _23: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18};
+    let mut _24: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18};
+    let mut _25: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18};
 
     bb0: {
-        _19 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66});
-        _18 = discriminant((*_19));
-        switchInt(move _18) -> [0: bb1, 1: bb19, 3: bb17, 4: bb18, otherwise: bb20];
+        _18 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18});
+        _17 = discriminant((*_18));
+        switchInt(move _17) -> [0: bb1, 1: bb19, 3: bb17, 4: bb18, otherwise: bb20];
     }
 
     bb1: {
-        _20 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66});
-        (((*_20) as variant#4).0: std::string::String) = move _2;
+        _19 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18});
+        (((*_19) as variant#4).0: std::string::String) = move _2;
         StorageLive(_3);
         StorageLive(_4);
         StorageLive(_5);
         StorageLive(_6);
-        _21 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66});
-        _6 = &(((*_21) as variant#4).0: std::string::String);
+        _20 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18});
+        _6 = &(((*_20) as variant#4).0: std::string::String);
         _5 = <String as Clone>::clone(move _6) -> [return: bb2, unwind unreachable];
     }
 
@@ -85,8 +84,8 @@ fn main::{closure#1}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:22:53: 22:66}>, _
         _0 = CoroutineState::<(&str, String, &Location<'_>), ()>::Yielded(move _4);
         StorageDead(_3);
         StorageDead(_4);
-        _22 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66});
-        discriminant((*_22)) = 3;
+        _21 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18});
+        discriminant((*_21)) = 3;
         return;
     }
 
@@ -109,8 +108,8 @@ fn main::{closure#1}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:22:53: 22:66}>, _
         _10 = &(*_11);
         StorageLive(_12);
         StorageLive(_13);
-        _23 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66});
-        _13 = &(((*_23) as variant#4).0: std::string::String);
+        _22 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18});
+        _13 = &(((*_22) as variant#4).0: std::string::String);
         _12 = <String as Clone>::clone(move _13) -> [return: bb8, unwind unreachable];
     }
 
@@ -136,8 +135,8 @@ fn main::{closure#1}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:22:53: 22:66}>, _
         StorageDead(_9);
         StorageDead(_11);
         StorageDead(_15);
-        _24 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66});
-        discriminant((*_24)) = 4;
+        _23 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18});
+        discriminant((*_23)) = 4;
         return;
     }
 
@@ -155,8 +154,8 @@ fn main::{closure#1}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:22:53: 22:66}>, _
         StorageDead(_11);
         StorageDead(_8);
         _16 = const ();
-        _25 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66});
-        drop((((*_25) as variant#4).0: std::string::String)) -> [return: bb14, unwind unreachable];
+        _24 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18});
+        drop((((*_24) as variant#4).0: std::string::String)) -> [return: bb14, unwind unreachable];
     }
 
     bb14: {
@@ -165,8 +164,8 @@ fn main::{closure#1}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:22:53: 22:66}>, _
 
     bb15: {
         _0 = CoroutineState::<(&str, String, &Location<'_>), ()>::Complete(move _16);
-        _26 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:22:53: 22:66});
-        discriminant((*_26)) = 1;
+        _25 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18});
+        discriminant((*_25)) = 1;
         return;
     }
 
diff --git a/tests/mir-opt/building/coroutine.rs b/tests/mir-opt/building/coroutine.rs
index 4b3310f7dd8bf..6d50c4d90b1a4 100644
--- a/tests/mir-opt/building/coroutine.rs
+++ b/tests/mir-opt/building/coroutine.rs
@@ -8,18 +8,21 @@
 #![feature(coroutines)]
 
 use std::ops::{Coroutine, CoroutineState};
-use std::pin::Pin;
 use std::panic::Location;
+use std::pin::Pin;
 
 // EMIT_MIR coroutine.main-{closure#0}.StateTransform.after.mir
 // EMIT_MIR coroutine.main-{closure#1}.StateTransform.after.mir
 fn main() {
-    let simple = #[coroutine] |arg: String| {
+    let simple = #[coroutine]
+    |arg: String| {
         yield ("first", arg.clone(), Location::caller());
         yield ("second", arg.clone(), Location::caller());
     };
 
-    let track_caller = #[track_caller] #[coroutine] |arg: String| {
+    let track_caller = #[track_caller]
+    #[coroutine]
+    |arg: String| {
         yield ("first", arg.clone(), Location::caller());
         yield ("second", arg.clone(), Location::caller());
     };
diff --git a/tests/mir-opt/coroutine_drop_cleanup.main-{closure#0}.coroutine_drop.0.panic-abort.mir b/tests/mir-opt/coroutine_drop_cleanup.main-{closure#0}.coroutine_drop.0.panic-abort.mir
index 7e033916fd348..33fbca7f77ed1 100644
--- a/tests/mir-opt/coroutine_drop_cleanup.main-{closure#0}.coroutine_drop.0.panic-abort.mir
+++ b/tests/mir-opt/coroutine_drop_cleanup.main-{closure#0}.coroutine_drop.0.panic-abort.mir
@@ -7,15 +7,14 @@ fn main::{closure#0}(_1: *mut {coroutine@$DIR/coroutine_drop_cleanup.rs:12:5: 12
     let _4: ();
     let mut _5: ();
     let mut _6: ();
-    let mut _7: ();
-    let mut _8: u32;
+    let mut _7: u32;
     scope 1 {
         debug _s => (((*_1) as variant#3).0: std::string::String);
     }
 
     bb0: {
-        _8 = discriminant((*_1));
-        switchInt(move _8) -> [0: bb5, 3: bb8, otherwise: bb9];
+        _7 = discriminant((*_1));
+        switchInt(move _7) -> [0: bb5, 3: bb8, otherwise: bb9];
     }
 
     bb1: {
diff --git a/tests/mir-opt/coroutine_drop_cleanup.main-{closure#0}.coroutine_drop.0.panic-unwind.mir b/tests/mir-opt/coroutine_drop_cleanup.main-{closure#0}.coroutine_drop.0.panic-unwind.mir
index 613ef2909b5e4..69e7219af9ff8 100644
--- a/tests/mir-opt/coroutine_drop_cleanup.main-{closure#0}.coroutine_drop.0.panic-unwind.mir
+++ b/tests/mir-opt/coroutine_drop_cleanup.main-{closure#0}.coroutine_drop.0.panic-unwind.mir
@@ -7,15 +7,14 @@ fn main::{closure#0}(_1: *mut {coroutine@$DIR/coroutine_drop_cleanup.rs:12:5: 12
     let _4: ();
     let mut _5: ();
     let mut _6: ();
-    let mut _7: ();
-    let mut _8: u32;
+    let mut _7: u32;
     scope 1 {
         debug _s => (((*_1) as variant#3).0: std::string::String);
     }
 
     bb0: {
-        _8 = discriminant((*_1));
-        switchInt(move _8) -> [0: bb7, 3: bb10, otherwise: bb11];
+        _7 = discriminant((*_1));
+        switchInt(move _7) -> [0: bb7, 3: bb10, otherwise: bb11];
     }
 
     bb1: {
diff --git a/tests/mir-opt/coroutine_tiny.main-{closure#0}.coroutine_resume.0.mir b/tests/mir-opt/coroutine_tiny.main-{closure#0}.coroutine_resume.0.mir
index 83159b5055acc..9905cc3e00f99 100644
--- a/tests/mir-opt/coroutine_tiny.main-{closure#0}.coroutine_resume.0.mir
+++ b/tests/mir-opt/coroutine_tiny.main-{closure#0}.coroutine_resume.0.mir
@@ -22,7 +22,7 @@
 } */
 
 fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine_tiny.rs:21:5: 21:13}>, _2: u8) -> CoroutineState<(), ()> {
-    debug _x => _10;
+    debug _x => _2;
     let mut _0: std::ops::CoroutineState<(), ()>;
     let _3: HasDrop;
     let mut _4: !;
@@ -31,19 +31,17 @@ fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine_tiny.rs:21:5: 21:13}
     let mut _7: ();
     let _8: ();
     let mut _9: ();
-    let _10: u8;
-    let mut _11: u32;
+    let mut _10: u32;
     scope 1 {
         debug _d => (((*(_1.0: &mut {coroutine@$DIR/coroutine_tiny.rs:21:5: 21:13})) as variant#3).0: HasDrop);
     }
 
     bb0: {
-        _11 = discriminant((*(_1.0: &mut {coroutine@$DIR/coroutine_tiny.rs:21:5: 21:13})));
-        switchInt(move _11) -> [0: bb1, 3: bb5, otherwise: bb6];
+        _10 = discriminant((*(_1.0: &mut {coroutine@$DIR/coroutine_tiny.rs:21:5: 21:13})));
+        switchInt(move _10) -> [0: bb1, 3: bb5, otherwise: bb6];
     }
 
     bb1: {
-        _10 = move _2;
         nop;
         (((*(_1.0: &mut {coroutine@$DIR/coroutine_tiny.rs:21:5: 21:13})) as variant#3).0: HasDrop) = HasDrop;
         StorageLive(_4);
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 22e6ea722ddaf..2ae86e2eb8bbd 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
@@ -39,8 +39,8 @@
 +                 let mut _28: &mut std::task::Context<'_>;
 +                 let mut _29: ();
 +                 let mut _30: ();
-+                 let mut _31: &mut std::task::Context<'_>;
-+                 let mut _32: u32;
++                 let mut _31: u32;
++                 let mut _32: &mut {async fn body of ActionPermit<'_, T>::perform()};
 +                 let mut _33: &mut {async fn body of ActionPermit<'_, T>::perform()};
 +                 let mut _34: &mut {async fn body of ActionPermit<'_, T>::perform()};
 +                 let mut _35: &mut {async fn body of ActionPermit<'_, T>::perform()};
@@ -48,7 +48,6 @@
 +                 let mut _37: &mut {async fn body of ActionPermit<'_, T>::perform()};
 +                 let mut _38: &mut {async fn body of ActionPermit<'_, T>::perform()};
 +                 let mut _39: &mut {async fn body of ActionPermit<'_, T>::perform()};
-+                 let mut _40: &mut {async fn body of ActionPermit<'_, T>::perform()};
 +                 scope 7 {
 +                     let mut _15: std::future::Ready<()>;
 +                     scope 8 {
@@ -58,14 +57,14 @@
 +                         scope 12 (inlined Pin::<&mut std::future::Ready<()>>::new_unchecked) {
 +                         }
 +                         scope 13 (inlined <std::future::Ready<()> as Future>::poll) {
-+                             let mut _42: ();
-+                             let mut _43: std::option::Option<()>;
-+                             let mut _44: &mut std::option::Option<()>;
-+                             let mut _45: &mut std::future::Ready<()>;
-+                             let mut _46: &mut std::pin::Pin<&mut std::future::Ready<()>>;
++                             let mut _41: ();
++                             let mut _42: std::option::Option<()>;
++                             let mut _43: &mut std::option::Option<()>;
++                             let mut _44: &mut std::future::Ready<()>;
++                             let mut _45: &mut std::pin::Pin<&mut std::future::Ready<()>>;
 +                             scope 14 (inlined <Pin<&mut std::future::Ready<()>> as DerefMut>::deref_mut) {
 +                                 scope 15 (inlined Pin::<&mut std::future::Ready<()>>::as_mut) {
-+                                     let mut _47: &mut &mut std::future::Ready<()>;
++                                     let mut _46: &mut &mut std::future::Ready<()>;
 +                                     scope 16 (inlined Pin::<&mut std::future::Ready<()>>::new_unchecked) {
 +                                     }
 +                                     scope 18 (inlined <&mut std::future::Ready<()> as DerefMut>::deref_mut) {
@@ -75,22 +74,22 @@
 +                                 }
 +                             }
 +                             scope 19 (inlined Option::<()>::take) {
-+                                 let mut _48: std::option::Option<()>;
++                                 let mut _47: std::option::Option<()>;
 +                                 scope 20 (inlined std::mem::replace::<Option<()>>) {
 +                                     scope 21 {
 +                                     }
 +                                 }
 +                             }
 +                             scope 22 (inlined #[track_caller] Option::<()>::expect) {
-+                                 let mut _49: isize;
-+                                 let mut _50: !;
++                                 let mut _48: isize;
++                                 let mut _49: !;
 +                                 scope 23 {
 +                                 }
 +                             }
 +                         }
 +                     }
 +                     scope 10 (inlined ready::<()>) {
-+                         let mut _41: std::option::Option<()>;
++                         let mut _40: std::option::Option<()>;
 +                     }
 +                     scope 11 (inlined <std::future::Ready<()> as IntoFuture>::into_future) {
 +                     }
@@ -145,10 +144,9 @@
 +         StorageLive(_37);
 +         StorageLive(_38);
 +         StorageLive(_39);
-+         StorageLive(_40);
-+         _33 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
-+         _32 = discriminant((*_33));
-+         switchInt(move _32) -> [0: bb3, 1: bb10, 3: bb9, otherwise: bb5];
++         _32 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         _31 = discriminant((*_32));
++         switchInt(move _31) -> [0: bb3, 1: bb10, 3: bb9, otherwise: bb5];
       }
   
 -     bb3: {
@@ -158,7 +156,6 @@
 +     }
 + 
 +     bb2: {
-+         StorageDead(_40);
 +         StorageDead(_39);
 +         StorageDead(_38);
 +         StorageDead(_37);
@@ -186,23 +183,22 @@
       }
   
 +     bb3: {
-+         _31 = move _9;
++         _33 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
 +         _34 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
-+         _35 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
-+         (((*_34) as variant#3).0: ActionPermit<'_, T>) = move ((*_35).0: ActionPermit<'_, T>);
++         (((*_33) as variant#3).0: ActionPermit<'_, T>) = move ((*_34).0: ActionPermit<'_, T>);
 +         StorageLive(_12);
 +         StorageLive(_13);
 +         StorageLive(_14);
 +         _14 = ();
-+         StorageLive(_41);
-+         _41 = Option::<()>::Some(copy _14);
-+         _13 = std::future::Ready::<()>(move _41);
-+         StorageDead(_41);
++         StorageLive(_40);
++         _40 = Option::<()>::Some(copy _14);
++         _13 = std::future::Ready::<()>(move _40);
++         StorageDead(_40);
 +         StorageDead(_14);
 +         _12 = move _13;
 +         StorageDead(_13);
-+         _36 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
-+         (((*_36) as variant#3).1: std::future::Ready<()>) = move _12;
++         _35 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         (((*_35) as variant#3).1: std::future::Ready<()>) = move _12;
 +         goto -> bb4;
 +     }
 + 
@@ -214,39 +210,39 @@
 +         StorageLive(_19);
 +         StorageLive(_20);
 +         StorageLive(_21);
-+         _37 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
-+         _21 = &mut (((*_37) as variant#3).1: std::future::Ready<()>);
++         _36 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         _21 = &mut (((*_36) as variant#3).1: std::future::Ready<()>);
 +         _20 = &mut (*_21);
 +         _19 = Pin::<&mut std::future::Ready<()>> { pointer: copy _20 };
 +         StorageDead(_20);
 +         StorageLive(_22);
 +         StorageLive(_23);
 +         StorageLive(_24);
-+         _24 = copy _31;
++         _24 = copy _9;
 +         _23 = move _24;
 +         _22 = &mut (*_23);
 +         StorageDead(_24);
++         StorageLive(_44);
 +         StorageLive(_45);
-+         StorageLive(_46);
-+         StorageLive(_50);
++         StorageLive(_49);
++         StorageLive(_41);
 +         StorageLive(_42);
 +         StorageLive(_43);
-+         StorageLive(_44);
-+         _46 = &mut _19;
++         _45 = &mut _19;
++         StorageLive(_46);
++         _46 = &mut (_19.0: &mut std::future::Ready<()>);
++         _44 = copy (_19.0: &mut std::future::Ready<()>);
++         StorageDead(_46);
++         _43 = &mut ((*_44).0: std::option::Option<()>);
 +         StorageLive(_47);
-+         _47 = &mut (_19.0: &mut std::future::Ready<()>);
-+         _45 = copy (_19.0: &mut std::future::Ready<()>);
++         _47 = Option::<()>::None;
++         _42 = copy ((*_44).0: std::option::Option<()>);
++         ((*_44).0: std::option::Option<()>) = copy _47;
 +         StorageDead(_47);
-+         _44 = &mut ((*_45).0: std::option::Option<()>);
++         StorageDead(_43);
 +         StorageLive(_48);
-+         _48 = Option::<()>::None;
-+         _43 = copy ((*_45).0: std::option::Option<()>);
-+         ((*_45).0: std::option::Option<()>) = copy _48;
-+         StorageDead(_48);
-+         StorageDead(_44);
-+         StorageLive(_49);
-+         _49 = discriminant(_43);
-+         switchInt(move _49) -> [0: bb11, 1: bb12, otherwise: bb5];
++         _48 = discriminant(_42);
++         switchInt(move _48) -> [0: bb11, 1: bb12, otherwise: bb5];
       }
 + 
 +     bb5: {
@@ -266,8 +262,8 @@
 +         StorageDead(_12);
 +         StorageDead(_28);
 +         StorageDead(_29);
-+         _38 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
-+         discriminant((*_38)) = 3;
++         _37 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         discriminant((*_37)) = 3;
 +         goto -> bb2;
 +     }
 + 
@@ -281,14 +277,14 @@
 +         StorageDead(_18);
 +         StorageDead(_17);
 +         StorageDead(_12);
-+         _39 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
-+         drop((((*_39) as variant#3).0: ActionPermit<'_, T>)) -> [return: bb8, unwind unreachable];
++         _38 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         drop((((*_38) as variant#3).0: ActionPermit<'_, T>)) -> [return: bb8, unwind unreachable];
 +     }
 + 
 +     bb8: {
 +         _7 = Poll::<()>::Ready(move _30);
-+         _40 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
-+         discriminant((*_40)) = 1;
++         _39 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         discriminant((*_39)) = 1;
 +         goto -> bb2;
 +     }
 + 
@@ -298,7 +294,7 @@
 +         StorageLive(_29);
 +         _28 = move _9;
 +         StorageDead(_29);
-+         _31 = move _28;
++         _9 = move _28;
 +         StorageDead(_28);
 +         _16 = const ();
 +         goto -> bb4;
@@ -309,18 +305,18 @@
 +     }
 + 
 +     bb11: {
-+         _50 = option::expect_failed(const "`Ready` polled after completion") -> unwind unreachable;
++         _49 = option::expect_failed(const "`Ready` polled after completion") -> unwind unreachable;
 +     }
 + 
 +     bb12: {
-+         _42 = move ((_43 as Some).0: ());
-+         StorageDead(_49);
-+         StorageDead(_43);
-+         _18 = Poll::<()>::Ready(move _42);
++         _41 = move ((_42 as Some).0: ());
++         StorageDead(_48);
 +         StorageDead(_42);
-+         StorageDead(_50);
-+         StorageDead(_46);
++         _18 = Poll::<()>::Ready(move _41);
++         StorageDead(_41);
++         StorageDead(_49);
 +         StorageDead(_45);
++         StorageDead(_44);
 +         StorageDead(_22);
 +         StorageDead(_19);
 +         _25 = discriminant(_18);
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 8b027e988b8e8..d7ae931aaae58 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
@@ -39,8 +39,8 @@
 +                 let mut _28: &mut std::task::Context<'_>;
 +                 let mut _29: ();
 +                 let mut _30: ();
-+                 let mut _31: &mut std::task::Context<'_>;
-+                 let mut _32: u32;
++                 let mut _31: u32;
++                 let mut _32: &mut {async fn body of ActionPermit<'_, T>::perform()};
 +                 let mut _33: &mut {async fn body of ActionPermit<'_, T>::perform()};
 +                 let mut _34: &mut {async fn body of ActionPermit<'_, T>::perform()};
 +                 let mut _35: &mut {async fn body of ActionPermit<'_, T>::perform()};
@@ -50,7 +50,6 @@
 +                 let mut _39: &mut {async fn body of ActionPermit<'_, T>::perform()};
 +                 let mut _40: &mut {async fn body of ActionPermit<'_, T>::perform()};
 +                 let mut _41: &mut {async fn body of ActionPermit<'_, T>::perform()};
-+                 let mut _42: &mut {async fn body of ActionPermit<'_, T>::perform()};
 +                 scope 7 {
 +                     let mut _15: std::future::Ready<()>;
 +                     scope 8 {
@@ -60,14 +59,14 @@
 +                         scope 12 (inlined Pin::<&mut std::future::Ready<()>>::new_unchecked) {
 +                         }
 +                         scope 13 (inlined <std::future::Ready<()> as Future>::poll) {
-+                             let mut _44: ();
-+                             let mut _45: std::option::Option<()>;
-+                             let mut _46: &mut std::option::Option<()>;
-+                             let mut _47: &mut std::future::Ready<()>;
-+                             let mut _48: &mut std::pin::Pin<&mut std::future::Ready<()>>;
++                             let mut _43: ();
++                             let mut _44: std::option::Option<()>;
++                             let mut _45: &mut std::option::Option<()>;
++                             let mut _46: &mut std::future::Ready<()>;
++                             let mut _47: &mut std::pin::Pin<&mut std::future::Ready<()>>;
 +                             scope 14 (inlined <Pin<&mut std::future::Ready<()>> as DerefMut>::deref_mut) {
 +                                 scope 15 (inlined Pin::<&mut std::future::Ready<()>>::as_mut) {
-+                                     let mut _49: &mut &mut std::future::Ready<()>;
++                                     let mut _48: &mut &mut std::future::Ready<()>;
 +                                     scope 16 (inlined Pin::<&mut std::future::Ready<()>>::new_unchecked) {
 +                                     }
 +                                     scope 18 (inlined <&mut std::future::Ready<()> as DerefMut>::deref_mut) {
@@ -77,22 +76,22 @@
 +                                 }
 +                             }
 +                             scope 19 (inlined Option::<()>::take) {
-+                                 let mut _50: std::option::Option<()>;
++                                 let mut _49: std::option::Option<()>;
 +                                 scope 20 (inlined std::mem::replace::<Option<()>>) {
 +                                     scope 21 {
 +                                     }
 +                                 }
 +                             }
 +                             scope 22 (inlined #[track_caller] Option::<()>::expect) {
-+                                 let mut _51: isize;
-+                                 let mut _52: !;
++                                 let mut _50: isize;
++                                 let mut _51: !;
 +                                 scope 23 {
 +                                 }
 +                             }
 +                         }
 +                     }
 +                     scope 10 (inlined ready::<()>) {
-+                         let mut _43: std::option::Option<()>;
++                         let mut _42: std::option::Option<()>;
 +                     }
 +                     scope 11 (inlined <std::future::Ready<()> as IntoFuture>::into_future) {
 +                     }
@@ -149,10 +148,9 @@
 +         StorageLive(_39);
 +         StorageLive(_40);
 +         StorageLive(_41);
-+         StorageLive(_42);
-+         _33 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
-+         _32 = discriminant((*_33));
-+         switchInt(move _32) -> [0: bb5, 1: bb15, 2: bb14, 3: bb13, otherwise: bb7];
++         _32 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         _31 = discriminant((*_32));
++         switchInt(move _31) -> [0: bb5, 1: bb15, 2: bb14, 3: bb13, otherwise: bb7];
       }
   
 -     bb3: {
@@ -170,7 +168,6 @@
 +     }
 + 
 +     bb4: {
-+         StorageDead(_42);
 +         StorageDead(_41);
 +         StorageDead(_40);
 +         StorageDead(_39);
@@ -203,23 +200,22 @@
 -         StorageDead(_2);
 -         return;
 +     bb5: {
-+         _31 = move _9;
++         _33 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
 +         _34 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
-+         _35 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
-+         (((*_34) as variant#3).0: ActionPermit<'_, T>) = move ((*_35).0: ActionPermit<'_, T>);
++         (((*_33) as variant#3).0: ActionPermit<'_, T>) = move ((*_34).0: ActionPermit<'_, T>);
 +         StorageLive(_12);
 +         StorageLive(_13);
 +         StorageLive(_14);
 +         _14 = ();
-+         StorageLive(_43);
-+         _43 = Option::<()>::Some(copy _14);
-+         _13 = std::future::Ready::<()>(move _43);
-+         StorageDead(_43);
++         StorageLive(_42);
++         _42 = Option::<()>::Some(copy _14);
++         _13 = std::future::Ready::<()>(move _42);
++         StorageDead(_42);
 +         StorageDead(_14);
 +         _12 = move _13;
 +         StorageDead(_13);
-+         _36 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
-+         (((*_36) as variant#3).1: std::future::Ready<()>) = move _12;
++         _35 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         (((*_35) as variant#3).1: std::future::Ready<()>) = move _12;
 +         goto -> bb6;
       }
   
@@ -231,39 +227,39 @@
 +         StorageLive(_19);
 +         StorageLive(_20);
 +         StorageLive(_21);
-+         _37 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
-+         _21 = &mut (((*_37) as variant#3).1: std::future::Ready<()>);
++         _36 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         _21 = &mut (((*_36) as variant#3).1: std::future::Ready<()>);
 +         _20 = &mut (*_21);
 +         _19 = Pin::<&mut std::future::Ready<()>> { pointer: copy _20 };
 +         StorageDead(_20);
 +         StorageLive(_22);
 +         StorageLive(_23);
 +         StorageLive(_24);
-+         _24 = copy _31;
++         _24 = copy _9;
 +         _23 = move _24;
 +         _22 = &mut (*_23);
 +         StorageDead(_24);
++         StorageLive(_46);
 +         StorageLive(_47);
-+         StorageLive(_48);
-+         StorageLive(_52);
++         StorageLive(_51);
++         StorageLive(_43);
 +         StorageLive(_44);
 +         StorageLive(_45);
-+         StorageLive(_46);
-+         _48 = &mut _19;
++         _47 = &mut _19;
++         StorageLive(_48);
++         _48 = &mut (_19.0: &mut std::future::Ready<()>);
++         _46 = copy (_19.0: &mut std::future::Ready<()>);
++         StorageDead(_48);
++         _45 = &mut ((*_46).0: std::option::Option<()>);
 +         StorageLive(_49);
-+         _49 = &mut (_19.0: &mut std::future::Ready<()>);
-+         _47 = copy (_19.0: &mut std::future::Ready<()>);
++         _49 = Option::<()>::None;
++         _44 = copy ((*_46).0: std::option::Option<()>);
++         ((*_46).0: std::option::Option<()>) = copy _49;
 +         StorageDead(_49);
-+         _46 = &mut ((*_47).0: std::option::Option<()>);
++         StorageDead(_45);
 +         StorageLive(_50);
-+         _50 = Option::<()>::None;
-+         _45 = copy ((*_47).0: std::option::Option<()>);
-+         ((*_47).0: std::option::Option<()>) = copy _50;
-+         StorageDead(_50);
-+         StorageDead(_46);
-+         StorageLive(_51);
-+         _51 = discriminant(_45);
-+         switchInt(move _51) -> [0: bb16, 1: bb17, otherwise: bb7];
++         _50 = discriminant(_44);
++         switchInt(move _50) -> [0: bb16, 1: bb17, otherwise: bb7];
       }
   
 -     bb6 (cleanup): {
@@ -285,8 +281,8 @@
 +         StorageDead(_12);
 +         StorageDead(_28);
 +         StorageDead(_29);
-+         _38 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
-+         discriminant((*_38)) = 3;
++         _37 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         discriminant((*_37)) = 3;
 +         goto -> bb4;
 +     }
 + 
@@ -300,14 +296,14 @@
 +         StorageDead(_18);
 +         StorageDead(_17);
 +         StorageDead(_12);
-+         _39 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
-+         drop((((*_39) as variant#3).0: ActionPermit<'_, T>)) -> [return: bb10, unwind: bb12];
++         _38 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         drop((((*_38) as variant#3).0: ActionPermit<'_, T>)) -> [return: bb10, unwind: bb12];
 +     }
 + 
 +     bb10: {
 +         _7 = Poll::<()>::Ready(move _30);
-+         _40 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
-+         discriminant((*_40)) = 1;
++         _39 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         discriminant((*_39)) = 1;
 +         goto -> bb4;
 +     }
 + 
@@ -319,13 +315,13 @@
 +         StorageDead(_18);
 +         StorageDead(_17);
 +         StorageDead(_12);
-+         _41 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
-+         drop((((*_41) as variant#3).0: ActionPermit<'_, T>)) -> [return: bb12, unwind terminate(cleanup)];
++         _40 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         drop((((*_40) as variant#3).0: ActionPermit<'_, T>)) -> [return: bb12, unwind terminate(cleanup)];
 +     }
 + 
 +     bb12 (cleanup): {
-+         _42 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
-+         discriminant((*_42)) = 2;
++         _41 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         discriminant((*_41)) = 2;
 +         goto -> bb2;
 +     }
 + 
@@ -335,7 +331,7 @@
 +         StorageLive(_29);
 +         _28 = move _9;
 +         StorageDead(_29);
-+         _31 = move _28;
++         _9 = move _28;
 +         StorageDead(_28);
 +         _16 = const ();
 +         goto -> bb6;
@@ -350,18 +346,18 @@
 +     }
 + 
 +     bb16: {
-+         _52 = option::expect_failed(const "`Ready` polled after completion") -> bb11;
++         _51 = option::expect_failed(const "`Ready` polled after completion") -> bb11;
 +     }
 + 
 +     bb17: {
-+         _44 = move ((_45 as Some).0: ());
-+         StorageDead(_51);
-+         StorageDead(_45);
-+         _18 = Poll::<()>::Ready(move _44);
++         _43 = move ((_44 as Some).0: ());
++         StorageDead(_50);
 +         StorageDead(_44);
-+         StorageDead(_52);
-+         StorageDead(_48);
++         _18 = Poll::<()>::Ready(move _43);
++         StorageDead(_43);
++         StorageDead(_51);
 +         StorageDead(_47);
++         StorageDead(_46);
 +         StorageDead(_22);
 +         StorageDead(_19);
 +         _25 = discriminant(_18);

From eddd755f284093b0d3a8ce027f68653d5f5773d1 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Tue, 16 Sep 2025 22:58:54 +0000
Subject: [PATCH 1023/1889] Bless ui.

---
 .../ui/rustc_public-ir-print/async-closure.rs |  2 +-
 .../async-closure.stdout                      | 44 +++++++++----------
 2 files changed, 21 insertions(+), 25 deletions(-)

diff --git a/tests/ui/rustc_public-ir-print/async-closure.rs b/tests/ui/rustc_public-ir-print/async-closure.rs
index 80f96e09cfc78..bd8c7e888a37c 100644
--- a/tests/ui/rustc_public-ir-print/async-closure.rs
+++ b/tests/ui/rustc_public-ir-print/async-closure.rs
@@ -1,6 +1,6 @@
 //@ compile-flags: -Z unpretty=stable-mir --crate-type lib -C panic=abort -Zmir-opt-level=0
 //@ check-pass
-//@ only-x86_64
+//@ only-64bit
 //@ edition: 2024
 //@ needs-unwind unwind edges are different with panic=abort
 
diff --git a/tests/ui/rustc_public-ir-print/async-closure.stdout b/tests/ui/rustc_public-ir-print/async-closure.stdout
index 73e9b8fc097ab..5113dc5048b93 100644
--- a/tests/ui/rustc_public-ir-print/async-closure.stdout
+++ b/tests/ui/rustc_public-ir-print/async-closure.stdout
@@ -40,30 +40,28 @@ fn foo::{closure#0}::{closure#0}(_1: Pin<&mut {async closure body@$DIR/async-clo
     let  _3: i32;
     let mut _4: &i32;
     let mut _5: ();
-    let mut _6: &mut Context<'_>;
-    let mut _7: u32;
+    let mut _6: u32;
+    let mut _7: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6};
     let mut _8: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6};
     let mut _9: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6};
-    let mut _10: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6};
-    debug _task_context => _6;
+    debug _task_context => _2;
     debug y => (*((*(_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6})).0: &i32));
     debug y => _3;
     bb0: {
-        _8 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
-        _7 = discriminant((*_8));
-        switchInt(move _7) -> [0: bb1, 1: bb2, otherwise: bb3];
+        _7 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
+        _6 = discriminant((*_7));
+        switchInt(move _6) -> [0: bb1, 1: bb2, otherwise: bb3];
     }
     bb1: {
-        _6 = move _2;
         StorageLive(_3);
-        _9 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
-        _4 = CopyForDeref(((*_9).0: &i32));
+        _8 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
+        _4 = CopyForDeref(((*_8).0: &i32));
         _3 = (*_4);
         _5 = ();
         StorageDead(_3);
         _0 = std::task::Poll::Ready(move _5);
-        _10 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
-        discriminant((*_10)) = 1;
+        _9 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
+        discriminant((*_9)) = 1;
         return;
     }
     bb2: {
@@ -78,30 +76,28 @@ fn foo::{closure#0}::{synthetic#0}(_1: Pin<&mut {async closure body@$DIR/async-c
     let  _3: i32;
     let mut _4: &i32;
     let mut _5: ();
-    let mut _6: &mut Context<'_>;
-    let mut _7: u32;
+    let mut _6: u32;
+    let mut _7: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6};
     let mut _8: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6};
     let mut _9: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6};
-    let mut _10: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6};
-    debug _task_context => _6;
+    debug _task_context => _2;
     debug y => (*((*(_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6})).0: &i32));
     debug y => _3;
     bb0: {
-        _8 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
-        _7 = discriminant((*_8));
-        switchInt(move _7) -> [0: bb1, 1: bb2, otherwise: bb3];
+        _7 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
+        _6 = discriminant((*_7));
+        switchInt(move _6) -> [0: bb1, 1: bb2, otherwise: bb3];
     }
     bb1: {
-        _6 = move _2;
         StorageLive(_3);
-        _9 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
-        _4 = CopyForDeref(((*_9).0: &i32));
+        _8 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
+        _4 = CopyForDeref(((*_8).0: &i32));
         _3 = (*_4);
         _5 = ();
         StorageDead(_3);
         _0 = std::task::Poll::Ready(move _5);
-        _10 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
-        discriminant((*_10)) = 1;
+        _9 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
+        discriminant((*_9)) = 1;
         return;
     }
     bb2: {

From 541989611144cdf5f2b5d7340b4f579ec004c799 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 16 Sep 2025 17:32:37 +1000
Subject: [PATCH 1024/1889] Use `LLVMDIBuilderCreateSubroutineType`

---
 .../rustc_codegen_llvm/src/debuginfo/metadata.rs   | 14 +++++++++++---
 compiler/rustc_codegen_llvm/src/debuginfo/mod.rs   |  8 ++++----
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs        | 13 ++++++++-----
 compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp   |  7 -------
 4 files changed, 23 insertions(+), 19 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
index dc3a84b6a151a..db821b3dee716 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
@@ -318,7 +318,7 @@ fn build_subroutine_type_di_node<'ll, 'tcx>(
 
     debug_context(cx).type_map.unique_id_to_di_node.borrow_mut().remove(&unique_type_id);
 
-    let fn_di_node = create_subroutine_type(cx, create_DIArray(DIB(cx), &signature_di_nodes[..]));
+    let fn_di_node = create_subroutine_type(cx, &signature_di_nodes[..]);
 
     // This is actually a function pointer, so wrap it in pointer DI.
     let name = compute_debuginfo_type_name(cx.tcx, fn_ty, false);
@@ -346,9 +346,17 @@ fn build_subroutine_type_di_node<'ll, 'tcx>(
 
 pub(super) fn create_subroutine_type<'ll>(
     cx: &CodegenCx<'ll, '_>,
-    signature: &'ll DICompositeType,
+    signature: &[Option<&'ll llvm::Metadata>],
 ) -> &'ll DICompositeType {
-    unsafe { llvm::LLVMRustDIBuilderCreateSubroutineType(DIB(cx), signature) }
+    unsafe {
+        llvm::LLVMDIBuilderCreateSubroutineType(
+            DIB(cx),
+            None, // ("File" is ignored and has no effect)
+            signature.as_ptr(),
+            signature.len() as c_uint,
+            DIFlags::FlagZero, // (default value)
+        )
+    }
 }
 
 /// Create debuginfo for `dyn SomeTrait` types. Currently these are empty structs
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
index 79334f7f9fe84..126082aa3aa68 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
@@ -349,7 +349,7 @@ impl<'ll, 'tcx> DebugInfoCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         let file_metadata = file_metadata(self, &loc.file);
 
         let function_type_metadata =
-            create_subroutine_type(self, get_function_signature(self, fn_abi));
+            create_subroutine_type(self, &get_function_signature(self, fn_abi));
 
         let mut name = String::with_capacity(64);
         type_names::push_item_name(tcx, def_id, false, &mut name);
@@ -441,9 +441,9 @@ impl<'ll, 'tcx> DebugInfoCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         fn get_function_signature<'ll, 'tcx>(
             cx: &CodegenCx<'ll, 'tcx>,
             fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
-        ) -> &'ll DIArray {
+        ) -> Vec<Option<&'ll llvm::Metadata>> {
             if cx.sess().opts.debuginfo != DebugInfo::Full {
-                return create_DIArray(DIB(cx), &[]);
+                return vec![];
             }
 
             let mut signature = Vec::with_capacity(fn_abi.args.len() + 1);
@@ -484,7 +484,7 @@ impl<'ll, 'tcx> DebugInfoCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
                     .extend(fn_abi.args.iter().map(|arg| Some(type_di_node(cx, arg.layout.ty))));
             }
 
-            create_DIArray(DIB(cx), &signature[..])
+            signature
         }
 
         fn get_template_parameters<'ll, 'tcx>(
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 0679f55ab7f08..af0ec6a33b0d2 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -1870,6 +1870,14 @@ unsafe extern "C" {
         Scope: &'ll Metadata,
         InlinedAt: Option<&'ll Metadata>,
     ) -> &'ll Metadata;
+
+    pub(crate) fn LLVMDIBuilderCreateSubroutineType<'ll>(
+        Builder: &DIBuilder<'ll>,
+        File: Option<&'ll Metadata>, // (ignored and has no effect)
+        ParameterTypes: *const Option<&'ll Metadata>,
+        NumParameterTypes: c_uint,
+        Flags: DIFlags, // (default is `DIFlags::DIFlagZero`)
+    ) -> &'ll Metadata;
 }
 
 #[link(name = "llvm-wrapper", kind = "static")]
@@ -2172,11 +2180,6 @@ unsafe extern "C" {
         SourceLen: size_t,
     ) -> &'a DIFile;
 
-    pub(crate) fn LLVMRustDIBuilderCreateSubroutineType<'a>(
-        Builder: &DIBuilder<'a>,
-        ParameterTypes: &'a DIArray,
-    ) -> &'a DICompositeType;
-
     pub(crate) fn LLVMRustDIBuilderCreateFunction<'a>(
         Builder: &DIBuilder<'a>,
         Scope: &'a DIDescriptor,
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index 361a5f765510f..a1c3cce99202d 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -1026,13 +1026,6 @@ LLVMRustDIBuilderCreateFile(LLVMDIBuilderRef Builder, const char *Filename,
                                           CSInfo, oSource));
 }
 
-extern "C" LLVMMetadataRef
-LLVMRustDIBuilderCreateSubroutineType(LLVMDIBuilderRef Builder,
-                                      LLVMMetadataRef ParameterTypes) {
-  return wrap(unwrap(Builder)->createSubroutineType(
-      DITypeRefArray(unwrap<MDTuple>(ParameterTypes))));
-}
-
 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateFunction(
     LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
     size_t NameLen, const char *LinkageName, size_t LinkageNameLen,

From 2552deb9cd84b3bebaec98902d9d42bee2315822 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 16 Sep 2025 18:21:46 +1000
Subject: [PATCH 1025/1889] Use `LLVMDIBuilderCreateUnionType`

---
 .../src/debuginfo/metadata/type_map.rs        | 13 +++++---
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs   | 33 ++++++++++---------
 .../rustc_llvm/llvm-wrapper/RustWrapper.cpp   | 13 --------
 3 files changed, 25 insertions(+), 34 deletions(-)

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 18a783a348a45..af72d4ea3de0a 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata/type_map.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata/type_map.rs
@@ -1,5 +1,6 @@
 use std::cell::RefCell;
 
+use libc::c_uint;
 use rustc_abi::{Align, Size, VariantIdx};
 use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_data_structures::fx::FxHashMap;
@@ -191,6 +192,7 @@ pub(super) fn stub<'ll, 'tcx>(
     containing_scope: Option<&'ll DIScope>,
     flags: DIFlags,
 ) -> StubInfo<'ll, 'tcx> {
+    let no_elements: &[Option<&llvm::Metadata>] = &[];
     let empty_array = create_DIArray(DIB(cx), &[]);
     let unique_type_id_str = unique_type_id.generate_unique_id_string(cx.tcx);
 
@@ -227,19 +229,20 @@ pub(super) fn stub<'ll, 'tcx>(
             }
         }
         Stub::Union => unsafe {
-            llvm::LLVMRustDIBuilderCreateUnionType(
+            llvm::LLVMDIBuilderCreateUnionType(
                 DIB(cx),
                 containing_scope,
-                name.as_c_char_ptr(),
+                name.as_ptr(),
                 name.len(),
                 file_metadata,
                 line_number,
                 size.bits(),
                 align.bits() as u32,
                 flags,
-                Some(empty_array),
-                0,
-                unique_type_id_str.as_c_char_ptr(),
+                no_elements.as_ptr(),
+                no_elements.len() as c_uint,
+                0u32, // (Objective-C runtime version; default is 0)
+                unique_type_id_str.as_ptr(),
                 unique_type_id_str.len(),
             )
         },
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index af0ec6a33b0d2..58aebe4c391ec 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -1878,6 +1878,23 @@ unsafe extern "C" {
         NumParameterTypes: c_uint,
         Flags: DIFlags, // (default is `DIFlags::DIFlagZero`)
     ) -> &'ll Metadata;
+
+    pub(crate) fn LLVMDIBuilderCreateUnionType<'ll>(
+        Builder: &DIBuilder<'ll>,
+        Scope: Option<&'ll Metadata>,
+        Name: *const c_uchar, // See "PTR_LEN_STR".
+        NameLen: size_t,
+        File: &'ll Metadata,
+        LineNumber: c_uint,
+        SizeInBits: u64,
+        AlignInBits: u32,
+        Flags: DIFlags,
+        Elements: *const Option<&'ll Metadata>,
+        NumElements: c_uint,
+        RunTimeLang: c_uint, // (optional Objective-C runtime version; default is 0)
+        UniqueId: *const c_uchar, // See "PTR_LEN_STR".
+        UniqueIdLen: size_t,
+    ) -> &'ll Metadata;
 }
 
 #[link(name = "llvm-wrapper", kind = "static")]
@@ -2391,22 +2408,6 @@ unsafe extern "C" {
         IsScoped: bool,
     ) -> &'a DIType;
 
-    pub(crate) fn LLVMRustDIBuilderCreateUnionType<'a>(
-        Builder: &DIBuilder<'a>,
-        Scope: Option<&'a DIScope>,
-        Name: *const c_char,
-        NameLen: size_t,
-        File: &'a DIFile,
-        LineNumber: c_uint,
-        SizeInBits: u64,
-        AlignInBits: u32,
-        Flags: DIFlags,
-        Elements: Option<&'a DIArray>,
-        RunTimeLang: c_uint,
-        UniqueId: *const c_char,
-        UniqueIdLen: size_t,
-    ) -> &'a DIType;
-
     pub(crate) fn LLVMRustDIBuilderCreateVariantPart<'a>(
         Builder: &DIBuilder<'a>,
         Scope: &'a DIScope,
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index a1c3cce99202d..2cbfcf79c83d2 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -1268,19 +1268,6 @@ extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateEnumerationType(
       /* RunTimeLang */ 0, "", IsScoped));
 }
 
-extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateUnionType(
-    LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
-    size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
-    uint64_t SizeInBits, uint32_t AlignInBits, LLVMDIFlags Flags,
-    LLVMMetadataRef Elements, unsigned RunTimeLang, const char *UniqueId,
-    size_t UniqueIdLen) {
-  return wrap(unwrap(Builder)->createUnionType(
-      unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen),
-      unwrapDI<DIFile>(File), LineNumber, SizeInBits, AlignInBits,
-      fromRust(Flags), DINodeArray(unwrapDI<MDTuple>(Elements)), RunTimeLang,
-      StringRef(UniqueId, UniqueIdLen)));
-}
-
 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateTemplateTypeParameter(
     LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
     size_t NameLen, LLVMMetadataRef Ty) {

From bef8f646a632215c362ee45d88d2390e47e65d4c Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 16 Sep 2025 18:37:23 +1000
Subject: [PATCH 1026/1889] Use `LLVMDIBuilderCreateArrayType`

---
 .../src/debuginfo/metadata.rs                   | 14 ++++++--------
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs     | 17 +++++++++--------
 .../rustc_llvm/llvm-wrapper/RustWrapper.cpp     |  9 ---------
 3 files changed, 15 insertions(+), 25 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
index db821b3dee716..fcbfe6ca2242f 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
@@ -32,9 +32,7 @@ use self::type_map::{DINodeCreationResult, Stub, UniqueTypeId};
 use super::CodegenUnitDebugContext;
 use super::namespace::mangled_name_of_instance;
 use super::type_names::{compute_debuginfo_type_name, compute_debuginfo_vtable_name};
-use super::utils::{
-    DIB, create_DIArray, debug_context, get_namespace_for_item, is_node_local_to_unit,
-};
+use super::utils::{DIB, debug_context, get_namespace_for_item, is_node_local_to_unit};
 use crate::common::{AsCCharPtr, CodegenCx};
 use crate::debuginfo::dwarf_const;
 use crate::debuginfo::metadata::type_map::build_type_with_children;
@@ -119,17 +117,17 @@ fn build_fixed_size_array_di_node<'ll, 'tcx>(
         .try_to_target_usize(cx.tcx)
         .expect("expected monomorphic const in codegen") as c_longlong;
 
-    let subrange =
-        unsafe { Some(llvm::LLVMRustDIBuilderGetOrCreateSubrange(DIB(cx), 0, upper_bound)) };
+    let subrange = unsafe { llvm::LLVMRustDIBuilderGetOrCreateSubrange(DIB(cx), 0, upper_bound) };
+    let subscripts = &[subrange];
 
-    let subscripts = create_DIArray(DIB(cx), &[subrange]);
     let di_node = unsafe {
-        llvm::LLVMRustDIBuilderCreateArrayType(
+        llvm::LLVMDIBuilderCreateArrayType(
             DIB(cx),
             size.bits(),
             align.bits() as u32,
             element_type_di_node,
-            subscripts,
+            subscripts.as_ptr(),
+            subscripts.len() as c_uint,
         )
     };
 
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 58aebe4c391ec..e2426980c6ad0 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -1895,6 +1895,15 @@ unsafe extern "C" {
         UniqueId: *const c_uchar, // See "PTR_LEN_STR".
         UniqueIdLen: size_t,
     ) -> &'ll Metadata;
+
+    pub(crate) fn LLVMDIBuilderCreateArrayType<'ll>(
+        Builder: &DIBuilder<'ll>,
+        Size: u64,
+        Align: u32,
+        Ty: &'ll Metadata,
+        Subscripts: *const &'ll Metadata,
+        NumSubscripts: c_uint,
+    ) -> &'ll Metadata;
 }
 
 #[link(name = "llvm-wrapper", kind = "static")]
@@ -2355,14 +2364,6 @@ unsafe extern "C" {
         AlignInBits: u32,
     ) -> &'a DIVariable;
 
-    pub(crate) fn LLVMRustDIBuilderCreateArrayType<'a>(
-        Builder: &DIBuilder<'a>,
-        Size: u64,
-        AlignInBits: u32,
-        Ty: &'a DIType,
-        Subscripts: &'a DIArray,
-    ) -> &'a DIType;
-
     pub(crate) fn LLVMRustDIBuilderGetOrCreateSubrange<'a>(
         Builder: &DIBuilder<'a>,
         Lo: i64,
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index 2cbfcf79c83d2..d5be7aeb236ef 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -1211,15 +1211,6 @@ extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariable(
   }
 }
 
-extern "C" LLVMMetadataRef
-LLVMRustDIBuilderCreateArrayType(LLVMDIBuilderRef Builder, uint64_t Size,
-                                 uint32_t AlignInBits, LLVMMetadataRef Ty,
-                                 LLVMMetadataRef Subscripts) {
-  return wrap(unwrap(Builder)->createArrayType(
-      Size, AlignInBits, unwrapDI<DIType>(Ty),
-      DINodeArray(unwrapDI<MDTuple>(Subscripts))));
-}
-
 extern "C" LLVMMetadataRef
 LLVMRustDIBuilderGetOrCreateSubrange(LLVMDIBuilderRef Builder, int64_t Lo,
                                      int64_t Count) {

From 3e9048d9a47bb9db2b95adda85cd544a30bfcb8a Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 16 Sep 2025 18:46:45 +1000
Subject: [PATCH 1027/1889] Use `LLVMDIBuilderCreateBasicType`

---
 .../src/debuginfo/metadata.rs                   |  5 +++--
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs     | 17 +++++++++--------
 .../rustc_llvm/llvm-wrapper/RustWrapper.cpp     |  8 --------
 3 files changed, 12 insertions(+), 18 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
index fcbfe6ca2242f..4c210b46f7247 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
@@ -840,12 +840,13 @@ fn create_basic_type<'ll, 'tcx>(
     encoding: u32,
 ) -> &'ll DIBasicType {
     unsafe {
-        llvm::LLVMRustDIBuilderCreateBasicType(
+        llvm::LLVMDIBuilderCreateBasicType(
             DIB(cx),
-            name.as_c_char_ptr(),
+            name.as_ptr(),
             name.len(),
             size.bits(),
             encoding,
+            DIFlags::FlagZero,
         )
     }
 }
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index e2426980c6ad0..63fdc079bae4f 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -1904,6 +1904,15 @@ unsafe extern "C" {
         Subscripts: *const &'ll Metadata,
         NumSubscripts: c_uint,
     ) -> &'ll Metadata;
+
+    pub(crate) fn LLVMDIBuilderCreateBasicType<'ll>(
+        Builder: &DIBuilder<'ll>,
+        Name: *const c_uchar, // See "PTR_LEN_STR".
+        NameLen: size_t,
+        SizeInBits: u64,
+        Encoding: c_uint, // (`LLVMDWARFTypeEncoding`)
+        Flags: DIFlags,   // (default is `DIFlags::DIFlagZero`)
+    ) -> &'ll Metadata;
 }
 
 #[link(name = "llvm-wrapper", kind = "static")]
@@ -2239,14 +2248,6 @@ unsafe extern "C" {
         TParam: &'a DIArray,
     ) -> &'a DISubprogram;
 
-    pub(crate) fn LLVMRustDIBuilderCreateBasicType<'a>(
-        Builder: &DIBuilder<'a>,
-        Name: *const c_char,
-        NameLen: size_t,
-        SizeInBits: u64,
-        Encoding: c_uint,
-    ) -> &'a DIBasicType;
-
     pub(crate) fn LLVMRustDIBuilderCreateTypedef<'a>(
         Builder: &DIBuilder<'a>,
         Type: &'a DIBasicType,
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index d5be7aeb236ef..80d3db3b99d97 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -1064,14 +1064,6 @@ extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateMethod(
   return wrap(Sub);
 }
 
-extern "C" LLVMMetadataRef
-LLVMRustDIBuilderCreateBasicType(LLVMDIBuilderRef Builder, const char *Name,
-                                 size_t NameLen, uint64_t SizeInBits,
-                                 unsigned Encoding) {
-  return wrap(unwrap(Builder)->createBasicType(StringRef(Name, NameLen),
-                                               SizeInBits, Encoding));
-}
-
 extern "C" LLVMMetadataRef
 LLVMRustDIBuilderCreateTypedef(LLVMDIBuilderRef Builder, LLVMMetadataRef Type,
                                const char *Name, size_t NameLen,

From bae6fde27057c4b8fe216eb39a4ba6867aeeb8fb Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 16 Sep 2025 20:09:34 +1000
Subject: [PATCH 1028/1889] Use `LLVMDIBuilderCreatePointerType`

---
 .../src/debuginfo/metadata.rs                 | 68 ++++++++++---------
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs   | 20 +++---
 .../rustc_llvm/llvm-wrapper/RustWrapper.cpp   |  9 ---
 3 files changed, 45 insertions(+), 52 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
index 4c210b46f7247..0903ddab28549 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
@@ -173,17 +173,13 @@ fn build_pointer_or_reference_di_node<'ll, 'tcx>(
                 "ptr_type={ptr_type}, pointee_type={pointee_type}",
             );
 
-            let di_node = unsafe {
-                llvm::LLVMRustDIBuilderCreatePointerType(
-                    DIB(cx),
-                    pointee_type_di_node,
-                    pointer_size.bits(),
-                    pointer_align.abi.bits() as u32,
-                    0, // Ignore DWARF address space.
-                    ptr_type_debuginfo_name.as_c_char_ptr(),
-                    ptr_type_debuginfo_name.len(),
-                )
-            };
+            let di_node = create_pointer_type(
+                cx,
+                pointee_type_di_node,
+                pointer_size,
+                pointer_align.abi,
+                &ptr_type_debuginfo_name,
+            );
 
             DINodeCreationResult { di_node, already_stored_in_typemap: false }
         }
@@ -231,17 +227,13 @@ fn build_pointer_or_reference_di_node<'ll, 'tcx>(
 
                     // The data pointer type is a regular, thin pointer, regardless of whether this
                     // is a slice or a trait object.
-                    let data_ptr_type_di_node = unsafe {
-                        llvm::LLVMRustDIBuilderCreatePointerType(
-                            DIB(cx),
-                            pointee_type_di_node,
-                            addr_field.size.bits(),
-                            addr_field.align.abi.bits() as u32,
-                            0, // Ignore DWARF address space.
-                            std::ptr::null(),
-                            0,
-                        )
-                    };
+                    let data_ptr_type_di_node = create_pointer_type(
+                        cx,
+                        pointee_type_di_node,
+                        addr_field.size,
+                        addr_field.align.abi,
+                        "",
+                    );
 
                     smallvec![
                         build_field_di_node(
@@ -327,17 +319,7 @@ fn build_subroutine_type_di_node<'ll, 'tcx>(
         }
         _ => unreachable!(),
     };
-    let di_node = unsafe {
-        llvm::LLVMRustDIBuilderCreatePointerType(
-            DIB(cx),
-            fn_di_node,
-            size.bits(),
-            align.bits() as u32,
-            0, // Ignore DWARF address space.
-            name.as_c_char_ptr(),
-            name.len(),
-        )
-    };
+    let di_node = create_pointer_type(cx, fn_di_node, size, align, &name);
 
     DINodeCreationResult::new(di_node, false)
 }
@@ -357,6 +339,26 @@ pub(super) fn create_subroutine_type<'ll>(
     }
 }
 
+fn create_pointer_type<'ll>(
+    cx: &CodegenCx<'ll, '_>,
+    pointee_ty: &'ll llvm::Metadata,
+    size: Size,
+    align: Align,
+    name: &str,
+) -> &'ll llvm::Metadata {
+    unsafe {
+        llvm::LLVMDIBuilderCreatePointerType(
+            DIB(cx),
+            pointee_ty,
+            size.bits(),
+            align.bits() as u32,
+            0, // Ignore DWARF address space.
+            name.as_ptr(),
+            name.len(),
+        )
+    }
+}
+
 /// Create debuginfo for `dyn SomeTrait` types. Currently these are empty structs
 /// we with the correct type name (e.g. "dyn SomeTrait<Foo, Item=u32> + Sync").
 fn build_dyn_type_di_node<'ll, 'tcx>(
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 63fdc079bae4f..bd26590e7d36d 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -1913,6 +1913,16 @@ unsafe extern "C" {
         Encoding: c_uint, // (`LLVMDWARFTypeEncoding`)
         Flags: DIFlags,   // (default is `DIFlags::DIFlagZero`)
     ) -> &'ll Metadata;
+
+    pub(crate) fn LLVMDIBuilderCreatePointerType<'ll>(
+        Builder: &DIBuilder<'ll>,
+        PointeeTy: &'ll Metadata,
+        SizeInBits: u64,
+        AlignInBits: u32,
+        AddressSpace: c_uint, // (optional DWARF address space; default is 0)
+        Name: *const c_uchar, // See "PTR_LEN_STR".
+        NameLen: size_t,
+    ) -> &'ll Metadata;
 }
 
 #[link(name = "llvm-wrapper", kind = "static")]
@@ -2258,16 +2268,6 @@ unsafe extern "C" {
         Scope: Option<&'a DIScope>,
     ) -> &'a DIDerivedType;
 
-    pub(crate) fn LLVMRustDIBuilderCreatePointerType<'a>(
-        Builder: &DIBuilder<'a>,
-        PointeeTy: &'a DIType,
-        SizeInBits: u64,
-        AlignInBits: u32,
-        AddressSpace: c_uint,
-        Name: *const c_char,
-        NameLen: size_t,
-    ) -> &'a DIDerivedType;
-
     pub(crate) fn LLVMRustDIBuilderCreateStructType<'a>(
         Builder: &DIBuilder<'a>,
         Scope: Option<&'a DIDescriptor>,
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index 80d3db3b99d97..e6be7e2961b41 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -1074,15 +1074,6 @@ LLVMRustDIBuilderCreateTypedef(LLVMDIBuilderRef Builder, LLVMMetadataRef Type,
       LineNo, unwrapDIPtr<DIScope>(Scope)));
 }
 
-extern "C" LLVMMetadataRef LLVMRustDIBuilderCreatePointerType(
-    LLVMDIBuilderRef Builder, LLVMMetadataRef PointeeTy, uint64_t SizeInBits,
-    uint32_t AlignInBits, unsigned AddressSpace, const char *Name,
-    size_t NameLen) {
-  return wrap(unwrap(Builder)->createPointerType(
-      unwrapDI<DIType>(PointeeTy), SizeInBits, AlignInBits, AddressSpace,
-      StringRef(Name, NameLen)));
-}
-
 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateStructType(
     LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
     size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,

From af88d14cac15dd47452ce670e65c1ed56dae9586 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 16 Sep 2025 20:29:56 +1000
Subject: [PATCH 1029/1889] Use `LLVMDIBuilderCreateStructType`

---
 .../src/debuginfo/metadata/type_map.rs        | 14 +++---
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs   | 43 ++++++++++---------
 .../rustc_llvm/llvm-wrapper/RustWrapper.cpp   | 14 ------
 3 files changed, 29 insertions(+), 42 deletions(-)

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 af72d4ea3de0a..37200fdc41afa 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata/type_map.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata/type_map.rs
@@ -10,7 +10,7 @@ use rustc_middle::bug;
 use rustc_middle::ty::{self, ExistentialTraitRef, Ty, TyCtxt};
 
 use super::{DefinitionLocation, SmallVec, UNKNOWN_LINE_NUMBER, unknown_file_metadata};
-use crate::common::{AsCCharPtr, CodegenCx};
+use crate::common::CodegenCx;
 use crate::debuginfo::utils::{DIB, create_DIArray, debug_context};
 use crate::llvm::debuginfo::{DIFlags, DIScope, DIType};
 use crate::llvm::{self};
@@ -193,7 +193,6 @@ pub(super) fn stub<'ll, 'tcx>(
     flags: DIFlags,
 ) -> StubInfo<'ll, 'tcx> {
     let no_elements: &[Option<&llvm::Metadata>] = &[];
-    let empty_array = create_DIArray(DIB(cx), &[]);
     let unique_type_id_str = unique_type_id.generate_unique_id_string(cx.tcx);
 
     let (file_metadata, line_number) = if let Some(def_location) = def_location {
@@ -209,10 +208,10 @@ pub(super) fn stub<'ll, 'tcx>(
                 _ => None,
             };
             unsafe {
-                llvm::LLVMRustDIBuilderCreateStructType(
+                llvm::LLVMDIBuilderCreateStructType(
                     DIB(cx),
                     containing_scope,
-                    name.as_c_char_ptr(),
+                    name.as_ptr(),
                     name.len(),
                     file_metadata,
                     line_number,
@@ -220,10 +219,11 @@ pub(super) fn stub<'ll, 'tcx>(
                     align.bits() as u32,
                     flags,
                     None,
-                    empty_array,
-                    0,
+                    no_elements.as_ptr(),
+                    no_elements.len() as c_uint,
+                    0u32, // (Objective-C runtime version; default is 0)
                     vtable_holder,
-                    unique_type_id_str.as_c_char_ptr(),
+                    unique_type_id_str.as_ptr(),
                     unique_type_id_str.len(),
                 )
             }
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index bd26590e7d36d..f88eaebc70061 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -24,9 +24,9 @@ use rustc_target::spec::SymbolVisibility;
 
 use super::RustString;
 use super::debuginfo::{
-    DIArray, DIBasicType, DIBuilder, DICompositeType, DIDerivedType, DIDescriptor, DIEnumerator,
-    DIFile, DIFlags, DIGlobalVariableExpression, DILocation, DISPFlags, DIScope, DISubprogram,
-    DISubrange, DITemplateTypeParameter, DIType, DIVariable, DebugEmissionKind, DebugNameTableKind,
+    DIArray, DIBasicType, DIBuilder, DIDerivedType, DIDescriptor, DIEnumerator, DIFile, DIFlags,
+    DIGlobalVariableExpression, DILocation, DISPFlags, DIScope, DISubprogram, DISubrange,
+    DITemplateTypeParameter, DIType, DIVariable, DebugEmissionKind, DebugNameTableKind,
 };
 use crate::llvm;
 
@@ -1923,6 +1923,25 @@ unsafe extern "C" {
         Name: *const c_uchar, // See "PTR_LEN_STR".
         NameLen: size_t,
     ) -> &'ll Metadata;
+
+    pub(crate) fn LLVMDIBuilderCreateStructType<'ll>(
+        Builder: &DIBuilder<'ll>,
+        Scope: Option<&'ll Metadata>,
+        Name: *const c_uchar, // See "PTR_LEN_STR".
+        NameLen: size_t,
+        File: &'ll Metadata,
+        LineNumber: c_uint,
+        SizeInBits: u64,
+        AlignInBits: u32,
+        Flags: DIFlags,
+        DerivedFrom: Option<&'ll Metadata>,
+        Elements: *const Option<&'ll Metadata>,
+        NumElements: c_uint,
+        RunTimeLang: c_uint, // (optional Objective-C runtime version; default is 0)
+        VTableHolder: Option<&'ll Metadata>,
+        UniqueId: *const c_uchar, // See "PTR_LEN_STR".
+        UniqueIdLen: size_t,
+    ) -> &'ll Metadata;
 }
 
 #[link(name = "llvm-wrapper", kind = "static")]
@@ -2268,24 +2287,6 @@ unsafe extern "C" {
         Scope: Option<&'a DIScope>,
     ) -> &'a DIDerivedType;
 
-    pub(crate) fn LLVMRustDIBuilderCreateStructType<'a>(
-        Builder: &DIBuilder<'a>,
-        Scope: Option<&'a DIDescriptor>,
-        Name: *const c_char,
-        NameLen: size_t,
-        File: &'a DIFile,
-        LineNumber: c_uint,
-        SizeInBits: u64,
-        AlignInBits: u32,
-        Flags: DIFlags,
-        DerivedFrom: Option<&'a DIType>,
-        Elements: &'a DIArray,
-        RunTimeLang: c_uint,
-        VTableHolder: Option<&'a DIType>,
-        UniqueId: *const c_char,
-        UniqueIdLen: size_t,
-    ) -> &'a DICompositeType;
-
     pub(crate) fn LLVMRustDIBuilderCreateMemberType<'a>(
         Builder: &DIBuilder<'a>,
         Scope: &'a DIDescriptor,
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index e6be7e2961b41..b4ca641674f08 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -1074,20 +1074,6 @@ LLVMRustDIBuilderCreateTypedef(LLVMDIBuilderRef Builder, LLVMMetadataRef Type,
       LineNo, unwrapDIPtr<DIScope>(Scope)));
 }
 
-extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateStructType(
-    LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
-    size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,
-    uint64_t SizeInBits, uint32_t AlignInBits, LLVMDIFlags Flags,
-    LLVMMetadataRef DerivedFrom, LLVMMetadataRef Elements, unsigned RunTimeLang,
-    LLVMMetadataRef VTableHolder, const char *UniqueId, size_t UniqueIdLen) {
-  return wrap(unwrap(Builder)->createStructType(
-      unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen),
-      unwrapDI<DIFile>(File), LineNumber, SizeInBits, AlignInBits,
-      fromRust(Flags), unwrapDI<DIType>(DerivedFrom),
-      DINodeArray(unwrapDI<MDTuple>(Elements)), RunTimeLang,
-      unwrapDI<DIType>(VTableHolder), StringRef(UniqueId, UniqueIdLen)));
-}
-
 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariantPart(
     LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
     size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,

From 26f3337d4eda0ba22b615744fda0185d0ee344b1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Wed, 17 Sep 2025 04:16:47 +0200
Subject: [PATCH 1030/1889] Remove `DynKind`

---
 .../src/diagnostics/explain_borrow.rs         |  4 +--
 compiler/rustc_borrowck/src/lib.rs            |  4 +--
 compiler/rustc_borrowck/src/type_check/mod.rs |  6 ++---
 .../rustc_codegen_cranelift/src/abi/mod.rs    |  2 +-
 .../rustc_codegen_cranelift/src/unsize.rs     |  4 +--
 .../src/value_and_place.rs                    |  3 +--
 compiler/rustc_codegen_ssa/src/base.rs        |  6 ++---
 compiler/rustc_codegen_ssa/src/meth.rs        |  2 +-
 compiler/rustc_codegen_ssa/src/mir/block.rs   |  2 +-
 .../rustc_const_eval/src/interpret/call.rs    |  6 ++---
 .../rustc_const_eval/src/interpret/cast.rs    |  4 +--
 .../src/interpret/eval_context.rs             |  2 +-
 .../src/interpret/intrinsics.rs               |  2 +-
 .../rustc_const_eval/src/interpret/stack.rs   |  2 +-
 .../rustc_const_eval/src/interpret/traits.rs  |  2 +-
 .../src/interpret/validity.rs                 |  2 +-
 .../rustc_const_eval/src/interpret/visitor.rs |  2 +-
 .../rustc_const_eval/src/util/type_name.rs    |  2 +-
 .../rustc_hir_analysis/src/collect/dump.rs    |  2 +-
 .../src/hir_ty_lowering/dyn_compatibility.rs  |  5 ++--
 .../src/hir_ty_lowering/errors.rs             |  2 +-
 .../src/hir_ty_lowering/mod.rs                |  7 +----
 .../src/variance/constraints.rs               |  2 +-
 compiler/rustc_hir_typeck/src/cast.rs         |  8 ++----
 compiler/rustc_hir_typeck/src/coercion.rs     |  2 +-
 .../rustc_hir_typeck/src/method/suggest.rs    |  2 +-
 .../src/deref_into_dyn_supertrait.rs          |  4 +--
 compiler/rustc_lint/src/types.rs              |  2 +-
 compiler/rustc_lint/src/unused.rs             |  2 +-
 compiler/rustc_middle/src/ty/context.rs       |  2 +-
 compiler/rustc_middle/src/ty/layout.rs        |  6 ++---
 compiler/rustc_middle/src/ty/print/pretty.rs  |  6 ++---
 .../src/ty/significant_drop_order.rs          |  2 +-
 .../rustc_middle/src/ty/structural_impls.rs   | 14 +++++-----
 compiler/rustc_middle/src/ty/sty.rs           | 14 +++++-----
 .../src/move_paths/builder.rs                 |  4 +--
 compiler/rustc_mir_transform/src/coroutine.rs |  2 +-
 .../src/canonicalizer.rs                      |  2 +-
 .../src/solve/assembly/mod.rs                 |  2 +-
 .../src/solve/assembly/structural_traits.rs   |  6 ++---
 .../src/solve/normalizes_to/mod.rs            |  4 +--
 .../src/solve/trait_goals.rs                  | 12 ++++-----
 compiler/rustc_passes/src/check_export.rs     |  2 +-
 compiler/rustc_pattern_analysis/src/rustc.rs  |  2 +-
 compiler/rustc_public/src/ty.rs               | 11 +++-----
 .../src/unstable/convert/internal.rs          | 19 ++-----------
 .../src/unstable/convert/stable/ty.rs         | 27 +++++--------------
 compiler/rustc_public/src/visitor.rs          |  2 +-
 .../src/cfi/typeid/itanium_cxx_abi/encode.rs  |  6 ++---
 .../cfi/typeid/itanium_cxx_abi/transform.rs   |  8 +++---
 compiler/rustc_symbol_mangling/src/export.rs  |  2 +-
 compiler/rustc_symbol_mangling/src/v0.rs      |  6 ++---
 .../nice_region_error/static_impl_trait.rs    |  2 +-
 .../error_reporting/infer/note_and_explain.rs | 12 +++------
 .../src/error_reporting/infer/region.rs       |  2 +-
 .../src/error_reporting/traits/mod.rs         |  2 +-
 .../traits/on_unimplemented.rs                |  2 +-
 .../src/error_reporting/traits/suggestions.rs |  6 ++---
 .../src/traits/select/candidate_assembly.rs   |  8 +++---
 .../src/traits/select/confirmation.rs         | 14 +++++-----
 .../src/traits/vtable.rs                      |  6 ++---
 .../rustc_trait_selection/src/traits/wf.rs    |  2 +-
 compiler/rustc_ty_utils/src/layout.rs         |  2 +-
 compiler/rustc_ty_utils/src/ty.rs             |  4 +--
 compiler/rustc_type_ir/src/flags.rs           |  2 +-
 compiler/rustc_type_ir/src/inherent.rs        |  9 ++-----
 compiler/rustc_type_ir/src/lib.rs             |  1 -
 compiler/rustc_type_ir/src/outlives.rs        |  2 +-
 compiler/rustc_type_ir/src/relate.rs          | 15 ++++-------
 compiler/rustc_type_ir/src/ty_kind.rs         | 22 +++------------
 compiler/rustc_type_ir/src/walk.rs            |  2 +-
 src/librustdoc/clean/mod.rs                   |  2 +-
 .../clippy_utils/src/qualify_min_const_fn.rs  |  2 +-
 src/tools/clippy/clippy_utils/src/ty/mod.rs   |  4 +--
 74 files changed, 142 insertions(+), 237 deletions(-)

diff --git a/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs b/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs
index fda96dde8269d..7ca07bb9b4348 100644
--- a/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs
@@ -438,7 +438,7 @@ impl<'tcx> BorrowExplanation<'tcx> {
 
             let elaborated_args =
                 std::iter::zip(*args, &generics.own_params).map(|(arg, param)| {
-                    if let Some(ty::Dynamic(obj, _, ty::Dyn)) = arg.as_type().map(Ty::kind) {
+                    if let Some(ty::Dynamic(obj, _)) = arg.as_type().map(Ty::kind) {
                         let default = tcx.object_lifetime_default(param.def_id);
 
                         let re_static = tcx.lifetimes.re_static;
@@ -464,7 +464,7 @@ impl<'tcx> BorrowExplanation<'tcx> {
 
                         has_dyn = true;
 
-                        Ty::new_dynamic(tcx, obj, implied_region, ty::Dyn).into()
+                        Ty::new_dynamic(tcx, obj, implied_region).into()
                     } else {
                         arg
                     }
diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs
index 5d2dda8b0e7cc..5b20c5536c390 100644
--- a/compiler/rustc_borrowck/src/lib.rs
+++ b/compiler/rustc_borrowck/src/lib.rs
@@ -1904,7 +1904,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                     | ty::Slice(_)
                     | ty::FnDef(_, _)
                     | ty::FnPtr(..)
-                    | ty::Dynamic(_, _, _)
+                    | ty::Dynamic(_, _)
                     | ty::Closure(_, _)
                     | ty::CoroutineClosure(_, _)
                     | ty::Coroutine(_, _)
@@ -1950,7 +1950,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                     | ty::Ref(_, _, _)
                     | ty::FnDef(_, _)
                     | ty::FnPtr(..)
-                    | ty::Dynamic(_, _, _)
+                    | ty::Dynamic(_, _)
                     | ty::CoroutineWitness(..)
                     | ty::Never
                     | ty::UnsafeBinder(_)
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
index 8c5447fe1e9e7..8e6150fe9da2c 100644
--- a/compiler/rustc_borrowck/src/type_check/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -1487,9 +1487,9 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                                     unsize_to: None,
                                 },
                             );
-                        } else if let ty::Dynamic(src_tty, _src_lt, ty::Dyn) =
+                        } else if let ty::Dynamic(src_tty, _src_lt) =
                             *self.struct_tail(src.ty, location).kind()
-                            && let ty::Dynamic(dst_tty, dst_lt, ty::Dyn) =
+                            && let ty::Dynamic(dst_tty, dst_lt) =
                                 *self.struct_tail(dst.ty, location).kind()
                             && src_tty.principal().is_some()
                             && dst_tty.principal().is_some()
@@ -1511,7 +1511,6 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                                 // FIXME: Once we disallow casting `*const dyn Trait + 'short`
                                 // to `*const dyn Trait + 'long`, then this can just be `src_lt`.
                                 dst_lt,
-                                ty::Dyn,
                             );
                             let dst_obj = Ty::new_dynamic(
                                 tcx,
@@ -1519,7 +1518,6 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                                     &dst_tty.without_auto_traits().collect::<Vec<_>>(),
                                 ),
                                 dst_lt,
-                                ty::Dyn,
                             );
 
                             debug!(?src_tty, ?dst_tty, ?src_obj, ?dst_obj);
diff --git a/compiler/rustc_codegen_cranelift/src/abi/mod.rs b/compiler/rustc_codegen_cranelift/src/abi/mod.rs
index 7d0731c77bdc4..29ee46194de19 100644
--- a/compiler/rustc_codegen_cranelift/src/abi/mod.rs
+++ b/compiler/rustc_codegen_cranelift/src/abi/mod.rs
@@ -715,7 +715,7 @@ pub(crate) fn codegen_drop<'tcx>(
         fx.bcx.ins().jump(ret_block, &[]);
     } else {
         match ty.kind() {
-            ty::Dynamic(_, _, ty::Dyn) => {
+            ty::Dynamic(_, _) => {
                 // IN THIS ARM, WE HAVE:
                 // ty = *mut (dyn Trait)
                 // which is: exists<T> ( *mut T,    Vtable<T: Trait> )
diff --git a/compiler/rustc_codegen_cranelift/src/unsize.rs b/compiler/rustc_codegen_cranelift/src/unsize.rs
index 2aee0b2e97424..643c7feb89a26 100644
--- a/compiler/rustc_codegen_cranelift/src/unsize.rs
+++ b/compiler/rustc_codegen_cranelift/src/unsize.rs
@@ -30,9 +30,7 @@ pub(crate) fn unsized_info<'tcx>(
             fx.pointer_type,
             len.try_to_target_usize(fx.tcx).expect("expected monomorphic const in codegen") as i64,
         ),
-        (&ty::Dynamic(data_a, _, src_dyn_kind), &ty::Dynamic(data_b, _, target_dyn_kind))
-            if src_dyn_kind == target_dyn_kind =>
-        {
+        (&ty::Dynamic(data_a, _), &ty::Dynamic(data_b, _)) => {
             let old_info =
                 old_info.expect("unsized_info: missing old info for trait upcasting coercion");
             let b_principal_def_id = data_b.principal_def_id();
diff --git a/compiler/rustc_codegen_cranelift/src/value_and_place.rs b/compiler/rustc_codegen_cranelift/src/value_and_place.rs
index 9d73f200afe2b..4519fa1a270e4 100644
--- a/compiler/rustc_codegen_cranelift/src/value_and_place.rs
+++ b/compiler/rustc_codegen_cranelift/src/value_and_place.rs
@@ -909,8 +909,7 @@ pub(crate) fn assert_assignable<'tcx>(
             );
             // fn(&T) -> for<'l> fn(&'l T) is allowed
         }
-        (&ty::Dynamic(from_traits, _, _from_kind), &ty::Dynamic(to_traits, _, _to_kind)) => {
-            // FIXME(dyn-star): Do the right thing with DynKinds
+        (&ty::Dynamic(from_traits, _), &ty::Dynamic(to_traits, _)) => {
             for (from, to) in from_traits.iter().zip(to_traits) {
                 let from = fx.tcx.normalize_erasing_late_bound_regions(fx.typing_env(), from);
                 let to = fx.tcx.normalize_erasing_late_bound_regions(fx.typing_env(), to);
diff --git a/compiler/rustc_codegen_ssa/src/base.rs b/compiler/rustc_codegen_ssa/src/base.rs
index 45b028aa8eff2..68a2f43ec67bc 100644
--- a/compiler/rustc_codegen_ssa/src/base.rs
+++ b/compiler/rustc_codegen_ssa/src/base.rs
@@ -168,9 +168,7 @@ fn unsized_info<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
         (&ty::Array(_, len), &ty::Slice(_)) => cx.const_usize(
             len.try_to_target_usize(cx.tcx()).expect("expected monomorphic const in codegen"),
         ),
-        (&ty::Dynamic(data_a, _, src_dyn_kind), &ty::Dynamic(data_b, _, target_dyn_kind))
-            if src_dyn_kind == target_dyn_kind =>
-        {
+        (&ty::Dynamic(data_a, _), &ty::Dynamic(data_b, _)) => {
             let old_info =
                 old_info.expect("unsized_info: missing old info for trait upcasting coercion");
             let b_principal_def_id = data_b.principal_def_id();
@@ -208,7 +206,7 @@ fn unsized_info<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
                 old_info
             }
         }
-        (_, ty::Dynamic(data, _, _)) => meth::get_vtable(
+        (_, ty::Dynamic(data, _)) => meth::get_vtable(
             cx,
             source,
             data.principal()
diff --git a/compiler/rustc_codegen_ssa/src/meth.rs b/compiler/rustc_codegen_ssa/src/meth.rs
index 34ad35a729b98..2fa466b500179 100644
--- a/compiler/rustc_codegen_ssa/src/meth.rs
+++ b/compiler/rustc_codegen_ssa/src/meth.rs
@@ -78,7 +78,7 @@ fn dyn_trait_in_self<'tcx>(
 ) -> Option<ty::ExistentialTraitRef<'tcx>> {
     for arg in ty.peel_refs().walk() {
         if let GenericArgKind::Type(ty) = arg.kind()
-            && let ty::Dynamic(data, _, _) = ty.kind()
+            && let ty::Dynamic(data, _) = ty.kind()
         {
             // FIXME(arbitrary_self_types): This is likely broken for receivers which
             // have a "non-self" trait objects as a generic argument.
diff --git a/compiler/rustc_codegen_ssa/src/mir/block.rs b/compiler/rustc_codegen_ssa/src/mir/block.rs
index 6492ef73956b0..1b218a0d33956 100644
--- a/compiler/rustc_codegen_ssa/src/mir/block.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/block.rs
@@ -614,7 +614,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         let (maybe_null, drop_fn, fn_abi, drop_instance) = match ty.kind() {
             // FIXME(eddyb) perhaps move some of this logic into
             // `Instance::resolve_drop_in_place`?
-            ty::Dynamic(_, _, ty::Dyn) => {
+            ty::Dynamic(_, _) => {
                 // IN THIS ARM, WE HAVE:
                 // ty = *mut (dyn Trait)
                 // which is: exists<T> ( *mut T,    Vtable<T: Trait> )
diff --git a/compiler/rustc_const_eval/src/interpret/call.rs b/compiler/rustc_const_eval/src/interpret/call.rs
index 4cb88d44e1b11..23e4a2921ea6e 100644
--- a/compiler/rustc_const_eval/src/interpret/call.rs
+++ b/compiler/rustc_const_eval/src/interpret/call.rs
@@ -658,7 +658,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                             let val = self.read_immediate(&receiver)?;
                             break self.ref_to_mplace(&val)?;
                         }
-                        ty::Dynamic(.., ty::Dyn) => break receiver.assert_mem_place(), // no immediate unsized values
+                        ty::Dynamic(..) => break receiver.assert_mem_place(), // no immediate unsized values
                         _ => {
                             // Not there yet, search for the only non-ZST field.
                             // (The rules for `DispatchFromDyn` ensure there's exactly one such field.)
@@ -675,7 +675,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 // (For that reason we also cannot use `unpack_dyn_trait`.)
                 let receiver_tail =
                     self.tcx.struct_tail_for_codegen(receiver_place.layout.ty, self.typing_env);
-                let ty::Dynamic(receiver_trait, _, ty::Dyn) = receiver_tail.kind() else {
+                let ty::Dynamic(receiver_trait, _) = receiver_tail.kind() else {
                     span_bug!(self.cur_span(), "dynamic call on non-`dyn` type {}", receiver_tail)
                 };
                 assert!(receiver_place.layout.is_unsized());
@@ -822,7 +822,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         // instead we do the virtual call stuff ourselves. It's easier here than in `eval_fn_call`
         // since we can just get a place of the underlying type and use `mplace_to_ref`.
         let place = match place.layout.ty.kind() {
-            ty::Dynamic(data, _, ty::Dyn) => {
+            ty::Dynamic(data, _) => {
                 // Dropping a trait object. Need to find actual drop fn.
                 self.unpack_dyn_trait(&place, data)?
             }
diff --git a/compiler/rustc_const_eval/src/interpret/cast.rs b/compiler/rustc_const_eval/src/interpret/cast.rs
index e3afeda5b7c97..0075740e03178 100644
--- a/compiler/rustc_const_eval/src/interpret/cast.rs
+++ b/compiler/rustc_const_eval/src/interpret/cast.rs
@@ -386,7 +386,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 );
                 self.write_immediate(val, dest)
             }
-            (ty::Dynamic(data_a, _, ty::Dyn), ty::Dynamic(data_b, _, ty::Dyn)) => {
+            (ty::Dynamic(data_a, _), ty::Dynamic(data_b, _)) => {
                 let val = self.read_immediate(src)?;
                 // MIR building generates odd NOP casts, prevent them from causing unexpected trouble.
                 // See <https://github.com/rust-lang/rust/issues/128880>.
@@ -436,7 +436,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 let new_vptr = self.get_vtable_ptr(ty, data_b)?;
                 self.write_immediate(Immediate::new_dyn_trait(old_data, new_vptr, self), dest)
             }
-            (_, &ty::Dynamic(data, _, ty::Dyn)) => {
+            (_, &ty::Dynamic(data, _)) => {
                 // Initial cast from sized to dyn trait
                 let vtable = self.get_vtable_ptr(src_pointee_ty, data)?;
                 let ptr = self.read_pointer(src)?;
diff --git a/compiler/rustc_const_eval/src/interpret/eval_context.rs b/compiler/rustc_const_eval/src/interpret/eval_context.rs
index 91ed71ac3e54c..0e4a98f0941ac 100644
--- a/compiler/rustc_const_eval/src/interpret/eval_context.rs
+++ b/compiler/rustc_const_eval/src/interpret/eval_context.rs
@@ -469,7 +469,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 }
                 interp_ok(Some((full_size, full_align)))
             }
-            ty::Dynamic(expected_trait, _, ty::Dyn) => {
+            ty::Dynamic(expected_trait, _) => {
                 let vtable = metadata.unwrap_meta().to_pointer(self)?;
                 // Read size and align from vtable (already checks size).
                 interp_ok(Some(self.get_vtable_size_and_align(vtable, Some(expected_trait))?))
diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
index 5e3d0a15d8bc1..418dd658121db 100644
--- a/compiler/rustc_const_eval/src/interpret/intrinsics.rs
+++ b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -181,7 +181,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                     | ty::Ref(_, _, _)
                     | ty::FnDef(_, _)
                     | ty::FnPtr(..)
-                    | ty::Dynamic(_, _, _)
+                    | ty::Dynamic(_, _)
                     | ty::Closure(_, _)
                     | ty::CoroutineClosure(_, _)
                     | ty::Coroutine(_, _)
diff --git a/compiler/rustc_const_eval/src/interpret/stack.rs b/compiler/rustc_const_eval/src/interpret/stack.rs
index 7cabfd961212f..1c1c59da9d886 100644
--- a/compiler/rustc_const_eval/src/interpret/stack.rs
+++ b/compiler/rustc_const_eval/src/interpret/stack.rs
@@ -509,7 +509,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 | ty::Never
                 | ty::Error(_) => true,
 
-                ty::Str | ty::Slice(_) | ty::Dynamic(_, _, ty::Dyn) | ty::Foreign(..) => false,
+                ty::Str | ty::Slice(_) | ty::Dynamic(_, _) | ty::Foreign(..) => false,
 
                 ty::Tuple(tys) => tys.last().is_none_or(|ty| is_very_trivially_sized(*ty)),
 
diff --git a/compiler/rustc_const_eval/src/interpret/traits.rs b/compiler/rustc_const_eval/src/interpret/traits.rs
index 870f9a396ae2b..d982ed9616742 100644
--- a/compiler/rustc_const_eval/src/interpret/traits.rs
+++ b/compiler/rustc_const_eval/src/interpret/traits.rs
@@ -109,7 +109,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         expected_trait: &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>>,
     ) -> InterpResult<'tcx, MPlaceTy<'tcx, M::Provenance>> {
         assert!(
-            matches!(mplace.layout.ty.kind(), ty::Dynamic(_, _, ty::Dyn)),
+            matches!(mplace.layout.ty.kind(), ty::Dynamic(_, _)),
             "`unpack_dyn_trait` only makes sense on `dyn*` types"
         );
         let vtable = mplace.meta().unwrap_meta().to_pointer(self)?;
diff --git a/compiler/rustc_const_eval/src/interpret/validity.rs b/compiler/rustc_const_eval/src/interpret/validity.rs
index 02e3d90f4af70..9adc3fa463180 100644
--- a/compiler/rustc_const_eval/src/interpret/validity.rs
+++ b/compiler/rustc_const_eval/src/interpret/validity.rs
@@ -449,7 +449,7 @@ impl<'rt, 'tcx, M: Machine<'tcx>> ValidityVisitor<'rt, 'tcx, M> {
     ) -> InterpResult<'tcx> {
         let tail = self.ecx.tcx.struct_tail_for_codegen(pointee.ty, self.ecx.typing_env);
         match tail.kind() {
-            ty::Dynamic(data, _, ty::Dyn) => {
+            ty::Dynamic(data, _) => {
                 let vtable = meta.unwrap_meta().to_pointer(self.ecx)?;
                 // Make sure it is a genuine vtable pointer for the right trait.
                 try_validation!(
diff --git a/compiler/rustc_const_eval/src/interpret/visitor.rs b/compiler/rustc_const_eval/src/interpret/visitor.rs
index 82c50fac6c0ee..b5de10c7dcd11 100644
--- a/compiler/rustc_const_eval/src/interpret/visitor.rs
+++ b/compiler/rustc_const_eval/src/interpret/visitor.rs
@@ -90,7 +90,7 @@ pub trait ValueVisitor<'tcx, M: Machine<'tcx>>: Sized {
         // Special treatment for special types, where the (static) layout is not sufficient.
         match *ty.kind() {
             // If it is a trait object, switch to the real type that was used to create it.
-            ty::Dynamic(data, _, ty::Dyn) => {
+            ty::Dynamic(data, _) => {
                 // Dyn types. This is unsized, and the actual dynamic type of the data is given by the
                 // vtable stored in the place metadata.
                 // unsized values are never immediate, so we can assert_mem_place
diff --git a/compiler/rustc_const_eval/src/util/type_name.rs b/compiler/rustc_const_eval/src/util/type_name.rs
index 5bcf96abd8cb5..db651811551f3 100644
--- a/compiler/rustc_const_eval/src/util/type_name.rs
+++ b/compiler/rustc_const_eval/src/util/type_name.rs
@@ -41,7 +41,7 @@ impl<'tcx> Printer<'tcx> for TypeNamePrinter<'tcx> {
             | ty::FnPtr(..)
             | ty::Never
             | ty::Tuple(_)
-            | ty::Dynamic(_, _, _)
+            | ty::Dynamic(_, _)
             | ty::UnsafeBinder(_) => self.pretty_print_type(ty),
 
             // Placeholders (all printed as `_` to uniformize them).
diff --git a/compiler/rustc_hir_analysis/src/collect/dump.rs b/compiler/rustc_hir_analysis/src/collect/dump.rs
index c3f965d845693..44cc2dec1cb52 100644
--- a/compiler/rustc_hir_analysis/src/collect/dump.rs
+++ b/compiler/rustc_hir_analysis/src/collect/dump.rs
@@ -152,7 +152,7 @@ pub(crate) fn vtables<'tcx>(tcx: TyCtxt<'tcx>) {
                     );
                     continue;
                 };
-                let ty::Dynamic(data, _, _) = *ty.kind() else {
+                let ty::Dynamic(data, _) = *ty.kind() else {
                     tcx.dcx()
                         .span_err(attr.span(), "`rustc_dump_vtable` to type alias of dyn type");
                     continue;
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_compatibility.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_compatibility.rs
index 76bb59e3f0901..c823a4a0430f4 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_compatibility.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_compatibility.rs
@@ -6,7 +6,7 @@ use rustc_hir::def::{DefKind, Res};
 use rustc_lint_defs::builtin::UNUSED_ASSOCIATED_TYPE_BOUNDS;
 use rustc_middle::ty::elaborate::ClauseWithSupertraitSpan;
 use rustc_middle::ty::{
-    self, BottomUpFolder, DynKind, ExistentialPredicateStableCmpExt as _, Ty, TyCtxt, TypeFoldable,
+    self, BottomUpFolder, ExistentialPredicateStableCmpExt as _, Ty, TyCtxt, TypeFoldable,
     TypeVisitableExt, Upcast,
 };
 use rustc_span::{ErrorGuaranteed, Span};
@@ -28,7 +28,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         hir_id: hir::HirId,
         hir_bounds: &[hir::PolyTraitRef<'tcx>],
         lifetime: &hir::Lifetime,
-        representation: DynKind,
     ) -> Ty<'tcx> {
         let tcx = self.tcx();
         let dummy_self = tcx.types.trait_object_dummy_self;
@@ -431,7 +430,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         };
         debug!(?region_bound);
 
-        Ty::new_dynamic(tcx, existential_predicates, region_bound, representation)
+        Ty::new_dynamic(tcx, existential_predicates, region_bound)
     }
 
     /// Check that elaborating the principal of a trait ref doesn't lead to projections
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 0cf9cb7193f72..165051744641f 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
@@ -859,7 +859,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                     bound_spans.get_mut_or_insert_default(tcx.def_span(def.did())).push(msg)
                 }
                 // Point at the trait object that couldn't satisfy the bound.
-                ty::Dynamic(preds, _, _) => {
+                ty::Dynamic(preds, _) => {
                     for pred in preds.iter() {
                         match pred.skip_binder() {
                             ty::ExistentialPredicate::Trait(tr) => {
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 c5e079fe89ac4..b64129dc54e67 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -23,7 +23,6 @@ mod lint;
 use std::assert_matches::assert_matches;
 use std::slice;
 
-use rustc_ast::TraitObjectSyntax;
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_errors::codes::*;
 use rustc_errors::{
@@ -2428,7 +2427,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             ),
             hir::TyKind::TraitObject(bounds, tagged_ptr) => {
                 let lifetime = tagged_ptr.pointer();
-                let repr = tagged_ptr.tag();
 
                 if let Some(guar) = self.prohibit_or_lint_bare_trait_object_ty(hir_ty) {
                     // Don't continue with type analysis if the `dyn` keyword is missing
@@ -2436,10 +2434,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                     // keyword like `impl`
                     Ty::new_error(tcx, guar)
                 } else {
-                    let repr = match repr {
-                        TraitObjectSyntax::Dyn | TraitObjectSyntax::None => ty::Dyn,
-                    };
-                    self.lower_trait_object_ty(hir_ty.span, hir_ty.hir_id, bounds, lifetime, repr)
+                    self.lower_trait_object_ty(hir_ty.span, hir_ty.hir_id, bounds, lifetime)
                 }
             }
             // If we encounter a fully qualified path with RTN generics, then it must have
diff --git a/compiler/rustc_hir_analysis/src/variance/constraints.rs b/compiler/rustc_hir_analysis/src/variance/constraints.rs
index 960ec7f66ab15..be841675821c1 100644
--- a/compiler/rustc_hir_analysis/src/variance/constraints.rs
+++ b/compiler/rustc_hir_analysis/src/variance/constraints.rs
@@ -281,7 +281,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
                 self.add_constraints_from_args(current, data.def_id, data.args, variance);
             }
 
-            ty::Dynamic(data, r, _) => {
+            ty::Dynamic(data, r) => {
                 // The type `dyn Trait<T> +'a` is covariant w/r/t `'a`:
                 self.add_constraints_from_region(current, r, variance);
 
diff --git a/compiler/rustc_hir_typeck/src/cast.rs b/compiler/rustc_hir_typeck/src/cast.rs
index 27540fd1a4382..40b21c45bc564 100644
--- a/compiler/rustc_hir_typeck/src/cast.rs
+++ b/compiler/rustc_hir_typeck/src/cast.rs
@@ -103,7 +103,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         Ok(match *t.kind() {
             ty::Slice(_) | ty::Str => Some(PointerKind::Length),
-            ty::Dynamic(tty, _, ty::Dyn) => Some(PointerKind::VTable(tty)),
+            ty::Dynamic(tty, _) => Some(PointerKind::VTable(tty)),
             ty::Adt(def, args) if def.is_struct() => match def.non_enum_variant().tail_opt() {
                 None => Some(PointerKind::Thin),
                 Some(f) => {
@@ -250,9 +250,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
         // cases now. We do a more thorough check at the end, once
         // inference is more completely known.
         match cast_ty.kind() {
-            ty::Dynamic(_, _, ty::Dyn) | ty::Slice(..) => {
-                Err(check.report_cast_to_unsized_type(fcx))
-            }
+            ty::Dynamic(_, _) | ty::Slice(..) => Err(check.report_cast_to_unsized_type(fcx)),
             _ => Ok(check),
         }
     }
@@ -900,7 +898,6 @@ impl<'a, 'tcx> CastCheck<'tcx> {
                                 &src_tty.without_auto_traits().collect::<Vec<_>>(),
                             ),
                             tcx.lifetimes.re_erased,
-                            ty::Dyn,
                         );
                         let dst_obj = Ty::new_dynamic(
                             tcx,
@@ -908,7 +905,6 @@ impl<'a, 'tcx> CastCheck<'tcx> {
                                 &dst_tty.without_auto_traits().collect::<Vec<_>>(),
                             ),
                             tcx.lifetimes.re_erased,
-                            ty::Dyn,
                         );
 
                         // `dyn Src = dyn Dst`, this checks for matching traits/generics/projections
diff --git a/compiler/rustc_hir_typeck/src/coercion.rs b/compiler/rustc_hir_typeck/src/coercion.rs
index b99f811db1a14..ced2cf2b57b14 100644
--- a/compiler/rustc_hir_typeck/src/coercion.rs
+++ b/compiler/rustc_hir_typeck/src/coercion.rs
@@ -558,7 +558,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
             | ty::Slice(_)
             | ty::FnDef(_, _)
             | ty::FnPtr(_, _)
-            | ty::Dynamic(_, _, _)
+            | ty::Dynamic(_, _)
             | ty::Closure(_, _)
             | ty::CoroutineClosure(_, _)
             | ty::Coroutine(_, _)
diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index c8f6c06b720dc..a39ac0fcb6e3e 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -1008,7 +1008,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         bound_spans.get_mut_or_insert_default(tcx.def_span(def.did())).push(msg)
                     }
                     // Point at the trait object that couldn't satisfy the bound.
-                    ty::Dynamic(preds, _, _) => {
+                    ty::Dynamic(preds, _) => {
                         for pred in preds.iter() {
                             match pred.skip_binder() {
                                 ty::ExistentialPredicate::Trait(tr) => {
diff --git a/compiler/rustc_lint/src/deref_into_dyn_supertrait.rs b/compiler/rustc_lint/src/deref_into_dyn_supertrait.rs
index e1c51ff829907..703f757abd50c 100644
--- a/compiler/rustc_lint/src/deref_into_dyn_supertrait.rs
+++ b/compiler/rustc_lint/src/deref_into_dyn_supertrait.rs
@@ -66,11 +66,11 @@ impl<'tcx> LateLintPass<'tcx> for DerefIntoDynSupertrait {
             && tcx.is_lang_item(did, LangItem::Deref)
             // the self type is `dyn t_principal`
             && let self_ty = tcx.type_of(item.owner_id).instantiate_identity()
-            && let ty::Dynamic(data, _, ty::Dyn) = self_ty.kind()
+            && let ty::Dynamic(data, _) = self_ty.kind()
             && let Some(self_principal) = data.principal()
             // `<T as Deref>::Target` is `dyn target_principal`
             && let Some(target) = cx.get_associated_type(self_ty, did, sym::Target)
-            && let ty::Dynamic(data, _, ty::Dyn) = target.kind()
+            && let ty::Dynamic(data, _) = target.kind()
             && let Some(target_principal) = data.principal()
             // `target_principal` is a supertrait of `t_principal`
             && let Some(supertrait_principal) = supertraits(tcx, self_principal.with_self_ty(tcx, self_ty))
diff --git a/compiler/rustc_lint/src/types.rs b/compiler/rustc_lint/src/types.rs
index 88527fa2e6e78..eaec0c9857d28 100644
--- a/compiler/rustc_lint/src/types.rs
+++ b/compiler/rustc_lint/src/types.rs
@@ -320,7 +320,7 @@ fn lint_wide_pointer<'tcx>(
         };
 
         (!ty.is_sized(cx.tcx, cx.typing_env()))
-            .then(|| (refs, modifiers, matches!(ty.kind(), ty::Dynamic(_, _, ty::Dyn))))
+            .then(|| (refs, modifiers, matches!(ty.kind(), ty::Dynamic(_, _))))
     };
 
     // the left and right operands can have references, remove any explicit references
diff --git a/compiler/rustc_lint/src/unused.rs b/compiler/rustc_lint/src/unused.rs
index 22d89d2461273..95c5bea6be898 100644
--- a/compiler/rustc_lint/src/unused.rs
+++ b/compiler/rustc_lint/src/unused.rs
@@ -312,7 +312,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedResults {
                         })
                         .map(|inner| MustUsePath::Opaque(Box::new(inner)))
                 }
-                ty::Dynamic(binders, _, _) => binders.iter().find_map(|predicate| {
+                ty::Dynamic(binders, _) => binders.iter().find_map(|predicate| {
                     if let ty::ExistentialPredicate::Trait(ref trait_ref) = predicate.skip_binder()
                     {
                         let def_id = trait_ref.def_id;
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 79700d485c440..7d3e2c9965dad 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -574,7 +574,7 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
             | ty::Ref(_, _, _)
             | ty::FnDef(_, _)
             | ty::FnPtr(..)
-            | ty::Dynamic(_, _, _)
+            | ty::Dynamic(_, _)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
             | ty::Coroutine(_, _)
diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs
index 2114d080dfa43..9524057eebc6c 100644
--- a/compiler/rustc_middle/src/ty/layout.rs
+++ b/compiler/rustc_middle/src/ty/layout.rs
@@ -812,7 +812,7 @@ where
                 | ty::CoroutineWitness(..)
                 | ty::Foreign(..)
                 | ty::Pat(_, _)
-                | ty::Dynamic(_, _, ty::Dyn) => {
+                | ty::Dynamic(_, _) => {
                     bug!("TyAndLayout::field({:?}): not applicable", this)
                 }
 
@@ -878,7 +878,7 @@ where
                         // `std::mem::uninitialized::<&dyn Trait>()`, for example.
                         if let ty::Adt(def, args) = metadata.kind()
                             && tcx.is_lang_item(def.did(), LangItem::DynMetadata)
-                            && let ty::Dynamic(data, _, ty::Dyn) = args.type_at(0).kind()
+                            && let ty::Dynamic(data, _) = args.type_at(0).kind()
                         {
                             mk_dyn_vtable(data.principal())
                         } else {
@@ -887,7 +887,7 @@ where
                     } else {
                         match tcx.struct_tail_for_codegen(pointee, cx.typing_env()).kind() {
                             ty::Slice(_) | ty::Str => tcx.types.usize,
-                            ty::Dynamic(data, _, ty::Dyn) => mk_dyn_vtable(data.principal()),
+                            ty::Dynamic(data, _) => mk_dyn_vtable(data.principal()),
                             _ => bug!("TyAndLayout::field({:?}): not applicable", this),
                         }
                     };
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index fc821ffdaa68b..1b7ef8de8454a 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -784,14 +784,12 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
                 },
             },
             ty::Adt(def, args) => self.print_def_path(def.did(), args)?,
-            ty::Dynamic(data, r, repr) => {
+            ty::Dynamic(data, r) => {
                 let print_r = self.should_print_optional_region(r);
                 if print_r {
                     write!(self, "(")?;
                 }
-                match repr {
-                    ty::Dyn => write!(self, "dyn ")?,
-                }
+                write!(self, "dyn ")?;
                 data.print(self)?;
                 if print_r {
                     write!(self, " + ")?;
diff --git a/compiler/rustc_middle/src/ty/significant_drop_order.rs b/compiler/rustc_middle/src/ty/significant_drop_order.rs
index 5ada9ecc80cf3..f1aa7076d98ac 100644
--- a/compiler/rustc_middle/src/ty/significant_drop_order.rs
+++ b/compiler/rustc_middle/src/ty/significant_drop_order.rs
@@ -132,7 +132,7 @@ pub fn ty_dtor_span<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option<Span> {
         | ty::Ref(_, _, _)
         | ty::FnPtr(_, _)
         | ty::Tuple(_)
-        | ty::Dynamic(_, _, _)
+        | ty::Dynamic(_, _)
         | ty::Alias(_, _)
         | ty::Bound(_, _)
         | ty::Pat(_, _)
diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs
index 89ef46b1ae571..11d109b463d90 100644
--- a/compiler/rustc_middle/src/ty/structural_impls.rs
+++ b/compiler/rustc_middle/src/ty/structural_impls.rs
@@ -390,11 +390,9 @@ impl<'tcx> TypeSuperFoldable<TyCtxt<'tcx>> for Ty<'tcx> {
             ty::Array(typ, sz) => ty::Array(typ.try_fold_with(folder)?, sz.try_fold_with(folder)?),
             ty::Slice(typ) => ty::Slice(typ.try_fold_with(folder)?),
             ty::Adt(tid, args) => ty::Adt(tid, args.try_fold_with(folder)?),
-            ty::Dynamic(trait_ty, region, representation) => ty::Dynamic(
-                trait_ty.try_fold_with(folder)?,
-                region.try_fold_with(folder)?,
-                representation,
-            ),
+            ty::Dynamic(trait_ty, region) => {
+                ty::Dynamic(trait_ty.try_fold_with(folder)?, region.try_fold_with(folder)?)
+            }
             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(sig_tys, hdr) => ty::FnPtr(sig_tys.try_fold_with(folder)?, hdr),
@@ -437,8 +435,8 @@ impl<'tcx> TypeSuperFoldable<TyCtxt<'tcx>> for Ty<'tcx> {
             ty::Array(typ, sz) => ty::Array(typ.fold_with(folder), sz.fold_with(folder)),
             ty::Slice(typ) => ty::Slice(typ.fold_with(folder)),
             ty::Adt(tid, args) => ty::Adt(tid, args.fold_with(folder)),
-            ty::Dynamic(trait_ty, region, representation) => {
-                ty::Dynamic(trait_ty.fold_with(folder), region.fold_with(folder), representation)
+            ty::Dynamic(trait_ty, region) => {
+                ty::Dynamic(trait_ty.fold_with(folder), region.fold_with(folder))
             }
             ty::Tuple(ts) => ty::Tuple(ts.fold_with(folder)),
             ty::FnDef(def_id, args) => ty::FnDef(def_id, args.fold_with(folder)),
@@ -481,7 +479,7 @@ impl<'tcx> TypeSuperVisitable<TyCtxt<'tcx>> for Ty<'tcx> {
             }
             ty::Slice(typ) => typ.visit_with(visitor),
             ty::Adt(_, args) => args.visit_with(visitor),
-            ty::Dynamic(trait_ty, reg, _) => {
+            ty::Dynamic(trait_ty, reg) => {
                 try_visit!(trait_ty.visit_with(visitor));
                 reg.visit_with(visitor)
             }
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
index 755fc68d86f34..2bea797799958 100644
--- a/compiler/rustc_middle/src/ty/sty.rs
+++ b/compiler/rustc_middle/src/ty/sty.rs
@@ -17,7 +17,7 @@ use rustc_span::{DUMMY_SP, Span, Symbol, sym};
 use rustc_type_ir::TyKind::*;
 use rustc_type_ir::solve::SizedTraitKind;
 use rustc_type_ir::walk::TypeWalker;
-use rustc_type_ir::{self as ir, BoundVar, CollectAndApply, DynKind, TypeVisitableExt, elaborate};
+use rustc_type_ir::{self as ir, BoundVar, CollectAndApply, TypeVisitableExt, elaborate};
 use tracing::instrument;
 use ty::util::IntTypeExt;
 
@@ -734,7 +734,6 @@ impl<'tcx> Ty<'tcx> {
         tcx: TyCtxt<'tcx>,
         obj: &'tcx List<ty::PolyExistentialPredicate<'tcx>>,
         reg: ty::Region<'tcx>,
-        repr: DynKind,
     ) -> Ty<'tcx> {
         if cfg!(debug_assertions) {
             let projection_count = obj
@@ -767,7 +766,7 @@ impl<'tcx> Ty<'tcx> {
                 but it has {projection_count}"
             );
         }
-        Ty::new(tcx, Dynamic(obj, reg, repr))
+        Ty::new(tcx, Dynamic(obj, reg))
     }
 
     #[inline]
@@ -980,9 +979,8 @@ impl<'tcx> rustc_type_ir::inherent::Ty<TyCtxt<'tcx>> for Ty<'tcx> {
         interner: TyCtxt<'tcx>,
         preds: &'tcx List<ty::PolyExistentialPredicate<'tcx>>,
         region: ty::Region<'tcx>,
-        kind: ty::DynKind,
     ) -> Self {
-        Ty::new_dynamic(interner, preds, region, kind)
+        Ty::new_dynamic(interner, preds, region)
     }
 
     fn new_coroutine(
@@ -1356,7 +1354,7 @@ impl<'tcx> Ty<'tcx> {
 
     #[inline]
     pub fn is_trait(self) -> bool {
-        matches!(self.kind(), Dynamic(_, _, ty::Dyn))
+        matches!(self.kind(), Dynamic(_, _))
     }
 
     #[inline]
@@ -1671,7 +1669,7 @@ impl<'tcx> Ty<'tcx> {
 
             ty::Str | ty::Slice(_) => Ok(tcx.types.usize),
 
-            ty::Dynamic(_, _, ty::Dyn) => {
+            ty::Dynamic(_, _) => {
                 let dyn_metadata = tcx.require_lang_item(LangItem::DynMetadata, DUMMY_SP);
                 Ok(tcx.type_of(dyn_metadata).instantiate(tcx, &[tail.into()]))
             }
@@ -1853,7 +1851,7 @@ impl<'tcx> Ty<'tcx> {
             | ty::Never
             | ty::Error(_) => true,
 
-            ty::Str | ty::Slice(_) | ty::Dynamic(_, _, ty::Dyn) => match sizedness {
+            ty::Str | ty::Slice(_) | ty::Dynamic(_, _) => match sizedness {
                 SizedTraitKind::Sized => false,
                 SizedTraitKind::MetaSized => true,
             },
diff --git a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
index 48718cad597a8..18f41c8b97f64 100644
--- a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
+++ b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
@@ -152,7 +152,7 @@ impl<'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> MoveDataBuilder<'a, 'tcx, F> {
                     | ty::Slice(_)
                     | ty::FnDef(_, _)
                     | ty::FnPtr(..)
-                    | ty::Dynamic(_, _, _)
+                    | ty::Dynamic(_, _)
                     | ty::Closure(..)
                     | ty::CoroutineClosure(..)
                     | ty::Coroutine(_, _)
@@ -196,7 +196,7 @@ impl<'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> MoveDataBuilder<'a, 'tcx, F> {
                     | ty::Ref(_, _, _)
                     | ty::FnDef(_, _)
                     | ty::FnPtr(..)
-                    | ty::Dynamic(_, _, _)
+                    | ty::Dynamic(_, _)
                     | ty::CoroutineWitness(..)
                     | ty::Never
                     | ty::UnsafeBinder(_)
diff --git a/compiler/rustc_mir_transform/src/coroutine.rs b/compiler/rustc_mir_transform/src/coroutine.rs
index 4603c695dedd5..d3cc23818c7e1 100644
--- a/compiler/rustc_mir_transform/src/coroutine.rs
+++ b/compiler/rustc_mir_transform/src/coroutine.rs
@@ -1891,7 +1891,7 @@ fn check_must_not_suspend_ty<'tcx>(
             }
             has_emitted
         }
-        ty::Dynamic(binder, _, _) => {
+        ty::Dynamic(binder, _) => {
             let mut has_emitted = false;
             for predicate in binder.iter() {
                 if let ty::ExistentialPredicate::Trait(ref trait_ref) = predicate.skip_binder() {
diff --git a/compiler/rustc_next_trait_solver/src/canonicalizer.rs b/compiler/rustc_next_trait_solver/src/canonicalizer.rs
index a8f2b4e8db662..4b4ec4956eb88 100644
--- a/compiler/rustc_next_trait_solver/src/canonicalizer.rs
+++ b/compiler/rustc_next_trait_solver/src/canonicalizer.rs
@@ -390,7 +390,7 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
             | ty::FnDef(_, _)
             | ty::FnPtr(..)
             | ty::UnsafeBinder(_)
-            | ty::Dynamic(_, _, _)
+            | ty::Dynamic(_, _)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
             | ty::Coroutine(_, _)
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 fb777496e31eb..7de7870bbb12c 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
@@ -86,7 +86,7 @@ where
     ) -> Result<Candidate<I>, NoSolution> {
         Self::probe_and_match_goal_against_assumption(ecx, source, goal, assumption, |ecx| {
             let cx = ecx.cx();
-            let ty::Dynamic(bounds, _, _) = goal.predicate.self_ty().kind() else {
+            let ty::Dynamic(bounds, _) = goal.predicate.self_ty().kind() else {
                 panic!("expected object type in `probe_and_consider_object_bound_candidate`");
             };
             match structural_traits::predicates_for_object_candidate(
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 f6eab286ba70b..c40739d12e680 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
@@ -383,7 +383,7 @@ pub(in crate::solve) fn extract_tupled_inputs_and_output_from_callable<I: Intern
         | ty::Slice(_)
         | ty::RawPtr(_, _)
         | ty::Ref(_, _, _)
-        | ty::Dynamic(_, _, _)
+        | ty::Dynamic(_, _)
         | ty::Coroutine(_, _)
         | ty::CoroutineWitness(..)
         | ty::Never
@@ -557,7 +557,7 @@ pub(in crate::solve) fn extract_tupled_inputs_and_output_from_async_callable<I:
         | ty::Slice(_)
         | ty::RawPtr(_, _)
         | ty::Ref(_, _, _)
-        | ty::Dynamic(_, _, _)
+        | ty::Dynamic(_, _)
         | ty::Coroutine(_, _)
         | ty::CoroutineWitness(..)
         | ty::Never
@@ -706,7 +706,7 @@ pub(in crate::solve) fn extract_fn_def_from_const_callable<I: Interner>(
         | ty::Slice(_)
         | ty::RawPtr(_, _)
         | ty::Ref(_, _, _)
-        | ty::Dynamic(_, _, _)
+        | ty::Dynamic(_, _)
         | ty::Coroutine(_, _)
         | ty::CoroutineWitness(..)
         | ty::Never
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 54b92ebac1ded..653c59c5d4241 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
@@ -665,7 +665,7 @@ where
 
             ty::Str | ty::Slice(_) => Ty::new_usize(cx),
 
-            ty::Dynamic(_, _, ty::Dyn) => {
+            ty::Dynamic(_, _) => {
                 let dyn_metadata = cx.require_lang_item(SolverLangItem::DynMetadata);
                 cx.type_of(dyn_metadata)
                     .instantiate(cx, &[I::GenericArg::from(goal.predicate.self_ty())])
@@ -916,7 +916,7 @@ where
             | ty::Adt(_, _)
             | ty::Str
             | ty::Slice(_)
-            | ty::Dynamic(_, _, _)
+            | ty::Dynamic(_, _)
             | ty::Tuple(_)
             | ty::Error(_) => self_ty.discriminant_ty(ecx.cx()),
 
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 a69e867289cee..3974114e9b43c 100644
--- a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
@@ -817,15 +817,13 @@ where
                 }
 
                 // Trait upcasting, or `dyn Trait + Auto + 'a` -> `dyn Trait + 'b`.
-                (
-                    ty::Dynamic(a_data, a_region, ty::Dyn),
-                    ty::Dynamic(b_data, b_region, ty::Dyn),
-                ) => ecx.consider_builtin_dyn_upcast_candidates(
-                    goal, a_data, a_region, b_data, b_region,
-                ),
+                (ty::Dynamic(a_data, a_region), ty::Dynamic(b_data, b_region)) => ecx
+                    .consider_builtin_dyn_upcast_candidates(
+                        goal, a_data, a_region, b_data, b_region,
+                    ),
 
                 // `T` -> `dyn Trait` unsizing.
-                (_, ty::Dynamic(b_region, b_data, ty::Dyn)) => result_to_single(
+                (_, ty::Dynamic(b_region, b_data)) => result_to_single(
                     ecx.consider_builtin_unsize_to_dyn_candidate(goal, b_region, b_data),
                 ),
 
diff --git a/compiler/rustc_passes/src/check_export.rs b/compiler/rustc_passes/src/check_export.rs
index 6eded3a9eb9ac..fee920221e1d1 100644
--- a/compiler/rustc_passes/src/check_export.rs
+++ b/compiler/rustc_passes/src/check_export.rs
@@ -295,7 +295,7 @@ impl<'tcx, 'a> TypeVisitor<TyCtxt<'tcx>> for ExportableItemsChecker<'tcx, 'a> {
             | ty::Ref(_, _, _)
             | ty::Param(_)
             | ty::Closure(_, _)
-            | ty::Dynamic(_, _, _)
+            | ty::Dynamic(_, _)
             | ty::Coroutine(_, _)
             | ty::Foreign(_)
             | ty::Str
diff --git a/compiler/rustc_pattern_analysis/src/rustc.rs b/compiler/rustc_pattern_analysis/src/rustc.rs
index c9bf4fe4449b0..d9f8085083ebd 100644
--- a/compiler/rustc_pattern_analysis/src/rustc.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc.rs
@@ -407,7 +407,7 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
             | ty::FnDef(_, _)
             | ty::FnPtr(..)
             | ty::Pat(_, _)
-            | ty::Dynamic(_, _, _)
+            | ty::Dynamic(_, _)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
             | ty::Coroutine(_, _)
diff --git a/compiler/rustc_public/src/ty.rs b/compiler/rustc_public/src/ty.rs
index bcc77ff849da5..0afb94c18d7b9 100644
--- a/compiler/rustc_public/src/ty.rs
+++ b/compiler/rustc_public/src/ty.rs
@@ -333,7 +333,7 @@ impl TyKind {
 
     #[inline]
     pub fn is_trait(&self) -> bool {
-        matches!(self, TyKind::RigidTy(RigidTy::Dynamic(_, _, DynKind::Dyn)))
+        matches!(self, TyKind::RigidTy(RigidTy::Dynamic(_, _)))
     }
 
     #[inline]
@@ -472,7 +472,7 @@ impl TyKind {
     }
 
     pub fn trait_principal(&self) -> Option<Binder<ExistentialTraitRef>> {
-        if let TyKind::RigidTy(RigidTy::Dynamic(predicates, _, _)) = self {
+        if let TyKind::RigidTy(RigidTy::Dynamic(predicates, _)) = self {
             if let Some(Binder { value: ExistentialPredicate::Trait(trait_ref), bound_vars }) =
                 predicates.first()
             {
@@ -562,7 +562,7 @@ pub enum RigidTy {
     Closure(ClosureDef, GenericArgs),
     Coroutine(CoroutineDef, GenericArgs),
     CoroutineClosure(CoroutineClosureDef, GenericArgs),
-    Dynamic(Vec<Binder<ExistentialPredicate>>, Region, DynKind),
+    Dynamic(Vec<Binder<ExistentialPredicate>>, Region),
     Never,
     Tuple(Vec<Ty>),
     CoroutineWitness(CoroutineWitnessDef, GenericArgs),
@@ -1206,11 +1206,6 @@ pub enum BoundRegionKind {
     BrEnv,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum DynKind {
-    Dyn,
-}
-
 #[derive(Clone, Debug, Eq, PartialEq, Serialize)]
 pub enum ExistentialPredicate {
     Trait(ExistentialTraitRef),
diff --git a/compiler/rustc_public/src/unstable/convert/internal.rs b/compiler/rustc_public/src/unstable/convert/internal.rs
index 66f767a98f5bd..dc9abd88614d3 100644
--- a/compiler/rustc_public/src/unstable/convert/internal.rs
+++ b/compiler/rustc_public/src/unstable/convert/internal.rs
@@ -14,7 +14,7 @@ use crate::mir::alloc::AllocId;
 use crate::mir::mono::{Instance, MonoItem, StaticDef};
 use crate::mir::{BinOp, Mutability, Place, ProjectionElem, RawPtrKind, Safety, UnOp};
 use crate::ty::{
-    Abi, AdtDef, Binder, BoundRegionKind, BoundTyKind, BoundVariableKind, ClosureKind, DynKind,
+    Abi, AdtDef, Binder, BoundRegionKind, BoundTyKind, BoundVariableKind, ClosureKind,
     ExistentialPredicate, ExistentialProjection, ExistentialTraitRef, FloatTy, FnSig,
     GenericArgKind, GenericArgs, IntTy, MirConst, Movability, Pattern, Region, RigidTy, Span,
     TermKind, TraitRef, Ty, TyConst, UintTy, VariantDef, VariantIdx,
@@ -188,10 +188,9 @@ impl RustcInternal for RigidTy {
                 def.0.internal(tables, tcx),
                 args.internal(tables, tcx),
             ),
-            RigidTy::Dynamic(predicate, region, dyn_kind) => rustc_ty::TyKind::Dynamic(
+            RigidTy::Dynamic(predicate, region) => rustc_ty::TyKind::Dynamic(
                 tcx.mk_poly_existential_predicates(&predicate.internal(tables, tcx)),
                 region.internal(tables, tcx),
-                dyn_kind.internal(tables, tcx),
             ),
             RigidTy::Tuple(tys) => {
                 rustc_ty::TyKind::Tuple(tcx.mk_type_list(&tys.internal(tables, tcx)))
@@ -460,20 +459,6 @@ impl RustcInternal for BoundVariableKind {
     }
 }
 
-impl RustcInternal for DynKind {
-    type T<'tcx> = rustc_ty::DynKind;
-
-    fn internal<'tcx>(
-        &self,
-        _tables: &mut Tables<'_, BridgeTys>,
-        _tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        match self {
-            DynKind::Dyn => rustc_ty::DynKind::Dyn,
-        }
-    }
-}
-
 impl RustcInternal for ExistentialPredicate {
     type T<'tcx> = rustc_ty::ExistentialPredicate<'tcx>;
 
diff --git a/compiler/rustc_public/src/unstable/convert/stable/ty.rs b/compiler/rustc_public/src/unstable/convert/stable/ty.rs
index 5131611eb02b3..7f14f878d3737 100644
--- a/compiler/rustc_public/src/unstable/convert/stable/ty.rs
+++ b/compiler/rustc_public/src/unstable/convert/stable/ty.rs
@@ -48,16 +48,6 @@ impl<'tcx> Stable<'tcx> for ty::AliasTerm<'tcx> {
     }
 }
 
-impl<'tcx> Stable<'tcx> for ty::DynKind {
-    type T = crate::ty::DynKind;
-
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
-        match self {
-            ty::Dyn => crate::ty::DynKind::Dyn,
-        }
-    }
-}
-
 impl<'tcx> Stable<'tcx> for ty::ExistentialPredicate<'tcx> {
     type T = crate::ty::ExistentialPredicate;
 
@@ -439,16 +429,13 @@ impl<'tcx> Stable<'tcx> for ty::TyKind<'tcx> {
             }
             // FIXME(unsafe_binders):
             ty::UnsafeBinder(_) => todo!(),
-            ty::Dynamic(existential_predicates, region, dyn_kind) => {
-                TyKind::RigidTy(RigidTy::Dynamic(
-                    existential_predicates
-                        .iter()
-                        .map(|existential_predicate| existential_predicate.stable(tables, cx))
-                        .collect(),
-                    region.stable(tables, cx),
-                    dyn_kind.stable(tables, cx),
-                ))
-            }
+            ty::Dynamic(existential_predicates, region) => TyKind::RigidTy(RigidTy::Dynamic(
+                existential_predicates
+                    .iter()
+                    .map(|existential_predicate| existential_predicate.stable(tables, cx))
+                    .collect(),
+                region.stable(tables, cx),
+            )),
             ty::Closure(def_id, generic_args) => TyKind::RigidTy(RigidTy::Closure(
                 tables.closure_def(*def_id),
                 generic_args.stable(tables, cx),
diff --git a/compiler/rustc_public/src/visitor.rs b/compiler/rustc_public/src/visitor.rs
index 87f1cc6ae69d8..acc3334769613 100644
--- a/compiler/rustc_public/src/visitor.rs
+++ b/compiler/rustc_public/src/visitor.rs
@@ -171,7 +171,7 @@ impl Visitable for RigidTy {
             | RigidTy::CoroutineClosure(_, args)
             | RigidTy::FnDef(_, args) => args.visit(visitor),
             RigidTy::FnPtr(sig) => sig.visit(visitor),
-            RigidTy::Dynamic(pred, r, _) => {
+            RigidTy::Dynamic(pred, r) => {
                 pred.visit(visitor)?;
                 r.visit(visitor)
             }
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 f4a14b36ce5cf..ec7a4a81a71aa 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
@@ -626,12 +626,10 @@ pub(crate) fn encode_ty<'tcx>(
         }
 
         // Trait types
-        ty::Dynamic(predicates, region, kind) => {
+        ty::Dynamic(predicates, region) => {
             // u3dynI<element-type1[..element-typeN]>E, where <element-type> is <predicate>, as
             // vendor extended type.
-            let mut s = String::from(match kind {
-                ty::Dyn => "u3dynI",
-            });
+            let mut s = String::from("u3dynI");
             s.push_str(&encode_predicates(tcx, predicates, dict, options));
             s.push_str(&encode_region(*region, dict));
             s.push('E');
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 577a16a0d2573..82a2a64f23078 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
@@ -268,7 +268,7 @@ fn trait_object_ty<'tcx>(tcx: TyCtxt<'tcx>, poly_trait_ref: ty::PolyTraitRef<'tc
     let preds = tcx.mk_poly_existential_predicates_from_iter(
         iter::once(principal_pred).chain(assoc_preds.into_iter()),
     );
-    Ty::new_dynamic(tcx, preds, tcx.lifetimes.re_erased, ty::Dyn)
+    Ty::new_dynamic(tcx, preds, tcx.lifetimes.re_erased)
 }
 
 /// Transforms an instance for LLVM CFI and cross-language LLVM CFI support using Itanium C++ ABI
@@ -334,7 +334,7 @@ pub(crate) fn transform_instance<'tcx>(
             ty::List::empty(),
         ));
         let predicates = tcx.mk_poly_existential_predicates(&[ty::Binder::dummy(predicate)]);
-        let self_ty = Ty::new_dynamic(tcx, predicates, tcx.lifetimes.re_erased, ty::Dyn);
+        let self_ty = Ty::new_dynamic(tcx, predicates, tcx.lifetimes.re_erased);
         instance.args = tcx.mk_args_trait(self_ty, List::empty());
     } else if let ty::InstanceKind::Virtual(def_id, _) = instance.def {
         // Transform self into a trait object of the trait that defines the method for virtual
@@ -347,7 +347,7 @@ pub(crate) fn transform_instance<'tcx>(
             // drop_in_place won't have a defining trait, skip the upcast
             None => instance.args.type_at(0),
         };
-        let ty::Dynamic(preds, lifetime, kind) = upcast_ty.kind() else {
+        let ty::Dynamic(preds, lifetime) = upcast_ty.kind() else {
             bug!("Tried to remove autotraits from non-dynamic type {upcast_ty}");
         };
         let self_ty = if preds.principal().is_some() {
@@ -355,7 +355,7 @@ pub(crate) fn transform_instance<'tcx>(
                 tcx.mk_poly_existential_predicates_from_iter(preds.into_iter().filter(|pred| {
                     !matches!(pred.skip_binder(), ty::ExistentialPredicate::AutoTrait(..))
                 }));
-            Ty::new_dynamic(tcx, filtered_preds, *lifetime, *kind)
+            Ty::new_dynamic(tcx, filtered_preds, *lifetime)
         } else {
             // If there's no principal type, re-encode it as a unit, since we don't know anything
             // about it. This technically discards the knowledge that it was a type that was made
diff --git a/compiler/rustc_symbol_mangling/src/export.rs b/compiler/rustc_symbol_mangling/src/export.rs
index 76ac82cf95a12..3896e06a627b7 100644
--- a/compiler/rustc_symbol_mangling/src/export.rs
+++ b/compiler/rustc_symbol_mangling/src/export.rs
@@ -110,7 +110,7 @@ impl<'tcx> AbiHashStable<'tcx> for Ty<'tcx> {
             | ty::RawPtr(_, _)
             | ty::FnDef(_, _)
             | ty::FnPtr(_, _)
-            | ty::Dynamic(_, _, _)
+            | ty::Dynamic(_, _)
             | ty::Closure(_, _)
             | ty::CoroutineClosure(_, _)
             | ty::Coroutine(_, _)
diff --git a/compiler/rustc_symbol_mangling/src/v0.rs b/compiler/rustc_symbol_mangling/src/v0.rs
index 1605b4958ba3d..9fa7e2f100393 100644
--- a/compiler/rustc_symbol_mangling/src/v0.rs
+++ b/compiler/rustc_symbol_mangling/src/v0.rs
@@ -577,10 +577,8 @@ impl<'tcx> Printer<'tcx> for V0SymbolMangler<'tcx> {
             // FIXME(unsafe_binder):
             ty::UnsafeBinder(..) => todo!(),
 
-            ty::Dynamic(predicates, r, kind) => {
-                self.push(match kind {
-                    ty::Dyn => "D",
-                });
+            ty::Dynamic(predicates, r) => {
+                self.push("D");
                 self.print_dyn_existential(predicates)?;
                 r.print(self)?;
             }
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/static_impl_trait.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/static_impl_trait.rs
index 3edc365c886ea..5b8315841765b 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/static_impl_trait.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/static_impl_trait.rs
@@ -399,7 +399,7 @@ pub struct TraitObjectVisitor(pub FxIndexSet<DefId>);
 impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for TraitObjectVisitor {
     fn visit_ty(&mut self, t: Ty<'tcx>) {
         match t.kind() {
-            ty::Dynamic(preds, re, _) if re.is_static() => {
+            ty::Dynamic(preds, re) if re.is_static() => {
                 if let Some(def_id) = preds.principal_def_id() {
                     self.0.insert(def_id);
                 }
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 f997842a607f6..b0b858aa270c1 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
@@ -292,7 +292,7 @@ impl<T> Trait<T> for X {
                             );
                         }
                     }
-                    (ty::Dynamic(t, _, ty::DynKind::Dyn), ty::Alias(ty::Opaque, alias))
+                    (ty::Dynamic(t, _), ty::Alias(ty::Opaque, alias))
                         if let Some(def_id) = t.principal_def_id()
                             && tcx
                                 .explicit_item_self_bounds(alias.def_id)
@@ -314,9 +314,7 @@ impl<T> Trait<T> for X {
                             values.found, values.expected,
                         ));
                     }
-                    (ty::Dynamic(t, _, ty::DynKind::Dyn), _)
-                        if let Some(def_id) = t.principal_def_id() =>
-                    {
+                    (ty::Dynamic(t, _), _) if let Some(def_id) = t.principal_def_id() => {
                         let mut has_matching_impl = false;
                         tcx.for_each_relevant_impl(def_id, values.found, |did| {
                             if DeepRejectCtxt::relate_rigid_infer(tcx)
@@ -335,9 +333,7 @@ impl<T> Trait<T> for X {
                             ));
                         }
                     }
-                    (_, ty::Dynamic(t, _, ty::DynKind::Dyn))
-                        if let Some(def_id) = t.principal_def_id() =>
-                    {
+                    (_, ty::Dynamic(t, _)) if let Some(def_id) = t.principal_def_id() => {
                         let mut has_matching_impl = false;
                         tcx.for_each_relevant_impl(def_id, values.expected, |did| {
                             if DeepRejectCtxt::relate_rigid_infer(tcx)
@@ -489,7 +485,7 @@ impl<T> Trait<T> for X {
                             && let Some(then) = blk.expr
                             && def.is_box()
                             && let boxed_ty = args.type_at(0)
-                            && let ty::Dynamic(t, _, _) = boxed_ty.kind()
+                            && let ty::Dynamic(t, _) = boxed_ty.kind()
                             && let Some(def_id) = t.principal_def_id()
                             && let mut impl_def_ids = vec![]
                             && let _ =
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 518d4fe17e8f4..9a8ccea3aca87 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/region.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/region.rs
@@ -430,7 +430,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 let mut alt_span = None;
                 if let Some(ty) = ty
                     && sub.is_static()
-                    && let ty::Dynamic(preds, _, ty::DynKind::Dyn) = ty.kind()
+                    && let ty::Dynamic(preds, _) = ty.kind()
                     && let Some(def_id) = preds.principal_def_id()
                 {
                     for (clause, span) in
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/mod.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/mod.rs
index f794ff632c592..b3d1b8e3888a1 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/mod.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/mod.rs
@@ -554,7 +554,7 @@ fn attempt_dyn_to_enum_suggestion(
             // defaults to assuming that things are *not* sized, whereas we want to
             // fall back to assuming that things may be sized.
             match impl_type.kind() {
-                ty::Str | ty::Slice(_) | ty::Dynamic(_, _, ty::DynKind::Dyn) => {
+                ty::Str | ty::Slice(_) | ty::Dynamic(_, _) => {
                     return None;
                 }
                 _ => {}
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/on_unimplemented.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/on_unimplemented.rs
index bb5c6469f34b4..00c123981e1c0 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/on_unimplemented.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/on_unimplemented.rs
@@ -237,7 +237,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
                     }
                 }
             }
-            if let ty::Dynamic(traits, _, _) = self_ty.kind() {
+            if let ty::Dynamic(traits, _) = self_ty.kind() {
                 for t in traits.iter() {
                     if let ty::ExistentialPredicate::Trait(trait_ref) = t.skip_binder() {
                         self_types.push(self.tcx.def_path_str(trait_ref.def_id));
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 f2f840581cf02..37e622102e70f 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -1131,7 +1131,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         },
                     )
                 }
-                ty::Dynamic(data, _, ty::Dyn) => data.iter().find_map(|pred| {
+                ty::Dynamic(data, _) => data.iter().find_map(|pred| {
                     if let ty::ExistentialPredicate::Projection(proj) = pred.skip_binder()
                         && self.tcx.is_lang_item(proj.def_id, LangItem::FnOnceOutput)
                         // for existential projection, args are shifted over by 1
@@ -1520,7 +1520,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         let ty::Ref(_, object_ty, hir::Mutability::Not) = target_ty.kind() else {
             return;
         };
-        let ty::Dynamic(predicates, _, ty::Dyn) = object_ty.kind() else {
+        let ty::Dynamic(predicates, _) = object_ty.kind() else {
             return;
         };
         let self_ref_ty = Ty::new_imm_ref(self.tcx, self.tcx.lifetimes.re_erased, self_ty);
@@ -1883,7 +1883,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         let ObligationCauseCode::SizedReturnType = obligation.cause.code() else {
             return false;
         };
-        let ty::Dynamic(_, _, ty::Dyn) = trait_pred.self_ty().skip_binder().kind() else {
+        let ty::Dynamic(_, _) = trait_pred.self_ty().skip_binder().kind() else {
             return 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 62795c8a3a686..60f1fcb26c004 100644
--- a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
@@ -669,7 +669,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
 
                 // These may potentially implement `FnPtr`
                 ty::Placeholder(..)
-                | ty::Dynamic(_, _, _)
+                | ty::Dynamic(_, _)
                 | ty::Alias(_, _)
                 | ty::Infer(_)
                 | ty::Param(..)
@@ -991,7 +991,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
 
         match (source.kind(), target.kind()) {
             // Trait+Kx+'a -> Trait+Ky+'b (upcasts).
-            (&ty::Dynamic(a_data, a_region, ty::Dyn), &ty::Dynamic(b_data, b_region, ty::Dyn)) => {
+            (&ty::Dynamic(a_data, a_region), &ty::Dynamic(b_data, b_region)) => {
                 // Upcast coercions permit several things:
                 //
                 // 1. Dropping auto traits, e.g., `Foo + Send` to `Foo`
@@ -1054,7 +1054,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             }
 
             // `T` -> `Trait`
-            (_, &ty::Dynamic(_, _, ty::Dyn)) => {
+            (_, &ty::Dynamic(_, _)) => {
                 candidates.vec.push(BuiltinUnsizeCandidate);
             }
 
@@ -1327,7 +1327,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             | ty::Pat(_, _)
             | ty::FnPtr(..)
             | ty::UnsafeBinder(_)
-            | ty::Dynamic(_, _, _)
+            | ty::Dynamic(_, _)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
             | ty::Coroutine(_, _)
diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
index 488094b15ac60..7ad65a1df8e9b 100644
--- a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
@@ -1023,10 +1023,10 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         let a_ty = self.infcx.shallow_resolve(predicate.self_ty());
         let b_ty = self.infcx.shallow_resolve(predicate.trait_ref.args.type_at(1));
 
-        let ty::Dynamic(a_data, a_region, ty::Dyn) = *a_ty.kind() else {
+        let ty::Dynamic(a_data, a_region) = *a_ty.kind() else {
             bug!("expected `dyn` type in `confirm_trait_upcasting_unsize_candidate`")
         };
-        let ty::Dynamic(b_data, b_region, ty::Dyn) = *b_ty.kind() else {
+        let ty::Dynamic(b_data, b_region) = *b_ty.kind() else {
             bug!("expected `dyn` type in `confirm_trait_upcasting_unsize_candidate`")
         };
 
@@ -1062,10 +1062,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         debug!(?source, ?target, "confirm_builtin_unsize_candidate");
 
         Ok(match (source.kind(), target.kind()) {
-            // Trait+Kx+'a -> Trait+Ky+'b (auto traits and lifetime subtyping).
-            (&ty::Dynamic(data_a, r_a, dyn_a), &ty::Dynamic(data_b, r_b, dyn_b))
-                if dyn_a == dyn_b =>
-            {
+            // `dyn Trait + Kx + 'a` -> `dyn Trait + Ky + 'b` (auto traits and lifetime subtyping).
+            (&ty::Dynamic(data_a, r_a), &ty::Dynamic(data_b, r_b)) => {
                 // See `assemble_candidates_for_unsizing` for more info.
                 // We already checked the compatibility of auto traits within `assemble_candidates_for_unsizing`.
                 let existential_predicates = if data_b.principal().is_some() {
@@ -1098,7 +1096,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                             .map(ty::Binder::dummy),
                     )
                 };
-                let source_trait = Ty::new_dynamic(tcx, existential_predicates, r_b, dyn_a);
+                let source_trait = Ty::new_dynamic(tcx, existential_predicates, r_b);
 
                 // Require that the traits involved in this upcast are **equal**;
                 // only the **lifetime bound** is changed.
@@ -1122,7 +1120,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             }
 
             // `T` -> `dyn Trait`
-            (_, &ty::Dynamic(data, r, ty::Dyn)) => {
+            (_, &ty::Dynamic(data, r)) => {
                 let mut object_dids = data.auto_traits().chain(data.principal_def_id());
                 if let Some(did) = object_dids.find(|did| !tcx.is_dyn_compatible(*did)) {
                     return Err(SelectionError::TraitDynIncompatible(did));
diff --git a/compiler/rustc_trait_selection/src/traits/vtable.rs b/compiler/rustc_trait_selection/src/traits/vtable.rs
index 7e8a41457d411..584c8e2a27c82 100644
--- a/compiler/rustc_trait_selection/src/traits/vtable.rs
+++ b/compiler/rustc_trait_selection/src/traits/vtable.rs
@@ -317,7 +317,7 @@ pub(crate) fn first_method_vtable_slot<'tcx>(tcx: TyCtxt<'tcx>, key: ty::TraitRe
         "vtable trait ref should be normalized"
     );
 
-    let ty::Dynamic(source, _, _) = *key.self_ty().kind() else {
+    let ty::Dynamic(source, _) = *key.self_ty().kind() else {
         bug!();
     };
     let source_principal = tcx.instantiate_bound_regions_with_erased(
@@ -384,13 +384,13 @@ pub(crate) fn supertrait_vtable_slot<'tcx>(
     let (source, target) = key;
 
     // If the target principal is `None`, we can just return `None`.
-    let ty::Dynamic(target_data, _, _) = *target.kind() else {
+    let ty::Dynamic(target_data, _) = *target.kind() else {
         bug!();
     };
     let target_principal = tcx.instantiate_bound_regions_with_erased(target_data.principal()?);
 
     // Given that we have a target principal, it is a bug for there not to be a source principal.
-    let ty::Dynamic(source_data, _, _) = *source.kind() else {
+    let ty::Dynamic(source_data, _) = *source.kind() else {
         bug!();
     };
     let source_principal = tcx.instantiate_bound_regions_with_erased(
diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs
index adce9850b594c..45cbb56b1c2ef 100644
--- a/compiler/rustc_trait_selection/src/traits/wf.rs
+++ b/compiler/rustc_trait_selection/src/traits/wf.rs
@@ -915,7 +915,7 @@ impl<'a, 'tcx> TypeVisitor<TyCtxt<'tcx>> for WfPredicates<'a, 'tcx> {
                 // We recurse into the binder below.
             }
 
-            ty::Dynamic(data, r, _) => {
+            ty::Dynamic(data, r) => {
                 // WfObject
                 //
                 // Here, we defer WF checking due to higher-ranked
diff --git a/compiler/rustc_ty_utils/src/layout.rs b/compiler/rustc_ty_utils/src/layout.rs
index 79f7e228e2adc..643e3db8f83fe 100644
--- a/compiler/rustc_ty_utils/src/layout.rs
+++ b/compiler/rustc_ty_utils/src/layout.rs
@@ -476,7 +476,7 @@ fn layout_of_uncached<'tcx>(
         }
 
         // Odd unit types.
-        ty::FnDef(..) | ty::Dynamic(_, _, ty::Dyn) | ty::Foreign(..) => {
+        ty::FnDef(..) | ty::Dynamic(_, _) | ty::Foreign(..) => {
             let sized = matches!(ty.kind(), ty::FnDef(..));
             tcx.mk_layout(LayoutData::unit(cx, sized))
         }
diff --git a/compiler/rustc_ty_utils/src/ty.rs b/compiler/rustc_ty_utils/src/ty.rs
index a5987757dc34d..18a9a7c22d9dd 100644
--- a/compiler/rustc_ty_utils/src/ty.rs
+++ b/compiler/rustc_ty_utils/src/ty.rs
@@ -40,7 +40,7 @@ fn sizedness_constraint_for_ty<'tcx>(
         | ty::CoroutineWitness(..)
         | ty::Never => None,
 
-        ty::Str | ty::Slice(..) | ty::Dynamic(_, _, ty::Dyn) => match sizedness {
+        ty::Str | ty::Slice(..) | ty::Dynamic(_, _) => match sizedness {
             // Never `Sized`
             SizedTraitKind::Sized => Some(ty),
             // Always `MetaSized`
@@ -366,7 +366,7 @@ fn impl_self_is_guaranteed_unsized<'tcx>(tcx: TyCtxt<'tcx>, impl_def_id: DefId)
     );
 
     match tail.kind() {
-        ty::Dynamic(_, _, ty::Dyn) | ty::Slice(_) | ty::Str => true,
+        ty::Dynamic(_, _) | ty::Slice(_) | ty::Str => true,
         ty::Bool
         | ty::Char
         | ty::Int(_)
diff --git a/compiler/rustc_type_ir/src/flags.rs b/compiler/rustc_type_ir/src/flags.rs
index 23b7f55fbbe53..24704c5bb5358 100644
--- a/compiler/rustc_type_ir/src/flags.rs
+++ b/compiler/rustc_type_ir/src/flags.rs
@@ -288,7 +288,7 @@ impl<I: Interner> FlagComputation<I> {
                 self.add_alias_ty(data);
             }
 
-            ty::Dynamic(obj, r, _) => {
+            ty::Dynamic(obj, r) => {
                 for predicate in obj.iter() {
                     self.bound_computation(predicate, |computation, predicate| match predicate {
                         ty::ExistentialPredicate::Trait(tr) => {
diff --git a/compiler/rustc_type_ir/src/inherent.rs b/compiler/rustc_type_ir/src/inherent.rs
index ecfc05a6e20e7..b5b552dbaec09 100644
--- a/compiler/rustc_type_ir/src/inherent.rs
+++ b/compiler/rustc_type_ir/src/inherent.rs
@@ -76,12 +76,7 @@ pub trait Ty<I: Interner<Ty = Self>>:
 
     fn new_foreign(interner: I, def_id: I::ForeignId) -> Self;
 
-    fn new_dynamic(
-        interner: I,
-        preds: I::BoundExistentialPredicates,
-        region: I::Region,
-        kind: ty::DynKind,
-    ) -> Self;
+    fn new_dynamic(interner: I, preds: I::BoundExistentialPredicates, region: I::Region) -> Self;
 
     fn new_coroutine(interner: I, def_id: I::CoroutineId, args: I::GenericArgs) -> Self;
 
@@ -167,7 +162,7 @@ pub trait Ty<I: Interner<Ty = Self>>:
 
     fn is_guaranteed_unsized_raw(self) -> bool {
         match self.kind() {
-            ty::Dynamic(_, _, ty::Dyn) | ty::Slice(_) | ty::Str => true,
+            ty::Dynamic(_, _) | ty::Slice(_) | ty::Str => true,
             ty::Bool
             | ty::Char
             | ty::Int(_)
diff --git a/compiler/rustc_type_ir/src/lib.rs b/compiler/rustc_type_ir/src/lib.rs
index 50b588029aed9..61e0b67b1639d 100644
--- a/compiler/rustc_type_ir/src/lib.rs
+++ b/compiler/rustc_type_ir/src/lib.rs
@@ -57,7 +57,6 @@ mod upcast;
 mod visit;
 
 pub use AliasTyKind::*;
-pub use DynKind::*;
 pub use InferTy::*;
 pub use RegionKind::*;
 pub use TyKind::*;
diff --git a/compiler/rustc_type_ir/src/outlives.rs b/compiler/rustc_type_ir/src/outlives.rs
index b09a378d34143..c7dccea6adc12 100644
--- a/compiler/rustc_type_ir/src/outlives.rs
+++ b/compiler/rustc_type_ir/src/outlives.rs
@@ -203,7 +203,7 @@ impl<I: Interner> TypeVisitor<I> for OutlivesCollector<'_, I> {
             | ty::Ref(_, _, _)
             | ty::FnPtr(..)
             | ty::UnsafeBinder(_)
-            | ty::Dynamic(_, _, _)
+            | 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 690a5f65e0848..09add529286d9 100644
--- a/compiler/rustc_type_ir/src/relate.rs
+++ b/compiler/rustc_type_ir/src/relate.rs
@@ -412,16 +412,11 @@ pub fn structurally_relate_tys<I: Interner, R: TypeRelation<I>>(
 
         (ty::Foreign(a_id), ty::Foreign(b_id)) if a_id == b_id => Ok(Ty::new_foreign(cx, a_id)),
 
-        (ty::Dynamic(a_obj, a_region, a_repr), ty::Dynamic(b_obj, b_region, b_repr))
-            if a_repr == b_repr =>
-        {
-            Ok(Ty::new_dynamic(
-                cx,
-                relation.relate(a_obj, b_obj)?,
-                relation.relate(a_region, b_region)?,
-                a_repr,
-            ))
-        }
+        (ty::Dynamic(a_obj, a_region), ty::Dynamic(b_obj, b_region)) => Ok(Ty::new_dynamic(
+            cx,
+            relation.relate(a_obj, b_obj)?,
+            relation.relate(a_region, b_region)?,
+        )),
 
         (ty::Coroutine(a_id, a_args), ty::Coroutine(b_id, b_args)) if a_id == b_id => {
             // All Coroutine types with the same id represent
diff --git a/compiler/rustc_type_ir/src/ty_kind.rs b/compiler/rustc_type_ir/src/ty_kind.rs
index 225d85f79c3d1..dda59283677cd 100644
--- a/compiler/rustc_type_ir/src/ty_kind.rs
+++ b/compiler/rustc_type_ir/src/ty_kind.rs
@@ -19,20 +19,6 @@ use crate::{self as ty, DebruijnIndex, FloatTy, IntTy, Interner, UintTy};
 
 mod closure;
 
-/// Specifies how a trait object is represented.
-///
-/// This used to have a variant `DynStar`, but that variant has been removed,
-/// and it's likely this whole enum will be removed soon.
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
-#[cfg_attr(
-    feature = "nightly",
-    derive(Encodable_NoContext, Decodable_NoContext, HashStable_NoContext)
-)]
-pub enum DynKind {
-    /// An unsized `dyn Trait` object
-    Dyn,
-}
-
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
 #[cfg_attr(
     feature = "nightly",
@@ -165,7 +151,7 @@ pub enum TyKind<I: Interner> {
     UnsafeBinder(UnsafeBinderInner<I>),
 
     /// A trait object. Written as `dyn for<'b> Trait<'b, Assoc = u32> + Send + 'a`.
-    Dynamic(I::BoundExistentialPredicates, I::Region, DynKind),
+    Dynamic(I::BoundExistentialPredicates, I::Region),
 
     /// The anonymous type of a closure. Used to represent the type of `|a| a`.
     ///
@@ -314,7 +300,7 @@ impl<I: Interner> TyKind<I> {
             | ty::FnDef(_, _)
             | ty::FnPtr(..)
             | ty::UnsafeBinder(_)
-            | ty::Dynamic(_, _, _)
+            | ty::Dynamic(_, _)
             | ty::Closure(_, _)
             | ty::CoroutineClosure(_, _)
             | ty::Coroutine(_, _)
@@ -367,9 +353,7 @@ impl<I: Interner> fmt::Debug for TyKind<I> {
             FnPtr(sig_tys, hdr) => write!(f, "{:?}", sig_tys.with(*hdr)),
             // FIXME(unsafe_binder): print this like `unsafe<'a> T<'a>`.
             UnsafeBinder(binder) => write!(f, "{:?}", binder),
-            Dynamic(p, r, repr) => match repr {
-                DynKind::Dyn => write!(f, "dyn {p:?} + {r:?}"),
-            },
+            Dynamic(p, r) => write!(f, "dyn {p:?} + {r:?}"),
             Closure(d, s) => f.debug_tuple("Closure").field(d).field(&s).finish(),
             CoroutineClosure(d, s) => f.debug_tuple("CoroutineClosure").field(d).field(&s).finish(),
             Coroutine(d, s) => f.debug_tuple("Coroutine").field(d).field(&s).finish(),
diff --git a/compiler/rustc_type_ir/src/walk.rs b/compiler/rustc_type_ir/src/walk.rs
index 9912fad1756ea..6d51817a7bf44 100644
--- a/compiler/rustc_type_ir/src/walk.rs
+++ b/compiler/rustc_type_ir/src/walk.rs
@@ -109,7 +109,7 @@ fn push_inner<I: Interner>(stack: &mut TypeWalkerStack<I>, parent: I::GenericArg
             ty::Alias(_, data) => {
                 stack.extend(data.args.iter().rev());
             }
-            ty::Dynamic(obj, lt, _) => {
+            ty::Dynamic(obj, lt) => {
                 stack.push(lt.into());
                 stack.extend(
                     obj.iter()
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 5ccacafea0158..0afb969d5c84f 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -2093,7 +2093,7 @@ pub(crate) fn clean_middle_ty<'tcx>(
             );
             Type::Path { path }
         }
-        ty::Dynamic(obj, reg, _) => {
+        ty::Dynamic(obj, reg) => {
             // HACK: pick the first `did` as the `did` of the trait object. Someone
             // might want to implement "native" support for marker-trait-only
             // trait objects.
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 68f0b5ea25589..ac87e21b82f15 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
@@ -86,7 +86,7 @@ fn check_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, span: Span, msrv: Msrv)
             ty::FnPtr(..) => {
                 return Err((span, "function pointers in const fn are unstable".into()));
             },
-            ty::Dynamic(preds, _, _) => {
+            ty::Dynamic(preds, _) => {
                 for pred in *preds {
                     match pred.skip_binder() {
                         ty::ExistentialPredicate::AutoTrait(_) | ty::ExistentialPredicate::Projection(_) => {
diff --git a/src/tools/clippy/clippy_utils/src/ty/mod.rs b/src/tools/clippy/clippy_utils/src/ty/mod.rs
index 9f77a1c4d9b62..3e41bce1dc4ce 100644
--- a/src/tools/clippy/clippy_utils/src/ty/mod.rs
+++ b/src/tools/clippy/clippy_utils/src/ty/mod.rs
@@ -349,7 +349,7 @@ pub fn is_must_use_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
             }
             false
         },
-        ty::Dynamic(binder, _, _) => {
+        ty::Dynamic(binder, _) => {
             for predicate in *binder {
                 if let ty::ExistentialPredicate::Trait(ref trait_ref) = predicate.skip_binder()
                     && find_attr!(cx.tcx.get_all_attrs(trait_ref.def_id), AttributeKind::MustUse { .. })
@@ -673,7 +673,7 @@ pub fn ty_sig<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<ExprFnSig<'t
             cx.tcx.opt_parent(def_id),
         ),
         ty::FnPtr(sig_tys, hdr) => Some(ExprFnSig::Sig(sig_tys.with(hdr), None)),
-        ty::Dynamic(bounds, _, _) => {
+        ty::Dynamic(bounds, _) => {
             let lang_items = cx.tcx.lang_items();
             match bounds.principal() {
                 Some(bound)

From 4d931e643af306eeabc417957975271879b68c50 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Wed, 17 Sep 2025 04:16:47 +0200
Subject: [PATCH 1031/1889] Remove `DynKind`

---
 clippy_utils/src/qualify_min_const_fn.rs | 2 +-
 clippy_utils/src/ty/mod.rs               | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/clippy_utils/src/qualify_min_const_fn.rs b/clippy_utils/src/qualify_min_const_fn.rs
index 68f0b5ea25589..ac87e21b82f15 100644
--- a/clippy_utils/src/qualify_min_const_fn.rs
+++ b/clippy_utils/src/qualify_min_const_fn.rs
@@ -86,7 +86,7 @@ fn check_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, span: Span, msrv: Msrv)
             ty::FnPtr(..) => {
                 return Err((span, "function pointers in const fn are unstable".into()));
             },
-            ty::Dynamic(preds, _, _) => {
+            ty::Dynamic(preds, _) => {
                 for pred in *preds {
                     match pred.skip_binder() {
                         ty::ExistentialPredicate::AutoTrait(_) | ty::ExistentialPredicate::Projection(_) => {
diff --git a/clippy_utils/src/ty/mod.rs b/clippy_utils/src/ty/mod.rs
index 9f77a1c4d9b62..3e41bce1dc4ce 100644
--- a/clippy_utils/src/ty/mod.rs
+++ b/clippy_utils/src/ty/mod.rs
@@ -349,7 +349,7 @@ pub fn is_must_use_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
             }
             false
         },
-        ty::Dynamic(binder, _, _) => {
+        ty::Dynamic(binder, _) => {
             for predicate in *binder {
                 if let ty::ExistentialPredicate::Trait(ref trait_ref) = predicate.skip_binder()
                     && find_attr!(cx.tcx.get_all_attrs(trait_ref.def_id), AttributeKind::MustUse { .. })
@@ -673,7 +673,7 @@ pub fn ty_sig<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<ExprFnSig<'t
             cx.tcx.opt_parent(def_id),
         ),
         ty::FnPtr(sig_tys, hdr) => Some(ExprFnSig::Sig(sig_tys.with(hdr), None)),
-        ty::Dynamic(bounds, _, _) => {
+        ty::Dynamic(bounds, _) => {
             let lang_items = cx.tcx.lang_items();
             match bounds.principal() {
                 Some(bound)

From 34062b124f00eb7c35da2e3981cfb5b45dd26039 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Wed, 17 Sep 2025 05:34:19 +0200
Subject: [PATCH 1032/1889] Merge modules dyn_compatibility and lint into
 dyn_trait

---
 .../{dyn_compatibility.rs => dyn_trait.rs}    | 553 +++++++++++++++++-
 .../src/hir_ty_lowering/lint.rs               | 533 -----------------
 .../src/hir_ty_lowering/mod.rs                |  14 +-
 3 files changed, 550 insertions(+), 550 deletions(-)
 rename compiler/rustc_hir_analysis/src/hir_ty_lowering/{dyn_compatibility.rs => dyn_trait.rs} (51%)
 delete mode 100644 compiler/rustc_hir_analysis/src/hir_ty_lowering/lint.rs

diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_compatibility.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_trait.rs
similarity index 51%
rename from compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_compatibility.rs
rename to compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_trait.rs
index c823a4a0430f4..c248cd7fec2e5 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_compatibility.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_trait.rs
@@ -1,16 +1,22 @@
+use rustc_ast::TraitObjectSyntax;
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_errors::codes::*;
-use rustc_errors::struct_span_code_err;
+use rustc_errors::{
+    Applicability, Diag, EmissionGuarantee, StashKey, Suggestions, struct_span_code_err,
+};
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
-use rustc_lint_defs::builtin::UNUSED_ASSOCIATED_TYPE_BOUNDS;
+use rustc_hir::def_id::DefId;
+use rustc_lint_defs::builtin::{BARE_TRAIT_OBJECTS, UNUSED_ASSOCIATED_TYPE_BOUNDS};
 use rustc_middle::ty::elaborate::ClauseWithSupertraitSpan;
 use rustc_middle::ty::{
     self, BottomUpFolder, ExistentialPredicateStableCmpExt as _, Ty, TyCtxt, TypeFoldable,
     TypeVisitableExt, Upcast,
 };
+use rustc_span::edit_distance::find_best_match_for_name;
 use rustc_span::{ErrorGuaranteed, Span};
 use rustc_trait_selection::error_reporting::traits::report_dyn_incompatibility;
+use rustc_trait_selection::error_reporting::traits::suggestions::NextTypeParamName;
 use rustc_trait_selection::traits;
 use smallvec::{SmallVec, smallvec};
 use tracing::{debug, instrument};
@@ -28,10 +34,24 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         hir_id: hir::HirId,
         hir_bounds: &[hir::PolyTraitRef<'tcx>],
         lifetime: &hir::Lifetime,
+        syntax: TraitObjectSyntax,
     ) -> Ty<'tcx> {
         let tcx = self.tcx();
         let dummy_self = tcx.types.trait_object_dummy_self;
 
+        match syntax {
+            TraitObjectSyntax::Dyn => {}
+            TraitObjectSyntax::None => {
+                match self.prohibit_or_lint_bare_trait_object_ty(span, hir_id, hir_bounds) {
+                    // Don't continue with type analysis if the `dyn` keyword is missing.
+                    // It generates confusing errors, especially if the user meant to use
+                    // another keyword like `impl`.
+                    Some(guar) => return Ty::new_error(tcx, guar),
+                    None => {}
+                }
+            }
+        }
+
         let mut user_written_bounds = Vec::new();
         let mut potential_assoc_types = Vec::new();
         for poly_trait_ref in hir_bounds.iter() {
@@ -46,10 +66,16 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             }
         }
 
-        let ast_bounds: Vec<_> =
-            hir_bounds.iter().map(|&trait_ref| hir::GenericBound::Trait(trait_ref)).collect();
-
-        self.add_default_traits(&mut user_written_bounds, dummy_self, &ast_bounds, None, span);
+        self.add_default_traits(
+            &mut user_written_bounds,
+            dummy_self,
+            &hir_bounds
+                .iter()
+                .map(|&trait_ref| hir::GenericBound::Trait(trait_ref))
+                .collect::<Vec<_>>(),
+            None,
+            span,
+        );
 
         let (elaborated_trait_bounds, elaborated_projection_bounds) =
             traits::expand_trait_aliases(tcx, user_written_bounds.iter().copied());
@@ -482,6 +508,521 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             },
         );
     }
+
+    /// Prohibit or lint against *bare* trait object types depending on the edition.
+    ///
+    /// *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.
+    fn prohibit_or_lint_bare_trait_object_ty(
+        &self,
+        span: Span,
+        hir_id: hir::HirId,
+        hir_bounds: &[hir::PolyTraitRef<'tcx>],
+    ) -> Option<ErrorGuaranteed> {
+        let tcx = self.tcx();
+        let [poly_trait_ref, ..] = hir_bounds else { return None };
+
+        let in_path = match tcx.parent_hir_node(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::PatExpr(hir::PatExpr {
+                kind: hir::PatExprKind::Path(hir::QPath::TypeRelative(qself, _)),
+                ..
+            }) if qself.hir_id == hir_id => true,
+            _ => false,
+        };
+        let needs_bracket = in_path
+            && !tcx
+                .sess
+                .source_map()
+                .span_to_prev_source(span)
+                .ok()
+                .is_some_and(|s| s.trim_end().ends_with('<'));
+
+        let is_global = poly_trait_ref.trait_ref.path.is_global();
+
+        let mut sugg = vec![(
+            span.shrink_to_lo(),
+            format!(
+                "{}dyn {}",
+                if needs_bracket { "<" } else { "" },
+                if is_global { "(" } else { "" },
+            ),
+        )];
+
+        if is_global || needs_bracket {
+            sugg.push((
+                span.shrink_to_hi(),
+                format!(
+                    "{}{}",
+                    if is_global { ")" } else { "" },
+                    if needs_bracket { ">" } else { "" },
+                ),
+            ));
+        }
+
+        if span.edition().at_least_rust_2021() {
+            let mut diag = rustc_errors::struct_span_code_err!(
+                self.dcx(),
+                span,
+                E0782,
+                "{}",
+                "expected a type, found a trait"
+            );
+            if span.can_be_used_for_suggestions()
+                && poly_trait_ref.trait_ref.trait_def_id().is_some()
+                && !self.maybe_suggest_impl_trait(span, hir_id, hir_bounds, &mut diag)
+                && !self.maybe_suggest_dyn_trait(hir_id, sugg, &mut diag)
+            {
+                self.maybe_suggest_add_generic_impl_trait(span, hir_id, &mut diag);
+            }
+            // Check if the impl trait that we are considering is an impl of a local trait.
+            self.maybe_suggest_blanket_trait_impl(span, hir_id, &mut diag);
+            self.maybe_suggest_assoc_ty_bound(hir_id, &mut diag);
+            self.maybe_suggest_typoed_method(
+                hir_id,
+                poly_trait_ref.trait_ref.trait_def_id(),
+                &mut diag,
+            );
+            // In case there is an associated type with the same name
+            // Add the suggestion to this error
+            if let Some(mut sugg) =
+                self.dcx().steal_non_err(span, StashKey::AssociatedTypeSuggestion)
+                && let Suggestions::Enabled(ref mut s1) = diag.suggestions
+                && let Suggestions::Enabled(ref mut s2) = sugg.suggestions
+            {
+                s1.append(s2);
+                sugg.cancel();
+            }
+            Some(diag.emit())
+        } else {
+            tcx.node_span_lint(BARE_TRAIT_OBJECTS, hir_id, span, |lint| {
+                lint.primary_message("trait objects without an explicit `dyn` are deprecated");
+                if span.can_be_used_for_suggestions() {
+                    lint.multipart_suggestion_verbose(
+                        "if this is a dyn-compatible trait, use `dyn`",
+                        sugg,
+                        Applicability::MachineApplicable,
+                    );
+                }
+                self.maybe_suggest_blanket_trait_impl(span, hir_id, lint);
+            });
+            None
+        }
+    }
+
+    /// For a struct or enum with an invalid bare trait object field, suggest turning
+    /// it into a generic type bound.
+    fn maybe_suggest_add_generic_impl_trait(
+        &self,
+        span: Span,
+        hir_id: hir::HirId,
+        diag: &mut Diag<'_>,
+    ) -> bool {
+        let tcx = self.tcx();
+
+        let parent_hir_id = tcx.parent_hir_id(hir_id);
+        let parent_item = tcx.hir_get_parent_item(hir_id).def_id;
+
+        let generics = match tcx.hir_node_by_def_id(parent_item) {
+            hir::Node::Item(hir::Item {
+                kind: hir::ItemKind::Struct(_, generics, variant),
+                ..
+            }) => {
+                if !variant.fields().iter().any(|field| field.hir_id == parent_hir_id) {
+                    return false;
+                }
+                generics
+            }
+            hir::Node::Item(hir::Item { kind: hir::ItemKind::Enum(_, generics, def), .. }) => {
+                if !def
+                    .variants
+                    .iter()
+                    .flat_map(|variant| variant.data.fields().iter())
+                    .any(|field| field.hir_id == parent_hir_id)
+                {
+                    return false;
+                }
+                generics
+            }
+            _ => return false,
+        };
+
+        let Ok(rendered_ty) = tcx.sess.source_map().span_to_snippet(span) else {
+            return false;
+        };
+
+        let param = "TUV"
+            .chars()
+            .map(|c| c.to_string())
+            .chain((0..).map(|i| format!("P{i}")))
+            .find(|s| !generics.params.iter().any(|param| param.name.ident().as_str() == s))
+            .expect("we definitely can find at least one param name to generate");
+        let mut sugg = vec![(span, param.to_string())];
+        if let Some(insertion_span) = generics.span_for_param_suggestion() {
+            sugg.push((insertion_span, format!(", {param}: {}", rendered_ty)));
+        } else {
+            sugg.push((generics.where_clause_span, format!("<{param}: {}>", rendered_ty)));
+        }
+        diag.multipart_suggestion_verbose(
+            "you might be missing a type parameter",
+            sugg,
+            Applicability::MachineApplicable,
+        );
+        true
+    }
+
+    /// Make sure that we are in the condition to suggest the blanket implementation.
+    fn maybe_suggest_blanket_trait_impl<G: EmissionGuarantee>(
+        &self,
+        span: Span,
+        hir_id: hir::HirId,
+        diag: &mut Diag<'_, G>,
+    ) {
+        let tcx = self.tcx();
+        let parent_id = tcx.hir_get_parent_item(hir_id).def_id;
+        if let hir::Node::Item(hir::Item {
+            kind: hir::ItemKind::Impl(hir::Impl { self_ty: impl_self_ty, of_trait, generics, .. }),
+            ..
+        }) = tcx.hir_node_by_def_id(parent_id)
+            && hir_id == impl_self_ty.hir_id
+        {
+            let Some(of_trait) = of_trait else {
+                diag.span_suggestion_verbose(
+                    impl_self_ty.span.shrink_to_hi(),
+                    "you might have intended to implement this trait for a given type",
+                    format!(" for /* Type */"),
+                    Applicability::HasPlaceholders,
+                );
+                return;
+            };
+            if !of_trait.trait_ref.trait_def_id().is_some_and(|def_id| def_id.is_local()) {
+                return;
+            }
+            let of_trait_span = of_trait.trait_ref.path.span;
+            // make sure that we are not calling unwrap to abort during the compilation
+            let Ok(of_trait_name) = tcx.sess.source_map().span_to_snippet(of_trait_span) else {
+                return;
+            };
+
+            let Ok(impl_trait_name) = self.tcx().sess.source_map().span_to_snippet(span) else {
+                return;
+            };
+            let sugg = self.add_generic_param_suggestion(generics, span, &impl_trait_name);
+            diag.multipart_suggestion(
+                format!(
+                    "alternatively use a blanket implementation to implement `{of_trait_name}` for \
+                     all types that also implement `{impl_trait_name}`"
+                ),
+                sugg,
+                Applicability::MaybeIncorrect,
+            );
+        }
+    }
+
+    /// Try our best to approximate when adding `dyn` would be helpful for a bare
+    /// trait object.
+    ///
+    /// Right now, this is if the type is either directly nested in another ty,
+    /// or if it's in the tail field within a struct. This approximates what the
+    /// user would've gotten on edition 2015, except for the case where we have
+    /// an *obvious* knock-on `Sized` error.
+    fn maybe_suggest_dyn_trait(
+        &self,
+        hir_id: hir::HirId,
+        sugg: Vec<(Span, String)>,
+        diag: &mut Diag<'_>,
+    ) -> bool {
+        let tcx = self.tcx();
+
+        // Look at the direct HIR parent, since we care about the relationship between
+        // the type and the thing that directly encloses it.
+        match tcx.parent_hir_node(hir_id) {
+            // These are all generally ok. Namely, when a trait object is nested
+            // into another expression or ty, it's either very certain that they
+            // missed the ty (e.g. `&Trait`) or it's not really possible to tell
+            // what their intention is, so let's not give confusing suggestions and
+            // just mention `dyn`. The user can make up their mind what to do here.
+            hir::Node::Ty(_)
+            | hir::Node::Expr(_)
+            | hir::Node::PatExpr(_)
+            | hir::Node::PathSegment(_)
+            | hir::Node::AssocItemConstraint(_)
+            | hir::Node::TraitRef(_)
+            | hir::Node::Item(_)
+            | hir::Node::WherePredicate(_) => {}
+
+            hir::Node::Field(field) => {
+                // Enums can't have unsized fields, fields can only have an unsized tail field.
+                if let hir::Node::Item(hir::Item {
+                    kind: hir::ItemKind::Struct(_, _, variant), ..
+                }) = tcx.parent_hir_node(field.hir_id)
+                    && variant
+                        .fields()
+                        .last()
+                        .is_some_and(|tail_field| tail_field.hir_id == field.hir_id)
+                {
+                    // Ok
+                } else {
+                    return false;
+                }
+            }
+            _ => return false,
+        }
+
+        // FIXME: Only emit this suggestion if the trait is dyn-compatible.
+        diag.multipart_suggestion_verbose(
+            "you can add the `dyn` keyword if you want a trait object",
+            sugg,
+            Applicability::MachineApplicable,
+        );
+        true
+    }
+
+    fn add_generic_param_suggestion(
+        &self,
+        generics: &hir::Generics<'_>,
+        self_ty_span: Span,
+        impl_trait_name: &str,
+    ) -> Vec<(Span, String)> {
+        // check if the trait has generics, to make a correct suggestion
+        let param_name = generics.params.next_type_param_name(None);
+
+        let add_generic_sugg = if let Some(span) = generics.span_for_param_suggestion() {
+            (span, format!(", {param_name}: {impl_trait_name}"))
+        } else {
+            (generics.span, format!("<{param_name}: {impl_trait_name}>"))
+        };
+        vec![(self_ty_span, param_name), add_generic_sugg]
+    }
+
+    /// Make sure that we are in the condition to suggest `impl Trait`.
+    fn maybe_suggest_impl_trait(
+        &self,
+        span: Span,
+        hir_id: hir::HirId,
+        hir_bounds: &[hir::PolyTraitRef<'tcx>],
+        diag: &mut Diag<'_>,
+    ) -> bool {
+        let tcx = self.tcx();
+        let parent_id = tcx.hir_get_parent_item(hir_id).def_id;
+        // FIXME: If `type_alias_impl_trait` is enabled, also look for `Trait0<Ty = Trait1>`
+        //        and suggest `Trait0<Ty = impl Trait1>`.
+        // Functions are found in three different contexts.
+        // 1. Independent functions
+        // 2. Functions inside trait blocks
+        // 3. Functions inside impl blocks
+        let (sig, generics) = match tcx.hir_node_by_def_id(parent_id) {
+            hir::Node::Item(hir::Item {
+                kind: hir::ItemKind::Fn { sig, generics, .. }, ..
+            }) => (sig, generics),
+            hir::Node::TraitItem(hir::TraitItem {
+                kind: hir::TraitItemKind::Fn(sig, _),
+                generics,
+                ..
+            }) => (sig, generics),
+            hir::Node::ImplItem(hir::ImplItem {
+                kind: hir::ImplItemKind::Fn(sig, _),
+                generics,
+                ..
+            }) => (sig, generics),
+            _ => return false,
+        };
+        let Ok(trait_name) = tcx.sess.source_map().span_to_snippet(span) else {
+            return false;
+        };
+        let impl_sugg = vec![(span.shrink_to_lo(), "impl ".to_string())];
+        // Check if trait object is safe for suggesting dynamic dispatch.
+        let is_dyn_compatible = hir_bounds.iter().all(|bound| match bound.trait_ref.path.res {
+            Res::Def(DefKind::Trait, id) => tcx.is_dyn_compatible(id),
+            _ => false,
+        });
+
+        let borrowed = matches!(
+            tcx.parent_hir_node(hir_id),
+            hir::Node::Ty(hir::Ty { kind: hir::TyKind::Ref(..), .. })
+        );
+
+        // Suggestions for function return type.
+        if let hir::FnRetTy::Return(ty) = sig.decl.output
+            && ty.peel_refs().hir_id == hir_id
+        {
+            let pre = if !is_dyn_compatible {
+                format!("`{trait_name}` is dyn-incompatible, ")
+            } else {
+                String::new()
+            };
+            let msg = format!(
+                "{pre}use `impl {trait_name}` to return an opaque type, as long as you return a \
+                 single underlying type",
+            );
+
+            diag.multipart_suggestion_verbose(msg, impl_sugg, Applicability::MachineApplicable);
+
+            // Suggest `Box<dyn Trait>` for return type
+            if is_dyn_compatible {
+                // If the return type is `&Trait`, we don't want
+                // the ampersand to be displayed in the `Box<dyn Trait>`
+                // suggestion.
+                let suggestion = if borrowed {
+                    vec![(ty.span, format!("Box<dyn {trait_name}>"))]
+                } else {
+                    vec![
+                        (ty.span.shrink_to_lo(), "Box<dyn ".to_string()),
+                        (ty.span.shrink_to_hi(), ">".to_string()),
+                    ]
+                };
+
+                diag.multipart_suggestion_verbose(
+                    "alternatively, you can return an owned trait object",
+                    suggestion,
+                    Applicability::MachineApplicable,
+                );
+            }
+            return true;
+        }
+
+        // Suggestions for function parameters.
+        for ty in sig.decl.inputs {
+            if ty.peel_refs().hir_id != hir_id {
+                continue;
+            }
+            let sugg = self.add_generic_param_suggestion(generics, span, &trait_name);
+            diag.multipart_suggestion_verbose(
+                format!("use a new generic type parameter, constrained by `{trait_name}`"),
+                sugg,
+                Applicability::MachineApplicable,
+            );
+            diag.multipart_suggestion_verbose(
+                "you can also use an opaque type, but users won't be able to specify the type \
+                 parameter when calling the `fn`, having to rely exclusively on type inference",
+                impl_sugg,
+                Applicability::MachineApplicable,
+            );
+            if !is_dyn_compatible {
+                diag.note(format!(
+                    "`{trait_name}` is dyn-incompatible, otherwise a trait object could be used"
+                ));
+            } else {
+                // No ampersand in suggestion if it's borrowed already
+                let (dyn_str, paren_dyn_str) =
+                    if borrowed { ("dyn ", "(dyn ") } else { ("&dyn ", "&(dyn ") };
+
+                let sugg = if let [_, _, ..] = hir_bounds {
+                    // There is more than one trait bound, we need surrounding parentheses.
+                    vec![
+                        (span.shrink_to_lo(), paren_dyn_str.to_string()),
+                        (span.shrink_to_hi(), ")".to_string()),
+                    ]
+                } else {
+                    vec![(span.shrink_to_lo(), dyn_str.to_string())]
+                };
+                diag.multipart_suggestion_verbose(
+                    format!(
+                        "alternatively, use a trait object to accept any type that implements \
+                         `{trait_name}`, accessing its methods at runtime using dynamic dispatch",
+                    ),
+                    sugg,
+                    Applicability::MachineApplicable,
+                );
+            }
+            return true;
+        }
+        false
+    }
+
+    fn maybe_suggest_assoc_ty_bound(&self, hir_id: hir::HirId, diag: &mut Diag<'_>) {
+        let mut parents = self.tcx().hir_parent_iter(hir_id);
+
+        if let Some((c_hir_id, hir::Node::AssocItemConstraint(constraint))) = parents.next()
+            && let Some(obj_ty) = constraint.ty()
+            && let Some((_, hir::Node::TraitRef(trait_ref))) = parents.next()
+        {
+            if let Some((_, hir::Node::Ty(ty))) = parents.next()
+                && let hir::TyKind::TraitObject(..) = ty.kind
+            {
+                // Assoc ty bounds aren't permitted inside trait object types.
+                return;
+            }
+
+            if trait_ref
+                .path
+                .segments
+                .iter()
+                .find_map(|seg| {
+                    seg.args.filter(|args| args.constraints.iter().any(|c| c.hir_id == c_hir_id))
+                })
+                .is_none_or(|args| args.parenthesized != hir::GenericArgsParentheses::No)
+            {
+                // Only consider angle-bracketed args (where we have a `=` to replace with `:`).
+                return;
+            }
+
+            let lo = if constraint.gen_args.span_ext.is_dummy() {
+                constraint.ident.span
+            } else {
+                constraint.gen_args.span_ext
+            };
+            let hi = obj_ty.span;
+
+            if !lo.eq_ctxt(hi) {
+                return;
+            }
+
+            diag.span_suggestion_verbose(
+                lo.between(hi),
+                "you might have meant to write a bound here",
+                ": ",
+                Applicability::MaybeIncorrect,
+            );
+        }
+    }
+
+    fn maybe_suggest_typoed_method(
+        &self,
+        hir_id: hir::HirId,
+        trait_def_id: Option<DefId>,
+        diag: &mut Diag<'_>,
+    ) {
+        let tcx = self.tcx();
+        let Some(trait_def_id) = trait_def_id else {
+            return;
+        };
+        let hir::Node::Expr(hir::Expr {
+            kind: hir::ExprKind::Path(hir::QPath::TypeRelative(path_ty, segment)),
+            ..
+        }) = tcx.parent_hir_node(hir_id)
+        else {
+            return;
+        };
+        if path_ty.hir_id != hir_id {
+            return;
+        }
+        let names: Vec<_> = tcx
+            .associated_items(trait_def_id)
+            .in_definition_order()
+            .filter(|assoc| assoc.namespace() == hir::def::Namespace::ValueNS)
+            .map(|cand| cand.name())
+            .collect();
+        if let Some(typo) = find_best_match_for_name(&names, segment.ident.name, None) {
+            diag.span_suggestion_verbose(
+                segment.ident.span,
+                format!(
+                    "you may have misspelled this associated item, causing `{}` \
+                    to be interpreted as a type rather than a trait",
+                    tcx.item_name(trait_def_id),
+                ),
+                typo,
+                Applicability::MaybeIncorrect,
+            );
+        }
+    }
 }
 
 fn replace_dummy_self_with_error<'tcx, T: TypeFoldable<TyCtxt<'tcx>>>(
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/lint.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/lint.rs
deleted file mode 100644
index 56998b5b53cc4..0000000000000
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/lint.rs
+++ /dev/null
@@ -1,533 +0,0 @@
-use rustc_ast::TraitObjectSyntax;
-use rustc_errors::codes::*;
-use rustc_errors::{Diag, EmissionGuarantee, ErrorGuaranteed, StashKey, Suggestions};
-use rustc_hir as hir;
-use rustc_hir::def::{DefKind, Namespace, Res};
-use rustc_hir::def_id::DefId;
-use rustc_lint_defs::Applicability;
-use rustc_lint_defs::builtin::BARE_TRAIT_OBJECTS;
-use rustc_span::Span;
-use rustc_span::edit_distance::find_best_match_for_name;
-use rustc_trait_selection::error_reporting::traits::suggestions::NextTypeParamName;
-
-use super::HirTyLowerer;
-
-impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
-    /// Prohibit or lint against *bare* trait object types depending on the edition.
-    ///
-    /// *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<'_>,
-    ) -> Option<ErrorGuaranteed> {
-        let tcx = self.tcx();
-
-        let poly_trait_ref = if let hir::TyKind::TraitObject([poly_trait_ref, ..], tagged_ptr) =
-            self_ty.kind
-            && let TraitObjectSyntax::None = tagged_ptr.tag()
-        {
-            poly_trait_ref
-        } else {
-            return None;
-        };
-
-        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::PatExpr(hir::PatExpr {
-                kind: hir::PatExprKind::Path(hir::QPath::TypeRelative(qself, _)),
-                ..
-            }) if qself.hir_id == self_ty.hir_id => true,
-            _ => false,
-        };
-        let needs_bracket = in_path
-            && !tcx
-                .sess
-                .source_map()
-                .span_to_prev_source(self_ty.span)
-                .ok()
-                .is_some_and(|s| s.trim_end().ends_with('<'));
-
-        let is_global = poly_trait_ref.trait_ref.path.is_global();
-
-        let mut sugg = vec![(
-            self_ty.span.shrink_to_lo(),
-            format!(
-                "{}dyn {}",
-                if needs_bracket { "<" } else { "" },
-                if is_global { "(" } else { "" },
-            ),
-        )];
-
-        if is_global || needs_bracket {
-            sugg.push((
-                self_ty.span.shrink_to_hi(),
-                format!(
-                    "{}{}",
-                    if is_global { ")" } else { "" },
-                    if needs_bracket { ">" } else { "" },
-                ),
-            ));
-        }
-
-        if self_ty.span.edition().at_least_rust_2021() {
-            let mut diag = rustc_errors::struct_span_code_err!(
-                self.dcx(),
-                self_ty.span,
-                E0782,
-                "{}",
-                "expected a type, found a trait"
-            );
-            if self_ty.span.can_be_used_for_suggestions()
-                && poly_trait_ref.trait_ref.trait_def_id().is_some()
-                && !self.maybe_suggest_impl_trait(self_ty, &mut diag)
-                && !self.maybe_suggest_dyn_trait(self_ty, sugg, &mut diag)
-            {
-                self.maybe_suggest_add_generic_impl_trait(self_ty, &mut diag);
-            }
-            // Check if the impl trait that we are considering is an impl of a local trait.
-            self.maybe_suggest_blanket_trait_impl(self_ty, &mut diag);
-            self.maybe_suggest_assoc_ty_bound(self_ty, &mut diag);
-            self.maybe_suggest_typoed_method(
-                self_ty,
-                poly_trait_ref.trait_ref.trait_def_id(),
-                &mut diag,
-            );
-            // In case there is an associated type with the same name
-            // Add the suggestion to this error
-            if let Some(mut sugg) =
-                self.dcx().steal_non_err(self_ty.span, StashKey::AssociatedTypeSuggestion)
-                && let Suggestions::Enabled(ref mut s1) = diag.suggestions
-                && let Suggestions::Enabled(ref mut s2) = sugg.suggestions
-            {
-                s1.append(s2);
-                sugg.cancel();
-            }
-            Some(diag.emit())
-        } else {
-            tcx.node_span_lint(BARE_TRAIT_OBJECTS, self_ty.hir_id, self_ty.span, |lint| {
-                lint.primary_message("trait objects without an explicit `dyn` are deprecated");
-                if self_ty.span.can_be_used_for_suggestions() {
-                    lint.multipart_suggestion_verbose(
-                        "if this is a dyn-compatible trait, use `dyn`",
-                        sugg,
-                        Applicability::MachineApplicable,
-                    );
-                }
-                self.maybe_suggest_blanket_trait_impl(self_ty, lint);
-            });
-            None
-        }
-    }
-
-    /// For a struct or enum with an invalid bare trait object field, suggest turning
-    /// it into a generic type bound.
-    fn maybe_suggest_add_generic_impl_trait(
-        &self,
-        self_ty: &hir::Ty<'_>,
-        diag: &mut Diag<'_>,
-    ) -> bool {
-        let tcx = self.tcx();
-
-        let parent_hir_id = tcx.parent_hir_id(self_ty.hir_id);
-        let parent_item = tcx.hir_get_parent_item(self_ty.hir_id).def_id;
-
-        let generics = match tcx.hir_node_by_def_id(parent_item) {
-            hir::Node::Item(hir::Item {
-                kind: hir::ItemKind::Struct(_, generics, variant),
-                ..
-            }) => {
-                if !variant.fields().iter().any(|field| field.hir_id == parent_hir_id) {
-                    return false;
-                }
-                generics
-            }
-            hir::Node::Item(hir::Item { kind: hir::ItemKind::Enum(_, generics, def), .. }) => {
-                if !def
-                    .variants
-                    .iter()
-                    .flat_map(|variant| variant.data.fields().iter())
-                    .any(|field| field.hir_id == parent_hir_id)
-                {
-                    return false;
-                }
-                generics
-            }
-            _ => return false,
-        };
-
-        let Ok(rendered_ty) = tcx.sess.source_map().span_to_snippet(self_ty.span) else {
-            return false;
-        };
-
-        let param = "TUV"
-            .chars()
-            .map(|c| c.to_string())
-            .chain((0..).map(|i| format!("P{i}")))
-            .find(|s| !generics.params.iter().any(|param| param.name.ident().as_str() == s))
-            .expect("we definitely can find at least one param name to generate");
-        let mut sugg = vec![(self_ty.span, param.to_string())];
-        if let Some(insertion_span) = generics.span_for_param_suggestion() {
-            sugg.push((insertion_span, format!(", {param}: {}", rendered_ty)));
-        } else {
-            sugg.push((generics.where_clause_span, format!("<{param}: {}>", rendered_ty)));
-        }
-        diag.multipart_suggestion_verbose(
-            "you might be missing a type parameter",
-            sugg,
-            Applicability::MachineApplicable,
-        );
-        true
-    }
-    /// Make sure that we are in the condition to suggest the blanket implementation.
-    fn maybe_suggest_blanket_trait_impl<G: EmissionGuarantee>(
-        &self,
-        self_ty: &hir::Ty<'_>,
-        diag: &mut Diag<'_, G>,
-    ) {
-        let tcx = self.tcx();
-        let parent_id = tcx.hir_get_parent_item(self_ty.hir_id).def_id;
-        if let hir::Node::Item(hir::Item {
-            kind: hir::ItemKind::Impl(hir::Impl { self_ty: impl_self_ty, of_trait, generics, .. }),
-            ..
-        }) = tcx.hir_node_by_def_id(parent_id)
-            && self_ty.hir_id == impl_self_ty.hir_id
-        {
-            let Some(of_trait) = of_trait else {
-                diag.span_suggestion_verbose(
-                    impl_self_ty.span.shrink_to_hi(),
-                    "you might have intended to implement this trait for a given type",
-                    format!(" for /* Type */"),
-                    Applicability::HasPlaceholders,
-                );
-                return;
-            };
-            if !of_trait.trait_ref.trait_def_id().is_some_and(|def_id| def_id.is_local()) {
-                return;
-            }
-            let of_trait_span = of_trait.trait_ref.path.span;
-            // make sure that we are not calling unwrap to abort during the compilation
-            let Ok(of_trait_name) = tcx.sess.source_map().span_to_snippet(of_trait_span) else {
-                return;
-            };
-
-            let Ok(impl_trait_name) = self.tcx().sess.source_map().span_to_snippet(self_ty.span)
-            else {
-                return;
-            };
-            let sugg = self.add_generic_param_suggestion(generics, self_ty.span, &impl_trait_name);
-            diag.multipart_suggestion(
-                format!(
-                    "alternatively use a blanket implementation to implement `{of_trait_name}` for \
-                     all types that also implement `{impl_trait_name}`"
-                ),
-                sugg,
-                Applicability::MaybeIncorrect,
-            );
-        }
-    }
-
-    /// Try our best to approximate when adding `dyn` would be helpful for a bare
-    /// trait object.
-    ///
-    /// Right now, this is if the type is either directly nested in another ty,
-    /// or if it's in the tail field within a struct. This approximates what the
-    /// user would've gotten on edition 2015, except for the case where we have
-    /// an *obvious* knock-on `Sized` error.
-    fn maybe_suggest_dyn_trait(
-        &self,
-        self_ty: &hir::Ty<'_>,
-        sugg: Vec<(Span, String)>,
-        diag: &mut Diag<'_>,
-    ) -> bool {
-        let tcx = self.tcx();
-
-        // Look at the direct HIR parent, since we care about the relationship between
-        // the type and the thing that directly encloses it.
-        match tcx.parent_hir_node(self_ty.hir_id) {
-            // These are all generally ok. Namely, when a trait object is nested
-            // into another expression or ty, it's either very certain that they
-            // missed the ty (e.g. `&Trait`) or it's not really possible to tell
-            // what their intention is, so let's not give confusing suggestions and
-            // just mention `dyn`. The user can make up their mind what to do here.
-            hir::Node::Ty(_)
-            | hir::Node::Expr(_)
-            | hir::Node::PatExpr(_)
-            | hir::Node::PathSegment(_)
-            | hir::Node::AssocItemConstraint(_)
-            | hir::Node::TraitRef(_)
-            | hir::Node::Item(_)
-            | hir::Node::WherePredicate(_) => {}
-
-            hir::Node::Field(field) => {
-                // Enums can't have unsized fields, fields can only have an unsized tail field.
-                if let hir::Node::Item(hir::Item {
-                    kind: hir::ItemKind::Struct(_, _, variant), ..
-                }) = tcx.parent_hir_node(field.hir_id)
-                    && variant
-                        .fields()
-                        .last()
-                        .is_some_and(|tail_field| tail_field.hir_id == field.hir_id)
-                {
-                    // Ok
-                } else {
-                    return false;
-                }
-            }
-            _ => return false,
-        }
-
-        // FIXME: Only emit this suggestion if the trait is dyn-compatible.
-        diag.multipart_suggestion_verbose(
-            "you can add the `dyn` keyword if you want a trait object",
-            sugg,
-            Applicability::MachineApplicable,
-        );
-        true
-    }
-
-    fn add_generic_param_suggestion(
-        &self,
-        generics: &hir::Generics<'_>,
-        self_ty_span: Span,
-        impl_trait_name: &str,
-    ) -> Vec<(Span, String)> {
-        // check if the trait has generics, to make a correct suggestion
-        let param_name = generics.params.next_type_param_name(None);
-
-        let add_generic_sugg = if let Some(span) = generics.span_for_param_suggestion() {
-            (span, format!(", {param_name}: {impl_trait_name}"))
-        } else {
-            (generics.span, format!("<{param_name}: {impl_trait_name}>"))
-        };
-        vec![(self_ty_span, param_name), add_generic_sugg]
-    }
-
-    /// Make sure that we are in the condition to suggest `impl Trait`.
-    fn maybe_suggest_impl_trait(&self, self_ty: &hir::Ty<'_>, diag: &mut Diag<'_>) -> bool {
-        let tcx = self.tcx();
-        let parent_id = tcx.hir_get_parent_item(self_ty.hir_id).def_id;
-        // FIXME: If `type_alias_impl_trait` is enabled, also look for `Trait0<Ty = Trait1>`
-        //        and suggest `Trait0<Ty = impl Trait1>`.
-        // Functions are found in three different contexts.
-        // 1. Independent functions
-        // 2. Functions inside trait blocks
-        // 3. Functions inside impl blocks
-        let (sig, generics) = match tcx.hir_node_by_def_id(parent_id) {
-            hir::Node::Item(hir::Item {
-                kind: hir::ItemKind::Fn { sig, generics, .. }, ..
-            }) => (sig, generics),
-            hir::Node::TraitItem(hir::TraitItem {
-                kind: hir::TraitItemKind::Fn(sig, _),
-                generics,
-                ..
-            }) => (sig, generics),
-            hir::Node::ImplItem(hir::ImplItem {
-                kind: hir::ImplItemKind::Fn(sig, _),
-                generics,
-                ..
-            }) => (sig, generics),
-            _ => return false,
-        };
-        let Ok(trait_name) = tcx.sess.source_map().span_to_snippet(self_ty.span) else {
-            return false;
-        };
-        let impl_sugg = vec![(self_ty.span.shrink_to_lo(), "impl ".to_string())];
-        // Check if trait object is safe for suggesting dynamic dispatch.
-        let is_dyn_compatible = match self_ty.kind {
-            hir::TyKind::TraitObject(objects, ..) => {
-                objects.iter().all(|o| match o.trait_ref.path.res {
-                    Res::Def(DefKind::Trait, id) => tcx.is_dyn_compatible(id),
-                    _ => false,
-                })
-            }
-            _ => false,
-        };
-
-        let borrowed = matches!(
-            tcx.parent_hir_node(self_ty.hir_id),
-            hir::Node::Ty(hir::Ty { kind: hir::TyKind::Ref(..), .. })
-        );
-
-        // Suggestions for function return type.
-        if let hir::FnRetTy::Return(ty) = sig.decl.output
-            && ty.peel_refs().hir_id == self_ty.hir_id
-        {
-            let pre = if !is_dyn_compatible {
-                format!("`{trait_name}` is dyn-incompatible, ")
-            } else {
-                String::new()
-            };
-            let msg = format!(
-                "{pre}use `impl {trait_name}` to return an opaque type, as long as you return a \
-                 single underlying type",
-            );
-
-            diag.multipart_suggestion_verbose(msg, impl_sugg, Applicability::MachineApplicable);
-
-            // Suggest `Box<dyn Trait>` for return type
-            if is_dyn_compatible {
-                // If the return type is `&Trait`, we don't want
-                // the ampersand to be displayed in the `Box<dyn Trait>`
-                // suggestion.
-                let suggestion = if borrowed {
-                    vec![(ty.span, format!("Box<dyn {trait_name}>"))]
-                } else {
-                    vec![
-                        (ty.span.shrink_to_lo(), "Box<dyn ".to_string()),
-                        (ty.span.shrink_to_hi(), ">".to_string()),
-                    ]
-                };
-
-                diag.multipart_suggestion_verbose(
-                    "alternatively, you can return an owned trait object",
-                    suggestion,
-                    Applicability::MachineApplicable,
-                );
-            }
-            return true;
-        }
-
-        // Suggestions for function parameters.
-        for ty in sig.decl.inputs {
-            if ty.peel_refs().hir_id != self_ty.hir_id {
-                continue;
-            }
-            let sugg = self.add_generic_param_suggestion(generics, self_ty.span, &trait_name);
-            diag.multipart_suggestion_verbose(
-                format!("use a new generic type parameter, constrained by `{trait_name}`"),
-                sugg,
-                Applicability::MachineApplicable,
-            );
-            diag.multipart_suggestion_verbose(
-                "you can also use an opaque type, but users won't be able to specify the type \
-                 parameter when calling the `fn`, having to rely exclusively on type inference",
-                impl_sugg,
-                Applicability::MachineApplicable,
-            );
-            if !is_dyn_compatible {
-                diag.note(format!(
-                    "`{trait_name}` is dyn-incompatible, otherwise a trait object could be used"
-                ));
-            } else {
-                // No ampersand in suggestion if it's borrowed already
-                let (dyn_str, paren_dyn_str) =
-                    if borrowed { ("dyn ", "(dyn ") } else { ("&dyn ", "&(dyn ") };
-
-                let sugg = if let hir::TyKind::TraitObject([_, _, ..], _) = self_ty.kind {
-                    // There is more than one trait bound, we need surrounding parentheses.
-                    vec![
-                        (self_ty.span.shrink_to_lo(), paren_dyn_str.to_string()),
-                        (self_ty.span.shrink_to_hi(), ")".to_string()),
-                    ]
-                } else {
-                    vec![(self_ty.span.shrink_to_lo(), dyn_str.to_string())]
-                };
-                diag.multipart_suggestion_verbose(
-                    format!(
-                        "alternatively, use a trait object to accept any type that implements \
-                         `{trait_name}`, accessing its methods at runtime using dynamic dispatch",
-                    ),
-                    sugg,
-                    Applicability::MachineApplicable,
-                );
-            }
-            return true;
-        }
-        false
-    }
-
-    fn maybe_suggest_assoc_ty_bound(&self, self_ty: &hir::Ty<'_>, diag: &mut Diag<'_>) {
-        let mut parents = self.tcx().hir_parent_iter(self_ty.hir_id);
-
-        if let Some((c_hir_id, hir::Node::AssocItemConstraint(constraint))) = parents.next()
-            && let Some(obj_ty) = constraint.ty()
-            && let Some((_, hir::Node::TraitRef(trait_ref))) = parents.next()
-        {
-            if let Some((_, hir::Node::Ty(ty))) = parents.next()
-                && let hir::TyKind::TraitObject(..) = ty.kind
-            {
-                // Assoc ty bounds aren't permitted inside trait object types.
-                return;
-            }
-
-            if trait_ref
-                .path
-                .segments
-                .iter()
-                .find_map(|seg| {
-                    seg.args.filter(|args| args.constraints.iter().any(|c| c.hir_id == c_hir_id))
-                })
-                .is_none_or(|args| args.parenthesized != hir::GenericArgsParentheses::No)
-            {
-                // Only consider angle-bracketed args (where we have a `=` to replace with `:`).
-                return;
-            }
-
-            let lo = if constraint.gen_args.span_ext.is_dummy() {
-                constraint.ident.span
-            } else {
-                constraint.gen_args.span_ext
-            };
-            let hi = obj_ty.span;
-
-            if !lo.eq_ctxt(hi) {
-                return;
-            }
-
-            diag.span_suggestion_verbose(
-                lo.between(hi),
-                "you might have meant to write a bound here",
-                ": ",
-                Applicability::MaybeIncorrect,
-            );
-        }
-    }
-
-    fn maybe_suggest_typoed_method(
-        &self,
-        self_ty: &hir::Ty<'_>,
-        trait_def_id: Option<DefId>,
-        diag: &mut Diag<'_>,
-    ) {
-        let tcx = self.tcx();
-        let Some(trait_def_id) = trait_def_id else {
-            return;
-        };
-        let hir::Node::Expr(hir::Expr {
-            kind: hir::ExprKind::Path(hir::QPath::TypeRelative(path_ty, segment)),
-            ..
-        }) = tcx.parent_hir_node(self_ty.hir_id)
-        else {
-            return;
-        };
-        if path_ty.hir_id != self_ty.hir_id {
-            return;
-        }
-        let names: Vec<_> = tcx
-            .associated_items(trait_def_id)
-            .in_definition_order()
-            .filter(|assoc| assoc.namespace() == Namespace::ValueNS)
-            .map(|cand| cand.name())
-            .collect();
-        if let Some(typo) = find_best_match_for_name(&names, segment.ident.name, None) {
-            diag.span_suggestion_verbose(
-                segment.ident.span,
-                format!(
-                    "you may have misspelled this associated item, causing `{}` \
-                    to be interpreted as a type rather than a trait",
-                    tcx.item_name(trait_def_id),
-                ),
-                typo,
-                Applicability::MaybeIncorrect,
-            );
-        }
-    }
-}
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 b64129dc54e67..9b198d044542f 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -15,10 +15,9 @@
 
 mod bounds;
 mod cmse;
-mod dyn_compatibility;
+mod dyn_trait;
 pub mod errors;
 pub mod generics;
-mod lint;
 
 use std::assert_matches::assert_matches;
 use std::slice;
@@ -2427,15 +2426,8 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             ),
             hir::TyKind::TraitObject(bounds, tagged_ptr) => {
                 let lifetime = tagged_ptr.pointer();
-
-                if let Some(guar) = self.prohibit_or_lint_bare_trait_object_ty(hir_ty) {
-                    // Don't continue with type analysis if the `dyn` keyword is missing
-                    // It generates confusing errors, especially if the user meant to use another
-                    // keyword like `impl`
-                    Ty::new_error(tcx, guar)
-                } else {
-                    self.lower_trait_object_ty(hir_ty.span, hir_ty.hir_id, bounds, lifetime)
-                }
+                let syntax = tagged_ptr.tag();
+                self.lower_trait_object_ty(hir_ty.span, hir_ty.hir_id, bounds, lifetime, syntax)
             }
             // If we encounter a fully qualified path with RTN generics, then it must have
             // *not* gone through `lower_ty_maybe_return_type_notation`, and therefore

From 06e881042d3f58fdb60fde58de5bf112b2184b11 Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Wed, 17 Sep 2025 04:52:58 +0000
Subject: [PATCH 1033/1889] Prepare for merging from rust-lang/rust

This updates the rust-version file to 3f1552a273e43e15f6ed240d00e1efdd6a53e65e.
---
 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 f27677cd50388..0eb16a943d6ab 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-9d82de19dfae60e55c291f5f28e28cfc2c1b9630
+3f1552a273e43e15f6ed240d00e1efdd6a53e65e

From 603d64c3bb61e5e39bf624cc152fe1b844e70220 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Wed, 17 Sep 2025 14:59:02 +0800
Subject: [PATCH 1034/1889] Fix complete type in nested pattern

Example
---
```rust
struct Foo { num: u32 }
struct Bar(Foo);
fn foo(Bar($0)) {}
```

**Before this PR**:

```rust
struct Foo { num: u32 }
struct Bar(Foo);
fn foo(Bar(Foo { num$1 }: Foo$0)) {}
```

**After this PR**:

```rust
struct Foo { num: u32 }
struct Bar(Foo);
fn foo(Bar(Foo { num$1 }$0)) {}
```
---
 .../ide-completion/src/render/pattern.rs      |  1 +
 .../ide-completion/src/tests/pattern.rs       | 19 +++++++++++++++++++
 2 files changed, 20 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/render/pattern.rs b/src/tools/rust-analyzer/crates/ide-completion/src/render/pattern.rs
index 60ec1128233e2..312d3bd426f90 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/render/pattern.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/render/pattern.rs
@@ -163,6 +163,7 @@ fn render_pat(
         PatternContext {
             param_ctx: Some(ParamContext { kind: ParamKind::Function(_), .. }),
             has_type_ascription: false,
+            parent_pat: None,
             ..
         }
     );
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/tests/pattern.rs b/src/tools/rust-analyzer/crates/ide-completion/src/tests/pattern.rs
index 9ec27252fd741..6eb0b818d6970 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/tests/pattern.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/tests/pattern.rs
@@ -398,6 +398,25 @@ fn foo($0) {}
     )
 }
 
+#[test]
+fn completes_in_fn_param_in_nested_pattern() {
+    check(
+        r#"
+struct Foo { num: u32 }
+struct Bar(Foo);
+fn foo(Bar($0)) {}
+"#,
+        expect![[r#"
+            st Bar
+            st Foo
+            bn Bar(…)        Bar($1)$0
+            bn Foo {…} Foo { num$1 }$0
+            kw mut
+            kw ref
+        "#]],
+    )
+}
+
 #[test]
 fn completes_in_closure_param() {
     check(

From ee496f203828c4aad321500cbe756de8f22895d8 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Wed, 17 Sep 2025 11:20:57 +0200
Subject: [PATCH 1035/1889] a valid state is achieved by passing the test suite

---
 src/doc/rustc-dev-guide/src/tests/ci.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/src/tests/ci.md b/src/doc/rustc-dev-guide/src/tests/ci.md
index d9fc2324d8bf6..1488103f469d1 100644
--- a/src/doc/rustc-dev-guide/src/tests/ci.md
+++ b/src/doc/rustc-dev-guide/src/tests/ci.md
@@ -1,7 +1,7 @@
 # Testing with CI
 
 The primary goal of our CI system is to ensure that the `master` branch of
-`rust-lang/rust` is always in a valid state and passes our test suite.
+`rust-lang/rust` is always in a valid state by passing our test suite.
 
 From a high-level point of view, when you open a pull request at
 `rust-lang/rust`, the following will happen:

From 11107679ee19cc54d4f6cf66501fd62f123e9eae Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Marcelo=20Dom=C3=ADnguez?= <dmmarcelo27@gmail.com>
Date: Mon, 14 Jul 2025 17:05:51 +0000
Subject: [PATCH 1036/1889] Add test for autodiff abi handling

---
 tests/codegen-llvm/autodiff/abi_handling.rs | 210 ++++++++++++++++++++
 1 file changed, 210 insertions(+)
 create mode 100644 tests/codegen-llvm/autodiff/abi_handling.rs

diff --git a/tests/codegen-llvm/autodiff/abi_handling.rs b/tests/codegen-llvm/autodiff/abi_handling.rs
new file mode 100644
index 0000000000000..454ec698b917c
--- /dev/null
+++ b/tests/codegen-llvm/autodiff/abi_handling.rs
@@ -0,0 +1,210 @@
+//@ revisions: debug release
+
+//@[debug] compile-flags: -Zautodiff=Enable -C opt-level=0 -Clto=fat
+//@[release] compile-flags: -Zautodiff=Enable -C opt-level=3 -Clto=fat
+//@ no-prefer-dynamic
+//@ needs-enzyme
+
+// This test checks that Rust types are lowered to LLVM-IR types in a way
+// we expect and Enzyme can handle. We explicitly check release mode to
+// ensure that LLVM's O3 pipeline doesn't rewrite function signatures
+// into forms that Enzyme can't process correctly.
+
+#![feature(autodiff)]
+
+use std::autodiff::{autodiff_forward, autodiff_reverse};
+
+#[derive(Copy, Clone)]
+struct Input {
+    x: f32,
+    y: f32,
+}
+
+#[derive(Copy, Clone)]
+struct Wrapper {
+    z: f32,
+}
+
+#[derive(Copy, Clone)]
+struct NestedInput {
+    x: f32,
+    y: Wrapper,
+}
+
+fn square(x: f32) -> f32 {
+    x * x
+}
+
+// CHECK-LABEL: ; abi_handling::df1
+// CHECK-NEXT: Function Attrs
+// debug-NEXT: define internal { float, float }
+// debug-SAME: (ptr align 4 %x, ptr align 4 %bx_0)
+// release-NEXT: define internal fastcc float
+// release-SAME: (float %x.0.val, float %x.4.val)
+
+// CHECK-LABEL: ; abi_handling::f1
+// CHECK-NEXT: Function Attrs
+// debug-NEXT: define internal float
+// debug-SAME: (ptr align 4 %x)
+// release-NEXT: define internal fastcc noundef float
+// release-SAME: (float %x.0.val, float %x.4.val)
+#[autodiff_forward(df1, Dual, Dual)]
+#[inline(never)]
+fn f1(x: &[f32; 2]) -> f32 {
+    x[0] + x[1]
+}
+
+// CHECK-LABEL: ; abi_handling::df2
+// CHECK-NEXT: Function Attrs
+// debug-NEXT: define internal { float, float }
+// debug-SAME: (ptr %f, float %x, float %dret)
+// release-NEXT: define internal fastcc float
+// release-SAME: (float noundef %x)
+
+// CHECK-LABEL: ; abi_handling::f2
+// CHECK-NEXT: Function Attrs
+// debug-NEXT: define internal float
+// debug-SAME: (ptr %f, float %x)
+// release-NEXT: define internal fastcc noundef float
+// release-SAME: (float noundef %x)
+#[autodiff_reverse(df2, Const, Active, Active)]
+#[inline(never)]
+fn f2(f: fn(f32) -> f32, x: f32) -> f32 {
+    f(x)
+}
+
+// CHECK-LABEL: ; abi_handling::df3
+// CHECK-NEXT: Function Attrs
+// debug-NEXT: define internal { float, float }
+// debug-SAME: (ptr align 4 %x, ptr align 4 %bx_0, ptr align 4 %y, ptr align 4 %by_0)
+// release-NEXT: define internal fastcc { float, float }
+// release-SAME: (float %x.0.val)
+
+// CHECK-LABEL: ; abi_handling::f3
+// CHECK-NEXT: Function Attrs
+// debug-NEXT: define internal float
+// debug-SAME: (ptr align 4 %x, ptr align 4 %y)
+// release-NEXT: define internal fastcc noundef float
+// release-SAME: (float %x.0.val)
+#[autodiff_forward(df3, Dual, Dual, Dual)]
+#[inline(never)]
+fn f3<'a>(x: &'a f32, y: &'a f32) -> f32 {
+    *x * *y
+}
+
+// CHECK-LABEL: ; abi_handling::df4
+// CHECK-NEXT: Function Attrs
+// debug-NEXT: define internal { float, float }
+// debug-SAME: (float %x.0, float %x.1, float %bx_0.0, float %bx_0.1)
+// release-NEXT: define internal fastcc { float, float }
+// release-SAME: (float noundef %x.0, float noundef %x.1)
+
+// CHECK-LABEL: ; abi_handling::f4
+// CHECK-NEXT: Function Attrs
+// debug-NEXT: define internal float
+// debug-SAME: (float %x.0, float %x.1)
+// release-NEXT: define internal fastcc noundef float
+// release-SAME: (float noundef %x.0, float noundef %x.1)
+#[autodiff_forward(df4, Dual, Dual)]
+#[inline(never)]
+fn f4(x: (f32, f32)) -> f32 {
+    x.0 * x.1
+}
+
+// CHECK-LABEL: ; abi_handling::df5
+// CHECK-NEXT: Function Attrs
+// debug-NEXT: define internal { float, float }
+// debug-SAME: (float %i.0, float %i.1, float %bi_0.0, float %bi_0.1)
+// release-NEXT: define internal fastcc { float, float }
+// release-SAME: (float noundef %i.0, float noundef %i.1)
+
+// CHECK-LABEL: ; abi_handling::f5
+// CHECK-NEXT: Function Attrs
+// debug-NEXT: define internal float
+// debug-SAME: (float %i.0, float %i.1)
+// release-NEXT: define internal fastcc noundef float
+// release-SAME: (float noundef %i.0, float noundef %i.1)
+#[autodiff_forward(df5, Dual, Dual)]
+#[inline(never)]
+fn f5(i: Input) -> f32 {
+    i.x + i.y
+}
+
+// CHECK-LABEL: ; abi_handling::df6
+// CHECK-NEXT: Function Attrs
+// debug-NEXT: define internal { float, float }
+// debug-SAME: (float %i.0, float %i.1, float %bi_0.0, float %bi_0.1)
+// release-NEXT: define internal fastcc { float, float }
+// release-SAME: float noundef %i.0, float noundef %i.1
+// release-SAME: float noundef %bi_0.0, float noundef %bi_0.1
+
+// CHECK-LABEL: ; abi_handling::f6
+// CHECK-NEXT: Function Attrs
+// debug-NEXT: define internal float
+// debug-SAME: (float %i.0, float %i.1)
+// release-NEXT: define internal fastcc noundef float
+// release-SAME: (float noundef %i.0, float noundef %i.1)
+#[autodiff_forward(df6, Dual, Dual)]
+#[inline(never)]
+fn f6(i: NestedInput) -> f32 {
+    i.x + i.y.z * i.y.z
+}
+
+// CHECK-LABEL: ; abi_handling::df7
+// CHECK-NEXT: Function Attrs
+// debug-NEXT: define internal { float, float }
+// debug-SAME: (ptr align 4 %x.0, ptr align 4 %x.1, ptr align 4 %bx_0.0, ptr align 4 %bx_0.1)
+// release-NEXT: define internal fastcc { float, float }
+// release-SAME: (float %x.0.0.val, float %x.1.0.val)
+
+// CHECK-LABEL: ; abi_handling::f7
+// CHECK-NEXT: Function Attrs
+// debug-NEXT: define internal float
+// debug-SAME: (ptr align 4 %x.0, ptr align 4 %x.1)
+// release-NEXT: define internal fastcc noundef float
+// release-SAME: (float %x.0.0.val, float %x.1.0.val)
+#[autodiff_forward(df7, Dual, Dual)]
+#[inline(never)]
+fn f7(x: (&f32, &f32)) -> f32 {
+    x.0 * x.1
+}
+
+fn main() {
+    let x = std::hint::black_box(2.0);
+    let y = std::hint::black_box(3.0);
+    let z = std::hint::black_box(4.0);
+    static Y: f32 = std::hint::black_box(3.2);
+
+    let in_f1 = [x, y];
+    dbg!(f1(&in_f1));
+    let res_f1 = df1(&in_f1, &[1.0, 0.0]);
+    dbg!(res_f1);
+
+    dbg!(f2(square, x));
+    let res_f2 = df2(square, x, 1.0);
+    dbg!(res_f2);
+
+    dbg!(f3(&x, &Y));
+    let res_f3 = df3(&x, &Y, &1.0, &0.0);
+    dbg!(res_f3);
+
+    let in_f4 = (x, y);
+    dbg!(f4(in_f4));
+    let res_f4 = df4(in_f4, (1.0, 0.0));
+    dbg!(res_f4);
+
+    let in_f5 = Input { x, y };
+    dbg!(f5(in_f5));
+    let res_f5 = df5(in_f5, Input { x: 1.0, y: 0.0 });
+    dbg!(res_f5);
+
+    let in_f6 = NestedInput { x, y: Wrapper { z: y } };
+    dbg!(f6(in_f6));
+    let res_f6 = df6(in_f6, NestedInput { x, y: Wrapper { z } });
+    dbg!(res_f6);
+
+    let in_f7 = (&x, &y);
+    dbg!(f7(in_f7));
+    let res_f7 = df7(in_f7, (&1.0, &0.0));
+    dbg!(res_f7);
+}

From 466bec90292a1b04a50a5889ab13fddd53c925ce Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Marcelo=20Dom=C3=ADnguez?= <dmmarcelo27@gmail.com>
Date: Mon, 14 Jul 2025 17:07:01 +0000
Subject: [PATCH 1037/1889] Adjust autodiff actitivies for ScalarPair

---
 .../rustc_codegen_llvm/src/builder/autodiff.rs  | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
index e2df3265f6f7d..a1cc4fdbdf67e 100644
--- a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
+++ b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
@@ -80,6 +80,23 @@ pub(crate) fn adjust_activity_to_abi<'tcx>(
                 continue;
             }
         }
+
+        let pci = PseudoCanonicalInput { typing_env: TypingEnv::fully_monomorphized(), value: *ty };
+
+        let layout = match tcx.layout_of(pci) {
+            Ok(layout) => layout.layout,
+            Err(_) => {
+                bug!("failed to compute layout for type {:?}", ty);
+            }
+        };
+
+        match layout.backend_repr() {
+            rustc_abi::BackendRepr::ScalarPair(_, _) => {
+                new_activities.push(da[i].clone());
+                new_positions.push(i + 1);
+            }
+            _ => {}
+        }
     }
     // now add the extra activities coming from slices
     // Reverse order to not invalidate the indices

From 8dbd1b014ac43cc9c950e3b7e112b62d0963ec17 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Marcelo=20Dom=C3=ADnguez?= <dmmarcelo27@gmail.com>
Date: Tue, 15 Jul 2025 09:56:51 +0000
Subject: [PATCH 1038/1889] doc and move single branch match to an if let

---
 compiler/rustc_codegen_llvm/src/builder/autodiff.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
index a1cc4fdbdf67e..a19a0d867ace8 100644
--- a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
+++ b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
@@ -90,12 +90,12 @@ pub(crate) fn adjust_activity_to_abi<'tcx>(
             }
         };
 
-        match layout.backend_repr() {
-            rustc_abi::BackendRepr::ScalarPair(_, _) => {
-                new_activities.push(da[i].clone());
-                new_positions.push(i + 1);
-            }
-            _ => {}
+        // If the argument is lowered as a `ScalarPair`, we need to duplicate its activity.
+        // Otherwise, the number of activities won't match the number of LLVM arguments and
+        // this will lead to errors when verifying the Enzyme call.
+        if let rustc_abi::BackendRepr::ScalarPair(_, _) = layout.backend_repr() {
+            new_activities.push(da[i].clone());
+            new_positions.push(i + 1);
         }
     }
     // now add the extra activities coming from slices

From ef90d22ddad5f2f43689e17fde5f048bcd83fd5a Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Wed, 17 Sep 2025 20:04:57 +0800
Subject: [PATCH 1039/1889] update enzyme submodule

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

diff --git a/src/tools/enzyme b/src/tools/enzyme
index 58af4e9e6c047..09f4820b78e2d 160000
--- a/src/tools/enzyme
+++ b/src/tools/enzyme
@@ -1 +1 @@
-Subproject commit 58af4e9e6c047534ba059b12af17cecb8a2e9f9e
+Subproject commit 09f4820b78e2d71b85a3278bbb41dc3a012e84dd

From 0bf85d35ec9ed9cbffd274def09027c5fe9a8f3c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Marcelo=20Dom=C3=ADnguez?= <dmmarcelo27@gmail.com>
Date: Sun, 3 Aug 2025 11:12:34 +0000
Subject: [PATCH 1040/1889] Support ZST args

---
 .../rustc_codegen_llvm/src/builder/autodiff.rs  | 11 ++++++++++-
 tests/ui/autodiff/zst.rs                        | 17 +++++++++++++++++
 2 files changed, 27 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/autodiff/zst.rs

diff --git a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
index a19a0d867ace8..78deffa3a7a6e 100644
--- a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
+++ b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
@@ -29,6 +29,7 @@ pub(crate) fn adjust_activity_to_abi<'tcx>(
 
     let mut new_activities = vec![];
     let mut new_positions = vec![];
+    let mut del_activities = 0;
     for (i, ty) in sig.inputs().iter().enumerate() {
         if let Some(inner_ty) = ty.builtin_deref(true) {
             if inner_ty.is_slice() {
@@ -90,12 +91,20 @@ pub(crate) fn adjust_activity_to_abi<'tcx>(
             }
         };
 
+        // For ZST, just ignore and don't add its activity, as this arg won't be present
+        // in the LLVM passed to Enzyme.
+        // FIXME(Sa4dUs): Enforce ZST corresponding diff activity be `Const`
+        if layout.is_zst() {
+            del_activities += 1;
+            da.remove(i);
+        }
+
         // If the argument is lowered as a `ScalarPair`, we need to duplicate its activity.
         // Otherwise, the number of activities won't match the number of LLVM arguments and
         // this will lead to errors when verifying the Enzyme call.
         if let rustc_abi::BackendRepr::ScalarPair(_, _) = layout.backend_repr() {
             new_activities.push(da[i].clone());
-            new_positions.push(i + 1);
+            new_positions.push(i + 1 - del_activities);
         }
     }
     // now add the extra activities coming from slices
diff --git a/tests/ui/autodiff/zst.rs b/tests/ui/autodiff/zst.rs
new file mode 100644
index 0000000000000..7b9b5f5f20bdc
--- /dev/null
+++ b/tests/ui/autodiff/zst.rs
@@ -0,0 +1,17 @@
+//@ compile-flags: -Zautodiff=Enable -C opt-level=3 -Clto=fat
+//@ no-prefer-dynamic
+//@ needs-enzyme
+//@ build-pass
+
+// Check that differentiating functions with ZST args does not break
+
+#![feature(autodiff)]
+
+#[core::autodiff::autodiff_forward(fd_inner, Const, Dual)]
+fn f(_zst: (), _x: &mut f64) {}
+
+fn fd(x: &mut f64, xd: &mut f64) {
+    fd_inner((), x, xd);
+}
+
+fn main() {}

From 923d1be6b6caec99a5eb46b3fb236f45f9e18233 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 17 Sep 2025 21:06:38 +1000
Subject: [PATCH 1041/1889] Use `LLVMDIBuilderCreateMemberType`

---
 .../src/debuginfo/metadata.rs                 |  4 +--
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs   | 28 +++++++++----------
 .../rustc_llvm/llvm-wrapper/RustWrapper.cpp   | 11 --------
 3 files changed, 16 insertions(+), 27 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
index 0903ddab28549..f2000311ae476 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
@@ -1034,10 +1034,10 @@ fn create_member_type<'ll, 'tcx>(
     type_di_node: &'ll DIType,
 ) -> &'ll DIType {
     unsafe {
-        llvm::LLVMRustDIBuilderCreateMemberType(
+        llvm::LLVMDIBuilderCreateMemberType(
             DIB(cx),
             owner,
-            name.as_c_char_ptr(),
+            name.as_ptr(),
             name.len(),
             file_metadata,
             line_number,
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 71d8b7d25fe72..2549296d12c69 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -1943,6 +1943,20 @@ unsafe extern "C" {
         UniqueId: *const c_uchar, // See "PTR_LEN_STR".
         UniqueIdLen: size_t,
     ) -> &'ll Metadata;
+
+    pub(crate) fn LLVMDIBuilderCreateMemberType<'ll>(
+        Builder: &DIBuilder<'ll>,
+        Scope: &'ll Metadata,
+        Name: *const c_uchar, // See "PTR_LEN_STR".
+        NameLen: size_t,
+        File: &'ll Metadata,
+        LineNo: c_uint,
+        SizeInBits: u64,
+        AlignInBits: u32,
+        OffsetInBits: u64,
+        Flags: DIFlags,
+        Ty: &'ll Metadata,
+    ) -> &'ll Metadata;
 }
 
 #[link(name = "llvm-wrapper", kind = "static")]
@@ -2288,20 +2302,6 @@ unsafe extern "C" {
         Scope: Option<&'a DIScope>,
     ) -> &'a DIDerivedType;
 
-    pub(crate) fn LLVMRustDIBuilderCreateMemberType<'a>(
-        Builder: &DIBuilder<'a>,
-        Scope: &'a DIDescriptor,
-        Name: *const c_char,
-        NameLen: size_t,
-        File: &'a DIFile,
-        LineNo: c_uint,
-        SizeInBits: u64,
-        AlignInBits: u32,
-        OffsetInBits: u64,
-        Flags: DIFlags,
-        Ty: &'a DIType,
-    ) -> &'a DIDerivedType;
-
     pub(crate) fn LLVMRustDIBuilderCreateVariantMemberType<'a>(
         Builder: &DIBuilder<'a>,
         Scope: &'a DIScope,
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index b4ca641674f08..af2469eeb9347 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -1088,17 +1088,6 @@ extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariantPart(
       StringRef(UniqueId, UniqueIdLen)));
 }
 
-extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateMemberType(
-    LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
-    size_t NameLen, LLVMMetadataRef File, unsigned LineNo, uint64_t SizeInBits,
-    uint32_t AlignInBits, uint64_t OffsetInBits, LLVMDIFlags Flags,
-    LLVMMetadataRef Ty) {
-  return wrap(unwrap(Builder)->createMemberType(
-      unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen),
-      unwrapDI<DIFile>(File), LineNo, SizeInBits, AlignInBits, OffsetInBits,
-      fromRust(Flags), unwrapDI<DIType>(Ty)));
-}
-
 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariantMemberType(
     LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
     size_t NameLen, LLVMMetadataRef File, unsigned LineNo, uint64_t SizeInBits,

From bb21dbeac79da68586d584ed2c7f8e87286fd8a8 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 17 Sep 2025 21:52:44 +1000
Subject: [PATCH 1042/1889] Use `LLVMDIBuilderCreateStaticMemberType`

---
 .../src/debuginfo/metadata/enums/cpp_like.rs  | 65 +++++++++++++------
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs   | 26 ++++----
 .../rustc_llvm/llvm-wrapper/RustWrapper.cpp   | 10 ---
 3 files changed, 57 insertions(+), 44 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 a5c808957410e..28945d6a2d7d4 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
@@ -11,7 +11,7 @@ use rustc_middle::ty::layout::{LayoutOf, TyAndLayout};
 use rustc_middle::ty::{self, AdtDef, CoroutineArgs, CoroutineArgsExt, Ty};
 use smallvec::smallvec;
 
-use crate::common::{AsCCharPtr, CodegenCx};
+use crate::common::CodegenCx;
 use crate::debuginfo::dwarf_const::DW_TAG_const_type;
 use crate::debuginfo::metadata::enums::DiscrResult;
 use crate::debuginfo::metadata::type_map::{self, Stub, UniqueTypeId};
@@ -378,20 +378,17 @@ fn build_single_variant_union_fields<'ll, 'tcx>(
             variant_struct_type_wrapper_di_node,
             None,
         ),
-        unsafe {
-            llvm::LLVMRustDIBuilderCreateStaticMemberType(
-                DIB(cx),
-                enum_type_di_node,
-                TAG_FIELD_NAME.as_c_char_ptr(),
-                TAG_FIELD_NAME.len(),
-                unknown_file_metadata(cx),
-                UNKNOWN_LINE_NUMBER,
-                variant_names_type_di_node,
-                visibility_flags,
-                Some(cx.const_u64(SINGLE_VARIANT_VIRTUAL_DISR)),
-                tag_base_type_align.bits() as u32,
-            )
-        }
+        create_static_member_type(
+            cx,
+            enum_type_di_node,
+            TAG_FIELD_NAME,
+            unknown_file_metadata(cx),
+            UNKNOWN_LINE_NUMBER,
+            variant_names_type_di_node,
+            visibility_flags,
+            Some(cx.const_u64(SINGLE_VARIANT_VIRTUAL_DISR)),
+            tag_base_type_align,
+        ),
     ]
 }
 
@@ -576,21 +573,20 @@ fn build_variant_struct_wrapper_type_di_node<'ll, 'tcx>(
                 // directly inspected via the debugger visualizer - which compares it to the `tag` value
                 // (whose type is not modified at all) it shouldn't cause any real problems.
                 let (t_di, align) = if name == ASSOC_CONST_DISCR_NAME {
-                    (type_di_node_, align.bits() as u32)
+                    (type_di_node_, align)
                 } else {
                     let ty_u64 = Ty::new_uint(cx.tcx, ty::UintTy::U64);
-                    (type_di_node(cx, ty_u64), Align::EIGHT.bits() as u32)
+                    (type_di_node(cx, ty_u64), Align::EIGHT)
                 };
 
                 // must wrap type in a `const` modifier for LLDB to be able to inspect the value of the member
                 let field_type =
                     llvm::LLVMRustDIBuilderCreateQualifiedType(DIB(cx), DW_TAG_const_type, t_di);
 
-                llvm::LLVMRustDIBuilderCreateStaticMemberType(
-                    DIB(cx),
+                create_static_member_type(
+                    cx,
                     wrapper_struct_type_di_node,
-                    name.as_c_char_ptr(),
-                    name.len(),
+                    name,
                     unknown_file_metadata(cx),
                     UNKNOWN_LINE_NUMBER,
                     field_type,
@@ -975,3 +971,30 @@ fn variant_struct_wrapper_type_name(variant_index: VariantIdx) -> Cow<'static, s
         .map(|&s| Cow::from(s))
         .unwrap_or_else(|| format!("Variant{}", variant_index.as_usize()).into())
 }
+
+fn create_static_member_type<'ll>(
+    cx: &CodegenCx<'ll, '_>,
+    scope: &'ll llvm::Metadata,
+    name: &str,
+    file: &'ll llvm::Metadata,
+    line_number: c_uint,
+    ty: &'ll llvm::Metadata,
+    flags: DIFlags,
+    value: Option<&'ll llvm::Value>,
+    align: Align,
+) -> &'ll llvm::Metadata {
+    unsafe {
+        llvm::LLVMDIBuilderCreateStaticMemberType(
+            DIB(cx),
+            scope,
+            name.as_ptr(),
+            name.len(),
+            file,
+            line_number,
+            ty,
+            flags,
+            value,
+            align.bits() as c_uint,
+        )
+    }
+}
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 2549296d12c69..a157a9b8c2610 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -1957,6 +1957,19 @@ unsafe extern "C" {
         Flags: DIFlags,
         Ty: &'ll Metadata,
     ) -> &'ll Metadata;
+
+    pub(crate) fn LLVMDIBuilderCreateStaticMemberType<'ll>(
+        Builder: &DIBuilder<'ll>,
+        Scope: &'ll Metadata,
+        Name: *const c_uchar, // See "PTR_LEN_STR".
+        NameLen: size_t,
+        File: &'ll Metadata,
+        LineNumber: c_uint,
+        Type: &'ll Metadata,
+        Flags: DIFlags,
+        ConstantVal: Option<&'ll Value>,
+        AlignInBits: u32,
+    ) -> &'ll Metadata;
 }
 
 #[link(name = "llvm-wrapper", kind = "static")]
@@ -2317,19 +2330,6 @@ unsafe extern "C" {
         Ty: &'a DIType,
     ) -> &'a DIType;
 
-    pub(crate) fn LLVMRustDIBuilderCreateStaticMemberType<'a>(
-        Builder: &DIBuilder<'a>,
-        Scope: &'a DIDescriptor,
-        Name: *const c_char,
-        NameLen: size_t,
-        File: &'a DIFile,
-        LineNo: c_uint,
-        Ty: &'a DIType,
-        Flags: DIFlags,
-        val: Option<&'a Value>,
-        AlignInBits: u32,
-    ) -> &'a DIDerivedType;
-
     pub(crate) fn LLVMRustDIBuilderCreateQualifiedType<'a>(
         Builder: &DIBuilder<'a>,
         Tag: c_uint,
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index af2469eeb9347..1b2303f5e7451 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -1103,16 +1103,6 @@ extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariantMemberType(
       fromRust(Flags), unwrapDI<DIType>(Ty)));
 }
 
-extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateStaticMemberType(
-    LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
-    size_t NameLen, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty,
-    LLVMDIFlags Flags, LLVMValueRef val, uint32_t AlignInBits) {
-  return wrap(unwrap(Builder)->createStaticMemberType(
-      unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen),
-      unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), fromRust(Flags),
-      unwrap<llvm::ConstantInt>(val), llvm::dwarf::DW_TAG_member, AlignInBits));
-}
-
 extern "C" LLVMMetadataRef
 LLVMRustDIBuilderCreateQualifiedType(LLVMDIBuilderRef Builder, unsigned Tag,
                                      LLVMMetadataRef Type) {

From 002771ab5c3a329038843d578d5f83c0289a959d Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 17 Sep 2025 21:36:59 +1000
Subject: [PATCH 1043/1889] Use `LLVMDIBuilderCreateQualifiedType`

---
 .../src/debuginfo/metadata/enums/cpp_like.rs       |  8 +++++---
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs        | 14 ++++++++------
 compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp   |  7 -------
 3 files changed, 13 insertions(+), 16 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 28945d6a2d7d4..4ecc3086e1bdf 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
@@ -567,7 +567,8 @@ fn build_variant_struct_wrapper_type_di_node<'ll, 'tcx>(
             let build_assoc_const = |name: &str,
                                      type_di_node_: &'ll DIType,
                                      value: u64,
-                                     align: Align| unsafe {
+                                     align: Align|
+             -> &'ll llvm::Metadata {
                 // FIXME: Currently we force all DISCR_* values to be u64's as LLDB seems to have
                 // problems inspecting other value types. Since DISCR_* is typically only going to be
                 // directly inspected via the debugger visualizer - which compares it to the `tag` value
@@ -580,8 +581,9 @@ fn build_variant_struct_wrapper_type_di_node<'ll, 'tcx>(
                 };
 
                 // must wrap type in a `const` modifier for LLDB to be able to inspect the value of the member
-                let field_type =
-                    llvm::LLVMRustDIBuilderCreateQualifiedType(DIB(cx), DW_TAG_const_type, t_di);
+                let field_type = unsafe {
+                    llvm::LLVMDIBuilderCreateQualifiedType(DIB(cx), DW_TAG_const_type, t_di)
+                };
 
                 create_static_member_type(
                     cx,
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index a157a9b8c2610..7c8a3261bb825 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -1970,6 +1970,14 @@ unsafe extern "C" {
         ConstantVal: Option<&'ll Value>,
         AlignInBits: u32,
     ) -> &'ll Metadata;
+
+    /// Creates a "qualified type" in the C/C++ sense, by adding modifiers
+    /// like `const` or `volatile`.
+    pub(crate) fn LLVMDIBuilderCreateQualifiedType<'ll>(
+        Builder: &DIBuilder<'ll>,
+        Tag: c_uint, // (DWARF tag, e.g. `DW_TAG_const_type`)
+        Type: &'ll Metadata,
+    ) -> &'ll Metadata;
 }
 
 #[link(name = "llvm-wrapper", kind = "static")]
@@ -2330,12 +2338,6 @@ unsafe extern "C" {
         Ty: &'a DIType,
     ) -> &'a DIType;
 
-    pub(crate) fn LLVMRustDIBuilderCreateQualifiedType<'a>(
-        Builder: &DIBuilder<'a>,
-        Tag: c_uint,
-        Type: &'a DIType,
-    ) -> &'a DIDerivedType;
-
     pub(crate) fn LLVMRustDIBuilderCreateStaticVariable<'a>(
         Builder: &DIBuilder<'a>,
         Context: Option<&'a DIScope>,
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index 1b2303f5e7451..eff1b75620597 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -1103,13 +1103,6 @@ extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariantMemberType(
       fromRust(Flags), unwrapDI<DIType>(Ty)));
 }
 
-extern "C" LLVMMetadataRef
-LLVMRustDIBuilderCreateQualifiedType(LLVMDIBuilderRef Builder, unsigned Tag,
-                                     LLVMMetadataRef Type) {
-  return wrap(
-      unwrap(Builder)->createQualifiedType(Tag, unwrapDI<DIType>(Type)));
-}
-
 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateStaticVariable(
     LLVMDIBuilderRef Builder, LLVMMetadataRef Context, const char *Name,
     size_t NameLen, const char *LinkageName, size_t LinkageNameLen,

From 6b51f7c07666b1b1446201477ad887fdfa26e08a Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 17 Sep 2025 21:36:59 +1000
Subject: [PATCH 1044/1889] Use `LLVMDIBuilderCreateTypedef`

---
 .../src/debuginfo/metadata.rs                 |  9 ++++----
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs   | 23 ++++++++++---------
 .../rustc_llvm/llvm-wrapper/RustWrapper.cpp   | 10 --------
 3 files changed, 17 insertions(+), 25 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
index f2000311ae476..aa8b8bd152dcc 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
@@ -821,14 +821,15 @@ fn build_basic_type_di_node<'ll, 'tcx>(
     };
 
     let typedef_di_node = unsafe {
-        llvm::LLVMRustDIBuilderCreateTypedef(
+        llvm::LLVMDIBuilderCreateTypedef(
             DIB(cx),
             ty_di_node,
-            typedef_name.as_c_char_ptr(),
+            typedef_name.as_ptr(),
             typedef_name.len(),
             unknown_file_metadata(cx),
-            0,
-            None,
+            0,    // (no line number)
+            None, // (no scope)
+            0u32, // (no alignment specified)
         )
     };
 
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 7c8a3261bb825..1124ebc3d44b0 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -24,7 +24,7 @@ use rustc_target::spec::SymbolVisibility;
 
 use super::RustString;
 use super::debuginfo::{
-    DIArray, DIBasicType, DIBuilder, DIDerivedType, DIDescriptor, DIEnumerator, DIFile, DIFlags,
+    DIArray, DIBuilder, DIDerivedType, DIDescriptor, DIEnumerator, DIFile, DIFlags,
     DIGlobalVariableExpression, DILocation, DISPFlags, DIScope, DISubprogram, DISubrange,
     DITemplateTypeParameter, DIType, DIVariable, DebugEmissionKind, DebugNameTableKind,
 };
@@ -1978,6 +1978,17 @@ unsafe extern "C" {
         Tag: c_uint, // (DWARF tag, e.g. `DW_TAG_const_type`)
         Type: &'ll Metadata,
     ) -> &'ll Metadata;
+
+    pub(crate) fn LLVMDIBuilderCreateTypedef<'ll>(
+        Builder: &DIBuilder<'ll>,
+        Type: &'ll Metadata,
+        Name: *const c_uchar, // See "PTR_LEN_STR".
+        NameLen: size_t,
+        File: &'ll Metadata,
+        LineNo: c_uint,
+        Scope: Option<&'ll Metadata>,
+        AlignInBits: u32, // (optional; default is 0)
+    ) -> &'ll Metadata;
 }
 
 #[link(name = "llvm-wrapper", kind = "static")]
@@ -2313,16 +2324,6 @@ unsafe extern "C" {
         TParam: &'a DIArray,
     ) -> &'a DISubprogram;
 
-    pub(crate) fn LLVMRustDIBuilderCreateTypedef<'a>(
-        Builder: &DIBuilder<'a>,
-        Type: &'a DIBasicType,
-        Name: *const c_char,
-        NameLen: size_t,
-        File: &'a DIFile,
-        LineNo: c_uint,
-        Scope: Option<&'a DIScope>,
-    ) -> &'a DIDerivedType;
-
     pub(crate) fn LLVMRustDIBuilderCreateVariantMemberType<'a>(
         Builder: &DIBuilder<'a>,
         Scope: &'a DIScope,
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index eff1b75620597..64151962321fd 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -1064,16 +1064,6 @@ extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateMethod(
   return wrap(Sub);
 }
 
-extern "C" LLVMMetadataRef
-LLVMRustDIBuilderCreateTypedef(LLVMDIBuilderRef Builder, LLVMMetadataRef Type,
-                               const char *Name, size_t NameLen,
-                               LLVMMetadataRef File, unsigned LineNo,
-                               LLVMMetadataRef Scope) {
-  return wrap(unwrap(Builder)->createTypedef(
-      unwrap<DIType>(Type), StringRef(Name, NameLen), unwrap<DIFile>(File),
-      LineNo, unwrapDIPtr<DIScope>(Scope)));
-}
-
 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariantPart(
     LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
     size_t NameLen, LLVMMetadataRef File, unsigned LineNumber,

From ea8baccbb15fd58afcde959eed7dc73741dd626d Mon Sep 17 00:00:00 2001
From: Tsukasa OI <floss_rust@irq.a4lg.com>
Date: Wed, 17 Sep 2025 12:35:21 +0000
Subject: [PATCH 1045/1889] rustc_codegen_llvm: Name major version of LLVM

It makes LLVM version comparison clearer.
---
 compiler/rustc_codegen_llvm/src/llvm_util.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index 8461c8b03d5a4..393361a1afe2a 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -228,6 +228,7 @@ pub(crate) fn to_llvm_features<'a>(sess: &Session, s: &'a str) -> Option<LLVMFea
     } else {
         &*sess.target.arch
     };
+    let (major, _, _) = get_version();
     match (arch, s) {
         ("x86", "sse4.2") => Some(LLVMFeature::with_dependencies(
             "sse4.2",
@@ -260,7 +261,7 @@ pub(crate) fn to_llvm_features<'a>(sess: &Session, s: &'a str) -> Option<LLVMFea
         ("aarch64", "fpmr") => None, // only existed in 18
         ("arm", "fp16") => Some(LLVMFeature::new("fullfp16")),
         // Filter out features that are not supported by the current LLVM version
-        ("loongarch32" | "loongarch64", "32s") if get_version().0 < 21 => None,
+        ("loongarch32" | "loongarch64", "32s") if major < 21 => None,
         // Enable the evex512 target feature if an avx512 target feature is enabled.
         ("x86", s) if s.starts_with("avx512") => Some(LLVMFeature::with_dependencies(
             s,

From d9f67cbb8be4500ba73bb30177c05153cbc9424a Mon Sep 17 00:00:00 2001
From: Tsukasa OI <floss_rust@irq.a4lg.com>
Date: Wed, 17 Sep 2025 12:35:21 +0000
Subject: [PATCH 1046/1889] rustc_codegen_llvm: Simplify `arch` conversion

This commit simplifies construction of `arch` from `sess.target.arch`.
It also preserves a reference to `sess.target.arch` as `raw_arch`
to make this function future proof.
---
 compiler/rustc_codegen_llvm/src/llvm_util.rs | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index 393361a1afe2a..6849cd241644a 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -217,16 +217,13 @@ impl<'a> IntoIterator for LLVMFeature<'a> {
 /// 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) -> Option<LLVMFeature<'a>> {
-    let arch = if sess.target.arch == "x86_64" {
-        "x86"
-    } else if sess.target.arch == "arm64ec" {
-        "aarch64"
-    } else if sess.target.arch == "sparc64" {
-        "sparc"
-    } else if sess.target.arch == "powerpc64" {
-        "powerpc"
-    } else {
-        &*sess.target.arch
+    let raw_arch = &*sess.target.arch;
+    let arch = match raw_arch {
+        "x86_64" => "x86",
+        "arm64ec" => "aarch64",
+        "sparc64" => "sparc",
+        "powerpc64" => "powerpc",
+        _ => raw_arch,
     };
     let (major, _, _) = get_version();
     match (arch, s) {

From a1a3cd043815a8b6e5faf53f33002d8dec1b2f30 Mon Sep 17 00:00:00 2001
From: Tsukasa OI <floss_rust@irq.a4lg.com>
Date: Wed, 17 Sep 2025 12:35:21 +0000
Subject: [PATCH 1047/1889] rustc_codegen_llvm: Reorder conversion cases

For maintainability, this commit reorders target feature conversion
cases by the architecture.
---
 compiler/rustc_codegen_llvm/src/llvm_util.rs | 22 ++++++++++----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index 6849cd241644a..45c5c9aa5514d 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -227,15 +227,6 @@ pub(crate) fn to_llvm_features<'a>(sess: &Session, s: &'a str) -> Option<LLVMFea
     };
     let (major, _, _) = get_version();
     match (arch, s) {
-        ("x86", "sse4.2") => Some(LLVMFeature::with_dependencies(
-            "sse4.2",
-            smallvec![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")),
@@ -259,13 +250,22 @@ pub(crate) fn to_llvm_features<'a>(sess: &Session, s: &'a str) -> Option<LLVMFea
         ("arm", "fp16") => Some(LLVMFeature::new("fullfp16")),
         // Filter out features that are not supported by the current LLVM version
         ("loongarch32" | "loongarch64", "32s") if major < 21 => None,
+        ("powerpc", "power8-crypto") => Some(LLVMFeature::new("crypto")),
+        ("sparc", "leoncasa") => Some(LLVMFeature::new("hasleoncasa")),
+        ("x86", "sse4.2") => Some(LLVMFeature::with_dependencies(
+            "sse4.2",
+            smallvec![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")),
         // Enable the evex512 target feature if an avx512 target feature is enabled.
         ("x86", s) if s.starts_with("avx512") => Some(LLVMFeature::with_dependencies(
             s,
             smallvec![TargetFeatureFoldStrength::EnableOnly("evex512")],
         )),
-        ("sparc", "leoncasa") => Some(LLVMFeature::new("hasleoncasa")),
-        ("powerpc", "power8-crypto") => Some(LLVMFeature::new("crypto")),
         ("x86", "avx10.1") => Some(LLVMFeature::new("avx10.1-512")),
         ("x86", "avx10.2") => Some(LLVMFeature::new("avx10.2-512")),
         ("x86", "apxf") => Some(LLVMFeature::with_dependencies(

From 6f813e887af44d74e9bcfdb207ecab407037a939 Mon Sep 17 00:00:00 2001
From: Reuben Cruise <reuben.cruise@arm.com>
Date: Mon, 1 Sep 2025 16:53:50 +0100
Subject: [PATCH 1048/1889] Adds AArch64 GCS support

- Adds option to rustc config to enable GCS
- Passes `guarded-control-stack` flag to llvm if enabled
---
 compiler/rustc_codegen_llvm/src/attributes.rs            | 5 ++++-
 compiler/rustc_codegen_llvm/src/context.rs               | 9 ++++++++-
 compiler/rustc_interface/src/tests.rs                    | 3 ++-
 compiler/rustc_session/src/config.rs                     | 1 +
 compiler/rustc_session/src/options.rs                    | 3 ++-
 .../src/compiler-flags/branch-protection.md              | 1 +
 6 files changed, 18 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/attributes.rs b/compiler/rustc_codegen_llvm/src/attributes.rs
index 573c51a95398b..dcf6b9454978c 100644
--- a/compiler/rustc_codegen_llvm/src/attributes.rs
+++ b/compiler/rustc_codegen_llvm/src/attributes.rs
@@ -407,13 +407,16 @@ pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>(
         to_add.extend(sanitize_attrs(cx, codegen_fn_attrs.no_sanitize));
 
         // For non-naked functions, set branch protection attributes on aarch64.
-        if let Some(BranchProtection { bti, pac_ret }) =
+        if let Some(BranchProtection { bti, pac_ret, gcs }) =
             cx.sess().opts.unstable_opts.branch_protection
         {
             assert!(cx.sess().target.arch == "aarch64");
             if bti {
                 to_add.push(llvm::CreateAttrString(cx.llcx, "branch-target-enforcement"));
             }
+            if gcs {
+                to_add.push(llvm::CreateAttrString(cx.llcx, "guarded-control-stack"));
+            }
             if let Some(PacRet { leaf, pc, key }) = pac_ret {
                 if pc {
                     to_add.push(llvm::CreateAttrString(cx.llcx, "branch-protection-pauth-lr"));
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index 4a8ea11a3a834..057f525c76f03 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -370,7 +370,8 @@ pub(crate) unsafe fn create_module<'ll>(
         );
     }
 
-    if let Some(BranchProtection { bti, pac_ret }) = sess.opts.unstable_opts.branch_protection {
+    if let Some(BranchProtection { bti, pac_ret, gcs }) = sess.opts.unstable_opts.branch_protection
+    {
         if sess.target.arch == "aarch64" {
             llvm::add_module_flag_u32(
                 llmod,
@@ -403,6 +404,12 @@ pub(crate) unsafe fn create_module<'ll>(
                 "sign-return-address-with-bkey",
                 u32::from(pac_opts.key == PAuthKey::B),
             );
+            llvm::add_module_flag_u32(
+                llmod,
+                llvm::ModuleFlagMergeBehavior::Min,
+                "guarded-control-stack",
+                gcs.into(),
+            );
         } else {
             bug!(
                 "branch-protection used on non-AArch64 target; \
diff --git a/compiler/rustc_interface/src/tests.rs b/compiler/rustc_interface/src/tests.rs
index 7730bddc0f12d..800f5efee41bf 100644
--- a/compiler/rustc_interface/src/tests.rs
+++ b/compiler/rustc_interface/src/tests.rs
@@ -772,7 +772,8 @@ fn test_unstable_options_tracking_hash() {
         branch_protection,
         Some(BranchProtection {
             bti: true,
-            pac_ret: Some(PacRet { leaf: true, pc: true, key: PAuthKey::B })
+            pac_ret: Some(PacRet { leaf: true, pc: true, key: PAuthKey::B }),
+            gcs: true,
         })
     );
     tracked!(codegen_backend, Some("abc".to_string()));
diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs
index 297df7c2c9765..8d9f424f1fe37 100644
--- a/compiler/rustc_session/src/config.rs
+++ b/compiler/rustc_session/src/config.rs
@@ -1615,6 +1615,7 @@ pub struct PacRet {
 pub struct BranchProtection {
     pub bti: bool,
     pub pac_ret: Option<PacRet>,
+    pub gcs: bool,
 }
 
 pub(crate) const fn default_lib_output() -> CrateType {
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
index 69facde693689..7956a06f6a985 100644
--- a/compiler/rustc_session/src/options.rs
+++ b/compiler/rustc_session/src/options.rs
@@ -866,7 +866,7 @@ mod desc {
     pub(crate) const parse_polonius: &str = "either no value or `legacy` (the default), or `next`";
     pub(crate) const parse_stack_protector: &str =
         "one of (`none` (default), `basic`, `strong`, or `all`)";
-    pub(crate) const parse_branch_protection: &str = "a `,` separated combination of `bti`, `pac-ret`, followed by a combination of `pc`, `b-key`, or `leaf`";
+    pub(crate) const parse_branch_protection: &str = "a `,` separated combination of `bti`, `gcs`, `pac-ret`, (optionally with `pc`, `b-key`, `leaf` if `pac-ret` is set)";
     pub(crate) const parse_proc_macro_execution_strategy: &str =
         "one of supported execution strategies (`same-thread`, or `cross-thread`)";
     pub(crate) const parse_remap_path_scope: &str =
@@ -1903,6 +1903,7 @@ pub mod parse {
                             Some(pac) => pac.pc = true,
                             _ => return false,
                         },
+                        "gcs" => slot.gcs = true,
                         _ => return false,
                     };
                 }
diff --git a/src/doc/unstable-book/src/compiler-flags/branch-protection.md b/src/doc/unstable-book/src/compiler-flags/branch-protection.md
index f0cc44a07f30d..c15567dcac2ee 100644
--- a/src/doc/unstable-book/src/compiler-flags/branch-protection.md
+++ b/src/doc/unstable-book/src/compiler-flags/branch-protection.md
@@ -13,6 +13,7 @@ It takes some combination of the following values, separated by a `,`.
 - `leaf` - Enable pointer authentication for all functions, including leaf functions.
 - `b-key` - Sign return addresses with key B, instead of the default key A.
 - `bti` - Enable branch target identification.
+- `gcs` - Enable guarded control stack support.
 
 `leaf`, `b-key` and `pc` are only valid if `pac-ret` was previously specified.
 For example, `-Z branch-protection=bti,pac-ret,leaf` is valid, but

From 2972ae5e539162778f83529599040d5bbc4adca4 Mon Sep 17 00:00:00 2001
From: Emmanuel Thompson <eet6646@gmail.com>
Date: Sat, 28 Jun 2025 19:39:43 -0400
Subject: [PATCH 1049/1889] rename_lint: unchecked_duration_subtraction to
 unchecked_time_subtraction

---
 CHANGELOG.md                                  |   1 +
 book/src/lint_configuration.md                |   2 +-
 clippy_config/src/conf.rs                     |   2 +-
 clippy_lints/src/declared_lints.rs            |   2 +-
 clippy_lints/src/deprecated_lints.rs          |   2 +
 clippy_lints/src/instant_subtraction.rs       |   6 +-
 tests/ui/manual_instant_elapsed.fixed         |   2 +-
 tests/ui/manual_instant_elapsed.rs            |   2 +-
 tests/ui/rename.fixed                         |   2 +
 tests/ui/rename.rs                            |   2 +
 tests/ui/rename.stderr                        | 154 +++++++++---------
 ...fixed => unchecked_time_subtraction.fixed} |  10 +-
 ...ction.rs => unchecked_time_subtraction.rs} |  10 +-
 ...derr => unchecked_time_subtraction.stderr} |  12 +-
 14 files changed, 111 insertions(+), 98 deletions(-)
 rename tests/ui/{unchecked_duration_subtraction.fixed => unchecked_time_subtraction.fixed} (64%)
 rename tests/ui/{unchecked_duration_subtraction.rs => unchecked_time_subtraction.rs} (58%)
 rename tests/ui/{unchecked_duration_subtraction.stderr => unchecked_time_subtraction.stderr} (75%)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4a9be02143722..2144d68ae1527 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6702,6 +6702,7 @@ Released 2018-09-13
 [`type_repetition_in_bounds`]: https://rust-lang.github.io/rust-clippy/master/index.html#type_repetition_in_bounds
 [`unbuffered_bytes`]: https://rust-lang.github.io/rust-clippy/master/index.html#unbuffered_bytes
 [`unchecked_duration_subtraction`]: https://rust-lang.github.io/rust-clippy/master/index.html#unchecked_duration_subtraction
+[`unchecked_time_subtraction`]: https://rust-lang.github.io/rust-clippy/master/index.html#unchecked_time_subtraction
 [`unconditional_recursion`]: https://rust-lang.github.io/rust-clippy/master/index.html#unconditional_recursion
 [`undocumented_unsafe_blocks`]: https://rust-lang.github.io/rust-clippy/master/index.html#undocumented_unsafe_blocks
 [`undropped_manually_drops`]: https://rust-lang.github.io/rust-clippy/master/index.html#undropped_manually_drops
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index c2d080cd96a1d..5502e6ff5e833 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -894,7 +894,7 @@ The minimum rust version that the project supports. Defaults to the `rust-versio
 * [`transmute_ptr_to_ref`](https://rust-lang.github.io/rust-clippy/master/index.html#transmute_ptr_to_ref)
 * [`tuple_array_conversions`](https://rust-lang.github.io/rust-clippy/master/index.html#tuple_array_conversions)
 * [`type_repetition_in_bounds`](https://rust-lang.github.io/rust-clippy/master/index.html#type_repetition_in_bounds)
-* [`unchecked_duration_subtraction`](https://rust-lang.github.io/rust-clippy/master/index.html#unchecked_duration_subtraction)
+* [`unchecked_time_subtraction`](https://rust-lang.github.io/rust-clippy/master/index.html#unchecked_time_subtraction)
 * [`uninlined_format_args`](https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args)
 * [`unnecessary_lazy_evaluations`](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_lazy_evaluations)
 * [`unnested_or_patterns`](https://rust-lang.github.io/rust-clippy/master/index.html#unnested_or_patterns)
diff --git a/clippy_config/src/conf.rs b/clippy_config/src/conf.rs
index 2f28f6175ad82..ae994815f63a5 100644
--- a/clippy_config/src/conf.rs
+++ b/clippy_config/src/conf.rs
@@ -790,7 +790,7 @@ define_Conf! {
         transmute_ptr_to_ref,
         tuple_array_conversions,
         type_repetition_in_bounds,
-        unchecked_duration_subtraction,
+        unchecked_time_subtraction,
         uninlined_format_args,
         unnecessary_lazy_evaluations,
         unnested_or_patterns,
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 1b19a8851edd4..7734f2266308f 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -227,7 +227,7 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::init_numbered_fields::INIT_NUMBERED_FIELDS_INFO,
     crate::inline_fn_without_body::INLINE_FN_WITHOUT_BODY_INFO,
     crate::instant_subtraction::MANUAL_INSTANT_ELAPSED_INFO,
-    crate::instant_subtraction::UNCHECKED_DURATION_SUBTRACTION_INFO,
+    crate::instant_subtraction::UNCHECKED_TIME_SUBTRACTION_INFO,
     crate::int_plus_one::INT_PLUS_ONE_INFO,
     crate::integer_division_remainder_used::INTEGER_DIVISION_REMAINDER_USED_INFO,
     crate::invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS_INFO,
diff --git a/clippy_lints/src/deprecated_lints.rs b/clippy_lints/src/deprecated_lints.rs
index 88aebc3e6a168..80b74f50223a4 100644
--- a/clippy_lints/src/deprecated_lints.rs
+++ b/clippy_lints/src/deprecated_lints.rs
@@ -184,6 +184,8 @@ declare_with_version! { RENAMED(RENAMED_VERSION) = [
     ("clippy::transmute_int_to_float", "unnecessary_transmutes"),
     #[clippy::version = "1.88.0"]
     ("clippy::transmute_num_to_bytes", "unnecessary_transmutes"),
+    #[clippy::version = "1.90.0"]
+    ("clippy::unchecked_duration_subtraction", "clippy::unchecked_time_subtraction"),
     #[clippy::version = ""]
     ("clippy::undropped_manually_drops", "undropped_manually_drops"),
     #[clippy::version = ""]
diff --git a/clippy_lints/src/instant_subtraction.rs b/clippy_lints/src/instant_subtraction.rs
index 13117f60abd52..5fe26e3e3e0c3 100644
--- a/clippy_lints/src/instant_subtraction.rs
+++ b/clippy_lints/src/instant_subtraction.rs
@@ -59,7 +59,7 @@ declare_clippy_lint! {
     /// let time_passed = Instant::now().checked_sub(Duration::from_secs(5));
     /// ```
     #[clippy::version = "1.67.0"]
-    pub UNCHECKED_DURATION_SUBTRACTION,
+    pub UNCHECKED_TIME_SUBTRACTION,
     pedantic,
     "finds unchecked subtraction of a 'Duration' from an 'Instant'"
 }
@@ -74,7 +74,7 @@ impl InstantSubtraction {
     }
 }
 
-impl_lint_pass!(InstantSubtraction => [MANUAL_INSTANT_ELAPSED, UNCHECKED_DURATION_SUBTRACTION]);
+impl_lint_pass!(InstantSubtraction => [MANUAL_INSTANT_ELAPSED, UNCHECKED_TIME_SUBTRACTION]);
 
 impl LateLintPass<'_> for InstantSubtraction {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
@@ -141,7 +141,7 @@ fn print_unchecked_duration_subtraction_sugg(
 
     span_lint_and_sugg(
         cx,
-        UNCHECKED_DURATION_SUBTRACTION,
+        UNCHECKED_TIME_SUBTRACTION,
         expr.span,
         "unchecked subtraction of a 'Duration' from an 'Instant'",
         "try",
diff --git a/tests/ui/manual_instant_elapsed.fixed b/tests/ui/manual_instant_elapsed.fixed
index 187802bb76c9e..a04c601e08c10 100644
--- a/tests/ui/manual_instant_elapsed.fixed
+++ b/tests/ui/manual_instant_elapsed.fixed
@@ -1,6 +1,6 @@
 #![warn(clippy::manual_instant_elapsed)]
 #![allow(clippy::unnecessary_operation)]
-#![allow(clippy::unchecked_duration_subtraction)]
+#![allow(clippy::unchecked_time_subtraction)]
 #![allow(unused_variables)]
 #![allow(unused_must_use)]
 
diff --git a/tests/ui/manual_instant_elapsed.rs b/tests/ui/manual_instant_elapsed.rs
index 61e14e5a3d9d3..7c67f6acf85de 100644
--- a/tests/ui/manual_instant_elapsed.rs
+++ b/tests/ui/manual_instant_elapsed.rs
@@ -1,6 +1,6 @@
 #![warn(clippy::manual_instant_elapsed)]
 #![allow(clippy::unnecessary_operation)]
-#![allow(clippy::unchecked_duration_subtraction)]
+#![allow(clippy::unchecked_time_subtraction)]
 #![allow(unused_variables)]
 #![allow(unused_must_use)]
 
diff --git a/tests/ui/rename.fixed b/tests/ui/rename.fixed
index ff81c64260274..fdd851414746b 100644
--- a/tests/ui/rename.fixed
+++ b/tests/ui/rename.fixed
@@ -58,6 +58,7 @@
 #![allow(clippy::missing_const_for_thread_local)]
 #![allow(clippy::recursive_format_impl)]
 #![allow(unnecessary_transmutes)]
+#![allow(clippy::unchecked_time_subtraction)]
 #![allow(undropped_manually_drops)]
 #![allow(unknown_lints)]
 #![allow(unused_labels)]
@@ -131,6 +132,7 @@
 #![warn(unnecessary_transmutes)] //~ ERROR: lint `clippy::transmute_int_to_char`
 #![warn(unnecessary_transmutes)] //~ ERROR: lint `clippy::transmute_int_to_float`
 #![warn(unnecessary_transmutes)] //~ ERROR: lint `clippy::transmute_num_to_bytes`
+#![warn(clippy::unchecked_time_subtraction)] //~ ERROR: lint `clippy::unchecked_duration_subtraction`
 #![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`
diff --git a/tests/ui/rename.rs b/tests/ui/rename.rs
index b5d5d07e639a0..591c8ca53ac22 100644
--- a/tests/ui/rename.rs
+++ b/tests/ui/rename.rs
@@ -58,6 +58,7 @@
 #![allow(clippy::missing_const_for_thread_local)]
 #![allow(clippy::recursive_format_impl)]
 #![allow(unnecessary_transmutes)]
+#![allow(clippy::unchecked_time_subtraction)]
 #![allow(undropped_manually_drops)]
 #![allow(unknown_lints)]
 #![allow(unused_labels)]
@@ -131,6 +132,7 @@
 #![warn(clippy::transmute_int_to_char)] //~ ERROR: lint `clippy::transmute_int_to_char`
 #![warn(clippy::transmute_int_to_float)] //~ ERROR: lint `clippy::transmute_int_to_float`
 #![warn(clippy::transmute_num_to_bytes)] //~ ERROR: lint `clippy::transmute_num_to_bytes`
+#![warn(clippy::unchecked_duration_subtraction)] //~ ERROR: lint `clippy::unchecked_duration_subtraction`
 #![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`
diff --git a/tests/ui/rename.stderr b/tests/ui/rename.stderr
index 2487dfc8eba44..b54fec8c57949 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:67:9
+  --> tests/ui/rename.rs:68:9
    |
 LL | #![warn(clippy::almost_complete_letter_range)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::almost_complete_range`
@@ -8,436 +8,442 @@ 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:68:9
+  --> tests/ui/rename.rs:69: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:69:9
+  --> tests/ui/rename.rs:70: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:70:9
+  --> tests/ui/rename.rs:71: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:71:9
+  --> tests/ui/rename.rs:72: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:72:9
+  --> tests/ui/rename.rs:73:9
    |
 LL | #![warn(clippy::box_vec)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::box_collection`
 
 error: lint `clippy::cast_ref_to_mut` has been renamed to `invalid_reference_casting`
-  --> tests/ui/rename.rs:73:9
+  --> tests/ui/rename.rs:74: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:74:9
+  --> tests/ui/rename.rs:75: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:75:9
+  --> tests/ui/rename.rs:76:9
    |
 LL | #![warn(clippy::cmp_nan)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `invalid_nan_comparisons`
 
 error: lint `clippy::const_static_lifetime` has been renamed to `clippy::redundant_static_lifetimes`
-  --> tests/ui/rename.rs:76:9
+  --> tests/ui/rename.rs:77: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:77:9
+  --> tests/ui/rename.rs:78: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:78:9
+  --> tests/ui/rename.rs:79: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:79:9
+  --> tests/ui/rename.rs:80: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:80:9
+  --> tests/ui/rename.rs:81:9
    |
 LL | #![warn(clippy::disallowed_type)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_types`
 
 error: lint `clippy::double_neg` has been renamed to `double_negations`
-  --> tests/ui/rename.rs:81:9
+  --> tests/ui/rename.rs:82:9
    |
 LL | #![warn(clippy::double_neg)]
    |         ^^^^^^^^^^^^^^^^^^ help: use the new name: `double_negations`
 
 error: lint `clippy::drop_bounds` has been renamed to `drop_bounds`
-  --> tests/ui/rename.rs:82:9
+  --> tests/ui/rename.rs:83: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:83:9
+  --> tests/ui/rename.rs:84: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:84:9
+  --> tests/ui/rename.rs:85:9
    |
 LL | #![warn(clippy::drop_ref)]
    |         ^^^^^^^^^^^^^^^^ help: use the new name: `dropping_references`
 
 error: lint `clippy::eval_order_dependence` has been renamed to `clippy::mixed_read_write_in_expression`
-  --> tests/ui/rename.rs:85:9
+  --> tests/ui/rename.rs:86:9
    |
 LL | #![warn(clippy::eval_order_dependence)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::mixed_read_write_in_expression`
 
 error: lint `clippy::filter_map` has been renamed to `clippy::manual_filter_map`
-  --> tests/ui/rename.rs:86:9
+  --> tests/ui/rename.rs:87:9
    |
 LL | #![warn(clippy::filter_map)]
    |         ^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::manual_filter_map`
 
 error: lint `clippy::find_map` has been renamed to `clippy::manual_find_map`
-  --> tests/ui/rename.rs:87:9
+  --> tests/ui/rename.rs:88:9
    |
 LL | #![warn(clippy::find_map)]
    |         ^^^^^^^^^^^^^^^^ help: use the new name: `clippy::manual_find_map`
 
 error: lint `clippy::fn_address_comparisons` has been renamed to `unpredictable_function_pointer_comparisons`
-  --> tests/ui/rename.rs:88:9
+  --> tests/ui/rename.rs:89:9
    |
 LL | #![warn(clippy::fn_address_comparisons)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unpredictable_function_pointer_comparisons`
 
 error: lint `clippy::fn_null_check` has been renamed to `useless_ptr_null_checks`
-  --> tests/ui/rename.rs:89:9
+  --> tests/ui/rename.rs:90: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:90:9
+  --> tests/ui/rename.rs:91: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:91:9
+  --> tests/ui/rename.rs:92: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:92:9
+  --> tests/ui/rename.rs:93: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:93:9
+  --> tests/ui/rename.rs:94: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:94:9
+  --> tests/ui/rename.rs:95:9
    |
 LL | #![warn(clippy::forget_ref)]
    |         ^^^^^^^^^^^^^^^^^^ help: use the new name: `forgetting_references`
 
 error: lint `clippy::identity_conversion` has been renamed to `clippy::useless_conversion`
-  --> tests/ui/rename.rs:95:9
+  --> tests/ui/rename.rs:96: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:96:9
+  --> tests/ui/rename.rs:97: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:97:9
+  --> tests/ui/rename.rs:98: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:98:9
+  --> tests/ui/rename.rs:99: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:99:9
+  --> tests/ui/rename.rs:100: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:100:9
+  --> tests/ui/rename.rs:101:9
    |
 LL | #![warn(clippy::integer_arithmetic)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::arithmetic_side_effects`
 
 error: lint `clippy::into_iter_on_array` has been renamed to `array_into_iter`
-  --> tests/ui/rename.rs:101:9
+  --> tests/ui/rename.rs:102: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:102:9
+  --> tests/ui/rename.rs:103:9
    |
 LL | #![warn(clippy::invalid_atomic_ordering)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_atomic_ordering`
 
 error: lint `clippy::invalid_null_ptr_usage` has been renamed to `invalid_null_arguments`
-  --> tests/ui/rename.rs:103:9
+  --> tests/ui/rename.rs:104:9
    |
 LL | #![warn(clippy::invalid_null_ptr_usage)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_null_arguments`
 
 error: lint `clippy::invalid_ref` has been renamed to `invalid_value`
-  --> tests/ui/rename.rs:104:9
+  --> tests/ui/rename.rs:105: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:105:9
+  --> tests/ui/rename.rs:106: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:106:9
+  --> tests/ui/rename.rs:107:9
    |
 LL | #![warn(clippy::let_underscore_drop)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `let_underscore_drop`
 
 error: lint `clippy::logic_bug` has been renamed to `clippy::overly_complex_bool_expr`
-  --> tests/ui/rename.rs:107:9
+  --> tests/ui/rename.rs:108:9
    |
 LL | #![warn(clippy::logic_bug)]
    |         ^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::overly_complex_bool_expr`
 
 error: lint `clippy::maybe_misused_cfg` has been renamed to `unexpected_cfgs`
-  --> tests/ui/rename.rs:108:9
+  --> tests/ui/rename.rs:109: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:109:9
+  --> tests/ui/rename.rs:110: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:110:9
+  --> tests/ui/rename.rs:111:9
    |
 LL | #![warn(clippy::mismatched_target_os)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unexpected_cfgs`
 
 error: lint `clippy::new_without_default_derive` has been renamed to `clippy::new_without_default`
-  --> tests/ui/rename.rs:111:9
+  --> tests/ui/rename.rs:112: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:112:9
+  --> tests/ui/rename.rs:113: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:113:9
+  --> tests/ui/rename.rs:114: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:114:9
+  --> tests/ui/rename.rs:115: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:115:9
+  --> tests/ui/rename.rs:116: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:116:9
+  --> tests/ui/rename.rs:117: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:117:9
+  --> tests/ui/rename.rs:118:9
    |
 LL | #![warn(clippy::overflow_check_conditional)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::panicking_overflow_checks`
 
 error: lint `clippy::panic_params` has been renamed to `non_fmt_panics`
-  --> tests/ui/rename.rs:118:9
+  --> tests/ui/rename.rs:119: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:119:9
+  --> tests/ui/rename.rs:120:9
    |
 LL | #![warn(clippy::positional_named_format_parameters)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `named_arguments_used_positionally`
 
 error: lint `clippy::ref_in_deref` has been renamed to `clippy::needless_borrow`
-  --> tests/ui/rename.rs:120:9
+  --> tests/ui/rename.rs:121: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:121:9
+  --> tests/ui/rename.rs:122: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:122:9
+  --> tests/ui/rename.rs:123: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:123:9
+  --> tests/ui/rename.rs:124:9
    |
 LL | #![warn(clippy::result_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::reverse_range_loop` has been renamed to `clippy::reversed_empty_ranges`
-  --> tests/ui/rename.rs:124:9
+  --> tests/ui/rename.rs:125:9
    |
 LL | #![warn(clippy::reverse_range_loop)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::reversed_empty_ranges`
 
 error: lint `clippy::single_char_push_str` has been renamed to `clippy::single_char_add_str`
-  --> tests/ui/rename.rs:125:9
+  --> tests/ui/rename.rs:126: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:126:9
+  --> tests/ui/rename.rs:127:9
    |
 LL | #![warn(clippy::stutter)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::module_name_repetitions`
 
 error: lint `clippy::temporary_cstring_as_ptr` has been renamed to `dangling_pointers_from_temporaries`
-  --> tests/ui/rename.rs:127:9
+  --> tests/ui/rename.rs:128:9
    |
 LL | #![warn(clippy::temporary_cstring_as_ptr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `dangling_pointers_from_temporaries`
 
 error: lint `clippy::thread_local_initializer_can_be_made_const` has been renamed to `clippy::missing_const_for_thread_local`
-  --> tests/ui/rename.rs:128:9
+  --> tests/ui/rename.rs:129: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:129:9
+  --> tests/ui/rename.rs:130:9
    |
 LL | #![warn(clippy::to_string_in_display)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::recursive_format_impl`
 
 error: lint `clippy::transmute_float_to_int` has been renamed to `unnecessary_transmutes`
-  --> tests/ui/rename.rs:130:9
+  --> tests/ui/rename.rs:131:9
    |
 LL | #![warn(clippy::transmute_float_to_int)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unnecessary_transmutes`
 
 error: lint `clippy::transmute_int_to_char` has been renamed to `unnecessary_transmutes`
-  --> tests/ui/rename.rs:131:9
+  --> tests/ui/rename.rs:132:9
    |
 LL | #![warn(clippy::transmute_int_to_char)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unnecessary_transmutes`
 
 error: lint `clippy::transmute_int_to_float` has been renamed to `unnecessary_transmutes`
-  --> tests/ui/rename.rs:132:9
+  --> tests/ui/rename.rs:133:9
    |
 LL | #![warn(clippy::transmute_int_to_float)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unnecessary_transmutes`
 
 error: lint `clippy::transmute_num_to_bytes` has been renamed to `unnecessary_transmutes`
-  --> tests/ui/rename.rs:133:9
+  --> tests/ui/rename.rs:134:9
    |
 LL | #![warn(clippy::transmute_num_to_bytes)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unnecessary_transmutes`
 
+error: lint `clippy::unchecked_duration_subtraction` has been renamed to `clippy::unchecked_time_subtraction`
+  --> tests/ui/rename.rs:135:9
+   |
+LL | #![warn(clippy::unchecked_duration_subtraction)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unchecked_time_subtraction`
+
 error: lint `clippy::undropped_manually_drops` has been renamed to `undropped_manually_drops`
-  --> tests/ui/rename.rs:134:9
+  --> tests/ui/rename.rs:136: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:135:9
+  --> tests/ui/rename.rs:137: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:136:9
+  --> tests/ui/rename.rs:138:9
    |
 LL | #![warn(clippy::unused_label)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unused_labels`
 
 error: lint `clippy::unwrap_or_else_default` has been renamed to `clippy::unwrap_or_default`
-  --> tests/ui/rename.rs:137:9
+  --> tests/ui/rename.rs:139:9
    |
 LL | #![warn(clippy::unwrap_or_else_default)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_or_default`
 
 error: lint `clippy::vtable_address_comparisons` has been renamed to `ambiguous_wide_pointer_comparisons`
-  --> tests/ui/rename.rs:138:9
+  --> tests/ui/rename.rs:140:9
    |
 LL | #![warn(clippy::vtable_address_comparisons)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `ambiguous_wide_pointer_comparisons`
 
 error: lint `clippy::zero_width_space` has been renamed to `clippy::invisible_characters`
-  --> tests/ui/rename.rs:139:9
+  --> tests/ui/rename.rs:141:9
    |
 LL | #![warn(clippy::zero_width_space)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::invisible_characters`
 
-error: aborting due to 73 previous errors
+error: aborting due to 74 previous errors
 
diff --git a/tests/ui/unchecked_duration_subtraction.fixed b/tests/ui/unchecked_time_subtraction.fixed
similarity index 64%
rename from tests/ui/unchecked_duration_subtraction.fixed
rename to tests/ui/unchecked_time_subtraction.fixed
index bddffe44ac4d0..0850226eeea74 100644
--- a/tests/ui/unchecked_duration_subtraction.fixed
+++ b/tests/ui/unchecked_time_subtraction.fixed
@@ -1,4 +1,4 @@
-#![warn(clippy::unchecked_duration_subtraction)]
+#![warn(clippy::unchecked_time_subtraction)]
 
 use std::time::{Duration, Instant};
 
@@ -7,14 +7,14 @@ fn main() {
     let second = Duration::from_secs(3);
 
     let _ = _first.checked_sub(second).unwrap();
-    //~^ unchecked_duration_subtraction
+    //~^ unchecked_time_subtraction
 
     let _ = Instant::now().checked_sub(Duration::from_secs(5)).unwrap();
-    //~^ unchecked_duration_subtraction
+    //~^ unchecked_time_subtraction
 
     let _ = _first.checked_sub(Duration::from_secs(5)).unwrap();
-    //~^ unchecked_duration_subtraction
+    //~^ unchecked_time_subtraction
 
     let _ = Instant::now().checked_sub(second).unwrap();
-    //~^ unchecked_duration_subtraction
+    //~^ unchecked_time_subtraction
 }
diff --git a/tests/ui/unchecked_duration_subtraction.rs b/tests/ui/unchecked_time_subtraction.rs
similarity index 58%
rename from tests/ui/unchecked_duration_subtraction.rs
rename to tests/ui/unchecked_time_subtraction.rs
index bb0f712396424..a2dbfd1c1fadf 100644
--- a/tests/ui/unchecked_duration_subtraction.rs
+++ b/tests/ui/unchecked_time_subtraction.rs
@@ -1,4 +1,4 @@
-#![warn(clippy::unchecked_duration_subtraction)]
+#![warn(clippy::unchecked_time_subtraction)]
 
 use std::time::{Duration, Instant};
 
@@ -7,14 +7,14 @@ fn main() {
     let second = Duration::from_secs(3);
 
     let _ = _first - second;
-    //~^ unchecked_duration_subtraction
+    //~^ unchecked_time_subtraction
 
     let _ = Instant::now() - Duration::from_secs(5);
-    //~^ unchecked_duration_subtraction
+    //~^ unchecked_time_subtraction
 
     let _ = _first - Duration::from_secs(5);
-    //~^ unchecked_duration_subtraction
+    //~^ unchecked_time_subtraction
 
     let _ = Instant::now() - second;
-    //~^ unchecked_duration_subtraction
+    //~^ unchecked_time_subtraction
 }
diff --git a/tests/ui/unchecked_duration_subtraction.stderr b/tests/ui/unchecked_time_subtraction.stderr
similarity index 75%
rename from tests/ui/unchecked_duration_subtraction.stderr
rename to tests/ui/unchecked_time_subtraction.stderr
index be291c320e689..da0d51dbaef16 100644
--- a/tests/ui/unchecked_duration_subtraction.stderr
+++ b/tests/ui/unchecked_time_subtraction.stderr
@@ -1,26 +1,26 @@
 error: unchecked subtraction of a 'Duration' from an 'Instant'
-  --> tests/ui/unchecked_duration_subtraction.rs:9:13
+  --> tests/ui/unchecked_time_subtraction.rs:9:13
    |
 LL |     let _ = _first - second;
    |             ^^^^^^^^^^^^^^^ help: try: `_first.checked_sub(second).unwrap()`
    |
-   = note: `-D clippy::unchecked-duration-subtraction` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::unchecked_duration_subtraction)]`
+   = note: `-D clippy::unchecked-time-subtraction` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::unchecked_time_subtraction)]`
 
 error: unchecked subtraction of a 'Duration' from an 'Instant'
-  --> tests/ui/unchecked_duration_subtraction.rs:12:13
+  --> tests/ui/unchecked_time_subtraction.rs:12:13
    |
 LL |     let _ = Instant::now() - Duration::from_secs(5);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Instant::now().checked_sub(Duration::from_secs(5)).unwrap()`
 
 error: unchecked subtraction of a 'Duration' from an 'Instant'
-  --> tests/ui/unchecked_duration_subtraction.rs:15:13
+  --> tests/ui/unchecked_time_subtraction.rs:15:13
    |
 LL |     let _ = _first - Duration::from_secs(5);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `_first.checked_sub(Duration::from_secs(5)).unwrap()`
 
 error: unchecked subtraction of a 'Duration' from an 'Instant'
-  --> tests/ui/unchecked_duration_subtraction.rs:18:13
+  --> tests/ui/unchecked_time_subtraction.rs:18:13
    |
 LL |     let _ = Instant::now() - second;
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Instant::now().checked_sub(second).unwrap()`

From b0566b949b1e68319ed9852e637c5a77aae45186 Mon Sep 17 00:00:00 2001
From: Emmanuel Thompson <eet6646@gmail.com>
Date: Sat, 28 Jun 2025 19:41:55 -0400
Subject: [PATCH 1050/1889] rename module: instant_substraction to
 time_substraction

---
 clippy_lints/src/declared_lints.rs                            | 4 ++--
 clippy_lints/src/lib.rs                                       | 4 ++--
 .../src/{instant_subtraction.rs => time_subtraction.rs}       | 0
 3 files changed, 4 insertions(+), 4 deletions(-)
 rename clippy_lints/src/{instant_subtraction.rs => time_subtraction.rs} (100%)

diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 7734f2266308f..6a2833e5f86eb 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -226,8 +226,8 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY_INFO,
     crate::init_numbered_fields::INIT_NUMBERED_FIELDS_INFO,
     crate::inline_fn_without_body::INLINE_FN_WITHOUT_BODY_INFO,
-    crate::instant_subtraction::MANUAL_INSTANT_ELAPSED_INFO,
-    crate::instant_subtraction::UNCHECKED_TIME_SUBTRACTION_INFO,
+    crate::time_subtraction::MANUAL_INSTANT_ELAPSED_INFO,
+    crate::time_subtraction::UNCHECKED_TIME_SUBTRACTION_INFO,
     crate::int_plus_one::INT_PLUS_ONE_INFO,
     crate::integer_division_remainder_used::INTEGER_DIVISION_REMAINDER_USED_INFO,
     crate::invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c56fa257b0689..1ab6eef5e57d2 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -176,7 +176,6 @@ mod inherent_impl;
 mod inherent_to_string;
 mod init_numbered_fields;
 mod inline_fn_without_body;
-mod instant_subtraction;
 mod int_plus_one;
 mod integer_division_remainder_used;
 mod invalid_upcast_comparisons;
@@ -357,6 +356,7 @@ mod swap_ptr_to_ref;
 mod tabs_in_doc_comments;
 mod temporary_assignment;
 mod tests_outside_test_module;
+mod time_subtraction;
 mod to_digit_is_some;
 mod to_string_trait_impl;
 mod toplevel_ref_arg;
@@ -718,7 +718,7 @@ pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Co
     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(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(move |_| Box::new(time_subtraction::InstantSubtraction::new(conf)));
     store.register_late_pass(|_| Box::new(partialeq_to_none::PartialeqToNone));
     store.register_late_pass(move |_| Box::new(manual_abs_diff::ManualAbsDiff::new(conf)));
     store.register_late_pass(move |_| Box::new(manual_clamp::ManualClamp::new(conf)));
diff --git a/clippy_lints/src/instant_subtraction.rs b/clippy_lints/src/time_subtraction.rs
similarity index 100%
rename from clippy_lints/src/instant_subtraction.rs
rename to clippy_lints/src/time_subtraction.rs

From f296de4665cec2f1200496a0432667a150322f9b Mon Sep 17 00:00:00 2001
From: Emmanuel Thompson <eet6646@gmail.com>
Date: Sat, 28 Jun 2025 19:47:24 -0400
Subject: [PATCH 1051/1889] Implement Duration - Duration

Renames InstantSubtraction to UncheckedTimeSubtraction
---
 clippy_lints/src/declared_lints.rs            |   4 +-
 clippy_lints/src/lib.rs                       |   2 +-
 clippy_lints/src/time_subtraction.rs          | 111 ++++++++++++++----
 tests/ui/unchecked_time_subtraction.fixed     |  17 +++
 tests/ui/unchecked_time_subtraction.rs        |  17 +++
 tests/ui/unchecked_time_subtraction.stderr    |  26 +++-
 .../unchecked_time_subtraction_unfixable.rs   |  22 ++++
 ...nchecked_time_subtraction_unfixable.stderr |  29 +++++
 8 files changed, 201 insertions(+), 27 deletions(-)
 create mode 100644 tests/ui/unchecked_time_subtraction_unfixable.rs
 create mode 100644 tests/ui/unchecked_time_subtraction_unfixable.stderr

diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 6a2833e5f86eb..e1b6ee41967a3 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -226,8 +226,6 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY_INFO,
     crate::init_numbered_fields::INIT_NUMBERED_FIELDS_INFO,
     crate::inline_fn_without_body::INLINE_FN_WITHOUT_BODY_INFO,
-    crate::time_subtraction::MANUAL_INSTANT_ELAPSED_INFO,
-    crate::time_subtraction::UNCHECKED_TIME_SUBTRACTION_INFO,
     crate::int_plus_one::INT_PLUS_ONE_INFO,
     crate::integer_division_remainder_used::INTEGER_DIVISION_REMAINDER_USED_INFO,
     crate::invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS_INFO,
@@ -703,6 +701,8 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::tabs_in_doc_comments::TABS_IN_DOC_COMMENTS_INFO,
     crate::temporary_assignment::TEMPORARY_ASSIGNMENT_INFO,
     crate::tests_outside_test_module::TESTS_OUTSIDE_TEST_MODULE_INFO,
+    crate::time_subtraction::MANUAL_INSTANT_ELAPSED_INFO,
+    crate::time_subtraction::UNCHECKED_TIME_SUBTRACTION_INFO,
     crate::to_digit_is_some::TO_DIGIT_IS_SOME_INFO,
     crate::to_string_trait_impl::TO_STRING_TRAIT_IMPL_INFO,
     crate::toplevel_ref_arg::TOPLEVEL_REF_ARG_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 1ab6eef5e57d2..65c9a947b578d 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -718,7 +718,7 @@ pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Co
     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(move |_| Box::new(std_instead_of_core::StdReexports::new(conf)));
-    store.register_late_pass(move |_| Box::new(time_subtraction::InstantSubtraction::new(conf)));
+    store.register_late_pass(move |_| Box::new(time_subtraction::UncheckedTimeSubtraction::new(conf)));
     store.register_late_pass(|_| Box::new(partialeq_to_none::PartialeqToNone));
     store.register_late_pass(move |_| Box::new(manual_abs_diff::ManualAbsDiff::new(conf)));
     store.register_late_pass(move |_| Box::new(manual_clamp::ManualClamp::new(conf)));
diff --git a/clippy_lints/src/time_subtraction.rs b/clippy_lints/src/time_subtraction.rs
index 5fe26e3e3e0c3..fde8c3d9a9a76 100644
--- a/clippy_lints/src/time_subtraction.rs
+++ b/clippy_lints/src/time_subtraction.rs
@@ -1,12 +1,12 @@
 use clippy_config::Conf;
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::source::snippet_with_context;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{is_path_diagnostic_item, ty};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::Ty;
 use rustc_session::impl_lint_pass;
 use rustc_span::source_map::Spanned;
 use rustc_span::sym;
@@ -41,7 +41,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Lints subtraction between an `Instant` and a `Duration`.
+    /// Lints subtraction between an `Instant` and a `Duration`, or between two `Duration` values.
     ///
     /// ### Why is this bad?
     /// Unchecked subtraction could cause underflow on certain platforms, leading to
@@ -51,32 +51,38 @@ declare_clippy_lint! {
     /// ```no_run
     /// # use std::time::{Instant, Duration};
     /// let time_passed = Instant::now() - Duration::from_secs(5);
+    /// let dur1 = Duration::from_secs(3);
+    /// let dur2 = Duration::from_secs(5);
+    /// let diff = dur1 - dur2;
     /// ```
     ///
     /// Use instead:
     /// ```no_run
     /// # use std::time::{Instant, Duration};
     /// let time_passed = Instant::now().checked_sub(Duration::from_secs(5));
+    /// let dur1 = Duration::from_secs(3);
+    /// let dur2 = Duration::from_secs(5);
+    /// let diff = dur1.checked_sub(dur2);
     /// ```
     #[clippy::version = "1.67.0"]
     pub UNCHECKED_TIME_SUBTRACTION,
     pedantic,
-    "finds unchecked subtraction of a 'Duration' from an 'Instant'"
+    "finds unchecked subtraction involving 'Duration' or 'Instant'"
 }
 
-pub struct InstantSubtraction {
+pub struct UncheckedTimeSubtraction {
     msrv: Msrv,
 }
 
-impl InstantSubtraction {
+impl UncheckedTimeSubtraction {
     pub fn new(conf: &'static Conf) -> Self {
         Self { msrv: conf.msrv }
     }
 }
 
-impl_lint_pass!(InstantSubtraction => [MANUAL_INSTANT_ELAPSED, UNCHECKED_TIME_SUBTRACTION]);
+impl_lint_pass!(UncheckedTimeSubtraction => [MANUAL_INSTANT_ELAPSED, UNCHECKED_TIME_SUBTRACTION]);
 
-impl LateLintPass<'_> for InstantSubtraction {
+impl LateLintPass<'_> for UncheckedTimeSubtraction {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
         if let ExprKind::Binary(
             Spanned {
@@ -85,21 +91,54 @@ impl LateLintPass<'_> for InstantSubtraction {
             lhs,
             rhs,
         ) = expr.kind
-            && let typeck = cx.typeck_results()
-            && ty::is_type_diagnostic_item(cx, typeck.expr_ty(lhs), sym::Instant)
         {
+            let typeck = cx.typeck_results();
+            let lhs_ty = typeck.expr_ty(lhs);
             let rhs_ty = typeck.expr_ty(rhs);
 
-            if is_instant_now_call(cx, lhs)
-                && ty::is_type_diagnostic_item(cx, rhs_ty, sym::Instant)
-                && let Some(sugg) = Sugg::hir_opt(cx, rhs)
-            {
-                print_manual_instant_elapsed_sugg(cx, expr, sugg);
-            } else if ty::is_type_diagnostic_item(cx, rhs_ty, sym::Duration)
+            if ty::is_type_diagnostic_item(cx, lhs_ty, sym::Instant) {
+                // Instant::now() - instant
+                if is_instant_now_call(cx, lhs)
+                    && ty::is_type_diagnostic_item(cx, rhs_ty, sym::Instant)
+                    && let Some(sugg) = Sugg::hir_opt(cx, rhs)
+                {
+                    print_manual_instant_elapsed_sugg(cx, expr, sugg);
+                }
+                // instant - duration
+                else if ty::is_type_diagnostic_item(cx, rhs_ty, sym::Duration)
+                    && !expr.span.from_expansion()
+                    && self.msrv.meets(cx, msrvs::TRY_FROM)
+                {
+                    // For chained subtraction like (instant - dur1) - dur2, avoid suggestions
+                    if is_chained_time_subtraction(cx, lhs) {
+                        span_lint(
+                            cx,
+                            UNCHECKED_TIME_SUBTRACTION,
+                            expr.span,
+                            "unchecked subtraction of a 'Duration' from an 'Instant'",
+                        );
+                    } else {
+                        // instant - duration
+                        print_unchecked_duration_subtraction_sugg(cx, lhs, rhs, expr);
+                    }
+                }
+            } else if ty::is_type_diagnostic_item(cx, lhs_ty, sym::Duration)
+                && ty::is_type_diagnostic_item(cx, rhs_ty, sym::Duration)
                 && !expr.span.from_expansion()
                 && self.msrv.meets(cx, msrvs::TRY_FROM)
             {
-                print_unchecked_duration_subtraction_sugg(cx, lhs, rhs, expr);
+                // For chained subtraction like (dur1 - dur2) - dur3, avoid suggestions
+                if is_chained_time_subtraction(cx, lhs) {
+                    span_lint(
+                        cx,
+                        UNCHECKED_TIME_SUBTRACTION,
+                        expr.span,
+                        "unchecked subtraction between 'Duration' values",
+                    );
+                } else {
+                    // duration - duration
+                    print_unchecked_duration_subtraction_sugg(cx, lhs, rhs, expr);
+                }
             }
         }
     }
@@ -115,6 +154,25 @@ fn is_instant_now_call(cx: &LateContext<'_>, expr_block: &'_ Expr<'_>) -> bool {
     }
 }
 
+/// Returns true if this subtraction is part of a chain like `(a - b) - c`
+fn is_chained_time_subtraction(cx: &LateContext<'_>, lhs: &Expr<'_>) -> bool {
+    if let ExprKind::Binary(op, inner_lhs, inner_rhs) = &lhs.kind
+        && matches!(op.node, BinOpKind::Sub)
+    {
+        let typeck = cx.typeck_results();
+        let left_ty = typeck.expr_ty(inner_lhs);
+        let right_ty = typeck.expr_ty(inner_rhs);
+        is_time_type(cx, left_ty) && is_time_type(cx, right_ty)
+    } else {
+        false
+    }
+}
+
+/// Returns true if the type is Duration or Instant
+fn is_time_type(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
+    ty::is_type_diagnostic_item(cx, ty, sym::Duration) || ty::is_type_diagnostic_item(cx, ty, sym::Instant)
+}
+
 fn print_manual_instant_elapsed_sugg(cx: &LateContext<'_>, expr: &Expr<'_>, sugg: Sugg<'_>) {
     span_lint_and_sugg(
         cx,
@@ -133,19 +191,26 @@ fn print_unchecked_duration_subtraction_sugg(
     right_expr: &Expr<'_>,
     expr: &Expr<'_>,
 ) {
-    let mut applicability = Applicability::MachineApplicable;
+    let typeck = cx.typeck_results();
+    let left_ty = typeck.expr_ty(left_expr);
 
-    let ctxt = expr.span.ctxt();
-    let left_expr = snippet_with_context(cx, left_expr.span, ctxt, "<instant>", &mut applicability).0;
-    let right_expr = snippet_with_context(cx, right_expr.span, ctxt, "<duration>", &mut applicability).0;
+    let lint_msg = if ty::is_type_diagnostic_item(cx, left_ty, sym::Instant) {
+        "unchecked subtraction of a 'Duration' from an 'Instant'"
+    } else {
+        "unchecked subtraction between 'Duration' values"
+    };
+
+    let mut applicability = Applicability::MachineApplicable;
+    let left_sugg = Sugg::hir_with_applicability(cx, left_expr, "<left>", &mut applicability);
+    let right_sugg = Sugg::hir_with_applicability(cx, right_expr, "<right>", &mut applicability);
 
     span_lint_and_sugg(
         cx,
         UNCHECKED_TIME_SUBTRACTION,
         expr.span,
-        "unchecked subtraction of a 'Duration' from an 'Instant'",
+        lint_msg,
         "try",
-        format!("{left_expr}.checked_sub({right_expr}).unwrap()"),
+        format!("{}.checked_sub({}).unwrap()", left_sugg.maybe_paren(), right_sugg),
         applicability,
     );
 }
diff --git a/tests/ui/unchecked_time_subtraction.fixed b/tests/ui/unchecked_time_subtraction.fixed
index 0850226eeea74..2f923fef4c25d 100644
--- a/tests/ui/unchecked_time_subtraction.fixed
+++ b/tests/ui/unchecked_time_subtraction.fixed
@@ -17,4 +17,21 @@ fn main() {
 
     let _ = Instant::now().checked_sub(second).unwrap();
     //~^ unchecked_time_subtraction
+
+    // Duration - Duration cases
+    let dur1 = Duration::from_secs(5);
+    let dur2 = Duration::from_secs(3);
+
+    let _ = dur1.checked_sub(dur2).unwrap();
+    //~^ unchecked_time_subtraction
+
+    let _ = Duration::from_secs(10).checked_sub(Duration::from_secs(5)).unwrap();
+    //~^ unchecked_time_subtraction
+
+    let _ = second.checked_sub(dur1).unwrap();
+    //~^ unchecked_time_subtraction
+
+    // Duration multiplication and subtraction
+    let _ = (2 * dur1).checked_sub(dur2).unwrap();
+    //~^ unchecked_time_subtraction
 }
diff --git a/tests/ui/unchecked_time_subtraction.rs b/tests/ui/unchecked_time_subtraction.rs
index a2dbfd1c1fadf..cf727f62aafa7 100644
--- a/tests/ui/unchecked_time_subtraction.rs
+++ b/tests/ui/unchecked_time_subtraction.rs
@@ -17,4 +17,21 @@ fn main() {
 
     let _ = Instant::now() - second;
     //~^ unchecked_time_subtraction
+
+    // Duration - Duration cases
+    let dur1 = Duration::from_secs(5);
+    let dur2 = Duration::from_secs(3);
+
+    let _ = dur1 - dur2;
+    //~^ unchecked_time_subtraction
+
+    let _ = Duration::from_secs(10) - Duration::from_secs(5);
+    //~^ unchecked_time_subtraction
+
+    let _ = second - dur1;
+    //~^ unchecked_time_subtraction
+
+    // Duration multiplication and subtraction
+    let _ = 2 * dur1 - dur2;
+    //~^ unchecked_time_subtraction
 }
diff --git a/tests/ui/unchecked_time_subtraction.stderr b/tests/ui/unchecked_time_subtraction.stderr
index da0d51dbaef16..7a39712269cf7 100644
--- a/tests/ui/unchecked_time_subtraction.stderr
+++ b/tests/ui/unchecked_time_subtraction.stderr
@@ -25,5 +25,29 @@ error: unchecked subtraction of a 'Duration' from an 'Instant'
 LL |     let _ = Instant::now() - second;
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Instant::now().checked_sub(second).unwrap()`
 
-error: aborting due to 4 previous errors
+error: unchecked subtraction between 'Duration' values
+  --> tests/ui/unchecked_time_subtraction.rs:25:13
+   |
+LL |     let _ = dur1 - dur2;
+   |             ^^^^^^^^^^^ help: try: `dur1.checked_sub(dur2).unwrap()`
+
+error: unchecked subtraction between 'Duration' values
+  --> tests/ui/unchecked_time_subtraction.rs:28:13
+   |
+LL |     let _ = Duration::from_secs(10) - Duration::from_secs(5);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Duration::from_secs(10).checked_sub(Duration::from_secs(5)).unwrap()`
+
+error: unchecked subtraction between 'Duration' values
+  --> tests/ui/unchecked_time_subtraction.rs:31:13
+   |
+LL |     let _ = second - dur1;
+   |             ^^^^^^^^^^^^^ help: try: `second.checked_sub(dur1).unwrap()`
+
+error: unchecked subtraction between 'Duration' values
+  --> tests/ui/unchecked_time_subtraction.rs:35:13
+   |
+LL |     let _ = 2 * dur1 - dur2;
+   |             ^^^^^^^^^^^^^^^ help: try: `(2 * dur1).checked_sub(dur2).unwrap()`
+
+error: aborting due to 8 previous errors
 
diff --git a/tests/ui/unchecked_time_subtraction_unfixable.rs b/tests/ui/unchecked_time_subtraction_unfixable.rs
new file mode 100644
index 0000000000000..4b6a5ca156209
--- /dev/null
+++ b/tests/ui/unchecked_time_subtraction_unfixable.rs
@@ -0,0 +1,22 @@
+#![warn(clippy::unchecked_time_subtraction)]
+//@no-rustfix
+
+use std::time::{Duration, Instant};
+
+fn main() {
+    let dur1 = Duration::from_secs(5);
+    let dur2 = Duration::from_secs(3);
+    let dur3 = Duration::from_secs(1);
+
+    // Chained Duration subtraction - should lint without suggestion due to complexity
+    let _ = dur1 - dur2 - dur3;
+    //~^ unchecked_time_subtraction
+    //~| unchecked_time_subtraction
+
+    // Chained Instant - Duration subtraction - should lint without suggestion due to complexity
+    let instant1 = Instant::now();
+
+    let _ = instant1 - dur2 - dur3;
+    //~^ unchecked_time_subtraction
+    //~| unchecked_time_subtraction
+}
diff --git a/tests/ui/unchecked_time_subtraction_unfixable.stderr b/tests/ui/unchecked_time_subtraction_unfixable.stderr
new file mode 100644
index 0000000000000..c25c112b06ce0
--- /dev/null
+++ b/tests/ui/unchecked_time_subtraction_unfixable.stderr
@@ -0,0 +1,29 @@
+error: unchecked subtraction between 'Duration' values
+  --> tests/ui/unchecked_time_subtraction_unfixable.rs:12:13
+   |
+LL |     let _ = dur1 - dur2 - dur3;
+   |             ^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::unchecked-time-subtraction` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::unchecked_time_subtraction)]`
+
+error: unchecked subtraction between 'Duration' values
+  --> tests/ui/unchecked_time_subtraction_unfixable.rs:12:13
+   |
+LL |     let _ = dur1 - dur2 - dur3;
+   |             ^^^^^^^^^^^ help: try: `dur1.checked_sub(dur2).unwrap()`
+
+error: unchecked subtraction of a 'Duration' from an 'Instant'
+  --> tests/ui/unchecked_time_subtraction_unfixable.rs:19:13
+   |
+LL |     let _ = instant1 - dur2 - dur3;
+   |             ^^^^^^^^^^^^^^^^^^^^^^
+
+error: unchecked subtraction of a 'Duration' from an 'Instant'
+  --> tests/ui/unchecked_time_subtraction_unfixable.rs:19:13
+   |
+LL |     let _ = instant1 - dur2 - dur3;
+   |             ^^^^^^^^^^^^^^^ help: try: `instant1.checked_sub(dur2).unwrap()`
+
+error: aborting due to 4 previous errors
+

From 6e101637fa9485e71e77217ab32cbfb0f013e6e5 Mon Sep 17 00:00:00 2001
From: Bart Jacobs <bart.jacobs@cs.kuleuven.be>
Date: Wed, 17 Sep 2025 15:46:23 +0200
Subject: [PATCH 1052/1889] Add the
 `rust-analyzer.semanticHighlighting.comments.enable` configuration value

---
 src/tools/rust-analyzer/crates/ide/src/lib.rs | 14 ++++++
 .../crates/ide/src/syntax_highlighting.rs     |  4 ++
 .../ide/src/syntax_highlighting/html.rs       | 42 +++++++++-------
 .../ide/src/syntax_highlighting/inject.rs     |  2 +
 .../highlight_comments_disabled.html          | 48 +++++++++++++++++++
 .../ide/src/syntax_highlighting/tests.rs      | 35 +++++++++++++-
 .../crates/rust-analyzer/src/config.rs        |  8 ++++
 .../docs/book/src/configuration_generated.md  | 11 +++++
 .../rust-analyzer/editors/code/package.json   | 10 ++++
 9 files changed, 156 insertions(+), 18 deletions(-)
 create mode 100644 src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_comments_disabled.html

diff --git a/src/tools/rust-analyzer/crates/ide/src/lib.rs b/src/tools/rust-analyzer/crates/ide/src/lib.rs
index cddf5f04f2442..481c2312176b4 100644
--- a/src/tools/rust-analyzer/crates/ide/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/lib.rs
@@ -703,6 +703,20 @@ impl Analysis {
         })
     }
 
+    /// Computes syntax highlighting for the given file.
+    pub fn highlight_as_html_with_config(
+        &self,
+        config: HighlightConfig,
+        file_id: FileId,
+        rainbow: bool,
+    ) -> Cancellable<String> {
+        // highlighting may construct a new database for "speculative" execution, so we can't currently attach the database
+        // highlighting instead sets up the attach hook where neceesary for the trait solver
+        Cancelled::catch(|| {
+            syntax_highlighting::highlight_as_html_with_config(&self.db, config, file_id, rainbow)
+        })
+    }
+
     /// Computes syntax highlighting for the given file.
     pub fn highlight_as_html(&self, file_id: FileId, rainbow: bool) -> Cancellable<String> {
         // highlighting may construct a new database for "speculative" execution, so we can't currently attach the database
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting.rs b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting.rs
index f98770805a451..4e43387f8d9da 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting.rs
@@ -35,6 +35,7 @@ use crate::{
 };
 
 pub(crate) use html::highlight_as_html;
+pub(crate) use html::highlight_as_html_with_config;
 
 #[derive(Debug, Clone, Copy)]
 pub struct HlRange {
@@ -47,6 +48,8 @@ pub struct HlRange {
 pub struct HighlightConfig {
     /// Whether to highlight strings
     pub strings: bool,
+    /// Whether to highlight comments
+    pub comments: bool,
     /// Whether to highlight punctuation
     pub punctuation: bool,
     /// Whether to specialize punctuation highlights
@@ -588,6 +591,7 @@ fn descend_token(
 fn filter_by_config(highlight: &mut Highlight, config: HighlightConfig) -> bool {
     match &mut highlight.tag {
         HlTag::StringLiteral if !config.strings => return false,
+        HlTag::Comment if !config.comments => return false,
         // If punctuation is disabled, make the macro bang part of the macro call again.
         tag @ HlTag::Punctuation(HlPunct::MacroBang) => {
             if !config.macro_bang {
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/html.rs b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/html.rs
index 9fd807f031f1f..358ac9b4ef352 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/html.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/html.rs
@@ -10,7 +10,12 @@ use crate::{
     syntax_highlighting::{HighlightConfig, highlight},
 };
 
-pub(crate) fn highlight_as_html(db: &RootDatabase, file_id: FileId, rainbow: bool) -> String {
+pub(crate) fn highlight_as_html_with_config(
+    db: &RootDatabase,
+    config: HighlightConfig,
+    file_id: FileId,
+    rainbow: bool,
+) -> String {
     let sema = Semantics::new(db);
     let file_id = sema
         .attach_first_edition(file_id)
@@ -27,21 +32,7 @@ pub(crate) fn highlight_as_html(db: &RootDatabase, file_id: FileId, rainbow: boo
         )
     }
 
-    let hl_ranges = highlight(
-        db,
-        HighlightConfig {
-            strings: true,
-            punctuation: true,
-            specialize_punctuation: true,
-            specialize_operator: true,
-            operator: true,
-            inject_doc_comment: true,
-            macro_bang: true,
-            syntactic_name_ref_highlighting: false,
-        },
-        file_id.file_id(db),
-        None,
-    );
+    let hl_ranges = highlight(db, config, file_id.file_id(db), None);
     let text = file.to_string();
     let mut buf = String::new();
     buf.push_str(STYLE);
@@ -66,6 +57,25 @@ pub(crate) fn highlight_as_html(db: &RootDatabase, file_id: FileId, rainbow: boo
     buf
 }
 
+pub(crate) fn highlight_as_html(db: &RootDatabase, file_id: FileId, rainbow: bool) -> String {
+    highlight_as_html_with_config(
+        db,
+        HighlightConfig {
+            strings: true,
+            comments: true,
+            punctuation: true,
+            specialize_punctuation: true,
+            specialize_operator: true,
+            operator: true,
+            inject_doc_comment: true,
+            macro_bang: true,
+            syntactic_name_ref_highlighting: false,
+        },
+        file_id,
+        rainbow,
+    )
+}
+
 //FIXME: like, real html escaping
 fn html_escape(text: &str) -> String {
     text.replace('<', "&lt;").replace('>', "&gt;")
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/inject.rs b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/inject.rs
index abe7be8c68881..4bb7308024144 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/inject.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/inject.rs
@@ -80,6 +80,7 @@ pub(super) fn ra_fixture(
         .highlight(
             HighlightConfig {
                 syntactic_name_ref_highlighting: false,
+                comments: true,
                 punctuation: true,
                 operator: true,
                 strings: true,
@@ -250,6 +251,7 @@ pub(super) fn doc_comment(
             db,
             HighlightConfig {
                 syntactic_name_ref_highlighting: true,
+                comments: true,
                 punctuation: true,
                 operator: true,
                 strings: true,
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_comments_disabled.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_comments_disabled.html
new file mode 100644
index 0000000000000..4607448bebaaa
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_comments_disabled.html
@@ -0,0 +1,48 @@
+
+<style>
+body                { margin: 0; }
+pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padding: 0.4em; }
+
+.lifetime           { color: #DFAF8F; font-style: italic; }
+.label              { color: #DFAF8F; font-style: italic; }
+.comment            { color: #7F9F7F; }
+.documentation      { color: #629755; }
+.intra_doc_link     { font-style: italic; }
+.injected           { opacity: 0.65 ; }
+.struct, .enum      { color: #7CB8BB; }
+.enum_variant       { color: #BDE0F3; }
+.string_literal     { color: #CC9393; }
+.field              { color: #94BFF3; }
+.function           { color: #93E0E3; }
+.parameter          { color: #94BFF3; }
+.text               { color: #DCDCCC; }
+.type               { color: #7CB8BB; }
+.builtin_type       { color: #8CD0D3; }
+.type_param         { color: #DFAF8F; }
+.attribute          { color: #94BFF3; }
+.numeric_literal    { color: #BFEBBF; }
+.bool_literal       { color: #BFE6EB; }
+.macro              { color: #94BFF3; }
+.proc_macro         { color: #94BFF3; text-decoration: underline; }
+.derive             { color: #94BFF3; font-style: italic; }
+.module             { color: #AFD8AF; }
+.value_param        { color: #DCDCCC; }
+.variable           { color: #DCDCCC; }
+.format_specifier   { color: #CC696B; }
+.mutable            { text-decoration: underline; }
+.escape_sequence    { color: #94BFF3; }
+.keyword            { color: #F0DFAF; font-weight: bold; }
+.control            { font-style: italic; }
+.reference          { font-style: italic; font-weight: bold; }
+.const              { font-weight: bolder; }
+.unsafe             { color: #BC8383; }
+
+.invalid_escape_sequence { color: #FC5555; text-decoration: wavy underline; }
+.unresolved_reference    { color: #FC5555; text-decoration: wavy underline; }
+</style>
+<pre><code>// This is a regular comment
+/// This is a doc comment
+<span class="keyword">fn</span> <span class="function declaration">main</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
+    // Another comment
+    <span class="unresolved_reference">println</span><span class="macro_bang">!</span><span class="parenthesis">(</span><span class="string_literal">"Hello, world!"</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+<span class="brace">}</span></code></pre>
\ No newline at end of file
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/tests.rs b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/tests.rs
index dd359326c61d6..8198701d68432 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/tests.rs
@@ -9,6 +9,7 @@ use crate::{FileRange, HighlightConfig, HlTag, TextRange, fixture};
 
 const HL_CONFIG: HighlightConfig = HighlightConfig {
     strings: true,
+    comments: true,
     punctuation: true,
     specialize_punctuation: true,
     specialize_operator: true,
@@ -1220,16 +1221,25 @@ fn foo(x: &fn(&dyn Trait)) {}
 /// Highlights the code given by the `ra_fixture` argument, renders the
 /// result as HTML, and compares it with the HTML file given as `snapshot`.
 /// Note that the `snapshot` file is overwritten by the rendered HTML.
-fn check_highlighting(
+fn check_highlighting_with_config(
     #[rust_analyzer::rust_fixture] ra_fixture: &str,
+    config: HighlightConfig,
     expect: ExpectFile,
     rainbow: bool,
 ) {
     let (analysis, file_id) = fixture::file(ra_fixture.trim());
-    let actual_html = &analysis.highlight_as_html(file_id, rainbow).unwrap();
+    let actual_html = &analysis.highlight_as_html_with_config(config, file_id, rainbow).unwrap();
     expect.assert_eq(actual_html)
 }
 
+fn check_highlighting(
+    #[rust_analyzer::rust_fixture] ra_fixture: &str,
+    expect: ExpectFile,
+    rainbow: bool,
+) {
+    check_highlighting_with_config(ra_fixture, HL_CONFIG, expect, rainbow)
+}
+
 #[test]
 fn benchmark_syntax_highlighting_long_struct() {
     if skip_slow_tests() {
@@ -1435,3 +1445,24 @@ fn main() {
         false,
     );
 }
+
+#[test]
+fn test_comment_highlighting_disabled() {
+    // Test that comments are not highlighted when disabled
+    check_highlighting_with_config(
+        r#"
+// This is a regular comment
+/// This is a doc comment
+fn main() {
+    // Another comment
+    println!("Hello, world!");
+}
+"#,
+        HighlightConfig {
+            comments: false, // Disable comment highlighting
+            ..HL_CONFIG
+        },
+        expect_file!["./test_data/highlight_comments_disabled.html"],
+        false,
+    );
+}
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
index c2252185a3aa3..8fe0a5d2eb662 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
@@ -382,6 +382,13 @@ config_data! {
         /// Exclude tests from find-all-references and call-hierarchy.
         references_excludeTests: bool = false,
 
+        /// Use semantic tokens for comments.
+        ///
+        /// In some editors (e.g. vscode) semantic tokens override other highlighting grammars.
+        /// By disabling semantic tokens for comments, other grammars can be used to highlight
+        /// their contents.
+        semanticHighlighting_comments_enable: bool = true,
+
         /// Inject additional highlighting into doc comments.
         ///
         /// When enabled, rust-analyzer will highlight rust source in doc comments as well as intra
@@ -1968,6 +1975,7 @@ impl Config {
     pub fn highlighting_config(&self) -> HighlightConfig {
         HighlightConfig {
             strings: self.semanticHighlighting_strings_enable().to_owned(),
+            comments: self.semanticHighlighting_comments_enable().to_owned(),
             punctuation: self.semanticHighlighting_punctuation_enable().to_owned(),
             specialize_punctuation: self
                 .semanticHighlighting_punctuation_specialization_enable()
diff --git a/src/tools/rust-analyzer/docs/book/src/configuration_generated.md b/src/tools/rust-analyzer/docs/book/src/configuration_generated.md
index 9a51212462db5..50dacd88f4072 100644
--- a/src/tools/rust-analyzer/docs/book/src/configuration_generated.md
+++ b/src/tools/rust-analyzer/docs/book/src/configuration_generated.md
@@ -1378,6 +1378,17 @@ Enables the use of rustfmt's unstable range formatting command for the
 available on a nightly build.
 
 
+## rust-analyzer.semanticHighlighting.comments.enable {#semanticHighlighting.comments.enable}
+
+Default: `true`
+
+Use semantic tokens for comments.
+
+In some editors (e.g. vscode) semantic tokens override other highlighting grammars.
+By disabling semantic tokens for comments, other grammars can be used to highlight
+their contents.
+
+
 ## rust-analyzer.semanticHighlighting.doc.comment.inject.enable {#semanticHighlighting.doc.comment.inject.enable}
 
 Default: `true`
diff --git a/src/tools/rust-analyzer/editors/code/package.json b/src/tools/rust-analyzer/editors/code/package.json
index 2b2e25e11c88a..1d27a12053552 100644
--- a/src/tools/rust-analyzer/editors/code/package.json
+++ b/src/tools/rust-analyzer/editors/code/package.json
@@ -2850,6 +2850,16 @@
                     }
                 }
             },
+            {
+                "title": "Semantic Highlighting",
+                "properties": {
+                    "rust-analyzer.semanticHighlighting.comments.enable": {
+                        "markdownDescription": "Use semantic tokens for comments.\n\nIn some editors (e.g. vscode) semantic tokens override other highlighting grammars.\nBy disabling semantic tokens for comments, other grammars can be used to highlight\ntheir contents.",
+                        "default": true,
+                        "type": "boolean"
+                    }
+                }
+            },
             {
                 "title": "Semantic Highlighting",
                 "properties": {

From e04567c363e1f0417bf8bf24830c2bc536020582 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Marcelo=20Dom=C3=ADnguez?= <dmmarcelo27@gmail.com>
Date: Wed, 17 Sep 2025 13:58:17 +0000
Subject: [PATCH 1053/1889] Check ZST via `PassMode`

---
 .../src/builder/autodiff.rs                   | 20 ++++++++++++++++---
 compiler/rustc_codegen_llvm/src/intrinsic.rs  |  3 ++-
 2 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
index 78deffa3a7a6e..566877f4a1ec5 100644
--- a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
+++ b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
@@ -3,8 +3,9 @@ use std::ptr;
 use rustc_ast::expand::autodiff_attrs::{AutoDiffAttrs, DiffActivity, DiffMode};
 use rustc_codegen_ssa::common::TypeKind;
 use rustc_codegen_ssa::traits::{BaseTypeCodegenMethods, BuilderMethods};
-use rustc_middle::ty::{PseudoCanonicalInput, Ty, TyCtxt, TypingEnv};
+use rustc_middle::ty::{Instance, PseudoCanonicalInput, TyCtxt, TypingEnv};
 use rustc_middle::{bug, ty};
+use rustc_target::callconv::PassMode;
 use tracing::debug;
 
 use crate::builder::{Builder, PlaceRef, UNNAMED};
@@ -16,9 +17,12 @@ use crate::value::Value;
 
 pub(crate) fn adjust_activity_to_abi<'tcx>(
     tcx: TyCtxt<'tcx>,
-    fn_ty: Ty<'tcx>,
+    instance: Instance<'tcx>,
+    typing_env: TypingEnv<'tcx>,
     da: &mut Vec<DiffActivity>,
 ) {
+    let fn_ty = instance.ty(tcx, typing_env);
+
     if !matches!(fn_ty.kind(), ty::FnDef(..)) {
         bug!("expected fn def for autodiff, got {:?}", fn_ty);
     }
@@ -27,6 +31,13 @@ pub(crate) fn adjust_activity_to_abi<'tcx>(
     // All we do is decide how to handle the arguments.
     let sig = fn_ty.fn_sig(tcx).skip_binder();
 
+    // FIXME(Sa4dUs): pass proper varargs once we have support for differentiating variadic functions
+    let Ok(fn_abi) =
+        tcx.fn_abi_of_instance(typing_env.as_query_input((instance, ty::List::empty())))
+    else {
+        bug!("failed to get fn_abi of instance with empty varargs");
+    };
+
     let mut new_activities = vec![];
     let mut new_positions = vec![];
     let mut del_activities = 0;
@@ -91,10 +102,13 @@ pub(crate) fn adjust_activity_to_abi<'tcx>(
             }
         };
 
+        let pass_mode = &fn_abi.args[i].mode;
+
         // For ZST, just ignore and don't add its activity, as this arg won't be present
         // in the LLVM passed to Enzyme.
+        // Some targets pass ZST indirectly in the C ABI, in that case, handle it as a normal arg
         // FIXME(Sa4dUs): Enforce ZST corresponding diff activity be `Const`
-        if layout.is_zst() {
+        if *pass_mode == PassMode::Ignore {
             del_activities += 1;
             da.remove(i);
         }
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
index 06c3d8ed6bc2d..9e6e760649120 100644
--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -1198,7 +1198,8 @@ fn codegen_autodiff<'ll, 'tcx>(
 
     adjust_activity_to_abi(
         tcx,
-        fn_source.ty(tcx, TypingEnv::fully_monomorphized()),
+        fn_source,
+        TypingEnv::fully_monomorphized(),
         &mut diff_attrs.input_activity,
     );
 

From 28b0e4e15e0ffd0c5f747f94dadb7a243566449d Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Wed, 17 Sep 2025 22:57:25 +0800
Subject: [PATCH 1054/1889] Fix applicable on variant field for
 change_visibility

Enum variant fields do not allow visibility

Example
---
```rust
enum Foo {
    Variant($0String),
}
```

**Before this PR**:

```rust
enum Foo {
    Variant(pub(crate) String),
}
```

**After this PR**:

Assist not applicable
---
 .../ide-assists/src/handlers/change_visibility.rs  | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/change_visibility.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/change_visibility.rs
index 9b9f0c4522ed2..7119d5b9c23eb 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/change_visibility.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/change_visibility.rs
@@ -65,11 +65,13 @@ fn add_vis(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {
         if field.visibility().is_some() {
             return None;
         }
+        check_is_not_variant(&field)?;
         (vis_offset(field.syntax()), field_name.syntax().text_range())
     } else if let Some(field) = ctx.find_node_at_offset::<ast::TupleField>() {
         if field.visibility().is_some() {
             return None;
         }
+        check_is_not_variant(&field)?;
         (vis_offset(field.syntax()), field.syntax().text_range())
     } else {
         return None;
@@ -134,6 +136,11 @@ fn change_vis(acc: &mut Assists, vis: ast::Visibility) -> Option<()> {
     None
 }
 
+fn check_is_not_variant(field: &impl AstNode) -> Option<()> {
+    let kind = field.syntax().parent()?.parent()?.kind();
+    (kind != SyntaxKind::VARIANT).then_some(())
+}
+
 #[cfg(test)]
 mod tests {
     use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
@@ -239,6 +246,13 @@ mod tests {
         );
     }
 
+    #[test]
+    fn not_applicable_for_enum_variant_fields() {
+        check_assist_not_applicable(change_visibility, r"pub enum Foo { Foo1($0i32) }");
+
+        check_assist_not_applicable(change_visibility, r"pub enum Foo { Foo1 { $0n: i32 } }");
+    }
+
     #[test]
     fn change_visibility_target() {
         check_assist_target(change_visibility, "$0fn foo() {}", "fn");

From 301092e249f3773fd41c8af7170acd88a2681c89 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Wed, 17 Sep 2025 17:36:17 +0200
Subject: [PATCH 1055/1889] Remove automatic feature freeze comment

The feature freeze period is over.
---
 .github/workflows/feature_freeze.yml   | 45 ---------------------
 book/src/README.md                     |  4 --
 book/src/SUMMARY.md                    |  1 -
 book/src/development/adding_lints.md   |  3 --
 book/src/development/feature_freeze.md | 55 --------------------------
 5 files changed, 108 deletions(-)
 delete mode 100644 .github/workflows/feature_freeze.yml
 delete mode 100644 book/src/development/feature_freeze.md

diff --git a/.github/workflows/feature_freeze.yml b/.github/workflows/feature_freeze.yml
deleted file mode 100644
index 5b139e767007b..0000000000000
--- a/.github/workflows/feature_freeze.yml
+++ /dev/null
@@ -1,45 +0,0 @@
-name: Feature freeze check
-
-on:
-  pull_request_target:
-    types:
-      - opened
-    branches:
-      - master
-    paths:
-      - 'clippy_lints/src/declared_lints.rs'
-
-jobs:
-  auto-comment:
-    runs-on: ubuntu-latest
-
-    permissions:
-      pull-requests: write
-
-    # Do not in any case add code that runs anything coming from the content
-    # of the pull request, as malicious code would be able to access the private
-    # GitHub token.
-    steps:
-      - name: Add freeze warning comment
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          GITHUB_REPOSITORY: ${{ github.repository }}
-          PR_NUMBER: ${{ github.event.pull_request.number }}
-        run: |
-          COMMENT=$(echo "**Seems that you are trying to add a new lint!**\n\
-          \n\
-          We are currently in a [feature freeze](https://doc.rust-lang.org/nightly/clippy/development/feature_freeze.html), so we are delaying all lint-adding PRs to September 18 and [focusing on bugfixes](https://github.com/rust-lang/rust-clippy/issues/15086).\n\
-          \n\
-          Thanks a lot for your contribution, and sorry for the inconvenience.\n\
-          \n\
-          With ❤ from the Clippy team.\n\
-          \n\
-          @rustbot note Feature-freeze\n\
-          @rustbot blocked\n\
-          @rustbot label +A-lint"
-          )
-          curl -s -H "Authorization: Bearer $GITHUB_TOKEN" \
-             -H "Content-Type: application/vnd.github.raw+json" \
-             -X POST \
-             --data "{\"body\":\"${COMMENT}\"}" \
-             "https://api.github.com/repos/${GITHUB_REPOSITORY}/issues/${PR_NUMBER}/comments"
diff --git a/book/src/README.md b/book/src/README.md
index db73b49ecc24e..5d2c3972b060a 100644
--- a/book/src/README.md
+++ b/book/src/README.md
@@ -1,9 +1,5 @@
 # Clippy
 
-[### IMPORTANT NOTE FOR CONTRIBUTORS ================](development/feature_freeze.md)
-
-----
-
 [![License: MIT OR Apache-2.0](https://img.shields.io/crates/l/clippy.svg)](https://github.com/rust-lang/rust-clippy#license)
 
 A collection of lints to catch common mistakes and improve your
diff --git a/book/src/SUMMARY.md b/book/src/SUMMARY.md
index b66c3481e4930..39fe7358ed87a 100644
--- a/book/src/SUMMARY.md
+++ b/book/src/SUMMARY.md
@@ -13,7 +13,6 @@
     - [GitLab CI](continuous_integration/gitlab.md)
     - [Travis CI](continuous_integration/travis.md)
 - [Development](development/README.md)
-    - [IMPORTANT: FEATURE FREEZE](development/feature_freeze.md)
     - [Basics](development/basics.md)
     - [Adding Lints](development/adding_lints.md)
     - [Defining Lints](development/defining_lints.md)
diff --git a/book/src/development/adding_lints.md b/book/src/development/adding_lints.md
index a42a298374465..2b89e94cf8f4f 100644
--- a/book/src/development/adding_lints.md
+++ b/book/src/development/adding_lints.md
@@ -1,8 +1,5 @@
 # Adding a new lint
 
-[### IMPORTANT NOTE FOR CONTRIBUTORS ================](feature_freeze.md)
-
-
 You are probably here because you want to add a new lint to Clippy. If this is
 the first time you're contributing to Clippy, this document guides you through
 creating an example lint from scratch.
diff --git a/book/src/development/feature_freeze.md b/book/src/development/feature_freeze.md
deleted file mode 100644
index 260cb136cc075..0000000000000
--- a/book/src/development/feature_freeze.md
+++ /dev/null
@@ -1,55 +0,0 @@
-# IMPORTANT: FEATURE FREEZE
-
-This is a temporary notice.
-
-From the 26th of June until the 18th of September we will perform a feature freeze. Only bugfix PRs will be reviewed
-except already open ones. Every feature-adding PR opened in between those dates will be moved into a
-milestone to be reviewed separately at another time.
-
-We do this because of the long backlog of bugs that need to be addressed
-in order to continue being the state-of-the-art linter that Clippy has become known for being.
-
-## For contributors
-
-If you are a contributor or are planning to become one, **please do not open a lint-adding PR**, we have lots of open
-bugs of all levels of difficulty that you can address instead!
-
-We currently have about 800 lints, each one posing a maintainability challenge that needs to account to every possible
-use case of the whole ecosystem. Bugs are natural in every software, but the Clippy team considers that Clippy needs a
-refinement period.
-
-If you open a PR at this time, we will not review it but push it into a milestone until the refinement period ends,
-adding additional load into our reviewing schedules.
-
-## I want to help, what can I do
-
-Thanks a lot to everyone who wants to help Clippy become better software in this feature freeze period!
-If you'd like to help, making a bugfix, making sure that it works, and opening a PR is a great step!
-
-To find things to fix, go to the [tracking issue][tracking_issue], find an issue that you like, go there and claim that
-issue with `@rustbot claim`.
-
-As a general metric and always taking into account your skill and knowledge level, you can use this guide:
-
-- 🟥 [ICEs][search_ice], these are compiler errors that causes Clippy to panic and crash. Usually involves high-level
-debugging, sometimes interacting directly with the upstream compiler. Difficult to fix but a great challenge that
-improves a lot developer workflows!
-
-- 🟧 [Suggestion causes bug][sugg_causes_bug], Clippy suggested code that changed logic in some silent way.
-Unacceptable, as this may have disastrous consequences. Easier to fix than ICEs
-
-- 🟨 [Suggestion causes error][sugg_causes_error], Clippy suggested code snippet that caused a compiler error
-when applied. We need to make sure that Clippy doesn't suggest using a variable twice at the same time or similar
-easy-to-happen occurrences.
-
-- 🟩 [False positives][false_positive], a lint should not have fired, the easiest of them all, as this is "just"
-identifying the root of a false positive and making an exception for those cases.
-
-Note that false negatives do not have priority unless the case is very clear, as they are a feature-request in a
-trench coat.
-
-[search_ice]: https://github.com/rust-lang/rust-clippy/issues?q=sort%3Aupdated-desc+state%3Aopen+label%3A%22I-ICE%22
-[sugg_causes_bug]: https://github.com/rust-lang/rust-clippy/issues?q=sort%3Aupdated-desc%20state%3Aopen%20label%3AI-suggestion-causes-bug
-[sugg_causes_error]: https://github.com/rust-lang/rust-clippy/issues?q=sort%3Aupdated-desc%20state%3Aopen%20label%3AI-suggestion-causes-error%20
-[false_positive]: https://github.com/rust-lang/rust-clippy/issues?q=sort%3Aupdated-desc%20state%3Aopen%20label%3AI-false-positive
-[tracking_issue]: https://github.com/rust-lang/rust-clippy/issues/15086

From e84b5ca1dd40d09b261b0a495c6cbd6a5d8cb194 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Wed, 17 Sep 2025 18:51:42 +0200
Subject: [PATCH 1056/1889] Do not look for `Cargo.toml` inside `target`

This test, which checks that we do not define new profiles directly in
Clippy's multiple `Cargo.toml` files, must not look inside `target` as
`lintcheck` might place some third-party sources there. Of course those
third-party sources are allowed to define profiles in their `Cargo.toml`.
---
 tests/no-profile-in-cargo-toml.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/tests/no-profile-in-cargo-toml.rs b/tests/no-profile-in-cargo-toml.rs
index 2ad9bfb75dee8..1f8c4fae9b31f 100644
--- a/tests/no-profile-in-cargo-toml.rs
+++ b/tests/no-profile-in-cargo-toml.rs
@@ -17,6 +17,9 @@ fn no_profile_in_cargo_toml() {
     // keep it fast and simple.
     for entry in WalkDir::new(".")
         .into_iter()
+        // Do not recurse into `target` as lintcheck might put some sources (and their
+        //  `Cargo.toml`) there.
+        .filter_entry(|e| e.file_name() != "target")
         .filter_map(Result::ok)
         .filter(|e| e.file_name().to_str() == Some("Cargo.toml"))
     {

From b2b43b25a845ff624d4b4c0efb604ed3b684a3bd Mon Sep 17 00:00:00 2001
From: Alan Wu <XrXr@users.noreply.github.com>
Date: Wed, 17 Sep 2025 12:59:07 -0400
Subject: [PATCH 1057/1889] Add space after brace in
 `Box<[T]>::new_uninit_slice` example

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

diff --git a/library/alloc/src/boxed.rs b/library/alloc/src/boxed.rs
index 98c9f6b51ab86..7d2dd12c6eaea 100644
--- a/library/alloc/src/boxed.rs
+++ b/library/alloc/src/boxed.rs
@@ -640,7 +640,7 @@ impl<T> Box<[T]> {
     /// values[0].write(1);
     /// values[1].write(2);
     /// values[2].write(3);
-    /// let values = unsafe {values.assume_init() };
+    /// let values = unsafe { values.assume_init() };
     ///
     /// assert_eq!(*values, [1, 2, 3])
     /// ```

From 205189c8c767b3910a630f79b156417b82b3558b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Sun, 24 Aug 2025 11:19:51 +0200
Subject: [PATCH 1058/1889] port `#[rustc_coherence_is_core]` to the new
 attribute parsing infrastructure

---
 .../rustc_attr_parsing/src/attributes/crate_level.rs |  9 +++++++++
 compiler/rustc_attr_parsing/src/attributes/traits.rs |  8 --------
 compiler/rustc_attr_parsing/src/context.rs           | 12 ++++++------
 compiler/rustc_hir/src/attrs/data_structures.rs      |  6 +++---
 compiler/rustc_hir/src/attrs/encode_cross_crate.rs   |  2 +-
 compiler/rustc_middle/src/hir/map.rs                 |  2 +-
 compiler/rustc_passes/src/check_attr.rs              |  2 +-
 7 files changed, 21 insertions(+), 20 deletions(-)

diff --git a/compiler/rustc_attr_parsing/src/attributes/crate_level.rs b/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
index 4611de4445997..0a340cd5e9330 100644
--- a/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
@@ -174,3 +174,12 @@ impl<S: Stage> NoArgsAttributeParser<S> for NoStdParser {
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::NoStd;
 }
+
+pub(crate) struct RustcCoherenceIsCoreParser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for RustcCoherenceIsCoreParser {
+    const PATH: &[Symbol] = &[sym::rustc_coherence_is_core];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::RustcCoherenceIsCore;
+}
diff --git a/compiler/rustc_attr_parsing/src/attributes/traits.rs b/compiler/rustc_attr_parsing/src/attributes/traits.rs
index c756bce96e28f..ced3bcad2293a 100644
--- a/compiler/rustc_attr_parsing/src/attributes/traits.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/traits.rs
@@ -149,14 +149,6 @@ impl<S: Stage> NoArgsAttributeParser<S> for AllowIncoherentImplParser {
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::AllowIncoherentImpl;
 }
 
-pub(crate) struct CoherenceIsCoreParser;
-impl<S: Stage> NoArgsAttributeParser<S> for CoherenceIsCoreParser {
-    const PATH: &[Symbol] = &[sym::rustc_coherence_is_core];
-    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
-    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::CoherenceIsCore;
-}
-
 pub(crate) struct FundamentalParser;
 impl<S: Stage> NoArgsAttributeParser<S> for FundamentalParser {
     const PATH: &[Symbol] = &[sym::fundamental];
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index 58b1329248412..ee5b7322b0247 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -26,7 +26,7 @@ use crate::attributes::codegen_attrs::{
 use crate::attributes::confusables::ConfusablesParser;
 use crate::attributes::crate_level::{
     CrateNameParser, MoveSizeLimitParser, NoCoreParser, NoStdParser, PatternComplexityLimitParser,
-    RecursionLimitParser, TypeLengthLimitParser,
+    RecursionLimitParser, RustcCoherenceIsCoreParser, TypeLengthLimitParser,
 };
 use crate::attributes::deprecation::DeprecationParser;
 use crate::attributes::dummy::DummyParser;
@@ -61,10 +61,10 @@ use crate::attributes::stability::{
 };
 use crate::attributes::test_attrs::{IgnoreParser, ShouldPanicParser};
 use crate::attributes::traits::{
-    AllowIncoherentImplParser, CoherenceIsCoreParser, CoinductiveParser, ConstTraitParser,
-    DenyExplicitImplParser, DoNotImplementViaObjectParser, FundamentalParser, MarkerParser,
-    ParenSugarParser, PointeeParser, SkipDuringMethodDispatchParser, SpecializationTraitParser,
-    TypeConstParser, UnsafeSpecializationMarkerParser,
+    AllowIncoherentImplParser, CoinductiveParser, ConstTraitParser, DenyExplicitImplParser,
+    DoNotImplementViaObjectParser, FundamentalParser, MarkerParser, ParenSugarParser,
+    PointeeParser, SkipDuringMethodDispatchParser, SpecializationTraitParser, TypeConstParser,
+    UnsafeSpecializationMarkerParser,
 };
 use crate::attributes::transparency::TransparencyParser;
 use crate::attributes::{AttributeParser as _, Combine, Single, WithoutArgs};
@@ -206,7 +206,6 @@ attribute_parsers!(
         Single<WithoutArgs<AllowInternalUnsafeParser>>,
         Single<WithoutArgs<AsPtrParser>>,
         Single<WithoutArgs<AutomaticallyDerivedParser>>,
-        Single<WithoutArgs<CoherenceIsCoreParser>>,
         Single<WithoutArgs<CoinductiveParser>>,
         Single<WithoutArgs<ColdParser>>,
         Single<WithoutArgs<ConstContinueParser>>,
@@ -234,6 +233,7 @@ attribute_parsers!(
         Single<WithoutArgs<ProcMacroAttributeParser>>,
         Single<WithoutArgs<ProcMacroParser>>,
         Single<WithoutArgs<PubTransparentParser>>,
+        Single<WithoutArgs<RustcCoherenceIsCoreParser>>,
         Single<WithoutArgs<SpecializationTraitParser>>,
         Single<WithoutArgs<StdInternalSymbolParser>>,
         Single<WithoutArgs<TrackCallerParser>>,
diff --git a/compiler/rustc_hir/src/attrs/data_structures.rs b/compiler/rustc_hir/src/attrs/data_structures.rs
index 04b144abd03df..0784675b177a0 100644
--- a/compiler/rustc_hir/src/attrs/data_structures.rs
+++ b/compiler/rustc_hir/src/attrs/data_structures.rs
@@ -444,9 +444,6 @@ pub enum AttributeKind {
         span: Span,
     },
 
-    /// Represents `#[rustc_coherence_is_core]`.
-    CoherenceIsCore,
-
     /// Represents `#[rustc_coinductive]`.
     Coinductive(Span),
 
@@ -639,6 +636,9 @@ pub enum AttributeKind {
     /// Represents `#[rustc_builtin_macro]`.
     RustcBuiltinMacro { builtin_name: Option<Symbol>, helper_attrs: ThinVec<Symbol>, span: Span },
 
+    /// Represents `#[rustc_coherence_is_core]`
+    RustcCoherenceIsCore(Span),
+
     /// Represents `#[rustc_layout_scalar_valid_range_end]`.
     RustcLayoutScalarValidRangeEnd(Box<u128>, Span),
 
diff --git a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
index cb4feeb05f1a0..563e7a58c6d5e 100644
--- a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
+++ b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
@@ -26,7 +26,6 @@ impl AttributeKind {
             AsPtr(..) => Yes,
             AutomaticallyDerived(..) => Yes,
             BodyStability { .. } => No,
-            CoherenceIsCore => No,
             Coinductive(..) => No,
             Cold(..) => No,
             Confusables { .. } => Yes,
@@ -84,6 +83,7 @@ impl AttributeKind {
             RecursionLimit { .. } => No,
             Repr { .. } => No,
             RustcBuiltinMacro { .. } => Yes,
+            RustcCoherenceIsCore(..) => No,
             RustcLayoutScalarValidRangeEnd(..) => Yes,
             RustcLayoutScalarValidRangeStart(..) => Yes,
             RustcObjectLifetimeDefault => No,
diff --git a/compiler/rustc_middle/src/hir/map.rs b/compiler/rustc_middle/src/hir/map.rs
index 4370816d38e5f..430cd329408f5 100644
--- a/compiler/rustc_middle/src/hir/map.rs
+++ b/compiler/rustc_middle/src/hir/map.rs
@@ -370,7 +370,7 @@ impl<'tcx> TyCtxt<'tcx> {
     }
 
     pub fn hir_rustc_coherence_is_core(self) -> bool {
-        find_attr!(self.hir_krate_attrs(), AttributeKind::CoherenceIsCore)
+        find_attr!(self.hir_krate_attrs(), AttributeKind::RustcCoherenceIsCore(..))
     }
 
     pub fn hir_get_module(self, module: LocalModDefId) -> (&'tcx Mod<'tcx>, Span, HirId) {
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 60f575cb84415..4d5a8447695be 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -246,7 +246,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::Repr { .. }
                     | AttributeKind::Cold(..)
                     | AttributeKind::ExportName { .. }
-                    | AttributeKind::CoherenceIsCore
                     | AttributeKind::Fundamental
                     | AttributeKind::Optimize(..)
                     | AttributeKind::LinkSection { .. }
@@ -278,6 +277,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::NoStd { .. }
                     | AttributeKind::ObjcClass { .. }
                     | AttributeKind::ObjcSelector { .. }
+                    | AttributeKind::RustcCoherenceIsCore(..)
                 ) => { /* do nothing  */ }
                 Attribute::Unparsed(attr_item) => {
                     style = Some(attr_item.style);

From 1d8971cf4e5f954c7fc9a2611dcf359a832f4c7a Mon Sep 17 00:00:00 2001
From: Yotam Ofek <yotam.ofek@gmail.com>
Date: Tue, 16 Sep 2025 10:34:04 +0000
Subject: [PATCH 1059/1889] Cleanup `FnDecl::inner_full_print`

---
 src/librustdoc/display.rs     |   6 +-
 src/librustdoc/html/format.rs | 107 +++++++++++++++++++---------------
 2 files changed, 62 insertions(+), 51 deletions(-)

diff --git a/src/librustdoc/display.rs b/src/librustdoc/display.rs
index aa0fad265208d..db868c5c9a8f3 100644
--- a/src/librustdoc/display.rs
+++ b/src/librustdoc/display.rs
@@ -10,7 +10,7 @@ pub(crate) trait Joined: IntoIterator {
     ///
     /// The performance of `joined` is slightly better than `format`, since it doesn't need to use a `Cell` to keep track of whether [`fmt`](Display::fmt)
     /// was already called (`joined`'s API doesn't allow it be called more than once).
-    fn joined(self, sep: &str, f: &mut Formatter<'_>) -> fmt::Result;
+    fn joined(self, sep: impl Display, f: &mut Formatter<'_>) -> fmt::Result;
 }
 
 impl<I, T> Joined for I
@@ -18,12 +18,12 @@ where
     I: IntoIterator<Item = T>,
     T: Display,
 {
-    fn joined(self, sep: &str, f: &mut Formatter<'_>) -> fmt::Result {
+    fn joined(self, sep: impl Display, f: &mut Formatter<'_>) -> fmt::Result {
         let mut iter = self.into_iter();
         let Some(first) = iter.next() else { return Ok(()) };
         first.fmt(f)?;
         for item in iter {
-            f.write_str(sep)?;
+            sep.fmt(f)?;
             item.fmt(f)?;
         }
         Ok(())
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
index 493fdc6fb1b33..8c75f301841f3 100644
--- a/src/librustdoc/html/format.rs
+++ b/src/librustdoc/html/format.rs
@@ -1264,6 +1264,7 @@ impl std::fmt::Write for WriteCounter {
 }
 
 // Implements Display by emitting the given number of spaces.
+#[derive(Clone, Copy)]
 struct Indent(usize);
 
 impl Display for Indent {
@@ -1275,6 +1276,37 @@ impl Display for Indent {
     }
 }
 
+impl clean::Parameter {
+    fn print(&self, cx: &Context<'_>) -> impl fmt::Display {
+        fmt::from_fn(move |f| {
+            if let Some(self_ty) = self.to_receiver() {
+                match self_ty {
+                    clean::SelfTy => f.write_str("self"),
+                    clean::BorrowedRef { lifetime, mutability, type_: box clean::SelfTy } => {
+                        f.write_str(if f.alternate() { "&" } else { "&amp;" })?;
+                        if let Some(lt) = lifetime {
+                            write!(f, "{lt} ", lt = lt.print())?;
+                        }
+                        write!(f, "{mutability}self", mutability = mutability.print_with_space())
+                    }
+                    _ => {
+                        f.write_str("self: ")?;
+                        self_ty.print(cx).fmt(f)
+                    }
+                }
+            } else {
+                if self.is_const {
+                    write!(f, "const ")?;
+                }
+                if let Some(name) = self.name {
+                    write!(f, "{name}: ")?;
+                }
+                self.type_.print(cx).fmt(f)
+            }
+        })
+    }
+}
+
 impl clean::FnDecl {
     pub(crate) fn print(&self, cx: &Context<'_>) -> impl Display {
         fmt::from_fn(move |f| {
@@ -1333,63 +1365,42 @@ impl clean::FnDecl {
         f: &mut fmt::Formatter<'_>,
         cx: &Context<'_>,
     ) -> fmt::Result {
-        let amp = if f.alternate() { "&" } else { "&amp;" };
+        f.write_char('(')?;
 
-        write!(f, "(")?;
-        if let Some(n) = line_wrapping_indent
-            && !self.inputs.is_empty()
-        {
-            write!(f, "\n{}", Indent(n + 4))?;
-        }
+        if !self.inputs.is_empty() {
+            let line_wrapping_indent = line_wrapping_indent.map(|n| Indent(n + 4));
 
-        let last_input_index = self.inputs.len().checked_sub(1);
-        for (i, param) in self.inputs.iter().enumerate() {
-            if let Some(selfty) = param.to_receiver() {
-                match selfty {
-                    clean::SelfTy => {
-                        write!(f, "self")?;
-                    }
-                    clean::BorrowedRef { lifetime, mutability, type_: box clean::SelfTy } => {
-                        write!(f, "{amp}")?;
-                        if let Some(lt) = lifetime {
-                            write!(f, "{lt} ", lt = lt.print())?;
-                        }
-                        write!(f, "{mutability}self", mutability = mutability.print_with_space())?;
-                    }
-                    _ => {
-                        write!(f, "self: ")?;
-                        selfty.print(cx).fmt(f)?;
-                    }
-                }
-            } else {
-                if param.is_const {
-                    write!(f, "const ")?;
-                }
-                if let Some(name) = param.name {
-                    write!(f, "{name}: ")?;
+            if let Some(indent) = line_wrapping_indent {
+                write!(f, "\n{indent}")?;
+            }
+
+            let sep = fmt::from_fn(|f| {
+                if let Some(indent) = line_wrapping_indent {
+                    write!(f, ",\n{indent}")
+                } else {
+                    f.write_str(", ")
                 }
-                param.type_.print(cx).fmt(f)?;
+            });
+
+            self.inputs.iter().map(|param| param.print(cx)).joined(sep, f)?;
+
+            if line_wrapping_indent.is_some() {
+                writeln!(f, ",")?
             }
-            match (line_wrapping_indent, last_input_index) {
-                (_, None) => (),
-                (None, Some(last_i)) if i != last_i => write!(f, ", ")?,
-                (None, Some(_)) => (),
-                (Some(n), Some(last_i)) if i != last_i => write!(f, ",\n{}", Indent(n + 4))?,
-                (Some(_), Some(_)) => writeln!(f, ",")?,
+
+            if self.c_variadic {
+                match line_wrapping_indent {
+                    None => write!(f, ", ...")?,
+                    Some(indent) => writeln!(f, "{indent}...")?,
+                };
             }
         }
 
-        if self.c_variadic {
-            match line_wrapping_indent {
-                None => write!(f, ", ...")?,
-                Some(n) => writeln!(f, "{}...", Indent(n + 4))?,
-            };
+        if let Some(n) = line_wrapping_indent {
+            write!(f, "{}", Indent(n))?
         }
 
-        match line_wrapping_indent {
-            None => write!(f, ")")?,
-            Some(n) => write!(f, "{})", Indent(n))?,
-        };
+        f.write_char(')')?;
 
         self.print_output(cx).fmt(f)
     }

From c1f782919bac1071a514eafb87e2463be25fc99e Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Wed, 17 Sep 2025 19:23:28 +0200
Subject: [PATCH 1060/1889] `match_as_ref`: do not lint if other arm is not
 `None => None`

---
 clippy_lints/src/manual_option_as_slice.rs |  6 ++---
 clippy_utils/src/lib.rs                    | 16 +++++++-----
 tests/ui/match_as_ref.fixed                | 30 ++++++++++++++++++++++
 tests/ui/match_as_ref.rs                   | 30 ++++++++++++++++++++++
 4 files changed, 73 insertions(+), 9 deletions(-)

diff --git a/clippy_lints/src/manual_option_as_slice.rs b/clippy_lints/src/manual_option_as_slice.rs
index 922db174e3d49..b036e78cdedc5 100644
--- a/clippy_lints/src/manual_option_as_slice.rs
+++ b/clippy_lints/src/manual_option_as_slice.rs
@@ -1,7 +1,7 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
 use clippy_utils::msrvs::Msrv;
-use clippy_utils::{is_none_arm, msrvs, peel_hir_expr_refs, sym};
+use clippy_utils::{is_none_pattern, msrvs, peel_hir_expr_refs, sym};
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Arm, Expr, ExprKind, LangItem, Pat, PatKind, QPath, is_range_literal};
@@ -60,8 +60,8 @@ impl LateLintPass<'_> for ManualOptionAsSlice {
         }
         match expr.kind {
             ExprKind::Match(scrutinee, [arm1, arm2], _) => {
-                if is_none_arm(cx, arm2) && check_arms(cx, arm2, arm1)
-                    || is_none_arm(cx, arm1) && check_arms(cx, arm1, arm2)
+                if is_none_pattern(cx, arm2.pat) && check_arms(cx, arm2, arm1)
+                    || is_none_pattern(cx, arm1.pat) && check_arms(cx, arm1, arm2)
                 {
                     check_as_ref(cx, scrutinee, span, self.msrv);
                 }
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 5223cd872a680..3e48397fbedbe 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -329,13 +329,17 @@ pub fn is_wild(pat: &Pat<'_>) -> bool {
     matches!(pat.kind, PatKind::Wild)
 }
 
-// Checks if arm has the form `None => None`
-pub fn is_none_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
-    matches!(
-        arm.pat.kind,
+/// Checks if the `pat` is `None`.
+pub fn is_none_pattern(cx: &LateContext<'_>, pat: &Pat<'_>) -> bool {
+    matches!(pat.kind,
         PatKind::Expr(PatExpr { kind: PatExprKind::Path(qpath), .. })
-            if is_res_lang_ctor(cx, cx.qpath_res(qpath, arm.pat.hir_id), OptionNone)
-    )
+            if is_res_lang_ctor(cx, cx.qpath_res(qpath, pat.hir_id), OptionNone))
+}
+
+/// Checks if `arm` has the form `None => None`.
+pub fn is_none_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
+    is_none_pattern(cx, arm.pat)
+        && matches!(peel_blocks(arm.body).kind, ExprKind::Path(qpath) if is_res_lang_ctor(cx, cx.qpath_res(&qpath, arm.body.hir_id), OptionNone))
 }
 
 /// Checks if the given `QPath` belongs to a type alias.
diff --git a/tests/ui/match_as_ref.fixed b/tests/ui/match_as_ref.fixed
index 8c07076af4a49..a39f0c9299bd5 100644
--- a/tests/ui/match_as_ref.fixed
+++ b/tests/ui/match_as_ref.fixed
@@ -41,3 +41,33 @@ fn main() {
         None => None,
     };
 }
+
+mod issue15691 {
+    use std::ops::{Deref, DerefMut};
+
+    struct A(B);
+    struct B;
+
+    impl Deref for A {
+        type Target = B;
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    impl DerefMut for A {
+        fn deref_mut(&mut self) -> &mut Self::Target {
+            &mut self.0
+        }
+    }
+
+    fn func() {
+        let mut a = Some(A(B));
+        let mut b = Some(B);
+        // Do not lint, we don't have `None => None`
+        let _ = match b {
+            Some(ref mut x) => Some(x),
+            None => a.as_deref_mut(),
+        };
+    }
+}
diff --git a/tests/ui/match_as_ref.rs b/tests/ui/match_as_ref.rs
index 3a5b1227331e7..049928167901a 100644
--- a/tests/ui/match_as_ref.rs
+++ b/tests/ui/match_as_ref.rs
@@ -53,3 +53,33 @@ fn main() {
         None => None,
     };
 }
+
+mod issue15691 {
+    use std::ops::{Deref, DerefMut};
+
+    struct A(B);
+    struct B;
+
+    impl Deref for A {
+        type Target = B;
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    impl DerefMut for A {
+        fn deref_mut(&mut self) -> &mut Self::Target {
+            &mut self.0
+        }
+    }
+
+    fn func() {
+        let mut a = Some(A(B));
+        let mut b = Some(B);
+        // Do not lint, we don't have `None => None`
+        let _ = match b {
+            Some(ref mut x) => Some(x),
+            None => a.as_deref_mut(),
+        };
+    }
+}

From 9cdc09b604f2a3bdab334911bac99d23ed556c23 Mon Sep 17 00:00:00 2001
From: LorrensP-2158466 <lorrens.pantelis@student.uhasselt.be>
Date: Tue, 16 Sep 2025 09:48:08 +0200
Subject: [PATCH 1061/1889] readdir for freebsd

---
 .../src/shims/unix/freebsd/foreign_items.rs   |  6 +-
 src/tools/miri/src/shims/unix/fs.rs           | 60 ++++++++++++-------
 .../src/shims/unix/linux/foreign_items.rs     |  2 +-
 .../src/shims/unix/solarish/foreign_items.rs  |  2 +-
 src/tools/miri/tests/pass/shims/fs.rs         |  3 +-
 5 files changed, 46 insertions(+), 27 deletions(-)

diff --git a/src/tools/miri/src/shims/unix/freebsd/foreign_items.rs b/src/tools/miri/src/shims/unix/freebsd/foreign_items.rs
index 9e247053fbcdb..413df85ee3aae 100644
--- a/src/tools/miri/src/shims/unix/freebsd/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/freebsd/foreign_items.rs
@@ -159,7 +159,11 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 let result = this.macos_fbsd_readdir_r(dirp, entry, result)?;
                 this.write_scalar(result, dest)?;
             }
-
+            "readdir" | "readdir@FBSD_1.0" => {
+                let [dirp] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
+                let result = this.readdir64("dirent", dirp)?;
+                this.write_scalar(result, dest)?;
+            }
             // Miscellaneous
             "__error" => {
                 let [] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
diff --git a/src/tools/miri/src/shims/unix/fs.rs b/src/tools/miri/src/shims/unix/fs.rs
index f9bcacf64c412..22bec9bd83941 100644
--- a/src/tools/miri/src/shims/unix/fs.rs
+++ b/src/tools/miri/src/shims/unix/fs.rs
@@ -900,14 +900,10 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         }
     }
 
-    fn linux_solarish_readdir64(
-        &mut self,
-        dirent_type: &str,
-        dirp_op: &OpTy<'tcx>,
-    ) -> InterpResult<'tcx, Scalar> {
+    fn readdir64(&mut self, dirent_type: &str, dirp_op: &OpTy<'tcx>) -> InterpResult<'tcx, Scalar> {
         let this = self.eval_context_mut();
 
-        if !matches!(&*this.tcx.sess.target.os, "linux" | "solaris" | "illumos") {
+        if !matches!(&*this.tcx.sess.target.os, "linux" | "solaris" | "illumos" | "freebsd") {
             panic!("`linux_solaris_readdir64` should not be called on {}", this.tcx.sess.target.os);
         }
 
@@ -926,6 +922,13 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         let entry = match open_dir.read_dir.next() {
             Some(Ok(dir_entry)) => {
+                // If the host is a Unix system, fill in the inode number with its real value.
+                // If not, use 0 as a fallback value.
+                #[cfg(unix)]
+                let ino = std::os::unix::fs::DirEntryExt::ino(&dir_entry);
+                #[cfg(not(unix))]
+                let ino = 0u64;
+
                 // Write the directory entry into a newly allocated buffer.
                 // The name is written with write_bytes, while the rest of the
                 // dirent64 (or dirent) struct is written using write_int_fields.
@@ -947,6 +950,15 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 //     pub d_reclen: c_ushort,
                 //     pub d_name: [c_char; 3],
                 // }
+                //
+                // On FreeBSD:
+                // pub struct dirent{
+                //     pub d_fileno: uint32_t,
+                //     pub d_reclen: uint16_t,
+                //     pub d_type: uint8_t,
+                //     pub d_namlen: uint8_t,
+                //     pub d_name: [c_char; 256]
+                // }
 
                 let mut name = dir_entry.file_name(); // not a Path as there are no separators!
                 name.push("\0"); // Add a NUL terminator
@@ -965,31 +977,35 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     MiriMemoryKind::Runtime.into(),
                     AllocInit::Uninit,
                 )?;
-                let entry: Pointer = entry.into();
+                let entry = this.ptr_to_mplace(entry.into(), dirent_layout);
 
-                // If the host is a Unix system, fill in the inode number with its real value.
-                // If not, use 0 as a fallback value.
-                #[cfg(unix)]
-                let ino = std::os::unix::fs::DirEntryExt::ino(&dir_entry);
-                #[cfg(not(unix))]
-                let ino = 0u64;
-
-                let file_type = this.file_type_to_d_type(dir_entry.file_type())?;
+                // Write common fields
+                let ino_name =
+                    if this.tcx.sess.target.os == "freebsd" { "d_fileno" } else { "d_ino" };
                 this.write_int_fields_named(
-                    &[("d_ino", ino.into()), ("d_off", 0), ("d_reclen", size.into())],
-                    &this.ptr_to_mplace(entry, dirent_layout),
+                    &[(ino_name, ino.into()), ("d_reclen", size.into())],
+                    &entry,
                 )?;
 
-                if let Some(d_type) = this
-                    .try_project_field_named(&this.ptr_to_mplace(entry, dirent_layout), "d_type")?
-                {
+                // Write "optional" fields.
+                if let Some(d_off) = this.try_project_field_named(&entry, "d_off")? {
+                    this.write_null(&d_off)?;
+                }
+
+                if let Some(d_namlen) = this.try_project_field_named(&entry, "d_namlen")? {
+                    this.write_int(name_len.strict_sub(1), &d_namlen)?;
+                }
+
+                let file_type = this.file_type_to_d_type(dir_entry.file_type())?;
+                if let Some(d_type) = this.try_project_field_named(&entry, "d_type")? {
                     this.write_int(file_type, &d_type)?;
                 }
 
-                let name_ptr = entry.wrapping_offset(Size::from_bytes(d_name_offset), this);
+                // The name is not a normal field, we already computed the offset above.
+                let name_ptr = entry.ptr().wrapping_offset(Size::from_bytes(d_name_offset), this);
                 this.write_bytes_ptr(name_ptr, name_bytes.iter().copied())?;
 
-                Some(entry)
+                Some(entry.ptr())
             }
             None => {
                 // end of stream: return NULL
diff --git a/src/tools/miri/src/shims/unix/linux/foreign_items.rs b/src/tools/miri/src/shims/unix/linux/foreign_items.rs
index e7e0c3b6ecd96..79052698f4bad 100644
--- a/src/tools/miri/src/shims/unix/linux/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/linux/foreign_items.rs
@@ -38,7 +38,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             // File related shims
             "readdir64" => {
                 let [dirp] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
-                let result = this.linux_solarish_readdir64("dirent64", dirp)?;
+                let result = this.readdir64("dirent64", dirp)?;
                 this.write_scalar(result, dest)?;
             }
             "sync_file_range" => {
diff --git a/src/tools/miri/src/shims/unix/solarish/foreign_items.rs b/src/tools/miri/src/shims/unix/solarish/foreign_items.rs
index d7033a65fe22b..31269bf00c948 100644
--- a/src/tools/miri/src/shims/unix/solarish/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/solarish/foreign_items.rs
@@ -106,7 +106,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             }
             "readdir" => {
                 let [dirp] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
-                let result = this.linux_solarish_readdir64("dirent", dirp)?;
+                let result = this.readdir64("dirent", dirp)?;
                 this.write_scalar(result, dest)?;
             }
 
diff --git a/src/tools/miri/tests/pass/shims/fs.rs b/src/tools/miri/tests/pass/shims/fs.rs
index 0748007b3c058..022dcc5dcbafa 100644
--- a/src/tools/miri/tests/pass/shims/fs.rs
+++ b/src/tools/miri/tests/pass/shims/fs.rs
@@ -28,8 +28,7 @@ fn main() {
     test_from_raw_os_error();
     test_file_clone();
     // Windows file handling is very incomplete.
-    // FIXME: read_dir broken on FreeBSD (https://github.com/rust-lang/miri/issues/4587)
-    if cfg!(not(windows)) && !cfg!(target_os = "freebsd") {
+    if cfg!(not(windows)) {
         test_file_set_len();
         test_file_sync();
         test_rename();

From 987f9603f9907bdcea9911517f216554f3c5cd4d Mon Sep 17 00:00:00 2001
From: ltdk <usr@ltdk.xyz>
Date: Wed, 17 Sep 2025 14:10:13 -0400
Subject: [PATCH 1062/1889] Sort safe intrinsic list

---
 .../rustc_hir_analysis/src/check/intrinsic.rs | 120 +++++++++---------
 1 file changed, 62 insertions(+), 58 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/check/intrinsic.rs b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
index aa2d27ab80945..5fd04427496d4 100644
--- a/compiler/rustc_hir_analysis/src/check/intrinsic.rs
+++ b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
@@ -64,83 +64,87 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         // it's usually worth updating that intrinsic's documentation
         // to note that it's safe to call, since
         // safe extern fns are otherwise unprecedented.
-        sym::abort
+
+        // tidy-alphabetical-start
+        | sym::abort
+        | sym::add_with_overflow
+        | sym::aggregate_raw_ptr
+        | sym::align_of
         | sym::assert_inhabited
-        | sym::assert_zero_valid
         | sym::assert_mem_uninitialized_valid
+        | sym::assert_zero_valid
+        | sym::autodiff
+        | sym::bitreverse
+        | sym::black_box
         | sym::box_new
         | sym::breakpoint
-        | sym::size_of
-        | sym::align_of
-        | sym::needs_drop
+        | sym::bswap
         | sym::caller_location
-        | sym::add_with_overflow
-        | sym::sub_with_overflow
-        | sym::mul_with_overflow
         | sym::carrying_mul_add
-        | sym::wrapping_add
-        | sym::wrapping_sub
-        | sym::wrapping_mul
-        | sym::saturating_add
-        | sym::saturating_sub
-        | sym::rotate_left
-        | sym::rotate_right
-        | sym::ctpop
+        | sym::cold_path
+        | sym::const_eval_select
+        | sym::contract_check_ensures
+        | sym::contract_check_requires
+        | sym::contract_checks
         | sym::ctlz
+        | sym::ctpop
         | sym::cttz
-        | sym::bswap
-        | sym::bitreverse
-        | sym::three_way_compare
         | sym::discriminant_value
-        | sym::type_id
-        | sym::type_id_eq
-        | sym::select_unpredictable
-        | sym::cold_path
-        | sym::ptr_guaranteed_cmp
-        | sym::minnumf16
-        | sym::minnumf32
-        | sym::minnumf64
-        | sym::minnumf128
-        | sym::minimumf16
-        | sym::minimumf32
-        | sym::minimumf64
-        | sym::minimumf128
-        | sym::maxnumf16
-        | sym::maxnumf32
-        | sym::maxnumf64
-        | sym::maxnumf128
+        | sym::fadd_algebraic
+        | sym::fdiv_algebraic
+        | sym::fmul_algebraic
+        | sym::forget
+        | sym::frem_algebraic
+        | sym::fsub_algebraic
+        | sym::is_val_statically_known
         | sym::maximumf16
         | sym::maximumf32
         | sym::maximumf64
         | sym::maximumf128
-        | sym::rustc_peek
-        | sym::type_name
-        | sym::forget
-        | sym::black_box
-        | sym::variant_count
-        | sym::is_val_statically_known
+        | sym::maxnumf16
+        | sym::maxnumf32
+        | sym::maxnumf64
+        | sym::maxnumf128
+        | sym::minimumf16
+        | sym::minimumf32
+        | sym::minimumf64
+        | sym::minimumf128
+        | sym::minnumf16
+        | sym::minnumf32
+        | sym::minnumf64
+        | sym::minnumf128
+        | sym::mul_with_overflow
+        | sym::needs_drop
+        | sym::prefetch_read_data
+        | sym::prefetch_read_instruction
+        | sym::prefetch_write_data
+        | sym::prefetch_write_instruction
+        | sym::ptr_guaranteed_cmp
         | sym::ptr_mask
-        | sym::aggregate_raw_ptr
         | sym::ptr_metadata
-        | sym::ub_checks
-        | sym::contract_checks
-        | sym::contract_check_requires
-        | sym::contract_check_ensures
-        | sym::fadd_algebraic
-        | sym::fsub_algebraic
-        | sym::fmul_algebraic
-        | sym::fdiv_algebraic
-        | sym::frem_algebraic
+        | sym::rotate_left
+        | sym::rotate_right
         | sym::round_ties_even_f16
         | sym::round_ties_even_f32
         | sym::round_ties_even_f64
         | sym::round_ties_even_f128
-        | sym::autodiff
-        | sym::prefetch_read_data
-        | sym::prefetch_write_data
-        | sym::prefetch_read_instruction
-        | sym::prefetch_write_instruction
-        | sym::const_eval_select => hir::Safety::Safe,
+        | sym::rustc_peek
+        | sym::saturating_add
+        | sym::saturating_sub
+        | sym::select_unpredictable
+        | sym::size_of
+        | sym::sub_with_overflow
+        | sym::three_way_compare
+        | sym::type_id
+        | sym::type_id_eq
+        | sym::type_name
+        | sym::ub_checks
+        | sym::variant_count
+        | sym::wrapping_add
+        | sym::wrapping_mul
+        | sym::wrapping_sub
+        // tidy-alphabetical-end
+        => hir::Safety::Safe,
         _ => hir::Safety::Unsafe,
     };
 

From b17213a87b66d94b0d7f7202cd0f56e74bcad857 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Wed, 17 Sep 2025 22:04:28 +0200
Subject: [PATCH 1063/1889] about-this-guide.md: improve a bit

---
 src/doc/rustc-dev-guide/src/about-this-guide.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/about-this-guide.md b/src/doc/rustc-dev-guide/src/about-this-guide.md
index f1a406a1c29be..4f5733ae0821a 100644
--- a/src/doc/rustc-dev-guide/src/about-this-guide.md
+++ b/src/doc/rustc-dev-guide/src/about-this-guide.md
@@ -48,9 +48,9 @@ In addition, many of the ideas discussed throughout this guide are idealized des
 that are not fully realized yet.
 All this makes keeping this guide completely up to date on everything very hard!
 
-The Guide itself is of course open-source as well,
-and the sources can be found at the [GitHub repository].
-If you find any mistakes in the guide, please file an issue about it.
+The guide itself is of course open source as well,
+and the sources are hosted on [a GitHub repository].
+If you find any mistakes in the guide, please file an issue.
 Even better, open a PR with a correction!
 
 If you do contribute to the guide,
@@ -105,7 +105,7 @@ You might also find the following sites useful:
 [cheatsheet]: https://bors.rust-lang.org/
 [Miri]: https://github.com/rust-lang/miri
 [@bors]: https://github.com/bors
-[GitHub repository]: https://github.com/rust-lang/rustc-dev-guide/
+[a GitHub repository]: https://github.com/rust-lang/rustc-dev-guide/
 [rustc API docs]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle
 [Forge]: https://forge.rust-lang.org/
 [compiler-team]: https://github.com/rust-lang/compiler-team/

From 80db273b6445cdbbac943c047ca4a10ee5c7ea45 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 17 Sep 2025 16:28:46 -0400
Subject: [PATCH 1064/1889] Remove jujutsu directory from search tools.

---
 .gitignore | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.gitignore b/.gitignore
index 36a4cdc1c3528..666c4ceac4dbb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -48,3 +48,6 @@ helper.txt
 
 # mdbook generated output
 /book/book
+
+# Remove jujutsu directory from search tools
+.jj

From 912785d966395d36cd2cebe5d0959316fdd28cef Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Sat, 13 Sep 2025 18:07:35 +0000
Subject: [PATCH 1065/1889] Lint overlapping assignments in MIR.

---
 compiler/rustc_middle/src/mir/visit.rs        | 17 +++++++
 compiler/rustc_mir_transform/src/dest_prop.rs | 18 +-------
 compiler/rustc_mir_transform/src/lint.rs      | 44 ++++++++++++++-----
 tests/ui/mir/lint/assignment-overlap.rs       |  2 +-
 4 files changed, 53 insertions(+), 28 deletions(-)

diff --git a/compiler/rustc_middle/src/mir/visit.rs b/compiler/rustc_middle/src/mir/visit.rs
index 07a15b3cd18a7..81df239dee42d 100644
--- a/compiler/rustc_middle/src/mir/visit.rs
+++ b/compiler/rustc_middle/src/mir/visit.rs
@@ -1475,3 +1475,20 @@ impl PlaceContext {
         }
     }
 }
+
+/// Small utility to visit places and locals without manually implementing a full visitor.
+pub struct VisitPlacesWith<F>(pub F);
+
+impl<'tcx, F> Visitor<'tcx> for VisitPlacesWith<F>
+where
+    F: FnMut(Place<'tcx>, PlaceContext),
+{
+    fn visit_local(&mut self, local: Local, ctxt: PlaceContext, _: Location) {
+        (self.0)(local.into(), ctxt);
+    }
+
+    fn visit_place(&mut self, place: &Place<'tcx>, ctxt: PlaceContext, location: Location) {
+        (self.0)(*place, ctxt);
+        self.visit_projection(place.as_ref(), ctxt, location);
+    }
+}
diff --git a/compiler/rustc_mir_transform/src/dest_prop.rs b/compiler/rustc_mir_transform/src/dest_prop.rs
index abd1cd4e35ac0..74c22ff10c198 100644
--- a/compiler/rustc_mir_transform/src/dest_prop.rs
+++ b/compiler/rustc_mir_transform/src/dest_prop.rs
@@ -141,7 +141,7 @@ use rustc_data_structures::union_find::UnionFind;
 use rustc_index::bit_set::DenseBitSet;
 use rustc_index::interval::SparseIntervalMatrix;
 use rustc_index::{IndexVec, newtype_index};
-use rustc_middle::mir::visit::{MutVisitor, PlaceContext, Visitor};
+use rustc_middle::mir::visit::{MutVisitor, PlaceContext, VisitPlacesWith, Visitor};
 use rustc_middle::mir::*;
 use rustc_middle::ty::TyCtxt;
 use rustc_mir_dataflow::impls::{DefUse, MaybeLiveLocals};
@@ -503,22 +503,6 @@ impl TwoStepIndex {
     }
 }
 
-struct VisitPlacesWith<F>(F);
-
-impl<'tcx, F> Visitor<'tcx> for VisitPlacesWith<F>
-where
-    F: FnMut(Place<'tcx>, PlaceContext),
-{
-    fn visit_local(&mut self, local: Local, ctxt: PlaceContext, _: Location) {
-        (self.0)(local.into(), ctxt);
-    }
-
-    fn visit_place(&mut self, place: &Place<'tcx>, ctxt: PlaceContext, location: Location) {
-        (self.0)(*place, ctxt);
-        self.visit_projection(place.as_ref(), ctxt, location);
-    }
-}
-
 /// Add points depending on the result of the given dataflow analysis.
 fn save_as_intervals<'tcx>(
     elements: &DenseLocationMap,
diff --git a/compiler/rustc_mir_transform/src/lint.rs b/compiler/rustc_mir_transform/src/lint.rs
index f472c7cb493d0..2ab49645dc44f 100644
--- a/compiler/rustc_mir_transform/src/lint.rs
+++ b/compiler/rustc_mir_transform/src/lint.rs
@@ -6,7 +6,7 @@ use std::borrow::Cow;
 
 use rustc_data_structures::fx::FxHashSet;
 use rustc_index::bit_set::DenseBitSet;
-use rustc_middle::mir::visit::{PlaceContext, Visitor};
+use rustc_middle::mir::visit::{PlaceContext, VisitPlacesWith, Visitor};
 use rustc_middle::mir::*;
 use rustc_middle::ty::TyCtxt;
 use rustc_mir_dataflow::impls::{MaybeStorageDead, MaybeStorageLive, always_storage_live_locals};
@@ -79,15 +79,39 @@ impl<'a, 'tcx> Visitor<'tcx> for Lint<'a, 'tcx> {
     fn visit_statement(&mut self, statement: &Statement<'tcx>, location: Location) {
         match &statement.kind {
             StatementKind::Assign(box (dest, rvalue)) => {
-                if let Rvalue::Use(Operand::Copy(src) | Operand::Move(src)) = rvalue {
-                    // The sides of an assignment must not alias. Currently this just checks whether
-                    // the places are identical.
-                    if dest == src {
-                        self.fail(
-                            location,
-                            "encountered `Assign` statement with overlapping memory",
-                        );
-                    }
+                let forbid_aliasing = match rvalue {
+                    Rvalue::Use(..)
+                    | Rvalue::CopyForDeref(..)
+                    | Rvalue::Repeat(..)
+                    | Rvalue::Aggregate(..)
+                    | Rvalue::Cast(..)
+                    | Rvalue::ShallowInitBox(..)
+                    | Rvalue::WrapUnsafeBinder(..) => true,
+                    Rvalue::ThreadLocalRef(..)
+                    | Rvalue::NullaryOp(..)
+                    | Rvalue::UnaryOp(..)
+                    | Rvalue::BinaryOp(..)
+                    | Rvalue::Ref(..)
+                    | Rvalue::RawPtr(..)
+                    | Rvalue::Discriminant(..) => false,
+                };
+                // The sides of an assignment must not alias.
+                if forbid_aliasing {
+                    VisitPlacesWith(|src: Place<'tcx>, _| {
+                        if *dest == src
+                            || (dest.local == src.local
+                                && !dest.is_indirect()
+                                && !src.is_indirect())
+                        {
+                            self.fail(
+                                location,
+                                format!(
+                                    "encountered `{statement:?}` statement with overlapping memory"
+                                ),
+                            );
+                        }
+                    })
+                    .visit_rvalue(rvalue, location);
                 }
             }
             StatementKind::StorageLive(local) => {
diff --git a/tests/ui/mir/lint/assignment-overlap.rs b/tests/ui/mir/lint/assignment-overlap.rs
index bbc140904671e..5d1213a77585f 100644
--- a/tests/ui/mir/lint/assignment-overlap.rs
+++ b/tests/ui/mir/lint/assignment-overlap.rs
@@ -13,7 +13,7 @@ pub fn main() {
         let a: [u8; 1024];
         {
             a = a; //~ ERROR broken MIR
-                   //~^ ERROR encountered `Assign` statement with overlapping memory
+                   //~^ ERROR encountered `_1 = copy _1` statement with overlapping memory
             Return()
         }
     }

From 8d7ec96c00994e3e4da652201792ae2040c979c1 Mon Sep 17 00:00:00 2001
From: Nathaniel McCallum <nathaniel@mccallum.life>
Date: Fri, 12 Sep 2025 18:35:21 -0400
Subject: [PATCH 1066/1889] add `[const] PartialEq` bound to `PartialOrd`

This change is included for discussion purposes.

The PartialOrd bound on PartialEq is not strictly necessary. It
is, rather, logical: anything which is orderable should by
definition have equality. Is the same true for constness? Should
every type which is const orderable also have const equality?
---
 library/core/src/cmp.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/library/core/src/cmp.rs b/library/core/src/cmp.rs
index 95896ab144187..7f369d19c3d12 100644
--- a/library/core/src/cmp.rs
+++ b/library/core/src/cmp.rs
@@ -1351,7 +1351,9 @@ pub macro Ord($item:item) {
 #[rustc_diagnostic_item = "PartialOrd"]
 #[allow(multiple_supertrait_upcastable)] // FIXME(sized_hierarchy): remove this
 #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
-pub const trait PartialOrd<Rhs: PointeeSized = Self>: PartialEq<Rhs> + PointeeSized {
+pub const trait PartialOrd<Rhs: PointeeSized = Self>:
+    [const] PartialEq<Rhs> + PointeeSized
+{
     /// This method returns an ordering between `self` and `other` values if one exists.
     ///
     /// # Examples

From f90075862346c78b4c0c373e48fb8929168d277e Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Wed, 17 Sep 2025 14:47:21 -0700
Subject: [PATCH 1067/1889] std: Fix WASI implementation of `remove_dir_all`

This commit is a change to the WASI-specific implementation of the
`std::fs::remove_dir_all` function. Specifically it changes how
directory entries are read of a directory-being-deleted to specifically
buffer them all into a `Vec` before actually proceeding to delete
anything. This is necessary to fix an interaction with how the WASIp1
`fd_readdir` API works to have everything work out in the face of
mutations while reading a directory.

The basic problem is that `fd_readdir`, the WASIp1 API for reading
directories, is not a stateful read of a directory but instead a
"seekable" read of a directory. Its `cookie` argument enables seeking
anywhere within the directory at any time to read further entries.
Native host implementations do not have this ability, however, which
means that this seeking property must be achieved by re-reading the
directory. The problem with this is that WASIp1 has under-specified
semantics around what should happen if a directory is mutated between
two calls to `fd_readdir`. In essence there's not really any possible
implementation in hosts except to read the entire directory and support
seeking through the already-read list. This implementation is not
possible in the WASIp1-to-WASIp2 adapter that is primarily used to
create components for the `wasm32-wasip2` target where it has
constrained memory requirements and can't buffer up arbitrarily sized
directories.

The WASIp1 API definitions are effectively "dead" now at the standards
level meaning that `fd_readdir` won't be changing nor will a replacement
be coming. For the `wasm32-wasip2` target this will get fixed once
filesystem APIs are updated to use WASIp2 directly instead of WASIp1,
making this buffering unnecessary. In essence while this is a hack it's
sort of the least invasive thing that works everywhere for now. I don't
think this is viable to fix in hosts so guests compiled to wasm are
going to have to work around it by not relying on any guarantees about
what happens to a directory if it's mutated between reads.
---
 library/std/src/sys/fs/wasi.rs | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/library/std/src/sys/fs/wasi.rs b/library/std/src/sys/fs/wasi.rs
index b65d86de12a3d..0b65b9cb389df 100644
--- a/library/std/src/sys/fs/wasi.rs
+++ b/library/std/src/sys/fs/wasi.rs
@@ -848,7 +848,14 @@ fn remove_dir_all_recursive(parent: &WasiFd, path: &Path) -> io::Result<()> {
 
     // Iterate over all the entries in this directory, and travel recursively if
     // necessary
-    for entry in ReadDir::new(fd, dummy_root) {
+    //
+    // Note that all directory entries for this directory are read first before
+    // any removal is done. This works around the fact that the WASIp1 API for
+    // reading directories is not well-designed for handling mutations between
+    // invocations of reading a directory. By reading all the entries at once
+    // this ensures that, at least without concurrent modifications, it should
+    // be possible to delete everything.
+    for entry in ReadDir::new(fd, dummy_root).collect::<Vec<_>>() {
         let entry = entry?;
         let path = crate::str::from_utf8(&entry.name).map_err(|_| {
             io::const_error!(io::ErrorKind::Uncategorized, "invalid utf-8 file name found")

From 9ecca51bbe151c4ce0e374c46d1a0bfd1ec63d49 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 16 Sep 2025 17:08:14 -0500
Subject: [PATCH 1068/1889] Remove ImplSubject

---
 compiler/rustc_infer/src/infer/at.rs   | 19 +------------------
 compiler/rustc_middle/src/hir/mod.rs   |  9 +--------
 compiler/rustc_middle/src/ty/mod.rs    |  6 ------
 compiler/rustc_middle/src/ty/relate.rs | 24 ------------------------
 src/librustdoc/html/render/mod.rs      | 10 +++++-----
 5 files changed, 7 insertions(+), 61 deletions(-)

diff --git a/compiler/rustc_infer/src/infer/at.rs b/compiler/rustc_infer/src/infer/at.rs
index ad19cdef4e752..70e3d7dc9fef0 100644
--- a/compiler/rustc_infer/src/infer/at.rs
+++ b/compiler/rustc_infer/src/infer/at.rs
@@ -28,7 +28,7 @@
 use relate::lattice::{LatticeOp, LatticeOpKind};
 use rustc_middle::bug;
 use rustc_middle::ty::relate::solver_relating::RelateExt as NextSolverRelate;
-use rustc_middle::ty::{Const, ImplSubject, TypingMode};
+use rustc_middle::ty::{Const, TypingMode};
 
 use super::*;
 use crate::infer::relate::type_relating::TypeRelating;
@@ -304,23 +304,6 @@ impl<'a, 'tcx> At<'a, 'tcx> {
     }
 }
 
-impl<'tcx> ToTrace<'tcx> for ImplSubject<'tcx> {
-    fn to_trace(cause: &ObligationCause<'tcx>, a: Self, b: Self) -> TypeTrace<'tcx> {
-        match (a, b) {
-            (ImplSubject::Trait(trait_ref_a), ImplSubject::Trait(trait_ref_b)) => {
-                ToTrace::to_trace(cause, trait_ref_a, trait_ref_b)
-            }
-            (ImplSubject::Inherent(ty_a), ImplSubject::Inherent(ty_b)) => {
-                ToTrace::to_trace(cause, ty_a, ty_b)
-            }
-            (ImplSubject::Trait(_), ImplSubject::Inherent(_))
-            | (ImplSubject::Inherent(_), ImplSubject::Trait(_)) => {
-                bug!("can not trace TraitRef and Ty");
-            }
-        }
-    }
-}
-
 impl<'tcx> ToTrace<'tcx> for Ty<'tcx> {
     fn to_trace(cause: &ObligationCause<'tcx>, a: Self, b: Self) -> TypeTrace<'tcx> {
         TypeTrace {
diff --git a/compiler/rustc_middle/src/hir/mod.rs b/compiler/rustc_middle/src/hir/mod.rs
index 67bc89692ff79..9e3162785f4b5 100644
--- a/compiler/rustc_middle/src/hir/mod.rs
+++ b/compiler/rustc_middle/src/hir/mod.rs
@@ -18,7 +18,7 @@ use rustc_macros::{Decodable, Encodable, HashStable};
 use rustc_span::{ErrorGuaranteed, ExpnId, Span};
 
 use crate::query::Providers;
-use crate::ty::{EarlyBinder, ImplSubject, TyCtxt};
+use crate::ty::TyCtxt;
 
 /// Gather the LocalDefId for each item-like within a module, including items contained within
 /// bodies. The Ids are in visitor order. This is used to partition a pass between modules.
@@ -154,13 +154,6 @@ impl<'tcx> TyCtxt<'tcx> {
         LocalModDefId::new_unchecked(id)
     }
 
-    pub fn impl_subject(self, def_id: DefId) -> EarlyBinder<'tcx, ImplSubject<'tcx>> {
-        match self.impl_trait_ref(def_id) {
-            Some(t) => t.map_bound(ImplSubject::Trait),
-            None => self.type_of(def_id).map_bound(ImplSubject::Inherent),
-        }
-    }
-
     /// Returns `true` if this is a foreign item (i.e., linked via `extern { ... }`).
     pub fn is_foreign_item(self, def_id: impl Into<DefId>) -> bool {
         self.opt_parent(def_id.into())
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index d4c001f625e11..0ffef393a33bd 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -254,12 +254,6 @@ pub struct ImplTraitHeader<'tcx> {
     pub constness: hir::Constness,
 }
 
-#[derive(Copy, Clone, PartialEq, Eq, Debug, TypeFoldable, TypeVisitable)]
-pub enum ImplSubject<'tcx> {
-    Trait(TraitRef<'tcx>),
-    Inherent(Ty<'tcx>),
-}
-
 #[derive(Copy, Clone, PartialEq, Eq, Hash, TyEncodable, TyDecodable, HashStable, Debug)]
 #[derive(TypeFoldable, TypeVisitable)]
 pub enum Asyncness {
diff --git a/compiler/rustc_middle/src/ty/relate.rs b/compiler/rustc_middle/src/ty/relate.rs
index dc1d60f3d43c1..2f96970af4788 100644
--- a/compiler/rustc_middle/src/ty/relate.rs
+++ b/compiler/rustc_middle/src/ty/relate.rs
@@ -7,30 +7,6 @@ use crate::ty::{self as ty, Ty, TyCtxt};
 
 pub type RelateResult<'tcx, T> = rustc_type_ir::relate::RelateResult<TyCtxt<'tcx>, T>;
 
-impl<'tcx> Relate<TyCtxt<'tcx>> for ty::ImplSubject<'tcx> {
-    #[inline]
-    fn relate<R: TypeRelation<TyCtxt<'tcx>>>(
-        relation: &mut R,
-        a: ty::ImplSubject<'tcx>,
-        b: ty::ImplSubject<'tcx>,
-    ) -> RelateResult<'tcx, ty::ImplSubject<'tcx>> {
-        match (a, b) {
-            (ty::ImplSubject::Trait(trait_ref_a), ty::ImplSubject::Trait(trait_ref_b)) => {
-                let trait_ref = ty::TraitRef::relate(relation, trait_ref_a, trait_ref_b)?;
-                Ok(ty::ImplSubject::Trait(trait_ref))
-            }
-            (ty::ImplSubject::Inherent(ty_a), ty::ImplSubject::Inherent(ty_b)) => {
-                let ty = Ty::relate(relation, ty_a, ty_b)?;
-                Ok(ty::ImplSubject::Inherent(ty))
-            }
-            (ty::ImplSubject::Trait(_), ty::ImplSubject::Inherent(_))
-            | (ty::ImplSubject::Inherent(_), ty::ImplSubject::Trait(_)) => {
-                bug!("can not relate TraitRef and Ty");
-            }
-        }
-    }
-}
-
 impl<'tcx> Relate<TyCtxt<'tcx>> for Ty<'tcx> {
     #[inline]
     fn relate<R: TypeRelation<TyCtxt<'tcx>>>(
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index b4ef47d1e2694..6d684449b6d2e 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -2454,11 +2454,11 @@ fn get_id_for_impl(tcx: TyCtxt<'_>, impl_id: ItemId) -> String {
             (ty, Some(ty::TraitRef::new(tcx, trait_, [ty])))
         }
         ItemId::Blanket { impl_id, .. } | ItemId::DefId(impl_id) => {
-            match tcx.impl_subject(impl_id).skip_binder() {
-                ty::ImplSubject::Trait(trait_ref) => {
-                    (trait_ref.args[0].expect_ty(), Some(trait_ref))
-                }
-                ty::ImplSubject::Inherent(ty) => (ty, None),
+            if let Some(trait_ref) = tcx.impl_trait_ref(impl_id) {
+                let trait_ref = trait_ref.skip_binder();
+                (trait_ref.self_ty(), Some(trait_ref))
+            } else {
+                (tcx.type_of(impl_id).skip_binder(), None)
             }
         }
     };

From 26cf3eee16d982ca66da4d103513f08da82f7ca5 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 8 May 2025 02:53:00 -0400
Subject: [PATCH 1069/1889] Rework `module_inception` * Don't check for
 repetition if the previous module crosses a body boundary. * Don't take a
 snippet of the entire item. * Check each item's visibility once. * Use
 `is_from_proc_macro` before linting

---
 clippy_lints/src/item_name_repetitions.rs | 180 ++++++++++++++--------
 tests/ui/module_inception.rs              |   9 ++
 2 files changed, 121 insertions(+), 68 deletions(-)

diff --git a/clippy_lints/src/item_name_repetitions.rs b/clippy_lints/src/item_name_repetitions.rs
index 945bb84708f85..76f5fdfaa8dcf 100644
--- a/clippy_lints/src/item_name_repetitions.rs
+++ b/clippy_lints/src/item_name_repetitions.rs
@@ -1,11 +1,9 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_hir};
-use clippy_utils::is_bool;
-use clippy_utils::macros::span_is_local;
-use clippy_utils::source::is_present_in_source;
 use clippy_utils::str_utils::{camel_case_split, count_match_end, count_match_start, to_camel_case, to_snake_case};
+use clippy_utils::{is_bool, is_from_proc_macro};
 use rustc_data_structures::fx::FxHashSet;
-use rustc_hir::{EnumDef, FieldDef, Item, ItemKind, OwnerId, QPath, TyKind, Variant, VariantData};
+use rustc_hir::{Body, EnumDef, FieldDef, Item, ItemKind, QPath, TyKind, UseKind, Variant, VariantData};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::impl_lint_pass;
 use rustc_span::symbol::Symbol;
@@ -158,7 +156,8 @@ declare_clippy_lint! {
 }
 
 pub struct ItemNameRepetitions {
-    modules: Vec<(Symbol, String, OwnerId)>,
+    /// The module path the lint pass is in.
+    modules: Vec<ModInfo>,
     enum_threshold: u64,
     struct_threshold: u64,
     avoid_breaking_exported_api: bool,
@@ -167,6 +166,17 @@ pub struct ItemNameRepetitions {
     allowed_prefixes: FxHashSet<String>,
 }
 
+struct ModInfo {
+    name: Symbol,
+    name_camel: String,
+    /// Does this module have the `pub` visibility modifier.
+    is_public: bool,
+    /// How many bodies are between this module and the current lint pass position.
+    ///
+    /// Only the most recently seen module is updated when entering/exiting a body.
+    in_body_count: u32,
+}
+
 impl ItemNameRepetitions {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
@@ -458,71 +468,109 @@ fn check_enum_tuple_path_match(variant_name: &str, variant_data: VariantData<'_>
 }
 
 impl LateLintPass<'_> for ItemNameRepetitions {
-    fn check_item_post(&mut self, _cx: &LateContext<'_>, item: &Item<'_>) {
-        let Some(_ident) = item.kind.ident() else { return };
-
-        let last = self.modules.pop();
-        assert!(last.is_some());
+    fn check_item_post(&mut self, _: &LateContext<'_>, item: &Item<'_>) {
+        if matches!(item.kind, ItemKind::Mod(..)) {
+            let prev = self.modules.pop();
+            debug_assert!(prev.is_some());
+        }
     }
 
-    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
-        let Some(ident) = item.kind.ident() else { return };
-
-        let item_name = ident.name.as_str();
-        let item_camel = to_camel_case(item_name);
-        if !item.span.from_expansion() && is_present_in_source(cx, item.span)
-            && let [.., (mod_name, mod_camel, mod_owner_id)] = &*self.modules
-            // constants don't have surrounding modules
-            && !mod_camel.is_empty()
-        {
-            if mod_name == &ident.name
-                && let ItemKind::Mod(..) = item.kind
-                && (!self.allow_private_module_inception || cx.tcx.visibility(mod_owner_id.def_id).is_public())
-            {
-                span_lint(
-                    cx,
-                    MODULE_INCEPTION,
-                    item.span,
-                    "module has the same name as its containing module",
-                );
-            }
+    fn check_body(&mut self, _: &LateContext<'_>, _: &Body<'_>) {
+        if let [.., last] = &mut *self.modules {
+            last.in_body_count += 1;
+        }
+    }
 
-            // The `module_name_repetitions` lint should only trigger if the item has the module in its
-            // name. Having the same name is only accepted if `allow_exact_repetition` is set to `true`.
+    fn check_body_post(&mut self, _: &LateContext<'_>, _: &Body<'_>) {
+        if let [.., last] = &mut *self.modules {
+            last.in_body_count -= 1;
+        }
+    }
 
-            let both_are_public =
-                cx.tcx.visibility(item.owner_id).is_public() && cx.tcx.visibility(mod_owner_id.def_id).is_public();
+    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        let ident = match item.kind {
+            ItemKind::Mod(ident, _) => {
+                if let [.., prev] = &*self.modules
+                    && prev.name == ident.name
+                    && prev.in_body_count == 0
+                    && (!self.allow_private_module_inception || prev.is_public)
+                    && !item.span.from_expansion()
+                    && !is_from_proc_macro(cx, item)
+                {
+                    span_lint(
+                        cx,
+                        MODULE_INCEPTION,
+                        item.span,
+                        "module has the same name as its containing module",
+                    );
+                }
+                ident
+            },
 
-            if both_are_public && !self.allow_exact_repetitions && item_camel == *mod_camel {
-                span_lint(
-                    cx,
-                    MODULE_NAME_REPETITIONS,
-                    ident.span,
-                    "item name is the same as its containing module's name",
-                );
-            }
+            ItemKind::Enum(ident, _, def) => {
+                if !ident.span.in_external_macro(cx.tcx.sess.source_map()) {
+                    self.check_variants(cx, item, &def);
+                }
+                ident
+            },
+            ItemKind::Struct(ident, _, data) => {
+                if let VariantData::Struct { fields, .. } = data
+                    && !ident.span.in_external_macro(cx.tcx.sess.source_map())
+                {
+                    self.check_fields(cx, item, fields);
+                }
+                ident
+            },
 
-            let is_macro = matches!(item.kind, ItemKind::Macro(_, _, _));
-            if both_are_public && item_camel.len() > mod_camel.len() && !is_macro {
-                let matching = count_match_start(mod_camel, &item_camel);
-                let rmatching = count_match_end(mod_camel, &item_camel);
-                let nchars = mod_camel.chars().count();
+            ItemKind::Const(ident, ..)
+            | ItemKind::ExternCrate(_, ident)
+            | ItemKind::Fn { ident, .. }
+            | ItemKind::Macro(ident, ..)
+            | ItemKind::Static(_, ident, ..)
+            | ItemKind::Trait(_, _, _, ident, ..)
+            | ItemKind::TraitAlias(ident, ..)
+            | ItemKind::TyAlias(ident, ..)
+            | ItemKind::Union(ident, ..)
+            | ItemKind::Use(_, UseKind::Single(ident)) => ident,
+
+            ItemKind::ForeignMod { .. } | ItemKind::GlobalAsm { .. } | ItemKind::Impl(_) | ItemKind::Use(..) => return,
+        };
 
-                let is_word_beginning = |c: char| c == '_' || c.is_uppercase() || c.is_numeric();
+        let item_name = ident.name.as_str();
+        let item_camel = to_camel_case(item_name);
 
-                if matching.char_count == nchars {
-                    match item_camel.chars().nth(nchars) {
-                        Some(c) if is_word_beginning(c) => span_lint(
+        if let [.., prev] = &*self.modules
+            && prev.is_public
+            && prev.in_body_count == 0
+            && !item.span.from_expansion()
+            && !matches!(item.kind, ItemKind::Macro(..))
+            && cx.tcx.visibility(item.owner_id).is_public()
+        {
+            if !self.allow_exact_repetitions && item_camel == prev.name_camel {
+                if !is_from_proc_macro(cx, item) {
+                    span_lint(
+                        cx,
+                        MODULE_NAME_REPETITIONS,
+                        ident.span,
+                        "item name is the same as its containing module's name",
+                    );
+                }
+            } else if item_camel.len() > prev.name_camel.len() {
+                if let Some(s) = item_camel.strip_prefix(&prev.name_camel)
+                    && let Some(c) = s.chars().next()
+                    && (c == '_' || c.is_uppercase() || c.is_numeric())
+                {
+                    if !is_from_proc_macro(cx, item) {
+                        span_lint(
                             cx,
                             MODULE_NAME_REPETITIONS,
                             ident.span,
                             "item name starts with its containing module's name",
-                        ),
-                        _ => (),
+                        );
                     }
-                }
-                if rmatching.char_count == nchars
-                    && !self.is_allowed_prefix(&item_camel[..item_camel.len() - rmatching.byte_count])
+                } else if let Some(s) = item_camel.strip_suffix(&prev.name_camel)
+                    && !self.is_allowed_prefix(s)
+                    && !is_from_proc_macro(cx, item)
                 {
                     span_lint(
                         cx,
@@ -534,17 +582,13 @@ impl LateLintPass<'_> for ItemNameRepetitions {
             }
         }
 
-        if span_is_local(item.span) {
-            match item.kind {
-                ItemKind::Enum(_, _, def) => {
-                    self.check_variants(cx, item, &def);
-                },
-                ItemKind::Struct(_, _, VariantData::Struct { fields, .. }) => {
-                    self.check_fields(cx, item, fields);
-                },
-                _ => (),
-            }
+        if matches!(item.kind, ItemKind::Mod(..)) {
+            self.modules.push(ModInfo {
+                name: ident.name,
+                name_camel: item_camel,
+                is_public: cx.tcx.visibility(item.owner_id).is_public(),
+                in_body_count: 0,
+            });
         }
-        self.modules.push((ident.name, item_camel, item.owner_id));
     }
 }
diff --git a/tests/ui/module_inception.rs b/tests/ui/module_inception.rs
index 15b7fb8777700..5735dd5867d55 100644
--- a/tests/ui/module_inception.rs
+++ b/tests/ui/module_inception.rs
@@ -38,4 +38,13 @@ mod bar {
     mod bar {}
 }
 
+mod with_inner_impl {
+    struct S;
+    impl S {
+        fn f() {
+            mod with_inner_impl {}
+        }
+    }
+}
+
 fn main() {}

From b216cf34b1d4dfce1a44f99f7c58e64724439a8e Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Thu, 18 Sep 2025 00:46:27 +0000
Subject: [PATCH 1070/1889] Avoid invalidating from MirPatch::apply.

---
 compiler/rustc_mir_transform/src/patch.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/patch.rs b/compiler/rustc_mir_transform/src/patch.rs
index c781d1a5324b7..f38881baf0f29 100644
--- a/compiler/rustc_mir_transform/src/patch.rs
+++ b/compiler/rustc_mir_transform/src/patch.rs
@@ -244,7 +244,7 @@ impl<'tcx> MirPatch<'tcx> {
             self.new_blocks.len(),
             body.basic_blocks.len()
         );
-        let bbs = if self.term_patch_map.is_empty() && self.new_blocks.is_empty() {
+        let bbs = if self.term_patch_map.iter().all(Option::is_none) && self.new_blocks.is_empty() {
             body.basic_blocks.as_mut_preserves_cfg()
         } else {
             body.basic_blocks.as_mut()
@@ -273,8 +273,8 @@ impl<'tcx> MirPatch<'tcx> {
             }
             debug!("MirPatch: adding statement {:?} at loc {:?}+{}", stmt, loc, delta);
             loc.statement_index += delta;
-            let source_info = Self::source_info_for_index(&body[loc.block], loc);
-            body[loc.block]
+            let source_info = Self::source_info_for_index(&bbs[loc.block], loc);
+            bbs[loc.block]
                 .statements
                 .insert(loc.statement_index, Statement::new(source_info, stmt));
             delta += 1;

From 15ce2093d53e3274e79d55858baa82ccc9c09b02 Mon Sep 17 00:00:00 2001
From: Daniel Gulotta <dgulotta@alum.mit.edu>
Date: Wed, 17 Sep 2025 20:39:20 -0700
Subject: [PATCH 1071/1889] test cases for option_if_let_else

---
 tests/ui/option_if_let_else.fixed  | 10 ++++++
 tests/ui/option_if_let_else.rs     | 16 ++++++++++
 tests/ui/option_if_let_else.stderr | 50 ++++++++++++++++++++----------
 3 files changed, 60 insertions(+), 16 deletions(-)

diff --git a/tests/ui/option_if_let_else.fixed b/tests/ui/option_if_let_else.fixed
index 0f86de5646cdb..6ce067f5c2462 100644
--- a/tests/ui/option_if_let_else.fixed
+++ b/tests/ui/option_if_let_else.fixed
@@ -125,6 +125,16 @@ fn complex_subpat() -> DummyEnum {
     DummyEnum::Two
 }
 
+// #10335
+pub fn test_result_err_ignored_1(r: Result<&[u8], &[u8]>) -> Vec<u8> {
+    r.map_or_else(|_| Vec::new(), |s| s.to_owned())
+}
+
+// #10335
+pub fn test_result_err_ignored_2(r: Result<&[u8], &[u8]>) -> Vec<u8> {
+    r.map_or_else(|_| Vec::new(), |s| s.to_owned())
+}
+
 fn main() {
     let optional = Some(5);
     let _ = optional.map_or(5, |x| x + 2);
diff --git a/tests/ui/option_if_let_else.rs b/tests/ui/option_if_let_else.rs
index 7aabd778f87e7..096d3aabf28db 100644
--- a/tests/ui/option_if_let_else.rs
+++ b/tests/ui/option_if_let_else.rs
@@ -152,6 +152,22 @@ fn complex_subpat() -> DummyEnum {
     DummyEnum::Two
 }
 
+// #10335
+pub fn test_result_err_ignored_1(r: Result<&[u8], &[u8]>) -> Vec<u8> {
+    match r {
+        //~^ option_if_let_else
+        Ok(s) => s.to_owned(),
+        Err(_) => Vec::new(),
+    }
+}
+
+// #10335
+pub fn test_result_err_ignored_2(r: Result<&[u8], &[u8]>) -> Vec<u8> {
+    if let Ok(s) = r { s.to_owned() }
+    //~^ option_if_let_else
+    else { Vec::new() }
+}
+
 fn main() {
     let optional = Some(5);
     let _ = if let Some(x) = optional { x + 2 } else { 5 };
diff --git a/tests/ui/option_if_let_else.stderr b/tests/ui/option_if_let_else.stderr
index 2e2fe6f20492b..21a80ae038d8c 100644
--- a/tests/ui/option_if_let_else.stderr
+++ b/tests/ui/option_if_let_else.stderr
@@ -188,14 +188,32 @@ LL +         true
 LL +     })
    |
 
+error: use Option::map_or_else instead of an if let/else
+  --> tests/ui/option_if_let_else.rs:157:5
+   |
+LL | /     match r {
+LL | |
+LL | |         Ok(s) => s.to_owned(),
+LL | |         Err(_) => Vec::new(),
+LL | |     }
+   | |_____^ help: try: `r.map_or_else(|_| Vec::new(), |s| s.to_owned())`
+
+error: use Option::map_or_else instead of an if let/else
+  --> tests/ui/option_if_let_else.rs:166:5
+   |
+LL | /     if let Ok(s) = r { s.to_owned() }
+LL | |
+LL | |     else { Vec::new() }
+   | |_______________________^ help: try: `r.map_or_else(|_| Vec::new(), |s| s.to_owned())`
+
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:157:13
+  --> tests/ui/option_if_let_else.rs:173:13
    |
 LL |     let _ = if let Some(x) = optional { x + 2 } else { 5 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `optional.map_or(5, |x| x + 2)`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:168:13
+  --> tests/ui/option_if_let_else.rs:184:13
    |
 LL |       let _ = if let Some(x) = Some(0) {
    |  _____________^
@@ -217,13 +235,13 @@ LL ~         });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:197:13
+  --> tests/ui/option_if_let_else.rs:213:13
    |
 LL |     let _ = if let Some(x) = Some(0) { s.len() + x } else { s.len() };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(0).map_or(s.len(), |x| s.len() + x)`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:202:13
+  --> tests/ui/option_if_let_else.rs:218:13
    |
 LL |       let _ = if let Some(x) = Some(0) {
    |  _____________^
@@ -245,7 +263,7 @@ LL ~     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:242:13
+  --> tests/ui/option_if_let_else.rs:258:13
    |
 LL |       let _ = match s {
    |  _____________^
@@ -256,7 +274,7 @@ LL | |     };
    | |_____^ help: try: `s.map_or(1, |string| string.len())`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:247:13
+  --> tests/ui/option_if_let_else.rs:263:13
    |
 LL |       let _ = match Some(10) {
    |  _____________^
@@ -267,7 +285,7 @@ LL | |     };
    | |_____^ help: try: `Some(10).map_or(5, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:254:13
+  --> tests/ui/option_if_let_else.rs:270:13
    |
 LL |       let _ = match res {
    |  _____________^
@@ -278,7 +296,7 @@ LL | |     };
    | |_____^ help: try: `res.map_or(1, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:259:13
+  --> tests/ui/option_if_let_else.rs:275:13
    |
 LL |       let _ = match res {
    |  _____________^
@@ -289,13 +307,13 @@ LL | |     };
    | |_____^ help: try: `res.map_or(1, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:264:13
+  --> tests/ui/option_if_let_else.rs:280:13
    |
 LL |     let _ = if let Ok(a) = res { a + 1 } else { 5 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `res.map_or(5, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:282:17
+  --> tests/ui/option_if_let_else.rs:298:17
    |
 LL |           let _ = match initial {
    |  _________________^
@@ -306,7 +324,7 @@ LL | |         };
    | |_________^ help: try: `initial.as_ref().map_or(42, |value| do_something(value))`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:290:17
+  --> tests/ui/option_if_let_else.rs:306:17
    |
 LL |           let _ = match initial {
    |  _________________^
@@ -317,7 +335,7 @@ LL | |         };
    | |_________^ help: try: `initial.as_mut().map_or(42, |value| do_something2(value))`
 
 error: use Option::map_or_else instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:314:24
+  --> tests/ui/option_if_let_else.rs:330:24
    |
 LL |       let mut _hashmap = if let Some(hm) = &opt {
    |  ________________________^
@@ -329,19 +347,19 @@ LL | |     };
    | |_____^ help: try: `opt.as_ref().map_or_else(HashMap::new, |hm| hm.clone())`
 
 error: use Option::map_or_else instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:321:19
+  --> tests/ui/option_if_let_else.rs:337:19
    |
 LL |     let mut _hm = if let Some(hm) = &opt { hm.clone() } else { new_map!() };
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `opt.as_ref().map_or_else(|| new_map!(), |hm| hm.clone())`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:372:22
+  --> tests/ui/option_if_let_else.rs:388:22
    |
 LL |     let _ = unsafe { if let Some(o) = *opt_raw_ptr { o } else { 1 } };
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(*opt_raw_ptr).map_or(1, |o| o)`
 
 error: use Option::map_or_else instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:378:13
+  --> tests/ui/option_if_let_else.rs:394:13
    |
 LL |       let _ = match res {
    |  _____________^
@@ -351,5 +369,5 @@ LL | |         Err(_) => String::new(),
 LL | |     };
    | |_____^ help: try: `res.map_or_else(|_| String::new(), |s| s.clone())`
 
-error: aborting due to 27 previous errors
+error: aborting due to 29 previous errors
 

From 8b0a25486040b91ede0120ff5a797517e0973895 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 17 Sep 2025 13:46:46 +1000
Subject: [PATCH 1072/1889] Move target machine command-line quoting from C++
 to Rust

---
 .../src/back/command_line_args.rs             | 37 +++++++++++++++++++
 .../src/back/command_line_args/tests.rs       | 25 +++++++++++++
 compiler/rustc_codegen_llvm/src/back/mod.rs   |  1 +
 .../src/back/owned_target_machine.rs          | 14 +++----
 compiler/rustc_codegen_llvm/src/back/write.rs | 30 ++++++---------
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs   |  6 ++-
 .../rustc_llvm/llvm-wrapper/PassWrapper.cpp   | 28 ++++----------
 7 files changed, 92 insertions(+), 49 deletions(-)
 create mode 100644 compiler/rustc_codegen_llvm/src/back/command_line_args.rs
 create mode 100644 compiler/rustc_codegen_llvm/src/back/command_line_args/tests.rs

diff --git a/compiler/rustc_codegen_llvm/src/back/command_line_args.rs b/compiler/rustc_codegen_llvm/src/back/command_line_args.rs
new file mode 100644
index 0000000000000..b14713969b34c
--- /dev/null
+++ b/compiler/rustc_codegen_llvm/src/back/command_line_args.rs
@@ -0,0 +1,37 @@
+#[cfg(test)]
+mod tests;
+
+/// Joins command-line arguments into a single space-separated string, quoting
+/// and escaping individual arguments as necessary.
+///
+/// The result is intended to be informational, for embedding in debug metadata,
+/// and might not be properly quoted/escaped for actual command-line use.
+pub(crate) fn quote_command_line_args(args: &[String]) -> String {
+    // Start with a decent-sized buffer, since rustc invocations tend to be long.
+    let mut buf = String::with_capacity(128);
+
+    for arg in args {
+        if !buf.is_empty() {
+            buf.push(' ');
+        }
+
+        print_arg_quoted(&mut buf, arg);
+    }
+
+    buf
+}
+
+/// Equivalent to LLVM's `sys::printArg` with quoting always enabled
+/// (see llvm/lib/Support/Program.cpp).
+fn print_arg_quoted(buf: &mut String, arg: &str) {
+    buf.reserve(arg.len() + 2);
+
+    buf.push('"');
+    for ch in arg.chars() {
+        if matches!(ch, '"' | '\\' | '$') {
+            buf.push('\\');
+        }
+        buf.push(ch);
+    }
+    buf.push('"');
+}
diff --git a/compiler/rustc_codegen_llvm/src/back/command_line_args/tests.rs b/compiler/rustc_codegen_llvm/src/back/command_line_args/tests.rs
new file mode 100644
index 0000000000000..69641fed3bc92
--- /dev/null
+++ b/compiler/rustc_codegen_llvm/src/back/command_line_args/tests.rs
@@ -0,0 +1,25 @@
+#[test]
+fn quote_command_line_args() {
+    use super::quote_command_line_args;
+
+    struct Case<'a> {
+        args: &'a [&'a str],
+        expected: &'a str,
+    }
+
+    let cases = &[
+        Case { args: &[], expected: "" },
+        Case { args: &["--hello", "world"], expected: r#""--hello" "world""# },
+        Case { args: &["--hello world"], expected: r#""--hello world""# },
+        Case {
+            args: &["plain", "$dollar", "spa ce", r"back\slash", r#""quote""#, "plain"],
+            expected: r#""plain" "\$dollar" "spa ce" "back\\slash" "\"quote\"" "plain""#,
+        },
+    ];
+
+    for &Case { args, expected } in cases {
+        let args = args.iter().copied().map(str::to_owned).collect::<Vec<_>>();
+        let actual = quote_command_line_args(&args);
+        assert_eq!(actual, expected, "args {args:?}");
+    }
+}
diff --git a/compiler/rustc_codegen_llvm/src/back/mod.rs b/compiler/rustc_codegen_llvm/src/back/mod.rs
index 6cb89f80ab89a..fe3883e8c73e6 100644
--- a/compiler/rustc_codegen_llvm/src/back/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/back/mod.rs
@@ -1,4 +1,5 @@
 pub(crate) mod archive;
+mod command_line_args;
 pub(crate) mod lto;
 pub(crate) mod owned_target_machine;
 mod profiling;
diff --git a/compiler/rustc_codegen_llvm/src/back/owned_target_machine.rs b/compiler/rustc_codegen_llvm/src/back/owned_target_machine.rs
index 6d8178320febd..d5228f0e0dee1 100644
--- a/compiler/rustc_codegen_llvm/src/back/owned_target_machine.rs
+++ b/compiler/rustc_codegen_llvm/src/back/owned_target_machine.rs
@@ -1,4 +1,3 @@
-use std::assert_matches::assert_matches;
 use std::ffi::CStr;
 use std::marker::PhantomData;
 use std::ptr::NonNull;
@@ -39,13 +38,10 @@ impl OwnedTargetMachine {
         output_obj_file: &CStr,
         debug_info_compression: &CStr,
         use_emulated_tls: bool,
-        args_cstr_buff: &[u8],
+        argv0: &str,
+        command_line_args: &str,
         use_wasm_eh: bool,
     ) -> Result<Self, LlvmError<'static>> {
-        // The argument list is passed as the concatenation of one or more C strings.
-        // This implies that there must be a last byte, and it must be 0.
-        assert_matches!(args_cstr_buff, [.., b'\0'], "the last byte must be a NUL terminator");
-
         // SAFETY: llvm::LLVMRustCreateTargetMachine copies pointed to data
         let tm_ptr = unsafe {
             llvm::LLVMRustCreateTargetMachine(
@@ -70,8 +66,10 @@ impl OwnedTargetMachine {
                 output_obj_file.as_ptr(),
                 debug_info_compression.as_ptr(),
                 use_emulated_tls,
-                args_cstr_buff.as_ptr(),
-                args_cstr_buff.len(),
+                argv0.as_ptr(),
+                argv0.len(),
+                command_line_args.as_ptr(),
+                command_line_args.len(),
                 use_wasm_eh,
             )
         };
diff --git a/compiler/rustc_codegen_llvm/src/back/write.rs b/compiler/rustc_codegen_llvm/src/back/write.rs
index bda81fbd19e82..c4881f0aafc80 100644
--- a/compiler/rustc_codegen_llvm/src/back/write.rs
+++ b/compiler/rustc_codegen_llvm/src/back/write.rs
@@ -31,6 +31,7 @@ use rustc_span::{BytePos, InnerSpan, Pos, SpanData, SyntaxContext, sym};
 use rustc_target::spec::{CodeModel, FloatAbi, RelocModel, SanitizerSet, SplitDebuginfo, TlsModel};
 use tracing::{debug, trace};
 
+use crate::back::command_line_args::quote_command_line_args;
 use crate::back::lto::ThinBuffer;
 use crate::back::owned_target_machine::OwnedTargetMachine;
 use crate::back::profiling::{
@@ -249,23 +250,15 @@ pub(crate) fn target_machine_factory(
 
     let use_emulated_tls = matches!(sess.tls_model(), TlsModel::Emulated);
 
-    // copy the exe path, followed by path all into one buffer
-    // null terminating them so we can use them as null terminated strings
-    let args_cstr_buff = {
-        let mut args_cstr_buff: Vec<u8> = Vec::new();
-        let exe_path = std::env::current_exe().unwrap_or_default();
-        let exe_path_str = exe_path.into_os_string().into_string().unwrap_or_default();
-
-        args_cstr_buff.extend_from_slice(exe_path_str.as_bytes());
-        args_cstr_buff.push(0);
-
-        for arg in sess.expanded_args.iter() {
-            args_cstr_buff.extend_from_slice(arg.as_bytes());
-            args_cstr_buff.push(0);
-        }
-
-        args_cstr_buff
-    };
+    // Command-line information to be included in the target machine.
+    // This seems to only be used for embedding in PDB debuginfo files.
+    // FIXME(Zalathar): Maybe skip this for non-PDB targets?
+    let argv0 = std::env::current_exe()
+        .unwrap_or_default()
+        .into_os_string()
+        .into_string()
+        .unwrap_or_default();
+    let command_line_args = quote_command_line_args(&sess.expanded_args);
 
     let debuginfo_compression = sess.opts.debuginfo_compression.to_string();
     match sess.opts.debuginfo_compression {
@@ -323,7 +316,8 @@ pub(crate) fn target_machine_factory(
             &output_obj_file,
             &debuginfo_compression,
             use_emulated_tls,
-            &args_cstr_buff,
+            &argv0,
+            &command_line_args,
             use_wasm_eh,
         )
     })
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 71d8b7d25fe72..c1b5649a58291 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -2488,8 +2488,10 @@ unsafe extern "C" {
         OutputObjFile: *const c_char,
         DebugInfoCompression: *const c_char,
         UseEmulatedTls: bool,
-        ArgsCstrBuff: *const c_uchar, // See "PTR_LEN_STR".
-        ArgsCstrBuffLen: usize,
+        Argv0: *const c_uchar, // See "PTR_LEN_STR".
+        Argv0Len: size_t,
+        CommandLineArgs: *const c_uchar, // See "PTR_LEN_STR".
+        CommandLineArgsLen: size_t,
         UseWasmEH: bool,
     ) -> *mut TargetMachine;
 
diff --git a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
index ab5d5c03e817a..7518b40799bc1 100644
--- a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
@@ -271,8 +271,9 @@ extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
     bool TrapUnreachable, bool Singlethread, bool VerboseAsm,
     bool EmitStackSizeSection, bool RelaxELFRelocations, bool UseInitArray,
     const char *SplitDwarfFile, const char *OutputObjFile,
-    const char *DebugInfoCompression, bool UseEmulatedTls,
-    const char *ArgsCstrBuff, size_t ArgsCstrBuffLen, bool UseWasmEH) {
+    const char *DebugInfoCompression, bool UseEmulatedTls, const char *Argv0,
+    size_t Argv0Len, const char *CommandLineArgs, size_t CommandLineArgsLen,
+    bool UseWasmEH) {
 
   auto OptLevel = fromRust(RustOptLevel);
   auto RM = fromRust(RustReloc);
@@ -343,25 +344,10 @@ extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
 
   Options.EmitStackSizeSection = EmitStackSizeSection;
 
-  if (ArgsCstrBuff != nullptr) {
-    size_t buffer_offset = 0;
-    assert(ArgsCstrBuff[ArgsCstrBuffLen - 1] == '\0');
-    auto Arg0 = std::string(ArgsCstrBuff);
-    buffer_offset = Arg0.size() + 1;
-
-    std::string CommandlineArgs;
-    raw_string_ostream OS(CommandlineArgs);
-    ListSeparator LS(" ");
-    for (StringRef Arg : split(StringRef(ArgsCstrBuff + buffer_offset,
-                                         ArgsCstrBuffLen - buffer_offset),
-                               '\0')) {
-      OS << LS;
-      sys::printArg(OS, Arg, /*Quote=*/true);
-    }
-    OS.flush();
-    Options.MCOptions.Argv0 = Arg0;
-    Options.MCOptions.CommandlineArgs = CommandlineArgs;
-  }
+  if (Argv0 != nullptr)
+    Options.MCOptions.Argv0 = {Argv0, Argv0Len};
+  if (CommandLineArgs != nullptr)
+    Options.MCOptions.CommandlineArgs = {CommandLineArgs, CommandLineArgsLen};
 
 #if LLVM_VERSION_GE(21, 0)
   TargetMachine *TM = TheTarget->createTargetMachine(Trip, CPU, Feature,

From b3e056f19882e1d60a2a67ad9485546890108b44 Mon Sep 17 00:00:00 2001
From: Zihan <zihanli0822@gmail.com>
Date: Mon, 11 Aug 2025 11:06:28 -0400
Subject: [PATCH 1073/1889] `module_style`: refactor and don't lint mod tagged
 with path attr

refactored with `check_item` and `check_item_post`. this refactoring
also fixed a few bugs related to mod path with shared segment name caused
by preivous approach.

changelog: [`self_named_module_files`]: don't lint mod tagged with path attribute
changelog: [`mod_module_files`]: don't lint mod tagged with path attribute

Signed-off-by: Zihan <zihanli0822@gmail.com>
---
 clippy_lints/src/lib.rs                       |   2 +-
 clippy_lints/src/module_style.rs              | 155 +++++++++---------
 .../duplicated_mod_names_14697/Cargo.stderr   |  11 ++
 .../duplicated_mod_names_14697/Cargo.toml     |  11 ++
 .../duplicated_mod_names_14697/src/foo.rs     |   1 +
 .../duplicated_mod_names_14697/src/foo/bar.rs |   1 +
 .../duplicated_mod_names_14697/src/lib.rs     |   4 +
 .../src/other/foo/mod.rs                      |   1 +
 .../src/other/mod.rs                          |   1 +
 .../module_style/fail_mod/Cargo.stderr        |  16 +-
 .../Cargo.toml                                |  10 ++
 .../foo/bar/Cargo.toml                        |   5 +
 .../foo/bar/src/foo.rs                        |   1 +
 .../foo/bar/src/lib.rs                        |   1 +
 .../src/lib.rs                                |   1 +
 .../with_path_attr_mod/Cargo.toml             |  10 ++
 .../with_path_attr_mod/src/bar/mod.rs         |   1 +
 .../with_path_attr_mod/src/lib.rs             |   4 +
 .../with_path_attr_no_mod/Cargo.toml          |  10 ++
 .../with_path_attr_no_mod/src/bar.rs          |   1 +
 .../with_path_attr_no_mod/src/foo.rs          |   2 +
 .../with_path_attr_no_mod/src/lib.rs          |   3 +
 22 files changed, 167 insertions(+), 85 deletions(-)
 create mode 100644 tests/ui-cargo/module_style/duplicated_mod_names_14697/Cargo.stderr
 create mode 100644 tests/ui-cargo/module_style/duplicated_mod_names_14697/Cargo.toml
 create mode 100644 tests/ui-cargo/module_style/duplicated_mod_names_14697/src/foo.rs
 create mode 100644 tests/ui-cargo/module_style/duplicated_mod_names_14697/src/foo/bar.rs
 create mode 100644 tests/ui-cargo/module_style/duplicated_mod_names_14697/src/lib.rs
 create mode 100644 tests/ui-cargo/module_style/duplicated_mod_names_14697/src/other/foo/mod.rs
 create mode 100644 tests/ui-cargo/module_style/duplicated_mod_names_14697/src/other/mod.rs
 create mode 100644 tests/ui-cargo/module_style/segment_with_mod_name_10271_11916/Cargo.toml
 create mode 100644 tests/ui-cargo/module_style/segment_with_mod_name_10271_11916/foo/bar/Cargo.toml
 create mode 100644 tests/ui-cargo/module_style/segment_with_mod_name_10271_11916/foo/bar/src/foo.rs
 create mode 100644 tests/ui-cargo/module_style/segment_with_mod_name_10271_11916/foo/bar/src/lib.rs
 create mode 100644 tests/ui-cargo/module_style/segment_with_mod_name_10271_11916/src/lib.rs
 create mode 100644 tests/ui-cargo/module_style/with_path_attr_mod/Cargo.toml
 create mode 100644 tests/ui-cargo/module_style/with_path_attr_mod/src/bar/mod.rs
 create mode 100644 tests/ui-cargo/module_style/with_path_attr_mod/src/lib.rs
 create mode 100644 tests/ui-cargo/module_style/with_path_attr_no_mod/Cargo.toml
 create mode 100644 tests/ui-cargo/module_style/with_path_attr_no_mod/src/bar.rs
 create mode 100644 tests/ui-cargo/module_style/with_path_attr_no_mod/src/foo.rs
 create mode 100644 tests/ui-cargo/module_style/with_path_attr_no_mod/src/lib.rs

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c56fa257b0689..2b8f09d33405c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -671,7 +671,7 @@ pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Co
     store.register_late_pass(|_| Box::new(from_str_radix_10::FromStrRadix10));
     store.register_late_pass(move |_| Box::new(if_then_some_else_none::IfThenSomeElseNone::new(conf)));
     store.register_late_pass(|_| Box::new(bool_assert_comparison::BoolAssertComparison));
-    store.register_early_pass(move || Box::new(module_style::ModStyle));
+    store.register_early_pass(move || Box::new(module_style::ModStyle::default()));
     store.register_late_pass(|_| Box::<unused_async::UnusedAsync>::default());
     store.register_late_pass(move |tcx| Box::new(disallowed_types::DisallowedTypes::new(tcx, conf)));
     store.register_late_pass(move |tcx| Box::new(missing_enforced_import_rename::ImportRename::new(tcx, conf)));
diff --git a/clippy_lints/src/module_style.rs b/clippy_lints/src/module_style.rs
index 98614baffcea6..f132b90ac4f2e 100644
--- a/clippy_lints/src/module_style.rs
+++ b/clippy_lints/src/module_style.rs
@@ -1,12 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use rustc_ast::ast;
-use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexSet};
+use rustc_ast::ast::{self, Inline, ItemKind, ModKind};
 use rustc_lint::{EarlyContext, EarlyLintPass, Level, LintContext};
 use rustc_session::impl_lint_pass;
 use rustc_span::def_id::LOCAL_CRATE;
-use rustc_span::{FileName, SourceFile, Span, SyntaxContext};
-use std::ffi::OsStr;
-use std::path::{Component, Path};
+use rustc_span::{FileName, SourceFile, Span, SyntaxContext, sym};
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -60,107 +59,97 @@ declare_clippy_lint! {
     ///     mod.rs
     ///   lib.rs
     /// ```
-
     #[clippy::version = "1.57.0"]
     pub SELF_NAMED_MODULE_FILES,
     restriction,
     "checks that module layout is consistent"
 }
 
-pub struct ModStyle;
-
 impl_lint_pass!(ModStyle => [MOD_MODULE_FILES, SELF_NAMED_MODULE_FILES]);
 
+pub struct ModState {
+    contains_external: bool,
+    has_path_attr: bool,
+    mod_file: Arc<SourceFile>,
+}
+
+#[derive(Default)]
+pub struct ModStyle {
+    working_dir: Option<PathBuf>,
+    module_stack: Vec<ModState>,
+}
+
 impl EarlyLintPass for ModStyle {
     fn check_crate(&mut self, cx: &EarlyContext<'_>, _: &ast::Crate) {
+        self.working_dir = cx.sess().opts.working_dir.local_path().map(Path::to_path_buf);
+    }
+
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &ast::Item) {
         if cx.builder.lint_level(MOD_MODULE_FILES).level == Level::Allow
             && cx.builder.lint_level(SELF_NAMED_MODULE_FILES).level == Level::Allow
         {
             return;
         }
+        if let ItemKind::Mod(.., ModKind::Loaded(_, Inline::No { .. }, mod_spans, ..)) = &item.kind {
+            let has_path_attr = item.attrs.iter().any(|attr| attr.has_name(sym::path));
+            if !has_path_attr && let Some(current) = self.module_stack.last_mut() {
+                current.contains_external = true;
+            }
+            let mod_file = cx.sess().source_map().lookup_source_file(mod_spans.inner_span.lo());
+            self.module_stack.push(ModState {
+                contains_external: false,
+                has_path_attr,
+                mod_file,
+            });
+        }
+    }
 
-        let files = cx.sess().source_map().files();
-
-        let Some(trim_to_src) = cx.sess().opts.working_dir.local_path() else {
+    fn check_item_post(&mut self, cx: &EarlyContext<'_>, item: &ast::Item) {
+        if cx.builder.lint_level(MOD_MODULE_FILES).level == Level::Allow
+            && cx.builder.lint_level(SELF_NAMED_MODULE_FILES).level == Level::Allow
+        {
             return;
-        };
-
-        // `folder_segments` is all unique folder path segments `path/to/foo.rs` gives
-        // `[path, to]` but not foo
-        let mut folder_segments = FxIndexSet::default();
-        // `mod_folders` is all the unique folder names that contain a mod.rs file
-        let mut mod_folders = FxHashSet::default();
-        // `file_map` maps file names to the full path including the file name
-        // `{ foo => path/to/foo.rs, .. }
-        let mut file_map = FxHashMap::default();
-        for file in files.iter() {
-            if let FileName::Real(name) = &file.name
-                && let Some(lp) = name.local_path()
-                && file.cnum == LOCAL_CRATE
-            {
-                // [#8887](https://github.com/rust-lang/rust-clippy/issues/8887)
-                // Only check files in the current crate.
-                // Fix false positive that crate dependency in workspace sub directory
-                // is checked unintentionally.
-                let path = if lp.is_relative() {
-                    lp
-                } else if let Ok(relative) = lp.strip_prefix(trim_to_src) {
-                    relative
-                } else {
-                    continue;
-                };
-
-                if let Some(stem) = path.file_stem() {
-                    file_map.insert(stem, (file, path));
-                }
-                process_paths_for_mod_files(path, &mut folder_segments, &mut mod_folders);
-                check_self_named_mod_exists(cx, path, file);
-            }
         }
 
-        for folder in &folder_segments {
-            if !mod_folders.contains(folder)
-                && let Some((file, path)) = file_map.get(folder)
-            {
-                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()),
-                    |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(),));
-                    },
-                );
+        if let ItemKind::Mod(.., ModKind::Loaded(_, Inline::No { .. }, ..)) = &item.kind
+            && let Some(current) = self.module_stack.pop()
+            && !current.has_path_attr
+        {
+            let Some(path) = self
+                .working_dir
+                .as_ref()
+                .and_then(|src| try_trim_file_path_prefix(&current.mod_file, src))
+            else {
+                return;
+            };
+            if current.contains_external {
+                check_self_named_module(cx, path, &current.mod_file);
             }
+            check_mod_module(cx, path, &current.mod_file);
         }
     }
 }
 
-/// For each `path` we add each folder component to `folder_segments` and if the file name
-/// is `mod.rs` we add it's parent folder to `mod_folders`.
-fn process_paths_for_mod_files<'a>(
-    path: &'a Path,
-    folder_segments: &mut FxIndexSet<&'a OsStr>,
-    mod_folders: &mut FxHashSet<&'a OsStr>,
-) {
-    let mut comp = path.components().rev().peekable();
-    let _: Option<_> = comp.next();
-    if path.ends_with("mod.rs") {
-        mod_folders.insert(comp.peek().map(|c| c.as_os_str()).unwrap_or_default());
+fn check_self_named_module(cx: &EarlyContext<'_>, path: &Path, file: &SourceFile) {
+    if !path.ends_with("mod.rs") {
+        let mut mod_folder = path.with_extension("");
+        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()),
+            |diag| {
+                mod_folder.push("mod.rs");
+                diag.help(format!("move `{}` to `{}`", path.display(), mod_folder.display()));
+            },
+        );
     }
-    let folders = comp.filter_map(|c| if let Component::Normal(s) = c { Some(s) } else { None });
-    folder_segments.extend(folders);
 }
 
-/// Checks every path for the presence of `mod.rs` files and emits the lint if found.
 /// We should not emit a lint for test modules in the presence of `mod.rs`.
 /// Using `mod.rs` in integration tests is a [common pattern](https://doc.rust-lang.org/book/ch11-03-test-organization.html#submodules-in-integration-test)
 /// for code-sharing between tests.
-fn check_self_named_mod_exists(cx: &EarlyContext<'_>, path: &Path, file: &SourceFile) {
+fn check_mod_module(cx: &EarlyContext<'_>, path: &Path, file: &SourceFile) {
     if path.ends_with("mod.rs") && !path.starts_with("tests") {
         span_lint_and_then(
             cx,
@@ -177,3 +166,17 @@ fn check_self_named_mod_exists(cx: &EarlyContext<'_>, path: &Path, file: &Source
         );
     }
 }
+
+fn try_trim_file_path_prefix<'a>(file: &'a SourceFile, prefix: &'a Path) -> Option<&'a Path> {
+    if let FileName::Real(name) = &file.name
+        && let Some(mut path) = name.local_path()
+        && file.cnum == LOCAL_CRATE
+    {
+        if !path.is_relative() {
+            path = path.strip_prefix(prefix).ok()?;
+        }
+        Some(path)
+    } else {
+        None
+    }
+}
diff --git a/tests/ui-cargo/module_style/duplicated_mod_names_14697/Cargo.stderr b/tests/ui-cargo/module_style/duplicated_mod_names_14697/Cargo.stderr
new file mode 100644
index 0000000000000..c7490c5da027b
--- /dev/null
+++ b/tests/ui-cargo/module_style/duplicated_mod_names_14697/Cargo.stderr
@@ -0,0 +1,11 @@
+error: `mod.rs` files are required, found `src/foo.rs`
+ --> src/foo.rs:1:1
+  |
+1 | pub mod bar;
+  | ^
+  |
+  = help: move `src/foo.rs` to `src/foo/mod.rs`
+  = note: `-D clippy::self-named-module-files` implied by `-D warnings`
+  = help: to override `-D warnings` add `#[allow(clippy::self_named_module_files)]`
+
+error: could not compile `duplicated-mod-names-14697` (lib) due to 1 previous error
diff --git a/tests/ui-cargo/module_style/duplicated_mod_names_14697/Cargo.toml b/tests/ui-cargo/module_style/duplicated_mod_names_14697/Cargo.toml
new file mode 100644
index 0000000000000..569082f2f6599
--- /dev/null
+++ b/tests/ui-cargo/module_style/duplicated_mod_names_14697/Cargo.toml
@@ -0,0 +1,11 @@
+# Should trigger when multiple mods with the same name exist and not all of them follow self-named convention.
+# See issue #14697.
+[package]
+name = "duplicated-mod-names-14697"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
diff --git a/tests/ui-cargo/module_style/duplicated_mod_names_14697/src/foo.rs b/tests/ui-cargo/module_style/duplicated_mod_names_14697/src/foo.rs
new file mode 100644
index 0000000000000..46f285ca47d69
--- /dev/null
+++ b/tests/ui-cargo/module_style/duplicated_mod_names_14697/src/foo.rs
@@ -0,0 +1 @@
+pub mod bar;
diff --git a/tests/ui-cargo/module_style/duplicated_mod_names_14697/src/foo/bar.rs b/tests/ui-cargo/module_style/duplicated_mod_names_14697/src/foo/bar.rs
new file mode 100644
index 0000000000000..8b137891791fe
--- /dev/null
+++ b/tests/ui-cargo/module_style/duplicated_mod_names_14697/src/foo/bar.rs
@@ -0,0 +1 @@
+
diff --git a/tests/ui-cargo/module_style/duplicated_mod_names_14697/src/lib.rs b/tests/ui-cargo/module_style/duplicated_mod_names_14697/src/lib.rs
new file mode 100644
index 0000000000000..a85dae5748165
--- /dev/null
+++ b/tests/ui-cargo/module_style/duplicated_mod_names_14697/src/lib.rs
@@ -0,0 +1,4 @@
+#![warn(clippy::self_named_module_files)]
+
+pub mod foo;
+pub mod other;
diff --git a/tests/ui-cargo/module_style/duplicated_mod_names_14697/src/other/foo/mod.rs b/tests/ui-cargo/module_style/duplicated_mod_names_14697/src/other/foo/mod.rs
new file mode 100644
index 0000000000000..8b137891791fe
--- /dev/null
+++ b/tests/ui-cargo/module_style/duplicated_mod_names_14697/src/other/foo/mod.rs
@@ -0,0 +1 @@
+
diff --git a/tests/ui-cargo/module_style/duplicated_mod_names_14697/src/other/mod.rs b/tests/ui-cargo/module_style/duplicated_mod_names_14697/src/other/mod.rs
new file mode 100644
index 0000000000000..b52703b257400
--- /dev/null
+++ b/tests/ui-cargo/module_style/duplicated_mod_names_14697/src/other/mod.rs
@@ -0,0 +1 @@
+pub mod foo;
diff --git a/tests/ui-cargo/module_style/fail_mod/Cargo.stderr b/tests/ui-cargo/module_style/fail_mod/Cargo.stderr
index 902330e178530..f134943e69bfc 100644
--- a/tests/ui-cargo/module_style/fail_mod/Cargo.stderr
+++ b/tests/ui-cargo/module_style/fail_mod/Cargo.stderr
@@ -1,19 +1,19 @@
-error: `mod.rs` files are required, found `src/bad/inner.rs`
- --> src/bad/inner.rs:1:1
+error: `mod.rs` files are required, found `src/bad/inner/stuff.rs`
+ --> src/bad/inner/stuff.rs:1:1
   |
-1 | pub mod stuff;
+1 | pub mod most;
   | ^
   |
-  = help: move `src/bad/inner.rs` to `src/bad/inner/mod.rs`
+  = help: move `src/bad/inner/stuff.rs` to `src/bad/inner/stuff/mod.rs`
   = note: `-D clippy::self-named-module-files` implied by `-D warnings`
   = help: to override `-D warnings` add `#[allow(clippy::self_named_module_files)]`
 
-error: `mod.rs` files are required, found `src/bad/inner/stuff.rs`
- --> src/bad/inner/stuff.rs:1:1
+error: `mod.rs` files are required, found `src/bad/inner.rs`
+ --> src/bad/inner.rs:1:1
   |
-1 | pub mod most;
+1 | pub mod stuff;
   | ^
   |
-  = help: move `src/bad/inner/stuff.rs` to `src/bad/inner/stuff/mod.rs`
+  = help: move `src/bad/inner.rs` to `src/bad/inner/mod.rs`
 
 error: could not compile `fail-mod` (bin "fail-mod") due to 2 previous errors
diff --git a/tests/ui-cargo/module_style/segment_with_mod_name_10271_11916/Cargo.toml b/tests/ui-cargo/module_style/segment_with_mod_name_10271_11916/Cargo.toml
new file mode 100644
index 0000000000000..5c2fabd2283d3
--- /dev/null
+++ b/tests/ui-cargo/module_style/segment_with_mod_name_10271_11916/Cargo.toml
@@ -0,0 +1,10 @@
+# Should not produce FP when irrelavant path segment shares the same name with module.
+# See issue #10271 and #11916.
+[package]
+name = "segment-with-mod-name-10271-11916"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[workspace]
+members = ["foo/bar"]
\ No newline at end of file
diff --git a/tests/ui-cargo/module_style/segment_with_mod_name_10271_11916/foo/bar/Cargo.toml b/tests/ui-cargo/module_style/segment_with_mod_name_10271_11916/foo/bar/Cargo.toml
new file mode 100644
index 0000000000000..1f68c0dccac54
--- /dev/null
+++ b/tests/ui-cargo/module_style/segment_with_mod_name_10271_11916/foo/bar/Cargo.toml
@@ -0,0 +1,5 @@
+[package]
+name = "bar"
+version = "0.1.0"
+edition = "2024"
+publish = false
diff --git a/tests/ui-cargo/module_style/segment_with_mod_name_10271_11916/foo/bar/src/foo.rs b/tests/ui-cargo/module_style/segment_with_mod_name_10271_11916/foo/bar/src/foo.rs
new file mode 100644
index 0000000000000..8b137891791fe
--- /dev/null
+++ b/tests/ui-cargo/module_style/segment_with_mod_name_10271_11916/foo/bar/src/foo.rs
@@ -0,0 +1 @@
+
diff --git a/tests/ui-cargo/module_style/segment_with_mod_name_10271_11916/foo/bar/src/lib.rs b/tests/ui-cargo/module_style/segment_with_mod_name_10271_11916/foo/bar/src/lib.rs
new file mode 100644
index 0000000000000..b52703b257400
--- /dev/null
+++ b/tests/ui-cargo/module_style/segment_with_mod_name_10271_11916/foo/bar/src/lib.rs
@@ -0,0 +1 @@
+pub mod foo;
diff --git a/tests/ui-cargo/module_style/segment_with_mod_name_10271_11916/src/lib.rs b/tests/ui-cargo/module_style/segment_with_mod_name_10271_11916/src/lib.rs
new file mode 100644
index 0000000000000..8b137891791fe
--- /dev/null
+++ b/tests/ui-cargo/module_style/segment_with_mod_name_10271_11916/src/lib.rs
@@ -0,0 +1 @@
+
diff --git a/tests/ui-cargo/module_style/with_path_attr_mod/Cargo.toml b/tests/ui-cargo/module_style/with_path_attr_mod/Cargo.toml
new file mode 100644
index 0000000000000..d867377545e15
--- /dev/null
+++ b/tests/ui-cargo/module_style/with_path_attr_mod/Cargo.toml
@@ -0,0 +1,10 @@
+# Should not lint mod tagged with `#[path = ...]` 
+[package]
+name = "with-path-attr-mod"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
diff --git a/tests/ui-cargo/module_style/with_path_attr_mod/src/bar/mod.rs b/tests/ui-cargo/module_style/with_path_attr_mod/src/bar/mod.rs
new file mode 100644
index 0000000000000..8b137891791fe
--- /dev/null
+++ b/tests/ui-cargo/module_style/with_path_attr_mod/src/bar/mod.rs
@@ -0,0 +1 @@
+
diff --git a/tests/ui-cargo/module_style/with_path_attr_mod/src/lib.rs b/tests/ui-cargo/module_style/with_path_attr_mod/src/lib.rs
new file mode 100644
index 0000000000000..a5c2109ece7db
--- /dev/null
+++ b/tests/ui-cargo/module_style/with_path_attr_mod/src/lib.rs
@@ -0,0 +1,4 @@
+#![warn(clippy::mod_module_files)]
+
+#[path = "bar/mod.rs"]
+pub mod foo;
diff --git a/tests/ui-cargo/module_style/with_path_attr_no_mod/Cargo.toml b/tests/ui-cargo/module_style/with_path_attr_no_mod/Cargo.toml
new file mode 100644
index 0000000000000..ddf2ac394cddc
--- /dev/null
+++ b/tests/ui-cargo/module_style/with_path_attr_no_mod/Cargo.toml
@@ -0,0 +1,10 @@
+# Should not lint mod tagged with `#[path = ...]` 
+[package]
+name = "with-path-attr-no-mod"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
diff --git a/tests/ui-cargo/module_style/with_path_attr_no_mod/src/bar.rs b/tests/ui-cargo/module_style/with_path_attr_no_mod/src/bar.rs
new file mode 100644
index 0000000000000..8b137891791fe
--- /dev/null
+++ b/tests/ui-cargo/module_style/with_path_attr_no_mod/src/bar.rs
@@ -0,0 +1 @@
+
diff --git a/tests/ui-cargo/module_style/with_path_attr_no_mod/src/foo.rs b/tests/ui-cargo/module_style/with_path_attr_no_mod/src/foo.rs
new file mode 100644
index 0000000000000..3b12aefa3d5fe
--- /dev/null
+++ b/tests/ui-cargo/module_style/with_path_attr_no_mod/src/foo.rs
@@ -0,0 +1,2 @@
+#[path = "bar.rs"]
+mod bar;
diff --git a/tests/ui-cargo/module_style/with_path_attr_no_mod/src/lib.rs b/tests/ui-cargo/module_style/with_path_attr_no_mod/src/lib.rs
new file mode 100644
index 0000000000000..bf2a5d0193350
--- /dev/null
+++ b/tests/ui-cargo/module_style/with_path_attr_no_mod/src/lib.rs
@@ -0,0 +1,3 @@
+#![warn(clippy::self_named_module_files)]
+
+pub mod foo;

From 6e74905be29b861bcfd2780a8c81495deffec6c3 Mon Sep 17 00:00:00 2001
From: Haidong Zhang <zhanghaidong@uniontech.com>
Date: Wed, 3 Sep 2025 17:40:45 +0800
Subject: [PATCH 1074/1889] Set lto="fat" automatically  when compiling with
 RUSTFLAGS="-Zautodiff=Enable".

---
 compiler/rustc_codegen_ssa/messages.ftl  | 2 --
 compiler/rustc_codegen_ssa/src/errors.rs | 4 ----
 compiler/rustc_session/src/config.rs     | 5 +++++
 compiler/rustc_session/src/session.rs    | 7 +++++++
 4 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/messages.ftl b/compiler/rustc_codegen_ssa/messages.ftl
index 1dd65d38a2be7..91c3806df4c34 100644
--- a/compiler/rustc_codegen_ssa/messages.ftl
+++ b/compiler/rustc_codegen_ssa/messages.ftl
@@ -8,8 +8,6 @@ codegen_ssa_aix_strip_not_used = using host's `strip` binary to cross-compile to
 
 codegen_ssa_archive_build_failure = failed to build archive at `{$path}`: {$error}
 
-codegen_ssa_autodiff_without_lto = using the autodiff feature requires using fat-lto
-
 codegen_ssa_bare_instruction_set = `#[instruction_set]` requires an argument
 
 codegen_ssa_binary_output_to_tty = option `-o` or `--emit` is used to write binary output type `{$shorthand}` to stdout, but stdout is a tty
diff --git a/compiler/rustc_codegen_ssa/src/errors.rs b/compiler/rustc_codegen_ssa/src/errors.rs
index fb5a82051405d..d5c30c5c7a6b0 100644
--- a/compiler/rustc_codegen_ssa/src/errors.rs
+++ b/compiler/rustc_codegen_ssa/src/errors.rs
@@ -37,10 +37,6 @@ pub(crate) struct CguNotRecorded<'a> {
     pub cgu_name: &'a str,
 }
 
-#[derive(Diagnostic)]
-#[diag(codegen_ssa_autodiff_without_lto)]
-pub struct AutodiffWithoutLto;
-
 #[derive(Diagnostic)]
 #[diag(codegen_ssa_unknown_reuse_kind)]
 pub(crate) struct UnknownReuseKind {
diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs
index 297df7c2c9765..795cb2b2cfeba 100644
--- a/compiler/rustc_session/src/config.rs
+++ b/compiler/rustc_session/src/config.rs
@@ -1509,6 +1509,11 @@ impl Options {
     pub fn get_symbol_mangling_version(&self) -> SymbolManglingVersion {
         self.cg.symbol_mangling_version.unwrap_or(SymbolManglingVersion::Legacy)
     }
+
+    #[inline]
+    pub fn autodiff_enabled(&self) -> bool {
+        self.unstable_opts.autodiff.contains(&AutoDiff::Enable)
+    }
 }
 
 impl UnstableOptions {
diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
index 3525c7c1d1a99..d0dd2cdac0c48 100644
--- a/compiler/rustc_session/src/session.rs
+++ b/compiler/rustc_session/src/session.rs
@@ -600,6 +600,13 @@ impl Session {
 
     /// Calculates the flavor of LTO to use for this compilation.
     pub fn lto(&self) -> config::Lto {
+        // Autodiff currently requires fat-lto to have access to the llvm-ir of all (indirectly) used functions and types.
+        // fat-lto is the easiest solution to this requirement, but quite expensive.
+        // FIXME(autodiff): Make autodiff also work with embed-bc instead of fat-lto.
+        if self.opts.autodiff_enabled() {
+            return config::Lto::Fat;
+        }
+
         // If our target has codegen requirements ignore the command line
         if self.target.requires_lto {
             return config::Lto::Fat;

From 2c1f1f0e9bb706d9adbb71e0bc33923c4478eb85 Mon Sep 17 00:00:00 2001
From: Patrick-6 <pamu99@gmx.ch>
Date: Mon, 8 Sep 2025 10:17:14 +0200
Subject: [PATCH 1075/1889] Add GenMC estimation mode. Improve error handling
 and output printing.

---
 src/tools/miri/doc/genmc.md                   |   3 +
 .../genmc-sys/cpp/include/MiriInterface.hpp   |   8 +-
 .../cpp/src/MiriInterface/Exploration.cpp     |  14 ++
 .../genmc-sys/cpp/src/MiriInterface/Setup.cpp |  23 ++-
 src/tools/miri/genmc-sys/src/lib.rs           |  55 +++++-
 src/tools/miri/src/bin/miri.rs                |   9 +-
 .../miri/src/concurrency/genmc/config.rs      |  17 ++
 src/tools/miri/src/concurrency/genmc/dummy.rs |  12 --
 src/tools/miri/src/concurrency/genmc/mod.rs   |  61 ++++---
 src/tools/miri/src/concurrency/genmc/run.rs   | 156 ++++++++++++++----
 .../genmc/fail/data_race/mpu2_rels_rlx.stderr |   2 +
 .../data_race/weak_orderings.rel_rlx.stderr   |   2 +
 .../data_race/weak_orderings.rlx_acq.stderr   |   2 +
 .../data_race/weak_orderings.rlx_rlx.stderr   |   2 +
 .../tests/genmc/fail/loom/buggy_inc.stderr    |   2 +
 .../fail/loom/store_buffering.genmc.stderr    |   2 +
 .../fail/simple/2w2w_weak.relaxed4.stderr     |   2 +
 .../fail/simple/2w2w_weak.release4.stderr     |   2 +
 .../fail/simple/2w2w_weak.sc3_rel1.stderr     |   2 +
 .../cas_failure_ord_racy_key_init.stderr      |   4 +-
 .../genmc/pass/atomics/cas_simple.stderr      |   4 +-
 .../tests/genmc/pass/atomics/rmw_ops.stderr   |   4 +-
 .../miri/tests/genmc/pass/litmus/2cowr.stderr |   4 +-
 .../genmc/pass/litmus/2w2w_2sc_scf.stderr     |   4 +-
 .../pass/litmus/2w2w_3sc_1rel.release1.stderr |   4 +-
 .../pass/litmus/2w2w_3sc_1rel.release2.stderr |   4 +-
 .../genmc/pass/litmus/2w2w_4rel.sc.stderr     |   4 +-
 .../genmc/pass/litmus/2w2w_4rel.weak.stderr   |   4 +-
 .../tests/genmc/pass/litmus/2w2w_4sc.stderr   |   4 +-
 .../genmc/pass/litmus/IRIW-acq-sc.stderr      |   4 +-
 .../tests/genmc/pass/litmus/IRIWish.stderr    |   4 +-
 .../miri/tests/genmc/pass/litmus/LB.stderr    |   4 +-
 .../tests/genmc/pass/litmus/LB_incMPs.stderr  |   4 +-
 .../miri/tests/genmc/pass/litmus/MP.stderr    |   4 +-
 .../genmc/pass/litmus/MPU2_rels_acqf.stderr   |   4 +-
 .../genmc/pass/litmus/MPU_rels_acq.stderr     |   4 +-
 .../tests/genmc/pass/litmus/MP_incMPs.stderr  |   4 +-
 .../genmc/pass/litmus/MP_rels_acqf.stderr     |   4 +-
 .../miri/tests/genmc/pass/litmus/SB.stderr    |   4 +-
 .../tests/genmc/pass/litmus/SB_2sc_scf.stderr |   4 +-
 .../tests/genmc/pass/litmus/Z6_U.sc.stderr    |   4 +-
 .../tests/genmc/pass/litmus/Z6_U.weak.stderr  |   4 +-
 .../tests/genmc/pass/litmus/Z6_acq.stderr     |   4 +-
 .../tests/genmc/pass/litmus/atomicpo.stderr   |   4 +-
 .../tests/genmc/pass/litmus/casdep.stderr     |   4 +-
 .../miri/tests/genmc/pass/litmus/ccr.stderr   |   4 +-
 .../miri/tests/genmc/pass/litmus/cii.stderr   |   4 +-
 .../miri/tests/genmc/pass/litmus/corr.stderr  |   4 +-
 .../miri/tests/genmc/pass/litmus/corr0.stderr |   4 +-
 .../miri/tests/genmc/pass/litmus/corr1.stderr |   4 +-
 .../miri/tests/genmc/pass/litmus/corr2.stderr |   4 +-
 .../miri/tests/genmc/pass/litmus/corw.stderr  |   4 +-
 .../miri/tests/genmc/pass/litmus/cowr.stderr  |   4 +-
 .../genmc/pass/litmus/cumul-release.stderr    |   4 +-
 .../tests/genmc/pass/litmus/default.stderr    |   4 +-
 .../genmc/pass/litmus/detour.join.stderr      |   4 +-
 .../genmc/pass/litmus/detour.no_join.stderr   |   4 +-
 .../genmc/pass/litmus/fr_w_w_w_reads.stderr   |   4 +-
 .../miri/tests/genmc/pass/litmus/inc2w.stderr |   4 +-
 .../genmc/pass/litmus/inc_inc_RR_W_RR.stderr  |   4 +-
 .../miri/tests/genmc/pass/litmus/riwi.stderr  |   4 +-
 .../tests/genmc/pass/litmus/viktor-relseq.rs  |   4 +-
 .../genmc/pass/litmus/viktor-relseq.stderr    |   6 +-
 src/tools/miri/tests/ui.rs                    |   2 +
 64 files changed, 386 insertions(+), 170 deletions(-)

diff --git a/src/tools/miri/doc/genmc.md b/src/tools/miri/doc/genmc.md
index 8af697be34a61..44e11dcbec44c 100644
--- a/src/tools/miri/doc/genmc.md
+++ b/src/tools/miri/doc/genmc.md
@@ -24,6 +24,8 @@ Note that `cargo miri test` in GenMC mode is currently not supported.
 ### Supported Parameters
 
 - `-Zmiri-genmc`: Enable GenMC mode (not required if any other GenMC options are used).
+- `-Zmiri-genmc-estimate`: This enables estimation of the concurrent execution space and verification time, before running the full verification. This should help users detect when their program is too complex to fully verify in a reasonable time. This will explore enough executions to make a good estimation, but at least 10 and at most `estimation-max` executions.
+- `-Zmiri-genmc-estimation-max={MAX_ITERATIONS}`: Set the maximum number of executions that will be explored during estimation (default: 1000).
 - `-Zmiri-genmc-print-exec-graphs={none,explored,blocked,all}`: Make GenMC print the execution graph of the program after every explored, every blocked, or after every execution (default: None).
 - `-Zmiri-genmc-print-exec-graphs`: Shorthand for suffix `=explored`.
 - `-Zmiri-genmc-print-genmc-output`: Print the output that GenMC provides. NOTE: this output is quite verbose and the events in the printed execution graph are hard to map back to the Rust code location they originate from.
@@ -36,6 +38,7 @@ Note that `cargo miri test` in GenMC mode is currently not supported.
     - `debug1`:   Print revisits considered by GenMC.
     - `debug2`:   Print the execution graph after every memory access.
     - `debug3`:   Print reads-from values considered by GenMC.
+- `-Zmiri-genmc-verbose`: Show more information, such as estimated number of executions, and time taken for verification.
 
 #### Regular Miri parameters useful for GenMC mode
 
diff --git a/src/tools/miri/genmc-sys/cpp/include/MiriInterface.hpp b/src/tools/miri/genmc-sys/cpp/include/MiriInterface.hpp
index 662eb0e173ca8..444c9375319af 100644
--- a/src/tools/miri/genmc-sys/cpp/include/MiriInterface.hpp
+++ b/src/tools/miri/genmc-sys/cpp/include/MiriInterface.hpp
@@ -31,6 +31,7 @@ enum class LogLevel : std::uint8_t;
 
 struct GenmcScalar;
 struct SchedulingResult;
+struct EstimationResult;
 struct LoadResult;
 struct StoreResult;
 struct ReadModifyWriteResult;
@@ -66,7 +67,7 @@ struct MiriGenmcShim : private GenMCDriver {
     /// `logLevel`, causing a data race. The safest way to use these functions is to call
     /// `set_log_level_raw` once, and only then start creating handles. There should not be any
     /// other (safe) way to create a `MiriGenmcShim`.
-    /* unsafe */ static auto create_handle(const GenmcParams& params)
+    /* unsafe */ static auto create_handle(const GenmcParams& params, bool estimation_mode)
         -> std::unique_ptr<MiriGenmcShim>;
 
     virtual ~MiriGenmcShim() {}
@@ -183,6 +184,11 @@ struct MiriGenmcShim : private GenMCDriver {
         return nullptr;
     }
 
+    /**** Printing and estimation mode functionality. ****/
+
+    /// Get the results of a run in estimation mode.
+    auto get_estimation_results() const -> EstimationResult;
+
   private:
     /** Increment the event index in the given thread by 1 and return the new event. */
     [[nodiscard]] inline auto inc_pos(ThreadId tid) -> Event {
diff --git a/src/tools/miri/genmc-sys/cpp/src/MiriInterface/Exploration.cpp b/src/tools/miri/genmc-sys/cpp/src/MiriInterface/Exploration.cpp
index c51b59e865170..5e7188f17e0d2 100644
--- a/src/tools/miri/genmc-sys/cpp/src/MiriInterface/Exploration.cpp
+++ b/src/tools/miri/genmc-sys/cpp/src/MiriInterface/Exploration.cpp
@@ -10,7 +10,9 @@
 #include "Support/Verbosity.hpp"
 
 // C++ headers:
+#include <cmath>
 #include <cstdint>
+#include <limits>
 
 auto MiriGenmcShim::schedule_next(
     const int curr_thread_id,
@@ -40,3 +42,15 @@ auto MiriGenmcShim::handle_execution_end() -> std::unique_ptr<std::string> {
     GenMCDriver::handleExecutionEnd();
     return {};
 }
+
+/**** Estimation mode result ****/
+
+auto MiriGenmcShim::get_estimation_results() const -> EstimationResult {
+    const auto& res = getResult();
+    return EstimationResult {
+        .mean = static_cast<double>(res.estimationMean),
+        .sd = static_cast<double>(std::sqrt(res.estimationVariance)),
+        .explored_execs = static_cast<uint64_t>(res.explored),
+        .blocked_execs = static_cast<uint64_t>(res.exploredBlocked),
+    };
+}
diff --git a/src/tools/miri/genmc-sys/cpp/src/MiriInterface/Setup.cpp b/src/tools/miri/genmc-sys/cpp/src/MiriInterface/Setup.cpp
index a17a83aa06e13..af13f0d07746e 100644
--- a/src/tools/miri/genmc-sys/cpp/src/MiriInterface/Setup.cpp
+++ b/src/tools/miri/genmc-sys/cpp/src/MiriInterface/Setup.cpp
@@ -58,7 +58,7 @@ static auto to_genmc_verbosity_level(const LogLevel log_level) -> VerbosityLevel
     logLevel = to_genmc_verbosity_level(log_level);
 }
 
-/* unsafe */ auto MiriGenmcShim::create_handle(const GenmcParams& params)
+/* unsafe */ auto MiriGenmcShim::create_handle(const GenmcParams& params, bool estimation_mode)
     -> std::unique_ptr<MiriGenmcShim> {
     auto conf = std::make_shared<Config>();
 
@@ -82,7 +82,8 @@ static auto to_genmc_verbosity_level(const LogLevel log_level) -> VerbosityLevel
     // Miri.
     conf->warnOnGraphSize = 1024 * 1024;
 
-    // We only support the `RC11` memory model for Rust, and `SC` when weak memory emulation is disabled.
+    // We only support the `RC11` memory model for Rust, and `SC` when weak memory emulation is
+    // disabled.
     conf->model = params.disable_weak_memory_emulation ? ModelType::SC : ModelType::RC11;
 
     // This prints the seed that GenMC picks for randomized scheduling during estimation mode.
@@ -119,12 +120,20 @@ static auto to_genmc_verbosity_level(const LogLevel log_level) -> VerbosityLevel
     );
     conf->symmetryReduction = params.do_symmetry_reduction;
 
-    // FIXME(genmc): expose this setting to Miri (useful for testing Miri-GenMC).
-    conf->schedulePolicy = SchedulePolicy::WF;
-
+    // Set the scheduling policy. GenMC uses `WFR` for estimation mode.
+    // For normal verification, `WF` has the best performance and is the GenMC default.
+    // Other scheduling policies are used by GenMC for testing and for modes currently
+    // unsupported with Miri such as bounding, which uses LTR.
+    conf->schedulePolicy = estimation_mode ? SchedulePolicy::WFR : SchedulePolicy::WF;
+
+    // Set the min and max number of executions tested in estimation mode.
+    conf->estimationMin = 10; // default taken from GenMC
+    conf->estimationMax = params.estimation_max;
+    // Deviation threshold % under which estimation is deemed good enough.
+    conf->sdThreshold = 10; // default taken from GenMC
     // Set the mode used for this driver, either estimation or verification.
-    // FIXME(genmc): implement estimation mode.
-    const auto mode = GenMCDriver::Mode(GenMCDriver::VerificationMode {});
+    const auto mode = estimation_mode ? GenMCDriver::Mode(GenMCDriver::EstimationMode {})
+                                      : GenMCDriver::Mode(GenMCDriver::VerificationMode {});
 
     // Running Miri-GenMC without race detection is not supported.
     // Disabling this option also changes the behavior of the replay scheduler to only schedule
diff --git a/src/tools/miri/genmc-sys/src/lib.rs b/src/tools/miri/genmc-sys/src/lib.rs
index 31bc2606adc01..733b3d780b187 100644
--- a/src/tools/miri/genmc-sys/src/lib.rs
+++ b/src/tools/miri/genmc-sys/src/lib.rs
@@ -27,6 +27,7 @@ static GENMC_LOG_LEVEL: OnceLock<LogLevel> = OnceLock::new();
 pub fn create_genmc_driver_handle(
     params: &GenmcParams,
     genmc_log_level: LogLevel,
+    do_estimation: bool,
 ) -> UniquePtr<MiriGenmcShim> {
     // SAFETY: Only setting the GenMC log level once is guaranteed by the `OnceLock`.
     // No other place calls `set_log_level_raw`, so the `logLevel` value in GenMC will not change once we initialize it once.
@@ -40,7 +41,7 @@ pub fn create_genmc_driver_handle(
         }),
         "Attempt to change the GenMC log level after it was already set"
     );
-    unsafe { MiriGenmcShim::create_handle(params) }
+    unsafe { MiriGenmcShim::create_handle(params, do_estimation) }
 }
 
 impl GenmcScalar {
@@ -54,6 +55,7 @@ impl GenmcScalar {
 impl Default for GenmcParams {
     fn default() -> Self {
         Self {
+            estimation_max: 1000, // default taken from GenMC
             print_random_schedule_seed: false,
             do_symmetry_reduction: false,
             // GenMC graphs can be quite large since Miri produces a lot of (non-atomic) events.
@@ -70,6 +72,20 @@ impl Default for LogLevel {
     }
 }
 
+impl FromStr for SchedulePolicy {
+    type Err = &'static str;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(match s {
+            "wf" => SchedulePolicy::WF,
+            "wfr" => SchedulePolicy::WFR,
+            "arbitrary" | "random" => SchedulePolicy::Arbitrary,
+            "ltr" => SchedulePolicy::LTR,
+            _ => return Err("invalid scheduling policy"),
+        })
+    }
+}
+
 impl FromStr for LogLevel {
     type Err = &'static str;
 
@@ -92,9 +108,12 @@ mod ffi {
     /**** Types shared between Miri/Rust and Miri/C++ through cxx_bridge: ****/
 
     /// Parameters that will be given to GenMC for setting up the model checker.
-    /// (The fields of this struct are visible to both Rust and C++)
+    /// The fields of this struct are visible to both Rust and C++.
+    /// Note that this struct is #[repr(C)], so the order of fields matters.
     #[derive(Clone, Debug)]
     struct GenmcParams {
+        /// Maximum number of executions explored in estimation mode.
+        pub estimation_max: u32,
         pub print_random_schedule_seed: bool,
         pub do_symmetry_reduction: bool,
         pub print_execution_graphs: ExecutiongraphPrinting,
@@ -165,6 +184,19 @@ mod ffi {
         next_thread: i32,
     }
 
+    #[must_use]
+    #[derive(Debug)]
+    struct EstimationResult {
+        /// Expected number of total executions.
+        mean: f64,
+        /// Standard deviation of the total executions estimate.
+        sd: f64,
+        /// Number of explored executions during the estimation.
+        explored_execs: u64,
+        /// Number of encounteded blocked executions during the estimation.
+        blocked_execs: u64,
+    }
+
     #[must_use]
     #[derive(Debug)]
     struct LoadResult {
@@ -214,6 +246,14 @@ mod ffi {
     /**** These are GenMC types that we have to copy-paste here since cxx does not support
     "importing" externally defined C++ types. ****/
 
+    #[derive(Clone, Copy, Debug)]
+    enum SchedulePolicy {
+        LTR,
+        WF,
+        WFR,
+        Arbitrary,
+    }
+
     #[derive(Debug)]
     /// Corresponds to GenMC's type with the same name.
     /// Should only be modified if changed by GenMC.
@@ -272,6 +312,7 @@ mod ffi {
         type ActionKind;
         type MemOrdering;
         type RMWBinOp;
+        type SchedulePolicy;
 
         /// Set the log level for GenMC.
         ///
@@ -295,7 +336,10 @@ mod ffi {
         /// start creating handles.
         /// There should not be any other (safe) way to create a `MiriGenmcShim`.
         #[Self = "MiriGenmcShim"]
-        unsafe fn create_handle(params: &GenmcParams) -> UniquePtr<MiriGenmcShim>;
+        unsafe fn create_handle(
+            params: &GenmcParams,
+            estimation_mode: bool,
+        ) -> UniquePtr<MiriGenmcShim>;
         /// Get the bit mask that GenMC expects for global memory allocations.
         fn get_global_alloc_static_mask() -> u64;
 
@@ -403,5 +447,10 @@ mod ffi {
         fn get_result_message(self: &MiriGenmcShim) -> UniquePtr<CxxString>;
         /// If an error occurred, return a string describing the error, otherwise, return `nullptr`.
         fn get_error_string(self: &MiriGenmcShim) -> UniquePtr<CxxString>;
+
+        /**** Printing functionality. ****/
+
+        /// Get the results of a run in estimation mode.
+        fn get_estimation_results(self: &MiriGenmcShim) -> EstimationResult;
     }
 }
diff --git a/src/tools/miri/src/bin/miri.rs b/src/tools/miri/src/bin/miri.rs
index 731fe283a2195..8b15a7863476e 100644
--- a/src/tools/miri/src/bin/miri.rs
+++ b/src/tools/miri/src/bin/miri.rs
@@ -186,18 +186,17 @@ impl rustc_driver::Callbacks for MiriCompilerCalls {
                     optimizations is usually marginal at best.");
         }
 
-        if let Some(_genmc_config) = &config.genmc_config {
+        // Run in GenMC mode if enabled.
+        if config.genmc_config.is_some() {
+            // This is the entry point used in GenMC mode.
+            // This closure will be called multiple times to explore the concurrent execution space of the program.
             let eval_entry_once = |genmc_ctx: Rc<GenmcCtx>| {
                 miri::eval_entry(tcx, entry_def_id, entry_type, &config, Some(genmc_ctx))
             };
-
-            // FIXME(genmc): add estimation mode here.
-
             let return_code = run_genmc_mode(&config, eval_entry_once, tcx).unwrap_or_else(|| {
                 tcx.dcx().abort_if_errors();
                 rustc_driver::EXIT_FAILURE
             });
-
             exit(return_code);
         };
 
diff --git a/src/tools/miri/src/concurrency/genmc/config.rs b/src/tools/miri/src/concurrency/genmc/config.rs
index 34933d423f064..c7cfa6012b8dc 100644
--- a/src/tools/miri/src/concurrency/genmc/config.rs
+++ b/src/tools/miri/src/concurrency/genmc/config.rs
@@ -10,11 +10,15 @@ use crate::{IsolatedOp, MiriConfig, RejectOpWith};
 pub struct GenmcConfig {
     /// Parameters sent to the C++ side to create a new handle to the GenMC model checker.
     pub(super) params: GenmcParams,
+    pub(super) do_estimation: bool,
     /// Print the output message that GenMC generates when an error occurs.
     /// This error message is currently hard to use, since there is no clear mapping between the events that GenMC sees and the Rust code location where this event was produced.
     pub(super) print_genmc_output: bool,
     /// The log level for GenMC.
     pub(super) log_level: LogLevel,
+    /// Enable more verbose output, such as number of executions estimate
+    /// and time to completion of verification step.
+    pub(super) verbose_output: bool,
 }
 
 impl GenmcConfig {
@@ -57,8 +61,21 @@ impl GenmcConfig {
                         "Invalid suffix to GenMC argument '-Zmiri-genmc-print-exec-graphs', expected '', '=none', '=explored', '=blocked' or '=all'"
                     )),
             }
+        } else if trimmed_arg == "estimate" {
+            // FIXME(genmc): should this be on by default (like for GenMC)?
+            // Enable estimating the execution space and require time before running the actual verification.
+            genmc_config.do_estimation = true;
+        } else if let Some(estimation_max_str) = trimmed_arg.strip_prefix("estimation-max=") {
+            // Set the maximum number of executions to explore during estimation.
+            genmc_config.params.estimation_max = estimation_max_str.parse().ok().filter(|estimation_max| *estimation_max > 0).ok_or_else(|| {
+                format!(
+                    "'-Zmiri-genmc-estimation-max=...' expects a positive integer argument, but got '{estimation_max_str}'"
+                )
+            })?;
         } else if trimmed_arg == "print-genmc-output" {
             genmc_config.print_genmc_output = true;
+        } else if trimmed_arg == "verbose" {
+            genmc_config.verbose_output = true;
         } else {
             return Err(format!("Invalid GenMC argument: \"-Zmiri-genmc-{trimmed_arg}\""));
         }
diff --git a/src/tools/miri/src/concurrency/genmc/dummy.rs b/src/tools/miri/src/concurrency/genmc/dummy.rs
index 92b34b83ee0fc..c28984cef35ad 100644
--- a/src/tools/miri/src/concurrency/genmc/dummy.rs
+++ b/src/tools/miri/src/concurrency/genmc/dummy.rs
@@ -39,18 +39,6 @@ mod run {
 impl GenmcCtx {
     // We don't provide the `new` function in the dummy module.
 
-    pub fn get_blocked_execution_count(&self) -> usize {
-        unreachable!()
-    }
-
-    pub fn get_explored_execution_count(&self) -> usize {
-        unreachable!()
-    }
-
-    pub fn is_exploration_done(&self) -> bool {
-        unreachable!()
-    }
-
     /**** Memory access handling ****/
 
     pub(super) fn set_ongoing_action_data_race_free(&self, _enable: bool) {
diff --git a/src/tools/miri/src/concurrency/genmc/mod.rs b/src/tools/miri/src/concurrency/genmc/mod.rs
index 7270c66810608..0086d3f2bf0bc 100644
--- a/src/tools/miri/src/concurrency/genmc/mod.rs
+++ b/src/tools/miri/src/concurrency/genmc/mod.rs
@@ -2,8 +2,8 @@ use std::cell::{Cell, RefCell};
 use std::sync::Arc;
 
 use genmc_sys::{
-    GENMC_GLOBAL_ADDRESSES_MASK, GenmcScalar, MemOrdering, MiriGenmcShim, RMWBinOp, UniquePtr,
-    create_genmc_driver_handle,
+    EstimationResult, GENMC_GLOBAL_ADDRESSES_MASK, GenmcScalar, MemOrdering, MiriGenmcShim,
+    RMWBinOp, UniquePtr, create_genmc_driver_handle,
 };
 use rustc_abi::{Align, Size};
 use rustc_const_eval::interpret::{AllocId, InterpCx, InterpResult, interp_ok};
@@ -16,6 +16,7 @@ use self::helper::{
     MAX_ACCESS_SIZE, Warnings, emit_warning, genmc_scalar_to_scalar,
     maybe_upgrade_compare_exchange_success_orderings, scalar_to_genmc_scalar, to_genmc_rmw_op,
 };
+use self::run::GenmcMode;
 use self::thread_id_map::ThreadIdMap;
 use crate::concurrency::genmc::helper::split_access;
 use crate::intrinsics::AtomicRmwOp;
@@ -37,6 +38,16 @@ pub use genmc_sys::GenmcParams;
 pub use self::config::GenmcConfig;
 pub use self::run::run_genmc_mode;
 
+#[derive(Debug)]
+pub enum ExecutionEndResult {
+    /// An error occurred at the end of the execution.
+    Error(String),
+    /// No errors occurred, and there are more executions to explore.
+    Continue,
+    /// No errors occurred and we are finished.
+    Stop,
+}
+
 #[derive(Clone, Copy, Debug)]
 pub enum ExitType {
     MainThreadFinish,
@@ -128,26 +139,33 @@ pub struct GenmcCtx {
 /// GenMC Context creation and administrative / query actions
 impl GenmcCtx {
     /// Create a new `GenmcCtx` from a given config.
-    fn new(miri_config: &MiriConfig, global_state: Arc<GlobalState>) -> Self {
+    fn new(miri_config: &MiriConfig, global_state: Arc<GlobalState>, mode: GenmcMode) -> Self {
         let genmc_config = miri_config.genmc_config.as_ref().unwrap();
-        let handle =
-            RefCell::new(create_genmc_driver_handle(&genmc_config.params, genmc_config.log_level));
+        let handle = RefCell::new(create_genmc_driver_handle(
+            &genmc_config.params,
+            genmc_config.log_level,
+            /* do_estimation: */ mode == GenmcMode::Estimation,
+        ));
         Self { handle, exec_state: Default::default(), global_state }
     }
 
+    fn get_estimation_results(&self) -> EstimationResult {
+        self.handle.borrow().get_estimation_results()
+    }
+
     /// Get the number of blocked executions encountered by GenMC.
-    pub fn get_blocked_execution_count(&self) -> u64 {
+    fn get_blocked_execution_count(&self) -> u64 {
         self.handle.borrow().get_blocked_execution_count()
     }
 
     /// Get the number of explored executions encountered by GenMC.
-    pub fn get_explored_execution_count(&self) -> u64 {
+    fn get_explored_execution_count(&self) -> u64 {
         self.handle.borrow().get_explored_execution_count()
     }
 
     /// Check if GenMC encountered an error that wasn't immediately returned during execution.
     /// Returns a string representation of the error if one occurred.
-    pub fn try_get_error(&self) -> Option<String> {
+    fn try_get_error(&self) -> Option<String> {
         self.handle
             .borrow()
             .get_error_string()
@@ -157,7 +175,7 @@ impl GenmcCtx {
 
     /// Check if GenMC encountered an error that wasn't immediately returned during execution.
     /// Returns a string representation of the error if one occurred.
-    pub fn get_result_message(&self) -> String {
+    fn get_result_message(&self) -> String {
         self.handle
             .borrow()
             .get_result_message()
@@ -166,13 +184,6 @@ impl GenmcCtx {
             .expect("there should always be a message")
     }
 
-    /// This function determines if we should continue exploring executions or if we are done.
-    ///
-    /// In GenMC mode, the input program should be repeatedly executed until this function returns `true` or an error is found.
-    pub fn is_exploration_done(&self) -> bool {
-        self.handle.borrow_mut().pin_mut().is_exploration_done()
-    }
-
     /// Select whether data race free actions should be allowed. This function should be used carefully!
     ///
     /// If `true` is passed, allow for data races to happen without triggering an error, until this function is called again with argument `false`.
@@ -218,13 +229,25 @@ impl GenmcCtx {
     /// This function will also check for those, and return their error description.
     ///
     /// To get the all messages (warnings, errors) that GenMC produces, use the `get_result_message` method.
-    fn handle_execution_end(&self) -> Option<String> {
+    fn handle_execution_end(&self) -> ExecutionEndResult {
         let result = self.handle.borrow_mut().pin_mut().handle_execution_end();
-        result.as_ref().map(|msg| msg.to_string_lossy().to_string())?;
+        if let Some(error) = result.as_ref() {
+            return ExecutionEndResult::Error(error.to_string_lossy().to_string());
+        }
+
+        // GenMC decides if there is more to explore:
+        let exploration_done = self.handle.borrow_mut().pin_mut().is_exploration_done();
 
         // GenMC currently does not return an error value immediately in all cases.
+        // Both `handle_execution_end` and `is_exploration_done` can produce such errors.
         // We manually query for any errors here to ensure we don't miss any.
-        self.try_get_error()
+        if let Some(error) = self.try_get_error() {
+            ExecutionEndResult::Error(error)
+        } else if exploration_done {
+            ExecutionEndResult::Stop
+        } else {
+            ExecutionEndResult::Continue
+        }
     }
 
     /**** Memory access handling ****/
diff --git a/src/tools/miri/src/concurrency/genmc/run.rs b/src/tools/miri/src/concurrency/genmc/run.rs
index 7e4ed816a76a1..bc2f5f7b79ec4 100644
--- a/src/tools/miri/src/concurrency/genmc/run.rs
+++ b/src/tools/miri/src/concurrency/genmc/run.rs
@@ -1,32 +1,65 @@
 use std::rc::Rc;
 use std::sync::Arc;
+use std::time::Instant;
 
+use genmc_sys::EstimationResult;
 use rustc_middle::ty::TyCtxt;
 
 use super::GlobalState;
+use crate::concurrency::genmc::ExecutionEndResult;
 use crate::rustc_const_eval::interpret::PointerArithmetic;
-use crate::{GenmcCtx, MiriConfig};
+use crate::{GenmcConfig, GenmcCtx, MiriConfig};
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(super) enum GenmcMode {
+    Estimation,
+    Verification,
+}
+
+impl GenmcMode {
+    /// Return whether warnings on unsupported features should be printed in this mode.
+    fn print_unsupported_warnings(self) -> bool {
+        self == GenmcMode::Verification
+    }
+}
 
 /// Do a complete run of the program in GenMC mode.
 /// This will call `eval_entry` multiple times, until either:
 /// - An error is detected (indicated by a `None` return value)
 /// - All possible executions are explored.
 ///
-/// FIXME(genmc): add estimation mode setting.
+/// Returns `None` is an error is detected, or `Some(return_value)` with the return value of the last run of the program.
 pub fn run_genmc_mode<'tcx>(
     config: &MiriConfig,
     eval_entry: impl Fn(Rc<GenmcCtx>) -> Option<i32>,
     tcx: TyCtxt<'tcx>,
 ) -> Option<i32> {
     let genmc_config = config.genmc_config.as_ref().unwrap();
+    // Run in Estimation mode if requested.
+    if genmc_config.do_estimation {
+        eprintln!("Estimating GenMC verification time...");
+        run_genmc_mode_impl(config, &eval_entry, tcx, GenmcMode::Estimation)?;
+    }
+    // Run in Verification mode.
+    eprintln!("Running GenMC Verification...");
+    run_genmc_mode_impl(config, &eval_entry, tcx, GenmcMode::Verification)
+}
+
+fn run_genmc_mode_impl<'tcx>(
+    config: &MiriConfig,
+    eval_entry: &impl Fn(Rc<GenmcCtx>) -> Option<i32>,
+    tcx: TyCtxt<'tcx>,
+    mode: GenmcMode,
+) -> Option<i32> {
+    let time_start = Instant::now();
+    let genmc_config = config.genmc_config.as_ref().unwrap();
 
     // There exists only one `global_state` per full run in GenMC mode.
     // It is shared by all `GenmcCtx` in this run.
     // FIXME(genmc): implement multithreading once GenMC supports it.
-    // FIXME(genmc): disable warnings in estimation mode once it is added.
     let global_state =
-        Arc::new(GlobalState::new(tcx.target_usize_max(), /* print_warnings */ true));
-    let genmc_ctx = Rc::new(GenmcCtx::new(config, global_state));
+        Arc::new(GlobalState::new(tcx.target_usize_max(), mode.print_unsupported_warnings()));
+    let genmc_ctx = Rc::new(GenmcCtx::new(config, global_state, mode));
 
     // `rep` is used to report the progress, Miri will panic on wrap-around.
     for rep in 0u64.. {
@@ -37,46 +70,97 @@ pub fn run_genmc_mode<'tcx>(
 
         // Execute the program until completion to get the return value, or return if an error happens:
         let Some(return_code) = eval_entry(genmc_ctx.clone()) else {
-            // If requested, print the output GenMC produced:
-            if genmc_config.print_genmc_output {
-                eprintln!("== raw GenMC output =========================");
-                eprintln!("{}", genmc_ctx.get_result_message());
-                eprintln!("== end of raw GenMC output ==================");
-            }
+            genmc_ctx.print_genmc_output(genmc_config);
             return None;
         };
 
-        // We inform GenMC that the execution is complete. If there was an error, we print it.
-        if let Some(error) = genmc_ctx.handle_execution_end() {
-            // This can be reached for errors that affect the entire execution, not just a specific event.
-            // For instance, linearizability checking and liveness checking report their errors this way.
-            // Neither are supported by Miri-GenMC at the moment though. However, GenMC also
-            // treats races on deallocation as global errors, so this code path is still reachable.
-            // Since we don't have any span information for the error at this point,
-            // we just print GenMC's error message.
-            eprintln!("(GenMC) Error detected: {error}");
-            eprintln!();
-            eprintln!("{}", genmc_ctx.get_result_message());
-            return None;
+        // We inform GenMC that the execution is complete.
+        // If there was an error, we print it.
+        match genmc_ctx.handle_execution_end() {
+            ExecutionEndResult::Continue => continue,
+            ExecutionEndResult::Stop => {
+                let elapsed_time_sec = Instant::now().duration_since(time_start).as_secs_f64();
+                // Print the output for the current mode.
+                if mode == GenmcMode::Estimation {
+                    genmc_ctx.print_estimation_output(genmc_config, elapsed_time_sec);
+                } else {
+                    genmc_ctx.print_verification_output(genmc_config, elapsed_time_sec);
+                }
+                // Return the return code of the last execution.
+                return Some(return_code);
+            }
+            ExecutionEndResult::Error(error) => {
+                // This can be reached for errors that affect the entire execution, not just a specific event.
+                // For instance, linearizability checking and liveness checking report their errors this way.
+                // Neither are supported by Miri-GenMC at the moment though. However, GenMC also
+                // treats races on deallocation as global errors, so this code path is still reachable.
+                // Since we don't have any span information for the error at this point,
+                // we just print GenMC's error string, and the full GenMC output if requested.
+                eprintln!("(GenMC) Error detected: {error}");
+                genmc_ctx.print_genmc_output(genmc_config);
+                return None;
+            }
         }
+    }
+    unreachable!()
+}
 
-        // Check if we've explored enough executions:
-        if !genmc_ctx.is_exploration_done() {
-            continue;
+impl GenmcCtx {
+    /// Print the full output message produced by GenMC if requested, or a hint on how to enable it.
+    ///
+    /// This message can be very verbose and is likely not useful for the average user.
+    /// This function should be called *after* Miri has printed all of its output.
+    fn print_genmc_output(&self, genmc_config: &GenmcConfig) {
+        if genmc_config.print_genmc_output {
+            eprintln!("GenMC error report:");
+            eprintln!("{}", self.get_result_message());
+        } else {
+            eprintln!(
+                "(Add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report.)"
+            );
         }
+    }
 
-        eprintln!("(GenMC) Verification complete. No errors were detected.");
-
-        let explored_execution_count = genmc_ctx.get_explored_execution_count();
-        let blocked_execution_count = genmc_ctx.get_blocked_execution_count();
+    /// Given the time taken for the estimation mode run, print the expected time range for verification.
+    /// Verbose output also includes information about the expected number of executions and how many estimation rounds were explored or got blocked.
+    fn print_estimation_output(&self, genmc_config: &GenmcConfig, elapsed_time_sec: f64) {
+        let EstimationResult { mean, sd, explored_execs, blocked_execs } =
+            self.get_estimation_results();
+        #[allow(clippy::as_conversions)]
+        let time_per_exec_sec = elapsed_time_sec / (explored_execs as f64 + blocked_execs as f64);
+        let estimated_mean_sec = time_per_exec_sec * mean;
+        let estimated_sd_sec = time_per_exec_sec * sd;
 
-        eprintln!("Number of complete executions explored: {explored_execution_count}");
-        if blocked_execution_count > 0 {
-            eprintln!("Number of blocked executions seen: {blocked_execution_count}");
+        if genmc_config.verbose_output {
+            eprintln!("Finished estimation in {elapsed_time_sec:.2?}s");
+            if blocked_execs != 0 {
+                eprintln!("  Explored executions: {explored_execs}");
+                eprintln!("  Blocked  executions: {blocked_execs}");
+            }
+            eprintln!("Expected number of executions: {mean:.0} ± {sd:.0}");
+        }
+        // The estimation can be out-of-bounds of an `f64`.
+        if !(mean.is_finite() && mean >= 0.0 && sd.is_finite() && sd >= 0.0) {
+            eprintln!("WARNING: Estimation gave weird results, there may have been an overflow.");
         }
+        eprintln!("Expected verification time: {estimated_mean_sec:.2}s ± {estimated_sd_sec:.2}s");
+    }
 
-        // Return the return code of the last execution.
-        return Some(return_code);
+    /// Given the time taken for the verification mode run, print the expected time range for verification.
+    /// Verbose output also includes information about the expected number of executions and how many estimation rounds were explored or got blocked.
+    fn print_verification_output(&self, genmc_config: &GenmcConfig, elapsed_time_sec: f64) {
+        let explored_execution_count = self.get_explored_execution_count();
+        let blocked_execution_count = self.get_blocked_execution_count();
+        eprintln!(
+            "Verification complete with {} executions. No errors found.",
+            explored_execution_count + blocked_execution_count
+        );
+        if genmc_config.verbose_output {
+            if blocked_execution_count > 0 {
+                eprintln!("Number of complete executions explored: {explored_execution_count}");
+                eprintln!("Number of blocked executions seen: {blocked_execution_count}");
+            }
+            eprintln!("Verification took {elapsed_time_sec:.2?}s.");
+        }
     }
-    unreachable!()
 }
diff --git a/src/tools/miri/tests/genmc/fail/data_race/mpu2_rels_rlx.stderr b/src/tools/miri/tests/genmc/fail/data_race/mpu2_rels_rlx.stderr
index 946d9a2124b88..00de74009d9b8 100644
--- a/src/tools/miri/tests/genmc/fail/data_race/mpu2_rels_rlx.stderr
+++ b/src/tools/miri/tests/genmc/fail/data_race/mpu2_rels_rlx.stderr
@@ -1,3 +1,4 @@
+Running GenMC Verification...
 error: Undefined Behavior: Non-atomic race
   --> tests/genmc/fail/data_race/mpu2_rels_rlx.rs:LL:CC
    |
@@ -15,5 +16,6 @@ note: inside `genmc::spawn_pthread_closure::thread_func::<{closure@tests/genmc/f
 LL |         f();
    |         ^^^
 
+(Add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report.)
 error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rel_rlx.stderr b/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rel_rlx.stderr
index 121ded2a181ca..501957a90d3ac 100644
--- a/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rel_rlx.stderr
+++ b/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rel_rlx.stderr
@@ -1,3 +1,4 @@
+Running GenMC Verification...
 error: Undefined Behavior: Non-atomic race
   --> tests/genmc/fail/data_race/weak_orderings.rs:LL:CC
    |
@@ -15,5 +16,6 @@ note: inside `genmc::spawn_pthread_closure::thread_func::<{closure@tests/genmc/f
 LL |         f();
    |         ^^^
 
+(Add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report.)
 error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rlx_acq.stderr b/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rlx_acq.stderr
index 121ded2a181ca..501957a90d3ac 100644
--- a/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rlx_acq.stderr
+++ b/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rlx_acq.stderr
@@ -1,3 +1,4 @@
+Running GenMC Verification...
 error: Undefined Behavior: Non-atomic race
   --> tests/genmc/fail/data_race/weak_orderings.rs:LL:CC
    |
@@ -15,5 +16,6 @@ note: inside `genmc::spawn_pthread_closure::thread_func::<{closure@tests/genmc/f
 LL |         f();
    |         ^^^
 
+(Add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report.)
 error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rlx_rlx.stderr b/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rlx_rlx.stderr
index 121ded2a181ca..501957a90d3ac 100644
--- a/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rlx_rlx.stderr
+++ b/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rlx_rlx.stderr
@@ -1,3 +1,4 @@
+Running GenMC Verification...
 error: Undefined Behavior: Non-atomic race
   --> tests/genmc/fail/data_race/weak_orderings.rs:LL:CC
    |
@@ -15,5 +16,6 @@ note: inside `genmc::spawn_pthread_closure::thread_func::<{closure@tests/genmc/f
 LL |         f();
    |         ^^^
 
+(Add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report.)
 error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/genmc/fail/loom/buggy_inc.stderr b/src/tools/miri/tests/genmc/fail/loom/buggy_inc.stderr
index 5a8948ff9b4b8..9c3ba1d4c5924 100644
--- a/src/tools/miri/tests/genmc/fail/loom/buggy_inc.stderr
+++ b/src/tools/miri/tests/genmc/fail/loom/buggy_inc.stderr
@@ -1,3 +1,4 @@
+Running GenMC Verification...
 error: abnormal termination: the program aborted execution
   --> tests/genmc/fail/loom/buggy_inc.rs:LL:CC
    |
@@ -9,5 +10,6 @@ LL |             std::process::abort();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
+(Add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report.)
 error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/genmc/fail/loom/store_buffering.genmc.stderr b/src/tools/miri/tests/genmc/fail/loom/store_buffering.genmc.stderr
index a6c3ed7055e75..db92d0573fad2 100644
--- a/src/tools/miri/tests/genmc/fail/loom/store_buffering.genmc.stderr
+++ b/src/tools/miri/tests/genmc/fail/loom/store_buffering.genmc.stderr
@@ -1,3 +1,4 @@
+Running GenMC Verification...
 error: abnormal termination: the program aborted execution
   --> tests/genmc/fail/loom/store_buffering.rs:LL:CC
    |
@@ -9,5 +10,6 @@ LL |             std::process::abort();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
+(Add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report.)
 error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.relaxed4.stderr b/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.relaxed4.stderr
index cbfb6ec833eb0..773f86a975967 100644
--- a/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.relaxed4.stderr
+++ b/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.relaxed4.stderr
@@ -1,3 +1,4 @@
+Running GenMC Verification...
 error: abnormal termination: the program aborted execution
   --> tests/genmc/fail/simple/2w2w_weak.rs:LL:CC
    |
@@ -9,5 +10,6 @@ LL |             std::process::abort();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
+(Add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report.)
 error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.release4.stderr b/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.release4.stderr
index cbfb6ec833eb0..773f86a975967 100644
--- a/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.release4.stderr
+++ b/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.release4.stderr
@@ -1,3 +1,4 @@
+Running GenMC Verification...
 error: abnormal termination: the program aborted execution
   --> tests/genmc/fail/simple/2w2w_weak.rs:LL:CC
    |
@@ -9,5 +10,6 @@ LL |             std::process::abort();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
+(Add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report.)
 error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.sc3_rel1.stderr b/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.sc3_rel1.stderr
index cbfb6ec833eb0..773f86a975967 100644
--- a/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.sc3_rel1.stderr
+++ b/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.sc3_rel1.stderr
@@ -1,3 +1,4 @@
+Running GenMC Verification...
 error: abnormal termination: the program aborted execution
   --> tests/genmc/fail/simple/2w2w_weak.rs:LL:CC
    |
@@ -9,5 +10,6 @@ LL |             std::process::abort();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
+(Add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report.)
 error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/genmc/pass/atomics/cas_failure_ord_racy_key_init.stderr b/src/tools/miri/tests/genmc/pass/atomics/cas_failure_ord_racy_key_init.stderr
index d97b8b3d92f48..31438f9352fe6 100644
--- a/src/tools/miri/tests/genmc/pass/atomics/cas_failure_ord_racy_key_init.stderr
+++ b/src/tools/miri/tests/genmc/pass/atomics/cas_failure_ord_racy_key_init.stderr
@@ -1,3 +1,4 @@
+Running GenMC Verification...
 warning: GenMC currently does not model the failure ordering for `compare_exchange`. Success ordering 'Release' was upgraded to 'AcqRel' to match failure ordering 'Acquire'. Miri with GenMC might miss bugs related to this memory access.
   --> tests/genmc/pass/atomics/cas_failure_ord_racy_key_init.rs:LL:CC
    |
@@ -18,5 +19,4 @@ note: inside `genmc::spawn_pthread_closure::thread_func::<{closure@tests/genmc/p
 LL |         f();
    |         ^^^
 
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 2
+Verification complete with 2 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/atomics/cas_simple.stderr b/src/tools/miri/tests/genmc/pass/atomics/cas_simple.stderr
index 3b22247ee44cb..7867be2dbe8ed 100644
--- a/src/tools/miri/tests/genmc/pass/atomics/cas_simple.stderr
+++ b/src/tools/miri/tests/genmc/pass/atomics/cas_simple.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 1
+Running GenMC Verification...
+Verification complete with 1 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/atomics/rmw_ops.stderr b/src/tools/miri/tests/genmc/pass/atomics/rmw_ops.stderr
index 3b22247ee44cb..7867be2dbe8ed 100644
--- a/src/tools/miri/tests/genmc/pass/atomics/rmw_ops.stderr
+++ b/src/tools/miri/tests/genmc/pass/atomics/rmw_ops.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 1
+Running GenMC Verification...
+Verification complete with 1 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/2cowr.stderr b/src/tools/miri/tests/genmc/pass/litmus/2cowr.stderr
index 0667962f99c88..a67635dee1bef 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/2cowr.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/2cowr.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 4
+Running GenMC Verification...
+Verification complete with 4 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/2w2w_2sc_scf.stderr b/src/tools/miri/tests/genmc/pass/litmus/2w2w_2sc_scf.stderr
index 115b1986ce557..485142e945a72 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/2w2w_2sc_scf.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/2w2w_2sc_scf.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 3
+Running GenMC Verification...
+Verification complete with 3 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/2w2w_3sc_1rel.release1.stderr b/src/tools/miri/tests/genmc/pass/litmus/2w2w_3sc_1rel.release1.stderr
index 0667962f99c88..a67635dee1bef 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/2w2w_3sc_1rel.release1.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/2w2w_3sc_1rel.release1.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 4
+Running GenMC Verification...
+Verification complete with 4 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/2w2w_3sc_1rel.release2.stderr b/src/tools/miri/tests/genmc/pass/litmus/2w2w_3sc_1rel.release2.stderr
index 0667962f99c88..a67635dee1bef 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/2w2w_3sc_1rel.release2.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/2w2w_3sc_1rel.release2.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 4
+Running GenMC Verification...
+Verification complete with 4 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/2w2w_4rel.sc.stderr b/src/tools/miri/tests/genmc/pass/litmus/2w2w_4rel.sc.stderr
index 115b1986ce557..485142e945a72 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/2w2w_4rel.sc.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/2w2w_4rel.sc.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 3
+Running GenMC Verification...
+Verification complete with 3 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/2w2w_4rel.weak.stderr b/src/tools/miri/tests/genmc/pass/litmus/2w2w_4rel.weak.stderr
index 0667962f99c88..a67635dee1bef 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/2w2w_4rel.weak.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/2w2w_4rel.weak.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 4
+Running GenMC Verification...
+Verification complete with 4 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/2w2w_4sc.stderr b/src/tools/miri/tests/genmc/pass/litmus/2w2w_4sc.stderr
index 115b1986ce557..485142e945a72 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/2w2w_4sc.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/2w2w_4sc.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 3
+Running GenMC Verification...
+Verification complete with 3 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/IRIW-acq-sc.stderr b/src/tools/miri/tests/genmc/pass/litmus/IRIW-acq-sc.stderr
index c760b44605112..d6ec73a8c6672 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/IRIW-acq-sc.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/IRIW-acq-sc.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 16
+Running GenMC Verification...
+Verification complete with 16 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/IRIWish.stderr b/src/tools/miri/tests/genmc/pass/litmus/IRIWish.stderr
index 4fc77b63f3803..7ea2dd5085136 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/IRIWish.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/IRIWish.stderr
@@ -1,3 +1,4 @@
+Running GenMC Verification...
 [1, 1, 1, 1, 1]
 [1, 1, 1, 0, 1]
 [1, 1, 1, 0, 0]
@@ -26,5 +27,4 @@
 [0, 0, 0, 0, 0]
 [0, 0, 0, 0, 1]
 [0, 0, 0, 0, 0]
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 28
+Verification complete with 28 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/LB.stderr b/src/tools/miri/tests/genmc/pass/litmus/LB.stderr
index 115b1986ce557..485142e945a72 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/LB.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/LB.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 3
+Running GenMC Verification...
+Verification complete with 3 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/LB_incMPs.stderr b/src/tools/miri/tests/genmc/pass/litmus/LB_incMPs.stderr
index c879e95a17085..e414cd5e064d9 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/LB_incMPs.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/LB_incMPs.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 15
+Running GenMC Verification...
+Verification complete with 15 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/MP.stderr b/src/tools/miri/tests/genmc/pass/litmus/MP.stderr
index 115b1986ce557..485142e945a72 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/MP.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/MP.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 3
+Running GenMC Verification...
+Verification complete with 3 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/MPU2_rels_acqf.stderr b/src/tools/miri/tests/genmc/pass/litmus/MPU2_rels_acqf.stderr
index 4551c00b0575d..29b59ce3bc1a3 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/MPU2_rels_acqf.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/MPU2_rels_acqf.stderr
@@ -1,3 +1,4 @@
+Running GenMC Verification...
 X=1, Y=2, a=Err(1), b=Ok(1), c=2
 X=1, Y=2, a=Err(1), b=Ok(1), c=1
 X=1, Y=2, a=Err(1), b=Ok(1), c=0
@@ -34,5 +35,4 @@ X=1, Y=1, a=Err(0), b=Err(0), c=0
 X=1, Y=1, a=Err(0), b=Err(0), c=1
 X=1, Y=1, a=Err(0), b=Err(0), c=0
 X=1, Y=1, a=Err(0), b=Err(0), c=0
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 36
+Verification complete with 36 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/MPU_rels_acq.stderr b/src/tools/miri/tests/genmc/pass/litmus/MPU_rels_acq.stderr
index c5e34b00642aa..423ee6dc39996 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/MPU_rels_acq.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/MPU_rels_acq.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 13
+Running GenMC Verification...
+Verification complete with 13 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/MP_incMPs.stderr b/src/tools/miri/tests/genmc/pass/litmus/MP_incMPs.stderr
index 2be9a6c7fbded..f527b61202327 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/MP_incMPs.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/MP_incMPs.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 7
+Running GenMC Verification...
+Verification complete with 7 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/MP_rels_acqf.stderr b/src/tools/miri/tests/genmc/pass/litmus/MP_rels_acqf.stderr
index 0667962f99c88..a67635dee1bef 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/MP_rels_acqf.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/MP_rels_acqf.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 4
+Running GenMC Verification...
+Verification complete with 4 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/SB.stderr b/src/tools/miri/tests/genmc/pass/litmus/SB.stderr
index 0667962f99c88..a67635dee1bef 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/SB.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/SB.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 4
+Running GenMC Verification...
+Verification complete with 4 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/SB_2sc_scf.stderr b/src/tools/miri/tests/genmc/pass/litmus/SB_2sc_scf.stderr
index 115b1986ce557..485142e945a72 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/SB_2sc_scf.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/SB_2sc_scf.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 3
+Running GenMC Verification...
+Verification complete with 3 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/Z6_U.sc.stderr b/src/tools/miri/tests/genmc/pass/litmus/Z6_U.sc.stderr
index 8dd2fbe1b9757..c8fbb8951a386 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/Z6_U.sc.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/Z6_U.sc.stderr
@@ -1,3 +1,4 @@
+Running GenMC Verification...
 a=2, b=1, X=1, Y=3
 a=4, b=1, X=1, Y=4
 a=3, b=1, X=1, Y=3
@@ -16,5 +17,4 @@ a=3, b=0, X=1, Y=1
 a=1, b=1, X=1, Y=3
 a=1, b=1, X=1, Y=1
 a=1, b=0, X=1, Y=1
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 18
+Verification complete with 18 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/Z6_U.weak.stderr b/src/tools/miri/tests/genmc/pass/litmus/Z6_U.weak.stderr
index 65622575de21d..72c59d33f77cf 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/Z6_U.weak.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/Z6_U.weak.stderr
@@ -1,3 +1,4 @@
+Running GenMC Verification...
 a=2, b=1, X=1, Y=3
 a=4, b=1, X=1, Y=4
 a=4, b=0, X=1, Y=4
@@ -20,5 +21,4 @@ a=1, b=1, X=1, Y=3
 a=1, b=0, X=1, Y=3
 a=1, b=1, X=1, Y=1
 a=1, b=0, X=1, Y=1
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 22
+Verification complete with 22 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/Z6_acq.stderr b/src/tools/miri/tests/genmc/pass/litmus/Z6_acq.stderr
index 2be9a6c7fbded..f527b61202327 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/Z6_acq.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/Z6_acq.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 7
+Running GenMC Verification...
+Verification complete with 7 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/atomicpo.stderr b/src/tools/miri/tests/genmc/pass/litmus/atomicpo.stderr
index 0667962f99c88..a67635dee1bef 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/atomicpo.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/atomicpo.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 4
+Running GenMC Verification...
+Verification complete with 4 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/casdep.stderr b/src/tools/miri/tests/genmc/pass/litmus/casdep.stderr
index 01701dfe6918a..bde951866d013 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/casdep.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/casdep.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 2
+Running GenMC Verification...
+Verification complete with 2 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/ccr.stderr b/src/tools/miri/tests/genmc/pass/litmus/ccr.stderr
index 01701dfe6918a..bde951866d013 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/ccr.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/ccr.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 2
+Running GenMC Verification...
+Verification complete with 2 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/cii.stderr b/src/tools/miri/tests/genmc/pass/litmus/cii.stderr
index be75e68fde77d..b9bdf2245aed6 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/cii.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/cii.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 6
+Running GenMC Verification...
+Verification complete with 6 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/corr.stderr b/src/tools/miri/tests/genmc/pass/litmus/corr.stderr
index be75e68fde77d..b9bdf2245aed6 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/corr.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/corr.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 6
+Running GenMC Verification...
+Verification complete with 6 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/corr0.stderr b/src/tools/miri/tests/genmc/pass/litmus/corr0.stderr
index 0667962f99c88..a67635dee1bef 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/corr0.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/corr0.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 4
+Running GenMC Verification...
+Verification complete with 4 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/corr1.stderr b/src/tools/miri/tests/genmc/pass/litmus/corr1.stderr
index f6d07e9c77b2b..384425fc43c67 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/corr1.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/corr1.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 36
+Running GenMC Verification...
+Verification complete with 36 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/corr2.stderr b/src/tools/miri/tests/genmc/pass/litmus/corr2.stderr
index 78a90b63feab6..07fd2d4de180c 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/corr2.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/corr2.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 72
+Running GenMC Verification...
+Verification complete with 72 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/corw.stderr b/src/tools/miri/tests/genmc/pass/litmus/corw.stderr
index 115b1986ce557..485142e945a72 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/corw.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/corw.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 3
+Running GenMC Verification...
+Verification complete with 3 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/cowr.stderr b/src/tools/miri/tests/genmc/pass/litmus/cowr.stderr
index 115b1986ce557..485142e945a72 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/cowr.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/cowr.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 3
+Running GenMC Verification...
+Verification complete with 3 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/cumul-release.stderr b/src/tools/miri/tests/genmc/pass/litmus/cumul-release.stderr
index 00394048ec5c6..a031dfc8977a5 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/cumul-release.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/cumul-release.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 8
+Running GenMC Verification...
+Verification complete with 8 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/default.stderr b/src/tools/miri/tests/genmc/pass/litmus/default.stderr
index e0313930282ea..87d38d250411a 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/default.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/default.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 12
+Running GenMC Verification...
+Verification complete with 12 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/detour.join.stderr b/src/tools/miri/tests/genmc/pass/litmus/detour.join.stderr
index 15017249dc3a7..5006f11fefb1c 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/detour.join.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/detour.join.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 9
+Running GenMC Verification...
+Verification complete with 9 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/detour.no_join.stderr b/src/tools/miri/tests/genmc/pass/litmus/detour.no_join.stderr
index 15017249dc3a7..5006f11fefb1c 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/detour.no_join.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/detour.no_join.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 9
+Running GenMC Verification...
+Verification complete with 9 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/fr_w_w_w_reads.stderr b/src/tools/miri/tests/genmc/pass/litmus/fr_w_w_w_reads.stderr
index 3b6ba238f5342..c09b50e282f1e 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/fr_w_w_w_reads.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/fr_w_w_w_reads.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 210
+Running GenMC Verification...
+Verification complete with 210 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/inc2w.stderr b/src/tools/miri/tests/genmc/pass/litmus/inc2w.stderr
index be75e68fde77d..b9bdf2245aed6 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/inc2w.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/inc2w.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 6
+Running GenMC Verification...
+Verification complete with 6 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/inc_inc_RR_W_RR.stderr b/src/tools/miri/tests/genmc/pass/litmus/inc_inc_RR_W_RR.stderr
index b5f8cd15b683f..770fb7ef88046 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/inc_inc_RR_W_RR.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/inc_inc_RR_W_RR.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 600
+Running GenMC Verification...
+Verification complete with 600 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/riwi.stderr b/src/tools/miri/tests/genmc/pass/litmus/riwi.stderr
index 115b1986ce557..485142e945a72 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/riwi.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/riwi.stderr
@@ -1,2 +1,2 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 3
+Running GenMC Verification...
+Verification complete with 3 executions. No errors found.
diff --git a/src/tools/miri/tests/genmc/pass/litmus/viktor-relseq.rs b/src/tools/miri/tests/genmc/pass/litmus/viktor-relseq.rs
index a193dcf0683ea..3256c9f421193 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/viktor-relseq.rs
+++ b/src/tools/miri/tests/genmc/pass/litmus/viktor-relseq.rs
@@ -1,6 +1,8 @@
-//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows
+//@compile-flags: -Zmiri-genmc -Zmiri-disable-stacked-borrows -Zmiri-genmc-estimate
 
 // Translated from GenMC's "litmus/viktor-relseq" test.
+//
+// This test also checks that we can run the GenMC estimation mode.
 
 #![no_main]
 
diff --git a/src/tools/miri/tests/genmc/pass/litmus/viktor-relseq.stderr b/src/tools/miri/tests/genmc/pass/litmus/viktor-relseq.stderr
index d63ac5199d5d4..c53d5c569b9ca 100644
--- a/src/tools/miri/tests/genmc/pass/litmus/viktor-relseq.stderr
+++ b/src/tools/miri/tests/genmc/pass/litmus/viktor-relseq.stderr
@@ -1,2 +1,4 @@
-(GenMC) Verification complete. No errors were detected.
-Number of complete executions explored: 180
+Estimating GenMC verification time...
+Expected verification time: [MEAN] ± [SD]
+Running GenMC Verification...
+Verification complete with 180 executions. No errors found.
diff --git a/src/tools/miri/tests/ui.rs b/src/tools/miri/tests/ui.rs
index b7286d9a3673a..efaaf9fc84170 100644
--- a/src/tools/miri/tests/ui.rs
+++ b/src/tools/miri/tests/ui.rs
@@ -277,6 +277,8 @@ regexes! {
     r"\bsys/([a-z_]+)/[a-z]+\b"     => "sys/$1/PLATFORM",
     // erase paths into the crate registry
     r"[^ ]*/\.?cargo/registry/.*/(.*\.rs)"  => "CARGO_REGISTRY/.../$1",
+    // remove time print from GenMC estimation mode output.
+    "\nExpected verification time: .* ± .*" => "\nExpected verification time: [MEAN] ± [SD]",
 }
 
 enum Dependencies {

From 4919d5560120e8dfbf4f93924a2c3dc5d4ed446a Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Thu, 18 Sep 2025 10:50:51 +0200
Subject: [PATCH 1076/1889] fix location for nested bodies in promoteds

---
 compiler/rustc_borrowck/src/type_check/mod.rs | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
index 8c5447fe1e9e7..e05c5b224858b 100644
--- a/compiler/rustc_borrowck/src/type_check/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -505,6 +505,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         let mut constraints = Default::default();
         let mut liveness_constraints =
             LivenessValues::without_specific_points(Rc::new(DenseLocationMap::new(promoted_body)));
+        let mut deferred_closure_requirements = Default::default();
 
         // Don't try to add borrow_region facts for the promoted MIR as they refer
         // to the wrong locations.
@@ -512,6 +513,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             mem::swap(this.polonius_facts, polonius_facts);
             mem::swap(&mut this.constraints.outlives_constraints, &mut constraints);
             mem::swap(&mut this.constraints.liveness_constraints, &mut liveness_constraints);
+            mem::swap(this.deferred_closure_requirements, &mut deferred_closure_requirements);
         };
 
         swap_constraints(self);
@@ -536,6 +538,17 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             }
             self.constraints.outlives_constraints.push(constraint)
         }
+
+        // If there are nested bodies in promoteds, we also need to update their
+        // location to something in the actually body, not the promoted.
+        //
+        // We don't update the constraint categories of the resulting constraints
+        // as returns in nested bodies are a proper return, even if that nested body
+        // is in a promoted.
+        for (closure_def_id, args, _locations) in deferred_closure_requirements {
+            self.deferred_closure_requirements.push((closure_def_id, args, locations));
+        }
+
         // If the region is live at least one location in the promoted MIR,
         // then add a liveness constraint to the main MIR for this region
         // at the location provided as an argument to this method

From 72fb9b28a62e56d266e34764ef7330ca09266f48 Mon Sep 17 00:00:00 2001
From: lukaslueg <lukas.lueg@gmail.com>
Date: Thu, 18 Sep 2025 11:51:29 +0200
Subject: [PATCH 1077/1889] Remove feature-freeze from gh templates

---
 .github/ISSUE_TEMPLATE/new_lint.yml | 4 +---
 .github/PULL_REQUEST_TEMPLATE.md    | 4 ----
 2 files changed, 1 insertion(+), 7 deletions(-)

diff --git a/.github/ISSUE_TEMPLATE/new_lint.yml b/.github/ISSUE_TEMPLATE/new_lint.yml
index a8202f6378fd3..6ad16aead601d 100644
--- a/.github/ISSUE_TEMPLATE/new_lint.yml
+++ b/.github/ISSUE_TEMPLATE/new_lint.yml
@@ -1,7 +1,5 @@
 name: New lint suggestion
-description: |
-  Suggest a new Clippy lint (currently not accepting new lints)
-  Check out the Clippy book for more information about the feature freeze.
+description: Suggest a new Clippy lint.
 labels: ["A-lint"]
 body:
   - type: markdown
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
index 83bfd8e9c6865..9e49f60892d26 100644
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -32,10 +32,6 @@ order to get feedback.
 
 Delete this line and everything above before opening your PR.
 
-Note that we are currently not taking in new PRs that add new lints. We are in a
-feature freeze. Check out the book for more information. If you open a
-feature-adding pull request, its review will be delayed.
-
 ---
 
 *Please write a short comment explaining your change (or "none" for internal only changes)*

From 68473ad11b058ed6a533eec889e28d1695fd2f8f Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Thu, 18 Sep 2025 11:54:58 +0200
Subject: [PATCH 1078/1889] Check that `.unwrap_or(LITERAL)` doesn't trigger
 `unwrap_or_default`

---
 tests/ui/or_fun_call.fixed  | 12 ++++++
 tests/ui/or_fun_call.rs     | 12 ++++++
 tests/ui/or_fun_call.stderr | 76 ++++++++++++++++++-------------------
 3 files changed, 62 insertions(+), 38 deletions(-)

diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index 0a8525a12f5e0..ac771c34ef49f 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -77,6 +77,18 @@ fn or_fun_call() {
     with_default_type.unwrap_or_default();
     //~^ unwrap_or_default
 
+    let with_default_literal = Some(1);
+    with_default_literal.unwrap_or(0);
+    // Do not lint because `.unwrap_or_default()` wouldn't be simpler
+
+    let with_default_literal = Some(1.0);
+    with_default_literal.unwrap_or(0.0);
+    // Do not lint because `.unwrap_or_default()` wouldn't be simpler
+
+    let with_default_literal = Some("foo");
+    with_default_literal.unwrap_or("");
+    // Do not lint because `.unwrap_or_default()` wouldn't be simpler
+
     let self_default = None::<FakeDefault>;
     self_default.unwrap_or_else(<FakeDefault>::default);
     //~^ or_fun_call
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index b4f9b950a7fe0..75762fb020ac0 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -77,6 +77,18 @@ fn or_fun_call() {
     with_default_type.unwrap_or(u64::default());
     //~^ unwrap_or_default
 
+    let with_default_literal = Some(1);
+    with_default_literal.unwrap_or(0);
+    // Do not lint because `.unwrap_or_default()` wouldn't be simpler
+
+    let with_default_literal = Some(1.0);
+    with_default_literal.unwrap_or(0.0);
+    // Do not lint because `.unwrap_or_default()` wouldn't be simpler
+
+    let with_default_literal = Some("foo");
+    with_default_literal.unwrap_or("");
+    // Do not lint because `.unwrap_or_default()` wouldn't be simpler
+
     let self_default = None::<FakeDefault>;
     self_default.unwrap_or(<FakeDefault>::default());
     //~^ or_fun_call
diff --git a/tests/ui/or_fun_call.stderr b/tests/ui/or_fun_call.stderr
index 3e4df772668d7..0f0cd3329b669 100644
--- a/tests/ui/or_fun_call.stderr
+++ b/tests/ui/or_fun_call.stderr
@@ -47,175 +47,175 @@ LL |     with_default_type.unwrap_or(u64::default());
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:81:18
+  --> tests/ui/or_fun_call.rs:93:18
    |
 LL |     self_default.unwrap_or(<FakeDefault>::default());
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(<FakeDefault>::default)`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:85:18
+  --> tests/ui/or_fun_call.rs:97:18
    |
 LL |     real_default.unwrap_or(<FakeDefault as Default>::default());
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:89:14
+  --> tests/ui/or_fun_call.rs:101:14
    |
 LL |     with_vec.unwrap_or(vec![]);
    |              ^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:93:21
+  --> tests/ui/or_fun_call.rs:105:21
    |
 LL |     without_default.unwrap_or(Foo::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(Foo::new)`
 
 error: use of `or_insert` to construct default value
-  --> tests/ui/or_fun_call.rs:97:19
+  --> tests/ui/or_fun_call.rs:109:19
    |
 LL |     map.entry(42).or_insert(String::new());
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert` to construct default value
-  --> tests/ui/or_fun_call.rs:101:23
+  --> tests/ui/or_fun_call.rs:113:23
    |
 LL |     map_vec.entry(42).or_insert(vec![]);
    |                       ^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert` to construct default value
-  --> tests/ui/or_fun_call.rs:105:21
+  --> tests/ui/or_fun_call.rs:117:21
    |
 LL |     btree.entry(42).or_insert(String::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert` to construct default value
-  --> tests/ui/or_fun_call.rs:109:25
+  --> tests/ui/or_fun_call.rs:121:25
    |
 LL |     btree_vec.entry(42).or_insert(vec![]);
    |                         ^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:113:21
+  --> tests/ui/or_fun_call.rs:125:21
    |
 LL |     let _ = stringy.unwrap_or(String::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `ok_or`
-  --> tests/ui/or_fun_call.rs:118:17
+  --> tests/ui/or_fun_call.rs:130:17
    |
 LL |     let _ = opt.ok_or(format!("{} world.", hello));
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `ok_or_else(|| format!("{} world.", hello))`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:123:21
+  --> tests/ui/or_fun_call.rs:135:21
    |
 LL |     let _ = Some(1).unwrap_or(map[&1]);
    |                     ^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| map[&1])`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:126:21
+  --> tests/ui/or_fun_call.rs:138:21
    |
 LL |     let _ = Some(1).unwrap_or(map[&1]);
    |                     ^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| map[&1])`
 
 error: function call inside of `or`
-  --> tests/ui/or_fun_call.rs:151:35
+  --> tests/ui/or_fun_call.rs:163:35
    |
 LL |     let _ = Some("a".to_string()).or(Some("b".to_string()));
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_else(|| Some("b".to_string()))`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:194:18
+  --> tests/ui/or_fun_call.rs:206:18
    |
 LL |             None.unwrap_or(ptr_to_ref(s));
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| ptr_to_ref(s))`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:202:14
+  --> tests/ui/or_fun_call.rs:214:14
    |
 LL |         None.unwrap_or(unsafe { ptr_to_ref(s) });
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| unsafe { ptr_to_ref(s) })`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:205:14
+  --> tests/ui/or_fun_call.rs:217:14
    |
 LL |         None.unwrap_or( unsafe { ptr_to_ref(s) }    );
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| unsafe { ptr_to_ref(s) })`
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:281:25
+  --> tests/ui/or_fun_call.rs:293:25
    |
 LL |         let _ = Some(4).map_or(g(), |v| v);
    |                         ^^^^^^^^^^^^^^^^^^ help: try: `map_or_else(g, |v| v)`
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:283:25
+  --> tests/ui/or_fun_call.rs:295:25
    |
 LL |         let _ = Some(4).map_or(g(), f);
    |                         ^^^^^^^^^^^^^^ help: try: `map_or_else(g, f)`
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:286:25
+  --> tests/ui/or_fun_call.rs:298:25
    |
 LL |         let _ = Some(4).map_or("asd".to_string().len() as i32, f);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map_or_else(|| "asd".to_string().len() as i32, f)`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:317:18
+  --> tests/ui/or_fun_call.rs:329:18
    |
 LL |         with_new.unwrap_or_else(Vec::new);
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:321:28
+  --> tests/ui/or_fun_call.rs:333:28
    |
 LL |         with_default_trait.unwrap_or_else(Default::default);
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:325:27
+  --> tests/ui/or_fun_call.rs:337:27
    |
 LL |         with_default_type.unwrap_or_else(u64::default);
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:329:22
+  --> tests/ui/or_fun_call.rs:341:22
    |
 LL |         real_default.unwrap_or_else(<FakeDefault as Default>::default);
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `or_insert_with` to construct default value
-  --> tests/ui/or_fun_call.rs:333:23
+  --> tests/ui/or_fun_call.rs:345:23
    |
 LL |         map.entry(42).or_insert_with(String::new);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert_with` to construct default value
-  --> tests/ui/or_fun_call.rs:337:25
+  --> tests/ui/or_fun_call.rs:349:25
    |
 LL |         btree.entry(42).or_insert_with(String::new);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:341:25
+  --> tests/ui/or_fun_call.rs:353:25
    |
 LL |         let _ = stringy.unwrap_or_else(String::new);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:383:17
+  --> tests/ui/or_fun_call.rs:395:17
    |
 LL |     let _ = opt.unwrap_or({ f() }); // suggest `.unwrap_or_else(f)`
    |                 ^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(f)`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:388:17
+  --> tests/ui/or_fun_call.rs:400:17
    |
 LL |     let _ = opt.unwrap_or(f() + 1); // suggest `.unwrap_or_else(|| f() + 1)`
    |                 ^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| f() + 1)`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:393:17
+  --> tests/ui/or_fun_call.rs:405:17
    |
 LL |       let _ = opt.unwrap_or({
    |  _________________^
@@ -235,55 +235,55 @@ LL ~     });
    |
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:399:17
+  --> tests/ui/or_fun_call.rs:411:17
    |
 LL |     let _ = opt.map_or(f() + 1, |v| v); // suggest `.map_or_else(|| f() + 1, |v| v)`
    |                 ^^^^^^^^^^^^^^^^^^^^^^ help: try: `map_or_else(|| f() + 1, |v| v)`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:404:17
+  --> tests/ui/or_fun_call.rs:416:17
    |
 LL |     let _ = opt.unwrap_or({ i32::default() });
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:411:21
+  --> tests/ui/or_fun_call.rs:423:21
    |
 LL |     let _ = opt_foo.unwrap_or(Foo { val: String::default() });
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| Foo { val: String::default() })`
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:426:19
+  --> tests/ui/or_fun_call.rs:438:19
    |
 LL |         let _ = x.map_or(g(), |v| v);
    |                   ^^^^^^^^^^^^^^^^^^ help: try: `map_or_else(|_| g(), |v| v)`
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:428:19
+  --> tests/ui/or_fun_call.rs:440:19
    |
 LL |         let _ = x.map_or(g(), f);
    |                   ^^^^^^^^^^^^^^ help: try: `map_or_else(|_| g(), f)`
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:431:19
+  --> tests/ui/or_fun_call.rs:443:19
    |
 LL |         let _ = x.map_or("asd".to_string().len() as i32, f);
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map_or_else(|_| "asd".to_string().len() as i32, f)`
 
 error: function call inside of `get_or_insert`
-  --> tests/ui/or_fun_call.rs:442:15
+  --> tests/ui/or_fun_call.rs:454:15
    |
 LL |     let _ = x.get_or_insert(g());
    |               ^^^^^^^^^^^^^^^^^^ help: try: `get_or_insert_with(g)`
 
 error: function call inside of `and`
-  --> tests/ui/or_fun_call.rs:452:15
+  --> tests/ui/or_fun_call.rs:464:15
    |
 LL |     let _ = x.and(g());
    |               ^^^^^^^^ help: try: `and_then(|_| g())`
 
 error: function call inside of `and`
-  --> tests/ui/or_fun_call.rs:462:15
+  --> tests/ui/or_fun_call.rs:474:15
    |
 LL |     let _ = x.and(g());
    |               ^^^^^^^^ help: try: `and_then(|_| g())`

From ad21dff50ab20a4a8c306eddffc779dfa9b0ee47 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Thu, 18 Sep 2025 11:54:58 +0200
Subject: [PATCH 1079/1889] Do not replace `.unwrap_or(vec![])` by
 `.unwrap_or_default()`

`.unwrap_or(vec![])` is as readable as `.unwrap_or_default()`.
---
 clippy_lints/src/methods/or_fun_call.rs |  7 ++
 tests/ui/or_fun_call.fixed              |  4 ++
 tests/ui/or_fun_call.rs                 | 10 ++-
 tests/ui/or_fun_call.stderr             | 88 ++++++++++++-------------
 4 files changed, 62 insertions(+), 47 deletions(-)

diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 04f0e3c0479e0..71b2f251eded6 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -2,6 +2,7 @@ use std::ops::ControlFlow;
 
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::eager_or_lazy::switch_to_lazy_eval;
+use clippy_utils::higher::VecArgs;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::{expr_type_is_certain, implements_trait, is_type_diagnostic_item};
 use clippy_utils::visitors::for_each_expr;
@@ -97,6 +98,12 @@ pub(super) fn check<'tcx>(
             return false;
         }
 
+        // `.unwrap_or(vec![])` is as readable as `.unwrap_or_default()`. And if the expression is a
+        // non-empty `Vec`, then it will not be a default value anyway. Bail out in all cases.
+        if call_expr.and_then(|call_expr| VecArgs::hir(cx, call_expr)).is_some() {
+            return false;
+        }
+
         // needs to target Default::default in particular or be *::new and have a Default impl
         // available
         if (is_new(fun) && output_type_implements_default(fun))
diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index ac771c34ef49f..7a0be97017ebc 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -89,6 +89,10 @@ fn or_fun_call() {
     with_default_literal.unwrap_or("");
     // Do not lint because `.unwrap_or_default()` wouldn't be simpler
 
+    let with_default_vec_macro = Some(vec![1, 2, 3]);
+    with_default_vec_macro.unwrap_or(vec![]);
+    // Do not lint because `.unwrap_or_default()` wouldn't be simpler
+
     let self_default = None::<FakeDefault>;
     self_default.unwrap_or_else(<FakeDefault>::default);
     //~^ or_fun_call
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index 75762fb020ac0..724af606de9cf 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -89,6 +89,10 @@ fn or_fun_call() {
     with_default_literal.unwrap_or("");
     // Do not lint because `.unwrap_or_default()` wouldn't be simpler
 
+    let with_default_vec_macro = Some(vec![1, 2, 3]);
+    with_default_vec_macro.unwrap_or(vec![]);
+    // Do not lint because `.unwrap_or_default()` wouldn't be simpler
+
     let self_default = None::<FakeDefault>;
     self_default.unwrap_or(<FakeDefault>::default());
     //~^ or_fun_call
@@ -98,7 +102,7 @@ fn or_fun_call() {
     //~^ unwrap_or_default
 
     let with_vec = Some(vec![1]);
-    with_vec.unwrap_or(vec![]);
+    with_vec.unwrap_or(Vec::new());
     //~^ unwrap_or_default
 
     let without_default = Some(Foo);
@@ -110,7 +114,7 @@ fn or_fun_call() {
     //~^ unwrap_or_default
 
     let mut map_vec = HashMap::<u64, Vec<i32>>::new();
-    map_vec.entry(42).or_insert(vec![]);
+    map_vec.entry(42).or_insert(Vec::new());
     //~^ unwrap_or_default
 
     let mut btree = BTreeMap::<u64, String>::new();
@@ -118,7 +122,7 @@ fn or_fun_call() {
     //~^ unwrap_or_default
 
     let mut btree_vec = BTreeMap::<u64, Vec<i32>>::new();
-    btree_vec.entry(42).or_insert(vec![]);
+    btree_vec.entry(42).or_insert(Vec::new());
     //~^ unwrap_or_default
 
     let stringy = Some(String::new());
diff --git a/tests/ui/or_fun_call.stderr b/tests/ui/or_fun_call.stderr
index 0f0cd3329b669..40b25f91154dd 100644
--- a/tests/ui/or_fun_call.stderr
+++ b/tests/ui/or_fun_call.stderr
@@ -47,175 +47,175 @@ LL |     with_default_type.unwrap_or(u64::default());
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:93:18
+  --> tests/ui/or_fun_call.rs:97:18
    |
 LL |     self_default.unwrap_or(<FakeDefault>::default());
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(<FakeDefault>::default)`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:97:18
+  --> tests/ui/or_fun_call.rs:101:18
    |
 LL |     real_default.unwrap_or(<FakeDefault as Default>::default());
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:101:14
+  --> tests/ui/or_fun_call.rs:105:14
    |
-LL |     with_vec.unwrap_or(vec![]);
-   |              ^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
+LL |     with_vec.unwrap_or(Vec::new());
+   |              ^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:105:21
+  --> tests/ui/or_fun_call.rs:109:21
    |
 LL |     without_default.unwrap_or(Foo::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(Foo::new)`
 
 error: use of `or_insert` to construct default value
-  --> tests/ui/or_fun_call.rs:109:19
+  --> tests/ui/or_fun_call.rs:113:19
    |
 LL |     map.entry(42).or_insert(String::new());
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert` to construct default value
-  --> tests/ui/or_fun_call.rs:113:23
+  --> tests/ui/or_fun_call.rs:117:23
    |
-LL |     map_vec.entry(42).or_insert(vec![]);
-   |                       ^^^^^^^^^^^^^^^^^ help: try: `or_default()`
+LL |     map_vec.entry(42).or_insert(Vec::new());
+   |                       ^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert` to construct default value
-  --> tests/ui/or_fun_call.rs:117:21
+  --> tests/ui/or_fun_call.rs:121:21
    |
 LL |     btree.entry(42).or_insert(String::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert` to construct default value
-  --> tests/ui/or_fun_call.rs:121:25
+  --> tests/ui/or_fun_call.rs:125:25
    |
-LL |     btree_vec.entry(42).or_insert(vec![]);
-   |                         ^^^^^^^^^^^^^^^^^ help: try: `or_default()`
+LL |     btree_vec.entry(42).or_insert(Vec::new());
+   |                         ^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:125:21
+  --> tests/ui/or_fun_call.rs:129:21
    |
 LL |     let _ = stringy.unwrap_or(String::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `ok_or`
-  --> tests/ui/or_fun_call.rs:130:17
+  --> tests/ui/or_fun_call.rs:134:17
    |
 LL |     let _ = opt.ok_or(format!("{} world.", hello));
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `ok_or_else(|| format!("{} world.", hello))`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:135:21
+  --> tests/ui/or_fun_call.rs:139:21
    |
 LL |     let _ = Some(1).unwrap_or(map[&1]);
    |                     ^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| map[&1])`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:138:21
+  --> tests/ui/or_fun_call.rs:142:21
    |
 LL |     let _ = Some(1).unwrap_or(map[&1]);
    |                     ^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| map[&1])`
 
 error: function call inside of `or`
-  --> tests/ui/or_fun_call.rs:163:35
+  --> tests/ui/or_fun_call.rs:167:35
    |
 LL |     let _ = Some("a".to_string()).or(Some("b".to_string()));
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_else(|| Some("b".to_string()))`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:206:18
+  --> tests/ui/or_fun_call.rs:210:18
    |
 LL |             None.unwrap_or(ptr_to_ref(s));
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| ptr_to_ref(s))`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:214:14
+  --> tests/ui/or_fun_call.rs:218:14
    |
 LL |         None.unwrap_or(unsafe { ptr_to_ref(s) });
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| unsafe { ptr_to_ref(s) })`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:217:14
+  --> tests/ui/or_fun_call.rs:221:14
    |
 LL |         None.unwrap_or( unsafe { ptr_to_ref(s) }    );
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| unsafe { ptr_to_ref(s) })`
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:293:25
+  --> tests/ui/or_fun_call.rs:297:25
    |
 LL |         let _ = Some(4).map_or(g(), |v| v);
    |                         ^^^^^^^^^^^^^^^^^^ help: try: `map_or_else(g, |v| v)`
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:295:25
+  --> tests/ui/or_fun_call.rs:299:25
    |
 LL |         let _ = Some(4).map_or(g(), f);
    |                         ^^^^^^^^^^^^^^ help: try: `map_or_else(g, f)`
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:298:25
+  --> tests/ui/or_fun_call.rs:302:25
    |
 LL |         let _ = Some(4).map_or("asd".to_string().len() as i32, f);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map_or_else(|| "asd".to_string().len() as i32, f)`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:329:18
+  --> tests/ui/or_fun_call.rs:333:18
    |
 LL |         with_new.unwrap_or_else(Vec::new);
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:333:28
+  --> tests/ui/or_fun_call.rs:337:28
    |
 LL |         with_default_trait.unwrap_or_else(Default::default);
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:337:27
+  --> tests/ui/or_fun_call.rs:341:27
    |
 LL |         with_default_type.unwrap_or_else(u64::default);
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:341:22
+  --> tests/ui/or_fun_call.rs:345:22
    |
 LL |         real_default.unwrap_or_else(<FakeDefault as Default>::default);
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `or_insert_with` to construct default value
-  --> tests/ui/or_fun_call.rs:345:23
+  --> tests/ui/or_fun_call.rs:349:23
    |
 LL |         map.entry(42).or_insert_with(String::new);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert_with` to construct default value
-  --> tests/ui/or_fun_call.rs:349:25
+  --> tests/ui/or_fun_call.rs:353:25
    |
 LL |         btree.entry(42).or_insert_with(String::new);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:353:25
+  --> tests/ui/or_fun_call.rs:357:25
    |
 LL |         let _ = stringy.unwrap_or_else(String::new);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:395:17
+  --> tests/ui/or_fun_call.rs:399:17
    |
 LL |     let _ = opt.unwrap_or({ f() }); // suggest `.unwrap_or_else(f)`
    |                 ^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(f)`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:400:17
+  --> tests/ui/or_fun_call.rs:404:17
    |
 LL |     let _ = opt.unwrap_or(f() + 1); // suggest `.unwrap_or_else(|| f() + 1)`
    |                 ^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| f() + 1)`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:405:17
+  --> tests/ui/or_fun_call.rs:409:17
    |
 LL |       let _ = opt.unwrap_or({
    |  _________________^
@@ -235,55 +235,55 @@ LL ~     });
    |
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:411:17
+  --> tests/ui/or_fun_call.rs:415:17
    |
 LL |     let _ = opt.map_or(f() + 1, |v| v); // suggest `.map_or_else(|| f() + 1, |v| v)`
    |                 ^^^^^^^^^^^^^^^^^^^^^^ help: try: `map_or_else(|| f() + 1, |v| v)`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:416:17
+  --> tests/ui/or_fun_call.rs:420:17
    |
 LL |     let _ = opt.unwrap_or({ i32::default() });
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:423:21
+  --> tests/ui/or_fun_call.rs:427:21
    |
 LL |     let _ = opt_foo.unwrap_or(Foo { val: String::default() });
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| Foo { val: String::default() })`
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:438:19
+  --> tests/ui/or_fun_call.rs:442:19
    |
 LL |         let _ = x.map_or(g(), |v| v);
    |                   ^^^^^^^^^^^^^^^^^^ help: try: `map_or_else(|_| g(), |v| v)`
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:440:19
+  --> tests/ui/or_fun_call.rs:444:19
    |
 LL |         let _ = x.map_or(g(), f);
    |                   ^^^^^^^^^^^^^^ help: try: `map_or_else(|_| g(), f)`
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:443:19
+  --> tests/ui/or_fun_call.rs:447:19
    |
 LL |         let _ = x.map_or("asd".to_string().len() as i32, f);
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map_or_else(|_| "asd".to_string().len() as i32, f)`
 
 error: function call inside of `get_or_insert`
-  --> tests/ui/or_fun_call.rs:454:15
+  --> tests/ui/or_fun_call.rs:458:15
    |
 LL |     let _ = x.get_or_insert(g());
    |               ^^^^^^^^^^^^^^^^^^ help: try: `get_or_insert_with(g)`
 
 error: function call inside of `and`
-  --> tests/ui/or_fun_call.rs:464:15
+  --> tests/ui/or_fun_call.rs:468:15
    |
 LL |     let _ = x.and(g());
    |               ^^^^^^^^ help: try: `and_then(|_| g())`
 
 error: function call inside of `and`
-  --> tests/ui/or_fun_call.rs:474:15
+  --> tests/ui/or_fun_call.rs:478:15
    |
 LL |     let _ = x.and(g());
    |               ^^^^^^^^ help: try: `and_then(|_| g())`

From f4e19c68786211f3c3cf2593442629599678800a Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Thu, 11 Sep 2025 13:08:36 +0200
Subject: [PATCH 1080/1889] support calls on opaque types :<

---
 compiler/rustc_hir_analysis/src/autoderef.rs  |  15 ++-
 compiler/rustc_hir_typeck/src/callee.rs       |  26 +++-
 .../rustc_hir_typeck/src/fn_ctxt/_impl.rs     |  37 +++---
 compiler/rustc_hir_typeck/src/method/mod.rs   |  29 ++++-
 compiler/rustc_hir_typeck/src/op.rs           |  15 ++-
 compiler/rustc_hir_typeck/src/place_op.rs     |  28 ++++-
 compiler/rustc_infer/src/infer/context.rs     |   3 +
 compiler/rustc_infer/src/infer/mod.rs         |  54 ++++++++
 .../src/solve/assembly/mod.rs                 |  40 ++++--
 .../src/solve/eval_ctxt/canonical.rs          |  25 ++--
 .../src/solve/eval_ctxt/mod.rs                |  76 +++++++-----
 .../rustc_next_trait_solver/src/solve/mod.rs  |  35 +++---
 .../src/solve/search_graph.rs                 |   2 +-
 .../src/solve/fulfill.rs                      |   4 +-
 .../src/solve/fulfill/derive_errors.rs        |  22 ++--
 .../src/solve/inspect/analyse.rs              |   2 +-
 .../rustc_trait_selection/src/solve/select.rs |   8 +-
 .../src/traits/coherence.rs                   |   2 +-
 .../src/traits/query/evaluate_obligation.rs   |  17 +++
 compiler/rustc_type_ir/src/infer_ctxt.rs      |   3 +-
 compiler/rustc_type_ir/src/solve/mod.rs       |  80 +++++++++++-
 .../ambiguous-ops.current.stderr              |  62 ++++++++++
 .../non-defining-uses/ambiguous-ops.rs        | 117 ++++++++++++++++++
 .../function-call-on-infer.rs                 |  73 +++++++++++
 .../impl-deref-function-call.rs               |  56 +++++++++
 .../shex_compat-regression-test.rs            |  19 +++
 .../return-block-type-inference-15965.stderr  |   6 +-
 ...oxed-closures-failed-recursive-fn-2.stderr |   2 +-
 28 files changed, 734 insertions(+), 124 deletions(-)
 create mode 100644 tests/ui/impl-trait/non-defining-uses/ambiguous-ops.current.stderr
 create mode 100644 tests/ui/impl-trait/non-defining-uses/ambiguous-ops.rs
 create mode 100644 tests/ui/impl-trait/non-defining-uses/function-call-on-infer.rs
 create mode 100644 tests/ui/impl-trait/non-defining-uses/impl-deref-function-call.rs
 create mode 100644 tests/ui/impl-trait/non-defining-uses/shex_compat-regression-test.rs

diff --git a/compiler/rustc_hir_analysis/src/autoderef.rs b/compiler/rustc_hir_analysis/src/autoderef.rs
index e8237471e1b68..88bd3339e4e18 100644
--- a/compiler/rustc_hir_analysis/src/autoderef.rs
+++ b/compiler/rustc_hir_analysis/src/autoderef.rs
@@ -68,7 +68,14 @@ impl<'a, 'tcx> Iterator for Autoderef<'a, 'tcx> {
             return None;
         }
 
-        if self.state.cur_ty.is_ty_var() {
+        // We want to support method and function calls for `impl Deref<Target = ..>`.
+        //
+        // To do so we don't eagerly bail if the current type is the hidden type of an
+        // opaque type and instead return `None` in `fn overloaded_deref_ty` if the
+        // opaque does not have a `Deref` item-bound.
+        if let &ty::Infer(ty::TyVar(vid)) = self.state.cur_ty.kind()
+            && !self.infcx.has_opaques_with_sub_unified_hidden_type(vid)
+        {
             return None;
         }
 
@@ -160,7 +167,11 @@ impl<'a, 'tcx> Autoderef<'a, 'tcx> {
             self.param_env,
             ty::Binder::dummy(trait_ref),
         );
-        if !self.infcx.next_trait_solver() && !self.infcx.predicate_may_hold(&obligation) {
+        // We detect whether the self type implements `Deref` before trying to
+        // structurally normalize. We use `predicate_may_hold_opaque_types_jank`
+        // to support not-yet-defined opaque types. It will succeed for `impl Deref`
+        // but fail for `impl OtherTrait`.
+        if !self.infcx.predicate_may_hold_opaque_types_jank(&obligation) {
             debug!("overloaded_deref_ty: cannot match obligation");
             return None;
         }
diff --git a/compiler/rustc_hir_typeck/src/callee.rs b/compiler/rustc_hir_typeck/src/callee.rs
index c6a4d78dcc830..f59fcab46661f 100644
--- a/compiler/rustc_hir_typeck/src/callee.rs
+++ b/compiler/rustc_hir_typeck/src/callee.rs
@@ -25,6 +25,7 @@ use tracing::{debug, instrument};
 use super::method::MethodCallee;
 use super::method::probe::ProbeScope;
 use super::{Expectation, FnCtxt, TupleArgumentsFlag};
+use crate::method::TreatNotYetDefinedOpaques;
 use crate::{errors, fluent_generated};
 
 /// Checks that it is legal to call methods of the trait corresponding
@@ -78,7 +79,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             _ => self.check_expr(callee_expr),
         };
 
-        let expr_ty = self.structurally_resolve_type(call_expr.span, original_callee_ty);
+        let expr_ty = self.try_structurally_resolve_type(call_expr.span, original_callee_ty);
 
         let mut autoderef = self.autoderef(callee_expr.span, expr_ty);
         let mut result = None;
@@ -200,7 +201,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         arg_exprs: &'tcx [hir::Expr<'tcx>],
         autoderef: &Autoderef<'a, 'tcx>,
     ) -> Option<CallStep<'tcx>> {
-        let adjusted_ty = self.structurally_resolve_type(autoderef.span(), autoderef.final_ty());
+        let adjusted_ty =
+            self.try_structurally_resolve_type(autoderef.span(), autoderef.final_ty());
 
         // If the callee is a function pointer or a closure, then we're all set.
         match *adjusted_ty.kind() {
@@ -297,6 +299,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 return None;
             }
 
+            ty::Infer(ty::TyVar(vid)) => {
+                // If we end up with an inference variable which is not the hidden type of
+                // an opaque, emit an error.
+                if !self.has_opaques_with_sub_unified_hidden_type(vid) {
+                    self.type_must_be_known_at_this_point(autoderef.span(), adjusted_ty);
+                    return None;
+                }
+            }
+
             ty::Error(_) => {
                 return None;
             }
@@ -367,26 +378,33 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 Ty::new_tup_from_iter(self.tcx, arg_exprs.iter().map(|e| self.next_ty_var(e.span)))
             });
 
+            // We use `TreatNotYetDefinedOpaques::AsRigid` here so that if the `adjusted_ty`
+            // is `Box<impl FnOnce()>` we choose  `FnOnce` instead of `Fn`.
+            //
+            // We try all the different call traits in order and choose the first
+            // one which may apply. So if we treat opaques as inference variables
+            // `Box<impl FnOnce()>: Fn` is considered ambiguous and chosen.
             if let Some(ok) = self.lookup_method_for_operator(
                 self.misc(call_expr.span),
                 method_name,
                 trait_def_id,
                 adjusted_ty,
                 opt_input_type,
+                TreatNotYetDefinedOpaques::AsRigid,
             ) {
                 let method = self.register_infer_ok_obligations(ok);
                 let mut autoref = None;
                 if borrow {
                     // Check for &self vs &mut self in the method signature. Since this is either
                     // the Fn or FnMut trait, it should be one of those.
-                    let ty::Ref(_, _, mutbl) = method.sig.inputs()[0].kind() else {
+                    let ty::Ref(_, _, mutbl) = *method.sig.inputs()[0].kind() else {
                         bug!("Expected `FnMut`/`Fn` to take receiver by-ref/by-mut")
                     };
 
                     // For initial two-phase borrow
                     // deployment, conservatively omit
                     // overloaded function call ops.
-                    let mutbl = AutoBorrowMutability::new(*mutbl, AllowTwoPhase::No);
+                    let mutbl = AutoBorrowMutability::new(mutbl, AllowTwoPhase::No);
 
                     autoref = Some(Adjustment {
                         kind: Adjust::Borrow(AutoBorrow::Ref(mutbl)),
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
index 7370124e800da..3444523974af2 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -1469,24 +1469,25 @@ impl<'a, 'tcx> FnCtxt<'a, '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() {
-            ty
-        } else {
-            let e = self.tainted_by_errors().unwrap_or_else(|| {
-                self.err_ctxt()
-                    .emit_inference_failure_err(
-                        self.body_id,
-                        sp,
-                        ty.into(),
-                        TypeAnnotationNeeded::E0282,
-                        true,
-                    )
-                    .emit()
-            });
-            let err = Ty::new_error(self.tcx, e);
-            self.demand_suptype(sp, err, ty);
-            err
-        }
+        if !ty.is_ty_var() { ty } else { self.type_must_be_known_at_this_point(sp, ty) }
+    }
+
+    #[cold]
+    pub(crate) fn type_must_be_known_at_this_point(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
+        let guar = self.tainted_by_errors().unwrap_or_else(|| {
+            self.err_ctxt()
+                .emit_inference_failure_err(
+                    self.body_id,
+                    sp,
+                    ty.into(),
+                    TypeAnnotationNeeded::E0282,
+                    true,
+                )
+                .emit()
+        });
+        let err = Ty::new_error(self.tcx, guar);
+        self.demand_suptype(sp, err, ty);
+        err
     }
 
     pub(crate) fn structurally_resolve_const(
diff --git a/compiler/rustc_hir_typeck/src/method/mod.rs b/compiler/rustc_hir_typeck/src/method/mod.rs
index 652644ad78cce..04f112e4a39cc 100644
--- a/compiler/rustc_hir_typeck/src/method/mod.rs
+++ b/compiler/rustc_hir_typeck/src/method/mod.rs
@@ -317,7 +317,26 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         )?;
         Ok(pick)
     }
+}
+
+/// Used by [FnCtxt::lookup_method_for_operator] with `-Znext-solver`.
+///
+/// With `AsRigid` we error on `impl Opaque: NotInItemBounds` while
+/// `AsInfer` just treats it as ambiguous and succeeds. This is necessary
+/// as we want [FnCtxt::check_expr_call] to treat not-yet-defined opaque
+/// types as rigid to support `impl Deref<Target = impl FnOnce()>` and
+/// `Box<impl FnOnce()>`.
+///
+/// We only want to treat opaque types as rigid if we need to eagerly choose
+/// between multiple candidates. We otherwise treat them as ordinary inference
+/// variable to avoid rejecting otherwise correct code.
+#[derive(Debug)]
+pub(super) enum TreatNotYetDefinedOpaques {
+    AsInfer,
+    AsRigid,
+}
 
+impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     /// `lookup_method_in_trait` is used for overloaded operators.
     /// It does a very narrow slice of what the normal probe/confirm path does.
     /// In particular, it doesn't really do any probing: it simply constructs
@@ -331,6 +350,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         trait_def_id: DefId,
         self_ty: Ty<'tcx>,
         opt_rhs_ty: Option<Ty<'tcx>>,
+        treat_opaques: TreatNotYetDefinedOpaques,
     ) -> Option<InferOk<'tcx, MethodCallee<'tcx>>> {
         // Construct a trait-reference `self_ty : Trait<input_tys>`
         let args = GenericArgs::for_item(self.tcx, trait_def_id, |param, _| match param.kind {
@@ -360,7 +380,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         );
 
         // Now we want to know if this can be matched
-        if !self.predicate_may_hold(&obligation) {
+        let matches_trait = match treat_opaques {
+            TreatNotYetDefinedOpaques::AsInfer => self.predicate_may_hold(&obligation),
+            TreatNotYetDefinedOpaques::AsRigid => {
+                self.predicate_may_hold_opaque_types_jank(&obligation)
+            }
+        };
+
+        if !matches_trait {
             debug!("--> Cannot match obligation");
             // Cannot be matched, no such method resolution is possible.
             return None;
diff --git a/compiler/rustc_hir_typeck/src/op.rs b/compiler/rustc_hir_typeck/src/op.rs
index 11defc3aa0339..054435379434c 100644
--- a/compiler/rustc_hir_typeck/src/op.rs
+++ b/compiler/rustc_hir_typeck/src/op.rs
@@ -21,6 +21,7 @@ use {rustc_ast as ast, rustc_hir as hir};
 use super::FnCtxt;
 use super::method::MethodCallee;
 use crate::Expectation;
+use crate::method::TreatNotYetDefinedOpaques;
 
 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     /// Checks a `a <op>= b`
@@ -974,8 +975,18 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             },
         );
 
-        let method =
-            self.lookup_method_for_operator(cause.clone(), opname, trait_did, lhs_ty, opt_rhs_ty);
+        // We don't consider any other candidates if this lookup fails
+        // so we can freely treat opaque types as inference variables here
+        // to allow more code to compile.
+        let treat_opaques = TreatNotYetDefinedOpaques::AsInfer;
+        let method = self.lookup_method_for_operator(
+            cause.clone(),
+            opname,
+            trait_did,
+            lhs_ty,
+            opt_rhs_ty,
+            treat_opaques,
+        );
         match method {
             Some(ok) => {
                 let method = self.register_infer_ok_obligations(ok);
diff --git a/compiler/rustc_hir_typeck/src/place_op.rs b/compiler/rustc_hir_typeck/src/place_op.rs
index 1125e98408045..a48db2cc855c0 100644
--- a/compiler/rustc_hir_typeck/src/place_op.rs
+++ b/compiler/rustc_hir_typeck/src/place_op.rs
@@ -12,7 +12,7 @@ use rustc_span::{Span, sym};
 use tracing::debug;
 use {rustc_ast as ast, rustc_hir as hir};
 
-use crate::method::MethodCallee;
+use crate::method::{MethodCallee, TreatNotYetDefinedOpaques};
 use crate::{FnCtxt, PlaceOp};
 
 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
@@ -210,7 +210,17 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             return None;
         };
 
-        self.lookup_method_for_operator(self.misc(span), imm_op, imm_tr, base_ty, opt_rhs_ty)
+        // FIXME(trait-system-refactor-initiative#231): we may want to treat
+        // opaque types as rigid here to support `impl Deref<Target = impl Index<usize>>`.
+        let treat_opaques = TreatNotYetDefinedOpaques::AsInfer;
+        self.lookup_method_for_operator(
+            self.misc(span),
+            imm_op,
+            imm_tr,
+            base_ty,
+            opt_rhs_ty,
+            treat_opaques,
+        )
     }
 
     fn try_mutable_overloaded_place_op(
@@ -230,7 +240,19 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             return None;
         };
 
-        self.lookup_method_for_operator(self.misc(span), mut_op, mut_tr, base_ty, opt_rhs_ty)
+        // We have to replace the operator with the mutable variant for the
+        // program to compile, so we don't really have a choice here and want
+        // to just try using `DerefMut` even if its not in the item bounds
+        // of the opaque.
+        let treat_opaques = TreatNotYetDefinedOpaques::AsInfer;
+        self.lookup_method_for_operator(
+            self.misc(span),
+            mut_op,
+            mut_tr,
+            base_ty,
+            opt_rhs_ty,
+            treat_opaques,
+        )
     }
 
     /// Convert auto-derefs, indices, etc of an expression from `Deref` and `Index`
diff --git a/compiler/rustc_infer/src/infer/context.rs b/compiler/rustc_infer/src/infer/context.rs
index 14cc590720ac5..5ffa7304efaff 100644
--- a/compiler/rustc_infer/src/infer/context.rs
+++ b/compiler/rustc_infer/src/infer/context.rs
@@ -302,6 +302,9 @@ impl<'tcx> rustc_type_ir::InferCtxtLike for InferCtxt<'tcx> {
             .map(|(k, h)| (k, h.ty))
             .collect()
     }
+    fn opaques_with_sub_unified_hidden_type(&self, ty: ty::TyVid) -> Vec<ty::AliasTy<'tcx>> {
+        self.opaques_with_sub_unified_hidden_type(ty)
+    }
 
     fn register_hidden_type_in_storage(
         &self,
diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
index 9d3886aff1c1a..c9fc124d3bf8d 100644
--- a/compiler/rustc_infer/src/infer/mod.rs
+++ b/compiler/rustc_infer/src/infer/mod.rs
@@ -1004,6 +1004,60 @@ impl<'tcx> InferCtxt<'tcx> {
         self.inner.borrow_mut().opaque_type_storage.iter_opaque_types().collect()
     }
 
+    pub fn has_opaques_with_sub_unified_hidden_type(&self, ty_vid: TyVid) -> bool {
+        if !self.next_trait_solver() {
+            return false;
+        }
+
+        let ty_sub_vid = self.sub_unification_table_root_var(ty_vid);
+        let inner = &mut *self.inner.borrow_mut();
+        let mut type_variables = inner.type_variable_storage.with_log(&mut inner.undo_log);
+        inner.opaque_type_storage.iter_opaque_types().any(|(_, hidden_ty)| {
+            if let ty::Infer(ty::TyVar(hidden_vid)) = *hidden_ty.ty.kind() {
+                let opaque_sub_vid = type_variables.sub_unification_table_root_var(hidden_vid);
+                if opaque_sub_vid == ty_sub_vid {
+                    return true;
+                }
+            }
+
+            false
+        })
+    }
+
+    /// Searches for an opaque type key whose hidden type is related to `ty_vid`.
+    ///
+    /// This only checks for a subtype relation, it does not require equality.
+    pub fn opaques_with_sub_unified_hidden_type(&self, ty_vid: TyVid) -> Vec<ty::AliasTy<'tcx>> {
+        // Avoid accidentally allowing more code to compile with the old solver.
+        if !self.next_trait_solver() {
+            return vec![];
+        }
+
+        let ty_sub_vid = self.sub_unification_table_root_var(ty_vid);
+        let inner = &mut *self.inner.borrow_mut();
+        // This is iffy, can't call `type_variables()` as we're already
+        // borrowing the `opaque_type_storage` here.
+        let mut type_variables = inner.type_variable_storage.with_log(&mut inner.undo_log);
+        inner
+            .opaque_type_storage
+            .iter_opaque_types()
+            .filter_map(|(key, hidden_ty)| {
+                if let ty::Infer(ty::TyVar(hidden_vid)) = *hidden_ty.ty.kind() {
+                    let opaque_sub_vid = type_variables.sub_unification_table_root_var(hidden_vid);
+                    if opaque_sub_vid == ty_sub_vid {
+                        return Some(ty::AliasTy::new_from_args(
+                            self.tcx,
+                            key.def_id.into(),
+                            key.args,
+                        ));
+                    }
+                }
+
+                None
+            })
+            .collect()
+    }
+
     #[inline(always)]
     pub fn can_define_opaque_ty(&self, id: impl Into<DefId>) -> bool {
         debug_assert!(!self.next_trait_solver());
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 fb777496e31eb..62dea547890b4 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
@@ -23,7 +23,8 @@ use crate::delegate::SolverDelegate;
 use crate::solve::inspect::ProbeKind;
 use crate::solve::{
     BuiltinImplSource, CandidateSource, CanonicalResponse, Certainty, EvalCtxt, Goal, GoalSource,
-    MaybeCause, NoSolution, ParamEnvSource, QueryResult, has_no_inference_or_external_constraints,
+    MaybeCause, NoSolution, OpaqueTypesJank, ParamEnvSource, QueryResult,
+    has_no_inference_or_external_constraints,
 };
 
 enum AliasBoundKind {
@@ -474,7 +475,7 @@ where
         //
         // cc trait-system-refactor-initiative#105
         let source = CandidateSource::BuiltinImpl(BuiltinImplSource::Misc);
-        let certainty = Certainty::Maybe(cause);
+        let certainty = Certainty::Maybe { cause, opaque_types_jank: OpaqueTypesJank::AllGood };
         self.probe_trait_candidate(source)
             .enter(|this| this.evaluate_added_goals_and_make_canonical_response(certainty))
     }
@@ -974,11 +975,21 @@ where
         candidates: &mut Vec<Candidate<I>>,
     ) {
         let self_ty = goal.predicate.self_ty();
-        // If the self type is sub unified with any opaque type, we
-        // also look at blanket impls for it.
-        let mut assemble_blanket_impls = false;
-        for alias_ty in self.opaques_with_sub_unified_hidden_type(self_ty) {
-            assemble_blanket_impls = true;
+        // We only use this hack during HIR typeck.
+        let opaque_types = match self.typing_mode() {
+            TypingMode::Analysis { .. } => self.opaques_with_sub_unified_hidden_type(self_ty),
+            TypingMode::Coherence
+            | TypingMode::Borrowck { .. }
+            | TypingMode::PostBorrowckAnalysis { .. }
+            | TypingMode::PostAnalysis => vec![],
+        };
+
+        if opaque_types.is_empty() {
+            candidates.extend(self.forced_ambiguity(MaybeCause::Ambiguity));
+            return;
+        }
+
+        for &alias_ty in &opaque_types {
             debug!("self ty is sub unified with {alias_ty:?}");
 
             struct ReplaceOpaque<I: Interner> {
@@ -1028,10 +1039,11 @@ where
             }
         }
 
-        // We also need to consider blanket impls for not-yet-defined opaque types.
+        // If the self type is sub unified with any opaque type, we also look at blanket
+        // impls for it.
         //
         // See tests/ui/impl-trait/non-defining-uses/use-blanket-impl.rs for an example.
-        if assemble_blanket_impls && assemble_from.should_assemble_impl_candidates() {
+        if assemble_from.should_assemble_impl_candidates() {
             let cx = self.cx();
             cx.for_each_blanket_impl(goal.predicate.trait_def_id(cx), |impl_def_id| {
                 // For every `default impl`, there's always a non-default `impl`
@@ -1062,7 +1074,15 @@ where
         }
 
         if candidates.is_empty() {
-            candidates.extend(self.forced_ambiguity(MaybeCause::Ambiguity));
+            let source = CandidateSource::BuiltinImpl(BuiltinImplSource::Misc);
+            let certainty = Certainty::Maybe {
+                cause: MaybeCause::Ambiguity,
+                opaque_types_jank: OpaqueTypesJank::ErrorIfRigidSelfTy,
+            };
+            candidates
+                .extend(self.probe_trait_candidate(source).enter(|this| {
+                    this.evaluate_added_goals_and_make_canonical_response(certainty)
+                }));
         }
     }
 
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs
index 169832ca5fbde..889588afe61ff 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs
@@ -15,6 +15,7 @@ use rustc_index::IndexVec;
 use rustc_type_ir::data_structures::HashSet;
 use rustc_type_ir::inherent::*;
 use rustc_type_ir::relate::solver_relating::RelateExt;
+use rustc_type_ir::solve::OpaqueTypesJank;
 use rustc_type_ir::{
     self as ty, Canonical, CanonicalVarKind, CanonicalVarValues, InferCtxtLike, Interner,
     TypeFoldable,
@@ -141,8 +142,10 @@ where
                 }
             };
 
-        if let Certainty::Maybe(cause @ MaybeCause::Overflow { keep_constraints: false, .. }) =
-            certainty
+        if let Certainty::Maybe {
+            cause: cause @ MaybeCause::Overflow { keep_constraints: false, .. },
+            opaque_types_jank,
+        } = certainty
         {
             // If we have overflow, it's probable that we're substituting a type
             // into itself infinitely and any partial substitutions in the query
@@ -155,7 +158,7 @@ where
             //
             // Changing this to retain some constraints in the future
             // won't be a breaking change, so this is good enough for now.
-            return Ok(self.make_ambiguous_response_no_constraints(cause));
+            return Ok(self.make_ambiguous_response_no_constraints(cause, opaque_types_jank));
         }
 
         let external_constraints =
@@ -199,10 +202,13 @@ where
                     .count();
                 if num_non_region_vars > self.cx().recursion_limit() {
                     debug!(?num_non_region_vars, "too many inference variables -> overflow");
-                    return Ok(self.make_ambiguous_response_no_constraints(MaybeCause::Overflow {
-                        suggest_increasing_limit: true,
-                        keep_constraints: false,
-                    }));
+                    return Ok(self.make_ambiguous_response_no_constraints(
+                        MaybeCause::Overflow {
+                            suggest_increasing_limit: true,
+                            keep_constraints: false,
+                        },
+                        OpaqueTypesJank::AllGood,
+                    ));
                 }
             }
         }
@@ -216,13 +222,14 @@ where
     /// ambiguity but return constrained variables to guide inference.
     pub(in crate::solve) fn make_ambiguous_response_no_constraints(
         &self,
-        maybe_cause: MaybeCause,
+        cause: MaybeCause,
+        opaque_types_jank: OpaqueTypesJank,
     ) -> CanonicalResponse<I> {
         response_no_constraints_raw(
             self.cx(),
             self.max_input_universe,
             self.variables,
-            Certainty::Maybe(maybe_cause),
+            Certainty::Maybe { cause, opaque_types_jank },
         )
     }
 
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
index 3e3a5246f3d76..5df7c92d88145 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
@@ -8,6 +8,7 @@ use rustc_type_ir::inherent::*;
 use rustc_type_ir::relate::Relate;
 use rustc_type_ir::relate::solver_relating::RelateExt;
 use rustc_type_ir::search_graph::{CandidateHeadUsages, PathKind};
+use rustc_type_ir::solve::OpaqueTypesJank;
 use rustc_type_ir::{
     self as ty, CanonicalVarValues, InferCtxtLike, Interner, TypeFoldable, TypeFolder,
     TypeSuperFoldable, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor,
@@ -151,6 +152,15 @@ pub trait SolverDelegateEvalExt: SolverDelegate {
         stalled_on: Option<GoalStalledOn<Self::Interner>>,
     ) -> Result<GoalEvaluation<Self::Interner>, NoSolution>;
 
+    /// Checks whether evaluating `goal` may hold while treating not-yet-defined
+    /// opaque types as being kind of rigid.
+    ///
+    /// See the comment on [OpaqueTypesJank] for more details.
+    fn root_goal_may_hold_opaque_types_jank(
+        &self,
+        goal: Goal<Self::Interner, <Self::Interner as Interner>::Predicate>,
+    ) -> bool;
+
     /// Check whether evaluating `goal` with a depth of `root_depth` may
     /// succeed. This only returns `false` if the goal is guaranteed to
     /// not hold. In case evaluation overflows and fails with ambiguity this
@@ -193,6 +203,24 @@ where
         })
     }
 
+    fn root_goal_may_hold_opaque_types_jank(
+        &self,
+        goal: Goal<Self::Interner, <Self::Interner as Interner>::Predicate>,
+    ) -> bool {
+        self.probe(|| {
+            EvalCtxt::enter_root(self, self.cx().recursion_limit(), I::Span::dummy(), |ecx| {
+                ecx.evaluate_goal(GoalSource::Misc, goal, None)
+            })
+            .is_ok_and(|r| match r.certainty {
+                Certainty::Yes => true,
+                Certainty::Maybe { cause: _, opaque_types_jank } => match opaque_types_jank {
+                    OpaqueTypesJank::AllGood => true,
+                    OpaqueTypesJank::ErrorIfRigidSelfTy => false,
+                },
+            })
+        })
+    }
+
     fn root_goal_may_hold_with_depth(
         &self,
         root_depth: usize,
@@ -407,8 +435,12 @@ where
         // If we have run this goal before, and it was stalled, check that any of the goal's
         // args have changed. Otherwise, we don't need to re-run the goal because it'll remain
         // stalled, since it'll canonicalize the same way and evaluation is pure.
-        if let Some(GoalStalledOn { num_opaques, ref stalled_vars, ref sub_roots, stalled_cause }) =
-            stalled_on
+        if let Some(GoalStalledOn {
+            num_opaques,
+            ref stalled_vars,
+            ref sub_roots,
+            stalled_certainty,
+        }) = stalled_on
             && !stalled_vars.iter().any(|value| self.delegate.is_changed_arg(*value))
             && !sub_roots
                 .iter()
@@ -419,7 +451,7 @@ where
                 NestedNormalizationGoals::empty(),
                 GoalEvaluation {
                     goal,
-                    certainty: Certainty::Maybe(stalled_cause),
+                    certainty: stalled_certainty,
                     has_changed: HasChanged::No,
                     stalled_on,
                 },
@@ -468,7 +500,7 @@ where
 
         let stalled_on = match certainty {
             Certainty::Yes => None,
-            Certainty::Maybe(stalled_cause) => match has_changed {
+            Certainty::Maybe { .. } => match has_changed {
                 // FIXME: We could recompute a *new* set of stalled variables by walking
                 // through the orig values, resolving, and computing the root vars of anything
                 // that is not resolved. Only when *these* have changed is it meaningful
@@ -518,7 +550,7 @@ where
                             .len(),
                         stalled_vars,
                         sub_roots,
-                        stalled_cause,
+                        stalled_certainty: certainty,
                     })
                 }
             },
@@ -634,7 +666,7 @@ where
             if let Some(certainty) = self.delegate.compute_goal_fast_path(goal, self.origin_span) {
                 match certainty {
                     Certainty::Yes => {}
-                    Certainty::Maybe(_) => {
+                    Certainty::Maybe { .. } => {
                         self.nested_goals.push((source, goal, None));
                         unchanged_certainty = unchanged_certainty.map(|c| c.and(certainty));
                     }
@@ -710,7 +742,7 @@ where
 
                 match certainty {
                     Certainty::Yes => {}
-                    Certainty::Maybe(_) => {
+                    Certainty::Maybe { .. } => {
                         self.nested_goals.push((source, with_resolved_vars, stalled_on));
                         unchanged_certainty = unchanged_certainty.map(|c| c.and(certainty));
                     }
@@ -724,7 +756,7 @@ where
 
                 match certainty {
                     Certainty::Yes => {}
-                    Certainty::Maybe(_) => {
+                    Certainty::Maybe { .. } => {
                         self.nested_goals.push((source, goal, stalled_on));
                         unchanged_certainty = unchanged_certainty.map(|c| c.and(certainty));
                     }
@@ -1184,28 +1216,12 @@ where
     pub(crate) fn opaques_with_sub_unified_hidden_type(
         &self,
         self_ty: I::Ty,
-    ) -> impl Iterator<Item = ty::AliasTy<I>> + use<'a, D, I> {
-        let delegate = self.delegate;
-        delegate
-            .clone_opaque_types_lookup_table()
-            .into_iter()
-            .chain(delegate.clone_duplicate_opaque_types())
-            .filter_map(move |(key, hidden_ty)| {
-                if let ty::Infer(ty::TyVar(self_vid)) = self_ty.kind() {
-                    if let ty::Infer(ty::TyVar(hidden_vid)) = hidden_ty.kind() {
-                        if delegate.sub_unification_table_root_var(self_vid)
-                            == delegate.sub_unification_table_root_var(hidden_vid)
-                        {
-                            return Some(ty::AliasTy::new_from_args(
-                                delegate.cx(),
-                                key.def_id.into(),
-                                key.args,
-                            ));
-                        }
-                    }
-                }
-                None
-            })
+    ) -> Vec<ty::AliasTy<I>> {
+        if let ty::Infer(ty::TyVar(vid)) = self_ty.kind() {
+            self.delegate.opaques_with_sub_unified_hidden_type(vid)
+        } else {
+            vec![]
+        }
     }
 }
 
diff --git a/compiler/rustc_next_trait_solver/src/solve/mod.rs b/compiler/rustc_next_trait_solver/src/solve/mod.rs
index cd27c9c26c1fd..fb900b592d13b 100644
--- a/compiler/rustc_next_trait_solver/src/solve/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/mod.rs
@@ -158,9 +158,10 @@ where
         if self.may_use_unstable_feature(param_env, symbol) {
             self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
         } else {
-            self.evaluate_added_goals_and_make_canonical_response(Certainty::Maybe(
-                MaybeCause::Ambiguity,
-            ))
+            self.evaluate_added_goals_and_make_canonical_response(Certainty::Maybe {
+                cause: MaybeCause::Ambiguity,
+                opaque_types_jank: OpaqueTypesJank::AllGood,
+            })
         }
     }
 
@@ -278,18 +279,21 @@ where
 
     fn bail_with_ambiguity(&mut self, candidates: &[Candidate<I>]) -> CanonicalResponse<I> {
         debug_assert!(candidates.len() > 1);
-        let maybe_cause =
-            candidates.iter().fold(MaybeCause::Ambiguity, |maybe_cause, candidates| {
-                // Pull down the certainty of `Certainty::Yes` to ambiguity when combining
+        let (cause, opaque_types_jank) = candidates.iter().fold(
+            (MaybeCause::Ambiguity, OpaqueTypesJank::AllGood),
+            |(c, jank), candidates| {
+                // We pull down the certainty of `Certainty::Yes` to ambiguity when combining
                 // these responses, b/c we're combining more than one response and this we
                 // don't know which one applies.
-                let candidate = match candidates.result.value.certainty {
-                    Certainty::Yes => MaybeCause::Ambiguity,
-                    Certainty::Maybe(candidate) => candidate,
-                };
-                maybe_cause.or(candidate)
-            });
-        self.make_ambiguous_response_no_constraints(maybe_cause)
+                match candidates.result.value.certainty {
+                    Certainty::Yes => (c, jank),
+                    Certainty::Maybe { cause, opaque_types_jank } => {
+                        (c.or(cause), jank.or(opaque_types_jank))
+                    }
+                }
+            },
+        );
+        self.make_ambiguous_response_no_constraints(cause, opaque_types_jank)
     }
 
     /// If we fail to merge responses we flounder and return overflow or ambiguity.
@@ -427,6 +431,7 @@ pub struct GoalStalledOn<I: Interner> {
     pub num_opaques: usize,
     pub stalled_vars: Vec<I::GenericArg>,
     pub sub_roots: Vec<TyVid>,
-    /// The cause that will be returned on subsequent evaluations if this goal remains stalled.
-    pub stalled_cause: MaybeCause,
+    /// The certainty that will be returned on subsequent evaluations if this
+    /// goal remains stalled.
+    pub stalled_certainty: Certainty,
 }
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 f0342e0523ff4..289325d70550c 100644
--- a/compiler/rustc_next_trait_solver/src/solve/search_graph.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/search_graph.rs
@@ -93,7 +93,7 @@ where
     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(_))
+                && matches!(response.value.certainty, Certainty::Maybe { .. })
         })
     }
 
diff --git a/compiler/rustc_trait_selection/src/solve/fulfill.rs b/compiler/rustc_trait_selection/src/solve/fulfill.rs
index 575e0472e0e38..bff4f6ce3fc6b 100644
--- a/compiler/rustc_trait_selection/src/solve/fulfill.rs
+++ b/compiler/rustc_trait_selection/src/solve/fulfill.rs
@@ -204,7 +204,7 @@ where
                         //
                         // Only goals proven via the trait solver should be region dependent.
                         Certainty::Yes => {}
-                        Certainty::Maybe(_) => {
+                        Certainty::Maybe { .. } => {
                             self.obligations.register(obligation, None);
                         }
                     }
@@ -258,7 +258,7 @@ where
                             infcx.push_hir_typeck_potentially_region_dependent_goal(obligation);
                         }
                     }
-                    Certainty::Maybe(_) => self.obligations.register(obligation, stalled_on),
+                    Certainty::Maybe { .. } => self.obligations.register(obligation, stalled_on),
                 }
             }
 
diff --git a/compiler/rustc_trait_selection/src/solve/fulfill/derive_errors.rs b/compiler/rustc_trait_selection/src/solve/fulfill/derive_errors.rs
index e31d1052d16c3..eef0ddcbf5965 100644
--- a/compiler/rustc_trait_selection/src/solve/fulfill/derive_errors.rs
+++ b/compiler/rustc_trait_selection/src/solve/fulfill/derive_errors.rs
@@ -95,15 +95,17 @@ pub(super) fn fulfillment_error_for_stalled<'tcx>(
             root_obligation.cause.span,
             None,
         ) {
-            Ok(GoalEvaluation { certainty: Certainty::Maybe(MaybeCause::Ambiguity), .. }) => {
-                (FulfillmentErrorCode::Ambiguity { overflow: None }, true)
-            }
+            Ok(GoalEvaluation {
+                certainty: Certainty::Maybe { cause: MaybeCause::Ambiguity, .. },
+                ..
+            }) => (FulfillmentErrorCode::Ambiguity { overflow: None }, true),
             Ok(GoalEvaluation {
                 certainty:
-                    Certainty::Maybe(MaybeCause::Overflow {
-                        suggest_increasing_limit,
-                        keep_constraints: _,
-                    }),
+                    Certainty::Maybe {
+                        cause:
+                            MaybeCause::Overflow { suggest_increasing_limit, keep_constraints: _ },
+                        ..
+                    },
                 ..
             }) => (
                 FulfillmentErrorCode::Ambiguity { overflow: Some(suggest_increasing_limit) },
@@ -266,7 +268,8 @@ impl<'tcx> BestObligation<'tcx> {
             );
             // Skip nested goals that aren't the *reason* for our goal's failure.
             match (self.consider_ambiguities, nested_goal.result()) {
-                (true, Ok(Certainty::Maybe(MaybeCause::Ambiguity))) | (false, Err(_)) => {}
+                (true, Ok(Certainty::Maybe { cause: MaybeCause::Ambiguity, .. }))
+                | (false, Err(_)) => {}
                 _ => continue,
             }
 
@@ -407,7 +410,8 @@ impl<'tcx> ProofTreeVisitor<'tcx> for BestObligation<'tcx> {
         let tcx = goal.infcx().tcx;
         // Skip goals that aren't the *reason* for our goal's failure.
         match (self.consider_ambiguities, goal.result()) {
-            (true, Ok(Certainty::Maybe(MaybeCause::Ambiguity))) | (false, Err(_)) => {}
+            (true, Ok(Certainty::Maybe { cause: MaybeCause::Ambiguity, .. })) | (false, Err(_)) => {
+            }
             _ => return ControlFlow::Continue(()),
         }
 
diff --git a/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs b/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs
index 342d7121fc373..086a7a44786d6 100644
--- a/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs
+++ b/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs
@@ -332,7 +332,7 @@ impl<'a, 'tcx> InspectGoal<'a, 'tcx> {
                 inspect::ProbeStep::MakeCanonicalResponse { shallow_certainty: c } => {
                     assert_matches!(
                         shallow_certainty.replace(c),
-                        None | Some(Certainty::Maybe(MaybeCause::Ambiguity))
+                        None | Some(Certainty::Maybe { cause: MaybeCause::Ambiguity, .. })
                     );
                 }
                 inspect::ProbeStep::NestedProbe(ref probe) => {
diff --git a/compiler/rustc_trait_selection/src/solve/select.rs b/compiler/rustc_trait_selection/src/solve/select.rs
index fb1adc2fd2ac3..8d01c880f8c59 100644
--- a/compiler/rustc_trait_selection/src/solve/select.rs
+++ b/compiler/rustc_trait_selection/src/solve/select.rs
@@ -62,7 +62,7 @@ impl<'tcx> inspect::ProofTreeVisitor<'tcx> for Select {
 
         // Don't winnow until `Certainty::Yes` -- we don't need to winnow until
         // codegen, and only on the good path.
-        if matches!(goal.result().unwrap(), Certainty::Maybe(..)) {
+        if matches!(goal.result().unwrap(), Certainty::Maybe { .. }) {
             return ControlFlow::Break(Ok(None));
         }
 
@@ -95,7 +95,7 @@ fn candidate_should_be_dropped_in_favor_of<'tcx>(
 ) -> bool {
     // Don't winnow until `Certainty::Yes` -- we don't need to winnow until
     // codegen, and only on the good path.
-    if matches!(other.result().unwrap(), Certainty::Maybe(..)) {
+    if matches!(other.result().unwrap(), Certainty::Maybe { .. }) {
         return false;
     }
 
@@ -143,13 +143,13 @@ fn to_selection<'tcx>(
     span: Span,
     cand: inspect::InspectCandidate<'_, 'tcx>,
 ) -> Option<Selection<'tcx>> {
-    if let Certainty::Maybe(..) = cand.shallow_certainty() {
+    if let Certainty::Maybe { .. } = cand.shallow_certainty() {
         return None;
     }
 
     let nested = match cand.result().expect("expected positive result") {
         Certainty::Yes => thin_vec![],
-        Certainty::Maybe(_) => cand
+        Certainty::Maybe { .. } => cand
             .instantiate_nested_goals(span)
             .into_iter()
             .map(|nested| {
diff --git a/compiler/rustc_trait_selection/src/traits/coherence.rs b/compiler/rustc_trait_selection/src/traits/coherence.rs
index 39afd77a8b682..8e8c7dd7c9d48 100644
--- a/compiler/rustc_trait_selection/src/traits/coherence.rs
+++ b/compiler/rustc_trait_selection/src/traits/coherence.rs
@@ -682,7 +682,7 @@ impl<'a, 'tcx> ProofTreeVisitor<'tcx> for AmbiguityCausesVisitor<'a, 'tcx> {
         // was irrelevant.
         match goal.result() {
             Ok(Certainty::Yes) | Err(NoSolution) => return,
-            Ok(Certainty::Maybe(_)) => {}
+            Ok(Certainty::Maybe { .. }) => {}
         }
 
         // For bound predicates we simply call `infcx.enter_forall`
diff --git a/compiler/rustc_trait_selection/src/traits/query/evaluate_obligation.rs b/compiler/rustc_trait_selection/src/traits/query/evaluate_obligation.rs
index 9e1a2a3e7d286..ae731505abfa5 100644
--- a/compiler/rustc_trait_selection/src/traits/query/evaluate_obligation.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/evaluate_obligation.rs
@@ -1,8 +1,11 @@
+use rustc_infer::traits::solve::Goal;
 use rustc_macros::extension;
 use rustc_middle::span_bug;
+use rustc_next_trait_solver::solve::SolverDelegateEvalExt;
 
 use crate::infer::InferCtxt;
 use crate::infer::canonical::OriginalQueryValues;
+use crate::solve::SolverDelegate;
 use crate::traits::{
     EvaluationResult, ObligationCtxt, OverflowError, PredicateObligation, SelectionContext,
 };
@@ -15,6 +18,20 @@ impl<'tcx> InferCtxt<'tcx> {
         self.evaluate_obligation_no_overflow(obligation).may_apply()
     }
 
+    /// See the comment on [OpaqueTypesJank](crate::solve::OpaqueTypesJank)
+    /// for more details.
+    fn predicate_may_hold_opaque_types_jank(&self, obligation: &PredicateObligation<'tcx>) -> bool {
+        if self.next_trait_solver() {
+            <&SolverDelegate<'tcx>>::from(self).root_goal_may_hold_opaque_types_jank(Goal::new(
+                self.tcx,
+                obligation.param_env,
+                obligation.predicate,
+            ))
+        } else {
+            self.predicate_may_hold(obligation)
+        }
+    }
+
     /// Evaluates whether the predicate can be satisfied in the given
     /// `ParamEnv`, and returns `false` if not certain. However, this is
     /// not entirely accurate if inference variables are involved.
diff --git a/compiler/rustc_type_ir/src/infer_ctxt.rs b/compiler/rustc_type_ir/src/infer_ctxt.rs
index 56962b4597b88..f743b84bce689 100644
--- a/compiler/rustc_type_ir/src/infer_ctxt.rs
+++ b/compiler/rustc_type_ir/src/infer_ctxt.rs
@@ -6,7 +6,7 @@ use crate::fold::TypeFoldable;
 use crate::inherent::*;
 use crate::relate::RelateResult;
 use crate::relate::combine::PredicateEmittingRelation;
-use crate::{self as ty, Interner};
+use crate::{self as ty, Interner, TyVid};
 
 /// The current typing mode of an inference context. We unfortunately have some
 /// slightly different typing rules depending on the current context. See the
@@ -271,6 +271,7 @@ pub trait InferCtxtLike: Sized {
         &self,
         prev_entries: Self::OpaqueTypeStorageEntries,
     ) -> Vec<(ty::OpaqueTypeKey<Self::Interner>, <Self::Interner as Interner>::Ty)>;
+    fn opaques_with_sub_unified_hidden_type(&self, ty: TyVid) -> Vec<ty::AliasTy<Self::Interner>>;
 
     fn register_hidden_type_in_storage(
         &self,
diff --git a/compiler/rustc_type_ir/src/solve/mod.rs b/compiler/rustc_type_ir/src/solve/mod.rs
index b48a8f46ebef7..1a1606d82685c 100644
--- a/compiler/rustc_type_ir/src/solve/mod.rs
+++ b/compiler/rustc_type_ir/src/solve/mod.rs
@@ -269,11 +269,70 @@ impl<I: Interner> NestedNormalizationGoals<I> {
 #[cfg_attr(feature = "nightly", derive(HashStable_NoContext))]
 pub enum Certainty {
     Yes,
-    Maybe(MaybeCause),
+    Maybe { cause: MaybeCause, opaque_types_jank: OpaqueTypesJank },
+}
+
+/// Supporting not-yet-defined opaque types in HIR typeck is somewhat
+/// challenging. Ideally we'd normalize them to a new inference variable
+/// and just defer type inference which relies on the opaque until we've
+/// constrained the hidden type.
+///
+/// This doesn't work for method and function calls as we need to guide type
+/// inference for the function arguments. We treat not-yet-defined opaque types
+/// as if they were rigid instead in these places.
+///
+/// When we encounter a `?hidden_type_of_opaque: Trait<?var>` goal, we use the
+/// item bounds and blanket impls to guide inference by constraining other type
+/// variables, see `EvalCtxt::try_assemble_bounds_via_registered_opaques`. We
+/// always keep the certainty as `Maybe` so that we properly prove these goals
+/// once the hidden type has been constrained.
+///
+/// If we fail to prove the trait goal via item bounds or blanket impls, the
+/// goal would have errored if the opaque type were rigid. In this case, we
+/// set `OpaqueTypesJank::ErrorIfRigidSelfTy` in the [Certainty].
+///
+/// Places in HIR typeck where we want to treat not-yet-defined opaque types as if
+/// they were kind of rigid then use `fn root_goal_may_hold_opaque_types_jank` which
+/// returns `false` if the goal doesn't hold or if `OpaqueTypesJank::ErrorIfRigidSelfTy`
+/// is set (i.e. proving it required relies on some `?hidden_ty: NotInItemBounds` goal).
+///
+/// This is subtly different from actually treating not-yet-defined opaque types as
+/// rigid, e.g. it allows constraining opaque types if they are not the self-type of
+/// a goal. It is good enough for now and only matters for very rare type inference
+/// edge cases. We can improve this later on if necessary.
+#[derive(Clone, Copy, Hash, PartialEq, Eq, Debug)]
+#[cfg_attr(feature = "nightly", derive(HashStable_NoContext))]
+pub enum OpaqueTypesJank {
+    AllGood,
+    ErrorIfRigidSelfTy,
+}
+impl OpaqueTypesJank {
+    fn and(self, other: OpaqueTypesJank) -> OpaqueTypesJank {
+        match (self, other) {
+            (OpaqueTypesJank::AllGood, OpaqueTypesJank::AllGood) => OpaqueTypesJank::AllGood,
+            (OpaqueTypesJank::ErrorIfRigidSelfTy, _) | (_, OpaqueTypesJank::ErrorIfRigidSelfTy) => {
+                OpaqueTypesJank::ErrorIfRigidSelfTy
+            }
+        }
+    }
+
+    pub fn or(self, other: OpaqueTypesJank) -> OpaqueTypesJank {
+        match (self, other) {
+            (OpaqueTypesJank::ErrorIfRigidSelfTy, OpaqueTypesJank::ErrorIfRigidSelfTy) => {
+                OpaqueTypesJank::ErrorIfRigidSelfTy
+            }
+            (OpaqueTypesJank::AllGood, _) | (_, OpaqueTypesJank::AllGood) => {
+                OpaqueTypesJank::AllGood
+            }
+        }
+    }
 }
 
 impl Certainty {
-    pub const AMBIGUOUS: Certainty = Certainty::Maybe(MaybeCause::Ambiguity);
+    pub const AMBIGUOUS: Certainty = Certainty::Maybe {
+        cause: MaybeCause::Ambiguity,
+        opaque_types_jank: OpaqueTypesJank::AllGood,
+    };
 
     /// Use this function to merge the certainty of multiple nested subgoals.
     ///
@@ -290,14 +349,23 @@ impl Certainty {
     pub fn and(self, other: Certainty) -> Certainty {
         match (self, other) {
             (Certainty::Yes, Certainty::Yes) => Certainty::Yes,
-            (Certainty::Yes, Certainty::Maybe(_)) => other,
-            (Certainty::Maybe(_), Certainty::Yes) => self,
-            (Certainty::Maybe(a), Certainty::Maybe(b)) => Certainty::Maybe(a.and(b)),
+            (Certainty::Yes, Certainty::Maybe { .. }) => other,
+            (Certainty::Maybe { .. }, Certainty::Yes) => self,
+            (
+                Certainty::Maybe { cause: a_cause, opaque_types_jank: a_jank },
+                Certainty::Maybe { cause: b_cause, opaque_types_jank: b_jank },
+            ) => Certainty::Maybe {
+                cause: a_cause.and(b_cause),
+                opaque_types_jank: a_jank.and(b_jank),
+            },
         }
     }
 
     pub const fn overflow(suggest_increasing_limit: bool) -> Certainty {
-        Certainty::Maybe(MaybeCause::Overflow { suggest_increasing_limit, keep_constraints: false })
+        Certainty::Maybe {
+            cause: MaybeCause::Overflow { suggest_increasing_limit, keep_constraints: false },
+            opaque_types_jank: OpaqueTypesJank::AllGood,
+        }
     }
 }
 
diff --git a/tests/ui/impl-trait/non-defining-uses/ambiguous-ops.current.stderr b/tests/ui/impl-trait/non-defining-uses/ambiguous-ops.current.stderr
new file mode 100644
index 0000000000000..c54c1bba028cb
--- /dev/null
+++ b/tests/ui/impl-trait/non-defining-uses/ambiguous-ops.current.stderr
@@ -0,0 +1,62 @@
+error[E0369]: cannot add `{integer}` to `impl Sized`
+  --> $DIR/ambiguous-ops.rs:17:15
+   |
+LL |         add() + 1
+   |         ----- ^ - {integer}
+   |         |
+   |         impl Sized
+
+error[E0368]: binary assignment operation `*=` cannot be applied to type `impl Sized`
+  --> $DIR/ambiguous-ops.rs:31:9
+   |
+LL |         temp *= 2;
+   |         ----^^^^^
+   |         |
+   |         cannot use `*=` on type `impl Sized`
+
+error[E0614]: type `DerefWrapper<impl Sized>` cannot be dereferenced
+  --> $DIR/ambiguous-ops.rs:57:22
+   |
+LL |         let _rarw = &*explicit_deref();
+   |                      ^^^^^^^^^^^^^^^^^ can't be dereferenced
+
+error[E0614]: type `DerefWrapper<impl Sized>` cannot be dereferenced
+  --> $DIR/ambiguous-ops.rs:69:9
+   |
+LL |         *explicit_deref_mut() = 1;
+   |         ^^^^^^^^^^^^^^^^^^^^^ can't be dereferenced
+
+error[E0277]: the type `impl Sized` cannot be indexed by `_`
+  --> $DIR/ambiguous-ops.rs:94:18
+   |
+LL |         let _y = explicit_index()[0];
+   |                  ^^^^^^^^^^^^^^^^ `impl Sized` cannot be indexed by `_`
+   |
+   = help: the trait `Index<_>` is not implemented for `impl Sized`
+note: required for `IndexWrapper<impl Sized>` to implement `Index<_>`
+  --> $DIR/ambiguous-ops.rs:81:22
+   |
+LL | impl<T: Index<U>, U> Index<U> for IndexWrapper<T> {
+   |         --------     ^^^^^^^^     ^^^^^^^^^^^^^^^
+   |         |
+   |         unsatisfied trait bound introduced here
+
+error[E0277]: the type `impl Sized` cannot be indexed by `_`
+  --> $DIR/ambiguous-ops.rs:106:9
+   |
+LL |         explicit_index_mut()[0] = 1;
+   |         ^^^^^^^^^^^^^^^^^^^^ `impl Sized` cannot be indexed by `_`
+   |
+   = help: the trait `Index<_>` is not implemented for `impl Sized`
+note: required for `IndexWrapper<impl Sized>` to implement `Index<_>`
+  --> $DIR/ambiguous-ops.rs:81:22
+   |
+LL | impl<T: Index<U>, U> Index<U> for IndexWrapper<T> {
+   |         --------     ^^^^^^^^     ^^^^^^^^^^^^^^^
+   |         |
+   |         unsatisfied trait bound introduced here
+
+error: aborting due to 6 previous errors
+
+Some errors have detailed explanations: E0277, E0368, E0369, E0614.
+For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/impl-trait/non-defining-uses/ambiguous-ops.rs b/tests/ui/impl-trait/non-defining-uses/ambiguous-ops.rs
new file mode 100644
index 0000000000000..0aa5715339dc2
--- /dev/null
+++ b/tests/ui/impl-trait/non-defining-uses/ambiguous-ops.rs
@@ -0,0 +1,117 @@
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] check-pass
+
+// Make sure we support non-call operations for opaque types even if
+// its not part of its item bounds.
+
+use std::ops::{Deref, DerefMut, Index, IndexMut};
+
+fn mk<T>() -> T {
+    todo!()
+}
+
+fn add() -> impl Sized {
+    let unconstrained = if false {
+        add() + 1
+        //[current]~^ ERROR cannot add `{integer}` to `impl Sized
+    } else {
+        let with_infer = mk();
+        let _ = with_infer + 1;
+        with_infer
+    };
+    let _: u32 = unconstrained;
+    1u32
+}
+
+fn mul_assign() -> impl Sized {
+    if false {
+        let mut temp = mul_assign();
+        temp *= 2;
+        //[current]~^ ERROR binary assignment operation `*=` cannot be applied to type `impl Sized`
+    }
+
+    let mut with_infer = mk();
+    with_infer *= 2;
+    let _: u32 = with_infer;
+
+    1u32
+}
+
+struct DerefWrapper<T>(T);
+impl<T: Deref> Deref for DerefWrapper<T> {
+    type Target = T::Target;
+    fn deref(&self) -> &Self::Target {
+        &*self.0
+    }
+}
+impl<T: DerefMut> DerefMut for DerefWrapper<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut *self.0
+    }
+}
+
+fn explicit_deref() -> DerefWrapper<impl Sized> {
+    if false {
+        let _rarw = &*explicit_deref();
+        //[current]~^ ERROR type `DerefWrapper<impl Sized>` cannot be dereferenced
+
+        let mut with_infer = DerefWrapper(mk());
+        let _rarw = &*with_infer;
+        with_infer
+    } else {
+        DerefWrapper(&1u32)
+    }
+}
+fn explicit_deref_mut() -> DerefWrapper<impl Sized> {
+    if false {
+        *explicit_deref_mut() = 1;
+        //[current]~^ ERROR type `DerefWrapper<impl Sized>` cannot be dereferenced
+
+        let mut with_infer = DerefWrapper(Default::default());
+        *with_infer = 1;
+        with_infer
+    } else {
+        DerefWrapper(Box::new(1u32))
+    }
+}
+
+struct IndexWrapper<T>(T);
+impl<T: Index<U>, U> Index<U> for IndexWrapper<T> {
+    type Output = T::Output;
+    fn index(&self, index: U) -> &Self::Output {
+        &self.0[index]
+    }
+}
+impl<T: IndexMut<U>, U> IndexMut<U> for IndexWrapper<T> {
+    fn index_mut(&mut self, index: U) -> &mut Self::Output {
+        &mut self.0[index]
+    }
+}
+fn explicit_index() -> IndexWrapper<impl Sized> {
+    if false {
+        let _y = explicit_index()[0];
+        //[current]~^ ERROR the type `impl Sized` cannot be indexed by `_`
+
+        let with_infer = IndexWrapper(Default::default());
+        let _y = with_infer[0];
+        with_infer
+    } else {
+        IndexWrapper([1u32])
+    }
+}
+fn explicit_index_mut() -> IndexWrapper<impl Sized> {
+    if false {
+        explicit_index_mut()[0] = 1;
+        //[current]~^ ERROR the type `impl Sized` cannot be indexed by `_`
+
+        let mut with_infer = IndexWrapper(Default::default());
+        with_infer[0] = 1;
+        with_infer
+    } else {
+        IndexWrapper([1u32])
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/impl-trait/non-defining-uses/function-call-on-infer.rs b/tests/ui/impl-trait/non-defining-uses/function-call-on-infer.rs
new file mode 100644
index 0000000000000..9b9156ee4c716
--- /dev/null
+++ b/tests/ui/impl-trait/non-defining-uses/function-call-on-infer.rs
@@ -0,0 +1,73 @@
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@ check-pass
+
+// Regression test for trait-system-refactor-initiative#181. Make sure calling
+// opaque types works.
+
+fn fn_trait() -> impl Fn() {
+    if false {
+        let f = fn_trait();
+        f();
+    }
+
+    || ()
+}
+
+fn fn_trait_ref() -> impl Fn() {
+    if false {
+        let f = &fn_trait();
+        f();
+    }
+    || ()
+}
+
+fn fn_mut() -> impl FnMut() -> usize {
+    if false {
+        let mut f = fn_mut();
+        f();
+    }
+
+    let mut state = 0;
+    move || {
+        state += 1;
+        state
+    }
+}
+
+fn fn_mut_ref() -> impl FnMut() -> usize {
+    if false {
+        let mut f = &mut fn_mut();
+        f();
+    }
+
+    let mut state = 0;
+    move || {
+        state += 1;
+        state
+    }
+}
+
+
+fn fn_once() -> impl FnOnce() {
+    if false {
+        let mut f = fn_once();
+        f();
+    }
+
+    let string = String::new();
+    move || drop(string)
+}
+
+fn fn_once_ref() -> impl FnOnce() {
+    if false {
+        let mut f = Box::new(fn_once_ref());
+        f();
+    }
+
+    let string = String::new();
+    move || drop(string)
+}
+
+fn main() {}
diff --git a/tests/ui/impl-trait/non-defining-uses/impl-deref-function-call.rs b/tests/ui/impl-trait/non-defining-uses/impl-deref-function-call.rs
new file mode 100644
index 0000000000000..5ff0dae55cc35
--- /dev/null
+++ b/tests/ui/impl-trait/non-defining-uses/impl-deref-function-call.rs
@@ -0,0 +1,56 @@
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@ check-pass
+
+// Regression test for trait-system-refactor-initiative#181. We want to
+// be able to step through `impl Deref` in its defining scope.
+use std::ops::{Deref, DerefMut};
+fn impl_deref_fn() -> impl Deref<Target = fn(fn(&str) -> usize)> {
+    if false {
+        let func = impl_deref_fn();
+        func(|s| s.len());
+    }
+
+    &((|_| ()) as fn(_))
+}
+
+fn impl_deref_impl_fn() -> impl Deref<Target = impl Fn()> {
+    if false {
+        let func = impl_deref_impl_fn();
+        func();
+    }
+
+    &|| ()
+}
+
+fn impl_deref_impl_deref_impl_fn() -> impl Deref<Target = impl Deref<Target = impl Fn()>> {
+    if false {
+        let func = impl_deref_impl_deref_impl_fn();
+        func();
+    }
+
+    &&|| ()
+}
+
+
+fn impl_deref_mut_impl_fn() -> impl DerefMut<Target = impl Fn()> {
+    if false {
+        let func = impl_deref_impl_fn();
+        func();
+    }
+
+    Box::new(|| ())
+}
+
+
+fn impl_deref_mut_impl_fn_mut() -> impl DerefMut<Target = impl FnMut()> {
+    if false {
+        let mut func = impl_deref_mut_impl_fn_mut();
+        func();
+    }
+
+    let mut state = 0;
+    Box::new(move || state += 1)
+}
+fn main() {}
diff --git a/tests/ui/impl-trait/non-defining-uses/shex_compat-regression-test.rs b/tests/ui/impl-trait/non-defining-uses/shex_compat-regression-test.rs
new file mode 100644
index 0000000000000..aa1b51d6906e4
--- /dev/null
+++ b/tests/ui/impl-trait/non-defining-uses/shex_compat-regression-test.rs
@@ -0,0 +1,19 @@
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@ check-pass
+
+// Regression test for trait-system-refactor-initiative#181.
+
+struct ShExCompactPrinter;
+
+struct TripleExpr;
+
+impl ShExCompactPrinter {
+    fn pp_triple_expr(&self) -> impl Fn(&TripleExpr, &ShExCompactPrinter) + '_ {
+        move |te, printer| {
+            printer.pp_triple_expr()(te, printer);
+        }
+    }
+}
+fn main() {}
diff --git a/tests/ui/inference/return-block-type-inference-15965.stderr b/tests/ui/inference/return-block-type-inference-15965.stderr
index fc4f2defe7ffa..bfee904192204 100644
--- a/tests/ui/inference/return-block-type-inference-15965.stderr
+++ b/tests/ui/inference/return-block-type-inference-15965.stderr
@@ -1,10 +1,8 @@
 error[E0282]: type annotations needed
   --> $DIR/return-block-type-inference-15965.rs:5:9
    |
-LL | /         { return () }
-LL | |
-LL | |     ()
-   | |______^ cannot infer type
+LL |         { return () }
+   |         ^^^^^^^^^^^^^ cannot infer type
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/unboxed-closures/unboxed-closures-failed-recursive-fn-2.stderr b/tests/ui/unboxed-closures/unboxed-closures-failed-recursive-fn-2.stderr
index 058dbb1e220f6..739182e120b4f 100644
--- a/tests/ui/unboxed-closures/unboxed-closures-failed-recursive-fn-2.stderr
+++ b/tests/ui/unboxed-closures/unboxed-closures-failed-recursive-fn-2.stderr
@@ -5,7 +5,7 @@ LL |     let mut closure0 = None;
    |         ^^^^^^^^^^^^
 ...
 LL |                         return c();
-   |                                --- type must be known at this point
+   |                                - type must be known at this point
    |
 help: consider giving `closure0` an explicit type, where the placeholders `_` are specified
    |

From 9913c47da2b616fee57f308071d6adc39bff4568 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Mon, 15 Sep 2025 14:39:01 +0200
Subject: [PATCH 1081/1889] add tests, silence type annotations needed errors
 for opaques

---
 compiler/rustc_hir_typeck/src/opaque_types.rs | 34 ++++++-----
 ...ncorrect-choice-diagnostics.current.stderr | 53 +++++++++++++++++
 ...r-incorrect-choice-diagnostics.next.stderr | 57 +++++++++++++++++++
 .../call-expr-incorrect-choice-diagnostics.rs | 52 +++++++++++++++++
 .../deref-constrains-self-ty.current.stderr   | 16 ++++++
 .../deref-constrains-self-ty.rs               | 28 +++++++++
 ...uble-wrap-with-defining-use.current.stderr |  4 +-
 .../double-wrap-with-defining-use.rs          |  1 -
 .../ice-issue-146191.current.stderr           |  2 +-
 .../ice-issue-146191.next.stderr              | 10 +---
 .../non-defining-uses/ice-issue-146191.rs     |  1 -
 .../two_tait_defining_each_other2.next.stderr |  8 +--
 .../two_tait_defining_each_other2.rs          |  3 +-
 13 files changed, 231 insertions(+), 38 deletions(-)
 create mode 100644 tests/ui/impl-trait/non-defining-uses/call-expr-incorrect-choice-diagnostics.current.stderr
 create mode 100644 tests/ui/impl-trait/non-defining-uses/call-expr-incorrect-choice-diagnostics.next.stderr
 create mode 100644 tests/ui/impl-trait/non-defining-uses/call-expr-incorrect-choice-diagnostics.rs
 create mode 100644 tests/ui/impl-trait/non-defining-uses/deref-constrains-self-ty.current.stderr
 create mode 100644 tests/ui/impl-trait/non-defining-uses/deref-constrains-self-ty.rs

diff --git a/compiler/rustc_hir_typeck/src/opaque_types.rs b/compiler/rustc_hir_typeck/src/opaque_types.rs
index 97feac3d0099a..5cefa506b5a06 100644
--- a/compiler/rustc_hir_typeck/src/opaque_types.rs
+++ b/compiler/rustc_hir_typeck/src/opaque_types.rs
@@ -117,21 +117,25 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
                     )
                 }
                 UsageKind::UnconstrainedHiddenType(hidden_type) => {
-                    let infer_var = hidden_type
-                        .ty
-                        .walk()
-                        .filter_map(ty::GenericArg::as_term)
-                        .find(|term| term.is_infer())
-                        .unwrap_or_else(|| hidden_type.ty.into());
-                    self.err_ctxt()
-                        .emit_inference_failure_err(
-                            self.body_id,
-                            hidden_type.span,
-                            infer_var,
-                            TypeAnnotationNeeded::E0282,
-                            false,
-                        )
-                        .emit()
+                    if let Some(guar) = self.tainted_by_errors() {
+                        guar
+                    } else {
+                        let infer_var = hidden_type
+                            .ty
+                            .walk()
+                            .filter_map(ty::GenericArg::as_term)
+                            .find(|term| term.is_infer())
+                            .unwrap_or_else(|| hidden_type.ty.into());
+                        self.err_ctxt()
+                            .emit_inference_failure_err(
+                                self.body_id,
+                                hidden_type.span,
+                                infer_var,
+                                TypeAnnotationNeeded::E0282,
+                                false,
+                            )
+                            .emit()
+                    }
                 }
                 UsageKind::HasDefiningUse => continue,
             };
diff --git a/tests/ui/impl-trait/non-defining-uses/call-expr-incorrect-choice-diagnostics.current.stderr b/tests/ui/impl-trait/non-defining-uses/call-expr-incorrect-choice-diagnostics.current.stderr
new file mode 100644
index 0000000000000..e213dab5d9618
--- /dev/null
+++ b/tests/ui/impl-trait/non-defining-uses/call-expr-incorrect-choice-diagnostics.current.stderr
@@ -0,0 +1,53 @@
+error[E0382]: use of moved value: `var`
+  --> $DIR/call-expr-incorrect-choice-diagnostics.rs:14:9
+   |
+LL |         let mut var = item_bound_is_too_weak();
+   |             ------- move occurs because `var` has type `impl FnOnce()`, which does not implement the `Copy` trait
+LL |         var();
+   |         ----- `var` moved due to this call
+LL |         var();
+   |         ^^^ value used here after move
+   |
+note: this value implements `FnOnce`, which causes it to be moved when called
+  --> $DIR/call-expr-incorrect-choice-diagnostics.rs:13:9
+   |
+LL |         var();
+   |         ^^^
+
+error[E0618]: expected function, found `impl Sized`
+  --> $DIR/call-expr-incorrect-choice-diagnostics.rs:24:9
+   |
+LL | fn opaque_type_no_impl_fn() -> impl Sized {
+   | ----------------------------------------- `opaque_type_no_impl_fn` defined here returns `impl Sized`
+LL |     if false {
+LL |         opaque_type_no_impl_fn()();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^--
+   |         |
+   |         call expression requires function
+
+error[E0618]: expected function, found `impl Sized`
+  --> $DIR/call-expr-incorrect-choice-diagnostics.rs:34:9
+   |
+LL | fn opaque_type_no_impl_fn_incorrect() -> impl Sized {
+   | --------------------------------------------------- `opaque_type_no_impl_fn_incorrect` defined here returns `impl Sized`
+LL |     if false {
+LL |         opaque_type_no_impl_fn_incorrect()();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^--
+   |         |
+   |         call expression requires function
+
+error[E0618]: expected function, found `impl Deref<Target = impl Sized>`
+  --> $DIR/call-expr-incorrect-choice-diagnostics.rs:44:9
+   |
+LL | fn opaque_type_deref_no_impl_fn() -> impl Deref<Target = impl Sized> {
+   | -------------------------------------------------------------------- `opaque_type_deref_no_impl_fn` defined here returns `impl Deref<Target = impl Sized>`
+LL |     if false {
+LL |         opaque_type_deref_no_impl_fn()();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^--
+   |         |
+   |         call expression requires function
+
+error: aborting due to 4 previous errors
+
+Some errors have detailed explanations: E0382, E0618.
+For more information about an error, try `rustc --explain E0382`.
diff --git a/tests/ui/impl-trait/non-defining-uses/call-expr-incorrect-choice-diagnostics.next.stderr b/tests/ui/impl-trait/non-defining-uses/call-expr-incorrect-choice-diagnostics.next.stderr
new file mode 100644
index 0000000000000..5678349cad32d
--- /dev/null
+++ b/tests/ui/impl-trait/non-defining-uses/call-expr-incorrect-choice-diagnostics.next.stderr
@@ -0,0 +1,57 @@
+error[E0382]: use of moved value: `var`
+  --> $DIR/call-expr-incorrect-choice-diagnostics.rs:14:9
+   |
+LL |         let mut var = item_bound_is_too_weak();
+   |             ------- move occurs because `var` has type `{closure@$DIR/call-expr-incorrect-choice-diagnostics.rs:19:5: 19:12}`, which does not implement the `Copy` trait
+LL |         var();
+   |         ----- `var` moved due to this call
+LL |         var();
+   |         ^^^ value used here after move
+   |
+note: this value implements `FnOnce`, which causes it to be moved when called
+  --> $DIR/call-expr-incorrect-choice-diagnostics.rs:13:9
+   |
+LL |         var();
+   |         ^^^
+help: consider cloning the value if the performance cost is acceptable
+   |
+LL |         var.clone()();
+   |            ++++++++
+
+error[E0618]: expected function, found `_`
+  --> $DIR/call-expr-incorrect-choice-diagnostics.rs:24:9
+   |
+LL | fn opaque_type_no_impl_fn() -> impl Sized {
+   | ----------------------------------------- `opaque_type_no_impl_fn` defined here returns `_`
+LL |     if false {
+LL |         opaque_type_no_impl_fn()();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^--
+   |         |
+   |         call expression requires function
+
+error[E0618]: expected function, found `_`
+  --> $DIR/call-expr-incorrect-choice-diagnostics.rs:34:9
+   |
+LL | fn opaque_type_no_impl_fn_incorrect() -> impl Sized {
+   | --------------------------------------------------- `opaque_type_no_impl_fn_incorrect` defined here returns `_`
+LL |     if false {
+LL |         opaque_type_no_impl_fn_incorrect()();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^--
+   |         |
+   |         call expression requires function
+
+error[E0618]: expected function, found `_`
+  --> $DIR/call-expr-incorrect-choice-diagnostics.rs:44:9
+   |
+LL | fn opaque_type_deref_no_impl_fn() -> impl Deref<Target = impl Sized> {
+   | -------------------------------------------------------------------- `opaque_type_deref_no_impl_fn` defined here returns `_`
+LL |     if false {
+LL |         opaque_type_deref_no_impl_fn()();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^--
+   |         |
+   |         call expression requires function
+
+error: aborting due to 4 previous errors
+
+Some errors have detailed explanations: E0382, E0618.
+For more information about an error, try `rustc --explain E0382`.
diff --git a/tests/ui/impl-trait/non-defining-uses/call-expr-incorrect-choice-diagnostics.rs b/tests/ui/impl-trait/non-defining-uses/call-expr-incorrect-choice-diagnostics.rs
new file mode 100644
index 0000000000000..1d73985f78a12
--- /dev/null
+++ b/tests/ui/impl-trait/non-defining-uses/call-expr-incorrect-choice-diagnostics.rs
@@ -0,0 +1,52 @@
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
+//@ ignore-compare-mode-next-solver (explicit revisions)
+
+// Testing the errors in case we've made a wrong choice when
+// calling an opaque.
+
+use std::ops::Deref;
+
+fn item_bound_is_too_weak() -> impl FnOnce() {
+    if false {
+        let mut var = item_bound_is_too_weak();
+        var();
+        var();
+        //~^ ERROR use of moved value: `var`
+    }
+
+    let mut state = String::new();
+    move || state.push('a')
+}
+
+fn opaque_type_no_impl_fn() -> impl Sized {
+    if false {
+        opaque_type_no_impl_fn()();
+        //[current]~^ ERROR expected function, found `impl Sized`
+        //[next]~^^ ERROR expected function, found `_`
+    }
+
+    1
+}
+
+fn opaque_type_no_impl_fn_incorrect() -> impl Sized {
+    if false {
+        opaque_type_no_impl_fn_incorrect()();
+        //[current]~^ ERROR expected function, found `impl Sized`
+        //[next]~^^ ERROR expected function, found `_`
+    }
+
+    || ()
+}
+
+fn opaque_type_deref_no_impl_fn() -> impl Deref<Target = impl Sized> {
+    if false {
+        opaque_type_deref_no_impl_fn()();
+        //[current]~^ ERROR expected function, found `impl Deref<Target = impl Sized>`
+        //[next]~^^ ERROR expected function, found `_`
+    }
+
+    &1
+}
+
+fn main() {}
diff --git a/tests/ui/impl-trait/non-defining-uses/deref-constrains-self-ty.current.stderr b/tests/ui/impl-trait/non-defining-uses/deref-constrains-self-ty.current.stderr
new file mode 100644
index 0000000000000..bbe90e5873d04
--- /dev/null
+++ b/tests/ui/impl-trait/non-defining-uses/deref-constrains-self-ty.current.stderr
@@ -0,0 +1,16 @@
+error[E0599]: no method named `len` found for struct `Wrapper<T>` in the current scope
+  --> $DIR/deref-constrains-self-ty.rs:22:32
+   |
+LL | struct Wrapper<T>(T);
+   | ----------------- method `len` not found for this struct
+...
+LL |         let _ = Wrapper(foo()).len();
+   |                                ^^^ method not found in `Wrapper<impl Sized>`
+   |
+   = help: items from traits can only be used if the trait is implemented and in scope
+   = note: the following trait defines an item `len`, perhaps you need to implement it:
+           candidate #1: `ExactSizeIterator`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/impl-trait/non-defining-uses/deref-constrains-self-ty.rs b/tests/ui/impl-trait/non-defining-uses/deref-constrains-self-ty.rs
new file mode 100644
index 0000000000000..d143878bc7466
--- /dev/null
+++ b/tests/ui/impl-trait/non-defining-uses/deref-constrains-self-ty.rs
@@ -0,0 +1,28 @@
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] check-pass
+
+// A test which shows that autoderef can constrain opaque types even
+// though it's supposed to treat not-yet-defined opaque types as
+// mostly rigid. I don't think this should necessarily compile :shrug:
+use std::ops::Deref;
+
+struct Wrapper<T>(T);
+
+impl<T> Deref for Wrapper<Vec<T>> {
+    type Target = Vec<T>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+fn foo() -> impl Sized {
+    if false {
+        let _ = Wrapper(foo()).len();
+        //[current]~^ ERROR no method named `len` found for struct `Wrapper<T>` in the current scope
+    }
+
+    std::iter::once(1).collect()
+}
+fn main() {}
diff --git a/tests/ui/impl-trait/non-defining-uses/double-wrap-with-defining-use.current.stderr b/tests/ui/impl-trait/non-defining-uses/double-wrap-with-defining-use.current.stderr
index 30424ec58f913..bac5b3e0cf441 100644
--- a/tests/ui/impl-trait/non-defining-uses/double-wrap-with-defining-use.current.stderr
+++ b/tests/ui/impl-trait/non-defining-uses/double-wrap-with-defining-use.current.stderr
@@ -1,5 +1,5 @@
 error[E0792]: expected generic type parameter, found `impl Foo`
-  --> $DIR/double-wrap-with-defining-use.rs:12:26
+  --> $DIR/double-wrap-with-defining-use.rs:11:26
    |
 LL | fn a<T: Foo>(x: T) -> impl Foo {
    |      - this generic parameter must be used with a generic type parameter
@@ -7,7 +7,7 @@ LL |     if true { x } else { a(a(x)) }
    |                          ^^^^^^^
 
 error: type parameter `T` is part of concrete type but not used in parameter list for the `impl Trait` type alias
-  --> $DIR/double-wrap-with-defining-use.rs:12:26
+  --> $DIR/double-wrap-with-defining-use.rs:11:26
    |
 LL |     if true { x } else { a(a(x)) }
    |                          ^^^^^^^
diff --git a/tests/ui/impl-trait/non-defining-uses/double-wrap-with-defining-use.rs b/tests/ui/impl-trait/non-defining-uses/double-wrap-with-defining-use.rs
index 734b1920772f7..39b327eff18ed 100644
--- a/tests/ui/impl-trait/non-defining-uses/double-wrap-with-defining-use.rs
+++ b/tests/ui/impl-trait/non-defining-uses/double-wrap-with-defining-use.rs
@@ -1,7 +1,6 @@
 // Regression test for ICE from issue #140545
 // The error message is confusing and wrong, but that's a different problem (#139350)
 
-//@ edition:2018
 //@ revisions: current next
 //@[next] compile-flags: -Znext-solver
 //@ ignore-compare-mode-next-solver (explicit revisions)
diff --git a/tests/ui/impl-trait/non-defining-uses/ice-issue-146191.current.stderr b/tests/ui/impl-trait/non-defining-uses/ice-issue-146191.current.stderr
index ccbe2d3593c66..5dc66f454652a 100644
--- a/tests/ui/impl-trait/non-defining-uses/ice-issue-146191.current.stderr
+++ b/tests/ui/impl-trait/non-defining-uses/ice-issue-146191.current.stderr
@@ -5,7 +5,7 @@ LL | fn create_complex_future() -> impl Future<Output = impl ReturnsSend> {
    |                                                    ^^^^^^^^^^^^^^^^ the trait `ReturnsSend` is not implemented for `()`
    |
 help: this trait has no implementations, consider adding one
-  --> $DIR/ice-issue-146191.rs:14:1
+  --> $DIR/ice-issue-146191.rs:13:1
    |
 LL | trait ReturnsSend {}
    | ^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/impl-trait/non-defining-uses/ice-issue-146191.next.stderr b/tests/ui/impl-trait/non-defining-uses/ice-issue-146191.next.stderr
index e8b551c65fc0c..4a88359ca9679 100644
--- a/tests/ui/impl-trait/non-defining-uses/ice-issue-146191.next.stderr
+++ b/tests/ui/impl-trait/non-defining-uses/ice-issue-146191.next.stderr
@@ -4,14 +4,6 @@ error[E0282]: type annotations needed
 LL |     async { create_complex_future().await }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type
 
-error[E0282]: type annotations needed
-  --> $DIR/ice-issue-146191.rs:8:5
-   |
-LL |     async { create_complex_future().await }
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/impl-trait/non-defining-uses/ice-issue-146191.rs b/tests/ui/impl-trait/non-defining-uses/ice-issue-146191.rs
index 356f7d01eb9b7..84f139da4e32a 100644
--- a/tests/ui/impl-trait/non-defining-uses/ice-issue-146191.rs
+++ b/tests/ui/impl-trait/non-defining-uses/ice-issue-146191.rs
@@ -8,7 +8,6 @@ fn create_complex_future() -> impl Future<Output = impl ReturnsSend> {
     async { create_complex_future().await }
     //[current]~^ ERROR recursion in an async block requires
     //[next]~^^ ERROR type annotations needed
-    //[next]~| ERROR type annotations needed
 }
 
 trait ReturnsSend {}
diff --git a/tests/ui/impl-trait/two_tait_defining_each_other2.next.stderr b/tests/ui/impl-trait/two_tait_defining_each_other2.next.stderr
index 785e5fdeb6433..9b18a9715f21f 100644
--- a/tests/ui/impl-trait/two_tait_defining_each_other2.next.stderr
+++ b/tests/ui/impl-trait/two_tait_defining_each_other2.next.stderr
@@ -4,12 +4,6 @@ error[E0282]: type annotations needed
 LL | fn muh(x: A) -> B {
    |        ^ cannot infer type
 
-error[E0282]: type annotations needed
-  --> $DIR/two_tait_defining_each_other2.rs:14:5
-   |
-LL |     x // B's hidden type is A (opaquely)
-   |     ^ cannot infer type
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/impl-trait/two_tait_defining_each_other2.rs b/tests/ui/impl-trait/two_tait_defining_each_other2.rs
index 99262f4bc4b38..ec2963249f9da 100644
--- a/tests/ui/impl-trait/two_tait_defining_each_other2.rs
+++ b/tests/ui/impl-trait/two_tait_defining_each_other2.rs
@@ -12,8 +12,7 @@ trait Foo {}
 fn muh(x: A) -> B {
     //[next]~^ ERROR: type annotations needed
     x // B's hidden type is A (opaquely)
-    //[next]~^ ERROR: type annotations needed
-    //[current]~^^ ERROR opaque type's hidden type cannot be another opaque type
+    //[current]~^ ERROR opaque type's hidden type cannot be another opaque type
 }
 
 struct Bar;

From 92646739fe52bc4c40756db71f78fe83b666847e Mon Sep 17 00:00:00 2001
From: aklaiber <alex.klaiber@gmail.com>
Date: Tue, 16 Sep 2025 06:36:22 +0200
Subject: [PATCH 1082/1889] Add regression test for issue 91831

---
 .../ex3-both-anon-regions-one-is-struct-5.rs  | 13 ++++++++++++
 ...3-both-anon-regions-one-is-struct-5.stderr | 20 +++++++++++++++++++
 2 files changed, 33 insertions(+)
 create mode 100644 tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-one-is-struct-5.rs
 create mode 100644 tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-one-is-struct-5.stderr

diff --git a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-one-is-struct-5.rs b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-one-is-struct-5.rs
new file mode 100644
index 0000000000000..16039f177b4de
--- /dev/null
+++ b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-one-is-struct-5.rs
@@ -0,0 +1,13 @@
+// Regression test for #91831
+
+struct Foo<'a>(&'a i32);
+
+impl<'a> Foo<'a> {
+    fn modify(&'a mut self) {}
+}
+
+fn bar(foo: &mut Foo) {
+    foo.modify(); //~ ERROR lifetime may not live long enough
+}
+
+fn main() {}
diff --git a/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-one-is-struct-5.stderr b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-one-is-struct-5.stderr
new file mode 100644
index 0000000000000..f02b65230b6eb
--- /dev/null
+++ b/tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-one-is-struct-5.stderr
@@ -0,0 +1,20 @@
+error: lifetime may not live long enough
+  --> $DIR/ex3-both-anon-regions-one-is-struct-5.rs:10:5
+   |
+LL | fn bar(foo: &mut Foo) {
+   |        ---  - let's call the lifetime of this reference `'1`
+   |        |
+   |        has type `&mut Foo<'2>`
+LL |     foo.modify();
+   |     ^^^^^^^^^^^^ argument requires that `'1` must outlive `'2`
+   |
+   = note: requirement occurs because of a mutable reference to `Foo<'_>`
+   = note: mutable references are invariant over their type parameter
+   = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
+help: consider introducing a named lifetime parameter
+   |
+LL | fn bar<'a>(foo: &'a mut Foo<'a>) {
+   |       ++++       ++        ++++
+
+error: aborting due to 1 previous error
+

From 3b2bbcd87ebdf9c1a62b1169667481cafe6d8d5d Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Thu, 18 Sep 2025 10:57:13 +0200
Subject: [PATCH 1083/1889] internal constraints are better than placeholder
 outlives

---
 .../rustc_borrowck/src/region_infer/mod.rs    |  7 ++--
 .../hr-do-not-blame-outlives-static-ice.rs    | 17 ++++++++++
 ...hr-do-not-blame-outlives-static-ice.stderr | 34 +++++++++++++++++++
 .../do-not-blame-outlives-static-ice.rs       | 12 +++++++
 .../do-not-blame-outlives-static-ice.stderr   | 17 ++++++++++
 5 files changed, 84 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/associated-inherent-types/hr-do-not-blame-outlives-static-ice.rs
 create mode 100644 tests/ui/associated-inherent-types/hr-do-not-blame-outlives-static-ice.stderr
 create mode 100644 tests/ui/higher-ranked/do-not-blame-outlives-static-ice.rs
 create mode 100644 tests/ui/higher-ranked/do-not-blame-outlives-static-ice.stderr

diff --git a/compiler/rustc_borrowck/src/region_infer/mod.rs b/compiler/rustc_borrowck/src/region_infer/mod.rs
index f57456949bb5e..bd017b213b645 100644
--- a/compiler/rustc_borrowck/src/region_infer/mod.rs
+++ b/compiler/rustc_borrowck/src/region_infer/mod.rs
@@ -1726,9 +1726,10 @@ impl<'tcx> RegionInferenceContext<'tcx> {
                 // `BoringNoLocation` constraints can point to user-written code, but are less
                 // specific, and are not used for relations that would make sense to blame.
                 ConstraintCategory::BoringNoLocation => 6,
-                // Do not blame internal constraints.
-                ConstraintCategory::OutlivesUnnameablePlaceholder(_) => 7,
-                ConstraintCategory::Internal => 8,
+                // Do not blame internal constraints if we can avoid it. Never blame
+                // the `'region: 'static` constraints introduced by placeholder outlives.
+                ConstraintCategory::Internal => 7,
+                ConstraintCategory::OutlivesUnnameablePlaceholder(_) => 8,
             };
 
             debug!("constraint {constraint:?} category: {category:?}, interest: {interest:?}");
diff --git a/tests/ui/associated-inherent-types/hr-do-not-blame-outlives-static-ice.rs b/tests/ui/associated-inherent-types/hr-do-not-blame-outlives-static-ice.rs
new file mode 100644
index 0000000000000..e5c1f47b9e02b
--- /dev/null
+++ b/tests/ui/associated-inherent-types/hr-do-not-blame-outlives-static-ice.rs
@@ -0,0 +1,17 @@
+//@ compile-flags: -Zdeduplicate-diagnostics=yes
+
+// Regression test for #146467.
+#![feature(inherent_associated_types)]
+//~^ WARN the feature `inherent_associated_types` is incomplete
+
+struct Foo<T>(T);
+
+impl<'a> Foo<fn(&())> {
+    //~^ ERROR the lifetime parameter `'a` is not constrained by the impl trait
+    type Assoc = &'a ();
+}
+
+fn foo(_: for<'a> fn(Foo<fn(&'a ())>::Assoc)) {}
+//~^ ERROR mismatched types
+//~| ERROR higher-ranked subtype error
+fn main() {}
diff --git a/tests/ui/associated-inherent-types/hr-do-not-blame-outlives-static-ice.stderr b/tests/ui/associated-inherent-types/hr-do-not-blame-outlives-static-ice.stderr
new file mode 100644
index 0000000000000..4c0726d4ddca9
--- /dev/null
+++ b/tests/ui/associated-inherent-types/hr-do-not-blame-outlives-static-ice.stderr
@@ -0,0 +1,34 @@
+warning: the feature `inherent_associated_types` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/hr-do-not-blame-outlives-static-ice.rs:4:12
+   |
+LL | #![feature(inherent_associated_types)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #8995 <https://github.com/rust-lang/rust/issues/8995> for more information
+   = note: `#[warn(incomplete_features)]` on by default
+
+error[E0207]: the lifetime parameter `'a` is not constrained by the impl trait, self type, or predicates
+  --> $DIR/hr-do-not-blame-outlives-static-ice.rs:9:6
+   |
+LL | impl<'a> Foo<fn(&())> {
+   |      ^^ unconstrained lifetime parameter
+
+error[E0308]: mismatched types
+  --> $DIR/hr-do-not-blame-outlives-static-ice.rs:14:11
+   |
+LL | fn foo(_: for<'a> fn(Foo<fn(&'a ())>::Assoc)) {}
+   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other
+   |
+   = note: expected struct `Foo<for<'a> fn(&'a ())>`
+              found struct `Foo<for<'a> fn(&'a ())>`
+
+error: higher-ranked subtype error
+  --> $DIR/hr-do-not-blame-outlives-static-ice.rs:14:1
+   |
+LL | fn foo(_: for<'a> fn(Foo<fn(&'a ())>::Assoc)) {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 3 previous errors; 1 warning emitted
+
+Some errors have detailed explanations: E0207, E0308.
+For more information about an error, try `rustc --explain E0207`.
diff --git a/tests/ui/higher-ranked/do-not-blame-outlives-static-ice.rs b/tests/ui/higher-ranked/do-not-blame-outlives-static-ice.rs
new file mode 100644
index 0000000000000..dfdb816652c44
--- /dev/null
+++ b/tests/ui/higher-ranked/do-not-blame-outlives-static-ice.rs
@@ -0,0 +1,12 @@
+//@ compile-flags: -Zdeduplicate-diagnostics=yes
+
+// Regression test for #146467.
+trait Trait { type Assoc; }
+
+impl Trait for fn(&()) { type Assoc = (); }
+
+fn f(_: for<'a> fn(<fn(&'a ()) as Trait>::Assoc)) {}
+//~^ ERROR implementation of `Trait` is not general enough
+//~| ERROR higher-ranked subtype error
+
+fn main() {}
diff --git a/tests/ui/higher-ranked/do-not-blame-outlives-static-ice.stderr b/tests/ui/higher-ranked/do-not-blame-outlives-static-ice.stderr
new file mode 100644
index 0000000000000..c75a063e45fa0
--- /dev/null
+++ b/tests/ui/higher-ranked/do-not-blame-outlives-static-ice.stderr
@@ -0,0 +1,17 @@
+error: implementation of `Trait` is not general enough
+  --> $DIR/do-not-blame-outlives-static-ice.rs:8:9
+   |
+LL | fn f(_: for<'a> fn(<fn(&'a ()) as Trait>::Assoc)) {}
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `Trait` is not general enough
+   |
+   = note: `for<'a> fn(&'a ())` must implement `Trait`, for any lifetime `'0`...
+   = note: ...but `Trait` is actually implemented for the type `for<'a> fn(&'a ())`
+
+error: higher-ranked subtype error
+  --> $DIR/do-not-blame-outlives-static-ice.rs:8:1
+   |
+LL | fn f(_: for<'a> fn(<fn(&'a ()) as Trait>::Assoc)) {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+

From 1a56d279b8dee896dd46552806686fac513336a7 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Thu, 18 Sep 2025 20:00:31 +0800
Subject: [PATCH 1084/1889] Fix applicable after l_curly for
 replace_is_method_with_if_let_method

---
 .../replace_is_method_with_if_let_method.rs    | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_is_method_with_if_let_method.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_is_method_with_if_let_method.rs
index 5ef8ba46b9e51..f507cae1bb0de 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_is_method_with_if_let_method.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_is_method_with_if_let_method.rs
@@ -31,6 +31,9 @@ pub(crate) fn replace_is_method_with_if_let_method(
         ast::Expr::MethodCallExpr(call) => call,
         _ => return None,
     };
+    if ctx.offset() > if_expr.then_branch()?.stmt_list()?.l_curly_token()?.text_range().end() {
+        return None;
+    }
 
     let name_ref = call_expr.name_ref()?;
     match name_ref.text().as_str() {
@@ -188,6 +191,21 @@ fn main() {
     let x = Ok(1);
     if x.is_e$0rr() {}
 }
+"#,
+        );
+    }
+
+    #[test]
+    fn replace_is_some_with_if_let_some_not_applicable_after_l_curly() {
+        check_assist_not_applicable(
+            replace_is_method_with_if_let_method,
+            r#"
+fn main() {
+    let x = Some(1);
+    if x.is_some() {
+        ()$0
+    }
+}
 "#,
         );
     }

From 2ed53732932716647b72f5f3e32a06da8634d6e2 Mon Sep 17 00:00:00 2001
From: Amanda Stjerna <amanda.stjerna@it.uu.se>
Date: Thu, 18 Sep 2025 13:11:37 +0200
Subject: [PATCH 1085/1889] Clean up universe evaluation during type test
 evaluation

The logic was, as the removed comments suggest, hackish
and meant to implement previous logic that was factored out.
The new logic does exactly what the comments say, and is much
less surprising.
---
 .../rustc_borrowck/src/handle_placeholders.rs | 10 +++-------
 .../rustc_borrowck/src/region_infer/mod.rs    | 20 ++++++++++++++-----
 2 files changed, 18 insertions(+), 12 deletions(-)

diff --git a/compiler/rustc_borrowck/src/handle_placeholders.rs b/compiler/rustc_borrowck/src/handle_placeholders.rs
index 94379cdebf730..6be90994015f3 100644
--- a/compiler/rustc_borrowck/src/handle_placeholders.rs
+++ b/compiler/rustc_borrowck/src/handle_placeholders.rs
@@ -166,13 +166,9 @@ impl RegionTracker {
         }
     }
 
-    /// Determine if the tracked universes of the two SCCs are compatible.
-    pub(crate) fn universe_compatible_with(&self, other: Self) -> bool {
-        // HACK: We first check whether we can name the highest existential universe
-        // of `other`. This only exists to avoid errors in case that scc already
-        // depends on a placeholder it cannot name itself.
-        self.max_nameable_universe().can_name(other.max_nameable_universe())
-            || other.reachable_placeholders.can_be_named_by(self.max_nameable_universe())
+    /// Determine if we can name all the placeholders in `other`.
+    pub(crate) fn can_name_all_placeholders(&self, other: Self) -> bool {
+        other.reachable_placeholders.can_be_named_by(self.max_nameable_universe.0)
     }
 
     /// If this SCC reaches a placeholder it can't name, return it.
diff --git a/compiler/rustc_borrowck/src/region_infer/mod.rs b/compiler/rustc_borrowck/src/region_infer/mod.rs
index f57456949bb5e..5f4bfd9df48e5 100644
--- a/compiler/rustc_borrowck/src/region_infer/mod.rs
+++ b/compiler/rustc_borrowck/src/region_infer/mod.rs
@@ -571,11 +571,15 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         }
     }
 
-    /// Returns `true` if all the elements in the value of `scc_b` are nameable
+    /// Returns `true` if all the placeholders in the value of `scc_b` are nameable
     /// in `scc_a`. Used during constraint propagation, and only once
     /// the value of `scc_b` has been computed.
-    fn universe_compatible(&self, scc_b: ConstraintSccIndex, scc_a: ConstraintSccIndex) -> bool {
-        self.scc_annotations[scc_a].universe_compatible_with(self.scc_annotations[scc_b])
+    fn can_name_all_placeholders(
+        &self,
+        scc_a: ConstraintSccIndex,
+        scc_b: ConstraintSccIndex,
+    ) -> bool {
+        self.scc_annotations[scc_a].can_name_all_placeholders(self.scc_annotations[scc_b])
     }
 
     /// Once regions have been propagated, this method is used to see
@@ -964,16 +968,22 @@ impl<'tcx> RegionInferenceContext<'tcx> {
             return true;
         }
 
+        let fr_static = self.universal_regions().fr_static;
+
         // If we are checking that `'sup: 'sub`, and `'sub` contains
         // some placeholder that `'sup` cannot name, then this is only
         // true if `'sup` outlives static.
-        if !self.universe_compatible(sub_region_scc, sup_region_scc) {
+        //
+        // Avoid infinite recursion if `sub_region` is already `'static`
+        if sub_region != fr_static
+            && !self.can_name_all_placeholders(sup_region_scc, sub_region_scc)
+        {
             debug!(
                 "sub universe `{sub_region_scc:?}` is not nameable \
                 by super `{sup_region_scc:?}`, promoting to static",
             );
 
-            return self.eval_outlives(sup_region, self.universal_regions().fr_static);
+            return self.eval_outlives(sup_region, fr_static);
         }
 
         // Both the `sub_region` and `sup_region` consist of the union

From 389907a17e5c1eecd9fe41a53ca145f42dcd1488 Mon Sep 17 00:00:00 2001
From: Jules Bertholet <julesbertholet@quoi.xyz>
Date: Mon, 15 Sep 2025 09:42:14 -0400
Subject: [PATCH 1086/1889] Enforce E0719 only for trait aliases

---
 .../src/error_codes/E0719.md                  |  14 +-
 .../src/hir_ty_lowering/bounds.rs             |  27 +-
 .../src/hir_ty_lowering/dyn_trait.rs          |   6 +-
 .../src/hir_ty_lowering/mod.rs                |   3 +-
 .../duplicate-bound-err.rs                    | 114 +++
 .../duplicate-bound-err.stderr                | 268 +++++++
 .../associated-type-bounds/duplicate-bound.rs | 240 ++++++
 tests/ui/associated-type-bounds/duplicate.rs  | 278 -------
 .../associated-type-bounds/duplicate.stderr   | 751 ------------------
 ...sociated-types-overridden-binding-2.stderr |   2 +-
 ...associated-types-overridden-binding.stderr |   2 +-
 tests/ui/error-codes/E0719.rs                 |   5 -
 tests/ui/error-codes/E0719.stderr             |  34 +-
 13 files changed, 650 insertions(+), 1094 deletions(-)
 create mode 100644 tests/ui/associated-type-bounds/duplicate-bound-err.rs
 create mode 100644 tests/ui/associated-type-bounds/duplicate-bound-err.stderr
 create mode 100644 tests/ui/associated-type-bounds/duplicate-bound.rs
 delete mode 100644 tests/ui/associated-type-bounds/duplicate.rs
 delete mode 100644 tests/ui/associated-type-bounds/duplicate.stderr

diff --git a/compiler/rustc_error_codes/src/error_codes/E0719.md b/compiler/rustc_error_codes/src/error_codes/E0719.md
index cd981db1058a6..17cbd2de49efd 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0719.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0719.md
@@ -1,4 +1,4 @@
-An associated type value was specified more than once.
+An associated item value was specified more than once in a trait object.
 
 Erroneous code example:
 
@@ -7,21 +7,15 @@ trait FooTrait {}
 trait BarTrait {}
 
 // error: associated type `Item` in trait `Iterator` is specified twice
-struct Foo<T: Iterator<Item: FooTrait, Item: BarTrait>> { f: T }
+type Foo = dyn Iterator<Item = u32, Item = u32>;
 ```
 
-`Item` in trait `Iterator` cannot be specified multiple times for struct `Foo`.
-To fix this, create a new trait that is a combination of the desired traits and
-specify the associated type with the new trait.
+To fix this, remove the duplicate specifier:
 
 Corrected example:
 
 ```
-trait FooTrait {}
-trait BarTrait {}
-trait FooBarTrait: FooTrait + BarTrait {}
-
-struct Foo<T: Iterator<Item: FooBarTrait>> { f: T } // ok!
+type Foo = dyn Iterator<Item = u32>; // ok!
 ```
 
 For more information about associated types, see [the book][bk-at]. For more
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
index 99dc8e6e52217..a8d75ba223ab3 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
@@ -362,6 +362,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                         param_ty,
                         bounds,
                         predicate_filter,
+                        false,
                     );
                 }
                 hir::GenericBound::Outlives(lifetime) => {
@@ -402,7 +403,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         trait_ref: ty::PolyTraitRef<'tcx>,
         constraint: &hir::AssocItemConstraint<'tcx>,
         bounds: &mut Vec<(ty::Clause<'tcx>, Span)>,
-        duplicates: &mut FxIndexMap<DefId, Span>,
+        duplicates: Option<&mut FxIndexMap<DefId, Span>>,
         path_span: Span,
         predicate_filter: PredicateFilter,
     ) -> Result<(), ErrorGuaranteed> {
@@ -458,17 +459,19 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             )
             .expect("failed to find associated item");
 
-        duplicates
-            .entry(assoc_item.def_id)
-            .and_modify(|prev_span| {
-                self.dcx().emit_err(errors::ValueOfAssociatedStructAlreadySpecified {
-                    span: constraint.span,
-                    prev_span: *prev_span,
-                    item_name: constraint.ident,
-                    def_path: tcx.def_path_str(assoc_item.container_id(tcx)),
-                });
-            })
-            .or_insert(constraint.span);
+        if let Some(duplicates) = duplicates {
+            duplicates
+                .entry(assoc_item.def_id)
+                .and_modify(|prev_span| {
+                    self.dcx().emit_err(errors::ValueOfAssociatedStructAlreadySpecified {
+                        span: constraint.span,
+                        prev_span: *prev_span,
+                        item_name: constraint.ident,
+                        def_path: tcx.def_path_str(assoc_item.container_id(tcx)),
+                    });
+                })
+                .or_insert(constraint.span);
+        }
 
         let projection_term = if let ty::AssocTag::Fn = assoc_tag {
             let bound_vars = tcx.late_bound_vars(constraint.hir_id);
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_trait.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_trait.rs
index c248cd7fec2e5..a4179776572d6 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_trait.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_trait.rs
@@ -60,6 +60,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 dummy_self,
                 &mut user_written_bounds,
                 PredicateFilter::SelfOnly,
+                true,
             );
             if let Err(GenericArgCountMismatch { invalid_args, .. }) = result.correct {
                 potential_assoc_types.extend(invalid_args);
@@ -157,10 +158,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 self.dcx()
                     .struct_span_err(
                         span,
-                        format!(
-                            "conflicting associated type bounds for `{item}` when \
-                            expanding trait alias"
-                        ),
+                        format!("conflicting associated type bounds for `{item}`"),
                     )
                     .with_span_label(
                         old_proj_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 9b198d044542f..0ff1fabd7b303 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -752,6 +752,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         self_ty: Ty<'tcx>,
         bounds: &mut Vec<(ty::Clause<'tcx>, Span)>,
         predicate_filter: PredicateFilter,
+        for_dyn: bool,
     ) -> GenericArgCountResult {
         let tcx = self.tcx();
 
@@ -927,7 +928,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 poly_trait_ref,
                 constraint,
                 bounds,
-                &mut dup_constraints,
+                for_dyn.then_some(&mut dup_constraints),
                 constraint.span,
                 predicate_filter,
             );
diff --git a/tests/ui/associated-type-bounds/duplicate-bound-err.rs b/tests/ui/associated-type-bounds/duplicate-bound-err.rs
new file mode 100644
index 0000000000000..50db5de7ca768
--- /dev/null
+++ b/tests/ui/associated-type-bounds/duplicate-bound-err.rs
@@ -0,0 +1,114 @@
+//@ edition: 2024
+
+#![feature(associated_const_equality, type_alias_impl_trait, return_type_notation)]
+#![allow(refining_impl_trait_internal)]
+
+use std::iter;
+
+fn frpit1() -> impl Iterator<Item: Copy, Item: Send> {
+    iter::empty()
+    //~^ ERROR type annotations needed
+}
+fn frpit2() -> impl Iterator<Item: Copy, Item: Copy> {
+    iter::empty()
+    //~^ ERROR type annotations needed
+}
+fn frpit3() -> impl Iterator<Item: 'static, Item: 'static> {
+    iter::empty()
+    //~^ ERROR type annotations needed
+}
+
+type ETAI1<T: Iterator<Item: Copy, Item: Send>> = impl Copy;
+//~^ ERROR unconstrained opaque type
+type ETAI2<T: Iterator<Item: Copy, Item: Copy>> = impl Copy;
+//~^ ERROR unconstrained opaque type
+type ETAI3<T: Iterator<Item: 'static, Item: 'static>> = impl Copy;
+//~^ ERROR unconstrained opaque type
+
+type ETAI4 = impl Iterator<Item: Copy, Item: Send>;
+//~^ ERROR unconstrained opaque type
+type ETAI5 = impl Iterator<Item: Copy, Item: Copy>;
+//~^ ERROR unconstrained opaque type
+type ETAI6 = impl Iterator<Item: 'static, Item: 'static>;
+//~^ ERROR unconstrained opaque type
+
+fn mismatch() -> impl Iterator<Item: Copy, Item: Send> {
+    //~^ ERROR [E0277]
+    iter::empty::<*const ()>()
+}
+
+fn mismatch_2() -> impl Iterator<Item: Copy, Item: Send> {
+    //~^ ERROR [E0277]
+    iter::empty::<String>()
+}
+
+trait Trait {
+    type Gat<T>;
+
+    const ASSOC: i32;
+
+    fn foo() -> impl Sized;
+}
+
+impl Trait for () {
+    type Gat<T> = ();
+
+    const ASSOC: i32 = 3;
+
+    fn foo() {}
+}
+
+impl Trait for u32 {
+    type Gat<T> = ();
+
+    const ASSOC: i32 = 4;
+
+    fn foo() -> u32 {
+        42
+    }
+}
+
+fn uncallable(_: impl Iterator<Item = i32, Item = u32>) {}
+
+fn uncallable_const(_: impl Trait<ASSOC = 3, ASSOC = 4>) {}
+
+fn uncallable_rtn(_: impl Trait<foo(..): Trait<ASSOC = 3>, foo(..): Trait<ASSOC = 4>>) {}
+
+type MustFail = dyn Iterator<Item = i32, Item = u32>;
+//~^ ERROR [E0719]
+//~| ERROR conflicting associated type bounds
+
+trait Trait2 {
+    const ASSOC: u32;
+}
+
+type MustFail2 = dyn Trait2<ASSOC = 3u32, ASSOC = 4u32>;
+//~^ ERROR [E0719]
+//~| ERROR conflicting associated type bounds
+
+type MustFail3 = dyn Iterator<Item = i32, Item = i32>;
+//~^ ERROR [E0719]
+
+type MustFail4 = dyn Trait2<ASSOC = 3u32, ASSOC = 3u32>;
+//~^ ERROR [E0719]
+
+trait Trait3 {
+    fn foo() -> impl Iterator<Item = i32, Item = u32>;
+}
+
+impl Trait3 for () {
+    fn foo() -> impl Iterator<Item = i32, Item = u32> {
+        //~^ ERROR[E0271]
+        //~| ERROR[E0271]
+        [2u32].into_iter()
+    }
+}
+
+fn main() {
+    uncallable(iter::empty::<u32>()); //~ ERROR [E0271]
+    uncallable(iter::empty::<i32>()); //~ ERROR [E0271]
+    uncallable_const(()); //~ ERROR [E0271]
+    uncallable_const(4u32); //~ ERROR [E0271]
+    uncallable_rtn(()); //~ ERROR [E0271]
+    uncallable_rtn(17u32); //~ ERROR [E0271]
+}
diff --git a/tests/ui/associated-type-bounds/duplicate-bound-err.stderr b/tests/ui/associated-type-bounds/duplicate-bound-err.stderr
new file mode 100644
index 0000000000000..6c1dc03676c79
--- /dev/null
+++ b/tests/ui/associated-type-bounds/duplicate-bound-err.stderr
@@ -0,0 +1,268 @@
+error[E0282]: type annotations needed
+  --> $DIR/duplicate-bound-err.rs:9:5
+   |
+LL |     iter::empty()
+   |     ^^^^^^^^^^^ cannot infer type of the type parameter `T` declared on the function `empty`
+   |
+help: consider specifying the generic argument
+   |
+LL |     iter::empty::<T>()
+   |                +++++
+
+error[E0282]: type annotations needed
+  --> $DIR/duplicate-bound-err.rs:13:5
+   |
+LL |     iter::empty()
+   |     ^^^^^^^^^^^ cannot infer type of the type parameter `T` declared on the function `empty`
+   |
+help: consider specifying the generic argument
+   |
+LL |     iter::empty::<T>()
+   |                +++++
+
+error[E0282]: type annotations needed
+  --> $DIR/duplicate-bound-err.rs:17:5
+   |
+LL |     iter::empty()
+   |     ^^^^^^^^^^^ cannot infer type of the type parameter `T` declared on the function `empty`
+   |
+help: consider specifying the generic argument
+   |
+LL |     iter::empty::<T>()
+   |                +++++
+
+error: unconstrained opaque type
+  --> $DIR/duplicate-bound-err.rs:21:51
+   |
+LL | type ETAI1<T: Iterator<Item: Copy, Item: Send>> = impl Copy;
+   |                                                   ^^^^^^^^^
+   |
+   = note: `ETAI1` must be used in combination with a concrete type within the same crate
+
+error: unconstrained opaque type
+  --> $DIR/duplicate-bound-err.rs:23:51
+   |
+LL | type ETAI2<T: Iterator<Item: Copy, Item: Copy>> = impl Copy;
+   |                                                   ^^^^^^^^^
+   |
+   = note: `ETAI2` must be used in combination with a concrete type within the same crate
+
+error: unconstrained opaque type
+  --> $DIR/duplicate-bound-err.rs:25:57
+   |
+LL | type ETAI3<T: Iterator<Item: 'static, Item: 'static>> = impl Copy;
+   |                                                         ^^^^^^^^^
+   |
+   = note: `ETAI3` must be used in combination with a concrete type within the same crate
+
+error: unconstrained opaque type
+  --> $DIR/duplicate-bound-err.rs:28:14
+   |
+LL | type ETAI4 = impl Iterator<Item: Copy, Item: Send>;
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `ETAI4` must be used in combination with a concrete type within the same crate
+
+error: unconstrained opaque type
+  --> $DIR/duplicate-bound-err.rs:30:14
+   |
+LL | type ETAI5 = impl Iterator<Item: Copy, Item: Copy>;
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `ETAI5` must be used in combination with a concrete type within the same crate
+
+error: unconstrained opaque type
+  --> $DIR/duplicate-bound-err.rs:32:14
+   |
+LL | type ETAI6 = impl Iterator<Item: 'static, Item: 'static>;
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `ETAI6` must be used in combination with a concrete type within the same crate
+
+error[E0277]: `*const ()` cannot be sent between threads safely
+  --> $DIR/duplicate-bound-err.rs:35:18
+   |
+LL | fn mismatch() -> impl Iterator<Item: Copy, Item: Send> {
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `*const ()` cannot be sent between threads safely
+LL |
+LL |     iter::empty::<*const ()>()
+   |     -------------------------- return type was inferred to be `std::iter::Empty<*const ()>` here
+   |
+   = help: the trait `Send` is not implemented for `*const ()`
+
+error[E0277]: the trait bound `String: Copy` is not satisfied
+  --> $DIR/duplicate-bound-err.rs:40:20
+   |
+LL | fn mismatch_2() -> impl Iterator<Item: Copy, Item: Send> {
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `String`
+LL |
+LL |     iter::empty::<String>()
+   |     ----------------------- return type was inferred to be `std::iter::Empty<String>` here
+
+error[E0271]: expected `IntoIter<u32, 1>` to be an iterator that yields `i32`, but it yields `u32`
+  --> $DIR/duplicate-bound-err.rs:100:17
+   |
+LL |     fn foo() -> impl Iterator<Item = i32, Item = u32> {
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `i32`, found `u32`
+...
+LL |         [2u32].into_iter()
+   |         ------------------ return type was inferred to be `std::array::IntoIter<u32, 1>` here
+
+error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
+  --> $DIR/duplicate-bound-err.rs:77:42
+   |
+LL | type MustFail = dyn Iterator<Item = i32, Item = u32>;
+   |                              ----------  ^^^^^^^^^^ re-bound here
+   |                              |
+   |                              `Item` bound here first
+
+error: conflicting associated type bounds for `Item`
+  --> $DIR/duplicate-bound-err.rs:77:17
+   |
+LL | type MustFail = dyn Iterator<Item = i32, Item = u32>;
+   |                 ^^^^^^^^^^^^^----------^^----------^
+   |                              |           |
+   |                              |           `Item` is specified to be `u32` here
+   |                              `Item` is specified to be `i32` here
+
+error[E0719]: the value of the associated type `ASSOC` in trait `Trait2` is already specified
+  --> $DIR/duplicate-bound-err.rs:85:43
+   |
+LL | type MustFail2 = dyn Trait2<ASSOC = 3u32, ASSOC = 4u32>;
+   |                             ------------  ^^^^^^^^^^^^ re-bound here
+   |                             |
+   |                             `ASSOC` bound here first
+
+error: conflicting associated type bounds for `ASSOC`
+  --> $DIR/duplicate-bound-err.rs:85:18
+   |
+LL | type MustFail2 = dyn Trait2<ASSOC = 3u32, ASSOC = 4u32>;
+   |                  ^^^^^^^^^^^------------^^------------^
+   |                             |             |
+   |                             |             `ASSOC` is specified to be `4` here
+   |                             `ASSOC` is specified to be `3` here
+
+error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
+  --> $DIR/duplicate-bound-err.rs:89:43
+   |
+LL | type MustFail3 = dyn Iterator<Item = i32, Item = i32>;
+   |                               ----------  ^^^^^^^^^^ re-bound here
+   |                               |
+   |                               `Item` bound here first
+
+error[E0719]: the value of the associated type `ASSOC` in trait `Trait2` is already specified
+  --> $DIR/duplicate-bound-err.rs:92:43
+   |
+LL | type MustFail4 = dyn Trait2<ASSOC = 3u32, ASSOC = 3u32>;
+   |                             ------------  ^^^^^^^^^^^^ re-bound here
+   |                             |
+   |                             `ASSOC` bound here first
+
+error[E0271]: expected `impl Iterator<Item = u32>` to be an iterator that yields `i32`, but it yields `u32`
+  --> $DIR/duplicate-bound-err.rs:100:17
+   |
+LL |     fn foo() -> impl Iterator<Item = i32, Item = u32> {
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `i32`, found `u32`
+   |
+note: required by a bound in `Trait3::foo::{anon_assoc#0}`
+  --> $DIR/duplicate-bound-err.rs:96:31
+   |
+LL |     fn foo() -> impl Iterator<Item = i32, Item = u32>;
+   |                               ^^^^^^^^^^ required by this bound in `Trait3::foo::{anon_assoc#0}`
+
+error[E0271]: expected `Empty<u32>` to be an iterator that yields `i32`, but it yields `u32`
+  --> $DIR/duplicate-bound-err.rs:108:16
+   |
+LL |     uncallable(iter::empty::<u32>());
+   |     ---------- ^^^^^^^^^^^^^^^^^^^^ expected `i32`, found `u32`
+   |     |
+   |     required by a bound introduced by this call
+   |
+note: required by a bound in `uncallable`
+  --> $DIR/duplicate-bound-err.rs:71:32
+   |
+LL | fn uncallable(_: impl Iterator<Item = i32, Item = u32>) {}
+   |                                ^^^^^^^^^^ required by this bound in `uncallable`
+
+error[E0271]: expected `Empty<i32>` to be an iterator that yields `u32`, but it yields `i32`
+  --> $DIR/duplicate-bound-err.rs:109:16
+   |
+LL |     uncallable(iter::empty::<i32>());
+   |     ---------- ^^^^^^^^^^^^^^^^^^^^ expected `u32`, found `i32`
+   |     |
+   |     required by a bound introduced by this call
+   |
+note: required by a bound in `uncallable`
+  --> $DIR/duplicate-bound-err.rs:71:44
+   |
+LL | fn uncallable(_: impl Iterator<Item = i32, Item = u32>) {}
+   |                                            ^^^^^^^^^^ required by this bound in `uncallable`
+
+error[E0271]: type mismatch resolving `<() as Trait>::ASSOC == 4`
+  --> $DIR/duplicate-bound-err.rs:110:22
+   |
+LL |     uncallable_const(());
+   |     ---------------- ^^ expected `4`, found `3`
+   |     |
+   |     required by a bound introduced by this call
+   |
+   = note: expected constant `4`
+              found constant `3`
+note: required by a bound in `uncallable_const`
+  --> $DIR/duplicate-bound-err.rs:73:46
+   |
+LL | fn uncallable_const(_: impl Trait<ASSOC = 3, ASSOC = 4>) {}
+   |                                              ^^^^^^^^^ required by this bound in `uncallable_const`
+
+error[E0271]: type mismatch resolving `<u32 as Trait>::ASSOC == 3`
+  --> $DIR/duplicate-bound-err.rs:111:22
+   |
+LL |     uncallable_const(4u32);
+   |     ---------------- ^^^^ expected `3`, found `4`
+   |     |
+   |     required by a bound introduced by this call
+   |
+   = note: expected constant `3`
+              found constant `4`
+note: required by a bound in `uncallable_const`
+  --> $DIR/duplicate-bound-err.rs:73:35
+   |
+LL | fn uncallable_const(_: impl Trait<ASSOC = 3, ASSOC = 4>) {}
+   |                                   ^^^^^^^^^ required by this bound in `uncallable_const`
+
+error[E0271]: type mismatch resolving `<() as Trait>::ASSOC == 4`
+  --> $DIR/duplicate-bound-err.rs:112:20
+   |
+LL |     uncallable_rtn(());
+   |     -------------- ^^ expected `4`, found `3`
+   |     |
+   |     required by a bound introduced by this call
+   |
+   = note: expected constant `4`
+              found constant `3`
+note: required by a bound in `uncallable_rtn`
+  --> $DIR/duplicate-bound-err.rs:75:75
+   |
+LL | fn uncallable_rtn(_: impl Trait<foo(..): Trait<ASSOC = 3>, foo(..): Trait<ASSOC = 4>>) {}
+   |                                                                           ^^^^^^^^^ required by this bound in `uncallable_rtn`
+
+error[E0271]: type mismatch resolving `<u32 as Trait>::ASSOC == 3`
+  --> $DIR/duplicate-bound-err.rs:113:20
+   |
+LL |     uncallable_rtn(17u32);
+   |     -------------- ^^^^^ expected `3`, found `4`
+   |     |
+   |     required by a bound introduced by this call
+   |
+   = note: expected constant `3`
+              found constant `4`
+note: required by a bound in `uncallable_rtn`
+  --> $DIR/duplicate-bound-err.rs:75:48
+   |
+LL | fn uncallable_rtn(_: impl Trait<foo(..): Trait<ASSOC = 3>, foo(..): Trait<ASSOC = 4>>) {}
+   |                                                ^^^^^^^^^ required by this bound in `uncallable_rtn`
+
+error: aborting due to 25 previous errors
+
+Some errors have detailed explanations: E0271, E0277, E0282, E0719.
+For more information about an error, try `rustc --explain E0271`.
diff --git a/tests/ui/associated-type-bounds/duplicate-bound.rs b/tests/ui/associated-type-bounds/duplicate-bound.rs
new file mode 100644
index 0000000000000..97b2b3905a55e
--- /dev/null
+++ b/tests/ui/associated-type-bounds/duplicate-bound.rs
@@ -0,0 +1,240 @@
+//@ edition: 2024
+//@ run-pass
+
+#![feature(associated_const_equality, return_type_notation)]
+#![allow(dead_code, refining_impl_trait_internal, type_alias_bounds)]
+
+use std::iter;
+use std::mem::ManuallyDrop;
+
+struct SI1<T: Iterator<Item: Copy, Item: Send>> {
+    f: T,
+}
+struct SI2<T: Iterator<Item: Copy, Item: Copy>> {
+    f: T,
+}
+struct SI3<T: Iterator<Item: 'static, Item: 'static>> {
+    f: T,
+}
+struct SW1<T>
+where
+    T: Iterator<Item: Copy, Item: Send>,
+{
+    f: T,
+}
+struct SW2<T>
+where
+    T: Iterator<Item: Copy, Item: Copy>,
+{
+    f: T,
+}
+struct SW3<T>
+where
+    T: Iterator<Item: 'static, Item: 'static>,
+{
+    f: T,
+}
+
+enum EI1<T: Iterator<Item: Copy, Item: Send>> {
+    V(T),
+}
+enum EI2<T: Iterator<Item: Copy, Item: Copy>> {
+    V(T),
+}
+enum EI3<T: Iterator<Item: 'static, Item: 'static>> {
+    V(T),
+}
+enum EW1<T>
+where
+    T: Iterator<Item: Copy, Item: Send>,
+{
+    V(T),
+}
+enum EW2<T>
+where
+    T: Iterator<Item: Copy, Item: Copy>,
+{
+    V(T),
+}
+enum EW3<T>
+where
+    T: Iterator<Item: 'static, Item: 'static>,
+{
+    V(T),
+}
+
+union UI1<T: Iterator<Item: Copy, Item: Send>> {
+    f: ManuallyDrop<T>,
+}
+union UI2<T: Iterator<Item: Copy, Item: Copy>> {
+    f: ManuallyDrop<T>,
+}
+union UI3<T: Iterator<Item: 'static, Item: 'static>> {
+    f: ManuallyDrop<T>,
+}
+union UW1<T>
+where
+    T: Iterator<Item: Copy, Item: Send>,
+{
+    f: ManuallyDrop<T>,
+}
+union UW2<T>
+where
+    T: Iterator<Item: Copy, Item: Copy>,
+{
+    f: ManuallyDrop<T>,
+}
+union UW3<T>
+where
+    T: Iterator<Item: 'static, Item: 'static>,
+{
+    f: ManuallyDrop<T>,
+}
+
+fn fi1<T: Iterator<Item: Copy, Item: Send>>() {}
+fn fi2<T: Iterator<Item: Copy, Item: Copy>>() {}
+fn fi3<T: Iterator<Item: 'static, Item: 'static>>() {}
+fn fw1<T>()
+where
+    T: Iterator<Item: Copy, Item: Send>,
+{
+}
+fn fw2<T>()
+where
+    T: Iterator<Item: Copy, Item: Copy>,
+{
+}
+fn fw3<T>()
+where
+    T: Iterator<Item: 'static, Item: 'static>,
+{
+}
+
+fn frpit1() -> impl Iterator<Item: Copy, Item: Send> {
+    iter::empty::<u32>()
+}
+fn frpit2() -> impl Iterator<Item: Copy, Item: Copy> {
+    iter::empty::<u32>()
+}
+fn frpit3() -> impl Iterator<Item: 'static, Item: 'static> {
+    iter::empty::<u32>()
+}
+fn fapit1(_: impl Iterator<Item: Copy, Item: Send>) {}
+fn fapit2(_: impl Iterator<Item: Copy, Item: Copy>) {}
+fn fapit3(_: impl Iterator<Item: 'static, Item: 'static>) {}
+
+type TAI1<T: Iterator<Item: Copy, Item: Send>> = T;
+type TAI2<T: Iterator<Item: Copy, Item: Copy>> = T;
+type TAI3<T: Iterator<Item: 'static, Item: 'static>> = T;
+type TAW1<T>
+where
+    T: Iterator<Item: Copy, Item: Send>,
+= T;
+type TAW2<T>
+where
+    T: Iterator<Item: Copy, Item: Copy>,
+= T;
+type TAW3<T>
+where
+    T: Iterator<Item: 'static, Item: 'static>,
+= T;
+
+trait TRI1<T: Iterator<Item: Copy, Item: Send>> {}
+trait TRI2<T: Iterator<Item: Copy, Item: Copy>> {}
+trait TRI3<T: Iterator<Item: 'static, Item: 'static>> {}
+trait TRS1: Iterator<Item: Copy, Item: Send> {}
+trait TRS2: Iterator<Item: Copy, Item: Copy> {}
+trait TRS3: Iterator<Item: 'static, Item: 'static> {}
+trait TRW1<T>
+where
+    T: Iterator<Item: Copy, Item: Send>,
+{
+}
+trait TRW2<T>
+where
+    T: Iterator<Item: Copy, Item: Copy>,
+{
+}
+trait TRW3<T>
+where
+    T: Iterator<Item: 'static, Item: 'static>,
+{
+}
+trait TRSW1
+where
+    Self: Iterator<Item: Copy, Item: Send>,
+{
+}
+trait TRSW2
+where
+    Self: Iterator<Item: Copy, Item: Copy>,
+{
+}
+trait TRSW3
+where
+    Self: Iterator<Item: 'static, Item: 'static>,
+{
+}
+trait TRA1 {
+    type A: Iterator<Item: Copy, Item: Send>;
+}
+trait TRA2 {
+    type A: Iterator<Item: Copy, Item: Copy>;
+}
+trait TRA3 {
+    type A: Iterator<Item: 'static, Item: 'static>;
+}
+
+trait Trait {
+    type Gat<T>;
+
+    const ASSOC: i32;
+
+    fn foo() -> impl Sized;
+}
+
+impl Trait for () {
+    type Gat<T> = ();
+
+    const ASSOC: i32 = 3;
+
+    fn foo() {}
+}
+
+trait Subtrait: Trait<Gat<u32> = u32, Gat<u64> = u64> {}
+
+fn f<T: Trait<Gat<i32> = (), Gat<i64> = ()>>() {
+    let _: T::Gat<i32> = ();
+    let _: T::Gat<i64> = ();
+}
+
+fn g<T: Trait<Gat<i32> = (), Gat<i64> = &'static str>>() {
+    let _: T::Gat<i32> = ();
+    let _: T::Gat<i64> = "";
+}
+
+fn uncallable(_: impl Iterator<Item = i32, Item = u32>) {}
+
+fn callable(_: impl Iterator<Item = i32, Item = i32>) {}
+
+fn uncallable_const(_: impl Trait<ASSOC = 3, ASSOC = 4>) {}
+
+fn callable_const(_: impl Trait<ASSOC = 3, ASSOC = 3>) {}
+
+fn uncallable_rtn(_: impl Trait<foo(..): Trait<ASSOC = 3>, foo(..): Trait<ASSOC = 4>>) {}
+
+fn callable_rtn(_: impl Trait<foo(..): Send, foo(..): Send, foo(..): Eq>) {}
+
+trait Trait2 {
+    const ASSOC: u32;
+}
+
+trait Trait3 {
+    fn foo() -> impl Iterator<Item = i32, Item = u32>;
+}
+
+fn main() {
+    callable(iter::empty::<i32>());
+    callable_const(());
+    callable_rtn(());
+}
diff --git a/tests/ui/associated-type-bounds/duplicate.rs b/tests/ui/associated-type-bounds/duplicate.rs
deleted file mode 100644
index e9d94787e9829..0000000000000
--- a/tests/ui/associated-type-bounds/duplicate.rs
+++ /dev/null
@@ -1,278 +0,0 @@
-#![feature(type_alias_impl_trait)]
-
-use std::iter;
-use std::mem::ManuallyDrop;
-
-struct SI1<T: Iterator<Item: Copy, Item: Send>> {
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-    f: T,
-}
-struct SI2<T: Iterator<Item: Copy, Item: Copy>> {
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-    f: T,
-}
-struct SI3<T: Iterator<Item: 'static, Item: 'static>> {
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-    f: T,
-}
-struct SW1<T>
-where
-    T: Iterator<Item: Copy, Item: Send>,
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-{
-    f: T,
-}
-struct SW2<T>
-where
-    T: Iterator<Item: Copy, Item: Copy>,
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-{
-    f: T,
-}
-struct SW3<T>
-where
-    T: Iterator<Item: 'static, Item: 'static>,
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-{
-    f: T,
-}
-
-enum EI1<T: Iterator<Item: Copy, Item: Send>> {
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-    V(T),
-}
-enum EI2<T: Iterator<Item: Copy, Item: Copy>> {
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-    V(T),
-}
-enum EI3<T: Iterator<Item: 'static, Item: 'static>> {
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-    V(T),
-}
-enum EW1<T>
-where
-    T: Iterator<Item: Copy, Item: Send>,
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-{
-    V(T),
-}
-enum EW2<T>
-where
-    T: Iterator<Item: Copy, Item: Copy>,
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-{
-    V(T),
-}
-enum EW3<T>
-where
-    T: Iterator<Item: 'static, Item: 'static>,
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-{
-    V(T),
-}
-
-union UI1<T: Iterator<Item: Copy, Item: Send>> {
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-    f: ManuallyDrop<T>,
-}
-union UI2<T: Iterator<Item: Copy, Item: Copy>> {
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-    f: ManuallyDrop<T>,
-}
-union UI3<T: Iterator<Item: 'static, Item: 'static>> {
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-    f: ManuallyDrop<T>,
-}
-union UW1<T>
-where
-    T: Iterator<Item: Copy, Item: Send>,
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-{
-    f: ManuallyDrop<T>,
-}
-union UW2<T>
-where
-    T: Iterator<Item: Copy, Item: Copy>,
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-{
-    f: ManuallyDrop<T>,
-}
-union UW3<T>
-where
-    T: Iterator<Item: 'static, Item: 'static>,
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-{
-    f: ManuallyDrop<T>,
-}
-
-fn FI1<T: Iterator<Item: Copy, Item: Send>>() {}
-//~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-fn FI2<T: Iterator<Item: Copy, Item: Copy>>() {}
-//~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-fn FI3<T: Iterator<Item: 'static, Item: 'static>>() {}
-//~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-fn FW1<T>()
-where
-    T: Iterator<Item: Copy, Item: Send>,
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-{
-}
-fn FW2<T>()
-where
-    T: Iterator<Item: Copy, Item: Copy>,
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-{
-}
-fn FW3<T>()
-where
-    T: Iterator<Item: 'static, Item: 'static>,
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-{
-}
-
-fn FRPIT1() -> impl Iterator<Item: Copy, Item: Send> {
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-    //~| ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-    iter::empty()
-    //~^ ERROR type annotations needed
-}
-fn FRPIT2() -> impl Iterator<Item: Copy, Item: Copy> {
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-    //~| ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-    iter::empty()
-    //~^ ERROR type annotations needed
-}
-fn FRPIT3() -> impl Iterator<Item: 'static, Item: 'static> {
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-    //~| ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-    iter::empty()
-    //~^ ERROR type annotations needed
-}
-fn FAPIT1(_: impl Iterator<Item: Copy, Item: Send>) {}
-//~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-fn FAPIT2(_: impl Iterator<Item: Copy, Item: Copy>) {}
-//~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-fn FAPIT3(_: impl Iterator<Item: 'static, Item: 'static>) {}
-//~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-
-type TAI1<T: Iterator<Item: Copy, Item: Send>> = T;
-//~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-type TAI2<T: Iterator<Item: Copy, Item: Copy>> = T;
-//~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-type TAI3<T: Iterator<Item: 'static, Item: 'static>> = T;
-//~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-type TAW1<T>
-where
-    T: Iterator<Item: Copy, Item: Send>,
-//~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-= T;
-type TAW2<T>
-where
-    T: Iterator<Item: Copy, Item: Copy>,
-//~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-= T;
-type TAW3<T>
-where
-    T: Iterator<Item: 'static, Item: 'static>,
-//~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-= T;
-
-type ETAI1<T: Iterator<Item: Copy, Item: Send>> = impl Copy;
-//~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-//~| ERROR unconstrained opaque type
-type ETAI2<T: Iterator<Item: Copy, Item: Copy>> = impl Copy;
-//~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-//~| ERROR unconstrained opaque type
-type ETAI3<T: Iterator<Item: 'static, Item: 'static>> = impl Copy;
-//~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-//~| ERROR unconstrained opaque type
-type ETAI4 = impl Iterator<Item: Copy, Item: Send>;
-//~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-//~| ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-//~| ERROR unconstrained opaque type
-type ETAI5 = impl Iterator<Item: Copy, Item: Copy>;
-//~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-//~| ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-//~| ERROR unconstrained opaque type
-type ETAI6 = impl Iterator<Item: 'static, Item: 'static>;
-//~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-//~| ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-//~| ERROR unconstrained opaque type
-
-trait TRI1<T: Iterator<Item: Copy, Item: Send>> {}
-//~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-trait TRI2<T: Iterator<Item: Copy, Item: Copy>> {}
-//~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-trait TRI3<T: Iterator<Item: 'static, Item: 'static>> {}
-//~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-trait TRS1: Iterator<Item: Copy, Item: Send> {}
-//~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-//~| ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-//~| ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-trait TRS2: Iterator<Item: Copy, Item: Copy> {}
-//~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-//~| ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-//~| ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-trait TRS3: Iterator<Item: 'static, Item: 'static> {}
-//~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-//~| ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-//~| ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-trait TRW1<T>
-where
-    T: Iterator<Item: Copy, Item: Send>,
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-{
-}
-trait TRW2<T>
-where
-    T: Iterator<Item: Copy, Item: Copy>,
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-{
-}
-trait TRW3<T>
-where
-    T: Iterator<Item: 'static, Item: 'static>,
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-{
-}
-trait TRSW1
-where
-    Self: Iterator<Item: Copy, Item: Send>,
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-    //~| ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-    //~| ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-{
-}
-trait TRSW2
-where
-    Self: Iterator<Item: Copy, Item: Copy>,
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-    //~| ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-    //~| ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-{
-}
-trait TRSW3
-where
-    Self: Iterator<Item: 'static, Item: 'static>,
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-    //~| ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-    //~| ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-{
-}
-trait TRA1 {
-    type A: Iterator<Item: Copy, Item: Send>;
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-    //~| ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-}
-trait TRA2 {
-    type A: Iterator<Item: Copy, Item: Copy>;
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-    //~| ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-}
-trait TRA3 {
-    type A: Iterator<Item: 'static, Item: 'static>;
-    //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-    //~| ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-}
-
-fn main() {}
diff --git a/tests/ui/associated-type-bounds/duplicate.stderr b/tests/ui/associated-type-bounds/duplicate.stderr
deleted file mode 100644
index 68fbb345f6f93..0000000000000
--- a/tests/ui/associated-type-bounds/duplicate.stderr
+++ /dev/null
@@ -1,751 +0,0 @@
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:6:36
-   |
-LL | struct SI1<T: Iterator<Item: Copy, Item: Send>> {
-   |                        ----------  ^^^^^^^^^^ re-bound here
-   |                        |
-   |                        `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:10:36
-   |
-LL | struct SI2<T: Iterator<Item: Copy, Item: Copy>> {
-   |                        ----------  ^^^^^^^^^^ re-bound here
-   |                        |
-   |                        `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:14:39
-   |
-LL | struct SI3<T: Iterator<Item: 'static, Item: 'static>> {
-   |                        -------------  ^^^^^^^^^^^^^ re-bound here
-   |                        |
-   |                        `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:20:29
-   |
-LL |     T: Iterator<Item: Copy, Item: Send>,
-   |                 ----------  ^^^^^^^^^^ re-bound here
-   |                 |
-   |                 `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:27:29
-   |
-LL |     T: Iterator<Item: Copy, Item: Copy>,
-   |                 ----------  ^^^^^^^^^^ re-bound here
-   |                 |
-   |                 `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:34:32
-   |
-LL |     T: Iterator<Item: 'static, Item: 'static>,
-   |                 -------------  ^^^^^^^^^^^^^ re-bound here
-   |                 |
-   |                 `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:40:34
-   |
-LL | enum EI1<T: Iterator<Item: Copy, Item: Send>> {
-   |                      ----------  ^^^^^^^^^^ re-bound here
-   |                      |
-   |                      `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:44:34
-   |
-LL | enum EI2<T: Iterator<Item: Copy, Item: Copy>> {
-   |                      ----------  ^^^^^^^^^^ re-bound here
-   |                      |
-   |                      `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:48:37
-   |
-LL | enum EI3<T: Iterator<Item: 'static, Item: 'static>> {
-   |                      -------------  ^^^^^^^^^^^^^ re-bound here
-   |                      |
-   |                      `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:54:29
-   |
-LL |     T: Iterator<Item: Copy, Item: Send>,
-   |                 ----------  ^^^^^^^^^^ re-bound here
-   |                 |
-   |                 `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:61:29
-   |
-LL |     T: Iterator<Item: Copy, Item: Copy>,
-   |                 ----------  ^^^^^^^^^^ re-bound here
-   |                 |
-   |                 `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:68:32
-   |
-LL |     T: Iterator<Item: 'static, Item: 'static>,
-   |                 -------------  ^^^^^^^^^^^^^ re-bound here
-   |                 |
-   |                 `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:74:35
-   |
-LL | union UI1<T: Iterator<Item: Copy, Item: Send>> {
-   |                       ----------  ^^^^^^^^^^ re-bound here
-   |                       |
-   |                       `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:78:35
-   |
-LL | union UI2<T: Iterator<Item: Copy, Item: Copy>> {
-   |                       ----------  ^^^^^^^^^^ re-bound here
-   |                       |
-   |                       `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:82:38
-   |
-LL | union UI3<T: Iterator<Item: 'static, Item: 'static>> {
-   |                       -------------  ^^^^^^^^^^^^^ re-bound here
-   |                       |
-   |                       `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:88:29
-   |
-LL |     T: Iterator<Item: Copy, Item: Send>,
-   |                 ----------  ^^^^^^^^^^ re-bound here
-   |                 |
-   |                 `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:95:29
-   |
-LL |     T: Iterator<Item: Copy, Item: Copy>,
-   |                 ----------  ^^^^^^^^^^ re-bound here
-   |                 |
-   |                 `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:102:32
-   |
-LL |     T: Iterator<Item: 'static, Item: 'static>,
-   |                 -------------  ^^^^^^^^^^^^^ re-bound here
-   |                 |
-   |                 `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:108:32
-   |
-LL | fn FI1<T: Iterator<Item: Copy, Item: Send>>() {}
-   |                    ----------  ^^^^^^^^^^ re-bound here
-   |                    |
-   |                    `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:110:32
-   |
-LL | fn FI2<T: Iterator<Item: Copy, Item: Copy>>() {}
-   |                    ----------  ^^^^^^^^^^ re-bound here
-   |                    |
-   |                    `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:112:35
-   |
-LL | fn FI3<T: Iterator<Item: 'static, Item: 'static>>() {}
-   |                    -------------  ^^^^^^^^^^^^^ re-bound here
-   |                    |
-   |                    `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:116:29
-   |
-LL |     T: Iterator<Item: Copy, Item: Send>,
-   |                 ----------  ^^^^^^^^^^ re-bound here
-   |                 |
-   |                 `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:122:29
-   |
-LL |     T: Iterator<Item: Copy, Item: Copy>,
-   |                 ----------  ^^^^^^^^^^ re-bound here
-   |                 |
-   |                 `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:128:32
-   |
-LL |     T: Iterator<Item: 'static, Item: 'static>,
-   |                 -------------  ^^^^^^^^^^^^^ re-bound here
-   |                 |
-   |                 `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:133:42
-   |
-LL | fn FRPIT1() -> impl Iterator<Item: Copy, Item: Send> {
-   |                              ----------  ^^^^^^^^^^ re-bound here
-   |                              |
-   |                              `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:139:42
-   |
-LL | fn FRPIT2() -> impl Iterator<Item: Copy, Item: Copy> {
-   |                              ----------  ^^^^^^^^^^ re-bound here
-   |                              |
-   |                              `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:145:45
-   |
-LL | fn FRPIT3() -> impl Iterator<Item: 'static, Item: 'static> {
-   |                              -------------  ^^^^^^^^^^^^^ re-bound here
-   |                              |
-   |                              `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:151:40
-   |
-LL | fn FAPIT1(_: impl Iterator<Item: Copy, Item: Send>) {}
-   |                            ----------  ^^^^^^^^^^ re-bound here
-   |                            |
-   |                            `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:153:40
-   |
-LL | fn FAPIT2(_: impl Iterator<Item: Copy, Item: Copy>) {}
-   |                            ----------  ^^^^^^^^^^ re-bound here
-   |                            |
-   |                            `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:155:43
-   |
-LL | fn FAPIT3(_: impl Iterator<Item: 'static, Item: 'static>) {}
-   |                            -------------  ^^^^^^^^^^^^^ re-bound here
-   |                            |
-   |                            `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:158:35
-   |
-LL | type TAI1<T: Iterator<Item: Copy, Item: Send>> = T;
-   |                       ----------  ^^^^^^^^^^ re-bound here
-   |                       |
-   |                       `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:160:35
-   |
-LL | type TAI2<T: Iterator<Item: Copy, Item: Copy>> = T;
-   |                       ----------  ^^^^^^^^^^ re-bound here
-   |                       |
-   |                       `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:162:38
-   |
-LL | type TAI3<T: Iterator<Item: 'static, Item: 'static>> = T;
-   |                       -------------  ^^^^^^^^^^^^^ re-bound here
-   |                       |
-   |                       `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:166:29
-   |
-LL |     T: Iterator<Item: Copy, Item: Send>,
-   |                 ----------  ^^^^^^^^^^ re-bound here
-   |                 |
-   |                 `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:171:29
-   |
-LL |     T: Iterator<Item: Copy, Item: Copy>,
-   |                 ----------  ^^^^^^^^^^ re-bound here
-   |                 |
-   |                 `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:176:32
-   |
-LL |     T: Iterator<Item: 'static, Item: 'static>,
-   |                 -------------  ^^^^^^^^^^^^^ re-bound here
-   |                 |
-   |                 `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:180:36
-   |
-LL | type ETAI1<T: Iterator<Item: Copy, Item: Send>> = impl Copy;
-   |                        ----------  ^^^^^^^^^^ re-bound here
-   |                        |
-   |                        `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:183:36
-   |
-LL | type ETAI2<T: Iterator<Item: Copy, Item: Copy>> = impl Copy;
-   |                        ----------  ^^^^^^^^^^ re-bound here
-   |                        |
-   |                        `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:186:39
-   |
-LL | type ETAI3<T: Iterator<Item: 'static, Item: 'static>> = impl Copy;
-   |                        -------------  ^^^^^^^^^^^^^ re-bound here
-   |                        |
-   |                        `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:202:36
-   |
-LL | trait TRI1<T: Iterator<Item: Copy, Item: Send>> {}
-   |                        ----------  ^^^^^^^^^^ re-bound here
-   |                        |
-   |                        `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:204:36
-   |
-LL | trait TRI2<T: Iterator<Item: Copy, Item: Copy>> {}
-   |                        ----------  ^^^^^^^^^^ re-bound here
-   |                        |
-   |                        `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:206:39
-   |
-LL | trait TRI3<T: Iterator<Item: 'static, Item: 'static>> {}
-   |                        -------------  ^^^^^^^^^^^^^ re-bound here
-   |                        |
-   |                        `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:208:34
-   |
-LL | trait TRS1: Iterator<Item: Copy, Item: Send> {}
-   |                      ----------  ^^^^^^^^^^ re-bound here
-   |                      |
-   |                      `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:208:34
-   |
-LL | trait TRS1: Iterator<Item: Copy, Item: Send> {}
-   |                      ----------  ^^^^^^^^^^ re-bound here
-   |                      |
-   |                      `Item` bound here first
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:208:34
-   |
-LL | trait TRS1: Iterator<Item: Copy, Item: Send> {}
-   |                      ----------  ^^^^^^^^^^ re-bound here
-   |                      |
-   |                      `Item` bound here first
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:212:34
-   |
-LL | trait TRS2: Iterator<Item: Copy, Item: Copy> {}
-   |                      ----------  ^^^^^^^^^^ re-bound here
-   |                      |
-   |                      `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:212:34
-   |
-LL | trait TRS2: Iterator<Item: Copy, Item: Copy> {}
-   |                      ----------  ^^^^^^^^^^ re-bound here
-   |                      |
-   |                      `Item` bound here first
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:212:34
-   |
-LL | trait TRS2: Iterator<Item: Copy, Item: Copy> {}
-   |                      ----------  ^^^^^^^^^^ re-bound here
-   |                      |
-   |                      `Item` bound here first
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:216:37
-   |
-LL | trait TRS3: Iterator<Item: 'static, Item: 'static> {}
-   |                      -------------  ^^^^^^^^^^^^^ re-bound here
-   |                      |
-   |                      `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:216:37
-   |
-LL | trait TRS3: Iterator<Item: 'static, Item: 'static> {}
-   |                      -------------  ^^^^^^^^^^^^^ re-bound here
-   |                      |
-   |                      `Item` bound here first
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:216:37
-   |
-LL | trait TRS3: Iterator<Item: 'static, Item: 'static> {}
-   |                      -------------  ^^^^^^^^^^^^^ re-bound here
-   |                      |
-   |                      `Item` bound here first
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:222:29
-   |
-LL |     T: Iterator<Item: Copy, Item: Send>,
-   |                 ----------  ^^^^^^^^^^ re-bound here
-   |                 |
-   |                 `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:228:29
-   |
-LL |     T: Iterator<Item: Copy, Item: Copy>,
-   |                 ----------  ^^^^^^^^^^ re-bound here
-   |                 |
-   |                 `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:234:32
-   |
-LL |     T: Iterator<Item: 'static, Item: 'static>,
-   |                 -------------  ^^^^^^^^^^^^^ re-bound here
-   |                 |
-   |                 `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:240:32
-   |
-LL |     Self: Iterator<Item: Copy, Item: Send>,
-   |                    ----------  ^^^^^^^^^^ re-bound here
-   |                    |
-   |                    `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:240:32
-   |
-LL |     Self: Iterator<Item: Copy, Item: Send>,
-   |                    ----------  ^^^^^^^^^^ re-bound here
-   |                    |
-   |                    `Item` bound here first
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:240:32
-   |
-LL |     Self: Iterator<Item: Copy, Item: Send>,
-   |                    ----------  ^^^^^^^^^^ re-bound here
-   |                    |
-   |                    `Item` bound here first
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:248:32
-   |
-LL |     Self: Iterator<Item: Copy, Item: Copy>,
-   |                    ----------  ^^^^^^^^^^ re-bound here
-   |                    |
-   |                    `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:248:32
-   |
-LL |     Self: Iterator<Item: Copy, Item: Copy>,
-   |                    ----------  ^^^^^^^^^^ re-bound here
-   |                    |
-   |                    `Item` bound here first
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:248:32
-   |
-LL |     Self: Iterator<Item: Copy, Item: Copy>,
-   |                    ----------  ^^^^^^^^^^ re-bound here
-   |                    |
-   |                    `Item` bound here first
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:256:35
-   |
-LL |     Self: Iterator<Item: 'static, Item: 'static>,
-   |                    -------------  ^^^^^^^^^^^^^ re-bound here
-   |                    |
-   |                    `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:256:35
-   |
-LL |     Self: Iterator<Item: 'static, Item: 'static>,
-   |                    -------------  ^^^^^^^^^^^^^ re-bound here
-   |                    |
-   |                    `Item` bound here first
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:256:35
-   |
-LL |     Self: Iterator<Item: 'static, Item: 'static>,
-   |                    -------------  ^^^^^^^^^^^^^ re-bound here
-   |                    |
-   |                    `Item` bound here first
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:263:34
-   |
-LL |     type A: Iterator<Item: Copy, Item: Send>;
-   |                      ----------  ^^^^^^^^^^ re-bound here
-   |                      |
-   |                      `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:263:34
-   |
-LL |     type A: Iterator<Item: Copy, Item: Send>;
-   |                      ----------  ^^^^^^^^^^ re-bound here
-   |                      |
-   |                      `Item` bound here first
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:268:34
-   |
-LL |     type A: Iterator<Item: Copy, Item: Copy>;
-   |                      ----------  ^^^^^^^^^^ re-bound here
-   |                      |
-   |                      `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:268:34
-   |
-LL |     type A: Iterator<Item: Copy, Item: Copy>;
-   |                      ----------  ^^^^^^^^^^ re-bound here
-   |                      |
-   |                      `Item` bound here first
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:273:37
-   |
-LL |     type A: Iterator<Item: 'static, Item: 'static>;
-   |                      -------------  ^^^^^^^^^^^^^ re-bound here
-   |                      |
-   |                      `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:273:37
-   |
-LL |     type A: Iterator<Item: 'static, Item: 'static>;
-   |                      -------------  ^^^^^^^^^^^^^ re-bound here
-   |                      |
-   |                      `Item` bound here first
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:133:42
-   |
-LL | fn FRPIT1() -> impl Iterator<Item: Copy, Item: Send> {
-   |                              ----------  ^^^^^^^^^^ re-bound here
-   |                              |
-   |                              `Item` bound here first
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0282]: type annotations needed
-  --> $DIR/duplicate.rs:136:5
-   |
-LL |     iter::empty()
-   |     ^^^^^^^^^^^ cannot infer type of the type parameter `T` declared on the function `empty`
-   |
-help: consider specifying the generic argument
-   |
-LL |     iter::empty::<T>()
-   |                +++++
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:139:42
-   |
-LL | fn FRPIT2() -> impl Iterator<Item: Copy, Item: Copy> {
-   |                              ----------  ^^^^^^^^^^ re-bound here
-   |                              |
-   |                              `Item` bound here first
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0282]: type annotations needed
-  --> $DIR/duplicate.rs:142:5
-   |
-LL |     iter::empty()
-   |     ^^^^^^^^^^^ cannot infer type of the type parameter `T` declared on the function `empty`
-   |
-help: consider specifying the generic argument
-   |
-LL |     iter::empty::<T>()
-   |                +++++
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:145:45
-   |
-LL | fn FRPIT3() -> impl Iterator<Item: 'static, Item: 'static> {
-   |                              -------------  ^^^^^^^^^^^^^ re-bound here
-   |                              |
-   |                              `Item` bound here first
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0282]: type annotations needed
-  --> $DIR/duplicate.rs:148:5
-   |
-LL |     iter::empty()
-   |     ^^^^^^^^^^^ cannot infer type of the type parameter `T` declared on the function `empty`
-   |
-help: consider specifying the generic argument
-   |
-LL |     iter::empty::<T>()
-   |                +++++
-
-error: unconstrained opaque type
-  --> $DIR/duplicate.rs:180:51
-   |
-LL | type ETAI1<T: Iterator<Item: Copy, Item: Send>> = impl Copy;
-   |                                                   ^^^^^^^^^
-   |
-   = note: `ETAI1` must be used in combination with a concrete type within the same crate
-
-error: unconstrained opaque type
-  --> $DIR/duplicate.rs:183:51
-   |
-LL | type ETAI2<T: Iterator<Item: Copy, Item: Copy>> = impl Copy;
-   |                                                   ^^^^^^^^^
-   |
-   = note: `ETAI2` must be used in combination with a concrete type within the same crate
-
-error: unconstrained opaque type
-  --> $DIR/duplicate.rs:186:57
-   |
-LL | type ETAI3<T: Iterator<Item: 'static, Item: 'static>> = impl Copy;
-   |                                                         ^^^^^^^^^
-   |
-   = note: `ETAI3` must be used in combination with a concrete type within the same crate
-
-error: unconstrained opaque type
-  --> $DIR/duplicate.rs:189:14
-   |
-LL | type ETAI4 = impl Iterator<Item: Copy, Item: Send>;
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `ETAI4` must be used in combination with a concrete type within the same crate
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:189:40
-   |
-LL | type ETAI4 = impl Iterator<Item: Copy, Item: Send>;
-   |                            ----------  ^^^^^^^^^^ re-bound here
-   |                            |
-   |                            `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:189:40
-   |
-LL | type ETAI4 = impl Iterator<Item: Copy, Item: Send>;
-   |                            ----------  ^^^^^^^^^^ re-bound here
-   |                            |
-   |                            `Item` bound here first
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: unconstrained opaque type
-  --> $DIR/duplicate.rs:193:14
-   |
-LL | type ETAI5 = impl Iterator<Item: Copy, Item: Copy>;
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `ETAI5` must be used in combination with a concrete type within the same crate
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:193:40
-   |
-LL | type ETAI5 = impl Iterator<Item: Copy, Item: Copy>;
-   |                            ----------  ^^^^^^^^^^ re-bound here
-   |                            |
-   |                            `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:193:40
-   |
-LL | type ETAI5 = impl Iterator<Item: Copy, Item: Copy>;
-   |                            ----------  ^^^^^^^^^^ re-bound here
-   |                            |
-   |                            `Item` bound here first
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: unconstrained opaque type
-  --> $DIR/duplicate.rs:197:14
-   |
-LL | type ETAI6 = impl Iterator<Item: 'static, Item: 'static>;
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `ETAI6` must be used in combination with a concrete type within the same crate
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:197:43
-   |
-LL | type ETAI6 = impl Iterator<Item: 'static, Item: 'static>;
-   |                            -------------  ^^^^^^^^^^^^^ re-bound here
-   |                            |
-   |                            `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:197:43
-   |
-LL | type ETAI6 = impl Iterator<Item: 'static, Item: 'static>;
-   |                            -------------  ^^^^^^^^^^^^^ re-bound here
-   |                            |
-   |                            `Item` bound here first
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: aborting due to 87 previous errors
-
-Some errors have detailed explanations: E0282, E0719.
-For more information about an error, try `rustc --explain E0282`.
diff --git a/tests/ui/associated-types/associated-types-overridden-binding-2.stderr b/tests/ui/associated-types/associated-types-overridden-binding-2.stderr
index 71a4a2610aac4..e96a2446b6ce0 100644
--- a/tests/ui/associated-types/associated-types-overridden-binding-2.stderr
+++ b/tests/ui/associated-types/associated-types-overridden-binding-2.stderr
@@ -1,4 +1,4 @@
-error: conflicting associated type bounds for `Item` when expanding trait alias
+error: conflicting associated type bounds for `Item`
   --> $DIR/associated-types-overridden-binding-2.rs:6:13
    |
 LL | trait I32Iterator = Iterator<Item = i32>;
diff --git a/tests/ui/associated-types/associated-types-overridden-binding.stderr b/tests/ui/associated-types/associated-types-overridden-binding.stderr
index 3b20015dfcab3..08ab9b63ee9fd 100644
--- a/tests/ui/associated-types/associated-types-overridden-binding.stderr
+++ b/tests/ui/associated-types/associated-types-overridden-binding.stderr
@@ -22,7 +22,7 @@ note: required by a bound in `I32Iterator`
 LL | trait I32Iterator = Iterator<Item = i32>;
    |                              ^^^^^^^^^^ required by this bound in `I32Iterator`
 
-error: conflicting associated type bounds for `Item` when expanding trait alias
+error: conflicting associated type bounds for `Item`
   --> $DIR/associated-types-overridden-binding.rs:10:13
    |
 LL | trait I32Iterator = Iterator<Item = i32>;
diff --git a/tests/ui/error-codes/E0719.rs b/tests/ui/error-codes/E0719.rs
index 0ea6d19000bd3..d7b4b876d1b78 100644
--- a/tests/ui/error-codes/E0719.rs
+++ b/tests/ui/error-codes/E0719.rs
@@ -1,8 +1,3 @@
-trait Foo: Iterator<Item = i32, Item = i32> {}
-//~^ ERROR is already specified
-//~| ERROR is already specified
-//~| ERROR is already specified
-
 type Unit = ();
 
 fn test() -> Box<dyn Iterator<Item = (), Item = Unit>> {
diff --git a/tests/ui/error-codes/E0719.stderr b/tests/ui/error-codes/E0719.stderr
index 7e8329db1f48f..f48175689249e 100644
--- a/tests/ui/error-codes/E0719.stderr
+++ b/tests/ui/error-codes/E0719.stderr
@@ -1,33 +1,5 @@
 error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/E0719.rs:1:33
-   |
-LL | trait Foo: Iterator<Item = i32, Item = i32> {}
-   |                     ----------  ^^^^^^^^^^ re-bound here
-   |                     |
-   |                     `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/E0719.rs:1:33
-   |
-LL | trait Foo: Iterator<Item = i32, Item = i32> {}
-   |                     ----------  ^^^^^^^^^^ re-bound here
-   |                     |
-   |                     `Item` bound here first
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/E0719.rs:1:33
-   |
-LL | trait Foo: Iterator<Item = i32, Item = i32> {}
-   |                     ----------  ^^^^^^^^^^ re-bound here
-   |                     |
-   |                     `Item` bound here first
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/E0719.rs:8:42
+  --> $DIR/E0719.rs:3:42
    |
 LL | fn test() -> Box<dyn Iterator<Item = (), Item = Unit>> {
    |                               ---------  ^^^^^^^^^^^ re-bound here
@@ -35,13 +7,13 @@ LL | fn test() -> Box<dyn Iterator<Item = (), Item = Unit>> {
    |                               `Item` bound here first
 
 error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/E0719.rs:14:38
+  --> $DIR/E0719.rs:9:38
    |
 LL |     let _: &dyn Iterator<Item = i32, Item = i32>;
    |                          ----------  ^^^^^^^^^^ re-bound here
    |                          |
    |                          `Item` bound here first
 
-error: aborting due to 5 previous errors
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0719`.

From 495d7ee587dc1b8d99fd9f0bce2f72b0072e3aca Mon Sep 17 00:00:00 2001
From: Mark Rousskov <mark.simulacrum@gmail.com>
Date: Thu, 18 Sep 2025 09:41:23 -0400
Subject: [PATCH 1087/1889] Include patch in release notes

This should fix triagebot publication of the GitHub release on merge.
---
 RELEASES.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/RELEASES.md b/RELEASES.md
index 2b65d070d5fd1..aa5f37fffebff 100644
--- a/RELEASES.md
+++ b/RELEASES.md
@@ -1,5 +1,5 @@
-Version 1.90 (2025-09-18)
-==========================
+Version 1.90.0 (2025-09-18)
+===========================
 
 <a id="1.90-Language"></a>
 

From 7e270ab27e80c06275c80fa1041f5ff9af3ffcd4 Mon Sep 17 00:00:00 2001
From: Shoyu Vanilla <modulo641@gmail.com>
Date: Thu, 18 Sep 2025 22:22:29 +0900
Subject: [PATCH 1088/1889] chore: Update rustc deps

---
 src/tools/rust-analyzer/Cargo.lock            | 44 +++++++++----------
 src/tools/rust-analyzer/Cargo.toml            | 16 +++----
 .../crates/hir-ty/src/next_solver/interner.rs | 14 ++++++
 3 files changed, 44 insertions(+), 30 deletions(-)

diff --git a/src/tools/rust-analyzer/Cargo.lock b/src/tools/rust-analyzer/Cargo.lock
index b70b89ea543d8..9475391acdb7f 100644
--- a/src/tools/rust-analyzer/Cargo.lock
+++ b/src/tools/rust-analyzer/Cargo.lock
@@ -1863,9 +1863,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_abi"
-version = "0.128.0"
+version = "0.129.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8da95e732b424802b1f043ab4007c78a0fc515ab249587abbea4634bf5fdce9a"
+checksum = "aa338fe027a8915009ca4a5a1cb7dde5fb4bc4170a928cb9462fda9d2ec52cec"
 dependencies = [
  "bitflags 2.9.1",
  "ra-ap-rustc_hashes",
@@ -1875,24 +1875,24 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_ast_ir"
-version = "0.128.0"
+version = "0.129.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3838d9d7a3a5cdc511cfb6ad78740ce532f75a2366d3fc3b9853ea1b5c872779"
+checksum = "a8468ef77e5359b3a51e327406f29ca2283a4feef93d3ba04f6740b274636922"
 
 [[package]]
 name = "ra-ap-rustc_hashes"
-version = "0.128.0"
+version = "0.129.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bdc8995d268d3bb4ece910f575ea5a063d6003e193ec155d15703b65882d53fb"
+checksum = "300bc3264ccc1e7a5b3f065023a02e612774206d8ad685b3b05c2e4e317f8daa"
 dependencies = [
  "rustc-stable-hash",
 ]
 
 [[package]]
 name = "ra-ap-rustc_index"
-version = "0.128.0"
+version = "0.129.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed0ccdf6e5627c6c3e54e571e52ce0bc8b94d5f0b94b7460269ca68a4706be69"
+checksum = "5eaa4a3ff61302e45c17ee72e067a39179081c19a12aa03192975a095f5d4e4b"
 dependencies = [
  "ra-ap-rustc_index_macros",
  "smallvec",
@@ -1900,9 +1900,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_index_macros"
-version = "0.128.0"
+version = "0.129.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd28f42362b5c9fb9b8766c3189df02a402b13363600c6885e11027889f03ee6"
+checksum = "0f7af0d51ee6bd5280be8e2eb7e9ac5cd9fc87af7a99f50cdb1316a8779c15ab"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1911,9 +1911,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_lexer"
-version = "0.128.0"
+version = "0.129.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1c31a82f091b910a27ee53a86a9af28a2df10c3484e2f1bbfe70633aa84dee9"
+checksum = "ee4e7df9bf702c855de7bea5e3c14b96f0728d4712edb663b0f4b183622341fc"
 dependencies = [
  "memchr",
  "unicode-properties",
@@ -1922,9 +1922,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_next_trait_solver"
-version = "0.128.0"
+version = "0.129.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8cac6c2b5a8924209d4ca682cbc507252c58a664911e0ef463c112882ba6f72"
+checksum = "15768080a276088a4a6af1e08a4ca622c57d5b4845ce5329dbbd71a2e025eecb"
 dependencies = [
  "derive-where",
  "ra-ap-rustc_index",
@@ -1935,9 +1935,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_parse_format"
-version = "0.128.0"
+version = "0.129.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a085a1cf902dcca8abbc537faaef154bbccbbb51850f779ce5484ae3782b5d8f"
+checksum = "e6f0c54b200c47768eaf142b1c829da9be1a3331a5defa4ac60bad4996f474e9"
 dependencies = [
  "ra-ap-rustc_lexer",
  "rustc-literal-escaper 0.0.5",
@@ -1945,9 +1945,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_pattern_analysis"
-version = "0.128.0"
+version = "0.129.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ba32e3985367bc34856b41c7604133649d4a367eb5d7bdf50623025731459d8"
+checksum = "a078fbbefda17d8d5d2c9d6b5a1f9ee1e23fae5f057e74784f6b95c189b0b048"
 dependencies = [
  "ra-ap-rustc_index",
  "rustc-hash 2.1.1",
@@ -1958,9 +1958,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_type_ir"
-version = "0.128.0"
+version = "0.129.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c9911d72f75d85d21fe88374d7bcec94f2200feffb7234108a24cc3da7c3591"
+checksum = "644e980122cdb7f2d7e175f33224dc6df414e8cf3e5dfbba9047e63336d9737a"
 dependencies = [
  "arrayvec",
  "bitflags 2.9.1",
@@ -1978,9 +1978,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_type_ir_macros"
-version = "0.128.0"
+version = "0.129.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22f539b87991683ce17cc52e62600fdf2b4a8af43952db30387edc1a576d3b43"
+checksum = "827d242d444cea86d9a64b5ce99db1462c9d43c7c6226d44ec2bc621b7c253c0"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/src/tools/rust-analyzer/Cargo.toml b/src/tools/rust-analyzer/Cargo.toml
index c5ffad544a6b3..94ec1a07438f4 100644
--- a/src/tools/rust-analyzer/Cargo.toml
+++ b/src/tools/rust-analyzer/Cargo.toml
@@ -89,14 +89,14 @@ vfs-notify = { path = "./crates/vfs-notify", version = "0.0.0" }
 vfs = { path = "./crates/vfs", version = "0.0.0" }
 edition = { path = "./crates/edition", version = "0.0.0" }
 
-ra-ap-rustc_lexer = { version = "0.128", default-features = false }
-ra-ap-rustc_parse_format = { version = "0.128", default-features = false }
-ra-ap-rustc_index = { version = "0.128", default-features = false }
-ra-ap-rustc_abi = { version = "0.128", default-features = false }
-ra-ap-rustc_pattern_analysis = { version = "0.128", default-features = false }
-ra-ap-rustc_ast_ir = { version = "0.128", default-features = false }
-ra-ap-rustc_type_ir = { version = "0.128", default-features = false }
-ra-ap-rustc_next_trait_solver = { version = "0.128", default-features = false }
+ra-ap-rustc_lexer = { version = "0.129", default-features = false }
+ra-ap-rustc_parse_format = { version = "0.129", default-features = false }
+ra-ap-rustc_index = { version = "0.129", default-features = false }
+ra-ap-rustc_abi = { version = "0.129", default-features = false }
+ra-ap-rustc_pattern_analysis = { version = "0.129", default-features = false }
+ra-ap-rustc_ast_ir = { version = "0.129", default-features = false }
+ra-ap-rustc_type_ir = { version = "0.129", default-features = false }
+ra-ap-rustc_next_trait_solver = { version = "0.129", default-features = false }
 
 # local crates that aren't published to crates.io. These should not have versions.
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
index 062f6aebf160d..9cf56bef9578a 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
@@ -1674,6 +1674,20 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
         }
     }
 
+    fn for_each_blanket_impl(self, trait_def_id: Self::TraitId, mut f: impl FnMut(Self::ImplId)) {
+        let Some(krate) = self.krate else { return };
+
+        for impls in self.db.trait_impls_in_deps(krate).iter() {
+            for impl_id in impls.for_trait(trait_def_id.0) {
+                let impl_data = self.db.impl_signature(impl_id);
+                let self_ty_ref = &impl_data.store[impl_data.self_ty];
+                if matches!(self_ty_ref, hir_def::type_ref::TypeRef::TypeParam(_)) {
+                    f(impl_id.into());
+                }
+            }
+        }
+    }
+
     fn has_item_definition(self, def_id: Self::DefId) -> bool {
         // FIXME(next-solver): should check if the associated item has a value.
         true

From 427774af0719cdf2214825cfa0a634e550839169 Mon Sep 17 00:00:00 2001
From: Kevin Reid <kpreid@switchb.org>
Date: Thu, 18 Sep 2025 07:46:17 -0700
Subject: [PATCH 1089/1889] Changelog: fix heading level in 1.90 section

---
 CHANGELOG.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4a9be02143722..fb7cbbed6542d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -17,7 +17,7 @@ Current stable, released 2025-09-18
 Note: This Clippy release does not introduce many new lints and is focused entirely on bug fixes — see
 [#15086](https://github.com/rust-lang/rust-clippy/issues/15086) for more details.
 
-## New Lints
+### New Lints
 
 * Added [`manual_is_multiple_of`] to `complexity` [#14292](https://github.com/rust-lang/rust-clippy/pull/14292)
 * Added [`doc_broken_link`] to `pedantic` [#13696](https://github.com/rust-lang/rust-clippy/pull/13696)

From 2c7350269c38ae3284702597c9fd016453d445cf Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Thu, 18 Sep 2025 16:59:20 +0200
Subject: [PATCH 1090/1889] Bump nightly version -> 2025-09-18

---
 clippy_utils/README.md | 2 +-
 rust-toolchain.toml    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/clippy_utils/README.md b/clippy_utils/README.md
index e01f563c49e73..2c66fdc73f539 100644
--- a/clippy_utils/README.md
+++ b/clippy_utils/README.md
@@ -8,7 +8,7 @@ This crate is only guaranteed to build with this `nightly` toolchain:
 
 <!-- begin autogenerated nightly -->
 ```
-nightly-2025-09-04
+nightly-2025-09-18
 ```
 <!-- end autogenerated nightly -->
 
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index ec2f24a0a6d84..9c102de448200 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,6 +1,6 @@
 [toolchain]
 # begin autogenerated nightly
-channel = "nightly-2025-09-04"
+channel = "nightly-2025-09-18"
 # end autogenerated nightly
 components = ["cargo", "llvm-tools", "rust-src", "rust-std", "rustc", "rustc-dev", "rustfmt"]
 profile = "minimal"

From 6b14443a028b9338ddf0c57962f2c6cea1170f5c Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Thu, 18 Sep 2025 16:59:44 +0200
Subject: [PATCH 1091/1889] Bump Clippy version -> 0.1.92

---
 Cargo.toml                     | 2 +-
 clippy_config/Cargo.toml       | 2 +-
 clippy_lints/Cargo.toml        | 2 +-
 clippy_utils/Cargo.toml        | 2 +-
 declare_clippy_lint/Cargo.toml | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index b3618932ded7d..e06383499893a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "clippy"
-version = "0.1.91"
+version = "0.1.92"
 description = "A bunch of helpful lints to avoid common pitfalls in Rust"
 repository = "https://github.com/rust-lang/rust-clippy"
 readme = "README.md"
diff --git a/clippy_config/Cargo.toml b/clippy_config/Cargo.toml
index 6ad2cf0d0b104..f8c748290e418 100644
--- a/clippy_config/Cargo.toml
+++ b/clippy_config/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "clippy_config"
-version = "0.1.91"
+version = "0.1.92"
 edition = "2024"
 publish = false
 
diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index 70184ee2ca596..51e59ae205076 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "clippy_lints"
-version = "0.1.91"
+version = "0.1.92"
 description = "A bunch of helpful lints to avoid common pitfalls in Rust"
 repository = "https://github.com/rust-lang/rust-clippy"
 readme = "README.md"
diff --git a/clippy_utils/Cargo.toml b/clippy_utils/Cargo.toml
index bdf7431f29f29..d58b47bf6deb3 100644
--- a/clippy_utils/Cargo.toml
+++ b/clippy_utils/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "clippy_utils"
-version = "0.1.91"
+version = "0.1.92"
 edition = "2024"
 description = "Helpful tools for writing lints, provided as they are used in Clippy"
 repository = "https://github.com/rust-lang/rust-clippy"
diff --git a/declare_clippy_lint/Cargo.toml b/declare_clippy_lint/Cargo.toml
index ec0e59e705495..4de7b5fb5924d 100644
--- a/declare_clippy_lint/Cargo.toml
+++ b/declare_clippy_lint/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "declare_clippy_lint"
-version = "0.1.91"
+version = "0.1.92"
 edition = "2024"
 repository = "https://github.com/rust-lang/rust-clippy"
 license = "MIT OR Apache-2.0"

From 47bcee4ee26cc03aa19df2331559686d6a719bd1 Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Thu, 18 Sep 2025 17:21:44 +0200
Subject: [PATCH 1092/1889] Merge commit
 '20ce69b9a63bcd2756cd906fe0964d1e901e042a' into clippy-subtree-update

---
 .github/ISSUE_TEMPLATE/new_lint.yml           |   4 +-
 .github/PULL_REQUEST_TEMPLATE.md              |   4 -
 .github/workflows/feature_freeze.yml          |  45 --
 .gitignore                                    |   3 +
 CHANGELOG.md                                  | 148 ++++-
 Cargo.toml                                    |   2 +-
 book/src/README.md                            |   4 -
 book/src/SUMMARY.md                           |   1 -
 book/src/development/adding_lints.md          |   3 -
 book/src/development/feature_freeze.md        |  55 --
 clippy_config/Cargo.toml                      |   2 +-
 clippy_lints/Cargo.toml                       |   2 +-
 clippy_lints/src/attrs/useless_attribute.rs   |   1 +
 clippy_lints/src/casts/as_underscore.rs       |   8 +-
 clippy_lints/src/casts/cast_possible_wrap.rs  |  30 +-
 clippy_lints/src/casts/cast_sign_loss.rs      |  29 +-
 clippy_lints/src/casts/mod.rs                 |   4 +-
 clippy_lints/src/casts/utils.rs               |  15 +
 clippy_lints/src/declared_lints.rs            |   5 +-
 clippy_lints/src/dereference.rs               |   7 +-
 clippy_lints/src/derive.rs                    | 527 ------------------
 .../src/derive/derive_ord_xor_partial_ord.rs  |  50 ++
 .../derive/derive_partial_eq_without_eq.rs    |  87 +++
 .../src/derive/derived_hash_with_manual_eq.rs |  49 ++
 .../src/derive/expl_impl_clone_on_copy.rs     |  65 +++
 clippy_lints/src/derive/mod.rs                | 215 +++++++
 .../src/derive/unsafe_derive_deserialize.rs   |  93 ++++
 clippy_lints/src/disallowed_macros.rs         |   4 +-
 clippy_lints/src/eta_reduction.rs             |  27 +-
 .../src/functions/not_unsafe_ptr_arg_deref.rs |   4 +-
 clippy_lints/src/functions/ref_option.rs      |  48 +-
 clippy_lints/src/future_not_send.rs           | 109 ++--
 .../src/invalid_upcast_comparisons.rs         |  13 +-
 clippy_lints/src/len_zero.rs                  |   6 +-
 clippy_lints/src/let_with_type_underscore.rs  |  16 +-
 clippy_lints/src/lib.rs                       |   6 +-
 clippy_lints/src/lifetimes.rs                 | 109 +++-
 clippy_lints/src/loops/explicit_iter_loop.rs  |   6 +-
 clippy_lints/src/loops/never_loop.rs          |  59 +-
 clippy_lints/src/manual_abs_diff.rs           |   6 +-
 clippy_lints/src/manual_option_as_slice.rs    |   6 +-
 .../src/manual_slice_size_calculation.rs      |   3 +-
 clippy_lints/src/matches/manual_ok_err.rs     |  16 +-
 clippy_lints/src/matches/manual_utils.rs      |   9 +-
 clippy_lints/src/matches/needless_match.rs    |   6 +-
 .../matches/rest_pat_in_fully_bound_struct.rs |  10 +-
 clippy_lints/src/matches/single_match.rs      |   8 +-
 clippy_lints/src/methods/implicit_clone.rs    |   6 +-
 .../src/methods/inefficient_to_string.rs      |   4 +-
 .../src/methods/iter_overeager_cloned.rs      |   5 +-
 clippy_lints/src/methods/mod.rs               |  75 ++-
 clippy_lints/src/methods/mut_mutex_lock.rs    |   5 +-
 clippy_lints/src/methods/or_fun_call.rs       |   7 +
 .../src/methods/ptr_offset_with_cast.rs       |  82 +++
 .../src/methods/unnecessary_to_owned.rs       |  13 +-
 clippy_lints/src/methods/useless_asref.rs     |   6 +-
 clippy_lints/src/min_ident_chars.rs           |   6 +-
 clippy_lints/src/misc.rs                      | 118 +---
 clippy_lints/src/missing_doc.rs               |   2 +-
 .../src/multiple_unsafe_ops_per_block.rs      |   8 +
 clippy_lints/src/only_used_in_recursion.rs    |   4 +-
 clippy_lints/src/operators/erasing_op.rs      |   4 +-
 clippy_lints/src/ptr_offset_with_cast.rs      | 151 -----
 clippy_lints/src/question_mark.rs             |  21 +-
 clippy_lints/src/read_zero_byte_vec.rs        |  27 +-
 clippy_lints/src/redundant_clone.rs           |   4 +-
 clippy_lints/src/redundant_slicing.rs         |   8 +-
 clippy_lints/src/returns.rs                   | 513 -----------------
 clippy_lints/src/returns/let_and_return.rs    |  86 +++
 clippy_lints/src/returns/mod.rs               | 140 +++++
 clippy_lints/src/returns/needless_return.rs   | 269 +++++++++
 .../needless_return_with_question_mark.rs     |  60 ++
 clippy_lints/src/semicolon_block.rs           |  14 +
 clippy_lints/src/size_of_ref.rs               |   5 +-
 clippy_lints/src/toplevel_ref_arg.rs          | 119 ++++
 .../src/transmute/transmute_ptr_to_ref.rs     |  44 +-
 .../src/transmute/transmute_ref_to_ref.rs     |   4 +-
 clippy_lints/src/uninit_vec.rs                |  11 +-
 clippy_lints/src/unused_peekable.rs           |   6 +-
 clippy_lints/src/unwrap.rs                    |   1 +
 clippy_lints/src/use_self.rs                  |  81 +--
 clippy_lints/src/useless_conversion.rs        |  14 +-
 clippy_utils/Cargo.toml                       |   2 +-
 clippy_utils/README.md                        |   2 +-
 clippy_utils/src/check_proc_macro.rs          | 146 ++++-
 clippy_utils/src/lib.rs                       |  29 +-
 clippy_utils/src/msrvs.rs                     |   4 +-
 clippy_utils/src/source.rs                    |   5 +
 clippy_utils/src/sym.rs                       |   1 +
 clippy_utils/src/ty/mod.rs                    |  88 ++-
 declare_clippy_lint/Cargo.toml                |   2 +-
 rust-toolchain.toml                           |   2 +-
 tests/no-profile-in-cargo-toml.rs             |   3 +
 .../ref_option/all/clippy.toml                |   0
 .../ref_option/private/clippy.toml            |   0
 tests/ui-toml/ref_option/ref_option.all.fixed | 114 ++++
 .../ref_option/ref_option.all.stderr          |  68 +--
 .../ref_option/ref_option.private.fixed       | 114 ++++
 .../ref_option/ref_option.private.stderr      |  44 +-
 tests/ui-toml/ref_option/ref_option.rs        | 114 ++++
 .../ref_option/ref_option_traits.all.stderr   |   8 +-
 .../ref_option_traits.private.stderr          |   4 +-
 tests/ui-toml/ref_option/ref_option_traits.rs |  71 +++
 tests/ui/as_underscore_unfixable.rs           |  14 +
 tests/ui/as_underscore_unfixable.stderr       |  20 +
 tests/ui/cast.rs                              |  13 +
 tests/ui/cast.stderr                          |  96 ++--
 .../ui/checked_unwrap/simple_conditionals.rs  |  22 +
 .../checked_unwrap/simple_conditionals.stderr |  36 +-
 tests/ui/crashes/ice-15657.rs                 |  11 +
 tests/ui/crashes/ice-15666.fixed              |   6 +
 tests/ui/crashes/ice-15666.rs                 |   6 +
 tests/ui/crashes/ice-15666.stderr             |  16 +
 tests/ui/elidable_lifetime_names.fixed        |  82 +++
 tests/ui/elidable_lifetime_names.rs           |  82 +++
 tests/ui/elidable_lifetime_names.stderr       | 146 ++++-
 tests/ui/eta.fixed                            |   8 +
 tests/ui/eta.rs                               |   8 +
 tests/ui/invalid_upcast_comparisons.rs        |  12 +
 tests/ui/invalid_upcast_comparisons.stderr    |   8 +-
 tests/ui/iter_overeager_cloned.fixed          |  12 +-
 tests/ui/iter_overeager_cloned.rs             |  12 +-
 tests/ui/iter_overeager_cloned.stderr         |   4 +-
 tests/ui/match_as_ref.fixed                   |  30 +
 tests/ui/match_as_ref.rs                      |  30 +
 tests/ui/multiple_unsafe_ops_per_block.rs     | 119 ++--
 tests/ui/multiple_unsafe_ops_per_block.stderr | 143 +++--
 tests/ui/needless_return.fixed                |   7 +
 tests/ui/needless_return.rs                   |   7 +
 tests/ui/never_loop.rs                        |  24 +
 tests/ui/never_loop.stderr                    |  97 +++-
 tests/ui/option_if_let_else.fixed             |  10 +
 tests/ui/option_if_let_else.rs                |  16 +
 tests/ui/option_if_let_else.stderr            |  50 +-
 tests/ui/or_fun_call.fixed                    |  16 +
 tests/ui/or_fun_call.rs                       |  22 +-
 tests/ui/or_fun_call.stderr                   |  88 +--
 tests/ui/ptr_offset_with_cast.fixed           |  22 +-
 tests/ui/ptr_offset_with_cast.rs              |  22 +-
 tests/ui/ptr_offset_with_cast.stderr          |  41 +-
 tests/ui/question_mark.fixed                  |  14 +-
 tests/ui/question_mark.rs                     |  26 +-
 tests/ui/question_mark.stderr                 |  92 +--
 tests/ui/read_zero_byte_vec.rs                |  27 +
 tests/ui/read_zero_byte_vec.stderr            |  65 ++-
 tests/ui/ref_option/ref_option.all.fixed      |  79 ---
 tests/ui/ref_option/ref_option.private.fixed  |  79 ---
 tests/ui/ref_option/ref_option.rs             |  79 ---
 tests/ui/ref_option/ref_option_traits.rs      |  40 --
 .../ui/rest_pat_in_fully_bound_structs.fixed  |  61 ++
 .../ui/rest_pat_in_fully_bound_structs.stderr |  18 +-
 tests/ui/semicolon_inside_block.fixed         |  17 +-
 tests/ui/semicolon_inside_block.rs            |  17 +-
 tests/ui/semicolon_inside_block.stderr        |   8 +-
 tests/ui/track-diagnostics-clippy.stderr      |   2 +-
 tests/ui/transmute_ptr_to_ref.fixed           |  39 +-
 tests/ui/transmute_ptr_to_ref.rs              |  39 +-
 tests/ui/transmute_ptr_to_ref.stderr          |  54 +-
 tests/ui/use_self.fixed                       |  18 +-
 tests/ui/use_self.rs                          |  16 +-
 tests/ui/use_self.stderr                      |   8 +-
 tests/ui/useless_attribute.fixed              |  10 +
 tests/ui/useless_attribute.rs                 |  10 +
 163 files changed, 4375 insertions(+), 2474 deletions(-)
 delete mode 100644 .github/workflows/feature_freeze.yml
 delete mode 100644 book/src/development/feature_freeze.md
 delete mode 100644 clippy_lints/src/derive.rs
 create mode 100644 clippy_lints/src/derive/derive_ord_xor_partial_ord.rs
 create mode 100644 clippy_lints/src/derive/derive_partial_eq_without_eq.rs
 create mode 100644 clippy_lints/src/derive/derived_hash_with_manual_eq.rs
 create mode 100644 clippy_lints/src/derive/expl_impl_clone_on_copy.rs
 create mode 100644 clippy_lints/src/derive/mod.rs
 create mode 100644 clippy_lints/src/derive/unsafe_derive_deserialize.rs
 create mode 100644 clippy_lints/src/methods/ptr_offset_with_cast.rs
 delete mode 100644 clippy_lints/src/ptr_offset_with_cast.rs
 delete mode 100644 clippy_lints/src/returns.rs
 create mode 100644 clippy_lints/src/returns/let_and_return.rs
 create mode 100644 clippy_lints/src/returns/mod.rs
 create mode 100644 clippy_lints/src/returns/needless_return.rs
 create mode 100644 clippy_lints/src/returns/needless_return_with_question_mark.rs
 create mode 100644 clippy_lints/src/toplevel_ref_arg.rs
 rename tests/{ui => ui-toml}/ref_option/all/clippy.toml (100%)
 rename tests/{ui => ui-toml}/ref_option/private/clippy.toml (100%)
 create mode 100644 tests/ui-toml/ref_option/ref_option.all.fixed
 rename tests/{ui => ui-toml}/ref_option/ref_option.all.stderr (62%)
 create mode 100644 tests/ui-toml/ref_option/ref_option.private.fixed
 rename tests/{ui => ui-toml}/ref_option/ref_option.private.stderr (63%)
 create mode 100644 tests/ui-toml/ref_option/ref_option.rs
 rename tests/{ui => ui-toml}/ref_option/ref_option_traits.all.stderr (85%)
 rename tests/{ui => ui-toml}/ref_option/ref_option_traits.private.stderr (86%)
 create mode 100644 tests/ui-toml/ref_option/ref_option_traits.rs
 create mode 100644 tests/ui/as_underscore_unfixable.rs
 create mode 100644 tests/ui/as_underscore_unfixable.stderr
 create mode 100644 tests/ui/crashes/ice-15657.rs
 create mode 100644 tests/ui/crashes/ice-15666.fixed
 create mode 100644 tests/ui/crashes/ice-15666.rs
 create mode 100644 tests/ui/crashes/ice-15666.stderr
 delete mode 100644 tests/ui/ref_option/ref_option.all.fixed
 delete mode 100644 tests/ui/ref_option/ref_option.private.fixed
 delete mode 100644 tests/ui/ref_option/ref_option.rs
 delete mode 100644 tests/ui/ref_option/ref_option_traits.rs
 create mode 100644 tests/ui/rest_pat_in_fully_bound_structs.fixed

diff --git a/.github/ISSUE_TEMPLATE/new_lint.yml b/.github/ISSUE_TEMPLATE/new_lint.yml
index a8202f6378fd3..6ad16aead601d 100644
--- a/.github/ISSUE_TEMPLATE/new_lint.yml
+++ b/.github/ISSUE_TEMPLATE/new_lint.yml
@@ -1,7 +1,5 @@
 name: New lint suggestion
-description: |
-  Suggest a new Clippy lint (currently not accepting new lints)
-  Check out the Clippy book for more information about the feature freeze.
+description: Suggest a new Clippy lint.
 labels: ["A-lint"]
 body:
   - type: markdown
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
index 83bfd8e9c6865..9e49f60892d26 100644
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -32,10 +32,6 @@ order to get feedback.
 
 Delete this line and everything above before opening your PR.
 
-Note that we are currently not taking in new PRs that add new lints. We are in a
-feature freeze. Check out the book for more information. If you open a
-feature-adding pull request, its review will be delayed.
-
 ---
 
 *Please write a short comment explaining your change (or "none" for internal only changes)*
diff --git a/.github/workflows/feature_freeze.yml b/.github/workflows/feature_freeze.yml
deleted file mode 100644
index 5b139e767007b..0000000000000
--- a/.github/workflows/feature_freeze.yml
+++ /dev/null
@@ -1,45 +0,0 @@
-name: Feature freeze check
-
-on:
-  pull_request_target:
-    types:
-      - opened
-    branches:
-      - master
-    paths:
-      - 'clippy_lints/src/declared_lints.rs'
-
-jobs:
-  auto-comment:
-    runs-on: ubuntu-latest
-
-    permissions:
-      pull-requests: write
-
-    # Do not in any case add code that runs anything coming from the content
-    # of the pull request, as malicious code would be able to access the private
-    # GitHub token.
-    steps:
-      - name: Add freeze warning comment
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          GITHUB_REPOSITORY: ${{ github.repository }}
-          PR_NUMBER: ${{ github.event.pull_request.number }}
-        run: |
-          COMMENT=$(echo "**Seems that you are trying to add a new lint!**\n\
-          \n\
-          We are currently in a [feature freeze](https://doc.rust-lang.org/nightly/clippy/development/feature_freeze.html), so we are delaying all lint-adding PRs to September 18 and [focusing on bugfixes](https://github.com/rust-lang/rust-clippy/issues/15086).\n\
-          \n\
-          Thanks a lot for your contribution, and sorry for the inconvenience.\n\
-          \n\
-          With ❤ from the Clippy team.\n\
-          \n\
-          @rustbot note Feature-freeze\n\
-          @rustbot blocked\n\
-          @rustbot label +A-lint"
-          )
-          curl -s -H "Authorization: Bearer $GITHUB_TOKEN" \
-             -H "Content-Type: application/vnd.github.raw+json" \
-             -X POST \
-             --data "{\"body\":\"${COMMENT}\"}" \
-             "https://api.github.com/repos/${GITHUB_REPOSITORY}/issues/${PR_NUMBER}/comments"
diff --git a/.gitignore b/.gitignore
index 36a4cdc1c3528..666c4ceac4dbb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -48,3 +48,6 @@ helper.txt
 
 # mdbook generated output
 /book/book
+
+# Remove jujutsu directory from search tools
+.jj
diff --git a/CHANGELOG.md b/CHANGELOG.md
index eb2a76a818369..3f26b9470e826 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,7 +6,152 @@ document.
 
 ## Unreleased / Beta / In Rust Nightly
 
-[4ef75291...master](https://github.com/rust-lang/rust-clippy/compare/4ef75291...master)
+[e9b7045...master](https://github.com/rust-lang/rust-clippy/compare/e9b7045...master)
+
+## Rust 1.90
+
+Current stable, released 2025-09-18
+
+[View all 118 merged pull requests](https://github.com/rust-lang/rust-clippy/pulls?q=merged%3A2025-06-13T15%3A55%3A04Z..2025-07-25T13%3A24%3A00Z+base%3Amaster)
+
+Note: This Clippy release does not introduce many new lints and is focused entirely on bug fixes — see
+[#15086](https://github.com/rust-lang/rust-clippy/issues/15086) for more details.
+
+## New Lints
+
+* Added [`manual_is_multiple_of`] to `complexity` [#14292](https://github.com/rust-lang/rust-clippy/pull/14292)
+* Added [`doc_broken_link`] to `pedantic` [#13696](https://github.com/rust-lang/rust-clippy/pull/13696)
+
+### Moves and Deprecations
+
+* Move [`uninlined_format_args`] to `pedantic` (from `style`, now allow-by-default) [#15287](https://github.com/rust-lang/rust-clippy/pull/15287)
+
+### Enhancements
+
+* [`or_fun_call`] now lints `Option::get_or_insert`, `Result::map_or`, `Option/Result::and` methods 
+  [#15071](https://github.com/rust-lang/rust-clippy/pull/15071) 
+  [#15073](https://github.com/rust-lang/rust-clippy/pull/15073) 
+  [#15074](https://github.com/rust-lang/rust-clippy/pull/15074)
+* [`incompatible_msrv`] now recognizes types exceeding MSRV 
+  [#15296](https://github.com/rust-lang/rust-clippy/pull/15296)
+* [`incompatible_msrv`] now checks the right MSRV when in a `const` context 
+  [#15297](https://github.com/rust-lang/rust-clippy/pull/15297)
+* [`zero_ptr`] now lints in `const` context as well 
+  [#15152](https://github.com/rust-lang/rust-clippy/pull/15152)
+* [`map_identity`],[`flat_map_identity`] now recognizes `|[x, y]| [x, y]` as an identity function
+  [#15229](https://github.com/rust-lang/rust-clippy/pull/15229)
+* [`exit`] no longer fails on the main function when using `--test` or `--all-targets` flag 
+  [#15222](https://github.com/rust-lang/rust-clippy/pull/15222)
+
+### False Positive Fixes
+
+* [`if_then_some_else_none`] fixed FP when require type coercion
+  [#15267](https://github.com/rust-lang/rust-clippy/pull/15267)
+* [`module_name_repetitions`] fixed FP on exported macros
+  [#15319](https://github.com/rust-lang/rust-clippy/pull/15319)
+* [`unused_async`] fixed FP on function with `todo!`
+  [#15308](https://github.com/rust-lang/rust-clippy/pull/15308)
+* [`useless_attribute`] fixed FP when using `#[expect(redundant_imports)]` and similar lint attributes 
+  on `use` statements
+  [#15318](https://github.com/rust-lang/rust-clippy/pull/15318)
+* [`pattern_type_mismatch`] fixed FP in external macro
+  [#15306](https://github.com/rust-lang/rust-clippy/pull/15306)
+* [`large_enum_variant`] fixed FP by not suggesting `Box` in `no_std` mode
+  [#15241](https://github.com/rust-lang/rust-clippy/pull/15241)
+* [`missing_inline_in_public_items`] fixed FP on functions with `extern`
+  [#15313](https://github.com/rust-lang/rust-clippy/pull/15313)
+* [`needless_range_loop`] fixed FP on array literals
+  [#15314](https://github.com/rust-lang/rust-clippy/pull/15314)
+* [`ptr_as_ptr`] fixed wrong suggestions with turbo fish
+  [#15289](https://github.com/rust-lang/rust-clippy/pull/15289)
+* [`range_plus_one`], [`range_minus_one`] fixed FP by restricting lint to cases where it is safe 
+  to switch the range type
+  [#14432](https://github.com/rust-lang/rust-clippy/pull/14432)
+* [`ptr_arg`] fixed FP with underscore binding to `&T` or `&mut T` argument
+  [#15105](https://github.com/rust-lang/rust-clippy/pull/15105)
+* [`unsafe_derive_deserialize`] fixed FP caused by the standard library's `pin!()` macro
+  [#15137](https://github.com/rust-lang/rust-clippy/pull/15137)
+* [`unused_trait_names`] fixed FP in macros
+  [#14947](https://github.com/rust-lang/rust-clippy/pull/14947)
+* [`expect_fun_call`] fixed invalid suggestions
+  [#15122](https://github.com/rust-lang/rust-clippy/pull/15122)
+* [`manual_is_multiple_of`] fixed various false positives
+  [#15205](https://github.com/rust-lang/rust-clippy/pull/15205)
+* [`manual_assert`] fixed wrong suggestions for macros
+  [#15264](https://github.com/rust-lang/rust-clippy/pull/15264)
+* [`expect_used`] fixed false negative when meeting `Option::ok().expect`
+  [#15253](https://github.com/rust-lang/rust-clippy/pull/15253)
+* [`manual_abs_diff`] fixed wrong suggestions behind refs
+  [#15265](https://github.com/rust-lang/rust-clippy/pull/15265)
+* [`approx_constant`] fixed FP with overly precise literals and non trivially formatted numerals
+  [#15236](https://github.com/rust-lang/rust-clippy/pull/15236)
+* [`arithmetic_side_effects`] fixed FP on `NonZeroU*.get() - 1`
+  [#15238](https://github.com/rust-lang/rust-clippy/pull/15238)
+* [`legacy_numeric_constants`] fixed suggestion when call is inside parentheses
+  [#15191](https://github.com/rust-lang/rust-clippy/pull/15191)
+* [`manual_is_variant_and`] fixed inverted suggestions that could lead to code with different semantics
+  [#15206](https://github.com/rust-lang/rust-clippy/pull/15206)
+* [`unnecessary_map_or`] fixed FP by not proposing to replace `map_or` call when types wouldn't be correct
+  [#15181](https://github.com/rust-lang/rust-clippy/pull/15181)
+* [`return_and_then`] fixed FP in case of a partially used expression
+  [#15115](https://github.com/rust-lang/rust-clippy/pull/15115)
+* [`manual_let_else`] fixed FP with binding subpattern with unused name
+  [#15118](https://github.com/rust-lang/rust-clippy/pull/15118)
+* [`suboptimal_flops`] fixed FP with ambiguous float types in mul_add suggestions
+  [#15133](https://github.com/rust-lang/rust-clippy/pull/15133)
+* [`borrow_as_ptr`] fixed FP by not removing cast to trait object pointer
+  [#15145](https://github.com/rust-lang/rust-clippy/pull/15145)
+* [`unnecessary_operation`] fixed FP by not removing casts if they are useful to type the expression
+  [#15182](https://github.com/rust-lang/rust-clippy/pull/15182)
+* [`empty_loop`] fixed FP on intrinsic function declaration
+  [#15201](https://github.com/rust-lang/rust-clippy/pull/15201)
+* [`doc_nested_refdefs`] fixed FP where task lists are reported as refdefs
+  [#15146](https://github.com/rust-lang/rust-clippy/pull/15146)
+* [`std_instead_of_core`] fixed FP when not all items come from the new crate
+  [#15165](https://github.com/rust-lang/rust-clippy/pull/15165)
+* [`swap_with_temporary`] fixed FP leading to different semantics being suggested
+  [#15172](https://github.com/rust-lang/rust-clippy/pull/15172)
+* [`cast_possible_truncation`] fixed FP by not giving suggestions inside const context
+  [#15164](https://github.com/rust-lang/rust-clippy/pull/15164)
+* [`missing_panics_doc`] fixed FP by allowing unwrap() and expect()s in const-only contexts
+  [#15170](https://github.com/rust-lang/rust-clippy/pull/15170)
+* [`disallowed_script_idents`] fixed FP on identifiers with `_`
+  [#15123](https://github.com/rust-lang/rust-clippy/pull/15123)
+* [`wildcard_enum_match_arm`] fixed wrong suggestions with raw identifiers
+  [#15093](https://github.com/rust-lang/rust-clippy/pull/15093)
+* [`borrow_deref_ref`] fixed FP by not proposing replacing a reborrow when the reborrow is itself mutably borrowed
+  [#14967](https://github.com/rust-lang/rust-clippy/pull/14967)
+* [`manual_ok_err`] fixed wrong suggestions with references
+  [#15053](https://github.com/rust-lang/rust-clippy/pull/15053)
+* [`identity_op`] fixed FP when encountering `Default::default()`
+  [#15028](https://github.com/rust-lang/rust-clippy/pull/15028)
+* [`exhaustive_structs`] fixed FP on structs with default valued field
+  [#15022](https://github.com/rust-lang/rust-clippy/pull/15022)
+* [`collapsible_else_if`] fixed FP on conditionally compiled stmt
+  [#14906](https://github.com/rust-lang/rust-clippy/pull/14906)
+* [`missing_const_for_fn`] fixed FP by checking MSRV before emitting lint on function containing 
+  non-`Sized` trait bounds
+  [#15080](https://github.com/rust-lang/rust-clippy/pull/15080)
+* [`question_mark`] fixed FP when else branch of let-else contains `#[cfg]`
+  [#15082](https://github.com/rust-lang/rust-clippy/pull/15082)
+
+### ICE Fixes
+
+* [`single_match`] fixed ICE with deref patterns and string literals 
+  [#15124](https://github.com/rust-lang/rust-clippy/pull/15124)
+* [`needless_doctest_main`] fixed panic when doctest is invalid
+  [#15052](https://github.com/rust-lang/rust-clippy/pull/15052)
+* [`zero_sized_map_values`] do not attempt to compute size of a type with escaping lifetimes
+  [#15434](https://github.com/rust-lang/rust-clippy/pull/15434)
+
+### Documentation Improvements
+
+* [`manual_is_variant_and`] improved documentation to include equality comparison patterns 
+  [#15239](https://github.com/rust-lang/rust-clippy/pull/15239)
+* [`uninlined_format_args`] improved documentation with example of how to fix a `{:?}` parameter
+  [#15228](https://github.com/rust-lang/rust-clippy/pull/15228)
+* [`undocumented_unsafe_blocks`] improved documentation wording 
+  [#15213](https://github.com/rust-lang/rust-clippy/pull/15213)
 
 ## Rust 1.89
 
@@ -6408,6 +6553,7 @@ Released 2018-09-13
 [`redundant_feature_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_feature_names
 [`redundant_field_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_field_names
 [`redundant_guards`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_guards
+[`redundant_iter_cloned`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_iter_cloned
 [`redundant_locals`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_locals
 [`redundant_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pattern
 [`redundant_pattern_matching`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pattern_matching
diff --git a/Cargo.toml b/Cargo.toml
index b3618932ded7d..e06383499893a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "clippy"
-version = "0.1.91"
+version = "0.1.92"
 description = "A bunch of helpful lints to avoid common pitfalls in Rust"
 repository = "https://github.com/rust-lang/rust-clippy"
 readme = "README.md"
diff --git a/book/src/README.md b/book/src/README.md
index db73b49ecc24e..5d2c3972b060a 100644
--- a/book/src/README.md
+++ b/book/src/README.md
@@ -1,9 +1,5 @@
 # Clippy
 
-[### IMPORTANT NOTE FOR CONTRIBUTORS ================](development/feature_freeze.md)
-
-----
-
 [![License: MIT OR Apache-2.0](https://img.shields.io/crates/l/clippy.svg)](https://github.com/rust-lang/rust-clippy#license)
 
 A collection of lints to catch common mistakes and improve your
diff --git a/book/src/SUMMARY.md b/book/src/SUMMARY.md
index b66c3481e4930..39fe7358ed87a 100644
--- a/book/src/SUMMARY.md
+++ b/book/src/SUMMARY.md
@@ -13,7 +13,6 @@
     - [GitLab CI](continuous_integration/gitlab.md)
     - [Travis CI](continuous_integration/travis.md)
 - [Development](development/README.md)
-    - [IMPORTANT: FEATURE FREEZE](development/feature_freeze.md)
     - [Basics](development/basics.md)
     - [Adding Lints](development/adding_lints.md)
     - [Defining Lints](development/defining_lints.md)
diff --git a/book/src/development/adding_lints.md b/book/src/development/adding_lints.md
index a42a298374465..2b89e94cf8f4f 100644
--- a/book/src/development/adding_lints.md
+++ b/book/src/development/adding_lints.md
@@ -1,8 +1,5 @@
 # Adding a new lint
 
-[### IMPORTANT NOTE FOR CONTRIBUTORS ================](feature_freeze.md)
-
-
 You are probably here because you want to add a new lint to Clippy. If this is
 the first time you're contributing to Clippy, this document guides you through
 creating an example lint from scratch.
diff --git a/book/src/development/feature_freeze.md b/book/src/development/feature_freeze.md
deleted file mode 100644
index 260cb136cc075..0000000000000
--- a/book/src/development/feature_freeze.md
+++ /dev/null
@@ -1,55 +0,0 @@
-# IMPORTANT: FEATURE FREEZE
-
-This is a temporary notice.
-
-From the 26th of June until the 18th of September we will perform a feature freeze. Only bugfix PRs will be reviewed
-except already open ones. Every feature-adding PR opened in between those dates will be moved into a
-milestone to be reviewed separately at another time.
-
-We do this because of the long backlog of bugs that need to be addressed
-in order to continue being the state-of-the-art linter that Clippy has become known for being.
-
-## For contributors
-
-If you are a contributor or are planning to become one, **please do not open a lint-adding PR**, we have lots of open
-bugs of all levels of difficulty that you can address instead!
-
-We currently have about 800 lints, each one posing a maintainability challenge that needs to account to every possible
-use case of the whole ecosystem. Bugs are natural in every software, but the Clippy team considers that Clippy needs a
-refinement period.
-
-If you open a PR at this time, we will not review it but push it into a milestone until the refinement period ends,
-adding additional load into our reviewing schedules.
-
-## I want to help, what can I do
-
-Thanks a lot to everyone who wants to help Clippy become better software in this feature freeze period!
-If you'd like to help, making a bugfix, making sure that it works, and opening a PR is a great step!
-
-To find things to fix, go to the [tracking issue][tracking_issue], find an issue that you like, go there and claim that
-issue with `@rustbot claim`.
-
-As a general metric and always taking into account your skill and knowledge level, you can use this guide:
-
-- 🟥 [ICEs][search_ice], these are compiler errors that causes Clippy to panic and crash. Usually involves high-level
-debugging, sometimes interacting directly with the upstream compiler. Difficult to fix but a great challenge that
-improves a lot developer workflows!
-
-- 🟧 [Suggestion causes bug][sugg_causes_bug], Clippy suggested code that changed logic in some silent way.
-Unacceptable, as this may have disastrous consequences. Easier to fix than ICEs
-
-- 🟨 [Suggestion causes error][sugg_causes_error], Clippy suggested code snippet that caused a compiler error
-when applied. We need to make sure that Clippy doesn't suggest using a variable twice at the same time or similar
-easy-to-happen occurrences.
-
-- 🟩 [False positives][false_positive], a lint should not have fired, the easiest of them all, as this is "just"
-identifying the root of a false positive and making an exception for those cases.
-
-Note that false negatives do not have priority unless the case is very clear, as they are a feature-request in a
-trench coat.
-
-[search_ice]: https://github.com/rust-lang/rust-clippy/issues?q=sort%3Aupdated-desc+state%3Aopen+label%3A%22I-ICE%22
-[sugg_causes_bug]: https://github.com/rust-lang/rust-clippy/issues?q=sort%3Aupdated-desc%20state%3Aopen%20label%3AI-suggestion-causes-bug
-[sugg_causes_error]: https://github.com/rust-lang/rust-clippy/issues?q=sort%3Aupdated-desc%20state%3Aopen%20label%3AI-suggestion-causes-error%20
-[false_positive]: https://github.com/rust-lang/rust-clippy/issues?q=sort%3Aupdated-desc%20state%3Aopen%20label%3AI-false-positive
-[tracking_issue]: https://github.com/rust-lang/rust-clippy/issues/15086
diff --git a/clippy_config/Cargo.toml b/clippy_config/Cargo.toml
index 6ad2cf0d0b104..f8c748290e418 100644
--- a/clippy_config/Cargo.toml
+++ b/clippy_config/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "clippy_config"
-version = "0.1.91"
+version = "0.1.92"
 edition = "2024"
 publish = false
 
diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index 70184ee2ca596..51e59ae205076 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "clippy_lints"
-version = "0.1.91"
+version = "0.1.92"
 description = "A bunch of helpful lints to avoid common pitfalls in Rust"
 repository = "https://github.com/rust-lang/rust-clippy"
 readme = "README.md"
diff --git a/clippy_lints/src/attrs/useless_attribute.rs b/clippy_lints/src/attrs/useless_attribute.rs
index b9b5cedb5aa76..1cebc18edc90a 100644
--- a/clippy_lints/src/attrs/useless_attribute.rs
+++ b/clippy_lints/src/attrs/useless_attribute.rs
@@ -30,6 +30,7 @@ pub(super) fn check(cx: &EarlyContext<'_>, item: &Item, attrs: &[Attribute]) {
                                 sym::ambiguous_glob_reexports
                                     | sym::dead_code
                                     | sym::deprecated
+                                    | sym::deprecated_in_future
                                     | sym::hidden_glob_reexports
                                     | sym::unreachable_pub
                                     | sym::unused
diff --git a/clippy_lints/src/casts/as_underscore.rs b/clippy_lints/src/casts/as_underscore.rs
index 3ac486dd63fbb..a73e48e5fd5d1 100644
--- a/clippy_lints/src/casts/as_underscore.rs
+++ b/clippy_lints/src/casts/as_underscore.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Ty, TyKind};
 use rustc_lint::LateContext;
-use rustc_middle::ty;
+use rustc_middle::ty::IsSuggestable;
 
 use super::AS_UNDERSCORE;
 
@@ -10,15 +10,15 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, ty: &'tc
     if matches!(ty.kind, TyKind::Infer(())) {
         span_lint_and_then(cx, AS_UNDERSCORE, expr.span, "using `as _` conversion", |diag| {
             let ty_resolved = cx.typeck_results().expr_ty(expr);
-            if let ty::Error(_) = ty_resolved.kind() {
-                diag.help("consider giving the type explicitly");
-            } else {
+            if ty_resolved.is_suggestable(cx.tcx, true) {
                 diag.span_suggestion(
                     ty.span,
                     "consider giving the type explicitly",
                     ty_resolved,
                     Applicability::MachineApplicable,
                 );
+            } else {
+                diag.help("consider giving the type explicitly");
             }
         });
     }
diff --git a/clippy_lints/src/casts/cast_possible_wrap.rs b/clippy_lints/src/casts/cast_possible_wrap.rs
index e26c03ccda933..9eaa6e4cf26e4 100644
--- a/clippy_lints/src/casts/cast_possible_wrap.rs
+++ b/clippy_lints/src/casts/cast_possible_wrap.rs
@@ -1,4 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::sugg::Sugg;
+use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::Ty;
@@ -16,7 +19,14 @@ enum EmitState {
     LintOnPtrSize(u64),
 }
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    cast_op: &Expr<'_>,
+    cast_from: Ty<'_>,
+    cast_to: Ty<'_>,
+    msrv: Msrv,
+) {
     let (Some(from_nbits), Some(to_nbits)) = (
         utils::int_ty_to_nbits(cx.tcx, cast_from),
         utils::int_ty_to_nbits(cx.tcx, cast_to),
@@ -85,5 +95,23 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, ca
                 .note("`usize` and `isize` may be as small as 16 bits on some platforms")
                 .note("for more information see https://doc.rust-lang.org/reference/types/numeric.html#machine-dependent-integer-types");
         }
+
+        if msrv.meets(cx, msrvs::INTEGER_SIGN_CAST)
+            && let Some(cast) = utils::is_signedness_cast(cast_from, cast_to)
+        {
+            let method = match cast {
+                utils::CastTo::Signed => "cast_signed()",
+                utils::CastTo::Unsigned => "cast_unsigned()",
+            };
+            let mut app = Applicability::MaybeIncorrect;
+            let sugg = Sugg::hir_with_context(cx, cast_op, expr.span.ctxt(), "..", &mut app);
+
+            diag.span_suggestion(
+                expr.span,
+                format!("if this is intentional, use `{method}` instead"),
+                format!("{}.{method}", sugg.maybe_paren()),
+                app,
+            );
+        }
     });
 }
diff --git a/clippy_lints/src/casts/cast_sign_loss.rs b/clippy_lints/src/casts/cast_sign_loss.rs
index a70bd88619195..f870d27b796e8 100644
--- a/clippy_lints/src/casts/cast_sign_loss.rs
+++ b/clippy_lints/src/casts/cast_sign_loss.rs
@@ -2,15 +2,18 @@ use std::convert::Infallible;
 use std::ops::ControlFlow;
 
 use clippy_utils::consts::{ConstEvalCtxt, Constant};
-use clippy_utils::diagnostics::span_lint;
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::sugg::Sugg;
 use clippy_utils::visitors::{Descend, for_each_expr_without_closures};
 use clippy_utils::{method_chain_args, sext, sym};
+use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
 use rustc_span::Symbol;
 
-use super::CAST_SIGN_LOSS;
+use super::{CAST_SIGN_LOSS, utils};
 
 /// A list of methods that can never return a negative value.
 /// Includes methods that panic rather than returning a negative value.
@@ -42,13 +45,33 @@ pub(super) fn check<'cx>(
     cast_op: &Expr<'_>,
     cast_from: Ty<'cx>,
     cast_to: Ty<'_>,
+    msrv: Msrv,
 ) {
     if should_lint(cx, cast_op, cast_from, cast_to) {
-        span_lint(
+        span_lint_and_then(
             cx,
             CAST_SIGN_LOSS,
             expr.span,
             format!("casting `{cast_from}` to `{cast_to}` may lose the sign of the value"),
+            |diag| {
+                if msrv.meets(cx, msrvs::INTEGER_SIGN_CAST)
+                    && let Some(cast) = utils::is_signedness_cast(cast_from, cast_to)
+                {
+                    let method = match cast {
+                        utils::CastTo::Signed => "cast_signed()",
+                        utils::CastTo::Unsigned => "cast_unsigned()",
+                    };
+                    let mut app = Applicability::MaybeIncorrect;
+                    let sugg = Sugg::hir_with_context(cx, cast_op, expr.span.ctxt(), "..", &mut app);
+
+                    diag.span_suggestion(
+                        expr.span,
+                        format!("if this is intentional, use `{method}` instead"),
+                        format!("{}.{method}", sugg.maybe_paren()),
+                        app,
+                    );
+                }
+            },
         );
     }
 }
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index d2e62ee56e43b..47cc1da0a6e9f 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -890,9 +890,9 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             if cast_to.is_numeric() {
                 cast_possible_truncation::check(cx, expr, cast_from_expr, cast_from, cast_to, cast_to_hir.span);
                 if cast_from.is_numeric() {
-                    cast_possible_wrap::check(cx, expr, cast_from, cast_to);
+                    cast_possible_wrap::check(cx, expr, cast_from_expr, cast_from, cast_to, self.msrv);
                     cast_precision_loss::check(cx, expr, cast_from, cast_to);
-                    cast_sign_loss::check(cx, expr, cast_from_expr, cast_from, cast_to);
+                    cast_sign_loss::check(cx, expr, cast_from_expr, cast_from, cast_to, self.msrv);
                     cast_abs_to_unsigned::check(cx, expr, cast_from_expr, cast_from, cast_to, self.msrv);
                     cast_nan_to_int::check(cx, expr, cast_from_expr, cast_from, cast_to);
                 }
diff --git a/clippy_lints/src/casts/utils.rs b/clippy_lints/src/casts/utils.rs
index d846d78b9ee78..707fc2a8eed35 100644
--- a/clippy_lints/src/casts/utils.rs
+++ b/clippy_lints/src/casts/utils.rs
@@ -60,3 +60,18 @@ pub(super) fn enum_ty_to_nbits(adt: AdtDef<'_>, tcx: TyCtxt<'_>) -> u64 {
         neg_bits.max(pos_bits).into()
     }
 }
+
+pub(super) enum CastTo {
+    Signed,
+    Unsigned,
+}
+/// Returns `Some` if the type cast is between 2 integral types that differ
+/// only in signedness, otherwise `None`. The value of `Some` is which
+/// signedness is casted to.
+pub(super) fn is_signedness_cast(cast_from: Ty<'_>, cast_to: Ty<'_>) -> Option<CastTo> {
+    match (cast_from.kind(), cast_to.kind()) {
+        (ty::Int(from), ty::Uint(to)) if from.to_unsigned() == *to => Some(CastTo::Unsigned),
+        (ty::Uint(from), ty::Int(to)) if *from == to.to_unsigned() => Some(CastTo::Signed),
+        _ => None,
+    }
+}
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index d0c7443a4a4b9..2a4bedc184552 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -448,10 +448,12 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::methods::OR_THEN_UNWRAP_INFO,
     crate::methods::PATH_BUF_PUSH_OVERWRITE_INFO,
     crate::methods::PATH_ENDS_WITH_EXT_INFO,
+    crate::methods::PTR_OFFSET_WITH_CAST_INFO,
     crate::methods::RANGE_ZIP_WITH_LEN_INFO,
     crate::methods::READONLY_WRITE_LOCK_INFO,
     crate::methods::READ_LINE_WITHOUT_TRIM_INFO,
     crate::methods::REDUNDANT_AS_STR_INFO,
+    crate::methods::REDUNDANT_ITER_CLONED_INFO,
     crate::methods::REPEAT_ONCE_INFO,
     crate::methods::RESULT_FILTER_MAP_INFO,
     crate::methods::RESULT_MAP_OR_INTO_OPTION_INFO,
@@ -503,7 +505,6 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::min_ident_chars::MIN_IDENT_CHARS_INFO,
     crate::minmax::MIN_MAX_INFO,
     crate::misc::SHORT_CIRCUIT_STATEMENT_INFO,
-    crate::misc::TOPLEVEL_REF_ARG_INFO,
     crate::misc::USED_UNDERSCORE_BINDING_INFO,
     crate::misc::USED_UNDERSCORE_ITEMS_INFO,
     crate::misc_early::BUILTIN_TYPE_SHADOW_INFO,
@@ -625,7 +626,6 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::ptr::MUT_FROM_REF_INFO,
     crate::ptr::PTR_ARG_INFO,
     crate::ptr::PTR_EQ_INFO,
-    crate::ptr_offset_with_cast::PTR_OFFSET_WITH_CAST_INFO,
     crate::pub_underscore_fields::PUB_UNDERSCORE_FIELDS_INFO,
     crate::pub_use::PUB_USE_INFO,
     crate::question_mark::QUESTION_MARK_INFO,
@@ -706,6 +706,7 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::tests_outside_test_module::TESTS_OUTSIDE_TEST_MODULE_INFO,
     crate::to_digit_is_some::TO_DIGIT_IS_SOME_INFO,
     crate::to_string_trait_impl::TO_STRING_TRAIT_IMPL_INFO,
+    crate::toplevel_ref_arg::TOPLEVEL_REF_ARG_INFO,
     crate::trailing_empty_array::TRAILING_EMPTY_ARRAY_INFO,
     crate::trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS_INFO,
     crate::trait_bounds::TYPE_REPETITION_IN_BOUNDS_INFO,
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 9645a26a68ae1..a70105db19490 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1,10 +1,9 @@
 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::{adjust_derefs_manually_drop, implements_trait, is_manually_drop};
+use clippy_utils::ty::{adjust_derefs_manually_drop, implements_trait, is_manually_drop, peel_and_count_ty_refs};
 use clippy_utils::{
     DefinedTy, ExprUseNode, expr_use_ctxt, get_parent_expr, is_block_like, is_lint_allowed, path_to_local,
-    peel_middle_ty_refs,
 };
 use rustc_ast::util::parser::ExprPrecedence;
 use rustc_data_structures::fx::FxIndexMap;
@@ -942,7 +941,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_middle_ty_refs(ty);
+            let (_, ref_count, _) = peel_and_count_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.
@@ -1045,7 +1044,7 @@ fn report<'tcx>(
             if let ty::Ref(_, dst, _) = data.adjusted_ty.kind()
                 && dst.is_slice()
             {
-                let (src, n_src_refs) = peel_middle_ty_refs(ty);
+                let (src, n_src_refs, _) = peel_and_count_ty_refs(ty);
                 if n_src_refs >= 2 && src.is_array() {
                     return;
                 }
diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
deleted file mode 100644
index c53a957f6a8b7..0000000000000
--- a/clippy_lints/src/derive.rs
+++ /dev/null
@@ -1,527 +0,0 @@
-use std::ops::ControlFlow;
-
-use clippy_utils::diagnostics::{span_lint_and_note, span_lint_and_then, span_lint_hir_and_then};
-use clippy_utils::ty::{implements_trait, implements_trait_with_env, is_copy};
-use clippy_utils::{has_non_exhaustive_attr, is_lint_allowed, paths};
-use rustc_errors::Applicability;
-use rustc_hir::def_id::DefId;
-use rustc_hir::intravisit::{FnKind, Visitor, walk_expr, walk_fn, walk_item};
-use rustc_hir::{self as hir, BlockCheckMode, BodyId, Expr, ExprKind, FnDecl, Impl, Item, ItemKind, UnsafeSource};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::hir::nested_filter;
-use rustc_middle::ty::{
-    self, ClauseKind, GenericArgKind, GenericParamDefKind, ParamEnv, TraitPredicate, Ty, TyCtxt, Upcast,
-};
-use rustc_session::declare_lint_pass;
-use rustc_span::def_id::LocalDefId;
-use rustc_span::{Span, sym};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Lints against manual `PartialEq` implementations for types with a derived `Hash`
-    /// implementation.
-    ///
-    /// ### Why is this bad?
-    /// The implementation of these traits must agree (for
-    /// example for use with `HashMap`) so it’s probably a bad idea to use a
-    /// default-generated `Hash` implementation with an explicitly defined
-    /// `PartialEq`. In particular, the following must hold for any type:
-    ///
-    /// ```text
-    /// k1 == k2 ⇒ hash(k1) == hash(k2)
-    /// ```
-    ///
-    /// ### Example
-    /// ```ignore
-    /// #[derive(Hash)]
-    /// struct Foo;
-    ///
-    /// impl PartialEq for Foo {
-    ///     ...
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub DERIVED_HASH_WITH_MANUAL_EQ,
-    correctness,
-    "deriving `Hash` but implementing `PartialEq` explicitly"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Lints against manual `PartialOrd` and `Ord` implementations for types with a derived `Ord`
-    /// or `PartialOrd` implementation.
-    ///
-    /// ### Why is this bad?
-    /// The implementation of these traits must agree (for
-    /// example for use with `sort`) so it’s probably a bad idea to use a
-    /// default-generated `Ord` implementation with an explicitly defined
-    /// `PartialOrd`. In particular, the following must hold for any type
-    /// implementing `Ord`:
-    ///
-    /// ```text
-    /// k1.cmp(&k2) == k1.partial_cmp(&k2).unwrap()
-    /// ```
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// #[derive(Ord, PartialEq, Eq)]
-    /// struct Foo;
-    ///
-    /// impl PartialOrd for Foo {
-    ///     ...
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust,ignore
-    /// #[derive(PartialEq, Eq)]
-    /// struct Foo;
-    ///
-    /// impl PartialOrd for Foo {
-    ///     fn partial_cmp(&self, other: &Foo) -> Option<Ordering> {
-    ///        Some(self.cmp(other))
-    ///     }
-    /// }
-    ///
-    /// impl Ord for Foo {
-    ///     ...
-    /// }
-    /// ```
-    /// or, if you don't need a custom ordering:
-    /// ```rust,ignore
-    /// #[derive(Ord, PartialOrd, PartialEq, Eq)]
-    /// struct Foo;
-    /// ```
-    #[clippy::version = "1.47.0"]
-    pub DERIVE_ORD_XOR_PARTIAL_ORD,
-    correctness,
-    "deriving `Ord` but implementing `PartialOrd` explicitly"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for explicit `Clone` implementations for `Copy`
-    /// types.
-    ///
-    /// ### Why is this bad?
-    /// To avoid surprising behavior, these traits should
-    /// agree and the behavior of `Copy` cannot be overridden. In almost all
-    /// situations a `Copy` type should have a `Clone` implementation that does
-    /// nothing more than copy the object, which is what `#[derive(Copy, Clone)]`
-    /// gets you.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// #[derive(Copy)]
-    /// struct Foo;
-    ///
-    /// impl Clone for Foo {
-    ///     // ..
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub EXPL_IMPL_CLONE_ON_COPY,
-    pedantic,
-    "implementing `Clone` explicitly on `Copy` types"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for deriving `serde::Deserialize` on a type that
-    /// has methods using `unsafe`.
-    ///
-    /// ### Why is this bad?
-    /// Deriving `serde::Deserialize` will create a constructor
-    /// that may violate invariants held by another constructor.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// use serde::Deserialize;
-    ///
-    /// #[derive(Deserialize)]
-    /// pub struct Foo {
-    ///     // ..
-    /// }
-    ///
-    /// impl Foo {
-    ///     pub fn new() -> Self {
-    ///         // setup here ..
-    ///     }
-    ///
-    ///     pub unsafe fn parts() -> (&str, &str) {
-    ///         // assumes invariants hold
-    ///     }
-    /// }
-    /// ```
-    #[clippy::version = "1.45.0"]
-    pub UNSAFE_DERIVE_DESERIALIZE,
-    pedantic,
-    "deriving `serde::Deserialize` on a type that has methods using `unsafe`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for types that derive `PartialEq` and could implement `Eq`.
-    ///
-    /// ### Why is this bad?
-    /// If a type `T` derives `PartialEq` and all of its members implement `Eq`,
-    /// then `T` can always implement `Eq`. Implementing `Eq` allows `T` to be used
-    /// in APIs that require `Eq` types. It also allows structs containing `T` to derive
-    /// `Eq` themselves.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// #[derive(PartialEq)]
-    /// struct Foo {
-    ///     i_am_eq: i32,
-    ///     i_am_eq_too: Vec<String>,
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// #[derive(PartialEq, Eq)]
-    /// struct Foo {
-    ///     i_am_eq: i32,
-    ///     i_am_eq_too: Vec<String>,
-    /// }
-    /// ```
-    #[clippy::version = "1.63.0"]
-    pub DERIVE_PARTIAL_EQ_WITHOUT_EQ,
-    nursery,
-    "deriving `PartialEq` on a type that can implement `Eq`, without implementing `Eq`"
-}
-
-declare_lint_pass!(Derive => [
-    EXPL_IMPL_CLONE_ON_COPY,
-    DERIVED_HASH_WITH_MANUAL_EQ,
-    DERIVE_ORD_XOR_PARTIAL_ORD,
-    UNSAFE_DERIVE_DESERIALIZE,
-    DERIVE_PARTIAL_EQ_WITHOUT_EQ
-]);
-
-impl<'tcx> LateLintPass<'tcx> for Derive {
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        if let ItemKind::Impl(Impl {
-            of_trait: Some(of_trait),
-            ..
-        }) = item.kind
-        {
-            let trait_ref = &of_trait.trait_ref;
-            let ty = cx.tcx.type_of(item.owner_id).instantiate_identity();
-            let is_automatically_derived = cx.tcx.is_automatically_derived(item.owner_id.to_def_id());
-
-            check_hash_peq(cx, item.span, trait_ref, ty, is_automatically_derived);
-            check_ord_partial_ord(cx, item.span, trait_ref, ty, is_automatically_derived);
-
-            if is_automatically_derived {
-                check_unsafe_derive_deserialize(cx, item, trait_ref, ty);
-                check_partial_eq_without_eq(cx, item.span, trait_ref, ty);
-            } else {
-                check_copy_clone(cx, item, trait_ref, ty);
-            }
-        }
-    }
-}
-
-/// Implementation of the `DERIVED_HASH_WITH_MANUAL_EQ` lint.
-fn check_hash_peq<'tcx>(
-    cx: &LateContext<'tcx>,
-    span: Span,
-    trait_ref: &hir::TraitRef<'_>,
-    ty: Ty<'tcx>,
-    hash_is_automatically_derived: bool,
-) {
-    if let Some(peq_trait_def_id) = cx.tcx.lang_items().eq_trait()
-        && let Some(def_id) = trait_ref.trait_def_id()
-        && cx.tcx.is_diagnostic_item(sym::Hash, def_id)
-    {
-        // Look for the PartialEq implementations for `ty`
-        cx.tcx.for_each_relevant_impl(peq_trait_def_id, ty, |impl_id| {
-            let peq_is_automatically_derived = cx.tcx.is_automatically_derived(impl_id);
-
-            if !hash_is_automatically_derived || peq_is_automatically_derived {
-                return;
-            }
-
-            let trait_ref = cx.tcx.impl_trait_ref(impl_id).expect("must be a trait implementation");
-
-            // Only care about `impl PartialEq<Foo> for Foo`
-            // For `impl PartialEq<B> for A, input_types is [A, B]
-            if trait_ref.instantiate_identity().args.type_at(1) == ty {
-                span_lint_and_then(
-                    cx,
-                    DERIVED_HASH_WITH_MANUAL_EQ,
-                    span,
-                    "you are deriving `Hash` but have implemented `PartialEq` explicitly",
-                    |diag| {
-                        if let Some(local_def_id) = impl_id.as_local() {
-                            let hir_id = cx.tcx.local_def_id_to_hir_id(local_def_id);
-                            diag.span_note(cx.tcx.hir_span(hir_id), "`PartialEq` implemented here");
-                        }
-                    },
-                );
-            }
-        });
-    }
-}
-
-/// Implementation of the `DERIVE_ORD_XOR_PARTIAL_ORD` lint.
-fn check_ord_partial_ord<'tcx>(
-    cx: &LateContext<'tcx>,
-    span: Span,
-    trait_ref: &hir::TraitRef<'_>,
-    ty: Ty<'tcx>,
-    ord_is_automatically_derived: bool,
-) {
-    if let Some(ord_trait_def_id) = cx.tcx.get_diagnostic_item(sym::Ord)
-        && let Some(partial_ord_trait_def_id) = cx.tcx.lang_items().partial_ord_trait()
-        && let Some(def_id) = &trait_ref.trait_def_id()
-        && *def_id == ord_trait_def_id
-    {
-        // Look for the PartialOrd implementations for `ty`
-        cx.tcx.for_each_relevant_impl(partial_ord_trait_def_id, ty, |impl_id| {
-            let partial_ord_is_automatically_derived = cx.tcx.is_automatically_derived(impl_id);
-
-            if partial_ord_is_automatically_derived == ord_is_automatically_derived {
-                return;
-            }
-
-            let trait_ref = cx.tcx.impl_trait_ref(impl_id).expect("must be a trait implementation");
-
-            // Only care about `impl PartialOrd<Foo> for Foo`
-            // For `impl PartialOrd<B> for A, input_types is [A, B]
-            if trait_ref.instantiate_identity().args.type_at(1) == ty {
-                let mess = if partial_ord_is_automatically_derived {
-                    "you are implementing `Ord` explicitly but have derived `PartialOrd`"
-                } else {
-                    "you are deriving `Ord` but have implemented `PartialOrd` explicitly"
-                };
-
-                span_lint_and_then(cx, DERIVE_ORD_XOR_PARTIAL_ORD, span, mess, |diag| {
-                    if let Some(local_def_id) = impl_id.as_local() {
-                        let hir_id = cx.tcx.local_def_id_to_hir_id(local_def_id);
-                        diag.span_note(cx.tcx.hir_span(hir_id), "`PartialOrd` implemented here");
-                    }
-                });
-            }
-        });
-    }
-}
-
-/// Implementation of the `EXPL_IMPL_CLONE_ON_COPY` lint.
-fn check_copy_clone<'tcx>(cx: &LateContext<'tcx>, item: &Item<'_>, trait_ref: &hir::TraitRef<'_>, ty: Ty<'tcx>) {
-    let clone_id = match cx.tcx.lang_items().clone_trait() {
-        Some(id) if trait_ref.trait_def_id() == Some(id) => id,
-        _ => return,
-    };
-    let Some(copy_id) = cx.tcx.lang_items().copy_trait() else {
-        return;
-    };
-    let (ty_adt, ty_subs) = match *ty.kind() {
-        // Unions can't derive clone.
-        ty::Adt(adt, subs) if !adt.is_union() => (adt, subs),
-        _ => return,
-    };
-    // If the current self type doesn't implement Copy (due to generic constraints), search to see if
-    // there's a Copy impl for any instance of the adt.
-    if !is_copy(cx, ty) {
-        if ty_subs.non_erasable_generics().next().is_some() {
-            let has_copy_impl = cx.tcx.local_trait_impls(copy_id).iter().any(|&id| {
-                matches!(cx.tcx.type_of(id).instantiate_identity().kind(), ty::Adt(adt, _)
-                                        if ty_adt.did() == adt.did())
-            });
-            if !has_copy_impl {
-                return;
-            }
-        } else {
-            return;
-        }
-    }
-    // Derive constrains all generic types to requiring Clone. Check if any type is not constrained for
-    // this impl.
-    if ty_subs.types().any(|ty| !implements_trait(cx, ty, clone_id, &[])) {
-        return;
-    }
-    // `#[repr(packed)]` structs with type/const parameters can't derive `Clone`.
-    // https://github.com/rust-lang/rust-clippy/issues/10188
-    if ty_adt.repr().packed()
-        && ty_subs
-            .iter()
-            .any(|arg| matches!(arg.kind(), GenericArgKind::Type(_) | GenericArgKind::Const(_)))
-    {
-        return;
-    }
-    // The presence of `unsafe` fields prevents deriving `Clone` automatically
-    if ty_adt.all_fields().any(|f| f.safety.is_unsafe()) {
-        return;
-    }
-
-    span_lint_and_note(
-        cx,
-        EXPL_IMPL_CLONE_ON_COPY,
-        item.span,
-        "you are implementing `Clone` explicitly on a `Copy` type",
-        Some(item.span),
-        "consider deriving `Clone` or removing `Copy`",
-    );
-}
-
-/// Implementation of the `UNSAFE_DERIVE_DESERIALIZE` lint.
-fn check_unsafe_derive_deserialize<'tcx>(
-    cx: &LateContext<'tcx>,
-    item: &Item<'_>,
-    trait_ref: &hir::TraitRef<'_>,
-    ty: Ty<'tcx>,
-) {
-    fn has_unsafe<'tcx>(cx: &LateContext<'tcx>, item: &'tcx Item<'_>) -> bool {
-        let mut visitor = UnsafeVisitor { cx };
-        walk_item(&mut visitor, item).is_break()
-    }
-
-    if let Some(trait_def_id) = trait_ref.trait_def_id()
-        && paths::SERDE_DESERIALIZE.matches(cx, trait_def_id)
-        && let ty::Adt(def, _) = ty.kind()
-        && let Some(local_def_id) = def.did().as_local()
-        && let adt_hir_id = cx.tcx.local_def_id_to_hir_id(local_def_id)
-        && !is_lint_allowed(cx, UNSAFE_DERIVE_DESERIALIZE, adt_hir_id)
-        && cx
-            .tcx
-            .inherent_impls(def.did())
-            .iter()
-            .map(|imp_did| cx.tcx.hir_expect_item(imp_did.expect_local()))
-            .any(|imp| has_unsafe(cx, imp))
-    {
-        span_lint_hir_and_then(
-            cx,
-            UNSAFE_DERIVE_DESERIALIZE,
-            adt_hir_id,
-            item.span,
-            "you are deriving `serde::Deserialize` on a type that has methods using `unsafe`",
-            |diag| {
-                diag.help(
-                    "consider implementing `serde::Deserialize` manually. See https://serde.rs/impl-deserialize.html",
-                );
-            },
-        );
-    }
-}
-
-struct UnsafeVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-}
-
-impl<'tcx> Visitor<'tcx> for UnsafeVisitor<'_, 'tcx> {
-    type Result = ControlFlow<()>;
-    type NestedFilter = nested_filter::All;
-
-    fn visit_fn(
-        &mut self,
-        kind: FnKind<'tcx>,
-        decl: &'tcx FnDecl<'_>,
-        body_id: BodyId,
-        _: Span,
-        id: LocalDefId,
-    ) -> Self::Result {
-        if let Some(header) = kind.header()
-            && header.is_unsafe()
-        {
-            ControlFlow::Break(())
-        } else {
-            walk_fn(self, kind, decl, body_id, id)
-        }
-    }
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) -> Self::Result {
-        if let ExprKind::Block(block, _) = expr.kind
-            && block.rules == BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided)
-            && block
-                .span
-                .source_callee()
-                .and_then(|expr| expr.macro_def_id)
-                .is_none_or(|did| !self.cx.tcx.is_diagnostic_item(sym::pin_macro, did))
-        {
-            return ControlFlow::Break(());
-        }
-
-        walk_expr(self, expr)
-    }
-
-    fn maybe_tcx(&mut self) -> Self::MaybeTyCtxt {
-        self.cx.tcx
-    }
-}
-
-/// Implementation of the `DERIVE_PARTIAL_EQ_WITHOUT_EQ` lint.
-fn check_partial_eq_without_eq<'tcx>(cx: &LateContext<'tcx>, span: Span, trait_ref: &hir::TraitRef<'_>, ty: Ty<'tcx>) {
-    if let ty::Adt(adt, args) = ty.kind()
-        && cx.tcx.visibility(adt.did()).is_public()
-        && let Some(eq_trait_def_id) = cx.tcx.get_diagnostic_item(sym::Eq)
-        && let Some(def_id) = trait_ref.trait_def_id()
-        && cx.tcx.is_diagnostic_item(sym::PartialEq, def_id)
-        && !has_non_exhaustive_attr(cx.tcx, *adt)
-        && !ty_implements_eq_trait(cx.tcx, ty, eq_trait_def_id)
-        && let typing_env = typing_env_for_derived_eq(cx.tcx, adt.did(), eq_trait_def_id)
-        && let Some(local_def_id) = adt.did().as_local()
-        // If all of our fields implement `Eq`, we can implement `Eq` too
-        && adt
-            .all_fields()
-            .map(|f| f.ty(cx.tcx, args))
-            .all(|ty| implements_trait_with_env(cx.tcx, typing_env, ty, eq_trait_def_id, None, &[]))
-    {
-        span_lint_hir_and_then(
-            cx,
-            DERIVE_PARTIAL_EQ_WITHOUT_EQ,
-            cx.tcx.local_def_id_to_hir_id(local_def_id),
-            span.ctxt().outer_expn_data().call_site,
-            "you are deriving `PartialEq` and can implement `Eq`",
-            |diag| {
-                diag.span_suggestion(
-                    span.ctxt().outer_expn_data().call_site,
-                    "consider deriving `Eq` as well",
-                    "PartialEq, Eq",
-                    Applicability::MachineApplicable,
-                );
-            },
-        );
-    }
-}
-
-fn ty_implements_eq_trait<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, eq_trait_id: DefId) -> bool {
-    tcx.non_blanket_impls_for_ty(eq_trait_id, ty).next().is_some()
-}
-
-/// Creates the `ParamEnv` used for the given type's derived `Eq` impl.
-fn typing_env_for_derived_eq(tcx: TyCtxt<'_>, did: DefId, eq_trait_id: DefId) -> ty::TypingEnv<'_> {
-    // Initial map from generic index to param def.
-    // Vec<(param_def, needs_eq)>
-    let mut params = tcx
-        .generics_of(did)
-        .own_params
-        .iter()
-        .map(|p| (p, matches!(p.kind, GenericParamDefKind::Type { .. })))
-        .collect::<Vec<_>>();
-
-    let ty_predicates = tcx.predicates_of(did).predicates;
-    for (p, _) in ty_predicates {
-        if let ClauseKind::Trait(p) = p.kind().skip_binder()
-            && p.trait_ref.def_id == eq_trait_id
-            && let ty::Param(self_ty) = p.trait_ref.self_ty().kind()
-        {
-            // Flag types which already have an `Eq` bound.
-            params[self_ty.index as usize].1 = false;
-        }
-    }
-
-    let param_env = ParamEnv::new(tcx.mk_clauses_from_iter(ty_predicates.iter().map(|&(p, _)| p).chain(
-        params.iter().filter(|&&(_, needs_eq)| needs_eq).map(|&(param, _)| {
-            ClauseKind::Trait(TraitPredicate {
-                trait_ref: ty::TraitRef::new(tcx, eq_trait_id, [tcx.mk_param_from_def(param)]),
-                polarity: ty::PredicatePolarity::Positive,
-            })
-            .upcast(tcx)
-        }),
-    )));
-    ty::TypingEnv {
-        typing_mode: ty::TypingMode::non_body_analysis(),
-        param_env,
-    }
-}
diff --git a/clippy_lints/src/derive/derive_ord_xor_partial_ord.rs b/clippy_lints/src/derive/derive_ord_xor_partial_ord.rs
new file mode 100644
index 0000000000000..cbbcb2f7a3bab
--- /dev/null
+++ b/clippy_lints/src/derive/derive_ord_xor_partial_ord.rs
@@ -0,0 +1,50 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_middle::ty::Ty;
+use rustc_span::{Span, sym};
+
+use super::DERIVE_ORD_XOR_PARTIAL_ORD;
+
+/// Implementation of the `DERIVE_ORD_XOR_PARTIAL_ORD` lint.
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    span: Span,
+    trait_ref: &hir::TraitRef<'_>,
+    ty: Ty<'tcx>,
+    ord_is_automatically_derived: bool,
+) {
+    if let Some(ord_trait_def_id) = cx.tcx.get_diagnostic_item(sym::Ord)
+        && let Some(partial_ord_trait_def_id) = cx.tcx.lang_items().partial_ord_trait()
+        && let Some(def_id) = &trait_ref.trait_def_id()
+        && *def_id == ord_trait_def_id
+    {
+        // Look for the PartialOrd implementations for `ty`
+        cx.tcx.for_each_relevant_impl(partial_ord_trait_def_id, ty, |impl_id| {
+            let partial_ord_is_automatically_derived = cx.tcx.is_automatically_derived(impl_id);
+
+            if partial_ord_is_automatically_derived == ord_is_automatically_derived {
+                return;
+            }
+
+            let trait_ref = cx.tcx.impl_trait_ref(impl_id).expect("must be a trait implementation");
+
+            // Only care about `impl PartialOrd<Foo> for Foo`
+            // For `impl PartialOrd<B> for A, input_types is [A, B]
+            if trait_ref.instantiate_identity().args.type_at(1) == ty {
+                let mess = if partial_ord_is_automatically_derived {
+                    "you are implementing `Ord` explicitly but have derived `PartialOrd`"
+                } else {
+                    "you are deriving `Ord` but have implemented `PartialOrd` explicitly"
+                };
+
+                span_lint_and_then(cx, DERIVE_ORD_XOR_PARTIAL_ORD, span, mess, |diag| {
+                    if let Some(local_def_id) = impl_id.as_local() {
+                        let hir_id = cx.tcx.local_def_id_to_hir_id(local_def_id);
+                        diag.span_note(cx.tcx.hir_span(hir_id), "`PartialOrd` implemented here");
+                    }
+                });
+            }
+        });
+    }
+}
diff --git a/clippy_lints/src/derive/derive_partial_eq_without_eq.rs b/clippy_lints/src/derive/derive_partial_eq_without_eq.rs
new file mode 100644
index 0000000000000..ed7881c461ffc
--- /dev/null
+++ b/clippy_lints/src/derive/derive_partial_eq_without_eq.rs
@@ -0,0 +1,87 @@
+use clippy_utils::diagnostics::span_lint_hir_and_then;
+use clippy_utils::has_non_exhaustive_attr;
+use clippy_utils::ty::implements_trait_with_env;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, ClauseKind, GenericParamDefKind, ParamEnv, TraitPredicate, Ty, TyCtxt, Upcast};
+use rustc_span::{Span, sym};
+
+use super::DERIVE_PARTIAL_EQ_WITHOUT_EQ;
+
+/// Implementation of the `DERIVE_PARTIAL_EQ_WITHOUT_EQ` lint.
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, span: Span, trait_ref: &hir::TraitRef<'_>, ty: Ty<'tcx>) {
+    if let ty::Adt(adt, args) = ty.kind()
+        && cx.tcx.visibility(adt.did()).is_public()
+        && let Some(eq_trait_def_id) = cx.tcx.get_diagnostic_item(sym::Eq)
+        && let Some(def_id) = trait_ref.trait_def_id()
+        && cx.tcx.is_diagnostic_item(sym::PartialEq, def_id)
+        && !has_non_exhaustive_attr(cx.tcx, *adt)
+        && !ty_implements_eq_trait(cx.tcx, ty, eq_trait_def_id)
+        && let typing_env = typing_env_for_derived_eq(cx.tcx, adt.did(), eq_trait_def_id)
+        && let Some(local_def_id) = adt.did().as_local()
+        // If all of our fields implement `Eq`, we can implement `Eq` too
+        && adt
+            .all_fields()
+            .map(|f| f.ty(cx.tcx, args))
+            .all(|ty| implements_trait_with_env(cx.tcx, typing_env, ty, eq_trait_def_id, None, &[]))
+    {
+        span_lint_hir_and_then(
+            cx,
+            DERIVE_PARTIAL_EQ_WITHOUT_EQ,
+            cx.tcx.local_def_id_to_hir_id(local_def_id),
+            span.ctxt().outer_expn_data().call_site,
+            "you are deriving `PartialEq` and can implement `Eq`",
+            |diag| {
+                diag.span_suggestion(
+                    span.ctxt().outer_expn_data().call_site,
+                    "consider deriving `Eq` as well",
+                    "PartialEq, Eq",
+                    Applicability::MachineApplicable,
+                );
+            },
+        );
+    }
+}
+
+fn ty_implements_eq_trait<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, eq_trait_id: DefId) -> bool {
+    tcx.non_blanket_impls_for_ty(eq_trait_id, ty).next().is_some()
+}
+
+/// Creates the `ParamEnv` used for the given type's derived `Eq` impl.
+fn typing_env_for_derived_eq(tcx: TyCtxt<'_>, did: DefId, eq_trait_id: DefId) -> ty::TypingEnv<'_> {
+    // Initial map from generic index to param def.
+    // Vec<(param_def, needs_eq)>
+    let mut params = tcx
+        .generics_of(did)
+        .own_params
+        .iter()
+        .map(|p| (p, matches!(p.kind, GenericParamDefKind::Type { .. })))
+        .collect::<Vec<_>>();
+
+    let ty_predicates = tcx.predicates_of(did).predicates;
+    for (p, _) in ty_predicates {
+        if let ClauseKind::Trait(p) = p.kind().skip_binder()
+            && p.trait_ref.def_id == eq_trait_id
+            && let ty::Param(self_ty) = p.trait_ref.self_ty().kind()
+        {
+            // Flag types which already have an `Eq` bound.
+            params[self_ty.index as usize].1 = false;
+        }
+    }
+
+    let param_env = ParamEnv::new(tcx.mk_clauses_from_iter(ty_predicates.iter().map(|&(p, _)| p).chain(
+        params.iter().filter(|&&(_, needs_eq)| needs_eq).map(|&(param, _)| {
+            ClauseKind::Trait(TraitPredicate {
+                trait_ref: ty::TraitRef::new(tcx, eq_trait_id, [tcx.mk_param_from_def(param)]),
+                polarity: ty::PredicatePolarity::Positive,
+            })
+            .upcast(tcx)
+        }),
+    )));
+    ty::TypingEnv {
+        typing_mode: ty::TypingMode::non_body_analysis(),
+        param_env,
+    }
+}
diff --git a/clippy_lints/src/derive/derived_hash_with_manual_eq.rs b/clippy_lints/src/derive/derived_hash_with_manual_eq.rs
new file mode 100644
index 0000000000000..6f36a58025a2b
--- /dev/null
+++ b/clippy_lints/src/derive/derived_hash_with_manual_eq.rs
@@ -0,0 +1,49 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_middle::ty::Ty;
+use rustc_span::{Span, sym};
+
+use super::DERIVED_HASH_WITH_MANUAL_EQ;
+
+/// Implementation of the `DERIVED_HASH_WITH_MANUAL_EQ` lint.
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    span: Span,
+    trait_ref: &hir::TraitRef<'_>,
+    ty: Ty<'tcx>,
+    hash_is_automatically_derived: bool,
+) {
+    if let Some(peq_trait_def_id) = cx.tcx.lang_items().eq_trait()
+        && let Some(def_id) = trait_ref.trait_def_id()
+        && cx.tcx.is_diagnostic_item(sym::Hash, def_id)
+    {
+        // Look for the PartialEq implementations for `ty`
+        cx.tcx.for_each_relevant_impl(peq_trait_def_id, ty, |impl_id| {
+            let peq_is_automatically_derived = cx.tcx.is_automatically_derived(impl_id);
+
+            if !hash_is_automatically_derived || peq_is_automatically_derived {
+                return;
+            }
+
+            let trait_ref = cx.tcx.impl_trait_ref(impl_id).expect("must be a trait implementation");
+
+            // Only care about `impl PartialEq<Foo> for Foo`
+            // For `impl PartialEq<B> for A, input_types is [A, B]
+            if trait_ref.instantiate_identity().args.type_at(1) == ty {
+                span_lint_and_then(
+                    cx,
+                    DERIVED_HASH_WITH_MANUAL_EQ,
+                    span,
+                    "you are deriving `Hash` but have implemented `PartialEq` explicitly",
+                    |diag| {
+                        if let Some(local_def_id) = impl_id.as_local() {
+                            let hir_id = cx.tcx.local_def_id_to_hir_id(local_def_id);
+                            diag.span_note(cx.tcx.hir_span(hir_id), "`PartialEq` implemented here");
+                        }
+                    },
+                );
+            }
+        });
+    }
+}
diff --git a/clippy_lints/src/derive/expl_impl_clone_on_copy.rs b/clippy_lints/src/derive/expl_impl_clone_on_copy.rs
new file mode 100644
index 0000000000000..6b97b4bd6b4d3
--- /dev/null
+++ b/clippy_lints/src/derive/expl_impl_clone_on_copy.rs
@@ -0,0 +1,65 @@
+use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::ty::{implements_trait, is_copy};
+use rustc_hir::{self as hir, Item};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, GenericArgKind, Ty};
+
+use super::EXPL_IMPL_CLONE_ON_COPY;
+
+/// Implementation of the `EXPL_IMPL_CLONE_ON_COPY` lint.
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, item: &Item<'_>, trait_ref: &hir::TraitRef<'_>, ty: Ty<'tcx>) {
+    let clone_id = match cx.tcx.lang_items().clone_trait() {
+        Some(id) if trait_ref.trait_def_id() == Some(id) => id,
+        _ => return,
+    };
+    let Some(copy_id) = cx.tcx.lang_items().copy_trait() else {
+        return;
+    };
+    let (ty_adt, ty_subs) = match *ty.kind() {
+        // Unions can't derive clone.
+        ty::Adt(adt, subs) if !adt.is_union() => (adt, subs),
+        _ => return,
+    };
+    // If the current self type doesn't implement Copy (due to generic constraints), search to see if
+    // there's a Copy impl for any instance of the adt.
+    if !is_copy(cx, ty) {
+        if ty_subs.non_erasable_generics().next().is_some() {
+            let has_copy_impl = cx.tcx.local_trait_impls(copy_id).iter().any(|&id| {
+                matches!(cx.tcx.type_of(id).instantiate_identity().kind(), ty::Adt(adt, _)
+                                        if ty_adt.did() == adt.did())
+            });
+            if !has_copy_impl {
+                return;
+            }
+        } else {
+            return;
+        }
+    }
+    // Derive constrains all generic types to requiring Clone. Check if any type is not constrained for
+    // this impl.
+    if ty_subs.types().any(|ty| !implements_trait(cx, ty, clone_id, &[])) {
+        return;
+    }
+    // `#[repr(packed)]` structs with type/const parameters can't derive `Clone`.
+    // https://github.com/rust-lang/rust-clippy/issues/10188
+    if ty_adt.repr().packed()
+        && ty_subs
+            .iter()
+            .any(|arg| matches!(arg.kind(), GenericArgKind::Type(_) | GenericArgKind::Const(_)))
+    {
+        return;
+    }
+    // The presence of `unsafe` fields prevents deriving `Clone` automatically
+    if ty_adt.all_fields().any(|f| f.safety.is_unsafe()) {
+        return;
+    }
+
+    span_lint_and_note(
+        cx,
+        EXPL_IMPL_CLONE_ON_COPY,
+        item.span,
+        "you are implementing `Clone` explicitly on a `Copy` type",
+        Some(item.span),
+        "consider deriving `Clone` or removing `Copy`",
+    );
+}
diff --git a/clippy_lints/src/derive/mod.rs b/clippy_lints/src/derive/mod.rs
new file mode 100644
index 0000000000000..1d63394ce37d4
--- /dev/null
+++ b/clippy_lints/src/derive/mod.rs
@@ -0,0 +1,215 @@
+use rustc_hir::{Impl, Item, ItemKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::declare_lint_pass;
+
+mod derive_ord_xor_partial_ord;
+mod derive_partial_eq_without_eq;
+mod derived_hash_with_manual_eq;
+mod expl_impl_clone_on_copy;
+mod unsafe_derive_deserialize;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Lints against manual `PartialEq` implementations for types with a derived `Hash`
+    /// implementation.
+    ///
+    /// ### Why is this bad?
+    /// The implementation of these traits must agree (for
+    /// example for use with `HashMap`) so it’s probably a bad idea to use a
+    /// default-generated `Hash` implementation with an explicitly defined
+    /// `PartialEq`. In particular, the following must hold for any type:
+    ///
+    /// ```text
+    /// k1 == k2 ⇒ hash(k1) == hash(k2)
+    /// ```
+    ///
+    /// ### Example
+    /// ```ignore
+    /// #[derive(Hash)]
+    /// struct Foo;
+    ///
+    /// impl PartialEq for Foo {
+    ///     ...
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub DERIVED_HASH_WITH_MANUAL_EQ,
+    correctness,
+    "deriving `Hash` but implementing `PartialEq` explicitly"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Lints against manual `PartialOrd` and `Ord` implementations for types with a derived `Ord`
+    /// or `PartialOrd` implementation.
+    ///
+    /// ### Why is this bad?
+    /// The implementation of these traits must agree (for
+    /// example for use with `sort`) so it’s probably a bad idea to use a
+    /// default-generated `Ord` implementation with an explicitly defined
+    /// `PartialOrd`. In particular, the following must hold for any type
+    /// implementing `Ord`:
+    ///
+    /// ```text
+    /// k1.cmp(&k2) == k1.partial_cmp(&k2).unwrap()
+    /// ```
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// #[derive(Ord, PartialEq, Eq)]
+    /// struct Foo;
+    ///
+    /// impl PartialOrd for Foo {
+    ///     ...
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// #[derive(PartialEq, Eq)]
+    /// struct Foo;
+    ///
+    /// impl PartialOrd for Foo {
+    ///     fn partial_cmp(&self, other: &Foo) -> Option<Ordering> {
+    ///        Some(self.cmp(other))
+    ///     }
+    /// }
+    ///
+    /// impl Ord for Foo {
+    ///     ...
+    /// }
+    /// ```
+    /// or, if you don't need a custom ordering:
+    /// ```rust,ignore
+    /// #[derive(Ord, PartialOrd, PartialEq, Eq)]
+    /// struct Foo;
+    /// ```
+    #[clippy::version = "1.47.0"]
+    pub DERIVE_ORD_XOR_PARTIAL_ORD,
+    correctness,
+    "deriving `Ord` but implementing `PartialOrd` explicitly"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for explicit `Clone` implementations for `Copy`
+    /// types.
+    ///
+    /// ### Why is this bad?
+    /// To avoid surprising behavior, these traits should
+    /// agree and the behavior of `Copy` cannot be overridden. In almost all
+    /// situations a `Copy` type should have a `Clone` implementation that does
+    /// nothing more than copy the object, which is what `#[derive(Copy, Clone)]`
+    /// gets you.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// #[derive(Copy)]
+    /// struct Foo;
+    ///
+    /// impl Clone for Foo {
+    ///     // ..
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub EXPL_IMPL_CLONE_ON_COPY,
+    pedantic,
+    "implementing `Clone` explicitly on `Copy` types"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for deriving `serde::Deserialize` on a type that
+    /// has methods using `unsafe`.
+    ///
+    /// ### Why is this bad?
+    /// Deriving `serde::Deserialize` will create a constructor
+    /// that may violate invariants held by another constructor.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// use serde::Deserialize;
+    ///
+    /// #[derive(Deserialize)]
+    /// pub struct Foo {
+    ///     // ..
+    /// }
+    ///
+    /// impl Foo {
+    ///     pub fn new() -> Self {
+    ///         // setup here ..
+    ///     }
+    ///
+    ///     pub unsafe fn parts() -> (&str, &str) {
+    ///         // assumes invariants hold
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "1.45.0"]
+    pub UNSAFE_DERIVE_DESERIALIZE,
+    pedantic,
+    "deriving `serde::Deserialize` on a type that has methods using `unsafe`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for types that derive `PartialEq` and could implement `Eq`.
+    ///
+    /// ### Why is this bad?
+    /// If a type `T` derives `PartialEq` and all of its members implement `Eq`,
+    /// then `T` can always implement `Eq`. Implementing `Eq` allows `T` to be used
+    /// in APIs that require `Eq` types. It also allows structs containing `T` to derive
+    /// `Eq` themselves.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// #[derive(PartialEq)]
+    /// struct Foo {
+    ///     i_am_eq: i32,
+    ///     i_am_eq_too: Vec<String>,
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// #[derive(PartialEq, Eq)]
+    /// struct Foo {
+    ///     i_am_eq: i32,
+    ///     i_am_eq_too: Vec<String>,
+    /// }
+    /// ```
+    #[clippy::version = "1.63.0"]
+    pub DERIVE_PARTIAL_EQ_WITHOUT_EQ,
+    nursery,
+    "deriving `PartialEq` on a type that can implement `Eq`, without implementing `Eq`"
+}
+
+declare_lint_pass!(Derive => [
+    EXPL_IMPL_CLONE_ON_COPY,
+    DERIVED_HASH_WITH_MANUAL_EQ,
+    DERIVE_ORD_XOR_PARTIAL_ORD,
+    UNSAFE_DERIVE_DESERIALIZE,
+    DERIVE_PARTIAL_EQ_WITHOUT_EQ
+]);
+
+impl<'tcx> LateLintPass<'tcx> for Derive {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+        if let ItemKind::Impl(Impl {
+            of_trait: Some(of_trait),
+            ..
+        }) = item.kind
+        {
+            let trait_ref = &of_trait.trait_ref;
+            let ty = cx.tcx.type_of(item.owner_id).instantiate_identity();
+            let is_automatically_derived = cx.tcx.is_automatically_derived(item.owner_id.to_def_id());
+
+            derived_hash_with_manual_eq::check(cx, item.span, trait_ref, ty, is_automatically_derived);
+            derive_ord_xor_partial_ord::check(cx, item.span, trait_ref, ty, is_automatically_derived);
+
+            if is_automatically_derived {
+                unsafe_derive_deserialize::check(cx, item, trait_ref, ty);
+                derive_partial_eq_without_eq::check(cx, item.span, trait_ref, ty);
+            } else {
+                expl_impl_clone_on_copy::check(cx, item, trait_ref, ty);
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/derive/unsafe_derive_deserialize.rs b/clippy_lints/src/derive/unsafe_derive_deserialize.rs
new file mode 100644
index 0000000000000..c391e7b62289f
--- /dev/null
+++ b/clippy_lints/src/derive/unsafe_derive_deserialize.rs
@@ -0,0 +1,93 @@
+use std::ops::ControlFlow;
+
+use clippy_utils::diagnostics::span_lint_hir_and_then;
+use clippy_utils::{is_lint_allowed, paths};
+use rustc_hir::def_id::LocalDefId;
+use rustc_hir::intravisit::{FnKind, Visitor, walk_expr, walk_fn, walk_item};
+use rustc_hir::{self as hir, BlockCheckMode, BodyId, Expr, ExprKind, FnDecl, Item, UnsafeSource};
+use rustc_lint::LateContext;
+use rustc_middle::hir::nested_filter;
+use rustc_middle::ty::{self, Ty};
+use rustc_span::{Span, sym};
+
+use super::UNSAFE_DERIVE_DESERIALIZE;
+
+/// Implementation of the `UNSAFE_DERIVE_DESERIALIZE` lint.
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, item: &Item<'_>, trait_ref: &hir::TraitRef<'_>, ty: Ty<'tcx>) {
+    fn has_unsafe<'tcx>(cx: &LateContext<'tcx>, item: &'tcx Item<'_>) -> bool {
+        let mut visitor = UnsafeVisitor { cx };
+        walk_item(&mut visitor, item).is_break()
+    }
+
+    if let Some(trait_def_id) = trait_ref.trait_def_id()
+        && paths::SERDE_DESERIALIZE.matches(cx, trait_def_id)
+        && let ty::Adt(def, _) = ty.kind()
+        && let Some(local_def_id) = def.did().as_local()
+        && let adt_hir_id = cx.tcx.local_def_id_to_hir_id(local_def_id)
+        && !is_lint_allowed(cx, UNSAFE_DERIVE_DESERIALIZE, adt_hir_id)
+        && cx
+            .tcx
+            .inherent_impls(def.did())
+            .iter()
+            .map(|imp_did| cx.tcx.hir_expect_item(imp_did.expect_local()))
+            .any(|imp| has_unsafe(cx, imp))
+    {
+        span_lint_hir_and_then(
+            cx,
+            UNSAFE_DERIVE_DESERIALIZE,
+            adt_hir_id,
+            item.span,
+            "you are deriving `serde::Deserialize` on a type that has methods using `unsafe`",
+            |diag| {
+                diag.help(
+                    "consider implementing `serde::Deserialize` manually. See https://serde.rs/impl-deserialize.html",
+                );
+            },
+        );
+    }
+}
+
+struct UnsafeVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+}
+
+impl<'tcx> Visitor<'tcx> for UnsafeVisitor<'_, 'tcx> {
+    type Result = ControlFlow<()>;
+    type NestedFilter = nested_filter::All;
+
+    fn visit_fn(
+        &mut self,
+        kind: FnKind<'tcx>,
+        decl: &'tcx FnDecl<'_>,
+        body_id: BodyId,
+        _: Span,
+        id: LocalDefId,
+    ) -> Self::Result {
+        if let Some(header) = kind.header()
+            && header.is_unsafe()
+        {
+            ControlFlow::Break(())
+        } else {
+            walk_fn(self, kind, decl, body_id, id)
+        }
+    }
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) -> Self::Result {
+        if let ExprKind::Block(block, _) = expr.kind
+            && block.rules == BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided)
+            && block
+                .span
+                .source_callee()
+                .and_then(|expr| expr.macro_def_id)
+                .is_none_or(|did| !self.cx.tcx.is_diagnostic_item(sym::pin_macro, did))
+        {
+            return ControlFlow::Break(());
+        }
+
+        walk_expr(self, expr)
+    }
+
+    fn maybe_tcx(&mut self) -> Self::MaybeTyCtxt {
+        self.cx.tcx
+    }
+}
diff --git a/clippy_lints/src/disallowed_macros.rs b/clippy_lints/src/disallowed_macros.rs
index 49cd2671dc003..1c9c971730f6e 100644
--- a/clippy_lints/src/disallowed_macros.rs
+++ b/clippy_lints/src/disallowed_macros.rs
@@ -1,4 +1,3 @@
-
 use clippy_config::Conf;
 use clippy_config::types::{DisallowedPath, create_disallowed_map};
 use clippy_utils::diagnostics::{span_lint_and_then, span_lint_hir_and_then};
@@ -8,7 +7,8 @@ use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::DefIdMap;
 use rustc_hir::{
-    AmbigArg, Expr, ExprKind, ForeignItem, HirId, ImplItem, ImplItemImplKind, Item, ItemKind, OwnerId, Pat, Path, Stmt, TraitItem, Ty,
+    AmbigArg, Expr, ExprKind, ForeignItem, HirId, ImplItem, ImplItemImplKind, Item, ItemKind, OwnerId, Pat, Path, Stmt,
+    TraitItem, Ty,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::TyCtxt;
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 2da1c2bad1174..752f39b4e6dc1 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -197,6 +197,18 @@ fn check_closure<'tcx>(cx: &LateContext<'tcx>, outer_receiver: Option<&Expr<'tcx
                 // 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(_)))
+                // Rule out `AsyncFn*`s, because while they can be called as `|x| f(x)`,
+                // they can't be passed directly into a place expecting an `Fn*` (#13892)
+                && let Ok((closure_kind, _)) = cx
+                    .tcx
+                    .infer_ctxt()
+                    .build(cx.typing_mode())
+                    .err_ctxt()
+                    .type_implements_fn_trait(
+                        cx.param_env,
+                        Binder::bind_with_vars(callee_ty_adjusted, List::empty()),
+                        ty::PredicatePolarity::Positive,
+                    )
             {
                 span_lint_hir_and_then(
                     cx,
@@ -213,19 +225,10 @@ fn check_closure<'tcx>(cx: &LateContext<'tcx>, outer_receiver: Option<&Expr<'tcx
                                 // '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(cx.typing_mode())
-                                    .err_ctxt()
-                                    .type_implements_fn_trait(
-                                        cx.param_env,
-                                        Binder::bind_with_vars(callee_ty_adjusted, List::empty()),
-                                        ty::PredicatePolarity::Positive,
-                                    ) {
+                                match closure_kind {
                                     // 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() => {
+                                    ClosureKind::FnMut => snippet = format!("&mut {snippet}"),
+                                    ClosureKind::Fn if !callee_ty_raw.is_ref() => {
                                         snippet = format!("&{snippet}");
                                     },
                                     _ => (),
diff --git a/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs b/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
index 906bbd006d463..72f8795304055 100644
--- a/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
+++ b/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
@@ -4,7 +4,7 @@ use rustc_middle::ty;
 use rustc_span::def_id::LocalDefId;
 
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::ty::type_is_unsafe_function;
+use clippy_utils::ty::is_unsafe_fn;
 use clippy_utils::visitors::for_each_expr;
 use clippy_utils::{iter_input_pats, path_to_local};
 
@@ -51,7 +51,7 @@ fn check_raw_ptr<'tcx>(
             let typeck = cx.tcx.typeck_body(body.id());
             let _: Option<!> = for_each_expr(cx, body.value, |e| {
                 match e.kind {
-                    hir::ExprKind::Call(f, args) if type_is_unsafe_function(cx, typeck.expr_ty(f)) => {
+                    hir::ExprKind::Call(f, args) if is_unsafe_fn(cx, typeck.expr_ty(f)) => {
                         for arg in args {
                             check_arg(cx, &raw_ptrs, arg);
                         }
diff --git a/clippy_lints/src/functions/ref_option.rs b/clippy_lints/src/functions/ref_option.rs
index 106202d00d403..5dc1b7269b761 100644
--- a/clippy_lints/src/functions/ref_option.rs
+++ b/clippy_lints/src/functions/ref_option.rs
@@ -1,23 +1,20 @@
 use crate::functions::REF_OPTION;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::is_trait_impl_item;
 use clippy_utils::source::snippet;
-use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::ty::option_arg_ty;
+use clippy_utils::{is_from_proc_macro, is_trait_impl_item};
 use rustc_errors::Applicability;
-use rustc_hir as hir;
 use rustc_hir::intravisit::FnKind;
-use rustc_hir::{FnDecl, HirId};
-use rustc_lint::LateContext;
-use rustc_middle::ty::{self, GenericArgKind, Mutability, Ty};
+use rustc_hir::{self as hir, FnDecl, HirId};
+use rustc_lint::{LateContext, LintContext};
+use rustc_middle::ty::{self, Mutability, Ty};
+use rustc_span::Span;
 use rustc_span::def_id::LocalDefId;
-use rustc_span::{Span, sym};
 
-fn check_ty<'a>(cx: &LateContext<'a>, param: &rustc_hir::Ty<'a>, param_ty: Ty<'a>, fixes: &mut Vec<(Span, String)>) {
-    if let ty::Ref(_, opt_ty, Mutability::Not) = param_ty.kind()
-        && is_type_diagnostic_item(cx, *opt_ty, sym::Option)
-        && let ty::Adt(_, opt_gen_args) = opt_ty.kind()
-        && let [gen_arg] = opt_gen_args.as_slice()
-        && let GenericArgKind::Type(gen_ty) = gen_arg.kind()
+fn check_ty<'a>(cx: &LateContext<'a>, param: &hir::Ty<'a>, param_ty: Ty<'a>, fixes: &mut Vec<(Span, String)>) {
+    if !param.span.in_external_macro(cx.sess().source_map())
+        && let ty::Ref(_, opt_ty, Mutability::Not) = param_ty.kind()
+        && let Some(gen_ty) = option_arg_ty(cx, *opt_ty)
         && !gen_ty.is_ref()
         // Need to gen the original spans, so first parsing mid, and hir parsing afterward
         && let hir::TyKind::Ref(lifetime, hir::MutTy { ty, .. }) = param.kind
@@ -27,6 +24,7 @@ fn check_ty<'a>(cx: &LateContext<'a>, param: &rustc_hir::Ty<'a>, param_ty: Ty<'a
             args: [hir::GenericArg::Type(opt_ty)],
             ..
         }) = last.args
+        && !is_from_proc_macro(cx, param)
     {
         let lifetime = snippet(cx, lifetime.ident.span, "..");
         fixes.push((
@@ -67,21 +65,24 @@ fn check_fn_sig<'a>(cx: &LateContext<'a>, decl: &FnDecl<'a>, span: Span, sig: ty
 #[allow(clippy::too_many_arguments)]
 pub(crate) fn check_fn<'a>(
     cx: &LateContext<'a>,
-    kind: FnKind<'_>,
+    kind: FnKind<'a>,
     decl: &FnDecl<'a>,
     span: Span,
     hir_id: HirId,
     def_id: LocalDefId,
-    body: &hir::Body<'_>,
+    body: &hir::Body<'a>,
     avoid_breaking_exported_api: bool,
 ) {
     if avoid_breaking_exported_api && cx.effective_visibilities.is_exported(def_id) {
         return;
     }
+    if span.in_external_macro(cx.sess().source_map()) {
+        return;
+    }
 
     if let FnKind::Closure = kind {
         // Compute the span of the closure parameters + return type if set
-        let span = if let hir::FnRetTy::Return(out_ty) = &decl.output {
+        let inputs_output_span = if let hir::FnRetTy::Return(out_ty) = &decl.output {
             if decl.inputs.is_empty() {
                 out_ty.span
             } else {
@@ -100,9 +101,18 @@ pub(crate) fn check_fn<'a>(
         };
         let sig = args.as_closure().sig().skip_binder();
 
-        check_fn_sig(cx, decl, span, sig);
+        if is_from_proc_macro(cx, &(&kind, body, hir_id, span)) {
+            return;
+        }
+
+        check_fn_sig(cx, decl, inputs_output_span, sig);
     } else if !is_trait_impl_item(cx, hir_id) {
         let sig = cx.tcx.fn_sig(def_id).instantiate_identity().skip_binder();
+
+        if is_from_proc_macro(cx, &(&kind, body, hir_id, span)) {
+            return;
+        }
+
         check_fn_sig(cx, decl, span, sig);
     }
 }
@@ -112,8 +122,10 @@ pub(super) fn check_trait_item<'a>(
     trait_item: &hir::TraitItem<'a>,
     avoid_breaking_exported_api: bool,
 ) {
-    if let hir::TraitItemKind::Fn(ref sig, _) = trait_item.kind
+    if !trait_item.span.in_external_macro(cx.sess().source_map())
+        && let hir::TraitItemKind::Fn(ref sig, _) = trait_item.kind
         && !(avoid_breaking_exported_api && cx.effective_visibilities.is_exported(trait_item.owner_id.def_id))
+        && !is_from_proc_macro(cx, trait_item)
     {
         let def_id = trait_item.owner_id.def_id;
         let ty_sig = cx.tcx.fn_sig(def_id).instantiate_identity().skip_binder();
diff --git a/clippy_lints/src/future_not_send.rs b/clippy_lints/src/future_not_send.rs
index 3ccfa51ab70b7..596047977a9b1 100644
--- a/clippy_lints/src/future_not_send.rs
+++ b/clippy_lints/src/future_not_send.rs
@@ -78,66 +78,65 @@ impl<'tcx> LateLintPass<'tcx> for FutureNotSend {
         if let ty::Alias(ty::Opaque, AliasTy { def_id, args, .. }) = *ret_ty.kind()
             && let Some(future_trait) = cx.tcx.lang_items().future_trait()
             && let Some(send_trait) = cx.tcx.get_diagnostic_item(sym::Send)
+            && let preds = cx.tcx.explicit_item_self_bounds(def_id)
+            // If is a Future
+            && preds
+                .iter_instantiated_copied(cx.tcx, args)
+                .filter_map(|(p, _)| p.as_trait_clause())
+                .any(|trait_pred| trait_pred.skip_binder().trait_ref.def_id == future_trait)
         {
-            let preds = cx.tcx.explicit_item_self_bounds(def_id);
-            let is_future = preds.iter_instantiated_copied(cx.tcx, args).any(|(p, _)| {
-                p.as_trait_clause()
-                    .is_some_and(|trait_pred| trait_pred.skip_binder().trait_ref.def_id == future_trait)
-            });
-            if is_future {
-                let span = decl.output.span();
-                let infcx = cx.tcx.infer_ctxt().build(cx.typing_mode());
-                let ocx = ObligationCtxt::new_with_diagnostics(&infcx);
-                let cause = traits::ObligationCause::misc(span, fn_def_id);
-                ocx.register_bound(cause, cx.param_env, ret_ty, send_trait);
-                let send_errors = ocx.select_all_or_error();
+            let span = decl.output.span();
+            let infcx = cx.tcx.infer_ctxt().build(cx.typing_mode());
+            let ocx = ObligationCtxt::new_with_diagnostics(&infcx);
+            let cause = traits::ObligationCause::misc(span, fn_def_id);
+            ocx.register_bound(cause, cx.param_env, ret_ty, send_trait);
+            let send_errors = ocx.select_all_or_error();
 
-                // Allow errors that try to prove `Send` for types that "mention" a generic parameter at the "top
-                // level".
-                // For example, allow errors that `T: Send` can't be proven, but reject `Rc<T>: Send` errors,
-                // which is always unconditionally `!Send` for any possible type `T`.
-                //
-                // We also allow associated type projections if the self type is either itself a projection or a
-                // type parameter.
-                // This is to prevent emitting warnings for e.g. holding a `<Fut as Future>::Output` across await
-                // points, where `Fut` is a type parameter.
+            // Allow errors that try to prove `Send` for types that "mention" a generic parameter at the "top
+            // level".
+            // For example, allow errors that `T: Send` can't be proven, but reject `Rc<T>: Send` errors,
+            // which is always unconditionally `!Send` for any possible type `T`.
+            //
+            // We also allow associated type projections if the self type is either itself a projection or a
+            // type parameter.
+            // This is to prevent emitting warnings for e.g. holding a `<Fut as Future>::Output` across await
+            // points, where `Fut` is a type parameter.
 
-                let is_send = send_errors.iter().all(|err| {
-                    err.obligation
-                        .predicate
-                        .as_trait_clause()
-                        .map(Binder::skip_binder)
-                        .is_some_and(|pred| {
-                            pred.def_id() == send_trait
-                                && pred.self_ty().has_param()
-                                && TyParamAtTopLevelVisitor.visit_ty(pred.self_ty()) == ControlFlow::Break(true)
-                        })
-                });
+            let is_send = send_errors.iter().all(|err| {
+                err.obligation
+                    .predicate
+                    .as_trait_clause()
+                    .map(Binder::skip_binder)
+                    .is_some_and(|pred| {
+                        pred.def_id() == send_trait
+                            && pred.self_ty().has_param()
+                            && TyParamAtTopLevelVisitor.visit_ty(pred.self_ty()) == ControlFlow::Break(true)
+                    })
+            });
 
-                if !is_send {
-                    span_lint_and_then(
-                        cx,
-                        FUTURE_NOT_SEND,
-                        span,
-                        "future cannot be sent between threads safely",
-                        |db| {
-                            for FulfillmentError { obligation, .. } in send_errors {
-                                infcx
-                                    .err_ctxt()
-                                    .maybe_note_obligation_cause_for_async_await(db, &obligation);
-                                if let PredicateKind::Clause(ClauseKind::Trait(trait_pred)) =
-                                    obligation.predicate.kind().skip_binder()
-                                {
-                                    db.note(format!(
-                                        "`{}` doesn't implement `{}`",
-                                        trait_pred.self_ty(),
-                                        trait_pred.trait_ref.print_only_trait_path(),
-                                    ));
-                                }
+            if !is_send {
+                span_lint_and_then(
+                    cx,
+                    FUTURE_NOT_SEND,
+                    span,
+                    "future cannot be sent between threads safely",
+                    |db| {
+                        for FulfillmentError { obligation, .. } in send_errors {
+                            infcx
+                                .err_ctxt()
+                                .maybe_note_obligation_cause_for_async_await(db, &obligation);
+                            if let PredicateKind::Clause(ClauseKind::Trait(trait_pred)) =
+                                obligation.predicate.kind().skip_binder()
+                            {
+                                db.note(format!(
+                                    "`{}` doesn't implement `{}`",
+                                    trait_pred.self_ty(),
+                                    trait_pred.trait_ref.print_only_trait_path(),
+                                ));
                             }
-                        },
-                    );
-                }
+                        }
+                    },
+                );
             }
         }
     }
diff --git a/clippy_lints/src/invalid_upcast_comparisons.rs b/clippy_lints/src/invalid_upcast_comparisons.rs
index b0ecc5d52ddb8..1666e8e5ae324 100644
--- a/clippy_lints/src/invalid_upcast_comparisons.rs
+++ b/clippy_lints/src/invalid_upcast_comparisons.rs
@@ -1,3 +1,4 @@
+use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::layout::LayoutOf;
@@ -9,7 +10,7 @@ use clippy_utils::comparisons;
 use clippy_utils::comparisons::Rel;
 use clippy_utils::consts::{ConstEvalCtxt, FullInt};
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::source::snippet;
+use clippy_utils::source::snippet_with_context;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -69,13 +70,21 @@ fn numeric_cast_precast_bounds(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<
 
 fn err_upcast_comparison(cx: &LateContext<'_>, span: Span, expr: &Expr<'_>, always: bool) {
     if let ExprKind::Cast(cast_val, _) = expr.kind {
+        let mut applicability = Applicability::MachineApplicable;
+        let (cast_val_snip, _) = snippet_with_context(
+            cx,
+            cast_val.span,
+            expr.span.ctxt(),
+            "the expression",
+            &mut applicability,
+        );
         span_lint(
             cx,
             INVALID_UPCAST_COMPARISONS,
             span,
             format!(
                 "because of the numeric bounds on `{}` prior to casting, this expression is always {}",
-                snippet(cx, cast_val.span, "the expression"),
+                cast_val_snip,
                 if always { "true" } else { "false" },
             ),
         );
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index f44a5fdf715e5..28a0fbc051158 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -371,9 +371,9 @@ fn parse_len_output<'tcx>(cx: &LateContext<'tcx>, sig: FnSig<'tcx>) -> Option<Le
 
     match *sig.output().kind() {
         ty::Int(_) | ty::Uint(_) => Some(LenOutput::Integral),
-        ty::Adt(adt, subs) if subs.type_at(0).is_integral() => match cx.tcx.get_diagnostic_name(adt.did()) {
-            Some(sym::Option) => Some(LenOutput::Option(adt.did())),
-            Some(sym::Result) => Some(LenOutput::Result(adt.did())),
+        ty::Adt(adt, subs) => match cx.tcx.get_diagnostic_name(adt.did()) {
+            Some(sym::Option) => subs.type_at(0).is_integral().then(|| LenOutput::Option(adt.did())),
+            Some(sym::Result) => subs.type_at(0).is_integral().then(|| LenOutput::Result(adt.did())),
             _ => None,
         },
         _ => None,
diff --git a/clippy_lints/src/let_with_type_underscore.rs b/clippy_lints/src/let_with_type_underscore.rs
index 5b0f95ffc377f..24a4c321bdabd 100644
--- a/clippy_lints/src/let_with_type_underscore.rs
+++ b/clippy_lints/src/let_with_type_underscore.rs
@@ -1,9 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_from_proc_macro;
 use clippy_utils::source::{IntoSpan, SpanRangeExt};
+use rustc_ast::{Local, TyKind};
 use rustc_errors::Applicability;
-use rustc_hir::{LetStmt, TyKind};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
@@ -26,14 +26,14 @@ declare_clippy_lint! {
 }
 declare_lint_pass!(UnderscoreTyped => [LET_WITH_TYPE_UNDERSCORE]);
 
-impl<'tcx> LateLintPass<'tcx> for UnderscoreTyped {
-    fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx LetStmt<'_>) {
-        if let Some(ty) = local.ty // Ensure that it has a type defined
-            && let TyKind::Infer(()) = &ty.kind // that type is '_'
+impl EarlyLintPass for UnderscoreTyped {
+    fn check_local(&mut self, cx: &EarlyContext<'_>, local: &Local) {
+        if let Some(ty) = &local.ty // Ensure that it has a type defined
+            && let TyKind::Infer = ty.kind // that type is '_'
             && local.span.eq_ctxt(ty.span)
-            && let sm = cx.tcx.sess.source_map()
+            && let sm = cx.sess().source_map()
             && !local.span.in_external_macro(sm)
-            && !is_from_proc_macro(cx, ty)
+            && !is_from_proc_macro(cx, &**ty)
         {
             let span_to_remove = sm
                 .span_extend_to_prev_char_before(ty.span, ':', true)
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index a89cf3fdc1eee..c56fa257b0689 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -302,7 +302,6 @@ mod permissions_set_readonly_false;
 mod pointers_in_nomem_asm_block;
 mod precedence;
 mod ptr;
-mod ptr_offset_with_cast;
 mod pub_underscore_fields;
 mod pub_use;
 mod question_mark;
@@ -360,6 +359,7 @@ mod temporary_assignment;
 mod tests_outside_test_module;
 mod to_digit_is_some;
 mod to_string_trait_impl;
+mod toplevel_ref_arg;
 mod trailing_empty_array;
 mod trait_bounds;
 mod transmute;
@@ -592,7 +592,6 @@ pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Co
     store.register_late_pass(|_| Box::new(unwrap::Unwrap));
     store.register_late_pass(move |_| Box::new(indexing_slicing::IndexingSlicing::new(conf)));
     store.register_late_pass(move |tcx| Box::new(non_copy_const::NonCopyConst::new(tcx, conf)));
-    store.register_late_pass(|_| Box::new(ptr_offset_with_cast::PtrOffsetWithCast));
     store.register_late_pass(|_| Box::new(redundant_clone::RedundantClone));
     store.register_late_pass(|_| Box::new(slow_vector_initialization::SlowVectorInit));
     store.register_late_pass(move |_| Box::new(unnecessary_wraps::UnnecessaryWraps::new(conf)));
@@ -744,7 +743,7 @@ pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Co
     store.register_late_pass(|_| Box::new(missing_assert_message::MissingAssertMessage));
     store.register_late_pass(|_| Box::new(needless_maybe_sized::NeedlessMaybeSized));
     store.register_late_pass(|_| Box::new(redundant_async_block::RedundantAsyncBlock));
-    store.register_late_pass(|_| Box::new(let_with_type_underscore::UnderscoreTyped));
+    store.register_early_pass(|| Box::new(let_with_type_underscore::UnderscoreTyped));
     store.register_late_pass(move |_| Box::new(manual_main_separator_str::ManualMainSeparatorStr::new(conf)));
     store.register_late_pass(|_| Box::new(unnecessary_struct_initialization::UnnecessaryStruct));
     store.register_late_pass(move |_| Box::new(unnecessary_box_returns::UnnecessaryBoxReturns::new(conf)));
@@ -831,5 +830,6 @@ pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Co
     store.register_late_pass(|_| Box::new(cloned_ref_to_slice_refs::ClonedRefToSliceRefs::new(conf)));
     store.register_late_pass(|_| Box::new(infallible_try_from::InfallibleTryFrom));
     store.register_late_pass(|_| Box::new(coerce_container_to_any::CoerceContainerToAny));
+    store.register_late_pass(|_| Box::new(toplevel_ref_arg::ToplevelRefArg));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 149ae5e710c1f..d8b186b6787d1 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -745,7 +745,7 @@ fn report_elidable_impl_lifetimes<'tcx>(
     impl_: &'tcx Impl<'_>,
     map: &FxIndexMap<LocalDefId, Vec<Usage>>,
 ) {
-    let single_usages = map
+    let (elidable_lts, usages): (Vec<_>, Vec<_>) = map
         .iter()
         .filter_map(|(def_id, usages)| {
             if let [
@@ -762,14 +762,12 @@ fn report_elidable_impl_lifetimes<'tcx>(
                 None
             }
         })
-        .collect::<Vec<_>>();
+        .unzip();
 
-    if single_usages.is_empty() {
+    if elidable_lts.is_empty() {
         return;
     }
 
-    let (elidable_lts, usages): (Vec<_>, Vec<_>) = single_usages.into_iter().unzip();
-
     report_elidable_lifetimes(cx, impl_.generics, &elidable_lts, &usages, true);
 }
 
@@ -795,9 +793,7 @@ fn report_elidable_lifetimes(
         // In principle, the result of the call to `Node::ident` could be `unwrap`ped, as `DefId` should refer to a
         // `Node::GenericParam`.
         .filter_map(|&def_id| cx.tcx.hir_node_by_def_id(def_id).ident())
-        .map(|ident| ident.to_string())
-        .collect::<Vec<_>>()
-        .join(", ");
+        .format(", ");
 
     let elidable_usages: Vec<ElidableUsage> = usages
         .iter()
@@ -860,36 +856,89 @@ fn elision_suggestions(
         .filter(|param| !param.is_elided_lifetime() && !param.is_impl_trait())
         .collect::<Vec<_>>();
 
-    let mut suggestions = if elidable_lts.len() == explicit_params.len() {
+    if !elidable_lts
+        .iter()
+        .all(|lt| explicit_params.iter().any(|param| param.def_id == *lt))
+    {
+        return None;
+    }
+
+    let mut suggestions = if elidable_lts.is_empty() {
+        vec![]
+    } else if elidable_lts.len() == explicit_params.len() {
         // if all the params are elided remove the whole generic block
         //
         // fn x<'a>() {}
         //     ^^^^
         vec![(generics.span, String::new())]
     } else {
-        elidable_lts
-            .iter()
-            .map(|&id| {
-                let pos = explicit_params.iter().position(|param| param.def_id == id)?;
-                let param = explicit_params.get(pos)?;
-
-                let span = if let Some(next) = explicit_params.get(pos + 1) {
-                    // fn x<'prev, 'a, 'next>() {}
-                    //             ^^^^
-                    param.span.until(next.span)
+        match &explicit_params[..] {
+            // no params, nothing to elide
+            [] => unreachable!("handled by `elidable_lts.is_empty()`"),
+            [param] => {
+                if elidable_lts.contains(&param.def_id) {
+                    unreachable!("handled by `elidable_lts.len() == explicit_params.len()`")
                 } else {
-                    // `pos` should be at least 1 here, because the param in position 0 would either have a `next`
-                    // param or would have taken the `elidable_lts.len() == explicit_params.len()` branch.
-                    let prev = explicit_params.get(pos - 1)?;
-
-                    // fn x<'prev, 'a>() {}
-                    //           ^^^^
-                    param.span.with_lo(prev.span.hi())
+                    unreachable!("handled by `elidable_lts.is_empty()`")
+                }
+            },
+            [_, _, ..] => {
+                // Given a list like `<'a, 'b, 'c, 'd, ..>`,
+                //
+                // If there is a cluster of elidable lifetimes at the beginning, say `'a` and `'b`, we should
+                // suggest removing them _and_ the trailing comma. The span for that is `a.span.until(c.span)`:
+                // <'a, 'b, 'c, 'd, ..> => <'a, 'b, 'c, 'd, ..>
+                //  ^^  ^^                  ^^^^^^^^
+                //
+                // And since we know that `'c` isn't elidable--otherwise it would've been in the cluster--we can go
+                // over all the lifetimes after it, and for each elidable one, add a suggestion spanning the
+                // lifetime itself and the comma before, because each individual suggestion is guaranteed to leave
+                // the list valid:
+                // <.., 'c, 'd, 'e, 'f, 'g, ..> => <.., 'c, 'd, 'e, 'f, 'g, ..>
+                //          ^^      ^^  ^^                ^^^^    ^^^^^^^^
+                //
+                // In case there is no such starting cluster, we only need to do the second part of the algorithm:
+                // <'a, 'b, 'c, 'd, 'e, 'f, 'g, ..> => <'a, 'b , 'c, 'd, 'e, 'f, 'g, ..>
+                //      ^^  ^^      ^^  ^^                ^^^^^^^^^    ^^^^^^^^
+
+                // Split off the starting cluster
+                // TODO: use `slice::split_once` once stabilized (github.com/rust-lang/rust/issues/112811):
+                // ```
+                // let Some(split) = explicit_params.split_once(|param| !elidable_lts.contains(&param.def_id)) else {
+                //     // there were no lifetime param that couldn't be elided
+                //     unreachable!("handled by `elidable_lts.len() == explicit_params.len()`")
+                // };
+                // match split { /* .. */ }
+                // ```
+                let Some(split_pos) = explicit_params
+                    .iter()
+                    .position(|param| !elidable_lts.contains(&param.def_id))
+                else {
+                    // there were no lifetime param that couldn't be elided
+                    unreachable!("handled by `elidable_lts.len() == explicit_params.len()`")
                 };
-
-                Some((span, String::new()))
-            })
-            .collect::<Option<Vec<_>>>()?
+                let split = explicit_params
+                    .split_at_checked(split_pos)
+                    .expect("got `split_pos` from `position` on the same Vec");
+
+                match split {
+                    ([..], []) => unreachable!("handled by `elidable_lts.len() == explicit_params.len()`"),
+                    ([], [_]) => unreachable!("handled by `explicit_params.len() == 1`"),
+                    (cluster, rest @ [rest_first, ..]) => {
+                        // the span for the cluster
+                        (cluster.first().map(|fw| fw.span.until(rest_first.span)).into_iter())
+                            // the span for the remaining lifetimes (calculations independent of the cluster)
+                            .chain(
+                                rest.array_windows()
+                                    .filter(|[_, curr]| elidable_lts.contains(&curr.def_id))
+                                    .map(|[prev, curr]| curr.span.with_lo(prev.span.hi())),
+                            )
+                            .map(|sp| (sp, String::new()))
+                            .collect()
+                    },
+                }
+            },
+        }
     };
 
     suggestions.extend(usages.iter().map(|&usage| {
diff --git a/clippy_lints/src/loops/explicit_iter_loop.rs b/clippy_lints/src/loops/explicit_iter_loop.rs
index 6ce7f0b1f0bc9..af475c40586fe 100644
--- a/clippy_lints/src/loops/explicit_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_iter_loop.rs
@@ -138,9 +138,9 @@ fn is_ref_iterable<'tcx>(
             return Some((AdjustKind::None, self_ty));
         }
 
-        let res_ty = cx
-            .tcx
-            .erase_and_anonymize_regions(EarlyBinder::bind(req_res_ty).instantiate(cx.tcx, typeck.node_args(call_expr.hir_id)));
+        let res_ty = cx.tcx.erase_and_anonymize_regions(
+            EarlyBinder::bind(req_res_ty).instantiate(cx.tcx, typeck.node_args(call_expr.hir_id)),
+        );
         let mutbl = if let ty::Ref(_, _, mutbl) = *req_self_ty.kind() {
             Some(mutbl)
         } else {
diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index 2ccff76809767..544c3c34d029c 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -22,7 +22,10 @@ pub(super) fn check<'tcx>(
     for_loop: Option<&ForLoop<'_>>,
 ) {
     match never_loop_block(cx, block, &mut Vec::new(), loop_id) {
-        NeverLoopResult::Diverging { ref break_spans } => {
+        NeverLoopResult::Diverging {
+            ref break_spans,
+            ref never_spans,
+        } => {
             span_lint_and_then(cx, NEVER_LOOP, span, "this loop never actually loops", |diag| {
                 if let Some(ForLoop {
                     arg: iterator,
@@ -34,12 +37,16 @@ pub(super) fn check<'tcx>(
                 {
                     // If the block contains a break or continue, or if the loop has a label, `MachineApplicable` is not
                     // appropriate.
-                    let app = if !contains_any_break_or_continue(block) && label.is_none() {
+                    let mut app = if !contains_any_break_or_continue(block) && label.is_none() {
                         Applicability::MachineApplicable
                     } else {
                         Applicability::Unspecified
                     };
 
+                    if !never_spans.is_empty() {
+                        app = Applicability::HasPlaceholders;
+                    }
+
                     let mut suggestions = vec![(
                         for_span.with_hi(iterator.span.hi()),
                         for_to_if_let_sugg(cx, iterator, pat),
@@ -51,6 +58,13 @@ pub(super) fn check<'tcx>(
                         suggestions,
                         app,
                     );
+
+                    for span in never_spans {
+                        diag.span_help(
+                            *span,
+                            "this code is unreachable. Consider moving the reachable parts out",
+                        );
+                    }
                 }
             });
         },
@@ -77,13 +91,16 @@ fn contains_any_break_or_continue(block: &Block<'_>) -> bool {
 /// The first two bits of information are in this enum, and the last part is in the
 /// `local_labels` variable, which contains a list of `(block_id, reachable)` pairs ordered by
 /// scope.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 enum NeverLoopResult {
     /// A continue may occur for the main loop.
     MayContinueMainLoop,
     /// We have not encountered any main loop continue,
     /// but we are diverging (subsequent control flow is not reachable)
-    Diverging { break_spans: Vec<Span> },
+    Diverging {
+        break_spans: Vec<Span>,
+        never_spans: Vec<Span>,
+    },
     /// We have not encountered any main loop continue,
     /// and subsequent control flow is (possibly) reachable
     Normal,
@@ -128,14 +145,18 @@ fn combine_branches(b1: NeverLoopResult, b2: NeverLoopResult) -> NeverLoopResult
         (
             NeverLoopResult::Diverging {
                 break_spans: mut break_spans1,
+                never_spans: mut never_spans1,
             },
             NeverLoopResult::Diverging {
                 break_spans: mut break_spans2,
+                never_spans: mut never_spans2,
             },
         ) => {
             break_spans1.append(&mut break_spans2);
+            never_spans1.append(&mut never_spans2);
             NeverLoopResult::Diverging {
                 break_spans: break_spans1,
+                never_spans: never_spans1,
             }
         },
     }
@@ -207,6 +228,8 @@ fn all_spans_after_expr(cx: &LateContext<'_>, expr: &Expr<'_>) -> Vec<Span> {
         }
 
         return vec![stmt.span];
+    } else if let Node::Block(_) = cx.tcx.parent_hir_node(expr.hir_id) {
+        return vec![expr.span];
     }
 
     vec![]
@@ -270,10 +293,13 @@ fn never_loop_expr<'tcx>(
         ExprKind::Match(e, arms, _) => {
             let e = never_loop_expr(cx, e, local_labels, main_loop_id);
             combine_seq(e, || {
-                arms.iter()
-                    .fold(NeverLoopResult::Diverging { break_spans: vec![] }, |a, b| {
-                        combine_branches(a, never_loop_expr(cx, b.body, local_labels, main_loop_id))
-                    })
+                arms.iter().fold(
+                    NeverLoopResult::Diverging {
+                        break_spans: vec![],
+                        never_spans: vec![],
+                    },
+                    |a, b| combine_branches(a, never_loop_expr(cx, b.body, local_labels, main_loop_id)),
+                )
             })
         },
         ExprKind::Block(b, _) => {
@@ -296,6 +322,7 @@ fn never_loop_expr<'tcx>(
             } else {
                 NeverLoopResult::Diverging {
                     break_spans: all_spans_after_expr(cx, expr),
+                    never_spans: vec![],
                 }
             }
         },
@@ -306,7 +333,10 @@ fn never_loop_expr<'tcx>(
             combine_seq(first, || {
                 // checks if break targets a block instead of a loop
                 mark_block_as_reachable(expr, local_labels);
-                NeverLoopResult::Diverging { break_spans: vec![] }
+                NeverLoopResult::Diverging {
+                    break_spans: vec![],
+                    never_spans: vec![],
+                }
             })
         },
         ExprKind::Break(dest, e) => {
@@ -322,11 +352,15 @@ fn never_loop_expr<'tcx>(
                     } else {
                         all_spans_after_expr(cx, expr)
                     },
+                    never_spans: vec![],
                 }
             })
         },
         ExprKind::Become(e) => combine_seq(never_loop_expr(cx, e, local_labels, main_loop_id), || {
-            NeverLoopResult::Diverging { break_spans: vec![] }
+            NeverLoopResult::Diverging {
+                break_spans: vec![],
+                never_spans: vec![],
+            }
         }),
         ExprKind::InlineAsm(asm) => combine_seq_many(asm.operands.iter().map(|(o, _)| match o {
             InlineAsmOperand::In { expr, .. } | InlineAsmOperand::InOut { expr, .. } => {
@@ -356,7 +390,10 @@ fn never_loop_expr<'tcx>(
     };
     let result = combine_seq(result, || {
         if cx.typeck_results().expr_ty(expr).is_never() {
-            NeverLoopResult::Diverging { break_spans: vec![] }
+            NeverLoopResult::Diverging {
+                break_spans: vec![],
+                never_spans: all_spans_after_expr(cx, expr),
+            }
         } else {
             NeverLoopResult::Normal
         }
diff --git a/clippy_lints/src/manual_abs_diff.rs b/clippy_lints/src/manual_abs_diff.rs
index 288f27db8ca2c..5814b6815a1ea 100644
--- a/clippy_lints/src/manual_abs_diff.rs
+++ b/clippy_lints/src/manual_abs_diff.rs
@@ -4,8 +4,8 @@ use clippy_utils::higher::If;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::HasSession as _;
 use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{eq_expr_value, peel_blocks, peel_middle_ty_refs, span_contains_comment};
+use clippy_utils::ty::{is_type_diagnostic_item, peel_and_count_ty_refs};
+use clippy_utils::{eq_expr_value, peel_blocks, span_contains_comment};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -107,7 +107,7 @@ impl ManualAbsDiff {
             |ty| is_type_diagnostic_item(cx, ty, sym::Duration) && self.msrv.meets(cx, msrvs::DURATION_ABS_DIFF);
 
         let a_ty = cx.typeck_results().expr_ty(a).peel_refs();
-        let (b_ty, b_n_refs) = peel_middle_ty_refs(cx.typeck_results().expr_ty(b));
+        let (b_ty, b_n_refs, _) = peel_and_count_ty_refs(cx.typeck_results().expr_ty(b));
 
         (a_ty == b_ty && (is_int(a_ty) || is_duration(a_ty))).then_some((a_ty, b_n_refs))
     }
diff --git a/clippy_lints/src/manual_option_as_slice.rs b/clippy_lints/src/manual_option_as_slice.rs
index 922db174e3d49..b036e78cdedc5 100644
--- a/clippy_lints/src/manual_option_as_slice.rs
+++ b/clippy_lints/src/manual_option_as_slice.rs
@@ -1,7 +1,7 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
 use clippy_utils::msrvs::Msrv;
-use clippy_utils::{is_none_arm, msrvs, peel_hir_expr_refs, sym};
+use clippy_utils::{is_none_pattern, msrvs, peel_hir_expr_refs, sym};
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Arm, Expr, ExprKind, LangItem, Pat, PatKind, QPath, is_range_literal};
@@ -60,8 +60,8 @@ impl LateLintPass<'_> for ManualOptionAsSlice {
         }
         match expr.kind {
             ExprKind::Match(scrutinee, [arm1, arm2], _) => {
-                if is_none_arm(cx, arm2) && check_arms(cx, arm2, arm1)
-                    || is_none_arm(cx, arm1) && check_arms(cx, arm1, arm2)
+                if is_none_pattern(cx, arm2.pat) && check_arms(cx, arm2, arm1)
+                    || is_none_pattern(cx, arm1.pat) && check_arms(cx, arm1, arm2)
                 {
                     check_as_ref(cx, scrutinee, span, self.msrv);
                 }
diff --git a/clippy_lints/src/manual_slice_size_calculation.rs b/clippy_lints/src/manual_slice_size_calculation.rs
index 0c09a47c96518..de12fa29d02cd 100644
--- a/clippy_lints/src/manual_slice_size_calculation.rs
+++ b/clippy_lints/src/manual_slice_size_calculation.rs
@@ -2,6 +2,7 @@ use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_context;
+use clippy_utils::ty::peel_and_count_ty_refs;
 use clippy_utils::{expr_or_init, is_in_const_context, std_or_core};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
@@ -102,7 +103,7 @@ fn simplify_half<'tcx>(
         && let ExprKind::MethodCall(method_path, receiver, [], _) = expr1.kind
         && method_path.ident.name == sym::len
         && let receiver_ty = cx.typeck_results().expr_ty(receiver)
-        && let (receiver_ty, refs_count) = clippy_utils::ty::walk_ptrs_ty_depth(receiver_ty)
+        && let (receiver_ty, refs_count, _) = peel_and_count_ty_refs(receiver_ty)
         && let ty::Slice(ty1) = receiver_ty.kind()
         // expr2 is `size_of::<T2>()`?
         && let ExprKind::Call(func, []) = expr2.kind
diff --git a/clippy_lints/src/matches/manual_ok_err.rs b/clippy_lints/src/matches/manual_ok_err.rs
index edbb556fd9766..a8490d6aa7d82 100644
--- a/clippy_lints/src/matches/manual_ok_err.rs
+++ b/clippy_lints/src/matches/manual_ok_err.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{indent_of, reindent_multiline};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::{option_arg_ty, peel_mid_ty_refs_is_mutable};
+use clippy_utils::ty::{option_arg_ty, peel_and_count_ty_refs};
 use clippy_utils::{get_parent_expr, is_res_lang_ctor, path_res, peel_blocks, span_contains_comment};
 use rustc_ast::{BindingMode, Mutability};
 use rustc_errors::Applicability;
@@ -135,15 +135,11 @@ fn apply_lint(cx: &LateContext<'_>, expr: &Expr<'_>, scrutinee: &Expr<'_>, is_ok
     let scrut = Sugg::hir_with_applicability(cx, scrutinee, "..", &mut app).maybe_paren();
 
     let scrutinee_ty = cx.typeck_results().expr_ty(scrutinee);
-    let (_, n_ref, mutability) = peel_mid_ty_refs_is_mutable(scrutinee_ty);
-    let prefix = if n_ref > 0 {
-        if mutability == Mutability::Mut {
-            ".as_mut()"
-        } else {
-            ".as_ref()"
-        }
-    } else {
-        ""
+    let (_, _, mutability) = peel_and_count_ty_refs(scrutinee_ty);
+    let prefix = match mutability {
+        Some(Mutability::Mut) => ".as_mut()",
+        Some(Mutability::Not) => ".as_ref()",
+        None => "",
     };
 
     let sugg = format!("{scrut}{prefix}.{method}()");
diff --git a/clippy_lints/src/matches/manual_utils.rs b/clippy_lints/src/matches/manual_utils.rs
index dbae71bbb1b06..d4bfdb7e440d8 100644
--- a/clippy_lints/src/matches/manual_utils.rs
+++ b/clippy_lints/src/matches/manual_utils.rs
@@ -2,7 +2,7 @@ use crate::map_unit_fn::OPTION_MAP_UNIT_FN;
 use crate::matches::MATCH_AS_REF;
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::{is_copy, is_type_diagnostic_item, peel_mid_ty_refs_is_mutable, type_is_unsafe_function};
+use clippy_utils::ty::{is_copy, is_type_diagnostic_item, is_unsafe_fn, peel_and_count_ty_refs};
 use clippy_utils::{
     CaptureKind, can_move_expr_to_closure, expr_requires_coercion, is_else_clause, is_lint_allowed, is_res_lang_ctor,
     path_res, path_to_local_id, peel_blocks, peel_hir_expr_refs, peel_hir_expr_while,
@@ -30,8 +30,9 @@ pub(super) fn check_with<'tcx, F>(
 where
     F: Fn(&LateContext<'tcx>, &'tcx Pat<'_>, &'tcx Expr<'_>, SyntaxContext) -> Option<SomeExpr<'tcx>>,
 {
-    let (scrutinee_ty, ty_ref_count, ty_mutability) =
-        peel_mid_ty_refs_is_mutable(cx.typeck_results().expr_ty(scrutinee));
+    let (scrutinee_ty, ty_ref_count, ty_mutability) = peel_and_count_ty_refs(cx.typeck_results().expr_ty(scrutinee));
+    let ty_mutability = ty_mutability.unwrap_or(Mutability::Mut);
+
     if !(is_type_diagnostic_item(cx, scrutinee_ty, sym::Option)
         && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::Option))
     {
@@ -191,7 +192,7 @@ fn can_pass_as_func<'tcx>(cx: &LateContext<'tcx>, binding: HirId, expr: &'tcx Ex
         ExprKind::Call(func, [arg])
             if path_to_local_id(arg, binding)
                 && cx.typeck_results().expr_adjustments(arg).is_empty()
-                && !type_is_unsafe_function(cx, cx.typeck_results().expr_ty(func).peel_refs()) =>
+                && !is_unsafe_fn(cx, cx.typeck_results().expr_ty(func).peel_refs()) =>
         {
             Some(func)
         },
diff --git a/clippy_lints/src/matches/needless_match.rs b/clippy_lints/src/matches/needless_match.rs
index b04db03f8d2e7..3a2097c3df261 100644
--- a/clippy_lints/src/matches/needless_match.rs
+++ b/clippy_lints/src/matches/needless_match.rs
@@ -1,7 +1,7 @@
 use super::NEEDLESS_MATCH;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::{is_type_diagnostic_item, same_type_and_consts};
+use clippy_utils::ty::{is_type_diagnostic_item, same_type_modulo_regions};
 use clippy_utils::{
     SpanlessEq, eq_expr_value, get_parent_expr_for_hir, higher, is_else_clause, is_res_lang_ctor, over, path_res,
     peel_blocks_with_stmt,
@@ -122,7 +122,7 @@ fn expr_ty_matches_p_ty(cx: &LateContext<'_>, expr: &Expr<'_>, p_expr: &Expr<'_>
         // Compare match_expr ty with local in `let local = match match_expr {..}`
         Node::LetStmt(local) => {
             let results = cx.typeck_results();
-            return same_type_and_consts(results.node_type(local.hir_id), results.expr_ty(expr));
+            return same_type_modulo_regions(results.node_type(local.hir_id), results.expr_ty(expr));
         },
         // compare match_expr ty with RetTy in `fn foo() -> RetTy`
         Node::Item(item) => {
@@ -133,7 +133,7 @@ fn expr_ty_matches_p_ty(cx: &LateContext<'_>, expr: &Expr<'_>, p_expr: &Expr<'_>
                     .instantiate_identity()
                     .output()
                     .skip_binder();
-                return same_type_and_consts(output, cx.typeck_results().expr_ty(expr));
+                return same_type_modulo_regions(output, cx.typeck_results().expr_ty(expr));
             }
         },
         // check the parent expr for this whole block `{ match match_expr {..} }`
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 ae09c2e87d6b7..1130d82ab78f9 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
@@ -7,7 +7,7 @@ use super::REST_PAT_IN_FULLY_BOUND_STRUCTS;
 
 pub(crate) fn check(cx: &LateContext<'_>, pat: &Pat<'_>) {
     if !pat.span.from_expansion()
-        && let PatKind::Struct(QPath::Resolved(_, path), fields, Some(_)) = pat.kind
+        && let PatKind::Struct(QPath::Resolved(_, path), fields, Some(dotdot)) = pat.kind
         && let Some(def_id) = path.res.opt_def_id()
         && let ty = cx.tcx.type_of(def_id).instantiate_identity()
         && let ty::Adt(def, _) = ty.kind()
@@ -15,14 +15,18 @@ 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()
     {
-        #[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",
             |diag| {
-                diag.help("consider removing `..` from this binding");
+                diag.span_suggestion_verbose(
+                    dotdot,
+                    "consider removing `..` from this binding",
+                    "",
+                    rustc_errors::Applicability::MachineApplicable,
+                );
             },
         );
     }
diff --git a/clippy_lints/src/matches/single_match.rs b/clippy_lints/src/matches/single_match.rs
index bcf079b700703..83939d325794e 100644
--- a/clippy_lints/src/matches/single_match.rs
+++ b/clippy_lints/src/matches/single_match.rs
@@ -2,10 +2,8 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::{
     SpanRangeExt, expr_block, snippet, snippet_block_with_context, snippet_with_applicability, snippet_with_context,
 };
-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 clippy_utils::ty::{implements_trait, peel_and_count_ty_refs};
+use clippy_utils::{is_lint_allowed, is_unit_expr, peel_blocks, peel_hir_pat_refs, peel_n_hir_expr_refs};
 use core::ops::ControlFlow;
 use rustc_arena::DroplessArena;
 use rustc_errors::{Applicability, Diag};
@@ -133,7 +131,7 @@ fn report_single_pattern(
 
     let (pat, pat_ref_count) = peel_hir_pat_refs(arm.pat);
     let (msg, sugg) = if let PatKind::Expr(_) = pat.kind
-        && let (ty, ty_ref_count) = peel_middle_ty_refs(cx.typeck_results().expr_ty(ex))
+        && let (ty, ty_ref_count, _) = peel_and_count_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()
diff --git a/clippy_lints/src/methods/implicit_clone.rs b/clippy_lints/src/methods/implicit_clone.rs
index 8a976d1b4dc00..0ba84919395cc 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;
-use clippy_utils::{is_diag_item_method, is_diag_trait_item, peel_middle_ty_refs, sym};
+use clippy_utils::ty::{implements_trait, peel_and_count_ty_refs};
+use clippy_utils::{is_diag_item_method, is_diag_trait_item, sym};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -14,7 +14,7 @@ pub fn check(cx: &LateContext<'_>, method_name: Symbol, expr: &hir::Expr<'_>, re
         && 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_middle_ty_refs(input_type)
+        && let (input_type, ref_count, _) = peel_and_count_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/inefficient_to_string.rs b/clippy_lints/src/methods/inefficient_to_string.rs
index 4ed7de81ea3d0..47195fdd65f5f 100644
--- a/clippy_lints/src/methods/inefficient_to_string.rs
+++ b/clippy_lints/src/methods/inefficient_to_string.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::{is_type_lang_item, walk_ptrs_ty_depth};
+use clippy_utils::ty::{is_type_lang_item, peel_and_count_ty_refs};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -24,7 +24,7 @@ pub fn check(
         && let Some(args) = cx.typeck_results().node_args_opt(expr.hir_id)
         && let arg_ty = cx.typeck_results().expr_ty_adjusted(receiver)
         && let self_ty = args.type_at(0)
-        && let (deref_self_ty, deref_count) = walk_ptrs_ty_depth(self_ty)
+        && let (deref_self_ty, deref_count, _) = peel_and_count_ty_refs(self_ty)
         && deref_count >= 1
         && specializes_tostring(cx, deref_self_ty)
     {
diff --git a/clippy_lints/src/methods/iter_overeager_cloned.rs b/clippy_lints/src/methods/iter_overeager_cloned.rs
index f851ebe91f37f..d43dc23a86b23 100644
--- a/clippy_lints/src/methods/iter_overeager_cloned.rs
+++ b/clippy_lints/src/methods/iter_overeager_cloned.rs
@@ -10,8 +10,7 @@ use rustc_middle::mir::{FakeReadCause, Mutability};
 use rustc_middle::ty::{self, BorrowKind};
 use rustc_span::{Symbol, sym};
 
-use super::ITER_OVEREAGER_CLONED;
-use crate::redundant_clone::REDUNDANT_CLONE;
+use super::{ITER_OVEREAGER_CLONED, REDUNDANT_ITER_CLONED};
 
 #[derive(Clone, Copy)]
 pub(super) enum Op<'a> {
@@ -96,7 +95,7 @@ pub(super) fn check<'tcx>(
         }
 
         let (lint, msg, trailing_clone) = match op {
-            Op::RmCloned | Op::NeedlessMove(_) => (REDUNDANT_CLONE, "unneeded cloning of iterator items", ""),
+            Op::RmCloned | Op::NeedlessMove(_) => (REDUNDANT_ITER_CLONED, "unneeded cloning of iterator items", ""),
             Op::LaterCloned | Op::FixClosure(_, _) => (
                 ITER_OVEREAGER_CLONED,
                 "unnecessarily eager cloning of iterator items",
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 49ca81dafc280..8679689c8ad4d 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -91,6 +91,7 @@ mod or_fun_call;
 mod or_then_unwrap;
 mod path_buf_push_overwrite;
 mod path_ends_with_ext;
+mod ptr_offset_with_cast;
 mod range_zip_with_len;
 mod read_line_without_trim;
 mod readonly_write_lock;
@@ -1725,6 +1726,43 @@ declare_clippy_lint! {
     "Check for offset calculations on raw pointers to zero-sized types"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of the `offset` pointer method with a `usize` casted to an
+    /// `isize`.
+    ///
+    /// ### Why is this bad?
+    /// If we’re always increasing the pointer address, we can avoid the numeric
+    /// cast by using the `add` method instead.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let vec = vec![b'a', b'b', b'c'];
+    /// let ptr = vec.as_ptr();
+    /// let offset = 1_usize;
+    ///
+    /// unsafe {
+    ///     ptr.offset(offset as isize);
+    /// }
+    /// ```
+    ///
+    /// Could be written:
+    ///
+    /// ```no_run
+    /// let vec = vec![b'a', b'b', b'c'];
+    /// let ptr = vec.as_ptr();
+    /// let offset = 1_usize;
+    ///
+    /// unsafe {
+    ///     ptr.add(offset);
+    /// }
+    /// ```
+    #[clippy::version = "1.30.0"]
+    pub PTR_OFFSET_WITH_CAST,
+    complexity,
+    "unneeded pointer offset cast"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for `FileType::is_file()`.
@@ -4576,6 +4614,31 @@ declare_clippy_lint! {
     "hardcoded localhost IP address"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calls to `Iterator::cloned` where the original value could be used
+    /// instead.
+    ///
+    /// ### Why is this bad?
+    /// It is not always possible for the compiler to eliminate useless allocations and
+    /// deallocations generated by redundant `clone()`s.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let x = vec![String::new()];
+    /// let _ = x.iter().cloned().map(|x| x.len());
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let x = vec![String::new()];
+    /// let _ = x.iter().map(|x| x.len());
+    /// ```
+    #[clippy::version = "1.90.0"]
+    pub REDUNDANT_ITER_CLONED,
+    perf,
+    "detects redundant calls to `Iterator::cloned`"
+}
+
 #[expect(clippy::struct_excessive_bools)]
 pub struct Methods {
     avoid_breaking_exported_api: bool,
@@ -4665,6 +4728,7 @@ impl_lint_pass!(Methods => [
     UNINIT_ASSUMED_INIT,
     MANUAL_SATURATING_ARITHMETIC,
     ZST_OFFSET,
+    PTR_OFFSET_WITH_CAST,
     FILETYPE_IS_FILE,
     OPTION_AS_REF_DEREF,
     UNNECESSARY_LAZY_EVALUATIONS,
@@ -4755,6 +4819,7 @@ impl_lint_pass!(Methods => [
     IO_OTHER_ERROR,
     SWAP_WITH_TEMPORARY,
     IP_CONSTANT,
+    REDUNDANT_ITER_CLONED,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -4960,10 +5025,7 @@ impl Methods {
         // Handle method calls whose receiver and arguments may not come from expansion
         if let Some((name, recv, args, span, call_span)) = method_call(expr) {
             match (name, args) {
-                (
-                    sym::add | sym::offset | sym::sub | sym::wrapping_offset | sym::wrapping_add | sym::wrapping_sub,
-                    [_arg],
-                ) => {
+                (sym::add | sym::sub | sym::wrapping_add | sym::wrapping_sub, [_arg]) => {
                     zst_offset::check(cx, expr, recv);
                 },
                 (sym::all, [arg]) => {
@@ -5334,6 +5396,11 @@ impl Methods {
                     },
                     _ => iter_nth_zero::check(cx, expr, recv, n_arg),
                 },
+                (sym::offset | sym::wrapping_offset, [arg]) => {
+                    zst_offset::check(cx, expr, recv);
+
+                    ptr_offset_with_cast::check(cx, name, expr, recv, arg, self.msrv);
+                },
                 (sym::ok_or_else, [arg]) => {
                     unnecessary_lazy_eval::check(cx, expr, recv, arg, "ok_or");
                 },
diff --git a/clippy_lints/src/methods/mut_mutex_lock.rs b/clippy_lints/src/methods/mut_mutex_lock.rs
index 4235af882b0c7..9d2c5e6232d65 100644
--- a/clippy_lints/src/methods/mut_mutex_lock.rs
+++ b/clippy_lints/src/methods/mut_mutex_lock.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::expr_custom_deref_adjustment;
-use clippy_utils::ty::{is_type_diagnostic_item, peel_mid_ty_refs_is_mutable};
+use clippy_utils::ty::{is_type_diagnostic_item, peel_and_count_ty_refs};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability};
 use rustc_lint::LateContext;
@@ -10,8 +10,7 @@ use super::MUT_MUTEX_LOCK;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, ex: &'tcx Expr<'tcx>, recv: &'tcx Expr<'tcx>, name_span: Span) {
     if matches!(expr_custom_deref_adjustment(cx, recv), None | Some(Mutability::Mut))
-        && let (_, ref_depth, Mutability::Mut) = peel_mid_ty_refs_is_mutable(cx.typeck_results().expr_ty(recv))
-        && ref_depth >= 1
+        && let (_, _, Some(Mutability::Mut)) = peel_and_count_ty_refs(cx.typeck_results().expr_ty(recv))
         && let Some(method_id) = cx.typeck_results().type_dependent_def_id(ex.hir_id)
         && let Some(impl_id) = cx.tcx.impl_of_assoc(method_id)
         && is_type_diagnostic_item(cx, cx.tcx.type_of(impl_id).instantiate_identity(), sym::Mutex)
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 04f0e3c0479e0..71b2f251eded6 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -2,6 +2,7 @@ use std::ops::ControlFlow;
 
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::eager_or_lazy::switch_to_lazy_eval;
+use clippy_utils::higher::VecArgs;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::{expr_type_is_certain, implements_trait, is_type_diagnostic_item};
 use clippy_utils::visitors::for_each_expr;
@@ -97,6 +98,12 @@ pub(super) fn check<'tcx>(
             return false;
         }
 
+        // `.unwrap_or(vec![])` is as readable as `.unwrap_or_default()`. And if the expression is a
+        // non-empty `Vec`, then it will not be a default value anyway. Bail out in all cases.
+        if call_expr.and_then(|call_expr| VecArgs::hir(cx, call_expr)).is_some() {
+            return false;
+        }
+
         // needs to target Default::default in particular or be *::new and have a Default impl
         // available
         if (is_new(fun) && output_type_implements_default(fun))
diff --git a/clippy_lints/src/methods/ptr_offset_with_cast.rs b/clippy_lints/src/methods/ptr_offset_with_cast.rs
new file mode 100644
index 0000000000000..d19d3b8eb89d9
--- /dev/null
+++ b/clippy_lints/src/methods/ptr_offset_with_cast.rs
@@ -0,0 +1,82 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::sym;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_span::Symbol;
+use std::fmt;
+
+use super::PTR_OFFSET_WITH_CAST;
+
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    method: Symbol,
+    expr: &Expr<'_>,
+    recv: &Expr<'_>,
+    arg: &Expr<'_>,
+    msrv: Msrv,
+) {
+    // `pointer::add` and `pointer::wrapping_add` are only stable since 1.26.0. These functions
+    // became const-stable in 1.61.0, the same version that `pointer::offset` became const-stable.
+    if !msrv.meets(cx, msrvs::POINTER_ADD_SUB_METHODS) {
+        return;
+    }
+
+    let method = match method {
+        sym::offset => Method::Offset,
+        sym::wrapping_offset => Method::WrappingOffset,
+        _ => return,
+    };
+
+    if !cx.typeck_results().expr_ty_adjusted(recv).is_raw_ptr() {
+        return;
+    }
+
+    // Check if the argument to the method call is a cast from usize.
+    let cast_lhs_expr = match arg.kind {
+        ExprKind::Cast(lhs, _) if cx.typeck_results().expr_ty(lhs).is_usize() => lhs,
+        _ => return,
+    };
+
+    let ExprKind::MethodCall(method_name, _, _, _) = expr.kind else {
+        return;
+    };
+
+    let msg = format!("use of `{method}` with a `usize` casted to an `isize`");
+    span_lint_and_then(cx, PTR_OFFSET_WITH_CAST, expr.span, msg, |diag| {
+        diag.multipart_suggestion(
+            format!("use `{}` instead", method.suggestion()),
+            vec![
+                (method_name.ident.span, method.suggestion().to_string()),
+                (arg.span.with_lo(cast_lhs_expr.span.hi()), String::new()),
+            ],
+            Applicability::MachineApplicable,
+        );
+    });
+}
+
+#[derive(Copy, Clone)]
+enum Method {
+    Offset,
+    WrappingOffset,
+}
+
+impl Method {
+    #[must_use]
+    fn suggestion(self) -> &'static str {
+        match self {
+            Self::Offset => "add",
+            Self::WrappingOffset => "wrapping_add",
+        }
+    }
+}
+
+impl fmt::Display for Method {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Offset => write!(f, "offset"),
+            Self::WrappingOffset => write!(f, "wrapping_offset"),
+        }
+    }
+}
diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index c1f4904af7c48..640931a828998 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -3,11 +3,12 @@ use super::unnecessary_iter_cloned::{self, is_into_iter};
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::{SpanRangeExt, snippet};
-use clippy_utils::ty::{get_iterator_item_ty, implements_trait, is_copy, is_type_diagnostic_item, is_type_lang_item};
+use clippy_utils::ty::{
+    get_iterator_item_ty, implements_trait, is_copy, is_type_diagnostic_item, is_type_lang_item, peel_and_count_ty_refs,
+};
 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, is_expr_temporary_value, peel_middle_ty_refs,
-    return_ty, sym,
+    fn_def_id, get_parent_expr, is_diag_item_method, is_diag_trait_item, is_expr_temporary_value, return_ty, sym,
 };
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
@@ -119,8 +120,8 @@ fn check_addr_of_expr(
                 },
             ] = adjustments[..]
         && let receiver_ty = cx.typeck_results().expr_ty(receiver)
-        && let (target_ty, n_target_refs) = peel_middle_ty_refs(*target_ty)
-        && let (receiver_ty, n_receiver_refs) = peel_middle_ty_refs(receiver_ty)
+        && let (target_ty, n_target_refs, _) = peel_and_count_ty_refs(*target_ty)
+        && let (receiver_ty, n_receiver_refs, _) = peel_and_count_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
@@ -385,7 +386,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_middle_ty_refs(*input)
+        && let (input, n_refs, _) = peel_and_count_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 Some(meta_sized_def_id) = cx.tcx.lang_items().meta_sized_trait()
diff --git a/clippy_lints/src/methods/useless_asref.rs b/clippy_lints/src/methods/useless_asref.rs
index 38fad239f6799..e56f4b80d0172 100644
--- a/clippy_lints/src/methods/useless_asref.rs
+++ b/clippy_lints/src/methods/useless_asref.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::{implements_trait, should_call_clone_as_function, walk_ptrs_ty_depth};
+use clippy_utils::ty::{implements_trait, peel_and_count_ty_refs, should_call_clone_as_function};
 use clippy_utils::{get_parent_expr, is_diag_trait_item, path_to_local_id, peel_blocks, strip_pat_refs};
 use rustc_errors::Applicability;
 use rustc_hir::{self as hir, LangItem};
@@ -50,8 +50,8 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: Symbo
         // check if the type after `as_ref` or `as_mut` is the same as before
         let rcv_ty = cx.typeck_results().expr_ty(recvr);
         let res_ty = cx.typeck_results().expr_ty(expr);
-        let (base_res_ty, res_depth) = walk_ptrs_ty_depth(res_ty);
-        let (base_rcv_ty, rcv_depth) = walk_ptrs_ty_depth(rcv_ty);
+        let (base_res_ty, res_depth, _) = peel_and_count_ty_refs(res_ty);
+        let (base_rcv_ty, rcv_depth, _) = peel_and_count_ty_refs(rcv_ty);
         if base_rcv_ty == base_res_ty && rcv_depth >= res_depth {
             if let Some(parent) = get_parent_expr(cx, expr) {
                 // allow the `as_ref` or `as_mut` if it is followed by another method call
diff --git a/clippy_lints/src/min_ident_chars.rs b/clippy_lints/src/min_ident_chars.rs
index 6258e408217fc..1ceee836732ae 100644
--- a/clippy_lints/src/min_ident_chars.rs
+++ b/clippy_lints/src/min_ident_chars.rs
@@ -256,7 +256,11 @@ fn is_not_in_trait_impl(cx: &LateContext<'_>, pat: &Pat<'_>, ident: Ident) -> bo
 }
 
 fn get_param_name(impl_item: &ImplItem<'_>, cx: &LateContext<'_>, ident: Ident) -> Option<Symbol> {
-    if let ImplItemImplKind::Trait { trait_item_def_id: Ok(trait_item_def_id), .. } = impl_item.impl_kind {
+    if let ImplItemImplKind::Trait {
+        trait_item_def_id: Ok(trait_item_def_id),
+        ..
+    } = impl_item.impl_kind
+    {
         let trait_param_names = cx.tcx.fn_arg_idents(trait_item_def_id);
 
         let ImplItemKind::Fn(_, body_id) = impl_item.kind else {
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 09ee6f7037c64..19e9910dfe9dd 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -1,57 +1,11 @@
-use clippy_utils::diagnostics::{span_lint_and_then, span_lint_hir, span_lint_hir_and_then};
-use clippy_utils::source::{snippet, snippet_with_context};
+use clippy_utils::diagnostics::{span_lint_and_then, span_lint_hir_and_then};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::{
-    SpanlessEq, fulfill_or_allowed, get_parent_expr, in_automatically_derived, is_lint_allowed, iter_input_pats,
-    last_path_segment,
-};
+use clippy_utils::{SpanlessEq, fulfill_or_allowed, get_parent_expr, in_automatically_derived, last_path_segment};
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
-use rustc_hir::intravisit::FnKind;
-use rustc_hir::{
-    BinOpKind, BindingMode, Body, ByRef, Expr, ExprKind, FnDecl, Mutability, PatKind, QPath, Stmt, StmtKind,
-};
+use rustc_hir::{BinOpKind, Expr, ExprKind, QPath, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::declare_lint_pass;
-use rustc_span::Span;
-use rustc_span::def_id::LocalDefId;
-
-use crate::ref_patterns::REF_PATTERNS;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for function arguments and let bindings denoted as
-    /// `ref`.
-    ///
-    /// ### Why is this bad?
-    /// The `ref` declaration makes the function take an owned
-    /// value, but turns the argument into a reference (which means that the value
-    /// is destroyed when exiting the function). This adds not much value: either
-    /// take a reference type, or take an owned value and create references in the
-    /// body.
-    ///
-    /// For let bindings, `let x = &foo;` is preferred over `let ref x = foo`. The
-    /// type of `x` is more obvious with the former.
-    ///
-    /// ### Known problems
-    /// If the argument is dereferenced within the function,
-    /// removing the `ref` will lead to errors. This can be fixed by removing the
-    /// dereferences, e.g., changing `*x` to `x` within the function.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// fn foo(ref _x: u8) {}
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// fn foo(_x: &u8) {}
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub TOPLEVEL_REF_ARG,
-    style,
-    "an entire binding declared as `ref`, in a function argument or a `let` statement"
-}
 
 declare_clippy_lint! {
     /// ### What it does
@@ -140,79 +94,13 @@ declare_clippy_lint! {
 }
 
 declare_lint_pass!(LintPass => [
-    TOPLEVEL_REF_ARG,
     USED_UNDERSCORE_BINDING,
     USED_UNDERSCORE_ITEMS,
     SHORT_CIRCUIT_STATEMENT,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for LintPass {
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'tcx>,
-        k: FnKind<'tcx>,
-        decl: &'tcx FnDecl<'_>,
-        body: &'tcx Body<'_>,
-        _: Span,
-        _: LocalDefId,
-    ) {
-        if !matches!(k, FnKind::Closure) {
-            for arg in iter_input_pats(decl, body) {
-                if let PatKind::Binding(BindingMode(ByRef::Yes(_), _), ..) = arg.pat.kind
-                    && is_lint_allowed(cx, REF_PATTERNS, arg.pat.hir_id)
-                    && !arg.span.in_external_macro(cx.tcx.sess.source_map())
-                {
-                    span_lint_hir(
-                        cx,
-                        TOPLEVEL_REF_ARG,
-                        arg.hir_id,
-                        arg.pat.span,
-                        "`ref` directly on a function parameter does not prevent taking ownership of the passed argument. \
-                        Consider using a reference type instead",
-                    );
-                }
-            }
-        }
-    }
-
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
-        if let StmtKind::Let(local) = stmt.kind
-            && let PatKind::Binding(BindingMode(ByRef::Yes(mutabl), _), .., name, None) = local.pat.kind
-            && let Some(init) = local.init
-            // Do not emit if clippy::ref_patterns is not allowed to avoid having two lints for the same issue.
-            && is_lint_allowed(cx, REF_PATTERNS, local.pat.hir_id)
-            && !stmt.span.in_external_macro(cx.tcx.sess.source_map())
-        {
-            let ctxt = local.span.ctxt();
-            let mut app = Applicability::MachineApplicable;
-            let sugg_init = Sugg::hir_with_context(cx, init, ctxt, "..", &mut app);
-            let (mutopt, initref) = if mutabl == Mutability::Mut {
-                ("mut ", sugg_init.mut_addr())
-            } else {
-                ("", sugg_init.addr())
-            };
-            let tyopt = if let Some(ty) = local.ty {
-                let ty_snip = snippet_with_context(cx, ty.span, ctxt, "_", &mut app).0;
-                format!(": &{mutopt}{ty_snip}")
-            } else {
-                String::new()
-            };
-            span_lint_hir_and_then(
-                cx,
-                TOPLEVEL_REF_ARG,
-                init.hir_id,
-                local.pat.span,
-                "`ref` on an entire `let` pattern is discouraged, take a reference with `&` instead",
-                |diag| {
-                    diag.span_suggestion(
-                        stmt.span,
-                        "try",
-                        format!("let {name}{tyopt} = {initref};", name = snippet(cx, name.span, ".."),),
-                        app,
-                    );
-                },
-            );
-        }
         if let StmtKind::Semi(expr) = stmt.kind
             && let ExprKind::Binary(binop, a, b) = &expr.kind
             && matches!(binop.node, BinOpKind::And | BinOpKind::Or)
diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs
index 39b5964bd87b1..1c62caa1c8274 100644
--- a/clippy_lints/src/missing_doc.rs
+++ b/clippy_lints/src/missing_doc.rs
@@ -250,7 +250,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
             AssocContainer::Trait | AssocContainer::TraitImpl(_) => {
                 note_prev_span_then_ret!(self.prev_span, impl_item.span);
             },
-            AssocContainer::InherentImpl => {}
+            AssocContainer::InherentImpl => {},
         }
 
         let (article, desc) = cx.tcx.article_and_description(impl_item.owner_id.to_def_id());
diff --git a/clippy_lints/src/multiple_unsafe_ops_per_block.rs b/clippy_lints/src/multiple_unsafe_ops_per_block.rs
index c6c27e22b90e5..bc5e72270f4e3 100644
--- a/clippy_lints/src/multiple_unsafe_ops_per_block.rs
+++ b/clippy_lints/src/multiple_unsafe_ops_per_block.rs
@@ -1,3 +1,4 @@
+use clippy_utils::desugar_await;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::visitors::{Descend, Visitable, for_each_expr};
 use core::ops::ControlFlow::Continue;
@@ -97,6 +98,13 @@ fn collect_unsafe_exprs<'tcx>(
 ) {
     for_each_expr(cx, node, |expr| {
         match expr.kind {
+            // The `await` itself will desugar to two unsafe calls, but we should ignore those.
+            // Instead, check the expression that is `await`ed
+            _ if let Some(e) = desugar_await(expr) => {
+                collect_unsafe_exprs(cx, e, unsafe_ops);
+                return Continue(Descend::No);
+            },
+
             ExprKind::InlineAsm(_) => unsafe_ops.push(("inline assembly used here", expr.span)),
 
             ExprKind::Field(e, _) => {
diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index c4cad592e3675..a21c361356e83 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -252,7 +252,9 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
                 {
                     (
                         trait_item_id,
-                        FnKind::ImplTraitFn(std::ptr::from_ref(cx.tcx.erase_and_anonymize_regions(trait_ref.args)) as usize),
+                        FnKind::ImplTraitFn(
+                            std::ptr::from_ref(cx.tcx.erase_and_anonymize_regions(trait_ref.args)) as usize
+                        ),
                         usize::from(sig.decl.implicit_self.has_implicit_self()),
                     )
                 } else {
diff --git a/clippy_lints/src/operators/erasing_op.rs b/clippy_lints/src/operators/erasing_op.rs
index e3fc8d8fea7d1..8f5ee390f7222 100644
--- a/clippy_lints/src/operators/erasing_op.rs
+++ b/clippy_lints/src/operators/erasing_op.rs
@@ -1,6 +1,6 @@
 use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::ty::same_type_and_consts;
+use clippy_utils::ty::same_type_modulo_regions;
 
 use rustc_hir::{BinOpKind, Expr};
 use rustc_lint::LateContext;
@@ -29,7 +29,7 @@ pub(super) fn check<'tcx>(
 fn different_types(tck: &TypeckResults<'_>, input: &Expr<'_>, output: &Expr<'_>) -> bool {
     let input_ty = tck.expr_ty(input).peel_refs();
     let output_ty = tck.expr_ty(output).peel_refs();
-    !same_type_and_consts(input_ty, output_ty)
+    !same_type_modulo_regions(input_ty, output_ty)
 }
 
 fn check_op<'tcx>(
diff --git a/clippy_lints/src/ptr_offset_with_cast.rs b/clippy_lints/src/ptr_offset_with_cast.rs
deleted file mode 100644
index d8d813f9846d5..0000000000000
--- a/clippy_lints/src/ptr_offset_with_cast.rs
+++ /dev/null
@@ -1,151 +0,0 @@
-use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
-use clippy_utils::source::SpanRangeExt;
-use clippy_utils::sym;
-use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::declare_lint_pass;
-use std::fmt;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of the `offset` pointer method with a `usize` casted to an
-    /// `isize`.
-    ///
-    /// ### Why is this bad?
-    /// If we’re always increasing the pointer address, we can avoid the numeric
-    /// cast by using the `add` method instead.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// let vec = vec![b'a', b'b', b'c'];
-    /// let ptr = vec.as_ptr();
-    /// let offset = 1_usize;
-    ///
-    /// unsafe {
-    ///     ptr.offset(offset as isize);
-    /// }
-    /// ```
-    ///
-    /// Could be written:
-    ///
-    /// ```no_run
-    /// let vec = vec![b'a', b'b', b'c'];
-    /// let ptr = vec.as_ptr();
-    /// let offset = 1_usize;
-    ///
-    /// unsafe {
-    ///     ptr.add(offset);
-    /// }
-    /// ```
-    #[clippy::version = "1.30.0"]
-    pub PTR_OFFSET_WITH_CAST,
-    complexity,
-    "unneeded pointer offset cast"
-}
-
-declare_lint_pass!(PtrOffsetWithCast => [PTR_OFFSET_WITH_CAST]);
-
-impl<'tcx> LateLintPass<'tcx> for PtrOffsetWithCast {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        // Check if the expressions is a ptr.offset or ptr.wrapping_offset method call
-        let Some((receiver_expr, arg_expr, method)) = expr_as_ptr_offset_call(cx, expr) else {
-            return;
-        };
-
-        // Check if the argument to the method call is a cast from usize
-        let Some(cast_lhs_expr) = expr_as_cast_from_usize(cx, arg_expr) else {
-            return;
-        };
-
-        let msg = format!("use of `{method}` with a `usize` casted to an `isize`");
-        if let Some(sugg) = build_suggestion(cx, method, receiver_expr, cast_lhs_expr) {
-            span_lint_and_sugg(
-                cx,
-                PTR_OFFSET_WITH_CAST,
-                expr.span,
-                msg,
-                "try",
-                sugg,
-                Applicability::MachineApplicable,
-            );
-        } else {
-            span_lint(cx, PTR_OFFSET_WITH_CAST, expr.span, msg);
-        }
-    }
-}
-
-// If the given expression is a cast from a usize, return the lhs of the cast
-fn expr_as_cast_from_usize<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
-    if let ExprKind::Cast(cast_lhs_expr, _) = expr.kind
-        && is_expr_ty_usize(cx, cast_lhs_expr)
-    {
-        return Some(cast_lhs_expr);
-    }
-    None
-}
-
-// If the given expression is a ptr::offset  or ptr::wrapping_offset method call, return the
-// receiver, the arg of the method call, and the method.
-fn expr_as_ptr_offset_call<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx Expr<'_>,
-) -> Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>, Method)> {
-    if let ExprKind::MethodCall(path_segment, arg_0, [arg_1], _) = &expr.kind
-        && is_expr_ty_raw_ptr(cx, arg_0)
-    {
-        if path_segment.ident.name == sym::offset {
-            return Some((arg_0, arg_1, Method::Offset));
-        }
-        if path_segment.ident.name == sym::wrapping_offset {
-            return Some((arg_0, arg_1, Method::WrappingOffset));
-        }
-    }
-    None
-}
-
-// Is the type of the expression a usize?
-fn is_expr_ty_usize(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    cx.typeck_results().expr_ty(expr) == cx.tcx.types.usize
-}
-
-// Is the type of the expression a raw pointer?
-fn is_expr_ty_raw_ptr(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    cx.typeck_results().expr_ty(expr).is_raw_ptr()
-}
-
-fn build_suggestion(
-    cx: &LateContext<'_>,
-    method: Method,
-    receiver_expr: &Expr<'_>,
-    cast_lhs_expr: &Expr<'_>,
-) -> Option<String> {
-    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()))
-}
-
-#[derive(Copy, Clone)]
-enum Method {
-    Offset,
-    WrappingOffset,
-}
-
-impl Method {
-    #[must_use]
-    fn suggestion(self) -> &'static str {
-        match self {
-            Self::Offset => "add",
-            Self::WrappingOffset => "wrapping_add",
-        }
-    }
-}
-
-impl fmt::Display for Method {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Offset => write!(f, "offset"),
-            Self::WrappingOffset => write!(f, "wrapping_offset"),
-        }
-    }
-}
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index de12a25b03dff..4aa100a50e053 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -8,9 +8,9 @@ use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use clippy_utils::{
-    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_res, path_to_local, path_to_local_id, peel_blocks, peel_blocks_with_stmt,
-    span_contains_cfg, span_contains_comment, sym,
+    eq_expr_value, fn_def_id_with_node_args, 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_res, path_to_local, path_to_local_id,
+    peel_blocks, peel_blocks_with_stmt, span_contains_cfg, span_contains_comment, sym,
 };
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{self, OptionNone, OptionSome, ResultErr, ResultOk};
@@ -393,8 +393,8 @@ fn check_arm_is_none_or_err<'tcx>(cx: &LateContext<'tcx>, mode: TryMode, arm: &A
                 && let ExprKind::Ret(Some(wrapped_ret_expr)) = arm_body.kind
                 && let ExprKind::Call(ok_ctor, [ret_expr]) = wrapped_ret_expr.kind
                 && is_res_lang_ctor(cx, path_res(cx, ok_ctor), ResultErr)
-                // check `...` is `val` from binding
-                && path_to_local_id(ret_expr, ok_val)
+                // check if `...` is `val` from binding or `val.into()`
+                && is_local_or_local_into(cx, ret_expr, ok_val)
             {
                 true
             } else {
@@ -417,6 +417,17 @@ fn check_arm_is_none_or_err<'tcx>(cx: &LateContext<'tcx>, mode: TryMode, arm: &A
     }
 }
 
+/// Check if `expr` is `val` or `val.into()`
+fn is_local_or_local_into(cx: &LateContext<'_>, expr: &Expr<'_>, val: HirId) -> bool {
+    let is_into_call = fn_def_id_with_node_args(cx, expr)
+        .and_then(|(fn_def_id, _)| cx.tcx.trait_of_assoc(fn_def_id))
+        .is_some_and(|trait_def_id| cx.tcx.is_diagnostic_item(sym::Into, trait_def_id));
+    match expr.kind {
+        ExprKind::MethodCall(_, recv, [], _) | ExprKind::Call(_, [recv]) => is_into_call && path_to_local_id(recv, val),
+        _ => path_to_local_id(expr, val),
+    }
+}
+
 fn check_arms_are_try<'tcx>(cx: &LateContext<'tcx>, mode: TryMode, arm1: &Arm<'tcx>, arm2: &Arm<'tcx>) -> bool {
     (check_arm_is_some_or_ok(cx, mode, arm1) && check_arm_is_none_or_err(cx, mode, arm2))
         || (check_arm_is_some_or_ok(cx, mode, arm2) && check_arm_is_none_or_err(cx, mode, arm1))
diff --git a/clippy_lints/src/read_zero_byte_vec.rs b/clippy_lints/src/read_zero_byte_vec.rs
index acd840401c6bb..b8d4e7c4651d2 100644
--- a/clippy_lints/src/read_zero_byte_vec.rs
+++ b/clippy_lints/src/read_zero_byte_vec.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::{span_lint_hir, span_lint_hir_and_then};
 use clippy_utils::higher::{VecInitKind, get_vec_init_kind};
-use clippy_utils::source::snippet;
+use clippy_utils::source::{indent_of, snippet};
 use clippy_utils::{get_enclosing_block, sym};
 
 use rustc_errors::Applicability;
@@ -83,10 +83,12 @@ impl<'tcx> LateLintPass<'tcx> for ReadZeroByteVec {
                             expr.span,
                             "reading zero byte data to `Vec`",
                             |diag| {
+                                let span = first_stmt_containing_expr(cx, expr).map_or(expr.span, |stmt| stmt.span);
+                                let indent = indent_of(cx, span).unwrap_or(0);
                                 diag.span_suggestion(
-                                    expr.span,
+                                    span.shrink_to_lo(),
                                     "try",
-                                    format!("{}.resize({len}, 0); {}", ident, snippet(cx, expr.span, "..")),
+                                    format!("{ident}.resize({len}, 0);\n{}", " ".repeat(indent)),
                                     applicability,
                                 );
                             },
@@ -100,14 +102,15 @@ impl<'tcx> LateLintPass<'tcx> for ReadZeroByteVec {
                                 expr.span,
                                 "reading zero byte data to `Vec`",
                                 |diag| {
+                                    let span = first_stmt_containing_expr(cx, expr).map_or(expr.span, |stmt| stmt.span);
+                                    let indent = indent_of(cx, span).unwrap_or(0);
                                     diag.span_suggestion(
-                                        expr.span,
+                                        span.shrink_to_lo(),
                                         "try",
                                         format!(
-                                            "{}.resize({}, 0); {}",
-                                            ident,
+                                            "{ident}.resize({}, 0);\n{}",
                                             snippet(cx, e.span, ".."),
-                                            snippet(cx, expr.span, "..")
+                                            " ".repeat(indent)
                                         ),
                                         applicability,
                                     );
@@ -130,6 +133,16 @@ impl<'tcx> LateLintPass<'tcx> for ReadZeroByteVec {
     }
 }
 
+fn first_stmt_containing_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<&'tcx hir::Stmt<'tcx>> {
+    cx.tcx.hir_parent_iter(expr.hir_id).find_map(|(_, node)| {
+        if let hir::Node::Stmt(stmt) = node {
+            Some(stmt)
+        } else {
+            None
+        }
+    })
+}
+
 struct ReadVecVisitor<'tcx> {
     local_id: HirId,
     read_zero_expr: Option<&'tcx Expr<'tcx>>,
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 1d58cdd26d88d..de6766cbe94aa 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::{span_lint_hir, span_lint_hir_and_then};
 use clippy_utils::fn_has_unsatisfiable_preds;
 use clippy_utils::mir::{LocalUsage, PossibleBorrowerMap, visit_local_usage};
 use clippy_utils::source::SpanRangeExt;
-use clippy_utils::ty::{has_drop, is_copy, is_type_lang_item, walk_ptrs_ty_depth};
+use clippy_utils::ty::{has_drop, is_copy, is_type_lang_item, peel_and_count_ty_refs};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, FnDecl, LangItem, def_id};
@@ -263,7 +263,7 @@ fn is_call_with_ref_arg<'tcx>(
         && args.len() == 1
         && let mir::Operand::Move(mir::Place { local, .. }) = &args[0].node
         && let ty::FnDef(def_id, _) = *func.ty(mir, cx.tcx).kind()
-        && let (inner_ty, 1) = walk_ptrs_ty_depth(args[0].node.ty(mir, cx.tcx))
+        && let (inner_ty, 1, _) = peel_and_count_ty_refs(args[0].node.ty(mir, cx.tcx))
         && !is_copy(cx, inner_ty)
     {
         Some((def_id, *local, inner_ty, destination.as_local()?))
diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index 324a05cdcc0c8..a358eff2ce554 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_then;
+use clippy_utils::get_parent_expr;
 use clippy_utils::source::snippet_with_context;
-use clippy_utils::ty::is_type_lang_item;
-use clippy_utils::{get_parent_expr, peel_middle_ty_refs};
+use clippy_utils::ty::{is_type_lang_item, peel_and_count_ty_refs};
 use rustc_ast::util::parser::ExprPrecedence;
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, LangItem, Mutability};
@@ -82,8 +82,8 @@ 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_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 (expr_ty, expr_ref_count, _) = peel_and_count_ty_refs(cx.typeck_results().expr_ty(expr));
+            let (indexed_ty, indexed_ref_count, _) = peel_and_count_ty_refs(cx.typeck_results().expr_ty(indexed));
             let parent_expr = get_parent_expr(cx, expr);
             let needs_parens_for_prefix =
                 parent_expr.is_some_and(|parent| cx.precedence(parent) > ExprPrecedence::Prefix);
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
deleted file mode 100644
index e0c93153a77a8..0000000000000
--- a/clippy_lints/src/returns.rs
+++ /dev/null
@@ -1,513 +0,0 @@
-use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
-use clippy_utils::source::{SpanRangeExt, snippet_with_context};
-use clippy_utils::sugg::has_enclosing_paren;
-use clippy_utils::visitors::for_each_expr;
-use clippy_utils::{
-    binary_expr_needs_parentheses, fn_def_id, is_from_proc_macro, is_inside_let_else, is_res_lang_ctor,
-    leaks_droppable_temporary_with_limited_lifetime, path_res, path_to_local_id, span_contains_cfg,
-    span_find_starting_semi, sym,
-};
-use core::ops::ControlFlow;
-use rustc_ast::MetaItemInner;
-use rustc_errors::Applicability;
-use rustc_hir::LangItem::ResultErr;
-use rustc_hir::intravisit::FnKind;
-use rustc_hir::{
-    Block, Body, Expr, ExprKind, FnDecl, HirId, ItemKind, LangItem, MatchSource, Node, OwnerNode, PatKind, QPath, Stmt,
-    StmtKind,
-};
-use rustc_lint::{LateContext, LateLintPass, Level, LintContext};
-use rustc_middle::ty::adjustment::Adjust;
-use rustc_middle::ty::{self, GenericArgKind, Ty};
-use rustc_session::declare_lint_pass;
-use rustc_span::def_id::LocalDefId;
-use rustc_span::edition::Edition;
-use rustc_span::{BytePos, Pos, Span};
-use std::borrow::Cow;
-use std::fmt::Display;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `let`-bindings, which are subsequently
-    /// returned.
-    ///
-    /// ### Why is this bad?
-    /// It is just extraneous code. Remove it to make your code
-    /// more rusty.
-    ///
-    /// ### Known problems
-    /// In the case of some temporaries, e.g. locks, eliding the variable binding could lead
-    /// to deadlocks. See [this issue](https://github.com/rust-lang/rust/issues/37612).
-    /// This could become relevant if the code is later changed to use the code that would have been
-    /// bound without first assigning it to a let-binding.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// fn foo() -> String {
-    ///     let x = String::new();
-    ///     x
-    /// }
-    /// ```
-    /// instead, use
-    /// ```no_run
-    /// fn foo() -> String {
-    ///     String::new()
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub LET_AND_RETURN,
-    style,
-    "creating a let-binding and then immediately returning it like `let x = expr; x` at the end of a block"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for return statements at the end of a block.
-    ///
-    /// ### Why is this bad?
-    /// Removing the `return` and semicolon will make the code
-    /// more rusty.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// fn foo(x: usize) -> usize {
-    ///     return x;
-    /// }
-    /// ```
-    /// simplify to
-    /// ```no_run
-    /// fn foo(x: usize) -> usize {
-    ///     x
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub NEEDLESS_RETURN,
-    // This lint requires some special handling in `check_final_expr` for `#[expect]`.
-    // This handling needs to be updated if the group gets changed. This should also
-    // be caught by tests.
-    style,
-    "using a return statement like `return expr;` where an expression would suffice"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for return statements on `Err` paired with the `?` operator.
-    ///
-    /// ### Why is this bad?
-    /// The `return` is unnecessary.
-    ///
-    /// Returns may be used to add attributes to the return expression. Return
-    /// statements with attributes are therefore be accepted by this lint.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// fn foo(x: usize) -> Result<(), Box<dyn Error>> {
-    ///     if x == 0 {
-    ///         return Err(...)?;
-    ///     }
-    ///     Ok(())
-    /// }
-    /// ```
-    /// simplify to
-    /// ```rust,ignore
-    /// fn foo(x: usize) -> Result<(), Box<dyn Error>> {
-    ///     if x == 0 {
-    ///         Err(...)?;
-    ///     }
-    ///     Ok(())
-    /// }
-    /// ```
-    /// if paired with `try_err`, use instead:
-    /// ```rust,ignore
-    /// fn foo(x: usize) -> Result<(), Box<dyn Error>> {
-    ///     if x == 0 {
-    ///         return Err(...);
-    ///     }
-    ///     Ok(())
-    /// }
-    /// ```
-    #[clippy::version = "1.73.0"]
-    pub NEEDLESS_RETURN_WITH_QUESTION_MARK,
-    style,
-    "using a return statement like `return Err(expr)?;` where removing it would suffice"
-}
-
-#[derive(PartialEq, Eq)]
-enum RetReplacement<'tcx> {
-    Empty,
-    Block,
-    Unit,
-    NeedsPar(Cow<'tcx, str>, Applicability),
-    Expr(Cow<'tcx, str>, Applicability),
-}
-
-impl RetReplacement<'_> {
-    fn sugg_help(&self) -> &'static str {
-        match self {
-            Self::Empty | Self::Expr(..) => "remove `return`",
-            Self::Block => "replace `return` with an empty block",
-            Self::Unit => "replace `return` with a unit value",
-            Self::NeedsPar(..) => "remove `return` and wrap the sequence with parentheses",
-        }
-    }
-
-    fn applicability(&self) -> Applicability {
-        match self {
-            Self::Expr(_, ap) | Self::NeedsPar(_, ap) => *ap,
-            _ => Applicability::MachineApplicable,
-        }
-    }
-}
-
-impl Display for RetReplacement<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Empty => write!(f, ""),
-            Self::Block => write!(f, "{{}}"),
-            Self::Unit => write!(f, "()"),
-            Self::NeedsPar(inner, _) => write!(f, "({inner})"),
-            Self::Expr(inner, _) => write!(f, "{inner}"),
-        }
-    }
-}
-
-declare_lint_pass!(Return => [LET_AND_RETURN, NEEDLESS_RETURN, NEEDLESS_RETURN_WITH_QUESTION_MARK]);
-
-/// Checks if a return statement is "needed" in the middle of a block, or if it can be removed. This
-/// is the case when the enclosing block expression is coerced to some other type, which only works
-/// because of the never-ness of `return` expressions
-fn stmt_needs_never_type(cx: &LateContext<'_>, stmt_hir_id: HirId) -> bool {
-    cx.tcx
-        .hir_parent_iter(stmt_hir_id)
-        .find_map(|(_, node)| if let Node::Expr(expr) = node { Some(expr) } else { None })
-        .is_some_and(|e| {
-            cx.typeck_results()
-                .expr_adjustments(e)
-                .iter()
-                .any(|adjust| adjust.target != cx.tcx.types.unit && matches!(adjust.kind, Adjust::NeverToAny))
-        })
-}
-
-impl<'tcx> LateLintPass<'tcx> for Return {
-    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
-        if !stmt.span.in_external_macro(cx.sess().source_map())
-            && let StmtKind::Semi(expr) = stmt.kind
-            && let ExprKind::Ret(Some(ret)) = expr.kind
-            // return Err(...)? desugars to a match
-            // over a Err(...).branch()
-            // which breaks down to a branch call, with the callee being
-            // the constructor of the Err variant
-            && let ExprKind::Match(maybe_cons, _, MatchSource::TryDesugar(_)) = ret.kind
-            && let ExprKind::Call(_, [maybe_result_err]) = maybe_cons.kind
-            && let ExprKind::Call(maybe_constr, _) = maybe_result_err.kind
-            && is_res_lang_ctor(cx, path_res(cx, maybe_constr), ResultErr)
-
-            // Ensure this is not the final stmt, otherwise removing it would cause a compile error
-            && let OwnerNode::Item(item) = cx.tcx.hir_owner_node(cx.tcx.hir_get_parent_item(expr.hir_id))
-            && let ItemKind::Fn { body, .. } = item.kind
-            && let block = cx.tcx.hir_body(body).value
-            && let ExprKind::Block(block, _) = block.kind
-            && !is_inside_let_else(cx.tcx, expr)
-            && let [.., final_stmt] = block.stmts
-            && final_stmt.hir_id != stmt.hir_id
-            && !is_from_proc_macro(cx, expr)
-            && !stmt_needs_never_type(cx, stmt.hir_id)
-        {
-            span_lint_and_sugg(
-                cx,
-                NEEDLESS_RETURN_WITH_QUESTION_MARK,
-                expr.span.until(ret.span),
-                "unneeded `return` statement with `?` operator",
-                "remove it",
-                String::new(),
-                Applicability::MachineApplicable,
-            );
-        }
-    }
-
-    fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'_>) {
-        // we need both a let-binding stmt and an expr
-        if let Some(retexpr) = block.expr
-            && let Some(stmt) = block.stmts.iter().last()
-            && let StmtKind::Let(local) = &stmt.kind
-            && local.ty.is_none()
-            && cx.tcx.hir_attrs(local.hir_id).is_empty()
-            && let Some(initexpr) = &local.init
-            && let PatKind::Binding(_, local_id, _, _) = local.pat.kind
-            && path_to_local_id(retexpr, local_id)
-            && (cx.sess().edition() >= Edition::Edition2024 || !last_statement_borrows(cx, initexpr))
-            && !initexpr.span.in_external_macro(cx.sess().source_map())
-            && !retexpr.span.in_external_macro(cx.sess().source_map())
-            && !local.span.from_expansion()
-            && !span_contains_cfg(cx, stmt.span.between(retexpr.span))
-        {
-            span_lint_hir_and_then(
-                cx,
-                LET_AND_RETURN,
-                retexpr.hir_id,
-                retexpr.span,
-                "returning the result of a `let` binding from a block",
-                |err| {
-                    err.span_label(local.span, "unnecessary `let` binding");
-
-                    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(&src) {
-                                format!("{src} as _")
-                            } else {
-                                format!("({src}) as _")
-                            }
-                        } else {
-                            src.to_owned()
-                        };
-                        err.multipart_suggestion(
-                            "return the expression directly",
-                            vec![(local.span, String::new()), (retexpr.span, sugg)],
-                            Applicability::MachineApplicable,
-                        );
-                    } else {
-                        err.span_help(initexpr.span, "this expression can be directly returned");
-                    }
-                },
-            );
-        }
-    }
-
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'tcx>,
-        kind: FnKind<'tcx>,
-        _: &'tcx FnDecl<'tcx>,
-        body: &'tcx Body<'tcx>,
-        sp: Span,
-        _: LocalDefId,
-    ) {
-        if sp.from_expansion() {
-            return;
-        }
-
-        match kind {
-            FnKind::Closure => {
-                // when returning without value in closure, replace this `return`
-                // with an empty block to prevent invalid suggestion (see #6501)
-                let replacement = if let ExprKind::Ret(None) = &body.value.kind {
-                    RetReplacement::Block
-                } else {
-                    RetReplacement::Empty
-                };
-                check_final_expr(cx, body.value, vec![], replacement, None);
-            },
-            FnKind::ItemFn(..) | FnKind::Method(..) => {
-                check_block_return(cx, &body.value.kind, sp, vec![]);
-            },
-        }
-    }
-}
-
-// if `expr` is a block, check if there are needless returns in it
-fn check_block_return<'tcx>(cx: &LateContext<'tcx>, expr_kind: &ExprKind<'tcx>, sp: Span, mut semi_spans: Vec<Span>) {
-    if let ExprKind::Block(block, _) = expr_kind {
-        if let Some(block_expr) = block.expr {
-            check_final_expr(cx, block_expr, semi_spans, RetReplacement::Empty, None);
-        } else if let Some(stmt) = block.stmts.iter().last() {
-            match stmt.kind {
-                StmtKind::Expr(expr) => {
-                    check_final_expr(cx, expr, semi_spans, RetReplacement::Empty, None);
-                },
-                StmtKind::Semi(semi_expr) => {
-                    // Remove ending semicolons and any whitespace ' ' in between.
-                    // Without `return`, the suggestion might not compile if the semicolon is retained
-                    if let Some(semi_span) = stmt.span.trim_start(semi_expr.span) {
-                        let semi_span_to_remove =
-                            span_find_starting_semi(cx.sess().source_map(), semi_span.with_hi(sp.hi()));
-                        semi_spans.push(semi_span_to_remove);
-                    }
-                    check_final_expr(cx, semi_expr, semi_spans, RetReplacement::Empty, None);
-                },
-                _ => (),
-            }
-        }
-    }
-}
-
-fn check_final_expr<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx Expr<'tcx>,
-    semi_spans: Vec<Span>, /* containing all the places where we would need to remove semicolons if finding an
-                            * needless return */
-    replacement: RetReplacement<'tcx>,
-    match_ty_opt: Option<Ty<'_>>,
-) {
-    let peeled_drop_expr = expr.peel_drop_temps();
-    match &peeled_drop_expr.kind {
-        // simple return is always "bad"
-        ExprKind::Ret(inner) => {
-            // check if expr return nothing
-            let ret_span = if inner.is_none() && replacement == RetReplacement::Empty {
-                extend_span_to_previous_non_ws(cx, peeled_drop_expr.span)
-            } else {
-                peeled_drop_expr.span
-            };
-
-            let replacement = if let Some(inner_expr) = inner {
-                // if desugar of `do yeet`, don't lint
-                if let ExprKind::Call(path_expr, [_]) = inner_expr.kind
-                    && let ExprKind::Path(QPath::LangItem(LangItem::TryTraitFromYeet, ..)) = path_expr.kind
-                {
-                    return;
-                }
-
-                let mut applicability = Applicability::MachineApplicable;
-                let (snippet, _) = snippet_with_context(cx, inner_expr.span, ret_span.ctxt(), "..", &mut applicability);
-                if binary_expr_needs_parentheses(inner_expr) {
-                    RetReplacement::NeedsPar(snippet, applicability)
-                } else {
-                    RetReplacement::Expr(snippet, applicability)
-                }
-            } else {
-                match match_ty_opt {
-                    Some(match_ty) => {
-                        match match_ty.kind() {
-                            // If the code got till here with
-                            // tuple not getting detected before it,
-                            // then we are sure it's going to be Unit
-                            // type
-                            ty::Tuple(_) => RetReplacement::Unit,
-                            // We don't want to anything in this case
-                            // cause we can't predict what the user would
-                            // want here
-                            _ => return,
-                        }
-                    },
-                    None => replacement,
-                }
-            };
-
-            if inner.is_some_and(|inner| leaks_droppable_temporary_with_limited_lifetime(cx, inner)) {
-                return;
-            }
-
-            if ret_span.from_expansion() || is_from_proc_macro(cx, expr) {
-                return;
-            }
-
-            // 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 separately to
-            // actually fulfill the expectation (clippy::#12998)
-            match cx.tcx.hir_attrs(expr.hir_id) {
-                [] => {},
-                [attr] => {
-                    if matches!(Level::from_attr(attr), Some((Level::Expect, _)))
-                        && let metas = attr.meta_item_list()
-                        && let Some(lst) = metas
-                        && let [MetaItemInner::MetaItem(meta_item), ..] = lst.as_slice()
-                        && let [tool, lint_name] = meta_item.path.segments.as_slice()
-                        && tool.ident.name == sym::clippy
-                        && matches!(
-                            lint_name.ident.name,
-                            sym::needless_return | sym::style | sym::all | sym::warnings
-                        )
-                    {
-                        // This is an expectation of the `needless_return` lint
-                    } else {
-                        return;
-                    }
-                },
-                _ => return,
-            }
-
-            emit_return_lint(
-                cx,
-                peeled_drop_expr.span,
-                ret_span,
-                semi_spans,
-                &replacement,
-                expr.hir_id,
-            );
-        },
-        ExprKind::If(_, then, else_clause_opt) => {
-            check_block_return(cx, &then.kind, peeled_drop_expr.span, semi_spans.clone());
-            if let Some(else_clause) = else_clause_opt {
-                // The `RetReplacement` won't be used there as `else_clause` will be either a block or
-                // a `if` expression.
-                check_final_expr(cx, else_clause, semi_spans, RetReplacement::Empty, match_ty_opt);
-            }
-        },
-        // a match expr, check all arms
-        // an if/if let expr, check both exprs
-        // note, if without else is going to be a type checking error anyways
-        // (except for unit type functions) so we don't match it
-        ExprKind::Match(_, arms, MatchSource::Normal) => {
-            let match_ty = cx.typeck_results().expr_ty(peeled_drop_expr);
-            for arm in *arms {
-                check_final_expr(cx, arm.body, semi_spans.clone(), RetReplacement::Unit, Some(match_ty));
-            }
-        },
-        // if it's a whole block, check it
-        other_expr_kind => check_block_return(cx, other_expr_kind, peeled_drop_expr.span, semi_spans),
-    }
-}
-
-fn emit_return_lint(
-    cx: &LateContext<'_>,
-    lint_span: Span,
-    ret_span: Span,
-    semi_spans: Vec<Span>,
-    replacement: &RetReplacement<'_>,
-    at: HirId,
-) {
-    span_lint_hir_and_then(
-        cx,
-        NEEDLESS_RETURN,
-        at,
-        lint_span,
-        "unneeded `return` statement",
-        |diag| {
-            let suggestions = std::iter::once((ret_span, replacement.to_string()))
-                .chain(semi_spans.into_iter().map(|span| (span, String::new())))
-                .collect();
-
-            diag.multipart_suggestion_verbose(replacement.sugg_help(), suggestions, replacement.applicability());
-        },
-    );
-}
-
-fn last_statement_borrows<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
-    for_each_expr(cx, expr, |e| {
-        if let Some(def_id) = fn_def_id(cx, e)
-            && cx
-                .tcx
-                .fn_sig(def_id)
-                .instantiate_identity()
-                .skip_binder()
-                .output()
-                .walk()
-                .any(|arg| matches!(arg.kind(), GenericArgKind::Lifetime(re) if !re.is_static()))
-        {
-            ControlFlow::Break(())
-        } else {
-            ControlFlow::Continue(())
-        }
-    })
-    .is_some()
-}
-
-// Go backwards while encountering whitespace and extend the given Span to that point.
-fn extend_span_to_previous_non_ws(cx: &LateContext<'_>, sp: Span) -> Span {
-    if let Ok(prev_source) = cx.sess().source_map().span_to_prev_source(sp) {
-        let ws = [b' ', b'\t', b'\n'];
-        if let Some(non_ws_pos) = prev_source.bytes().rposition(|c| !ws.contains(&c)) {
-            let len = prev_source.len() - non_ws_pos - 1;
-            return sp.with_lo(sp.lo() - BytePos::from_usize(len));
-        }
-    }
-
-    sp
-}
diff --git a/clippy_lints/src/returns/let_and_return.rs b/clippy_lints/src/returns/let_and_return.rs
new file mode 100644
index 0000000000000..e2002fb36e5a6
--- /dev/null
+++ b/clippy_lints/src/returns/let_and_return.rs
@@ -0,0 +1,86 @@
+use clippy_utils::diagnostics::span_lint_hir_and_then;
+use clippy_utils::source::SpanRangeExt;
+use clippy_utils::sugg::has_enclosing_paren;
+use clippy_utils::visitors::for_each_expr;
+use clippy_utils::{binary_expr_needs_parentheses, fn_def_id, path_to_local_id, span_contains_cfg};
+use core::ops::ControlFlow;
+use rustc_errors::Applicability;
+use rustc_hir::{Block, Expr, PatKind, StmtKind};
+use rustc_lint::{LateContext, LintContext};
+use rustc_middle::ty::GenericArgKind;
+use rustc_span::edition::Edition;
+
+use super::LET_AND_RETURN;
+
+pub(super) fn check_block<'tcx>(cx: &LateContext<'tcx>, block: &'tcx Block<'_>) {
+    // we need both a let-binding stmt and an expr
+    if let Some(retexpr) = block.expr
+        && let Some(stmt) = block.stmts.last()
+        && let StmtKind::Let(local) = &stmt.kind
+        && local.ty.is_none()
+        && cx.tcx.hir_attrs(local.hir_id).is_empty()
+        && let Some(initexpr) = &local.init
+        && let PatKind::Binding(_, local_id, _, _) = local.pat.kind
+        && path_to_local_id(retexpr, local_id)
+        && (cx.sess().edition() >= Edition::Edition2024 || !last_statement_borrows(cx, initexpr))
+        && !initexpr.span.in_external_macro(cx.sess().source_map())
+        && !retexpr.span.in_external_macro(cx.sess().source_map())
+        && !local.span.from_expansion()
+        && !span_contains_cfg(cx, stmt.span.between(retexpr.span))
+    {
+        span_lint_hir_and_then(
+            cx,
+            LET_AND_RETURN,
+            retexpr.hir_id,
+            retexpr.span,
+            "returning the result of a `let` binding from a block",
+            |err| {
+                err.span_label(local.span, "unnecessary `let` binding");
+
+                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(&src) {
+                            format!("{src} as _")
+                        } else {
+                            format!("({src}) as _")
+                        }
+                    } else {
+                        src.to_owned()
+                    };
+                    err.multipart_suggestion(
+                        "return the expression directly",
+                        vec![(local.span, String::new()), (retexpr.span, sugg)],
+                        Applicability::MachineApplicable,
+                    );
+                } else {
+                    err.span_help(initexpr.span, "this expression can be directly returned");
+                }
+            },
+        );
+    }
+}
+fn last_statement_borrows<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+    for_each_expr(cx, expr, |e| {
+        if let Some(def_id) = fn_def_id(cx, e)
+            && cx
+                .tcx
+                .fn_sig(def_id)
+                .instantiate_identity()
+                .skip_binder()
+                .output()
+                .walk()
+                .any(|arg| matches!(arg.kind(), GenericArgKind::Lifetime(re) if !re.is_static()))
+        {
+            ControlFlow::Break(())
+        } else {
+            ControlFlow::Continue(())
+        }
+    })
+    .is_some()
+}
diff --git a/clippy_lints/src/returns/mod.rs b/clippy_lints/src/returns/mod.rs
new file mode 100644
index 0000000000000..47c6332b9b81d
--- /dev/null
+++ b/clippy_lints/src/returns/mod.rs
@@ -0,0 +1,140 @@
+use rustc_hir::intravisit::FnKind;
+use rustc_hir::{Block, Body, FnDecl, Stmt};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::declare_lint_pass;
+use rustc_span::Span;
+use rustc_span::def_id::LocalDefId;
+
+mod let_and_return;
+mod needless_return;
+mod needless_return_with_question_mark;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `let`-bindings, which are subsequently
+    /// returned.
+    ///
+    /// ### Why is this bad?
+    /// It is just extraneous code. Remove it to make your code
+    /// more rusty.
+    ///
+    /// ### Known problems
+    /// In the case of some temporaries, e.g. locks, eliding the variable binding could lead
+    /// to deadlocks. See [this issue](https://github.com/rust-lang/rust/issues/37612).
+    /// This could become relevant if the code is later changed to use the code that would have been
+    /// bound without first assigning it to a let-binding.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// fn foo() -> String {
+    ///     let x = String::new();
+    ///     x
+    /// }
+    /// ```
+    /// instead, use
+    /// ```no_run
+    /// fn foo() -> String {
+    ///     String::new()
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub LET_AND_RETURN,
+    style,
+    "creating a let-binding and then immediately returning it like `let x = expr; x` at the end of a block"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for return statements at the end of a block.
+    ///
+    /// ### Why is this bad?
+    /// Removing the `return` and semicolon will make the code
+    /// more rusty.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// fn foo(x: usize) -> usize {
+    ///     return x;
+    /// }
+    /// ```
+    /// simplify to
+    /// ```no_run
+    /// fn foo(x: usize) -> usize {
+    ///     x
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub NEEDLESS_RETURN,
+    // This lint requires some special handling in `check_final_expr` for `#[expect]`.
+    // This handling needs to be updated if the group gets changed. This should also
+    // be caught by tests.
+    style,
+    "using a return statement like `return expr;` where an expression would suffice"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for return statements on `Err` paired with the `?` operator.
+    ///
+    /// ### Why is this bad?
+    /// The `return` is unnecessary.
+    ///
+    /// Returns may be used to add attributes to the return expression. Return
+    /// statements with attributes are therefore be accepted by this lint.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// fn foo(x: usize) -> Result<(), Box<dyn Error>> {
+    ///     if x == 0 {
+    ///         return Err(...)?;
+    ///     }
+    ///     Ok(())
+    /// }
+    /// ```
+    /// simplify to
+    /// ```rust,ignore
+    /// fn foo(x: usize) -> Result<(), Box<dyn Error>> {
+    ///     if x == 0 {
+    ///         Err(...)?;
+    ///     }
+    ///     Ok(())
+    /// }
+    /// ```
+    /// if paired with `try_err`, use instead:
+    /// ```rust,ignore
+    /// fn foo(x: usize) -> Result<(), Box<dyn Error>> {
+    ///     if x == 0 {
+    ///         return Err(...);
+    ///     }
+    ///     Ok(())
+    /// }
+    /// ```
+    #[clippy::version = "1.73.0"]
+    pub NEEDLESS_RETURN_WITH_QUESTION_MARK,
+    style,
+    "using a return statement like `return Err(expr)?;` where removing it would suffice"
+}
+
+declare_lint_pass!(Return => [LET_AND_RETURN, NEEDLESS_RETURN, NEEDLESS_RETURN_WITH_QUESTION_MARK]);
+
+impl<'tcx> LateLintPass<'tcx> for Return {
+    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
+        needless_return_with_question_mark::check_stmt(cx, stmt);
+    }
+
+    fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'_>) {
+        let_and_return::check_block(cx, block);
+    }
+
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        kind: FnKind<'tcx>,
+        _: &'tcx FnDecl<'tcx>,
+        body: &'tcx Body<'tcx>,
+        sp: Span,
+        _: LocalDefId,
+    ) {
+        needless_return::check_fn(cx, kind, body, sp);
+    }
+}
diff --git a/clippy_lints/src/returns/needless_return.rs b/clippy_lints/src/returns/needless_return.rs
new file mode 100644
index 0000000000000..04739fc1b22ad
--- /dev/null
+++ b/clippy_lints/src/returns/needless_return.rs
@@ -0,0 +1,269 @@
+use clippy_utils::diagnostics::span_lint_hir_and_then;
+use clippy_utils::source::snippet_with_context;
+use clippy_utils::{
+    binary_expr_needs_parentheses, is_from_proc_macro, leaks_droppable_temporary_with_limited_lifetime,
+    span_contains_cfg, span_find_starting_semi, sym,
+};
+use rustc_ast::MetaItemInner;
+use rustc_errors::Applicability;
+use rustc_hir::intravisit::FnKind;
+use rustc_hir::{Body, Expr, ExprKind, HirId, LangItem, MatchSource, QPath, StmtKind};
+use rustc_lint::{LateContext, Level, LintContext};
+use rustc_middle::ty::{self, Ty};
+use rustc_span::{BytePos, Pos, Span};
+use std::borrow::Cow;
+use std::fmt::Display;
+
+use super::NEEDLESS_RETURN;
+
+#[derive(PartialEq, Eq)]
+enum RetReplacement<'tcx> {
+    Empty,
+    Block,
+    Unit,
+    NeedsPar(Cow<'tcx, str>, Applicability),
+    Expr(Cow<'tcx, str>, Applicability),
+}
+
+impl RetReplacement<'_> {
+    fn sugg_help(&self) -> &'static str {
+        match self {
+            Self::Empty | Self::Expr(..) => "remove `return`",
+            Self::Block => "replace `return` with an empty block",
+            Self::Unit => "replace `return` with a unit value",
+            Self::NeedsPar(..) => "remove `return` and wrap the sequence with parentheses",
+        }
+    }
+
+    fn applicability(&self) -> Applicability {
+        match self {
+            Self::Expr(_, ap) | Self::NeedsPar(_, ap) => *ap,
+            _ => Applicability::MachineApplicable,
+        }
+    }
+}
+
+impl Display for RetReplacement<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Empty => f.write_str(""),
+            Self::Block => f.write_str("{}"),
+            Self::Unit => f.write_str("()"),
+            Self::NeedsPar(inner, _) => write!(f, "({inner})"),
+            Self::Expr(inner, _) => write!(f, "{inner}"),
+        }
+    }
+}
+
+pub(super) fn check_fn<'tcx>(cx: &LateContext<'tcx>, kind: FnKind<'tcx>, body: &'tcx Body<'tcx>, sp: Span) {
+    if sp.from_expansion() {
+        return;
+    }
+
+    match kind {
+        FnKind::Closure => {
+            // when returning without value in closure, replace this `return`
+            // with an empty block to prevent invalid suggestion (see #6501)
+            let replacement = if let ExprKind::Ret(None) = &body.value.kind {
+                RetReplacement::Block
+            } else {
+                RetReplacement::Empty
+            };
+            check_final_expr(cx, body.value, vec![], replacement, None);
+        },
+        FnKind::ItemFn(..) | FnKind::Method(..) => {
+            check_block_return(cx, &body.value.kind, sp, vec![]);
+        },
+    }
+}
+
+// if `expr` is a block, check if there are needless returns in it
+fn check_block_return<'tcx>(cx: &LateContext<'tcx>, expr_kind: &ExprKind<'tcx>, sp: Span, mut semi_spans: Vec<Span>) {
+    if let ExprKind::Block(block, _) = expr_kind {
+        if let Some(block_expr) = block.expr {
+            check_final_expr(cx, block_expr, semi_spans, RetReplacement::Empty, None);
+        } else if let Some(stmt) = block.stmts.last() {
+            if span_contains_cfg(
+                cx,
+                Span::between(
+                    stmt.span,
+                    cx.sess().source_map().end_point(block.span), // the closing brace of the block
+                ),
+            ) {
+                return;
+            }
+            match stmt.kind {
+                StmtKind::Expr(expr) => {
+                    check_final_expr(cx, expr, semi_spans, RetReplacement::Empty, None);
+                },
+                StmtKind::Semi(semi_expr) => {
+                    // Remove ending semicolons and any whitespace ' ' in between.
+                    // Without `return`, the suggestion might not compile if the semicolon is retained
+                    if let Some(semi_span) = stmt.span.trim_start(semi_expr.span) {
+                        let semi_span_to_remove =
+                            span_find_starting_semi(cx.sess().source_map(), semi_span.with_hi(sp.hi()));
+                        semi_spans.push(semi_span_to_remove);
+                    }
+                    check_final_expr(cx, semi_expr, semi_spans, RetReplacement::Empty, None);
+                },
+                _ => (),
+            }
+        }
+    }
+}
+
+fn check_final_expr<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    semi_spans: Vec<Span>, /* containing all the places where we would need to remove semicolons if finding an
+                            * needless return */
+    replacement: RetReplacement<'tcx>,
+    match_ty_opt: Option<Ty<'_>>,
+) {
+    let peeled_drop_expr = expr.peel_drop_temps();
+    match &peeled_drop_expr.kind {
+        // simple return is always "bad"
+        ExprKind::Ret(inner) => {
+            // check if expr return nothing
+            let ret_span = if inner.is_none() && replacement == RetReplacement::Empty {
+                extend_span_to_previous_non_ws(cx, peeled_drop_expr.span)
+            } else {
+                peeled_drop_expr.span
+            };
+
+            let replacement = if let Some(inner_expr) = inner {
+                // if desugar of `do yeet`, don't lint
+                if let ExprKind::Call(path_expr, [_]) = inner_expr.kind
+                    && let ExprKind::Path(QPath::LangItem(LangItem::TryTraitFromYeet, ..)) = path_expr.kind
+                {
+                    return;
+                }
+
+                let mut applicability = Applicability::MachineApplicable;
+                let (snippet, _) = snippet_with_context(cx, inner_expr.span, ret_span.ctxt(), "..", &mut applicability);
+                if binary_expr_needs_parentheses(inner_expr) {
+                    RetReplacement::NeedsPar(snippet, applicability)
+                } else {
+                    RetReplacement::Expr(snippet, applicability)
+                }
+            } else {
+                match match_ty_opt {
+                    Some(match_ty) => {
+                        match match_ty.kind() {
+                            // If the code got till here with
+                            // tuple not getting detected before it,
+                            // then we are sure it's going to be Unit
+                            // type
+                            ty::Tuple(_) => RetReplacement::Unit,
+                            // We don't want to anything in this case
+                            // cause we can't predict what the user would
+                            // want here
+                            _ => return,
+                        }
+                    },
+                    None => replacement,
+                }
+            };
+
+            if inner.is_some_and(|inner| leaks_droppable_temporary_with_limited_lifetime(cx, inner)) {
+                return;
+            }
+
+            if ret_span.from_expansion() || is_from_proc_macro(cx, expr) {
+                return;
+            }
+
+            // 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 separately to
+            // actually fulfill the expectation (clippy::#12998)
+            match cx.tcx.hir_attrs(expr.hir_id) {
+                [] => {},
+                [attr] => {
+                    if matches!(Level::from_attr(attr), Some((Level::Expect, _)))
+                        && let metas = attr.meta_item_list()
+                        && let Some(lst) = metas
+                        && let [MetaItemInner::MetaItem(meta_item), ..] = lst.as_slice()
+                        && let [tool, lint_name] = meta_item.path.segments.as_slice()
+                        && tool.ident.name == sym::clippy
+                        && matches!(
+                            lint_name.ident.name,
+                            sym::needless_return | sym::style | sym::all | sym::warnings
+                        )
+                    {
+                        // This is an expectation of the `needless_return` lint
+                    } else {
+                        return;
+                    }
+                },
+                _ => return,
+            }
+
+            emit_return_lint(
+                cx,
+                peeled_drop_expr.span,
+                ret_span,
+                semi_spans,
+                &replacement,
+                expr.hir_id,
+            );
+        },
+        ExprKind::If(_, then, else_clause_opt) => {
+            check_block_return(cx, &then.kind, peeled_drop_expr.span, semi_spans.clone());
+            if let Some(else_clause) = else_clause_opt {
+                // The `RetReplacement` won't be used there as `else_clause` will be either a block or
+                // a `if` expression.
+                check_final_expr(cx, else_clause, semi_spans, RetReplacement::Empty, match_ty_opt);
+            }
+        },
+        // a match expr, check all arms
+        // an if/if let expr, check both exprs
+        // note, if without else is going to be a type checking error anyways
+        // (except for unit type functions) so we don't match it
+        ExprKind::Match(_, arms, MatchSource::Normal) => {
+            let match_ty = cx.typeck_results().expr_ty(peeled_drop_expr);
+            for arm in *arms {
+                check_final_expr(cx, arm.body, semi_spans.clone(), RetReplacement::Unit, Some(match_ty));
+            }
+        },
+        // if it's a whole block, check it
+        other_expr_kind => check_block_return(cx, other_expr_kind, peeled_drop_expr.span, semi_spans),
+    }
+}
+
+fn emit_return_lint(
+    cx: &LateContext<'_>,
+    lint_span: Span,
+    ret_span: Span,
+    semi_spans: Vec<Span>,
+    replacement: &RetReplacement<'_>,
+    at: HirId,
+) {
+    span_lint_hir_and_then(
+        cx,
+        NEEDLESS_RETURN,
+        at,
+        lint_span,
+        "unneeded `return` statement",
+        |diag| {
+            let suggestions = std::iter::once((ret_span, replacement.to_string()))
+                .chain(semi_spans.into_iter().map(|span| (span, String::new())))
+                .collect();
+
+            diag.multipart_suggestion_verbose(replacement.sugg_help(), suggestions, replacement.applicability());
+        },
+    );
+}
+
+// Go backwards while encountering whitespace and extend the given Span to that point.
+fn extend_span_to_previous_non_ws(cx: &LateContext<'_>, sp: Span) -> Span {
+    if let Ok(prev_source) = cx.sess().source_map().span_to_prev_source(sp) {
+        let ws = [b' ', b'\t', b'\n'];
+        if let Some(non_ws_pos) = prev_source.bytes().rposition(|c| !ws.contains(&c)) {
+            let len = prev_source.len() - non_ws_pos - 1;
+            return sp.with_lo(sp.lo() - BytePos::from_usize(len));
+        }
+    }
+
+    sp
+}
diff --git a/clippy_lints/src/returns/needless_return_with_question_mark.rs b/clippy_lints/src/returns/needless_return_with_question_mark.rs
new file mode 100644
index 0000000000000..c05038cd1e50e
--- /dev/null
+++ b/clippy_lints/src/returns/needless_return_with_question_mark.rs
@@ -0,0 +1,60 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::{is_from_proc_macro, is_inside_let_else, is_res_lang_ctor, path_res};
+use rustc_errors::Applicability;
+use rustc_hir::LangItem::ResultErr;
+use rustc_hir::{ExprKind, HirId, ItemKind, MatchSource, Node, OwnerNode, Stmt, StmtKind};
+use rustc_lint::{LateContext, LintContext};
+use rustc_middle::ty::adjustment::Adjust;
+
+use super::NEEDLESS_RETURN_WITH_QUESTION_MARK;
+
+pub(super) fn check_stmt<'tcx>(cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
+    if !stmt.span.in_external_macro(cx.sess().source_map())
+        && let StmtKind::Semi(expr) = stmt.kind
+        && let ExprKind::Ret(Some(ret)) = expr.kind
+        // return Err(...)? desugars to a match
+        // over a Err(...).branch()
+        // which breaks down to a branch call, with the callee being
+        // the constructor of the Err variant
+        && let ExprKind::Match(maybe_cons, _, MatchSource::TryDesugar(_)) = ret.kind
+        && let ExprKind::Call(_, [maybe_result_err]) = maybe_cons.kind
+        && let ExprKind::Call(maybe_constr, _) = maybe_result_err.kind
+        && is_res_lang_ctor(cx, path_res(cx, maybe_constr), ResultErr)
+
+        // Ensure this is not the final stmt, otherwise removing it would cause a compile error
+        && let OwnerNode::Item(item) = cx.tcx.hir_owner_node(cx.tcx.hir_get_parent_item(expr.hir_id))
+        && let ItemKind::Fn { body, .. } = item.kind
+        && let block = cx.tcx.hir_body(body).value
+        && let ExprKind::Block(block, _) = block.kind
+        && !is_inside_let_else(cx.tcx, expr)
+        && let [.., final_stmt] = block.stmts
+        && final_stmt.hir_id != stmt.hir_id
+        && !is_from_proc_macro(cx, expr)
+        && !stmt_needs_never_type(cx, stmt.hir_id)
+    {
+        span_lint_and_sugg(
+            cx,
+            NEEDLESS_RETURN_WITH_QUESTION_MARK,
+            expr.span.until(ret.span),
+            "unneeded `return` statement with `?` operator",
+            "remove it",
+            String::new(),
+            Applicability::MachineApplicable,
+        );
+    }
+}
+
+/// Checks if a return statement is "needed" in the middle of a block, or if it can be removed.
+/// This is the case when the enclosing block expression is coerced to some other type,
+/// which only works because of the never-ness of `return` expressions
+fn stmt_needs_never_type(cx: &LateContext<'_>, stmt_hir_id: HirId) -> bool {
+    cx.tcx
+        .hir_parent_iter(stmt_hir_id)
+        .find_map(|(_, node)| if let Node::Expr(expr) = node { Some(expr) } else { None })
+        .is_some_and(|e| {
+            cx.typeck_results()
+                .expr_adjustments(e)
+                .iter()
+                .any(|adjust| adjust.target != cx.tcx.types.unit && matches!(adjust.kind, Adjust::NeverToAny))
+        })
+}
diff --git a/clippy_lints/src/semicolon_block.rs b/clippy_lints/src/semicolon_block.rs
index 1dea8f17c34be..371d62a068492 100644
--- a/clippy_lints/src/semicolon_block.rs
+++ b/clippy_lints/src/semicolon_block.rs
@@ -1,5 +1,6 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::SpanRangeExt;
 use rustc_errors::Applicability;
 use rustc_hir::{Block, Expr, ExprKind, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -82,6 +83,19 @@ impl SemicolonBlock {
         let insert_span = tail.span.source_callsite().shrink_to_hi();
         let remove_span = semi_span.with_lo(block.span.hi());
 
+        // If the block is surrounded by parens (`({ 0 });`), the author probably knows what
+        // they're doing and why, so don't get in their way.
+        //
+        // This has the additional benefit of stopping the block being parsed as a function call:
+        // ```
+        // fn foo() {
+        //     ({ 0 }); // if we remove this `;`, this will parse as a `({ 0 })(5);` function call
+        //     (5);
+        // }
+        if remove_span.check_source_text(cx, |src| src.contains(')')) {
+            return;
+        }
+
         if self.semicolon_inside_block_ignore_singleline && get_line(cx, remove_span) == get_line(cx, insert_span) {
             return;
         }
diff --git a/clippy_lints/src/size_of_ref.rs b/clippy_lints/src/size_of_ref.rs
index 60d923bcd77e7..606e852aae9e3 100644
--- a/clippy_lints/src/size_of_ref.rs
+++ b/clippy_lints/src/size_of_ref.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::{path_def_id, peel_middle_ty_refs};
+use clippy_utils::path_def_id;
+use clippy_utils::ty::peel_and_count_ty_refs;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
@@ -59,7 +60,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_middle_ty_refs(arg_ty).1 > 1
+            && peel_and_count_ty_refs(arg_ty).1 > 1
         {
             span_lint_and_help(
                 cx,
diff --git a/clippy_lints/src/toplevel_ref_arg.rs b/clippy_lints/src/toplevel_ref_arg.rs
new file mode 100644
index 0000000000000..074b79263d377
--- /dev/null
+++ b/clippy_lints/src/toplevel_ref_arg.rs
@@ -0,0 +1,119 @@
+use clippy_utils::diagnostics::{span_lint_hir, span_lint_hir_and_then};
+use clippy_utils::source::{snippet, snippet_with_context};
+use clippy_utils::sugg::Sugg;
+use clippy_utils::{is_lint_allowed, iter_input_pats};
+use rustc_errors::Applicability;
+use rustc_hir::intravisit::FnKind;
+use rustc_hir::{BindingMode, Body, ByRef, FnDecl, Mutability, PatKind, Stmt, StmtKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::declare_lint_pass;
+use rustc_span::Span;
+use rustc_span::def_id::LocalDefId;
+
+use crate::ref_patterns::REF_PATTERNS;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for function arguments and let bindings denoted as
+    /// `ref`.
+    ///
+    /// ### Why is this bad?
+    /// The `ref` declaration makes the function take an owned
+    /// value, but turns the argument into a reference (which means that the value
+    /// is destroyed when exiting the function). This adds not much value: either
+    /// take a reference type, or take an owned value and create references in the
+    /// body.
+    ///
+    /// For let bindings, `let x = &foo;` is preferred over `let ref x = foo`. The
+    /// type of `x` is more obvious with the former.
+    ///
+    /// ### Known problems
+    /// If the argument is dereferenced within the function,
+    /// removing the `ref` will lead to errors. This can be fixed by removing the
+    /// dereferences, e.g., changing `*x` to `x` within the function.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// fn foo(ref _x: u8) {}
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// fn foo(_x: &u8) {}
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub TOPLEVEL_REF_ARG,
+    style,
+    "an entire binding declared as `ref`, in a function argument or a `let` statement"
+}
+
+declare_lint_pass!(ToplevelRefArg => [TOPLEVEL_REF_ARG]);
+
+impl<'tcx> LateLintPass<'tcx> for ToplevelRefArg {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        k: FnKind<'tcx>,
+        decl: &'tcx FnDecl<'_>,
+        body: &'tcx Body<'_>,
+        _: Span,
+        _: LocalDefId,
+    ) {
+        if !matches!(k, FnKind::Closure) {
+            for arg in iter_input_pats(decl, body) {
+                if let PatKind::Binding(BindingMode(ByRef::Yes(_), _), ..) = arg.pat.kind
+                    && is_lint_allowed(cx, REF_PATTERNS, arg.pat.hir_id)
+                    && !arg.span.in_external_macro(cx.tcx.sess.source_map())
+                {
+                    span_lint_hir(
+                        cx,
+                        TOPLEVEL_REF_ARG,
+                        arg.hir_id,
+                        arg.pat.span,
+                        "`ref` directly on a function parameter does not prevent taking ownership of the passed argument. \
+                            Consider using a reference type instead",
+                    );
+                }
+            }
+        }
+    }
+
+    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
+        if let StmtKind::Let(local) = stmt.kind
+            && let PatKind::Binding(BindingMode(ByRef::Yes(mutabl), _), .., name, None) = local.pat.kind
+            && let Some(init) = local.init
+            // Do not emit if clippy::ref_patterns is not allowed to avoid having two lints for the same issue.
+            && is_lint_allowed(cx, REF_PATTERNS, local.pat.hir_id)
+            && !stmt.span.in_external_macro(cx.tcx.sess.source_map())
+        {
+            let ctxt = local.span.ctxt();
+            let mut app = Applicability::MachineApplicable;
+            let sugg_init = Sugg::hir_with_context(cx, init, ctxt, "..", &mut app);
+            let (mutopt, initref) = match mutabl {
+                Mutability::Mut => ("mut ", sugg_init.mut_addr()),
+                Mutability::Not => ("", sugg_init.addr()),
+            };
+            let tyopt = if let Some(ty) = local.ty {
+                let ty_snip = snippet_with_context(cx, ty.span, ctxt, "_", &mut app).0;
+                format!(": &{mutopt}{ty_snip}")
+            } else {
+                String::new()
+            };
+            span_lint_hir_and_then(
+                cx,
+                TOPLEVEL_REF_ARG,
+                init.hir_id,
+                local.pat.span,
+                "`ref` on an entire `let` pattern is discouraged, take a reference with `&` instead",
+                |diag| {
+                    diag.span_suggestion(
+                        stmt.span,
+                        "try",
+                        format!("let {name}{tyopt} = {initref};", name = snippet(cx, name.span, ".."),),
+                        app,
+                    );
+                },
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/transmute/transmute_ptr_to_ref.rs b/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
index e58212fae15cf..e67ab6a73d269 100644
--- a/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
+++ b/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
@@ -28,16 +28,27 @@ pub(super) fn check<'tcx>(
                 format!("transmute from a pointer type (`{from_ty}`) to a reference type (`{to_ty}`)"),
                 |diag| {
                     let arg = sugg::Sugg::hir(cx, arg, "..");
-                    let (deref, cast) = if *mutbl == Mutability::Mut {
-                        ("&mut *", "*mut")
-                    } else {
-                        ("&*", "*const")
+                    let (deref, cast) = match mutbl {
+                        Mutability::Mut => ("&mut *", "*mut"),
+                        Mutability::Not => ("&*", "*const"),
                     };
                     let mut app = Applicability::MachineApplicable;
 
                     let sugg = if let Some(ty) = get_explicit_type(path) {
                         let ty_snip = snippet_with_applicability(cx, ty.span, "..", &mut app);
-                        if msrv.meets(cx, msrvs::POINTER_CAST) {
+                        if !to_ref_ty.is_sized(cx.tcx, cx.typing_env()) {
+                            // We can't suggest `.cast()`, because that requires `to_ref_ty` to be Sized.
+                            if from_ptr_ty.has_erased_regions() {
+                                // We can't suggest `as *mut/const () as *mut/const to_ref_ty`, because the former is a
+                                // thin pointer, whereas the latter is a wide pointer, due of its pointee, `to_ref_ty`,
+                                // being !Sized.
+                                //
+                                // The only remaining option is be to skip `*mut/const ()`, but that might not be safe
+                                // to do because of the erased regions in `from_ptr_ty`, so reduce the applicability.
+                                app = Applicability::MaybeIncorrect;
+                            }
+                            sugg::make_unop(deref, arg.as_ty(format!("{cast} {ty_snip}"))).to_string()
+                        } else if msrv.meets(cx, msrvs::POINTER_CAST) {
                             format!("{deref}{}.cast::<{ty_snip}>()", arg.maybe_paren())
                         } else if from_ptr_ty.has_erased_regions() {
                             sugg::make_unop(deref, arg.as_ty(format!("{cast} () as {cast} {ty_snip}"))).to_string()
@@ -45,15 +56,22 @@ pub(super) fn check<'tcx>(
                             sugg::make_unop(deref, arg.as_ty(format!("{cast} {ty_snip}"))).to_string()
                         }
                     } else if *from_ptr_ty == *to_ref_ty {
-                        if from_ptr_ty.has_erased_regions() {
-                            if msrv.meets(cx, msrvs::POINTER_CAST) {
-                                format!("{deref}{}.cast::<{to_ref_ty}>()", arg.maybe_paren())
-                            } else {
-                                sugg::make_unop(deref, arg.as_ty(format!("{cast} () as {cast} {to_ref_ty}")))
-                                    .to_string()
-                            }
-                        } else {
+                        if !from_ptr_ty.has_erased_regions() {
                             sugg::make_unop(deref, arg).to_string()
+                        } else if !to_ref_ty.is_sized(cx.tcx, cx.typing_env()) {
+                            // 1. We can't suggest `.cast()`, because that requires `to_ref_ty` to be Sized.
+                            // 2. We can't suggest `as *mut/const () as *mut/const to_ref_ty`, because the former is a
+                            //    thin pointer, whereas the latter is a wide pointer, due of its pointee, `to_ref_ty`,
+                            //    being !Sized.
+                            //
+                            // The only remaining option is be to skip `*mut/const ()`, but that might not be safe to do
+                            // because of the erased regions in `from_ptr_ty`, so reduce the applicability.
+                            app = Applicability::MaybeIncorrect;
+                            sugg::make_unop(deref, arg.as_ty(format!("{cast} {to_ref_ty}"))).to_string()
+                        } else if msrv.meets(cx, msrvs::POINTER_CAST) {
+                            format!("{deref}{}.cast::<{to_ref_ty}>()", arg.maybe_paren())
+                        } else {
+                            sugg::make_unop(deref, arg.as_ty(format!("{cast} () as {cast} {to_ref_ty}"))).to_string()
                         }
                     } else {
                         sugg::make_unop(deref, arg.as_ty(format!("{cast} {to_ref_ty}"))).to_string()
diff --git a/clippy_lints/src/transmute/transmute_ref_to_ref.rs b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
index 6aeb22d41a7d7..70c2a73ce6ef2 100644
--- a/clippy_lints/src/transmute/transmute_ref_to_ref.rs
+++ b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
@@ -45,7 +45,9 @@ pub(super) fn check<'tcx>(
                 Applicability::MaybeIncorrect,
             );
             triggered = true;
-        } else if (cx.tcx.erase_and_anonymize_regions(from_ty) != cx.tcx.erase_and_anonymize_regions(to_ty)) && !const_context {
+        } else if (cx.tcx.erase_and_anonymize_regions(from_ty) != cx.tcx.erase_and_anonymize_regions(to_ty))
+            && !const_context
+        {
             span_lint_and_then(
                 cx,
                 TRANSMUTE_PTR_TO_PTR,
diff --git a/clippy_lints/src/uninit_vec.rs b/clippy_lints/src/uninit_vec.rs
index cee4a53f03cbe..51116b5eba9e1 100644
--- a/clippy_lints/src/uninit_vec.rs
+++ b/clippy_lints/src/uninit_vec.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::higher::{VecInitKind, get_vec_init_kind};
 use clippy_utils::ty::{is_type_diagnostic_item, is_uninit_value_valid_for_ty};
 use clippy_utils::{SpanlessEq, is_integer_literal, is_lint_allowed, path_to_local_id, peel_hir_expr_while, sym};
@@ -95,16 +95,13 @@ fn handle_uninit_vec_pair<'tcx>(
 
             // Check T of Vec<T>
             if !is_uninit_value_valid_for_ty(cx, args.type_at(0)) {
-                // FIXME: #7698, false positive of the internal lints
-                #[expect(clippy::collapsible_span_lint_calls)]
-                span_lint_and_then(
+                span_lint_and_help(
                     cx,
                     UNINIT_VEC,
                     vec![call_span, maybe_init_or_reserve.span],
                     "calling `set_len()` immediately after reserving a buffer creates uninitialized values",
-                    |diag| {
-                        diag.help("initialize the buffer or wrap the content in `MaybeUninit`");
-                    },
+                    None,
+                    "initialize the buffer or wrap the content in `MaybeUninit`",
                 );
             }
         } else {
diff --git a/clippy_lints/src/unused_peekable.rs b/clippy_lints/src/unused_peekable.rs
index 1f5351e32aacf..5224b62e9fc71 100644
--- a/clippy_lints/src/unused_peekable.rs
+++ b/clippy_lints/src/unused_peekable.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_hir_and_then;
-use clippy_utils::ty::{is_type_diagnostic_item, peel_mid_ty_refs_is_mutable};
+use clippy_utils::ty::{is_type_diagnostic_item, peel_and_count_ty_refs};
 use clippy_utils::{fn_def_id, is_trait_method, path_to_local_id, peel_ref_operators, sym};
 use rustc_ast::Mutability;
 use rustc_hir::intravisit::{Visitor, walk_expr};
@@ -61,7 +61,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedPeekable {
                 && let Some(init) = local.init
                 && !init.span.from_expansion()
                 && let Some(ty) = cx.typeck_results().expr_ty_opt(init)
-                && let (ty, _, Mutability::Mut) = peel_mid_ty_refs_is_mutable(ty)
+                && let (ty, _, None | Some(Mutability::Mut)) = peel_and_count_ty_refs(ty)
                 && is_type_diagnostic_item(cx, ty, sym::IterPeekable)
             {
                 let mut vis = PeekableVisitor::new(cx, binding);
@@ -211,7 +211,7 @@ impl<'tcx> Visitor<'tcx> for PeekableVisitor<'_, 'tcx> {
 
 fn arg_is_mut_peekable(cx: &LateContext<'_>, arg: &Expr<'_>) -> bool {
     if let Some(ty) = cx.typeck_results().expr_ty_opt(arg)
-        && let (ty, _, Mutability::Mut) = peel_mid_ty_refs_is_mutable(ty)
+        && let (ty, _, None | Some(Mutability::Mut)) = peel_and_count_ty_refs(ty)
         && is_type_diagnostic_item(cx, ty, sym::IterPeekable)
     {
         true
diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index 490da4f1e037a..34dfe5b6546fa 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -292,6 +292,7 @@ impl<'tcx> Visitor<'tcx> for UnwrappableVariablesVisitor<'_, 'tcx> {
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
         // Shouldn't lint when `expr` is in macro.
         if expr.span.in_external_macro(self.cx.tcx.sess.source_map()) {
+            walk_expr(self, expr);
             return;
         }
         // Skip checking inside closures since they are visited through `Unwrap::check_fn()` already.
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 8252e6d48694b..9d5be922f43f8 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -2,20 +2,21 @@ use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::is_from_proc_macro;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::ty::{same_type_and_consts, ty_from_hir_ty};
+use clippy_utils::ty::{same_type_modulo_regions, ty_from_hir_ty};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir::def::{CtorOf, DefKind, Res};
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::intravisit::{InferKind, Visitor, VisitorExt, walk_ty};
 use rustc_hir::{
-    self as hir, AmbigArg, Expr, ExprKind, FnRetTy, FnSig, GenericArgsParentheses, GenericParam, GenericParamKind,
-    HirId, Impl, ImplItemKind, Item, ItemKind, Pat, PatExpr, PatExprKind, PatKind, Path, QPath, Ty, TyKind,
+    self as hir, AmbigArg, Expr, ExprKind, FnRetTy, FnSig, GenericArgsParentheses, GenericParamKind, HirId, Impl,
+    ImplItemKind, Item, ItemKind, Pat, PatExpr, PatExprKind, PatKind, Path, QPath, Ty, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Ty as MiddleTy;
 use rustc_session::impl_lint_pass;
 use rustc_span::Span;
+use std::iter;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -101,17 +102,11 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
             let types_to_skip = generics
                 .params
                 .iter()
-                .filter_map(|param| match param {
-                    GenericParam {
-                        kind:
-                            GenericParamKind::Const {
-                                ty: Ty { hir_id, .. }, ..
-                            },
-                        ..
-                    } => Some(*hir_id),
+                .filter_map(|param| match param.kind {
+                    GenericParamKind::Const { ty, .. } => Some(ty.hir_id),
                     _ => None,
                 })
-                .chain(std::iter::once(self_ty.hir_id))
+                .chain([self_ty.hir_id])
                 .collect();
             StackItem::Check {
                 impl_id: item.owner_id.def_id,
@@ -209,11 +204,11 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
             && !types_to_skip.contains(&hir_ty.hir_id)
             && let ty = ty_from_hir_ty(cx, hir_ty.as_unambig_ty())
             && let impl_ty = cx.tcx.type_of(impl_id).instantiate_identity()
-            && same_type_and_consts(ty, impl_ty)
+            && same_type_modulo_regions(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 elided (`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))
+            && same_lifetimes(ty, impl_ty)
             && self.msrv.meets(cx, msrvs::TYPE_ALIAS_ENUM_VARIANTS)
         {
             span_lint(cx, hir_ty.span);
@@ -226,18 +221,16 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
             && cx.typeck_results().expr_ty(expr) == cx.tcx.type_of(impl_id).instantiate_identity()
             && self.msrv.meets(cx, msrvs::TYPE_ALIAS_ENUM_VARIANTS)
         {
-        } else {
-            return;
-        }
-        match expr.kind {
-            ExprKind::Struct(QPath::Resolved(_, path), ..) => check_path(cx, path),
-            ExprKind::Call(fun, _) => {
-                if let ExprKind::Path(QPath::Resolved(_, path)) = fun.kind {
-                    check_path(cx, path);
-                }
-            },
-            ExprKind::Path(QPath::Resolved(_, path)) => check_path(cx, path),
-            _ => (),
+            match expr.kind {
+                ExprKind::Struct(QPath::Resolved(_, path), ..) => check_path(cx, path),
+                ExprKind::Call(fun, _) => {
+                    if let ExprKind::Path(QPath::Resolved(_, path)) = fun.kind {
+                        check_path(cx, path);
+                    }
+                },
+                ExprKind::Path(QPath::Resolved(_, path)) => check_path(cx, path),
+                _ => (),
+            }
         }
     }
 
@@ -307,36 +300,20 @@ fn lint_path_to_variant(cx: &LateContext<'_>, path: &Path<'_>) {
     }
 }
 
-/// Returns `true` if types `a` and `b` have the same lifetime parameters, otherwise returns
-/// `false`.
+/// Checks whether types `a` and `b` have the same lifetime parameters.
 ///
 /// This function does not check that types `a` and `b` are the same types.
 fn same_lifetimes<'tcx>(a: MiddleTy<'tcx>, b: MiddleTy<'tcx>) -> bool {
     use rustc_middle::ty::{Adt, GenericArgKind};
-    match (&a.kind(), &b.kind()) {
-        (&Adt(_, args_a), &Adt(_, args_b)) => {
-            args_a
-                .iter()
-                .zip(args_b.iter())
-                .all(|(arg_a, arg_b)| match (arg_a.kind(), arg_b.kind()) {
-                    // TODO: Handle inferred lifetimes
-                    (GenericArgKind::Lifetime(inner_a), GenericArgKind::Lifetime(inner_b)) => inner_a == inner_b,
-                    (GenericArgKind::Type(type_a), GenericArgKind::Type(type_b)) => same_lifetimes(type_a, type_b),
-                    _ => true,
-                })
+    match (a.kind(), b.kind()) {
+        (Adt(_, args_a), Adt(_, args_b)) => {
+            iter::zip(*args_a, *args_b).all(|(arg_a, arg_b)| match (arg_a.kind(), arg_b.kind()) {
+                // TODO: Handle inferred lifetimes
+                (GenericArgKind::Lifetime(inner_a), GenericArgKind::Lifetime(inner_b)) => inner_a == inner_b,
+                (GenericArgKind::Type(type_a), GenericArgKind::Type(type_b)) => same_lifetimes(type_a, type_b),
+                _ => true,
+            })
         },
         _ => a == b,
     }
 }
-
-/// Returns `true` if `ty` has no lifetime parameter, otherwise returns `false`.
-fn has_no_lifetime(ty: MiddleTy<'_>) -> bool {
-    use rustc_middle::ty::{Adt, GenericArgKind};
-    match ty.kind() {
-        &Adt(_, args) => !args
-            .iter()
-            // TODO: Handle inferred lifetimes
-            .any(|arg| matches!(arg.kind(), GenericArgKind::Lifetime(..))),
-        _ => true,
-    }
-}
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index e45f884cfcbcf..1b137017ecb46 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_with_context};
 use clippy_utils::sugg::{DiagExt as _, Sugg};
-use clippy_utils::ty::{get_type_diagnostic_name, is_copy, is_type_diagnostic_item, same_type_and_consts};
+use clippy_utils::ty::{get_type_diagnostic_name, is_copy, is_type_diagnostic_item, same_type_modulo_regions};
 use clippy_utils::{
     get_parent_expr, is_inherent_method_call, is_trait_item, is_trait_method, is_ty_alias, path_to_local, sym,
 };
@@ -184,7 +184,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                     && (is_trait_item(cx, arg, sym::Into) || is_trait_item(cx, arg, sym::From))
                     && let ty::FnDef(_, args) = cx.typeck_results().expr_ty(arg).kind()
                     && let &[from_ty, to_ty] = args.into_type_list(cx.tcx).as_slice()
-                    && same_type_and_consts(from_ty, to_ty)
+                    && same_type_modulo_regions(from_ty, to_ty)
                 {
                     span_lint_and_then(
                         cx,
@@ -207,7 +207,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                 if is_trait_method(cx, e, sym::Into) && name.ident.name == sym::into {
                     let a = cx.typeck_results().expr_ty(e);
                     let b = cx.typeck_results().expr_ty(recv);
-                    if same_type_and_consts(a, b) {
+                    if same_type_modulo_regions(a, b) {
                         let mut app = Applicability::MachineApplicable;
                         let sugg = snippet_with_context(cx, recv.span, e.span.ctxt(), "<expr>", &mut app).0;
                         span_lint_and_sugg(
@@ -324,7 +324,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                     // If the types are identical then .into_iter() can be removed, unless the type
                     // implements Copy, in which case .into_iter() returns a copy of the receiver and
                     // cannot be safely omitted.
-                    if same_type_and_consts(a, b) && !is_copy(cx, b) {
+                    if same_type_modulo_regions(a, b) && !is_copy(cx, b) {
                         // Below we check if the parent method call meets the following conditions:
                         // 1. First parameter is `&mut self` (requires mutable reference)
                         // 2. Second parameter implements the `FnMut` trait (e.g., Iterator::any)
@@ -371,7 +371,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                     && is_type_diagnostic_item(cx, a, sym::Result)
                     && let ty::Adt(_, args) = a.kind()
                     && let Some(a_type) = args.types().next()
-                    && same_type_and_consts(a_type, b)
+                    && same_type_modulo_regions(a_type, b)
                 {
                     span_lint_and_help(
                         cx,
@@ -396,7 +396,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                         && is_type_diagnostic_item(cx, a, sym::Result)
                         && let ty::Adt(_, args) = a.kind()
                         && let Some(a_type) = args.types().next()
-                        && same_type_and_consts(a_type, b)
+                        && same_type_modulo_regions(a_type, b)
                     {
                         let hint = format!("consider removing `{}()`", snippet(cx, path.span, "TryFrom::try_from"));
                         span_lint_and_help(
@@ -407,7 +407,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                             None,
                             hint,
                         );
-                    } else if name == sym::from_fn && same_type_and_consts(a, b) {
+                    } else if name == sym::from_fn && same_type_modulo_regions(a, b) {
                         let mut app = Applicability::MachineApplicable;
                         let sugg = Sugg::hir_with_context(cx, arg, e.span.ctxt(), "<expr>", &mut app).maybe_paren();
                         let sugg_msg = format!("consider removing `{}()`", snippet(cx, path.span, "From::from"));
diff --git a/clippy_utils/Cargo.toml b/clippy_utils/Cargo.toml
index bdf7431f29f29..d58b47bf6deb3 100644
--- a/clippy_utils/Cargo.toml
+++ b/clippy_utils/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "clippy_utils"
-version = "0.1.91"
+version = "0.1.92"
 edition = "2024"
 description = "Helpful tools for writing lints, provided as they are used in Clippy"
 repository = "https://github.com/rust-lang/rust-clippy"
diff --git a/clippy_utils/README.md b/clippy_utils/README.md
index e01f563c49e73..2c66fdc73f539 100644
--- a/clippy_utils/README.md
+++ b/clippy_utils/README.md
@@ -8,7 +8,7 @@ This crate is only guaranteed to build with this `nightly` toolchain:
 
 <!-- begin autogenerated nightly -->
 ```
-nightly-2025-09-04
+nightly-2025-09-18
 ```
 <!-- end autogenerated nightly -->
 
diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index 1a25c90d735e4..948a7203402d5 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -13,20 +13,24 @@
 //! if the span is not from a `macro_rules` based macro.
 
 use rustc_abi::ExternAbi;
+use rustc_ast as ast;
 use rustc_ast::AttrStyle;
-use rustc_ast::ast::{AttrKind, Attribute, IntTy, LitIntType, LitKind, StrStyle, TraitObjectSyntax, UintTy};
+use rustc_ast::ast::{
+    AttrKind, Attribute, GenericArgs, IntTy, LitIntType, LitKind, StrStyle, TraitObjectSyntax, UintTy,
+};
 use rustc_ast::token::CommentKind;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
     Block, BlockCheckMode, Body, Closure, Destination, Expr, ExprKind, FieldDef, FnHeader, FnRetTy, HirId, Impl,
-    ImplItem, ImplItemImplKind, ImplItemKind, IsAuto, Item, ItemKind, Lit, LoopSource, MatchSource, MutTy, Node, Path, QPath, Safety,
-    TraitImplHeader, TraitItem, TraitItemKind, Ty, TyKind, UnOp, UnsafeSource, Variant, VariantData, YieldSource,
+    ImplItem, ImplItemImplKind, ImplItemKind, IsAuto, Item, ItemKind, Lit, LoopSource, MatchSource, MutTy, Node, Path,
+    QPath, Safety, TraitImplHeader, TraitItem, TraitItemKind, Ty, TyKind, UnOp, UnsafeSource, Variant, VariantData,
+    YieldSource,
 };
 use rustc_lint::{EarlyContext, LateContext, LintContext};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Session;
 use rustc_span::symbol::{Ident, kw};
-use rustc_span::{Span, Symbol};
+use rustc_span::{Span, Symbol, sym};
 
 /// The search pattern to look for. Used by `span_matches_pat`
 #[derive(Clone)]
@@ -289,7 +293,7 @@ fn impl_item_search_pat(item: &ImplItem<'_>) -> (Pat, Pat) {
         && !vis_span.is_empty()
     {
         start_pat = Pat::Str("pub");
-    };
+    }
     (start_pat, end_pat)
 }
 
@@ -321,14 +325,17 @@ fn fn_kind_pat(tcx: TyCtxt<'_>, kind: &FnKind<'_>, body: &Body<'_>, hir_id: HirI
     };
     match tcx.hir_node(hir_id) {
         Node::Item(Item { vis_span, .. })
-        | Node::ImplItem(ImplItem { impl_kind: ImplItemImplKind::Inherent { vis_span, .. }, .. }) => {
+        | Node::ImplItem(ImplItem {
+            impl_kind: ImplItemImplKind::Inherent { vis_span, .. },
+            ..
+        }) => {
             if !vis_span.is_empty() {
-                start_pat = Pat::Str("pub")
+                start_pat = Pat::Str("pub");
             }
         },
         Node::ImplItem(_) | Node::TraitItem(_) => {},
         _ => start_pat = Pat::Str(""),
-    };
+    }
     (start_pat, end_pat)
 }
 
@@ -403,6 +410,7 @@ fn ty_search_pat(ty: &Ty<'_>) -> (Pat, Pat) {
         TyKind::OpaqueDef(..) => (Pat::Str("impl"), Pat::Str("")),
         TyKind::Path(qpath) => qpath_search_pat(&qpath),
         TyKind::Infer(()) => (Pat::Str("_"), Pat::Str("_")),
+        TyKind::UnsafeBinder(binder_ty) => (Pat::Str("unsafe"), ty_search_pat(binder_ty.inner_ty).1),
         TyKind::TraitObject(_, tagged_ptr) if let TraitObjectSyntax::Dyn = tagged_ptr.tag() => {
             (Pat::Str("dyn"), Pat::Str(""))
         },
@@ -411,6 +419,127 @@ fn ty_search_pat(ty: &Ty<'_>) -> (Pat, Pat) {
     }
 }
 
+fn ast_ty_search_pat(ty: &ast::Ty) -> (Pat, Pat) {
+    use ast::{Extern, FnRetTy, MutTy, Safety, TraitObjectSyntax, TyKind};
+
+    match &ty.kind {
+        TyKind::Slice(..) | TyKind::Array(..) => (Pat::Str("["), Pat::Str("]")),
+        TyKind::Ptr(MutTy { ty, .. }) => (Pat::Str("*"), ast_ty_search_pat(ty).1),
+        TyKind::Ref(_, MutTy { ty, .. }) | TyKind::PinnedRef(_, MutTy { ty, .. }) => {
+            (Pat::Str("&"), ast_ty_search_pat(ty).1)
+        },
+        TyKind::FnPtr(fn_ptr) => (
+            if let Safety::Unsafe(_) = fn_ptr.safety {
+                Pat::Str("unsafe")
+            } else if let Extern::Explicit(strlit, _) = fn_ptr.ext
+                && strlit.symbol == sym::rust
+            {
+                Pat::MultiStr(&["fn", "extern"])
+            } else {
+                Pat::Str("extern")
+            },
+            match &fn_ptr.decl.output {
+                FnRetTy::Default(_) => {
+                    if let [.., param] = &*fn_ptr.decl.inputs {
+                        ast_ty_search_pat(&param.ty).1
+                    } else {
+                        Pat::Str("(")
+                    }
+                },
+                FnRetTy::Ty(ty) => ast_ty_search_pat(ty).1,
+            },
+        ),
+        TyKind::Never => (Pat::Str("!"), Pat::Str("!")),
+        // Parenthesis are trimmed from the text before the search patterns are matched.
+        // See: `span_matches_pat`
+        TyKind::Tup(tup) => match &**tup {
+            [] => (Pat::Str(")"), Pat::Str("(")),
+            [ty] => ast_ty_search_pat(ty),
+            [head, .., tail] => (ast_ty_search_pat(head).0, ast_ty_search_pat(tail).1),
+        },
+        TyKind::ImplTrait(..) => (Pat::Str("impl"), Pat::Str("")),
+        TyKind::Path(qself_path, path) => {
+            let start = if qself_path.is_some() {
+                Pat::Str("<")
+            } else if let Some(first) = path.segments.first() {
+                ident_search_pat(first.ident).0
+            } else {
+                // this shouldn't be possible, but sure
+                Pat::Str("")
+            };
+            let end = if let Some(last) = path.segments.last() {
+                match last.args.as_deref() {
+                    // last `>` in `std::foo::Bar<T>`
+                    Some(GenericArgs::AngleBracketed(_)) => Pat::Str(">"),
+                    Some(GenericArgs::Parenthesized(par_args)) => match &par_args.output {
+                        FnRetTy::Default(_) => {
+                            if let Some(last) = par_args.inputs.last() {
+                                // `B` in `(A, B)` -- `)` gets stripped
+                                ast_ty_search_pat(last).1
+                            } else {
+                                // `(` in `()` -- `)` gets stripped
+                                Pat::Str("(")
+                            }
+                        },
+                        // `C` in `(A, B) -> C`
+                        FnRetTy::Ty(ty) => ast_ty_search_pat(ty).1,
+                    },
+                    // last `..` in `(..)` -- `)` gets stripped
+                    Some(GenericArgs::ParenthesizedElided(_)) => Pat::Str(".."),
+                    // `bar` in `std::foo::bar`
+                    None => ident_search_pat(last.ident).1,
+                }
+            } else {
+                // this shouldn't be possible, but sure
+                #[allow(
+                    clippy::collapsible_else_if,
+                    reason = "we want to keep these cases together, since they are both impossible"
+                )]
+                if qself_path.is_some() {
+                    // last `>` in `<Vec as IntoIterator>`
+                    Pat::Str(">")
+                } else {
+                    Pat::Str("")
+                }
+            };
+            (start, end)
+        },
+        TyKind::Infer => (Pat::Str("_"), Pat::Str("_")),
+        TyKind::Paren(ty) => ast_ty_search_pat(ty),
+        TyKind::UnsafeBinder(binder_ty) => (Pat::Str("unsafe"), ast_ty_search_pat(&binder_ty.inner_ty).1),
+        TyKind::TraitObject(_, trait_obj_syntax) => {
+            if let TraitObjectSyntax::Dyn = trait_obj_syntax {
+                (Pat::Str("dyn"), Pat::Str(""))
+            } else {
+                // NOTE: `TraitObject` is incomplete. It will always return true then.
+                (Pat::Str(""), Pat::Str(""))
+            }
+        },
+        TyKind::MacCall(mac_call) => {
+            let start = if let Some(first) = mac_call.path.segments.first() {
+                ident_search_pat(first.ident).0
+            } else {
+                Pat::Str("")
+            };
+            (start, Pat::Str(""))
+        },
+
+        // implicit, so has no contents to match against
+        TyKind::ImplicitSelf
+
+        // experimental
+        |TyKind::Pat(..)
+
+        // unused
+        | TyKind::CVarArgs
+        | TyKind::Typeof(_)
+
+        // placeholder
+        | TyKind::Dummy
+        | TyKind::Err(_) => (Pat::Str(""), Pat::Str("")),
+    }
+}
+
 fn ident_search_pat(ident: Ident) -> (Pat, Pat) {
     (Pat::Sym(ident.name), Pat::Sym(ident.name))
 }
@@ -445,6 +574,7 @@ impl_with_search_pat!((_cx: LateContext<'tcx>, self: Lit) => lit_search_pat(&sel
 impl_with_search_pat!((_cx: LateContext<'tcx>, self: Path<'_>) => path_search_pat(self));
 
 impl_with_search_pat!((_cx: EarlyContext<'tcx>, self: Attribute) => attr_search_pat(self));
+impl_with_search_pat!((_cx: EarlyContext<'tcx>, self: ast::Ty) => ast_ty_search_pat(self));
 
 impl<'cx> WithSearchPat<'cx> for (&FnKind<'cx>, &Body<'cx>, HirId, Span) {
     type Context = LateContext<'cx>;
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 120ab2e717db8..feadc0ecf659a 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -329,13 +329,17 @@ pub fn is_wild(pat: &Pat<'_>) -> bool {
     matches!(pat.kind, PatKind::Wild)
 }
 
-// Checks if arm has the form `None => None`
-pub fn is_none_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
-    matches!(
-        arm.pat.kind,
+/// Checks if the `pat` is `None`.
+pub fn is_none_pattern(cx: &LateContext<'_>, pat: &Pat<'_>) -> bool {
+    matches!(pat.kind,
         PatKind::Expr(PatExpr { kind: PatExprKind::Path(qpath), .. })
-            if is_res_lang_ctor(cx, cx.qpath_res(qpath, arm.pat.hir_id), OptionNone)
-    )
+            if is_res_lang_ctor(cx, cx.qpath_res(qpath, pat.hir_id), OptionNone))
+}
+
+/// Checks if `arm` has the form `None => None`.
+pub fn is_none_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
+    is_none_pattern(cx, arm.pat)
+        && matches!(peel_blocks(arm.body).kind, ExprKind::Path(qpath) if is_res_lang_ctor(cx, cx.qpath_res(&qpath, arm.body.hir_id), OptionNone))
 }
 
 /// Checks if the given `QPath` belongs to a type alias.
@@ -2374,15 +2378,12 @@ pub fn peel_hir_ty_refs<'a>(mut ty: &'a hir::Ty<'a>) -> (&'a hir::Ty<'a>, usize)
     }
 }
 
-/// Peels off all references on the type. Returns the underlying type and the number of references
-/// removed.
-pub fn peel_middle_ty_refs(mut ty: Ty<'_>) -> (Ty<'_>, usize) {
-    let mut count = 0;
-    while let rustc_ty::Ref(_, dest_ty, _) = ty.kind() {
-        ty = *dest_ty;
-        count += 1;
+/// Returns the base type for HIR references and pointers.
+pub fn peel_hir_ty_refs_and_ptrs<'tcx>(ty: &'tcx hir::Ty<'tcx>) -> &'tcx hir::Ty<'tcx> {
+    match &ty.kind {
+        TyKind::Ptr(mut_ty) | TyKind::Ref(_, mut_ty) => peel_hir_ty_refs_and_ptrs(mut_ty.ty),
+        _ => ty,
     }
-    (ty, count)
 }
 
 /// Removes `AddrOf` operators (`&`) or deref operators (`*`), but only if a reference type is
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 896d607fbcdd9..6e07ed9ffcc4d 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -24,7 +24,7 @@ macro_rules! msrv_aliases {
 // names may refer to stabilized feature flags or library items
 msrv_aliases! {
     1,88,0 { LET_CHAINS }
-    1,87,0 { OS_STR_DISPLAY, INT_MIDPOINT, CONST_CHAR_IS_DIGIT, UNSIGNED_IS_MULTIPLE_OF }
+    1,87,0 { OS_STR_DISPLAY, INT_MIDPOINT, CONST_CHAR_IS_DIGIT, UNSIGNED_IS_MULTIPLE_OF, INTEGER_SIGN_CAST }
     1,85,0 { UINT_FLOAT_MIDPOINT, CONST_SIZE_OF_VAL }
     1,84,0 { CONST_OPTION_AS_SLICE, MANUAL_DANGLING_PTR }
     1,83,0 { CONST_EXTERN_FN, CONST_FLOAT_BITS_CONV, CONST_FLOAT_CLASSIFY, CONST_MUT_REFS, CONST_UNWRAP }
@@ -73,7 +73,7 @@ msrv_aliases! {
     1,29,0 { ITER_FLATTEN }
     1,28,0 { FROM_BOOL, REPEAT_WITH, SLICE_FROM_REF }
     1,27,0 { ITERATOR_TRY_FOLD }
-    1,26,0 { RANGE_INCLUSIVE, STRING_RETAIN }
+    1,26,0 { RANGE_INCLUSIVE, STRING_RETAIN, POINTER_ADD_SUB_METHODS }
     1,24,0 { IS_ASCII_DIGIT, PTR_NULL }
     1,18,0 { HASH_MAP_RETAIN, HASH_SET_RETAIN }
     1,17,0 { FIELD_INIT_SHORTHAND, STATIC_IN_CONST, EXPECT_ERR }
diff --git a/clippy_utils/src/source.rs b/clippy_utils/src/source.rs
index e675291b6f3a7..638d329031231 100644
--- a/clippy_utils/src/source.rs
+++ b/clippy_utils/src/source.rs
@@ -215,6 +215,11 @@ impl fmt::Display for SourceText {
         self.as_str().fmt(f)
     }
 }
+impl fmt::Debug for SourceText {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.as_str().fmt(f)
+    }
+}
 
 fn get_source_range(sm: &SourceMap, sp: Range<BytePos>) -> Option<SourceFileRange> {
     let start = sm.lookup_byte_offset(sp.start);
diff --git a/clippy_utils/src/sym.rs b/clippy_utils/src/sym.rs
index 8033b74a8d25c..7530d3bc7157d 100644
--- a/clippy_utils/src/sym.rs
+++ b/clippy_utils/src/sym.rs
@@ -125,6 +125,7 @@ generate! {
     cycle,
     cyclomatic_complexity,
     de,
+    deprecated_in_future,
     diagnostics,
     disallowed_types,
     drain,
diff --git a/clippy_utils/src/ty/mod.rs b/clippy_utils/src/ty/mod.rs
index 3e41bce1dc4ce..e4bc3b7682942 100644
--- a/clippy_utils/src/ty/mod.rs
+++ b/clippy_utils/src/ty/mod.rs
@@ -11,7 +11,7 @@ use rustc_hir as hir;
 use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
 use rustc_hir::def_id::DefId;
-use rustc_hir::{Expr, FnDecl, LangItem, TyKind, find_attr};
+use rustc_hir::{Expr, FnDecl, LangItem, find_attr};
 use rustc_hir_analysis::lower_ty;
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
@@ -43,13 +43,8 @@ pub use type_certainty::expr_type_is_certain;
 /// Lower a [`hir::Ty`] to a [`rustc_middle::ty::Ty`].
 pub fn ty_from_hir_ty<'tcx>(cx: &LateContext<'tcx>, hir_ty: &hir::Ty<'tcx>) -> Ty<'tcx> {
     cx.maybe_typeck_results()
-        .and_then(|results| {
-            if results.hir_owner == hir_ty.hir_id.owner {
-                results.node_type_opt(hir_ty.hir_id)
-            } else {
-                None
-            }
-        })
+        .filter(|results| results.hir_owner == hir_ty.hir_id.owner)
+        .and_then(|results| results.node_type_opt(hir_ty.hir_id))
         .unwrap_or_else(|| lower_ty(cx.tcx, hir_ty))
 }
 
@@ -475,63 +470,50 @@ 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, 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) {
-    fn f(ty: Ty<'_>, count: usize, mutability: Mutability) -> (Ty<'_>, usize, Mutability) {
-        match ty.kind() {
-            ty::Ref(_, ty, Mutability::Mut) => f(*ty, count + 1, mutability),
-            ty::Ref(_, ty, Mutability::Not) => f(*ty, count + 1, Mutability::Not),
-            _ => (ty, count, mutability),
-        }
-    }
-    f(ty, 0, Mutability::Mut)
-}
-
-/// Returns `true` if the given type is an `unsafe` function.
-pub fn type_is_unsafe_function<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+/// Returns `true` if `ty` denotes an `unsafe fn`.
+pub fn is_unsafe_fn<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
     ty.is_fn() && ty.fn_sig(cx.tcx).safety().is_unsafe()
 }
 
-/// Returns the base type for HIR references and pointers.
-pub fn walk_ptrs_hir_ty<'tcx>(ty: &'tcx hir::Ty<'tcx>) -> &'tcx hir::Ty<'tcx> {
-    match ty.kind {
-        TyKind::Ptr(ref mut_ty) | TyKind::Ref(_, ref mut_ty) => walk_ptrs_hir_ty(mut_ty.ty),
-        _ => ty,
-    }
-}
-
-/// Returns the base type for references and raw pointers, and count reference
-/// depth.
-pub fn walk_ptrs_ty_depth(ty: Ty<'_>) -> (Ty<'_>, usize) {
-    fn inner(ty: Ty<'_>, depth: usize) -> (Ty<'_>, usize) {
-        match ty.kind() {
-            ty::Ref(_, ty, _) => inner(*ty, depth + 1),
-            _ => (ty, depth),
-        }
+/// Peels off all references on the type. Returns the underlying type, the number of references
+/// removed, and, if there were any such references, whether the pointer is ultimately mutable or
+/// not.
+pub fn peel_and_count_ty_refs(mut ty: Ty<'_>) -> (Ty<'_>, usize, Option<Mutability>) {
+    let mut count = 0;
+    let mut mutbl = None;
+    while let ty::Ref(_, dest_ty, m) = ty.kind() {
+        ty = *dest_ty;
+        count += 1;
+        mutbl.replace(mutbl.map_or(*m, |mutbl: Mutability| mutbl.min(*m)));
     }
-    inner(ty, 0)
+    (ty, count, mutbl)
 }
 
-/// Returns `true` if types `a` and `b` are same types having same `Const` generic args,
-/// otherwise returns `false`
-pub fn same_type_and_consts<'tcx>(a: Ty<'tcx>, b: Ty<'tcx>) -> bool {
+/// Checks whether `a` and `b` are same types having same `Const` generic args, but ignores
+/// lifetimes.
+///
+/// For example, the function would return `true` for
+/// - `u32` and `u32`
+/// - `[u8; N]` and `[u8; M]`, if `N=M`
+/// - `Option<T>` and `Option<U>`, if `same_type_modulo_regions(T, U)` holds
+/// - `&'a str` and `&'b str`
+///
+/// and `false` for:
+/// - `Result<u32, String>` and `Result<usize, String>`
+pub fn same_type_modulo_regions<'tcx>(a: Ty<'tcx>, b: Ty<'tcx>) -> bool {
     match (&a.kind(), &b.kind()) {
         (&ty::Adt(did_a, args_a), &ty::Adt(did_b, args_b)) => {
             if did_a != did_b {
                 return false;
             }
 
-            args_a
-                .iter()
-                .zip(args_b.iter())
-                .all(|(arg_a, arg_b)| match (arg_a.kind(), arg_b.kind()) {
-                    (GenericArgKind::Const(inner_a), GenericArgKind::Const(inner_b)) => inner_a == inner_b,
-                    (GenericArgKind::Type(type_a), GenericArgKind::Type(type_b)) => {
-                        same_type_and_consts(type_a, type_b)
-                    },
-                    _ => true,
-                })
+            iter::zip(*args_a, *args_b).all(|(arg_a, arg_b)| match (arg_a.kind(), arg_b.kind()) {
+                (GenericArgKind::Const(inner_a), GenericArgKind::Const(inner_b)) => inner_a == inner_b,
+                (GenericArgKind::Type(type_a), GenericArgKind::Type(type_b)) => {
+                    same_type_modulo_regions(type_a, type_b)
+                },
+                _ => true,
+            })
         },
         _ => a == b,
     }
diff --git a/declare_clippy_lint/Cargo.toml b/declare_clippy_lint/Cargo.toml
index ec0e59e705495..4de7b5fb5924d 100644
--- a/declare_clippy_lint/Cargo.toml
+++ b/declare_clippy_lint/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "declare_clippy_lint"
-version = "0.1.91"
+version = "0.1.92"
 edition = "2024"
 repository = "https://github.com/rust-lang/rust-clippy"
 license = "MIT OR Apache-2.0"
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index ec2f24a0a6d84..9c102de448200 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,6 +1,6 @@
 [toolchain]
 # begin autogenerated nightly
-channel = "nightly-2025-09-04"
+channel = "nightly-2025-09-18"
 # end autogenerated nightly
 components = ["cargo", "llvm-tools", "rust-src", "rust-std", "rustc", "rustc-dev", "rustfmt"]
 profile = "minimal"
diff --git a/tests/no-profile-in-cargo-toml.rs b/tests/no-profile-in-cargo-toml.rs
index 2ad9bfb75dee8..1f8c4fae9b31f 100644
--- a/tests/no-profile-in-cargo-toml.rs
+++ b/tests/no-profile-in-cargo-toml.rs
@@ -17,6 +17,9 @@ fn no_profile_in_cargo_toml() {
     // keep it fast and simple.
     for entry in WalkDir::new(".")
         .into_iter()
+        // Do not recurse into `target` as lintcheck might put some sources (and their
+        //  `Cargo.toml`) there.
+        .filter_entry(|e| e.file_name() != "target")
         .filter_map(Result::ok)
         .filter(|e| e.file_name().to_str() == Some("Cargo.toml"))
     {
diff --git a/tests/ui/ref_option/all/clippy.toml b/tests/ui-toml/ref_option/all/clippy.toml
similarity index 100%
rename from tests/ui/ref_option/all/clippy.toml
rename to tests/ui-toml/ref_option/all/clippy.toml
diff --git a/tests/ui/ref_option/private/clippy.toml b/tests/ui-toml/ref_option/private/clippy.toml
similarity index 100%
rename from tests/ui/ref_option/private/clippy.toml
rename to tests/ui-toml/ref_option/private/clippy.toml
diff --git a/tests/ui-toml/ref_option/ref_option.all.fixed b/tests/ui-toml/ref_option/ref_option.all.fixed
new file mode 100644
index 0000000000000..f8f097e9a75e3
--- /dev/null
+++ b/tests/ui-toml/ref_option/ref_option.all.fixed
@@ -0,0 +1,114 @@
+//@aux-build:../../ui/auxiliary/proc_macros.rs
+//@revisions: private all
+//@[private] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/ref_option/private
+//@[all] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/ref_option/all
+
+#![allow(unused, clippy::needless_lifetimes, clippy::borrowed_box)]
+#![warn(clippy::ref_option)]
+
+fn opt_u8(a: Option<&u8>) {}
+//~^ ref_option
+fn opt_gen<T>(a: Option<&T>) {}
+//~^ ref_option
+fn opt_string(a: std::option::Option<&String>) {}
+//~^ ref_option
+fn ret_u8<'a>(p: &'a str) -> Option<&'a u8> {
+    //~^ ref_option
+    panic!()
+}
+fn ret_u8_static() -> Option<&'static u8> {
+    //~^ ref_option
+    panic!()
+}
+fn mult_string(a: Option<&String>, b: Option<&Vec<u8>>) {}
+//~^ ref_option
+fn ret_box<'a>() -> Option<&'a Box<u8>> {
+    //~^ ref_option
+    panic!()
+}
+
+pub fn pub_opt_string(a: Option<&String>) {}
+//~[all]^ ref_option
+pub fn pub_mult_string(a: Option<&String>, b: Option<&Vec<u8>>) {}
+//~[all]^ ref_option
+
+pub struct PubStruct;
+
+impl PubStruct {
+    pub fn pub_opt_params(&self, a: Option<&()>) {}
+    //~[all]^ ref_option
+    pub fn pub_opt_ret(&self) -> Option<&String> {
+        //~[all]^ ref_option
+        panic!()
+    }
+
+    fn private_opt_params(&self, a: Option<&()>) {}
+    //~^ ref_option
+    fn private_opt_ret(&self) -> Option<&String> {
+        //~^ ref_option
+        panic!()
+    }
+}
+
+// valid, don't change
+fn mut_u8(a: &mut Option<u8>) {}
+pub fn pub_mut_u8(a: &mut Option<String>) {}
+
+// might be good to catch in the future
+fn mut_u8_ref(a: &mut &Option<u8>) {}
+pub fn pub_mut_u8_ref(a: &mut &Option<String>) {}
+fn lambdas() {
+    // Not handled for now, not sure if we should
+    let x = |a: &Option<String>| {};
+    let x = |a: &Option<String>| -> &Option<String> { panic!() };
+}
+
+pub mod external {
+    proc_macros::external!(
+        fn opt_u8(a: &Option<u8>) {}
+        fn ret_u8<'a>(p: &'a str) -> &'a Option<u8> {
+            panic!()
+        }
+        pub fn pub_opt_u8(a: &Option<u8>) {}
+
+        pub struct PubStruct;
+        impl PubStruct {
+            pub fn pub_opt_params(&self, a: &Option<()>) {}
+            pub fn pub_opt_ret(&self) -> &Option<String> {
+                panic!()
+            }
+
+            fn private_opt_params(&self, a: &Option<()>) {}
+            fn private_opt_ret(&self) -> &Option<String> {
+                panic!()
+            }
+        }
+    );
+}
+
+pub mod proc_macros {
+    proc_macros::with_span!(
+        span
+
+        fn opt_u8(a: &Option<u8>) {}
+        fn ret_u8<'a>(p: &'a str) -> &'a Option<u8> {
+            panic!()
+        }
+        pub fn pub_opt_u8(a: &Option<u8>) {}
+
+        pub struct PubStruct;
+        impl PubStruct {
+            pub fn pub_opt_params(&self, a: &Option<()>) {}
+            pub fn pub_opt_ret(&self) -> &Option<String> {
+                panic!()
+            }
+
+            fn private_opt_params(&self, a: &Option<()>) {}
+            fn private_opt_ret(&self) -> &Option<String> {
+                panic!()
+            }
+        }
+    );
+}
+
+fn main() {}
diff --git a/tests/ui/ref_option/ref_option.all.stderr b/tests/ui-toml/ref_option/ref_option.all.stderr
similarity index 62%
rename from tests/ui/ref_option/ref_option.all.stderr
rename to tests/ui-toml/ref_option/ref_option.all.stderr
index bd43c28336eb3..45ce105e03084 100644
--- a/tests/ui/ref_option/ref_option.all.stderr
+++ b/tests/ui-toml/ref_option/ref_option.all.stderr
@@ -1,5 +1,5 @@
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:8:1
+  --> tests/ui-toml/ref_option/ref_option.rs:9:1
    |
 LL | fn opt_u8(a: &Option<u8>) {}
    | ^^^^^^^^^^^^^-----------^^^^
@@ -10,7 +10,7 @@ LL | fn opt_u8(a: &Option<u8>) {}
    = help: to override `-D warnings` add `#[allow(clippy::ref_option)]`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:10:1
+  --> tests/ui-toml/ref_option/ref_option.rs:11:1
    |
 LL | fn opt_gen<T>(a: &Option<T>) {}
    | ^^^^^^^^^^^^^^^^^----------^^^^
@@ -18,7 +18,7 @@ LL | fn opt_gen<T>(a: &Option<T>) {}
    |                  help: change this to: `Option<&T>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:12:1
+  --> tests/ui-toml/ref_option/ref_option.rs:13:1
    |
 LL | fn opt_string(a: &std::option::Option<String>) {}
    | ^^^^^^^^^^^^^^^^^----------------------------^^^^
@@ -26,10 +26,10 @@ LL | fn opt_string(a: &std::option::Option<String>) {}
    |                  help: change this to: `std::option::Option<&String>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:14:1
+  --> tests/ui-toml/ref_option/ref_option.rs:15:1
    |
-LL |   fn ret_string<'a>(p: &'a str) -> &'a Option<u8> {
-   |   ^                                -------------- help: change this to: `Option<&'a u8>`
+LL |   fn ret_u8<'a>(p: &'a str) -> &'a Option<u8> {
+   |   ^                            -------------- help: change this to: `Option<&'a u8>`
    |  _|
    | |
 LL | |
@@ -38,10 +38,10 @@ LL | | }
    | |_^
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:18:1
+  --> tests/ui-toml/ref_option/ref_option.rs:19:1
    |
-LL |   fn ret_string_static() -> &'static Option<u8> {
-   |   ^                         ------------------- help: change this to: `Option<&'static u8>`
+LL |   fn ret_u8_static() -> &'static Option<u8> {
+   |   ^                     ------------------- help: change this to: `Option<&'static u8>`
    |  _|
    | |
 LL | |
@@ -50,7 +50,7 @@ LL | | }
    | |_^
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:22:1
+  --> tests/ui-toml/ref_option/ref_option.rs:23:1
    |
 LL | fn mult_string(a: &Option<String>, b: &Option<Vec<u8>>) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -62,7 +62,7 @@ LL + fn mult_string(a: Option<&String>, b: Option<&Vec<u8>>) {}
    |
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:24:1
+  --> tests/ui-toml/ref_option/ref_option.rs:25:1
    |
 LL |   fn ret_box<'a>() -> &'a Option<Box<u8>> {
    |   ^                   ------------------- help: change this to: `Option<&'a Box<u8>>`
@@ -74,7 +74,7 @@ LL | | }
    | |_^
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:29:1
+  --> tests/ui-toml/ref_option/ref_option.rs:30:1
    |
 LL | pub fn pub_opt_string(a: &Option<String>) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^---------------^^^^
@@ -82,7 +82,7 @@ LL | pub fn pub_opt_string(a: &Option<String>) {}
    |                          help: change this to: `Option<&String>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:31:1
+  --> tests/ui-toml/ref_option/ref_option.rs:32:1
    |
 LL | pub fn pub_mult_string(a: &Option<String>, b: &Option<Vec<u8>>) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -94,39 +94,7 @@ LL + pub fn pub_mult_string(a: Option<&String>, b: Option<&Vec<u8>>) {}
    |
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:35:5
-   |
-LL |     fn pub_trait_opt(&self, a: &Option<Vec<u8>>);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^----------------^^
-   |                                |
-   |                                help: change this to: `Option<&Vec<u8>>`
-
-error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:37:5
-   |
-LL |     fn pub_trait_ret(&self) -> &Option<Vec<u8>>;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^----------------^
-   |                                |
-   |                                help: change this to: `Option<&Vec<u8>>`
-
-error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:42:5
-   |
-LL |     fn trait_opt(&self, a: &Option<String>);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^^
-   |                            |
-   |                            help: change this to: `Option<&String>`
-
-error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:44:5
-   |
-LL |     fn trait_ret(&self) -> &Option<String>;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^
-   |                            |
-   |                            help: change this to: `Option<&String>`
-
-error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:51:5
+  --> tests/ui-toml/ref_option/ref_option.rs:38:5
    |
 LL |     pub fn pub_opt_params(&self, a: &Option<()>) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-----------^^^^
@@ -134,7 +102,7 @@ LL |     pub fn pub_opt_params(&self, a: &Option<()>) {}
    |                                     help: change this to: `Option<&()>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:53:5
+  --> tests/ui-toml/ref_option/ref_option.rs:40:5
    |
 LL |       pub fn pub_opt_ret(&self) -> &Option<String> {
    |       ^                            --------------- help: change this to: `Option<&String>`
@@ -146,7 +114,7 @@ LL | |     }
    | |_____^
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:58:5
+  --> tests/ui-toml/ref_option/ref_option.rs:45:5
    |
 LL |     fn private_opt_params(&self, a: &Option<()>) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-----------^^^^
@@ -154,7 +122,7 @@ LL |     fn private_opt_params(&self, a: &Option<()>) {}
    |                                     help: change this to: `Option<&()>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:60:5
+  --> tests/ui-toml/ref_option/ref_option.rs:47:5
    |
 LL |       fn private_opt_ret(&self) -> &Option<String> {
    |       ^                            --------------- help: change this to: `Option<&String>`
@@ -165,5 +133,5 @@ LL | |         panic!()
 LL | |     }
    | |_____^
 
-error: aborting due to 17 previous errors
+error: aborting due to 13 previous errors
 
diff --git a/tests/ui-toml/ref_option/ref_option.private.fixed b/tests/ui-toml/ref_option/ref_option.private.fixed
new file mode 100644
index 0000000000000..4dd14a822067b
--- /dev/null
+++ b/tests/ui-toml/ref_option/ref_option.private.fixed
@@ -0,0 +1,114 @@
+//@aux-build:../../ui/auxiliary/proc_macros.rs
+//@revisions: private all
+//@[private] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/ref_option/private
+//@[all] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/ref_option/all
+
+#![allow(unused, clippy::needless_lifetimes, clippy::borrowed_box)]
+#![warn(clippy::ref_option)]
+
+fn opt_u8(a: Option<&u8>) {}
+//~^ ref_option
+fn opt_gen<T>(a: Option<&T>) {}
+//~^ ref_option
+fn opt_string(a: std::option::Option<&String>) {}
+//~^ ref_option
+fn ret_u8<'a>(p: &'a str) -> Option<&'a u8> {
+    //~^ ref_option
+    panic!()
+}
+fn ret_u8_static() -> Option<&'static u8> {
+    //~^ ref_option
+    panic!()
+}
+fn mult_string(a: Option<&String>, b: Option<&Vec<u8>>) {}
+//~^ ref_option
+fn ret_box<'a>() -> Option<&'a Box<u8>> {
+    //~^ ref_option
+    panic!()
+}
+
+pub fn pub_opt_string(a: &Option<String>) {}
+//~[all]^ ref_option
+pub fn pub_mult_string(a: &Option<String>, b: &Option<Vec<u8>>) {}
+//~[all]^ ref_option
+
+pub struct PubStruct;
+
+impl PubStruct {
+    pub fn pub_opt_params(&self, a: &Option<()>) {}
+    //~[all]^ ref_option
+    pub fn pub_opt_ret(&self) -> &Option<String> {
+        //~[all]^ ref_option
+        panic!()
+    }
+
+    fn private_opt_params(&self, a: Option<&()>) {}
+    //~^ ref_option
+    fn private_opt_ret(&self) -> Option<&String> {
+        //~^ ref_option
+        panic!()
+    }
+}
+
+// valid, don't change
+fn mut_u8(a: &mut Option<u8>) {}
+pub fn pub_mut_u8(a: &mut Option<String>) {}
+
+// might be good to catch in the future
+fn mut_u8_ref(a: &mut &Option<u8>) {}
+pub fn pub_mut_u8_ref(a: &mut &Option<String>) {}
+fn lambdas() {
+    // Not handled for now, not sure if we should
+    let x = |a: &Option<String>| {};
+    let x = |a: &Option<String>| -> &Option<String> { panic!() };
+}
+
+pub mod external {
+    proc_macros::external!(
+        fn opt_u8(a: &Option<u8>) {}
+        fn ret_u8<'a>(p: &'a str) -> &'a Option<u8> {
+            panic!()
+        }
+        pub fn pub_opt_u8(a: &Option<u8>) {}
+
+        pub struct PubStruct;
+        impl PubStruct {
+            pub fn pub_opt_params(&self, a: &Option<()>) {}
+            pub fn pub_opt_ret(&self) -> &Option<String> {
+                panic!()
+            }
+
+            fn private_opt_params(&self, a: &Option<()>) {}
+            fn private_opt_ret(&self) -> &Option<String> {
+                panic!()
+            }
+        }
+    );
+}
+
+pub mod proc_macros {
+    proc_macros::with_span!(
+        span
+
+        fn opt_u8(a: &Option<u8>) {}
+        fn ret_u8<'a>(p: &'a str) -> &'a Option<u8> {
+            panic!()
+        }
+        pub fn pub_opt_u8(a: &Option<u8>) {}
+
+        pub struct PubStruct;
+        impl PubStruct {
+            pub fn pub_opt_params(&self, a: &Option<()>) {}
+            pub fn pub_opt_ret(&self) -> &Option<String> {
+                panic!()
+            }
+
+            fn private_opt_params(&self, a: &Option<()>) {}
+            fn private_opt_ret(&self) -> &Option<String> {
+                panic!()
+            }
+        }
+    );
+}
+
+fn main() {}
diff --git a/tests/ui/ref_option/ref_option.private.stderr b/tests/ui-toml/ref_option/ref_option.private.stderr
similarity index 63%
rename from tests/ui/ref_option/ref_option.private.stderr
rename to tests/ui-toml/ref_option/ref_option.private.stderr
index 88c65e429d870..a63efd60a0368 100644
--- a/tests/ui/ref_option/ref_option.private.stderr
+++ b/tests/ui-toml/ref_option/ref_option.private.stderr
@@ -1,5 +1,5 @@
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:8:1
+  --> tests/ui-toml/ref_option/ref_option.rs:9:1
    |
 LL | fn opt_u8(a: &Option<u8>) {}
    | ^^^^^^^^^^^^^-----------^^^^
@@ -10,7 +10,7 @@ LL | fn opt_u8(a: &Option<u8>) {}
    = help: to override `-D warnings` add `#[allow(clippy::ref_option)]`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:10:1
+  --> tests/ui-toml/ref_option/ref_option.rs:11:1
    |
 LL | fn opt_gen<T>(a: &Option<T>) {}
    | ^^^^^^^^^^^^^^^^^----------^^^^
@@ -18,7 +18,7 @@ LL | fn opt_gen<T>(a: &Option<T>) {}
    |                  help: change this to: `Option<&T>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:12:1
+  --> tests/ui-toml/ref_option/ref_option.rs:13:1
    |
 LL | fn opt_string(a: &std::option::Option<String>) {}
    | ^^^^^^^^^^^^^^^^^----------------------------^^^^
@@ -26,10 +26,10 @@ LL | fn opt_string(a: &std::option::Option<String>) {}
    |                  help: change this to: `std::option::Option<&String>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:14:1
+  --> tests/ui-toml/ref_option/ref_option.rs:15:1
    |
-LL |   fn ret_string<'a>(p: &'a str) -> &'a Option<u8> {
-   |   ^                                -------------- help: change this to: `Option<&'a u8>`
+LL |   fn ret_u8<'a>(p: &'a str) -> &'a Option<u8> {
+   |   ^                            -------------- help: change this to: `Option<&'a u8>`
    |  _|
    | |
 LL | |
@@ -38,10 +38,10 @@ LL | | }
    | |_^
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:18:1
+  --> tests/ui-toml/ref_option/ref_option.rs:19:1
    |
-LL |   fn ret_string_static() -> &'static Option<u8> {
-   |   ^                         ------------------- help: change this to: `Option<&'static u8>`
+LL |   fn ret_u8_static() -> &'static Option<u8> {
+   |   ^                     ------------------- help: change this to: `Option<&'static u8>`
    |  _|
    | |
 LL | |
@@ -50,7 +50,7 @@ LL | | }
    | |_^
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:22:1
+  --> tests/ui-toml/ref_option/ref_option.rs:23:1
    |
 LL | fn mult_string(a: &Option<String>, b: &Option<Vec<u8>>) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -62,7 +62,7 @@ LL + fn mult_string(a: Option<&String>, b: Option<&Vec<u8>>) {}
    |
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:24:1
+  --> tests/ui-toml/ref_option/ref_option.rs:25:1
    |
 LL |   fn ret_box<'a>() -> &'a Option<Box<u8>> {
    |   ^                   ------------------- help: change this to: `Option<&'a Box<u8>>`
@@ -74,23 +74,7 @@ LL | | }
    | |_^
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:42:5
-   |
-LL |     fn trait_opt(&self, a: &Option<String>);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^^
-   |                            |
-   |                            help: change this to: `Option<&String>`
-
-error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:44:5
-   |
-LL |     fn trait_ret(&self) -> &Option<String>;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^
-   |                            |
-   |                            help: change this to: `Option<&String>`
-
-error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:58:5
+  --> tests/ui-toml/ref_option/ref_option.rs:45:5
    |
 LL |     fn private_opt_params(&self, a: &Option<()>) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-----------^^^^
@@ -98,7 +82,7 @@ LL |     fn private_opt_params(&self, a: &Option<()>) {}
    |                                     help: change this to: `Option<&()>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:60:5
+  --> tests/ui-toml/ref_option/ref_option.rs:47:5
    |
 LL |       fn private_opt_ret(&self) -> &Option<String> {
    |       ^                            --------------- help: change this to: `Option<&String>`
@@ -109,5 +93,5 @@ LL | |         panic!()
 LL | |     }
    | |_____^
 
-error: aborting due to 11 previous errors
+error: aborting due to 9 previous errors
 
diff --git a/tests/ui-toml/ref_option/ref_option.rs b/tests/ui-toml/ref_option/ref_option.rs
new file mode 100644
index 0000000000000..8397c2213d172
--- /dev/null
+++ b/tests/ui-toml/ref_option/ref_option.rs
@@ -0,0 +1,114 @@
+//@aux-build:../../ui/auxiliary/proc_macros.rs
+//@revisions: private all
+//@[private] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/ref_option/private
+//@[all] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/ref_option/all
+
+#![allow(unused, clippy::needless_lifetimes, clippy::borrowed_box)]
+#![warn(clippy::ref_option)]
+
+fn opt_u8(a: &Option<u8>) {}
+//~^ ref_option
+fn opt_gen<T>(a: &Option<T>) {}
+//~^ ref_option
+fn opt_string(a: &std::option::Option<String>) {}
+//~^ ref_option
+fn ret_u8<'a>(p: &'a str) -> &'a Option<u8> {
+    //~^ ref_option
+    panic!()
+}
+fn ret_u8_static() -> &'static Option<u8> {
+    //~^ ref_option
+    panic!()
+}
+fn mult_string(a: &Option<String>, b: &Option<Vec<u8>>) {}
+//~^ ref_option
+fn ret_box<'a>() -> &'a Option<Box<u8>> {
+    //~^ ref_option
+    panic!()
+}
+
+pub fn pub_opt_string(a: &Option<String>) {}
+//~[all]^ ref_option
+pub fn pub_mult_string(a: &Option<String>, b: &Option<Vec<u8>>) {}
+//~[all]^ ref_option
+
+pub struct PubStruct;
+
+impl PubStruct {
+    pub fn pub_opt_params(&self, a: &Option<()>) {}
+    //~[all]^ ref_option
+    pub fn pub_opt_ret(&self) -> &Option<String> {
+        //~[all]^ ref_option
+        panic!()
+    }
+
+    fn private_opt_params(&self, a: &Option<()>) {}
+    //~^ ref_option
+    fn private_opt_ret(&self) -> &Option<String> {
+        //~^ ref_option
+        panic!()
+    }
+}
+
+// valid, don't change
+fn mut_u8(a: &mut Option<u8>) {}
+pub fn pub_mut_u8(a: &mut Option<String>) {}
+
+// might be good to catch in the future
+fn mut_u8_ref(a: &mut &Option<u8>) {}
+pub fn pub_mut_u8_ref(a: &mut &Option<String>) {}
+fn lambdas() {
+    // Not handled for now, not sure if we should
+    let x = |a: &Option<String>| {};
+    let x = |a: &Option<String>| -> &Option<String> { panic!() };
+}
+
+pub mod external {
+    proc_macros::external!(
+        fn opt_u8(a: &Option<u8>) {}
+        fn ret_u8<'a>(p: &'a str) -> &'a Option<u8> {
+            panic!()
+        }
+        pub fn pub_opt_u8(a: &Option<u8>) {}
+
+        pub struct PubStruct;
+        impl PubStruct {
+            pub fn pub_opt_params(&self, a: &Option<()>) {}
+            pub fn pub_opt_ret(&self) -> &Option<String> {
+                panic!()
+            }
+
+            fn private_opt_params(&self, a: &Option<()>) {}
+            fn private_opt_ret(&self) -> &Option<String> {
+                panic!()
+            }
+        }
+    );
+}
+
+pub mod proc_macros {
+    proc_macros::with_span!(
+        span
+
+        fn opt_u8(a: &Option<u8>) {}
+        fn ret_u8<'a>(p: &'a str) -> &'a Option<u8> {
+            panic!()
+        }
+        pub fn pub_opt_u8(a: &Option<u8>) {}
+
+        pub struct PubStruct;
+        impl PubStruct {
+            pub fn pub_opt_params(&self, a: &Option<()>) {}
+            pub fn pub_opt_ret(&self) -> &Option<String> {
+                panic!()
+            }
+
+            fn private_opt_params(&self, a: &Option<()>) {}
+            fn private_opt_ret(&self) -> &Option<String> {
+                panic!()
+            }
+        }
+    );
+}
+
+fn main() {}
diff --git a/tests/ui/ref_option/ref_option_traits.all.stderr b/tests/ui-toml/ref_option/ref_option_traits.all.stderr
similarity index 85%
rename from tests/ui/ref_option/ref_option_traits.all.stderr
rename to tests/ui-toml/ref_option/ref_option_traits.all.stderr
index 886bf2b034989..602e148be6012 100644
--- a/tests/ui/ref_option/ref_option_traits.all.stderr
+++ b/tests/ui-toml/ref_option/ref_option_traits.all.stderr
@@ -1,5 +1,5 @@
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option_traits.rs:9:5
+  --> tests/ui-toml/ref_option/ref_option_traits.rs:10:5
    |
 LL |     fn pub_trait_opt(&self, a: &Option<Vec<u8>>);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^----------------^^
@@ -10,7 +10,7 @@ LL |     fn pub_trait_opt(&self, a: &Option<Vec<u8>>);
    = help: to override `-D warnings` add `#[allow(clippy::ref_option)]`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option_traits.rs:11:5
+  --> tests/ui-toml/ref_option/ref_option_traits.rs:12:5
    |
 LL |     fn pub_trait_ret(&self) -> &Option<Vec<u8>>;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^----------------^
@@ -18,7 +18,7 @@ LL |     fn pub_trait_ret(&self) -> &Option<Vec<u8>>;
    |                                help: change this to: `Option<&Vec<u8>>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option_traits.rs:16:5
+  --> tests/ui-toml/ref_option/ref_option_traits.rs:17:5
    |
 LL |     fn trait_opt(&self, a: &Option<String>);
    |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^^
@@ -26,7 +26,7 @@ LL |     fn trait_opt(&self, a: &Option<String>);
    |                            help: change this to: `Option<&String>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option_traits.rs:18:5
+  --> tests/ui-toml/ref_option/ref_option_traits.rs:19:5
    |
 LL |     fn trait_ret(&self) -> &Option<String>;
    |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^
diff --git a/tests/ui/ref_option/ref_option_traits.private.stderr b/tests/ui-toml/ref_option/ref_option_traits.private.stderr
similarity index 86%
rename from tests/ui/ref_option/ref_option_traits.private.stderr
rename to tests/ui-toml/ref_option/ref_option_traits.private.stderr
index cfab7fa5734c3..20bea400edfe6 100644
--- a/tests/ui/ref_option/ref_option_traits.private.stderr
+++ b/tests/ui-toml/ref_option/ref_option_traits.private.stderr
@@ -1,5 +1,5 @@
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option_traits.rs:16:5
+  --> tests/ui-toml/ref_option/ref_option_traits.rs:17:5
    |
 LL |     fn trait_opt(&self, a: &Option<String>);
    |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^^
@@ -10,7 +10,7 @@ LL |     fn trait_opt(&self, a: &Option<String>);
    = help: to override `-D warnings` add `#[allow(clippy::ref_option)]`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option_traits.rs:18:5
+  --> tests/ui-toml/ref_option/ref_option_traits.rs:19:5
    |
 LL |     fn trait_ret(&self) -> &Option<String>;
    |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^
diff --git a/tests/ui-toml/ref_option/ref_option_traits.rs b/tests/ui-toml/ref_option/ref_option_traits.rs
new file mode 100644
index 0000000000000..e1477d7f8463d
--- /dev/null
+++ b/tests/ui-toml/ref_option/ref_option_traits.rs
@@ -0,0 +1,71 @@
+//@no-rustfix: fixes are only done to traits, not the impls
+//@aux-build:../../ui/auxiliary/proc_macros.rs
+//@revisions: private all
+//@[private] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/ref_option/private
+//@[all] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/ref_option/all
+
+#![warn(clippy::ref_option)]
+
+pub trait PubTrait {
+    fn pub_trait_opt(&self, a: &Option<Vec<u8>>);
+    //~[all]^ ref_option
+    fn pub_trait_ret(&self) -> &Option<Vec<u8>>;
+    //~[all]^ ref_option
+}
+
+trait PrivateTrait {
+    fn trait_opt(&self, a: &Option<String>);
+    //~^ ref_option
+    fn trait_ret(&self) -> &Option<String>;
+    //~^ ref_option
+}
+
+pub struct PubStruct;
+
+impl PubTrait for PubStruct {
+    fn pub_trait_opt(&self, a: &Option<Vec<u8>>) {}
+    fn pub_trait_ret(&self) -> &Option<Vec<u8>> {
+        panic!()
+    }
+}
+
+struct PrivateStruct;
+
+impl PrivateTrait for PrivateStruct {
+    fn trait_opt(&self, a: &Option<String>) {}
+    fn trait_ret(&self) -> &Option<String> {
+        panic!()
+    }
+}
+
+pub mod external {
+    proc_macros::external!(
+        pub trait PubTrait {
+            fn pub_trait_opt(&self, a: &Option<Vec<u8>>);
+            fn pub_trait_ret(&self) -> &Option<Vec<u8>>;
+        }
+
+        trait PrivateTrait {
+            fn trait_opt(&self, a: &Option<String>);
+            fn trait_ret(&self) -> &Option<String>;
+        }
+    );
+}
+
+pub mod proc_macros {
+    proc_macros::with_span!(
+        span
+
+        pub trait PubTrait {
+            fn pub_trait_opt(&self, a: &Option<Vec<u8>>);
+            fn pub_trait_ret(&self) -> &Option<Vec<u8>>;
+        }
+
+        trait PrivateTrait {
+            fn trait_opt(&self, a: &Option<String>);
+            fn trait_ret(&self) -> &Option<String>;
+        }
+    );
+}
+
+fn main() {}
diff --git a/tests/ui/as_underscore_unfixable.rs b/tests/ui/as_underscore_unfixable.rs
new file mode 100644
index 0000000000000..854feca7174fb
--- /dev/null
+++ b/tests/ui/as_underscore_unfixable.rs
@@ -0,0 +1,14 @@
+//@no-rustfix
+
+#![warn(clippy::as_underscore)]
+
+fn main() {
+    // From issue #15282
+    let f = async || ();
+    let _: Box<dyn FnOnce() -> _> = Box::new(f) as _;
+    //~^ as_underscore
+
+    let barr = || (|| ());
+    let _: Box<dyn Fn() -> _> = Box::new(barr) as _;
+    //~^ as_underscore
+}
diff --git a/tests/ui/as_underscore_unfixable.stderr b/tests/ui/as_underscore_unfixable.stderr
new file mode 100644
index 0000000000000..7385bea5c6501
--- /dev/null
+++ b/tests/ui/as_underscore_unfixable.stderr
@@ -0,0 +1,20 @@
+error: using `as _` conversion
+  --> tests/ui/as_underscore_unfixable.rs:8:37
+   |
+LL |     let _: Box<dyn FnOnce() -> _> = Box::new(f) as _;
+   |                                     ^^^^^^^^^^^^^^^^
+   |
+   = help: consider giving the type explicitly
+   = note: `-D clippy::as-underscore` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::as_underscore)]`
+
+error: using `as _` conversion
+  --> tests/ui/as_underscore_unfixable.rs:12:33
+   |
+LL |     let _: Box<dyn Fn() -> _> = Box::new(barr) as _;
+   |                                 ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider giving the type explicitly
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/cast.rs b/tests/ui/cast.rs
index 525be8216500a..fab02bf7b24e4 100644
--- a/tests/ui/cast.rs
+++ b/tests/ui/cast.rs
@@ -569,3 +569,16 @@ fn issue12721() {
     (255 % 999999u64) as u8;
     //~^ cast_possible_truncation
 }
+
+mod issue14150 {
+    #[clippy::msrv = "1.87"]
+    fn msrv_supports_cast_signed() {
+        _ = 1u8 as i8;
+        //~^ cast_possible_wrap
+    }
+    #[clippy::msrv = "1.86"]
+    fn msrv_doesnt_supports_cast_signed() {
+        _ = 1u8 as i8;
+        //~^ cast_possible_wrap
+    }
+}
diff --git a/tests/ui/cast.stderr b/tests/ui/cast.stderr
index 1cb30d956679a..8c48855123f93 100644
--- a/tests/ui/cast.stderr
+++ b/tests/ui/cast.stderr
@@ -194,7 +194,7 @@ error: casting `u8` to `i8` may wrap around the value
   --> tests/ui/cast.rs:88:5
    |
 LL |     1u8 as i8;
-   |     ^^^^^^^^^
+   |     ^^^^^^^^^ help: if this is intentional, use `cast_signed()` instead: `1u8.cast_signed()`
    |
    = note: `-D clippy::cast-possible-wrap` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::cast_possible_wrap)]`
@@ -203,25 +203,25 @@ error: casting `u16` to `i16` may wrap around the value
   --> tests/ui/cast.rs:91:5
    |
 LL |     1u16 as i16;
-   |     ^^^^^^^^^^^
+   |     ^^^^^^^^^^^ help: if this is intentional, use `cast_signed()` instead: `1u16.cast_signed()`
 
 error: casting `u32` to `i32` may wrap around the value
   --> tests/ui/cast.rs:94:5
    |
 LL |     1u32 as i32;
-   |     ^^^^^^^^^^^
+   |     ^^^^^^^^^^^ help: if this is intentional, use `cast_signed()` instead: `1u32.cast_signed()`
 
 error: casting `u64` to `i64` may wrap around the value
   --> tests/ui/cast.rs:97:5
    |
 LL |     1u64 as i64;
-   |     ^^^^^^^^^^^
+   |     ^^^^^^^^^^^ help: if this is intentional, use `cast_signed()` instead: `1u64.cast_signed()`
 
 error: casting `usize` to `isize` may wrap around the value
   --> tests/ui/cast.rs:100:5
    |
 LL |     1usize as isize;
-   |     ^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_signed()` instead: `1usize.cast_signed()`
 
 error: casting `usize` to `i8` may truncate the value
   --> tests/ui/cast.rs:104:5
@@ -321,43 +321,43 @@ error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:138:5
    |
 LL |     -1i32 as u32;
-   |     ^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(-1i32).cast_unsigned()`
 
 error: casting `isize` to `usize` may lose the sign of the value
   --> tests/ui/cast.rs:142:5
    |
 LL |     -1isize as usize;
-   |     ^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(-1isize).cast_unsigned()`
 
 error: casting `i8` to `u8` may lose the sign of the value
   --> tests/ui/cast.rs:154:5
    |
 LL |     (i8::MIN).abs() as u8;
-   |     ^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(i8::MIN).abs().cast_unsigned()`
 
 error: casting `i64` to `u64` may lose the sign of the value
   --> tests/ui/cast.rs:159:5
    |
 LL |     (-1i64).abs() as u64;
-   |     ^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(-1i64).abs().cast_unsigned()`
 
 error: casting `isize` to `usize` may lose the sign of the value
   --> tests/ui/cast.rs:161:5
    |
 LL |     (-1isize).abs() as usize;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(-1isize).abs().cast_unsigned()`
 
 error: casting `i64` to `u64` may lose the sign of the value
   --> tests/ui/cast.rs:169:5
    |
 LL |     (unsafe { (-1i64).checked_abs().unwrap_unchecked() }) as u64;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(unsafe { (-1i64).checked_abs().unwrap_unchecked() }).cast_unsigned()`
 
 error: casting `i64` to `u64` may lose the sign of the value
   --> tests/ui/cast.rs:185:5
    |
 LL |     (unsafe { (-1i64).checked_isqrt().unwrap_unchecked() }) as u64;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(unsafe { (-1i64).checked_isqrt().unwrap_unchecked() }).cast_unsigned()`
 
 error: casting `i64` to `i8` may truncate the value
   --> tests/ui/cast.rs:237:5
@@ -495,79 +495,79 @@ error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:438:9
    |
 LL |         (x * x) as u32;
-   |         ^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(x * x).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:444:32
    |
 LL |     let _a = |x: i32| -> u32 { (x * x * x * x) as u32 };
-   |                                ^^^^^^^^^^^^^^^^^^^^^^
+   |                                ^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(x * x * x * x).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:447:5
    |
 LL |     (2_i32).checked_pow(3).unwrap() as u32;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(2_i32).checked_pow(3).unwrap().cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:449:5
    |
 LL |     (-2_i32).pow(3) as u32;
-   |     ^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(-2_i32).pow(3).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:454:5
    |
 LL |     (-5_i32 % 2) as u32;
-   |     ^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(-5_i32 % 2).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:457:5
    |
 LL |     (-5_i32 % -2) as u32;
-   |     ^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(-5_i32 % -2).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:461:5
    |
 LL |     (-2_i32 >> 1) as u32;
-   |     ^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(-2_i32 >> 1).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:465:5
    |
 LL |     (x * x) as u32;
-   |     ^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(x * x).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:467:5
    |
 LL |     (x * x * x) as u32;
-   |     ^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(x * x * x).cast_unsigned()`
 
 error: casting `i16` to `u16` may lose the sign of the value
   --> tests/ui/cast.rs:471:5
    |
 LL |     (y * y * y * y * -2) as u16;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(y * y * y * y * -2).cast_unsigned()`
 
 error: casting `i16` to `u16` may lose the sign of the value
   --> tests/ui/cast.rs:474:5
    |
 LL |     (y * y * y / y * 2) as u16;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(y * y * y / y * 2).cast_unsigned()`
 
 error: casting `i16` to `u16` may lose the sign of the value
   --> tests/ui/cast.rs:476:5
    |
 LL |     (y * y / y * 2) as u16;
-   |     ^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(y * y / y * 2).cast_unsigned()`
 
 error: casting `i16` to `u16` may lose the sign of the value
   --> tests/ui/cast.rs:479:5
    |
 LL |     (y / y * y * -2) as u16;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(y / y * y * -2).cast_unsigned()`
 
 error: equal expressions as operands to `/`
   --> tests/ui/cast.rs:479:6
@@ -581,97 +581,97 @@ error: casting `i16` to `u16` may lose the sign of the value
   --> tests/ui/cast.rs:483:5
    |
 LL |     (y + y + y + -2) as u16;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(y + y + y + -2).cast_unsigned()`
 
 error: casting `i16` to `u16` may lose the sign of the value
   --> tests/ui/cast.rs:486:5
    |
 LL |     (y + y + y + 2) as u16;
-   |     ^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(y + y + y + 2).cast_unsigned()`
 
 error: casting `i16` to `u16` may lose the sign of the value
   --> tests/ui/cast.rs:490:5
    |
 LL |     (z + -2) as u16;
-   |     ^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(z + -2).cast_unsigned()`
 
 error: casting `i16` to `u16` may lose the sign of the value
   --> tests/ui/cast.rs:493:5
    |
 LL |     (z + z + 2) as u16;
-   |     ^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(z + z + 2).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:497:9
    |
 LL |         (a * a * b * b * c * c) as u32;
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(a * a * b * b * c * c).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:499:9
    |
 LL |         (a * b * c) as u32;
-   |         ^^^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(a * b * c).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:502:9
    |
 LL |         (a * -b * c) as u32;
-   |         ^^^^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(a * -b * c).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:505:9
    |
 LL |         (a * b * c * c) as u32;
-   |         ^^^^^^^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(a * b * c * c).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:507:9
    |
 LL |         (a * -2) as u32;
-   |         ^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(a * -2).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:510:9
    |
 LL |         (a * b * c * -2) as u32;
-   |         ^^^^^^^^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(a * b * c * -2).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:513:9
    |
 LL |         (a / b) as u32;
-   |         ^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(a / b).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:515:9
    |
 LL |         (a / b * c) as u32;
-   |         ^^^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(a / b * c).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:518:9
    |
 LL |         (a / b + b * c) as u32;
-   |         ^^^^^^^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(a / b + b * c).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:521:9
    |
 LL |         a.saturating_pow(3) as u32;
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `a.saturating_pow(3).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:524:9
    |
 LL |         (a.abs() * b.pow(2) / c.abs()) as u32
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `(a.abs() * b.pow(2) / c.abs()).cast_unsigned()`
 
 error: casting `i32` to `u32` may lose the sign of the value
   --> tests/ui/cast.rs:532:21
    |
 LL |             let _ = i32::MIN as u32; // cast_sign_loss
-   |                     ^^^^^^^^^^^^^^^
+   |                     ^^^^^^^^^^^^^^^ help: if this is intentional, use `cast_unsigned()` instead: `i32::MIN.cast_unsigned()`
 ...
 LL |     m!();
    |     ---- in this macro invocation
@@ -752,5 +752,17 @@ LL -     (255 % 999999u64) as u8;
 LL +     u8::try_from(255 % 999999u64);
    |
 
-error: aborting due to 92 previous errors
+error: casting `u8` to `i8` may wrap around the value
+  --> tests/ui/cast.rs:576:13
+   |
+LL |         _ = 1u8 as i8;
+   |             ^^^^^^^^^ help: if this is intentional, use `cast_signed()` instead: `1u8.cast_signed()`
+
+error: casting `u8` to `i8` may wrap around the value
+  --> tests/ui/cast.rs:581:13
+   |
+LL |         _ = 1u8 as i8;
+   |             ^^^^^^^^^
+
+error: aborting due to 94 previous errors
 
diff --git a/tests/ui/checked_unwrap/simple_conditionals.rs b/tests/ui/checked_unwrap/simple_conditionals.rs
index 785b2473c0530..bba264080b406 100644
--- a/tests/ui/checked_unwrap/simple_conditionals.rs
+++ b/tests/ui/checked_unwrap/simple_conditionals.rs
@@ -273,6 +273,28 @@ const ISSUE14763: fn(Option<String>) = |x| {
     }
 };
 
+fn issue12295() {
+    let option = Some(());
+
+    if option.is_some() {
+        println!("{:?}", option.unwrap());
+        //~^ unnecessary_unwrap
+    } else {
+        println!("{:?}", option.unwrap());
+        //~^ panicking_unwrap
+    }
+
+    let result = Ok::<(), ()>(());
+
+    if result.is_ok() {
+        println!("{:?}", result.unwrap());
+        //~^ unnecessary_unwrap
+    } else {
+        println!("{:?}", result.unwrap());
+        //~^ panicking_unwrap
+    }
+}
+
 fn check_expect() {
     let x = Some(());
     if x.is_some() {
diff --git a/tests/ui/checked_unwrap/simple_conditionals.stderr b/tests/ui/checked_unwrap/simple_conditionals.stderr
index 939b509d85c91..2007a85954137 100644
--- a/tests/ui/checked_unwrap/simple_conditionals.stderr
+++ b/tests/ui/checked_unwrap/simple_conditionals.stderr
@@ -322,6 +322,40 @@ LL |         if x.is_some() {
 LL |             _ = x.unwrap();
    |                 ^^^^^^^^^^
 
+error: called `unwrap` on `option` after checking its variant with `is_some`
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:280:26
+   |
+LL |     if option.is_some() {
+   |     ------------------- help: try: `if let Some(<item>) = option`
+LL |         println!("{:?}", option.unwrap());
+   |                          ^^^^^^^^^^^^^^^
+
+error: this call to `unwrap()` will always panic
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:283:26
+   |
+LL |     if option.is_some() {
+   |        ---------------- because of this check
+...
+LL |         println!("{:?}", option.unwrap());
+   |                          ^^^^^^^^^^^^^^^
+
+error: called `unwrap` on `result` after checking its variant with `is_ok`
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:290:26
+   |
+LL |     if result.is_ok() {
+   |     ----------------- help: try: `if let Ok(<item>) = result`
+LL |         println!("{:?}", result.unwrap());
+   |                          ^^^^^^^^^^^^^^^
+
+error: this call to `unwrap()` will always panic
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:293:26
+   |
+LL |     if result.is_ok() {
+   |        -------------- because of this check
+...
+LL |         println!("{:?}", result.unwrap());
+   |                          ^^^^^^^^^^^^^^^
+
 error: creating a shared reference to mutable static
   --> tests/ui/checked_unwrap/simple_conditionals.rs:183:12
    |
@@ -332,5 +366,5 @@ LL |         if X.is_some() {
    = note: shared references to mutable statics are dangerous; it's undefined behavior if the static is mutated or if a mutable reference is created for it while the shared reference lives
    = note: `#[deny(static_mut_refs)]` (part of `#[deny(rust_2024_compatibility)]`) on by default
 
-error: aborting due to 36 previous errors
+error: aborting due to 40 previous errors
 
diff --git a/tests/ui/crashes/ice-15657.rs b/tests/ui/crashes/ice-15657.rs
new file mode 100644
index 0000000000000..c6f6506cd8d03
--- /dev/null
+++ b/tests/ui/crashes/ice-15657.rs
@@ -0,0 +1,11 @@
+//@check-pass
+#![warn(clippy::len_zero)]
+
+pub struct S1;
+pub struct S2;
+
+impl S1 {
+    pub fn len(&self) -> S2 {
+        S2
+    }
+}
diff --git a/tests/ui/crashes/ice-15666.fixed b/tests/ui/crashes/ice-15666.fixed
new file mode 100644
index 0000000000000..53b618765c0f0
--- /dev/null
+++ b/tests/ui/crashes/ice-15666.fixed
@@ -0,0 +1,6 @@
+#![warn(clippy::elidable_lifetime_names)]
+
+struct UnitVariantAccess<'a, 'b, 's>(&'a &'b &'s ());
+trait Trait<'de> {}
+impl<'de> Trait<'de> for UnitVariantAccess<'_, 'de, '_> {}
+//~^ elidable_lifetime_names
diff --git a/tests/ui/crashes/ice-15666.rs b/tests/ui/crashes/ice-15666.rs
new file mode 100644
index 0000000000000..1414b3d2035e4
--- /dev/null
+++ b/tests/ui/crashes/ice-15666.rs
@@ -0,0 +1,6 @@
+#![warn(clippy::elidable_lifetime_names)]
+
+struct UnitVariantAccess<'a, 'b, 's>(&'a &'b &'s ());
+trait Trait<'de> {}
+impl<'de, 'a, 's> Trait<'de> for UnitVariantAccess<'a, 'de, 's> {}
+//~^ elidable_lifetime_names
diff --git a/tests/ui/crashes/ice-15666.stderr b/tests/ui/crashes/ice-15666.stderr
new file mode 100644
index 0000000000000..b417c09b5c65a
--- /dev/null
+++ b/tests/ui/crashes/ice-15666.stderr
@@ -0,0 +1,16 @@
+error: the following explicit lifetimes could be elided: 'a, 's
+  --> tests/ui/crashes/ice-15666.rs:5:11
+   |
+LL | impl<'de, 'a, 's> Trait<'de> for UnitVariantAccess<'a, 'de, 's> {}
+   |           ^^  ^^                                   ^^       ^^
+   |
+   = note: `-D clippy::elidable-lifetime-names` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::elidable_lifetime_names)]`
+help: elide the lifetimes
+   |
+LL - impl<'de, 'a, 's> Trait<'de> for UnitVariantAccess<'a, 'de, 's> {}
+LL + impl<'de> Trait<'de> for UnitVariantAccess<'_, 'de, '_> {}
+   |
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/elidable_lifetime_names.fixed b/tests/ui/elidable_lifetime_names.fixed
index abeee5c4cef34..a6c4cb7a36a8d 100644
--- a/tests/ui/elidable_lifetime_names.fixed
+++ b/tests/ui/elidable_lifetime_names.fixed
@@ -192,3 +192,85 @@ mod issue13923 {
         x.b
     }
 }
+
+fn issue15666_original() {
+    struct UnitVariantAccess<'a, 'b, 's>(&'a &'b &'s ());
+
+    trait Trait<'de> {}
+
+    //~v elidable_lifetime_names
+    impl<'de> Trait<'de> for UnitVariantAccess<'_, 'de, '_> {}
+    //        ^^  ^^                                   ^^       ^^
+}
+
+#[allow(clippy::upper_case_acronyms)]
+fn issue15666() {
+    struct S1<'a>(&'a ());
+    struct S2<'a, 'b>(&'a &'b ());
+    struct S3<'a, 'b, 'c>(&'a &'b &'c ());
+
+    trait T {}
+    trait TA<'a> {}
+    trait TB<'b> {}
+    trait TC<'c> {}
+    trait TAB<'a, 'b> {}
+    trait TAC<'a, 'c> {}
+    trait TBC<'b, 'c> {}
+    trait TABC<'a, 'b, 'c> {}
+
+    // 1 lifetime
+
+    impl<'a> TA<'a> for S1<'a> {}
+
+    //~v elidable_lifetime_names
+    impl T for S1<'_> {}
+    //   ^^
+
+    // 2 lifetimes
+
+    impl<'a, 'b> TAB<'a, 'b> for S2<'a, 'b> {}
+
+    //~v elidable_lifetime_names
+    impl<'a> TA<'a> for S2<'a, '_> {}
+    //       ^^
+
+    //~v elidable_lifetime_names
+    impl<'b> TB<'b> for S2<'_, 'b> {}
+    //   ^^
+
+    //~v elidable_lifetime_names
+    impl T for S2<'_, '_> {}
+    //   ^^  ^^
+
+    // 3 lifetimes
+
+    impl<'a, 'b, 'c> TABC<'a, 'b, 'c> for S3<'a, 'b, 'c> {}
+
+    //~v elidable_lifetime_names
+    impl<'a, 'b> TAB<'a, 'b> for S3<'a, 'b, '_> {}
+    //           ^^
+
+    //~v elidable_lifetime_names
+    impl<'a, 'c> TAC<'a, 'c> for S3<'a, '_, 'c> {}
+    //       ^^
+
+    //~v elidable_lifetime_names
+    impl<'a> TA<'a> for S3<'a, '_, '_> {}
+    //       ^^  ^^
+
+    //~v elidable_lifetime_names
+    impl<'b, 'c> TBC<'b, 'c> for S3<'_, 'b, 'c> {}
+    //   ^^
+
+    //~v elidable_lifetime_names
+    impl<'b> TB<'b> for S3<'_, 'b, '_> {}
+    //   ^^      ^^
+
+    //~v elidable_lifetime_names
+    impl<'c> TC<'c> for S3<'_, '_, 'c> {}
+    //   ^^  ^^
+
+    //~v elidable_lifetime_names
+    impl T for S3<'_, '_, '_> {}
+    //   ^^  ^^  ^^
+}
diff --git a/tests/ui/elidable_lifetime_names.rs b/tests/ui/elidable_lifetime_names.rs
index fae3577a8e960..e08056b2fb56b 100644
--- a/tests/ui/elidable_lifetime_names.rs
+++ b/tests/ui/elidable_lifetime_names.rs
@@ -192,3 +192,85 @@ mod issue13923 {
         x.b
     }
 }
+
+fn issue15666_original() {
+    struct UnitVariantAccess<'a, 'b, 's>(&'a &'b &'s ());
+
+    trait Trait<'de> {}
+
+    //~v elidable_lifetime_names
+    impl<'de, 'a, 's> Trait<'de> for UnitVariantAccess<'a, 'de, 's> {}
+    //        ^^  ^^                                   ^^       ^^
+}
+
+#[allow(clippy::upper_case_acronyms)]
+fn issue15666() {
+    struct S1<'a>(&'a ());
+    struct S2<'a, 'b>(&'a &'b ());
+    struct S3<'a, 'b, 'c>(&'a &'b &'c ());
+
+    trait T {}
+    trait TA<'a> {}
+    trait TB<'b> {}
+    trait TC<'c> {}
+    trait TAB<'a, 'b> {}
+    trait TAC<'a, 'c> {}
+    trait TBC<'b, 'c> {}
+    trait TABC<'a, 'b, 'c> {}
+
+    // 1 lifetime
+
+    impl<'a> TA<'a> for S1<'a> {}
+
+    //~v elidable_lifetime_names
+    impl<'a> T for S1<'a> {}
+    //   ^^
+
+    // 2 lifetimes
+
+    impl<'a, 'b> TAB<'a, 'b> for S2<'a, 'b> {}
+
+    //~v elidable_lifetime_names
+    impl<'a, 'b> TA<'a> for S2<'a, 'b> {}
+    //       ^^
+
+    //~v elidable_lifetime_names
+    impl<'a, 'b> TB<'b> for S2<'a, 'b> {}
+    //   ^^
+
+    //~v elidable_lifetime_names
+    impl<'a, 'b> T for S2<'a, 'b> {}
+    //   ^^  ^^
+
+    // 3 lifetimes
+
+    impl<'a, 'b, 'c> TABC<'a, 'b, 'c> for S3<'a, 'b, 'c> {}
+
+    //~v elidable_lifetime_names
+    impl<'a, 'b, 'c> TAB<'a, 'b> for S3<'a, 'b, 'c> {}
+    //           ^^
+
+    //~v elidable_lifetime_names
+    impl<'a, 'b, 'c> TAC<'a, 'c> for S3<'a, 'b, 'c> {}
+    //       ^^
+
+    //~v elidable_lifetime_names
+    impl<'a, 'b, 'c> TA<'a> for S3<'a, 'b, 'c> {}
+    //       ^^  ^^
+
+    //~v elidable_lifetime_names
+    impl<'a, 'b, 'c> TBC<'b, 'c> for S3<'a, 'b, 'c> {}
+    //   ^^
+
+    //~v elidable_lifetime_names
+    impl<'a, 'b, 'c> TB<'b> for S3<'a, 'b, 'c> {}
+    //   ^^      ^^
+
+    //~v elidable_lifetime_names
+    impl<'a, 'b, 'c> TC<'c> for S3<'a, 'b, 'c> {}
+    //   ^^  ^^
+
+    //~v elidable_lifetime_names
+    impl<'a, 'b, 'c> T for S3<'a, 'b, 'c> {}
+    //   ^^  ^^  ^^
+}
diff --git a/tests/ui/elidable_lifetime_names.stderr b/tests/ui/elidable_lifetime_names.stderr
index a60dfc697564e..03fe383b8f67f 100644
--- a/tests/ui/elidable_lifetime_names.stderr
+++ b/tests/ui/elidable_lifetime_names.stderr
@@ -158,5 +158,149 @@ LL |             o: &'t str,
 LL ~         ) -> Content<'t, '_> {
    |
 
-error: aborting due to 12 previous errors
+error: the following explicit lifetimes could be elided: 'a, 's
+  --> tests/ui/elidable_lifetime_names.rs:202:15
+   |
+LL |     impl<'de, 'a, 's> Trait<'de> for UnitVariantAccess<'a, 'de, 's> {}
+   |               ^^  ^^                                   ^^       ^^
+   |
+help: elide the lifetimes
+   |
+LL -     impl<'de, 'a, 's> Trait<'de> for UnitVariantAccess<'a, 'de, 's> {}
+LL +     impl<'de> Trait<'de> for UnitVariantAccess<'_, 'de, '_> {}
+   |
+
+error: the following explicit lifetimes could be elided: 'a
+  --> tests/ui/elidable_lifetime_names.rs:226:10
+   |
+LL |     impl<'a> T for S1<'a> {}
+   |          ^^           ^^
+   |
+help: elide the lifetimes
+   |
+LL -     impl<'a> T for S1<'a> {}
+LL +     impl T for S1<'_> {}
+   |
+
+error: the following explicit lifetimes could be elided: 'b
+  --> tests/ui/elidable_lifetime_names.rs:234:14
+   |
+LL |     impl<'a, 'b> TA<'a> for S2<'a, 'b> {}
+   |              ^^                    ^^
+   |
+help: elide the lifetimes
+   |
+LL -     impl<'a, 'b> TA<'a> for S2<'a, 'b> {}
+LL +     impl<'a> TA<'a> for S2<'a, '_> {}
+   |
+
+error: the following explicit lifetimes could be elided: 'a
+  --> tests/ui/elidable_lifetime_names.rs:238:10
+   |
+LL |     impl<'a, 'b> TB<'b> for S2<'a, 'b> {}
+   |          ^^                    ^^
+   |
+help: elide the lifetimes
+   |
+LL -     impl<'a, 'b> TB<'b> for S2<'a, 'b> {}
+LL +     impl<'b> TB<'b> for S2<'_, 'b> {}
+   |
+
+error: the following explicit lifetimes could be elided: 'a, 'b
+  --> tests/ui/elidable_lifetime_names.rs:242:10
+   |
+LL |     impl<'a, 'b> T for S2<'a, 'b> {}
+   |          ^^  ^^           ^^  ^^
+   |
+help: elide the lifetimes
+   |
+LL -     impl<'a, 'b> T for S2<'a, 'b> {}
+LL +     impl T for S2<'_, '_> {}
+   |
+
+error: the following explicit lifetimes could be elided: 'c
+  --> tests/ui/elidable_lifetime_names.rs:250:18
+   |
+LL |     impl<'a, 'b, 'c> TAB<'a, 'b> for S3<'a, 'b, 'c> {}
+   |                  ^^                             ^^
+   |
+help: elide the lifetimes
+   |
+LL -     impl<'a, 'b, 'c> TAB<'a, 'b> for S3<'a, 'b, 'c> {}
+LL +     impl<'a, 'b> TAB<'a, 'b> for S3<'a, 'b, '_> {}
+   |
+
+error: the following explicit lifetimes could be elided: 'b
+  --> tests/ui/elidable_lifetime_names.rs:254:14
+   |
+LL |     impl<'a, 'b, 'c> TAC<'a, 'c> for S3<'a, 'b, 'c> {}
+   |              ^^                             ^^
+   |
+help: elide the lifetimes
+   |
+LL -     impl<'a, 'b, 'c> TAC<'a, 'c> for S3<'a, 'b, 'c> {}
+LL +     impl<'a, 'c> TAC<'a, 'c> for S3<'a, '_, 'c> {}
+   |
+
+error: the following explicit lifetimes could be elided: 'b, 'c
+  --> tests/ui/elidable_lifetime_names.rs:258:14
+   |
+LL |     impl<'a, 'b, 'c> TA<'a> for S3<'a, 'b, 'c> {}
+   |              ^^  ^^                    ^^  ^^
+   |
+help: elide the lifetimes
+   |
+LL -     impl<'a, 'b, 'c> TA<'a> for S3<'a, 'b, 'c> {}
+LL +     impl<'a> TA<'a> for S3<'a, '_, '_> {}
+   |
+
+error: the following explicit lifetimes could be elided: 'a
+  --> tests/ui/elidable_lifetime_names.rs:262:10
+   |
+LL |     impl<'a, 'b, 'c> TBC<'b, 'c> for S3<'a, 'b, 'c> {}
+   |          ^^                             ^^
+   |
+help: elide the lifetimes
+   |
+LL -     impl<'a, 'b, 'c> TBC<'b, 'c> for S3<'a, 'b, 'c> {}
+LL +     impl<'b, 'c> TBC<'b, 'c> for S3<'_, 'b, 'c> {}
+   |
+
+error: the following explicit lifetimes could be elided: 'a, 'c
+  --> tests/ui/elidable_lifetime_names.rs:266:10
+   |
+LL |     impl<'a, 'b, 'c> TB<'b> for S3<'a, 'b, 'c> {}
+   |          ^^      ^^                ^^      ^^
+   |
+help: elide the lifetimes
+   |
+LL -     impl<'a, 'b, 'c> TB<'b> for S3<'a, 'b, 'c> {}
+LL +     impl<'b> TB<'b> for S3<'_, 'b, '_> {}
+   |
+
+error: the following explicit lifetimes could be elided: 'a, 'b
+  --> tests/ui/elidable_lifetime_names.rs:270:10
+   |
+LL |     impl<'a, 'b, 'c> TC<'c> for S3<'a, 'b, 'c> {}
+   |          ^^  ^^                    ^^  ^^
+   |
+help: elide the lifetimes
+   |
+LL -     impl<'a, 'b, 'c> TC<'c> for S3<'a, 'b, 'c> {}
+LL +     impl<'c> TC<'c> for S3<'_, '_, 'c> {}
+   |
+
+error: the following explicit lifetimes could be elided: 'a, 'b, 'c
+  --> tests/ui/elidable_lifetime_names.rs:274:10
+   |
+LL |     impl<'a, 'b, 'c> T for S3<'a, 'b, 'c> {}
+   |          ^^  ^^  ^^           ^^  ^^  ^^
+   |
+help: elide the lifetimes
+   |
+LL -     impl<'a, 'b, 'c> T for S3<'a, 'b, 'c> {}
+LL +     impl T for S3<'_, '_, '_> {}
+   |
+
+error: aborting due to 24 previous errors
 
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index 6944a979c05e6..107318e5323d0 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -635,3 +635,11 @@ fn issue8817() {
         //~| HELP: replace the closure with the tuple variant itself
         .unwrap(); // just for nicer formatting
 }
+
+async fn issue13892<'a, T, F>(maybe: Option<&'a T>, visitor: F)
+where
+    F: AsyncFn(&'a T),
+    T: 'a,
+{
+    maybe.map(|x| visitor(x));
+}
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index 5bcc1cb26fd78..b85e8e75153a1 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -635,3 +635,11 @@ fn issue8817() {
         //~| HELP: replace the closure with the tuple variant itself
         .unwrap(); // just for nicer formatting
 }
+
+async fn issue13892<'a, T, F>(maybe: Option<&'a T>, visitor: F)
+where
+    F: AsyncFn(&'a T),
+    T: 'a,
+{
+    maybe.map(|x| visitor(x));
+}
diff --git a/tests/ui/invalid_upcast_comparisons.rs b/tests/ui/invalid_upcast_comparisons.rs
index 4f3194869f430..88ecca65e1509 100644
--- a/tests/ui/invalid_upcast_comparisons.rs
+++ b/tests/ui/invalid_upcast_comparisons.rs
@@ -133,3 +133,15 @@ fn main() {
 
     -5 == (u32 as i32);
 }
+
+fn issue15662() {
+    macro_rules! add_one {
+        ($x:expr) => {
+            $x + 1
+        };
+    }
+
+    let x: u8 = 1;
+    (add_one!(x) as u32) > 300;
+    //~^ invalid_upcast_comparisons
+}
diff --git a/tests/ui/invalid_upcast_comparisons.stderr b/tests/ui/invalid_upcast_comparisons.stderr
index ef36f18eabc9a..cc042a7c4b01e 100644
--- a/tests/ui/invalid_upcast_comparisons.stderr
+++ b/tests/ui/invalid_upcast_comparisons.stderr
@@ -163,5 +163,11 @@ error: because of the numeric bounds on `u8` prior to casting, this expression i
 LL |     -5 >= (u8 as i32);
    |     ^^^^^^^^^^^^^^^^^
 
-error: aborting due to 27 previous errors
+error: because of the numeric bounds on `add_one!(x)` prior to casting, this expression is always false
+  --> tests/ui/invalid_upcast_comparisons.rs:145:5
+   |
+LL |     (add_one!(x) as u32) > 300;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 28 previous errors
 
diff --git a/tests/ui/iter_overeager_cloned.fixed b/tests/ui/iter_overeager_cloned.fixed
index b0e548f179093..4171f19469a4d 100644
--- a/tests/ui/iter_overeager_cloned.fixed
+++ b/tests/ui/iter_overeager_cloned.fixed
@@ -1,4 +1,4 @@
-#![warn(clippy::iter_overeager_cloned, clippy::redundant_clone, clippy::filter_next)]
+#![warn(clippy::iter_overeager_cloned, clippy::redundant_iter_cloned, clippy::filter_next)]
 #![allow(
     dead_code,
     clippy::let_unit_value,
@@ -16,7 +16,7 @@ fn main() {
     //~^ iter_overeager_cloned
 
     let _: usize = vec.iter().filter(|x| x == &"2").count();
-    //~^ redundant_clone
+    //~^ redundant_iter_cloned
 
     let _: Vec<_> = vec.iter().take(2).cloned().collect();
     //~^ iter_overeager_cloned
@@ -77,19 +77,19 @@ fn main() {
     }
 
     let _ = vec.iter().map(|x| x.len());
-    //~^ redundant_clone
+    //~^ redundant_iter_cloned
 
     // This would fail if changed.
     let _ = vec.iter().cloned().map(|x| x + "2");
 
     let _ = vec.iter().for_each(|x| assert!(!x.is_empty()));
-    //~^ redundant_clone
+    //~^ redundant_iter_cloned
 
     let _ = vec.iter().all(|x| x.len() == 1);
-    //~^ redundant_clone
+    //~^ redundant_iter_cloned
 
     let _ = vec.iter().any(|x| x.len() == 1);
-    //~^ redundant_clone
+    //~^ redundant_iter_cloned
 
     // Should probably stay as it is.
     let _ = [0, 1, 2, 3, 4].iter().cloned().take(10);
diff --git a/tests/ui/iter_overeager_cloned.rs b/tests/ui/iter_overeager_cloned.rs
index cedf62a6b4730..fe6aba24dd3e2 100644
--- a/tests/ui/iter_overeager_cloned.rs
+++ b/tests/ui/iter_overeager_cloned.rs
@@ -1,4 +1,4 @@
-#![warn(clippy::iter_overeager_cloned, clippy::redundant_clone, clippy::filter_next)]
+#![warn(clippy::iter_overeager_cloned, clippy::redundant_iter_cloned, clippy::filter_next)]
 #![allow(
     dead_code,
     clippy::let_unit_value,
@@ -16,7 +16,7 @@ fn main() {
     //~^ iter_overeager_cloned
 
     let _: usize = vec.iter().filter(|x| x == &"2").cloned().count();
-    //~^ redundant_clone
+    //~^ redundant_iter_cloned
 
     let _: Vec<_> = vec.iter().cloned().take(2).collect();
     //~^ iter_overeager_cloned
@@ -78,19 +78,19 @@ fn main() {
     }
 
     let _ = vec.iter().cloned().map(|x| x.len());
-    //~^ redundant_clone
+    //~^ redundant_iter_cloned
 
     // This would fail if changed.
     let _ = vec.iter().cloned().map(|x| x + "2");
 
     let _ = vec.iter().cloned().for_each(|x| assert!(!x.is_empty()));
-    //~^ redundant_clone
+    //~^ redundant_iter_cloned
 
     let _ = vec.iter().cloned().all(|x| x.len() == 1);
-    //~^ redundant_clone
+    //~^ redundant_iter_cloned
 
     let _ = vec.iter().cloned().any(|x| x.len() == 1);
-    //~^ redundant_clone
+    //~^ redundant_iter_cloned
 
     // Should probably stay as it is.
     let _ = [0, 1, 2, 3, 4].iter().cloned().take(10);
diff --git a/tests/ui/iter_overeager_cloned.stderr b/tests/ui/iter_overeager_cloned.stderr
index 1616dec95b792..f234d19e4aaaa 100644
--- a/tests/ui/iter_overeager_cloned.stderr
+++ b/tests/ui/iter_overeager_cloned.stderr
@@ -25,8 +25,8 @@ LL |     let _: usize = vec.iter().filter(|x| x == &"2").cloned().count();
    |                                                    |
    |                                                    help: try: `.count()`
    |
-   = note: `-D clippy::redundant-clone` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::redundant_clone)]`
+   = note: `-D clippy::redundant-iter-cloned` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::redundant_iter_cloned)]`
 
 error: unnecessarily eager cloning of iterator items
   --> tests/ui/iter_overeager_cloned.rs:21:21
diff --git a/tests/ui/match_as_ref.fixed b/tests/ui/match_as_ref.fixed
index 8c07076af4a49..a39f0c9299bd5 100644
--- a/tests/ui/match_as_ref.fixed
+++ b/tests/ui/match_as_ref.fixed
@@ -41,3 +41,33 @@ fn main() {
         None => None,
     };
 }
+
+mod issue15691 {
+    use std::ops::{Deref, DerefMut};
+
+    struct A(B);
+    struct B;
+
+    impl Deref for A {
+        type Target = B;
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    impl DerefMut for A {
+        fn deref_mut(&mut self) -> &mut Self::Target {
+            &mut self.0
+        }
+    }
+
+    fn func() {
+        let mut a = Some(A(B));
+        let mut b = Some(B);
+        // Do not lint, we don't have `None => None`
+        let _ = match b {
+            Some(ref mut x) => Some(x),
+            None => a.as_deref_mut(),
+        };
+    }
+}
diff --git a/tests/ui/match_as_ref.rs b/tests/ui/match_as_ref.rs
index 3a5b1227331e7..049928167901a 100644
--- a/tests/ui/match_as_ref.rs
+++ b/tests/ui/match_as_ref.rs
@@ -53,3 +53,33 @@ fn main() {
         None => None,
     };
 }
+
+mod issue15691 {
+    use std::ops::{Deref, DerefMut};
+
+    struct A(B);
+    struct B;
+
+    impl Deref for A {
+        type Target = B;
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    impl DerefMut for A {
+        fn deref_mut(&mut self) -> &mut Self::Target {
+            &mut self.0
+        }
+    }
+
+    fn func() {
+        let mut a = Some(A(B));
+        let mut b = Some(B);
+        // Do not lint, we don't have `None => None`
+        let _ = match b {
+            Some(ref mut x) => Some(x),
+            None => a.as_deref_mut(),
+        };
+    }
+}
diff --git a/tests/ui/multiple_unsafe_ops_per_block.rs b/tests/ui/multiple_unsafe_ops_per_block.rs
index 016fd89a7b7ac..132673d5164ab 100644
--- a/tests/ui/multiple_unsafe_ops_per_block.rs
+++ b/tests/ui/multiple_unsafe_ops_per_block.rs
@@ -1,10 +1,10 @@
 //@needs-asm-support
 //@aux-build:proc_macros.rs
-#![allow(unused)]
-#![allow(deref_nullptr)]
-#![allow(clippy::unnecessary_operation)]
-#![allow(dropping_copy_types)]
-#![allow(clippy::assign_op_pattern)]
+#![expect(
+    dropping_copy_types,
+    clippy::unnecessary_operation,
+    clippy::unnecessary_literal_unwrap
+)]
 #![warn(clippy::multiple_unsafe_ops_per_block)]
 
 extern crate proc_macros;
@@ -105,17 +105,17 @@ fn correct3() {
     }
 }
 
-// tests from the issue (https://github.com/rust-lang/rust-clippy/issues/10064)
-
-unsafe fn read_char_bad(ptr: *const u8) -> char {
-    unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
-    //~^ multiple_unsafe_ops_per_block
-}
+fn issue10064() {
+    unsafe fn read_char_bad(ptr: *const u8) -> char {
+        unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
+        //~^ multiple_unsafe_ops_per_block
+    }
 
-// no lint
-unsafe fn read_char_good(ptr: *const u8) -> char {
-    let int_value = unsafe { *ptr.cast::<u32>() };
-    unsafe { core::char::from_u32_unchecked(int_value) }
+    // no lint
+    unsafe fn read_char_good(ptr: *const u8) -> char {
+        let int_value = unsafe { *ptr.cast::<u32>() };
+        unsafe { core::char::from_u32_unchecked(int_value) }
+    }
 }
 
 // no lint
@@ -126,42 +126,87 @@ fn issue10259() {
     });
 }
 
-fn _fn_ptr(x: unsafe fn()) {
-    unsafe {
-        //~^ multiple_unsafe_ops_per_block
-        x();
-        x();
+fn issue10367() {
+    fn fn_ptr(x: unsafe fn()) {
+        unsafe {
+            //~^ multiple_unsafe_ops_per_block
+            x();
+            x();
+        }
     }
-}
 
-fn _assoc_const() {
-    trait X {
-        const X: unsafe fn();
+    fn assoc_const() {
+        trait X {
+            const X: unsafe fn();
+        }
+        fn _f<T: X>() {
+            unsafe {
+                //~^ multiple_unsafe_ops_per_block
+                T::X();
+                T::X();
+            }
+        }
     }
-    fn _f<T: X>() {
+
+    fn field_fn_ptr(x: unsafe fn()) {
+        struct X(unsafe fn());
+        let x = X(x);
         unsafe {
             //~^ multiple_unsafe_ops_per_block
-            T::X();
-            T::X();
+            x.0();
+            x.0();
         }
     }
 }
 
-fn _field_fn_ptr(x: unsafe fn()) {
-    struct X(unsafe fn());
-    let x = X(x);
+// await expands to an unsafe block with several operations, but this is fine.
+async fn issue11312() {
+    async fn helper() {}
+
+    helper().await;
+}
+
+async fn issue13879() {
+    async fn foo() {}
+
+    // no lint: nothing unsafe beyond the `await` which we ignore
+    unsafe {
+        foo().await;
+    }
+
+    // no lint: only one unsafe call beyond the `await`
+    unsafe {
+        not_very_safe();
+        foo().await;
+    }
+
+    // lint: two unsafe calls beyond the `await`
     unsafe {
         //~^ multiple_unsafe_ops_per_block
-        x.0();
-        x.0();
+        not_very_safe();
+        STATIC += 1;
+        foo().await;
     }
-}
 
-// await expands to an unsafe block with several operations, but this is fine.: #11312
-async fn await_desugaring_silent() {
-    async fn helper() {}
+    async unsafe fn foo_unchecked() {}
 
-    helper().await;
+    // no lint: only one unsafe call in the `await`ed expr
+    unsafe {
+        foo_unchecked().await;
+    }
+
+    // lint: one unsafe call in the `await`ed expr, and one outside
+    unsafe {
+        //~^ multiple_unsafe_ops_per_block
+        not_very_safe();
+        foo_unchecked().await;
+    }
+
+    // lint: two unsafe calls in the `await`ed expr
+    unsafe {
+        //~^ multiple_unsafe_ops_per_block
+        Some(foo_unchecked()).unwrap_unchecked().await;
+    }
 }
 
 fn main() {}
diff --git a/tests/ui/multiple_unsafe_ops_per_block.stderr b/tests/ui/multiple_unsafe_ops_per_block.stderr
index 3130cecc25250..922a464c6b6ef 100644
--- a/tests/ui/multiple_unsafe_ops_per_block.stderr
+++ b/tests/ui/multiple_unsafe_ops_per_block.stderr
@@ -113,84 +113,147 @@ LL |         asm!("nop");
    |         ^^^^^^^^^^^
 
 error: this `unsafe` block contains 2 unsafe operations, expected only one
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:111:5
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:110:9
    |
-LL |     unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:111:14
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:110:18
    |
-LL |     unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: raw pointer dereference occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:111:39
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:110:43
    |
-LL |     unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
-   |                                       ^^^^^^^^^^^^^^^^^^
+LL |         unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
+   |                                           ^^^^^^^^^^^^^^^^^^
 
 error: this `unsafe` block contains 2 unsafe operations, expected only one
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:130:5
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:131:9
    |
-LL | /     unsafe {
+LL | /         unsafe {
 LL | |
-LL | |         x();
-LL | |         x();
-LL | |     }
-   | |_____^
+LL | |             x();
+LL | |             x();
+LL | |         }
+   | |_________^
    |
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:132:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:133:13
    |
-LL |         x();
-   |         ^^^
+LL |             x();
+   |             ^^^
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:133:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:134:13
    |
-LL |         x();
-   |         ^^^
+LL |             x();
+   |             ^^^
 
 error: this `unsafe` block contains 2 unsafe operations, expected only one
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:142:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:143:13
+   |
+LL | /             unsafe {
+LL | |
+LL | |                 T::X();
+LL | |                 T::X();
+LL | |             }
+   | |_____________^
+   |
+note: unsafe function call occurs here
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:145:17
+   |
+LL |                 T::X();
+   |                 ^^^^^^
+note: unsafe function call occurs here
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:146:17
+   |
+LL |                 T::X();
+   |                 ^^^^^^
+
+error: this `unsafe` block contains 2 unsafe operations, expected only one
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:154:9
    |
 LL | /         unsafe {
 LL | |
-LL | |             T::X();
-LL | |             T::X();
+LL | |             x.0();
+LL | |             x.0();
 LL | |         }
    | |_________^
    |
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:144:13
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:156:13
    |
-LL |             T::X();
-   |             ^^^^^^
+LL |             x.0();
+   |             ^^^^^
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:145:13
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:157:13
    |
-LL |             T::X();
-   |             ^^^^^^
+LL |             x.0();
+   |             ^^^^^
 
 error: this `unsafe` block contains 2 unsafe operations, expected only one
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:153:5
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:184:5
    |
 LL | /     unsafe {
 LL | |
-LL | |         x.0();
-LL | |         x.0();
+LL | |         not_very_safe();
+LL | |         STATIC += 1;
+LL | |         foo().await;
 LL | |     }
    | |_____^
    |
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:155:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:186:9
+   |
+LL |         not_very_safe();
+   |         ^^^^^^^^^^^^^^^
+note: modification of a mutable static occurs here
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:187:9
+   |
+LL |         STATIC += 1;
+   |         ^^^^^^^^^^^
+
+error: this `unsafe` block contains 2 unsafe operations, expected only one
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:199:5
+   |
+LL | /     unsafe {
+LL | |
+LL | |         not_very_safe();
+LL | |         foo_unchecked().await;
+LL | |     }
+   | |_____^
+   |
+note: unsafe function call occurs here
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:201:9
+   |
+LL |         not_very_safe();
+   |         ^^^^^^^^^^^^^^^
+note: unsafe function call occurs here
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:202:9
+   |
+LL |         foo_unchecked().await;
+   |         ^^^^^^^^^^^^^^^
+
+error: this `unsafe` block contains 2 unsafe operations, expected only one
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:206:5
+   |
+LL | /     unsafe {
+LL | |
+LL | |         Some(foo_unchecked()).unwrap_unchecked().await;
+LL | |     }
+   | |_____^
+   |
+note: unsafe method call occurs here
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:208:9
    |
-LL |         x.0();
-   |         ^^^^^
+LL |         Some(foo_unchecked()).unwrap_unchecked().await;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:156:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:208:14
    |
-LL |         x.0();
-   |         ^^^^^
+LL |         Some(foo_unchecked()).unwrap_unchecked().await;
+   |              ^^^^^^^^^^^^^^^
 
-error: aborting due to 8 previous errors
+error: aborting due to 11 previous errors
 
diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index d571b97f51946..f5f8bb21e815b 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -517,3 +517,10 @@ mod else_ifs {
         }
     }
 }
+
+fn issue14474() -> u64 {
+    return 456;
+
+    #[cfg(false)]
+    123
+}
diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs
index 2e4348ea338c0..495516c1c2e5d 100644
--- a/tests/ui/needless_return.rs
+++ b/tests/ui/needless_return.rs
@@ -526,3 +526,10 @@ mod else_ifs {
         }
     }
 }
+
+fn issue14474() -> u64 {
+    return 456;
+
+    #[cfg(false)]
+    123
+}
diff --git a/tests/ui/never_loop.rs b/tests/ui/never_loop.rs
index 48d4b8ad15196..01db64a446c0f 100644
--- a/tests/ui/never_loop.rs
+++ b/tests/ui/never_loop.rs
@@ -498,3 +498,27 @@ fn issue15059() {
         ()
     }
 }
+
+fn issue15350() {
+    'bar: for _ in 0..100 {
+        //~^ never_loop
+        loop {
+            //~^ never_loop
+            println!("This will still run");
+            break 'bar;
+        }
+    }
+
+    'foo: for _ in 0..100 {
+        //~^ never_loop
+        loop {
+            //~^ never_loop
+            println!("This will still run");
+            loop {
+                //~^ never_loop
+                println!("This will still run");
+                break 'foo;
+            }
+        }
+    }
+}
diff --git a/tests/ui/never_loop.stderr b/tests/ui/never_loop.stderr
index 54b463266a3a5..4fda06cff4ab9 100644
--- a/tests/ui/never_loop.stderr
+++ b/tests/ui/never_loop.stderr
@@ -193,6 +193,19 @@ LL | |         return;
 LL | |     }
    | |_____^
    |
+help: this code is unreachable. Consider moving the reachable parts out
+  --> tests/ui/never_loop.rs:436:9
+   |
+LL | /         loop {
+LL | |
+LL | |             break 'outer;
+LL | |         }
+   | |_________^
+help: this code is unreachable. Consider moving the reachable parts out
+  --> tests/ui/never_loop.rs:440:9
+   |
+LL |         return;
+   |         ^^^^^^^
 help: if you need the first element of the iterator, try writing
    |
 LL -     'outer: for v in 0..10 {
@@ -297,5 +310,87 @@ LL ~
 LL ~         
    |
 
-error: aborting due to 24 previous errors
+error: this loop never actually loops
+  --> tests/ui/never_loop.rs:503:5
+   |
+LL | /     'bar: for _ in 0..100 {
+LL | |
+LL | |         loop {
+...  |
+LL | |     }
+   | |_____^
+   |
+help: this code is unreachable. Consider moving the reachable parts out
+  --> tests/ui/never_loop.rs:505:9
+   |
+LL | /         loop {
+LL | |
+LL | |             println!("This will still run");
+LL | |             break 'bar;
+LL | |         }
+   | |_________^
+help: if you need the first element of the iterator, try writing
+   |
+LL -     'bar: for _ in 0..100 {
+LL +     if let Some(_) = (0..100).next() {
+   |
+
+error: this loop never actually loops
+  --> tests/ui/never_loop.rs:505:9
+   |
+LL | /         loop {
+LL | |
+LL | |             println!("This will still run");
+LL | |             break 'bar;
+LL | |         }
+   | |_________^
+
+error: this loop never actually loops
+  --> tests/ui/never_loop.rs:512:5
+   |
+LL | /     'foo: for _ in 0..100 {
+LL | |
+LL | |         loop {
+...  |
+LL | |     }
+   | |_____^
+   |
+help: this code is unreachable. Consider moving the reachable parts out
+  --> tests/ui/never_loop.rs:514:9
+   |
+LL | /         loop {
+LL | |
+LL | |             println!("This will still run");
+LL | |             loop {
+...  |
+LL | |         }
+   | |_________^
+help: if you need the first element of the iterator, try writing
+   |
+LL -     'foo: for _ in 0..100 {
+LL +     if let Some(_) = (0..100).next() {
+   |
+
+error: this loop never actually loops
+  --> tests/ui/never_loop.rs:514:9
+   |
+LL | /         loop {
+LL | |
+LL | |             println!("This will still run");
+LL | |             loop {
+...  |
+LL | |         }
+   | |_________^
+
+error: this loop never actually loops
+  --> tests/ui/never_loop.rs:517:13
+   |
+LL | /             loop {
+LL | |
+LL | |                 println!("This will still run");
+LL | |                 break 'foo;
+LL | |             }
+   | |_____________^
+
+error: aborting due to 29 previous errors
 
diff --git a/tests/ui/option_if_let_else.fixed b/tests/ui/option_if_let_else.fixed
index 0f86de5646cdb..6ce067f5c2462 100644
--- a/tests/ui/option_if_let_else.fixed
+++ b/tests/ui/option_if_let_else.fixed
@@ -125,6 +125,16 @@ fn complex_subpat() -> DummyEnum {
     DummyEnum::Two
 }
 
+// #10335
+pub fn test_result_err_ignored_1(r: Result<&[u8], &[u8]>) -> Vec<u8> {
+    r.map_or_else(|_| Vec::new(), |s| s.to_owned())
+}
+
+// #10335
+pub fn test_result_err_ignored_2(r: Result<&[u8], &[u8]>) -> Vec<u8> {
+    r.map_or_else(|_| Vec::new(), |s| s.to_owned())
+}
+
 fn main() {
     let optional = Some(5);
     let _ = optional.map_or(5, |x| x + 2);
diff --git a/tests/ui/option_if_let_else.rs b/tests/ui/option_if_let_else.rs
index 7aabd778f87e7..096d3aabf28db 100644
--- a/tests/ui/option_if_let_else.rs
+++ b/tests/ui/option_if_let_else.rs
@@ -152,6 +152,22 @@ fn complex_subpat() -> DummyEnum {
     DummyEnum::Two
 }
 
+// #10335
+pub fn test_result_err_ignored_1(r: Result<&[u8], &[u8]>) -> Vec<u8> {
+    match r {
+        //~^ option_if_let_else
+        Ok(s) => s.to_owned(),
+        Err(_) => Vec::new(),
+    }
+}
+
+// #10335
+pub fn test_result_err_ignored_2(r: Result<&[u8], &[u8]>) -> Vec<u8> {
+    if let Ok(s) = r { s.to_owned() }
+    //~^ option_if_let_else
+    else { Vec::new() }
+}
+
 fn main() {
     let optional = Some(5);
     let _ = if let Some(x) = optional { x + 2 } else { 5 };
diff --git a/tests/ui/option_if_let_else.stderr b/tests/ui/option_if_let_else.stderr
index 2e2fe6f20492b..21a80ae038d8c 100644
--- a/tests/ui/option_if_let_else.stderr
+++ b/tests/ui/option_if_let_else.stderr
@@ -188,14 +188,32 @@ LL +         true
 LL +     })
    |
 
+error: use Option::map_or_else instead of an if let/else
+  --> tests/ui/option_if_let_else.rs:157:5
+   |
+LL | /     match r {
+LL | |
+LL | |         Ok(s) => s.to_owned(),
+LL | |         Err(_) => Vec::new(),
+LL | |     }
+   | |_____^ help: try: `r.map_or_else(|_| Vec::new(), |s| s.to_owned())`
+
+error: use Option::map_or_else instead of an if let/else
+  --> tests/ui/option_if_let_else.rs:166:5
+   |
+LL | /     if let Ok(s) = r { s.to_owned() }
+LL | |
+LL | |     else { Vec::new() }
+   | |_______________________^ help: try: `r.map_or_else(|_| Vec::new(), |s| s.to_owned())`
+
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:157:13
+  --> tests/ui/option_if_let_else.rs:173:13
    |
 LL |     let _ = if let Some(x) = optional { x + 2 } else { 5 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `optional.map_or(5, |x| x + 2)`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:168:13
+  --> tests/ui/option_if_let_else.rs:184:13
    |
 LL |       let _ = if let Some(x) = Some(0) {
    |  _____________^
@@ -217,13 +235,13 @@ LL ~         });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:197:13
+  --> tests/ui/option_if_let_else.rs:213:13
    |
 LL |     let _ = if let Some(x) = Some(0) { s.len() + x } else { s.len() };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(0).map_or(s.len(), |x| s.len() + x)`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:202:13
+  --> tests/ui/option_if_let_else.rs:218:13
    |
 LL |       let _ = if let Some(x) = Some(0) {
    |  _____________^
@@ -245,7 +263,7 @@ LL ~     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:242:13
+  --> tests/ui/option_if_let_else.rs:258:13
    |
 LL |       let _ = match s {
    |  _____________^
@@ -256,7 +274,7 @@ LL | |     };
    | |_____^ help: try: `s.map_or(1, |string| string.len())`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:247:13
+  --> tests/ui/option_if_let_else.rs:263:13
    |
 LL |       let _ = match Some(10) {
    |  _____________^
@@ -267,7 +285,7 @@ LL | |     };
    | |_____^ help: try: `Some(10).map_or(5, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:254:13
+  --> tests/ui/option_if_let_else.rs:270:13
    |
 LL |       let _ = match res {
    |  _____________^
@@ -278,7 +296,7 @@ LL | |     };
    | |_____^ help: try: `res.map_or(1, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:259:13
+  --> tests/ui/option_if_let_else.rs:275:13
    |
 LL |       let _ = match res {
    |  _____________^
@@ -289,13 +307,13 @@ LL | |     };
    | |_____^ help: try: `res.map_or(1, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:264:13
+  --> tests/ui/option_if_let_else.rs:280:13
    |
 LL |     let _ = if let Ok(a) = res { a + 1 } else { 5 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `res.map_or(5, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:282:17
+  --> tests/ui/option_if_let_else.rs:298:17
    |
 LL |           let _ = match initial {
    |  _________________^
@@ -306,7 +324,7 @@ LL | |         };
    | |_________^ help: try: `initial.as_ref().map_or(42, |value| do_something(value))`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:290:17
+  --> tests/ui/option_if_let_else.rs:306:17
    |
 LL |           let _ = match initial {
    |  _________________^
@@ -317,7 +335,7 @@ LL | |         };
    | |_________^ help: try: `initial.as_mut().map_or(42, |value| do_something2(value))`
 
 error: use Option::map_or_else instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:314:24
+  --> tests/ui/option_if_let_else.rs:330:24
    |
 LL |       let mut _hashmap = if let Some(hm) = &opt {
    |  ________________________^
@@ -329,19 +347,19 @@ LL | |     };
    | |_____^ help: try: `opt.as_ref().map_or_else(HashMap::new, |hm| hm.clone())`
 
 error: use Option::map_or_else instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:321:19
+  --> tests/ui/option_if_let_else.rs:337:19
    |
 LL |     let mut _hm = if let Some(hm) = &opt { hm.clone() } else { new_map!() };
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `opt.as_ref().map_or_else(|| new_map!(), |hm| hm.clone())`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:372:22
+  --> tests/ui/option_if_let_else.rs:388:22
    |
 LL |     let _ = unsafe { if let Some(o) = *opt_raw_ptr { o } else { 1 } };
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(*opt_raw_ptr).map_or(1, |o| o)`
 
 error: use Option::map_or_else instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:378:13
+  --> tests/ui/option_if_let_else.rs:394:13
    |
 LL |       let _ = match res {
    |  _____________^
@@ -351,5 +369,5 @@ LL | |         Err(_) => String::new(),
 LL | |     };
    | |_____^ help: try: `res.map_or_else(|_| String::new(), |s| s.clone())`
 
-error: aborting due to 27 previous errors
+error: aborting due to 29 previous errors
 
diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index 0a8525a12f5e0..7a0be97017ebc 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -77,6 +77,22 @@ fn or_fun_call() {
     with_default_type.unwrap_or_default();
     //~^ unwrap_or_default
 
+    let with_default_literal = Some(1);
+    with_default_literal.unwrap_or(0);
+    // Do not lint because `.unwrap_or_default()` wouldn't be simpler
+
+    let with_default_literal = Some(1.0);
+    with_default_literal.unwrap_or(0.0);
+    // Do not lint because `.unwrap_or_default()` wouldn't be simpler
+
+    let with_default_literal = Some("foo");
+    with_default_literal.unwrap_or("");
+    // Do not lint because `.unwrap_or_default()` wouldn't be simpler
+
+    let with_default_vec_macro = Some(vec![1, 2, 3]);
+    with_default_vec_macro.unwrap_or(vec![]);
+    // Do not lint because `.unwrap_or_default()` wouldn't be simpler
+
     let self_default = None::<FakeDefault>;
     self_default.unwrap_or_else(<FakeDefault>::default);
     //~^ or_fun_call
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index b4f9b950a7fe0..724af606de9cf 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -77,6 +77,22 @@ fn or_fun_call() {
     with_default_type.unwrap_or(u64::default());
     //~^ unwrap_or_default
 
+    let with_default_literal = Some(1);
+    with_default_literal.unwrap_or(0);
+    // Do not lint because `.unwrap_or_default()` wouldn't be simpler
+
+    let with_default_literal = Some(1.0);
+    with_default_literal.unwrap_or(0.0);
+    // Do not lint because `.unwrap_or_default()` wouldn't be simpler
+
+    let with_default_literal = Some("foo");
+    with_default_literal.unwrap_or("");
+    // Do not lint because `.unwrap_or_default()` wouldn't be simpler
+
+    let with_default_vec_macro = Some(vec![1, 2, 3]);
+    with_default_vec_macro.unwrap_or(vec![]);
+    // Do not lint because `.unwrap_or_default()` wouldn't be simpler
+
     let self_default = None::<FakeDefault>;
     self_default.unwrap_or(<FakeDefault>::default());
     //~^ or_fun_call
@@ -86,7 +102,7 @@ fn or_fun_call() {
     //~^ unwrap_or_default
 
     let with_vec = Some(vec![1]);
-    with_vec.unwrap_or(vec![]);
+    with_vec.unwrap_or(Vec::new());
     //~^ unwrap_or_default
 
     let without_default = Some(Foo);
@@ -98,7 +114,7 @@ fn or_fun_call() {
     //~^ unwrap_or_default
 
     let mut map_vec = HashMap::<u64, Vec<i32>>::new();
-    map_vec.entry(42).or_insert(vec![]);
+    map_vec.entry(42).or_insert(Vec::new());
     //~^ unwrap_or_default
 
     let mut btree = BTreeMap::<u64, String>::new();
@@ -106,7 +122,7 @@ fn or_fun_call() {
     //~^ unwrap_or_default
 
     let mut btree_vec = BTreeMap::<u64, Vec<i32>>::new();
-    btree_vec.entry(42).or_insert(vec![]);
+    btree_vec.entry(42).or_insert(Vec::new());
     //~^ unwrap_or_default
 
     let stringy = Some(String::new());
diff --git a/tests/ui/or_fun_call.stderr b/tests/ui/or_fun_call.stderr
index 3e4df772668d7..40b25f91154dd 100644
--- a/tests/ui/or_fun_call.stderr
+++ b/tests/ui/or_fun_call.stderr
@@ -47,175 +47,175 @@ LL |     with_default_type.unwrap_or(u64::default());
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:81:18
+  --> tests/ui/or_fun_call.rs:97:18
    |
 LL |     self_default.unwrap_or(<FakeDefault>::default());
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(<FakeDefault>::default)`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:85:18
+  --> tests/ui/or_fun_call.rs:101:18
    |
 LL |     real_default.unwrap_or(<FakeDefault as Default>::default());
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:89:14
+  --> tests/ui/or_fun_call.rs:105:14
    |
-LL |     with_vec.unwrap_or(vec![]);
-   |              ^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
+LL |     with_vec.unwrap_or(Vec::new());
+   |              ^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:93:21
+  --> tests/ui/or_fun_call.rs:109:21
    |
 LL |     without_default.unwrap_or(Foo::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(Foo::new)`
 
 error: use of `or_insert` to construct default value
-  --> tests/ui/or_fun_call.rs:97:19
+  --> tests/ui/or_fun_call.rs:113:19
    |
 LL |     map.entry(42).or_insert(String::new());
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert` to construct default value
-  --> tests/ui/or_fun_call.rs:101:23
+  --> tests/ui/or_fun_call.rs:117:23
    |
-LL |     map_vec.entry(42).or_insert(vec![]);
-   |                       ^^^^^^^^^^^^^^^^^ help: try: `or_default()`
+LL |     map_vec.entry(42).or_insert(Vec::new());
+   |                       ^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert` to construct default value
-  --> tests/ui/or_fun_call.rs:105:21
+  --> tests/ui/or_fun_call.rs:121:21
    |
 LL |     btree.entry(42).or_insert(String::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert` to construct default value
-  --> tests/ui/or_fun_call.rs:109:25
+  --> tests/ui/or_fun_call.rs:125:25
    |
-LL |     btree_vec.entry(42).or_insert(vec![]);
-   |                         ^^^^^^^^^^^^^^^^^ help: try: `or_default()`
+LL |     btree_vec.entry(42).or_insert(Vec::new());
+   |                         ^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:113:21
+  --> tests/ui/or_fun_call.rs:129:21
    |
 LL |     let _ = stringy.unwrap_or(String::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `ok_or`
-  --> tests/ui/or_fun_call.rs:118:17
+  --> tests/ui/or_fun_call.rs:134:17
    |
 LL |     let _ = opt.ok_or(format!("{} world.", hello));
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `ok_or_else(|| format!("{} world.", hello))`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:123:21
+  --> tests/ui/or_fun_call.rs:139:21
    |
 LL |     let _ = Some(1).unwrap_or(map[&1]);
    |                     ^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| map[&1])`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:126:21
+  --> tests/ui/or_fun_call.rs:142:21
    |
 LL |     let _ = Some(1).unwrap_or(map[&1]);
    |                     ^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| map[&1])`
 
 error: function call inside of `or`
-  --> tests/ui/or_fun_call.rs:151:35
+  --> tests/ui/or_fun_call.rs:167:35
    |
 LL |     let _ = Some("a".to_string()).or(Some("b".to_string()));
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_else(|| Some("b".to_string()))`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:194:18
+  --> tests/ui/or_fun_call.rs:210:18
    |
 LL |             None.unwrap_or(ptr_to_ref(s));
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| ptr_to_ref(s))`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:202:14
+  --> tests/ui/or_fun_call.rs:218:14
    |
 LL |         None.unwrap_or(unsafe { ptr_to_ref(s) });
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| unsafe { ptr_to_ref(s) })`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:205:14
+  --> tests/ui/or_fun_call.rs:221:14
    |
 LL |         None.unwrap_or( unsafe { ptr_to_ref(s) }    );
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| unsafe { ptr_to_ref(s) })`
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:281:25
+  --> tests/ui/or_fun_call.rs:297:25
    |
 LL |         let _ = Some(4).map_or(g(), |v| v);
    |                         ^^^^^^^^^^^^^^^^^^ help: try: `map_or_else(g, |v| v)`
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:283:25
+  --> tests/ui/or_fun_call.rs:299:25
    |
 LL |         let _ = Some(4).map_or(g(), f);
    |                         ^^^^^^^^^^^^^^ help: try: `map_or_else(g, f)`
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:286:25
+  --> tests/ui/or_fun_call.rs:302:25
    |
 LL |         let _ = Some(4).map_or("asd".to_string().len() as i32, f);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map_or_else(|| "asd".to_string().len() as i32, f)`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:317:18
+  --> tests/ui/or_fun_call.rs:333:18
    |
 LL |         with_new.unwrap_or_else(Vec::new);
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:321:28
+  --> tests/ui/or_fun_call.rs:337:28
    |
 LL |         with_default_trait.unwrap_or_else(Default::default);
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:325:27
+  --> tests/ui/or_fun_call.rs:341:27
    |
 LL |         with_default_type.unwrap_or_else(u64::default);
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:329:22
+  --> tests/ui/or_fun_call.rs:345:22
    |
 LL |         real_default.unwrap_or_else(<FakeDefault as Default>::default);
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `or_insert_with` to construct default value
-  --> tests/ui/or_fun_call.rs:333:23
+  --> tests/ui/or_fun_call.rs:349:23
    |
 LL |         map.entry(42).or_insert_with(String::new);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert_with` to construct default value
-  --> tests/ui/or_fun_call.rs:337:25
+  --> tests/ui/or_fun_call.rs:353:25
    |
 LL |         btree.entry(42).or_insert_with(String::new);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:341:25
+  --> tests/ui/or_fun_call.rs:357:25
    |
 LL |         let _ = stringy.unwrap_or_else(String::new);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:383:17
+  --> tests/ui/or_fun_call.rs:399:17
    |
 LL |     let _ = opt.unwrap_or({ f() }); // suggest `.unwrap_or_else(f)`
    |                 ^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(f)`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:388:17
+  --> tests/ui/or_fun_call.rs:404:17
    |
 LL |     let _ = opt.unwrap_or(f() + 1); // suggest `.unwrap_or_else(|| f() + 1)`
    |                 ^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| f() + 1)`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:393:17
+  --> tests/ui/or_fun_call.rs:409:17
    |
 LL |       let _ = opt.unwrap_or({
    |  _________________^
@@ -235,55 +235,55 @@ LL ~     });
    |
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:399:17
+  --> tests/ui/or_fun_call.rs:415:17
    |
 LL |     let _ = opt.map_or(f() + 1, |v| v); // suggest `.map_or_else(|| f() + 1, |v| v)`
    |                 ^^^^^^^^^^^^^^^^^^^^^^ help: try: `map_or_else(|| f() + 1, |v| v)`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:404:17
+  --> tests/ui/or_fun_call.rs:420:17
    |
 LL |     let _ = opt.unwrap_or({ i32::default() });
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:411:21
+  --> tests/ui/or_fun_call.rs:427:21
    |
 LL |     let _ = opt_foo.unwrap_or(Foo { val: String::default() });
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| Foo { val: String::default() })`
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:426:19
+  --> tests/ui/or_fun_call.rs:442:19
    |
 LL |         let _ = x.map_or(g(), |v| v);
    |                   ^^^^^^^^^^^^^^^^^^ help: try: `map_or_else(|_| g(), |v| v)`
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:428:19
+  --> tests/ui/or_fun_call.rs:444:19
    |
 LL |         let _ = x.map_or(g(), f);
    |                   ^^^^^^^^^^^^^^ help: try: `map_or_else(|_| g(), f)`
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:431:19
+  --> tests/ui/or_fun_call.rs:447:19
    |
 LL |         let _ = x.map_or("asd".to_string().len() as i32, f);
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map_or_else(|_| "asd".to_string().len() as i32, f)`
 
 error: function call inside of `get_or_insert`
-  --> tests/ui/or_fun_call.rs:442:15
+  --> tests/ui/or_fun_call.rs:458:15
    |
 LL |     let _ = x.get_or_insert(g());
    |               ^^^^^^^^^^^^^^^^^^ help: try: `get_or_insert_with(g)`
 
 error: function call inside of `and`
-  --> tests/ui/or_fun_call.rs:452:15
+  --> tests/ui/or_fun_call.rs:468:15
    |
 LL |     let _ = x.and(g());
    |               ^^^^^^^^ help: try: `and_then(|_| g())`
 
 error: function call inside of `and`
-  --> tests/ui/or_fun_call.rs:462:15
+  --> tests/ui/or_fun_call.rs:478:15
    |
 LL |     let _ = x.and(g());
    |               ^^^^^^^^ help: try: `and_then(|_| g())`
diff --git a/tests/ui/ptr_offset_with_cast.fixed b/tests/ui/ptr_offset_with_cast.fixed
index 4fe9dcf46c357..42d1abeaa05a6 100644
--- a/tests/ui/ptr_offset_with_cast.fixed
+++ b/tests/ui/ptr_offset_with_cast.fixed
@@ -1,4 +1,4 @@
-#![allow(clippy::unnecessary_cast, clippy::useless_vec)]
+#![expect(clippy::unnecessary_cast, clippy::useless_vec, clippy::needless_borrow)]
 
 fn main() {
     let vec = vec![b'a', b'b', b'c'];
@@ -18,5 +18,25 @@ fn main() {
         //~^ ptr_offset_with_cast
         let _ = ptr.wrapping_offset(offset_isize as isize);
         let _ = ptr.wrapping_offset(offset_u8 as isize);
+
+        let _ = S.offset(offset_usize as isize);
+        let _ = S.wrapping_offset(offset_usize as isize);
+
+        let _ = (&ptr).add(offset_usize);
+        //~^ ptr_offset_with_cast
+        let _ = (&ptr).wrapping_add(offset_usize);
+        //~^ ptr_offset_with_cast
+    }
+}
+
+#[derive(Clone, Copy)]
+struct S;
+
+impl S {
+    fn offset(self, _: isize) -> Self {
+        self
+    }
+    fn wrapping_offset(self, _: isize) -> Self {
+        self
     }
 }
diff --git a/tests/ui/ptr_offset_with_cast.rs b/tests/ui/ptr_offset_with_cast.rs
index a1fb892733d35..6d06a6af1fa2d 100644
--- a/tests/ui/ptr_offset_with_cast.rs
+++ b/tests/ui/ptr_offset_with_cast.rs
@@ -1,4 +1,4 @@
-#![allow(clippy::unnecessary_cast, clippy::useless_vec)]
+#![expect(clippy::unnecessary_cast, clippy::useless_vec, clippy::needless_borrow)]
 
 fn main() {
     let vec = vec![b'a', b'b', b'c'];
@@ -18,5 +18,25 @@ fn main() {
         //~^ ptr_offset_with_cast
         let _ = ptr.wrapping_offset(offset_isize as isize);
         let _ = ptr.wrapping_offset(offset_u8 as isize);
+
+        let _ = S.offset(offset_usize as isize);
+        let _ = S.wrapping_offset(offset_usize as isize);
+
+        let _ = (&ptr).offset(offset_usize as isize);
+        //~^ ptr_offset_with_cast
+        let _ = (&ptr).wrapping_offset(offset_usize as isize);
+        //~^ ptr_offset_with_cast
+    }
+}
+
+#[derive(Clone, Copy)]
+struct S;
+
+impl S {
+    fn offset(self, _: isize) -> Self {
+        self
+    }
+    fn wrapping_offset(self, _: isize) -> Self {
+        self
     }
 }
diff --git a/tests/ui/ptr_offset_with_cast.stderr b/tests/ui/ptr_offset_with_cast.stderr
index dcd5e027d1829..022b3286c93b7 100644
--- a/tests/ui/ptr_offset_with_cast.stderr
+++ b/tests/ui/ptr_offset_with_cast.stderr
@@ -2,16 +2,51 @@ error: use of `offset` with a `usize` casted to an `isize`
   --> tests/ui/ptr_offset_with_cast.rs:12:17
    |
 LL |         let _ = ptr.offset(offset_usize as isize);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `ptr.add(offset_usize)`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::ptr-offset-with-cast` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::ptr_offset_with_cast)]`
+help: use `add` instead
+   |
+LL -         let _ = ptr.offset(offset_usize as isize);
+LL +         let _ = ptr.add(offset_usize);
+   |
 
 error: use of `wrapping_offset` with a `usize` casted to an `isize`
   --> tests/ui/ptr_offset_with_cast.rs:17:17
    |
 LL |         let _ = ptr.wrapping_offset(offset_usize as isize);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `ptr.wrapping_add(offset_usize)`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `wrapping_add` instead
+   |
+LL -         let _ = ptr.wrapping_offset(offset_usize as isize);
+LL +         let _ = ptr.wrapping_add(offset_usize);
+   |
+
+error: use of `offset` with a `usize` casted to an `isize`
+  --> tests/ui/ptr_offset_with_cast.rs:25:17
+   |
+LL |         let _ = (&ptr).offset(offset_usize as isize);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `add` instead
+   |
+LL -         let _ = (&ptr).offset(offset_usize as isize);
+LL +         let _ = (&ptr).add(offset_usize);
+   |
+
+error: use of `wrapping_offset` with a `usize` casted to an `isize`
+  --> tests/ui/ptr_offset_with_cast.rs:27:17
+   |
+LL |         let _ = (&ptr).wrapping_offset(offset_usize as isize);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `wrapping_add` instead
+   |
+LL -         let _ = (&ptr).wrapping_offset(offset_usize as isize);
+LL +         let _ = (&ptr).wrapping_add(offset_usize);
+   |
 
-error: aborting due to 2 previous errors
+error: aborting due to 4 previous errors
 
diff --git a/tests/ui/question_mark.fixed b/tests/ui/question_mark.fixed
index 8d6f5fbadca56..ac81b324c2049 100644
--- a/tests/ui/question_mark.fixed
+++ b/tests/ui/question_mark.fixed
@@ -1,6 +1,4 @@
 #![feature(try_blocks)]
-#![allow(unreachable_code)]
-#![allow(dead_code)]
 #![allow(clippy::unnecessary_wraps)]
 
 use std::sync::MutexGuard;
@@ -465,3 +463,15 @@ fn issue_13642(x: Option<i32>) -> Option<()> {
 
     None
 }
+
+fn issue_15679() -> Result<i32, String> {
+    let some_result: Result<i32, &'static str> = todo!();
+
+    some_result?;
+
+    some_result?;
+
+    some_result?;
+
+    Ok(0)
+}
diff --git a/tests/ui/question_mark.rs b/tests/ui/question_mark.rs
index f13eee29c113c..b5866dac6b8f6 100644
--- a/tests/ui/question_mark.rs
+++ b/tests/ui/question_mark.rs
@@ -1,6 +1,4 @@
 #![feature(try_blocks)]
-#![allow(unreachable_code)]
-#![allow(dead_code)]
 #![allow(clippy::unnecessary_wraps)]
 
 use std::sync::MutexGuard;
@@ -561,3 +559,27 @@ fn issue_13642(x: Option<i32>) -> Option<()> {
 
     None
 }
+
+fn issue_15679() -> Result<i32, String> {
+    let some_result: Result<i32, &'static str> = todo!();
+
+    match some_result {
+        //~^ question_mark
+        Ok(val) => val,
+        Err(err) => return Err(err.into()),
+    };
+
+    match some_result {
+        //~^ question_mark
+        Ok(val) => val,
+        Err(err) => return Err(Into::into(err)),
+    };
+
+    match some_result {
+        //~^ question_mark
+        Ok(val) => val,
+        Err(err) => return Err(<&str as Into<String>>::into(err)),
+    };
+
+    Ok(0)
+}
diff --git a/tests/ui/question_mark.stderr b/tests/ui/question_mark.stderr
index d8ce4420aeeb6..1ecd936292e55 100644
--- a/tests/ui/question_mark.stderr
+++ b/tests/ui/question_mark.stderr
@@ -1,5 +1,5 @@
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:9:5
+  --> tests/ui/question_mark.rs:7:5
    |
 LL | /     if a.is_none() {
 LL | |
@@ -11,7 +11,7 @@ LL | |     }
    = help: to override `-D warnings` add `#[allow(clippy::question_mark)]`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:55:9
+  --> tests/ui/question_mark.rs:53:9
    |
 LL | /         if (self.opt).is_none() {
 LL | |
@@ -20,7 +20,7 @@ LL | |         }
    | |_________^ help: replace it with: `(self.opt)?;`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:60:9
+  --> tests/ui/question_mark.rs:58:9
    |
 LL | /         if self.opt.is_none() {
 LL | |
@@ -29,7 +29,7 @@ LL | |         }
    | |_________^ help: replace it with: `self.opt?;`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:65:17
+  --> tests/ui/question_mark.rs:63:17
    |
 LL |           let _ = if self.opt.is_none() {
    |  _________________^
@@ -41,7 +41,7 @@ LL | |         };
    | |_________^ help: replace it with: `Some(self.opt?)`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:72:17
+  --> tests/ui/question_mark.rs:70:17
    |
 LL |           let _ = if let Some(x) = self.opt {
    |  _________________^
@@ -53,7 +53,7 @@ LL | |         };
    | |_________^ help: replace it with: `self.opt?`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:90:9
+  --> tests/ui/question_mark.rs:88:9
    |
 LL | /         if self.opt.is_none() {
 LL | |
@@ -62,7 +62,7 @@ LL | |         }
    | |_________^ help: replace it with: `self.opt.as_ref()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:99:9
+  --> tests/ui/question_mark.rs:97:9
    |
 LL | /         if self.opt.is_none() {
 LL | |
@@ -71,7 +71,7 @@ LL | |         }
    | |_________^ help: replace it with: `self.opt.as_ref()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:108:9
+  --> tests/ui/question_mark.rs:106:9
    |
 LL | /         if self.opt.is_none() {
 LL | |
@@ -80,7 +80,7 @@ LL | |         }
    | |_________^ help: replace it with: `self.opt.as_ref()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:116:26
+  --> tests/ui/question_mark.rs:114:26
    |
 LL |           let v: &Vec<_> = if let Some(ref v) = self.opt {
    |  __________________________^
@@ -92,7 +92,7 @@ LL | |         };
    | |_________^ help: replace it with: `self.opt.as_ref()?`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:127:17
+  --> tests/ui/question_mark.rs:125:17
    |
 LL |           let v = if let Some(v) = self.opt {
    |  _________________^
@@ -104,7 +104,7 @@ LL | |         };
    | |_________^ help: replace it with: `self.opt?`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:149:5
+  --> tests/ui/question_mark.rs:147:5
    |
 LL | /     if f().is_none() {
 LL | |
@@ -113,7 +113,7 @@ LL | |     }
    | |_____^ help: replace it with: `f()?;`
 
 error: this `match` expression can be replaced with `?`
-  --> tests/ui/question_mark.rs:154:16
+  --> tests/ui/question_mark.rs:152:16
    |
 LL |       let _val = match f() {
    |  ________________^
@@ -124,7 +124,7 @@ LL | |     };
    | |_____^ help: try instead: `f()?`
 
 error: this `match` expression can be replaced with `?`
-  --> tests/ui/question_mark.rs:165:5
+  --> tests/ui/question_mark.rs:163:5
    |
 LL | /     match f() {
 LL | |
@@ -134,7 +134,7 @@ LL | |     };
    | |_____^ help: try instead: `f()?`
 
 error: this `match` expression can be replaced with `?`
-  --> tests/ui/question_mark.rs:171:5
+  --> tests/ui/question_mark.rs:169:5
    |
 LL | /     match opt_none!() {
 LL | |
@@ -144,13 +144,13 @@ LL | |     };
    | |_____^ help: try instead: `opt_none!()?`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:198:13
+  --> tests/ui/question_mark.rs:196:13
    |
 LL |     let _ = if let Ok(x) = x { x } else { return x };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `x?`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:201:5
+  --> tests/ui/question_mark.rs:199:5
    |
 LL | /     if x.is_err() {
 LL | |
@@ -159,7 +159,7 @@ LL | |     }
    | |_____^ help: replace it with: `x?;`
 
 error: this `match` expression can be replaced with `?`
-  --> tests/ui/question_mark.rs:206:16
+  --> tests/ui/question_mark.rs:204:16
    |
 LL |       let _val = match func_returning_result() {
    |  ________________^
@@ -170,7 +170,7 @@ LL | |     };
    | |_____^ help: try instead: `func_returning_result()?`
 
 error: this `match` expression can be replaced with `?`
-  --> tests/ui/question_mark.rs:212:5
+  --> tests/ui/question_mark.rs:210:5
    |
 LL | /     match func_returning_result() {
 LL | |
@@ -180,7 +180,7 @@ LL | |     };
    | |_____^ help: try instead: `func_returning_result()?`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:304:5
+  --> tests/ui/question_mark.rs:302:5
    |
 LL | /     if let Err(err) = func_returning_result() {
 LL | |
@@ -189,7 +189,7 @@ LL | |     }
    | |_____^ help: replace it with: `func_returning_result()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:312:5
+  --> tests/ui/question_mark.rs:310:5
    |
 LL | /     if let Err(err) = func_returning_result() {
 LL | |
@@ -198,7 +198,7 @@ LL | |     }
    | |_____^ help: replace it with: `func_returning_result()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:395:13
+  --> tests/ui/question_mark.rs:393:13
    |
 LL | /             if a.is_none() {
 LL | |
@@ -208,7 +208,7 @@ LL | |             }
    | |_____________^ help: replace it with: `a?;`
 
 error: this `let...else` may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:456:5
+  --> tests/ui/question_mark.rs:454:5
    |
 LL | /     let Some(v) = bar.foo.owned.clone() else {
 LL | |         return None;
@@ -216,7 +216,7 @@ LL | |     };
    | |______^ help: replace it with: `let v = bar.foo.owned.clone()?;`
 
 error: this `let...else` may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:471:5
+  --> tests/ui/question_mark.rs:469:5
    |
 LL | /     let Some(ref x) = foo.opt_x else {
 LL | |         return None;
@@ -224,7 +224,7 @@ LL | |     };
    | |______^ help: replace it with: `let x = foo.opt_x.as_ref()?;`
 
 error: this `let...else` may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:481:5
+  --> tests/ui/question_mark.rs:479:5
    |
 LL | /     let Some(ref mut x) = foo.opt_x else {
 LL | |         return None;
@@ -232,7 +232,7 @@ LL | |     };
    | |______^ help: replace it with: `let x = foo.opt_x.as_mut()?;`
 
 error: this `let...else` may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:492:5
+  --> tests/ui/question_mark.rs:490:5
    |
 LL | /     let Some(ref x @ ref y) = foo.opt_x else {
 LL | |         return None;
@@ -240,7 +240,7 @@ LL | |     };
    | |______^ help: replace it with: `let x @ y = foo.opt_x.as_ref()?;`
 
 error: this `let...else` may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:496:5
+  --> tests/ui/question_mark.rs:494:5
    |
 LL | /     let Some(ref x @ WrapperStructWithString(_)) = bar else {
 LL | |         return None;
@@ -248,7 +248,7 @@ LL | |     };
    | |______^ help: replace it with: `let x @ &WrapperStructWithString(_) = bar.as_ref()?;`
 
 error: this `let...else` may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:500:5
+  --> tests/ui/question_mark.rs:498:5
    |
 LL | /     let Some(ref mut x @ WrapperStructWithString(_)) = bar else {
 LL | |         return None;
@@ -256,7 +256,7 @@ LL | |     };
    | |______^ help: replace it with: `let x @ &mut WrapperStructWithString(_) = bar.as_mut()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:522:5
+  --> tests/ui/question_mark.rs:520:5
    |
 LL | /     if arg.is_none() {
 LL | |
@@ -265,7 +265,7 @@ LL | |     }
    | |_____^ help: replace it with: `arg?;`
 
 error: this `match` expression can be replaced with `?`
-  --> tests/ui/question_mark.rs:526:15
+  --> tests/ui/question_mark.rs:524:15
    |
 LL |       let val = match arg {
    |  _______________^
@@ -276,12 +276,42 @@ LL | |     };
    | |_____^ help: try instead: `arg?`
 
 error: this `let...else` may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:536:5
+  --> tests/ui/question_mark.rs:534:5
    |
 LL | /     let Some(a) = *a else {
 LL | |         return None;
 LL | |     };
    | |______^ help: replace it with: `let a = (*a)?;`
 
-error: aborting due to 30 previous errors
+error: this `match` expression can be replaced with `?`
+  --> tests/ui/question_mark.rs:566:5
+   |
+LL | /     match some_result {
+LL | |
+LL | |         Ok(val) => val,
+LL | |         Err(err) => return Err(err.into()),
+LL | |     };
+   | |_____^ help: try instead: `some_result?`
+
+error: this `match` expression can be replaced with `?`
+  --> tests/ui/question_mark.rs:572:5
+   |
+LL | /     match some_result {
+LL | |
+LL | |         Ok(val) => val,
+LL | |         Err(err) => return Err(Into::into(err)),
+LL | |     };
+   | |_____^ help: try instead: `some_result?`
+
+error: this `match` expression can be replaced with `?`
+  --> tests/ui/question_mark.rs:578:5
+   |
+LL | /     match some_result {
+LL | |
+LL | |         Ok(val) => val,
+LL | |         Err(err) => return Err(<&str as Into<String>>::into(err)),
+LL | |     };
+   | |_____^ help: try instead: `some_result?`
+
+error: aborting due to 33 previous errors
 
diff --git a/tests/ui/read_zero_byte_vec.rs b/tests/ui/read_zero_byte_vec.rs
index 938d61b68607c..720276cb55488 100644
--- a/tests/ui/read_zero_byte_vec.rs
+++ b/tests/ui/read_zero_byte_vec.rs
@@ -120,3 +120,30 @@ fn allow_works<F: std::io::Read>(mut f: F) {
 }
 
 fn main() {}
+
+fn issue15575() -> usize {
+    use std::io::Read;
+    use std::net::TcpListener;
+
+    let listener = TcpListener::bind("127.0.0.1:9010").unwrap();
+    let mut stream_and_addr = listener.accept().unwrap();
+    let mut buf = Vec::with_capacity(32);
+    let num_bytes_received = stream_and_addr.0.read(&mut buf).unwrap();
+    //~^ read_zero_byte_vec
+
+    let cap = 1000;
+    let mut buf = Vec::with_capacity(cap);
+    let num_bytes_received = stream_and_addr.0.read(&mut buf).unwrap();
+    //~^ read_zero_byte_vec
+
+    let cap = 1000;
+    let mut buf = Vec::with_capacity(cap);
+    let num_bytes_received = { stream_and_addr.0.read(&mut buf) }.unwrap();
+    //~^ read_zero_byte_vec
+
+    use std::fs::File;
+    let mut f = File::open("foo.txt").unwrap();
+    let mut data = Vec::with_capacity(100);
+    f.read(&mut data).unwrap()
+    //~^ read_zero_byte_vec
+}
diff --git a/tests/ui/read_zero_byte_vec.stderr b/tests/ui/read_zero_byte_vec.stderr
index 8f255bc87ab82..8dd74592e4c15 100644
--- a/tests/ui/read_zero_byte_vec.stderr
+++ b/tests/ui/read_zero_byte_vec.stderr
@@ -2,16 +2,27 @@ error: reading zero byte data to `Vec`
   --> tests/ui/read_zero_byte_vec.rs:22:5
    |
 LL |     f.read_exact(&mut data).unwrap();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `data.resize(20, 0); f.read_exact(&mut data)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::read-zero-byte-vec` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::read_zero_byte_vec)]`
+help: try
+   |
+LL ~     data.resize(20, 0);
+LL ~     f.read_exact(&mut data).unwrap();
+   |
 
 error: reading zero byte data to `Vec`
   --> tests/ui/read_zero_byte_vec.rs:28:5
    |
 LL |     f.read_exact(&mut data2)?;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `data2.resize(cap, 0); f.read_exact(&mut data2)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL ~     data2.resize(cap, 0);
+LL ~     f.read_exact(&mut data2)?;
+   |
 
 error: reading zero byte data to `Vec`
   --> tests/ui/read_zero_byte_vec.rs:33:5
@@ -67,5 +78,53 @@ error: reading zero byte data to `Vec`
 LL |     r.read_exact(&mut data2).await.unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 11 previous errors
+error: reading zero byte data to `Vec`
+  --> tests/ui/read_zero_byte_vec.rs:131:30
+   |
+LL |     let num_bytes_received = stream_and_addr.0.read(&mut buf).unwrap();
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL ~     buf.resize(32, 0);
+LL ~     let num_bytes_received = stream_and_addr.0.read(&mut buf).unwrap();
+   |
+
+error: reading zero byte data to `Vec`
+  --> tests/ui/read_zero_byte_vec.rs:136:30
+   |
+LL |     let num_bytes_received = stream_and_addr.0.read(&mut buf).unwrap();
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL ~     buf.resize(cap, 0);
+LL ~     let num_bytes_received = stream_and_addr.0.read(&mut buf).unwrap();
+   |
+
+error: reading zero byte data to `Vec`
+  --> tests/ui/read_zero_byte_vec.rs:141:32
+   |
+LL |     let num_bytes_received = { stream_and_addr.0.read(&mut buf) }.unwrap();
+   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL ~     buf.resize(cap, 0);
+LL ~     let num_bytes_received = { stream_and_addr.0.read(&mut buf) }.unwrap();
+   |
+
+error: reading zero byte data to `Vec`
+  --> tests/ui/read_zero_byte_vec.rs:147:5
+   |
+LL |     f.read(&mut data).unwrap()
+   |     ^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL ~     data.resize(100, 0);
+LL ~     f.read(&mut data).unwrap()
+   |
+
+error: aborting due to 15 previous errors
 
diff --git a/tests/ui/ref_option/ref_option.all.fixed b/tests/ui/ref_option/ref_option.all.fixed
deleted file mode 100644
index 4159e916f1995..0000000000000
--- a/tests/ui/ref_option/ref_option.all.fixed
+++ /dev/null
@@ -1,79 +0,0 @@
-//@revisions: private all
-//@[private] rustc-env:CLIPPY_CONF_DIR=tests/ui/ref_option/private
-//@[all] rustc-env:CLIPPY_CONF_DIR=tests/ui/ref_option/all
-
-#![allow(unused, clippy::needless_lifetimes, clippy::borrowed_box)]
-#![warn(clippy::ref_option)]
-
-fn opt_u8(a: Option<&u8>) {}
-//~^ ref_option
-fn opt_gen<T>(a: Option<&T>) {}
-//~^ ref_option
-fn opt_string(a: std::option::Option<&String>) {}
-//~^ ref_option
-fn ret_string<'a>(p: &'a str) -> Option<&'a u8> {
-    //~^ ref_option
-    panic!()
-}
-fn ret_string_static() -> Option<&'static u8> {
-    //~^ ref_option
-    panic!()
-}
-fn mult_string(a: Option<&String>, b: Option<&Vec<u8>>) {}
-//~^ ref_option
-fn ret_box<'a>() -> Option<&'a Box<u8>> {
-    //~^ ref_option
-    panic!()
-}
-
-pub fn pub_opt_string(a: Option<&String>) {}
-//~[all]^ ref_option
-pub fn pub_mult_string(a: Option<&String>, b: Option<&Vec<u8>>) {}
-//~[all]^ ref_option
-
-pub trait PubTrait {
-    fn pub_trait_opt(&self, a: Option<&Vec<u8>>);
-    //~[all]^ ref_option
-    fn pub_trait_ret(&self) -> Option<&Vec<u8>>;
-    //~[all]^ ref_option
-}
-
-trait PrivateTrait {
-    fn trait_opt(&self, a: Option<&String>);
-    //~^ ref_option
-    fn trait_ret(&self) -> Option<&String>;
-    //~^ ref_option
-}
-
-pub struct PubStruct;
-
-impl PubStruct {
-    pub fn pub_opt_params(&self, a: Option<&()>) {}
-    //~[all]^ ref_option
-    pub fn pub_opt_ret(&self) -> Option<&String> {
-        //~[all]^ ref_option
-        panic!()
-    }
-
-    fn private_opt_params(&self, a: Option<&()>) {}
-    //~^ ref_option
-    fn private_opt_ret(&self) -> Option<&String> {
-        //~^ ref_option
-        panic!()
-    }
-}
-
-// valid, don't change
-fn mut_u8(a: &mut Option<u8>) {}
-pub fn pub_mut_u8(a: &mut Option<String>) {}
-
-// might be good to catch in the future
-fn mut_u8_ref(a: &mut &Option<u8>) {}
-pub fn pub_mut_u8_ref(a: &mut &Option<String>) {}
-fn lambdas() {
-    // Not handled for now, not sure if we should
-    let x = |a: &Option<String>| {};
-    let x = |a: &Option<String>| -> &Option<String> { panic!() };
-}
-
-fn main() {}
diff --git a/tests/ui/ref_option/ref_option.private.fixed b/tests/ui/ref_option/ref_option.private.fixed
deleted file mode 100644
index 3b158befb926e..0000000000000
--- a/tests/ui/ref_option/ref_option.private.fixed
+++ /dev/null
@@ -1,79 +0,0 @@
-//@revisions: private all
-//@[private] rustc-env:CLIPPY_CONF_DIR=tests/ui/ref_option/private
-//@[all] rustc-env:CLIPPY_CONF_DIR=tests/ui/ref_option/all
-
-#![allow(unused, clippy::needless_lifetimes, clippy::borrowed_box)]
-#![warn(clippy::ref_option)]
-
-fn opt_u8(a: Option<&u8>) {}
-//~^ ref_option
-fn opt_gen<T>(a: Option<&T>) {}
-//~^ ref_option
-fn opt_string(a: std::option::Option<&String>) {}
-//~^ ref_option
-fn ret_string<'a>(p: &'a str) -> Option<&'a u8> {
-    //~^ ref_option
-    panic!()
-}
-fn ret_string_static() -> Option<&'static u8> {
-    //~^ ref_option
-    panic!()
-}
-fn mult_string(a: Option<&String>, b: Option<&Vec<u8>>) {}
-//~^ ref_option
-fn ret_box<'a>() -> Option<&'a Box<u8>> {
-    //~^ ref_option
-    panic!()
-}
-
-pub fn pub_opt_string(a: &Option<String>) {}
-//~[all]^ ref_option
-pub fn pub_mult_string(a: &Option<String>, b: &Option<Vec<u8>>) {}
-//~[all]^ ref_option
-
-pub trait PubTrait {
-    fn pub_trait_opt(&self, a: &Option<Vec<u8>>);
-    //~[all]^ ref_option
-    fn pub_trait_ret(&self) -> &Option<Vec<u8>>;
-    //~[all]^ ref_option
-}
-
-trait PrivateTrait {
-    fn trait_opt(&self, a: Option<&String>);
-    //~^ ref_option
-    fn trait_ret(&self) -> Option<&String>;
-    //~^ ref_option
-}
-
-pub struct PubStruct;
-
-impl PubStruct {
-    pub fn pub_opt_params(&self, a: &Option<()>) {}
-    //~[all]^ ref_option
-    pub fn pub_opt_ret(&self) -> &Option<String> {
-        //~[all]^ ref_option
-        panic!()
-    }
-
-    fn private_opt_params(&self, a: Option<&()>) {}
-    //~^ ref_option
-    fn private_opt_ret(&self) -> Option<&String> {
-        //~^ ref_option
-        panic!()
-    }
-}
-
-// valid, don't change
-fn mut_u8(a: &mut Option<u8>) {}
-pub fn pub_mut_u8(a: &mut Option<String>) {}
-
-// might be good to catch in the future
-fn mut_u8_ref(a: &mut &Option<u8>) {}
-pub fn pub_mut_u8_ref(a: &mut &Option<String>) {}
-fn lambdas() {
-    // Not handled for now, not sure if we should
-    let x = |a: &Option<String>| {};
-    let x = |a: &Option<String>| -> &Option<String> { panic!() };
-}
-
-fn main() {}
diff --git a/tests/ui/ref_option/ref_option.rs b/tests/ui/ref_option/ref_option.rs
deleted file mode 100644
index 35cd94174f8bc..0000000000000
--- a/tests/ui/ref_option/ref_option.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-//@revisions: private all
-//@[private] rustc-env:CLIPPY_CONF_DIR=tests/ui/ref_option/private
-//@[all] rustc-env:CLIPPY_CONF_DIR=tests/ui/ref_option/all
-
-#![allow(unused, clippy::needless_lifetimes, clippy::borrowed_box)]
-#![warn(clippy::ref_option)]
-
-fn opt_u8(a: &Option<u8>) {}
-//~^ ref_option
-fn opt_gen<T>(a: &Option<T>) {}
-//~^ ref_option
-fn opt_string(a: &std::option::Option<String>) {}
-//~^ ref_option
-fn ret_string<'a>(p: &'a str) -> &'a Option<u8> {
-    //~^ ref_option
-    panic!()
-}
-fn ret_string_static() -> &'static Option<u8> {
-    //~^ ref_option
-    panic!()
-}
-fn mult_string(a: &Option<String>, b: &Option<Vec<u8>>) {}
-//~^ ref_option
-fn ret_box<'a>() -> &'a Option<Box<u8>> {
-    //~^ ref_option
-    panic!()
-}
-
-pub fn pub_opt_string(a: &Option<String>) {}
-//~[all]^ ref_option
-pub fn pub_mult_string(a: &Option<String>, b: &Option<Vec<u8>>) {}
-//~[all]^ ref_option
-
-pub trait PubTrait {
-    fn pub_trait_opt(&self, a: &Option<Vec<u8>>);
-    //~[all]^ ref_option
-    fn pub_trait_ret(&self) -> &Option<Vec<u8>>;
-    //~[all]^ ref_option
-}
-
-trait PrivateTrait {
-    fn trait_opt(&self, a: &Option<String>);
-    //~^ ref_option
-    fn trait_ret(&self) -> &Option<String>;
-    //~^ ref_option
-}
-
-pub struct PubStruct;
-
-impl PubStruct {
-    pub fn pub_opt_params(&self, a: &Option<()>) {}
-    //~[all]^ ref_option
-    pub fn pub_opt_ret(&self) -> &Option<String> {
-        //~[all]^ ref_option
-        panic!()
-    }
-
-    fn private_opt_params(&self, a: &Option<()>) {}
-    //~^ ref_option
-    fn private_opt_ret(&self) -> &Option<String> {
-        //~^ ref_option
-        panic!()
-    }
-}
-
-// valid, don't change
-fn mut_u8(a: &mut Option<u8>) {}
-pub fn pub_mut_u8(a: &mut Option<String>) {}
-
-// might be good to catch in the future
-fn mut_u8_ref(a: &mut &Option<u8>) {}
-pub fn pub_mut_u8_ref(a: &mut &Option<String>) {}
-fn lambdas() {
-    // Not handled for now, not sure if we should
-    let x = |a: &Option<String>| {};
-    let x = |a: &Option<String>| -> &Option<String> { panic!() };
-}
-
-fn main() {}
diff --git a/tests/ui/ref_option/ref_option_traits.rs b/tests/ui/ref_option/ref_option_traits.rs
deleted file mode 100644
index 4c773e84f8da8..0000000000000
--- a/tests/ui/ref_option/ref_option_traits.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-//@no-rustfix: fixes are only done to traits, not the impls
-//@revisions: private all
-//@[private] rustc-env:CLIPPY_CONF_DIR=tests/ui/ref_option/private
-//@[all] rustc-env:CLIPPY_CONF_DIR=tests/ui/ref_option/all
-
-#![warn(clippy::ref_option)]
-
-pub trait PubTrait {
-    fn pub_trait_opt(&self, a: &Option<Vec<u8>>);
-    //~[all]^ ref_option
-    fn pub_trait_ret(&self) -> &Option<Vec<u8>>;
-    //~[all]^ ref_option
-}
-
-trait PrivateTrait {
-    fn trait_opt(&self, a: &Option<String>);
-    //~^ ref_option
-    fn trait_ret(&self) -> &Option<String>;
-    //~^ ref_option
-}
-
-pub struct PubStruct;
-
-impl PubTrait for PubStruct {
-    fn pub_trait_opt(&self, a: &Option<Vec<u8>>) {}
-    fn pub_trait_ret(&self) -> &Option<Vec<u8>> {
-        panic!()
-    }
-}
-
-struct PrivateStruct;
-
-impl PrivateTrait for PrivateStruct {
-    fn trait_opt(&self, a: &Option<String>) {}
-    fn trait_ret(&self) -> &Option<String> {
-        panic!()
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/rest_pat_in_fully_bound_structs.fixed b/tests/ui/rest_pat_in_fully_bound_structs.fixed
new file mode 100644
index 0000000000000..ac200b3b19b74
--- /dev/null
+++ b/tests/ui/rest_pat_in_fully_bound_structs.fixed
@@ -0,0 +1,61 @@
+#![warn(clippy::rest_pat_in_fully_bound_structs)]
+#![allow(clippy::struct_field_names)]
+
+struct A {
+    a: i32,
+    b: i64,
+    c: &'static str,
+}
+
+macro_rules! foo {
+    ($param:expr) => {
+        match $param {
+            A { a: 0, b: 0, c: "", .. } => {},
+            _ => {},
+        }
+    };
+}
+
+fn main() {
+    let a_struct = A { a: 5, b: 42, c: "A" };
+
+    match a_struct {
+        A { a: 5, b: 42, c: "",  } => {}, // Lint
+        //~^ rest_pat_in_fully_bound_structs
+        A { a: 0, b: 0, c: "",  } => {}, // Lint
+        //~^ rest_pat_in_fully_bound_structs
+        _ => {},
+    }
+
+    match a_struct {
+        A { a: 5, b: 42, .. } => {},
+        A { a: 0, b: 0, c: "",  } => {}, // Lint
+        //~^ rest_pat_in_fully_bound_structs
+        _ => {},
+    }
+
+    // No lint
+    match a_struct {
+        A { a: 5, .. } => {},
+        A { a: 0, b: 0, .. } => {},
+        _ => {},
+    }
+
+    // No lint
+    foo!(a_struct);
+
+    #[non_exhaustive]
+    struct B {
+        a: u32,
+        b: u32,
+        c: u64,
+    }
+
+    let b_struct = B { a: 5, b: 42, c: 342 };
+
+    match b_struct {
+        B { a: 5, b: 42, .. } => {},
+        B { a: 0, b: 0, c: 128, .. } => {}, // No Lint
+        _ => {},
+    }
+}
diff --git a/tests/ui/rest_pat_in_fully_bound_structs.stderr b/tests/ui/rest_pat_in_fully_bound_structs.stderr
index d048933ddb7bc..8a2da302b9ef2 100644
--- a/tests/ui/rest_pat_in_fully_bound_structs.stderr
+++ b/tests/ui/rest_pat_in_fully_bound_structs.stderr
@@ -4,9 +4,13 @@ error: unnecessary use of `..` pattern in struct binding. All fields were alread
 LL |         A { a: 5, b: 42, c: "", .. } => {}, // Lint
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: consider removing `..` from this binding
    = note: `-D clippy::rest-pat-in-fully-bound-structs` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::rest_pat_in_fully_bound_structs)]`
+help: consider removing `..` from this binding
+   |
+LL -         A { a: 5, b: 42, c: "", .. } => {}, // Lint
+LL +         A { a: 5, b: 42, c: "",  } => {}, // Lint
+   |
 
 error: unnecessary use of `..` pattern in struct binding. All fields were already bound
   --> tests/ui/rest_pat_in_fully_bound_structs.rs:25:9
@@ -14,7 +18,11 @@ error: unnecessary use of `..` pattern in struct binding. All fields were alread
 LL |         A { a: 0, b: 0, c: "", .. } => {}, // Lint
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: consider removing `..` from this binding
+help: consider removing `..` from this binding
+   |
+LL -         A { a: 0, b: 0, c: "", .. } => {}, // Lint
+LL +         A { a: 0, b: 0, c: "",  } => {}, // Lint
+   |
 
 error: unnecessary use of `..` pattern in struct binding. All fields were already bound
   --> tests/ui/rest_pat_in_fully_bound_structs.rs:32:9
@@ -22,7 +30,11 @@ error: unnecessary use of `..` pattern in struct binding. All fields were alread
 LL |         A { a: 0, b: 0, c: "", .. } => {}, // Lint
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: consider removing `..` from this binding
+help: consider removing `..` from this binding
+   |
+LL -         A { a: 0, b: 0, c: "", .. } => {}, // Lint
+LL +         A { a: 0, b: 0, c: "",  } => {}, // Lint
+   |
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/semicolon_inside_block.fixed b/tests/ui/semicolon_inside_block.fixed
index 7308e78aae263..468f0a5b1e472 100644
--- a/tests/ui/semicolon_inside_block.fixed
+++ b/tests/ui/semicolon_inside_block.fixed
@@ -3,7 +3,8 @@
     clippy::unused_unit,
     clippy::unnecessary_operation,
     clippy::no_effect,
-    clippy::single_element_loop
+    clippy::single_element_loop,
+    clippy::double_parens
 )]
 #![warn(clippy::semicolon_inside_block)]
 
@@ -87,6 +88,20 @@ fn main() {
     unit_fn_block()
 }
 
+#[rustfmt::skip]
+fn issue15380() {
+    ( {0;0});
+
+    ({
+        0;
+        0
+    });
+
+    (({ 0 }))      ;
+
+    ( ( { 0 } ) ) ;
+}
+
 pub fn issue15388() {
     #[rustfmt::skip]
     {0; 0};
diff --git a/tests/ui/semicolon_inside_block.rs b/tests/ui/semicolon_inside_block.rs
index 467bf4d779f2a..101374af26471 100644
--- a/tests/ui/semicolon_inside_block.rs
+++ b/tests/ui/semicolon_inside_block.rs
@@ -3,7 +3,8 @@
     clippy::unused_unit,
     clippy::unnecessary_operation,
     clippy::no_effect,
-    clippy::single_element_loop
+    clippy::single_element_loop,
+    clippy::double_parens
 )]
 #![warn(clippy::semicolon_inside_block)]
 
@@ -87,6 +88,20 @@ fn main() {
     unit_fn_block()
 }
 
+#[rustfmt::skip]
+fn issue15380() {
+    ( {0;0});
+
+    ({
+        0;
+        0
+    });
+
+    (({ 0 }))      ;
+
+    ( ( { 0 } ) ) ;
+}
+
 pub fn issue15388() {
     #[rustfmt::skip]
     {0; 0};
diff --git a/tests/ui/semicolon_inside_block.stderr b/tests/ui/semicolon_inside_block.stderr
index 23433f4e7ef90..2046dd1c36be7 100644
--- a/tests/ui/semicolon_inside_block.stderr
+++ b/tests/ui/semicolon_inside_block.stderr
@@ -1,5 +1,5 @@
 error: consider moving the `;` inside the block for consistent formatting
-  --> tests/ui/semicolon_inside_block.rs:38:5
+  --> tests/ui/semicolon_inside_block.rs:39:5
    |
 LL |     { unit_fn_block() };
    |     ^^^^^^^^^^^^^^^^^^^^
@@ -13,7 +13,7 @@ LL +     { unit_fn_block(); }
    |
 
 error: consider moving the `;` inside the block for consistent formatting
-  --> tests/ui/semicolon_inside_block.rs:40:5
+  --> tests/ui/semicolon_inside_block.rs:41:5
    |
 LL |     unsafe { unit_fn_block() };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     unsafe { unit_fn_block(); }
    |
 
 error: consider moving the `;` inside the block for consistent formatting
-  --> tests/ui/semicolon_inside_block.rs:49:5
+  --> tests/ui/semicolon_inside_block.rs:50:5
    |
 LL | /     {
 LL | |
@@ -41,7 +41,7 @@ LL ~     }
    |
 
 error: consider moving the `;` inside the block for consistent formatting
-  --> tests/ui/semicolon_inside_block.rs:63:5
+  --> tests/ui/semicolon_inside_block.rs:64:5
    |
 LL |     { m!(()) };
    |     ^^^^^^^^^^^
diff --git a/tests/ui/track-diagnostics-clippy.stderr b/tests/ui/track-diagnostics-clippy.stderr
index d5533877b4515..3ceb501463b77 100644
--- a/tests/ui/track-diagnostics-clippy.stderr
+++ b/tests/ui/track-diagnostics-clippy.stderr
@@ -16,7 +16,7 @@ LL |         let d = 42;
 LL |         d
    |         ^
    |
-   = note: -Ztrack-diagnostics: created at clippy_lints/src/returns.rs:LL:CC
+   = note: -Ztrack-diagnostics: created at clippy_lints/src/returns/let_and_return.rs:LL:CC
    = note: `-D clippy::let-and-return` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::let_and_return)]`
 help: return the expression directly
diff --git a/tests/ui/transmute_ptr_to_ref.fixed b/tests/ui/transmute_ptr_to_ref.fixed
index 61e3ac2fe88e3..c130575df9607 100644
--- a/tests/ui/transmute_ptr_to_ref.fixed
+++ b/tests/ui/transmute_ptr_to_ref.fixed
@@ -5,7 +5,7 @@
     clippy::missing_transmute_annotations
 )]
 
-unsafe fn _ptr_to_ref<T, U>(p: *const T, m: *mut T, o: *const U, om: *mut U) {
+fn ptr_to_ref<T, U>(p: *const T, m: *mut T, o: *const U, om: *mut U) {
     unsafe {
         let _: &T = &*p;
         //~^ transmute_ptr_to_ref
@@ -37,7 +37,7 @@ unsafe fn _ptr_to_ref<T, U>(p: *const T, m: *mut T, o: *const U, om: *mut U) {
     }
 }
 
-fn _issue1231() {
+fn issue1231() {
     struct Foo<'a, T> {
         bar: &'a T,
     }
@@ -55,7 +55,7 @@ fn _issue1231() {
     //~^ transmute_ptr_to_ref
 }
 
-unsafe fn _issue8924<'a, 'b, 'c>(x: *const &'a u32, y: *const &'b u32) -> &'c &'b u32 {
+fn issue8924<'a, 'b, 'c>(x: *const &'a u32, y: *const &'b u32) -> &'c &'b u32 {
     unsafe {
         match 0 {
             0 => &*x.cast::<&u32>(),
@@ -71,7 +71,7 @@ unsafe fn _issue8924<'a, 'b, 'c>(x: *const &'a u32, y: *const &'b u32) -> &'c &'
 }
 
 #[clippy::msrv = "1.38"]
-unsafe fn _meets_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
+fn meets_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
     unsafe {
         let a = 0u32;
         let a = &a as *const u32;
@@ -89,7 +89,7 @@ unsafe fn _meets_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
 }
 
 #[clippy::msrv = "1.37"]
-unsafe fn _under_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
+fn under_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
     unsafe {
         let a = 0u32;
         let a = &a as *const u32;
@@ -106,4 +106,33 @@ unsafe fn _under_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
     }
 }
 
+// handle DSTs
+fn issue13357(ptr: *const [i32], s_ptr: *const &str, a_s_ptr: *const [&str]) {
+    unsafe {
+        // different types, without erased regions
+        let _ = &*(ptr as *const [u32]);
+        //~^ transmute_ptr_to_ref
+        let _: &[u32] = &*(ptr as *const [u32]);
+        //~^ transmute_ptr_to_ref
+
+        // different types, with erased regions
+        let _ = &*(a_s_ptr as *const [&[u8]]);
+        //~^ transmute_ptr_to_ref
+        let _: &[&[u8]] = &*(a_s_ptr as *const [&[u8]]);
+        //~^ transmute_ptr_to_ref
+
+        // same type, without erased regions
+        let _ = &*(ptr as *const [i32]);
+        //~^ transmute_ptr_to_ref
+        let _: &[i32] = &*ptr;
+        //~^ transmute_ptr_to_ref
+
+        // same type, with erased regions
+        let _ = &*(a_s_ptr as *const [&str]);
+        //~^ transmute_ptr_to_ref
+        let _: &[&str] = &*(a_s_ptr as *const [&str]);
+        //~^ transmute_ptr_to_ref
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/transmute_ptr_to_ref.rs b/tests/ui/transmute_ptr_to_ref.rs
index 48e2f527b554c..f79d54234a2c9 100644
--- a/tests/ui/transmute_ptr_to_ref.rs
+++ b/tests/ui/transmute_ptr_to_ref.rs
@@ -5,7 +5,7 @@
     clippy::missing_transmute_annotations
 )]
 
-unsafe fn _ptr_to_ref<T, U>(p: *const T, m: *mut T, o: *const U, om: *mut U) {
+fn ptr_to_ref<T, U>(p: *const T, m: *mut T, o: *const U, om: *mut U) {
     unsafe {
         let _: &T = std::mem::transmute(p);
         //~^ transmute_ptr_to_ref
@@ -37,7 +37,7 @@ unsafe fn _ptr_to_ref<T, U>(p: *const T, m: *mut T, o: *const U, om: *mut U) {
     }
 }
 
-fn _issue1231() {
+fn issue1231() {
     struct Foo<'a, T> {
         bar: &'a T,
     }
@@ -55,7 +55,7 @@ fn _issue1231() {
     //~^ transmute_ptr_to_ref
 }
 
-unsafe fn _issue8924<'a, 'b, 'c>(x: *const &'a u32, y: *const &'b u32) -> &'c &'b u32 {
+fn issue8924<'a, 'b, 'c>(x: *const &'a u32, y: *const &'b u32) -> &'c &'b u32 {
     unsafe {
         match 0 {
             0 => std::mem::transmute(x),
@@ -71,7 +71,7 @@ unsafe fn _issue8924<'a, 'b, 'c>(x: *const &'a u32, y: *const &'b u32) -> &'c &'
 }
 
 #[clippy::msrv = "1.38"]
-unsafe fn _meets_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
+fn meets_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
     unsafe {
         let a = 0u32;
         let a = &a as *const u32;
@@ -89,7 +89,7 @@ unsafe fn _meets_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
 }
 
 #[clippy::msrv = "1.37"]
-unsafe fn _under_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
+fn under_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
     unsafe {
         let a = 0u32;
         let a = &a as *const u32;
@@ -106,4 +106,33 @@ unsafe fn _under_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
     }
 }
 
+// handle DSTs
+fn issue13357(ptr: *const [i32], s_ptr: *const &str, a_s_ptr: *const [&str]) {
+    unsafe {
+        // different types, without erased regions
+        let _ = core::mem::transmute::<_, &[u32]>(ptr);
+        //~^ transmute_ptr_to_ref
+        let _: &[u32] = core::mem::transmute(ptr);
+        //~^ transmute_ptr_to_ref
+
+        // different types, with erased regions
+        let _ = core::mem::transmute::<_, &[&[u8]]>(a_s_ptr);
+        //~^ transmute_ptr_to_ref
+        let _: &[&[u8]] = core::mem::transmute(a_s_ptr);
+        //~^ transmute_ptr_to_ref
+
+        // same type, without erased regions
+        let _ = core::mem::transmute::<_, &[i32]>(ptr);
+        //~^ transmute_ptr_to_ref
+        let _: &[i32] = core::mem::transmute(ptr);
+        //~^ transmute_ptr_to_ref
+
+        // same type, with erased regions
+        let _ = core::mem::transmute::<_, &[&str]>(a_s_ptr);
+        //~^ transmute_ptr_to_ref
+        let _: &[&str] = core::mem::transmute(a_s_ptr);
+        //~^ transmute_ptr_to_ref
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/transmute_ptr_to_ref.stderr b/tests/ui/transmute_ptr_to_ref.stderr
index 7685c345c8619..3f404d295fef0 100644
--- a/tests/ui/transmute_ptr_to_ref.stderr
+++ b/tests/ui/transmute_ptr_to_ref.stderr
@@ -43,13 +43,13 @@ error: transmute from a pointer type (`*mut U`) to a reference type (`&T`)
 LL |         let _: &T = std::mem::transmute(om);
    |                     ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(om as *const T)`
 
-error: transmute from a pointer type (`*const i32`) to a reference type (`&_issue1231::Foo<'_, u8>`)
+error: transmute from a pointer type (`*const i32`) to a reference type (`&issue1231::Foo<'_, u8>`)
   --> tests/ui/transmute_ptr_to_ref.rs:46:32
    |
 LL |     let _: &Foo<u8> = unsafe { std::mem::transmute::<_, &Foo<_>>(raw) };
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*raw.cast::<Foo<_>>()`
 
-error: transmute from a pointer type (`*const i32`) to a reference type (`&_issue1231::Foo<'_, &u8>`)
+error: transmute from a pointer type (`*const i32`) to a reference type (`&issue1231::Foo<'_, &u8>`)
   --> tests/ui/transmute_ptr_to_ref.rs:49:33
    |
 LL |     let _: &Foo<&u8> = unsafe { std::mem::transmute::<_, &Foo<&_>>(raw) };
@@ -133,5 +133,53 @@ error: transmute from a pointer type (`*const &u32`) to a reference type (`&&u32
 LL |             _ => std::mem::transmute::<_, &&'b u32>(x),
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(x as *const () as *const &'b u32)`
 
-error: aborting due to 22 previous errors
+error: transmute from a pointer type (`*const [i32]`) to a reference type (`&[u32]`)
+  --> tests/ui/transmute_ptr_to_ref.rs:113:17
+   |
+LL |         let _ = core::mem::transmute::<_, &[u32]>(ptr);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(ptr as *const [u32])`
+
+error: transmute from a pointer type (`*const [i32]`) to a reference type (`&[u32]`)
+  --> tests/ui/transmute_ptr_to_ref.rs:115:25
+   |
+LL |         let _: &[u32] = core::mem::transmute(ptr);
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(ptr as *const [u32])`
+
+error: transmute from a pointer type (`*const [&str]`) to a reference type (`&[&[u8]]`)
+  --> tests/ui/transmute_ptr_to_ref.rs:119:17
+   |
+LL |         let _ = core::mem::transmute::<_, &[&[u8]]>(a_s_ptr);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(a_s_ptr as *const [&[u8]])`
+
+error: transmute from a pointer type (`*const [&str]`) to a reference type (`&[&[u8]]`)
+  --> tests/ui/transmute_ptr_to_ref.rs:121:27
+   |
+LL |         let _: &[&[u8]] = core::mem::transmute(a_s_ptr);
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(a_s_ptr as *const [&[u8]])`
+
+error: transmute from a pointer type (`*const [i32]`) to a reference type (`&[i32]`)
+  --> tests/ui/transmute_ptr_to_ref.rs:125:17
+   |
+LL |         let _ = core::mem::transmute::<_, &[i32]>(ptr);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(ptr as *const [i32])`
+
+error: transmute from a pointer type (`*const [i32]`) to a reference type (`&[i32]`)
+  --> tests/ui/transmute_ptr_to_ref.rs:127:25
+   |
+LL |         let _: &[i32] = core::mem::transmute(ptr);
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*ptr`
+
+error: transmute from a pointer type (`*const [&str]`) to a reference type (`&[&str]`)
+  --> tests/ui/transmute_ptr_to_ref.rs:131:17
+   |
+LL |         let _ = core::mem::transmute::<_, &[&str]>(a_s_ptr);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(a_s_ptr as *const [&str])`
+
+error: transmute from a pointer type (`*const [&str]`) to a reference type (`&[&str]`)
+  --> tests/ui/transmute_ptr_to_ref.rs:133:26
+   |
+LL |         let _: &[&str] = core::mem::transmute(a_s_ptr);
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(a_s_ptr as *const [&str])`
+
+error: aborting due to 30 previous errors
 
diff --git a/tests/ui/use_self.fixed b/tests/ui/use_self.fixed
index cccb6bffabb71..075e31d202b06 100644
--- a/tests/ui/use_self.fixed
+++ b/tests/ui/use_self.fixed
@@ -530,8 +530,8 @@ mod issue7206 {
 
     impl<'a> S2<S<'a>> {
         fn new_again() -> Self {
-            Self::new()
-            //~^ use_self
+            S2::new()
+            // FIXME: ^Broken by PR #15611
         }
     }
 }
@@ -755,3 +755,17 @@ mod crash_check_13128 {
         }
     }
 }
+
+mod issue_13277 {
+    trait Foo {
+        type Item<'foo>;
+    }
+    struct Bar<'b> {
+        content: &'b str,
+    }
+    impl<'b> Foo for Option<Bar<'b>> {
+        // when checking whether `Option<Bar<'foo>>` has a lifetime, check not only the outer
+        // `Option<T>`, but also the inner `Bar<'foo>`
+        type Item<'foo> = Option<Bar<'foo>>;
+    }
+}
diff --git a/tests/ui/use_self.rs b/tests/ui/use_self.rs
index 09288677aa715..6fbba0bbc550b 100644
--- a/tests/ui/use_self.rs
+++ b/tests/ui/use_self.rs
@@ -531,7 +531,7 @@ mod issue7206 {
     impl<'a> S2<S<'a>> {
         fn new_again() -> Self {
             S2::new()
-            //~^ use_self
+            // FIXME: ^Broken by PR #15611
         }
     }
 }
@@ -755,3 +755,17 @@ mod crash_check_13128 {
         }
     }
 }
+
+mod issue_13277 {
+    trait Foo {
+        type Item<'foo>;
+    }
+    struct Bar<'b> {
+        content: &'b str,
+    }
+    impl<'b> Foo for Option<Bar<'b>> {
+        // when checking whether `Option<Bar<'foo>>` has a lifetime, check not only the outer
+        // `Option<T>`, but also the inner `Bar<'foo>`
+        type Item<'foo> = Option<Bar<'foo>>;
+    }
+}
diff --git a/tests/ui/use_self.stderr b/tests/ui/use_self.stderr
index 781327696ac19..5f65c53ea25c3 100644
--- a/tests/ui/use_self.stderr
+++ b/tests/ui/use_self.stderr
@@ -169,12 +169,6 @@ error: unnecessary structure name repetition
 LL |             A::new::<submod::B>(submod::B {})
    |             ^ help: use the applicable keyword: `Self`
 
-error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:533:13
-   |
-LL |             S2::new()
-   |             ^^ help: use the applicable keyword: `Self`
-
 error: unnecessary structure name repetition
   --> tests/ui/use_self.rs:571:17
    |
@@ -259,5 +253,5 @@ error: unnecessary structure name repetition
 LL |                 E::A => {},
    |                 ^ help: use the applicable keyword: `Self`
 
-error: aborting due to 43 previous errors
+error: aborting due to 42 previous errors
 
diff --git a/tests/ui/useless_attribute.fixed b/tests/ui/useless_attribute.fixed
index be4fb55ddfb86..15070dd9c2ca6 100644
--- a/tests/ui/useless_attribute.fixed
+++ b/tests/ui/useless_attribute.fixed
@@ -158,3 +158,13 @@ pub mod redundant_imports_issue {
 
     empty!();
 }
+
+pub mod issue15636 {
+    pub mod f {
+        #[deprecated(since = "TBD")]
+        pub mod deprec {}
+    }
+
+    #[allow(deprecated_in_future)]
+    pub use f::deprec;
+}
diff --git a/tests/ui/useless_attribute.rs b/tests/ui/useless_attribute.rs
index 5a1bcf97a5b46..3f530de7fd8e3 100644
--- a/tests/ui/useless_attribute.rs
+++ b/tests/ui/useless_attribute.rs
@@ -158,3 +158,13 @@ pub mod redundant_imports_issue {
 
     empty!();
 }
+
+pub mod issue15636 {
+    pub mod f {
+        #[deprecated(since = "TBD")]
+        pub mod deprec {}
+    }
+
+    #[allow(deprecated_in_future)]
+    pub use f::deprec;
+}

From 5d1619b3ec4b843715c795789b7173e48066db5a Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Thu, 18 Sep 2025 17:21:54 +0200
Subject: [PATCH 1093/1889] Update Cargo.lock

---
 Cargo.lock | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d39cfefea0c77..4d1c6d4c46b23 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -568,7 +568,7 @@ checksum = "b94f61472cee1439c0b966b47e3aca9ae07e45d070759512cd390ea2bebc6675"
 
 [[package]]
 name = "clippy"
-version = "0.1.91"
+version = "0.1.92"
 dependencies = [
  "anstream",
  "askama",
@@ -595,7 +595,7 @@ dependencies = [
 
 [[package]]
 name = "clippy_config"
-version = "0.1.91"
+version = "0.1.92"
 dependencies = [
  "clippy_utils",
  "itertools",
@@ -618,7 +618,7 @@ dependencies = [
 
 [[package]]
 name = "clippy_lints"
-version = "0.1.91"
+version = "0.1.92"
 dependencies = [
  "arrayvec",
  "cargo_metadata 0.18.1",
@@ -649,7 +649,7 @@ dependencies = [
 
 [[package]]
 name = "clippy_utils"
-version = "0.1.91"
+version = "0.1.92"
 dependencies = [
  "arrayvec",
  "itertools",
@@ -1051,7 +1051,7 @@ dependencies = [
 
 [[package]]
 name = "declare_clippy_lint"
-version = "0.1.91"
+version = "0.1.92"
 
 [[package]]
 name = "derive-where"

From c6b4f6f33f6e78d575a477a3398af44e47b18630 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Lauren=C8=9Biu=20Nicola?= <lnicola@dend.ro>
Date: Thu, 18 Sep 2025 19:03:35 +0300
Subject: [PATCH 1094/1889] Bump rustc crates again

---
 src/tools/rust-analyzer/Cargo.lock            | 44 +++++++++----------
 src/tools/rust-analyzer/Cargo.toml            | 16 +++----
 .../crates/hir-ty/src/display.rs              |  6 +--
 .../crates/hir-ty/src/infer/coerce.rs         |  2 +-
 .../crates/hir-ty/src/lower_nextsolver.rs     |  2 +-
 .../crates/hir-ty/src/method_resolution.rs    |  2 +-
 .../crates/hir-ty/src/mir/eval.rs             |  2 +-
 .../hir-ty/src/next_solver/fulfill/errors.rs  |  2 +-
 .../crates/hir-ty/src/next_solver/mapping.rs  |  6 +--
 .../crates/hir-ty/src/next_solver/ty.rs       | 23 ++++------
 .../crates/hir-ty/src/next_solver/util.rs     |  2 +-
 11 files changed, 50 insertions(+), 57 deletions(-)

diff --git a/src/tools/rust-analyzer/Cargo.lock b/src/tools/rust-analyzer/Cargo.lock
index 9475391acdb7f..be21cfd9c24fe 100644
--- a/src/tools/rust-analyzer/Cargo.lock
+++ b/src/tools/rust-analyzer/Cargo.lock
@@ -1863,9 +1863,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_abi"
-version = "0.129.0"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa338fe027a8915009ca4a5a1cb7dde5fb4bc4170a928cb9462fda9d2ec52cec"
+checksum = "dd3df655461690c1554bc0e355f19495eef6cd729dc29f01bd07cb7cd2a0990a"
 dependencies = [
  "bitflags 2.9.1",
  "ra-ap-rustc_hashes",
@@ -1875,24 +1875,24 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_ast_ir"
-version = "0.129.0"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8468ef77e5359b3a51e327406f29ca2283a4feef93d3ba04f6740b274636922"
+checksum = "10f55c57676d67dba036171d23f7941a9c3b884181c5e93d3bd5fa599f8f129b"
 
 [[package]]
 name = "ra-ap-rustc_hashes"
-version = "0.129.0"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "300bc3264ccc1e7a5b3f065023a02e612774206d8ad685b3b05c2e4e317f8daa"
+checksum = "feec9ffe50d93b8f17770b49d4cbf46280e074a105c7c9325c8d2171cf395b76"
 dependencies = [
  "rustc-stable-hash",
 ]
 
 [[package]]
 name = "ra-ap-rustc_index"
-version = "0.129.0"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5eaa4a3ff61302e45c17ee72e067a39179081c19a12aa03192975a095f5d4e4b"
+checksum = "a73bab902bcdeceac4a9630ed732d19f6b7189cbe8e828a94156a780bd8e1196"
 dependencies = [
  "ra-ap-rustc_index_macros",
  "smallvec",
@@ -1900,9 +1900,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_index_macros"
-version = "0.129.0"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f7af0d51ee6bd5280be8e2eb7e9ac5cd9fc87af7a99f50cdb1316a8779c15ab"
+checksum = "88c7906b654b9c4188aee3fde82a7449bac6e156a5d86ad923bae05bd5040690"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1911,9 +1911,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_lexer"
-version = "0.129.0"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee4e7df9bf702c855de7bea5e3c14b96f0728d4712edb663b0f4b183622341fc"
+checksum = "acec3893f60dca2a37f9e838c08f3f3c8e012ce36194c2b84da96781e794e359"
 dependencies = [
  "memchr",
  "unicode-properties",
@@ -1922,9 +1922,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_next_trait_solver"
-version = "0.129.0"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15768080a276088a4a6af1e08a4ca622c57d5b4845ce5329dbbd71a2e025eecb"
+checksum = "c4626e22dc21062bdac1a8340b497365e1983a69cc271d7d052a62348b88bd7f"
 dependencies = [
  "derive-where",
  "ra-ap-rustc_index",
@@ -1935,9 +1935,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_parse_format"
-version = "0.129.0"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6f0c54b200c47768eaf142b1c829da9be1a3331a5defa4ac60bad4996f474e9"
+checksum = "47a95720d31edf45a8ccde190c14954425af0d53c9b6d4702fdd905b3951a2e1"
 dependencies = [
  "ra-ap-rustc_lexer",
  "rustc-literal-escaper 0.0.5",
@@ -1945,9 +1945,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_pattern_analysis"
-version = "0.129.0"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a078fbbefda17d8d5d2c9d6b5a1f9ee1e23fae5f057e74784f6b95c189b0b048"
+checksum = "0c1ebf6272bf11f0ba3b909e3405f547de32ea19d745b8fef11f1fb643b72fcd"
 dependencies = [
  "ra-ap-rustc_index",
  "rustc-hash 2.1.1",
@@ -1958,9 +1958,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_type_ir"
-version = "0.129.0"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "644e980122cdb7f2d7e175f33224dc6df414e8cf3e5dfbba9047e63336d9737a"
+checksum = "a9aa8f1344940e097514403c53bb5a1e4f5c3986da888461bc651373d195090b"
 dependencies = [
  "arrayvec",
  "bitflags 2.9.1",
@@ -1978,9 +1978,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_type_ir_macros"
-version = "0.129.0"
+version = "0.130.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "827d242d444cea86d9a64b5ce99db1462c9d43c7c6226d44ec2bc621b7c253c0"
+checksum = "30c65f1a5da2f3c39d72a56687694568abb203b3737a2321090e112da04958b3"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/src/tools/rust-analyzer/Cargo.toml b/src/tools/rust-analyzer/Cargo.toml
index 94ec1a07438f4..e81c4088122bf 100644
--- a/src/tools/rust-analyzer/Cargo.toml
+++ b/src/tools/rust-analyzer/Cargo.toml
@@ -89,14 +89,14 @@ vfs-notify = { path = "./crates/vfs-notify", version = "0.0.0" }
 vfs = { path = "./crates/vfs", version = "0.0.0" }
 edition = { path = "./crates/edition", version = "0.0.0" }
 
-ra-ap-rustc_lexer = { version = "0.129", default-features = false }
-ra-ap-rustc_parse_format = { version = "0.129", default-features = false }
-ra-ap-rustc_index = { version = "0.129", default-features = false }
-ra-ap-rustc_abi = { version = "0.129", default-features = false }
-ra-ap-rustc_pattern_analysis = { version = "0.129", default-features = false }
-ra-ap-rustc_ast_ir = { version = "0.129", default-features = false }
-ra-ap-rustc_type_ir = { version = "0.129", default-features = false }
-ra-ap-rustc_next_trait_solver = { version = "0.129", default-features = false }
+ra-ap-rustc_lexer = { version = "0.130", default-features = false }
+ra-ap-rustc_parse_format = { version = "0.130", default-features = false }
+ra-ap-rustc_index = { version = "0.130", default-features = false }
+ra-ap-rustc_abi = { version = "0.130", default-features = false }
+ra-ap-rustc_pattern_analysis = { version = "0.130", default-features = false }
+ra-ap-rustc_ast_ir = { version = "0.130", default-features = false }
+ra-ap-rustc_type_ir = { version = "0.130", default-features = false }
+ra-ap-rustc_next_trait_solver = { version = "0.130", default-features = false }
 
 # local crates that aren't published to crates.io. These should not have versions.
 
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 0a514f389b471..519e4b59237f4 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
@@ -897,7 +897,7 @@ fn render_const_scalar_inner(
                 }
                 f.write_str("]")
             }
-            TyKind::Dynamic(_, _, _) => {
+            TyKind::Dynamic(_, _) => {
                 let addr = usize::from_le_bytes(b[0..b.len() / 2].try_into().unwrap());
                 let ty_id = usize::from_le_bytes(b[b.len() / 2..].try_into().unwrap());
                 let Ok(t) = memory_map.vtable_ty(ty_id) else {
@@ -1064,7 +1064,7 @@ fn render_const_scalar_inner(
         | TyKind::Bound(_, _)
         | TyKind::Infer(_) => f.write_str("<placeholder-or-unknown-type>"),
         // The below arms are unreachable, since we handled them in ref case.
-        TyKind::Slice(_) | TyKind::Str | TyKind::Dynamic(_, _, _) => f.write_str("<unsized-value>"),
+        TyKind::Slice(_) | TyKind::Str | TyKind::Dynamic(_, _) => f.write_str("<unsized-value>"),
     }
 }
 
@@ -1213,7 +1213,7 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                     })
                 };
                 let (preds_to_print, has_impl_fn_pred) = match t.kind() {
-                    TyKind::Dynamic(bounds, region, _) => {
+                    TyKind::Dynamic(bounds, region) => {
                         let render_lifetime = f.render_region(region);
                         (
                             bounds.len() + render_lifetime as usize,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
index 88b10e87e531e..7930d8b0ed68f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
@@ -611,7 +611,7 @@ impl<'a, 'b, 'db> Coerce<'a, 'b, 'db> {
             | TyKind::Slice(_)
             | TyKind::FnDef(_, _)
             | TyKind::FnPtr(_, _)
-            | TyKind::Dynamic(_, _, _)
+            | TyKind::Dynamic(_, _)
             | TyKind::Closure(_, _)
             | TyKind::CoroutineClosure(_, _)
             | TyKind::Coroutine(_, _)
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
index 2292e5c99413e..b8e0599dba289 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
@@ -790,7 +790,7 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
                 },
                 None => Region::new_static(self.interner),
             };
-            Ty::new_dynamic(self.interner, bounds, region, rustc_type_ir::DynKind::Dyn)
+            Ty::new_dynamic(self.interner, bounds, region)
         } else {
             // FIXME: report error
             // (additional non-auto traits, associated type rebound, or no resolved trait)
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
index a4427517a10b8..7fa3d31fe5fdc 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
@@ -164,7 +164,7 @@ impl TyFingerprint {
                 rustc_ast_ir::Mutability::Not => TyFingerprint::RawPtr(Mutability::Not),
             },
             TyKind::Foreign(def) => TyFingerprint::ForeignType(crate::to_foreign_def_id(def.0)),
-            TyKind::Dynamic(bounds, _, _) => {
+            TyKind::Dynamic(bounds, _) => {
                 let trait_ref = bounds
                     .as_slice()
                     .iter()
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
index 6f950b8022c98..3e658cb93ed8a 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
@@ -2446,7 +2446,7 @@ impl<'db> Evaluator<'db> {
             | TyKind::Foreign(_)
             | TyKind::Error(_)
             | TyKind::Placeholder(_)
-            | TyKind::Dynamic(_, _, _)
+            | TyKind::Dynamic(_, _)
             | TyKind::Alias(_, _)
             | TyKind::Bound(_, _)
             | TyKind::Infer(_)
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill/errors.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill/errors.rs
index 6cd9e55acf0e7..b49fac18c5dd3 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill/errors.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill/errors.rs
@@ -1146,7 +1146,7 @@ mod wf {
                 }
                 TyKind::UnsafeBinder(ty) => {}
 
-                TyKind::Dynamic(data, r, _) => {
+                TyKind::Dynamic(data, r) => {
                     // WfObject
                     //
                     // Here, we defer WF checking due to higher-ranked
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
index d8a86ea083e08..b24b996b0927c 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
@@ -370,8 +370,7 @@ impl<'db> ChalkToNextSolver<'db, Ty<'db>> for chalk_ir::Ty<Interner> {
                         }),
                     );
                     let region = dyn_ty.lifetime.to_nextsolver(interner);
-                    let kind = rustc_type_ir::DynKind::Dyn;
-                    rustc_type_ir::TyKind::Dynamic(bounds, region, kind)
+                    rustc_type_ir::TyKind::Dynamic(bounds, region)
                 }
                 chalk_ir::TyKind::Alias(alias_ty) => match alias_ty {
                     chalk_ir::AliasTy::Projection(projection_ty) => {
@@ -1445,8 +1444,7 @@ pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>)
             TyKind::Function(fnptr)
         }
 
-        rustc_type_ir::TyKind::Dynamic(preds, region, dyn_kind) => {
-            assert!(matches!(dyn_kind, rustc_type_ir::DynKind::Dyn));
+        rustc_type_ir::TyKind::Dynamic(preds, region) => {
             let self_ty = Ty::new_bound(
                 interner,
                 DebruijnIndex::from_u32(1),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
index e6c444d0d6bed..70139e8666948 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
@@ -178,7 +178,7 @@ impl<'db> Ty<'db> {
             | TyKind::Never
             | TyKind::Error(_) => true,
 
-            TyKind::Str | TyKind::Slice(_) | TyKind::Dynamic(_, _, _) => match sizedness {
+            TyKind::Str | TyKind::Slice(_) | TyKind::Dynamic(_, _) => match sizedness {
                 SizedTraitKind::Sized => false,
                 SizedTraitKind::MetaSized => true,
             },
@@ -421,7 +421,7 @@ impl<'db> TypeSuperVisitable<DbInterner<'db>> for Ty<'db> {
             }
             TyKind::Slice(typ) => typ.visit_with(visitor),
             TyKind::Adt(_, args) => args.visit_with(visitor),
-            TyKind::Dynamic(ref trait_ty, ref reg, _) => {
+            TyKind::Dynamic(ref trait_ty, ref reg) => {
                 try_visit!(trait_ty.visit_with(visitor));
                 reg.visit_with(visitor)
             }
@@ -486,11 +486,9 @@ impl<'db> TypeSuperFoldable<DbInterner<'db>> for Ty<'db> {
             }
             TyKind::Slice(typ) => TyKind::Slice(typ.try_fold_with(folder)?),
             TyKind::Adt(tid, args) => TyKind::Adt(tid, args.try_fold_with(folder)?),
-            TyKind::Dynamic(trait_ty, region, representation) => TyKind::Dynamic(
-                trait_ty.try_fold_with(folder)?,
-                region.try_fold_with(folder)?,
-                representation,
-            ),
+            TyKind::Dynamic(trait_ty, region) => {
+                TyKind::Dynamic(trait_ty.try_fold_with(folder)?, region.try_fold_with(folder)?)
+            }
             TyKind::Tuple(ts) => TyKind::Tuple(ts.try_fold_with(folder)?),
             TyKind::FnDef(def_id, args) => TyKind::FnDef(def_id, args.try_fold_with(folder)?),
             TyKind::FnPtr(sig_tys, hdr) => TyKind::FnPtr(sig_tys.try_fold_with(folder)?, hdr),
@@ -537,11 +535,9 @@ impl<'db> TypeSuperFoldable<DbInterner<'db>> for Ty<'db> {
             TyKind::Array(typ, sz) => TyKind::Array(typ.fold_with(folder), sz.fold_with(folder)),
             TyKind::Slice(typ) => TyKind::Slice(typ.fold_with(folder)),
             TyKind::Adt(tid, args) => TyKind::Adt(tid, args.fold_with(folder)),
-            TyKind::Dynamic(trait_ty, region, representation) => TyKind::Dynamic(
-                trait_ty.fold_with(folder),
-                region.fold_with(folder),
-                representation,
-            ),
+            TyKind::Dynamic(trait_ty, region) => {
+                TyKind::Dynamic(trait_ty.fold_with(folder), region.fold_with(folder))
+            }
             TyKind::Tuple(ts) => TyKind::Tuple(ts.fold_with(folder)),
             TyKind::FnDef(def_id, args) => TyKind::FnDef(def_id, args.fold_with(folder)),
             TyKind::FnPtr(sig_tys, hdr) => TyKind::FnPtr(sig_tys.fold_with(folder), hdr),
@@ -676,9 +672,8 @@ impl<'db> rustc_type_ir::inherent::Ty<DbInterner<'db>> for Ty<'db> {
         interner: DbInterner<'db>,
         preds: <DbInterner<'db> as rustc_type_ir::Interner>::BoundExistentialPredicates,
         region: <DbInterner<'db> as rustc_type_ir::Interner>::Region,
-        kind: rustc_type_ir::DynKind,
     ) -> Self {
-        Ty::new(interner, TyKind::Dynamic(preds, region, kind))
+        Ty::new(interner, TyKind::Dynamic(preds, region))
     }
 
     fn new_coroutine(
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/util.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/util.rs
index a50f20a565ee2..a7f9817f9c08e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/util.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/util.rs
@@ -461,7 +461,7 @@ pub fn sizedness_constraint_for_ty<'db>(
         | CoroutineWitness(..) | Never => None,
 
         // these are never sized
-        Str | Slice(..) | Dynamic(_, _, rustc_type_ir::DynKind::Dyn) => match sizedness {
+        Str | Slice(..) | Dynamic(_, _) => match sizedness {
             // Never `Sized`
             SizedTraitKind::Sized => Some(ty),
             // Always `MetaSized`

From 7f55f5761cd44b8ad49efb976ae650602fc2d42a Mon Sep 17 00:00:00 2001
From: Erick Tryzelaar <etryzelaar@google.com>
Date: Fri, 12 Sep 2025 20:29:23 +0000
Subject: [PATCH 1095/1889] Allow windows resource compiler to be overridden

It is now required to provide a resource compiler on windows when
compiling rust. This allows toolchain builders to explicitly provide a
path to an alternative, such as llvm-rc, instead of the one that's
provided by the Windows SDK.
---
 bootstrap.example.toml                      | 3 +++
 compiler/rustc_windows_rc/src/lib.rs        | 7 +++++--
 src/bootstrap/src/core/builder/cargo.rs     | 5 +++++
 src/bootstrap/src/core/config/config.rs     | 3 +++
 src/bootstrap/src/core/config/toml/build.rs | 1 +
 src/bootstrap/src/utils/change_tracker.rs   | 5 +++++
 6 files changed, 22 insertions(+), 2 deletions(-)

diff --git a/bootstrap.example.toml b/bootstrap.example.toml
index 51529751dd58f..0cd571134ef15 100644
--- a/bootstrap.example.toml
+++ b/bootstrap.example.toml
@@ -325,6 +325,9 @@
 # Defaults to the Python interpreter used to execute x.py.
 #build.python = "python"
 
+# The path to (or name of) the resource compiler executable to use on Windows.
+#build.windows-rc = "rc.exe"
+
 # The path to the REUSE executable to use. Note that REUSE is not required in
 # most cases, as our tooling relies on a cached (and shrunk) copy of the
 # REUSE output present in the git repository and in our source tarballs.
diff --git a/compiler/rustc_windows_rc/src/lib.rs b/compiler/rustc_windows_rc/src/lib.rs
index caa5e5ef27656..5e95557501ea2 100644
--- a/compiler/rustc_windows_rc/src/lib.rs
+++ b/compiler/rustc_windows_rc/src/lib.rs
@@ -35,8 +35,11 @@ pub fn compile_windows_resource_file(
     resources_dir.push("resources");
     fs::create_dir_all(&resources_dir).unwrap();
 
-    let resource_compiler =
-        find_resource_compiler(&env::var("CARGO_CFG_TARGET_ARCH").unwrap()).expect("found rc.exe");
+    let resource_compiler = if let Ok(path) = env::var("RUSTC_WINDOWS_RC") {
+        path.into()
+    } else {
+        find_resource_compiler(&env::var("CARGO_CFG_TARGET_ARCH").unwrap()).expect("found rc.exe")
+    };
 
     let rc_path = resources_dir.join(file_stem.with_extension("rc"));
 
diff --git a/src/bootstrap/src/core/builder/cargo.rs b/src/bootstrap/src/core/builder/cargo.rs
index 6121bf7d9cd62..ee2bb710674c0 100644
--- a/src/bootstrap/src/core/builder/cargo.rs
+++ b/src/bootstrap/src/core/builder/cargo.rs
@@ -1227,6 +1227,11 @@ impl Builder<'_> {
             rustflags.arg("-Zehcont-guard");
         }
 
+        // Optionally override the rc.exe when compiling rustc on Windows.
+        if let Some(windows_rc) = &self.config.windows_rc {
+            cargo.env("RUSTC_WINDOWS_RC", windows_rc);
+        }
+
         // For `cargo doc` invocations, make rustdoc print the Rust version into the docs
         // This replaces spaces with tabs because RUSTDOCFLAGS does not
         // support arguments with regular spaces. Hopefully someday Cargo will
diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index efb7ad9169971..a97399b3d4ae9 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -273,6 +273,7 @@ pub struct Config {
     pub gdb: Option<PathBuf>,
     pub lldb: Option<PathBuf>,
     pub python: Option<PathBuf>,
+    pub windows_rc: Option<PathBuf>,
     pub reuse: Option<PathBuf>,
     pub cargo_native_static: bool,
     pub configure_args: Vec<String>,
@@ -450,6 +451,7 @@ impl Config {
             nodejs: build_nodejs,
             npm: build_npm,
             python: build_python,
+            windows_rc: build_windows_rc,
             reuse: build_reuse,
             locked_deps: build_locked_deps,
             vendor: build_vendor,
@@ -1342,6 +1344,7 @@ impl Config {
                 .unwrap_or(rust_debug == Some(true)),
             vendor,
             verbose_tests,
+            windows_rc: build_windows_rc.map(PathBuf::from),
             // tidy-alphabetical-end
         }
     }
diff --git a/src/bootstrap/src/core/config/toml/build.rs b/src/bootstrap/src/core/config/toml/build.rs
index 25c19f1070a39..a9d4d3961c9b7 100644
--- a/src/bootstrap/src/core/config/toml/build.rs
+++ b/src/bootstrap/src/core/config/toml/build.rs
@@ -37,6 +37,7 @@ define_config! {
         nodejs: Option<String> = "nodejs",
         npm: Option<String> = "npm",
         python: Option<String> = "python",
+        windows_rc: Option<String> = "windows-rc",
         reuse: Option<String> = "reuse",
         locked_deps: Option<bool> = "locked-deps",
         vendor: Option<bool> = "vendor",
diff --git a/src/bootstrap/src/utils/change_tracker.rs b/src/bootstrap/src/utils/change_tracker.rs
index 2c48cebd2df05..6b187578c31ec 100644
--- a/src/bootstrap/src/utils/change_tracker.rs
+++ b/src/bootstrap/src/utils/change_tracker.rs
@@ -551,4 +551,9 @@ pub const CONFIG_CHANGE_HISTORY: &[ChangeInfo] = &[
         severity: ChangeSeverity::Info,
         summary: "There is now a bootstrap option called `rust.parallel-frontend-threads`, which can be used to set the number of threads for the compiler frontend used during compilation of Rust code.",
     },
+    ChangeInfo {
+        change_id: 146663,
+        severity: ChangeSeverity::Info,
+        summary: "New option `build.windows-rc` that will override which resource compiler on Windows will be used to compile Rust.",
+    },
 ];

From 63a55083aa03e94dc380af31d51e3ffd944cb2b4 Mon Sep 17 00:00:00 2001
From: pommicket <pommicket@gmail.com>
Date: Mon, 12 May 2025 10:32:21 -0400
Subject: [PATCH 1096/1889] Add clippy::self_only_used_in_recursion lint

and use it instead of clippy::only_used_in_recursion
when the parameter in question is self.
---
 CHANGELOG.md                               |   1 +
 clippy_lints/src/declared_lints.rs         |   1 +
 clippy_lints/src/only_used_in_recursion.rs | 153 ++++++++++++++++-----
 tests/ui/only_used_in_recursion.rs         |   3 +-
 tests/ui/only_used_in_recursion.stderr     |  70 +++++-----
 5 files changed, 162 insertions(+), 66 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4a9be02143722..f4e4cbfe37509 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6597,6 +6597,7 @@ Released 2018-09-13
 [`self_assignment`]: https://rust-lang.github.io/rust-clippy/master/index.html#self_assignment
 [`self_named_constructors`]: https://rust-lang.github.io/rust-clippy/master/index.html#self_named_constructors
 [`self_named_module_files`]: https://rust-lang.github.io/rust-clippy/master/index.html#self_named_module_files
+[`self_only_used_in_recursion`]: https://rust-lang.github.io/rust-clippy/master/index.html#self_only_used_in_recursion
 [`semicolon_if_nothing_returned`]: https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_if_nothing_returned
 [`semicolon_inside_block`]: https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_inside_block
 [`semicolon_outside_block`]: https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_outside_block
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 1b19a8851edd4..c67026e6f266d 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -575,6 +575,7 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES_INFO,
     crate::octal_escapes::OCTAL_ESCAPES_INFO,
     crate::only_used_in_recursion::ONLY_USED_IN_RECURSION_INFO,
+    crate::only_used_in_recursion::SELF_ONLY_USED_IN_RECURSION_INFO,
     crate::operators::ABSURD_EXTREME_COMPARISONS_INFO,
     crate::operators::ARITHMETIC_SIDE_EFFECTS_INFO,
     crate::operators::ASSIGN_OP_PATTERN_INFO,
diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index a42763172f565..bd2fb9d1aa72a 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -24,6 +24,33 @@ declare_clippy_lint! {
     /// the calculations have no side-effects (function calls or mutating dereference)
     /// and the assigned variables are also only in recursion, it is useless.
     ///
+    /// ### Example
+    /// ```no_run
+    /// fn f(a: usize, b: usize) -> usize {
+    ///     if a == 0 {
+    ///         1
+    ///     } else {
+    ///         f(a - 1, b + 1)
+    ///     }
+    /// }
+    /// # fn main() {
+    /// #     print!("{}", f(1, 1));
+    /// # }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// fn f(a: usize) -> usize {
+    ///     if a == 0 {
+    ///         1
+    ///     } else {
+    ///         f(a - 1)
+    ///     }
+    /// }
+    /// # fn main() {
+    /// #     print!("{}", f(1));
+    /// # }
+    /// ```
+    ///
     /// ### Known problems
     /// Too many code paths in the linting code are currently untested and prone to produce false
     /// positives or are prone to have performance implications.
@@ -51,39 +78,90 @@ declare_clippy_lint! {
     /// - struct pattern binding
     ///
     /// Also, when you recurse the function name with path segments, it is not possible to detect.
+    #[clippy::version = "1.61.0"]
+    pub ONLY_USED_IN_RECURSION,
+    complexity,
+    "arguments that is only used in recursion can be removed"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `self` receiver that is only used in recursion with no side-effects.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// It may be possible to remove the `self` argument, allowing the function to be
+    /// used without an object of type `Self`.
     ///
     /// ### Example
     /// ```no_run
-    /// fn f(a: usize, b: usize) -> usize {
-    ///     if a == 0 {
-    ///         1
-    ///     } else {
-    ///         f(a - 1, b + 1)
+    /// struct Foo;
+    /// impl Foo {
+    ///     fn f(&self, n: u32) -> u32 {
+    ///         if n == 0 {
+    ///             1
+    ///         } else {
+    ///             n * self.f(n - 1)
+    ///         }
     ///     }
     /// }
     /// # fn main() {
-    /// #     print!("{}", f(1, 1));
+    /// #     print!("{}", Foo.f(10));
     /// # }
     /// ```
     /// Use instead:
     /// ```no_run
-    /// fn f(a: usize) -> usize {
-    ///     if a == 0 {
-    ///         1
-    ///     } else {
-    ///         f(a - 1)
+    /// struct Foo;
+    /// impl Foo {
+    ///     fn f(n: u32) -> u32 {
+    ///         if n == 0 {
+    ///             1
+    ///         } else {
+    ///             n * Self::f(n - 1)
+    ///         }
     ///     }
     /// }
     /// # fn main() {
-    /// #     print!("{}", f(1));
+    /// #     print!("{}", Foo::f(10));
     /// # }
     /// ```
-    #[clippy::version = "1.61.0"]
-    pub ONLY_USED_IN_RECURSION,
-    complexity,
-    "arguments that is only used in recursion can be removed"
+    ///
+    /// ### Known problems
+    /// Too many code paths in the linting code are currently untested and prone to produce false
+    /// positives or are prone to have performance implications.
+    ///
+    /// In some cases, this would not catch all useless arguments.
+    ///
+    /// ```no_run
+    /// struct Foo;
+    /// impl Foo {
+    ///     fn foo(&self, a: usize) -> usize {
+    ///         let f = |x| x;
+    ///
+    ///         if a == 0 {
+    ///             1
+    ///         } else {
+    ///             f(self).foo(a)
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// For example, here `self` is only used in recursion, but the lint would not catch it.
+    ///
+    /// List of some examples that can not be caught:
+    /// - binary operation of non-primitive types
+    /// - closure usage
+    /// - some `break` relative operations
+    /// - struct pattern binding
+    ///
+    /// Also, when you recurse the function name with path segments, it is not possible to detect.
+    #[clippy::version = "1.92.0"]
+    pub SELF_ONLY_USED_IN_RECURSION,
+    pedantic,
+    "self receiver only used to recursively call method can be removed"
 }
-impl_lint_pass!(OnlyUsedInRecursion => [ONLY_USED_IN_RECURSION]);
+impl_lint_pass!(OnlyUsedInRecursion => [ONLY_USED_IN_RECURSION, SELF_ONLY_USED_IN_RECURSION]);
 
 #[derive(Clone, Copy)]
 enum FnKind {
@@ -355,26 +433,39 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
             self.params.flag_for_linting();
             for param in &self.params.params {
                 if param.apply_lint.get() {
-                    span_lint_and_then(
-                        cx,
-                        ONLY_USED_IN_RECURSION,
-                        param.ident.span,
-                        "parameter is only used in recursion",
-                        |diag| {
-                            if param.ident.name != kw::SelfLower {
+                    if param.ident.name == kw::SelfLower {
+                        span_lint_and_then(
+                            cx,
+                            SELF_ONLY_USED_IN_RECURSION,
+                            param.ident.span,
+                            "`self` is only used in recursion",
+                            |diag| {
+                                diag.span_note(
+                                    param.uses.iter().map(|x| x.span).collect::<Vec<_>>(),
+                                    "`self` used here",
+                                );
+                            },
+                        );
+                    } else {
+                        span_lint_and_then(
+                            cx,
+                            ONLY_USED_IN_RECURSION,
+                            param.ident.span,
+                            "parameter is only used in recursion",
+                            |diag| {
                                 diag.span_suggestion(
                                     param.ident.span,
                                     "if this is intentional, prefix it with an underscore",
                                     format!("_{}", param.ident.name),
                                     Applicability::MaybeIncorrect,
                                 );
-                            }
-                            diag.span_note(
-                                param.uses.iter().map(|x| x.span).collect::<Vec<_>>(),
-                                "parameter used here",
-                            );
-                        },
-                    );
+                                diag.span_note(
+                                    param.uses.iter().map(|x| x.span).collect::<Vec<_>>(),
+                                    "parameter used here",
+                                );
+                            },
+                        );
+                    }
                 }
             }
             self.params.clear();
diff --git a/tests/ui/only_used_in_recursion.rs b/tests/ui/only_used_in_recursion.rs
index 7d6075ba9ea47..d58635969238b 100644
--- a/tests/ui/only_used_in_recursion.rs
+++ b/tests/ui/only_used_in_recursion.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::only_used_in_recursion)]
+#![warn(clippy::self_only_used_in_recursion)]
 //@no-rustfix
 fn _simple(x: u32) -> u32 {
     x
@@ -74,7 +75,7 @@ impl A {
     }
 
     fn _method_self(&self, flag: usize, a: usize) -> usize {
-        //~^ only_used_in_recursion
+        //~^ self_only_used_in_recursion
         //~| only_used_in_recursion
 
         if flag == 0 { 0 } else { self._method_self(flag - 1, a) }
diff --git a/tests/ui/only_used_in_recursion.stderr b/tests/ui/only_used_in_recursion.stderr
index ca08319e11200..5d1e3e9c50fd9 100644
--- a/tests/ui/only_used_in_recursion.stderr
+++ b/tests/ui/only_used_in_recursion.stderr
@@ -1,11 +1,11 @@
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:11:27
+  --> tests/ui/only_used_in_recursion.rs:12:27
    |
 LL | fn _one_unused(flag: u32, a: usize) -> usize {
    |                           ^ help: if this is intentional, prefix it with an underscore: `_a`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:14:53
+  --> tests/ui/only_used_in_recursion.rs:15:53
    |
 LL |     if flag == 0 { 0 } else { _one_unused(flag - 1, a) }
    |                                                     ^
@@ -13,181 +13,183 @@ LL |     if flag == 0 { 0 } else { _one_unused(flag - 1, a) }
    = help: to override `-D warnings` add `#[allow(clippy::only_used_in_recursion)]`
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:17:27
+  --> tests/ui/only_used_in_recursion.rs:18:27
    |
 LL | fn _two_unused(flag: u32, a: u32, b: i32) -> usize {
    |                           ^ help: if this is intentional, prefix it with an underscore: `_a`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:21:53
+  --> tests/ui/only_used_in_recursion.rs:22:53
    |
 LL |     if flag == 0 { 0 } else { _two_unused(flag - 1, a, b) }
    |                                                     ^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:17:35
+  --> tests/ui/only_used_in_recursion.rs:18:35
    |
 LL | fn _two_unused(flag: u32, a: u32, b: i32) -> usize {
    |                                   ^ help: if this is intentional, prefix it with an underscore: `_b`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:21:56
+  --> tests/ui/only_used_in_recursion.rs:22:56
    |
 LL |     if flag == 0 { 0 } else { _two_unused(flag - 1, a, b) }
    |                                                        ^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:24:26
+  --> tests/ui/only_used_in_recursion.rs:25:26
    |
 LL | fn _with_calc(flag: u32, a: i64) -> usize {
    |                          ^ help: if this is intentional, prefix it with an underscore: `_a`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:30:32
+  --> tests/ui/only_used_in_recursion.rs:31:32
    |
 LL |         _with_calc(flag - 1, (-a + 10) * 5)
    |                                ^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:39:33
+  --> tests/ui/only_used_in_recursion.rs:40:33
    |
 LL | fn _used_with_unused(flag: u32, a: i32, b: i32) -> usize {
    |                                 ^ help: if this is intentional, prefix it with an underscore: `_a`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:46:38
+  --> tests/ui/only_used_in_recursion.rs:47:38
    |
 LL |         _used_with_unused(flag - 1, -a, a + b)
    |                                      ^  ^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:39:41
+  --> tests/ui/only_used_in_recursion.rs:40:41
    |
 LL | fn _used_with_unused(flag: u32, a: i32, b: i32) -> usize {
    |                                         ^ help: if this is intentional, prefix it with an underscore: `_b`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:46:45
+  --> tests/ui/only_used_in_recursion.rs:47:45
    |
 LL |         _used_with_unused(flag - 1, -a, a + b)
    |                                             ^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:50:35
+  --> tests/ui/only_used_in_recursion.rs:51:35
    |
 LL | fn _codependent_unused(flag: u32, a: i32, b: i32) -> usize {
    |                                   ^ help: if this is intentional, prefix it with an underscore: `_a`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:57:39
+  --> tests/ui/only_used_in_recursion.rs:58:39
    |
 LL |         _codependent_unused(flag - 1, a * b, a + b)
    |                                       ^      ^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:50:43
+  --> tests/ui/only_used_in_recursion.rs:51:43
    |
 LL | fn _codependent_unused(flag: u32, a: i32, b: i32) -> usize {
    |                                           ^ help: if this is intentional, prefix it with an underscore: `_b`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:57:43
+  --> tests/ui/only_used_in_recursion.rs:58:43
    |
 LL |         _codependent_unused(flag - 1, a * b, a + b)
    |                                           ^      ^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:61:30
+  --> tests/ui/only_used_in_recursion.rs:62:30
    |
 LL | fn _not_primitive(flag: u32, b: String) -> usize {
    |                              ^ help: if this is intentional, prefix it with an underscore: `_b`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:64:56
+  --> tests/ui/only_used_in_recursion.rs:65:56
    |
 LL |     if flag == 0 { 0 } else { _not_primitive(flag - 1, b) }
    |                                                        ^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:70:29
+  --> tests/ui/only_used_in_recursion.rs:71:29
    |
 LL |     fn _method(flag: usize, a: usize) -> usize {
    |                             ^ help: if this is intentional, prefix it with an underscore: `_a`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:73:59
+  --> tests/ui/only_used_in_recursion.rs:74:59
    |
 LL |         if flag == 0 { 0 } else { Self::_method(flag - 1, a) }
    |                                                           ^
 
-error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:76:22
+error: `self` is only used in recursion
+  --> tests/ui/only_used_in_recursion.rs:77:22
    |
 LL |     fn _method_self(&self, flag: usize, a: usize) -> usize {
    |                      ^^^^
    |
-note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:80:35
+note: `self` used here
+  --> tests/ui/only_used_in_recursion.rs:81:35
    |
 LL |         if flag == 0 { 0 } else { self._method_self(flag - 1, a) }
    |                                   ^^^^
+   = note: `-D clippy::self-only-used-in-recursion` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::self_only_used_in_recursion)]`
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:76:41
+  --> tests/ui/only_used_in_recursion.rs:77:41
    |
 LL |     fn _method_self(&self, flag: usize, a: usize) -> usize {
    |                                         ^ help: if this is intentional, prefix it with an underscore: `_a`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:80:63
+  --> tests/ui/only_used_in_recursion.rs:81:63
    |
 LL |         if flag == 0 { 0 } else { self._method_self(flag - 1, a) }
    |                                                               ^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:90:26
+  --> tests/ui/only_used_in_recursion.rs:91:26
    |
 LL |     fn method(flag: u32, a: usize) -> usize {
    |                          ^ help: if this is intentional, prefix it with an underscore: `_a`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:93:58
+  --> tests/ui/only_used_in_recursion.rs:94:58
    |
 LL |         if flag == 0 { 0 } else { Self::method(flag - 1, a) }
    |                                                          ^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:96:38
+  --> tests/ui/only_used_in_recursion.rs:97:38
    |
 LL |     fn method_self(&self, flag: u32, a: usize) -> usize {
    |                                      ^ help: if this is intentional, prefix it with an underscore: `_a`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:99:62
+  --> tests/ui/only_used_in_recursion.rs:100:62
    |
 LL |         if flag == 0 { 0 } else { self.method_self(flag - 1, a) }
    |                                                              ^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:124:26
+  --> tests/ui/only_used_in_recursion.rs:125:26
    |
 LL |     fn method(flag: u32, a: usize) -> usize {
    |                          ^ help: if this is intentional, prefix it with an underscore: `_a`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:127:58
+  --> tests/ui/only_used_in_recursion.rs:128:58
    |
 LL |         if flag == 0 { 0 } else { Self::method(flag - 1, a) }
    |                                                          ^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:130:38
+  --> tests/ui/only_used_in_recursion.rs:131:38
    |
 LL |     fn method_self(&self, flag: u32, a: usize) -> usize {
    |                                      ^ help: if this is intentional, prefix it with an underscore: `_a`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:133:62
+  --> tests/ui/only_used_in_recursion.rs:134:62
    |
 LL |         if flag == 0 { 0 } else { self.method_self(flag - 1, a) }
    |                                                              ^

From 60f0407ba313fbea163ee4fe21a8a71ba633ecc6 Mon Sep 17 00:00:00 2001
From: Shoyu Vanilla <modulo641@gmail.com>
Date: Fri, 19 Sep 2025 03:04:14 +0900
Subject: [PATCH 1097/1889] fix: Fix `indexmap` with `in-rust-tree`

---
 src/tools/rust-analyzer/crates/hir-ty/src/next_solver.rs | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver.rs
index deee8dd1ff06e..073a02908deeb 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver.rs
@@ -45,9 +45,4 @@ pub type PolyFnSig<'db> = Binder<'db, rustc_type_ir::FnSig<DbInterner<'db>>>;
 pub type TypingMode<'db> = rustc_type_ir::TypingMode<DbInterner<'db>>;
 pub type TypeError<'db> = rustc_type_ir::error::TypeError<DbInterner<'db>>;
 pub type QueryResult<'db> = rustc_type_ir::solve::QueryResult<DbInterner<'db>>;
-
-#[cfg(feature = "in-rust-tree")]
-use rustc_data_structure::sorted_map::index_map as indexmap;
-
-pub type FxIndexMap<K, V> =
-    indexmap::IndexMap<K, V, std::hash::BuildHasherDefault<rustc_hash::FxHasher>>;
+pub type FxIndexMap<K, V> = rustc_type_ir::data_structures::IndexMap<K, V>;

From 3ba8b8e0e5284ad3c33eb6a1490a6adcea4c105d Mon Sep 17 00:00:00 2001
From: Shoyu Vanilla <modulo641@gmail.com>
Date: Fri, 19 Sep 2025 03:26:03 +0900
Subject: [PATCH 1098/1889] minor: Yet another rustc crates bump

---
 src/tools/rust-analyzer/Cargo.lock            | 44 +++++++++----------
 src/tools/rust-analyzer/Cargo.toml            | 16 +++----
 .../crates/hir-ty/src/infer/unify.rs          |  2 +-
 .../crates/hir-ty/src/next_solver/fulfill.rs  |  4 +-
 .../hir-ty/src/next_solver/fulfill/errors.rs  | 22 ++++++----
 .../hir-ty/src/next_solver/infer/context.rs   |  9 ++++
 .../hir-ty/src/next_solver/infer/select.rs    |  8 ++--
 .../crates/hir-ty/src/next_solver/inspect.rs  |  2 +-
 .../rust-analyzer/crates/hir-ty/src/traits.rs |  4 +-
 9 files changed, 62 insertions(+), 49 deletions(-)

diff --git a/src/tools/rust-analyzer/Cargo.lock b/src/tools/rust-analyzer/Cargo.lock
index be21cfd9c24fe..97c4f06dd5960 100644
--- a/src/tools/rust-analyzer/Cargo.lock
+++ b/src/tools/rust-analyzer/Cargo.lock
@@ -1863,9 +1863,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_abi"
-version = "0.130.0"
+version = "0.131.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd3df655461690c1554bc0e355f19495eef6cd729dc29f01bd07cb7cd2a0990a"
+checksum = "016c05852e89655395fbf7d5e729e31cd58b2690480b3a8468eb2b38c91f3756"
 dependencies = [
  "bitflags 2.9.1",
  "ra-ap-rustc_hashes",
@@ -1875,24 +1875,24 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_ast_ir"
-version = "0.130.0"
+version = "0.131.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10f55c57676d67dba036171d23f7941a9c3b884181c5e93d3bd5fa599f8f129b"
+checksum = "c5bff48bd0a26f17a4e2e8610bc393296c3d002e221f5c6c4d2875e6a64a3b4b"
 
 [[package]]
 name = "ra-ap-rustc_hashes"
-version = "0.130.0"
+version = "0.131.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "feec9ffe50d93b8f17770b49d4cbf46280e074a105c7c9325c8d2171cf395b76"
+checksum = "5d15e7571f6f31f6112fd2fcbc3450a6ef477cc6bfe51643a2b110436a7455f0"
 dependencies = [
  "rustc-stable-hash",
 ]
 
 [[package]]
 name = "ra-ap-rustc_index"
-version = "0.130.0"
+version = "0.131.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a73bab902bcdeceac4a9630ed732d19f6b7189cbe8e828a94156a780bd8e1196"
+checksum = "60a30f0a15682f1194e5812cc3544266f3494ca8fb3c5033e8b9c08f4f8b8c6d"
 dependencies = [
  "ra-ap-rustc_index_macros",
  "smallvec",
@@ -1900,9 +1900,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_index_macros"
-version = "0.130.0"
+version = "0.131.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88c7906b654b9c4188aee3fde82a7449bac6e156a5d86ad923bae05bd5040690"
+checksum = "e2f82c9176b964591e1657a9f0fae2850525542d39075c49c2459afc291f4804"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1911,9 +1911,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_lexer"
-version = "0.130.0"
+version = "0.131.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "acec3893f60dca2a37f9e838c08f3f3c8e012ce36194c2b84da96781e794e359"
+checksum = "585c71ff7da5ca1e8a0c65d5e7cec7ab2a7e9e45b6859543bd2d0be21bee631c"
 dependencies = [
  "memchr",
  "unicode-properties",
@@ -1922,9 +1922,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_next_trait_solver"
-version = "0.130.0"
+version = "0.131.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4626e22dc21062bdac1a8340b497365e1983a69cc271d7d052a62348b88bd7f"
+checksum = "839f521a6cd97c71b2b6681604ace38a9c6737f7a223d072fa8f909879f9dc4b"
 dependencies = [
  "derive-where",
  "ra-ap-rustc_index",
@@ -1935,9 +1935,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_parse_format"
-version = "0.130.0"
+version = "0.131.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47a95720d31edf45a8ccde190c14954425af0d53c9b6d4702fdd905b3951a2e1"
+checksum = "83e7872a4fa0620937b60fc6270aa8c31864cb324357553e2be5b2bdc25fa89a"
 dependencies = [
  "ra-ap-rustc_lexer",
  "rustc-literal-escaper 0.0.5",
@@ -1945,9 +1945,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_pattern_analysis"
-version = "0.130.0"
+version = "0.131.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c1ebf6272bf11f0ba3b909e3405f547de32ea19d745b8fef11f1fb643b72fcd"
+checksum = "4ecd7f9b960c8cf1e9d02a25297f52a520134132164cfedd3e69fee4f294d41c"
 dependencies = [
  "ra-ap-rustc_index",
  "rustc-hash 2.1.1",
@@ -1958,9 +1958,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_type_ir"
-version = "0.130.0"
+version = "0.131.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9aa8f1344940e097514403c53bb5a1e4f5c3986da888461bc651373d195090b"
+checksum = "9494498f8f7c57a5b4ea4e35a6c554cca8d5323adb534d13dc6cd117a7e00e4d"
 dependencies = [
  "arrayvec",
  "bitflags 2.9.1",
@@ -1978,9 +1978,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_type_ir_macros"
-version = "0.130.0"
+version = "0.131.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30c65f1a5da2f3c39d72a56687694568abb203b3737a2321090e112da04958b3"
+checksum = "28ed893760b86529080af59438c28dfa9ca976b821cfd0a3b0eb9591932847e6"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/src/tools/rust-analyzer/Cargo.toml b/src/tools/rust-analyzer/Cargo.toml
index e81c4088122bf..513af11a87aad 100644
--- a/src/tools/rust-analyzer/Cargo.toml
+++ b/src/tools/rust-analyzer/Cargo.toml
@@ -89,14 +89,14 @@ vfs-notify = { path = "./crates/vfs-notify", version = "0.0.0" }
 vfs = { path = "./crates/vfs", version = "0.0.0" }
 edition = { path = "./crates/edition", version = "0.0.0" }
 
-ra-ap-rustc_lexer = { version = "0.130", default-features = false }
-ra-ap-rustc_parse_format = { version = "0.130", default-features = false }
-ra-ap-rustc_index = { version = "0.130", default-features = false }
-ra-ap-rustc_abi = { version = "0.130", default-features = false }
-ra-ap-rustc_pattern_analysis = { version = "0.130", default-features = false }
-ra-ap-rustc_ast_ir = { version = "0.130", default-features = false }
-ra-ap-rustc_type_ir = { version = "0.130", default-features = false }
-ra-ap-rustc_next_trait_solver = { version = "0.130", default-features = false }
+ra-ap-rustc_lexer = { version = "0.131", default-features = false }
+ra-ap-rustc_parse_format = { version = "0.131", default-features = false }
+ra-ap-rustc_index = { version = "0.131", default-features = false }
+ra-ap-rustc_abi = { version = "0.131", default-features = false }
+ra-ap-rustc_pattern_analysis = { version = "0.131", default-features = false }
+ra-ap-rustc_ast_ir = { version = "0.131", default-features = false }
+ra-ap-rustc_type_ir = { version = "0.131", default-features = false }
+ra-ap-rustc_next_trait_solver = { version = "0.131", default-features = false }
 
 # local crates that aren't published to crates.io. These should not have versions.
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
index 77eaf83eec73d..1687857ae1ac2 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
@@ -910,7 +910,7 @@ impl<'db> InferenceTable<'db> {
         match result {
             Ok((_, Certainty::Yes)) => {}
             Err(rustc_type_ir::solve::NoSolution) => {}
-            Ok((_, Certainty::Maybe(_))) => {
+            Ok((_, Certainty::Maybe { .. })) => {
                 self.fulfillment_cx.register_predicate_obligation(
                     &self.infer_ctxt,
                     Obligation::new(
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill.rs
index a8183ab422792..34dff37972e7e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill.rs
@@ -182,7 +182,7 @@ impl<'db> FulfillmentCtxt<'db> {
                 if let Some(certainty) = delegate.compute_goal_fast_path(goal, Span::dummy()) {
                     match certainty {
                         Certainty::Yes => {}
-                        Certainty::Maybe(_) => {
+                        Certainty::Maybe { .. } => {
                             self.obligations.register(obligation, None);
                         }
                     }
@@ -211,7 +211,7 @@ impl<'db> FulfillmentCtxt<'db> {
 
                 match certainty {
                     Certainty::Yes => {}
-                    Certainty::Maybe(_) => self.obligations.register(obligation, stalled_on),
+                    Certainty::Maybe { .. } => self.obligations.register(obligation, stalled_on),
                 }
             }
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill/errors.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill/errors.rs
index b49fac18c5dd3..ab4a229fbc05f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill/errors.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill/errors.rs
@@ -153,15 +153,17 @@ pub(super) fn fulfillment_error_for_stalled<'db>(
             Span::dummy(),
             None,
         ) {
-            Ok(GoalEvaluation { certainty: Certainty::Maybe(MaybeCause::Ambiguity), .. }) => {
-                (FulfillmentErrorCode::Ambiguity { overflow: None }, true)
-            }
+            Ok(GoalEvaluation {
+                certainty: Certainty::Maybe { cause: MaybeCause::Ambiguity, .. },
+                ..
+            }) => (FulfillmentErrorCode::Ambiguity { overflow: None }, true),
             Ok(GoalEvaluation {
                 certainty:
-                    Certainty::Maybe(MaybeCause::Overflow {
-                        suggest_increasing_limit,
-                        keep_constraints: _,
-                    }),
+                    Certainty::Maybe {
+                        cause:
+                            MaybeCause::Overflow { suggest_increasing_limit, keep_constraints: _ },
+                        ..
+                    },
                 ..
             }) => (
                 FulfillmentErrorCode::Ambiguity { overflow: Some(suggest_increasing_limit) },
@@ -314,7 +316,8 @@ impl<'db> BestObligation<'db> {
                 .instantiate_proof_tree_for_nested_goal(GoalSource::Misc, obligation.as_goal());
             // Skip nested goals that aren't the *reason* for our goal's failure.
             match (self.consider_ambiguities, nested_goal.result()) {
-                (true, Ok(Certainty::Maybe(MaybeCause::Ambiguity))) | (false, Err(_)) => {}
+                (true, Ok(Certainty::Maybe { cause: MaybeCause::Ambiguity, .. }))
+                | (false, Err(_)) => {}
                 _ => continue,
             }
 
@@ -456,7 +459,8 @@ impl<'db> ProofTreeVisitor<'db> for BestObligation<'db> {
         let interner = goal.infcx().interner;
         // Skip goals that aren't the *reason* for our goal's failure.
         match (self.consider_ambiguities, goal.result()) {
-            (true, Ok(Certainty::Maybe(MaybeCause::Ambiguity))) | (false, Err(_)) => {}
+            (true, Ok(Certainty::Maybe { cause: MaybeCause::Ambiguity, .. })) | (false, Err(_)) => {
+            }
             _ => return ControlFlow::Continue(()),
         }
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/context.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/context.rs
index 45ce7e6f6cc75..5aa5ad14af551 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/context.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/context.rs
@@ -321,4 +321,13 @@ impl<'db> rustc_type_ir::InferCtxtLike for InferCtxt<'db> {
     fn sub_unify_ty_vids_raw(&self, a: rustc_type_ir::TyVid, b: rustc_type_ir::TyVid) {
         self.sub_unify_ty_vids_raw(a, b);
     }
+
+    fn opaques_with_sub_unified_hidden_type(
+        &self,
+        _ty: TyVid,
+    ) -> Vec<rustc_type_ir::AliasTy<Self::Interner>> {
+        // FIXME: I guess we are okay without this for now since currently r-a lacks of
+        // detailed checks over opaque types. Might need to implement this in future.
+        vec![]
+    }
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/select.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/select.rs
index d656d94f4f91e..4f111fa662668 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/select.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/infer/select.rs
@@ -208,7 +208,7 @@ impl<'db> ProofTreeVisitor<'db> for Select {
 
         // Don't winnow until `Certainty::Yes` -- we don't need to winnow until
         // codegen, and only on the good path.
-        if matches!(goal.result().unwrap(), Certainty::Maybe(..)) {
+        if matches!(goal.result().unwrap(), Certainty::Maybe { .. }) {
             return ControlFlow::Break(Ok(None));
         }
 
@@ -241,7 +241,7 @@ fn candidate_should_be_dropped_in_favor_of<'db>(
 ) -> bool {
     // Don't winnow until `Certainty::Yes` -- we don't need to winnow until
     // codegen, and only on the good path.
-    if matches!(other.result().unwrap(), Certainty::Maybe(..)) {
+    if matches!(other.result().unwrap(), Certainty::Maybe { .. }) {
         return false;
     }
 
@@ -284,13 +284,13 @@ fn candidate_should_be_dropped_in_favor_of<'db>(
 }
 
 fn to_selection<'db>(cand: InspectCandidate<'_, 'db>) -> Option<Selection<'db>> {
-    if let Certainty::Maybe(..) = cand.shallow_certainty() {
+    if let Certainty::Maybe { .. } = cand.shallow_certainty() {
         return None;
     }
 
     let nested = match cand.result().expect("expected positive result") {
         Certainty::Yes => Vec::new(),
-        Certainty::Maybe(_) => cand
+        Certainty::Maybe { .. } => cand
             .instantiate_nested_goals()
             .into_iter()
             .map(|nested| {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/inspect.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/inspect.rs
index cab3c69118f64..f9d0aa99cf4f3 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/inspect.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/inspect.rs
@@ -350,7 +350,7 @@ impl<'a, 'db> InspectGoal<'a, 'db> {
                 inspect::ProbeStep::MakeCanonicalResponse { shallow_certainty: c } => {
                     assert!(matches!(
                         shallow_certainty.replace(c),
-                        None | Some(Certainty::Maybe(MaybeCause::Ambiguity))
+                        None | Some(Certainty::Maybe { cause: MaybeCause::Ambiguity, .. })
                     ));
                 }
                 inspect::ProbeStep::NestedProbe(ref probe) => {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs b/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
index d73d7da4b9b98..8b6836c0e90bf 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
@@ -277,7 +277,7 @@ pub fn next_trait_solve(
         Ok((_, Certainty::Yes, args)) => NextTraitSolveResult::Certain(
             convert_canonical_args_for_result(DbInterner::new_with(db, Some(krate), block), args),
         ),
-        Ok((_, Certainty::Maybe(_), args)) => {
+        Ok((_, Certainty::Maybe { .. }, args)) => {
             let subst = convert_canonical_args_for_result(
                 DbInterner::new_with(db, Some(krate), block),
                 args,
@@ -316,7 +316,7 @@ pub fn next_trait_solve_canonical_in_ctxt<'db>(
         Ok((_, Certainty::Yes, args)) => NextTraitSolveResult::Certain(
             convert_canonical_args_for_result(infer_ctxt.interner, args),
         ),
-        Ok((_, Certainty::Maybe(_), args)) => {
+        Ok((_, Certainty::Maybe { .. }, args)) => {
             let subst = convert_canonical_args_for_result(infer_ctxt.interner, args);
             NextTraitSolveResult::Uncertain(chalk_ir::Canonical {
                 binders: subst.binders,

From 00bfe9ce6ed3d21b39a40309974dda5c19dc6fb0 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 18 Sep 2025 20:41:06 +0200
Subject: [PATCH 1099/1889] tweak genmc error report note

---
 src/tools/miri/src/concurrency/genmc/run.rs            | 10 +++++-----
 .../tests/genmc/fail/data_race/mpu2_rels_rlx.stderr    |  3 ++-
 .../genmc/fail/data_race/weak_orderings.rel_rlx.stderr |  3 ++-
 .../genmc/fail/data_race/weak_orderings.rlx_acq.stderr |  3 ++-
 .../genmc/fail/data_race/weak_orderings.rlx_rlx.stderr |  3 ++-
 src/tools/miri/tests/genmc/fail/loom/buggy_inc.stderr  |  3 ++-
 .../tests/genmc/fail/loom/store_buffering.genmc.stderr |  3 ++-
 .../tests/genmc/fail/simple/2w2w_weak.relaxed4.stderr  |  3 ++-
 .../tests/genmc/fail/simple/2w2w_weak.release4.stderr  |  3 ++-
 .../tests/genmc/fail/simple/2w2w_weak.sc3_rel1.stderr  |  3 ++-
 10 files changed, 23 insertions(+), 14 deletions(-)

diff --git a/src/tools/miri/src/concurrency/genmc/run.rs b/src/tools/miri/src/concurrency/genmc/run.rs
index bc2f5f7b79ec4..33c5b6b0a005f 100644
--- a/src/tools/miri/src/concurrency/genmc/run.rs
+++ b/src/tools/miri/src/concurrency/genmc/run.rs
@@ -70,7 +70,7 @@ fn run_genmc_mode_impl<'tcx>(
 
         // Execute the program until completion to get the return value, or return if an error happens:
         let Some(return_code) = eval_entry(genmc_ctx.clone()) else {
-            genmc_ctx.print_genmc_output(genmc_config);
+            genmc_ctx.print_genmc_output(genmc_config, tcx);
             return None;
         };
 
@@ -97,7 +97,7 @@ fn run_genmc_mode_impl<'tcx>(
                 // Since we don't have any span information for the error at this point,
                 // we just print GenMC's error string, and the full GenMC output if requested.
                 eprintln!("(GenMC) Error detected: {error}");
-                genmc_ctx.print_genmc_output(genmc_config);
+                genmc_ctx.print_genmc_output(genmc_config, tcx);
                 return None;
             }
         }
@@ -110,13 +110,13 @@ impl GenmcCtx {
     ///
     /// This message can be very verbose and is likely not useful for the average user.
     /// This function should be called *after* Miri has printed all of its output.
-    fn print_genmc_output(&self, genmc_config: &GenmcConfig) {
+    fn print_genmc_output(&self, genmc_config: &GenmcConfig, tcx: TyCtxt<'_>) {
         if genmc_config.print_genmc_output {
             eprintln!("GenMC error report:");
             eprintln!("{}", self.get_result_message());
         } else {
-            eprintln!(
-                "(Add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report.)"
+            tcx.dcx().note(
+                "add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report"
             );
         }
     }
diff --git a/src/tools/miri/tests/genmc/fail/data_race/mpu2_rels_rlx.stderr b/src/tools/miri/tests/genmc/fail/data_race/mpu2_rels_rlx.stderr
index 00de74009d9b8..1ffb55f22e6e0 100644
--- a/src/tools/miri/tests/genmc/fail/data_race/mpu2_rels_rlx.stderr
+++ b/src/tools/miri/tests/genmc/fail/data_race/mpu2_rels_rlx.stderr
@@ -16,6 +16,7 @@ note: inside `genmc::spawn_pthread_closure::thread_func::<{closure@tests/genmc/f
 LL |         f();
    |         ^^^
 
-(Add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report.)
+note: add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report
+
 error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rel_rlx.stderr b/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rel_rlx.stderr
index 501957a90d3ac..b0037c211c69d 100644
--- a/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rel_rlx.stderr
+++ b/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rel_rlx.stderr
@@ -16,6 +16,7 @@ note: inside `genmc::spawn_pthread_closure::thread_func::<{closure@tests/genmc/f
 LL |         f();
    |         ^^^
 
-(Add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report.)
+note: add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report
+
 error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rlx_acq.stderr b/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rlx_acq.stderr
index 501957a90d3ac..b0037c211c69d 100644
--- a/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rlx_acq.stderr
+++ b/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rlx_acq.stderr
@@ -16,6 +16,7 @@ note: inside `genmc::spawn_pthread_closure::thread_func::<{closure@tests/genmc/f
 LL |         f();
    |         ^^^
 
-(Add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report.)
+note: add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report
+
 error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rlx_rlx.stderr b/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rlx_rlx.stderr
index 501957a90d3ac..b0037c211c69d 100644
--- a/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rlx_rlx.stderr
+++ b/src/tools/miri/tests/genmc/fail/data_race/weak_orderings.rlx_rlx.stderr
@@ -16,6 +16,7 @@ note: inside `genmc::spawn_pthread_closure::thread_func::<{closure@tests/genmc/f
 LL |         f();
    |         ^^^
 
-(Add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report.)
+note: add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report
+
 error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/genmc/fail/loom/buggy_inc.stderr b/src/tools/miri/tests/genmc/fail/loom/buggy_inc.stderr
index 9c3ba1d4c5924..290cdf90a0847 100644
--- a/src/tools/miri/tests/genmc/fail/loom/buggy_inc.stderr
+++ b/src/tools/miri/tests/genmc/fail/loom/buggy_inc.stderr
@@ -10,6 +10,7 @@ LL |             std::process::abort();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-(Add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report.)
+note: add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report
+
 error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/genmc/fail/loom/store_buffering.genmc.stderr b/src/tools/miri/tests/genmc/fail/loom/store_buffering.genmc.stderr
index db92d0573fad2..7742790e33307 100644
--- a/src/tools/miri/tests/genmc/fail/loom/store_buffering.genmc.stderr
+++ b/src/tools/miri/tests/genmc/fail/loom/store_buffering.genmc.stderr
@@ -10,6 +10,7 @@ LL |             std::process::abort();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-(Add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report.)
+note: add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report
+
 error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.relaxed4.stderr b/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.relaxed4.stderr
index 773f86a975967..80ac7206644c6 100644
--- a/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.relaxed4.stderr
+++ b/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.relaxed4.stderr
@@ -10,6 +10,7 @@ LL |             std::process::abort();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-(Add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report.)
+note: add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report
+
 error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.release4.stderr b/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.release4.stderr
index 773f86a975967..80ac7206644c6 100644
--- a/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.release4.stderr
+++ b/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.release4.stderr
@@ -10,6 +10,7 @@ LL |             std::process::abort();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-(Add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report.)
+note: add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report
+
 error: aborting due to 1 previous error
 
diff --git a/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.sc3_rel1.stderr b/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.sc3_rel1.stderr
index 773f86a975967..80ac7206644c6 100644
--- a/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.sc3_rel1.stderr
+++ b/src/tools/miri/tests/genmc/fail/simple/2w2w_weak.sc3_rel1.stderr
@@ -10,6 +10,7 @@ LL |             std::process::abort();
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
-(Add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report.)
+note: add `-Zmiri-genmc-print-genmc-output` to MIRIFLAGS to see the detailed GenMC error report
+
 error: aborting due to 1 previous error
 

From 01cd04f78d86cdc1a60441fd9d6d08aa2fe05a2f Mon Sep 17 00:00:00 2001
From: Shoyu Vanilla <modulo641@gmail.com>
Date: Fri, 19 Sep 2025 04:20:24 +0900
Subject: [PATCH 1100/1889] fix: Fix one more thing in `in-rust-tree`

---
 .../rust-analyzer/crates/hir-ty/src/next_solver/inspect.rs      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/inspect.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/inspect.rs
index f9d0aa99cf4f3..128135d8debe8 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/inspect.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/inspect.rs
@@ -1,4 +1,4 @@
-pub use ra_ap_rustc_next_trait_solver::solve::inspect::*;
+pub use rustc_next_trait_solver::solve::inspect::*;
 
 use rustc_ast_ir::try_visit;
 use rustc_next_trait_solver::{

From eb7abeb2614fb64f4d23afaa83df7380159b72c2 Mon Sep 17 00:00:00 2001
From: Yotam Ofek <yotam.ofek@gmail.com>
Date: Sun, 16 Feb 2025 10:14:53 +0000
Subject: [PATCH 1101/1889] Specialize `Iterator::eq[_by]` for `TrustedLen`
 iterators

---
 library/core/src/iter/traits/iterator.rs | 52 ++++++++++++++++++++++--
 1 file changed, 48 insertions(+), 4 deletions(-)

diff --git a/library/core/src/iter/traits/iterator.rs b/library/core/src/iter/traits/iterator.rs
index 7fb162a653fb9..695f8d1e195e9 100644
--- a/library/core/src/iter/traits/iterator.rs
+++ b/library/core/src/iter/traits/iterator.rs
@@ -4,6 +4,7 @@ use super::super::{
     Product, Rev, Scan, Skip, SkipWhile, StepBy, Sum, Take, TakeWhile, TrustedRandomAccessNoCoerce,
     Zip, try_process,
 };
+use super::TrustedLen;
 use crate::array;
 use crate::cmp::{self, Ordering};
 use crate::num::NonZero;
@@ -3816,10 +3817,7 @@ pub trait Iterator {
             }
         }
 
-        match iter_compare(self, other.into_iter(), compare(eq)) {
-            ControlFlow::Continue(ord) => ord == Ordering::Equal,
-            ControlFlow::Break(()) => false,
-        }
+        SpecIterEq::spec_iter_eq(self, other.into_iter(), compare(eq))
     }
 
     /// Determines if the elements of this [`Iterator`] are not equal to those of
@@ -4038,6 +4036,42 @@ pub trait Iterator {
     }
 }
 
+trait SpecIterEq<B: Iterator>: Iterator {
+    fn spec_iter_eq<F>(self, b: B, f: F) -> bool
+    where
+        F: FnMut(Self::Item, <B as Iterator>::Item) -> ControlFlow<()>;
+}
+
+impl<A: Iterator, B: Iterator> SpecIterEq<B> for A {
+    #[inline]
+    default fn spec_iter_eq<F>(self, b: B, f: F) -> bool
+    where
+        F: FnMut(Self::Item, <B as Iterator>::Item) -> ControlFlow<()>,
+    {
+        iter_eq(self, b, f)
+    }
+}
+
+impl<A: Iterator + TrustedLen, B: Iterator + TrustedLen> SpecIterEq<B> for A {
+    #[inline]
+    fn spec_iter_eq<F>(self, b: B, f: F) -> bool
+    where
+        F: FnMut(Self::Item, <B as Iterator>::Item) -> ControlFlow<()>,
+    {
+        // we *can't* short-circuit if:
+        match (self.size_hint(), b.size_hint()) {
+            // ... both iterators have the same length
+            ((_, Some(a)), (_, Some(b))) if a == b => {}
+            // ... or both of them are longer than `usize::MAX` (i.e. have an unknown length).
+            ((_, None), (_, None)) => {}
+            // otherwise, we can ascertain that they are unequal without actually comparing items
+            _ => return false,
+        }
+
+        iter_eq(self, b, f)
+    }
+}
+
 /// Compares two iterators element-wise using the given function.
 ///
 /// If `ControlFlow::Continue(())` is returned from the function, the comparison moves on to the next
@@ -4078,6 +4112,16 @@ where
     }
 }
 
+#[inline]
+fn iter_eq<A, B, F>(a: A, b: B, f: F) -> bool
+where
+    A: Iterator,
+    B: Iterator,
+    F: FnMut(A::Item, B::Item) -> ControlFlow<()>,
+{
+    iter_compare(a, b, f).continue_value().is_some_and(|ord| ord == Ordering::Equal)
+}
+
 /// Implements `Iterator` for mutable references to iterators, such as those produced by [`Iterator::by_ref`].
 ///
 /// This implementation passes all method calls on to the original iterator.

From f19b560fa96ca8dd4352db6372f662fa32942a9f Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 18 Sep 2025 22:02:46 +0200
Subject: [PATCH 1102/1889] implement sqrt for f16 and f128

---
 src/tools/miri/src/intrinsics/math.rs | 16 ++++++++++
 src/tools/miri/tests/pass/float.rs    | 44 ++++++++++++++++++---------
 2 files changed, 45 insertions(+), 15 deletions(-)

diff --git a/src/tools/miri/src/intrinsics/math.rs b/src/tools/miri/src/intrinsics/math.rs
index 21d4a92e7d288..ca81454a98c08 100644
--- a/src/tools/miri/src/intrinsics/math.rs
+++ b/src/tools/miri/src/intrinsics/math.rs
@@ -20,6 +20,14 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         match intrinsic_name {
             // Operations we can do with soft-floats.
+            "sqrtf16" => {
+                let [f] = check_intrinsic_arg_count(args)?;
+                let f = this.read_scalar(f)?.to_f16()?;
+                // Sqrt is specified to be fully precise.
+                let res = math::sqrt(f);
+                let res = this.adjust_nan(res, &[f]);
+                this.write_scalar(res, dest)?;
+            }
             "sqrtf32" => {
                 let [f] = check_intrinsic_arg_count(args)?;
                 let f = this.read_scalar(f)?.to_f32()?;
@@ -36,6 +44,14 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 let res = this.adjust_nan(res, &[f]);
                 this.write_scalar(res, dest)?;
             }
+            "sqrtf128" => {
+                let [f] = check_intrinsic_arg_count(args)?;
+                let f = this.read_scalar(f)?.to_f128()?;
+                // Sqrt is specified to be fully precise.
+                let res = math::sqrt(f);
+                let res = this.adjust_nan(res, &[f]);
+                this.write_scalar(res, dest)?;
+            }
 
             "fmaf32" => {
                 let [a, b, c] = check_intrinsic_arg_count(args)?;
diff --git a/src/tools/miri/tests/pass/float.rs b/src/tools/miri/tests/pass/float.rs
index 9f1b3f612b2d2..3ce5ea8356bd5 100644
--- a/src/tools/miri/tests/pass/float.rs
+++ b/src/tools/miri/tests/pass/float.rs
@@ -281,6 +281,35 @@ fn basic() {
     assert_eq!(34.2f64.abs(), 34.2f64);
     assert_eq!((-1.0f128).abs(), 1.0f128);
     assert_eq!(34.2f128.abs(), 34.2f128);
+
+    assert_eq!(64_f16.sqrt(), 8_f16);
+    assert_eq!(64_f32.sqrt(), 8_f32);
+    assert_eq!(64_f64.sqrt(), 8_f64);
+    assert_eq!(64_f128.sqrt(), 8_f128);
+    assert_eq!(f16::INFINITY.sqrt(), f16::INFINITY);
+    assert_eq!(f32::INFINITY.sqrt(), f32::INFINITY);
+    assert_eq!(f64::INFINITY.sqrt(), f64::INFINITY);
+    assert_eq!(f128::INFINITY.sqrt(), f128::INFINITY);
+    assert_eq!(0.0_f16.sqrt().total_cmp(&0.0), std::cmp::Ordering::Equal);
+    assert_eq!(0.0_f32.sqrt().total_cmp(&0.0), std::cmp::Ordering::Equal);
+    assert_eq!(0.0_f64.sqrt().total_cmp(&0.0), std::cmp::Ordering::Equal);
+    assert_eq!(0.0_f128.sqrt().total_cmp(&0.0), std::cmp::Ordering::Equal);
+    assert_eq!((-0.0_f16).sqrt().total_cmp(&-0.0), std::cmp::Ordering::Equal);
+    assert_eq!((-0.0_f32).sqrt().total_cmp(&-0.0), std::cmp::Ordering::Equal);
+    assert_eq!((-0.0_f64).sqrt().total_cmp(&-0.0), std::cmp::Ordering::Equal);
+    assert_eq!((-0.0_f128).sqrt().total_cmp(&-0.0), std::cmp::Ordering::Equal);
+    assert!((-5.0_f16).sqrt().is_nan());
+    assert!((-5.0_f32).sqrt().is_nan());
+    assert!((-5.0_f64).sqrt().is_nan());
+    assert!((-5.0_f128).sqrt().is_nan());
+    assert!(f16::NEG_INFINITY.sqrt().is_nan());
+    assert!(f32::NEG_INFINITY.sqrt().is_nan());
+    assert!(f64::NEG_INFINITY.sqrt().is_nan());
+    assert!(f128::NEG_INFINITY.sqrt().is_nan());
+    assert!(f16::NAN.sqrt().is_nan());
+    assert!(f32::NAN.sqrt().is_nan());
+    assert!(f64::NAN.sqrt().is_nan());
+    assert!(f128::NAN.sqrt().is_nan());
 }
 
 /// Test casts from floats to ints and back
@@ -1012,21 +1041,6 @@ pub fn libm() {
         unsafe { ldexp(a, b) }
     }
 
-    assert_eq!(64_f32.sqrt(), 8_f32);
-    assert_eq!(64_f64.sqrt(), 8_f64);
-    assert_eq!(f32::INFINITY.sqrt(), f32::INFINITY);
-    assert_eq!(f64::INFINITY.sqrt(), f64::INFINITY);
-    assert_eq!(0.0_f32.sqrt().total_cmp(&0.0), std::cmp::Ordering::Equal);
-    assert_eq!(0.0_f64.sqrt().total_cmp(&0.0), std::cmp::Ordering::Equal);
-    assert_eq!((-0.0_f32).sqrt().total_cmp(&-0.0), std::cmp::Ordering::Equal);
-    assert_eq!((-0.0_f64).sqrt().total_cmp(&-0.0), std::cmp::Ordering::Equal);
-    assert!((-5.0_f32).sqrt().is_nan());
-    assert!((-5.0_f64).sqrt().is_nan());
-    assert!(f32::NEG_INFINITY.sqrt().is_nan());
-    assert!(f64::NEG_INFINITY.sqrt().is_nan());
-    assert!(f32::NAN.sqrt().is_nan());
-    assert!(f64::NAN.sqrt().is_nan());
-
     assert_approx_eq!(25f32.powi(-2), 0.0016f32);
     assert_approx_eq!(23.2f64.powi(2), 538.24f64);
 

From 77f2d865549e8f2e1ad656c8202de9bfa6d2e354 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 18 Sep 2025 22:13:15 +0200
Subject: [PATCH 1103/1889] share sqrt implemention across float types

---
 src/tools/miri/src/intrinsics/math.rs | 52 ++++++++++-----------------
 src/tools/miri/src/math.rs            | 12 +++----
 2 files changed, 25 insertions(+), 39 deletions(-)

diff --git a/src/tools/miri/src/intrinsics/math.rs b/src/tools/miri/src/intrinsics/math.rs
index ca81454a98c08..b9c99f2859468 100644
--- a/src/tools/miri/src/intrinsics/math.rs
+++ b/src/tools/miri/src/intrinsics/math.rs
@@ -1,5 +1,5 @@
 use rand::Rng;
-use rustc_apfloat::{self, Float, Round};
+use rustc_apfloat::{self, Float, FloatConvert, Round};
 use rustc_middle::mir;
 use rustc_middle::ty::{self, FloatTy};
 
@@ -7,6 +7,20 @@ use self::helpers::{ToHost, ToSoft};
 use super::check_intrinsic_arg_count;
 use crate::*;
 
+fn sqrt<'tcx, F: Float + FloatConvert<F> + Into<Scalar>>(
+    this: &mut MiriInterpCx<'tcx>,
+    args: &[OpTy<'tcx>],
+    dest: &MPlaceTy<'tcx>,
+) -> InterpResult<'tcx> {
+    let [f] = check_intrinsic_arg_count(args)?;
+    let f = this.read_scalar(f)?;
+    let f: F = f.to_float()?;
+    // Sqrt is specified to be fully precise.
+    let res = math::sqrt(f);
+    let res = this.adjust_nan(res, &[f]);
+    this.write_scalar(res, dest)
+}
+
 impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
 pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     fn emulate_math_intrinsic(
@@ -20,38 +34,10 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         match intrinsic_name {
             // Operations we can do with soft-floats.
-            "sqrtf16" => {
-                let [f] = check_intrinsic_arg_count(args)?;
-                let f = this.read_scalar(f)?.to_f16()?;
-                // Sqrt is specified to be fully precise.
-                let res = math::sqrt(f);
-                let res = this.adjust_nan(res, &[f]);
-                this.write_scalar(res, dest)?;
-            }
-            "sqrtf32" => {
-                let [f] = check_intrinsic_arg_count(args)?;
-                let f = this.read_scalar(f)?.to_f32()?;
-                // Sqrt is specified to be fully precise.
-                let res = math::sqrt(f);
-                let res = this.adjust_nan(res, &[f]);
-                this.write_scalar(res, dest)?;
-            }
-            "sqrtf64" => {
-                let [f] = check_intrinsic_arg_count(args)?;
-                let f = this.read_scalar(f)?.to_f64()?;
-                // Sqrt is specified to be fully precise.
-                let res = math::sqrt(f);
-                let res = this.adjust_nan(res, &[f]);
-                this.write_scalar(res, dest)?;
-            }
-            "sqrtf128" => {
-                let [f] = check_intrinsic_arg_count(args)?;
-                let f = this.read_scalar(f)?.to_f128()?;
-                // Sqrt is specified to be fully precise.
-                let res = math::sqrt(f);
-                let res = this.adjust_nan(res, &[f]);
-                this.write_scalar(res, dest)?;
-            }
+            "sqrtf16" => sqrt::<rustc_apfloat::ieee::Half>(this, args, dest)?,
+            "sqrtf32" => sqrt::<rustc_apfloat::ieee::Single>(this, args, dest)?,
+            "sqrtf64" => sqrt::<rustc_apfloat::ieee::Double>(this, args, dest)?,
+            "sqrtf128" => sqrt::<rustc_apfloat::ieee::Quad>(this, args, dest)?,
 
             "fmaf32" => {
                 let [a, b, c] = check_intrinsic_arg_count(args)?;
diff --git a/src/tools/miri/src/math.rs b/src/tools/miri/src/math.rs
index 401e6dd7aab84..50472ed3638e9 100644
--- a/src/tools/miri/src/math.rs
+++ b/src/tools/miri/src/math.rs
@@ -2,7 +2,7 @@ use std::ops::Neg;
 use std::{f32, f64};
 
 use rand::Rng as _;
-use rustc_apfloat::Float as _;
+use rustc_apfloat::Float;
 use rustc_apfloat::ieee::{DoubleS, IeeeFloat, Semantics, SingleS};
 use rustc_middle::ty::{self, FloatTy, ScalarInt};
 
@@ -317,19 +317,19 @@ where
     }
 }
 
-pub(crate) fn sqrt<S: rustc_apfloat::ieee::Semantics>(x: IeeeFloat<S>) -> IeeeFloat<S> {
+pub(crate) fn sqrt<F: Float>(x: F) -> F {
     match x.category() {
         // preserve zero sign
         rustc_apfloat::Category::Zero => x,
         // propagate NaN
         rustc_apfloat::Category::NaN => x,
         // sqrt of negative number is NaN
-        _ if x.is_negative() => IeeeFloat::NAN,
+        _ if x.is_negative() => F::NAN,
         // sqrt(∞) = ∞
-        rustc_apfloat::Category::Infinity => IeeeFloat::INFINITY,
+        rustc_apfloat::Category::Infinity => F::INFINITY,
         rustc_apfloat::Category::Normal => {
             // Floating point precision, excluding the integer bit
-            let prec = i32::try_from(S::PRECISION).unwrap() - 1;
+            let prec = i32::try_from(F::PRECISION).unwrap() - 1;
 
             // x = 2^(exp - prec) * mant
             // where mant is an integer with prec+1 bits
@@ -394,7 +394,7 @@ pub(crate) fn sqrt<S: rustc_apfloat::ieee::Semantics>(x: IeeeFloat<S>) -> IeeeFl
             res = (res + 1) >> 1;
 
             // Build resulting value with res as mantissa and exp/2 as exponent
-            IeeeFloat::from_u128(res).value.scalbn(exp / 2 - prec)
+            F::from_u128(res).value.scalbn(exp / 2 - prec)
         }
     }
 }

From 45e5c765c660463179128c5deaf6f56ff24f3578 Mon Sep 17 00:00:00 2001
From: beepster4096 <19316085+beepster4096@users.noreply.github.com>
Date: Thu, 18 Sep 2025 13:17:39 -0700
Subject: [PATCH 1104/1889] fix tidy spellchecking on windows

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

diff --git a/src/tools/tidy/src/lib.rs b/src/tools/tidy/src/lib.rs
index 2a9c3963d2d86..f7920e3205ab2 100644
--- a/src/tools/tidy/src/lib.rs
+++ b/src/tools/tidy/src/lib.rs
@@ -237,7 +237,7 @@ pub fn ensure_version_or_cargo_install(
     if !cargo_exit_code.success() {
         return Err(io::Error::other("cargo install failed"));
     }
-    let bin_path = tool_bin_dir.join(bin_name);
+    let bin_path = tool_bin_dir.join(bin_name).with_extension(env::consts::EXE_EXTENSION);
     assert!(
         matches!(bin_path.try_exists(), Ok(true)),
         "cargo install did not produce the expected binary"

From 7af6e590a4d1f66770b49698bd01d88cca98f18f Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 18 Sep 2025 23:33:38 +0200
Subject: [PATCH 1105/1889] update lockfile

---
 Cargo.lock | 37 ++++++++++++++++++++++---------------
 1 file changed, 22 insertions(+), 15 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d39cfefea0c77..910a03eaffca2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -674,7 +674,7 @@ checksum = "fe6d2e5af09e8c8ad56c969f2157a3d4238cebc7c55f0a517728c38f7b200f81"
 dependencies = [
  "serde",
  "termcolor",
- "unicode-width 0.1.14",
+ "unicode-width 0.2.1",
 ]
 
 [[package]]
@@ -937,23 +937,24 @@ dependencies = [
 
 [[package]]
 name = "cxx"
-version = "1.0.168"
+version = "1.0.185"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7aa144b12f11741f0dab5b4182896afad46faa0598b6a061f7b9d17a21837ba7"
+checksum = "2f81de88da10862f22b5b3a60f18f6f42bbe7cb8faa24845dd7b1e4e22190e77"
 dependencies = [
  "cc",
+ "cxx-build",
  "cxxbridge-cmd",
  "cxxbridge-flags",
  "cxxbridge-macro",
- "foldhash",
+ "foldhash 0.2.0",
  "link-cplusplus",
 ]
 
 [[package]]
 name = "cxx-build"
-version = "1.0.168"
+version = "1.0.185"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12d3cbb84fb003242941c231b45ca9417e786e66e94baa39584bd99df3a270b6"
+checksum = "5edd58bf75c3fdfc80d79806403af626570662f7b6cc782a7fabe156166bd6d6"
 dependencies = [
  "cc",
  "codespan-reporting",
@@ -966,9 +967,9 @@ dependencies = [
 
 [[package]]
 name = "cxxbridge-cmd"
-version = "1.0.168"
+version = "1.0.185"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fa36b7b249d43f67a3f54bd65788e35e7afe64bbc671396387a48b3e8aaea94"
+checksum = "fd46bf2b541a4e0c2d5abba76607379ee05d68e714868e3cb406dc8d591ce2d2"
 dependencies = [
  "clap",
  "codespan-reporting",
@@ -980,15 +981,15 @@ dependencies = [
 
 [[package]]
 name = "cxxbridge-flags"
-version = "1.0.168"
+version = "1.0.185"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77707c70f6563edc5429618ca34a07241b75ebab35bd01d46697c75d58f8ddfe"
+checksum = "2c79b68f6a3a8f809d39b38ae8af61305a6113819b19b262643b9c21353b92d9"
 
 [[package]]
 name = "cxxbridge-macro"
-version = "1.0.168"
+version = "1.0.185"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ede6c0fb7e318f0a11799b86ee29dcf17b9be2960bd379a6c38e1a96a6010fff"
+checksum = "862b7fdb048ff9ef0779a0d0a03affd09746c4c875543746b640756be9cff2af"
 dependencies = [
  "indexmap",
  "proc-macro2",
@@ -1388,6 +1389,12 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
 
+[[package]]
+name = "foldhash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+
 [[package]]
 name = "form_urlencoded"
 version = "1.2.1"
@@ -1567,7 +1574,7 @@ checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
 dependencies = [
  "allocator-api2",
  "equivalent",
- "foldhash",
+ "foldhash 0.1.5",
  "serde",
 ]
 
@@ -2160,9 +2167,9 @@ dependencies = [
 
 [[package]]
 name = "link-cplusplus"
-version = "1.0.10"
+version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a6f6da007f968f9def0d65a05b187e2960183de70c160204ecfccf0ee330212"
+checksum = "7f78c730aaa7d0b9336a299029ea49f9ee53b0ed06e9202e8cb7db9bae7b8c82"
 dependencies = [
  "cc",
 ]

From a08e6499e6a215021684681448ed0f3ce60c827a Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Tue, 16 Sep 2025 15:18:42 +0200
Subject: [PATCH 1106/1889] move `mod canonical` out of `eval_ctxt`

---
 .../src/{ => canonical}/canonicalizer.rs      |   0
 .../canonical.rs => canonical/mod.rs}         | 226 ++----------------
 compiler/rustc_next_trait_solver/src/lib.rs   |   2 +-
 .../src/solve/eval_ctxt/mod.rs                | 202 +++++++++++++++-
 .../src/solve/inspect/build.rs                |   2 +-
 .../src/solve/inspect/mod.rs                  |   2 -
 .../rustc_next_trait_solver/src/solve/mod.rs  |  19 --
 .../src/solve/search_graph.rs                 |   3 +-
 .../src/solve/inspect/analyse.rs              |   4 +-
 9 files changed, 229 insertions(+), 231 deletions(-)
 rename compiler/rustc_next_trait_solver/src/{ => canonical}/canonicalizer.rs (100%)
 rename compiler/rustc_next_trait_solver/src/{solve/eval_ctxt/canonical.rs => canonical/mod.rs} (58%)

diff --git a/compiler/rustc_next_trait_solver/src/canonicalizer.rs b/compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs
similarity index 100%
rename from compiler/rustc_next_trait_solver/src/canonicalizer.rs
rename to compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs b/compiler/rustc_next_trait_solver/src/canonical/mod.rs
similarity index 58%
rename from compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs
rename to compiler/rustc_next_trait_solver/src/canonical/mod.rs
index 889588afe61ff..35881acf0c753 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs
+++ b/compiler/rustc_next_trait_solver/src/canonical/mod.rs
@@ -11,27 +11,25 @@
 
 use std::iter;
 
+use canonicalizer::Canonicalizer;
 use rustc_index::IndexVec;
-use rustc_type_ir::data_structures::HashSet;
 use rustc_type_ir::inherent::*;
 use rustc_type_ir::relate::solver_relating::RelateExt;
-use rustc_type_ir::solve::OpaqueTypesJank;
 use rustc_type_ir::{
     self as ty, Canonical, CanonicalVarKind, CanonicalVarValues, InferCtxtLike, Interner,
     TypeFoldable,
 };
-use tracing::{debug, instrument, trace};
+use tracing::instrument;
 
-use crate::canonicalizer::Canonicalizer;
 use crate::delegate::SolverDelegate;
 use crate::resolve::eager_resolve_vars;
-use crate::solve::eval_ctxt::CurrentGoalKind;
 use crate::solve::{
     CanonicalInput, CanonicalResponse, Certainty, EvalCtxt, ExternalConstraintsData, Goal,
-    MaybeCause, NestedNormalizationGoals, NoSolution, PredefinedOpaquesData, QueryInput,
-    QueryResult, Response, inspect, response_no_constraints_raw,
+    NestedNormalizationGoals, PredefinedOpaquesData, QueryInput, Response, inspect,
 };
 
+pub mod canonicalizer;
+
 trait ResponseT<I: Interner> {
     fn var_values(&self) -> CanonicalVarValues<I>;
 }
@@ -78,199 +76,6 @@ where
         (orig_values, query_input)
     }
 
-    /// To return the constraints of a canonical query to the caller, we canonicalize:
-    ///
-    /// - `var_values`: a map from bound variables in the canonical goal to
-    ///   the values inferred while solving the instantiated goal.
-    /// - `external_constraints`: additional constraints which aren't expressible
-    ///   using simple unification of inference variables.
-    ///
-    /// This takes the `shallow_certainty` which represents whether we're confident
-    /// that the final result of the current goal only depends on the nested goals.
-    ///
-    /// In case this is `Certainty::Maybe`, there may still be additional nested goals
-    /// or inference constraints required for this candidate to be hold. The candidate
-    /// always requires all already added constraints and nested goals.
-    #[instrument(level = "trace", skip(self), ret)]
-    pub(in crate::solve) fn evaluate_added_goals_and_make_canonical_response(
-        &mut self,
-        shallow_certainty: Certainty,
-    ) -> QueryResult<I> {
-        self.inspect.make_canonical_response(shallow_certainty);
-
-        let goals_certainty = self.try_evaluate_added_goals()?;
-        assert_eq!(
-            self.tainted,
-            Ok(()),
-            "EvalCtxt is tainted -- nested goals may have been dropped in a \
-            previous call to `try_evaluate_added_goals!`"
-        );
-
-        // We only check for leaks from universes which were entered inside
-        // of the query.
-        self.delegate.leak_check(self.max_input_universe).map_err(|NoSolution| {
-            trace!("failed the leak check");
-            NoSolution
-        })?;
-
-        let (certainty, normalization_nested_goals) =
-            match (self.current_goal_kind, shallow_certainty) {
-                // When normalizing, we've replaced the expected term with an unconstrained
-                // inference variable. This means that we dropped information which could
-                // have been important. We handle this by instead returning the nested goals
-                // to the caller, where they are then handled. We only do so if we do not
-                // need to recompute the `NormalizesTo` goal afterwards to avoid repeatedly
-                // uplifting its nested goals. This is the case if the `shallow_certainty` is
-                // `Certainty::Yes`.
-                (CurrentGoalKind::NormalizesTo, Certainty::Yes) => {
-                    let goals = std::mem::take(&mut self.nested_goals);
-                    // As we return all ambiguous nested goals, we can ignore the certainty
-                    // returned by `self.try_evaluate_added_goals()`.
-                    if goals.is_empty() {
-                        assert!(matches!(goals_certainty, Certainty::Yes));
-                    }
-                    (
-                        Certainty::Yes,
-                        NestedNormalizationGoals(
-                            goals.into_iter().map(|(s, g, _)| (s, g)).collect(),
-                        ),
-                    )
-                }
-                _ => {
-                    let certainty = shallow_certainty.and(goals_certainty);
-                    (certainty, NestedNormalizationGoals::empty())
-                }
-            };
-
-        if let Certainty::Maybe {
-            cause: cause @ MaybeCause::Overflow { keep_constraints: false, .. },
-            opaque_types_jank,
-        } = certainty
-        {
-            // If we have overflow, it's probable that we're substituting a type
-            // into itself infinitely and any partial substitutions in the query
-            // response are probably not useful anyways, so just return an empty
-            // query response.
-            //
-            // This may prevent us from potentially useful inference, e.g.
-            // 2 candidates, one ambiguous and one overflow, which both
-            // have the same inference constraints.
-            //
-            // Changing this to retain some constraints in the future
-            // won't be a breaking change, so this is good enough for now.
-            return Ok(self.make_ambiguous_response_no_constraints(cause, opaque_types_jank));
-        }
-
-        let external_constraints =
-            self.compute_external_query_constraints(certainty, normalization_nested_goals);
-        let (var_values, mut external_constraints) =
-            eager_resolve_vars(self.delegate, (self.var_values, external_constraints));
-
-        // Remove any trivial or duplicated region constraints once we've resolved regions
-        let mut unique = HashSet::default();
-        external_constraints.region_constraints.retain(|outlives| {
-            outlives.0.as_region().is_none_or(|re| re != outlives.1) && unique.insert(*outlives)
-        });
-
-        let canonical = Canonicalizer::canonicalize_response(
-            self.delegate,
-            self.max_input_universe,
-            &mut Default::default(),
-            Response {
-                var_values,
-                certainty,
-                external_constraints: self.cx().mk_external_constraints(external_constraints),
-            },
-        );
-
-        // HACK: We bail with overflow if the response would have too many non-region
-        // inference variables. This tends to only happen if we encounter a lot of
-        // ambiguous alias types which get replaced with fresh inference variables
-        // during generalization. This prevents hangs caused by an exponential blowup,
-        // see tests/ui/traits/next-solver/coherence-alias-hang.rs.
-        match self.current_goal_kind {
-            // We don't do so for `NormalizesTo` goals as we erased the expected term and
-            // bailing with overflow here would prevent us from detecting a type-mismatch,
-            // causing a coherence error in diesel, see #131969. We still bail with overflow
-            // when later returning from the parent AliasRelate goal.
-            CurrentGoalKind::NormalizesTo => {}
-            CurrentGoalKind::Misc | CurrentGoalKind::CoinductiveTrait => {
-                let num_non_region_vars = canonical
-                    .variables
-                    .iter()
-                    .filter(|c| !c.is_region() && c.is_existential())
-                    .count();
-                if num_non_region_vars > self.cx().recursion_limit() {
-                    debug!(?num_non_region_vars, "too many inference variables -> overflow");
-                    return Ok(self.make_ambiguous_response_no_constraints(
-                        MaybeCause::Overflow {
-                            suggest_increasing_limit: true,
-                            keep_constraints: false,
-                        },
-                        OpaqueTypesJank::AllGood,
-                    ));
-                }
-            }
-        }
-
-        Ok(canonical)
-    }
-
-    /// Constructs a totally unconstrained, ambiguous response to a goal.
-    ///
-    /// Take care when using this, since often it's useful to respond with
-    /// ambiguity but return constrained variables to guide inference.
-    pub(in crate::solve) fn make_ambiguous_response_no_constraints(
-        &self,
-        cause: MaybeCause,
-        opaque_types_jank: OpaqueTypesJank,
-    ) -> CanonicalResponse<I> {
-        response_no_constraints_raw(
-            self.cx(),
-            self.max_input_universe,
-            self.variables,
-            Certainty::Maybe { cause, opaque_types_jank },
-        )
-    }
-
-    /// Computes the region constraints and *new* opaque types registered when
-    /// proving a goal.
-    ///
-    /// If an opaque was already constrained before proving this goal, then the
-    /// external constraints do not need to record that opaque, since if it is
-    /// further constrained by inference, that will be passed back in the var
-    /// values.
-    #[instrument(level = "trace", skip(self), ret)]
-    fn compute_external_query_constraints(
-        &self,
-        certainty: Certainty,
-        normalization_nested_goals: NestedNormalizationGoals<I>,
-    ) -> ExternalConstraintsData<I> {
-        // We only return region constraints once the certainty is `Yes`. This
-        // is necessary as we may drop nested goals on ambiguity, which may result
-        // in unconstrained inference variables in the region constraints. It also
-        // prevents us from emitting duplicate region constraints, avoiding some
-        // unnecessary work. This slightly weakens the leak check in case it uses
-        // region constraints from an ambiguous nested goal. This is tested in both
-        // `tests/ui/higher-ranked/leak-check/leak-check-in-selection-5-ambig.rs` and
-        // `tests/ui/higher-ranked/leak-check/leak-check-in-selection-6-ambig-unify.rs`.
-        let region_constraints = if certainty == Certainty::Yes {
-            self.delegate.make_deduplicated_outlives_constraints()
-        } else {
-            Default::default()
-        };
-
-        // We only return *newly defined* opaque types from canonical queries.
-        //
-        // Constraints for any existing opaque types are already tracked by changes
-        // to the `var_values`.
-        let opaque_types = self
-            .delegate
-            .clone_opaque_types_added_since(self.initial_opaque_types_storage_num_entries);
-
-        ExternalConstraintsData { region_constraints, opaque_types, normalization_nested_goals }
-    }
-
     /// After calling a canonical query, we apply the constraints returned
     /// by the query using this function.
     ///
@@ -469,7 +274,7 @@ where
 /// evaluating a goal. The `var_values` not only include the bound variables
 /// of the query input, but also contain all unconstrained inference vars
 /// created while evaluating this goal.
-pub(in crate::solve) fn make_canonical_state<D, T, I>(
+pub fn make_canonical_state<D, T, I>(
     delegate: &D,
     var_values: &[I::GenericArg],
     max_input_universe: ty::UniverseIndex,
@@ -515,3 +320,22 @@ where
     EvalCtxt::unify_query_var_values(delegate, param_env, orig_values, var_values, span);
     data
 }
+
+pub fn response_no_constraints_raw<I: Interner>(
+    cx: I,
+    max_universe: ty::UniverseIndex,
+    variables: I::CanonicalVarKinds,
+    certainty: Certainty,
+) -> CanonicalResponse<I> {
+    ty::Canonical {
+        max_universe,
+        variables,
+        value: Response {
+            var_values: ty::CanonicalVarValues::make_identity(cx, variables),
+            // FIXME: maybe we should store the "no response" version in cx, like
+            // we do for cx.types and stuff.
+            external_constraints: cx.mk_external_constraints(ExternalConstraintsData::default()),
+            certainty,
+        },
+    }
+}
diff --git a/compiler/rustc_next_trait_solver/src/lib.rs b/compiler/rustc_next_trait_solver/src/lib.rs
index d3965e14c68a8..5fa29b7d9f813 100644
--- a/compiler/rustc_next_trait_solver/src/lib.rs
+++ b/compiler/rustc_next_trait_solver/src/lib.rs
@@ -10,7 +10,7 @@
 #![allow(rustc::usage_of_type_ir_traits)]
 // tidy-alphabetical-end
 
-pub mod canonicalizer;
+pub mod canonical;
 pub mod coherence;
 pub mod delegate;
 pub mod placeholder;
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
index 5df7c92d88145..8f9b68dbac4f4 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
@@ -17,6 +17,8 @@ use rustc_type_ir::{
 use tracing::{debug, instrument, trace};
 
 use super::has_only_region_constraints;
+use crate::canonical::canonicalizer::Canonicalizer;
+use crate::canonical::response_no_constraints_raw;
 use crate::coherence;
 use crate::delegate::SolverDelegate;
 use crate::placeholder::BoundVarReplacer;
@@ -24,12 +26,11 @@ use crate::resolve::eager_resolve_vars;
 use crate::solve::search_graph::SearchGraph;
 use crate::solve::ty::may_use_unstable_feature;
 use crate::solve::{
-    CanonicalInput, Certainty, FIXPOINT_STEP_LIMIT, Goal, GoalEvaluation, GoalSource,
-    GoalStalledOn, HasChanged, NestedNormalizationGoals, NoSolution, QueryInput, QueryResult,
-    inspect,
+    CanonicalInput, CanonicalResponse, Certainty, ExternalConstraintsData, FIXPOINT_STEP_LIMIT,
+    Goal, GoalEvaluation, GoalSource, GoalStalledOn, HasChanged, MaybeCause,
+    NestedNormalizationGoals, NoSolution, QueryInput, QueryResult, Response, inspect,
 };
 
-pub(super) mod canonical;
 mod probe;
 
 /// The kind of goal we're currently proving.
@@ -1223,6 +1224,199 @@ where
             vec![]
         }
     }
+
+    /// To return the constraints of a canonical query to the caller, we canonicalize:
+    ///
+    /// - `var_values`: a map from bound variables in the canonical goal to
+    ///   the values inferred while solving the instantiated goal.
+    /// - `external_constraints`: additional constraints which aren't expressible
+    ///   using simple unification of inference variables.
+    ///
+    /// This takes the `shallow_certainty` which represents whether we're confident
+    /// that the final result of the current goal only depends on the nested goals.
+    ///
+    /// In case this is `Certainty::Maybe`, there may still be additional nested goals
+    /// or inference constraints required for this candidate to be hold. The candidate
+    /// always requires all already added constraints and nested goals.
+    #[instrument(level = "trace", skip(self), ret)]
+    pub(in crate::solve) fn evaluate_added_goals_and_make_canonical_response(
+        &mut self,
+        shallow_certainty: Certainty,
+    ) -> QueryResult<I> {
+        self.inspect.make_canonical_response(shallow_certainty);
+
+        let goals_certainty = self.try_evaluate_added_goals()?;
+        assert_eq!(
+            self.tainted,
+            Ok(()),
+            "EvalCtxt is tainted -- nested goals may have been dropped in a \
+            previous call to `try_evaluate_added_goals!`"
+        );
+
+        // We only check for leaks from universes which were entered inside
+        // of the query.
+        self.delegate.leak_check(self.max_input_universe).map_err(|NoSolution| {
+            trace!("failed the leak check");
+            NoSolution
+        })?;
+
+        let (certainty, normalization_nested_goals) =
+            match (self.current_goal_kind, shallow_certainty) {
+                // When normalizing, we've replaced the expected term with an unconstrained
+                // inference variable. This means that we dropped information which could
+                // have been important. We handle this by instead returning the nested goals
+                // to the caller, where they are then handled. We only do so if we do not
+                // need to recompute the `NormalizesTo` goal afterwards to avoid repeatedly
+                // uplifting its nested goals. This is the case if the `shallow_certainty` is
+                // `Certainty::Yes`.
+                (CurrentGoalKind::NormalizesTo, Certainty::Yes) => {
+                    let goals = std::mem::take(&mut self.nested_goals);
+                    // As we return all ambiguous nested goals, we can ignore the certainty
+                    // returned by `self.try_evaluate_added_goals()`.
+                    if goals.is_empty() {
+                        assert!(matches!(goals_certainty, Certainty::Yes));
+                    }
+                    (
+                        Certainty::Yes,
+                        NestedNormalizationGoals(
+                            goals.into_iter().map(|(s, g, _)| (s, g)).collect(),
+                        ),
+                    )
+                }
+                _ => {
+                    let certainty = shallow_certainty.and(goals_certainty);
+                    (certainty, NestedNormalizationGoals::empty())
+                }
+            };
+
+        if let Certainty::Maybe {
+            cause: cause @ MaybeCause::Overflow { keep_constraints: false, .. },
+            opaque_types_jank,
+        } = certainty
+        {
+            // If we have overflow, it's probable that we're substituting a type
+            // into itself infinitely and any partial substitutions in the query
+            // response are probably not useful anyways, so just return an empty
+            // query response.
+            //
+            // This may prevent us from potentially useful inference, e.g.
+            // 2 candidates, one ambiguous and one overflow, which both
+            // have the same inference constraints.
+            //
+            // Changing this to retain some constraints in the future
+            // won't be a breaking change, so this is good enough for now.
+            return Ok(self.make_ambiguous_response_no_constraints(cause, opaque_types_jank));
+        }
+
+        let external_constraints =
+            self.compute_external_query_constraints(certainty, normalization_nested_goals);
+        let (var_values, mut external_constraints) =
+            eager_resolve_vars(self.delegate, (self.var_values, external_constraints));
+
+        // Remove any trivial or duplicated region constraints once we've resolved regions
+        let mut unique = HashSet::default();
+        external_constraints.region_constraints.retain(|outlives| {
+            outlives.0.as_region().is_none_or(|re| re != outlives.1) && unique.insert(*outlives)
+        });
+
+        let canonical = Canonicalizer::canonicalize_response(
+            self.delegate,
+            self.max_input_universe,
+            &mut Default::default(),
+            Response {
+                var_values,
+                certainty,
+                external_constraints: self.cx().mk_external_constraints(external_constraints),
+            },
+        );
+
+        // HACK: We bail with overflow if the response would have too many non-region
+        // inference variables. This tends to only happen if we encounter a lot of
+        // ambiguous alias types which get replaced with fresh inference variables
+        // during generalization. This prevents hangs caused by an exponential blowup,
+        // see tests/ui/traits/next-solver/coherence-alias-hang.rs.
+        match self.current_goal_kind {
+            // We don't do so for `NormalizesTo` goals as we erased the expected term and
+            // bailing with overflow here would prevent us from detecting a type-mismatch,
+            // causing a coherence error in diesel, see #131969. We still bail with overflow
+            // when later returning from the parent AliasRelate goal.
+            CurrentGoalKind::NormalizesTo => {}
+            CurrentGoalKind::Misc | CurrentGoalKind::CoinductiveTrait => {
+                let num_non_region_vars = canonical
+                    .variables
+                    .iter()
+                    .filter(|c| !c.is_region() && c.is_existential())
+                    .count();
+                if num_non_region_vars > self.cx().recursion_limit() {
+                    debug!(?num_non_region_vars, "too many inference variables -> overflow");
+                    return Ok(self.make_ambiguous_response_no_constraints(
+                        MaybeCause::Overflow {
+                            suggest_increasing_limit: true,
+                            keep_constraints: false,
+                        },
+                        OpaqueTypesJank::AllGood,
+                    ));
+                }
+            }
+        }
+
+        Ok(canonical)
+    }
+
+    /// Constructs a totally unconstrained, ambiguous response to a goal.
+    ///
+    /// Take care when using this, since often it's useful to respond with
+    /// ambiguity but return constrained variables to guide inference.
+    pub(in crate::solve) fn make_ambiguous_response_no_constraints(
+        &self,
+        cause: MaybeCause,
+        opaque_types_jank: OpaqueTypesJank,
+    ) -> CanonicalResponse<I> {
+        response_no_constraints_raw(
+            self.cx(),
+            self.max_input_universe,
+            self.variables,
+            Certainty::Maybe { cause, opaque_types_jank },
+        )
+    }
+
+    /// Computes the region constraints and *new* opaque types registered when
+    /// proving a goal.
+    ///
+    /// If an opaque was already constrained before proving this goal, then the
+    /// external constraints do not need to record that opaque, since if it is
+    /// further constrained by inference, that will be passed back in the var
+    /// values.
+    #[instrument(level = "trace", skip(self), ret)]
+    fn compute_external_query_constraints(
+        &self,
+        certainty: Certainty,
+        normalization_nested_goals: NestedNormalizationGoals<I>,
+    ) -> ExternalConstraintsData<I> {
+        // We only return region constraints once the certainty is `Yes`. This
+        // is necessary as we may drop nested goals on ambiguity, which may result
+        // in unconstrained inference variables in the region constraints. It also
+        // prevents us from emitting duplicate region constraints, avoiding some
+        // unnecessary work. This slightly weakens the leak check in case it uses
+        // region constraints from an ambiguous nested goal. This is tested in both
+        // `tests/ui/higher-ranked/leak-check/leak-check-in-selection-5-ambig.rs` and
+        // `tests/ui/higher-ranked/leak-check/leak-check-in-selection-6-ambig-unify.rs`.
+        let region_constraints = if certainty == Certainty::Yes {
+            self.delegate.make_deduplicated_outlives_constraints()
+        } else {
+            Default::default()
+        };
+
+        // We only return *newly defined* opaque types from canonical queries.
+        //
+        // Constraints for any existing opaque types are already tracked by changes
+        // to the `var_values`.
+        let opaque_types = self
+            .delegate
+            .clone_opaque_types_added_since(self.initial_opaque_types_storage_num_entries);
+
+        ExternalConstraintsData { region_constraints, opaque_types, normalization_nested_goals }
+    }
 }
 
 /// Eagerly replace aliases with inference variables, emitting `AliasRelate`
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 2675ed0d0da65..4369148baf91d 100644
--- a/compiler/rustc_next_trait_solver/src/solve/inspect/build.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/inspect/build.rs
@@ -10,8 +10,8 @@ use derive_where::derive_where;
 use rustc_type_ir::inherent::*;
 use rustc_type_ir::{self as ty, Interner};
 
+use crate::canonical;
 use crate::delegate::SolverDelegate;
-use crate::solve::eval_ctxt::canonical;
 use crate::solve::{Certainty, Goal, GoalSource, QueryResult, inspect};
 
 /// We need to know whether to build a prove tree while evaluating. We
diff --git a/compiler/rustc_next_trait_solver/src/solve/inspect/mod.rs b/compiler/rustc_next_trait_solver/src/solve/inspect/mod.rs
index 0d8c00601269b..65f32f1947fef 100644
--- a/compiler/rustc_next_trait_solver/src/solve/inspect/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/inspect/mod.rs
@@ -2,5 +2,3 @@ pub use rustc_type_ir::solve::inspect::*;
 
 mod build;
 pub(in crate::solve) use build::*;
-
-pub use crate::solve::eval_ctxt::canonical::instantiate_canonical_state;
diff --git a/compiler/rustc_next_trait_solver/src/solve/mod.rs b/compiler/rustc_next_trait_solver/src/solve/mod.rs
index fb900b592d13b..afb86aaf8ab21 100644
--- a/compiler/rustc_next_trait_solver/src/solve/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/mod.rs
@@ -380,25 +380,6 @@ where
     }
 }
 
-fn response_no_constraints_raw<I: Interner>(
-    cx: I,
-    max_universe: ty::UniverseIndex,
-    variables: I::CanonicalVarKinds,
-    certainty: Certainty,
-) -> CanonicalResponse<I> {
-    ty::Canonical {
-        max_universe,
-        variables,
-        value: Response {
-            var_values: ty::CanonicalVarValues::make_identity(cx, variables),
-            // FIXME: maybe we should store the "no response" version in cx, like
-            // we do for cx.types and stuff.
-            external_constraints: cx.mk_external_constraints(ExternalConstraintsData::default()),
-            certainty,
-        },
-    }
-}
-
 /// The result of evaluating a goal.
 pub struct GoalEvaluation<I: Interner> {
     /// The goal we've evaluated. This is the input goal, but potentially with its
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 289325d70550c..aa9dfc9a9a265 100644
--- a/compiler/rustc_next_trait_solver/src/solve/search_graph.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/search_graph.rs
@@ -6,6 +6,7 @@ use rustc_type_ir::search_graph::{self, PathKind};
 use rustc_type_ir::solve::{CanonicalInput, Certainty, NoSolution, QueryResult};
 use rustc_type_ir::{Interner, TypingMode};
 
+use crate::canonical::response_no_constraints_raw;
 use crate::delegate::SolverDelegate;
 use crate::solve::{
     EvalCtxt, FIXPOINT_STEP_LIMIT, has_no_inference_or_external_constraints, inspect,
@@ -127,7 +128,7 @@ fn response_no_constraints<I: Interner>(
     input: CanonicalInput<I>,
     certainty: Certainty,
 ) -> QueryResult<I> {
-    Ok(super::response_no_constraints_raw(
+    Ok(response_no_constraints_raw(
         cx,
         input.canonical.max_universe,
         input.canonical.variables,
diff --git a/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs b/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs
index 086a7a44786d6..c010add0fc50f 100644
--- a/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs
+++ b/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs
@@ -18,9 +18,9 @@ use rustc_middle::traits::ObligationCause;
 use rustc_middle::traits::solve::{Certainty, Goal, GoalSource, NoSolution, QueryResult};
 use rustc_middle::ty::{TyCtxt, VisitorResult, try_visit};
 use rustc_middle::{bug, ty};
+use rustc_next_trait_solver::canonical::instantiate_canonical_state;
 use rustc_next_trait_solver::resolve::eager_resolve_vars;
-use rustc_next_trait_solver::solve::inspect::{self, instantiate_canonical_state};
-use rustc_next_trait_solver::solve::{MaybeCause, SolverDelegateEvalExt as _};
+use rustc_next_trait_solver::solve::{MaybeCause, SolverDelegateEvalExt as _, inspect};
 use rustc_span::Span;
 use tracing::instrument;
 

From b83c0f0e94592d1a7eae1124e4e951f331ccf6c8 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Tue, 16 Sep 2025 15:30:25 +0200
Subject: [PATCH 1107/1889] canonical: yeet `EvalCtxt`, mk `Canonicalizer`
 private

---
 .../src/canonical/canonicalizer.rs            |   7 +-
 .../src/canonical/mod.rs                      | 419 +++++++++---------
 .../src/solve/eval_ctxt/mod.rs                |  18 +-
 3 files changed, 233 insertions(+), 211 deletions(-)

diff --git a/compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs b/compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs
index 4b4ec4956eb88..b25671d676b9c 100644
--- a/compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs
+++ b/compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs
@@ -57,7 +57,7 @@ enum CanonicalizeMode {
     },
 }
 
-pub struct Canonicalizer<'a, D: SolverDelegate<Interner = I>, I: Interner> {
+pub(super) struct Canonicalizer<'a, D: SolverDelegate<Interner = I>, I: Interner> {
     delegate: &'a D,
 
     // Immutable field.
@@ -83,7 +83,7 @@ pub struct Canonicalizer<'a, D: SolverDelegate<Interner = I>, I: Interner> {
 }
 
 impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
-    pub fn canonicalize_response<T: TypeFoldable<I>>(
+    pub(super) fn canonicalize_response<T: TypeFoldable<I>>(
         delegate: &'a D,
         max_input_universe: ty::UniverseIndex,
         variables: &'a mut Vec<I::GenericArg>,
@@ -112,7 +112,6 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
         let (max_universe, variables) = canonicalizer.finalize();
         Canonical { max_universe, variables, value }
     }
-
     fn canonicalize_param_env(
         delegate: &'a D,
         variables: &'a mut Vec<I::GenericArg>,
@@ -195,7 +194,7 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
     ///
     /// We want to keep the option of canonicalizing `'static` to an existential
     /// variable in the future by changing the way we detect global where-bounds.
-    pub fn canonicalize_input<P: TypeFoldable<I>>(
+    pub(super) fn canonicalize_input<P: TypeFoldable<I>>(
         delegate: &'a D,
         variables: &'a mut Vec<I::GenericArg>,
         input: QueryInput<I, P>,
diff --git a/compiler/rustc_next_trait_solver/src/canonical/mod.rs b/compiler/rustc_next_trait_solver/src/canonical/mod.rs
index 35881acf0c753..e3520e238ed37 100644
--- a/compiler/rustc_next_trait_solver/src/canonical/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/canonical/mod.rs
@@ -24,7 +24,7 @@ use tracing::instrument;
 use crate::delegate::SolverDelegate;
 use crate::resolve::eager_resolve_vars;
 use crate::solve::{
-    CanonicalInput, CanonicalResponse, Certainty, EvalCtxt, ExternalConstraintsData, Goal,
+    CanonicalInput, CanonicalResponse, Certainty, ExternalConstraintsData, Goal,
     NestedNormalizationGoals, PredefinedOpaquesData, QueryInput, Response, inspect,
 };
 
@@ -46,226 +46,248 @@ impl<I: Interner, T> ResponseT<I> for inspect::State<I, T> {
     }
 }
 
-impl<D, I> EvalCtxt<'_, D>
+/// Canonicalizes the goal remembering the original values
+/// for each bound variable.
+///
+/// This expects `goal` and `opaque_types` to be eager resolved.
+pub(super) fn canonicalize_goal<D, I>(
+    delegate: &D,
+    goal: Goal<I, I::Predicate>,
+    opaque_types: Vec<(ty::OpaqueTypeKey<I>, I::Ty)>,
+) -> (Vec<I::GenericArg>, CanonicalInput<I, I::Predicate>)
 where
     D: SolverDelegate<Interner = I>,
     I: Interner,
 {
-    /// Canonicalizes the goal remembering the original values
-    /// for each bound variable.
-    ///
-    /// This expects `goal` and `opaque_types` to be eager resolved.
-    pub(super) fn canonicalize_goal(
-        delegate: &D,
-        goal: Goal<I, I::Predicate>,
-        opaque_types: Vec<(ty::OpaqueTypeKey<I>, I::Ty)>,
-    ) -> (Vec<I::GenericArg>, CanonicalInput<I, I::Predicate>) {
-        let mut orig_values = Default::default();
-        let canonical = Canonicalizer::canonicalize_input(
-            delegate,
-            &mut orig_values,
-            QueryInput {
-                goal,
-                predefined_opaques_in_body: delegate
-                    .cx()
-                    .mk_predefined_opaques_in_body(PredefinedOpaquesData { opaque_types }),
-            },
-        );
-        let query_input =
-            ty::CanonicalQueryInput { canonical, typing_mode: delegate.typing_mode() };
-        (orig_values, query_input)
-    }
+    let mut orig_values = Default::default();
+    let canonical = Canonicalizer::canonicalize_input(
+        delegate,
+        &mut orig_values,
+        QueryInput {
+            goal,
+            predefined_opaques_in_body: delegate
+                .cx()
+                .mk_predefined_opaques_in_body(PredefinedOpaquesData { opaque_types }),
+        },
+    );
+    let query_input = ty::CanonicalQueryInput { canonical, typing_mode: delegate.typing_mode() };
+    (orig_values, query_input)
+}
 
-    /// After calling a canonical query, we apply the constraints returned
-    /// by the query using this function.
-    ///
-    /// This happens in three steps:
-    /// - we instantiate the bound variables of the query response
-    /// - we unify the `var_values` of the response with the `original_values`
-    /// - we apply the `external_constraints` returned by the query, returning
-    ///   the `normalization_nested_goals`
-    pub(super) fn instantiate_and_apply_query_response(
-        delegate: &D,
-        param_env: I::ParamEnv,
-        original_values: &[I::GenericArg],
-        response: CanonicalResponse<I>,
-        span: I::Span,
-    ) -> (NestedNormalizationGoals<I>, Certainty) {
-        let instantiation = Self::compute_query_response_instantiation_values(
-            delegate,
-            &original_values,
-            &response,
-            span,
-        );
+pub(super) fn canonicalize_response<D, I, T>(
+    delegate: &D,
+    max_input_universe: ty::UniverseIndex,
+    value: T,
+) -> ty::Canonical<I, T>
+where
+    D: SolverDelegate<Interner = I>,
+    I: Interner,
+    T: TypeFoldable<I>,
+{
+    let mut orig_values = Default::default();
+    let canonical =
+        Canonicalizer::canonicalize_response(delegate, max_input_universe, &mut orig_values, value);
+    canonical
+}
 
-        let Response { var_values, external_constraints, certainty } =
-            delegate.instantiate_canonical(response, instantiation);
+/// After calling a canonical query, we apply the constraints returned
+/// by the query using this function.
+///
+/// This happens in three steps:
+/// - we instantiate the bound variables of the query response
+/// - we unify the `var_values` of the response with the `original_values`
+/// - we apply the `external_constraints` returned by the query, returning
+///   the `normalization_nested_goals`
+pub(super) fn instantiate_and_apply_query_response<D, I>(
+    delegate: &D,
+    param_env: I::ParamEnv,
+    original_values: &[I::GenericArg],
+    response: CanonicalResponse<I>,
+    span: I::Span,
+) -> (NestedNormalizationGoals<I>, Certainty)
+where
+    D: SolverDelegate<Interner = I>,
+    I: Interner,
+{
+    let instantiation =
+        compute_query_response_instantiation_values(delegate, &original_values, &response, span);
 
-        Self::unify_query_var_values(delegate, param_env, &original_values, var_values, span);
+    let Response { var_values, external_constraints, certainty } =
+        delegate.instantiate_canonical(response, instantiation);
 
-        let ExternalConstraintsData {
-            region_constraints,
-            opaque_types,
-            normalization_nested_goals,
-        } = &*external_constraints;
+    unify_query_var_values(delegate, param_env, &original_values, var_values, span);
 
-        Self::register_region_constraints(delegate, region_constraints, span);
-        Self::register_new_opaque_types(delegate, opaque_types, span);
+    let ExternalConstraintsData { region_constraints, opaque_types, normalization_nested_goals } =
+        &*external_constraints;
 
-        (normalization_nested_goals.clone(), certainty)
-    }
+    register_region_constraints(delegate, region_constraints, span);
+    register_new_opaque_types(delegate, opaque_types, span);
 
-    /// This returns the canonical variable values to instantiate the bound variables of
-    /// the canonical response. This depends on the `original_values` for the
-    /// bound variables.
-    fn compute_query_response_instantiation_values<T: ResponseT<I>>(
-        delegate: &D,
-        original_values: &[I::GenericArg],
-        response: &Canonical<I, T>,
-        span: I::Span,
-    ) -> CanonicalVarValues<I> {
-        // FIXME: Longterm canonical queries should deal with all placeholders
-        // created inside of the query directly instead of returning them to the
-        // caller.
-        let prev_universe = delegate.universe();
-        let universes_created_in_query = response.max_universe.index();
-        for _ in 0..universes_created_in_query {
-            delegate.create_next_universe();
-        }
+    (normalization_nested_goals.clone(), certainty)
+}
+
+/// This returns the canonical variable values to instantiate the bound variables of
+/// the canonical response. This depends on the `original_values` for the
+/// bound variables.
+fn compute_query_response_instantiation_values<D, I, T>(
+    delegate: &D,
+    original_values: &[I::GenericArg],
+    response: &Canonical<I, T>,
+    span: I::Span,
+) -> CanonicalVarValues<I>
+where
+    D: SolverDelegate<Interner = I>,
+    I: Interner,
+    T: ResponseT<I>,
+{
+    // FIXME: Longterm canonical queries should deal with all placeholders
+    // created inside of the query directly instead of returning them to the
+    // caller.
+    let prev_universe = delegate.universe();
+    let universes_created_in_query = response.max_universe.index();
+    for _ in 0..universes_created_in_query {
+        delegate.create_next_universe();
+    }
 
-        let var_values = response.value.var_values();
-        assert_eq!(original_values.len(), var_values.len());
+    let var_values = response.value.var_values();
+    assert_eq!(original_values.len(), var_values.len());
 
-        // If the query did not make progress with constraining inference variables,
-        // we would normally create a new inference variables for bound existential variables
-        // only then unify this new inference variable with the inference variable from
-        // the input.
-        //
-        // We therefore instantiate the existential variable in the canonical response with the
-        // inference variable of the input right away, which is more performant.
-        let mut opt_values = IndexVec::from_elem_n(None, response.variables.len());
-        for (original_value, result_value) in
-            iter::zip(original_values, var_values.var_values.iter())
-        {
-            match result_value.kind() {
-                ty::GenericArgKind::Type(t) => {
-                    // We disable the instantiation guess for inference variables
-                    // and only use it for placeholders. We need to handle the
-                    // `sub_root` of type inference variables which would make this
-                    // more involved. They are also a lot rarer than region variables.
-                    if let ty::Bound(debruijn, b) = t.kind()
-                        && !matches!(
-                            response.variables.get(b.var().as_usize()).unwrap(),
-                            CanonicalVarKind::Ty { .. }
-                        )
-                    {
-                        assert_eq!(debruijn, ty::INNERMOST);
-                        opt_values[b.var()] = Some(*original_value);
-                    }
+    // If the query did not make progress with constraining inference variables,
+    // we would normally create a new inference variables for bound existential variables
+    // only then unify this new inference variable with the inference variable from
+    // the input.
+    //
+    // We therefore instantiate the existential variable in the canonical response with the
+    // inference variable of the input right away, which is more performant.
+    let mut opt_values = IndexVec::from_elem_n(None, response.variables.len());
+    for (original_value, result_value) in iter::zip(original_values, var_values.var_values.iter()) {
+        match result_value.kind() {
+            ty::GenericArgKind::Type(t) => {
+                // We disable the instantiation guess for inference variables
+                // and only use it for placeholders. We need to handle the
+                // `sub_root` of type inference variables which would make this
+                // more involved. They are also a lot rarer than region variables.
+                if let ty::Bound(debruijn, b) = t.kind()
+                    && !matches!(
+                        response.variables.get(b.var().as_usize()).unwrap(),
+                        CanonicalVarKind::Ty { .. }
+                    )
+                {
+                    assert_eq!(debruijn, ty::INNERMOST);
+                    opt_values[b.var()] = Some(*original_value);
                 }
-                ty::GenericArgKind::Lifetime(r) => {
-                    if let ty::ReBound(debruijn, br) = r.kind() {
-                        assert_eq!(debruijn, ty::INNERMOST);
-                        opt_values[br.var()] = Some(*original_value);
-                    }
+            }
+            ty::GenericArgKind::Lifetime(r) => {
+                if let ty::ReBound(debruijn, br) = r.kind() {
+                    assert_eq!(debruijn, ty::INNERMOST);
+                    opt_values[br.var()] = Some(*original_value);
                 }
-                ty::GenericArgKind::Const(c) => {
-                    if let ty::ConstKind::Bound(debruijn, bv) = c.kind() {
-                        assert_eq!(debruijn, ty::INNERMOST);
-                        opt_values[bv.var()] = Some(*original_value);
-                    }
+            }
+            ty::GenericArgKind::Const(c) => {
+                if let ty::ConstKind::Bound(debruijn, bv) = c.kind() {
+                    assert_eq!(debruijn, ty::INNERMOST);
+                    opt_values[bv.var()] = Some(*original_value);
                 }
             }
         }
-        CanonicalVarValues::instantiate(delegate.cx(), response.variables, |var_values, kind| {
-            if kind.universe() != ty::UniverseIndex::ROOT {
-                // A variable from inside a binder of the query. While ideally these shouldn't
-                // exist at all (see the FIXME at the start of this method), we have to deal with
-                // them for now.
-                delegate.instantiate_canonical_var(kind, span, &var_values, |idx| {
-                    prev_universe + idx.index()
-                })
-            } else if kind.is_existential() {
-                // As an optimization we sometimes avoid creating a new inference variable here.
-                //
-                // All new inference variables we create start out in the current universe of the caller.
-                // This is conceptually wrong as these inference variables would be able to name
-                // more placeholders then they should be able to. However the inference variables have
-                // to "come from somewhere", so by equating them with the original values of the caller
-                // later on, we pull them down into their correct universe again.
-                if let Some(v) = opt_values[ty::BoundVar::from_usize(var_values.len())] {
-                    v
-                } else {
-                    delegate.instantiate_canonical_var(kind, span, &var_values, |_| prev_universe)
-                }
+    }
+    CanonicalVarValues::instantiate(delegate.cx(), response.variables, |var_values, kind| {
+        if kind.universe() != ty::UniverseIndex::ROOT {
+            // A variable from inside a binder of the query. While ideally these shouldn't
+            // exist at all (see the FIXME at the start of this method), we have to deal with
+            // them for now.
+            delegate.instantiate_canonical_var(kind, span, &var_values, |idx| {
+                prev_universe + idx.index()
+            })
+        } else if kind.is_existential() {
+            // As an optimization we sometimes avoid creating a new inference variable here.
+            //
+            // All new inference variables we create start out in the current universe of the caller.
+            // This is conceptually wrong as these inference variables would be able to name
+            // more placeholders then they should be able to. However the inference variables have
+            // to "come from somewhere", so by equating them with the original values of the caller
+            // later on, we pull them down into their correct universe again.
+            if let Some(v) = opt_values[ty::BoundVar::from_usize(var_values.len())] {
+                v
             } else {
-                // For placeholders which were already part of the input, we simply map this
-                // universal bound variable back the placeholder of the input.
-                original_values[kind.expect_placeholder_index()]
+                delegate.instantiate_canonical_var(kind, span, &var_values, |_| prev_universe)
             }
-        })
-    }
+        } else {
+            // For placeholders which were already part of the input, we simply map this
+            // universal bound variable back the placeholder of the input.
+            original_values[kind.expect_placeholder_index()]
+        }
+    })
+}
 
-    /// Unify the `original_values` with the `var_values` returned by the canonical query..
-    ///
-    /// This assumes that this unification will always succeed. This is the case when
-    /// applying a query response right away. However, calling a canonical query, doing any
-    /// other kind of trait solving, and only then instantiating the result of the query
-    /// can cause the instantiation to fail. This is not supported and we ICE in this case.
-    ///
-    /// We always structurally instantiate aliases. Relating aliases needs to be different
-    /// depending on whether the alias is *rigid* or not. We're only really able to tell
-    /// whether an alias is rigid by using the trait solver. When instantiating a response
-    /// from the solver we assume that the solver correctly handled aliases and therefore
-    /// always relate them structurally here.
-    #[instrument(level = "trace", skip(delegate))]
-    fn unify_query_var_values(
-        delegate: &D,
-        param_env: I::ParamEnv,
-        original_values: &[I::GenericArg],
-        var_values: CanonicalVarValues<I>,
-        span: I::Span,
-    ) {
-        assert_eq!(original_values.len(), var_values.len());
+/// Unify the `original_values` with the `var_values` returned by the canonical query..
+///
+/// This assumes that this unification will always succeed. This is the case when
+/// applying a query response right away. However, calling a canonical query, doing any
+/// other kind of trait solving, and only then instantiating the result of the query
+/// can cause the instantiation to fail. This is not supported and we ICE in this case.
+///
+/// We always structurally instantiate aliases. Relating aliases needs to be different
+/// depending on whether the alias is *rigid* or not. We're only really able to tell
+/// whether an alias is rigid by using the trait solver. When instantiating a response
+/// from the solver we assume that the solver correctly handled aliases and therefore
+/// always relate them structurally here.
+#[instrument(level = "trace", skip(delegate))]
+fn unify_query_var_values<D, I>(
+    delegate: &D,
+    param_env: I::ParamEnv,
+    original_values: &[I::GenericArg],
+    var_values: CanonicalVarValues<I>,
+    span: I::Span,
+) where
+    D: SolverDelegate<Interner = I>,
+    I: Interner,
+{
+    assert_eq!(original_values.len(), var_values.len());
 
-        for (&orig, response) in iter::zip(original_values, var_values.var_values.iter()) {
-            let goals =
-                delegate.eq_structurally_relating_aliases(param_env, orig, response, span).unwrap();
-            assert!(goals.is_empty());
-        }
+    for (&orig, response) in iter::zip(original_values, var_values.var_values.iter()) {
+        let goals =
+            delegate.eq_structurally_relating_aliases(param_env, orig, response, span).unwrap();
+        assert!(goals.is_empty());
     }
+}
 
-    fn register_region_constraints(
-        delegate: &D,
-        outlives: &[ty::OutlivesPredicate<I, I::GenericArg>],
-        span: I::Span,
-    ) {
-        for &ty::OutlivesPredicate(lhs, rhs) in outlives {
-            match lhs.kind() {
-                ty::GenericArgKind::Lifetime(lhs) => delegate.sub_regions(rhs, lhs, span),
-                ty::GenericArgKind::Type(lhs) => delegate.register_ty_outlives(lhs, rhs, span),
-                ty::GenericArgKind::Const(_) => panic!("const outlives: {lhs:?}: {rhs:?}"),
-            }
+fn register_region_constraints<D, I>(
+    delegate: &D,
+    outlives: &[ty::OutlivesPredicate<I, I::GenericArg>],
+    span: I::Span,
+) where
+    D: SolverDelegate<Interner = I>,
+    I: Interner,
+{
+    for &ty::OutlivesPredicate(lhs, rhs) in outlives {
+        match lhs.kind() {
+            ty::GenericArgKind::Lifetime(lhs) => delegate.sub_regions(rhs, lhs, span),
+            ty::GenericArgKind::Type(lhs) => delegate.register_ty_outlives(lhs, rhs, span),
+            ty::GenericArgKind::Const(_) => panic!("const outlives: {lhs:?}: {rhs:?}"),
         }
     }
+}
 
-    fn register_new_opaque_types(
-        delegate: &D,
-        opaque_types: &[(ty::OpaqueTypeKey<I>, I::Ty)],
-        span: I::Span,
-    ) {
-        for &(key, ty) in opaque_types {
-            let prev = delegate.register_hidden_type_in_storage(key, ty, span);
-            // We eagerly resolve inference variables when computing the query response.
-            // This can cause previously distinct opaque type keys to now be structurally equal.
-            //
-            // To handle this, we store any duplicate entries in a separate list to check them
-            // at the end of typeck/borrowck. We could alternatively eagerly equate the hidden
-            // types here. However, doing so is difficult as it may result in nested goals and
-            // any errors may make it harder to track the control flow for diagnostics.
-            if let Some(prev) = prev {
-                delegate.add_duplicate_opaque_type(key, prev, span);
-            }
+fn register_new_opaque_types<D, I>(
+    delegate: &D,
+    opaque_types: &[(ty::OpaqueTypeKey<I>, I::Ty)],
+    span: I::Span,
+) where
+    D: SolverDelegate<Interner = I>,
+    I: Interner,
+{
+    for &(key, ty) in opaque_types {
+        let prev = delegate.register_hidden_type_in_storage(key, ty, span);
+        // We eagerly resolve inference variables when computing the query response.
+        // This can cause previously distinct opaque type keys to now be structurally equal.
+        //
+        // To handle this, we store any duplicate entries in a separate list to check them
+        // at the end of typeck/borrowck. We could alternatively eagerly equate the hidden
+        // types here. However, doing so is difficult as it may result in nested goals and
+        // any errors may make it harder to track the control flow for diagnostics.
+        if let Some(prev) = prev {
+            delegate.add_duplicate_opaque_type(key, prev, span);
         }
     }
 }
@@ -274,7 +296,7 @@ where
 /// evaluating a goal. The `var_values` not only include the bound variables
 /// of the query input, but also contain all unconstrained inference vars
 /// created while evaluating this goal.
-pub fn make_canonical_state<D, T, I>(
+pub fn make_canonical_state<D, I, T>(
     delegate: &D,
     var_values: &[I::GenericArg],
     max_input_universe: ty::UniverseIndex,
@@ -293,7 +315,7 @@ where
 
 // FIXME: needs to be pub to be accessed by downstream
 // `rustc_trait_selection::solve::inspect::analyse`.
-pub fn instantiate_canonical_state<D, I, T: TypeFoldable<I>>(
+pub fn instantiate_canonical_state<D, I, T>(
     delegate: &D,
     span: I::Span,
     param_env: I::ParamEnv,
@@ -303,6 +325,7 @@ pub fn instantiate_canonical_state<D, I, T: TypeFoldable<I>>(
 where
     D: SolverDelegate<Interner = I>,
     I: Interner,
+    T: TypeFoldable<I>,
 {
     // In case any fresh inference variables have been created between `state`
     // and the previous instantiation, extend `orig_values` for it.
@@ -313,11 +336,11 @@ where
     );
 
     let instantiation =
-        EvalCtxt::compute_query_response_instantiation_values(delegate, orig_values, &state, span);
+        compute_query_response_instantiation_values(delegate, orig_values, &state, span);
 
     let inspect::State { var_values, data } = delegate.instantiate_canonical(state, instantiation);
 
-    EvalCtxt::unify_query_var_values(delegate, param_env, orig_values, var_values, span);
+    unify_query_var_values(delegate, param_env, orig_values, var_values, span);
     data
 }
 
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
index 8f9b68dbac4f4..bb86357a85f8a 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
@@ -17,8 +17,10 @@ use rustc_type_ir::{
 use tracing::{debug, instrument, trace};
 
 use super::has_only_region_constraints;
-use crate::canonical::canonicalizer::Canonicalizer;
-use crate::canonical::response_no_constraints_raw;
+use crate::canonical::{
+    canonicalize_goal, canonicalize_response, instantiate_and_apply_query_response,
+    response_no_constraints_raw,
+};
 use crate::coherence;
 use crate::delegate::SolverDelegate;
 use crate::placeholder::BoundVarReplacer;
@@ -465,8 +467,7 @@ where
         let opaque_types = self.delegate.clone_opaque_types_lookup_table();
         let (goal, opaque_types) = eager_resolve_vars(self.delegate, (goal, opaque_types));
 
-        let (orig_values, canonical_goal) =
-            Self::canonicalize_goal(self.delegate, goal, opaque_types);
+        let (orig_values, canonical_goal) = canonicalize_goal(self.delegate, goal, opaque_types);
         let canonical_result = self.search_graph.evaluate_goal(
             self.cx(),
             canonical_goal,
@@ -481,7 +482,7 @@ where
         let has_changed =
             if !has_only_region_constraints(response) { HasChanged::Yes } else { HasChanged::No };
 
-        let (normalization_nested_goals, certainty) = Self::instantiate_and_apply_query_response(
+        let (normalization_nested_goals, certainty) = instantiate_and_apply_query_response(
             self.delegate,
             goal.param_env,
             &orig_values,
@@ -1319,10 +1320,9 @@ where
             outlives.0.as_region().is_none_or(|re| re != outlives.1) && unique.insert(*outlives)
         });
 
-        let canonical = Canonicalizer::canonicalize_response(
+        let canonical = canonicalize_response(
             self.delegate,
             self.max_input_universe,
-            &mut Default::default(),
             Response {
                 var_values,
                 certainty,
@@ -1557,7 +1557,7 @@ pub(super) fn evaluate_root_goal_for_proof_tree<D: SolverDelegate<Interner = I>,
     let opaque_types = delegate.clone_opaque_types_lookup_table();
     let (goal, opaque_types) = eager_resolve_vars(delegate, (goal, opaque_types));
 
-    let (orig_values, canonical_goal) = EvalCtxt::canonicalize_goal(delegate, goal, opaque_types);
+    let (orig_values, canonical_goal) = canonicalize_goal(delegate, goal, opaque_types);
 
     let (canonical_result, final_revision) =
         delegate.cx().evaluate_root_goal_for_proof_tree_raw(canonical_goal);
@@ -1574,7 +1574,7 @@ pub(super) fn evaluate_root_goal_for_proof_tree<D: SolverDelegate<Interner = I>,
         Ok(response) => response,
     };
 
-    let (normalization_nested_goals, _certainty) = EvalCtxt::instantiate_and_apply_query_response(
+    let (normalization_nested_goals, _certainty) = instantiate_and_apply_query_response(
         delegate,
         goal.param_env,
         &proof_tree.orig_values,

From 47d6936c7d37898a2de5549dcba8b50b25be21dd Mon Sep 17 00:00:00 2001
From: Oblarg <emichaelbrnett@gmail.com>
Date: Thu, 18 Sep 2025 18:15:19 -0400
Subject: [PATCH 1108/1889] fix negative const generic integer literals

---
 .../rust-analyzer/crates/hir-ty/src/lower.rs  | 23 +++++++++++++++++++
 .../crates/ide/src/hover/tests.rs             |  2 +-
 2 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
index 79f78c545e595..4d5172fd4f24f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
@@ -299,6 +299,29 @@ impl<'a> TyLoweringContext<'a> {
                 const_type,
                 self.resolver.krate(),
             ),
+            hir_def::hir::Expr::UnaryOp { expr: inner_expr, op: hir_def::hir::UnaryOp::Neg } => {
+                if let hir_def::hir::Expr::Literal(literal) = &self.store[*inner_expr] {
+                    // Only handle negation for signed integers and floats
+                    match literal {
+                        hir_def::hir::Literal::Int(_, _) | hir_def::hir::Literal::Float(_, _) => {
+                            if let Some(negated_literal) = literal.clone().negate() {
+                                intern_const_ref(
+                                    self.db,
+                                    &negated_literal.into(),
+                                    const_type,
+                                    self.resolver.krate(),
+                                )
+                            } else {
+                                unknown_const(const_type)
+                            }
+                        }
+                        // For unsigned integers, chars, bools, etc., negation is not meaningful
+                        _ => unknown_const(const_type),
+                    }
+                } else {
+                    unknown_const(const_type)
+                }
+            }
             _ => unknown_const(const_type),
         }
     }
diff --git a/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs b/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
index 45aec3877475e..1ea11a215f83d 100644
--- a/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
@@ -4738,7 +4738,7 @@ fn main() {
             *value*
 
             ```rust
-            let value: Const<_>
+            let value: Const<-1>
             ```
 
             ---

From 934ee043feb6601f9dfb5be173a190a921e6d9a9 Mon Sep 17 00:00:00 2001
From: Sidney Cammeresi <sac@cheesecake.org>
Date: Sun, 14 Sep 2025 11:14:50 -0700
Subject: [PATCH 1109/1889] Plumb Allocator generic into `std::vec::PeekMut`

---
 library/alloc/src/vec/mod.rs      | 54 +++++++++++++++----------------
 library/alloc/src/vec/peek_mut.rs | 22 ++++++++-----
 library/alloctests/tests/vec.rs   | 19 +++++------
 3 files changed, 51 insertions(+), 44 deletions(-)

diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs
index 2e40227a058af..1b80b43abc357 100644
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -760,33 +760,6 @@ impl<T> Vec<T> {
         unsafe { Self::from_parts_in(ptr, length, capacity, Global) }
     }
 
-    /// Returns a mutable reference to the last item in the vector, or
-    /// `None` if it is empty.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// #![feature(vec_peek_mut)]
-    /// let mut vec = Vec::new();
-    /// assert!(vec.peek_mut().is_none());
-    ///
-    /// vec.push(1);
-    /// vec.push(5);
-    /// vec.push(2);
-    /// assert_eq!(vec.last(), Some(&2));
-    /// if let Some(mut val) = vec.peek_mut() {
-    ///     *val = 0;
-    /// }
-    /// assert_eq!(vec.last(), Some(&0));
-    /// ```
-    #[inline]
-    #[unstable(feature = "vec_peek_mut", issue = "122742")]
-    pub fn peek_mut(&mut self) -> Option<PeekMut<'_, T>> {
-        PeekMut::new(self)
-    }
-
     /// Decomposes a `Vec<T>` into its raw components: `(pointer, length, capacity)`.
     ///
     /// Returns the raw pointer to the underlying data, the length of
@@ -2747,6 +2720,33 @@ impl<T, A: Allocator> Vec<T, A> {
         if predicate(last) { self.pop() } else { None }
     }
 
+    /// Returns a mutable reference to the last item in the vector, or
+    /// `None` if it is empty.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// #![feature(vec_peek_mut)]
+    /// let mut vec = Vec::new();
+    /// assert!(vec.peek_mut().is_none());
+    ///
+    /// vec.push(1);
+    /// vec.push(5);
+    /// vec.push(2);
+    /// assert_eq!(vec.last(), Some(&2));
+    /// if let Some(mut val) = vec.peek_mut() {
+    ///     *val = 0;
+    /// }
+    /// assert_eq!(vec.last(), Some(&0));
+    /// ```
+    #[inline]
+    #[unstable(feature = "vec_peek_mut", issue = "122742")]
+    pub fn peek_mut(&mut self) -> Option<PeekMut<'_, T, A>> {
+        PeekMut::new(self)
+    }
+
     /// Moves all the elements of `other` into `self`, leaving `other` empty.
     ///
     /// # Panics
diff --git a/library/alloc/src/vec/peek_mut.rs b/library/alloc/src/vec/peek_mut.rs
index caeaf2799d733..979bcaa1111d5 100644
--- a/library/alloc/src/vec/peek_mut.rs
+++ b/library/alloc/src/vec/peek_mut.rs
@@ -1,6 +1,7 @@
 use core::ops::{Deref, DerefMut};
 
 use super::Vec;
+use crate::alloc::{Allocator, Global};
 use crate::fmt;
 
 /// Structure wrapping a mutable reference to the last item in a
@@ -11,19 +12,23 @@ use crate::fmt;
 ///
 /// [`peek_mut`]: Vec::peek_mut
 #[unstable(feature = "vec_peek_mut", issue = "122742")]
-pub struct PeekMut<'a, T> {
-    vec: &'a mut Vec<T>,
+pub struct PeekMut<
+    'a,
+    T,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    vec: &'a mut Vec<T, A>,
 }
 
 #[unstable(feature = "vec_peek_mut", issue = "122742")]
-impl<T: fmt::Debug> fmt::Debug for PeekMut<'_, T> {
+impl<T: fmt::Debug, A: Allocator> fmt::Debug for PeekMut<'_, T, A> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_tuple("PeekMut").field(self.deref()).finish()
     }
 }
 
-impl<'a, T> PeekMut<'a, T> {
-    pub(crate) fn new(vec: &'a mut Vec<T>) -> Option<Self> {
+impl<'a, T, A: Allocator> PeekMut<'a, T, A> {
+    pub(super) fn new(vec: &'a mut Vec<T, A>) -> Option<Self> {
         if vec.is_empty() { None } else { Some(Self { vec }) }
     }
 
@@ -36,17 +41,18 @@ impl<'a, T> PeekMut<'a, T> {
 }
 
 #[unstable(feature = "vec_peek_mut", issue = "122742")]
-impl<'a, T> Deref for PeekMut<'a, T> {
+impl<'a, T, A: Allocator> Deref for PeekMut<'a, T, A> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
+        let idx = self.vec.len() - 1;
         // SAFETY: PeekMut is only constructed if the vec is non-empty
-        unsafe { self.vec.get_unchecked(self.vec.len() - 1) }
+        unsafe { self.vec.get_unchecked(idx) }
     }
 }
 
 #[unstable(feature = "vec_peek_mut", issue = "122742")]
-impl<'a, T> DerefMut for PeekMut<'a, T> {
+impl<'a, T, A: Allocator> DerefMut for PeekMut<'a, T, A> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         let idx = self.vec.len() - 1;
         // SAFETY: PeekMut is only constructed if the vec is non-empty
diff --git a/library/alloctests/tests/vec.rs b/library/alloctests/tests/vec.rs
index 404eb49e1ea9c..33a34daccbfd2 100644
--- a/library/alloctests/tests/vec.rs
+++ b/library/alloctests/tests/vec.rs
@@ -2643,15 +2643,16 @@ fn test_peek_mut() {
     assert!(vec.peek_mut().is_none());
     vec.push(1);
     vec.push(2);
-    if let Some(mut p) = vec.peek_mut() {
-        assert_eq!(*p, 2);
-        *p = 0;
-        assert_eq!(*p, 0);
-        PeekMut::pop(p);
-        assert_eq!(vec.len(), 1);
-    } else {
-        unreachable!()
-    }
+    let mut p = vec.peek_mut().unwrap();
+    assert_eq!(*p, 2);
+    *p = 0;
+    assert_eq!(*p, 0);
+    drop(p);
+    assert_eq!(vec, vec![1, 0]);
+    let p = vec.peek_mut().unwrap();
+    let p = PeekMut::pop(p);
+    assert_eq!(p, 0);
+    assert_eq!(vec, vec![1]);
 }
 
 /// This assortment of tests, in combination with miri, verifies we handle UB on fishy arguments

From 7ce81d145359aa230f8fc2d7de12650091508329 Mon Sep 17 00:00:00 2001
From: beepster4096 <19316085+beepster4096@users.noreply.github.com>
Date: Tue, 26 Aug 2025 01:12:20 -0700
Subject: [PATCH 1110/1889] deref related cleanups in ref_prop

---
 compiler/rustc_mir_transform/src/ref_prop.rs | 33 ++++++++------------
 1 file changed, 13 insertions(+), 20 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/ref_prop.rs b/compiler/rustc_mir_transform/src/ref_prop.rs
index 6f61215cee2d6..b9d6e74ecae89 100644
--- a/compiler/rustc_mir_transform/src/ref_prop.rs
+++ b/compiler/rustc_mir_transform/src/ref_prop.rs
@@ -195,10 +195,10 @@ fn compute_replacement<'tcx>(
     //   including DEF. This violates the DEF dominates USE condition, and so is impossible.
     let is_constant_place = |place: Place<'_>| {
         // We only allow `Deref` as the first projection, to avoid surprises.
-        if place.projection.first() == Some(&PlaceElem::Deref) {
+        if let Some((&PlaceElem::Deref, rest)) = place.projection.split_first() {
             // `place == (*some_local).xxx`, it is constant only if `some_local` is constant.
             // We approximate constness using SSAness.
-            ssa.is_ssa(place.local) && place.projection[1..].iter().all(PlaceElem::is_stable_offset)
+            ssa.is_ssa(place.local) && rest.iter().all(PlaceElem::is_stable_offset)
         } else {
             storage_live.has_single_storage(place.local)
                 && place.projection[..].iter().all(PlaceElem::is_stable_offset)
@@ -206,7 +206,7 @@ fn compute_replacement<'tcx>(
     };
 
     let mut can_perform_opt = |target: Place<'tcx>, loc: Location| {
-        if target.projection.first() == Some(&PlaceElem::Deref) {
+        if target.is_indirect_first_projection() {
             // We are creating a reborrow. As `place.local` is a reference, removing the storage
             // statements should not make it much harder for LLVM to optimize.
             storage_to_remove.insert(target.local);
@@ -266,7 +266,7 @@ fn compute_replacement<'tcx>(
             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)
+                if let Some((&PlaceElem::Deref, rest)) = place.projection.split_first()
                     && let Value::Pointer(target, inner_needs_unique) = targets[place.local]
                     // Only see through immutable reference and pointers, as we do not know yet if
                     // mutable references are fully replaced.
@@ -274,7 +274,7 @@ fn compute_replacement<'tcx>(
                     // Only collapse chain if the pointee is definitely live.
                     && can_perform_opt(target, location)
                 {
-                    place = target.project_deeper(&place.projection[1..], tcx);
+                    place = target.project_deeper(rest, tcx);
                 }
                 assert_ne!(place.local, local);
                 if is_constant_place(place) {
@@ -323,7 +323,7 @@ fn compute_replacement<'tcx>(
                 return;
             }
 
-            if place.projection.first() != Some(&PlaceElem::Deref) {
+            if !place.is_indirect_first_projection() {
                 // This is not a dereference, nothing to do.
                 return;
             }
@@ -392,20 +392,15 @@ impl<'tcx> MutVisitor<'tcx> for Replacer<'tcx> {
     }
 
     fn visit_var_debug_info(&mut self, debuginfo: &mut VarDebugInfo<'tcx>) {
-        // If the debuginfo is a pointer to another place:
-        // - if it's a reborrow, see through it;
-        // - if it's a direct borrow, increase `debuginfo.references`.
+        // If the debuginfo is a pointer to another place
+        // and it's a reborrow: see through it
         while let VarDebugInfoContents::Place(ref mut place) = debuginfo.value
             && place.projection.is_empty()
             && let Value::Pointer(target, _) = self.targets[place.local]
-            && target.projection.iter().all(|p| p.can_use_in_debuginfo())
+            && let &[PlaceElem::Deref] = &target.projection[..]
         {
-            if let Some((&PlaceElem::Deref, rest)) = target.projection.split_last() {
-                *place = Place::from(target.local).project_deeper(rest, self.tcx);
-                self.any_replacement = true;
-            } else {
-                break;
-            }
+            *place = Place::from(target.local);
+            self.any_replacement = true;
         }
 
         // Simplify eventual projections left inside `debuginfo`.
@@ -414,9 +409,7 @@ impl<'tcx> MutVisitor<'tcx> for Replacer<'tcx> {
 
     fn visit_place(&mut self, place: &mut Place<'tcx>, ctxt: PlaceContext, loc: Location) {
         loop {
-            if place.projection.first() != Some(&PlaceElem::Deref) {
-                return;
-            }
+            let Some((&PlaceElem::Deref, rest)) = place.projection.split_first() else { return };
 
             let Value::Pointer(target, _) = self.targets[place.local] else { return };
 
@@ -432,7 +425,7 @@ impl<'tcx> MutVisitor<'tcx> for Replacer<'tcx> {
                 return;
             }
 
-            *place = target.project_deeper(&place.projection[1..], self.tcx);
+            *place = target.project_deeper(rest, self.tcx);
             self.any_replacement = true;
         }
     }

From e1258e79d6cb709b26ded97d32de6c55f355e2aa Mon Sep 17 00:00:00 2001
From: Karan Janthe <karanjanthe@gmail.com>
Date: Sat, 23 Aug 2025 20:17:32 +0000
Subject: [PATCH 1111/1889] autodiff: Add basic TypeTree with NoTT flag

Signed-off-by: Karan Janthe <karanjanthe@gmail.com>
---
 .../rustc_ast/src/expand/autodiff_attrs.rs    | 17 +++-
 compiler/rustc_codegen_llvm/src/back/lto.rs   |  2 +
 compiler/rustc_interface/src/tests.rs         |  1 +
 compiler/rustc_middle/src/error.rs            |  1 -
 compiler/rustc_middle/src/ty/mod.rs           | 80 +++++++++++++++++++
 compiler/rustc_session/src/config.rs          |  2 +
 compiler/rustc_session/src/options.rs         |  3 +-
 tests/codegen-llvm/autodiff/typetree.rs       | 33 ++++++++
 .../autodiff/type-trees/nott-flag/nott.check  |  3 +
 .../autodiff/type-trees/nott-flag/rmake.rs    | 38 +++++++++
 .../autodiff/type-trees/nott-flag/test.rs     | 15 ++++
 .../type-trees/nott-flag/with_tt.check        |  3 +
 tests/ui/autodiff/flag_nott.rs                | 19 +++++
 13 files changed, 212 insertions(+), 5 deletions(-)
 create mode 100644 tests/codegen-llvm/autodiff/typetree.rs
 create mode 100644 tests/run-make/autodiff/type-trees/nott-flag/nott.check
 create mode 100644 tests/run-make/autodiff/type-trees/nott-flag/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/nott-flag/test.rs
 create mode 100644 tests/run-make/autodiff/type-trees/nott-flag/with_tt.check
 create mode 100644 tests/ui/autodiff/flag_nott.rs

diff --git a/compiler/rustc_ast/src/expand/autodiff_attrs.rs b/compiler/rustc_ast/src/expand/autodiff_attrs.rs
index 33451f9974835..90f15753e99c9 100644
--- a/compiler/rustc_ast/src/expand/autodiff_attrs.rs
+++ b/compiler/rustc_ast/src/expand/autodiff_attrs.rs
@@ -6,6 +6,7 @@
 use std::fmt::{self, Display, Formatter};
 use std::str::FromStr;
 
+use crate::expand::typetree::TypeTree;
 use crate::expand::{Decodable, Encodable, HashStable_Generic};
 use crate::{Ty, TyKind};
 
@@ -84,6 +85,8 @@ pub struct AutoDiffItem {
     /// The name of the function being generated
     pub target: String,
     pub attrs: AutoDiffAttrs,
+    pub inputs: Vec<TypeTree>,
+    pub output: TypeTree,
 }
 
 #[derive(Clone, Eq, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
@@ -275,14 +278,22 @@ impl AutoDiffAttrs {
         !matches!(self.mode, DiffMode::Error | DiffMode::Source)
     }
 
-    pub fn into_item(self, source: String, target: String) -> AutoDiffItem {
-        AutoDiffItem { source, target, attrs: self }
+    pub fn into_item(
+        self,
+        source: String,
+        target: String,
+        inputs: Vec<TypeTree>,
+        output: TypeTree,
+    ) -> AutoDiffItem {
+        AutoDiffItem { source, target, inputs, output, attrs: self }
     }
 }
 
 impl fmt::Display for AutoDiffItem {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "Differentiating {} -> {}", self.source, self.target)?;
-        write!(f, " with attributes: {:?}", self.attrs)
+        write!(f, " with attributes: {:?}", self.attrs)?;
+        write!(f, " with inputs: {:?}", self.inputs)?;
+        write!(f, " with output: {:?}", self.output)
     }
 }
diff --git a/compiler/rustc_codegen_llvm/src/back/lto.rs b/compiler/rustc_codegen_llvm/src/back/lto.rs
index 78107d95e5a70..5ac3a87c158e6 100644
--- a/compiler/rustc_codegen_llvm/src/back/lto.rs
+++ b/compiler/rustc_codegen_llvm/src/back/lto.rs
@@ -563,6 +563,8 @@ fn enable_autodiff_settings(ad: &[config::AutoDiff]) {
             config::AutoDiff::Enable => {}
             // We handle this below
             config::AutoDiff::NoPostopt => {}
+            // Disables TypeTree generation
+            config::AutoDiff::NoTT => {}
         }
     }
     // This helps with handling enums for now.
diff --git a/compiler/rustc_interface/src/tests.rs b/compiler/rustc_interface/src/tests.rs
index 7730bddc0f12d..837acdadd579d 100644
--- a/compiler/rustc_interface/src/tests.rs
+++ b/compiler/rustc_interface/src/tests.rs
@@ -766,6 +766,7 @@ fn test_unstable_options_tracking_hash() {
     tracked!(always_encode_mir, true);
     tracked!(assume_incomplete_release, true);
     tracked!(autodiff, vec![AutoDiff::Enable]);
+    tracked!(autodiff, vec![AutoDiff::Enable, AutoDiff::NoTT]);
     tracked!(binary_dep_depinfo, true);
     tracked!(box_noalias, false);
     tracked!(
diff --git a/compiler/rustc_middle/src/error.rs b/compiler/rustc_middle/src/error.rs
index e3e1393b5f9ae..ef014af7beb14 100644
--- a/compiler/rustc_middle/src/error.rs
+++ b/compiler/rustc_middle/src/error.rs
@@ -37,7 +37,6 @@ pub(crate) struct OpaqueHiddenTypeMismatch<'tcx> {
     pub sub: TypeMismatchReason,
 }
 
-// FIXME(autodiff): I should get used somewhere
 #[derive(Diagnostic)]
 #[diag(middle_unsupported_union)]
 pub struct UnsupportedUnion {
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 0ffef393a33bd..df42c40031752 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -25,6 +25,7 @@ pub use generic_args::{GenericArgKind, TermKind, *};
 pub use generics::*;
 pub use intrinsic::IntrinsicDef;
 use rustc_abi::{Align, FieldIdx, Integer, IntegerType, ReprFlags, ReprOptions, VariantIdx};
+use rustc_ast::expand::typetree::{FncTree, Kind, Type, TypeTree};
 use rustc_ast::node_id::NodeMap;
 pub use rustc_ast_ir::{Movability, Mutability, try_visit};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap, FxIndexSet};
@@ -2216,3 +2217,82 @@ pub struct DestructuredConst<'tcx> {
     pub variant: Option<VariantIdx>,
     pub fields: &'tcx [ty::Const<'tcx>],
 }
+
+/// Generate TypeTree information for autodiff.
+/// This function creates TypeTree metadata that describes the memory layout
+/// of function parameters and return types for Enzyme autodiff.
+pub fn fnc_typetrees<'tcx>(tcx: TyCtxt<'tcx>, fn_ty: Ty<'tcx>) -> FncTree {
+    // Check if TypeTrees are disabled via NoTT flag
+    if tcx.sess.opts.unstable_opts.autodiff.contains(&rustc_session::config::AutoDiff::NoTT) {
+        return FncTree { args: vec![], ret: TypeTree::new() };
+    }
+
+    // Check if this is actually a function type
+    if !fn_ty.is_fn() {
+        return FncTree { args: vec![], ret: TypeTree::new() };
+    }
+
+    // Get the function signature
+    let fn_sig = fn_ty.fn_sig(tcx);
+    let sig = tcx.instantiate_bound_regions_with_erased(fn_sig);
+
+    // Create TypeTrees for each input parameter
+    let mut args = vec![];
+    for ty in sig.inputs().iter() {
+        let type_tree = typetree_from_ty(tcx, *ty);
+        args.push(type_tree);
+    }
+
+    // Create TypeTree for return type
+    let ret = typetree_from_ty(tcx, sig.output());
+
+    FncTree { args, ret }
+}
+
+/// Generate TypeTree for a specific type.
+/// This function analyzes a Rust type and creates appropriate TypeTree metadata.
+fn typetree_from_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> TypeTree {
+    // Handle basic scalar types
+    if ty.is_scalar() {
+        let (kind, size) = if ty.is_integral() || ty.is_char() || ty.is_bool() {
+            (Kind::Integer, ty.primitive_size(tcx).bytes_usize())
+        } else if ty.is_floating_point() {
+            match ty {
+                x if x == tcx.types.f32 => (Kind::Float, 4),
+                x if x == tcx.types.f64 => (Kind::Double, 8),
+                _ => return TypeTree::new(), // Unknown float type
+            }
+        } else {
+            // TODO(KMJ-007): Handle other scalar types if needed
+            return TypeTree::new();
+        };
+        
+        return TypeTree(vec![Type { 
+            offset: -1, 
+            size, 
+            kind, 
+            child: TypeTree::new() 
+        }]);
+    }
+
+    // Handle references and pointers
+    if ty.is_ref() || ty.is_raw_ptr() || ty.is_box() {
+        let inner_ty = if let Some(inner) = ty.builtin_deref(true) {
+            inner
+        } else {
+            // TODO(KMJ-007): Handle complex pointer types
+            return TypeTree::new();
+        };
+
+        let child = typetree_from_ty(tcx, inner_ty);
+        return TypeTree(vec![Type {
+            offset: -1,
+            size: 8, // TODO(KMJ-007): Get actual pointer size from target
+            kind: Kind::Pointer,
+            child,
+        }]);
+    }
+
+    // TODO(KMJ-007): Handle arrays, slices, structs, and other complex types
+    TypeTree::new()
+}
diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs
index 297df7c2c9765..3a035fcf9e896 100644
--- a/compiler/rustc_session/src/config.rs
+++ b/compiler/rustc_session/src/config.rs
@@ -257,6 +257,8 @@ pub enum AutoDiff {
     LooseTypes,
     /// Runs Enzyme's aggressive inlining
     Inline,
+    /// Disable Type Tree
+    NoTT,
 }
 
 /// Settings for `-Z instrument-xray` flag.
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
index 69facde693689..ee53dd39bc887 100644
--- a/compiler/rustc_session/src/options.rs
+++ b/compiler/rustc_session/src/options.rs
@@ -792,7 +792,7 @@ mod desc {
     pub(crate) const parse_list: &str = "a space-separated list of strings";
     pub(crate) const parse_list_with_polarity: &str =
         "a comma-separated list of strings, with elements beginning with + or -";
-    pub(crate) const parse_autodiff: &str = "a comma separated list of settings: `Enable`, `PrintSteps`, `PrintTA`, `PrintTAFn`, `PrintAA`, `PrintPerf`, `PrintModBefore`, `PrintModAfter`, `PrintModFinal`, `PrintPasses`, `NoPostopt`, `LooseTypes`, `Inline`";
+    pub(crate) const parse_autodiff: &str = "a comma separated list of settings: `Enable`, `PrintSteps`, `PrintTA`, `PrintTAFn`, `PrintAA`, `PrintPerf`, `PrintModBefore`, `PrintModAfter`, `PrintModFinal`, `PrintPasses`, `NoPostopt`, `LooseTypes`, `Inline`, `NoTT`";
     pub(crate) const parse_offload: &str = "a comma separated list of settings: `Enable`";
     pub(crate) const parse_comma_list: &str = "a comma-separated list of strings";
     pub(crate) const parse_opt_comma_list: &str = parse_comma_list;
@@ -1479,6 +1479,7 @@ pub mod parse {
                 "PrintPasses" => AutoDiff::PrintPasses,
                 "LooseTypes" => AutoDiff::LooseTypes,
                 "Inline" => AutoDiff::Inline,
+                "NoTT" => AutoDiff::NoTT,
                 _ => {
                     // FIXME(ZuseZ4): print an error saying which value is not recognized
                     return false;
diff --git a/tests/codegen-llvm/autodiff/typetree.rs b/tests/codegen-llvm/autodiff/typetree.rs
new file mode 100644
index 0000000000000..3ad38d581b9a1
--- /dev/null
+++ b/tests/codegen-llvm/autodiff/typetree.rs
@@ -0,0 +1,33 @@
+//@ compile-flags: -Zautodiff=Enable -C opt-level=3 -Clto=fat
+//@ no-prefer-dynamic
+//@ needs-enzyme
+
+// Test that basic autodiff still works with our TypeTree infrastructure
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_simple, Duplicated, Active)]
+#[no_mangle]
+#[inline(never)]
+fn simple(x: &f64) -> f64 {
+    2.0 * x
+}
+
+// CHECK-LABEL: @simple
+// CHECK: fmul double
+
+// The derivative function should be generated normally
+// CHECK-LABEL: diffesimple
+// CHECK: fadd fast double
+
+fn main() {
+    let x = std::hint::black_box(3.0);
+    let output = simple(&x);
+    assert_eq!(6.0, output);
+
+    let mut df_dx = 0.0;
+    let output_ = d_simple(&x, &mut df_dx, 1.0);
+    assert_eq!(output, output_);
+    assert_eq!(2.0, df_dx);
+}
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/nott-flag/nott.check b/tests/run-make/autodiff/type-trees/nott-flag/nott.check
new file mode 100644
index 0000000000000..56ef2f0bdf380
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/nott-flag/nott.check
@@ -0,0 +1,3 @@
+// TODO(KMJ-007): Update this test when TypeTree integration is complete
+// CHECK: square - {[-1]:Float@double} |{[-1]:Pointer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@double}
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/nott-flag/rmake.rs b/tests/run-make/autodiff/type-trees/nott-flag/rmake.rs
new file mode 100644
index 0000000000000..536164192dc06
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/nott-flag/rmake.rs
@@ -0,0 +1,38 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Test with NoTT flag - should not generate TypeTree metadata
+    let output_nott = rustc()
+        .input("test.rs")
+        .arg("-Zautodiff=Enable,NoTT,PrintTAFn=square")
+        .arg("-Zautodiff=NoPostopt")
+        .opt_level("3")
+        .arg("-Clto=fat")
+        .arg("-g")
+        .run();
+
+    // Write output for NoTT case
+    rfs::write("nott.stdout", output_nott.stdout_utf8());
+    
+    // Test without NoTT flag - should generate TypeTree metadata
+    let output_with_tt = rustc()
+        .input("test.rs")
+        .arg("-Zautodiff=Enable,PrintTAFn=square")
+        .arg("-Zautodiff=NoPostopt")
+        .opt_level("3")
+        .arg("-Clto=fat")
+        .arg("-g")
+        .run();
+
+    // Write output for TypeTree case  
+    rfs::write("with_tt.stdout", output_with_tt.stdout_utf8());
+
+    // Verify NoTT output has minimal TypeTree info
+    llvm_filecheck().patterns("nott.check").stdin_buf(rfs::read("nott.stdout")).run();
+    
+    // Verify normal output will have TypeTree info (once implemented)
+    llvm_filecheck().patterns("with_tt.check").stdin_buf(rfs::read("with_tt.stdout")).run();
+}
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/nott-flag/test.rs b/tests/run-make/autodiff/type-trees/nott-flag/test.rs
new file mode 100644
index 0000000000000..5c634eea035d9
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/nott-flag/test.rs
@@ -0,0 +1,15 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_square, Duplicated, Active)]
+#[no_mangle]
+fn square(x: &f64) -> f64 {
+    x * x
+}
+
+fn main() {
+    let x = 2.0;
+    let mut dx = 0.0;
+    let _result = d_square(&x, &mut dx, 1.0);
+}
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/nott-flag/with_tt.check b/tests/run-make/autodiff/type-trees/nott-flag/with_tt.check
new file mode 100644
index 0000000000000..56ef2f0bdf380
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/nott-flag/with_tt.check
@@ -0,0 +1,3 @@
+// TODO(KMJ-007): Update this test when TypeTree integration is complete
+// CHECK: square - {[-1]:Float@double} |{[-1]:Pointer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@double}
\ No newline at end of file
diff --git a/tests/ui/autodiff/flag_nott.rs b/tests/ui/autodiff/flag_nott.rs
new file mode 100644
index 0000000000000..7a97d892cd881
--- /dev/null
+++ b/tests/ui/autodiff/flag_nott.rs
@@ -0,0 +1,19 @@
+//@ compile-flags: -Zautodiff=Enable,NoTT
+//@ needs-enzyme
+//@ check-pass
+
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+// Test that NoTT flag is accepted and doesn't cause compilation errors
+#[autodiff_reverse(d_square, Duplicated, Active)]
+fn square(x: &f64) -> f64 {
+    x * x
+}
+
+fn main() {
+    let x = 2.0;
+    let mut dx = 0.0;
+    let result = d_square(&x, &mut dx, 1.0);
+}
\ No newline at end of file

From 375e14ef491ac7bfa701e269b2815625abf2fca6 Mon Sep 17 00:00:00 2001
From: Karan Janthe <karanjanthe@gmail.com>
Date: Sat, 23 Aug 2025 21:56:56 +0000
Subject: [PATCH 1112/1889] Add TypeTree metadata attachment for autodiff

  - Add F128 support to TypeTree Kind enum
  - Implement TypeTree FFI bindings and conversion functions
  - Add typetree.rs module for metadata attachment to LLVM functions
  - Integrate TypeTree generation with autodiff intrinsic pipeline
  - Support scalar types: f32, f64, integers, f16, f128
  - Attach enzyme_type attributes as LLVM string metadata for Enzyme

Signed-off-by: Karan Janthe <karanjanthe@gmail.com>
---
 compiler/rustc_ast/src/expand/typetree.rs     |   1 +
 .../src/builder/autodiff.rs                   |   6 +
 compiler/rustc_codegen_llvm/src/intrinsic.rs  |   4 +
 compiler/rustc_codegen_llvm/src/lib.rs        |   1 +
 .../rustc_codegen_llvm/src/llvm/enzyme_ffi.rs | 182 +++++++++++++++++-
 compiler/rustc_codegen_llvm/src/typetree.rs   | 144 ++++++++++++++
 compiler/rustc_middle/src/ty/mod.rs           |  19 +-
 7 files changed, 343 insertions(+), 14 deletions(-)
 create mode 100644 compiler/rustc_codegen_llvm/src/typetree.rs

diff --git a/compiler/rustc_ast/src/expand/typetree.rs b/compiler/rustc_ast/src/expand/typetree.rs
index 9a2dd2e85e0d6..e7b4f3aff413a 100644
--- a/compiler/rustc_ast/src/expand/typetree.rs
+++ b/compiler/rustc_ast/src/expand/typetree.rs
@@ -31,6 +31,7 @@ pub enum Kind {
     Half,
     Float,
     Double,
+    F128,
     Unknown,
 }
 
diff --git a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
index b66e3dfdeec29..c3485f563916f 100644
--- a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
+++ b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
@@ -1,6 +1,7 @@
 use std::ptr;
 
 use rustc_ast::expand::autodiff_attrs::{AutoDiffAttrs, DiffActivity, DiffMode};
+use rustc_ast::expand::typetree::FncTree;
 use rustc_codegen_ssa::common::TypeKind;
 use rustc_codegen_ssa::traits::{BaseTypeCodegenMethods, BuilderMethods};
 use rustc_middle::ty::{Instance, PseudoCanonicalInput, TyCtxt, TypingEnv};
@@ -294,6 +295,7 @@ pub(crate) fn generate_enzyme_call<'ll, 'tcx>(
     fn_args: &[&'ll Value],
     attrs: AutoDiffAttrs,
     dest: PlaceRef<'tcx, &'ll Value>,
+    fnc_tree: FncTree,
 ) {
     // We have to pick the name depending on whether we want forward or reverse mode autodiff.
     let mut ad_name: String = match attrs.mode {
@@ -370,6 +372,10 @@ pub(crate) fn generate_enzyme_call<'ll, 'tcx>(
         fn_args,
     );
 
+    if !fnc_tree.args.is_empty() || !fnc_tree.ret.0.is_empty() {
+        crate::typetree::add_tt(cx.llmod, cx.llcx, fn_to_diff, fnc_tree);
+    }
+
     let call = builder.call(enzyme_ty, None, None, ad_fn, &args, None, None);
 
     builder.store_to_place(call, dest.val);
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
index e7f4a3570488e..3254b31865197 100644
--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -1213,6 +1213,9 @@ fn codegen_autodiff<'ll, 'tcx>(
         &mut diff_attrs.input_activity,
     );
 
+    let fnc_tree =
+        rustc_middle::ty::fnc_typetrees(tcx, fn_source.ty(tcx, TypingEnv::fully_monomorphized()));
+
     // Build body
     generate_enzyme_call(
         bx,
@@ -1223,6 +1226,7 @@ fn codegen_autodiff<'ll, 'tcx>(
         &val_arr,
         diff_attrs.clone(),
         result,
+        fnc_tree,
     );
 }
 
diff --git a/compiler/rustc_codegen_llvm/src/lib.rs b/compiler/rustc_codegen_llvm/src/lib.rs
index 6fb23d0984335..a5ac789285d47 100644
--- a/compiler/rustc_codegen_llvm/src/lib.rs
+++ b/compiler/rustc_codegen_llvm/src/lib.rs
@@ -67,6 +67,7 @@ mod llvm_util;
 mod mono_item;
 mod type_;
 mod type_of;
+mod typetree;
 mod va_arg;
 mod value;
 
diff --git a/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
index 695435eb6daa7..12b6ffa3c0b5f 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
@@ -3,9 +3,35 @@
 use libc::{c_char, c_uint};
 
 use super::MetadataKindId;
-use super::ffi::{AttributeKind, BasicBlock, Metadata, Module, Type, Value};
+use super::ffi::{AttributeKind, BasicBlock, Context, Metadata, Module, Type, Value};
 use crate::llvm::{Bool, Builder};
 
+// TypeTree types
+pub(crate) type CTypeTreeRef = *mut EnzymeTypeTree;
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub(crate) struct EnzymeTypeTree {
+    _unused: [u8; 0],
+}
+
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+#[allow(non_camel_case_types)]
+pub(crate) enum CConcreteType {
+    DT_Anything = 0,
+    DT_Integer = 1,
+    DT_Pointer = 2,
+    DT_Half = 3,
+    DT_Float = 4,
+    DT_Double = 5,
+    DT_Unknown = 6,
+}
+
+pub(crate) struct TypeTree {
+    pub(crate) inner: CTypeTreeRef,
+}
+
 #[link(name = "llvm-wrapper", kind = "static")]
 unsafe extern "C" {
     // Enzyme
@@ -68,10 +94,33 @@ pub(crate) mod Enzyme_AD {
 
     use libc::c_void;
 
+    use super::{CConcreteType, CTypeTreeRef, Context};
+
     unsafe extern "C" {
         pub(crate) fn EnzymeSetCLBool(arg1: *mut ::std::os::raw::c_void, arg2: u8);
         pub(crate) fn EnzymeSetCLString(arg1: *mut ::std::os::raw::c_void, arg2: *const c_char);
     }
+
+    // TypeTree functions
+    unsafe extern "C" {
+        pub(crate) fn EnzymeNewTypeTree() -> CTypeTreeRef;
+        pub(crate) fn EnzymeNewTypeTreeCT(arg1: CConcreteType, ctx: &Context) -> CTypeTreeRef;
+        pub(crate) fn EnzymeNewTypeTreeTR(arg1: CTypeTreeRef) -> CTypeTreeRef;
+        pub(crate) fn EnzymeFreeTypeTree(CTT: CTypeTreeRef);
+        pub(crate) fn EnzymeMergeTypeTree(arg1: CTypeTreeRef, arg2: CTypeTreeRef) -> bool;
+        pub(crate) fn EnzymeTypeTreeOnlyEq(arg1: CTypeTreeRef, pos: i64);
+        pub(crate) fn EnzymeTypeTreeData0Eq(arg1: CTypeTreeRef);
+        pub(crate) fn EnzymeTypeTreeShiftIndiciesEq(
+            arg1: CTypeTreeRef,
+            data_layout: *const c_char,
+            offset: i64,
+            max_size: i64,
+            add_offset: u64,
+        );
+        pub(crate) fn EnzymeTypeTreeToString(arg1: CTypeTreeRef) -> *const c_char;
+        pub(crate) fn EnzymeTypeTreeToStringFree(arg1: *const c_char);
+    }
+
     unsafe extern "C" {
         static mut EnzymePrintPerf: c_void;
         static mut EnzymePrintActivity: c_void;
@@ -141,6 +190,57 @@ pub(crate) use self::Fallback_AD::*;
 pub(crate) mod Fallback_AD {
     #![allow(unused_variables)]
 
+    use libc::c_char;
+
+    use super::{CConcreteType, CTypeTreeRef, Context};
+
+    // TypeTree function fallbacks
+    pub(crate) unsafe fn EnzymeNewTypeTree() -> CTypeTreeRef {
+        unimplemented!()
+    }
+
+    pub(crate) unsafe fn EnzymeNewTypeTreeCT(arg1: CConcreteType, ctx: &Context) -> CTypeTreeRef {
+        unimplemented!()
+    }
+
+    pub(crate) unsafe fn EnzymeNewTypeTreeTR(arg1: CTypeTreeRef) -> CTypeTreeRef {
+        unimplemented!()
+    }
+
+    pub(crate) unsafe fn EnzymeFreeTypeTree(CTT: CTypeTreeRef) {
+        unimplemented!()
+    }
+
+    pub(crate) unsafe fn EnzymeMergeTypeTree(arg1: CTypeTreeRef, arg2: CTypeTreeRef) -> bool {
+        unimplemented!()
+    }
+
+    pub(crate) unsafe fn EnzymeTypeTreeOnlyEq(arg1: CTypeTreeRef, pos: i64) {
+        unimplemented!()
+    }
+
+    pub(crate) unsafe fn EnzymeTypeTreeData0Eq(arg1: CTypeTreeRef) {
+        unimplemented!()
+    }
+
+    pub(crate) unsafe fn EnzymeTypeTreeShiftIndiciesEq(
+        arg1: CTypeTreeRef,
+        data_layout: *const c_char,
+        offset: i64,
+        max_size: i64,
+        add_offset: u64,
+    ) {
+        unimplemented!()
+    }
+
+    pub(crate) unsafe fn EnzymeTypeTreeToString(arg1: CTypeTreeRef) -> *const c_char {
+        unimplemented!()
+    }
+
+    pub(crate) unsafe fn EnzymeTypeTreeToStringFree(arg1: *const c_char) {
+        unimplemented!()
+    }
+
     pub(crate) fn set_inline(val: bool) {
         unimplemented!()
     }
@@ -169,3 +269,83 @@ pub(crate) mod Fallback_AD {
         unimplemented!()
     }
 }
+
+impl TypeTree {
+    pub(crate) fn new() -> TypeTree {
+        let inner = unsafe { EnzymeNewTypeTree() };
+        TypeTree { inner }
+    }
+
+    pub(crate) fn from_type(t: CConcreteType, ctx: &Context) -> TypeTree {
+        let inner = unsafe { EnzymeNewTypeTreeCT(t, ctx) };
+        TypeTree { inner }
+    }
+
+    pub(crate) fn merge(self, other: Self) -> Self {
+        unsafe {
+            EnzymeMergeTypeTree(self.inner, other.inner);
+        }
+        drop(other);
+        self
+    }
+
+    #[must_use]
+    pub(crate) fn shift(
+        self,
+        layout: &str,
+        offset: isize,
+        max_size: isize,
+        add_offset: usize,
+    ) -> Self {
+        let layout = std::ffi::CString::new(layout).unwrap();
+
+        unsafe {
+            EnzymeTypeTreeShiftIndiciesEq(
+                self.inner,
+                layout.as_ptr(),
+                offset as i64,
+                max_size as i64,
+                add_offset as u64,
+            );
+        }
+
+        self
+    }
+}
+
+impl Clone for TypeTree {
+    fn clone(&self) -> Self {
+        let inner = unsafe { EnzymeNewTypeTreeTR(self.inner) };
+        TypeTree { inner }
+    }
+}
+
+impl std::fmt::Display for TypeTree {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let ptr = unsafe { EnzymeTypeTreeToString(self.inner) };
+        let cstr = unsafe { std::ffi::CStr::from_ptr(ptr) };
+        match cstr.to_str() {
+            Ok(x) => write!(f, "{}", x)?,
+            Err(err) => write!(f, "could not parse: {}", err)?,
+        }
+
+        // delete C string pointer
+        unsafe {
+            EnzymeTypeTreeToStringFree(ptr);
+        }
+
+        Ok(())
+    }
+}
+
+impl std::fmt::Debug for TypeTree {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        <Self as std::fmt::Display>::fmt(self, f)
+    }
+}
+
+impl Drop for TypeTree {
+    fn drop(&mut self) {
+        unsafe { EnzymeFreeTypeTree(self.inner) }
+    }
+}
diff --git a/compiler/rustc_codegen_llvm/src/typetree.rs b/compiler/rustc_codegen_llvm/src/typetree.rs
new file mode 100644
index 0000000000000..434316464e626
--- /dev/null
+++ b/compiler/rustc_codegen_llvm/src/typetree.rs
@@ -0,0 +1,144 @@
+use std::ffi::{CString, c_char, c_uint};
+
+use rustc_ast::expand::typetree::{FncTree, TypeTree as RustTypeTree};
+
+use crate::attributes;
+use crate::llvm::{self, Value};
+
+/// Converts a Rust TypeTree to Enzyme's internal TypeTree format
+///
+/// This function takes a Rust-side TypeTree (from rustc_ast::expand::typetree)
+/// and converts it to Enzyme's internal C++ TypeTree representation that
+/// Enzyme can understand during differentiation analysis.
+#[cfg(llvm_enzyme)]
+fn to_enzyme_typetree(
+    rust_typetree: RustTypeTree,
+    data_layout: &str,
+    llcx: &llvm::Context,
+) -> llvm::TypeTree {
+    // Start with an empty TypeTree
+    let mut enzyme_tt = llvm::TypeTree::new();
+
+    // Convert each Type in the Rust TypeTree to Enzyme format
+    for rust_type in rust_typetree.0 {
+        let concrete_type = match rust_type.kind {
+            rustc_ast::expand::typetree::Kind::Anything => llvm::CConcreteType::DT_Anything,
+            rustc_ast::expand::typetree::Kind::Integer => llvm::CConcreteType::DT_Integer,
+            rustc_ast::expand::typetree::Kind::Pointer => llvm::CConcreteType::DT_Pointer,
+            rustc_ast::expand::typetree::Kind::Half => llvm::CConcreteType::DT_Half,
+            rustc_ast::expand::typetree::Kind::Float => llvm::CConcreteType::DT_Float,
+            rustc_ast::expand::typetree::Kind::Double => llvm::CConcreteType::DT_Double,
+            rustc_ast::expand::typetree::Kind::F128 => llvm::CConcreteType::DT_Unknown,
+            rustc_ast::expand::typetree::Kind::Unknown => llvm::CConcreteType::DT_Unknown,
+        };
+
+        // Create a TypeTree for this specific type
+        let type_tt = llvm::TypeTree::from_type(concrete_type, llcx);
+
+        // Apply offset if specified
+        let type_tt = if rust_type.offset == -1 {
+            type_tt // -1 means everywhere/no specific offset
+        } else {
+            // Apply specific offset positioning
+            type_tt.shift(data_layout, rust_type.offset, rust_type.size as isize, 0)
+        };
+
+        // Merge this type into the main TypeTree
+        enzyme_tt = enzyme_tt.merge(type_tt);
+    }
+
+    enzyme_tt
+}
+
+#[cfg(not(llvm_enzyme))]
+fn to_enzyme_typetree(
+    _rust_typetree: RustTypeTree,
+    _data_layout: &str,
+    _llcx: &llvm::Context,
+) -> ! {
+    unimplemented!("TypeTree conversion not available without llvm_enzyme support")
+}
+
+// Attaches TypeTree information to LLVM function as enzyme_type attributes.
+#[cfg(llvm_enzyme)]
+pub(crate) fn add_tt<'ll>(
+    llmod: &'ll llvm::Module,
+    llcx: &'ll llvm::Context,
+    fn_def: &'ll Value,
+    tt: FncTree,
+) {
+    let inputs = tt.args;
+    let ret_tt: RustTypeTree = tt.ret;
+
+    // Get LLVM data layout string for TypeTree conversion
+    let llvm_data_layout: *const c_char = unsafe { llvm::LLVMGetDataLayoutStr(&*llmod) };
+    let llvm_data_layout =
+        std::str::from_utf8(unsafe { std::ffi::CStr::from_ptr(llvm_data_layout) }.to_bytes())
+            .expect("got a non-UTF8 data-layout from LLVM");
+
+    // Attribute name that Enzyme recognizes for TypeTree information
+    let attr_name = "enzyme_type";
+    let c_attr_name = CString::new(attr_name).unwrap();
+
+    // Attach TypeTree attributes to each input parameter
+    // Enzyme uses these to understand parameter memory layouts during differentiation
+    for (i, input) in inputs.iter().enumerate() {
+        unsafe {
+            // Convert Rust TypeTree to Enzyme's internal format
+            let enzyme_tt = to_enzyme_typetree(input.clone(), llvm_data_layout, llcx);
+
+            // Serialize TypeTree to string format that Enzyme can parse
+            let c_str = llvm::EnzymeTypeTreeToString(enzyme_tt.inner);
+            let c_str = std::ffi::CStr::from_ptr(c_str);
+
+            // Create LLVM string attribute with TypeTree information
+            let attr = llvm::LLVMCreateStringAttribute(
+                llcx,
+                c_attr_name.as_ptr(),
+                c_attr_name.as_bytes().len() as c_uint,
+                c_str.as_ptr(),
+                c_str.to_bytes().len() as c_uint,
+            );
+
+            // Attach attribute to the specific function parameter
+            // Note: ArgumentPlace uses 0-based indexing, but LLVM uses 1-based for arguments
+            attributes::apply_to_llfn(fn_def, llvm::AttributePlace::Argument(i as u32), &[attr]);
+
+            // Free the C string to prevent memory leaks
+            llvm::EnzymeTypeTreeToStringFree(c_str.as_ptr());
+        }
+    }
+
+    // Attach TypeTree attribute to the return type
+    // Enzyme needs this to understand how to handle return value derivatives
+    unsafe {
+        let enzyme_tt = to_enzyme_typetree(ret_tt, llvm_data_layout, llcx);
+        let c_str = llvm::EnzymeTypeTreeToString(enzyme_tt.inner);
+        let c_str = std::ffi::CStr::from_ptr(c_str);
+
+        let ret_attr = llvm::LLVMCreateStringAttribute(
+            llcx,
+            c_attr_name.as_ptr(),
+            c_attr_name.as_bytes().len() as c_uint,
+            c_str.as_ptr(),
+            c_str.to_bytes().len() as c_uint,
+        );
+
+        // Attach to function return type
+        attributes::apply_to_llfn(fn_def, llvm::AttributePlace::ReturnValue, &[ret_attr]);
+
+        // Free the C string
+        llvm::EnzymeTypeTreeToStringFree(c_str.as_ptr());
+    }
+}
+
+// Fallback implementation when Enzyme is not available
+#[cfg(not(llvm_enzyme))]
+pub(crate) fn add_tt<'ll>(
+    _llmod: &'ll llvm::Module,
+    _llcx: &'ll llvm::Context,
+    _fn_def: &'ll Value,
+    _tt: FncTree,
+) {
+    unimplemented!()
+}
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index df42c40031752..e7130757f1db6 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -2251,36 +2251,29 @@ pub fn fnc_typetrees<'tcx>(tcx: TyCtxt<'tcx>, fn_ty: Ty<'tcx>) -> FncTree {
 
 /// Generate TypeTree for a specific type.
 /// This function analyzes a Rust type and creates appropriate TypeTree metadata.
-fn typetree_from_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> TypeTree {
-    // Handle basic scalar types
+pub fn typetree_from_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> TypeTree {
     if ty.is_scalar() {
         let (kind, size) = if ty.is_integral() || ty.is_char() || ty.is_bool() {
             (Kind::Integer, ty.primitive_size(tcx).bytes_usize())
         } else if ty.is_floating_point() {
             match ty {
+                x if x == tcx.types.f16 => (Kind::Half, 2),
                 x if x == tcx.types.f32 => (Kind::Float, 4),
                 x if x == tcx.types.f64 => (Kind::Double, 8),
-                _ => return TypeTree::new(), // Unknown float type
+                x if x == tcx.types.f128 => (Kind::F128, 16),
+                _ => return TypeTree::new(),
             }
         } else {
-            // TODO(KMJ-007): Handle other scalar types if needed
             return TypeTree::new();
         };
-        
-        return TypeTree(vec![Type { 
-            offset: -1, 
-            size, 
-            kind, 
-            child: TypeTree::new() 
-        }]);
+
+        return TypeTree(vec![Type { offset: -1, size, kind, child: TypeTree::new() }]);
     }
 
-    // Handle references and pointers
     if ty.is_ref() || ty.is_raw_ptr() || ty.is_box() {
         let inner_ty = if let Some(inner) = ty.builtin_deref(true) {
             inner
         } else {
-            // TODO(KMJ-007): Handle complex pointer types
             return TypeTree::new();
         };
 

From beba6b9b8692d0db14c56292d4fb793fcd8ceb1e Mon Sep 17 00:00:00 2001
From: Karan Janthe <karanjanthe@gmail.com>
Date: Sat, 23 Aug 2025 21:57:37 +0000
Subject: [PATCH 1113/1889] Update TypeTree tests to verify metadata attachment

  - Fix nott-flag test to emit LLVM IR and check enzyme_type attributes
  - Replace TODO comments with actual TypeTree metadata verification
  - Test that NoTT flag properly disables TypeTree generation
  - Test that TypeTree enabled generates proper enzyme_type attributes

Signed-off-by: Karan Janthe <karanjanthe@gmail.com>
---
 .../autodiff/type-trees/nott-flag/nott.check  |  8 ++--
 .../autodiff/type-trees/nott-flag/rmake.rs    | 42 +++++++++----------
 .../type-trees/nott-flag/with_tt.check        |  7 ++--
 3 files changed, 29 insertions(+), 28 deletions(-)

diff --git a/tests/run-make/autodiff/type-trees/nott-flag/nott.check b/tests/run-make/autodiff/type-trees/nott-flag/nott.check
index 56ef2f0bdf380..8d23e2ee31957 100644
--- a/tests/run-make/autodiff/type-trees/nott-flag/nott.check
+++ b/tests/run-make/autodiff/type-trees/nott-flag/nott.check
@@ -1,3 +1,5 @@
-// TODO(KMJ-007): Update this test when TypeTree integration is complete
-// CHECK: square - {[-1]:Float@double} |{[-1]:Pointer}:{}
-// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@double}
\ No newline at end of file
+// Check that enzyme_type attributes are NOT present when NoTT flag is used
+// This verifies the NoTT flag correctly disables TypeTree metadata
+
+CHECK: define{{.*}}@square
+CHECK-NOT: "enzyme_type"
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/nott-flag/rmake.rs b/tests/run-make/autodiff/type-trees/nott-flag/rmake.rs
index 536164192dc06..bab863ca9ff29 100644
--- a/tests/run-make/autodiff/type-trees/nott-flag/rmake.rs
+++ b/tests/run-make/autodiff/type-trees/nott-flag/rmake.rs
@@ -5,34 +5,32 @@ use run_make_support::{llvm_filecheck, rfs, rustc};
 
 fn main() {
     // Test with NoTT flag - should not generate TypeTree metadata
-    let output_nott = rustc()
+    rustc()
         .input("test.rs")
-        .arg("-Zautodiff=Enable,NoTT,PrintTAFn=square")
-        .arg("-Zautodiff=NoPostopt")
-        .opt_level("3")
-        .arg("-Clto=fat")
-        .arg("-g")
+        .arg("-Zautodiff=Enable,NoTT")
+        .emit("llvm-ir")
+        .arg("-o")
+        .arg("nott.ll")
         .run();
 
-    // Write output for NoTT case
-    rfs::write("nott.stdout", output_nott.stdout_utf8());
-    
     // Test without NoTT flag - should generate TypeTree metadata
-    let output_with_tt = rustc()
+    rustc()
         .input("test.rs")
-        .arg("-Zautodiff=Enable,PrintTAFn=square")
-        .arg("-Zautodiff=NoPostopt")
-        .opt_level("3")
-        .arg("-Clto=fat")
-        .arg("-g")
+        .arg("-Zautodiff=Enable")
+        .emit("llvm-ir")
+        .arg("-o")
+        .arg("with_tt.ll")
         .run();
 
-    // Write output for TypeTree case  
-    rfs::write("with_tt.stdout", output_with_tt.stdout_utf8());
-
-    // Verify NoTT output has minimal TypeTree info
-    llvm_filecheck().patterns("nott.check").stdin_buf(rfs::read("nott.stdout")).run();
+    // Verify NoTT version does NOT have enzyme_type attributes
+    llvm_filecheck()
+        .patterns("nott.check")
+        .stdin_buf(rfs::read("nott.ll"))
+        .run();
     
-    // Verify normal output will have TypeTree info (once implemented)
-    llvm_filecheck().patterns("with_tt.check").stdin_buf(rfs::read("with_tt.stdout")).run();
+    // Verify TypeTree version DOES have enzyme_type attributes
+    llvm_filecheck()
+        .patterns("with_tt.check")
+        .stdin_buf(rfs::read("with_tt.ll"))
+        .run();
 }
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/nott-flag/with_tt.check b/tests/run-make/autodiff/type-trees/nott-flag/with_tt.check
index 56ef2f0bdf380..53eafc10a65da 100644
--- a/tests/run-make/autodiff/type-trees/nott-flag/with_tt.check
+++ b/tests/run-make/autodiff/type-trees/nott-flag/with_tt.check
@@ -1,3 +1,4 @@
-// TODO(KMJ-007): Update this test when TypeTree integration is complete
-// CHECK: square - {[-1]:Float@double} |{[-1]:Pointer}:{}
-// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@double}
\ No newline at end of file
+// Check that enzyme_type attributes are present when TypeTree is enabled
+// This verifies our TypeTree metadata attachment is working
+
+CHECK: define{{.*}}"enzyme_type"="{[]:Float@double}"{{.*}}@square{{.*}}"enzyme_type"="{[]:Pointer}"
\ No newline at end of file

From 5d3ebc3804299503387b7ea1427f1619d410c2b2 Mon Sep 17 00:00:00 2001
From: Karan Janthe <karanjanthe@gmail.com>
Date: Sat, 23 Aug 2025 21:57:54 +0000
Subject: [PATCH 1114/1889] Add TypeTree tests for scalar types

  - Add specific tests for f32, f64, i32, f16, f128 TypeTree generation
  - Verify correct enzyme_type metadata for each scalar type
  - Ensure TypeTree metadata matches expected Enzyme format

Signed-off-by: Karan Janthe <karanjanthe@gmail.com>
---
 .../scalar-types/f128-typetree/f128.check         |  4 ++++
 .../scalar-types/f128-typetree/rmake.rs           | 12 ++++++++++++
 .../type-trees/scalar-types/f128-typetree/test.rs | 15 +++++++++++++++
 .../scalar-types/f16-typetree/f16.check           |  4 ++++
 .../type-trees/scalar-types/f16-typetree/rmake.rs | 12 ++++++++++++
 .../type-trees/scalar-types/f16-typetree/test.rs  | 15 +++++++++++++++
 .../scalar-types/f32-typetree/f32.check           |  4 ++++
 .../type-trees/scalar-types/f32-typetree/rmake.rs | 12 ++++++++++++
 .../type-trees/scalar-types/f32-typetree/test.rs  | 15 +++++++++++++++
 .../scalar-types/f64-typetree/f64.check           |  4 ++++
 .../type-trees/scalar-types/f64-typetree/rmake.rs | 12 ++++++++++++
 .../type-trees/scalar-types/f64-typetree/test.rs  | 15 +++++++++++++++
 .../scalar-types/i32-typetree/i32.check           |  4 ++++
 .../type-trees/scalar-types/i32-typetree/rmake.rs | 12 ++++++++++++
 .../type-trees/scalar-types/i32-typetree/test.rs  | 14 ++++++++++++++
 15 files changed, 154 insertions(+)
 create mode 100644 tests/run-make/autodiff/type-trees/scalar-types/f128-typetree/f128.check
 create mode 100644 tests/run-make/autodiff/type-trees/scalar-types/f128-typetree/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/scalar-types/f128-typetree/test.rs
 create mode 100644 tests/run-make/autodiff/type-trees/scalar-types/f16-typetree/f16.check
 create mode 100644 tests/run-make/autodiff/type-trees/scalar-types/f16-typetree/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/scalar-types/f16-typetree/test.rs
 create mode 100644 tests/run-make/autodiff/type-trees/scalar-types/f32-typetree/f32.check
 create mode 100644 tests/run-make/autodiff/type-trees/scalar-types/f32-typetree/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/scalar-types/f32-typetree/test.rs
 create mode 100644 tests/run-make/autodiff/type-trees/scalar-types/f64-typetree/f64.check
 create mode 100644 tests/run-make/autodiff/type-trees/scalar-types/f64-typetree/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/scalar-types/f64-typetree/test.rs
 create mode 100644 tests/run-make/autodiff/type-trees/scalar-types/i32-typetree/i32.check
 create mode 100644 tests/run-make/autodiff/type-trees/scalar-types/i32-typetree/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/scalar-types/i32-typetree/test.rs

diff --git a/tests/run-make/autodiff/type-trees/scalar-types/f128-typetree/f128.check b/tests/run-make/autodiff/type-trees/scalar-types/f128-typetree/f128.check
new file mode 100644
index 0000000000000..31cef113420db
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/scalar-types/f128-typetree/f128.check
@@ -0,0 +1,4 @@
+; Check that f128 TypeTree metadata is correctly generated
+; f128 maps to Unknown in our current implementation since CConcreteType doesn't have DT_F128
+
+CHECK: define{{.*}}"enzyme_type"={{.*}}@test_f128{{.*}}"enzyme_type"="{[]:Pointer}"
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/scalar-types/f128-typetree/rmake.rs b/tests/run-make/autodiff/type-trees/scalar-types/f128-typetree/rmake.rs
new file mode 100644
index 0000000000000..44320ecdd5714
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/scalar-types/f128-typetree/rmake.rs
@@ -0,0 +1,12 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Compile with TypeTree enabled and emit LLVM IR
+    rustc().input("test.rs").arg("-Zautodiff=Enable").emit("llvm-ir").run();
+
+    // Check that f128 TypeTree metadata is correctly generated
+    llvm_filecheck().patterns("f128.check").stdin_buf(rfs::read("test.ll")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/scalar-types/f128-typetree/test.rs b/tests/run-make/autodiff/type-trees/scalar-types/f128-typetree/test.rs
new file mode 100644
index 0000000000000..5c71baa3e6999
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/scalar-types/f128-typetree/test.rs
@@ -0,0 +1,15 @@
+#![feature(autodiff, f128)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_test, Duplicated, Active)]
+#[no_mangle]
+fn test_f128(x: &f128) -> f128 {
+    *x * *x
+}
+
+fn main() {
+    let x = 2.0_f128;
+    let mut dx = 0.0_f128;
+    let _result = d_test(&x, &mut dx, 1.0);
+}
diff --git a/tests/run-make/autodiff/type-trees/scalar-types/f16-typetree/f16.check b/tests/run-make/autodiff/type-trees/scalar-types/f16-typetree/f16.check
new file mode 100644
index 0000000000000..97a3964a569b1
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/scalar-types/f16-typetree/f16.check
@@ -0,0 +1,4 @@
+; Check that f16 TypeTree metadata is correctly generated
+; Should show Half for f16 values and Pointer for references
+
+CHECK: define{{.*}}"enzyme_type"={{.*}}@test_f16{{.*}}"enzyme_type"="{[]:Pointer}"
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/scalar-types/f16-typetree/rmake.rs b/tests/run-make/autodiff/type-trees/scalar-types/f16-typetree/rmake.rs
new file mode 100644
index 0000000000000..0aebdbf55209b
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/scalar-types/f16-typetree/rmake.rs
@@ -0,0 +1,12 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Compile with TypeTree enabled and emit LLVM IR
+    rustc().input("test.rs").arg("-Zautodiff=Enable").emit("llvm-ir").run();
+
+    // Check that f16 TypeTree metadata is correctly generated
+    llvm_filecheck().patterns("f16.check").stdin_buf(rfs::read("test.ll")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/scalar-types/f16-typetree/test.rs b/tests/run-make/autodiff/type-trees/scalar-types/f16-typetree/test.rs
new file mode 100644
index 0000000000000..6b68e8252f4c0
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/scalar-types/f16-typetree/test.rs
@@ -0,0 +1,15 @@
+#![feature(autodiff, f16)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_test, Duplicated, Active)]
+#[no_mangle]
+fn test_f16(x: &f16) -> f16 {
+    *x * *x
+}
+
+fn main() {
+    let x = 2.0_f16;
+    let mut dx = 0.0_f16;
+    let _result = d_test(&x, &mut dx, 1.0);
+}
diff --git a/tests/run-make/autodiff/type-trees/scalar-types/f32-typetree/f32.check b/tests/run-make/autodiff/type-trees/scalar-types/f32-typetree/f32.check
new file mode 100644
index 0000000000000..b32d5086d07d1
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/scalar-types/f32-typetree/f32.check
@@ -0,0 +1,4 @@
+; Check that f32 TypeTree metadata is correctly generated
+; Should show Float@float for f32 values and Pointer for references
+
+CHECK: define{{.*}}"enzyme_type"="{[]:Float@float}"{{.*}}@test_f32{{.*}}"enzyme_type"="{[]:Pointer}"
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/scalar-types/f32-typetree/rmake.rs b/tests/run-make/autodiff/type-trees/scalar-types/f32-typetree/rmake.rs
new file mode 100644
index 0000000000000..ee3ab753bf505
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/scalar-types/f32-typetree/rmake.rs
@@ -0,0 +1,12 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Compile with TypeTree enabled and emit LLVM IR
+    rustc().input("test.rs").arg("-Zautodiff=Enable").emit("llvm-ir").run();
+
+    // Check that f32 TypeTree metadata is correctly generated
+    llvm_filecheck().patterns("f32.check").stdin_buf(rfs::read("test.ll")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/scalar-types/f32-typetree/test.rs b/tests/run-make/autodiff/type-trees/scalar-types/f32-typetree/test.rs
new file mode 100644
index 0000000000000..56c118399ee4b
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/scalar-types/f32-typetree/test.rs
@@ -0,0 +1,15 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_test, Duplicated, Active)]
+#[no_mangle]
+fn test_f32(x: &f32) -> f32 {
+    x * x
+}
+
+fn main() {
+    let x = 2.0_f32;
+    let mut dx = 0.0_f32;
+    let _result = d_test(&x, &mut dx, 1.0);
+}
diff --git a/tests/run-make/autodiff/type-trees/scalar-types/f64-typetree/f64.check b/tests/run-make/autodiff/type-trees/scalar-types/f64-typetree/f64.check
new file mode 100644
index 0000000000000..0e9d9c03a0f86
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/scalar-types/f64-typetree/f64.check
@@ -0,0 +1,4 @@
+; Check that f64 TypeTree metadata is correctly generated  
+; Should show Float@double for f64 values and Pointer for references
+
+CHECK: define{{.*}}"enzyme_type"="{[]:Float@double}"{{.*}}@test_f64{{.*}}"enzyme_type"="{[]:Pointer}"
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/scalar-types/f64-typetree/rmake.rs b/tests/run-make/autodiff/type-trees/scalar-types/f64-typetree/rmake.rs
new file mode 100644
index 0000000000000..5fac9b23bc80f
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/scalar-types/f64-typetree/rmake.rs
@@ -0,0 +1,12 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Compile with TypeTree enabled and emit LLVM IR
+    rustc().input("test.rs").arg("-Zautodiff=Enable").emit("llvm-ir").run();
+
+    // Check that f64 TypeTree metadata is correctly generated
+    llvm_filecheck().patterns("f64.check").stdin_buf(rfs::read("test.ll")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/scalar-types/f64-typetree/test.rs b/tests/run-make/autodiff/type-trees/scalar-types/f64-typetree/test.rs
new file mode 100644
index 0000000000000..235360b76b23d
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/scalar-types/f64-typetree/test.rs
@@ -0,0 +1,15 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_test, Duplicated, Active)]
+#[no_mangle]
+fn test_f64(x: &f64) -> f64 {
+    x * x
+}
+
+fn main() {
+    let x = 2.0_f64;
+    let mut dx = 0.0_f64;
+    let _result = d_test(&x, &mut dx, 1.0);
+}
diff --git a/tests/run-make/autodiff/type-trees/scalar-types/i32-typetree/i32.check b/tests/run-make/autodiff/type-trees/scalar-types/i32-typetree/i32.check
new file mode 100644
index 0000000000000..aa8e5223e8ed5
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/scalar-types/i32-typetree/i32.check
@@ -0,0 +1,4 @@
+; Check that i32 TypeTree metadata is correctly generated
+; Should show Integer for i32 values (integers are typically Const in autodiff)
+
+CHECK: define{{.*}}"enzyme_type"="{[]:Integer}"{{.*}}@test_i32{{.*}}"enzyme_type"="{[]:Integer}"
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/scalar-types/i32-typetree/rmake.rs b/tests/run-make/autodiff/type-trees/scalar-types/i32-typetree/rmake.rs
new file mode 100644
index 0000000000000..a40fd55d88adf
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/scalar-types/i32-typetree/rmake.rs
@@ -0,0 +1,12 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Compile with TypeTree enabled and emit LLVM IR
+    rustc().input("test.rs").arg("-Zautodiff=Enable").emit("llvm-ir").run();
+
+    // Check that i32 TypeTree metadata is correctly generated
+    llvm_filecheck().patterns("i32.check").stdin_buf(rfs::read("test.ll")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/scalar-types/i32-typetree/test.rs b/tests/run-make/autodiff/type-trees/scalar-types/i32-typetree/test.rs
new file mode 100644
index 0000000000000..530c137f62b9c
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/scalar-types/i32-typetree/test.rs
@@ -0,0 +1,14 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_test, Const, Active)]
+#[no_mangle]
+fn test_i32(x: i32) -> i32 {
+    x * x
+}
+
+fn main() {
+    let x = 5_i32;
+    let _result = d_test(x, 1);
+}

From 664e83b3e76b51fb5192e74a64eef3bc5bbd4e32 Mon Sep 17 00:00:00 2001
From: Karan Janthe <karanjanthe@gmail.com>
Date: Sat, 23 Aug 2025 23:10:48 +0000
Subject: [PATCH 1115/1889] added typetree support for memcpy

---
 compiler/rustc_codegen_gcc/src/builder.rs     |  1 +
 .../rustc_codegen_gcc/src/intrinsic/mod.rs    |  1 +
 compiler/rustc_codegen_llvm/src/abi.rs        |  1 +
 compiler/rustc_codegen_llvm/src/builder.rs    | 15 ++++++-
 .../rustc_codegen_llvm/src/llvm/enzyme_ffi.rs |  1 +
 compiler/rustc_codegen_llvm/src/typetree.rs   | 20 ++++------
 compiler/rustc_codegen_llvm/src/va_arg.rs     |  1 +
 compiler/rustc_codegen_ssa/src/mir/block.rs   |  1 +
 .../rustc_codegen_ssa/src/mir/intrinsic.rs    |  2 +-
 .../rustc_codegen_ssa/src/mir/statement.rs    |  2 +-
 .../rustc_codegen_ssa/src/traits/builder.rs   |  3 +-
 compiler/rustc_interface/src/tests.rs         |  1 -
 compiler/rustc_middle/src/ty/mod.rs           |  4 +-
 tests/codegen-llvm/autodiff/typetree.rs       |  2 +-
 .../memcpy-typetree/memcpy-ir.check           |  8 ++++
 .../type-trees/memcpy-typetree/memcpy.check   | 13 +++++++
 .../type-trees/memcpy-typetree/memcpy.rs      | 36 +++++++++++++++++
 .../type-trees/memcpy-typetree/rmake.rs       | 39 +++++++++++++++++++
 .../autodiff/type-trees/nott-flag/rmake.rs    | 14 ++-----
 .../autodiff/type-trees/nott-flag/test.rs     |  2 +-
 tests/ui/autodiff/flag_nott.rs                |  2 +-
 21 files changed, 135 insertions(+), 34 deletions(-)
 create mode 100644 tests/run-make/autodiff/type-trees/memcpy-typetree/memcpy-ir.check
 create mode 100644 tests/run-make/autodiff/type-trees/memcpy-typetree/memcpy.check
 create mode 100644 tests/run-make/autodiff/type-trees/memcpy-typetree/memcpy.rs
 create mode 100644 tests/run-make/autodiff/type-trees/memcpy-typetree/rmake.rs

diff --git a/compiler/rustc_codegen_gcc/src/builder.rs b/compiler/rustc_codegen_gcc/src/builder.rs
index f7a7a3f8c7e35..5657620879ca1 100644
--- a/compiler/rustc_codegen_gcc/src/builder.rs
+++ b/compiler/rustc_codegen_gcc/src/builder.rs
@@ -1383,6 +1383,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         _src_align: Align,
         size: RValue<'gcc>,
         flags: MemFlags,
+        _tt: Option<rustc_ast::expand::typetree::FncTree>, // Autodiff TypeTrees are LLVM-only, ignored in GCC backend
     ) {
         assert!(!flags.contains(MemFlags::NONTEMPORAL), "non-temporal memcpy not supported");
         let size = self.intcast(size, self.type_size_t(), false);
diff --git a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
index 84fa56cf90308..3b897a1983503 100644
--- a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
+++ b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
@@ -771,6 +771,7 @@ impl<'gcc, 'tcx> ArgAbiExt<'gcc, 'tcx> for ArgAbi<'tcx, Ty<'tcx>> {
                     scratch_align,
                     bx.const_usize(self.layout.size.bytes()),
                     MemFlags::empty(),
+                    None,
                 );
 
                 bx.lifetime_end(scratch, scratch_size);
diff --git a/compiler/rustc_codegen_llvm/src/abi.rs b/compiler/rustc_codegen_llvm/src/abi.rs
index 11be704116790..61fadad606613 100644
--- a/compiler/rustc_codegen_llvm/src/abi.rs
+++ b/compiler/rustc_codegen_llvm/src/abi.rs
@@ -246,6 +246,7 @@ impl<'ll, 'tcx> ArgAbiExt<'ll, 'tcx> for ArgAbi<'tcx, Ty<'tcx>> {
                     scratch_align,
                     bx.const_usize(copy_bytes),
                     MemFlags::empty(),
+                    None,
                 );
                 bx.lifetime_end(llscratch, scratch_size);
             }
diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
index 0f17cc9063a87..83a9cf620f109 100644
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -2,6 +2,7 @@ use std::borrow::{Borrow, Cow};
 use std::ops::Deref;
 use std::{iter, ptr};
 
+use rustc_ast::expand::typetree::FncTree;
 pub(crate) mod autodiff;
 pub(crate) mod gpu_offload;
 
@@ -1107,11 +1108,12 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         src_align: Align,
         size: &'ll Value,
         flags: MemFlags,
+        tt: Option<FncTree>,
     ) {
         assert!(!flags.contains(MemFlags::NONTEMPORAL), "non-temporal memcpy not supported");
         let size = self.intcast(size, self.type_isize(), false);
         let is_volatile = flags.contains(MemFlags::VOLATILE);
-        unsafe {
+        let memcpy = unsafe {
             llvm::LLVMRustBuildMemCpy(
                 self.llbuilder,
                 dst,
@@ -1120,7 +1122,16 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
                 src_align.bytes() as c_uint,
                 size,
                 is_volatile,
-            );
+            )
+        };
+
+        // TypeTree metadata for memcpy is especially important: when Enzyme encounters
+        // a memcpy during autodiff, it needs to know the structure of the data being
+        // copied to properly track derivatives. For example, copying an array of floats
+        // vs. copying a struct with mixed types requires different derivative handling.
+        // The TypeTree tells Enzyme exactly what memory layout to expect.
+        if let Some(tt) = tt {
+            crate::typetree::add_tt(self.cx().llmod, self.cx().llcx, memcpy, tt);
         }
     }
 
diff --git a/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
index 12b6ffa3c0b5f..9dd84ad9a4dc3 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
@@ -25,6 +25,7 @@ pub(crate) enum CConcreteType {
     DT_Half = 3,
     DT_Float = 4,
     DT_Double = 5,
+    // FIXME(KMJ-007): handle f128 using long double here(https://github.com/EnzymeAD/Enzyme/issues/1600)
     DT_Unknown = 6,
 }
 
diff --git a/compiler/rustc_codegen_llvm/src/typetree.rs b/compiler/rustc_codegen_llvm/src/typetree.rs
index 434316464e626..8e6272a186b88 100644
--- a/compiler/rustc_codegen_llvm/src/typetree.rs
+++ b/compiler/rustc_codegen_llvm/src/typetree.rs
@@ -1,8 +1,11 @@
-use std::ffi::{CString, c_char, c_uint};
-
-use rustc_ast::expand::typetree::{FncTree, TypeTree as RustTypeTree};
+use rustc_ast::expand::typetree::FncTree;
+#[cfg(llvm_enzyme)]
+use {
+    crate::attributes,
+    rustc_ast::expand::typetree::TypeTree as RustTypeTree,
+    std::ffi::{CString, c_char, c_uint},
+};
 
-use crate::attributes;
 use crate::llvm::{self, Value};
 
 /// Converts a Rust TypeTree to Enzyme's internal TypeTree format
@@ -50,15 +53,6 @@ fn to_enzyme_typetree(
     enzyme_tt
 }
 
-#[cfg(not(llvm_enzyme))]
-fn to_enzyme_typetree(
-    _rust_typetree: RustTypeTree,
-    _data_layout: &str,
-    _llcx: &llvm::Context,
-) -> ! {
-    unimplemented!("TypeTree conversion not available without llvm_enzyme support")
-}
-
 // Attaches TypeTree information to LLVM function as enzyme_type attributes.
 #[cfg(llvm_enzyme)]
 pub(crate) fn add_tt<'ll>(
diff --git a/compiler/rustc_codegen_llvm/src/va_arg.rs b/compiler/rustc_codegen_llvm/src/va_arg.rs
index ab08125217ff5..d48c7cf874a0a 100644
--- a/compiler/rustc_codegen_llvm/src/va_arg.rs
+++ b/compiler/rustc_codegen_llvm/src/va_arg.rs
@@ -738,6 +738,7 @@ fn copy_to_temporary_if_more_aligned<'ll, 'tcx>(
             src_align,
             bx.const_u32(layout.layout.size().bytes() as u32),
             MemFlags::empty(),
+            None,
         );
         tmp
     } else {
diff --git a/compiler/rustc_codegen_ssa/src/mir/block.rs b/compiler/rustc_codegen_ssa/src/mir/block.rs
index 1b218a0d33956..b2dc4fe32b0fe 100644
--- a/compiler/rustc_codegen_ssa/src/mir/block.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/block.rs
@@ -1626,6 +1626,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                     align,
                     bx.const_usize(copy_bytes),
                     MemFlags::empty(),
+                    None,
                 );
                 // ...and then load it with the ABI type.
                 llval = load_cast(bx, cast, llscratch, scratch_align);
diff --git a/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs b/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs
index 3c667b8e88203..befa00c6861ed 100644
--- a/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs
@@ -30,7 +30,7 @@ fn copy_intrinsic<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
     if allow_overlap {
         bx.memmove(dst, align, src, align, size, flags);
     } else {
-        bx.memcpy(dst, align, src, align, size, flags);
+        bx.memcpy(dst, align, src, align, size, flags, None);
     }
 }
 
diff --git a/compiler/rustc_codegen_ssa/src/mir/statement.rs b/compiler/rustc_codegen_ssa/src/mir/statement.rs
index f164e0f912373..0a50d7f18dbef 100644
--- a/compiler/rustc_codegen_ssa/src/mir/statement.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/statement.rs
@@ -90,7 +90,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 let align = pointee_layout.align;
                 let dst = dst_val.immediate();
                 let src = src_val.immediate();
-                bx.memcpy(dst, align, src, align, bytes, crate::MemFlags::empty());
+                bx.memcpy(dst, align, src, align, bytes, crate::MemFlags::empty(), None);
             }
             mir::StatementKind::FakeRead(..)
             | mir::StatementKind::Retag { .. }
diff --git a/compiler/rustc_codegen_ssa/src/traits/builder.rs b/compiler/rustc_codegen_ssa/src/traits/builder.rs
index 4a5694e97fa20..60296e36e0c1a 100644
--- a/compiler/rustc_codegen_ssa/src/traits/builder.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/builder.rs
@@ -451,6 +451,7 @@ pub trait BuilderMethods<'a, 'tcx>:
         src_align: Align,
         size: Self::Value,
         flags: MemFlags,
+        tt: Option<rustc_ast::expand::typetree::FncTree>,
     );
     fn memmove(
         &mut self,
@@ -507,7 +508,7 @@ pub trait BuilderMethods<'a, 'tcx>:
             temp.val.store_with_flags(self, dst.with_type(layout), flags);
         } else if !layout.is_zst() {
             let bytes = self.const_usize(layout.size.bytes());
-            self.memcpy(dst.llval, dst.align, src.llval, src.align, bytes, flags);
+            self.memcpy(dst.llval, dst.align, src.llval, src.align, bytes, flags, None);
         }
     }
 
diff --git a/compiler/rustc_interface/src/tests.rs b/compiler/rustc_interface/src/tests.rs
index 837acdadd579d..0dc5b5af3aca0 100644
--- a/compiler/rustc_interface/src/tests.rs
+++ b/compiler/rustc_interface/src/tests.rs
@@ -765,7 +765,6 @@ fn test_unstable_options_tracking_hash() {
     tracked!(allow_features, Some(vec![String::from("lang_items")]));
     tracked!(always_encode_mir, true);
     tracked!(assume_incomplete_release, true);
-    tracked!(autodiff, vec![AutoDiff::Enable]);
     tracked!(autodiff, vec![AutoDiff::Enable, AutoDiff::NoTT]);
     tracked!(binary_dep_depinfo, true);
     tracked!(box_noalias, false);
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index e7130757f1db6..741b5d7fd4e06 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -2280,12 +2280,12 @@ pub fn typetree_from_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> TypeTree {
         let child = typetree_from_ty(tcx, inner_ty);
         return TypeTree(vec![Type {
             offset: -1,
-            size: 8, // TODO(KMJ-007): Get actual pointer size from target
+            size: tcx.data_layout.pointer_size().bytes_usize(),
             kind: Kind::Pointer,
             child,
         }]);
     }
 
-    // TODO(KMJ-007): Handle arrays, slices, structs, and other complex types
+    // FIXME(KMJ-007): Handle arrays, slices, structs, and other complex types
     TypeTree::new()
 }
diff --git a/tests/codegen-llvm/autodiff/typetree.rs b/tests/codegen-llvm/autodiff/typetree.rs
index 3ad38d581b9a1..1cb0c2fb68be3 100644
--- a/tests/codegen-llvm/autodiff/typetree.rs
+++ b/tests/codegen-llvm/autodiff/typetree.rs
@@ -30,4 +30,4 @@ fn main() {
     let output_ = d_simple(&x, &mut df_dx, 1.0);
     assert_eq!(output, output_);
     assert_eq!(2.0, df_dx);
-}
\ No newline at end of file
+}
diff --git a/tests/run-make/autodiff/type-trees/memcpy-typetree/memcpy-ir.check b/tests/run-make/autodiff/type-trees/memcpy-typetree/memcpy-ir.check
new file mode 100644
index 0000000000000..3a59f06dda1e4
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/memcpy-typetree/memcpy-ir.check
@@ -0,0 +1,8 @@
+; Check that enzyme_type attributes are present in the LLVM IR function definition
+; This verifies our TypeTree system correctly attaches metadata for Enzyme
+
+CHECK: define{{.*}}"enzyme_type"="{[]:Float@double}"{{.*}}@test_memcpy({{.*}}"enzyme_type"="{[]:Pointer}"
+
+; Check that llvm.memcpy exists (either call or declare)
+CHECK: {{(call|declare).*}}@llvm.memcpy
+
diff --git a/tests/run-make/autodiff/type-trees/memcpy-typetree/memcpy.check b/tests/run-make/autodiff/type-trees/memcpy-typetree/memcpy.check
new file mode 100644
index 0000000000000..ae70830297a78
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/memcpy-typetree/memcpy.check
@@ -0,0 +1,13 @@
+CHECK: force_memcpy
+
+CHECK: @llvm.memcpy.p0.p0.i64
+
+CHECK: test_memcpy - {[-1]:Float@double} |{[-1]:Pointer}:{}
+
+CHECK-DAG: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@double, [-1,8]:Float@double, [-1,16]:Float@double, [-1,24]:Float@double}
+
+CHECK-DAG: load double{{.*}}: {[-1]:Float@double}
+
+CHECK-DAG: fmul double{{.*}}: {[-1]:Float@double}
+
+CHECK-DAG: fadd double{{.*}}: {[-1]:Float@double}
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/memcpy-typetree/memcpy.rs b/tests/run-make/autodiff/type-trees/memcpy-typetree/memcpy.rs
new file mode 100644
index 0000000000000..3c1029190c88a
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/memcpy-typetree/memcpy.rs
@@ -0,0 +1,36 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+use std::ptr;
+
+#[inline(never)]
+fn force_memcpy(src: *const f64, dst: *mut f64, count: usize) {
+    unsafe {
+        ptr::copy_nonoverlapping(src, dst, count);
+    }
+}
+
+#[autodiff_reverse(d_test_memcpy, Duplicated, Active)]
+#[no_mangle]
+fn test_memcpy(input: &[f64; 128]) -> f64 {
+    let mut local_data = [0.0f64; 128];
+
+    // Use a separate function to prevent inlining and optimization
+    force_memcpy(input.as_ptr(), local_data.as_mut_ptr(), 128);
+
+    // Sum only first few elements to keep the computation simple
+    local_data[0] * local_data[0]
+        + local_data[1] * local_data[1]
+        + local_data[2] * local_data[2]
+        + local_data[3] * local_data[3]
+}
+
+fn main() {
+    let input = [1.0; 128];
+    let mut d_input = [0.0; 128];
+    let result = test_memcpy(&input);
+    let result_d = d_test_memcpy(&input, &mut d_input, 1.0);
+
+    assert_eq!(result, result_d);
+    println!("Memcpy test passed: result = {}", result);
+}
diff --git a/tests/run-make/autodiff/type-trees/memcpy-typetree/rmake.rs b/tests/run-make/autodiff/type-trees/memcpy-typetree/rmake.rs
new file mode 100644
index 0000000000000..b4c650330fe94
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/memcpy-typetree/rmake.rs
@@ -0,0 +1,39 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // First, compile to LLVM IR to check for enzyme_type attributes
+    let _ir_output = rustc()
+        .input("memcpy.rs")
+        .arg("-Zautodiff=Enable")
+        .arg("-Zautodiff=NoPostopt")
+        .opt_level("0")
+        .arg("--emit=llvm-ir")
+        .arg("-o")
+        .arg("main.ll")
+        .run();
+
+    // Then compile with TypeTree analysis output for the existing checks
+    let output = rustc()
+        .input("memcpy.rs")
+        .arg("-Zautodiff=Enable,PrintTAFn=test_memcpy")
+        .arg("-Zautodiff=NoPostopt")
+        .opt_level("3")
+        .arg("-Clto=fat")
+        .arg("-g")
+        .run();
+
+    let stdout = output.stdout_utf8();
+    let stderr = output.stderr_utf8();
+    let ir_content = rfs::read_to_string("main.ll");
+
+    rfs::write("memcpy.stdout", &stdout);
+    rfs::write("memcpy.stderr", &stderr);
+    rfs::write("main.ir", &ir_content);
+
+    llvm_filecheck().patterns("memcpy.check").stdin_buf(stdout).run();
+
+    llvm_filecheck().patterns("memcpy-ir.check").stdin_buf(ir_content).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/nott-flag/rmake.rs b/tests/run-make/autodiff/type-trees/nott-flag/rmake.rs
index bab863ca9ff29..de540b990cabd 100644
--- a/tests/run-make/autodiff/type-trees/nott-flag/rmake.rs
+++ b/tests/run-make/autodiff/type-trees/nott-flag/rmake.rs
@@ -23,14 +23,8 @@ fn main() {
         .run();
 
     // Verify NoTT version does NOT have enzyme_type attributes
-    llvm_filecheck()
-        .patterns("nott.check")
-        .stdin_buf(rfs::read("nott.ll"))
-        .run();
-    
+    llvm_filecheck().patterns("nott.check").stdin_buf(rfs::read("nott.ll")).run();
+
     // Verify TypeTree version DOES have enzyme_type attributes
-    llvm_filecheck()
-        .patterns("with_tt.check")
-        .stdin_buf(rfs::read("with_tt.ll"))
-        .run();
-}
\ No newline at end of file
+    llvm_filecheck().patterns("with_tt.check").stdin_buf(rfs::read("with_tt.ll")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/nott-flag/test.rs b/tests/run-make/autodiff/type-trees/nott-flag/test.rs
index 5c634eea035d9..de3549c37c679 100644
--- a/tests/run-make/autodiff/type-trees/nott-flag/test.rs
+++ b/tests/run-make/autodiff/type-trees/nott-flag/test.rs
@@ -12,4 +12,4 @@ fn main() {
     let x = 2.0;
     let mut dx = 0.0;
     let _result = d_square(&x, &mut dx, 1.0);
-}
\ No newline at end of file
+}
diff --git a/tests/ui/autodiff/flag_nott.rs b/tests/ui/autodiff/flag_nott.rs
index 7a97d892cd881..faa9949fe8167 100644
--- a/tests/ui/autodiff/flag_nott.rs
+++ b/tests/ui/autodiff/flag_nott.rs
@@ -16,4 +16,4 @@ fn main() {
     let x = 2.0;
     let mut dx = 0.0;
     let result = d_square(&x, &mut dx, 1.0);
-}
\ No newline at end of file
+}

From b8bb2e8bfec298aecec54f67e8ea3deda471eafa Mon Sep 17 00:00:00 2001
From: Karan Janthe <karanjanthe@gmail.com>
Date: Wed, 27 Aug 2025 05:58:42 +0000
Subject: [PATCH 1116/1889] typo: allow EnzymeTypeTreeShiftIndiciesEq

---
 typos.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/typos.toml b/typos.toml
index b0ff48f8fa28b..c7d5b0000b9d7 100644
--- a/typos.toml
+++ b/typos.toml
@@ -53,6 +53,7 @@ ERROR_DS_NOT_AUTHORITIVE_FOR_DST_NC = "ERROR_DS_NOT_AUTHORITIVE_FOR_DST_NC"
 ERROR_MCA_OCCURED = "ERROR_MCA_OCCURED"
 ERRNO_ACCES = "ERRNO_ACCES"
 tolen = "tolen"
+EnzymeTypeTreeShiftIndiciesEq = "EnzymeTypeTreeShiftIndiciesEq"
 
 [default]
 extend-ignore-words-re = [

From d89ee858ab80f2c922c117c95b20264be8b84e3c Mon Sep 17 00:00:00 2001
From: Karan Janthe <karanjanthe@gmail.com>
Date: Wed, 27 Aug 2025 18:19:55 +0000
Subject: [PATCH 1117/1889] enzyme submodule updated

---
 src/llvm-project | 2 +-
 src/tools/cargo  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/llvm-project b/src/llvm-project
index 333793696b0a0..2a22c8014390b 160000
--- a/src/llvm-project
+++ b/src/llvm-project
@@ -1 +1 @@
-Subproject commit 333793696b0a08002acac6af983adc7a5233fc56
+Subproject commit 2a22c8014390bdf387d8ed26005fee3187fb98bd
diff --git a/src/tools/cargo b/src/tools/cargo
index 966f94733bbc9..a4bd03c92d3b9 160000
--- a/src/tools/cargo
+++ b/src/tools/cargo
@@ -1 +1 @@
-Subproject commit 966f94733bbc94ca51ff9f1e4c49ad250ebbdc50
+Subproject commit a4bd03c92d3b977909953d06cc45e263bd7ca7d8

From 54f9376660707d4ca9fce51fd423658f75128ac4 Mon Sep 17 00:00:00 2001
From: Karan Janthe <karanjanthe@gmail.com>
Date: Wed, 27 Aug 2025 18:23:54 +0000
Subject: [PATCH 1118/1889] autodiff: f128 support added for typetree

---
 compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs | 2 +-
 compiler/rustc_codegen_llvm/src/typetree.rs        | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
index 9dd84ad9a4dc3..1596dc4837978 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
@@ -25,8 +25,8 @@ pub(crate) enum CConcreteType {
     DT_Half = 3,
     DT_Float = 4,
     DT_Double = 5,
-    // FIXME(KMJ-007): handle f128 using long double here(https://github.com/EnzymeAD/Enzyme/issues/1600)
     DT_Unknown = 6,
+    DT_FP128 = 9,
 }
 
 pub(crate) struct TypeTree {
diff --git a/compiler/rustc_codegen_llvm/src/typetree.rs b/compiler/rustc_codegen_llvm/src/typetree.rs
index 8e6272a186b88..8c0d255bba84e 100644
--- a/compiler/rustc_codegen_llvm/src/typetree.rs
+++ b/compiler/rustc_codegen_llvm/src/typetree.rs
@@ -31,7 +31,7 @@ fn to_enzyme_typetree(
             rustc_ast::expand::typetree::Kind::Half => llvm::CConcreteType::DT_Half,
             rustc_ast::expand::typetree::Kind::Float => llvm::CConcreteType::DT_Float,
             rustc_ast::expand::typetree::Kind::Double => llvm::CConcreteType::DT_Double,
-            rustc_ast::expand::typetree::Kind::F128 => llvm::CConcreteType::DT_Unknown,
+            rustc_ast::expand::typetree::Kind::F128 => llvm::CConcreteType::DT_FP128,
             rustc_ast::expand::typetree::Kind::Unknown => llvm::CConcreteType::DT_Unknown,
         };
 

From 31541feb6f7e46c23141bdeb3e35ecd305bf8762 Mon Sep 17 00:00:00 2001
From: Karan Janthe <karanjanthe@gmail.com>
Date: Mon, 1 Sep 2025 05:05:49 +0000
Subject: [PATCH 1119/1889] autodiff: add TypeTree support for arrays

---
 compiler/rustc_middle/src/ty/mod.rs           | 42 ++++++++++++++++++-
 .../type-trees/array-typetree/array.check     |  4 ++
 .../type-trees/array-typetree/rmake.rs        |  9 ++++
 .../type-trees/array-typetree/test.rs         | 15 +++++++
 4 files changed, 69 insertions(+), 1 deletion(-)
 create mode 100644 tests/run-make/autodiff/type-trees/array-typetree/array.check
 create mode 100644 tests/run-make/autodiff/type-trees/array-typetree/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/array-typetree/test.rs

diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 741b5d7fd4e06..02a4e4e2b1592 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -2286,6 +2286,46 @@ pub fn typetree_from_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> TypeTree {
         }]);
     }
 
-    // FIXME(KMJ-007): Handle arrays, slices, structs, and other complex types
+    if ty.is_array() {
+        if let ty::Array(element_ty, len_const) = ty.kind() {
+            let len = len_const.try_to_target_usize(tcx).unwrap_or(0);
+            if len == 0 {
+                return TypeTree::new();
+            }
+
+            let element_tree = typetree_from_ty(tcx, *element_ty);
+
+            let element_layout = tcx
+                .layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(*element_ty))
+                .ok()
+                .map(|layout| layout.size.bytes_usize())
+                .unwrap_or(0);
+
+            if element_layout == 0 {
+                return TypeTree::new();
+            }
+
+            let mut types = Vec::new();
+            for i in 0..len {
+                let base_offset = (i as usize * element_layout) as isize;
+
+                for elem_type in &element_tree.0 {
+                    types.push(Type {
+                        offset: if elem_type.offset == -1 {
+                            base_offset
+                        } else {
+                            base_offset + elem_type.offset
+                        },
+                        size: elem_type.size,
+                        kind: elem_type.kind,
+                        child: elem_type.child.clone(),
+                    });
+                }
+            }
+
+            return TypeTree(types);
+        }
+    }
+
     TypeTree::new()
 }
diff --git a/tests/run-make/autodiff/type-trees/array-typetree/array.check b/tests/run-make/autodiff/type-trees/array-typetree/array.check
new file mode 100644
index 0000000000000..7513458b8ab81
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/array-typetree/array.check
@@ -0,0 +1,4 @@
+; Check that array TypeTree metadata is correctly generated  
+; Should show Float@double at each array element offset (0, 8, 16, 24, 32 bytes)
+
+CHECK: define{{.*}}"enzyme_type"="{[]:Float@double}"{{.*}}@test_array{{.*}}"enzyme_type"="{[]:Pointer}"
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/array-typetree/rmake.rs b/tests/run-make/autodiff/type-trees/array-typetree/rmake.rs
new file mode 100644
index 0000000000000..20b6a06690625
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/array-typetree/rmake.rs
@@ -0,0 +1,9 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    rustc().input("test.rs").arg("-Zautodiff=Enable").emit("llvm-ir").run();
+    llvm_filecheck().patterns("array.check").stdin_buf(rfs::read("test.ll")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/array-typetree/test.rs b/tests/run-make/autodiff/type-trees/array-typetree/test.rs
new file mode 100644
index 0000000000000..f54ebf5a4c7b5
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/array-typetree/test.rs
@@ -0,0 +1,15 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_test, Duplicated, Active)]
+#[no_mangle]
+fn test_array(arr: &[f64; 5]) -> f64 {
+    arr[0] + arr[1] + arr[2] + arr[3] + arr[4]
+}
+
+fn main() {
+    let arr = [1.0, 2.0, 3.0, 4.0, 5.0];
+    let mut d_arr = [0.0; 5];
+    let _result = d_test(&arr, &mut d_arr, 1.0);
+}

From be3617b04031c7d4f227ce54c4ce6ceeae00981c Mon Sep 17 00:00:00 2001
From: Karan Janthe <karanjanthe@gmail.com>
Date: Mon, 1 Sep 2025 06:17:34 +0000
Subject: [PATCH 1120/1889] autodiff: slice support in typetree

---
 compiler/rustc_middle/src/ty/mod.rs              |  7 +++++++
 .../autodiff/type-trees/slice-typetree/rmake.rs  |  9 +++++++++
 .../type-trees/slice-typetree/slice.check        |  4 ++++
 .../autodiff/type-trees/slice-typetree/test.rs   | 16 ++++++++++++++++
 4 files changed, 36 insertions(+)
 create mode 100644 tests/run-make/autodiff/type-trees/slice-typetree/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/slice-typetree/slice.check
 create mode 100644 tests/run-make/autodiff/type-trees/slice-typetree/test.rs

diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 02a4e4e2b1592..82a41f403f8b4 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -2327,5 +2327,12 @@ pub fn typetree_from_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> TypeTree {
         }
     }
 
+    if ty.is_slice() {
+        if let ty::Slice(element_ty) = ty.kind() {
+            let element_tree = typetree_from_ty(tcx, *element_ty);
+            return element_tree;
+        }
+    }
+
     TypeTree::new()
 }
diff --git a/tests/run-make/autodiff/type-trees/slice-typetree/rmake.rs b/tests/run-make/autodiff/type-trees/slice-typetree/rmake.rs
new file mode 100644
index 0000000000000..b81fb50bf1a75
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/slice-typetree/rmake.rs
@@ -0,0 +1,9 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    rustc().input("test.rs").arg("-Zautodiff=Enable").emit("llvm-ir").run();
+    llvm_filecheck().patterns("slice.check").stdin_buf(rfs::read("test.ll")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/slice-typetree/slice.check b/tests/run-make/autodiff/type-trees/slice-typetree/slice.check
new file mode 100644
index 0000000000000..8fc9e9c4f1b17
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/slice-typetree/slice.check
@@ -0,0 +1,4 @@
+; Check that slice TypeTree metadata is correctly generated
+; Should show Float@double for slice elements
+
+CHECK: define{{.*}}"enzyme_type"="{[]:Float@double}"{{.*}}@test_slice{{.*}}"enzyme_type"="{[]:Pointer}"
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/slice-typetree/test.rs b/tests/run-make/autodiff/type-trees/slice-typetree/test.rs
new file mode 100644
index 0000000000000..7117fa3844f59
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/slice-typetree/test.rs
@@ -0,0 +1,16 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_test, Duplicated, Active)]
+#[no_mangle]
+fn test_slice(slice: &[f64]) -> f64 {
+    slice.iter().sum()
+}
+
+fn main() {
+    let arr = [1.0, 2.0, 3.0, 4.0, 5.0];
+    let slice = &arr[..];
+    let mut d_slice = [0.0; 5];
+    let _result = d_test(slice, &mut d_slice[..], 1.0);
+}

From 7c5fbfbdbbb389462e0ffb936ba9b16cffbce6ed Mon Sep 17 00:00:00 2001
From: Karan Janthe <karanjanthe@gmail.com>
Date: Mon, 1 Sep 2025 16:14:31 +0000
Subject: [PATCH 1121/1889] autodiff: tuple support in typetree

---
 compiler/rustc_middle/src/ty/mod.rs           | 36 +++++++++++++++++++
 .../type-trees/tuple-typetree/rmake.rs        |  9 +++++
 .../type-trees/tuple-typetree/test.rs         | 15 ++++++++
 .../type-trees/tuple-typetree/tuple.check     |  4 +++
 4 files changed, 64 insertions(+)
 create mode 100644 tests/run-make/autodiff/type-trees/tuple-typetree/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/tuple-typetree/test.rs
 create mode 100644 tests/run-make/autodiff/type-trees/tuple-typetree/tuple.check

diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 82a41f403f8b4..c0a091551c9eb 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -2334,5 +2334,41 @@ pub fn typetree_from_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> TypeTree {
         }
     }
 
+    if let ty::Tuple(tuple_types) = ty.kind() {
+        if tuple_types.is_empty() {
+            return TypeTree::new();
+        }
+
+        let mut types = Vec::new();
+        let mut current_offset = 0;
+
+        for tuple_ty in tuple_types.iter() {
+            let element_tree = typetree_from_ty(tcx, tuple_ty);
+
+            let element_layout = tcx
+                .layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(tuple_ty))
+                .ok()
+                .map(|layout| layout.size.bytes_usize())
+                .unwrap_or(0);
+
+            for elem_type in &element_tree.0 {
+                types.push(Type {
+                    offset: if elem_type.offset == -1 {
+                        current_offset as isize
+                    } else {
+                        current_offset as isize + elem_type.offset
+                    },
+                    size: elem_type.size,
+                    kind: elem_type.kind,
+                    child: elem_type.child.clone(),
+                });
+            }
+
+            current_offset += element_layout;
+        }
+
+        return TypeTree(types);
+    }
+
     TypeTree::new()
 }
diff --git a/tests/run-make/autodiff/type-trees/tuple-typetree/rmake.rs b/tests/run-make/autodiff/type-trees/tuple-typetree/rmake.rs
new file mode 100644
index 0000000000000..76913828901c6
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/tuple-typetree/rmake.rs
@@ -0,0 +1,9 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    rustc().input("test.rs").arg("-Zautodiff=Enable").emit("llvm-ir").run();
+    llvm_filecheck().patterns("tuple.check").stdin_buf(rfs::read("test.ll")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/tuple-typetree/test.rs b/tests/run-make/autodiff/type-trees/tuple-typetree/test.rs
new file mode 100644
index 0000000000000..32187b587a383
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/tuple-typetree/test.rs
@@ -0,0 +1,15 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_test, Duplicated, Active)]
+#[no_mangle]
+fn test_tuple(tuple: &(f64, f64, f64)) -> f64 {
+    tuple.0 + tuple.1 * 2.0 + tuple.2 * 3.0
+}
+
+fn main() {
+    let tuple = (1.0, 2.0, 3.0);
+    let mut d_tuple = (0.0, 0.0, 0.0);
+    let _result = d_test(&tuple, &mut d_tuple, 1.0);
+}
diff --git a/tests/run-make/autodiff/type-trees/tuple-typetree/tuple.check b/tests/run-make/autodiff/type-trees/tuple-typetree/tuple.check
new file mode 100644
index 0000000000000..50aa25e96aedd
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/tuple-typetree/tuple.check
@@ -0,0 +1,4 @@
+; Check that tuple TypeTree metadata is correctly generated
+; Should show Float@double at offsets 0, 8, 16 for (f64, f64, f64)
+
+CHECK: define{{.*}}"enzyme_type"="{[]:Float@double}"{{.*}}@test_tuple{{.*}}"enzyme_type"="{[]:Pointer}"
\ No newline at end of file

From 574f0b97d6f30cd6cedb165fde13cdec176611b8 Mon Sep 17 00:00:00 2001
From: Karan Janthe <karanjanthe@gmail.com>
Date: Mon, 1 Sep 2025 16:28:14 +0000
Subject: [PATCH 1122/1889] autodiff: struct support in typetree

---
 compiler/rustc_middle/src/ty/mod.rs           | 32 +++++++++++++++++++
 .../type-trees/struct-typetree/rmake.rs       |  9 ++++++
 .../type-trees/struct-typetree/struct.check   |  4 +++
 .../type-trees/struct-typetree/test.rs        | 22 +++++++++++++
 4 files changed, 67 insertions(+)
 create mode 100644 tests/run-make/autodiff/type-trees/struct-typetree/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/struct-typetree/struct.check
 create mode 100644 tests/run-make/autodiff/type-trees/struct-typetree/test.rs

diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index c0a091551c9eb..703d417f96db9 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -2370,5 +2370,37 @@ pub fn typetree_from_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> TypeTree {
         return TypeTree(types);
     }
 
+    if let ty::Adt(adt_def, args) = ty.kind() {
+        if adt_def.is_struct() {
+            let struct_layout =
+                tcx.layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(ty));
+            if let Ok(layout) = struct_layout {
+                let mut types = Vec::new();
+
+                for (field_idx, field_def) in adt_def.all_fields().enumerate() {
+                    let field_ty = field_def.ty(tcx, args);
+                    let field_tree = typetree_from_ty(tcx, field_ty);
+
+                    let field_offset = layout.fields.offset(field_idx).bytes_usize();
+
+                    for elem_type in &field_tree.0 {
+                        types.push(Type {
+                            offset: if elem_type.offset == -1 {
+                                field_offset as isize
+                            } else {
+                                field_offset as isize + elem_type.offset
+                            },
+                            size: elem_type.size,
+                            kind: elem_type.kind,
+                            child: elem_type.child.clone(),
+                        });
+                    }
+                }
+
+                return TypeTree(types);
+            }
+        }
+    }
+
     TypeTree::new()
 }
diff --git a/tests/run-make/autodiff/type-trees/struct-typetree/rmake.rs b/tests/run-make/autodiff/type-trees/struct-typetree/rmake.rs
new file mode 100644
index 0000000000000..0af1b65ee181b
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/struct-typetree/rmake.rs
@@ -0,0 +1,9 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    rustc().input("test.rs").arg("-Zautodiff=Enable").emit("llvm-ir").run();
+    llvm_filecheck().patterns("struct.check").stdin_buf(rfs::read("test.ll")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/struct-typetree/struct.check b/tests/run-make/autodiff/type-trees/struct-typetree/struct.check
new file mode 100644
index 0000000000000..2f763f18c1cee
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/struct-typetree/struct.check
@@ -0,0 +1,4 @@
+; Check that struct TypeTree metadata is correctly generated
+; Should show Float@double at offsets 0, 8, 16 for Point struct fields
+
+CHECK: define{{.*}}"enzyme_type"="{[]:Float@double}"{{.*}}@test_struct{{.*}}"enzyme_type"="{[]:Pointer}"
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/struct-typetree/test.rs b/tests/run-make/autodiff/type-trees/struct-typetree/test.rs
new file mode 100644
index 0000000000000..cbe7b10e40974
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/struct-typetree/test.rs
@@ -0,0 +1,22 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[repr(C)]
+struct Point {
+    x: f64,
+    y: f64,
+    z: f64,
+}
+
+#[autodiff_reverse(d_test, Duplicated, Active)]
+#[no_mangle]
+fn test_struct(point: &Point) -> f64 {
+    point.x + point.y * 2.0 + point.z * 3.0
+}
+
+fn main() {
+    let point = Point { x: 1.0, y: 2.0, z: 3.0 };
+    let mut d_point = Point { x: 0.0, y: 0.0, z: 0.0 };
+    let _result = d_test(&point, &mut d_point, 1.0);
+}

From 4f3f0f48e7b1e61818b2bcbe4451f89bb4f47049 Mon Sep 17 00:00:00 2001
From: Karan Janthe <karanjanthe@gmail.com>
Date: Thu, 4 Sep 2025 11:17:34 +0000
Subject: [PATCH 1123/1889] autodiff: fixed test to be more precise for type
 tree checking

---
 .../rustc_codegen_llvm/src/llvm/enzyme_ffi.rs | 23 ++++++
 compiler/rustc_codegen_llvm/src/typetree.rs   | 70 ++++++++-----------
 compiler/rustc_middle/src/ty/mod.rs           | 36 +++-------
 .../type-trees/array-typetree/array.check     |  2 +-
 .../memcpy-typetree/memcpy-ir.check           |  2 +-
 .../mixed-struct-typetree/mixed.check         |  2 +
 .../type-trees/mixed-struct-typetree/rmake.rs | 16 +++++
 .../type-trees/mixed-struct-typetree/test.rs  | 23 ++++++
 .../type-trees/nott-flag/with_tt.check        |  2 +-
 .../scalar-types/f128-typetree/f128.check     |  4 +-
 .../scalar-types/f16-typetree/f16.check       |  4 +-
 .../scalar-types/f32-typetree/f32.check       |  2 +-
 .../scalar-types/f64-typetree/f64.check       |  2 +-
 .../scalar-types/i32-typetree/i32.check       |  4 +-
 .../scalar-types/i32-typetree/test.rs         |  7 +-
 .../type-trees/slice-typetree/slice.check     |  2 +-
 .../type-trees/struct-typetree/struct.check   |  2 +-
 .../type-trees/tuple-typetree/tuple.check     |  2 +-
 .../type-trees/type-analysis/vec/vec.check    |  2 +-
 19 files changed, 120 insertions(+), 87 deletions(-)
 create mode 100644 tests/run-make/autodiff/type-trees/mixed-struct-typetree/mixed.check
 create mode 100644 tests/run-make/autodiff/type-trees/mixed-struct-typetree/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/mixed-struct-typetree/test.rs

diff --git a/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
index 1596dc4837978..e63043b21227f 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
@@ -118,6 +118,13 @@ pub(crate) mod Enzyme_AD {
             max_size: i64,
             add_offset: u64,
         );
+        pub(crate) fn EnzymeTypeTreeInsertEq(
+            CTT: CTypeTreeRef,
+            indices: *const i64,
+            len: usize,
+            ct: CConcreteType,
+            ctx: &Context,
+        );
         pub(crate) fn EnzymeTypeTreeToString(arg1: CTypeTreeRef) -> *const c_char;
         pub(crate) fn EnzymeTypeTreeToStringFree(arg1: *const c_char);
     }
@@ -234,6 +241,16 @@ pub(crate) mod Fallback_AD {
         unimplemented!()
     }
 
+    pub(crate) unsafe fn EnzymeTypeTreeInsertEq(
+        CTT: CTypeTreeRef,
+        indices: *const i64,
+        len: usize,
+        ct: CConcreteType,
+        ctx: &Context,
+    ) {
+        unimplemented!()
+    }
+
     pub(crate) unsafe fn EnzymeTypeTreeToString(arg1: CTypeTreeRef) -> *const c_char {
         unimplemented!()
     }
@@ -312,6 +329,12 @@ impl TypeTree {
 
         self
     }
+
+    pub(crate) fn insert(&mut self, indices: &[i64], ct: CConcreteType, ctx: &Context) {
+        unsafe {
+            EnzymeTypeTreeInsertEq(self.inner, indices.as_ptr(), indices.len(), ct, ctx);
+        }
+    }
 }
 
 impl Clone for TypeTree {
diff --git a/compiler/rustc_codegen_llvm/src/typetree.rs b/compiler/rustc_codegen_llvm/src/typetree.rs
index 8c0d255bba84e..ae6a2da62b5dd 100644
--- a/compiler/rustc_codegen_llvm/src/typetree.rs
+++ b/compiler/rustc_codegen_llvm/src/typetree.rs
@@ -8,22 +8,24 @@ use {
 
 use crate::llvm::{self, Value};
 
-/// Converts a Rust TypeTree to Enzyme's internal TypeTree format
-///
-/// This function takes a Rust-side TypeTree (from rustc_ast::expand::typetree)
-/// and converts it to Enzyme's internal C++ TypeTree representation that
-/// Enzyme can understand during differentiation analysis.
 #[cfg(llvm_enzyme)]
 fn to_enzyme_typetree(
     rust_typetree: RustTypeTree,
-    data_layout: &str,
+    _data_layout: &str,
     llcx: &llvm::Context,
 ) -> llvm::TypeTree {
-    // Start with an empty TypeTree
     let mut enzyme_tt = llvm::TypeTree::new();
-
-    // Convert each Type in the Rust TypeTree to Enzyme format
-    for rust_type in rust_typetree.0 {
+    process_typetree_recursive(&mut enzyme_tt, &rust_typetree, &[], llcx);
+    enzyme_tt
+}
+#[cfg(llvm_enzyme)]
+fn process_typetree_recursive(
+    enzyme_tt: &mut llvm::TypeTree,
+    rust_typetree: &RustTypeTree,
+    parent_indices: &[i64],
+    llcx: &llvm::Context,
+) {
+    for rust_type in &rust_typetree.0 {
         let concrete_type = match rust_type.kind {
             rustc_ast::expand::typetree::Kind::Anything => llvm::CConcreteType::DT_Anything,
             rustc_ast::expand::typetree::Kind::Integer => llvm::CConcreteType::DT_Integer,
@@ -35,25 +37,27 @@ fn to_enzyme_typetree(
             rustc_ast::expand::typetree::Kind::Unknown => llvm::CConcreteType::DT_Unknown,
         };
 
-        // Create a TypeTree for this specific type
-        let type_tt = llvm::TypeTree::from_type(concrete_type, llcx);
-
-        // Apply offset if specified
-        let type_tt = if rust_type.offset == -1 {
-            type_tt // -1 means everywhere/no specific offset
+        let mut indices = parent_indices.to_vec();
+        if !parent_indices.is_empty() {
+            if rust_type.offset == -1 {
+                indices.push(-1);
+            } else {
+                indices.push(rust_type.offset as i64);
+            }
+        } else if rust_type.offset == -1 {
+            indices.push(-1);
         } else {
-            // Apply specific offset positioning
-            type_tt.shift(data_layout, rust_type.offset, rust_type.size as isize, 0)
-        };
+            indices.push(rust_type.offset as i64);
+        }
 
-        // Merge this type into the main TypeTree
-        enzyme_tt = enzyme_tt.merge(type_tt);
-    }
+        enzyme_tt.insert(&indices, concrete_type, llcx);
 
-    enzyme_tt
+        if rust_type.kind == rustc_ast::expand::typetree::Kind::Pointer && !rust_type.child.0.is_empty() {
+            process_typetree_recursive(enzyme_tt, &rust_type.child, &indices, llcx);
+        }
+    }
 }
 
-// Attaches TypeTree information to LLVM function as enzyme_type attributes.
 #[cfg(llvm_enzyme)]
 pub(crate) fn add_tt<'ll>(
     llmod: &'ll llvm::Module,
@@ -64,28 +68,20 @@ pub(crate) fn add_tt<'ll>(
     let inputs = tt.args;
     let ret_tt: RustTypeTree = tt.ret;
 
-    // Get LLVM data layout string for TypeTree conversion
     let llvm_data_layout: *const c_char = unsafe { llvm::LLVMGetDataLayoutStr(&*llmod) };
     let llvm_data_layout =
         std::str::from_utf8(unsafe { std::ffi::CStr::from_ptr(llvm_data_layout) }.to_bytes())
             .expect("got a non-UTF8 data-layout from LLVM");
 
-    // Attribute name that Enzyme recognizes for TypeTree information
     let attr_name = "enzyme_type";
     let c_attr_name = CString::new(attr_name).unwrap();
 
-    // Attach TypeTree attributes to each input parameter
-    // Enzyme uses these to understand parameter memory layouts during differentiation
     for (i, input) in inputs.iter().enumerate() {
         unsafe {
-            // Convert Rust TypeTree to Enzyme's internal format
             let enzyme_tt = to_enzyme_typetree(input.clone(), llvm_data_layout, llcx);
-
-            // Serialize TypeTree to string format that Enzyme can parse
             let c_str = llvm::EnzymeTypeTreeToString(enzyme_tt.inner);
             let c_str = std::ffi::CStr::from_ptr(c_str);
 
-            // Create LLVM string attribute with TypeTree information
             let attr = llvm::LLVMCreateStringAttribute(
                 llcx,
                 c_attr_name.as_ptr(),
@@ -94,17 +90,11 @@ pub(crate) fn add_tt<'ll>(
                 c_str.to_bytes().len() as c_uint,
             );
 
-            // Attach attribute to the specific function parameter
-            // Note: ArgumentPlace uses 0-based indexing, but LLVM uses 1-based for arguments
             attributes::apply_to_llfn(fn_def, llvm::AttributePlace::Argument(i as u32), &[attr]);
-
-            // Free the C string to prevent memory leaks
             llvm::EnzymeTypeTreeToStringFree(c_str.as_ptr());
         }
     }
 
-    // Attach TypeTree attribute to the return type
-    // Enzyme needs this to understand how to handle return value derivatives
     unsafe {
         let enzyme_tt = to_enzyme_typetree(ret_tt, llvm_data_layout, llcx);
         let c_str = llvm::EnzymeTypeTreeToString(enzyme_tt.inner);
@@ -118,15 +108,11 @@ pub(crate) fn add_tt<'ll>(
             c_str.to_bytes().len() as c_uint,
         );
 
-        // Attach to function return type
         attributes::apply_to_llfn(fn_def, llvm::AttributePlace::ReturnValue, &[ret_attr]);
-
-        // Free the C string
         llvm::EnzymeTypeTreeToStringFree(c_str.as_ptr());
     }
 }
 
-// Fallback implementation when Enzyme is not available
 #[cfg(not(llvm_enzyme))]
 pub(crate) fn add_tt<'ll>(
     _llmod: &'ll llvm::Module,
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 703d417f96db9..581f20e8492d9 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -2261,10 +2261,10 @@ pub fn typetree_from_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> TypeTree {
                 x if x == tcx.types.f32 => (Kind::Float, 4),
                 x if x == tcx.types.f64 => (Kind::Double, 8),
                 x if x == tcx.types.f128 => (Kind::F128, 16),
-                _ => return TypeTree::new(),
+                _ => (Kind::Integer, 0),
             }
         } else {
-            return TypeTree::new();
+            (Kind::Integer, 0)
         };
 
         return TypeTree(vec![Type { offset: -1, size, kind, child: TypeTree::new() }]);
@@ -2295,32 +2295,14 @@ pub fn typetree_from_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> TypeTree {
 
             let element_tree = typetree_from_ty(tcx, *element_ty);
 
-            let element_layout = tcx
-                .layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(*element_ty))
-                .ok()
-                .map(|layout| layout.size.bytes_usize())
-                .unwrap_or(0);
-
-            if element_layout == 0 {
-                return TypeTree::new();
-            }
-
             let mut types = Vec::new();
-            for i in 0..len {
-                let base_offset = (i as usize * element_layout) as isize;
-
-                for elem_type in &element_tree.0 {
-                    types.push(Type {
-                        offset: if elem_type.offset == -1 {
-                            base_offset
-                        } else {
-                            base_offset + elem_type.offset
-                        },
-                        size: elem_type.size,
-                        kind: elem_type.kind,
-                        child: elem_type.child.clone(),
-                    });
-                }
+            for elem_type in &element_tree.0 {
+                types.push(Type {
+                    offset: -1,
+                    size: elem_type.size,
+                    kind: elem_type.kind,
+                    child: elem_type.child.clone(),
+                });
             }
 
             return TypeTree(types);
diff --git a/tests/run-make/autodiff/type-trees/array-typetree/array.check b/tests/run-make/autodiff/type-trees/array-typetree/array.check
index 7513458b8ab81..0d38bdec17e84 100644
--- a/tests/run-make/autodiff/type-trees/array-typetree/array.check
+++ b/tests/run-make/autodiff/type-trees/array-typetree/array.check
@@ -1,4 +1,4 @@
 ; Check that array TypeTree metadata is correctly generated  
 ; Should show Float@double at each array element offset (0, 8, 16, 24, 32 bytes)
 
-CHECK: define{{.*}}"enzyme_type"="{[]:Float@double}"{{.*}}@test_array{{.*}}"enzyme_type"="{[]:Pointer}"
\ No newline at end of file
+CHECK: define{{.*}}"enzyme_type"="{[-1]:Float@double}"{{.*}}@test_array{{.*}}"enzyme_type"="{[-1]:Pointer, [-1,-1]:Float@double}"
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/memcpy-typetree/memcpy-ir.check b/tests/run-make/autodiff/type-trees/memcpy-typetree/memcpy-ir.check
index 3a59f06dda1e4..0e6351ac4d39d 100644
--- a/tests/run-make/autodiff/type-trees/memcpy-typetree/memcpy-ir.check
+++ b/tests/run-make/autodiff/type-trees/memcpy-typetree/memcpy-ir.check
@@ -1,7 +1,7 @@
 ; Check that enzyme_type attributes are present in the LLVM IR function definition
 ; This verifies our TypeTree system correctly attaches metadata for Enzyme
 
-CHECK: define{{.*}}"enzyme_type"="{[]:Float@double}"{{.*}}@test_memcpy({{.*}}"enzyme_type"="{[]:Pointer}"
+CHECK: define{{.*}}"enzyme_type"="{[-1]:Float@double}"{{.*}}@test_memcpy({{.*}}"enzyme_type"="{[-1]:Pointer, [-1,-1]:Float@double}"
 
 ; Check that llvm.memcpy exists (either call or declare)
 CHECK: {{(call|declare).*}}@llvm.memcpy
diff --git a/tests/run-make/autodiff/type-trees/mixed-struct-typetree/mixed.check b/tests/run-make/autodiff/type-trees/mixed-struct-typetree/mixed.check
new file mode 100644
index 0000000000000..584f584084358
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/mixed-struct-typetree/mixed.check
@@ -0,0 +1,2 @@
+; Check that mixed struct with large array generates correct detailed type tree
+CHECK: define{{.*}}"enzyme_type"="{[-1]:Float@float}"{{.*}}@test_mixed_struct{{.*}}"enzyme_type"="{[-1]:Pointer, [-1,0]:Integer, [-1,8]:Float@float}"
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/mixed-struct-typetree/rmake.rs b/tests/run-make/autodiff/type-trees/mixed-struct-typetree/rmake.rs
new file mode 100644
index 0000000000000..1c19963bc3612
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/mixed-struct-typetree/rmake.rs
@@ -0,0 +1,16 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    rustc()
+        .input("test.rs")
+        .arg("-Zautodiff=Enable")
+        .arg("-Zautodiff=NoPostopt")
+        .opt_level("0")
+        .emit("llvm-ir")
+        .run();
+
+    llvm_filecheck().patterns("mixed.check").stdin_buf(rfs::read("test.ll")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/mixed-struct-typetree/test.rs b/tests/run-make/autodiff/type-trees/mixed-struct-typetree/test.rs
new file mode 100644
index 0000000000000..7a734980e617c
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/mixed-struct-typetree/test.rs
@@ -0,0 +1,23 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[repr(C)]
+struct Container {
+    header: i64,
+    data: [f32; 1000],
+}
+
+#[autodiff_reverse(d_test, Duplicated, Active)]
+#[no_mangle]
+#[inline(never)]
+fn test_mixed_struct(container: &Container) -> f32 {
+    container.data[0] + container.data[999]
+}
+
+fn main() {
+    let container = Container { header: 42, data: [1.0; 1000] };
+    let mut d_container = Container { header: 0, data: [0.0; 1000] };
+    let result = d_test(&container, &mut d_container, 1.0);
+    std::hint::black_box(result);
+}
diff --git a/tests/run-make/autodiff/type-trees/nott-flag/with_tt.check b/tests/run-make/autodiff/type-trees/nott-flag/with_tt.check
index 53eafc10a65da..3c02003c88287 100644
--- a/tests/run-make/autodiff/type-trees/nott-flag/with_tt.check
+++ b/tests/run-make/autodiff/type-trees/nott-flag/with_tt.check
@@ -1,4 +1,4 @@
 // Check that enzyme_type attributes are present when TypeTree is enabled
 // This verifies our TypeTree metadata attachment is working
 
-CHECK: define{{.*}}"enzyme_type"="{[]:Float@double}"{{.*}}@square{{.*}}"enzyme_type"="{[]:Pointer}"
\ No newline at end of file
+CHECK: define{{.*}}"enzyme_type"="{[-1]:Float@double}"{{.*}}@square{{.*}}"enzyme_type"="{[-1]:Pointer, [-1,-1]:Float@double}"
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/scalar-types/f128-typetree/f128.check b/tests/run-make/autodiff/type-trees/scalar-types/f128-typetree/f128.check
index 31cef113420db..733e46aa45a57 100644
--- a/tests/run-make/autodiff/type-trees/scalar-types/f128-typetree/f128.check
+++ b/tests/run-make/autodiff/type-trees/scalar-types/f128-typetree/f128.check
@@ -1,4 +1,4 @@
 ; Check that f128 TypeTree metadata is correctly generated
-; f128 maps to Unknown in our current implementation since CConcreteType doesn't have DT_F128
+; Should show Float@fp128 for f128 values and Pointer for references
 
-CHECK: define{{.*}}"enzyme_type"={{.*}}@test_f128{{.*}}"enzyme_type"="{[]:Pointer}"
\ No newline at end of file
+CHECK: define{{.*}}"enzyme_type"="{[-1]:Float@fp128}"{{.*}}@test_f128{{.*}}"enzyme_type"="{[-1]:Pointer, [-1,-1]:Float@fp128}"
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/scalar-types/f16-typetree/f16.check b/tests/run-make/autodiff/type-trees/scalar-types/f16-typetree/f16.check
index 97a3964a569b1..9caca26b5cf51 100644
--- a/tests/run-make/autodiff/type-trees/scalar-types/f16-typetree/f16.check
+++ b/tests/run-make/autodiff/type-trees/scalar-types/f16-typetree/f16.check
@@ -1,4 +1,4 @@
 ; Check that f16 TypeTree metadata is correctly generated
-; Should show Half for f16 values and Pointer for references
+; Should show Float@half for f16 values and Pointer for references
 
-CHECK: define{{.*}}"enzyme_type"={{.*}}@test_f16{{.*}}"enzyme_type"="{[]:Pointer}"
\ No newline at end of file
+CHECK: define{{.*}}"enzyme_type"="{[-1]:Float@half}"{{.*}}@test_f16{{.*}}"enzyme_type"="{[-1]:Pointer, [-1,-1]:Float@half}"
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/scalar-types/f32-typetree/f32.check b/tests/run-make/autodiff/type-trees/scalar-types/f32-typetree/f32.check
index b32d5086d07d1..ec12ba6b2348d 100644
--- a/tests/run-make/autodiff/type-trees/scalar-types/f32-typetree/f32.check
+++ b/tests/run-make/autodiff/type-trees/scalar-types/f32-typetree/f32.check
@@ -1,4 +1,4 @@
 ; Check that f32 TypeTree metadata is correctly generated
 ; Should show Float@float for f32 values and Pointer for references
 
-CHECK: define{{.*}}"enzyme_type"="{[]:Float@float}"{{.*}}@test_f32{{.*}}"enzyme_type"="{[]:Pointer}"
\ No newline at end of file
+CHECK: define{{.*}}"enzyme_type"="{[-1]:Float@float}"{{.*}}@test_f32{{.*}}"enzyme_type"="{[-1]:Pointer, [-1,-1]:Float@float}"
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/scalar-types/f64-typetree/f64.check b/tests/run-make/autodiff/type-trees/scalar-types/f64-typetree/f64.check
index 0e9d9c03a0f86..f1af270824d57 100644
--- a/tests/run-make/autodiff/type-trees/scalar-types/f64-typetree/f64.check
+++ b/tests/run-make/autodiff/type-trees/scalar-types/f64-typetree/f64.check
@@ -1,4 +1,4 @@
 ; Check that f64 TypeTree metadata is correctly generated  
 ; Should show Float@double for f64 values and Pointer for references
 
-CHECK: define{{.*}}"enzyme_type"="{[]:Float@double}"{{.*}}@test_f64{{.*}}"enzyme_type"="{[]:Pointer}"
\ No newline at end of file
+CHECK: define{{.*}}"enzyme_type"="{[-1]:Float@double}"{{.*}}@test_f64{{.*}}"enzyme_type"="{[-1]:Pointer, [-1,-1]:Float@double}"
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/scalar-types/i32-typetree/i32.check b/tests/run-make/autodiff/type-trees/scalar-types/i32-typetree/i32.check
index aa8e5223e8ed5..fd9a94be8100b 100644
--- a/tests/run-make/autodiff/type-trees/scalar-types/i32-typetree/i32.check
+++ b/tests/run-make/autodiff/type-trees/scalar-types/i32-typetree/i32.check
@@ -1,4 +1,4 @@
 ; Check that i32 TypeTree metadata is correctly generated
-; Should show Integer for i32 values (integers are typically Const in autodiff)
+; Should show Integer for i32 values and Pointer for references
 
-CHECK: define{{.*}}"enzyme_type"="{[]:Integer}"{{.*}}@test_i32{{.*}}"enzyme_type"="{[]:Integer}"
\ No newline at end of file
+CHECK: define{{.*}}"enzyme_type"="{[-1]:Integer}"{{.*}}@test_i32{{.*}}"enzyme_type"="{[-1]:Pointer, [-1,-1]:Integer}"
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/scalar-types/i32-typetree/test.rs b/tests/run-make/autodiff/type-trees/scalar-types/i32-typetree/test.rs
index 530c137f62b9c..249803c5d9f7a 100644
--- a/tests/run-make/autodiff/type-trees/scalar-types/i32-typetree/test.rs
+++ b/tests/run-make/autodiff/type-trees/scalar-types/i32-typetree/test.rs
@@ -2,13 +2,14 @@
 
 use std::autodiff::autodiff_reverse;
 
-#[autodiff_reverse(d_test, Const, Active)]
+#[autodiff_reverse(d_test, Duplicated, Active)]
 #[no_mangle]
-fn test_i32(x: i32) -> i32 {
+fn test_i32(x: &i32) -> i32 {
     x * x
 }
 
 fn main() {
     let x = 5_i32;
-    let _result = d_test(x, 1);
+    let mut dx = 0_i32;
+    let _result = d_test(&x, &mut dx, 1);
 }
diff --git a/tests/run-make/autodiff/type-trees/slice-typetree/slice.check b/tests/run-make/autodiff/type-trees/slice-typetree/slice.check
index 8fc9e9c4f1b17..6543b61611538 100644
--- a/tests/run-make/autodiff/type-trees/slice-typetree/slice.check
+++ b/tests/run-make/autodiff/type-trees/slice-typetree/slice.check
@@ -1,4 +1,4 @@
 ; Check that slice TypeTree metadata is correctly generated
 ; Should show Float@double for slice elements
 
-CHECK: define{{.*}}"enzyme_type"="{[]:Float@double}"{{.*}}@test_slice{{.*}}"enzyme_type"="{[]:Pointer}"
\ No newline at end of file
+CHECK: define{{.*}}"enzyme_type"="{[-1]:Float@double}"{{.*}}@test_slice{{.*}}"enzyme_type"="{[-1]:Pointer, [-1,-1]:Float@double}"
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/struct-typetree/struct.check b/tests/run-make/autodiff/type-trees/struct-typetree/struct.check
index 2f763f18c1cee..54956317e1e95 100644
--- a/tests/run-make/autodiff/type-trees/struct-typetree/struct.check
+++ b/tests/run-make/autodiff/type-trees/struct-typetree/struct.check
@@ -1,4 +1,4 @@
 ; Check that struct TypeTree metadata is correctly generated
 ; Should show Float@double at offsets 0, 8, 16 for Point struct fields
 
-CHECK: define{{.*}}"enzyme_type"="{[]:Float@double}"{{.*}}@test_struct{{.*}}"enzyme_type"="{[]:Pointer}"
\ No newline at end of file
+CHECK: define{{.*}}"enzyme_type"="{[-1]:Float@double}"{{.*}}@test_struct{{.*}}"enzyme_type"="{[-1]:Pointer, [-1,0]:Float@double, [-1,8]:Float@double, [-1,16]:Float@double}"
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/tuple-typetree/tuple.check b/tests/run-make/autodiff/type-trees/tuple-typetree/tuple.check
index 50aa25e96aedd..47647e78cc35c 100644
--- a/tests/run-make/autodiff/type-trees/tuple-typetree/tuple.check
+++ b/tests/run-make/autodiff/type-trees/tuple-typetree/tuple.check
@@ -1,4 +1,4 @@
 ; Check that tuple TypeTree metadata is correctly generated
 ; Should show Float@double at offsets 0, 8, 16 for (f64, f64, f64)
 
-CHECK: define{{.*}}"enzyme_type"="{[]:Float@double}"{{.*}}@test_tuple{{.*}}"enzyme_type"="{[]:Pointer}"
\ No newline at end of file
+CHECK: define{{.*}}"enzyme_type"="{[-1]:Float@double}"{{.*}}@test_tuple{{.*}}"enzyme_type"="{[-1]:Pointer, [-1,0]:Float@double, [-1,8]:Float@double, [-1,16]:Float@double}"
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/vec/vec.check b/tests/run-make/autodiff/type-trees/type-analysis/vec/vec.check
index dcf9508b69d6f..cdb70eb83fc19 100644
--- a/tests/run-make/autodiff/type-trees/type-analysis/vec/vec.check
+++ b/tests/run-make/autodiff/type-trees/type-analysis/vec/vec.check
@@ -1,7 +1,7 @@
 // CHECK: callee - {[-1]:Float@float} |{[-1]:Pointer}:{}
 // CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer}
 // CHECK-DAG: %{{[0-9]+}} = getelementptr inbounds nuw i8, ptr %{{[0-9]+}}, i64 8, !dbg !{{[0-9]+}}: {[-1]:Pointer}
-// CHECK-DAG: %{{[0-9]+}} = load ptr, ptr %{{[0-9]+}}, align 8, !dbg !{{[0-9]+}}, !nonnull !102, !noundef !{{[0-9]+}}: {}
+// CHECK-DAG: %{{[0-9]+}} = load ptr, ptr %{{[0-9]+}}, align 8, !dbg !{{[0-9]+}}, !nonnull !{{[0-9]+}}, !noundef !{{[0-9]+}}: {}
 // CHECK-DAG: %{{[0-9]+}} = getelementptr inbounds nuw i8, ptr %{{[0-9]+}}, i64 16, !dbg !{{[0-9]+}}: {[-1]:Pointer}
 // CHECK-DAG: %{{[0-9]+}} = load i64, ptr %{{[0-9]+}}, align 8, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {}
 // CHECK-DAG: %{{[0-9]+}} = icmp eq i64 %{{[0-9]+}}, 0, !dbg !{{[0-9]+}}: {[-1]:Integer}

From 4520926bb527bd43edbf0de84c2b0c6a9c5fc5ce Mon Sep 17 00:00:00 2001
From: Karan Janthe <karanjanthe@gmail.com>
Date: Thu, 11 Sep 2025 07:30:35 +0000
Subject: [PATCH 1124/1889] autodiff: recurion added for typetree

---
 .../rustc_codegen_llvm/src/llvm/enzyme_ffi.rs |   1 +
 compiler/rustc_codegen_llvm/src/typetree.rs   |  10 +-
 compiler/rustc_middle/src/ty/mod.rs           |  76 +++++++++++--
 .../type-trees/nott-flag/with_tt.check        |   2 +-
 .../recursion-typetree/recursion.check        |   3 +
 .../type-trees/recursion-typetree/rmake.rs    |   9 ++
 .../type-trees/recursion-typetree/test.rs     | 100 ++++++++++++++++++
 .../scalar-types/f128-typetree/f128.check     |   2 +-
 .../scalar-types/f16-typetree/f16.check       |   2 +-
 .../scalar-types/f32-typetree/f32.check       |   2 +-
 .../scalar-types/f64-typetree/f64.check       |   2 +-
 .../scalar-types/i32-typetree/i32.check       |   2 +-
 12 files changed, 191 insertions(+), 20 deletions(-)
 create mode 100644 tests/run-make/autodiff/type-trees/recursion-typetree/recursion.check
 create mode 100644 tests/run-make/autodiff/type-trees/recursion-typetree/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/recursion-typetree/test.rs

diff --git a/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
index e63043b21227f..b604f5139c8c1 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
@@ -127,6 +127,7 @@ pub(crate) mod Enzyme_AD {
         );
         pub(crate) fn EnzymeTypeTreeToString(arg1: CTypeTreeRef) -> *const c_char;
         pub(crate) fn EnzymeTypeTreeToStringFree(arg1: *const c_char);
+        pub(crate) fn EnzymeGetMaxTypeDepth() -> ::std::os::raw::c_uint;
     }
 
     unsafe extern "C" {
diff --git a/compiler/rustc_codegen_llvm/src/typetree.rs b/compiler/rustc_codegen_llvm/src/typetree.rs
index ae6a2da62b5dd..1a54884f6c5a4 100644
--- a/compiler/rustc_codegen_llvm/src/typetree.rs
+++ b/compiler/rustc_codegen_llvm/src/typetree.rs
@@ -39,11 +39,7 @@ fn process_typetree_recursive(
 
         let mut indices = parent_indices.to_vec();
         if !parent_indices.is_empty() {
-            if rust_type.offset == -1 {
-                indices.push(-1);
-            } else {
-                indices.push(rust_type.offset as i64);
-            }
+            indices.push(rust_type.offset as i64);
         } else if rust_type.offset == -1 {
             indices.push(-1);
         } else {
@@ -52,7 +48,9 @@ fn process_typetree_recursive(
 
         enzyme_tt.insert(&indices, concrete_type, llcx);
 
-        if rust_type.kind == rustc_ast::expand::typetree::Kind::Pointer && !rust_type.child.0.is_empty() {
+        if rust_type.kind == rustc_ast::expand::typetree::Kind::Pointer
+            && !rust_type.child.0.is_empty()
+        {
             process_typetree_recursive(enzyme_tt, &rust_type.child, &indices, llcx);
         }
     }
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 581f20e8492d9..7ca2355947ad4 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -2252,6 +2252,61 @@ pub fn fnc_typetrees<'tcx>(tcx: TyCtxt<'tcx>, fn_ty: Ty<'tcx>) -> FncTree {
 /// Generate TypeTree for a specific type.
 /// This function analyzes a Rust type and creates appropriate TypeTree metadata.
 pub fn typetree_from_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> TypeTree {
+    let mut visited = Vec::new();
+    typetree_from_ty_inner(tcx, ty, 0, &mut visited)
+}
+
+/// Internal recursive function for TypeTree generation with cycle detection and depth limiting.
+fn typetree_from_ty_inner<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    ty: Ty<'tcx>,
+    depth: usize,
+    visited: &mut Vec<Ty<'tcx>>,
+) -> TypeTree {
+    #[cfg(llvm_enzyme)]
+    {
+        unsafe extern "C" {
+            fn EnzymeGetMaxTypeDepth() -> ::std::os::raw::c_uint;
+        }
+        let max_depth = unsafe { EnzymeGetMaxTypeDepth() } as usize;
+        if depth > max_depth {
+            return TypeTree::new();
+        }
+    }
+
+    #[cfg(not(llvm_enzyme))]
+    if depth > 6 {
+        return TypeTree::new();
+    }
+
+    if visited.contains(&ty) {
+        return TypeTree::new();
+    }
+
+    visited.push(ty);
+    let result = typetree_from_ty_impl(tcx, ty, depth, visited);
+    visited.pop();
+    result
+}
+
+/// Implementation of TypeTree generation logic.
+fn typetree_from_ty_impl<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    ty: Ty<'tcx>,
+    depth: usize,
+    visited: &mut Vec<Ty<'tcx>>,
+) -> TypeTree {
+    typetree_from_ty_impl_inner(tcx, ty, depth, visited, false)
+}
+
+/// Internal implementation with context about whether this is for a reference target.
+fn typetree_from_ty_impl_inner<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    ty: Ty<'tcx>,
+    depth: usize,
+    visited: &mut Vec<Ty<'tcx>>,
+    is_reference_target: bool,
+) -> TypeTree {
     if ty.is_scalar() {
         let (kind, size) = if ty.is_integral() || ty.is_char() || ty.is_bool() {
             (Kind::Integer, ty.primitive_size(tcx).bytes_usize())
@@ -2267,7 +2322,10 @@ pub fn typetree_from_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> TypeTree {
             (Kind::Integer, 0)
         };
 
-        return TypeTree(vec![Type { offset: -1, size, kind, child: TypeTree::new() }]);
+        // Use offset 0 for scalars that are direct targets of references (like &f64)
+        // Use offset -1 for scalars used directly (like function return types)
+        let offset = if is_reference_target && !ty.is_array() { 0 } else { -1 };
+        return TypeTree(vec![Type { offset, size, kind, child: TypeTree::new() }]);
     }
 
     if ty.is_ref() || ty.is_raw_ptr() || ty.is_box() {
@@ -2277,7 +2335,7 @@ pub fn typetree_from_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> TypeTree {
             return TypeTree::new();
         };
 
-        let child = typetree_from_ty(tcx, inner_ty);
+        let child = typetree_from_ty_impl_inner(tcx, inner_ty, depth + 1, visited, true);
         return TypeTree(vec![Type {
             offset: -1,
             size: tcx.data_layout.pointer_size().bytes_usize(),
@@ -2292,9 +2350,8 @@ pub fn typetree_from_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> TypeTree {
             if len == 0 {
                 return TypeTree::new();
             }
-
-            let element_tree = typetree_from_ty(tcx, *element_ty);
-
+            let element_tree =
+                typetree_from_ty_impl_inner(tcx, *element_ty, depth + 1, visited, false);
             let mut types = Vec::new();
             for elem_type in &element_tree.0 {
                 types.push(Type {
@@ -2311,7 +2368,8 @@ pub fn typetree_from_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> TypeTree {
 
     if ty.is_slice() {
         if let ty::Slice(element_ty) = ty.kind() {
-            let element_tree = typetree_from_ty(tcx, *element_ty);
+            let element_tree =
+                typetree_from_ty_impl_inner(tcx, *element_ty, depth + 1, visited, false);
             return element_tree;
         }
     }
@@ -2325,7 +2383,8 @@ pub fn typetree_from_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> TypeTree {
         let mut current_offset = 0;
 
         for tuple_ty in tuple_types.iter() {
-            let element_tree = typetree_from_ty(tcx, tuple_ty);
+            let element_tree =
+                typetree_from_ty_impl_inner(tcx, tuple_ty, depth + 1, visited, false);
 
             let element_layout = tcx
                 .layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(tuple_ty))
@@ -2361,7 +2420,8 @@ pub fn typetree_from_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> TypeTree {
 
                 for (field_idx, field_def) in adt_def.all_fields().enumerate() {
                     let field_ty = field_def.ty(tcx, args);
-                    let field_tree = typetree_from_ty(tcx, field_ty);
+                    let field_tree =
+                        typetree_from_ty_impl_inner(tcx, field_ty, depth + 1, visited, false);
 
                     let field_offset = layout.fields.offset(field_idx).bytes_usize();
 
diff --git a/tests/run-make/autodiff/type-trees/nott-flag/with_tt.check b/tests/run-make/autodiff/type-trees/nott-flag/with_tt.check
index 3c02003c88287..0b4c91191798b 100644
--- a/tests/run-make/autodiff/type-trees/nott-flag/with_tt.check
+++ b/tests/run-make/autodiff/type-trees/nott-flag/with_tt.check
@@ -1,4 +1,4 @@
 // Check that enzyme_type attributes are present when TypeTree is enabled
 // This verifies our TypeTree metadata attachment is working
 
-CHECK: define{{.*}}"enzyme_type"="{[-1]:Float@double}"{{.*}}@square{{.*}}"enzyme_type"="{[-1]:Pointer, [-1,-1]:Float@double}"
\ No newline at end of file
+CHECK: define{{.*}}"enzyme_type"="{[-1]:Float@double}"{{.*}}@square{{.*}}"enzyme_type"="{[-1]:Pointer, [-1,0]:Float@double}"
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/recursion-typetree/recursion.check b/tests/run-make/autodiff/type-trees/recursion-typetree/recursion.check
new file mode 100644
index 0000000000000..1960e7b816c5f
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/recursion-typetree/recursion.check
@@ -0,0 +1,3 @@
+CHECK: define{{.*}}"enzyme_type"="{[-1]:Float@double}"{{.*}}@test_deep{{.*}}"enzyme_type"="{[-1]:Pointer, [-1,0]:Float@double}"
+CHECK: define{{.*}}"enzyme_type"="{[-1]:Float@double}"{{.*}}@test_graph{{.*}}"enzyme_type"="{[-1]:Pointer, [-1,0]:Integer, [-1,8]:Integer, [-1,16]:Integer, [-1,24]:Float@double}"
+CHECK: define{{.*}}"enzyme_type"="{[-1]:Float@double}"{{.*}}@test_node{{.*}}"enzyme_type"="{[-1]:Pointer, [-1,0]:Float@double}"
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/recursion-typetree/rmake.rs b/tests/run-make/autodiff/type-trees/recursion-typetree/rmake.rs
new file mode 100644
index 0000000000000..78718f3a21595
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/recursion-typetree/rmake.rs
@@ -0,0 +1,9 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    rustc().input("test.rs").arg("-Zautodiff=Enable").emit("llvm-ir").run();
+    llvm_filecheck().patterns("recursion.check").stdin_buf(rfs::read("test.ll")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/recursion-typetree/test.rs b/tests/run-make/autodiff/type-trees/recursion-typetree/test.rs
new file mode 100644
index 0000000000000..9d40bec1bf1d1
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/recursion-typetree/test.rs
@@ -0,0 +1,100 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+// Self-referential struct to test recursion detection
+#[derive(Clone)]
+struct Node {
+    value: f64,
+    next: Option<Box<Node>>,
+}
+
+// Mutually recursive structs to test cycle detection
+#[derive(Clone)]
+struct GraphNodeA {
+    value: f64,
+    connections: Vec<GraphNodeB>,
+}
+
+#[derive(Clone)]
+struct GraphNodeB {
+    weight: f64,
+    target: Option<Box<GraphNodeA>>,
+}
+
+#[autodiff_reverse(d_test_node, Duplicated, Active)]
+#[no_mangle]
+fn test_node(node: &Node) -> f64 {
+    node.value * 2.0
+}
+
+#[autodiff_reverse(d_test_graph, Duplicated, Active)]
+#[no_mangle]
+fn test_graph(a: &GraphNodeA) -> f64 {
+    a.value * 3.0
+}
+
+// Simple depth test - deeply nested but not circular
+#[derive(Clone)]
+struct Level1 {
+    val: f64,
+    next: Option<Box<Level2>>,
+}
+#[derive(Clone)]
+struct Level2 {
+    val: f64,
+    next: Option<Box<Level3>>,
+}
+#[derive(Clone)]
+struct Level3 {
+    val: f64,
+    next: Option<Box<Level4>>,
+}
+#[derive(Clone)]
+struct Level4 {
+    val: f64,
+    next: Option<Box<Level5>>,
+}
+#[derive(Clone)]
+struct Level5 {
+    val: f64,
+    next: Option<Box<Level6>>,
+}
+#[derive(Clone)]
+struct Level6 {
+    val: f64,
+    next: Option<Box<Level7>>,
+}
+#[derive(Clone)]
+struct Level7 {
+    val: f64,
+    next: Option<Box<Level8>>,
+}
+#[derive(Clone)]
+struct Level8 {
+    val: f64,
+}
+
+#[autodiff_reverse(d_test_deep, Duplicated, Active)]
+#[no_mangle]
+fn test_deep(deep: &Level1) -> f64 {
+    deep.val * 4.0
+}
+
+fn main() {
+    let node = Node { value: 1.0, next: None };
+
+    let graph = GraphNodeA { value: 2.0, connections: vec![] };
+
+    let deep = Level1 { val: 5.0, next: None };
+
+    let mut d_node = Node { value: 0.0, next: None };
+
+    let mut d_graph = GraphNodeA { value: 0.0, connections: vec![] };
+
+    let mut d_deep = Level1 { val: 0.0, next: None };
+
+    let _result1 = d_test_node(&node, &mut d_node, 1.0);
+    let _result2 = d_test_graph(&graph, &mut d_graph, 1.0);
+    let _result3 = d_test_deep(&deep, &mut d_deep, 1.0);
+}
diff --git a/tests/run-make/autodiff/type-trees/scalar-types/f128-typetree/f128.check b/tests/run-make/autodiff/type-trees/scalar-types/f128-typetree/f128.check
index 733e46aa45a57..23db64eea52aa 100644
--- a/tests/run-make/autodiff/type-trees/scalar-types/f128-typetree/f128.check
+++ b/tests/run-make/autodiff/type-trees/scalar-types/f128-typetree/f128.check
@@ -1,4 +1,4 @@
 ; Check that f128 TypeTree metadata is correctly generated
 ; Should show Float@fp128 for f128 values and Pointer for references
 
-CHECK: define{{.*}}"enzyme_type"="{[-1]:Float@fp128}"{{.*}}@test_f128{{.*}}"enzyme_type"="{[-1]:Pointer, [-1,-1]:Float@fp128}"
\ No newline at end of file
+CHECK: define{{.*}}"enzyme_type"="{[-1]:Float@fp128}"{{.*}}@test_f128{{.*}}"enzyme_type"="{[-1]:Pointer, [-1,0]:Float@fp128}"
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/scalar-types/f16-typetree/f16.check b/tests/run-make/autodiff/type-trees/scalar-types/f16-typetree/f16.check
index 9caca26b5cf51..9adff68d36f34 100644
--- a/tests/run-make/autodiff/type-trees/scalar-types/f16-typetree/f16.check
+++ b/tests/run-make/autodiff/type-trees/scalar-types/f16-typetree/f16.check
@@ -1,4 +1,4 @@
 ; Check that f16 TypeTree metadata is correctly generated
 ; Should show Float@half for f16 values and Pointer for references
 
-CHECK: define{{.*}}"enzyme_type"="{[-1]:Float@half}"{{.*}}@test_f16{{.*}}"enzyme_type"="{[-1]:Pointer, [-1,-1]:Float@half}"
\ No newline at end of file
+CHECK: define{{.*}}"enzyme_type"="{[-1]:Float@half}"{{.*}}@test_f16{{.*}}"enzyme_type"="{[-1]:Pointer, [-1,0]:Float@half}"
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/scalar-types/f32-typetree/f32.check b/tests/run-make/autodiff/type-trees/scalar-types/f32-typetree/f32.check
index ec12ba6b2348d..176630f57e8f7 100644
--- a/tests/run-make/autodiff/type-trees/scalar-types/f32-typetree/f32.check
+++ b/tests/run-make/autodiff/type-trees/scalar-types/f32-typetree/f32.check
@@ -1,4 +1,4 @@
 ; Check that f32 TypeTree metadata is correctly generated
 ; Should show Float@float for f32 values and Pointer for references
 
-CHECK: define{{.*}}"enzyme_type"="{[-1]:Float@float}"{{.*}}@test_f32{{.*}}"enzyme_type"="{[-1]:Pointer, [-1,-1]:Float@float}"
\ No newline at end of file
+CHECK: define{{.*}}"enzyme_type"="{[-1]:Float@float}"{{.*}}@test_f32{{.*}}"enzyme_type"="{[-1]:Pointer, [-1,0]:Float@float}"
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/scalar-types/f64-typetree/f64.check b/tests/run-make/autodiff/type-trees/scalar-types/f64-typetree/f64.check
index f1af270824d57..929cd379694ac 100644
--- a/tests/run-make/autodiff/type-trees/scalar-types/f64-typetree/f64.check
+++ b/tests/run-make/autodiff/type-trees/scalar-types/f64-typetree/f64.check
@@ -1,4 +1,4 @@
 ; Check that f64 TypeTree metadata is correctly generated  
 ; Should show Float@double for f64 values and Pointer for references
 
-CHECK: define{{.*}}"enzyme_type"="{[-1]:Float@double}"{{.*}}@test_f64{{.*}}"enzyme_type"="{[-1]:Pointer, [-1,-1]:Float@double}"
\ No newline at end of file
+CHECK: define{{.*}}"enzyme_type"="{[-1]:Float@double}"{{.*}}@test_f64{{.*}}"enzyme_type"="{[-1]:Pointer, [-1,0]:Float@double}"
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/scalar-types/i32-typetree/i32.check b/tests/run-make/autodiff/type-trees/scalar-types/i32-typetree/i32.check
index fd9a94be8100b..dee4aa5bbb6b2 100644
--- a/tests/run-make/autodiff/type-trees/scalar-types/i32-typetree/i32.check
+++ b/tests/run-make/autodiff/type-trees/scalar-types/i32-typetree/i32.check
@@ -1,4 +1,4 @@
 ; Check that i32 TypeTree metadata is correctly generated
 ; Should show Integer for i32 values and Pointer for references
 
-CHECK: define{{.*}}"enzyme_type"="{[-1]:Integer}"{{.*}}@test_i32{{.*}}"enzyme_type"="{[-1]:Pointer, [-1,-1]:Integer}"
\ No newline at end of file
+CHECK: define{{.*}}"enzyme_type"="{[-1]:Integer}"{{.*}}@test_i32{{.*}}"enzyme_type"="{[-1]:Pointer, [-1,0]:Integer}"
\ No newline at end of file

From b1a9f231fea0459356f751ad6c1704b55f541118 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Fri, 19 Sep 2025 14:41:18 +1000
Subject: [PATCH 1125/1889] Use `LLVMDIBuilderGetOrCreateSubrange`

---
 .../rustc_codegen_llvm/src/debuginfo/metadata.rs  |  2 +-
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs       | 15 +++++++--------
 compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp  |  6 ------
 3 files changed, 8 insertions(+), 15 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
index aa8b8bd152dcc..c3712e5b74477 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
@@ -117,7 +117,7 @@ fn build_fixed_size_array_di_node<'ll, 'tcx>(
         .try_to_target_usize(cx.tcx)
         .expect("expected monomorphic const in codegen") as c_longlong;
 
-    let subrange = unsafe { llvm::LLVMRustDIBuilderGetOrCreateSubrange(DIB(cx), 0, upper_bound) };
+    let subrange = unsafe { llvm::LLVMDIBuilderGetOrCreateSubrange(DIB(cx), 0, upper_bound) };
     let subscripts = &[subrange];
 
     let di_node = unsafe {
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 1124ebc3d44b0..d125c1c9c297b 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -25,7 +25,7 @@ use rustc_target::spec::SymbolVisibility;
 use super::RustString;
 use super::debuginfo::{
     DIArray, DIBuilder, DIDerivedType, DIDescriptor, DIEnumerator, DIFile, DIFlags,
-    DIGlobalVariableExpression, DILocation, DISPFlags, DIScope, DISubprogram, DISubrange,
+    DIGlobalVariableExpression, DILocation, DISPFlags, DIScope, DISubprogram,
     DITemplateTypeParameter, DIType, DIVariable, DebugEmissionKind, DebugNameTableKind,
 };
 use crate::llvm;
@@ -890,7 +890,6 @@ pub(crate) mod debuginfo {
     pub(crate) type DIVariable = DIDescriptor;
     pub(crate) type DIGlobalVariableExpression = DIDescriptor;
     pub(crate) type DIArray = DIDescriptor;
-    pub(crate) type DISubrange = DIDescriptor;
     pub(crate) type DIEnumerator = DIDescriptor;
     pub(crate) type DITemplateTypeParameter = DIDescriptor;
 
@@ -1989,6 +1988,12 @@ unsafe extern "C" {
         Scope: Option<&'ll Metadata>,
         AlignInBits: u32, // (optional; default is 0)
     ) -> &'ll Metadata;
+
+    pub(crate) fn LLVMDIBuilderGetOrCreateSubrange<'ll>(
+        Builder: &DIBuilder<'ll>,
+        LowerBound: i64,
+        Count: i64,
+    ) -> &'ll Metadata;
 }
 
 #[link(name = "llvm-wrapper", kind = "static")]
@@ -2370,12 +2375,6 @@ unsafe extern "C" {
         AlignInBits: u32,
     ) -> &'a DIVariable;
 
-    pub(crate) fn LLVMRustDIBuilderGetOrCreateSubrange<'a>(
-        Builder: &DIBuilder<'a>,
-        Lo: i64,
-        Count: i64,
-    ) -> &'a DISubrange;
-
     pub(crate) fn LLVMRustDIBuilderGetOrCreateArray<'a>(
         Builder: &DIBuilder<'a>,
         Ptr: *const Option<&'a DIDescriptor>,
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index 64151962321fd..de79c3e6861c6 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -1142,12 +1142,6 @@ extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariable(
   }
 }
 
-extern "C" LLVMMetadataRef
-LLVMRustDIBuilderGetOrCreateSubrange(LLVMDIBuilderRef Builder, int64_t Lo,
-                                     int64_t Count) {
-  return wrap(unwrap(Builder)->getOrCreateSubrange(Lo, Count));
-}
-
 extern "C" LLVMMetadataRef
 LLVMRustDIBuilderGetOrCreateArray(LLVMDIBuilderRef Builder,
                                   LLVMMetadataRef *Ptr, unsigned Count) {

From a6d261712ee546fc1fc1b7b7c0ee0782aa827b8b Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Fri, 19 Sep 2025 14:44:54 +1000
Subject: [PATCH 1126/1889] Use `LLVMDIBuilderGetOrCreateArray`

---
 compiler/rustc_codegen_llvm/src/debuginfo/utils.rs |  2 +-
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs        | 12 ++++++------
 compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp   |  9 ---------
 3 files changed, 7 insertions(+), 16 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/utils.rs b/compiler/rustc_codegen_llvm/src/debuginfo/utils.rs
index cc1d504b43017..7e1e49310f61c 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/utils.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/utils.rs
@@ -28,7 +28,7 @@ pub(crate) fn create_DIArray<'ll>(
     builder: &DIBuilder<'ll>,
     arr: &[Option<&'ll DIDescriptor>],
 ) -> &'ll DIArray {
-    unsafe { llvm::LLVMRustDIBuilderGetOrCreateArray(builder, arr.as_ptr(), arr.len() as u32) }
+    unsafe { llvm::LLVMDIBuilderGetOrCreateArray(builder, arr.as_ptr(), arr.len()) }
 }
 
 #[inline]
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index d125c1c9c297b..290dbda77f6fb 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -1994,6 +1994,12 @@ unsafe extern "C" {
         LowerBound: i64,
         Count: i64,
     ) -> &'ll Metadata;
+
+    pub(crate) fn LLVMDIBuilderGetOrCreateArray<'ll>(
+        Builder: &DIBuilder<'ll>,
+        Data: *const Option<&'ll Metadata>,
+        NumElements: size_t,
+    ) -> &'ll Metadata;
 }
 
 #[link(name = "llvm-wrapper", kind = "static")]
@@ -2375,12 +2381,6 @@ unsafe extern "C" {
         AlignInBits: u32,
     ) -> &'a DIVariable;
 
-    pub(crate) fn LLVMRustDIBuilderGetOrCreateArray<'a>(
-        Builder: &DIBuilder<'a>,
-        Ptr: *const Option<&'a DIDescriptor>,
-        Count: c_uint,
-    ) -> &'a DIArray;
-
     pub(crate) fn LLVMRustDIBuilderInsertDeclareAtEnd<'a>(
         Builder: &DIBuilder<'a>,
         Val: &'a Value,
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index de79c3e6861c6..b78786921760e 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -1142,15 +1142,6 @@ extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariable(
   }
 }
 
-extern "C" LLVMMetadataRef
-LLVMRustDIBuilderGetOrCreateArray(LLVMDIBuilderRef Builder,
-                                  LLVMMetadataRef *Ptr, unsigned Count) {
-  Metadata **DataValue = unwrap(Ptr);
-  return wrap(unwrap(Builder)
-                  ->getOrCreateArray(ArrayRef<Metadata *>(DataValue, Count))
-                  .get());
-}
-
 extern "C" void
 LLVMRustDIBuilderInsertDeclareAtEnd(LLVMDIBuilderRef Builder, LLVMValueRef V,
                                     LLVMMetadataRef VarInfo, uint64_t *AddrOps,

From 6870e24fdbd9dc1770101457ebdcf9d5837f0b23 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Lauren=C8=9Biu=20Nicola?= <lnicola@dend.ro>
Date: Fri, 19 Sep 2025 08:08:23 +0300
Subject: [PATCH 1127/1889] Set WithCachedTypeInfo::stable_hash when in-tree

---
 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs | 2 ++
 .../rust-analyzer/crates/hir-ty/src/next_solver/predicate.rs    | 2 ++
 src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs     | 2 ++
 3 files changed, 6 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs
index 0b3582051bc07..7ebefa76ed029 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs
@@ -36,6 +36,8 @@ impl<'db> Const<'db> {
             internee: kind,
             flags: flags.flags,
             outer_exclusive_binder: flags.outer_exclusive_binder,
+            #[cfg(feature = "in-rust-tree")]
+            stable_hash: ena::fingerprint::Fingerprint::ZERO,
         };
         Const::new_(interner.db(), InternedWrapperNoDebug(cached))
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/predicate.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/predicate.rs
index 99b1354b6335f..86545415009a0 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/predicate.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/predicate.rs
@@ -227,6 +227,8 @@ impl<'db> Predicate<'db> {
             internee: kind,
             flags: flags.flags,
             outer_exclusive_binder: flags.outer_exclusive_binder,
+            #[cfg(feature = "in-rust-tree")]
+            stable_hash: ena::fingerprint::Fingerprint::ZERO,
         };
         Predicate::new_(interner.db(), InternedWrapperNoDebug(cached))
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
index 70139e8666948..c7a747ade3e76 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
@@ -60,6 +60,8 @@ impl<'db> Ty<'db> {
             internee: kind,
             flags: flags.flags,
             outer_exclusive_binder: flags.outer_exclusive_binder,
+            #[cfg(feature = "in-rust-tree")]
+            stable_hash: ena::fingerprint::Fingerprint::ZERO,
         };
         Ty::new_(interner.db(), InternedWrapperNoDebug(cached))
     }

From 5a043cef02229eb6eb777277745cd7e12b350311 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Fri, 19 Sep 2025 13:35:34 +0800
Subject: [PATCH 1128/1889] Fix extract_variable on LetExpr

Example
---
```rust
fn main() {
    if $0let$0 Some(x) = Some(2+2) {}
}
```

**Before this PR**:

```rust
fn main() {
    let $0var_name = let Some(x) = Some(2+2);
    if var_name {}
}
```

**After this PR**:

```rust
fn main() {
    let $0var_name = Some(2+2);
    if let Some(x) = var_name {}
}
```
---
 .../src/handlers/extract_variable.rs          | 29 ++++++++++++++++++-
 1 file changed, 28 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_variable.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_variable.rs
index bd88e8b09ced0..da596262962c5 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_variable.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_variable.rs
@@ -285,7 +285,7 @@ fn peel_parens(mut expr: ast::Expr) -> ast::Expr {
 /// In general that's true for any expression, but in some cases that would produce invalid code.
 fn valid_target_expr(node: SyntaxNode) -> Option<ast::Expr> {
     match node.kind() {
-        SyntaxKind::PATH_EXPR | SyntaxKind::LOOP_EXPR => None,
+        SyntaxKind::PATH_EXPR | SyntaxKind::LOOP_EXPR | SyntaxKind::LET_EXPR => None,
         SyntaxKind::BREAK_EXPR => ast::BreakExpr::cast(node).and_then(|e| e.expr()),
         SyntaxKind::RETURN_EXPR => ast::ReturnExpr::cast(node).and_then(|e| e.expr()),
         SyntaxKind::BLOCK_EXPR => {
@@ -1403,6 +1403,25 @@ fn main() {
         );
     }
 
+    #[test]
+    fn extract_var_let_expr() {
+        check_assist_by_label(
+            extract_variable,
+            r#"
+fn main() {
+    if $0let$0 Some(x) = Some(2+2) {}
+}
+"#,
+            r#"
+fn main() {
+    let $0var_name = Some(2+2);
+    if let Some(x) = var_name {}
+}
+"#,
+            "Extract into variable",
+        );
+    }
+
     #[test]
     fn extract_var_for_cast() {
         check_assist_by_label(
@@ -1738,6 +1757,14 @@ fn main() {
         check_assist_not_applicable(extract_variable, "fn main() { loop { $0break$0; }; }");
     }
 
+    #[test]
+    fn extract_var_for_let_expr_not_applicable() {
+        check_assist_not_applicable(
+            extract_variable,
+            "fn main() { if $0let Some(x) = Some(2+2) {} }",
+        );
+    }
+
     #[test]
     fn extract_var_unit_expr_not_applicable() {
         check_assist_not_applicable(

From f69da330493233c9f5485919cc7c421c35a83bbc Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Fri, 19 Sep 2025 13:39:45 +0800
Subject: [PATCH 1129/1889] Add `#[track_caller]` for check_assist_by_label

---
 src/tools/rust-analyzer/crates/ide-assists/src/tests.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/tests.rs b/src/tools/rust-analyzer/crates/ide-assists/src/tests.rs
index 3e422ae1b8f6c..c0637a7470f3e 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/tests.rs
@@ -180,6 +180,7 @@ pub(crate) fn check_assist_import_one(
 
 // There is no way to choose what assist within a group you want to test against,
 // so this is here to allow you choose.
+#[track_caller]
 pub(crate) fn check_assist_by_label(
     assist: Handler,
     #[rust_analyzer::rust_fixture] ra_fixture_before: &str,

From 3ba5f19182bf7144c54cbbd0b7af3d4fe76b5317 Mon Sep 17 00:00:00 2001
From: Karan Janthe <karanjanthe@gmail.com>
Date: Fri, 12 Sep 2025 06:11:18 +0000
Subject: [PATCH 1130/1889] autodiff: typetree recursive depth query from
 enzyme with fallback

Signed-off-by: Karan Janthe <karanjanthe@gmail.com>
---
 .../rustc_codegen_llvm/src/llvm/enzyme_ffi.rs |  1 -
 compiler/rustc_codegen_llvm/src/typetree.rs   | 10 ++++-----
 .../rustc_llvm/llvm-wrapper/RustWrapper.cpp   | 12 +++++++++++
 compiler/rustc_middle/src/ty/mod.rs           | 21 +++++++------------
 src/llvm-project                              |  2 +-
 src/tools/cargo                               |  2 +-
 6 files changed, 26 insertions(+), 22 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
index b604f5139c8c1..e63043b21227f 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
@@ -127,7 +127,6 @@ pub(crate) mod Enzyme_AD {
         );
         pub(crate) fn EnzymeTypeTreeToString(arg1: CTypeTreeRef) -> *const c_char;
         pub(crate) fn EnzymeTypeTreeToStringFree(arg1: *const c_char);
-        pub(crate) fn EnzymeGetMaxTypeDepth() -> ::std::os::raw::c_uint;
     }
 
     unsafe extern "C" {
diff --git a/compiler/rustc_codegen_llvm/src/typetree.rs b/compiler/rustc_codegen_llvm/src/typetree.rs
index 1a54884f6c5a4..7e2635037008e 100644
--- a/compiler/rustc_codegen_llvm/src/typetree.rs
+++ b/compiler/rustc_codegen_llvm/src/typetree.rs
@@ -1,5 +1,5 @@
 use rustc_ast::expand::typetree::FncTree;
-#[cfg(llvm_enzyme)]
+#[cfg(feature = "llvm_enzyme")]
 use {
     crate::attributes,
     rustc_ast::expand::typetree::TypeTree as RustTypeTree,
@@ -8,7 +8,7 @@ use {
 
 use crate::llvm::{self, Value};
 
-#[cfg(llvm_enzyme)]
+#[cfg(feature = "llvm_enzyme")]
 fn to_enzyme_typetree(
     rust_typetree: RustTypeTree,
     _data_layout: &str,
@@ -18,7 +18,7 @@ fn to_enzyme_typetree(
     process_typetree_recursive(&mut enzyme_tt, &rust_typetree, &[], llcx);
     enzyme_tt
 }
-#[cfg(llvm_enzyme)]
+#[cfg(feature = "llvm_enzyme")]
 fn process_typetree_recursive(
     enzyme_tt: &mut llvm::TypeTree,
     rust_typetree: &RustTypeTree,
@@ -56,7 +56,7 @@ fn process_typetree_recursive(
     }
 }
 
-#[cfg(llvm_enzyme)]
+#[cfg(feature = "llvm_enzyme")]
 pub(crate) fn add_tt<'ll>(
     llmod: &'ll llvm::Module,
     llcx: &'ll llvm::Context,
@@ -111,7 +111,7 @@ pub(crate) fn add_tt<'ll>(
     }
 }
 
-#[cfg(not(llvm_enzyme))]
+#[cfg(not(feature = "llvm_enzyme"))]
 pub(crate) fn add_tt<'ll>(
     _llmod: &'ll llvm::Module,
     _llcx: &'ll llvm::Context,
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index 64151962321fd..c1a924a87e414 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -1847,3 +1847,15 @@ extern "C" void LLVMRustSetNoSanitizeHWAddress(LLVMValueRef Global) {
   MD.NoHWAddress = true;
   GV.setSanitizerMetadata(MD);
 }
+
+#ifdef ENZYME
+extern "C" {
+extern llvm::cl::opt<unsigned> EnzymeMaxTypeDepth;
+}
+
+extern "C" size_t LLVMRustEnzymeGetMaxTypeDepth() { return EnzymeMaxTypeDepth; }
+#else
+extern "C" size_t LLVMRustEnzymeGetMaxTypeDepth() {
+  return 6; // Default fallback depth
+}
+#endif
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 7ca2355947ad4..ce4de6b95e0bb 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -63,7 +63,7 @@ pub use rustc_type_ir::solve::SizedTraitKind;
 pub use rustc_type_ir::*;
 #[allow(hidden_glob_reexports, unused_imports)]
 use rustc_type_ir::{InferCtxtLike, Interner};
-use tracing::{debug, instrument};
+use tracing::{debug, instrument, trace};
 pub use vtable::*;
 use {rustc_ast as ast, rustc_hir as hir};
 
@@ -2256,6 +2256,10 @@ pub fn typetree_from_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> TypeTree {
     typetree_from_ty_inner(tcx, ty, 0, &mut visited)
 }
 
+/// Maximum recursion depth for TypeTree generation to prevent stack overflow
+/// from pathological deeply nested types. Combined with cycle detection.
+const MAX_TYPETREE_DEPTH: usize = 6;
+
 /// Internal recursive function for TypeTree generation with cycle detection and depth limiting.
 fn typetree_from_ty_inner<'tcx>(
     tcx: TyCtxt<'tcx>,
@@ -2263,19 +2267,8 @@ fn typetree_from_ty_inner<'tcx>(
     depth: usize,
     visited: &mut Vec<Ty<'tcx>>,
 ) -> TypeTree {
-    #[cfg(llvm_enzyme)]
-    {
-        unsafe extern "C" {
-            fn EnzymeGetMaxTypeDepth() -> ::std::os::raw::c_uint;
-        }
-        let max_depth = unsafe { EnzymeGetMaxTypeDepth() } as usize;
-        if depth > max_depth {
-            return TypeTree::new();
-        }
-    }
-
-    #[cfg(not(llvm_enzyme))]
-    if depth > 6 {
+    if depth >= MAX_TYPETREE_DEPTH {
+        trace!("typetree depth limit {} reached for type: {}", MAX_TYPETREE_DEPTH, ty);
         return TypeTree::new();
     }
 
diff --git a/src/llvm-project b/src/llvm-project
index 2a22c8014390b..333793696b0a0 160000
--- a/src/llvm-project
+++ b/src/llvm-project
@@ -1 +1 @@
-Subproject commit 2a22c8014390bdf387d8ed26005fee3187fb98bd
+Subproject commit 333793696b0a08002acac6af983adc7a5233fc56
diff --git a/src/tools/cargo b/src/tools/cargo
index a4bd03c92d3b9..966f94733bbc9 160000
--- a/src/tools/cargo
+++ b/src/tools/cargo
@@ -1 +1 @@
-Subproject commit a4bd03c92d3b977909953d06cc45e263bd7ca7d8
+Subproject commit 966f94733bbc94ca51ff9f1e4c49ad250ebbdc50

From 1db74d4845ed18b63e0c683f7a13714c3653a268 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 19 Sep 2025 09:02:03 +0200
Subject: [PATCH 1131/1889] fix miri bootstrap build

---
 src/tools/miri/src/clock.rs | 16 +++++++++++++++-
 src/tools/miri/src/lib.rs   |  2 +-
 2 files changed, 16 insertions(+), 2 deletions(-)

diff --git a/src/tools/miri/src/clock.rs b/src/tools/miri/src/clock.rs
index 47608f873a481..dbbe741a0714d 100644
--- a/src/tools/miri/src/clock.rs
+++ b/src/tools/miri/src/clock.rs
@@ -46,7 +46,21 @@ impl Instant {
                 InstantKind::Virtual { nanoseconds: earlier },
             ) => {
                 let duration = nanoseconds.saturating_sub(earlier);
-                Duration::from_nanos_u128(duration)
+                cfg_select! {
+                    bootstrap => {
+                         // `Duration` does not provide a nice constructor from a `u128` of nanoseconds,
+                        // so we have to implement this ourselves.
+                        // It is possible for second to overflow because u64::MAX < (u128::MAX / 1e9).
+                        // It will be saturated to u64::MAX seconds if the value after division exceeds u64::MAX.
+                        let seconds = u64::try_from(duration / 1_000_000_000).unwrap_or(u64::MAX);
+                        // It is impossible for nanosecond to overflow because u32::MAX > 1e9.
+                        let nanosecond = u32::try_from(duration.wrapping_rem(1_000_000_000)).unwrap();
+                        Duration::new(seconds, nanosecond)
+                    }
+                    _ => {
+                        Duration::from_nanos_u128(duration)
+                    }
+                }
             }
             _ => panic!("all `Instant` must be of the same kind"),
         }
diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
index dbc2a99593d2c..7f5f25b9f66b2 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -18,7 +18,7 @@
 #![feature(derive_coerce_pointee)]
 #![feature(arbitrary_self_types)]
 #![feature(iter_advance_by)]
-#![feature(duration_from_nanos_u128)]
+#![cfg_attr(not(bootstrap), feature(duration_from_nanos_u128))]
 // Configure clippy and other lints
 #![allow(
     clippy::collapsible_else_if,

From 9daa026cadca6de0d932ddb6f6ddbfa5411a25e3 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Fri, 19 Sep 2025 16:56:28 +1000
Subject: [PATCH 1132/1889] Use
 `LLVMDIBuilder(CreateExpression|InsertDeclareRecordAtEnd)`

---
 .../rustc_codegen_llvm/src/debuginfo/mod.rs   | 15 ++++++-----
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs   | 27 ++++++++++++-------
 .../rustc_llvm/llvm-wrapper/RustWrapper.cpp   | 12 ---------
 3 files changed, 26 insertions(+), 28 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
index 126082aa3aa68..dc36ed17875e7 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
@@ -191,18 +191,21 @@ impl<'ll> DebugInfoBuilderMethods for Builder<'_, 'll, '_> {
             addr_ops.push((fragment.end - fragment.start).bits() as u64);
         }
 
+        let di_builder = DIB(self.cx());
+        let addr_expr = unsafe {
+            llvm::LLVMDIBuilderCreateExpression(di_builder, addr_ops.as_ptr(), addr_ops.len())
+        };
         unsafe {
             // FIXME(eddyb) replace `llvm.dbg.declare` with `llvm.dbg.addr`.
-            llvm::LLVMRustDIBuilderInsertDeclareAtEnd(
-                DIB(self.cx()),
+            llvm::LLVMDIBuilderInsertDeclareRecordAtEnd(
+                di_builder,
                 variable_alloca,
                 dbg_var,
-                addr_ops.as_ptr(),
-                addr_ops.len() as c_uint,
+                addr_expr,
                 dbg_loc,
                 self.llbb(),
-            );
-        }
+            )
+        };
     }
 
     fn set_dbg_loc(&mut self, dbg_loc: &'ll DILocation) {
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 290dbda77f6fb..11de4ed965303 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -806,6 +806,8 @@ unsafe extern "C" {
     pub(crate) type Metadata;
     pub(crate) type BasicBlock;
     pub(crate) type Comdat;
+    /// `&'ll DbgRecord` represents `LLVMDbgRecordRef`.
+    pub(crate) type DbgRecord;
 }
 #[repr(C)]
 pub(crate) struct Builder<'a>(InvariantOpaque<'a>);
@@ -2000,6 +2002,21 @@ unsafe extern "C" {
         Data: *const Option<&'ll Metadata>,
         NumElements: size_t,
     ) -> &'ll Metadata;
+
+    pub(crate) fn LLVMDIBuilderCreateExpression<'ll>(
+        Builder: &DIBuilder<'ll>,
+        Addr: *const u64,
+        Length: size_t,
+    ) -> &'ll Metadata;
+
+    pub(crate) fn LLVMDIBuilderInsertDeclareRecordAtEnd<'ll>(
+        Builder: &DIBuilder<'ll>,
+        Storage: &'ll Value,
+        VarInfo: &'ll Metadata,
+        Expr: &'ll Metadata,
+        DebugLoc: &'ll Metadata,
+        Block: &'ll BasicBlock,
+    ) -> &'ll DbgRecord;
 }
 
 #[link(name = "llvm-wrapper", kind = "static")]
@@ -2381,16 +2398,6 @@ unsafe extern "C" {
         AlignInBits: u32,
     ) -> &'a DIVariable;
 
-    pub(crate) fn LLVMRustDIBuilderInsertDeclareAtEnd<'a>(
-        Builder: &DIBuilder<'a>,
-        Val: &'a Value,
-        VarInfo: &'a DIVariable,
-        AddrOps: *const u64,
-        AddrOpsCount: c_uint,
-        DL: &'a DILocation,
-        InsertAtEnd: &'a BasicBlock,
-    );
-
     pub(crate) fn LLVMRustDIBuilderCreateEnumerator<'a>(
         Builder: &DIBuilder<'a>,
         Name: *const c_char,
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index b78786921760e..fc79cb9d473e8 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -1142,18 +1142,6 @@ extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariable(
   }
 }
 
-extern "C" void
-LLVMRustDIBuilderInsertDeclareAtEnd(LLVMDIBuilderRef Builder, LLVMValueRef V,
-                                    LLVMMetadataRef VarInfo, uint64_t *AddrOps,
-                                    unsigned AddrOpsCount, LLVMMetadataRef DL,
-                                    LLVMBasicBlockRef InsertAtEnd) {
-  unwrap(Builder)->insertDeclare(
-      unwrap(V), unwrap<DILocalVariable>(VarInfo),
-      unwrap(Builder)->createExpression(
-          llvm::ArrayRef<uint64_t>(AddrOps, AddrOpsCount)),
-      DebugLoc(cast<MDNode>(unwrap(DL))), unwrap(InsertAtEnd));
-}
-
 extern "C" LLVMMetadataRef
 LLVMRustDIBuilderCreateEnumerator(LLVMDIBuilderRef Builder, const char *Name,
                                   size_t NameLen, const uint64_t Value[2],

From 4a909bc6b6d39f3596e12ebd77f1dc02f039af3d Mon Sep 17 00:00:00 2001
From: Alexey Semenyuk <alexsemenyuk88@gmail.com>
Date: Fri, 19 Sep 2025 13:24:16 +0500
Subject: [PATCH 1133/1889] Fix versions lints from 1.90.0

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

diff --git a/clippy_lints/src/doc/mod.rs b/clippy_lints/src/doc/mod.rs
index eca3bc390d778..f8ae770b3a4db 100644
--- a/clippy_lints/src/doc/mod.rs
+++ b/clippy_lints/src/doc/mod.rs
@@ -315,7 +315,7 @@ declare_clippy_lint! {
     /// /// [example of a good link](https://github.com/rust-lang/rust-clippy/)
     /// pub fn do_something() {}
     /// ```
-    #[clippy::version = "1.84.0"]
+    #[clippy::version = "1.90.0"]
     pub DOC_BROKEN_LINK,
     pedantic,
     "broken document link"
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index bdbbb3475cd5f..aaea4ff11fc37 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -854,7 +854,7 @@ declare_clippy_lint! {
     ///     println!("{a} is divisible by {b}");
     /// }
     /// ```
-    #[clippy::version = "1.89.0"]
+    #[clippy::version = "1.90.0"]
     pub MANUAL_IS_MULTIPLE_OF,
     complexity,
     "manual implementation of `.is_multiple_of()`"

From 7506352af077b316c12be32e0f9782a0cfd73b1d Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 19 Sep 2025 10:41:56 +0200
Subject: [PATCH 1134/1889] fix clippy warning

---
 src/tools/miri/src/concurrency/sync.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/tools/miri/src/concurrency/sync.rs b/src/tools/miri/src/concurrency/sync.rs
index 15d486c27e36a..e4e7fb1d725fe 100644
--- a/src/tools/miri/src/concurrency/sync.rs
+++ b/src/tools/miri/src/concurrency/sync.rs
@@ -381,8 +381,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 // We need to drop our mutex borrow before unblock_thread
                 // because it will be borrowed again in the unblock callback.
                 drop(mutex);
-                if thread_id.is_some() {
-                    this.unblock_thread(thread_id.unwrap(), BlockReason::Mutex)?;
+                if let Some(thread_id) = thread_id {
+                    this.unblock_thread(thread_id, BlockReason::Mutex)?;
                 }
             }
             Some(old_lock_count)

From be01d87ba2c3ae88ed8a5f73c7440b02dbf9d80b Mon Sep 17 00:00:00 2001
From: Mads Marquart <mads@marquart.dk>
Date: Fri, 19 Sep 2025 10:52:53 +0200
Subject: [PATCH 1135/1889] Allow running remote-test-server on Apple
 simulators

---
 src/tools/remote-test-server/src/main.rs | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

diff --git a/src/tools/remote-test-server/src/main.rs b/src/tools/remote-test-server/src/main.rs
index 67a7ad6f3b454..5ec5e6e28982d 100644
--- a/src/tools/remote-test-server/src/main.rs
+++ b/src/tools/remote-test-server/src/main.rs
@@ -53,6 +53,10 @@ impl Config {
             batch: false,
             bind: if cfg!(target_os = "android") || cfg!(windows) {
                 ([0, 0, 0, 0], 12345).into()
+            } else if cfg!(target_env = "sim") {
+                // iOS/tvOS/watchOS/visionOS simulators share network device
+                // with the host machine.
+                ([127, 0, 0, 1], 12345).into()
             } else {
                 ([10, 0, 2, 15], 12345).into()
             },
@@ -262,10 +266,17 @@ fn handle_run(socket: TcpStream, work: &Path, tmp: &Path, lock: &Mutex<()>, conf
     cmd.args(args);
     cmd.envs(env);
 
-    // On windows, libraries are just searched in the executable directory,
-    // system directories, PWD, and PATH, in that order. PATH is the only one
-    // we can change for this.
-    let library_path = if cfg!(windows) { "PATH" } else { "LD_LIBRARY_PATH" };
+    let library_path = if cfg!(windows) {
+        // On windows, libraries are just searched in the executable directory,
+        // system directories, PWD, and PATH, in that order. PATH is the only
+        // one we can change for this.
+        "PATH"
+    } else if cfg!(target_vendor = "apple") {
+        // On Apple platforms, the environment variable is named differently.
+        "DYLD_LIBRARY_PATH"
+    } else {
+        "LD_LIBRARY_PATH"
+    };
 
     // Support libraries were uploaded to `work` earlier, so make sure that's
     // in `LD_LIBRARY_PATH`. Also include our own current dir which may have

From 09d3120a99fee8d839e502bdb54f8117c0623c5d Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Sun, 14 Sep 2025 15:30:44 +0200
Subject: [PATCH 1136/1889] std: simplify host lookup

---
 library/std/src/net/socket_addr.rs            | 41 +++++++------
 library/std/src/sys/net/connection/sgx.rs     | 29 ++--------
 .../std/src/sys/net/connection/socket/mod.rs  | 58 +++++--------------
 .../src/sys/net/connection/socket/tests.rs    |  2 +-
 .../std/src/sys/net/connection/uefi/mod.rs    | 22 +------
 .../std/src/sys/net/connection/unsupported.rs | 22 +------
 library/std/src/sys/net/connection/wasip1.rs  | 22 +------
 .../std/src/sys/net/connection/xous/dns.rs    | 45 +-------------
 .../std/src/sys/net/connection/xous/mod.rs    |  2 +-
 tests/ui/inference/issue-72616.rs             |  1 -
 tests/ui/inference/issue-72616.stderr         | 19 +-----
 11 files changed, 51 insertions(+), 212 deletions(-)

diff --git a/library/std/src/net/socket_addr.rs b/library/std/src/net/socket_addr.rs
index 41e623e79ce27..5b56dd3f74472 100644
--- a/library/std/src/net/socket_addr.rs
+++ b/library/std/src/net/socket_addr.rs
@@ -6,7 +6,6 @@ mod tests;
 pub use core::net::{SocketAddr, SocketAddrV4, SocketAddrV6};
 
 use crate::net::{IpAddr, Ipv4Addr, Ipv6Addr};
-use crate::sys::net::LookupHost;
 use crate::{io, iter, option, slice, vec};
 
 /// A trait for objects which can be converted or resolved to one or more
@@ -188,15 +187,9 @@ impl ToSocketAddrs for (Ipv6Addr, u16) {
     }
 }
 
-fn resolve_socket_addr(lh: LookupHost) -> io::Result<vec::IntoIter<SocketAddr>> {
-    let p = lh.port();
-    let v: Vec<_> = lh
-        .map(|mut a| {
-            a.set_port(p);
-            a
-        })
-        .collect();
-    Ok(v.into_iter())
+fn lookup_host(host: &str, port: u16) -> io::Result<vec::IntoIter<SocketAddr>> {
+    let addrs = crate::sys::net::lookup_host(host, port)?;
+    Ok(Vec::from_iter(addrs).into_iter())
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -205,17 +198,14 @@ impl ToSocketAddrs for (&str, u16) {
     fn to_socket_addrs(&self) -> io::Result<vec::IntoIter<SocketAddr>> {
         let (host, port) = *self;
 
-        // try to parse the host as a regular IP address first
-        if let Ok(addr) = host.parse::<Ipv4Addr>() {
-            let addr = SocketAddrV4::new(addr, port);
-            return Ok(vec![SocketAddr::V4(addr)].into_iter());
-        }
-        if let Ok(addr) = host.parse::<Ipv6Addr>() {
-            let addr = SocketAddrV6::new(addr, port, 0, 0);
-            return Ok(vec![SocketAddr::V6(addr)].into_iter());
+        // Try to parse the host as a regular IP address first
+        if let Ok(addr) = host.parse::<IpAddr>() {
+            let addr = SocketAddr::new(addr, port);
+            return Ok(vec![addr].into_iter());
         }
 
-        resolve_socket_addr((host, port).try_into()?)
+        // Otherwise, make the system look it up.
+        lookup_host(host, port)
     }
 }
 
@@ -232,12 +222,21 @@ impl ToSocketAddrs for (String, u16) {
 impl ToSocketAddrs for str {
     type Iter = vec::IntoIter<SocketAddr>;
     fn to_socket_addrs(&self) -> io::Result<vec::IntoIter<SocketAddr>> {
-        // try to parse as a regular SocketAddr first
+        // Try to parse as a regular SocketAddr first
         if let Ok(addr) = self.parse() {
             return Ok(vec![addr].into_iter());
         }
 
-        resolve_socket_addr(self.try_into()?)
+        // Otherwise, split the string by ':' and convert the second part to u16...
+        let Some((host, port_str)) = self.rsplit_once(':') else {
+            return Err(io::const_error!(io::ErrorKind::InvalidInput, "invalid socket address"));
+        };
+        let Ok(port) = port_str.parse::<u16>() else {
+            return Err(io::const_error!(io::ErrorKind::InvalidInput, "invalid port value"));
+        };
+
+        // ... and make the system look up the host.
+        lookup_host(host, port)
     }
 }
 
diff --git a/library/std/src/sys/net/connection/sgx.rs b/library/std/src/sys/net/connection/sgx.rs
index 9b54571997d0b..8c9c17d3f1714 100644
--- a/library/std/src/sys/net/connection/sgx.rs
+++ b/library/std/src/sys/net/connection/sgx.rs
@@ -499,16 +499,6 @@ impl fmt::Display for NonIpSockAddr {
 
 pub struct LookupHost(!);
 
-impl LookupHost {
-    fn new(host: String) -> io::Result<LookupHost> {
-        Err(io::Error::new(io::ErrorKind::Uncategorized, NonIpSockAddr { host }))
-    }
-
-    pub fn port(&self) -> u16 {
-        self.0
-    }
-}
-
 impl Iterator for LookupHost {
     type Item = SocketAddr;
     fn next(&mut self) -> Option<SocketAddr> {
@@ -516,18 +506,9 @@ impl Iterator for LookupHost {
     }
 }
 
-impl TryFrom<&str> for LookupHost {
-    type Error = io::Error;
-
-    fn try_from(v: &str) -> io::Result<LookupHost> {
-        LookupHost::new(v.to_owned())
-    }
-}
-
-impl<'a> TryFrom<(&'a str, u16)> for LookupHost {
-    type Error = io::Error;
-
-    fn try_from((host, port): (&'a str, u16)) -> io::Result<LookupHost> {
-        LookupHost::new(format!("{host}:{port}"))
-    }
+pub fn lookup_host(host: &str, port: u16) -> io::Result<LookupHost> {
+    Err(io::Error::new(
+        io::ErrorKind::Uncategorized,
+        NonIpSockAddr { host: format!("{host}:{port}") },
+    ))
 }
diff --git a/library/std/src/sys/net/connection/socket/mod.rs b/library/std/src/sys/net/connection/socket/mod.rs
index 564f2e3a01f3b..1dd06e97bbabd 100644
--- a/library/std/src/sys/net/connection/socket/mod.rs
+++ b/library/std/src/sys/net/connection/socket/mod.rs
@@ -258,7 +258,7 @@ fn to_ipv6mr_interface(value: u32) -> crate::ffi::c_uint {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// get_host_addresses
+// lookup_host
 ////////////////////////////////////////////////////////////////////////////////
 
 pub struct LookupHost {
@@ -267,12 +267,6 @@ pub struct LookupHost {
     port: u16,
 }
 
-impl LookupHost {
-    pub fn port(&self) -> u16 {
-        self.port
-    }
-}
-
 impl Iterator for LookupHost {
     type Item = SocketAddr;
     fn next(&mut self) -> Option<SocketAddr> {
@@ -281,7 +275,10 @@ impl Iterator for LookupHost {
                 let cur = self.cur.as_ref()?;
                 self.cur = cur.ai_next;
                 match socket_addr_from_c(cur.ai_addr.cast(), cur.ai_addrlen as usize) {
-                    Ok(addr) => return Some(addr),
+                    Ok(mut addr) => {
+                        addr.set_port(self.port);
+                        return Some(addr);
+                    }
                     Err(_) => continue,
                 }
             }
@@ -298,42 +295,17 @@ impl Drop for LookupHost {
     }
 }
 
-impl TryFrom<&str> for LookupHost {
-    type Error = io::Error;
-
-    fn try_from(s: &str) -> io::Result<LookupHost> {
-        macro_rules! try_opt {
-            ($e:expr, $msg:expr) => {
-                match $e {
-                    Some(r) => r,
-                    None => return Err(io::const_error!(io::ErrorKind::InvalidInput, $msg)),
-                }
-            };
+pub fn lookup_host(host: &str, port: u16) -> io::Result<LookupHost> {
+    init();
+    run_with_cstr(host.as_bytes(), &|c_host| {
+        let mut hints: c::addrinfo = unsafe { mem::zeroed() };
+        hints.ai_socktype = c::SOCK_STREAM;
+        let mut res = ptr::null_mut();
+        unsafe {
+            cvt_gai(c::getaddrinfo(c_host.as_ptr(), ptr::null(), &hints, &mut res))
+                .map(|_| LookupHost { original: res, cur: res, port })
         }
-
-        // split the string by ':' and convert the second part to u16
-        let (host, port_str) = try_opt!(s.rsplit_once(':'), "invalid socket address");
-        let port: u16 = try_opt!(port_str.parse().ok(), "invalid port value");
-        (host, port).try_into()
-    }
-}
-
-impl<'a> TryFrom<(&'a str, u16)> for LookupHost {
-    type Error = io::Error;
-
-    fn try_from((host, port): (&'a str, u16)) -> io::Result<LookupHost> {
-        init();
-
-        run_with_cstr(host.as_bytes(), &|c_host| {
-            let mut hints: c::addrinfo = unsafe { mem::zeroed() };
-            hints.ai_socktype = c::SOCK_STREAM;
-            let mut res = ptr::null_mut();
-            unsafe {
-                cvt_gai(c::getaddrinfo(c_host.as_ptr(), ptr::null(), &hints, &mut res))
-                    .map(|_| LookupHost { original: res, cur: res, port })
-            }
-        })
-    }
+    })
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/library/std/src/sys/net/connection/socket/tests.rs b/library/std/src/sys/net/connection/socket/tests.rs
index fc236b8027b67..049355afca7ac 100644
--- a/library/std/src/sys/net/connection/socket/tests.rs
+++ b/library/std/src/sys/net/connection/socket/tests.rs
@@ -4,7 +4,7 @@ use crate::collections::HashMap;
 #[test]
 fn no_lookup_host_duplicates() {
     let mut addrs = HashMap::new();
-    let lh = match LookupHost::try_from(("localhost", 0)) {
+    let lh = match lookup_host("localhost", 0) {
         Ok(lh) => lh,
         Err(e) => panic!("couldn't resolve `localhost`: {e}"),
     };
diff --git a/library/std/src/sys/net/connection/uefi/mod.rs b/library/std/src/sys/net/connection/uefi/mod.rs
index 0036804287352..004f6d413a1f3 100644
--- a/library/std/src/sys/net/connection/uefi/mod.rs
+++ b/library/std/src/sys/net/connection/uefi/mod.rs
@@ -333,12 +333,6 @@ impl fmt::Debug for UdpSocket {
 
 pub struct LookupHost(!);
 
-impl LookupHost {
-    pub fn port(&self) -> u16 {
-        self.0
-    }
-}
-
 impl Iterator for LookupHost {
     type Item = SocketAddr;
     fn next(&mut self) -> Option<SocketAddr> {
@@ -346,18 +340,6 @@ impl Iterator for LookupHost {
     }
 }
 
-impl TryFrom<&str> for LookupHost {
-    type Error = io::Error;
-
-    fn try_from(_v: &str) -> io::Result<LookupHost> {
-        unsupported()
-    }
-}
-
-impl<'a> TryFrom<(&'a str, u16)> for LookupHost {
-    type Error = io::Error;
-
-    fn try_from(_v: (&'a str, u16)) -> io::Result<LookupHost> {
-        unsupported()
-    }
+pub fn lookup_host(_host: &str, _port: u16) -> io::Result<LookupHost> {
+    unsupported()
 }
diff --git a/library/std/src/sys/net/connection/unsupported.rs b/library/std/src/sys/net/connection/unsupported.rs
index fbc86343272fc..fb18e8dec557c 100644
--- a/library/std/src/sys/net/connection/unsupported.rs
+++ b/library/std/src/sys/net/connection/unsupported.rs
@@ -304,12 +304,6 @@ impl fmt::Debug for UdpSocket {
 
 pub struct LookupHost(!);
 
-impl LookupHost {
-    pub fn port(&self) -> u16 {
-        self.0
-    }
-}
-
 impl Iterator for LookupHost {
     type Item = SocketAddr;
     fn next(&mut self) -> Option<SocketAddr> {
@@ -317,18 +311,6 @@ impl Iterator for LookupHost {
     }
 }
 
-impl TryFrom<&str> for LookupHost {
-    type Error = io::Error;
-
-    fn try_from(_v: &str) -> io::Result<LookupHost> {
-        unsupported()
-    }
-}
-
-impl<'a> TryFrom<(&'a str, u16)> for LookupHost {
-    type Error = io::Error;
-
-    fn try_from(_v: (&'a str, u16)) -> io::Result<LookupHost> {
-        unsupported()
-    }
+pub fn lookup_host(_host: &str, _port: u16) -> io::Result<LookupHost> {
+    unsupported()
 }
diff --git a/library/std/src/sys/net/connection/wasip1.rs b/library/std/src/sys/net/connection/wasip1.rs
index cdfa25c8a4407..048dafdcd7f7c 100644
--- a/library/std/src/sys/net/connection/wasip1.rs
+++ b/library/std/src/sys/net/connection/wasip1.rs
@@ -477,12 +477,6 @@ impl fmt::Debug for UdpSocket {
 
 pub struct LookupHost(!);
 
-impl LookupHost {
-    pub fn port(&self) -> u16 {
-        self.0
-    }
-}
-
 impl Iterator for LookupHost {
     type Item = SocketAddr;
     fn next(&mut self) -> Option<SocketAddr> {
@@ -490,18 +484,6 @@ impl Iterator for LookupHost {
     }
 }
 
-impl<'a> TryFrom<&'a str> for LookupHost {
-    type Error = io::Error;
-
-    fn try_from(_v: &'a str) -> io::Result<LookupHost> {
-        unsupported()
-    }
-}
-
-impl<'a> TryFrom<(&'a str, u16)> for LookupHost {
-    type Error = io::Error;
-
-    fn try_from(_v: (&'a str, u16)) -> io::Result<LookupHost> {
-        unsupported()
-    }
+pub fn lookup_host(_host: &str, _port: u16) -> io::Result<LookupHost> {
+    unsupported()
 }
diff --git a/library/std/src/sys/net/connection/xous/dns.rs b/library/std/src/sys/net/connection/xous/dns.rs
index bb29d211fad56..b139376f59768 100644
--- a/library/std/src/sys/net/connection/xous/dns.rs
+++ b/library/std/src/sys/net/connection/xous/dns.rs
@@ -1,15 +1,8 @@
-use core::convert::{TryFrom, TryInto};
-
 use crate::io;
 use crate::net::{Ipv4Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
 use crate::os::xous::ffi::lend_mut;
 use crate::os::xous::services::{DnsLendMut, dns_server};
 
-pub struct DnsError {
-    #[allow(dead_code)]
-    pub code: u8,
-}
-
 #[repr(C, align(4096))]
 struct LookupHostQuery([u8; 4096]);
 
@@ -20,12 +13,6 @@ pub struct LookupHost {
     count: usize,
 }
 
-impl LookupHost {
-    pub fn port(&self) -> u16 {
-        self.port
-    }
-}
-
 impl Iterator for LookupHost {
     type Item = SocketAddr;
     fn next(&mut self) -> Option<SocketAddr> {
@@ -72,7 +59,7 @@ impl Iterator for LookupHost {
     }
 }
 
-pub fn lookup(query: &str, port: u16) -> Result<LookupHost, DnsError> {
+pub fn lookup_host(query: &str, port: u16) -> io::Result<LookupHost> {
     let mut result = LookupHost { data: LookupHostQuery([0u8; 4096]), offset: 0, count: 0, port };
 
     // Copy the query into the message that gets sent to the DNS server
@@ -89,7 +76,7 @@ pub fn lookup(query: &str, port: u16) -> Result<LookupHost, DnsError> {
     )
     .unwrap();
     if result.data.0[0] != 0 {
-        return Err(DnsError { code: result.data.0[1] });
+        return Err(io::const_error!(io::ErrorKind::InvalidInput, "DNS failure"));
     }
     assert_eq!(result.offset, 0);
     result.count = result.data.0[1] as usize;
@@ -98,31 +85,3 @@ pub fn lookup(query: &str, port: u16) -> Result<LookupHost, DnsError> {
     result.offset = 2;
     Ok(result)
 }
-
-impl TryFrom<&str> for LookupHost {
-    type Error = io::Error;
-
-    fn try_from(s: &str) -> io::Result<LookupHost> {
-        macro_rules! try_opt {
-            ($e:expr, $msg:expr) => {
-                match $e {
-                    Some(r) => r,
-                    None => return Err(io::const_error!(io::ErrorKind::InvalidInput, &$msg)),
-                }
-            };
-        }
-
-        // split the string by ':' and convert the second part to u16
-        let (host, port_str) = try_opt!(s.rsplit_once(':'), "invalid socket address");
-        let port: u16 = try_opt!(port_str.parse().ok(), "invalid port value");
-        (host, port).try_into()
-    }
-}
-
-impl TryFrom<(&str, u16)> for LookupHost {
-    type Error = io::Error;
-
-    fn try_from(v: (&str, u16)) -> io::Result<LookupHost> {
-        lookup(v.0, v.1).map_err(|_e| io::const_error!(io::ErrorKind::InvalidInput, "DNS failure"))
-    }
-}
diff --git a/library/std/src/sys/net/connection/xous/mod.rs b/library/std/src/sys/net/connection/xous/mod.rs
index e44a375b9e3c5..0f77be5c3fac8 100644
--- a/library/std/src/sys/net/connection/xous/mod.rs
+++ b/library/std/src/sys/net/connection/xous/mod.rs
@@ -45,4 +45,4 @@ pub struct GetAddress {
     raw: [u8; 4096],
 }
 
-pub use dns::LookupHost;
+pub use dns::lookup_host;
diff --git a/tests/ui/inference/issue-72616.rs b/tests/ui/inference/issue-72616.rs
index 71e095cc6fc02..ba18575a57156 100644
--- a/tests/ui/inference/issue-72616.rs
+++ b/tests/ui/inference/issue-72616.rs
@@ -21,7 +21,6 @@ pub fn main() {
     {
         if String::from("a") == "a".try_into().unwrap() {}
         //~^ ERROR type annotations needed
-        //~| ERROR type annotations needed
     }
     {
         let _: String = match "_".try_into() {
diff --git a/tests/ui/inference/issue-72616.stderr b/tests/ui/inference/issue-72616.stderr
index a271639996fd2..6b47d56881134 100644
--- a/tests/ui/inference/issue-72616.stderr
+++ b/tests/ui/inference/issue-72616.stderr
@@ -16,23 +16,6 @@ LL -         if String::from("a") == "a".try_into().unwrap() {}
 LL +         if String::from("a") == <&str as TryInto<T>>::try_into("a").unwrap() {}
    |
 
-error[E0283]: type annotations needed
-  --> $DIR/issue-72616.rs:22:37
-   |
-LL |         if String::from("a") == "a".try_into().unwrap() {}
-   |                                     ^^^^^^^^
-   |
-   = note: multiple `impl`s satisfying `_: TryFrom<&str>` found in the following crates: `core`, `std`:
-           - impl TryFrom<&str> for std::sys::net::connection::socket::LookupHost;
-           - impl<T, U> TryFrom<U> for T
-             where U: Into<T>;
-   = note: required for `&str` to implement `TryInto<_>`
-help: try using a fully qualified path to specify the expected types
-   |
-LL -         if String::from("a") == "a".try_into().unwrap() {}
-LL +         if String::from("a") == <&str as TryInto<T>>::try_into("a").unwrap() {}
-   |
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0283`.

From e39e5a0d157a56680cdc10a77551af225b797787 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Fri, 19 Sep 2025 16:14:35 +1000
Subject: [PATCH 1137/1889] Use `LLVMDIBuilderCreate(Auto|Parameter)Variable`

---
 .../rustc_codegen_llvm/src/debuginfo/mod.rs   | 58 ++++++++++---------
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs   | 43 +++++++++-----
 .../rustc_llvm/llvm-wrapper/RustWrapper.cpp   | 18 ------
 3 files changed, 57 insertions(+), 62 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
index dc36ed17875e7..66b963436afb2 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
@@ -52,15 +52,6 @@ mod utils;
 use self::create_scope_map::compute_mir_scopes;
 pub(crate) use self::metadata::build_global_var_di_node;
 
-// FIXME(Zalathar): These `DW_TAG_*` constants are fake values that were
-// removed from LLVM in 2015, and are only used by our own `RustWrapper.cpp`
-// to decide which C++ API to call. Instead, we should just have two separate
-// FFI functions and choose the correct one on the Rust side.
-#[allow(non_upper_case_globals)]
-const DW_TAG_auto_variable: c_uint = 0x100;
-#[allow(non_upper_case_globals)]
-const DW_TAG_arg_variable: c_uint = 0x101;
-
 /// A context object for maintaining all state needed by the debuginfo module.
 pub(crate) struct CodegenUnitDebugContext<'ll, 'tcx> {
     llmod: &'ll llvm::Module,
@@ -633,28 +624,39 @@ impl<'ll, 'tcx> DebugInfoCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
 
         let type_metadata = spanned_type_di_node(self, variable_type, span);
 
-        let (argument_index, dwarf_tag) = match variable_kind {
-            ArgumentVariable(index) => (index as c_uint, DW_TAG_arg_variable),
-            LocalVariable => (0, DW_TAG_auto_variable),
-        };
         let align = self.align_of(variable_type);
 
         let name = variable_name.as_str();
-        unsafe {
-            llvm::LLVMRustDIBuilderCreateVariable(
-                DIB(self),
-                dwarf_tag,
-                scope_metadata,
-                name.as_c_char_ptr(),
-                name.len(),
-                file_metadata,
-                loc.line,
-                type_metadata,
-                true,
-                DIFlags::FlagZero,
-                argument_index,
-                align.bits() as u32,
-            )
+
+        match variable_kind {
+            ArgumentVariable(arg_index) => unsafe {
+                llvm::LLVMDIBuilderCreateParameterVariable(
+                    DIB(self),
+                    scope_metadata,
+                    name.as_ptr(),
+                    name.len(),
+                    arg_index as c_uint,
+                    file_metadata,
+                    loc.line,
+                    type_metadata,
+                    llvm::Bool::TRUE, // (preserve descriptor during optimizations)
+                    DIFlags::FlagZero,
+                )
+            },
+            LocalVariable => unsafe {
+                llvm::LLVMDIBuilderCreateAutoVariable(
+                    DIB(self),
+                    scope_metadata,
+                    name.as_ptr(),
+                    name.len(),
+                    file_metadata,
+                    loc.line,
+                    type_metadata,
+                    llvm::Bool::TRUE, // (preserve descriptor during optimizations)
+                    DIFlags::FlagZero,
+                    align.bits() as u32,
+                )
+            },
         }
     }
 }
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 11de4ed965303..b0388594f27db 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -26,7 +26,7 @@ use super::RustString;
 use super::debuginfo::{
     DIArray, DIBuilder, DIDerivedType, DIDescriptor, DIEnumerator, DIFile, DIFlags,
     DIGlobalVariableExpression, DILocation, DISPFlags, DIScope, DISubprogram,
-    DITemplateTypeParameter, DIType, DIVariable, DebugEmissionKind, DebugNameTableKind,
+    DITemplateTypeParameter, DIType, DebugEmissionKind, DebugNameTableKind,
 };
 use crate::llvm;
 
@@ -2017,6 +2017,32 @@ unsafe extern "C" {
         DebugLoc: &'ll Metadata,
         Block: &'ll BasicBlock,
     ) -> &'ll DbgRecord;
+
+    pub(crate) fn LLVMDIBuilderCreateAutoVariable<'ll>(
+        Builder: &DIBuilder<'ll>,
+        Scope: &'ll Metadata,
+        Name: *const c_uchar, // See "PTR_LEN_STR".
+        NameLen: size_t,
+        File: &'ll Metadata,
+        LineNo: c_uint,
+        Ty: &'ll Metadata,
+        AlwaysPreserve: llvm::Bool, // "If true, this descriptor will survive optimizations."
+        Flags: DIFlags,
+        AlignInBits: u32,
+    ) -> &'ll Metadata;
+
+    pub(crate) fn LLVMDIBuilderCreateParameterVariable<'ll>(
+        Builder: &DIBuilder<'ll>,
+        Scope: &'ll Metadata,
+        Name: *const c_uchar, // See "PTR_LEN_STR".
+        NameLen: size_t,
+        ArgNo: c_uint,
+        File: &'ll Metadata,
+        LineNo: c_uint,
+        Ty: &'ll Metadata,
+        AlwaysPreserve: llvm::Bool, // "If true, this descriptor will survive optimizations."
+        Flags: DIFlags,
+    ) -> &'ll Metadata;
 }
 
 #[link(name = "llvm-wrapper", kind = "static")]
@@ -2383,21 +2409,6 @@ unsafe extern "C" {
         AlignInBits: u32,
     ) -> &'a DIGlobalVariableExpression;
 
-    pub(crate) fn LLVMRustDIBuilderCreateVariable<'a>(
-        Builder: &DIBuilder<'a>,
-        Tag: c_uint,
-        Scope: &'a DIDescriptor,
-        Name: *const c_char,
-        NameLen: size_t,
-        File: &'a DIFile,
-        LineNo: c_uint,
-        Ty: &'a DIType,
-        AlwaysPreserve: bool,
-        Flags: DIFlags,
-        ArgNo: c_uint,
-        AlignInBits: u32,
-    ) -> &'a DIVariable;
-
     pub(crate) fn LLVMRustDIBuilderCreateEnumerator<'a>(
         Builder: &DIBuilder<'a>,
         Name: *const c_char,
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index fc79cb9d473e8..c7fa26f18e14a 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -1124,24 +1124,6 @@ extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateStaticVariable(
   return wrap(VarExpr);
 }
 
-extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariable(
-    LLVMDIBuilderRef Builder, unsigned Tag, LLVMMetadataRef Scope,
-    const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNo,
-    LLVMMetadataRef Ty, bool AlwaysPreserve, LLVMDIFlags Flags, unsigned ArgNo,
-    uint32_t AlignInBits) {
-  if (Tag == 0x100) { // DW_TAG_auto_variable
-    return wrap(unwrap(Builder)->createAutoVariable(
-        unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen),
-        unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), AlwaysPreserve,
-        fromRust(Flags), AlignInBits));
-  } else {
-    return wrap(unwrap(Builder)->createParameterVariable(
-        unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen), ArgNo,
-        unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), AlwaysPreserve,
-        fromRust(Flags)));
-  }
-}
-
 extern "C" LLVMMetadataRef
 LLVMRustDIBuilderCreateEnumerator(LLVMDIBuilderRef Builder, const char *Name,
                                   size_t NameLen, const uint64_t Value[2],

From 272d336f0f89610bc18bc276b5f89dc163c69d24 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Fri, 19 Sep 2025 17:25:16 +1000
Subject: [PATCH 1138/1889] Remove some unnecessary `as u64` casts

In each of these casts, the LHS is already `u64`.
---
 compiler/rustc_codegen_llvm/src/debuginfo/mod.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
index 66b963436afb2..af64e4ebed0f7 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
@@ -165,21 +165,21 @@ impl<'ll> DebugInfoBuilderMethods for Builder<'_, 'll, '_> {
 
         if direct_offset.bytes() > 0 {
             addr_ops.push(DW_OP_plus_uconst);
-            addr_ops.push(direct_offset.bytes() as u64);
+            addr_ops.push(direct_offset.bytes());
         }
         for &offset in indirect_offsets {
             addr_ops.push(DW_OP_deref);
             if offset.bytes() > 0 {
                 addr_ops.push(DW_OP_plus_uconst);
-                addr_ops.push(offset.bytes() as u64);
+                addr_ops.push(offset.bytes());
             }
         }
         if let Some(fragment) = fragment {
             // `DW_OP_LLVM_fragment` takes as arguments the fragment's
             // offset and size, both of them in bits.
             addr_ops.push(DW_OP_LLVM_fragment);
-            addr_ops.push(fragment.start.bits() as u64);
-            addr_ops.push((fragment.end - fragment.start).bits() as u64);
+            addr_ops.push(fragment.start.bits());
+            addr_ops.push((fragment.end - fragment.start).bits());
         }
 
         let di_builder = DIB(self.cx());

From b30c1b53f3fbd79b94f40b1d000067e1c49ea1d2 Mon Sep 17 00:00:00 2001
From: Mads Marquart <mads@marquart.dk>
Date: Fri, 19 Sep 2025 13:55:02 +0200
Subject: [PATCH 1139/1889] Document how to test with iOS/tvOS/watchOS/visionOS
 simulator

---
 src/doc/rustc-dev-guide/src/tests/running.md  | 31 +++++++++++++++++--
 .../rustc/src/platform-support/apple-ios.md   | 22 ++++++++++---
 .../rustc/src/platform-support/apple-tvos.md  | 13 ++------
 .../src/platform-support/apple-visionos.md    | 13 ++------
 .../src/platform-support/apple-watchos.md     | 13 ++------
 5 files changed, 51 insertions(+), 41 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/tests/running.md b/src/doc/rustc-dev-guide/src/tests/running.md
index 317b65f98cd3c..482f3c42578ae 100644
--- a/src/doc/rustc-dev-guide/src/tests/running.md
+++ b/src/doc/rustc-dev-guide/src/tests/running.md
@@ -339,9 +339,34 @@ results.  The Docker image is set up to launch `remote-test-server` and the
 build tools use `remote-test-client` to communicate with the server to
 coordinate running tests (see [src/bootstrap/src/core/build_steps/test.rs]).
 
-> **TODO**
->
-> - Is there any support for using an iOS emulator?
+To run on the iOS/tvOS/watchOS/visionOS simulator, we can similarly treat it as
+a "remote" machine. A curious detail here is that the network is shared between
+the simulator instance and the host macOS, so we can use the local loopback
+address `127.0.0.1`. Something like the following should work:
+
+```sh
+# Build the test server for the iOS simulator:
+./x build src/tools/remote-test-server --target aarch64-apple-ios-sim
+
+# If you already have a simulator instance open, copy the device UUID from:
+xcrun simctl list devices booted
+UDID=01234567-89AB-CDEF-0123-456789ABCDEF
+
+# Alternatively, create and boot a new simulator instance:
+xcrun simctl list runtimes
+xcrun simctl list devicetypes
+UDID=$(xcrun simctl create $CHOSEN_DEVICE_TYPE $CHOSEN_RUNTIME)
+xcrun simctl boot $UDID
+# See https://nshipster.com/simctl/ for details.
+
+# Spawn the runner on port 12345:
+xcrun simctl spawn $UDID ./build/host/stage2-tools/aarch64-apple-ios-sim/release/remote-test-server -v --bind 127.0.0.1:12345
+
+# In a new terminal, run tests via the runner:
+export TEST_DEVICE_ADDR="127.0.0.1:12345"
+./x test --host='' --target aarch64-apple-ios-sim --skip tests/debuginfo
+# FIXME(madsmtm): Allow debuginfo tests to work (maybe needs `.dSYM` folder to be copied to the target?).
+```
 
 [armhf-gnu]: https://github.com/rust-lang/rust/tree/master/src/ci/docker/host-x86_64/armhf-gnu/Dockerfile
 [QEMU]: https://www.qemu.org/
diff --git a/src/doc/rustc/src/platform-support/apple-ios.md b/src/doc/rustc/src/platform-support/apple-ios.md
index 586afa652262b..3ac1470475468 100644
--- a/src/doc/rustc/src/platform-support/apple-ios.md
+++ b/src/doc/rustc/src/platform-support/apple-ios.md
@@ -66,6 +66,11 @@ Rust programs can be built for these targets by specifying `--target`, if
 $ rustc --target aarch64-apple-ios your-code.rs
 ```
 
+Or if using Cargo and `-Zbuild-std`:
+```console
+$ cargo +nightly build -Zbuild-std --target armv7s-apple-ios
+```
+
 The simulator variants can be differentiated from the variants running
 on-device with the `target_env = "sim"` cfg (or `target_abi = "sim"` before
 Rust CURRENT_RUSTC_VERSION).
@@ -73,7 +78,7 @@ Rust CURRENT_RUSTC_VERSION).
 ```rust
 if cfg!(all(target_vendor = "apple", target_env = "sim")) {
     // Do something on the iOS/tvOS/visionOS/watchOS Simulator.
-} {
+} else {
     // Everything else, like Windows and non-Simulator iOS.
 }
 ```
@@ -82,8 +87,15 @@ This is similar to the `TARGET_OS_SIMULATOR` define in C code.
 
 ## Testing
 
-There is no support for running the Rust or standard library testsuite at the
-moment. Testing has mostly been done manually with builds of static libraries
-embedded into applications called from Xcode or a simulator.
+Running and testing your code naturally requires either an actual device
+running iOS, or the equivalent Xcode simulator environment. There exists
+several tools in the ecosystem for running a Cargo project on one of these.
+One of these tools is [`cargo-dinghy`]. [madsmtm/objc2#459] contains a more
+exhaustive list.
+
+See also [testing on emulators in the `rustc-dev-guide`][test-sim] for
+instructions on running the standard library's test suite.
 
-It hopefully will be possible to improve this in the future.
+[`cargo-dinghy`]: https://github.com/sonos/dinghy
+[madsmtm/objc2#459]: https://github.com/madsmtm/objc2/issues/459
+[test-sim]: https://rustc-dev-guide.rust-lang.org/tests/running.html#testing-on-emulators
diff --git a/src/doc/rustc/src/platform-support/apple-tvos.md b/src/doc/rustc/src/platform-support/apple-tvos.md
index 193d64666121e..a952d8e230d44 100644
--- a/src/doc/rustc/src/platform-support/apple-tvos.md
+++ b/src/doc/rustc/src/platform-support/apple-tvos.md
@@ -65,17 +65,8 @@ Using the unstable `-Zbuild-std` with a nightly Cargo may also work.
 
 ## Building Rust programs
 
-Rust programs can be built for these targets by specifying `--target`, if
-`rustc` has been built with support for them. For example:
-
-```console
-$ rustc --target aarch64-apple-tvos your-code.rs
-```
+See [the instructions for iOS](./apple-ios.md#building-rust-programs).
 
 ## Testing
 
-There is no support for running the Rust or standard library testsuite at the
-moment. Testing has mostly been done manually with builds of static libraries
-embedded into applications called from Xcode or a simulator.
-
-It hopefully will be possible to improve this in the future.
+See [the instructions for iOS](./apple-ios.md#testing).
diff --git a/src/doc/rustc/src/platform-support/apple-visionos.md b/src/doc/rustc/src/platform-support/apple-visionos.md
index ed96912da7a48..2ac069248ee91 100644
--- a/src/doc/rustc/src/platform-support/apple-visionos.md
+++ b/src/doc/rustc/src/platform-support/apple-visionos.md
@@ -46,20 +46,11 @@ be fixed in [#124560](https://github.com/rust-lang/rust/pull/124560).
 
 ## Building Rust programs
 
-Rust programs can be built for these targets by specifying `--target`, if
-`rustc` has been built with support for them. For example:
-
-```console
-$ rustc --target aarch64-apple-visionos-sim your-code.rs
-```
+See [the instructions for iOS](./apple-ios.md#building-rust-programs).
 
 ## Testing
 
-There is no support for running the Rust or standard library testsuite at the
-moment. Testing has mostly been done manually with builds of static libraries
-embedded into applications called from Xcode or a simulator.
-
-It hopefully will be possible to improve this in the future.
+See [the instructions for iOS](./apple-ios.md#testing).
 
 ## Cross-compilation toolchains and C code
 
diff --git a/src/doc/rustc/src/platform-support/apple-watchos.md b/src/doc/rustc/src/platform-support/apple-watchos.md
index 6ac09d0d1e538..c1a009614250a 100644
--- a/src/doc/rustc/src/platform-support/apple-watchos.md
+++ b/src/doc/rustc/src/platform-support/apple-watchos.md
@@ -50,17 +50,8 @@ Using the unstable `-Zbuild-std` with a nightly Cargo may also work.
 
 ## Building Rust programs
 
-Rust programs can be built for these targets by specifying `--target`, if
-`rustc` has been built with support for them. For example:
-
-```console
-$ rustc --target aarch64-apple-watchos-sim your-code.rs
-```
+See [the instructions for iOS](./apple-ios.md#building-rust-programs).
 
 ## Testing
 
-There is no support for running the Rust or standard library testsuite at the
-moment. Testing has mostly been done manually with builds of static libraries
-embedded into applications called from Xcode or a simulator.
-
-It hopefully will be possible to improve this in the future.
+See [the instructions for iOS](./apple-ios.md#testing).

From 37be93497e5318fee712dabb70631f9676f07701 Mon Sep 17 00:00:00 2001
From: Mads Marquart <mads@marquart.dk>
Date: Fri, 19 Sep 2025 09:17:20 +0200
Subject: [PATCH 1140/1889] Fix test suite in iOS/tvOS/watchOS/visionOS
 simulator

---
 library/std/src/os/unix/process.rs            |   2 +
 library/std/src/process.rs                    |  16 +--
 library/std/src/process/tests.rs              | 102 ++++++++++++++----
 .../std/src/sys/process/unix/unix/tests.rs    |   1 +
 library/std/tests/process_spawning.rs         |   1 +
 tests/ui/backtrace/apple-no-dsymutil.rs       |   1 +
 tests/ui/backtrace/dylib-dep.rs               |   4 +
 tests/ui/backtrace/line-tables-only.rs        |   4 +
 tests/ui/command/command-current-dir.rs       |   2 +
 tests/ui/command/command-exec.rs              |   2 +
 tests/ui/command/command-pre-exec.rs          |   2 +
 tests/ui/command/command-uid-gid.rs           |   2 +
 .../ui/compiletest-self-test/test-aux-bin.rs  |   1 +
 ...xporting-impl-from-root-causes-ice-2472.rs |   5 +-
 tests/ui/issues/issue-45731.rs                |   4 +
 tests/ui/process/core-run-destroy.rs          |   4 +
 tests/ui/process/env-funky-keys.rs            |  19 +++-
 tests/ui/process/fds-are-cloexec.rs           |  11 +-
 tests/ui/process/println-with-broken-pipe.rs  |   4 +
 tests/ui/process/process-envs.rs              |   4 +
 tests/ui/process/process-panic-after-fork.rs  |   2 +
 tests/ui/process/process-remove-from-env.rs   |   4 +
 tests/ui/process/process-sigpipe.rs           |   4 +
 tests/ui/process/process-spawn-failure.rs     |   4 +
 tests/ui/runtime/backtrace-debuginfo.rs       |   4 +
 .../runtime/on-broken-pipe/child-processes.rs |   1 +
 tests/ui/runtime/on-broken-pipe/inherit.rs    |   1 +
 27 files changed, 179 insertions(+), 32 deletions(-)

diff --git a/library/std/src/os/unix/process.rs b/library/std/src/os/unix/process.rs
index 09429af06e386..5b7b5a8ea803d 100644
--- a/library/std/src/os/unix/process.rs
+++ b/library/std/src/os/unix/process.rs
@@ -406,8 +406,10 @@ pub trait ChildExt: Sealed {
     /// use libc::SIGTERM;
     ///
     /// fn main() -> io::Result<()> {
+    ///     # if cfg!(not(all(target_vendor = "apple", not(target_os = "macos")))) {
     ///     let child = Command::new("cat").stdin(Stdio::piped()).spawn()?;
     ///     child.send_signal(SIGTERM)?;
+    ///     # }
     ///     Ok(())
     /// }
     /// ```
diff --git a/library/std/src/process.rs b/library/std/src/process.rs
index 48265de90c4d6..0883e56342c8f 100644
--- a/library/std/src/process.rs
+++ b/library/std/src/process.rs
@@ -532,6 +532,7 @@ impl fmt::Debug for ChildStderr {
 /// to be changed (for example, by adding arguments) prior to spawning:
 ///
 /// ```
+/// # if cfg!(not(all(target_vendor = "apple", not(target_os = "macos")))) {
 /// use std::process::Command;
 ///
 /// let output = if cfg!(target_os = "windows") {
@@ -548,6 +549,7 @@ impl fmt::Debug for ChildStderr {
 /// };
 ///
 /// let hello = output.stdout;
+/// # }
 /// ```
 ///
 /// `Command` can be reused to spawn multiple processes. The builder methods
@@ -1348,7 +1350,7 @@ impl Output {
     ///
     /// ```
     /// #![feature(exit_status_error)]
-    /// # #[cfg(all(unix, not(target_os = "android")))] {
+    /// # #[cfg(all(unix, not(target_os = "android"), not(all(target_vendor = "apple", not(target_os = "macos")))))] {
     /// use std::process::Command;
     /// assert!(Command::new("false").output().unwrap().exit_ok().is_err());
     /// # }
@@ -1695,7 +1697,7 @@ impl From<io::Stdout> for Stdio {
     /// # Ok(())
     /// # }
     /// #
-    /// # if cfg!(all(unix, not(target_os = "android"))) {
+    /// # if cfg!(all(unix, not(target_os = "android"), not(all(target_vendor = "apple", not(target_os = "macos"))))) {
     /// #     test().unwrap();
     /// # }
     /// ```
@@ -1724,7 +1726,7 @@ impl From<io::Stderr> for Stdio {
     /// # Ok(())
     /// # }
     /// #
-    /// # if cfg!(all(unix, not(target_os = "android"))) {
+    /// # if cfg!(all(unix, not(target_os = "android"), not(all(target_vendor = "apple", not(target_os = "macos"))))) {
     /// #     test().unwrap();
     /// # }
     /// ```
@@ -1800,7 +1802,7 @@ impl ExitStatus {
     ///
     /// ```
     /// #![feature(exit_status_error)]
-    /// # if cfg!(unix) {
+    /// # if cfg!(all(unix, not(all(target_vendor = "apple", not(target_os = "macos"))))) {
     /// use std::process::Command;
     ///
     /// let status = Command::new("ls")
@@ -1907,7 +1909,7 @@ impl crate::sealed::Sealed for ExitStatusError {}
 ///
 /// ```
 /// #![feature(exit_status_error)]
-/// # if cfg!(all(unix, not(target_os = "android"))) {
+/// # if cfg!(all(unix, not(target_os = "android"), not(all(target_vendor = "apple", not(target_os = "macos"))))) {
 /// use std::process::{Command, ExitStatusError};
 ///
 /// fn run(cmd: &str) -> Result<(), ExitStatusError> {
@@ -1950,7 +1952,7 @@ impl ExitStatusError {
     ///
     /// ```
     /// #![feature(exit_status_error)]
-    /// # #[cfg(all(unix, not(target_os = "android")))] {
+    /// # #[cfg(all(unix, not(target_os = "android"), not(all(target_vendor = "apple", not(target_os = "macos")))))] {
     /// use std::process::Command;
     ///
     /// let bad = Command::new("false").status().unwrap().exit_ok().unwrap_err();
@@ -1975,7 +1977,7 @@ impl ExitStatusError {
     /// ```
     /// #![feature(exit_status_error)]
     ///
-    /// # if cfg!(all(unix, not(target_os = "android"))) {
+    /// # if cfg!(all(unix, not(target_os = "android"), not(all(target_vendor = "apple", not(target_os = "macos"))))) {
     /// use std::num::NonZero;
     /// use std::process::Command;
     ///
diff --git a/library/std/src/process/tests.rs b/library/std/src/process/tests.rs
index 5879914ca206a..12c5130defe5a 100644
--- a/library/std/src/process/tests.rs
+++ b/library/std/src/process/tests.rs
@@ -5,7 +5,15 @@ use crate::mem::MaybeUninit;
 use crate::str;
 
 fn known_command() -> Command {
-    if cfg!(windows) { Command::new("help") } else { Command::new("echo") }
+    if cfg!(windows) {
+        Command::new("help")
+    } else if cfg!(all(target_vendor = "apple", not(target_os = "macos"))) {
+        // iOS/tvOS/watchOS/visionOS have a very limited set of commandline
+        // binaries available.
+        Command::new("log")
+    } else {
+        Command::new("echo")
+    }
 }
 
 #[cfg(target_os = "android")]
@@ -19,7 +27,10 @@ fn shell_cmd() -> Command {
 }
 
 #[test]
-#[cfg_attr(any(target_os = "vxworks"), ignore)]
+#[cfg_attr(
+    any(target_os = "vxworks", all(target_vendor = "apple", not(target_os = "macos"))),
+    ignore = "no shell available"
+)]
 fn smoke() {
     let p = if cfg!(target_os = "windows") {
         Command::new("cmd").args(&["/C", "exit 0"]).spawn()
@@ -41,7 +52,10 @@ fn smoke_failure() {
 }
 
 #[test]
-#[cfg_attr(any(target_os = "vxworks"), ignore)]
+#[cfg_attr(
+    any(target_os = "vxworks", all(target_vendor = "apple", not(target_os = "macos"))),
+    ignore = "no shell available"
+)]
 fn exit_reported_right() {
     let p = if cfg!(target_os = "windows") {
         Command::new("cmd").args(&["/C", "exit 1"]).spawn()
@@ -56,7 +70,10 @@ fn exit_reported_right() {
 
 #[test]
 #[cfg(unix)]
-#[cfg_attr(any(target_os = "vxworks"), ignore)]
+#[cfg_attr(
+    any(target_os = "vxworks", all(target_vendor = "apple", not(target_os = "macos"))),
+    ignore = "no shell available"
+)]
 fn signal_reported_right() {
     use crate::os::unix::process::ExitStatusExt;
 
@@ -80,7 +97,10 @@ pub fn run_output(mut cmd: Command) -> String {
 }
 
 #[test]
-#[cfg_attr(any(target_os = "vxworks"), ignore)]
+#[cfg_attr(
+    any(target_os = "vxworks", all(target_vendor = "apple", not(target_os = "macos"))),
+    ignore = "no shell available"
+)]
 fn stdout_works() {
     if cfg!(target_os = "windows") {
         let mut cmd = Command::new("cmd");
@@ -94,7 +114,11 @@ fn stdout_works() {
 }
 
 #[test]
-#[cfg_attr(any(windows, target_os = "vxworks"), ignore)]
+#[cfg_attr(windows, ignore)]
+#[cfg_attr(
+    any(target_os = "vxworks", all(target_vendor = "apple", not(target_os = "macos"))),
+    ignore = "no shell available"
+)]
 fn set_current_dir_works() {
     // On many Unix platforms this will use the posix_spawn path.
     let mut cmd = shell_cmd();
@@ -116,7 +140,11 @@ fn set_current_dir_works() {
 }
 
 #[test]
-#[cfg_attr(any(windows, target_os = "vxworks"), ignore)]
+#[cfg_attr(windows, ignore)]
+#[cfg_attr(
+    any(target_os = "vxworks", all(target_vendor = "apple", not(target_os = "macos"))),
+    ignore = "no shell available"
+)]
 fn stdin_works() {
     let mut p = shell_cmd()
         .arg("-c")
@@ -134,7 +162,10 @@ fn stdin_works() {
 }
 
 #[test]
-#[cfg_attr(any(target_os = "vxworks"), ignore)]
+#[cfg_attr(
+    any(target_os = "vxworks", all(target_vendor = "apple", not(target_os = "macos"))),
+    ignore = "no shell available"
+)]
 fn child_stdout_read_buf() {
     let mut cmd = if cfg!(target_os = "windows") {
         let mut cmd = Command::new("cmd");
@@ -165,7 +196,10 @@ fn child_stdout_read_buf() {
 }
 
 #[test]
-#[cfg_attr(any(target_os = "vxworks"), ignore)]
+#[cfg_attr(
+    any(target_os = "vxworks", all(target_vendor = "apple", not(target_os = "macos"))),
+    ignore = "no shell available"
+)]
 fn test_process_status() {
     let mut status = if cfg!(target_os = "windows") {
         Command::new("cmd").args(&["/C", "exit 1"]).status().unwrap()
@@ -191,7 +225,10 @@ fn test_process_output_fail_to_start() {
 }
 
 #[test]
-#[cfg_attr(any(target_os = "vxworks"), ignore)]
+#[cfg_attr(
+    any(target_os = "vxworks", all(target_vendor = "apple", not(target_os = "macos"))),
+    ignore = "no shell available"
+)]
 fn test_process_output_output() {
     let Output { status, stdout, stderr } = if cfg!(target_os = "windows") {
         Command::new("cmd").args(&["/C", "echo hello"]).output().unwrap()
@@ -206,7 +243,10 @@ fn test_process_output_output() {
 }
 
 #[test]
-#[cfg_attr(any(target_os = "vxworks"), ignore)]
+#[cfg_attr(
+    any(target_os = "vxworks", all(target_vendor = "apple", not(target_os = "macos"))),
+    ignore = "no shell available"
+)]
 fn test_process_output_error() {
     let Output { status, stdout, stderr } = if cfg!(target_os = "windows") {
         Command::new("cmd").args(&["/C", "mkdir ."]).output().unwrap()
@@ -221,7 +261,10 @@ fn test_process_output_error() {
 }
 
 #[test]
-#[cfg_attr(any(target_os = "vxworks"), ignore)]
+#[cfg_attr(
+    any(target_os = "vxworks", all(target_vendor = "apple", not(target_os = "macos"))),
+    ignore = "no shell available"
+)]
 fn test_finish_once() {
     let mut prog = if cfg!(target_os = "windows") {
         Command::new("cmd").args(&["/C", "exit 1"]).spawn().unwrap()
@@ -232,7 +275,10 @@ fn test_finish_once() {
 }
 
 #[test]
-#[cfg_attr(any(target_os = "vxworks"), ignore)]
+#[cfg_attr(
+    any(target_os = "vxworks", all(target_vendor = "apple", not(target_os = "macos"))),
+    ignore = "no shell available"
+)]
 fn test_finish_twice() {
     let mut prog = if cfg!(target_os = "windows") {
         Command::new("cmd").args(&["/C", "exit 1"]).spawn().unwrap()
@@ -244,7 +290,10 @@ fn test_finish_twice() {
 }
 
 #[test]
-#[cfg_attr(any(target_os = "vxworks"), ignore)]
+#[cfg_attr(
+    any(target_os = "vxworks", all(target_vendor = "apple", not(target_os = "macos"))),
+    ignore = "no shell available"
+)]
 fn test_wait_with_output_once() {
     let prog = if cfg!(target_os = "windows") {
         Command::new("cmd").args(&["/C", "echo hello"]).stdout(Stdio::piped()).spawn().unwrap()
@@ -279,7 +328,10 @@ pub fn env_cmd() -> Command {
 }
 
 #[test]
-#[cfg_attr(target_os = "vxworks", ignore)]
+#[cfg_attr(
+    any(target_os = "vxworks", all(target_vendor = "apple", not(target_os = "macos"))),
+    ignore = "no shell available"
+)]
 fn test_override_env() {
     use crate::env;
 
@@ -302,7 +354,10 @@ fn test_override_env() {
 }
 
 #[test]
-#[cfg_attr(target_os = "vxworks", ignore)]
+#[cfg_attr(
+    any(target_os = "vxworks", all(target_vendor = "apple", not(target_os = "macos"))),
+    ignore = "no shell available"
+)]
 fn test_add_to_env() {
     let result = env_cmd().env("RUN_TEST_NEW_ENV", "123").output().unwrap();
     let output = String::from_utf8_lossy(&result.stdout).to_string();
@@ -314,7 +369,10 @@ fn test_add_to_env() {
 }
 
 #[test]
-#[cfg_attr(target_os = "vxworks", ignore)]
+#[cfg_attr(
+    any(target_os = "vxworks", all(target_vendor = "apple", not(target_os = "macos"))),
+    ignore = "no shell available"
+)]
 fn test_capture_env_at_spawn() {
     use crate::env;
 
@@ -378,7 +436,10 @@ fn test_interior_nul_in_current_dir_is_error() {
 
 // Regression tests for #30862.
 #[test]
-#[cfg_attr(target_os = "vxworks", ignore)]
+#[cfg_attr(
+    any(target_os = "vxworks", all(target_vendor = "apple", not(target_os = "macos"))),
+    ignore = "no `env` cmd available"
+)]
 fn test_interior_nul_in_env_key_is_error() {
     match env_cmd().env("has-some-\0\0s-inside", "value").spawn() {
         Err(e) => assert_eq!(e.kind(), ErrorKind::InvalidInput),
@@ -387,7 +448,10 @@ fn test_interior_nul_in_env_key_is_error() {
 }
 
 #[test]
-#[cfg_attr(target_os = "vxworks", ignore)]
+#[cfg_attr(
+    any(target_os = "vxworks", all(target_vendor = "apple", not(target_os = "macos"))),
+    ignore = "no `env` cmd available"
+)]
 fn test_interior_nul_in_env_value_is_error() {
     match env_cmd().env("key", "has-some-\0\0s-inside").spawn() {
         Err(e) => assert_eq!(e.kind(), ErrorKind::InvalidInput),
diff --git a/library/std/src/sys/process/unix/unix/tests.rs b/library/std/src/sys/process/unix/unix/tests.rs
index f4d6ac6b4e340..663ba61f966c9 100644
--- a/library/std/src/sys/process/unix/unix/tests.rs
+++ b/library/std/src/sys/process/unix/unix/tests.rs
@@ -51,6 +51,7 @@ fn exitstatus_display_tests() {
 
 #[test]
 #[cfg_attr(target_os = "emscripten", ignore)]
+#[cfg_attr(any(target_os = "tvos", target_os = "watchos"), ignore = "fork is prohibited")]
 fn test_command_fork_no_unwind() {
     let got = catch_unwind(|| {
         let mut c = Command::new("echo");
diff --git a/library/std/tests/process_spawning.rs b/library/std/tests/process_spawning.rs
index 43b45cb2d2b5c..93f73ccad3ea4 100644
--- a/library/std/tests/process_spawning.rs
+++ b/library/std/tests/process_spawning.rs
@@ -7,6 +7,7 @@ mod common;
 #[test]
 // Process spawning not supported by Miri, Emscripten and wasi
 #[cfg_attr(any(miri, target_os = "emscripten", target_os = "wasi"), ignore)]
+#[cfg_attr(any(target_os = "tvos", target_os = "watchos"), ignore = "fork is prohibited")]
 fn issue_15149() {
     // If we're the parent, copy our own binary to a new directory.
     let my_path = env::current_exe().unwrap();
diff --git a/tests/ui/backtrace/apple-no-dsymutil.rs b/tests/ui/backtrace/apple-no-dsymutil.rs
index e5aeced25ca35..00c8349d1293e 100644
--- a/tests/ui/backtrace/apple-no-dsymutil.rs
+++ b/tests/ui/backtrace/apple-no-dsymutil.rs
@@ -3,6 +3,7 @@
 //@ compile-flags:-Cstrip=none
 //@ compile-flags:-g -Csplit-debuginfo=unpacked
 //@ only-apple
+//@ ignore-remote needs the compiler-produced `.o` file to be copied to the device
 
 use std::process::Command;
 use std::str;
diff --git a/tests/ui/backtrace/dylib-dep.rs b/tests/ui/backtrace/dylib-dep.rs
index 05fdb9afef80d..cf420ec8d0697 100644
--- a/tests/ui/backtrace/dylib-dep.rs
+++ b/tests/ui/backtrace/dylib-dep.rs
@@ -7,6 +7,10 @@
 //@ ignore-android FIXME #17520
 //@ ignore-fuchsia Backtraces not symbolized
 //@ ignore-musl musl doesn't support dynamic libraries (at least when the original test was written).
+//@ ignore-ios needs the `.dSYM` files to be moved to the device
+//@ ignore-tvos needs the `.dSYM` files to be moved to the device
+//@ ignore-watchos needs the `.dSYM` files to be moved to the device
+//@ ignore-visionos needs the `.dSYM` files to be moved to the device
 //@ needs-unwind
 //@ ignore-backends: gcc
 //@ compile-flags: -g -Copt-level=0 -Cstrip=none -Cforce-frame-pointers=yes
diff --git a/tests/ui/backtrace/line-tables-only.rs b/tests/ui/backtrace/line-tables-only.rs
index 6624c71e184b0..5863cc1d17d46 100644
--- a/tests/ui/backtrace/line-tables-only.rs
+++ b/tests/ui/backtrace/line-tables-only.rs
@@ -11,6 +11,10 @@
 //@ ignore-android FIXME #17520
 //@ ignore-fuchsia Backtraces not symbolized
 //@ ignore-emscripten Requires custom symbolization code
+//@ ignore-ios needs the `.dSYM` files to be moved to the device
+//@ ignore-tvos needs the `.dSYM` files to be moved to the device
+//@ ignore-watchos needs the `.dSYM` files to be moved to the device
+//@ ignore-visionos needs the `.dSYM` files to be moved to the device
 //@ needs-unwind
 //@ aux-build: line-tables-only-helper.rs
 
diff --git a/tests/ui/command/command-current-dir.rs b/tests/ui/command/command-current-dir.rs
index e264cbe4d7045..a6b51df5f176c 100644
--- a/tests/ui/command/command-current-dir.rs
+++ b/tests/ui/command/command-current-dir.rs
@@ -2,6 +2,8 @@
 //@ no-prefer-dynamic We move the binary around, so do not depend dynamically on libstd
 //@ needs-subprocess
 //@ ignore-fuchsia Needs directory creation privilege
+//@ ignore-tvos `Command::current_dir` requires fork, which is prohibited
+//@ ignore-watchos `Command::current_dir` requires fork, which is prohibited
 
 use std::env;
 use std::fs;
diff --git a/tests/ui/command/command-exec.rs b/tests/ui/command/command-exec.rs
index 77336377e8899..870f8b047b9a2 100644
--- a/tests/ui/command/command-exec.rs
+++ b/tests/ui/command/command-exec.rs
@@ -3,6 +3,8 @@
 //@ only-unix (this is a unix-specific test)
 //@ needs-subprocess
 //@ ignore-fuchsia no execvp syscall provided
+//@ ignore-tvos execvp is prohibited
+//@ ignore-watchos execvp is prohibited
 
 use std::env;
 use std::os::unix::process::CommandExt;
diff --git a/tests/ui/command/command-pre-exec.rs b/tests/ui/command/command-pre-exec.rs
index 7299f357bd078..a62ab0b5ed6a7 100644
--- a/tests/ui/command/command-pre-exec.rs
+++ b/tests/ui/command/command-pre-exec.rs
@@ -2,6 +2,8 @@
 //@ only-unix (this is a unix-specific test)
 //@ needs-subprocess
 //@ ignore-fuchsia no execvp syscall
+//@ ignore-tvos execvp is prohibited
+//@ ignore-watchos execvp is prohibited
 
 #![feature(rustc_private)]
 
diff --git a/tests/ui/command/command-uid-gid.rs b/tests/ui/command/command-uid-gid.rs
index f54a0f50708ba..ef0653eb2cb4e 100644
--- a/tests/ui/command/command-uid-gid.rs
+++ b/tests/ui/command/command-uid-gid.rs
@@ -1,6 +1,8 @@
 //@ run-pass
 //@ ignore-android
 //@ ignore-fuchsia no '/bin/sh', '/bin/ls'
+//@ ignore-tvos `Command::uid/gid` requires fork, which is prohibited
+//@ ignore-watchos `Command::uid/gid` requires fork, which is prohibited
 //@ needs-subprocess
 
 #![feature(rustc_private)]
diff --git a/tests/ui/compiletest-self-test/test-aux-bin.rs b/tests/ui/compiletest-self-test/test-aux-bin.rs
index c1c28e12b3b5a..9ac17e6e14619 100644
--- a/tests/ui/compiletest-self-test/test-aux-bin.rs
+++ b/tests/ui/compiletest-self-test/test-aux-bin.rs
@@ -1,4 +1,5 @@
 //@ ignore-cross-compile because aux-bin does not yet support it
+//@ ignore-remote because aux-bin does not yet support it
 //@ aux-bin: print-it-works.rs
 //@ run-pass
 
diff --git a/tests/ui/cross-crate/exporting-impl-from-root-causes-ice-2472.rs b/tests/ui/cross-crate/exporting-impl-from-root-causes-ice-2472.rs
index 86d637b579dc6..c6cfae1e5452c 100644
--- a/tests/ui/cross-crate/exporting-impl-from-root-causes-ice-2472.rs
+++ b/tests/ui/cross-crate/exporting-impl-from-root-causes-ice-2472.rs
@@ -1,6 +1,9 @@
 //@ run-pass
 //@ aux-build:exporting-impl-from-root-causes-ice-2472-b.rs
-
+//@ ignore-ios FIXME(madsmtm): For some reason the necessary dylib isn't copied to the remote?
+//@ ignore-tvos FIXME(madsmtm): For some reason the necessary dylib isn't copied to the remote?
+//@ ignore-watchos FIXME(madsmtm): For some reason the necessary dylib isn't copied to the remote?
+//@ ignore-visionos FIXME(madsmtm): For some reason the necessary dylib isn't copied to the remote?
 
 extern crate exporting_impl_from_root_causes_ice_2472_b as lib;
 
diff --git a/tests/ui/issues/issue-45731.rs b/tests/ui/issues/issue-45731.rs
index 49335362dd0f7..db11d1dbef1c7 100644
--- a/tests/ui/issues/issue-45731.rs
+++ b/tests/ui/issues/issue-45731.rs
@@ -1,6 +1,10 @@
 //@ run-pass
 #![allow(unused_variables)]
 //@ compile-flags:--test -g
+//@ ignore-ios needs the `.dSYM` files to be moved to the device
+//@ ignore-tvos needs the `.dSYM` files to be moved to the device
+//@ ignore-watchos needs the `.dSYM` files to be moved to the device
+//@ ignore-visionos needs the `.dSYM` files to be moved to the device
 
 #[cfg(target_vendor = "apple")]
 #[test]
diff --git a/tests/ui/process/core-run-destroy.rs b/tests/ui/process/core-run-destroy.rs
index f4be54da8fe67..f381997ef7931 100644
--- a/tests/ui/process/core-run-destroy.rs
+++ b/tests/ui/process/core-run-destroy.rs
@@ -8,6 +8,10 @@
 //@ needs-subprocess
 //@ ignore-vxworks no 'cat' and 'sleep'
 //@ ignore-fuchsia no 'cat'
+//@ ignore-ios no 'cat' and 'sleep'
+//@ ignore-tvos no 'cat' and 'sleep'
+//@ ignore-watchos no 'cat' and 'sleep'
+//@ ignore-visionos no 'cat' and 'sleep'
 
 // N.B., these tests kill child processes. Valgrind sees these children as leaking
 // memory, which makes for some *confusing* logs. That's why these are here
diff --git a/tests/ui/process/env-funky-keys.rs b/tests/ui/process/env-funky-keys.rs
index a4a71c94020cd..193659bea293e 100644
--- a/tests/ui/process/env-funky-keys.rs
+++ b/tests/ui/process/env-funky-keys.rs
@@ -1,8 +1,7 @@
 //@ run-pass
 //@ edition: 2021
-// Ignore this test on Android, because it segfaults there.
 
-//@ ignore-android
+//@ ignore-android segfaults
 //@ ignore-windows
 //@ ignore-wasm32 no execve
 //@ ignore-sgx no execve
@@ -24,6 +23,9 @@ use std::ptr;
 fn main() {
     if env::args_os().count() == 2 {
         for (key, value) in env::vars_os() {
+            if key == "DYLD_ROOT_PATH" {
+                continue;
+            }
             panic!("found env value {:?} {:?}", key, value);
         }
         return;
@@ -35,7 +37,18 @@ fn main() {
                                        .as_bytes()).unwrap();
     let filename: *const c_char = current_exe.as_ptr();
     let argv: &[*const c_char] = &[filename, filename, ptr::null()];
-    let envp: &[*const c_char] = &[c"FOOBAR".as_ptr(), ptr::null()];
+
+    let root;
+    let envp: &[*const c_char] = if cfg!(all(target_vendor = "apple", target_env = "sim")) {
+        // Workaround: iOS/tvOS/watchOS/visionOS simulators need the root path
+        // from the current process.
+        root = format!("DYLD_ROOT_PATH={}\0", std::env::var("DYLD_ROOT_PATH").unwrap());
+        &[c"FOOBAR".as_ptr(), root.as_ptr().cast(), ptr::null()]
+    } else {
+        // Try to set an environment variable without a value.
+        &[c"FOOBAR".as_ptr(), ptr::null()]
+    };
+
     unsafe {
         execve(filename, &argv[0], &envp[0]);
     }
diff --git a/tests/ui/process/fds-are-cloexec.rs b/tests/ui/process/fds-are-cloexec.rs
index f6678379dd675..0fae7c2b5024d 100644
--- a/tests/ui/process/fds-are-cloexec.rs
+++ b/tests/ui/process/fds-are-cloexec.rs
@@ -74,8 +74,15 @@ fn child(args: &[String]) {
         let fd: libc::c_int = arg.parse().unwrap();
         unsafe {
             assert_eq!(libc::read(fd, b.as_mut_ptr() as *mut _, 2), -1);
-            assert_eq!(io::Error::last_os_error().raw_os_error(),
-                       Some(libc::EBADF));
+            let raw = io::Error::last_os_error().raw_os_error();
+            if cfg!(all(target_vendor = "apple", not(target_os = "macos"))) {
+                // Workaround: iOS/tvOS/watchOS/visionOS seems to treat `tcp6`
+                // as a directory?
+                if raw == Some(libc::EISDIR) {
+                    continue;
+                }
+            }
+            assert_eq!(raw, Some(libc::EBADF));
         }
     }
 }
diff --git a/tests/ui/process/println-with-broken-pipe.rs b/tests/ui/process/println-with-broken-pipe.rs
index 58b83a2dd9a2f..e87e207737027 100644
--- a/tests/ui/process/println-with-broken-pipe.rs
+++ b/tests/ui/process/println-with-broken-pipe.rs
@@ -5,6 +5,10 @@
 //@ ignore-fuchsia
 //@ ignore-horizon
 //@ ignore-android
+//@ ignore-ios no 'head'
+//@ ignore-tvos no 'head'
+//@ ignore-watchos no 'head'
+//@ ignore-visionos no 'head'
 //@ ignore-backends: gcc
 //@ normalize-stderr: ".rs:\d+:\d+" -> ".rs:LL:CC"
 //@ compile-flags: -Zon-broken-pipe=error
diff --git a/tests/ui/process/process-envs.rs b/tests/ui/process/process-envs.rs
index 98052f1d3a5d7..cbe16704a8e19 100644
--- a/tests/ui/process/process-envs.rs
+++ b/tests/ui/process/process-envs.rs
@@ -2,6 +2,10 @@
 //@ needs-subprocess
 //@ ignore-vxworks no 'env'
 //@ ignore-fuchsia no 'env'
+//@ ignore-ios no 'env'
+//@ ignore-tvos no 'env'
+//@ ignore-watchos no 'env'
+//@ ignore-visionos no 'env'
 
 use std::process::Command;
 use std::env;
diff --git a/tests/ui/process/process-panic-after-fork.rs b/tests/ui/process/process-panic-after-fork.rs
index 6e0267e0a54f5..653ff6ce314d9 100644
--- a/tests/ui/process/process-panic-after-fork.rs
+++ b/tests/ui/process/process-panic-after-fork.rs
@@ -3,6 +3,8 @@
 //@ only-unix
 //@ needs-subprocess
 //@ ignore-fuchsia no fork
+//@ ignore-tvos fork is prohibited
+//@ ignore-watchos fork is prohibited
 
 #![feature(rustc_private)]
 #![feature(never_type)]
diff --git a/tests/ui/process/process-remove-from-env.rs b/tests/ui/process/process-remove-from-env.rs
index c1a2b2daf5b63..68c3909b15ae0 100644
--- a/tests/ui/process/process-remove-from-env.rs
+++ b/tests/ui/process/process-remove-from-env.rs
@@ -2,6 +2,10 @@
 //@ needs-subprocess
 //@ ignore-vxworks no 'env'
 //@ ignore-fuchsia no 'env'
+//@ ignore-ios no 'env'
+//@ ignore-tvos no 'env'
+//@ ignore-watchos no 'env'
+//@ ignore-visionos no 'env'
 
 use std::process::Command;
 use std::env;
diff --git a/tests/ui/process/process-sigpipe.rs b/tests/ui/process/process-sigpipe.rs
index 3ecf271599d23..574d79ee1ddaf 100644
--- a/tests/ui/process/process-sigpipe.rs
+++ b/tests/ui/process/process-sigpipe.rs
@@ -15,6 +15,10 @@
 
 //@ ignore-vxworks no 'sh'
 //@ ignore-fuchsia no 'sh'
+//@ ignore-ios no 'sh'
+//@ ignore-tvos no 'sh'
+//@ ignore-watchos no 'sh'
+//@ ignore-visionos no 'sh'
 //@ needs-threads
 //@ only-unix SIGPIPE is a unix feature
 
diff --git a/tests/ui/process/process-spawn-failure.rs b/tests/ui/process/process-spawn-failure.rs
index 0950b044c97ca..ac2c34bc7836d 100644
--- a/tests/ui/process/process-spawn-failure.rs
+++ b/tests/ui/process/process-spawn-failure.rs
@@ -9,6 +9,10 @@
 //@ ignore-vxworks no 'ps'
 //@ ignore-fuchsia no 'ps'
 //@ ignore-nto no 'ps'
+//@ ignore-ios no 'ps'
+//@ ignore-tvos no 'ps'
+//@ ignore-watchos no 'ps'
+//@ ignore-visionos no 'ps'
 
 #![feature(rustc_private)]
 
diff --git a/tests/ui/runtime/backtrace-debuginfo.rs b/tests/ui/runtime/backtrace-debuginfo.rs
index 5fb9943d6c3c4..5e91f22aec029 100644
--- a/tests/ui/runtime/backtrace-debuginfo.rs
+++ b/tests/ui/runtime/backtrace-debuginfo.rs
@@ -11,6 +11,10 @@
 //@ compile-flags:-Cstrip=none
 //@ needs-subprocess
 //@ ignore-fuchsia Backtrace not symbolized, trace different line alignment
+//@ ignore-ios needs the `.dSYM` files to be moved to the device
+//@ ignore-tvos needs the `.dSYM` files to be moved to the device
+//@ ignore-watchos needs the `.dSYM` files to be moved to the device
+//@ ignore-visionos needs the `.dSYM` files to be moved to the device
 
 // FIXME(#117097): backtrace (possibly unwinding mechanism) seems to be different on at least
 // `i686-mingw` (32-bit windows-gnu)? cc #128911.
diff --git a/tests/ui/runtime/on-broken-pipe/child-processes.rs b/tests/ui/runtime/on-broken-pipe/child-processes.rs
index c0c8ad4e2f5e6..b7022e1b09d90 100644
--- a/tests/ui/runtime/on-broken-pipe/child-processes.rs
+++ b/tests/ui/runtime/on-broken-pipe/child-processes.rs
@@ -1,5 +1,6 @@
 //@ revisions: default error kill inherit
 //@ ignore-cross-compile because aux-bin does not yet support it
+//@ ignore-remote because aux-bin does not yet support it
 //@ only-unix because SIGPIPE is a unix thing
 //@ ignore-backends: gcc
 //@ run-pass
diff --git a/tests/ui/runtime/on-broken-pipe/inherit.rs b/tests/ui/runtime/on-broken-pipe/inherit.rs
index f3c8140eaaef1..e99c7c7a0fe4f 100644
--- a/tests/ui/runtime/on-broken-pipe/inherit.rs
+++ b/tests/ui/runtime/on-broken-pipe/inherit.rs
@@ -1,4 +1,5 @@
 //@ ignore-cross-compile because aux-bin does not yet support it
+//@ ignore-remote because aux-bin does not yet support it
 //@ only-unix because SIGPIPE is a unix thing
 //@ aux-bin: assert-inherit-sig_dfl.rs
 //@ aux-bin: assert-inherit-sig_ign.rs

From 024ea0274d0ac4c938712653e2f8e2e7fec619f2 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Fri, 19 Sep 2025 19:55:02 +0800
Subject: [PATCH 1141/1889] Fix `else` completion before else keyword

Example
---
```rust
fn foo() {
    let x = if true {
        1
    } el$0 else {
        2
    };
}
```

**Before this PR**:

```text
else~    k [LS]
else if~ k [LS]
```

**After this PR**:

```text
else if~ k [LS]
```
---
 .../ide-completion/src/completions/expr.rs    |   3 +-
 .../crates/ide-completion/src/context.rs      |   1 +
 .../ide-completion/src/context/analysis.rs    |   4 +-
 .../ide-completion/src/tests/expression.rs    | 128 +++++++++++++++++-
 4 files changed, 133 insertions(+), 3 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/expr.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/expr.rs
index a7df0ab3863b1..080875e016329 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/expr.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/expr.rs
@@ -59,6 +59,7 @@ pub(crate) fn complete_expr_path(
         in_block_expr,
         in_breakable,
         after_if_expr,
+        before_else_kw,
         in_condition,
         incomplete_let,
         after_incomplete_let,
@@ -386,7 +387,7 @@ pub(crate) fn complete_expr_path(
                         add_keyword("let", "let $1 = $0;");
                     }
 
-                    if after_if_expr || after_incomplete_let {
+                    if !before_else_kw && (after_if_expr || after_incomplete_let) {
                         add_keyword("else", "else {\n    $0\n}");
                     }
 
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context.rs
index 007475688d209..9deaaf6631270 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context.rs
@@ -144,6 +144,7 @@ pub(crate) struct PathExprCtx<'db> {
     pub(crate) in_block_expr: bool,
     pub(crate) in_breakable: BreakableKind,
     pub(crate) after_if_expr: bool,
+    pub(crate) before_else_kw: bool,
     /// Whether this expression is the direct condition of an if or while expression
     pub(crate) in_condition: bool,
     pub(crate) incomplete_let: bool,
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
index b33a547dee972..7b78a9700ec56 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
@@ -1282,11 +1282,12 @@ fn classify_name_ref<'db>(
         let after_incomplete_let = after_incomplete_let(it.clone()).is_some();
         let incomplete_expr_stmt =
             it.parent().and_then(ast::ExprStmt::cast).map(|it| it.semicolon_token().is_none());
+        let before_else_kw = before_else_kw(it);
         let incomplete_let = it
             .parent()
             .and_then(ast::LetStmt::cast)
             .is_some_and(|it| it.semicolon_token().is_none())
-            || after_incomplete_let && incomplete_expr_stmt.unwrap_or(true) && !before_else_kw(it);
+            || after_incomplete_let && incomplete_expr_stmt.unwrap_or(true) && !before_else_kw;
         let in_value = it.parent().and_then(Either::<ast::LetStmt, ast::ArgList>::cast).is_some();
         let impl_ = fetch_immediate_impl(sema, original_file, expr.syntax());
 
@@ -1302,6 +1303,7 @@ fn classify_name_ref<'db>(
                 in_block_expr,
                 in_breakable: in_loop_body,
                 after_if_expr,
+                before_else_kw,
                 in_condition,
                 ref_expr_parent,
                 after_amp,
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs b/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
index 79137104b568d..db9a7b2efe178 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
@@ -1673,7 +1673,133 @@ fn foo() { let x = if foo {} $0 else {}; }
             kw async
             kw const
             kw crate::
-            kw else
+            kw else if
+            kw enum
+            kw extern
+            kw false
+            kw fn
+            kw for
+            kw if
+            kw if let
+            kw impl
+            kw impl for
+            kw let
+            kw letm
+            kw loop
+            kw match
+            kw mod
+            kw return
+            kw self::
+            kw static
+            kw struct
+            kw trait
+            kw true
+            kw type
+            kw union
+            kw unsafe
+            kw use
+            kw while
+            kw while let
+            sn macro_rules
+            sn pd
+            sn ppd
+        "#]],
+    );
+    check(
+        r#"
+fn foo() { let x = if foo {} $0 else if true {}; }
+"#,
+        expect![[r#"
+            fn foo    fn()
+            bt u32     u32
+            kw async
+            kw const
+            kw crate::
+            kw else if
+            kw enum
+            kw extern
+            kw false
+            kw fn
+            kw for
+            kw if
+            kw if let
+            kw impl
+            kw impl for
+            kw let
+            kw letm
+            kw loop
+            kw match
+            kw mod
+            kw return
+            kw self::
+            kw static
+            kw struct
+            kw trait
+            kw true
+            kw type
+            kw union
+            kw unsafe
+            kw use
+            kw while
+            kw while let
+            sn macro_rules
+            sn pd
+            sn ppd
+        "#]],
+    );
+    check(
+        r#"
+fn foo() { let x = if foo {} el$0 else if true {} else {}; }
+"#,
+        expect![[r#"
+            fn foo()  fn()
+            lc x        ()
+            bt u32     u32
+            kw async
+            kw const
+            kw crate::
+            kw else if
+            kw enum
+            kw extern
+            kw false
+            kw fn
+            kw for
+            kw if
+            kw if let
+            kw impl
+            kw impl for
+            kw let
+            kw letm
+            kw loop
+            kw match
+            kw mod
+            kw return
+            kw self::
+            kw static
+            kw struct
+            kw trait
+            kw true
+            kw type
+            kw union
+            kw unsafe
+            kw use
+            kw while
+            kw while let
+            sn macro_rules
+            sn pd
+            sn ppd
+        "#]],
+    );
+    check(
+        r#"
+fn foo() { let x = if foo {} $0 else if true {} else {}; }
+"#,
+        expect![[r#"
+            fn foo    fn()
+            bt u32     u32
+            kw async
+            kw const
+            kw crate::
             kw else if
             kw enum
             kw extern

From bf5fe6e44c2cce2877b25686dd1c0bb3c5d64d80 Mon Sep 17 00:00:00 2001
From: Shoyu Vanilla <modulo641@gmail.com>
Date: Fri, 19 Sep 2025 22:35:46 +0900
Subject: [PATCH 1142/1889] minor: Get rid of unused deps `chalk-solve` and
 `chalk-recursive`

---
 src/tools/rust-analyzer/Cargo.lock            | 88 ++++---------------
 src/tools/rust-analyzer/Cargo.toml            |  4 -
 .../rust-analyzer/crates/hir-ty/Cargo.toml    |  2 -
 .../rust-analyzer/crates/hir-ty/src/traits.rs | 10 ---
 4 files changed, 16 insertions(+), 88 deletions(-)

diff --git a/src/tools/rust-analyzer/Cargo.lock b/src/tools/rust-analyzer/Cargo.lock
index 97c4f06dd5960..097bb81f66765 100644
--- a/src/tools/rust-analyzer/Cargo.lock
+++ b/src/tools/rust-analyzer/Cargo.lock
@@ -279,35 +279,6 @@ dependencies = [
  "chalk-derive",
 ]
 
-[[package]]
-name = "chalk-recursive"
-version = "0.104.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "882959c242558cc686de7ff0aa59860295598d119e84a4b100215f44c3d606c4"
-dependencies = [
- "chalk-derive",
- "chalk-ir",
- "chalk-solve",
- "rustc-hash 1.1.0",
- "tracing",
-]
-
-[[package]]
-name = "chalk-solve"
-version = "0.104.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72860086494ccfa05bbd3779a74babb8ace27da9a0cbabffa1315223c7290927"
-dependencies = [
- "chalk-derive",
- "chalk-ir",
- "ena",
- "indexmap",
- "itertools 0.12.1",
- "petgraph",
- "rustc-hash 1.1.0",
- "tracing",
-]
-
 [[package]]
 name = "clap"
 version = "4.5.42"
@@ -574,12 +545,6 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
-[[package]]
-name = "fixedbitset"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
-
 [[package]]
 name = "flate2"
 version = "1.1.2"
@@ -706,7 +671,7 @@ dependencies = [
  "hir-ty",
  "indexmap",
  "intern",
- "itertools 0.14.0",
+ "itertools",
  "ra-ap-rustc_type_ir",
  "rustc-hash 2.1.1",
  "smallvec",
@@ -739,7 +704,7 @@ dependencies = [
  "hir-expand",
  "indexmap",
  "intern",
- "itertools 0.14.0",
+ "itertools",
  "la-arena 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "mbe",
  "query-group-macro",
@@ -773,7 +738,7 @@ dependencies = [
  "either",
  "expect-test",
  "intern",
- "itertools 0.14.0",
+ "itertools",
  "mbe",
  "parser",
  "query-group-macro",
@@ -799,8 +764,6 @@ dependencies = [
  "bitflags 2.9.1",
  "chalk-derive",
  "chalk-ir",
- "chalk-recursive",
- "chalk-solve",
  "cov-mark",
  "either",
  "ena",
@@ -809,7 +772,7 @@ dependencies = [
  "hir-expand",
  "indexmap",
  "intern",
- "itertools 0.14.0",
+ "itertools",
  "la-arena 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "oorandom",
  "project-model",
@@ -949,7 +912,7 @@ dependencies = [
  "ide-db",
  "ide-diagnostics",
  "ide-ssr",
- "itertools 0.14.0",
+ "itertools",
  "nohash-hasher",
  "oorandom",
  "profile",
@@ -977,7 +940,7 @@ dependencies = [
  "expect-test",
  "hir",
  "ide-db",
- "itertools 0.14.0",
+ "itertools",
  "smallvec",
  "stdx",
  "syntax",
@@ -995,7 +958,7 @@ dependencies = [
  "expect-test",
  "hir",
  "ide-db",
- "itertools 0.14.0",
+ "itertools",
  "smallvec",
  "stdx",
  "syntax",
@@ -1018,7 +981,7 @@ dependencies = [
  "fst",
  "hir",
  "indexmap",
- "itertools 0.14.0",
+ "itertools",
  "line-index 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "memchr",
  "nohash-hasher",
@@ -1049,7 +1012,7 @@ dependencies = [
  "expect-test",
  "hir",
  "ide-db",
- "itertools 0.14.0",
+ "itertools",
  "paths",
  "serde_json",
  "stdx",
@@ -1067,7 +1030,7 @@ dependencies = [
  "expect-test",
  "hir",
  "ide-db",
- "itertools 0.14.0",
+ "itertools",
  "parser",
  "syntax",
  "test-fixture",
@@ -1146,15 +1109,6 @@ dependencies = [
  "memoffset",
 ]
 
-[[package]]
-name = "itertools"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
-dependencies = [
- "either",
-]
-
 [[package]]
 name = "itertools"
 version = "0.14.0"
@@ -1283,7 +1237,7 @@ dependencies = [
  "hir-expand",
  "ide-db",
  "intern",
- "itertools 0.14.0",
+ "itertools",
  "proc-macro-api",
  "project-model",
  "span",
@@ -1640,16 +1594,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "petgraph"
-version = "0.6.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db"
-dependencies = [
- "fixedbitset",
- "indexmap",
-]
-
 [[package]]
 name = "pin-project-lite"
 version = "0.2.16"
@@ -1784,7 +1728,7 @@ dependencies = [
  "cfg",
  "expect-test",
  "intern",
- "itertools 0.14.0",
+ "itertools",
  "la-arena 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "paths",
  "rustc-hash 2.1.1",
@@ -2062,7 +2006,7 @@ dependencies = [
  "ide-ssr",
  "indexmap",
  "intern",
- "itertools 0.14.0",
+ "itertools",
  "load-cargo",
  "lsp-server 0.7.9 (registry+https://github.com/rust-lang/crates.io-index)",
  "lsp-types",
@@ -2400,7 +2344,7 @@ dependencies = [
  "backtrace",
  "crossbeam-channel",
  "crossbeam-utils",
- "itertools 0.14.0",
+ "itertools",
  "jod-thread",
  "libc",
  "miow",
@@ -2436,7 +2380,7 @@ version = "0.0.0"
 dependencies = [
  "either",
  "expect-test",
- "itertools 0.14.0",
+ "itertools",
  "parser",
  "rayon",
  "rowan",
@@ -3285,7 +3229,7 @@ dependencies = [
  "edition",
  "either",
  "flate2",
- "itertools 0.14.0",
+ "itertools",
  "proc-macro2",
  "quote",
  "stdx",
diff --git a/src/tools/rust-analyzer/Cargo.toml b/src/tools/rust-analyzer/Cargo.toml
index 513af11a87aad..cfbd8a56b76fd 100644
--- a/src/tools/rust-analyzer/Cargo.toml
+++ b/src/tools/rust-analyzer/Cargo.toml
@@ -37,9 +37,7 @@ debug = 2
 [patch.'crates-io']
 # rowan = { path = "../rowan" }
 
-# chalk-solve = { path = "../chalk/chalk-solve" }
 # chalk-ir = { path = "../chalk/chalk-ir" }
-# chalk-recursive = { path = "../chalk/chalk-recursive" }
 # chalk-derive = { path = "../chalk/chalk-derive" }
 # line-index = { path = "lib/line-index" }
 # la-arena = { path = "lib/la-arena" }
@@ -111,9 +109,7 @@ arrayvec = "0.7.6"
 bitflags = "2.9.1"
 cargo_metadata = "0.21.0"
 camino = "1.1.10"
-chalk-solve = { version = "0.104.0", default-features = false }
 chalk-ir = "0.104.0"
-chalk-recursive = { version = "0.104.0", default-features = false }
 chalk-derive = "0.104.0"
 crossbeam-channel = "0.5.15"
 dissimilar = "1.0.10"
diff --git a/src/tools/rust-analyzer/crates/hir-ty/Cargo.toml b/src/tools/rust-analyzer/crates/hir-ty/Cargo.toml
index 64182110e1862..138d02e5a6105 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/Cargo.toml
+++ b/src/tools/rust-analyzer/crates/hir-ty/Cargo.toml
@@ -24,9 +24,7 @@ oorandom = "11.1.5"
 tracing.workspace = true
 rustc-hash.workspace = true
 scoped-tls = "1.0.1"
-chalk-solve.workspace = true
 chalk-ir.workspace = true
-chalk-recursive.workspace = true
 chalk-derive.workspace = true
 la-arena.workspace = true
 triomphe.workspace = true
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs b/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
index 8b6836c0e90bf..8095d702be489 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
@@ -4,7 +4,6 @@ use core::fmt;
 use std::hash::Hash;
 
 use chalk_ir::{DebruijnIndex, GoalData, fold::TypeFoldable};
-use chalk_solve::rust_ir;
 
 use base_db::Crate;
 use hir_def::{BlockId, TraitId, lang_item::LangItem};
@@ -405,15 +404,6 @@ impl FnTrait {
         }
     }
 
-    pub const fn to_chalk_ir(self) -> rust_ir::ClosureKind {
-        // Chalk doesn't support async fn traits.
-        match self {
-            FnTrait::AsyncFnOnce | FnTrait::FnOnce => rust_ir::ClosureKind::FnOnce,
-            FnTrait::AsyncFnMut | FnTrait::FnMut => rust_ir::ClosureKind::FnMut,
-            FnTrait::AsyncFn | FnTrait::Fn => rust_ir::ClosureKind::Fn,
-        }
-    }
-
     pub fn method_name(self) -> Name {
         match self {
             FnTrait::FnOnce => Name::new_symbol_root(sym::call_once),

From 9ba9869b335b56823753a6ce6614f8dffee4fcf3 Mon Sep 17 00:00:00 2001
From: Oblarg <emichaelbrnett@gmail.com>
Date: Fri, 19 Sep 2025 10:03:14 -0400
Subject: [PATCH 1143/1889] address review feedback

---
 .../crates/hir-ty/src/lower_nextsolver.rs     | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
index b8e0599dba289..0076446a958b0 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
@@ -285,6 +285,29 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
                 const_type,
                 self.resolver.krate(),
             ),
+            hir_def::hir::Expr::UnaryOp { expr: inner_expr, op: hir_def::hir::UnaryOp::Neg } => {
+                if let hir_def::hir::Expr::Literal(literal) = &self.store[*inner_expr] {
+                    // Only handle negation for signed integers and floats
+                    match literal {
+                        hir_def::hir::Literal::Int(_, _) | hir_def::hir::Literal::Float(_, _) => {
+                            if let Some(negated_literal) = literal.clone().negate() {
+                                intern_const_ref(
+                                    self.db,
+                                    &negated_literal.into(),
+                                    const_type,
+                                    self.resolver.krate(),
+                                )
+                            } else {
+                                unknown_const(const_type)
+                            }
+                        }
+                        // For unsigned integers, chars, bools, etc., negation is not meaningful
+                        _ => unknown_const(const_type),
+                    }
+                } else {
+                    unknown_const(const_type)
+                }
+            }
             _ => unknown_const(const_type),
         }
     }

From 58814bce6cfb8faf62979c7d043347e0526d7e7f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Fri, 19 Sep 2025 16:21:34 +0200
Subject: [PATCH 1144/1889] Allow running `x <cmd> <path>` from a different
 directory

---
 src/bootstrap/src/core/builder/mod.rs | 22 +++++++++++++++++-----
 1 file changed, 17 insertions(+), 5 deletions(-)

diff --git a/src/bootstrap/src/core/builder/mod.rs b/src/bootstrap/src/core/builder/mod.rs
index 75c8ee365284e..8226b4325b6b8 100644
--- a/src/bootstrap/src/core/builder/mod.rs
+++ b/src/bootstrap/src/core/builder/mod.rs
@@ -590,18 +590,30 @@ impl StepDescription {
         // Attempt to resolve paths to be relative to the builder source directory.
         let mut paths: Vec<PathBuf> = paths
             .iter()
-            .map(|p| {
+            .map(|original_path| {
+                let mut path = original_path.clone();
+
+                // Someone could run `x <cmd> <path>` from a different repository than the source
+                // directory.
+                // In that case, we should not try to resolve the paths relative to the working
+                // directory, but rather relative to the source directory.
+                // So we forcefully "relocate" the path to the source directory here.
+                if !path.is_absolute() {
+                    path = builder.src.join(path);
+                }
+
                 // If the path does not exist, it may represent the name of a Step, such as `tidy` in `x test tidy`
-                if !p.exists() {
-                    return p.clone();
+                if !path.exists() {
+                    // Use the original path here
+                    return original_path.clone();
                 }
 
                 // Make the path absolute, strip the prefix, and convert to a PathBuf.
-                match std::path::absolute(p) {
+                match std::path::absolute(&path) {
                     Ok(p) => p.strip_prefix(&builder.src).unwrap_or(&p).to_path_buf(),
                     Err(e) => {
                         eprintln!("ERROR: {e:?}");
-                        panic!("Due to the above error, failed to resolve path: {p:?}");
+                        panic!("Due to the above error, failed to resolve path: {path:?}");
                     }
                 }
             })

From 4320de6424626cb7cd798973e22aef15dae3ba58 Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Fri, 19 Sep 2025 14:22:26 +0000
Subject: [PATCH 1145/1889] fixes for numerous clippy warnings

---
 compiler/rustc_hir_typeck/src/pat.rs | 72 +++++++++++++---------------
 1 file changed, 33 insertions(+), 39 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/pat.rs b/compiler/rustc_hir_typeck/src/pat.rs
index f735c0a416099..46accb76a184a 100644
--- a/compiler/rustc_hir_typeck/src/pat.rs
+++ b/compiler/rustc_hir_typeck/src/pat.rs
@@ -47,7 +47,7 @@ You can read more about trait objects in the Trait Objects section of the Refere
 https://doc.rust-lang.org/reference/types.html#trait-objects";
 
 fn is_number(text: &str) -> bool {
-    text.chars().all(|c: char| c.is_digit(10))
+    text.chars().all(|c: char| c.is_ascii_digit())
 }
 
 /// Information about the expected type at the top level of type checking a pattern.
@@ -262,8 +262,9 @@ enum InheritedRefMatchRule {
         /// pattern matches a given type:
         /// - If the underlying type is not a reference, a reference pattern may eat the inherited reference;
         /// - If the underlying type is a reference, a reference pattern matches if it can eat either one
-        ///    of the underlying and inherited references. E.g. a `&mut` pattern is allowed if either the
-        ///    underlying type is `&mut` or the inherited reference is `&mut`.
+        ///   of the underlying and inherited references. E.g. a `&mut` pattern is allowed if either the
+        ///   underlying type is `&mut` or the inherited reference is `&mut`.
+        ///
         /// If `false`, a reference pattern is only matched against the underlying type.
         /// This is `false` for stable Rust and `true` for both the `ref_pat_eat_one_layer_2024` and
         /// `ref_pat_eat_one_layer_2024_structural` feature gates.
@@ -1069,7 +1070,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 {
                     if !self.tcx.features().mut_ref() {
                         feature_err(
-                            &self.tcx.sess,
+                            self.tcx.sess,
                             sym::mut_ref,
                             pat.span.until(ident.span),
                             "binding cannot be both mutable and by-reference",
@@ -1487,31 +1488,24 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         opt_def_id: Option<hir::def_id::DefId>,
         ident: Ident,
     ) -> bool {
-        match opt_def_id {
-            Some(def_id) => match self.tcx.hir_get_if_local(def_id) {
-                Some(hir::Node::Item(hir::Item {
-                    kind: hir::ItemKind::Const(_, _, _, body_id),
-                    ..
-                })) => match self.tcx.hir_node(body_id.hir_id) {
-                    hir::Node::Expr(expr) => {
-                        if hir::is_range_literal(expr) {
-                            let span = self.tcx.hir_span(body_id.hir_id);
-                            if let Ok(snip) = self.tcx.sess.source_map().span_to_snippet(span) {
-                                e.span_suggestion_verbose(
-                                    ident.span,
-                                    "you may want to move the range into the match block",
-                                    snip,
-                                    Applicability::MachineApplicable,
-                                );
-                                return true;
-                            }
-                        }
-                    }
-                    _ => (),
-                },
-                _ => (),
-            },
-            _ => (),
+        if let Some(def_id) = opt_def_id
+            && let Some(hir::Node::Item(hir::Item {
+                kind: hir::ItemKind::Const(_, _, _, body_id),
+                ..
+            })) = self.tcx.hir_get_if_local(def_id)
+            && let hir::Node::Expr(expr) = self.tcx.hir_node(body_id.hir_id)
+            && hir::is_range_literal(expr)
+        {
+            let span = self.tcx.hir_span(body_id.hir_id);
+            if let Ok(snip) = self.tcx.sess.source_map().span_to_snippet(span) {
+                e.span_suggestion_verbose(
+                    ident.span,
+                    "you may want to move the range into the match block",
+                    snip,
+                    Applicability::MachineApplicable,
+                );
+                return true;
+            }
         }
         false
     }
@@ -1529,7 +1523,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         if let Some(span) = self.tcx.hir_res_span(pat_res) {
             e.span_label(span, format!("{} defined here", res.descr()));
-            if let [hir::PathSegment { ident, .. }] = &*segments {
+            if let [hir::PathSegment { ident, .. }] = segments {
                 e.span_label(
                     pat_span,
                     format!(
@@ -1557,17 +1551,17 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             _ => (None, None),
                         };
 
-                        let is_range = match type_def_id.and_then(|id| self.tcx.as_lang_item(id)) {
+                        let is_range = matches!(
+                            type_def_id.and_then(|id| self.tcx.as_lang_item(id)),
                             Some(
                                 LangItem::Range
-                                | LangItem::RangeFrom
-                                | LangItem::RangeTo
-                                | LangItem::RangeFull
-                                | LangItem::RangeInclusiveStruct
-                                | LangItem::RangeToInclusive,
-                            ) => true,
-                            _ => false,
-                        };
+                                    | LangItem::RangeFrom
+                                    | LangItem::RangeTo
+                                    | LangItem::RangeFull
+                                    | LangItem::RangeInclusiveStruct
+                                    | LangItem::RangeToInclusive,
+                            )
+                        );
                         if is_range {
                             if !self.maybe_suggest_range_literal(&mut e, item_def_id, *ident) {
                                 let msg = "constants only support matching by type, \

From e500dd820bc703b5b727e691e89a8f879522a90f Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Fri, 19 Sep 2025 14:46:12 +0000
Subject: [PATCH 1146/1889] fixes for numerous clippy warnings

---
 .../rustc_hir_typeck/src/method/suggest.rs    | 42 ++++++++-----------
 compiler/rustc_hir_typeck/src/op.rs           |  8 ++--
 2 files changed, 22 insertions(+), 28 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index a39ac0fcb6e3e..024b9ee08c222 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -2194,7 +2194,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     fn suggest_associated_call_syntax(
         &self,
         err: &mut Diag<'_>,
-        static_candidates: &Vec<CandidateSource>,
+        static_candidates: &[CandidateSource],
         rcvr_ty: Ty<'tcx>,
         source: SelfSource<'tcx>,
         item_name: Ident,
@@ -2422,7 +2422,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
                     let span_included = match parent_expr.kind {
                         hir::ExprKind::Struct(_, eps, _) => {
-                            eps.len() > 0 && eps.last().is_some_and(|ep| ep.span.contains(span))
+                            eps.last().is_some_and(|ep| ep.span.contains(span))
                         }
                         // `..=` desugars into `::std::ops::RangeInclusive::new(...)`.
                         hir::ExprKind::Call(func, ..) => func.span.contains(span),
@@ -2484,7 +2484,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             simplify_type(tcx, ty, TreatParams::InstantiateWithInfer)
                 .and_then(|simp| {
                     tcx.incoherent_impls(simp)
-                        .into_iter()
+                        .iter()
                         .find_map(|&id| self.associated_value(id, item_name))
                 })
                 .is_some()
@@ -2617,7 +2617,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
                 if let Node::Expr(call_expr) = self.tcx.parent_hir_node(seg1.hir_id)
                     && let ControlFlow::Break(Some(expr)) =
-                        (LetVisitor { ident_name: seg1.ident.name }).visit_body(&body)
+                        (LetVisitor { ident_name: seg1.ident.name }).visit_body(body)
                     && let Some(self_ty) = self.node_ty_opt(expr.hir_id)
                 {
                     let probe = self.lookup_probe_for_diagnostic(
@@ -2960,14 +2960,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             .collect::<Vec<_>>()
             .into();
         for pred in &local_preds {
-            match pred.self_ty().kind() {
-                ty::Adt(def, _) => {
-                    local_spans.push_span_label(
-                        self.tcx.def_span(def.did()),
-                        format!("must implement `{}`", pred.trait_ref.print_trait_sugared()),
-                    );
-                }
-                _ => {}
+            if let ty::Adt(def, _) = pred.self_ty().kind() {
+                local_spans.push_span_label(
+                    self.tcx.def_span(def.did()),
+                    format!("must implement `{}`", pred.trait_ref.print_trait_sugared()),
+                );
             }
         }
         if local_spans.primary_span().is_some() {
@@ -3006,14 +3003,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             .collect::<Vec<_>>()
             .into();
         for pred in &foreign_preds {
-            match pred.self_ty().kind() {
-                ty::Adt(def, _) => {
-                    foreign_spans.push_span_label(
-                        self.tcx.def_span(def.did()),
-                        format!("not implement `{}`", pred.trait_ref.print_trait_sugared()),
-                    );
-                }
-                _ => {}
+            if let ty::Adt(def, _) = pred.self_ty().kind() {
+                foreign_spans.push_span_label(
+                    self.tcx.def_span(def.did()),
+                    format!("not implement `{}`", pred.trait_ref.print_trait_sugared()),
+                );
             }
         }
         if foreign_spans.primary_span().is_some() {
@@ -3595,7 +3589,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     // would take care of them.
                     && !skippable.contains(&Some(pick.item.container_id(self.tcx)))
                     // Do not suggest pinning when the method is directly on `Pin`.
-                    && pick.item.impl_container(self.tcx).map_or(true, |did| {
+                    && pick.item.impl_container(self.tcx).is_none_or(|did| {
                         match self.tcx.type_of(did).skip_binder().kind() {
                             ty::Adt(def, _) => Some(def.did()) != self.tcx.lang_items().pin_type(),
                             _ => true,
@@ -3653,7 +3647,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                                 vec![
                                     (
                                         rcvr.span.shrink_to_lo(),
-                                        format!("let mut pinned = std::pin::pin!("),
+                                        "let mut pinned = std::pin::pin!(".to_string(),
                                     ),
                                     (
                                         rcvr.span.shrink_to_hi(),
@@ -4128,7 +4122,7 @@ 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"));
+        multi_span.push_span_label(trait_span, "this is the trait that is needed".to_string());
         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());
@@ -4146,7 +4140,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             }
             multi_span.push_span_label(
                 self.tcx.def_span(def_id),
-                format!("this is the trait that was imported"),
+                "this is the trait that was imported".to_string(),
             );
         }
         err.span_note(multi_span, msg);
diff --git a/compiler/rustc_hir_typeck/src/op.rs b/compiler/rustc_hir_typeck/src/op.rs
index 054435379434c..a8e8582c51c49 100644
--- a/compiler/rustc_hir_typeck/src/op.rs
+++ b/compiler/rustc_hir_typeck/src/op.rs
@@ -566,7 +566,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     rhs_ty,
                     lhs_expr,
                     lhs_ty,
-                    |lhs_ty, rhs_ty| is_compatible_after_call(lhs_ty, rhs_ty),
+                    is_compatible_after_call,
                 ) {
                     // Cool
                 }
@@ -1170,8 +1170,8 @@ fn deref_ty_if_possible(ty: Ty<'_>) -> Ty<'_> {
     }
 }
 
-/// Returns `true` if this is a built-in arithmetic operation (e.g., u32
-/// + u32, i16x4 == i16x4) and false if these types would have to be
+/// Returns `true` if this is a built-in arithmetic operation (e.g.,
+/// u32 + u32, i16x4 == i16x4) and false if these types would have to be
 /// overloaded to be legal. There are two reasons that we distinguish
 /// builtin operations from overloaded ones (vs trying to drive
 /// everything uniformly through the trait system and intrinsics or
@@ -1191,7 +1191,7 @@ fn is_builtin_binop<'tcx>(lhs: Ty<'tcx>, rhs: Ty<'tcx>, category: BinOpCategory)
     // (See https://github.com/rust-lang/rust/issues/57447.)
     let (lhs, rhs) = (deref_ty_if_possible(lhs), deref_ty_if_possible(rhs));
 
-    match category.into() {
+    match category {
         BinOpCategory::Shortcircuit => true,
         BinOpCategory::Shift => {
             lhs.references_error()

From 04f6b8f99242eb61756fe294dd9d46536c1c8571 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 19 Sep 2025 16:48:05 +0200
Subject: [PATCH 1147/1889] fix ./x readdir logic when CDPATH is set

---
 x | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/x b/x
index 551cfe6efbf33..4fce0be219e7c 100755
--- a/x
+++ b/x
@@ -15,7 +15,8 @@ realpath() {
     if [ -L "$path" ]; then
         readlink -f "$path"
     elif [ -d "$path" ]; then
-        (cd -P "$path" && pwd)
+        # "cd" is not always silent (e.g. when CDPATH is set), so discard its output.
+        (cd -P "$path" >/dev/null && pwd)
     else
         echo "$(realpath "$(dirname "$path")")/$(basename "$path")"
     fi

From fb7e89cc7268f7b02d39e2c61ab4bd2df458a586 Mon Sep 17 00:00:00 2001
From: yanglsh <yanglsh@shanghaitech.edu.cn>
Date: Tue, 9 Sep 2025 23:30:24 +0800
Subject: [PATCH 1148/1889] fix: `question_mark` FP on variables used after

---
 clippy_lints/src/question_mark.rs | 10 +++++++++-
 tests/ui/question_mark.fixed      | 25 ++++++++++++++++++++++++
 tests/ui/question_mark.rs         | 32 +++++++++++++++++++++++++++++++
 tests/ui/question_mark.stderr     | 22 ++++++++++++++++++++-
 4 files changed, 87 insertions(+), 2 deletions(-)

diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index 4aa100a50e053..d3a5a5dddfbeb 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -6,7 +6,8 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
+use clippy_utils::ty::{implements_trait, is_copy, is_type_diagnostic_item};
+use clippy_utils::usage::local_used_after_expr;
 use clippy_utils::{
     eq_expr_value, fn_def_id_with_node_args, 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_res, path_to_local, path_to_local_id,
@@ -483,6 +484,13 @@ fn check_if_let_some_or_err_and_early_return<'tcx>(cx: &LateContext<'tcx>, expr:
             .filter(|e| *e)
             .is_none()
     {
+        if !is_copy(cx, caller_ty)
+            && let Some(hir_id) = path_to_local(let_expr)
+            && local_used_after_expr(cx, hir_id, expr)
+        {
+            return;
+        }
+
         let mut applicability = Applicability::MachineApplicable;
         let receiver_str = snippet_with_applicability(cx, let_expr.span, "..", &mut applicability);
         let requires_semi = matches!(cx.tcx.parent_hir_node(expr.hir_id), Node::Stmt(_));
diff --git a/tests/ui/question_mark.fixed b/tests/ui/question_mark.fixed
index ac81b324c2049..2c5ee02450389 100644
--- a/tests/ui/question_mark.fixed
+++ b/tests/ui/question_mark.fixed
@@ -475,3 +475,28 @@ fn issue_15679() -> Result<i32, String> {
 
     Ok(0)
 }
+
+mod issue14894 {
+    fn use_after_question_mark(do_something_else: impl Fn() -> Result<String, ()>) -> Result<(), ()> {
+        let result = do_something_else();
+        if let Err(reason) = result {
+            return Err(reason);
+        }
+        drop(result);
+
+        let result = do_something_else();
+        let x = result?;
+        drop(x);
+
+        Ok(())
+    }
+
+    #[expect(dropping_copy_types)]
+    fn use_after_question_mark_but_is_copy(do_something_else: impl Fn() -> Result<i32, ()>) -> Result<(), ()> {
+        let result = do_something_else();
+        result?;
+        drop(result);
+
+        Ok(())
+    }
+}
diff --git a/tests/ui/question_mark.rs b/tests/ui/question_mark.rs
index b5866dac6b8f6..b9ff9d1565b2f 100644
--- a/tests/ui/question_mark.rs
+++ b/tests/ui/question_mark.rs
@@ -583,3 +583,35 @@ fn issue_15679() -> Result<i32, String> {
 
     Ok(0)
 }
+
+mod issue14894 {
+    fn use_after_question_mark(do_something_else: impl Fn() -> Result<String, ()>) -> Result<(), ()> {
+        let result = do_something_else();
+        if let Err(reason) = result {
+            return Err(reason);
+        }
+        drop(result);
+
+        let result = do_something_else();
+        let x = match result {
+            //~^ question_mark
+            Ok(v) => v,
+            Err(e) => return Err(e),
+        };
+        drop(x);
+
+        Ok(())
+    }
+
+    #[expect(dropping_copy_types)]
+    fn use_after_question_mark_but_is_copy(do_something_else: impl Fn() -> Result<i32, ()>) -> Result<(), ()> {
+        let result = do_something_else();
+        if let Err(reason) = result {
+            //~^ question_mark
+            return Err(reason);
+        }
+        drop(result);
+
+        Ok(())
+    }
+}
diff --git a/tests/ui/question_mark.stderr b/tests/ui/question_mark.stderr
index 1ecd936292e55..9b2896328e665 100644
--- a/tests/ui/question_mark.stderr
+++ b/tests/ui/question_mark.stderr
@@ -313,5 +313,25 @@ LL | |         Err(err) => return Err(<&str as Into<String>>::into(err)),
 LL | |     };
    | |_____^ help: try instead: `some_result?`
 
-error: aborting due to 33 previous errors
+error: this `match` expression can be replaced with `?`
+  --> tests/ui/question_mark.rs:596:17
+   |
+LL |           let x = match result {
+   |  _________________^
+LL | |
+LL | |             Ok(v) => v,
+LL | |             Err(e) => return Err(e),
+LL | |         };
+   | |_________^ help: try instead: `result?`
+
+error: this block may be rewritten with the `?` operator
+  --> tests/ui/question_mark.rs:609:9
+   |
+LL | /         if let Err(reason) = result {
+LL | |
+LL | |             return Err(reason);
+LL | |         }
+   | |_________^ help: replace it with: `result?;`
+
+error: aborting due to 35 previous errors
 

From 3ab89abac41443b125f2440b8f525f56536d8ffc Mon Sep 17 00:00:00 2001
From: Josh Triplett <josh@joshtriplett.org>
Date: Fri, 19 Sep 2025 23:06:44 +0800
Subject: [PATCH 1149/1889] mbe: Fix feature gate for `macro_derive`

---
 compiler/rustc_expand/src/mbe/macro_rules.rs            | 2 +-
 tests/ui/feature-gates/feature-gate-macro-derive.stderr | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/compiler/rustc_expand/src/mbe/macro_rules.rs b/compiler/rustc_expand/src/mbe/macro_rules.rs
index 946265eba8bdb..1d147a0385c68 100644
--- a/compiler/rustc_expand/src/mbe/macro_rules.rs
+++ b/compiler/rustc_expand/src/mbe/macro_rules.rs
@@ -702,7 +702,7 @@ pub fn compile_declarative_macro(
             kinds |= MacroKinds::DERIVE;
             let derive_keyword_span = p.prev_token.span;
             if !features.macro_derive() {
-                feature_err(sess, sym::macro_attr, span, "`macro_rules!` derives are unstable")
+                feature_err(sess, sym::macro_derive, span, "`macro_rules!` derives are unstable")
                     .emit();
             }
             if let Some(guar) = check_no_eof(sess, &p, "expected `()` after `derive`") {
diff --git a/tests/ui/feature-gates/feature-gate-macro-derive.stderr b/tests/ui/feature-gates/feature-gate-macro-derive.stderr
index b7ca6717bd51f..177518edafb38 100644
--- a/tests/ui/feature-gates/feature-gate-macro-derive.stderr
+++ b/tests/ui/feature-gates/feature-gate-macro-derive.stderr
@@ -4,8 +4,8 @@ error[E0658]: `macro_rules!` derives are unstable
 LL | macro_rules! MyDerive { derive() {} => {} }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: see issue #83527 <https://github.com/rust-lang/rust/issues/83527> for more information
-   = help: add `#![feature(macro_attr)]` to the crate attributes to enable
+   = note: see issue #143549 <https://github.com/rust-lang/rust/issues/143549> for more information
+   = help: add `#![feature(macro_derive)]` 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

From 3ba0c221aea356b73376784de50cf604ead1b441 Mon Sep 17 00:00:00 2001
From: Shoyu Vanilla <modulo641@gmail.com>
Date: Thu, 18 Sep 2025 03:21:01 +0900
Subject: [PATCH 1150/1889] fix: Make flycheck clearing dependency-aware

---
 .../project-model/src/build_dependencies.rs   |  11 +-
 .../project-model/src/cargo_workspace.rs      |  57 ++++++++-
 .../crates/rust-analyzer/src/diagnostics.rs   |  23 ++++
 .../crates/rust-analyzer/src/flycheck.rs      | 110 ++++++++++++++----
 .../crates/rust-analyzer/src/global_state.rs  |  23 ++++
 .../src/handlers/notification.rs              |  10 +-
 .../crates/rust-analyzer/src/main_loop.rs     |  19 +--
 .../crates/rust-analyzer/src/target_spec.rs   |   3 +
 8 files changed, 213 insertions(+), 43 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/project-model/src/build_dependencies.rs b/src/tools/rust-analyzer/crates/project-model/src/build_dependencies.rs
index 203173c11be40..5eda5af3ace0b 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/build_dependencies.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/build_dependencies.rs
@@ -9,7 +9,7 @@
 use std::{cell::RefCell, io, mem, process::Command};
 
 use base_db::Env;
-use cargo_metadata::{Message, camino::Utf8Path};
+use cargo_metadata::{Message, PackageId, camino::Utf8Path};
 use cfg::CfgAtom;
 use itertools::Itertools;
 use la_arena::ArenaMap;
@@ -18,6 +18,7 @@ use rustc_hash::{FxHashMap, FxHashSet};
 use serde::Deserialize as _;
 use stdx::never;
 use toolchain::Tool;
+use triomphe::Arc;
 
 use crate::{
     CargoConfig, CargoFeatures, CargoWorkspace, InvocationStrategy, ManifestPath, Package, Sysroot,
@@ -284,7 +285,7 @@ impl WorkspaceBuildScripts {
         // NB: Cargo.toml could have been modified between `cargo metadata` and
         // `cargo check`. We shouldn't assume that package ids we see here are
         // exactly those from `config`.
-        let mut by_id: FxHashMap<String, Package> = FxHashMap::default();
+        let mut by_id: FxHashMap<Arc<PackageId>, Package> = FxHashMap::default();
         for package in workspace.packages() {
             outputs.insert(package, BuildScriptOutput::default());
             by_id.insert(workspace[package].id.clone(), package);
@@ -323,7 +324,7 @@ impl WorkspaceBuildScripts {
         // ideally this would be something like:
         // with_output_for: impl FnMut(&str, dyn FnOnce(&mut BuildScriptOutput)),
         // but owned trait objects aren't a thing
-        mut with_output_for: impl FnMut(&str, &mut dyn FnMut(&str, &mut BuildScriptOutput)),
+        mut with_output_for: impl FnMut(&PackageId, &mut dyn FnMut(&str, &mut BuildScriptOutput)),
         progress: &dyn Fn(String),
     ) -> io::Result<Option<String>> {
         let errors = RefCell::new(String::new());
@@ -346,7 +347,7 @@ impl WorkspaceBuildScripts {
 
                 match message {
                     Message::BuildScriptExecuted(mut message) => {
-                        with_output_for(&message.package_id.repr, &mut |name, data| {
+                        with_output_for(&message.package_id, &mut |name, data| {
                             progress(format!("build script {name} run"));
                             let cfgs = {
                                 let mut acc = Vec::new();
@@ -377,7 +378,7 @@ impl WorkspaceBuildScripts {
                         });
                     }
                     Message::CompilerArtifact(message) => {
-                        with_output_for(&message.package_id.repr, &mut |name, data| {
+                        with_output_for(&message.package_id, &mut |name, data| {
                             progress(format!("proc-macro {name} built"));
                             if data.proc_macro_dylib_path == ProcMacroDylibPath::NotBuilt {
                                 data.proc_macro_dylib_path = ProcMacroDylibPath::NotProcMacro;
diff --git a/src/tools/rust-analyzer/crates/project-model/src/cargo_workspace.rs b/src/tools/rust-analyzer/crates/project-model/src/cargo_workspace.rs
index e613fd590c70b..adc0cc5094166 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/cargo_workspace.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/cargo_workspace.rs
@@ -5,7 +5,7 @@ use std::str::from_utf8;
 
 use anyhow::Context;
 use base_db::Env;
-use cargo_metadata::{CargoOpt, MetadataCommand};
+use cargo_metadata::{CargoOpt, MetadataCommand, PackageId};
 use la_arena::{Arena, Idx};
 use paths::{AbsPath, AbsPathBuf, Utf8Path, Utf8PathBuf};
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -14,6 +14,7 @@ use serde_json::from_value;
 use span::Edition;
 use stdx::process::spawn_with_streaming_output;
 use toolchain::Tool;
+use triomphe::Arc;
 
 use crate::cargo_config_file::make_lockfile_copy;
 use crate::{CfgOverrides, InvocationStrategy};
@@ -155,8 +156,8 @@ pub struct PackageData {
     pub features: FxHashMap<String, Vec<String>>,
     /// List of features enabled on this package
     pub active_features: Vec<String>,
-    /// String representation of package id
-    pub id: String,
+    /// Package id
+    pub id: Arc<PackageId>,
     /// Authors as given in the `Cargo.toml`
     pub authors: Vec<String>,
     /// Description as given in the `Cargo.toml`
@@ -173,6 +174,10 @@ pub struct PackageData {
     pub rust_version: Option<semver::Version>,
     /// The contents of [package.metadata.rust-analyzer]
     pub metadata: RustAnalyzerPackageMetaData,
+    /// If this package is a member of the workspace, store all direct and transitive
+    /// dependencies as long as they are workspace members, to track dependency relationships
+    /// between members.
+    pub all_member_deps: Option<FxHashSet<Package>>,
 }
 
 #[derive(Deserialize, Default, Debug, Clone, Eq, PartialEq)]
@@ -334,6 +339,8 @@ impl CargoWorkspace {
         let mut is_virtual_workspace = true;
         let mut requires_rustc_private = false;
 
+        let mut members = FxHashSet::default();
+
         meta.packages.sort_by(|a, b| a.id.cmp(&b.id));
         for meta_pkg in meta.packages {
             let cargo_metadata::Package {
@@ -356,6 +363,7 @@ impl CargoWorkspace {
                 rust_version,
                 ..
             } = meta_pkg;
+            let id = Arc::new(id);
             let meta = from_value::<PackageMetadata>(metadata).unwrap_or_default();
             let edition = match edition {
                 cargo_metadata::Edition::E2015 => Edition::Edition2015,
@@ -375,7 +383,7 @@ impl CargoWorkspace {
             let manifest = ManifestPath::try_from(AbsPathBuf::assert(manifest_path)).unwrap();
             is_virtual_workspace &= manifest != ws_manifest_path;
             let pkg = packages.alloc(PackageData {
-                id: id.repr.clone(),
+                id: id.clone(),
                 name: name.to_string(),
                 version,
                 manifest: manifest.clone(),
@@ -395,7 +403,11 @@ impl CargoWorkspace {
                 features: features.into_iter().collect(),
                 active_features: Vec::new(),
                 metadata: meta.rust_analyzer.unwrap_or_default(),
+                all_member_deps: None,
             });
+            if is_member {
+                members.insert(pkg);
+            }
             let pkg_data = &mut packages[pkg];
             requires_rustc_private |= pkg_data.metadata.rustc_private;
             pkg_by_id.insert(id, pkg);
@@ -440,6 +452,43 @@ impl CargoWorkspace {
                 .extend(node.features.into_iter().map(|it| it.to_string()));
         }
 
+        fn saturate_all_member_deps(
+            packages: &mut Arena<PackageData>,
+            to_visit: Package,
+            visited: &mut FxHashSet<Package>,
+            members: &FxHashSet<Package>,
+        ) {
+            let pkg_data = &mut packages[to_visit];
+
+            if !visited.insert(to_visit) {
+                return;
+            }
+
+            let deps: Vec<_> = pkg_data
+                .dependencies
+                .iter()
+                .filter_map(|dep| {
+                    let pkg = dep.pkg;
+                    if members.contains(&pkg) { Some(pkg) } else { None }
+                })
+                .collect();
+
+            let mut all_member_deps = FxHashSet::from_iter(deps.iter().copied());
+            for dep in deps {
+                saturate_all_member_deps(packages, dep, visited, members);
+                if let Some(transitives) = &packages[dep].all_member_deps {
+                    all_member_deps.extend(transitives);
+                }
+            }
+
+            packages[to_visit].all_member_deps = Some(all_member_deps);
+        }
+
+        let mut visited = FxHashSet::default();
+        for member in members.iter() {
+            saturate_all_member_deps(&mut packages, *member, &mut visited, &members);
+        }
+
         CargoWorkspace {
             packages,
             targets,
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/diagnostics.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/diagnostics.rs
index ee50237c405e6..4bfad98b39976 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/diagnostics.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/diagnostics.rs
@@ -120,6 +120,29 @@ impl DiagnosticCollection {
         }
     }
 
+    pub(crate) fn clear_check_older_than_for_package(
+        &mut self,
+        flycheck_id: usize,
+        package_id: Arc<PackageId>,
+        generation: DiagnosticsGeneration,
+    ) {
+        let Some(check) = self.check.get_mut(flycheck_id) else {
+            return;
+        };
+        let package_id = Some(package_id);
+        let Some((_, checks)) = check
+            .per_package
+            .extract_if(|k, v| *k == package_id && v.generation < generation)
+            .next()
+        else {
+            return;
+        };
+        self.changes.extend(checks.per_file.into_keys());
+        if let Some(fixes) = Arc::make_mut(&mut self.check_fixes).get_mut(flycheck_id) {
+            fixes.remove(&package_id);
+        }
+    }
+
     pub(crate) fn clear_native_for(&mut self, file_id: FileId) {
         self.native_syntax.remove(&file_id);
         self.native_semantic.remove(&file_id);
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs
index 315c45d5b6392..cded34be14a28 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/flycheck.rs
@@ -180,17 +180,27 @@ impl FlycheckHandle {
     pub(crate) fn restart_workspace(&self, saved_file: Option<AbsPathBuf>) {
         let generation = self.generation.fetch_add(1, Ordering::Relaxed) + 1;
         self.sender
-            .send(StateChange::Restart { generation, package: None, saved_file, target: None })
+            .send(StateChange::Restart {
+                generation,
+                scope: FlycheckScope::Workspace,
+                saved_file,
+                target: None,
+            })
             .unwrap();
     }
 
     /// Schedule a re-start of the cargo check worker to do a package wide check.
-    pub(crate) fn restart_for_package(&self, package: String, target: Option<Target>) {
+    pub(crate) fn restart_for_package(
+        &self,
+        package: Arc<PackageId>,
+        target: Option<Target>,
+        workspace_deps: Option<FxHashSet<Arc<PackageId>>>,
+    ) {
         let generation = self.generation.fetch_add(1, Ordering::Relaxed) + 1;
         self.sender
             .send(StateChange::Restart {
                 generation,
-                package: Some(package),
+                scope: FlycheckScope::Package { package, workspace_deps },
                 saved_file: None,
                 target,
             })
@@ -213,8 +223,13 @@ impl FlycheckHandle {
 
 #[derive(Debug)]
 pub(crate) enum ClearDiagnosticsKind {
-    All,
-    OlderThan(DiagnosticsGeneration),
+    All(ClearScope),
+    OlderThan(DiagnosticsGeneration, ClearScope),
+}
+
+#[derive(Debug)]
+pub(crate) enum ClearScope {
+    Workspace,
     Package(Arc<PackageId>),
 }
 
@@ -275,10 +290,15 @@ pub(crate) enum Progress {
     DidFailToRestart(String),
 }
 
+enum FlycheckScope {
+    Workspace,
+    Package { package: Arc<PackageId>, workspace_deps: Option<FxHashSet<Arc<PackageId>>> },
+}
+
 enum StateChange {
     Restart {
         generation: DiagnosticsGeneration,
-        package: Option<String>,
+        scope: FlycheckScope,
         saved_file: Option<AbsPathBuf>,
         target: Option<Target>,
     },
@@ -298,6 +318,7 @@ struct FlycheckActor {
     /// or the project root of the project.
     root: Arc<AbsPathBuf>,
     sysroot_root: Option<AbsPathBuf>,
+    scope: FlycheckScope,
     /// CargoHandle exists to wrap around the communication needed to be able to
     /// run `cargo check` without blocking. Currently the Rust standard library
     /// doesn't provide a way to read sub-process output without blocking, so we
@@ -343,6 +364,7 @@ impl FlycheckActor {
             config,
             sysroot_root,
             root: Arc::new(workspace_root),
+            scope: FlycheckScope::Workspace,
             manifest_path,
             command_handle: None,
             command_receiver: None,
@@ -376,7 +398,7 @@ impl FlycheckActor {
                 }
                 Event::RequestStateChange(StateChange::Restart {
                     generation,
-                    package,
+                    scope,
                     saved_file,
                     target,
                 }) => {
@@ -389,11 +411,11 @@ impl FlycheckActor {
                         }
                     }
 
+                    let command = self.check_command(&scope, saved_file.as_deref(), target);
+                    self.scope = scope;
                     self.generation = generation;
 
-                    let Some(command) =
-                        self.check_command(package.as_deref(), saved_file.as_deref(), target)
-                    else {
+                    let Some(command) = command else {
                         continue;
                     };
 
@@ -435,19 +457,55 @@ impl FlycheckActor {
                         tracing::trace!(flycheck_id = self.id, "clearing diagnostics");
                         // We finished without receiving any diagnostics.
                         // Clear everything for good measure
-                        self.send(FlycheckMessage::ClearDiagnostics {
-                            id: self.id,
-                            kind: ClearDiagnosticsKind::All,
-                        });
+                        match &self.scope {
+                            FlycheckScope::Workspace => {
+                                self.send(FlycheckMessage::ClearDiagnostics {
+                                    id: self.id,
+                                    kind: ClearDiagnosticsKind::All(ClearScope::Workspace),
+                                });
+                            }
+                            FlycheckScope::Package { package, workspace_deps } => {
+                                for pkg in
+                                    std::iter::once(package).chain(workspace_deps.iter().flatten())
+                                {
+                                    self.send(FlycheckMessage::ClearDiagnostics {
+                                        id: self.id,
+                                        kind: ClearDiagnosticsKind::All(ClearScope::Package(
+                                            pkg.clone(),
+                                        )),
+                                    });
+                                }
+                            }
+                        }
                     } else if res.is_ok() {
                         // We clear diagnostics for packages on
                         // `[CargoCheckMessage::CompilerArtifact]` but there seem to be setups where
                         // cargo may not report an artifact to our runner at all. To handle such
                         // cases, clear stale diagnostics when flycheck completes successfully.
-                        self.send(FlycheckMessage::ClearDiagnostics {
-                            id: self.id,
-                            kind: ClearDiagnosticsKind::OlderThan(self.generation),
-                        });
+                        match &self.scope {
+                            FlycheckScope::Workspace => {
+                                self.send(FlycheckMessage::ClearDiagnostics {
+                                    id: self.id,
+                                    kind: ClearDiagnosticsKind::OlderThan(
+                                        self.generation,
+                                        ClearScope::Workspace,
+                                    ),
+                                });
+                            }
+                            FlycheckScope::Package { package, workspace_deps } => {
+                                for pkg in
+                                    std::iter::once(package).chain(workspace_deps.iter().flatten())
+                                {
+                                    self.send(FlycheckMessage::ClearDiagnostics {
+                                        id: self.id,
+                                        kind: ClearDiagnosticsKind::OlderThan(
+                                            self.generation,
+                                            ClearScope::Package(pkg.clone()),
+                                        ),
+                                    });
+                                }
+                            }
+                        }
                     }
                     self.clear_diagnostics_state();
 
@@ -475,7 +533,7 @@ impl FlycheckActor {
                             );
                             self.send(FlycheckMessage::ClearDiagnostics {
                                 id: self.id,
-                                kind: ClearDiagnosticsKind::Package(package_id),
+                                kind: ClearDiagnosticsKind::All(ClearScope::Package(package_id)),
                             });
                         }
                     }
@@ -498,7 +556,9 @@ impl FlycheckActor {
                                 );
                                 self.send(FlycheckMessage::ClearDiagnostics {
                                     id: self.id,
-                                    kind: ClearDiagnosticsKind::Package(package_id.clone()),
+                                    kind: ClearDiagnosticsKind::All(ClearScope::Package(
+                                        package_id.clone(),
+                                    )),
                                 });
                             }
                         } else if self.diagnostics_received
@@ -507,7 +567,7 @@ impl FlycheckActor {
                             self.diagnostics_received = DiagnosticsReceived::YesAndClearedForAll;
                             self.send(FlycheckMessage::ClearDiagnostics {
                                 id: self.id,
-                                kind: ClearDiagnosticsKind::All,
+                                kind: ClearDiagnosticsKind::All(ClearScope::Workspace),
                             });
                         }
                         self.send(FlycheckMessage::AddDiagnostic {
@@ -548,7 +608,7 @@ impl FlycheckActor {
     /// return None.
     fn check_command(
         &self,
-        package: Option<&str>,
+        scope: &FlycheckScope,
         saved_file: Option<&AbsPath>,
         target: Option<Target>,
     ) -> Option<Command> {
@@ -564,9 +624,9 @@ impl FlycheckActor {
                 }
                 cmd.arg(command);
 
-                match package {
-                    Some(pkg) => cmd.arg("-p").arg(pkg),
-                    None => cmd.arg("--workspace"),
+                match scope {
+                    FlycheckScope::Workspace => cmd.arg("--workspace"),
+                    FlycheckScope::Package { package, .. } => cmd.arg("-p").arg(&package.repr),
                 };
 
                 if let Some(tgt) = target {
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/global_state.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/global_state.rs
index 89d6fb8edc2e6..ce6644f725ca6 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/global_state.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/global_state.rs
@@ -9,6 +9,7 @@ use std::{
     time::{Duration, Instant},
 };
 
+use cargo_metadata::PackageId;
 use crossbeam_channel::{Receiver, Sender, unbounded};
 use hir::ChangeWithProcMacros;
 use ide::{Analysis, AnalysisHost, Cancellable, FileId, SourceRootId};
@@ -784,6 +785,7 @@ impl GlobalStateSnapshot {
                         cargo_toml: package_data.manifest.clone(),
                         crate_id,
                         package: cargo.package_flag(package_data),
+                        package_id: package_data.id.clone(),
                         target: target_data.name.clone(),
                         target_kind: target_data.kind,
                         required_features: target_data.required_features.clone(),
@@ -812,6 +814,27 @@ impl GlobalStateSnapshot {
         None
     }
 
+    pub(crate) fn all_workspace_dependencies_for_package(
+        &self,
+        package: &Arc<PackageId>,
+    ) -> Option<FxHashSet<Arc<PackageId>>> {
+        for workspace in self.workspaces.iter() {
+            match &workspace.kind {
+                ProjectWorkspaceKind::Cargo { cargo, .. }
+                | ProjectWorkspaceKind::DetachedFile { cargo: Some((cargo, _, _)), .. } => {
+                    let package = cargo.packages().find(|p| cargo[*p].id == *package)?;
+
+                    return cargo[package]
+                        .all_member_deps
+                        .as_ref()
+                        .map(|deps| deps.iter().map(|dep| cargo[*dep].id.clone()).collect());
+                }
+                _ => {}
+            }
+        }
+        None
+    }
+
     pub(crate) fn file_exists(&self, file_id: FileId) -> bool {
         self.vfs.read().0.exists(file_id)
     }
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/notification.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/notification.rs
index 68c91a653940b..87be09dcbd275 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/notification.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/notification.rs
@@ -331,7 +331,7 @@ fn run_flycheck(state: &mut GlobalState, vfs_path: VfsPath) -> bool {
                         let target = TargetSpec::for_file(&world, file_id)?.and_then(|it| {
                             let tgt_kind = it.target_kind();
                             let (tgt_name, root, package) = match it {
-                                TargetSpec::Cargo(c) => (c.target, c.workspace_root, c.package),
+                                TargetSpec::Cargo(c) => (c.target, c.workspace_root, c.package_id),
                                 _ => return None,
                             };
 
@@ -368,7 +368,13 @@ fn run_flycheck(state: &mut GlobalState, vfs_path: VfsPath) -> bool {
                                         _ => false,
                                     });
                                 if let Some(idx) = package_workspace_idx {
-                                    world.flycheck[idx].restart_for_package(package, target);
+                                    let workspace_deps =
+                                        world.all_workspace_dependencies_for_package(&package);
+                                    world.flycheck[idx].restart_for_package(
+                                        package,
+                                        target,
+                                        workspace_deps,
+                                    );
                                 }
                             }
                         }
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs
index c6762f318326a..3e80e8b7bdfb5 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs
@@ -20,7 +20,7 @@ use crate::{
     config::Config,
     diagnostics::{DiagnosticsGeneration, NativeDiagnosticsFetchKind, fetch_native_diagnostics},
     discover::{DiscoverArgument, DiscoverCommand, DiscoverProjectMessage},
-    flycheck::{self, ClearDiagnosticsKind, FlycheckMessage},
+    flycheck::{self, ClearDiagnosticsKind, ClearScope, FlycheckMessage},
     global_state::{
         FetchBuildDataResponse, FetchWorkspaceRequest, FetchWorkspaceResponse, GlobalState,
         file_id_to_url, url_to_file_id,
@@ -1042,17 +1042,22 @@ impl GlobalState {
                     };
                 }
             }
-            FlycheckMessage::ClearDiagnostics { id, kind: ClearDiagnosticsKind::All } => {
-                self.diagnostics.clear_check(id)
-            }
             FlycheckMessage::ClearDiagnostics {
                 id,
-                kind: ClearDiagnosticsKind::OlderThan(generation),
-            } => self.diagnostics.clear_check_older_than(id, generation),
+                kind: ClearDiagnosticsKind::All(ClearScope::Workspace),
+            } => self.diagnostics.clear_check(id),
             FlycheckMessage::ClearDiagnostics {
                 id,
-                kind: ClearDiagnosticsKind::Package(package_id),
+                kind: ClearDiagnosticsKind::All(ClearScope::Package(package_id)),
             } => self.diagnostics.clear_check_for_package(id, package_id),
+            FlycheckMessage::ClearDiagnostics {
+                id,
+                kind: ClearDiagnosticsKind::OlderThan(generation, ClearScope::Workspace),
+            } => self.diagnostics.clear_check_older_than(id, generation),
+            FlycheckMessage::ClearDiagnostics {
+                id,
+                kind: ClearDiagnosticsKind::OlderThan(generation, ClearScope::Package(package_id)),
+            } => self.diagnostics.clear_check_older_than_for_package(id, package_id, generation),
             FlycheckMessage::Progress { id, progress } => {
                 let (state, message) = match progress {
                     flycheck::Progress::DidStart => (Progress::Begin, None),
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/target_spec.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/target_spec.rs
index 7132e09146ebc..e532d155536c1 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/target_spec.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/target_spec.rs
@@ -2,12 +2,14 @@
 
 use std::mem;
 
+use cargo_metadata::PackageId;
 use cfg::{CfgAtom, CfgExpr};
 use hir::sym;
 use ide::{Cancellable, Crate, FileId, RunnableKind, TestId};
 use project_model::project_json::Runnable;
 use project_model::{CargoFeatures, ManifestPath, TargetKind};
 use rustc_hash::FxHashSet;
+use triomphe::Arc;
 use vfs::AbsPathBuf;
 
 use crate::global_state::GlobalStateSnapshot;
@@ -52,6 +54,7 @@ pub(crate) struct CargoTargetSpec {
     pub(crate) workspace_root: AbsPathBuf,
     pub(crate) cargo_toml: ManifestPath,
     pub(crate) package: String,
+    pub(crate) package_id: Arc<PackageId>,
     pub(crate) target: String,
     pub(crate) target_kind: TargetKind,
     pub(crate) crate_id: Crate,

From 7eea65f8e0544d3e51ce383513c0108e9d02e874 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mateusz=20Miku=C5=82a?= <oss@mateuszmikula.dev>
Date: Fri, 19 Sep 2025 10:57:03 +0200
Subject: [PATCH 1151/1889] Stop linking rs{begin,end} on x86_64-*-windows-gnu

Until now, x86_64-pc-windows-gnu linked `rsbegin.o` and `rsend.o` just
like i686-pc-windows-gnu, even though they were no-ops for it.
This was likely done for the simplicity back when it was introduced.

Today the things are different and these startup/end objects harm other
features, like `build-std`. Given the demotion of i686-pc-windows-gnu
from tier 1, there is no point in hurting x86_64-pc-windows-gnu,
which remains a tier 1.

The files are still shipped in case downstream crates expect them, as in
case of the unmaintained `xargo`.
---
 .../rustc_target/src/spec/base/windows_gnu.rs   |  3 ---
 compiler/rustc_target/src/spec/crt_objects.rs   | 17 ++++++++++++++---
 .../src/spec/targets/i686_pc_windows_gnu.rs     |  8 +++++++-
 src/bootstrap/src/core/build_steps/compile.rs   |  2 ++
 4 files changed, 23 insertions(+), 7 deletions(-)

diff --git a/compiler/rustc_target/src/spec/base/windows_gnu.rs b/compiler/rustc_target/src/spec/base/windows_gnu.rs
index 4ba1102198847..2867428e42f7a 100644
--- a/compiler/rustc_target/src/spec/base/windows_gnu.rs
+++ b/compiler/rustc_target/src/spec/base/windows_gnu.rs
@@ -93,10 +93,7 @@ pub(crate) fn opts() -> TargetOptions {
         binary_format: BinaryFormat::Coff,
         allows_weak_linkage: false,
         pre_link_args,
-        pre_link_objects: crt_objects::pre_mingw(),
-        post_link_objects: crt_objects::post_mingw(),
         pre_link_objects_self_contained: crt_objects::pre_mingw_self_contained(),
-        post_link_objects_self_contained: crt_objects::post_mingw_self_contained(),
         link_self_contained: LinkSelfContainedDefault::InferredForMingw,
         late_link_args,
         late_link_args_dynamic,
diff --git a/compiler/rustc_target/src/spec/crt_objects.rs b/compiler/rustc_target/src/spec/crt_objects.rs
index e3b6430a46371..2d84e78f25572 100644
--- a/compiler/rustc_target/src/spec/crt_objects.rs
+++ b/compiler/rustc_target/src/spec/crt_objects.rs
@@ -85,6 +85,17 @@ pub(super) fn post_musl_self_contained() -> CrtObjects {
 }
 
 pub(super) fn pre_mingw_self_contained() -> CrtObjects {
+    new(&[
+        (LinkOutputKind::DynamicNoPicExe, &["crt2.o"]),
+        (LinkOutputKind::DynamicPicExe, &["crt2.o"]),
+        (LinkOutputKind::StaticNoPicExe, &["crt2.o"]),
+        (LinkOutputKind::StaticPicExe, &["crt2.o"]),
+        (LinkOutputKind::DynamicDylib, &["dllcrt2.o"]),
+        (LinkOutputKind::StaticDylib, &["dllcrt2.o"]),
+    ])
+}
+
+pub(super) fn pre_i686_mingw_self_contained() -> CrtObjects {
     new(&[
         (LinkOutputKind::DynamicNoPicExe, &["crt2.o", "rsbegin.o"]),
         (LinkOutputKind::DynamicPicExe, &["crt2.o", "rsbegin.o"]),
@@ -95,15 +106,15 @@ pub(super) fn pre_mingw_self_contained() -> CrtObjects {
     ])
 }
 
-pub(super) fn post_mingw_self_contained() -> CrtObjects {
+pub(super) fn post_i686_mingw_self_contained() -> CrtObjects {
     all("rsend.o")
 }
 
-pub(super) fn pre_mingw() -> CrtObjects {
+pub(super) fn pre_i686_mingw() -> CrtObjects {
     all("rsbegin.o")
 }
 
-pub(super) fn post_mingw() -> CrtObjects {
+pub(super) fn post_i686_mingw() -> CrtObjects {
     all("rsend.o")
 }
 
diff --git a/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnu.rs b/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnu.rs
index e775c8fc524c4..a0d403bd05e69 100644
--- a/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnu.rs
+++ b/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnu.rs
@@ -1,4 +1,6 @@
-use crate::spec::{Cc, FramePointer, LinkerFlavor, Lld, RustcAbi, Target, TargetMetadata, base};
+use crate::spec::{
+    Cc, FramePointer, LinkerFlavor, Lld, RustcAbi, Target, TargetMetadata, base, crt_objects,
+};
 
 pub(crate) fn target() -> Target {
     let mut base = base::windows_gnu::opts();
@@ -15,6 +17,10 @@ pub(crate) fn target() -> Target {
         &["-m", "i386pe", "--large-address-aware"],
     );
     base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-Wl,--large-address-aware"]);
+    base.pre_link_objects = crt_objects::pre_i686_mingw();
+    base.post_link_objects = crt_objects::post_i686_mingw();
+    base.pre_link_objects_self_contained = crt_objects::pre_i686_mingw_self_contained();
+    base.post_link_objects_self_contained = crt_objects::post_i686_mingw_self_contained();
 
     Target {
         llvm_target: "i686-pc-windows-gnu".into(),
diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index 14104d7d1d783..6daf82d4e6834 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -895,6 +895,8 @@ impl Step for StartupObjects {
     fn run(self, builder: &Builder<'_>) -> Vec<(PathBuf, DependencyType)> {
         let for_compiler = self.compiler;
         let target = self.target;
+        // Even though no longer necessary on x86_64, they are kept for now to
+        // avoid potential issues in downstream crates.
         if !target.is_windows_gnu() {
             return vec![];
         }

From e2de670558111dc6ce46d764aed6cb3dc4222794 Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Fri, 19 Sep 2025 17:21:55 +0000
Subject: [PATCH 1152/1889] btree: safety comments for init and new

---
 library/alloc/src/collections/btree/node.rs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/library/alloc/src/collections/btree/node.rs b/library/alloc/src/collections/btree/node.rs
index 37f784a322cad..b233e1740b7b7 100644
--- a/library/alloc/src/collections/btree/node.rs
+++ b/library/alloc/src/collections/btree/node.rs
@@ -67,6 +67,10 @@ struct LeafNode<K, V> {
 
 impl<K, V> LeafNode<K, V> {
     /// Initializes a new `LeafNode` in-place.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `this` points to a (possibly uninitialized) `LeafNode`
     unsafe fn init(this: *mut Self) {
         // As a general policy, we leave fields uninitialized if they can be, as this should
         // be both slightly faster and easier to track in Valgrind.
@@ -79,9 +83,11 @@ impl<K, V> LeafNode<K, V> {
 
     /// Creates a new boxed `LeafNode`.
     fn new<A: Allocator + Clone>(alloc: A) -> Box<Self, A> {
+        let mut leaf = Box::new_uninit_in(alloc);
         unsafe {
-            let mut leaf = Box::new_uninit_in(alloc);
+            // SAFETY: `leaf` points to a `LeafNode`
             LeafNode::init(leaf.as_mut_ptr());
+            // SAFETY: `leaf` was just initialized
             leaf.assume_init()
         }
     }

From e32b975e840e99748b947884505b74ebe4bd23b9 Mon Sep 17 00:00:00 2001
From: Augie Fackler <augie@google.com>
Date: Thu, 18 Sep 2025 14:23:43 -0400
Subject: [PATCH 1153/1889] tests: relax expectations after llvm change
 902ddda120a5

LLVM 22 is able to drop assumes that seem to not help further
optimizations, which actually seems to dramatically _help_ further
optimizations in some of our small test cases.
---
 .../issues/issue-122600-ptr-discriminant-update.rs         | 7 +++++--
 tests/codegen-llvm/vec_pop_push_noop.rs                    | 5 ++++-
 tests/codegen-llvm/vecdeque_pop_push.rs                    | 5 ++++-
 3 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/tests/codegen-llvm/issues/issue-122600-ptr-discriminant-update.rs b/tests/codegen-llvm/issues/issue-122600-ptr-discriminant-update.rs
index 853a1ff36b109..631468d8c217a 100644
--- a/tests/codegen-llvm/issues/issue-122600-ptr-discriminant-update.rs
+++ b/tests/codegen-llvm/issues/issue-122600-ptr-discriminant-update.rs
@@ -1,4 +1,7 @@
 //@ compile-flags: -Copt-level=3
+//@ revisions: new old
+//@ [old] ignore-llvm-version: 22 - 99
+//@ [new] min-llvm-version: 22
 
 #![crate_type = "lib"]
 
@@ -22,8 +25,8 @@ pub unsafe fn update(s: *mut State) {
     // CHECK-NOT: memcpy
     // CHECK-NOT: 75{{3|4}}
 
-    // CHECK: %[[TAG:.+]] = load i8, ptr %s, align 1
-    // CHECK-NEXT: trunc nuw i8 %[[TAG]] to i1
+    // old: %[[TAG:.+]] = load i8, ptr %s, align 1
+    // old-NEXT: trunc nuw i8 %[[TAG]] to i1
 
     // CHECK-NOT: load
     // CHECK-NOT: store
diff --git a/tests/codegen-llvm/vec_pop_push_noop.rs b/tests/codegen-llvm/vec_pop_push_noop.rs
index 3e375219fe018..fadc6e99dc7a6 100644
--- a/tests/codegen-llvm/vec_pop_push_noop.rs
+++ b/tests/codegen-llvm/vec_pop_push_noop.rs
@@ -1,4 +1,7 @@
 //@ compile-flags: -Copt-level=3
+//@ revisions: new old
+//@ [old] ignore-llvm-version: 22 - 99
+//@ [new] min-llvm-version: 22
 
 #![crate_type = "lib"]
 
@@ -7,7 +10,7 @@
 pub fn noop(v: &mut Vec<u8>) {
     // CHECK-NOT: grow_one
     // CHECK-NOT: call
-    // CHECK: tail call void @llvm.assume
+    // old: tail call void @llvm.assume
     // CHECK-NOT: grow_one
     // CHECK-NOT: call
     // CHECK: {{ret|[}]}}
diff --git a/tests/codegen-llvm/vecdeque_pop_push.rs b/tests/codegen-llvm/vecdeque_pop_push.rs
index 5afa1b2248b0e..7886db3fedeba 100644
--- a/tests/codegen-llvm/vecdeque_pop_push.rs
+++ b/tests/codegen-llvm/vecdeque_pop_push.rs
@@ -1,4 +1,7 @@
 //@ compile-flags: -Copt-level=3
+//@ revisions: new old
+//@ [old] ignore-llvm-version: 22 - 99
+//@ [new] min-llvm-version: 22
 
 #![crate_type = "lib"]
 
@@ -8,7 +11,7 @@ use std::collections::VecDeque;
 // CHECK-LABEL: @noop_back(
 pub fn noop_back(v: &mut VecDeque<u8>) {
     // CHECK-NOT: grow
-    // CHECK: tail call void @llvm.assume
+    // old: tail call void @llvm.assume
     // CHECK-NOT: grow
     // CHECK: ret
     if let Some(x) = v.pop_back() {

From 696add0d477a65d6a79d97c6b8e0f4ab9268bb89 Mon Sep 17 00:00:00 2001
From: sysrex <769991+sysrex@users.noreply.github.com>
Date: Fri, 19 Sep 2025 19:04:48 +0100
Subject: [PATCH 1154/1889] chore: fixes #146756

---
 CONTRIBUTING.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index aadc7c48ea839..5b52c3dfff61d 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -31,8 +31,8 @@ bootstrapping, the compiler architecture, source code representation, and more.
 
 ## [Getting help](https://rustc-dev-guide.rust-lang.org/getting-started.html#asking-questions)
 
-There are many ways you can get help when you're stuck. Rust has many platforms for this:
-[internals], [rust-zulip], and [rust-discord]. It is recommended to ask for help on
+There are many ways you can get help when you're stuck. Rust has two platforms for this:
+[internals] and [rust-zulip]. It is recommended to ask for help on
 the [rust-zulip], but any of these platforms are great ways to seek help and even
 find a mentor! You can learn more about asking questions and getting help in the
 [Asking Questions](https://rustc-dev-guide.rust-lang.org/getting-started.html#asking-questions) chapter of the [rustc-dev-guide].

From 4b755141bc297444401397b09995bb2baafb3fc2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Fri, 19 Sep 2025 16:00:05 +0200
Subject: [PATCH 1155/1889] Simplify default value of `download-ci-llvm`

---
 src/bootstrap/src/core/config/config.rs | 15 ++++-----------
 1 file changed, 4 insertions(+), 11 deletions(-)

diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index efb7ad9169971..3dd1b0160a974 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -2134,15 +2134,7 @@ pub fn parse_download_ci_llvm<'a>(
     asserts: bool,
 ) -> bool {
     let dwn_ctx = dwn_ctx.as_ref();
-
-    // We don't ever want to use `true` on CI, as we should not
-    // download upstream artifacts if there are any local modifications.
-    let default = if dwn_ctx.is_running_on_ci {
-        StringOrBool::String("if-unchanged".to_string())
-    } else {
-        StringOrBool::Bool(true)
-    };
-    let download_ci_llvm = download_ci_llvm.unwrap_or(default);
+    let download_ci_llvm = download_ci_llvm.unwrap_or(StringOrBool::Bool(true));
 
     let if_unchanged = || {
         if rust_info.is_from_tarball() {
@@ -2174,8 +2166,9 @@ pub fn parse_download_ci_llvm<'a>(
                 );
             }
 
-            if b && dwn_ctx.is_running_on_ci {
-                // On CI, we must always rebuild LLVM if there were any modifications to it
+            #[cfg(not(test))]
+            if b && dwn_ctx.is_running_on_ci && CiEnv::is_rust_lang_managed_ci_job() {
+                // On rust-lang CI, we must always rebuild LLVM if there were any modifications to it
                 panic!(
                     "`llvm.download-ci-llvm` cannot be set to `true` on CI. Use `if-unchanged` instead."
                 );

From 82eed00d3979b74315f66201c6bf4d3f00d38c25 Mon Sep 17 00:00:00 2001
From: Scott Schafer <schaferjscott@gmail.com>
Date: Tue, 16 Sep 2025 01:48:24 -0600
Subject: [PATCH 1156/1889] chore(compiletest): Use newest anstyle-svg version

---
 Cargo.lock                                                  | 6 +++---
 src/tools/compiletest/Cargo.toml                            | 2 +-
 tests/ui/codemap_tests/huge_multispan_highlight.ascii.svg   | 4 ++--
 tests/ui/codemap_tests/huge_multispan_highlight.unicode.svg | 4 ++--
 tests/ui/diagnostic-flags/colored-session-opt-error.svg     | 4 ++--
 tests/ui/error-emitter/E0308-clarification.svg              | 2 +-
 tests/ui/error-emitter/highlighting.svg                     | 2 +-
 tests/ui/error-emitter/highlighting.windows.svg             | 2 +-
 tests/ui/error-emitter/multiline-multipart-suggestion.svg   | 2 +-
 .../multiline-multipart-suggestion.windows.svg              | 2 +-
 tests/ui/error-emitter/multiline-removal-suggestion.svg     | 4 ++--
 tests/ui/error-emitter/unicode-output.svg                   | 2 +-
 ...ht-difference-between-expected-trait-and-found-trait.svg | 4 ++--
 tests/ui/suggestions/incorrect-variant-literal.svg          | 2 +-
 14 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d39cfefea0c77..71343a48be771 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -128,9 +128,9 @@ dependencies = [
 
 [[package]]
 name = "anstyle-svg"
-version = "0.1.10"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc03a770ef506fe1396c0e476120ac0e6523cf14b74218dd5f18cd6833326fa9"
+checksum = "26b9ec8c976eada1b0f9747a3d7cc4eae3bef10613e443746e7487f26c872fde"
 dependencies = [
  "anstyle",
  "anstyle-lossy",
@@ -674,7 +674,7 @@ checksum = "fe6d2e5af09e8c8ad56c969f2157a3d4238cebc7c55f0a517728c38f7b200f81"
 dependencies = [
  "serde",
  "termcolor",
- "unicode-width 0.1.14",
+ "unicode-width 0.2.1",
 ]
 
 [[package]]
diff --git a/src/tools/compiletest/Cargo.toml b/src/tools/compiletest/Cargo.toml
index cdada5a223062..6597c3c70f691 100644
--- a/src/tools/compiletest/Cargo.toml
+++ b/src/tools/compiletest/Cargo.toml
@@ -12,7 +12,7 @@ path = "src/bin/main.rs"
 
 [dependencies]
 # tidy-alphabetical-start
-anstyle-svg = "0.1.3"
+anstyle-svg = "0.1.11"
 build_helper = { path = "../../build_helper" }
 camino = "1"
 colored = "2"
diff --git a/tests/ui/codemap_tests/huge_multispan_highlight.ascii.svg b/tests/ui/codemap_tests/huge_multispan_highlight.ascii.svg
index 1cedbf75e4bf6..7ffbc64b074bf 100644
--- a/tests/ui/codemap_tests/huge_multispan_highlight.ascii.svg
+++ b/tests/ui/codemap_tests/huge_multispan_highlight.ascii.svg
@@ -1,7 +1,7 @@
-<svg width="743px" height="758px" xmlns="http://www.w3.org/2000/svg">
+<svg width="740px" height="758px" xmlns="http://www.w3.org/2000/svg">
   <style>
     .fg { fill: #AAAAAA }
-    .bg { background: #000000 }
+    .bg { fill: #000000 }
     .fg-ansi256-009 { fill: #FF5555 }
     .fg-ansi256-012 { fill: #5555FF }
     .container {
diff --git a/tests/ui/codemap_tests/huge_multispan_highlight.unicode.svg b/tests/ui/codemap_tests/huge_multispan_highlight.unicode.svg
index 36a33b7404264..5f1fcdb3d5087 100644
--- a/tests/ui/codemap_tests/huge_multispan_highlight.unicode.svg
+++ b/tests/ui/codemap_tests/huge_multispan_highlight.unicode.svg
@@ -1,7 +1,7 @@
-<svg width="743px" height="758px" xmlns="http://www.w3.org/2000/svg">
+<svg width="740px" height="758px" xmlns="http://www.w3.org/2000/svg">
   <style>
     .fg { fill: #AAAAAA }
-    .bg { background: #000000 }
+    .bg { fill: #000000 }
     .fg-ansi256-009 { fill: #FF5555 }
     .fg-ansi256-012 { fill: #5555FF }
     .container {
diff --git a/tests/ui/diagnostic-flags/colored-session-opt-error.svg b/tests/ui/diagnostic-flags/colored-session-opt-error.svg
index 69f452f29f31f..136c6fa562807 100644
--- a/tests/ui/diagnostic-flags/colored-session-opt-error.svg
+++ b/tests/ui/diagnostic-flags/colored-session-opt-error.svg
@@ -1,7 +1,7 @@
-<svg width="750px" height="74px" xmlns="http://www.w3.org/2000/svg">
+<svg width="740px" height="74px" xmlns="http://www.w3.org/2000/svg">
   <style>
     .fg { fill: #AAAAAA }
-    .bg { background: #000000 }
+    .bg { fill: #000000 }
     .fg-yellow { fill: #AA5500 }
     .container {
       padding: 0 10px;
diff --git a/tests/ui/error-emitter/E0308-clarification.svg b/tests/ui/error-emitter/E0308-clarification.svg
index 9432e3a4ee918..03ee973882da8 100644
--- a/tests/ui/error-emitter/E0308-clarification.svg
+++ b/tests/ui/error-emitter/E0308-clarification.svg
@@ -1,7 +1,7 @@
 <svg width="740px" height="668px" xmlns="http://www.w3.org/2000/svg">
   <style>
     .fg { fill: #AAAAAA }
-    .bg { background: #000000 }
+    .bg { fill: #000000 }
     .fg-ansi256-009 { fill: #FF5555 }
     .fg-ansi256-012 { fill: #5555FF }
     .fg-magenta { fill: #AA00AA }
diff --git a/tests/ui/error-emitter/highlighting.svg b/tests/ui/error-emitter/highlighting.svg
index 19818ab6146c7..d414f042f0a9e 100644
--- a/tests/ui/error-emitter/highlighting.svg
+++ b/tests/ui/error-emitter/highlighting.svg
@@ -1,7 +1,7 @@
 <svg width="785px" height="434px" xmlns="http://www.w3.org/2000/svg">
   <style>
     .fg { fill: #AAAAAA }
-    .bg { background: #000000 }
+    .bg { fill: #000000 }
     .fg-ansi256-009 { fill: #FF5555 }
     .fg-ansi256-010 { fill: #55FF55 }
     .fg-ansi256-012 { fill: #5555FF }
diff --git a/tests/ui/error-emitter/highlighting.windows.svg b/tests/ui/error-emitter/highlighting.windows.svg
index f891bc1d2a687..92f9055cd1df5 100644
--- a/tests/ui/error-emitter/highlighting.windows.svg
+++ b/tests/ui/error-emitter/highlighting.windows.svg
@@ -1,7 +1,7 @@
 <svg width="785px" height="434px" xmlns="http://www.w3.org/2000/svg">
   <style>
     .fg { fill: #AAAAAA }
-    .bg { background: #000000 }
+    .bg { fill: #000000 }
     .fg-ansi256-009 { fill: #FF5555 }
     .fg-ansi256-010 { fill: #55FF55 }
     .fg-ansi256-014 { fill: #55FFFF }
diff --git a/tests/ui/error-emitter/multiline-multipart-suggestion.svg b/tests/ui/error-emitter/multiline-multipart-suggestion.svg
index dd84234236d77..5ffdc5a53fada 100644
--- a/tests/ui/error-emitter/multiline-multipart-suggestion.svg
+++ b/tests/ui/error-emitter/multiline-multipart-suggestion.svg
@@ -1,7 +1,7 @@
 <svg width="1306px" height="866px" xmlns="http://www.w3.org/2000/svg">
   <style>
     .fg { fill: #AAAAAA }
-    .bg { background: #000000 }
+    .bg { fill: #000000 }
     .fg-ansi256-009 { fill: #FF5555 }
     .fg-ansi256-010 { fill: #55FF55 }
     .fg-ansi256-012 { fill: #5555FF }
diff --git a/tests/ui/error-emitter/multiline-multipart-suggestion.windows.svg b/tests/ui/error-emitter/multiline-multipart-suggestion.windows.svg
index 144e57165da7c..37dc37e3e04c5 100644
--- a/tests/ui/error-emitter/multiline-multipart-suggestion.windows.svg
+++ b/tests/ui/error-emitter/multiline-multipart-suggestion.windows.svg
@@ -1,7 +1,7 @@
 <svg width="1306px" height="866px" xmlns="http://www.w3.org/2000/svg">
   <style>
     .fg { fill: #AAAAAA }
-    .bg { background: #000000 }
+    .bg { fill: #000000 }
     .fg-ansi256-009 { fill: #FF5555 }
     .fg-ansi256-010 { fill: #55FF55 }
     .fg-ansi256-014 { fill: #55FFFF }
diff --git a/tests/ui/error-emitter/multiline-removal-suggestion.svg b/tests/ui/error-emitter/multiline-removal-suggestion.svg
index 7a88ac55b23e2..a774d558b58a2 100644
--- a/tests/ui/error-emitter/multiline-removal-suggestion.svg
+++ b/tests/ui/error-emitter/multiline-removal-suggestion.svg
@@ -1,7 +1,7 @@
-<svg width="2238px" height="3890px" xmlns="http://www.w3.org/2000/svg">
+<svg width="2288px" height="3890px" xmlns="http://www.w3.org/2000/svg">
   <style>
     .fg { fill: #AAAAAA }
-    .bg { background: #000000 }
+    .bg { fill: #000000 }
     .fg-ansi256-009 { fill: #FF5555 }
     .fg-ansi256-010 { fill: #55FF55 }
     .fg-ansi256-012 { fill: #5555FF }
diff --git a/tests/ui/error-emitter/unicode-output.svg b/tests/ui/error-emitter/unicode-output.svg
index b253fff643b0f..bda4d1a2f284e 100644
--- a/tests/ui/error-emitter/unicode-output.svg
+++ b/tests/ui/error-emitter/unicode-output.svg
@@ -1,7 +1,7 @@
 <svg width="785px" height="434px" xmlns="http://www.w3.org/2000/svg">
   <style>
     .fg { fill: #AAAAAA }
-    .bg { background: #000000 }
+    .bg { fill: #000000 }
     .fg-ansi256-009 { fill: #FF5555 }
     .fg-ansi256-010 { fill: #55FF55 }
     .fg-ansi256-012 { fill: #5555FF }
diff --git a/tests/ui/impl-trait/diagnostics/highlight-difference-between-expected-trait-and-found-trait.svg b/tests/ui/impl-trait/diagnostics/highlight-difference-between-expected-trait-and-found-trait.svg
index 73acb072ac52a..6077dbdc200f5 100644
--- a/tests/ui/impl-trait/diagnostics/highlight-difference-between-expected-trait-and-found-trait.svg
+++ b/tests/ui/impl-trait/diagnostics/highlight-difference-between-expected-trait-and-found-trait.svg
@@ -1,7 +1,7 @@
-<svg width="1188px" height="398px" xmlns="http://www.w3.org/2000/svg">
+<svg width="1096px" height="398px" xmlns="http://www.w3.org/2000/svg">
   <style>
     .fg { fill: #AAAAAA }
-    .bg { background: #000000 }
+    .bg { fill: #000000 }
     .fg-ansi256-009 { fill: #FF5555 }
     .fg-ansi256-010 { fill: #55FF55 }
     .fg-ansi256-012 { fill: #5555FF }
diff --git a/tests/ui/suggestions/incorrect-variant-literal.svg b/tests/ui/suggestions/incorrect-variant-literal.svg
index 2cab1f4b60f64..4b952325cf7e6 100644
--- a/tests/ui/suggestions/incorrect-variant-literal.svg
+++ b/tests/ui/suggestions/incorrect-variant-literal.svg
@@ -1,7 +1,7 @@
 <svg width="886px" height="9524px" xmlns="http://www.w3.org/2000/svg">
   <style>
     .fg { fill: #AAAAAA }
-    .bg { background: #000000 }
+    .bg { fill: #000000 }
     .fg-ansi256-009 { fill: #FF5555 }
     .fg-ansi256-010 { fill: #55FF55 }
     .fg-ansi256-012 { fill: #5555FF }

From 4f02ec2cea496445b650ba686b3ef49f2f4150c4 Mon Sep 17 00:00:00 2001
From: Scott Schafer <schaferjscott@gmail.com>
Date: Tue, 16 Sep 2025 01:53:23 -0600
Subject: [PATCH 1157/1889] test: Use SVG for terminal url test

---
 tests/ui/diagnostic-flags/terminal_urls.rs    |  4 +-
 .../ui/diagnostic-flags/terminal_urls.stderr  | 11 -----
 tests/ui/diagnostic-flags/terminal_urls.svg   | 48 ++++++++++++++++++
 .../terminal_urls.windows.svg                 | 49 +++++++++++++++++++
 4 files changed, 99 insertions(+), 13 deletions(-)
 delete mode 100644 tests/ui/diagnostic-flags/terminal_urls.stderr
 create mode 100644 tests/ui/diagnostic-flags/terminal_urls.svg
 create mode 100644 tests/ui/diagnostic-flags/terminal_urls.windows.svg

diff --git a/tests/ui/diagnostic-flags/terminal_urls.rs b/tests/ui/diagnostic-flags/terminal_urls.rs
index 3c74e992395c1..631512ab579e4 100644
--- a/tests/ui/diagnostic-flags/terminal_urls.rs
+++ b/tests/ui/diagnostic-flags/terminal_urls.rs
@@ -1,4 +1,4 @@
-//@ compile-flags: -Zterminal-urls=yes
+//@ compile-flags: -Zterminal-urls=yes --error-format=human --color=always
 fn main() {
-    let () = 4; //~ ERROR
+    let () = 4;
 }
diff --git a/tests/ui/diagnostic-flags/terminal_urls.stderr b/tests/ui/diagnostic-flags/terminal_urls.stderr
deleted file mode 100644
index e5dfcdf6431a6..0000000000000
--- a/tests/ui/diagnostic-flags/terminal_urls.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-error[]8;;https://doc.rust-lang.org/error_codes/E0308.htmlE0308]8;;]: mismatched types
-  --> $DIR/terminal_urls.rs:3:9
-   |
-LL |     let () = 4;
-   |         ^^   - this expression has type `{integer}`
-   |         |
-   |         expected integer, found `()`
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/diagnostic-flags/terminal_urls.svg b/tests/ui/diagnostic-flags/terminal_urls.svg
new file mode 100644
index 0000000000000..fcb65637c4a30
--- /dev/null
+++ b/tests/ui/diagnostic-flags/terminal_urls.svg
@@ -0,0 +1,48 @@
+<svg width="740px" height="236px" xmlns="http://www.w3.org/2000/svg">
+  <style>
+    .fg { fill: #AAAAAA }
+    .bg { fill: #000000 }
+    .fg-ansi256-009 { fill: #FF5555 }
+    .fg-ansi256-012 { fill: #5555FF }
+    .container {
+      padding: 0 10px;
+      line-height: 18px;
+    }
+    .bold { font-weight: bold; }
+    tspan {
+      font: 14px SFMono-Regular, Consolas, Liberation Mono, Menlo, monospace;
+      white-space: pre;
+      line-height: 18px;
+    }
+  </style>
+
+  <rect width="100%" height="100%" y="0" rx="4.5" class="bg" />
+
+  <text xml:space="preserve" class="container fg">
+    <tspan x="10px" y="28px"><tspan class="fg-ansi256-009 bold">error[</tspan><tspan class="fg-ansi256-009 bold"><a href="https://doc.rust-lang.org/error_codes/E0308.html">E0308</a></tspan><tspan class="fg-ansi256-009 bold">]</tspan><tspan class="bold">: mismatched types</tspan>
+</tspan>
+    <tspan x="10px" y="46px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/terminal_urls.rs:3:9</tspan>
+</tspan>
+    <tspan x="10px" y="64px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="82px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>     let () = 4;</tspan>
+</tspan>
+    <tspan x="10px" y="100px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         </tspan><tspan class="fg-ansi256-009 bold">^^</tspan><tspan>   </tspan><tspan class="fg-ansi256-012 bold">-</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">this expression has type `{integer}`</tspan>
+</tspan>
+    <tspan x="10px" y="118px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         </tspan><tspan class="fg-ansi256-009 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="136px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         </tspan><tspan class="fg-ansi256-009 bold">expected integer, found `()`</tspan>
+</tspan>
+    <tspan x="10px" y="154px">
+</tspan>
+    <tspan x="10px" y="172px"><tspan class="fg-ansi256-009 bold">error</tspan><tspan class="bold">: aborting due to 1 previous error</tspan>
+</tspan>
+    <tspan x="10px" y="190px">
+</tspan>
+    <tspan x="10px" y="208px"><tspan class="bold">For more information about this error, try `rustc --explain E0308`.</tspan>
+</tspan>
+    <tspan x="10px" y="226px">
+</tspan>
+  </text>
+
+</svg>
diff --git a/tests/ui/diagnostic-flags/terminal_urls.windows.svg b/tests/ui/diagnostic-flags/terminal_urls.windows.svg
new file mode 100644
index 0000000000000..e7b4663839950
--- /dev/null
+++ b/tests/ui/diagnostic-flags/terminal_urls.windows.svg
@@ -0,0 +1,49 @@
+<svg width="740px" height="236px" xmlns="http://www.w3.org/2000/svg">
+  <style>
+    .fg { fill: #AAAAAA }
+    .bg { fill: #000000 }
+    .fg-ansi256-009 { fill: #FF5555 }
+    .fg-ansi256-014 { fill: #55FFFF }
+    .fg-ansi256-015 { fill: #FFFFFF }
+    .container {
+      padding: 0 10px;
+      line-height: 18px;
+    }
+    .bold { font-weight: bold; }
+    tspan {
+      font: 14px SFMono-Regular, Consolas, Liberation Mono, Menlo, monospace;
+      white-space: pre;
+      line-height: 18px;
+    }
+  </style>
+
+  <rect width="100%" height="100%" y="0" rx="4.5" class="bg" />
+
+  <text xml:space="preserve" class="container fg">
+    <tspan x="10px" y="28px"><tspan class="fg-ansi256-009 bold">error[</tspan><tspan class="fg-ansi256-009 bold"><a href="https://doc.rust-lang.org/error_codes/E0308.html">E0308</a></tspan><tspan class="fg-ansi256-009 bold">]</tspan><tspan class="fg-ansi256-015 bold">: mismatched types</tspan>
+</tspan>
+    <tspan x="10px" y="46px"><tspan>  </tspan><tspan class="fg-ansi256-014 bold">--&gt; </tspan><tspan>$DIR/terminal_urls.rs:3:9</tspan>
+</tspan>
+    <tspan x="10px" y="64px"><tspan>   </tspan><tspan class="fg-ansi256-014 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="82px"><tspan class="fg-ansi256-014 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-014 bold">|</tspan><tspan>     let () = 4;</tspan>
+</tspan>
+    <tspan x="10px" y="100px"><tspan>   </tspan><tspan class="fg-ansi256-014 bold">|</tspan><tspan>         </tspan><tspan class="fg-ansi256-009 bold">^^</tspan><tspan>   </tspan><tspan class="fg-ansi256-014 bold">-</tspan><tspan> </tspan><tspan class="fg-ansi256-014 bold">this expression has type `{integer}`</tspan>
+</tspan>
+    <tspan x="10px" y="118px"><tspan>   </tspan><tspan class="fg-ansi256-014 bold">|</tspan><tspan>         </tspan><tspan class="fg-ansi256-009 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="136px"><tspan>   </tspan><tspan class="fg-ansi256-014 bold">|</tspan><tspan>         </tspan><tspan class="fg-ansi256-009 bold">expected integer, found `()`</tspan>
+</tspan>
+    <tspan x="10px" y="154px">
+</tspan>
+    <tspan x="10px" y="172px"><tspan class="fg-ansi256-009 bold">error</tspan><tspan class="fg-ansi256-015 bold">: aborting due to 1 previous error</tspan>
+</tspan>
+    <tspan x="10px" y="190px">
+</tspan>
+    <tspan x="10px" y="208px"><tspan class="fg-ansi256-015 bold">For more information about this error, try `rustc --explain E0308`.</tspan>
+</tspan>
+    <tspan x="10px" y="226px">
+</tspan>
+  </text>
+
+</svg>

From 4da59355fd88ba7d92b571c8b3a59c270e1aa7da Mon Sep 17 00:00:00 2001
From: Daniel Paoliello <danpao@microsoft.com>
Date: Fri, 19 Sep 2025 09:16:26 -0700
Subject: [PATCH 1158/1889] [win] Use find-msvc-tools instead of cc to find the
 linker and rc on Windows

---
 Cargo.lock                                    | 10 ++++--
 compiler/rustc_codegen_ssa/Cargo.toml         |  4 +--
 compiler/rustc_codegen_ssa/src/back/link.rs   |  6 ++--
 compiler/rustc_codegen_ssa/src/back/linker.rs |  5 ++-
 compiler/rustc_llvm/Cargo.toml                |  3 +-
 compiler/rustc_windows_rc/Cargo.toml          |  4 +--
 compiler/rustc_windows_rc/src/lib.rs          | 34 +++----------------
 src/tools/tidy/src/deps.rs                    |  1 +
 8 files changed, 22 insertions(+), 45 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index c2e635b4cfe65..edddce6c382c1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1332,6 +1332,12 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ced73b1dacfc750a6db6c0a0c3a3853c8b41997e2e2c563dc90804ae6867959"
+
 [[package]]
 name = "flate2"
 version = "1.1.2"
@@ -3556,7 +3562,7 @@ dependencies = [
  "ar_archive_writer",
  "bitflags",
  "bstr",
- "cc",
+ "find-msvc-tools",
  "itertools",
  "libc",
  "object 0.37.3",
@@ -4760,7 +4766,7 @@ dependencies = [
 name = "rustc_windows_rc"
 version = "0.0.0"
 dependencies = [
- "cc",
+ "find-msvc-tools",
 ]
 
 [[package]]
diff --git a/compiler/rustc_codegen_ssa/Cargo.toml b/compiler/rustc_codegen_ssa/Cargo.toml
index 5462163f4ffd3..9c5a3d839ceba 100644
--- a/compiler/rustc_codegen_ssa/Cargo.toml
+++ b/compiler/rustc_codegen_ssa/Cargo.toml
@@ -8,9 +8,7 @@ edition = "2024"
 ar_archive_writer = "0.5"
 bitflags = "2.4.1"
 bstr = "1.11.3"
-# `cc` updates often break things, so we pin it here. Cargo enforces "max 1 semver-compat version
-# per crate", so if you change this, you need to also change it in `rustc_llvm` and `rustc_windows_rc`.
-cc = "=1.2.16"
+find-msvc-tools = "0.1.2"
 itertools = "0.12"
 pathdiff = "0.2.0"
 regex = "1.4"
diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
index 48b01ea2df197..371f2c1a6a299 100644
--- a/compiler/rustc_codegen_ssa/src/back/link.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -9,7 +9,7 @@ use std::path::{Path, PathBuf};
 use std::process::{Output, Stdio};
 use std::{env, fmt, fs, io, mem, str};
 
-use cc::windows_registry;
+use find_msvc_tools;
 use itertools::Itertools;
 use regex::Regex;
 use rustc_arena::TypedArena;
@@ -877,9 +877,9 @@ fn link_natively(
                     // All Microsoft `link.exe` linking ror codes are
                     // four digit numbers in the range 1000 to 9999 inclusive
                     if is_msvc_link_exe && (code < 1000 || code > 9999) {
-                        let is_vs_installed = windows_registry::find_vs_version().is_ok();
+                        let is_vs_installed = find_msvc_tools::find_vs_version().is_ok();
                         let has_linker =
-                            windows_registry::find_tool(&sess.target.arch, "link.exe").is_some();
+                            find_msvc_tools::find_tool(&sess.target.arch, "link.exe").is_some();
 
                         sess.dcx().emit_note(errors::LinkExeUnexpectedError);
 
diff --git a/compiler/rustc_codegen_ssa/src/back/linker.rs b/compiler/rustc_codegen_ssa/src/back/linker.rs
index a2efd420a327a..dff9f1eb06288 100644
--- a/compiler/rustc_codegen_ssa/src/back/linker.rs
+++ b/compiler/rustc_codegen_ssa/src/back/linker.rs
@@ -4,7 +4,7 @@ use std::io::prelude::*;
 use std::path::{Path, PathBuf};
 use std::{env, io, iter, mem, str};
 
-use cc::windows_registry;
+use find_msvc_tools;
 use rustc_hir::def_id::{CrateNum, LOCAL_CRATE};
 use rustc_metadata::{
     find_native_static_library, try_find_native_dynamic_library, try_find_native_static_library,
@@ -53,7 +53,7 @@ pub(crate) fn get_linker<'a>(
     self_contained: bool,
     target_cpu: &'a str,
 ) -> Box<dyn Linker + 'a> {
-    let msvc_tool = windows_registry::find_tool(&sess.target.arch, "link.exe");
+    let msvc_tool = find_msvc_tools::find_tool(&sess.target.arch, "link.exe");
 
     // If our linker looks like a batch script on Windows then to execute this
     // we'll need to spawn `cmd` explicitly. This is primarily done to handle
@@ -117,7 +117,6 @@ pub(crate) fn get_linker<'a>(
     if sess.target.is_like_msvc
         && let Some(ref tool) = msvc_tool
     {
-        cmd.args(tool.args());
         for (k, v) in tool.env() {
             if k == "PATH" {
                 new_path.extend(env::split_paths(v));
diff --git a/compiler/rustc_llvm/Cargo.toml b/compiler/rustc_llvm/Cargo.toml
index 0dfd1b13df502..ad93c74538130 100644
--- a/compiler/rustc_llvm/Cargo.toml
+++ b/compiler/rustc_llvm/Cargo.toml
@@ -10,8 +10,7 @@ libc = "0.2.73"
 
 [build-dependencies]
 # tidy-alphabetical-start
-# `cc` updates often break things, so we pin it here. Cargo enforces "max 1 semver-compat version
-# per crate", so if you change this, you need to also change it in `rustc_codegen_ssa` and `rustc_windows_rc`.
+# `cc` updates often break things, so we pin it here.
 cc = "=1.2.16"
 # tidy-alphabetical-end
 
diff --git a/compiler/rustc_windows_rc/Cargo.toml b/compiler/rustc_windows_rc/Cargo.toml
index 080acd35c38cb..13f716897face 100644
--- a/compiler/rustc_windows_rc/Cargo.toml
+++ b/compiler/rustc_windows_rc/Cargo.toml
@@ -5,7 +5,5 @@ edition = "2024"
 
 [dependencies]
 #tidy-alphabetical-start
-# `cc` updates often break things, so we pin it here. Cargo enforces "max 1 semver-compat version
-# per crate", so if you change this, you need to also change it in `rustc_llvm` and `rustc_codegen_ssa`.
-cc = "=1.2.16"
+find-msvc-tools = "0.1.2"
 #tidy-alphabetical-end
diff --git a/compiler/rustc_windows_rc/src/lib.rs b/compiler/rustc_windows_rc/src/lib.rs
index 5e95557501ea2..15afaf7b94b8e 100644
--- a/compiler/rustc_windows_rc/src/lib.rs
+++ b/compiler/rustc_windows_rc/src/lib.rs
@@ -2,9 +2,7 @@
 //!
 //! Uses values from the `CFG_VERSION` and `CFG_RELEASE` environment variables
 //! to set the product and file version information in the Windows resource file.
-use std::{env, ffi, fs, path, process};
-
-use cc::windows_registry;
+use std::{env, fs, path, process};
 
 /// The template for the Windows resource file.
 const RESOURCE_TEMPLATE: &str = include_str!("../rustc.rc.in");
@@ -38,7 +36,10 @@ pub fn compile_windows_resource_file(
     let resource_compiler = if let Ok(path) = env::var("RUSTC_WINDOWS_RC") {
         path.into()
     } else {
-        find_resource_compiler(&env::var("CARGO_CFG_TARGET_ARCH").unwrap()).expect("found rc.exe")
+        find_msvc_tools::find_tool(&env::var("CARGO_CFG_TARGET_ARCH").unwrap(), "rc.exe")
+            .expect("found rc.exe")
+            .path()
+            .to_owned()
     };
 
     let rc_path = resources_dir.join(file_stem.with_extension("rc"));
@@ -134,28 +135,3 @@ fn parse_version(version: &str) -> Option<ResourceVersion> {
         Some(ResourceVersion { major, minor, patch, build: 0 })
     }
 }
-
-/// Find the Windows SDK resource compiler `rc.exe` for the given architecture or target triple.
-/// Returns `None` if the tool could not be found.
-fn find_resource_compiler(arch_or_target: &str) -> Option<path::PathBuf> {
-    find_windows_sdk_tool(arch_or_target, "rc.exe")
-}
-
-/// Find a Windows SDK tool for the given architecture or target triple.
-/// Returns `None` if the tool could not be found.
-fn find_windows_sdk_tool(arch_or_target: &str, tool_name: &str) -> Option<path::PathBuf> {
-    // windows_registry::find_tool can only find MSVC tools, not Windows SDK tools, but
-    // cc does include the Windows SDK tools in the PATH environment of MSVC tools.
-
-    let msvc_linker = windows_registry::find_tool(arch_or_target, "link.exe")?;
-    let path = &msvc_linker.env().iter().find(|(k, _)| k == "PATH")?.1;
-    find_tool_in_path(tool_name, path)
-}
-
-/// Find a tool in the directories in a given PATH-like string.
-fn find_tool_in_path<P: AsRef<ffi::OsStr>>(tool_name: &str, path: P) -> Option<path::PathBuf> {
-    env::split_paths(path.as_ref()).find_map(|p| {
-        let tool_path = p.join(tool_name);
-        if tool_path.try_exists().unwrap_or(false) { Some(tool_path) } else { None }
-    })
-}
diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs
index 568ec0c119896..8a08917eb4ea2 100644
--- a/src/tools/tidy/src/deps.rs
+++ b/src/tools/tidy/src/deps.rs
@@ -365,6 +365,7 @@ const PERMITTED_RUSTC_DEPENDENCIES: &[&str] = &[
     "expect-test",
     "fallible-iterator", // dependency of `thorin`
     "fastrand",
+    "find-msvc-tools",
     "flate2",
     "fluent-bundle",
     "fluent-langneg",

From b27942853efdb2fde2b6f73023c38ebfec3fcb8f Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Fri, 19 Sep 2025 21:53:06 +0200
Subject: [PATCH 1159/1889] naked_asm: emit a label starting with `func_end`

The `cargo asm` tool pattern matches on such labels to figure out where functions end: normal functions generated by LLVM always do have such a label. We don't guarantee that naked functions emit such a label, but having `cargo asm` work is convenient
---
 compiler/rustc_codegen_ssa/src/mir/naked_asm.rs | 6 ++++++
 tests/assembly-llvm/naked-functions/wasm32.rs   | 1 +
 2 files changed, 7 insertions(+)

diff --git a/compiler/rustc_codegen_ssa/src/mir/naked_asm.rs b/compiler/rustc_codegen_ssa/src/mir/naked_asm.rs
index 31784cabf4af3..e7239ebfecf63 100644
--- a/compiler/rustc_codegen_ssa/src/mir/naked_asm.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/naked_asm.rs
@@ -228,6 +228,9 @@ fn prefix_and_suffix<'tcx>(
             writeln!(begin, "{asm_name}:").unwrap();
 
             writeln!(end).unwrap();
+            // emit a label starting with `func_end` for `cargo asm` and other tooling that might
+            // pattern match on assembly generated by LLVM.
+            writeln!(end, ".Lfunc_end_{asm_name}:").unwrap();
             writeln!(end, ".size {asm_name}, . - {asm_name}").unwrap();
             writeln!(end, ".popsection").unwrap();
             if !arch_suffix.is_empty() {
@@ -246,6 +249,7 @@ fn prefix_and_suffix<'tcx>(
             writeln!(begin, "{asm_name}:").unwrap();
 
             writeln!(end).unwrap();
+            writeln!(end, ".Lfunc_end_{asm_name}:").unwrap();
             writeln!(end, ".popsection").unwrap();
             if !arch_suffix.is_empty() {
                 writeln!(end, "{}", arch_suffix).unwrap();
@@ -263,6 +267,7 @@ fn prefix_and_suffix<'tcx>(
             writeln!(begin, "{asm_name}:").unwrap();
 
             writeln!(end).unwrap();
+            writeln!(end, ".Lfunc_end_{asm_name}:").unwrap();
             writeln!(end, ".popsection").unwrap();
             if !arch_suffix.is_empty() {
                 writeln!(end, "{}", arch_suffix).unwrap();
@@ -287,6 +292,7 @@ fn prefix_and_suffix<'tcx>(
             writeln!(end).unwrap();
             // .size is ignored for function symbols, so we can skip it
             writeln!(end, "end_function").unwrap();
+            writeln!(end, ".Lfunc_end_{asm_name}:").unwrap();
         }
         BinaryFormat::Xcoff => {
             // the LLVM XCOFFAsmParser is extremely incomplete and does not implement many of the
diff --git a/tests/assembly-llvm/naked-functions/wasm32.rs b/tests/assembly-llvm/naked-functions/wasm32.rs
index 77547e82041fe..4bf04dd392341 100644
--- a/tests/assembly-llvm/naked-functions/wasm32.rs
+++ b/tests/assembly-llvm/naked-functions/wasm32.rs
@@ -21,6 +21,7 @@ use minicore::*;
 // CHECK: .functype nop () -> ()
 // CHECK-NOT: .size
 // CHECK: end_function
+// CHECK-LABEL: .Lfunc_end_nop:
 #[no_mangle]
 #[unsafe(naked)]
 extern "C" fn nop() {

From f354d93abe1c404544c18585861518cf03188b0e Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Fri, 19 Sep 2025 13:16:38 -0700
Subject: [PATCH 1160/1889] Enable `limit_rdylib_exports` on wasm targets

This commit updates the target specification of wasm targets to set the
`limit_rdylib_exports` value to `true` like it is on other native
platforms. This was originally not implemented long ago as `wasm-ld`
didn't have options for symbol exports, but since then it's grown a
`--export` flag and such to control this. A custom case is needed in the
linker implementation to handle wasm targets as `wasm-ld` doesn't
support linker scripts used on other targets, but other than that the
implementation is straightforward.

The goal of this commit is enable building dynamic libraries on
`wasm32-wasip2` which don't export every single symbol in the Rust
standard library. Currently, without otherwise control over symbol
visibility, all symbols end up being exported which generates
excessively large binaries because `--gc-sections` ends up doing nothing
as it's all exported anyway.
---
 compiler/rustc_codegen_ssa/src/back/linker.rs | 5 +++++
 compiler/rustc_target/src/spec/base/wasm.rs   | 5 -----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/linker.rs b/compiler/rustc_codegen_ssa/src/back/linker.rs
index a2efd420a327a..b90be2faa08f7 100644
--- a/compiler/rustc_codegen_ssa/src/back/linker.rs
+++ b/compiler/rustc_codegen_ssa/src/back/linker.rs
@@ -845,6 +845,11 @@ impl<'a> Linker for GccLinker<'a> {
                 self.sess.dcx().emit_fatal(errors::VersionScriptWriteFailure { error });
             }
             self.link_arg("--dynamic-list").link_arg(path);
+        } else if self.sess.target.is_like_wasm {
+            self.link_arg("--no-export-dynamic");
+            for (sym, _) in symbols {
+                self.link_arg("--export").link_arg(sym);
+            }
         } else {
             // Write an LD version script
             let res: io::Result<()> = try {
diff --git a/compiler/rustc_target/src/spec/base/wasm.rs b/compiler/rustc_target/src/spec/base/wasm.rs
index 88e7af5e66978..7ede45766ea59 100644
--- a/compiler/rustc_target/src/spec/base/wasm.rs
+++ b/compiler/rustc_target/src/spec/base/wasm.rs
@@ -81,11 +81,6 @@ pub(crate) fn options() -> TargetOptions {
         // threaded model which will legalize atomics to normal operations.
         singlethread: true,
 
-        // Symbol visibility takes care of this for the WebAssembly.
-        // Additionally the only known linker, LLD, doesn't support the script
-        // arguments just yet
-        limit_rdylib_exports: false,
-
         // we use the LLD shipped with the Rust toolchain by default
         linker: Some("rust-lld".into()),
         linker_flavor: LinkerFlavor::WasmLld(Cc::No),

From 54b15a66d89926c4e3e719f26a46b32653d1343f Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Fri, 19 Sep 2025 14:00:29 +0000
Subject: [PATCH 1161/1889] fixes for numerous clippy warnings

---
 compiler/rustc_driver_impl/src/lib.rs      | 21 ++++++++++-----------
 compiler/rustc_driver_impl/src/print.rs    |  2 +-
 compiler/rustc_hir_typeck/src/lib.rs       |  4 ++--
 compiler/rustc_hir_typeck/src/upvar.rs     | 17 +++++++----------
 compiler/rustc_hir_typeck/src/writeback.rs |  6 +++---
 compiler/rustc_interface/src/passes.rs     | 12 ++++++------
 compiler/rustc_interface/src/queries.rs    |  2 +-
 compiler/rustc_interface/src/util.rs       |  4 ++--
 8 files changed, 32 insertions(+), 36 deletions(-)

diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
index 4f875cf99ec21..8dab520cf36b9 100644
--- a/compiler/rustc_driver_impl/src/lib.rs
+++ b/compiler/rustc_driver_impl/src/lib.rs
@@ -206,7 +206,7 @@ impl Callbacks for TimePassesCallbacks {
         // time because it will mess up the --print output. See #64339.
         //
         self.time_passes = (config.opts.prints.is_empty() && config.opts.unstable_opts.time_passes)
-            .then(|| config.opts.unstable_opts.time_passes_format);
+            .then_some(config.opts.unstable_opts.time_passes_format);
         config.opts.trimmed_def_paths = true;
     }
 }
@@ -439,8 +439,9 @@ fn make_input(early_dcx: &EarlyDiagCtxt, free_matches: &[String]) -> Option<Inpu
                         "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 line = line
+                        .parse::<isize>()
+                        .expect("UNSTABLE_RUSTDOC_TEST_LINE needs to be a number");
                     FileName::doc_test_source_code(PathBuf::from(path), line)
                 }
                 Err(_) => FileName::anon_source_code(&input),
@@ -474,8 +475,7 @@ fn handle_explain(early_dcx: &EarlyDiagCtxt, registry: Registry, code: &str, col
         let mut text = String::new();
         // Slice off the leading newline and print.
         for line in description.lines() {
-            let indent_level =
-                line.find(|c: char| !c.is_whitespace()).unwrap_or_else(|| line.len());
+            let indent_level = line.find(|c: char| !c.is_whitespace()).unwrap_or(line.len());
             let dedented_line = &line[indent_level..];
             if dedented_line.starts_with("```") {
                 is_in_code_block = !is_in_code_block;
@@ -547,7 +547,7 @@ fn show_md_content_with_pager(content: &str, color: ColorConfig) {
 
     // The pager failed. Try to print pretty output to stdout.
     if let Some((bufwtr, mdbuf)) = &pretty_data
-        && bufwtr.print(&mdbuf).is_ok()
+        && bufwtr.print(mdbuf).is_ok()
     {
         return;
     }
@@ -598,8 +598,7 @@ fn process_rlink(sess: &Session, compiler: &interface::Compiler) {
 
 fn list_metadata(sess: &Session, metadata_loader: &dyn MetadataLoader) {
     match sess.io.input {
-        Input::File(ref ifile) => {
-            let path = &(*ifile);
+        Input::File(ref path) => {
             let mut v = Vec::new();
             locator::list_file_metadata(
                 &sess.target,
@@ -833,7 +832,7 @@ fn print_crate_info(
             SupportedCrateTypes => {
                 let supported_crate_types = CRATE_TYPES
                     .iter()
-                    .filter(|(_, crate_type)| !invalid_output_for_target(&sess, *crate_type))
+                    .filter(|(_, crate_type)| !invalid_output_for_target(sess, *crate_type))
                     .filter(|(_, crate_type)| *crate_type != CrateType::Sdylib)
                     .map(|(crate_type_sym, _)| *crate_type_sym)
                     .collect::<BTreeSet<_>>();
@@ -1434,7 +1433,7 @@ pub fn install_ice_hook(bug_report_url: &'static str, extra_info: fn(&DiagCtxt))
                 eprintln!();
 
                 if let Some(ice_path) = ice_path()
-                    && let Ok(mut out) = File::options().create(true).append(true).open(&ice_path)
+                    && let Ok(mut out) = File::options().create(true).append(true).open(ice_path)
                 {
                     // The current implementation always returns `Some`.
                     let location = info.location().unwrap();
@@ -1510,7 +1509,7 @@ fn report_ice(
 
     let file = if let Some(path) = ice_path() {
         // Create the ICE dump target file.
-        match crate::fs::File::options().create(true).append(true).open(&path) {
+        match crate::fs::File::options().create(true).append(true).open(path) {
             Ok(mut file) => {
                 dcx.emit_note(session_diagnostics::IcePath { path: path.clone() });
                 if FIRST_PANIC.swap(false, Ordering::SeqCst) {
diff --git a/compiler/rustc_driver_impl/src/print.rs b/compiler/rustc_driver_impl/src/print.rs
index 70de55320f7ae..3f107eb7a61aa 100644
--- a/compiler/rustc_driver_impl/src/print.rs
+++ b/compiler/rustc_driver_impl/src/print.rs
@@ -14,7 +14,7 @@ macro_rules! safe_println {
 }
 
 pub(crate) fn print(args: fmt::Arguments<'_>) {
-    if let Err(_) = io::stdout().write_fmt(args) {
+    if io::stdout().write_fmt(args).is_err() {
         rustc_errors::FatalError.raise();
     }
 }
diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
index 7f5397a7926da..43a23822fd1e3 100644
--- a/compiler/rustc_hir_typeck/src/lib.rs
+++ b/compiler/rustc_hir_typeck/src/lib.rs
@@ -254,7 +254,7 @@ fn typeck_with_inspect<'tcx>(
     }
 
     fcx.select_obligations_where_possible(|_| {});
-    if let None = fcx.infcx.tainted_by_errors() {
+    if fcx.infcx.tainted_by_errors().is_none() {
         fcx.report_ambiguity_errors();
     }
 
@@ -295,7 +295,7 @@ fn infer_type_if_missing<'tcx>(fcx: &FnCtxt<'_, 'tcx>, node: Node<'tcx>) -> Opti
     } else if let Node::AnonConst(_) = node {
         let id = tcx.local_def_id_to_hir_id(def_id);
         match tcx.parent_hir_node(id) {
-            Node::Ty(&hir::Ty { kind: hir::TyKind::Typeof(ref anon_const), span, .. })
+            Node::Ty(&hir::Ty { kind: hir::TyKind::Typeof(anon_const), span, .. })
                 if anon_const.hir_id == id =>
             {
                 Some(fcx.next_ty_var(span))
diff --git a/compiler/rustc_hir_typeck/src/upvar.rs b/compiler/rustc_hir_typeck/src/upvar.rs
index 06acff06a51ac..0a7b458f3fb35 100644
--- a/compiler/rustc_hir_typeck/src/upvar.rs
+++ b/compiler/rustc_hir_typeck/src/upvar.rs
@@ -421,7 +421,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         // Not all upvars are captured by ref, so use
                         // `apply_capture_kind_on_capture_ty` to ensure that we
                         // compute the right captured type.
-                        return apply_capture_kind_on_capture_ty(
+                        apply_capture_kind_on_capture_ty(
                             self.tcx,
                             upvar_ty,
                             capture,
@@ -430,7 +430,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             } else {
                                 self.tcx.lifetimes.re_erased
                             },
-                        );
+                        )
                     },
                 ),
             );
@@ -529,11 +529,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // process any deferred resolutions.
         let deferred_call_resolutions = self.remove_deferred_call_resolutions(closure_def_id);
         for deferred_call_resolution in deferred_call_resolutions {
-            deferred_call_resolution.resolve(&mut FnCtxt::new(
-                self,
-                self.param_env,
-                closure_def_id,
-            ));
+            deferred_call_resolution.resolve(&FnCtxt::new(self, self.param_env, closure_def_id));
         }
     }
 
@@ -1493,7 +1489,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     /// Notation:
     /// - Ty(place): Type of place
     /// - `(a, b)`: Represents the function parameters `base_path_ty` and `captured_by_move_projs`
-    /// respectively.
+    ///   respectively.
     /// ```ignore (illustrative)
     ///                  (Ty(w), [ &[p, x], &[c] ])
     /// //                              |
@@ -2179,9 +2175,10 @@ fn restrict_precision_for_unsafe(
     (place, curr_mode)
 }
 
-/// Truncate projections so that following rules are obeyed by the captured `place`:
+/// Truncate projections so that the following rules are obeyed by the captured `place`:
 /// - No Index projections are captured, since arrays are captured completely.
-/// - No unsafe block is required to capture `place`
+/// - No unsafe block is required to capture `place`.
+///
 /// Returns the truncated place and updated capture mode.
 fn restrict_capture_precision(
     place: Place<'_>,
diff --git a/compiler/rustc_hir_typeck/src/writeback.rs b/compiler/rustc_hir_typeck/src/writeback.rs
index 90301d1b391a0..6192420898f6e 100644
--- a/compiler/rustc_hir_typeck/src/writeback.rs
+++ b/compiler/rustc_hir_typeck/src/writeback.rs
@@ -220,7 +220,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
     // to use builtin indexing because the index type is known to be
     // usize-ish
     fn fix_index_builtin_expr(&mut self, e: &hir::Expr<'_>) {
-        if let hir::ExprKind::Index(ref base, ref index, _) = e.kind {
+        if let hir::ExprKind::Index(base, index, _) = e.kind {
             // All valid indexing looks like this; might encounter non-valid indexes at this point.
             let base_ty = self.typeck_results.expr_ty_adjusted(base);
             if let ty::Ref(_, base_ty_inner, _) = *base_ty.kind() {
@@ -583,7 +583,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
             }
 
             if let Err(err) = opaque_type_has_defining_use_args(
-                &self.fcx,
+                self.fcx,
                 opaque_type_key,
                 hidden_type.span,
                 DefiningScopeKind::HirTypeck,
@@ -792,7 +792,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
 
     fn visit_potentially_region_dependent_goals(&mut self) {
         let obligations = self.fcx.take_hir_typeck_potentially_region_dependent_goals();
-        if let None = self.fcx.tainted_by_errors() {
+        if self.fcx.tainted_by_errors().is_none() {
             for obligation in obligations {
                 let (predicate, mut cause) =
                     self.fcx.resolve_vars_if_possible((obligation.predicate, obligation.cause));
diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs
index d39219bfd660f..6cefe8875306a 100644
--- a/compiler/rustc_interface/src/passes.rs
+++ b/compiler/rustc_interface/src/passes.rs
@@ -192,7 +192,7 @@ fn configure_and_expand(
             unsafe {
                 env::set_var(
                     "PATH",
-                    &env::join_paths(
+                    env::join_paths(
                         new_path.iter().filter(|p| env::join_paths(iter::once(p)).is_ok()),
                     )
                     .unwrap(),
@@ -446,7 +446,7 @@ fn early_lint_checks(tcx: TyCtxt<'_>, (): ()) {
                 let prev_source = sess.psess.source_map().span_to_prev_source(first_span);
                 let ferris_fix = prev_source
                     .map_or(FerrisFix::SnakeCase, |source| {
-                        let mut source_before_ferris = source.trim_end().split_whitespace().rev();
+                        let mut source_before_ferris = source.split_whitespace().rev();
                         match source_before_ferris.next() {
                             Some("struct" | "trait" | "mod" | "union" | "type" | "enum") => {
                                 FerrisFix::PascalCase
@@ -500,7 +500,7 @@ fn env_var_os<'tcx>(tcx: TyCtxt<'tcx>, key: &'tcx OsStr) -> Option<&'tcx OsStr>
     // properly change-tracked.
     tcx.sess.psess.env_depinfo.borrow_mut().insert((
         Symbol::intern(&key.to_string_lossy()),
-        value.as_ref().and_then(|value| value.to_str()).map(|value| Symbol::intern(&value)),
+        value.as_ref().and_then(|value| value.to_str()).map(|value| Symbol::intern(value)),
     ));
 
     value_tcx
@@ -824,7 +824,7 @@ pub fn write_dep_info(tcx: TyCtxt<'_>) {
 
     let outputs = tcx.output_filenames(());
     let output_paths =
-        generated_output_paths(tcx, &outputs, sess.io.output_file.is_some(), crate_name);
+        generated_output_paths(tcx, outputs, sess.io.output_file.is_some(), crate_name);
 
     // Ensure the source file isn't accidentally overwritten during compilation.
     if let Some(input_path) = sess.io.input.opt_path() {
@@ -847,7 +847,7 @@ pub fn write_dep_info(tcx: TyCtxt<'_>) {
         }
     }
 
-    write_out_deps(tcx, &outputs, &output_paths);
+    write_out_deps(tcx, outputs, &output_paths);
 
     let only_dep_info = sess.opts.output_types.contains_key(&OutputType::DepInfo)
         && sess.opts.output_types.len() == 1;
@@ -1303,7 +1303,7 @@ pub(crate) fn parse_crate_name(
     let rustc_hir::Attribute::Parsed(AttributeKind::CrateName { name, name_span, .. }) =
         AttributeParser::parse_limited_should_emit(
             sess,
-            &attrs,
+            attrs,
             sym::crate_name,
             DUMMY_SP,
             rustc_ast::node_id::CRATE_NODE_ID,
diff --git a/compiler/rustc_interface/src/queries.rs b/compiler/rustc_interface/src/queries.rs
index 370e886c525fd..280214ab4183a 100644
--- a/compiler/rustc_interface/src/queries.rs
+++ b/compiler/rustc_interface/src/queries.rs
@@ -94,7 +94,7 @@ impl Linker {
                 &rlink_file,
                 &codegen_results,
                 &self.metadata,
-                &*self.output_filenames,
+                &self.output_filenames,
             )
             .unwrap_or_else(|error| {
                 sess.dcx().emit_fatal(FailedWritingFile { path: &rlink_file, error })
diff --git a/compiler/rustc_interface/src/util.rs b/compiler/rustc_interface/src/util.rs
index 061c764e619a3..26e09c95e7698 100644
--- a/compiler/rustc_interface/src/util.rs
+++ b/compiler/rustc_interface/src/util.rs
@@ -243,7 +243,7 @@ pub(crate) fn run_in_thread_pool_with_globals<
                                 let query_map = rustc_span::set_session_globals_then(unsafe { &*(session_globals as *const SessionGlobals) }, || {
                                     // Ensure there was no errors collecting all active jobs.
                                     // We need the complete map to ensure we find a cycle to break.
-                                    QueryCtxt::new(tcx).collect_active_jobs().ok().expect("failed to collect active queries in deadlock handler")
+                                    QueryCtxt::new(tcx).collect_active_jobs().expect("failed to collect active queries in deadlock handler")
                                 });
                                 break_query_cycles(query_map, &registry);
                             })
@@ -561,7 +561,7 @@ pub fn build_output_filenames(attrs: &[ast::Attribute], sess: &Session) -> Outpu
                 }
                 Some(out_file.clone())
             };
-            if sess.io.output_dir != None {
+            if sess.io.output_dir.is_some() {
                 sess.dcx().emit_warn(errors::IgnoringOutDir);
             }
 

From 4841d8c5ffb6a7bd025c14d8e9d2c23e6c458792 Mon Sep 17 00:00:00 2001
From: Deadbeef <ent3rm4n@gmail.com>
Date: Fri, 19 Sep 2025 22:14:50 +0000
Subject: [PATCH 1162/1889] generate list of all variants with
 `target_spec_enum`

This helps us avoid the hardcoded lists elsewhere.
---
 compiler/rustc_codegen_llvm/src/lib.rs   | 16 +++-------------
 compiler/rustc_session/src/config/cfg.rs |  6 ++++--
 compiler/rustc_target/src/lib.rs         | 23 ++++++++++++-----------
 compiler/rustc_target/src/spec/mod.rs    | 16 ----------------
 4 files changed, 19 insertions(+), 42 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/lib.rs b/compiler/rustc_codegen_llvm/src/lib.rs
index 6fb23d0984335..13bdb7cb1a274 100644
--- a/compiler/rustc_codegen_llvm/src/lib.rs
+++ b/compiler/rustc_codegen_llvm/src/lib.rs
@@ -45,6 +45,7 @@ use rustc_middle::util::Providers;
 use rustc_session::Session;
 use rustc_session::config::{OptLevel, OutputFilenames, PrintKind, PrintRequest};
 use rustc_span::Symbol;
+use rustc_target::spec::{RelocModel, TlsModel};
 
 mod abi;
 mod allocator;
@@ -244,16 +245,7 @@ impl CodegenBackend for LlvmCodegenBackend {
         match req.kind {
             PrintKind::RelocationModels => {
                 writeln!(out, "Available relocation models:").unwrap();
-                for name in &[
-                    "static",
-                    "pic",
-                    "pie",
-                    "dynamic-no-pic",
-                    "ropi",
-                    "rwpi",
-                    "ropi-rwpi",
-                    "default",
-                ] {
+                for name in RelocModel::ALL.iter().map(RelocModel::desc).chain(["default"]) {
                     writeln!(out, "    {name}").unwrap();
                 }
                 writeln!(out).unwrap();
@@ -267,9 +259,7 @@ impl CodegenBackend for LlvmCodegenBackend {
             }
             PrintKind::TlsModels => {
                 writeln!(out, "Available TLS models:").unwrap();
-                for name in
-                    &["global-dynamic", "local-dynamic", "initial-exec", "local-exec", "emulated"]
-                {
+                for name in TlsModel::ALL.iter().map(TlsModel::desc) {
                     writeln!(out, "    {name}").unwrap();
                 }
                 writeln!(out).unwrap();
diff --git a/compiler/rustc_session/src/config/cfg.rs b/compiler/rustc_session/src/config/cfg.rs
index 8f63ce6f0ae88..7e970461ab731 100644
--- a/compiler/rustc_session/src/config/cfg.rs
+++ b/compiler/rustc_session/src/config/cfg.rs
@@ -374,11 +374,13 @@ impl CheckCfg {
 
         ins!(sym::overflow_checks, no_values);
 
-        ins!(sym::panic, empty_values).extend(&PanicStrategy::all());
+        ins!(sym::panic, empty_values)
+            .extend(PanicStrategy::ALL.iter().map(PanicStrategy::desc_symbol));
 
         ins!(sym::proc_macro, no_values);
 
-        ins!(sym::relocation_model, empty_values).extend(RelocModel::all());
+        ins!(sym::relocation_model, empty_values)
+            .extend(RelocModel::ALL.iter().map(RelocModel::desc_symbol));
 
         let sanitize_values = SanitizerSet::all()
             .into_iter()
diff --git a/compiler/rustc_target/src/lib.rs b/compiler/rustc_target/src/lib.rs
index b3fe1fffccebc..8c6a77cba8ba7 100644
--- a/compiler/rustc_target/src/lib.rs
+++ b/compiler/rustc_target/src/lib.rs
@@ -76,10 +76,10 @@ fn find_relative_libdir(sysroot: &Path) -> std::borrow::Cow<'static, str> {
 macro_rules! target_spec_enum {
     (
         $( #[$attr:meta] )*
-        pub enum $name:ident {
+        pub enum $Name:ident {
             $(
                 $( #[$variant_attr:meta] )*
-                $variant:ident = $string:literal,
+                $Variant:ident = $string:literal,
             )*
         }
         parse_error_type = $parse_error_type:literal;
@@ -87,20 +87,20 @@ macro_rules! target_spec_enum {
         $( #[$attr] )*
         #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, PartialOrd, Ord)]
         #[derive(schemars::JsonSchema)]
-        pub enum $name {
+        pub enum $Name {
             $(
                 $( #[$variant_attr] )*
                 #[serde(rename = $string)] // for JSON schema generation only
-                $variant,
+                $Variant,
             )*
         }
 
-        impl FromStr for $name {
+        impl FromStr for $Name {
             type Err = String;
 
             fn from_str(s: &str) -> Result<Self, Self::Err> {
                 Ok(match s {
-                    $( $string => Self::$variant, )*
+                    $( $string => Self::$Variant, )*
                     _ => {
                         let all = [$( concat!("'", $string, "'") ),*].join(", ");
                         return Err(format!("invalid {}: '{s}'. allowed values: {all}", $parse_error_type));
@@ -109,24 +109,25 @@ macro_rules! target_spec_enum {
             }
         }
 
-        impl $name {
+        impl $Name {
+            pub const ALL: &'static [$Name] = &[ $( $Name::$Variant, )* ];
             pub fn desc(&self) -> &'static str {
                 match self {
-                    $( Self::$variant => $string, )*
+                    $( Self::$Variant => $string, )*
                 }
             }
         }
 
-        impl crate::json::ToJson for $name {
+        impl crate::json::ToJson for $Name {
             fn to_json(&self) -> crate::json::Json {
                 self.desc().to_json()
             }
         }
 
-        crate::json::serde_deserialize_from_str!($name);
+        crate::json::serde_deserialize_from_str!($Name);
 
 
-        impl std::fmt::Display for $name {
+        impl std::fmt::Display for $Name {
             fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                 f.write_str(self.desc())
             }
diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index 07fb1ce63f7c4..f705af52bd868 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -854,10 +854,6 @@ impl PanicStrategy {
             PanicStrategy::Abort => sym::abort,
         }
     }
-
-    pub const fn all() -> [Symbol; 2] {
-        [Self::Abort.desc_symbol(), Self::Unwind.desc_symbol()]
-    }
 }
 
 crate::target_spec_enum! {
@@ -974,18 +970,6 @@ impl RelocModel {
             RelocModel::RopiRwpi => sym::ropi_rwpi,
         }
     }
-
-    pub const fn all() -> [Symbol; 7] {
-        [
-            RelocModel::Static.desc_symbol(),
-            RelocModel::Pic.desc_symbol(),
-            RelocModel::Pie.desc_symbol(),
-            RelocModel::DynamicNoPic.desc_symbol(),
-            RelocModel::Ropi.desc_symbol(),
-            RelocModel::Rwpi.desc_symbol(),
-            RelocModel::RopiRwpi.desc_symbol(),
-        ]
-    }
 }
 
 crate::target_spec_enum! {

From 6a5838105d8496b9db5dc61b0bd12dda70f7bbe1 Mon Sep 17 00:00:00 2001
From: Thalia Archibald <thalia@archibald.dev>
Date: Fri, 19 Sep 2025 18:13:21 -0600
Subject: [PATCH 1163/1889] Fix unsupported std::sys::thread

Fixes building std for any platform with an unsupported thread
abstraction. This includes {aarch64,armv7,x86_64}-unknown-trusty and
riscv32im-risc0-zkvm-elf, which explicitly include the unsupported
module, and platforms with no PAL.

Bug fix for PR 145177 (std: move thread into sys).
---
 library/std/src/sys/pal/trusty/mod.rs       | 2 --
 library/std/src/sys/pal/unsupported/mod.rs  | 1 -
 library/std/src/sys/pal/zkvm/mod.rs         | 2 --
 library/std/src/sys/process/unix/vxworks.rs | 3 +--
 4 files changed, 1 insertion(+), 7 deletions(-)

diff --git a/library/std/src/sys/pal/trusty/mod.rs b/library/std/src/sys/pal/trusty/mod.rs
index 275f606246336..cf0c098f8a2f3 100644
--- a/library/std/src/sys/pal/trusty/mod.rs
+++ b/library/std/src/sys/pal/trusty/mod.rs
@@ -7,8 +7,6 @@ mod common;
 pub mod os;
 #[path = "../unsupported/pipe.rs"]
 pub mod pipe;
-#[path = "../unsupported/thread.rs"]
-pub mod thread;
 #[path = "../unsupported/time.rs"]
 pub mod time;
 
diff --git a/library/std/src/sys/pal/unsupported/mod.rs b/library/std/src/sys/pal/unsupported/mod.rs
index 5e3295b1331a3..e64bbc7c6169d 100644
--- a/library/std/src/sys/pal/unsupported/mod.rs
+++ b/library/std/src/sys/pal/unsupported/mod.rs
@@ -2,7 +2,6 @@
 
 pub mod os;
 pub mod pipe;
-pub mod thread;
 pub mod time;
 
 mod common;
diff --git a/library/std/src/sys/pal/zkvm/mod.rs b/library/std/src/sys/pal/zkvm/mod.rs
index e1efa2406858f..9069c8d12fa1d 100644
--- a/library/std/src/sys/pal/zkvm/mod.rs
+++ b/library/std/src/sys/pal/zkvm/mod.rs
@@ -14,8 +14,6 @@ pub mod abi;
 pub mod os;
 #[path = "../unsupported/pipe.rs"]
 pub mod pipe;
-#[path = "../unsupported/thread.rs"]
-pub mod thread;
 #[path = "../unsupported/time.rs"]
 pub mod time;
 
diff --git a/library/std/src/sys/process/unix/vxworks.rs b/library/std/src/sys/process/unix/vxworks.rs
index 2275cbb946a9c..b9298f5fa44c1 100644
--- a/library/std/src/sys/process/unix/vxworks.rs
+++ b/library/std/src/sys/process/unix/vxworks.rs
@@ -4,8 +4,7 @@ use libc::{self, RTP_ID, c_char, c_int};
 use super::common::*;
 use crate::io::{self, ErrorKind};
 use crate::num::NonZero;
-use crate::sys::cvt;
-use crate::sys::pal::thread;
+use crate::sys::{cvt, thread};
 use crate::{fmt, sys};
 
 ////////////////////////////////////////////////////////////////////////////////

From 776c199c7bb7a26f2578087c28ee7be4d8941097 Mon Sep 17 00:00:00 2001
From: Thalia Archibald <thalia@archibald.dev>
Date: Fri, 19 Sep 2025 18:30:18 -0600
Subject: [PATCH 1164/1889] Fix std build for xtensa

---
 library/core/src/ffi/va_list.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/library/core/src/ffi/va_list.rs b/library/core/src/ffi/va_list.rs
index 643bd95df846d..0d4ccb5aeb28c 100644
--- a/library/core/src/ffi/va_list.rs
+++ b/library/core/src/ffi/va_list.rs
@@ -2,6 +2,7 @@
 //!
 //! Better known as "varargs".
 
+#[cfg(not(target_arch = "xtensa"))]
 use crate::ffi::c_void;
 #[allow(unused_imports)]
 use crate::fmt;

From db4d4eff56a38c7c1096e0cf76ee3bd523bade05 Mon Sep 17 00:00:00 2001
From: Thalia Archibald <thalia@archibald.dev>
Date: Fri, 19 Sep 2025 18:57:49 -0600
Subject: [PATCH 1165/1889] Update cfg_if! to cfg_select!

The macro is now builtin.
---
 library/std/src/sys/env_consts.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/std/src/sys/env_consts.rs b/library/std/src/sys/env_consts.rs
index 9683fd47cf96b..711ba0a5f8a92 100644
--- a/library/std/src/sys/env_consts.rs
+++ b/library/std/src/sys/env_consts.rs
@@ -2,7 +2,7 @@
 
 // Replaces the #[else] gate with #[cfg(not(any(…)))] of all the other gates.
 // This ensures that they must be mutually exclusive and do not have precedence
-// like cfg_if!.
+// like cfg_select!.
 macro cfg_unordered(
     $(#[cfg($cfg:meta)] $os:item)*
     #[else] $fallback:item

From bb430f8e1e4081b7600ef2bf6ff7207ea6b5d83f Mon Sep 17 00:00:00 2001
From: Josh Triplett <josh@joshtriplett.org>
Date: Fri, 19 Sep 2025 20:49:18 +0800
Subject: [PATCH 1166/1889] mbe: Simplify match in `transcribe_metavar`

Factor out the check for a variable that's still repeating.
---
 compiler/rustc_expand/src/mbe/transcribe.rs | 37 +++++++++++----------
 1 file changed, 19 insertions(+), 18 deletions(-)

diff --git a/compiler/rustc_expand/src/mbe/transcribe.rs b/compiler/rustc_expand/src/mbe/transcribe.rs
index 6a3f1f62c91e1..6a2cb5f5560ae 100644
--- a/compiler/rustc_expand/src/mbe/transcribe.rs
+++ b/compiler/rustc_expand/src/mbe/transcribe.rs
@@ -375,6 +375,11 @@ fn transcribe_metavar<'tx>(
         return Ok(());
     };
 
+    let MatchedSingle(pnr) = cur_matched else {
+        // We were unable to descend far enough. This is an error.
+        return Err(dcx.create_err(MacroVarStillRepeating { span: sp, ident }));
+    };
+
     // We wrap the tokens in invisible delimiters, unless they are already wrapped
     // in invisible delimiters with the same `MetaVarKind`. Because some proc
     // macros can't handle multiple layers of invisible delimiters of the same
@@ -404,33 +409,33 @@ fn transcribe_metavar<'tx>(
         )
     };
 
-    let tt = match cur_matched {
-        MatchedSingle(ParseNtResult::Tt(tt)) => {
+    let tt = match pnr {
+        ParseNtResult::Tt(tt) => {
             // `tt`s are emitted into the output stream directly as "raw tokens",
             // without wrapping them into groups. Other variables are emitted into
             // the output stream as groups with `Delimiter::Invisible` to maintain
             // parsing priorities.
             maybe_use_metavar_location(tscx.psess, &tscx.stack, sp, tt, &mut tscx.marker)
         }
-        MatchedSingle(ParseNtResult::Ident(ident, is_raw)) => {
+        ParseNtResult::Ident(ident, is_raw) => {
             tscx.marker.mark_span(&mut sp);
             with_metavar_spans(|mspans| mspans.insert(ident.span, sp));
             let kind = token::NtIdent(*ident, *is_raw);
             TokenTree::token_alone(kind, sp)
         }
-        MatchedSingle(ParseNtResult::Lifetime(ident, is_raw)) => {
+        ParseNtResult::Lifetime(ident, is_raw) => {
             tscx.marker.mark_span(&mut sp);
             with_metavar_spans(|mspans| mspans.insert(ident.span, sp));
             let kind = token::NtLifetime(*ident, *is_raw);
             TokenTree::token_alone(kind, sp)
         }
-        MatchedSingle(ParseNtResult::Item(item)) => {
+        ParseNtResult::Item(item) => {
             mk_delimited(item.span, MetaVarKind::Item, TokenStream::from_ast(item))
         }
-        MatchedSingle(ParseNtResult::Block(block)) => {
+        ParseNtResult::Block(block) => {
             mk_delimited(block.span, MetaVarKind::Block, TokenStream::from_ast(block))
         }
-        MatchedSingle(ParseNtResult::Stmt(stmt)) => {
+        ParseNtResult::Stmt(stmt) => {
             let stream = if let StmtKind::Empty = stmt.kind {
                 // FIXME: Properly collect tokens for empty statements.
                 TokenStream::token_alone(token::Semi, stmt.span)
@@ -439,10 +444,10 @@ fn transcribe_metavar<'tx>(
             };
             mk_delimited(stmt.span, MetaVarKind::Stmt, stream)
         }
-        MatchedSingle(ParseNtResult::Pat(pat, pat_kind)) => {
+        ParseNtResult::Pat(pat, pat_kind) => {
             mk_delimited(pat.span, MetaVarKind::Pat(*pat_kind), TokenStream::from_ast(pat))
         }
-        MatchedSingle(ParseNtResult::Expr(expr, kind)) => {
+        ParseNtResult::Expr(expr, kind) => {
             let (can_begin_literal_maybe_minus, can_begin_string_literal) = match &expr.kind {
                 ExprKind::Lit(_) => (true, true),
                 ExprKind::Unary(UnOp::Neg, e) if matches!(&e.kind, ExprKind::Lit(_)) => {
@@ -460,14 +465,14 @@ fn transcribe_metavar<'tx>(
                 TokenStream::from_ast(expr),
             )
         }
-        MatchedSingle(ParseNtResult::Literal(lit)) => {
+        ParseNtResult::Literal(lit) => {
             mk_delimited(lit.span, MetaVarKind::Literal, TokenStream::from_ast(lit))
         }
-        MatchedSingle(ParseNtResult::Ty(ty)) => {
+        ParseNtResult::Ty(ty) => {
             let is_path = matches!(&ty.kind, TyKind::Path(None, _path));
             mk_delimited(ty.span, MetaVarKind::Ty { is_path }, TokenStream::from_ast(ty))
         }
-        MatchedSingle(ParseNtResult::Meta(attr_item)) => {
+        ParseNtResult::Meta(attr_item) => {
             let has_meta_form = attr_item.meta_kind().is_some();
             mk_delimited(
                 attr_item.span(),
@@ -475,16 +480,12 @@ fn transcribe_metavar<'tx>(
                 TokenStream::from_ast(attr_item),
             )
         }
-        MatchedSingle(ParseNtResult::Path(path)) => {
+        ParseNtResult::Path(path) => {
             mk_delimited(path.span, MetaVarKind::Path, TokenStream::from_ast(path))
         }
-        MatchedSingle(ParseNtResult::Vis(vis)) => {
+        ParseNtResult::Vis(vis) => {
             mk_delimited(vis.span, MetaVarKind::Vis, TokenStream::from_ast(vis))
         }
-        MatchedSeq(..) => {
-            // We were unable to descend far enough. This is an error.
-            return Err(dcx.create_err(MacroVarStillRepeating { span: sp, ident }));
-        }
     };
 
     tscx.result.push(tt);

From fc41c38379ab186fee7dab193ae94813592f818c Mon Sep 17 00:00:00 2001
From: Josh Triplett <josh@joshtriplett.org>
Date: Fri, 19 Sep 2025 21:38:12 +0800
Subject: [PATCH 1167/1889] mbe: Factor out a function to transcribe a
 `ParseNtResult`

---
 compiler/rustc_expand/src/mbe/transcribe.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/compiler/rustc_expand/src/mbe/transcribe.rs b/compiler/rustc_expand/src/mbe/transcribe.rs
index 6a2cb5f5560ae..dddd62a4945a2 100644
--- a/compiler/rustc_expand/src/mbe/transcribe.rs
+++ b/compiler/rustc_expand/src/mbe/transcribe.rs
@@ -380,6 +380,14 @@ fn transcribe_metavar<'tx>(
         return Err(dcx.create_err(MacroVarStillRepeating { span: sp, ident }));
     };
 
+    transcribe_pnr(tscx, sp, pnr)
+}
+
+fn transcribe_pnr<'tx>(
+    tscx: &mut TranscrCtx<'tx, '_>,
+    mut sp: Span,
+    pnr: &ParseNtResult,
+) -> PResult<'tx, ()> {
     // We wrap the tokens in invisible delimiters, unless they are already wrapped
     // in invisible delimiters with the same `MetaVarKind`. Because some proc
     // macros can't handle multiple layers of invisible delimiters of the same

From a54111a54861ad9f68979622012c85454d43734a Mon Sep 17 00:00:00 2001
From: Josh Triplett <josh@joshtriplett.org>
Date: Sat, 20 Sep 2025 10:25:48 +0800
Subject: [PATCH 1168/1889] mbe: metavar expressions: Use symbols rather than
 `ident.as_str()`

Identify metavariable functions by using named symbols rather than
string comparisons.
---
 compiler/rustc_expand/src/mbe/metavar_expr.rs | 25 +++++++++----------
 1 file changed, 12 insertions(+), 13 deletions(-)

diff --git a/compiler/rustc_expand/src/mbe/metavar_expr.rs b/compiler/rustc_expand/src/mbe/metavar_expr.rs
index d2b275ad20a9f..70d796cda11c0 100644
--- a/compiler/rustc_expand/src/mbe/metavar_expr.rs
+++ b/compiler/rustc_expand/src/mbe/metavar_expr.rs
@@ -5,7 +5,7 @@ use rustc_ast_pretty::pprust;
 use rustc_errors::{Applicability, PResult};
 use rustc_macros::{Decodable, Encodable};
 use rustc_session::parse::ParseSess;
-use rustc_span::{Ident, Span, Symbol};
+use rustc_span::{Ident, Span, Symbol, sym};
 
 use crate::errors;
 
@@ -69,15 +69,15 @@ impl MetaVarExpr {
         }
 
         let mut iter = args.iter();
-        let rslt = match ident.as_str() {
-            "concat" => parse_concat(&mut iter, psess, outer_span, ident.span)?,
-            "count" => parse_count(&mut iter, psess, ident.span)?,
-            "ignore" => {
+        let rslt = match ident.name {
+            sym::concat => parse_concat(&mut iter, psess, outer_span, ident.span)?,
+            sym::count => parse_count(&mut iter, psess, ident.span)?,
+            sym::ignore => {
                 eat_dollar(&mut iter, psess, ident.span)?;
                 MetaVarExpr::Ignore(parse_ident(&mut iter, psess, ident.span)?)
             }
-            "index" => MetaVarExpr::Index(parse_depth(&mut iter, psess, ident.span)?),
-            "len" => MetaVarExpr::Len(parse_depth(&mut iter, psess, ident.span)?),
+            sym::index => MetaVarExpr::Index(parse_depth(&mut iter, psess, ident.span)?),
+            sym::len => MetaVarExpr::Len(parse_depth(&mut iter, psess, ident.span)?),
             _ => {
                 let err = errors::MveUnrecognizedExpr {
                     span: ident.span,
@@ -119,14 +119,13 @@ fn check_trailing_tokens<'psess>(
     }
 
     // `None` for max indicates the arg count must be exact, `Some` indicates a range is accepted.
-    let (min_or_exact_args, max_args) = match ident.as_str() {
-        "concat" => panic!("concat takes unlimited tokens but didn't eat them all"),
-        "ignore" => (1, None),
+    let (min_or_exact_args, max_args) = match ident.name {
+        sym::concat => panic!("concat takes unlimited tokens but didn't eat them all"),
+        sym::ignore => (1, None),
         // 1 or 2 args
-        "count" => (1, Some(2)),
+        sym::count => (1, Some(2)),
         // 0 or 1 arg
-        "index" => (0, Some(1)),
-        "len" => (0, Some(1)),
+        sym::index | sym::len => (0, Some(1)),
         other => unreachable!("unknown MVEs should be rejected earlier (got `{other}`)"),
     };
 

From 741e1e2ec79b6819759274117947bafe75189b2a Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sat, 20 Sep 2025 12:48:48 +1000
Subject: [PATCH 1169/1889] Remove unused `LLVMRustDIBuilder(Create|Dispose)`

These should have been removed earlier, when we switched to the corresponding
LLVM-C bindings.
---
 compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index c7fa26f18e14a..b8db9fac90f87 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -985,14 +985,6 @@ extern "C" void LLVMRustGlobalAddMetadata(LLVMValueRef Global, unsigned Kind,
   unwrap<GlobalObject>(Global)->addMetadata(Kind, *unwrap<MDNode>(MD));
 }
 
-extern "C" LLVMDIBuilderRef LLVMRustDIBuilderCreate(LLVMModuleRef M) {
-  return wrap(new DIBuilder(*unwrap(M)));
-}
-
-extern "C" void LLVMRustDIBuilderDispose(LLVMDIBuilderRef Builder) {
-  delete unwrap(Builder);
-}
-
 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateCompileUnit(
     LLVMDIBuilderRef Builder, unsigned Lang, LLVMMetadataRef FileRef,
     const char *Producer, size_t ProducerLen, bool isOptimized,

From 42b38e3781ee3c34cf3df4dea4cd836a814cfb60 Mon Sep 17 00:00:00 2001
From: Sidney Cammeresi <sac@cheesecake.org>
Date: Fri, 19 Sep 2025 21:17:21 -0700
Subject: [PATCH 1170/1889] Add unstable attribute to BTreeMap-related
 allocator generics

Although these types aren't directly constructable externally, since
they're pub, I think this omission was an oversight.
---
 library/alloc/src/collections/btree/map.rs       | 6 +++++-
 library/alloc/src/collections/btree/map/entry.rs | 7 ++++++-
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/library/alloc/src/collections/btree/map.rs b/library/alloc/src/collections/btree/map.rs
index 98f11e2ea57fd..cebd25c6039cc 100644
--- a/library/alloc/src/collections/btree/map.rs
+++ b/library/alloc/src/collections/btree/map.rs
@@ -546,7 +546,11 @@ impl<K, V: fmt::Debug> fmt::Debug for ValuesMut<'_, K, V> {
 /// [`into_keys`]: BTreeMap::into_keys
 #[must_use = "iterators are lazy and do nothing unless consumed"]
 #[stable(feature = "map_into_keys_values", since = "1.54.0")]
-pub struct IntoKeys<K, V, A: Allocator + Clone = Global> {
+pub struct IntoKeys<
+    K,
+    V,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator + Clone = Global,
+> {
     inner: IntoIter<K, V, A>,
 }
 
diff --git a/library/alloc/src/collections/btree/map/entry.rs b/library/alloc/src/collections/btree/map/entry.rs
index 21486651b0b0f..df51be3de54b9 100644
--- a/library/alloc/src/collections/btree/map/entry.rs
+++ b/library/alloc/src/collections/btree/map/entry.rs
@@ -99,7 +99,12 @@ impl<K: Debug + Ord, V: Debug, A: Allocator + Clone> Debug for OccupiedEntry<'_,
 ///
 /// Contains the occupied entry, and the value that was not inserted.
 #[unstable(feature = "map_try_insert", issue = "82766")]
-pub struct OccupiedError<'a, K: 'a, V: 'a, A: Allocator + Clone = Global> {
+pub struct OccupiedError<
+    'a,
+    K: 'a,
+    V: 'a,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator + Clone = Global,
+> {
     /// The entry in the map that was already occupied.
     pub entry: OccupiedEntry<'a, K, V, A>,
     /// The value which was not inserted, because the entry was already occupied.

From 88ceae98c57e17bf9923861d7c91319d7ca44f69 Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Sat, 20 Sep 2025 04:52:31 +0000
Subject: [PATCH 1171/1889] Prepare for merging from rust-lang/rust

This updates the rust-version file to ec38671075266e9cee0348701da2e133379e7c6c.
---
 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 0eb16a943d6ab..7333f7968f771 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-3f1552a273e43e15f6ed240d00e1efdd6a53e65e
+ec38671075266e9cee0348701da2e133379e7c6c

From 4d8655e8d0b69cd1a424ccadd4c9043124a627f4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Lauren=C8=9Biu=20Nicola?= <lnicola@dend.ro>
Date: Sat, 20 Sep 2025 09:38:53 +0300
Subject: [PATCH 1172/1889] Bump rustc crates once more

---
 src/tools/rust-analyzer/Cargo.lock            | 44 +++++++++----------
 src/tools/rust-analyzer/Cargo.toml            | 16 +++----
 .../crates/hir-ty/src/next_solver/inspect.rs  |  6 +--
 3 files changed, 32 insertions(+), 34 deletions(-)

diff --git a/src/tools/rust-analyzer/Cargo.lock b/src/tools/rust-analyzer/Cargo.lock
index 097bb81f66765..17dea1ba4cdec 100644
--- a/src/tools/rust-analyzer/Cargo.lock
+++ b/src/tools/rust-analyzer/Cargo.lock
@@ -1807,9 +1807,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_abi"
-version = "0.131.0"
+version = "0.132.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "016c05852e89655395fbf7d5e729e31cd58b2690480b3a8468eb2b38c91f3756"
+checksum = "597bb303548ddcca3a2eb05af254508aaf39cf334d4350bb5da51de1eb728859"
 dependencies = [
  "bitflags 2.9.1",
  "ra-ap-rustc_hashes",
@@ -1819,24 +1819,24 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_ast_ir"
-version = "0.131.0"
+version = "0.132.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5bff48bd0a26f17a4e2e8610bc393296c3d002e221f5c6c4d2875e6a64a3b4b"
+checksum = "78982b4e4432ee4b938e47bb5c8f1a5a5a88c27c782f193aefcc12a3250bd2e2"
 
 [[package]]
 name = "ra-ap-rustc_hashes"
-version = "0.131.0"
+version = "0.132.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d15e7571f6f31f6112fd2fcbc3450a6ef477cc6bfe51643a2b110436a7455f0"
+checksum = "2f7f33a422f724cc1ab43972cdd76a556b17fc256f301d23be620adfc8351df7"
 dependencies = [
  "rustc-stable-hash",
 ]
 
 [[package]]
 name = "ra-ap-rustc_index"
-version = "0.131.0"
+version = "0.132.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60a30f0a15682f1194e5812cc3544266f3494ca8fb3c5033e8b9c08f4f8b8c6d"
+checksum = "8a6006023c8be18c3ac225d69c1b42f55b3f597f3db03fb40764b4cf1454fd13"
 dependencies = [
  "ra-ap-rustc_index_macros",
  "smallvec",
@@ -1844,9 +1844,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_index_macros"
-version = "0.131.0"
+version = "0.132.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2f82c9176b964591e1657a9f0fae2850525542d39075c49c2459afc291f4804"
+checksum = "9217c29f7fcc30d07ed13a62262144f665410ef1460202599ae924f9ae47ad78"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1855,9 +1855,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_lexer"
-version = "0.131.0"
+version = "0.132.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "585c71ff7da5ca1e8a0c65d5e7cec7ab2a7e9e45b6859543bd2d0be21bee631c"
+checksum = "573ad4f5da620e8ba1849d8862866abd7bc765c3d81cb2488c3ecbef33ce2c69"
 dependencies = [
  "memchr",
  "unicode-properties",
@@ -1866,9 +1866,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_next_trait_solver"
-version = "0.131.0"
+version = "0.132.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "839f521a6cd97c71b2b6681604ace38a9c6737f7a223d072fa8f909879f9dc4b"
+checksum = "0d42b095b99e988aeb94622ae62ebda4b7de55d7d98846eec352b8a5a2b8a858"
 dependencies = [
  "derive-where",
  "ra-ap-rustc_index",
@@ -1879,9 +1879,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_parse_format"
-version = "0.131.0"
+version = "0.132.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83e7872a4fa0620937b60fc6270aa8c31864cb324357553e2be5b2bdc25fa89a"
+checksum = "a21b4e95cb45f840c172493c05f5b9471cf44adb2eccf95d76a0d76e88007870"
 dependencies = [
  "ra-ap-rustc_lexer",
  "rustc-literal-escaper 0.0.5",
@@ -1889,9 +1889,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_pattern_analysis"
-version = "0.131.0"
+version = "0.132.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ecd7f9b960c8cf1e9d02a25297f52a520134132164cfedd3e69fee4f294d41c"
+checksum = "b6aeacef1248066f7b67e7296ef135eeab6446d5d2a5c7f02b8d7b747b41e39b"
 dependencies = [
  "ra-ap-rustc_index",
  "rustc-hash 2.1.1",
@@ -1902,9 +1902,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_type_ir"
-version = "0.131.0"
+version = "0.132.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9494498f8f7c57a5b4ea4e35a6c554cca8d5323adb534d13dc6cd117a7e00e4d"
+checksum = "52e35ee9e052406035016b8e6d54ca202bc39ccba1702780b33b2d5fb10d1da8"
 dependencies = [
  "arrayvec",
  "bitflags 2.9.1",
@@ -1922,9 +1922,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_type_ir_macros"
-version = "0.131.0"
+version = "0.132.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28ed893760b86529080af59438c28dfa9ca976b821cfd0a3b0eb9591932847e6"
+checksum = "9b934c956b0c88df8176803416b69d85d2c392a69c8aa794a4c338f22c527d38"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/src/tools/rust-analyzer/Cargo.toml b/src/tools/rust-analyzer/Cargo.toml
index cfbd8a56b76fd..0401367f78647 100644
--- a/src/tools/rust-analyzer/Cargo.toml
+++ b/src/tools/rust-analyzer/Cargo.toml
@@ -87,14 +87,14 @@ vfs-notify = { path = "./crates/vfs-notify", version = "0.0.0" }
 vfs = { path = "./crates/vfs", version = "0.0.0" }
 edition = { path = "./crates/edition", version = "0.0.0" }
 
-ra-ap-rustc_lexer = { version = "0.131", default-features = false }
-ra-ap-rustc_parse_format = { version = "0.131", default-features = false }
-ra-ap-rustc_index = { version = "0.131", default-features = false }
-ra-ap-rustc_abi = { version = "0.131", default-features = false }
-ra-ap-rustc_pattern_analysis = { version = "0.131", default-features = false }
-ra-ap-rustc_ast_ir = { version = "0.131", default-features = false }
-ra-ap-rustc_type_ir = { version = "0.131", default-features = false }
-ra-ap-rustc_next_trait_solver = { version = "0.131", default-features = false }
+ra-ap-rustc_lexer = { version = "0.132", default-features = false }
+ra-ap-rustc_parse_format = { version = "0.132", default-features = false }
+ra-ap-rustc_index = { version = "0.132", default-features = false }
+ra-ap-rustc_abi = { version = "0.132", default-features = false }
+ra-ap-rustc_pattern_analysis = { version = "0.132", default-features = false }
+ra-ap-rustc_ast_ir = { version = "0.132", default-features = false }
+ra-ap-rustc_type_ir = { version = "0.132", default-features = false }
+ra-ap-rustc_next_trait_solver = { version = "0.132", default-features = false }
 
 # local crates that aren't published to crates.io. These should not have versions.
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/inspect.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/inspect.rs
index 128135d8debe8..bc19d51d23e32 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/inspect.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/inspect.rs
@@ -2,11 +2,9 @@ pub use rustc_next_trait_solver::solve::inspect::*;
 
 use rustc_ast_ir::try_visit;
 use rustc_next_trait_solver::{
+    canonical::instantiate_canonical_state,
     resolve::eager_resolve_vars,
-    solve::{
-        SolverDelegateEvalExt,
-        inspect::{self, instantiate_canonical_state},
-    },
+    solve::{SolverDelegateEvalExt, inspect},
 };
 use rustc_type_ir::{
     VisitorResult,

From f3427c50c20ff78f1c088f81d069e53be57d5b0a Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 20 Sep 2025 09:34:51 +0200
Subject: [PATCH 1173/1889] clippy

---
 src/tools/miri/miri-script/src/commands.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/tools/miri/miri-script/src/commands.rs b/src/tools/miri/miri-script/src/commands.rs
index ee09b9b4b735b..f1b5229312325 100644
--- a/src/tools/miri/miri-script/src/commands.rs
+++ b/src/tools/miri/miri-script/src/commands.rs
@@ -130,15 +130,15 @@ impl Command {
         let new_commit = sh.read_file("rust-version")?.trim().to_owned();
         let current_commit = {
             let rustc_info = cmd!(sh, "rustc +miri --version -v").read();
-            if rustc_info.is_err() {
-                None
-            } else {
-                let metadata = rustc_version::version_meta_for(&rustc_info.unwrap())?;
+            if let Ok(rustc_info) = rustc_info {
+                let metadata = rustc_version::version_meta_for(&rustc_info)?;
                 Some(
                     metadata
                         .commit_hash
                         .ok_or_else(|| anyhow!("rustc metadata did not contain commit hash"))?,
                 )
+            } else {
+                None
             }
         };
         // Check if we already are at that commit.

From 5c2320380d4e412348fede00c70bfb9ae4e85d86 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 19 Sep 2025 15:17:14 +0200
Subject: [PATCH 1174/1889] CI: test bootstrap build

---
 src/tools/miri/.github/workflows/ci.yml | 39 +++++++++++++++++++++++--
 1 file changed, 37 insertions(+), 2 deletions(-)

diff --git a/src/tools/miri/.github/workflows/ci.yml b/src/tools/miri/.github/workflows/ci.yml
index e1a948c92faa4..740118bb4a02b 100644
--- a/src/tools/miri/.github/workflows/ci.yml
+++ b/src/tools/miri/.github/workflows/ci.yml
@@ -117,6 +117,41 @@ jobs:
       - name: rustdoc
         run: RUSTDOCFLAGS="-Dwarnings" ./miri doc --document-private-items
 
+  bootstrap:
+    name: bootstrap build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      # Deliberately skipping `./.github/workflows/setup` as we do our own setup
+      - name: Add cache for cargo
+        id: cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            # Taken from <https://doc.rust-lang.org/nightly/cargo/guide/cargo-home.html#caching-the-cargo-home-in-ci>.
+            # Cache package/registry information
+            ~/.cargo/registry/index
+            ~/.cargo/registry/cache
+            ~/.cargo/git/db
+            # Cache bootstrap downloads
+            ../rust/build/cache
+          key: cargo-bootstrap-${{ hashFiles('rust-version') }}
+          restore-keys: cargo-bootstrap
+      - name: prepare build environment
+        run: |
+          MIRIDIR=$(pwd)
+          cd ..
+          # Bootstrap needs at least depth 2 to function.
+          git clone https://github.com/rust-lang/rust/ rust --depth 2 --revision $(cat "$MIRIDIR/rust-version")
+          cd rust
+          # Replace the in-tree Miri with the current version.
+          rm src/tools/miri -rf
+          ln -s "$MIRIDIR" src/tools/miri
+      - name: check build
+        run: |
+          cd ../rust # ./x does not seem to like being invoked from elsewhere
+          ./x check miri
+
   coverage:
     name: coverage report
     runs-on: ubuntu-latest
@@ -130,7 +165,7 @@ jobs:
   # ALL THE PREVIOUS JOBS NEED TO BE ADDED TO THE `needs` SECTION OF THIS JOB!
   # And they should be added below in `cron-fail-notify` as well.
   conclusion:
-    needs: [test, style, coverage]
+    needs: [test, style, bootstrap, coverage]
     # We need to ensure this job does *not* get skipped if its dependencies fail,
     # because a skipped job is considered a success by GitHub. So we have to
     # overwrite `if:`. We use `!cancelled()` to ensure the job does still not get run
@@ -211,7 +246,7 @@ jobs:
   cron-fail-notify:
     name: cronjob failure notification
     runs-on: ubuntu-latest
-    needs: [test, style, coverage]
+    needs: [test, style, bootstrap, coverage]
     if: ${{ github.event_name == 'schedule' && failure() }}
     steps:
       # Send a Zulip notification

From 2a75cb9d6c63eb02365e9fd8b7e53cd0d360cbdf Mon Sep 17 00:00:00 2001
From: Iris Shi <0.0@owo.li>
Date: Sat, 20 Sep 2025 16:09:40 +0800
Subject: [PATCH 1175/1889] add private module override re-export test

---
 tests/rustdoc/private-mod-override-re-export.rs | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 tests/rustdoc/private-mod-override-re-export.rs

diff --git a/tests/rustdoc/private-mod-override-re-export.rs b/tests/rustdoc/private-mod-override-re-export.rs
new file mode 100644
index 0000000000000..47b07958709bb
--- /dev/null
+++ b/tests/rustdoc/private-mod-override-re-export.rs
@@ -0,0 +1,14 @@
+// https://github.com/rust-lang/rust/issues/60926
+#![crate_name = "foo"]
+#![crate_type = "lib"]
+
+mod m1 {
+    pub mod m2 {
+        pub struct Foo;
+    }
+}
+
+pub use m1::*;
+use crate::m1::m2;
+
+//@ !has foo/index.html '//a[@href="m2/index.html"]' 'm2'

From bb1ad20f59509ec9310125968ef30fae88f92245 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Sat, 20 Sep 2025 14:59:59 +0800
Subject: [PATCH 1176/1889] Fix panics on `Foo{mut x}` for
 destructure_struct_binding

Example
---
```rust
struct Foo { x: () }
struct Bar { foo: Foo }
fn f(Bar { mut $0foo }: Bar) {}
```

**Before this PR**:

Panic `Option::unwrap`

**After this PR**:

```rust
struct Foo { x: () }
struct Bar { foo: Foo }
fn f(Bar { foo: Foo { mut x } }: Bar) {}
```
---
 .../handlers/destructure_struct_binding.rs    | 105 ++++++++++++++++--
 1 file changed, 96 insertions(+), 9 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_struct_binding.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_struct_binding.rs
index 397327cb4ff8c..63a41ae5dc89e 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_struct_binding.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_struct_binding.rs
@@ -7,7 +7,7 @@ use ide_db::{
     search::{FileReference, SearchScope},
 };
 use itertools::Itertools;
-use syntax::ast::syntax_factory::SyntaxFactory;
+use syntax::ast::{HasName, syntax_factory::SyntaxFactory};
 use syntax::syntax_editor::SyntaxEditor;
 use syntax::{AstNode, Edition, SmolStr, SyntaxNode, ToSmolStr, ast};
 
@@ -71,13 +71,14 @@ fn destructure_struct_binding_impl(
 
 struct StructEditData {
     ident_pat: ast::IdentPat,
+    name: ast::Name,
     kind: hir::StructKind,
     struct_def_path: hir::ModPath,
     visible_fields: Vec<hir::Field>,
     usages: Vec<FileReference>,
     names_in_scope: FxHashSet<SmolStr>,
     has_private_members: bool,
-    is_nested: bool,
+    need_record_field_name: bool,
     is_ref: bool,
     edition: Edition,
 }
@@ -114,7 +115,11 @@ fn collect_data(ident_pat: ast::IdentPat, ctx: &AssistContext<'_>) -> Option<Str
     }
 
     let is_ref = ty.is_reference();
-    let is_nested = ident_pat.syntax().parent().and_then(ast::RecordPatField::cast).is_some();
+    let need_record_field_name = ident_pat
+        .syntax()
+        .parent()
+        .and_then(ast::RecordPatField::cast)
+        .is_some_and(|field| field.colon_token().is_none());
 
     let usages = ctx
         .sema
@@ -133,6 +138,7 @@ fn collect_data(ident_pat: ast::IdentPat, ctx: &AssistContext<'_>) -> Option<Str
     let names_in_scope = get_names_in_scope(ctx, &ident_pat, &usages).unwrap_or_default();
 
     Some(StructEditData {
+        name: ident_pat.name()?,
         ident_pat,
         kind,
         struct_def_path,
@@ -140,7 +146,7 @@ fn collect_data(ident_pat: ast::IdentPat, ctx: &AssistContext<'_>) -> Option<Str
         has_private_members,
         visible_fields,
         names_in_scope,
-        is_nested,
+        need_record_field_name,
         is_ref,
         edition: module.krate().edition(ctx.db()),
     })
@@ -177,6 +183,7 @@ fn destructure_pat(
     field_names: &[(SmolStr, SmolStr)],
 ) {
     let ident_pat = &data.ident_pat;
+    let name = &data.name;
 
     let struct_path = mod_path_to_ast(&data.struct_def_path, data.edition);
     let is_ref = ident_pat.ref_token().is_some();
@@ -194,9 +201,9 @@ fn destructure_pat(
         hir::StructKind::Record => {
             let fields = field_names.iter().map(|(old_name, new_name)| {
                 // Use shorthand syntax if possible
-                if old_name == new_name && !is_mut {
+                if old_name == new_name {
                     make.record_pat_field_shorthand(
-                        make.ident_pat(false, false, make.name(old_name)).into(),
+                        make.ident_pat(is_ref, is_mut, make.name(old_name)).into(),
                     )
                 } else {
                     make.record_pat_field(
@@ -215,8 +222,8 @@ fn destructure_pat(
 
     // If the binding is nested inside a record, we need to wrap the new
     // destructured pattern in a non-shorthand record field
-    let destructured_pat = if data.is_nested {
-        make.record_pat_field(make.name_ref(&ident_pat.to_string()), new_pat).syntax().clone()
+    let destructured_pat = if data.need_record_field_name {
+        make.record_pat_field(make.name_ref(&name.to_string()), new_pat).syntax().clone()
     } else {
         new_pat.syntax().clone()
     };
@@ -579,7 +586,7 @@ mod tests {
             struct Foo { bar: i32, baz: i32 }
 
             fn main() {
-                let Foo { bar: mut bar, baz: mut baz } = Foo { bar: 1, baz: 2 };
+                let Foo { mut bar, mut baz } = Foo { bar: 1, baz: 2 };
                 let bar2 = bar;
                 let baz2 = &baz;
             }
@@ -587,6 +594,86 @@ mod tests {
         )
     }
 
+    #[test]
+    fn mut_record_field() {
+        check_assist(
+            destructure_struct_binding,
+            r#"
+            struct Foo { x: () }
+            struct Bar { foo: Foo }
+            fn f(Bar { mut $0foo }: Bar) {}
+            "#,
+            r#"
+            struct Foo { x: () }
+            struct Bar { foo: Foo }
+            fn f(Bar { foo: Foo { mut x } }: Bar) {}
+            "#,
+        )
+    }
+
+    #[test]
+    fn ref_record_field() {
+        check_assist(
+            destructure_struct_binding,
+            r#"
+            struct Foo { x: () }
+            struct Bar { foo: Foo }
+            fn f(Bar { ref $0foo }: Bar) {
+                let _ = foo.x;
+            }
+            "#,
+            r#"
+            struct Foo { x: () }
+            struct Bar { foo: Foo }
+            fn f(Bar { foo: Foo { ref x } }: Bar) {
+                let _ = *x;
+            }
+            "#,
+        )
+    }
+
+    #[test]
+    fn ref_mut_record_field() {
+        check_assist(
+            destructure_struct_binding,
+            r#"
+            struct Foo { x: () }
+            struct Bar { foo: Foo }
+            fn f(Bar { ref mut $0foo }: Bar) {
+                let _ = foo.x;
+            }
+            "#,
+            r#"
+            struct Foo { x: () }
+            struct Bar { foo: Foo }
+            fn f(Bar { foo: Foo { ref mut x } }: Bar) {
+                let _ = *x;
+            }
+            "#,
+        )
+    }
+
+    #[test]
+    fn ref_mut_record_renamed_field() {
+        check_assist(
+            destructure_struct_binding,
+            r#"
+            struct Foo { x: () }
+            struct Bar { foo: Foo }
+            fn f(Bar { foo: ref mut $0foo1 }: Bar) {
+                let _ = foo1.x;
+            }
+            "#,
+            r#"
+            struct Foo { x: () }
+            struct Bar { foo: Foo }
+            fn f(Bar { foo: Foo { ref mut x } }: Bar) {
+                let _ = *x;
+            }
+            "#,
+        )
+    }
+
     #[test]
     fn mut_ref() {
         check_assist(

From 8eda71b98a8540f848cfd33b58f6d284edb64073 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Sat, 20 Sep 2025 17:04:56 +0800
Subject: [PATCH 1177/1889] Fix panic `!self.data().mutable` for
 destructure_struct_binding

When the reference type does not require adding a dereference or parentheses, it will panic

Example
---

```rust
struct Foo { bar: i32, baz: i32 }

fn main() {
    let $0foo = &Foo { bar: 1, baz: 2 };
    let _ = &foo.bar;
}
```

**Before this PR**:

Panic:
```
assertion failed: !self.data().mutable
```

**After this PR**:

```rust
struct Foo { bar: i32, baz: i32 }

fn main() {
    let Foo { bar, baz } = &Foo { bar: 1, baz: 2 };
    let _ = bar;
}
```
---
 .../handlers/destructure_struct_binding.rs    | 50 ++++++++++++++++++-
 1 file changed, 48 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_struct_binding.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_struct_binding.rs
index 397327cb4ff8c..5ba2f96c01ae0 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_struct_binding.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/destructure_struct_binding.rs
@@ -288,7 +288,7 @@ fn build_usage_edit(
         Some(field_expr) => Some({
             let field_name: SmolStr = field_expr.name_ref()?.to_string().into();
             let new_field_name = field_names.get(&field_name)?;
-            let new_expr = make.expr_path(ast::make::ext::ident_path(new_field_name));
+            let new_expr = ast::make::expr_path(ast::make::ext::ident_path(new_field_name));
 
             // If struct binding is a reference, we might need to deref field usages
             if data.is_ref {
@@ -298,7 +298,7 @@ fn build_usage_edit(
                     ref_data.wrap_expr(new_expr).syntax().clone_for_update(),
                 )
             } else {
-                (field_expr.syntax().clone(), new_expr.syntax().clone())
+                (field_expr.syntax().clone(), new_expr.syntax().clone_for_update())
             }
         }),
         None => Some((
@@ -610,6 +610,52 @@ mod tests {
         )
     }
 
+    #[test]
+    fn ref_not_add_parenthesis_and_deref_record() {
+        check_assist(
+            destructure_struct_binding,
+            r#"
+            struct Foo { bar: i32, baz: i32 }
+
+            fn main() {
+                let $0foo = &Foo { bar: 1, baz: 2 };
+                let _ = &foo.bar;
+            }
+            "#,
+            r#"
+            struct Foo { bar: i32, baz: i32 }
+
+            fn main() {
+                let Foo { bar, baz } = &Foo { bar: 1, baz: 2 };
+                let _ = bar;
+            }
+            "#,
+        )
+    }
+
+    #[test]
+    fn ref_not_add_parenthesis_and_deref_tuple() {
+        check_assist(
+            destructure_struct_binding,
+            r#"
+            struct Foo(i32, i32);
+
+            fn main() {
+                let $0foo = &Foo(1, 2);
+                let _ = &foo.0;
+            }
+            "#,
+            r#"
+            struct Foo(i32, i32);
+
+            fn main() {
+                let Foo(_0, _1) = &Foo(1, 2);
+                let _ = _0;
+            }
+            "#,
+        )
+    }
+
     #[test]
     fn record_struct_name_collision() {
         check_assist(

From ac3c480388d27ee9ebeb23d308bd37289d37bc41 Mon Sep 17 00:00:00 2001
From: tk <49250442+tkr-sh@users.noreply.github.com>
Date: Wed, 14 May 2025 00:54:47 +0200
Subject: [PATCH 1178/1889] docs: improve doc of some methods w/ ranges

---
 library/alloc/src/collections/vec_deque/mod.rs | 12 ++++++------
 library/alloc/src/string.rs                    | 12 ++++++------
 library/alloc/src/vec/mod.rs                   |  8 ++++----
 3 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs
index 2fce5c3e737e4..d589860524b82 100644
--- a/library/alloc/src/collections/vec_deque/mod.rs
+++ b/library/alloc/src/collections/vec_deque/mod.rs
@@ -1486,8 +1486,8 @@ impl<T, A: Allocator> VecDeque<T, A> {
     ///
     /// # Panics
     ///
-    /// Panics if the starting point is greater than the end point or if
-    /// the end point is greater than the length of the deque.
+    /// Panics if the range has `start_bound > end_bound`, or, if the range is
+    /// bounded on either end and past the length of the deque.
     ///
     /// # Examples
     ///
@@ -1522,8 +1522,8 @@ impl<T, A: Allocator> VecDeque<T, A> {
     ///
     /// # Panics
     ///
-    /// Panics if the starting point is greater than the end point or if
-    /// the end point is greater than the length of the deque.
+    /// Panics if the range has `start_bound > end_bound`, or, if the range is
+    /// bounded on either end and past the length of the deque.
     ///
     /// # Examples
     ///
@@ -1568,8 +1568,8 @@ impl<T, A: Allocator> VecDeque<T, A> {
     ///
     /// # Panics
     ///
-    /// Panics if the starting point is greater than the end point or if
-    /// the end point is greater than the length of the deque.
+    /// Panics if the range has `start_bound > end_bound`, or, if the range is
+    /// bounded on either end and past the length of the deque.
     ///
     /// # Leaking
     ///
diff --git a/library/alloc/src/string.rs b/library/alloc/src/string.rs
index 1d0dd4be1b66a..e669c4708ad09 100644
--- a/library/alloc/src/string.rs
+++ b/library/alloc/src/string.rs
@@ -1117,8 +1117,8 @@ impl String {
     ///
     /// # Panics
     ///
-    /// Panics if the starting point or end point do not lie on a [`char`]
-    /// boundary, or if they're out of bounds.
+    /// Panics if the range has `start_bound > end_bound`, or, if the range is
+    /// bounded on either end and does not lie on a [`char`] boundary.
     ///
     /// # Examples
     ///
@@ -1939,8 +1939,8 @@ impl String {
     ///
     /// # Panics
     ///
-    /// Panics if the starting point or end point do not lie on a [`char`]
-    /// boundary, or if they're out of bounds.
+    /// Panics if the range has `start_bound > end_bound`, or, if the range is
+    /// bounded on either end and does not lie on a [`char`] boundary.
     ///
     /// # Leaking
     ///
@@ -2050,8 +2050,8 @@ impl String {
     ///
     /// # Panics
     ///
-    /// Panics if the starting point or end point do not lie on a [`char`]
-    /// boundary, or if they're out of bounds.
+    /// Panics if the range has `start_bound > end_bound`, or, if the range is
+    /// bounded on either end and does not lie on a [`char`] boundary.
     ///
     /// # Examples
     ///
diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs
index 1b80b43abc357..10c7ee4f6c89d 100644
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -2796,8 +2796,8 @@ impl<T, A: Allocator> Vec<T, A> {
     ///
     /// # Panics
     ///
-    /// Panics if the starting point is greater than the end point or if
-    /// the end point is greater than the length of the vector.
+    /// Panics if the range has `start_bound > end_bound`, or, if the range is
+    /// bounded on either end and past the length of the vector.
     ///
     /// # Leaking
     ///
@@ -3860,8 +3860,8 @@ impl<T, A: Allocator> Vec<T, A> {
     ///
     /// # Panics
     ///
-    /// Panics if the starting point is greater than the end point or if
-    /// the end point is greater than the length of the vector.
+    /// Panics if the range has `start_bound > end_bound`, or, if the range is
+    /// bounded on either end and past the length of the vector.
     ///
     /// # Examples
     ///

From 1850a5569df16cacf9f2269edb5141daff18b29e Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Sat, 20 Sep 2025 17:50:29 +0800
Subject: [PATCH 1179/1889] Fix unused_variables fixes shorthand record field

Example
---

```rust
struct S { field : u32 }
fn main() {
    let s = S { field : 2 };
    let S { $0field } = s
}
```

**Before this PR**:

```rust
struct S { field : u32 }
fn main() {
    let s = S { field : 2 };
    let S { _field } = s
}
```

**After this PR**:

```rust
struct S { field : u32 }
fn main() {
    let s = S { field : 2 };
    let S { field: _field } = s
}
```
---
 .../src/handlers/unused_variables.rs          | 68 ++++++++++++++++---
 1 file changed, 57 insertions(+), 11 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/unused_variables.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/unused_variables.rs
index e6bbff05f7e8c..a4f3ca0a26725 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/unused_variables.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/unused_variables.rs
@@ -6,7 +6,7 @@ use ide_db::{
     label::Label,
     source_change::SourceChange,
 };
-use syntax::{Edition, TextRange};
+use syntax::{AstNode, Edition, TextRange};
 
 use crate::{Diagnostic, DiagnosticCode, DiagnosticsContext};
 
@@ -24,15 +24,21 @@ pub(crate) fn unused_variables(
     }
     let diagnostic_range = ctx.sema.diagnostics_display_range(ast);
     // The range for the Actual Name. We don't want to replace the entire declaration. Using the diagnostic range causes issues within in Array Destructuring.
-    let name_range = d
-        .local
-        .primary_source(ctx.sema.db)
+    let primary_source = d.local.primary_source(ctx.sema.db);
+    let name_range = primary_source
         .name()
         .map(|v| v.syntax().original_file_range_rooted(ctx.sema.db))
         .filter(|it| {
             Some(it.file_id) == ast.file_id.file_id()
                 && diagnostic_range.range.contains_range(it.range)
         });
+    let is_shorthand_field = primary_source
+        .source
+        .value
+        .left()
+        .and_then(|name| name.syntax().parent())
+        .and_then(syntax::ast::RecordPatField::cast)
+        .is_some_and(|field| field.colon_token().is_none());
     let var_name = d.local.name(ctx.sema.db);
     Some(
         Diagnostic::new_with_syntax_node_ptr(
@@ -48,6 +54,7 @@ pub(crate) fn unused_variables(
                 it.range,
                 diagnostic_range,
                 ast.file_id.is_macro(),
+                is_shorthand_field,
                 ctx.edition,
             )
         })),
@@ -60,24 +67,23 @@ fn fixes(
     name_range: TextRange,
     diagnostic_range: FileRange,
     is_in_marco: bool,
+    is_shorthand_field: bool,
     edition: Edition,
 ) -> Option<Vec<Assist>> {
     if is_in_marco {
         return None;
     }
+    let name = var_name.display(db, edition);
+    let new_name = if is_shorthand_field { format!("{name}: _{name}") } else { format!("_{name}") };
 
     Some(vec![Assist {
         id: AssistId::quick_fix("unscore_unused_variable_name"),
-        label: Label::new(format!(
-            "Rename unused {} to _{}",
-            var_name.display(db, edition),
-            var_name.display(db, edition)
-        )),
+        label: Label::new(format!("Rename unused {name} to {new_name}")),
         group: None,
         target: diagnostic_range.range,
         source_change: Some(SourceChange::from_text_edit(
             diagnostic_range.file_id,
-            TextEdit::replace(name_range, format!("_{}", var_name.display(db, edition))),
+            TextEdit::replace(name_range, new_name),
         )),
         command: None,
     }])
@@ -220,7 +226,7 @@ struct Foo { f1: i32, f2: i64 }
 fn main() {
     let f = Foo { f1: 0, f2: 0 };
     match f {
-        Foo { _f1, f2 } => {
+        Foo { f1: _f1, f2 } => {
             _ = f2;
         }
     }
@@ -263,6 +269,46 @@ fn main() {
         );
     }
 
+    #[test]
+    fn unused_variable_in_record_field() {
+        check_fix(
+            r#"
+struct S { field : u32 }
+fn main() {
+    let s = S { field : 2 };
+    let S { field: $0x } = s
+}
+"#,
+            r#"
+struct S { field : u32 }
+fn main() {
+    let s = S { field : 2 };
+    let S { field: _x } = s
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn unused_variable_in_shorthand_record_field() {
+        check_fix(
+            r#"
+struct S { field : u32 }
+fn main() {
+    let s = S { field : 2 };
+    let S { $0field } = s
+}
+"#,
+            r#"
+struct S { field : u32 }
+fn main() {
+    let s = S { field : 2 };
+    let S { field: _field } = s
+}
+"#,
+        );
+    }
+
     // regression test as we used to panic in this scenario
     #[test]
     fn unknown_struct_pattern_param_type() {

From 19a67ebab7a9d669164ef641061d33eb7b464db0 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Thu, 18 Sep 2025 13:57:07 +0800
Subject: [PATCH 1180/1889] Fix selected multi variants applicable
 generate_default_from_enum_variant

---
 .../generate_default_from_enum_variant.rs     | 46 +++++++++++++++++++
 1 file changed, 46 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_default_from_enum_variant.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_default_from_enum_variant.rs
index 6198dbc4ed99b..056edb00b687f 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_default_from_enum_variant.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_default_from_enum_variant.rs
@@ -39,6 +39,9 @@ pub(crate) fn generate_default_from_enum_variant(
         cov_mark::hit!(test_gen_default_on_non_unit_variant_not_implemented);
         return None;
     }
+    if !variant.syntax().text_range().contains_range(ctx.selection_trimmed()) {
+        return None;
+    }
 
     if existing_default_impl(&ctx.sema, &variant).is_some() {
         cov_mark::hit!(test_gen_default_impl_already_exists);
@@ -114,6 +117,49 @@ impl Default for Variant {
         );
     }
 
+    #[test]
+    fn test_generate_default_selected_variant() {
+        check_assist(
+            generate_default_from_enum_variant,
+            r#"
+//- minicore: default
+enum Variant {
+    Undefined,
+    $0Minor$0,
+    Major,
+}
+"#,
+            r#"
+enum Variant {
+    Undefined,
+    Minor,
+    Major,
+}
+
+impl Default for Variant {
+    fn default() -> Self {
+        Self::Minor
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn test_generate_default_not_applicable_with_multiple_variant_selection() {
+        check_assist_not_applicable(
+            generate_default_from_enum_variant,
+            r#"
+//- minicore: default
+enum Variant {
+    Undefined,
+    $0Minor,
+    M$0ajor,
+}
+"#,
+        );
+    }
+
     #[test]
     fn test_generate_default_already_implemented() {
         cov_mark::check!(test_gen_default_impl_already_exists);

From 71fdb598c7d8a2b85d757c361c812b33b7433a10 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Sun, 14 Sep 2025 00:42:11 +0800
Subject: [PATCH 1181/1889] Fix IfExpr then branch suggest

- And add logic operation suggest

Example
---
In the old implementation, it always suggested conditions,
this is a lot of noise, e.g `contract_checks()~(use std::intrinsics::contract_checks) const fn() -> bool`

```rust
fn foo() {
    if true {
        c$0
    }
}
```
---
 .../ide-completion/src/context/analysis.rs    | 13 +++-
 .../ide-completion/src/context/tests.rs       | 69 +++++++++++++++++++
 .../ide-completion/src/tests/expression.rs    |  8 +--
 3 files changed, 82 insertions(+), 8 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
index 7b78a9700ec56..cdb1ad8b38e71 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
@@ -637,6 +637,9 @@ fn expected_type_and_name<'db>(
                             .or_else(|| it.rhs().and_then(|rhs| sema.type_of_expr(&rhs)))
                             .map(TypeInfo::original);
                         (ty, None)
+                    } else if let Some(ast::BinaryOp::LogicOp(_)) = it.op_kind() {
+                        let ty = sema.type_of_expr(&it.clone().into()).map(TypeInfo::original);
+                        (ty, None)
                     } else {
                         (None, None)
                     }
@@ -707,9 +710,13 @@ fn expected_type_and_name<'db>(
                     (ty, None)
                 },
                 ast::IfExpr(it) => {
-                    let ty = it.condition()
-                        .and_then(|e| sema.type_of_expr(&e))
-                        .map(TypeInfo::original);
+                    let ty = if let Some(body) = it.then_branch()
+                        && token.text_range().end() > body.syntax().text_range().start()
+                    {
+                        sema.type_of_expr(&body.into())
+                    } else {
+                        it.condition().and_then(|e| sema.type_of_expr(&e))
+                    }.map(TypeInfo::original);
                     (ty, None)
                 },
                 ast::IdentPat(it) => {
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context/tests.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context/tests.rs
index 445afa75f3f4f..d9ec7915e3c72 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context/tests.rs
@@ -278,6 +278,62 @@ fn foo() {
     )
 }
 
+#[test]
+fn expected_type_if_let_chain_bool() {
+    check_expected_type_and_name(
+        r#"
+fn foo() {
+    let f = Foo::Quux;
+    if let c = f && $0 { }
+}
+"#,
+        expect![[r#"ty: bool, name: ?"#]],
+    );
+}
+
+#[test]
+fn expected_type_if_condition() {
+    check_expected_type_and_name(
+        r#"
+fn foo() {
+    if a$0 { }
+}
+"#,
+        expect![[r#"ty: bool, name: ?"#]],
+    );
+}
+
+#[test]
+fn expected_type_if_body() {
+    check_expected_type_and_name(
+        r#"
+enum Foo { Bar, Baz, Quux }
+
+fn foo() {
+    let _: Foo = if true {
+        $0
+    };
+}
+"#,
+        expect![[r#"ty: Foo, name: ?"#]],
+    );
+
+    check_expected_type_and_name(
+        r#"
+enum Foo { Bar, Baz, Quux }
+
+fn foo() {
+    let _: Foo = if true {
+        Foo::Bar
+    } else {
+        $0
+    };
+}
+"#,
+        expect![[r#"ty: Foo, name: ?"#]],
+    );
+}
+
 #[test]
 fn expected_type_fn_ret_without_leading_char() {
     cov_mark::check!(expected_type_fn_ret_without_leading_char);
@@ -526,3 +582,16 @@ fn foo() {
         expect![[r#"ty: State, name: ?"#]],
     );
 }
+
+#[test]
+fn expected_type_logic_op() {
+    check_expected_type_and_name(
+        r#"
+enum State { Stop }
+fn foo() {
+    true && $0;
+}
+"#,
+        expect![[r#"ty: bool, name: ?"#]],
+    );
+}
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs b/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
index c420953036f72..98a6f95f334a6 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/tests/expression.rs
@@ -271,8 +271,6 @@ fn complete_in_block() {
             sn macro_rules
             sn pd
             sn ppd
-            ex false
-            ex true
         "#]],
     )
 }
@@ -1668,7 +1666,7 @@ fn foo() { let x = if foo {} $0; let y = 92; }
 fn foo() { let x = if foo {} $0 else {}; }
 "#,
         expect![[r#"
-            fn foo    fn()
+            fn foo()  fn()
             bt u32     u32
             kw async
             kw const
@@ -1710,7 +1708,7 @@ fn foo() { let x = if foo {} $0 else {}; }
 fn foo() { let x = if foo {} $0 else if true {}; }
 "#,
         expect![[r#"
-            fn foo    fn()
+            fn foo()  fn()
             bt u32     u32
             kw async
             kw const
@@ -1795,7 +1793,7 @@ fn foo() { let x = if foo {} el$0 else if true {} else {}; }
 fn foo() { let x = if foo {} $0 else if true {} else {}; }
 "#,
         expect![[r#"
-            fn foo    fn()
+            fn foo()  fn()
             bt u32     u32
             kw async
             kw const

From 66b1066028ecdf7d4814926600a80222a21a846b Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Sat, 20 Sep 2025 12:04:59 +0800
Subject: [PATCH 1182/1889] Fix to implements in-place stdx::replace

---
 src/tools/rust-analyzer/crates/stdx/src/lib.rs | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/stdx/src/lib.rs b/src/tools/rust-analyzer/crates/stdx/src/lib.rs
index 978c50d807bcc..82f17fb9f7878 100644
--- a/src/tools/rust-analyzer/crates/stdx/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/stdx/src/lib.rs
@@ -187,11 +187,19 @@ pub fn is_upper_snake_case(s: &str) -> bool {
 }
 
 pub fn replace(buf: &mut String, from: char, to: &str) {
-    if !buf.contains(from) {
+    let replace_count = buf.chars().filter(|&ch| ch == from).count();
+    if replace_count == 0 {
         return;
     }
-    // FIXME: do this in place.
-    *buf = buf.replace(from, to);
+    let from_len = from.len_utf8();
+    let additional = to.len().saturating_sub(from_len);
+    buf.reserve(additional * replace_count);
+
+    let mut end = buf.len();
+    while let Some(i) = buf[..end].rfind(from) {
+        buf.replace_range(i..i + from_len, to);
+        end = i;
+    }
 }
 
 #[must_use]

From c38c6b862851b6ff1a897037e1cb16898cfbf44f Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Sat, 20 Sep 2025 21:15:12 +0800
Subject: [PATCH 1183/1889] Add some test for stdx::replace

---
 .../rust-analyzer/crates/stdx/src/lib.rs      | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/stdx/src/lib.rs b/src/tools/rust-analyzer/crates/stdx/src/lib.rs
index 82f17fb9f7878..5fa0074163713 100644
--- a/src/tools/rust-analyzer/crates/stdx/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/stdx/src/lib.rs
@@ -351,4 +351,34 @@ mod tests {
             "fn main() {\n    return 92;\n}\n"
         );
     }
+
+    #[test]
+    fn test_replace() {
+        #[track_caller]
+        fn test_replace(src: &str, from: char, to: &str, expected: &str) {
+            let mut s = src.to_owned();
+            replace(&mut s, from, to);
+            assert_eq!(s, expected, "from: {from:?}, to: {to:?}");
+        }
+
+        test_replace("", 'a', "b", "");
+        test_replace("", 'a', "😀", "");
+        test_replace("", '😀', "a", "");
+        test_replace("a", 'a', "b", "b");
+        test_replace("aa", 'a', "b", "bb");
+        test_replace("ada", 'a', "b", "bdb");
+        test_replace("a", 'a', "😀", "😀");
+        test_replace("😀", '😀', "a", "a");
+        test_replace("😀x", '😀', "a", "ax");
+        test_replace("y😀x", '😀', "a", "yax");
+        test_replace("a,b,c", ',', ".", "a.b.c");
+        test_replace("a,b,c", ',', "..", "a..b..c");
+        test_replace("a.b.c", '.', "..", "a..b..c");
+        test_replace("a.b.c", '.', "..", "a..b..c");
+        test_replace("a😀b😀c", '😀', ".", "a.b.c");
+        test_replace("a.b.c", '.', "😀", "a😀b😀c");
+        test_replace("a.b.c", '.', "😀😀", "a😀😀b😀😀c");
+        test_replace(".a.b.c.", '.', "()", "()a()b()c()");
+        test_replace(".a.b.c.", '.', "", "abc");
+    }
 }

From 3e65620bef7d86a8f914a2a408dd91ca66b3499d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Justus=20Fl=C3=BCgel?= <justusfluegel@gmail.com>
Date: Sun, 7 Sep 2025 15:33:11 +0200
Subject: [PATCH 1184/1889] Add tests for `explicit_deref_methods` lints from
 within proc macros
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Justus Flügel <justusfluegel@gmail.com>
---
 tests/ui/explicit_deref_methods.fixed  | 15 +++++++++++++++
 tests/ui/explicit_deref_methods.rs     | 15 +++++++++++++++
 tests/ui/explicit_deref_methods.stderr | 26 +++++++++++++-------------
 3 files changed, 43 insertions(+), 13 deletions(-)

diff --git a/tests/ui/explicit_deref_methods.fixed b/tests/ui/explicit_deref_methods.fixed
index 52c4d1b1f301a..97e8e0bafe4fd 100644
--- a/tests/ui/explicit_deref_methods.fixed
+++ b/tests/ui/explicit_deref_methods.fixed
@@ -1,3 +1,4 @@
+//@aux-build:proc_macros.rs
 #![warn(clippy::explicit_deref_methods)]
 #![allow(unused_variables, unused_must_use)]
 #![allow(
@@ -14,6 +15,8 @@
 
 use std::ops::{Deref, DerefMut};
 
+extern crate proc_macros;
+
 fn concat(deref_str: &str) -> String {
     format!("{}bar", deref_str)
 }
@@ -121,6 +124,18 @@ fn main() {
     let b: &str = expr_deref!(&*a);
     //~^ explicit_deref_methods
 
+    proc_macros::external! {
+        let a: &mut String = &mut String::from("foo");
+        let b: &str = a.deref();
+    }
+
+    // Issue #15168
+    proc_macros::with_span! {
+        span
+        let a: &mut String = &mut String::from("foo");
+        let b: &str = a.deref();
+    }
+
     // The struct does not implement Deref trait
     #[derive(Copy, Clone)]
     struct NoLint(u32);
diff --git a/tests/ui/explicit_deref_methods.rs b/tests/ui/explicit_deref_methods.rs
index 706d6cb2b79a6..b689649d49dd7 100644
--- a/tests/ui/explicit_deref_methods.rs
+++ b/tests/ui/explicit_deref_methods.rs
@@ -1,3 +1,4 @@
+//@aux-build:proc_macros.rs
 #![warn(clippy::explicit_deref_methods)]
 #![allow(unused_variables, unused_must_use)]
 #![allow(
@@ -14,6 +15,8 @@
 
 use std::ops::{Deref, DerefMut};
 
+extern crate proc_macros;
+
 fn concat(deref_str: &str) -> String {
     format!("{}bar", deref_str)
 }
@@ -121,6 +124,18 @@ fn main() {
     let b: &str = expr_deref!(a.deref());
     //~^ explicit_deref_methods
 
+    proc_macros::external! {
+        let a: &mut String = &mut String::from("foo");
+        let b: &str = a.deref();
+    }
+
+    // Issue #15168
+    proc_macros::with_span! {
+        span
+        let a: &mut String = &mut String::from("foo");
+        let b: &str = a.deref();
+    }
+
     // The struct does not implement Deref trait
     #[derive(Copy, Clone)]
     struct NoLint(u32);
diff --git a/tests/ui/explicit_deref_methods.stderr b/tests/ui/explicit_deref_methods.stderr
index 5036884366cfc..e2f2e68720b17 100644
--- a/tests/ui/explicit_deref_methods.stderr
+++ b/tests/ui/explicit_deref_methods.stderr
@@ -1,5 +1,5 @@
 error: explicit `deref` method call
-  --> tests/ui/explicit_deref_methods.rs:55:19
+  --> tests/ui/explicit_deref_methods.rs:58:19
    |
 LL |     let b: &str = a.deref();
    |                   ^^^^^^^^^ help: try: `&*a`
@@ -8,73 +8,73 @@ LL |     let b: &str = a.deref();
    = help: to override `-D warnings` add `#[allow(clippy::explicit_deref_methods)]`
 
 error: explicit `deref_mut` method call
-  --> tests/ui/explicit_deref_methods.rs:58:23
+  --> tests/ui/explicit_deref_methods.rs:61:23
    |
 LL |     let b: &mut str = a.deref_mut();
    |                       ^^^^^^^^^^^^^ help: try: `&mut **a`
 
 error: explicit `deref` method call
-  --> tests/ui/explicit_deref_methods.rs:62:39
+  --> tests/ui/explicit_deref_methods.rs:65:39
    |
 LL |     let b: String = format!("{}, {}", a.deref(), a.deref());
    |                                       ^^^^^^^^^ help: try: `&*a`
 
 error: explicit `deref` method call
-  --> tests/ui/explicit_deref_methods.rs:62:50
+  --> tests/ui/explicit_deref_methods.rs:65:50
    |
 LL |     let b: String = format!("{}, {}", a.deref(), a.deref());
    |                                                  ^^^^^^^^^ help: try: `&*a`
 
 error: explicit `deref` method call
-  --> tests/ui/explicit_deref_methods.rs:66:20
+  --> tests/ui/explicit_deref_methods.rs:69:20
    |
 LL |     println!("{}", a.deref());
    |                    ^^^^^^^^^ help: try: `&*a`
 
 error: explicit `deref` method call
-  --> tests/ui/explicit_deref_methods.rs:70:11
+  --> tests/ui/explicit_deref_methods.rs:73:11
    |
 LL |     match a.deref() {
    |           ^^^^^^^^^ help: try: `&*a`
 
 error: explicit `deref` method call
-  --> tests/ui/explicit_deref_methods.rs:75:28
+  --> tests/ui/explicit_deref_methods.rs:78:28
    |
 LL |     let b: String = concat(a.deref());
    |                            ^^^^^^^^^ help: try: `&*a`
 
 error: explicit `deref` method call
-  --> tests/ui/explicit_deref_methods.rs:78:13
+  --> tests/ui/explicit_deref_methods.rs:81:13
    |
 LL |     let b = just_return(a).deref();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: try: `just_return(a)`
 
 error: explicit `deref` method call
-  --> tests/ui/explicit_deref_methods.rs:81:28
+  --> tests/ui/explicit_deref_methods.rs:84:28
    |
 LL |     let b: String = concat(just_return(a).deref());
    |                            ^^^^^^^^^^^^^^^^^^^^^^ help: try: `just_return(a)`
 
 error: explicit `deref` method call
-  --> tests/ui/explicit_deref_methods.rs:121:31
+  --> tests/ui/explicit_deref_methods.rs:124:31
    |
 LL |     let b: &str = expr_deref!(a.deref());
    |                               ^^^^^^^^^ help: try: `&*a`
 
 error: explicit `deref` method call
-  --> tests/ui/explicit_deref_methods.rs:139:14
+  --> tests/ui/explicit_deref_methods.rs:154:14
    |
 LL |     let _ = &Deref::deref(&"foo");
    |              ^^^^^^^^^^^^^^^^^^^^ help: try: `*&"foo"`
 
 error: explicit `deref_mut` method call
-  --> tests/ui/explicit_deref_methods.rs:141:14
+  --> tests/ui/explicit_deref_methods.rs:156:14
    |
 LL |     let _ = &DerefMut::deref_mut(&mut x);
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&mut **&mut x`
 
 error: explicit `deref_mut` method call
-  --> tests/ui/explicit_deref_methods.rs:142:14
+  --> tests/ui/explicit_deref_methods.rs:157:14
    |
 LL |     let _ = &DerefMut::deref_mut((&mut &mut x).deref_mut());
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&mut ***(&mut &mut x)`

From 3c232fe38f1629ae469ee97455ce0be07a1ae8ae Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Sat, 20 Sep 2025 13:53:58 +0000
Subject: [PATCH 1185/1889] Make term_patch_map sparse.

---
 compiler/rustc_mir_transform/src/patch.rs | 32 +++++++++++++----------
 1 file changed, 18 insertions(+), 14 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/patch.rs b/compiler/rustc_mir_transform/src/patch.rs
index f38881baf0f29..8f2124405650a 100644
--- a/compiler/rustc_mir_transform/src/patch.rs
+++ b/compiler/rustc_mir_transform/src/patch.rs
@@ -1,4 +1,5 @@
-use rustc_index::{Idx, IndexVec};
+use rustc_data_structures::fx::FxHashMap;
+use rustc_index::Idx;
 use rustc_middle::mir::*;
 use rustc_middle::ty::Ty;
 use rustc_span::Span;
@@ -9,7 +10,7 @@ use tracing::debug;
 /// and replacement of terminators, and then apply the queued changes all at
 /// once with `apply`. This is useful for MIR transformation passes.
 pub(crate) struct MirPatch<'tcx> {
-    term_patch_map: IndexVec<BasicBlock, Option<TerminatorKind<'tcx>>>,
+    term_patch_map: FxHashMap<BasicBlock, TerminatorKind<'tcx>>,
     new_blocks: Vec<BasicBlockData<'tcx>>,
     new_statements: Vec<(Location, StatementKind<'tcx>)>,
     new_locals: Vec<LocalDecl<'tcx>>,
@@ -22,17 +23,19 @@ pub(crate) struct MirPatch<'tcx> {
     terminate_block: Option<(BasicBlock, UnwindTerminateReason)>,
     body_span: Span,
     next_local: usize,
+    next_block: usize,
 }
 
 impl<'tcx> MirPatch<'tcx> {
     /// Creates a new, empty patch.
     pub(crate) fn new(body: &Body<'tcx>) -> Self {
         let mut result = MirPatch {
-            term_patch_map: IndexVec::from_elem(None, &body.basic_blocks),
+            term_patch_map: Default::default(),
             new_blocks: vec![],
             new_statements: vec![],
             new_locals: vec![],
             next_local: body.local_decls.len(),
+            next_block: body.basic_blocks.len(),
             resume_block: None,
             unreachable_cleanup_block: None,
             unreachable_no_cleanup_block: None,
@@ -141,7 +144,7 @@ impl<'tcx> MirPatch<'tcx> {
 
     /// Has a replacement of this block's terminator been queued in this patch?
     pub(crate) fn is_term_patched(&self, bb: BasicBlock) -> bool {
-        self.term_patch_map[bb].is_some()
+        self.term_patch_map.contains_key(&bb)
     }
 
     /// Universal getter for block data, either it is in 'old' blocks or in patched ones
@@ -194,18 +197,17 @@ impl<'tcx> MirPatch<'tcx> {
 
     /// Queues the addition of a new basic block.
     pub(crate) fn new_block(&mut self, data: BasicBlockData<'tcx>) -> BasicBlock {
-        let block = self.term_patch_map.next_index();
+        let block = BasicBlock::from_usize(self.next_block + self.new_blocks.len());
         debug!("MirPatch: new_block: {:?}: {:?}", block, data);
         self.new_blocks.push(data);
-        self.term_patch_map.push(None);
         block
     }
 
     /// Queues the replacement of a block's terminator.
     pub(crate) fn patch_terminator(&mut self, block: BasicBlock, new: TerminatorKind<'tcx>) {
-        assert!(self.term_patch_map[block].is_none());
+        assert!(!self.term_patch_map.contains_key(&block));
         debug!("MirPatch: patch_terminator({:?}, {:?})", block, new);
-        self.term_patch_map[block] = Some(new);
+        self.term_patch_map.insert(block, new);
     }
 
     /// Queues the insertion of a statement at a given location. The statement
@@ -244,18 +246,20 @@ impl<'tcx> MirPatch<'tcx> {
             self.new_blocks.len(),
             body.basic_blocks.len()
         );
-        let bbs = if self.term_patch_map.iter().all(Option::is_none) && self.new_blocks.is_empty() {
+        debug_assert_eq!(self.next_block, body.basic_blocks.len());
+        let bbs = if self.term_patch_map.is_empty() && self.new_blocks.is_empty() {
             body.basic_blocks.as_mut_preserves_cfg()
         } else {
             body.basic_blocks.as_mut()
         };
         bbs.extend(self.new_blocks);
         body.local_decls.extend(self.new_locals);
-        for (src, patch) in self.term_patch_map.into_iter_enumerated() {
-            if let Some(patch) = patch {
-                debug!("MirPatch: patching block {:?}", src);
-                bbs[src].terminator_mut().kind = patch;
-            }
+
+        // The order in which we patch terminators does not change the result.
+        #[allow(rustc::potential_query_instability)]
+        for (src, patch) in self.term_patch_map {
+            debug!("MirPatch: patching block {:?}", src);
+            bbs[src].terminator_mut().kind = patch;
         }
 
         let mut new_statements = self.new_statements;

From 2f6503d57406b17d2c56ce77339df5547589c1f6 Mon Sep 17 00:00:00 2001
From: Alexey Semenyuk <alexsemenyuk88@gmail.com>
Date: Sat, 20 Sep 2025 19:45:28 +0500
Subject: [PATCH 1186/1889] Update actions/download-artifact to v5

---
 .github/workflows/clippy_mq.yml         | 2 +-
 .github/workflows/lintcheck.yml         | 2 +-
 .github/workflows/lintcheck_summary.yml | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/clippy_mq.yml b/.github/workflows/clippy_mq.yml
index 0bcb713593593..9d099137449ef 100644
--- a/.github/workflows/clippy_mq.yml
+++ b/.github/workflows/clippy_mq.yml
@@ -181,7 +181,7 @@ jobs:
 
     # Download
     - name: Download target dir
-      uses: actions/download-artifact@v4
+      uses: actions/download-artifact@v5
       with:
         name: binaries
         path: target/debug
diff --git a/.github/workflows/lintcheck.yml b/.github/workflows/lintcheck.yml
index 390d6a0f74758..45fd10ae76149 100644
--- a/.github/workflows/lintcheck.yml
+++ b/.github/workflows/lintcheck.yml
@@ -126,7 +126,7 @@ jobs:
         fail-on-cache-miss: true
 
     - name: Download JSON
-      uses: actions/download-artifact@v4
+      uses: actions/download-artifact@v5
 
     - name: Store PR number
       run: echo ${{ github.event.pull_request.number }} > pr.txt
diff --git a/.github/workflows/lintcheck_summary.yml b/.github/workflows/lintcheck_summary.yml
index 52f52e155a07b..183258a964379 100644
--- a/.github/workflows/lintcheck_summary.yml
+++ b/.github/workflows/lintcheck_summary.yml
@@ -27,7 +27,7 @@ jobs:
     if: ${{ github.event.workflow_run.conclusion == 'success' }}
     steps:
       - name: Download artifact
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v5
         with:
           name: summary
           path: untrusted

From aa3aac5880d690075d9add402ab4227edeae0889 Mon Sep 17 00:00:00 2001
From: Kivooeo <Kivooeo123@gmail.com>
Date: Sat, 20 Sep 2025 08:42:51 -0700
Subject: [PATCH 1187/1889] allow take union field addresses in safe rust

---
 .../hir-ty/src/diagnostics/unsafe_check.rs    | 16 +++++++
 .../src/handlers/missing_unsafe.rs            | 43 +++++++++++++++++++
 .../test_data/highlight_unsafe.html           |  2 +-
 3 files changed, 60 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs
index 3f04b72c2fc68..3c78f5ef38704 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/unsafe_check.rs
@@ -315,6 +315,22 @@ impl<'db> UnsafeVisitor<'db> {
                     }
                     _ => (),
                 }
+
+                let mut peeled = *expr;
+                while let Expr::Field { expr: lhs, .. } = &self.body[peeled] {
+                    if let Some(Either::Left(FieldId { parent: VariantId::UnionId(_), .. })) =
+                        self.infer.field_resolution(peeled)
+                    {
+                        peeled = *lhs;
+                    } else {
+                        break;
+                    }
+                }
+
+                // Walk the peeled expression (the LHS of the union field chain)
+                self.walk_expr(peeled);
+                // Return so we don't recurse directly onto the union field access(es)
+                return;
             }
             Expr::MethodCall { .. } => {
                 if let Some((func, _)) = self.infer.method_resolution(current) {
diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_unsafe.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_unsafe.rs
index 4bb64747f5bb7..029ed18a4d390 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_unsafe.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_unsafe.rs
@@ -441,6 +441,49 @@ fn main() {
         )
     }
 
+    #[test]
+    fn raw_deref_on_union_field() {
+        check_diagnostics(
+            r#"
+fn main() {
+
+    union U {
+        a: u8
+    }
+    let x = U { a: 3 };
+
+    let a = &raw mut x.a;
+
+    union U1 {
+        a: u8
+    }
+    let x = U1 { a: 3 };
+
+    let a = x.a;
+         // ^^^ 💡 error: access to union field is unsafe and requires an unsafe function or block
+
+
+    let b = &raw const x.a;
+
+    let tmp = Vec::from([1, 2, 3]);
+
+    let c = &raw const tmp[x.a];
+                        // ^^^ 💡 error: access to union field is unsafe and requires an unsafe function or block
+
+    union URef {
+        p: &'static mut i32,
+    }
+
+    fn deref_union_field(u: URef) {
+        // Not an assignment but an access to the union field!
+        *(u.p) = 13;
+       // ^^^ 💡 error: access to union field is unsafe and requires an unsafe function or block
+    }
+}
+"#,
+        )
+    }
+
     #[test]
     fn unsafe_expr_as_an_argument_of_a_method_call() {
         check_fix(
diff --git a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
index 828b8f762c58a..8339daf32462b 100644
--- a/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
+++ b/src/tools/rust-analyzer/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
@@ -96,7 +96,7 @@
 
         <span class="variable">u</span><span class="operator">.</span><span class="field unsafe">field</span><span class="semicolon">;</span>
         <span class="operator">&</span><span class="variable">u</span><span class="operator">.</span><span class="field unsafe">field</span><span class="semicolon">;</span>
-        <span class="operator">&</span><span class="keyword">raw</span> <span class="keyword const">const</span> <span class="variable">u</span><span class="operator">.</span><span class="field unsafe">field</span><span class="semicolon">;</span>
+        <span class="operator">&</span><span class="keyword">raw</span> <span class="keyword const">const</span> <span class="variable">u</span><span class="operator">.</span><span class="field">field</span><span class="semicolon">;</span>
         <span class="comment">// this should be safe!</span>
         <span class="keyword">let</span> <span class="union">Union</span> <span class="brace">{</span> <span class="field">field</span><span class="colon">:</span> <span class="punctuation">_</span> <span class="brace">}</span><span class="semicolon">;</span>
         <span class="comment">// but not these</span>

From fd7f8b2b25d195d47682bbddb9de38b01ae9f6da Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sat, 20 Sep 2025 17:58:32 +0200
Subject: [PATCH 1188/1889] [GCC backend] Ignore failing ui abi tests

---
 tests/ui/abi/abi-sysv64-arg-passing.rs          | 1 +
 tests/ui/abi/abi-sysv64-register-usage.rs       | 1 +
 tests/ui/abi/issue-28676.rs                     | 2 ++
 tests/ui/abi/large-byval-align.rs               | 1 +
 tests/ui/abi/numbers-arithmetic/float-struct.rs | 1 +
 tests/ui/abi/stack-probes-lto.rs                | 1 +
 tests/ui/abi/stack-probes.rs                    | 1 +
 tests/ui/abi/stack-protector.rs                 | 1 +
 tests/ui/abi/struct-enums/struct-return.rs      | 2 ++
 tests/ui/abi/variadic-ffi.rs                    | 2 ++
 tests/ui/abi/x86stdcall.rs                      | 1 +
 11 files changed, 14 insertions(+)

diff --git a/tests/ui/abi/abi-sysv64-arg-passing.rs b/tests/ui/abi/abi-sysv64-arg-passing.rs
index c18752418a1d6..362a1862f9d4c 100644
--- a/tests/ui/abi/abi-sysv64-arg-passing.rs
+++ b/tests/ui/abi/abi-sysv64-arg-passing.rs
@@ -28,6 +28,7 @@
 //@ ignore-arm
 //@ ignore-aarch64
 //@ ignore-windows
+//@ ignore-backends: gcc
 
 // Windows is ignored because bootstrap doesn't yet know to compile rust_test_helpers with
 // the sysv64 ABI on Windows.
diff --git a/tests/ui/abi/abi-sysv64-register-usage.rs b/tests/ui/abi/abi-sysv64-register-usage.rs
index d2fb2ae53ac73..cf1620db6f7be 100644
--- a/tests/ui/abi/abi-sysv64-register-usage.rs
+++ b/tests/ui/abi/abi-sysv64-register-usage.rs
@@ -6,6 +6,7 @@
 //@ ignore-arm
 //@ ignore-aarch64
 //@ needs-asm-support
+//@ ignore-backends: gcc
 
 #[cfg(target_arch = "x86_64")]
 pub extern "sysv64" fn all_the_registers(
diff --git a/tests/ui/abi/issue-28676.rs b/tests/ui/abi/issue-28676.rs
index 8640f5aad21c9..2abb4ce52b3b3 100644
--- a/tests/ui/abi/issue-28676.rs
+++ b/tests/ui/abi/issue-28676.rs
@@ -1,4 +1,6 @@
 //@ run-pass
+//@ ignore-backends: gcc
+
 #![allow(dead_code)]
 #![allow(improper_ctypes)]
 
diff --git a/tests/ui/abi/large-byval-align.rs b/tests/ui/abi/large-byval-align.rs
index c1de841178fcd..69418e1cbc7b8 100644
--- a/tests/ui/abi/large-byval-align.rs
+++ b/tests/ui/abi/large-byval-align.rs
@@ -1,6 +1,7 @@
 //@ compile-flags: -Copt-level=0
 //@ only-x86_64
 //@ build-pass
+//@ ignore-backends: gcc
 
 #[repr(align(536870912))]
 pub struct A(i64);
diff --git a/tests/ui/abi/numbers-arithmetic/float-struct.rs b/tests/ui/abi/numbers-arithmetic/float-struct.rs
index a958dc272722f..dc4c536a14e2d 100644
--- a/tests/ui/abi/numbers-arithmetic/float-struct.rs
+++ b/tests/ui/abi/numbers-arithmetic/float-struct.rs
@@ -1,4 +1,5 @@
 //@ run-pass
+//@ ignore-backends: gcc
 
 use std::fmt::Debug;
 use std::hint::black_box;
diff --git a/tests/ui/abi/stack-probes-lto.rs b/tests/ui/abi/stack-probes-lto.rs
index c6e5bea5f4225..6203be90590d3 100644
--- a/tests/ui/abi/stack-probes-lto.rs
+++ b/tests/ui/abi/stack-probes-lto.rs
@@ -13,5 +13,6 @@
 //@ ignore-tvos Stack probes are enabled, but the SIGSEGV handler isn't
 //@ ignore-watchos Stack probes are enabled, but the SIGSEGV handler isn't
 //@ ignore-visionos Stack probes are enabled, but the SIGSEGV handler isn't
+//@ ignore-backends: gcc
 
 include!("stack-probes.rs");
diff --git a/tests/ui/abi/stack-probes.rs b/tests/ui/abi/stack-probes.rs
index f0fbd80d2e734..4d0301411e0fd 100644
--- a/tests/ui/abi/stack-probes.rs
+++ b/tests/ui/abi/stack-probes.rs
@@ -10,6 +10,7 @@
 //@ ignore-tvos Stack probes are enabled, but the SIGSEGV handler isn't
 //@ ignore-watchos Stack probes are enabled, but the SIGSEGV handler isn't
 //@ ignore-visionos Stack probes are enabled, but the SIGSEGV handler isn't
+//@ ignore-backends: gcc
 
 use std::env;
 use std::mem::MaybeUninit;
diff --git a/tests/ui/abi/stack-protector.rs b/tests/ui/abi/stack-protector.rs
index 29332861977b7..928b49c0eea50 100644
--- a/tests/ui/abi/stack-protector.rs
+++ b/tests/ui/abi/stack-protector.rs
@@ -4,6 +4,7 @@
 //@ [ssp] compile-flags: -Z stack-protector=all
 //@ compile-flags: -C opt-level=2
 //@ compile-flags: -g
+//@ ignore-backends: gcc
 
 use std::env;
 use std::process::{Command, ExitStatus};
diff --git a/tests/ui/abi/struct-enums/struct-return.rs b/tests/ui/abi/struct-enums/struct-return.rs
index 5b39c0de45467..5fe80d5f670b2 100644
--- a/tests/ui/abi/struct-enums/struct-return.rs
+++ b/tests/ui/abi/struct-enums/struct-return.rs
@@ -1,4 +1,6 @@
 //@ run-pass
+//@ ignore-backends: gcc
+
 #![allow(dead_code)]
 
 #[repr(C)]
diff --git a/tests/ui/abi/variadic-ffi.rs b/tests/ui/abi/variadic-ffi.rs
index 6cfae0f2a320f..dfdbff33264be 100644
--- a/tests/ui/abi/variadic-ffi.rs
+++ b/tests/ui/abi/variadic-ffi.rs
@@ -1,4 +1,6 @@
 //@ run-pass
+//@ ignore-backends: gcc
+
 #![feature(c_variadic)]
 
 use std::ffi::VaList;
diff --git a/tests/ui/abi/x86stdcall.rs b/tests/ui/abi/x86stdcall.rs
index c1bd35b80d266..77866c30f0e49 100644
--- a/tests/ui/abi/x86stdcall.rs
+++ b/tests/ui/abi/x86stdcall.rs
@@ -1,5 +1,6 @@
 //@ run-pass
 //@ only-windows
+//@ ignore-backends: gcc
 // GetLastError doesn't seem to work with stack switching
 
 #[cfg(windows)]

From 5c0cb3af59e03b4248ae58ca4e65f14307320195 Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Sat, 20 Sep 2025 18:27:33 -0400
Subject: [PATCH 1189/1889] Fix old typo in lang_start_internal comment

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

diff --git a/library/std/src/rt.rs b/library/std/src/rt.rs
index b3f3b301e3db6..8d95cc1fb5747 100644
--- a/library/std/src/rt.rs
+++ b/library/std/src/rt.rs
@@ -161,7 +161,7 @@ fn lang_start_internal(
     // mechanism itself.
     //
     // There are a couple of instances where unwinding can begin. First is inside of the
-    // `rt::init`, `rt::cleanup` and similar functions controlled by bstd. In those instances a
+    // `rt::init`, `rt::cleanup` and similar functions controlled by std. In those instances a
     // panic is a std implementation bug. A quite likely one too, as there isn't any way to
     // prevent std from accidentally introducing a panic to these functions. Another is from
     // user code from `main` or, more nefariously, as described in e.g. issue #86030.

From 1dcba116f57014454282f8cf0997682e3769003d Mon Sep 17 00:00:00 2001
From: "Igor S. Gerasimov" <foxtranigor@gmail.com>
Date: Sun, 21 Sep 2025 04:19:10 +0200
Subject: [PATCH 1190/1889] Update list of good combinations (inc. beta +
 nightly)

---
 src/doc/rustc/src/linker-plugin-lto.md | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/doc/rustc/src/linker-plugin-lto.md b/src/doc/rustc/src/linker-plugin-lto.md
index ab95aa2e5a193..32e712a48d76f 100644
--- a/src/doc/rustc/src/linker-plugin-lto.md
+++ b/src/doc/rustc/src/linker-plugin-lto.md
@@ -144,7 +144,7 @@ def minor_version(version):
 INSTALL_TOOLCHAIN = ["rustup", "toolchain", "install", "--profile", "minimal"]
 subprocess.run(INSTALL_TOOLCHAIN + ["nightly"])
 
-LOWER_BOUND = 73
+LOWER_BOUND = 87
 NIGHTLY_VERSION = minor_version(subprocess.run(
     ["rustc", "+nightly", "--version"],
     capture_output=True,
@@ -201,6 +201,9 @@ The following table shows known good combinations of toolchain versions.
 | 1.65 - 1.69  |      15       |
 | 1.70 - 1.72  |      16       |
 | 1.73 - 1.77  |      17       |
-| 1.78         |      18       |
+| 1.78 - 1.81  |      18       |
+| 1.82 - 1.86  |      19       |
+| 1.87 - 1.90  |      20       |
+| 1.91 - 1.92  |      21       |
 
 Note that the compatibility policy for this feature might change in the future.

From 1525bf3e8dcd1e800ec5602030bf01e39dcd6137 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Sun, 21 Sep 2025 11:00:00 +0800
Subject: [PATCH 1191/1889] Fix not applicable on trailing comma for remove_dbg

`remove_dbg` not applicable for whitespaces after trailing comma

Example
---
```rust
fn foo() {
    dbg!(
        bar(),
    );
}
```

**Before this PR**:

Assist not applicable

**After this PR**:

```rust
fn foo() {
    bar();
}
```
---
 .../ide-assists/src/handlers/remove_dbg.rs      | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/remove_dbg.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/remove_dbg.rs
index 414f6746d4404..08779a3ed1f77 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/remove_dbg.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/remove_dbg.rs
@@ -83,7 +83,9 @@ fn compute_dbg_replacement(
     let input_expressions = input_expressions
         .into_iter()
         .filter_map(|(is_sep, group)| (!is_sep).then_some(group))
-        .map(|mut tokens| syntax::hacks::parse_expr_from_str(&tokens.join(""), Edition::CURRENT))
+        .map(|tokens| tokens.collect::<Vec<_>>())
+        .filter(|tokens| !tokens.iter().all(|it| it.kind().is_trivia()))
+        .map(|tokens| syntax::hacks::parse_expr_from_str(&tokens.iter().join(""), Edition::CURRENT))
         .collect::<Option<Vec<ast::Expr>>>()?;
 
     let parent = macro_expr.syntax().parent()?;
@@ -268,6 +270,8 @@ fn foo() {
     dbg!('x');
     dbg!(&n);
     dbg!(n);
+    dbg!(n,);
+    dbg!(n, );
     // needless comment
     dbg!("foo");$0
 }
@@ -281,6 +285,17 @@ fn foo() {
         );
     }
 
+    #[test]
+    fn test_remove_trailing_comma_dbg() {
+        check("$0dbg!(1 + 1,)", "1 + 1");
+        check("$0dbg!(1 + 1, )", "1 + 1");
+        check("$0dbg!(1 + 1,\n)", "1 + 1");
+        check("$0dbg!(1 + 1, 2 + 3)", "(1 + 1, 2 + 3)");
+        check("$0dbg!(1 + 1, 2 + 3 )", "(1 + 1, 2 + 3)");
+        check("$0dbg!(1 + 1, 2 + 3, )", "(1 + 1, 2 + 3)");
+        check("$0dbg!(1 + 1, 2 + 3 ,)", "(1 + 1, 2 + 3)");
+    }
+
     #[test]
     fn test_remove_dbg_not_applicable() {
         check_assist_not_applicable(remove_dbg, "fn main() {$0vec![1, 2, 3]}");

From 3934fc9eb29061168327640ba7b9ca8f79ba01e2 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Tue, 16 Sep 2025 02:33:24 +0000
Subject: [PATCH 1192/1889] Consider errors in MIR as impossible predicates.

---
 .../src/impossible_predicates.rs              | 33 ++++++-----
 tests/crashes/122904-2.rs                     | 17 ------
 tests/crashes/139556.rs                       | 13 -----
 tests/ui/consts/promoted_const_call2.rs       |  1 -
 tests/ui/consts/promoted_const_call2.stderr   | 17 ++----
 .../122630.rs => ui/coroutine/moved-twice.rs} | 11 +++-
 tests/ui/coroutine/moved-twice.stderr         | 24 ++++++++
 .../recursive-drop-elaboration-2.rs           | 19 ++++++
 .../recursive-drop-elaboration-2.stderr       | 30 ++++++++++
 .../recursive-drop-elaboration.rs             | 24 ++++++++
 .../recursive-drop-elaboration.stderr         | 58 +++++++++++++++++++
 .../type-error-drop-elaboration.rs}           |  3 +-
 .../type-error-drop-elaboration.stderr        | 12 ++++
 13 files changed, 201 insertions(+), 61 deletions(-)
 delete mode 100644 tests/crashes/122904-2.rs
 delete mode 100644 tests/crashes/139556.rs
 rename tests/{crashes/122630.rs => ui/coroutine/moved-twice.rs} (62%)
 create mode 100644 tests/ui/coroutine/moved-twice.stderr
 create mode 100644 tests/ui/type-alias-impl-trait/recursive-drop-elaboration-2.rs
 create mode 100644 tests/ui/type-alias-impl-trait/recursive-drop-elaboration-2.stderr
 create mode 100644 tests/ui/type-alias-impl-trait/recursive-drop-elaboration.rs
 create mode 100644 tests/ui/type-alias-impl-trait/recursive-drop-elaboration.stderr
 rename tests/{crashes/125185.rs => ui/type-alias-impl-trait/type-error-drop-elaboration.rs} (78%)
 create mode 100644 tests/ui/type-alias-impl-trait/type-error-drop-elaboration.stderr

diff --git a/compiler/rustc_mir_transform/src/impossible_predicates.rs b/compiler/rustc_mir_transform/src/impossible_predicates.rs
index b03518de00a9c..883ee32bdec91 100644
--- a/compiler/rustc_mir_transform/src/impossible_predicates.rs
+++ b/compiler/rustc_mir_transform/src/impossible_predicates.rs
@@ -28,6 +28,7 @@
 
 use rustc_middle::mir::{Body, START_BLOCK, TerminatorKind};
 use rustc_middle::ty::{TyCtxt, TypeFlags, TypeVisitableExt};
+use rustc_span::def_id::DefId;
 use rustc_trait_selection::traits;
 use tracing::trace;
 
@@ -35,23 +36,29 @@ use crate::pass_manager::MirPass;
 
 pub(crate) struct ImpossiblePredicates;
 
+fn has_impossible_predicates(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
+    let predicates = tcx.predicates_of(def_id).instantiate_identity(tcx);
+    tracing::trace!(?predicates);
+    let predicates = predicates.predicates.into_iter().filter(|p| {
+        !p.has_type_flags(
+            // Only consider global clauses to simplify.
+            TypeFlags::HAS_FREE_LOCAL_NAMES
+                // Clauses that refer to unevaluated constants as they cause cycles.
+                | TypeFlags::HAS_CT_PROJECTION,
+        )
+    });
+    let predicates: Vec<_> = traits::elaborate(tcx, predicates).collect();
+    tracing::trace!(?predicates);
+    predicates.references_error() || traits::impossible_predicates(tcx, predicates)
+}
+
 impl<'tcx> MirPass<'tcx> for ImpossiblePredicates {
     #[tracing::instrument(level = "trace", skip(self, tcx, body))]
     fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
         tracing::trace!(def_id = ?body.source.def_id());
-        let predicates = tcx.predicates_of(body.source.def_id()).instantiate_identity(tcx);
-        tracing::trace!(?predicates);
-        let predicates = predicates.predicates.into_iter().filter(|p| {
-            !p.has_type_flags(
-                // Only consider global clauses to simplify.
-                TypeFlags::HAS_FREE_LOCAL_NAMES
-                // Clauses that refer to unevaluated constants as they cause cycles.
-                | TypeFlags::HAS_CT_PROJECTION,
-            )
-        });
-        let predicates: Vec<_> = traits::elaborate(tcx, predicates).collect();
-        tracing::trace!(?predicates);
-        if predicates.references_error() || traits::impossible_predicates(tcx, predicates) {
+        let impossible = body.tainted_by_errors.is_some()
+            || has_impossible_predicates(tcx, body.source.def_id());
+        if impossible {
             trace!("found unsatisfiable predicates");
             // Clear the body to only contain a single `unreachable` statement.
             let bbs = body.basic_blocks.as_mut();
diff --git a/tests/crashes/122904-2.rs b/tests/crashes/122904-2.rs
deleted file mode 100644
index db66b8625db0e..0000000000000
--- a/tests/crashes/122904-2.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ known-bug: #122904
-trait T {}
-
-type Alias<'a> = impl T;
-
-struct S;
-impl<'a> T for &'a S {}
-
-#[define_opaque(Alias)]
-fn with_positive(fun: impl Fn(Alias<'_>)) {
-    with_positive(|&n| ());
-}
-
-#[define_opaque(Alias)]
-fn main(Alias<'_>) {
-    with_positive(|&a| ());
-}
diff --git a/tests/crashes/139556.rs b/tests/crashes/139556.rs
deleted file mode 100644
index 60dc8d7c3afcc..0000000000000
--- a/tests/crashes/139556.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ known-bug: #139556
-
-trait T {}
-
-type Alias<'a> = impl T;
-
-struct S;
-impl<'a> T for &'a S {}
-
-#[define_opaque(Alias)]
-fn with_positive(fun: impl Fn(Alias<'_>)) {
-    with_positive(|&n| ());
-}
diff --git a/tests/ui/consts/promoted_const_call2.rs b/tests/ui/consts/promoted_const_call2.rs
index f332cd18cea37..62391f098e5d1 100644
--- a/tests/ui/consts/promoted_const_call2.rs
+++ b/tests/ui/consts/promoted_const_call2.rs
@@ -4,7 +4,6 @@ pub const C: () = {
     let _: &'static _ = &id(&String::new());
     //~^ ERROR: temporary value dropped while borrowed
     //~| ERROR: temporary value dropped while borrowed
-    //~| ERROR: destructor of `String` cannot be evaluated at compile-time
 };
 
 fn main() {
diff --git a/tests/ui/consts/promoted_const_call2.stderr b/tests/ui/consts/promoted_const_call2.stderr
index bdb43385d2032..e62458d1a6ae4 100644
--- a/tests/ui/consts/promoted_const_call2.stderr
+++ b/tests/ui/consts/promoted_const_call2.stderr
@@ -18,16 +18,8 @@ LL |     let _: &'static _ = &id(&String::new());
    |            |                 creates a temporary value which is freed while still in use
    |            type annotation requires that borrow lasts for `'static`
 
-error[E0493]: destructor of `String` cannot be evaluated at compile-time
-  --> $DIR/promoted_const_call2.rs:4:30
-   |
-LL |     let _: &'static _ = &id(&String::new());
-   |                              ^^^^^^^^^^^^^ - value is dropped here
-   |                              |
-   |                              the destructor for this type cannot be evaluated in constants
-
 error[E0716]: temporary value dropped while borrowed
-  --> $DIR/promoted_const_call2.rs:11:26
+  --> $DIR/promoted_const_call2.rs:10:26
    |
 LL |     let _: &'static _ = &id(&String::new());
    |            ----------    ^^^^^^^^^^^^^^^^^^ creates a temporary value which is freed while still in use
@@ -38,7 +30,7 @@ LL | }
    | - temporary value is freed at the end of this statement
 
 error[E0716]: temporary value dropped while borrowed
-  --> $DIR/promoted_const_call2.rs:11:30
+  --> $DIR/promoted_const_call2.rs:10:30
    |
 LL |     let _: &'static _ = &id(&String::new());
    |            ----------        ^^^^^^^^^^^^^ - temporary value is freed at the end of this statement
@@ -46,7 +38,6 @@ LL |     let _: &'static _ = &id(&String::new());
    |            |                 creates a temporary value which is freed while still in use
    |            type annotation requires that borrow lasts for `'static`
 
-error: aborting due to 5 previous errors
+error: aborting due to 4 previous errors
 
-Some errors have detailed explanations: E0493, E0716.
-For more information about an error, try `rustc --explain E0493`.
+For more information about this error, try `rustc --explain E0716`.
diff --git a/tests/crashes/122630.rs b/tests/ui/coroutine/moved-twice.rs
similarity index 62%
rename from tests/crashes/122630.rs
rename to tests/ui/coroutine/moved-twice.rs
index e66624431c510..72b83e274c929 100644
--- a/tests/crashes/122630.rs
+++ b/tests/ui/coroutine/moved-twice.rs
@@ -1,22 +1,27 @@
-//@ known-bug: #122630
+//! Regression test for #122630
 //@ compile-flags: -Zvalidate-mir
 
+#![feature(coroutines, coroutine_trait, yield_expr)]
+
 use std::ops::Coroutine;
 
 const FOO_SIZE: usize = 1024;
 struct Foo([u8; FOO_SIZE]);
 
 impl Drop for Foo {
-    fn move_before_yield_with_noop() -> impl Coroutine<Yield = ()> {}
+    fn drop(&mut self) {}
 }
 
 fn overlap_move_points() -> impl Coroutine<Yield = ()> {
-    static || {
+    #[coroutine] static || {
         let first = Foo([0; FOO_SIZE]);
         yield;
         let second = first;
         yield;
         let second = first;
+        //~^ ERROR: use of moved value: `first` [E0382]
         yield;
     }
 }
+
+fn main() {}
diff --git a/tests/ui/coroutine/moved-twice.stderr b/tests/ui/coroutine/moved-twice.stderr
new file mode 100644
index 0000000000000..2b21f6c59f0bc
--- /dev/null
+++ b/tests/ui/coroutine/moved-twice.stderr
@@ -0,0 +1,24 @@
+error[E0382]: use of moved value: `first`
+  --> $DIR/moved-twice.rs:21:22
+   |
+LL |         let first = Foo([0; FOO_SIZE]);
+   |             ----- move occurs because `first` has type `Foo`, which does not implement the `Copy` trait
+LL |         yield;
+LL |         let second = first;
+   |                      ----- value moved here
+LL |         yield;
+LL |         let second = first;
+   |                      ^^^^^ value used here after move
+   |
+note: if `Foo` implemented `Clone`, you could clone the value
+  --> $DIR/moved-twice.rs:9:1
+   |
+LL | struct Foo([u8; FOO_SIZE]);
+   | ^^^^^^^^^^ consider implementing `Clone` for this type
+...
+LL |         let second = first;
+   |                      ----- you could clone this value
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/type-alias-impl-trait/recursive-drop-elaboration-2.rs b/tests/ui/type-alias-impl-trait/recursive-drop-elaboration-2.rs
new file mode 100644
index 0000000000000..5541c5267f39a
--- /dev/null
+++ b/tests/ui/type-alias-impl-trait/recursive-drop-elaboration-2.rs
@@ -0,0 +1,19 @@
+//! Regression test for ICE #139556
+
+#![feature(type_alias_impl_trait)]
+
+trait T {}
+
+type Alias<'a> = impl T;
+
+struct S;
+impl<'a> T for &'a S {}
+
+#[define_opaque(Alias)]
+fn with_positive(fun: impl Fn(Alias<'_>)) {
+//~^ WARN: function cannot return without recursing
+    with_positive(|&n| ());
+    //~^ ERROR: cannot move out of a shared reference
+}
+
+fn main() {}
diff --git a/tests/ui/type-alias-impl-trait/recursive-drop-elaboration-2.stderr b/tests/ui/type-alias-impl-trait/recursive-drop-elaboration-2.stderr
new file mode 100644
index 0000000000000..e1fdd222ee147
--- /dev/null
+++ b/tests/ui/type-alias-impl-trait/recursive-drop-elaboration-2.stderr
@@ -0,0 +1,30 @@
+warning: function cannot return without recursing
+  --> $DIR/recursive-drop-elaboration-2.rs:13:1
+   |
+LL | fn with_positive(fun: impl Fn(Alias<'_>)) {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot return without recursing
+LL |
+LL |     with_positive(|&n| ());
+   |     ---------------------- recursive call site
+   |
+   = help: a `loop` may express intention better if this is on purpose
+   = note: `#[warn(unconditional_recursion)]` on by default
+
+error[E0507]: cannot move out of a shared reference
+  --> $DIR/recursive-drop-elaboration-2.rs:15:20
+   |
+LL |     with_positive(|&n| ());
+   |                    ^-
+   |                     |
+   |                     data moved here
+   |                     move occurs because `n` has type `S`, which does not implement the `Copy` trait
+   |
+help: consider removing the borrow
+   |
+LL -     with_positive(|&n| ());
+LL +     with_positive(|n| ());
+   |
+
+error: aborting due to 1 previous error; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/type-alias-impl-trait/recursive-drop-elaboration.rs b/tests/ui/type-alias-impl-trait/recursive-drop-elaboration.rs
new file mode 100644
index 0000000000000..dd28732ebb281
--- /dev/null
+++ b/tests/ui/type-alias-impl-trait/recursive-drop-elaboration.rs
@@ -0,0 +1,24 @@
+//! Regression test for #122904.
+
+#![feature(type_alias_impl_trait)]
+
+trait T {}
+
+type Alias<'a> = impl T;
+
+struct S;
+impl<'a> T for &'a S {}
+
+#[define_opaque(Alias)]
+fn with_positive(fun: impl Fn(Alias<'_>)) {
+//~^ WARN: function cannot return without recursing
+    with_positive(|&n| ());
+    //~^ ERROR: cannot move out of a shared reference
+}
+
+#[define_opaque(Alias)]
+fn main(_: Alias<'_>) {
+//~^ ERROR: `main` function has wrong type [E0580]
+    with_positive(|&a| ());
+    //~^ ERROR: cannot move out of a shared reference
+}
diff --git a/tests/ui/type-alias-impl-trait/recursive-drop-elaboration.stderr b/tests/ui/type-alias-impl-trait/recursive-drop-elaboration.stderr
new file mode 100644
index 0000000000000..8b5dc950afdde
--- /dev/null
+++ b/tests/ui/type-alias-impl-trait/recursive-drop-elaboration.stderr
@@ -0,0 +1,58 @@
+warning: function cannot return without recursing
+  --> $DIR/recursive-drop-elaboration.rs:13:1
+   |
+LL | fn with_positive(fun: impl Fn(Alias<'_>)) {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot return without recursing
+LL |
+LL |     with_positive(|&n| ());
+   |     ---------------------- recursive call site
+   |
+   = help: a `loop` may express intention better if this is on purpose
+   = note: `#[warn(unconditional_recursion)]` on by default
+
+error[E0507]: cannot move out of a shared reference
+  --> $DIR/recursive-drop-elaboration.rs:15:20
+   |
+LL |     with_positive(|&n| ());
+   |                    ^-
+   |                     |
+   |                     data moved here
+   |                     move occurs because `n` has type `S`, which does not implement the `Copy` trait
+   |
+help: consider removing the borrow
+   |
+LL -     with_positive(|&n| ());
+LL +     with_positive(|n| ());
+   |
+
+error[E0507]: cannot move out of a shared reference
+  --> $DIR/recursive-drop-elaboration.rs:22:20
+   |
+LL |     with_positive(|&a| ());
+   |                    ^-
+   |                     |
+   |                     data moved here
+   |                     move occurs because `a` has type `S`, which does not implement the `Copy` trait
+   |
+help: consider removing the borrow
+   |
+LL -     with_positive(|&a| ());
+LL +     with_positive(|a| ());
+   |
+
+error[E0580]: `main` function has wrong type
+  --> $DIR/recursive-drop-elaboration.rs:20:1
+   |
+LL | type Alias<'a> = impl T;
+   |                  ------ the found opaque type
+...
+LL | fn main(_: Alias<'_>) {
+   | ^^^^^^^^^^^^^^^^^^^^^ incorrect number of function parameters
+   |
+   = note: expected signature `fn()`
+              found signature `for<'a> fn(Alias<'a>)`
+
+error: aborting due to 3 previous errors; 1 warning emitted
+
+Some errors have detailed explanations: E0507, E0580.
+For more information about an error, try `rustc --explain E0507`.
diff --git a/tests/crashes/125185.rs b/tests/ui/type-alias-impl-trait/type-error-drop-elaboration.rs
similarity index 78%
rename from tests/crashes/125185.rs
rename to tests/ui/type-alias-impl-trait/type-error-drop-elaboration.rs
index e77666ca73d36..c0fb9007865a5 100644
--- a/tests/crashes/125185.rs
+++ b/tests/ui/type-alias-impl-trait/type-error-drop-elaboration.rs
@@ -1,4 +1,4 @@
-//@ known-bug: rust-lang/rust#125185
+//! Regression test for #125185
 //@ compile-flags: -Zvalidate-mir
 
 #![feature(type_alias_impl_trait)]
@@ -10,6 +10,7 @@ struct A;
 #[define_opaque(Foo)]
 const fn foo() -> Foo {
     value()
+    //~^ ERROR: cannot find function `value` in this scope
 }
 
 const VALUE: Foo = foo();
diff --git a/tests/ui/type-alias-impl-trait/type-error-drop-elaboration.stderr b/tests/ui/type-alias-impl-trait/type-error-drop-elaboration.stderr
new file mode 100644
index 0000000000000..1cb33eabd902e
--- /dev/null
+++ b/tests/ui/type-alias-impl-trait/type-error-drop-elaboration.stderr
@@ -0,0 +1,12 @@
+error[E0425]: cannot find function `value` in this scope
+  --> $DIR/type-error-drop-elaboration.rs:12:5
+   |
+LL |     value()
+   |     ^^^^^ help: a constant with a similar name exists: `VALUE`
+...
+LL | const VALUE: Foo = foo();
+   | ------------------------- similarly named constant `VALUE` defined here
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0425`.

From b441b801fa72dac0886b98dc68b02993dc07649e Mon Sep 17 00:00:00 2001
From: Iris Shi <0.0@owo.li>
Date: Sun, 21 Sep 2025 11:43:36 +0800
Subject: [PATCH 1193/1889] fix a crash in rustdoc merge finalize without input
 file

---
 src/librustdoc/lib.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index 9871066b9eb51..904972f52d018 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -835,8 +835,10 @@ fn main_args(early_dcx: &mut EarlyDiagCtxt, at_args: &[String]) {
         config::InputMode::NoInputMergeFinalize => {
             return wrap_return(
                 dcx,
-                run_merge_finalize(render_options)
-                    .map_err(|e| format!("could not write merged cross-crate info: {e}")),
+                rustc_span::create_session_globals_then(options.edition, &[], None, || {
+                    run_merge_finalize(render_options)
+                        .map_err(|e| format!("could not write merged cross-crate info: {e}"))
+                }),
             );
         }
     };

From f4b876867d609404be8a78220c0d5117303bb0f8 Mon Sep 17 00:00:00 2001
From: Taiki Endo <te316e89@gmail.com>
Date: Sun, 21 Sep 2025 13:48:22 +0900
Subject: [PATCH 1194/1889] Support ctr and lr as clobber-only registers in
 PowerPC inline assembly

---
 compiler/rustc_codegen_gcc/src/asm.rs         |  16 +-
 compiler/rustc_codegen_llvm/src/asm.rs        |  14 +-
 compiler/rustc_span/src/symbol.rs             |   2 +
 compiler/rustc_target/src/asm/mod.rs          |   5 +-
 compiler/rustc_target/src/asm/powerpc.rs      |  12 +-
 .../asm-experimental-arch.md                  |   6 +-
 tests/codegen-llvm/asm/powerpc-clobbers.rs    |   8 +-
 tests/ui/asm/powerpc/bad-reg.aix64.stderr     | 162 ++++++++++++----
 tests/ui/asm/powerpc/bad-reg.powerpc.stderr   | 176 +++++++++++++-----
 tests/ui/asm/powerpc/bad-reg.powerpc64.stderr | 168 ++++++++++++-----
 .../ui/asm/powerpc/bad-reg.powerpc64le.stderr | 162 ++++++++++++----
 tests/ui/asm/powerpc/bad-reg.rs               |  30 ++-
 12 files changed, 572 insertions(+), 189 deletions(-)

diff --git a/compiler/rustc_codegen_gcc/src/asm.rs b/compiler/rustc_codegen_gcc/src/asm.rs
index 17e2e028b16fa..a14881c502cf3 100644
--- a/compiler/rustc_codegen_gcc/src/asm.rs
+++ b/compiler/rustc_codegen_gcc/src/asm.rs
@@ -698,8 +698,12 @@ fn reg_class_to_gcc(reg_class: InlineAsmRegClass) -> &'static str {
         InlineAsmRegClass::PowerPC(PowerPCInlineAsmRegClass::reg_nonzero) => "b",
         InlineAsmRegClass::PowerPC(PowerPCInlineAsmRegClass::freg) => "f",
         InlineAsmRegClass::PowerPC(PowerPCInlineAsmRegClass::vreg) => "v",
-        InlineAsmRegClass::PowerPC(PowerPCInlineAsmRegClass::cr)
-        | InlineAsmRegClass::PowerPC(PowerPCInlineAsmRegClass::xer) => {
+        InlineAsmRegClass::PowerPC(
+            PowerPCInlineAsmRegClass::cr
+            | PowerPCInlineAsmRegClass::ctr
+            | PowerPCInlineAsmRegClass::lr
+            | PowerPCInlineAsmRegClass::xer,
+        ) => {
             unreachable!("clobber-only")
         }
         InlineAsmRegClass::RiscV(RiscVInlineAsmRegClass::reg) => "r",
@@ -777,8 +781,12 @@ fn dummy_output_type<'gcc, 'tcx>(cx: &CodegenCx<'gcc, 'tcx>, reg: InlineAsmRegCl
         InlineAsmRegClass::PowerPC(PowerPCInlineAsmRegClass::vreg) => {
             cx.type_vector(cx.type_i32(), 4)
         }
-        InlineAsmRegClass::PowerPC(PowerPCInlineAsmRegClass::cr)
-        | InlineAsmRegClass::PowerPC(PowerPCInlineAsmRegClass::xer) => {
+        InlineAsmRegClass::PowerPC(
+            PowerPCInlineAsmRegClass::cr
+            | PowerPCInlineAsmRegClass::ctr
+            | PowerPCInlineAsmRegClass::lr
+            | PowerPCInlineAsmRegClass::xer,
+        ) => {
             unreachable!("clobber-only")
         }
         InlineAsmRegClass::RiscV(RiscVInlineAsmRegClass::reg) => cx.type_i32(),
diff --git a/compiler/rustc_codegen_llvm/src/asm.rs b/compiler/rustc_codegen_llvm/src/asm.rs
index b79176e909818..197ca7e0ba663 100644
--- a/compiler/rustc_codegen_llvm/src/asm.rs
+++ b/compiler/rustc_codegen_llvm/src/asm.rs
@@ -662,7 +662,12 @@ fn reg_to_llvm(reg: InlineAsmRegOrRegClass, layout: Option<&TyAndLayout<'_>>) ->
             PowerPC(PowerPCInlineAsmRegClass::reg_nonzero) => "b",
             PowerPC(PowerPCInlineAsmRegClass::freg) => "f",
             PowerPC(PowerPCInlineAsmRegClass::vreg) => "v",
-            PowerPC(PowerPCInlineAsmRegClass::cr) | PowerPC(PowerPCInlineAsmRegClass::xer) => {
+            PowerPC(
+                PowerPCInlineAsmRegClass::cr
+                | PowerPCInlineAsmRegClass::ctr
+                | PowerPCInlineAsmRegClass::lr
+                | PowerPCInlineAsmRegClass::xer,
+            ) => {
                 unreachable!("clobber-only")
             }
             RiscV(RiscVInlineAsmRegClass::reg) => "r",
@@ -830,7 +835,12 @@ fn dummy_output_type<'ll>(cx: &CodegenCx<'ll, '_>, reg: InlineAsmRegClass) -> &'
         PowerPC(PowerPCInlineAsmRegClass::reg_nonzero) => cx.type_i32(),
         PowerPC(PowerPCInlineAsmRegClass::freg) => cx.type_f64(),
         PowerPC(PowerPCInlineAsmRegClass::vreg) => cx.type_vector(cx.type_i32(), 4),
-        PowerPC(PowerPCInlineAsmRegClass::cr) | PowerPC(PowerPCInlineAsmRegClass::xer) => {
+        PowerPC(
+            PowerPCInlineAsmRegClass::cr
+            | PowerPCInlineAsmRegClass::ctr
+            | PowerPCInlineAsmRegClass::lr
+            | PowerPCInlineAsmRegClass::xer,
+        ) => {
             unreachable!("clobber-only")
         }
         RiscV(RiscVInlineAsmRegClass::reg) => cx.type_i32(),
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 4fef65f46b1fd..a6ae58f87dcc8 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -794,6 +794,7 @@ symbols! {
         ctlz,
         ctlz_nonzero,
         ctpop,
+        ctr,
         cttz,
         cttz_nonzero,
         custom_attribute,
@@ -1333,6 +1334,7 @@ symbols! {
         loongarch_target_feature,
         loop_break_value,
         loop_match,
+        lr,
         lt,
         m68k_target_feature,
         macro_at_most_once_rep,
diff --git a/compiler/rustc_target/src/asm/mod.rs b/compiler/rustc_target/src/asm/mod.rs
index e06f881e4b1c7..0601613567ead 100644
--- a/compiler/rustc_target/src/asm/mod.rs
+++ b/compiler/rustc_target/src/asm/mod.rs
@@ -1260,11 +1260,12 @@ impl InlineAsmClobberAbi {
                     v8, v9, v10, v11, v12, v13, v14,
                     v15, v16, v17, v18, v19,
 
-                    // cr0-cr1, cr5-cr7, xer
+                    // cr0-cr1, cr5-cr7, ctr, lr, xer
                     cr0, cr1,
                     cr5, cr6, cr7,
+                    ctr,
+                    lr,
                     xer,
-                    // lr and ctr are reserved
                 }
             },
             InlineAsmClobberAbi::S390x => clobbered_regs! {
diff --git a/compiler/rustc_target/src/asm/powerpc.rs b/compiler/rustc_target/src/asm/powerpc.rs
index f3934afa6d94f..2348a0fd202e1 100644
--- a/compiler/rustc_target/src/asm/powerpc.rs
+++ b/compiler/rustc_target/src/asm/powerpc.rs
@@ -13,6 +13,8 @@ def_reg_class! {
         freg,
         vreg,
         cr,
+        ctr,
+        lr,
         xer,
     }
 }
@@ -56,7 +58,7 @@ impl PowerPCInlineAsmRegClass {
                 altivec: VecI8(16), VecI16(8), VecI32(4), VecF32(4);
                 vsx: F32, F64, VecI64(2), VecF64(2);
             },
-            Self::cr | Self::xer => &[],
+            Self::cr | Self::ctr | Self::lr | Self::xer => &[],
         }
     }
 }
@@ -195,6 +197,8 @@ def_regs! {
         cr5: cr = ["cr5"],
         cr6: cr = ["cr6"],
         cr7: cr = ["cr7"],
+        ctr: ctr = ["ctr"],
+        lr: lr = ["lr"],
         xer: xer = ["xer"],
         #error = ["r1", "1", "sp"] =>
             "the stack pointer cannot be used as an operand for inline asm",
@@ -206,10 +210,6 @@ def_regs! {
             "r30 is used internally by LLVM and cannot be used as an operand for inline asm",
         #error = ["r31", "31", "fp"] =>
             "the frame pointer cannot be used as an operand for inline asm",
-        #error = ["lr"] =>
-            "the link register cannot be used as an operand for inline asm",
-        #error = ["ctr"] =>
-            "the counter register cannot be used as an operand for inline asm",
         #error = ["vrsave"] =>
             "the vrsave register cannot be used as an operand for inline asm",
     }
@@ -247,6 +247,8 @@ impl PowerPCInlineAsmReg {
             (v24, "24"), (v25, "25"), (v26, "26"), (v27, "27"), (v28, "28"), (v29, "29"), (v30, "30"), (v31, "31");
             (cr, "cr");
             (cr0, "0"), (cr1, "1"), (cr2, "2"), (cr3, "3"), (cr4, "4"), (cr5, "5"), (cr6, "6"), (cr7, "7");
+            (ctr, "ctr");
+            (lr, "lr");
             (xer, "xer");
         }
     }
diff --git a/src/doc/unstable-book/src/language-features/asm-experimental-arch.md b/src/doc/unstable-book/src/language-features/asm-experimental-arch.md
index d9566c9f55c5c..9434868dc08e6 100644
--- a/src/doc/unstable-book/src/language-features/asm-experimental-arch.md
+++ b/src/doc/unstable-book/src/language-features/asm-experimental-arch.md
@@ -36,6 +36,8 @@ This feature tracks `asm!` and `global_asm!` support for the following architect
 | PowerPC      | `freg`         | `f[0-31]`                          | `f`                  |
 | PowerPC      | `vreg`         | `v[0-31]`                          | `v`                  |
 | PowerPC      | `cr`           | `cr[0-7]`, `cr`                    | Only clobbers        |
+| PowerPC      | `ctr`          | `ctr`                              | Only clobbers        |
+| PowerPC      | `lr`           | `lr`                               | Only clobbers        |
 | PowerPC      | `xer`          | `xer`                              | Only clobbers        |
 | wasm32       | `local`        | None\*                             | `r`                  |
 | BPF          | `reg`          | `r[0-10]`                          | `r`                  |
@@ -78,6 +80,8 @@ This feature tracks `asm!` and `global_asm!` support for the following architect
 | PowerPC      | `vreg`                          | `altivec`      | `i8x16`, `i16x8`, `i32x4`, `f32x4`      |
 | PowerPC      | `vreg`                          | `vsx`          | `f32`, `f64`, `i64x2`, `f64x2`          |
 | PowerPC      | `cr`                            | N/A            | Only clobbers                           |
+| PowerPC      | `ctr`                           | N/A            | Only clobbers                           |
+| PowerPC      | `lr`                            | N/A            | Only clobbers                           |
 | PowerPC      | `xer`                           | N/A            | Only clobbers                           |
 | wasm32       | `local`                         | None           | `i8` `i16` `i32` `i64` `f32` `f64`      |
 | BPF          | `reg`                           | None           | `i8` `i16` `i32` `i64`                  |
@@ -150,8 +154,6 @@ This feature tracks `asm!` and `global_asm!` support for the following architect
 | MIPS         | `$ra`                                   | Return address cannot be used as inputs or outputs.                                                                                                                                 |
 | Hexagon      | `lr`                                    | This is the link register which cannot be used as an input or output.                                                                                                               |
 | PowerPC      | `r2`, `r13`                             | These are system reserved registers.                                                                                                                                                |
-| PowerPC      | `lr`                                    | The link register cannot be used as an input or output.                                                                                                                             |
-| PowerPC      | `ctr`                                   | The counter register cannot be used as an input or output.                                                                                                                          |
 | PowerPC      | `vrsave`                                | The vrsave register cannot be used as an input or output.                                                                                                                           |
 | AVR          | `r0`, `r1`, `r1r0`                      | Due to an issue in LLVM, the `r0` and `r1` registers cannot be used as inputs or outputs.  If modified, they must be restored to their original values before the end of the block. |
 |MSP430        | `r0`, `r2`, `r3`                        | These are the program counter, status register, and constant generator respectively. Neither the status register nor constant generator can be written to.                          |
diff --git a/tests/codegen-llvm/asm/powerpc-clobbers.rs b/tests/codegen-llvm/asm/powerpc-clobbers.rs
index f7fc7eea5d506..10d7ae4dba40b 100644
--- a/tests/codegen-llvm/asm/powerpc-clobbers.rs
+++ b/tests/codegen-llvm/asm/powerpc-clobbers.rs
@@ -58,10 +58,10 @@ pub unsafe fn v0_clobber() {
 
 // Output format depends on the availability of altivec.
 // CHECK-LABEL: @clobber_abi
-// powerpc: asm sideeffect "", "={r0},={r3},={r4},={r5},={r6},={r7},={r8},={r9},={r10},={r11},={r12},={f0},={f1},={f2},={f3},={f4},={f5},={f6},={f7},={f8},={f9},={f10},={f11},={f12},={f13},~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{cr0},~{cr1},~{cr5},~{cr6},~{cr7},~{xer}"()
-// powerpc64: asm sideeffect "", "={r0},={r3},={r4},={r5},={r6},={r7},={r8},={r9},={r10},={r11},={r12},={f0},={f1},={f2},={f3},={f4},={f5},={f6},={f7},={f8},={f9},={f10},={f11},={f12},={f13},={v0},={v1},={v2},={v3},={v4},={v5},={v6},={v7},={v8},={v9},={v10},={v11},={v12},={v13},={v14},={v15},={v16},={v17},={v18},={v19},~{cr0},~{cr1},~{cr5},~{cr6},~{cr7},~{xer}"()
-// powerpc64le: asm sideeffect "", "={r0},={r3},={r4},={r5},={r6},={r7},={r8},={r9},={r10},={r11},={r12},={f0},={f1},={f2},={f3},={f4},={f5},={f6},={f7},={f8},={f9},={f10},={f11},={f12},={f13},={v0},={v1},={v2},={v3},={v4},={v5},={v6},={v7},={v8},={v9},={v10},={v11},={v12},={v13},={v14},={v15},={v16},={v17},={v18},={v19},~{cr0},~{cr1},~{cr5},~{cr6},~{cr7},~{xer}"()
-// aix64: asm sideeffect "", "={r0},={r3},={r4},={r5},={r6},={r7},={r8},={r9},={r10},={r11},={r12},={f0},={f1},={f2},={f3},={f4},={f5},={f6},={f7},={f8},={f9},={f10},={f11},={f12},={f13},={v0},={v1},={v2},={v3},={v4},={v5},={v6},={v7},={v8},={v9},={v10},={v11},={v12},={v13},={v14},={v15},={v16},={v17},={v18},={v19},~{cr0},~{cr1},~{cr5},~{cr6},~{cr7},~{xer}"()
+// powerpc: asm sideeffect "", "={r0},={r3},={r4},={r5},={r6},={r7},={r8},={r9},={r10},={r11},={r12},={f0},={f1},={f2},={f3},={f4},={f5},={f6},={f7},={f8},={f9},={f10},={f11},={f12},={f13},~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{cr0},~{cr1},~{cr5},~{cr6},~{cr7},~{ctr},~{lr},~{xer}"()
+// powerpc64: asm sideeffect "", "={r0},={r3},={r4},={r5},={r6},={r7},={r8},={r9},={r10},={r11},={r12},={f0},={f1},={f2},={f3},={f4},={f5},={f6},={f7},={f8},={f9},={f10},={f11},={f12},={f13},={v0},={v1},={v2},={v3},={v4},={v5},={v6},={v7},={v8},={v9},={v10},={v11},={v12},={v13},={v14},={v15},={v16},={v17},={v18},={v19},~{cr0},~{cr1},~{cr5},~{cr6},~{cr7},~{ctr},~{lr},~{xer}"()
+// powerpc64le: asm sideeffect "", "={r0},={r3},={r4},={r5},={r6},={r7},={r8},={r9},={r10},={r11},={r12},={f0},={f1},={f2},={f3},={f4},={f5},={f6},={f7},={f8},={f9},={f10},={f11},={f12},={f13},={v0},={v1},={v2},={v3},={v4},={v5},={v6},={v7},={v8},={v9},={v10},={v11},={v12},={v13},={v14},={v15},={v16},={v17},={v18},={v19},~{cr0},~{cr1},~{cr5},~{cr6},~{cr7},~{ctr},~{lr},~{xer}"()
+// aix64: asm sideeffect "", "={r0},={r3},={r4},={r5},={r6},={r7},={r8},={r9},={r10},={r11},={r12},={f0},={f1},={f2},={f3},={f4},={f5},={f6},={f7},={f8},={f9},={f10},={f11},={f12},={f13},={v0},={v1},={v2},={v3},={v4},={v5},={v6},={v7},={v8},={v9},={v10},={v11},={v12},={v13},={v14},={v15},={v16},={v17},={v18},={v19},~{cr0},~{cr1},~{cr5},~{cr6},~{cr7},~{ctr},~{lr},~{xer}"()
 #[no_mangle]
 pub unsafe fn clobber_abi() {
     asm!("", clobber_abi("C"), options(nostack, nomem, preserves_flags));
diff --git a/tests/ui/asm/powerpc/bad-reg.aix64.stderr b/tests/ui/asm/powerpc/bad-reg.aix64.stderr
index 124013f89afa9..82faba8d167fa 100644
--- a/tests/ui/asm/powerpc/bad-reg.aix64.stderr
+++ b/tests/ui/asm/powerpc/bad-reg.aix64.stderr
@@ -28,74 +28,110 @@ error: invalid register `fp`: the frame pointer cannot be used as an operand for
 LL |         asm!("", out("fp") _);
    |                  ^^^^^^^^^^^
 
-error: invalid register `lr`: the link register cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:48:18
-   |
-LL |         asm!("", out("lr") _);
-   |                  ^^^^^^^^^^^
-
-error: invalid register `ctr`: the counter register cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:50:18
-   |
-LL |         asm!("", out("ctr") _);
-   |                  ^^^^^^^^^^^^
-
 error: invalid register `vrsave`: the vrsave register cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:52:18
+  --> $DIR/bad-reg.rs:48:18
    |
 LL |         asm!("", out("vrsave") _);
    |                  ^^^^^^^^^^^^^^^
 
 error: register class `cr` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:100:18
+  --> $DIR/bad-reg.rs:96:18
    |
 LL |         asm!("", in("cr") x);
    |                  ^^^^^^^^^^
 
 error: register class `cr` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:103:18
+  --> $DIR/bad-reg.rs:99:18
    |
 LL |         asm!("", out("cr") x);
    |                  ^^^^^^^^^^^
 
 error: register class `cr` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:106:26
+  --> $DIR/bad-reg.rs:102:26
    |
 LL |         asm!("/* {} */", in(cr) x);
    |                          ^^^^^^^^
 
 error: register class `cr` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:109:26
+  --> $DIR/bad-reg.rs:105:26
    |
 LL |         asm!("/* {} */", out(cr) _);
    |                          ^^^^^^^^^
 
+error: register class `ctr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:109:18
+   |
+LL |         asm!("", in("ctr") x);
+   |                  ^^^^^^^^^^^
+
+error: register class `ctr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:112:18
+   |
+LL |         asm!("", out("ctr") x);
+   |                  ^^^^^^^^^^^^
+
+error: register class `ctr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:115:26
+   |
+LL |         asm!("/* {} */", in(ctr) x);
+   |                          ^^^^^^^^^
+
+error: register class `ctr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:118:26
+   |
+LL |         asm!("/* {} */", out(ctr) _);
+   |                          ^^^^^^^^^^
+
+error: register class `lr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:122:18
+   |
+LL |         asm!("", in("lr") x);
+   |                  ^^^^^^^^^^
+
+error: register class `lr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:125:18
+   |
+LL |         asm!("", out("lr") x);
+   |                  ^^^^^^^^^^^
+
+error: register class `lr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:128:26
+   |
+LL |         asm!("/* {} */", in(lr) x);
+   |                          ^^^^^^^^
+
+error: register class `lr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:131:26
+   |
+LL |         asm!("/* {} */", out(lr) _);
+   |                          ^^^^^^^^^
+
 error: register class `xer` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:113:18
+  --> $DIR/bad-reg.rs:135:18
    |
 LL |         asm!("", in("xer") x);
    |                  ^^^^^^^^^^^
 
 error: register class `xer` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:116:18
+  --> $DIR/bad-reg.rs:138:18
    |
 LL |         asm!("", out("xer") x);
    |                  ^^^^^^^^^^^^
 
 error: register class `xer` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:119:26
+  --> $DIR/bad-reg.rs:141:26
    |
 LL |         asm!("/* {} */", in(xer) x);
    |                          ^^^^^^^^^
 
 error: register class `xer` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:122:26
+  --> $DIR/bad-reg.rs:144:26
    |
 LL |         asm!("/* {} */", out(xer) _);
    |                          ^^^^^^^^^^
 
 error: register `cr0` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:126:31
+  --> $DIR/bad-reg.rs:148:31
    |
 LL |         asm!("", out("cr") _, out("cr0") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr0`
@@ -103,7 +139,7 @@ LL |         asm!("", out("cr") _, out("cr0") _);
    |                  register `cr`
 
 error: register `cr1` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:128:31
+  --> $DIR/bad-reg.rs:150:31
    |
 LL |         asm!("", out("cr") _, out("cr1") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr1`
@@ -111,7 +147,7 @@ LL |         asm!("", out("cr") _, out("cr1") _);
    |                  register `cr`
 
 error: register `cr2` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:130:31
+  --> $DIR/bad-reg.rs:152:31
    |
 LL |         asm!("", out("cr") _, out("cr2") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr2`
@@ -119,7 +155,7 @@ LL |         asm!("", out("cr") _, out("cr2") _);
    |                  register `cr`
 
 error: register `cr3` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:132:31
+  --> $DIR/bad-reg.rs:154:31
    |
 LL |         asm!("", out("cr") _, out("cr3") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr3`
@@ -127,7 +163,7 @@ LL |         asm!("", out("cr") _, out("cr3") _);
    |                  register `cr`
 
 error: register `cr4` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:134:31
+  --> $DIR/bad-reg.rs:156:31
    |
 LL |         asm!("", out("cr") _, out("cr4") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr4`
@@ -135,7 +171,7 @@ LL |         asm!("", out("cr") _, out("cr4") _);
    |                  register `cr`
 
 error: register `cr5` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:136:31
+  --> $DIR/bad-reg.rs:158:31
    |
 LL |         asm!("", out("cr") _, out("cr5") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr5`
@@ -143,7 +179,7 @@ LL |         asm!("", out("cr") _, out("cr5") _);
    |                  register `cr`
 
 error: register `cr6` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:138:31
+  --> $DIR/bad-reg.rs:160:31
    |
 LL |         asm!("", out("cr") _, out("cr6") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr6`
@@ -151,7 +187,7 @@ LL |         asm!("", out("cr") _, out("cr6") _);
    |                  register `cr`
 
 error: register `cr7` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:140:31
+  --> $DIR/bad-reg.rs:162:31
    |
 LL |         asm!("", out("cr") _, out("cr7") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr7`
@@ -165,7 +201,7 @@ LL |         asm!("", out("r13") _);
    |                  ^^^^^^^^^^^^
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:67:27
+  --> $DIR/bad-reg.rs:63:27
    |
 LL |         asm!("", in("v0") x); // FIXME: should be ok if vsx is available
    |                           ^
@@ -173,7 +209,7 @@ LL |         asm!("", in("v0") x); // FIXME: should be ok if vsx is available
    = note: register class `vreg` supports these types: i8x16, i16x8, i32x4, f32x4, f32, f64, i64x2, f64x2
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:70:28
+  --> $DIR/bad-reg.rs:66:28
    |
 LL |         asm!("", out("v0") x); // FIXME: should be ok if vsx is available
    |                            ^
@@ -181,7 +217,7 @@ LL |         asm!("", out("v0") x); // FIXME: should be ok if vsx is available
    = note: register class `vreg` supports these types: i8x16, i16x8, i32x4, f32x4, f32, f64, i64x2, f64x2
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:78:35
+  --> $DIR/bad-reg.rs:74:35
    |
 LL |         asm!("/* {} */", in(vreg) x); // FIXME: should be ok if vsx is available
    |                                   ^
@@ -189,7 +225,7 @@ LL |         asm!("/* {} */", in(vreg) x); // FIXME: should be ok if vsx is avai
    = note: register class `vreg` supports these types: i8x16, i16x8, i32x4, f32x4, f32, f64, i64x2, f64x2
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:100:27
+  --> $DIR/bad-reg.rs:96:27
    |
 LL |         asm!("", in("cr") x);
    |                           ^
@@ -197,7 +233,7 @@ LL |         asm!("", in("cr") x);
    = note: register class `cr` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:103:28
+  --> $DIR/bad-reg.rs:99:28
    |
 LL |         asm!("", out("cr") x);
    |                            ^
@@ -205,7 +241,7 @@ LL |         asm!("", out("cr") x);
    = note: register class `cr` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:106:33
+  --> $DIR/bad-reg.rs:102:33
    |
 LL |         asm!("/* {} */", in(cr) x);
    |                                 ^
@@ -213,7 +249,55 @@ LL |         asm!("/* {} */", in(cr) x);
    = note: register class `cr` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:113:28
+  --> $DIR/bad-reg.rs:109:28
+   |
+LL |         asm!("", in("ctr") x);
+   |                            ^
+   |
+   = note: register class `ctr` supports these types: 
+
+error: type `i32` cannot be used with this register class
+  --> $DIR/bad-reg.rs:112:29
+   |
+LL |         asm!("", out("ctr") x);
+   |                             ^
+   |
+   = note: register class `ctr` supports these types: 
+
+error: type `i32` cannot be used with this register class
+  --> $DIR/bad-reg.rs:115:34
+   |
+LL |         asm!("/* {} */", in(ctr) x);
+   |                                  ^
+   |
+   = note: register class `ctr` supports these types: 
+
+error: type `i32` cannot be used with this register class
+  --> $DIR/bad-reg.rs:122:27
+   |
+LL |         asm!("", in("lr") x);
+   |                           ^
+   |
+   = note: register class `lr` supports these types: 
+
+error: type `i32` cannot be used with this register class
+  --> $DIR/bad-reg.rs:125:28
+   |
+LL |         asm!("", out("lr") x);
+   |                            ^
+   |
+   = note: register class `lr` supports these types: 
+
+error: type `i32` cannot be used with this register class
+  --> $DIR/bad-reg.rs:128:33
+   |
+LL |         asm!("/* {} */", in(lr) x);
+   |                                 ^
+   |
+   = note: register class `lr` supports these types: 
+
+error: type `i32` cannot be used with this register class
+  --> $DIR/bad-reg.rs:135:28
    |
 LL |         asm!("", in("xer") x);
    |                            ^
@@ -221,7 +305,7 @@ LL |         asm!("", in("xer") x);
    = note: register class `xer` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:116:29
+  --> $DIR/bad-reg.rs:138:29
    |
 LL |         asm!("", out("xer") x);
    |                             ^
@@ -229,12 +313,12 @@ LL |         asm!("", out("xer") x);
    = note: register class `xer` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:119:34
+  --> $DIR/bad-reg.rs:141:34
    |
 LL |         asm!("/* {} */", in(xer) x);
    |                                  ^
    |
    = note: register class `xer` supports these types: 
 
-error: aborting due to 34 previous errors
+error: aborting due to 46 previous errors
 
diff --git a/tests/ui/asm/powerpc/bad-reg.powerpc.stderr b/tests/ui/asm/powerpc/bad-reg.powerpc.stderr
index b11c946f80da5..fac70ea77cb3a 100644
--- a/tests/ui/asm/powerpc/bad-reg.powerpc.stderr
+++ b/tests/ui/asm/powerpc/bad-reg.powerpc.stderr
@@ -28,74 +28,110 @@ error: invalid register `fp`: the frame pointer cannot be used as an operand for
 LL |         asm!("", out("fp") _);
    |                  ^^^^^^^^^^^
 
-error: invalid register `lr`: the link register cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:48:18
-   |
-LL |         asm!("", out("lr") _);
-   |                  ^^^^^^^^^^^
-
-error: invalid register `ctr`: the counter register cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:50:18
-   |
-LL |         asm!("", out("ctr") _);
-   |                  ^^^^^^^^^^^^
-
 error: invalid register `vrsave`: the vrsave register cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:52:18
+  --> $DIR/bad-reg.rs:48:18
    |
 LL |         asm!("", out("vrsave") _);
    |                  ^^^^^^^^^^^^^^^
 
 error: register class `cr` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:100:18
+  --> $DIR/bad-reg.rs:96:18
    |
 LL |         asm!("", in("cr") x);
    |                  ^^^^^^^^^^
 
 error: register class `cr` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:103:18
+  --> $DIR/bad-reg.rs:99:18
    |
 LL |         asm!("", out("cr") x);
    |                  ^^^^^^^^^^^
 
 error: register class `cr` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:106:26
+  --> $DIR/bad-reg.rs:102:26
    |
 LL |         asm!("/* {} */", in(cr) x);
    |                          ^^^^^^^^
 
 error: register class `cr` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:109:26
+  --> $DIR/bad-reg.rs:105:26
    |
 LL |         asm!("/* {} */", out(cr) _);
    |                          ^^^^^^^^^
 
+error: register class `ctr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:109:18
+   |
+LL |         asm!("", in("ctr") x);
+   |                  ^^^^^^^^^^^
+
+error: register class `ctr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:112:18
+   |
+LL |         asm!("", out("ctr") x);
+   |                  ^^^^^^^^^^^^
+
+error: register class `ctr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:115:26
+   |
+LL |         asm!("/* {} */", in(ctr) x);
+   |                          ^^^^^^^^^
+
+error: register class `ctr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:118:26
+   |
+LL |         asm!("/* {} */", out(ctr) _);
+   |                          ^^^^^^^^^^
+
+error: register class `lr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:122:18
+   |
+LL |         asm!("", in("lr") x);
+   |                  ^^^^^^^^^^
+
+error: register class `lr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:125:18
+   |
+LL |         asm!("", out("lr") x);
+   |                  ^^^^^^^^^^^
+
+error: register class `lr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:128:26
+   |
+LL |         asm!("/* {} */", in(lr) x);
+   |                          ^^^^^^^^
+
+error: register class `lr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:131:26
+   |
+LL |         asm!("/* {} */", out(lr) _);
+   |                          ^^^^^^^^^
+
 error: register class `xer` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:113:18
+  --> $DIR/bad-reg.rs:135:18
    |
 LL |         asm!("", in("xer") x);
    |                  ^^^^^^^^^^^
 
 error: register class `xer` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:116:18
+  --> $DIR/bad-reg.rs:138:18
    |
 LL |         asm!("", out("xer") x);
    |                  ^^^^^^^^^^^^
 
 error: register class `xer` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:119:26
+  --> $DIR/bad-reg.rs:141:26
    |
 LL |         asm!("/* {} */", in(xer) x);
    |                          ^^^^^^^^^
 
 error: register class `xer` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:122:26
+  --> $DIR/bad-reg.rs:144:26
    |
 LL |         asm!("/* {} */", out(xer) _);
    |                          ^^^^^^^^^^
 
 error: register `cr0` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:126:31
+  --> $DIR/bad-reg.rs:148:31
    |
 LL |         asm!("", out("cr") _, out("cr0") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr0`
@@ -103,7 +139,7 @@ LL |         asm!("", out("cr") _, out("cr0") _);
    |                  register `cr`
 
 error: register `cr1` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:128:31
+  --> $DIR/bad-reg.rs:150:31
    |
 LL |         asm!("", out("cr") _, out("cr1") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr1`
@@ -111,7 +147,7 @@ LL |         asm!("", out("cr") _, out("cr1") _);
    |                  register `cr`
 
 error: register `cr2` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:130:31
+  --> $DIR/bad-reg.rs:152:31
    |
 LL |         asm!("", out("cr") _, out("cr2") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr2`
@@ -119,7 +155,7 @@ LL |         asm!("", out("cr") _, out("cr2") _);
    |                  register `cr`
 
 error: register `cr3` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:132:31
+  --> $DIR/bad-reg.rs:154:31
    |
 LL |         asm!("", out("cr") _, out("cr3") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr3`
@@ -127,7 +163,7 @@ LL |         asm!("", out("cr") _, out("cr3") _);
    |                  register `cr`
 
 error: register `cr4` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:134:31
+  --> $DIR/bad-reg.rs:156:31
    |
 LL |         asm!("", out("cr") _, out("cr4") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr4`
@@ -135,7 +171,7 @@ LL |         asm!("", out("cr") _, out("cr4") _);
    |                  register `cr`
 
 error: register `cr5` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:136:31
+  --> $DIR/bad-reg.rs:158:31
    |
 LL |         asm!("", out("cr") _, out("cr5") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr5`
@@ -143,7 +179,7 @@ LL |         asm!("", out("cr") _, out("cr5") _);
    |                  register `cr`
 
 error: register `cr6` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:138:31
+  --> $DIR/bad-reg.rs:160:31
    |
 LL |         asm!("", out("cr") _, out("cr6") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr6`
@@ -151,7 +187,7 @@ LL |         asm!("", out("cr") _, out("cr6") _);
    |                  register `cr`
 
 error: register `cr7` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:140:31
+  --> $DIR/bad-reg.rs:162:31
    |
 LL |         asm!("", out("cr") _, out("cr7") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr7`
@@ -165,67 +201,67 @@ LL |         asm!("", out("r13") _);
    |                  ^^^^^^^^^^^^
 
 error: register class `vreg` requires at least one of the following target features: altivec, vsx
-  --> $DIR/bad-reg.rs:57:18
+  --> $DIR/bad-reg.rs:53:18
    |
 LL |         asm!("", in("v0") v32x4); // requires altivec
    |                  ^^^^^^^^^^^^^^
 
 error: register class `vreg` requires at least one of the following target features: altivec, vsx
-  --> $DIR/bad-reg.rs:59:18
+  --> $DIR/bad-reg.rs:55:18
    |
 LL |         asm!("", out("v0") v32x4); // requires altivec
    |                  ^^^^^^^^^^^^^^^
 
 error: register class `vreg` requires at least one of the following target features: altivec, vsx
-  --> $DIR/bad-reg.rs:61:18
+  --> $DIR/bad-reg.rs:57:18
    |
 LL |         asm!("", in("v0") v64x2); // requires vsx
    |                  ^^^^^^^^^^^^^^
 
 error: register class `vreg` requires at least one of the following target features: altivec, vsx
-  --> $DIR/bad-reg.rs:64:18
+  --> $DIR/bad-reg.rs:60:18
    |
 LL |         asm!("", out("v0") v64x2); // requires vsx
    |                  ^^^^^^^^^^^^^^^
 
 error: register class `vreg` requires at least one of the following target features: altivec, vsx
-  --> $DIR/bad-reg.rs:67:18
+  --> $DIR/bad-reg.rs:63:18
    |
 LL |         asm!("", in("v0") x); // FIXME: should be ok if vsx is available
    |                  ^^^^^^^^^^
 
 error: register class `vreg` requires at least one of the following target features: altivec, vsx
-  --> $DIR/bad-reg.rs:70:18
+  --> $DIR/bad-reg.rs:66:18
    |
 LL |         asm!("", out("v0") x); // FIXME: should be ok if vsx is available
    |                  ^^^^^^^^^^^
 
 error: register class `vreg` requires at least one of the following target features: altivec, vsx
-  --> $DIR/bad-reg.rs:73:26
+  --> $DIR/bad-reg.rs:69:26
    |
 LL |         asm!("/* {} */", in(vreg) v32x4); // requires altivec
    |                          ^^^^^^^^^^^^^^
 
 error: register class `vreg` requires at least one of the following target features: altivec, vsx
-  --> $DIR/bad-reg.rs:75:26
+  --> $DIR/bad-reg.rs:71:26
    |
 LL |         asm!("/* {} */", in(vreg) v64x2); // requires vsx
    |                          ^^^^^^^^^^^^^^
 
 error: register class `vreg` requires at least one of the following target features: altivec, vsx
-  --> $DIR/bad-reg.rs:78:26
+  --> $DIR/bad-reg.rs:74:26
    |
 LL |         asm!("/* {} */", in(vreg) x); // FIXME: should be ok if vsx is available
    |                          ^^^^^^^^^^
 
 error: register class `vreg` requires at least one of the following target features: altivec, vsx
-  --> $DIR/bad-reg.rs:81:26
+  --> $DIR/bad-reg.rs:77:26
    |
 LL |         asm!("/* {} */", out(vreg) _); // requires altivec
    |                          ^^^^^^^^^^^
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:100:27
+  --> $DIR/bad-reg.rs:96:27
    |
 LL |         asm!("", in("cr") x);
    |                           ^
@@ -233,7 +269,7 @@ LL |         asm!("", in("cr") x);
    = note: register class `cr` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:103:28
+  --> $DIR/bad-reg.rs:99:28
    |
 LL |         asm!("", out("cr") x);
    |                            ^
@@ -241,7 +277,7 @@ LL |         asm!("", out("cr") x);
    = note: register class `cr` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:106:33
+  --> $DIR/bad-reg.rs:102:33
    |
 LL |         asm!("/* {} */", in(cr) x);
    |                                 ^
@@ -249,7 +285,55 @@ LL |         asm!("/* {} */", in(cr) x);
    = note: register class `cr` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:113:28
+  --> $DIR/bad-reg.rs:109:28
+   |
+LL |         asm!("", in("ctr") x);
+   |                            ^
+   |
+   = note: register class `ctr` supports these types: 
+
+error: type `i32` cannot be used with this register class
+  --> $DIR/bad-reg.rs:112:29
+   |
+LL |         asm!("", out("ctr") x);
+   |                             ^
+   |
+   = note: register class `ctr` supports these types: 
+
+error: type `i32` cannot be used with this register class
+  --> $DIR/bad-reg.rs:115:34
+   |
+LL |         asm!("/* {} */", in(ctr) x);
+   |                                  ^
+   |
+   = note: register class `ctr` supports these types: 
+
+error: type `i32` cannot be used with this register class
+  --> $DIR/bad-reg.rs:122:27
+   |
+LL |         asm!("", in("lr") x);
+   |                           ^
+   |
+   = note: register class `lr` supports these types: 
+
+error: type `i32` cannot be used with this register class
+  --> $DIR/bad-reg.rs:125:28
+   |
+LL |         asm!("", out("lr") x);
+   |                            ^
+   |
+   = note: register class `lr` supports these types: 
+
+error: type `i32` cannot be used with this register class
+  --> $DIR/bad-reg.rs:128:33
+   |
+LL |         asm!("/* {} */", in(lr) x);
+   |                                 ^
+   |
+   = note: register class `lr` supports these types: 
+
+error: type `i32` cannot be used with this register class
+  --> $DIR/bad-reg.rs:135:28
    |
 LL |         asm!("", in("xer") x);
    |                            ^
@@ -257,7 +341,7 @@ LL |         asm!("", in("xer") x);
    = note: register class `xer` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:116:29
+  --> $DIR/bad-reg.rs:138:29
    |
 LL |         asm!("", out("xer") x);
    |                             ^
@@ -265,12 +349,12 @@ LL |         asm!("", out("xer") x);
    = note: register class `xer` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:119:34
+  --> $DIR/bad-reg.rs:141:34
    |
 LL |         asm!("/* {} */", in(xer) x);
    |                                  ^
    |
    = note: register class `xer` supports these types: 
 
-error: aborting due to 41 previous errors
+error: aborting due to 53 previous errors
 
diff --git a/tests/ui/asm/powerpc/bad-reg.powerpc64.stderr b/tests/ui/asm/powerpc/bad-reg.powerpc64.stderr
index a93b2b018df0e..42a59448f425e 100644
--- a/tests/ui/asm/powerpc/bad-reg.powerpc64.stderr
+++ b/tests/ui/asm/powerpc/bad-reg.powerpc64.stderr
@@ -28,74 +28,110 @@ error: invalid register `fp`: the frame pointer cannot be used as an operand for
 LL |         asm!("", out("fp") _);
    |                  ^^^^^^^^^^^
 
-error: invalid register `lr`: the link register cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:48:18
-   |
-LL |         asm!("", out("lr") _);
-   |                  ^^^^^^^^^^^
-
-error: invalid register `ctr`: the counter register cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:50:18
-   |
-LL |         asm!("", out("ctr") _);
-   |                  ^^^^^^^^^^^^
-
 error: invalid register `vrsave`: the vrsave register cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:52:18
+  --> $DIR/bad-reg.rs:48:18
    |
 LL |         asm!("", out("vrsave") _);
    |                  ^^^^^^^^^^^^^^^
 
 error: register class `cr` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:100:18
+  --> $DIR/bad-reg.rs:96:18
    |
 LL |         asm!("", in("cr") x);
    |                  ^^^^^^^^^^
 
 error: register class `cr` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:103:18
+  --> $DIR/bad-reg.rs:99:18
    |
 LL |         asm!("", out("cr") x);
    |                  ^^^^^^^^^^^
 
 error: register class `cr` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:106:26
+  --> $DIR/bad-reg.rs:102:26
    |
 LL |         asm!("/* {} */", in(cr) x);
    |                          ^^^^^^^^
 
 error: register class `cr` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:109:26
+  --> $DIR/bad-reg.rs:105:26
    |
 LL |         asm!("/* {} */", out(cr) _);
    |                          ^^^^^^^^^
 
+error: register class `ctr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:109:18
+   |
+LL |         asm!("", in("ctr") x);
+   |                  ^^^^^^^^^^^
+
+error: register class `ctr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:112:18
+   |
+LL |         asm!("", out("ctr") x);
+   |                  ^^^^^^^^^^^^
+
+error: register class `ctr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:115:26
+   |
+LL |         asm!("/* {} */", in(ctr) x);
+   |                          ^^^^^^^^^
+
+error: register class `ctr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:118:26
+   |
+LL |         asm!("/* {} */", out(ctr) _);
+   |                          ^^^^^^^^^^
+
+error: register class `lr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:122:18
+   |
+LL |         asm!("", in("lr") x);
+   |                  ^^^^^^^^^^
+
+error: register class `lr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:125:18
+   |
+LL |         asm!("", out("lr") x);
+   |                  ^^^^^^^^^^^
+
+error: register class `lr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:128:26
+   |
+LL |         asm!("/* {} */", in(lr) x);
+   |                          ^^^^^^^^
+
+error: register class `lr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:131:26
+   |
+LL |         asm!("/* {} */", out(lr) _);
+   |                          ^^^^^^^^^
+
 error: register class `xer` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:113:18
+  --> $DIR/bad-reg.rs:135:18
    |
 LL |         asm!("", in("xer") x);
    |                  ^^^^^^^^^^^
 
 error: register class `xer` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:116:18
+  --> $DIR/bad-reg.rs:138:18
    |
 LL |         asm!("", out("xer") x);
    |                  ^^^^^^^^^^^^
 
 error: register class `xer` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:119:26
+  --> $DIR/bad-reg.rs:141:26
    |
 LL |         asm!("/* {} */", in(xer) x);
    |                          ^^^^^^^^^
 
 error: register class `xer` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:122:26
+  --> $DIR/bad-reg.rs:144:26
    |
 LL |         asm!("/* {} */", out(xer) _);
    |                          ^^^^^^^^^^
 
 error: register `cr0` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:126:31
+  --> $DIR/bad-reg.rs:148:31
    |
 LL |         asm!("", out("cr") _, out("cr0") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr0`
@@ -103,7 +139,7 @@ LL |         asm!("", out("cr") _, out("cr0") _);
    |                  register `cr`
 
 error: register `cr1` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:128:31
+  --> $DIR/bad-reg.rs:150:31
    |
 LL |         asm!("", out("cr") _, out("cr1") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr1`
@@ -111,7 +147,7 @@ LL |         asm!("", out("cr") _, out("cr1") _);
    |                  register `cr`
 
 error: register `cr2` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:130:31
+  --> $DIR/bad-reg.rs:152:31
    |
 LL |         asm!("", out("cr") _, out("cr2") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr2`
@@ -119,7 +155,7 @@ LL |         asm!("", out("cr") _, out("cr2") _);
    |                  register `cr`
 
 error: register `cr3` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:132:31
+  --> $DIR/bad-reg.rs:154:31
    |
 LL |         asm!("", out("cr") _, out("cr3") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr3`
@@ -127,7 +163,7 @@ LL |         asm!("", out("cr") _, out("cr3") _);
    |                  register `cr`
 
 error: register `cr4` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:134:31
+  --> $DIR/bad-reg.rs:156:31
    |
 LL |         asm!("", out("cr") _, out("cr4") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr4`
@@ -135,7 +171,7 @@ LL |         asm!("", out("cr") _, out("cr4") _);
    |                  register `cr`
 
 error: register `cr5` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:136:31
+  --> $DIR/bad-reg.rs:158:31
    |
 LL |         asm!("", out("cr") _, out("cr5") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr5`
@@ -143,7 +179,7 @@ LL |         asm!("", out("cr") _, out("cr5") _);
    |                  register `cr`
 
 error: register `cr6` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:138:31
+  --> $DIR/bad-reg.rs:160:31
    |
 LL |         asm!("", out("cr") _, out("cr6") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr6`
@@ -151,7 +187,7 @@ LL |         asm!("", out("cr") _, out("cr6") _);
    |                  register `cr`
 
 error: register `cr7` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:140:31
+  --> $DIR/bad-reg.rs:162:31
    |
 LL |         asm!("", out("cr") _, out("cr7") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr7`
@@ -165,7 +201,7 @@ LL |         asm!("", out("r13") _);
    |                  ^^^^^^^^^^^^
 
 error: `vsx` target feature is not enabled
-  --> $DIR/bad-reg.rs:61:27
+  --> $DIR/bad-reg.rs:57:27
    |
 LL |         asm!("", in("v0") v64x2); // requires vsx
    |                           ^^^^^
@@ -173,7 +209,7 @@ LL |         asm!("", in("v0") v64x2); // requires vsx
    = note: this is required to use type `i64x2` with register class `vreg`
 
 error: `vsx` target feature is not enabled
-  --> $DIR/bad-reg.rs:64:28
+  --> $DIR/bad-reg.rs:60:28
    |
 LL |         asm!("", out("v0") v64x2); // requires vsx
    |                            ^^^^^
@@ -181,7 +217,7 @@ LL |         asm!("", out("v0") v64x2); // requires vsx
    = note: this is required to use type `i64x2` with register class `vreg`
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:67:27
+  --> $DIR/bad-reg.rs:63:27
    |
 LL |         asm!("", in("v0") x); // FIXME: should be ok if vsx is available
    |                           ^
@@ -189,7 +225,7 @@ LL |         asm!("", in("v0") x); // FIXME: should be ok if vsx is available
    = note: register class `vreg` supports these types: i8x16, i16x8, i32x4, f32x4, f32, f64, i64x2, f64x2
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:70:28
+  --> $DIR/bad-reg.rs:66:28
    |
 LL |         asm!("", out("v0") x); // FIXME: should be ok if vsx is available
    |                            ^
@@ -197,7 +233,7 @@ LL |         asm!("", out("v0") x); // FIXME: should be ok if vsx is available
    = note: register class `vreg` supports these types: i8x16, i16x8, i32x4, f32x4, f32, f64, i64x2, f64x2
 
 error: `vsx` target feature is not enabled
-  --> $DIR/bad-reg.rs:75:35
+  --> $DIR/bad-reg.rs:71:35
    |
 LL |         asm!("/* {} */", in(vreg) v64x2); // requires vsx
    |                                   ^^^^^
@@ -205,7 +241,7 @@ LL |         asm!("/* {} */", in(vreg) v64x2); // requires vsx
    = note: this is required to use type `i64x2` with register class `vreg`
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:78:35
+  --> $DIR/bad-reg.rs:74:35
    |
 LL |         asm!("/* {} */", in(vreg) x); // FIXME: should be ok if vsx is available
    |                                   ^
@@ -213,7 +249,7 @@ LL |         asm!("/* {} */", in(vreg) x); // FIXME: should be ok if vsx is avai
    = note: register class `vreg` supports these types: i8x16, i16x8, i32x4, f32x4, f32, f64, i64x2, f64x2
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:100:27
+  --> $DIR/bad-reg.rs:96:27
    |
 LL |         asm!("", in("cr") x);
    |                           ^
@@ -221,7 +257,7 @@ LL |         asm!("", in("cr") x);
    = note: register class `cr` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:103:28
+  --> $DIR/bad-reg.rs:99:28
    |
 LL |         asm!("", out("cr") x);
    |                            ^
@@ -229,7 +265,7 @@ LL |         asm!("", out("cr") x);
    = note: register class `cr` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:106:33
+  --> $DIR/bad-reg.rs:102:33
    |
 LL |         asm!("/* {} */", in(cr) x);
    |                                 ^
@@ -237,7 +273,55 @@ LL |         asm!("/* {} */", in(cr) x);
    = note: register class `cr` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:113:28
+  --> $DIR/bad-reg.rs:109:28
+   |
+LL |         asm!("", in("ctr") x);
+   |                            ^
+   |
+   = note: register class `ctr` supports these types: 
+
+error: type `i32` cannot be used with this register class
+  --> $DIR/bad-reg.rs:112:29
+   |
+LL |         asm!("", out("ctr") x);
+   |                             ^
+   |
+   = note: register class `ctr` supports these types: 
+
+error: type `i32` cannot be used with this register class
+  --> $DIR/bad-reg.rs:115:34
+   |
+LL |         asm!("/* {} */", in(ctr) x);
+   |                                  ^
+   |
+   = note: register class `ctr` supports these types: 
+
+error: type `i32` cannot be used with this register class
+  --> $DIR/bad-reg.rs:122:27
+   |
+LL |         asm!("", in("lr") x);
+   |                           ^
+   |
+   = note: register class `lr` supports these types: 
+
+error: type `i32` cannot be used with this register class
+  --> $DIR/bad-reg.rs:125:28
+   |
+LL |         asm!("", out("lr") x);
+   |                            ^
+   |
+   = note: register class `lr` supports these types: 
+
+error: type `i32` cannot be used with this register class
+  --> $DIR/bad-reg.rs:128:33
+   |
+LL |         asm!("/* {} */", in(lr) x);
+   |                                 ^
+   |
+   = note: register class `lr` supports these types: 
+
+error: type `i32` cannot be used with this register class
+  --> $DIR/bad-reg.rs:135:28
    |
 LL |         asm!("", in("xer") x);
    |                            ^
@@ -245,7 +329,7 @@ LL |         asm!("", in("xer") x);
    = note: register class `xer` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:116:29
+  --> $DIR/bad-reg.rs:138:29
    |
 LL |         asm!("", out("xer") x);
    |                             ^
@@ -253,12 +337,12 @@ LL |         asm!("", out("xer") x);
    = note: register class `xer` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:119:34
+  --> $DIR/bad-reg.rs:141:34
    |
 LL |         asm!("/* {} */", in(xer) x);
    |                                  ^
    |
    = note: register class `xer` supports these types: 
 
-error: aborting due to 37 previous errors
+error: aborting due to 49 previous errors
 
diff --git a/tests/ui/asm/powerpc/bad-reg.powerpc64le.stderr b/tests/ui/asm/powerpc/bad-reg.powerpc64le.stderr
index 124013f89afa9..82faba8d167fa 100644
--- a/tests/ui/asm/powerpc/bad-reg.powerpc64le.stderr
+++ b/tests/ui/asm/powerpc/bad-reg.powerpc64le.stderr
@@ -28,74 +28,110 @@ error: invalid register `fp`: the frame pointer cannot be used as an operand for
 LL |         asm!("", out("fp") _);
    |                  ^^^^^^^^^^^
 
-error: invalid register `lr`: the link register cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:48:18
-   |
-LL |         asm!("", out("lr") _);
-   |                  ^^^^^^^^^^^
-
-error: invalid register `ctr`: the counter register cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:50:18
-   |
-LL |         asm!("", out("ctr") _);
-   |                  ^^^^^^^^^^^^
-
 error: invalid register `vrsave`: the vrsave register cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:52:18
+  --> $DIR/bad-reg.rs:48:18
    |
 LL |         asm!("", out("vrsave") _);
    |                  ^^^^^^^^^^^^^^^
 
 error: register class `cr` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:100:18
+  --> $DIR/bad-reg.rs:96:18
    |
 LL |         asm!("", in("cr") x);
    |                  ^^^^^^^^^^
 
 error: register class `cr` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:103:18
+  --> $DIR/bad-reg.rs:99:18
    |
 LL |         asm!("", out("cr") x);
    |                  ^^^^^^^^^^^
 
 error: register class `cr` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:106:26
+  --> $DIR/bad-reg.rs:102:26
    |
 LL |         asm!("/* {} */", in(cr) x);
    |                          ^^^^^^^^
 
 error: register class `cr` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:109:26
+  --> $DIR/bad-reg.rs:105:26
    |
 LL |         asm!("/* {} */", out(cr) _);
    |                          ^^^^^^^^^
 
+error: register class `ctr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:109:18
+   |
+LL |         asm!("", in("ctr") x);
+   |                  ^^^^^^^^^^^
+
+error: register class `ctr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:112:18
+   |
+LL |         asm!("", out("ctr") x);
+   |                  ^^^^^^^^^^^^
+
+error: register class `ctr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:115:26
+   |
+LL |         asm!("/* {} */", in(ctr) x);
+   |                          ^^^^^^^^^
+
+error: register class `ctr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:118:26
+   |
+LL |         asm!("/* {} */", out(ctr) _);
+   |                          ^^^^^^^^^^
+
+error: register class `lr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:122:18
+   |
+LL |         asm!("", in("lr") x);
+   |                  ^^^^^^^^^^
+
+error: register class `lr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:125:18
+   |
+LL |         asm!("", out("lr") x);
+   |                  ^^^^^^^^^^^
+
+error: register class `lr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:128:26
+   |
+LL |         asm!("/* {} */", in(lr) x);
+   |                          ^^^^^^^^
+
+error: register class `lr` can only be used as a clobber, not as an input or output
+  --> $DIR/bad-reg.rs:131:26
+   |
+LL |         asm!("/* {} */", out(lr) _);
+   |                          ^^^^^^^^^
+
 error: register class `xer` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:113:18
+  --> $DIR/bad-reg.rs:135:18
    |
 LL |         asm!("", in("xer") x);
    |                  ^^^^^^^^^^^
 
 error: register class `xer` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:116:18
+  --> $DIR/bad-reg.rs:138:18
    |
 LL |         asm!("", out("xer") x);
    |                  ^^^^^^^^^^^^
 
 error: register class `xer` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:119:26
+  --> $DIR/bad-reg.rs:141:26
    |
 LL |         asm!("/* {} */", in(xer) x);
    |                          ^^^^^^^^^
 
 error: register class `xer` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:122:26
+  --> $DIR/bad-reg.rs:144:26
    |
 LL |         asm!("/* {} */", out(xer) _);
    |                          ^^^^^^^^^^
 
 error: register `cr0` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:126:31
+  --> $DIR/bad-reg.rs:148:31
    |
 LL |         asm!("", out("cr") _, out("cr0") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr0`
@@ -103,7 +139,7 @@ LL |         asm!("", out("cr") _, out("cr0") _);
    |                  register `cr`
 
 error: register `cr1` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:128:31
+  --> $DIR/bad-reg.rs:150:31
    |
 LL |         asm!("", out("cr") _, out("cr1") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr1`
@@ -111,7 +147,7 @@ LL |         asm!("", out("cr") _, out("cr1") _);
    |                  register `cr`
 
 error: register `cr2` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:130:31
+  --> $DIR/bad-reg.rs:152:31
    |
 LL |         asm!("", out("cr") _, out("cr2") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr2`
@@ -119,7 +155,7 @@ LL |         asm!("", out("cr") _, out("cr2") _);
    |                  register `cr`
 
 error: register `cr3` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:132:31
+  --> $DIR/bad-reg.rs:154:31
    |
 LL |         asm!("", out("cr") _, out("cr3") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr3`
@@ -127,7 +163,7 @@ LL |         asm!("", out("cr") _, out("cr3") _);
    |                  register `cr`
 
 error: register `cr4` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:134:31
+  --> $DIR/bad-reg.rs:156:31
    |
 LL |         asm!("", out("cr") _, out("cr4") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr4`
@@ -135,7 +171,7 @@ LL |         asm!("", out("cr") _, out("cr4") _);
    |                  register `cr`
 
 error: register `cr5` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:136:31
+  --> $DIR/bad-reg.rs:158:31
    |
 LL |         asm!("", out("cr") _, out("cr5") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr5`
@@ -143,7 +179,7 @@ LL |         asm!("", out("cr") _, out("cr5") _);
    |                  register `cr`
 
 error: register `cr6` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:138:31
+  --> $DIR/bad-reg.rs:160:31
    |
 LL |         asm!("", out("cr") _, out("cr6") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr6`
@@ -151,7 +187,7 @@ LL |         asm!("", out("cr") _, out("cr6") _);
    |                  register `cr`
 
 error: register `cr7` conflicts with register `cr`
-  --> $DIR/bad-reg.rs:140:31
+  --> $DIR/bad-reg.rs:162:31
    |
 LL |         asm!("", out("cr") _, out("cr7") _);
    |                  -----------  ^^^^^^^^^^^^ register `cr7`
@@ -165,7 +201,7 @@ LL |         asm!("", out("r13") _);
    |                  ^^^^^^^^^^^^
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:67:27
+  --> $DIR/bad-reg.rs:63:27
    |
 LL |         asm!("", in("v0") x); // FIXME: should be ok if vsx is available
    |                           ^
@@ -173,7 +209,7 @@ LL |         asm!("", in("v0") x); // FIXME: should be ok if vsx is available
    = note: register class `vreg` supports these types: i8x16, i16x8, i32x4, f32x4, f32, f64, i64x2, f64x2
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:70:28
+  --> $DIR/bad-reg.rs:66:28
    |
 LL |         asm!("", out("v0") x); // FIXME: should be ok if vsx is available
    |                            ^
@@ -181,7 +217,7 @@ LL |         asm!("", out("v0") x); // FIXME: should be ok if vsx is available
    = note: register class `vreg` supports these types: i8x16, i16x8, i32x4, f32x4, f32, f64, i64x2, f64x2
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:78:35
+  --> $DIR/bad-reg.rs:74:35
    |
 LL |         asm!("/* {} */", in(vreg) x); // FIXME: should be ok if vsx is available
    |                                   ^
@@ -189,7 +225,7 @@ LL |         asm!("/* {} */", in(vreg) x); // FIXME: should be ok if vsx is avai
    = note: register class `vreg` supports these types: i8x16, i16x8, i32x4, f32x4, f32, f64, i64x2, f64x2
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:100:27
+  --> $DIR/bad-reg.rs:96:27
    |
 LL |         asm!("", in("cr") x);
    |                           ^
@@ -197,7 +233,7 @@ LL |         asm!("", in("cr") x);
    = note: register class `cr` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:103:28
+  --> $DIR/bad-reg.rs:99:28
    |
 LL |         asm!("", out("cr") x);
    |                            ^
@@ -205,7 +241,7 @@ LL |         asm!("", out("cr") x);
    = note: register class `cr` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:106:33
+  --> $DIR/bad-reg.rs:102:33
    |
 LL |         asm!("/* {} */", in(cr) x);
    |                                 ^
@@ -213,7 +249,55 @@ LL |         asm!("/* {} */", in(cr) x);
    = note: register class `cr` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:113:28
+  --> $DIR/bad-reg.rs:109:28
+   |
+LL |         asm!("", in("ctr") x);
+   |                            ^
+   |
+   = note: register class `ctr` supports these types: 
+
+error: type `i32` cannot be used with this register class
+  --> $DIR/bad-reg.rs:112:29
+   |
+LL |         asm!("", out("ctr") x);
+   |                             ^
+   |
+   = note: register class `ctr` supports these types: 
+
+error: type `i32` cannot be used with this register class
+  --> $DIR/bad-reg.rs:115:34
+   |
+LL |         asm!("/* {} */", in(ctr) x);
+   |                                  ^
+   |
+   = note: register class `ctr` supports these types: 
+
+error: type `i32` cannot be used with this register class
+  --> $DIR/bad-reg.rs:122:27
+   |
+LL |         asm!("", in("lr") x);
+   |                           ^
+   |
+   = note: register class `lr` supports these types: 
+
+error: type `i32` cannot be used with this register class
+  --> $DIR/bad-reg.rs:125:28
+   |
+LL |         asm!("", out("lr") x);
+   |                            ^
+   |
+   = note: register class `lr` supports these types: 
+
+error: type `i32` cannot be used with this register class
+  --> $DIR/bad-reg.rs:128:33
+   |
+LL |         asm!("/* {} */", in(lr) x);
+   |                                 ^
+   |
+   = note: register class `lr` supports these types: 
+
+error: type `i32` cannot be used with this register class
+  --> $DIR/bad-reg.rs:135:28
    |
 LL |         asm!("", in("xer") x);
    |                            ^
@@ -221,7 +305,7 @@ LL |         asm!("", in("xer") x);
    = note: register class `xer` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:116:29
+  --> $DIR/bad-reg.rs:138:29
    |
 LL |         asm!("", out("xer") x);
    |                             ^
@@ -229,12 +313,12 @@ LL |         asm!("", out("xer") x);
    = note: register class `xer` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:119:34
+  --> $DIR/bad-reg.rs:141:34
    |
 LL |         asm!("/* {} */", in(xer) x);
    |                                  ^
    |
    = note: register class `xer` supports these types: 
 
-error: aborting due to 34 previous errors
+error: aborting due to 46 previous errors
 
diff --git a/tests/ui/asm/powerpc/bad-reg.rs b/tests/ui/asm/powerpc/bad-reg.rs
index 5598f8379603d..21ea451934ed4 100644
--- a/tests/ui/asm/powerpc/bad-reg.rs
+++ b/tests/ui/asm/powerpc/bad-reg.rs
@@ -45,10 +45,6 @@ fn f() {
         //~^ ERROR invalid register `r30`: r30 is used internally by LLVM and cannot be used as an operand for inline asm
         asm!("", out("fp") _);
         //~^ ERROR invalid register `fp`: the frame pointer cannot be used as an operand for inline asm
-        asm!("", out("lr") _);
-        //~^ ERROR invalid register `lr`: the link register cannot be used as an operand for inline asm
-        asm!("", out("ctr") _);
-        //~^ ERROR invalid register `ctr`: the counter register cannot be used as an operand for inline asm
         asm!("", out("vrsave") _);
         //~^ ERROR invalid register `vrsave`: the vrsave register cannot be used as an operand for inline asm
 
@@ -108,6 +104,32 @@ fn f() {
         //~| ERROR type `i32` cannot be used with this register class
         asm!("/* {} */", out(cr) _);
         //~^ ERROR can only be used as a clobber
+        // ctr
+        asm!("", out("ctr") _); // ok
+        asm!("", in("ctr") x);
+        //~^ ERROR can only be used as a clobber
+        //~| ERROR type `i32` cannot be used with this register class
+        asm!("", out("ctr") x);
+        //~^ ERROR can only be used as a clobber
+        //~| ERROR type `i32` cannot be used with this register class
+        asm!("/* {} */", in(ctr) x);
+        //~^ ERROR can only be used as a clobber
+        //~| ERROR type `i32` cannot be used with this register class
+        asm!("/* {} */", out(ctr) _);
+        //~^ ERROR can only be used as a clobber
+        // lr
+        asm!("", out("lr") _); // ok
+        asm!("", in("lr") x);
+        //~^ ERROR can only be used as a clobber
+        //~| ERROR type `i32` cannot be used with this register class
+        asm!("", out("lr") x);
+        //~^ ERROR can only be used as a clobber
+        //~| ERROR type `i32` cannot be used with this register class
+        asm!("/* {} */", in(lr) x);
+        //~^ ERROR can only be used as a clobber
+        //~| ERROR type `i32` cannot be used with this register class
+        asm!("/* {} */", out(lr) _);
+        //~^ ERROR can only be used as a clobber
         // xer
         asm!("", out("xer") _); // ok
         asm!("", in("xer") x);

From 77f44f2f0760867aef315fb8429fa1c495622fb7 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sun, 21 Sep 2025 11:05:22 +0200
Subject: [PATCH 1195/1889] `default_constructed_unit_structs`: use
 `check_source_text`

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

diff --git a/clippy_lints/src/default_constructed_unit_structs.rs b/clippy_lints/src/default_constructed_unit_structs.rs
index f8a9037fc8047..641f8ae03b72a 100644
--- a/clippy_lints/src/default_constructed_unit_structs.rs
+++ b/clippy_lints/src/default_constructed_unit_structs.rs
@@ -75,7 +75,7 @@ impl LateLintPass<'_> for DefaultConstructedUnitStructs {
             && !base.is_suggestable_infer_ty()
         {
             let mut removals = vec![(expr.span.with_lo(qpath.qself_span().hi()), String::new())];
-            if expr.span.with_source_text(cx, |s| s.starts_with('<')) == Some(true) {
+            if expr.span.check_source_text(cx, |s| s.starts_with('<')) {
                 // Remove `<`, '>` has already been removed by the existing removal expression.
                 removals.push((expr.span.with_hi(qpath.qself_span().lo()), String::new()));
             }

From f76664ca83b816c08370e806b61f5230fd980d18 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sun, 21 Sep 2025 08:57:36 +0200
Subject: [PATCH 1196/1889] clean-up `match_same_arms` a bit

---
 clippy_lints/src/matches/match_same_arms.rs | 54 ++++++++-------------
 1 file changed, 20 insertions(+), 34 deletions(-)

diff --git a/clippy_lints/src/matches/match_same_arms.rs b/clippy_lints/src/matches/match_same_arms.rs
index ae277da089fd2..818e504245549 100644
--- a/clippy_lints/src/matches/match_same_arms.rs
+++ b/clippy_lints/src/matches/match_same_arms.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::SpanRangeExt;
-use clippy_utils::{SpanlessEq, SpanlessHash, fulfill_or_allowed, is_lint_allowed, path_to_local, search_same};
+use clippy_utils::{SpanlessEq, fulfill_or_allowed, hash_expr, is_lint_allowed, path_to_local, search_same};
 use core::cmp::Ordering;
 use core::{iter, slice};
 use itertools::Itertools;
@@ -18,11 +18,7 @@ use super::MATCH_SAME_ARMS;
 
 #[expect(clippy::too_many_lines)]
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
-    let hash = |&(_, arm): &(usize, &Arm<'_>)| -> u64 {
-        let mut h = SpanlessHash::new(cx);
-        h.hash_expr(arm.body);
-        h.finish()
-    };
+    let hash = |&(_, arm): &(_, &Arm<'_>)| hash_expr(cx, arm.body);
 
     let arena = DroplessArena::default();
     let normalized_pats: Vec<_> = arms
@@ -35,9 +31,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
         .iter()
         .enumerate()
         .map(|(i, pat)| {
-            normalized_pats[i + 1..]
-                .iter()
-                .enumerate()
+            (normalized_pats[i + 1..].iter().enumerate())
                 .find_map(|(j, other)| pat.has_overlapping_values(other).then_some(i + 1 + j))
                 .unwrap_or(normalized_pats.len())
         })
@@ -48,16 +42,15 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
         .iter()
         .enumerate()
         .map(|(i, pat)| {
-            normalized_pats[..i]
-                .iter()
-                .enumerate()
-                .rev()
-                .zip(forwards_blocking_idxs[..i].iter().copied().rev())
-                .skip_while(|&(_, forward_block)| forward_block > i)
-                .find_map(|((j, other), forward_block)| {
-                    (forward_block == i || pat.has_overlapping_values(other)).then_some(j)
-                })
-                .unwrap_or(0)
+            iter::zip(
+                normalized_pats[..i].iter().enumerate().rev(),
+                forwards_blocking_idxs[..i].iter().copied().rev(),
+            )
+            .skip_while(|&(_, forward_block)| forward_block > i)
+            .find_map(|((j, other), forward_block)| {
+                (forward_block == i || pat.has_overlapping_values(other)).then_some(j)
+            })
+            .unwrap_or(0)
         })
         .collect();
 
@@ -158,12 +151,12 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
                             .map(|(_, arm)| arm.pat.span.get_source_text(cx))
                             .collect::<Option<Vec<_>>>()
                     {
-                        let mut suggs = src
+                        let suggs = src
                             .iter()
                             .map(|(_, arm)| (adjusted_arm_span(cx, arm.span), String::new()))
+                            .chain([(dest.pat.span, pat_snippets.iter().join(" | "))])
                             .collect_vec();
 
-                        suggs.push((dest.pat.span, pat_snippets.iter().join(" | ")));
                         diag.multipart_suggestion_verbose(
                             "otherwise merge the patterns into a single arm",
                             suggs,
@@ -396,10 +389,7 @@ impl<'a> NormalizedPat<'a> {
                 if lpath != rpath {
                     return false;
                 }
-                lpats
-                    .iter()
-                    .zip(rpats.iter())
-                    .all(|(lpat, rpat)| lpat.has_overlapping_values(rpat))
+                iter::zip(lpats, rpats).all(|(lpat, rpat)| lpat.has_overlapping_values(rpat))
             },
             (Self::Path(x), Self::Path(y)) => x == y,
             (Self::LitStr(x), Self::LitStr(y)) => x == y,
@@ -409,7 +399,7 @@ impl<'a> NormalizedPat<'a> {
             (Self::Range(ref x), Self::Range(ref y)) => x.overlaps(y),
             (Self::Range(ref range), Self::LitInt(x)) | (Self::LitInt(x), Self::Range(ref range)) => range.contains(x),
             (Self::Slice(lpats, None), Self::Slice(rpats, None)) => {
-                lpats.len() == rpats.len() && lpats.iter().zip(rpats.iter()).all(|(x, y)| x.has_overlapping_values(y))
+                lpats.len() == rpats.len() && iter::zip(lpats, rpats).all(|(x, y)| x.has_overlapping_values(y))
             },
             (Self::Slice(pats, None), Self::Slice(front, Some(back)))
             | (Self::Slice(front, Some(back)), Self::Slice(pats, None)) => {
@@ -418,16 +408,12 @@ impl<'a> NormalizedPat<'a> {
                 if pats.len() < front.len() + back.len() {
                     return false;
                 }
-                pats[..front.len()]
-                    .iter()
-                    .zip(front.iter())
-                    .chain(pats[pats.len() - back.len()..].iter().zip(back.iter()))
+                iter::zip(&pats[..front.len()], front)
+                    .chain(iter::zip(&pats[pats.len() - back.len()..], back))
                     .all(|(x, y)| x.has_overlapping_values(y))
             },
-            (Self::Slice(lfront, Some(lback)), Self::Slice(rfront, Some(rback))) => lfront
-                .iter()
-                .zip(rfront.iter())
-                .chain(lback.iter().rev().zip(rback.iter().rev()))
+            (Self::Slice(lfront, Some(lback)), Self::Slice(rfront, Some(rback))) => iter::zip(lfront, rfront)
+                .chain(iter::zip(lback.iter().rev(), rback.iter().rev()))
                 .all(|(x, y)| x.has_overlapping_values(y)),
 
             // Enums can mix unit variants with tuple/struct variants. These can never overlap.

From b6c4b3068ba7398c3e82b54675dcade446f276bf Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Fri, 19 Sep 2025 22:51:17 +0200
Subject: [PATCH 1197/1889] move `copies.rs` to `ifs/mod.rs`

all the lints work with `if`-expressions
---
 clippy_lints/src/declared_lints.rs         | 8 ++++----
 clippy_lints/src/{copies.rs => ifs/mod.rs} | 0
 clippy_lints/src/lib.rs                    | 4 ++--
 3 files changed, 6 insertions(+), 6 deletions(-)
 rename clippy_lints/src/{copies.rs => ifs/mod.rs} (100%)

diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 5563b8094f01b..a468cc19004cf 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -84,10 +84,6 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::collapsible_if::COLLAPSIBLE_IF_INFO,
     crate::collection_is_never_read::COLLECTION_IS_NEVER_READ_INFO,
     crate::comparison_chain::COMPARISON_CHAIN_INFO,
-    crate::copies::BRANCHES_SHARING_CODE_INFO,
-    crate::copies::IFS_SAME_COND_INFO,
-    crate::copies::IF_SAME_THEN_ELSE_INFO,
-    crate::copies::SAME_FUNCTIONS_IN_IF_CONDITION_INFO,
     crate::copy_iterator::COPY_ITERATOR_INFO,
     crate::crate_in_macro_def::CRATE_IN_MACRO_DEF_INFO,
     crate::create_dir::CREATE_DIR_INFO,
@@ -204,6 +200,10 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::if_let_mutex::IF_LET_MUTEX_INFO,
     crate::if_not_else::IF_NOT_ELSE_INFO,
     crate::if_then_some_else_none::IF_THEN_SOME_ELSE_NONE_INFO,
+    crate::ifs::BRANCHES_SHARING_CODE_INFO,
+    crate::ifs::IFS_SAME_COND_INFO,
+    crate::ifs::IF_SAME_THEN_ELSE_INFO,
+    crate::ifs::SAME_FUNCTIONS_IN_IF_CONDITION_INFO,
     crate::ignored_unit_patterns::IGNORED_UNIT_PATTERNS_INFO,
     crate::impl_hash_with_borrow_str_and_bytes::IMPL_HASH_BORROW_WITH_STR_AND_BYTES_INFO,
     crate::implicit_hasher::IMPLICIT_HASHER_INFO,
diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/ifs/mod.rs
similarity index 100%
rename from clippy_lints/src/copies.rs
rename to clippy_lints/src/ifs/mod.rs
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c56fa257b0689..1cae377f3fbd3 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -100,7 +100,6 @@ mod cognitive_complexity;
 mod collapsible_if;
 mod collection_is_never_read;
 mod comparison_chain;
-mod copies;
 mod copy_iterator;
 mod crate_in_macro_def;
 mod create_dir;
@@ -158,6 +157,7 @@ mod future_not_send;
 mod if_let_mutex;
 mod if_not_else;
 mod if_then_some_else_none;
+mod ifs;
 mod ignored_unit_patterns;
 mod impl_hash_with_borrow_str_and_bytes;
 mod implicit_hasher;
@@ -549,7 +549,7 @@ pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Co
     store.register_late_pass(|_| Box::new(empty_enum::EmptyEnum));
     store.register_late_pass(|_| Box::new(invalid_upcast_comparisons::InvalidUpcastComparisons));
     store.register_late_pass(|_| Box::<regex::Regex>::default());
-    store.register_late_pass(move |tcx| Box::new(copies::CopyAndPaste::new(tcx, conf)));
+    store.register_late_pass(move |tcx| Box::new(ifs::CopyAndPaste::new(tcx, conf)));
     store.register_late_pass(|_| Box::new(copy_iterator::CopyIterator));
     let format_args = format_args_storage.clone();
     store.register_late_pass(move |_| Box::new(format::UselessFormat::new(format_args.clone())));

From 95f5a00d8628fba223c802251af3c42547927c5a Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sun, 21 Sep 2025 11:19:14 +0200
Subject: [PATCH 1198/1889] extract each lint into its own module

---
 clippy_lints/src/ifs/branches_sharing_code.rs | 407 ++++++++++++++
 clippy_lints/src/ifs/if_same_then_else.rs     |  29 +
 clippy_lints/src/ifs/ifs_same_cond.rs         |  46 ++
 clippy_lints/src/ifs/mod.rs                   | 508 +-----------------
 .../src/ifs/same_functions_in_if_cond.rs      |  31 ++
 5 files changed, 525 insertions(+), 496 deletions(-)
 create mode 100644 clippy_lints/src/ifs/branches_sharing_code.rs
 create mode 100644 clippy_lints/src/ifs/if_same_then_else.rs
 create mode 100644 clippy_lints/src/ifs/ifs_same_cond.rs
 create mode 100644 clippy_lints/src/ifs/same_functions_in_if_cond.rs

diff --git a/clippy_lints/src/ifs/branches_sharing_code.rs b/clippy_lints/src/ifs/branches_sharing_code.rs
new file mode 100644
index 0000000000000..eb1025f71498e
--- /dev/null
+++ b/clippy_lints/src/ifs/branches_sharing_code.rs
@@ -0,0 +1,407 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::{IntoSpan, SpanRangeExt, first_line_of_span, indent_of, reindent_multiline, snippet};
+use clippy_utils::ty::needs_ordered_drop;
+use clippy_utils::visitors::for_each_expr_without_closures;
+use clippy_utils::{
+    ContainsName, HirEqInterExpr, SpanlessEq, capture_local_usage, get_enclosing_block, hash_expr, hash_stmt,
+    path_to_local,
+};
+use core::iter;
+use core::ops::ControlFlow;
+use rustc_errors::Applicability;
+use rustc_hir::{Block, Expr, ExprKind, HirId, HirIdSet, LetStmt, Node, Stmt, StmtKind, intravisit};
+use rustc_lint::LateContext;
+use rustc_span::hygiene::walk_chain;
+use rustc_span::source_map::SourceMap;
+use rustc_span::{Span, Symbol};
+
+use super::BRANCHES_SHARING_CODE;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    conds: &[&'tcx Expr<'_>],
+    blocks: &[&'tcx Block<'_>],
+    expr: &'tcx Expr<'_>,
+) {
+    // We only lint ifs with multiple blocks
+    let &[first_block, ref blocks @ ..] = blocks else {
+        return;
+    };
+    let &[.., last_block] = blocks else {
+        return;
+    };
+
+    let res = scan_block_for_eq(cx, conds, first_block, blocks);
+    let sm = cx.tcx.sess.source_map();
+    let start_suggestion = res.start_span(first_block, sm).map(|span| {
+        let first_line_span = first_line_of_span(cx, expr.span);
+        let replace_span = first_line_span.with_hi(span.hi());
+        let cond_span = first_line_span.until(first_block.span);
+        let cond_snippet = reindent_multiline(&snippet(cx, cond_span, "_"), false, None);
+        let cond_indent = indent_of(cx, cond_span);
+        let moved_snippet = reindent_multiline(&snippet(cx, span, "_"), true, None);
+        let suggestion = moved_snippet + "\n" + &cond_snippet + "{";
+        let suggestion = reindent_multiline(&suggestion, true, cond_indent);
+        (replace_span, suggestion)
+    });
+    let end_suggestion = res.end_span(last_block, sm).map(|span| {
+        let moved_snipped = reindent_multiline(&snippet(cx, span, "_"), true, None);
+        let indent = indent_of(cx, expr.span.shrink_to_hi());
+        let suggestion = "}\n".to_string() + &moved_snipped;
+        let suggestion = reindent_multiline(&suggestion, true, indent);
+
+        let span = span.with_hi(last_block.span.hi());
+        // Improve formatting if the inner block has indentation (i.e. normal Rust formatting)
+        let span = span
+            .map_range(cx, |_, src, range| {
+                (range.start > 4 && src.get(range.start - 4..range.start)? == "    ")
+                    .then_some(range.start - 4..range.end)
+            })
+            .map_or(span, |range| range.with_ctxt(span.ctxt()));
+        (span, suggestion.clone())
+    });
+
+    let (span, msg, end_span) = match (&start_suggestion, &end_suggestion) {
+        (&Some((span, _)), &Some((end_span, _))) => (
+            span,
+            "all if blocks contain the same code at both the start and the end",
+            Some(end_span),
+        ),
+        (&Some((span, _)), None) => (span, "all if blocks contain the same code at the start", None),
+        (None, &Some((span, _))) => (span, "all if blocks contain the same code at the end", None),
+        (None, None) => return,
+    };
+    span_lint_and_then(cx, BRANCHES_SHARING_CODE, span, msg, |diag| {
+        if let Some(span) = end_span {
+            diag.span_note(span, "this code is shared at the end");
+        }
+        if let Some((span, sugg)) = start_suggestion {
+            diag.span_suggestion(
+                span,
+                "consider moving these statements before the if",
+                sugg,
+                Applicability::Unspecified,
+            );
+        }
+        if let Some((span, sugg)) = end_suggestion {
+            diag.span_suggestion(
+                span,
+                "consider moving these statements after the if",
+                sugg,
+                Applicability::Unspecified,
+            );
+            if is_expr_parent_assignment(cx, expr) || !cx.typeck_results().expr_ty(expr).is_unit() {
+                diag.note("the end suggestion probably needs some adjustments to use the expression result correctly");
+            }
+        }
+        if check_for_warn_of_moved_symbol(cx, &res.moved_locals, expr) {
+            diag.warn("some moved values might need to be renamed to avoid wrong references");
+        }
+    });
+}
+
+struct BlockEq {
+    /// The end of the range of equal stmts at the start.
+    start_end_eq: usize,
+    /// The start of the range of equal stmts at the end.
+    end_begin_eq: Option<usize>,
+    /// The name and id of every local which can be moved at the beginning and the end.
+    moved_locals: Vec<(HirId, Symbol)>,
+}
+impl BlockEq {
+    fn start_span(&self, b: &Block<'_>, sm: &SourceMap) -> Option<Span> {
+        match &b.stmts[..self.start_end_eq] {
+            [first, .., last] => Some(sm.stmt_span(first.span, b.span).to(sm.stmt_span(last.span, b.span))),
+            [s] => Some(sm.stmt_span(s.span, b.span)),
+            [] => None,
+        }
+    }
+
+    fn end_span(&self, b: &Block<'_>, sm: &SourceMap) -> Option<Span> {
+        match (&b.stmts[b.stmts.len() - self.end_begin_eq?..], b.expr) {
+            ([first, .., last], None) => Some(sm.stmt_span(first.span, b.span).to(sm.stmt_span(last.span, b.span))),
+            ([first, ..], Some(last)) => Some(sm.stmt_span(first.span, b.span).to(sm.stmt_span(last.span, b.span))),
+            ([s], None) => Some(sm.stmt_span(s.span, b.span)),
+            ([], Some(e)) => Some(walk_chain(e.span, b.span.ctxt())),
+            ([], None) => None,
+        }
+    }
+}
+
+/// If the statement is a local, checks if the bound names match the expected list of names.
+fn eq_binding_names(s: &Stmt<'_>, names: &[(HirId, Symbol)]) -> bool {
+    if let StmtKind::Let(l) = s.kind {
+        let mut i = 0usize;
+        let mut res = true;
+        l.pat.each_binding_or_first(&mut |_, _, _, name| {
+            if names.get(i).is_some_and(|&(_, n)| n == name.name) {
+                i += 1;
+            } else {
+                res = false;
+            }
+        });
+        res && i == names.len()
+    } else {
+        false
+    }
+}
+
+/// Checks if the statement modifies or moves any of the given locals.
+fn modifies_any_local<'tcx>(cx: &LateContext<'tcx>, s: &'tcx Stmt<'_>, locals: &HirIdSet) -> bool {
+    for_each_expr_without_closures(s, |e| {
+        if let Some(id) = path_to_local(e)
+            && locals.contains(&id)
+            && !capture_local_usage(cx, e).is_imm_ref()
+        {
+            ControlFlow::Break(())
+        } else {
+            ControlFlow::Continue(())
+        }
+    })
+    .is_some()
+}
+
+/// Checks if the given statement should be considered equal to the statement in the same
+/// position for each block.
+fn eq_stmts(
+    stmt: &Stmt<'_>,
+    blocks: &[&Block<'_>],
+    get_stmt: impl for<'a> Fn(&'a Block<'a>) -> Option<&'a Stmt<'a>>,
+    eq: &mut HirEqInterExpr<'_, '_, '_>,
+    moved_bindings: &mut Vec<(HirId, Symbol)>,
+) -> bool {
+    (if let StmtKind::Let(l) = stmt.kind {
+        let old_count = moved_bindings.len();
+        l.pat.each_binding_or_first(&mut |_, id, _, name| {
+            moved_bindings.push((id, name.name));
+        });
+        let new_bindings = &moved_bindings[old_count..];
+        blocks
+            .iter()
+            .all(|b| get_stmt(b).is_some_and(|s| eq_binding_names(s, new_bindings)))
+    } else {
+        true
+    }) && blocks.iter().all(|b| get_stmt(b).is_some_and(|s| eq.eq_stmt(s, stmt)))
+}
+
+#[expect(clippy::too_many_lines)]
+fn scan_block_for_eq<'tcx>(
+    cx: &LateContext<'tcx>,
+    conds: &[&'tcx Expr<'_>],
+    block: &'tcx Block<'_>,
+    blocks: &[&'tcx Block<'_>],
+) -> BlockEq {
+    let mut eq = SpanlessEq::new(cx);
+    let mut eq = eq.inter_expr();
+    let mut moved_locals = Vec::new();
+
+    let mut cond_locals = HirIdSet::default();
+    for &cond in conds {
+        let _: Option<!> = for_each_expr_without_closures(cond, |e| {
+            if let Some(id) = path_to_local(e) {
+                cond_locals.insert(id);
+            }
+            ControlFlow::Continue(())
+        });
+    }
+
+    let mut local_needs_ordered_drop = false;
+    let start_end_eq = block
+        .stmts
+        .iter()
+        .enumerate()
+        .find(|&(i, stmt)| {
+            if let StmtKind::Let(l) = stmt.kind
+                && needs_ordered_drop(cx, cx.typeck_results().node_type(l.hir_id))
+            {
+                local_needs_ordered_drop = true;
+                return true;
+            }
+            modifies_any_local(cx, stmt, &cond_locals)
+                || !eq_stmts(stmt, blocks, |b| b.stmts.get(i), &mut eq, &mut moved_locals)
+        })
+        .map_or(block.stmts.len(), |(i, stmt)| {
+            adjust_by_closest_callsite(i, stmt, block.stmts[..i].iter().enumerate().rev())
+        });
+
+    if local_needs_ordered_drop {
+        return BlockEq {
+            start_end_eq,
+            end_begin_eq: None,
+            moved_locals,
+        };
+    }
+
+    // Walk backwards through the final expression/statements so long as their hashes are equal. Note
+    // `SpanlessHash` treats all local references as equal allowing locals declared earlier in the block
+    // to match those in other blocks. e.g. If each block ends with the following the hash value will be
+    // the same even though each `x` binding will have a different `HirId`:
+    //     let x = foo();
+    //     x + 50
+    let expr_hash_eq = if let Some(e) = block.expr {
+        let hash = hash_expr(cx, e);
+        blocks.iter().all(|b| b.expr.is_some_and(|e| hash_expr(cx, e) == hash))
+    } else {
+        blocks.iter().all(|b| b.expr.is_none())
+    };
+    if !expr_hash_eq {
+        return BlockEq {
+            start_end_eq,
+            end_begin_eq: None,
+            moved_locals,
+        };
+    }
+    let end_search_start = block.stmts[start_end_eq..]
+        .iter()
+        .rev()
+        .enumerate()
+        .find(|&(offset, stmt)| {
+            let hash = hash_stmt(cx, stmt);
+            blocks.iter().any(|b| {
+                b.stmts
+                    // the bounds check will catch the underflow
+                    .get(b.stmts.len().wrapping_sub(offset + 1))
+                    .is_none_or(|s| hash != hash_stmt(cx, s))
+            })
+        })
+        .map_or(block.stmts.len() - start_end_eq, |(i, stmt)| {
+            adjust_by_closest_callsite(i, stmt, (0..i).rev().zip(block.stmts[(block.stmts.len() - i)..].iter()))
+        });
+
+    let moved_locals_at_start = moved_locals.len();
+    let mut i = end_search_start;
+    let end_begin_eq = block.stmts[block.stmts.len() - end_search_start..]
+        .iter()
+        .zip(iter::repeat_with(move || {
+            let x = i;
+            i -= 1;
+            x
+        }))
+        .fold(end_search_start, |init, (stmt, offset)| {
+            if eq_stmts(
+                stmt,
+                blocks,
+                |b| b.stmts.get(b.stmts.len() - offset),
+                &mut eq,
+                &mut moved_locals,
+            ) {
+                init
+            } else {
+                // Clear out all locals seen at the end so far. None of them can be moved.
+                let stmts = &blocks[0].stmts;
+                for stmt in &stmts[stmts.len() - init..=stmts.len() - offset] {
+                    if let StmtKind::Let(l) = stmt.kind {
+                        l.pat.each_binding_or_first(&mut |_, id, _, _| {
+                            // FIXME(rust/#120456) - is `swap_remove` correct?
+                            eq.locals.swap_remove(&id);
+                        });
+                    }
+                }
+                moved_locals.truncate(moved_locals_at_start);
+                offset - 1
+            }
+        });
+    if let Some(e) = block.expr {
+        for block in blocks {
+            if block.expr.is_some_and(|expr| !eq.eq_expr(expr, e)) {
+                moved_locals.truncate(moved_locals_at_start);
+                return BlockEq {
+                    start_end_eq,
+                    end_begin_eq: None,
+                    moved_locals,
+                };
+            }
+        }
+    }
+
+    BlockEq {
+        start_end_eq,
+        end_begin_eq: Some(end_begin_eq),
+        moved_locals,
+    }
+}
+
+/// Adjusts the index for which the statements begin to differ to the closest macro callsite.
+/// This avoids giving suggestions that requires splitting a macro call in half, when only a
+/// part of the macro expansion is equal.
+///
+/// For example, for the following macro:
+/// ```rust,ignore
+/// macro_rules! foo {
+///    ($x:expr) => {
+///        let y = 42;
+///        $x;
+///    };
+/// }
+/// ```
+/// If the macro is called like this:
+/// ```rust,ignore
+/// if false {
+///    let z = 42;
+///    foo!(println!("Hello"));
+/// } else {
+///    let z = 42;
+///    foo!(println!("World"));
+/// }
+/// ```
+/// Although the expanded `let y = 42;` is equal, the macro call should not be included in the
+/// suggestion.
+fn adjust_by_closest_callsite<'tcx>(
+    i: usize,
+    stmt: &'tcx Stmt<'tcx>,
+    mut iter: impl Iterator<Item = (usize, &'tcx Stmt<'tcx>)>,
+) -> usize {
+    let Some((_, first)) = iter.next() else {
+        return 0;
+    };
+
+    // If it is already at the boundary of a macro call, then just return.
+    if first.span.source_callsite() != stmt.span.source_callsite() {
+        return i;
+    }
+
+    iter.find(|(_, stmt)| stmt.span.source_callsite() != first.span.source_callsite())
+        .map_or(0, |(i, _)| i + 1)
+}
+
+fn check_for_warn_of_moved_symbol(cx: &LateContext<'_>, symbols: &[(HirId, Symbol)], if_expr: &Expr<'_>) -> bool {
+    get_enclosing_block(cx, if_expr.hir_id).is_some_and(|block| {
+        let ignore_span = block.span.shrink_to_lo().to(if_expr.span);
+
+        symbols
+            .iter()
+            .filter(|&&(_, name)| !name.as_str().starts_with('_'))
+            .any(|&(_, name)| {
+                let mut walker = ContainsName { name, cx };
+
+                // Scan block
+                let mut res = block
+                    .stmts
+                    .iter()
+                    .filter(|stmt| !ignore_span.overlaps(stmt.span))
+                    .try_for_each(|stmt| intravisit::walk_stmt(&mut walker, stmt));
+
+                if let Some(expr) = block.expr
+                    && res.is_continue()
+                {
+                    res = intravisit::walk_expr(&mut walker, expr);
+                }
+
+                res.is_break()
+            })
+    })
+}
+
+fn is_expr_parent_assignment(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    let parent = cx.tcx.parent_hir_node(expr.hir_id);
+    if let Node::LetStmt(LetStmt { init: Some(e), .. })
+    | Node::Expr(Expr {
+        kind: ExprKind::Assign(_, e, _),
+        ..
+    }) = parent
+    {
+        return e.hir_id == expr.hir_id;
+    }
+
+    false
+}
diff --git a/clippy_lints/src/ifs/if_same_then_else.rs b/clippy_lints/src/ifs/if_same_then_else.rs
new file mode 100644
index 0000000000000..69402ec890768
--- /dev/null
+++ b/clippy_lints/src/ifs/if_same_then_else.rs
@@ -0,0 +1,29 @@
+use clippy_utils::SpanlessEq;
+use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::higher::has_let_expr;
+use rustc_hir::{Block, Expr};
+use rustc_lint::LateContext;
+
+use super::IF_SAME_THEN_ELSE;
+
+pub(super) fn check(cx: &LateContext<'_>, conds: &[&Expr<'_>], blocks: &[&Block<'_>]) -> bool {
+    let mut eq = SpanlessEq::new(cx);
+    blocks
+        .array_windows::<2>()
+        .enumerate()
+        .fold(true, |all_eq, (i, &[lhs, rhs])| {
+            if eq.eq_block(lhs, rhs) && !has_let_expr(conds[i]) && conds.get(i + 1).is_none_or(|e| !has_let_expr(e)) {
+                span_lint_and_note(
+                    cx,
+                    IF_SAME_THEN_ELSE,
+                    lhs.span,
+                    "this `if` has identical blocks",
+                    Some(rhs.span),
+                    "same as this",
+                );
+                all_eq
+            } else {
+                false
+            }
+        })
+}
diff --git a/clippy_lints/src/ifs/ifs_same_cond.rs b/clippy_lints/src/ifs/ifs_same_cond.rs
new file mode 100644
index 0000000000000..ca76fc2587db9
--- /dev/null
+++ b/clippy_lints/src/ifs/ifs_same_cond.rs
@@ -0,0 +1,46 @@
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::ty::InteriorMut;
+use clippy_utils::{SpanlessEq, eq_expr_value, find_binding_init, hash_expr, path_to_local, search_same};
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+
+use super::IFS_SAME_COND;
+
+fn method_caller_is_mutable<'tcx>(
+    cx: &LateContext<'tcx>,
+    caller_expr: &Expr<'_>,
+    interior_mut: &mut InteriorMut<'tcx>,
+) -> bool {
+    let caller_ty = cx.typeck_results().expr_ty(caller_expr);
+
+    interior_mut.is_interior_mut_ty(cx, caller_ty)
+        || caller_ty.is_mutable_ptr()
+        // `find_binding_init` will return the binding iff its not mutable
+        || path_to_local(caller_expr)
+            .and_then(|hid| find_binding_init(cx, hid))
+            .is_none()
+}
+
+/// Implementation of `IFS_SAME_COND`.
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, conds: &[&Expr<'_>], interior_mut: &mut InteriorMut<'tcx>) {
+    for group in search_same(
+        conds,
+        |e| hash_expr(cx, e),
+        |lhs, rhs| {
+            // Ignore eq_expr side effects iff one of the expression kind is a method call
+            // and the caller is not a mutable, including inner mutable type.
+            if let ExprKind::MethodCall(_, caller, _, _) = lhs.kind {
+                if method_caller_is_mutable(cx, caller, interior_mut) {
+                    false
+                } else {
+                    SpanlessEq::new(cx).eq_expr(lhs, rhs)
+                }
+            } else {
+                eq_expr_value(cx, lhs, rhs)
+            }
+        },
+    ) {
+        let spans: Vec<_> = group.into_iter().map(|expr| expr.span).collect();
+        span_lint(cx, IFS_SAME_COND, spans, "these `if` branches have the same condition");
+    }
+}
diff --git a/clippy_lints/src/ifs/mod.rs b/clippy_lints/src/ifs/mod.rs
index 4fdb497950f8d..739f2fc917293 100644
--- a/clippy_lints/src/ifs/mod.rs
+++ b/clippy_lints/src/ifs/mod.rs
@@ -1,24 +1,15 @@
 use clippy_config::Conf;
-use clippy_utils::diagnostics::{span_lint, span_lint_and_note, span_lint_and_then};
-use clippy_utils::higher::has_let_expr;
-use clippy_utils::source::{IntoSpan, SpanRangeExt, first_line_of_span, indent_of, reindent_multiline, snippet};
-use clippy_utils::ty::{InteriorMut, needs_ordered_drop};
-use clippy_utils::visitors::for_each_expr_without_closures;
-use clippy_utils::{
-    ContainsName, HirEqInterExpr, SpanlessEq, capture_local_usage, eq_expr_value, find_binding_init,
-    get_enclosing_block, hash_expr, hash_stmt, if_sequence, is_else_clause, is_lint_allowed, path_to_local,
-    search_same,
-};
-use core::iter;
-use core::ops::ControlFlow;
-use rustc_errors::Applicability;
-use rustc_hir::{Block, Expr, ExprKind, HirId, HirIdSet, LetStmt, Node, Stmt, StmtKind, intravisit};
+use clippy_utils::ty::InteriorMut;
+use clippy_utils::{if_sequence, is_else_clause, is_lint_allowed};
+use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::impl_lint_pass;
-use rustc_span::hygiene::walk_chain;
-use rustc_span::source_map::SourceMap;
-use rustc_span::{Span, Symbol};
+
+mod branches_sharing_code;
+mod if_same_then_else;
+mod ifs_same_cond;
+mod same_functions_in_if_cond;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -179,488 +170,13 @@ impl<'tcx> LateLintPass<'tcx> for CopyAndPaste<'tcx> {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if !expr.span.from_expansion() && matches!(expr.kind, ExprKind::If(..)) && !is_else_clause(cx.tcx, expr) {
             let (conds, blocks) = if_sequence(expr);
-            lint_same_cond(cx, &conds, &mut self.interior_mut);
-            lint_same_fns_in_if_cond(cx, &conds);
+            ifs_same_cond::check(cx, &conds, &mut self.interior_mut);
+            same_functions_in_if_cond::check(cx, &conds);
             let all_same =
-                !is_lint_allowed(cx, IF_SAME_THEN_ELSE, expr.hir_id) && lint_if_same_then_else(cx, &conds, &blocks);
+                !is_lint_allowed(cx, IF_SAME_THEN_ELSE, expr.hir_id) && if_same_then_else::check(cx, &conds, &blocks);
             if !all_same && conds.len() != blocks.len() {
-                lint_branches_sharing_code(cx, &conds, &blocks, expr);
-            }
-        }
-    }
-}
-
-fn lint_if_same_then_else(cx: &LateContext<'_>, conds: &[&Expr<'_>], blocks: &[&Block<'_>]) -> bool {
-    let mut eq = SpanlessEq::new(cx);
-    blocks
-        .array_windows::<2>()
-        .enumerate()
-        .fold(true, |all_eq, (i, &[lhs, rhs])| {
-            if eq.eq_block(lhs, rhs) && !has_let_expr(conds[i]) && conds.get(i + 1).is_none_or(|e| !has_let_expr(e)) {
-                span_lint_and_note(
-                    cx,
-                    IF_SAME_THEN_ELSE,
-                    lhs.span,
-                    "this `if` has identical blocks",
-                    Some(rhs.span),
-                    "same as this",
-                );
-                all_eq
-            } else {
-                false
-            }
-        })
-}
-
-fn lint_branches_sharing_code<'tcx>(
-    cx: &LateContext<'tcx>,
-    conds: &[&'tcx Expr<'_>],
-    blocks: &[&'tcx Block<'_>],
-    expr: &'tcx Expr<'_>,
-) {
-    // We only lint ifs with multiple blocks
-    let &[first_block, ref blocks @ ..] = blocks else {
-        return;
-    };
-    let &[.., last_block] = blocks else {
-        return;
-    };
-
-    let res = scan_block_for_eq(cx, conds, first_block, blocks);
-    let sm = cx.tcx.sess.source_map();
-    let start_suggestion = res.start_span(first_block, sm).map(|span| {
-        let first_line_span = first_line_of_span(cx, expr.span);
-        let replace_span = first_line_span.with_hi(span.hi());
-        let cond_span = first_line_span.until(first_block.span);
-        let cond_snippet = reindent_multiline(&snippet(cx, cond_span, "_"), false, None);
-        let cond_indent = indent_of(cx, cond_span);
-        let moved_snippet = reindent_multiline(&snippet(cx, span, "_"), true, None);
-        let suggestion = moved_snippet + "\n" + &cond_snippet + "{";
-        let suggestion = reindent_multiline(&suggestion, true, cond_indent);
-        (replace_span, suggestion)
-    });
-    let end_suggestion = res.end_span(last_block, sm).map(|span| {
-        let moved_snipped = reindent_multiline(&snippet(cx, span, "_"), true, None);
-        let indent = indent_of(cx, expr.span.shrink_to_hi());
-        let suggestion = "}\n".to_string() + &moved_snipped;
-        let suggestion = reindent_multiline(&suggestion, true, indent);
-
-        let span = span.with_hi(last_block.span.hi());
-        // Improve formatting if the inner block has indentation (i.e. normal Rust formatting)
-        let span = span
-            .map_range(cx, |_, src, range| {
-                (range.start > 4 && src.get(range.start - 4..range.start)? == "    ")
-                    .then_some(range.start - 4..range.end)
-            })
-            .map_or(span, |range| range.with_ctxt(span.ctxt()));
-        (span, suggestion.clone())
-    });
-
-    let (span, msg, end_span) = match (&start_suggestion, &end_suggestion) {
-        (&Some((span, _)), &Some((end_span, _))) => (
-            span,
-            "all if blocks contain the same code at both the start and the end",
-            Some(end_span),
-        ),
-        (&Some((span, _)), None) => (span, "all if blocks contain the same code at the start", None),
-        (None, &Some((span, _))) => (span, "all if blocks contain the same code at the end", None),
-        (None, None) => return,
-    };
-    span_lint_and_then(cx, BRANCHES_SHARING_CODE, span, msg, |diag| {
-        if let Some(span) = end_span {
-            diag.span_note(span, "this code is shared at the end");
-        }
-        if let Some((span, sugg)) = start_suggestion {
-            diag.span_suggestion(
-                span,
-                "consider moving these statements before the if",
-                sugg,
-                Applicability::Unspecified,
-            );
-        }
-        if let Some((span, sugg)) = end_suggestion {
-            diag.span_suggestion(
-                span,
-                "consider moving these statements after the if",
-                sugg,
-                Applicability::Unspecified,
-            );
-            if is_expr_parent_assignment(cx, expr) || !cx.typeck_results().expr_ty(expr).is_unit() {
-                diag.note("the end suggestion probably needs some adjustments to use the expression result correctly");
+                branches_sharing_code::check(cx, &conds, &blocks, expr);
             }
         }
-        if check_for_warn_of_moved_symbol(cx, &res.moved_locals, expr) {
-            diag.warn("some moved values might need to be renamed to avoid wrong references");
-        }
-    });
-}
-
-struct BlockEq {
-    /// The end of the range of equal stmts at the start.
-    start_end_eq: usize,
-    /// The start of the range of equal stmts at the end.
-    end_begin_eq: Option<usize>,
-    /// The name and id of every local which can be moved at the beginning and the end.
-    moved_locals: Vec<(HirId, Symbol)>,
-}
-impl BlockEq {
-    fn start_span(&self, b: &Block<'_>, sm: &SourceMap) -> Option<Span> {
-        match &b.stmts[..self.start_end_eq] {
-            [first, .., last] => Some(sm.stmt_span(first.span, b.span).to(sm.stmt_span(last.span, b.span))),
-            [s] => Some(sm.stmt_span(s.span, b.span)),
-            [] => None,
-        }
     }
-
-    fn end_span(&self, b: &Block<'_>, sm: &SourceMap) -> Option<Span> {
-        match (&b.stmts[b.stmts.len() - self.end_begin_eq?..], b.expr) {
-            ([first, .., last], None) => Some(sm.stmt_span(first.span, b.span).to(sm.stmt_span(last.span, b.span))),
-            ([first, ..], Some(last)) => Some(sm.stmt_span(first.span, b.span).to(sm.stmt_span(last.span, b.span))),
-            ([s], None) => Some(sm.stmt_span(s.span, b.span)),
-            ([], Some(e)) => Some(walk_chain(e.span, b.span.ctxt())),
-            ([], None) => None,
-        }
-    }
-}
-
-/// If the statement is a local, checks if the bound names match the expected list of names.
-fn eq_binding_names(s: &Stmt<'_>, names: &[(HirId, Symbol)]) -> bool {
-    if let StmtKind::Let(l) = s.kind {
-        let mut i = 0usize;
-        let mut res = true;
-        l.pat.each_binding_or_first(&mut |_, _, _, name| {
-            if names.get(i).is_some_and(|&(_, n)| n == name.name) {
-                i += 1;
-            } else {
-                res = false;
-            }
-        });
-        res && i == names.len()
-    } else {
-        false
-    }
-}
-
-/// Checks if the statement modifies or moves any of the given locals.
-fn modifies_any_local<'tcx>(cx: &LateContext<'tcx>, s: &'tcx Stmt<'_>, locals: &HirIdSet) -> bool {
-    for_each_expr_without_closures(s, |e| {
-        if let Some(id) = path_to_local(e)
-            && locals.contains(&id)
-            && !capture_local_usage(cx, e).is_imm_ref()
-        {
-            ControlFlow::Break(())
-        } else {
-            ControlFlow::Continue(())
-        }
-    })
-    .is_some()
-}
-
-/// Checks if the given statement should be considered equal to the statement in the same position
-/// for each block.
-fn eq_stmts(
-    stmt: &Stmt<'_>,
-    blocks: &[&Block<'_>],
-    get_stmt: impl for<'a> Fn(&'a Block<'a>) -> Option<&'a Stmt<'a>>,
-    eq: &mut HirEqInterExpr<'_, '_, '_>,
-    moved_bindings: &mut Vec<(HirId, Symbol)>,
-) -> bool {
-    (if let StmtKind::Let(l) = stmt.kind {
-        let old_count = moved_bindings.len();
-        l.pat.each_binding_or_first(&mut |_, id, _, name| {
-            moved_bindings.push((id, name.name));
-        });
-        let new_bindings = &moved_bindings[old_count..];
-        blocks
-            .iter()
-            .all(|b| get_stmt(b).is_some_and(|s| eq_binding_names(s, new_bindings)))
-    } else {
-        true
-    }) && blocks.iter().all(|b| get_stmt(b).is_some_and(|s| eq.eq_stmt(s, stmt)))
-}
-
-#[expect(clippy::too_many_lines)]
-fn scan_block_for_eq<'tcx>(
-    cx: &LateContext<'tcx>,
-    conds: &[&'tcx Expr<'_>],
-    block: &'tcx Block<'_>,
-    blocks: &[&'tcx Block<'_>],
-) -> BlockEq {
-    let mut eq = SpanlessEq::new(cx);
-    let mut eq = eq.inter_expr();
-    let mut moved_locals = Vec::new();
-
-    let mut cond_locals = HirIdSet::default();
-    for &cond in conds {
-        let _: Option<!> = for_each_expr_without_closures(cond, |e| {
-            if let Some(id) = path_to_local(e) {
-                cond_locals.insert(id);
-            }
-            ControlFlow::Continue(())
-        });
-    }
-
-    let mut local_needs_ordered_drop = false;
-    let start_end_eq = block
-        .stmts
-        .iter()
-        .enumerate()
-        .find(|&(i, stmt)| {
-            if let StmtKind::Let(l) = stmt.kind
-                && needs_ordered_drop(cx, cx.typeck_results().node_type(l.hir_id))
-            {
-                local_needs_ordered_drop = true;
-                return true;
-            }
-            modifies_any_local(cx, stmt, &cond_locals)
-                || !eq_stmts(stmt, blocks, |b| b.stmts.get(i), &mut eq, &mut moved_locals)
-        })
-        .map_or(block.stmts.len(), |(i, stmt)| {
-            adjust_by_closest_callsite(i, stmt, block.stmts[..i].iter().enumerate().rev())
-        });
-
-    if local_needs_ordered_drop {
-        return BlockEq {
-            start_end_eq,
-            end_begin_eq: None,
-            moved_locals,
-        };
-    }
-
-    // Walk backwards through the final expression/statements so long as their hashes are equal. Note
-    // `SpanlessHash` treats all local references as equal allowing locals declared earlier in the block
-    // to match those in other blocks. e.g. If each block ends with the following the hash value will be
-    // the same even though each `x` binding will have a different `HirId`:
-    //     let x = foo();
-    //     x + 50
-    let expr_hash_eq = if let Some(e) = block.expr {
-        let hash = hash_expr(cx, e);
-        blocks.iter().all(|b| b.expr.is_some_and(|e| hash_expr(cx, e) == hash))
-    } else {
-        blocks.iter().all(|b| b.expr.is_none())
-    };
-    if !expr_hash_eq {
-        return BlockEq {
-            start_end_eq,
-            end_begin_eq: None,
-            moved_locals,
-        };
-    }
-    let end_search_start = block.stmts[start_end_eq..]
-        .iter()
-        .rev()
-        .enumerate()
-        .find(|&(offset, stmt)| {
-            let hash = hash_stmt(cx, stmt);
-            blocks.iter().any(|b| {
-                b.stmts
-                    // the bounds check will catch the underflow
-                    .get(b.stmts.len().wrapping_sub(offset + 1))
-                    .is_none_or(|s| hash != hash_stmt(cx, s))
-            })
-        })
-        .map_or(block.stmts.len() - start_end_eq, |(i, stmt)| {
-            adjust_by_closest_callsite(i, stmt, (0..i).rev().zip(block.stmts[(block.stmts.len() - i)..].iter()))
-        });
-
-    let moved_locals_at_start = moved_locals.len();
-    let mut i = end_search_start;
-    let end_begin_eq = block.stmts[block.stmts.len() - end_search_start..]
-        .iter()
-        .zip(iter::repeat_with(move || {
-            let x = i;
-            i -= 1;
-            x
-        }))
-        .fold(end_search_start, |init, (stmt, offset)| {
-            if eq_stmts(
-                stmt,
-                blocks,
-                |b| b.stmts.get(b.stmts.len() - offset),
-                &mut eq,
-                &mut moved_locals,
-            ) {
-                init
-            } else {
-                // Clear out all locals seen at the end so far. None of them can be moved.
-                let stmts = &blocks[0].stmts;
-                for stmt in &stmts[stmts.len() - init..=stmts.len() - offset] {
-                    if let StmtKind::Let(l) = stmt.kind {
-                        l.pat.each_binding_or_first(&mut |_, id, _, _| {
-                            // FIXME(rust/#120456) - is `swap_remove` correct?
-                            eq.locals.swap_remove(&id);
-                        });
-                    }
-                }
-                moved_locals.truncate(moved_locals_at_start);
-                offset - 1
-            }
-        });
-    if let Some(e) = block.expr {
-        for block in blocks {
-            if block.expr.is_some_and(|expr| !eq.eq_expr(expr, e)) {
-                moved_locals.truncate(moved_locals_at_start);
-                return BlockEq {
-                    start_end_eq,
-                    end_begin_eq: None,
-                    moved_locals,
-                };
-            }
-        }
-    }
-
-    BlockEq {
-        start_end_eq,
-        end_begin_eq: Some(end_begin_eq),
-        moved_locals,
-    }
-}
-
-/// Adjusts the index for which the statements begin to differ to the closest macro callsite. This
-/// avoids giving suggestions that requires splitting a macro call in half, when only a part of the
-/// macro expansion is equal.
-///
-/// For example, for the following macro:
-/// ```rust,ignore
-/// macro_rules! foo {
-///    ($x:expr) => {
-///        let y = 42;
-///        $x;
-///    };
-/// }
-/// ```
-/// If the macro is called like this:
-/// ```rust,ignore
-/// if false {
-///    let z = 42;
-///    foo!(println!("Hello"));
-/// } else {
-///    let z = 42;
-///    foo!(println!("World"));
-/// }
-/// ```
-/// Although the expanded `let y = 42;` is equal, the macro call should not be included in the
-/// suggestion.
-fn adjust_by_closest_callsite<'tcx>(
-    i: usize,
-    stmt: &'tcx Stmt<'tcx>,
-    mut iter: impl Iterator<Item = (usize, &'tcx Stmt<'tcx>)>,
-) -> usize {
-    let Some((_, first)) = iter.next() else {
-        return 0;
-    };
-
-    // If it is already at the boundary of a macro call, then just return.
-    if first.span.source_callsite() != stmt.span.source_callsite() {
-        return i;
-    }
-
-    iter.find(|(_, stmt)| stmt.span.source_callsite() != first.span.source_callsite())
-        .map_or(0, |(i, _)| i + 1)
-}
-
-fn check_for_warn_of_moved_symbol(cx: &LateContext<'_>, symbols: &[(HirId, Symbol)], if_expr: &Expr<'_>) -> bool {
-    get_enclosing_block(cx, if_expr.hir_id).is_some_and(|block| {
-        let ignore_span = block.span.shrink_to_lo().to(if_expr.span);
-
-        symbols
-            .iter()
-            .filter(|&&(_, name)| !name.as_str().starts_with('_'))
-            .any(|&(_, name)| {
-                let mut walker = ContainsName { name, cx };
-
-                // Scan block
-                let mut res = block
-                    .stmts
-                    .iter()
-                    .filter(|stmt| !ignore_span.overlaps(stmt.span))
-                    .try_for_each(|stmt| intravisit::walk_stmt(&mut walker, stmt));
-
-                if let Some(expr) = block.expr
-                    && res.is_continue()
-                {
-                    res = intravisit::walk_expr(&mut walker, expr);
-                }
-
-                res.is_break()
-            })
-    })
-}
-
-fn method_caller_is_mutable<'tcx>(
-    cx: &LateContext<'tcx>,
-    caller_expr: &Expr<'_>,
-    interior_mut: &mut InteriorMut<'tcx>,
-) -> bool {
-    let caller_ty = cx.typeck_results().expr_ty(caller_expr);
-
-    interior_mut.is_interior_mut_ty(cx, caller_ty)
-        || caller_ty.is_mutable_ptr()
-        // `find_binding_init` will return the binding iff its not mutable
-        || path_to_local(caller_expr)
-            .and_then(|hid| find_binding_init(cx, hid))
-            .is_none()
-}
-
-/// Implementation of `IFS_SAME_COND`.
-fn lint_same_cond<'tcx>(cx: &LateContext<'tcx>, conds: &[&Expr<'_>], interior_mut: &mut InteriorMut<'tcx>) {
-    for group in search_same(
-        conds,
-        |e| hash_expr(cx, e),
-        |lhs, rhs| {
-            // Ignore eq_expr side effects iff one of the expression kind is a method call
-            // and the caller is not a mutable, including inner mutable type.
-            if let ExprKind::MethodCall(_, caller, _, _) = lhs.kind {
-                if method_caller_is_mutable(cx, caller, interior_mut) {
-                    false
-                } else {
-                    SpanlessEq::new(cx).eq_expr(lhs, rhs)
-                }
-            } else {
-                eq_expr_value(cx, lhs, rhs)
-            }
-        },
-    ) {
-        let spans: Vec<_> = group.into_iter().map(|expr| expr.span).collect();
-        span_lint(cx, IFS_SAME_COND, spans, "these `if` branches have the same condition");
-    }
-}
-
-/// Implementation of `SAME_FUNCTIONS_IN_IF_CONDITION`.
-fn lint_same_fns_in_if_cond(cx: &LateContext<'_>, conds: &[&Expr<'_>]) {
-    let eq: &dyn Fn(&&Expr<'_>, &&Expr<'_>) -> bool = &|&lhs, &rhs| -> bool {
-        // Do not lint if any expr originates from a macro
-        if lhs.span.from_expansion() || rhs.span.from_expansion() {
-            return false;
-        }
-        // Do not spawn warning if `IFS_SAME_COND` already produced it.
-        if eq_expr_value(cx, lhs, rhs) {
-            return false;
-        }
-        SpanlessEq::new(cx).eq_expr(lhs, rhs)
-    };
-
-    for group in search_same(conds, |e| hash_expr(cx, e), eq) {
-        let spans: Vec<_> = group.into_iter().map(|expr| expr.span).collect();
-        span_lint(
-            cx,
-            SAME_FUNCTIONS_IN_IF_CONDITION,
-            spans,
-            "these `if` branches have the same function call",
-        );
-    }
-}
-
-fn is_expr_parent_assignment(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    let parent = cx.tcx.parent_hir_node(expr.hir_id);
-    if let Node::LetStmt(LetStmt { init: Some(e), .. })
-    | Node::Expr(Expr {
-        kind: ExprKind::Assign(_, e, _),
-        ..
-    }) = parent
-    {
-        return e.hir_id == expr.hir_id;
-    }
-
-    false
 }
diff --git a/clippy_lints/src/ifs/same_functions_in_if_cond.rs b/clippy_lints/src/ifs/same_functions_in_if_cond.rs
new file mode 100644
index 0000000000000..1f6bf04e22e7d
--- /dev/null
+++ b/clippy_lints/src/ifs/same_functions_in_if_cond.rs
@@ -0,0 +1,31 @@
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::{SpanlessEq, eq_expr_value, hash_expr, search_same};
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+
+use super::SAME_FUNCTIONS_IN_IF_CONDITION;
+
+/// Implementation of `SAME_FUNCTIONS_IN_IF_CONDITION`.
+pub(super) fn check(cx: &LateContext<'_>, conds: &[&Expr<'_>]) {
+    let eq: &dyn Fn(&&Expr<'_>, &&Expr<'_>) -> bool = &|&lhs, &rhs| -> bool {
+        // Do not lint if any expr originates from a macro
+        if lhs.span.from_expansion() || rhs.span.from_expansion() {
+            return false;
+        }
+        // Do not spawn warning if `IFS_SAME_COND` already produced it.
+        if eq_expr_value(cx, lhs, rhs) {
+            return false;
+        }
+        SpanlessEq::new(cx).eq_expr(lhs, rhs)
+    };
+
+    for group in search_same(conds, |e| hash_expr(cx, e), eq) {
+        let spans: Vec<_> = group.into_iter().map(|expr| expr.span).collect();
+        span_lint(
+            cx,
+            SAME_FUNCTIONS_IN_IF_CONDITION,
+            spans,
+            "these `if` branches have the same function call",
+        );
+    }
+}

From b17fb70d0437b90fc9ada0ac2d924cce06eb8828 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sun, 21 Sep 2025 20:50:44 +1000
Subject: [PATCH 1199/1889] Add self-profile events for target-machine creation

These code paths are surprisingly hot in the `large-workspace` benchmark; it
would be handy to see some detailed timings and execution counts.
---
 compiler/rustc_codegen_llvm/src/back/write.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/compiler/rustc_codegen_llvm/src/back/write.rs b/compiler/rustc_codegen_llvm/src/back/write.rs
index c4881f0aafc80..1950b8288d149 100644
--- a/compiler/rustc_codegen_llvm/src/back/write.rs
+++ b/compiler/rustc_codegen_llvm/src/back/write.rs
@@ -204,6 +204,9 @@ pub(crate) fn target_machine_factory(
     optlvl: config::OptLevel,
     target_features: &[String],
 ) -> TargetMachineFactoryFn<LlvmCodegenBackend> {
+    // Self-profile timer for creating a _factory_.
+    let _prof_timer = sess.prof.generic_activity("target_machine_factory");
+
     let reloc_model = to_llvm_relocation_model(sess.relocation_model());
 
     let (opt_level, _) = to_llvm_opt_settings(optlvl);
@@ -259,6 +262,9 @@ pub(crate) fn target_machine_factory(
         .into_string()
         .unwrap_or_default();
     let command_line_args = quote_command_line_args(&sess.expanded_args);
+    // Self-profile counter for the number of bytes produced by command-line quoting.
+    // Values are summed, so the summary result is cumulative across all TM factories.
+    sess.prof.artifact_size("quoted_command_line_args", "-", command_line_args.len() as u64);
 
     let debuginfo_compression = sess.opts.debuginfo_compression.to_string();
     match sess.opts.debuginfo_compression {
@@ -281,7 +287,11 @@ pub(crate) fn target_machine_factory(
 
     let use_wasm_eh = wants_wasm_eh(sess);
 
+    let prof = SelfProfilerRef::clone(&sess.prof);
     Arc::new(move |config: TargetMachineFactoryConfig| {
+        // Self-profile timer for invoking a factory to create a target machine.
+        let _prof_timer = prof.generic_activity("target_machine_factory_inner");
+
         let path_to_cstring_helper = |path: Option<PathBuf>| -> CString {
             let path = path.unwrap_or_default();
             let path = path_mapping

From 2dfcd0948e0dc1608a04e35d2f1812a21cf45b7a Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Sun, 21 Sep 2025 12:05:09 +0000
Subject: [PATCH 1200/1889] btree InternalNode::new safety comments

---
 library/alloc/src/collections/btree/node.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/library/alloc/src/collections/btree/node.rs b/library/alloc/src/collections/btree/node.rs
index b233e1740b7b7..2b8103c8b7786 100644
--- a/library/alloc/src/collections/btree/node.rs
+++ b/library/alloc/src/collections/btree/node.rs
@@ -117,10 +117,11 @@ impl<K, V> InternalNode<K, V> {
     /// initialized and valid edge. This function does not set up
     /// such an edge.
     unsafe fn new<A: Allocator + Clone>(alloc: A) -> Box<Self, A> {
+        let mut node = Box::<Self, _>::new_uninit_in(alloc);
         unsafe {
-            let mut node = Box::<Self, _>::new_uninit_in(alloc);
-            // We only need to initialize the data; the edges are MaybeUninit.
+            // SAFETY: argument points to the `node.data` `LeafNode`
             LeafNode::init(&raw mut (*node.as_mut_ptr()).data);
+            // SAFETY: `node.data` was just initialized and `node.edges` is MaybeUninit.
             node.assume_init()
         }
     }

From b0010dd5aeb3b9837fdf92c121ebfdd1a07bce6f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Mon, 15 Sep 2025 13:16:25 +0200
Subject: [PATCH 1201/1889] Add diagnostics context and migrate the `style`
 check to it

---
 src/tools/tidy/src/diagnostics.rs | 102 +++++++++++++++++++++++
 src/tools/tidy/src/lib.rs         |   8 +-
 src/tools/tidy/src/main.rs        | 129 +++++++++++++++---------------
 src/tools/tidy/src/style.rs       |  37 ++++-----
 4 files changed, 187 insertions(+), 89 deletions(-)
 create mode 100644 src/tools/tidy/src/diagnostics.rs

diff --git a/src/tools/tidy/src/diagnostics.rs b/src/tools/tidy/src/diagnostics.rs
new file mode 100644
index 0000000000000..a410938400eeb
--- /dev/null
+++ b/src/tools/tidy/src/diagnostics.rs
@@ -0,0 +1,102 @@
+use std::collections::HashSet;
+use std::fmt::Display;
+use std::sync::{Arc, Mutex};
+
+use crate::tidy_error;
+
+/// Collects diagnostics from all tidy steps, and contains shared information
+/// that determines how should message and logs be presented.
+///
+/// Since checks are executed in parallel, the context is internally synchronized, to avoid
+/// all checks to lock it explicitly.
+#[derive(Clone)]
+pub struct DiagCtx(Arc<Mutex<DiagCtxInner>>);
+
+impl DiagCtx {
+    pub fn new(verbose: bool) -> Self {
+        Self(Arc::new(Mutex::new(DiagCtxInner {
+            running_checks: Default::default(),
+            finished_checks: Default::default(),
+            verbose,
+        })))
+    }
+
+    pub fn start_check<T: Display>(&self, name: T) -> RunningCheck {
+        let name = name.to_string();
+
+        let mut ctx = self.0.lock().unwrap();
+        ctx.start_check(&name);
+        RunningCheck { name, bad: false, ctx: self.0.clone() }
+    }
+
+    pub fn into_conclusion(self) -> bool {
+        let ctx = self.0.lock().unwrap();
+        assert!(ctx.running_checks.is_empty(), "Some checks are still running");
+        ctx.finished_checks.iter().any(|c| c.bad)
+    }
+}
+
+struct DiagCtxInner {
+    running_checks: HashSet<String>,
+    finished_checks: HashSet<FinishedCheck>,
+    verbose: bool,
+}
+
+impl DiagCtxInner {
+    fn start_check(&mut self, name: &str) {
+        if self.has_check(name) {
+            panic!("Starting a check named {name} for the second time");
+        }
+        self.running_checks.insert(name.to_string());
+    }
+
+    fn finish_check(&mut self, check: FinishedCheck) {
+        assert!(
+            self.running_checks.remove(&check.name),
+            "Finishing check {} that was not started",
+            check.name
+        );
+        self.finished_checks.insert(check);
+    }
+
+    fn has_check(&self, name: &str) -> bool {
+        self.running_checks
+            .iter()
+            .chain(self.finished_checks.iter().map(|c| &c.name))
+            .any(|c| c == name)
+    }
+}
+
+#[derive(PartialEq, Eq, Hash, Debug)]
+struct FinishedCheck {
+    name: String,
+    bad: bool,
+}
+
+/// Represents a single tidy check, identified by its `name`, running.
+pub struct RunningCheck {
+    name: String,
+    bad: bool,
+    ctx: Arc<Mutex<DiagCtxInner>>,
+}
+
+impl RunningCheck {
+    /// Immediately output an error and mark the check as failed.
+    pub fn error<T: Display>(&mut self, t: T) {
+        self.mark_as_bad();
+        tidy_error(&t.to_string()).expect("failed to output error");
+    }
+
+    fn mark_as_bad(&mut self) {
+        self.bad = true;
+    }
+}
+
+impl Drop for RunningCheck {
+    fn drop(&mut self) {
+        self.ctx
+            .lock()
+            .unwrap()
+            .finish_check(FinishedCheck { name: self.name.clone(), bad: self.bad })
+    }
+}
diff --git a/src/tools/tidy/src/lib.rs b/src/tools/tidy/src/lib.rs
index f7920e3205ab2..953d699199066 100644
--- a/src/tools/tidy/src/lib.rs
+++ b/src/tools/tidy/src/lib.rs
@@ -50,13 +50,6 @@ macro_rules! tidy_error {
     });
 }
 
-macro_rules! tidy_error_ext {
-    ($tidy_error:path, $bad:expr, $($fmt:tt)*) => ({
-        $tidy_error(&format_args!($($fmt)*).to_string()).expect("failed to output error");
-        *$bad = true;
-    });
-}
-
 fn tidy_error(args: &str) -> std::io::Result<()> {
     use std::io::Write;
 
@@ -250,6 +243,7 @@ pub mod alphabetical;
 pub mod bins;
 pub mod debug_artifacts;
 pub mod deps;
+pub mod diagnostics;
 pub mod edition;
 pub mod error_codes;
 pub mod extdeps;
diff --git a/src/tools/tidy/src/main.rs b/src/tools/tidy/src/main.rs
index f9e82341b7aa5..708daffe657ab 100644
--- a/src/tools/tidy/src/main.rs
+++ b/src/tools/tidy/src/main.rs
@@ -9,9 +9,11 @@ use std::num::NonZeroUsize;
 use std::path::PathBuf;
 use std::str::FromStr;
 use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
 use std::thread::{self, ScopedJoinHandle, scope};
 use std::{env, process};
 
+use tidy::diagnostics::DiagCtx;
 use tidy::*;
 
 fn main() {
@@ -54,6 +56,8 @@ fn main() {
     let ci_info = CiInfo::new(&mut bad);
     let bad = std::sync::Arc::new(AtomicBool::new(bad));
 
+    let mut diag_ctx = DiagCtx::new(verbose);
+
     let drain_handles = |handles: &mut VecDeque<ScopedJoinHandle<'_, ()>>| {
         // poll all threads for completion before awaiting the oldest one
         for i in (0..handles.len()).rev() {
@@ -87,76 +91,73 @@ fn main() {
             (@ $p:ident, name=$name:expr $(, $args:expr)* ) => {
                 drain_handles(&mut handles);
 
+                let diag_ctx = diag_ctx.clone();
                 let handle = thread::Builder::new().name($name).spawn_scoped(s, || {
-                    let mut flag = false;
-                    $p::check($($args, )* &mut flag);
-                    if (flag) {
-                        bad.store(true, Ordering::Relaxed);
-                    }
+                    $p::check($($args, )* diag_ctx);
                 }).unwrap();
                 handles.push_back(handle);
             }
         }
 
-        check!(target_specific_tests, &tests_path);
+        // check!(target_specific_tests, &tests_path);
 
         // Checks that are done on the cargo workspace.
-        check!(deps, &root_path, &cargo, bless);
-        check!(extdeps, &root_path);
+        // check!(deps, &root_path, &cargo, bless);
+        // check!(extdeps, &root_path);
 
         // Checks over tests.
-        check!(tests_placement, &root_path);
-        check!(tests_revision_unpaired_stdout_stderr, &tests_path);
-        check!(debug_artifacts, &tests_path);
-        check!(ui_tests, &root_path, bless);
-        check!(mir_opt_tests, &tests_path, bless);
-        check!(rustdoc_gui_tests, &tests_path);
-        check!(rustdoc_css_themes, &librustdoc_path);
-        check!(rustdoc_templates, &librustdoc_path);
-        check!(rustdoc_json, &src_path, &ci_info);
-        check!(known_bug, &crashes_path);
-        check!(unknown_revision, &tests_path);
+        // check!(tests_placement, &root_path);
+        // check!(tests_revision_unpaired_stdout_stderr, &tests_path);
+        // check!(debug_artifacts, &tests_path);
+        // check!(ui_tests, &root_path, bless);
+        // check!(mir_opt_tests, &tests_path, bless);
+        // check!(rustdoc_gui_tests, &tests_path);
+        // check!(rustdoc_css_themes, &librustdoc_path);
+        // check!(rustdoc_templates, &librustdoc_path);
+        // check!(rustdoc_json, &src_path, &ci_info);
+        // check!(known_bug, &crashes_path);
+        // check!(unknown_revision, &tests_path);
 
         // Checks that only make sense for the compiler.
-        check!(error_codes, &root_path, &[&compiler_path, &librustdoc_path], verbose, &ci_info);
-        check!(fluent_alphabetical, &compiler_path, bless);
-        check!(fluent_period, &compiler_path);
-        check!(fluent_lowercase, &compiler_path);
-        check!(target_policy, &root_path);
-        check!(gcc_submodule, &root_path, &compiler_path);
+        // check!(error_codes, &root_path, &[&compiler_path, &librustdoc_path], verbose, &ci_info);
+        // check!(fluent_alphabetical, &compiler_path, bless);
+        // check!(fluent_period, &compiler_path);
+        // check!(fluent_lowercase, &compiler_path);
+        // check!(target_policy, &root_path);
+        // check!(gcc_submodule, &root_path, &compiler_path);
 
         // Checks that only make sense for the std libs.
-        check!(pal, &library_path);
+        // check!(pal, &library_path);
 
         // Checks that need to be done for both the compiler and std libraries.
-        check!(unit_tests, &src_path, false);
-        check!(unit_tests, &compiler_path, false);
-        check!(unit_tests, &library_path, true);
-
-        if bins::check_filesystem_support(&[&root_path], &output_directory) {
-            check!(bins, &root_path);
-        }
+        // check!(unit_tests, &src_path, false);
+        // check!(unit_tests, &compiler_path, false);
+        // check!(unit_tests, &library_path, true);
+        //
+        // if bins::check_filesystem_support(&[&root_path], &output_directory) {
+        //     check!(bins, &root_path);
+        // }
 
         check!(style, &src_path);
         check!(style, &tests_path);
         check!(style, &compiler_path);
         check!(style, &library_path);
 
-        check!(edition, &src_path);
-        check!(edition, &compiler_path);
-        check!(edition, &library_path);
-
-        check!(alphabetical, &root_manifest);
-        check!(alphabetical, &src_path);
-        check!(alphabetical, &tests_path);
-        check!(alphabetical, &compiler_path);
-        check!(alphabetical, &library_path);
-
-        check!(x_version, &root_path, &cargo);
-
-        check!(triagebot, &root_path);
-
-        check!(filenames, &root_path);
+        // check!(edition, &src_path);
+        // check!(edition, &compiler_path);
+        // check!(edition, &library_path);
+        //
+        // check!(alphabetical, &root_manifest);
+        // check!(alphabetical, &src_path);
+        // check!(alphabetical, &tests_path);
+        // check!(alphabetical, &compiler_path);
+        // check!(alphabetical, &library_path);
+        //
+        // check!(x_version, &root_path, &cargo);
+        //
+        // check!(triagebot, &root_path);
+        //
+        // check!(filenames, &root_path);
 
         let collected = {
             drain_handles(&mut handles);
@@ -175,24 +176,24 @@ fn main() {
             }
             r
         };
-        check!(unstable_book, &src_path, collected);
-
-        check!(
-            extra_checks,
-            &root_path,
-            &output_directory,
-            &ci_info,
-            &librustdoc_path,
-            &tools_path,
-            &npm,
-            &cargo,
-            bless,
-            extra_checks,
-            pos_args
-        );
+        // check!(unstable_book, &src_path, collected);
+        //
+        // check!(
+        //     extra_checks,
+        //     &root_path,
+        //     &output_directory,
+        //     &ci_info,
+        //     &librustdoc_path,
+        //     &tools_path,
+        //     &npm,
+        //     &cargo,
+        //     bless,
+        //     extra_checks,
+        //     pos_args
+        // );
     });
 
-    if bad.load(Ordering::Relaxed) {
+    if diag_ctx.into_conclusion() {
         eprintln!("some tidy checks failed");
         process::exit(1);
     }
diff --git a/src/tools/tidy/src/style.rs b/src/tools/tidy/src/style.rs
index fca097c091b75..7d6ebed397fb4 100644
--- a/src/tools/tidy/src/style.rs
+++ b/src/tools/tidy/src/style.rs
@@ -24,6 +24,7 @@ use std::sync::LazyLock;
 use regex::RegexSetBuilder;
 use rustc_hash::FxHashMap;
 
+use crate::diagnostics::DiagCtx;
 use crate::walk::{filter_dirs, walk};
 
 #[cfg(test)]
@@ -338,7 +339,9 @@ fn is_unexplained_ignore(extension: &str, line: &str) -> bool {
     true
 }
 
-pub fn check(path: &Path, bad: &mut bool) {
+pub fn check(path: &Path, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx.start_check(format!("style {}", path.display()));
+
     fn skip(path: &Path, is_dir: bool) -> bool {
         if path.file_name().is_some_and(|name| name.to_string_lossy().starts_with(".#")) {
             // vim or emacs temporary file
@@ -391,7 +394,7 @@ pub fn check(path: &Path, bad: &mut bool) {
             });
 
         if contents.is_empty() {
-            tidy_error!(bad, "{}: empty file", file.display());
+            check.error(format!("{}: empty file", file.display()));
         }
 
         let extension = file.extension().unwrap().to_string_lossy();
@@ -467,7 +470,7 @@ pub fn check(path: &Path, bad: &mut bool) {
             }
 
             let mut err = |msg: &str| {
-                tidy_error!(bad, "{}:{}: {}", file.display(), i + 1, msg);
+                check.error(format!("{}:{}: {msg}", file.display(), i + 1));
             };
 
             if trimmed.contains("dbg!")
@@ -611,7 +614,7 @@ pub fn check(path: &Path, bad: &mut bool) {
                     && backtick_count % 2 == 1
                 {
                     let mut err = |msg: &str| {
-                        tidy_error!(bad, "{}:{start_line}: {msg}", file.display());
+                        check.error(format!("{}:{start_line}: {msg}", file.display()));
                     };
                     let block_len = (i + 1) - start_line;
                     if block_len == 1 {
@@ -632,12 +635,12 @@ pub fn check(path: &Path, bad: &mut bool) {
         }
         if leading_new_lines {
             let mut err = |_| {
-                tidy_error!(bad, "{}: leading newline", file.display());
+                check.error(format!("{}: leading newline", file.display()));
             };
             suppressible_tidy_err!(err, skip_leading_newlines, "missing leading newline");
         }
         let mut err = |msg: &str| {
-            tidy_error!(bad, "{}: {}", file.display(), msg);
+            check.error(format!("{}: {}", file.display(), msg));
         };
         match trailing_new_lines {
             0 => suppressible_tidy_err!(err, skip_trailing_newlines, "missing trailing newline"),
@@ -650,38 +653,36 @@ pub fn check(path: &Path, bad: &mut bool) {
         };
         if lines > LINES {
             let mut err = |_| {
-                tidy_error!(
-                    bad,
-                    "{}: too many lines ({}) (add `// \
+                check.error(format!(
+                    "{}: too many lines ({lines}) (add `// \
                      ignore-tidy-filelength` to the file to suppress this error)",
                     file.display(),
-                    lines
-                );
+                ));
             };
             suppressible_tidy_err!(err, skip_file_length, "");
         }
 
         if let Directive::Ignore(false) = skip_cr {
-            tidy_error!(bad, "{}: ignoring CR characters unnecessarily", file.display());
+            check.error(format!("{}: ignoring CR characters unnecessarily", file.display()));
         }
         if let Directive::Ignore(false) = skip_tab {
-            tidy_error!(bad, "{}: ignoring tab characters unnecessarily", file.display());
+            check.error(format!("{}: ignoring tab characters unnecessarily", file.display()));
         }
         if let Directive::Ignore(false) = skip_end_whitespace {
-            tidy_error!(bad, "{}: ignoring trailing whitespace unnecessarily", file.display());
+            check.error(format!("{}: ignoring trailing whitespace unnecessarily", file.display()));
         }
         if let Directive::Ignore(false) = skip_trailing_newlines {
-            tidy_error!(bad, "{}: ignoring trailing newlines unnecessarily", file.display());
+            check.error(format!("{}: ignoring trailing newlines unnecessarily", file.display()));
         }
         if let Directive::Ignore(false) = skip_leading_newlines {
-            tidy_error!(bad, "{}: ignoring leading newlines unnecessarily", file.display());
+            check.error(format!("{}: ignoring leading newlines unnecessarily", file.display()));
         }
         if let Directive::Ignore(false) = skip_copyright {
-            tidy_error!(bad, "{}: ignoring copyright unnecessarily", file.display());
+            check.error(format!("{}: ignoring copyright unnecessarily", file.display()));
         }
         // We deliberately do not warn about these being unnecessary,
         // that would just lead to annoying churn.
         let _unused = skip_line_length;
         let _unused = skip_file_length;
-    })
+    });
 }

From c36faff900bc03c5c4ee5772dcac4f3630fa2dff Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Mon, 15 Sep 2025 13:24:46 +0200
Subject: [PATCH 1202/1889] Add `CheckId`, migrate the `alphabetical` check to
 diagnostics

---
 src/tools/tidy/src/alphabetical.rs | 31 +++++++--------
 src/tools/tidy/src/diagnostics.rs  | 63 ++++++++++++++++++++----------
 src/tools/tidy/src/main.rs         | 10 ++---
 src/tools/tidy/src/style.rs        |  4 +-
 4 files changed, 63 insertions(+), 45 deletions(-)

diff --git a/src/tools/tidy/src/alphabetical.rs b/src/tools/tidy/src/alphabetical.rs
index 9ddce72510693..f93d3b5611309 100644
--- a/src/tools/tidy/src/alphabetical.rs
+++ b/src/tools/tidy/src/alphabetical.rs
@@ -24,6 +24,7 @@ use std::fmt::Display;
 use std::iter::Peekable;
 use std::path::Path;
 
+use crate::diagnostics::{CheckId, DiagCtx, RunningCheck};
 use crate::walk::{filter_dirs, walk};
 
 #[cfg(test)]
@@ -43,8 +44,7 @@ const END_MARKER: &str = "tidy-alphabetical-end";
 fn check_section<'a>(
     file: impl Display,
     lines: impl Iterator<Item = (usize, &'a str)>,
-    err: &mut dyn FnMut(&str) -> std::io::Result<()>,
-    bad: &mut bool,
+    check: &mut RunningCheck,
 ) {
     let mut prev_line = String::new();
     let mut first_indent = None;
@@ -56,12 +56,10 @@ fn check_section<'a>(
         }
 
         if line.contains(START_MARKER) {
-            tidy_error_ext!(
-                err,
-                bad,
+            check.error(format!(
                 "{file}:{} found `{START_MARKER}` expecting `{END_MARKER}`",
                 idx + 1
-            );
+            ));
             return;
         }
 
@@ -104,45 +102,44 @@ fn check_section<'a>(
         let prev_line_trimmed_lowercase = prev_line.trim_start_matches(' ');
 
         if version_sort(trimmed_line, prev_line_trimmed_lowercase).is_lt() {
-            tidy_error_ext!(err, bad, "{file}:{}: line not in alphabetical order", idx + 1);
+            check.error(format!("{file}:{}: line not in alphabetical order", idx + 1));
         }
 
         prev_line = line;
     }
 
-    tidy_error_ext!(err, bad, "{file}: reached end of file expecting `{END_MARKER}`")
+    check.error(format!("{file}: reached end of file expecting `{END_MARKER}`"));
 }
 
 fn check_lines<'a>(
     file: &impl Display,
     mut lines: impl Iterator<Item = (usize, &'a str)>,
-    err: &mut dyn FnMut(&str) -> std::io::Result<()>,
-    bad: &mut bool,
+    check: &mut RunningCheck,
 ) {
     while let Some((idx, line)) = lines.next() {
         if line.contains(END_MARKER) {
-            tidy_error_ext!(
-                err,
-                bad,
+            check.error(format!(
                 "{file}:{} found `{END_MARKER}` expecting `{START_MARKER}`",
                 idx + 1
-            )
+            ));
         }
 
         if line.contains(START_MARKER) {
-            check_section(file, &mut lines, err, bad);
+            check_section(file, &mut lines, check);
         }
     }
 }
 
-pub fn check(path: &Path, bad: &mut bool) {
+pub fn check(path: &Path, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx.start_check(CheckId::new("alphabetical").path(path));
+
     let skip =
         |path: &_, _is_dir| filter_dirs(path) || path.ends_with("tidy/src/alphabetical/tests.rs");
 
     walk(path, skip, &mut |entry, contents| {
         let file = &entry.path().display();
         let lines = contents.lines().enumerate();
-        check_lines(file, lines, &mut crate::tidy_error, bad)
+        check_lines(file, lines, &mut check)
     });
 }
 
diff --git a/src/tools/tidy/src/diagnostics.rs b/src/tools/tidy/src/diagnostics.rs
index a410938400eeb..ae20f92715c06 100644
--- a/src/tools/tidy/src/diagnostics.rs
+++ b/src/tools/tidy/src/diagnostics.rs
@@ -1,5 +1,6 @@
 use std::collections::HashSet;
 use std::fmt::Display;
+use std::path::{Path, PathBuf};
 use std::sync::{Arc, Mutex};
 
 use crate::tidy_error;
@@ -21,12 +22,12 @@ impl DiagCtx {
         })))
     }
 
-    pub fn start_check<T: Display>(&self, name: T) -> RunningCheck {
-        let name = name.to_string();
+    pub fn start_check<Id: Into<CheckId>>(&self, id: Id) -> RunningCheck {
+        let id = id.into();
 
         let mut ctx = self.0.lock().unwrap();
-        ctx.start_check(&name);
-        RunningCheck { name, bad: false, ctx: self.0.clone() }
+        ctx.start_check(id.clone());
+        RunningCheck { id, bad: false, ctx: self.0.clone() }
     }
 
     pub fn into_conclusion(self) -> bool {
@@ -37,45 +38,68 @@ impl DiagCtx {
 }
 
 struct DiagCtxInner {
-    running_checks: HashSet<String>,
+    running_checks: HashSet<CheckId>,
     finished_checks: HashSet<FinishedCheck>,
     verbose: bool,
 }
 
 impl DiagCtxInner {
-    fn start_check(&mut self, name: &str) {
-        if self.has_check(name) {
-            panic!("Starting a check named {name} for the second time");
+    fn start_check(&mut self, id: CheckId) {
+        if self.has_check_id(&id) {
+            panic!("Starting a check named `{id:?}` for the second time");
         }
-        self.running_checks.insert(name.to_string());
+        self.running_checks.insert(id);
     }
 
     fn finish_check(&mut self, check: FinishedCheck) {
         assert!(
-            self.running_checks.remove(&check.name),
-            "Finishing check {} that was not started",
-            check.name
+            self.running_checks.remove(&check.id),
+            "Finishing check `{:?}` that was not started",
+            check.id
         );
         self.finished_checks.insert(check);
     }
 
-    fn has_check(&self, name: &str) -> bool {
+    fn has_check_id(&self, id: &CheckId) -> bool {
         self.running_checks
             .iter()
-            .chain(self.finished_checks.iter().map(|c| &c.name))
-            .any(|c| c == name)
+            .chain(self.finished_checks.iter().map(|c| &c.id))
+            .any(|c| c == id)
+    }
+}
+
+/// Identifies a single step
+#[derive(PartialEq, Eq, Hash, Clone, Debug)]
+pub struct CheckId {
+    name: String,
+    path: Option<PathBuf>,
+}
+
+impl CheckId {
+    pub fn new(name: &'static str) -> Self {
+        Self { name: name.to_string(), path: None }
+    }
+
+    pub fn path(self, path: &Path) -> Self {
+        Self { path: Some(path.to_path_buf()), ..self }
+    }
+}
+
+impl From<&'static str> for CheckId {
+    fn from(name: &'static str) -> Self {
+        Self::new(name)
     }
 }
 
 #[derive(PartialEq, Eq, Hash, Debug)]
 struct FinishedCheck {
-    name: String,
+    id: CheckId,
     bad: bool,
 }
 
 /// Represents a single tidy check, identified by its `name`, running.
 pub struct RunningCheck {
-    name: String,
+    id: CheckId,
     bad: bool,
     ctx: Arc<Mutex<DiagCtxInner>>,
 }
@@ -94,9 +118,6 @@ impl RunningCheck {
 
 impl Drop for RunningCheck {
     fn drop(&mut self) {
-        self.ctx
-            .lock()
-            .unwrap()
-            .finish_check(FinishedCheck { name: self.name.clone(), bad: self.bad })
+        self.ctx.lock().unwrap().finish_check(FinishedCheck { id: self.id.clone(), bad: self.bad })
     }
 }
diff --git a/src/tools/tidy/src/main.rs b/src/tools/tidy/src/main.rs
index 708daffe657ab..7d42102bbb9d0 100644
--- a/src/tools/tidy/src/main.rs
+++ b/src/tools/tidy/src/main.rs
@@ -147,11 +147,11 @@ fn main() {
         // check!(edition, &compiler_path);
         // check!(edition, &library_path);
         //
-        // check!(alphabetical, &root_manifest);
-        // check!(alphabetical, &src_path);
-        // check!(alphabetical, &tests_path);
-        // check!(alphabetical, &compiler_path);
-        // check!(alphabetical, &library_path);
+        check!(alphabetical, &root_manifest);
+        check!(alphabetical, &src_path);
+        check!(alphabetical, &tests_path);
+        check!(alphabetical, &compiler_path);
+        check!(alphabetical, &library_path);
         //
         // check!(x_version, &root_path, &cargo);
         //
diff --git a/src/tools/tidy/src/style.rs b/src/tools/tidy/src/style.rs
index 7d6ebed397fb4..d17278edc849a 100644
--- a/src/tools/tidy/src/style.rs
+++ b/src/tools/tidy/src/style.rs
@@ -24,7 +24,7 @@ use std::sync::LazyLock;
 use regex::RegexSetBuilder;
 use rustc_hash::FxHashMap;
 
-use crate::diagnostics::DiagCtx;
+use crate::diagnostics::{CheckId, DiagCtx};
 use crate::walk::{filter_dirs, walk};
 
 #[cfg(test)]
@@ -340,7 +340,7 @@ fn is_unexplained_ignore(extension: &str, line: &str) -> bool {
 }
 
 pub fn check(path: &Path, diag_ctx: DiagCtx) {
-    let mut check = diag_ctx.start_check(format!("style {}", path.display()));
+    let mut check = diag_ctx.start_check(CheckId::new("style").path(path));
 
     fn skip(path: &Path, is_dir: bool) -> bool {
         if path.file_name().is_some_and(|name| name.to_string_lossy().starts_with(".#")) {

From 352fa3960a00046ff81bd2e0528c51371e5c6c1d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Mon, 15 Sep 2025 13:26:29 +0200
Subject: [PATCH 1203/1889] Migrate the remaining tidy checks to diagnostics

---
 src/tools/tidy/src/bins.rs                    |  14 +-
 src/tools/tidy/src/debug_artifacts.rs         |  15 +-
 src/tools/tidy/src/deps.rs                    | 115 +++++++--------
 src/tools/tidy/src/diagnostics.rs             |  44 +++++-
 src/tools/tidy/src/edition.rs                 |   9 +-
 src/tools/tidy/src/error_codes.rs             | 124 +++++++---------
 src/tools/tidy/src/extdeps.rs                 |   9 +-
 src/tools/tidy/src/extra_checks/mod.rs        |   7 +-
 src/tools/tidy/src/features.rs                | 132 ++++++++----------
 src/tools/tidy/src/filenames.rs               |  20 +--
 src/tools/tidy/src/fluent_alphabetical.rs     |  36 +++--
 src/tools/tidy/src/fluent_lowercase.rs        |  13 +-
 src/tools/tidy/src/fluent_period.rs           |  13 +-
 src/tools/tidy/src/fluent_used.rs             |   7 +-
 src/tools/tidy/src/gcc_submodule.rs           |  13 +-
 src/tools/tidy/src/known_bug.rs               |   9 +-
 src/tools/tidy/src/lib.rs                     |  43 ++----
 src/tools/tidy/src/main.rs                    | 128 ++++++++---------
 src/tools/tidy/src/mir_opt_tests.rs           |  23 +--
 src/tools/tidy/src/pal.rs                     |  11 +-
 src/tools/tidy/src/rustdoc_css_themes.rs      |  37 ++---
 src/tools/tidy/src/rustdoc_gui_tests.rs       |  11 +-
 src/tools/tidy/src/rustdoc_json.rs            |  42 +++---
 src/tools/tidy/src/rustdoc_templates.rs       |  15 +-
 src/tools/tidy/src/target_policy.rs           |   7 +-
 src/tools/tidy/src/target_specific_tests.rs   |  23 ++-
 src/tools/tidy/src/tests_placement.rs         |  17 ++-
 .../tests_revision_unpaired_stdout_stderr.rs  |  16 ++-
 src/tools/tidy/src/triagebot.rs               |  38 +++--
 src/tools/tidy/src/ui_tests.rs                |  53 ++++---
 src/tools/tidy/src/unit_tests.rs              |  14 +-
 src/tools/tidy/src/unknown_revision.rs        |  17 +--
 src/tools/tidy/src/unstable_book.rs           |  40 +++---
 src/tools/tidy/src/x_version.rs               |  17 ++-
 34 files changed, 560 insertions(+), 572 deletions(-)

diff --git a/src/tools/tidy/src/bins.rs b/src/tools/tidy/src/bins.rs
index a18f549844b86..10b6186997167 100644
--- a/src/tools/tidy/src/bins.rs
+++ b/src/tools/tidy/src/bins.rs
@@ -12,11 +12,13 @@ pub use os_impl::*;
 mod os_impl {
     use std::path::Path;
 
+    use crate::diagnostics::DiagCtx;
+
     pub fn check_filesystem_support(_sources: &[&Path], _output: &Path) -> bool {
         return false;
     }
 
-    pub fn check(_path: &Path, _bad: &mut bool) {}
+    pub fn check(_path: &Path, _diag_ctx: DiagCtx) {}
 }
 
 #[cfg(unix)]
@@ -36,6 +38,8 @@ mod os_impl {
 
     use FilesystemSupport::*;
 
+    use crate::diagnostics::DiagCtx;
+
     fn is_executable(path: &Path) -> std::io::Result<bool> {
         Ok(path.metadata()?.mode() & 0o111 != 0)
     }
@@ -106,14 +110,16 @@ mod os_impl {
     }
 
     #[cfg(unix)]
-    pub fn check(path: &Path, bad: &mut bool) {
+    pub fn check(path: &Path, diag_ctx: DiagCtx) {
+        let mut check = diag_ctx.start_check("bins");
+
         use std::ffi::OsStr;
 
         const ALLOWED: &[&str] = &["configure", "x"];
 
         for p in RI_EXCLUSION_LIST {
             if !path.join(Path::new(p)).exists() {
-                tidy_error!(bad, "rust-installer test bins missed: {p}");
+                check.error(format!("rust-installer test bins missed: {p}"));
             }
         }
 
@@ -153,7 +159,7 @@ mod os_impl {
                         });
                     let path_bytes = rel_path.as_os_str().as_bytes();
                     if output.status.success() && output.stdout.starts_with(path_bytes) {
-                        tidy_error!(bad, "binary checked into source: {}", file.display());
+                        check.error(format!("binary checked into source: {}", file.display()));
                     }
                 }
             },
diff --git a/src/tools/tidy/src/debug_artifacts.rs b/src/tools/tidy/src/debug_artifacts.rs
index 645534cc82738..19effaede817b 100644
--- a/src/tools/tidy/src/debug_artifacts.rs
+++ b/src/tools/tidy/src/debug_artifacts.rs
@@ -2,24 +2,25 @@
 
 use std::path::Path;
 
+use crate::diagnostics::{CheckId, DiagCtx};
 use crate::walk::{filter_dirs, filter_not_rust, walk};
 
 const GRAPHVIZ_POSTFLOW_MSG: &str = "`borrowck_graphviz_postflow` attribute in test";
 
-pub fn check(test_dir: &Path, bad: &mut bool) {
+pub fn check(test_dir: &Path, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx.start_check(CheckId::new("debug_artifacts").path(test_dir));
+
     walk(
         test_dir,
         |path, _is_dir| filter_dirs(path) || filter_not_rust(path),
         &mut |entry, contents| {
             for (i, line) in contents.lines().enumerate() {
                 if line.contains("borrowck_graphviz_postflow") {
-                    tidy_error!(
-                        bad,
-                        "{}:{}: {}",
+                    check.error(format!(
+                        "{}:{}: {GRAPHVIZ_POSTFLOW_MSG}",
                         entry.path().display(),
-                        i + 1,
-                        GRAPHVIZ_POSTFLOW_MSG
-                    );
+                        i + 1
+                    ));
                 }
             }
         },
diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs
index 568ec0c119896..a9d07c7531579 100644
--- a/src/tools/tidy/src/deps.rs
+++ b/src/tools/tidy/src/deps.rs
@@ -9,6 +9,8 @@ use build_helper::ci::CiEnv;
 use cargo_metadata::semver::Version;
 use cargo_metadata::{Metadata, Package, PackageId};
 
+use crate::diagnostics::{CheckId, DiagCtx, RunningCheck};
+
 #[path = "../../../bootstrap/src/utils/proc_macro_deps.rs"]
 mod proc_macro_deps;
 
@@ -661,10 +663,12 @@ const PERMITTED_CRANELIFT_DEPENDENCIES: &[&str] = &[
 ///
 /// `root` is path to the directory with the root `Cargo.toml` (for the workspace). `cargo` is path
 /// to the cargo executable.
-pub fn check(root: &Path, cargo: &Path, bless: bool, bad: &mut bool) {
+pub fn check(root: &Path, cargo: &Path, bless: bool, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx.start_check(CheckId::new("deps").path(root));
+
     let mut checked_runtime_licenses = false;
 
-    check_proc_macro_dep_list(root, cargo, bless, bad);
+    check_proc_macro_dep_list(root, cargo, bless, &mut check);
 
     for &WorkspaceInfo { path, exceptions, crates_and_deps, submodules } in WORKSPACES {
         if has_missing_submodule(root, submodules) {
@@ -672,7 +676,7 @@ pub fn check(root: &Path, cargo: &Path, bless: bool, bad: &mut bool) {
         }
 
         if !root.join(path).join("Cargo.lock").exists() {
-            tidy_error!(bad, "the `{path}` workspace doesn't have a Cargo.lock");
+            check.error(format!("the `{path}` workspace doesn't have a Cargo.lock"));
             continue;
         }
 
@@ -683,16 +687,23 @@ pub fn check(root: &Path, cargo: &Path, bless: bool, bad: &mut bool) {
             .other_options(vec!["--locked".to_owned()]);
         let metadata = t!(cmd.exec());
 
-        check_license_exceptions(&metadata, path, exceptions, bad);
+        check_license_exceptions(&metadata, path, exceptions, &mut check);
         if let Some((crates, permitted_deps, location)) = crates_and_deps {
             let descr = crates.get(0).unwrap_or(&path);
-            check_permitted_dependencies(&metadata, descr, permitted_deps, crates, location, bad);
+            check_permitted_dependencies(
+                &metadata,
+                descr,
+                permitted_deps,
+                crates,
+                location,
+                &mut check,
+            );
         }
 
         if path == "library" {
-            check_runtime_license_exceptions(&metadata, bad);
-            check_runtime_no_duplicate_dependencies(&metadata, bad);
-            check_runtime_no_proc_macros(&metadata, bad);
+            check_runtime_license_exceptions(&metadata, &mut check);
+            check_runtime_no_duplicate_dependencies(&metadata, &mut check);
+            check_runtime_no_proc_macros(&metadata, &mut check);
             checked_runtime_licenses = true;
         }
     }
@@ -703,7 +714,7 @@ pub fn check(root: &Path, cargo: &Path, bless: bool, bad: &mut bool) {
 }
 
 /// Ensure the list of proc-macro crate transitive dependencies is up to date
-fn check_proc_macro_dep_list(root: &Path, cargo: &Path, bless: bool, bad: &mut bool) {
+fn check_proc_macro_dep_list(root: &Path, cargo: &Path, bless: bool, check: &mut RunningCheck) {
     let mut cmd = cargo_metadata::MetadataCommand::new();
     cmd.cargo_path(cargo)
         .manifest_path(root.join("Cargo.toml"))
@@ -750,22 +761,22 @@ pub static CRATES: &[&str] = &[
         )
         .unwrap();
     } else {
-        let old_bad = *bad;
+        let mut error_found = false;
 
         for missing in proc_macro_deps.difference(&expected) {
-            tidy_error!(
-                bad,
+            error_found = true;
+            check.error(format!(
                 "proc-macro crate dependency `{missing}` is not registered in `src/bootstrap/src/utils/proc_macro_deps.rs`",
-            );
+            ));
         }
         for extra in expected.difference(&proc_macro_deps) {
-            tidy_error!(
-                bad,
+            error_found = true;
+            check.error(format!(
                 "`{extra}` is registered in `src/bootstrap/src/utils/proc_macro_deps.rs`, but is not a proc-macro crate dependency",
-            );
+            ));
         }
-        if *bad != old_bad {
-            eprintln!("Run `./x.py test tidy --bless` to regenerate the list");
+        if error_found {
+            check.message("Run `./x.py test tidy --bless` to regenerate the list");
         }
     }
 }
@@ -787,7 +798,7 @@ pub fn has_missing_submodule(root: &Path, submodules: &[&str]) -> bool {
 ///
 /// Unlike for tools we don't allow exceptions to the `LICENSES` list for the runtime with the sole
 /// exception of `fortanix-sgx-abi` which is only used on x86_64-fortanix-unknown-sgx.
-fn check_runtime_license_exceptions(metadata: &Metadata, bad: &mut bool) {
+fn check_runtime_license_exceptions(metadata: &Metadata, check: &mut RunningCheck) {
     for pkg in &metadata.packages {
         if pkg.source.is_none() {
             // No need to check local packages.
@@ -796,7 +807,8 @@ fn check_runtime_license_exceptions(metadata: &Metadata, bad: &mut bool) {
         let license = match &pkg.license {
             Some(license) => license,
             None => {
-                tidy_error!(bad, "dependency `{}` does not define a license expression", pkg.id);
+                check
+                    .error(format!("dependency `{}` does not define a license expression", pkg.id));
                 continue;
             }
         };
@@ -809,7 +821,7 @@ fn check_runtime_license_exceptions(metadata: &Metadata, bad: &mut bool) {
                 continue;
             }
 
-            tidy_error!(bad, "invalid license `{}` in `{}`", license, pkg.id);
+            check.error(format!("invalid license `{}` in `{}`", license, pkg.id));
         }
     }
 }
@@ -821,37 +833,32 @@ fn check_license_exceptions(
     metadata: &Metadata,
     workspace: &str,
     exceptions: &[(&str, &str)],
-    bad: &mut bool,
+    check: &mut RunningCheck,
 ) {
     // Validate the EXCEPTIONS list hasn't changed.
     for (name, license) in exceptions {
         // Check that the package actually exists.
         if !metadata.packages.iter().any(|p| *p.name == *name) {
-            tidy_error!(
-                bad,
-                "could not find exception package `{}` in workspace `{workspace}`\n\
+            check.error(format!(
+                "could not find exception package `{name}` in workspace `{workspace}`\n\
                 Remove from EXCEPTIONS list if it is no longer used.",
-                name
-            );
+            ));
         }
         // Check that the license hasn't changed.
         for pkg in metadata.packages.iter().filter(|p| *p.name == *name) {
             match &pkg.license {
                 None => {
-                    tidy_error!(
-                        bad,
+                    check.error(format!(
                         "dependency exception `{}` in workspace `{workspace}` does not declare a license expression",
                         pkg.id
-                    );
+                    ));
                 }
                 Some(pkg_license) => {
                     if pkg_license.as_str() != *license {
-                        println!(
-                            "dependency exception `{name}` license in workspace `{workspace}` has changed"
-                        );
-                        println!("    previously `{license}` now `{pkg_license}`");
-                        println!("    update EXCEPTIONS for the new license");
-                        *bad = true;
+                        check.error(format!(r#"dependency exception `{name}` license in workspace `{workspace}` has changed
+    previously `{license}` now `{pkg_license}`
+    update EXCEPTIONS for the new license
+"#));
                     }
                 }
             }
@@ -872,26 +879,23 @@ fn check_license_exceptions(
         let license = match &pkg.license {
             Some(license) => license,
             None => {
-                tidy_error!(
-                    bad,
+                check.error(format!(
                     "dependency `{}` in workspace `{workspace}` does not define a license expression",
                     pkg.id
-                );
+                ));
                 continue;
             }
         };
         if !LICENSES.contains(&license.as_str()) {
-            tidy_error!(
-                bad,
+            check.error(format!(
                 "invalid license `{}` for package `{}` in workspace `{workspace}`",
-                license,
-                pkg.id
-            );
+                license, pkg.id
+            ));
         }
     }
 }
 
-fn check_runtime_no_duplicate_dependencies(metadata: &Metadata, bad: &mut bool) {
+fn check_runtime_no_duplicate_dependencies(metadata: &Metadata, check: &mut RunningCheck) {
     let mut seen_pkgs = HashSet::new();
     for pkg in &metadata.packages {
         if pkg.source.is_none() {
@@ -902,25 +906,23 @@ fn check_runtime_no_duplicate_dependencies(metadata: &Metadata, bad: &mut bool)
         // depends on two version of (one for the `wasm32-wasip1` target and
         // another for the `wasm32-wasip2` target).
         if pkg.name.to_string() != "wasi" && !seen_pkgs.insert(&*pkg.name) {
-            tidy_error!(
-                bad,
+            check.error(format!(
                 "duplicate package `{}` is not allowed for the standard library",
                 pkg.name
-            );
+            ));
         }
     }
 }
 
-fn check_runtime_no_proc_macros(metadata: &Metadata, bad: &mut bool) {
+fn check_runtime_no_proc_macros(metadata: &Metadata, check: &mut RunningCheck) {
     for pkg in &metadata.packages {
         if pkg.targets.iter().any(|target| target.is_proc_macro()) {
-            tidy_error!(
-                bad,
+            check.error(format!(
                 "proc macro `{}` is not allowed as standard library dependency.\n\
                 Using proc macros in the standard library would break cross-compilation \
                 as proc-macros don't get shipped for the host tuple.",
                 pkg.name
-            );
+            ));
         }
     }
 }
@@ -935,7 +937,7 @@ fn check_permitted_dependencies(
     permitted_dependencies: &[&'static str],
     restricted_dependency_crates: &[&'static str],
     permitted_location: ListLocation,
-    bad: &mut bool,
+    check: &mut RunningCheck,
 ) {
     let mut has_permitted_dep_error = false;
     let mut deps = HashSet::new();
@@ -957,11 +959,10 @@ fn check_permitted_dependencies(
             }
         }
         if !deps.iter().any(|dep_id| compare(pkg_from_id(metadata, dep_id), permitted)) {
-            tidy_error!(
-                bad,
+            check.error(format!(
                 "could not find allowed package `{permitted}`\n\
                 Remove from PERMITTED_DEPENDENCIES list if it is no longer used.",
-            );
+            ));
             has_permitted_dep_error = true;
         }
     }
@@ -988,7 +989,7 @@ fn check_permitted_dependencies(
                 false
             };
             if !is_eq {
-                tidy_error!(bad, "Dependency for {descr} not explicitly permitted: {}", dep.id);
+                check.error(format!("Dependency for {descr} not explicitly permitted: {}", dep.id));
                 has_permitted_dep_error = true;
             }
         }
diff --git a/src/tools/tidy/src/diagnostics.rs b/src/tools/tidy/src/diagnostics.rs
index ae20f92715c06..d7889f925ea91 100644
--- a/src/tools/tidy/src/diagnostics.rs
+++ b/src/tools/tidy/src/diagnostics.rs
@@ -3,7 +3,7 @@ use std::fmt::Display;
 use std::path::{Path, PathBuf};
 use std::sync::{Arc, Mutex};
 
-use crate::tidy_error;
+use termcolor::WriteColor;
 
 /// Collects diagnostics from all tidy steps, and contains shared information
 /// that determines how should message and logs be presented.
@@ -111,6 +111,33 @@ impl RunningCheck {
         tidy_error(&t.to_string()).expect("failed to output error");
     }
 
+    /// Immediately output a warning.
+    pub fn warning<T: Display>(&mut self, t: T) {
+        eprintln!("WARNING: {t}");
+    }
+
+    /// Output an informational message
+    pub fn message<T: Display>(&mut self, t: T) {
+        eprintln!("{t}");
+    }
+
+    /// Output a message only if verbose output is enabled.
+    pub fn verbose_msg<T: Display>(&mut self, t: T) {
+        if self.is_verbose_enabled() {
+            self.message(t);
+        }
+    }
+
+    /// Has an error already occured for this check?
+    pub fn is_bad(&self) -> bool {
+        self.bad
+    }
+
+    /// Is verbose output enabled?
+    pub fn is_verbose_enabled(&self) -> bool {
+        self.ctx.lock().unwrap().verbose
+    }
+
     fn mark_as_bad(&mut self) {
         self.bad = true;
     }
@@ -121,3 +148,18 @@ impl Drop for RunningCheck {
         self.ctx.lock().unwrap().finish_check(FinishedCheck { id: self.id.clone(), bad: self.bad })
     }
 }
+
+fn tidy_error(args: &str) -> std::io::Result<()> {
+    use std::io::Write;
+
+    use termcolor::{Color, ColorChoice, ColorSpec, StandardStream};
+
+    let mut stderr = StandardStream::stdout(ColorChoice::Auto);
+    stderr.set_color(ColorSpec::new().set_fg(Some(Color::Red)))?;
+
+    write!(&mut stderr, "tidy error")?;
+    stderr.set_color(&ColorSpec::new())?;
+
+    writeln!(&mut stderr, ": {args}")?;
+    Ok(())
+}
diff --git a/src/tools/tidy/src/edition.rs b/src/tools/tidy/src/edition.rs
index 08f6a3909f806..448e0b0e0a8c6 100644
--- a/src/tools/tidy/src/edition.rs
+++ b/src/tools/tidy/src/edition.rs
@@ -2,9 +2,11 @@
 
 use std::path::Path;
 
+use crate::diagnostics::{CheckId, DiagCtx};
 use crate::walk::{filter_dirs, walk};
 
-pub fn check(path: &Path, bad: &mut bool) {
+pub fn check(path: &Path, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx.start_check(CheckId::new("edition").path(path));
     walk(path, |path, _is_dir| filter_dirs(path), &mut |entry, contents| {
         let file = entry.path();
         let filename = file.file_name().unwrap();
@@ -23,11 +25,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_current_edition {
-            tidy_error!(
-                bad,
+            check.error(format!(
                 "{} doesn't have `edition = \"2021\"` or `edition = \"2024\"` on a separate line",
                 file.display()
-            );
+            ));
         }
     });
 }
diff --git a/src/tools/tidy/src/error_codes.rs b/src/tools/tidy/src/error_codes.rs
index 65aa89fe80169..83fbefa43d975 100644
--- a/src/tools/tidy/src/error_codes.rs
+++ b/src/tools/tidy/src/error_codes.rs
@@ -22,6 +22,7 @@ use std::path::Path;
 
 use regex::Regex;
 
+use crate::diagnostics::{DiagCtx, RunningCheck};
 use crate::walk::{filter_dirs, walk, walk_many};
 
 const ERROR_CODES_PATH: &str = "compiler/rustc_error_codes/src/lib.rs";
@@ -35,71 +36,50 @@ const IGNORE_DOCTEST_CHECK: &[&str] = &["E0464", "E0570", "E0601", "E0602", "E07
 const IGNORE_UI_TEST_CHECK: &[&str] =
     &["E0461", "E0465", "E0514", "E0554", "E0640", "E0717", "E0729"];
 
-macro_rules! verbose_print {
-    ($verbose:expr, $($fmt:tt)*) => {
-        if $verbose {
-            println!("{}", format_args!($($fmt)*));
-        }
-    };
-}
-
-pub fn check(
-    root_path: &Path,
-    search_paths: &[&Path],
-    verbose: bool,
-    ci_info: &crate::CiInfo,
-    bad: &mut bool,
-) {
-    let mut errors = Vec::new();
+pub fn check(root_path: &Path, search_paths: &[&Path], ci_info: &crate::CiInfo, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx.start_check("error_codes");
 
     // Check that no error code explanation was removed.
-    check_removed_error_code_explanation(ci_info, bad);
+    check_removed_error_code_explanation(ci_info, &mut check);
 
     // Stage 1: create list
-    let error_codes = extract_error_codes(root_path, &mut errors);
-    if verbose {
-        println!("Found {} error codes", error_codes.len());
-        println!("Highest error code: `{}`", error_codes.iter().max().unwrap());
-    }
+    let error_codes = extract_error_codes(root_path, &mut check);
+    check.verbose_msg(format!("Found {} error codes", error_codes.len()));
+    check.verbose_msg(format!("Highest error code: `{}`", error_codes.iter().max().unwrap()));
 
     // Stage 2: check list has docs
-    let no_longer_emitted = check_error_codes_docs(root_path, &error_codes, &mut errors, verbose);
+    let no_longer_emitted = check_error_codes_docs(root_path, &error_codes, &mut check);
 
     // Stage 3: check list has UI tests
-    check_error_codes_tests(root_path, &error_codes, &mut errors, verbose, &no_longer_emitted);
+    check_error_codes_tests(root_path, &error_codes, &mut check, &no_longer_emitted);
 
     // Stage 4: check list is emitted by compiler
-    check_error_codes_used(search_paths, &error_codes, &mut errors, &no_longer_emitted, verbose);
-
-    // Print any errors.
-    for error in errors {
-        tidy_error!(bad, "{}", error);
-    }
+    check_error_codes_used(search_paths, &error_codes, &mut check, &no_longer_emitted);
 }
 
-fn check_removed_error_code_explanation(ci_info: &crate::CiInfo, bad: &mut bool) {
+fn check_removed_error_code_explanation(ci_info: &crate::CiInfo, check: &mut RunningCheck) {
     let Some(base_commit) = &ci_info.base_commit else {
-        eprintln!("Skipping error code explanation removal check");
+        check.verbose_msg("Skipping error code explanation removal check");
         return;
     };
     let Some(diff) = crate::git_diff(base_commit, "--name-status") else {
-        *bad = true;
-        eprintln!("removed error code explanation tidy check: Failed to run git diff");
+        check.error(format!("removed error code explanation: Failed to run git diff"));
         return;
     };
     if diff.lines().any(|line| {
         line.starts_with('D') && line.contains("compiler/rustc_error_codes/src/error_codes/")
     }) {
-        *bad = true;
-        eprintln!("tidy check error: Error code explanations should never be removed!");
-        eprintln!("Take a look at E0001 to see how to handle it.");
+        check.error(format!(
+            r#"Error code explanations should never be removed!
+Take a look at E0001 to see how to handle it."#
+        ));
         return;
     }
-    println!("No error code explanation was removed!");
+    check.verbose_msg("No error code explanation was removed!");
 }
 
 /// Stage 1: Parses a list of error codes from `error_codes.rs`.
-fn extract_error_codes(root_path: &Path, errors: &mut Vec<String>) -> Vec<String> {
+fn extract_error_codes(root_path: &Path, check: &mut RunningCheck) -> Vec<String> {
     let path = root_path.join(Path::new(ERROR_CODES_PATH));
     let file =
         fs::read_to_string(&path).unwrap_or_else(|e| panic!("failed to read `{path:?}`: {e}"));
@@ -117,7 +97,7 @@ fn extract_error_codes(root_path: &Path, errors: &mut Vec<String>) -> Vec<String
             // Extract the error code from the line. Emit a fatal error if it is not in the correct
             // format.
             let Some(split_line) = split_line else {
-                errors.push(format!(
+                check.error(format!(
                     "{path}:{line_index}: Expected a line with the format `Eabcd: abcd, \
                     but got \"{line}\" without a `:` delimiter",
                 ));
@@ -128,8 +108,9 @@ fn extract_error_codes(root_path: &Path, errors: &mut Vec<String>) -> Vec<String
 
             // If this is a duplicate of another error code, emit a fatal error.
             if error_codes.contains(&err_code) {
-                errors
-                    .push(format!("{path}:{line_index}: Found duplicate error code: `{err_code}`"));
+                check.error(format!(
+                    "{path}:{line_index}: Found duplicate error code: `{err_code}`"
+                ));
                 continue;
             }
 
@@ -140,14 +121,14 @@ fn extract_error_codes(root_path: &Path, errors: &mut Vec<String>) -> Vec<String
             // Ensure that the line references the correct markdown file.
             let rest = split_line.1.split_once(',');
             let Some(rest) = rest else {
-                errors.push(format!(
+                check.error(format!(
                     "{path}:{line_index}: Expected a line with the format `Eabcd: abcd, \
                     but got \"{line}\" without a `,` delimiter",
                 ));
                 continue;
             };
             if error_num_as_str != rest.0.trim() {
-                errors.push(format!(
+                check.error(format!(
                     "{path}:{line_index}: `{}:` should be followed by `{},` but instead found `{}` in \
                     `compiler/rustc_error_codes/src/lib.rs`",
                     err_code,
@@ -157,7 +138,7 @@ fn extract_error_codes(root_path: &Path, errors: &mut Vec<String>) -> Vec<String
                 continue;
             }
             if !rest.1.trim().is_empty() && !rest.1.trim().starts_with("//") {
-                errors.push(format!("{path}:{line_index}: should only have one error per line"));
+                check.error(format!("{path}:{line_index}: should only have one error per line"));
                 continue;
             }
 
@@ -172,8 +153,7 @@ fn extract_error_codes(root_path: &Path, errors: &mut Vec<String>) -> Vec<String
 fn check_error_codes_docs(
     root_path: &Path,
     error_codes: &[String],
-    errors: &mut Vec<String>,
-    verbose: bool,
+    check: &mut RunningCheck,
 ) -> Vec<String> {
     let docs_path = root_path.join(Path::new(ERROR_DOCS_PATH));
 
@@ -184,7 +164,7 @@ fn check_error_codes_docs(
 
         // Error if the file isn't markdown.
         if path.extension() != Some(OsStr::new("md")) {
-            errors.push(format!(
+            check.error(format!(
                 "Found unexpected non-markdown file in error code docs directory: {}",
                 path.display()
             ));
@@ -196,7 +176,7 @@ fn check_error_codes_docs(
         let err_code = filename.unwrap().0; // `unwrap` is ok because we know the filename is in the correct format.
 
         if error_codes.iter().all(|e| e != err_code) {
-            errors.push(format!(
+            check.error(format!(
                 "Found valid file `{}` in error code docs directory without corresponding \
                 entry in `rustc_error_codes/src/lib.rs`",
                 path.display()
@@ -208,11 +188,10 @@ fn check_error_codes_docs(
             check_explanation_has_doctest(contents, err_code);
 
         if emit_ignore_warning {
-            verbose_print!(
-                verbose,
+            check.verbose_msg(format!(
                 "warning: Error code `{err_code}` uses the ignore header. This should not be used, add the error code to the \
                 `IGNORE_DOCTEST_CHECK` constant instead."
-            );
+            ));
         }
 
         if no_longer_emitted {
@@ -220,11 +199,10 @@ fn check_error_codes_docs(
         }
 
         if !found_code_example {
-            verbose_print!(
-                verbose,
+            check.verbose_msg(format!(
                 "warning: Error code `{err_code}` doesn't have a code example, all error codes are expected to have one \
                 (even if untested)."
-            );
+            ));
             return;
         }
 
@@ -232,12 +210,12 @@ fn check_error_codes_docs(
 
         // Check that the explanation has a doctest, and if it shouldn't, that it doesn't
         if !found_proper_doctest && !test_ignored {
-            errors.push(format!(
+            check.error(format!(
                 "`{}` doesn't use its own error code in compile_fail example",
                 path.display(),
             ));
         } else if found_proper_doctest && test_ignored {
-            errors.push(format!(
+            check.error(format!(
                 "`{}` has a compile_fail doctest with its own error code, it shouldn't \
                 be listed in `IGNORE_DOCTEST_CHECK`",
                 path.display(),
@@ -289,8 +267,7 @@ fn check_explanation_has_doctest(explanation: &str, err_code: &str) -> (bool, bo
 fn check_error_codes_tests(
     root_path: &Path,
     error_codes: &[String],
-    errors: &mut Vec<String>,
-    verbose: bool,
+    check: &mut RunningCheck,
     no_longer_emitted: &[String],
 ) {
     let tests_path = root_path.join(Path::new(ERROR_TESTS_PATH));
@@ -299,15 +276,14 @@ fn check_error_codes_tests(
         let test_path = tests_path.join(format!("{code}.stderr"));
 
         if !test_path.exists() && !IGNORE_UI_TEST_CHECK.contains(&code.as_str()) {
-            verbose_print!(
-                verbose,
+            check.verbose_msg(format!(
                 "warning: Error code `{code}` needs to have at least one UI test in the `tests/error-codes/` directory`!"
-            );
+            ));
             continue;
         }
         if IGNORE_UI_TEST_CHECK.contains(&code.as_str()) {
             if test_path.exists() {
-                errors.push(format!(
+                check.error(format!(
                     "Error code `{code}` has a UI test in `tests/ui/error-codes/{code}.rs`, it shouldn't be listed in `EXEMPTED_FROM_TEST`!"
                 ));
             }
@@ -317,11 +293,10 @@ fn check_error_codes_tests(
         let file = match fs::read_to_string(&test_path) {
             Ok(file) => file,
             Err(err) => {
-                verbose_print!(
-                    verbose,
+                check.verbose_msg(format!(
                     "warning: Failed to read UI test file (`{}`) for `{code}` but the file exists. The test is assumed to work:\n{err}",
                     test_path.display()
-                );
+                ));
                 continue;
             }
         };
@@ -343,10 +318,9 @@ fn check_error_codes_tests(
         }
 
         if !found_code {
-            verbose_print!(
-                verbose,
+            check.verbose_msg(format!(
                 "warning: Error code `{code}` has a UI test file, but doesn't contain its own error code!"
-            );
+            ));
         }
     }
 }
@@ -355,9 +329,8 @@ fn check_error_codes_tests(
 fn check_error_codes_used(
     search_paths: &[&Path],
     error_codes: &[String],
-    errors: &mut Vec<String>,
+    check: &mut RunningCheck,
     no_longer_emitted: &[String],
-    verbose: bool,
 ) {
     // Search for error codes in the form `E0123`.
     let regex = Regex::new(r#"\bE\d{4}\b"#).unwrap();
@@ -384,7 +357,7 @@ fn check_error_codes_used(
 
                     if !error_codes.contains(&error_code) {
                         // This error code isn't properly defined, we must error.
-                        errors.push(format!("Error code `{error_code}` is used in the compiler but not defined and documented in `compiler/rustc_error_codes/src/lib.rs`."));
+                        check.error(format!("Error code `{error_code}` is used in the compiler but not defined and documented in `compiler/rustc_error_codes/src/lib.rs`."));
                         continue;
                     }
 
@@ -397,7 +370,7 @@ fn check_error_codes_used(
 
     for code in error_codes {
         if !found_codes.contains(code) && !no_longer_emitted.contains(code) {
-            errors.push(format!(
+            check.error(format!(
                 "Error code `{code}` exists, but is not emitted by the compiler!\n\
                 Please mark the code as no longer emitted by adding the following note to the top of the `EXXXX.md` file:\n\
                 `#### Note: this error code is no longer emitted by the compiler`\n\
@@ -406,10 +379,9 @@ fn check_error_codes_used(
         }
 
         if found_codes.contains(code) && no_longer_emitted.contains(code) {
-            verbose_print!(
-                verbose,
+            check.verbose_msg(format!(
                 "warning: Error code `{code}` is used when it's marked as \"no longer emitted\""
-            );
+            ));
         }
     }
 }
diff --git a/src/tools/tidy/src/extdeps.rs b/src/tools/tidy/src/extdeps.rs
index 2b212cfa67a4b..21612980007d8 100644
--- a/src/tools/tidy/src/extdeps.rs
+++ b/src/tools/tidy/src/extdeps.rs
@@ -4,6 +4,7 @@ use std::fs;
 use std::path::Path;
 
 use crate::deps::WorkspaceInfo;
+use crate::diagnostics::{CheckId, DiagCtx};
 
 /// List of allowed sources for packages.
 const ALLOWED_SOURCES: &[&str] = &[
@@ -14,7 +15,9 @@ const ALLOWED_SOURCES: &[&str] = &[
 
 /// Checks for external package sources. `root` is the path to the directory that contains the
 /// workspace `Cargo.toml`.
-pub fn check(root: &Path, bad: &mut bool) {
+pub fn check(root: &Path, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx.start_check(CheckId::new("extdeps").path(root));
+
     for &WorkspaceInfo { path, submodules, .. } in crate::deps::WORKSPACES {
         if crate::deps::has_missing_submodule(root, submodules) {
             continue;
@@ -25,7 +28,7 @@ pub fn check(root: &Path, bad: &mut bool) {
         let lockfile = root.join(path).join("Cargo.lock");
 
         if !lockfile.exists() {
-            tidy_error!(bad, "the `{path}` workspace doesn't have a Cargo.lock");
+            check.error(format!("the `{path}` workspace doesn't have a Cargo.lock"));
             continue;
         }
 
@@ -44,7 +47,7 @@ pub fn check(root: &Path, bad: &mut bool) {
 
             // Ensure source is allowed.
             if !ALLOWED_SOURCES.contains(&source) {
-                tidy_error!(bad, "invalid source: {}", source);
+                check.error(format!("invalid source: {}", source));
             }
         }
     }
diff --git a/src/tools/tidy/src/extra_checks/mod.rs b/src/tools/tidy/src/extra_checks/mod.rs
index a6b50b5ca4701..9f2f2da2e86d7 100644
--- a/src/tools/tidy/src/extra_checks/mod.rs
+++ b/src/tools/tidy/src/extra_checks/mod.rs
@@ -24,6 +24,7 @@ use std::str::FromStr;
 use std::{fmt, fs, io};
 
 use crate::CiInfo;
+use crate::diagnostics::DiagCtx;
 
 mod rustdoc_js;
 
@@ -54,8 +55,10 @@ pub fn check(
     bless: bool,
     extra_checks: Option<&str>,
     pos_args: &[String],
-    bad: &mut bool,
+    diag_ctx: DiagCtx,
 ) {
+    let mut check = diag_ctx.start_check("extra_checks");
+
     if let Err(e) = check_impl(
         root_path,
         outdir,
@@ -68,7 +71,7 @@ pub fn check(
         extra_checks,
         pos_args,
     ) {
-        tidy_error!(bad, "{e}");
+        check.error(e);
     }
 }
 
diff --git a/src/tools/tidy/src/features.rs b/src/tools/tidy/src/features.rs
index 6618ba24be609..0a0ba217c6338 100644
--- a/src/tools/tidy/src/features.rs
+++ b/src/tools/tidy/src/features.rs
@@ -16,6 +16,7 @@ use std::num::NonZeroU32;
 use std::path::{Path, PathBuf};
 use std::{fmt, fs};
 
+use crate::diagnostics::{DiagCtx, RunningCheck};
 use crate::walk::{filter_dirs, filter_not_rust, walk, walk_many};
 
 #[cfg(test)]
@@ -91,13 +92,14 @@ pub fn check(
     tests_path: &Path,
     compiler_path: &Path,
     lib_path: &Path,
-    bad: &mut bool,
-    verbose: bool,
+    diag_ctx: DiagCtx,
 ) -> CollectedFeatures {
-    let mut features = collect_lang_features(compiler_path, bad);
+    let mut check = diag_ctx.start_check("features");
+
+    let mut features = collect_lang_features(compiler_path, &mut check);
     assert!(!features.is_empty());
 
-    let lib_features = get_and_check_lib_features(lib_path, bad, &features);
+    let lib_features = get_and_check_lib_features(lib_path, &mut check, &features);
     assert!(!lib_features.is_empty());
 
     walk_many(
@@ -121,7 +123,7 @@ pub fn check(
 
             for (i, line) in contents.lines().enumerate() {
                 let mut err = |msg: &str| {
-                    tidy_error!(bad, "{}:{}: {}", file.display(), i + 1, msg);
+                    check.error(format!("{}:{}: {}", file.display(), i + 1, msg));
                 };
 
                 let gate_test_str = "gate-test-";
@@ -175,7 +177,7 @@ pub fn check(
     }
 
     if !gate_untested.is_empty() {
-        tidy_error!(bad, "Found {} features without a gate test.", gate_untested.len());
+        check.error(format!("Found {} features without a gate test.", gate_untested.len()));
     }
 
     let (version, channel) = get_version_and_channel(src_path);
@@ -189,39 +191,32 @@ pub fn check(
         let file = feature.file.display();
         let line = feature.line;
         if since > version && since != Version::CurrentPlaceholder {
-            tidy_error!(
-                bad,
+            check.error(format!(
                 "{file}:{line}: The stabilization version {since} of {kind} feature `{feature_name}` is newer than the current {version}"
-            );
+            ));
         }
         if channel == "nightly" && since == version {
-            tidy_error!(
-                bad,
+            check.error(format!(
                 "{file}:{line}: The stabilization version {since} of {kind} feature `{feature_name}` is written out but should be {}",
                 version::VERSION_PLACEHOLDER
-            );
+            ));
         }
         if channel != "nightly" && since == Version::CurrentPlaceholder {
-            tidy_error!(
-                bad,
+            check.error(format!(
                 "{file}:{line}: The placeholder use of {kind} feature `{feature_name}` is not allowed on the {channel} channel",
-            );
+            ));
         }
     }
 
-    if *bad {
-        return CollectedFeatures { lib: lib_features, lang: features };
-    }
-
-    if verbose {
+    if !check.is_bad() && check.is_verbose_enabled() {
         let mut lines = Vec::new();
         lines.extend(format_features(&features, "lang"));
         lines.extend(format_features(&lib_features, "lib"));
-
         lines.sort();
-        for line in lines {
-            println!("* {line}");
-        }
+
+        check.verbose_msg(
+            lines.into_iter().map(|l| format!("* {l}")).collect::<Vec<String>>().join("\n"),
+        );
     }
 
     CollectedFeatures { lib: lib_features, lang: features }
@@ -275,15 +270,20 @@ fn test_filen_gate<'f>(filen_underscore: &'f str, features: &mut Features) -> Op
     None
 }
 
-pub fn collect_lang_features(base_compiler_path: &Path, bad: &mut bool) -> Features {
+pub fn collect_lang_features(base_compiler_path: &Path, check: &mut RunningCheck) -> Features {
     let mut features = Features::new();
-    collect_lang_features_in(&mut features, base_compiler_path, "accepted.rs", bad);
-    collect_lang_features_in(&mut features, base_compiler_path, "removed.rs", bad);
-    collect_lang_features_in(&mut features, base_compiler_path, "unstable.rs", bad);
+    collect_lang_features_in(&mut features, base_compiler_path, "accepted.rs", check);
+    collect_lang_features_in(&mut features, base_compiler_path, "removed.rs", check);
+    collect_lang_features_in(&mut features, base_compiler_path, "unstable.rs", check);
     features
 }
 
-fn collect_lang_features_in(features: &mut Features, base: &Path, file: &str, bad: &mut bool) {
+fn collect_lang_features_in(
+    features: &mut Features,
+    base: &Path,
+    file: &str,
+    check: &mut RunningCheck,
+) {
     let path = base.join("rustc_feature").join("src").join(file);
     let contents = t!(fs::read_to_string(&path));
 
@@ -315,13 +315,11 @@ fn collect_lang_features_in(features: &mut Features, base: &Path, file: &str, ba
 
         if line.starts_with(FEATURE_GROUP_START_PREFIX) {
             if in_feature_group {
-                tidy_error!(
-                    bad,
-                    "{}:{}: \
+                check.error(format!(
+                    "{}:{line_number}: \
                         new feature group is started without ending the previous one",
-                    path.display(),
-                    line_number,
-                );
+                    path.display()
+                ));
             }
 
             in_feature_group = true;
@@ -353,14 +351,10 @@ fn collect_lang_features_in(features: &mut Features, base: &Path, file: &str, ba
         let since = match since_str.parse() {
             Ok(since) => Some(since),
             Err(err) => {
-                tidy_error!(
-                    bad,
-                    "{}:{}: failed to parse since: {} ({:?})",
-                    path.display(),
-                    line_number,
-                    since_str,
-                    err,
-                );
+                check.error(format!(
+                    "{}:{line_number}: failed to parse since: {since_str} ({err:?})",
+                    path.display()
+                ));
                 None
             }
         };
@@ -371,13 +365,10 @@ fn collect_lang_features_in(features: &mut Features, base: &Path, file: &str, ba
                 let correct_index = match prev_names.binary_search(&name) {
                     Ok(_) => {
                         // This only occurs when the feature name has already been declared.
-                        tidy_error!(
-                            bad,
-                            "{}:{}: duplicate feature {}",
-                            path.display(),
-                            line_number,
-                            name,
-                        );
+                        check.error(format!(
+                            "{}:{line_number}: duplicate feature {name}",
+                            path.display()
+                        ));
                         // skip any additional checks for this line
                         continue;
                     }
@@ -398,14 +389,10 @@ fn collect_lang_features_in(features: &mut Features, base: &Path, file: &str, ba
                     )
                 };
 
-                tidy_error!(
-                    bad,
-                    "{}:{}: feature {} is not sorted by feature name (should be {})",
+                check.error(format!(
+                    "{}:{line_number}: feature {name} is not sorted by feature name (should be {correct_placement})",
                     path.display(),
-                    line_number,
-                    name,
-                    correct_placement,
-                );
+                ));
             }
             prev_names.push(name);
         }
@@ -413,13 +400,10 @@ fn collect_lang_features_in(features: &mut Features, base: &Path, file: &str, ba
         let issue_str = parts.next().unwrap().trim();
         let tracking_issue = if issue_str.starts_with("None") {
             if level == Status::Unstable && !next_feature_omits_tracking_issue {
-                tidy_error!(
-                    bad,
-                    "{}:{}: no tracking issue for feature {}",
+                check.error(format!(
+                    "{}:{line_number}: no tracking issue for feature {name}",
                     path.display(),
-                    line_number,
-                    name,
-                );
+                ));
             }
             None
         } else {
@@ -428,13 +412,11 @@ fn collect_lang_features_in(features: &mut Features, base: &Path, file: &str, ba
         };
         match features.entry(name.to_owned()) {
             Entry::Occupied(e) => {
-                tidy_error!(
-                    bad,
-                    "{}:{} feature {name} already specified with status '{}'",
+                check.error(format!(
+                    "{}:{line_number} feature {name} already specified with status '{}'",
                     path.display(),
-                    line_number,
                     e.get().level,
-                );
+                ));
             }
             Entry::Vacant(e) => {
                 e.insert(Feature {
@@ -458,7 +440,7 @@ fn collect_lang_features_in(features: &mut Features, base: &Path, file: &str, ba
 
 fn get_and_check_lib_features(
     base_src_path: &Path,
-    bad: &mut bool,
+    check: &mut RunningCheck,
     lang_features: &Features,
 ) -> Features {
     let mut lib_features = Features::new();
@@ -469,16 +451,12 @@ fn get_and_check_lib_features(
                     && f.tracking_issue != s.tracking_issue
                     && f.level != Status::Accepted
                 {
-                    tidy_error!(
-                        bad,
-                        "{}:{}: feature gate {} has inconsistent `issue`: \"{}\" mismatches the {} `issue` of \"{}\"",
+                    check.error(format!(
+                        "{}:{line}: feature gate {name} has inconsistent `issue`: \"{}\" mismatches the {display} `issue` of \"{}\"",
                         file.display(),
-                        line,
-                        name,
                         f.tracking_issue_display(),
-                        display,
                         s.tracking_issue_display(),
-                    );
+                    ));
                 }
             };
             check_features(&f, lang_features, "corresponding lang feature");
@@ -486,7 +464,7 @@ fn get_and_check_lib_features(
             lib_features.insert(name.to_owned(), f);
         }
         Err(msg) => {
-            tidy_error!(bad, "{}:{}: {}", file.display(), line, msg);
+            check.error(format!("{}:{line}: {msg}", file.display()));
         }
     });
     lib_features
diff --git a/src/tools/tidy/src/filenames.rs b/src/tools/tidy/src/filenames.rs
index 53115f4eaa41b..d52a82297388f 100644
--- a/src/tools/tidy/src/filenames.rs
+++ b/src/tools/tidy/src/filenames.rs
@@ -10,7 +10,10 @@
 use std::path::Path;
 use std::process::Command;
 
-pub fn check(root_path: &Path, bad: &mut bool) {
+use crate::diagnostics::{CheckId, DiagCtx};
+
+pub fn check(root_path: &Path, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx.start_check(CheckId::new("filenames").path(root_path));
     let stat_output = Command::new("git")
         .arg("-C")
         .arg(root_path)
@@ -20,20 +23,17 @@ pub fn check(root_path: &Path, bad: &mut bool) {
         .stdout;
     for filename in stat_output.split(|&b| b == 0) {
         match str::from_utf8(filename) {
-            Err(_) => tidy_error!(
-                bad,
+            Err(_) => check.error(format!(
                 r#"non-UTF8 file names are not supported: "{}""#,
                 String::from_utf8_lossy(filename),
-            ),
-            Ok(name) if name.chars().any(|c| c.is_control()) => tidy_error!(
-                bad,
+            )),
+            Ok(name) if name.chars().any(|c| c.is_control()) => check.error(format!(
                 r#"control characters are not supported in file names: "{}""#,
                 String::from_utf8_lossy(filename),
-            ),
-            Ok(name) if name.contains(':') => tidy_error!(
-                bad,
+            )),
+            Ok(name) if name.contains(':') => check.error(format!(
                 r#"":" is not supported in file names because of Windows compatibility: "{name}""#,
-            ),
+            )),
             _ => (),
         }
     }
diff --git a/src/tools/tidy/src/fluent_alphabetical.rs b/src/tools/tidy/src/fluent_alphabetical.rs
index 48d14a37514bd..02b914c21aebf 100644
--- a/src/tools/tidy/src/fluent_alphabetical.rs
+++ b/src/tools/tidy/src/fluent_alphabetical.rs
@@ -7,6 +7,7 @@ use std::path::Path;
 
 use regex::Regex;
 
+use crate::diagnostics::{CheckId, DiagCtx, RunningCheck};
 use crate::walk::{filter_dirs, walk};
 
 fn message() -> &'static Regex {
@@ -20,19 +21,17 @@ fn is_fluent(path: &Path) -> bool {
 fn check_alphabetic(
     filename: &str,
     fluent: &str,
-    bad: &mut bool,
+    check: &mut RunningCheck,
     all_defined_msgs: &mut HashMap<String, String>,
 ) {
     let mut matches = message().captures_iter(fluent).peekable();
     while let Some(m) = matches.next() {
         let name = m.get(1).unwrap();
         if let Some(defined_filename) = all_defined_msgs.get(name.as_str()) {
-            tidy_error!(
-                bad,
-                "{filename}: message `{}` is already defined in {}",
+            check.error(format!(
+                "{filename}: message `{}` is already defined in {defined_filename}",
                 name.as_str(),
-                defined_filename,
-            );
+            ));
         }
 
         all_defined_msgs.insert(name.as_str().to_owned(), filename.to_owned());
@@ -40,13 +39,12 @@ fn check_alphabetic(
         if let Some(next) = matches.peek() {
             let next = next.get(1).unwrap();
             if name.as_str() > next.as_str() {
-                tidy_error!(
-                    bad,
+                check.error(format!(
                     "{filename}: message `{}` appears before `{}`, but is alphabetically later than it
 run `./x.py test tidy --bless` to sort the file correctly",
                     name.as_str(),
                     next.as_str()
-                );
+                ));
             }
         } else {
             break;
@@ -57,7 +55,7 @@ run `./x.py test tidy --bless` to sort the file correctly",
 fn sort_messages(
     filename: &str,
     fluent: &str,
-    bad: &mut bool,
+    check: &mut RunningCheck,
     all_defined_msgs: &mut HashMap<String, String>,
 ) -> String {
     let mut chunks = vec![];
@@ -65,12 +63,10 @@ fn sort_messages(
     for line in fluent.lines() {
         if let Some(name) = message().find(line) {
             if let Some(defined_filename) = all_defined_msgs.get(name.as_str()) {
-                tidy_error!(
-                    bad,
-                    "{filename}: message `{}` is already defined in {}",
+                check.error(format!(
+                    "{filename}: message `{}` is already defined in {defined_filename}",
                     name.as_str(),
-                    defined_filename,
-                );
+                ));
             }
 
             all_defined_msgs.insert(name.as_str().to_owned(), filename.to_owned());
@@ -88,7 +84,9 @@ fn sort_messages(
     out
 }
 
-pub fn check(path: &Path, bless: bool, bad: &mut bool) {
+pub fn check(path: &Path, bless: bool, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx.start_check(CheckId::new("fluent_alphabetical").path(path));
+
     let mut all_defined_msgs = HashMap::new();
     walk(
         path,
@@ -98,7 +96,7 @@ pub fn check(path: &Path, bless: bool, bad: &mut bool) {
                 let sorted = sort_messages(
                     ent.path().to_str().unwrap(),
                     contents,
-                    bad,
+                    &mut check,
                     &mut all_defined_msgs,
                 );
                 if sorted != contents {
@@ -110,12 +108,12 @@ pub fn check(path: &Path, bless: bool, bad: &mut bool) {
                 check_alphabetic(
                     ent.path().to_str().unwrap(),
                     contents,
-                    bad,
+                    &mut check,
                     &mut all_defined_msgs,
                 );
             }
         },
     );
 
-    crate::fluent_used::check(path, all_defined_msgs, bad);
+    crate::fluent_used::check(path, all_defined_msgs, diag_ctx);
 }
diff --git a/src/tools/tidy/src/fluent_lowercase.rs b/src/tools/tidy/src/fluent_lowercase.rs
index 13f0319909e17..1d80fda8f3b86 100644
--- a/src/tools/tidy/src/fluent_lowercase.rs
+++ b/src/tools/tidy/src/fluent_lowercase.rs
@@ -4,6 +4,7 @@ use std::path::Path;
 
 use fluent_syntax::ast::{Entry, Message, PatternElement};
 
+use crate::diagnostics::{CheckId, DiagCtx, RunningCheck};
 use crate::walk::{filter_dirs, walk};
 
 #[rustfmt::skip]
@@ -34,7 +35,7 @@ fn is_allowed_capitalized_word(msg: &str) -> bool {
     })
 }
 
-fn check_lowercase(filename: &str, contents: &str, bad: &mut bool) {
+fn check_lowercase(filename: &str, contents: &str, check: &mut RunningCheck) {
     let (Ok(parse) | Err((parse, _))) = fluent_syntax::parser::parse(contents);
 
     for entry in &parse.body {
@@ -45,20 +46,20 @@ fn check_lowercase(filename: &str, contents: &str, bad: &mut bool) {
             && value.chars().next().is_some_and(char::is_uppercase)
             && !is_allowed_capitalized_word(value)
         {
-            tidy_error!(
-                bad,
+            check.error(format!(
                 "{filename}: message `{value}` starts with an uppercase letter. Fix it or add it to `ALLOWED_CAPITALIZED_WORDS`"
-            );
+            ));
         }
     }
 }
 
-pub fn check(path: &Path, bad: &mut bool) {
+pub fn check(path: &Path, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx.start_check(CheckId::new("fluent_lowercase").path(path));
     walk(
         path,
         |path, is_dir| filter_dirs(path) || (!is_dir && filter_fluent(path)),
         &mut |ent, contents| {
-            check_lowercase(ent.path().to_str().unwrap(), contents, bad);
+            check_lowercase(ent.path().to_str().unwrap(), contents, &mut check);
         },
     );
 }
diff --git a/src/tools/tidy/src/fluent_period.rs b/src/tools/tidy/src/fluent_period.rs
index 836b5699289f2..c7c760b8d54fd 100644
--- a/src/tools/tidy/src/fluent_period.rs
+++ b/src/tools/tidy/src/fluent_period.rs
@@ -4,6 +4,7 @@ use std::path::Path;
 
 use fluent_syntax::ast::{Entry, PatternElement};
 
+use crate::diagnostics::{CheckId, DiagCtx, RunningCheck};
 use crate::walk::{filter_dirs, walk};
 
 fn filter_fluent(path: &Path) -> bool {
@@ -20,7 +21,7 @@ const ALLOWLIST: &[&str] = &[
     "incremental_corrupt_file",
 ];
 
-fn check_period(filename: &str, contents: &str, bad: &mut bool) {
+fn check_period(filename: &str, contents: &str, check: &mut RunningCheck) {
     if filename.contains("codegen") {
         // FIXME: Too many codegen messages have periods right now...
         return;
@@ -40,7 +41,7 @@ fn check_period(filename: &str, contents: &str, bad: &mut bool) {
                 if value.ends_with(".") && !value.ends_with("...") {
                     let ll = find_line(contents, value);
                     let name = m.id.name;
-                    tidy_error!(bad, "{filename}:{ll}: message `{name}` ends in a period");
+                    check.error(format!("{filename}:{ll}: message `{name}` ends in a period"));
                 }
             }
 
@@ -56,7 +57,7 @@ fn check_period(filename: &str, contents: &str, bad: &mut bool) {
                 {
                     let ll = find_line(contents, value);
                     let name = attr.id.name;
-                    tidy_error!(bad, "{filename}:{ll}: attr `{name}` ends in a period");
+                    check.error(format!("{filename}:{ll}: attr `{name}` ends in a period"));
                 }
             }
         }
@@ -74,12 +75,14 @@ fn find_line(haystack: &str, needle: &str) -> usize {
     1
 }
 
-pub fn check(path: &Path, bad: &mut bool) {
+pub fn check(path: &Path, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx.start_check(CheckId::new("fluent_period").path(path));
+
     walk(
         path,
         |path, is_dir| filter_dirs(path) || (!is_dir && filter_fluent(path)),
         &mut |ent, contents| {
-            check_period(ent.path().to_str().unwrap(), contents, bad);
+            check_period(ent.path().to_str().unwrap(), contents, &mut check);
         },
     );
 }
diff --git a/src/tools/tidy/src/fluent_used.rs b/src/tools/tidy/src/fluent_used.rs
index 909bf482ddfce..2047089631b38 100644
--- a/src/tools/tidy/src/fluent_used.rs
+++ b/src/tools/tidy/src/fluent_used.rs
@@ -3,6 +3,7 @@
 use std::collections::HashMap;
 use std::path::Path;
 
+use crate::diagnostics::{CheckId, DiagCtx};
 use crate::walk::{filter_dirs, walk};
 
 fn filter_used_messages(
@@ -27,13 +28,15 @@ fn filter_used_messages(
     }
 }
 
-pub fn check(path: &Path, mut all_defined_msgs: HashMap<String, String>, bad: &mut bool) {
+pub fn check(path: &Path, mut all_defined_msgs: HashMap<String, String>, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx.start_check(CheckId::new("fluent_used").path(path));
+
     let mut msgs_appear_only_once = HashMap::new();
     walk(path, |path, _| filter_dirs(path), &mut |_, contents| {
         filter_used_messages(contents, &mut all_defined_msgs, &mut msgs_appear_only_once);
     });
 
     for (name, filename) in msgs_appear_only_once {
-        tidy_error!(bad, "{filename}: message `{}` is not used", name,);
+        check.error(format!("{filename}: message `{name}` is not used"));
     }
 }
diff --git a/src/tools/tidy/src/gcc_submodule.rs b/src/tools/tidy/src/gcc_submodule.rs
index 217eaf1758c48..3a6e3247de606 100644
--- a/src/tools/tidy/src/gcc_submodule.rs
+++ b/src/tools/tidy/src/gcc_submodule.rs
@@ -4,7 +4,11 @@
 use std::path::Path;
 use std::process::Command;
 
-pub fn check(root_path: &Path, compiler_path: &Path, bad: &mut bool) {
+use crate::diagnostics::DiagCtx;
+
+pub fn check(root_path: &Path, compiler_path: &Path, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx.start_check("gcc_submodule");
+
     let cg_gcc_version_path = compiler_path.join("rustc_codegen_gcc/libgccjit.version");
     let cg_gcc_version = std::fs::read_to_string(&cg_gcc_version_path)
         .unwrap_or_else(|_| {
@@ -26,7 +30,7 @@ pub fn check(root_path: &Path, compiler_path: &Path, bad: &mut bool) {
 
     // Git is not available or we are in a tarball
     if !git_output.status.success() {
-        eprintln!("Cannot figure out the SHA of the GCC submodule");
+        check.message("Cannot figure out the SHA of the GCC submodule");
         return;
     }
 
@@ -43,12 +47,11 @@ pub fn check(root_path: &Path, compiler_path: &Path, bad: &mut bool) {
     // The SHA can start with + if the submodule is modified or - if it is not checked out.
     let gcc_submodule_sha = git_output.trim_start_matches(['+', '-']);
     if gcc_submodule_sha != cg_gcc_version {
-        *bad = true;
-        eprintln!(
+        check.error(format!(
             r#"Commit SHA of the src/gcc submodule (`{gcc_submodule_sha}`) does not match the required GCC version of the GCC codegen backend (`{cg_gcc_version}`).
 Make sure to set the src/gcc submodule to commit {cg_gcc_version}.
 The GCC codegen backend commit is configured at {}."#,
             cg_gcc_version_path.display(),
-        );
+        ));
     }
 }
diff --git a/src/tools/tidy/src/known_bug.rs b/src/tools/tidy/src/known_bug.rs
index e1921715ab922..d3b75e0cf5b8c 100644
--- a/src/tools/tidy/src/known_bug.rs
+++ b/src/tools/tidy/src/known_bug.rs
@@ -2,9 +2,11 @@
 
 use std::path::Path;
 
+use crate::diagnostics::{CheckId, DiagCtx};
 use crate::walk::*;
 
-pub fn check(filepath: &Path, bad: &mut bool) {
+pub fn check(filepath: &Path, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx.start_check(CheckId::new("known_bug").path(filepath));
     walk(filepath, |path, _is_dir| filter_not_rust(path), &mut |entry, contents| {
         let file: &Path = entry.path();
 
@@ -19,11 +21,10 @@ pub fn check(filepath: &Path, bad: &mut bool) {
             [.., "tests", "crashes", "auxiliary", _aux_file_rs]
         ) && !contents.lines().any(|line| line.starts_with("//@ known-bug: "))
         {
-            tidy_error!(
-                bad,
+            check.error(format!(
                 "{} crash/ice test does not have a \"//@ known-bug: \" directive",
                 file.display()
-            );
+            ));
         }
     });
 }
diff --git a/src/tools/tidy/src/lib.rs b/src/tools/tidy/src/lib.rs
index 953d699199066..0bfee93796be1 100644
--- a/src/tools/tidy/src/lib.rs
+++ b/src/tools/tidy/src/lib.rs
@@ -11,7 +11,8 @@ use std::{env, io};
 use build_helper::ci::CiEnv;
 use build_helper::git::{GitConfig, get_closest_upstream_commit};
 use build_helper::stage0_parser::{Stage0Config, parse_stage0_file};
-use termcolor::WriteColor;
+
+use crate::diagnostics::{DiagCtx, RunningCheck};
 
 macro_rules! static_regex {
     ($re:literal) => {{
@@ -43,28 +44,6 @@ macro_rules! t {
     };
 }
 
-macro_rules! tidy_error {
-    ($bad:expr, $($fmt:tt)*) => ({
-        $crate::tidy_error(&format_args!($($fmt)*).to_string()).expect("failed to output error");
-        *$bad = true;
-    });
-}
-
-fn tidy_error(args: &str) -> std::io::Result<()> {
-    use std::io::Write;
-
-    use termcolor::{Color, ColorChoice, ColorSpec, StandardStream};
-
-    let mut stderr = StandardStream::stdout(ColorChoice::Auto);
-    stderr.set_color(ColorSpec::new().set_fg(Some(Color::Red)))?;
-
-    write!(&mut stderr, "tidy error")?;
-    stderr.set_color(&ColorSpec::new())?;
-
-    writeln!(&mut stderr, ": {args}")?;
-    Ok(())
-}
-
 pub struct CiInfo {
     pub git_merge_commit_email: String,
     pub nightly_branch: String,
@@ -73,7 +52,9 @@ pub struct CiInfo {
 }
 
 impl CiInfo {
-    pub fn new(bad: &mut bool) -> Self {
+    pub fn new(diag_ctx: DiagCtx) -> Self {
+        let mut check = diag_ctx.start_check("CI history");
+
         let stage0 = parse_stage0_file();
         let Stage0Config { nightly_branch, git_merge_commit_email, .. } = stage0.config;
 
@@ -86,11 +67,14 @@ impl CiInfo {
         let base_commit = match get_closest_upstream_commit(None, &info.git_config(), info.ci_env) {
             Ok(Some(commit)) => Some(commit),
             Ok(None) => {
-                info.error_if_in_ci("no base commit found", bad);
+                info.error_if_in_ci("no base commit found", &mut check);
                 None
             }
             Err(error) => {
-                info.error_if_in_ci(&format!("failed to retrieve base commit: {error}"), bad);
+                info.error_if_in_ci(
+                    &format!("failed to retrieve base commit: {error}"),
+                    &mut check,
+                );
                 None
             }
         };
@@ -105,12 +89,11 @@ impl CiInfo {
         }
     }
 
-    pub fn error_if_in_ci(&self, msg: &str, bad: &mut bool) {
+    pub fn error_if_in_ci(&self, msg: &str, check: &mut RunningCheck) {
         if self.ci_env.is_running_in_ci() {
-            *bad = true;
-            eprintln!("tidy check error: {msg}");
+            check.error(msg);
         } else {
-            eprintln!("tidy check warning: {msg}. Some checks will be skipped.");
+            check.warning(format!("{msg}. Some checks will be skipped."));
         }
     }
 }
diff --git a/src/tools/tidy/src/main.rs b/src/tools/tidy/src/main.rs
index 7d42102bbb9d0..73ff183868a27 100644
--- a/src/tools/tidy/src/main.rs
+++ b/src/tools/tidy/src/main.rs
@@ -8,8 +8,6 @@ use std::collections::VecDeque;
 use std::num::NonZeroUsize;
 use std::path::PathBuf;
 use std::str::FromStr;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, Mutex};
 use std::thread::{self, ScopedJoinHandle, scope};
 use std::{env, process};
 
@@ -52,11 +50,8 @@ fn main() {
     let extra_checks =
         cfg_args.iter().find(|s| s.starts_with("--extra-checks=")).map(String::as_str);
 
-    let mut bad = false;
-    let ci_info = CiInfo::new(&mut bad);
-    let bad = std::sync::Arc::new(AtomicBool::new(bad));
-
-    let mut diag_ctx = DiagCtx::new(verbose);
+    let diag_ctx = DiagCtx::new(verbose);
+    let ci_info = CiInfo::new(diag_ctx.clone());
 
     let drain_handles = |handles: &mut VecDeque<ScopedJoinHandle<'_, ()>>| {
         // poll all threads for completion before awaiting the oldest one
@@ -99,98 +94,85 @@ fn main() {
             }
         }
 
-        // check!(target_specific_tests, &tests_path);
+        check!(target_specific_tests, &tests_path);
 
         // Checks that are done on the cargo workspace.
-        // check!(deps, &root_path, &cargo, bless);
-        // check!(extdeps, &root_path);
+        check!(deps, &root_path, &cargo, bless);
+        check!(extdeps, &root_path);
 
         // Checks over tests.
-        // check!(tests_placement, &root_path);
-        // check!(tests_revision_unpaired_stdout_stderr, &tests_path);
-        // check!(debug_artifacts, &tests_path);
-        // check!(ui_tests, &root_path, bless);
-        // check!(mir_opt_tests, &tests_path, bless);
-        // check!(rustdoc_gui_tests, &tests_path);
-        // check!(rustdoc_css_themes, &librustdoc_path);
-        // check!(rustdoc_templates, &librustdoc_path);
-        // check!(rustdoc_json, &src_path, &ci_info);
-        // check!(known_bug, &crashes_path);
-        // check!(unknown_revision, &tests_path);
+        check!(tests_placement, &root_path);
+        check!(tests_revision_unpaired_stdout_stderr, &tests_path);
+        check!(debug_artifacts, &tests_path);
+        check!(ui_tests, &root_path, bless);
+        check!(mir_opt_tests, &tests_path, bless);
+        check!(rustdoc_gui_tests, &tests_path);
+        check!(rustdoc_css_themes, &librustdoc_path);
+        check!(rustdoc_templates, &librustdoc_path);
+        check!(rustdoc_json, &src_path, &ci_info);
+        check!(known_bug, &crashes_path);
+        check!(unknown_revision, &tests_path);
 
         // Checks that only make sense for the compiler.
-        // check!(error_codes, &root_path, &[&compiler_path, &librustdoc_path], verbose, &ci_info);
-        // check!(fluent_alphabetical, &compiler_path, bless);
-        // check!(fluent_period, &compiler_path);
-        // check!(fluent_lowercase, &compiler_path);
-        // check!(target_policy, &root_path);
-        // check!(gcc_submodule, &root_path, &compiler_path);
+        check!(error_codes, &root_path, &[&compiler_path, &librustdoc_path], &ci_info);
+        check!(fluent_alphabetical, &compiler_path, bless);
+        check!(fluent_period, &compiler_path);
+        check!(fluent_lowercase, &compiler_path);
+        check!(target_policy, &root_path);
+        check!(gcc_submodule, &root_path, &compiler_path);
 
         // Checks that only make sense for the std libs.
-        // check!(pal, &library_path);
+        check!(pal, &library_path);
 
         // Checks that need to be done for both the compiler and std libraries.
-        // check!(unit_tests, &src_path, false);
-        // check!(unit_tests, &compiler_path, false);
-        // check!(unit_tests, &library_path, true);
-        //
-        // if bins::check_filesystem_support(&[&root_path], &output_directory) {
-        //     check!(bins, &root_path);
-        // }
+        check!(unit_tests, &src_path, false);
+        check!(unit_tests, &compiler_path, false);
+        check!(unit_tests, &library_path, true);
+
+        if bins::check_filesystem_support(&[&root_path], &output_directory) {
+            check!(bins, &root_path);
+        }
 
         check!(style, &src_path);
         check!(style, &tests_path);
         check!(style, &compiler_path);
         check!(style, &library_path);
 
-        // check!(edition, &src_path);
-        // check!(edition, &compiler_path);
-        // check!(edition, &library_path);
-        //
+        check!(edition, &src_path);
+        check!(edition, &compiler_path);
+        check!(edition, &library_path);
+
         check!(alphabetical, &root_manifest);
         check!(alphabetical, &src_path);
         check!(alphabetical, &tests_path);
         check!(alphabetical, &compiler_path);
         check!(alphabetical, &library_path);
-        //
-        // check!(x_version, &root_path, &cargo);
-        //
-        // check!(triagebot, &root_path);
-        //
-        // check!(filenames, &root_path);
+
+        check!(x_version, &root_path, &cargo);
+
+        check!(triagebot, &root_path);
+        check!(filenames, &root_path);
 
         let collected = {
             drain_handles(&mut handles);
 
-            let mut flag = false;
-            let r = features::check(
-                &src_path,
-                &tests_path,
-                &compiler_path,
-                &library_path,
-                &mut flag,
-                verbose,
-            );
-            if flag {
-                bad.store(true, Ordering::Relaxed);
-            }
-            r
+            features::check(&src_path, &tests_path, &compiler_path, &library_path, diag_ctx.clone())
         };
-        // check!(unstable_book, &src_path, collected);
-        //
-        // check!(
-        //     extra_checks,
-        //     &root_path,
-        //     &output_directory,
-        //     &ci_info,
-        //     &librustdoc_path,
-        //     &tools_path,
-        //     &npm,
-        //     &cargo,
-        //     bless,
-        //     extra_checks,
-        //     pos_args
-        // );
+        check!(unstable_book, &src_path, collected);
+
+        check!(
+            extra_checks,
+            &root_path,
+            &output_directory,
+            &ci_info,
+            &librustdoc_path,
+            &tools_path,
+            &npm,
+            &cargo,
+            bless,
+            extra_checks,
+            pos_args
+        );
     });
 
     if diag_ctx.into_conclusion() {
diff --git a/src/tools/tidy/src/mir_opt_tests.rs b/src/tools/tidy/src/mir_opt_tests.rs
index 6119eb58383e3..0f9fab51d096f 100644
--- a/src/tools/tidy/src/mir_opt_tests.rs
+++ b/src/tools/tidy/src/mir_opt_tests.rs
@@ -5,9 +5,10 @@ use std::path::{Path, PathBuf};
 
 use miropt_test_tools::PanicStrategy;
 
+use crate::diagnostics::{CheckId, DiagCtx, RunningCheck};
 use crate::walk::walk_no_read;
 
-fn check_unused_files(path: &Path, bless: bool, bad: &mut bool) {
+fn check_unused_files(path: &Path, bless: bool, check: &mut RunningCheck) {
     let mut rs_files = Vec::<PathBuf>::new();
     let mut output_files = HashSet::<PathBuf>::new();
 
@@ -37,18 +38,17 @@ fn check_unused_files(path: &Path, bless: bool, bad: &mut bool) {
 
     for extra in output_files {
         if !bless {
-            tidy_error!(
-                bad,
+            check.error(format!(
                 "the following output file is not associated with any mir-opt test, you can remove it: {}",
                 extra.display()
-            );
+            ));
         } else {
             let _ = std::fs::remove_file(extra);
         }
     }
 }
 
-fn check_dash_files(path: &Path, bless: bool, bad: &mut bool) {
+fn check_dash_files(path: &Path, bless: bool, check: &mut RunningCheck) {
     for file in walkdir::WalkDir::new(path.join("mir-opt"))
         .into_iter()
         .filter_map(Result::ok)
@@ -60,11 +60,10 @@ fn check_dash_files(path: &Path, bless: bool, bad: &mut bool) {
             && name.contains('-')
         {
             if !bless {
-                tidy_error!(
-                    bad,
+                check.error(format!(
                     "mir-opt test files should not have dashes in them: {}",
                     path.display()
-                );
+                ));
             } else {
                 let new_name = name.replace('-', "_");
                 let mut new_path = path.to_owned();
@@ -75,7 +74,9 @@ fn check_dash_files(path: &Path, bless: bool, bad: &mut bool) {
     }
 }
 
-pub fn check(path: &Path, bless: bool, bad: &mut bool) {
-    check_unused_files(path, bless, bad);
-    check_dash_files(path, bless, bad);
+pub fn check(path: &Path, bless: bool, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx.start_check(CheckId::new("mir_opt_tests").path(path));
+
+    check_unused_files(path, bless, &mut check);
+    check_dash_files(path, bless, &mut check);
 }
diff --git a/src/tools/tidy/src/pal.rs b/src/tools/tidy/src/pal.rs
index 991ad55809cc3..cefad7d9596a6 100644
--- a/src/tools/tidy/src/pal.rs
+++ b/src/tools/tidy/src/pal.rs
@@ -32,6 +32,7 @@
 
 use std::path::Path;
 
+use crate::diagnostics::{CheckId, DiagCtx, RunningCheck};
 use crate::walk::{filter_dirs, walk};
 
 // Paths that may contain platform-specific code.
@@ -67,7 +68,9 @@ const EXCEPTION_PATHS: &[&str] = &[
     "library/std/src/io/error.rs", // Repr unpacked needed for UEFI
 ];
 
-pub fn check(path: &Path, bad: &mut bool) {
+pub fn check(path: &Path, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx.start_check(CheckId::new("pal").path(path));
+
     // Sanity check that the complex parsing here works.
     let mut saw_target_arch = false;
     let mut saw_cfg_bang = false;
@@ -88,7 +91,7 @@ pub fn check(path: &Path, bad: &mut bool) {
             return;
         }
 
-        check_cfgs(contents, file, bad, &mut saw_target_arch, &mut saw_cfg_bang);
+        check_cfgs(contents, file, &mut check, &mut saw_target_arch, &mut saw_cfg_bang);
     });
 
     assert!(saw_target_arch);
@@ -98,7 +101,7 @@ pub fn check(path: &Path, bad: &mut bool) {
 fn check_cfgs(
     contents: &str,
     file: &Path,
-    bad: &mut bool,
+    check: &mut RunningCheck,
     saw_target_arch: &mut bool,
     saw_cfg_bang: &mut bool,
 ) {
@@ -115,7 +118,7 @@ fn check_cfgs(
             Ok(_) => unreachable!(),
             Err(i) => i + 1,
         };
-        tidy_error!(bad, "{}:{}: platform-specific cfg: {}", file.display(), line, cfg);
+        check.error(format!("{}:{line}: platform-specific cfg: {cfg}", file.display()));
     };
 
     for (idx, cfg) in cfgs {
diff --git a/src/tools/tidy/src/rustdoc_css_themes.rs b/src/tools/tidy/src/rustdoc_css_themes.rs
index af36f9ba58e0d..8d4af7a3bd564 100644
--- a/src/tools/tidy/src/rustdoc_css_themes.rs
+++ b/src/tools/tidy/src/rustdoc_css_themes.rs
@@ -3,7 +3,11 @@
 
 use std::path::Path;
 
-pub fn check(librustdoc_path: &Path, bad: &mut bool) {
+use crate::diagnostics::{CheckId, DiagCtx, RunningCheck};
+
+pub fn check(librustdoc_path: &Path, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx.start_check(CheckId::new("rustdoc_css_themes").path(librustdoc_path));
+
     let rustdoc_css = "html/static/css/rustdoc.css";
     let noscript_css = "html/static/css/noscript.css";
     let rustdoc_css_contents = std::fs::read_to_string(librustdoc_path.join(rustdoc_css))
@@ -14,13 +18,13 @@ pub fn check(librustdoc_path: &Path, bad: &mut bool) {
         "light",
         rustdoc_css_contents.lines().enumerate().map(|(i, l)| (i + 1, l.trim())),
         noscript_css_contents.lines().enumerate().map(|(i, l)| (i + 1, l.trim())),
-        bad,
+        &mut check,
     );
     compare_themes_from_files(
         "dark",
         rustdoc_css_contents.lines().enumerate(),
         noscript_css_contents.lines().enumerate(),
-        bad,
+        &mut check,
     );
 }
 
@@ -28,7 +32,7 @@ fn compare_themes_from_files<'a>(
     name: &str,
     mut rustdoc_css_lines: impl Iterator<Item = (usize, &'a str)>,
     mut noscript_css_lines: impl Iterator<Item = (usize, &'a str)>,
-    bad: &mut bool,
+    check: &mut RunningCheck,
 ) {
     let begin_theme_pat = format!("/* Begin theme: {name}");
     let mut found_theme = None;
@@ -38,10 +42,9 @@ fn compare_themes_from_files<'a>(
             continue;
         }
         if let Some(found_theme) = found_theme {
-            tidy_error!(
-                bad,
+            check.error(format!(
                 "rustdoc.css contains two {name} themes on lines {rustdoc_css_line_number} and {found_theme}",
-            );
+            ));
             return;
         }
         found_theme = Some(rustdoc_css_line_number);
@@ -50,14 +53,13 @@ fn compare_themes_from_files<'a>(
                 continue;
             }
             if let Some(found_theme_noscript) = found_theme_noscript {
-                tidy_error!(
-                    bad,
+                check.error(format!(
                     "noscript.css contains two {name} themes on lines {noscript_css_line_number} and {found_theme_noscript}",
-                );
+                ));
                 return;
             }
             found_theme_noscript = Some(noscript_css_line_number);
-            compare_themes(name, &mut rustdoc_css_lines, &mut noscript_css_lines, bad);
+            compare_themes(name, &mut rustdoc_css_lines, &mut noscript_css_lines, check);
         }
     }
 }
@@ -66,7 +68,7 @@ fn compare_themes<'a>(
     name: &str,
     rustdoc_css_lines: impl Iterator<Item = (usize, &'a str)>,
     noscript_css_lines: impl Iterator<Item = (usize, &'a str)>,
-    bad: &mut bool,
+    check: &mut RunningCheck,
 ) {
     let end_theme_pat = format!("/* End theme: {name}");
     for (
@@ -90,12 +92,11 @@ fn compare_themes<'a>(
             break;
         }
         if rustdoc_css_line != noscript_css_line {
-            tidy_error!(
-                bad,
-                "noscript.css:{noscript_css_line_number} and rustdoc.css:{rustdoc_css_line_number} contain copies of {name} theme that are not the same",
-            );
-            eprintln!("- {noscript_css_line}");
-            eprintln!("+ {rustdoc_css_line}");
+            check.error(format!(
+                r#"noscript.css:{noscript_css_line_number} and rustdoc.css:{rustdoc_css_line_number} contain copies of {name} theme that are not the same
+- {noscript_css_line}
++ {rustdoc_css_line}"#,
+            ));
             return;
         }
     }
diff --git a/src/tools/tidy/src/rustdoc_gui_tests.rs b/src/tools/tidy/src/rustdoc_gui_tests.rs
index 3b995f219d269..8ec300c42ce9f 100644
--- a/src/tools/tidy/src/rustdoc_gui_tests.rs
+++ b/src/tools/tidy/src/rustdoc_gui_tests.rs
@@ -2,18 +2,21 @@
 
 use std::path::Path;
 
-pub fn check(path: &Path, bad: &mut bool) {
+use crate::diagnostics::{CheckId, DiagCtx};
+
+pub fn check(path: &Path, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx.start_check(CheckId::new("rustdoc_gui_tests").path(path));
+
     crate::walk::walk(
         &path.join("rustdoc-gui"),
         |p, is_dir| !is_dir && p.extension().is_none_or(|e| e != "goml"),
         &mut |entry, content| {
             for line in content.lines() {
                 if !line.starts_with("// ") {
-                    tidy_error!(
-                        bad,
+                    check.error(format!(
                         "{}: rustdoc-gui tests must start with a small description",
                         entry.path().display(),
-                    );
+                    ));
                     return;
                 } else if line.starts_with("// ") {
                     let parts = line[2..].trim();
diff --git a/src/tools/tidy/src/rustdoc_json.rs b/src/tools/tidy/src/rustdoc_json.rs
index 722e1ebd0cad2..7a53c08737f6c 100644
--- a/src/tools/tidy/src/rustdoc_json.rs
+++ b/src/tools/tidy/src/rustdoc_json.rs
@@ -4,19 +4,22 @@
 use std::path::Path;
 use std::str::FromStr;
 
+use crate::diagnostics::{CheckId, DiagCtx};
+
 const RUSTDOC_JSON_TYPES: &str = "src/rustdoc-json-types";
 
-pub fn check(src_path: &Path, ci_info: &crate::CiInfo, bad: &mut bool) {
-    println!("Checking tidy rustdoc_json...");
+pub fn check(src_path: &Path, ci_info: &crate::CiInfo, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx.start_check(CheckId::new("rustdoc_json").path(src_path));
+
     let Some(base_commit) = &ci_info.base_commit else {
-        eprintln!("No base commit, skipping rustdoc_json check");
+        check.verbose_msg("No base commit, skipping rustdoc_json check");
         return;
     };
 
     // First we check that `src/rustdoc-json-types` was modified.
     if !crate::files_modified(ci_info, |p| p == RUSTDOC_JSON_TYPES) {
         // `rustdoc-json-types` was not modified so nothing more to check here.
-        println!("`rustdoc-json-types` was not modified.");
+        check.verbose_msg("`rustdoc-json-types` was not modified.");
         return;
     }
     // Then we check that if `FORMAT_VERSION` was updated, the `Latest feature:` was also updated.
@@ -45,34 +48,29 @@ pub fn check(src_path: &Path, ci_info: &crate::CiInfo, bad: &mut bool) {
                 }
             }
             if format_version_updated != latest_feature_comment_updated {
-                *bad = true;
-                if latest_feature_comment_updated {
-                    eprintln!(
-                        "error in `rustdoc_json` tidy check: `Latest feature` comment was updated \
-                         whereas `FORMAT_VERSION` wasn't in `{RUSTDOC_JSON_TYPES}/lib.rs`"
-                    );
+                let msg = if latest_feature_comment_updated {
+                    format!(
+                        "`Latest feature` comment was updated whereas `FORMAT_VERSION` wasn't in `{RUSTDOC_JSON_TYPES}/lib.rs`"
+                    )
                 } else {
-                    eprintln!(
-                        "error in `rustdoc_json` tidy check: `Latest feature` comment was not \
-                         updated whereas `FORMAT_VERSION` was in `{RUSTDOC_JSON_TYPES}/lib.rs`"
-                    );
-                }
+                    format!(
+                        "`Latest feature` comment was not updated whereas `FORMAT_VERSION` was in `{RUSTDOC_JSON_TYPES}/lib.rs`"
+                    )
+                };
+                check.error(msg);
             }
             match (new_version, old_version) {
                 (Some(new_version), Some(old_version)) if new_version != old_version + 1 => {
-                    *bad = true;
-                    eprintln!(
-                        "error in `rustdoc_json` tidy check: invalid `FORMAT_VERSION` increase in \
-                         `{RUSTDOC_JSON_TYPES}/lib.rs`, should be `{}`, found `{new_version}`",
+                    check.error(format!(
+                        "invalid `FORMAT_VERSION` increase in `{RUSTDOC_JSON_TYPES}/lib.rs`, should be `{}`, found `{new_version}`",
                         old_version + 1,
-                    );
+                    ));
                 }
                 _ => {}
             }
         }
         None => {
-            *bad = true;
-            eprintln!("error: failed to run `git diff` in rustdoc_json check");
+            check.error("failed to run `git diff` in rustdoc_json check");
         }
     }
 }
diff --git a/src/tools/tidy/src/rustdoc_templates.rs b/src/tools/tidy/src/rustdoc_templates.rs
index 597290a6a9a8d..4e5b9988d5391 100644
--- a/src/tools/tidy/src/rustdoc_templates.rs
+++ b/src/tools/tidy/src/rustdoc_templates.rs
@@ -6,12 +6,15 @@ use std::path::Path;
 
 use ignore::DirEntry;
 
+use crate::diagnostics::{CheckId, DiagCtx};
 use crate::walk::walk;
 
 // Array containing `("beginning of tag", "end of tag")`.
 const TAGS: &[(&str, &str)] = &[("{#", "#}"), ("{%", "%}"), ("{{", "}}")];
 
-pub fn check(librustdoc_path: &Path, bad: &mut bool) {
+pub fn check(librustdoc_path: &Path, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx.start_check(CheckId::new("rustdoc_templates").path(librustdoc_path));
+
     walk(
         &librustdoc_path.join("html/templates"),
         |path, is_dir| is_dir || path.extension().is_none_or(|ext| ext != OsStr::new("html")),
@@ -46,12 +49,11 @@ pub fn check(librustdoc_path: &Path, bad: &mut bool) {
                         })
                     {
                         // It seems like ending this line with a jinja tag is not needed after all.
-                        tidy_error!(
-                            bad,
+                        check.error(format!(
                             "`{}` at line {}: unneeded `{{# #}}` tag at the end of the line",
                             path.path().display(),
                             pos + 1,
-                        );
+                        ));
                     }
                     continue;
                 }
@@ -67,12 +69,11 @@ pub fn check(librustdoc_path: &Path, bad: &mut bool) {
                 }) {
                     None => {
                         // No it's not, let's error.
-                        tidy_error!(
-                            bad,
+                        check.error(format!(
                             "`{}` at line {}: missing `{{# #}}` at the end of the line",
                             path.path().display(),
                             pos + 1,
-                        );
+                        ));
                     }
                     Some(end_tag) => {
                         // We skip the tag.
diff --git a/src/tools/tidy/src/target_policy.rs b/src/tools/tidy/src/target_policy.rs
index 550932dbfdc38..cfcfcaf2435b3 100644
--- a/src/tools/tidy/src/target_policy.rs
+++ b/src/tools/tidy/src/target_policy.rs
@@ -5,6 +5,7 @@
 use std::collections::HashSet;
 use std::path::Path;
 
+use crate::diagnostics::DiagCtx;
 use crate::walk::{filter_not_rust, walk};
 
 const TARGET_DEFINITIONS_PATH: &str = "compiler/rustc_target/src/spec/targets/";
@@ -23,7 +24,9 @@ const EXCEPTIONS: &[&str] = &[
     "xtensa_esp32s3_espidf",
 ];
 
-pub fn check(root_path: &Path, bad: &mut bool) {
+pub fn check(root_path: &Path, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx.start_check("target_policy");
+
     let mut targets_to_find = HashSet::new();
 
     let definitions_path = root_path.join(TARGET_DEFINITIONS_PATH);
@@ -55,7 +58,7 @@ pub fn check(root_path: &Path, bad: &mut bool) {
 
     for target in targets_to_find {
         if !EXCEPTIONS.contains(&target.as_str()) {
-            tidy_error!(bad, "{ASSEMBLY_LLVM_TEST_PATH}: missing assembly test for {target}")
+            check.error(format!("{ASSEMBLY_LLVM_TEST_PATH}: missing assembly test for {target}"));
         }
     }
 }
diff --git a/src/tools/tidy/src/target_specific_tests.rs b/src/tools/tidy/src/target_specific_tests.rs
index b2d5f259eb2db..c1db3874ad547 100644
--- a/src/tools/tidy/src/target_specific_tests.rs
+++ b/src/tools/tidy/src/target_specific_tests.rs
@@ -4,6 +4,7 @@
 use std::collections::BTreeMap;
 use std::path::Path;
 
+use crate::diagnostics::{CheckId, DiagCtx};
 use crate::iter_header::{HeaderLine, iter_header};
 use crate::walk::filter_not_rust;
 
@@ -16,7 +17,9 @@ struct RevisionInfo<'a> {
     llvm_components: Option<Vec<&'a str>>,
 }
 
-pub fn check(tests_path: &Path, bad: &mut bool) {
+pub fn check(tests_path: &Path, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx.start_check(CheckId::new("target-specific-tests").path(tests_path));
+
     crate::walk::walk(tests_path, |path, _is_dir| filter_not_rust(path), &mut |entry, content| {
         if content.contains("// ignore-tidy-target-specific-tests") {
             return;
@@ -44,8 +47,7 @@ pub fn check(tests_path: &Path, bad: &mut bool) {
                 } else if let Some((arch, _)) = v.split_once("-") {
                     info.target_arch.replace(Some(arch));
                 } else {
-                    eprintln!("{file}: seems to have a malformed --target value");
-                    *bad = true;
+                    check.error(format!("{file}: seems to have a malformed --target value"));
                 }
             }
         });
@@ -62,25 +64,22 @@ pub fn check(tests_path: &Path, bad: &mut bool) {
                 (Some(target_arch), None) => {
                     let llvm_component =
                         target_arch.map_or_else(|| "<arch>".to_string(), arch_to_llvm_component);
-                    eprintln!(
+                    check.error(format!(
                         "{file}: revision {rev} should specify `{LLVM_COMPONENTS_HEADER} {llvm_component}` as it has `--target` set"
-                    );
-                    *bad = true;
+                    ));
                 }
                 (None, Some(_)) => {
-                    eprintln!(
+                    check.error(format!(
                         "{file}: revision {rev} should not specify `{LLVM_COMPONENTS_HEADER}` as it doesn't need `--target`"
-                    );
-                    *bad = true;
+                    ));
                 }
                 (Some(target_arch), Some(llvm_components)) => {
                     if let Some(target_arch) = target_arch {
                         let llvm_component = arch_to_llvm_component(target_arch);
                         if !llvm_components.contains(&llvm_component.as_str()) {
-                            eprintln!(
+                            check.error(format!(
                                 "{file}: revision {rev} should specify `{LLVM_COMPONENTS_HEADER} {llvm_component}` as it has `--target` set"
-                            );
-                            *bad = true;
+                            ));
                         }
                     }
                 }
diff --git a/src/tools/tidy/src/tests_placement.rs b/src/tools/tidy/src/tests_placement.rs
index 9d0057df8bcd8..e978e1c453c1e 100644
--- a/src/tools/tidy/src/tests_placement.rs
+++ b/src/tools/tidy/src/tests_placement.rs
@@ -1,15 +1,18 @@
 use std::path::Path;
 
+use crate::diagnostics::{CheckId, DiagCtx};
+
 const FORBIDDEN_PATH: &str = "src/test";
 const ALLOWED_PATH: &str = "tests";
 
-pub fn check(root_path: impl AsRef<Path>, bad: &mut bool) {
-    if root_path.as_ref().join(FORBIDDEN_PATH).exists() {
-        tidy_error!(
-            bad,
+pub fn check(root_path: &Path, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx.start_check(CheckId::new("tests-placement").path(root_path));
+
+    if root_path.join(FORBIDDEN_PATH).exists() {
+        check.error(format!(
             "Tests have been moved, please move them from {} to {}",
-            root_path.as_ref().join(FORBIDDEN_PATH).display(),
-            root_path.as_ref().join(ALLOWED_PATH).display()
-        )
+            root_path.join(FORBIDDEN_PATH).display(),
+            root_path.join(ALLOWED_PATH).display()
+        ));
     }
 }
diff --git a/src/tools/tidy/src/tests_revision_unpaired_stdout_stderr.rs b/src/tools/tidy/src/tests_revision_unpaired_stdout_stderr.rs
index 02412b6f190e8..1738088a3a0c0 100644
--- a/src/tools/tidy/src/tests_revision_unpaired_stdout_stderr.rs
+++ b/src/tools/tidy/src/tests_revision_unpaired_stdout_stderr.rs
@@ -4,6 +4,7 @@ use std::collections::{BTreeMap, BTreeSet};
 use std::ffi::OsStr;
 use std::path::Path;
 
+use crate::diagnostics::{CheckId, DiagCtx};
 use crate::iter_header::*;
 use crate::walk::*;
 
@@ -21,7 +22,10 @@ const IGNORES: &[&str] = &[
 const EXTENSIONS: &[&str] = &["stdout", "stderr"];
 const SPECIAL_TEST: &str = "tests/ui/command/need-crate-arg-ignore-tidy.x.rs";
 
-pub fn check(tests_path: impl AsRef<Path>, bad: &mut bool) {
+pub fn check(tests_path: &Path, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx
+        .start_check(CheckId::new("tests_revision_unpaired_stdout_stderr").path(tests_path));
+
     // Recurse over subdirectories under `tests/`
     walk_dir(tests_path.as_ref(), filter, &mut |entry| {
         // We are inspecting a folder. Collect the paths to interesting files `.rs`, `.stderr`,
@@ -122,12 +126,11 @@ pub fn check(tests_path: impl AsRef<Path>, bad: &mut bool) {
                 [] | [_] => return,
                 [_, _] if !expected_revisions.is_empty() => {
                     // Found unrevisioned output files for a revisioned test.
-                    tidy_error!(
-                        bad,
+                    check.error(format!(
                         "found unrevisioned output file `{}` for a revisioned test `{}`",
                         sibling.display(),
                         test_path.display(),
-                    );
+                    ));
                 }
                 [_, _] => return,
                 [_, found_revision, .., extension] => {
@@ -138,13 +141,12 @@ pub fn check(tests_path: impl AsRef<Path>, bad: &mut bool) {
                     {
                         // Found some unexpected revision-esque component that is not a known
                         // compare-mode or expected revision.
-                        tidy_error!(
-                            bad,
+                        check.error(format!(
                             "found output file `{}` for unexpected revision `{}` of test `{}`",
                             sibling.display(),
                             found_revision,
                             test_path.display()
-                        );
+                        ));
                     }
                 }
             }
diff --git a/src/tools/tidy/src/triagebot.rs b/src/tools/tidy/src/triagebot.rs
index 6f25ed616fac7..9eccef29f2e2a 100644
--- a/src/tools/tidy/src/triagebot.rs
+++ b/src/tools/tidy/src/triagebot.rs
@@ -4,7 +4,10 @@ use std::path::Path;
 
 use toml::Value;
 
-pub fn check(path: &Path, bad: &mut bool) {
+use crate::diagnostics::{CheckId, DiagCtx};
+
+pub fn check(path: &Path, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx.start_check(CheckId::new("triagebot").path(path));
     let triagebot_path = path.join("triagebot.toml");
 
     // This check is mostly to catch broken path filters *within* `triagebot.toml`, and not enforce
@@ -30,17 +33,14 @@ pub fn check(path: &Path, bad: &mut bool) {
             let full_path = path.join(clean_path);
 
             if !full_path.exists() {
-                tidy_error!(
-                    bad,
-                    "triagebot.toml [mentions.*] contains path '{}' which doesn't exist",
-                    clean_path
-                );
+                check.error(format!(
+                    "triagebot.toml [mentions.*] contains path '{clean_path}' which doesn't exist"
+                ));
             }
         }
     } else {
-        tidy_error!(
-            bad,
-            "triagebot.toml missing [mentions.*] section, this wrong for rust-lang/rust repo."
+        check.error(
+            "triagebot.toml missing [mentions.*] section, this wrong for rust-lang/rust repo.",
         );
     }
 
@@ -55,16 +55,13 @@ pub fn check(path: &Path, bad: &mut bool) {
                 let full_path = path.join(clean_path);
 
                 if !full_path.exists() {
-                    tidy_error!(
-                        bad,
-                        "triagebot.toml [assign.owners] contains path '{}' which doesn't exist",
-                        clean_path
-                    );
+                    check.error(format!(
+                        "triagebot.toml [assign.owners] contains path '{clean_path}' which doesn't exist"
+                    ));
                 }
             }
         } else {
-            tidy_error!(
-                bad,
+            check.error(
                 "triagebot.toml missing [assign.owners] section, this wrong for rust-lang/rust repo."
             );
         }
@@ -86,12 +83,9 @@ pub fn check(path: &Path, bad: &mut bool) {
 
                         // Handle both file and directory paths
                         if !full_path.exists() {
-                            tidy_error!(
-                                bad,
-                                "triagebot.toml [autolabel.{}] contains trigger_files path '{}' which doesn't exist",
-                                label,
-                                file_str
-                            );
+                            check.error(format!(
+                                "triagebot.toml [autolabel.{label}] contains trigger_files path '{file_str}' which doesn't exist",
+                            ));
                         }
                     }
                 }
diff --git a/src/tools/tidy/src/ui_tests.rs b/src/tools/tidy/src/ui_tests.rs
index 5bf966b658c63..12eca47c171dc 100644
--- a/src/tools/tidy/src/ui_tests.rs
+++ b/src/tools/tidy/src/ui_tests.rs
@@ -7,13 +7,16 @@ use std::fs;
 use std::io::Write;
 use std::path::{Path, PathBuf};
 
+use crate::diagnostics::{CheckId, DiagCtx, RunningCheck};
+
 const ISSUES_TXT_HEADER: &str = r#"============================================================
     ⚠️⚠️⚠️NOTHING SHOULD EVER BE ADDED TO THIS LIST⚠️⚠️⚠️
 ============================================================
 "#;
 
-pub fn check(root_path: &Path, bless: bool, bad: &mut bool) {
+pub fn check(root_path: &Path, bless: bool, diag_ctx: DiagCtx) {
     let path = &root_path.join("tests");
+    let mut check = diag_ctx.start_check(CheckId::new("ui_tests").path(path));
 
     // the list of files in ui tests that are allowed to start with `issue-XXXX`
     // BTreeSet because we would like a stable ordering so --bless works
@@ -33,16 +36,15 @@ pub fn check(root_path: &Path, bless: bool, bad: &mut bool) {
         .collect();
 
     if !is_sorted && !bless {
-        tidy_error!(
-            bad,
+        check.error(
             "`src/tools/tidy/src/issues.txt` is not in order, mostly because you modified it manually,
             please only update it with command `x test tidy --bless`"
         );
     }
 
-    deny_new_top_level_ui_tests(bad, &path.join("ui"));
+    deny_new_top_level_ui_tests(&mut check, &path.join("ui"));
 
-    let remaining_issue_names = recursively_check_ui_tests(bad, path, &allowed_issue_names);
+    let remaining_issue_names = recursively_check_ui_tests(&mut check, path, &allowed_issue_names);
 
     // if there are any file names remaining, they were moved on the fs.
     // our data must remain up to date, so it must be removed from issues.txt
@@ -64,16 +66,15 @@ pub fn check(root_path: &Path, bless: bool, bad: &mut bool) {
         for file_name in remaining_issue_names {
             let mut p = PathBuf::from(path);
             p.push(file_name);
-            tidy_error!(
-                bad,
+            check.error(format!(
                 "file `{}` no longer exists and should be removed from the exclusions in `src/tools/tidy/src/issues.txt`",
                 p.display()
-            );
+            ));
         }
     }
 }
 
-fn deny_new_top_level_ui_tests(bad: &mut bool, tests_path: &Path) {
+fn deny_new_top_level_ui_tests(check: &mut RunningCheck, tests_path: &Path) {
     // See <https://github.com/rust-lang/compiler-team/issues/902> where we propose banning adding
     // new ui tests *directly* under `tests/ui/`. For more context, see:
     //
@@ -93,16 +94,15 @@ fn deny_new_top_level_ui_tests(bad: &mut bool, tests_path: &Path) {
         })
         .filter(|e| !e.file_type().is_dir());
     for entry in top_level_ui_tests {
-        tidy_error!(
-            bad,
+        check.error(format!(
             "ui tests should be added under meaningful subdirectories: `{}`",
             entry.path().display()
-        )
+        ));
     }
 }
 
 fn recursively_check_ui_tests<'issues>(
-    bad: &mut bool,
+    check: &mut RunningCheck,
     path: &Path,
     allowed_issue_names: &'issues BTreeSet<&'issues str>,
 ) -> BTreeSet<&'issues str> {
@@ -113,19 +113,19 @@ fn recursively_check_ui_tests<'issues>(
     crate::walk::walk_no_read(&paths, |_, _| false, &mut |entry| {
         let file_path = entry.path();
         if let Some(ext) = file_path.extension().and_then(OsStr::to_str) {
-            check_unexpected_extension(bad, file_path, ext);
+            check_unexpected_extension(check, file_path, ext);
 
             // NB: We do not use file_stem() as some file names have multiple `.`s and we
             // must strip all of them.
             let testname =
                 file_path.file_name().unwrap().to_str().unwrap().split_once('.').unwrap().0;
             if ext == "stderr" || ext == "stdout" || ext == "fixed" {
-                check_stray_output_snapshot(bad, file_path, testname);
-                check_empty_output_snapshot(bad, file_path);
+                check_stray_output_snapshot(check, file_path, testname);
+                check_empty_output_snapshot(check, file_path);
             }
 
             deny_new_nondescriptive_test_names(
-                bad,
+                check,
                 path,
                 &mut remaining_issue_names,
                 file_path,
@@ -137,7 +137,7 @@ fn recursively_check_ui_tests<'issues>(
     remaining_issue_names
 }
 
-fn check_unexpected_extension(bad: &mut bool, file_path: &Path, ext: &str) {
+fn check_unexpected_extension(check: &mut RunningCheck, file_path: &Path, ext: &str) {
     const EXPECTED_TEST_FILE_EXTENSIONS: &[&str] = &[
         "rs",     // test source files
         "stderr", // expected stderr file, corresponds to a rs file
@@ -178,11 +178,11 @@ fn check_unexpected_extension(bad: &mut bool, file_path: &Path, ext: &str) {
     if !(EXPECTED_TEST_FILE_EXTENSIONS.contains(&ext)
         || EXTENSION_EXCEPTION_PATHS.iter().any(|path| file_path.ends_with(path)))
     {
-        tidy_error!(bad, "file {} has unexpected extension {}", file_path.display(), ext);
+        check.error(format!("file {} has unexpected extension {}", file_path.display(), ext));
     }
 }
 
-fn check_stray_output_snapshot(bad: &mut bool, file_path: &Path, testname: &str) {
+fn check_stray_output_snapshot(check: &mut RunningCheck, file_path: &Path, testname: &str) {
     // Test output filenames have one of the formats:
     // ```
     // $testname.stderr
@@ -197,20 +197,20 @@ fn check_stray_output_snapshot(bad: &mut bool, file_path: &Path, testname: &str)
     if !file_path.with_file_name(testname).with_extension("rs").exists()
         && !testname.contains("ignore-tidy")
     {
-        tidy_error!(bad, "Stray file with UI testing output: {:?}", file_path);
+        check.error(format!("Stray file with UI testing output: {:?}", file_path));
     }
 }
 
-fn check_empty_output_snapshot(bad: &mut bool, file_path: &Path) {
+fn check_empty_output_snapshot(check: &mut RunningCheck, file_path: &Path) {
     if let Ok(metadata) = fs::metadata(file_path)
         && metadata.len() == 0
     {
-        tidy_error!(bad, "Empty file with UI testing output: {:?}", file_path);
+        check.error(format!("Empty file with UI testing output: {:?}", file_path));
     }
 }
 
 fn deny_new_nondescriptive_test_names(
-    bad: &mut bool,
+    check: &mut RunningCheck,
     path: &Path,
     remaining_issue_names: &mut BTreeSet<&str>,
     file_path: &Path,
@@ -231,11 +231,10 @@ fn deny_new_nondescriptive_test_names(
         if !remaining_issue_names.remove(stripped_path.as_str())
             && !stripped_path.starts_with("ui/issues/")
         {
-            tidy_error!(
-                bad,
+            check.error(format!(
                 "file `tests/{stripped_path}` must begin with a descriptive name, consider `{{reason}}-issue-{issue_n}.rs`",
                 issue_n = &test_name[1],
-            );
+            ));
         }
     }
 }
diff --git a/src/tools/tidy/src/unit_tests.rs b/src/tools/tidy/src/unit_tests.rs
index 7396310ed37c9..cab445ac63a1b 100644
--- a/src/tools/tidy/src/unit_tests.rs
+++ b/src/tools/tidy/src/unit_tests.rs
@@ -11,9 +11,12 @@
 
 use std::path::Path;
 
+use crate::diagnostics::{CheckId, DiagCtx};
 use crate::walk::{filter_dirs, walk};
 
-pub fn check(root_path: &Path, stdlib: bool, bad: &mut bool) {
+pub fn check(root_path: &Path, stdlib: bool, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx.start_check(CheckId::new("unit_tests").path(root_path));
+
     let skip = move |path: &Path, is_dir| {
         let file_name = path.file_name().unwrap_or_default();
 
@@ -92,14 +95,11 @@ pub fn check(root_path: &Path, stdlib: bool, bad: &mut bool) {
                         .to_owned()
                 };
                 let name = if is_test() { "test" } else { "bench" };
-                tidy_error!(
-                    bad,
-                    "`{}:{}` contains `#[{}]`; {}",
+                check.error(format!(
+                    "`{}:{}` contains `#[{name}]`; {explanation}",
                     path.display(),
                     i + 1,
-                    name,
-                    explanation,
-                );
+                ));
                 return;
             }
         }
diff --git a/src/tools/tidy/src/unknown_revision.rs b/src/tools/tidy/src/unknown_revision.rs
index 0ba05c80a791b..776d45e25de0d 100644
--- a/src/tools/tidy/src/unknown_revision.rs
+++ b/src/tools/tidy/src/unknown_revision.rs
@@ -12,12 +12,14 @@ use std::sync::OnceLock;
 use ignore::DirEntry;
 use regex::Regex;
 
+use crate::diagnostics::{CheckId, DiagCtx, RunningCheck};
 use crate::iter_header::{HeaderLine, iter_header};
 use crate::walk::{filter_dirs, filter_not_rust, walk};
 
-pub fn check(tests_path: impl AsRef<Path>, bad: &mut bool) {
+pub fn check(tests_path: &Path, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx.start_check(CheckId::new("unknown_revision").path(tests_path));
     walk(
-        tests_path.as_ref(),
+        tests_path,
         |path, is_dir| {
             filter_dirs(path) || filter_not_rust(path) || {
                 // Auxiliary source files for incremental tests can refer to revisions
@@ -25,11 +27,11 @@ pub fn check(tests_path: impl AsRef<Path>, bad: &mut bool) {
                 is_dir && path.file_name().is_some_and(|name| name == "auxiliary")
             }
         },
-        &mut |entry, contents| visit_test_file(entry, contents, bad),
+        &mut |entry, contents| visit_test_file(entry, contents, &mut check),
     );
 }
 
-fn visit_test_file(entry: &DirEntry, contents: &str, bad: &mut bool) {
+fn visit_test_file(entry: &DirEntry, contents: &str, check: &mut RunningCheck) {
     let mut revisions = HashSet::new();
     let mut unused_revision_names = HashSet::new();
 
@@ -68,10 +70,9 @@ fn visit_test_file(entry: &DirEntry, contents: &str, bad: &mut bool) {
 
     // Fail if any revision names appear in both places, since that's probably a mistake.
     for rev in revisions.intersection(&unused_revision_names).copied().collect::<BTreeSet<_>>() {
-        tidy_error!(
-            bad,
+        check.error(format!(
             "revision name [{rev}] appears in both `revisions` and `unused-revision-names` in {path}"
-        );
+        ));
     }
 
     // Compute the set of revisions that were mentioned but not declared,
@@ -84,7 +85,7 @@ fn visit_test_file(entry: &DirEntry, contents: &str, bad: &mut bool) {
     bad_revisions.sort();
 
     for (line_number, rev) in bad_revisions {
-        tidy_error!(bad, "unknown revision [{rev}] at {path}:{line_number}");
+        check.error(format!("unknown revision [{rev}] at {path}:{line_number}"));
     }
 }
 
diff --git a/src/tools/tidy/src/unstable_book.rs b/src/tools/tidy/src/unstable_book.rs
index 0ed954d48deb1..bab294abee02d 100644
--- a/src/tools/tidy/src/unstable_book.rs
+++ b/src/tools/tidy/src/unstable_book.rs
@@ -2,6 +2,7 @@ use std::collections::BTreeSet;
 use std::fs;
 use std::path::{Path, PathBuf};
 
+use crate::diagnostics::{DiagCtx, RunningCheck};
 use crate::features::{CollectedFeatures, Features, Status};
 
 pub const PATH_STR: &str = "doc/unstable-book";
@@ -75,19 +76,18 @@ fn collect_unstable_book_lib_features_section_file_names(base_src_path: &Path) -
 }
 
 /// Would switching underscores for dashes work?
-fn maybe_suggest_dashes(names: &BTreeSet<String>, feature_name: &str, bad: &mut bool) {
+fn maybe_suggest_dashes(names: &BTreeSet<String>, feature_name: &str, check: &mut RunningCheck) {
     let with_dashes = feature_name.replace('_', "-");
     if names.contains(&with_dashes) {
-        tidy_error!(
-            bad,
-            "the file `{}.md` contains underscores; use dashes instead: `{}.md`",
-            feature_name,
-            with_dashes,
-        );
+        check.error(format!(
+            "the file `{feature_name}.md` contains underscores; use dashes instead: `{with_dashes}.md`",
+        ));
     }
 }
 
-pub fn check(path: &Path, features: CollectedFeatures, bad: &mut bool) {
+pub fn check(path: &Path, features: CollectedFeatures, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx.start_check("unstable_book");
+
     let lang_features = features.lang;
     let lib_features = features
         .lib
@@ -108,26 +108,22 @@ pub fn check(path: &Path, features: CollectedFeatures, bad: &mut bool) {
     // Check for Unstable Book sections that don't have a corresponding unstable feature
     for feature_name in &unstable_book_lib_features_section_file_names - &unstable_lib_feature_names
     {
-        tidy_error!(
-            bad,
-            "The Unstable Book has a 'library feature' section '{}' which doesn't \
-                         correspond to an unstable library feature",
-            feature_name
-        );
-        maybe_suggest_dashes(&unstable_lib_feature_names, &feature_name, bad);
+        check.error(format!(
+            "The Unstable Book has a 'library feature' section '{feature_name}' which doesn't \
+                         correspond to an unstable library feature"
+        ));
+        maybe_suggest_dashes(&unstable_lib_feature_names, &feature_name, &mut check);
     }
 
     // Check for Unstable Book sections that don't have a corresponding unstable feature.
     for feature_name in
         &unstable_book_lang_features_section_file_names - &unstable_lang_feature_names
     {
-        tidy_error!(
-            bad,
-            "The Unstable Book has a 'language feature' section '{}' which doesn't \
-                     correspond to an unstable language feature",
-            feature_name
-        );
-        maybe_suggest_dashes(&unstable_lang_feature_names, &feature_name, bad);
+        check.error(format!(
+            "The Unstable Book has a 'language feature' section '{feature_name}' which doesn't \
+                     correspond to an unstable language feature"
+        ));
+        maybe_suggest_dashes(&unstable_lang_feature_names, &feature_name, &mut check);
     }
 
     // List unstable features that don't have Unstable Book sections.
diff --git a/src/tools/tidy/src/x_version.rs b/src/tools/tidy/src/x_version.rs
index 9f7f43c4000b1..b3e322d9403f4 100644
--- a/src/tools/tidy/src/x_version.rs
+++ b/src/tools/tidy/src/x_version.rs
@@ -3,12 +3,18 @@ use std::process::{Command, Stdio};
 
 use semver::Version;
 
-pub fn check(root: &Path, cargo: &Path, bad: &mut bool) {
+use crate::diagnostics::{CheckId, DiagCtx};
+
+pub fn check(root: &Path, cargo: &Path, diag_ctx: DiagCtx) {
+    let mut check = diag_ctx.start_check(CheckId::new("x_version").path(root));
     let cargo_list = Command::new(cargo).args(["install", "--list"]).stdout(Stdio::piped()).spawn();
 
     let child = match cargo_list {
         Ok(child) => child,
-        Err(e) => return tidy_error!(bad, "failed to run `cargo`: {}", e),
+        Err(e) => {
+            check.error(format!("failed to run `cargo`: {e}"));
+            return;
+        }
     };
 
     let cargo_list = child.wait_with_output().unwrap();
@@ -47,13 +53,10 @@ pub fn check(root: &Path, cargo: &Path, bad: &mut bool) {
                 )
             }
         } else {
-            tidy_error!(
-                bad,
-                "Unable to parse the latest version of `x` at `src/tools/x/Cargo.toml`"
-            )
+            check.error("Unable to parse the latest version of `x` at `src/tools/x/Cargo.toml`")
         }
     } else {
-        tidy_error!(bad, "failed to check version of `x`: {}", cargo_list.status)
+        check.error(format!("failed to check version of `x`: {}", cargo_list.status))
     }
 }
 

From 4c208f5c64c3a86e52f5ebff2792ed1e3d8ca5b8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Mon, 15 Sep 2025 15:24:56 +0200
Subject: [PATCH 1204/1889] Implement output of colored messages with optional
 check context

---
 src/tools/features-status-dump/src/main.rs |   3 +-
 src/tools/tidy/src/alphabetical/tests.rs   |  27 +++--
 src/tools/tidy/src/deps.rs                 |   4 +-
 src/tools/tidy/src/diagnostics.rs          | 132 ++++++++++++++++-----
 src/tools/tidy/src/extdeps.rs              |   4 +-
 src/tools/tidy/src/filenames.rs            |   4 +-
 src/tools/tidy/src/main.rs                 |  22 +++-
 src/tools/tidy/src/tests_placement.rs      |   4 +-
 src/tools/tidy/src/triagebot.rs            |   4 +-
 src/tools/unstable-book-gen/src/main.rs    |   3 +-
 10 files changed, 152 insertions(+), 55 deletions(-)

diff --git a/src/tools/features-status-dump/src/main.rs b/src/tools/features-status-dump/src/main.rs
index 1ce98d1506d1c..a4f88362ab816 100644
--- a/src/tools/features-status-dump/src/main.rs
+++ b/src/tools/features-status-dump/src/main.rs
@@ -5,6 +5,7 @@ use std::path::PathBuf;
 
 use anyhow::{Context, Result};
 use clap::Parser;
+use tidy::diagnostics::RunningCheck;
 use tidy::features::{Feature, collect_lang_features, collect_lib_features};
 
 #[derive(Debug, Parser)]
@@ -29,7 +30,7 @@ struct FeaturesStatus {
 fn main() -> Result<()> {
     let Cli { compiler_path, library_path, output_path } = Cli::parse();
 
-    let lang_features_status = collect_lang_features(&compiler_path, &mut false);
+    let lang_features_status = collect_lang_features(&compiler_path, &mut RunningCheck::new_noop());
     let lib_features_status = collect_lib_features(&library_path)
         .into_iter()
         .filter(|&(ref name, _)| !lang_features_status.contains_key(name))
diff --git a/src/tools/tidy/src/alphabetical/tests.rs b/src/tools/tidy/src/alphabetical/tests.rs
index 4d05bc33cedc3..b181ab8f744f9 100644
--- a/src/tools/tidy/src/alphabetical/tests.rs
+++ b/src/tools/tidy/src/alphabetical/tests.rs
@@ -1,19 +1,22 @@
-use std::io::Write;
-use std::str::from_utf8;
+use std::path::Path;
 
-use super::*;
+use crate::alphabetical::check_lines;
+use crate::diagnostics::DiagCtx;
 
 #[track_caller]
 fn test(lines: &str, name: &str, expected_msg: &str, expected_bad: bool) {
-    let mut actual_msg = Vec::new();
-    let mut actual_bad = false;
-    let mut err = |args: &_| {
-        write!(&mut actual_msg, "{args}")?;
-        Ok(())
-    };
-    check_lines(&name, lines.lines().enumerate(), &mut err, &mut actual_bad);
-    assert_eq!(expected_msg, from_utf8(&actual_msg).unwrap());
-    assert_eq!(expected_bad, actual_bad);
+    let diag_ctx = DiagCtx::new(Path::new("/"), false);
+    let mut check = diag_ctx.start_check("alphabetical-test");
+    check_lines(&name, lines.lines().enumerate(), &mut check);
+
+    assert_eq!(expected_bad, check.is_bad());
+    let errors = check.get_errors();
+    if expected_bad {
+        assert_eq!(errors.len(), 1);
+        assert_eq!(expected_msg, errors[0]);
+    } else {
+        assert!(errors.is_empty());
+    }
 }
 
 #[track_caller]
diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs
index a9d07c7531579..e275d3042cbba 100644
--- a/src/tools/tidy/src/deps.rs
+++ b/src/tools/tidy/src/deps.rs
@@ -9,7 +9,7 @@ use build_helper::ci::CiEnv;
 use cargo_metadata::semver::Version;
 use cargo_metadata::{Metadata, Package, PackageId};
 
-use crate::diagnostics::{CheckId, DiagCtx, RunningCheck};
+use crate::diagnostics::{DiagCtx, RunningCheck};
 
 #[path = "../../../bootstrap/src/utils/proc_macro_deps.rs"]
 mod proc_macro_deps;
@@ -664,7 +664,7 @@ const PERMITTED_CRANELIFT_DEPENDENCIES: &[&str] = &[
 /// `root` is path to the directory with the root `Cargo.toml` (for the workspace). `cargo` is path
 /// to the cargo executable.
 pub fn check(root: &Path, cargo: &Path, bless: bool, diag_ctx: DiagCtx) {
-    let mut check = diag_ctx.start_check(CheckId::new("deps").path(root));
+    let mut check = diag_ctx.start_check("deps");
 
     let mut checked_runtime_licenses = false;
 
diff --git a/src/tools/tidy/src/diagnostics.rs b/src/tools/tidy/src/diagnostics.rs
index d7889f925ea91..6e95f97d0104f 100644
--- a/src/tools/tidy/src/diagnostics.rs
+++ b/src/tools/tidy/src/diagnostics.rs
@@ -1,9 +1,9 @@
 use std::collections::HashSet;
-use std::fmt::Display;
+use std::fmt::{Display, Formatter};
 use std::path::{Path, PathBuf};
 use std::sync::{Arc, Mutex};
 
-use termcolor::WriteColor;
+use termcolor::{Color, WriteColor};
 
 /// Collects diagnostics from all tidy steps, and contains shared information
 /// that determines how should message and logs be presented.
@@ -14,26 +14,40 @@ use termcolor::WriteColor;
 pub struct DiagCtx(Arc<Mutex<DiagCtxInner>>);
 
 impl DiagCtx {
-    pub fn new(verbose: bool) -> Self {
+    pub fn new(root_path: &Path, verbose: bool) -> Self {
         Self(Arc::new(Mutex::new(DiagCtxInner {
             running_checks: Default::default(),
             finished_checks: Default::default(),
+            root_path: root_path.to_path_buf(),
             verbose,
         })))
     }
 
     pub fn start_check<Id: Into<CheckId>>(&self, id: Id) -> RunningCheck {
-        let id = id.into();
+        let mut id = id.into();
 
         let mut ctx = self.0.lock().unwrap();
+
+        // Shorten path for shorter diagnostics
+        id.path = match id.path {
+            Some(path) => Some(path.strip_prefix(&ctx.root_path).unwrap_or(&path).to_path_buf()),
+            None => None,
+        };
+
         ctx.start_check(id.clone());
-        RunningCheck { id, bad: false, ctx: self.0.clone() }
+        RunningCheck {
+            id,
+            bad: false,
+            ctx: self.0.clone(),
+            #[cfg(test)]
+            errors: vec![],
+        }
     }
 
-    pub fn into_conclusion(self) -> bool {
-        let ctx = self.0.lock().unwrap();
+    pub fn into_failed_checks(self) -> Vec<FinishedCheck> {
+        let ctx = Arc::into_inner(self.0).unwrap().into_inner().unwrap();
         assert!(ctx.running_checks.is_empty(), "Some checks are still running");
-        ctx.finished_checks.iter().any(|c| c.bad)
+        ctx.finished_checks.into_iter().filter(|c| c.bad).collect()
     }
 }
 
@@ -41,6 +55,7 @@ struct DiagCtxInner {
     running_checks: HashSet<CheckId>,
     finished_checks: HashSet<FinishedCheck>,
     verbose: bool,
+    root_path: PathBuf,
 }
 
 impl DiagCtxInner {
@@ -48,6 +63,7 @@ impl DiagCtxInner {
         if self.has_check_id(&id) {
             panic!("Starting a check named `{id:?}` for the second time");
         }
+
         self.running_checks.insert(id);
     }
 
@@ -57,6 +73,13 @@ impl DiagCtxInner {
             "Finishing check `{:?}` that was not started",
             check.id
         );
+
+        if check.bad {
+            output_message("FAIL", Some(&check.id), Some(COLOR_ERROR));
+        } else if self.verbose {
+            output_message("OK", Some(&check.id), Some(COLOR_SUCCESS));
+        }
+
         self.finished_checks.insert(check);
     }
 
@@ -71,8 +94,8 @@ impl DiagCtxInner {
 /// Identifies a single step
 #[derive(PartialEq, Eq, Hash, Clone, Debug)]
 pub struct CheckId {
-    name: String,
-    path: Option<PathBuf>,
+    pub name: String,
+    pub path: Option<PathBuf>,
 }
 
 impl CheckId {
@@ -91,40 +114,70 @@ impl From<&'static str> for CheckId {
     }
 }
 
+impl Display for CheckId {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.name)?;
+        if let Some(path) = &self.path {
+            write!(f, " ({})", path.display())?;
+        }
+        Ok(())
+    }
+}
+
 #[derive(PartialEq, Eq, Hash, Debug)]
-struct FinishedCheck {
+pub struct FinishedCheck {
     id: CheckId,
     bad: bool,
 }
 
+impl FinishedCheck {
+    pub fn id(&self) -> &CheckId {
+        &self.id
+    }
+}
+
 /// Represents a single tidy check, identified by its `name`, running.
 pub struct RunningCheck {
     id: CheckId,
     bad: bool,
     ctx: Arc<Mutex<DiagCtxInner>>,
+    #[cfg(test)]
+    errors: Vec<String>,
 }
 
 impl RunningCheck {
+    /// Creates a new instance of a running check without going through the diag
+    /// context.
+    /// Useful if you want to run some functions from tidy without configuring
+    /// diagnostics.
+    pub fn new_noop() -> Self {
+        let ctx = DiagCtx::new(Path::new(""), false);
+        ctx.start_check("noop")
+    }
+
     /// Immediately output an error and mark the check as failed.
-    pub fn error<T: Display>(&mut self, t: T) {
+    pub fn error<T: Display>(&mut self, msg: T) {
         self.mark_as_bad();
-        tidy_error(&t.to_string()).expect("failed to output error");
+        let msg = msg.to_string();
+        output_message(&msg, Some(&self.id), Some(COLOR_ERROR));
+        #[cfg(test)]
+        self.errors.push(msg);
     }
 
     /// Immediately output a warning.
-    pub fn warning<T: Display>(&mut self, t: T) {
-        eprintln!("WARNING: {t}");
+    pub fn warning<T: Display>(&mut self, msg: T) {
+        output_message(&msg.to_string(), Some(&self.id), Some(COLOR_WARNING));
     }
 
     /// Output an informational message
-    pub fn message<T: Display>(&mut self, t: T) {
-        eprintln!("{t}");
+    pub fn message<T: Display>(&mut self, msg: T) {
+        output_message(&msg.to_string(), Some(&self.id), None);
     }
 
     /// Output a message only if verbose output is enabled.
-    pub fn verbose_msg<T: Display>(&mut self, t: T) {
+    pub fn verbose_msg<T: Display>(&mut self, msg: T) {
         if self.is_verbose_enabled() {
-            self.message(t);
+            self.message(msg);
         }
     }
 
@@ -138,6 +191,11 @@ impl RunningCheck {
         self.ctx.lock().unwrap().verbose
     }
 
+    #[cfg(test)]
+    pub fn get_errors(&self) -> Vec<String> {
+        self.errors.clone()
+    }
+
     fn mark_as_bad(&mut self) {
         self.bad = true;
     }
@@ -149,17 +207,37 @@ impl Drop for RunningCheck {
     }
 }
 
-fn tidy_error(args: &str) -> std::io::Result<()> {
+pub const COLOR_SUCCESS: Color = Color::Green;
+pub const COLOR_ERROR: Color = Color::Red;
+pub const COLOR_WARNING: Color = Color::Yellow;
+
+/// Output a message to stderr.
+/// The message can be optionally scoped to a certain check, and it can also have a certain color.
+pub fn output_message(msg: &str, id: Option<&CheckId>, color: Option<Color>) {
     use std::io::Write;
 
-    use termcolor::{Color, ColorChoice, ColorSpec, StandardStream};
+    use termcolor::{ColorChoice, ColorSpec, StandardStream};
 
-    let mut stderr = StandardStream::stdout(ColorChoice::Auto);
-    stderr.set_color(ColorSpec::new().set_fg(Some(Color::Red)))?;
+    let mut stderr = StandardStream::stderr(ColorChoice::Auto);
+    if let Some(color) = &color {
+        stderr.set_color(ColorSpec::new().set_fg(Some(*color))).unwrap();
+    }
 
-    write!(&mut stderr, "tidy error")?;
-    stderr.set_color(&ColorSpec::new())?;
+    match id {
+        Some(id) => {
+            write!(&mut stderr, "tidy [{}", id.name).unwrap();
+            if let Some(path) = &id.path {
+                write!(&mut stderr, " ({})", path.display()).unwrap();
+            }
+            write!(&mut stderr, "]").unwrap();
+        }
+        None => {
+            write!(&mut stderr, "tidy").unwrap();
+        }
+    }
+    if color.is_some() {
+        stderr.set_color(&ColorSpec::new()).unwrap();
+    }
 
-    writeln!(&mut stderr, ": {args}")?;
-    Ok(())
+    writeln!(&mut stderr, ": {msg}").unwrap();
 }
diff --git a/src/tools/tidy/src/extdeps.rs b/src/tools/tidy/src/extdeps.rs
index 21612980007d8..f75de13b45ceb 100644
--- a/src/tools/tidy/src/extdeps.rs
+++ b/src/tools/tidy/src/extdeps.rs
@@ -4,7 +4,7 @@ use std::fs;
 use std::path::Path;
 
 use crate::deps::WorkspaceInfo;
-use crate::diagnostics::{CheckId, DiagCtx};
+use crate::diagnostics::DiagCtx;
 
 /// List of allowed sources for packages.
 const ALLOWED_SOURCES: &[&str] = &[
@@ -16,7 +16,7 @@ const ALLOWED_SOURCES: &[&str] = &[
 /// Checks for external package sources. `root` is the path to the directory that contains the
 /// workspace `Cargo.toml`.
 pub fn check(root: &Path, diag_ctx: DiagCtx) {
-    let mut check = diag_ctx.start_check(CheckId::new("extdeps").path(root));
+    let mut check = diag_ctx.start_check("extdeps");
 
     for &WorkspaceInfo { path, submodules, .. } in crate::deps::WORKSPACES {
         if crate::deps::has_missing_submodule(root, submodules) {
diff --git a/src/tools/tidy/src/filenames.rs b/src/tools/tidy/src/filenames.rs
index d52a82297388f..835cbefbf6910 100644
--- a/src/tools/tidy/src/filenames.rs
+++ b/src/tools/tidy/src/filenames.rs
@@ -10,10 +10,10 @@
 use std::path::Path;
 use std::process::Command;
 
-use crate::diagnostics::{CheckId, DiagCtx};
+use crate::diagnostics::DiagCtx;
 
 pub fn check(root_path: &Path, diag_ctx: DiagCtx) {
-    let mut check = diag_ctx.start_check(CheckId::new("filenames").path(root_path));
+    let mut check = diag_ctx.start_check("filenames");
     let stat_output = Command::new("git")
         .arg("-C")
         .arg(root_path)
diff --git a/src/tools/tidy/src/main.rs b/src/tools/tidy/src/main.rs
index 73ff183868a27..93bc16111992a 100644
--- a/src/tools/tidy/src/main.rs
+++ b/src/tools/tidy/src/main.rs
@@ -11,7 +11,7 @@ use std::str::FromStr;
 use std::thread::{self, ScopedJoinHandle, scope};
 use std::{env, process};
 
-use tidy::diagnostics::DiagCtx;
+use tidy::diagnostics::{COLOR_ERROR, COLOR_SUCCESS, DiagCtx, output_message};
 use tidy::*;
 
 fn main() {
@@ -50,7 +50,7 @@ fn main() {
     let extra_checks =
         cfg_args.iter().find(|s| s.starts_with("--extra-checks=")).map(String::as_str);
 
-    let diag_ctx = DiagCtx::new(verbose);
+    let diag_ctx = DiagCtx::new(&root_path, verbose);
     let ci_info = CiInfo::new(diag_ctx.clone());
 
     let drain_handles = |handles: &mut VecDeque<ScopedJoinHandle<'_, ()>>| {
@@ -175,8 +175,22 @@ fn main() {
         );
     });
 
-    if diag_ctx.into_conclusion() {
-        eprintln!("some tidy checks failed");
+    let failed_checks = diag_ctx.into_failed_checks();
+    if !failed_checks.is_empty() {
+        let mut failed: Vec<String> =
+            failed_checks.into_iter().map(|c| c.id().to_string()).collect();
+        failed.sort();
+        output_message(
+            &format!(
+                "The following check{} failed: {}",
+                if failed.len() > 1 { "s" } else { "" },
+                failed.join(", ")
+            ),
+            None,
+            Some(COLOR_ERROR),
+        );
         process::exit(1);
+    } else {
+        output_message("All tidy checks succeeded", None, Some(COLOR_SUCCESS));
     }
 }
diff --git a/src/tools/tidy/src/tests_placement.rs b/src/tools/tidy/src/tests_placement.rs
index e978e1c453c1e..8ba8cf552bd7f 100644
--- a/src/tools/tidy/src/tests_placement.rs
+++ b/src/tools/tidy/src/tests_placement.rs
@@ -1,12 +1,12 @@
 use std::path::Path;
 
-use crate::diagnostics::{CheckId, DiagCtx};
+use crate::diagnostics::DiagCtx;
 
 const FORBIDDEN_PATH: &str = "src/test";
 const ALLOWED_PATH: &str = "tests";
 
 pub fn check(root_path: &Path, diag_ctx: DiagCtx) {
-    let mut check = diag_ctx.start_check(CheckId::new("tests-placement").path(root_path));
+    let mut check = diag_ctx.start_check("tests_placement");
 
     if root_path.join(FORBIDDEN_PATH).exists() {
         check.error(format!(
diff --git a/src/tools/tidy/src/triagebot.rs b/src/tools/tidy/src/triagebot.rs
index 9eccef29f2e2a..41d61dcd14118 100644
--- a/src/tools/tidy/src/triagebot.rs
+++ b/src/tools/tidy/src/triagebot.rs
@@ -4,10 +4,10 @@ use std::path::Path;
 
 use toml::Value;
 
-use crate::diagnostics::{CheckId, DiagCtx};
+use crate::diagnostics::DiagCtx;
 
 pub fn check(path: &Path, diag_ctx: DiagCtx) {
-    let mut check = diag_ctx.start_check(CheckId::new("triagebot").path(path));
+    let mut check = diag_ctx.start_check("triagebot");
     let triagebot_path = path.join("triagebot.toml");
 
     // This check is mostly to catch broken path filters *within* `triagebot.toml`, and not enforce
diff --git a/src/tools/unstable-book-gen/src/main.rs b/src/tools/unstable-book-gen/src/main.rs
index a7c6173d88c48..16550f83003dc 100644
--- a/src/tools/unstable-book-gen/src/main.rs
+++ b/src/tools/unstable-book-gen/src/main.rs
@@ -5,6 +5,7 @@ use std::env;
 use std::fs::{self, write};
 use std::path::Path;
 
+use tidy::diagnostics::RunningCheck;
 use tidy::features::{Features, collect_env_vars, collect_lang_features, collect_lib_features};
 use tidy::t;
 use tidy::unstable_book::{
@@ -122,7 +123,7 @@ fn main() {
     let src_path = Path::new(&src_path_str);
     let dest_path = Path::new(&dest_path_str);
 
-    let lang_features = collect_lang_features(compiler_path, &mut false);
+    let lang_features = collect_lang_features(compiler_path, &mut RunningCheck::new_noop());
     let lib_features = collect_lib_features(library_path)
         .into_iter()
         .filter(|&(ref name, _)| !lang_features.contains_key(name))

From 6abcadc235c24b0541e7bb3b6f6444d397d32f35 Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Sun, 21 Sep 2025 10:20:56 -0400
Subject: [PATCH 1205/1889] Port #[macro_export] to the new attribute parsing
 infrastructure

Co-authored-by: Anne Stijns <anstijns@gmail.com>
---
 .../src/attributes/macro_attrs.rs             | 63 +++++++++++++++++++
 compiler/rustc_attr_parsing/src/context.rs    |  3 +-
 compiler/rustc_attr_parsing/src/lints.rs      | 12 ++++
 compiler/rustc_expand/src/base.rs             |  6 +-
 .../rustc_hir/src/attrs/data_structures.rs    |  3 +
 .../rustc_hir/src/attrs/encode_cross_crate.rs |  1 +
 compiler/rustc_hir/src/lints.rs               | 35 +++++++++--
 compiler/rustc_lint/src/non_local_def.rs      | 10 ++-
 compiler/rustc_lint_defs/src/builtin.rs       |  7 ++-
 compiler/rustc_passes/messages.ftl            |  7 ---
 compiler/rustc_passes/src/check_attr.rs       | 60 ++++++------------
 compiler/rustc_passes/src/errors.rs           |  9 ---
 src/librustdoc/html/render/search_index.rs    | 23 ++++---
 src/librustdoc/json/conversions.rs            |  9 +--
 src/librustdoc/passes/strip_hidden.rs         |  5 +-
 src/librustdoc/visit_ast.rs                   | 10 +--
 .../src/macro_metavars_in_unsafe.rs           |  7 ++-
 17 files changed, 177 insertions(+), 93 deletions(-)

diff --git a/compiler/rustc_attr_parsing/src/attributes/macro_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/macro_attrs.rs
index 180130c7be4fc..849141c34f7d9 100644
--- a/compiler/rustc_attr_parsing/src/attributes/macro_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/macro_attrs.rs
@@ -1,3 +1,4 @@
+use rustc_ast::AttrStyle;
 use rustc_errors::DiagArgValue;
 use rustc_hir::attrs::MacroUseArgs;
 
@@ -133,3 +134,65 @@ impl<S: Stage> NoArgsAttributeParser<S> for AllowInternalUnsafeParser {
     ]);
     const CREATE: fn(Span) -> AttributeKind = |span| AttributeKind::AllowInternalUnsafe(span);
 }
+
+pub(crate) struct MacroExportParser;
+
+impl<S: Stage> SingleAttributeParser<S> for MacroExportParser {
+    const PATH: &[Symbol] = &[sym::macro_export];
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const TEMPLATE: AttributeTemplate = template!(Word, List: &["local_inner_macros"]);
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowListWarnRest(&[
+        Allow(Target::MacroDef),
+        Error(Target::WherePredicate),
+        Error(Target::Crate),
+    ]);
+
+    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
+        let suggestions = || {
+            <Self as SingleAttributeParser<S>>::TEMPLATE
+                .suggestions(AttrStyle::Inner, "macro_export")
+        };
+        let local_inner_macros = match args {
+            ArgParser::NoArgs => false,
+            ArgParser::List(list) => {
+                let Some(l) = list.single() else {
+                    let span = cx.attr_span;
+                    cx.emit_lint(
+                        AttributeLintKind::InvalidMacroExportArguments {
+                            suggestions: suggestions(),
+                        },
+                        span,
+                    );
+                    return None;
+                };
+                match l.meta_item().and_then(|i| i.path().word_sym()) {
+                    Some(sym::local_inner_macros) => true,
+                    _ => {
+                        let span = cx.attr_span;
+                        cx.emit_lint(
+                            AttributeLintKind::InvalidMacroExportArguments {
+                                suggestions: suggestions(),
+                            },
+                            span,
+                        );
+                        return None;
+                    }
+                }
+            }
+            ArgParser::NameValue(_) => {
+                let span = cx.attr_span;
+                let suggestions = suggestions();
+                cx.emit_err(IllFormedAttributeInputLint {
+                    num_suggestions: suggestions.len(),
+                    suggestions: DiagArgValue::StrListSepByAnd(
+                        suggestions.into_iter().map(|s| format!("`{s}`").into()).collect(),
+                    ),
+                    span,
+                });
+                return None;
+            }
+        };
+        Some(AttributeKind::MacroExport { span: cx.attr_span, local_inner_macros })
+    }
+}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index ee5b7322b0247..4c32bb87a242c 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -40,7 +40,7 @@ use crate::attributes::lint_helpers::{
 };
 use crate::attributes::loop_match::{ConstContinueParser, LoopMatchParser};
 use crate::attributes::macro_attrs::{
-    AllowInternalUnsafeParser, MacroEscapeParser, MacroUseParser,
+    AllowInternalUnsafeParser, MacroEscapeParser, MacroExportParser, MacroUseParser,
 };
 use crate::attributes::must_use::MustUseParser;
 use crate::attributes::no_implicit_prelude::NoImplicitPreludeParser;
@@ -183,6 +183,7 @@ attribute_parsers!(
         Single<LinkOrdinalParser>,
         Single<LinkSectionParser>,
         Single<LinkageParser>,
+        Single<MacroExportParser>,
         Single<MoveSizeLimitParser>,
         Single<MustUseParser>,
         Single<ObjcClassParser>,
diff --git a/compiler/rustc_attr_parsing/src/lints.rs b/compiler/rustc_attr_parsing/src/lints.rs
index b1a971eec3245..ab8ba0daf1f10 100644
--- a/compiler/rustc_attr_parsing/src/lints.rs
+++ b/compiler/rustc_attr_parsing/src/lints.rs
@@ -31,6 +31,18 @@ pub fn emit_attribute_lint<L: LintEmitter>(lint: &AttributeLint<L::Id>, lint_emi
                 },
             );
         }
+        AttributeLintKind::InvalidMacroExportArguments { suggestions } => lint_emitter
+            .emit_node_span_lint(
+                rustc_session::lint::builtin::INVALID_MACRO_EXPORT_ARGUMENTS,
+                *id,
+                *span,
+                session_diagnostics::IllFormedAttributeInput {
+                    num_suggestions: suggestions.len(),
+                    suggestions: DiagArgValue::StrListSepByAnd(
+                        suggestions.into_iter().map(|s| format!("`{s}`").into()).collect(),
+                    ),
+                },
+            ),
         AttributeLintKind::EmptyAttribute { first_span } => lint_emitter.emit_node_span_lint(
             rustc_session::lint::builtin::UNUSED_ATTRIBUTES,
             *id,
diff --git a/compiler/rustc_expand/src/base.rs b/compiler/rustc_expand/src/base.rs
index 88f88f30a8c69..3956125bace02 100644
--- a/compiler/rustc_expand/src/base.rs
+++ b/compiler/rustc_expand/src/base.rs
@@ -942,9 +942,9 @@ impl SyntaxExtension {
                 .unwrap_or_default();
         let allow_internal_unsafe = find_attr!(attrs, AttributeKind::AllowInternalUnsafe(_));
 
-        let local_inner_macros = ast::attr::find_by_name(attrs, sym::macro_export)
-            .and_then(|macro_export| macro_export.meta_item_list())
-            .is_some_and(|l| ast::attr::list_contains_name(&l, sym::local_inner_macros));
+        let local_inner_macros =
+            *find_attr!(attrs, AttributeKind::MacroExport {local_inner_macros: l, ..} => l)
+                .unwrap_or(&false);
         let collapse_debuginfo = Self::get_collapse_debuginfo(sess, attrs, !is_local);
         tracing::debug!(?name, ?local_inner_macros, ?collapse_debuginfo, ?allow_internal_unsafe);
 
diff --git a/compiler/rustc_hir/src/attrs/data_structures.rs b/compiler/rustc_hir/src/attrs/data_structures.rs
index 0784675b177a0..8ab43ff2582c0 100644
--- a/compiler/rustc_hir/src/attrs/data_structures.rs
+++ b/compiler/rustc_hir/src/attrs/data_structures.rs
@@ -551,6 +551,9 @@ pub enum AttributeKind {
     /// Represents `#[macro_escape]`.
     MacroEscape(Span),
 
+    /// Represents [`#[macro_export]`](https://doc.rust-lang.org/reference/macros-by-example.html#r-macro.decl.scope.path).
+    MacroExport { span: Span, local_inner_macros: bool },
+
     /// Represents `#[rustc_macro_transparency]`.
     MacroTransparency(Transparency),
 
diff --git a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
index 563e7a58c6d5e..8e44340507478 100644
--- a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
+++ b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
@@ -56,6 +56,7 @@ impl AttributeKind {
             Linkage(..) => No,
             LoopMatch(..) => No,
             MacroEscape(..) => No,
+            MacroExport { .. } => Yes,
             MacroTransparency(..) => Yes,
             MacroUse { .. } => No,
             Marker(..) => No,
diff --git a/compiler/rustc_hir/src/lints.rs b/compiler/rustc_hir/src/lints.rs
index 0b24052b453e4..b7a0a6a0c197f 100644
--- a/compiler/rustc_hir/src/lints.rs
+++ b/compiler/rustc_hir/src/lints.rs
@@ -31,9 +31,34 @@ pub struct AttributeLint<Id> {
 
 #[derive(Clone, Debug, HashStable_Generic)]
 pub enum AttributeLintKind {
-    UnusedDuplicate { this: Span, other: Span, warning: bool },
-    IllFormedAttributeInput { suggestions: Vec<String> },
-    EmptyAttribute { first_span: Span },
-    InvalidTarget { name: AttrPath, target: Target, applied: Vec<String>, only: &'static str },
-    InvalidStyle { name: AttrPath, is_used_as_inner: bool, target: Target, target_span: Span },
+    UnusedDuplicate {
+        this: Span,
+        other: Span,
+        warning: bool,
+    },
+    IllFormedAttributeInput {
+        suggestions: Vec<String>,
+    },
+    EmptyAttribute {
+        first_span: Span,
+    },
+
+    /// Copy of `IllFormedAttributeInput`
+    /// specifically for the `invalid_macro_export_arguments` lint until that is removed,
+    /// see <https://github.com/rust-lang/rust/pull/143857#issuecomment-3079175663>
+    InvalidMacroExportArguments {
+        suggestions: Vec<String>,
+    },
+    InvalidTarget {
+        name: AttrPath,
+        target: Target,
+        applied: Vec<String>,
+        only: &'static str,
+    },
+    InvalidStyle {
+        name: AttrPath,
+        is_used_as_inner: bool,
+        target: Target,
+        target_span: Span,
+    },
 }
diff --git a/compiler/rustc_lint/src/non_local_def.rs b/compiler/rustc_lint/src/non_local_def.rs
index dca22b986ffaa..b10be22dc389d 100644
--- a/compiler/rustc_lint/src/non_local_def.rs
+++ b/compiler/rustc_lint/src/non_local_def.rs
@@ -1,11 +1,12 @@
 use rustc_errors::MultiSpan;
+use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::intravisit::{self, Visitor, VisitorExt};
-use rustc_hir::{Body, HirId, Item, ItemKind, Node, Path, TyKind};
+use rustc_hir::{Body, HirId, Item, ItemKind, Node, Path, TyKind, find_attr};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::{declare_lint, impl_lint_pass};
 use rustc_span::def_id::{DefId, LOCAL_CRATE};
-use rustc_span::{ExpnKind, Span, kw, sym};
+use rustc_span::{ExpnKind, Span, kw};
 
 use crate::lints::{NonLocalDefinitionsCargoUpdateNote, NonLocalDefinitionsDiag};
 use crate::{LateContext, LateLintPass, LintContext, fluent_generated as fluent};
@@ -241,7 +242,10 @@ impl<'tcx> LateLintPass<'tcx> for NonLocalDefinitions {
                 )
             }
             ItemKind::Macro(_, _macro, _kinds)
-                if cx.tcx.has_attr(item.owner_id.def_id, sym::macro_export) =>
+                if find_attr!(
+                    cx.tcx.get_all_attrs(item.owner_id.def_id),
+                    AttributeKind::MacroExport { .. }
+                ) =>
             {
                 cx.emit_span_lint(
                     NON_LOCAL_DEFINITIONS,
diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs
index b79075ac09b9c..3d0974d5d2809 100644
--- a/compiler/rustc_lint_defs/src/builtin.rs
+++ b/compiler/rustc_lint_defs/src/builtin.rs
@@ -4191,8 +4191,13 @@ declare_lint! {
     /// You can't have multiple arguments in a `#[macro_export(..)]`, or mention arguments other than `local_inner_macros`.
     ///
     pub INVALID_MACRO_EXPORT_ARGUMENTS,
-    Warn,
+    Deny,
     "\"invalid_parameter\" isn't a valid argument for `#[macro_export]`",
+    @future_incompatible = FutureIncompatibleInfo {
+        reason: FutureIncompatibilityReason::FutureReleaseError,
+        reference: "issue #57571 <https://github.com/rust-lang/rust/issues/57571>",
+        report_in_deps: true,
+    };
 }
 
 declare_lint! {
diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index 75537caa8946a..6cd68380e46f1 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -349,10 +349,6 @@ passes_invalid_attr_at_crate_level =
 passes_invalid_attr_at_crate_level_item =
     the inner attribute doesn't annotate this {$kind}
 
-passes_invalid_macro_export_arguments = invalid `#[macro_export]` argument
-
-passes_invalid_macro_export_arguments_too_many_items = `#[macro_export]` can only take 1 or 0 arguments
-
 passes_lang_item_fn = {$name ->
     [panic_impl] `#[panic_handler]`
     *[other] `{$name}` lang item
@@ -392,9 +388,6 @@ passes_loop_match_attr =
     `#[loop_match]` should be applied to a loop
     .label = not a loop
 
-passes_macro_export =
-    `#[macro_export]` only has an effect on macro definitions
-
 passes_macro_export_on_decl_macro =
     `#[macro_export]` has no effect on declarative macro definitions
     .note = declarative macros follow the same exporting rules as regular items
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 4d5a8447695be..94c9e71ce7705 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -38,8 +38,8 @@ use rustc_middle::{bug, span_bug};
 use rustc_session::config::CrateType;
 use rustc_session::lint;
 use rustc_session::lint::builtin::{
-    CONFLICTING_REPR_HINTS, INVALID_DOC_ATTRIBUTES, INVALID_MACRO_EXPORT_ARGUMENTS,
-    MALFORMED_DIAGNOSTIC_ATTRIBUTES, MISPLACED_DIAGNOSTIC_ATTRIBUTES, UNUSED_ATTRIBUTES,
+    CONFLICTING_REPR_HINTS, INVALID_DOC_ATTRIBUTES, MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+    MISPLACED_DIAGNOSTIC_ATTRIBUTES, UNUSED_ATTRIBUTES,
 };
 use rustc_session::parse::feature_err;
 use rustc_span::edition::Edition;
@@ -217,7 +217,10 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 },
                 Attribute::Parsed(AttributeKind::Link(_, attr_span)) => {
                     self.check_link(hir_id, *attr_span, span, target)
-                }
+                },
+                Attribute::Parsed(AttributeKind::MacroExport { span, .. }) => {
+                    self.check_macro_export(hir_id, *span, target)
+                },
                 Attribute::Parsed(
                     AttributeKind::BodyStability { .. }
                     | AttributeKind::ConstStabilityIndirect
@@ -331,7 +334,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         [sym::rustc_has_incoherent_inherent_impls, ..] => {
                             self.check_has_incoherent_inherent_impls(attr, span, target)
                         }
-                        [sym::macro_export, ..] => self.check_macro_export(hir_id, attr, target),
                         [sym::autodiff_forward, ..] | [sym::autodiff_reverse, ..] => {
                             self.check_autodiff(hir_id, attr, span, target)
                         }
@@ -1850,45 +1852,22 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         }
     }
 
-    fn check_macro_export(&self, hir_id: HirId, attr: &Attribute, target: Target) {
+    fn check_macro_export(&self, hir_id: HirId, attr_span: Span, target: Target) {
         if target != Target::MacroDef {
+            return;
+        }
+
+        // special case when `#[macro_export]` is applied to a macro 2.0
+        let (_, macro_definition, _) = self.tcx.hir_node(hir_id).expect_item().expect_macro();
+        let is_decl_macro = !macro_definition.macro_rules;
+
+        if is_decl_macro {
             self.tcx.emit_node_span_lint(
                 UNUSED_ATTRIBUTES,
                 hir_id,
-                attr.span(),
-                errors::MacroExport::Normal,
+                attr_span,
+                errors::MacroExport::OnDeclMacro,
             );
-        } else if let Some(meta_item_list) = attr.meta_item_list()
-            && !meta_item_list.is_empty()
-        {
-            if meta_item_list.len() > 1 {
-                self.tcx.emit_node_span_lint(
-                    INVALID_MACRO_EXPORT_ARGUMENTS,
-                    hir_id,
-                    attr.span(),
-                    errors::MacroExport::TooManyItems,
-                );
-            } else if !meta_item_list[0].has_name(sym::local_inner_macros) {
-                self.tcx.emit_node_span_lint(
-                    INVALID_MACRO_EXPORT_ARGUMENTS,
-                    hir_id,
-                    meta_item_list[0].span(),
-                    errors::MacroExport::InvalidArgument,
-                );
-            }
-        } else {
-            // special case when `#[macro_export]` is applied to a macro 2.0
-            let (_, macro_definition, _) = self.tcx.hir_node(hir_id).expect_item().expect_macro();
-            let is_decl_macro = !macro_definition.macro_rules;
-
-            if is_decl_macro {
-                self.tcx.emit_node_span_lint(
-                    UNUSED_ATTRIBUTES,
-                    hir_id,
-                    attr.span(),
-                    errors::MacroExport::OnDeclMacro,
-                );
-            }
         }
     }
 
@@ -2253,7 +2232,9 @@ impl<'tcx> Visitor<'tcx> for CheckAttrVisitor<'tcx> {
         // In the long run, the checks should be harmonized.
         if let ItemKind::Macro(_, macro_def, _) = item.kind {
             let def_id = item.owner_id.to_def_id();
-            if macro_def.macro_rules && !self.tcx.has_attr(def_id, sym::macro_export) {
+            if macro_def.macro_rules
+                && !find_attr!(self.tcx.get_all_attrs(def_id), AttributeKind::MacroExport { .. })
+            {
                 check_non_exported_macro_for_invalid_attrs(self.tcx, item);
             }
         }
@@ -2384,7 +2365,6 @@ fn check_invalid_crate_level_attr(tcx: TyCtxt<'_>, attrs: &[Attribute]) {
     // which were unsuccessfully resolved due to cannot determine
     // resolution for the attribute macro error.
     const ATTRS_TO_CHECK: &[Symbol] = &[
-        sym::macro_export,
         sym::rustc_main,
         sym::derive,
         sym::test,
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index 2da4b6f52cf2c..cd8935f6b2f07 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -530,18 +530,9 @@ pub(crate) struct RustcForceInlineCoro {
 
 #[derive(LintDiagnostic)]
 pub(crate) enum MacroExport {
-    #[diag(passes_macro_export)]
-    Normal,
-
     #[diag(passes_macro_export_on_decl_macro)]
     #[note]
     OnDeclMacro,
-
-    #[diag(passes_invalid_macro_export_arguments)]
-    InvalidArgument,
-
-    #[diag(passes_invalid_macro_export_arguments_too_many_items)]
-    TooManyItems,
 }
 
 #[derive(Subdiagnostic)]
diff --git a/src/librustdoc/html/render/search_index.rs b/src/librustdoc/html/render/search_index.rs
index 2984f3ab50eea..3ffce61f7c613 100644
--- a/src/librustdoc/html/render/search_index.rs
+++ b/src/librustdoc/html/render/search_index.rs
@@ -6,6 +6,8 @@ use std::path::Path;
 
 use rustc_ast::join_path_syms;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
+use rustc_hir::attrs::AttributeKind;
+use rustc_hir::find_attr;
 use rustc_middle::ty::TyCtxt;
 use rustc_span::def_id::DefId;
 use rustc_span::sym;
@@ -1458,16 +1460,17 @@ pub(crate) fn build_index(
                     if fqp.last() != Some(&item.name) {
                         return None;
                     }
-                    let path =
-                        if item.ty == ItemType::Macro && tcx.has_attr(defid, sym::macro_export) {
-                            // `#[macro_export]` always exports to the crate root.
-                            vec![tcx.crate_name(defid.krate)]
-                        } else {
-                            if fqp.len() < 2 {
-                                return None;
-                            }
-                            fqp[..fqp.len() - 1].to_vec()
-                        };
+                    let path = if item.ty == ItemType::Macro
+                        && find_attr!(tcx.get_all_attrs(defid), AttributeKind::MacroExport { .. })
+                    {
+                        // `#[macro_export]` always exports to the crate root.
+                        vec![tcx.crate_name(defid.krate)]
+                    } else {
+                        if fqp.len() < 2 {
+                            return None;
+                        }
+                        fqp[..fqp.len() - 1].to_vec()
+                    };
                     if path == item.module_path {
                         return None;
                     }
diff --git a/src/librustdoc/json/conversions.rs b/src/librustdoc/json/conversions.rs
index 6fe94f9d291b4..779e26c7b0f7b 100644
--- a/src/librustdoc/json/conversions.rs
+++ b/src/librustdoc/json/conversions.rs
@@ -912,12 +912,8 @@ fn maybe_from_hir_attr(
         hir::Attribute::Parsed(kind) => kind,
 
         hir::Attribute::Unparsed(_) => {
-            return Some(if attr.has_name(sym::macro_export) {
-                Attribute::MacroExport
-                // FIXME: We should handle `#[doc(hidden)]`.
-            } else {
-                other_attr(tcx, attr)
-            });
+            // FIXME: We should handle `#[doc(hidden)]`.
+            return Some(other_attr(tcx, attr));
         }
     };
 
@@ -925,6 +921,7 @@ fn maybe_from_hir_attr(
         AK::Deprecation { .. } => return None, // Handled separately into Item::deprecation.
         AK::DocComment { .. } => unreachable!("doc comments stripped out earlier"),
 
+        AK::MacroExport { .. } => Attribute::MacroExport,
         AK::MustUse { reason, span: _ } => {
             Attribute::MustUse { reason: reason.map(|s| s.to_string()) }
         }
diff --git a/src/librustdoc/passes/strip_hidden.rs b/src/librustdoc/passes/strip_hidden.rs
index 3388ae46f056c..525d05b6a9860 100644
--- a/src/librustdoc/passes/strip_hidden.rs
+++ b/src/librustdoc/passes/strip_hidden.rs
@@ -2,9 +2,10 @@
 
 use std::mem;
 
+use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def_id::{CRATE_DEF_ID, LocalDefId};
+use rustc_hir::find_attr;
 use rustc_middle::ty::TyCtxt;
-use rustc_span::symbol::sym;
 use tracing::debug;
 
 use crate::clean::utils::inherits_doc_hidden;
@@ -114,7 +115,7 @@ impl DocFolder for Stripper<'_, '_> {
             // If the macro has the `#[macro_export]` attribute, it means it's accessible at the
             // crate level so it should be handled differently.
             clean::MacroItem(..) => {
-                i.attrs.other_attrs.iter().any(|attr| attr.has_name(sym::macro_export))
+                find_attr!(&i.attrs.other_attrs, AttributeKind::MacroExport { .. })
             }
             _ => false,
         };
diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs
index b2e4b59437504..cd28322f5901c 100644
--- a/src/librustdoc/visit_ast.rs
+++ b/src/librustdoc/visit_ast.rs
@@ -5,10 +5,11 @@ use std::mem;
 
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
 use rustc_hir as hir;
+use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def::{DefKind, MacroKinds, Res};
 use rustc_hir::def_id::{DefId, DefIdMap, LocalDefId, LocalDefIdSet};
 use rustc_hir::intravisit::{Visitor, walk_body, walk_item};
-use rustc_hir::{CRATE_HIR_ID, Node};
+use rustc_hir::{CRATE_HIR_ID, Node, find_attr};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::TyCtxt;
 use rustc_span::Span;
@@ -166,7 +167,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
             if !child.reexport_chain.is_empty()
                 && let Res::Def(DefKind::Macro(_), def_id) = child.res
                 && let Some(local_def_id) = def_id.as_local()
-                && self.cx.tcx.has_attr(def_id, sym::macro_export)
+                && find_attr!(self.cx.tcx.get_all_attrs(def_id), AttributeKind::MacroExport { .. })
                 && inserted.insert(def_id)
             {
                 let item = self.cx.tcx.hir_expect_item(local_def_id);
@@ -406,7 +407,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
             || match item.kind {
                 hir::ItemKind::Impl(..) => true,
                 hir::ItemKind::Macro(_, _, _) => {
-                    self.cx.tcx.has_attr(item.owner_id.def_id, sym::macro_export)
+                    find_attr!(self.cx.tcx.get_all_attrs(item.owner_id.def_id), AttributeKind::MacroExport{..})
                 }
                 _ => false,
             }
@@ -524,7 +525,8 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
 
                 let def_id = item.owner_id.to_def_id();
                 let is_macro_2_0 = !macro_def.macro_rules;
-                let nonexported = !tcx.has_attr(def_id, sym::macro_export);
+                let nonexported =
+                    !find_attr!(tcx.get_all_attrs(def_id), AttributeKind::MacroExport { .. });
 
                 if is_macro_2_0 || nonexported || self.inlining {
                     self.add_to_current_mod(item, renamed, import_id);
diff --git a/src/tools/clippy/clippy_lints/src/macro_metavars_in_unsafe.rs b/src/tools/clippy/clippy_lints/src/macro_metavars_in_unsafe.rs
index 9071c9c95f9d7..c5acaf0999332 100644
--- a/src/tools/clippy/clippy_lints/src/macro_metavars_in_unsafe.rs
+++ b/src/tools/clippy/clippy_lints/src/macro_metavars_in_unsafe.rs
@@ -5,10 +5,12 @@ use itertools::Itertools;
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::intravisit::{Visitor, walk_block, walk_expr, walk_stmt};
 use rustc_hir::{BlockCheckMode, Expr, ExprKind, HirId, Stmt, UnsafeSource};
+use rustc_hir::attrs::AttributeKind;
+use rustc_hir::find_attr;
 use rustc_lint::{LateContext, LateLintPass, Level, LintContext};
 use rustc_middle::lint::LevelAndSource;
 use rustc_session::impl_lint_pass;
-use rustc_span::{Span, SyntaxContext, sym};
+use rustc_span::{Span, SyntaxContext};
 use std::collections::BTreeMap;
 use std::collections::btree_map::Entry;
 
@@ -146,7 +148,8 @@ struct BodyVisitor<'a, 'tcx> {
 }
 
 fn is_public_macro(cx: &LateContext<'_>, def_id: LocalDefId) -> bool {
-    (cx.effective_visibilities.is_exported(def_id) || cx.tcx.has_attr(def_id, sym::macro_export))
+    ( cx.effective_visibilities.is_exported(def_id) ||
+        find_attr!(cx.tcx.get_all_attrs(def_id), AttributeKind::MacroExport{..}) )
         && !cx.tcx.is_doc_hidden(def_id)
 }
 

From f7fa83ec626b91c360067e78eae94d9199cf43dc Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Sun, 21 Sep 2025 10:21:11 -0400
Subject: [PATCH 1206/1889] Changes to uitests for macro_export port

Co-authored-by: Anne Stijns <anstijns@gmail.com>
---
 ...invalid_macro_export_argument.allow.stderr |  40 ++
 .../invalid_macro_export_argument.deny.stderr |  93 ++++-
 .../invalid_macro_export_argument.rs          |  12 +-
 tests/ui/attributes/malformed-attrs.rs        |   2 +-
 tests/ui/attributes/malformed-attrs.stderr    |  22 +-
 ...sue-43106-gating-of-builtin-attrs-error.rs |   3 +-
 ...43106-gating-of-builtin-attrs-error.stderr |  79 ++--
 .../issue-43106-gating-of-builtin-attrs.rs    |  30 +-
 ...issue-43106-gating-of-builtin-attrs.stderr | 389 +++++++++---------
 .../lint/unused/unused-attr-duplicate.stderr  |  24 +-
 10 files changed, 417 insertions(+), 277 deletions(-)
 create mode 100644 tests/ui/attributes/invalid_macro_export_argument.allow.stderr

diff --git a/tests/ui/attributes/invalid_macro_export_argument.allow.stderr b/tests/ui/attributes/invalid_macro_export_argument.allow.stderr
new file mode 100644
index 0000000000000..162b315b072a4
--- /dev/null
+++ b/tests/ui/attributes/invalid_macro_export_argument.allow.stderr
@@ -0,0 +1,40 @@
+Future incompatibility report: Future breakage diagnostic:
+warning: valid forms for the attribute are `#![macro_export(local_inner_macros)]` and `#![macro_export]`
+  --> $DIR/invalid_macro_export_argument.rs:7:1
+   |
+LL | #[macro_export(hello, world)]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #57571 <https://github.com/rust-lang/rust/issues/57571>
+
+Future breakage diagnostic:
+warning: valid forms for the attribute are `#![macro_export(local_inner_macros)]` and `#![macro_export]`
+  --> $DIR/invalid_macro_export_argument.rs:14:1
+   |
+LL | #[macro_export(not_local_inner_macros)]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #57571 <https://github.com/rust-lang/rust/issues/57571>
+
+Future breakage diagnostic:
+warning: valid forms for the attribute are `#![macro_export(local_inner_macros)]` and `#![macro_export]`
+  --> $DIR/invalid_macro_export_argument.rs:31:1
+   |
+LL | #[macro_export()]
+   | ^^^^^^^^^^^^^^^^^
+   |
+   = 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 #57571 <https://github.com/rust-lang/rust/issues/57571>
+
+Future breakage diagnostic:
+warning: valid forms for the attribute are `#![macro_export(local_inner_macros)]` and `#![macro_export]`
+  --> $DIR/invalid_macro_export_argument.rs:38:1
+   |
+LL | #[macro_export("blah")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #57571 <https://github.com/rust-lang/rust/issues/57571>
+
diff --git a/tests/ui/attributes/invalid_macro_export_argument.deny.stderr b/tests/ui/attributes/invalid_macro_export_argument.deny.stderr
index 9d44bd162c7b7..ad225ae187b11 100644
--- a/tests/ui/attributes/invalid_macro_export_argument.deny.stderr
+++ b/tests/ui/attributes/invalid_macro_export_argument.deny.stderr
@@ -1,26 +1,103 @@
-error: `#[macro_export]` can only take 1 or 0 arguments
+error: valid forms for the attribute are `#![macro_export(local_inner_macros)]` and `#![macro_export]`
   --> $DIR/invalid_macro_export_argument.rs:7:1
    |
 LL | #[macro_export(hello, world)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = 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 #57571 <https://github.com/rust-lang/rust/issues/57571>
 note: the lint level is defined here
   --> $DIR/invalid_macro_export_argument.rs:4:24
    |
 LL | #![cfg_attr(deny, deny(invalid_macro_export_arguments))]
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: invalid `#[macro_export]` argument
-  --> $DIR/invalid_macro_export_argument.rs:13:16
+error: valid forms for the attribute are `#![macro_export(local_inner_macros)]` and `#![macro_export]`
+  --> $DIR/invalid_macro_export_argument.rs:14:1
    |
 LL | #[macro_export(not_local_inner_macros)]
-   |                ^^^^^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #57571 <https://github.com/rust-lang/rust/issues/57571>
+
+error: valid forms for the attribute are `#![macro_export(local_inner_macros)]` and `#![macro_export]`
+  --> $DIR/invalid_macro_export_argument.rs:31:1
+   |
+LL | #[macro_export()]
+   | ^^^^^^^^^^^^^^^^^
+   |
+   = 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 #57571 <https://github.com/rust-lang/rust/issues/57571>
 
-error: invalid `#[macro_export]` argument
-  --> $DIR/invalid_macro_export_argument.rs:33:16
+error: valid forms for the attribute are `#![macro_export(local_inner_macros)]` and `#![macro_export]`
+  --> $DIR/invalid_macro_export_argument.rs:38:1
    |
 LL | #[macro_export("blah")]
-   |                ^^^^^^
+   | ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #57571 <https://github.com/rust-lang/rust/issues/57571>
+
+error: aborting due to 4 previous errors
+
+Future incompatibility report: Future breakage diagnostic:
+error: valid forms for the attribute are `#![macro_export(local_inner_macros)]` and `#![macro_export]`
+  --> $DIR/invalid_macro_export_argument.rs:7:1
+   |
+LL | #[macro_export(hello, world)]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #57571 <https://github.com/rust-lang/rust/issues/57571>
+note: the lint level is defined here
+  --> $DIR/invalid_macro_export_argument.rs:4:24
+   |
+LL | #![cfg_attr(deny, deny(invalid_macro_export_arguments))]
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: valid forms for the attribute are `#![macro_export(local_inner_macros)]` and `#![macro_export]`
+  --> $DIR/invalid_macro_export_argument.rs:14:1
+   |
+LL | #[macro_export(not_local_inner_macros)]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #57571 <https://github.com/rust-lang/rust/issues/57571>
+note: the lint level is defined here
+  --> $DIR/invalid_macro_export_argument.rs:4:24
+   |
+LL | #![cfg_attr(deny, deny(invalid_macro_export_arguments))]
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 3 previous errors
+Future breakage diagnostic:
+error: valid forms for the attribute are `#![macro_export(local_inner_macros)]` and `#![macro_export]`
+  --> $DIR/invalid_macro_export_argument.rs:31:1
+   |
+LL | #[macro_export()]
+   | ^^^^^^^^^^^^^^^^^
+   |
+   = 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 #57571 <https://github.com/rust-lang/rust/issues/57571>
+note: the lint level is defined here
+  --> $DIR/invalid_macro_export_argument.rs:4:24
+   |
+LL | #![cfg_attr(deny, deny(invalid_macro_export_arguments))]
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: valid forms for the attribute are `#![macro_export(local_inner_macros)]` and `#![macro_export]`
+  --> $DIR/invalid_macro_export_argument.rs:38:1
+   |
+LL | #[macro_export("blah")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #57571 <https://github.com/rust-lang/rust/issues/57571>
+note: the lint level is defined here
+  --> $DIR/invalid_macro_export_argument.rs:4:24
+   |
+LL | #![cfg_attr(deny, deny(invalid_macro_export_arguments))]
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/tests/ui/attributes/invalid_macro_export_argument.rs b/tests/ui/attributes/invalid_macro_export_argument.rs
index c5fe39d062a4e..05a40913434e8 100644
--- a/tests/ui/attributes/invalid_macro_export_argument.rs
+++ b/tests/ui/attributes/invalid_macro_export_argument.rs
@@ -5,13 +5,15 @@
 #![cfg_attr(allow, allow(invalid_macro_export_arguments))]
 
 #[macro_export(hello, world)]
-//[deny]~^ ERROR `#[macro_export]` can only take 1 or 0 arguments
+//[deny]~^ ERROR valid forms for the attribute are
+//[deny]~| WARN this was previously accepted
 macro_rules! a {
     () => ()
 }
 
 #[macro_export(not_local_inner_macros)]
-//[deny]~^ ERROR invalid `#[macro_export]` argument
+//[deny]~^ ERROR valid forms for the attribute are
+//[deny]~| WARN this was previously accepted
 macro_rules! b {
     () => ()
 }
@@ -20,18 +22,22 @@ macro_rules! b {
 macro_rules! c {
     () => ()
 }
+
 #[macro_export(local_inner_macros)]
 macro_rules! d {
     () => ()
 }
 
 #[macro_export()]
+//[deny]~^ ERROR valid forms for the attribute are
+//[deny]~| WARN this was previously accepted
 macro_rules! e {
     () => ()
 }
 
 #[macro_export("blah")]
-//[deny]~^ ERROR invalid `#[macro_export]` argument
+//[deny]~^ ERROR valid forms for the attribute are
+//[deny]~| WARN this was previously accepted
 macro_rules! f {
     () => ()
 }
diff --git a/tests/ui/attributes/malformed-attrs.rs b/tests/ui/attributes/malformed-attrs.rs
index 932aaf7a9e2fa..e30479b03b11f 100644
--- a/tests/ui/attributes/malformed-attrs.rs
+++ b/tests/ui/attributes/malformed-attrs.rs
@@ -211,7 +211,7 @@ extern crate wloop;
 //~^ ERROR can't find crate for `wloop` [E0463]
 
 #[macro_export = 18]
-//~^ ERROR malformed `macro_export` attribute input
+//~^ ERROR valid forms for the attribute are
 #[allow_internal_unsafe = 1]
 //~^ ERROR malformed
 //~| ERROR allow_internal_unsafe side-steps the unsafe_code lint
diff --git a/tests/ui/attributes/malformed-attrs.stderr b/tests/ui/attributes/malformed-attrs.stderr
index b85864b401e37..246029ecf80fe 100644
--- a/tests/ui/attributes/malformed-attrs.stderr
+++ b/tests/ui/attributes/malformed-attrs.stderr
@@ -178,22 +178,6 @@ LL | #[no_link()]
    |
    = note: for more information, visit <https://doc.rust-lang.org/reference/items/extern-crates.html#the-no_link-attribute>
 
-error: malformed `macro_export` attribute input
-  --> $DIR/malformed-attrs.rs:213:1
-   |
-LL | #[macro_export = 18]
-   | ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: for more information, visit <https://doc.rust-lang.org/reference/macros-by-example.html#path-based-scope>
-help: the following are the possible correct uses
-   |
-LL - #[macro_export = 18]
-LL + #[macro_export(local_inner_macros)]
-   |
-LL - #[macro_export = 18]
-LL + #[macro_export]
-   |
-
 error: the `#[proc_macro]` attribute is only usable with crates of the `proc-macro` crate type
   --> $DIR/malformed-attrs.rs:98:1
    |
@@ -725,6 +709,12 @@ error: valid forms for the attribute are `#[macro_use(name1, name2, ...)]` and `
 LL | #[macro_use = 1]
    | ^^^^^^^^^^^^^^^^
 
+error: valid forms for the attribute are `#![macro_export(local_inner_macros)]` and `#![macro_export]`
+  --> $DIR/malformed-attrs.rs:213:1
+   |
+LL | #[macro_export = 18]
+   | ^^^^^^^^^^^^^^^^^^^^
+
 error[E0565]: malformed `allow_internal_unsafe` attribute input
   --> $DIR/malformed-attrs.rs:215:1
    |
diff --git a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.rs b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.rs
index f391cf92fb639..a1a78df8d5375 100644
--- a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.rs
+++ b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.rs
@@ -8,7 +8,7 @@
 
 
 #![macro_export]
-//~^ ERROR: `macro_export` attribute cannot be used at crate level
+//~^ ERROR:  `#[macro_export]` attribute cannot be used on crates
 #![rustc_main]
 //~^ ERROR: `rustc_main` attribute cannot be used at crate level
 //~| ERROR: use of an internal attribute [E0658]
@@ -32,7 +32,6 @@
 mod inline {
     //~^ NOTE the inner attribute doesn't annotate this module
     //~| NOTE the inner attribute doesn't annotate this module
-    //~| NOTE the inner attribute doesn't annotate this module
 
     mod inner { #![inline] }
     //~^ ERROR attribute cannot be used on
diff --git a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.stderr b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.stderr
index 3b010c3e3127f..4f4edeef420fe 100644
--- a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.stderr
+++ b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.stderr
@@ -8,6 +8,14 @@ LL | #![rustc_main]
    = note: the `#[rustc_main]` attribute is an internal implementation detail that will never be stable
    = note: the `#[rustc_main]` attribute is used internally to specify test entry point function
 
+error: `#[macro_export]` attribute cannot be used on crates
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:10:1
+   |
+LL | #![macro_export]
+   | ^^^^^^^^^^^^^^^^
+   |
+   = help: `#[macro_export]` can only be applied to macro defs
+
 error: `#[path]` attribute cannot be used on crates
   --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:19:1
    |
@@ -49,7 +57,7 @@ LL | #[inline]
    = help: `#[inline]` can only be applied to functions
 
 error: `#[inline]` attribute cannot be used on modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:37:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:36:17
    |
 LL |     mod inner { #![inline] }
    |                 ^^^^^^^^^^
@@ -57,7 +65,7 @@ LL |     mod inner { #![inline] }
    = help: `#[inline]` can only be applied to functions
 
 error: `#[inline]` attribute cannot be used on structs
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:46:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:45:5
    |
 LL |     #[inline] struct S;
    |     ^^^^^^^^^
@@ -65,7 +73,7 @@ LL |     #[inline] struct S;
    = help: `#[inline]` can only be applied to functions
 
 error: `#[inline]` attribute cannot be used on type aliases
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:49:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:48:5
    |
 LL |     #[inline] type T = S;
    |     ^^^^^^^^^
@@ -73,7 +81,7 @@ LL |     #[inline] type T = S;
    = help: `#[inline]` can only be applied to functions
 
 error: `#[inline]` attribute cannot be used on inherent impl blocks
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:52:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:51:5
    |
 LL |     #[inline] impl S { }
    |     ^^^^^^^^^
@@ -81,7 +89,7 @@ LL |     #[inline] impl S { }
    = help: `#[inline]` can only be applied to functions
 
 error: `#[export_name]` attribute cannot be used on modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:82:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:81:1
    |
 LL | #[export_name = "2200"]
    | ^^^^^^^^^^^^^^^^^^^^^^^
@@ -89,7 +97,7 @@ LL | #[export_name = "2200"]
    = help: `#[export_name]` can be applied to functions and statics
 
 error: `#[export_name]` attribute cannot be used on modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:85:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:84:17
    |
 LL |     mod inner { #![export_name="2200"] }
    |                 ^^^^^^^^^^^^^^^^^^^^^^
@@ -97,7 +105,7 @@ LL |     mod inner { #![export_name="2200"] }
    = help: `#[export_name]` can be applied to functions and statics
 
 error: `#[export_name]` attribute cannot be used on structs
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:90:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:89:5
    |
 LL |     #[export_name = "2200"] struct S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^
@@ -105,7 +113,7 @@ LL |     #[export_name = "2200"] struct S;
    = help: `#[export_name]` can be applied to functions and statics
 
 error: `#[export_name]` attribute cannot be used on type aliases
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:93:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:92:5
    |
 LL |     #[export_name = "2200"] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^
@@ -113,7 +121,7 @@ LL |     #[export_name = "2200"] type T = S;
    = help: `#[export_name]` can be applied to functions and statics
 
 error: `#[export_name]` attribute cannot be used on inherent impl blocks
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:96:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:95:5
    |
 LL |     #[export_name = "2200"] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^
@@ -121,7 +129,7 @@ LL |     #[export_name = "2200"] impl S { }
    = help: `#[export_name]` can be applied to functions and statics
 
 error: `#[export_name]` attribute cannot be used on required trait methods
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:100:9
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:99:9
    |
 LL |         #[export_name = "2200"] fn foo();
    |         ^^^^^^^^^^^^^^^^^^^^^^^
@@ -129,7 +137,7 @@ LL |         #[export_name = "2200"] fn foo();
    = help: `#[export_name]` can be applied to statics, functions, inherent methods, provided trait methods, and trait methods in impl blocks
 
 error: attribute should be applied to an `extern crate` item
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:56:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:55:1
    |
 LL |   #[no_link]
    |   ^^^^^^^^^^
@@ -143,7 +151,7 @@ LL | | }
    | |_- not an `extern crate` item
 
 error[E0517]: attribute should be applied to a struct, enum, or union
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:107:8
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:106:8
    |
 LL |   #[repr(C)]
    |          ^
@@ -156,7 +164,7 @@ LL | | }
    | |_- not a struct, enum, or union
 
 error[E0517]: attribute should be applied to a struct, enum, or union
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:131:8
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:130:8
    |
 LL |   #[repr(Rust)]
    |          ^^^^
@@ -174,21 +182,6 @@ error: attribute should be applied to an `extern crate` item
 LL | #![no_link]
    | ^^^^^^^^^^^ not an `extern crate` item
 
-error: `macro_export` attribute cannot be used at crate level
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:10:1
-   |
-LL | #![macro_export]
-   | ^^^^^^^^^^^^^^^^
-...
-LL | mod inline {
-   |     ------ the inner attribute doesn't annotate this module
-   |
-help: perhaps you meant to use an outer attribute
-   |
-LL - #![macro_export]
-LL + #[macro_export]
-   |
-
 error: `rustc_main` attribute cannot be used at crate level
   --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:12:1
    |
@@ -220,85 +213,85 @@ LL + #[repr()]
    |
 
 error: attribute should be applied to an `extern crate` item
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:61:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:60:17
    |
 LL |     mod inner { #![no_link] }
    |     ------------^^^^^^^^^^^-- not an `extern crate` item
 
 error: attribute should be applied to an `extern crate` item
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:65:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:64:5
    |
 LL |     #[no_link] fn f() { }
    |     ^^^^^^^^^^ ---------- not an `extern crate` item
 
 error: attribute should be applied to an `extern crate` item
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:69:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:68:5
    |
 LL |     #[no_link] struct S;
    |     ^^^^^^^^^^ --------- not an `extern crate` item
 
 error: attribute should be applied to an `extern crate` item
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:73:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:72:5
    |
 LL |     #[no_link]type T = S;
    |     ^^^^^^^^^^----------- not an `extern crate` item
 
 error: attribute should be applied to an `extern crate` item
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:77:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:76:5
    |
 LL |     #[no_link] impl S { }
    |     ^^^^^^^^^^ ---------- not an `extern crate` item
 
 error[E0517]: attribute should be applied to a struct, enum, or union
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:111:25
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:110:25
    |
 LL |     mod inner { #![repr(C)] }
    |     --------------------^---- not a struct, enum, or union
 
 error[E0517]: attribute should be applied to a struct, enum, or union
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:115:12
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:114:12
    |
 LL |     #[repr(C)] fn f() { }
    |            ^   ---------- not a struct, enum, or union
 
 error[E0517]: attribute should be applied to a struct, enum, or union
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:121:12
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:120:12
    |
 LL |     #[repr(C)] type T = S;
    |            ^   ----------- not a struct, enum, or union
 
 error[E0517]: attribute should be applied to a struct, enum, or union
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:125:12
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:124:12
    |
 LL |     #[repr(C)] impl S { }
    |            ^   ---------- not a struct, enum, or union
 
 error[E0517]: attribute should be applied to a struct, enum, or union
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:135:25
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:134:25
    |
 LL |     mod inner { #![repr(Rust)] }
    |     --------------------^^^^---- not a struct, enum, or union
 
 error[E0517]: attribute should be applied to a struct, enum, or union
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:139:12
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:138:12
    |
 LL |     #[repr(Rust)] fn f() { }
    |            ^^^^   ---------- not a struct, enum, or union
 
 error[E0517]: attribute should be applied to a struct, enum, or union
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:145:12
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:144:12
    |
 LL |     #[repr(Rust)] type T = S;
    |            ^^^^   ----------- not a struct, enum, or union
 
 error[E0517]: attribute should be applied to a struct, enum, or union
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:149:12
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:148:12
    |
 LL |     #[repr(Rust)] impl S { }
    |            ^^^^   ---------- not a struct, enum, or union
 
 error: valid forms for the attribute are `#[inline(always)]`, `#[inline(never)]`, and `#[inline]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:40:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:39:5
    |
 LL |     #[inline = "2100"] fn f() { }
    |     ^^^^^^^^^^^^^^^^^^
@@ -313,7 +306,7 @@ Some errors have detailed explanations: E0517, E0658.
 For more information about an error, try `rustc --explain E0517`.
 Future incompatibility report: Future breakage diagnostic:
 error: valid forms for the attribute are `#[inline(always)]`, `#[inline(never)]`, and `#[inline]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:40:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:39:5
    |
 LL |     #[inline = "2100"] fn f() { }
    |     ^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.rs b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.rs
index 546aa4052d333..aa5aab41e7258 100644
--- a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.rs
+++ b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.rs
@@ -214,22 +214,40 @@ mod macro_use {
 }
 
 #[macro_export]
-//~^ WARN `#[macro_export]` only has an effect on macro definitions
+//~^ WARN `#[macro_export]` attribute cannot be used on modules [unused_attributes]
+//~| WARN previously accepted
+//~| HELP can only be applied to
+//~| HELP remove the attribute
 mod macro_export {
     mod inner { #![macro_export] }
-    //~^ WARN `#[macro_export]` only has an effect on macro definitions
+    //~^ WARN `#[macro_export]` attribute cannot be used on modules
+    //~| WARN previously accepted
+    //~| HELP can only be applied to
+    //~| HELP remove the attribute
 
     #[macro_export] fn f() { }
-    //~^ WARN `#[macro_export]` only has an effect on macro definitions
+    //~^ WARN `#[macro_export]` attribute cannot be used on function
+    //~| WARN previously accepted
+    //~| HELP can only be applied to
+    //~| HELP remove the attribute
 
     #[macro_export] struct S;
-    //~^ WARN `#[macro_export]` only has an effect on macro definitions
+    //~^ WARN `#[macro_export]` attribute cannot be used on structs
+    //~| WARN previously accepted
+    //~| HELP can only be applied to
+    //~| HELP remove the attribute
 
     #[macro_export] type T = S;
-    //~^ WARN `#[macro_export]` only has an effect on macro definitions
+    //~^ WARN `#[macro_export]` attribute cannot be used on type aliases
+    //~| WARN previously accepted
+    //~| HELP can only be applied to
+    //~| HELP remove the attribute
 
     #[macro_export] impl S { }
-    //~^ WARN `#[macro_export]` only has an effect on macro definitions
+    //~^ WARN  `#[macro_export]` attribute cannot be used on inherent impl blocks
+    //~| WARN previously accepted
+    //~| HELP can only be applied to
+    //~| HELP remove the attribute
 }
 
 // At time of unit test authorship, if compiling without `--test` then
diff --git a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr
index 3c835be5cffab..5e2029c45165a 100644
--- a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr
+++ b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr
@@ -1,5 +1,5 @@
 warning: `#[macro_escape]` is a deprecated synonym for `#[macro_use]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:511:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:529:17
    |
 LL |     mod inner { #![macro_escape] }
    |                 ^^^^^^^^^^^^^^^^
@@ -7,7 +7,7 @@ LL |     mod inner { #![macro_escape] }
    = help: try an outer attribute: `#[macro_use]`
 
 warning: `#[macro_escape]` is a deprecated synonym for `#[macro_use]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:508:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:526:1
    |
 LL | #[macro_escape]
    | ^^^^^^^^^^^^^^^
@@ -186,31 +186,24 @@ warning: unknown lint: `x5100`
 LL |     #[deny(x5100)] impl S { }
    |            ^^^^^
 
-warning: `#[macro_export]` only has an effect on macro definitions
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:216:1
+warning: crate-level attribute should be an inner attribute
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:501:1
    |
-LL | #[macro_export]
-   | ^^^^^^^^^^^^^^^
+LL | #[reexport_test_harness_main = "2900"]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: the lint level is defined here
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:37:9
    |
 LL | #![warn(unused_attributes, unknown_lints)]
    |         ^^^^^^^^^^^^^^^^^
-
-warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:483:1
-   |
-LL | #[reexport_test_harness_main = "2900"]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
 help: add a `!`
    |
 LL | #![reexport_test_harness_main = "2900"]
    |  +
 
 warning: attribute should be applied to an `extern` block with non-Rust ABI
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:695:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:713:1
    |
 LL |   #[link(name = "x")]
    |   ^^^^^^^^^^^^^^^^^^^
@@ -226,7 +219,7 @@ LL | | }
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:771:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:789:1
    |
 LL | #[windows_subsystem = "windows"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -237,7 +230,7 @@ LL | #![windows_subsystem = "windows"]
    |  +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:821:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:839:1
    |
 LL | #[crate_type = "0800"]
    | ^^^^^^^^^^^^^^^^^^^^^^
@@ -248,7 +241,7 @@ LL | #![crate_type = "0800"]
    |  +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:845:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:863:1
    |
 LL | #[feature(x0600)]
    | ^^^^^^^^^^^^^^^^^
@@ -259,7 +252,7 @@ LL | #![feature(x0600)]
    |  +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:870:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:888:1
    |
 LL | #[no_main]
    | ^^^^^^^^^^
@@ -270,7 +263,7 @@ LL | #![no_main]
    |  +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:894:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:912:1
    |
 LL | #[no_builtins]
    | ^^^^^^^^^^^^^^
@@ -296,44 +289,14 @@ LL | #![feature(rust1)]
    |
    = note: `#[warn(stable_features)]` on by default
 
-warning: `#[macro_export]` only has an effect on macro definitions
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:219:17
-   |
-LL |     mod inner { #![macro_export] }
-   |                 ^^^^^^^^^^^^^^^^
-
-warning: `#[macro_export]` only has an effect on macro definitions
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:222:5
-   |
-LL |     #[macro_export] fn f() { }
-   |     ^^^^^^^^^^^^^^^
-
-warning: `#[macro_export]` only has an effect on macro definitions
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:225:5
-   |
-LL |     #[macro_export] struct S;
-   |     ^^^^^^^^^^^^^^^
-
-warning: `#[macro_export]` only has an effect on macro definitions
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:228:5
-   |
-LL |     #[macro_export] type T = S;
-   |     ^^^^^^^^^^^^^^^
-
-warning: `#[macro_export]` only has an effect on macro definitions
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:231:5
-   |
-LL |     #[macro_export] impl S { }
-   |     ^^^^^^^^^^^^^^^
-
 warning: crate-level attribute should be in the root module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:487:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:505:17
    |
 LL |     mod inner { #![reexport_test_harness_main="2900"] }
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:490:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:508:5
    |
 LL |     #[reexport_test_harness_main = "2900"] fn f() { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -344,7 +307,7 @@ LL |     #![reexport_test_harness_main = "2900"] fn f() { }
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:494:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:512:5
    |
 LL |     #[reexport_test_harness_main = "2900"] struct S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -355,7 +318,7 @@ LL |     #![reexport_test_harness_main = "2900"] struct S;
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:498:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:516:5
    |
 LL |     #[reexport_test_harness_main = "2900"] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -366,7 +329,7 @@ LL |     #![reexport_test_harness_main = "2900"] type T = S;
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:502:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:520:5
    |
 LL |     #[reexport_test_harness_main = "2900"] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -377,7 +340,7 @@ LL |     #![reexport_test_harness_main = "2900"] impl S { }
    |      +
 
 warning: attribute should be applied to an `extern` block with non-Rust ABI
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:701:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:719:17
    |
 LL |     mod inner { #![link(name = "x")] }
    |     ------------^^^^^^^^^^^^^^^^^^^^-- not an `extern` block
@@ -385,7 +348,7 @@ LL |     mod inner { #![link(name = "x")] }
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to an `extern` block with non-Rust ABI
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:706:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:724:5
    |
 LL |     #[link(name = "x")] fn f() { }
    |     ^^^^^^^^^^^^^^^^^^^ ---------- not an `extern` block
@@ -393,7 +356,7 @@ LL |     #[link(name = "x")] fn f() { }
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to an `extern` block with non-Rust ABI
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:711:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:729:5
    |
 LL |     #[link(name = "x")] struct S;
    |     ^^^^^^^^^^^^^^^^^^^ --------- not an `extern` block
@@ -401,7 +364,7 @@ LL |     #[link(name = "x")] struct S;
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to an `extern` block with non-Rust ABI
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:716:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:734:5
    |
 LL |     #[link(name = "x")] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^ ----------- not an `extern` block
@@ -409,7 +372,7 @@ LL |     #[link(name = "x")] type T = S;
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to an `extern` block with non-Rust ABI
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:721:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:739:5
    |
 LL |     #[link(name = "x")] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^ ---------- not an `extern` block
@@ -417,7 +380,7 @@ LL |     #[link(name = "x")] impl S { }
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to an `extern` block with non-Rust ABI
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:726:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:744:5
    |
 LL |     #[link(name = "x")] extern "Rust" {}
    |     ^^^^^^^^^^^^^^^^^^^
@@ -425,13 +388,13 @@ LL |     #[link(name = "x")] extern "Rust" {}
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: crate-level attribute should be in the root module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:775:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:793:17
    |
 LL |     mod inner { #![windows_subsystem="windows"] }
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:778:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:796:5
    |
 LL |     #[windows_subsystem = "windows"] fn f() { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -442,7 +405,7 @@ LL |     #![windows_subsystem = "windows"] fn f() { }
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:782:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:800:5
    |
 LL |     #[windows_subsystem = "windows"] struct S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -453,7 +416,7 @@ LL |     #![windows_subsystem = "windows"] struct S;
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:786:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:804:5
    |
 LL |     #[windows_subsystem = "windows"] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -464,7 +427,7 @@ LL |     #![windows_subsystem = "windows"] type T = S;
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:790:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:808:5
    |
 LL |     #[windows_subsystem = "windows"] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -475,13 +438,13 @@ LL |     #![windows_subsystem = "windows"] impl S { }
    |      +
 
 warning: crate-level attribute should be in the root module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:825:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:843:17
    |
 LL |     mod inner { #![crate_type="0800"] }
    |                 ^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:828:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:846:5
    |
 LL |     #[crate_type = "0800"] fn f() { }
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -492,7 +455,7 @@ LL |     #![crate_type = "0800"] fn f() { }
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:832:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:850:5
    |
 LL |     #[crate_type = "0800"] struct S;
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -503,7 +466,7 @@ LL |     #![crate_type = "0800"] struct S;
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:836:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:854:5
    |
 LL |     #[crate_type = "0800"] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -514,7 +477,7 @@ LL |     #![crate_type = "0800"] type T = S;
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:840:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:858:5
    |
 LL |     #[crate_type = "0800"] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -525,13 +488,13 @@ LL |     #![crate_type = "0800"] impl S { }
    |      +
 
 warning: crate-level attribute should be in the root module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:849:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:867:17
    |
 LL |     mod inner { #![feature(x0600)] }
    |                 ^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:852:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:870:5
    |
 LL |     #[feature(x0600)] fn f() { }
    |     ^^^^^^^^^^^^^^^^^
@@ -542,7 +505,7 @@ LL |     #![feature(x0600)] fn f() { }
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:856:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:874:5
    |
 LL |     #[feature(x0600)] struct S;
    |     ^^^^^^^^^^^^^^^^^
@@ -553,7 +516,7 @@ LL |     #![feature(x0600)] struct S;
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:860:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:878:5
    |
 LL |     #[feature(x0600)] type T = S;
    |     ^^^^^^^^^^^^^^^^^
@@ -564,7 +527,7 @@ LL |     #![feature(x0600)] type T = S;
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:864:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:882:5
    |
 LL |     #[feature(x0600)] impl S { }
    |     ^^^^^^^^^^^^^^^^^
@@ -575,13 +538,13 @@ LL |     #![feature(x0600)] impl S { }
    |      +
 
 warning: crate-level attribute should be in the root module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:874:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:892:17
    |
 LL |     mod inner { #![no_main] }
    |                 ^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:877:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:895:5
    |
 LL |     #[no_main] fn f() { }
    |     ^^^^^^^^^^
@@ -592,7 +555,7 @@ LL |     #![no_main] fn f() { }
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:881:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:899:5
    |
 LL |     #[no_main] struct S;
    |     ^^^^^^^^^^
@@ -603,7 +566,7 @@ LL |     #![no_main] struct S;
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:885:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:903:5
    |
 LL |     #[no_main] type T = S;
    |     ^^^^^^^^^^
@@ -614,7 +577,7 @@ LL |     #![no_main] type T = S;
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:889:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:907:5
    |
 LL |     #[no_main] impl S { }
    |     ^^^^^^^^^^
@@ -625,13 +588,13 @@ LL |     #![no_main] impl S { }
    |      +
 
 warning: crate-level attribute should be in the root module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:898:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:916:17
    |
 LL |     mod inner { #![no_builtins] }
    |                 ^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:901:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:919:5
    |
 LL |     #[no_builtins] fn f() { }
    |     ^^^^^^^^^^^^^^
@@ -642,7 +605,7 @@ LL |     #![no_builtins] fn f() { }
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:905:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:923:5
    |
 LL |     #[no_builtins] struct S;
    |     ^^^^^^^^^^^^^^
@@ -653,7 +616,7 @@ LL |     #![no_builtins] struct S;
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:909:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:927:5
    |
 LL |     #[no_builtins] type T = S;
    |     ^^^^^^^^^^^^^^
@@ -664,7 +627,7 @@ LL |     #![no_builtins] type T = S;
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:913:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:931:5
    |
 LL |     #[no_builtins] impl S { }
    |     ^^^^^^^^^^^^^^
@@ -710,8 +673,62 @@ LL |     #[macro_use] impl S { }
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = help: `#[macro_use]` can be applied to modules, extern crates, and crates
 
+warning: `#[macro_export]` attribute cannot be used on modules
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:216:1
+   |
+LL | #[macro_export]
+   | ^^^^^^^^^^^^^^^
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = help: `#[macro_export]` can only be applied to macro defs
+
+warning: `#[macro_export]` attribute cannot be used on modules
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:222:17
+   |
+LL |     mod inner { #![macro_export] }
+   |                 ^^^^^^^^^^^^^^^^
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = help: `#[macro_export]` can only be applied to macro defs
+
+warning: `#[macro_export]` attribute cannot be used on functions
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:228:5
+   |
+LL |     #[macro_export] fn f() { }
+   |     ^^^^^^^^^^^^^^^
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = help: `#[macro_export]` can only be applied to macro defs
+
+warning: `#[macro_export]` attribute cannot be used on structs
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:234:5
+   |
+LL |     #[macro_export] struct S;
+   |     ^^^^^^^^^^^^^^^
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = help: `#[macro_export]` can only be applied to macro defs
+
+warning: `#[macro_export]` attribute cannot be used on type aliases
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:240:5
+   |
+LL |     #[macro_export] type T = S;
+   |     ^^^^^^^^^^^^^^^
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = help: `#[macro_export]` can only be applied to macro defs
+
+warning: `#[macro_export]` attribute cannot be used on inherent impl blocks
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:246:5
+   |
+LL |     #[macro_export] impl S { }
+   |     ^^^^^^^^^^^^^^^
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = help: `#[macro_export]` can only be applied to macro defs
+
 warning: `#[path]` attribute cannot be used on functions
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:271:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:289:5
    |
 LL |     #[path = "3800"] fn f() { }
    |     ^^^^^^^^^^^^^^^^
@@ -720,7 +737,7 @@ LL |     #[path = "3800"] fn f() { }
    = help: `#[path]` can only be applied to modules
 
 warning: `#[path]` attribute cannot be used on structs
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:277:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:295:5
    |
 LL |     #[path = "3800"]  struct S;
    |     ^^^^^^^^^^^^^^^^
@@ -729,7 +746,7 @@ LL |     #[path = "3800"]  struct S;
    = help: `#[path]` can only be applied to modules
 
 warning: `#[path]` attribute cannot be used on type aliases
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:283:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:301:5
    |
 LL |     #[path = "3800"] type T = S;
    |     ^^^^^^^^^^^^^^^^
@@ -738,7 +755,7 @@ LL |     #[path = "3800"] type T = S;
    = help: `#[path]` can only be applied to modules
 
 warning: `#[path]` attribute cannot be used on inherent impl blocks
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:289:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:307:5
    |
 LL |     #[path = "3800"] impl S { }
    |     ^^^^^^^^^^^^^^^^
@@ -747,7 +764,7 @@ LL |     #[path = "3800"] impl S { }
    = help: `#[path]` can only be applied to modules
 
 warning: `#[automatically_derived]` attribute cannot be used on modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:296:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:314:1
    |
 LL | #[automatically_derived]
    | ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -756,7 +773,7 @@ LL | #[automatically_derived]
    = help: `#[automatically_derived]` can only be applied to trait impl blocks
 
 warning: `#[automatically_derived]` attribute cannot be used on modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:302:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:320:17
    |
 LL |     mod inner { #![automatically_derived] }
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -765,7 +782,7 @@ LL |     mod inner { #![automatically_derived] }
    = help: `#[automatically_derived]` can only be applied to trait impl blocks
 
 warning: `#[automatically_derived]` attribute cannot be used on functions
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:308:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:326:5
    |
 LL |     #[automatically_derived] fn f() { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -774,7 +791,7 @@ LL |     #[automatically_derived] fn f() { }
    = help: `#[automatically_derived]` can only be applied to trait impl blocks
 
 warning: `#[automatically_derived]` attribute cannot be used on structs
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:314:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:332:5
    |
 LL |     #[automatically_derived] struct S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -783,7 +800,7 @@ LL |     #[automatically_derived] struct S;
    = help: `#[automatically_derived]` can only be applied to trait impl blocks
 
 warning: `#[automatically_derived]` attribute cannot be used on type aliases
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:320:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:338:5
    |
 LL |     #[automatically_derived] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -792,7 +809,7 @@ LL |     #[automatically_derived] type T = S;
    = help: `#[automatically_derived]` can only be applied to trait impl blocks
 
 warning: `#[automatically_derived]` attribute cannot be used on traits
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:326:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:344:5
    |
 LL |     #[automatically_derived] trait W { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -801,7 +818,7 @@ LL |     #[automatically_derived] trait W { }
    = help: `#[automatically_derived]` can only be applied to trait impl blocks
 
 warning: `#[automatically_derived]` attribute cannot be used on inherent impl blocks
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:332:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:350:5
    |
 LL |     #[automatically_derived] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -810,7 +827,7 @@ LL |     #[automatically_derived] impl S { }
    = help: `#[automatically_derived]` can only be applied to trait impl blocks
 
 warning: `#[no_mangle]` attribute cannot be used on modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:341:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:359:1
    |
 LL | #[no_mangle]
    | ^^^^^^^^^^^^
@@ -819,7 +836,7 @@ LL | #[no_mangle]
    = help: `#[no_mangle]` can be applied to functions and statics
 
 warning: `#[no_mangle]` attribute cannot be used on modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:347:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:365:17
    |
 LL |     mod inner { #![no_mangle] }
    |                 ^^^^^^^^^^^^^
@@ -828,7 +845,7 @@ LL |     mod inner { #![no_mangle] }
    = help: `#[no_mangle]` can be applied to functions and statics
 
 warning: `#[no_mangle]` attribute cannot be used on structs
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:355:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:373:5
    |
 LL |     #[no_mangle] struct S;
    |     ^^^^^^^^^^^^
@@ -837,7 +854,7 @@ LL |     #[no_mangle] struct S;
    = help: `#[no_mangle]` can be applied to functions and statics
 
 warning: `#[no_mangle]` attribute cannot be used on type aliases
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:361:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:379:5
    |
 LL |     #[no_mangle] type T = S;
    |     ^^^^^^^^^^^^
@@ -846,7 +863,7 @@ LL |     #[no_mangle] type T = S;
    = help: `#[no_mangle]` can be applied to functions and statics
 
 warning: `#[no_mangle]` attribute cannot be used on inherent impl blocks
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:367:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:385:5
    |
 LL |     #[no_mangle] impl S { }
    |     ^^^^^^^^^^^^
@@ -855,7 +872,7 @@ LL |     #[no_mangle] impl S { }
    = help: `#[no_mangle]` can be applied to functions and statics
 
 warning: `#[no_mangle]` attribute cannot be used on required trait methods
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:374:9
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:392:9
    |
 LL |         #[no_mangle] fn foo();
    |         ^^^^^^^^^^^^
@@ -864,7 +881,7 @@ LL |         #[no_mangle] fn foo();
    = help: `#[no_mangle]` can be applied to functions, statics, inherent methods, and trait methods in impl blocks
 
 warning: `#[no_mangle]` attribute cannot be used on provided trait methods
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:380:9
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:398:9
    |
 LL |         #[no_mangle] fn bar() {}
    |         ^^^^^^^^^^^^
@@ -873,7 +890,7 @@ LL |         #[no_mangle] fn bar() {}
    = help: `#[no_mangle]` can be applied to functions, statics, inherent methods, and trait methods in impl blocks
 
 warning: `#[should_panic]` attribute cannot be used on modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:388:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:406:1
    |
 LL | #[should_panic]
    | ^^^^^^^^^^^^^^^
@@ -882,7 +899,7 @@ LL | #[should_panic]
    = help: `#[should_panic]` can only be applied to functions
 
 warning: `#[should_panic]` attribute cannot be used on modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:394:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:412:17
    |
 LL |     mod inner { #![should_panic] }
    |                 ^^^^^^^^^^^^^^^^
@@ -891,7 +908,7 @@ LL |     mod inner { #![should_panic] }
    = help: `#[should_panic]` can only be applied to functions
 
 warning: `#[should_panic]` attribute cannot be used on structs
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:402:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:420:5
    |
 LL |     #[should_panic] struct S;
    |     ^^^^^^^^^^^^^^^
@@ -900,7 +917,7 @@ LL |     #[should_panic] struct S;
    = help: `#[should_panic]` can only be applied to functions
 
 warning: `#[should_panic]` attribute cannot be used on type aliases
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:408:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:426:5
    |
 LL |     #[should_panic] type T = S;
    |     ^^^^^^^^^^^^^^^
@@ -909,7 +926,7 @@ LL |     #[should_panic] type T = S;
    = help: `#[should_panic]` can only be applied to functions
 
 warning: `#[should_panic]` attribute cannot be used on inherent impl blocks
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:414:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:432:5
    |
 LL |     #[should_panic] impl S { }
    |     ^^^^^^^^^^^^^^^
@@ -918,7 +935,7 @@ LL |     #[should_panic] impl S { }
    = help: `#[should_panic]` can only be applied to functions
 
 warning: `#[ignore]` attribute cannot be used on modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:421:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:439:1
    |
 LL | #[ignore]
    | ^^^^^^^^^
@@ -927,7 +944,7 @@ LL | #[ignore]
    = help: `#[ignore]` can only be applied to functions
 
 warning: `#[ignore]` attribute cannot be used on modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:427:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:445:17
    |
 LL |     mod inner { #![ignore] }
    |                 ^^^^^^^^^^
@@ -936,7 +953,7 @@ LL |     mod inner { #![ignore] }
    = help: `#[ignore]` can only be applied to functions
 
 warning: `#[ignore]` attribute cannot be used on structs
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:435:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:453:5
    |
 LL |     #[ignore] struct S;
    |     ^^^^^^^^^
@@ -945,7 +962,7 @@ LL |     #[ignore] struct S;
    = help: `#[ignore]` can only be applied to functions
 
 warning: `#[ignore]` attribute cannot be used on type aliases
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:441:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:459:5
    |
 LL |     #[ignore] type T = S;
    |     ^^^^^^^^^
@@ -954,7 +971,7 @@ LL |     #[ignore] type T = S;
    = help: `#[ignore]` can only be applied to functions
 
 warning: `#[ignore]` attribute cannot be used on inherent impl blocks
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:447:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:465:5
    |
 LL |     #[ignore] impl S { }
    |     ^^^^^^^^^
@@ -963,7 +980,7 @@ LL |     #[ignore] impl S { }
    = help: `#[ignore]` can only be applied to functions
 
 warning: `#[no_implicit_prelude]` attribute cannot be used on functions
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:458:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:476:5
    |
 LL |     #[no_implicit_prelude] fn f() { }
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -972,7 +989,7 @@ LL |     #[no_implicit_prelude] fn f() { }
    = help: `#[no_implicit_prelude]` can be applied to modules and crates
 
 warning: `#[no_implicit_prelude]` attribute cannot be used on structs
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:464:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:482:5
    |
 LL |     #[no_implicit_prelude] struct S;
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -981,7 +998,7 @@ LL |     #[no_implicit_prelude] struct S;
    = help: `#[no_implicit_prelude]` can be applied to modules and crates
 
 warning: `#[no_implicit_prelude]` attribute cannot be used on type aliases
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:470:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:488:5
    |
 LL |     #[no_implicit_prelude] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -990,7 +1007,7 @@ LL |     #[no_implicit_prelude] type T = S;
    = help: `#[no_implicit_prelude]` can be applied to modules and crates
 
 warning: `#[no_implicit_prelude]` attribute cannot be used on inherent impl blocks
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:476:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:494:5
    |
 LL |     #[no_implicit_prelude] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -999,7 +1016,7 @@ LL |     #[no_implicit_prelude] impl S { }
    = help: `#[no_implicit_prelude]` can be applied to modules and crates
 
 warning: `#[macro_escape]` attribute cannot be used on functions
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:515:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:533:5
    |
 LL |     #[macro_escape] fn f() { }
    |     ^^^^^^^^^^^^^^^
@@ -1008,7 +1025,7 @@ LL |     #[macro_escape] fn f() { }
    = help: `#[macro_escape]` can be applied to modules, extern crates, and crates
 
 warning: `#[macro_escape]` attribute cannot be used on structs
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:521:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:539:5
    |
 LL |     #[macro_escape] struct S;
    |     ^^^^^^^^^^^^^^^
@@ -1017,7 +1034,7 @@ LL |     #[macro_escape] struct S;
    = help: `#[macro_escape]` can be applied to modules, extern crates, and crates
 
 warning: `#[macro_escape]` attribute cannot be used on type aliases
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:527:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:545:5
    |
 LL |     #[macro_escape] type T = S;
    |     ^^^^^^^^^^^^^^^
@@ -1026,7 +1043,7 @@ LL |     #[macro_escape] type T = S;
    = help: `#[macro_escape]` can be applied to modules, extern crates, and crates
 
 warning: `#[macro_escape]` attribute cannot be used on inherent impl blocks
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:533:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:551:5
    |
 LL |     #[macro_escape] impl S { }
    |     ^^^^^^^^^^^^^^^
@@ -1035,13 +1052,13 @@ LL |     #[macro_escape] impl S { }
    = help: `#[macro_escape]` can be applied to modules, extern crates, and crates
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![no_std]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:540:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:558:1
    |
 LL | #[no_std]
    | ^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:542:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:560:1
    |
 LL | / mod no_std {
 LL | |
@@ -1051,61 +1068,61 @@ LL | | }
    | |_^
 
 warning: the `#![no_std]` attribute can only be used at the crate root
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:544:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:562:17
    |
 LL |     mod inner { #![no_std] }
    |                 ^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![no_std]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:547:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:565:5
    |
 LL |     #[no_std] fn f() { }
    |     ^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this function
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:547:15
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:565:15
    |
 LL |     #[no_std] fn f() { }
    |               ^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![no_std]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:551:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:569:5
    |
 LL |     #[no_std] struct S;
    |     ^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this struct
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:551:15
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:569:15
    |
 LL |     #[no_std] struct S;
    |               ^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![no_std]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:555:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:573:5
    |
 LL |     #[no_std] type T = S;
    |     ^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this type alias
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:555:15
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:573:15
    |
 LL |     #[no_std] type T = S;
    |               ^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![no_std]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:559:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:577:5
    |
 LL |     #[no_std] impl S { }
    |     ^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this implementation block
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:559:15
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:577:15
    |
 LL |     #[no_std] impl S { }
    |               ^^^^^^^^^^
 
 warning: `#[cold]` attribute cannot be used on modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:581:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:599:1
    |
 LL | #[cold]
    | ^^^^^^^
@@ -1114,7 +1131,7 @@ LL | #[cold]
    = help: `#[cold]` can only be applied to functions
 
 warning: `#[cold]` attribute cannot be used on modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:588:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:606:17
    |
 LL |     mod inner { #![cold] }
    |                 ^^^^^^^^
@@ -1123,7 +1140,7 @@ LL |     mod inner { #![cold] }
    = help: `#[cold]` can only be applied to functions
 
 warning: `#[cold]` attribute cannot be used on structs
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:596:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:614:5
    |
 LL |     #[cold] struct S;
    |     ^^^^^^^
@@ -1132,7 +1149,7 @@ LL |     #[cold] struct S;
    = help: `#[cold]` can only be applied to functions
 
 warning: `#[cold]` attribute cannot be used on type aliases
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:602:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:620:5
    |
 LL |     #[cold] type T = S;
    |     ^^^^^^^
@@ -1141,7 +1158,7 @@ LL |     #[cold] type T = S;
    = help: `#[cold]` can only be applied to functions
 
 warning: `#[cold]` attribute cannot be used on inherent impl blocks
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:608:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:626:5
    |
 LL |     #[cold] impl S { }
    |     ^^^^^^^
@@ -1150,7 +1167,7 @@ LL |     #[cold] impl S { }
    = help: `#[cold]` can only be applied to functions
 
 warning: `#[link_name]` attribute cannot be used on modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:615:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:633:1
    |
 LL | #[link_name = "1900"]
    | ^^^^^^^^^^^^^^^^^^^^^
@@ -1159,7 +1176,7 @@ LL | #[link_name = "1900"]
    = help: `#[link_name]` can be applied to foreign functions and foreign statics
 
 warning: `#[link_name]` attribute cannot be used on foreign modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:621:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:639:5
    |
 LL |     #[link_name = "1900"]
    |     ^^^^^^^^^^^^^^^^^^^^^
@@ -1168,7 +1185,7 @@ LL |     #[link_name = "1900"]
    = help: `#[link_name]` can be applied to foreign functions and foreign statics
 
 warning: `#[link_name]` attribute cannot be used on modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:628:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:646:17
    |
 LL |     mod inner { #![link_name="1900"] }
    |                 ^^^^^^^^^^^^^^^^^^^^
@@ -1177,7 +1194,7 @@ LL |     mod inner { #![link_name="1900"] }
    = help: `#[link_name]` can be applied to foreign functions and foreign statics
 
 warning: `#[link_name]` attribute cannot be used on functions
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:634:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:652:5
    |
 LL |     #[link_name = "1900"] fn f() { }
    |     ^^^^^^^^^^^^^^^^^^^^^
@@ -1186,7 +1203,7 @@ LL |     #[link_name = "1900"] fn f() { }
    = help: `#[link_name]` can be applied to foreign functions and foreign statics
 
 warning: `#[link_name]` attribute cannot be used on structs
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:640:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:658:5
    |
 LL |     #[link_name = "1900"] struct S;
    |     ^^^^^^^^^^^^^^^^^^^^^
@@ -1195,7 +1212,7 @@ LL |     #[link_name = "1900"] struct S;
    = help: `#[link_name]` can be applied to foreign functions and foreign statics
 
 warning: `#[link_name]` attribute cannot be used on type aliases
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:646:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:664:5
    |
 LL |     #[link_name = "1900"] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^^^
@@ -1204,7 +1221,7 @@ LL |     #[link_name = "1900"] type T = S;
    = help: `#[link_name]` can be applied to foreign functions and foreign statics
 
 warning: `#[link_name]` attribute cannot be used on inherent impl blocks
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:652:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:670:5
    |
 LL |     #[link_name = "1900"] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^^^
@@ -1213,7 +1230,7 @@ LL |     #[link_name = "1900"] impl S { }
    = help: `#[link_name]` can be applied to foreign functions and foreign statics
 
 warning: `#[link_section]` attribute cannot be used on modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:659:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:677:1
    |
 LL | #[link_section = "1800"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -1222,7 +1239,7 @@ LL | #[link_section = "1800"]
    = help: `#[link_section]` can be applied to statics and functions
 
 warning: `#[link_section]` attribute cannot be used on modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:665:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:683:17
    |
 LL |     mod inner { #![link_section="1800"] }
    |                 ^^^^^^^^^^^^^^^^^^^^^^^
@@ -1231,7 +1248,7 @@ LL |     mod inner { #![link_section="1800"] }
    = help: `#[link_section]` can be applied to statics and functions
 
 warning: `#[link_section]` attribute cannot be used on structs
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:673:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:691:5
    |
 LL |     #[link_section = "1800"] struct S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -1240,7 +1257,7 @@ LL |     #[link_section = "1800"] struct S;
    = help: `#[link_section]` can be applied to statics and functions
 
 warning: `#[link_section]` attribute cannot be used on type aliases
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:679:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:697:5
    |
 LL |     #[link_section = "1800"] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -1249,7 +1266,7 @@ LL |     #[link_section = "1800"] type T = S;
    = help: `#[link_section]` can be applied to statics and functions
 
 warning: `#[link_section]` attribute cannot be used on inherent impl blocks
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:685:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:703:5
    |
 LL |     #[link_section = "1800"] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -1258,7 +1275,7 @@ LL |     #[link_section = "1800"] impl S { }
    = help: `#[link_section]` can be applied to statics and functions
 
 warning: `#[must_use]` attribute cannot be used on modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:746:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:764:1
    |
 LL | #[must_use]
    | ^^^^^^^^^^^
@@ -1267,7 +1284,7 @@ LL | #[must_use]
    = help: `#[must_use]` can be applied to functions, data types, unions, and traits
 
 warning: `#[must_use]` attribute cannot be used on modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:751:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:769:17
    |
 LL |     mod inner { #![must_use] }
    |                 ^^^^^^^^^^^^
@@ -1276,7 +1293,7 @@ LL |     mod inner { #![must_use] }
    = help: `#[must_use]` can be applied to functions, data types, unions, and traits
 
 warning: `#[must_use]` attribute cannot be used on type aliases
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:760:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:778:5
    |
 LL |     #[must_use] type T = S;
    |     ^^^^^^^^^^^
@@ -1285,7 +1302,7 @@ LL |     #[must_use] type T = S;
    = help: `#[must_use]` can be applied to functions, data types, unions, and traits
 
 warning: `#[must_use]` attribute cannot be used on inherent impl blocks
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:765:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:783:5
    |
 LL |     #[must_use] impl S { }
    |     ^^^^^^^^^^^
@@ -1294,13 +1311,13 @@ LL |     #[must_use] impl S { }
    = help: `#[must_use]` can be applied to functions, data types, unions, and traits
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![crate_name]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:797:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:815:1
    |
 LL | #[crate_name = "0900"]
    | ^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:799:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:817:1
    |
 LL | / mod crate_name {
 LL | |
@@ -1310,67 +1327,67 @@ LL | | }
    | |_^
 
 warning: the `#![crate_name]` attribute can only be used at the crate root
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:801:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:819:17
    |
 LL |     mod inner { #![crate_name="0900"] }
    |                 ^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![crate_name]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:804:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:822:5
    |
 LL |     #[crate_name = "0900"] fn f() { }
    |     ^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this function
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:804:28
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:822:28
    |
 LL |     #[crate_name = "0900"] fn f() { }
    |                            ^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![crate_name]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:808:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:826:5
    |
 LL |     #[crate_name = "0900"] struct S;
    |     ^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this struct
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:808:28
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:826:28
    |
 LL |     #[crate_name = "0900"] struct S;
    |                            ^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![crate_name]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:812:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:830:5
    |
 LL |     #[crate_name = "0900"] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this type alias
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:812:28
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:830:28
    |
 LL |     #[crate_name = "0900"] type T = S;
    |                            ^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![crate_name]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:816:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:834:5
    |
 LL |     #[crate_name = "0900"] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this implementation block
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:816:28
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:834:28
    |
 LL |     #[crate_name = "0900"] impl S { }
    |                            ^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![recursion_limit]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:918:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:936:1
    |
 LL | #[recursion_limit="0200"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:920:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:938:1
    |
 LL | / mod recursion_limit {
 LL | |
@@ -1380,67 +1397,67 @@ LL | | }
    | |_^
 
 warning: the `#![recursion_limit]` attribute can only be used at the crate root
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:922:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:940:17
    |
 LL |     mod inner { #![recursion_limit="0200"] }
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![recursion_limit]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:925:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:943:5
    |
 LL |     #[recursion_limit="0200"] fn f() { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this function
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:925:31
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:943:31
    |
 LL |     #[recursion_limit="0200"] fn f() { }
    |                               ^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![recursion_limit]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:929:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:947:5
    |
 LL |     #[recursion_limit="0200"] struct S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this struct
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:929:31
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:947:31
    |
 LL |     #[recursion_limit="0200"] struct S;
    |                               ^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![recursion_limit]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:933:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:951:5
    |
 LL |     #[recursion_limit="0200"] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this type alias
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:933:31
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:951:31
    |
 LL |     #[recursion_limit="0200"] type T = S;
    |                               ^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![recursion_limit]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:937:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:955:5
    |
 LL |     #[recursion_limit="0200"] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this implementation block
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:937:31
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:955:31
    |
 LL |     #[recursion_limit="0200"] impl S { }
    |                               ^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![type_length_limit]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:942:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:960:1
    |
 LL | #[type_length_limit="0100"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:944:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:962:1
    |
 LL | / mod type_length_limit {
 LL | |
@@ -1450,55 +1467,55 @@ LL | | }
    | |_^
 
 warning: the `#![type_length_limit]` attribute can only be used at the crate root
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:946:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:964:17
    |
 LL |     mod inner { #![type_length_limit="0100"] }
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![type_length_limit]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:949:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:967:5
    |
 LL |     #[type_length_limit="0100"] fn f() { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this function
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:949:33
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:967:33
    |
 LL |     #[type_length_limit="0100"] fn f() { }
    |                                 ^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![type_length_limit]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:953:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:971:5
    |
 LL |     #[type_length_limit="0100"] struct S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this struct
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:953:33
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:971:33
    |
 LL |     #[type_length_limit="0100"] struct S;
    |                                 ^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![type_length_limit]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:957:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:975:5
    |
 LL |     #[type_length_limit="0100"] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this type alias
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:957:33
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:975:33
    |
 LL |     #[type_length_limit="0100"] type T = S;
    |                                 ^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![type_length_limit]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:961:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:979:5
    |
 LL |     #[type_length_limit="0100"] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this implementation block
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:961:33
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:979:33
    |
 LL |     #[type_length_limit="0100"] impl S { }
    |                                 ^^^^^^^^^^
diff --git a/tests/ui/lint/unused/unused-attr-duplicate.stderr b/tests/ui/lint/unused/unused-attr-duplicate.stderr
index 3a3b450f3c55f..fa2c9e59a4184 100644
--- a/tests/ui/lint/unused/unused-attr-duplicate.stderr
+++ b/tests/ui/lint/unused/unused-attr-duplicate.stderr
@@ -53,18 +53,6 @@ note: attribute also specified here
 LL | #![no_builtins]
    | ^^^^^^^^^^^^^^^
 
-error: unused attribute
-  --> $DIR/unused-attr-duplicate.rs:44:5
-   |
-LL |     #[macro_export]
-   |     ^^^^^^^^^^^^^^^ help: remove this attribute
-   |
-note: attribute also specified here
-  --> $DIR/unused-attr-duplicate.rs:43:5
-   |
-LL |     #[macro_export]
-   |     ^^^^^^^^^^^^^^^
-
 error: unused attribute
   --> $DIR/unused-attr-duplicate.rs:41:1
    |
@@ -77,6 +65,18 @@ note: attribute also specified here
 LL | #[macro_use]
    | ^^^^^^^^^^^^
 
+error: unused attribute
+  --> $DIR/unused-attr-duplicate.rs:44:5
+   |
+LL |     #[macro_export]
+   |     ^^^^^^^^^^^^^^^ help: remove this attribute
+   |
+note: attribute also specified here
+  --> $DIR/unused-attr-duplicate.rs:43:5
+   |
+LL |     #[macro_export]
+   |     ^^^^^^^^^^^^^^^
+
 error: unused attribute
   --> $DIR/unused-attr-duplicate.rs:51:1
    |

From 7d80c15fa049a808e3b7cd7ff88447f9a42c0ceb Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Sun, 21 Sep 2025 10:20:56 -0400
Subject: [PATCH 1207/1889] Port #[macro_export] to the new attribute parsing
 infrastructure

Co-authored-by: Anne Stijns <anstijns@gmail.com>
---
 clippy_lints/src/macro_metavars_in_unsafe.rs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/clippy_lints/src/macro_metavars_in_unsafe.rs b/clippy_lints/src/macro_metavars_in_unsafe.rs
index 9071c9c95f9d7..c5acaf0999332 100644
--- a/clippy_lints/src/macro_metavars_in_unsafe.rs
+++ b/clippy_lints/src/macro_metavars_in_unsafe.rs
@@ -5,10 +5,12 @@ use itertools::Itertools;
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::intravisit::{Visitor, walk_block, walk_expr, walk_stmt};
 use rustc_hir::{BlockCheckMode, Expr, ExprKind, HirId, Stmt, UnsafeSource};
+use rustc_hir::attrs::AttributeKind;
+use rustc_hir::find_attr;
 use rustc_lint::{LateContext, LateLintPass, Level, LintContext};
 use rustc_middle::lint::LevelAndSource;
 use rustc_session::impl_lint_pass;
-use rustc_span::{Span, SyntaxContext, sym};
+use rustc_span::{Span, SyntaxContext};
 use std::collections::BTreeMap;
 use std::collections::btree_map::Entry;
 
@@ -146,7 +148,8 @@ struct BodyVisitor<'a, 'tcx> {
 }
 
 fn is_public_macro(cx: &LateContext<'_>, def_id: LocalDefId) -> bool {
-    (cx.effective_visibilities.is_exported(def_id) || cx.tcx.has_attr(def_id, sym::macro_export))
+    ( cx.effective_visibilities.is_exported(def_id) ||
+        find_attr!(cx.tcx.get_all_attrs(def_id), AttributeKind::MacroExport{..}) )
         && !cx.tcx.is_doc_hidden(def_id)
 }
 

From d84505b2ca9d5c79c3700eb2098f8d0dc9aabb2e Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Thu, 18 Sep 2025 22:30:21 +0200
Subject: [PATCH 1208/1889] Post lint on the type HIR node

Out of the 5 lints in the `derive` directory, only two of them
(`unsafe_derive_deserialize` and `derive_partial_eq_without_eq`) posted
the lint on the ADT node. This fixes the situation for the three other
lints:

- `derive_hash_with_manual_eq`
- `derive_ord_xor_partial_ord`
- `expl_impl_clone_on_copy`

This allows `#[expect]` to be used on the ADT to silence the lint.

Also, this makes `expl_impl_clone_on_copy` properly use an "help" message
instead of a "note" one when suggesting a fix.
---
 .../src/derive/derive_ord_xor_partial_ord.rs  |  7 ++++---
 .../derive/derive_partial_eq_without_eq.rs    | 13 ++++++++----
 .../src/derive/derived_hash_with_manual_eq.rs | 10 ++++++----
 .../src/derive/expl_impl_clone_on_copy.rs     | 20 +++++++++++++------
 clippy_lints/src/derive/mod.rs                | 16 ++++++++++-----
 .../src/derive/unsafe_derive_deserialize.rs   | 12 +++++++----
 tests/ui/derive.rs                            | 13 ++++++++++++
 tests/ui/derive.stderr                        | 10 +++++-----
 tests/ui/derive_ord_xor_partial_ord.rs        | 15 ++++++++++++++
 tests/ui/derived_hash_with_manual_eq.rs       | 16 +++++++++++++++
 10 files changed, 101 insertions(+), 31 deletions(-)

diff --git a/clippy_lints/src/derive/derive_ord_xor_partial_ord.rs b/clippy_lints/src/derive/derive_ord_xor_partial_ord.rs
index cbbcb2f7a3bab..274c699ff9d24 100644
--- a/clippy_lints/src/derive/derive_ord_xor_partial_ord.rs
+++ b/clippy_lints/src/derive/derive_ord_xor_partial_ord.rs
@@ -1,5 +1,5 @@
-use clippy_utils::diagnostics::span_lint_and_then;
-use rustc_hir as hir;
+use clippy_utils::diagnostics::span_lint_hir_and_then;
+use rustc_hir::{self as hir, HirId};
 use rustc_lint::LateContext;
 use rustc_middle::ty::Ty;
 use rustc_span::{Span, sym};
@@ -12,6 +12,7 @@ pub(super) fn check<'tcx>(
     span: Span,
     trait_ref: &hir::TraitRef<'_>,
     ty: Ty<'tcx>,
+    adt_hir_id: HirId,
     ord_is_automatically_derived: bool,
 ) {
     if let Some(ord_trait_def_id) = cx.tcx.get_diagnostic_item(sym::Ord)
@@ -38,7 +39,7 @@ pub(super) fn check<'tcx>(
                     "you are deriving `Ord` but have implemented `PartialOrd` explicitly"
                 };
 
-                span_lint_and_then(cx, DERIVE_ORD_XOR_PARTIAL_ORD, span, mess, |diag| {
+                span_lint_hir_and_then(cx, DERIVE_ORD_XOR_PARTIAL_ORD, adt_hir_id, span, mess, |diag| {
                     if let Some(local_def_id) = impl_id.as_local() {
                         let hir_id = cx.tcx.local_def_id_to_hir_id(local_def_id);
                         diag.span_note(cx.tcx.hir_span(hir_id), "`PartialOrd` implemented here");
diff --git a/clippy_lints/src/derive/derive_partial_eq_without_eq.rs b/clippy_lints/src/derive/derive_partial_eq_without_eq.rs
index ed7881c461ffc..fbace0bd73acf 100644
--- a/clippy_lints/src/derive/derive_partial_eq_without_eq.rs
+++ b/clippy_lints/src/derive/derive_partial_eq_without_eq.rs
@@ -2,8 +2,8 @@ use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::has_non_exhaustive_attr;
 use clippy_utils::ty::implements_trait_with_env;
 use rustc_errors::Applicability;
-use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
+use rustc_hir::{self as hir, HirId};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, ClauseKind, GenericParamDefKind, ParamEnv, TraitPredicate, Ty, TyCtxt, Upcast};
 use rustc_span::{Span, sym};
@@ -11,7 +11,13 @@ use rustc_span::{Span, sym};
 use super::DERIVE_PARTIAL_EQ_WITHOUT_EQ;
 
 /// Implementation of the `DERIVE_PARTIAL_EQ_WITHOUT_EQ` lint.
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, span: Span, trait_ref: &hir::TraitRef<'_>, ty: Ty<'tcx>) {
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    span: Span,
+    trait_ref: &hir::TraitRef<'_>,
+    ty: Ty<'tcx>,
+    adt_hir_id: HirId,
+) {
     if let ty::Adt(adt, args) = ty.kind()
         && cx.tcx.visibility(adt.did()).is_public()
         && let Some(eq_trait_def_id) = cx.tcx.get_diagnostic_item(sym::Eq)
@@ -20,7 +26,6 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, span: Span, trait_ref: &hir::T
         && !has_non_exhaustive_attr(cx.tcx, *adt)
         && !ty_implements_eq_trait(cx.tcx, ty, eq_trait_def_id)
         && let typing_env = typing_env_for_derived_eq(cx.tcx, adt.did(), eq_trait_def_id)
-        && let Some(local_def_id) = adt.did().as_local()
         // If all of our fields implement `Eq`, we can implement `Eq` too
         && adt
             .all_fields()
@@ -30,7 +35,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, span: Span, trait_ref: &hir::T
         span_lint_hir_and_then(
             cx,
             DERIVE_PARTIAL_EQ_WITHOUT_EQ,
-            cx.tcx.local_def_id_to_hir_id(local_def_id),
+            adt_hir_id,
             span.ctxt().outer_expn_data().call_site,
             "you are deriving `PartialEq` and can implement `Eq`",
             |diag| {
diff --git a/clippy_lints/src/derive/derived_hash_with_manual_eq.rs b/clippy_lints/src/derive/derived_hash_with_manual_eq.rs
index 6f36a58025a2b..afc02ce32d48e 100644
--- a/clippy_lints/src/derive/derived_hash_with_manual_eq.rs
+++ b/clippy_lints/src/derive/derived_hash_with_manual_eq.rs
@@ -1,5 +1,5 @@
-use clippy_utils::diagnostics::span_lint_and_then;
-use rustc_hir as hir;
+use clippy_utils::diagnostics::span_lint_hir_and_then;
+use rustc_hir::{HirId, TraitRef};
 use rustc_lint::LateContext;
 use rustc_middle::ty::Ty;
 use rustc_span::{Span, sym};
@@ -10,8 +10,9 @@ use super::DERIVED_HASH_WITH_MANUAL_EQ;
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     span: Span,
-    trait_ref: &hir::TraitRef<'_>,
+    trait_ref: &TraitRef<'_>,
     ty: Ty<'tcx>,
+    adt_hir_id: HirId,
     hash_is_automatically_derived: bool,
 ) {
     if let Some(peq_trait_def_id) = cx.tcx.lang_items().eq_trait()
@@ -31,9 +32,10 @@ pub(super) fn check<'tcx>(
             // Only care about `impl PartialEq<Foo> for Foo`
             // For `impl PartialEq<B> for A, input_types is [A, B]
             if trait_ref.instantiate_identity().args.type_at(1) == ty {
-                span_lint_and_then(
+                span_lint_hir_and_then(
                     cx,
                     DERIVED_HASH_WITH_MANUAL_EQ,
+                    adt_hir_id,
                     span,
                     "you are deriving `Hash` but have implemented `PartialEq` explicitly",
                     |diag| {
diff --git a/clippy_lints/src/derive/expl_impl_clone_on_copy.rs b/clippy_lints/src/derive/expl_impl_clone_on_copy.rs
index 6b97b4bd6b4d3..dfb723b86eb93 100644
--- a/clippy_lints/src/derive/expl_impl_clone_on_copy.rs
+++ b/clippy_lints/src/derive/expl_impl_clone_on_copy.rs
@@ -1,13 +1,19 @@
-use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::ty::{implements_trait, is_copy};
-use rustc_hir::{self as hir, Item};
+use rustc_hir::{self as hir, HirId, Item};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, GenericArgKind, Ty};
 
 use super::EXPL_IMPL_CLONE_ON_COPY;
 
 /// Implementation of the `EXPL_IMPL_CLONE_ON_COPY` lint.
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, item: &Item<'_>, trait_ref: &hir::TraitRef<'_>, ty: Ty<'tcx>) {
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    item: &Item<'_>,
+    trait_ref: &hir::TraitRef<'_>,
+    ty: Ty<'tcx>,
+    adt_hir_id: HirId,
+) {
     let clone_id = match cx.tcx.lang_items().clone_trait() {
         Some(id) if trait_ref.trait_def_id() == Some(id) => id,
         _ => return,
@@ -54,12 +60,14 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, item: &Item<'_>, trait_ref: &h
         return;
     }
 
-    span_lint_and_note(
+    span_lint_hir_and_then(
         cx,
         EXPL_IMPL_CLONE_ON_COPY,
+        adt_hir_id,
         item.span,
         "you are implementing `Clone` explicitly on a `Copy` type",
-        Some(item.span),
-        "consider deriving `Clone` or removing `Copy`",
+        |diag| {
+            diag.span_help(item.span, "consider deriving `Clone` or removing `Copy`");
+        },
     );
 }
diff --git a/clippy_lints/src/derive/mod.rs b/clippy_lints/src/derive/mod.rs
index 1d63394ce37d4..06efc2709faa6 100644
--- a/clippy_lints/src/derive/mod.rs
+++ b/clippy_lints/src/derive/mod.rs
@@ -1,3 +1,5 @@
+use clippy_utils::path_res;
+use rustc_hir::def::Res;
 use rustc_hir::{Impl, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
@@ -194,21 +196,25 @@ impl<'tcx> LateLintPass<'tcx> for Derive {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         if let ItemKind::Impl(Impl {
             of_trait: Some(of_trait),
+            self_ty,
             ..
         }) = item.kind
+            && let Res::Def(_, def_id) = path_res(cx, self_ty)
+            && let Some(local_def_id) = def_id.as_local()
         {
+            let adt_hir_id = cx.tcx.local_def_id_to_hir_id(local_def_id);
             let trait_ref = &of_trait.trait_ref;
             let ty = cx.tcx.type_of(item.owner_id).instantiate_identity();
             let is_automatically_derived = cx.tcx.is_automatically_derived(item.owner_id.to_def_id());
 
-            derived_hash_with_manual_eq::check(cx, item.span, trait_ref, ty, is_automatically_derived);
-            derive_ord_xor_partial_ord::check(cx, item.span, trait_ref, ty, is_automatically_derived);
+            derived_hash_with_manual_eq::check(cx, item.span, trait_ref, ty, adt_hir_id, is_automatically_derived);
+            derive_ord_xor_partial_ord::check(cx, item.span, trait_ref, ty, adt_hir_id, is_automatically_derived);
 
             if is_automatically_derived {
-                unsafe_derive_deserialize::check(cx, item, trait_ref, ty);
-                derive_partial_eq_without_eq::check(cx, item.span, trait_ref, ty);
+                unsafe_derive_deserialize::check(cx, item, trait_ref, ty, adt_hir_id);
+                derive_partial_eq_without_eq::check(cx, item.span, trait_ref, ty, adt_hir_id);
             } else {
-                expl_impl_clone_on_copy::check(cx, item, trait_ref, ty);
+                expl_impl_clone_on_copy::check(cx, item, trait_ref, ty, adt_hir_id);
             }
         }
     }
diff --git a/clippy_lints/src/derive/unsafe_derive_deserialize.rs b/clippy_lints/src/derive/unsafe_derive_deserialize.rs
index c391e7b62289f..38f3251fd3891 100644
--- a/clippy_lints/src/derive/unsafe_derive_deserialize.rs
+++ b/clippy_lints/src/derive/unsafe_derive_deserialize.rs
@@ -4,7 +4,7 @@ use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::{is_lint_allowed, paths};
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::intravisit::{FnKind, Visitor, walk_expr, walk_fn, walk_item};
-use rustc_hir::{self as hir, BlockCheckMode, BodyId, Expr, ExprKind, FnDecl, Item, UnsafeSource};
+use rustc_hir::{self as hir, BlockCheckMode, BodyId, Expr, ExprKind, FnDecl, HirId, Item, UnsafeSource};
 use rustc_lint::LateContext;
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::{self, Ty};
@@ -13,7 +13,13 @@ use rustc_span::{Span, sym};
 use super::UNSAFE_DERIVE_DESERIALIZE;
 
 /// Implementation of the `UNSAFE_DERIVE_DESERIALIZE` lint.
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, item: &Item<'_>, trait_ref: &hir::TraitRef<'_>, ty: Ty<'tcx>) {
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    item: &Item<'_>,
+    trait_ref: &hir::TraitRef<'_>,
+    ty: Ty<'tcx>,
+    adt_hir_id: HirId,
+) {
     fn has_unsafe<'tcx>(cx: &LateContext<'tcx>, item: &'tcx Item<'_>) -> bool {
         let mut visitor = UnsafeVisitor { cx };
         walk_item(&mut visitor, item).is_break()
@@ -22,8 +28,6 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, item: &Item<'_>, trait_ref: &h
     if let Some(trait_def_id) = trait_ref.trait_def_id()
         && paths::SERDE_DESERIALIZE.matches(cx, trait_def_id)
         && let ty::Adt(def, _) = ty.kind()
-        && let Some(local_def_id) = def.did().as_local()
-        && let adt_hir_id = cx.tcx.local_def_id_to_hir_id(local_def_id)
         && !is_lint_allowed(cx, UNSAFE_DERIVE_DESERIALIZE, adt_hir_id)
         && cx
             .tcx
diff --git a/tests/ui/derive.rs b/tests/ui/derive.rs
index 2c5fa0be9755c..305f73c92cd5c 100644
--- a/tests/ui/derive.rs
+++ b/tests/ui/derive.rs
@@ -130,3 +130,16 @@ fn issue14558() {
 }
 
 fn main() {}
+
+mod issue15708 {
+    // Check that the lint posts on the type definition node
+    #[expect(clippy::expl_impl_clone_on_copy)]
+    #[derive(Copy)]
+    struct S;
+
+    impl Clone for S {
+        fn clone(&self) -> Self {
+            S
+        }
+    }
+}
diff --git a/tests/ui/derive.stderr b/tests/ui/derive.stderr
index ff2c24ff48ee7..48e55fc7469e4 100644
--- a/tests/ui/derive.stderr
+++ b/tests/ui/derive.stderr
@@ -9,7 +9,7 @@ LL | |     fn clone(&self) -> Self {
 LL | | }
    | |_^
    |
-note: consider deriving `Clone` or removing `Copy`
+help: consider deriving `Clone` or removing `Copy`
   --> tests/ui/derive.rs:15:1
    |
 LL | / impl Clone for Qux {
@@ -33,7 +33,7 @@ LL | |     fn clone(&self) -> Self {
 LL | | }
    | |_^
    |
-note: consider deriving `Clone` or removing `Copy`
+help: consider deriving `Clone` or removing `Copy`
   --> tests/ui/derive.rs:41:1
    |
 LL | / impl<'a> Clone for Lt<'a> {
@@ -55,7 +55,7 @@ LL | |     fn clone(&self) -> Self {
 LL | | }
    | |_^
    |
-note: consider deriving `Clone` or removing `Copy`
+help: consider deriving `Clone` or removing `Copy`
   --> tests/ui/derive.rs:54:1
    |
 LL | / impl Clone for BigArray {
@@ -77,7 +77,7 @@ LL | |     fn clone(&self) -> Self {
 LL | | }
    | |_^
    |
-note: consider deriving `Clone` or removing `Copy`
+help: consider deriving `Clone` or removing `Copy`
   --> tests/ui/derive.rs:67:1
    |
 LL | / impl Clone for FnPtr {
@@ -99,7 +99,7 @@ LL | |     fn clone(&self) -> Self {
 LL | | }
    | |_^
    |
-note: consider deriving `Clone` or removing `Copy`
+help: consider deriving `Clone` or removing `Copy`
   --> tests/ui/derive.rs:89:1
    |
 LL | / impl<T: Clone> Clone for Generic2<T> {
diff --git a/tests/ui/derive_ord_xor_partial_ord.rs b/tests/ui/derive_ord_xor_partial_ord.rs
index 3ef4ee9463dca..b4bb24b0d2fe7 100644
--- a/tests/ui/derive_ord_xor_partial_ord.rs
+++ b/tests/ui/derive_ord_xor_partial_ord.rs
@@ -76,3 +76,18 @@ mod use_ord {
 }
 
 fn main() {}
+
+mod issue15708 {
+    use std::cmp::{Ord, Ordering};
+
+    // Check that the lint posts on the type definition node
+    #[expect(clippy::derive_ord_xor_partial_ord)]
+    #[derive(PartialOrd, PartialEq, Eq)]
+    struct DerivePartialOrdInUseOrd;
+
+    impl Ord for DerivePartialOrdInUseOrd {
+        fn cmp(&self, other: &Self) -> Ordering {
+            Ordering::Less
+        }
+    }
+}
diff --git a/tests/ui/derived_hash_with_manual_eq.rs b/tests/ui/derived_hash_with_manual_eq.rs
index 88b574add3f27..9f5c85d7fbc38 100644
--- a/tests/ui/derived_hash_with_manual_eq.rs
+++ b/tests/ui/derived_hash_with_manual_eq.rs
@@ -41,3 +41,19 @@ impl std::hash::Hash for Bah {
 }
 
 fn main() {}
+
+mod issue15708 {
+    // Check that the lint posts on the type definition node
+    #[expect(clippy::derived_hash_with_manual_eq)]
+    #[derive(Debug, Clone, Copy, Eq, PartialOrd, Ord, Hash)]
+    pub struct Span {
+        start: usize,
+        end: usize,
+    }
+
+    impl PartialEq for Span {
+        fn eq(&self, other: &Self) -> bool {
+            self.start.cmp(&other.start).then(self.end.cmp(&other.end)).is_eq()
+        }
+    }
+}

From 1bc19932e6f0a5ce098af6f3d59e28a61abbc631 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 15 Sep 2025 19:08:55 +0530
Subject: [PATCH 1209/1889] make cargo test work for bootstrap self test

---
 src/bootstrap/src/core/config/config.rs  | 24 ++++-----
 src/bootstrap/src/core/config/tests.rs   | 62 ++----------------------
 src/bootstrap/src/utils/helpers/tests.rs |  4 +-
 3 files changed, 17 insertions(+), 73 deletions(-)

diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index dd2d5a1fd5332..19fcaeaaa24de 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -630,19 +630,9 @@ impl Config {
         let llvm_assertions = llvm_assertions.unwrap_or(false);
         let mut target_config = HashMap::new();
         let mut channel = "dev".to_string();
-        let out = flags_build_dir.or(build_build_dir.map(PathBuf::from)).unwrap_or_else(|| {
-            if cfg!(test) {
-                // Use the build directory of the original x.py invocation, so that we can set `initial_rustc` properly.
-                Path::new(
-                    &env::var_os("CARGO_TARGET_DIR").expect("cargo test directly is not supported"),
-                )
-                .parent()
-                .unwrap()
-                .to_path_buf()
-            } else {
-                PathBuf::from("build")
-            }
-        });
+        let out = flags_build_dir
+            .or(build_build_dir.map(PathBuf::from))
+            .unwrap_or_else(|| PathBuf::from("build"));
 
         // NOTE: Bootstrap spawns various commands with different working directories.
         // To avoid writing to random places on the file system, `config.out` needs to be an absolute path.
@@ -693,8 +683,14 @@ impl Config {
         };
 
         let initial_rustc = build_rustc.unwrap_or_else(|| {
+            let out = if cfg!(test) { Path::new("../../build").to_path_buf() } else { out.clone() };
+
             download_beta_toolchain(&dwn_ctx, &out);
-            out.join(host_target).join("stage0").join("bin").join(exe("rustc", host_target))
+
+            out.join(if cfg!(test) { get_host_target() } else { host_target })
+                .join("stage0")
+                .join("bin")
+                .join(exe("rustc", host_target))
         });
 
         let initial_sysroot = t!(PathBuf::from_str(
diff --git a/src/bootstrap/src/core/config/tests.rs b/src/bootstrap/src/core/config/tests.rs
index e93525fbd09ce..46d05fbc06864 100644
--- a/src/bootstrap/src/core/config/tests.rs
+++ b/src/bootstrap/src/core/config/tests.rs
@@ -39,7 +39,11 @@ fn prepare_test_specific_dir() -> PathBuf {
     // Replace "::" with "_" to make it safe for directory names on Windows systems
     let test_path = current.name().unwrap().replace("::", "_");
 
-    let testdir = parse("").tempdir().join(test_path);
+    let testdir = crate::utils::tests::TestCtx::new()
+        .config("check")
+        .create_config()
+        .tempdir()
+        .join(test_path);
 
     // clean up any old test files
     let _ = fs::remove_dir_all(&testdir);
@@ -64,62 +68,6 @@ fn download_ci_llvm() {
     }
 }
 
-// FIXME(onur-ozkan): extend scope of the test
-// refs:
-//   - https://github.com/rust-lang/rust/issues/109120
-//   - https://github.com/rust-lang/rust/pull/109162#issuecomment-1496782487
-#[test]
-fn detect_src_and_out() {
-    fn test(cfg: Config, build_dir: Option<&str>) {
-        // This will bring absolute form of `src/bootstrap` path
-        let current_dir = std::env::current_dir().unwrap();
-
-        // get `src` by moving into project root path
-        let expected_src = current_dir.ancestors().nth(2).unwrap();
-        assert_eq!(&cfg.src, expected_src);
-
-        // Sanity check for `src`
-        let manifest_dir = Path::new(env!("CARGO_MANIFEST_DIR"));
-        let expected_src = manifest_dir.ancestors().nth(2).unwrap();
-        assert_eq!(&cfg.src, expected_src);
-
-        // test if build-dir was manually given in bootstrap.toml
-        if let Some(custom_build_dir) = build_dir {
-            assert_eq!(&cfg.out, Path::new(custom_build_dir));
-        }
-        // test the native bootstrap way
-        else {
-            // This should bring output path of bootstrap in absolute form
-            let cargo_target_dir = env::var_os("CARGO_TARGET_DIR").expect(
-                "CARGO_TARGET_DIR must been provided for the test environment from bootstrap",
-            );
-
-            // Move to `build` from `build/bootstrap`
-            let expected_out = Path::new(&cargo_target_dir).parent().unwrap();
-            assert_eq!(&cfg.out, expected_out);
-
-            let args: Vec<String> = env::args().collect();
-
-            // Another test for `out` as a sanity check
-            //
-            // This will bring something similar to:
-            //     `{build-dir}/bootstrap/debug/deps/bootstrap-c7ee91d5661e2804`
-            // `{build-dir}` can be anywhere, not just in the rust project directory.
-            let dep = Path::new(args.first().unwrap());
-            let expected_out = dep.ancestors().nth(5).unwrap();
-
-            assert_eq!(&cfg.out, expected_out);
-        }
-    }
-
-    test(parse(""), None);
-
-    {
-        let build_dir = if cfg!(windows) { "C:\\tmp" } else { "/tmp" };
-        test(parse(&format!("build.build-dir = '{build_dir}'")), Some(build_dir));
-    }
-}
-
 #[test]
 fn clap_verify() {
     Flags::command().debug_assert();
diff --git a/src/bootstrap/src/utils/helpers/tests.rs b/src/bootstrap/src/utils/helpers/tests.rs
index 9030ca2820a8b..e586fe77b4f62 100644
--- a/src/bootstrap/src/utils/helpers/tests.rs
+++ b/src/bootstrap/src/utils/helpers/tests.rs
@@ -6,6 +6,7 @@ use crate::utils::helpers::{
     check_cfg_arg, extract_beta_rev, hex_encode, make, set_file_times, submodule_path_of,
     symlink_dir,
 };
+use crate::utils::tests::TestCtx;
 use crate::{Config, Flags};
 
 #[test]
@@ -80,8 +81,7 @@ fn test_symlink_dir() {
 
 #[test]
 fn test_set_file_times_sanity_check() {
-    let config =
-        Config::parse(Flags::parse(&["check".to_owned(), "--config=/does/not/exist".to_owned()]));
+    let config = TestCtx::new().config("check").create_config();
     let tempfile = config.tempdir().join(".tmp-file");
 
     {

From a12969e0d10387ad17755879e98cf5097a937473 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 15 Sep 2025 19:20:05 +0530
Subject: [PATCH 1210/1889] walk up the ancestors

---
 src/bootstrap/src/core/config/config.rs | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index 19fcaeaaa24de..003cf3f2f9c3e 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -683,14 +683,15 @@ impl Config {
         };
 
         let initial_rustc = build_rustc.unwrap_or_else(|| {
-            let out = if cfg!(test) { Path::new("../../build").to_path_buf() } else { out.clone() };
-
+            let out = if cfg!(test) {
+                std::env::current_dir().unwrap().ancestors().nth(2).unwrap().join("build")
+            } else {
+                out.clone()
+            };
             download_beta_toolchain(&dwn_ctx, &out);
+            let target = if cfg!(test) { get_host_target() } else { host_target };
 
-            out.join(if cfg!(test) { get_host_target() } else { host_target })
-                .join("stage0")
-                .join("bin")
-                .join(exe("rustc", host_target))
+            out.join(target).join("stage0").join("bin").join(exe("rustc", host_target))
         });
 
         let initial_sysroot = t!(PathBuf::from_str(

From 6c79f547f9ecf72ff8b9748dc0001d92217dff71 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Tue, 16 Sep 2025 21:16:29 +0530
Subject: [PATCH 1211/1889] add an API in ConfigBuilder to point to config file
 for toml parsing

---
 src/bootstrap/src/utils/tests/mod.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/bootstrap/src/utils/tests/mod.rs b/src/bootstrap/src/utils/tests/mod.rs
index 3332187e2a853..ff84bfdb4cde3 100644
--- a/src/bootstrap/src/utils/tests/mod.rs
+++ b/src/bootstrap/src/utils/tests/mod.rs
@@ -98,6 +98,14 @@ impl ConfigBuilder {
         self
     }
 
+    pub fn config_toml(mut self, config_toml: &str) -> Self {
+        let toml_path = self.directory.join("bootstrap.toml");
+        std::fs::write(&toml_path, config_toml).unwrap();
+        self.args.push("--config".to_string());
+        self.args.push(toml_path.display().to_string());
+        self
+    }
+
     pub fn create_config(mut self) -> Config {
         // Run in dry-check, otherwise the test would be too slow
         self.args.push("--dry-run".to_string());

From d488d33fd6f7d4832cab12d0dece896bf1b975c0 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Tue, 16 Sep 2025 21:17:15 +0530
Subject: [PATCH 1212/1889] let verify method run in test settings

---
 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 2f3c80559c0ef..ce3f49a35b9e6 100644
--- a/src/bootstrap/src/core/download.rs
+++ b/src/bootstrap/src/core/download.rs
@@ -857,7 +857,7 @@ pub(crate) fn verify(exec_ctx: &ExecutionContext, path: &Path, expected: &str) -
         println!("verifying {}", path.display());
     });
 
-    if exec_ctx.dry_run() {
+    if exec_ctx.dry_run() && !cfg!(test) {
         return false;
     }
 

From ce4604e34e6f29740b41306806c6bd7947e103a4 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Tue, 16 Sep 2025 21:18:35 +0530
Subject: [PATCH 1213/1889] remove using default toml config for test in
 get_toml, we handle it via using the temp directory created via the testCtx

---
 src/bootstrap/src/core/config/toml/mod.rs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/bootstrap/src/core/config/toml/mod.rs b/src/bootstrap/src/core/config/toml/mod.rs
index 7af22432ef8ca..f6dc5b67e1010 100644
--- a/src/bootstrap/src/core/config/toml/mod.rs
+++ b/src/bootstrap/src/core/config/toml/mod.rs
@@ -152,10 +152,6 @@ impl Config {
     }
 
     pub(crate) fn get_toml(file: &Path) -> Result<TomlConfig, toml::de::Error> {
-        #[cfg(test)]
-        return Ok(TomlConfig::default());
-
-        #[cfg(not(test))]
         Self::get_toml_inner(file)
     }
 

From 24ed1a0455ced62f48402f6740effbf818f45269 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Tue, 16 Sep 2025 21:18:58 +0530
Subject: [PATCH 1214/1889] allow symlinking during test

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

diff --git a/src/bootstrap/src/utils/helpers.rs b/src/bootstrap/src/utils/helpers.rs
index e802c0214ddcb..0561f343a8c19 100644
--- a/src/bootstrap/src/utils/helpers.rs
+++ b/src/bootstrap/src/utils/helpers.rs
@@ -160,7 +160,7 @@ impl Drop for TimeIt {
 /// Symlinks two directories, using junctions on Windows and normal symlinks on
 /// Unix.
 pub fn symlink_dir(config: &Config, original: &Path, link: &Path) -> io::Result<()> {
-    if config.dry_run() {
+    if config.dry_run() && !cfg!(test) {
         return Ok(());
     }
     let _ = fs::remove_dir_all(link);

From 05131bd5f11812390018dddc29fb9a36c4657ed2 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Tue, 16 Sep 2025 21:19:29 +0530
Subject: [PATCH 1215/1889] move most of the test to new testCtx

---
 src/bootstrap/src/core/builder/tests.rs  |  31 +--
 src/bootstrap/src/core/config/tests.rs   | 305 +++++++++++------------
 src/bootstrap/src/utils/helpers/tests.rs |   7 +-
 3 files changed, 152 insertions(+), 191 deletions(-)

diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index 229adf714598b..a3cb4660ffc51 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -218,18 +218,16 @@ fn prepare_rustc_checkout(ctx: &mut GitCtx) {
 
 /// Parses a Config directory from `path`, with the given value of `download_rustc`.
 fn parse_config_download_rustc_at(path: &Path, download_rustc: &str, ci: bool) -> Config {
-    Config::parse_inner(
-        Flags::parse(&[
-            "build".to_owned(),
-            "--dry-run".to_owned(),
-            "--ci".to_owned(),
-            if ci { "true" } else { "false" }.to_owned(),
-            format!("--set=rust.download-rustc='{download_rustc}'"),
-            "--src".to_owned(),
-            path.to_str().unwrap().to_owned(),
-        ]),
-        |&_| Ok(Default::default()),
-    )
+    TestCtx::new()
+        .config("build")
+        .args(&[
+            "--ci",
+            if ci { "true" } else { "false" },
+            format!("--set=rust.download-rustc='{download_rustc}'").as_str(),
+            "--src",
+            path.to_str().unwrap(),
+        ])
+        .create_config_without_ci_llvm_override()
 }
 
 mod dist {
@@ -359,14 +357,7 @@ fn test_test_coverage() {
 #[test]
 fn test_prebuilt_llvm_config_path_resolution() {
     fn configure(config: &str) -> Config {
-        Config::parse_inner(
-            Flags::parse(&[
-                "build".to_string(),
-                "--dry-run".to_string(),
-                "--config=/does/not/exist".to_string(),
-            ]),
-            |&_| toml::from_str(&config),
-        )
+        TestCtx::new().config("build").config_toml(config).create_config()
     }
 
     // Removes Windows disk prefix if present
diff --git a/src/bootstrap/src/core/config/tests.rs b/src/bootstrap/src/core/config/tests.rs
index 46d05fbc06864..68859c6545e10 100644
--- a/src/bootstrap/src/core/config/tests.rs
+++ b/src/bootstrap/src/core/config/tests.rs
@@ -14,17 +14,15 @@ use super::toml::change_id::ChangeIdWrapper;
 use super::{Config, RUSTC_IF_UNCHANGED_ALLOWED_PATHS};
 use crate::ChangeId;
 use crate::core::build_steps::clippy::{LintConfig, get_clippy_rules_in_order};
-use crate::core::build_steps::llvm;
 use crate::core::build_steps::llvm::LLVM_INVALIDATION_PATHS;
+use crate::core::build_steps::{llvm, test};
 use crate::core::config::toml::TomlConfig;
 use crate::core::config::{CompilerBuiltins, LldMode, StringOrBool, Target, TargetSelection};
+use crate::utils::tests::TestCtx;
 use crate::utils::tests::git::git_test;
 
 pub(crate) fn parse(config: &str) -> Config {
-    Config::parse_inner(
-        Flags::parse(&["check".to_string(), "--config=/does/not/exist".to_string()]),
-        |&_| toml::from_str(&config),
-    )
+    TestCtx::new().config("check").config_toml(config).create_config()
 }
 
 fn get_toml(file: &Path) -> Result<TomlConfig, toml::de::Error> {
@@ -54,10 +52,14 @@ fn prepare_test_specific_dir() -> PathBuf {
 
 #[test]
 fn download_ci_llvm() {
-    let config = parse("llvm.download-ci-llvm = false");
+    let config = TestCtx::new().config("check").create_config();
     assert!(!config.llvm_from_ci);
 
-    let if_unchanged_config = parse("llvm.download-ci-llvm = \"if-unchanged\"");
+    // this doesn't make sense, as we are overriding it later.
+    let if_unchanged_config = TestCtx::new()
+        .config("check")
+        .config_toml("llvm.download-ci-llvm = \"if-unchanged\"")
+        .create_config();
     if if_unchanged_config.llvm_from_ci && if_unchanged_config.is_running_on_ci {
         let has_changes = if_unchanged_config.has_changes_from_upstream(LLVM_INVALIDATION_PATHS);
 
@@ -75,54 +77,51 @@ fn clap_verify() {
 
 #[test]
 fn override_toml() {
-    let config = Config::parse_inner(
-        Flags::parse(&[
-            "check".to_owned(),
-            "--config=/does/not/exist".to_owned(),
-            "--set=change-id=1".to_owned(),
-            "--set=rust.lto=fat".to_owned(),
-            "--set=rust.deny-warnings=false".to_owned(),
-            "--set=build.optimized-compiler-builtins=true".to_owned(),
-            "--set=build.gdb=\"bar\"".to_owned(),
-            "--set=build.tools=[\"cargo\"]".to_owned(),
-            "--set=llvm.build-config={\"foo\" = \"bar\"}".to_owned(),
-            "--set=target.x86_64-unknown-linux-gnu.runner=bar".to_owned(),
-            "--set=target.x86_64-unknown-linux-gnu.rpath=false".to_owned(),
-            "--set=target.aarch64-unknown-linux-gnu.sanitizers=false".to_owned(),
-            "--set=target.aarch64-apple-darwin.runner=apple".to_owned(),
-            "--set=target.aarch64-apple-darwin.optimized-compiler-builtins=false".to_owned(),
-        ]),
-        |&_| {
-            toml::from_str(
-                r#"
-change-id = 0
-[rust]
-lto = "off"
-deny-warnings = true
-download-rustc=false
-
-[build]
-gdb = "foo"
-tools = []
-
-[llvm]
-download-ci-llvm = false
-build-config = {}
-
-[target.aarch64-unknown-linux-gnu]
-sanitizers = true
-rpath = true
-runner = "aarch64-runner"
-
-[target.x86_64-unknown-linux-gnu]
-sanitizers = true
-rpath = true
-runner = "x86_64-runner"
-
-                "#,
-            )
-        },
-    );
+    let config_toml: &str = r#"
+    change-id = 0
+
+    [rust]
+    lto = "off"
+    deny-warnings = true
+    download-rustc = false
+
+    [build]
+    gdb = "foo"
+    tools = []
+
+    [llvm]
+    download-ci-llvm = false
+    build-config = {}
+
+    [target.aarch64-unknown-linux-gnu]
+    sanitizers = true
+    rpath = true
+    runner = "aarch64-runner"
+
+    [target.x86_64-unknown-linux-gnu]
+    sanitizers = true
+    rpath = true
+    runner = "x86_64-runner"
+    "#;
+
+    let args = [
+        "--set=change-id=1",
+        "--set=rust.lto=fat",
+        "--set=rust.deny-warnings=false",
+        "--set=build.optimized-compiler-builtins=true",
+        "--set=build.gdb=\"bar\"",
+        "--set=build.tools=[\"cargo\"]",
+        "--set=llvm.build-config={\"foo\" = \"bar\"}",
+        "--set=target.x86_64-unknown-linux-gnu.runner=bar",
+        "--set=target.x86_64-unknown-linux-gnu.rpath=false",
+        "--set=target.aarch64-unknown-linux-gnu.sanitizers=false",
+        "--set=target.aarch64-apple-darwin.runner=apple",
+        "--set=target.aarch64-apple-darwin.optimized-compiler-builtins=false",
+    ];
+
+    let config =
+        TestCtx::new().config("check").config_toml(config_toml).args(&args).create_config();
+
     assert_eq!(config.change_id, Some(ChangeId::Id(1)), "setting top-level value");
     assert_eq!(
         config.rust_lto,
@@ -181,15 +180,14 @@ runner = "x86_64-runner"
 #[test]
 #[should_panic]
 fn override_toml_duplicate() {
-    Config::parse_inner(
-        Flags::parse(&[
-            "check".to_owned(),
-            "--config=/does/not/exist".to_string(),
-            "--set=change-id=1".to_owned(),
-            "--set=change-id=2".to_owned(),
-        ]),
-        |&_| toml::from_str("change-id = 0"),
-    );
+    TestCtx::new()
+        .config("check")
+        .config_toml("change-id = 0")
+        .arg("--set")
+        .arg("change-id=1")
+        .arg("--set")
+        .arg("change-id=2")
+        .create_config();
 }
 
 #[test]
@@ -225,12 +223,12 @@ fn rust_optimize() {
 #[test]
 #[should_panic]
 fn invalid_rust_optimize() {
-    parse("rust.optimize = \"a\"");
+    TestCtx::new().config("check").config_toml("rust.optimize = \"a\"").create_config();
 }
 
 #[test]
 fn verify_file_integrity() {
-    let config = parse("");
+    let config = TestCtx::new().config("check").create_config();
 
     let tempfile = config.tempdir().join(".tmp-test-file");
     File::create(&tempfile).unwrap().write_all(b"dummy value").unwrap();
@@ -272,22 +270,23 @@ fn parse_change_id_with_unknown_field() {
 
 #[test]
 fn order_of_clippy_rules() {
-    let args = vec![
-        "clippy".to_string(),
-        "--fix".to_string(),
-        "--allow-dirty".to_string(),
-        "--allow-staged".to_string(),
-        "-Aclippy:all".to_string(),
-        "-Wclippy::style".to_string(),
-        "-Aclippy::foo1".to_string(),
-        "-Aclippy::foo2".to_string(),
+    let args = [
+        "clippy",
+        "--fix",
+        "--allow-dirty",
+        "--allow-staged",
+        "-Aclippy:all",
+        "-Wclippy::style",
+        "-Aclippy::foo1",
+        "-Aclippy::foo2",
     ];
-    let config = Config::parse(Flags::parse(&args));
+    let config = TestCtx::new().config(&args[0]).args(&args[1..]).create_config();
 
     let actual = match config.cmd.clone() {
         crate::Subcommand::Clippy { allow, deny, warn, forbid, .. } => {
             let cfg = LintConfig { allow, deny, warn, forbid };
-            get_clippy_rules_in_order(&args, &cfg)
+            let args_vec: Vec<String> = args.iter().map(|s| s.to_string()).collect();
+            get_clippy_rules_in_order(&args_vec, &cfg)
         }
         _ => panic!("invalid subcommand"),
     };
@@ -304,14 +303,14 @@ fn order_of_clippy_rules() {
 
 #[test]
 fn clippy_rule_separate_prefix() {
-    let args =
-        vec!["clippy".to_string(), "-A clippy:all".to_string(), "-W clippy::style".to_string()];
-    let config = Config::parse(Flags::parse(&args));
+    let args = ["clippy", "-A clippy:all", "-W clippy::style"];
+    let config = TestCtx::new().config(&args[0]).args(&args[1..]).create_config();
 
     let actual = match config.cmd.clone() {
         crate::Subcommand::Clippy { allow, deny, warn, forbid, .. } => {
             let cfg = LintConfig { allow, deny, warn, forbid };
-            get_clippy_rules_in_order(&args, &cfg)
+            let args_vec: Vec<String> = args.iter().map(|s| s.to_string()).collect();
+            get_clippy_rules_in_order(&args_vec, &cfg)
         }
         _ => panic!("invalid subcommand"),
     };
@@ -331,7 +330,10 @@ fn verbose_tests_default_value() {
 
 #[test]
 fn parse_rust_std_features() {
-    let config = parse("rust.std-features = [\"panic-unwind\", \"backtrace\"]");
+    let config = TestCtx::new()
+        .config("check")
+        .config_toml("rust.std-features = [\"panic-unwind\", \"backtrace\"]")
+        .create_config();
     let expected_features: BTreeSet<String> =
         ["panic-unwind", "backtrace"].into_iter().map(|s| s.to_string()).collect();
     assert_eq!(config.rust_std_features, expected_features);
@@ -339,7 +341,8 @@ fn parse_rust_std_features() {
 
 #[test]
 fn parse_rust_std_features_empty() {
-    let config = parse("rust.std-features = []");
+    let config =
+        TestCtx::new().config("check").config_toml("rust.std-features = []").create_config();
     let expected_features: BTreeSet<String> = BTreeSet::new();
     assert_eq!(config.rust_std_features, expected_features);
 }
@@ -347,70 +350,58 @@ fn parse_rust_std_features_empty() {
 #[test]
 #[should_panic]
 fn parse_rust_std_features_invalid() {
-    parse("rust.std-features = \"backtrace\"");
+    TestCtx::new().config("check").config_toml("rust.std-features = \"backtrace\"").create_config();
 }
 
 #[test]
 fn parse_jobs() {
-    assert_eq!(parse("build.jobs = 1").jobs, Some(1));
+    assert_eq!(
+        TestCtx::new().config("check").config_toml("build.jobs = 1").create_config().jobs,
+        Some(1)
+    );
 }
 
 #[test]
 fn jobs_precedence() {
     // `--jobs` should take precedence over using `--set build.jobs`.
 
-    let config = Config::parse_inner(
-        Flags::parse(&[
-            "check".to_owned(),
-            "--config=/does/not/exist".to_owned(),
-            "--jobs=67890".to_owned(),
-            "--set=build.jobs=12345".to_owned(),
-        ]),
-        |&_| toml::from_str(""),
-    );
+    let config = TestCtx::new()
+        .config("check")
+        .args(&["--jobs=67890", "--set=build.jobs=12345"])
+        .create_config();
     assert_eq!(config.jobs, Some(67890));
 
     // `--set build.jobs` should take precedence over `bootstrap.toml`.
-    let config = Config::parse_inner(
-        Flags::parse(&[
-            "check".to_owned(),
-            "--config=/does/not/exist".to_owned(),
-            "--set=build.jobs=12345".to_owned(),
-        ]),
-        |&_| {
-            toml::from_str(
-                r#"
-            [build]
-            jobs = 67890
-        "#,
-            )
-        },
-    );
+    let config = TestCtx::new()
+        .config("check")
+        .args(&["--set=build.jobs=12345"])
+        .config_toml(
+            r#"
+        [build]
+        jobs = 67890
+    "#,
+        )
+        .create_config();
+
     assert_eq!(config.jobs, Some(12345));
 
     // `--jobs` > `--set build.jobs` > `bootstrap.toml`
-    let config = Config::parse_inner(
-        Flags::parse(&[
-            "check".to_owned(),
-            "--jobs=123".to_owned(),
-            "--config=/does/not/exist".to_owned(),
-            "--set=build.jobs=456".to_owned(),
-        ]),
-        |&_| {
-            toml::from_str(
-                r#"
-            [build]
-            jobs = 789
-        "#,
-            )
-        },
-    );
+    let config = TestCtx::new()
+        .config("check")
+        .args(&["--jobs=123", "--set=build.jobs=456"])
+        .config_toml(
+            r#"
+        [build]
+        jobs = 789
+    "#,
+        )
+        .create_config();
     assert_eq!(config.jobs, Some(123));
 }
 
 #[test]
 fn check_rustc_if_unchanged_paths() {
-    let config = parse("");
+    let config = TestCtx::new().config("check").create_config();
     let normalised_allowed_paths: Vec<_> = RUSTC_IF_UNCHANGED_ALLOWED_PATHS
         .iter()
         .map(|t| {
@@ -425,59 +416,42 @@ fn check_rustc_if_unchanged_paths() {
 
 #[test]
 fn test_explicit_stage() {
-    let config = Config::parse_inner(
-        Flags::parse(&["check".to_owned(), "--config=/does/not/exist".to_owned()]),
-        |&_| {
-            toml::from_str(
-                r#"
+    let config = TestCtx::new()
+        .config("check")
+        .config_toml(
+            r#"
             [build]
             test-stage = 1
         "#,
-            )
-        },
-    );
+        )
+        .create_config();
 
     assert!(!config.explicit_stage_from_cli);
     assert!(config.explicit_stage_from_config);
     assert!(config.is_explicit_stage());
 
-    let config = Config::parse_inner(
-        Flags::parse(&[
-            "check".to_owned(),
-            "--stage=2".to_owned(),
-            "--config=/does/not/exist".to_owned(),
-        ]),
-        |&_| toml::from_str(""),
-    );
+    let config = TestCtx::new().config("check").stage(2).create_config();
 
     assert!(config.explicit_stage_from_cli);
     assert!(!config.explicit_stage_from_config);
     assert!(config.is_explicit_stage());
 
-    let config = Config::parse_inner(
-        Flags::parse(&[
-            "check".to_owned(),
-            "--stage=2".to_owned(),
-            "--config=/does/not/exist".to_owned(),
-        ]),
-        |&_| {
-            toml::from_str(
-                r#"
+    let config = TestCtx::new()
+        .config("check")
+        .stage(2)
+        .config_toml(
+            r#"
             [build]
             test-stage = 1
         "#,
-            )
-        },
-    );
+        )
+        .create_config();
 
     assert!(config.explicit_stage_from_cli);
     assert!(config.explicit_stage_from_config);
     assert!(config.is_explicit_stage());
 
-    let config = Config::parse_inner(
-        Flags::parse(&["check".to_owned(), "--config=/does/not/exist".to_owned()]),
-        |&_| toml::from_str(""),
-    );
+    let config = TestCtx::new().config("check").create_config();
 
     assert!(!config.explicit_stage_from_cli);
     assert!(!config.explicit_stage_from_config);
@@ -487,7 +461,10 @@ fn test_explicit_stage() {
 #[test]
 fn test_exclude() {
     let exclude_path = "compiler";
-    let config = parse(&format!("build.exclude=[\"{}\"]", exclude_path));
+    let config = TestCtx::new()
+        .config("check")
+        .config_toml(&format!("build.exclude=[\"{}\"]", exclude_path))
+        .create_config();
 
     let first_excluded = config
         .skip
@@ -501,17 +478,13 @@ fn test_exclude() {
 
 #[test]
 fn test_ci_flag() {
-    let config = Config::parse_inner(Flags::parse(&["check".into(), "--ci=false".into()]), |&_| {
-        toml::from_str("")
-    });
+    let config = TestCtx::new().config("check").arg("--ci").arg("false").create_config();
     assert!(!config.is_running_on_ci);
 
-    let config = Config::parse_inner(Flags::parse(&["check".into(), "--ci=true".into()]), |&_| {
-        toml::from_str("")
-    });
+    let config = TestCtx::new().config("check").arg("--ci").arg("true").create_config();
     assert!(config.is_running_on_ci);
 
-    let config = Config::parse_inner(Flags::parse(&["check".into()]), |&_| toml::from_str(""));
+    let config = TestCtx::new().config("check").create_config();
     assert_eq!(config.is_running_on_ci, CiEnv::is_ci());
 }
 
diff --git a/src/bootstrap/src/utils/helpers/tests.rs b/src/bootstrap/src/utils/helpers/tests.rs
index e586fe77b4f62..ec99743d1ed88 100644
--- a/src/bootstrap/src/utils/helpers/tests.rs
+++ b/src/bootstrap/src/utils/helpers/tests.rs
@@ -60,8 +60,7 @@ fn test_check_cfg_arg() {
 
 #[test]
 fn test_symlink_dir() {
-    let config =
-        Config::parse(Flags::parse(&["check".to_owned(), "--config=/does/not/exist".to_owned()]));
+    let config = TestCtx::new().config("check").create_config();
     let tempdir = config.tempdir().join(".tmp-dir");
     let link_path = config.tempdir().join(".tmp-link");
 
@@ -102,9 +101,7 @@ fn test_set_file_times_sanity_check() {
 
 #[test]
 fn test_submodule_path_of() {
-    let config = Config::parse_inner(Flags::parse(&["build".into(), "--dry-run".into()]), |&_| {
-        Ok(Default::default())
-    });
+    let config = TestCtx::new().config("build").create_config();
 
     let build = crate::Build::new(config.clone());
     let builder = crate::core::builder::Builder::new(&build);

From a29474d3ff06660071ebb5f071a7cdce0ee07646 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Tue, 16 Sep 2025 21:20:14 +0530
Subject: [PATCH 1216/1889] this is dicy, whether we have a method to
 explicitly enable_llvm_override

---
 src/bootstrap/src/utils/tests/mod.rs | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/src/bootstrap/src/utils/tests/mod.rs b/src/bootstrap/src/utils/tests/mod.rs
index ff84bfdb4cde3..d47a224d7af51 100644
--- a/src/bootstrap/src/utils/tests/mod.rs
+++ b/src/bootstrap/src/utils/tests/mod.rs
@@ -125,4 +125,19 @@ impl ConfigBuilder {
 
         Config::parse(Flags::parse(&self.args))
     }
+
+    pub fn create_config_without_ci_llvm_override(mut self) -> Config {
+        // Run in dry-check, otherwise the test would be too slow
+        self.args.push("--dry-run".to_string());
+
+        // Ignore submodules
+        self.args.push("--set".to_string());
+        self.args.push("build.submodules=false".to_string());
+
+        // Do not mess with the local rustc checkout build directory
+        self.args.push("--build-dir".to_string());
+        self.args.push(self.directory.join("build").display().to_string());
+
+        Config::parse(Flags::parse(&self.args))
+    }
 }

From 0c68c82957e86c15d4a543c0d32f9e101ce74ba9 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Sun, 21 Sep 2025 18:16:47 +0530
Subject: [PATCH 1217/1889] rename config_toml to with_default_toml_config

---
 src/bootstrap/src/core/builder/tests.rs |  2 +-
 src/bootstrap/src/core/config/tests.rs  | 47 ++++++++++++++++---------
 src/bootstrap/src/utils/tests/mod.rs    |  2 +-
 3 files changed, 33 insertions(+), 18 deletions(-)

diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index a3cb4660ffc51..7033098b79bff 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -357,7 +357,7 @@ fn test_test_coverage() {
 #[test]
 fn test_prebuilt_llvm_config_path_resolution() {
     fn configure(config: &str) -> Config {
-        TestCtx::new().config("build").config_toml(config).create_config()
+        TestCtx::new().config("build").with_default_toml_config(config).create_config()
     }
 
     // Removes Windows disk prefix if present
diff --git a/src/bootstrap/src/core/config/tests.rs b/src/bootstrap/src/core/config/tests.rs
index 68859c6545e10..30b4c6cfc4317 100644
--- a/src/bootstrap/src/core/config/tests.rs
+++ b/src/bootstrap/src/core/config/tests.rs
@@ -22,7 +22,7 @@ use crate::utils::tests::TestCtx;
 use crate::utils::tests::git::git_test;
 
 pub(crate) fn parse(config: &str) -> Config {
-    TestCtx::new().config("check").config_toml(config).create_config()
+    TestCtx::new().config("check").with_default_toml_config(config).create_config()
 }
 
 fn get_toml(file: &Path) -> Result<TomlConfig, toml::de::Error> {
@@ -58,7 +58,7 @@ fn download_ci_llvm() {
     // this doesn't make sense, as we are overriding it later.
     let if_unchanged_config = TestCtx::new()
         .config("check")
-        .config_toml("llvm.download-ci-llvm = \"if-unchanged\"")
+        .with_default_toml_config("llvm.download-ci-llvm = \"if-unchanged\"")
         .create_config();
     if if_unchanged_config.llvm_from_ci && if_unchanged_config.is_running_on_ci {
         let has_changes = if_unchanged_config.has_changes_from_upstream(LLVM_INVALIDATION_PATHS);
@@ -119,8 +119,11 @@ fn override_toml() {
         "--set=target.aarch64-apple-darwin.optimized-compiler-builtins=false",
     ];
 
-    let config =
-        TestCtx::new().config("check").config_toml(config_toml).args(&args).create_config();
+    let config = TestCtx::new()
+        .config("check")
+        .with_default_toml_config(config_toml)
+        .args(&args)
+        .create_config();
 
     assert_eq!(config.change_id, Some(ChangeId::Id(1)), "setting top-level value");
     assert_eq!(
@@ -182,7 +185,7 @@ fn override_toml() {
 fn override_toml_duplicate() {
     TestCtx::new()
         .config("check")
-        .config_toml("change-id = 0")
+        .with_default_toml_config("change-id = 0")
         .arg("--set")
         .arg("change-id=1")
         .arg("--set")
@@ -223,7 +226,10 @@ fn rust_optimize() {
 #[test]
 #[should_panic]
 fn invalid_rust_optimize() {
-    TestCtx::new().config("check").config_toml("rust.optimize = \"a\"").create_config();
+    TestCtx::new()
+        .config("check")
+        .with_default_toml_config("rust.optimize = \"a\"")
+        .create_config();
 }
 
 #[test]
@@ -332,7 +338,7 @@ fn verbose_tests_default_value() {
 fn parse_rust_std_features() {
     let config = TestCtx::new()
         .config("check")
-        .config_toml("rust.std-features = [\"panic-unwind\", \"backtrace\"]")
+        .with_default_toml_config("rust.std-features = [\"panic-unwind\", \"backtrace\"]")
         .create_config();
     let expected_features: BTreeSet<String> =
         ["panic-unwind", "backtrace"].into_iter().map(|s| s.to_string()).collect();
@@ -341,8 +347,10 @@ fn parse_rust_std_features() {
 
 #[test]
 fn parse_rust_std_features_empty() {
-    let config =
-        TestCtx::new().config("check").config_toml("rust.std-features = []").create_config();
+    let config = TestCtx::new()
+        .config("check")
+        .with_default_toml_config("rust.std-features = []")
+        .create_config();
     let expected_features: BTreeSet<String> = BTreeSet::new();
     assert_eq!(config.rust_std_features, expected_features);
 }
@@ -350,13 +358,20 @@ fn parse_rust_std_features_empty() {
 #[test]
 #[should_panic]
 fn parse_rust_std_features_invalid() {
-    TestCtx::new().config("check").config_toml("rust.std-features = \"backtrace\"").create_config();
+    TestCtx::new()
+        .config("check")
+        .with_default_toml_config("rust.std-features = \"backtrace\"")
+        .create_config();
 }
 
 #[test]
 fn parse_jobs() {
     assert_eq!(
-        TestCtx::new().config("check").config_toml("build.jobs = 1").create_config().jobs,
+        TestCtx::new()
+            .config("check")
+            .with_default_toml_config("build.jobs = 1")
+            .create_config()
+            .jobs,
         Some(1)
     );
 }
@@ -375,7 +390,7 @@ fn jobs_precedence() {
     let config = TestCtx::new()
         .config("check")
         .args(&["--set=build.jobs=12345"])
-        .config_toml(
+        .with_default_toml_config(
             r#"
         [build]
         jobs = 67890
@@ -389,7 +404,7 @@ fn jobs_precedence() {
     let config = TestCtx::new()
         .config("check")
         .args(&["--jobs=123", "--set=build.jobs=456"])
-        .config_toml(
+        .with_default_toml_config(
             r#"
         [build]
         jobs = 789
@@ -418,7 +433,7 @@ fn check_rustc_if_unchanged_paths() {
 fn test_explicit_stage() {
     let config = TestCtx::new()
         .config("check")
-        .config_toml(
+        .with_default_toml_config(
             r#"
             [build]
             test-stage = 1
@@ -439,7 +454,7 @@ fn test_explicit_stage() {
     let config = TestCtx::new()
         .config("check")
         .stage(2)
-        .config_toml(
+        .with_default_toml_config(
             r#"
             [build]
             test-stage = 1
@@ -463,7 +478,7 @@ fn test_exclude() {
     let exclude_path = "compiler";
     let config = TestCtx::new()
         .config("check")
-        .config_toml(&format!("build.exclude=[\"{}\"]", exclude_path))
+        .with_default_toml_config(&format!("build.exclude=[\"{}\"]", exclude_path))
         .create_config();
 
     let first_excluded = config
diff --git a/src/bootstrap/src/utils/tests/mod.rs b/src/bootstrap/src/utils/tests/mod.rs
index d47a224d7af51..80df15939b057 100644
--- a/src/bootstrap/src/utils/tests/mod.rs
+++ b/src/bootstrap/src/utils/tests/mod.rs
@@ -98,7 +98,7 @@ impl ConfigBuilder {
         self
     }
 
-    pub fn config_toml(mut self, config_toml: &str) -> Self {
+    pub fn with_default_toml_config(mut self, config_toml: &str) -> Self {
         let toml_path = self.directory.join("bootstrap.toml");
         std::fs::write(&toml_path, config_toml).unwrap();
         self.args.push("--config".to_string());

From 9189bf79d43dd162858bc58d64c6c99da7ca0add Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Sun, 21 Sep 2025 18:32:20 +0530
Subject: [PATCH 1218/1889] remove create_config_without_ci_llvm_override
 duplication

---
 src/bootstrap/src/core/builder/tests.rs |  3 +-
 src/bootstrap/src/utils/tests/mod.rs    | 37 ++++++++++++-------------
 2 files changed, 19 insertions(+), 21 deletions(-)

diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index 7033098b79bff..0bb22eccd1936 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -227,7 +227,8 @@ fn parse_config_download_rustc_at(path: &Path, download_rustc: &str, ci: bool) -
             "--src",
             path.to_str().unwrap(),
         ])
-        .create_config_without_ci_llvm_override()
+        .no_override_download_ci_llvm()
+        .create_config()
 }
 
 mod dist {
diff --git a/src/bootstrap/src/utils/tests/mod.rs b/src/bootstrap/src/utils/tests/mod.rs
index 80df15939b057..0ccc8e1ebb8f4 100644
--- a/src/bootstrap/src/utils/tests/mod.rs
+++ b/src/bootstrap/src/utils/tests/mod.rs
@@ -48,11 +48,16 @@ impl TestCtx {
 pub struct ConfigBuilder {
     args: Vec<String>,
     directory: PathBuf,
+    override_download_ci_llvm: bool,
 }
 
 impl ConfigBuilder {
     fn from_args(args: &[&str], directory: PathBuf) -> Self {
-        Self { args: args.iter().copied().map(String::from).collect(), directory }
+        Self {
+            args: args.iter().copied().map(String::from).collect(),
+            directory,
+            override_download_ci_llvm: true,
+        }
     }
 
     pub fn path(mut self, path: &str) -> Self {
@@ -106,27 +111,12 @@ impl ConfigBuilder {
         self
     }
 
-    pub fn create_config(mut self) -> Config {
-        // Run in dry-check, otherwise the test would be too slow
-        self.args.push("--dry-run".to_string());
-
-        // Ignore submodules
-        self.args.push("--set".to_string());
-        self.args.push("build.submodules=false".to_string());
-
-        // Override any external LLVM set and inhibit CI LLVM; pretend that we're always building
-        // in-tree LLVM from sources.
-        self.args.push("--set".to_string());
-        self.args.push("llvm.download-ci-llvm=false".to_string());
-
-        // Do not mess with the local rustc checkout build directory
-        self.args.push("--build-dir".to_string());
-        self.args.push(self.directory.join("build").display().to_string());
-
-        Config::parse(Flags::parse(&self.args))
+    pub fn no_override_download_ci_llvm(mut self) -> Self {
+        self.override_download_ci_llvm = false;
+        self
     }
 
-    pub fn create_config_without_ci_llvm_override(mut self) -> Config {
+    pub fn create_config(mut self) -> Config {
         // Run in dry-check, otherwise the test would be too slow
         self.args.push("--dry-run".to_string());
 
@@ -134,6 +124,13 @@ impl ConfigBuilder {
         self.args.push("--set".to_string());
         self.args.push("build.submodules=false".to_string());
 
+        if self.override_download_ci_llvm {
+            // Override any external LLVM set and inhibit CI LLVM; pretend that we're always building
+            // in-tree LLVM from sources.
+            self.args.push("--set".to_string());
+            self.args.push("llvm.download-ci-llvm=false".to_string());
+        }
+
         // Do not mess with the local rustc checkout build directory
         self.args.push("--build-dir".to_string());
         self.args.push(self.directory.join("build").display().to_string());

From 671aabd4eb1a56a09b989abc021bee32750ee59b Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Sun, 21 Sep 2025 19:34:49 +0530
Subject: [PATCH 1219/1889] add dry_run flag in config builder and remove
 runtime test hacks

---
 src/bootstrap/src/core/config/tests.rs   |  2 +-
 src/bootstrap/src/core/download.rs       |  2 +-
 src/bootstrap/src/utils/helpers.rs       |  2 +-
 src/bootstrap/src/utils/helpers/tests.rs |  2 +-
 src/bootstrap/src/utils/tests/mod.rs     | 14 +++++++++++---
 5 files changed, 15 insertions(+), 7 deletions(-)

diff --git a/src/bootstrap/src/core/config/tests.rs b/src/bootstrap/src/core/config/tests.rs
index 30b4c6cfc4317..a7429e07d858c 100644
--- a/src/bootstrap/src/core/config/tests.rs
+++ b/src/bootstrap/src/core/config/tests.rs
@@ -234,7 +234,7 @@ fn invalid_rust_optimize() {
 
 #[test]
 fn verify_file_integrity() {
-    let config = TestCtx::new().config("check").create_config();
+    let config = TestCtx::new().config("check").no_dry_run().create_config();
 
     let tempfile = config.tempdir().join(".tmp-test-file");
     File::create(&tempfile).unwrap().write_all(b"dummy value").unwrap();
diff --git a/src/bootstrap/src/core/download.rs b/src/bootstrap/src/core/download.rs
index ce3f49a35b9e6..2f3c80559c0ef 100644
--- a/src/bootstrap/src/core/download.rs
+++ b/src/bootstrap/src/core/download.rs
@@ -857,7 +857,7 @@ pub(crate) fn verify(exec_ctx: &ExecutionContext, path: &Path, expected: &str) -
         println!("verifying {}", path.display());
     });
 
-    if exec_ctx.dry_run() && !cfg!(test) {
+    if exec_ctx.dry_run() {
         return false;
     }
 
diff --git a/src/bootstrap/src/utils/helpers.rs b/src/bootstrap/src/utils/helpers.rs
index 0561f343a8c19..e802c0214ddcb 100644
--- a/src/bootstrap/src/utils/helpers.rs
+++ b/src/bootstrap/src/utils/helpers.rs
@@ -160,7 +160,7 @@ impl Drop for TimeIt {
 /// Symlinks two directories, using junctions on Windows and normal symlinks on
 /// Unix.
 pub fn symlink_dir(config: &Config, original: &Path, link: &Path) -> io::Result<()> {
-    if config.dry_run() && !cfg!(test) {
+    if config.dry_run() {
         return Ok(());
     }
     let _ = fs::remove_dir_all(link);
diff --git a/src/bootstrap/src/utils/helpers/tests.rs b/src/bootstrap/src/utils/helpers/tests.rs
index ec99743d1ed88..676fe6cbd5fe5 100644
--- a/src/bootstrap/src/utils/helpers/tests.rs
+++ b/src/bootstrap/src/utils/helpers/tests.rs
@@ -60,7 +60,7 @@ fn test_check_cfg_arg() {
 
 #[test]
 fn test_symlink_dir() {
-    let config = TestCtx::new().config("check").create_config();
+    let config = TestCtx::new().config("check").no_dry_run().create_config();
     let tempdir = config.tempdir().join(".tmp-dir");
     let link_path = config.tempdir().join(".tmp-link");
 
diff --git a/src/bootstrap/src/utils/tests/mod.rs b/src/bootstrap/src/utils/tests/mod.rs
index 0ccc8e1ebb8f4..dc905969dcac1 100644
--- a/src/bootstrap/src/utils/tests/mod.rs
+++ b/src/bootstrap/src/utils/tests/mod.rs
@@ -49,6 +49,7 @@ pub struct ConfigBuilder {
     args: Vec<String>,
     directory: PathBuf,
     override_download_ci_llvm: bool,
+    dry_run: bool,
 }
 
 impl ConfigBuilder {
@@ -57,6 +58,7 @@ impl ConfigBuilder {
             args: args.iter().copied().map(String::from).collect(),
             directory,
             override_download_ci_llvm: true,
+            dry_run: true,
         }
     }
 
@@ -116,10 +118,16 @@ impl ConfigBuilder {
         self
     }
 
-    pub fn create_config(mut self) -> Config {
-        // Run in dry-check, otherwise the test would be too slow
-        self.args.push("--dry-run".to_string());
+    pub fn no_dry_run(mut self) -> Self {
+        self.dry_run = false;
+        self
+    }
 
+    pub fn create_config(mut self) -> Config {
+        if self.dry_run {
+            // Run in dry-check, otherwise the test would be too slow
+            self.args.push("--dry-run".to_string());
+        }
         // Ignore submodules
         self.args.push("--set".to_string());
         self.args.push("build.submodules=false".to_string());

From afe380dd58170b55b100a659f05017b1149d0ec9 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Sun, 21 Sep 2025 19:43:43 +0530
Subject: [PATCH 1220/1889] initialize out with CARGO_TARGET_DIR and then go
 for manifest and then for current

---
 src/bootstrap/src/core/config/config.rs | 27 +++++++++++++++++--------
 1 file changed, 19 insertions(+), 8 deletions(-)

diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index 003cf3f2f9c3e..1f3b90d324fb1 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -630,9 +630,13 @@ impl Config {
         let llvm_assertions = llvm_assertions.unwrap_or(false);
         let mut target_config = HashMap::new();
         let mut channel = "dev".to_string();
-        let out = flags_build_dir
-            .or(build_build_dir.map(PathBuf::from))
-            .unwrap_or_else(|| PathBuf::from("build"));
+        let out = if cfg!(test) {
+            test_build_dir()
+        } else {
+            flags_build_dir
+                .or_else(|| build_build_dir.map(PathBuf::from))
+                .unwrap_or_else(|| PathBuf::from("build"))
+        };
 
         // NOTE: Bootstrap spawns various commands with different working directories.
         // To avoid writing to random places on the file system, `config.out` needs to be an absolute path.
@@ -683,11 +687,6 @@ impl Config {
         };
 
         let initial_rustc = build_rustc.unwrap_or_else(|| {
-            let out = if cfg!(test) {
-                std::env::current_dir().unwrap().ancestors().nth(2).unwrap().join("build")
-            } else {
-                out.clone()
-            };
             download_beta_toolchain(&dwn_ctx, &out);
             let target = if cfg!(test) { get_host_target() } else { host_target };
 
@@ -2481,3 +2480,15 @@ fn find_correct_section_for_field(field_name: &str) -> Vec<WouldBeValidFor> {
         })
         .collect()
 }
+
+fn test_build_dir() -> PathBuf {
+    env::var_os("CARGO_TARGET_DIR")
+        .map(|value| Path::new(&value).parent().unwrap().to_path_buf())
+        .unwrap_or_else(|| {
+            let base = option_env!("CARGO_MANIFEST_DIR")
+                .map(PathBuf::from)
+                .unwrap_or_else(|| std::env::current_dir().expect("failed to get current dir"));
+
+            base.ancestors().nth(2).unwrap_or_else(|| Path::new(".")).join("build")
+        })
+}

From a48cd767f634ec7461b8367e5d301a2985cfce7d Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Sun, 21 Sep 2025 20:03:15 +0530
Subject: [PATCH 1221/1889] add explicit config assignment when running the
 test, as the src is assigned to CARGO_MANIFEST_DIR, so the config actually
 use the <src>/bootstrap.toml and the /tmp/bootstrap.toml

---
 src/bootstrap/src/utils/tests/mod.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/bootstrap/src/utils/tests/mod.rs b/src/bootstrap/src/utils/tests/mod.rs
index dc905969dcac1..764b89086cf2f 100644
--- a/src/bootstrap/src/utils/tests/mod.rs
+++ b/src/bootstrap/src/utils/tests/mod.rs
@@ -50,6 +50,7 @@ pub struct ConfigBuilder {
     directory: PathBuf,
     override_download_ci_llvm: bool,
     dry_run: bool,
+    explicit_config: bool,
 }
 
 impl ConfigBuilder {
@@ -59,6 +60,7 @@ impl ConfigBuilder {
             directory,
             override_download_ci_llvm: true,
             dry_run: true,
+            explicit_config: true,
         }
     }
 
@@ -108,6 +110,7 @@ impl ConfigBuilder {
     pub fn with_default_toml_config(mut self, config_toml: &str) -> Self {
         let toml_path = self.directory.join("bootstrap.toml");
         std::fs::write(&toml_path, config_toml).unwrap();
+        self.explicit_config = false;
         self.args.push("--config".to_string());
         self.args.push(toml_path.display().to_string());
         self
@@ -139,6 +142,12 @@ impl ConfigBuilder {
             self.args.push("llvm.download-ci-llvm=false".to_string());
         }
 
+        // always use the bootstrap toml created in the
+        // temporary directory and not from the <src>
+        if self.explicit_config {
+            self = self.with_default_toml_config("");
+        }
+
         // Do not mess with the local rustc checkout build directory
         self.args.push("--build-dir".to_string());
         self.args.push(self.directory.join("build").display().to_string());

From 33e262e8cc5ec07e0d3312be2d2c2ae3404f5fbd Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Sun, 21 Sep 2025 20:52:26 +0530
Subject: [PATCH 1222/1889] remove prepare_test_specific_dir and update tests
 accordingly

---
 src/bootstrap/src/core/config/tests.rs | 154 +++++++++++--------------
 1 file changed, 65 insertions(+), 89 deletions(-)

diff --git a/src/bootstrap/src/core/config/tests.rs b/src/bootstrap/src/core/config/tests.rs
index a7429e07d858c..f277e3704f277 100644
--- a/src/bootstrap/src/core/config/tests.rs
+++ b/src/bootstrap/src/core/config/tests.rs
@@ -30,26 +30,6 @@ fn get_toml(file: &Path) -> Result<TomlConfig, toml::de::Error> {
     toml::from_str(&contents).and_then(|table: toml::Value| TomlConfig::deserialize(table))
 }
 
-/// Helps with debugging by using consistent test-specific directories instead of
-/// random temporary directories.
-fn prepare_test_specific_dir() -> PathBuf {
-    let current = std::thread::current();
-    // Replace "::" with "_" to make it safe for directory names on Windows systems
-    let test_path = current.name().unwrap().replace("::", "_");
-
-    let testdir = crate::utils::tests::TestCtx::new()
-        .config("check")
-        .create_config()
-        .tempdir()
-        .join(test_path);
-
-    // clean up any old test files
-    let _ = fs::remove_dir_all(&testdir);
-    let _ = fs::create_dir_all(&testdir);
-
-    testdir
-}
-
 #[test]
 fn download_ci_llvm() {
     let config = TestCtx::new().config("check").create_config();
@@ -505,16 +485,8 @@ fn test_ci_flag() {
 
 #[test]
 fn test_precedence_of_includes() {
-    let testdir = prepare_test_specific_dir();
-
-    let root_config = testdir.join("config.toml");
-    let root_config_content = br#"
-        include = ["./extension.toml"]
-
-        [llvm]
-        link-jobs = 2
-    "#;
-    File::create(&root_config).unwrap().write_all(root_config_content).unwrap();
+    let test_ctx = TestCtx::new();
+    let testdir = test_ctx.dir();
 
     let extension = testdir.join("extension.toml");
     let extension_content = br#"
@@ -535,10 +507,17 @@ fn test_precedence_of_includes() {
     "#;
     File::create(extension).unwrap().write_all(extension_content).unwrap();
 
-    let config = Config::parse_inner(
-        Flags::parse(&["check".to_owned(), format!("--config={}", root_config.to_str().unwrap())]),
-        get_toml,
-    );
+    let config = test_ctx
+        .config("check")
+        .with_default_toml_config(
+            r#"
+        include = ["./extension.toml"]
+
+        [llvm]
+        link-jobs = 2
+    "#,
+        )
+        .create_config();
 
     assert_eq!(config.change_id.unwrap(), ChangeId::Id(543));
     assert_eq!(config.llvm_link_jobs.unwrap(), 2);
@@ -548,36 +527,29 @@ fn test_precedence_of_includes() {
 #[test]
 #[should_panic(expected = "Cyclic inclusion detected")]
 fn test_cyclic_include_direct() {
-    let testdir = prepare_test_specific_dir();
-
-    let root_config = testdir.join("config.toml");
-    let root_config_content = br#"
-        include = ["./extension.toml"]
-    "#;
-    File::create(&root_config).unwrap().write_all(root_config_content).unwrap();
-
+    let test_ctx = TestCtx::new();
+    let testdir = test_ctx.dir();
     let extension = testdir.join("extension.toml");
     let extension_content = br#"
-        include = ["./config.toml"]
+        include = ["./bootstrap.toml"]
     "#;
     File::create(extension).unwrap().write_all(extension_content).unwrap();
 
-    let config = Config::parse_inner(
-        Flags::parse(&["check".to_owned(), format!("--config={}", root_config.to_str().unwrap())]),
-        get_toml,
-    );
+    test_ctx
+        .config("check")
+        .with_default_toml_config(
+            r#"
+        include = ["./extension.toml"]
+    "#,
+        )
+        .create_config();
 }
 
 #[test]
 #[should_panic(expected = "Cyclic inclusion detected")]
 fn test_cyclic_include_indirect() {
-    let testdir = prepare_test_specific_dir();
-
-    let root_config = testdir.join("config.toml");
-    let root_config_content = br#"
-        include = ["./extension.toml"]
-    "#;
-    File::create(&root_config).unwrap().write_all(root_config_content).unwrap();
+    let test_ctx = TestCtx::new();
+    let testdir = test_ctx.dir();
 
     let extension = testdir.join("extension.toml");
     let extension_content = br#"
@@ -597,43 +569,37 @@ fn test_cyclic_include_indirect() {
     "#;
     File::create(extension).unwrap().write_all(extension_content).unwrap();
 
-    let config = Config::parse_inner(
-        Flags::parse(&["check".to_owned(), format!("--config={}", root_config.to_str().unwrap())]),
-        get_toml,
-    );
+    test_ctx
+        .config("check")
+        .with_default_toml_config(
+            r#"
+        include = ["./extension.toml"]
+    "#,
+        )
+        .create_config();
 }
 
 #[test]
 fn test_include_absolute_paths() {
-    let testdir = prepare_test_specific_dir();
+    let test_ctx = TestCtx::new();
+    let testdir = test_ctx.dir();
 
     let extension = testdir.join("extension.toml");
     File::create(&extension).unwrap().write_all(&[]).unwrap();
 
-    let root_config = testdir.join("config.toml");
     let extension_absolute_path =
         extension.canonicalize().unwrap().to_str().unwrap().replace('\\', r"\\");
     let root_config_content = format!(r#"include = ["{}"]"#, extension_absolute_path);
-    File::create(&root_config).unwrap().write_all(root_config_content.as_bytes()).unwrap();
-
-    let config = Config::parse_inner(
-        Flags::parse(&["check".to_owned(), format!("--config={}", root_config.to_str().unwrap())]),
-        get_toml,
-    );
+    test_ctx.config("check").with_default_toml_config(&root_config_content).create_config();
 }
 
 #[test]
 fn test_include_relative_paths() {
-    let testdir = prepare_test_specific_dir();
+    let test_ctx = TestCtx::new();
+    let testdir = test_ctx.dir();
 
     let _ = fs::create_dir_all(&testdir.join("subdir/another_subdir"));
 
-    let root_config = testdir.join("config.toml");
-    let root_config_content = br#"
-        include = ["./subdir/extension.toml"]
-    "#;
-    File::create(&root_config).unwrap().write_all(root_config_content).unwrap();
-
     let extension = testdir.join("subdir/extension.toml");
     let extension_content = br#"
         include = ["../extension2.toml"]
@@ -655,22 +621,20 @@ fn test_include_relative_paths() {
     let extension = testdir.join("extension4.toml");
     File::create(extension).unwrap().write_all(&[]).unwrap();
 
-    let config = Config::parse_inner(
-        Flags::parse(&["check".to_owned(), format!("--config={}", root_config.to_str().unwrap())]),
-        get_toml,
-    );
+    test_ctx
+        .config("check")
+        .with_default_toml_config(
+            r#"
+        include = ["./subdir/extension.toml"]
+    "#,
+        )
+        .create_config();
 }
 
 #[test]
 fn test_include_precedence_over_profile() {
-    let testdir = prepare_test_specific_dir();
-
-    let root_config = testdir.join("config.toml");
-    let root_config_content = br#"
-        profile = "dist"
-        include = ["./extension.toml"]
-    "#;
-    File::create(&root_config).unwrap().write_all(root_config_content).unwrap();
+    let test_ctx = TestCtx::new();
+    let testdir = test_ctx.dir();
 
     let extension = testdir.join("extension.toml");
     let extension_content = br#"
@@ -679,10 +643,22 @@ fn test_include_precedence_over_profile() {
     "#;
     File::create(extension).unwrap().write_all(extension_content).unwrap();
 
-    let config = Config::parse_inner(
-        Flags::parse(&["check".to_owned(), format!("--config={}", root_config.to_str().unwrap())]),
-        get_toml,
-    );
+    let root_config = testdir.join("config.toml");
+    let root_config_content = br#"
+        profile = "dist"
+        include = ["./extension.toml"]
+    "#;
+    File::create(&root_config).unwrap().write_all(root_config_content).unwrap();
+
+    let config = test_ctx
+        .config("check")
+        .with_default_toml_config(
+            r#"
+        profile = "dist"
+        include = ["./extension.toml"]
+    "#,
+        )
+        .create_config();
 
     // "dist" profile would normally set the channel to "auto-detect", but includes should
     // override profile settings, so we expect this to be "dev" here.

From d887c570a0688bed2c5c8995f35cfdad5980cc54 Mon Sep 17 00:00:00 2001
From: Sidney Cammeresi <sac@cheesecake.org>
Date: Sun, 21 Sep 2025 09:30:18 -0700
Subject: [PATCH 1223/1889] Correct a misspelling of RUSTC_LOG

---
 src/doc/rustc-dev-guide/src/tracing.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/src/tracing.md b/src/doc/rustc-dev-guide/src/tracing.md
index 5e5b81fc65b22..a7cdab73e7973 100644
--- a/src/doc/rustc-dev-guide/src/tracing.md
+++ b/src/doc/rustc-dev-guide/src/tracing.md
@@ -109,7 +109,7 @@ Miri, use `MIRI_LOG` instead. You get the idea :)
 
 See the [`tracing`] crate's docs, and specifically the docs for [`debug!`] to
 see the full syntax you can use. (Note: unlike the compiler, the [`tracing`]
-crate and its examples use the `RUST_LOG` environment variable. rustc, rustdoc,
+crate and its examples use the `RUSTC_LOG` environment variable. rustc, rustdoc,
 and other tools set custom environment variables.)
 
 **Note that unless you use a very strict filter, the logger will emit a lot of

From e99e226748d3438d40a11ff556820375a762c8e1 Mon Sep 17 00:00:00 2001
From: Josh Triplett <josh@joshtriplett.org>
Date: Sun, 21 Sep 2025 23:20:20 +0800
Subject: [PATCH 1224/1889] Switch `dummy_bang` from `LegacyBang` to `Bang`

---
 compiler/rustc_expand/src/base.rs   | 23 ++++++++++-------------
 compiler/rustc_expand/src/expand.rs |  2 +-
 2 files changed, 11 insertions(+), 14 deletions(-)

diff --git a/compiler/rustc_expand/src/base.rs b/compiler/rustc_expand/src/base.rs
index 88f88f30a8c69..7db1be24f2418 100644
--- a/compiler/rustc_expand/src/base.rs
+++ b/compiler/rustc_expand/src/base.rs
@@ -324,16 +324,16 @@ pub trait BangProcMacro {
 
 impl<F> BangProcMacro for F
 where
-    F: Fn(TokenStream) -> TokenStream,
+    F: Fn(&mut ExtCtxt<'_>, Span, TokenStream) -> Result<TokenStream, ErrorGuaranteed>,
 {
     fn expand<'cx>(
         &self,
-        _ecx: &'cx mut ExtCtxt<'_>,
-        _span: Span,
+        ecx: &'cx mut ExtCtxt<'_>,
+        span: Span,
         ts: TokenStream,
     ) -> Result<TokenStream, ErrorGuaranteed> {
         // FIXME setup implicit context in TLS before calling self.
-        Ok(self(ts))
+        self(ecx, span, ts)
     }
 }
 
@@ -999,17 +999,14 @@ impl SyntaxExtension {
 
     /// A dummy bang macro `foo!()`.
     pub fn dummy_bang(edition: Edition) -> SyntaxExtension {
-        fn expander<'cx>(
-            cx: &'cx mut ExtCtxt<'_>,
+        fn expand(
+            ecx: &mut ExtCtxt<'_>,
             span: Span,
-            _: TokenStream,
-        ) -> MacroExpanderResult<'cx> {
-            ExpandResult::Ready(DummyResult::any(
-                span,
-                cx.dcx().span_delayed_bug(span, "expanded a dummy bang macro"),
-            ))
+            _ts: TokenStream,
+        ) -> Result<TokenStream, ErrorGuaranteed> {
+            Err(ecx.dcx().span_delayed_bug(span, "expanded a dummy bang macro"))
         }
-        SyntaxExtension::default(SyntaxExtensionKind::LegacyBang(Arc::new(expander)), edition)
+        SyntaxExtension::default(SyntaxExtensionKind::Bang(Arc::new(expand)), edition)
     }
 
     /// A dummy derive macro `#[derive(Foo)]`.
diff --git a/compiler/rustc_expand/src/expand.rs b/compiler/rustc_expand/src/expand.rs
index 4c0e0bbfe26d1..172bc3d1d9f86 100644
--- a/compiler/rustc_expand/src/expand.rs
+++ b/compiler/rustc_expand/src/expand.rs
@@ -971,7 +971,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
                             });
                         }
                     },
-                    SyntaxExtensionKind::LegacyBang(..) => {
+                    SyntaxExtensionKind::Bang(..) => {
                         let msg = "expanded a dummy glob delegation";
                         let guar = self.cx.dcx().span_delayed_bug(span, msg);
                         return ExpandResult::Ready(fragment_kind.dummy(span, guar));

From a1646bf90c12c168a898361d2ef34e73311eccde Mon Sep 17 00:00:00 2001
From: Josh Triplett <josh@joshtriplett.org>
Date: Sun, 21 Sep 2025 23:28:10 +0800
Subject: [PATCH 1225/1889] mbe: Switch dummy extension used for errors from
 `LegacyBang` to `Bang`

---
 compiler/rustc_expand/src/mbe/macro_rules.rs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/compiler/rustc_expand/src/mbe/macro_rules.rs b/compiler/rustc_expand/src/mbe/macro_rules.rs
index 1d147a0385c68..9ed4c56efb3ea 100644
--- a/compiler/rustc_expand/src/mbe/macro_rules.rs
+++ b/compiler/rustc_expand/src/mbe/macro_rules.rs
@@ -33,8 +33,8 @@ use super::diagnostics::{FailedMacro, failed_to_match_macro};
 use super::macro_parser::{NamedMatches, NamedParseResult};
 use super::{SequenceRepetition, diagnostics};
 use crate::base::{
-    AttrProcMacro, DummyResult, ExpandResult, ExtCtxt, MacResult, MacroExpanderResult,
-    SyntaxExtension, SyntaxExtensionKind, TTMacroExpander,
+    AttrProcMacro, BangProcMacro, DummyResult, ExpandResult, ExtCtxt, MacResult,
+    MacroExpanderResult, SyntaxExtension, SyntaxExtensionKind, TTMacroExpander,
 };
 use crate::errors;
 use crate::expand::{AstFragment, AstFragmentKind, ensure_complete_parse, parse_ast_fragment};
@@ -267,16 +267,16 @@ impl AttrProcMacro for MacroRulesMacroExpander {
     }
 }
 
-struct DummyExpander(ErrorGuaranteed);
+struct DummyBang(ErrorGuaranteed);
 
-impl TTMacroExpander for DummyExpander {
+impl BangProcMacro for DummyBang {
     fn expand<'cx>(
         &self,
         _: &'cx mut ExtCtxt<'_>,
-        span: Span,
+        _: Span,
         _: TokenStream,
-    ) -> ExpandResult<Box<dyn MacResult + 'cx>, ()> {
-        ExpandResult::Ready(DummyResult::any(span, self.0))
+    ) -> Result<TokenStream, ErrorGuaranteed> {
+        Err(self.0)
     }
 }
 
@@ -664,7 +664,7 @@ pub fn compile_declarative_macro(
         SyntaxExtension::new(sess, kind, span, Vec::new(), edition, ident.name, attrs, is_local)
     };
     let dummy_syn_ext =
-        |guar| (mk_syn_ext(SyntaxExtensionKind::LegacyBang(Arc::new(DummyExpander(guar)))), 0);
+        |guar| (mk_syn_ext(SyntaxExtensionKind::Bang(Arc::new(DummyBang(guar)))), 0);
 
     let macro_rules = macro_def.macro_rules;
     let exp_sep = if macro_rules { exp!(Semi) } else { exp!(Comma) };

From 888679013d1f424adef06267f3630069b4cabd40 Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Sun, 7 Sep 2025 12:31:35 -0400
Subject: [PATCH 1226/1889] Add panic=immediate-abort

---
 .../rustc_builtin_macros/src/test_harness.rs  | 10 +--
 compiler/rustc_codegen_gcc/src/base.rs        |  4 +-
 .../rustc_codegen_gcc/src/intrinsic/mod.rs    |  3 +-
 compiler/rustc_codegen_llvm/src/intrinsic.rs  |  3 +-
 compiler/rustc_codegen_llvm/src/llvm_util.rs  |  2 +-
 compiler/rustc_codegen_ssa/src/back/link.rs   | 10 +--
 compiler/rustc_interface/messages.ftl         |  2 +-
 compiler/rustc_interface/src/passes.rs        |  3 +-
 compiler/rustc_metadata/messages.ftl          |  7 ++
 compiler/rustc_metadata/src/creader.rs        |  4 +
 .../rustc_metadata/src/dependency_format.rs   | 47 ++++++++---
 compiler/rustc_metadata/src/errors.rs         | 10 +++
 .../rustc_middle/src/middle/lang_items.rs     |  1 +
 compiler/rustc_middle/src/ty/layout.rs        |  8 +-
 compiler/rustc_mir_transform/src/coroutine.rs |  3 +-
 .../src/ffi_unwind_calls.rs                   |  9 +-
 .../src/remove_noop_landing_pads.rs           |  3 +-
 compiler/rustc_session/src/config.rs          |  9 +-
 compiler/rustc_session/src/config/cfg.rs      |  7 +-
 compiler/rustc_session/src/options.rs         |  4 +-
 compiler/rustc_session/src/session.rs         | 10 ++-
 compiler/rustc_span/src/symbol.rs             |  1 +
 compiler/rustc_target/src/spec/mod.rs         |  6 ++
 library/alloc/Cargo.toml                      |  2 -
 library/alloc/src/alloc.rs                    |  4 +-
 library/alloc/src/raw_vec/mod.rs              |  2 +-
 library/alloc/src/vec/mod.rs                  |  8 +-
 library/core/Cargo.toml                       |  2 +-
 library/core/src/cell.rs                      |  4 +-
 library/core/src/num/mod.rs                   |  4 +-
 library/core/src/option.rs                    |  8 +-
 library/core/src/panicking.rs                 | 83 ++++++++++---------
 library/core/src/result.rs                    |  4 +-
 library/core/src/slice/index.rs               |  4 +-
 library/core/src/slice/mod.rs                 |  4 +-
 .../core/src/slice/sort/shared/smallsort.rs   |  4 +-
 library/core/src/str/mod.rs                   |  4 +-
 library/std/Cargo.toml                        |  5 --
 library/std/src/panicking.rs                  | 26 +++---
 library/std/src/rt.rs                         |  4 +-
 library/std/src/thread/local.rs               |  2 +-
 library/sysroot/Cargo.toml                    |  1 -
 src/doc/rustc/src/codegen-options/index.md    |  2 +
 src/tools/compiletest/src/directives.rs       | 19 +++++
 .../src/directives/directive_names.rs         |  1 +
 src/tools/compiletest/src/runtest.rs          | 22 +++--
 .../panic-immediate-abort-codegen/Cargo.toml  | 12 +++
 .../panic-immediate-abort-codegen/lib.rs      | 65 +++++++++++++++
 .../panic-immediate-abort-codegen/rmake.rs    | 41 +++++++++
 .../hello/Cargo.toml                          |  4 +
 .../hello/src/main.rs                         |  1 +
 .../panic-immediate-abort-works/rmake.rs      | 28 +++++++
 .../report-in-external-macros.cargo.stderr    |  2 +-
 .../report-in-external-macros.rustc.stderr    |  2 +-
 tests/ui/check-cfg/well-known-values.stderr   |  2 +-
 .../ui/panic-runtime/auxiliary/needs-abort.rs |  2 +
 .../auxiliary/needs-immediate-abort.rs        |  7 ++
 .../auxiliary/needs-unwind-immediate-abort.rs | 18 ++++
 tests/ui/panic-runtime/bad-panic-flag1.rs     |  2 +-
 tests/ui/panic-runtime/bad-panic-flag1.stderr |  2 +-
 tests/ui/panic-runtime/bad-panic-flag2.rs     |  2 +-
 tests/ui/panic-runtime/bad-panic-flag2.stderr |  2 +-
 .../immediate-abort-default-sysroot.rs        | 15 ++++
 .../immediate-abort-default-sysroot.stderr    |  4 +
 .../need-abort-got-immediate-abort.rs         | 21 +++++
 .../need-abort-got-immediate-abort.stderr     |  4 +
 .../need-immediate-abort-got-abort.rs         | 20 +++++
 .../need-immediate-abort-got-abort.stderr     |  4 +
 .../need-immediate-abort-got-unwind.rs        | 20 +++++
 .../need-immediate-abort-got-unwind.stderr    |  4 +
 .../need-unwind-got-immediate-abort.rs        | 21 +++++
 .../need-unwind-got-immediate-abort.stderr    |  4 +
 tests/ui/proc-macro/panic-abort.rs            |  2 +-
 tests/ui/proc-macro/panic-abort.stderr        |  2 +-
 74 files changed, 541 insertions(+), 157 deletions(-)
 create mode 100644 tests/run-make-cargo/panic-immediate-abort-codegen/Cargo.toml
 create mode 100644 tests/run-make-cargo/panic-immediate-abort-codegen/lib.rs
 create mode 100644 tests/run-make-cargo/panic-immediate-abort-codegen/rmake.rs
 create mode 100644 tests/run-make-cargo/panic-immediate-abort-works/hello/Cargo.toml
 create mode 100644 tests/run-make-cargo/panic-immediate-abort-works/hello/src/main.rs
 create mode 100644 tests/run-make-cargo/panic-immediate-abort-works/rmake.rs
 create mode 100644 tests/ui/panic-runtime/auxiliary/needs-immediate-abort.rs
 create mode 100644 tests/ui/panic-runtime/auxiliary/needs-unwind-immediate-abort.rs
 create mode 100644 tests/ui/panic-runtime/immediate-abort-default-sysroot.rs
 create mode 100644 tests/ui/panic-runtime/immediate-abort-default-sysroot.stderr
 create mode 100644 tests/ui/panic-runtime/need-abort-got-immediate-abort.rs
 create mode 100644 tests/ui/panic-runtime/need-abort-got-immediate-abort.stderr
 create mode 100644 tests/ui/panic-runtime/need-immediate-abort-got-abort.rs
 create mode 100644 tests/ui/panic-runtime/need-immediate-abort-got-abort.stderr
 create mode 100644 tests/ui/panic-runtime/need-immediate-abort-got-unwind.rs
 create mode 100644 tests/ui/panic-runtime/need-immediate-abort-got-unwind.stderr
 create mode 100644 tests/ui/panic-runtime/need-unwind-got-immediate-abort.rs
 create mode 100644 tests/ui/panic-runtime/need-unwind-got-immediate-abort.stderr

diff --git a/compiler/rustc_builtin_macros/src/test_harness.rs b/compiler/rustc_builtin_macros/src/test_harness.rs
index 51089e5a1d3f1..82c59d5a3a20b 100644
--- a/compiler/rustc_builtin_macros/src/test_harness.rs
+++ b/compiler/rustc_builtin_macros/src/test_harness.rs
@@ -63,8 +63,8 @@ pub fn inject(
 
     if sess.is_test_crate() {
         let panic_strategy = match (panic_strategy, sess.opts.unstable_opts.panic_abort_tests) {
-            (PanicStrategy::Abort, true) => PanicStrategy::Abort,
-            (PanicStrategy::Abort, false) => {
+            (PanicStrategy::Abort | PanicStrategy::ImmediateAbort, true) => panic_strategy,
+            (PanicStrategy::Abort | PanicStrategy::ImmediateAbort, false) => {
                 if panic_strategy == platform_panic_strategy {
                     // Silently allow compiling with panic=abort on these platforms,
                     // but with old behavior (abort if a test fails).
@@ -287,10 +287,8 @@ fn mk_main(cx: &mut TestCtxt<'_>) -> Box<ast::Item> {
     let ecx = &cx.ext_cx;
     let test_ident = Ident::new(sym::test, sp);
 
-    let runner_name = match cx.panic_strategy {
-        PanicStrategy::Unwind => "test_main_static",
-        PanicStrategy::Abort => "test_main_static_abort",
-    };
+    let runner_name =
+        if cx.panic_strategy.unwinds() { "test_main_static" } else { "test_main_static_abort" };
 
     // test::test_main_static(...)
     let mut test_runner = cx.test_runner.clone().unwrap_or_else(|| {
diff --git a/compiler/rustc_codegen_gcc/src/base.rs b/compiler/rustc_codegen_gcc/src/base.rs
index e9d72e457a086..e8672f49580b6 100644
--- a/compiler/rustc_codegen_gcc/src/base.rs
+++ b/compiler/rustc_codegen_gcc/src/base.rs
@@ -15,9 +15,9 @@ use rustc_middle::mir::mono::Visibility;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::config::DebugInfo;
 use rustc_span::Symbol;
+use rustc_target::spec::RelocModel;
 #[cfg(feature = "master")]
 use rustc_target::spec::SymbolVisibility;
-use rustc_target::spec::{PanicStrategy, RelocModel};
 
 use crate::builder::Builder;
 use crate::context::CodegenCx;
@@ -101,7 +101,7 @@ pub fn compile_codegen_unit(
         // Instantiate monomorphizations without filling out definitions yet...
         let context = new_context(tcx);
 
-        if tcx.sess.panic_strategy() == PanicStrategy::Unwind {
+        if tcx.sess.panic_strategy().unwinds() {
             context.add_command_line_option("-fexceptions");
             context.add_driver_option("-fexceptions");
         }
diff --git a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
index 84fa56cf90308..a915f5d64188f 100644
--- a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
+++ b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
@@ -29,7 +29,6 @@ use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::ty::{self, Instance, Ty};
 use rustc_span::{Span, Symbol, sym};
 use rustc_target::callconv::{ArgAbi, PassMode};
-use rustc_target::spec::PanicStrategy;
 
 #[cfg(feature = "master")]
 use crate::abi::FnAbiGccExt;
@@ -1334,7 +1333,7 @@ fn try_intrinsic<'a, 'b, 'gcc, 'tcx>(
     _catch_func: RValue<'gcc>,
     dest: PlaceRef<'tcx, RValue<'gcc>>,
 ) {
-    if bx.sess().panic_strategy() == PanicStrategy::Abort {
+    if !bx.sess().panic_strategy().unwinds() {
         bx.call(bx.type_void(), None, None, try_func, &[data], None, None);
         // Return 0 unconditionally from the intrinsic call;
         // we can never unwind.
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
index e7f4a3570488e..50398a32142eb 100644
--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -18,7 +18,6 @@ use rustc_middle::{bug, span_bug};
 use rustc_span::{Span, Symbol, sym};
 use rustc_symbol_mangling::{mangle_internal_symbol, symbol_name_for_instance_in_crate};
 use rustc_target::callconv::PassMode;
-use rustc_target::spec::PanicStrategy;
 use tracing::debug;
 
 use crate::abi::FnAbiLlvmExt;
@@ -674,7 +673,7 @@ fn catch_unwind_intrinsic<'ll, 'tcx>(
     catch_func: &'ll Value,
     dest: PlaceRef<'tcx, &'ll Value>,
 ) {
-    if bx.sess().panic_strategy() == PanicStrategy::Abort {
+    if !bx.sess().panic_strategy().unwinds() {
         let try_func_ty = bx.type_func(&[bx.type_ptr()], bx.type_void());
         bx.call(try_func_ty, None, None, try_func, &[data], None, None);
         // Return 0 unconditionally from the intrinsic call;
diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index 45c5c9aa5514d..3b920168e06dc 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -106,7 +106,7 @@ unsafe fn configure_llvm(sess: &Session) {
 
         if sess.target.os == "emscripten"
             && !sess.opts.unstable_opts.emscripten_wasm_eh
-            && sess.panic_strategy() == PanicStrategy::Unwind
+            && sess.panic_strategy().unwinds()
         {
             add("-enable-emscripten-cxx-exceptions", false);
         }
diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
index 48b01ea2df197..327f001e1c85a 100644
--- a/compiler/rustc_codegen_ssa/src/back/link.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -47,8 +47,8 @@ use rustc_span::Symbol;
 use rustc_target::spec::crt_objects::CrtObjects;
 use rustc_target::spec::{
     BinaryFormat, Cc, LinkOutputKind, LinkSelfContainedComponents, LinkSelfContainedDefault,
-    LinkerFeatures, LinkerFlavor, LinkerFlavorCli, Lld, PanicStrategy, RelocModel, RelroLevel,
-    SanitizerSet, SplitDebuginfo,
+    LinkerFeatures, LinkerFlavor, LinkerFlavorCli, Lld, RelocModel, RelroLevel, SanitizerSet,
+    SplitDebuginfo,
 };
 use tracing::{debug, info, warn};
 
@@ -2512,10 +2512,10 @@ fn add_order_independent_options(
     if sess.target.os == "emscripten" {
         cmd.cc_arg(if sess.opts.unstable_opts.emscripten_wasm_eh {
             "-fwasm-exceptions"
-        } else if sess.panic_strategy() == PanicStrategy::Abort {
-            "-sDISABLE_EXCEPTION_CATCHING=1"
-        } else {
+        } else if sess.panic_strategy().unwinds() {
             "-sDISABLE_EXCEPTION_CATCHING=0"
+        } else {
+            "-sDISABLE_EXCEPTION_CATCHING=1"
         });
     }
 
diff --git a/compiler/rustc_interface/messages.ftl b/compiler/rustc_interface/messages.ftl
index 6f6666f8c76fa..1f5c5e74d97ae 100644
--- a/compiler/rustc_interface/messages.ftl
+++ b/compiler/rustc_interface/messages.ftl
@@ -47,7 +47,7 @@ interface_out_dir_error =
     failed to find or create the directory specified by `--out-dir`
 
 interface_proc_macro_crate_panic_abort =
-    building proc macro crate with `panic=abort` may crash the compiler should the proc-macro panic
+    building proc macro crate with `panic=abort` or `panic=immediate-abort` may crash the compiler should the proc-macro panic
 
 interface_temps_dir_error =
     failed to find or create the directory specified by `--temps-dir`
diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs
index 6cefe8875306a..761a5c8091822 100644
--- a/compiler/rustc_interface/src/passes.rs
+++ b/compiler/rustc_interface/src/passes.rs
@@ -42,7 +42,6 @@ use rustc_span::{
     DUMMY_SP, ErrorGuaranteed, ExpnKind, FileName, SourceFileHash, SourceFileHashAlgorithm, Span,
     Symbol, sym,
 };
-use rustc_target::spec::PanicStrategy;
 use rustc_trait_selection::{solve, traits};
 use tracing::{info, instrument};
 
@@ -282,7 +281,7 @@ fn configure_and_expand(
         feature_err(sess, sym::export_stable, DUMMY_SP, "`sdylib` crate type is unstable").emit();
     }
 
-    if is_proc_macro_crate && sess.panic_strategy() == PanicStrategy::Abort {
+    if is_proc_macro_crate && !sess.panic_strategy().unwinds() {
         sess.dcx().emit_warn(errors::ProcMacroCratePanicAbort);
     }
 
diff --git a/compiler/rustc_metadata/messages.ftl b/compiler/rustc_metadata/messages.ftl
index e104be2c46637..e624bfc5b8bda 100644
--- a/compiler/rustc_metadata/messages.ftl
+++ b/compiler/rustc_metadata/messages.ftl
@@ -98,6 +98,13 @@ metadata_full_metadata_not_found =
 metadata_global_alloc_required =
     no global memory allocator found but one is required; link to std or add `#[global_allocator]` to a static item that implements the GlobalAlloc trait
 
+metadata_incompatible_with_immediate_abort =
+    the crate `{$crate_name}` was compiled with a panic strategy which is incompatible with `immediate-abort`
+
+metadata_incompatible_with_immediate_abort_core =
+    the crate `core` was compiled with a panic strategy which is incompatible with `immediate-abort`
+    .help = consider building the standard library from source with `cargo build -Zbuild-std`
+
 metadata_incompatible_panic_in_drop_strategy =
     the crate `{$crate_name}` is compiled with the panic-in-drop strategy `{$found_strategy}` which is incompatible with this crate's strategy of `{$desired_strategy}`
 
diff --git a/compiler/rustc_metadata/src/creader.rs b/compiler/rustc_metadata/src/creader.rs
index 9e23da88f5e1e..7650acbd292d2 100644
--- a/compiler/rustc_metadata/src/creader.rs
+++ b/compiler/rustc_metadata/src/creader.rs
@@ -1027,6 +1027,10 @@ impl CStore {
         let name = match desired_strategy {
             PanicStrategy::Unwind => sym::panic_unwind,
             PanicStrategy::Abort => sym::panic_abort,
+            PanicStrategy::ImmediateAbort => {
+                // Immediate-aborting panics don't use a runtime.
+                return;
+            }
         };
         info!("panic runtime not found -- loading {}", name);
 
diff --git a/compiler/rustc_metadata/src/dependency_format.rs b/compiler/rustc_metadata/src/dependency_format.rs
index fb9c2e23b715b..8054a48d37af1 100644
--- a/compiler/rustc_metadata/src/dependency_format.rs
+++ b/compiler/rustc_metadata/src/dependency_format.rs
@@ -61,11 +61,13 @@ use rustc_session::config::CrateType;
 use rustc_session::cstore::CrateDepKind;
 use rustc_session::cstore::LinkagePreference::{self, RequireDynamic, RequireStatic};
 use rustc_span::sym;
+use rustc_target::spec::PanicStrategy;
 use tracing::info;
 
 use crate::creader::CStore;
 use crate::errors::{
-    BadPanicStrategy, CrateDepMultiple, IncompatiblePanicInDropStrategy, LibRequired,
+    BadPanicStrategy, CrateDepMultiple, IncompatiblePanicInDropStrategy,
+    IncompatibleWithImmediateAbort, IncompatibleWithImmediateAbortCore, LibRequired,
     NonStaticCrateDep, RequiredPanicStrategy, RlibRequired, RustcDriverHelp, RustcLibRequired,
     TwoPanicRuntimes,
 };
@@ -402,15 +404,43 @@ fn activate_injected_dep(
 /// there's only going to be one panic runtime in the output.
 fn verify_ok(tcx: TyCtxt<'_>, list: &DependencyList) {
     let sess = &tcx.sess;
+    let list: Vec<_> = list
+        .iter_enumerated()
+        .filter_map(
+            |(cnum, linkage)| if *linkage == Linkage::NotLinked { None } else { Some(cnum) },
+        )
+        .collect();
     if list.is_empty() {
         return;
     }
-    let mut panic_runtime = None;
-    for (cnum, linkage) in list.iter_enumerated() {
-        if let Linkage::NotLinked = *linkage {
-            continue;
+    let desired_strategy = sess.panic_strategy();
+
+    // If we are panic=immediate-abort, make sure everything in the dependency tree has also been
+    // compiled with immediate-abort.
+    if list
+        .iter()
+        .any(|cnum| tcx.required_panic_strategy(*cnum) == Some(PanicStrategy::ImmediateAbort))
+    {
+        let mut invalid_crates = Vec::new();
+        for cnum in list.iter().copied() {
+            if tcx.required_panic_strategy(cnum) != Some(PanicStrategy::ImmediateAbort) {
+                invalid_crates.push(cnum);
+                // If core is incompatible, it's very likely that we'd emit an error for every
+                // sysroot crate, so instead of doing that emit a single fatal error that suggests
+                // using build-std.
+                if tcx.crate_name(cnum) == sym::core {
+                    sess.dcx().emit_fatal(IncompatibleWithImmediateAbortCore);
+                }
+            }
         }
+        for cnum in invalid_crates {
+            sess.dcx()
+                .emit_err(IncompatibleWithImmediateAbort { crate_name: tcx.crate_name(cnum) });
+        }
+    }
 
+    let mut panic_runtime = None;
+    for cnum in list.iter().copied() {
         if tcx.is_panic_runtime(cnum) {
             if let Some((prev, _)) = panic_runtime {
                 let prev_name = tcx.crate_name(prev);
@@ -430,8 +460,6 @@ fn verify_ok(tcx: TyCtxt<'_>, list: &DependencyList) {
     // only one, but we perform validation here that all the panic strategy
     // compilation modes for the whole DAG are valid.
     if let Some((runtime_cnum, found_strategy)) = panic_runtime {
-        let desired_strategy = sess.panic_strategy();
-
         // First up, validate that our selected panic runtime is indeed exactly
         // our same strategy.
         if found_strategy != desired_strategy {
@@ -445,10 +473,7 @@ fn verify_ok(tcx: TyCtxt<'_>, list: &DependencyList) {
         // strategy. If the dep isn't linked, we ignore it, and if our strategy
         // is abort then it's compatible with everything. Otherwise all crates'
         // panic strategy must match our own.
-        for (cnum, linkage) in list.iter_enumerated() {
-            if let Linkage::NotLinked = *linkage {
-                continue;
-            }
+        for cnum in list.iter().copied() {
             if cnum == runtime_cnum || tcx.is_compiler_builtins(cnum) {
                 continue;
             }
diff --git a/compiler/rustc_metadata/src/errors.rs b/compiler/rustc_metadata/src/errors.rs
index e5a4fd48353fa..abfd078f7462d 100644
--- a/compiler/rustc_metadata/src/errors.rs
+++ b/compiler/rustc_metadata/src/errors.rs
@@ -75,6 +75,16 @@ pub struct RequiredPanicStrategy {
     pub desired_strategy: PanicStrategy,
 }
 
+#[derive(Diagnostic)]
+#[diag(metadata_incompatible_with_immediate_abort)]
+pub struct IncompatibleWithImmediateAbort {
+    pub crate_name: Symbol,
+}
+
+#[derive(Diagnostic)]
+#[diag(metadata_incompatible_with_immediate_abort_core)]
+pub struct IncompatibleWithImmediateAbortCore;
+
 #[derive(Diagnostic)]
 #[diag(metadata_incompatible_panic_in_drop_strategy)]
 pub struct IncompatiblePanicInDropStrategy {
diff --git a/compiler/rustc_middle/src/middle/lang_items.rs b/compiler/rustc_middle/src/middle/lang_items.rs
index 93264f02cc259..a0e4c288c4a85 100644
--- a/compiler/rustc_middle/src/middle/lang_items.rs
+++ b/compiler/rustc_middle/src/middle/lang_items.rs
@@ -98,5 +98,6 @@ pub fn required(tcx: TyCtxt<'_>, lang_item: LangItem) -> bool {
             lang_item != LangItem::EhPersonality && lang_item != LangItem::EhCatchTypeinfo
         }
         PanicStrategy::Unwind => true,
+        PanicStrategy::ImmediateAbort => false,
     }
 }
diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs
index c477e65f5d6b3..47b45c58b9f8c 100644
--- a/compiler/rustc_middle/src/ty/layout.rs
+++ b/compiler/rustc_middle/src/ty/layout.rs
@@ -16,7 +16,7 @@ use rustc_macros::{HashStable, TyDecodable, TyEncodable, extension};
 use rustc_session::config::OptLevel;
 use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span, Symbol, sym};
 use rustc_target::callconv::FnAbi;
-use rustc_target::spec::{HasTargetSpec, HasX86AbiOpt, PanicStrategy, Target, X86Abi};
+use rustc_target::spec::{HasTargetSpec, HasX86AbiOpt, Target, X86Abi};
 use tracing::debug;
 use {rustc_abi as abi, rustc_hir as hir};
 
@@ -1198,7 +1198,7 @@ pub fn fn_can_unwind(tcx: TyCtxt<'_>, fn_def_id: Option<DefId>, abi: ExternAbi)
         //
         // Note that this is true regardless ABI specified on the function -- a `extern "C-unwind"`
         // function defined in Rust is also required to abort.
-        if tcx.sess.panic_strategy() == PanicStrategy::Abort && !tcx.is_foreign_item(did) {
+        if !tcx.sess.panic_strategy().unwinds() && !tcx.is_foreign_item(did) {
             return false;
         }
 
@@ -1206,7 +1206,7 @@ pub fn fn_can_unwind(tcx: TyCtxt<'_>, fn_def_id: Option<DefId>, abi: ExternAbi)
         //
         // This is not part of `codegen_fn_attrs` as it can differ between crates
         // and therefore cannot be computed in core.
-        if tcx.sess.opts.unstable_opts.panic_in_drop == PanicStrategy::Abort
+        if !tcx.sess.opts.unstable_opts.panic_in_drop.unwinds()
             && tcx.is_lang_item(did, LangItem::DropInPlace)
         {
             return false;
@@ -1245,7 +1245,7 @@ pub fn fn_can_unwind(tcx: TyCtxt<'_>, fn_def_id: Option<DefId>, abi: ExternAbi)
         | RiscvInterruptS
         | RustInvalid
         | Unadjusted => false,
-        Rust | RustCall | RustCold => tcx.sess.panic_strategy() == PanicStrategy::Unwind,
+        Rust | RustCall | RustCold => tcx.sess.panic_strategy().unwinds(),
     }
 }
 
diff --git a/compiler/rustc_mir_transform/src/coroutine.rs b/compiler/rustc_mir_transform/src/coroutine.rs
index c1cd2788348a6..c5cd06f170c47 100644
--- a/compiler/rustc_mir_transform/src/coroutine.rs
+++ b/compiler/rustc_mir_transform/src/coroutine.rs
@@ -86,7 +86,6 @@ use rustc_span::def_id::{DefId, LocalDefId};
 use rustc_span::source_map::dummy_spanned;
 use rustc_span::symbol::sym;
 use rustc_span::{DUMMY_SP, Span};
-use rustc_target::spec::PanicStrategy;
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::infer::TyCtxtInferExt as _;
 use rustc_trait_selection::traits::{ObligationCause, ObligationCauseCode, ObligationCtxt};
@@ -1149,7 +1148,7 @@ fn can_return<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'tcx>, typing_env: ty::Typing
 
 fn can_unwind<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'tcx>) -> bool {
     // Nothing can unwind when landing pads are off.
-    if tcx.sess.panic_strategy() == PanicStrategy::Abort {
+    if !tcx.sess.panic_strategy().unwinds() {
         return false;
     }
 
diff --git a/compiler/rustc_mir_transform/src/ffi_unwind_calls.rs b/compiler/rustc_mir_transform/src/ffi_unwind_calls.rs
index abbff1c48dd9a..7c66783548ea4 100644
--- a/compiler/rustc_mir_transform/src/ffi_unwind_calls.rs
+++ b/compiler/rustc_mir_transform/src/ffi_unwind_calls.rs
@@ -101,12 +101,15 @@ fn has_ffi_unwind_calls(tcx: TyCtxt<'_>, local_def_id: LocalDefId) -> bool {
 }
 
 fn required_panic_strategy(tcx: TyCtxt<'_>, _: LocalCrate) -> Option<PanicStrategy> {
+    let local_strategy = tcx.sess.panic_strategy();
+
     if tcx.is_panic_runtime(LOCAL_CRATE) {
-        return Some(tcx.sess.panic_strategy());
+        return Some(local_strategy);
     }
 
-    if tcx.sess.panic_strategy() == PanicStrategy::Abort {
-        return Some(PanicStrategy::Abort);
+    match local_strategy {
+        PanicStrategy::Abort | PanicStrategy::ImmediateAbort => return Some(local_strategy),
+        _ => {}
     }
 
     for def_id in tcx.hir_body_owners() {
diff --git a/compiler/rustc_mir_transform/src/remove_noop_landing_pads.rs b/compiler/rustc_mir_transform/src/remove_noop_landing_pads.rs
index 5b6d7ffb51102..b53c1f6d20203 100644
--- a/compiler/rustc_mir_transform/src/remove_noop_landing_pads.rs
+++ b/compiler/rustc_mir_transform/src/remove_noop_landing_pads.rs
@@ -1,7 +1,6 @@
 use rustc_index::bit_set::DenseBitSet;
 use rustc_middle::mir::*;
 use rustc_middle::ty::TyCtxt;
-use rustc_target::spec::PanicStrategy;
 use tracing::debug;
 
 use crate::patch::MirPatch;
@@ -13,7 +12,7 @@ pub(super) struct RemoveNoopLandingPads;
 
 impl<'tcx> crate::MirPass<'tcx> for RemoveNoopLandingPads {
     fn is_enabled(&self, sess: &rustc_session::Session) -> bool {
-        sess.panic_strategy() != PanicStrategy::Abort
+        sess.panic_strategy().unwinds()
     }
 
     fn run_pass(&self, _tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs
index 795cb2b2cfeba..81ada79dd4384 100644
--- a/compiler/rustc_session/src/config.rs
+++ b/compiler/rustc_session/src/config.rs
@@ -29,7 +29,8 @@ use rustc_span::{
     SourceFileHashAlgorithm, Symbol, sym,
 };
 use rustc_target::spec::{
-    FramePointer, LinkSelfContainedComponents, LinkerFeatures, SplitDebuginfo, Target, TargetTuple,
+    FramePointer, LinkSelfContainedComponents, LinkerFeatures, PanicStrategy, SplitDebuginfo,
+    Target, TargetTuple,
 };
 use tracing::debug;
 
@@ -2799,6 +2800,12 @@ pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::M
         }
     }
 
+    if !unstable_options_enabled && cg.panic == Some(PanicStrategy::ImmediateAbort) {
+        early_dcx.early_fatal(
+            "`-Cpanic=immediate-abort` requires `-Zunstable-options` and a nightly compiler",
+        )
+    }
+
     let crate_name = matches.opt_str("crate-name");
     let unstable_features = UnstableFeatures::from_environment(crate_name.as_deref());
     // Parse any `-l` flags, which link to native libraries.
diff --git a/compiler/rustc_session/src/config/cfg.rs b/compiler/rustc_session/src/config/cfg.rs
index 7e970461ab731..fc36fe9d5d76e 100644
--- a/compiler/rustc_session/src/config/cfg.rs
+++ b/compiler/rustc_session/src/config/cfg.rs
@@ -125,7 +125,9 @@ pub(crate) fn disallow_cfgs(sess: &Session, user_cfgs: &Cfg) {
                 None | Some(_),
             ) => disallow(cfg, "-Z sanitizer=cfi"),
             (sym::proc_macro, None) => disallow(cfg, "--crate-type proc-macro"),
-            (sym::panic, Some(sym::abort | sym::unwind)) => disallow(cfg, "-C panic"),
+            (sym::panic, Some(sym::abort | sym::unwind | sym::immediate_abort)) => {
+                disallow(cfg, "-C panic")
+            }
             (sym::target_feature, Some(_)) => disallow(cfg, "-C target-feature"),
             (sym::unix, None)
             | (sym::windows, None)
@@ -204,6 +206,9 @@ pub(crate) fn default_configuration(sess: &Session) -> Cfg {
     }
 
     ins_sym!(sym::panic, sess.panic_strategy().desc_symbol());
+    if sess.panic_strategy() == PanicStrategy::ImmediateAbort {
+        ins_sym!(sym::panic, PanicStrategy::Abort.desc_symbol());
+    }
 
     // JUSTIFICATION: before wrapper fn is available
     #[allow(rustc::bad_opt_access)]
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
index 69facde693689..3b9d81177861d 100644
--- a/compiler/rustc_session/src/options.rs
+++ b/compiler/rustc_session/src/options.rs
@@ -802,7 +802,7 @@ mod desc {
     pub(crate) const parse_threads: &str = parse_number;
     pub(crate) const parse_time_passes_format: &str = "`text` (default) or `json`";
     pub(crate) const parse_passes: &str = "a space-separated list of passes, or `all`";
-    pub(crate) const parse_panic_strategy: &str = "either `unwind` or `abort`";
+    pub(crate) const parse_panic_strategy: &str = "either `unwind`, `abort`, or `immediate-abort`";
     pub(crate) const parse_on_broken_pipe: &str = "either `kill`, `error`, or `inherit`";
     pub(crate) const parse_patchable_function_entry: &str = "either two comma separated integers (total_nops,prefix_nops), with prefix_nops <= total_nops, or one integer (total_nops)";
     pub(crate) const parse_opt_panic_strategy: &str = parse_panic_strategy;
@@ -1165,6 +1165,7 @@ pub mod parse {
         match v {
             Some("unwind") => *slot = Some(PanicStrategy::Unwind),
             Some("abort") => *slot = Some(PanicStrategy::Abort),
+            Some("immediate-abort") => *slot = Some(PanicStrategy::ImmediateAbort),
             _ => return false,
         }
         true
@@ -1174,6 +1175,7 @@ pub mod parse {
         match v {
             Some("unwind") => *slot = PanicStrategy::Unwind,
             Some("abort") => *slot = PanicStrategy::Abort,
+            Some("immediate-abort") => *slot = PanicStrategy::ImmediateAbort,
             _ => return false,
         }
         true
diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
index d0dd2cdac0c48..25b46241c52df 100644
--- a/compiler/rustc_session/src/session.rs
+++ b/compiler/rustc_session/src/session.rs
@@ -777,9 +777,11 @@ impl Session {
         // Otherwise, we can defer to the `-C force-unwind-tables=<yes/no>`
         // value, if it is provided, or disable them, if not.
         self.target.requires_uwtable
-            || self.opts.cg.force_unwind_tables.unwrap_or(
-                self.panic_strategy() == PanicStrategy::Unwind || self.target.default_uwtable,
-            )
+            || self
+                .opts
+                .cg
+                .force_unwind_tables
+                .unwrap_or(self.panic_strategy().unwinds() || self.target.default_uwtable)
     }
 
     /// Returns the number of query threads that should be used for this
@@ -1229,7 +1231,7 @@ fn validate_commandline_args_with_session_available(sess: &Session) {
     }
 
     // KCFI requires panic=abort
-    if sess.is_sanitizer_kcfi_enabled() && sess.panic_strategy() != PanicStrategy::Abort {
+    if sess.is_sanitizer_kcfi_enabled() && sess.panic_strategy().unwinds() {
         sess.dcx().emit_err(errors::SanitizerKcfiRequiresPanicAbort);
     }
 
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 4fef65f46b1fd..efeb4371e4ca6 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1195,6 +1195,7 @@ symbols! {
         if_let_rescope,
         if_while_or_patterns,
         ignore,
+        immediate_abort,
         impl_header_lifetime_elision,
         impl_lint_pass,
         impl_trait_in_assoc_type,
diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index f705af52bd868..2299db94535d7 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -834,6 +834,7 @@ crate::target_spec_enum! {
     pub enum PanicStrategy {
         Unwind = "unwind",
         Abort = "abort",
+        ImmediateAbort = "immediate-abort",
     }
 
     parse_error_type = "panic strategy";
@@ -852,8 +853,13 @@ impl PanicStrategy {
         match *self {
             PanicStrategy::Unwind => sym::unwind,
             PanicStrategy::Abort => sym::abort,
+            PanicStrategy::ImmediateAbort => sym::immediate_abort,
         }
     }
+
+    pub fn unwinds(self) -> bool {
+        matches!(self, PanicStrategy::Unwind)
+    }
 }
 
 crate::target_spec_enum! {
diff --git a/library/alloc/Cargo.toml b/library/alloc/Cargo.toml
index 9ba7c5bd28a11..fb1f8c86dbfd5 100644
--- a/library/alloc/Cargo.toml
+++ b/library/alloc/Cargo.toml
@@ -22,8 +22,6 @@ compiler_builtins = { path = "../compiler-builtins/compiler-builtins", features
 compiler-builtins-mem = ['compiler_builtins/mem']
 compiler-builtins-c = ["compiler_builtins/c"]
 compiler-builtins-no-f16-f128 = ["compiler_builtins/no-f16-f128"]
-# Make panics and failed asserts immediately abort without formatting any message
-panic_immediate_abort = ["core/panic_immediate_abort"]
 # Choose algorithms that are optimized for binary size instead of runtime performance
 optimize_for_size = ["core/optimize_for_size"]
 
diff --git a/library/alloc/src/alloc.rs b/library/alloc/src/alloc.rs
index 76630a746dd26..304b473f14df7 100644
--- a/library/alloc/src/alloc.rs
+++ b/library/alloc/src/alloc.rs
@@ -408,12 +408,12 @@ pub const fn handle_alloc_error(layout: Layout) -> ! {
         }
     }
 
-    #[cfg(not(feature = "panic_immediate_abort"))]
+    #[cfg(not(panic = "immediate_abort"))]
     {
         core::intrinsics::const_eval_select((layout,), ct_error, rt_error)
     }
 
-    #[cfg(feature = "panic_immediate_abort")]
+    #[cfg(panic = "immediate_abort")]
     ct_error(layout)
 }
 
diff --git a/library/alloc/src/raw_vec/mod.rs b/library/alloc/src/raw_vec/mod.rs
index b0027e964e467..4853b84a01a32 100644
--- a/library/alloc/src/raw_vec/mod.rs
+++ b/library/alloc/src/raw_vec/mod.rs
@@ -23,7 +23,7 @@ mod tests;
 // ensure that the code generation related to these panics is minimal as there's
 // only one location which panics rather than a bunch throughout the module.
 #[cfg(not(no_global_oom_handling))]
-#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never))]
+#[cfg_attr(not(panic = "immediate_abort"), inline(never))]
 #[track_caller]
 fn capacity_overflow() -> ! {
     panic!("capacity overflow");
diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs
index 10c7ee4f6c89d..1a9041290ef17 100644
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -2020,7 +2020,7 @@ impl<T, A: Allocator> Vec<T, A> {
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn swap_remove(&mut self, index: usize) -> T {
         #[cold]
-        #[cfg_attr(not(feature = "panic_immediate_abort"), inline(never))]
+        #[cfg_attr(not(panic = "immediate_abort"), inline(never))]
         #[track_caller]
         #[optimize(size)]
         fn assert_failed(index: usize, len: usize) -> ! {
@@ -2102,7 +2102,7 @@ impl<T, A: Allocator> Vec<T, A> {
     #[must_use = "if you don't need a reference to the value, use `Vec::insert` instead"]
     pub fn insert_mut(&mut self, index: usize, element: T) -> &mut T {
         #[cold]
-        #[cfg_attr(not(feature = "panic_immediate_abort"), inline(never))]
+        #[cfg_attr(not(panic = "immediate_abort"), inline(never))]
         #[track_caller]
         #[optimize(size)]
         fn assert_failed(index: usize, len: usize) -> ! {
@@ -2166,7 +2166,7 @@ impl<T, A: Allocator> Vec<T, A> {
     #[rustc_confusables("delete", "take")]
     pub fn remove(&mut self, index: usize) -> T {
         #[cold]
-        #[cfg_attr(not(feature = "panic_immediate_abort"), inline(never))]
+        #[cfg_attr(not(panic = "immediate_abort"), inline(never))]
         #[track_caller]
         #[optimize(size)]
         fn assert_failed(index: usize, len: usize) -> ! {
@@ -2955,7 +2955,7 @@ impl<T, A: Allocator> Vec<T, A> {
         A: Clone,
     {
         #[cold]
-        #[cfg_attr(not(feature = "panic_immediate_abort"), inline(never))]
+        #[cfg_attr(not(panic = "immediate_abort"), inline(never))]
         #[track_caller]
         #[optimize(size)]
         fn assert_failed(at: usize, len: usize) -> ! {
diff --git a/library/core/Cargo.toml b/library/core/Cargo.toml
index 3e34e03a61e91..d094172b07659 100644
--- a/library/core/Cargo.toml
+++ b/library/core/Cargo.toml
@@ -16,7 +16,7 @@ test = false
 bench = false
 
 [features]
-# Make panics and failed asserts immediately abort without formatting any message
+# Issue a compile error that says to use -Cpanic=immediate-abort
 panic_immediate_abort = []
 # Choose algorithms that are optimized for binary size instead of runtime performance
 optimize_for_size = []
diff --git a/library/core/src/cell.rs b/library/core/src/cell.rs
index 9b53b75ebee80..d7097e3b6fd4e 100644
--- a/library/core/src/cell.rs
+++ b/library/core/src/cell.rs
@@ -778,7 +778,7 @@ impl Display for BorrowMutError {
 }
 
 // This ensures the panicking code is outlined from `borrow_mut` for `RefCell`.
-#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never))]
+#[cfg_attr(not(panic = "immediate_abort"), inline(never))]
 #[track_caller]
 #[cold]
 const fn panic_already_borrowed(err: BorrowMutError) -> ! {
@@ -790,7 +790,7 @@ const fn panic_already_borrowed(err: BorrowMutError) -> ! {
 }
 
 // This ensures the panicking code is outlined from `borrow` for `RefCell`.
-#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never))]
+#[cfg_attr(not(panic = "immediate_abort"), inline(never))]
 #[track_caller]
 #[cold]
 const fn panic_already_mutably_borrowed(err: BorrowError) -> ! {
diff --git a/library/core/src/num/mod.rs b/library/core/src/num/mod.rs
index 54d5a63633c22..3c4bfe28aa326 100644
--- a/library/core/src/num/mod.rs
+++ b/library/core/src/num/mod.rs
@@ -1387,8 +1387,8 @@ pub const fn can_not_overflow<T>(radix: u32, is_signed_ty: bool, digits: &[u8])
     radix <= 16 && digits.len() <= size_of::<T>() * 2 - is_signed_ty as usize
 }
 
-#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never))]
-#[cfg_attr(feature = "panic_immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate_abort"), inline(never))]
+#[cfg_attr(panic = "immediate_abort", inline)]
 #[cold]
 #[track_caller]
 const fn from_ascii_radix_panic(radix: u32) -> ! {
diff --git a/library/core/src/option.rs b/library/core/src/option.rs
index 886d581b0a6b6..10eec2cdfb6cf 100644
--- a/library/core/src/option.rs
+++ b/library/core/src/option.rs
@@ -2161,8 +2161,8 @@ impl<T, E> Option<Result<T, E>> {
     }
 }
 
-#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never))]
-#[cfg_attr(feature = "panic_immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate_abort"), inline(never))]
+#[cfg_attr(panic = "immediate_abort", inline)]
 #[cold]
 #[track_caller]
 const fn unwrap_failed() -> ! {
@@ -2170,8 +2170,8 @@ const fn unwrap_failed() -> ! {
 }
 
 // This is a separate function to reduce the code size of .expect() itself.
-#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never))]
-#[cfg_attr(feature = "panic_immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate_abort"), inline(never))]
+#[cfg_attr(panic = "immediate_abort", inline)]
 #[cold]
 #[track_caller]
 const fn expect_failed(msg: &str) -> ! {
diff --git a/library/core/src/panicking.rs b/library/core/src/panicking.rs
index 804a12ee477bb..da37d72960a61 100644
--- a/library/core/src/panicking.rs
+++ b/library/core/src/panicking.rs
@@ -33,7 +33,10 @@ use crate::intrinsics::const_eval_select;
 use crate::panic::{Location, PanicInfo};
 
 #[cfg(feature = "panic_immediate_abort")]
-const _: () = assert!(cfg!(panic = "abort"), "panic_immediate_abort requires -C panic=abort");
+compile_error!(
+    "panic_immediate_abort is now a real panic strategy! \
+    Enable it with the compiler flags `-Zunstable-options -Cpanic=immediate-abort`"
+);
 
 // First we define the two main entry points that all panics go through.
 // In the end both are just convenience wrappers around `panic_impl`.
@@ -44,16 +47,16 @@ const _: () = assert!(cfg!(panic = "abort"), "panic_immediate_abort requires -C
 /// site as much as possible (so that `panic!()` has as low an impact
 /// on (e.g.) the inlining of other functions as possible), by moving
 /// the actual formatting into this shared place.
-// If panic_immediate_abort, inline the abort call,
+// If panic=immediate-abort, inline the abort call,
 // otherwise avoid inlining because of it is cold path.
-#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold)]
-#[cfg_attr(feature = "panic_immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold)]
+#[cfg_attr(panic = "immediate_abort", inline)]
 #[track_caller]
 #[lang = "panic_fmt"] // needed for const-evaluated panics
 #[rustc_do_not_const_check] // hooked by const-eval
 #[rustc_const_stable_indirect] // must follow stable const rules since it is exposed to stable
 pub const fn panic_fmt(fmt: fmt::Arguments<'_>) -> ! {
-    if cfg!(feature = "panic_immediate_abort") {
+    if cfg!(panic = "immediate_abort") {
         super::intrinsics::abort()
     }
 
@@ -78,8 +81,8 @@ pub const fn panic_fmt(fmt: fmt::Arguments<'_>) -> ! {
 /// Like `panic_fmt`, but for non-unwinding panics.
 ///
 /// Has to be a separate function so that it can carry the `rustc_nounwind` attribute.
-#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold)]
-#[cfg_attr(feature = "panic_immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold)]
+#[cfg_attr(panic = "immediate_abort", inline)]
 #[track_caller]
 // This attribute has the key side-effect that if the panic handler ignores `can_unwind`
 // and unwinds anyway, we will hit the "unwinding out of nounwind function" guard,
@@ -94,7 +97,7 @@ pub const fn panic_nounwind_fmt(fmt: fmt::Arguments<'_>, force_no_backtrace: boo
             // We don't unwind anyway at compile-time so we can call the regular `panic_fmt`.
             panic_fmt(fmt)
         } else #[track_caller] {
-            if cfg!(feature = "panic_immediate_abort") {
+            if cfg!(panic = "immediate_abort") {
                 super::intrinsics::abort()
             }
 
@@ -123,10 +126,10 @@ pub const fn panic_nounwind_fmt(fmt: fmt::Arguments<'_>, force_no_backtrace: boo
 // above.
 
 /// The underlying implementation of core's `panic!` macro when no formatting is used.
-// Never inline unless panic_immediate_abort to avoid code
+// Never inline unless panic=immediate-abort to avoid code
 // bloat at the call sites as much as possible.
-#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold)]
-#[cfg_attr(feature = "panic_immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold)]
+#[cfg_attr(panic = "immediate_abort", inline)]
 #[track_caller]
 #[rustc_const_stable_indirect] // must follow stable const rules since it is exposed to stable
 #[lang = "panic"] // used by lints and miri for panics
@@ -158,10 +161,10 @@ macro_rules! panic_const {
         $(
             /// This is a panic called with a message that's a result of a MIR-produced Assert.
             //
-            // never inline unless panic_immediate_abort to avoid code
+            // never inline unless panic=immediate-abort to avoid code
             // bloat at the call sites as much as possible
-            #[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold)]
-            #[cfg_attr(feature = "panic_immediate_abort", inline)]
+            #[cfg_attr(not(panic = "immediate_abort"), inline(never), cold)]
+            #[cfg_attr(panic = "immediate_abort", inline)]
             #[track_caller]
             #[rustc_const_stable_indirect] // must follow stable const rules since it is exposed to stable
             #[lang = stringify!($lang)]
@@ -216,8 +219,8 @@ pub mod panic_const {
 
 /// Like `panic`, but without unwinding and track_caller to reduce the impact on codesize on the caller.
 /// If you want `#[track_caller]` for nicer errors, call `panic_nounwind_fmt` directly.
-#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold)]
-#[cfg_attr(feature = "panic_immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold)]
+#[cfg_attr(panic = "immediate_abort", inline)]
 #[lang = "panic_nounwind"] // needed by codegen for non-unwinding panics
 #[rustc_nounwind]
 #[rustc_const_stable_indirect] // must follow stable const rules since it is exposed to stable
@@ -226,8 +229,8 @@ pub const fn panic_nounwind(expr: &'static str) -> ! {
 }
 
 /// Like `panic_nounwind`, but also inhibits showing a backtrace.
-#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold)]
-#[cfg_attr(feature = "panic_immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold)]
+#[cfg_attr(panic = "immediate_abort", inline)]
 #[rustc_nounwind]
 pub fn panic_nounwind_nobacktrace(expr: &'static str) -> ! {
     panic_nounwind_fmt(fmt::Arguments::new_const(&[expr]), /* force_no_backtrace */ true);
@@ -259,25 +262,25 @@ pub const fn panic_display<T: fmt::Display>(x: &T) -> ! {
     panic_fmt(format_args!("{}", *x));
 }
 
-#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold, optimize(size))]
-#[cfg_attr(feature = "panic_immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold, optimize(size))]
+#[cfg_attr(panic = "immediate_abort", inline)]
 #[track_caller]
 #[lang = "panic_bounds_check"] // needed by codegen for panic on OOB array/slice access
 fn panic_bounds_check(index: usize, len: usize) -> ! {
-    if cfg!(feature = "panic_immediate_abort") {
+    if cfg!(panic = "immediate_abort") {
         super::intrinsics::abort()
     }
 
     panic!("index out of bounds: the len is {len} but the index is {index}")
 }
 
-#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold, optimize(size))]
-#[cfg_attr(feature = "panic_immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold, optimize(size))]
+#[cfg_attr(panic = "immediate_abort", inline)]
 #[track_caller]
 #[lang = "panic_misaligned_pointer_dereference"] // needed by codegen for panic on misaligned pointer deref
 #[rustc_nounwind] // `CheckAlignment` MIR pass requires this function to never unwind
 fn panic_misaligned_pointer_dereference(required: usize, found: usize) -> ! {
-    if cfg!(feature = "panic_immediate_abort") {
+    if cfg!(panic = "immediate_abort") {
         super::intrinsics::abort()
     }
 
@@ -289,13 +292,13 @@ fn panic_misaligned_pointer_dereference(required: usize, found: usize) -> ! {
     )
 }
 
-#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold, optimize(size))]
-#[cfg_attr(feature = "panic_immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold, optimize(size))]
+#[cfg_attr(panic = "immediate_abort", inline)]
 #[track_caller]
 #[lang = "panic_null_pointer_dereference"] // needed by codegen for panic on null pointer deref
 #[rustc_nounwind] // `CheckNull` MIR pass requires this function to never unwind
 fn panic_null_pointer_dereference() -> ! {
-    if cfg!(feature = "panic_immediate_abort") {
+    if cfg!(panic = "immediate_abort") {
         super::intrinsics::abort()
     }
 
@@ -305,13 +308,13 @@ fn panic_null_pointer_dereference() -> ! {
     )
 }
 
-#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold, optimize(size))]
-#[cfg_attr(feature = "panic_immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold, optimize(size))]
+#[cfg_attr(panic = "immediate_abort", inline)]
 #[track_caller]
 #[lang = "panic_invalid_enum_construction"] // needed by codegen for panic on invalid enum construction.
 #[rustc_nounwind] // `CheckEnums` MIR pass requires this function to never unwind
 fn panic_invalid_enum_construction(source: u128) -> ! {
-    if cfg!(feature = "panic_immediate_abort") {
+    if cfg!(panic = "immediate_abort") {
         super::intrinsics::abort()
     }
 
@@ -328,8 +331,8 @@ fn panic_invalid_enum_construction(source: u128) -> ! {
 ///
 /// This function is called directly by the codegen backend, and must not have
 /// any extra arguments (including those synthesized by track_caller).
-#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold, optimize(size))]
-#[cfg_attr(feature = "panic_immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold, optimize(size))]
+#[cfg_attr(panic = "immediate_abort", inline)]
 #[lang = "panic_cannot_unwind"] // needed by codegen for panic in nounwind function
 #[rustc_nounwind]
 fn panic_cannot_unwind() -> ! {
@@ -344,8 +347,8 @@ fn panic_cannot_unwind() -> ! {
 ///
 /// This function is called directly by the codegen backend, and must not have
 /// any extra arguments (including those synthesized by track_caller).
-#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold, optimize(size))]
-#[cfg_attr(feature = "panic_immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold, optimize(size))]
+#[cfg_attr(panic = "immediate_abort", inline)]
 #[lang = "panic_in_cleanup"] // needed by codegen for panic in nounwind function
 #[rustc_nounwind]
 fn panic_in_cleanup() -> ! {
@@ -377,8 +380,8 @@ pub enum AssertKind {
 }
 
 /// Internal function for `assert_eq!` and `assert_ne!` macros
-#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold, optimize(size))]
-#[cfg_attr(feature = "panic_immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold, optimize(size))]
+#[cfg_attr(panic = "immediate_abort", inline)]
 #[track_caller]
 #[doc(hidden)]
 pub fn assert_failed<T, U>(
@@ -395,8 +398,8 @@ where
 }
 
 /// Internal function for `assert_match!`
-#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold, optimize(size))]
-#[cfg_attr(feature = "panic_immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold, optimize(size))]
+#[cfg_attr(panic = "immediate_abort", inline)]
 #[track_caller]
 #[doc(hidden)]
 pub fn assert_matches_failed<T: fmt::Debug + ?Sized>(
@@ -415,8 +418,8 @@ pub fn assert_matches_failed<T: fmt::Debug + ?Sized>(
 }
 
 /// Non-generic version of the above functions, to avoid code bloat.
-#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold, optimize(size))]
-#[cfg_attr(feature = "panic_immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold, optimize(size))]
+#[cfg_attr(panic = "immediate_abort", inline)]
 #[track_caller]
 fn assert_failed_inner(
     kind: AssertKind,
diff --git a/library/core/src/result.rs b/library/core/src/result.rs
index 5c1f64bfe14af..742f1c19112b7 100644
--- a/library/core/src/result.rs
+++ b/library/core/src/result.rs
@@ -1847,7 +1847,7 @@ impl<T, E> Result<Result<T, E>, E> {
 }
 
 // This is a separate function to reduce the code size of the methods
-#[cfg(not(feature = "panic_immediate_abort"))]
+#[cfg(not(panic = "immediate_abort"))]
 #[inline(never)]
 #[cold]
 #[track_caller]
@@ -1859,7 +1859,7 @@ fn unwrap_failed(msg: &str, error: &dyn fmt::Debug) -> ! {
 // that gets immediately thrown away, since vtables don't get cleaned up
 // by dead code elimination if a trait object is constructed even if it goes
 // unused
-#[cfg(feature = "panic_immediate_abort")]
+#[cfg(panic = "immediate_abort")]
 #[inline]
 #[cold]
 #[track_caller]
diff --git a/library/core/src/slice/index.rs b/library/core/src/slice/index.rs
index a8147d745f3ab..c1a55c1f62a20 100644
--- a/library/core/src/slice/index.rs
+++ b/library/core/src/slice/index.rs
@@ -31,8 +31,8 @@ where
     }
 }
 
-#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold)]
-#[cfg_attr(feature = "panic_immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold)]
+#[cfg_attr(panic = "immediate_abort", inline)]
 #[track_caller]
 const fn slice_index_fail(start: usize, end: usize, len: usize) -> ! {
     if start > len {
diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs
index dfbb3628350a8..e8b2712e147c5 100644
--- a/library/core/src/slice/mod.rs
+++ b/library/core/src/slice/mod.rs
@@ -3858,8 +3858,8 @@ impl<T> [T] {
     {
         // The panic code path was put into a cold function to not bloat the
         // call site.
-        #[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold)]
-        #[cfg_attr(feature = "panic_immediate_abort", inline)]
+        #[cfg_attr(not(panic = "immediate_abort"), inline(never), cold)]
+        #[cfg_attr(panic = "immediate_abort", inline)]
         #[track_caller]
         const fn len_mismatch_fail(dst_len: usize, src_len: usize) -> ! {
             const_panic!(
diff --git a/library/core/src/slice/sort/shared/smallsort.rs b/library/core/src/slice/sort/shared/smallsort.rs
index 400daba16c1b8..17858bf9f0d01 100644
--- a/library/core/src/slice/sort/shared/smallsort.rs
+++ b/library/core/src/slice/sort/shared/smallsort.rs
@@ -840,8 +840,8 @@ unsafe fn bidirectional_merge<T: FreezeMarker, F: FnMut(&T, &T) -> bool>(
     }
 }
 
-#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold)]
-#[cfg_attr(feature = "panic_immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold)]
+#[cfg_attr(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
diff --git a/library/core/src/str/mod.rs b/library/core/src/str/mod.rs
index 04fdaa8143eff..910ea2948ee12 100644
--- a/library/core/src/str/mod.rs
+++ b/library/core/src/str/mod.rs
@@ -64,12 +64,12 @@ pub use validations::{next_code_point, utf8_char_width};
 #[cold]
 #[track_caller]
 #[rustc_allow_const_fn_unstable(const_eval_select)]
-#[cfg(not(feature = "panic_immediate_abort"))]
+#[cfg(not(panic = "immediate_abort"))]
 const fn slice_error_fail(s: &str, begin: usize, end: usize) -> ! {
     crate::intrinsics::const_eval_select((s, begin, end), slice_error_fail_ct, slice_error_fail_rt)
 }
 
-#[cfg(feature = "panic_immediate_abort")]
+#[cfg(panic = "immediate_abort")]
 const fn slice_error_fail(s: &str, begin: usize, end: usize) -> ! {
     slice_error_fail_ct(s, begin, end)
 }
diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
index d28a7f0b46022..958cafb8f3d43 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -106,11 +106,6 @@ compiler-builtins-no-f16-f128 = ["alloc/compiler-builtins-no-f16-f128"]
 llvm-libunwind = ["unwind/llvm-libunwind"]
 system-llvm-libunwind = ["unwind/system-llvm-libunwind"]
 
-# Make panics and failed asserts immediately abort without formatting any message
-panic_immediate_abort = [
-    "core/panic_immediate_abort",
-    "alloc/panic_immediate_abort",
-]
 # Choose algorithms that are optimized for binary size instead of runtime performance
 optimize_for_size = ["core/optimize_for_size", "alloc/optimize_for_size"]
 
diff --git a/library/std/src/panicking.rs b/library/std/src/panicking.rs
index 8b7282c51d123..5d52bc366bd73 100644
--- a/library/std/src/panicking.rs
+++ b/library/std/src/panicking.rs
@@ -331,7 +331,7 @@ fn default_hook(info: &PanicHookInfo<'_>) {
 
 #[cfg(not(test))]
 #[doc(hidden)]
-#[cfg(feature = "panic_immediate_abort")]
+#[cfg(panic = "immediate_abort")]
 #[unstable(feature = "update_panic_count", issue = "none")]
 pub mod panic_count {
     /// A reason for forcing an immediate abort on panic.
@@ -371,7 +371,7 @@ pub mod panic_count {
 
 #[cfg(not(test))]
 #[doc(hidden)]
-#[cfg(not(feature = "panic_immediate_abort"))]
+#[cfg(not(panic = "immediate_abort"))]
 #[unstable(feature = "update_panic_count", issue = "none")]
 pub mod panic_count {
     use crate::cell::Cell;
@@ -499,13 +499,13 @@ pub mod panic_count {
 pub use realstd::rt::panic_count;
 
 /// Invoke a closure, capturing the cause of an unwinding panic if one occurs.
-#[cfg(feature = "panic_immediate_abort")]
+#[cfg(panic = "immediate_abort")]
 pub unsafe fn catch_unwind<R, F: FnOnce() -> R>(f: F) -> Result<R, Box<dyn Any + Send>> {
     Ok(f())
 }
 
 /// Invoke a closure, capturing the cause of an unwinding panic if one occurs.
-#[cfg(not(feature = "panic_immediate_abort"))]
+#[cfg(not(panic = "immediate_abort"))]
 pub unsafe fn catch_unwind<R, F: FnOnce() -> R>(f: F) -> Result<R, Box<dyn Any + Send>> {
     union Data<F, R> {
         f: ManuallyDrop<F>,
@@ -720,14 +720,14 @@ pub fn panic_handler(info: &core::panic::PanicInfo<'_>) -> ! {
 #[unstable(feature = "libstd_sys_internals", reason = "used by the panic! macro", issue = "none")]
 #[cfg_attr(not(any(test, doctest)), lang = "begin_panic")]
 // lang item for CTFE panic support
-// never inline unless panic_immediate_abort to avoid code
+// never inline unless panic=immediate-abort to avoid code
 // bloat at the call sites as much as possible
-#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold, optimize(size))]
-#[cfg_attr(feature = "panic_immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold, optimize(size))]
+#[cfg_attr(panic = "immediate_abort", inline)]
 #[track_caller]
 #[rustc_do_not_const_check] // hooked by const-eval
 pub const fn begin_panic<M: Any + Send>(msg: M) -> ! {
-    if cfg!(feature = "panic_immediate_abort") {
+    if cfg!(panic = "immediate_abort") {
         intrinsics::abort()
     }
 
@@ -861,7 +861,7 @@ fn panic_with_hook(
 
 /// This is the entry point for `resume_unwind`.
 /// It just forwards the payload to the panic runtime.
-#[cfg_attr(feature = "panic_immediate_abort", inline)]
+#[cfg_attr(panic = "immediate_abort", inline)]
 pub fn resume_unwind(payload: Box<dyn Any + Send>) -> ! {
     panic_count::increase(false);
 
@@ -890,16 +890,14 @@ pub fn resume_unwind(payload: Box<dyn Any + Send>) -> ! {
 /// on which to slap yer breakpoints.
 #[inline(never)]
 #[cfg_attr(not(test), rustc_std_internal_symbol)]
-#[cfg(not(feature = "panic_immediate_abort"))]
+#[cfg(not(panic = "immediate_abort"))]
 fn rust_panic(msg: &mut dyn PanicPayload) -> ! {
     let code = unsafe { __rust_start_panic(msg) };
     rtabort!("failed to initiate panic, error {code}")
 }
 
 #[cfg_attr(not(test), rustc_std_internal_symbol)]
-#[cfg(feature = "panic_immediate_abort")]
+#[cfg(panic = "immediate_abort")]
 fn rust_panic(_: &mut dyn PanicPayload) -> ! {
-    unsafe {
-        crate::intrinsics::abort();
-    }
+    crate::intrinsics::abort();
 }
diff --git a/library/std/src/rt.rs b/library/std/src/rt.rs
index 8d95cc1fb5747..d98f2e692cd50 100644
--- a/library/std/src/rt.rs
+++ b/library/std/src/rt.rs
@@ -39,11 +39,11 @@ fn __rust_abort() {
 // - nothing (so this macro is a no-op)
 macro_rules! rtprintpanic {
     ($($t:tt)*) => {
-        #[cfg(not(feature = "panic_immediate_abort"))]
+        #[cfg(not(panic = "immediate_abort"))]
         if let Some(mut out) = crate::sys::stdio::panic_output() {
             let _ = crate::io::Write::write_fmt(&mut out, format_args!($($t)*));
         }
-        #[cfg(feature = "panic_immediate_abort")]
+        #[cfg(panic = "immediate_abort")]
         {
             let _ = format_args!($($t)*);
         }
diff --git a/library/std/src/thread/local.rs b/library/std/src/thread/local.rs
index 797feeb2bbb5f..b49de8d1b6084 100644
--- a/library/std/src/thread/local.rs
+++ b/library/std/src/thread/local.rs
@@ -230,7 +230,7 @@ impl fmt::Display for AccessError {
 impl Error for AccessError {}
 
 // This ensures the panicking code is outlined from `with` for `LocalKey`.
-#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never))]
+#[cfg_attr(not(panic = "immediate_abort"), inline(never))]
 #[track_caller]
 #[cold]
 fn panic_access_error(err: AccessError) -> ! {
diff --git a/library/sysroot/Cargo.toml b/library/sysroot/Cargo.toml
index 7b4aeed94e980..ee4aec61872e7 100644
--- a/library/sysroot/Cargo.toml
+++ b/library/sysroot/Cargo.toml
@@ -31,7 +31,6 @@ llvm-libunwind = ["std/llvm-libunwind"]
 system-llvm-libunwind = ["std/system-llvm-libunwind"]
 optimize_for_size = ["std/optimize_for_size"]
 panic-unwind = ["std/panic-unwind"]
-panic_immediate_abort = ["std/panic_immediate_abort"]
 profiler = ["dep:profiler_builtins"]
 std_detect_file_io = ["std/std_detect_file_io"]
 std_detect_dlsym_getauxval = ["std/std_detect_dlsym_getauxval"]
diff --git a/src/doc/rustc/src/codegen-options/index.md b/src/doc/rustc/src/codegen-options/index.md
index 445b10188e3f8..0e340de4daa27 100644
--- a/src/doc/rustc/src/codegen-options/index.md
+++ b/src/doc/rustc/src/codegen-options/index.md
@@ -471,11 +471,13 @@ If not specified, overflow checks are enabled if
 This option lets you control what happens when the code panics.
 
 * `abort`: terminate the process upon panic
+* `immediate-abort`: terminate the process upon panic, and do not call any panic hooks
 * `unwind`: unwind the stack upon panic
 
 If not specified, the default depends on the target.
 
 If any crate in the crate graph uses `abort`, the final binary (`bin`, `dylib`, `cdylib`, `staticlib`) must also use `abort`.
+If any crate in the crate graph uses `immediate-abort`, every crate in the graph must use `immediate-abort`.
 If `std` is used as a `dylib` with `unwind`, the final binary must also use `unwind`.
 
 ## passes
diff --git a/src/tools/compiletest/src/directives.rs b/src/tools/compiletest/src/directives.rs
index 1277fd225eb66..e84a22787668d 100644
--- a/src/tools/compiletest/src/directives.rs
+++ b/src/tools/compiletest/src/directives.rs
@@ -201,6 +201,8 @@ pub struct TestProps {
     /// Build and use `minicore` as `core` stub for `no_core` tests in cross-compilation scenarios
     /// that don't otherwise want/need `-Z build-std`.
     pub add_core_stubs: bool,
+    /// Add these flags to the build of `minicore`.
+    pub core_stubs_compile_flags: Vec<String>,
     /// Whether line annotatins are required for the given error kind.
     pub dont_require_annotations: HashSet<ErrorKind>,
     /// Whether pretty printers should be disabled in gdb.
@@ -253,6 +255,7 @@ mod directives {
     pub const FILECHECK_FLAGS: &'static str = "filecheck-flags";
     pub const NO_AUTO_CHECK_CFG: &'static str = "no-auto-check-cfg";
     pub const ADD_CORE_STUBS: &'static str = "add-core-stubs";
+    pub const CORE_STUBS_COMPILE_FLAGS: &'static str = "core-stubs-compile-flags";
     // This isn't a real directive, just one that is probably mistyped often
     pub const INCORRECT_COMPILER_FLAGS: &'static str = "compiler-flags";
     pub const DISABLE_GDB_PRETTY_PRINTERS: &'static str = "disable-gdb-pretty-printers";
@@ -311,6 +314,7 @@ impl TestProps {
             no_auto_check_cfg: false,
             has_enzyme: false,
             add_core_stubs: false,
+            core_stubs_compile_flags: vec![],
             dont_require_annotations: Default::default(),
             disable_gdb_pretty_printers: false,
             compare_output_by_lines: false,
@@ -653,6 +657,21 @@ impl TestProps {
 
                     self.update_add_core_stubs(ln, config);
 
+                    if let Some(flags) = config.parse_name_value_directive(
+                        ln,
+                        directives::CORE_STUBS_COMPILE_FLAGS,
+                        testfile,
+                        line_number,
+                    ) {
+                        let flags = split_flags(&flags);
+                        for flag in &flags {
+                            if flag == "--edition" || flag.starts_with("--edition=") {
+                                panic!("you must use `//@ edition` to configure the edition");
+                            }
+                        }
+                        self.core_stubs_compile_flags.extend(flags);
+                    }
+
                     if let Some(err_kind) = config.parse_name_value_directive(
                         ln,
                         DONT_REQUIRE_ANNOTATIONS,
diff --git a/src/tools/compiletest/src/directives/directive_names.rs b/src/tools/compiletest/src/directives/directive_names.rs
index 0ef84fb459493..4fef899256739 100644
--- a/src/tools/compiletest/src/directives/directive_names.rs
+++ b/src/tools/compiletest/src/directives/directive_names.rs
@@ -19,6 +19,7 @@ pub(crate) const KNOWN_DIRECTIVE_NAMES: &[&str] = &[
     "check-test-line-numbers-match",
     "compare-output-by-lines",
     "compile-flags",
+    "core-stubs-compile-flags",
     "disable-gdb-pretty-printers",
     "doc-flags",
     "dont-check-compiler-stderr",
diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index 89fb8eb4357b7..29578acb40400 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -1322,6 +1322,7 @@ impl<'test> TestCx<'test> {
 
         rustc.args(&["--crate-type", "rlib"]);
         rustc.arg("-Cpanic=abort");
+        rustc.args(self.props.core_stubs_compile_flags.clone());
 
         let res = self.compose_and_run(rustc, self.config.compile_lib_path.as_path(), None, None);
         if !res.status.success() {
@@ -1432,6 +1433,12 @@ impl<'test> TestCx<'test> {
 
         aux_rustc.arg("-L").arg(&aux_dir);
 
+        if aux_props.add_core_stubs {
+            let minicore_path = self.build_minicore();
+            aux_rustc.arg("--extern");
+            aux_rustc.arg(&format!("minicore={}", minicore_path));
+        }
+
         let auxres = aux_cx.compose_and_run(
             aux_rustc,
             aux_cx.config.compile_lib_path.as_path(),
@@ -1858,14 +1865,13 @@ impl<'test> TestCx<'test> {
             }
         }
 
-        rustc.args(&self.props.compile_flags);
-
         // FIXME(jieyouxu): we should report a fatal error or warning if user wrote `-Cpanic=` with
-        // something that's not `abort` and `-Cforce-unwind-tables` with a value that is not `yes`,
-        // however, by moving this last we should override previous `-Cpanic`s and
-        // `-Cforce-unwind-tables`s. Note that checking here is very fragile, because we'd have to
-        // account for all possible compile flag splittings (they have some... intricacies and are
-        // not yet normalized).
+        // something that's not `abort` and `-Cforce-unwind-tables` with a value that is not `yes`.
+        //
+        // We could apply these last and override any provided flags. That would ensure that the
+        // build works, but some tests want to exercise that mixing panic modes in specific ways is
+        // rejected. So we enable aborting panics and unwind tables before adding flags, just to
+        // change the default.
         //
         // `minicore` requires `#![no_std]` and `#![no_core]`, which means no unwinding panics.
         if self.props.add_core_stubs {
@@ -1873,6 +1879,8 @@ impl<'test> TestCx<'test> {
             rustc.arg("-Cforce-unwind-tables=yes");
         }
 
+        rustc.args(&self.props.compile_flags);
+
         rustc
     }
 
diff --git a/tests/run-make-cargo/panic-immediate-abort-codegen/Cargo.toml b/tests/run-make-cargo/panic-immediate-abort-codegen/Cargo.toml
new file mode 100644
index 0000000000000..3c61c12a84ede
--- /dev/null
+++ b/tests/run-make-cargo/panic-immediate-abort-codegen/Cargo.toml
@@ -0,0 +1,12 @@
+cargo-features = ["profile-rustflags"]
+
+[package]
+name = "panic_scenarios"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+path = "lib.rs"
+
+[profile.release]
+rustflags = ["-Zmerge-functions=disabled", "-Zcodegen-source-order", "--emit=llvm-ir"]
diff --git a/tests/run-make-cargo/panic-immediate-abort-codegen/lib.rs b/tests/run-make-cargo/panic-immediate-abort-codegen/lib.rs
new file mode 100644
index 0000000000000..1e20da93ba805
--- /dev/null
+++ b/tests/run-make-cargo/panic-immediate-abort-codegen/lib.rs
@@ -0,0 +1,65 @@
+#![no_std]
+
+#[unsafe(no_mangle)]
+pub fn panic_noarg() {
+    // CHECK-LABEL: @panic_noarg(
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: tail call void @llvm.trap()
+    panic!();
+}
+
+#[unsafe(no_mangle)]
+pub fn panic_str() {
+    // CHECK-LABEL: @panic_str(
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: tail call void @llvm.trap()
+    panic!("ouch");
+}
+
+#[unsafe(no_mangle)]
+pub fn bounds_check(x: &[u8], idx: usize) -> &u8 {
+    // CHECK-LABEL: @bounds_check(
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: icmp ult
+    // CHECK-NEXT: br i1
+    // CHECK: bb1:
+    // CHECK-NEXT: getelementptr inbounds nuw i8
+    // CHECK-NEXT: ret ptr
+    // CHECK: panic:
+    // CHECK-NEXT: tail call void @llvm.trap()
+    &x[idx]
+}
+
+#[unsafe(no_mangle)]
+pub fn str_bounds_check(x: &str, idx: usize) -> &str {
+    // CHECK-LABEL: @str_bounds_check(
+    // CHECK-NOT: call
+    // CHECK: tail call void @llvm.trap()
+    // CHECK-NOT: call
+    &x[idx..]
+}
+
+#[unsafe(no_mangle)]
+pub fn unsigned_integer_div(x: u16, y: u16) -> u16 {
+    // CHECK-LABEL: @unsigned_integer_div(
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: icmp eq i16
+    // CHECK-NEXT: br i1
+    // CHECK: bb1:
+    // CHECK-NEXT: udiv i16
+    // CHECK-NEXT: ret i16
+    // CHECK: panic:
+    // CHECK-NEXT: tail call void @llvm.trap()
+    x / y
+}
+
+#[unsafe(no_mangle)]
+pub fn refcell_already_borrowed() {
+    // CHECK-LABEL: @refcell_already_borrowed(
+    // CHECK-NOT: call
+    // CHECK: tail call void @llvm.trap()
+    // CHECK-NOT: call
+    let r = core::cell::RefCell::new(0u8);
+    let _guard = r.borrow_mut();
+    r.borrow_mut();
+}
diff --git a/tests/run-make-cargo/panic-immediate-abort-codegen/rmake.rs b/tests/run-make-cargo/panic-immediate-abort-codegen/rmake.rs
new file mode 100644
index 0000000000000..e91d1db83d1d1
--- /dev/null
+++ b/tests/run-make-cargo/panic-immediate-abort-codegen/rmake.rs
@@ -0,0 +1,41 @@
+#![deny(warnings)]
+
+use run_make_support::{cargo, llvm_filecheck, path, rfs, target};
+
+fn main() {
+    let target_dir = path("target");
+
+    cargo()
+        .args(&[
+            "build",
+            "--release",
+            "--lib",
+            "--manifest-path",
+            "Cargo.toml",
+            "-Zbuild-std=core",
+            "--target",
+            &target(),
+        ])
+        .env("RUSTFLAGS", "-Zunstable-options -Cpanic=immediate-abort")
+        .env("CARGO_TARGET_DIR", &target_dir)
+        .env("RUSTC_BOOTSTRAP", "1")
+        // Visual Studio 2022 requires that the LIB env var be set so it can
+        // find the Windows SDK.
+        .env("LIB", std::env::var("LIB").unwrap_or_default())
+        .run();
+
+    let out_dir = target_dir.join(target()).join("release").join("deps");
+    let ir_file = rfs::read_dir(out_dir)
+        .find_map(|e| {
+            let path = e.unwrap().path();
+            let file_name = path.file_name().unwrap().to_str().unwrap();
+            if file_name.starts_with("panic_scenarios") && file_name.ends_with(".ll") {
+                Some(path)
+            } else {
+                None
+            }
+        })
+        .unwrap();
+
+    llvm_filecheck().patterns("lib.rs").input_file(ir_file).run();
+}
diff --git a/tests/run-make-cargo/panic-immediate-abort-works/hello/Cargo.toml b/tests/run-make-cargo/panic-immediate-abort-works/hello/Cargo.toml
new file mode 100644
index 0000000000000..1e278d557c082
--- /dev/null
+++ b/tests/run-make-cargo/panic-immediate-abort-works/hello/Cargo.toml
@@ -0,0 +1,4 @@
+[package]
+name = "hello"
+version = "0.1.0"
+edition = "2024"
diff --git a/tests/run-make-cargo/panic-immediate-abort-works/hello/src/main.rs b/tests/run-make-cargo/panic-immediate-abort-works/hello/src/main.rs
new file mode 100644
index 0000000000000..f328e4d9d04c3
--- /dev/null
+++ b/tests/run-make-cargo/panic-immediate-abort-works/hello/src/main.rs
@@ -0,0 +1 @@
+fn main() {}
diff --git a/tests/run-make-cargo/panic-immediate-abort-works/rmake.rs b/tests/run-make-cargo/panic-immediate-abort-works/rmake.rs
new file mode 100644
index 0000000000000..a3c5877a6a19d
--- /dev/null
+++ b/tests/run-make-cargo/panic-immediate-abort-works/rmake.rs
@@ -0,0 +1,28 @@
+//@ needs-target-std
+
+#![deny(warnings)]
+
+use run_make_support::{cargo, path, target};
+
+fn main() {
+    let target_dir = path("target");
+
+    cargo()
+        .current_dir("hello")
+        .args(&[
+            "build",
+            "--release",
+            "--manifest-path",
+            "Cargo.toml",
+            "-Zbuild-std",
+            "--target",
+            &target(),
+        ])
+        .env("RUSTFLAGS", "-Zunstable-options -Cpanic=immediate-abort")
+        .env("CARGO_TARGET_DIR", &target_dir)
+        .env("RUSTC_BOOTSTRAP", "1")
+        // Visual Studio 2022 requires that the LIB env var be set so it can
+        // find the Windows SDK.
+        .env("LIB", std::env::var("LIB").unwrap_or_default())
+        .run();
+}
diff --git a/tests/ui/check-cfg/report-in-external-macros.cargo.stderr b/tests/ui/check-cfg/report-in-external-macros.cargo.stderr
index 989a01f224412..b99ce169b8900 100644
--- a/tests/ui/check-cfg/report-in-external-macros.cargo.stderr
+++ b/tests/ui/check-cfg/report-in-external-macros.cargo.stderr
@@ -18,7 +18,7 @@ warning: unexpected `cfg` condition value: `UNEXPECTED_VALUE`
 LL |     cfg_macro::my_lib_macro_value!();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: expected values for `panic` are: `abort` and `unwind`
+   = note: expected values for `panic` are: `abort`, `immediate_abort`, and `unwind`
    = note: using a cfg inside a macro will use the cfgs from the destination crate and not the ones from the defining crate
    = help: try referring to `cfg_macro::my_lib_macro_value` crate for guidance on how handle this unexpected cfg
    = help: the macro `cfg_macro::my_lib_macro_value` may come from an old version of the `cfg_macro` crate, try updating your dependency with `cargo update -p cfg_macro`
diff --git a/tests/ui/check-cfg/report-in-external-macros.rustc.stderr b/tests/ui/check-cfg/report-in-external-macros.rustc.stderr
index 95d10e014f33b..8e1760bd969a7 100644
--- a/tests/ui/check-cfg/report-in-external-macros.rustc.stderr
+++ b/tests/ui/check-cfg/report-in-external-macros.rustc.stderr
@@ -18,7 +18,7 @@ warning: unexpected `cfg` condition value: `UNEXPECTED_VALUE`
 LL |     cfg_macro::my_lib_macro_value!();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: expected values for `panic` are: `abort` and `unwind`
+   = note: expected values for `panic` are: `abort`, `immediate_abort`, and `unwind`
    = note: using a cfg inside a macro will use the cfgs from the destination crate and not the ones from the defining crate
    = help: try referring to `cfg_macro::my_lib_macro_value` crate for guidance on how handle this unexpected cfg
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
diff --git a/tests/ui/check-cfg/well-known-values.stderr b/tests/ui/check-cfg/well-known-values.stderr
index 6490fc63fd766..c34c20b172d50 100644
--- a/tests/ui/check-cfg/well-known-values.stderr
+++ b/tests/ui/check-cfg/well-known-values.stderr
@@ -80,7 +80,7 @@ warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
 LL |     panic = "_UNEXPECTED_VALUE",
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: expected values for `panic` are: `abort` and `unwind`
+   = note: expected values for `panic` are: `abort`, `immediate_abort`, and `unwind`
    = 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/panic-runtime/auxiliary/needs-abort.rs b/tests/ui/panic-runtime/auxiliary/needs-abort.rs
index 21f862e4b431c..cba4907dbb633 100644
--- a/tests/ui/panic-runtime/auxiliary/needs-abort.rs
+++ b/tests/ui/panic-runtime/auxiliary/needs-abort.rs
@@ -1,5 +1,7 @@
 //@ compile-flags:-C panic=abort
 //@ no-prefer-dynamic
 
+#![feature(no_core)]
 #![crate_type = "rlib"]
 #![no_std]
+#![no_core]
diff --git a/tests/ui/panic-runtime/auxiliary/needs-immediate-abort.rs b/tests/ui/panic-runtime/auxiliary/needs-immediate-abort.rs
new file mode 100644
index 0000000000000..4a41d16faa080
--- /dev/null
+++ b/tests/ui/panic-runtime/auxiliary/needs-immediate-abort.rs
@@ -0,0 +1,7 @@
+//@ compile-flags:-C panic=immediate-abort -Zunstable-options
+//@ no-prefer-dynamic
+
+#![feature(no_core)]
+#![crate_type = "rlib"]
+#![no_std]
+#![no_core]
diff --git a/tests/ui/panic-runtime/auxiliary/needs-unwind-immediate-abort.rs b/tests/ui/panic-runtime/auxiliary/needs-unwind-immediate-abort.rs
new file mode 100644
index 0000000000000..295876fec5279
--- /dev/null
+++ b/tests/ui/panic-runtime/auxiliary/needs-unwind-immediate-abort.rs
@@ -0,0 +1,18 @@
+//@ compile-flags:-C panic=unwind
+//@ no-prefer-dynamic
+//@ add-core-stubs
+
+#![crate_type = "rlib"]
+#![feature(no_core)]
+#![no_std]
+#![no_core]
+
+extern crate minicore;
+
+extern "C-unwind" fn foo() {}
+
+#[inline]
+fn bar() {
+    let ptr: extern "C-unwind" fn() = foo;
+    ptr();
+}
diff --git a/tests/ui/panic-runtime/bad-panic-flag1.rs b/tests/ui/panic-runtime/bad-panic-flag1.rs
index 117935847cbd7..575e30f785cf5 100644
--- a/tests/ui/panic-runtime/bad-panic-flag1.rs
+++ b/tests/ui/panic-runtime/bad-panic-flag1.rs
@@ -2,4 +2,4 @@
 
 fn main() {}
 
-//~? ERROR incorrect value `foo` for codegen option `panic` - either `unwind` or `abort` was expected
+//~? ERROR incorrect value `foo` for codegen option `panic` - either `unwind`, `abort`, or `immediate-abort` was expected
diff --git a/tests/ui/panic-runtime/bad-panic-flag1.stderr b/tests/ui/panic-runtime/bad-panic-flag1.stderr
index 013373c6f9313..c30598bba538e 100644
--- a/tests/ui/panic-runtime/bad-panic-flag1.stderr
+++ b/tests/ui/panic-runtime/bad-panic-flag1.stderr
@@ -1,2 +1,2 @@
-error: incorrect value `foo` for codegen option `panic` - either `unwind` or `abort` was expected
+error: incorrect value `foo` for codegen option `panic` - either `unwind`, `abort`, or `immediate-abort` was expected
 
diff --git a/tests/ui/panic-runtime/bad-panic-flag2.rs b/tests/ui/panic-runtime/bad-panic-flag2.rs
index b5d0442a03326..4e34da217d7d2 100644
--- a/tests/ui/panic-runtime/bad-panic-flag2.rs
+++ b/tests/ui/panic-runtime/bad-panic-flag2.rs
@@ -2,4 +2,4 @@
 
 fn main() {}
 
-//~? ERROR codegen option `panic` requires either `unwind` or `abort`
+//~? ERROR codegen option `panic` requires either `unwind`, `abort`, or `immediate-abort`
diff --git a/tests/ui/panic-runtime/bad-panic-flag2.stderr b/tests/ui/panic-runtime/bad-panic-flag2.stderr
index 6ab94ea704d30..c8d12749c5d96 100644
--- a/tests/ui/panic-runtime/bad-panic-flag2.stderr
+++ b/tests/ui/panic-runtime/bad-panic-flag2.stderr
@@ -1,2 +1,2 @@
-error: codegen option `panic` requires either `unwind` or `abort` (C panic=<value>)
+error: codegen option `panic` requires either `unwind`, `abort`, or `immediate-abort` (C panic=<value>)
 
diff --git a/tests/ui/panic-runtime/immediate-abort-default-sysroot.rs b/tests/ui/panic-runtime/immediate-abort-default-sysroot.rs
new file mode 100644
index 0000000000000..94dc7c5671ead
--- /dev/null
+++ b/tests/ui/panic-runtime/immediate-abort-default-sysroot.rs
@@ -0,0 +1,15 @@
+//@ build-fail
+//@ aux-build:needs-unwind.rs
+//@ compile-flags:-C panic=immediate-abort -Zunstable-options
+//@ no-prefer-dynamic
+
+extern crate needs_unwind;
+
+// immediate-abort does not require any panic runtime, so trying to build a binary crate with
+// panic=immediate-abort and the precompiled sysroot will fail to link, because no panic runtime
+// provides the panic entrypoints used by sysroot crates.
+// This test ensures that we get a clean compile error instead of a linker error.
+
+fn main() {}
+
+//~? ERROR the crate `core` was compiled with a panic strategy which is incompatible with `immediate-abort`
diff --git a/tests/ui/panic-runtime/immediate-abort-default-sysroot.stderr b/tests/ui/panic-runtime/immediate-abort-default-sysroot.stderr
new file mode 100644
index 0000000000000..bd6bdd8b6673a
--- /dev/null
+++ b/tests/ui/panic-runtime/immediate-abort-default-sysroot.stderr
@@ -0,0 +1,4 @@
+error: the crate `core` was compiled with a panic strategy which is incompatible with `immediate-abort`
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/panic-runtime/need-abort-got-immediate-abort.rs b/tests/ui/panic-runtime/need-abort-got-immediate-abort.rs
new file mode 100644
index 0000000000000..78977c60be985
--- /dev/null
+++ b/tests/ui/panic-runtime/need-abort-got-immediate-abort.rs
@@ -0,0 +1,21 @@
+//@ build-fail
+//@ aux-build:needs-abort.rs
+//@ compile-flags:-Cpanic=immediate-abort -Zunstable-options
+//@ no-prefer-dynamic
+//@ add-core-stubs
+//@ core-stubs-compile-flags: -Cpanic=immediate-abort -Zunstable-options
+
+#![feature(no_core)]
+#![no_std]
+#![no_main]
+#![no_core]
+
+extern crate minicore;
+extern crate needs_abort;
+
+#[no_mangle]
+extern "C" fn main(_argc: i32, _argv: *const *const u8) -> i32 {
+    0
+}
+
+//~? ERROR the crate `needs_abort` was compiled with a panic strategy which is incompatible with `immediate-abort`
diff --git a/tests/ui/panic-runtime/need-abort-got-immediate-abort.stderr b/tests/ui/panic-runtime/need-abort-got-immediate-abort.stderr
new file mode 100644
index 0000000000000..65a26b676b92e
--- /dev/null
+++ b/tests/ui/panic-runtime/need-abort-got-immediate-abort.stderr
@@ -0,0 +1,4 @@
+error: the crate `needs_abort` was compiled with a panic strategy which is incompatible with `immediate-abort`
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/panic-runtime/need-immediate-abort-got-abort.rs b/tests/ui/panic-runtime/need-immediate-abort-got-abort.rs
new file mode 100644
index 0000000000000..1c5f597a3f992
--- /dev/null
+++ b/tests/ui/panic-runtime/need-immediate-abort-got-abort.rs
@@ -0,0 +1,20 @@
+//@ build-fail
+//@ aux-build:needs-immediate-abort.rs
+//@ compile-flags:-C panic=abort
+//@ no-prefer-dynamic
+//@ add-core-stubs
+//@ core-stubs-compile-flags: -Zunstable-options -Cpanic=immediate-abort
+
+#![feature(no_core)]
+#![no_std]
+#![no_main]
+#![no_core]
+
+extern crate minicore;
+extern crate needs_immediate_abort;
+
+extern "C" fn main(argc: i32, argv: *const *const u8) -> i32 {
+    0
+}
+
+//~? ERROR the crate `need_immediate_abort_got_abort` was compiled with a panic strategy which is incompatible with `immediate-abort`
diff --git a/tests/ui/panic-runtime/need-immediate-abort-got-abort.stderr b/tests/ui/panic-runtime/need-immediate-abort-got-abort.stderr
new file mode 100644
index 0000000000000..8dcf120cb9f46
--- /dev/null
+++ b/tests/ui/panic-runtime/need-immediate-abort-got-abort.stderr
@@ -0,0 +1,4 @@
+error: the crate `need_immediate_abort_got_abort` was compiled with a panic strategy which is incompatible with `immediate-abort`
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/panic-runtime/need-immediate-abort-got-unwind.rs b/tests/ui/panic-runtime/need-immediate-abort-got-unwind.rs
new file mode 100644
index 0000000000000..24d521230d49a
--- /dev/null
+++ b/tests/ui/panic-runtime/need-immediate-abort-got-unwind.rs
@@ -0,0 +1,20 @@
+//@ build-fail
+//@ needs-unwind
+//@ aux-build:needs-immediate-abort.rs
+//@ no-prefer-dynamic
+//@ add-core-stubs
+//@ core-stubs-compile-flags: -Zunstable-options -Cpanic=immediate-abort
+
+#![feature(no_core)]
+#![no_std]
+#![no_main]
+#![no_core]
+
+extern crate minicore;
+extern crate needs_immediate_abort;
+
+extern "C" fn main(argc: i32, argv: *const *const u8) -> i32 {
+    0
+}
+
+//~? ERROR the crate `need_immediate_abort_got_unwind` was compiled with a panic strategy which is incompatible with `immediate-abort`
diff --git a/tests/ui/panic-runtime/need-immediate-abort-got-unwind.stderr b/tests/ui/panic-runtime/need-immediate-abort-got-unwind.stderr
new file mode 100644
index 0000000000000..740fc80a77df8
--- /dev/null
+++ b/tests/ui/panic-runtime/need-immediate-abort-got-unwind.stderr
@@ -0,0 +1,4 @@
+error: the crate `need_immediate_abort_got_unwind` was compiled with a panic strategy which is incompatible with `immediate-abort`
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/panic-runtime/need-unwind-got-immediate-abort.rs b/tests/ui/panic-runtime/need-unwind-got-immediate-abort.rs
new file mode 100644
index 0000000000000..5aec028a46cf7
--- /dev/null
+++ b/tests/ui/panic-runtime/need-unwind-got-immediate-abort.rs
@@ -0,0 +1,21 @@
+//@ build-fail
+//@ aux-build:needs-unwind-immediate-abort.rs
+//@ compile-flags:-C panic=immediate-abort -Zunstable-options
+//@ no-prefer-dynamic
+//@ add-core-stubs
+//@ core-stubs-compile-flags: -Zunstable-options -Cpanic=immediate-abort
+
+#![feature(no_core)]
+#![no_std]
+#![no_main]
+#![no_core]
+
+extern crate minicore;
+extern crate needs_unwind_immediate_abort;
+
+#[no_mangle]
+extern "C" fn main(_argc: i32, _argv: *const *const u8) -> i32 {
+    0
+}
+
+//~? ERROR the crate `needs_unwind_immediate_abort` was compiled with a panic strategy which is incompatible with `immediate-abort`
diff --git a/tests/ui/panic-runtime/need-unwind-got-immediate-abort.stderr b/tests/ui/panic-runtime/need-unwind-got-immediate-abort.stderr
new file mode 100644
index 0000000000000..8b3747d644f13
--- /dev/null
+++ b/tests/ui/panic-runtime/need-unwind-got-immediate-abort.stderr
@@ -0,0 +1,4 @@
+error: the crate `needs_unwind_immediate_abort` was compiled with a panic strategy which is incompatible with `immediate-abort`
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/proc-macro/panic-abort.rs b/tests/ui/proc-macro/panic-abort.rs
index 58e1d00643309..adedba4ebca61 100644
--- a/tests/ui/proc-macro/panic-abort.rs
+++ b/tests/ui/proc-macro/panic-abort.rs
@@ -2,4 +2,4 @@
 //@ force-host
 //@ check-pass
 
-//~? WARN building proc macro crate with `panic=abort` may crash the compiler should the proc-macro panic
+//~? WARN building proc macro crate with `panic=abort` or `panic=immediate-abort` may crash the compiler should the proc-macro panic
diff --git a/tests/ui/proc-macro/panic-abort.stderr b/tests/ui/proc-macro/panic-abort.stderr
index a6e18614f8f06..3dd75768bc4ab 100644
--- a/tests/ui/proc-macro/panic-abort.stderr
+++ b/tests/ui/proc-macro/panic-abort.stderr
@@ -1,4 +1,4 @@
-warning: building proc macro crate with `panic=abort` may crash the compiler should the proc-macro panic
+warning: building proc macro crate with `panic=abort` or `panic=immediate-abort` may crash the compiler should the proc-macro panic
 
 warning: 1 warning emitted
 

From df58fd8cf7710f7516c541769a141f0235978dab Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Thu, 18 Sep 2025 10:48:18 -0400
Subject: [PATCH 1227/1889] Change the cfg to a dash

---
 compiler/rustc_span/src/symbol.rs             |  2 +-
 library/alloc/src/alloc.rs                    |  4 +-
 library/alloc/src/raw_vec/mod.rs              |  2 +-
 library/alloc/src/vec/mod.rs                  |  8 +--
 library/core/src/cell.rs                      |  4 +-
 library/core/src/num/mod.rs                   |  4 +-
 library/core/src/option.rs                    |  8 +--
 library/core/src/panicking.rs                 | 72 +++++++++----------
 library/core/src/result.rs                    |  4 +-
 library/core/src/slice/index.rs               |  4 +-
 library/core/src/slice/mod.rs                 |  4 +-
 .../core/src/slice/sort/shared/smallsort.rs   |  4 +-
 library/core/src/str/mod.rs                   |  4 +-
 library/std/src/panicking.rs                  | 20 +++---
 library/std/src/rt.rs                         |  4 +-
 library/std/src/thread/local.rs               |  2 +-
 .../report-in-external-macros.cargo.stderr    |  2 +-
 .../report-in-external-macros.rustc.stderr    |  2 +-
 tests/ui/check-cfg/well-known-values.stderr   |  2 +-
 19 files changed, 78 insertions(+), 78 deletions(-)

diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index efeb4371e4ca6..a2840828b19b6 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1195,7 +1195,7 @@ symbols! {
         if_let_rescope,
         if_while_or_patterns,
         ignore,
-        immediate_abort,
+        immediate_abort: "immediate-abort",
         impl_header_lifetime_elision,
         impl_lint_pass,
         impl_trait_in_assoc_type,
diff --git a/library/alloc/src/alloc.rs b/library/alloc/src/alloc.rs
index 304b473f14df7..65c8206e9d462 100644
--- a/library/alloc/src/alloc.rs
+++ b/library/alloc/src/alloc.rs
@@ -408,12 +408,12 @@ pub const fn handle_alloc_error(layout: Layout) -> ! {
         }
     }
 
-    #[cfg(not(panic = "immediate_abort"))]
+    #[cfg(not(panic = "immediate-abort"))]
     {
         core::intrinsics::const_eval_select((layout,), ct_error, rt_error)
     }
 
-    #[cfg(panic = "immediate_abort")]
+    #[cfg(panic = "immediate-abort")]
     ct_error(layout)
 }
 
diff --git a/library/alloc/src/raw_vec/mod.rs b/library/alloc/src/raw_vec/mod.rs
index 4853b84a01a32..b7c153b825dfd 100644
--- a/library/alloc/src/raw_vec/mod.rs
+++ b/library/alloc/src/raw_vec/mod.rs
@@ -23,7 +23,7 @@ mod tests;
 // ensure that the code generation related to these panics is minimal as there's
 // only one location which panics rather than a bunch throughout the module.
 #[cfg(not(no_global_oom_handling))]
-#[cfg_attr(not(panic = "immediate_abort"), inline(never))]
+#[cfg_attr(not(panic = "immediate-abort"), inline(never))]
 #[track_caller]
 fn capacity_overflow() -> ! {
     panic!("capacity overflow");
diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs
index 1a9041290ef17..ebdb86f98a857 100644
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -2020,7 +2020,7 @@ impl<T, A: Allocator> Vec<T, A> {
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn swap_remove(&mut self, index: usize) -> T {
         #[cold]
-        #[cfg_attr(not(panic = "immediate_abort"), inline(never))]
+        #[cfg_attr(not(panic = "immediate-abort"), inline(never))]
         #[track_caller]
         #[optimize(size)]
         fn assert_failed(index: usize, len: usize) -> ! {
@@ -2102,7 +2102,7 @@ impl<T, A: Allocator> Vec<T, A> {
     #[must_use = "if you don't need a reference to the value, use `Vec::insert` instead"]
     pub fn insert_mut(&mut self, index: usize, element: T) -> &mut T {
         #[cold]
-        #[cfg_attr(not(panic = "immediate_abort"), inline(never))]
+        #[cfg_attr(not(panic = "immediate-abort"), inline(never))]
         #[track_caller]
         #[optimize(size)]
         fn assert_failed(index: usize, len: usize) -> ! {
@@ -2166,7 +2166,7 @@ impl<T, A: Allocator> Vec<T, A> {
     #[rustc_confusables("delete", "take")]
     pub fn remove(&mut self, index: usize) -> T {
         #[cold]
-        #[cfg_attr(not(panic = "immediate_abort"), inline(never))]
+        #[cfg_attr(not(panic = "immediate-abort"), inline(never))]
         #[track_caller]
         #[optimize(size)]
         fn assert_failed(index: usize, len: usize) -> ! {
@@ -2955,7 +2955,7 @@ impl<T, A: Allocator> Vec<T, A> {
         A: Clone,
     {
         #[cold]
-        #[cfg_attr(not(panic = "immediate_abort"), inline(never))]
+        #[cfg_attr(not(panic = "immediate-abort"), inline(never))]
         #[track_caller]
         #[optimize(size)]
         fn assert_failed(at: usize, len: usize) -> ! {
diff --git a/library/core/src/cell.rs b/library/core/src/cell.rs
index d7097e3b6fd4e..7d4a66640b106 100644
--- a/library/core/src/cell.rs
+++ b/library/core/src/cell.rs
@@ -778,7 +778,7 @@ impl Display for BorrowMutError {
 }
 
 // This ensures the panicking code is outlined from `borrow_mut` for `RefCell`.
-#[cfg_attr(not(panic = "immediate_abort"), inline(never))]
+#[cfg_attr(not(panic = "immediate-abort"), inline(never))]
 #[track_caller]
 #[cold]
 const fn panic_already_borrowed(err: BorrowMutError) -> ! {
@@ -790,7 +790,7 @@ const fn panic_already_borrowed(err: BorrowMutError) -> ! {
 }
 
 // This ensures the panicking code is outlined from `borrow` for `RefCell`.
-#[cfg_attr(not(panic = "immediate_abort"), inline(never))]
+#[cfg_attr(not(panic = "immediate-abort"), inline(never))]
 #[track_caller]
 #[cold]
 const fn panic_already_mutably_borrowed(err: BorrowError) -> ! {
diff --git a/library/core/src/num/mod.rs b/library/core/src/num/mod.rs
index 3c4bfe28aa326..c75ee11d15efe 100644
--- a/library/core/src/num/mod.rs
+++ b/library/core/src/num/mod.rs
@@ -1387,8 +1387,8 @@ pub const fn can_not_overflow<T>(radix: u32, is_signed_ty: bool, digits: &[u8])
     radix <= 16 && digits.len() <= size_of::<T>() * 2 - is_signed_ty as usize
 }
 
-#[cfg_attr(not(panic = "immediate_abort"), inline(never))]
-#[cfg_attr(panic = "immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate-abort"), inline(never))]
+#[cfg_attr(panic = "immediate-abort", inline)]
 #[cold]
 #[track_caller]
 const fn from_ascii_radix_panic(radix: u32) -> ! {
diff --git a/library/core/src/option.rs b/library/core/src/option.rs
index 10eec2cdfb6cf..430ee3470ac3f 100644
--- a/library/core/src/option.rs
+++ b/library/core/src/option.rs
@@ -2161,8 +2161,8 @@ impl<T, E> Option<Result<T, E>> {
     }
 }
 
-#[cfg_attr(not(panic = "immediate_abort"), inline(never))]
-#[cfg_attr(panic = "immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate-abort"), inline(never))]
+#[cfg_attr(panic = "immediate-abort", inline)]
 #[cold]
 #[track_caller]
 const fn unwrap_failed() -> ! {
@@ -2170,8 +2170,8 @@ const fn unwrap_failed() -> ! {
 }
 
 // This is a separate function to reduce the code size of .expect() itself.
-#[cfg_attr(not(panic = "immediate_abort"), inline(never))]
-#[cfg_attr(panic = "immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate-abort"), inline(never))]
+#[cfg_attr(panic = "immediate-abort", inline)]
 #[cold]
 #[track_caller]
 const fn expect_failed(msg: &str) -> ! {
diff --git a/library/core/src/panicking.rs b/library/core/src/panicking.rs
index da37d72960a61..3f30038dbc03e 100644
--- a/library/core/src/panicking.rs
+++ b/library/core/src/panicking.rs
@@ -49,14 +49,14 @@ compile_error!(
 /// the actual formatting into this shared place.
 // If panic=immediate-abort, inline the abort call,
 // otherwise avoid inlining because of it is cold path.
-#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold)]
-#[cfg_attr(panic = "immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate-abort"), inline(never), cold)]
+#[cfg_attr(panic = "immediate-abort", inline)]
 #[track_caller]
 #[lang = "panic_fmt"] // needed for const-evaluated panics
 #[rustc_do_not_const_check] // hooked by const-eval
 #[rustc_const_stable_indirect] // must follow stable const rules since it is exposed to stable
 pub const fn panic_fmt(fmt: fmt::Arguments<'_>) -> ! {
-    if cfg!(panic = "immediate_abort") {
+    if cfg!(panic = "immediate-abort") {
         super::intrinsics::abort()
     }
 
@@ -81,8 +81,8 @@ pub const fn panic_fmt(fmt: fmt::Arguments<'_>) -> ! {
 /// Like `panic_fmt`, but for non-unwinding panics.
 ///
 /// Has to be a separate function so that it can carry the `rustc_nounwind` attribute.
-#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold)]
-#[cfg_attr(panic = "immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate-abort"), inline(never), cold)]
+#[cfg_attr(panic = "immediate-abort", inline)]
 #[track_caller]
 // This attribute has the key side-effect that if the panic handler ignores `can_unwind`
 // and unwinds anyway, we will hit the "unwinding out of nounwind function" guard,
@@ -97,7 +97,7 @@ pub const fn panic_nounwind_fmt(fmt: fmt::Arguments<'_>, force_no_backtrace: boo
             // We don't unwind anyway at compile-time so we can call the regular `panic_fmt`.
             panic_fmt(fmt)
         } else #[track_caller] {
-            if cfg!(panic = "immediate_abort") {
+            if cfg!(panic = "immediate-abort") {
                 super::intrinsics::abort()
             }
 
@@ -128,8 +128,8 @@ pub const fn panic_nounwind_fmt(fmt: fmt::Arguments<'_>, force_no_backtrace: boo
 /// The underlying implementation of core's `panic!` macro when no formatting is used.
 // Never inline unless panic=immediate-abort to avoid code
 // bloat at the call sites as much as possible.
-#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold)]
-#[cfg_attr(panic = "immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate-abort"), inline(never), cold)]
+#[cfg_attr(panic = "immediate-abort", inline)]
 #[track_caller]
 #[rustc_const_stable_indirect] // must follow stable const rules since it is exposed to stable
 #[lang = "panic"] // used by lints and miri for panics
@@ -163,8 +163,8 @@ macro_rules! panic_const {
             //
             // never inline unless panic=immediate-abort to avoid code
             // bloat at the call sites as much as possible
-            #[cfg_attr(not(panic = "immediate_abort"), inline(never), cold)]
-            #[cfg_attr(panic = "immediate_abort", inline)]
+            #[cfg_attr(not(panic = "immediate-abort"), inline(never), cold)]
+            #[cfg_attr(panic = "immediate-abort", inline)]
             #[track_caller]
             #[rustc_const_stable_indirect] // must follow stable const rules since it is exposed to stable
             #[lang = stringify!($lang)]
@@ -219,8 +219,8 @@ pub mod panic_const {
 
 /// Like `panic`, but without unwinding and track_caller to reduce the impact on codesize on the caller.
 /// If you want `#[track_caller]` for nicer errors, call `panic_nounwind_fmt` directly.
-#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold)]
-#[cfg_attr(panic = "immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate-abort"), inline(never), cold)]
+#[cfg_attr(panic = "immediate-abort", inline)]
 #[lang = "panic_nounwind"] // needed by codegen for non-unwinding panics
 #[rustc_nounwind]
 #[rustc_const_stable_indirect] // must follow stable const rules since it is exposed to stable
@@ -229,8 +229,8 @@ pub const fn panic_nounwind(expr: &'static str) -> ! {
 }
 
 /// Like `panic_nounwind`, but also inhibits showing a backtrace.
-#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold)]
-#[cfg_attr(panic = "immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate-abort"), inline(never), cold)]
+#[cfg_attr(panic = "immediate-abort", inline)]
 #[rustc_nounwind]
 pub fn panic_nounwind_nobacktrace(expr: &'static str) -> ! {
     panic_nounwind_fmt(fmt::Arguments::new_const(&[expr]), /* force_no_backtrace */ true);
@@ -262,25 +262,25 @@ pub const fn panic_display<T: fmt::Display>(x: &T) -> ! {
     panic_fmt(format_args!("{}", *x));
 }
 
-#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold, optimize(size))]
-#[cfg_attr(panic = "immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate-abort"), inline(never), cold, optimize(size))]
+#[cfg_attr(panic = "immediate-abort", inline)]
 #[track_caller]
 #[lang = "panic_bounds_check"] // needed by codegen for panic on OOB array/slice access
 fn panic_bounds_check(index: usize, len: usize) -> ! {
-    if cfg!(panic = "immediate_abort") {
+    if cfg!(panic = "immediate-abort") {
         super::intrinsics::abort()
     }
 
     panic!("index out of bounds: the len is {len} but the index is {index}")
 }
 
-#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold, optimize(size))]
-#[cfg_attr(panic = "immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate-abort"), inline(never), cold, optimize(size))]
+#[cfg_attr(panic = "immediate-abort", inline)]
 #[track_caller]
 #[lang = "panic_misaligned_pointer_dereference"] // needed by codegen for panic on misaligned pointer deref
 #[rustc_nounwind] // `CheckAlignment` MIR pass requires this function to never unwind
 fn panic_misaligned_pointer_dereference(required: usize, found: usize) -> ! {
-    if cfg!(panic = "immediate_abort") {
+    if cfg!(panic = "immediate-abort") {
         super::intrinsics::abort()
     }
 
@@ -292,13 +292,13 @@ fn panic_misaligned_pointer_dereference(required: usize, found: usize) -> ! {
     )
 }
 
-#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold, optimize(size))]
-#[cfg_attr(panic = "immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate-abort"), inline(never), cold, optimize(size))]
+#[cfg_attr(panic = "immediate-abort", inline)]
 #[track_caller]
 #[lang = "panic_null_pointer_dereference"] // needed by codegen for panic on null pointer deref
 #[rustc_nounwind] // `CheckNull` MIR pass requires this function to never unwind
 fn panic_null_pointer_dereference() -> ! {
-    if cfg!(panic = "immediate_abort") {
+    if cfg!(panic = "immediate-abort") {
         super::intrinsics::abort()
     }
 
@@ -308,13 +308,13 @@ fn panic_null_pointer_dereference() -> ! {
     )
 }
 
-#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold, optimize(size))]
-#[cfg_attr(panic = "immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate-abort"), inline(never), cold, optimize(size))]
+#[cfg_attr(panic = "immediate-abort", inline)]
 #[track_caller]
 #[lang = "panic_invalid_enum_construction"] // needed by codegen for panic on invalid enum construction.
 #[rustc_nounwind] // `CheckEnums` MIR pass requires this function to never unwind
 fn panic_invalid_enum_construction(source: u128) -> ! {
-    if cfg!(panic = "immediate_abort") {
+    if cfg!(panic = "immediate-abort") {
         super::intrinsics::abort()
     }
 
@@ -331,8 +331,8 @@ fn panic_invalid_enum_construction(source: u128) -> ! {
 ///
 /// This function is called directly by the codegen backend, and must not have
 /// any extra arguments (including those synthesized by track_caller).
-#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold, optimize(size))]
-#[cfg_attr(panic = "immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate-abort"), inline(never), cold, optimize(size))]
+#[cfg_attr(panic = "immediate-abort", inline)]
 #[lang = "panic_cannot_unwind"] // needed by codegen for panic in nounwind function
 #[rustc_nounwind]
 fn panic_cannot_unwind() -> ! {
@@ -347,8 +347,8 @@ fn panic_cannot_unwind() -> ! {
 ///
 /// This function is called directly by the codegen backend, and must not have
 /// any extra arguments (including those synthesized by track_caller).
-#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold, optimize(size))]
-#[cfg_attr(panic = "immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate-abort"), inline(never), cold, optimize(size))]
+#[cfg_attr(panic = "immediate-abort", inline)]
 #[lang = "panic_in_cleanup"] // needed by codegen for panic in nounwind function
 #[rustc_nounwind]
 fn panic_in_cleanup() -> ! {
@@ -380,8 +380,8 @@ pub enum AssertKind {
 }
 
 /// Internal function for `assert_eq!` and `assert_ne!` macros
-#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold, optimize(size))]
-#[cfg_attr(panic = "immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate-abort"), inline(never), cold, optimize(size))]
+#[cfg_attr(panic = "immediate-abort", inline)]
 #[track_caller]
 #[doc(hidden)]
 pub fn assert_failed<T, U>(
@@ -398,8 +398,8 @@ where
 }
 
 /// Internal function for `assert_match!`
-#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold, optimize(size))]
-#[cfg_attr(panic = "immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate-abort"), inline(never), cold, optimize(size))]
+#[cfg_attr(panic = "immediate-abort", inline)]
 #[track_caller]
 #[doc(hidden)]
 pub fn assert_matches_failed<T: fmt::Debug + ?Sized>(
@@ -418,8 +418,8 @@ pub fn assert_matches_failed<T: fmt::Debug + ?Sized>(
 }
 
 /// Non-generic version of the above functions, to avoid code bloat.
-#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold, optimize(size))]
-#[cfg_attr(panic = "immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate-abort"), inline(never), cold, optimize(size))]
+#[cfg_attr(panic = "immediate-abort", inline)]
 #[track_caller]
 fn assert_failed_inner(
     kind: AssertKind,
diff --git a/library/core/src/result.rs b/library/core/src/result.rs
index 742f1c19112b7..c69762a728598 100644
--- a/library/core/src/result.rs
+++ b/library/core/src/result.rs
@@ -1847,7 +1847,7 @@ impl<T, E> Result<Result<T, E>, E> {
 }
 
 // This is a separate function to reduce the code size of the methods
-#[cfg(not(panic = "immediate_abort"))]
+#[cfg(not(panic = "immediate-abort"))]
 #[inline(never)]
 #[cold]
 #[track_caller]
@@ -1859,7 +1859,7 @@ fn unwrap_failed(msg: &str, error: &dyn fmt::Debug) -> ! {
 // that gets immediately thrown away, since vtables don't get cleaned up
 // by dead code elimination if a trait object is constructed even if it goes
 // unused
-#[cfg(panic = "immediate_abort")]
+#[cfg(panic = "immediate-abort")]
 #[inline]
 #[cold]
 #[track_caller]
diff --git a/library/core/src/slice/index.rs b/library/core/src/slice/index.rs
index c1a55c1f62a20..d3de81555c49d 100644
--- a/library/core/src/slice/index.rs
+++ b/library/core/src/slice/index.rs
@@ -31,8 +31,8 @@ where
     }
 }
 
-#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold)]
-#[cfg_attr(panic = "immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate-abort"), inline(never), cold)]
+#[cfg_attr(panic = "immediate-abort", inline)]
 #[track_caller]
 const fn slice_index_fail(start: usize, end: usize, len: usize) -> ! {
     if start > len {
diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs
index e8b2712e147c5..f7f5ee819b2e4 100644
--- a/library/core/src/slice/mod.rs
+++ b/library/core/src/slice/mod.rs
@@ -3858,8 +3858,8 @@ impl<T> [T] {
     {
         // The panic code path was put into a cold function to not bloat the
         // call site.
-        #[cfg_attr(not(panic = "immediate_abort"), inline(never), cold)]
-        #[cfg_attr(panic = "immediate_abort", inline)]
+        #[cfg_attr(not(panic = "immediate-abort"), inline(never), cold)]
+        #[cfg_attr(panic = "immediate-abort", inline)]
         #[track_caller]
         const fn len_mismatch_fail(dst_len: usize, src_len: usize) -> ! {
             const_panic!(
diff --git a/library/core/src/slice/sort/shared/smallsort.rs b/library/core/src/slice/sort/shared/smallsort.rs
index 17858bf9f0d01..e555fce440872 100644
--- a/library/core/src/slice/sort/shared/smallsort.rs
+++ b/library/core/src/slice/sort/shared/smallsort.rs
@@ -840,8 +840,8 @@ unsafe fn bidirectional_merge<T: FreezeMarker, F: FnMut(&T, &T) -> bool>(
     }
 }
 
-#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold)]
-#[cfg_attr(panic = "immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate-abort"), inline(never), cold)]
+#[cfg_attr(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
diff --git a/library/core/src/str/mod.rs b/library/core/src/str/mod.rs
index 910ea2948ee12..2e473d348b0b2 100644
--- a/library/core/src/str/mod.rs
+++ b/library/core/src/str/mod.rs
@@ -64,12 +64,12 @@ pub use validations::{next_code_point, utf8_char_width};
 #[cold]
 #[track_caller]
 #[rustc_allow_const_fn_unstable(const_eval_select)]
-#[cfg(not(panic = "immediate_abort"))]
+#[cfg(not(panic = "immediate-abort"))]
 const fn slice_error_fail(s: &str, begin: usize, end: usize) -> ! {
     crate::intrinsics::const_eval_select((s, begin, end), slice_error_fail_ct, slice_error_fail_rt)
 }
 
-#[cfg(panic = "immediate_abort")]
+#[cfg(panic = "immediate-abort")]
 const fn slice_error_fail(s: &str, begin: usize, end: usize) -> ! {
     slice_error_fail_ct(s, begin, end)
 }
diff --git a/library/std/src/panicking.rs b/library/std/src/panicking.rs
index 5d52bc366bd73..b7be869c4eb48 100644
--- a/library/std/src/panicking.rs
+++ b/library/std/src/panicking.rs
@@ -331,7 +331,7 @@ fn default_hook(info: &PanicHookInfo<'_>) {
 
 #[cfg(not(test))]
 #[doc(hidden)]
-#[cfg(panic = "immediate_abort")]
+#[cfg(panic = "immediate-abort")]
 #[unstable(feature = "update_panic_count", issue = "none")]
 pub mod panic_count {
     /// A reason for forcing an immediate abort on panic.
@@ -371,7 +371,7 @@ pub mod panic_count {
 
 #[cfg(not(test))]
 #[doc(hidden)]
-#[cfg(not(panic = "immediate_abort"))]
+#[cfg(not(panic = "immediate-abort"))]
 #[unstable(feature = "update_panic_count", issue = "none")]
 pub mod panic_count {
     use crate::cell::Cell;
@@ -499,13 +499,13 @@ pub mod panic_count {
 pub use realstd::rt::panic_count;
 
 /// Invoke a closure, capturing the cause of an unwinding panic if one occurs.
-#[cfg(panic = "immediate_abort")]
+#[cfg(panic = "immediate-abort")]
 pub unsafe fn catch_unwind<R, F: FnOnce() -> R>(f: F) -> Result<R, Box<dyn Any + Send>> {
     Ok(f())
 }
 
 /// Invoke a closure, capturing the cause of an unwinding panic if one occurs.
-#[cfg(not(panic = "immediate_abort"))]
+#[cfg(not(panic = "immediate-abort"))]
 pub unsafe fn catch_unwind<R, F: FnOnce() -> R>(f: F) -> Result<R, Box<dyn Any + Send>> {
     union Data<F, R> {
         f: ManuallyDrop<F>,
@@ -722,12 +722,12 @@ pub fn panic_handler(info: &core::panic::PanicInfo<'_>) -> ! {
 // lang item for CTFE panic support
 // never inline unless panic=immediate-abort to avoid code
 // bloat at the call sites as much as possible
-#[cfg_attr(not(panic = "immediate_abort"), inline(never), cold, optimize(size))]
-#[cfg_attr(panic = "immediate_abort", inline)]
+#[cfg_attr(not(panic = "immediate-abort"), inline(never), cold, optimize(size))]
+#[cfg_attr(panic = "immediate-abort", inline)]
 #[track_caller]
 #[rustc_do_not_const_check] // hooked by const-eval
 pub const fn begin_panic<M: Any + Send>(msg: M) -> ! {
-    if cfg!(panic = "immediate_abort") {
+    if cfg!(panic = "immediate-abort") {
         intrinsics::abort()
     }
 
@@ -861,7 +861,7 @@ fn panic_with_hook(
 
 /// This is the entry point for `resume_unwind`.
 /// It just forwards the payload to the panic runtime.
-#[cfg_attr(panic = "immediate_abort", inline)]
+#[cfg_attr(panic = "immediate-abort", inline)]
 pub fn resume_unwind(payload: Box<dyn Any + Send>) -> ! {
     panic_count::increase(false);
 
@@ -890,14 +890,14 @@ pub fn resume_unwind(payload: Box<dyn Any + Send>) -> ! {
 /// on which to slap yer breakpoints.
 #[inline(never)]
 #[cfg_attr(not(test), rustc_std_internal_symbol)]
-#[cfg(not(panic = "immediate_abort"))]
+#[cfg(not(panic = "immediate-abort"))]
 fn rust_panic(msg: &mut dyn PanicPayload) -> ! {
     let code = unsafe { __rust_start_panic(msg) };
     rtabort!("failed to initiate panic, error {code}")
 }
 
 #[cfg_attr(not(test), rustc_std_internal_symbol)]
-#[cfg(panic = "immediate_abort")]
+#[cfg(panic = "immediate-abort")]
 fn rust_panic(_: &mut dyn PanicPayload) -> ! {
     crate::intrinsics::abort();
 }
diff --git a/library/std/src/rt.rs b/library/std/src/rt.rs
index d98f2e692cd50..2717b7b469cee 100644
--- a/library/std/src/rt.rs
+++ b/library/std/src/rt.rs
@@ -39,11 +39,11 @@ fn __rust_abort() {
 // - nothing (so this macro is a no-op)
 macro_rules! rtprintpanic {
     ($($t:tt)*) => {
-        #[cfg(not(panic = "immediate_abort"))]
+        #[cfg(not(panic = "immediate-abort"))]
         if let Some(mut out) = crate::sys::stdio::panic_output() {
             let _ = crate::io::Write::write_fmt(&mut out, format_args!($($t)*));
         }
-        #[cfg(panic = "immediate_abort")]
+        #[cfg(panic = "immediate-abort")]
         {
             let _ = format_args!($($t)*);
         }
diff --git a/library/std/src/thread/local.rs b/library/std/src/thread/local.rs
index b49de8d1b6084..0a6f2e5d5088b 100644
--- a/library/std/src/thread/local.rs
+++ b/library/std/src/thread/local.rs
@@ -230,7 +230,7 @@ impl fmt::Display for AccessError {
 impl Error for AccessError {}
 
 // This ensures the panicking code is outlined from `with` for `LocalKey`.
-#[cfg_attr(not(panic = "immediate_abort"), inline(never))]
+#[cfg_attr(not(panic = "immediate-abort"), inline(never))]
 #[track_caller]
 #[cold]
 fn panic_access_error(err: AccessError) -> ! {
diff --git a/tests/ui/check-cfg/report-in-external-macros.cargo.stderr b/tests/ui/check-cfg/report-in-external-macros.cargo.stderr
index b99ce169b8900..4b5fc91c7eb91 100644
--- a/tests/ui/check-cfg/report-in-external-macros.cargo.stderr
+++ b/tests/ui/check-cfg/report-in-external-macros.cargo.stderr
@@ -18,7 +18,7 @@ warning: unexpected `cfg` condition value: `UNEXPECTED_VALUE`
 LL |     cfg_macro::my_lib_macro_value!();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: expected values for `panic` are: `abort`, `immediate_abort`, and `unwind`
+   = note: expected values for `panic` are: `abort`, `immediate-abort`, and `unwind`
    = note: using a cfg inside a macro will use the cfgs from the destination crate and not the ones from the defining crate
    = help: try referring to `cfg_macro::my_lib_macro_value` crate for guidance on how handle this unexpected cfg
    = help: the macro `cfg_macro::my_lib_macro_value` may come from an old version of the `cfg_macro` crate, try updating your dependency with `cargo update -p cfg_macro`
diff --git a/tests/ui/check-cfg/report-in-external-macros.rustc.stderr b/tests/ui/check-cfg/report-in-external-macros.rustc.stderr
index 8e1760bd969a7..0d99d061d28df 100644
--- a/tests/ui/check-cfg/report-in-external-macros.rustc.stderr
+++ b/tests/ui/check-cfg/report-in-external-macros.rustc.stderr
@@ -18,7 +18,7 @@ warning: unexpected `cfg` condition value: `UNEXPECTED_VALUE`
 LL |     cfg_macro::my_lib_macro_value!();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: expected values for `panic` are: `abort`, `immediate_abort`, and `unwind`
+   = note: expected values for `panic` are: `abort`, `immediate-abort`, and `unwind`
    = note: using a cfg inside a macro will use the cfgs from the destination crate and not the ones from the defining crate
    = help: try referring to `cfg_macro::my_lib_macro_value` crate for guidance on how handle this unexpected cfg
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
diff --git a/tests/ui/check-cfg/well-known-values.stderr b/tests/ui/check-cfg/well-known-values.stderr
index c34c20b172d50..43dd53939cb03 100644
--- a/tests/ui/check-cfg/well-known-values.stderr
+++ b/tests/ui/check-cfg/well-known-values.stderr
@@ -80,7 +80,7 @@ warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
 LL |     panic = "_UNEXPECTED_VALUE",
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: expected values for `panic` are: `abort`, `immediate_abort`, and `unwind`
+   = note: expected values for `panic` are: `abort`, `immediate-abort`, and `unwind`
    = 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`

From aef02fb864349a249207cbd14b51b9fe5f5691ca Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Sun, 21 Sep 2025 13:04:59 -0400
Subject: [PATCH 1228/1889] Explain tests and setting cfgs

---
 compiler/rustc_session/src/config/cfg.rs                    | 4 ++++
 tests/run-make-cargo/panic-immediate-abort-codegen/rmake.rs | 5 +++++
 tests/run-make-cargo/panic-immediate-abort-works/rmake.rs   | 6 ++++++
 3 files changed, 15 insertions(+)

diff --git a/compiler/rustc_session/src/config/cfg.rs b/compiler/rustc_session/src/config/cfg.rs
index fc36fe9d5d76e..f3d91ce4a5dd8 100644
--- a/compiler/rustc_session/src/config/cfg.rs
+++ b/compiler/rustc_session/src/config/cfg.rs
@@ -205,6 +205,10 @@ pub(crate) fn default_configuration(sess: &Session) -> Cfg {
         ins_none!(sym::overflow_checks);
     }
 
+    // We insert a cfg for the name of session's panic strategy.
+    // Since the ImmediateAbort strategy is new, it also sets cfg(panic="abort"), so that code
+    // which is trying to detect whether unwinding is enabled by checking for cfg(panic="abort")
+    // does not need to be updated.
     ins_sym!(sym::panic, sess.panic_strategy().desc_symbol());
     if sess.panic_strategy() == PanicStrategy::ImmediateAbort {
         ins_sym!(sym::panic, PanicStrategy::Abort.desc_symbol());
diff --git a/tests/run-make-cargo/panic-immediate-abort-codegen/rmake.rs b/tests/run-make-cargo/panic-immediate-abort-codegen/rmake.rs
index e91d1db83d1d1..d7a7a8bfd8c3b 100644
--- a/tests/run-make-cargo/panic-immediate-abort-codegen/rmake.rs
+++ b/tests/run-make-cargo/panic-immediate-abort-codegen/rmake.rs
@@ -1,3 +1,8 @@
+// This is a codegen test which checks that when code is compiled with panic=immediate-abort,
+// we get a `tail call void @llvm.trap()` in user code instead of a call into the standard
+// library's panic formatting code (such as panic_fmt) or one of the numerous panic outlining shims
+// (such as slice_index_fail).
+
 #![deny(warnings)]
 
 use run_make_support::{cargo, llvm_filecheck, path, rfs, target};
diff --git a/tests/run-make-cargo/panic-immediate-abort-works/rmake.rs b/tests/run-make-cargo/panic-immediate-abort-works/rmake.rs
index a3c5877a6a19d..bb15bd41e79c4 100644
--- a/tests/run-make-cargo/panic-immediate-abort-works/rmake.rs
+++ b/tests/run-make-cargo/panic-immediate-abort-works/rmake.rs
@@ -1,3 +1,9 @@
+// This test ensures we are able to compile and link a simple binary with panic=immediate-abort.
+// The test panic-immediate-abort-codegen checks that panic strategy produces the desired codegen,
+// but is based on compiling a library crate (which is the norm for codegen tests because it is
+// cleaner and more portable). So this test ensures that we didn't mix up a cfg or a compiler
+// implementation detail in a way that makes panic=immediate-abort encounter errors at link time.
+
 //@ needs-target-std
 
 #![deny(warnings)]

From 87a00f67ba4c8148e6aa2e1768025b9d51a0fa8b Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Tue, 16 Sep 2025 15:48:43 +0200
Subject: [PATCH 1229/1889] std: merge definitions of `StdioPipes`

All platforms define this structure the same way, so we can just put it in the `process` module directly.
---
 library/std/src/process.rs                      | 13 +++++++++++--
 library/std/src/sys/process/mod.rs              |  2 +-
 library/std/src/sys/process/uefi.rs             |  9 +--------
 library/std/src/sys/process/unix/common.rs      |  9 +--------
 library/std/src/sys/process/unix/fuchsia.rs     |  1 +
 library/std/src/sys/process/unix/mod.rs         |  2 +-
 library/std/src/sys/process/unix/unix.rs        |  1 +
 library/std/src/sys/process/unix/unsupported.rs |  1 +
 library/std/src/sys/process/unix/vxworks.rs     |  1 +
 library/std/src/sys/process/unsupported.rs      |  9 +--------
 library/std/src/sys/process/windows.rs          |  7 +------
 11 files changed, 21 insertions(+), 34 deletions(-)

diff --git a/library/std/src/process.rs b/library/std/src/process.rs
index 0883e56342c8f..5c0ac526a36c9 100644
--- a/library/std/src/process.rs
+++ b/library/std/src/process.rs
@@ -268,8 +268,8 @@ impl AsInner<imp::Process> for Child {
     }
 }
 
-impl FromInner<(imp::Process, imp::StdioPipes)> for Child {
-    fn from_inner((handle, io): (imp::Process, imp::StdioPipes)) -> Child {
+impl FromInner<(imp::Process, StdioPipes)> for Child {
+    fn from_inner((handle, io): (imp::Process, StdioPipes)) -> Child {
         Child {
             handle,
             stdin: io.stdin.map(ChildStdin::from_inner),
@@ -296,6 +296,15 @@ impl fmt::Debug for Child {
     }
 }
 
+/// The pipes connected to a spawned process.
+///
+/// Used to pass pipe handles between this module and [`imp`].
+pub(crate) struct StdioPipes {
+    pub stdin: Option<AnonPipe>,
+    pub stdout: Option<AnonPipe>,
+    pub stderr: Option<AnonPipe>,
+}
+
 /// A handle to a child process's standard input (stdin).
 ///
 /// This struct is used in the [`stdin`] field on [`Child`].
diff --git a/library/std/src/sys/process/mod.rs b/library/std/src/sys/process/mod.rs
index 9ef5496e57a05..a1ed0cd2cdd2d 100644
--- a/library/std/src/sys/process/mod.rs
+++ b/library/std/src/sys/process/mod.rs
@@ -24,7 +24,7 @@ mod env;
 
 pub use env::CommandEnvs;
 pub use imp::{
-    Command, CommandArgs, EnvKey, ExitCode, ExitStatus, ExitStatusError, Process, Stdio, StdioPipes,
+    Command, CommandArgs, EnvKey, ExitCode, ExitStatus, ExitStatusError, Process, Stdio,
 };
 
 #[cfg(any(
diff --git a/library/std/src/sys/process/uefi.rs b/library/std/src/sys/process/uefi.rs
index 4864c58698817..11c8b682bb9bc 100644
--- a/library/std/src/sys/process/uefi.rs
+++ b/library/std/src/sys/process/uefi.rs
@@ -6,6 +6,7 @@ pub use crate::ffi::OsString as EnvKey;
 use crate::ffi::{OsStr, OsString};
 use crate::num::{NonZero, NonZeroI32};
 use crate::path::Path;
+use crate::process::StdioPipes;
 use crate::sys::fs::File;
 use crate::sys::pal::helpers;
 use crate::sys::pal::os::error_string;
@@ -27,14 +28,6 @@ pub struct Command {
     env: CommandEnv,
 }
 
-// passed back to std::process with the pipes connected to the child, if any
-// were requested
-pub struct StdioPipes {
-    pub stdin: Option<AnonPipe>,
-    pub stdout: Option<AnonPipe>,
-    pub stderr: Option<AnonPipe>,
-}
-
 #[derive(Copy, Clone, Debug)]
 pub enum Stdio {
     Inherit,
diff --git a/library/std/src/sys/process/unix/common.rs b/library/std/src/sys/process/unix/common.rs
index ea45b08e90a34..1d5909e99bacc 100644
--- a/library/std/src/sys/process/unix/common.rs
+++ b/library/std/src/sys/process/unix/common.rs
@@ -9,6 +9,7 @@ use crate::collections::BTreeMap;
 use crate::ffi::{CStr, CString, OsStr, OsString};
 use crate::os::unix::prelude::*;
 use crate::path::Path;
+use crate::process::StdioPipes;
 use crate::sys::fd::FileDesc;
 use crate::sys::fs::File;
 #[cfg(not(target_os = "fuchsia"))]
@@ -104,14 +105,6 @@ pub struct Command {
     setsid: bool,
 }
 
-// passed back to std::process with the pipes connected to the child, if any
-// were requested
-pub struct StdioPipes {
-    pub stdin: Option<AnonPipe>,
-    pub stdout: Option<AnonPipe>,
-    pub stderr: Option<AnonPipe>,
-}
-
 // passed to do_exec() with configuration of what the child stdio should look
 // like
 #[cfg_attr(target_os = "vita", allow(dead_code))]
diff --git a/library/std/src/sys/process/unix/fuchsia.rs b/library/std/src/sys/process/unix/fuchsia.rs
index d71be510b6afe..3fae5ec1468b1 100644
--- a/library/std/src/sys/process/unix/fuchsia.rs
+++ b/library/std/src/sys/process/unix/fuchsia.rs
@@ -2,6 +2,7 @@ use libc::{c_int, size_t};
 
 use super::common::*;
 use crate::num::NonZero;
+use crate::process::StdioPipes;
 use crate::sys::pal::fuchsia::*;
 use crate::{fmt, io, mem, ptr};
 
diff --git a/library/std/src/sys/process/unix/mod.rs b/library/std/src/sys/process/unix/mod.rs
index b4cf060fba9bf..cda1bf74f1cad 100644
--- a/library/std/src/sys/process/unix/mod.rs
+++ b/library/std/src/sys/process/unix/mod.rs
@@ -23,5 +23,5 @@ cfg_select! {
 
 pub use imp::{ExitStatus, ExitStatusError, Process};
 
-pub use self::common::{Command, CommandArgs, ExitCode, Stdio, StdioPipes};
+pub use self::common::{Command, CommandArgs, ExitCode, Stdio};
 pub use crate::ffi::OsString as EnvKey;
diff --git a/library/std/src/sys/process/unix/unix.rs b/library/std/src/sys/process/unix/unix.rs
index 11d48878727b0..7d944f2f7eef1 100644
--- a/library/std/src/sys/process/unix/unix.rs
+++ b/library/std/src/sys/process/unix/unix.rs
@@ -13,6 +13,7 @@ use libc::{gid_t, uid_t};
 use super::common::*;
 use crate::io::{self, Error, ErrorKind};
 use crate::num::NonZero;
+use crate::process::StdioPipes;
 use crate::sys::cvt;
 #[cfg(target_os = "linux")]
 use crate::sys::pal::linux::pidfd::PidFd;
diff --git a/library/std/src/sys/process/unix/unsupported.rs b/library/std/src/sys/process/unix/unsupported.rs
index 87403cd50f822..9bda394f24659 100644
--- a/library/std/src/sys/process/unix/unsupported.rs
+++ b/library/std/src/sys/process/unix/unsupported.rs
@@ -3,6 +3,7 @@ use libc::{c_int, pid_t};
 use super::common::*;
 use crate::io;
 use crate::num::NonZero;
+use crate::process::StdioPipes;
 use crate::sys::pal::unsupported::*;
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/library/std/src/sys/process/unix/vxworks.rs b/library/std/src/sys/process/unix/vxworks.rs
index b9298f5fa44c1..346ca6d74c9bd 100644
--- a/library/std/src/sys/process/unix/vxworks.rs
+++ b/library/std/src/sys/process/unix/vxworks.rs
@@ -4,6 +4,7 @@ use libc::{self, RTP_ID, c_char, c_int};
 use super::common::*;
 use crate::io::{self, ErrorKind};
 use crate::num::NonZero;
+use crate::process::StdioPipes;
 use crate::sys::{cvt, thread};
 use crate::{fmt, sys};
 
diff --git a/library/std/src/sys/process/unsupported.rs b/library/std/src/sys/process/unsupported.rs
index 469922c78aca2..636465b68e541 100644
--- a/library/std/src/sys/process/unsupported.rs
+++ b/library/std/src/sys/process/unsupported.rs
@@ -3,6 +3,7 @@ pub use crate::ffi::OsString as EnvKey;
 use crate::ffi::{OsStr, OsString};
 use crate::num::NonZero;
 use crate::path::Path;
+use crate::process::StdioPipes;
 use crate::sys::fs::File;
 use crate::sys::pipe::AnonPipe;
 use crate::sys::unsupported;
@@ -23,14 +24,6 @@ pub struct Command {
     stderr: Option<Stdio>,
 }
 
-// passed back to std::process with the pipes connected to the child, if any
-// were requested
-pub struct StdioPipes {
-    pub stdin: Option<AnonPipe>,
-    pub stdout: Option<AnonPipe>,
-    pub stderr: Option<AnonPipe>,
-}
-
 #[derive(Debug)]
 pub enum Stdio {
     Inherit,
diff --git a/library/std/src/sys/process/windows.rs b/library/std/src/sys/process/windows.rs
index f9e15b824757d..1f2001bdc2040 100644
--- a/library/std/src/sys/process/windows.rs
+++ b/library/std/src/sys/process/windows.rs
@@ -15,6 +15,7 @@ use crate::os::windows::ffi::{OsStrExt, OsStringExt};
 use crate::os::windows::io::{AsHandle, AsRawHandle, BorrowedHandle, FromRawHandle, IntoRawHandle};
 use crate::os::windows::process::ProcThreadAttributeList;
 use crate::path::{Path, PathBuf};
+use crate::process::StdioPipes;
 use crate::sync::Mutex;
 use crate::sys::args::{self, Arg};
 use crate::sys::c::{self, EXIT_FAILURE, EXIT_SUCCESS};
@@ -169,12 +170,6 @@ pub enum Stdio {
     Handle(Handle),
 }
 
-pub struct StdioPipes {
-    pub stdin: Option<AnonPipe>,
-    pub stdout: Option<AnonPipe>,
-    pub stderr: Option<AnonPipe>,
-}
-
 impl Command {
     pub fn new(program: &OsStr) -> Command {
         Command {

From 5f0a68eb220c4aa780e0206ee6c6273413d8d5fd Mon Sep 17 00:00:00 2001
From: The 8472 <git@infinite-source.de>
Date: Fri, 15 Aug 2025 01:20:37 +0200
Subject: [PATCH 1230/1889] regression test for
 https://github.com/rust-lang/rust/issues/117763

---
 .../issues/cows-dont-have-branches-117763.rs    | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 tests/codegen-llvm/issues/cows-dont-have-branches-117763.rs

diff --git a/tests/codegen-llvm/issues/cows-dont-have-branches-117763.rs b/tests/codegen-llvm/issues/cows-dont-have-branches-117763.rs
new file mode 100644
index 0000000000000..b97729fa14657
--- /dev/null
+++ b/tests/codegen-llvm/issues/cows-dont-have-branches-117763.rs
@@ -0,0 +1,17 @@
+//@ compile-flags: -Copt-level=3
+//@ needs-deterministic-layouts
+
+// Currently Vec<T> and &[T] have layouts that start with (pointer, len)
+// which makes the conversion branchless.
+// A nice-to-have property, not guaranteed.
+#![crate_type = "cdylib"]
+
+// CHECK-LABEL: @branchless_cow_slices
+#[no_mangle]
+pub fn branchless_cow_slices<'a>(cow: &'a std::borrow::Cow<'a, [u8]>) -> &'a [u8] {
+    // CHECK-NOT: br
+    // CHECK-NOT: select
+    // CHECK-NOT: icmp
+    // CHECK: ret { ptr, {{i32|i64}} }
+    &*cow
+}

From 97b2292b065f825d482899149001a74b6a5450c4 Mon Sep 17 00:00:00 2001
From: Jules Bertholet <julesbertholet@quoi.xyz>
Date: Wed, 17 Sep 2025 10:26:52 -0400
Subject: [PATCH 1231/1889] Allow shared access to `Exclusive<T>` when `T:
 Sync`

---
 library/core/src/sync/exclusive.rs | 114 ++++++++++++++++++++++++++---
 1 file changed, 104 insertions(+), 10 deletions(-)

diff --git a/library/core/src/sync/exclusive.rs b/library/core/src/sync/exclusive.rs
index cf086bf4f5080..f181c5514f256 100644
--- a/library/core/src/sync/exclusive.rs
+++ b/library/core/src/sync/exclusive.rs
@@ -1,28 +1,32 @@
 //! Defines [`Exclusive`].
 
+use core::cmp::Ordering;
 use core::fmt;
 use core::future::Future;
-use core::marker::Tuple;
+use core::hash::{Hash, Hasher};
+use core::marker::{StructuralPartialEq, Tuple};
 use core::ops::{Coroutine, CoroutineState};
 use core::pin::Pin;
 use core::task::{Context, Poll};
 
-/// `Exclusive` provides only _mutable_ access, also referred to as _exclusive_
-/// access to the underlying value. It provides no _immutable_, or _shared_
-/// access to the underlying value.
+/// `Exclusive` provides _mutable_ access, also referred to as _exclusive_
+/// access to the underlying value. However, it only permits _immutable_, or _shared_
+/// access to the underlying value when that value is [`Sync`].
 ///
 /// While this may seem not very useful, it allows `Exclusive` to _unconditionally_
-/// implement [`Sync`]. Indeed, the safety requirements of `Sync` state that for `Exclusive`
+/// implement `Sync`. Indeed, the safety requirements of `Sync` state that for `Exclusive`
 /// to be `Sync`, it must be sound to _share_ across threads, that is, it must be sound
-/// for `&Exclusive` to cross thread boundaries. By design, a `&Exclusive` has no API
-/// whatsoever, making it useless, thus harmless, thus memory safe.
+/// for `&Exclusive` to cross thread boundaries. By design, a `&Exclusive<T>` for non-`Sync` T
+/// has no API whatsoever, making it useless, thus harmless, thus memory safe.
 ///
 /// Certain constructs like [`Future`]s can only be used with _exclusive_ access,
 /// and are often `Send` but not `Sync`, so `Exclusive` can be used as hint to the
 /// Rust compiler that something is `Sync` in practice.
 ///
 /// ## Examples
-/// Using a non-`Sync` future prevents the wrapping struct from being `Sync`
+///
+/// Using a non-`Sync` future prevents the wrapping struct from being `Sync`:
+///
 /// ```compile_fail
 /// use core::cell::Cell;
 ///
@@ -43,7 +47,8 @@ use core::task::{Context, Poll};
 /// ```
 ///
 /// `Exclusive` ensures the struct is `Sync` without stripping the future of its
-/// functionality.
+/// functionality:
+///
 /// ```
 /// #![feature(exclusive_wrapper)]
 /// use core::cell::Cell;
@@ -66,6 +71,7 @@ use core::task::{Context, Poll};
 /// ```
 ///
 /// ## Parallels with a mutex
+///
 /// In some sense, `Exclusive` can be thought of as a _compile-time_ version of
 /// a mutex, as the borrow-checker guarantees that only one `&mut` can exist
 /// for any value. This is a parallel with the fact that
@@ -75,7 +81,7 @@ use core::task::{Context, Poll};
 #[doc(alias = "SyncWrapper")]
 #[doc(alias = "SyncCell")]
 #[doc(alias = "Unique")]
-// `Exclusive` can't have `PartialOrd`, `Clone`, etc. impls as they would
+// `Exclusive` can't have derived `PartialOrd`, `Clone`, etc. impls as they would
 // use `&` access to the inner value, violating the `Sync` impl's safety
 // requirements.
 #[derive(Default)]
@@ -195,6 +201,17 @@ where
     }
 }
 
+#[unstable(feature = "exclusive_wrapper", issue = "98407")]
+impl<F, Args> Fn<Args> for Exclusive<F>
+where
+    F: Sync + Fn<Args>,
+    Args: Tuple,
+{
+    extern "rust-call" fn call(&self, args: Args) -> Self::Output {
+        self.as_ref().call(args)
+    }
+}
+
 #[unstable(feature = "exclusive_wrapper", issue = "98407")]
 impl<T> Future for Exclusive<T>
 where
@@ -221,3 +238,80 @@ where
         G::resume(self.get_pin_mut(), arg)
     }
 }
+
+#[unstable(feature = "exclusive_wrapper", issue = "98407")]
+impl<T> AsRef<T> for Exclusive<T>
+where
+    T: Sync + ?Sized,
+{
+    #[inline]
+    fn as_ref(&self) -> &T {
+        &self.inner
+    }
+}
+
+#[unstable(feature = "exclusive_wrapper", issue = "98407")]
+impl<T> Clone for Exclusive<T>
+where
+    T: Sync + Clone,
+{
+    #[inline]
+    fn clone(&self) -> Self {
+        Self { inner: self.inner.clone() }
+    }
+}
+
+#[unstable(feature = "exclusive_wrapper", issue = "98407")]
+impl<T> Copy for Exclusive<T> where T: Sync + Copy {}
+
+#[unstable(feature = "exclusive_wrapper", issue = "98407")]
+impl<T, U> PartialEq<Exclusive<U>> for Exclusive<T>
+where
+    T: Sync + PartialEq<U> + ?Sized,
+    U: Sync + ?Sized,
+{
+    #[inline]
+    fn eq(&self, other: &Exclusive<U>) -> bool {
+        self.inner == other.inner
+    }
+}
+
+#[unstable(feature = "exclusive_wrapper", issue = "98407")]
+impl<T> StructuralPartialEq for Exclusive<T> where T: Sync + StructuralPartialEq + ?Sized {}
+
+#[unstable(feature = "exclusive_wrapper", issue = "98407")]
+impl<T> Eq for Exclusive<T> where T: Sync + Eq + ?Sized {}
+
+#[unstable(feature = "exclusive_wrapper", issue = "98407")]
+impl<T> Hash for Exclusive<T>
+where
+    T: Sync + Hash + ?Sized,
+{
+    #[inline]
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        Hash::hash(&self.inner, state)
+    }
+}
+
+#[unstable(feature = "exclusive_wrapper", issue = "98407")]
+impl<T, U> PartialOrd<Exclusive<U>> for Exclusive<T>
+where
+    T: Sync + PartialOrd<U> + ?Sized,
+    U: Sync + ?Sized,
+{
+    #[inline]
+    fn partial_cmp(&self, other: &Exclusive<U>) -> Option<Ordering> {
+        self.inner.partial_cmp(&other.inner)
+    }
+}
+
+#[unstable(feature = "exclusive_wrapper", issue = "98407")]
+impl<T> Ord for Exclusive<T>
+where
+    T: Sync + Ord + ?Sized,
+{
+    #[inline]
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.inner.cmp(&other.inner)
+    }
+}

From b3c24356884d9cb333ff71e49e41b648a7dec1e2 Mon Sep 17 00:00:00 2001
From: Jens Reidel <adrian@travitia.xyz>
Date: Sun, 21 Sep 2025 21:13:03 +0200
Subject: [PATCH 1232/1889] Make mips64el-unknown-linux-muslabi64 link
 dynamically

I missed this target when I changed all the other tier 3 targets. Only
realized that this one was still statically linked when I looked at the
list of targets in the test later.

Signed-off-by: Jens Reidel <adrian@travitia.xyz>
---
 .../src/spec/targets/mips64el_unknown_linux_muslabi64.rs       | 2 --
 tests/run-make/musl-default-linking/rmake.rs                   | 3 +--
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/compiler/rustc_target/src/spec/targets/mips64el_unknown_linux_muslabi64.rs b/compiler/rustc_target/src/spec/targets/mips64el_unknown_linux_muslabi64.rs
index d42e097b0fd8b..38c3c7dfaa1bb 100644
--- a/compiler/rustc_target/src/spec/targets/mips64el_unknown_linux_muslabi64.rs
+++ b/compiler/rustc_target/src/spec/targets/mips64el_unknown_linux_muslabi64.rs
@@ -5,8 +5,6 @@ pub(crate) fn target() -> Target {
     base.cpu = "mips64r2".into();
     base.features = "+mips64r2,+xgot".into();
     base.max_atomic_width = Some(64);
-    // FIXME(compiler-team#422): musl targets should be dynamically linked by default.
-    base.crt_static_default = true;
     Target {
         // LLVM doesn't recognize "muslabi64" yet.
         llvm_target: "mips64el-unknown-linux-musl".into(),
diff --git a/tests/run-make/musl-default-linking/rmake.rs b/tests/run-make/musl-default-linking/rmake.rs
index 1b30c538b5e30..e9d09e359c686 100644
--- a/tests/run-make/musl-default-linking/rmake.rs
+++ b/tests/run-make/musl-default-linking/rmake.rs
@@ -4,7 +4,7 @@ use run_make_support::{rustc, serde_json};
 // Per https://github.com/rust-lang/compiler-team/issues/422,
 // we should be trying to move these targets to dynamically link
 // musl libc by default.
-//@ needs-llvm-components: aarch64 arm mips powerpc x86
+//@ needs-llvm-components: aarch64 arm powerpc x86
 static LEGACY_STATIC_LINKING_TARGETS: &[&'static str] = &[
     "aarch64-unknown-linux-musl",
     "arm-unknown-linux-musleabi",
@@ -14,7 +14,6 @@ static LEGACY_STATIC_LINKING_TARGETS: &[&'static str] = &[
     "armv7-unknown-linux-musleabihf",
     "i586-unknown-linux-musl",
     "i686-unknown-linux-musl",
-    "mips64el-unknown-linux-muslabi64",
     "powerpc64le-unknown-linux-musl",
     "x86_64-unknown-linux-musl",
 ];

From 3565b0699d6830dc31732afa96272bcbd1f83606 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Fri, 19 Sep 2025 20:39:47 +0200
Subject: [PATCH 1233/1889] emit attribute for readonly non-pure inline
 assembly

---
 compiler/rustc_codegen_llvm/src/asm.rs        |  4 +-
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs   |  1 +
 .../rustc_llvm/llvm-wrapper/RustWrapper.cpp   |  5 ++
 tests/codegen-llvm/asm/readonly-not-pure.rs   | 48 +++++++++++++++++++
 4 files changed, 56 insertions(+), 2 deletions(-)
 create mode 100644 tests/codegen-llvm/asm/readonly-not-pure.rs

diff --git a/compiler/rustc_codegen_llvm/src/asm.rs b/compiler/rustc_codegen_llvm/src/asm.rs
index b79176e909818..838eb0db0403d 100644
--- a/compiler/rustc_codegen_llvm/src/asm.rs
+++ b/compiler/rustc_codegen_llvm/src/asm.rs
@@ -340,8 +340,8 @@ impl<'ll, 'tcx> AsmBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
             attrs.push(llvm::AttributeKind::WillReturn.create_attr(self.cx.llcx));
         } else if options.contains(InlineAsmOptions::NOMEM) {
             attrs.push(llvm::MemoryEffects::InaccessibleMemOnly.create_attr(self.cx.llcx));
-        } else {
-            // LLVM doesn't have an attribute to represent ReadOnly + SideEffect
+        } else if options.contains(InlineAsmOptions::READONLY) {
+            attrs.push(llvm::MemoryEffects::ReadOnlyNotPure.create_attr(self.cx.llcx));
         }
         attributes::apply_to_callsite(result, llvm::AttributePlace::Function, &{ attrs });
 
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 9a86e4373d8f4..fd972f371df49 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -710,6 +710,7 @@ pub(crate) enum MemoryEffects {
     None,
     ReadOnly,
     InaccessibleMemOnly,
+    ReadOnlyNotPure,
 }
 
 /// LLVMOpcode
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index 64151962321fd..414274f24fb50 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -553,6 +553,7 @@ enum class LLVMRustMemoryEffects {
   None,
   ReadOnly,
   InaccessibleMemOnly,
+  ReadOnlyNotPure,
 };
 
 extern "C" LLVMAttributeRef
@@ -568,6 +569,10 @@ LLVMRustCreateMemoryEffectsAttr(LLVMContextRef C,
   case LLVMRustMemoryEffects::InaccessibleMemOnly:
     return wrap(Attribute::getWithMemoryEffects(
         *unwrap(C), MemoryEffects::inaccessibleMemOnly()));
+  case LLVMRustMemoryEffects::ReadOnlyNotPure:
+    return wrap(Attribute::getWithMemoryEffects(
+        *unwrap(C),
+        MemoryEffects::readOnly() | MemoryEffects::inaccessibleMemOnly()));
   default:
     report_fatal_error("bad MemoryEffects.");
   }
diff --git a/tests/codegen-llvm/asm/readonly-not-pure.rs b/tests/codegen-llvm/asm/readonly-not-pure.rs
new file mode 100644
index 0000000000000..a3c0e276c7f5e
--- /dev/null
+++ b/tests/codegen-llvm/asm/readonly-not-pure.rs
@@ -0,0 +1,48 @@
+//@ add-core-stubs
+//@ compile-flags: -Copt-level=3 --target x86_64-unknown-linux-gnu
+//@ needs-llvm-components: x86
+
+#![crate_type = "rlib"]
+#![feature(no_core)]
+#![no_core]
+
+// Test that when an inline assembly block specifies `readonly` but not `pure`, a detailed
+// `MemoryEffects` is provided to LLVM: this assembly block is not allowed to perform writes,
+// but it may have side-effects.
+
+extern crate minicore;
+use minicore::*;
+
+pub static mut VAR: i32 = 0;
+
+// CHECK-LABEL: @no_options
+// CHECK: call i32 asm
+#[no_mangle]
+pub unsafe fn no_options() -> i32 {
+    VAR = 1;
+    let _ignored: i32;
+    asm!("mov {0}, 1", out(reg) _ignored);
+    VAR
+}
+
+// CHECK-LABEL: @readonly_pure
+// CHECK-NOT: call i32 asm
+#[no_mangle]
+pub unsafe fn readonly_pure() -> i32 {
+    VAR = 1;
+    let _ignored: i32;
+    asm!("mov {0}, 1", out(reg) _ignored, options(pure, readonly));
+    VAR
+}
+
+// CHECK-LABEL: @readonly_not_pure
+// CHECK: call i32 asm {{.*}} #[[ATTR:[0-9]+]]
+#[no_mangle]
+pub unsafe fn readonly_not_pure() -> i32 {
+    VAR = 1;
+    let _ignored: i32;
+    asm!("mov {0}, 1", out(reg) _ignored, options(readonly));
+    VAR
+}
+
+// CHECK: attributes #[[ATTR]] = { nounwind memory(read, inaccessiblemem: readwrite) }

From 27cad5a61602e0435967d2c5c34f0d94178ab1be Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 13 Aug 2025 20:30:34 +0200
Subject: [PATCH 1234/1889] fix `unnecessary_semicolon`: FN on
 `#[feature(stmt_expr_attributes)]`

---
 clippy_lints/src/unnecessary_semicolon.rs           |  3 ++-
 ...ary_semicolon_feature_stmt_expr_attributes.fixed | 13 +++++++++++++
 ...essary_semicolon_feature_stmt_expr_attributes.rs | 13 +++++++++++++
 ...ry_semicolon_feature_stmt_expr_attributes.stderr | 11 +++++++++++
 4 files changed, 39 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/unnecessary_semicolon_feature_stmt_expr_attributes.fixed
 create mode 100644 tests/ui/unnecessary_semicolon_feature_stmt_expr_attributes.rs
 create mode 100644 tests/ui/unnecessary_semicolon_feature_stmt_expr_attributes.stderr

diff --git a/clippy_lints/src/unnecessary_semicolon.rs b/clippy_lints/src/unnecessary_semicolon.rs
index 76e24b6bf8058..e1e450a52fdf0 100644
--- a/clippy_lints/src/unnecessary_semicolon.rs
+++ b/clippy_lints/src/unnecessary_semicolon.rs
@@ -88,7 +88,8 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessarySemicolon {
             )
             && cx.typeck_results().expr_ty(expr).is_unit()
             // if a stmt has attrs, then turning it into an expr will break the code, since attrs aren't allowed on exprs
-            && cx.tcx.hir_attrs(stmt.hir_id).is_empty()
+            // -- unless the corresponding feature is enabled
+            && (cx.tcx.hir_attrs(stmt.hir_id).is_empty() || cx.tcx.features().stmt_expr_attributes())
         {
             if let Some(block_is_unit) = self.is_last_in_block(stmt) {
                 if cx.tcx.sess.edition() <= Edition2021 && leaks_droppable_temporary_with_limited_lifetime(cx, expr) {
diff --git a/tests/ui/unnecessary_semicolon_feature_stmt_expr_attributes.fixed b/tests/ui/unnecessary_semicolon_feature_stmt_expr_attributes.fixed
new file mode 100644
index 0000000000000..b90ae1365bbf2
--- /dev/null
+++ b/tests/ui/unnecessary_semicolon_feature_stmt_expr_attributes.fixed
@@ -0,0 +1,13 @@
+#![warn(clippy::unnecessary_semicolon)]
+#![feature(stmt_expr_attributes)]
+
+fn main() {
+    // removing the `;` would turn the stmt into an expr, but attrs aren't allowed on exprs
+    // -- unless the feature `stmt_expr_attributes` is enabled
+    #[rustfmt::skip]
+    match 0 {
+        0b00 => {}  0b01 => {}
+        0b11 => {}  _    => {}
+    }
+    //~^ unnecessary_semicolon
+}
diff --git a/tests/ui/unnecessary_semicolon_feature_stmt_expr_attributes.rs b/tests/ui/unnecessary_semicolon_feature_stmt_expr_attributes.rs
new file mode 100644
index 0000000000000..606c901c20d35
--- /dev/null
+++ b/tests/ui/unnecessary_semicolon_feature_stmt_expr_attributes.rs
@@ -0,0 +1,13 @@
+#![warn(clippy::unnecessary_semicolon)]
+#![feature(stmt_expr_attributes)]
+
+fn main() {
+    // removing the `;` would turn the stmt into an expr, but attrs aren't allowed on exprs
+    // -- unless the feature `stmt_expr_attributes` is enabled
+    #[rustfmt::skip]
+    match 0 {
+        0b00 => {}  0b01 => {}
+        0b11 => {}  _    => {}
+    };
+    //~^ unnecessary_semicolon
+}
diff --git a/tests/ui/unnecessary_semicolon_feature_stmt_expr_attributes.stderr b/tests/ui/unnecessary_semicolon_feature_stmt_expr_attributes.stderr
new file mode 100644
index 0000000000000..3e98a92ef299c
--- /dev/null
+++ b/tests/ui/unnecessary_semicolon_feature_stmt_expr_attributes.stderr
@@ -0,0 +1,11 @@
+error: unnecessary semicolon
+  --> tests/ui/unnecessary_semicolon_feature_stmt_expr_attributes.rs:11:6
+   |
+LL |     };
+   |      ^ help: remove
+   |
+   = note: `-D clippy::unnecessary-semicolon` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::unnecessary_semicolon)]`
+
+error: aborting due to 1 previous error
+

From 0138bbd4958f2247770105ff63e9129e779da569 Mon Sep 17 00:00:00 2001
From: "U. Lasiotus" <lasiotus@motor-os.org>
Date: Sun, 21 Sep 2025 08:54:25 -0700
Subject: [PATCH 1235/1889] Add x86_64-unknown-motor (Motor OS) tier 3 target

Add the initial no-std Motor OS compiler target.

Motor OS has been developed for several years in the open:
https://github.com/moturus/motor-os.

It has a more or less full implementation of Rust std library,
as well as tokio/mio ports.

Build instructions can be found here:
https://github.com/moturus/motor-os/blob/main/docs/build.md.

Signed-off-by: U. Lasiotus <lasiotus@motor-os.org>
---
 compiler/rustc_target/src/spec/base/mod.rs    |  1 +
 compiler/rustc_target/src/spec/base/motor.rs  | 34 ++++++++++++++
 compiler/rustc_target/src/spec/mod.rs         |  1 +
 .../src/spec/targets/x86_64_unknown_motor.rs  | 38 ++++++++++++++++
 src/bootstrap/src/core/sanity.rs              |  5 +++
 src/doc/rustc/src/platform-support.md         |  1 +
 src/doc/rustc/src/platform-support/motor.md   | 45 +++++++++++++++++++
 tests/assembly-llvm/targets/targets-elf.rs    |  3 ++
 tests/ui/check-cfg/cfg-crate-features.stderr  |  2 +-
 tests/ui/check-cfg/well-known-values.stderr   |  4 +-
 10 files changed, 131 insertions(+), 3 deletions(-)
 create mode 100644 compiler/rustc_target/src/spec/base/motor.rs
 create mode 100644 compiler/rustc_target/src/spec/targets/x86_64_unknown_motor.rs
 create mode 100644 src/doc/rustc/src/platform-support/motor.md

diff --git a/compiler/rustc_target/src/spec/base/mod.rs b/compiler/rustc_target/src/spec/base/mod.rs
index be15da7329d79..6ab8597a4ecb0 100644
--- a/compiler/rustc_target/src/spec/base/mod.rs
+++ b/compiler/rustc_target/src/spec/base/mod.rs
@@ -21,6 +21,7 @@ pub(crate) mod linux_uclibc;
 pub(crate) mod linux_wasm;
 pub(crate) mod lynxos178;
 pub(crate) mod managarm_mlibc;
+pub(crate) mod motor;
 pub(crate) mod msvc;
 pub(crate) mod netbsd;
 pub(crate) mod nto_qnx;
diff --git a/compiler/rustc_target/src/spec/base/motor.rs b/compiler/rustc_target/src/spec/base/motor.rs
new file mode 100644
index 0000000000000..18485b2cef2fc
--- /dev/null
+++ b/compiler/rustc_target/src/spec/base/motor.rs
@@ -0,0 +1,34 @@
+use crate::spec::{
+    Cc, FramePointer, LinkerFlavor, Lld, PanicStrategy, StackProbeType, TargetOptions,
+};
+
+pub(crate) fn opts() -> TargetOptions {
+    let pre_link_args = TargetOptions::link_args(
+        LinkerFlavor::Gnu(Cc::No, Lld::No),
+        &[
+            "-e",
+            "motor_start",
+            "--no-undefined",
+            "--error-unresolved-symbols",
+            "--no-undefined-version",
+            "-u",
+            "__rust_abort",
+        ],
+    );
+    TargetOptions {
+        os: "motor".into(),
+        executables: true,
+        // TLS is false below because if true, the compiler assumes
+        // we handle TLS at the ELF loading level, which we don't.
+        // We use "OS level" TLS (see thread/local.rs in stdlib).
+        has_thread_local: false,
+        frame_pointer: FramePointer::NonLeaf,
+        linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::No),
+        main_needs_argc_argv: true,
+        panic_strategy: PanicStrategy::Abort,
+        pre_link_args,
+        stack_probes: StackProbeType::Inline,
+        supports_stack_protector: true,
+        ..Default::default()
+    }
+}
diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index f705af52bd868..c40358af59388 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -1642,6 +1642,7 @@ supported_targets! {
     ("aarch64-unknown-hermit", aarch64_unknown_hermit),
     ("riscv64gc-unknown-hermit", riscv64gc_unknown_hermit),
     ("x86_64-unknown-hermit", x86_64_unknown_hermit),
+    ("x86_64-unknown-motor", x86_64_unknown_motor),
 
     ("x86_64-unikraft-linux-musl", x86_64_unikraft_linux_musl),
 
diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_motor.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_motor.rs
new file mode 100644
index 0000000000000..0fd43357a7664
--- /dev/null
+++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_motor.rs
@@ -0,0 +1,38 @@
+use crate::spec::{
+    CodeModel, LinkSelfContainedDefault, LldFlavor, RelocModel, RelroLevel, Target, base,
+};
+
+pub(crate) fn target() -> Target {
+    let mut base = base::motor::opts();
+    base.cpu = "x86-64".into();
+    base.max_atomic_width = Some(64);
+    base.code_model = Some(CodeModel::Small);
+
+    // We want fully static relocatable binaries. It was surprisingly
+    // difficult to make it happen reliably, especially various
+    // linker-related options below. Mostly trial and error.
+    base.position_independent_executables = true;
+    base.relro_level = RelroLevel::Full;
+    base.static_position_independent_executables = true;
+    base.relocation_model = RelocModel::Pic;
+    base.lld_flavor_json = LldFlavor::Ld;
+    base.link_self_contained = LinkSelfContainedDefault::True;
+    base.dynamic_linking = false;
+    base.crt_static_default = true;
+    base.crt_static_respected = true;
+
+    Target {
+        llvm_target: "x86_64-unknown-none-elf".into(),
+        metadata: crate::spec::TargetMetadata {
+            description: Some("Motor OS".into()),
+            tier: Some(3),
+            host_tools: None,
+            std: None,
+        },
+        pointer_width: 64,
+        data_layout:
+            "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(),
+        arch: "x86_64".into(),
+        options: base,
+    }
+}
diff --git a/src/bootstrap/src/core/sanity.rs b/src/bootstrap/src/core/sanity.rs
index 68202500d9791..91d80c96e4268 100644
--- a/src/bootstrap/src/core/sanity.rs
+++ b/src/bootstrap/src/core/sanity.rs
@@ -38,6 +38,7 @@ const STAGE0_MISSING_TARGETS: &[&str] = &[
     // just a dummy comment so the list doesn't get onelined
     "aarch64_be-unknown-hermit",
     "aarch64_be-unknown-none-softfloat",
+    "x86_64-unknown-motor",
 ];
 
 /// Minimum version threshold for libstdc++ required when using prebuilt LLVM
@@ -239,6 +240,10 @@ than building it.
             continue;
         }
 
+        if target.contains("motor") {
+            continue;
+        }
+
         // skip check for cross-targets
         if skip_target_sanity && target != &build.host_target {
             continue;
diff --git a/src/doc/rustc/src/platform-support.md b/src/doc/rustc/src/platform-support.md
index e5e46f7263751..99c8e365f5cf5 100644
--- a/src/doc/rustc/src/platform-support.md
+++ b/src/doc/rustc/src/platform-support.md
@@ -431,6 +431,7 @@ target | std | host | notes
 `x86_64-unknown-l4re-uclibc` | ? |  |
 [`x86_64-unknown-linux-none`](platform-support/x86_64-unknown-linux-none.md) | * |  | 64-bit Linux with no libc
 [`x86_64-unknown-managarm-mlibc`](platform-support/managarm.md) | ? |   | x86_64 Managarm
+[`x86_64-unknown-motor`[(platform-support/motor.md) | ? |  | x86_64 Motor OS
 [`x86_64-unknown-openbsd`](platform-support/openbsd.md) | ✓ | ✓ | 64-bit OpenBSD
 [`x86_64-unknown-trusty`](platform-support/trusty.md) | ✓ |  |
 `x86_64-uwp-windows-gnu` | ✓ |  |
diff --git a/src/doc/rustc/src/platform-support/motor.md b/src/doc/rustc/src/platform-support/motor.md
new file mode 100644
index 0000000000000..e7aa7b23f3a54
--- /dev/null
+++ b/src/doc/rustc/src/platform-support/motor.md
@@ -0,0 +1,45 @@
+# `x86_64-unknown-motor`
+
+**Tier: 3**
+
+[Motor OS](https://github.com/moturus/motor-os) is a new operating system
+for virtualized environments.
+
+## Target maintainers
+
+[@lasiotus](https://github.com/lasiotus)
+
+## Requirements
+
+This target is cross-compiled. There are no special requirements for the host.
+
+Motor OS uses the ELF file format.
+
+## Building the target
+
+The target can be built by enabling it for a `rustc` build, for example:
+
+```toml
+[build]
+build-stage = 2
+target = ["x86_64-unknown-motor"]
+```
+
+## Building Rust programs
+
+Rust standard library is fully supported/implemented, but is not yet part of
+the official Rust repo, so an out-of-tree building process should be
+followed, as described in the
+[build doc](https://github.com/moturus/motor-os/blob/main/docs/build.md).
+
+## Testing
+
+Cross-compiled Rust binaries and test artifacts can be executed in Motor OS VMs,
+as described in e.g.
+[Hello Motor OS](https://github.com/moturus/motor-os/blob/main/docs/recipes/hello-motor-os.md)
+example.
+
+## Cross-compilation toolchains and C code
+
+C code can be compiled as part of Rust cargo projects. However, there is
+no libc support.
diff --git a/tests/assembly-llvm/targets/targets-elf.rs b/tests/assembly-llvm/targets/targets-elf.rs
index b5c116cdfef0d..ebea9fe40f518 100644
--- a/tests/assembly-llvm/targets/targets-elf.rs
+++ b/tests/assembly-llvm/targets/targets-elf.rs
@@ -658,6 +658,9 @@
 //@ revisions: x86_64_unknown_managarm_mlibc
 //@ [x86_64_unknown_managarm_mlibc] compile-flags: --target x86_64-unknown-managarm-mlibc
 //@ [x86_64_unknown_managarm_mlibc] needs-llvm-components: x86
+//@ revisions: x86_64_unknown_motor
+//@ [x86_64_unknown_motor] compile-flags: --target x86_64-unknown-motor
+//@ [x86_64_unknown_motor] needs-llvm-components: x86
 //@ revisions: x86_64_unknown_netbsd
 //@ [x86_64_unknown_netbsd] compile-flags: --target x86_64-unknown-netbsd
 //@ [x86_64_unknown_netbsd] needs-llvm-components: x86
diff --git a/tests/ui/check-cfg/cfg-crate-features.stderr b/tests/ui/check-cfg/cfg-crate-features.stderr
index 6b2e628e12ea1..39fee52a909b6 100644
--- a/tests/ui/check-cfg/cfg-crate-features.stderr
+++ b/tests/ui/check-cfg/cfg-crate-features.stderr
@@ -24,7 +24,7 @@ warning: unexpected `cfg` condition value: `does_not_exist`
 LL | #![cfg(not(target(os = "does_not_exist")))]
    |                   ^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: expected values for `target_os` are: `aix`, `amdhsa`, `android`, `cuda`, `cygwin`, `dragonfly`, `emscripten`, `espidf`, `freebsd`, `fuchsia`, `haiku`, `hermit`, `horizon`, `hurd`, `illumos`, `ios`, `l4re`, `linux`, `lynxos178`, `macos`, `managarm`, `netbsd`, `none`, `nto`, `nuttx`, `openbsd`, `psp`, `psx`, `redox`, `rtems`, `solaris`, `solid_asp3`, `teeos`, `trusty`, and `tvos` and 11 more
+   = note: expected values for `target_os` are: `aix`, `amdhsa`, `android`, `cuda`, `cygwin`, `dragonfly`, `emscripten`, `espidf`, `freebsd`, `fuchsia`, `haiku`, `hermit`, `horizon`, `hurd`, `illumos`, `ios`, `l4re`, `linux`, `lynxos178`, `macos`, `managarm`, `motor`, `netbsd`, `none`, `nto`, `nuttx`, `openbsd`, `psp`, `psx`, `redox`, `rtems`, `solaris`, `solid_asp3`, `teeos`, and `trusty` and 12 more
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
    = note: `#[warn(unexpected_cfgs)]` on by default
 
diff --git a/tests/ui/check-cfg/well-known-values.stderr b/tests/ui/check-cfg/well-known-values.stderr
index 6490fc63fd766..df2357696a377 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`, `amdhsa`, `android`, `cuda`, `cygwin`, `dragonfly`, `emscripten`, `espidf`, `freebsd`, `fuchsia`, `haiku`, `hermit`, `horizon`, `hurd`, `illumos`, `ios`, `l4re`, `linux`, `lynxos178`, `macos`, `managarm`, `netbsd`, `none`, `nto`, `nuttx`, `openbsd`, `psp`, `psx`, `redox`, `rtems`, `solaris`, `solid_asp3`, `teeos`, `trusty`, `tvos`, `uefi`, `unknown`, `vexos`, `visionos`, `vita`, `vxworks`, `wasi`, `watchos`, `windows`, `xous`, and `zkvm`
+   = note: expected values for `target_os` are: `aix`, `amdhsa`, `android`, `cuda`, `cygwin`, `dragonfly`, `emscripten`, `espidf`, `freebsd`, `fuchsia`, `haiku`, `hermit`, `horizon`, `hurd`, `illumos`, `ios`, `l4re`, `linux`, `lynxos178`, `macos`, `managarm`, `motor`, `netbsd`, `none`, `nto`, `nuttx`, `openbsd`, `psp`, `psx`, `redox`, `rtems`, `solaris`, `solid_asp3`, `teeos`, `trusty`, `tvos`, `uefi`, `unknown`, `vexos`, `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`
@@ -274,7 +274,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`, `amdhsa`, `android`, `cuda`, `cygwin`, `dragonfly`, `emscripten`, `espidf`, `freebsd`, `fuchsia`, `haiku`, `hermit`, `horizon`, `hurd`, `illumos`, `ios`, `l4re`, `linux`, `lynxos178`, `macos`, `managarm`, `netbsd`, `none`, `nto`, `nuttx`, `openbsd`, `psp`, `psx`, `redox`, `rtems`, `solaris`, `solid_asp3`, `teeos`, `trusty`, `tvos`, `uefi`, `unknown`, `vexos`, `visionos`, `vita`, `vxworks`, `wasi`, `watchos`, `windows`, `xous`, and `zkvm`
+   = note: expected values for `target_os` are: `aix`, `amdhsa`, `android`, `cuda`, `cygwin`, `dragonfly`, `emscripten`, `espidf`, `freebsd`, `fuchsia`, `haiku`, `hermit`, `horizon`, `hurd`, `illumos`, `ios`, `l4re`, `linux`, `lynxos178`, `macos`, `managarm`, `motor`, `netbsd`, `none`, `nto`, `nuttx`, `openbsd`, `psp`, `psx`, `redox`, `rtems`, `solaris`, `solid_asp3`, `teeos`, `trusty`, `tvos`, `uefi`, `unknown`, `vexos`, `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: 28 warnings emitted

From c54a953402aaa132c363b578f59cd30e39cb0abb Mon Sep 17 00:00:00 2001
From: Yotam Ofek <yotam.ofek@gmail.com>
Date: Sun, 21 Sep 2025 11:18:30 +0300
Subject: [PATCH 1236/1889] Early return in `visibility_print_with_space`

---
 src/librustdoc/html/format.rs | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
index 8c75f301841f3..950d3a08827d2 100644
--- a/src/librustdoc/html/format.rs
+++ b/src/librustdoc/html/format.rs
@@ -1422,10 +1422,13 @@ pub(crate) fn visibility_print_with_space(item: &clean::Item, cx: &Context<'_>)
             f.write_str("#[doc(hidden)] ")?;
         }
 
-        match item.visibility(cx.tcx()) {
-            None => {}
-            Some(ty::Visibility::Public) => f.write_str("pub ")?,
-            Some(ty::Visibility::Restricted(vis_did)) => {
+        let Some(vis) = item.visibility(cx.tcx()) else {
+            return Ok(());
+        };
+
+        match vis {
+            ty::Visibility::Public => f.write_str("pub ")?,
+            ty::Visibility::Restricted(vis_did) => {
                 // FIXME(camelid): This may not work correctly if `item_did` is a module.
                 //                 However, rustdoc currently never displays a module's
                 //                 visibility, so it shouldn't matter.

From cdf96614cf19643a0337e8b012d3e72f1bfa3cd2 Mon Sep 17 00:00:00 2001
From: Yotam Ofek <yotam.ofek@gmail.com>
Date: Sun, 21 Sep 2025 10:55:50 +0300
Subject: [PATCH 1237/1889] Re-use some existing util fns

---
 src/librustdoc/html/format.rs | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
index 950d3a08827d2..fa55de4239a2a 100644
--- a/src/librustdoc/html/format.rs
+++ b/src/librustdoc/html/format.rs
@@ -965,10 +965,7 @@ fn fmt_type(
             write!(f, "]")
         }
         clean::RawPointer(m, t) => {
-            let m = match m {
-                hir::Mutability::Mut => "mut",
-                hir::Mutability::Not => "const",
-            };
+            let m = m.ptr_str();
 
             if matches!(**t, clean::Generic(_)) || t.is_assoc_ty() {
                 let ty = t.print(cx);
@@ -1406,12 +1403,13 @@ impl clean::FnDecl {
     }
 
     fn print_output(&self, cx: &Context<'_>) -> impl Display {
-        fmt::from_fn(move |f| match &self.output {
-            clean::Tuple(tys) if tys.is_empty() => Ok(()),
-            ty if f.alternate() => {
-                write!(f, " -> {:#}", ty.print(cx))
+        fmt::from_fn(move |f| {
+            if self.output.is_unit() {
+                return Ok(());
             }
-            ty => write!(f, " -&gt; {}", ty.print(cx)),
+
+            f.write_str(if f.alternate() { " -> " } else { " -&gt; " })?;
+            self.output.print(cx).fmt(f)
         })
     }
 }

From f1d6e000b500bd23a9f75716a161bc015ab49273 Mon Sep 17 00:00:00 2001
From: Jules Bertholet <julesbertholet@quoi.xyz>
Date: Sun, 21 Sep 2025 17:26:39 -0400
Subject: [PATCH 1238/1889] Bless UI tests

---
 tests/ui/explicit-tail-calls/callee_is_weird.stderr      | 2 +-
 tests/ui/impl-trait/where-allowed.stderr                 | 2 ++
 tests/ui/traits/next-solver/well-formed-in-relate.stderr | 2 ++
 3 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/tests/ui/explicit-tail-calls/callee_is_weird.stderr b/tests/ui/explicit-tail-calls/callee_is_weird.stderr
index a4e5a38ce3320..9a5da28b559e3 100644
--- a/tests/ui/explicit-tail-calls/callee_is_weird.stderr
+++ b/tests/ui/explicit-tail-calls/callee_is_weird.stderr
@@ -12,7 +12,7 @@ error: tail calls can only be performed with function definitions or pointers
 LL |     become (&mut &std::sync::Exclusive::new(f))()
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: callee has type `Exclusive<fn() {f}>`
+   = note: callee has type `&Exclusive<fn() {f}>`
 
 error: tail calls can only be performed with function definitions or pointers
   --> $DIR/callee_is_weird.rs:22:12
diff --git a/tests/ui/impl-trait/where-allowed.stderr b/tests/ui/impl-trait/where-allowed.stderr
index 08caff326c470..4d8f23bf7ca64 100644
--- a/tests/ui/impl-trait/where-allowed.stderr
+++ b/tests/ui/impl-trait/where-allowed.stderr
@@ -387,6 +387,8 @@ LL | fn in_impl_Fn_return_in_return() -> &'static impl Fn() -> impl Debug { pani
              where A: Tuple, F: Fn<A>, F: ?Sized;
            - impl<Args, F, A> Fn<Args> for Box<F, A>
              where Args: Tuple, F: Fn<Args>, A: Allocator, F: ?Sized;
+           - impl<F, Args> Fn<Args> for Exclusive<F>
+             where F: Sync, F: Fn<Args>, Args: Tuple;
 
 error[E0118]: no nominal type found for inherent implementation
   --> $DIR/where-allowed.rs:240:1
diff --git a/tests/ui/traits/next-solver/well-formed-in-relate.stderr b/tests/ui/traits/next-solver/well-formed-in-relate.stderr
index 5294a072d3123..d79e465b3e387 100644
--- a/tests/ui/traits/next-solver/well-formed-in-relate.stderr
+++ b/tests/ui/traits/next-solver/well-formed-in-relate.stderr
@@ -12,6 +12,8 @@ LL |     x = unconstrained_map();
              where A: Tuple, F: Fn<A>, F: ?Sized;
            - impl<Args, F, A> Fn<Args> for Box<F, A>
              where Args: Tuple, F: Fn<Args>, A: Allocator, F: ?Sized;
+           - impl<F, Args> Fn<Args> for Exclusive<F>
+             where F: Sync, F: Fn<Args>, Args: Tuple;
 note: required by a bound in `unconstrained_map`
   --> $DIR/well-formed-in-relate.rs:21:25
    |

From 0ed31beba681fab11b8137b81c981c57cab06308 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sun, 21 Sep 2025 23:27:21 +0200
Subject: [PATCH 1239/1889] rename `mut_reference` to `unnecessary_mut_passed`

The lint was probably renamed at some point, but the files weren't. This
made it annoying to search for the lint.
---
 clippy_lints/src/declared_lints.rs            |  2 +-
 clippy_lints/src/lib.rs                       |  4 ++--
 ...reference.rs => unnecessary_mut_passed.rs} |  0
 ...nce.fixed => unnecessary_mut_passed.fixed} |  0
 ...reference.rs => unnecessary_mut_passed.rs} |  0
 ...e.stderr => unnecessary_mut_passed.stderr} | 24 +++++++++----------
 6 files changed, 15 insertions(+), 15 deletions(-)
 rename clippy_lints/src/{mut_reference.rs => unnecessary_mut_passed.rs} (100%)
 rename tests/ui/{mut_reference.fixed => unnecessary_mut_passed.fixed} (100%)
 rename tests/ui/{mut_reference.rs => unnecessary_mut_passed.rs} (100%)
 rename tests/ui/{mut_reference.stderr => unnecessary_mut_passed.stderr} (80%)

diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 5563b8094f01b..89178290e1a2f 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -535,7 +535,6 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::multiple_unsafe_ops_per_block::MULTIPLE_UNSAFE_OPS_PER_BLOCK_INFO,
     crate::mut_key::MUTABLE_KEY_TYPE_INFO,
     crate::mut_mut::MUT_MUT_INFO,
-    crate::mut_reference::UNNECESSARY_MUT_PASSED_INFO,
     crate::mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL_INFO,
     crate::mutex_atomic::MUTEX_ATOMIC_INFO,
     crate::mutex_atomic::MUTEX_INTEGER_INFO,
@@ -752,6 +751,7 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::unnecessary_box_returns::UNNECESSARY_BOX_RETURNS_INFO,
     crate::unnecessary_literal_bound::UNNECESSARY_LITERAL_BOUND_INFO,
     crate::unnecessary_map_on_constructor::UNNECESSARY_MAP_ON_CONSTRUCTOR_INFO,
+    crate::unnecessary_mut_passed::UNNECESSARY_MUT_PASSED_INFO,
     crate::unnecessary_owned_empty_strings::UNNECESSARY_OWNED_EMPTY_STRINGS_INFO,
     crate::unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS_INFO,
     crate::unnecessary_semicolon::UNNECESSARY_SEMICOLON_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c56fa257b0689..1d6c836691547 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -253,7 +253,6 @@ mod multiple_bound_locations;
 mod multiple_unsafe_ops_per_block;
 mod mut_key;
 mod mut_mut;
-mod mut_reference;
 mod mutable_debug_assertion;
 mod mutex_atomic;
 mod needless_arbitrary_self_type;
@@ -375,6 +374,7 @@ mod unit_types;
 mod unnecessary_box_returns;
 mod unnecessary_literal_bound;
 mod unnecessary_map_on_constructor;
+mod unnecessary_mut_passed;
 mod unnecessary_owned_empty_strings;
 mod unnecessary_self_imports;
 mod unnecessary_semicolon;
@@ -483,7 +483,7 @@ pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Co
     store.register_late_pass(|_| Box::new(misc::LintPass));
     store.register_late_pass(|_| Box::new(eta_reduction::EtaReduction));
     store.register_late_pass(|_| Box::new(mut_mut::MutMut));
-    store.register_late_pass(|_| Box::new(mut_reference::UnnecessaryMutPassed));
+    store.register_late_pass(|_| Box::new(unnecessary_mut_passed::UnnecessaryMutPassed));
     store.register_late_pass(|_| Box::<significant_drop_tightening::SignificantDropTightening<'_>>::default());
     store.register_late_pass(|_| Box::new(len_zero::LenZero));
     store.register_late_pass(move |_| Box::new(attrs::Attributes::new(conf)));
diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/unnecessary_mut_passed.rs
similarity index 100%
rename from clippy_lints/src/mut_reference.rs
rename to clippy_lints/src/unnecessary_mut_passed.rs
diff --git a/tests/ui/mut_reference.fixed b/tests/ui/unnecessary_mut_passed.fixed
similarity index 100%
rename from tests/ui/mut_reference.fixed
rename to tests/ui/unnecessary_mut_passed.fixed
diff --git a/tests/ui/mut_reference.rs b/tests/ui/unnecessary_mut_passed.rs
similarity index 100%
rename from tests/ui/mut_reference.rs
rename to tests/ui/unnecessary_mut_passed.rs
diff --git a/tests/ui/mut_reference.stderr b/tests/ui/unnecessary_mut_passed.stderr
similarity index 80%
rename from tests/ui/mut_reference.stderr
rename to tests/ui/unnecessary_mut_passed.stderr
index 5ecfaa37416ba..c69a637bf4088 100644
--- a/tests/ui/mut_reference.stderr
+++ b/tests/ui/unnecessary_mut_passed.stderr
@@ -1,5 +1,5 @@
 error: the function `takes_ref` doesn't need a mutable reference
-  --> tests/ui/mut_reference.rs:56:15
+  --> tests/ui/unnecessary_mut_passed.rs:56:15
    |
 LL |     takes_ref(&mut 42);
    |               ^^^^^^^ help: remove this `mut`: `&42`
@@ -8,67 +8,67 @@ LL |     takes_ref(&mut 42);
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_mut_passed)]`
 
 error: the function `takes_ref_ref` doesn't need a mutable reference
-  --> tests/ui/mut_reference.rs:58:19
+  --> tests/ui/unnecessary_mut_passed.rs:58:19
    |
 LL |     takes_ref_ref(&mut &42);
    |                   ^^^^^^^^ help: remove this `mut`: `&&42`
 
 error: the function `takes_ref_refmut` doesn't need a mutable reference
-  --> tests/ui/mut_reference.rs:60:22
+  --> tests/ui/unnecessary_mut_passed.rs:60:22
    |
 LL |     takes_ref_refmut(&mut &mut 42);
    |                      ^^^^^^^^^^^^ help: remove this `mut`: `&&mut 42`
 
 error: the function `takes_raw_const` doesn't need a mutable reference
-  --> tests/ui/mut_reference.rs:62:21
+  --> tests/ui/unnecessary_mut_passed.rs:62:21
    |
 LL |     takes_raw_const(&mut 42);
    |                     ^^^^^^^ help: remove this `mut`: `&42`
 
 error: the function `as_ptr` doesn't need a mutable reference
-  --> tests/ui/mut_reference.rs:66:12
+  --> tests/ui/unnecessary_mut_passed.rs:66:12
    |
 LL |     as_ptr(&mut 42);
    |            ^^^^^^^ help: remove this `mut`: `&42`
 
 error: the function `as_ptr` doesn't need a mutable reference
-  --> tests/ui/mut_reference.rs:69:12
+  --> tests/ui/unnecessary_mut_passed.rs:69:12
    |
 LL |     as_ptr(&mut &42);
    |            ^^^^^^^^ help: remove this `mut`: `&&42`
 
 error: the function `as_ptr` doesn't need a mutable reference
-  --> tests/ui/mut_reference.rs:72:12
+  --> tests/ui/unnecessary_mut_passed.rs:72:12
    |
 LL |     as_ptr(&mut &mut 42);
    |            ^^^^^^^^^^^^ help: remove this `mut`: `&&mut 42`
 
 error: the function `as_ptr` doesn't need a mutable reference
-  --> tests/ui/mut_reference.rs:75:12
+  --> tests/ui/unnecessary_mut_passed.rs:75:12
    |
 LL |     as_ptr(&mut 42);
    |            ^^^^^^^ help: remove this `mut`: `&42`
 
 error: the method `takes_ref` doesn't need a mutable reference
-  --> tests/ui/mut_reference.rs:80:25
+  --> tests/ui/unnecessary_mut_passed.rs:80:25
    |
 LL |     my_struct.takes_ref(&mut 42);
    |                         ^^^^^^^ help: remove this `mut`: `&42`
 
 error: the method `takes_ref_ref` doesn't need a mutable reference
-  --> tests/ui/mut_reference.rs:82:29
+  --> tests/ui/unnecessary_mut_passed.rs:82:29
    |
 LL |     my_struct.takes_ref_ref(&mut &42);
    |                             ^^^^^^^^ help: remove this `mut`: `&&42`
 
 error: the method `takes_ref_refmut` doesn't need a mutable reference
-  --> tests/ui/mut_reference.rs:84:32
+  --> tests/ui/unnecessary_mut_passed.rs:84:32
    |
 LL |     my_struct.takes_ref_refmut(&mut &mut 42);
    |                                ^^^^^^^^^^^^ help: remove this `mut`: `&&mut 42`
 
 error: the method `takes_raw_const` doesn't need a mutable reference
-  --> tests/ui/mut_reference.rs:86:31
+  --> tests/ui/unnecessary_mut_passed.rs:86:31
    |
 LL |     my_struct.takes_raw_const(&mut 42);
    |                               ^^^^^^^ help: remove this `mut`: `&42`

From 20671600a2873139a61c39128a359225c8580d3c Mon Sep 17 00:00:00 2001
From: Yotam Ofek <yotam.ofek@gmail.com>
Date: Sun, 21 Sep 2025 11:13:37 +0300
Subject: [PATCH 1240/1889] Introduce "wrapper" helpers to rustdoc

---
 src/librustdoc/clean/cfg.rs   |  78 ++++-----
 src/librustdoc/display.rs     |  86 ++++++++-
 src/librustdoc/html/format.rs | 321 ++++++++++++++--------------------
 src/librustdoc/lib.rs         |   1 +
 4 files changed, 248 insertions(+), 238 deletions(-)

diff --git a/src/librustdoc/clean/cfg.rs b/src/librustdoc/clean/cfg.rs
index e204e1788baa8..8feca1367fc9e 100644
--- a/src/librustdoc/clean/cfg.rs
+++ b/src/librustdoc/clean/cfg.rs
@@ -3,16 +3,16 @@
 // FIXME: Once the portability lint RFC is implemented (see tracking issue #41619),
 // switch to use those structures instead.
 
-use std::fmt::{self, Write};
-use std::{mem, ops};
+use std::{fmt, mem, ops};
 
+use itertools::Either;
 use rustc_ast::{LitKind, MetaItem, MetaItemInner, MetaItemKind, MetaItemLit};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_session::parse::ParseSess;
 use rustc_span::Span;
 use rustc_span::symbol::{Symbol, sym};
 
-use crate::display::Joined as _;
+use crate::display::{Joined as _, MaybeDisplay, Wrapped};
 use crate::html::escape::Escape;
 
 #[cfg(test)]
@@ -376,27 +376,20 @@ impl Format {
             Format::LongPlain => false,
         }
     }
+
+    fn escape(self, s: &str) -> impl fmt::Display {
+        if self.is_html() { Either::Left(Escape(s)) } else { Either::Right(s) }
+    }
 }
 
 /// Pretty-print wrapper for a `Cfg`. Also indicates what form of rendering should be used.
 struct Display<'a>(&'a Cfg, Format);
 
-fn write_with_opt_paren<T: fmt::Display>(
-    fmt: &mut fmt::Formatter<'_>,
-    has_paren: bool,
-    obj: T,
-) -> fmt::Result {
-    if has_paren {
-        fmt.write_char('(')?;
-    }
-    obj.fmt(fmt)?;
-    if has_paren {
-        fmt.write_char(')')?;
+impl Display<'_> {
+    fn code_wrappers(&self) -> Wrapped<&'static str> {
+        if self.1.is_html() { Wrapped::with("<code>", "</code>") } else { Wrapped::with("`", "`") }
     }
-    Ok(())
-}
 
-impl Display<'_> {
     fn display_sub_cfgs(
         &self,
         fmt: &mut fmt::Formatter<'_>,
@@ -427,20 +420,17 @@ impl Display<'_> {
             sub_cfgs
                 .iter()
                 .map(|sub_cfg| {
-                    fmt::from_fn(move |fmt| {
-                        if let Cfg::Cfg(_, Some(feat)) = sub_cfg
-                            && short_longhand
-                        {
-                            if self.1.is_html() {
-                                write!(fmt, "<code>{feat}</code>")?;
-                            } else {
-                                write!(fmt, "`{feat}`")?;
-                            }
-                        } else {
-                            write_with_opt_paren(fmt, !sub_cfg.is_all(), Display(sub_cfg, self.1))?;
-                        }
-                        Ok(())
-                    })
+                    if let Cfg::Cfg(_, Some(feat)) = sub_cfg
+                        && short_longhand
+                    {
+                        Either::Left(self.code_wrappers().wrap(feat))
+                    } else {
+                        Either::Right(
+                            Wrapped::with_parens()
+                                .when(!sub_cfg.is_all())
+                                .wrap(Display(sub_cfg, self.1)),
+                        )
+                    }
                 })
                 .joined(separator, f)
         })
@@ -461,9 +451,9 @@ impl fmt::Display for Display<'_> {
                 sub_cfgs
                     .iter()
                     .map(|sub_cfg| {
-                        fmt::from_fn(|fmt| {
-                            write_with_opt_paren(fmt, !sub_cfg.is_all(), Display(sub_cfg, self.1))
-                        })
+                        Wrapped::with_parens()
+                            .when(!sub_cfg.is_all())
+                            .wrap(Display(sub_cfg, self.1))
                     })
                     .joined(separator, fmt)
             }
@@ -568,21 +558,13 @@ impl fmt::Display for Display<'_> {
                 };
                 if !human_readable.is_empty() {
                     fmt.write_str(human_readable)
-                } else if let Some(v) = value {
-                    if self.1.is_html() {
-                        write!(
-                            fmt,
-                            r#"<code>{}="{}"</code>"#,
-                            Escape(name.as_str()),
-                            Escape(v.as_str())
-                        )
-                    } else {
-                        write!(fmt, r#"`{name}="{v}"`"#)
-                    }
-                } else if self.1.is_html() {
-                    write!(fmt, "<code>{}</code>", Escape(name.as_str()))
                 } else {
-                    write!(fmt, "`{name}`")
+                    let value = value
+                        .map(|v| fmt::from_fn(move |f| write!(f, "={}", self.1.escape(v.as_str()))))
+                        .maybe_display();
+                    self.code_wrappers()
+                        .wrap(format_args!("{}{value}", self.1.escape(name.as_str())))
+                        .fmt(fmt)
                 }
             }
         }
diff --git a/src/librustdoc/display.rs b/src/librustdoc/display.rs
index db868c5c9a8f3..d62ea4c368804 100644
--- a/src/librustdoc/display.rs
+++ b/src/librustdoc/display.rs
@@ -1,6 +1,6 @@
 //! Various utilities for working with [`fmt::Display`] implementations.
 
-use std::fmt::{self, Display, Formatter};
+use std::fmt::{self, Display, Formatter, FormattingOptions};
 
 pub(crate) trait Joined: IntoIterator {
     /// Takes an iterator over elements that implement [`Display`], and format them into `f`, separated by `sep`.
@@ -45,3 +45,87 @@ impl<T: Display> MaybeDisplay for Option<T> {
         })
     }
 }
+
+#[derive(Clone, Copy)]
+pub(crate) struct Wrapped<T> {
+    prefix: T,
+    suffix: T,
+}
+
+pub(crate) enum AngleBracket {
+    Open,
+    Close,
+}
+
+impl Display for AngleBracket {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        f.write_str(match (self, f.alternate()) {
+            (Self::Open, true) => "<",
+            (Self::Open, false) => "&lt;",
+            (Self::Close, true) => ">",
+            (Self::Close, false) => "&gt;",
+        })
+    }
+}
+
+impl Wrapped<AngleBracket> {
+    pub(crate) fn with_angle_brackets() -> Self {
+        Self { prefix: AngleBracket::Open, suffix: AngleBracket::Close }
+    }
+}
+
+impl Wrapped<char> {
+    pub(crate) fn with_parens() -> Self {
+        Self { prefix: '(', suffix: ')' }
+    }
+
+    pub(crate) fn with_square_brackets() -> Self {
+        Self { prefix: '[', suffix: ']' }
+    }
+}
+
+impl<T: Display> Wrapped<T> {
+    pub(crate) fn with(prefix: T, suffix: T) -> Self {
+        Self { prefix, suffix }
+    }
+
+    pub(crate) fn when(self, if_: bool) -> Wrapped<impl Display> {
+        Wrapped {
+            prefix: if_.then_some(self.prefix).maybe_display(),
+            suffix: if_.then_some(self.suffix).maybe_display(),
+        }
+    }
+
+    pub(crate) fn wrap_fn(
+        self,
+        content: impl Fn(&mut Formatter<'_>) -> fmt::Result,
+    ) -> impl Display {
+        fmt::from_fn(move |f| {
+            self.prefix.fmt(f)?;
+            content(f)?;
+            self.suffix.fmt(f)
+        })
+    }
+
+    pub(crate) fn wrap<C: Display>(self, content: C) -> impl Display {
+        self.wrap_fn(move |f| content.fmt(f))
+    }
+}
+
+#[derive(Clone, Copy)]
+pub(crate) struct WithOpts {
+    opts: FormattingOptions,
+}
+
+impl WithOpts {
+    pub(crate) fn from(f: &Formatter<'_>) -> Self {
+        Self { opts: f.options() }
+    }
+
+    pub(crate) fn display(self, t: impl Display) -> impl Display {
+        fmt::from_fn(move |f| {
+            let mut f = f.with_options(self.opts);
+            t.fmt(&mut f)
+        })
+    }
+}
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
index fa55de4239a2a..ecaff4cdf43af 100644
--- a/src/librustdoc/html/format.rs
+++ b/src/librustdoc/html/format.rs
@@ -30,7 +30,7 @@ use super::url_parts_builder::UrlPartsBuilder;
 use crate::clean::types::ExternalLocation;
 use crate::clean::utils::find_nearest_parent_module;
 use crate::clean::{self, ExternalCrate, PrimitiveType};
-use crate::display::{Joined as _, MaybeDisplay as _};
+use crate::display::{Joined as _, MaybeDisplay as _, WithOpts, Wrapped};
 use crate::formats::cache::Cache;
 use crate::formats::item_type::ItemType;
 use crate::html::escape::{Escape, EscapeBodyText};
@@ -105,20 +105,16 @@ impl clean::GenericParamDef {
 
 impl clean::Generics {
     pub(crate) fn print(&self, cx: &Context<'_>) -> impl Display {
-        fmt::from_fn(move |f| {
-            let mut real_params = self.params.iter().filter(|p| !p.is_synthetic_param()).peekable();
-            if real_params.peek().is_none() {
-                return Ok(());
-            }
-
-            let real_params =
-                fmt::from_fn(|f| real_params.clone().map(|g| g.print(cx)).joined(", ", f));
-            if f.alternate() {
-                write!(f, "<{real_params:#}>")
-            } else {
-                write!(f, "&lt;{real_params}&gt;")
-            }
-        })
+        let mut real_params = self.params.iter().filter(|p| !p.is_synthetic_param()).peekable();
+        if real_params.peek().is_none() {
+            None
+        } else {
+            Some(
+                Wrapped::with_angle_brackets()
+                    .wrap_fn(move |f| real_params.clone().map(|g| g.print(cx)).joined(", ", f)),
+            )
+        }
+        .maybe_display()
     }
 }
 
@@ -151,11 +147,8 @@ fn print_where_predicate(predicate: &clean::WherePredicate, cx: &Context<'_>) ->
                 Ok(())
             }
             clean::WherePredicate::EqPredicate { lhs, rhs } => {
-                if f.alternate() {
-                    write!(f, "{:#} == {:#}", lhs.print(cx), rhs.print(cx))
-                } else {
-                    write!(f, "{} == {}", lhs.print(cx), rhs.print(cx))
-                }
+                let opts = WithOpts::from(f);
+                write!(f, "{} == {}", opts.display(lhs.print(cx)), opts.display(rhs.print(cx)))
             }
         }
     })
@@ -279,13 +272,10 @@ impl clean::GenericBound {
                 ty.print(cx).fmt(f)
             }
             clean::GenericBound::Use(args) => {
-                if f.alternate() {
-                    f.write_str("use<")?;
-                } else {
-                    f.write_str("use&lt;")?;
-                }
-                args.iter().map(|arg| arg.name()).joined(", ", f)?;
-                if f.alternate() { f.write_str(">") } else { f.write_str("&gt;") }
+                f.write_str("use")?;
+                Wrapped::with_angle_brackets()
+                    .wrap_fn(|f| args.iter().map(|arg| arg.name()).joined(", ", f))
+                    .fmt(f)
             }
         })
     }
@@ -297,40 +287,29 @@ impl clean::GenericArgs {
             match self {
                 clean::GenericArgs::AngleBracketed { args, constraints } => {
                     if !args.is_empty() || !constraints.is_empty() {
-                        if f.alternate() {
-                            f.write_str("<")?;
-                        } else {
-                            f.write_str("&lt;")?;
-                        }
-
-                        [Either::Left(args), Either::Right(constraints)]
-                            .into_iter()
-                            .flat_map(Either::factor_into_iter)
-                            .map(|either| {
-                                either.map_either(
-                                    |arg| arg.print(cx),
-                                    |constraint| constraint.print(cx),
-                                )
+                        Wrapped::with_angle_brackets()
+                            .wrap_fn(|f| {
+                                [Either::Left(args), Either::Right(constraints)]
+                                    .into_iter()
+                                    .flat_map(Either::factor_into_iter)
+                                    .map(|either| {
+                                        either.map_either(
+                                            |arg| arg.print(cx),
+                                            |constraint| constraint.print(cx),
+                                        )
+                                    })
+                                    .joined(", ", f)
                             })
-                            .joined(", ", f)?;
-
-                        if f.alternate() {
-                            f.write_str(">")?;
-                        } else {
-                            f.write_str("&gt;")?;
-                        }
+                            .fmt(f)?;
                     }
                 }
                 clean::GenericArgs::Parenthesized { inputs, output } => {
-                    f.write_str("(")?;
-                    inputs.iter().map(|ty| ty.print(cx)).joined(", ", f)?;
-                    f.write_str(")")?;
+                    Wrapped::with_parens()
+                        .wrap_fn(|f| inputs.iter().map(|ty| ty.print(cx)).joined(", ", f))
+                        .fmt(f)?;
                     if let Some(ref ty) = *output {
-                        if f.alternate() {
-                            write!(f, " -> {:#}", ty.print(cx))?;
-                        } else {
-                            write!(f, " -&gt; {}", ty.print(cx))?;
-                        }
+                        f.write_str(if f.alternate() { " -> " } else { " -&gt; " })?;
+                        ty.print(cx).fmt(f)?;
                     }
                 }
                 clean::GenericArgs::ReturnTypeNotation => {
@@ -834,9 +813,10 @@ fn print_higher_ranked_params_with_space(
     fmt::from_fn(move |f| {
         if !params.is_empty() {
             f.write_str(keyword)?;
-            f.write_str(if f.alternate() { "<" } else { "&lt;" })?;
-            params.iter().map(|lt| lt.print(cx)).joined(", ", f)?;
-            f.write_str(if f.alternate() { "> " } else { "&gt; " })?;
+            Wrapped::with_angle_brackets()
+                .wrap_fn(|f| params.iter().map(|lt| lt.print(cx)).joined(", ", f))
+                .fmt(f)?;
+            f.write_char(' ')?;
         }
         Ok(())
     })
@@ -923,26 +903,23 @@ fn fmt_type(
                         f,
                         PrimitiveType::Tuple,
                         format_args!(
-                            "({})",
-                            fmt::from_fn(|f| generic_names.iter().joined(", ", f))
+                            "{}",
+                            Wrapped::with_parens()
+                                .wrap_fn(|f| generic_names.iter().joined(", ", f))
                         ),
                         cx,
                     )
                 } else {
-                    f.write_str("(")?;
-                    many.iter().map(|item| item.print(cx)).joined(", ", f)?;
-                    f.write_str(")")
+                    Wrapped::with_parens()
+                        .wrap_fn(|f| many.iter().map(|item| item.print(cx)).joined(", ", f))
+                        .fmt(f)
                 }
             }
         },
         clean::Slice(box clean::Generic(name)) => {
             primitive_link(f, PrimitiveType::Slice, format_args!("[{name}]"), cx)
         }
-        clean::Slice(t) => {
-            write!(f, "[")?;
-            t.print(cx).fmt(f)?;
-            write!(f, "]")
-        }
+        clean::Slice(t) => Wrapped::with_square_brackets().wrap(t.print(cx)).fmt(f),
         clean::Type::Pat(t, pat) => {
             fmt::Display::fmt(&t.print(cx), f)?;
             write!(f, " is {pat}")
@@ -953,37 +930,27 @@ fn fmt_type(
             format_args!("[{name}; {n}]", n = Escape(n)),
             cx,
         ),
-        clean::Array(t, n) => {
-            write!(f, "[")?;
-            t.print(cx).fmt(f)?;
-            if f.alternate() {
-                write!(f, "; {n}")?;
-            } else {
-                write!(f, "; ")?;
-                primitive_link(f, PrimitiveType::Array, format_args!("{n}", n = Escape(n)), cx)?;
-            }
-            write!(f, "]")
-        }
+        clean::Array(t, n) => Wrapped::with_square_brackets()
+            .wrap(fmt::from_fn(|f| {
+                t.print(cx).fmt(f)?;
+                f.write_str("; ")?;
+                if f.alternate() {
+                    f.write_str(n)
+                } else {
+                    primitive_link(f, PrimitiveType::Array, format_args!("{n}", n = Escape(n)), cx)
+                }
+            }))
+            .fmt(f),
         clean::RawPointer(m, t) => {
             let m = m.ptr_str();
 
             if matches!(**t, clean::Generic(_)) || t.is_assoc_ty() {
-                let ty = t.print(cx);
-                if f.alternate() {
-                    primitive_link(
-                        f,
-                        clean::PrimitiveType::RawPointer,
-                        format_args!("*{m} {ty:#}"),
-                        cx,
-                    )
-                } else {
-                    primitive_link(
-                        f,
-                        clean::PrimitiveType::RawPointer,
-                        format_args!("*{m} {ty}"),
-                        cx,
-                    )
-                }
+                primitive_link(
+                    f,
+                    clean::PrimitiveType::RawPointer,
+                    format_args!("*{m} {ty}", ty = WithOpts::from(f).display(t.print(cx))),
+                    cx,
+                )
             } else {
                 primitive_link(f, clean::PrimitiveType::RawPointer, format_args!("*{m} "), cx)?;
                 t.print(cx).fmt(f)
@@ -1017,14 +984,10 @@ fn fmt_type(
                 clean::ImplTrait(ref bounds) if bounds.len() > 1 => true,
                 _ => false,
             };
-            if needs_parens {
-                f.write_str("(")?;
-            }
-            fmt_type(ty, f, use_absolute, cx)?;
-            if needs_parens {
-                f.write_str(")")?;
-            }
-            Ok(())
+            Wrapped::with_parens()
+                .when(needs_parens)
+                .wrap_fn(|f| fmt_type(ty, f, use_absolute, cx))
+                .fmt(f)
         }
         clean::ImplTrait(bounds) => {
             f.write_str("impl ")?;
@@ -1054,23 +1017,21 @@ impl clean::QPathData {
             // FIXME(inherent_associated_types): Once we support non-ADT self-types (#106719),
             // we need to surround them with angle brackets in some cases (e.g. `<dyn …>::P`).
 
-            if f.alternate() {
-                if let Some(trait_) = trait_
-                    && should_fully_qualify
-                {
-                    write!(f, "<{:#} as {:#}>::", self_type.print(cx), trait_.print(cx))?
-                } else {
-                    write!(f, "{:#}::", self_type.print(cx))?
-                }
+            if let Some(trait_) = trait_
+                && should_fully_qualify
+            {
+                let opts = WithOpts::from(f);
+                Wrapped::with_angle_brackets()
+                    .wrap(format_args!(
+                        "{} as {}",
+                        opts.display(self_type.print(cx)),
+                        opts.display(trait_.print(cx))
+                    ))
+                    .fmt(f)?
             } else {
-                if let Some(trait_) = trait_
-                    && should_fully_qualify
-                {
-                    write!(f, "&lt;{} as {}&gt;::", self_type.print(cx), trait_.print(cx))?
-                } else {
-                    write!(f, "{}::", self_type.print(cx))?
-                }
-            };
+                self_type.print(cx).fmt(f)?;
+            }
+            f.write_str("::")?;
             // It's pretty unsightly to look at `<A as B>::C` in output, and
             // we've got hyperlinking on our side, so try to avoid longer
             // notation as much as possible by making `C` a hyperlink to trait
@@ -1129,7 +1090,7 @@ impl clean::Impl {
 
             if let Some(ref ty) = self.trait_ {
                 if self.is_negative_trait_impl() {
-                    write!(f, "!")?;
+                    f.write_char('!')?;
                 }
                 if self.kind.is_fake_variadic()
                     && let Some(generics) = ty.generics()
@@ -1137,18 +1098,17 @@ impl clean::Impl {
                 {
                     let last = ty.last();
                     if f.alternate() {
-                        write!(f, "{last}<")?;
-                        self.print_type(inner_type, f, use_absolute, cx)?;
-                        write!(f, ">")?;
+                        write!(f, "{last}")?;
                     } else {
-                        write!(f, "{}&lt;", print_anchor(ty.def_id(), last, cx))?;
-                        self.print_type(inner_type, f, use_absolute, cx)?;
-                        write!(f, "&gt;")?;
-                    }
+                        write!(f, "{}", print_anchor(ty.def_id(), last, cx))?;
+                    };
+                    Wrapped::with_angle_brackets()
+                        .wrap_fn(|f| self.print_type(inner_type, f, use_absolute, cx))
+                        .fmt(f)?;
                 } else {
                     ty.print(cx).fmt(f)?;
                 }
-                write!(f, " for ")?;
+                f.write_str(" for ")?;
             }
 
             if let Some(ty) = self.kind.as_blanket_ty() {
@@ -1215,18 +1175,10 @@ impl clean::Impl {
             && let Ok(ty) = generics.exactly_one()
             && self.kind.is_fake_variadic()
         {
-            let wrapper = print_anchor(path.def_id(), path.last(), cx);
-            if f.alternate() {
-                write!(f, "{wrapper:#}&lt;")?;
-            } else {
-                write!(f, "{wrapper}<")?;
-            }
-            self.print_type(ty, f, use_absolute, cx)?;
-            if f.alternate() {
-                write!(f, "&gt;")?;
-            } else {
-                write!(f, ">")?;
-            }
+            print_anchor(path.def_id(), path.last(), cx).fmt(f)?;
+            Wrapped::with_angle_brackets()
+                .wrap_fn(|f| self.print_type(ty, f, use_absolute, cx))
+                .fmt(f)?;
         } else {
             fmt_type(type_, f, use_absolute, cx)?;
         }
@@ -1308,23 +1260,13 @@ impl clean::FnDecl {
     pub(crate) fn print(&self, cx: &Context<'_>) -> impl Display {
         fmt::from_fn(move |f| {
             let ellipsis = if self.c_variadic { ", ..." } else { "" };
-            if f.alternate() {
-                write!(
-                    f,
-                    "({params:#}{ellipsis}){arrow:#}",
-                    params = print_params(&self.inputs, cx),
-                    ellipsis = ellipsis,
-                    arrow = self.print_output(cx)
-                )
-            } else {
-                write!(
-                    f,
-                    "({params}{ellipsis}){arrow}",
-                    params = print_params(&self.inputs, cx),
-                    ellipsis = ellipsis,
-                    arrow = self.print_output(cx)
-                )
-            }
+            Wrapped::with_parens()
+                .wrap_fn(|f| {
+                    print_params(&self.inputs, cx).fmt(f)?;
+                    f.write_str(ellipsis)
+                })
+                .fmt(f)?;
+            self.print_output(cx).fmt(f)
         })
     }
 
@@ -1343,8 +1285,7 @@ impl clean::FnDecl {
         fmt::from_fn(move |f| {
             // First, generate the text form of the declaration, with no line wrapping, and count the bytes.
             let mut counter = WriteCounter(0);
-            write!(&mut counter, "{:#}", fmt::from_fn(|f| { self.inner_full_print(None, f, cx) }))
-                .unwrap();
+            write!(&mut counter, "{:#}", fmt::from_fn(|f| { self.inner_full_print(None, f, cx) }))?;
             // If the text form was over 80 characters wide, we will line-wrap our output.
             let line_wrapping_indent =
                 if header_len + counter.0 > 80 { Some(indent) } else { None };
@@ -1362,42 +1303,44 @@ impl clean::FnDecl {
         f: &mut fmt::Formatter<'_>,
         cx: &Context<'_>,
     ) -> fmt::Result {
-        f.write_char('(')?;
-
-        if !self.inputs.is_empty() {
-            let line_wrapping_indent = line_wrapping_indent.map(|n| Indent(n + 4));
+        Wrapped::with_parens()
+            .wrap_fn(|f| {
+                if !self.inputs.is_empty() {
+                    let line_wrapping_indent = line_wrapping_indent.map(|n| Indent(n + 4));
 
-            if let Some(indent) = line_wrapping_indent {
-                write!(f, "\n{indent}")?;
-            }
+                    if let Some(indent) = line_wrapping_indent {
+                        write!(f, "\n{indent}")?;
+                    }
 
-            let sep = fmt::from_fn(|f| {
-                if let Some(indent) = line_wrapping_indent {
-                    write!(f, ",\n{indent}")
-                } else {
-                    f.write_str(", ")
-                }
-            });
+                    let sep = fmt::from_fn(|f| {
+                        if let Some(indent) = line_wrapping_indent {
+                            write!(f, ",\n{indent}")
+                        } else {
+                            f.write_str(", ")
+                        }
+                    });
 
-            self.inputs.iter().map(|param| param.print(cx)).joined(sep, f)?;
+                    self.inputs.iter().map(|param| param.print(cx)).joined(sep, f)?;
 
-            if line_wrapping_indent.is_some() {
-                writeln!(f, ",")?
-            }
+                    if line_wrapping_indent.is_some() {
+                        writeln!(f, ",")?
+                    }
 
-            if self.c_variadic {
-                match line_wrapping_indent {
-                    None => write!(f, ", ...")?,
-                    Some(indent) => writeln!(f, "{indent}...")?,
-                };
-            }
-        }
+                    if self.c_variadic {
+                        match line_wrapping_indent {
+                            None => write!(f, ", ...")?,
+                            Some(indent) => writeln!(f, "{indent}...")?,
+                        };
+                    }
+                }
 
-        if let Some(n) = line_wrapping_indent {
-            write!(f, "{}", Indent(n))?
-        }
+                if let Some(n) = line_wrapping_indent {
+                    write!(f, "{}", Indent(n))?
+                }
 
-        f.write_char(')')?;
+                Ok(())
+            })
+            .fmt(f)?;
 
         self.print_output(cx).fmt(f)
     }
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index 9871066b9eb51..0ff1c09068936 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -10,6 +10,7 @@
 #![feature(box_patterns)]
 #![feature(debug_closure_helpers)]
 #![feature(file_buffered)]
+#![feature(formatting_options)]
 #![feature(if_let_guard)]
 #![feature(iter_advance_by)]
 #![feature(iter_intersperse)]

From 055e05a338af00751ffccc992feeda227b8436b1 Mon Sep 17 00:00:00 2001
From: ltdk <usr@ltdk.xyz>
Date: Wed, 17 Sep 2025 14:07:23 -0400
Subject: [PATCH 1241/1889] Mark float intrinsics with no preconditions as safe

---
 .../rustc_hir_analysis/src/check/intrinsic.rs |  64 ++++++++
 .../libm/src/math/support/float_traits.rs     |   2 +-
 library/core/src/intrinsics/mod.rs            | 138 +++++++++---------
 library/core/src/num/f128.rs                  |  21 +--
 library/core/src/num/f16.rs                   |  21 +--
 library/core/src/num/f32.rs                   |  21 +--
 library/core/src/num/f64.rs                   |  21 +--
 library/std/src/num/f128.rs                   |  16 +-
 library/std/src/num/f16.rs                    |  16 +-
 library/std/src/num/f32.rs                    |  16 +-
 library/std/src/num/f64.rs                    |  16 +-
 .../core_arch/src/aarch64/neon/generated.rs   |  12 +-
 .../crates/core_arch/src/wasm32/mod.rs        |  16 +-
 .../spec/neon/aarch64.spec.yml                |  12 +-
 src/tools/miri/tests/pass/float.rs            |   4 +-
 .../intrinsics/fmuladd_nondeterministic.rs    |   4 +-
 .../codegen-llvm/intrinsic-no-unnamed-attr.rs |   4 +-
 tests/ui/intrinsics/intrinsic-fmuladd.rs      |   4 +-
 tests/ui/intrinsics/reify-intrinsic.stderr    |   2 +-
 19 files changed, 222 insertions(+), 188 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/check/intrinsic.rs b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
index 5fd04427496d4..6faa67f6a904a 100644
--- a/compiler/rustc_hir_analysis/src/check/intrinsic.rs
+++ b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
@@ -81,22 +81,62 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::bswap
         | sym::caller_location
         | sym::carrying_mul_add
+        | sym::ceilf16
+        | sym::ceilf32
+        | sym::ceilf64
+        | sym::ceilf128
         | sym::cold_path
         | sym::const_eval_select
         | sym::contract_check_ensures
         | sym::contract_check_requires
         | sym::contract_checks
+        | sym::cosf16
+        | sym::cosf32
+        | sym::cosf64
+        | sym::cosf128
         | sym::ctlz
         | sym::ctpop
         | sym::cttz
         | sym::discriminant_value
+        | sym::exp2f16
+        | sym::exp2f32
+        | sym::exp2f64
+        | sym::exp2f128
+        | sym::expf16
+        | sym::expf32
+        | sym::expf64
+        | sym::expf128
         | sym::fadd_algebraic
         | sym::fdiv_algebraic
+        | sym::floorf16
+        | sym::floorf32
+        | sym::floorf64
+        | sym::floorf128
+        | sym::fmaf16
+        | sym::fmaf32
+        | sym::fmaf64
+        | sym::fmaf128
         | sym::fmul_algebraic
+        | sym::fmuladdf16
+        | sym::fmuladdf32
+        | sym::fmuladdf64
+        | sym::fmuladdf128
         | sym::forget
         | sym::frem_algebraic
         | sym::fsub_algebraic
         | sym::is_val_statically_known
+        | sym::log2f16
+        | sym::log2f32
+        | sym::log2f64
+        | sym::log2f128
+        | sym::log10f16
+        | sym::log10f32
+        | sym::log10f64
+        | sym::log10f128
+        | sym::logf16
+        | sym::logf32
+        | sym::logf64
+        | sym::logf128
         | sym::maximumf16
         | sym::maximumf32
         | sym::maximumf64
@@ -115,6 +155,14 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::minnumf128
         | sym::mul_with_overflow
         | sym::needs_drop
+        | sym::powf16
+        | sym::powf32
+        | sym::powf64
+        | sym::powf128
+        | sym::powif16
+        | sym::powif32
+        | sym::powif64
+        | sym::powif128
         | sym::prefetch_read_data
         | sym::prefetch_read_instruction
         | sym::prefetch_write_data
@@ -128,13 +176,29 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::round_ties_even_f32
         | sym::round_ties_even_f64
         | sym::round_ties_even_f128
+        | sym::roundf16
+        | sym::roundf32
+        | sym::roundf64
+        | sym::roundf128
         | sym::rustc_peek
         | sym::saturating_add
         | sym::saturating_sub
         | sym::select_unpredictable
+        | sym::sinf16
+        | sym::sinf32
+        | sym::sinf64
+        | sym::sinf128
         | sym::size_of
+        | sym::sqrtf16
+        | sym::sqrtf32
+        | sym::sqrtf64
+        | sym::sqrtf128
         | sym::sub_with_overflow
         | sym::three_way_compare
+        | sym::truncf16
+        | sym::truncf32
+        | sym::truncf64
+        | sym::truncf128
         | sym::type_id
         | sym::type_id_eq
         | sym::type_name
diff --git a/library/compiler-builtins/libm/src/math/support/float_traits.rs b/library/compiler-builtins/libm/src/math/support/float_traits.rs
index fb790e696159f..b5ee6413d5539 100644
--- a/library/compiler-builtins/libm/src/math/support/float_traits.rs
+++ b/library/compiler-builtins/libm/src/math/support/float_traits.rs
@@ -289,7 +289,7 @@ macro_rules! float_impl {
                 cfg_if! {
                     // fma is not yet available in `core`
                     if #[cfg(intrinsics_enabled)] {
-                        unsafe{ core::intrinsics::$fma_intrinsic(self, y, z) }
+                        core::intrinsics::$fma_intrinsic(self, y, z)
                     } else {
                         super::super::$fma_fn(self, y, z)
                     }
diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs
index bffffbc29c1eb..a174ced5a2a63 100644
--- a/library/core/src/intrinsics/mod.rs
+++ b/library/core/src/intrinsics/mod.rs
@@ -1022,28 +1022,28 @@ pub unsafe fn unaligned_volatile_store<T>(dst: *mut T, val: T);
 /// [`f16::sqrt`](../../std/primitive.f16.html#method.sqrt)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn sqrtf16(x: f16) -> f16;
+pub fn sqrtf16(x: f16) -> f16;
 /// Returns the square root of an `f32`
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::sqrt`](../../std/primitive.f32.html#method.sqrt)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn sqrtf32(x: f32) -> f32;
+pub fn sqrtf32(x: f32) -> f32;
 /// Returns the square root of an `f64`
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::sqrt`](../../std/primitive.f64.html#method.sqrt)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn sqrtf64(x: f64) -> f64;
+pub fn sqrtf64(x: f64) -> f64;
 /// Returns the square root of an `f128`
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::sqrt`](../../std/primitive.f128.html#method.sqrt)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn sqrtf128(x: f128) -> f128;
+pub fn sqrtf128(x: f128) -> f128;
 
 /// Raises an `f16` to an integer power.
 ///
@@ -1051,28 +1051,28 @@ pub unsafe fn sqrtf128(x: f128) -> f128;
 /// [`f16::powi`](../../std/primitive.f16.html#method.powi)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn powif16(a: f16, x: i32) -> f16;
+pub fn powif16(a: f16, x: i32) -> f16;
 /// Raises an `f32` to an integer power.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::powi`](../../std/primitive.f32.html#method.powi)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn powif32(a: f32, x: i32) -> f32;
+pub fn powif32(a: f32, x: i32) -> f32;
 /// Raises an `f64` to an integer power.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::powi`](../../std/primitive.f64.html#method.powi)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn powif64(a: f64, x: i32) -> f64;
+pub fn powif64(a: f64, x: i32) -> f64;
 /// Raises an `f128` to an integer power.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::powi`](../../std/primitive.f128.html#method.powi)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn powif128(a: f128, x: i32) -> f128;
+pub fn powif128(a: f128, x: i32) -> f128;
 
 /// Returns the sine of an `f16`.
 ///
@@ -1080,28 +1080,28 @@ pub unsafe fn powif128(a: f128, x: i32) -> f128;
 /// [`f16::sin`](../../std/primitive.f16.html#method.sin)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn sinf16(x: f16) -> f16;
+pub fn sinf16(x: f16) -> f16;
 /// Returns the sine of an `f32`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::sin`](../../std/primitive.f32.html#method.sin)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn sinf32(x: f32) -> f32;
+pub fn sinf32(x: f32) -> f32;
 /// Returns the sine of an `f64`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::sin`](../../std/primitive.f64.html#method.sin)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn sinf64(x: f64) -> f64;
+pub fn sinf64(x: f64) -> f64;
 /// Returns the sine of an `f128`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::sin`](../../std/primitive.f128.html#method.sin)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn sinf128(x: f128) -> f128;
+pub fn sinf128(x: f128) -> f128;
 
 /// Returns the cosine of an `f16`.
 ///
@@ -1109,28 +1109,28 @@ pub unsafe fn sinf128(x: f128) -> f128;
 /// [`f16::cos`](../../std/primitive.f16.html#method.cos)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn cosf16(x: f16) -> f16;
+pub fn cosf16(x: f16) -> f16;
 /// Returns the cosine of an `f32`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::cos`](../../std/primitive.f32.html#method.cos)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn cosf32(x: f32) -> f32;
+pub fn cosf32(x: f32) -> f32;
 /// Returns the cosine of an `f64`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::cos`](../../std/primitive.f64.html#method.cos)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn cosf64(x: f64) -> f64;
+pub fn cosf64(x: f64) -> f64;
 /// Returns the cosine of an `f128`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::cos`](../../std/primitive.f128.html#method.cos)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn cosf128(x: f128) -> f128;
+pub fn cosf128(x: f128) -> f128;
 
 /// Raises an `f16` to an `f16` power.
 ///
@@ -1138,28 +1138,28 @@ pub unsafe fn cosf128(x: f128) -> f128;
 /// [`f16::powf`](../../std/primitive.f16.html#method.powf)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn powf16(a: f16, x: f16) -> f16;
+pub fn powf16(a: f16, x: f16) -> f16;
 /// Raises an `f32` to an `f32` power.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::powf`](../../std/primitive.f32.html#method.powf)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn powf32(a: f32, x: f32) -> f32;
+pub fn powf32(a: f32, x: f32) -> f32;
 /// Raises an `f64` to an `f64` power.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::powf`](../../std/primitive.f64.html#method.powf)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn powf64(a: f64, x: f64) -> f64;
+pub fn powf64(a: f64, x: f64) -> f64;
 /// Raises an `f128` to an `f128` power.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::powf`](../../std/primitive.f128.html#method.powf)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn powf128(a: f128, x: f128) -> f128;
+pub fn powf128(a: f128, x: f128) -> f128;
 
 /// Returns the exponential of an `f16`.
 ///
@@ -1167,28 +1167,28 @@ pub unsafe fn powf128(a: f128, x: f128) -> f128;
 /// [`f16::exp`](../../std/primitive.f16.html#method.exp)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn expf16(x: f16) -> f16;
+pub fn expf16(x: f16) -> f16;
 /// Returns the exponential of an `f32`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::exp`](../../std/primitive.f32.html#method.exp)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn expf32(x: f32) -> f32;
+pub fn expf32(x: f32) -> f32;
 /// Returns the exponential of an `f64`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::exp`](../../std/primitive.f64.html#method.exp)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn expf64(x: f64) -> f64;
+pub fn expf64(x: f64) -> f64;
 /// Returns the exponential of an `f128`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::exp`](../../std/primitive.f128.html#method.exp)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn expf128(x: f128) -> f128;
+pub fn expf128(x: f128) -> f128;
 
 /// Returns 2 raised to the power of an `f16`.
 ///
@@ -1196,28 +1196,28 @@ pub unsafe fn expf128(x: f128) -> f128;
 /// [`f16::exp2`](../../std/primitive.f16.html#method.exp2)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn exp2f16(x: f16) -> f16;
+pub fn exp2f16(x: f16) -> f16;
 /// Returns 2 raised to the power of an `f32`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::exp2`](../../std/primitive.f32.html#method.exp2)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn exp2f32(x: f32) -> f32;
+pub fn exp2f32(x: f32) -> f32;
 /// Returns 2 raised to the power of an `f64`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::exp2`](../../std/primitive.f64.html#method.exp2)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn exp2f64(x: f64) -> f64;
+pub fn exp2f64(x: f64) -> f64;
 /// Returns 2 raised to the power of an `f128`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::exp2`](../../std/primitive.f128.html#method.exp2)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn exp2f128(x: f128) -> f128;
+pub fn exp2f128(x: f128) -> f128;
 
 /// Returns the natural logarithm of an `f16`.
 ///
@@ -1225,28 +1225,28 @@ pub unsafe fn exp2f128(x: f128) -> f128;
 /// [`f16::ln`](../../std/primitive.f16.html#method.ln)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn logf16(x: f16) -> f16;
+pub fn logf16(x: f16) -> f16;
 /// Returns the natural logarithm of an `f32`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::ln`](../../std/primitive.f32.html#method.ln)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn logf32(x: f32) -> f32;
+pub fn logf32(x: f32) -> f32;
 /// Returns the natural logarithm of an `f64`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::ln`](../../std/primitive.f64.html#method.ln)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn logf64(x: f64) -> f64;
+pub fn logf64(x: f64) -> f64;
 /// Returns the natural logarithm of an `f128`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::ln`](../../std/primitive.f128.html#method.ln)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn logf128(x: f128) -> f128;
+pub fn logf128(x: f128) -> f128;
 
 /// Returns the base 10 logarithm of an `f16`.
 ///
@@ -1254,28 +1254,28 @@ pub unsafe fn logf128(x: f128) -> f128;
 /// [`f16::log10`](../../std/primitive.f16.html#method.log10)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn log10f16(x: f16) -> f16;
+pub fn log10f16(x: f16) -> f16;
 /// Returns the base 10 logarithm of an `f32`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::log10`](../../std/primitive.f32.html#method.log10)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn log10f32(x: f32) -> f32;
+pub fn log10f32(x: f32) -> f32;
 /// Returns the base 10 logarithm of an `f64`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::log10`](../../std/primitive.f64.html#method.log10)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn log10f64(x: f64) -> f64;
+pub fn log10f64(x: f64) -> f64;
 /// Returns the base 10 logarithm of an `f128`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::log10`](../../std/primitive.f128.html#method.log10)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn log10f128(x: f128) -> f128;
+pub fn log10f128(x: f128) -> f128;
 
 /// Returns the base 2 logarithm of an `f16`.
 ///
@@ -1283,28 +1283,28 @@ pub unsafe fn log10f128(x: f128) -> f128;
 /// [`f16::log2`](../../std/primitive.f16.html#method.log2)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn log2f16(x: f16) -> f16;
+pub fn log2f16(x: f16) -> f16;
 /// Returns the base 2 logarithm of an `f32`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::log2`](../../std/primitive.f32.html#method.log2)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn log2f32(x: f32) -> f32;
+pub fn log2f32(x: f32) -> f32;
 /// Returns the base 2 logarithm of an `f64`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::log2`](../../std/primitive.f64.html#method.log2)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn log2f64(x: f64) -> f64;
+pub fn log2f64(x: f64) -> f64;
 /// Returns the base 2 logarithm of an `f128`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::log2`](../../std/primitive.f128.html#method.log2)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn log2f128(x: f128) -> f128;
+pub fn log2f128(x: f128) -> f128;
 
 /// Returns `a * b + c` for `f16` values.
 ///
@@ -1312,28 +1312,28 @@ pub unsafe fn log2f128(x: f128) -> f128;
 /// [`f16::mul_add`](../../std/primitive.f16.html#method.mul_add)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn fmaf16(a: f16, b: f16, c: f16) -> f16;
+pub fn fmaf16(a: f16, b: f16, c: f16) -> f16;
 /// Returns `a * b + c` for `f32` values.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::mul_add`](../../std/primitive.f32.html#method.mul_add)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn fmaf32(a: f32, b: f32, c: f32) -> f32;
+pub fn fmaf32(a: f32, b: f32, c: f32) -> f32;
 /// Returns `a * b + c` for `f64` values.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::mul_add`](../../std/primitive.f64.html#method.mul_add)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn fmaf64(a: f64, b: f64, c: f64) -> f64;
+pub fn fmaf64(a: f64, b: f64, c: f64) -> f64;
 /// Returns `a * b + c` for `f128` values.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::mul_add`](../../std/primitive.f128.html#method.mul_add)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn fmaf128(a: f128, b: f128, c: f128) -> f128;
+pub fn fmaf128(a: f128, b: f128, c: f128) -> f128;
 
 /// Returns `a * b + c` for `f16` values, non-deterministically executing
 /// either a fused multiply-add or two operations with rounding of the
@@ -1347,7 +1347,7 @@ pub unsafe fn fmaf128(a: f128, b: f128, c: f128) -> f128;
 /// example.
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn fmuladdf16(a: f16, b: f16, c: f16) -> f16;
+pub fn fmuladdf16(a: f16, b: f16, c: f16) -> f16;
 /// Returns `a * b + c` for `f32` values, non-deterministically executing
 /// either a fused multiply-add or two operations with rounding of the
 /// intermediate result.
@@ -1360,7 +1360,7 @@ pub unsafe fn fmuladdf16(a: f16, b: f16, c: f16) -> f16;
 /// example.
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn fmuladdf32(a: f32, b: f32, c: f32) -> f32;
+pub fn fmuladdf32(a: f32, b: f32, c: f32) -> f32;
 /// Returns `a * b + c` for `f64` values, non-deterministically executing
 /// either a fused multiply-add or two operations with rounding of the
 /// intermediate result.
@@ -1373,7 +1373,7 @@ pub unsafe fn fmuladdf32(a: f32, b: f32, c: f32) -> f32;
 /// example.
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn fmuladdf64(a: f64, b: f64, c: f64) -> f64;
+pub fn fmuladdf64(a: f64, b: f64, c: f64) -> f64;
 /// Returns `a * b + c` for `f128` values, non-deterministically executing
 /// either a fused multiply-add or two operations with rounding of the
 /// intermediate result.
@@ -1386,7 +1386,7 @@ pub unsafe fn fmuladdf64(a: f64, b: f64, c: f64) -> f64;
 /// example.
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn fmuladdf128(a: f128, b: f128, c: f128) -> f128;
+pub fn fmuladdf128(a: f128, b: f128, c: f128) -> f128;
 
 /// Returns the largest integer less than or equal to an `f16`.
 ///
@@ -1395,7 +1395,7 @@ pub unsafe fn fmuladdf128(a: f128, b: f128, c: f128) -> f128;
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub const unsafe fn floorf16(x: f16) -> f16;
+pub const fn floorf16(x: f16) -> f16;
 /// Returns the largest integer less than or equal to an `f32`.
 ///
 /// The stabilized version of this intrinsic is
@@ -1403,7 +1403,7 @@ pub const unsafe fn floorf16(x: f16) -> f16;
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub const unsafe fn floorf32(x: f32) -> f32;
+pub const fn floorf32(x: f32) -> f32;
 /// Returns the largest integer less than or equal to an `f64`.
 ///
 /// The stabilized version of this intrinsic is
@@ -1411,7 +1411,7 @@ pub const unsafe fn floorf32(x: f32) -> f32;
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub const unsafe fn floorf64(x: f64) -> f64;
+pub const fn floorf64(x: f64) -> f64;
 /// Returns the largest integer less than or equal to an `f128`.
 ///
 /// The stabilized version of this intrinsic is
@@ -1419,7 +1419,7 @@ pub const unsafe fn floorf64(x: f64) -> f64;
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub const unsafe fn floorf128(x: f128) -> f128;
+pub const fn floorf128(x: f128) -> f128;
 
 /// Returns the smallest integer greater than or equal to an `f16`.
 ///
@@ -1428,7 +1428,7 @@ pub const unsafe fn floorf128(x: f128) -> f128;
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub const unsafe fn ceilf16(x: f16) -> f16;
+pub const fn ceilf16(x: f16) -> f16;
 /// Returns the smallest integer greater than or equal to an `f32`.
 ///
 /// The stabilized version of this intrinsic is
@@ -1436,7 +1436,7 @@ pub const unsafe fn ceilf16(x: f16) -> f16;
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub const unsafe fn ceilf32(x: f32) -> f32;
+pub const fn ceilf32(x: f32) -> f32;
 /// Returns the smallest integer greater than or equal to an `f64`.
 ///
 /// The stabilized version of this intrinsic is
@@ -1444,7 +1444,7 @@ pub const unsafe fn ceilf32(x: f32) -> f32;
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub const unsafe fn ceilf64(x: f64) -> f64;
+pub const fn ceilf64(x: f64) -> f64;
 /// Returns the smallest integer greater than or equal to an `f128`.
 ///
 /// The stabilized version of this intrinsic is
@@ -1452,7 +1452,7 @@ pub const unsafe fn ceilf64(x: f64) -> f64;
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub const unsafe fn ceilf128(x: f128) -> f128;
+pub const fn ceilf128(x: f128) -> f128;
 
 /// Returns the integer part of an `f16`.
 ///
@@ -1461,7 +1461,7 @@ pub const unsafe fn ceilf128(x: f128) -> f128;
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub const unsafe fn truncf16(x: f16) -> f16;
+pub const fn truncf16(x: f16) -> f16;
 /// Returns the integer part of an `f32`.
 ///
 /// The stabilized version of this intrinsic is
@@ -1469,7 +1469,7 @@ pub const unsafe fn truncf16(x: f16) -> f16;
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub const unsafe fn truncf32(x: f32) -> f32;
+pub const fn truncf32(x: f32) -> f32;
 /// Returns the integer part of an `f64`.
 ///
 /// The stabilized version of this intrinsic is
@@ -1477,7 +1477,7 @@ pub const unsafe fn truncf32(x: f32) -> f32;
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub const unsafe fn truncf64(x: f64) -> f64;
+pub const fn truncf64(x: f64) -> f64;
 /// Returns the integer part of an `f128`.
 ///
 /// The stabilized version of this intrinsic is
@@ -1485,7 +1485,7 @@ pub const unsafe fn truncf64(x: f64) -> f64;
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub const unsafe fn truncf128(x: f128) -> f128;
+pub const fn truncf128(x: f128) -> f128;
 
 /// Returns the nearest integer to an `f16`. Rounds half-way cases to the number with an even
 /// least significant digit.
@@ -1534,7 +1534,7 @@ pub const fn round_ties_even_f128(x: f128) -> f128;
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub const unsafe fn roundf16(x: f16) -> f16;
+pub const fn roundf16(x: f16) -> f16;
 /// Returns the nearest integer to an `f32`. Rounds half-way cases away from zero.
 ///
 /// The stabilized version of this intrinsic is
@@ -1542,7 +1542,7 @@ pub const unsafe fn roundf16(x: f16) -> f16;
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub const unsafe fn roundf32(x: f32) -> f32;
+pub const fn roundf32(x: f32) -> f32;
 /// Returns the nearest integer to an `f64`. Rounds half-way cases away from zero.
 ///
 /// The stabilized version of this intrinsic is
@@ -1550,7 +1550,7 @@ pub const unsafe fn roundf32(x: f32) -> f32;
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub const unsafe fn roundf64(x: f64) -> f64;
+pub const fn roundf64(x: f64) -> f64;
 /// Returns the nearest integer to an `f128`. Rounds half-way cases away from zero.
 ///
 /// The stabilized version of this intrinsic is
@@ -1558,10 +1558,10 @@ pub const unsafe fn roundf64(x: f64) -> f64;
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub const unsafe fn roundf128(x: f128) -> f128;
+pub const fn roundf128(x: f128) -> f128;
 
 /// Float addition that allows optimizations based on algebraic rules.
-/// May assume inputs are finite.
+/// Requires that inputs and output of the operation are finite, causing UB otherwise.
 ///
 /// This intrinsic does not have a stable counterpart.
 #[rustc_intrinsic]
@@ -1569,7 +1569,7 @@ pub const unsafe fn roundf128(x: f128) -> f128;
 pub unsafe fn fadd_fast<T: Copy>(a: T, b: T) -> T;
 
 /// Float subtraction that allows optimizations based on algebraic rules.
-/// May assume inputs are finite.
+/// Requires that inputs and output of the operation are finite, causing UB otherwise.
 ///
 /// This intrinsic does not have a stable counterpart.
 #[rustc_intrinsic]
@@ -1577,7 +1577,7 @@ pub unsafe fn fadd_fast<T: Copy>(a: T, b: T) -> T;
 pub unsafe fn fsub_fast<T: Copy>(a: T, b: T) -> T;
 
 /// Float multiplication that allows optimizations based on algebraic rules.
-/// May assume inputs are finite.
+/// Requires that inputs and output of the operation are finite, causing UB otherwise.
 ///
 /// This intrinsic does not have a stable counterpart.
 #[rustc_intrinsic]
@@ -1585,7 +1585,7 @@ pub unsafe fn fsub_fast<T: Copy>(a: T, b: T) -> T;
 pub unsafe fn fmul_fast<T: Copy>(a: T, b: T) -> T;
 
 /// Float division that allows optimizations based on algebraic rules.
-/// May assume inputs are finite.
+/// Requires that inputs and output of the operation are finite, causing UB otherwise.
 ///
 /// This intrinsic does not have a stable counterpart.
 #[rustc_intrinsic]
@@ -1593,7 +1593,7 @@ pub unsafe fn fmul_fast<T: Copy>(a: T, b: T) -> T;
 pub unsafe fn fdiv_fast<T: Copy>(a: T, b: T) -> T;
 
 /// Float remainder that allows optimizations based on algebraic rules.
-/// May assume inputs are finite.
+/// Requires that inputs and output of the operation are finite, causing UB otherwise.
 ///
 /// This intrinsic does not have a stable counterpart.
 #[rustc_intrinsic]
diff --git a/library/core/src/num/f128.rs b/library/core/src/num/f128.rs
index 66c892aadd083..6088fb6fa1786 100644
--- a/library/core/src/num/f128.rs
+++ b/library/core/src/num/f128.rs
@@ -1459,8 +1459,7 @@ impl f128 {
     #[rustc_const_unstable(feature = "f128", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn floor(self) -> f128 {
-        // SAFETY: intrinsic with no preconditions
-        unsafe { intrinsics::floorf128(self) }
+        intrinsics::floorf128(self)
     }
 
     /// Returns the smallest integer greater than or equal to `self`.
@@ -1488,8 +1487,7 @@ impl f128 {
     #[rustc_const_unstable(feature = "f128", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn ceil(self) -> f128 {
-        // SAFETY: intrinsic with no preconditions
-        unsafe { intrinsics::ceilf128(self) }
+        intrinsics::ceilf128(self)
     }
 
     /// Returns the nearest integer to `self`. If a value is half-way between two
@@ -1523,8 +1521,7 @@ impl f128 {
     #[rustc_const_unstable(feature = "f128", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn round(self) -> f128 {
-        // SAFETY: intrinsic with no preconditions
-        unsafe { intrinsics::roundf128(self) }
+        intrinsics::roundf128(self)
     }
 
     /// Returns the nearest integer to a number. Rounds half-way cases to the number
@@ -1587,8 +1584,7 @@ impl f128 {
     #[rustc_const_unstable(feature = "f128", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn trunc(self) -> f128 {
-        // SAFETY: intrinsic with no preconditions
-        unsafe { intrinsics::truncf128(self) }
+        intrinsics::truncf128(self)
     }
 
     /// Returns the fractional part of `self`.
@@ -1664,8 +1660,7 @@ impl f128 {
     #[unstable(feature = "f128", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn mul_add(self, a: f128, b: f128) -> f128 {
-        // SAFETY: intrinsic with no preconditions
-        unsafe { intrinsics::fmaf128(self, a, b) }
+        intrinsics::fmaf128(self, a, b)
     }
 
     /// Calculates Euclidean division, the matching method for `rem_euclid`.
@@ -1780,8 +1775,7 @@ impl f128 {
     #[unstable(feature = "f128", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn powi(self, n: i32) -> f128 {
-        // SAFETY: intrinsic with no preconditions
-        unsafe { intrinsics::powif128(self, n) }
+        intrinsics::powif128(self, n)
     }
 
     /// Returns the square root of a number.
@@ -1816,7 +1810,6 @@ impl f128 {
     #[unstable(feature = "f128", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn sqrt(self) -> f128 {
-        // SAFETY: intrinsic with no preconditions
-        unsafe { intrinsics::sqrtf128(self) }
+        intrinsics::sqrtf128(self)
     }
 }
diff --git a/library/core/src/num/f16.rs b/library/core/src/num/f16.rs
index 81220065e72a6..3f66c5973d4ac 100644
--- a/library/core/src/num/f16.rs
+++ b/library/core/src/num/f16.rs
@@ -1434,8 +1434,7 @@ impl f16 {
     #[rustc_const_unstable(feature = "f16", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn floor(self) -> f16 {
-        // SAFETY: intrinsic with no preconditions
-        unsafe { intrinsics::floorf16(self) }
+        intrinsics::floorf16(self)
     }
 
     /// Returns the smallest integer greater than or equal to `self`.
@@ -1463,8 +1462,7 @@ impl f16 {
     #[rustc_const_unstable(feature = "f16", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn ceil(self) -> f16 {
-        // SAFETY: intrinsic with no preconditions
-        unsafe { intrinsics::ceilf16(self) }
+        intrinsics::ceilf16(self)
     }
 
     /// Returns the nearest integer to `self`. If a value is half-way between two
@@ -1498,8 +1496,7 @@ impl f16 {
     #[rustc_const_unstable(feature = "f16", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn round(self) -> f16 {
-        // SAFETY: intrinsic with no preconditions
-        unsafe { intrinsics::roundf16(self) }
+        intrinsics::roundf16(self)
     }
 
     /// Returns the nearest integer to a number. Rounds half-way cases to the number
@@ -1562,8 +1559,7 @@ impl f16 {
     #[rustc_const_unstable(feature = "f16", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn trunc(self) -> f16 {
-        // SAFETY: intrinsic with no preconditions
-        unsafe { intrinsics::truncf16(self) }
+        intrinsics::truncf16(self)
     }
 
     /// Returns the fractional part of `self`.
@@ -1639,8 +1635,7 @@ impl f16 {
     #[doc(alias = "fmaf16", alias = "fusedMultiplyAdd")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn mul_add(self, a: f16, b: f16) -> f16 {
-        // SAFETY: intrinsic with no preconditions
-        unsafe { intrinsics::fmaf16(self, a, b) }
+        intrinsics::fmaf16(self, a, b)
     }
 
     /// Calculates Euclidean division, the matching method for `rem_euclid`.
@@ -1755,8 +1750,7 @@ impl f16 {
     #[unstable(feature = "f16", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn powi(self, n: i32) -> f16 {
-        // SAFETY: intrinsic with no preconditions
-        unsafe { intrinsics::powif16(self, n) }
+        intrinsics::powif16(self, n)
     }
 
     /// Returns the square root of a number.
@@ -1791,8 +1785,7 @@ impl f16 {
     #[unstable(feature = "f16", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn sqrt(self) -> f16 {
-        // SAFETY: intrinsic with no preconditions
-        unsafe { intrinsics::sqrtf16(self) }
+        intrinsics::sqrtf16(self)
     }
 
     /// Returns the cube root of a number.
diff --git a/library/core/src/num/f32.rs b/library/core/src/num/f32.rs
index cefcf1d1fe2fc..ebce89e5b3da5 100644
--- a/library/core/src/num/f32.rs
+++ b/library/core/src/num/f32.rs
@@ -1603,8 +1603,7 @@ pub mod math {
     #[unstable(feature = "core_float_math", issue = "137578")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn floor(x: f32) -> f32 {
-        // SAFETY: intrinsic with no preconditions
-        unsafe { intrinsics::floorf32(x) }
+        intrinsics::floorf32(x)
     }
 
     /// Experimental version of `ceil` in `core`. See [`f32::ceil`] for details.
@@ -1632,8 +1631,7 @@ pub mod math {
     #[must_use = "method returns a new number and does not mutate the original value"]
     #[unstable(feature = "core_float_math", issue = "137578")]
     pub const fn ceil(x: f32) -> f32 {
-        // SAFETY: intrinsic with no preconditions
-        unsafe { intrinsics::ceilf32(x) }
+        intrinsics::ceilf32(x)
     }
 
     /// Experimental version of `round` in `core`. See [`f32::round`] for details.
@@ -1666,8 +1664,7 @@ pub mod math {
     #[unstable(feature = "core_float_math", issue = "137578")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn round(x: f32) -> f32 {
-        // SAFETY: intrinsic with no preconditions
-        unsafe { intrinsics::roundf32(x) }
+        intrinsics::roundf32(x)
     }
 
     /// Experimental version of `round_ties_even` in `core`. See [`f32::round_ties_even`] for
@@ -1729,8 +1726,7 @@ pub mod math {
     #[must_use = "method returns a new number and does not mutate the original value"]
     #[unstable(feature = "core_float_math", issue = "137578")]
     pub const fn trunc(x: f32) -> f32 {
-        // SAFETY: intrinsic with no preconditions
-        unsafe { intrinsics::truncf32(x) }
+        intrinsics::truncf32(x)
     }
 
     /// Experimental version of `fract` in `core`. See [`f32::fract`] for details.
@@ -1804,8 +1800,7 @@ pub mod math {
     #[must_use = "method returns a new number and does not mutate the original value"]
     #[unstable(feature = "core_float_math", issue = "137578")]
     pub fn mul_add(x: f32, y: f32, z: f32) -> f32 {
-        // SAFETY: intrinsic with no preconditions
-        unsafe { intrinsics::fmaf32(x, y, z) }
+        intrinsics::fmaf32(x, y, z)
     }
 
     /// Experimental version of `div_euclid` in `core`. See [`f32::div_euclid`] for details.
@@ -1896,8 +1891,7 @@ pub mod math {
     #[must_use = "method returns a new number and does not mutate the original value"]
     #[unstable(feature = "core_float_math", issue = "137578")]
     pub fn powi(x: f32, n: i32) -> f32 {
-        // SAFETY: intrinsic with no preconditions
-        unsafe { intrinsics::powif32(x, n) }
+        intrinsics::powif32(x, n)
     }
 
     /// Experimental version of `sqrt` in `core`. See [`f32::sqrt`] for details.
@@ -1927,8 +1921,7 @@ pub mod math {
     #[unstable(feature = "core_float_math", issue = "137578")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn sqrt(x: f32) -> f32 {
-        // SAFETY: intrinsic with no preconditions
-        unsafe { intrinsics::sqrtf32(x) }
+        intrinsics::sqrtf32(x)
     }
 
     /// Experimental version of `abs_sub` in `core`. See [`f32::abs_sub`] for details.
diff --git a/library/core/src/num/f64.rs b/library/core/src/num/f64.rs
index 9dd1141e70331..91e3949fc3900 100644
--- a/library/core/src/num/f64.rs
+++ b/library/core/src/num/f64.rs
@@ -1601,8 +1601,7 @@ pub mod math {
     #[unstable(feature = "core_float_math", issue = "137578")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn floor(x: f64) -> f64 {
-        // SAFETY: intrinsic with no preconditions
-        unsafe { intrinsics::floorf64(x) }
+        intrinsics::floorf64(x)
     }
 
     /// Experimental version of `ceil` in `core`. See [`f64::ceil`] for details.
@@ -1630,8 +1629,7 @@ pub mod math {
     #[unstable(feature = "core_float_math", issue = "137578")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn ceil(x: f64) -> f64 {
-        // SAFETY: intrinsic with no preconditions
-        unsafe { intrinsics::ceilf64(x) }
+        intrinsics::ceilf64(x)
     }
 
     /// Experimental version of `round` in `core`. See [`f64::round`] for details.
@@ -1664,8 +1662,7 @@ pub mod math {
     #[unstable(feature = "core_float_math", issue = "137578")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn round(x: f64) -> f64 {
-        // SAFETY: intrinsic with no preconditions
-        unsafe { intrinsics::roundf64(x) }
+        intrinsics::roundf64(x)
     }
 
     /// Experimental version of `round_ties_even` in `core`. See [`f64::round_ties_even`] for
@@ -1727,8 +1724,7 @@ pub mod math {
     #[unstable(feature = "core_float_math", issue = "137578")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn trunc(x: f64) -> f64 {
-        // SAFETY: intrinsic with no preconditions
-        unsafe { intrinsics::truncf64(x) }
+        intrinsics::truncf64(x)
     }
 
     /// Experimental version of `fract` in `core`. See [`f64::fract`] for details.
@@ -1802,8 +1798,7 @@ pub mod math {
     #[unstable(feature = "core_float_math", issue = "137578")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn mul_add(x: f64, a: f64, b: f64) -> f64 {
-        // SAFETY: intrinsic with no preconditions
-        unsafe { intrinsics::fmaf64(x, a, b) }
+        intrinsics::fmaf64(x, a, b)
     }
 
     /// Experimental version of `div_euclid` in `core`. See [`f64::div_euclid`] for details.
@@ -1894,8 +1889,7 @@ pub mod math {
     #[unstable(feature = "core_float_math", issue = "137578")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn powi(x: f64, n: i32) -> f64 {
-        // SAFETY: intrinsic with no preconditions
-        unsafe { intrinsics::powif64(x, n) }
+        intrinsics::powif64(x, n)
     }
 
     /// Experimental version of `sqrt` in `core`. See [`f64::sqrt`] for details.
@@ -1925,8 +1919,7 @@ pub mod math {
     #[unstable(feature = "core_float_math", issue = "137578")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn sqrt(x: f64) -> f64 {
-        // SAFETY: intrinsic with no preconditions
-        unsafe { intrinsics::sqrtf64(x) }
+        intrinsics::sqrtf64(x)
     }
 
     /// Experimental version of `abs_sub` in `core`. See [`f64::abs_sub`] for details.
diff --git a/library/std/src/num/f128.rs b/library/std/src/num/f128.rs
index b83692390b6bc..5d206c4b7da5f 100644
--- a/library/std/src/num/f128.rs
+++ b/library/std/src/num/f128.rs
@@ -44,7 +44,7 @@ impl f128 {
     #[unstable(feature = "f128", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn powf(self, n: f128) -> f128 {
-        unsafe { intrinsics::powf128(self, n) }
+        intrinsics::powf128(self, n)
     }
 
     /// Returns `e^(self)`, (the exponential function).
@@ -76,7 +76,7 @@ impl f128 {
     #[unstable(feature = "f128", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn exp(self) -> f128 {
-        unsafe { intrinsics::expf128(self) }
+        intrinsics::expf128(self)
     }
 
     /// Returns `2^(self)`.
@@ -106,7 +106,7 @@ impl f128 {
     #[unstable(feature = "f128", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn exp2(self) -> f128 {
-        unsafe { intrinsics::exp2f128(self) }
+        intrinsics::exp2f128(self)
     }
 
     /// Returns the natural logarithm of the number.
@@ -151,7 +151,7 @@ impl f128 {
     #[unstable(feature = "f128", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn ln(self) -> f128 {
-        unsafe { intrinsics::logf128(self) }
+        intrinsics::logf128(self)
     }
 
     /// Returns the logarithm of the number with respect to an arbitrary base.
@@ -241,7 +241,7 @@ impl f128 {
     #[unstable(feature = "f128", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn log2(self) -> f128 {
-        unsafe { intrinsics::log2f128(self) }
+        intrinsics::log2f128(self)
     }
 
     /// Returns the base 10 logarithm of the number.
@@ -284,7 +284,7 @@ impl f128 {
     #[unstable(feature = "f128", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn log10(self) -> f128 {
-        unsafe { intrinsics::log10f128(self) }
+        intrinsics::log10f128(self)
     }
 
     /// Returns the cube root of a number.
@@ -385,7 +385,7 @@ impl f128 {
     #[unstable(feature = "f128", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn sin(self) -> f128 {
-        unsafe { intrinsics::sinf128(self) }
+        intrinsics::sinf128(self)
     }
 
     /// Computes the cosine of a number (in radians).
@@ -414,7 +414,7 @@ impl f128 {
     #[unstable(feature = "f128", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn cos(self) -> f128 {
-        unsafe { intrinsics::cosf128(self) }
+        intrinsics::cosf128(self)
     }
 
     /// Computes the tangent of a number (in radians).
diff --git a/library/std/src/num/f16.rs b/library/std/src/num/f16.rs
index 5599528717cbe..2565ef0f9f2cd 100644
--- a/library/std/src/num/f16.rs
+++ b/library/std/src/num/f16.rs
@@ -44,7 +44,7 @@ impl f16 {
     #[unstable(feature = "f16", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn powf(self, n: f16) -> f16 {
-        unsafe { intrinsics::powf16(self, n) }
+        intrinsics::powf16(self, n)
     }
 
     /// Returns `e^(self)`, (the exponential function).
@@ -76,7 +76,7 @@ impl f16 {
     #[unstable(feature = "f16", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn exp(self) -> f16 {
-        unsafe { intrinsics::expf16(self) }
+        intrinsics::expf16(self)
     }
 
     /// Returns `2^(self)`.
@@ -106,7 +106,7 @@ impl f16 {
     #[unstable(feature = "f16", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn exp2(self) -> f16 {
-        unsafe { intrinsics::exp2f16(self) }
+        intrinsics::exp2f16(self)
     }
 
     /// Returns the natural logarithm of the number.
@@ -151,7 +151,7 @@ impl f16 {
     #[unstable(feature = "f16", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn ln(self) -> f16 {
-        unsafe { intrinsics::logf16(self) }
+        intrinsics::logf16(self)
     }
 
     /// Returns the logarithm of the number with respect to an arbitrary base.
@@ -241,7 +241,7 @@ impl f16 {
     #[unstable(feature = "f16", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn log2(self) -> f16 {
-        unsafe { intrinsics::log2f16(self) }
+        intrinsics::log2f16(self)
     }
 
     /// Returns the base 10 logarithm of the number.
@@ -284,7 +284,7 @@ impl f16 {
     #[unstable(feature = "f16", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn log10(self) -> f16 {
-        unsafe { intrinsics::log10f16(self) }
+        intrinsics::log10f16(self)
     }
 
     /// Compute the distance between the origin and a point (`x`, `y`) on the
@@ -350,7 +350,7 @@ impl f16 {
     #[unstable(feature = "f16", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn sin(self) -> f16 {
-        unsafe { intrinsics::sinf16(self) }
+        intrinsics::sinf16(self)
     }
 
     /// Computes the cosine of a number (in radians).
@@ -379,7 +379,7 @@ impl f16 {
     #[unstable(feature = "f16", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn cos(self) -> f16 {
-        unsafe { intrinsics::cosf16(self) }
+        intrinsics::cosf16(self)
     }
 
     /// Computes the tangent of a number (in radians).
diff --git a/library/std/src/num/f32.rs b/library/std/src/num/f32.rs
index 0247080a8d6be..ac1d889cc3731 100644
--- a/library/std/src/num/f32.rs
+++ b/library/std/src/num/f32.rs
@@ -338,7 +338,7 @@ impl f32 {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn powf(self, n: f32) -> f32 {
-        unsafe { intrinsics::powf32(self, n) }
+        intrinsics::powf32(self, n)
     }
 
     /// Returns the square root of a number.
@@ -395,7 +395,7 @@ impl f32 {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn exp(self) -> f32 {
-        unsafe { intrinsics::expf32(self) }
+        intrinsics::expf32(self)
     }
 
     /// Returns `2^(self)`.
@@ -420,7 +420,7 @@ impl f32 {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn exp2(self) -> f32 {
-        unsafe { intrinsics::exp2f32(self) }
+        intrinsics::exp2f32(self)
     }
 
     /// Returns the natural logarithm of the number.
@@ -455,7 +455,7 @@ impl f32 {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn ln(self) -> f32 {
-        unsafe { intrinsics::logf32(self) }
+        intrinsics::logf32(self)
     }
 
     /// Returns the logarithm of the number with respect to an arbitrary base.
@@ -525,7 +525,7 @@ impl f32 {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn log2(self) -> f32 {
-        unsafe { intrinsics::log2f32(self) }
+        intrinsics::log2f32(self)
     }
 
     /// Returns the base 10 logarithm of the number.
@@ -558,7 +558,7 @@ impl f32 {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn log10(self) -> f32 {
-        unsafe { intrinsics::log10f32(self) }
+        intrinsics::log10f32(self)
     }
 
     /// The positive difference of two numbers.
@@ -683,7 +683,7 @@ impl f32 {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn sin(self) -> f32 {
-        unsafe { intrinsics::sinf32(self) }
+        intrinsics::sinf32(self)
     }
 
     /// Computes the cosine of a number (in radians).
@@ -707,7 +707,7 @@ impl f32 {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn cos(self) -> f32 {
-        unsafe { intrinsics::cosf32(self) }
+        intrinsics::cosf32(self)
     }
 
     /// Computes the tangent of a number (in radians).
diff --git a/library/std/src/num/f64.rs b/library/std/src/num/f64.rs
index 1cfd3909d967e..55c8593a0c0b1 100644
--- a/library/std/src/num/f64.rs
+++ b/library/std/src/num/f64.rs
@@ -338,7 +338,7 @@ impl f64 {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn powf(self, n: f64) -> f64 {
-        unsafe { intrinsics::powf64(self, n) }
+        intrinsics::powf64(self, n)
     }
 
     /// Returns the square root of a number.
@@ -395,7 +395,7 @@ impl f64 {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn exp(self) -> f64 {
-        unsafe { intrinsics::expf64(self) }
+        intrinsics::expf64(self)
     }
 
     /// Returns `2^(self)`.
@@ -420,7 +420,7 @@ impl f64 {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn exp2(self) -> f64 {
-        unsafe { intrinsics::exp2f64(self) }
+        intrinsics::exp2f64(self)
     }
 
     /// Returns the natural logarithm of the number.
@@ -455,7 +455,7 @@ impl f64 {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn ln(self) -> f64 {
-        unsafe { intrinsics::logf64(self) }
+        intrinsics::logf64(self)
     }
 
     /// Returns the logarithm of the number with respect to an arbitrary base.
@@ -525,7 +525,7 @@ impl f64 {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn log2(self) -> f64 {
-        unsafe { intrinsics::log2f64(self) }
+        intrinsics::log2f64(self)
     }
 
     /// Returns the base 10 logarithm of the number.
@@ -558,7 +558,7 @@ impl f64 {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn log10(self) -> f64 {
-        unsafe { intrinsics::log10f64(self) }
+        intrinsics::log10f64(self)
     }
 
     /// The positive difference of two numbers.
@@ -683,7 +683,7 @@ impl f64 {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn sin(self) -> f64 {
-        unsafe { intrinsics::sinf64(self) }
+        intrinsics::sinf64(self)
     }
 
     /// Computes the cosine of a number (in radians).
@@ -707,7 +707,7 @@ impl f64 {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn cos(self) -> f64 {
-        unsafe { intrinsics::cosf64(self) }
+        intrinsics::cosf64(self)
     }
 
     /// Computes the tangent of a number (in radians).
diff --git a/library/stdarch/crates/core_arch/src/aarch64/neon/generated.rs b/library/stdarch/crates/core_arch/src/aarch64/neon/generated.rs
index bc4c438038dc5..40612660d4db4 100644
--- a/library/stdarch/crates/core_arch/src/aarch64/neon/generated.rs
+++ b/library/stdarch/crates/core_arch/src/aarch64/neon/generated.rs
@@ -10183,7 +10183,7 @@ pub fn vfmad_lane_f64<const LANE: i32>(a: f64, b: f64, c: float64x1_t) -> f64 {
 #[target_feature(enable = "neon,fp16")]
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 pub fn vfmah_f16(a: f16, b: f16, c: f16) -> f16 {
-    unsafe { fmaf16(b, c, a) }
+    fmaf16(b, c, a)
 }
 #[doc = "Floating-point fused multiply-add to accumulator"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmah_lane_f16)"]
@@ -23045,7 +23045,7 @@ pub fn vrndaq_f64(a: float64x2_t) -> float64x2_t {
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg_attr(test, assert_instr(frinta))]
 pub fn vrndah_f16(a: f16) -> f16 {
-    unsafe { roundf16(a) }
+    roundf16(a)
 }
 #[doc = "Floating-point round to integral, to nearest with ties to away"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndh_f16)"]
@@ -23054,7 +23054,7 @@ pub fn vrndah_f16(a: f16) -> f16 {
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg_attr(test, assert_instr(frintz))]
 pub fn vrndh_f16(a: f16) -> f16 {
-    unsafe { truncf16(a) }
+    truncf16(a)
 }
 #[doc = "Floating-point round to integral, using current rounding mode"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndi_f16)"]
@@ -23229,7 +23229,7 @@ pub fn vrndmq_f64(a: float64x2_t) -> float64x2_t {
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg_attr(test, assert_instr(frintm))]
 pub fn vrndmh_f16(a: f16) -> f16 {
-    unsafe { floorf16(a) }
+    floorf16(a)
 }
 #[doc = "Floating-point round to integral, to nearest with ties to even"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndn_f64)"]
@@ -23356,7 +23356,7 @@ pub fn vrndpq_f64(a: float64x2_t) -> float64x2_t {
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg_attr(test, assert_instr(frintp))]
 pub fn vrndph_f16(a: f16) -> f16 {
-    unsafe { ceilf16(a) }
+    ceilf16(a)
 }
 #[doc = "Floating-point round to integral exact, using current rounding mode"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndx_f16)"]
@@ -24846,7 +24846,7 @@ pub fn vsqrtq_f64(a: float64x2_t) -> float64x2_t {
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg_attr(test, assert_instr(fsqrt))]
 pub fn vsqrth_f16(a: f16) -> f16 {
-    unsafe { sqrtf16(a) }
+    sqrtf16(a)
 }
 #[doc = "Shift Right and Insert (immediate)"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsri_n_s8)"]
diff --git a/library/stdarch/crates/core_arch/src/wasm32/mod.rs b/library/stdarch/crates/core_arch/src/wasm32/mod.rs
index 60049c73295c1..01bf0a71658b8 100644
--- a/library/stdarch/crates/core_arch/src/wasm32/mod.rs
+++ b/library/stdarch/crates/core_arch/src/wasm32/mod.rs
@@ -43,7 +43,7 @@ pub fn unreachable() -> ! {
 #[must_use = "method returns a new number and does not mutate the original value"]
 #[unstable(feature = "wasm_numeric_instr", issue = "133908")]
 pub fn f32_ceil(a: f32) -> f32 {
-    unsafe { crate::intrinsics::ceilf32(a) }
+    crate::intrinsics::ceilf32(a)
 }
 
 /// Generates the [`f32.floor`] instruction, returning the largest integer less than or equal to `a`.
@@ -57,7 +57,7 @@ pub fn f32_ceil(a: f32) -> f32 {
 #[must_use = "method returns a new number and does not mutate the original value"]
 #[unstable(feature = "wasm_numeric_instr", issue = "133908")]
 pub fn f32_floor(a: f32) -> f32 {
-    unsafe { crate::intrinsics::floorf32(a) }
+    crate::intrinsics::floorf32(a)
 }
 
 /// Generates the [`f32.trunc`] instruction, roundinging to the nearest integer towards zero.
@@ -71,7 +71,7 @@ pub fn f32_floor(a: f32) -> f32 {
 #[must_use = "method returns a new number and does not mutate the original value"]
 #[unstable(feature = "wasm_numeric_instr", issue = "133908")]
 pub fn f32_trunc(a: f32) -> f32 {
-    unsafe { crate::intrinsics::truncf32(a) }
+    crate::intrinsics::truncf32(a)
 }
 
 /// Generates the [`f32.nearest`] instruction, roundinging to the nearest integer. Rounds half-way
@@ -100,7 +100,7 @@ pub fn f32_nearest(a: f32) -> f32 {
 #[must_use = "method returns a new number and does not mutate the original value"]
 #[unstable(feature = "wasm_numeric_instr", issue = "133908")]
 pub fn f32_sqrt(a: f32) -> f32 {
-    unsafe { crate::intrinsics::sqrtf32(a) }
+    crate::intrinsics::sqrtf32(a)
 }
 
 /// Generates the [`f64.ceil`] instruction, returning the smallest integer greater than or equal to `a`.
@@ -114,7 +114,7 @@ pub fn f32_sqrt(a: f32) -> f32 {
 #[must_use = "method returns a new number and does not mutate the original value"]
 #[unstable(feature = "wasm_numeric_instr", issue = "133908")]
 pub fn f64_ceil(a: f64) -> f64 {
-    unsafe { crate::intrinsics::ceilf64(a) }
+    crate::intrinsics::ceilf64(a)
 }
 
 /// Generates the [`f64.floor`] instruction, returning the largest integer less than or equal to `a`.
@@ -128,7 +128,7 @@ pub fn f64_ceil(a: f64) -> f64 {
 #[must_use = "method returns a new number and does not mutate the original value"]
 #[unstable(feature = "wasm_numeric_instr", issue = "133908")]
 pub fn f64_floor(a: f64) -> f64 {
-    unsafe { crate::intrinsics::floorf64(a) }
+    crate::intrinsics::floorf64(a)
 }
 
 /// Generates the [`f64.trunc`] instruction, roundinging to the nearest integer towards zero.
@@ -142,7 +142,7 @@ pub fn f64_floor(a: f64) -> f64 {
 #[must_use = "method returns a new number and does not mutate the original value"]
 #[unstable(feature = "wasm_numeric_instr", issue = "133908")]
 pub fn f64_trunc(a: f64) -> f64 {
-    unsafe { crate::intrinsics::truncf64(a) }
+    crate::intrinsics::truncf64(a)
 }
 
 /// Generates the [`f64.nearest`] instruction, roundinging to the nearest integer. Rounds half-way
@@ -171,7 +171,7 @@ pub fn f64_nearest(a: f64) -> f64 {
 #[must_use = "method returns a new number and does not mutate the original value"]
 #[unstable(feature = "wasm_numeric_instr", issue = "133908")]
 pub fn f64_sqrt(a: f64) -> f64 {
-    unsafe { crate::intrinsics::sqrtf64(a) }
+    crate::intrinsics::sqrtf64(a)
 }
 
 unsafe extern "C-unwind" {
diff --git a/library/stdarch/crates/stdarch-gen-arm/spec/neon/aarch64.spec.yml b/library/stdarch/crates/stdarch-gen-arm/spec/neon/aarch64.spec.yml
index a31613e6b1aef..ece435870ae2f 100644
--- a/library/stdarch/crates/stdarch-gen-arm/spec/neon/aarch64.spec.yml
+++ b/library/stdarch/crates/stdarch-gen-arm/spec/neon/aarch64.spec.yml
@@ -3054,7 +3054,7 @@ intrinsics:
     types:
       - [f16, 'h_']
     compose:
-      - FnCall: [roundf16, [a], [], true]
+      - FnCall: [roundf16, [a], []]
 
   - name: "vrndn{neon_type.no}"
     doc: "Floating-point round to integral, to nearest with ties to even"
@@ -3151,7 +3151,7 @@ intrinsics:
     types:
       - [f16, 'h_']
     compose:
-      - FnCall: [floorf16, [a], [], true]
+      - FnCall: [floorf16, [a], []]
 
 
 
@@ -3198,7 +3198,7 @@ intrinsics:
     types:
       - [f16, 'h_']
     compose:
-      - FnCall: [ceilf16, [a], [], true]
+      - FnCall: [ceilf16, [a], []]
 
   - name: "vrnd{neon_type.no}"
     doc: "Floating-point round to integral, toward zero"
@@ -3243,7 +3243,7 @@ intrinsics:
     types:
       - [f16, 'h_']
     compose:
-      - FnCall: [truncf16, [a], [], true]
+      - FnCall: [truncf16, [a], []]
 
 
   - name: "vrndi{neon_type.no}"
@@ -8398,7 +8398,7 @@ intrinsics:
     types:
       - [f16, 'h_']
     compose:
-      - FnCall: [sqrtf16, [a], [], true]
+      - FnCall: [sqrtf16, [a], []]
 
   - name: "vrsqrts{type[0]}"
     doc: "Floating-point reciprocal square root step"
@@ -10346,7 +10346,7 @@ intrinsics:
     types:
       - ["f16", "h_f16"]
     compose:
-      - FnCall: [fmaf16, [b, c, a], [], true]
+      - FnCall: [fmaf16, [b, c, a], []]
 
 
   - name: "vfmah_lane{type[2]}"
diff --git a/src/tools/miri/tests/pass/float.rs b/src/tools/miri/tests/pass/float.rs
index 9f1b3f612b2d2..323019df42504 100644
--- a/src/tools/miri/tests/pass/float.rs
+++ b/src/tools/miri/tests/pass/float.rs
@@ -1401,12 +1401,12 @@ fn test_fmuladd() {
 
     #[inline(never)]
     pub fn test_operations_f32(a: f32, b: f32, c: f32) {
-        assert_approx_eq!(unsafe { fmuladdf32(a, b, c) }, a * b + c);
+        assert_approx_eq!(fmuladdf32(a, b, c), a * b + c);
     }
 
     #[inline(never)]
     pub fn test_operations_f64(a: f64, b: f64, c: f64) {
-        assert_approx_eq!(unsafe { fmuladdf64(a, b, c) }, a * b + c);
+        assert_approx_eq!(fmuladdf64(a, b, c), a * b + c);
     }
 
     test_operations_f32(0.1, 0.2, 0.3);
diff --git a/src/tools/miri/tests/pass/intrinsics/fmuladd_nondeterministic.rs b/src/tools/miri/tests/pass/intrinsics/fmuladd_nondeterministic.rs
index b688405c4b184..4d3e91c4cba76 100644
--- a/src/tools/miri/tests/pass/intrinsics/fmuladd_nondeterministic.rs
+++ b/src/tools/miri/tests/pass/intrinsics/fmuladd_nondeterministic.rs
@@ -28,7 +28,7 @@ fn main() {
             let c = std::hint::black_box(-a * b);
             // It is unspecified whether the following operation is fused or not. The
             // following evaluates to 0.0 if unfused, and nonzero (-1.66e-18) if fused.
-            let x = unsafe { fmuladdf64(a, b, c) };
+            let x = fmuladdf64(a, b, c);
             x == 0.0
         }),
         "`fmuladdf64` failed to be evaluated as both fused and unfused"
@@ -41,7 +41,7 @@ fn main() {
             let c = std::hint::black_box(-a * b);
             // It is unspecified whether the following operation is fused or not. The
             // following evaluates to 0.0 if unfused, and nonzero (-8.1956386e-10) if fused.
-            let x = unsafe { fmuladdf32(a, b, c) };
+            let x = fmuladdf32(a, b, c);
             x == 0.0
         }),
         "`fmuladdf32` failed to be evaluated as both fused and unfused"
diff --git a/tests/codegen-llvm/intrinsic-no-unnamed-attr.rs b/tests/codegen-llvm/intrinsic-no-unnamed-attr.rs
index 4bec579831dc4..255f20e6ff640 100644
--- a/tests/codegen-llvm/intrinsic-no-unnamed-attr.rs
+++ b/tests/codegen-llvm/intrinsic-no-unnamed-attr.rs
@@ -7,7 +7,5 @@ use std::intrinsics::sqrtf32;
 // CHECK: @llvm.sqrt.f32(float) #{{[0-9]*}}
 
 fn main() {
-    unsafe {
-        sqrtf32(0.0f32);
-    }
+    sqrtf32(0.0f32);
 }
diff --git a/tests/ui/intrinsics/intrinsic-fmuladd.rs b/tests/ui/intrinsics/intrinsic-fmuladd.rs
index d03297884f791..ab4285590cb95 100644
--- a/tests/ui/intrinsics/intrinsic-fmuladd.rs
+++ b/tests/ui/intrinsics/intrinsic-fmuladd.rs
@@ -11,7 +11,7 @@ macro_rules! assert_approx_eq {
 }
 
 fn main() {
-    unsafe {
+    {
         let nan: f32 = f32::NAN;
         let inf: f32 = f32::INFINITY;
         let neg_inf: f32 = f32::NEG_INFINITY;
@@ -25,7 +25,7 @@ fn main() {
         assert_eq!(fmuladdf32(8.9, inf, 3.2), inf);
         assert_eq!(fmuladdf32(-3.2, 2.4, neg_inf), neg_inf);
     }
-    unsafe {
+    {
         let nan: f64 = f64::NAN;
         let inf: f64 = f64::INFINITY;
         let neg_inf: f64 = f64::NEG_INFINITY;
diff --git a/tests/ui/intrinsics/reify-intrinsic.stderr b/tests/ui/intrinsics/reify-intrinsic.stderr
index aea6f838e0d44..1307a85c8b6ca 100644
--- a/tests/ui/intrinsics/reify-intrinsic.stderr
+++ b/tests/ui/intrinsics/reify-intrinsic.stderr
@@ -22,7 +22,7 @@ LL |         std::intrinsics::floorf32,
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ cannot coerce intrinsics to function pointers
    |
    = note: expected fn pointer `unsafe fn(_) -> _`
-                 found fn item `unsafe fn(_) -> _ {floorf32}`
+                 found fn item `fn(_) -> _ {floorf32}`
 
 error: aborting due to 3 previous errors
 

From ab7cfc7c307d50659a0165dad910565809f5d40f Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Mon, 22 Sep 2025 02:14:50 +0300
Subject: [PATCH 1242/1889] Clarify `rust-analyzer.inlayHints.maxLength` is not
 a hard guarantee

---
 src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs      | 2 ++
 .../rust-analyzer/docs/book/src/configuration_generated.md      | 2 ++
 src/tools/rust-analyzer/editors/code/package.json               | 2 +-
 3 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
index 6b489d5114381..a88d228fcb60c 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/config.rs
@@ -267,6 +267,8 @@ config_data! {
         inlayHints_lifetimeElisionHints_useParameterNames: bool = false,
 
         /// Maximum length for inlay hints. Set to null to have an unlimited length.
+        ///
+        /// **Note:** This is mostly a hint, and we don't guarantee to strictly follow the limit.
         inlayHints_maxLength: Option<usize> = Some(25),
 
         /// Show function parameter name inlay hints at the call site.
diff --git a/src/tools/rust-analyzer/docs/book/src/configuration_generated.md b/src/tools/rust-analyzer/docs/book/src/configuration_generated.md
index 50dacd88f4072..e78f1b4ba3582 100644
--- a/src/tools/rust-analyzer/docs/book/src/configuration_generated.md
+++ b/src/tools/rust-analyzer/docs/book/src/configuration_generated.md
@@ -1046,6 +1046,8 @@ Default: `25`
 
 Maximum length for inlay hints. Set to null to have an unlimited length.
 
+**Note:** This is mostly a hint, and we don't guarantee to strictly follow the limit.
+
 
 ## rust-analyzer.inlayHints.parameterHints.enable {#inlayHints.parameterHints.enable}
 
diff --git a/src/tools/rust-analyzer/editors/code/package.json b/src/tools/rust-analyzer/editors/code/package.json
index 1d27a12053552..745e0da4efef0 100644
--- a/src/tools/rust-analyzer/editors/code/package.json
+++ b/src/tools/rust-analyzer/editors/code/package.json
@@ -2355,7 +2355,7 @@
                 "title": "Inlay Hints",
                 "properties": {
                     "rust-analyzer.inlayHints.maxLength": {
-                        "markdownDescription": "Maximum length for inlay hints. Set to null to have an unlimited length.",
+                        "markdownDescription": "Maximum length for inlay hints. Set to null to have an unlimited length.\n\n**Note:** This is mostly a hint, and we don't guarantee to strictly follow the limit.",
                         "default": 25,
                         "type": [
                             "null",

From 8f1a1f8533cb270625a057a2bb7f50ef3f8ec1b5 Mon Sep 17 00:00:00 2001
From: Iris Shi <0.0@owo.li>
Date: Mon, 22 Sep 2025 05:45:23 +0200
Subject: [PATCH 1243/1889] Update
 tests/rustdoc/private-mod-override-re-export.rs

Co-authored-by: lolbinarycat <dogedoge61+github@gmail.com>
---
 tests/rustdoc/private-mod-override-re-export.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/rustdoc/private-mod-override-re-export.rs b/tests/rustdoc/private-mod-override-re-export.rs
index 47b07958709bb..8deafe2422256 100644
--- a/tests/rustdoc/private-mod-override-re-export.rs
+++ b/tests/rustdoc/private-mod-override-re-export.rs
@@ -11,4 +11,4 @@ mod m1 {
 pub use m1::*;
 use crate::m1::m2;
 
-//@ !has foo/index.html '//a[@href="m2/index.html"]' 'm2'
+//@ count foo/index.html '//a[@class="mod"]' 0

From 52e6998a1837884daad9c9a0f8bf78631557fd2a Mon Sep 17 00:00:00 2001
From: Iris Shi <0.0@owo.li>
Date: Mon, 22 Sep 2025 11:47:12 +0800
Subject: [PATCH 1244/1889] Move test file

---
 .../private-mod-override-reexport.rs}                             | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename tests/rustdoc/{private-mod-override-re-export.rs => reexport/private-mod-override-reexport.rs} (100%)

diff --git a/tests/rustdoc/private-mod-override-re-export.rs b/tests/rustdoc/reexport/private-mod-override-reexport.rs
similarity index 100%
rename from tests/rustdoc/private-mod-override-re-export.rs
rename to tests/rustdoc/reexport/private-mod-override-reexport.rs

From 5658b39397d2667ed8c51ef6b5c52f562af4415e Mon Sep 17 00:00:00 2001
From: The rustc-josh-sync Cronjob Bot <github-actions@github.com>
Date: Mon, 22 Sep 2025 04:13:50 +0000
Subject: [PATCH 1245/1889] Prepare for merging from rust-lang/rust

This updates the rust-version file to 9f32ccf35fb877270bc44a86a126440f04d676d0.
---
 src/doc/rustc-dev-guide/rust-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/rust-version b/src/doc/rustc-dev-guide/rust-version
index df2bac877b66f..0dc9ce843e9c9 100644
--- a/src/doc/rustc-dev-guide/rust-version
+++ b/src/doc/rustc-dev-guide/rust-version
@@ -1 +1 @@
-2f3f27bf79ec147fec9d2e7980605307a74067f4
+9f32ccf35fb877270bc44a86a126440f04d676d0

From 9acc63a48c8206cfe2c2d272600d538983308657 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Wed, 17 Sep 2025 22:29:49 -0700
Subject: [PATCH 1246/1889] port `#[debugger_visualizer]` to the new attribute
 system

---
 .../src/attributes/debugger.rs                |  60 ++++++++++
 .../rustc_attr_parsing/src/attributes/mod.rs  |   1 +
 compiler/rustc_attr_parsing/src/context.rs    |   2 +
 .../rustc_codegen_llvm/src/debuginfo/gdb.rs   |   2 +-
 compiler/rustc_codegen_ssa/src/base.rs        |   4 +-
 .../rustc_hir/src/attrs/data_structures.rs    |  19 ++-
 .../rustc_hir/src/attrs/encode_cross_crate.rs |   1 +
 .../src/middle/debugger_visualizer.rs         |   8 +-
 compiler/rustc_passes/messages.ftl            |   9 --
 compiler/rustc_passes/src/check_attr.rs       |  16 +--
 .../rustc_passes/src/debugger_visualizer.rs   | 113 +++++++++---------
 compiler/rustc_passes/src/errors.rs           |  17 ---
 tests/ui/attributes/malformed-attrs.rs        |   3 +-
 tests/ui/attributes/malformed-attrs.stderr    |  53 ++++----
 .../invalid-debugger-visualizer-option.rs     |   2 +-
 .../invalid-debugger-visualizer-option.stderr |  22 ++--
 .../invalid-debugger-visualizer-target.rs     |   3 +-
 .../invalid-debugger-visualizer-target.stderr |   4 +-
 18 files changed, 185 insertions(+), 154 deletions(-)
 create mode 100644 compiler/rustc_attr_parsing/src/attributes/debugger.rs

diff --git a/compiler/rustc_attr_parsing/src/attributes/debugger.rs b/compiler/rustc_attr_parsing/src/attributes/debugger.rs
new file mode 100644
index 0000000000000..56ff10be42640
--- /dev/null
+++ b/compiler/rustc_attr_parsing/src/attributes/debugger.rs
@@ -0,0 +1,60 @@
+use rustc_hir::attrs::{DebugVisualizer, DebuggerVisualizerType};
+
+use super::prelude::*;
+
+pub(crate) struct DebuggerViualizerParser;
+
+impl<S: Stage> CombineAttributeParser<S> for DebuggerViualizerParser {
+    const PATH: &[Symbol] = &[sym::debugger_visualizer];
+    const ALLOWED_TARGETS: AllowedTargets =
+        AllowedTargets::AllowList(&[Allow(Target::Mod), Allow(Target::Crate)]);
+    const TEMPLATE: AttributeTemplate = template!(
+        List: &[r#"natvis_file = "...", gdb_script_file = "...""#],
+        "https://doc.rust-lang.org/reference/attributes/debugger.html#the-debugger_visualizer-attribute"
+    );
+
+    type Item = DebugVisualizer;
+    const CONVERT: ConvertFn<Self::Item> = |v, _| AttributeKind::DebuggerVisualizer(v);
+
+    fn extend<'c>(
+        cx: &'c mut AcceptContext<'_, '_, S>,
+        args: &'c ArgParser<'_>,
+    ) -> impl IntoIterator<Item = Self::Item> + 'c {
+        let Some(l) = args.list() else {
+            cx.expected_list(args.span().unwrap_or(cx.attr_span));
+            return None;
+        };
+        let Some(single) = l.single() else {
+            cx.expected_single_argument(l.span);
+            return None;
+        };
+        let Some(mi) = single.meta_item() else {
+            cx.expected_name_value(single.span(), None);
+            return None;
+        };
+        let path = mi.path().word_sym();
+        let visualizer_type = match path {
+            Some(sym::natvis_file) => DebuggerVisualizerType::Natvis,
+            Some(sym::gdb_script_file) => DebuggerVisualizerType::GdbPrettyPrinter,
+            _ => {
+                cx.expected_specific_argument(
+                    mi.path().span(),
+                    &[sym::natvis_file, sym::gdb_script_file],
+                );
+                return None;
+            }
+        };
+
+        let Some(path) = mi.args().name_value() else {
+            cx.expected_name_value(single.span(), path);
+            return None;
+        };
+
+        let Some(path) = path.value_as_str() else {
+            cx.expected_string_literal(path.value_span, Some(path.value_as_lit()));
+            return None;
+        };
+
+        Some(DebugVisualizer { span: mi.span(), visualizer_type, path })
+    }
+}
diff --git a/compiler/rustc_attr_parsing/src/attributes/mod.rs b/compiler/rustc_attr_parsing/src/attributes/mod.rs
index 4ed13d239b9d6..8dbf4c0ef32ef 100644
--- a/compiler/rustc_attr_parsing/src/attributes/mod.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/mod.rs
@@ -36,6 +36,7 @@ pub(crate) mod cfg_old;
 pub(crate) mod codegen_attrs;
 pub(crate) mod confusables;
 pub(crate) mod crate_level;
+pub(crate) mod debugger;
 pub(crate) mod deprecation;
 pub(crate) mod dummy;
 pub(crate) mod inline;
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index 4c32bb87a242c..1f1f9d6d50e56 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -28,6 +28,7 @@ use crate::attributes::crate_level::{
     CrateNameParser, MoveSizeLimitParser, NoCoreParser, NoStdParser, PatternComplexityLimitParser,
     RecursionLimitParser, RustcCoherenceIsCoreParser, TypeLengthLimitParser,
 };
+use crate::attributes::debugger::DebuggerViualizerParser;
 use crate::attributes::deprecation::DeprecationParser;
 use crate::attributes::dummy::DummyParser;
 use crate::attributes::inline::{InlineParser, RustcForceInlineParser};
@@ -163,6 +164,7 @@ attribute_parsers!(
         // tidy-alphabetical-start
         Combine<AllowConstFnUnstableParser>,
         Combine<AllowInternalUnstableParser>,
+        Combine<DebuggerViualizerParser>,
         Combine<ForceTargetFeatureParser>,
         Combine<LinkParser>,
         Combine<ReprParser>,
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs b/compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs
index 7a6dc008c7b9e..3081badb821fa 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs
@@ -2,9 +2,9 @@
 
 use rustc_codegen_ssa::base::collect_debugger_visualizers_transitive;
 use rustc_codegen_ssa::traits::*;
+use rustc_hir::attrs::DebuggerVisualizerType;
 use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_middle::bug;
-use rustc_middle::middle::debugger_visualizer::DebuggerVisualizerType;
 use rustc_session::config::{CrateType, DebugInfo};
 
 use crate::builder::Builder;
diff --git a/compiler/rustc_codegen_ssa/src/base.rs b/compiler/rustc_codegen_ssa/src/base.rs
index 68a2f43ec67bc..422b06350e1fc 100644
--- a/compiler/rustc_codegen_ssa/src/base.rs
+++ b/compiler/rustc_codegen_ssa/src/base.rs
@@ -11,12 +11,12 @@ use rustc_data_structures::fx::{FxHashMap, FxIndexSet};
 use rustc_data_structures::profiling::{get_resident_set_size, print_time_passes_entry};
 use rustc_data_structures::sync::{IntoDynSyncSend, par_map};
 use rustc_data_structures::unord::UnordMap;
-use rustc_hir::attrs::OptimizeAttr;
+use rustc_hir::attrs::{DebuggerVisualizerType, OptimizeAttr};
 use rustc_hir::def_id::{DefId, LOCAL_CRATE};
 use rustc_hir::lang_items::LangItem;
 use rustc_hir::{ItemId, Target};
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrs;
-use rustc_middle::middle::debugger_visualizer::{DebuggerVisualizerFile, DebuggerVisualizerType};
+use rustc_middle::middle::debugger_visualizer::DebuggerVisualizerFile;
 use rustc_middle::middle::dependency_format::Dependencies;
 use rustc_middle::middle::exported_symbols::{self, SymbolExportKind};
 use rustc_middle::middle::lang_items;
diff --git a/compiler/rustc_hir/src/attrs/data_structures.rs b/compiler/rustc_hir/src/attrs/data_structures.rs
index 8ab43ff2582c0..5a9e644f9702c 100644
--- a/compiler/rustc_hir/src/attrs/data_structures.rs
+++ b/compiler/rustc_hir/src/attrs/data_structures.rs
@@ -363,6 +363,20 @@ pub struct LinkEntry {
     pub import_name_type: Option<(PeImportNameType, Span)>,
 }
 
+#[derive(HashStable_Generic, PrintAttribute)]
+#[derive(Copy, PartialEq, PartialOrd, Clone, Ord, Eq, Hash, Debug, Encodable, Decodable)]
+pub enum DebuggerVisualizerType {
+    Natvis,
+    GdbPrettyPrinter,
+}
+
+#[derive(Debug, Encodable, Decodable, Clone, HashStable_Generic, PrintAttribute)]
+pub struct DebugVisualizer {
+    pub span: Span,
+    pub visualizer_type: DebuggerVisualizerType,
+    pub path: Symbol,
+}
+
 /// Represents parsed *built-in* inert attributes.
 ///
 /// ## Overview
@@ -485,7 +499,10 @@ pub enum AttributeKind {
     /// Represents `#[custom_mir]`.
     CustomMir(Option<(MirDialect, Span)>, Option<(MirPhase, Span)>, Span),
 
-    ///Represents `#[rustc_deny_explicit_impl]`.
+    /// Represents `#[debugger_visualizer]`.
+    DebuggerVisualizer(ThinVec<DebugVisualizer>),
+
+    /// Represents `#[rustc_deny_explicit_impl]`.
     DenyExplicitImpl(Span),
 
     /// Represents [`#[deprecated]`](https://doc.rust-lang.org/stable/reference/attributes/diagnostics.html#the-deprecated-attribute).
diff --git a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
index 8e44340507478..7112daa327e2f 100644
--- a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
+++ b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
@@ -37,6 +37,7 @@ impl AttributeKind {
             Coverage(..) => No,
             CrateName { .. } => No,
             CustomMir(_, _, _) => Yes,
+            DebuggerVisualizer(..) => No,
             DenyExplicitImpl(..) => No,
             Deprecation { .. } => Yes,
             DoNotImplementViaObject(..) => No,
diff --git a/compiler/rustc_middle/src/middle/debugger_visualizer.rs b/compiler/rustc_middle/src/middle/debugger_visualizer.rs
index 5a811321f58b9..a7f0095dcdfb8 100644
--- a/compiler/rustc_middle/src/middle/debugger_visualizer.rs
+++ b/compiler/rustc_middle/src/middle/debugger_visualizer.rs
@@ -1,15 +1,9 @@
 use std::path::PathBuf;
 use std::sync::Arc;
 
+use rustc_hir::attrs::DebuggerVisualizerType;
 use rustc_macros::{Decodable, Encodable, HashStable};
 
-#[derive(HashStable)]
-#[derive(Copy, PartialEq, PartialOrd, Clone, Ord, Eq, Hash, Debug, Encodable, Decodable)]
-pub enum DebuggerVisualizerType {
-    Natvis,
-    GdbPrettyPrinter,
-}
-
 /// A single debugger visualizer file.
 #[derive(HashStable)]
 #[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Encodable, Decodable)]
diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index 6cd68380e46f1..870e0a90b5421 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -93,15 +93,6 @@ passes_dead_codes =
        }
     } never {$participle}
 
-passes_debug_visualizer_invalid =
-    invalid argument
-    .note_1 = expected: `natvis_file = "..."`
-    .note_2 = OR
-    .note_3 = expected: `gdb_script_file = "..."`
-
-passes_debug_visualizer_placement =
-    attribute should be applied to a module
-
 passes_debug_visualizer_unreadable =
     couldn't read {$file}: {$error}
 
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 94c9e71ce7705..9f40e713e5084 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -281,6 +281,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::ObjcClass { .. }
                     | AttributeKind::ObjcSelector { .. }
                     | AttributeKind::RustcCoherenceIsCore(..)
+                    | AttributeKind::DebuggerVisualizer(..)
                 ) => { /* do nothing  */ }
                 Attribute::Unparsed(attr_item) => {
                     style = Some(attr_item.style);
@@ -301,7 +302,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                             &mut doc_aliases,
                         ),
                         [sym::no_link, ..] => self.check_no_link(hir_id, attr, span, target),
-                        [sym::debugger_visualizer, ..] => self.check_debugger_visualizer(attr, target),
                         [sym::rustc_no_implicit_autorefs, ..] => {
                             self.check_applied_to_fn_or_method(hir_id, attr.span(), span, target)
                         }
@@ -1782,20 +1782,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         }
     }
 
-    /// Checks if the items on the `#[debugger_visualizer]` attribute are valid.
-    fn check_debugger_visualizer(&self, attr: &Attribute, target: Target) {
-        // Here we only check that the #[debugger_visualizer] attribute is attached
-        // to nothing other than a module. All other checks are done in the
-        // `debugger_visualizer` query where they need to be done for decoding
-        // anyway.
-        match target {
-            Target::Mod => {}
-            _ => {
-                self.dcx().emit_err(errors::DebugVisualizerPlacement { span: attr.span() });
-            }
-        }
-    }
-
     /// Outputs an error for `#[allow_internal_unstable]` which can only be applied to macros.
     /// (Allows proc_macro functions)
     fn check_rustc_allow_const_fn_unstable(
diff --git a/compiler/rustc_passes/src/debugger_visualizer.rs b/compiler/rustc_passes/src/debugger_visualizer.rs
index 7a7a8175e5569..7211f3cf85b31 100644
--- a/compiler/rustc_passes/src/debugger_visualizer.rs
+++ b/compiler/rustc_passes/src/debugger_visualizer.rs
@@ -1,67 +1,60 @@
 //! Detecting usage of the `#[debugger_visualizer]` attribute.
 
-use rustc_ast::Attribute;
+use rustc_ast::ast::NodeId;
+use rustc_ast::{HasNodeId, ItemKind, ast};
+use rustc_attr_parsing::AttributeParser;
 use rustc_expand::base::resolve_path;
-use rustc_middle::middle::debugger_visualizer::{DebuggerVisualizerFile, DebuggerVisualizerType};
+use rustc_hir::Attribute;
+use rustc_hir::attrs::{AttributeKind, DebugVisualizer};
+use rustc_middle::middle::debugger_visualizer::DebuggerVisualizerFile;
 use rustc_middle::query::{LocalCrate, Providers};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Session;
-use rustc_span::sym;
+use rustc_span::{DUMMY_SP, Span, sym};
 
-use crate::errors::{DebugVisualizerInvalid, DebugVisualizerUnreadable};
+use crate::errors::DebugVisualizerUnreadable;
 
 impl DebuggerVisualizerCollector<'_> {
-    fn check_for_debugger_visualizer(&mut self, attr: &Attribute) {
-        if attr.has_name(sym::debugger_visualizer) {
-            let Some(hints) = attr.meta_item_list() else {
-                self.sess.dcx().emit_err(DebugVisualizerInvalid { span: attr.span });
-                return;
-            };
+    fn check_for_debugger_visualizer(
+        &mut self,
+        attrs: &[ast::Attribute],
+        span: Span,
+        node_id: NodeId,
+    ) {
+        if let Some(Attribute::Parsed(AttributeKind::DebuggerVisualizer(visualizers))) =
+            AttributeParser::parse_limited(
+                &self.sess,
+                attrs,
+                sym::debugger_visualizer,
+                span,
+                node_id,
+                None,
+            )
+        {
+            for DebugVisualizer { span, visualizer_type, path } in visualizers {
+                let file = match resolve_path(&self.sess, path.as_str(), span) {
+                    Ok(file) => file,
+                    Err(err) => {
+                        err.emit();
+                        return;
+                    }
+                };
 
-            let [hint] = hints.as_slice() else {
-                self.sess.dcx().emit_err(DebugVisualizerInvalid { span: attr.span });
-                return;
-            };
-
-            let Some(meta_item) = hint.meta_item() else {
-                self.sess.dcx().emit_err(DebugVisualizerInvalid { span: attr.span });
-                return;
-            };
-
-            let (visualizer_type, visualizer_path) = match (meta_item.name(), meta_item.value_str())
-            {
-                (Some(sym::natvis_file), Some(value)) => (DebuggerVisualizerType::Natvis, value),
-                (Some(sym::gdb_script_file), Some(value)) => {
-                    (DebuggerVisualizerType::GdbPrettyPrinter, value)
-                }
-                (_, _) => {
-                    self.sess.dcx().emit_err(DebugVisualizerInvalid { span: meta_item.span });
-                    return;
-                }
-            };
-
-            let file = match resolve_path(&self.sess, visualizer_path.as_str(), attr.span) {
-                Ok(file) => file,
-                Err(err) => {
-                    err.emit();
-                    return;
-                }
-            };
-
-            match self.sess.source_map().load_binary_file(&file) {
-                Ok((source, _)) => {
-                    self.visualizers.push(DebuggerVisualizerFile::new(
-                        source,
-                        visualizer_type,
-                        file,
-                    ));
-                }
-                Err(error) => {
-                    self.sess.dcx().emit_err(DebugVisualizerUnreadable {
-                        span: meta_item.span,
-                        file: &file,
-                        error,
-                    });
+                match self.sess.source_map().load_binary_file(&file) {
+                    Ok((source, _)) => {
+                        self.visualizers.push(DebuggerVisualizerFile::new(
+                            source,
+                            visualizer_type,
+                            file,
+                        ));
+                    }
+                    Err(error) => {
+                        self.sess.dcx().emit_err(DebugVisualizerUnreadable {
+                            span,
+                            file: &file,
+                            error,
+                        });
+                    }
                 }
             }
         }
@@ -74,9 +67,15 @@ struct DebuggerVisualizerCollector<'a> {
 }
 
 impl<'ast> rustc_ast::visit::Visitor<'ast> for DebuggerVisualizerCollector<'_> {
-    fn visit_attribute(&mut self, attr: &'ast Attribute) {
-        self.check_for_debugger_visualizer(attr);
-        rustc_ast::visit::walk_attribute(self, attr);
+    fn visit_item(&mut self, item: &'ast rustc_ast::Item) -> Self::Result {
+        if let ItemKind::Mod(..) = item.kind {
+            self.check_for_debugger_visualizer(&item.attrs, item.span, item.node_id());
+        }
+        rustc_ast::visit::walk_item(self, item);
+    }
+    fn visit_crate(&mut self, krate: &'ast ast::Crate) -> Self::Result {
+        self.check_for_debugger_visualizer(&krate.attrs, DUMMY_SP, krate.id);
+        rustc_ast::visit::walk_crate(self, krate);
     }
 }
 
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index cd8935f6b2f07..cfd6b9e6dffaf 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -475,23 +475,6 @@ pub(crate) struct MacroOnlyAttribute {
     pub span: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag(passes_debug_visualizer_placement)]
-pub(crate) struct DebugVisualizerPlacement {
-    #[primary_span]
-    pub span: Span,
-}
-
-#[derive(Diagnostic)]
-#[diag(passes_debug_visualizer_invalid)]
-#[note(passes_note_1)]
-#[note(passes_note_2)]
-#[note(passes_note_3)]
-pub(crate) struct DebugVisualizerInvalid {
-    #[primary_span]
-    pub span: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag(passes_debug_visualizer_unreadable)]
 pub(crate) struct DebugVisualizerUnreadable<'a> {
diff --git a/tests/ui/attributes/malformed-attrs.rs b/tests/ui/attributes/malformed-attrs.rs
index e30479b03b11f..820484aa015d2 100644
--- a/tests/ui/attributes/malformed-attrs.rs
+++ b/tests/ui/attributes/malformed-attrs.rs
@@ -185,8 +185,7 @@ extern "C" {
 #[forbid]
 //~^ ERROR malformed
 #[debugger_visualizer]
-//~^ ERROR invalid argument
-//~| ERROR malformed `debugger_visualizer` attribute input
+//~^ ERROR malformed `debugger_visualizer` attribute input
 #[automatically_derived = 18]
 //~^ ERROR malformed
 mod yooo {
diff --git a/tests/ui/attributes/malformed-attrs.stderr b/tests/ui/attributes/malformed-attrs.stderr
index 246029ecf80fe..70ab3fb13c49e 100644
--- a/tests/ui/attributes/malformed-attrs.stderr
+++ b/tests/ui/attributes/malformed-attrs.stderr
@@ -22,7 +22,7 @@ LL | #[cfg_attr(condition, attribute, other_attribute, ...)]
    |           ++++++++++++++++++++++++++++++++++++++++++++
 
 error[E0463]: can't find crate for `wloop`
-  --> $DIR/malformed-attrs.rs:210:1
+  --> $DIR/malformed-attrs.rs:209:1
    |
 LL | extern crate wloop;
    | ^^^^^^^^^^^^^^^^^^^ can't find crate
@@ -156,22 +156,14 @@ LL | #[forbid(lint1, lint2, ...)]
 LL | #[forbid(lint1, lint2, lint3, reason = "...")]
    |         +++++++++++++++++++++++++++++++++++++
 
-error: malformed `debugger_visualizer` attribute input
-  --> $DIR/malformed-attrs.rs:187:1
-   |
-LL | #[debugger_visualizer]
-   | ^^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[debugger_visualizer(natvis_file = "...", gdb_script_file = "...")]`
-   |
-   = note: for more information, visit <https://doc.rust-lang.org/reference/attributes/debugger.html#the-debugger_visualizer-attribute>
-
 error: malformed `thread_local` attribute input
-  --> $DIR/malformed-attrs.rs:202:1
+  --> $DIR/malformed-attrs.rs:201:1
    |
 LL | #[thread_local()]
    | ^^^^^^^^^^^^^^^^^ help: must be of the form: `#[thread_local]`
 
 error: malformed `no_link` attribute input
-  --> $DIR/malformed-attrs.rs:206:1
+  --> $DIR/malformed-attrs.rs:205:1
    |
 LL | #[no_link()]
    | ^^^^^^^^^^^^ help: must be of the form: `#[no_link]`
@@ -197,7 +189,7 @@ LL | #[proc_macro_derive]
    | ^^^^^^^^^^^^^^^^^^^^
 
 error[E0658]: allow_internal_unsafe side-steps the unsafe_code lint
-  --> $DIR/malformed-attrs.rs:215:1
+  --> $DIR/malformed-attrs.rs:214:1
    |
 LL | #[allow_internal_unsafe = 1]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -226,16 +218,6 @@ LL | #[doc]
    = note: for more information, see issue #57571 <https://github.com/rust-lang/rust/issues/57571>
    = note: for more information, visit <https://doc.rust-lang.org/rustdoc/write-documentation/the-doc-attribute.html>
 
-error: invalid argument
-  --> $DIR/malformed-attrs.rs:187:1
-   |
-LL | #[debugger_visualizer]
-   | ^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: expected: `natvis_file = "..."`
-   = note: OR
-   = note: expected: `gdb_script_file = "..."`
-
 error[E0539]: malformed `export_name` attribute input
   --> $DIR/malformed-attrs.rs:29:1
    |
@@ -685,8 +667,19 @@ LL |     #[linkage = "external"]
    |               ++++++++++++
    = and 5 other candidates
 
+error[E0539]: malformed `debugger_visualizer` attribute input
+  --> $DIR/malformed-attrs.rs:187:1
+   |
+LL | #[debugger_visualizer]
+   | ^^^^^^^^^^^^^^^^^^^^^^
+   | |
+   | expected this to be a list
+   | help: must be of the form: `#[debugger_visualizer(natvis_file = "...", gdb_script_file = "...")]`
+   |
+   = note: for more information, visit <https://doc.rust-lang.org/reference/attributes/debugger.html#the-debugger_visualizer-attribute>
+
 error[E0565]: malformed `automatically_derived` attribute input
-  --> $DIR/malformed-attrs.rs:190:1
+  --> $DIR/malformed-attrs.rs:189:1
    |
 LL | #[automatically_derived = 18]
    | ^^^^^^^^^^^^^^^^^^^^^^^^----^
@@ -695,7 +688,7 @@ LL | #[automatically_derived = 18]
    | help: must be of the form: `#[automatically_derived]`
 
 error[E0565]: malformed `non_exhaustive` attribute input
-  --> $DIR/malformed-attrs.rs:196:1
+  --> $DIR/malformed-attrs.rs:195:1
    |
 LL | #[non_exhaustive = 1]
    | ^^^^^^^^^^^^^^^^^---^
@@ -704,19 +697,19 @@ LL | #[non_exhaustive = 1]
    | help: must be of the form: `#[non_exhaustive]`
 
 error: valid forms for the attribute are `#[macro_use(name1, name2, ...)]` and `#[macro_use]`
-  --> $DIR/malformed-attrs.rs:208:1
+  --> $DIR/malformed-attrs.rs:207:1
    |
 LL | #[macro_use = 1]
    | ^^^^^^^^^^^^^^^^
 
 error: valid forms for the attribute are `#![macro_export(local_inner_macros)]` and `#![macro_export]`
-  --> $DIR/malformed-attrs.rs:213:1
+  --> $DIR/malformed-attrs.rs:212:1
    |
 LL | #[macro_export = 18]
    | ^^^^^^^^^^^^^^^^^^^^
 
 error[E0565]: malformed `allow_internal_unsafe` attribute input
-  --> $DIR/malformed-attrs.rs:215:1
+  --> $DIR/malformed-attrs.rs:214:1
    |
 LL | #[allow_internal_unsafe = 1]
    | ^^^^^^^^^^^^^^^^^^^^^^^^---^
@@ -800,7 +793,7 @@ LL | #[ignore()]
    = note: for more information, see issue #57571 <https://github.com/rust-lang/rust/issues/57571>
 
 error: valid forms for the attribute are `#[ignore = "reason"]` and `#[ignore]`
-  --> $DIR/malformed-attrs.rs:222:1
+  --> $DIR/malformed-attrs.rs:221:1
    |
 LL | #[ignore = 1]
    | ^^^^^^^^^^^^^
@@ -819,7 +812,7 @@ LL |     #[coroutine = 63] || {}
    = note: expected unit type `()`
               found coroutine `{coroutine@$DIR/malformed-attrs.rs:110:23: 110:25}`
 
-error: aborting due to 77 previous errors; 3 warnings emitted
+error: aborting due to 76 previous errors; 3 warnings emitted
 
 Some errors have detailed explanations: E0308, E0463, E0539, E0565, E0658, E0805.
 For more information about an error, try `rustc --explain E0308`.
@@ -871,7 +864,7 @@ LL | #[ignore()]
 
 Future breakage diagnostic:
 error: valid forms for the attribute are `#[ignore = "reason"]` and `#[ignore]`
-  --> $DIR/malformed-attrs.rs:222:1
+  --> $DIR/malformed-attrs.rs:221:1
    |
 LL | #[ignore = 1]
    | ^^^^^^^^^^^^^
diff --git a/tests/ui/invalid/invalid-debugger-visualizer-option.rs b/tests/ui/invalid/invalid-debugger-visualizer-option.rs
index 0f1cf15a6879a..166962866dce4 100644
--- a/tests/ui/invalid/invalid-debugger-visualizer-option.rs
+++ b/tests/ui/invalid/invalid-debugger-visualizer-option.rs
@@ -1,6 +1,6 @@
 //@ normalize-stderr: "foo.random:.*\(" -> "foo.random: $$FILE_NOT_FOUND_MSG ("
 //@ normalize-stderr: "os error \d+" -> "os error $$FILE_NOT_FOUND_CODE"
 
-#![debugger_visualizer(random_file = "../foo.random")] //~ ERROR invalid argument
+#![debugger_visualizer(random_file = "../foo.random")] //~ ERROR malformed `debugger_visualizer` attribute input
 #![debugger_visualizer(natvis_file = "../foo.random")] //~ ERROR
 fn main() {}
diff --git a/tests/ui/invalid/invalid-debugger-visualizer-option.stderr b/tests/ui/invalid/invalid-debugger-visualizer-option.stderr
index 6fbb4d641e6f6..e877e39d8f119 100644
--- a/tests/ui/invalid/invalid-debugger-visualizer-option.stderr
+++ b/tests/ui/invalid/invalid-debugger-visualizer-option.stderr
@@ -1,18 +1,20 @@
-error: invalid argument
-  --> $DIR/invalid-debugger-visualizer-option.rs:4:24
-   |
-LL | #![debugger_visualizer(random_file = "../foo.random")]
-   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: expected: `natvis_file = "..."`
-   = note: OR
-   = note: expected: `gdb_script_file = "..."`
-
 error: couldn't read $DIR/../foo.random: $FILE_NOT_FOUND_MSG (os error $FILE_NOT_FOUND_CODE)
   --> $DIR/invalid-debugger-visualizer-option.rs:5:24
    |
 LL | #![debugger_visualizer(natvis_file = "../foo.random")]
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+error[E0539]: malformed `debugger_visualizer` attribute input
+  --> $DIR/invalid-debugger-visualizer-option.rs:4:1
+   |
+LL | #![debugger_visualizer(random_file = "../foo.random")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^-----------^^^^^^^^^^^^^^^^^^^^
+   | |                      |
+   | |                      valid arguments are `natvis_file` or `gdb_script_file`
+   | help: must be of the form: `#![debugger_visualizer(natvis_file = "...", gdb_script_file = "...")]`
+   |
+   = note: for more information, visit <https://doc.rust-lang.org/reference/attributes/debugger.html#the-debugger_visualizer-attribute>
+
 error: aborting due to 2 previous errors
 
+For more information about this error, try `rustc --explain E0539`.
diff --git a/tests/ui/invalid/invalid-debugger-visualizer-target.rs b/tests/ui/invalid/invalid-debugger-visualizer-target.rs
index 1efb9555c242a..48b041532140a 100644
--- a/tests/ui/invalid/invalid-debugger-visualizer-target.rs
+++ b/tests/ui/invalid/invalid-debugger-visualizer-target.rs
@@ -1,2 +1,3 @@
-#[debugger_visualizer(natvis_file = "./foo.natvis.xml")] //~ ERROR attribute should be applied to a module
+#[debugger_visualizer(natvis_file = "./foo.natvis.xml")]
+//~^ ERROR `#[debugger_visualizer]` attribute cannot be used on functions
 fn main() {}
diff --git a/tests/ui/invalid/invalid-debugger-visualizer-target.stderr b/tests/ui/invalid/invalid-debugger-visualizer-target.stderr
index 1df3453253372..629af94c5ef22 100644
--- a/tests/ui/invalid/invalid-debugger-visualizer-target.stderr
+++ b/tests/ui/invalid/invalid-debugger-visualizer-target.stderr
@@ -1,8 +1,10 @@
-error: attribute should be applied to a module
+error: `#[debugger_visualizer]` attribute cannot be used on functions
   --> $DIR/invalid-debugger-visualizer-target.rs:1:1
    |
 LL | #[debugger_visualizer(natvis_file = "./foo.natvis.xml")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: `#[debugger_visualizer]` can be applied to modules and crates
 
 error: aborting due to 1 previous error
 

From e1ae7b783781b93ec6a112ce586f75ac8db8c0d4 Mon Sep 17 00:00:00 2001
From: Martin Nordholts <martin.nordholts@codetale.se>
Date: Mon, 22 Sep 2025 07:22:37 +0200
Subject: [PATCH 1247/1889] tests: Check error when struct from wrong crate
 version is used for impl

---
 tests/run-make/duplicate-dependency/foo-v1.rs |  1 +
 tests/run-make/duplicate-dependency/foo-v2.rs |  1 +
 tests/run-make/duplicate-dependency/main.rs   | 15 +++++++
 .../run-make/duplicate-dependency/main.stderr | 18 ++++++++
 .../duplicate-dependency/re-export-foo.rs     |  3 ++
 tests/run-make/duplicate-dependency/rmake.rs  | 43 +++++++++++++++++++
 6 files changed, 81 insertions(+)
 create mode 100644 tests/run-make/duplicate-dependency/foo-v1.rs
 create mode 100644 tests/run-make/duplicate-dependency/foo-v2.rs
 create mode 100644 tests/run-make/duplicate-dependency/main.rs
 create mode 100644 tests/run-make/duplicate-dependency/main.stderr
 create mode 100644 tests/run-make/duplicate-dependency/re-export-foo.rs
 create mode 100644 tests/run-make/duplicate-dependency/rmake.rs

diff --git a/tests/run-make/duplicate-dependency/foo-v1.rs b/tests/run-make/duplicate-dependency/foo-v1.rs
new file mode 100644
index 0000000000000..4a835673a596b
--- /dev/null
+++ b/tests/run-make/duplicate-dependency/foo-v1.rs
@@ -0,0 +1 @@
+pub struct Foo;
diff --git a/tests/run-make/duplicate-dependency/foo-v2.rs b/tests/run-make/duplicate-dependency/foo-v2.rs
new file mode 100644
index 0000000000000..4a835673a596b
--- /dev/null
+++ b/tests/run-make/duplicate-dependency/foo-v2.rs
@@ -0,0 +1 @@
+pub struct Foo;
diff --git a/tests/run-make/duplicate-dependency/main.rs b/tests/run-make/duplicate-dependency/main.rs
new file mode 100644
index 0000000000000..b22d9581c9a40
--- /dev/null
+++ b/tests/run-make/duplicate-dependency/main.rs
@@ -0,0 +1,15 @@
+struct Bar;
+
+impl From<Bar> for foo::Foo {
+    fn from(_: Bar) -> Self {
+        foo::Foo
+    }
+}
+
+fn main() {
+    // The user might wrongly expect this to work since From<Bar> for Foo
+    // implies Into<Foo> for Bar. What the user missed is that different
+    // versions of Foo exist in the dependency graph, and the impl is for the
+    // wrong version.
+    re_export_foo::into_foo(Bar);
+}
diff --git a/tests/run-make/duplicate-dependency/main.stderr b/tests/run-make/duplicate-dependency/main.stderr
new file mode 100644
index 0000000000000..2c912f872fe35
--- /dev/null
+++ b/tests/run-make/duplicate-dependency/main.stderr
@@ -0,0 +1,18 @@
+error[E0277]: the trait bound `re_export_foo::foo::Foo: From<Bar>` is not satisfied
+  --> main.rs:14:29
+   |
+LL |     re_export_foo::into_foo(Bar);
+   |     ----------------------- ^^^ the trait `From<Bar>` is not implemented for `re_export_foo::foo::Foo`
+   |     |
+   |     required by a bound introduced by this call
+   |
+   = note: required for `Bar` to implement `Into<re_export_foo::foo::Foo>`
+note: required by a bound in `into_foo`
+  --> $DIR/re-export-foo.rs:3:25
+   |
+LL | pub fn into_foo(_: impl Into<foo::Foo>) {}
+   |                         ^^^^^^^^^^^^^^ required by this bound in `into_foo`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/run-make/duplicate-dependency/re-export-foo.rs b/tests/run-make/duplicate-dependency/re-export-foo.rs
new file mode 100644
index 0000000000000..b346cfcee9b1f
--- /dev/null
+++ b/tests/run-make/duplicate-dependency/re-export-foo.rs
@@ -0,0 +1,3 @@
+pub use foo;
+
+pub fn into_foo(_: impl Into<foo::Foo>) {}
diff --git a/tests/run-make/duplicate-dependency/rmake.rs b/tests/run-make/duplicate-dependency/rmake.rs
new file mode 100644
index 0000000000000..13ab4caaba56f
--- /dev/null
+++ b/tests/run-make/duplicate-dependency/rmake.rs
@@ -0,0 +1,43 @@
+use run_make_support::{Rustc, cwd, diff, rust_lib_name, rustc};
+
+fn rustc_with_common_args() -> Rustc {
+    let mut rustc = rustc();
+    rustc.remap_path_prefix(cwd(), "$DIR");
+    rustc.edition("2018"); // Don't require `extern crate`
+    rustc
+}
+
+fn main() {
+    rustc_with_common_args()
+        .input("foo-v1.rs")
+        .crate_type("rlib")
+        .crate_name("foo")
+        .extra_filename("-v1")
+        .metadata("-v1")
+        .run();
+
+    rustc_with_common_args()
+        .input("foo-v2.rs")
+        .crate_type("rlib")
+        .crate_name("foo")
+        .extra_filename("-v2")
+        .metadata("-v2")
+        .run();
+
+    rustc_with_common_args()
+        .input("re-export-foo.rs")
+        .crate_type("rlib")
+        .extern_("foo", rust_lib_name("foo-v2"))
+        .run();
+
+    let stderr = rustc_with_common_args()
+        .input("main.rs")
+        .extern_("foo", rust_lib_name("foo-v1"))
+        .extern_("re_export_foo", rust_lib_name("re_export_foo"))
+        .library_search_path(cwd())
+        .ui_testing()
+        .run_fail()
+        .stderr_utf8();
+
+    diff().expected_file("main.stderr").actual_text("(rustc)", &stderr).run();
+}

From dc805bf49844d7bde1013f817c4368c1c3c485aa Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Mon, 22 Sep 2025 14:18:48 +0800
Subject: [PATCH 1248/1889] Fix apply in internal if for pull_assignment_up

Example
---
```rust
fn foo() {
    let mut a = 1;

    if true {
        a = 2;
    } else if true {
        $0a = 3;
    } else {
        a = 4;
    }
}
```

**Before this PR**:

```rust
fn foo() {
    let mut a = 1;

    if true {
        a = 2;
    } else a = if true {
        3
    } else {
        4
    };
}
```

**After this PR**:

```rust
fn foo() {
    let mut a = 1;

    a = if true {
        2
    } else if true {
        3
    } else {
        4
    };
}
```
---
 .../src/handlers/pull_assignment_up.rs        | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/pull_assignment_up.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/pull_assignment_up.rs
index 21debf6745a67..00902fafe8278 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/pull_assignment_up.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/pull_assignment_up.rs
@@ -53,6 +53,10 @@ pub(crate) fn pull_assignment_up(acc: &mut Assists, ctx: &AssistContext<'_>) ->
     };
 
     let tgt: ast::Expr = if let Some(if_expr) = ctx.find_node_at_offset::<ast::IfExpr>() {
+        let if_expr = std::iter::successors(Some(if_expr), |it| {
+            it.syntax().parent().and_then(ast::IfExpr::cast)
+        })
+        .last()?;
         collector.collect_if(&if_expr)?;
         if_expr.into()
     } else if let Some(match_expr) = ctx.find_node_at_offset::<ast::MatchExpr>() {
@@ -237,6 +241,37 @@ fn foo() {
         );
     }
 
+    #[test]
+    fn test_pull_assignment_up_inner_if() {
+        check_assist(
+            pull_assignment_up,
+            r#"
+fn foo() {
+    let mut a = 1;
+
+    if true {
+        a = 2;
+    } else if true {
+        $0a = 3;
+    } else {
+        a = 4;
+    }
+}"#,
+            r#"
+fn foo() {
+    let mut a = 1;
+
+    a = if true {
+        2
+    } else if true {
+        3
+    } else {
+        4
+    };
+}"#,
+        );
+    }
+
     #[test]
     fn test_pull_assignment_up_match() {
         check_assist(

From c5e668274b56a0c83745336352fd9df9fe68e50a Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Mon, 22 Sep 2025 14:45:31 +0800
Subject: [PATCH 1249/1889] Fix applicable on underscore for bind_unused_param

Fixes:
- applicable on underscore prefix parameter
- using binding mode as an expression

Examples
---
```rust
fn foo($0_x: i32, y: i32) {}
```

**Before this PR**:

```rust
fn foo(_x: i32, y: i32) {
    let _ = _x;
}
```

**After this PR**:

Assist not applicable

---

```rust
fn foo(ref $0y: i32) {}
```

**Before this PR**:

```rust
fn foo(ref y: i32) {
    let _ = ref y;
}
```

**After this PR**:

```rust
fn foo(ref y: i32) {
    let _ = y;
}
```
---
 .../src/handlers/bind_unused_param.rs         | 33 +++++++++++++++++--
 1 file changed, 30 insertions(+), 3 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/bind_unused_param.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/bind_unused_param.rs
index 00c7d25b257b2..1b24f7fe7ffba 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/bind_unused_param.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/bind_unused_param.rs
@@ -2,7 +2,7 @@ use crate::assist_context::{AssistContext, Assists};
 use ide_db::{LineIndexDatabase, assists::AssistId, defs::Definition};
 use syntax::{
     AstNode,
-    ast::{self, edit_in_place::Indent},
+    ast::{self, HasName, edit_in_place::Indent},
 };
 
 // Assist: bind_unused_param
@@ -22,6 +22,7 @@ pub(crate) fn bind_unused_param(acc: &mut Assists, ctx: &AssistContext<'_>) -> O
     let param: ast::Param = ctx.find_node_at_offset()?;
 
     let Some(ast::Pat::IdentPat(ident_pat)) = param.pat() else { return None };
+    let name = ident_pat.name().filter(|n| !n.text().starts_with('_'))?;
 
     let param_def = {
         let local = ctx.sema.to_def(&ident_pat)?;
@@ -39,14 +40,14 @@ pub(crate) fn bind_unused_param(acc: &mut Assists, ctx: &AssistContext<'_>) -> O
 
     acc.add(
         AssistId::quick_fix("bind_unused_param"),
-        format!("Bind as `let _ = {ident_pat};`"),
+        format!("Bind as `let _ = {name};`"),
         param.syntax().text_range(),
         |builder| {
             let line_index = ctx.db().line_index(ctx.vfs_file_id());
 
             let indent = func.indent_level();
             let text_indent = indent + 1;
-            let mut text = format!("\n{text_indent}let _ = {ident_pat};");
+            let mut text = format!("\n{text_indent}let _ = {name};");
 
             let left_line = line_index.line_col(l_curly_range.end()).line;
             let right_line = line_index.line_col(r_curly_range.start()).line;
@@ -83,6 +84,22 @@ fn foo(y: i32) {
         );
     }
 
+    #[test]
+    fn bind_unused_ref_ident_pat() {
+        cov_mark::check!(single_line);
+        check_assist(
+            bind_unused_param,
+            r#"
+fn foo(ref $0y: i32) {}
+"#,
+            r#"
+fn foo(ref y: i32) {
+    let _ = y;
+}
+"#,
+        );
+    }
+
     #[test]
     fn bind_unused_empty_block_with_newline() {
         check_assist(
@@ -149,6 +166,16 @@ impl Trait for () {
             bind_unused_param,
             r#"
 fn foo(x: i32, $0y: i32) { y; }
+"#,
+        );
+    }
+
+    #[test]
+    fn keep_underscore_used() {
+        check_assist_not_applicable(
+            bind_unused_param,
+            r#"
+fn foo($0_x: i32, y: i32) {}
 "#,
         );
     }

From 4193716963035cccc26dfde9dbf6a78a133dfb60 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Mon, 22 Sep 2025 10:26:03 +0300
Subject: [PATCH 1250/1889] Another regression test for next solver fixed bug

---
 .../hir-ty/src/tests/regression/new_solver.rs | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
index ead79a8f5b90b..c7711f31bf262 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
@@ -418,3 +418,35 @@ fn foo() {
         "#]],
     );
 }
+
+#[test]
+fn regression_19637() {
+    check_no_mismatches(
+        r#"
+//- minicore: coerce_unsized
+pub trait Any {}
+
+impl<T: 'static> Any for T {}
+
+pub trait Trait: Any {
+    type F;
+}
+
+pub struct TT {}
+
+impl Trait for TT {
+    type F = f32;
+}
+
+pub fn coercion(x: &mut dyn Any) -> &mut dyn Any {
+    x
+}
+
+fn main() {
+    let mut t = TT {};
+    let tt = &mut t as &mut dyn Trait<F = f32>;
+    let st = coercion(tt);
+}
+    "#,
+    );
+}

From 7d0012914ea223ba1f6b7dae1ecd31be95e0051a Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 22 Sep 2025 09:28:38 +0200
Subject: [PATCH 1251/1889] assert_unsafe_precondition: fix some incorrect
 check_language_ub

---
 library/core/src/ascii/ascii_char.rs | 2 +-
 library/core/src/num/int_macros.rs   | 6 +++---
 library/core/src/num/uint_macros.rs  | 4 ++--
 library/core/src/slice/index.rs      | 2 +-
 library/core/src/ub_checks.rs        | 5 +++--
 5 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/library/core/src/ascii/ascii_char.rs b/library/core/src/ascii/ascii_char.rs
index 178af2c0e3b46..d77fafed2039b 100644
--- a/library/core/src/ascii/ascii_char.rs
+++ b/library/core/src/ascii/ascii_char.rs
@@ -515,7 +515,7 @@ impl AsciiChar {
     #[track_caller]
     pub const unsafe fn digit_unchecked(d: u8) -> Self {
         assert_unsafe_precondition!(
-            check_language_ub,
+            check_library_ub,
             "`ascii::Char::digit_unchecked` input cannot exceed 9.",
             (d: u8 = d) => d < 10
         );
diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs
index 64a3dd3e8bc54..0d80c40fb2363 100644
--- a/library/core/src/num/int_macros.rs
+++ b/library/core/src/num/int_macros.rs
@@ -1460,8 +1460,8 @@ macro_rules! int_impl {
         #[inline]
         pub const unsafe fn unchecked_exact_shl(self, rhs: u32) -> $SelfT {
             assert_unsafe_precondition!(
-                check_language_ub,
-                concat!(stringify!($SelfT), "::unchecked_exact_shl cannot shift out non-zero bits"),
+                check_library_ub,
+                concat!(stringify!($SelfT), "::unchecked_exact_shl cannot shift out bits that would change the value of the first bit"),
                 (
                     zeros: u32 = self.leading_zeros(),
                     ones: u32 = self.leading_ones(),
@@ -1638,7 +1638,7 @@ macro_rules! int_impl {
         #[inline]
         pub const unsafe fn unchecked_exact_shr(self, rhs: u32) -> $SelfT {
             assert_unsafe_precondition!(
-                check_language_ub,
+                check_library_ub,
                 concat!(stringify!($SelfT), "::unchecked_exact_shr cannot shift out non-zero bits"),
                 (
                     zeros: u32 = self.trailing_zeros(),
diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs
index bf72ec8319704..d68c7be9865b1 100644
--- a/library/core/src/num/uint_macros.rs
+++ b/library/core/src/num/uint_macros.rs
@@ -1865,7 +1865,7 @@ macro_rules! uint_impl {
         #[inline]
         pub const unsafe fn unchecked_exact_shl(self, rhs: u32) -> $SelfT {
             assert_unsafe_precondition!(
-                check_language_ub,
+                check_library_ub,
                 concat!(stringify!($SelfT), "::exact_shl_unchecked cannot shift out non-zero bits"),
                 (
                     zeros: u32 = self.leading_zeros(),
@@ -2037,7 +2037,7 @@ macro_rules! uint_impl {
         #[inline]
         pub const unsafe fn unchecked_exact_shr(self, rhs: u32) -> $SelfT {
             assert_unsafe_precondition!(
-                check_language_ub,
+                check_library_ub,
                 concat!(stringify!($SelfT), "::exact_shr_unchecked cannot shift out non-zero bits"),
                 (
                     zeros: u32 = self.trailing_zeros(),
diff --git a/library/core/src/slice/index.rs b/library/core/src/slice/index.rs
index a8147d745f3ab..d4c466201edf5 100644
--- a/library/core/src/slice/index.rs
+++ b/library/core/src/slice/index.rs
@@ -233,7 +233,7 @@ unsafe impl<T> const SliceIndex<[T]> for usize {
     #[track_caller]
     unsafe fn get_unchecked(self, slice: *const [T]) -> *const T {
         assert_unsafe_precondition!(
-            check_language_ub,
+            check_language_ub, // okay because of the `assume` below
             "slice::get_unchecked requires that the index is within the slice",
             (this: usize = self, len: usize = slice.len()) => this < len
         );
diff --git a/library/core/src/ub_checks.rs b/library/core/src/ub_checks.rs
index b809294cfcee7..514ff93c9820e 100644
--- a/library/core/src/ub_checks.rs
+++ b/library/core/src/ub_checks.rs
@@ -21,8 +21,9 @@ use crate::intrinsics::{self, const_eval_select};
 /// slow down const-eval/Miri and we'll get the panic message instead of the interpreter's nice
 /// diagnostic, but our ability to detect UB is unchanged.
 /// But if `check_language_ub` is used when the check is actually for library UB, the check is
-/// omitted in const-eval/Miri and thus if we eventually execute language UB which relies on the
-/// library UB, the backtrace Miri reports may be far removed from original cause.
+/// omitted in const-eval/Miri and thus UB might occur undetected. Even if we eventually execute
+/// language UB which relies on the library UB, the backtrace Miri reports may be far removed from
+/// original cause.
 ///
 /// These checks are behind a condition which is evaluated at codegen time, not expansion time like
 /// [`debug_assert`]. This means that a standard library built with optimizations and debug

From e9b2c4f395673399b0445733c7e8d3955e42ff0c Mon Sep 17 00:00:00 2001
From: Petros Angelatos <petrosagg@gmail.com>
Date: Thu, 15 May 2025 15:46:53 +0300
Subject: [PATCH 1252/1889] avoid violating `slice::from_raw_parts` safety
 contract in `Vec::extract_if`

The implementation of the `Vec::extract_if` iterator violates the safety
contract adverized by `slice::from_raw_parts` by always constructing a
mutable slice for the entire length of the vector even though that span
of memory can contain holes from items already drained. The safety
contract of `slice::from_raw_parts` requires that all elements must be
properly initialized.

As an example we can look at the following code:

```rust
let mut v = vec![Box::new(0u64), Box::new(1u64)];
for item in v.extract_if(.., |x| **x == 0) {
    drop(item);
}
```

In the second iteration a `&mut [Box<u64>]` slice of length 2 will be
constructed. The first slot of the slice contains the bitpattern of an
already deallocated box, which is invalid.

This fixes the issue by only creating references to valid items and
using pointer manipulation for the rest. I have also taken the liberty
to remove the big `unsafe` blocks in place of targetted ones with a
SAFETY comment. The approach closely mirrors the implementation of
`Vec::retain_mut`.

Signed-off-by: Petros Angelatos <petrosagg@gmail.com>
---
 library/alloc/src/vec/extract_if.rs | 64 ++++++++++++++++++-----------
 src/tools/miri/tests/pass/vec.rs    | 10 +++++
 2 files changed, 49 insertions(+), 25 deletions(-)

diff --git a/library/alloc/src/vec/extract_if.rs b/library/alloc/src/vec/extract_if.rs
index a456d3d9e602d..cb9e14f554d41 100644
--- a/library/alloc/src/vec/extract_if.rs
+++ b/library/alloc/src/vec/extract_if.rs
@@ -64,27 +64,37 @@ where
     type Item = T;
 
     fn next(&mut self) -> Option<T> {
-        unsafe {
-            while self.idx < self.end {
-                let i = self.idx;
-                let v = slice::from_raw_parts_mut(self.vec.as_mut_ptr(), self.old_len);
-                let drained = (self.pred)(&mut v[i]);
-                // Update the index *after* the predicate is called. If the index
-                // is updated prior and the predicate panics, the element at this
-                // index would be leaked.
-                self.idx += 1;
-                if drained {
-                    self.del += 1;
-                    return Some(ptr::read(&v[i]));
-                } else if self.del > 0 {
-                    let del = self.del;
-                    let src: *const T = &v[i];
-                    let dst: *mut T = &mut v[i - del];
-                    ptr::copy_nonoverlapping(src, dst, 1);
+        while self.idx < self.end {
+            let i = self.idx;
+            // SAFETY:
+            //  We know that `i < self.end` from the if guard and that `self.end <= self.old_len` from
+            //  the validity of `Self`. Therefore `i` points to an element within `vec`.
+            //
+            //  Additionally, the i-th element is valid because each element is visited at most once
+            //  and it is the first time we access vec[i].
+            //
+            //  Note: we can't use `vec.get_unchecked_mut(i)` here since the precondition for that
+            //  function is that i < vec.len(), but we've set vec's length to zero.
+            let cur = unsafe { &mut *self.vec.as_mut_ptr().add(i) };
+            let drained = (self.pred)(cur);
+            // Update the index *after* the predicate is called. If the index
+            // is updated prior and the predicate panics, the element at this
+            // index would be leaked.
+            self.idx += 1;
+            if drained {
+                self.del += 1;
+                // SAFETY: We never touch this element again after returning it.
+                return Some(unsafe { ptr::read(cur) });
+            } else if self.del > 0 {
+                // SAFETY: `self.del` > 0, so the hole slot must not overlap with current element.
+                // We use copy for move, and never touch this element again.
+                unsafe {
+                    let hole_slot = self.vec.as_mut_ptr().add(i - self.del);
+                    ptr::copy_nonoverlapping(cur, hole_slot, 1);
                 }
             }
-            None
         }
+        None
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
@@ -95,14 +105,18 @@ where
 #[stable(feature = "extract_if", since = "1.87.0")]
 impl<T, F, A: Allocator> Drop for ExtractIf<'_, T, F, A> {
     fn drop(&mut self) {
-        unsafe {
-            if self.idx < self.old_len && self.del > 0 {
-                let ptr = self.vec.as_mut_ptr();
-                let src = ptr.add(self.idx);
-                let dst = src.sub(self.del);
-                let tail_len = self.old_len - self.idx;
-                src.copy_to(dst, tail_len);
+        if self.del > 0 {
+            // SAFETY: Trailing unchecked items must be valid since we never touch them.
+            unsafe {
+                ptr::copy(
+                    self.vec.as_ptr().add(self.idx),
+                    self.vec.as_mut_ptr().add(self.idx - self.del),
+                    self.old_len - self.idx,
+                );
             }
+        }
+        // SAFETY: After filling holes, all items are in contiguous memory.
+        unsafe {
             self.vec.set_len(self.old_len - self.del);
         }
     }
diff --git a/src/tools/miri/tests/pass/vec.rs b/src/tools/miri/tests/pass/vec.rs
index 3e526813bb457..8b1b1e143b16d 100644
--- a/src/tools/miri/tests/pass/vec.rs
+++ b/src/tools/miri/tests/pass/vec.rs
@@ -169,6 +169,15 @@ fn miri_issue_2759() {
     input.replace_range(0..0, "0");
 }
 
+/// This was skirting the edge of UB, let's make sure it remains on the sound side.
+/// Context: <https://github.com/rust-lang/rust/pull/141032>.
+fn extract_if() {
+    let mut v = vec![Box::new(0u64), Box::new(1u64)];
+    for item in v.extract_if(.., |x| **x == 0) {
+        drop(item);
+    }
+}
+
 fn main() {
     assert_eq!(vec_reallocate().len(), 5);
 
@@ -199,4 +208,5 @@ fn main() {
     swap_remove();
     reverse();
     miri_issue_2759();
+    extract_if();
 }

From 8d7e637dc947e11fab4294ec032cfc1e252e421d Mon Sep 17 00:00:00 2001
From: sysrex <769991+sysrex@users.noreply.github.com>
Date: Mon, 22 Sep 2025 10:15:50 +0100
Subject: [PATCH 1253/1889] chore: remove dead links

---
 CONTRIBUTING.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 5b52c3dfff61d..2b5699dcd098d 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -47,5 +47,4 @@ refer to [this section][contributing-bug-reports] and [open an issue][issue temp
 [contributing-bug-reports]: https://rustc-dev-guide.rust-lang.org/contributing.html#bug-reports
 [issue template]: https://github.com/rust-lang/rust/issues/new/choose
 [internals]: https://internals.rust-lang.org
-[rust-discord]: http://discord.gg/rust-lang
 [rust-zulip]: https://rust-lang.zulipchat.com

From e37f0fed052701f38c9b61541f565b834106ad32 Mon Sep 17 00:00:00 2001
From: Iris Shi <0.0@owo.li>
Date: Mon, 22 Sep 2025 17:32:50 +0800
Subject: [PATCH 1254/1889] Add regression test

---
 .../rustdoc-merge-no-input-finalize/rmake.rs  | 22 +++++++++++++++++++
 .../rustdoc-merge-no-input-finalize/sierra.rs |  1 +
 2 files changed, 23 insertions(+)
 create mode 100644 tests/run-make/rustdoc-merge-no-input-finalize/rmake.rs
 create mode 100644 tests/run-make/rustdoc-merge-no-input-finalize/sierra.rs

diff --git a/tests/run-make/rustdoc-merge-no-input-finalize/rmake.rs b/tests/run-make/rustdoc-merge-no-input-finalize/rmake.rs
new file mode 100644
index 0000000000000..6df9e95829d8d
--- /dev/null
+++ b/tests/run-make/rustdoc-merge-no-input-finalize/rmake.rs
@@ -0,0 +1,22 @@
+// Running --merge=finalize without an input crate root should not trigger ICE.
+// Issue: https://github.com/rust-lang/rust/issues/146646
+
+//@ needs-target-std
+
+use run_make_support::rustdoc;
+
+fn main() {
+    rustdoc()
+        .input("sierra.rs")
+        .arg("-Zunstable-options")
+        .arg("--parts-out-dir=parts")
+        .arg("--merge=none")
+        .run();
+
+    rustdoc()
+        .arg("-Zunstable-options")
+        .arg("--include-parts-dir=parts")
+        .arg("--merge=finalize")
+        .out_dir("out")
+        .run();
+}
diff --git a/tests/run-make/rustdoc-merge-no-input-finalize/sierra.rs b/tests/run-make/rustdoc-merge-no-input-finalize/sierra.rs
new file mode 100644
index 0000000000000..f8fc48341ed6b
--- /dev/null
+++ b/tests/run-make/rustdoc-merge-no-input-finalize/sierra.rs
@@ -0,0 +1 @@
+pub struct Sierra;

From 1c316023d65be6ae88ff938d272669bc286fd5b3 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 19 Sep 2025 12:24:22 +0200
Subject: [PATCH 1255/1889] =?UTF-8?q?TB:=20rename=20Active=20=E2=86=92=20U?=
 =?UTF-8?q?nique=20to=20match=20paper?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../tree_borrows/diagnostics.rs               |   4 +-
 .../src/borrow_tracker/tree_borrows/perms.rs  | 102 +++++++++---------
 .../src/borrow_tracker/tree_borrows/tree.rs   |  18 ++--
 .../borrow_tracker/tree_borrows/tree/tests.rs |   4 +-
 .../fail/async-shared-mutable.tree.stderr     |   2 +-
 .../box_noalias_violation.tree.stderr         |   4 +-
 .../both_borrows/illegal_write6.tree.stderr   |   4 +-
 .../arg_inplace_locals_alias.tree.stderr      |   4 +-
 .../arg_inplace_locals_alias_ret.tree.stderr  |   4 +-
 .../arg_inplace_mutate.tree.stderr            |   4 +-
 .../arg_inplace_observe_during.tree.stderr    |   4 +-
 .../return_pointer_aliasing_read.tree.stderr  |   4 +-
 .../return_pointer_aliasing_write.tree.stderr |   4 +-
 ...inter_aliasing_write_tail_call.tree.stderr |   4 +-
 .../tree_borrows/alternate-read-write.stderr  |   2 +-
 .../tree_borrows/fnentry_invalidation.stderr  |   2 +-
 .../parent_read_freezes_raw_mut.stderr        |   2 +-
 .../fail/tree_borrows/pass_invalid_mut.stderr |   2 +-
 .../tree_borrows/reservedim_spurious_write.rs |   3 +-
 .../tree_borrows/return_invalid_mut.stderr    |   2 +-
 .../subtree_traversal_skipping_diagnostics.rs |   2 +-
 .../fail/tree_borrows/unique.default.stderr   |  32 ------
 .../pass/tree_borrows/cell-inside-box.rs      |   2 +-
 .../pass/tree_borrows/reborrow-is-read.rs     |   4 +-
 .../miri/tests/pass/tree_borrows/reserved.rs  |   4 +-
 25 files changed, 95 insertions(+), 128 deletions(-)
 delete mode 100644 src/tools/miri/tests/fail/tree_borrows/unique.default.stderr

diff --git a/src/tools/miri/src/borrow_tracker/tree_borrows/diagnostics.rs b/src/tools/miri/src/borrow_tracker/tree_borrows/diagnostics.rs
index 7b4c533cfaed7..a7977cd3366f9 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/diagnostics.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/diagnostics.rs
@@ -244,8 +244,8 @@ pub(super) enum TransitionError {
     ChildAccessForbidden(Permission),
     /// A protector was triggered due to an invalid transition that loses
     /// too much permissions.
-    /// For example, if a protected tag goes from `Active` to `Disabled` due
-    /// to a foreign write this will produce a `ProtectedDisabled(Active)`.
+    /// For example, if a protected tag goes from `Unique` to `Disabled` due
+    /// to a foreign write this will produce a `ProtectedDisabled(Unique)`.
     /// This kind of error can only occur on foreign accesses.
     ProtectedDisabled(Permission),
     /// Cannot deallocate because some tag in the allocation is strongly protected.
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 390435e58d173..e21775c9f239f 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/perms.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/perms.rs
@@ -14,7 +14,7 @@ enum PermissionPriv {
     Cell,
     /// represents: a local mutable reference that has not yet been written to;
     /// allows: child reads, foreign reads;
-    /// affected by: child writes (becomes Active),
+    /// affected by: child writes (becomes Unique),
     /// rejects: foreign writes (Disabled).
     ///
     /// `ReservedFrz` is mostly for types that are `Freeze` (no interior mutability).
@@ -31,17 +31,17 @@ enum PermissionPriv {
     /// This is so that the behavior of `Reserved` adheres to the rules of `noalias`:
     /// - 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.
+    ///   foreign-read disables a protected `Unique`, which is UB.
     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);
+    /// affected by: child writes (becomes Unique);
     /// rejects: nothing.
     ReservedIM,
     /// represents: a unique pointer;
     /// allows: child reads, child writes;
     /// rejects: foreign reads (Frozen), foreign writes (Disabled).
-    Active,
+    Unique,
     /// represents: a shared pointer;
     /// allows: all read accesses;
     /// rejects child writes (UB), foreign writes (Disabled).
@@ -56,7 +56,7 @@ use super::foreign_access_skipping::IdempotentForeignAccess;
 
 impl PartialOrd for PermissionPriv {
     /// PermissionPriv is ordered by the reflexive transitive closure of
-    /// `Reserved(conflicted=false) < Reserved(conflicted=true) < Active < Frozen < Disabled`.
+    /// `Reserved(conflicted=false) < Reserved(conflicted=true) < Unique < Frozen < Disabled`.
     /// `Reserved` that have incompatible `ty_is_freeze` are incomparable to each other.
     /// This ordering matches the reachability by transitions, as asserted by the exhaustive test
     /// `permissionpriv_partialord_is_reachability`.
@@ -76,8 +76,8 @@ impl PartialOrd for PermissionPriv {
             (_, Disabled) => Less,
             (Frozen, _) => Greater,
             (_, Frozen) => Less,
-            (Active, _) => Greater,
-            (_, Active) => Less,
+            (Unique, _) => Greater,
+            (_, Unique) => Less,
             (ReservedIM, ReservedIM) => Equal,
             (ReservedFrz { conflicted: c1 }, ReservedFrz { conflicted: c2 }) => {
                 // `bool` is ordered such that `false <= true`, so this works as intended.
@@ -115,8 +115,8 @@ impl PermissionPriv {
             // Famously, ReservedIM survives foreign writes. It is never protected.
             ReservedIM if prot => unreachable!("Protected ReservedIM should not exist!"),
             ReservedIM => IdempotentForeignAccess::Write,
-            // Active changes on any foreign access (becomes Frozen/Disabled).
-            Active => IdempotentForeignAccess::None,
+            // Unique changes on any foreign access (becomes Frozen/Disabled).
+            Unique => IdempotentForeignAccess::None,
             // Frozen survives foreign reads, but not writes.
             Frozen => IdempotentForeignAccess::Read,
             // Disabled survives foreign reads and writes. It survives them
@@ -139,12 +139,12 @@ 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 @ (Cell | ReservedFrz { .. } | ReservedIM | Active | Frozen) => readable,
+            readable @ (Cell | ReservedFrz { .. } | ReservedIM | Unique | Frozen) => readable,
         })
     }
 
     /// A non-child node was read-accessed: keep `Reserved` but mark it as `conflicted` if it
-    /// is protected; invalidate `Active`.
+    /// is protected; invalidate `Unique`.
     fn foreign_read(state: PermissionPriv, protected: bool) -> Option<PermissionPriv> {
         Some(match state {
             // Cell ignores foreign reads.
@@ -167,10 +167,10 @@ mod transition {
                 assert!(!protected);
                 res
             }
-            Active =>
+            Unique =>
                 if protected {
                     // We wrote, someone else reads -- that's bad.
-                    // (Since Active is always initialized, this move-to-protected will mean insta-UB.)
+                    // (Since Unique is always initialized, this move-to-protected will mean insta-UB.)
                     Disabled
                 } else {
                     // We don't want to disable here to allow read-read reordering: it is crucial
@@ -180,7 +180,7 @@ mod transition {
         })
     }
 
-    /// A child node was write-accessed: `Reserved` must become `Active` to obtain
+    /// A child node was write-accessed: `Reserved` must become `Unique` to obtain
     /// write permissions, `Frozen` and `Disabled` cannot obtain such permissions and produce UB.
     fn child_write(state: PermissionPriv, protected: bool) -> Option<PermissionPriv> {
         Some(match state {
@@ -192,7 +192,7 @@ mod transition {
             ReservedFrz { conflicted: true } if protected => return None,
             // A write always activates the 2-phase borrow, even with interior
             // mutability
-            ReservedFrz { .. } | ReservedIM | Active => Active,
+            ReservedFrz { .. } | ReservedIM | Unique => Unique,
             Frozen | Disabled => return None,
         })
     }
@@ -266,8 +266,8 @@ impl Permission {
 
     /// Default initial permission of the root of a new tree at inbounds positions.
     /// Must *only* be used for the root, this is not in general an "initial" permission!
-    pub fn new_active() -> Self {
-        Self { inner: Active }
+    pub fn new_unique() -> Self {
+        Self { inner: Unique }
     }
 
     /// Default initial permission of a reborrowed mutable reference that is either
@@ -309,7 +309,7 @@ impl Permission {
             // Do not do perform access if it is a `Cell`, as this
             // can cause data races when using thread-safe data types.
             Cell => None,
-            Active => Some(AccessKind::Write),
+            Unique => Some(AccessKind::Write),
             _ => Some(AccessKind::Read),
         }
     }
@@ -344,7 +344,7 @@ impl Permission {
             (_, Cell) => false,
             // ReservedIM can be replaced by anything besides Cell.
             // ReservedIM allows all transitions, but unlike Cell, a local write
-            // to ReservedIM transitions to Active, while it is a no-op for Cell.
+            // to ReservedIM transitions to Unique, while it is a no-op for Cell.
             (ReservedIM, _) => true,
             (_, ReservedIM) => false,
             // Reserved (as parent, where conflictedness does not matter)
@@ -352,12 +352,12 @@ impl Permission {
             // since ReservedIM and Cell alone would survive foreign writes
             (ReservedFrz { .. }, _) => true,
             (_, ReservedFrz { .. }) => false,
-            // Active can not be replaced by something surviving
+            // Unique can not be replaced by something surviving
             // foreign reads and then remaining writable (i.e., Reserved*).
             // Replacing a state by itself is always okay, even if the child state is protected.
-            // Active can be replaced by Frozen, since it is not protected.
-            (Active, Active | Frozen | Disabled) => true,
-            (_, Active) => false,
+            // Unique can be replaced by Frozen, since it is not protected.
+            (Unique, Unique | Frozen | Disabled) => true,
+            (_, Unique) => false,
             // Frozen can only be replaced by Disabled (and itself).
             (Frozen, Frozen | Disabled) => true,
             (_, Frozen) => false,
@@ -410,7 +410,7 @@ pub mod diagnostics {
                     ReservedFrz { conflicted: false } => "Reserved",
                     ReservedFrz { conflicted: true } => "Reserved (conflicted)",
                     ReservedIM => "Reserved (interior mutable)",
-                    Active => "Active",
+                    Unique => "Unique",
                     Frozen => "Frozen",
                     Disabled => "Disabled",
                 }
@@ -441,7 +441,7 @@ pub mod diagnostics {
                 ReservedFrz { conflicted: false } => "Res ",
                 ReservedFrz { conflicted: true } => "ResC",
                 ReservedIM => "ReIM",
-                Active => "Act ",
+                Unique => "Act ",
                 Frozen => "Frz ",
                 Disabled => "Dis ",
             }
@@ -455,7 +455,7 @@ pub mod diagnostics {
             assert!(self.is_possible());
             assert!(!self.is_noop());
             match (self.from, self.to) {
-                (_, Active) => "the first write to a 2-phase borrowed mutable reference",
+                (_, Unique) => "the first write to a 2-phase borrowed mutable reference",
                 (_, Frozen) => "a loss of write permissions",
                 (ReservedFrz { conflicted: false }, ReservedFrz { conflicted: true }) =>
                     "a temporary loss of write permissions until function exit",
@@ -472,8 +472,8 @@ pub mod diagnostics {
         ///
         /// Irrelevant events:
         /// - modifications of write permissions when the error is related to read permissions
-        ///   (on failed reads and protected `Frozen -> Disabled`, ignore `Reserved -> Active`,
-        ///   `Reserved(conflicted=false) -> Reserved(conflicted=true)`, and `Active -> Frozen`)
+        ///   (on failed reads and protected `Frozen -> Disabled`, ignore `Reserved -> Unique`,
+        ///   `Reserved(conflicted=false) -> Reserved(conflicted=true)`, and `Unique -> Frozen`)
         /// - all transitions for attempts to deallocate strongly protected tags
         ///
         /// # Panics
@@ -481,10 +481,10 @@ pub mod diagnostics {
         /// This function assumes that its arguments apply to the same location
         /// and that they were obtained during a normal execution. It will panic otherwise.
         /// - all transitions involved in `self` and `err` should be increasing
-        ///   (Reserved < Active < Frozen < Disabled);
+        ///   (Reserved < Unique < Frozen < Disabled);
         /// - between `self` and `err` the permission should also be increasing,
         ///   so all permissions inside `err` should be greater than `self.1`;
-        /// - `Active`, `Reserved(conflicted=false)`, and `Cell` cannot cause an error
+        /// - `Unique`, `Reserved(conflicted=false)`, and `Cell` cannot cause an error
         ///   due to insufficient permissions, so `err` cannot be a `ChildAccessForbidden(_)`
         ///   of either of them;
         /// - `err` should not be `ProtectedDisabled(Disabled)`, because the protected
@@ -500,11 +500,11 @@ pub mod diagnostics {
                 TransitionError::ChildAccessForbidden(insufficient) => {
                     // Show where the permission was gained then lost,
                     // but ignore unrelated permissions.
-                    // This eliminates transitions like `Active -> Frozen`
+                    // This eliminates transitions like `Unique -> Frozen`
                     // when the error is a failed `Read`.
                     match (self.to, insufficient.inner) {
                         (Frozen, Frozen) => true,
-                        (Active, Frozen) => true,
+                        (Unique, Frozen) => true,
                         (Disabled, Disabled) => true,
                         (
                             ReservedFrz { conflicted: true, .. },
@@ -512,14 +512,14 @@ pub mod diagnostics {
                         ) => 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
+                        // then where it became `Frozen` (or `Unique` or `Reserved`) is the least
                         // of our concerns for now.
-                        (ReservedFrz { conflicted: true } | Active | Frozen, Disabled) => false,
+                        (ReservedFrz { conflicted: true } | Unique | Frozen, Disabled) => false,
                         (ReservedFrz { conflicted: true }, Frozen) => false,
 
-                        // `Active`, `Reserved`, and `Cell` have all permissions, so a
-                        // `ChildAccessForbidden(Reserved | Active)` can never exist.
-                        (_, Active) | (_, ReservedFrz { conflicted: false }) | (_, Cell) =>
+                        // `Unique`, `Reserved`, and `Cell` have all permissions, so a
+                        // `ChildAccessForbidden(Reserved | Unique)` can never exist.
+                        (_, Unique) | (_, ReservedFrz { conflicted: false }) | (_, Cell) =>
                             unreachable!("this permission cannot cause an error"),
                         // No transition has `Reserved { conflicted: false }` or `ReservedIM`
                         // as its `.to` unless it's a noop. `Cell` cannot be in its `.to`
@@ -527,11 +527,11 @@ pub mod diagnostics {
                         (ReservedFrz { conflicted: false } | ReservedIM | Cell, _) =>
                             unreachable!("self is a noop transition"),
                         // All transitions produced in normal executions (using `apply_access`)
-                        // change permissions in the order `Reserved -> Active -> Frozen -> Disabled`.
+                        // change permissions in the order `Reserved -> Unique -> 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, ReservedFrz { .. } | ReservedIM)
+                        (Unique | Frozen | Disabled, ReservedFrz { .. } | ReservedIM)
                         | (Disabled, Frozen)
                         | (ReservedFrz { .. }, ReservedIM) =>
                             unreachable!("permissions between self and err must be increasing"),
@@ -540,29 +540,29 @@ pub mod diagnostics {
                 TransitionError::ProtectedDisabled(before_disabled) => {
                     // Show how we got to the starting point of the forbidden transition,
                     // but ignore what came before.
-                    // This eliminates transitions like `Reserved -> Active`
+                    // This eliminates transitions like `Reserved -> Unique`
                     // when the error is a `Frozen -> Disabled`.
                     match (self.to, before_disabled.inner) {
                         // We absolutely want to know where it was activated/frozen/marked
                         // conflicted.
-                        (Active, Active) => true,
+                        (Unique, Unique) => true,
                         (Frozen, Frozen) => 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
+                        // care whether before that was `Reserved -> Unique -> Frozen` or
                         // `Frozen` directly.
                         // The error will only show either
                         // - created as Reserved { conflicted: false },
                         //   then Reserved { .. } -> Disabled is forbidden
                         // - created as Reserved { conflicted: false },
-                        //   then Active -> Disabled is forbidden
+                        //   then Unique -> Disabled is forbidden
                         // A potential `Reserved { conflicted: false }
                         //   -> Reserved { conflicted: true }` is inexistant or irrelevant,
-                        // and so is the `Reserved { conflicted: false } -> Active`
-                        (Active, Frozen) => false,
+                        // and so is the `Reserved { conflicted: false } -> Unique`
+                        (Unique, Frozen) => false,
                         (ReservedFrz { conflicted: true }, _) => false,
 
                         (_, Disabled) =>
@@ -575,12 +575,12 @@ pub mod diagnostics {
                         (ReservedFrz { conflicted: false } | ReservedIM | Cell, _) =>
                             unreachable!("self is a noop transition"),
 
-                        // Permissions only evolve in the order `Reserved -> Active -> Frozen -> Disabled`,
+                        // Permissions only evolve in the order `Reserved -> Unique -> Frozen -> Disabled`,
                         // so permissions found must be increasing in the order
                         // `self.from < self.to <= forbidden.from < forbidden.to`.
-                        (Disabled, Cell | ReservedFrz { .. } | ReservedIM | Active | Frozen)
-                        | (Frozen, Cell | ReservedFrz { .. } | ReservedIM | Active)
-                        | (Active, Cell | ReservedFrz { .. } | ReservedIM) =>
+                        (Disabled, Cell | ReservedFrz { .. } | ReservedIM | Unique | Frozen)
+                        | (Frozen, Cell | ReservedFrz { .. } | ReservedIM | Unique)
+                        | (Unique, Cell | ReservedFrz { .. } | ReservedIM) =>
                             unreachable!("permissions between self and err must be increasing"),
                     }
                 }
@@ -617,7 +617,7 @@ mod propagation_optimization_checks {
     impl Exhaustive for PermissionPriv {
         fn exhaustive() -> Box<dyn Iterator<Item = Self>> {
             Box::new(
-                vec![Active, Frozen, Disabled, ReservedIM, Cell]
+                vec![Unique, Frozen, Disabled, ReservedIM, Cell]
                     .into_iter()
                     .chain(<bool>::exhaustive().map(|conflicted| ReservedFrz { conflicted })),
             )
@@ -730,7 +730,7 @@ mod propagation_optimization_checks {
 
     #[test]
     // Check that all transitions are consistent with the order on PermissionPriv,
-    // i.e. Reserved -> Active -> Frozen -> Disabled
+    // i.e. Reserved -> Unique -> Frozen -> Disabled
     fn permissionpriv_partialord_is_reachability() {
         let reach = {
             let mut reach = rustc_data_structures::fx::FxHashSet::default();
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 22bd63bd6b6f4..9e7d272ee4b00 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/tree.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/tree.rs
@@ -57,7 +57,7 @@ pub(super) struct LocationState {
 impl LocationState {
     /// Constructs a new initial state. It has neither been accessed, nor been subjected
     /// to any foreign access yet.
-    /// The permission is not allowed to be `Active`.
+    /// The permission is not allowed to be `Unique`.
     /// `sifa` is the (strongest) idempotent foreign access, see `foreign_access_skipping.rs`
     pub fn new_non_accessed(permission: Permission, sifa: IdempotentForeignAccess) -> Self {
         assert!(permission.is_initial() || permission.is_disabled());
@@ -80,7 +80,7 @@ impl LocationState {
     /// Check if the state can exist as the initial permission of a pointer.
     ///
     /// Do not confuse with `is_accessed`, the two are almost orthogonal
-    /// as apart from `Active` which is not initial and must be accessed,
+    /// as apart from `Unique` which is not initial and must be accessed,
     /// any other permission can have an arbitrary combination of being
     /// initial/accessed.
     /// FIXME: when the corresponding `assert` in `tree_borrows/mod.rs` finally
@@ -170,7 +170,7 @@ impl LocationState {
             }
             if self.permission.is_frozen() && access_kind == AccessKind::Read {
                 // A foreign read to a `Frozen` tag will have almost no observable effect.
-                // It's a theorem that `Frozen` nodes have no active children, so all children
+                // It's a theorem that `Frozen` nodes have no `Unique` children, so all children
                 // already survive foreign reads. Foreign reads in general have almost no
                 // effect, the only further thing they could do is make protected `Reserved`
                 // nodes become conflicted, i.e. make them reject child writes for the further
@@ -265,7 +265,7 @@ pub(super) struct Node {
     pub children: SmallVec<[UniIndex; 4]>,
     /// Either `Reserved`,  `Frozen`, or `Disabled`, it is the permission this tag will
     /// lazily be initialized to on the first access.
-    /// It is only ever `Disabled` for a tree root, since the root is initialized to `Active` by
+    /// It is only ever `Disabled` for a tree root, since the root is initialized to `Unique` by
     /// its own separate mechanism.
     default_initial_perm: Permission,
     /// The default initial (strongest) idempotent foreign access.
@@ -598,14 +598,14 @@ impl Tree {
         };
         let rperms = {
             let mut perms = UniValMap::default();
-            // We manually set it to `Active` on all in-bounds positions.
-            // We also ensure that it is accessed, so that no `Active` but
+            // We manually set it to `Unique` on all in-bounds positions.
+            // We also ensure that it is accessed, so that no `Unique` but
             // not yet accessed nodes exist. Essentially, we pretend there
-            // was a write that initialized these to `Active`.
+            // was a write that initialized these to `Unique`.
             perms.insert(
                 root_idx,
                 LocationState::new_accessed(
-                    Permission::new_active(),
+                    Permission::new_unique(),
                     IdempotentForeignAccess::None,
                 ),
             );
@@ -790,7 +790,7 @@ impl<'tcx> Tree {
     /// - the access will be applied only to accessed locations of the allocation,
     /// - it will not be visible to children,
     /// - it will be recorded as a `FnExit` diagnostic access
-    /// - and it will be a read except if the location is `Active`, i.e. has been written to,
+    /// - and it will be a read except if the location is `Unique`, i.e. has been written to,
     ///   in which case it will be a write.
     ///
     /// `LocationState::perform_access` will take care of raising transition
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 d9b3696e4f805..83232615616e6 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
@@ -420,7 +420,7 @@ mod spurious_read {
     /// `(LocStateProt, LocStateProt)` where the two states are not guaranteed
     /// to be updated at the same time.
     /// Some `LocStateProtPair` may be unreachable through normal means
-    /// such as `x: Active, y: Active` in the case of mutually foreign pointers.
+    /// such as `x: Unique, y: Unique` in the case of mutually foreign pointers.
     struct LocStateProtPair {
         xy_rel: RelPosXY,
         x: LocStateProt,
@@ -709,7 +709,7 @@ mod spurious_read {
         let mut err = 0;
         for pat in Pattern::exhaustive() {
             let Ok(initial_source) = pat.initial_state() else {
-                // Failed to retag `x` in the source (e.g. `y` was protected Active)
+                // Failed to retag `x` in the source (e.g. `y` was protected Unique)
                 continue;
             };
             // `x` must stay protected, but the function protecting `y` might return here
diff --git a/src/tools/miri/tests/fail/async-shared-mutable.tree.stderr b/src/tools/miri/tests/fail/async-shared-mutable.tree.stderr
index 449a29088a01d..dc8b4f6665a03 100644
--- a/src/tools/miri/tests/fail/async-shared-mutable.tree.stderr
+++ b/src/tools/miri/tests/fail/async-shared-mutable.tree.stderr
@@ -16,7 +16,7 @@ LL | |             Poll::<()>::Pending
 LL | |         })
 LL | |         .await
    | |______________^
-help: the accessed tag <TAG> later transitioned to Active due to a child write access at offsets [OFFSET]
+help: the accessed tag <TAG> later transitioned to Unique due to a child write access at offsets [OFFSET]
   --> tests/fail/async-shared-mutable.rs:LL:CC
    |
 LL |             *x = 1;
diff --git a/src/tools/miri/tests/fail/both_borrows/box_noalias_violation.tree.stderr b/src/tools/miri/tests/fail/both_borrows/box_noalias_violation.tree.stderr
index 3c8ec7f7d3e4a..6a1f7761a4108 100644
--- a/src/tools/miri/tests/fail/both_borrows/box_noalias_violation.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/box_noalias_violation.tree.stderr
@@ -7,7 +7,7 @@ LL |     *y
    = 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: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/tree-borrows.md for further information
    = help: the accessed tag <TAG> is foreign to the protected tag <TAG> (i.e., it is not a child)
-   = help: this foreign read access would cause the protected tag <TAG> (currently Active) to become Disabled
+   = help: this foreign read access would cause the protected tag <TAG> (currently Unique) to become Disabled
    = help: protected tags must never be Disabled
 help: the accessed tag <TAG> was created here
   --> tests/fail/both_borrows/box_noalias_violation.rs:LL:CC
@@ -19,7 +19,7 @@ help: the protected tag <TAG> was created here, in the initial state Reserved
    |
 LL | unsafe fn test(mut x: Box<i32>, y: *const i32) -> i32 {
    |                ^^^^^
-help: the protected tag <TAG> later transitioned to Active due to a child write access at offsets [0x0..0x4]
+help: the protected tag <TAG> later transitioned to Unique due to a child write access at offsets [0x0..0x4]
   --> tests/fail/both_borrows/box_noalias_violation.rs:LL:CC
    |
 LL |     *x = 5;
diff --git a/src/tools/miri/tests/fail/both_borrows/illegal_write6.tree.stderr b/src/tools/miri/tests/fail/both_borrows/illegal_write6.tree.stderr
index 6780e52c3baf3..1547a6ca73a04 100644
--- a/src/tools/miri/tests/fail/both_borrows/illegal_write6.tree.stderr
+++ b/src/tools/miri/tests/fail/both_borrows/illegal_write6.tree.stderr
@@ -7,7 +7,7 @@ LL |     unsafe { *y = 2 };
    = 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: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/tree-borrows.md for further information
    = help: the accessed tag <TAG> 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: this foreign write access would cause the protected tag <TAG> (currently Unique) to become Disabled
    = help: protected tags must never be Disabled
 help: the accessed tag <TAG> was created here
   --> tests/fail/both_borrows/illegal_write6.rs:LL:CC
@@ -19,7 +19,7 @@ help: the protected tag <TAG> was created here, in the initial state Reserved
    |
 LL | fn foo(a: &mut u32, y: *mut u32) -> u32 {
    |        ^
-help: the protected tag <TAG> later transitioned to Active due to a child write access at offsets [0x0..0x4]
+help: the protected tag <TAG> later transitioned to Unique due to a child write access at offsets [0x0..0x4]
   --> tests/fail/both_borrows/illegal_write6.rs:LL:CC
    |
 LL |     *a = 1;
diff --git a/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias.tree.stderr b/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias.tree.stderr
index 2266a9c39f91d..2d9ce2aa1fb62 100644
--- a/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias.tree.stderr
+++ b/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias.tree.stderr
@@ -7,7 +7,7 @@ LL |             Call(_unit = callee(Move(non_copy), Move(non_copy)), ReturnTo(a
    = 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: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/tree-borrows.md for further information
    = 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 read access would cause the protected tag <TAG> (currently Active) to become Disabled
+   = help: this foreign read access would cause the protected tag <TAG> (currently Unique) to become Disabled
    = help: protected tags must never be Disabled
 help: the accessed tag <TAG> was created here
   --> tests/fail/function_calls/arg_inplace_locals_alias.rs:LL:CC
@@ -19,7 +19,7 @@ help: the protected tag <TAG> was created here, in the initial state Reserved
    |
 LL |     y.0 = 0;
    |     ^^^^^^^
-help: the protected tag <TAG> later transitioned to Active due to a child write access at offsets [0x0..0x4]
+help: the protected tag <TAG> later transitioned to Unique due to a child write access at offsets [0x0..0x4]
   --> tests/fail/function_calls/arg_inplace_locals_alias.rs:LL:CC
    |
 LL |     y.0 = 0;
diff --git a/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias_ret.tree.stderr b/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias_ret.tree.stderr
index b7f514de0af98..42e391b5daf0e 100644
--- a/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias_ret.tree.stderr
+++ b/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias_ret.tree.stderr
@@ -7,7 +7,7 @@ LL |             Call(_non_copy = callee(Move(_non_copy)), ReturnTo(after_call),
    = 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: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/tree-borrows.md for further information
    = 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 reborrow (acting as a foreign read access) would cause the protected tag <TAG> (currently Active) to become Disabled
+   = help: this reborrow (acting as a foreign read access) would cause the protected tag <TAG> (currently Unique) to become Disabled
    = help: protected tags must never be Disabled
 help: the accessed tag <TAG> was created here
   --> tests/fail/function_calls/arg_inplace_locals_alias_ret.rs:LL:CC
@@ -19,7 +19,7 @@ help: the protected tag <TAG> was created here, in the initial state Reserved
    |
 LL |     x
    |     ^
-help: the protected tag <TAG> later transitioned to Active due to a child write access at offsets [0x0..0x4]
+help: the protected tag <TAG> later transitioned to Unique due to a child write access at offsets [0x0..0x4]
   --> tests/fail/function_calls/arg_inplace_locals_alias_ret.rs:LL:CC
    |
 LL |     x
diff --git a/src/tools/miri/tests/fail/function_calls/arg_inplace_mutate.tree.stderr b/src/tools/miri/tests/fail/function_calls/arg_inplace_mutate.tree.stderr
index 1995528e9f9df..74706d6b9f6bc 100644
--- a/src/tools/miri/tests/fail/function_calls/arg_inplace_mutate.tree.stderr
+++ b/src/tools/miri/tests/fail/function_calls/arg_inplace_mutate.tree.stderr
@@ -7,7 +7,7 @@ LL |     unsafe { ptr.write(S(0)) };
    = 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: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/tree-borrows.md for further information
    = 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: this foreign write access would cause the protected tag <TAG> (currently Unique) to become Disabled
    = help: protected tags must never be Disabled
 help: the accessed tag <TAG> was created here
   --> tests/fail/function_calls/arg_inplace_mutate.rs:LL:CC
@@ -24,7 +24,7 @@ help: the protected tag <TAG> was created here, in the initial state Reserved
    |
 LL |     unsafe { ptr.write(S(0)) };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: the protected tag <TAG> later transitioned to Active due to a child write access at offsets [0x0..0x4]
+help: the protected tag <TAG> later transitioned to Unique due to a child write access at offsets [0x0..0x4]
   --> tests/fail/function_calls/arg_inplace_mutate.rs:LL:CC
    |
 LL |     unsafe { ptr.write(S(0)) };
diff --git a/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.tree.stderr b/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.tree.stderr
index e506a61c6bb3b..c8c0e5c37efed 100644
--- a/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.tree.stderr
+++ b/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.tree.stderr
@@ -7,7 +7,7 @@ LL |     unsafe { ptr.read() };
    = 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: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/tree-borrows.md for further information
    = 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 read access would cause the protected tag <TAG> (currently Active) to become Disabled
+   = help: this foreign read access would cause the protected tag <TAG> (currently Unique) to become Disabled
    = help: protected tags must never be Disabled
 help: the accessed tag <TAG> was created here
   --> tests/fail/function_calls/arg_inplace_observe_during.rs:LL:CC
@@ -24,7 +24,7 @@ help: the protected tag <TAG> was created here, in the initial state Reserved
    |
 LL |     x.0 = 0;
    |     ^^^^^^^
-help: the protected tag <TAG> later transitioned to Active due to a child write access at offsets [0x0..0x4]
+help: the protected tag <TAG> later transitioned to Unique due to a child write access at offsets [0x0..0x4]
   --> tests/fail/function_calls/arg_inplace_observe_during.rs:LL:CC
    |
 LL |     x.0 = 0;
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.tree.stderr b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.tree.stderr
index b1aa2ba28860c..b43e19c3905c0 100644
--- a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.tree.stderr
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.tree.stderr
@@ -7,7 +7,7 @@ LL |     unsafe { ptr.read() };
    = 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: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/tree-borrows.md for further information
    = 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 read access would cause the protected tag <TAG> (currently Active) to become Disabled
+   = help: this foreign read access would cause the protected tag <TAG> (currently Unique) to become Disabled
    = help: protected tags must never be Disabled
 help: the accessed tag <TAG> was created here
   --> tests/fail/function_calls/return_pointer_aliasing_read.rs:LL:CC
@@ -24,7 +24,7 @@ help: the protected tag <TAG> was created here, in the initial state Reserved
    |
 LL |     unsafe { ptr.read() };
    |     ^^^^^^^^^^^^^^^^^^^^^
-help: the protected tag <TAG> later transitioned to Active due to a child write access at offsets [0x0..0x4]
+help: the protected tag <TAG> later transitioned to Unique due to a child write access at offsets [0x0..0x4]
   --> tests/fail/function_calls/return_pointer_aliasing_read.rs:LL:CC
    |
 LL |     unsafe { ptr.read() };
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.tree.stderr b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.tree.stderr
index 0cf449ea3ec2f..deefb24b7850d 100644
--- a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.tree.stderr
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.tree.stderr
@@ -7,7 +7,7 @@ LL |     unsafe { ptr.write(0) };
    = 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: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/tree-borrows.md for further information
    = 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: this foreign write access would cause the protected tag <TAG> (currently Unique) to become Disabled
    = help: protected tags must never be Disabled
 help: the accessed tag <TAG> was created here
   --> tests/fail/function_calls/return_pointer_aliasing_write.rs:LL:CC
@@ -24,7 +24,7 @@ help: the protected tag <TAG> was created here, in the initial state Reserved
    |
 LL |     unsafe { ptr.write(0) };
    |     ^^^^^^^^^^^^^^^^^^^^^^^
-help: the protected tag <TAG> later transitioned to Active due to a child write access at offsets [0x0..0x4]
+help: the protected tag <TAG> later transitioned to Unique due to a child write access at offsets [0x0..0x4]
   --> tests/fail/function_calls/return_pointer_aliasing_write.rs:LL:CC
    |
 LL |     unsafe { ptr.write(0) };
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
index a006c6feae43c..76ccf39744d9b 100644
--- 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
@@ -7,7 +7,7 @@ LL |     unsafe { ptr.write(0) };
    = 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: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/tree-borrows.md for further information
    = 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: this foreign write access would cause the protected tag <TAG> (currently Unique) to become Disabled
    = help: protected tags must never be Disabled
 help: the accessed tag <TAG> was created here
   --> tests/fail/function_calls/return_pointer_aliasing_write_tail_call.rs:LL:CC
@@ -24,7 +24,7 @@ help: the protected tag <TAG> was created here, in the initial state Reserved
    |
 LL |     unsafe { ptr.write(0) };
    |     ^^^^^^^^^^^^^^^^^^^^^^^
-help: the protected tag <TAG> later transitioned to Active due to a child write access at offsets [0x0..0x4]
+help: the protected tag <TAG> later transitioned to Unique due to a child write access at offsets [0x0..0x4]
   --> tests/fail/function_calls/return_pointer_aliasing_write_tail_call.rs:LL:CC
    |
 LL |     unsafe { ptr.write(0) };
diff --git a/src/tools/miri/tests/fail/tree_borrows/alternate-read-write.stderr b/src/tools/miri/tests/fail/tree_borrows/alternate-read-write.stderr
index 9e955a6d5b196..aff482abfa0c7 100644
--- a/src/tools/miri/tests/fail/tree_borrows/alternate-read-write.stderr
+++ b/src/tools/miri/tests/fail/tree_borrows/alternate-read-write.stderr
@@ -12,7 +12,7 @@ help: the accessed tag <TAG> was created here, in the initial state Reserved
    |
 LL |     let y = unsafe { &mut *(x as *mut u8) };
    |                      ^^^^^^^^^^^^^^^^^^^^
-help: the accessed tag <TAG> later transitioned to Active due to a child write access at offsets [0x0..0x1]
+help: the accessed tag <TAG> later transitioned to Unique due to a child write access at offsets [0x0..0x1]
   --> tests/fail/tree_borrows/alternate-read-write.rs:LL:CC
    |
 LL |     *y += 1; // Success
diff --git a/src/tools/miri/tests/fail/tree_borrows/fnentry_invalidation.stderr b/src/tools/miri/tests/fail/tree_borrows/fnentry_invalidation.stderr
index 7886029dccfc2..bfd6854514e57 100644
--- a/src/tools/miri/tests/fail/tree_borrows/fnentry_invalidation.stderr
+++ b/src/tools/miri/tests/fail/tree_borrows/fnentry_invalidation.stderr
@@ -12,7 +12,7 @@ help: the accessed tag <TAG> was created here, in the initial state Reserved
    |
 LL |     let z = &mut x as *mut i32;
    |             ^^^^^^
-help: the accessed tag <TAG> later transitioned to Active due to a child write access at offsets [0x0..0x4]
+help: the accessed tag <TAG> later transitioned to Unique due to a child write access at offsets [0x0..0x4]
   --> tests/fail/tree_borrows/fnentry_invalidation.rs:LL:CC
    |
 LL |         *z = 1;
diff --git a/src/tools/miri/tests/fail/tree_borrows/parent_read_freezes_raw_mut.stderr b/src/tools/miri/tests/fail/tree_borrows/parent_read_freezes_raw_mut.stderr
index 2edbbd80569b2..7a713abcbc455 100644
--- a/src/tools/miri/tests/fail/tree_borrows/parent_read_freezes_raw_mut.stderr
+++ b/src/tools/miri/tests/fail/tree_borrows/parent_read_freezes_raw_mut.stderr
@@ -12,7 +12,7 @@ help: the accessed tag <TAG> was created here, in the initial state Reserved
    |
 LL |         let mref = &mut root;
    |                    ^^^^^^^^^
-help: the accessed tag <TAG> later transitioned to Active due to a child write access at offsets [0x0..0x1]
+help: the accessed tag <TAG> later transitioned to Unique due to a child write access at offsets [0x0..0x1]
   --> tests/fail/tree_borrows/parent_read_freezes_raw_mut.rs:LL:CC
    |
 LL |         *ptr = 0; // Write
diff --git a/src/tools/miri/tests/fail/tree_borrows/pass_invalid_mut.stderr b/src/tools/miri/tests/fail/tree_borrows/pass_invalid_mut.stderr
index c00c67173b7d8..9a70d248aa0c3 100644
--- a/src/tools/miri/tests/fail/tree_borrows/pass_invalid_mut.stderr
+++ b/src/tools/miri/tests/fail/tree_borrows/pass_invalid_mut.stderr
@@ -18,7 +18,7 @@ help: the conflicting tag <TAG> was created here, in the initial state Reserved
    |
 LL |     let xref = unsafe { &mut *xraw };
    |                         ^^^^^^^^^^
-help: the conflicting tag <TAG> later transitioned to Active due to a child write access at offsets [0x0..0x4]
+help: the conflicting tag <TAG> later transitioned to Unique due to a child write access at offsets [0x0..0x4]
   --> tests/fail/tree_borrows/pass_invalid_mut.rs:LL:CC
    |
 LL |     *xref = 18; // activate xref
diff --git a/src/tools/miri/tests/fail/tree_borrows/reservedim_spurious_write.rs b/src/tools/miri/tests/fail/tree_borrows/reservedim_spurious_write.rs
index 024a14600b1ba..3e5d83911ee63 100644
--- a/src/tools/miri/tests/fail/tree_borrows/reservedim_spurious_write.rs
+++ b/src/tools/miri/tests/fail/tree_borrows/reservedim_spurious_write.rs
@@ -60,8 +60,7 @@ fn main() {
         fn inner(x: &mut u8, b: IdxBarrier) {
             *x = 42; // activate immediately
             synchronized!(b, "[lazy] retag y (&mut, protect, IM)");
-            // A spurious write should be valid here because `x` is
-            // `Active` and protected.
+            // A spurious write should be valid here because `x` is `Unique` and protected.
             if cfg!(with) {
                 synchronized!(b, "spurious write x (executed)");
                 *x = 64;
diff --git a/src/tools/miri/tests/fail/tree_borrows/return_invalid_mut.stderr b/src/tools/miri/tests/fail/tree_borrows/return_invalid_mut.stderr
index ba8ab472872f7..4b6308847bb8f 100644
--- a/src/tools/miri/tests/fail/tree_borrows/return_invalid_mut.stderr
+++ b/src/tools/miri/tests/fail/tree_borrows/return_invalid_mut.stderr
@@ -18,7 +18,7 @@ help: the conflicting tag <TAG> was created here, in the initial state Reserved
    |
 LL |     let ret = unsafe { &mut (*xraw).1 };
    |                        ^^^^^^^^^^^^^^
-help: the conflicting tag <TAG> later transitioned to Active due to a child write access at offsets [0x4..0x8]
+help: the conflicting tag <TAG> later transitioned to Unique due to a child write access at offsets [0x4..0x8]
   --> tests/fail/tree_borrows/return_invalid_mut.rs:LL:CC
    |
 LL |     *ret = *ret; // activate
diff --git a/src/tools/miri/tests/fail/tree_borrows/subtree_traversal_skipping_diagnostics.rs b/src/tools/miri/tests/fail/tree_borrows/subtree_traversal_skipping_diagnostics.rs
index 6514334b09df6..94a3bb805442c 100644
--- a/src/tools/miri/tests/fail/tree_borrows/subtree_traversal_skipping_diagnostics.rs
+++ b/src/tools/miri/tests/fail/tree_borrows/subtree_traversal_skipping_diagnostics.rs
@@ -5,7 +5,7 @@
 
 // When this method is called, the tree will be a single line and look like this,
 // with other_ptr being the root at the top
-// other_ptr = root : Active
+// other_ptr = root : Unique
 // intermediary     : Frozen // an intermediary node
 // m                : Reserved
 fn write_to_mut(m: &mut u8, other_ptr: *const u8) {
diff --git a/src/tools/miri/tests/fail/tree_borrows/unique.default.stderr b/src/tools/miri/tests/fail/tree_borrows/unique.default.stderr
deleted file mode 100644
index c7d72f70f40cf..0000000000000
--- a/src/tools/miri/tests/fail/tree_borrows/unique.default.stderr
+++ /dev/null
@@ -1,32 +0,0 @@
-error: Undefined Behavior: write access through <TAG> at ALLOC[0x0] is forbidden
-  --> tests/fail/tree_borrows/unique.rs:LL:CC
-   |
-LL |         *uniq.as_ptr() = 3;
-   |         ^^^^^^^^^^^^^^^^^^ write access through <TAG> 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> has state Frozen which forbids this child write access
-help: the accessed tag <TAG> was created here, in the initial state Reserved
-  --> tests/fail/tree_borrows/unique.rs:LL:CC
-   |
-LL |     let refmut = &mut data;
-   |                  ^^^^^^^^^
-help: the accessed tag <TAG> later transitioned to Active due to a child write access at offsets [0x0..0x1]
-  --> tests/fail/tree_borrows/unique.rs:LL:CC
-   |
-LL |         *uniq.as_ptr() = 1; // activation
-   |         ^^^^^^^^^^^^^^^^^^
-   = help: this transition corresponds to the first write to a 2-phase borrowed mutable reference
-help: the accessed tag <TAG> later transitioned to Frozen due to a foreign read access at offsets [0x0..0x1]
-  --> tests/fail/tree_borrows/unique.rs:LL:CC
-   |
-LL |         let _definitely_parent = data; // definitely Frozen by now
-   |                                  ^^^^
-   = help: this transition corresponds to a loss of write permissions
-   = note: BACKTRACE (of the first span):
-   = note: inside `main` at tests/fail/tree_borrows/unique.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/tree_borrows/cell-inside-box.rs b/src/tools/miri/tests/pass/tree_borrows/cell-inside-box.rs
index adf2f4e845b5b..4a868455c8497 100644
--- a/src/tools/miri/tests/pass/tree_borrows/cell-inside-box.rs
+++ b/src/tools/miri/tests/pass/tree_borrows/cell-inside-box.rs
@@ -20,7 +20,7 @@ pub fn main() {
         name!(ptr2);
 
         // We perform a write through `x`.
-        // Because `ptr1` is ReservedIM, a child write will make it transition to Active.
+        // Because `ptr1` is ReservedIM, a child write will make it transition to Unique.
         // Because `ptr2` is ReservedIM, a foreign write doesn't have any effect on it.
         let x = (*ptr1).get();
         *x = 1;
diff --git a/src/tools/miri/tests/pass/tree_borrows/reborrow-is-read.rs b/src/tools/miri/tests/pass/tree_borrows/reborrow-is-read.rs
index 4fbccef2367d5..edd649b91edd3 100644
--- a/src/tools/miri/tests/pass/tree_borrows/reborrow-is-read.rs
+++ b/src/tools/miri/tests/pass/tree_borrows/reborrow-is-read.rs
@@ -6,7 +6,7 @@
 mod utils;
 
 // To check that a reborrow is counted as a Read access, we use a reborrow
-// with no additional Read to Freeze an Active pointer.
+// with no additional Read to Freeze an Unique pointer.
 
 fn main() {
     unsafe {
@@ -15,7 +15,7 @@ fn main() {
         let alloc_id = alloc_id!(parent);
         let x = &mut *parent;
         name!(x);
-        *x = 0; // x is now Active
+        *x = 0; // x is now Unique
         print_state!(alloc_id);
         let y = &mut *parent;
         name!(y);
diff --git a/src/tools/miri/tests/pass/tree_borrows/reserved.rs b/src/tools/miri/tests/pass/tree_borrows/reserved.rs
index c57cd7fcf0abe..83e1d9c70ed50 100644
--- a/src/tools/miri/tests/pass/tree_borrows/reserved.rs
+++ b/src/tools/miri/tests/pass/tree_borrows/reserved.rs
@@ -68,7 +68,7 @@ unsafe fn cell_unprotected_read() {
 }
 
 // Foreign Write on an interior mutable pointer is a noop.
-// Also y must become Active.
+// Also y must become Unique.
 unsafe fn cell_unprotected_write() {
     print("[interior mut] Foreign Write: Re* -> Re*");
     let base = &mut UnsafeCell::new(0u64);
@@ -97,7 +97,7 @@ unsafe fn int_protected_read() {
 }
 
 // Foreign Read on a Reserved is a noop.
-// Also y must become Active.
+// Also y must become Unique.
 unsafe fn int_unprotected_read() {
     print("[] Foreign Read: Res -> Res");
     let base = &mut 0u8;

From bbe05dcbdf4e08ab24e179cbbaaf50c96fa0634e Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 22 Sep 2025 09:54:24 +0200
Subject: [PATCH 1256/1889] Tree::new_child: remove SIFA precondition and sync
 terminology

---
 .../tree_borrows/diagnostics.rs               |  2 +-
 .../src/borrow_tracker/tree_borrows/mod.rs    | 28 ++------
 .../src/borrow_tracker/tree_borrows/tree.rs   | 68 +++++++------------
 .../borrow_tracker/tree_borrows/tree/tests.rs |  6 +-
 4 files changed, 34 insertions(+), 70 deletions(-)

diff --git a/src/tools/miri/src/borrow_tracker/tree_borrows/diagnostics.rs b/src/tools/miri/src/borrow_tracker/tree_borrows/diagnostics.rs
index a7977cd3366f9..00f921b0f8afb 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/diagnostics.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/diagnostics.rs
@@ -504,7 +504,7 @@ impl DisplayFmt {
         if let Some(perm) = perm {
             format!(
                 "{ac}{st}",
-                ac = if perm.is_accessed() { self.accessed.yes } else { self.accessed.no },
+                ac = if perm.accessed() { self.accessed.yes } else { self.accessed.no },
                 st = perm.permission().short_name(),
             )
         } else {
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 bed65440dc9aa..6e5b5c807aa22 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
@@ -294,24 +294,6 @@ trait EvalContextPrivExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             return interp_ok(Some(Provenance::Concrete { alloc_id, tag: new_tag }));
         }
 
-        let span = this.machine.current_span();
-
-        // When adding a new node, the SIFA of its parents needs to be updated, potentially across
-        // the entire memory range. For the parts that are being accessed below, the access itself
-        // trivially takes care of that. However, we have to do some more work to also deal with the
-        // parts that are not being accessed. Specifically what we do is that we call
-        // `update_last_accessed_after_retag` on the SIFA of the permission set for the part of
-        // memory outside `perm_map` -- so that part is definitely taken care of. The remaining
-        // concern is the part of memory that is in the range of `perms_map`, but not accessed
-        // below. There we have two cases:
-        // * If the type is `!Freeze`, then the non-accessed part uses `nonfreeze_perm`, so the
-        //   `nonfreeze_perm` initialized parts are also fine. We enforce the `freeze_perm` parts to
-        //   be accessed via the assert below, and thus everything is taken care of.
-        // * If the type is `Freeze`, then `freeze_perm` is used everywhere (both inside and outside
-        //   the initial range), and we update everything to have the `freeze_perm`'s SIFA, so there
-        //   are no issues. (And this assert below is not actually needed in this case).
-        assert!(new_perm.freeze_access);
-
         let protected = new_perm.protector.is_some();
         let precise_interior_mut = this
             .machine
@@ -337,7 +319,7 @@ trait EvalContextPrivExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 LocationState::new_non_accessed(perm, sifa)
             }
         };
-        let perms_map = if !precise_interior_mut {
+        let inside_perms = if !precise_interior_mut {
             // For `!Freeze` types, just pretend the entire thing is an `UnsafeCell`.
             let ty_is_freeze = place.layout.ty.is_freeze(*this.tcx, this.typing_env());
             let state = loc_state(ty_is_freeze);
@@ -364,8 +346,8 @@ trait EvalContextPrivExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let alloc_extra = this.get_alloc_extra(alloc_id)?;
         let mut tree_borrows = alloc_extra.borrow_tracker_tb().borrow_mut();
 
-        for (perm_range, perm) in perms_map.iter_all() {
-            if perm.is_accessed() {
+        for (perm_range, perm) in inside_perms.iter_all() {
+            if perm.accessed() {
                 // Some reborrows incur a read access to the parent.
                 // Adjust range to be relative to allocation start (rather than to `place`).
                 let range_in_alloc = AllocRange {
@@ -401,10 +383,10 @@ trait EvalContextPrivExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             base_offset,
             orig_tag,
             new_tag,
-            perms_map,
+            inside_perms,
             new_perm.outside_perm,
             protected,
-            span,
+            this.machine.current_span(),
         )?;
         drop(tree_borrows);
 
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 9e7d272ee4b00..be2a07eee1503 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/tree.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/tree.rs
@@ -11,7 +11,7 @@
 //! - idempotency properties asserted in `perms.rs` (for optimizations)
 
 use std::ops::Range;
-use std::{fmt, mem};
+use std::{cmp, fmt, mem};
 
 use rustc_abi::Size;
 use rustc_data_structures::fx::FxHashSet;
@@ -73,23 +73,10 @@ impl LocationState {
 
     /// Check if the location has been accessed, i.e. if it has
     /// ever been accessed through a child pointer.
-    pub fn is_accessed(&self) -> bool {
+    pub fn accessed(&self) -> bool {
         self.accessed
     }
 
-    /// Check if the state can exist as the initial permission of a pointer.
-    ///
-    /// Do not confuse with `is_accessed`, the two are almost orthogonal
-    /// as apart from `Unique` which is not initial and must be accessed,
-    /// any other permission can have an arbitrary combination of being
-    /// initial/accessed.
-    /// FIXME: when the corresponding `assert` in `tree_borrows/mod.rs` finally
-    /// passes and can be uncommented, remove this `#[allow(dead_code)]`.
-    #[cfg_attr(not(test), allow(dead_code))]
-    pub fn is_initial(&self) -> bool {
-        self.permission.is_initial()
-    }
-
     pub fn permission(&self) -> Permission {
         self.permission
     }
@@ -618,30 +605,26 @@ impl Tree {
 impl<'tcx> Tree {
     /// Insert a new tag in the tree.
     ///
-    /// `initial_perms` defines the initial permissions for the part of memory
-    /// that is already considered "initialized" immediately. The ranges in this
-    /// map are relative to `base_offset`.
-    /// `default_perm` defines the initial permission for the rest of the allocation.
-    ///
-    /// For all non-accessed locations in the RangeMap (those that haven't had an
-    /// implicit read), their SIFA must be weaker than or as weak as the SIFA of
-    /// `default_perm`.
+    /// `inside_perm` defines the initial permissions for a block of memory starting at
+    /// `base_offset`. These may nor may not be already marked as "accessed".
+    /// `outside_perm` defines the initial permission for the rest of the allocation.
+    /// These are definitely not "accessed".
     pub(super) fn new_child(
         &mut self,
         base_offset: Size,
         parent_tag: BorTag,
         new_tag: BorTag,
-        initial_perms: DedupRangeMap<LocationState>,
-        default_perm: Permission,
+        inside_perms: DedupRangeMap<LocationState>,
+        outside_perm: Permission,
         protected: bool,
         span: Span,
     ) -> InterpResult<'tcx> {
         let idx = self.tag_mapping.insert(new_tag);
         let parent_idx = self.tag_mapping.get(&parent_tag).unwrap();
-        assert!(default_perm.is_initial());
+        assert!(outside_perm.is_initial());
 
         let default_strongest_idempotent =
-            default_perm.strongest_idempotent_foreign_access(protected);
+            outside_perm.strongest_idempotent_foreign_access(protected);
         // Create the node
         self.nodes.insert(
             idx,
@@ -649,36 +632,35 @@ impl<'tcx> Tree {
                 tag: new_tag,
                 parent: Some(parent_idx),
                 children: SmallVec::default(),
-                default_initial_perm: default_perm,
+                default_initial_perm: outside_perm,
                 default_initial_idempotent_foreign_access: default_strongest_idempotent,
-                debug_info: NodeDebugInfo::new(new_tag, default_perm, span),
+                debug_info: NodeDebugInfo::new(new_tag, outside_perm, span),
             },
         );
         // Register new_tag as a child of parent_tag
         self.nodes.get_mut(parent_idx).unwrap().children.push(idx);
 
+        // We need to know the biggest SIFA for `update_last_accessed_after_retag` below.
+        let mut max_sifa = default_strongest_idempotent;
         for (Range { start, end }, &perm) in
-            initial_perms.iter(Size::from_bytes(0), initial_perms.size())
+            inside_perms.iter(Size::from_bytes(0), inside_perms.size())
         {
-            assert!(perm.is_initial());
+            assert!(perm.permission.is_initial());
+            max_sifa = cmp::max(max_sifa, perm.idempotent_foreign_access);
             for (_perms_range, perms) in self
                 .rperms
                 .iter_mut(Size::from_bytes(start) + base_offset, Size::from_bytes(end - start))
             {
-                assert!(
-                    default_strongest_idempotent
-                        >= perm.permission.strongest_idempotent_foreign_access(protected)
-                );
                 perms.insert(idx, perm);
             }
         }
 
-        // Inserting the new perms might have broken the SIFA invariant (see `foreign_access_skipping.rs`).
-        // We now weaken the recorded SIFA for our parents, until the invariant is restored.
-        // We could weaken them all to `LocalAccess`, but it is more efficient to compute the SIFA
-        // for the new permission statically, and use that.
-        // See the comment in `tb_reborrow` for why it is correct to use the SIFA of `default_uninit_perm`.
-        self.update_last_accessed_after_retag(parent_idx, default_strongest_idempotent);
+        // Inserting the new perms might have broken the SIFA invariant (see
+        // `foreign_access_skipping.rs`). We now weaken the recorded SIFA for our parents, until the
+        // invariant is restored. We could weaken them all to `LocalAccess`, but it is more
+        // efficient to compute the SIFA for the new permission statically, and use that. For this
+        // we need the *maximum* SIFA (`Write` needs more fixup than `None`).
+        self.update_last_accessed_after_retag(parent_idx, max_sifa);
 
         interp_ok(())
     }
@@ -755,9 +737,9 @@ impl<'tcx> Tree {
                             == Some(&ProtectorKind::StrongProtector)
                             // Don't check for protector if it is a Cell (see `unsafe_cell_deallocate` in `interior_mutability.rs`).
                             // Related to https://github.com/rust-lang/rust/issues/55005.
-                            && !perm.permission().is_cell()
+                            && !perm.permission.is_cell()
                             // Only trigger UB if the accessed bit is set, i.e. if the protector is actually protecting this offset. See #4579.
-                            && perm.is_accessed()
+                            && perm.accessed
                         {
                             Err(TransitionError::ProtectedDealloc)
                         } else {
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 83232615616e6..189e48eca724a 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
@@ -106,7 +106,7 @@ fn tree_compacting_is_sound() {
                         as_foreign_or_child(rel),
                         kind,
                         parent.permission(),
-                        as_lazy_or_accessed(child.is_accessed()),
+                        as_lazy_or_accessed(child.accessed()),
                         child.permission(),
                         as_protected(child_protected),
                         np.permission(),
@@ -122,7 +122,7 @@ fn tree_compacting_is_sound() {
                         as_foreign_or_child(rel),
                         kind,
                         parent.permission(),
-                        as_lazy_or_accessed(child.is_accessed()),
+                        as_lazy_or_accessed(child.accessed()),
                         child.permission(),
                         as_protected(child_protected),
                         nc.permission()
@@ -375,7 +375,7 @@ mod spurious_read {
 
     impl LocStateProt {
         fn is_initial(&self) -> bool {
-            self.state.is_initial()
+            self.state.permission().is_initial()
         }
 
         fn perform_access(&self, kind: AccessKind, rel: AccessRelatedness) -> Result<Self, ()> {

From ba2537b6ffdbd9979874ca029e5bd86c6b925b37 Mon Sep 17 00:00:00 2001
From: Iris Shi <0.0@owo.li>
Date: Mon, 22 Sep 2025 18:09:10 +0800
Subject: [PATCH 1257/1889] add exit code check

---
 .../rustdoc-merge-no-input-finalize/rmake.rs     | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/tests/run-make/rustdoc-merge-no-input-finalize/rmake.rs b/tests/run-make/rustdoc-merge-no-input-finalize/rmake.rs
index 6df9e95829d8d..4ead8c2e56c56 100644
--- a/tests/run-make/rustdoc-merge-no-input-finalize/rmake.rs
+++ b/tests/run-make/rustdoc-merge-no-input-finalize/rmake.rs
@@ -3,20 +3,26 @@
 
 //@ needs-target-std
 
-use run_make_support::rustdoc;
+use run_make_support::{path, rustdoc};
 
 fn main() {
+    let out_dir = path("out");
+    let merged_dir = path("merged");
+    let parts_out_dir = path("parts");
     rustdoc()
         .input("sierra.rs")
+        .out_dir(&out_dir)
         .arg("-Zunstable-options")
-        .arg("--parts-out-dir=parts")
+        .arg(format!("--parts-out-dir={}", parts_out_dir.display()))
         .arg("--merge=none")
         .run();
 
-    rustdoc()
+    let output = rustdoc()
         .arg("-Zunstable-options")
-        .arg("--include-parts-dir=parts")
+        .out_dir(&out_dir)
+        .arg(format!("--include-parts-dir={}", parts_out_dir.display()))
         .arg("--merge=finalize")
-        .out_dir("out")
         .run();
+
+    output.assert_exit_code(0);
 }

From 06819d95c0697c6a2f8f1498a22260f47c210bd7 Mon Sep 17 00:00:00 2001
From: Reuben Cruise <reuben.cruise@arm.com>
Date: Tue, 2 Sep 2025 16:13:51 +0100
Subject: [PATCH 1258/1889] Extends branch protection tests to include GCS

---
 tests/assembly-llvm/aarch64-pointer-auth.rs            |  6 +++++-
 tests/codegen-llvm/branch-protection.rs                |  6 +++++-
 .../pointer-auth-link-with-c-lto-clang/rmake.rs        |  8 +++++---
 tests/run-make/pointer-auth-link-with-c/rmake.rs       | 10 ++++++----
 .../branch-protection-missing-pac-ret.BADFLAGS.stderr  |  2 +-
 ...branch-protection-missing-pac-ret.BADFLAGSPC.stderr |  2 +-
 6 files changed, 23 insertions(+), 11 deletions(-)

diff --git a/tests/assembly-llvm/aarch64-pointer-auth.rs b/tests/assembly-llvm/aarch64-pointer-auth.rs
index 56a26df469f35..e1ca6d775813d 100644
--- a/tests/assembly-llvm/aarch64-pointer-auth.rs
+++ b/tests/assembly-llvm/aarch64-pointer-auth.rs
@@ -1,10 +1,13 @@
 // Test that PAC instructions are emitted when branch-protection is specified.
 
 //@ add-core-stubs
-//@ revisions: PACRET PAUTHLR_NOP PAUTHLR
+//@ revisions: GCS PACRET PAUTHLR_NOP PAUTHLR
 //@ assembly-output: emit-asm
 //@ needs-llvm-components: aarch64
 //@ compile-flags: --target aarch64-unknown-linux-gnu
+//@ [GCS] min-llvm-version: 21
+//@ [GCS] ignore-apple (XCode version needs updating)
+//@ [GCS] compile-flags: -Z branch-protection=gcs
 //@ [PACRET] compile-flags: -Z branch-protection=pac-ret,leaf
 //@ [PAUTHLR_NOP] compile-flags: -Z branch-protection=pac-ret,pc,leaf
 //@ [PAUTHLR] compile-flags: -C target-feature=+pauth-lr -Z branch-protection=pac-ret,pc,leaf
@@ -17,6 +20,7 @@
 extern crate minicore;
 use minicore::*;
 
+// GCS: .aeabi_attribute 2, 1 // Tag_Feature_GCS
 // PACRET: hint #25
 // PACRET: hint #29
 // PAUTHLR_NOP: hint #25
diff --git a/tests/codegen-llvm/branch-protection.rs b/tests/codegen-llvm/branch-protection.rs
index d67e494cc0d65..f92259c941cef 100644
--- a/tests/codegen-llvm/branch-protection.rs
+++ b/tests/codegen-llvm/branch-protection.rs
@@ -1,9 +1,10 @@
 // Test that the correct module flags are emitted with different branch protection flags.
 
 //@ add-core-stubs
-//@ revisions: BTI PACRET LEAF BKEY PAUTHLR PAUTHLR_BKEY PAUTHLR_LEAF PAUTHLR_BTI NONE
+//@ revisions: BTI GCS PACRET LEAF BKEY PAUTHLR PAUTHLR_BKEY PAUTHLR_LEAF PAUTHLR_BTI NONE
 //@ needs-llvm-components: aarch64
 //@ [BTI] compile-flags: -Z branch-protection=bti
+//@ [GCS] compile-flags: -Z branch-protection=gcs
 //@ [PACRET] compile-flags: -Z branch-protection=pac-ret
 //@ [LEAF] compile-flags: -Z branch-protection=pac-ret,leaf
 //@ [BKEY] compile-flags: -Z branch-protection=pac-ret,b-key
@@ -32,6 +33,9 @@ pub fn test() {}
 // BTI: !"sign-return-address-all", i32 0
 // BTI: !"sign-return-address-with-bkey", i32 0
 
+// GCS: attributes [[ATTR]] = {{.*}} "guarded-control-stack"
+// GCS: !"guarded-control-stack", i32 1
+
 // PACRET: attributes [[ATTR]] = {{.*}} "sign-return-address"="non-leaf"
 // PACRET-SAME: "sign-return-address-key"="a_key"
 // PACRET: !"branch-target-enforcement", i32 0
diff --git a/tests/run-make/pointer-auth-link-with-c-lto-clang/rmake.rs b/tests/run-make/pointer-auth-link-with-c-lto-clang/rmake.rs
index 0a2186b095389..2ac5fdee063c2 100644
--- a/tests/run-make/pointer-auth-link-with-c-lto-clang/rmake.rs
+++ b/tests/run-make/pointer-auth-link-with-c-lto-clang/rmake.rs
@@ -1,12 +1,14 @@
 // `-Z branch protection` is an unstable compiler feature which adds pointer-authentication
 // code (PAC), a useful hashing measure for verifying that pointers have not been modified.
 // This test checks that compilation and execution is successful when this feature is activated,
-// with some of its possible extra arguments (bti, pac-ret, leaf) when doing LTO.
+// with some of its possible extra arguments (bti, gcs, pac-ret, leaf) when doing LTO.
 // See https://github.com/rust-lang/rust/pull/88354
 
 //@ needs-force-clang-based-tests
 //@ only-aarch64
 // Reason: branch protection is not supported on other architectures
+//@ ignore-apple
+// Reason: XCode needs updating to support gcs
 //@ ignore-cross-compile
 // Reason: the compiled binary is executed
 
@@ -19,7 +21,7 @@ fn main() {
     clang()
         .arg("-v")
         .lto("thin")
-        .arg("-mbranch-protection=bti+pac-ret+b-key+leaf")
+        .arg("-mbranch-protection=bti+gcs+pac-ret+b-key+leaf")
         .arg("-c")
         .out_exe("test.o")
         .input("test.c")
@@ -30,7 +32,7 @@ fn main() {
         .opt_level("2")
         .linker(&env_var("CLANG"))
         .link_arg("-fuse-ld=lld")
-        .arg("-Zbranch-protection=bti,pac-ret,leaf")
+        .arg("-Zbranch-protection=bti,gcs,pac-ret,leaf")
         .input("test.rs")
         .output("test.bin")
         .run();
diff --git a/tests/run-make/pointer-auth-link-with-c/rmake.rs b/tests/run-make/pointer-auth-link-with-c/rmake.rs
index a4d7454e5755a..1ddcb79d64ff4 100644
--- a/tests/run-make/pointer-auth-link-with-c/rmake.rs
+++ b/tests/run-make/pointer-auth-link-with-c/rmake.rs
@@ -1,11 +1,13 @@
 // `-Z branch protection` is an unstable compiler feature which adds pointer-authentication
 // code (PAC), a useful hashing measure for verifying that pointers have not been modified.
 // This test checks that compilation and execution is successful when this feature is activated,
-// with some of its possible extra arguments (bti, pac-ret, pc, leaf, b-key).
+// with some of its possible extra arguments (bti, gcs, pac-ret, pc, leaf, b-key).
 // See https://github.com/rust-lang/rust/pull/88354
 
 //@ only-aarch64
 // Reason: branch protection is not supported on other architectures
+//@ ignore-apple
+// Reason: XCode needs updating to support gcs
 //@ ignore-cross-compile
 // Reason: the compiled binary is executed
 
@@ -13,17 +15,17 @@ use run_make_support::{build_native_static_lib, cc, is_windows_msvc, llvm_ar, ru
 
 fn main() {
     build_native_static_lib("test");
-    rustc().arg("-Zbranch-protection=bti,pac-ret,leaf").input("test.rs").run();
+    rustc().arg("-Zbranch-protection=bti,gcs,pac-ret,leaf").input("test.rs").run();
     run("test");
     cc().arg("-v")
         .arg("-c")
         .out_exe("test")
         .input("test.c")
-        .arg("-mbranch-protection=bti+pac-ret+leaf")
+        .arg("-mbranch-protection=bti+gcs+pac-ret+leaf")
         .run();
     let obj_file = if is_windows_msvc() { "test.obj" } else { "test" };
     llvm_ar().obj_to_ar().output_input("libtest.a", &obj_file).run();
-    rustc().arg("-Zbranch-protection=bti,pac-ret,leaf").input("test.rs").run();
+    rustc().arg("-Zbranch-protection=bti,gcs,pac-ret,leaf").input("test.rs").run();
     run("test");
 
     // FIXME: +pc was only recently added to LLVM
diff --git a/tests/ui/invalid-compile-flags/branch-protection-missing-pac-ret.BADFLAGS.stderr b/tests/ui/invalid-compile-flags/branch-protection-missing-pac-ret.BADFLAGS.stderr
index dae08119dbc68..277111a41f29c 100644
--- a/tests/ui/invalid-compile-flags/branch-protection-missing-pac-ret.BADFLAGS.stderr
+++ b/tests/ui/invalid-compile-flags/branch-protection-missing-pac-ret.BADFLAGS.stderr
@@ -1,2 +1,2 @@
-error: incorrect value `leaf` for unstable option `branch-protection` - a `,` separated combination of `bti`, `pac-ret`, followed by a combination of `pc`, `b-key`, or `leaf` was expected
+error: incorrect value `leaf` for unstable option `branch-protection` - a `,` separated combination of `bti`, `gcs`, `pac-ret`, (optionally with `pc`, `b-key`, `leaf` if `pac-ret` is set) was expected
 
diff --git a/tests/ui/invalid-compile-flags/branch-protection-missing-pac-ret.BADFLAGSPC.stderr b/tests/ui/invalid-compile-flags/branch-protection-missing-pac-ret.BADFLAGSPC.stderr
index 13f79e94674b2..e1ade01d2fe76 100644
--- a/tests/ui/invalid-compile-flags/branch-protection-missing-pac-ret.BADFLAGSPC.stderr
+++ b/tests/ui/invalid-compile-flags/branch-protection-missing-pac-ret.BADFLAGSPC.stderr
@@ -1,2 +1,2 @@
-error: incorrect value `pc` for unstable option `branch-protection` - a `,` separated combination of `bti`, `pac-ret`, followed by a combination of `pc`, `b-key`, or `leaf` was expected
+error: incorrect value `pc` for unstable option `branch-protection` - a `,` separated combination of `bti`, `gcs`, `pac-ret`, (optionally with `pc`, `b-key`, `leaf` if `pac-ret` is set) was expected
 

From f51fb9178e8d3648a908136d132bbfd1811481fd Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sun, 21 Sep 2025 23:39:59 +0200
Subject: [PATCH 1259/1889] kcfi: only reify trait methods when dyn-compatible

---
 compiler/rustc_middle/src/ty/instance.rs      |  4 +-
 .../sanitizer/kcfi/fn-ptr-reify-shim.rs       | 74 +++++++++++++++++++
 .../sanitizer/kcfi/naked-function.rs          |  7 +-
 tests/ui/sanitizer/kcfi-c-variadic.rs         | 20 +++++
 4 files changed, 100 insertions(+), 5 deletions(-)
 create mode 100644 tests/codegen-llvm/sanitizer/kcfi/fn-ptr-reify-shim.rs
 create mode 100644 tests/ui/sanitizer/kcfi-c-variadic.rs

diff --git a/compiler/rustc_middle/src/ty/instance.rs b/compiler/rustc_middle/src/ty/instance.rs
index 34ead91b4f6de..c27d47fcc0d8d 100644
--- a/compiler/rustc_middle/src/ty/instance.rs
+++ b/compiler/rustc_middle/src/ty/instance.rs
@@ -618,11 +618,11 @@ impl<'tcx> Instance<'tcx> {
                         // be directly reified because it's closure-like. The reify can handle the
                         // unresolved instance.
                         resolved = Instance { def: InstanceKind::ReifyShim(def_id, reason), args }
-                    // Reify `Trait::method` implementations
-                    // FIXME(maurer) only reify it if it is a vtable-safe function
+                    // Reify `Trait::method` implementations if the trait is dyn-compatible.
                     } else if let Some(assoc) = tcx.opt_associated_item(def_id)
                         && let AssocContainer::Trait | AssocContainer::TraitImpl(Ok(_)) =
                             assoc.container
+                        && tcx.is_dyn_compatible(assoc.container_id(tcx))
                     {
                         // If this function could also go in a vtable, we need to `ReifyShim` it with
                         // KCFI because it can only attach one type per function.
diff --git a/tests/codegen-llvm/sanitizer/kcfi/fn-ptr-reify-shim.rs b/tests/codegen-llvm/sanitizer/kcfi/fn-ptr-reify-shim.rs
new file mode 100644
index 0000000000000..604b4c8c2f8a5
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/kcfi/fn-ptr-reify-shim.rs
@@ -0,0 +1,74 @@
+//@ add-core-stubs
+//@ 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 -Cno-prepopulate-passes -Copt-level=0
+
+#![feature(no_core, lang_items)]
+#![crate_type = "lib"]
+#![no_core]
+
+// A `ReifyShim` should only be created when the trait is dyn-compatible.
+
+extern crate minicore;
+use minicore::*;
+
+trait DynCompatible {
+    fn dyn_name(&self) -> &'static str;
+
+    fn dyn_name_default(&self) -> &'static str {
+        let _ = self;
+        "dyn_default"
+    }
+}
+
+// Not dyn-compatible because the `Self: Sized` bound is missing.
+trait NotDynCompatible {
+    fn not_dyn_name() -> &'static str;
+
+    fn not_dyn_name_default() -> &'static str {
+        "not_dyn_default"
+    }
+}
+
+struct S;
+
+impl DynCompatible for S {
+    fn dyn_name(&self) -> &'static str {
+        "dyn_compatible"
+    }
+}
+
+impl NotDynCompatible for S {
+    fn not_dyn_name() -> &'static str {
+        "not_dyn_compatible"
+    }
+}
+
+#[no_mangle]
+pub fn main() {
+    let s = S;
+
+    // `DynCompatible` is indeed dyn-compatible.
+    let _: &dyn DynCompatible = &s;
+
+    // CHECK: call <fn_ptr_reify_shim::S as fn_ptr_reify_shim::DynCompatible>::dyn_name{{.*}}reify.shim.fnptr
+    let dyn_name = S::dyn_name as fn(&S) -> &str;
+    let _unused = dyn_name(&s);
+
+    // CHECK: call fn_ptr_reify_shim::DynCompatible::dyn_name_default{{.*}}reify.shim.fnptr
+    let dyn_name_default = S::dyn_name_default as fn(&S) -> &str;
+    let _unused = dyn_name_default(&s);
+
+    // Check using $ (end-of-line) that these calls do not contain `reify.shim.fnptr`.
+
+    // CHECK: call <fn_ptr_reify_shim::S as fn_ptr_reify_shim::NotDynCompatible>::not_dyn_name{{$}}
+    let not_dyn_name = S::not_dyn_name as fn() -> &'static str;
+    let _unused = not_dyn_name();
+
+    // CHECK: call fn_ptr_reify_shim::NotDynCompatible::not_dyn_name_default{{$}}
+    let not_dyn_name_default = S::not_dyn_name_default as fn() -> &'static str;
+    let _unused = not_dyn_name_default();
+}
diff --git a/tests/codegen-llvm/sanitizer/kcfi/naked-function.rs b/tests/codegen-llvm/sanitizer/kcfi/naked-function.rs
index 2c8cdc919b85d..31f59ee01decb 100644
--- a/tests/codegen-llvm/sanitizer/kcfi/naked-function.rs
+++ b/tests/codegen-llvm/sanitizer/kcfi/naked-function.rs
@@ -15,8 +15,9 @@ use minicore::*;
 
 struct Thing;
 trait MyTrait {
+    // NOTE: this test assumes that this trait is dyn-compatible.
     #[unsafe(naked)]
-    extern "C" fn my_naked_function() {
+    extern "C" fn my_naked_function(&self) {
         // the real function is defined
         // CHECK: .globl
         // CHECK-SAME: my_naked_function
@@ -34,13 +35,13 @@ impl MyTrait for Thing {}
 #[unsafe(no_mangle)]
 pub fn main() {
     // Trick the compiler into generating an indirect call.
-    const F: extern "C" fn() = Thing::my_naked_function;
+    const F: extern "C" fn(&Thing) = Thing::my_naked_function;
 
     // main calls the shim function
     // CHECK: call void
     // CHECK-SAME: my_naked_function
     // CHECK-SAME: reify.shim.fnptr
-    (F)();
+    (F)(&Thing);
 }
 
 // CHECK: declare !kcfi_type
diff --git a/tests/ui/sanitizer/kcfi-c-variadic.rs b/tests/ui/sanitizer/kcfi-c-variadic.rs
new file mode 100644
index 0000000000000..45d00a4524ebf
--- /dev/null
+++ b/tests/ui/sanitizer/kcfi-c-variadic.rs
@@ -0,0 +1,20 @@
+//@ needs-sanitizer-kcfi
+//@ no-prefer-dynamic
+//@ compile-flags: -Zsanitizer=kcfi -Cpanic=abort -Cunsafe-allow-abi-mismatch=sanitizer
+//@ ignore-backends: gcc
+//@ run-pass
+
+#![feature(c_variadic)]
+
+trait Trait {
+    unsafe extern "C" fn foo(x: i32, y: i32, mut ap: ...) -> i32 {
+        x + y + ap.arg::<i32>() + ap.arg::<i32>()
+    }
+}
+
+impl Trait for i32 {}
+
+fn main() {
+    let f = i32::foo as unsafe extern "C" fn(i32, i32, ...) -> i32;
+    assert_eq!(unsafe { f(1, 2, 3, 4) }, 1 + 2 + 3 + 4);
+}

From 870a98c7b3bec5e0ec3432a4900d2bb6f0e1cc89 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Mon, 22 Sep 2025 14:14:48 +0200
Subject: [PATCH 1260/1889] Fix modification check of `rustdoc-json-types`

---
 src/tools/tidy/src/rustdoc_json.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/tools/tidy/src/rustdoc_json.rs b/src/tools/tidy/src/rustdoc_json.rs
index 7a53c08737f6c..ade774616c71b 100644
--- a/src/tools/tidy/src/rustdoc_json.rs
+++ b/src/tools/tidy/src/rustdoc_json.rs
@@ -17,11 +17,13 @@ pub fn check(src_path: &Path, ci_info: &crate::CiInfo, diag_ctx: DiagCtx) {
     };
 
     // First we check that `src/rustdoc-json-types` was modified.
-    if !crate::files_modified(ci_info, |p| p == RUSTDOC_JSON_TYPES) {
+    if !crate::files_modified(ci_info, |p| p.starts_with(RUSTDOC_JSON_TYPES)) {
         // `rustdoc-json-types` was not modified so nothing more to check here.
-        check.verbose_msg("`rustdoc-json-types` was not modified.");
         return;
     }
+
+    check.message("`rustdoc-json-types` modified, checking format version");
+
     // Then we check that if `FORMAT_VERSION` was updated, the `Latest feature:` was also updated.
     match crate::git_diff(base_commit, src_path.join("rustdoc-json-types")) {
         Some(output) => {

From 6adbb3a18972c1e4c24ac8a2766a0a5fc699f900 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 22 Sep 2025 18:06:07 +0530
Subject: [PATCH 1261/1889] remove explicit target assignment in config during
 rustc initialization

---
 src/bootstrap/src/core/builder/tests.rs | 19 +++++++------------
 src/bootstrap/src/core/config/config.rs |  4 +---
 2 files changed, 8 insertions(+), 15 deletions(-)

diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index 0bb22eccd1936..f838149977d01 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -22,13 +22,7 @@ fn configure(cmd: &str, host: &[&str], target: &[&str]) -> Config {
 }
 
 fn configure_with_args(cmd: &[&str], host: &[&str], target: &[&str]) -> Config {
-    TestCtx::new()
-        .config(cmd[0])
-        .args(&cmd[1..])
-        .hosts(host)
-        .targets(target)
-        .args(&["--build", TEST_TRIPLE_1])
-        .create_config()
+    TestCtx::new().config(cmd[0]).args(&cmd[1..]).hosts(host).targets(target).create_config()
 }
 
 fn first<A, B>(v: Vec<(A, B)>) -> Vec<A> {
@@ -236,6 +230,7 @@ mod dist {
 
     use super::{Config, TEST_TRIPLE_1, TEST_TRIPLE_2, TEST_TRIPLE_3, first, run_build};
     use crate::Flags;
+    use crate::core::builder::tests::host_target;
     use crate::core::builder::*;
 
     fn configure(host: &[&str], target: &[&str]) -> Config {
@@ -244,11 +239,11 @@ mod dist {
 
     #[test]
     fn llvm_out_behaviour() {
-        let mut config = configure(&[TEST_TRIPLE_1], &[TEST_TRIPLE_2]);
+        let mut config = configure(&[], &[TEST_TRIPLE_2]);
         config.llvm_from_ci = true;
         let build = Build::new(config.clone());
 
-        let target = TargetSelection::from_user(TEST_TRIPLE_1);
+        let target = TargetSelection::from_user(&host_target());
         assert!(build.llvm_out(target).ends_with("ci-llvm"));
         let target = TargetSelection::from_user(TEST_TRIPLE_2);
         assert!(build.llvm_out(target).ends_with("llvm"));
@@ -313,14 +308,14 @@ mod sysroot_target_dirs {
 /// cg_gcc tests instead.
 #[test]
 fn test_test_compiler() {
-    let config = configure_with_args(&["test", "compiler"], &[TEST_TRIPLE_1], &[TEST_TRIPLE_1]);
+    let config = configure_with_args(&["test", "compiler"], &[], &[TEST_TRIPLE_1]);
     let cache = run_build(&config.paths.clone(), config);
 
     let compiler = cache.contains::<test::CrateLibrustc>();
     let cranelift = cache.contains::<test::CodegenCranelift>();
     let gcc = cache.contains::<test::CodegenGCC>();
 
-    assert_eq!((compiler, cranelift, gcc), (true, false, false));
+    assert_eq!((compiler, cranelift, gcc), (false, false, false));
 }
 
 #[test]
@@ -346,7 +341,7 @@ fn test_test_coverage() {
         // Print each test case so that if one fails, the most recently printed
         // case is the one that failed.
         println!("Testing case: {cmd:?}");
-        let config = configure_with_args(cmd, &[TEST_TRIPLE_1], &[TEST_TRIPLE_1]);
+        let config = configure_with_args(cmd, &[], &[TEST_TRIPLE_1]);
         let mut cache = run_build(&config.paths.clone(), config);
 
         let modes =
diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index 1f3b90d324fb1..957de5367ef6a 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -688,9 +688,7 @@ impl Config {
 
         let initial_rustc = build_rustc.unwrap_or_else(|| {
             download_beta_toolchain(&dwn_ctx, &out);
-            let target = if cfg!(test) { get_host_target() } else { host_target };
-
-            out.join(target).join("stage0").join("bin").join(exe("rustc", host_target))
+            out.join(host_target).join("stage0").join("bin").join(exe("rustc", host_target))
         });
 
         let initial_sysroot = t!(PathBuf::from_str(

From 42ebba214b3c570761dc99f5fc1517ad092778ac Mon Sep 17 00:00:00 2001
From: Iris Shi <0.0@owo.li>
Date: Mon, 22 Sep 2025 20:36:18 +0800
Subject: [PATCH 1262/1889] address review comments

---
 tests/run-make/rustdoc-merge-no-input-finalize/rmake.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/run-make/rustdoc-merge-no-input-finalize/rmake.rs b/tests/run-make/rustdoc-merge-no-input-finalize/rmake.rs
index 4ead8c2e56c56..0b1e1948d5fcc 100644
--- a/tests/run-make/rustdoc-merge-no-input-finalize/rmake.rs
+++ b/tests/run-make/rustdoc-merge-no-input-finalize/rmake.rs
@@ -16,6 +16,7 @@ fn main() {
         .arg(format!("--parts-out-dir={}", parts_out_dir.display()))
         .arg("--merge=none")
         .run();
+    assert!(parts_out_dir.join("crate-info").exists());
 
     let output = rustdoc()
         .arg("-Zunstable-options")
@@ -23,6 +24,5 @@ fn main() {
         .arg(format!("--include-parts-dir={}", parts_out_dir.display()))
         .arg("--merge=finalize")
         .run();
-
-    output.assert_exit_code(0);
+    output.assert_stderr_not_contains("error: the compiler unexpectedly panicked. this is a bug.");
 }

From a25896bc2785b234c8b093a25b7f7df34798aea8 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 22 Sep 2025 14:34:34 +0200
Subject: [PATCH 1263/1889] share check_all_outcomes impl, and increase max
 iteration counts

---
 .../miri/tests/pass/0weak_memory/weak.rs      | 33 ++---------------
 src/tools/miri/tests/pass/float_nan.rs        | 37 +++----------------
 src/tools/miri/tests/utils/mod.rs             | 35 ++++++++++++++++++
 3 files changed, 45 insertions(+), 60 deletions(-)

diff --git a/src/tools/miri/tests/pass/0weak_memory/weak.rs b/src/tools/miri/tests/pass/0weak_memory/weak.rs
index c752fc114ba57..611733d0dac52 100644
--- a/src/tools/miri/tests/pass/0weak_memory/weak.rs
+++ b/src/tools/miri/tests/pass/0weak_memory/weak.rs
@@ -13,6 +13,10 @@ use std::sync::atomic::Ordering::*;
 use std::sync::atomic::{AtomicUsize, fence};
 use std::thread::spawn;
 
+#[path = "../../utils/mod.rs"]
+mod utils;
+use utils::check_all_outcomes;
+
 #[allow(dead_code)]
 #[derive(Copy, Clone)]
 struct EvilSend<T>(pub T);
@@ -33,35 +37,6 @@ fn spin_until(loc: &AtomicUsize, val: usize) -> usize {
     val
 }
 
-/// Check that the function produces the intended set of outcomes.
-#[track_caller]
-fn check_all_outcomes<T: Eq + std::hash::Hash + std::fmt::Debug>(
-    expected: impl IntoIterator<Item = T>,
-    generate: impl Fn() -> T,
-) {
-    use std::collections::HashSet;
-
-    let expected: HashSet<T> = HashSet::from_iter(expected);
-    let mut seen = HashSet::new();
-    // Let's give it N times as many tries as we are expecting values.
-    let tries = expected.len() * 16;
-    for i in 0..tries {
-        let val = generate();
-        assert!(expected.contains(&val), "got an unexpected value: {val:?}");
-        seen.insert(val);
-        if i > tries / 2 && expected.len() == seen.len() {
-            // We saw everything and we did quite a few tries, let's avoid wasting time.
-            return;
-        }
-    }
-    // Let's see if we saw them all.
-    for val in expected {
-        if !seen.contains(&val) {
-            panic!("did not get value that should be possible: {val:?}");
-        }
-    }
-}
-
 fn relaxed() {
     check_all_outcomes([0, 1, 2], || {
         let x = static_atomic(0);
diff --git a/src/tools/miri/tests/pass/float_nan.rs b/src/tools/miri/tests/pass/float_nan.rs
index 902816307403a..c07ffdf9740c4 100644
--- a/src/tools/miri/tests/pass/float_nan.rs
+++ b/src/tools/miri/tests/pass/float_nan.rs
@@ -5,6 +5,10 @@
 use std::fmt;
 use std::hint::black_box;
 
+#[path = "../utils/mod.rs"]
+mod utils;
+use utils::check_all_outcomes;
+
 fn ldexp(a: f64, b: i32) -> f64 {
     extern "C" {
         fn ldexp(x: f64, n: i32) -> f64;
@@ -26,35 +30,6 @@ enum NaNKind {
 }
 use NaNKind::*;
 
-/// Check that the function produces the intended set of outcomes.
-#[track_caller]
-fn check_all_outcomes<T: Eq + std::hash::Hash + fmt::Display>(
-    expected: impl IntoIterator<Item = T>,
-    generate: impl Fn() -> T,
-) {
-    use std::collections::HashSet;
-
-    let expected: HashSet<T> = HashSet::from_iter(expected);
-    let mut seen = HashSet::new();
-    // Let's give it N times as many tries as we are expecting values.
-    let tries = expected.len() * 12;
-    for i in 0..tries {
-        let val = generate();
-        assert!(expected.contains(&val), "got an unexpected value: {val}");
-        seen.insert(val);
-        if i > tries / 2 && expected.len() == seen.len() {
-            // We saw everything and we did quite a few tries, let's avoid wasting time.
-            return;
-        }
-    }
-    // Let's see if we saw them all.
-    for val in expected {
-        if !seen.contains(&val) {
-            panic!("did not get value that should be possible: {val}");
-        }
-    }
-}
-
 // -- f32 support
 #[repr(C)]
 #[derive(Copy, Clone, Eq, PartialEq, Hash)]
@@ -81,7 +56,7 @@ const F32_EXP: u32 = 8; // 8 bits of exponent
 const F32_MANTISSA: u32 = F32_SIGN_BIT - F32_EXP;
 const F32_NAN_PAYLOAD: u32 = F32_MANTISSA - 1;
 
-impl fmt::Display for F32 {
+impl fmt::Debug for F32 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         // Alaways show raw bits.
         write!(f, "0x{:08x} ", self.0)?;
@@ -154,7 +129,7 @@ const F64_EXP: u32 = 11; // 11 bits of exponent
 const F64_MANTISSA: u32 = F64_SIGN_BIT - F64_EXP;
 const F64_NAN_PAYLOAD: u32 = F64_MANTISSA - 1;
 
-impl fmt::Display for F64 {
+impl fmt::Debug for F64 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         // Alaways show raw bits.
         write!(f, "0x{:08x} ", self.0)?;
diff --git a/src/tools/miri/tests/utils/mod.rs b/src/tools/miri/tests/utils/mod.rs
index 138ada4e20d7a..459fea404ea3c 100644
--- a/src/tools/miri/tests/utils/mod.rs
+++ b/src/tools/miri/tests/utils/mod.rs
@@ -16,3 +16,38 @@ pub fn run_provenance_gc() {
     // SAFETY: No preconditions. The GC is fine to run at any time.
     unsafe { miri_run_provenance_gc() }
 }
+
+/// Check that the function produces the intended set of outcomes.
+#[track_caller]
+pub fn check_all_outcomes<T: Eq + std::hash::Hash + std::fmt::Debug>(
+    expected: impl IntoIterator<Item = T>,
+    generate: impl Fn() -> T,
+) {
+    use std::collections::HashSet;
+
+    let expected: HashSet<T> = HashSet::from_iter(expected);
+    let mut seen = HashSet::new();
+    // Let's give it N times as many tries as we are expecting values.
+    let min_tries = std::cmp::max(20, expected.len() * 4);
+    let max_tries = expected.len() * 50;
+    for i in 0..max_tries {
+        let val = generate();
+        assert!(expected.contains(&val), "got an unexpected value: {val:?}");
+        seen.insert(val);
+        if i >= min_tries && expected.len() == seen.len() {
+            // We saw everything and we did enough tries, let's avoid wasting time.
+            return;
+        }
+    }
+    // Let's see if we saw them all.
+    if expected.len() == seen.len() {
+        return;
+    }
+    // Find the missing one.
+    for val in expected {
+        if !seen.contains(&val) {
+            panic!("did not get value that should be possible: {val:?}");
+        }
+    }
+    unreachable!()
+}

From 37de09fed92a2814d93faff6e789c34d2a18718e Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 22 Sep 2025 14:49:13 +0200
Subject: [PATCH 1264/1889] share the check_nondet helper as well

---
 src/tools/miri/tests/pass/float.rs            | 194 ++++++++----------
 .../intrinsics/fmuladd_nondeterministic.rs    | 103 ++++------
 src/tools/miri/tests/utils/mod.rs             |  15 ++
 3 files changed, 138 insertions(+), 174 deletions(-)

diff --git a/src/tools/miri/tests/pass/float.rs b/src/tools/miri/tests/pass/float.rs
index 3ce5ea8356bd5..8570addeedd20 100644
--- a/src/tools/miri/tests/pass/float.rs
+++ b/src/tools/miri/tests/pass/float.rs
@@ -8,12 +8,16 @@
 #![allow(internal_features)]
 #![allow(unnecessary_transmutes)]
 
+#[path = "../utils/mod.rs"]
+mod utils;
 use std::any::type_name;
 use std::cmp::min;
 use std::fmt::{Debug, Display, LowerHex};
 use std::hint::black_box;
 use std::{f32, f64};
 
+use utils::check_nondet;
+
 /// Compare the two floats, allowing for $ulp many ULPs of error.
 ///
 /// ULP means "Units in the Last Place" or "Units of Least Precision".
@@ -1429,29 +1433,14 @@ fn test_fmuladd() {
 
 /// `min` and `max` on equal arguments are non-deterministic.
 fn test_min_max_nondet() {
-    /// Ensure that if we call the closure often enough, we see both `true` and `false.`
-    #[track_caller]
-    fn ensure_both(f: impl Fn() -> bool) {
-        let rounds = 32;
-        let first = f();
-        for _ in 1..rounds {
-            if f() != first {
-                // We saw two different values!
-                return;
-            }
-        }
-        // We saw the same thing N times.
-        panic!("expected non-determinism, got {rounds} times the same result: {first:?}");
-    }
-
-    ensure_both(|| f16::min(0.0, -0.0).is_sign_positive());
-    ensure_both(|| f16::max(0.0, -0.0).is_sign_positive());
-    ensure_both(|| f32::min(0.0, -0.0).is_sign_positive());
-    ensure_both(|| f32::max(0.0, -0.0).is_sign_positive());
-    ensure_both(|| f64::min(0.0, -0.0).is_sign_positive());
-    ensure_both(|| f64::max(0.0, -0.0).is_sign_positive());
-    ensure_both(|| f128::min(0.0, -0.0).is_sign_positive());
-    ensure_both(|| f128::max(0.0, -0.0).is_sign_positive());
+    check_nondet(|| f16::min(0.0, -0.0).is_sign_positive());
+    check_nondet(|| f16::max(0.0, -0.0).is_sign_positive());
+    check_nondet(|| f32::min(0.0, -0.0).is_sign_positive());
+    check_nondet(|| f32::max(0.0, -0.0).is_sign_positive());
+    check_nondet(|| f64::min(0.0, -0.0).is_sign_positive());
+    check_nondet(|| f64::max(0.0, -0.0).is_sign_positive());
+    check_nondet(|| f128::min(0.0, -0.0).is_sign_positive());
+    check_nondet(|| f128::max(0.0, -0.0).is_sign_positive());
 }
 
 fn test_non_determinism() {
@@ -1461,35 +1450,20 @@ fn test_non_determinism() {
     };
     use std::{f32, f64};
 
-    /// Ensure that the operation is non-deterministic
-    #[track_caller]
-    fn ensure_nondet<T: PartialEq + std::fmt::Debug>(f: impl Fn() -> T) {
-        let rounds = 16;
-        let first = f();
-        for _ in 1..rounds {
-            if f() != first {
-                // We saw two different values!
-                return;
-            }
-        }
-        // We saw the same thing N times.
-        panic!("expected non-determinism, got {rounds} times the same result: {first:?}");
-    }
-
     macro_rules! test_operations_f {
         ($a:expr, $b:expr) => {
-            ensure_nondet(|| fadd_algebraic($a, $b));
-            ensure_nondet(|| fsub_algebraic($a, $b));
-            ensure_nondet(|| fmul_algebraic($a, $b));
-            ensure_nondet(|| fdiv_algebraic($a, $b));
-            ensure_nondet(|| frem_algebraic($a, $b));
+            check_nondet(|| fadd_algebraic($a, $b));
+            check_nondet(|| fsub_algebraic($a, $b));
+            check_nondet(|| fmul_algebraic($a, $b));
+            check_nondet(|| fdiv_algebraic($a, $b));
+            check_nondet(|| frem_algebraic($a, $b));
 
             unsafe {
-                ensure_nondet(|| fadd_fast($a, $b));
-                ensure_nondet(|| fsub_fast($a, $b));
-                ensure_nondet(|| fmul_fast($a, $b));
-                ensure_nondet(|| fdiv_fast($a, $b));
-                ensure_nondet(|| frem_fast($a, $b));
+                check_nondet(|| fadd_fast($a, $b));
+                check_nondet(|| fsub_fast($a, $b));
+                check_nondet(|| fmul_fast($a, $b));
+                check_nondet(|| fdiv_fast($a, $b));
+                check_nondet(|| frem_fast($a, $b));
             }
         };
     }
@@ -1499,70 +1473,70 @@ fn test_non_determinism() {
     }
     pub fn test_operations_f32(a: f32, b: f32) {
         test_operations_f!(a, b);
-        ensure_nondet(|| a.powf(b));
-        ensure_nondet(|| a.powi(2));
-        ensure_nondet(|| a.log(b));
-        ensure_nondet(|| a.exp());
-        ensure_nondet(|| 10f32.exp2());
-        ensure_nondet(|| f32::consts::E.ln());
-        ensure_nondet(|| 10f32.log10());
-        ensure_nondet(|| 8f32.log2());
-        ensure_nondet(|| 1f32.ln_1p());
-        ensure_nondet(|| 27.0f32.cbrt());
-        ensure_nondet(|| 3.0f32.hypot(4.0f32));
-        ensure_nondet(|| 1f32.sin());
-        ensure_nondet(|| 1f32.cos());
+        check_nondet(|| a.powf(b));
+        check_nondet(|| a.powi(2));
+        check_nondet(|| a.log(b));
+        check_nondet(|| a.exp());
+        check_nondet(|| 10f32.exp2());
+        check_nondet(|| f32::consts::E.ln());
+        check_nondet(|| 10f32.log10());
+        check_nondet(|| 8f32.log2());
+        check_nondet(|| 1f32.ln_1p());
+        check_nondet(|| 27.0f32.cbrt());
+        check_nondet(|| 3.0f32.hypot(4.0f32));
+        check_nondet(|| 1f32.sin());
+        check_nondet(|| 1f32.cos());
         // On i686-pc-windows-msvc , these functions are implemented by calling the `f64` version,
         // which means the little rounding errors Miri introduces are discarded by the cast down to
         // `f32`. Just skip the test for them.
         if !cfg!(all(target_os = "windows", target_env = "msvc", target_arch = "x86")) {
-            ensure_nondet(|| 1.0f32.tan());
-            ensure_nondet(|| 1.0f32.asin());
-            ensure_nondet(|| 5.0f32.acos());
-            ensure_nondet(|| 1.0f32.atan());
-            ensure_nondet(|| 1.0f32.atan2(2.0f32));
-            ensure_nondet(|| 1.0f32.sinh());
-            ensure_nondet(|| 1.0f32.cosh());
-            ensure_nondet(|| 1.0f32.tanh());
+            check_nondet(|| 1.0f32.tan());
+            check_nondet(|| 1.0f32.asin());
+            check_nondet(|| 5.0f32.acos());
+            check_nondet(|| 1.0f32.atan());
+            check_nondet(|| 1.0f32.atan2(2.0f32));
+            check_nondet(|| 1.0f32.sinh());
+            check_nondet(|| 1.0f32.cosh());
+            check_nondet(|| 1.0f32.tanh());
         }
-        ensure_nondet(|| 1.0f32.asinh());
-        ensure_nondet(|| 2.0f32.acosh());
-        ensure_nondet(|| 0.5f32.atanh());
-        ensure_nondet(|| 5.0f32.gamma());
-        ensure_nondet(|| 5.0f32.ln_gamma());
-        ensure_nondet(|| 5.0f32.erf());
-        ensure_nondet(|| 5.0f32.erfc());
+        check_nondet(|| 1.0f32.asinh());
+        check_nondet(|| 2.0f32.acosh());
+        check_nondet(|| 0.5f32.atanh());
+        check_nondet(|| 5.0f32.gamma());
+        check_nondet(|| 5.0f32.ln_gamma());
+        check_nondet(|| 5.0f32.erf());
+        check_nondet(|| 5.0f32.erfc());
     }
     pub fn test_operations_f64(a: f64, b: f64) {
         test_operations_f!(a, b);
-        ensure_nondet(|| a.powf(b));
-        ensure_nondet(|| a.powi(2));
-        ensure_nondet(|| a.log(b));
-        ensure_nondet(|| a.exp());
-        ensure_nondet(|| 50f64.exp2());
-        ensure_nondet(|| 3f64.ln());
-        ensure_nondet(|| f64::consts::E.log10());
-        ensure_nondet(|| f64::consts::E.log2());
-        ensure_nondet(|| 1f64.ln_1p());
-        ensure_nondet(|| 27.0f64.cbrt());
-        ensure_nondet(|| 3.0f64.hypot(4.0f64));
-        ensure_nondet(|| 1f64.sin());
-        ensure_nondet(|| 1f64.cos());
-        ensure_nondet(|| 1.0f64.tan());
-        ensure_nondet(|| 1.0f64.asin());
-        ensure_nondet(|| 5.0f64.acos());
-        ensure_nondet(|| 1.0f64.atan());
-        ensure_nondet(|| 1.0f64.atan2(2.0f64));
-        ensure_nondet(|| 1.0f64.sinh());
-        ensure_nondet(|| 1.0f64.cosh());
-        ensure_nondet(|| 1.0f64.tanh());
-        ensure_nondet(|| 1.0f64.asinh());
-        ensure_nondet(|| 3.0f64.acosh());
-        ensure_nondet(|| 0.5f64.atanh());
-        ensure_nondet(|| 5.0f64.gamma());
-        ensure_nondet(|| 5.0f64.ln_gamma());
-        ensure_nondet(|| 5.0f64.erf());
-        ensure_nondet(|| 5.0f64.erfc());
+        check_nondet(|| a.powf(b));
+        check_nondet(|| a.powi(2));
+        check_nondet(|| a.log(b));
+        check_nondet(|| a.exp());
+        check_nondet(|| 50f64.exp2());
+        check_nondet(|| 3f64.ln());
+        check_nondet(|| f64::consts::E.log10());
+        check_nondet(|| f64::consts::E.log2());
+        check_nondet(|| 1f64.ln_1p());
+        check_nondet(|| 27.0f64.cbrt());
+        check_nondet(|| 3.0f64.hypot(4.0f64));
+        check_nondet(|| 1f64.sin());
+        check_nondet(|| 1f64.cos());
+        check_nondet(|| 1.0f64.tan());
+        check_nondet(|| 1.0f64.asin());
+        check_nondet(|| 5.0f64.acos());
+        check_nondet(|| 1.0f64.atan());
+        check_nondet(|| 1.0f64.atan2(2.0f64));
+        check_nondet(|| 1.0f64.sinh());
+        check_nondet(|| 1.0f64.cosh());
+        check_nondet(|| 1.0f64.tanh());
+        check_nondet(|| 1.0f64.asinh());
+        check_nondet(|| 3.0f64.acosh());
+        check_nondet(|| 0.5f64.atanh());
+        check_nondet(|| 5.0f64.gamma());
+        check_nondet(|| 5.0f64.ln_gamma());
+        check_nondet(|| 5.0f64.erf());
+        check_nondet(|| 5.0f64.erfc());
     }
     pub fn test_operations_f128(a: f128, b: f128) {
         test_operations_f!(a, b);
@@ -1574,15 +1548,15 @@ fn test_non_determinism() {
     test_operations_f128(25., 18.);
 
     // SNaN^0 = (1 | NaN)
-    ensure_nondet(|| f32::powf(SNAN_F32, 0.0).is_nan());
-    ensure_nondet(|| f64::powf(SNAN_F64, 0.0).is_nan());
+    check_nondet(|| f32::powf(SNAN_F32, 0.0).is_nan());
+    check_nondet(|| f64::powf(SNAN_F64, 0.0).is_nan());
 
     // 1^SNaN = (1 | NaN)
-    ensure_nondet(|| f32::powf(1.0, SNAN_F32).is_nan());
-    ensure_nondet(|| f64::powf(1.0, SNAN_F64).is_nan());
+    check_nondet(|| f32::powf(1.0, SNAN_F32).is_nan());
+    check_nondet(|| f64::powf(1.0, SNAN_F64).is_nan());
 
     // same as powf (keep it consistent):
     // x^SNaN = (1 | NaN)
-    ensure_nondet(|| f32::powi(SNAN_F32, 0).is_nan());
-    ensure_nondet(|| f64::powi(SNAN_F64, 0).is_nan());
+    check_nondet(|| f32::powi(SNAN_F32, 0).is_nan());
+    check_nondet(|| f64::powi(SNAN_F64, 0).is_nan());
 }
diff --git a/src/tools/miri/tests/pass/intrinsics/fmuladd_nondeterministic.rs b/src/tools/miri/tests/pass/intrinsics/fmuladd_nondeterministic.rs
index b688405c4b184..401b2911f809a 100644
--- a/src/tools/miri/tests/pass/intrinsics/fmuladd_nondeterministic.rs
+++ b/src/tools/miri/tests/pass/intrinsics/fmuladd_nondeterministic.rs
@@ -3,73 +3,48 @@ use std::intrinsics::simd::simd_relaxed_fma;
 use std::intrinsics::{fmuladdf32, fmuladdf64};
 use std::simd::prelude::*;
 
-fn ensure_both_happen(f: impl Fn() -> bool) -> bool {
-    let mut saw_true = false;
-    let mut saw_false = false;
-    for _ in 0..50 {
-        let b = f();
-        if b {
-            saw_true = true;
-        } else {
-            saw_false = true;
-        }
-        if saw_true && saw_false {
-            return true;
-        }
-    }
-    false
-}
+#[path = "../../utils/mod.rs"]
+mod utils;
+use utils::check_nondet;
 
 fn main() {
-    assert!(
-        ensure_both_happen(|| {
-            let a = std::hint::black_box(0.1_f64);
-            let b = std::hint::black_box(0.2);
-            let c = std::hint::black_box(-a * b);
-            // It is unspecified whether the following operation is fused or not. The
-            // following evaluates to 0.0 if unfused, and nonzero (-1.66e-18) if fused.
-            let x = unsafe { fmuladdf64(a, b, c) };
-            x == 0.0
-        }),
-        "`fmuladdf64` failed to be evaluated as both fused and unfused"
-    );
+    check_nondet(|| {
+        let a = std::hint::black_box(0.1_f64);
+        let b = std::hint::black_box(0.2);
+        let c = std::hint::black_box(-a * b);
+        // It is unspecified whether the following operation is fused or not. The
+        // following evaluates to 0.0 if unfused, and nonzero (-1.66e-18) if fused.
+        let x = unsafe { fmuladdf64(a, b, c) };
+        x == 0.0
+    });
 
-    assert!(
-        ensure_both_happen(|| {
-            let a = std::hint::black_box(0.1_f32);
-            let b = std::hint::black_box(0.2);
-            let c = std::hint::black_box(-a * b);
-            // It is unspecified whether the following operation is fused or not. The
-            // following evaluates to 0.0 if unfused, and nonzero (-8.1956386e-10) if fused.
-            let x = unsafe { fmuladdf32(a, b, c) };
-            x == 0.0
-        }),
-        "`fmuladdf32` failed to be evaluated as both fused and unfused"
-    );
+    check_nondet(|| {
+        let a = std::hint::black_box(0.1_f32);
+        let b = std::hint::black_box(0.2);
+        let c = std::hint::black_box(-a * b);
+        // It is unspecified whether the following operation is fused or not. The
+        // following evaluates to 0.0 if unfused, and nonzero (-8.1956386e-10) if fused.
+        let x = unsafe { fmuladdf32(a, b, c) };
+        x == 0.0
+    });
 
-    assert!(
-        ensure_both_happen(|| {
-            let a = f32x4::splat(std::hint::black_box(0.1));
-            let b = f32x4::splat(std::hint::black_box(0.2));
-            let c = std::hint::black_box(-a * b);
-            let x = unsafe { simd_relaxed_fma(a, b, c) };
-            // Whether we fuse or not is a per-element decision, so sometimes these should be
-            // the same and sometimes not.
-            x[0] == x[1]
-        }),
-        "`simd_relaxed_fma` failed to be evaluated as both fused and unfused"
-    );
+    check_nondet(|| {
+        let a = f32x4::splat(std::hint::black_box(0.1));
+        let b = f32x4::splat(std::hint::black_box(0.2));
+        let c = std::hint::black_box(-a * b);
+        let x = unsafe { simd_relaxed_fma(a, b, c) };
+        // Whether we fuse or not is a per-element decision, so sometimes these should be
+        // the same and sometimes not.
+        x[0] == x[1]
+    });
 
-    assert!(
-        ensure_both_happen(|| {
-            let a = f64x4::splat(std::hint::black_box(0.1));
-            let b = f64x4::splat(std::hint::black_box(0.2));
-            let c = std::hint::black_box(-a * b);
-            let x = unsafe { simd_relaxed_fma(a, b, c) };
-            // Whether we fuse or not is a per-element decision, so sometimes these should be
-            // the same and sometimes not.
-            x[0] == x[1]
-        }),
-        "`simd_relaxed_fma` failed to be evaluated as both fused and unfused"
-    );
+    check_nondet(|| {
+        let a = f64x4::splat(std::hint::black_box(0.1));
+        let b = f64x4::splat(std::hint::black_box(0.2));
+        let c = std::hint::black_box(-a * b);
+        let x = unsafe { simd_relaxed_fma(a, b, c) };
+        // Whether we fuse or not is a per-element decision, so sometimes these should be
+        // the same and sometimes not.
+        x[0] == x[1]
+    });
 }
diff --git a/src/tools/miri/tests/utils/mod.rs b/src/tools/miri/tests/utils/mod.rs
index 459fea404ea3c..37f9996216343 100644
--- a/src/tools/miri/tests/utils/mod.rs
+++ b/src/tools/miri/tests/utils/mod.rs
@@ -51,3 +51,18 @@ pub fn check_all_outcomes<T: Eq + std::hash::Hash + std::fmt::Debug>(
     }
     unreachable!()
 }
+
+/// Check that the operation is non-deterministic
+#[track_caller]
+pub fn check_nondet<T: PartialEq + std::fmt::Debug>(f: impl Fn() -> T) {
+    let rounds = 50;
+    let first = f();
+    for _ in 1..rounds {
+        if f() != first {
+            // We saw two different values!
+            return;
+        }
+    }
+    // We saw the same thing N times.
+    panic!("expected non-determinism, got {rounds} times the same result: {first:?}");
+}

From 823337a4ade5e559d485904b685e8f2cef4a3a2c Mon Sep 17 00:00:00 2001
From: Taiki Endo <te316e89@gmail.com>
Date: Mon, 22 Sep 2025 22:15:25 +0900
Subject: [PATCH 1265/1889] Remove unused #![feature(get_mut_unchecked)] in Rc
 and Arc examples

---
 library/alloc/src/rc.rs   | 9 ---------
 library/alloc/src/sync.rs | 9 ---------
 2 files changed, 18 deletions(-)

diff --git a/library/alloc/src/rc.rs b/library/alloc/src/rc.rs
index fcb466778a3fb..aed3357afbf4b 100644
--- a/library/alloc/src/rc.rs
+++ b/library/alloc/src/rc.rs
@@ -480,8 +480,6 @@ impl<T> Rc<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(get_mut_unchecked)]
-    ///
     /// use std::rc::Rc;
     ///
     /// let mut five = Rc::<u32>::new_uninit();
@@ -572,7 +570,6 @@ impl<T> Rc<T> {
     ///
     /// ```
     /// #![feature(allocator_api)]
-    /// #![feature(get_mut_unchecked)]
     ///
     /// use std::rc::Rc;
     ///
@@ -1014,8 +1011,6 @@ impl<T> Rc<[T]> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(get_mut_unchecked)]
-    ///
     /// use std::rc::Rc;
     ///
     /// let mut values = Rc::<[u32]>::new_uninit_slice(3);
@@ -1181,8 +1176,6 @@ impl<T, A: Allocator> Rc<mem::MaybeUninit<T>, A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(get_mut_unchecked)]
-    ///
     /// use std::rc::Rc;
     ///
     /// let mut five = Rc::<u32>::new_uninit();
@@ -1218,8 +1211,6 @@ impl<T, A: Allocator> Rc<[mem::MaybeUninit<T>], A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(get_mut_unchecked)]
-    ///
     /// use std::rc::Rc;
     ///
     /// let mut values = Rc::<[u32]>::new_uninit_slice(3);
diff --git a/library/alloc/src/sync.rs b/library/alloc/src/sync.rs
index 32396cccb8fca..a466b74944c5d 100644
--- a/library/alloc/src/sync.rs
+++ b/library/alloc/src/sync.rs
@@ -480,8 +480,6 @@ impl<T> Arc<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(get_mut_unchecked)]
-    ///
     /// use std::sync::Arc;
     ///
     /// let mut five = Arc::<u32>::new_uninit();
@@ -586,7 +584,6 @@ impl<T> Arc<T> {
     ///
     /// ```
     /// #![feature(allocator_api)]
-    /// #![feature(get_mut_unchecked)]
     ///
     /// use std::sync::Arc;
     ///
@@ -1156,8 +1153,6 @@ impl<T> Arc<[T]> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(get_mut_unchecked)]
-    ///
     /// use std::sync::Arc;
     ///
     /// let mut values = Arc::<[u32]>::new_uninit_slice(3);
@@ -1326,8 +1321,6 @@ impl<T, A: Allocator> Arc<mem::MaybeUninit<T>, A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(get_mut_unchecked)]
-    ///
     /// use std::sync::Arc;
     ///
     /// let mut five = Arc::<u32>::new_uninit();
@@ -1364,8 +1357,6 @@ impl<T, A: Allocator> Arc<[mem::MaybeUninit<T>], A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(get_mut_unchecked)]
-    ///
     /// use std::sync::Arc;
     ///
     /// let mut values = Arc::<[u32]>::new_uninit_slice(3);

From 8a0e3808c04c16732c4651884c2a28063f4eec43 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 22 Sep 2025 18:46:18 +0530
Subject: [PATCH 1266/1889] add check for toml file

---
 src/bootstrap/src/core/config/tests.rs    | 13 +++----------
 src/bootstrap/src/core/config/toml/mod.rs |  6 ++++++
 2 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/src/bootstrap/src/core/config/tests.rs b/src/bootstrap/src/core/config/tests.rs
index f277e3704f277..3390e9586a4c7 100644
--- a/src/bootstrap/src/core/config/tests.rs
+++ b/src/bootstrap/src/core/config/tests.rs
@@ -307,10 +307,11 @@ fn clippy_rule_separate_prefix() {
 
 #[test]
 fn verbose_tests_default_value() {
-    let config = Config::parse(Flags::parse(&["build".into(), "compiler".into()]));
+    let config = TestCtx::new().config("build").args(&["compiler".into()]).create_config();
     assert_eq!(config.verbose_tests, false);
 
-    let config = Config::parse(Flags::parse(&["build".into(), "compiler".into(), "-v".into()]));
+    let config =
+        TestCtx::new().config("build").args(&["compiler".into(), "-v".into()]).create_config();
     assert_eq!(config.verbose_tests, true);
 }
 
@@ -643,18 +644,10 @@ fn test_include_precedence_over_profile() {
     "#;
     File::create(extension).unwrap().write_all(extension_content).unwrap();
 
-    let root_config = testdir.join("config.toml");
-    let root_config_content = br#"
-        profile = "dist"
-        include = ["./extension.toml"]
-    "#;
-    File::create(&root_config).unwrap().write_all(root_config_content).unwrap();
-
     let config = test_ctx
         .config("check")
         .with_default_toml_config(
             r#"
-        profile = "dist"
         include = ["./extension.toml"]
     "#,
         )
diff --git a/src/bootstrap/src/core/config/toml/mod.rs b/src/bootstrap/src/core/config/toml/mod.rs
index f6dc5b67e1010..5f86d2e728184 100644
--- a/src/bootstrap/src/core/config/toml/mod.rs
+++ b/src/bootstrap/src/core/config/toml/mod.rs
@@ -152,6 +152,12 @@ impl Config {
     }
 
     pub(crate) fn get_toml(file: &Path) -> Result<TomlConfig, toml::de::Error> {
+        #[cfg(test)]
+        {
+            let tmp = std::env::temp_dir();
+            assert!(file.starts_with(&tmp), "Expected path in temp dir {:?}, got {:?}", tmp, file);
+        }
+
         Self::get_toml_inner(file)
     }
 

From 83b784fda12a3422bfa7ce14c1bbd9864df70e5e Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 22 Sep 2025 18:54:23 +0530
Subject: [PATCH 1267/1889] add comment explaining the test_build_dir

---
 src/bootstrap/src/core/config/config.rs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index 957de5367ef6a..280ae088f3f3d 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -2479,6 +2479,13 @@ fn find_correct_section_for_field(field_name: &str) -> Vec<WouldBeValidFor> {
         .collect()
 }
 
+/// Resolve the build directory used for tests.
+///
+/// - When tests are run through bootstrap (`x.py test`), the build system
+///   sets `CARGO_TARGET_DIR`, so we can trust and use it here.
+/// - When tests are run directly with cargo test, `CARGO_TARGET_DIR` will
+///   not be set. In that case we fall back to resolving relative to
+///   `CARGO_MANIFEST_DIR`, by walking two parents up and appending `build`.
 fn test_build_dir() -> PathBuf {
     env::var_os("CARGO_TARGET_DIR")
         .map(|value| Path::new(&value).parent().unwrap().to_path_buf())

From a45d58bcb55f3639f07721ca3032d5bec1b0443f Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Mon, 22 Sep 2025 16:53:20 +0300
Subject: [PATCH 1268/1889] Fix lifetime elision handling for `Fn`-style trait
 bounds

Two fixes were needed:

 1. Previously, we enabled elision for the generic args of `Fn` itself, instead of for generic args of paths within it.
 2. In lowering in the new solver the `Output` parameter did not have elision set correctly, I don't know why. In the old lowering it was done correctly.
---
 .../crates/hir-ty/src/lower/path.rs           | 12 ++--
 .../hir-ty/src/lower_nextsolver/path.rs       | 56 ++++++++++++-------
 .../src/handlers/missing_lifetime.rs          | 12 ++++
 3 files changed, 55 insertions(+), 25 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs
index b0132e4dcbc46..bc03298e3bbb0 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs
@@ -603,7 +603,7 @@ impl<'a, 'b> PathLoweringContext<'a, 'b> {
         explicit_self_ty: Option<Ty>,
         lowering_assoc_type_generics: bool,
     ) -> Substitution {
-        let mut lifetime_elision = self.ctx.lifetime_elision.clone();
+        let old_lifetime_elision = self.ctx.lifetime_elision.clone();
 
         if let Some(args) = self.current_or_prev_segment.args_and_bindings
             && args.parenthesized != GenericArgsParentheses::No
@@ -633,19 +633,21 @@ impl<'a, 'b> PathLoweringContext<'a, 'b> {
             }
 
             // `Fn()`-style generics are treated like functions for the purpose of lifetime elision.
-            lifetime_elision =
+            self.ctx.lifetime_elision =
                 LifetimeElisionKind::AnonymousCreateParameter { report_in_path: false };
         }
 
-        self.substs_from_args_and_bindings(
+        let result = self.substs_from_args_and_bindings(
             self.current_or_prev_segment.args_and_bindings,
             def,
             infer_args,
             explicit_self_ty,
             PathGenericsSource::Segment(self.current_segment_u32()),
             lowering_assoc_type_generics,
-            lifetime_elision,
-        )
+            self.ctx.lifetime_elision.clone(),
+        );
+        self.ctx.lifetime_elision = old_lifetime_elision;
+        result
     }
 
     pub(super) fn substs_from_args_and_bindings(
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver/path.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver/path.rs
index 7d6734303c48b..46dc66a8c8bae 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver/path.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver/path.rs
@@ -616,7 +616,7 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
         explicit_self_ty: Option<Ty<'db>>,
         lowering_assoc_type_generics: bool,
     ) -> crate::next_solver::GenericArgs<'db> {
-        let mut lifetime_elision = self.ctx.lifetime_elision.clone();
+        let old_lifetime_elision = self.ctx.lifetime_elision.clone();
 
         if let Some(args) = self.current_or_prev_segment.args_and_bindings
             && args.parenthesized != GenericArgsParentheses::No
@@ -646,19 +646,21 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
             }
 
             // `Fn()`-style generics are treated like functions for the purpose of lifetime elision.
-            lifetime_elision =
+            self.ctx.lifetime_elision =
                 LifetimeElisionKind::AnonymousCreateParameter { report_in_path: false };
         }
 
-        self.substs_from_args_and_bindings(
+        let result = self.substs_from_args_and_bindings(
             self.current_or_prev_segment.args_and_bindings,
             def,
             infer_args,
             explicit_self_ty,
             PathGenericsSource::Segment(self.current_segment_u32()),
             lowering_assoc_type_generics,
-            lifetime_elision,
-        )
+            self.ctx.lifetime_elision.clone(),
+        );
+        self.ctx.lifetime_elision = old_lifetime_elision;
+        result
     }
 
     pub(super) fn substs_from_args_and_bindings(
@@ -915,22 +917,36 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
                     binding.type_ref.as_ref().map_or(0, |_| 1) + binding.bounds.len(),
                 );
                 if let Some(type_ref) = binding.type_ref {
-                    match (&self.ctx.store[type_ref], self.ctx.impl_trait_mode.mode) {
-                        (TypeRef::ImplTrait(_), ImplTraitLoweringMode::Disallowed) => (),
-                        (_, ImplTraitLoweringMode::Disallowed | ImplTraitLoweringMode::Opaque) => {
-                            let ty = self.ctx.lower_ty(type_ref);
-                            let pred = Clause(Predicate::new(
-                                interner,
-                                Binder::dummy(rustc_type_ir::PredicateKind::Clause(
-                                    rustc_type_ir::ClauseKind::Projection(ProjectionPredicate {
-                                        projection_term,
-                                        term: ty.into(),
-                                    }),
-                                )),
-                            ));
-                            predicates.push(pred);
+                    let lifetime_elision =
+                        if args_and_bindings.parenthesized == GenericArgsParentheses::ParenSugar {
+                            // `Fn()`-style generics are elided like functions. This is `Output` (we lower to it in hir-def).
+                            LifetimeElisionKind::for_fn_ret(self.ctx.interner)
+                        } else {
+                            self.ctx.lifetime_elision.clone()
+                        };
+                    self.with_lifetime_elision(lifetime_elision, |this| {
+                        match (&this.ctx.store[type_ref], this.ctx.impl_trait_mode.mode) {
+                            (TypeRef::ImplTrait(_), ImplTraitLoweringMode::Disallowed) => (),
+                            (
+                                _,
+                                ImplTraitLoweringMode::Disallowed | ImplTraitLoweringMode::Opaque,
+                            ) => {
+                                let ty = this.ctx.lower_ty(type_ref);
+                                let pred = Clause(Predicate::new(
+                                    interner,
+                                    Binder::dummy(rustc_type_ir::PredicateKind::Clause(
+                                        rustc_type_ir::ClauseKind::Projection(
+                                            ProjectionPredicate {
+                                                projection_term,
+                                                term: ty.into(),
+                                            },
+                                        ),
+                                    )),
+                                ));
+                                predicates.push(pred);
+                            }
                         }
-                    }
+                    })
                 }
                 for bound in binding.bounds.iter() {
                     predicates.extend(self.ctx.lower_type_bound(
diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_lifetime.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_lifetime.rs
index 76b30745a04d1..b07f9e68f6341 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_lifetime.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_lifetime.rs
@@ -88,4 +88,16 @@ fn bar<const F: Foo>() {}
         "#,
         );
     }
+
+    #[test]
+    fn fn_traits() {
+        check_diagnostics(
+            r#"
+//- minicore: fn
+struct WithLifetime<'a>(&'a ());
+
+fn foo<T: Fn(WithLifetime) -> WithLifetime>() {}
+        "#,
+        );
+    }
 }

From a23d4e16d82953c493c75acc568a2c75a368828c Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Mon, 22 Sep 2025 15:56:27 +0200
Subject: [PATCH 1269/1889] flip1995 is back from vacation

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

diff --git a/triagebot.toml b/triagebot.toml
index 7b19f8658c088..b2fb50918f583 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -60,7 +60,6 @@ contributing_url = "https://github.com/rust-lang/rust-clippy/blob/master/CONTRIB
 users_on_vacation = [
     "matthiaskrgr",
     "Manishearth",
-    "flip1995",
 ]
 
 [assign.owners]

From 5dde557fc49ff0268f9890786ef050802b309a75 Mon Sep 17 00:00:00 2001
From: Nathaniel McCallum <nathaniel@mccallum.life>
Date: Sat, 6 Sep 2025 12:57:18 -0400
Subject: [PATCH 1270/1889] constify {float}::total_cmp()

---
 library/core/src/num/f128.rs          |   3 +-
 library/core/src/num/f16.rs           |   3 +-
 library/core/src/num/f32.rs           |   3 +-
 library/core/src/num/f64.rs           |   3 +-
 library/coretests/tests/floats/mod.rs | 171 +++++++++++++-------------
 5 files changed, 93 insertions(+), 90 deletions(-)

diff --git a/library/core/src/num/f128.rs b/library/core/src/num/f128.rs
index 66c892aadd083..c5323c9d0421a 100644
--- a/library/core/src/num/f128.rs
+++ b/library/core/src/num/f128.rs
@@ -1196,7 +1196,8 @@ impl f128 {
     #[inline]
     #[must_use]
     #[unstable(feature = "f128", issue = "116909")]
-    pub fn total_cmp(&self, other: &Self) -> crate::cmp::Ordering {
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    pub const fn total_cmp(&self, other: &Self) -> crate::cmp::Ordering {
         let mut left = self.to_bits() as i128;
         let mut right = other.to_bits() as i128;
 
diff --git a/library/core/src/num/f16.rs b/library/core/src/num/f16.rs
index 81220065e72a6..77b73b6348924 100644
--- a/library/core/src/num/f16.rs
+++ b/library/core/src/num/f16.rs
@@ -1175,7 +1175,8 @@ impl f16 {
     #[inline]
     #[must_use]
     #[unstable(feature = "f16", issue = "116909")]
-    pub fn total_cmp(&self, other: &Self) -> crate::cmp::Ordering {
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    pub const fn total_cmp(&self, other: &Self) -> crate::cmp::Ordering {
         let mut left = self.to_bits() as i16;
         let mut right = other.to_bits() as i16;
 
diff --git a/library/core/src/num/f32.rs b/library/core/src/num/f32.rs
index cefcf1d1fe2fc..da0ba7fe1db56 100644
--- a/library/core/src/num/f32.rs
+++ b/library/core/src/num/f32.rs
@@ -1353,9 +1353,10 @@ impl f32 {
     /// }
     /// ```
     #[stable(feature = "total_cmp", since = "1.62.0")]
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
     #[must_use]
     #[inline]
-    pub fn total_cmp(&self, other: &Self) -> crate::cmp::Ordering {
+    pub const fn total_cmp(&self, other: &Self) -> crate::cmp::Ordering {
         let mut left = self.to_bits() as i32;
         let mut right = other.to_bits() as i32;
 
diff --git a/library/core/src/num/f64.rs b/library/core/src/num/f64.rs
index 9dd1141e70331..c93056e310635 100644
--- a/library/core/src/num/f64.rs
+++ b/library/core/src/num/f64.rs
@@ -1351,9 +1351,10 @@ impl f64 {
     /// }
     /// ```
     #[stable(feature = "total_cmp", since = "1.62.0")]
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
     #[must_use]
     #[inline]
-    pub fn total_cmp(&self, other: &Self) -> crate::cmp::Ordering {
+    pub const fn total_cmp(&self, other: &Self) -> crate::cmp::Ordering {
         let mut left = self.to_bits() as i64;
         let mut right = other.to_bits() as i64;
 
diff --git a/library/coretests/tests/floats/mod.rs b/library/coretests/tests/floats/mod.rs
index 31515561c637b..d2b5722309445 100644
--- a/library/coretests/tests/floats/mod.rs
+++ b/library/coretests/tests/floats/mod.rs
@@ -1246,104 +1246,103 @@ float_test! {
 float_test! {
     name: total_cmp,
     attrs: {
-        const: #[cfg(false)],
         f16: #[cfg(all(not(miri), target_has_reliable_f16_math))],
         f128: #[cfg(all(not(miri), target_has_reliable_f128_math))],
     },
     test<Float> {
         use core::cmp::Ordering;
 
-        fn quiet_bit_mask() -> <Float as TestableFloat>::Int {
+        const fn quiet_bit_mask() -> <Float as TestableFloat>::Int {
             1 << (Float::MANTISSA_DIGITS - 2)
         }
 
-        fn q_nan() -> Float {
+        const fn q_nan() -> Float {
             Float::from_bits(Float::NAN.to_bits() | quiet_bit_mask())
         }
 
-        assert_eq!(Ordering::Equal, Float::total_cmp(&-q_nan(), &-q_nan()));
-        assert_eq!(Ordering::Equal, Float::total_cmp(&-Float::INFINITY, &-Float::INFINITY));
-        assert_eq!(Ordering::Equal, Float::total_cmp(&-Float::MAX, &-Float::MAX));
-        assert_eq!(Ordering::Equal, Float::total_cmp(&-2.5, &-2.5));
-        assert_eq!(Ordering::Equal, Float::total_cmp(&-1.0, &-1.0));
-        assert_eq!(Ordering::Equal, Float::total_cmp(&-1.5, &-1.5));
-        assert_eq!(Ordering::Equal, Float::total_cmp(&-0.5, &-0.5));
-        assert_eq!(Ordering::Equal, Float::total_cmp(&-Float::MIN_POSITIVE, &-Float::MIN_POSITIVE));
-        assert_eq!(Ordering::Equal, Float::total_cmp(&-Float::MAX_SUBNORMAL, &-Float::MAX_SUBNORMAL));
-        assert_eq!(Ordering::Equal, Float::total_cmp(&-Float::TINY, &-Float::TINY));
-        assert_eq!(Ordering::Equal, Float::total_cmp(&-0.0, &-0.0));
-        assert_eq!(Ordering::Equal, Float::total_cmp(&0.0, &0.0));
-        assert_eq!(Ordering::Equal, Float::total_cmp(&Float::TINY, &Float::TINY));
-        assert_eq!(Ordering::Equal, Float::total_cmp(&Float::MAX_SUBNORMAL, &Float::MAX_SUBNORMAL));
-        assert_eq!(Ordering::Equal, Float::total_cmp(&Float::MIN_POSITIVE, &Float::MIN_POSITIVE));
-        assert_eq!(Ordering::Equal, Float::total_cmp(&0.5, &0.5));
-        assert_eq!(Ordering::Equal, Float::total_cmp(&1.0, &1.0));
-        assert_eq!(Ordering::Equal, Float::total_cmp(&1.5, &1.5));
-        assert_eq!(Ordering::Equal, Float::total_cmp(&2.5, &2.5));
-        assert_eq!(Ordering::Equal, Float::total_cmp(&Float::MAX, &Float::MAX));
-        assert_eq!(Ordering::Equal, Float::total_cmp(&Float::INFINITY, &Float::INFINITY));
-        assert_eq!(Ordering::Equal, Float::total_cmp(&q_nan(), &q_nan()));
-
-        assert_eq!(Ordering::Less, Float::total_cmp(&-Float::INFINITY, &-Float::MAX));
-        assert_eq!(Ordering::Less, Float::total_cmp(&-Float::MAX, &-2.5));
-        assert_eq!(Ordering::Less, Float::total_cmp(&-2.5, &-1.5));
-        assert_eq!(Ordering::Less, Float::total_cmp(&-1.5, &-1.0));
-        assert_eq!(Ordering::Less, Float::total_cmp(&-1.0, &-0.5));
-        assert_eq!(Ordering::Less, Float::total_cmp(&-0.5, &-Float::MIN_POSITIVE));
-        assert_eq!(Ordering::Less, Float::total_cmp(&-Float::MIN_POSITIVE, &-Float::MAX_SUBNORMAL));
-        assert_eq!(Ordering::Less, Float::total_cmp(&-Float::MAX_SUBNORMAL, &-Float::TINY));
-        assert_eq!(Ordering::Less, Float::total_cmp(&-Float::TINY, &-0.0));
-        assert_eq!(Ordering::Less, Float::total_cmp(&-0.0, &0.0));
-        assert_eq!(Ordering::Less, Float::total_cmp(&0.0, &Float::TINY));
-        assert_eq!(Ordering::Less, Float::total_cmp(&Float::TINY, &Float::MAX_SUBNORMAL));
-        assert_eq!(Ordering::Less, Float::total_cmp(&Float::MAX_SUBNORMAL, &Float::MIN_POSITIVE));
-        assert_eq!(Ordering::Less, Float::total_cmp(&Float::MIN_POSITIVE, &0.5));
-        assert_eq!(Ordering::Less, Float::total_cmp(&0.5, &1.0));
-        assert_eq!(Ordering::Less, Float::total_cmp(&1.0, &1.5));
-        assert_eq!(Ordering::Less, Float::total_cmp(&1.5, &2.5));
-        assert_eq!(Ordering::Less, Float::total_cmp(&2.5, &Float::MAX));
-        assert_eq!(Ordering::Less, Float::total_cmp(&Float::MAX, &Float::INFINITY));
-
-        assert_eq!(Ordering::Greater, Float::total_cmp(&-Float::MAX, &-Float::INFINITY));
-        assert_eq!(Ordering::Greater, Float::total_cmp(&-2.5, &-Float::MAX));
-        assert_eq!(Ordering::Greater, Float::total_cmp(&-1.5, &-2.5));
-        assert_eq!(Ordering::Greater, Float::total_cmp(&-1.0, &-1.5));
-        assert_eq!(Ordering::Greater, Float::total_cmp(&-0.5, &-1.0));
-        assert_eq!(Ordering::Greater, Float::total_cmp(&-Float::MIN_POSITIVE, &-0.5));
-        assert_eq!(Ordering::Greater, Float::total_cmp(&-Float::MAX_SUBNORMAL, &-Float::MIN_POSITIVE));
-        assert_eq!(Ordering::Greater, Float::total_cmp(&-Float::TINY, &-Float::MAX_SUBNORMAL));
-        assert_eq!(Ordering::Greater, Float::total_cmp(&-0.0, &-Float::TINY));
-        assert_eq!(Ordering::Greater, Float::total_cmp(&0.0, &-0.0));
-        assert_eq!(Ordering::Greater, Float::total_cmp(&Float::TINY, &0.0));
-        assert_eq!(Ordering::Greater, Float::total_cmp(&Float::MAX_SUBNORMAL, &Float::TINY));
-        assert_eq!(Ordering::Greater, Float::total_cmp(&Float::MIN_POSITIVE, &Float::MAX_SUBNORMAL));
-        assert_eq!(Ordering::Greater, Float::total_cmp(&0.5, &Float::MIN_POSITIVE));
-        assert_eq!(Ordering::Greater, Float::total_cmp(&1.0, &0.5));
-        assert_eq!(Ordering::Greater, Float::total_cmp(&1.5, &1.0));
-        assert_eq!(Ordering::Greater, Float::total_cmp(&2.5, &1.5));
-        assert_eq!(Ordering::Greater, Float::total_cmp(&Float::MAX, &2.5));
-        assert_eq!(Ordering::Greater, Float::total_cmp(&Float::INFINITY, &Float::MAX));
-
-        assert_eq!(Ordering::Less, Float::total_cmp(&-q_nan(), &-Float::INFINITY));
-        assert_eq!(Ordering::Less, Float::total_cmp(&-q_nan(), &-Float::MAX));
-        assert_eq!(Ordering::Less, Float::total_cmp(&-q_nan(), &-2.5));
-        assert_eq!(Ordering::Less, Float::total_cmp(&-q_nan(), &-1.5));
-        assert_eq!(Ordering::Less, Float::total_cmp(&-q_nan(), &-1.0));
-        assert_eq!(Ordering::Less, Float::total_cmp(&-q_nan(), &-0.5));
-        assert_eq!(Ordering::Less, Float::total_cmp(&-q_nan(), &-Float::MIN_POSITIVE));
-        assert_eq!(Ordering::Less, Float::total_cmp(&-q_nan(), &-Float::MAX_SUBNORMAL));
-        assert_eq!(Ordering::Less, Float::total_cmp(&-q_nan(), &-Float::TINY));
-        assert_eq!(Ordering::Less, Float::total_cmp(&-q_nan(), &-0.0));
-        assert_eq!(Ordering::Less, Float::total_cmp(&-q_nan(), &0.0));
-        assert_eq!(Ordering::Less, Float::total_cmp(&-q_nan(), &Float::TINY));
-        assert_eq!(Ordering::Less, Float::total_cmp(&-q_nan(), &Float::MAX_SUBNORMAL));
-        assert_eq!(Ordering::Less, Float::total_cmp(&-q_nan(), &Float::MIN_POSITIVE));
-        assert_eq!(Ordering::Less, Float::total_cmp(&-q_nan(), &0.5));
-        assert_eq!(Ordering::Less, Float::total_cmp(&-q_nan(), &1.0));
-        assert_eq!(Ordering::Less, Float::total_cmp(&-q_nan(), &1.5));
-        assert_eq!(Ordering::Less, Float::total_cmp(&-q_nan(), &2.5));
-        assert_eq!(Ordering::Less, Float::total_cmp(&-q_nan(), &Float::MAX));
-        assert_eq!(Ordering::Less, Float::total_cmp(&-q_nan(), &Float::INFINITY));
+        assert!(matches!(Float::total_cmp(&-q_nan(), &-q_nan()), Ordering::Equal));
+        assert!(matches!(Float::total_cmp(&-Float::INFINITY, &-Float::INFINITY), Ordering::Equal));
+        assert!(matches!(Float::total_cmp(&-Float::MAX, &-Float::MAX), Ordering::Equal));
+        assert!(matches!(Float::total_cmp(&-2.5, &-2.5), Ordering::Equal));
+        assert!(matches!(Float::total_cmp(&-1.0, &-1.0), Ordering::Equal));
+        assert!(matches!(Float::total_cmp(&-1.5, &-1.5), Ordering::Equal));
+        assert!(matches!(Float::total_cmp(&-0.5, &-0.5), Ordering::Equal));
+        assert!(matches!(Float::total_cmp(&-Float::MIN_POSITIVE, &-Float::MIN_POSITIVE), Ordering::Equal));
+        assert!(matches!(Float::total_cmp(&-Float::MAX_SUBNORMAL, &-Float::MAX_SUBNORMAL), Ordering::Equal));
+        assert!(matches!(Float::total_cmp(&-Float::TINY, &-Float::TINY), Ordering::Equal));
+        assert!(matches!(Float::total_cmp(&-0.0, &-0.0), Ordering::Equal));
+        assert!(matches!(Float::total_cmp(&0.0, &0.0), Ordering::Equal));
+        assert!(matches!(Float::total_cmp(&Float::TINY, &Float::TINY), Ordering::Equal));
+        assert!(matches!(Float::total_cmp(&Float::MAX_SUBNORMAL, &Float::MAX_SUBNORMAL), Ordering::Equal));
+        assert!(matches!(Float::total_cmp(&Float::MIN_POSITIVE, &Float::MIN_POSITIVE), Ordering::Equal));
+        assert!(matches!(Float::total_cmp(&0.5, &0.5), Ordering::Equal));
+        assert!(matches!(Float::total_cmp(&1.0, &1.0), Ordering::Equal));
+        assert!(matches!(Float::total_cmp(&1.5, &1.5), Ordering::Equal));
+        assert!(matches!(Float::total_cmp(&2.5, &2.5), Ordering::Equal));
+        assert!(matches!(Float::total_cmp(&Float::MAX, &Float::MAX), Ordering::Equal));
+        assert!(matches!(Float::total_cmp(&Float::INFINITY, &Float::INFINITY), Ordering::Equal));
+        assert!(matches!(Float::total_cmp(&q_nan(), &q_nan()), Ordering::Equal));
+
+        assert!(matches!(Float::total_cmp(&-Float::INFINITY, &-Float::MAX), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&-Float::MAX, &-2.5), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&-2.5, &-1.5), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&-1.5, &-1.0), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&-1.0, &-0.5), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&-0.5, &-Float::MIN_POSITIVE), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&-Float::MIN_POSITIVE, &-Float::MAX_SUBNORMAL), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&-Float::MAX_SUBNORMAL, &-Float::TINY), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&-Float::TINY, &-0.0), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&-0.0, &0.0), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&0.0, &Float::TINY), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&Float::TINY, &Float::MAX_SUBNORMAL), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&Float::MAX_SUBNORMAL, &Float::MIN_POSITIVE), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&Float::MIN_POSITIVE, &0.5), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&0.5, &1.0), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&1.0, &1.5), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&1.5, &2.5), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&2.5, &Float::MAX), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&Float::MAX, &Float::INFINITY), Ordering::Less));
+
+        assert!(matches!(Float::total_cmp(&-Float::MAX, &-Float::INFINITY), Ordering::Greater));
+        assert!(matches!(Float::total_cmp(&-2.5, &-Float::MAX), Ordering::Greater));
+        assert!(matches!(Float::total_cmp(&-1.5, &-2.5), Ordering::Greater));
+        assert!(matches!(Float::total_cmp(&-1.0, &-1.5), Ordering::Greater));
+        assert!(matches!(Float::total_cmp(&-0.5, &-1.0), Ordering::Greater));
+        assert!(matches!(Float::total_cmp(&-Float::MIN_POSITIVE, &-0.5), Ordering::Greater));
+        assert!(matches!(Float::total_cmp(&-Float::MAX_SUBNORMAL, &-Float::MIN_POSITIVE), Ordering::Greater));
+        assert!(matches!(Float::total_cmp(&-Float::TINY, &-Float::MAX_SUBNORMAL), Ordering::Greater));
+        assert!(matches!(Float::total_cmp(&-0.0, &-Float::TINY), Ordering::Greater));
+        assert!(matches!(Float::total_cmp(&0.0, &-0.0), Ordering::Greater));
+        assert!(matches!(Float::total_cmp(&Float::TINY, &0.0), Ordering::Greater));
+        assert!(matches!(Float::total_cmp(&Float::MAX_SUBNORMAL, &Float::TINY), Ordering::Greater));
+        assert!(matches!(Float::total_cmp(&Float::MIN_POSITIVE, &Float::MAX_SUBNORMAL), Ordering::Greater));
+        assert!(matches!(Float::total_cmp(&0.5, &Float::MIN_POSITIVE), Ordering::Greater));
+        assert!(matches!(Float::total_cmp(&1.0, &0.5), Ordering::Greater));
+        assert!(matches!(Float::total_cmp(&1.5, &1.0), Ordering::Greater));
+        assert!(matches!(Float::total_cmp(&2.5, &1.5), Ordering::Greater));
+        assert!(matches!(Float::total_cmp(&Float::MAX, &2.5), Ordering::Greater));
+        assert!(matches!(Float::total_cmp(&Float::INFINITY, &Float::MAX), Ordering::Greater));
+
+        assert!(matches!(Float::total_cmp(&-q_nan(), &-Float::INFINITY), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&-q_nan(), &-Float::MAX), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&-q_nan(), &-2.5), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&-q_nan(), &-1.5), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&-q_nan(), &-1.0), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&-q_nan(), &-0.5), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&-q_nan(), &-Float::MIN_POSITIVE), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&-q_nan(), &-Float::MAX_SUBNORMAL), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&-q_nan(), &-Float::TINY), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&-q_nan(), &-0.0), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&-q_nan(), &0.0), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&-q_nan(), &Float::TINY), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&-q_nan(), &Float::MAX_SUBNORMAL), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&-q_nan(), &Float::MIN_POSITIVE), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&-q_nan(), &0.5), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&-q_nan(), &1.0), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&-q_nan(), &1.5), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&-q_nan(), &2.5), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&-q_nan(), &Float::MAX), Ordering::Less));
+        assert!(matches!(Float::total_cmp(&-q_nan(), &Float::INFINITY), Ordering::Less));
 
     }
 }

From 62b2bd5809c18b79798b730058f494d9a2fb85c4 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Mon, 22 Sep 2025 16:26:27 +0200
Subject: [PATCH 1271/1889] reduce overlong lines

---
 .../bootstrapping/writing-tools-in-bootstrap.md       | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/building/bootstrapping/writing-tools-in-bootstrap.md b/src/doc/rustc-dev-guide/src/building/bootstrapping/writing-tools-in-bootstrap.md
index 8250a6f3b51df..8ac2e6bfe287c 100644
--- a/src/doc/rustc-dev-guide/src/building/bootstrapping/writing-tools-in-bootstrap.md
+++ b/src/doc/rustc-dev-guide/src/building/bootstrapping/writing-tools-in-bootstrap.md
@@ -19,11 +19,16 @@ There are three types of tools you can write in bootstrap:
 
   Use this for tools that use the `rustc_private` mechanism,
   and thus depend on the locally built `rustc` and its rlib artifacts.
-  This is more complex than the other modes because the tool must be built with the same compiler used for `rustc` and placed in the "stageN-tools" directory.
-  When you choose `Mode::ToolRustcPrivate`, `ToolBuild` implementation takes care of this automatically.
+  This is more complex than the other modes,
+  because the tool must be built with the same compiler used for `rustc`,
+  and placed in the "stageN-tools" directory.
+  When you choose `Mode::ToolRustcPrivate`,
+  `ToolBuild` implementation takes care of this automatically.
   If you need to use the builder’s compiler for something specific,
   you can get it from `ToolBuildResult`, which is returned by the tool's [`Step`].
 
-Regardless of the tool type you must return `ToolBuildResult` from the tool’s [`Step`] implementation and use `ToolBuild` inside it.
+Regardless of the tool type,
+you must return `ToolBuildResult` from the tool’s [`Step`] implementation,
+and use `ToolBuild` inside it.
 
 [`Step`]: https://doc.rust-lang.org/nightly/nightly-rustc/bootstrap/core/builder/trait.Step.html

From 1e2594f94f6ba665d5fc290986f8181137c94a17 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Mon, 22 Sep 2025 16:32:50 +0200
Subject: [PATCH 1272/1889] various improvements resulting from reading Testing
 with CI

---
 src/doc/rustc-dev-guide/src/tests/ci.md     | 106 ++++++++++----------
 src/doc/rustc-dev-guide/src/tests/crater.md |  24 ++---
 2 files changed, 65 insertions(+), 65 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/tests/ci.md b/src/doc/rustc-dev-guide/src/tests/ci.md
index d9fc2324d8bf6..43afb8536cb80 100644
--- a/src/doc/rustc-dev-guide/src/tests/ci.md
+++ b/src/doc/rustc-dev-guide/src/tests/ci.md
@@ -7,12 +7,12 @@ From a high-level point of view, when you open a pull request at
 `rust-lang/rust`, the following will happen:
 
 - A small [subset](#pull-request-builds) of tests and checks are run after each
-  push to the PR. This should help catching common errors.
+  push to the PR. This should help catch common errors.
 - When the PR is approved, the [bors] bot enqueues the PR into a [merge queue].
 - Once the PR gets to the front of the queue, bors will create a merge commit
   and run the [full test suite](#auto-builds) on it. The merge commit either
   contains only one specific PR or it can be a ["rollup"](#rollups) which
-  combines multiple PRs together, to save CI costs.
+  combines multiple PRs together, to reduce CI costs and merge delays.
 - Once the whole test suite finishes, two things can happen. Either CI fails
   with an error that needs to be addressed by the developer, or CI succeeds and
   the merge commit is then pushed to the `master` branch.
@@ -38,12 +38,12 @@ input, which contains a declarative configuration of all our CI jobs.
 > orchestrating the scripts that drive the process.
 
 In essence, all CI jobs run `./x test`, `./x dist` or some other command with
-different configurations, across various operating systems, targets and
+different configurations, across various operating systems, targets, and
 platforms. There are two broad categories of jobs that are executed, `dist` and
 non-`dist` jobs.
 
 - Dist jobs build a full release of the compiler for a specific platform,
-  including all the tools we ship through rustup; Those builds are then uploaded
+  including all the tools we ship through rustup. Those builds are then uploaded
   to the `rust-lang-ci2` S3 bucket and are available to be locally installed
   with the [rustup-toolchain-install-master] tool. The same builds are also used
   for actual releases: our release process basically consists of copying those
@@ -70,7 +70,7 @@ these execute the `x86_64-gnu-llvm-X`, `x86_64-gnu-tools`, `pr-check-1`, `pr-che
 and `tidy` jobs, all running on Linux. These execute a relatively short
 (~40 minutes) and lightweight test suite that should catch common issues. More
 specifically, they run a set of lints, they try to perform a cross-compile check
-build to Windows mingw (without producing any artifacts) and they test the
+build to Windows mingw (without producing any artifacts), and they test the
 compiler using a *system* version of LLVM. Unfortunately, it would take too many
 resources to run the full test suite for each commit on every PR.
 
@@ -95,17 +95,16 @@ jobs that exercise various tests across operating systems and targets. The full
 test suite is quite slow; it can take several hours until all the `auto` CI
 jobs finish.
 
-Most platforms only run the build steps, some run a restricted set of tests,
+Most platforms only run the build steps, some run a restricted set of tests;
 only a subset run the full suite of tests (see Rust's [platform tiers]).
 
 Auto jobs are defined in the `auto` section of [`jobs.yml`]. They are executed
-on the `auto` branch under the `rust-lang/rust` repository and
-their results can be seen [here](https://github.com/rust-lang/rust/actions),
-although usually you will be notified of the result by a comment made by bors on
-the corresponding PR.
+on the `auto` branch under the `rust-lang/rust` repository,
+and the final result will be reported via a comment made by bors on the corresponding PR.
+The live results can be seen on [the GitHub Actions workflows page].
 
 At any given time, at most a single `auto` build is being executed. Find out
-more [here](#merging-prs-serially-with-bors).
+more in [Merging PRs serially with bors](#merging-prs-serially-with-bors).
 
 [platform tiers]: https://forge.rust-lang.org/release/platform-support.html#rust-platform-support
 
@@ -125,7 +124,7 @@ There are several use-cases for try builds:
   when you start a try build). To create a try build and schedule it for a
   performance benchmark, you can use the `@bors try @rust-timer queue` command
   combination.
-- Check the impact of the PR across the Rust ecosystem, using a [crater] run.
+- Check the impact of the PR across the Rust ecosystem, using a [Crater](crater.md) run.
   Again, a working compiler build is needed for this, which can be produced by
   the [dist-x86_64-linux] CI job.
 - Run a specific CI job (e.g. Windows tests) on a PR, to quickly test if it
@@ -134,11 +133,11 @@ There are several use-cases for try builds:
 By default, if you send a comment with `@bors try`, the jobs defined in the `try` section of
 [`jobs.yml`] will be executed. We call this mode a "fast try build". Such a try build
 will not execute any tests, and it will allow compilation warnings. It is useful when you want to
-get an optimized toolchain as fast as possible, for a crater run or performance benchmarks,
+get an optimized toolchain as fast as possible, for a Crater run or performance benchmarks,
 even if it might not be working fully correctly. If you want to do a full build for the default try job,
 specify its job name in a job pattern (explained below).
 
-If you want to run custom CI job(s) in a try build and make sure that they pass all tests and do
+If you want to run custom CI jobs in a try build and make sure that they pass all tests and do
 not produce any compilation warnings, you can select CI jobs to be executed by specifying a *job pattern*,
 which can be used in one of two ways:
 - You can add a set of `try-job: <job pattern>` directives to the PR description (described below) and then
@@ -151,7 +150,7 @@ which can be used in one of two ways:
 
 Each job pattern can either be an exact name of a job or a glob pattern that matches multiple jobs,
 for example `*msvc*` or `*-alt`. You can start at most 20 jobs in a single try build. When using
-glob patterns in the PR description, you can (but do not have to) wrap them in backticks (`` ` ``) to avoid GitHub rendering
+glob patterns in the PR description, you can optionally wrap them in backticks (`` ` ``) to avoid GitHub rendering
 the pattern as Markdown if it contains e.g. an asterisk. Note that this escaping will not work when using
 the `@bors jobs=` parameter.
 
@@ -190,18 +189,17 @@ of [`jobs.yml`]:
 > that are exercised this way.
 
 Try builds are executed on the `try` branch under the `rust-lang/rust` repository and
-their results can be seen [here](https://github.com/rust-lang/rust/actions),
+their results can be seen on [the GitHub Actions workflows page],
 although usually you will be notified of the result by a comment made by bors on
 the corresponding PR.
 
 Multiple try builds can execute concurrently across different PRs, but there can be at most
 a single try build running on a single PR at any given time.
 
-Note that try builds are handled using the new [bors][new-bors] implementation.
+Note that try builds are handled using the [new bors] implementation.
 
 [rustc-perf]: https://github.com/rust-lang/rustc-perf
-[crater]: https://github.com/rust-lang/crater
-[new-bors]: https://github.com/rust-lang/bors
+[new bors]: https://github.com/rust-lang/bors
 
 ### Modifying CI jobs
 
@@ -211,8 +209,7 @@ If you want to modify what gets executed on our CI, you can simply modify the
 You can also modify what gets executed temporarily, for example to test a
 particular platform or configuration that is challenging to test locally (for
 example, if a Windows build fails, but you don't have access to a Windows
-machine). Don't hesitate to use CI resources in such situations to try out a
-fix!
+machine). Don't hesitate to use CI resources in such situations.
 
 You can perform an arbitrary CI job in two ways:
 - Use the [try build](#try-builds) functionality, and specify the CI jobs that
@@ -255,8 +252,8 @@ purposes.
 </div>
 
 Although you are welcome to use CI, just be conscious that this is a shared
-resource with limited concurrency. Try not to enable too many jobs at once (one
-or two should be sufficient in most cases).
+resource with limited concurrency. Try not to enable too many jobs at once;
+one or two should be sufficient in most cases.
 
 ## Merging PRs serially with bors
 
@@ -280,12 +277,12 @@ by listening for either Commit Statuses or Check Runs. Since the merge commit is
 based on the latest `master` and only one can be tested at the same time, when
 the results are green, `master` is fast-forwarded to that merge commit.
 
-Unfortunately testing a single PR at the time, combined with our long CI (~2
-hours for a full run), means we can’t merge too many PRs in a single day, and a
-single failure greatly impacts our throughput for the day. The maximum number of
+Unfortunately, testing a single PR at a time, combined with our long CI (~2
+hours for a full run), means we can’t merge a lot of PRs in a single day, and a
+single failure greatly impacts our throughput. The maximum number of
 PRs we can merge in a day is around ~10.
 
-The large CI run times and requirement for a large builder pool is largely due
+The long CI run times, and requirement for a large builder pool, is largely due
 to the fact that full release artifacts are built in the `dist-` builders. This
 is worth it because these release artifacts:
 
@@ -298,12 +295,11 @@ is worth it because these release artifacts:
 
 Some PRs don’t need the full test suite to be executed: trivial changes like
 typo fixes or README improvements *shouldn’t* break the build, and testing every
-single one of them for 2+ hours is a big waste of time. To solve this, we
+single one of them for 2+ hours would be wasteful. To solve this, we
 regularly create a "rollup", a PR where we merge several pending trivial PRs so
 they can be tested together. Rollups are created manually by a team member using
 the "create a rollup" button on the [merge queue]. The team member uses their
-judgment to decide if a PR is risky or not, and are the best tool we have at the
-moment to keep the queue in a manageable state.
+judgment to decide if a PR is risky or not.
 
 ## Docker
 
@@ -316,18 +312,22 @@ platform’s custom [Docker container]. This has a lot of advantages for us:
 - We can use ancient build environments to ensure maximum binary compatibility,
   for example [using older CentOS releases][dist-x86_64-linux] on our Linux
   builders.
-- We can avoid reinstalling tools (like QEMU or the Android emulator) every time
+- We can avoid reinstalling tools (like QEMU or the Android emulator) every time,
   thanks to Docker image caching.
-- Users can run the same tests in the same environment locally by just running
-  `cargo run --manifest-path src/ci/citool/Cargo.toml run-local <job-name>`, which is awesome to debug failures. Note that there are only linux docker images available locally due to licensing and
+- Users can run the same tests in the same environment locally by just running this command:
+
+      cargo run --manifest-path src/ci/citool/Cargo.toml run-local <job-name>
+
+  This is helpful for debugging failures.
+  Note that there are only Linux Docker images available locally due to licensing and
   other restrictions.
 
-The docker images prefixed with `dist-` are used for building artifacts while
+The Docker images prefixed with `dist-` are used for building artifacts while
 those without that prefix run tests and checks.
 
 We also run tests for less common architectures (mainly Tier 2 and Tier 3
-platforms) in CI. Since those platforms are not x86 we either run everything
-inside QEMU or just cross-compile if we don’t want to run the tests for that
+platforms) in CI. Since those platforms are not x86, we either run everything
+inside QEMU, or we just cross-compile if we don’t want to run the tests for that
 platform.
 
 These builders are running on a special pool of builders set up and maintained
@@ -364,41 +364,41 @@ invalidated if one of the following changes:
 [ghcr.io]: https://github.com/rust-lang/rust/pkgs/container/rust-ci
 [Docker registry caching]: https://docs.docker.com/build/cache/backends/registry/
 
-### LLVM caching with sccache
+### LLVM caching with Sccache
 
-We build some C/C++ stuff in various CI jobs, and we rely on [sccache] to cache
+We build some C/C++ stuff in various CI jobs, and we rely on [Sccache] to cache
 the intermediate LLVM artifacts. Sccache is a distributed ccache developed by
 Mozilla, which can use an object storage bucket as the storage backend.
 
-With sccache there's no need to calculate the hash key ourselves. Sccache
+With Sccache there's no need to calculate the hash key ourselves. Sccache
 invalidates the cache automatically when it detects changes to relevant inputs,
 such as the source code, the version of the compiler, and important environment
 variables.
-So we just pass the sccache wrapper on top of cargo and sccache does the rest.
+So we just pass the Sccache wrapper on top of Cargo and Sccache does the rest.
 
-We store the persistent artifacts on the S3 bucket `rust-lang-ci-sccache2`. So
-when the CI runs, if sccache sees that LLVM is being compiled with the same C/C++
-compiler and the LLVM source code is the same, sccache retrieves the individual
+We store the persistent artifacts on the S3 bucket, `rust-lang-ci-sccache2`. So
+when the CI runs, if Sccache sees that LLVM is being compiled with the same C/C++
+compiler and the LLVM source code is the same, Sccache retrieves the individual
 compiled translation units from S3.
 
 [sccache]: https://github.com/mozilla/sccache
 
 ## Custom tooling around CI
 
-During the years we developed some custom tooling to improve our CI experience.
+During the years, we developed some custom tooling to improve our CI experience.
 
 ### Rust Log Analyzer to show the error message in PRs
 
 The build logs for `rust-lang/rust` are huge, and it’s not practical to find
-what caused the build to fail by looking at the logs. To improve the developers’
-experience we developed a bot called [Rust Log Analyzer][rla] (RLA) that
-receives the build logs on failure and extracts the error message automatically,
-posting it on the PR.
+what caused the build to fail by looking at the logs.
+We therefore developed a bot called [Rust Log Analyzer][rla] (RLA) that
+receives the build logs on failure, and extracts the error message automatically,
+posting it on the PR thread.
 
 The bot is not hardcoded to look for error strings, but was trained with a bunch
 of build failures to recognize which lines are common between builds and which
 are not. While the generated snippets can be weird sometimes, the bot is pretty
-good at identifying the relevant lines even if it’s an error we've never seen
+good at identifying the relevant lines, even if it’s an error we've never seen
 before.
 
 [rla]: https://github.com/rust-lang/rust-log-analyzer
@@ -430,11 +430,11 @@ More information is available in the [toolstate documentation].
 
 ## Public CI dashboard
 
-To monitor the Rust CI, you can have a look at the [public dashboard] maintained by the infra-team.
+To monitor the Rust CI, you can have a look at the [public dashboard] maintained by the infra team.
 
 These are some useful panels from the dashboard:
 
-- Pipeline duration: check how long the auto builds takes to run.
+- Pipeline duration: check how long the auto builds take to run.
 - Top slowest jobs: check which jobs are taking the longest to run.
 - Change in median job duration: check what jobs are slowest than before. Useful
   to detect regressions.
@@ -457,8 +457,7 @@ this:
 2. Choose the job you are interested in on the left-hand side.
 3. Click on the gear icon and choose "View raw logs"
 4. Search for the string "Configure the build"
-5. All of the build settings are listed below that starting with the
-   `configure:` prefix.
+5. All of the build settings are listed on the line with the text, `build.configure-args`
 
 [GitHub Actions]: https://github.com/rust-lang/rust/actions
 [`jobs.yml`]: https://github.com/rust-lang/rust/blob/master/src/ci/github-actions/jobs.yml
@@ -468,3 +467,4 @@ this:
 [homu]: https://github.com/rust-lang/homu
 [merge queue]: https://bors.rust-lang.org/queue/rust
 [dist-x86_64-linux]: https://github.com/rust-lang/rust/blob/master/src/ci/docker/host-x86_64/dist-x86_64-linux/Dockerfile
+[the GitHub Actions workflows page]: https://github.com/rust-lang/rust/actions
diff --git a/src/doc/rustc-dev-guide/src/tests/crater.md b/src/doc/rustc-dev-guide/src/tests/crater.md
index 9d4ac87daf36a..96bb5a4f2ae67 100644
--- a/src/doc/rustc-dev-guide/src/tests/crater.md
+++ b/src/doc/rustc-dev-guide/src/tests/crater.md
@@ -8,30 +8,30 @@ stable compiler versions.
 
 ## When to run Crater
 
-You should request a crater run if your PR makes large changes to the compiler
+You should request a Crater run if your PR makes large changes to the compiler
 or could cause breakage. If you are unsure, feel free to ask your PR's reviewer.
 
 ## Requesting Crater Runs
 
-The rust team maintains a few machines that can be used for running crater runs
-on the changes introduced by a PR. If your PR needs a crater run, leave a
+The Rust team maintains a few machines that can be used for Crater runs
+on the changes introduced by a PR. If your PR needs a Crater run, leave a
 comment for the triage team in the PR thread. Please inform the team whether you
-require a "check-only" crater run, a "build only" crater run, or a
-"build-and-test" crater run. The difference is primarily in time; the
-conservative (if you're not sure) option is to go for the build-and-test run. If
+require a "check-only" Crater run, a "build only" Crater run, or a
+"build-and-test" Crater run. The difference is primarily in time;
+if you're not sure, go for the build-and-test run. If
 making changes that will only have an effect at compile-time (e.g., implementing
-a new trait) then you only need a check run.
+a new trait), then you only need a check run.
 
 Your PR will be enqueued by the triage team and the results will be posted when
-they are ready. Check runs will take around ~3-4 days, with the other two taking
+they are ready. Check runs will take around ~3-4 days, and the other two taking
 5-6 days on average.
 
-While crater is really useful, it is also important to be aware of a few
+While Crater is really useful, it is also important to be aware of a few
 caveats:
 
 - Not all code is on crates.io! There is a lot of code in repos on GitHub and
   elsewhere. Also, companies may not wish to publish their code. Thus, a
-  successful crater run is not a magically green light that there will be no
+  successful Crater run does not mean there will be no
   breakage; you still need to be careful.
 
 - Crater only runs Linux builds on x86_64. Thus, other architectures and
@@ -41,5 +41,5 @@ caveats:
   the crate doesn't compile any more (e.g. used old nightly features), has
   broken or flaky tests, requires network access, or other reasons.
 
-- Before crater can be run, `@bors try` needs to succeed in building artifacts.
-  This means that if your code doesn't compile, you cannot run crater.
+- Before Crater can be run, `@bors try` needs to succeed in building artifacts.
+  This means that if your code doesn't compile, you cannot run Crater.

From 75e3eb82682752563a2687ffb3f135e68ea2b802 Mon Sep 17 00:00:00 2001
From: Shoyu Vanilla <modulo641@gmail.com>
Date: Mon, 22 Sep 2025 00:42:44 +0900
Subject: [PATCH 1273/1889] internal: Migrate more predicate things to
 next-solver

---
 .../crates/hir-ty/src/infer/unify.rs          | 110 +++++++-----------
 .../rust-analyzer/crates/hir-ty/src/lib.rs    |  47 +++++---
 .../crates/hir-ty/src/lower_nextsolver.rs     |  12 ++
 .../crates/hir-ty/src/method_resolution.rs    | 100 ++++++----------
 .../rust-analyzer/crates/hir-ty/src/traits.rs |   6 +-
 5 files changed, 122 insertions(+), 153 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
index 1687857ae1ac2..cee95d3880df9 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
@@ -11,39 +11,35 @@ use hir_def::{AdtId, lang_item::LangItem};
 use hir_expand::name::Name;
 use intern::sym;
 use rustc_hash::{FxHashMap, FxHashSet};
-use rustc_type_ir::inherent::Ty as _;
 use rustc_type_ir::{
-    FloatVid, IntVid, TyVid, TypeVisitableExt,
-    inherent::{IntoKind, Span, Term as _},
+    FloatVid, IntVid, TyVid, TypeVisitableExt, UpcastFrom,
+    inherent::{IntoKind, Span, Term as _, Ty as _},
     relate::{Relate, solver_relating::RelateExt},
-    solve::{Certainty, GoalSource, NoSolution},
+    solve::{Certainty, GoalSource},
 };
 use smallvec::SmallVec;
 use triomphe::Arc;
 
 use super::{InferResult, InferenceContext, TypeError};
-use crate::next_solver::ErrorGuaranteed;
 use crate::{
     AliasTy, BoundVar, Canonical, Const, ConstValue, DebruijnIndex, GenericArg, GenericArgData,
-    Goal, GoalData, InEnvironment, InferenceVar, Interner, Lifetime, OpaqueTyId, ParamKind,
-    ProjectionTy, Scalar, Substitution, TraitEnvironment, TraitRef, Ty, TyBuilder, TyExt, TyKind,
-    VariableKind, WhereClause,
+    InferenceVar, Interner, Lifetime, OpaqueTyId, ProjectionTy, Scalar, Substitution,
+    TraitEnvironment, Ty, TyExt, TyKind, VariableKind,
     consteval::unknown_const,
     db::HirDatabase,
     fold_generic_args, fold_tys_and_consts,
-    next_solver::infer::InferOk,
     next_solver::{
-        self, ClauseKind, DbInterner, ParamEnv, Predicate, PredicateKind, SolverDefIds, Term,
+        self, ClauseKind, DbInterner, ErrorGuaranteed, ParamEnv, Predicate, PredicateKind,
+        SolverDefIds, Term, TraitRef,
         fulfill::FulfillmentCtxt,
         infer::{
-            DbInternerInferExt, InferCtxt,
+            DbInternerInferExt, InferCtxt, InferOk,
             snapshot::CombinedSnapshot,
             traits::{Obligation, ObligationCause},
         },
         inspect::{InspectConfig, InspectGoal, ProofTreeVisitor},
         mapping::{ChalkToNextSolver, NextSolverToChalk},
     },
-    to_chalk_trait_id,
     traits::{
         FnTrait, NextTraitSolveResult, next_trait_solve_canonical_in_ctxt, next_trait_solve_in_ctxt,
     },
@@ -877,26 +873,15 @@ impl<'db> InferenceTable<'db> {
     /// whether a trait *might* be implemented before deciding to 'lock in' the
     /// choice (during e.g. method resolution or deref).
     #[tracing::instrument(level = "debug", skip(self))]
-    pub(crate) fn try_obligation(&mut self, goal: Goal) -> NextTraitSolveResult {
-        let in_env = InEnvironment::new(&self.trait_env.env, goal);
-        let canonicalized = self.canonicalize(in_env.to_nextsolver(self.interner));
+    pub(crate) fn try_obligation(&mut self, predicate: Predicate<'db>) -> NextTraitSolveResult {
+        let goal = next_solver::Goal { param_env: self.param_env, predicate };
+        let canonicalized = self.canonicalize(goal);
 
         next_trait_solve_canonical_in_ctxt(&self.infer_ctxt, canonicalized)
     }
 
-    #[tracing::instrument(level = "debug", skip(self))]
-    pub(crate) fn solve_obligation(&mut self, goal: Goal) -> Result<Certainty, NoSolution> {
-        let goal = InEnvironment::new(&self.trait_env.env, goal);
-        let goal = goal.to_nextsolver(self.interner);
-        let result = next_trait_solve_in_ctxt(&self.infer_ctxt, goal);
-        result.map(|m| m.1)
-    }
-
     pub(crate) fn register_obligation(&mut self, predicate: Predicate<'db>) {
-        let goal = next_solver::Goal {
-            param_env: self.trait_env.env.to_nextsolver(self.interner),
-            predicate,
-        };
+        let goal = next_solver::Goal { param_env: self.param_env, predicate };
         self.register_obligation_in_env(goal)
     }
 
@@ -984,7 +969,7 @@ impl<'db> InferenceTable<'db> {
         &mut self,
         ty: &Ty,
         num_args: usize,
-    ) -> Option<(FnTrait, Vec<crate::next_solver::Ty<'db>>, crate::next_solver::Ty<'db>)> {
+    ) -> Option<(FnTrait, Vec<next_solver::Ty<'db>>, next_solver::Ty<'db>)> {
         for (fn_trait_name, output_assoc_name, subtraits) in [
             (FnTrait::FnOnce, sym::Output, &[FnTrait::Fn, FnTrait::FnMut][..]),
             (FnTrait::AsyncFnMut, sym::CallRefFuture, &[FnTrait::AsyncFn]),
@@ -997,42 +982,34 @@ impl<'db> InferenceTable<'db> {
                 trait_data.associated_type_by_name(&Name::new_symbol_root(output_assoc_name))?;
 
             let mut arg_tys = Vec::with_capacity(num_args);
-            let arg_ty = TyBuilder::tuple(num_args)
-                .fill(|it| {
-                    let arg = match it {
-                        ParamKind::Type => self.new_type_var(),
-                        ParamKind::Lifetime => unreachable!("Tuple with lifetime parameter"),
-                        ParamKind::Const(_) => unreachable!("Tuple with const parameter"),
-                    };
-                    arg_tys.push(arg.to_nextsolver(self.interner));
-                    arg.cast(Interner)
+            let arg_ty = next_solver::Ty::new_tup_from_iter(
+                self.interner,
+                std::iter::repeat_with(|| {
+                    let ty = self.next_ty_var();
+                    arg_tys.push(ty);
+                    ty
                 })
-                .build();
-
-            let b = TyBuilder::trait_ref(self.db, fn_trait);
-            if b.remaining() != 2 {
-                return None;
-            }
-            let mut trait_ref = b.push(ty.clone()).push(arg_ty).build();
-
-            let projection = TyBuilder::assoc_type_projection(
-                self.db,
-                output_assoc_type,
-                Some(trait_ref.substitution.clone()),
-            )
-            .fill_with_unknown()
-            .build();
-
-            let goal: Goal = trait_ref.clone().cast(Interner);
-            if !self.try_obligation(goal.clone()).no_solution() {
-                self.register_obligation(goal.to_nextsolver(self.interner));
-                let return_ty =
-                    self.normalize_projection_ty(projection).to_nextsolver(self.interner);
+                .take(num_args),
+            );
+            let args = [ty.to_nextsolver(self.interner), arg_ty];
+            let trait_ref = crate::next_solver::TraitRef::new(self.interner, fn_trait.into(), args);
+
+            let projection = crate::next_solver::Ty::new_alias(
+                self.interner,
+                rustc_type_ir::AliasTyKind::Projection,
+                crate::next_solver::AliasTy::new(self.interner, output_assoc_type.into(), args),
+            );
+
+            let pred = crate::next_solver::Predicate::upcast_from(trait_ref, self.interner);
+            if !self.try_obligation(pred).no_solution() {
+                self.register_obligation(pred);
+                let return_ty = self.normalize_alias_ty(projection);
                 for &fn_x in subtraits {
                     let fn_x_trait = fn_x.get_id(self.db, krate)?;
-                    trait_ref.trait_id = to_chalk_trait_id(fn_x_trait);
-                    let goal = trait_ref.clone().cast(Interner);
-                    if !self.try_obligation(goal).no_solution() {
+                    let trait_ref =
+                        crate::next_solver::TraitRef::new(self.interner, fn_x_trait.into(), args);
+                    let pred = crate::next_solver::Predicate::upcast_from(trait_ref, self.interner);
+                    if !self.try_obligation(pred).no_solution() {
                         return Some((fn_x, arg_tys, return_ty));
                     }
                 }
@@ -1171,12 +1148,11 @@ impl<'db> InferenceTable<'db> {
         let Some(sized) = LangItem::Sized.resolve_trait(self.db, self.trait_env.krate) else {
             return false;
         };
-        let sized_pred = WhereClause::Implemented(TraitRef {
-            trait_id: to_chalk_trait_id(sized),
-            substitution: Substitution::from1(Interner, ty),
-        });
-        let goal = GoalData::DomainGoal(chalk_ir::DomainGoal::Holds(sized_pred)).intern(Interner);
-        self.try_obligation(goal).certain()
+        let sized_pred = Predicate::upcast_from(
+            TraitRef::new(self.interner, sized.into(), [ty.to_nextsolver(self.interner)]),
+            self.interner,
+        );
+        self.try_obligation(sized_pred).certain()
     }
 }
 
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 451622ef7472b..2accf48843442 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
@@ -93,7 +93,10 @@ use intern::{Symbol, sym};
 use la_arena::{Arena, Idx};
 use mir::{MirEvalError, VTableMap};
 use rustc_hash::{FxBuildHasher, FxHashMap, FxHashSet};
-use rustc_type_ir::inherent::SliceLike;
+use rustc_type_ir::{
+    UpcastFrom,
+    inherent::{SliceLike, Ty as _},
+};
 use syntax::ast::{ConstArg, make};
 use traits::FnTrait;
 use triomphe::Arc;
@@ -106,7 +109,7 @@ use crate::{
     infer::unify::InferenceTable,
     next_solver::{
         DbInterner,
-        mapping::{ChalkToNextSolver, convert_ty_for_result},
+        mapping::{ChalkToNextSolver, NextSolverToChalk, convert_ty_for_result},
     },
 };
 
@@ -957,26 +960,32 @@ pub fn callable_sig_from_fn_trait(
     // Register two obligations:
     // - Self: FnOnce<?args_ty>
     // - <Self as FnOnce<?args_ty>>::Output == ?ret_ty
-    let args_ty = table.new_type_var();
-    let mut trait_ref = b.push(self_ty.clone()).push(args_ty.clone()).build();
-    let projection = TyBuilder::assoc_type_projection(
-        db,
-        output_assoc_type,
-        Some(trait_ref.substitution.clone()),
-    )
-    .build();
-
-    let goal: Goal = trait_ref.clone().cast(Interner);
-    let pred = goal.to_nextsolver(table.interner);
-    if !table.try_obligation(goal).no_solution() {
+    let args_ty = table.next_ty_var();
+    let args = [self_ty.to_nextsolver(table.interner), args_ty];
+    let trait_ref = crate::next_solver::TraitRef::new(table.interner, fn_once_trait.into(), args);
+    let projection = crate::next_solver::Ty::new_alias(
+        table.interner,
+        rustc_type_ir::AliasTyKind::Projection,
+        crate::next_solver::AliasTy::new(table.interner, output_assoc_type.into(), args),
+    );
+
+    let pred = crate::next_solver::Predicate::upcast_from(trait_ref, table.interner);
+    if !table.try_obligation(pred).no_solution() {
         table.register_obligation(pred);
-        let return_ty = table.normalize_projection_ty(projection);
+        let return_ty = table.normalize_alias_ty(projection);
         for fn_x in [FnTrait::Fn, FnTrait::FnMut, FnTrait::FnOnce] {
             let fn_x_trait = fn_x.get_id(db, krate)?;
-            trait_ref.trait_id = to_chalk_trait_id(fn_x_trait);
-            if !table.try_obligation(trait_ref.clone().cast(Interner)).no_solution() {
-                let ret_ty = table.resolve_completely(return_ty);
-                let args_ty = table.resolve_completely(args_ty);
+            let trait_ref =
+                crate::next_solver::TraitRef::new(table.interner, fn_x_trait.into(), args);
+            if !table
+                .try_obligation(crate::next_solver::Predicate::upcast_from(
+                    trait_ref,
+                    table.interner,
+                ))
+                .no_solution()
+            {
+                let ret_ty = table.resolve_completely(return_ty.to_chalk(table.interner));
+                let args_ty = table.resolve_completely(args_ty.to_chalk(table.interner));
                 let params = args_ty
                     .as_tuple()?
                     .iter(Interner)
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
index 0076446a958b0..6ecf8874c46d2 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
@@ -1355,6 +1355,18 @@ pub(crate) fn generic_predicates_for_param_cycle_result(
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct GenericPredicates<'db>(Option<Arc<[Clause<'db>]>>);
 
+impl<'db> GenericPredicates<'db> {
+    pub fn instantiate(
+        &self,
+        interner: DbInterner<'db>,
+        args: GenericArgs<'db>,
+    ) -> Option<impl Iterator<Item = Clause<'db>>> {
+        self.0
+            .as_ref()
+            .map(|it| EarlyBinder::bind(it.iter().copied()).iter_instantiated(interner, args))
+    }
+}
+
 impl<'db> ops::Deref for GenericPredicates<'db> {
     type Target = [Clause<'db>];
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
index 7fa3d31fe5fdc..5cd4879a54046 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
@@ -32,9 +32,12 @@ use crate::{
     lang_items::is_box,
     next_solver::{
         self, SolverDefId,
-        fulfill::FulfillmentCtxt,
-        infer::DefineOpaqueTypes,
+        infer::{
+            DefineOpaqueTypes,
+            traits::{ObligationCause, PredicateObligation},
+        },
         mapping::{ChalkToNextSolver, NextSolverToChalk},
+        obligation_ctxt::ObligationCtxt,
     },
     primitive::{FloatTy, IntTy, UintTy},
     to_chalk_trait_id,
@@ -907,10 +910,11 @@ fn find_matching_impl(
                 .into_iter()
                 .map(|b| -> Goal { b.cast(Interner) });
             for goal in wcs {
-                if table.try_obligation(goal.clone()).no_solution() {
+                let goal = goal.to_nextsolver(table.interner);
+                if table.try_obligation(goal).no_solution() {
                     return None;
                 }
-                table.register_obligation(goal.to_nextsolver(table.interner));
+                table.register_obligation(goal);
             }
             Some((
                 impl_.impl_items(db),
@@ -1395,7 +1399,7 @@ fn iterate_trait_method_candidates(
     let db = table.db;
 
     let canonical_self_ty = table.canonicalize(self_ty.clone().to_nextsolver(table.interner));
-    let TraitEnvironment { krate, .. } = *table.trait_env;
+    let krate = table.trait_env.krate;
 
     'traits: for &t in traits_in_scope {
         let data = db.trait_signature(t);
@@ -1635,7 +1639,6 @@ pub(crate) fn resolve_indexing_op<'db>(
     let ty = table.instantiate_canonical_ns(ty);
     let deref_chain = autoderef_method_receiver(table, ty);
     for (ty, adj) in deref_chain {
-        //let goal = generic_implements_goal_ns(db, &table.trait_env, index_trait, &ty);
         let goal = generic_implements_goal_ns(table, index_trait, ty);
         if !next_trait_solve_canonical_in_ctxt(&table.infer_ctxt, goal).no_solution() {
             return Some(adj);
@@ -1752,10 +1755,7 @@ fn is_valid_trait_method_candidate(
                     };
                     let res = table
                         .infer_ctxt
-                        .at(
-                            &next_solver::infer::traits::ObligationCause::dummy(),
-                            table.trait_env.env.to_nextsolver(table.interner),
-                        )
+                        .at(&next_solver::infer::traits::ObligationCause::dummy(), table.param_env)
                         .relate(
                             DefineOpaqueTypes::No,
                             expected_receiver.to_nextsolver(table.interner),
@@ -1767,12 +1767,10 @@ fn is_valid_trait_method_candidate(
                     };
 
                     if !infer_ok.obligations.is_empty() {
-                        let mut ctxt = FulfillmentCtxt::new(&table.infer_ctxt);
-                        for pred in infer_ok.into_obligations() {
-                            ctxt.register_predicate_obligation(&table.infer_ctxt, pred);
-                        }
+                        let mut ctxt = ObligationCtxt::new(&table.infer_ctxt);
+                        ctxt.register_obligations(infer_ok.into_obligations());
                         // FIXME: Are we doing this correctly? Probably better to follow rustc more closely.
-                        check_that!(ctxt.select_where_possible(&table.infer_ctxt).is_empty());
+                        check_that!(ctxt.select_where_possible().is_empty());
                     }
 
                     check_that!(table.unify(receiver_ty, &expected_receiver));
@@ -1815,9 +1813,11 @@ fn is_valid_impl_fn_candidate(
     }
     table.run_in_snapshot(|table| {
         let _p = tracing::info_span!("subst_for_def").entered();
-        let impl_subst =
-            TyBuilder::subst_for_def(db, impl_id, None).fill_with_inference_vars(table).build();
-        let expect_self_ty = db.impl_self_ty(impl_id).substitute(Interner, &impl_subst);
+        let impl_subst = table.infer_ctxt.fresh_args_for_item(impl_id.into());
+        let expect_self_ty = db
+            .impl_self_ty_ns(impl_id)
+            .instantiate(table.interner, &impl_subst)
+            .to_chalk(table.interner);
 
         check_that!(table.unify(&expect_self_ty, self_ty));
 
@@ -1825,9 +1825,8 @@ fn is_valid_impl_fn_candidate(
             let _p = tracing::info_span!("check_receiver_ty").entered();
             check_that!(data.has_self_param());
 
-            let fn_subst = TyBuilder::subst_for_def(db, fn_id, Some(impl_subst.clone()))
-                .fill_with_inference_vars(table)
-                .build();
+            let fn_subst: crate::Substitution =
+                table.infer_ctxt.fresh_args_for_item(fn_id.into()).to_chalk(table.interner);
 
             let sig = db.callable_item_signature(fn_id.into());
             let expected_receiver =
@@ -1838,46 +1837,23 @@ fn is_valid_impl_fn_candidate(
 
         // We need to consider the bounds on the impl to distinguish functions of the same name
         // for a type.
-        let predicates = db.generic_predicates(impl_id.into());
-        let goals = predicates.iter().map(|p| {
-            let (p, b) = p
-                .clone()
-                .substitute(Interner, &impl_subst)
-                // Skipping the inner binders is ok, as we don't handle quantified where
-                // clauses yet.
-                .into_value_and_skipped_binders();
-            stdx::always!(b.len(Interner) == 0);
-
-            p.cast::<Goal>(Interner)
-        });
-
-        for goal in goals.clone() {
-            match table.solve_obligation(goal) {
-                Ok(_) => {}
-                Err(_) => {
-                    return IsValidCandidate::No;
-                }
-            }
-        }
+        let predicates = db.generic_predicates_ns(impl_id.into());
+        let Some(predicates) = predicates.instantiate(table.interner, impl_subst) else {
+            return IsValidCandidate::Yes;
+        };
 
-        for goal in goals {
-            if table.try_obligation(goal).no_solution() {
-                return IsValidCandidate::No;
-            }
-        }
+        let mut ctxt = ObligationCtxt::new(&table.infer_ctxt);
 
-        IsValidCandidate::Yes
-    })
-}
+        ctxt.register_obligations(predicates.into_iter().map(|p| {
+            PredicateObligation::new(table.interner, ObligationCause::new(), table.param_env, p.0)
+        }));
 
-pub fn implements_trait(
-    ty: &Canonical<Ty>,
-    db: &dyn HirDatabase,
-    env: &TraitEnvironment,
-    trait_: TraitId,
-) -> bool {
-    let goal = generic_implements_goal(db, env, trait_, ty);
-    !db.trait_solve(env.krate, env.block, goal.cast(Interner)).no_solution()
+        if ctxt.select_where_possible().is_empty() {
+            IsValidCandidate::Yes
+        } else {
+            IsValidCandidate::No
+        }
+    })
 }
 
 pub fn implements_trait_unique(
@@ -1891,7 +1867,7 @@ pub fn implements_trait_unique(
 }
 
 /// This creates Substs for a trait with the given Self type and type variables
-/// for all other parameters, to query Chalk with it.
+/// for all other parameters, to query next solver with it.
 #[tracing::instrument(skip_all)]
 fn generic_implements_goal(
     db: &dyn HirDatabase,
@@ -1934,11 +1910,7 @@ fn generic_implements_goal_ns<'db>(
     let trait_ref =
         rustc_type_ir::TraitRef::new_from_args(table.infer_ctxt.interner, trait_.into(), args)
             .with_replaced_self_ty(table.infer_ctxt.interner, self_ty);
-    let goal = next_solver::Goal::new(
-        table.infer_ctxt.interner,
-        table.trait_env.env.to_nextsolver(table.infer_ctxt.interner),
-        trait_ref,
-    );
+    let goal = next_solver::Goal::new(table.infer_ctxt.interner, table.param_env, trait_ref);
 
     table.canonicalize(goal)
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs b/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
index 8095d702be489..3ce78e83c1294 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
@@ -1,4 +1,4 @@
-//! Trait solving using Chalk.
+//! Trait solving using next trait solver.
 
 use core::fmt;
 use std::hash::Hash;
@@ -128,7 +128,7 @@ fn identity_subst(
     chalk_ir::Canonical { binders, value: identity_subst }
 }
 
-/// Solve a trait goal using Chalk.
+/// Solve a trait goal using next trait solver.
 pub(crate) fn trait_solve_query(
     db: &dyn HirDatabase,
     krate: Crate,
@@ -325,7 +325,7 @@ pub fn next_trait_solve_canonical_in_ctxt<'db>(
     }
 }
 
-/// Solve a trait goal using Chalk.
+/// Solve a trait goal using next trait solver.
 pub fn next_trait_solve_in_ctxt<'db, 'a>(
     infer_ctxt: &'a InferCtxt<'db>,
     goal: crate::next_solver::Goal<'db, crate::next_solver::Predicate<'db>>,

From bd98e73fe0da34a9c57cf87f3ac248a2e653f970 Mon Sep 17 00:00:00 2001
From: Iris Shi <0.0@owo.li>
Date: Mon, 22 Sep 2025 17:45:51 +0200
Subject: [PATCH 1274/1889] Update
 tests/rustdoc/reexport/private-mod-override-reexport.rs

---
 tests/rustdoc/reexport/private-mod-override-reexport.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/rustdoc/reexport/private-mod-override-reexport.rs b/tests/rustdoc/reexport/private-mod-override-reexport.rs
index 8deafe2422256..849acc5fdaecd 100644
--- a/tests/rustdoc/reexport/private-mod-override-reexport.rs
+++ b/tests/rustdoc/reexport/private-mod-override-reexport.rs
@@ -1,6 +1,5 @@
 // https://github.com/rust-lang/rust/issues/60926
 #![crate_name = "foo"]
-#![crate_type = "lib"]
 
 mod m1 {
     pub mod m2 {

From 293e0a3aa0dee0cacb4e7aad80f1007e5f06cf39 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 22 Sep 2025 17:36:20 +0200
Subject: [PATCH 1275/1889] fix SIFA logic

---
 .../tree_borrows/foreign_access_skipping.rs   |  2 +-
 .../src/borrow_tracker/tree_borrows/tree.rs   | 33 ++++++++++++-------
 2 files changed, 23 insertions(+), 12 deletions(-)

diff --git a/src/tools/miri/src/borrow_tracker/tree_borrows/foreign_access_skipping.rs b/src/tools/miri/src/borrow_tracker/tree_borrows/foreign_access_skipping.rs
index 928b3e6baef44..90df05d36d965 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/foreign_access_skipping.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/foreign_access_skipping.rs
@@ -24,7 +24,7 @@ use super::tree::AccessRelatedness;
 /// "manually" reset the parent's SIFA to be at least as strong as the new child's. This is accomplished with the `ensure_no_stronger_than` method.
 ///
 /// Note that we derive Ord and PartialOrd, so the order in which variants are listed below matters:
-/// None < Read < Write. Do not change that order. See the `test_order` test.
+/// None < Read < Write (weaker to stronger). Do not change that order. See the `test_order` test.
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Default)]
 pub enum IdempotentForeignAccess {
     #[default]
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 be2a07eee1503..c4345c63289f1 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/tree.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/tree.rs
@@ -640,13 +640,18 @@ impl<'tcx> Tree {
         // Register new_tag as a child of parent_tag
         self.nodes.get_mut(parent_idx).unwrap().children.push(idx);
 
-        // We need to know the biggest SIFA for `update_last_accessed_after_retag` below.
-        let mut max_sifa = default_strongest_idempotent;
+        // We need to know the weakest SIFA for `update_idempotent_foreign_access_after_retag`.
+        let mut min_sifa = default_strongest_idempotent;
         for (Range { start, end }, &perm) in
             inside_perms.iter(Size::from_bytes(0), inside_perms.size())
         {
             assert!(perm.permission.is_initial());
-            max_sifa = cmp::max(max_sifa, perm.idempotent_foreign_access);
+            assert_eq!(
+                perm.idempotent_foreign_access,
+                perm.permission.strongest_idempotent_foreign_access(protected)
+            );
+
+            min_sifa = cmp::min(min_sifa, perm.idempotent_foreign_access);
             for (_perms_range, perms) in self
                 .rperms
                 .iter_mut(Size::from_bytes(start) + base_offset, Size::from_bytes(end - start))
@@ -656,22 +661,28 @@ impl<'tcx> Tree {
         }
 
         // Inserting the new perms might have broken the SIFA invariant (see
-        // `foreign_access_skipping.rs`). We now weaken the recorded SIFA for our parents, until the
-        // invariant is restored. We could weaken them all to `LocalAccess`, but it is more
-        // efficient to compute the SIFA for the new permission statically, and use that. For this
-        // we need the *maximum* SIFA (`Write` needs more fixup than `None`).
-        self.update_last_accessed_after_retag(parent_idx, max_sifa);
+        // `foreign_access_skipping.rs`) if the SIFA we inserted is weaker than that of some parent.
+        // We now weaken the recorded SIFA for our parents, until the invariant is restored. We
+        // could weaken them all to `None`, but it is more efficient to compute the SIFA for the new
+        // permission statically, and use that. For this we need the *minimum* SIFA (`None` needs
+        // more fixup than `Write`).
+        self.update_idempotent_foreign_access_after_retag(parent_idx, min_sifa);
 
         interp_ok(())
     }
 
-    /// Restores the SIFA "children are stronger" invariant after a retag.
-    /// See `foreign_access_skipping` and `new_child`.
-    fn update_last_accessed_after_retag(
+    /// Restores the SIFA "children are stronger"/"parents are weaker" invariant after a retag:
+    /// reduce the SIFA of `current` and its parents to be no stronger than `strongest_allowed`.
+    /// See `foreign_access_skipping.rs` and [`Tree::new_child`].
+    fn update_idempotent_foreign_access_after_retag(
         &mut self,
         mut current: UniIndex,
         strongest_allowed: IdempotentForeignAccess,
     ) {
+        if strongest_allowed == IdempotentForeignAccess::Write {
+            // Nothing is stronger than `Write`.
+            return;
+        }
         // We walk the tree upwards, until the invariant is restored
         loop {
             let current_node = self.nodes.get_mut(current).unwrap();

From 2dc1354cd0ed52bedc4f7c823e6fa6af581a3109 Mon Sep 17 00:00:00 2001
From: Martin Nordholts <martin.nordholts@codetale.se>
Date: Fri, 5 Sep 2025 19:58:01 +0200
Subject: [PATCH 1276/1889] tests/run-make/crate-loading: Rename source files
 for clarity

To make the code easier to understand.
---
 .../{multiple-dep-versions-3.rs => dep-2-reexport.rs}    | 0
 .../{multiple-dep-versions-1.rs => dependency-1.rs}      | 0
 .../{multiple-dep-versions-2.rs => dependency-2.rs}      | 0
 tests/run-make/crate-loading/rmake.rs                    | 9 +++------
 4 files changed, 3 insertions(+), 6 deletions(-)
 rename tests/run-make/crate-loading/{multiple-dep-versions-3.rs => dep-2-reexport.rs} (100%)
 rename tests/run-make/crate-loading/{multiple-dep-versions-1.rs => dependency-1.rs} (100%)
 rename tests/run-make/crate-loading/{multiple-dep-versions-2.rs => dependency-2.rs} (100%)

diff --git a/tests/run-make/crate-loading/multiple-dep-versions-3.rs b/tests/run-make/crate-loading/dep-2-reexport.rs
similarity index 100%
rename from tests/run-make/crate-loading/multiple-dep-versions-3.rs
rename to tests/run-make/crate-loading/dep-2-reexport.rs
diff --git a/tests/run-make/crate-loading/multiple-dep-versions-1.rs b/tests/run-make/crate-loading/dependency-1.rs
similarity index 100%
rename from tests/run-make/crate-loading/multiple-dep-versions-1.rs
rename to tests/run-make/crate-loading/dependency-1.rs
diff --git a/tests/run-make/crate-loading/multiple-dep-versions-2.rs b/tests/run-make/crate-loading/dependency-2.rs
similarity index 100%
rename from tests/run-make/crate-loading/multiple-dep-versions-2.rs
rename to tests/run-make/crate-loading/dependency-2.rs
diff --git a/tests/run-make/crate-loading/rmake.rs b/tests/run-make/crate-loading/rmake.rs
index 6ad456e3e3e57..8f2577861239d 100644
--- a/tests/run-make/crate-loading/rmake.rs
+++ b/tests/run-make/crate-loading/rmake.rs
@@ -6,12 +6,9 @@
 use run_make_support::{diff, 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("dependency-1.rs").run();
+    rustc().input("dependency-2.rs").extra_filename("2").metadata("2").run();
+    rustc().input("dep-2-reexport.rs").extern_("dependency", rust_lib_name("dependency2")).run();
 
     let out = rustc()
         .input("multiple-dep-versions.rs")

From 5e7d34636447a6ae155f4140e7e4cc1ab2b33944 Mon Sep 17 00:00:00 2001
From: rustbot <47979223+rustbot@users.noreply.github.com>
Date: Mon, 22 Sep 2025 19:01:13 +0200
Subject: [PATCH 1277/1889] Update books

---
 src/doc/book            | 2 +-
 src/doc/reference       | 2 +-
 src/doc/rust-by-example | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/doc/book b/src/doc/book
index 3e9dc46aa563c..33f1af40cc44d 160000
--- a/src/doc/book
+++ b/src/doc/book
@@ -1 +1 @@
-Subproject commit 3e9dc46aa563ca0c53ec826c41b05f10c5915925
+Subproject commit 33f1af40cc44dde7e3e892f7a508e6f427d2cbc6
diff --git a/src/doc/reference b/src/doc/reference
index b3ce60628c6f5..cc7247d8dfaef 160000
--- a/src/doc/reference
+++ b/src/doc/reference
@@ -1 +1 @@
-Subproject commit b3ce60628c6f55ab8ff3dba9f3d20203df1c0dee
+Subproject commit cc7247d8dfaef4c39000bb12c55c32ba5b5ba976
diff --git a/src/doc/rust-by-example b/src/doc/rust-by-example
index dd26bc8e726dc..2c9b490d70e53 160000
--- a/src/doc/rust-by-example
+++ b/src/doc/rust-by-example
@@ -1 +1 @@
-Subproject commit dd26bc8e726dc2e73534c8972d4dccd1bed7495f
+Subproject commit 2c9b490d70e535cf166bf17feba59e594579843f

From 88f954453f794e7eaa16a4cb78b63e0777e12c20 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Mon, 22 Sep 2025 20:45:37 +0200
Subject: [PATCH 1278/1889] compiler-team.md: remove obsolete membership level

There used to be compiler team and compiler-contributor team, and those have since been collapsed into 1 team.
---
 src/doc/rustc-dev-guide/src/compiler-team.md | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/compiler-team.md b/src/doc/rustc-dev-guide/src/compiler-team.md
index 896d9e6f6d94c..8c0481f6ea8f5 100644
--- a/src/doc/rustc-dev-guide/src/compiler-team.md
+++ b/src/doc/rustc-dev-guide/src/compiler-team.md
@@ -134,12 +134,3 @@ Getting on the reviewer rotation is much appreciated as it lowers the
 review burden for all of us! However, if you don't have time to give
 people timely feedback on their PRs, it may be better that you don't
 get on the list.
-
-### Full team membership
-
-Full team membership is typically extended once someone made many
-contributions to the Rust compiler over time, ideally (but not
-necessarily) to multiple areas. Sometimes this might be implementing a
-new feature, but it is also important — perhaps more important! — to
-have time and willingness to help out with general upkeep such as
-bugfixes, tracking regressions, and other less glamorous work.

From 24144ff499852b0fab63cf0c93d4c8d8b2fad8ef Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Mon, 22 Sep 2025 21:02:37 +0200
Subject: [PATCH 1279/1889] make rust-analyzer settings use dedicated directory

This avoids rust-analyzer having to wait for a build lock due to ./x
running other commands (and the other way around).
---
 src/bootstrap/src/core/build_steps/setup.rs |  4 ++++
 src/etc/rust_analyzer_eglot.el              |  8 +++++--
 src/etc/rust_analyzer_helix.toml            | 14 ++++++-------
 src/etc/rust_analyzer_settings.json         |  8 +++++--
 src/etc/rust_analyzer_zed.json              | 23 +++++++++++++++++----
 5 files changed, 42 insertions(+), 15 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/setup.rs b/src/bootstrap/src/core/build_steps/setup.rs
index 9f9af1d9abe34..4b0080f1c80a4 100644
--- a/src/bootstrap/src/core/build_steps/setup.rs
+++ b/src/bootstrap/src/core/build_steps/setup.rs
@@ -587,6 +587,7 @@ Select which editor you would like to set up [default: None]: ";
                 "631c837b0e98ae35fd48b0e5f743b1ca60adadf2d0a2b23566ba25df372cf1a9",
                 "080955765db84bb6cbf178879f489c4e2369397626a6ecb3debedb94a9d0b3ce",
                 "f501475c6654187091c924ae26187fa5791d74d4a8ab3fb61fbbe4c0275aade1",
+                "e260553b71e4773c30a63c4b23b42b279fc73e72f95b775c47b7b7c511c51595",
             ],
             EditorKind::Helix => &[
                 "2d3069b8cf1b977e5d4023965eb6199597755e6c96c185ed5f2854f98b83d233",
@@ -594,6 +595,7 @@ Select which editor you would like to set up [default: None]: ";
                 "f252dcc30ca85a193a699581e5e929d5bd6c19d40d7a7ade5e257a9517a124a5",
                 "198c195ed0c070d15907b279b8b4ea96198ca71b939f5376454f3d636ab54da5",
                 "1c43ead340b20792b91d02b08494ee68708e7e09f56b6766629b4b72079208f1",
+                "eec09a09452682060afd23dd5d3536ccac5615b3cdbf427366446901215fb9f6",
             ],
             EditorKind::Vim | EditorKind::VsCode => &[
                 "ea67e259dedf60d4429b6c349a564ffcd1563cf41c920a856d1f5b16b4701ac8",
@@ -610,6 +612,7 @@ Select which editor you would like to set up [default: None]: ";
                 "f954316090936c7e590c253ca9d524008375882fa13c5b41d7e2547a896ff893",
                 "701b73751efd7abd6487f2c79348dab698af7ac4427b79fa3d2087c867144b12",
                 "a61df796c0c007cb6512127330564e49e57d558dec715703916a928b072a1054",
+                "02a49ac2d31f00ef6e4531c44e00dac51cea895112e480553f1ba060b3942a47",
             ],
             EditorKind::Zed => &[
                 "bbce727c269d1bd0c98afef4d612eb4ce27aea3c3a8968c5f10b31affbc40b6c",
@@ -617,6 +620,7 @@ Select which editor you would like to set up [default: None]: ";
                 "2e96bf0d443852b12f016c8fc9840ab3d0a2b4fe0b0fb3a157e8d74d5e7e0e26",
                 "4fadd4c87389a601a27db0d3d74a142fa3a2e656ae78982e934dbe24bee32ad6",
                 "f0bb3d23ab1a49175ab0ef5c4071af95bb03d01d460776cdb716d91333443382",
+                "5ef83292111d9a8bb63b6afc3abf42d0bc78fe24985f0d2e039e73258b5dab8f",
             ],
         }
     }
diff --git a/src/etc/rust_analyzer_eglot.el b/src/etc/rust_analyzer_eglot.el
index 3151cb1a6e755..e5abf67235a5d 100644
--- a/src/etc/rust_analyzer_eglot.el
+++ b/src/etc/rust_analyzer_eglot.el
@@ -6,6 +6,8 @@
                                        :overrideCommand ["python3"
                                                          "x.py"
                                                          "check"
+                                                         "--build-dir"
+                                                         "build-rust-analyzer"
                                                          "--json-output"])
                  :linkedProjects ["Cargo.toml"
                                   "compiler/rustc_codegen_cranelift/Cargo.toml"
@@ -13,9 +15,9 @@
                                   "library/Cargo.toml"
                                   "src/bootstrap/Cargo.toml"
                                   "src/tools/rust-analyzer/Cargo.toml"]
-                 :rustfmt ( :overrideCommand ["build/host/rustfmt/bin/rustfmt"
+                 :rustfmt ( :overrideCommand ["build-rust-analyzer/host/rustfmt/bin/rustfmt"
                                               "--edition=2024"])
-                 :procMacro ( :server "build/host/stage0/libexec/rust-analyzer-proc-macro-srv"
+                 :procMacro ( :server "build-rust-analyzer/host/stage0/libexec/rust-analyzer-proc-macro-srv"
                                       :enable t)
                  :cargo ( :buildScripts ( :enable t
                                                   :invocationLocation "root"
@@ -23,6 +25,8 @@
                                                   :overrideCommand ["python3"
                                                                     "x.py"
                                                                     "check"
+                                                                    "--build-dir"
+                                                                    "build-rust-analyzer"
                                                                     "--json-output"
                                                                     "--compile-time-deps"])]
                                         :sysrootSrc "./library"
diff --git a/src/etc/rust_analyzer_helix.toml b/src/etc/rust_analyzer_helix.toml
index 8c1782a1abce3..e2de2a374cbed 100644
--- a/src/etc/rust_analyzer_helix.toml
+++ b/src/etc/rust_analyzer_helix.toml
@@ -1,10 +1,10 @@
 # This config uses a separate build directory for rust-analyzer,
 # so that r-a's checks don't block user `x` commands and vice-verse.
-# R-a's build directory is located in `build/rust-analyzer`.
+# R-a's build directory is located in `build-rust-analyzer`.
 #
 # To build rustfmt and proc macro server for r-a run the following command:
 # ```
-# x b proc-macro-srv-cli rustfmt --stage 0 --build-dir build/rust-analyzer
+# x b proc-macro-srv-cli rustfmt --stage 0 --build-dir build-rust-analyzer
 # ```
 
 [language-server.rust-analyzer.config]
@@ -26,17 +26,17 @@ overrideCommand = [
     "check",
     "--json-output",
     "--build-dir",
-    "build/rust-analyzer",
+    "build-rust-analyzer",
 ]
 
 [language-server.rust-analyzer.config.rustfmt]
 overrideCommand = [
-    "build/rust-analyzer/host/rustfmt/bin/rustfmt",
+    "build-rust-analyzer/host/rustfmt/bin/rustfmt",
     "--edition=2024"
 ]
 
 [language-server.rust-analyzer.config.procMacro]
-server = "build/rust-analyzer/host/stage0/libexec/rust-analyzer-proc-macro-srv"
+server = "build-rust-analyzer/host/stage0/libexec/rust-analyzer-proc-macro-srv"
 enable = true
 
 [language-server.rust-analyzer.config.rustc]
@@ -58,6 +58,6 @@ overrideCommand = [
     "check",
     "--json-output",
     "--build-dir",
-    "build/rust-analyzer",
-    "--compile-time-deps"
+    "build-rust-analyzer",
+    "--compile-time-deps",
 ]
diff --git a/src/etc/rust_analyzer_settings.json b/src/etc/rust_analyzer_settings.json
index b31169857c5e1..f89e8a2df1878 100644
--- a/src/etc/rust_analyzer_settings.json
+++ b/src/etc/rust_analyzer_settings.json
@@ -5,6 +5,8 @@
         "python3",
         "x.py",
         "check",
+        "--build-dir",
+        "build-rust-analyzer",
         "--json-output"
     ],
     "rust-analyzer.linkedProjects": [
@@ -16,10 +18,10 @@
         "src/tools/rust-analyzer/Cargo.toml"
     ],
     "rust-analyzer.rustfmt.overrideCommand": [
-        "${workspaceFolder}/build/host/rustfmt/bin/rustfmt",
+        "${workspaceFolder}/build-rust-analyzer/host/rustfmt/bin/rustfmt",
         "--edition=2024"
     ],
-    "rust-analyzer.procMacro.server": "${workspaceFolder}/build/host/stage0/libexec/rust-analyzer-proc-macro-srv",
+    "rust-analyzer.procMacro.server": "${workspaceFolder}/build-rust-analyzer/host/stage0/libexec/rust-analyzer-proc-macro-srv",
     "rust-analyzer.procMacro.enable": true,
     "rust-analyzer.cargo.buildScripts.enable": true,
     "rust-analyzer.cargo.buildScripts.invocationStrategy": "once",
@@ -27,6 +29,8 @@
         "python3",
         "x.py",
         "check",
+        "--build-dir",
+        "build-rust-analyzer",
         "--json-output",
         "--compile-time-deps"
     ],
diff --git a/src/etc/rust_analyzer_zed.json b/src/etc/rust_analyzer_zed.json
index 7eace92500e83..d98a082a9b8ad 100644
--- a/src/etc/rust_analyzer_zed.json
+++ b/src/etc/rust_analyzer_zed.json
@@ -7,7 +7,15 @@
             "enable": true,
             "invocationLocation": "root",
             "invocationStrategy": "once",
-            "overrideCommand": ["python3", "x.py", "check", "--json-output", "--compile-time-deps"]
+            "overrideCommand": [
+              "python3",
+              "x.py",
+              "check",
+              "--build-dir",
+              "build-rust-analyzer",
+              "--compile-time-deps",
+              "--json-output"
+            ]
           },
           "extraEnv": {
             "RUSTC_BOOTSTRAP": "1"
@@ -17,7 +25,14 @@
         "check": {
           "invocationLocation": "root",
           "invocationStrategy": "once",
-          "overrideCommand": ["python3", "x.py", "check", "--json-output"]
+          "overrideCommand": [
+            "python3",
+            "x.py",
+            "check",
+            "--json-output",
+            "--build-dir",
+            "build-rust-analyzer"
+          ]
         },
         "linkedProjects": [
           "Cargo.toml",
@@ -29,14 +44,14 @@
         ],
         "procMacro": {
           "enable": true,
-          "server": "build/host/stage0/libexec/rust-analyzer-proc-macro-srv"
+          "server": "build-rust-analyzer/host/stage0/libexec/rust-analyzer-proc-macro-srv"
         },
         "rustc": {
           "source": "./Cargo.toml"
         },
         "rustfmt": {
           "overrideCommand": [
-            "build/host/rustfmt/bin/rustfmt",
+            "build-rust-analyzer/host/rustfmt/bin/rustfmt",
             "--edition=2024"
           ]
         },

From 2d18c886f5754258109fad2e1e0c3bcca0cc9fa5 Mon Sep 17 00:00:00 2001
From: Alex <huangalex409@gmail.com>
Date: Mon, 22 Sep 2025 15:10:41 -0400
Subject: [PATCH 1280/1889] Fix a crash/mislex when more than one frontmatter
 closing possibility is considered

---
 compiler/rustc_lexer/src/lib.rs        |  4 +++-
 tests/ui/frontmatter/unclosed-6.rs     | 12 ++++++++++++
 tests/ui/frontmatter/unclosed-6.stderr | 19 +++++++++++++++++++
 3 files changed, 34 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/frontmatter/unclosed-6.rs
 create mode 100644 tests/ui/frontmatter/unclosed-6.stderr

diff --git a/compiler/rustc_lexer/src/lib.rs b/compiler/rustc_lexer/src/lib.rs
index c29ab569f4795..f6790f7ed1e96 100644
--- a/compiler/rustc_lexer/src/lib.rs
+++ b/compiler/rustc_lexer/src/lib.rs
@@ -599,14 +599,16 @@ impl Cursor<'_> {
             if potential_closing.is_none() {
                 // a less fortunate recovery if all else fails which finds any dashes preceded by whitespace
                 // on a standalone line. Might be wrong.
+                let mut base_index = 0;
                 while let Some(closing) = rest.find("---") {
                     let preceding_chars_start = rest[..closing].rfind("\n").map_or(0, |i| i + 1);
                     if rest[preceding_chars_start..closing].chars().all(is_horizontal_whitespace) {
                         // candidate found
-                        potential_closing = Some(closing);
+                        potential_closing = Some(closing + base_index);
                         break;
                     } else {
                         rest = &rest[closing + 3..];
+                        base_index += closing + 3;
                     }
                 }
             }
diff --git a/tests/ui/frontmatter/unclosed-6.rs b/tests/ui/frontmatter/unclosed-6.rs
new file mode 100644
index 0000000000000..ea8d4702f6307
--- /dev/null
+++ b/tests/ui/frontmatter/unclosed-6.rs
@@ -0,0 +1,12 @@
+---
+//~^ ERROR unclosed frontmatter
+🦀---
+ ---
+
+// This test checks the location of the --- recovered by the parser is not
+// incorrectly tracked during the less fortunate recovery case and multiple
+// candidates are found, as seen with #146847
+
+#![feature(frontmatter)]
+
+fn main() {}
diff --git a/tests/ui/frontmatter/unclosed-6.stderr b/tests/ui/frontmatter/unclosed-6.stderr
new file mode 100644
index 0000000000000..01a13e87268c7
--- /dev/null
+++ b/tests/ui/frontmatter/unclosed-6.stderr
@@ -0,0 +1,19 @@
+error: unclosed frontmatter
+  --> $DIR/unclosed-6.rs:1:1
+   |
+LL | / ---
+LL | |
+LL | | 🦀---
+LL | |  ---
+...  |
+LL | |
+   | |_^
+   |
+note: frontmatter opening here was not closed
+  --> $DIR/unclosed-6.rs:1:1
+   |
+LL | ---
+   | ^^^
+
+error: aborting due to 1 previous error
+

From 819f8b05b90adcf976d9b76e00fe3a9542781bf5 Mon Sep 17 00:00:00 2001
From: Peter Lyons Kehl <peter.kehl@gmail.com>
Date: Mon, 22 Sep 2025 11:40:53 -0700
Subject: [PATCH 1281/1889] Mutex/RwLock/ReentrantLock::data_ptr to be const fn

---
 library/std/src/sync/nonpoison/mutex.rs  | 2 +-
 library/std/src/sync/nonpoison/rwlock.rs | 2 +-
 library/std/src/sync/poison/mutex.rs     | 2 +-
 library/std/src/sync/poison/rwlock.rs    | 2 +-
 library/std/src/sync/reentrant_lock.rs   | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/library/std/src/sync/nonpoison/mutex.rs b/library/std/src/sync/nonpoison/mutex.rs
index 07430ce3a1393..eeecf5d710767 100644
--- a/library/std/src/sync/nonpoison/mutex.rs
+++ b/library/std/src/sync/nonpoison/mutex.rs
@@ -373,7 +373,7 @@ impl<T: ?Sized> Mutex<T> {
     /// or written through after the mutex is dropped.
     #[unstable(feature = "mutex_data_ptr", issue = "140368")]
     // #[unstable(feature = "nonpoison_mutex", issue = "134645")]
-    pub fn data_ptr(&self) -> *mut T {
+    pub const fn data_ptr(&self) -> *mut T {
         self.data.get()
     }
 }
diff --git a/library/std/src/sync/nonpoison/rwlock.rs b/library/std/src/sync/nonpoison/rwlock.rs
index eb0aef99cc1e7..b2f26edc083e9 100644
--- a/library/std/src/sync/nonpoison/rwlock.rs
+++ b/library/std/src/sync/nonpoison/rwlock.rs
@@ -495,7 +495,7 @@ impl<T: ?Sized> RwLock<T> {
     /// or written through after the lock is dropped.
     #[unstable(feature = "rwlock_data_ptr", issue = "140368")]
     // #[unstable(feature = "nonpoison_rwlock", issue = "134645")]
-    pub fn data_ptr(&self) -> *mut T {
+    pub const fn data_ptr(&self) -> *mut T {
         self.data.get()
     }
 }
diff --git a/library/std/src/sync/poison/mutex.rs b/library/std/src/sync/poison/mutex.rs
index 7e9d920d92f85..6fdb4f6799ee5 100644
--- a/library/std/src/sync/poison/mutex.rs
+++ b/library/std/src/sync/poison/mutex.rs
@@ -668,7 +668,7 @@ impl<T: ?Sized> Mutex<T> {
     /// are properly synchronized to avoid data races, and that it is not read
     /// or written through after the mutex is dropped.
     #[unstable(feature = "mutex_data_ptr", issue = "140368")]
-    pub fn data_ptr(&self) -> *mut T {
+    pub const fn data_ptr(&self) -> *mut T {
         self.data.get()
     }
 }
diff --git a/library/std/src/sync/poison/rwlock.rs b/library/std/src/sync/poison/rwlock.rs
index 0a463f3f9c7e3..e3a72c73bf4ed 100644
--- a/library/std/src/sync/poison/rwlock.rs
+++ b/library/std/src/sync/poison/rwlock.rs
@@ -667,7 +667,7 @@ impl<T: ?Sized> RwLock<T> {
     /// are properly synchronized to avoid data races, and that it is not read
     /// or written through after the lock is dropped.
     #[unstable(feature = "rwlock_data_ptr", issue = "140368")]
-    pub fn data_ptr(&self) -> *mut T {
+    pub const fn data_ptr(&self) -> *mut T {
         self.data.get()
     }
 }
diff --git a/library/std/src/sync/reentrant_lock.rs b/library/std/src/sync/reentrant_lock.rs
index 4140718560c65..f560b616dd922 100644
--- a/library/std/src/sync/reentrant_lock.rs
+++ b/library/std/src/sync/reentrant_lock.rs
@@ -355,7 +355,7 @@ impl<T: ?Sized> ReentrantLock<T> {
     /// properly synchronized to avoid data races, and that it is not read
     /// through after the lock is dropped.
     #[unstable(feature = "reentrant_lock_data_ptr", issue = "140368")]
-    pub fn data_ptr(&self) -> *const T {
+    pub const fn data_ptr(&self) -> *const T {
         &raw const self.data
     }
 

From 82c4018619b8ec48807151ce1164c9649e998b4d Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Mon, 22 Sep 2025 11:20:52 -0500
Subject: [PATCH 1282/1889] fix ICE in rustdoc::invalid_html_tags

---
 src/librustdoc/passes/lint/html_tags.rs       |  3 +-
 .../lints/invalid-html-tags-ice-146890.rs     | 25 ++++++++++++
 .../lints/invalid-html-tags-ice-146890.stderr | 38 +++++++++++++++++++
 3 files changed, 65 insertions(+), 1 deletion(-)
 create mode 100644 tests/rustdoc-ui/lints/invalid-html-tags-ice-146890.rs
 create mode 100644 tests/rustdoc-ui/lints/invalid-html-tags-ice-146890.stderr

diff --git a/src/librustdoc/passes/lint/html_tags.rs b/src/librustdoc/passes/lint/html_tags.rs
index da09117b1bba7..136ff258048bf 100644
--- a/src/librustdoc/passes/lint/html_tags.rs
+++ b/src/librustdoc/passes/lint/html_tags.rs
@@ -364,6 +364,7 @@ impl TagParser {
             } else {
                 if !self.tag_name.is_empty() {
                     self.in_attrs = true;
+                    // range of the entire tag within dox
                     let mut r = Range { start: range.start + start_pos, end: range.start + pos };
                     if c == '>' {
                         // In case we have a tag without attribute, we can consider the span to
@@ -381,7 +382,7 @@ impl TagParser {
                             for (new_pos, c) in text[pos..].char_indices() {
                                 if !c.is_whitespace() {
                                     if c == '>' {
-                                        r.end = range.start + new_pos + 1;
+                                        r.end = range.start + pos + new_pos + 1;
                                         found = true;
                                     } else if c == '<' {
                                         self.handle_lt_in_tag(range.clone(), pos + new_pos, f);
diff --git a/tests/rustdoc-ui/lints/invalid-html-tags-ice-146890.rs b/tests/rustdoc-ui/lints/invalid-html-tags-ice-146890.rs
new file mode 100644
index 0000000000000..d7efc201e7e39
--- /dev/null
+++ b/tests/rustdoc-ui/lints/invalid-html-tags-ice-146890.rs
@@ -0,0 +1,25 @@
+// this test ensures that bad HTML with multiline tags doesn't cause an ICE
+// regression test for https://github.com/rust-lang/rust/issues/146890
+#[deny(rustdoc::invalid_html_tags)]
+
+/// <TABLE
+/// BORDER>
+/// <TR
+/// >
+/// <TH
+//~^ ERROR: unclosed HTML tag `TH`
+/// >key
+/// </TD
+//~^ ERROR: unopened HTML tag `TD`
+/// >
+/// <TH
+//~^ ERROR: unclosed HTML tag `TH`
+/// >value
+/// </TD
+//~^ ERROR: unopened HTML tag `TD`
+/// >
+/// </TR
+/// >
+/// </TABLE
+/// >
+pub fn foo() {}
diff --git a/tests/rustdoc-ui/lints/invalid-html-tags-ice-146890.stderr b/tests/rustdoc-ui/lints/invalid-html-tags-ice-146890.stderr
new file mode 100644
index 0000000000000..64a82b3a952aa
--- /dev/null
+++ b/tests/rustdoc-ui/lints/invalid-html-tags-ice-146890.stderr
@@ -0,0 +1,38 @@
+error: unopened HTML tag `TD`
+  --> $DIR/invalid-html-tags-ice-146890.rs:12:5
+   |
+LL |   /// </TD
+   |  _____^
+LL | |
+LL | | /// >
+   | |_____^
+   |
+note: the lint level is defined here
+  --> $DIR/invalid-html-tags-ice-146890.rs:3:8
+   |
+LL | #[deny(rustdoc::invalid_html_tags)]
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: unopened HTML tag `TD`
+  --> $DIR/invalid-html-tags-ice-146890.rs:18:5
+   |
+LL |   /// </TD
+   |  _____^
+LL | |
+LL | | /// >
+   | |_____^
+
+error: unclosed HTML tag `TH`
+  --> $DIR/invalid-html-tags-ice-146890.rs:9:5
+   |
+LL | /// <TH
+   |     ^^^
+
+error: unclosed HTML tag `TH`
+  --> $DIR/invalid-html-tags-ice-146890.rs:15:5
+   |
+LL | /// <TH
+   |     ^^^
+
+error: aborting due to 4 previous errors
+

From 60f60127e79672953eb1ccd1ba48a518cd05224d Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Mon, 22 Sep 2025 22:02:24 +0200
Subject: [PATCH 1283/1889] add regression test for issue 146537

---
 .../suggestions/non_copy_move_out_of_tuple.rs |  8 ++++++
 .../non_copy_move_out_of_tuple.stderr         | 26 +++++++++++++++++++
 2 files changed, 34 insertions(+)
 create mode 100644 tests/ui/suggestions/non_copy_move_out_of_tuple.rs
 create mode 100644 tests/ui/suggestions/non_copy_move_out_of_tuple.stderr

diff --git a/tests/ui/suggestions/non_copy_move_out_of_tuple.rs b/tests/ui/suggestions/non_copy_move_out_of_tuple.rs
new file mode 100644
index 0000000000000..baf15dba33a96
--- /dev/null
+++ b/tests/ui/suggestions/non_copy_move_out_of_tuple.rs
@@ -0,0 +1,8 @@
+// Regression test for #146537.
+
+struct NonCopy;
+fn main() {
+    let tuple = &(NonCopy,);
+    let b: NonCopy;
+    (b,) = *tuple; //~ ERROR: cannot move out of `tuple.0` which is behind a shared reference [E0507]
+}
diff --git a/tests/ui/suggestions/non_copy_move_out_of_tuple.stderr b/tests/ui/suggestions/non_copy_move_out_of_tuple.stderr
new file mode 100644
index 0000000000000..62f24324fcc17
--- /dev/null
+++ b/tests/ui/suggestions/non_copy_move_out_of_tuple.stderr
@@ -0,0 +1,26 @@
+error[E0507]: cannot move out of `tuple.0` which is behind a shared reference
+  --> $DIR/non_copy_move_out_of_tuple.rs:7:12
+   |
+LL |     (b,) = *tuple;
+   |      -     ^^^^^^
+   |      |
+   |      data moved here
+   |      move occurs because the place has type `NonCopy`, which does not implement the `Copy` trait
+   |
+note: if `NonCopy` implemented `Clone`, you could clone the value
+  --> $DIR/non_copy_move_out_of_tuple.rs:3:1
+   |
+LL | struct NonCopy;
+   | ^^^^^^^^^^^^^^ consider implementing `Clone` for this type
+...
+LL |     (b,) = *tuple;
+   |      - you could clone this value
+help: consider removing the dereference here
+   |
+LL -     (b,) = *tuple;
+LL +     (b,) = tuple;
+   |
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0507`.

From 389a502ade65e82d8a0c4d323118121c1c09c4f8 Mon Sep 17 00:00:00 2001
From: Josh Stone <jistone@redhat.com>
Date: Fri, 19 Sep 2025 17:16:05 -0700
Subject: [PATCH 1284/1889] Fix a dangling reference in `rustc_thread_pool`

---
 compiler/rustc_thread_pool/src/latch.rs | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_thread_pool/src/latch.rs b/compiler/rustc_thread_pool/src/latch.rs
index 18d654d9f7828..58dabaf35c005 100644
--- a/compiler/rustc_thread_pool/src/latch.rs
+++ b/compiler/rustc_thread_pool/src/latch.rs
@@ -388,13 +388,17 @@ impl Latch for CountLatch {
     #[inline]
     unsafe fn set(this: *const Self) {
         if unsafe { (*this).counter.fetch_sub(1, Ordering::SeqCst) == 1 } {
-            // NOTE: Once we call `set` on the internal `latch`,
+            // SAFETY: Once we call `set` on the internal `latch`,
             // the target may proceed and invalidate `this`!
             match unsafe { &(*this).kind } {
                 CountLatchKind::Stealing { latch, registry, worker_index } => {
                     let registry = Arc::clone(registry);
+                    let worker_index = *worker_index;
+                    // SAFETY: We don't use any references from `this` after this call.
                     if unsafe { CoreLatch::set(latch) } {
-                        registry.notify_worker_latch_is_set(*worker_index);
+                        // We **must not** access any part of `this` anymore, which
+                        // is why we read and shadowed these fields beforehand.
+                        registry.notify_worker_latch_is_set(worker_index);
                     }
                 }
                 CountLatchKind::Blocking { latch } => unsafe { LockLatch::set(latch) },

From 2ba71fba652720807a2c8cd5c35c230943ce06e9 Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Fri, 15 Aug 2025 15:59:28 +0000
Subject: [PATCH 1285/1889] Use ns versions of with_diagnostics queries

---
 src/tools/rust-analyzer/crates/hir/src/lib.rs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index f8dacf0fb863d..f231348d24a4b 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -680,7 +680,7 @@ impl Module {
                             push_ty_diagnostics(
                                 db,
                                 acc,
-                                db.field_types_with_diagnostics(s.id.into()).1,
+                                db.field_types_with_diagnostics_ns(s.id.into()).1,
                                 source_map,
                             );
                         }
@@ -692,7 +692,7 @@ impl Module {
                             push_ty_diagnostics(
                                 db,
                                 acc,
-                                db.field_types_with_diagnostics(u.id.into()).1,
+                                db.field_types_with_diagnostics_ns(u.id.into()).1,
                                 source_map,
                             );
                         }
@@ -722,7 +722,7 @@ impl Module {
                                 push_ty_diagnostics(
                                     db,
                                     acc,
-                                    db.field_types_with_diagnostics(v.into()).1,
+                                    db.field_types_with_diagnostics_ns(v.into()).1,
                                     source_map,
                                 );
                                 expr_store_diagnostics(db, acc, source_map);
@@ -738,7 +738,7 @@ impl Module {
                     push_ty_diagnostics(
                         db,
                         acc,
-                        db.type_for_type_alias_with_diagnostics(type_alias.id).1,
+                        db.type_for_type_alias_with_diagnostics_ns(type_alias.id).1,
                         &source_map,
                     );
                     acc.extend(def.diagnostics(db, style_lints));
@@ -913,13 +913,13 @@ impl Module {
             push_ty_diagnostics(
                 db,
                 acc,
-                db.impl_self_ty_with_diagnostics(impl_def.id).1,
+                db.impl_self_ty_with_diagnostics_ns(impl_def.id).1,
                 &source_map,
             );
             push_ty_diagnostics(
                 db,
                 acc,
-                db.impl_trait_with_diagnostics(impl_def.id).and_then(|it| it.1),
+                db.impl_trait_with_diagnostics_ns(impl_def.id).and_then(|it| it.1),
                 &source_map,
             );
 
@@ -3646,7 +3646,7 @@ impl AssocItem {
                 push_ty_diagnostics(
                     db,
                     acc,
-                    db.type_for_type_alias_with_diagnostics(type_alias.id).1,
+                    db.type_for_type_alias_with_diagnostics_ns(type_alias.id).1,
                     &db.type_alias_signature_with_source_map(type_alias.id).1,
                 );
                 for diag in hir_ty::diagnostics::incorrect_case(db, type_alias.id.into()) {
@@ -3782,7 +3782,7 @@ impl GenericDef {
                 push_ty_diagnostics(
                     db,
                     acc,
-                    db.const_param_ty_with_diagnostics(ConstParamId::from_unchecked(
+                    db.const_param_ty_with_diagnostics_ns(ConstParamId::from_unchecked(
                         TypeOrConstParamId { parent: def, local_id: param_id },
                     ))
                     .1,

From 9e8f6e82b1b76055edb33b1d8de1263344c50cc0 Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Sun, 17 Aug 2025 16:02:17 +0000
Subject: [PATCH 1286/1889] Make Field::ty return TypeNs

---
 .../crates/hir-ty/src/next_solver/mapping.rs  |  2 +-
 .../rust-analyzer/crates/hir/src/display.rs   |  8 ++++-
 src/tools/rust-analyzer/crates/hir/src/lib.rs | 33 ++++++++++---------
 .../src/handlers/add_missing_match_arms.rs    |  2 +-
 .../src/handlers/expand_rest_pattern.rs       |  7 ++--
 .../ide-completion/src/completions/record.rs  | 12 +++++--
 .../crates/ide/src/goto_type_definition.rs    |  2 +-
 .../rust-analyzer/crates/ide/src/hover.rs     |  4 +--
 .../crates/ide/src/hover/render.rs            |  8 ++---
 .../crates/ide/src/signature_help.rs          |  2 +-
 .../crates/ide/src/view_memory_layout.rs      |  2 +-
 11 files changed, 51 insertions(+), 31 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
index b24b996b0927c..5dcb1e62329d0 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
@@ -1266,7 +1266,7 @@ pub fn convert_args_for_result<'db>(
     Substitution::from_iter(Interner, substs)
 }
 
-pub(crate) fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>) -> crate::Ty {
+pub fn convert_ty_for_result<'db>(interner: DbInterner<'db>, ty: Ty<'db>) -> crate::Ty {
     use crate::{Scalar, TyKind};
     use chalk_ir::{FloatTy, IntTy, UintTy};
     match ty.kind() {
diff --git a/src/tools/rust-analyzer/crates/hir/src/display.rs b/src/tools/rust-analyzer/crates/hir/src/display.rs
index 833a9ef03065d..2bf9bb85e50dd 100644
--- a/src/tools/rust-analyzer/crates/hir/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/display.rs
@@ -24,7 +24,7 @@ use crate::{
     Adt, AsAssocItem, AssocItem, AssocItemContainer, Const, ConstParam, Crate, Enum,
     ExternCrateDecl, Field, Function, GenericParam, HasCrate, HasVisibility, Impl, LifetimeParam,
     Macro, Module, SelfParam, Static, Struct, StructKind, Trait, TraitRef, TupleField, TyBuilder,
-    Type, TypeAlias, TypeOrConstParam, TypeParam, Union, Variant,
+    Type, TypeAlias, TypeNs, TypeOrConstParam, TypeParam, Union, Variant,
 };
 
 impl HirDisplay for Function {
@@ -437,6 +437,12 @@ impl HirDisplay for Type<'_> {
     }
 }
 
+impl HirDisplay for TypeNs<'_> {
+    fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
+        self.ty.hir_fmt(f)
+    }
+}
+
 impl HirDisplay for ExternCrateDecl {
     fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
         write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index f231348d24a4b..1cec01da6008e 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -86,7 +86,9 @@ use hir_ty::{
     method_resolution,
     mir::{MutBorrowKind, interpret_mir},
     next_solver::{
-        ClauseKind, DbInterner, GenericArgs, infer::InferCtxt, mapping::ChalkToNextSolver,
+        ClauseKind, DbInterner, GenericArgs,
+        infer::InferCtxt,
+        mapping::{ChalkToNextSolver, convert_ty_for_result},
     },
     primitive::UintTy,
     traits::FnTrait,
@@ -1346,19 +1348,12 @@ impl Field {
         u32::from(self.id.into_raw()) as usize
     }
 
-    /// Returns the type as in the signature of the struct (i.e., with
-    /// placeholder types for type parameters). Only use this in the context of
-    /// the field definition.
-    pub fn ty<'db>(&self, db: &'db dyn HirDatabase) -> Type<'db> {
+    /// Returns the type as in the signature of the struct. Only use this in the
+    /// context of the field definition.
+    pub fn ty<'db>(&self, db: &'db dyn HirDatabase) -> TypeNs<'db> {
         let var_id = self.parent.into();
-        let generic_def_id: GenericDefId = match self.parent {
-            VariantDef::Struct(it) => it.id.into(),
-            VariantDef::Union(it) => it.id.into(),
-            VariantDef::Variant(it) => it.id.lookup(db).parent.into(),
-        };
-        let substs = TyBuilder::placeholder_subst(db, generic_def_id);
-        let ty = db.field_types(var_id)[self.id].clone().substitute(Interner, &substs);
-        Type::new(db, var_id, ty)
+        let ty = db.field_types_ns(var_id)[self.id].skip_binder();
+        TypeNs::new(db, var_id, ty)
     }
 
     // FIXME: Find better API to also handle const generics
@@ -1388,9 +1383,8 @@ impl Field {
     }
 
     pub fn layout(&self, db: &dyn HirDatabase) -> Result<Layout, LayoutError> {
-        let interner = DbInterner::new_with(db, None, None);
         db.layout_of_ty(
-            self.ty(db).ty.to_nextsolver(interner),
+            self.ty(db).ty,
             db.trait_environment(match hir_def::VariantId::from(self.parent) {
                 hir_def::VariantId::EnumVariantId(id) => {
                     GenericDefId::AdtId(id.lookup(db).parent.into())
@@ -5969,6 +5963,11 @@ impl<'db> TypeNs<'db> {
         TypeNs { env: environment, ty, _pd: PhantomCovariantLifetime::new() }
     }
 
+    pub fn to_type(&self, db: &'db dyn HirDatabase) -> Type<'db> {
+        let interner = DbInterner::new_with(db, Some(self.env.krate), self.env.block);
+        Type { env: self.env.clone(), ty: convert_ty_for_result(interner, self.ty), _pd: self._pd }
+    }
+
     // FIXME: Find better API that also handles const generics
     pub fn impls_trait(&self, infcx: InferCtxt<'db>, trait_: Trait, args: &[TypeNs<'db>]) -> bool {
         let args = GenericArgs::new_from_iter(
@@ -5992,6 +5991,10 @@ impl<'db> TypeNs<'db> {
         let res = hir_ty::traits::next_trait_solve_in_ctxt(&infcx, goal);
         res.map_or(false, |res| matches!(res.1, rustc_type_ir::solve::Certainty::Yes))
     }
+
+    pub fn is_bool(&self) -> bool {
+        matches!(self.ty.kind(), rustc_type_ir::TyKind::Bool)
+    }
 }
 
 #[derive(Debug, PartialEq, Eq, Copy, Clone, Hash)]
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs
index 4d3212c515f28..3910921fbe03a 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs
@@ -521,7 +521,7 @@ fn build_pat(
                 hir::StructKind::Tuple => {
                     let mut name_generator = suggest_name::NameGenerator::default();
                     let pats = fields.into_iter().map(|f| {
-                        let name = name_generator.for_type(&f.ty(db), db, edition);
+                        let name = name_generator.for_type(&f.ty(db).to_type(db), db, edition);
                         match name {
                             Some(name) => make::ext::simple_ident_pat(make.name(&name)).into(),
                             None => make.wildcard_pat().into(),
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/expand_rest_pattern.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/expand_rest_pattern.rs
index c80b78fd97056..1c0d330fc3793 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/expand_rest_pattern.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/expand_rest_pattern.rs
@@ -145,8 +145,11 @@ fn expand_tuple_struct_rest_pattern(
                         make.ident_pat(
                             false,
                             false,
-                            match name_gen.for_type(&f.ty(ctx.sema.db), ctx.sema.db, ctx.edition())
-                            {
+                            match name_gen.for_type(
+                                &f.ty(ctx.sema.db).to_type(ctx.sema.db),
+                                ctx.sema.db,
+                                ctx.edition(),
+                            ) {
                                 Some(name) => make.name(&name),
                                 None => make.name(&format!("_{}", f.index())),
                             },
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/record.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/record.rs
index 36f38a70db638..2f5abd18934fc 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/record.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/record.rs
@@ -28,7 +28,11 @@ pub(crate) fn complete_record_pattern_fields(
                     record_pat.record_pat_field_list().and_then(|fl| fl.fields().next()).is_some();
 
                 match were_fields_specified {
-                    false => un.fields(ctx.db).into_iter().map(|f| (f, f.ty(ctx.db))).collect(),
+                    false => un
+                        .fields(ctx.db)
+                        .into_iter()
+                        .map(|f| (f, f.ty(ctx.db).to_type(ctx.db)))
+                        .collect(),
                     true => return,
                 }
             }
@@ -56,7 +60,11 @@ pub(crate) fn complete_record_expr_fields(
                 record_expr.record_expr_field_list().and_then(|fl| fl.fields().next()).is_some();
 
             match were_fields_specified {
-                false => un.fields(ctx.db).into_iter().map(|f| (f, f.ty(ctx.db))).collect(),
+                false => un
+                    .fields(ctx.db)
+                    .into_iter()
+                    .map(|f| (f, f.ty(ctx.db).to_type(ctx.db)))
+                    .collect(),
                 true => return,
             }
         }
diff --git a/src/tools/rust-analyzer/crates/ide/src/goto_type_definition.rs b/src/tools/rust-analyzer/crates/ide/src/goto_type_definition.rs
index ffd144a827e34..ae208fe1b5615 100644
--- a/src/tools/rust-analyzer/crates/ide/src/goto_type_definition.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/goto_type_definition.rs
@@ -88,7 +88,7 @@ pub(crate) fn goto_type_definition(
                             ast::Pat(it) => sema.type_of_pat(&it)?.original,
                             ast::SelfParam(it) => sema.type_of_self(&it)?,
                             ast::Type(it) => sema.resolve_type(&it)?,
-                            ast::RecordField(it) => sema.to_def(&it)?.ty(db),
+                            ast::RecordField(it) => sema.to_def(&it)?.ty(db).to_type(db),
                             // can't match on RecordExprField directly as `ast::Expr` will match an iteration too early otherwise
                             ast::NameRef(it) => {
                                 if let Some(record_field) = ast::RecordExprField::for_name_ref(&it) {
diff --git a/src/tools/rust-analyzer/crates/ide/src/hover.rs b/src/tools/rust-analyzer/crates/ide/src/hover.rs
index 03b9b3677511c..c4fb6d1a5b4b4 100644
--- a/src/tools/rust-analyzer/crates/ide/src/hover.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/hover.rs
@@ -440,7 +440,7 @@ pub(crate) fn hover_for_definition(
         Definition::Local(it) => Some(it.ty(db)),
         Definition::GenericParam(hir::GenericParam::ConstParam(it)) => Some(it.ty(db)),
         Definition::GenericParam(hir::GenericParam::TypeParam(it)) => Some(it.ty(db)),
-        Definition::Field(field) => Some(field.ty(db)),
+        Definition::Field(field) => Some(field.ty(db).to_type(db)),
         Definition::TupleField(it) => Some(it.ty(db)),
         Definition::Function(it) => Some(it.ty(db)),
         Definition::Adt(it) => Some(it.ty(db)),
@@ -602,7 +602,7 @@ fn goto_type_action_for_def(
 
     let ty = match def {
         Definition::Local(it) => Some(it.ty(db)),
-        Definition::Field(field) => Some(field.ty(db)),
+        Definition::Field(field) => Some(field.ty(db).to_type(db)),
         Definition::TupleField(field) => Some(field.ty(db)),
         Definition::Const(it) => Some(it.ty(db)),
         Definition::Static(it) => Some(it.ty(db)),
diff --git a/src/tools/rust-analyzer/crates/ide/src/hover/render.rs b/src/tools/rust-analyzer/crates/ide/src/hover/render.rs
index 65375ed8f78c0..c5d695ccec3a7 100644
--- a/src/tools/rust-analyzer/crates/ide/src/hover/render.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/hover/render.rs
@@ -692,14 +692,14 @@ pub(super) fn definition(
         }
         let drop_info = match def {
             Definition::Field(field) => {
-                DropInfo { drop_glue: field.ty(db).drop_glue(db), has_dtor: None }
+                DropInfo { drop_glue: field.ty(db).to_type(db).drop_glue(db), has_dtor: None }
             }
             Definition::Adt(Adt::Struct(strukt)) => {
                 let struct_drop_glue = strukt.ty_placeholders(db).drop_glue(db);
                 let mut fields_drop_glue = strukt
                     .fields(db)
                     .iter()
-                    .map(|field| field.ty(db).drop_glue(db))
+                    .map(|field| field.ty(db).to_type(db).drop_glue(db))
                     .max()
                     .unwrap_or(DropGlue::None);
                 let has_dtor = match (fields_drop_glue, struct_drop_glue) {
@@ -727,7 +727,7 @@ pub(super) fn definition(
                         variant
                             .fields(db)
                             .iter()
-                            .map(|field| field.ty(db).drop_glue(db))
+                            .map(|field| field.ty(db).to_type(db).drop_glue(db))
                             .max()
                             .unwrap_or(DropGlue::None)
                     })
@@ -742,7 +742,7 @@ pub(super) fn definition(
                 let fields_drop_glue = variant
                     .fields(db)
                     .iter()
-                    .map(|field| field.ty(db).drop_glue(db))
+                    .map(|field| field.ty(db).to_type(db).drop_glue(db))
                     .max()
                     .unwrap_or(DropGlue::None);
                 DropInfo { drop_glue: fields_drop_glue, has_dtor: None }
diff --git a/src/tools/rust-analyzer/crates/ide/src/signature_help.rs b/src/tools/rust-analyzer/crates/ide/src/signature_help.rs
index f45d096ac1904..e74d997e97c52 100644
--- a/src/tools/rust-analyzer/crates/ide/src/signature_help.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/signature_help.rs
@@ -526,7 +526,7 @@ fn signature_help_for_tuple_struct_pat(
         pat.syntax(),
         token,
         pat.fields(),
-        fields.into_iter().map(|it| it.ty(db)),
+        fields.into_iter().map(|it| it.ty(db).to_type(db)),
         display_target,
     ))
 }
diff --git a/src/tools/rust-analyzer/crates/ide/src/view_memory_layout.rs b/src/tools/rust-analyzer/crates/ide/src/view_memory_layout.rs
index 950f3f6c64706..5457d57b3976e 100644
--- a/src/tools/rust-analyzer/crates/ide/src/view_memory_layout.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/view_memory_layout.rs
@@ -99,7 +99,7 @@ pub(crate) fn view_memory_layout(
         Definition::BuiltinType(it) => it.ty(db),
         Definition::SelfType(it) => it.self_ty(db),
         Definition::Local(it) => it.ty(db),
-        Definition::Field(it) => it.ty(db),
+        Definition::Field(it) => salsa::attach(db, || it.ty(db).to_type(db)),
         Definition::Const(it) => it.ty(db),
         Definition::Static(it) => it.ty(db),
         _ => return None,

From 263b2a5c277a26c3d686bbbe1c4a194ad601f341 Mon Sep 17 00:00:00 2001
From: Jack Huey <31162821+jackh726@users.noreply.github.com>
Date: Thu, 11 Sep 2025 04:47:39 -0400
Subject: [PATCH 1287/1889] Add 'db to TraitEnvironment

---
 .../crates/hir-ty/src/autoderef.rs            |  8 ++--
 .../crates/hir-ty/src/consteval.rs            |  4 +-
 .../rust-analyzer/crates/hir-ty/src/db.rs     | 21 +++++----
 .../crates/hir-ty/src/diagnostics/expr.rs     |  8 ++--
 .../diagnostics/match_check/pat_analysis.rs   |  4 +-
 .../crates/hir-ty/src/display.rs              | 10 ++--
 .../rust-analyzer/crates/hir-ty/src/drop.rs   | 12 +++--
 .../rust-analyzer/crates/hir-ty/src/infer.rs  |  2 +-
 .../crates/hir-ty/src/infer/coerce.rs         |  8 ++--
 .../crates/hir-ty/src/infer/unify.rs          | 10 ++--
 .../crates/hir-ty/src/inhabitedness.rs        |  6 +--
 .../rust-analyzer/crates/hir-ty/src/layout.rs |  6 +--
 .../crates/hir-ty/src/layout/adt.rs           |  4 +-
 .../rust-analyzer/crates/hir-ty/src/lib.rs    |  6 +--
 .../rust-analyzer/crates/hir-ty/src/lower.rs  |  8 ++--
 .../crates/hir-ty/src/method_resolution.rs    | 46 +++++++++----------
 .../crates/hir-ty/src/mir/eval.rs             | 14 +++---
 .../crates/hir-ty/src/mir/lower.rs            |  2 +-
 .../crates/hir-ty/src/mir/monomorphization.rs | 20 ++++----
 .../rust-analyzer/crates/hir-ty/src/traits.rs | 20 +++++---
 src/tools/rust-analyzer/crates/hir/src/lib.rs | 10 ++--
 .../crates/hir/src/source_analyzer.rs         |  2 +-
 22 files changed, 122 insertions(+), 109 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs b/src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs
index fd60ffcf24b0a..4c79c800fcf3b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs
@@ -32,11 +32,11 @@ const AUTODEREF_RECURSION_LIMIT: usize = 20;
 /// - the yielded types don't contain inference variables (but may contain `TyKind::Error`).
 /// - a type won't be yielded more than once; in other words, the returned iterator will stop if it
 ///   detects a cycle in the deref chain.
-pub fn autoderef(
-    db: &dyn HirDatabase,
-    env: Arc<TraitEnvironment>,
+pub fn autoderef<'db>(
+    db: &'db dyn HirDatabase,
+    env: Arc<TraitEnvironment<'db>>,
     ty: crate::Canonical<crate::Ty>,
-) -> impl Iterator<Item = crate::Ty> {
+) -> impl Iterator<Item = crate::Ty> + use<> {
     let mut table = InferenceTable::new(db, env);
     let interner = table.interner;
     let ty = table.instantiate_canonical(ty);
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
index 0f2cc17f563dd..e2a8d1cedc284 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
@@ -229,7 +229,7 @@ pub(crate) fn const_eval_cycle_result(
     _: &dyn HirDatabase,
     _: GeneralConstId,
     _: Substitution,
-    _: Option<Arc<TraitEnvironment>>,
+    _: Option<Arc<TraitEnvironment<'_>>>,
 ) -> Result<Const, ConstEvalError> {
     Err(ConstEvalError::MirLowerError(MirLowerError::Loop))
 }
@@ -252,7 +252,7 @@ pub(crate) fn const_eval_query(
     db: &dyn HirDatabase,
     def: GeneralConstId,
     subst: Substitution,
-    trait_env: Option<Arc<TraitEnvironment>>,
+    trait_env: Option<Arc<TraitEnvironment<'_>>>,
 ) -> Result<Const, ConstEvalError> {
     let body = match def {
         GeneralConstId::ConstId(c) => {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
index 448fc4aede037..24e617135160d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
@@ -49,7 +49,7 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
         &self,
         def: DefWithBodyId,
         subst: Substitution,
-        env: Arc<TraitEnvironment>,
+        env: Arc<TraitEnvironment<'_>>,
     ) -> Result<Arc<MirBody>, MirLowerError>;
 
     #[salsa::invoke(crate::mir::monomorphized_mir_body_for_closure_query)]
@@ -57,7 +57,7 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
         &self,
         def: InternedClosureId,
         subst: Substitution,
-        env: Arc<TraitEnvironment>,
+        env: Arc<TraitEnvironment<'_>>,
     ) -> Result<Arc<MirBody>, MirLowerError>;
 
     #[salsa::invoke(crate::mir::borrowck_query)]
@@ -70,7 +70,7 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
         &self,
         def: GeneralConstId,
         subst: Substitution,
-        trait_env: Option<Arc<TraitEnvironment>>,
+        trait_env: Option<Arc<TraitEnvironment<'_>>>,
     ) -> Result<Const, ConstEvalError>;
 
     #[salsa::invoke(crate::consteval::const_eval_static_query)]
@@ -84,7 +84,7 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
     #[salsa::invoke(crate::method_resolution::lookup_impl_method_query)]
     fn lookup_impl_method(
         &self,
-        env: Arc<TraitEnvironment>,
+        env: Arc<TraitEnvironment<'_>>,
         func: FunctionId,
         fn_subst: Substitution,
     ) -> (FunctionId, Substitution);
@@ -97,7 +97,7 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
         &'db self,
         def: AdtId,
         args: crate::next_solver::GenericArgs<'db>,
-        trait_env: Arc<TraitEnvironment>,
+        trait_env: Arc<TraitEnvironment<'db>>,
     ) -> Result<Arc<Layout>, LayoutError>;
 
     #[salsa::invoke(crate::layout::layout_of_ty_query)]
@@ -105,7 +105,7 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
     fn layout_of_ty<'db>(
         &'db self,
         ty: crate::next_solver::Ty<'db>,
-        env: Arc<TraitEnvironment>,
+        env: Arc<TraitEnvironment<'db>>,
     ) -> Result<Arc<Layout>, LayoutError>;
 
     #[salsa::invoke(crate::layout::target_data_layout_query)]
@@ -184,10 +184,11 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
 
     #[salsa::invoke(crate::lower::trait_environment_for_body_query)]
     #[salsa::transparent]
-    fn trait_environment_for_body(&self, def: DefWithBodyId) -> Arc<TraitEnvironment>;
+    fn trait_environment_for_body<'db>(&'db self, def: DefWithBodyId)
+    -> Arc<TraitEnvironment<'db>>;
 
     #[salsa::invoke(crate::lower::trait_environment_query)]
-    fn trait_environment(&self, def: GenericDefId) -> Arc<TraitEnvironment>;
+    fn trait_environment<'db>(&'db self, def: GenericDefId) -> Arc<TraitEnvironment<'db>>;
 
     #[salsa::invoke(crate::lower::generic_defaults_with_diagnostics_query)]
     #[salsa::cycle(cycle_result = crate::lower::generic_defaults_with_diagnostics_cycle_result)]
@@ -258,7 +259,7 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
     fn normalize_projection(
         &self,
         projection: crate::ProjectionTy,
-        env: Arc<TraitEnvironment>,
+        env: Arc<TraitEnvironment<'_>>,
     ) -> Ty;
 
     #[salsa::invoke(crate::traits::trait_solve_query)]
@@ -272,7 +273,7 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
 
     #[salsa::invoke(crate::drop::has_drop_glue)]
     #[salsa::cycle(cycle_result = crate::drop::has_drop_glue_cycle_result)]
-    fn has_drop_glue(&self, ty: Ty, env: Arc<TraitEnvironment>) -> DropGlue;
+    fn has_drop_glue(&self, ty: Ty, env: Arc<TraitEnvironment<'_>>) -> DropGlue;
 
     // next trait solver
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/expr.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/expr.rs
index 403ea05a4f53c..d05814e0e7e40 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/expr.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/expr.rs
@@ -81,17 +81,17 @@ impl BodyValidationDiagnostic {
     }
 }
 
-struct ExprValidator {
+struct ExprValidator<'db> {
     owner: DefWithBodyId,
     body: Arc<Body>,
     infer: Arc<InferenceResult>,
-    env: Arc<TraitEnvironment>,
+    env: Arc<TraitEnvironment<'db>>,
     diagnostics: Vec<BodyValidationDiagnostic>,
     validate_lints: bool,
 }
 
-impl ExprValidator {
-    fn validate_body(&mut self, db: &dyn HirDatabase) {
+impl<'db> ExprValidator<'db> {
+    fn validate_body(&mut self, db: &'db dyn HirDatabase) {
         let mut filter_map_next_checker = None;
         // we'll pass &mut self while iterating over body.exprs, so they need to be disjoint
         let body = Arc::clone(&self.body);
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs
index 56fd12e1f2b47..eb20d3c51ff41 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs
@@ -70,7 +70,7 @@ pub(crate) struct MatchCheckCtx<'db> {
     body: DefWithBodyId,
     pub(crate) db: &'db dyn HirDatabase,
     exhaustive_patterns: bool,
-    env: Arc<TraitEnvironment>,
+    env: Arc<TraitEnvironment<'db>>,
 }
 
 impl<'db> MatchCheckCtx<'db> {
@@ -78,7 +78,7 @@ impl<'db> MatchCheckCtx<'db> {
         module: ModuleId,
         body: DefWithBodyId,
         db: &'db dyn HirDatabase,
-        env: Arc<TraitEnvironment>,
+        env: Arc<TraitEnvironment<'db>>,
     ) -> Self {
         let def_map = module.crate_def_map(db);
         let exhaustive_patterns = def_map.is_unstable_feature_enabled(&sym::exhaustive_patterns);
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 519e4b59237f4..02f3eb39a4e0f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
@@ -799,12 +799,12 @@ fn render_const_scalar_ns(
     render_const_scalar_inner(f, b, memory_map, ty, trait_env)
 }
 
-fn render_const_scalar_inner(
+fn render_const_scalar_inner<'db>(
     f: &mut HirFormatter<'_>,
     b: &[u8],
     memory_map: &MemoryMap<'_>,
-    ty: crate::next_solver::Ty<'_>,
-    trait_env: Arc<TraitEnvironment>,
+    ty: crate::next_solver::Ty<'db>,
+    trait_env: Arc<TraitEnvironment<'db>>,
 ) -> Result<(), HirDisplayError> {
     use rustc_type_ir::TyKind;
     match ty.kind() {
@@ -1068,11 +1068,11 @@ fn render_const_scalar_inner(
     }
 }
 
-fn render_variant_after_name(
+fn render_variant_after_name<'db>(
     data: &VariantFields,
     f: &mut HirFormatter<'_>,
     field_types: &ArenaMap<LocalFieldId, Binders<Ty>>,
-    trait_env: Arc<TraitEnvironment>,
+    trait_env: Arc<TraitEnvironment<'db>>,
     layout: &Layout,
     args: GenericArgs<'_>,
     b: &[u8],
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/drop.rs b/src/tools/rust-analyzer/crates/hir-ty/src/drop.rs
index f5c2f41069ea0..88a7d15d8ea7d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/drop.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/drop.rs
@@ -43,7 +43,11 @@ pub enum DropGlue {
     HasDropGlue,
 }
 
-pub(crate) fn has_drop_glue(db: &dyn HirDatabase, ty: Ty, env: Arc<TraitEnvironment>) -> DropGlue {
+pub(crate) fn has_drop_glue(
+    db: &dyn HirDatabase,
+    ty: Ty,
+    env: Arc<TraitEnvironment<'_>>,
+) -> DropGlue {
     match ty.kind(Interner) {
         TyKind::Adt(adt, subst) => {
             if has_destructor(db, adt.0) {
@@ -165,7 +169,7 @@ pub(crate) fn has_drop_glue(db: &dyn HirDatabase, ty: Ty, env: Arc<TraitEnvironm
 
 fn projection_has_drop_glue(
     db: &dyn HirDatabase,
-    env: Arc<TraitEnvironment>,
+    env: Arc<TraitEnvironment<'_>>,
     projection: ProjectionTy,
     ty: Ty,
 ) -> DropGlue {
@@ -178,7 +182,7 @@ fn projection_has_drop_glue(
     }
 }
 
-fn is_copy(db: &dyn HirDatabase, ty: Ty, env: Arc<TraitEnvironment>) -> bool {
+fn is_copy(db: &dyn HirDatabase, ty: Ty, env: Arc<TraitEnvironment<'_>>) -> bool {
     let Some(copy_trait) = LangItem::Copy.resolve_trait(db, env.krate) else {
         return false;
     };
@@ -193,7 +197,7 @@ fn is_copy(db: &dyn HirDatabase, ty: Ty, env: Arc<TraitEnvironment>) -> bool {
 pub(crate) fn has_drop_glue_cycle_result(
     _db: &dyn HirDatabase,
     _ty: Ty,
-    _env: Arc<TraitEnvironment>,
+    _env: Arc<TraitEnvironment<'_>>,
 ) -> DropGlue {
     DropGlue::None
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
index 017119781a709..3ece62ec35b63 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
@@ -152,7 +152,7 @@ pub(crate) fn infer_cycle_result(_: &dyn HirDatabase, _: DefWithBodyId) -> Arc<I
 /// This is appropriate to use only after type-check: it assumes
 /// that normalization will succeed, for example.
 #[tracing::instrument(level = "debug", skip(db))]
-pub(crate) fn normalize(db: &dyn HirDatabase, trait_env: Arc<TraitEnvironment>, ty: Ty) -> Ty {
+pub(crate) fn normalize(db: &dyn HirDatabase, trait_env: Arc<TraitEnvironment<'_>>, ty: Ty) -> Ty {
     // FIXME: TypeFlags::HAS_CT_PROJECTION is not implemented in chalk, so TypeFlags::HAS_PROJECTION only
     // works for the type case, so we check array unconditionally. Remove the array part
     // when the bug in chalk becomes fixed.
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
index 7930d8b0ed68f..42948ccb93063 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
@@ -1564,9 +1564,9 @@ impl<'db, 'exprs> CoerceMany<'db, 'exprs> {
     }
 }
 
-pub fn could_coerce(
-    db: &dyn HirDatabase,
-    env: Arc<TraitEnvironment>,
+pub fn could_coerce<'db>(
+    db: &'db dyn HirDatabase,
+    env: Arc<TraitEnvironment<'db>>,
     tys: &crate::Canonical<(crate::Ty, crate::Ty)>,
 ) -> bool {
     coerce(db, env, tys).is_ok()
@@ -1574,7 +1574,7 @@ pub fn could_coerce(
 
 fn coerce<'db>(
     db: &'db dyn HirDatabase,
-    env: Arc<TraitEnvironment>,
+    env: Arc<TraitEnvironment<'db>>,
     tys: &crate::Canonical<(crate::Ty, crate::Ty)>,
 ) -> Result<(Vec<Adjustment>, crate::Ty), TypeError<DbInterner<'db>>> {
     let mut table = InferenceTable::new(db, env);
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
index cee95d3880df9..1204fb06d2fe2 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
@@ -121,7 +121,7 @@ impl<'a, 'db> ProofTreeVisitor<'db> for NestedObligationsForSelfTy<'a, 'db> {
 /// unresolved goal `T = U`.
 pub fn could_unify(
     db: &dyn HirDatabase,
-    env: Arc<TraitEnvironment>,
+    env: Arc<TraitEnvironment<'_>>,
     tys: &Canonical<(Ty, Ty)>,
 ) -> bool {
     unify(db, env, tys).is_some()
@@ -133,7 +133,7 @@ pub fn could_unify(
 /// them. For example `Option<T>` and `Option<U>` do not unify as we cannot show that `T = U`
 pub fn could_unify_deeply(
     db: &dyn HirDatabase,
-    env: Arc<TraitEnvironment>,
+    env: Arc<TraitEnvironment<'_>>,
     tys: &Canonical<(Ty, Ty)>,
 ) -> bool {
     let mut table = InferenceTable::new(db, env);
@@ -151,7 +151,7 @@ pub fn could_unify_deeply(
 
 pub(crate) fn unify(
     db: &dyn HirDatabase,
-    env: Arc<TraitEnvironment>,
+    env: Arc<TraitEnvironment<'_>>,
     tys: &Canonical<(Ty, Ty)>,
 ) -> Option<Substitution> {
     let mut table = InferenceTable::new(db, env);
@@ -212,7 +212,7 @@ bitflags::bitflags! {
 pub(crate) struct InferenceTable<'db> {
     pub(crate) db: &'db dyn HirDatabase,
     pub(crate) interner: DbInterner<'db>,
-    pub(crate) trait_env: Arc<TraitEnvironment>,
+    pub(crate) trait_env: Arc<TraitEnvironment<'db>>,
     pub(crate) param_env: ParamEnv<'db>,
     pub(crate) tait_coercion_table: Option<FxHashMap<OpaqueTyId, Ty>>,
     pub(crate) infer_ctxt: InferCtxt<'db>,
@@ -227,7 +227,7 @@ pub(crate) struct InferenceTableSnapshot<'db> {
 }
 
 impl<'db> InferenceTable<'db> {
-    pub(crate) fn new(db: &'db dyn HirDatabase, trait_env: Arc<TraitEnvironment>) -> Self {
+    pub(crate) fn new(db: &'db dyn HirDatabase, trait_env: Arc<TraitEnvironment<'db>>) -> Self {
         let interner = DbInterner::new_with(db, Some(trait_env.krate), trait_env.block);
         let infer_ctxt = interner.infer_ctxt().build(rustc_type_ir::TypingMode::Analysis {
             defining_opaque_types_and_generators: SolverDefIds::new_from_iter(interner, []),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/inhabitedness.rs b/src/tools/rust-analyzer/crates/hir-ty/src/inhabitedness.rs
index b16b6a1178460..bdebe41b29989 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/inhabitedness.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/inhabitedness.rs
@@ -20,7 +20,7 @@ pub(crate) fn is_ty_uninhabited_from(
     db: &dyn HirDatabase,
     ty: &Ty,
     target_mod: ModuleId,
-    env: Arc<TraitEnvironment>,
+    env: Arc<TraitEnvironment<'_>>,
 ) -> bool {
     let _p = tracing::info_span!("is_ty_uninhabited_from", ?ty).entered();
     let mut uninhabited_from =
@@ -36,7 +36,7 @@ pub(crate) fn is_enum_variant_uninhabited_from(
     variant: EnumVariantId,
     subst: &Substitution,
     target_mod: ModuleId,
-    env: Arc<TraitEnvironment>,
+    env: Arc<TraitEnvironment<'_>>,
 ) -> bool {
     let _p = tracing::info_span!("is_enum_variant_uninhabited_from").entered();
 
@@ -52,7 +52,7 @@ struct UninhabitedFrom<'a> {
     // guard for preventing stack overflow in non trivial non terminating types
     max_depth: usize,
     db: &'a dyn HirDatabase,
-    env: Arc<TraitEnvironment>,
+    env: Arc<TraitEnvironment<'a>>,
 }
 
 const CONTINUE_OPAQUELY_INHABITED: ControlFlow<VisiblyUninhabited> = Continue(());
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
index f21673c732e40..4071b9a1d5e9d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
@@ -132,7 +132,7 @@ fn layout_of_simd_ty<'db>(
     id: StructId,
     repr_packed: bool,
     args: &GenericArgs<'db>,
-    env: Arc<TraitEnvironment>,
+    env: Arc<TraitEnvironment<'db>>,
     dl: &TargetDataLayout,
 ) -> Result<Arc<Layout>, LayoutError> {
     // Supported SIMD vectors are homogeneous ADTs with exactly one array field:
@@ -160,7 +160,7 @@ fn layout_of_simd_ty<'db>(
 pub fn layout_of_ty_query<'db>(
     db: &'db dyn HirDatabase,
     ty: Ty<'db>,
-    trait_env: Arc<TraitEnvironment>,
+    trait_env: Arc<TraitEnvironment<'db>>,
 ) -> Result<Arc<Layout>, LayoutError> {
     let krate = trait_env.krate;
     let interner = DbInterner::new_with(db, Some(krate), trait_env.block);
@@ -371,7 +371,7 @@ pub fn layout_of_ty_query<'db>(
 pub(crate) fn layout_of_ty_cycle_result<'db>(
     _: &dyn HirDatabase,
     _: Ty<'db>,
-    _: Arc<TraitEnvironment>,
+    _: Arc<TraitEnvironment<'db>>,
 ) -> Result<Arc<Layout>, LayoutError> {
     Err(LayoutError::RecursiveTypeWithoutIndirection)
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs
index 9a746ca888589..a8f04bf8c132e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout/adt.rs
@@ -23,7 +23,7 @@ pub fn layout_of_adt_query<'db>(
     db: &'db dyn HirDatabase,
     def: AdtId,
     args: GenericArgs<'db>,
-    trait_env: Arc<TraitEnvironment>,
+    trait_env: Arc<TraitEnvironment<'db>>,
 ) -> Result<Arc<Layout>, LayoutError> {
     let krate = trait_env.krate;
     let Ok(target) = db.target_data_layout(krate) else {
@@ -99,7 +99,7 @@ pub(crate) fn layout_of_adt_cycle_result<'db>(
     _: &'db dyn HirDatabase,
     _def: AdtId,
     _args: GenericArgs<'db>,
-    _trait_env: Arc<TraitEnvironment>,
+    _trait_env: Arc<TraitEnvironment<'db>>,
 ) -> Result<Arc<Layout>, LayoutError> {
     Err(LayoutError::RecursiveTypeWithoutIndirection)
 }
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 2accf48843442..05c5a7a28b9a9 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
@@ -940,10 +940,10 @@ where
     Canonical { value, binders: chalk_ir::CanonicalVarKinds::from_iter(Interner, kinds) }
 }
 
-pub fn callable_sig_from_fn_trait(
+pub fn callable_sig_from_fn_trait<'db>(
     self_ty: &Ty,
-    trait_env: Arc<TraitEnvironment>,
-    db: &dyn HirDatabase,
+    trait_env: Arc<TraitEnvironment<'db>>,
+    db: &'db dyn HirDatabase,
 ) -> Option<(FnTrait, CallableSig)> {
     let krate = trait_env.krate;
     let fn_once_trait = FnTrait::FnOnce.get_id(db, krate)?;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
index 4d5172fd4f24f..eeec9d0454d3e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
@@ -1089,7 +1089,7 @@ pub(crate) fn generic_predicates_for_param_cycle_result(
 pub(crate) fn trait_environment_for_body_query(
     db: &dyn HirDatabase,
     def: DefWithBodyId,
-) -> Arc<TraitEnvironment> {
+) -> Arc<TraitEnvironment<'_>> {
     let Some(def) = def.as_generic_def_id(db) else {
         let krate = def.module(db).krate();
         return TraitEnvironment::empty(krate);
@@ -1097,10 +1097,10 @@ pub(crate) fn trait_environment_for_body_query(
     db.trait_environment(def)
 }
 
-pub(crate) fn trait_environment_query(
-    db: &dyn HirDatabase,
+pub(crate) fn trait_environment_query<'db>(
+    db: &'db dyn HirDatabase,
     def: GenericDefId,
-) -> Arc<TraitEnvironment> {
+) -> Arc<TraitEnvironment<'db>> {
     let generics = generics(db, def);
     if generics.has_no_predicates() && generics.is_empty() {
         return TraitEnvironment::empty(def.krate(db));
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
index 5cd4879a54046..db74ca258732c 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
@@ -545,7 +545,7 @@ pub fn def_crates(db: &dyn HirDatabase, ty: &Ty, cur_crate: Crate) -> Option<Sma
 pub(crate) fn lookup_method<'db>(
     db: &'db dyn HirDatabase,
     ty: &next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
-    env: Arc<TraitEnvironment>,
+    env: Arc<TraitEnvironment<'db>>,
     traits_in_scope: &FxHashSet<TraitId>,
     visible_from_module: VisibleFromModule,
     name: &Name,
@@ -714,7 +714,7 @@ impl ReceiverAdjustments {
 pub(crate) fn iterate_method_candidates<'db, T>(
     ty: &next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
     db: &'db dyn HirDatabase,
-    env: Arc<TraitEnvironment>,
+    env: Arc<TraitEnvironment<'db>>,
     traits_in_scope: &FxHashSet<TraitId>,
     visible_from_module: VisibleFromModule,
     name: Option<&Name>,
@@ -742,9 +742,9 @@ pub(crate) fn iterate_method_candidates<'db, T>(
     slot
 }
 
-pub fn lookup_impl_const(
-    db: &dyn HirDatabase,
-    env: Arc<TraitEnvironment>,
+pub fn lookup_impl_const<'db>(
+    db: &'db dyn HirDatabase,
+    env: Arc<TraitEnvironment<'db>>,
     const_id: ConstId,
     subs: Substitution,
 ) -> (ConstId, Substitution) {
@@ -770,9 +770,9 @@ pub fn lookup_impl_const(
 
 /// Checks if the self parameter of `Trait` method is the `dyn Trait` and we should
 /// call the method using the vtable.
-pub fn is_dyn_method(
-    db: &dyn HirDatabase,
-    _env: Arc<TraitEnvironment>,
+pub fn is_dyn_method<'db>(
+    db: &'db dyn HirDatabase,
+    _env: Arc<TraitEnvironment<'db>>,
     func: FunctionId,
     fn_subst: Substitution,
 ) -> Option<usize> {
@@ -812,9 +812,9 @@ pub fn is_dyn_method(
 /// Looks up the impl method that actually runs for the trait method `func`.
 ///
 /// Returns `func` if it's not a method defined in a trait or the lookup failed.
-pub(crate) fn lookup_impl_method_query(
-    db: &dyn HirDatabase,
-    env: Arc<TraitEnvironment>,
+pub(crate) fn lookup_impl_method_query<'db>(
+    db: &'db dyn HirDatabase,
+    env: Arc<TraitEnvironment<'db>>,
     func: FunctionId,
     fn_subst: Substitution,
 ) -> (FunctionId, Substitution) {
@@ -845,10 +845,10 @@ pub(crate) fn lookup_impl_method_query(
     )
 }
 
-fn lookup_impl_assoc_item_for_trait_ref(
+fn lookup_impl_assoc_item_for_trait_ref<'db>(
     trait_ref: TraitRef,
-    db: &dyn HirDatabase,
-    env: Arc<TraitEnvironment>,
+    db: &'db dyn HirDatabase,
+    env: Arc<TraitEnvironment<'db>>,
     name: &Name,
 ) -> Option<(AssocItemId, Substitution)> {
     let hir_trait_id = trait_ref.hir_trait_id();
@@ -1067,7 +1067,7 @@ pub fn check_orphan_rules(db: &dyn HirDatabase, impl_: ImplId) -> bool {
 pub fn iterate_path_candidates<'db>(
     ty: &next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
     db: &'db dyn HirDatabase,
-    env: Arc<TraitEnvironment>,
+    env: Arc<TraitEnvironment<'db>>,
     traits_in_scope: &FxHashSet<TraitId>,
     visible_from_module: VisibleFromModule,
     name: Option<&Name>,
@@ -1089,7 +1089,7 @@ pub fn iterate_path_candidates<'db>(
 pub fn iterate_method_candidates_dyn<'db>(
     ty: &next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
     db: &'db dyn HirDatabase,
-    env: Arc<TraitEnvironment>,
+    env: Arc<TraitEnvironment<'db>>,
     traits_in_scope: &FxHashSet<TraitId>,
     visible_from_module: VisibleFromModule,
     name: Option<&Name>,
@@ -1351,7 +1351,7 @@ fn iterate_method_candidates_by_receiver<'db>(
 fn iterate_method_candidates_for_self_ty<'db>(
     self_ty: &next_solver::Canonical<'db, crate::next_solver::Ty<'db>>,
     db: &'db dyn HirDatabase,
-    env: Arc<TraitEnvironment>,
+    env: Arc<TraitEnvironment<'db>>,
     traits_in_scope: &FxHashSet<TraitId>,
     visible_from_module: VisibleFromModule,
     name: Option<&Name>,
@@ -1856,10 +1856,10 @@ fn is_valid_impl_fn_candidate(
     })
 }
 
-pub fn implements_trait_unique(
+pub fn implements_trait_unique<'db>(
     ty: &Canonical<Ty>,
-    db: &dyn HirDatabase,
-    env: &TraitEnvironment,
+    db: &'db dyn HirDatabase,
+    env: &TraitEnvironment<'db>,
     trait_: TraitId,
 ) -> bool {
     let goal = generic_implements_goal(db, env, trait_, ty);
@@ -1869,9 +1869,9 @@ pub fn implements_trait_unique(
 /// This creates Substs for a trait with the given Self type and type variables
 /// for all other parameters, to query next solver with it.
 #[tracing::instrument(skip_all)]
-fn generic_implements_goal(
-    db: &dyn HirDatabase,
-    env: &TraitEnvironment,
+fn generic_implements_goal<'db>(
+    db: &'db dyn HirDatabase,
+    env: &TraitEnvironment<'db>,
     trait_: TraitId,
     self_ty: &Canonical<Ty>,
 ) -> Canonical<InEnvironment<super::DomainGoal>> {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
index 3e658cb93ed8a..3d7ad8d3b0693 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
@@ -165,7 +165,7 @@ enum MirOrDynIndex {
 
 pub struct Evaluator<'a> {
     db: &'a dyn HirDatabase,
-    trait_env: Arc<TraitEnvironment>,
+    trait_env: Arc<TraitEnvironment<'a>>,
     target_data_layout: Arc<TargetDataLayout>,
     stack: Vec<u8>,
     heap: Vec<u8>,
@@ -582,8 +582,8 @@ impl MirOutput {
     }
 }
 
-pub fn interpret_mir(
-    db: &dyn HirDatabase,
+pub fn interpret_mir<'db>(
+    db: &'db dyn HirDatabase,
     body: Arc<MirBody>,
     // FIXME: This is workaround. Ideally, const generics should have a separate body (issue #7434), but now
     // they share their body with their parent, so in MIR lowering we have locals of the parent body, which
@@ -591,7 +591,7 @@ pub fn interpret_mir(
     // a zero size, hoping that they are all outside of our current body. Even without a fix for #7434, we can
     // (and probably should) do better here, for example by excluding bindings outside of the target expression.
     assert_placeholder_ty_is_unused: bool,
-    trait_env: Option<Arc<TraitEnvironment>>,
+    trait_env: Option<Arc<TraitEnvironment<'db>>>,
 ) -> Result<(Result<Const>, MirOutput)> {
     let ty = body.locals[return_slot()].ty.clone();
     let mut evaluator = Evaluator::new(db, body.owner, assert_placeholder_ty_is_unused, trait_env)?;
@@ -632,11 +632,11 @@ const EXECUTION_LIMIT: usize = 10_000_000;
 
 impl<'db> Evaluator<'db> {
     pub fn new(
-        db: &dyn HirDatabase,
+        db: &'db dyn HirDatabase,
         owner: DefWithBodyId,
         assert_placeholder_ty_is_unused: bool,
-        trait_env: Option<Arc<TraitEnvironment>>,
-    ) -> Result<Evaluator<'_>> {
+        trait_env: Option<Arc<TraitEnvironment<'db>>>,
+    ) -> Result<Evaluator<'db>> {
         let crate_id = owner.module(db).krate();
         let target_data_layout = match db.target_data_layout(crate_id) {
             Ok(target_data_layout) => target_data_layout,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
index 50e416a66a64b..0416f4315d4dd 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
@@ -82,7 +82,7 @@ struct MirLowerCtx<'db> {
     infer: &'db InferenceResult,
     resolver: Resolver<'db>,
     drop_scopes: Vec<DropScope>,
-    env: Arc<TraitEnvironment>,
+    env: Arc<TraitEnvironment<'db>>,
 }
 
 // FIXME: Make this smaller, its stored in database queries
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/monomorphization.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/monomorphization.rs
index 555b87850924c..f293f38c76980 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/monomorphization.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/monomorphization.rs
@@ -35,7 +35,7 @@ macro_rules! not_supported {
 
 struct Filler<'a> {
     db: &'a dyn HirDatabase,
-    trait_env: Arc<TraitEnvironment>,
+    trait_env: Arc<TraitEnvironment<'a>>,
     subst: &'a Substitution,
     generics: Option<Generics>,
 }
@@ -301,11 +301,11 @@ impl Filler<'_> {
     }
 }
 
-pub fn monomorphized_mir_body_query(
-    db: &dyn HirDatabase,
+pub fn monomorphized_mir_body_query<'db>(
+    db: &'db dyn HirDatabase,
     owner: DefWithBodyId,
     subst: Substitution,
-    trait_env: Arc<crate::TraitEnvironment>,
+    trait_env: Arc<crate::TraitEnvironment<'db>>,
 ) -> Result<Arc<MirBody>, MirLowerError> {
     let generics = owner.as_generic_def_id(db).map(|g_def| generics(db, g_def));
     let filler = &mut Filler { db, subst: &subst, trait_env, generics };
@@ -315,20 +315,20 @@ pub fn monomorphized_mir_body_query(
     Ok(Arc::new(body))
 }
 
-pub(crate) fn monomorphized_mir_body_cycle_result(
-    _db: &dyn HirDatabase,
+pub(crate) fn monomorphized_mir_body_cycle_result<'db>(
+    _db: &'db dyn HirDatabase,
     _: DefWithBodyId,
     _: Substitution,
-    _: Arc<crate::TraitEnvironment>,
+    _: Arc<crate::TraitEnvironment<'db>>,
 ) -> Result<Arc<MirBody>, MirLowerError> {
     Err(MirLowerError::Loop)
 }
 
-pub fn monomorphized_mir_body_for_closure_query(
-    db: &dyn HirDatabase,
+pub fn monomorphized_mir_body_for_closure_query<'db>(
+    db: &'db dyn HirDatabase,
     closure: InternedClosureId,
     subst: Substitution,
-    trait_env: Arc<crate::TraitEnvironment>,
+    trait_env: Arc<crate::TraitEnvironment<'db>>,
 ) -> Result<Arc<MirBody>, MirLowerError> {
     let InternedClosure(owner, _) = db.lookup_intern_closure(closure);
     let generics = owner.as_generic_def_id(db).map(|g_def| generics(db, g_def));
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs b/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
index 3ce78e83c1294..d6a86c13978b3 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
@@ -39,21 +39,23 @@ use crate::{
 /// ```
 /// we assume that `T: Default`.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TraitEnvironment {
+pub struct TraitEnvironment<'db> {
     pub krate: Crate,
     pub block: Option<BlockId>,
     // FIXME make this a BTreeMap
     traits_from_clauses: Box<[(Ty, TraitId)]>,
     pub env: chalk_ir::Environment<Interner>,
+    _db: std::marker::PhantomData<&'db ()>,
 }
 
-impl TraitEnvironment {
+impl<'db> TraitEnvironment<'db> {
     pub fn empty(krate: Crate) -> Arc<Self> {
         Arc::new(TraitEnvironment {
             krate,
             block: None,
             traits_from_clauses: Box::default(),
             env: chalk_ir::Environment::new(Interner),
+            _db: std::marker::PhantomData,
         })
     }
 
@@ -63,7 +65,13 @@ impl TraitEnvironment {
         traits_from_clauses: Box<[(Ty, TraitId)]>,
         env: chalk_ir::Environment<Interner>,
     ) -> Arc<Self> {
-        Arc::new(TraitEnvironment { krate, block, traits_from_clauses, env })
+        Arc::new(TraitEnvironment {
+            krate,
+            block,
+            traits_from_clauses,
+            env,
+            _db: std::marker::PhantomData,
+        })
     }
 
     // pub fn with_block(self: &mut Arc<Self>, block: BlockId) {
@@ -78,10 +86,10 @@ impl TraitEnvironment {
     }
 }
 
-pub(crate) fn normalize_projection_query(
-    db: &dyn HirDatabase,
+pub(crate) fn normalize_projection_query<'db>(
+    db: &'db dyn HirDatabase,
     projection: ProjectionTy,
-    env: Arc<TraitEnvironment>,
+    env: Arc<TraitEnvironment<'db>>,
 ) -> Ty {
     if projection.substitution.iter(Interner).any(|arg| {
         arg.ty(Interner)
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index 1cec01da6008e..eaae15835d0b5 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -3808,12 +3808,12 @@ impl GenericDef {
 pub struct GenericSubstitution<'db> {
     def: GenericDefId,
     subst: Substitution,
-    env: Arc<TraitEnvironment>,
+    env: Arc<TraitEnvironment<'db>>,
     _pd: PhantomCovariantLifetime<'db>,
 }
 
 impl<'db> GenericSubstitution<'db> {
-    fn new(def: GenericDefId, subst: Substitution, env: Arc<TraitEnvironment>) -> Self {
+    fn new(def: GenericDefId, subst: Substitution, env: Arc<TraitEnvironment<'db>>) -> Self {
         Self { def, subst, env, _pd: PhantomCovariantLifetime::new() }
     }
 
@@ -4567,7 +4567,7 @@ impl Impl {
 
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub struct TraitRef<'db> {
-    env: Arc<TraitEnvironment>,
+    env: Arc<TraitEnvironment<'db>>,
     trait_ref: hir_ty::next_solver::TraitRef<'db>,
     _pd: PhantomCovariantLifetime<'db>,
 }
@@ -4790,7 +4790,7 @@ impl CaptureUsageSource {
 
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub struct Type<'db> {
-    env: Arc<TraitEnvironment>,
+    env: Arc<TraitEnvironment<'db>>,
     ty: Ty,
     _pd: PhantomCovariantLifetime<'db>,
 }
@@ -5945,7 +5945,7 @@ impl<'db> Type<'db> {
 
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub struct TypeNs<'db> {
-    env: Arc<TraitEnvironment>,
+    env: Arc<TraitEnvironment<'db>>,
     ty: hir_ty::next_solver::Ty<'db>,
     _pd: PhantomCovariantLifetime<'db>,
 }
diff --git a/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs b/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
index 539b25387aef0..a19183fa1302a 100644
--- a/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
@@ -219,7 +219,7 @@ impl<'db> SourceAnalyzer<'db> {
         })
     }
 
-    fn trait_environment(&self, db: &'db dyn HirDatabase) -> Arc<TraitEnvironment> {
+    fn trait_environment(&self, db: &'db dyn HirDatabase) -> Arc<TraitEnvironment<'db>> {
         self.body_().map(|(def, ..)| def).map_or_else(
             || TraitEnvironment::empty(self.resolver.krate()),
             |def| db.trait_environment_for_body(def),

From 06078dfa9782115e83fb2a02bec9253e927aeee3 Mon Sep 17 00:00:00 2001
From: Jack Huey <31162821+jackh726@users.noreply.github.com>
Date: Mon, 22 Sep 2025 17:38:31 -0400
Subject: [PATCH 1288/1889] Use ParamEnv in TraitEnvironment

---
 .../crates/hir-ty/src/autoderef.rs            |   2 +-
 .../crates/hir-ty/src/chalk_ext.rs            |  14 +-
 .../rust-analyzer/crates/hir-ty/src/db.rs     |   4 +-
 .../crates/hir-ty/src/display.rs              |   5 +-
 .../rust-analyzer/crates/hir-ty/src/drop.rs   |   7 +-
 .../crates/hir-ty/src/infer/closure.rs        |   6 +-
 .../crates/hir-ty/src/infer/coerce.rs         |  20 +--
 .../crates/hir-ty/src/infer/expr.rs           |   5 +-
 .../crates/hir-ty/src/infer/unify.rs          |  18 ++-
 .../rust-analyzer/crates/hir-ty/src/lower.rs  | 111 +--------------
 .../crates/hir-ty/src/lower_nextsolver.rs     | 130 +++++++++++++++++-
 .../crates/hir-ty/src/method_resolution.rs    |  21 ++-
 .../crates/hir-ty/src/tests/regression.rs     |   2 +-
 .../rust-analyzer/crates/hir-ty/src/traits.rs |  18 +--
 src/tools/rust-analyzer/crates/hir/src/lib.rs |  11 +-
 .../crates/ide-completion/src/tests.rs        |   8 +-
 .../crates/ide/src/view_memory_layout.rs      |   4 +-
 17 files changed, 216 insertions(+), 170 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs b/src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs
index 4c79c800fcf3b..21a86d3e43727 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs
@@ -298,7 +298,7 @@ fn structurally_normalize_ty<'db>(
 ) -> Option<(Ty<'db>, PredicateObligations<'db>)> {
     let mut ocx = ObligationCtxt::new(&table.infer_ctxt);
     let Ok(normalized_ty) =
-        ocx.structurally_normalize_ty(&ObligationCause::misc(), table.param_env, ty)
+        ocx.structurally_normalize_ty(&ObligationCause::misc(), table.trait_env.env, ty)
     else {
         // We shouldn't have errors here in the old solver, except for
         // evaluate/fulfill mismatches, but that's not a reason for an ICE.
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/chalk_ext.rs b/src/tools/rust-analyzer/crates/hir-ty/src/chalk_ext.rs
index 1faf9f66dc547..6956a0a123283 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/chalk_ext.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/chalk_ext.rs
@@ -15,8 +15,13 @@ use crate::{
     AdtId, AliasEq, AliasTy, Binders, CallableDefId, CallableSig, Canonical, CanonicalVarKinds,
     ClosureId, DynTy, FnPointer, ImplTraitId, InEnvironment, Interner, Lifetime, ProjectionTy,
     QuantifiedWhereClause, Substitution, ToChalk, TraitRef, Ty, TyBuilder, TyKind, TypeFlags,
-    WhereClause, db::HirDatabase, from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id,
-    from_placeholder_idx, generics::generics, to_chalk_trait_id, utils::ClosureSubst,
+    WhereClause,
+    db::HirDatabase,
+    from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id, from_placeholder_idx,
+    generics::generics,
+    next_solver::{DbInterner, mapping::NextSolverToChalk},
+    to_chalk_trait_id,
+    utils::ClosureSubst,
 };
 
 pub trait TyExt {
@@ -372,7 +377,10 @@ impl TyExt for Ty {
         let trait_ref = TyBuilder::trait_ref(db, copy_trait).push(self).build();
         let env = db.trait_environment_for_body(owner);
         let goal = Canonical {
-            value: InEnvironment::new(&env.env, trait_ref.cast(Interner)),
+            value: InEnvironment::new(
+                &env.env.to_chalk(DbInterner::new_with(db, Some(env.krate), env.block)),
+                trait_ref.cast(Interner),
+            ),
             binders: CanonicalVarKinds::empty(Interner),
         };
         !db.trait_solve(crate_id, None, goal).no_solution()
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
index 24e617135160d..44f48069ab240 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
@@ -182,12 +182,12 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
     #[salsa::invoke(crate::lower::generic_predicates_query)]
     fn generic_predicates(&self, def: GenericDefId) -> GenericPredicates;
 
-    #[salsa::invoke(crate::lower::trait_environment_for_body_query)]
+    #[salsa::invoke(crate::lower_nextsolver::trait_environment_for_body_query)]
     #[salsa::transparent]
     fn trait_environment_for_body<'db>(&'db self, def: DefWithBodyId)
     -> Arc<TraitEnvironment<'db>>;
 
-    #[salsa::invoke(crate::lower::trait_environment_query)]
+    #[salsa::invoke(crate::lower_nextsolver::trait_environment_query)]
     fn trait_environment<'db>(&'db self, def: GenericDefId) -> Arc<TraitEnvironment<'db>>;
 
     #[salsa::invoke(crate::lower::generic_defaults_with_diagnostics_query)]
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 02f3eb39a4e0f..dc42304e1cab2 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
@@ -792,10 +792,7 @@ fn render_const_scalar_ns(
     let trait_env = TraitEnvironment::empty(f.krate());
     let interner = DbInterner::new_with(f.db, Some(trait_env.krate), trait_env.block);
     let infcx = interner.infer_ctxt().build(rustc_type_ir::TypingMode::PostAnalysis);
-    let ty = infcx
-        .at(&ObligationCause::new(), trait_env.env.to_nextsolver(interner))
-        .deeply_normalize(ty)
-        .unwrap_or(ty);
+    let ty = infcx.at(&ObligationCause::new(), trait_env.env).deeply_normalize(ty).unwrap_or(ty);
     render_const_scalar_inner(f, b, memory_map, ty, trait_env)
 }
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/drop.rs b/src/tools/rust-analyzer/crates/hir-ty/src/drop.rs
index 88a7d15d8ea7d..413f70532a548 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/drop.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/drop.rs
@@ -7,6 +7,8 @@ use hir_def::signatures::StructFlags;
 use stdx::never;
 use triomphe::Arc;
 
+use crate::next_solver::DbInterner;
+use crate::next_solver::mapping::NextSolverToChalk;
 use crate::{
     AliasTy, Canonical, CanonicalVarKinds, ConcreteConst, ConstScalar, ConstValue, InEnvironment,
     Interner, ProjectionTy, TraitEnvironment, Ty, TyBuilder, TyKind, db::HirDatabase,
@@ -188,7 +190,10 @@ fn is_copy(db: &dyn HirDatabase, ty: Ty, env: Arc<TraitEnvironment<'_>>) -> bool
     };
     let trait_ref = TyBuilder::trait_ref(db, copy_trait).push(ty).build();
     let goal = Canonical {
-        value: InEnvironment::new(&env.env, trait_ref.cast(Interner)),
+        value: InEnvironment::new(
+            &env.env.to_chalk(DbInterner::new_with(db, Some(env.krate), env.block)),
+            trait_ref.cast(Interner),
+        ),
         binders: CanonicalVarKinds::empty(Interner),
     };
     db.trait_solve(env.krate, env.block, goal).certain()
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
index 1d5d8dd13edd4..4a57b2f37510e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/closure.rs
@@ -318,7 +318,7 @@ impl<'db> InferenceContext<'db> {
                     _ = self
                         .table
                         .infer_ctxt
-                        .at(&ObligationCause::new(), self.table.param_env)
+                        .at(&ObligationCause::new(), self.table.trait_env.env)
                         .eq(DefineOpaqueTypes::Yes, inferred_fnptr_sig, generalized_fnptr_sig)
                         .map(|infer_ok| self.table.register_infer_ok(infer_ok));
 
@@ -703,7 +703,7 @@ impl<'db> InferenceContext<'db> {
                 let cause = ObligationCause::new();
                 let InferOk { value: (), obligations } = table
                     .infer_ctxt
-                    .at(&cause, table.param_env)
+                    .at(&cause, table.trait_env.env)
                     .eq(DefineOpaqueTypes::Yes, expected_ty, supplied_ty)?;
                 all_obligations.extend(obligations);
             }
@@ -711,7 +711,7 @@ impl<'db> InferenceContext<'db> {
             let supplied_output_ty = supplied_sig.output();
             let cause = ObligationCause::new();
             let InferOk { value: (), obligations } =
-                table.infer_ctxt.at(&cause, table.param_env).eq(
+                table.infer_ctxt.at(&cause, table.trait_env.env).eq(
                     DefineOpaqueTypes::Yes,
                     expected_sigs.liberated_sig.output(),
                     supplied_output_ty,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
index 42948ccb93063..219b519e46bb8 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
@@ -144,7 +144,7 @@ impl<'a, 'b, 'db> Coerce<'a, 'b, 'db> {
     fn unify_raw(&mut self, a: Ty<'db>, b: Ty<'db>) -> InferResult<'db, Ty<'db>> {
         debug!("unify(a: {:?}, b: {:?}, use_lub: {})", a, b, self.use_lub);
         self.commit_if_ok(|this| {
-            let at = this.infer_ctxt().at(&this.cause, this.table.param_env);
+            let at = this.infer_ctxt().at(&this.cause, this.table.trait_env.env);
 
             let res = if this.use_lub {
                 at.lub(b, a)
@@ -330,7 +330,7 @@ impl<'a, 'b, 'db> Coerce<'a, 'b, 'db> {
                     obligations.push(Obligation::new(
                         self.interner(),
                         self.cause.clone(),
-                        self.table.param_env,
+                        self.table.trait_env.env,
                         Binder::dummy(PredicateKind::Coerce(CoercePredicate {
                             a: source_ty,
                             b: target_ty,
@@ -718,7 +718,7 @@ impl<'a, 'b, 'db> Coerce<'a, 'b, 'db> {
         let mut queue: SmallVec<[PredicateObligation<'db>; 4]> = smallvec![Obligation::new(
             self.interner(),
             cause,
-            self.table.param_env,
+            self.table.trait_env.env,
             TraitRef::new(
                 self.interner(),
                 coerce_unsized_did.into(),
@@ -1114,8 +1114,12 @@ impl<'db> InferenceContext<'db> {
                         match self.table.commit_if_ok(|table| {
                             // We need to eagerly handle nested obligations due to lazy norm.
                             let mut ocx = ObligationCtxt::new(&table.infer_ctxt);
-                            let value =
-                                ocx.lub(&ObligationCause::new(), table.param_env, prev_ty, new_ty)?;
+                            let value = ocx.lub(
+                                &ObligationCause::new(),
+                                table.trait_env.env,
+                                prev_ty,
+                                new_ty,
+                            )?;
                             if ocx.select_where_possible().is_empty() {
                                 Ok(InferOk { value, obligations: ocx.into_pending_obligations() })
                             } else {
@@ -1158,7 +1162,7 @@ impl<'db> InferenceContext<'db> {
             let sig = self
                 .table
                 .infer_ctxt
-                .at(&ObligationCause::new(), self.table.param_env)
+                .at(&ObligationCause::new(), self.table.trait_env.env)
                 .lub(a_sig, b_sig)
                 .map(|ok| self.table.register_infer_ok(ok))?;
 
@@ -1248,7 +1252,7 @@ impl<'db> InferenceContext<'db> {
                         .commit_if_ok(|table| {
                             table
                                 .infer_ctxt
-                                .at(&ObligationCause::new(), table.param_env)
+                                .at(&ObligationCause::new(), table.trait_env.env)
                                 .lub(prev_ty, new_ty)
                         })
                         .unwrap_err())
@@ -1498,7 +1502,7 @@ impl<'db, 'exprs> CoerceMany<'db, 'exprs> {
             assert!(expression_ty.is_unit(), "if let hack without unit type");
             icx.table
                 .infer_ctxt
-                .at(cause, icx.table.param_env)
+                .at(cause, icx.table.trait_env.env)
                 .eq(
                     // needed for tests/ui/type-alias-impl-trait/issue-65679-inst-opaque-ty-from-val-twice.rs
                     DefineOpaqueTypes::Yes,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
index c5a51dfc4cf92..b4a332f1da849 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
@@ -1662,7 +1662,6 @@ impl<'db> InferenceContext<'db> {
             });
         self.resolver.reset_to_guard(g);
         if let Some(prev_env) = prev_env {
-            self.table.param_env = prev_env.env.to_nextsolver(self.table.interner);
             self.table.trait_env = prev_env;
         }
 
@@ -2132,7 +2131,7 @@ impl<'db> InferenceContext<'db> {
                         let origin = ObligationCause::new();
                         ocx.sup(
                             &origin,
-                            self.table.param_env,
+                            self.table.trait_env.env,
                             expected_output.to_nextsolver(interner),
                             formal_output,
                         )?;
@@ -2239,7 +2238,7 @@ impl<'db> InferenceContext<'db> {
             let formal_ty_error = this
                 .table
                 .infer_ctxt
-                .at(&ObligationCause::new(), this.table.param_env)
+                .at(&ObligationCause::new(), this.table.trait_env.env)
                 .eq(DefineOpaqueTypes::Yes, formal_input_ty, coerced_ty);
 
             // If neither check failed, the types are compatible
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
index 1204fb06d2fe2..6df9cbaa29394 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
@@ -29,8 +29,8 @@ use crate::{
     db::HirDatabase,
     fold_generic_args, fold_tys_and_consts,
     next_solver::{
-        self, ClauseKind, DbInterner, ErrorGuaranteed, ParamEnv, Predicate, PredicateKind,
-        SolverDefIds, Term, TraitRef,
+        self, ClauseKind, DbInterner, ErrorGuaranteed, Predicate, PredicateKind, SolverDefIds,
+        Term, TraitRef,
         fulfill::FulfillmentCtxt,
         infer::{
             DbInternerInferExt, InferCtxt, InferOk,
@@ -213,7 +213,6 @@ pub(crate) struct InferenceTable<'db> {
     pub(crate) db: &'db dyn HirDatabase,
     pub(crate) interner: DbInterner<'db>,
     pub(crate) trait_env: Arc<TraitEnvironment<'db>>,
-    pub(crate) param_env: ParamEnv<'db>,
     pub(crate) tait_coercion_table: Option<FxHashMap<OpaqueTyId, Ty>>,
     pub(crate) infer_ctxt: InferCtxt<'db>,
     diverging_tys: FxHashSet<Ty>,
@@ -235,7 +234,6 @@ impl<'db> InferenceTable<'db> {
         InferenceTable {
             db,
             interner,
-            param_env: trait_env.env.to_nextsolver(interner),
             trait_env,
             tait_coercion_table: None,
             fulfillment_cx: FulfillmentCtxt::new(&infer_ctxt),
@@ -426,7 +424,7 @@ impl<'db> InferenceTable<'db> {
     {
         let ty = self.resolve_vars_with_obligations(ty);
         self.infer_ctxt
-            .at(&ObligationCause::new(), self.param_env)
+            .at(&ObligationCause::new(), self.trait_env.env)
             .deeply_normalize(ty.clone())
             .unwrap_or(ty)
     }
@@ -741,7 +739,7 @@ impl<'db> InferenceTable<'db> {
     ) -> InferResult<'db, ()> {
         let variance = rustc_type_ir::Variance::Invariant;
         let span = crate::next_solver::Span::dummy();
-        match self.infer_ctxt.relate(self.param_env, lhs, variance, rhs, span) {
+        match self.infer_ctxt.relate(self.trait_env.env, lhs, variance, rhs, span) {
             Ok(goals) => Ok(crate::infer::InferOk { goals, value: () }),
             Err(_) => Err(TypeError),
         }
@@ -798,7 +796,7 @@ impl<'db> InferenceTable<'db> {
 
     fn structurally_normalize_term(&mut self, term: Term<'db>) -> Term<'db> {
         self.infer_ctxt
-            .at(&ObligationCause::new(), self.param_env)
+            .at(&ObligationCause::new(), self.trait_env.env)
             .structurally_normalize_term(term, &mut self.fulfillment_cx)
             .unwrap_or(term)
     }
@@ -818,7 +816,7 @@ impl<'db> InferenceTable<'db> {
             // in a reentrant borrow, causing an ICE.
             let result = self
                 .infer_ctxt
-                .at(&ObligationCause::misc(), self.param_env)
+                .at(&ObligationCause::misc(), self.trait_env.env)
                 .structurally_normalize_ty(ty, &mut self.fulfillment_cx);
             match result {
                 Ok(normalized_ty) => normalized_ty,
@@ -874,14 +872,14 @@ impl<'db> InferenceTable<'db> {
     /// choice (during e.g. method resolution or deref).
     #[tracing::instrument(level = "debug", skip(self))]
     pub(crate) fn try_obligation(&mut self, predicate: Predicate<'db>) -> NextTraitSolveResult {
-        let goal = next_solver::Goal { param_env: self.param_env, predicate };
+        let goal = next_solver::Goal { param_env: self.trait_env.env, predicate };
         let canonicalized = self.canonicalize(goal);
 
         next_trait_solve_canonical_in_ctxt(&self.infer_ctxt, canonicalized)
     }
 
     pub(crate) fn register_obligation(&mut self, predicate: Predicate<'db>) {
-        let goal = next_solver::Goal { param_env: self.param_env, predicate };
+        let goal = next_solver::Goal { param_env: self.trait_env.env, predicate };
         self.register_obligation_in_env(goal)
     }
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
index eeec9d0454d3e..20f421dbbcd90 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
@@ -24,9 +24,9 @@ use chalk_ir::{
 
 use either::Either;
 use hir_def::{
-    AdtId, AssocItemId, CallableDefId, ConstId, ConstParamId, DefWithBodyId, EnumId, EnumVariantId,
-    FunctionId, GenericDefId, GenericParamId, HasModule, ImplId, ItemContainerId, LocalFieldId,
-    Lookup, StaticId, StructId, TypeAliasId, TypeOrConstParamId, UnionId, VariantId,
+    AdtId, AssocItemId, CallableDefId, ConstId, ConstParamId, EnumId, EnumVariantId, FunctionId,
+    GenericDefId, GenericParamId, ImplId, ItemContainerId, LocalFieldId, Lookup, StaticId,
+    StructId, TypeAliasId, TypeOrConstParamId, UnionId, VariantId,
     builtin_type::BuiltinType,
     expr_store::{ExpressionStore, path::Path},
     hir::generics::{GenericParamDataRef, TypeOrConstParamData, WherePredicate},
@@ -46,11 +46,10 @@ use stdx::{impl_from, never};
 use triomphe::{Arc, ThinArc};
 
 use crate::{
-    AliasTy, Binders, BoundVar, CallableSig, Const, DebruijnIndex, DomainGoal, DynTy, FnAbi,
-    FnPointer, FnSig, FnSubst, ImplTrait, ImplTraitId, ImplTraits, Interner, Lifetime,
-    LifetimeData, LifetimeOutlives, PolyFnSig, QuantifiedWhereClause, QuantifiedWhereClauses,
-    Substitution, TraitEnvironment, TraitRef, TraitRefExt, Ty, TyBuilder, TyKind, WhereClause,
-    all_super_traits,
+    AliasTy, Binders, BoundVar, CallableSig, Const, DebruijnIndex, DynTy, FnAbi, FnPointer, FnSig,
+    FnSubst, ImplTrait, ImplTraitId, ImplTraits, Interner, Lifetime, LifetimeData,
+    LifetimeOutlives, PolyFnSig, QuantifiedWhereClause, QuantifiedWhereClauses, Substitution,
+    TraitRef, TraitRefExt, Ty, TyBuilder, TyKind, WhereClause, all_super_traits,
     consteval::{intern_const_ref, path_to_const, unknown_const, unknown_const_as_generic},
     db::HirDatabase,
     error_lifetime,
@@ -1086,102 +1085,6 @@ pub(crate) fn generic_predicates_for_param_cycle_result(
     GenericPredicates(None)
 }
 
-pub(crate) fn trait_environment_for_body_query(
-    db: &dyn HirDatabase,
-    def: DefWithBodyId,
-) -> Arc<TraitEnvironment<'_>> {
-    let Some(def) = def.as_generic_def_id(db) else {
-        let krate = def.module(db).krate();
-        return TraitEnvironment::empty(krate);
-    };
-    db.trait_environment(def)
-}
-
-pub(crate) fn trait_environment_query<'db>(
-    db: &'db dyn HirDatabase,
-    def: GenericDefId,
-) -> Arc<TraitEnvironment<'db>> {
-    let generics = generics(db, def);
-    if generics.has_no_predicates() && generics.is_empty() {
-        return TraitEnvironment::empty(def.krate(db));
-    }
-
-    let resolver = def.resolver(db);
-    let mut ctx = TyLoweringContext::new(
-        db,
-        &resolver,
-        generics.store(),
-        def,
-        LifetimeElisionKind::AnonymousReportError,
-    )
-    .with_type_param_mode(ParamLoweringMode::Placeholder);
-    let mut traits_in_scope = Vec::new();
-    let mut clauses = Vec::new();
-    for maybe_parent_generics in
-        std::iter::successors(Some(&generics), |generics| generics.parent_generics())
-    {
-        ctx.store = maybe_parent_generics.store();
-        for pred in maybe_parent_generics.where_predicates() {
-            for pred in ctx.lower_where_predicate(pred, false) {
-                if let WhereClause::Implemented(tr) = pred.skip_binders() {
-                    traits_in_scope
-                        .push((tr.self_type_parameter(Interner).clone(), tr.hir_trait_id()));
-                }
-                let program_clause: Binders<DomainGoal> =
-                    pred.map(|pred| pred.into_from_env_goal(Interner).cast(Interner));
-                clauses.push(program_clause);
-            }
-        }
-    }
-
-    if let Some(trait_id) = def.assoc_trait_container(db) {
-        // add `Self: Trait<T1, T2, ...>` to the environment in trait
-        // function default implementations (and speculative code
-        // inside consts or type aliases)
-        cov_mark::hit!(trait_self_implements_self);
-        let substs = TyBuilder::placeholder_subst(db, trait_id);
-        let trait_ref = TraitRef { trait_id: to_chalk_trait_id(trait_id), substitution: substs };
-        let pred = WhereClause::Implemented(trait_ref);
-        clauses.push(Binders::empty(
-            Interner,
-            pred.cast::<DomainGoal>(Interner).into_from_env_goal(Interner),
-        ));
-    }
-
-    let subst = generics.placeholder_subst(db);
-    if !subst.is_empty(Interner) {
-        let explicitly_unsized_tys = ctx.unsized_types;
-        if let Some(implicitly_sized_clauses) =
-            implicitly_sized_clauses(db, def, &explicitly_unsized_tys, &subst, &resolver)
-        {
-            clauses.extend(implicitly_sized_clauses.map(|pred| {
-                Binders::empty(
-                    Interner,
-                    pred.into_from_env_goal(Interner).cast::<DomainGoal>(Interner),
-                )
-            }));
-        };
-    }
-
-    let clauses = chalk_ir::ProgramClauses::from_iter(
-        Interner,
-        clauses.into_iter().map(|g| {
-            chalk_ir::ProgramClause::new(
-                Interner,
-                chalk_ir::ProgramClauseData(g.map(|g| chalk_ir::ProgramClauseImplication {
-                    consequence: g,
-                    conditions: chalk_ir::Goals::empty(Interner),
-                    constraints: chalk_ir::Constraints::empty(Interner),
-                    priority: chalk_ir::ClausePriority::High,
-                })),
-            )
-        }),
-    );
-    let env = chalk_ir::Environment { clauses };
-
-    TraitEnvironment::new(resolver.krate(), None, traits_in_scope.into_boxed_slice(), env)
-}
-
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct GenericPredicates(Option<Arc<[Binders<QuantifiedWhereClause>]>>);
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
index 6ecf8874c46d2..1ca56feb099a1 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
@@ -19,9 +19,9 @@ use base_db::Crate;
 use either::Either;
 use hir_def::item_tree::FieldsShape;
 use hir_def::{
-    AdtId, AssocItemId, CallableDefId, ConstParamId, EnumVariantId, FunctionId, GenericDefId,
-    GenericParamId, ImplId, ItemContainerId, LocalFieldId, Lookup, StructId, TraitId, TypeAliasId,
-    TypeOrConstParamId, VariantId,
+    AdtId, AssocItemId, CallableDefId, ConstParamId, DefWithBodyId, EnumVariantId, FunctionId,
+    GenericDefId, GenericParamId, HasModule, ImplId, ItemContainerId, LocalFieldId, Lookup,
+    StructId, TraitId, TypeAliasId, TypeOrConstParamId, VariantId,
     expr_store::{
         ExpressionStore,
         path::{GenericArg, Path},
@@ -57,7 +57,7 @@ use triomphe::Arc;
 
 use crate::ValueTyDefId;
 use crate::{
-    FnAbi, ImplTraitId, Interner, ParamKind, TyDefId, TyLoweringDiagnostic,
+    FnAbi, ImplTraitId, Interner, ParamKind, TraitEnvironment, TyDefId, TyLoweringDiagnostic,
     TyLoweringDiagnosticKind,
     consteval_nextsolver::{intern_const_ref, path_to_const, unknown_const_as_generic},
     db::HirDatabase,
@@ -66,8 +66,10 @@ use crate::{
     next_solver::{
         AdtDef, AliasTy, Binder, BoundExistentialPredicates, BoundRegionKind, BoundTyKind,
         BoundVarKind, BoundVarKinds, Clause, Clauses, Const, DbInterner, EarlyBinder,
-        EarlyParamRegion, ErrorGuaranteed, GenericArgs, PolyFnSig, Predicate, Region, SolverDefId,
-        TraitPredicate, TraitRef, Ty, Tys, abi::Safety, mapping::ChalkToNextSolver,
+        EarlyParamRegion, ErrorGuaranteed, GenericArgs, ParamEnv, PolyFnSig, Predicate, Region,
+        SolverDefId, TraitPredicate, TraitRef, Ty, Tys,
+        abi::Safety,
+        mapping::{ChalkToNextSolver, convert_ty_for_result},
     },
 };
 
@@ -1375,6 +1377,122 @@ impl<'db> ops::Deref for GenericPredicates<'db> {
     }
 }
 
+pub(crate) fn trait_environment_for_body_query(
+    db: &dyn HirDatabase,
+    def: DefWithBodyId,
+) -> Arc<TraitEnvironment<'_>> {
+    let Some(def) = def.as_generic_def_id(db) else {
+        let krate = def.module(db).krate();
+        return TraitEnvironment::empty(krate);
+    };
+    db.trait_environment(def)
+}
+
+pub(crate) fn trait_environment_query<'db>(
+    db: &'db dyn HirDatabase,
+    def: GenericDefId,
+) -> Arc<TraitEnvironment<'db>> {
+    let generics = generics(db, def);
+    if generics.has_no_predicates() && generics.is_empty() {
+        return TraitEnvironment::empty(def.krate(db));
+    }
+
+    let interner = DbInterner::new_with(db, Some(def.krate(db)), None);
+    let resolver = def.resolver(db);
+    let mut ctx = TyLoweringContext::new(
+        db,
+        &resolver,
+        generics.store(),
+        def,
+        LifetimeElisionKind::AnonymousReportError,
+    );
+    let mut traits_in_scope = Vec::new();
+    let mut clauses = Vec::new();
+    for maybe_parent_generics in
+        std::iter::successors(Some(&generics), |generics| generics.parent_generics())
+    {
+        ctx.store = maybe_parent_generics.store();
+        for pred in maybe_parent_generics.where_predicates() {
+            for pred in ctx.lower_where_predicate(pred, false, &generics, PredicateFilter::All) {
+                if let rustc_type_ir::ClauseKind::Trait(tr) = pred.kind().skip_binder() {
+                    traits_in_scope
+                        .push((convert_ty_for_result(interner, tr.self_ty()), tr.def_id().0));
+                }
+                clauses.push(pred);
+            }
+        }
+    }
+
+    if let Some(trait_id) = def.assoc_trait_container(db) {
+        // add `Self: Trait<T1, T2, ...>` to the environment in trait
+        // function default implementations (and speculative code
+        // inside consts or type aliases)
+        cov_mark::hit!(trait_self_implements_self);
+        let trait_ref = TraitRef::identity(ctx.interner, trait_id.into());
+        let clause = Clause(Predicate::new(
+            ctx.interner,
+            Binder::dummy(rustc_type_ir::PredicateKind::Clause(rustc_type_ir::ClauseKind::Trait(
+                TraitPredicate { trait_ref, polarity: rustc_type_ir::PredicatePolarity::Positive },
+            ))),
+        ));
+        clauses.push(clause);
+    }
+
+    let explicitly_unsized_tys = ctx.unsized_types;
+
+    let sized_trait = LangItem::Sized.resolve_trait(db, resolver.krate());
+    if let Some(sized_trait) = sized_trait {
+        let (mut generics, mut def_id) =
+            (crate::next_solver::generics::generics(db, def.into()), def);
+        loop {
+            let self_idx = trait_self_param_idx(db, def_id);
+            for (idx, p) in generics.own_params.iter().enumerate() {
+                if let Some(self_idx) = self_idx
+                    && p.index() as usize == self_idx
+                {
+                    continue;
+                }
+                let GenericParamId::TypeParamId(param_id) = p.id else {
+                    continue;
+                };
+                let idx = idx as u32 + generics.parent_count as u32;
+                let param_ty = Ty::new_param(ctx.interner, param_id, idx, p.name.clone());
+                if explicitly_unsized_tys.contains(&param_ty) {
+                    continue;
+                }
+                let trait_ref = TraitRef::new_from_args(
+                    ctx.interner,
+                    sized_trait.into(),
+                    GenericArgs::new_from_iter(ctx.interner, [param_ty.into()]),
+                );
+                let clause = Clause(Predicate::new(
+                    ctx.interner,
+                    Binder::dummy(rustc_type_ir::PredicateKind::Clause(
+                        rustc_type_ir::ClauseKind::Trait(TraitPredicate {
+                            trait_ref,
+                            polarity: rustc_type_ir::PredicatePolarity::Positive,
+                        }),
+                    )),
+                ));
+                clauses.push(clause);
+            }
+
+            if let Some(g) = generics.parent {
+                generics = crate::next_solver::generics::generics(db, g.into());
+                def_id = g;
+            } else {
+                break;
+            }
+        }
+    }
+
+    let clauses = rustc_type_ir::elaborate::elaborate(ctx.interner, clauses);
+    let clauses = Clauses::new_from_iter(ctx.interner, clauses);
+    let env = ParamEnv { clauses };
+
+    TraitEnvironment::new(resolver.krate(), None, traits_in_scope.into_boxed_slice(), env)
+}
+
 #[derive(Copy, Clone, Debug)]
 pub(crate) enum PredicateFilter {
     SelfTrait,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
index db74ca258732c..fd28159b49cb6 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
@@ -31,7 +31,7 @@ use crate::{
     infer::{Adjust, Adjustment, OverloadedDeref, PointerCast, unify::InferenceTable},
     lang_items::is_box,
     next_solver::{
-        self, SolverDefId,
+        self, DbInterner, SolverDefId,
         infer::{
             DefineOpaqueTypes,
             traits::{ObligationCause, PredicateObligation},
@@ -1755,7 +1755,10 @@ fn is_valid_trait_method_candidate(
                     };
                     let res = table
                         .infer_ctxt
-                        .at(&next_solver::infer::traits::ObligationCause::dummy(), table.param_env)
+                        .at(
+                            &next_solver::infer::traits::ObligationCause::dummy(),
+                            table.trait_env.env,
+                        )
                         .relate(
                             DefineOpaqueTypes::No,
                             expected_receiver.to_nextsolver(table.interner),
@@ -1845,7 +1848,12 @@ fn is_valid_impl_fn_candidate(
         let mut ctxt = ObligationCtxt::new(&table.infer_ctxt);
 
         ctxt.register_obligations(predicates.into_iter().map(|p| {
-            PredicateObligation::new(table.interner, ObligationCause::new(), table.param_env, p.0)
+            PredicateObligation::new(
+                table.interner,
+                ObligationCause::new(),
+                table.trait_env.env,
+                p.0,
+            )
         }));
 
         if ctxt.select_where_possible().is_empty() {
@@ -1893,7 +1901,10 @@ fn generic_implements_goal<'db>(
     let binders = CanonicalVarKinds::from_iter(Interner, kinds);
 
     let obligation = trait_ref.cast(Interner);
-    let value = InEnvironment::new(&env.env, obligation);
+    let value = InEnvironment::new(
+        &env.env.to_chalk(DbInterner::new_with(db, Some(env.krate), env.block)),
+        obligation,
+    );
     Canonical { binders, value }
 }
 
@@ -1910,7 +1921,7 @@ fn generic_implements_goal_ns<'db>(
     let trait_ref =
         rustc_type_ir::TraitRef::new_from_args(table.infer_ctxt.interner, trait_.into(), args)
             .with_replaced_self_ty(table.infer_ctxt.interner, self_ty);
-    let goal = next_solver::Goal::new(table.infer_ctxt.interner, table.param_env, trait_ref);
+    let goal = next_solver::Goal::new(table.infer_ctxt.interner, table.trait_env.env, trait_ref);
 
     table.canonicalize(goal)
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
index 2ba1e2341b297..a6215ef8fe4fe 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
@@ -632,7 +632,7 @@ fn issue_4053_diesel_where_clauses() {
             488..522 '{     ...     }': <SelectStatement<F, S, D, W, O, LOf, {unknown}, {unknown}> as BoxedDsl<DB>>::Output
             498..502 'self': SelectStatement<F, S, D, W, O, LOf, {unknown}, {unknown}>
             498..508 'self.order': O
-            498..515 'self.o...into()': dyn QueryFragment<DB> + '?
+            498..515 'self.o...into()': dyn QueryFragment<DB> + 'static
         "#]],
     );
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs b/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
index d6a86c13978b3..8ac152341e753 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/traits.rs
@@ -25,7 +25,7 @@ use crate::{
     db::HirDatabase,
     infer::unify::InferenceTable,
     next_solver::{
-        DbInterner, GenericArg, Predicate, SolverContext, Span,
+        DbInterner, GenericArg, ParamEnv, Predicate, SolverContext, Span,
         infer::{DbInternerInferExt, InferCtxt},
         mapping::{ChalkToNextSolver, convert_canonical_args_for_result},
         util::mini_canonicalize,
@@ -44,8 +44,7 @@ pub struct TraitEnvironment<'db> {
     pub block: Option<BlockId>,
     // FIXME make this a BTreeMap
     traits_from_clauses: Box<[(Ty, TraitId)]>,
-    pub env: chalk_ir::Environment<Interner>,
-    _db: std::marker::PhantomData<&'db ()>,
+    pub env: ParamEnv<'db>,
 }
 
 impl<'db> TraitEnvironment<'db> {
@@ -54,8 +53,7 @@ impl<'db> TraitEnvironment<'db> {
             krate,
             block: None,
             traits_from_clauses: Box::default(),
-            env: chalk_ir::Environment::new(Interner),
-            _db: std::marker::PhantomData,
+            env: ParamEnv::empty(),
         })
     }
 
@@ -63,15 +61,9 @@ impl<'db> TraitEnvironment<'db> {
         krate: Crate,
         block: Option<BlockId>,
         traits_from_clauses: Box<[(Ty, TraitId)]>,
-        env: chalk_ir::Environment<Interner>,
+        env: ParamEnv<'db>,
     ) -> Arc<Self> {
-        Arc::new(TraitEnvironment {
-            krate,
-            block,
-            traits_from_clauses,
-            env,
-            _db: std::marker::PhantomData,
-        })
+        Arc::new(TraitEnvironment { krate, block, traits_from_clauses, env })
     }
 
     // pub fn with_block(self: &mut Arc<Self>, block: BlockId) {
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index eaae15835d0b5..862067e5916c0 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -88,7 +88,7 @@ use hir_ty::{
     next_solver::{
         ClauseKind, DbInterner, GenericArgs,
         infer::InferCtxt,
-        mapping::{ChalkToNextSolver, convert_ty_for_result},
+        mapping::{ChalkToNextSolver, NextSolverToChalk, convert_ty_for_result},
     },
     primitive::UintTy,
     traits::FnTrait,
@@ -5171,7 +5171,14 @@ impl<'db> Type<'db> {
             .build();
 
         let goal = Canonical {
-            value: hir_ty::InEnvironment::new(&self.env.env, trait_ref.cast(Interner)),
+            value: hir_ty::InEnvironment::new(
+                &self.env.env.to_chalk(DbInterner::new_with(
+                    db,
+                    Some(self.env.krate),
+                    self.env.block,
+                )),
+                trait_ref.cast(Interner),
+            ),
             binders: CanonicalVarKinds::empty(Interner),
         };
 
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/tests.rs b/src/tools/rust-analyzer/crates/ide-completion/src/tests.rs
index 809a26bf5de47..b20b570c2b8df 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/tests.rs
@@ -26,6 +26,7 @@ mod visibility;
 
 use base_db::{SourceDatabase, salsa};
 use expect_test::Expect;
+use hir::db::HirDatabase;
 use hir::{PrefixKind, setup_tracing};
 use ide_db::{
     FilePosition, RootDatabase, SnippetCap,
@@ -306,8 +307,11 @@ pub(crate) fn get_all_items(
     trigger_character: Option<char>,
 ) -> Vec<CompletionItem> {
     let (db, position) = position(code);
-    let res = salsa::attach(&db, || crate::completions(&db, &config, position, trigger_character))
-        .map_or_else(Vec::default, Into::into);
+    let res = salsa::attach(&db, || {
+        HirDatabase::zalsa_register_downcaster(&db);
+        crate::completions(&db, &config, position, trigger_character)
+    })
+    .map_or_else(Vec::default, Into::into);
     // validate
     res.iter().for_each(|it| {
         let sr = it.source_range;
diff --git a/src/tools/rust-analyzer/crates/ide/src/view_memory_layout.rs b/src/tools/rust-analyzer/crates/ide/src/view_memory_layout.rs
index 5457d57b3976e..04537f908fbb8 100644
--- a/src/tools/rust-analyzer/crates/ide/src/view_memory_layout.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/view_memory_layout.rs
@@ -100,8 +100,8 @@ pub(crate) fn view_memory_layout(
         Definition::SelfType(it) => it.self_ty(db),
         Definition::Local(it) => it.ty(db),
         Definition::Field(it) => salsa::attach(db, || it.ty(db).to_type(db)),
-        Definition::Const(it) => it.ty(db),
-        Definition::Static(it) => it.ty(db),
+        Definition::Const(it) => salsa::attach(db, || it.ty(db)),
+        Definition::Static(it) => salsa::attach(db, || it.ty(db)),
         _ => return None,
     };
 

From 4c1595a93b349fa755d84f8943860589c27b64f0 Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Mon, 22 Sep 2025 21:13:38 -0400
Subject: [PATCH 1289/1889] Skip the panic-immediate-abort-works test when
 cross-compiling

---
 tests/run-make-cargo/panic-immediate-abort-works/rmake.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/tests/run-make-cargo/panic-immediate-abort-works/rmake.rs b/tests/run-make-cargo/panic-immediate-abort-works/rmake.rs
index bb15bd41e79c4..3eeef38c962dc 100644
--- a/tests/run-make-cargo/panic-immediate-abort-works/rmake.rs
+++ b/tests/run-make-cargo/panic-immediate-abort-works/rmake.rs
@@ -4,7 +4,12 @@
 // cleaner and more portable). So this test ensures that we didn't mix up a cfg or a compiler
 // implementation detail in a way that makes panic=immediate-abort encounter errors at link time.
 
+// Ideally this test would be run for most targets, but unfortunately:
+// This test is currently written using `fn main() {}` which requires std.
+// And since the default linker is only a linker for the host, we can't handle cross-compilation.
+// Both of these shortcomings could be addressed at the cost of making the test more complicated.
 //@ needs-target-std
+//@ ignore-cross-compile
 
 #![deny(warnings)]
 

From c241ff4089bf4619ec327c6da0955ee71a08c0a2 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Tue, 23 Sep 2025 11:26:52 +0800
Subject: [PATCH 1290/1889] Add const parameter keyword completion

Example
---
```rust
fn foo<c$0>() {}
```
->
```rust
fn foo<const $1: $0>() {}
```
---
 .../crates/ide-completion/src/completions.rs  |  4 ++-
 .../ide-completion/src/tests/special.rs       | 25 +++++++++++++++++++
 2 files changed, 28 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions.rs
index e36e0e5704581..eb2bb31f963e1 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions.rs
@@ -691,6 +691,9 @@ pub(super) fn complete_name(
         NameKind::RecordField => {
             field::complete_field_list_record_variant(acc, ctx);
         }
+        NameKind::TypeParam => {
+            acc.add_keyword_snippet(ctx, "const", "const $1: $0");
+        }
         NameKind::ConstParam
         | NameKind::Enum
         | NameKind::MacroDef
@@ -700,7 +703,6 @@ pub(super) fn complete_name(
         | NameKind::Static
         | NameKind::Struct
         | NameKind::Trait
-        | NameKind::TypeParam
         | NameKind::Union
         | NameKind::Variant => (),
     }
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/tests/special.rs b/src/tools/rust-analyzer/crates/ide-completion/src/tests/special.rs
index 84ddff8f617ac..c438ca7880625 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/tests/special.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/tests/special.rs
@@ -1510,3 +1510,28 @@ fn foo<T>() {
         "#]],
     );
 }
+
+#[test]
+fn fn_generic_params_const_param_snippet() {
+    check_edit("const", "fn foo<c$0>() {}", "fn foo<const $1: $0>() {}");
+    check_edit("const", "fn foo<T, c$0>() {}", "fn foo<T, const $1: $0>() {}");
+    check(
+        r#"
+fn foo<T: $0>() {}
+"#,
+        expect![[r#"
+            kw crate::
+            kw self::
+        "#]],
+    );
+    check(
+        r#"
+fn foo<const N: $0>() {}
+"#,
+        expect![[r#"
+            bt u32 u32
+            kw crate::
+            kw self::
+        "#]],
+    );
+}

From aaa82aea053bfbb226916b38c66243a28a296b6e Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 22 Sep 2025 21:52:48 +0530
Subject: [PATCH 1291/1889] move config check logic from get_toml to
 parse_inner

---
 src/bootstrap/src/core/builder/tests.rs   |  4 ++--
 src/bootstrap/src/core/config/config.rs   | 12 +++++++++++
 src/bootstrap/src/core/config/tests.rs    | 25 ++++++++---------------
 src/bootstrap/src/core/config/toml/mod.rs |  6 ------
 4 files changed, 23 insertions(+), 24 deletions(-)

diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index f838149977d01..4555f0d20912e 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -308,14 +308,14 @@ mod sysroot_target_dirs {
 /// cg_gcc tests instead.
 #[test]
 fn test_test_compiler() {
-    let config = configure_with_args(&["test", "compiler"], &[], &[TEST_TRIPLE_1]);
+    let config = configure_with_args(&["test", "compiler"], &[&host_target()], &[TEST_TRIPLE_1]);
     let cache = run_build(&config.paths.clone(), config);
 
     let compiler = cache.contains::<test::CrateLibrustc>();
     let cranelift = cache.contains::<test::CodegenCranelift>();
     let gcc = cache.contains::<test::CodegenGCC>();
 
-    assert_eq!((compiler, cranelift, gcc), (false, false, false));
+    assert_eq!((compiler, cranelift, gcc), (true, false, false));
 }
 
 #[test]
diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index 280ae088f3f3d..1e207380a0a1b 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -424,6 +424,18 @@ impl Config {
             src = src_;
         }
 
+        #[cfg(test)]
+        {
+            if let Some(config_path) = flags_config.as_ref() {
+                assert!(
+                    !config_path.starts_with(&src),
+                    "Path {config_path:?} should not be inside or equal to src dir {src:?}"
+                );
+            } else {
+                panic!("During test the config should be explicitly added");
+            }
+        }
+
         // Now load the TOML config, as soon as possible
         let (mut toml, toml_path) = load_toml_config(&src, flags_config, &get_toml);
 
diff --git a/src/bootstrap/src/core/config/tests.rs b/src/bootstrap/src/core/config/tests.rs
index 3390e9586a4c7..4f2df76a15658 100644
--- a/src/bootstrap/src/core/config/tests.rs
+++ b/src/bootstrap/src/core/config/tests.rs
@@ -175,20 +175,14 @@ fn override_toml_duplicate() {
 
 #[test]
 fn profile_user_dist() {
-    fn get_toml(file: &Path) -> Result<TomlConfig, toml::de::Error> {
-        let contents = if file.ends_with("bootstrap.toml")
-            || file.ends_with("config.toml")
-            || env::var_os("RUST_BOOTSTRAP_CONFIG").is_some()
-        {
-            "profile = \"user\"".to_owned()
-        } else {
-            assert!(file.ends_with("config.dist.toml") || file.ends_with("bootstrap.dist.toml"));
-            std::fs::read_to_string(file).unwrap()
-        };
-
-        toml::from_str(&contents).and_then(|table: toml::Value| TomlConfig::deserialize(table))
-    }
-    Config::parse_inner(Flags::parse(&["check".to_owned()]), get_toml);
+    TestCtx::new()
+        .config("check")
+        .with_default_toml_config(
+            r#"
+        profile = "user"
+    "#,
+        )
+        .create_config();
 }
 
 #[test]
@@ -224,8 +218,6 @@ fn verify_file_integrity() {
         config
             .verify(&tempfile, "7e255dd9542648a8779268a0f268b891a198e9828e860ed23f826440e786eae5")
     );
-
-    remove_file(tempfile).unwrap();
 }
 
 #[test]
@@ -648,6 +640,7 @@ fn test_include_precedence_over_profile() {
         .config("check")
         .with_default_toml_config(
             r#"
+        profile = "dist"
         include = ["./extension.toml"]
     "#,
         )
diff --git a/src/bootstrap/src/core/config/toml/mod.rs b/src/bootstrap/src/core/config/toml/mod.rs
index 5f86d2e728184..f6dc5b67e1010 100644
--- a/src/bootstrap/src/core/config/toml/mod.rs
+++ b/src/bootstrap/src/core/config/toml/mod.rs
@@ -152,12 +152,6 @@ impl Config {
     }
 
     pub(crate) fn get_toml(file: &Path) -> Result<TomlConfig, toml::de::Error> {
-        #[cfg(test)]
-        {
-            let tmp = std::env::temp_dir();
-            assert!(file.starts_with(&tmp), "Expected path in temp dir {:?}, got {:?}", tmp, file);
-        }
-
         Self::get_toml_inner(file)
     }
 

From 2d495ccaaa874666768b1a9e47e06d7de9e9aceb Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Tue, 23 Sep 2025 12:14:14 +0800
Subject: [PATCH 1292/1889] Migrate `expand_record_rest_pattern` assist to use
 `SyntaxEditor`

Because `add_field` uses `ted`
---
 .../src/handlers/expand_rest_pattern.rs       | 21 +++++++++----------
 .../crates/ide-assists/src/tests/generated.rs |  2 +-
 2 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/expand_rest_pattern.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/expand_rest_pattern.rs
index c80b78fd97056..44fe7957bca0e 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/expand_rest_pattern.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/expand_rest_pattern.rs
@@ -24,7 +24,7 @@ use crate::{AssistContext, AssistId, Assists};
 // struct Bar { y: Y, z: Z }
 //
 // fn foo(bar: Bar) {
-//     let Bar { y, z  } = bar;
+//     let Bar { y, z } = bar;
 // }
 // ```
 fn expand_record_rest_pattern(
@@ -53,18 +53,17 @@ fn expand_record_rest_pattern(
         |builder| {
             let make = SyntaxFactory::with_mappings();
             let mut editor = builder.make_editor(rest_pat.syntax());
-            let new_field_list = make.record_pat_field_list(old_field_list.fields(), None);
-            for (f, _) in missing_fields.iter() {
-                let field = make.record_pat_field_shorthand(
+            let new_fields = old_field_list.fields().chain(missing_fields.iter().map(|(f, _)| {
+                make.record_pat_field_shorthand(
                     make.ident_pat(
                         false,
                         false,
                         make.name(&f.name(ctx.sema.db).display_no_db(edition).to_smolstr()),
                     )
                     .into(),
-                );
-                new_field_list.add_field(field);
-            }
+                )
+            }));
+            let new_field_list = make.record_pat_field_list(new_fields, None);
 
             editor.replace(old_field_list.syntax(), new_field_list.syntax());
 
@@ -211,7 +210,7 @@ enum Foo {
 fn bar(foo: Foo) {
     match foo {
         Foo::A(_) => false,
-        Foo::B{ y, z  } => true,
+        Foo::B{ y, z } => true,
     };
 }
 "#,
@@ -272,7 +271,7 @@ struct Bar {
 }
 
 fn foo(bar: Bar) {
-    let Bar { y, z  } = bar;
+    let Bar { y, z } = bar;
 }
 "#,
         );
@@ -376,7 +375,7 @@ macro_rules! position {
 position!(usize);
 
 fn macro_call(pos: Pos) {
-    let Pos { x, y  } = pos;
+    let Pos { x, y } = pos;
 }
 "#,
         );
@@ -420,7 +419,7 @@ enum_gen!(usize);
 fn macro_call(foo: Foo) {
     match foo {
         Foo::A(_) => false,
-        Foo::B{ x, y  } => true,
+        Foo::B{ x, y } => true,
     }
 }
 "#,
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/tests/generated.rs b/src/tools/rust-analyzer/crates/ide-assists/src/tests/generated.rs
index 91348be97eb72..71ffaa23fc640 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/tests/generated.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/tests/generated.rs
@@ -1035,7 +1035,7 @@ fn foo(bar: Bar) {
 struct Bar { y: Y, z: Z }
 
 fn foo(bar: Bar) {
-    let Bar { y, z  } = bar;
+    let Bar { y, z } = bar;
 }
 "#####,
     )

From 9ae7aef06d1146ee30190fb399d548e1db3652dd Mon Sep 17 00:00:00 2001
From: Iris Shi <0.0@owo.li>
Date: Mon, 22 Sep 2025 15:02:02 +0800
Subject: [PATCH 1293/1889] prevent line number from being copied in chrome

---
 src/librustdoc/html/static/js/main.js | 25 ++++++++++++++++++-------
 1 file changed, 18 insertions(+), 7 deletions(-)

diff --git a/src/librustdoc/html/static/js/main.js b/src/librustdoc/html/static/js/main.js
index 75febd6f737e6..3ea9de381eca6 100644
--- a/src/librustdoc/html/static/js/main.js
+++ b/src/librustdoc/html/static/js/main.js
@@ -2227,11 +2227,18 @@ function preLoadCss(cssUrl) {
     });
 }());
 
-// This section is a bugfix for firefox: when copying text with `user-select: none`, it adds
-// extra backline characters.
+
+// Workaround for browser-specific bugs when copying code snippets.
+//
+// * In Firefox, copying text that includes elements with `user-select: none`
+//   inserts extra blank lines.
+//   - Firefox issue: https://bugzilla.mozilla.org/show_bug.cgi?id=1273836
+//   - Rust issue: https://github.com/rust-lang/rust/issues/141464
 //
-// Rustdoc issue: Workaround for https://github.com/rust-lang/rust/issues/141464
-// Firefox issue: https://bugzilla.mozilla.org/show_bug.cgi?id=1273836
+// * In Chromium-based browsers, `document.getSelection()` includes elements
+//   with `user-select: none`, causing unwanted line numbers to be copied.
+//   - Chromium issue: https://issues.chromium.org/issues/446539520
+//   - Rust issue: https://github.com/rust-lang/rust/issues/146816
 (function() {
     document.body.addEventListener("copy", event => {
         let target = nonnull(event.target);
@@ -2248,9 +2255,13 @@ function preLoadCss(cssUrl) {
         if (!isInsideCode) {
             return;
         }
-        const selection = document.getSelection();
-         // @ts-expect-error
-        nonnull(event.clipboardData).setData("text/plain", selection.toString());
+        const selection = nonnull(document.getSelection());
+        const text = Array.from({ length: selection.rangeCount }, (_, i) => {
+            const fragment = selection.getRangeAt(i).cloneContents();
+            fragment.querySelectorAll("[data-nosnippet]").forEach(el => el.remove());
+            return fragment.textContent;
+        }).join("");
+        nonnull(event.clipboardData).setData("text/plain", text);
         event.preventDefault();
     });
 }());

From 465e373542b529055cd1302849f79db13a617a98 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Tue, 23 Sep 2025 07:55:43 +0200
Subject: [PATCH 1294/1889] add regression test

---
 tests/ui/methods/overflow-if-subtyping.rs | 30 +++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 tests/ui/methods/overflow-if-subtyping.rs

diff --git a/tests/ui/methods/overflow-if-subtyping.rs b/tests/ui/methods/overflow-if-subtyping.rs
new file mode 100644
index 0000000000000..a97f29f1f6dfc
--- /dev/null
+++ b/tests/ui/methods/overflow-if-subtyping.rs
@@ -0,0 +1,30 @@
+//@ check-pass
+
+// Regression test for #128887.
+#![allow(unconditional_recursion)]
+trait Mappable<T> {
+    type Output;
+}
+
+trait Bound<T> {}
+// Deleting this impl made it compile on beta
+impl<T> Bound<T> for T {}
+
+trait Generic<M> {}
+
+// Deleting the `: Mappable<T>` already made it error on stable.
+struct IndexWithIter<I, M: Mappable<T>, T>(I, M, T);
+
+impl<I, M, T> IndexWithIter<I, M, T>
+where
+    <M as Mappable<T>>::Output: Bound<T>,
+    // Flipping these where bounds causes this to succeed, even when removing
+    // the where-clause on the struct definition.
+    M: Mappable<T>,
+    I: Generic<M>,
+{
+    fn new(x: I) {
+        IndexWithIter::<_, _, _>::new(x);
+    }
+}
+fn main() {}

From 3c8d8da693eb5d63099eef5cf4a73106a3a2ba25 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 23 Sep 2025 09:09:53 +0200
Subject: [PATCH 1295/1889] Prepare for merging from rust-lang/rust

This updates the rust-version file to f6092f224d2b1774b31033f12d0bee626943b02f.
---
 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 7333f7968f771..388e88fe43eb7 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-ec38671075266e9cee0348701da2e133379e7c6c
+f6092f224d2b1774b31033f12d0bee626943b02f

From c960e9c218e5adac9b61a3cd044d40ebc0cb1ace Mon Sep 17 00:00:00 2001
From: Jack Huey <31162821+jackh726@users.noreply.github.com>
Date: Mon, 22 Sep 2025 23:46:40 -0400
Subject: [PATCH 1296/1889] Remove lower::ty in favor of lower_nextsolver::ty

---
 .../crates/hir-ty/src/builder.rs              | 35 ++++++++------
 .../rust-analyzer/crates/hir-ty/src/db.rs     | 14 ++----
 .../rust-analyzer/crates/hir-ty/src/infer.rs  | 46 ++++++++++++++-----
 .../crates/hir-ty/src/infer/unify.rs          |  2 +-
 .../crates/hir-ty/src/layout/tests.rs         | 23 +++++-----
 .../rust-analyzer/crates/hir-ty/src/lower.rs  | 22 ---------
 .../crates/hir-ty/src/lower/path.rs           | 15 ++++--
 .../crates/hir-ty/src/method_resolution.rs    |  6 ++-
 .../crates/hir-ty/src/mir/eval/shim.rs        |  6 +--
 .../crates/hir-ty/src/next_solver/interner.rs |  4 +-
 .../crates/hir-ty/src/tests/incremental.rs    |  2 -
 .../hir-ty/src/tests/method_resolution.rs     |  2 +-
 src/tools/rust-analyzer/crates/hir/src/lib.rs | 23 +++++++---
 .../crates/ide/src/view_memory_layout.rs      |  4 +-
 14 files changed, 112 insertions(+), 92 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/builder.rs b/src/tools/rust-analyzer/crates/hir-ty/src/builder.rs
index 3755175cf5163..4957c69ae1656 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/builder.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/builder.rs
@@ -3,17 +3,20 @@
 use chalk_ir::{
     AdtId, DebruijnIndex, Scalar,
     cast::{Cast, CastTo, Caster},
-    fold::TypeFoldable,
-    interner::HasInterner,
 };
 use hir_def::{GenericDefId, GenericParamId, TraitId, TypeAliasId, builtin_type::BuiltinType};
 use smallvec::SmallVec;
 
 use crate::{
-    Binders, BoundVar, CallableSig, GenericArg, GenericArgData, Interner, ProjectionTy,
-    Substitution, TraitRef, Ty, TyDefId, TyExt, TyKind, consteval::unknown_const_as_generic,
-    db::HirDatabase, error_lifetime, generics::generics, infer::unify::InferenceTable, primitive,
-    to_assoc_type_id, to_chalk_trait_id,
+    BoundVar, CallableSig, GenericArg, GenericArgData, Interner, ProjectionTy, Substitution,
+    TraitRef, Ty, TyDefId, TyExt, TyKind,
+    consteval::unknown_const_as_generic,
+    db::HirDatabase,
+    error_lifetime,
+    generics::generics,
+    infer::unify::InferenceTable,
+    next_solver::{DbInterner, EarlyBinder, mapping::ChalkToNextSolver},
+    primitive, to_assoc_type_id, to_chalk_trait_id,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -345,19 +348,20 @@ impl TyBuilder<TypeAliasId> {
     }
 }
 
-impl<T: HasInterner<Interner = Interner> + TypeFoldable<Interner>> TyBuilder<Binders<T>> {
-    pub fn build(self) -> T {
+impl<'db, T: rustc_type_ir::TypeFoldable<DbInterner<'db>>> TyBuilder<EarlyBinder<'db, T>> {
+    pub fn build(self, interner: DbInterner<'db>) -> T {
         let (b, subst) = self.build_internal();
-        b.substitute(Interner, &subst)
+        let args: crate::next_solver::GenericArgs<'db> = subst.to_nextsolver(interner);
+        b.instantiate(interner, args)
     }
 }
 
-impl TyBuilder<Binders<Ty>> {
+impl<'db> TyBuilder<EarlyBinder<'db, crate::next_solver::Ty<'db>>> {
     pub fn def_ty(
-        db: &dyn HirDatabase,
+        db: &'db dyn HirDatabase,
         def: TyDefId,
         parent_subst: Option<Substitution>,
-    ) -> TyBuilder<Binders<Ty>> {
+    ) -> TyBuilder<EarlyBinder<'db, crate::next_solver::Ty<'db>>> {
         let poly_ty = db.ty(def);
         let id: GenericDefId = match def {
             TyDefId::BuiltinType(_) => {
@@ -370,7 +374,10 @@ impl TyBuilder<Binders<Ty>> {
         TyBuilder::subst_for_def(db, id, parent_subst).with_data(poly_ty)
     }
 
-    pub fn impl_self_ty(db: &dyn HirDatabase, def: hir_def::ImplId) -> TyBuilder<Binders<Ty>> {
-        TyBuilder::subst_for_def(db, def, None).with_data(db.impl_self_ty(def))
+    pub fn impl_self_ty(
+        db: &'db dyn HirDatabase,
+        def: hir_def::ImplId,
+    ) -> TyBuilder<EarlyBinder<'db, crate::next_solver::Ty<'db>>> {
+        TyBuilder::subst_for_def(db, def, None).with_data(db.impl_self_ty_ns(def))
     }
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
index 44f48069ab240..41540f328b237 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
@@ -114,9 +114,12 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
     #[salsa::invoke(crate::dyn_compatibility::dyn_compatibility_of_trait_query)]
     fn dyn_compatibility_of_trait(&self, trait_: TraitId) -> Option<DynCompatibilityViolation>;
 
-    #[salsa::invoke(crate::lower::ty_query)]
+    #[salsa::invoke(crate::lower_nextsolver::ty_query)]
     #[salsa::transparent]
-    fn ty(&self, def: TyDefId) -> Binders<Ty>;
+    fn ty<'db>(
+        &'db self,
+        def: TyDefId,
+    ) -> crate::next_solver::EarlyBinder<'db, crate::next_solver::Ty<'db>>;
 
     #[salsa::invoke(crate::lower::type_for_type_alias_with_diagnostics_query)]
     #[salsa::cycle(cycle_result = crate::lower::type_for_type_alias_with_diagnostics_cycle_result)]
@@ -277,13 +280,6 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
 
     // next trait solver
 
-    #[salsa::invoke(crate::lower_nextsolver::ty_query)]
-    #[salsa::transparent]
-    fn ty_ns<'db>(
-        &'db self,
-        def: TyDefId,
-    ) -> crate::next_solver::EarlyBinder<'db, crate::next_solver::Ty<'db>>;
-
     /// Returns the type of the value of the given constant, or `None` if the `ValueTyDefId` is
     /// a `StructId` or `EnumVariantId` with a record constructor.
     #[salsa::invoke(crate::lower_nextsolver::value_ty_query)]
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
index 3ece62ec35b63..0a095ea644589 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
@@ -1708,6 +1708,7 @@ impl<'db> InferenceContext<'db> {
             LifetimeElisionKind::Infer,
         );
         let mut path_ctx = ctx.at_path(path, node);
+        let interner = DbInterner::conjure();
         let (resolution, unresolved) = if value_ns {
             let Some(res) = path_ctx.resolve_path_in_value_ns(HygieneId::ROOT) else {
                 return (self.err_ty(), None);
@@ -1717,15 +1718,27 @@ impl<'db> InferenceContext<'db> {
                     ValueNs::EnumVariantId(var) => {
                         let substs = path_ctx.substs_from_path(var.into(), true, false);
                         drop(ctx);
-                        let ty = self.db.ty(var.lookup(self.db).parent.into());
-                        let ty = self.insert_type_vars(ty.substitute(Interner, &substs));
+                        let args: crate::next_solver::GenericArgs<'_> =
+                            substs.to_nextsolver(interner);
+                        let ty = self
+                            .db
+                            .ty(var.lookup(self.db).parent.into())
+                            .instantiate(interner, args)
+                            .to_chalk(interner);
+                        let ty = self.insert_type_vars(ty);
                         return (ty, Some(var.into()));
                     }
                     ValueNs::StructId(strukt) => {
                         let substs = path_ctx.substs_from_path(strukt.into(), true, false);
                         drop(ctx);
-                        let ty = self.db.ty(strukt.into());
-                        let ty = self.insert_type_vars(ty.substitute(Interner, &substs));
+                        let args: crate::next_solver::GenericArgs<'_> =
+                            substs.to_nextsolver(interner);
+                        let ty = self
+                            .db
+                            .ty(strukt.into())
+                            .instantiate(interner, args)
+                            .to_chalk(interner);
+                        let ty = self.insert_type_vars(ty);
                         return (ty, Some(strukt.into()));
                     }
                     ValueNs::ImplSelf(impl_id) => (TypeNs::SelfType(impl_id), None),
@@ -1746,22 +1759,29 @@ impl<'db> InferenceContext<'db> {
             TypeNs::AdtId(AdtId::StructId(strukt)) => {
                 let substs = path_ctx.substs_from_path(strukt.into(), true, false);
                 drop(ctx);
-                let ty = self.db.ty(strukt.into());
-                let ty = self.insert_type_vars(ty.substitute(Interner, &substs));
+                let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);
+                let ty = self.db.ty(strukt.into()).instantiate(interner, args).to_chalk(interner);
+                let ty = self.insert_type_vars(ty);
                 forbid_unresolved_segments((ty, Some(strukt.into())), unresolved)
             }
             TypeNs::AdtId(AdtId::UnionId(u)) => {
                 let substs = path_ctx.substs_from_path(u.into(), true, false);
                 drop(ctx);
-                let ty = self.db.ty(u.into());
-                let ty = self.insert_type_vars(ty.substitute(Interner, &substs));
+                let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);
+                let ty = self.db.ty(u.into()).instantiate(interner, args).to_chalk(interner);
+                let ty = self.insert_type_vars(ty);
                 forbid_unresolved_segments((ty, Some(u.into())), unresolved)
             }
             TypeNs::EnumVariantId(var) => {
                 let substs = path_ctx.substs_from_path(var.into(), true, false);
                 drop(ctx);
-                let ty = self.db.ty(var.lookup(self.db).parent.into());
-                let ty = self.insert_type_vars(ty.substitute(Interner, &substs));
+                let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);
+                let ty = self
+                    .db
+                    .ty(var.lookup(self.db).parent.into())
+                    .instantiate(interner, args)
+                    .to_chalk(interner);
+                let ty = self.insert_type_vars(ty);
                 forbid_unresolved_segments((ty, Some(var.into())), unresolved)
             }
             TypeNs::SelfType(impl_id) => {
@@ -1844,8 +1864,10 @@ impl<'db> InferenceContext<'db> {
                 };
                 let substs = path_ctx.substs_from_path_segment(it.into(), true, None, false);
                 drop(ctx);
-                let ty = self.db.ty(it.into());
-                let ty = self.insert_type_vars(ty.substitute(Interner, &substs));
+                let interner = DbInterner::conjure();
+                let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);
+                let ty = self.db.ty(it.into()).instantiate(interner, args).to_chalk(interner);
+                let ty = self.insert_type_vars(ty);
 
                 self.resolve_variant_on_alias(ty, unresolved, mod_path)
             }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
index 6df9cbaa29394..dd7e77ba8c098 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
@@ -780,7 +780,7 @@ impl<'db> InferenceTable<'db> {
     }
 
     pub(crate) fn structurally_resolve_type(&mut self, ty: &Ty) -> Ty {
-        if let TyKind::Alias(..) = ty.kind(Interner) {
+        if let TyKind::Alias(chalk_ir::AliasTy::Projection(..)) = ty.kind(Interner) {
             self.structurally_normalize_ty(ty)
         } else {
             self.resolve_vars_with_obligations(ty.to_nextsolver(self.interner))
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs
index 523ddad94666b..6960e230a6850 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs
@@ -1,18 +1,17 @@
 use base_db::target::TargetData;
-use chalk_ir::{AdtId, TyKind};
 use either::Either;
 use hir_def::db::DefDatabase;
 use project_model::{Sysroot, toolchain_info::QueryConfig};
 use rustc_hash::FxHashMap;
+use rustc_type_ir::inherent::{GenericArgs as _, Ty as _};
 use syntax::ToSmolStr;
 use test_fixture::WithFixture;
 use triomphe::Arc;
 
 use crate::{
-    Interner, Substitution,
     db::HirDatabase,
     layout::{Layout, LayoutError},
-    next_solver::{DbInterner, mapping::ChalkToNextSolver},
+    next_solver::{AdtDef, DbInterner, GenericArgs, mapping::ChalkToNextSolver},
     setup_tracing,
     test_db::TestDB,
 };
@@ -80,18 +79,18 @@ fn eval_goal(
             Some(adt_or_type_alias_id)
         })
         .unwrap();
-    let goal_ty = match adt_or_type_alias_id {
-        Either::Left(adt_id) => {
-            TyKind::Adt(AdtId(adt_id), Substitution::empty(Interner)).intern(Interner)
-        }
-        Either::Right(ty_id) => {
-            db.ty(ty_id.into()).substitute(Interner, &Substitution::empty(Interner))
-        }
-    };
     salsa::attach(&db, || {
         let interner = DbInterner::new_with(&db, None, None);
+        let goal_ty = match adt_or_type_alias_id {
+            Either::Left(adt_id) => crate::next_solver::Ty::new_adt(
+                interner,
+                AdtDef::new(adt_id, interner),
+                GenericArgs::identity_for_item(interner, adt_id.into()),
+            ),
+            Either::Right(ty_id) => db.ty(ty_id.into()).instantiate_identity(),
+        };
         db.layout_of_ty(
-            goal_ty.to_nextsolver(interner),
+            goal_ty,
             db.trait_environment(match adt_or_type_alias_id {
                 Either::Left(adt) => hir_def::GenericDefId::AdtId(adt),
                 Either::Right(ty) => hir_def::GenericDefId::TypeAliasId(ty),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
index 20f421dbbcd90..97005e5d466a2 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
@@ -1458,16 +1458,6 @@ fn type_for_enum_variant_constructor(
     }
 }
 
-#[salsa_macros::tracked(cycle_result = type_for_adt_cycle_result)]
-fn type_for_adt_tracked(db: &dyn HirDatabase, adt: AdtId) -> Binders<Ty> {
-    type_for_adt(db, adt)
-}
-
-fn type_for_adt_cycle_result(db: &dyn HirDatabase, adt: AdtId) -> Binders<Ty> {
-    let generics = generics(db, adt.into());
-    make_binders(db, &generics, TyKind::Error.intern(Interner))
-}
-
 fn type_for_adt(db: &dyn HirDatabase, adt: AdtId) -> Binders<Ty> {
     let generics = generics(db, adt.into());
     let subst = generics.bound_vars_subst(db, DebruijnIndex::INNERMOST);
@@ -1547,18 +1537,6 @@ impl ValueTyDefId {
     }
 }
 
-/// Build the declared type of an item. This depends on the namespace; e.g. for
-/// `struct Foo(usize)`, we have two types: The type of the struct itself, and
-/// the constructor function `(usize) -> Foo` which lives in the values
-/// namespace.
-pub(crate) fn ty_query(db: &dyn HirDatabase, def: TyDefId) -> Binders<Ty> {
-    match def {
-        TyDefId::BuiltinType(it) => Binders::empty(Interner, TyBuilder::builtin(it)),
-        TyDefId::AdtId(it) => type_for_adt_tracked(db, it),
-        TyDefId::TypeAliasId(it) => db.type_for_type_alias_with_diagnostics(it).0,
-    }
-}
-
 pub(crate) fn value_ty_query(db: &dyn HirDatabase, def: ValueTyDefId) -> Option<Binders<Ty>> {
     match def {
         ValueTyDefId::FunctionId(it) => Some(type_for_fn(db, it)),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs
index bc03298e3bbb0..279bbff7c0d9e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs
@@ -28,6 +28,10 @@ use crate::{
     error_lifetime,
     generics::{Generics, generics},
     lower::{LifetimeElisionKind, named_associated_type_shorthand_candidates},
+    next_solver::{
+        DbInterner,
+        mapping::{ChalkToNextSolver, NextSolverToChalk},
+    },
     static_lifetime, to_assoc_type_id, to_chalk_trait_id, to_placeholder_idx,
     utils::associated_type_by_name_including_super_traits,
 };
@@ -256,7 +260,8 @@ impl<'a, 'b> PathLoweringContext<'a, 'b> {
                     }
                     ParamLoweringMode::Variable => TyBuilder::impl_self_ty(self.ctx.db, impl_id)
                         .fill_with_bound_vars(self.ctx.in_binders, 0)
-                        .build(),
+                        .build(DbInterner::conjure())
+                        .to_chalk(DbInterner::conjure()),
                 }
             }
             TypeNs::AdtSelfType(adt) => {
@@ -267,7 +272,9 @@ impl<'a, 'b> PathLoweringContext<'a, 'b> {
                         generics.bound_vars_subst(self.ctx.db, self.ctx.in_binders)
                     }
                 };
-                self.ctx.db.ty(adt.into()).substitute(Interner, &substs)
+                let interner = DbInterner::conjure();
+                let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);
+                self.ctx.db.ty(adt.into()).instantiate(interner, args).to_chalk(interner)
             }
 
             TypeNs::AdtId(it) => self.lower_path_inner(it.into(), infer_args),
@@ -537,7 +544,9 @@ impl<'a, 'b> PathLoweringContext<'a, 'b> {
             TyDefId::TypeAliasId(it) => it.into(),
         };
         let substs = self.substs_from_path_segment(generic_def, infer_args, None, false);
-        self.ctx.db.ty(typeable).substitute(Interner, &substs)
+        let interner = DbInterner::conjure();
+        let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);
+        self.ctx.db.ty(typeable).instantiate(interner, args).to_chalk(interner)
     }
 
     /// Collect generic arguments from a path into a `Substs`. See also
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
index fd28159b49cb6..66687490b4a45 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
@@ -1697,8 +1697,10 @@ fn is_valid_impl_method_candidate(
                 return IsValidCandidate::NotVisible;
             }
             let self_ty_matches = table.run_in_snapshot(|table| {
-                let expected_self_ty =
-                    TyBuilder::impl_self_ty(db, impl_id).fill_with_inference_vars(table).build();
+                let expected_self_ty = TyBuilder::impl_self_ty(db, impl_id)
+                    .fill_with_inference_vars(table)
+                    .build(DbInterner::conjure())
+                    .to_chalk(DbInterner::conjure());
                 table.unify(&expected_self_ty, self_ty)
             });
             if !self_ty_matches {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs
index f67778b0f12f3..bb0d1f70fbb29 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs
@@ -14,6 +14,7 @@ use hir_expand::name::Name;
 use intern::{Symbol, sym};
 use stdx::never;
 
+use crate::next_solver::mapping::NextSolverToChalk;
 use crate::{
     DropGlue,
     display::DisplayTarget,
@@ -1371,9 +1372,8 @@ impl Evaluator<'_> {
                     result = (l as i8).cmp(&(r as i8));
                 }
                 if let Some(e) = LangItem::Ordering.resolve_enum(self.db, self.crate_id) {
-                    let ty = self.db.ty(e.into());
-                    let r = self
-                        .compute_discriminant(ty.skip_binders().clone(), &[result as i8 as u8])?;
+                    let ty = self.db.ty(e.into()).skip_binder().to_chalk(interner);
+                    let r = self.compute_discriminant(ty.clone(), &[result as i8 as u8])?;
                     destination.write_from_bytes(self, &r.to_le_bytes()[0..destination.size])?;
                     Ok(())
                 } else {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
index 9cf56bef9578a..6c4212e6ecd43 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
@@ -1091,9 +1091,9 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
                     ItemContainerId::ImplId(it) => it,
                     _ => panic!("assoc ty value should be in impl"),
                 };
-                self.db().ty_ns(id.into())
+                self.db().ty(id.into())
             }
-            SolverDefId::AdtId(id) => self.db().ty_ns(id.into()),
+            SolverDefId::AdtId(id) => self.db().ty(id.into()),
             // FIXME(next-solver): This uses the types of `query mir_borrowck` in rustc.
             //
             // We currently always use the type from HIR typeck which ignores regions. This
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
index c0b930e5e1231..0d922de9aeb07 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
@@ -511,7 +511,6 @@ impl SomeStruct {
                 "struct_signature_shim",
                 "struct_signature_with_source_map_shim",
                 "attrs_shim",
-                "type_for_adt_tracked",
             ]
         "#]],
     );
@@ -609,7 +608,6 @@ fn main() {
                 "trait_impls_in_crate_shim",
                 "impl_trait_with_diagnostics_shim",
                 "impl_self_ty_with_diagnostics_shim",
-                "type_for_adt_tracked",
                 "impl_trait_with_diagnostics_ns_shim",
                 "impl_self_ty_with_diagnostics_ns_shim",
                 "generic_predicates_ns_shim",
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs
index b14ce35aa99c8..6a566a505579c 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs
@@ -2053,7 +2053,7 @@ impl dyn Error + Send {
                                // ^^^^ expected Box<dyn Error + '?>, got Box<dyn Error + Send + '?>
                                // FIXME, type mismatch should not occur
         <dyn Error>::downcast(err).map_err(|_| loop {})
-      //^^^^^^^^^^^^^^^^^^^^^ type: fn downcast<{unknown}>(Box<dyn Error + '?>) -> Result<Box<{unknown}>, Box<dyn Error + '?>>
+      //^^^^^^^^^^^^^^^^^^^^^ type: fn downcast<{unknown}>(Box<dyn Error + 'static>) -> Result<Box<{unknown}>, Box<dyn Error + '?>>
     }
 }
 "#,
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index 862067e5916c0..a1d9e6d365f83 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -1504,7 +1504,7 @@ impl<'db> InstantiatedStruct<'db> {
         let krate = self.inner.krate(db);
         let interner = DbInterner::new_with(db, Some(krate.base()), None);
 
-        let ty = db.ty_ns(self.inner.id.into());
+        let ty = db.ty(self.inner.id.into());
         TypeNs::new(db, self.inner.id, ty.instantiate(interner, self.args))
     }
 }
@@ -1664,7 +1664,7 @@ impl<'db> InstantiatedEnum<'db> {
         let krate = self.inner.krate(db);
         let interner = DbInterner::new_with(db, Some(krate.base()), None);
 
-        let ty = db.ty_ns(self.inner.id.into());
+        let ty = db.ty(self.inner.id.into());
         TypeNs::new(db, self.inner.id, ty.instantiate(interner, self.args))
     }
 }
@@ -1851,7 +1851,8 @@ impl Adt {
                     ParamKind::Lifetime => error_lifetime().cast(Interner),
                 }
             })
-            .build();
+            .build(DbInterner::conjure())
+            .to_chalk(DbInterner::conjure());
         Type::new(db, id, ty)
     }
 
@@ -4828,32 +4829,40 @@ impl<'db> Type<'db> {
     }
 
     fn from_def(db: &'db dyn HirDatabase, def: impl Into<TyDefId> + HasResolver) -> Self {
+        let interner = DbInterner::new_with(db, None, None);
         let ty = db.ty(def.into());
         let substs = TyBuilder::unknown_subst(
             db,
             match def.into() {
                 TyDefId::AdtId(it) => GenericDefId::AdtId(it),
                 TyDefId::TypeAliasId(it) => GenericDefId::TypeAliasId(it),
-                TyDefId::BuiltinType(_) => return Type::new(db, def, ty.skip_binders().clone()),
+                TyDefId::BuiltinType(_) => {
+                    return Type::new(db, def, ty.skip_binder().to_chalk(interner));
+                }
             },
         );
-        Type::new(db, def, ty.substitute(Interner, &substs))
+        let args: hir_ty::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);
+        Type::new(db, def, ty.instantiate(interner, args).to_chalk(interner))
     }
 
     fn from_def_placeholders(
         db: &'db dyn HirDatabase,
         def: impl Into<TyDefId> + HasResolver,
     ) -> Self {
+        let interner = DbInterner::new_with(db, None, None);
         let ty = db.ty(def.into());
         let substs = TyBuilder::placeholder_subst(
             db,
             match def.into() {
                 TyDefId::AdtId(it) => GenericDefId::AdtId(it),
                 TyDefId::TypeAliasId(it) => GenericDefId::TypeAliasId(it),
-                TyDefId::BuiltinType(_) => return Type::new(db, def, ty.skip_binders().clone()),
+                TyDefId::BuiltinType(_) => {
+                    return Type::new(db, def, ty.skip_binder().to_chalk(interner));
+                }
             },
         );
-        Type::new(db, def, ty.substitute(Interner, &substs))
+        let args: hir_ty::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);
+        Type::new(db, def, ty.instantiate(interner, args).to_chalk(interner))
     }
 
     fn from_value_def(
diff --git a/src/tools/rust-analyzer/crates/ide/src/view_memory_layout.rs b/src/tools/rust-analyzer/crates/ide/src/view_memory_layout.rs
index 04537f908fbb8..ddd58a0a3c9fb 100644
--- a/src/tools/rust-analyzer/crates/ide/src/view_memory_layout.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/view_memory_layout.rs
@@ -94,8 +94,8 @@ pub(crate) fn view_memory_layout(
     let def = get_definition(&sema, token)?;
 
     let ty = match def {
-        Definition::Adt(it) => it.ty(db),
-        Definition::TypeAlias(it) => it.ty(db),
+        Definition::Adt(it) => salsa::attach(db, || it.ty(db)),
+        Definition::TypeAlias(it) => salsa::attach(db, || it.ty(db)),
         Definition::BuiltinType(it) => it.ty(db),
         Definition::SelfType(it) => it.self_ty(db),
         Definition::Local(it) => it.ty(db),

From 9e34268e24b753355a96bc9326d8e4e2a2ca916a Mon Sep 17 00:00:00 2001
From: Jack Huey <31162821+jackh726@users.noreply.github.com>
Date: Tue, 23 Sep 2025 00:26:28 -0400
Subject: [PATCH 1297/1889] Remove lower::value_ty in favor of
 lower_nextsolver::value_ty

---
 .../rust-analyzer/crates/hir-ty/src/db.rs     | 15 +--
 .../crates/hir-ty/src/infer/expr.rs           | 42 +++++---
 .../crates/hir-ty/src/infer/path.rs           | 13 ++-
 .../rust-analyzer/crates/hir-ty/src/lower.rs  | 99 +------------------
 .../crates/hir-ty/src/next_solver/interner.rs |  6 +-
 src/tools/rust-analyzer/crates/hir/src/lib.rs |  8 +-
 .../crates/hir/src/source_analyzer.rs         | 10 +-
 .../ide-db/src/syntax_helpers/suggest_name.rs |  2 +-
 8 files changed, 61 insertions(+), 134 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
index 41540f328b237..6eb5f8defaa1b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
@@ -127,8 +127,11 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
 
     /// Returns the type of the value of the given constant, or `None` if the `ValueTyDefId` is
     /// a `StructId` or `EnumVariantId` with a record constructor.
-    #[salsa::invoke(crate::lower::value_ty_query)]
-    fn value_ty(&self, def: ValueTyDefId) -> Option<Binders<Ty>>;
+    #[salsa::invoke(crate::lower_nextsolver::value_ty_query)]
+    fn value_ty<'db>(
+        &'db self,
+        def: ValueTyDefId,
+    ) -> Option<crate::next_solver::EarlyBinder<'db, crate::next_solver::Ty<'db>>>;
 
     #[salsa::invoke(crate::lower::impl_self_ty_with_diagnostics_query)]
     #[salsa::cycle(cycle_result = crate::lower::impl_self_ty_with_diagnostics_cycle_result)]
@@ -280,14 +283,6 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
 
     // next trait solver
 
-    /// Returns the type of the value of the given constant, or `None` if the `ValueTyDefId` is
-    /// a `StructId` or `EnumVariantId` with a record constructor.
-    #[salsa::invoke(crate::lower_nextsolver::value_ty_query)]
-    fn value_ty_ns<'db>(
-        &'db self,
-        def: ValueTyDefId,
-    ) -> Option<crate::next_solver::EarlyBinder<'db, crate::next_solver::Ty<'db>>>;
-
     #[salsa::invoke(crate::lower_nextsolver::type_for_type_alias_with_diagnostics_query)]
     #[salsa::cycle(cycle_result = crate::lower_nextsolver::type_for_type_alias_with_diagnostics_cycle_result)]
     fn type_for_type_alias_with_diagnostics_ns<'db>(
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
index b4a332f1da849..ddf632c1c81b5 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
@@ -23,13 +23,13 @@ use syntax::ast::RangeOp;
 use tracing::debug;
 
 use crate::autoderef::overloaded_deref_ty;
-use crate::next_solver::ErrorGuaranteed;
 use crate::next_solver::infer::DefineOpaqueTypes;
 use crate::next_solver::obligation_ctxt::ObligationCtxt;
+use crate::next_solver::{DbInterner, ErrorGuaranteed};
 use crate::{
-    Adjust, Adjustment, AdtId, AutoBorrow, Binders, CallableDefId, CallableSig, DeclContext,
-    DeclOrigin, IncorrectGenericsLenKind, Interner, LifetimeElisionKind, Rawness, Scalar,
-    Substitution, TraitEnvironment, TraitRef, Ty, TyBuilder, TyExt, TyKind, consteval,
+    Adjust, Adjustment, AdtId, AutoBorrow, CallableDefId, CallableSig, DeclContext, DeclOrigin,
+    IncorrectGenericsLenKind, Interner, LifetimeElisionKind, Rawness, Scalar, Substitution,
+    TraitEnvironment, TraitRef, Ty, TyBuilder, TyExt, TyKind, consteval,
     generics::generics,
     infer::{
         AllowTwoPhase, BreakableKind,
@@ -1481,7 +1481,10 @@ impl<'db> InferenceContext<'db> {
 
         self.write_method_resolution(tgt_expr, func, subst.clone());
 
-        let method_ty = self.db.value_ty(func.into()).unwrap().substitute(Interner, &subst);
+        let interner = DbInterner::new_with(self.db, None, None);
+        let args: crate::next_solver::GenericArgs<'_> = subst.to_nextsolver(interner);
+        let method_ty =
+            self.db.value_ty(func.into()).unwrap().instantiate(interner, args).to_chalk(interner);
         self.register_obligations_for_call(&method_ty);
 
         self.infer_expr_coerce(rhs, &Expectation::has_type(rhs_ty.clone()), ExprIsRead::Yes);
@@ -1800,11 +1803,17 @@ impl<'db> InferenceContext<'db> {
                         self.write_expr_adj(receiver, adjustments.into_boxed_slice());
                         self.write_method_resolution(tgt_expr, func, substs.clone());
 
+                        let interner = DbInterner::new_with(self.db, None, None);
+                        let args: crate::next_solver::GenericArgs<'_> =
+                            substs.to_nextsolver(interner);
                         self.check_method_call(
                             tgt_expr,
                             &[],
-                            self.db.value_ty(func.into()).unwrap(),
-                            substs,
+                            self.db
+                                .value_ty(func.into())
+                                .unwrap()
+                                .instantiate(interner, args)
+                                .to_chalk(interner),
                             ty,
                             expected,
                         )
@@ -1963,11 +1972,16 @@ impl<'db> InferenceContext<'db> {
 
                 let substs = self.substs_for_method_call(tgt_expr, func.into(), generic_args);
                 self.write_method_resolution(tgt_expr, func, substs.clone());
+                let interner = DbInterner::new_with(self.db, None, None);
+                let gen_args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);
                 self.check_method_call(
                     tgt_expr,
                     args,
-                    self.db.value_ty(func.into()).expect("we have a function def"),
-                    substs,
+                    self.db
+                        .value_ty(func.into())
+                        .expect("we have a function def")
+                        .instantiate(interner, gen_args)
+                        .to_chalk(interner),
                     ty,
                     expected,
                 )
@@ -2012,11 +2026,15 @@ impl<'db> InferenceContext<'db> {
                 let recovered = match assoc_func_with_same_name {
                     Some(f) => {
                         let substs = self.substs_for_method_call(tgt_expr, f.into(), generic_args);
+                        let interner = DbInterner::new_with(self.db, None, None);
+                        let args: crate::next_solver::GenericArgs<'_> =
+                            substs.to_nextsolver(interner);
                         let f = self
                             .db
                             .value_ty(f.into())
                             .expect("we have a function def")
-                            .substitute(Interner, &substs);
+                            .instantiate(interner, args)
+                            .to_chalk(interner);
                         let sig = f.callable_sig(self.db).expect("we have a function def");
                         Some((f, sig, true))
                     }
@@ -2056,12 +2074,10 @@ impl<'db> InferenceContext<'db> {
         &mut self,
         tgt_expr: ExprId,
         args: &[ExprId],
-        method_ty: Binders<Ty>,
-        substs: Substitution,
+        method_ty: Ty,
         receiver_ty: Ty,
         expected: &Expectation,
     ) -> Ty {
-        let method_ty = method_ty.substitute(Interner, &substs);
         self.register_obligations_for_call(&method_ty);
         let interner = self.table.interner;
         let ((formal_receiver_ty, param_tys), ret_ty, is_varargs) =
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs
index 80f7324e58b2b..3a50b832cf19d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs
@@ -17,7 +17,10 @@ use crate::{
     generics::generics,
     infer::diagnostics::InferenceTyLoweringContext as TyLoweringContext,
     method_resolution::{self, VisibleFromModule},
-    next_solver::mapping::ChalkToNextSolver,
+    next_solver::{
+        DbInterner,
+        mapping::{ChalkToNextSolver, NextSolverToChalk},
+    },
     to_chalk_trait_id,
 };
 
@@ -36,7 +39,9 @@ impl<'db> InferenceContext<'db> {
 
         self.add_required_obligations_for_value_path(generic_def, &substs);
 
-        let ty = self.db.value_ty(value_def)?.substitute(Interner, &substs);
+        let interner = DbInterner::new_with(self.db, None, None);
+        let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);
+        let ty = self.db.value_ty(value_def)?.instantiate(interner, args).to_chalk(interner);
         let ty = self.process_remote_user_written_ty(ty);
         Some(ty)
     }
@@ -89,9 +94,9 @@ impl<'db> InferenceContext<'db> {
 
         let generic_def = value_def.to_generic_def_id(self.db);
         if let GenericDefId::StaticId(_) = generic_def {
+            let interner = DbInterner::new_with(self.db, None, None);
             // `Static` is the kind of item that can never be generic currently. We can just skip the binders to get its type.
-            let (ty, binders) = self.db.value_ty(value_def)?.into_value_and_skipped_binders();
-            stdx::always!(binders.is_empty(Interner), "non-empty binders for non-generic def",);
+            let ty = self.db.value_ty(value_def)?.skip_binder().to_chalk(interner);
             return Some(ValuePathResolution::NonGeneric(ty));
         };
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
index 97005e5d466a2..756769a2174f1 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
@@ -30,7 +30,6 @@ use hir_def::{
     builtin_type::BuiltinType,
     expr_store::{ExpressionStore, path::Path},
     hir::generics::{GenericParamDataRef, TypeOrConstParamData, WherePredicate},
-    item_tree::FieldsShape,
     lang_item::LangItem,
     resolver::{HasResolver, LifetimeNs, Resolver, TypeNs},
     signatures::{FunctionSignature, TraitFlags, TypeAliasFlags},
@@ -59,7 +58,7 @@ use crate::{
         path::{PathDiagnosticCallback, PathLoweringContext},
     },
     make_binders,
-    mapping::{ToChalk, from_chalk_trait_id, lt_to_placeholder_idx},
+    mapping::{from_chalk_trait_id, lt_to_placeholder_idx},
     static_lifetime, to_chalk_trait_id, to_placeholder_idx,
     utils::all_super_trait_refs,
     variable_kinds_from_iter,
@@ -1352,51 +1351,6 @@ fn fn_sig_for_fn(db: &dyn HirDatabase, def: FunctionId) -> PolyFnSig {
     make_binders(db, &generics, sig)
 }
 
-/// Build the declared type of a function. This should not need to look at the
-/// function body.
-fn type_for_fn(db: &dyn HirDatabase, def: FunctionId) -> Binders<Ty> {
-    let generics = generics(db, def.into());
-    let substs = generics.bound_vars_subst(db, DebruijnIndex::INNERMOST);
-    make_binders(
-        db,
-        &generics,
-        TyKind::FnDef(CallableDefId::FunctionId(def).to_chalk(db), substs).intern(Interner),
-    )
-}
-
-/// Build the declared type of a const.
-fn type_for_const(db: &dyn HirDatabase, def: ConstId) -> Binders<Ty> {
-    let data = db.const_signature(def);
-    let generics = generics(db, def.into());
-    let resolver = def.resolver(db);
-    let parent = def.loc(db).container;
-    let mut ctx = TyLoweringContext::new(
-        db,
-        &resolver,
-        &data.store,
-        def.into(),
-        LifetimeElisionKind::for_const(parent),
-    )
-    .with_type_param_mode(ParamLoweringMode::Variable);
-
-    make_binders(db, &generics, ctx.lower_ty(data.type_ref))
-}
-
-/// Build the declared type of a static.
-fn type_for_static(db: &dyn HirDatabase, def: StaticId) -> Binders<Ty> {
-    let data = db.static_signature(def);
-    let resolver = def.resolver(db);
-    let mut ctx = TyLoweringContext::new(
-        db,
-        &resolver,
-        &data.store,
-        def.into(),
-        LifetimeElisionKind::Elided(static_lifetime()),
-    );
-
-    Binders::empty(Interner, ctx.lower_ty(data.type_ref))
-}
-
 fn fn_sig_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> PolyFnSig {
     let field_tys = db.field_types(def.into());
     let params = field_tys.iter().map(|(_, ty)| ty.skip_binders().clone());
@@ -1407,24 +1361,6 @@ fn fn_sig_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> PolyFnS
     )
 }
 
-/// Build the type of a tuple struct constructor.
-fn type_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> Option<Binders<Ty>> {
-    let struct_data = def.fields(db);
-    match struct_data.shape {
-        FieldsShape::Record => None,
-        FieldsShape::Unit => Some(type_for_adt(db, def.into())),
-        FieldsShape::Tuple => {
-            let generics = generics(db, AdtId::from(def).into());
-            let substs = generics.bound_vars_subst(db, DebruijnIndex::INNERMOST);
-            Some(make_binders(
-                db,
-                &generics,
-                TyKind::FnDef(CallableDefId::StructId(def).to_chalk(db), substs).intern(Interner),
-            ))
-        }
-    }
-}
-
 fn fn_sig_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId) -> PolyFnSig {
     let field_tys = db.field_types(def.into());
     let params = field_tys.iter().map(|(_, ty)| ty.skip_binders().clone());
@@ -1436,28 +1372,6 @@ fn fn_sig_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId)
     )
 }
 
-/// Build the type of a tuple enum variant constructor.
-fn type_for_enum_variant_constructor(
-    db: &dyn HirDatabase,
-    def: EnumVariantId,
-) -> Option<Binders<Ty>> {
-    let e = def.lookup(db).parent;
-    match def.fields(db).shape {
-        FieldsShape::Record => None,
-        FieldsShape::Unit => Some(type_for_adt(db, e.into())),
-        FieldsShape::Tuple => {
-            let generics = generics(db, e.into());
-            let substs = generics.bound_vars_subst(db, DebruijnIndex::INNERMOST);
-            Some(make_binders(
-                db,
-                &generics,
-                TyKind::FnDef(CallableDefId::EnumVariantId(def).to_chalk(db), substs)
-                    .intern(Interner),
-            ))
-        }
-    }
-}
-
 fn type_for_adt(db: &dyn HirDatabase, adt: AdtId) -> Binders<Ty> {
     let generics = generics(db, adt.into());
     let subst = generics.bound_vars_subst(db, DebruijnIndex::INNERMOST);
@@ -1537,17 +1451,6 @@ impl ValueTyDefId {
     }
 }
 
-pub(crate) fn value_ty_query(db: &dyn HirDatabase, def: ValueTyDefId) -> Option<Binders<Ty>> {
-    match def {
-        ValueTyDefId::FunctionId(it) => Some(type_for_fn(db, it)),
-        ValueTyDefId::StructId(it) => type_for_struct_constructor(db, it),
-        ValueTyDefId::UnionId(it) => Some(type_for_adt(db, it.into())),
-        ValueTyDefId::EnumVariantId(it) => type_for_enum_variant_constructor(db, it),
-        ValueTyDefId::ConstId(it) => Some(type_for_const(db, it)),
-        ValueTyDefId::StaticId(it) => Some(type_for_static(db, it)),
-    }
-}
-
 pub(crate) fn impl_self_ty_query(db: &dyn HirDatabase, impl_id: ImplId) -> Binders<Ty> {
     db.impl_self_ty_with_diagnostics(impl_id).0
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
index 6c4212e6ecd43..3f61b9f02621b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
@@ -1099,15 +1099,13 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
             // We currently always use the type from HIR typeck which ignores regions. This
             // should be fine.
             SolverDefId::InternedOpaqueTyId(_) => self.type_of_opaque_hir_typeck(def_id),
-            SolverDefId::FunctionId(id) => self.db.value_ty_ns(id.into()).unwrap(),
+            SolverDefId::FunctionId(id) => self.db.value_ty(id.into()).unwrap(),
             SolverDefId::Ctor(id) => {
                 let id = match id {
                     Ctor::Struct(id) => id.into(),
                     Ctor::Enum(id) => id.into(),
                 };
-                self.db
-                    .value_ty_ns(id)
-                    .expect("`SolverDefId::Ctor` should have a function-like ctor")
+                self.db.value_ty(id).expect("`SolverDefId::Ctor` should have a function-like ctor")
             }
             _ => panic!("Unexpected def_id `{def_id:?}` provided for `type_of`"),
         }
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index a1d9e6d365f83..8b440611e6ccd 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -4872,6 +4872,7 @@ impl<'db> Type<'db> {
         let Some(ty) = db.value_ty(def.into()) else {
             return Type::new(db, def, TyKind::Error.intern(Interner));
         };
+        let interner = DbInterner::new_with(db, None, None);
         let substs = TyBuilder::unknown_subst(
             db,
             match def.into() {
@@ -4882,10 +4883,13 @@ impl<'db> Type<'db> {
                 ValueTyDefId::EnumVariantId(it) => {
                     GenericDefId::AdtId(AdtId::EnumId(it.lookup(db).parent))
                 }
-                ValueTyDefId::StaticId(_) => return Type::new(db, def, ty.skip_binders().clone()),
+                ValueTyDefId::StaticId(_) => {
+                    return Type::new(db, def, ty.skip_binder().to_chalk(interner));
+                }
             },
         );
-        Type::new(db, def, ty.substitute(Interner, &substs))
+        let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);
+        Type::new(db, def, ty.instantiate(interner, args).to_chalk(interner))
     }
 
     pub fn new_slice(ty: Self) -> Self {
diff --git a/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs b/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
index a19183fa1302a..c6b7e84dc20f1 100644
--- a/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
@@ -46,6 +46,10 @@ use hir_ty::{
     from_assoc_type_id,
     lang_items::lang_items_for_bin_op,
     method_resolution,
+    next_solver::{
+        DbInterner,
+        mapping::{ChalkToNextSolver, NextSolverToChalk},
+    },
 };
 use intern::sym;
 use itertools::Itertools;
@@ -372,8 +376,10 @@ impl<'db> SourceAnalyzer<'db> {
     ) -> Option<Callable<'db>> {
         let expr_id = self.expr_id(call.clone().into())?.as_expr()?;
         let (func, substs) = self.infer()?.method_resolution(expr_id)?;
-        let ty = db.value_ty(func.into())?.substitute(Interner, &substs);
-        let ty = Type::new_with_resolver(db, &self.resolver, ty);
+        let interner = DbInterner::new_with(db, None, None);
+        let args: hir_ty::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);
+        let ty = db.value_ty(func.into())?.instantiate(interner, args);
+        let ty = Type::new_with_resolver(db, &self.resolver, ty.to_chalk(interner));
         let mut res = ty.as_callable(db)?;
         res.is_bound_method = true;
         Some(res)
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/syntax_helpers/suggest_name.rs b/src/tools/rust-analyzer/crates/ide-db/src/syntax_helpers/suggest_name.rs
index 995bf72dca163..2e03665765f38 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/syntax_helpers/suggest_name.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/syntax_helpers/suggest_name.rs
@@ -473,7 +473,7 @@ mod tests {
             frange.range,
             "selection is not an expression(yet contained in one)"
         );
-        let name = NameGenerator::default().for_variable(&expr, &sema);
+        let name = salsa::attach(sema.db, || NameGenerator::default().for_variable(&expr, &sema));
         assert_eq!(&name, expected);
     }
 

From bc7986ec791ded521f3f75ab82645b6be0c39508 Mon Sep 17 00:00:00 2001
From: Nikita Popov <npopov@redhat.com>
Date: Thu, 18 Sep 2025 17:09:14 +0200
Subject: [PATCH 1298/1889] Add attributes for #[global_allocator] functions

Emit `#[rustc_allocator]` etc. attributes on the functions generated
by the `#[global_allocator]` macro, which will emit LLVM attributes
like `"alloc-family"`. If the module with the global allocator
participates in LTO, this ensures that the attributes typically
emitted on the allocator declarations are not lost if the
definition is imported.
---
 .../src/global_allocator.rs                   | 16 ++++++--
 .../global-allocator-attributes.rs            | 41 +++++++++++++++++++
 2 files changed, 54 insertions(+), 3 deletions(-)
 create mode 100644 tests/codegen-llvm/global-allocator-attributes.rs

diff --git a/compiler/rustc_builtin_macros/src/global_allocator.rs b/compiler/rustc_builtin_macros/src/global_allocator.rs
index f14b1920722f4..96bece2a368cd 100644
--- a/compiler/rustc_builtin_macros/src/global_allocator.rs
+++ b/compiler/rustc_builtin_macros/src/global_allocator.rs
@@ -85,7 +85,7 @@ impl AllocFnFactory<'_, '_> {
             body,
             define_opaque: None,
         }));
-        let item = self.cx.item(self.span, self.attrs(), kind);
+        let item = self.cx.item(self.span, self.attrs(method), kind);
         self.cx.stmt_item(self.ty_span, item)
     }
 
@@ -100,8 +100,18 @@ impl AllocFnFactory<'_, '_> {
         self.cx.expr_call(self.ty_span, method, args)
     }
 
-    fn attrs(&self) -> AttrVec {
-        thin_vec![self.cx.attr_word(sym::rustc_std_internal_symbol, self.span)]
+    fn attrs(&self, method: &AllocatorMethod) -> AttrVec {
+        let alloc_attr = match method.name {
+            sym::alloc => sym::rustc_allocator,
+            sym::dealloc => sym::rustc_deallocator,
+            sym::realloc => sym::rustc_reallocator,
+            sym::alloc_zeroed => sym::rustc_allocator_zeroed,
+            _ => unreachable!("Unknown allocator method!"),
+        };
+        thin_vec![
+            self.cx.attr_word(sym::rustc_std_internal_symbol, self.span),
+            self.cx.attr_word(alloc_attr, self.span)
+        ]
     }
 
     fn arg_ty(&self, input: &AllocatorMethodInput, args: &mut ThinVec<Param>) -> Box<Expr> {
diff --git a/tests/codegen-llvm/global-allocator-attributes.rs b/tests/codegen-llvm/global-allocator-attributes.rs
new file mode 100644
index 0000000000000..472ca77207500
--- /dev/null
+++ b/tests/codegen-llvm/global-allocator-attributes.rs
@@ -0,0 +1,41 @@
+//@ compile-flags: -C opt-level=3
+#![crate_type = "lib"]
+
+mod foobar {
+    use std::alloc::{GlobalAlloc, Layout};
+
+    struct Allocator;
+
+    unsafe impl GlobalAlloc for Allocator {
+        unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+            // CHECK-LABEL: ; __rustc::__rust_alloc
+            // CHECK-NEXT: ; Function Attrs: {{.*}}allockind("alloc,uninitialized,aligned") allocsize(0){{.*}}
+            // CHECK-NEXT: define{{.*}} noalias{{.*}} ptr @{{.*}}__rust_alloc(i[[SIZE:[0-9]+]] {{.*}}%size, i[[SIZE]] allocalign{{.*}} %align)
+            panic!()
+        }
+
+        unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+            // CHECK-LABEL: ; __rustc::__rust_dealloc
+            // CHECK-NEXT: ; Function Attrs: {{.*}}allockind("free"){{.*}}
+            // CHECK-NEXT: define{{.*}} void @{{.*}}__rust_dealloc(ptr allocptr{{.*}} %ptr, i[[SIZE]] {{.*}} %size, i[[SIZE]] {{.*}} %align)
+            panic!()
+        }
+
+        unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+            // CHECK-LABEL: ; __rustc::__rust_realloc
+            // CHECK-NEXT: ; Function Attrs: {{.*}}allockind("realloc,aligned") allocsize(3){{.*}}
+            // CHECK-NEXT: define{{.*}} noalias{{.*}} ptr @{{.*}}__rust_realloc(ptr allocptr{{.*}} %ptr, i[[SIZE]] {{.*}} %size, i[[SIZE]] allocalign{{.*}} %align, i[[SIZE]] {{.*}} %new_size)
+            panic!()
+        }
+
+        unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
+            // CHECK-LABEL: ; __rustc::__rust_alloc_zeroed
+            // CHECK-NEXT: ; Function Attrs: {{.*}}allockind("alloc,zeroed,aligned") allocsize(0){{.*}}
+            // CHECK-NEXT: define{{.*}} noalias{{.*}} ptr @{{.*}}__rust_alloc_zeroed(i[[SIZE]] {{.*}} %size, i[[SIZE]] allocalign{{.*}} %align)
+            panic!()
+        }
+    }
+
+    #[global_allocator]
+    static GLOBAL: Allocator = Allocator;
+}

From a025cacc600fe1848db29cdaf199ac2d33f83181 Mon Sep 17 00:00:00 2001
From: Vincent Esche <regexident@gmail.com>
Date: Wed, 17 Sep 2025 21:19:53 +0200
Subject: [PATCH 1299/1889] Expose iterators over an inference result's types

(This re-introduces a reduced access to a couple of previously public fields on `InferenceResult`)
---
 .../rust-analyzer/crates/hir-ty/src/infer.rs  | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
index 3ece62ec35b63..b5e9aece364c0 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
@@ -632,6 +632,26 @@ impl InferenceResult {
     pub fn binding_mode(&self, id: PatId) -> Option<BindingMode> {
         self.binding_modes.get(id).copied()
     }
+
+    // This method is consumed by external tools to run rust-analyzer as a library. Don't remove, please.
+    pub fn expression_types(&self) -> impl Iterator<Item = (ExprId, &Ty)> {
+        self.type_of_expr.iter()
+    }
+
+    // This method is consumed by external tools to run rust-analyzer as a library. Don't remove, please.
+    pub fn pattern_types(&self) -> impl Iterator<Item = (PatId, &Ty)> {
+        self.type_of_pat.iter()
+    }
+
+    // This method is consumed by external tools to run rust-analyzer as a library. Don't remove, please.
+    pub fn binding_types(&self) -> impl Iterator<Item = (BindingId, &Ty)> {
+        self.type_of_binding.iter()
+    }
+
+    // This method is consumed by external tools to run rust-analyzer as a library. Don't remove, please.
+    pub fn return_position_impl_trait_types(&self) -> impl Iterator<Item = (ImplTraitIdx, &Ty)> {
+        self.type_of_rpit.iter()
+    }
 }
 
 impl Index<ExprId> for InferenceResult {

From ffca2f0a1e5366221c3b81925089e4fa14cd3a69 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Tue, 23 Sep 2025 11:39:40 +0200
Subject: [PATCH 1300/1889] Make it possible to `x install` Cranelift and LLVM
 bitcode linker

---
 src/bootstrap/src/core/builder/mod.rs   | 2 ++
 src/bootstrap/src/core/builder/tests.rs | 3 +++
 2 files changed, 5 insertions(+)

diff --git a/src/bootstrap/src/core/builder/mod.rs b/src/bootstrap/src/core/builder/mod.rs
index 8226b4325b6b8..10587b02c7166 100644
--- a/src/bootstrap/src/core/builder/mod.rs
+++ b/src/bootstrap/src/core/builder/mod.rs
@@ -1221,6 +1221,8 @@ impl<'a> Builder<'a> {
                 install::Miri,
                 install::LlvmTools,
                 install::Src,
+                install::RustcCodegenCranelift,
+                install::LlvmBitcodeLinker
             ),
             Kind::Run => describe!(
                 run::BuildManifest,
diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index 229adf714598b..87bea431a0588 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -2911,6 +2911,9 @@ mod snapshot {
         [build] rustc 1 <host> -> cargo-miri 2 <host>
         [dist] rustc 1 <host> -> miri 2 <host>
         [dist] src <>
+        [build] rustc 1 <host> -> rustc_codegen_cranelift 2 <host>
+        [dist] rustc 1 <host> -> rustc_codegen_cranelift 2 <host>
+        [build] rustc 1 <host> -> LlvmBitcodeLinker 2 <host>
         ");
     }
 

From 739e89980f2c5602851c9271fd61f7381007e87a Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Wed, 11 Jun 2025 11:32:57 +0000
Subject: [PATCH 1301/1889] Add proper name mangling for pattern types

---
 compiler/rustc_symbol_mangling/src/v0.rs   | 14 +++++------
 src/doc/rustc/src/symbol-mangling/v0.md    | 28 ++++++++++++++++++++++
 tests/codegen-llvm/pattern_type_symbols.rs |  4 ++--
 3 files changed, 36 insertions(+), 10 deletions(-)

diff --git a/compiler/rustc_symbol_mangling/src/v0.rs b/compiler/rustc_symbol_mangling/src/v0.rs
index 9fa7e2f100393..d24924b424a5b 100644
--- a/compiler/rustc_symbol_mangling/src/v0.rs
+++ b/compiler/rustc_symbol_mangling/src/v0.rs
@@ -262,15 +262,16 @@ impl<'tcx> V0SymbolMangler<'tcx> {
     fn print_pat(&mut self, pat: ty::Pattern<'tcx>) -> Result<(), std::fmt::Error> {
         Ok(match *pat {
             ty::PatternKind::Range { start, end } => {
-                let consts = [start, end];
-                for ct in consts {
-                    Ty::new_array_with_const_len(self.tcx, self.tcx.types.unit, ct).print(self)?;
-                }
+                self.push("R");
+                self.print_const(start)?;
+                self.print_const(end)?;
             }
             ty::PatternKind::Or(patterns) => {
+                self.push("O");
                 for pat in patterns {
                     self.print_pat(pat)?;
                 }
+                self.push("E");
             }
         })
     }
@@ -498,12 +499,9 @@ impl<'tcx> Printer<'tcx> for V0SymbolMangler<'tcx> {
             }
 
             ty::Pat(ty, pat) => {
-                // HACK: Represent as tuple until we have something better.
-                // HACK: constants are used in arrays, even if the types don't match.
-                self.push("T");
+                self.push("W");
                 ty.print(self)?;
                 self.print_pat(pat)?;
-                self.push("E");
             }
 
             ty::Array(ty, len) => {
diff --git a/src/doc/rustc/src/symbol-mangling/v0.md b/src/doc/rustc/src/symbol-mangling/v0.md
index 109942518fc93..2bcc453a53265 100644
--- a/src/doc/rustc/src/symbol-mangling/v0.md
+++ b/src/doc/rustc/src/symbol-mangling/v0.md
@@ -710,6 +710,7 @@ A *placeholder* may occur in circumstances where a type or const value is not re
 [mut-ptr-type]: #mut-ptr-type
 [fn-type]: #fn-type
 [dyn-trait-type]: #dyn-trait-type
+[pattern-type]: #pattern-type
 
 > type → \
 > &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; *[basic-type]* \
@@ -722,6 +723,7 @@ A *placeholder* may occur in circumstances where a type or const value is not re
 > &nbsp;&nbsp; | *[mut-ptr-type]* \
 > &nbsp;&nbsp; | *[fn-type]* \
 > &nbsp;&nbsp; | *[dyn-trait-type]* \
+> &nbsp;&nbsp; | *[pattern-type]* \
 > &nbsp;&nbsp; | *[path]* \
 > &nbsp;&nbsp; | *[backref]*
 
@@ -830,6 +832,23 @@ Remaining primitives are encoded as a crate production, e.g. `C4f128`.
 [fn-sig]: #fn-sig
 [abi]: #abi
 
+* `W` — A [pattern-type][pattern-tpye] `u32 is 0..100`.
+  > <span id="pattern-type">pattern-type</span> → `W` *[pattern-kind]*
+  >
+  > <span id="pattern-kind">pattern-kind</span> → \
+  > &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; *[range-pattern-kind]* \
+  > &nbsp;&nbsp; *[or-pattern-kind]*
+  >
+  > <span id="range-pattern-kind">range-pattern-kind</span> → `R` *[const]* *[const]*
+  >
+  > <span id="or-pattern-kind">or-pattern-kind</span> → `O` *[pattern-kind]* `E`
+
+  While or patterns can be nested in theory, in practice this does not happen and they are instead flattened.
+
+  Range patterns have a start and end constant that are both included in the range.
+  The end must be larger than the start (there can be no wraparound). To emulate wraparound,
+  you need to use an or pattern of the two ranges to the upper limit and from the lower limit.
+
 * `D` — A [trait object][reference-trait-object] `dyn Trait<Assoc=X> + Send + 'a`.
 
   > <span id="dyn-trait-type">dyn-trait-type</span> → `D` *[dyn-bounds]* *[lifetime]*
@@ -1139,6 +1158,7 @@ The following is a summary of all of the productions of the symbol grammar.
 > &nbsp;&nbsp; | *[mut-ptr-type]* \
 > &nbsp;&nbsp; | *[fn-type]* \
 > &nbsp;&nbsp; | *[dyn-trait-type]* \
+> &nbsp;&nbsp; | *[pattern-type]* \
 > &nbsp;&nbsp; | *[path]* \
 > &nbsp;&nbsp; | *[backref]*
 >
@@ -1152,6 +1172,14 @@ The following is a summary of all of the productions of the symbol grammar.
 > [mut-ptr-type] → `O` *[type]* \
 > [fn-type] → `F` *[fn-sig]* \
 > [dyn-trait-type] → `D` *[dyn-bounds]* *[lifetime]*
+> [pattern-type] → `W` *[pattern-kind]*
+>
+> [pattern-kind] → \
+> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; *[range-pattern-kind]* \
+> &nbsp;&nbsp; *[or-pattern-kind]*
+>
+> [range-pattern-kind] -> `R` *[const]* *[const]* \
+> [or-pattern-kind] -> `O` *[pattern-kind]* `E` \
 >
 > [namespace] → *[lower]* | *[upper]*
 >
diff --git a/tests/codegen-llvm/pattern_type_symbols.rs b/tests/codegen-llvm/pattern_type_symbols.rs
index e86a9ef27de1b..a90262ff12d21 100644
--- a/tests/codegen-llvm/pattern_type_symbols.rs
+++ b/tests/codegen-llvm/pattern_type_symbols.rs
@@ -16,7 +16,7 @@ pub fn bar() {
     // CHECK: call pattern_type_symbols::foo::<u32>
     // CHECK: call void @_RINvC[[CRATE_IDENT:[a-zA-Z0-9]{12}]]_20pattern_type_symbols3foomEB2_
     foo::<u32>();
-    // CHECK: call pattern_type_symbols::foo::<(u32, [(); 0], [(); 999999999])>
-    // CHECK: call void @_RINvC[[CRATE_IDENT]]_20pattern_type_symbols3fooTmAum0_Aum3b9ac9ff_EEB2_
+    // CHECK: call pattern_type_symbols::foo::<u32 is 0..=999999999>
+    // CHECK: call void @_RINvC[[CRATE_IDENT]]_20pattern_type_symbols3fooWmRm0_m3b9ac9ff_EB2_
     foo::<NanoU32>();
 }

From 526d794d807ca0e54d3411fed4c508b1c6f0f0e5 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 20 Aug 2025 01:34:05 +0200
Subject: [PATCH 1302/1889] create let-chain

---
 clippy_lints/src/non_canonical_impls.rs | 222 +++++++++++-------------
 1 file changed, 106 insertions(+), 116 deletions(-)

diff --git a/clippy_lints/src/non_canonical_impls.rs b/clippy_lints/src/non_canonical_impls.rs
index ba67dc62abbda..c479f40707e98 100644
--- a/clippy_lints/src/non_canonical_impls.rs
+++ b/clippy_lints/src/non_canonical_impls.rs
@@ -114,136 +114,126 @@ declare_lint_pass!(NonCanonicalImpls => [NON_CANONICAL_CLONE_IMPL, NON_CANONICAL
 impl LateLintPass<'_> for NonCanonicalImpls {
     #[expect(clippy::too_many_lines)]
     fn check_impl_item<'tcx>(&mut self, cx: &LateContext<'tcx>, impl_item: &ImplItem<'tcx>) {
-        let Node::Item(item) = cx.tcx.parent_hir_node(impl_item.hir_id()) else {
-            return;
-        };
-        let Some(trait_impl) = cx.tcx.impl_trait_ref(item.owner_id).map(EarlyBinder::skip_binder) else {
-            return;
-        };
-        if cx.tcx.is_automatically_derived(item.owner_id.to_def_id()) {
-            return;
-        }
-        let ImplItemKind::Fn(_, impl_item_id) = cx.tcx.hir_impl_item(impl_item.impl_item_id()).kind else {
-            return;
-        };
-        let body = cx.tcx.hir_body(impl_item_id);
-        let ExprKind::Block(block, ..) = body.value.kind else {
-            return;
-        };
-        if block.span.in_external_macro(cx.sess().source_map()) || is_from_proc_macro(cx, impl_item) {
-            return;
-        }
-
-        let trait_name = cx.tcx.get_diagnostic_name(trait_impl.def_id);
-        if trait_name == Some(sym::Clone)
-            && let Some(copy_def_id) = cx.tcx.get_diagnostic_item(sym::Copy)
-            && implements_trait(cx, trait_impl.self_ty(), copy_def_id, &[])
+        if let Node::Item(item) = cx.tcx.parent_hir_node(impl_item.hir_id())
+            && let Some(trait_impl) = cx.tcx.impl_trait_ref(item.owner_id).map(EarlyBinder::skip_binder)
+            && !cx.tcx.is_automatically_derived(item.owner_id.to_def_id())
+            && let ImplItemKind::Fn(_, impl_item_id) = cx.tcx.hir_impl_item(impl_item.impl_item_id()).kind
+            && let body = cx.tcx.hir_body(impl_item_id)
+            && let ExprKind::Block(block, ..) = body.value.kind
+            && !block.span.in_external_macro(cx.sess().source_map())
+            && !is_from_proc_macro(cx, impl_item)
         {
-            if impl_item.ident.name == sym::clone {
-                if block.stmts.is_empty()
-                    && let Some(expr) = block.expr
-                    && let ExprKind::Unary(UnOp::Deref, deref) = expr.kind
-                    && let ExprKind::Path(qpath) = deref.kind
-                    && last_path_segment(&qpath).ident.name == kw::SelfLower
-                {
-                } else {
+            let trait_name = cx.tcx.get_diagnostic_name(trait_impl.def_id);
+            if trait_name == Some(sym::Clone)
+                && let Some(copy_def_id) = cx.tcx.get_diagnostic_item(sym::Copy)
+                && implements_trait(cx, trait_impl.self_ty(), copy_def_id, &[])
+            {
+                if impl_item.ident.name == sym::clone {
+                    if block.stmts.is_empty()
+                        && let Some(expr) = block.expr
+                        && let ExprKind::Unary(UnOp::Deref, deref) = expr.kind
+                        && let ExprKind::Path(qpath) = deref.kind
+                        && last_path_segment(&qpath).ident.name == kw::SelfLower
+                    {
+                    } else {
+                        span_lint_and_sugg(
+                            cx,
+                            NON_CANONICAL_CLONE_IMPL,
+                            block.span,
+                            "non-canonical implementation of `clone` on a `Copy` type",
+                            "change this to",
+                            "{ *self }".to_owned(),
+                            Applicability::MaybeIncorrect,
+                        );
+
+                        return;
+                    }
+                }
+
+                if impl_item.ident.name == sym::clone_from {
                     span_lint_and_sugg(
                         cx,
                         NON_CANONICAL_CLONE_IMPL,
-                        block.span,
-                        "non-canonical implementation of `clone` on a `Copy` type",
-                        "change this to",
-                        "{ *self }".to_owned(),
+                        impl_item.span,
+                        "unnecessary implementation of `clone_from` on a `Copy` type",
+                        "remove it",
+                        String::new(),
                         Applicability::MaybeIncorrect,
                     );
+                }
+            } else if trait_name == Some(sym::PartialOrd)
+                && impl_item.ident.name == sym::partial_cmp
+                && let Some(ord_def_id) = cx.tcx.get_diagnostic_item(sym::Ord)
+                && implements_trait(cx, trait_impl.self_ty(), ord_def_id, &[])
+            {
+                // If the `cmp` call likely needs to be fully qualified in the suggestion
+                // (like `std::cmp::Ord::cmp`). It's unfortunate we must put this here but we can't
+                // access `cmp_expr` in the suggestion without major changes, as we lint in `else`.
+                let mut needs_fully_qualified = false;
 
+                if block.stmts.is_empty()
+                    && let Some(expr) = block.expr
+                    && expr_is_cmp(cx, expr, impl_item, &mut needs_fully_qualified)
+                {
+                    return;
+                }
+                // Fix #12683, allow [`needless_return`] here
+                else if block.expr.is_none()
+                    && let Some(stmt) = block.stmts.first()
+                    && let rustc_hir::StmtKind::Semi(Expr {
+                        kind: ExprKind::Ret(Some(ret)),
+                        ..
+                    }) = stmt.kind
+                    && expr_is_cmp(cx, ret, impl_item, &mut needs_fully_qualified)
+                {
+                    return;
+                }
+                // If `Self` and `Rhs` are not the same type, bail. This makes creating a valid
+                // suggestion tons more complex.
+                else if let [lhs, rhs, ..] = trait_impl.args.as_slice()
+                    && lhs != rhs
+                {
                     return;
                 }
-            }
 
-            if impl_item.ident.name == sym::clone_from {
-                span_lint_and_sugg(
+                span_lint_and_then(
                     cx,
-                    NON_CANONICAL_CLONE_IMPL,
-                    impl_item.span,
-                    "unnecessary implementation of `clone_from` on a `Copy` type",
-                    "remove it",
-                    String::new(),
-                    Applicability::MaybeIncorrect,
-                );
-            }
-        } else if trait_name == Some(sym::PartialOrd)
-            && impl_item.ident.name == sym::partial_cmp
-            && let Some(ord_def_id) = cx.tcx.get_diagnostic_item(sym::Ord)
-            && implements_trait(cx, trait_impl.self_ty(), ord_def_id, &[])
-        {
-            // If the `cmp` call likely needs to be fully qualified in the suggestion
-            // (like `std::cmp::Ord::cmp`). It's unfortunate we must put this here but we can't
-            // access `cmp_expr` in the suggestion without major changes, as we lint in `else`.
-            let mut needs_fully_qualified = false;
-
-            if block.stmts.is_empty()
-                && let Some(expr) = block.expr
-                && expr_is_cmp(cx, expr, impl_item, &mut needs_fully_qualified)
-            {
-                return;
-            }
-            // Fix #12683, allow [`needless_return`] here
-            else if block.expr.is_none()
-                && let Some(stmt) = block.stmts.first()
-                && let rustc_hir::StmtKind::Semi(Expr {
-                    kind: ExprKind::Ret(Some(ret)),
-                    ..
-                }) = stmt.kind
-                && expr_is_cmp(cx, ret, impl_item, &mut needs_fully_qualified)
-            {
-                return;
-            }
-            // If `Self` and `Rhs` are not the same type, bail. This makes creating a valid
-            // suggestion tons more complex.
-            else if let [lhs, rhs, ..] = trait_impl.args.as_slice()
-                && lhs != rhs
-            {
-                return;
-            }
-
-            span_lint_and_then(
-                cx,
-                NON_CANONICAL_PARTIAL_ORD_IMPL,
-                item.span,
-                "non-canonical implementation of `partial_cmp` on an `Ord` type",
-                |diag| {
-                    let [_, other] = body.params else {
-                        return;
-                    };
-                    let Some(std_or_core) = std_or_core(cx) else {
-                        return;
-                    };
+                    NON_CANONICAL_PARTIAL_ORD_IMPL,
+                    item.span,
+                    "non-canonical implementation of `partial_cmp` on an `Ord` type",
+                    |diag| {
+                        let [_, other] = body.params else {
+                            return;
+                        };
+                        let Some(std_or_core) = std_or_core(cx) else {
+                            return;
+                        };
 
-                    let suggs = match (other.pat.simple_ident(), needs_fully_qualified) {
-                        (Some(other_ident), true) => vec![(
-                            block.span,
-                            format!("{{ Some({std_or_core}::cmp::Ord::cmp(self, {})) }}", other_ident.name),
-                        )],
-                        (Some(other_ident), false) => {
-                            vec![(block.span, format!("{{ Some(self.cmp({})) }}", other_ident.name))]
-                        },
-                        (None, true) => vec![
-                            (
+                        let suggs = match (other.pat.simple_ident(), needs_fully_qualified) {
+                            (Some(other_ident), true) => vec![(
                                 block.span,
-                                format!("{{ Some({std_or_core}::cmp::Ord::cmp(self, other)) }}"),
-                            ),
-                            (other.pat.span, "other".to_owned()),
-                        ],
-                        (None, false) => vec![
-                            (block.span, "{ Some(self.cmp(other)) }".to_owned()),
-                            (other.pat.span, "other".to_owned()),
-                        ],
-                    };
+                                format!("{{ Some({std_or_core}::cmp::Ord::cmp(self, {})) }}", other_ident.name),
+                            )],
+                            (Some(other_ident), false) => {
+                                vec![(block.span, format!("{{ Some(self.cmp({})) }}", other_ident.name))]
+                            },
+                            (None, true) => vec![
+                                (
+                                    block.span,
+                                    format!("{{ Some({std_or_core}::cmp::Ord::cmp(self, other)) }}"),
+                                ),
+                                (other.pat.span, "other".to_owned()),
+                            ],
+                            (None, false) => vec![
+                                (block.span, "{ Some(self.cmp(other)) }".to_owned()),
+                                (other.pat.span, "other".to_owned()),
+                            ],
+                        };
 
-                    diag.multipart_suggestion("change this to", suggs, Applicability::Unspecified);
-                },
-            );
+                        diag.multipart_suggestion("change this to", suggs, Applicability::Unspecified);
+                    },
+                );
+            }
         }
     }
 }

From 54e28471d707c86476f7519571eea74c0016d3c8 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 20 Aug 2025 01:31:18 +0200
Subject: [PATCH 1303/1889] extract helper functions

too many lines no more!
---
 clippy_lints/src/non_canonical_impls.rs | 214 +++++++++++++-----------
 1 file changed, 113 insertions(+), 101 deletions(-)

diff --git a/clippy_lints/src/non_canonical_impls.rs b/clippy_lints/src/non_canonical_impls.rs
index c479f40707e98..5f2c388ff678f 100644
--- a/clippy_lints/src/non_canonical_impls.rs
+++ b/clippy_lints/src/non_canonical_impls.rs
@@ -5,9 +5,9 @@ use clippy_utils::{
 };
 use rustc_errors::Applicability;
 use rustc_hir::def_id::LocalDefId;
-use rustc_hir::{Expr, ExprKind, ImplItem, ImplItemKind, LangItem, Node, UnOp};
+use rustc_hir::{Block, Body, Expr, ExprKind, ImplItem, ImplItemKind, Item, LangItem, Node, UnOp};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::ty::EarlyBinder;
+use rustc_middle::ty::{EarlyBinder, TraitRef};
 use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 use rustc_span::symbol::kw;
@@ -112,7 +112,6 @@ declare_clippy_lint! {
 declare_lint_pass!(NonCanonicalImpls => [NON_CANONICAL_CLONE_IMPL, NON_CANONICAL_PARTIAL_ORD_IMPL]);
 
 impl LateLintPass<'_> for NonCanonicalImpls {
-    #[expect(clippy::too_many_lines)]
     fn check_impl_item<'tcx>(&mut self, cx: &LateContext<'tcx>, impl_item: &ImplItem<'tcx>) {
         if let Node::Item(item) = cx.tcx.parent_hir_node(impl_item.hir_id())
             && let Some(trait_impl) = cx.tcx.impl_trait_ref(item.owner_id).map(EarlyBinder::skip_binder)
@@ -128,114 +127,127 @@ impl LateLintPass<'_> for NonCanonicalImpls {
                 && let Some(copy_def_id) = cx.tcx.get_diagnostic_item(sym::Copy)
                 && implements_trait(cx, trait_impl.self_ty(), copy_def_id, &[])
             {
-                if impl_item.ident.name == sym::clone {
-                    if block.stmts.is_empty()
-                        && let Some(expr) = block.expr
-                        && let ExprKind::Unary(UnOp::Deref, deref) = expr.kind
-                        && let ExprKind::Path(qpath) = deref.kind
-                        && last_path_segment(&qpath).ident.name == kw::SelfLower
-                    {
-                    } else {
-                        span_lint_and_sugg(
-                            cx,
-                            NON_CANONICAL_CLONE_IMPL,
-                            block.span,
-                            "non-canonical implementation of `clone` on a `Copy` type",
-                            "change this to",
-                            "{ *self }".to_owned(),
-                            Applicability::MaybeIncorrect,
-                        );
-
-                        return;
-                    }
-                }
-
-                if impl_item.ident.name == sym::clone_from {
-                    span_lint_and_sugg(
-                        cx,
-                        NON_CANONICAL_CLONE_IMPL,
-                        impl_item.span,
-                        "unnecessary implementation of `clone_from` on a `Copy` type",
-                        "remove it",
-                        String::new(),
-                        Applicability::MaybeIncorrect,
-                    );
-                }
+                check_clone_on_copy(cx, impl_item, block);
             } else if trait_name == Some(sym::PartialOrd)
                 && impl_item.ident.name == sym::partial_cmp
                 && let Some(ord_def_id) = cx.tcx.get_diagnostic_item(sym::Ord)
                 && implements_trait(cx, trait_impl.self_ty(), ord_def_id, &[])
             {
-                // If the `cmp` call likely needs to be fully qualified in the suggestion
-                // (like `std::cmp::Ord::cmp`). It's unfortunate we must put this here but we can't
-                // access `cmp_expr` in the suggestion without major changes, as we lint in `else`.
-                let mut needs_fully_qualified = false;
+                check_partial_ord_on_ord(cx, impl_item, item, &trait_impl, body, block);
+            }
+        }
+    }
+}
 
-                if block.stmts.is_empty()
-                    && let Some(expr) = block.expr
-                    && expr_is_cmp(cx, expr, impl_item, &mut needs_fully_qualified)
-                {
-                    return;
-                }
-                // Fix #12683, allow [`needless_return`] here
-                else if block.expr.is_none()
-                    && let Some(stmt) = block.stmts.first()
-                    && let rustc_hir::StmtKind::Semi(Expr {
-                        kind: ExprKind::Ret(Some(ret)),
-                        ..
-                    }) = stmt.kind
-                    && expr_is_cmp(cx, ret, impl_item, &mut needs_fully_qualified)
-                {
-                    return;
-                }
-                // If `Self` and `Rhs` are not the same type, bail. This makes creating a valid
-                // suggestion tons more complex.
-                else if let [lhs, rhs, ..] = trait_impl.args.as_slice()
-                    && lhs != rhs
-                {
-                    return;
-                }
+fn check_clone_on_copy(cx: &LateContext<'_>, impl_item: &ImplItem<'_>, block: &Block<'_>) {
+    if impl_item.ident.name == sym::clone {
+        if block.stmts.is_empty()
+            && let Some(expr) = block.expr
+            && let ExprKind::Unary(UnOp::Deref, deref) = expr.kind
+            && let ExprKind::Path(qpath) = deref.kind
+            && last_path_segment(&qpath).ident.name == kw::SelfLower
+        {
+        } else {
+            span_lint_and_sugg(
+                cx,
+                NON_CANONICAL_CLONE_IMPL,
+                block.span,
+                "non-canonical implementation of `clone` on a `Copy` type",
+                "change this to",
+                "{ *self }".to_owned(),
+                Applicability::MaybeIncorrect,
+            );
+        }
+    }
 
-                span_lint_and_then(
-                    cx,
-                    NON_CANONICAL_PARTIAL_ORD_IMPL,
-                    item.span,
-                    "non-canonical implementation of `partial_cmp` on an `Ord` type",
-                    |diag| {
-                        let [_, other] = body.params else {
-                            return;
-                        };
-                        let Some(std_or_core) = std_or_core(cx) else {
-                            return;
-                        };
+    if impl_item.ident.name == sym::clone_from {
+        span_lint_and_sugg(
+            cx,
+            NON_CANONICAL_CLONE_IMPL,
+            impl_item.span,
+            "unnecessary implementation of `clone_from` on a `Copy` type",
+            "remove it",
+            String::new(),
+            Applicability::MaybeIncorrect,
+        );
+    }
+}
 
-                        let suggs = match (other.pat.simple_ident(), needs_fully_qualified) {
-                            (Some(other_ident), true) => vec![(
-                                block.span,
-                                format!("{{ Some({std_or_core}::cmp::Ord::cmp(self, {})) }}", other_ident.name),
-                            )],
-                            (Some(other_ident), false) => {
-                                vec![(block.span, format!("{{ Some(self.cmp({})) }}", other_ident.name))]
-                            },
-                            (None, true) => vec![
-                                (
-                                    block.span,
-                                    format!("{{ Some({std_or_core}::cmp::Ord::cmp(self, other)) }}"),
-                                ),
-                                (other.pat.span, "other".to_owned()),
-                            ],
-                            (None, false) => vec![
-                                (block.span, "{ Some(self.cmp(other)) }".to_owned()),
-                                (other.pat.span, "other".to_owned()),
-                            ],
-                        };
+fn check_partial_ord_on_ord<'tcx>(
+    cx: &LateContext<'tcx>,
+    impl_item: &ImplItem<'_>,
+    item: &Item<'_>,
+    trait_impl: &TraitRef<'_>,
+    body: &Body<'_>,
+    block: &Block<'tcx>,
+) {
+    // If the `cmp` call likely needs to be fully qualified in the suggestion
+    // (like `std::cmp::Ord::cmp`). It's unfortunate we must put this here but we can't
+    // access `cmp_expr` in the suggestion without major changes, as we lint in `else`.
 
-                        diag.multipart_suggestion("change this to", suggs, Applicability::Unspecified);
-                    },
-                );
-            }
-        }
+    let mut needs_fully_qualified = false;
+    if block.stmts.is_empty()
+        && let Some(expr) = block.expr
+        && expr_is_cmp(cx, expr, impl_item, &mut needs_fully_qualified)
+    {
+        return;
+    }
+    // Fix #12683, allow [`needless_return`] here
+    else if block.expr.is_none()
+        && let Some(stmt) = block.stmts.first()
+        && let rustc_hir::StmtKind::Semi(Expr {
+            kind: ExprKind::Ret(Some(ret)),
+            ..
+        }) = stmt.kind
+        && expr_is_cmp(cx, ret, impl_item, &mut needs_fully_qualified)
+    {
+        return;
+    }
+    // If `Self` and `Rhs` are not the same type, bail. This makes creating a valid
+    // suggestion tons more complex.
+    else if let [lhs, rhs, ..] = trait_impl.args.as_slice()
+        && lhs != rhs
+    {
+        return;
     }
+
+    span_lint_and_then(
+        cx,
+        NON_CANONICAL_PARTIAL_ORD_IMPL,
+        item.span,
+        "non-canonical implementation of `partial_cmp` on an `Ord` type",
+        |diag| {
+            let [_, other] = body.params else {
+                return;
+            };
+            let Some(std_or_core) = std_or_core(cx) else {
+                return;
+            };
+
+            let suggs = match (other.pat.simple_ident(), needs_fully_qualified) {
+                (Some(other_ident), true) => vec![(
+                    block.span,
+                    format!("{{ Some({std_or_core}::cmp::Ord::cmp(self, {})) }}", other_ident.name),
+                )],
+                (Some(other_ident), false) => {
+                    vec![(block.span, format!("{{ Some(self.cmp({})) }}", other_ident.name))]
+                },
+                (None, true) => vec![
+                    (
+                        block.span,
+                        format!("{{ Some({std_or_core}::cmp::Ord::cmp(self, other)) }}"),
+                    ),
+                    (other.pat.span, "other".to_owned()),
+                ],
+                (None, false) => vec![
+                    (block.span, "{ Some(self.cmp(other)) }".to_owned()),
+                    (other.pat.span, "other".to_owned()),
+                ],
+            };
+
+            diag.multipart_suggestion("change this to", suggs, Applicability::Unspecified);
+        },
+    );
 }
 
 /// Return true if `expr_kind` is a `cmp` call.

From 34d9a2a084b42533d508cbfe3207b91b2f014eba Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 20 Aug 2025 23:17:32 +0200
Subject: [PATCH 1304/1889] use `match`

imo it's a bit more clear than checking for the same thing (`expr.kind`)
in multiple branches
---
 clippy_lints/src/non_canonical_impls.rs | 37 +++++++++++++------------
 1 file changed, 19 insertions(+), 18 deletions(-)

diff --git a/clippy_lints/src/non_canonical_impls.rs b/clippy_lints/src/non_canonical_impls.rs
index 5f2c388ff678f..7dd5157340305 100644
--- a/clippy_lints/src/non_canonical_impls.rs
+++ b/clippy_lints/src/non_canonical_impls.rs
@@ -258,26 +258,27 @@ fn expr_is_cmp<'tcx>(
     needs_fully_qualified: &mut bool,
 ) -> bool {
     let impl_item_did = impl_item.owner_id.def_id;
-    if let ExprKind::Call(
-        Expr {
-            kind: ExprKind::Path(some_path),
-            hir_id: some_hir_id,
-            ..
-        },
-        [cmp_expr],
-    ) = expr.kind
-    {
-        is_res_lang_ctor(cx, cx.qpath_res(some_path, *some_hir_id), LangItem::OptionSome)
+    match expr.kind {
+        ExprKind::Call(
+            Expr {
+                kind: ExprKind::Path(some_path),
+                hir_id: some_hir_id,
+                ..
+            },
+            [cmp_expr],
+        ) => {
+            is_res_lang_ctor(cx, cx.qpath_res(some_path, *some_hir_id), LangItem::OptionSome)
             // Fix #11178, allow `Self::cmp(self, ..)` too
             && self_cmp_call(cx, cmp_expr, impl_item_did, needs_fully_qualified)
-    } else if let ExprKind::MethodCall(_, recv, [], _) = expr.kind {
-        cx.tcx
-            .typeck(impl_item_did)
-            .type_dependent_def_id(expr.hir_id)
-            .is_some_and(|def_id| is_diag_trait_item(cx, def_id, sym::Into))
-            && self_cmp_call(cx, recv, impl_item_did, needs_fully_qualified)
-    } else {
-        false
+        },
+        ExprKind::MethodCall(_, recv, [], _) => {
+            cx.tcx
+                .typeck(impl_item_did)
+                .type_dependent_def_id(expr.hir_id)
+                .is_some_and(|def_id| is_diag_trait_item(cx, def_id, sym::Into))
+                && self_cmp_call(cx, recv, impl_item_did, needs_fully_qualified)
+        },
+        _ => false,
     }
 }
 

From 21a5948ca17787961c6dcae8964086ddadb4f1b8 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sun, 21 Sep 2025 22:04:25 +0200
Subject: [PATCH 1305/1889] incorporate review feedback

---
 clippy_lints/src/non_canonical_impls.rs | 30 ++++++++++++++-----------
 1 file changed, 17 insertions(+), 13 deletions(-)

diff --git a/clippy_lints/src/non_canonical_impls.rs b/clippy_lints/src/non_canonical_impls.rs
index 7dd5157340305..e531f797272d2 100644
--- a/clippy_lints/src/non_canonical_impls.rs
+++ b/clippy_lints/src/non_canonical_impls.rs
@@ -113,16 +113,18 @@ declare_lint_pass!(NonCanonicalImpls => [NON_CANONICAL_CLONE_IMPL, NON_CANONICAL
 
 impl LateLintPass<'_> for NonCanonicalImpls {
     fn check_impl_item<'tcx>(&mut self, cx: &LateContext<'tcx>, impl_item: &ImplItem<'tcx>) {
-        if let Node::Item(item) = cx.tcx.parent_hir_node(impl_item.hir_id())
+        if let ImplItemKind::Fn(_, impl_item_id) = impl_item.kind
+            && let Node::Item(item) = cx.tcx.parent_hir_node(impl_item.hir_id())
             && let Some(trait_impl) = cx.tcx.impl_trait_ref(item.owner_id).map(EarlyBinder::skip_binder)
+            && let trait_name = cx.tcx.get_diagnostic_name(trait_impl.def_id)
+            // NOTE: check this early to avoid expensive checks that come after this one
+            && matches!(trait_name, Some(sym::Clone | sym::PartialOrd))
             && !cx.tcx.is_automatically_derived(item.owner_id.to_def_id())
-            && let ImplItemKind::Fn(_, impl_item_id) = cx.tcx.hir_impl_item(impl_item.impl_item_id()).kind
             && let body = cx.tcx.hir_body(impl_item_id)
             && let ExprKind::Block(block, ..) = body.value.kind
             && !block.span.in_external_macro(cx.sess().source_map())
             && !is_from_proc_macro(cx, impl_item)
         {
-            let trait_name = cx.tcx.get_diagnostic_name(trait_impl.def_id);
             if trait_name == Some(sym::Clone)
                 && let Some(copy_def_id) = cx.tcx.get_diagnostic_item(sym::Copy)
                 && implements_trait(cx, trait_impl.self_ty(), copy_def_id, &[])
@@ -147,17 +149,19 @@ fn check_clone_on_copy(cx: &LateContext<'_>, impl_item: &ImplItem<'_>, block: &B
             && let ExprKind::Path(qpath) = deref.kind
             && last_path_segment(&qpath).ident.name == kw::SelfLower
         {
-        } else {
-            span_lint_and_sugg(
-                cx,
-                NON_CANONICAL_CLONE_IMPL,
-                block.span,
-                "non-canonical implementation of `clone` on a `Copy` type",
-                "change this to",
-                "{ *self }".to_owned(),
-                Applicability::MaybeIncorrect,
-            );
+            // this is the canonical implementation, `fn clone(&self) -> Self { *self }`
+            return;
         }
+
+        span_lint_and_sugg(
+            cx,
+            NON_CANONICAL_CLONE_IMPL,
+            block.span,
+            "non-canonical implementation of `clone` on a `Copy` type",
+            "change this to",
+            "{ *self }".to_owned(),
+            Applicability::MaybeIncorrect,
+        );
     }
 
     if impl_item.ident.name == sym::clone_from {

From 08020def99d2851af0dabde12cc6d203017fa72c Mon Sep 17 00:00:00 2001
From: Reuben Cruise <reuben.cruise@arm.com>
Date: Wed, 10 Sep 2025 15:40:27 +0100
Subject: [PATCH 1306/1889] Changes some aarch64 CIs g++ install & ubuntu ver.

GCS support was added to GCC in version 15, thus the rmake test for this
patch requires GCC15
Similarly, the ubuntu version is updated so the newer clang version is
available, and/or GCC15 is the default.
---
 src/ci/docker/host-aarch64/aarch64-gnu-debug/Dockerfile   | 2 +-
 src/ci/docker/host-aarch64/aarch64-gnu-llvm-20/Dockerfile | 2 +-
 src/ci/docker/host-aarch64/aarch64-gnu/Dockerfile         | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/ci/docker/host-aarch64/aarch64-gnu-debug/Dockerfile b/src/ci/docker/host-aarch64/aarch64-gnu-debug/Dockerfile
index 71de8f917fa2c..04b46226acfa4 100644
--- a/src/ci/docker/host-aarch64/aarch64-gnu-debug/Dockerfile
+++ b/src/ci/docker/host-aarch64/aarch64-gnu-debug/Dockerfile
@@ -1,4 +1,4 @@
-FROM ubuntu:22.04
+FROM ubuntu:25.10
 
 ARG DEBIAN_FRONTEND=noninteractive
 RUN apt-get update && apt-get install -y --no-install-recommends \
diff --git a/src/ci/docker/host-aarch64/aarch64-gnu-llvm-20/Dockerfile b/src/ci/docker/host-aarch64/aarch64-gnu-llvm-20/Dockerfile
index adbb1f03378a6..095624d6fb714 100644
--- a/src/ci/docker/host-aarch64/aarch64-gnu-llvm-20/Dockerfile
+++ b/src/ci/docker/host-aarch64/aarch64-gnu-llvm-20/Dockerfile
@@ -1,4 +1,4 @@
-FROM ubuntu:25.04
+FROM ubuntu:25.10
 
 ARG DEBIAN_FRONTEND=noninteractive
 
diff --git a/src/ci/docker/host-aarch64/aarch64-gnu/Dockerfile b/src/ci/docker/host-aarch64/aarch64-gnu/Dockerfile
index e6133fce83e28..4b61fd94a6cfa 100644
--- a/src/ci/docker/host-aarch64/aarch64-gnu/Dockerfile
+++ b/src/ci/docker/host-aarch64/aarch64-gnu/Dockerfile
@@ -1,4 +1,4 @@
-FROM ubuntu:22.04
+FROM ubuntu:25.10
 
 ARG DEBIAN_FRONTEND=noninteractive
 RUN apt-get update && apt-get install -y --no-install-recommends \

From 220e137089943b3977cdac4755212646bded08dc Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Tue, 23 Sep 2025 14:34:38 +0200
Subject: [PATCH 1307/1889] split `unnecessary_clone` test into
 `clone_on_ref_ptr` and `clone_on_copy`

---
 tests/ui/clone_on_copy.fixed      |  65 +++++++++++++----
 tests/ui/clone_on_copy.rs         |  65 +++++++++++++----
 tests/ui/clone_on_copy.stderr     |  26 ++++---
 tests/ui/clone_on_ref_ptr.fixed   |  51 ++++++++++++++
 tests/ui/clone_on_ref_ptr.rs      |  51 ++++++++++++++
 tests/ui/clone_on_ref_ptr.stderr  |  41 +++++++++++
 tests/ui/unnecessary_clone.rs     | 111 ------------------------------
 tests/ui/unnecessary_clone.stderr |  62 -----------------
 8 files changed, 261 insertions(+), 211 deletions(-)
 create mode 100644 tests/ui/clone_on_ref_ptr.fixed
 create mode 100644 tests/ui/clone_on_ref_ptr.rs
 create mode 100644 tests/ui/clone_on_ref_ptr.stderr
 delete mode 100644 tests/ui/unnecessary_clone.rs
 delete mode 100644 tests/ui/unnecessary_clone.stderr

diff --git a/tests/ui/clone_on_copy.fixed b/tests/ui/clone_on_copy.fixed
index 2dd8af1525150..469121bbd740f 100644
--- a/tests/ui/clone_on_copy.fixed
+++ b/tests/ui/clone_on_copy.fixed
@@ -1,25 +1,16 @@
+#![warn(clippy::clone_on_copy)]
 #![allow(
-    unused,
     clippy::redundant_clone,
     clippy::deref_addrof,
     clippy::no_effect,
     clippy::unnecessary_operation,
-    clippy::vec_init_then_push,
     clippy::toplevel_ref_arg,
     clippy::needless_borrow
 )]
 
 use std::cell::RefCell;
-use std::rc::{self, Rc};
-use std::sync::{self, Arc};
 
-fn main() {}
-
-fn is_ascii(ch: char) -> bool {
-    ch.is_ascii()
-}
-
-fn clone_on_copy() -> Option<(i32)> {
+fn main() {
     42;
     //~^ clone_on_copy
 
@@ -65,20 +56,66 @@ fn clone_on_copy() -> Option<(i32)> {
     let x = 42;
     let ref y = x.clone(); // ok, binds by reference
     let ref mut y = x.clone(); // ok, binds by reference
+}
+
+mod issue3052 {
+    struct A;
+    struct B;
+    struct C;
+    struct D;
+    #[derive(Copy, Clone)]
+    struct E;
+
+    macro_rules! impl_deref {
+        ($src:ident, $dst:ident) => {
+            impl std::ops::Deref for $src {
+                type Target = $dst;
+                fn deref(&self) -> &Self::Target {
+                    &$dst
+                }
+            }
+        };
+    }
+
+    impl_deref!(A, B);
+    impl_deref!(B, C);
+    impl_deref!(C, D);
+    impl std::ops::Deref for D {
+        type Target = &'static E;
+        fn deref(&self) -> &Self::Target {
+            &&E
+        }
+    }
+
+    fn go1() {
+        let a = A;
+        let _: E = *****a;
+        //~^ clone_on_copy
+
+        let _: E = *****a;
+    }
+}
+
+fn issue4348() {
+    fn is_ascii(ch: char) -> bool {
+        ch.is_ascii()
+    }
 
-    // Issue #4348
     let mut x = 43;
     let _ = &x.clone(); // ok, getting a ref
     'a'.clone().make_ascii_uppercase(); // ok, clone and then mutate
     is_ascii('z');
     //~^ clone_on_copy
+}
 
-    // Issue #5436
+#[expect(clippy::vec_init_then_push)]
+fn issue5436() {
     let mut vec = Vec::new();
     vec.push(42);
     //~^ clone_on_copy
+}
 
-    //  Issue #9277
+fn issue9277() -> Option<i32> {
     let opt: &Option<i32> = &None;
     let value = (*opt)?; // operator precedence needed (*opt)?
     //
diff --git a/tests/ui/clone_on_copy.rs b/tests/ui/clone_on_copy.rs
index a371afb04a78f..b05f1d3aa35e9 100644
--- a/tests/ui/clone_on_copy.rs
+++ b/tests/ui/clone_on_copy.rs
@@ -1,25 +1,16 @@
+#![warn(clippy::clone_on_copy)]
 #![allow(
-    unused,
     clippy::redundant_clone,
     clippy::deref_addrof,
     clippy::no_effect,
     clippy::unnecessary_operation,
-    clippy::vec_init_then_push,
     clippy::toplevel_ref_arg,
     clippy::needless_borrow
 )]
 
 use std::cell::RefCell;
-use std::rc::{self, Rc};
-use std::sync::{self, Arc};
 
-fn main() {}
-
-fn is_ascii(ch: char) -> bool {
-    ch.is_ascii()
-}
-
-fn clone_on_copy() -> Option<(i32)> {
+fn main() {
     42.clone();
     //~^ clone_on_copy
 
@@ -65,20 +56,66 @@ fn clone_on_copy() -> Option<(i32)> {
     let x = 42;
     let ref y = x.clone(); // ok, binds by reference
     let ref mut y = x.clone(); // ok, binds by reference
+}
+
+mod issue3052 {
+    struct A;
+    struct B;
+    struct C;
+    struct D;
+    #[derive(Copy, Clone)]
+    struct E;
+
+    macro_rules! impl_deref {
+        ($src:ident, $dst:ident) => {
+            impl std::ops::Deref for $src {
+                type Target = $dst;
+                fn deref(&self) -> &Self::Target {
+                    &$dst
+                }
+            }
+        };
+    }
+
+    impl_deref!(A, B);
+    impl_deref!(B, C);
+    impl_deref!(C, D);
+    impl std::ops::Deref for D {
+        type Target = &'static E;
+        fn deref(&self) -> &Self::Target {
+            &&E
+        }
+    }
+
+    fn go1() {
+        let a = A;
+        let _: E = a.clone();
+        //~^ clone_on_copy
+
+        let _: E = *****a;
+    }
+}
+
+fn issue4348() {
+    fn is_ascii(ch: char) -> bool {
+        ch.is_ascii()
+    }
 
-    // Issue #4348
     let mut x = 43;
     let _ = &x.clone(); // ok, getting a ref
     'a'.clone().make_ascii_uppercase(); // ok, clone and then mutate
     is_ascii('z'.clone());
     //~^ clone_on_copy
+}
 
-    // Issue #5436
+#[expect(clippy::vec_init_then_push)]
+fn issue5436() {
     let mut vec = Vec::new();
     vec.push(42.clone());
     //~^ clone_on_copy
+}
 
-    //  Issue #9277
+fn issue9277() -> Option<i32> {
     let opt: &Option<i32> = &None;
     let value = opt.clone()?; // operator precedence needed (*opt)?
     //
diff --git a/tests/ui/clone_on_copy.stderr b/tests/ui/clone_on_copy.stderr
index 92cdd635d20a8..c87d1d488dde5 100644
--- a/tests/ui/clone_on_copy.stderr
+++ b/tests/ui/clone_on_copy.stderr
@@ -1,5 +1,5 @@
 error: using `clone` on type `i32` which implements the `Copy` trait
-  --> tests/ui/clone_on_copy.rs:23:5
+  --> tests/ui/clone_on_copy.rs:14:5
    |
 LL |     42.clone();
    |     ^^^^^^^^^^ help: try removing the `clone` call: `42`
@@ -8,52 +8,58 @@ LL |     42.clone();
    = help: to override `-D warnings` add `#[allow(clippy::clone_on_copy)]`
 
 error: using `clone` on type `i32` which implements the `Copy` trait
-  --> tests/ui/clone_on_copy.rs:28:5
+  --> tests/ui/clone_on_copy.rs:19:5
    |
 LL |     (&42).clone();
    |     ^^^^^^^^^^^^^ help: try dereferencing it: `*(&42)`
 
 error: using `clone` on type `i32` which implements the `Copy` trait
-  --> tests/ui/clone_on_copy.rs:32:5
+  --> tests/ui/clone_on_copy.rs:23:5
    |
 LL |     rc.borrow().clone();
    |     ^^^^^^^^^^^^^^^^^^^ help: try dereferencing it: `*rc.borrow()`
 
 error: using `clone` on type `u32` which implements the `Copy` trait
-  --> tests/ui/clone_on_copy.rs:36:5
+  --> tests/ui/clone_on_copy.rs:27:5
    |
 LL |     x.clone().rotate_left(1);
    |     ^^^^^^^^^ help: try removing the `clone` call: `x`
 
 error: using `clone` on type `i32` which implements the `Copy` trait
-  --> tests/ui/clone_on_copy.rs:51:5
+  --> tests/ui/clone_on_copy.rs:42:5
    |
 LL |     m!(42).clone();
    |     ^^^^^^^^^^^^^^ help: try removing the `clone` call: `m!(42)`
 
 error: using `clone` on type `[u32; 2]` which implements the `Copy` trait
-  --> tests/ui/clone_on_copy.rs:62:5
+  --> tests/ui/clone_on_copy.rs:53:5
    |
 LL |     x.clone()[0];
    |     ^^^^^^^^^ help: try dereferencing it: `(*x)`
 
+error: using `clone` on type `E` which implements the `Copy` trait
+  --> tests/ui/clone_on_copy.rs:92:20
+   |
+LL |         let _: E = a.clone();
+   |                    ^^^^^^^^^ help: try dereferencing it: `*****a`
+
 error: using `clone` on type `char` which implements the `Copy` trait
-  --> tests/ui/clone_on_copy.rs:73:14
+  --> tests/ui/clone_on_copy.rs:107:14
    |
 LL |     is_ascii('z'.clone());
    |              ^^^^^^^^^^^ help: try removing the `clone` call: `'z'`
 
 error: using `clone` on type `i32` which implements the `Copy` trait
-  --> tests/ui/clone_on_copy.rs:78:14
+  --> tests/ui/clone_on_copy.rs:114:14
    |
 LL |     vec.push(42.clone());
    |              ^^^^^^^^^^ help: try removing the `clone` call: `42`
 
 error: using `clone` on type `Option<i32>` which implements the `Copy` trait
-  --> tests/ui/clone_on_copy.rs:83:17
+  --> tests/ui/clone_on_copy.rs:120:17
    |
 LL |     let value = opt.clone()?; // operator precedence needed (*opt)?
    |                 ^^^^^^^^^^^ help: try dereferencing it: `(*opt)`
 
-error: aborting due to 9 previous errors
+error: aborting due to 10 previous errors
 
diff --git a/tests/ui/clone_on_ref_ptr.fixed b/tests/ui/clone_on_ref_ptr.fixed
new file mode 100644
index 0000000000000..8ef4b36566363
--- /dev/null
+++ b/tests/ui/clone_on_ref_ptr.fixed
@@ -0,0 +1,51 @@
+#![warn(clippy::clone_on_ref_ptr)]
+
+use std::rc::{Rc, Weak as RcWeak};
+use std::sync::{Arc, Weak as ArcWeak};
+
+fn main() {}
+
+fn clone_on_ref_ptr(rc: Rc<str>, rc_weak: RcWeak<str>, arc: Arc<str>, arc_weak: ArcWeak<str>) {
+    std::rc::Rc::<str>::clone(&rc);
+    //~^ clone_on_ref_ptr
+    std::rc::Weak::<str>::clone(&rc_weak);
+    //~^ clone_on_ref_ptr
+    std::sync::Arc::<str>::clone(&arc);
+    //~^ clone_on_ref_ptr
+    std::sync::Weak::<str>::clone(&arc_weak);
+    //~^ clone_on_ref_ptr
+
+    Rc::clone(&rc);
+    Arc::clone(&arc);
+    RcWeak::clone(&rc_weak);
+    ArcWeak::clone(&arc_weak);
+}
+
+trait SomeTrait {}
+struct SomeImpl;
+impl SomeTrait for SomeImpl {}
+
+fn trait_object() {
+    let x = Arc::new(SomeImpl);
+    let _: Arc<dyn SomeTrait> = std::sync::Arc::<SomeImpl>::clone(&x);
+    //~^ clone_on_ref_ptr
+}
+
+mod issue2076 {
+    use std::rc::Rc;
+
+    macro_rules! try_opt {
+        ($expr: expr) => {
+            match $expr {
+                Some(value) => value,
+                None => return None,
+            }
+        };
+    }
+
+    fn func() -> Option<Rc<u8>> {
+        let rc = Rc::new(42);
+        Some(std::rc::Rc::<u8>::clone(&try_opt!(Some(rc))))
+        //~^ clone_on_ref_ptr
+    }
+}
diff --git a/tests/ui/clone_on_ref_ptr.rs b/tests/ui/clone_on_ref_ptr.rs
new file mode 100644
index 0000000000000..fbd787099aee3
--- /dev/null
+++ b/tests/ui/clone_on_ref_ptr.rs
@@ -0,0 +1,51 @@
+#![warn(clippy::clone_on_ref_ptr)]
+
+use std::rc::{Rc, Weak as RcWeak};
+use std::sync::{Arc, Weak as ArcWeak};
+
+fn main() {}
+
+fn clone_on_ref_ptr(rc: Rc<str>, rc_weak: RcWeak<str>, arc: Arc<str>, arc_weak: ArcWeak<str>) {
+    rc.clone();
+    //~^ clone_on_ref_ptr
+    rc_weak.clone();
+    //~^ clone_on_ref_ptr
+    arc.clone();
+    //~^ clone_on_ref_ptr
+    arc_weak.clone();
+    //~^ clone_on_ref_ptr
+
+    Rc::clone(&rc);
+    Arc::clone(&arc);
+    RcWeak::clone(&rc_weak);
+    ArcWeak::clone(&arc_weak);
+}
+
+trait SomeTrait {}
+struct SomeImpl;
+impl SomeTrait for SomeImpl {}
+
+fn trait_object() {
+    let x = Arc::new(SomeImpl);
+    let _: Arc<dyn SomeTrait> = x.clone();
+    //~^ clone_on_ref_ptr
+}
+
+mod issue2076 {
+    use std::rc::Rc;
+
+    macro_rules! try_opt {
+        ($expr: expr) => {
+            match $expr {
+                Some(value) => value,
+                None => return None,
+            }
+        };
+    }
+
+    fn func() -> Option<Rc<u8>> {
+        let rc = Rc::new(42);
+        Some(try_opt!(Some(rc)).clone())
+        //~^ clone_on_ref_ptr
+    }
+}
diff --git a/tests/ui/clone_on_ref_ptr.stderr b/tests/ui/clone_on_ref_ptr.stderr
new file mode 100644
index 0000000000000..b15f0e803a352
--- /dev/null
+++ b/tests/ui/clone_on_ref_ptr.stderr
@@ -0,0 +1,41 @@
+error: using `.clone()` on a ref-counted pointer
+  --> tests/ui/clone_on_ref_ptr.rs:9:5
+   |
+LL |     rc.clone();
+   |     ^^^^^^^^^^ help: try: `std::rc::Rc::<str>::clone(&rc)`
+   |
+   = note: `-D clippy::clone-on-ref-ptr` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::clone_on_ref_ptr)]`
+
+error: using `.clone()` on a ref-counted pointer
+  --> tests/ui/clone_on_ref_ptr.rs:11:5
+   |
+LL |     rc_weak.clone();
+   |     ^^^^^^^^^^^^^^^ help: try: `std::rc::Weak::<str>::clone(&rc_weak)`
+
+error: using `.clone()` on a ref-counted pointer
+  --> tests/ui/clone_on_ref_ptr.rs:13:5
+   |
+LL |     arc.clone();
+   |     ^^^^^^^^^^^ help: try: `std::sync::Arc::<str>::clone(&arc)`
+
+error: using `.clone()` on a ref-counted pointer
+  --> tests/ui/clone_on_ref_ptr.rs:15:5
+   |
+LL |     arc_weak.clone();
+   |     ^^^^^^^^^^^^^^^^ help: try: `std::sync::Weak::<str>::clone(&arc_weak)`
+
+error: using `.clone()` on a ref-counted pointer
+  --> tests/ui/clone_on_ref_ptr.rs:30:33
+   |
+LL |     let _: Arc<dyn SomeTrait> = x.clone();
+   |                                 ^^^^^^^^^ help: try: `std::sync::Arc::<SomeImpl>::clone(&x)`
+
+error: using `.clone()` on a ref-counted pointer
+  --> tests/ui/clone_on_ref_ptr.rs:48:14
+   |
+LL |         Some(try_opt!(Some(rc)).clone())
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::rc::Rc::<u8>::clone(&try_opt!(Some(rc)))`
+
+error: aborting due to 6 previous errors
+
diff --git a/tests/ui/unnecessary_clone.rs b/tests/ui/unnecessary_clone.rs
deleted file mode 100644
index 7335b6f9f0390..0000000000000
--- a/tests/ui/unnecessary_clone.rs
+++ /dev/null
@@ -1,111 +0,0 @@
-// does not test any rustfixable lints
-#![warn(clippy::clone_on_ref_ptr)]
-#![allow(unused)]
-#![allow(clippy::redundant_clone, clippy::uninlined_format_args, clippy::unnecessary_wraps)]
-//@no-rustfix
-use std::cell::RefCell;
-use std::rc::{self, Rc};
-use std::sync::{self, Arc};
-
-trait SomeTrait {}
-struct SomeImpl;
-impl SomeTrait for SomeImpl {}
-
-fn main() {}
-
-fn clone_on_ref_ptr() {
-    let rc = Rc::new(true);
-    let arc = Arc::new(true);
-
-    let rcweak = Rc::downgrade(&rc);
-    let arc_weak = Arc::downgrade(&arc);
-
-    rc.clone();
-    //~^ clone_on_ref_ptr
-
-    Rc::clone(&rc);
-
-    arc.clone();
-    //~^ clone_on_ref_ptr
-
-    Arc::clone(&arc);
-
-    rcweak.clone();
-    //~^ clone_on_ref_ptr
-
-    rc::Weak::clone(&rcweak);
-
-    arc_weak.clone();
-    //~^ clone_on_ref_ptr
-
-    sync::Weak::clone(&arc_weak);
-
-    let x = Arc::new(SomeImpl);
-    let _: Arc<dyn SomeTrait> = x.clone();
-    //~^ clone_on_ref_ptr
-}
-
-fn clone_on_copy_generic<T: Copy>(t: T) {
-    t.clone();
-    //~^ clone_on_copy
-
-    Some(t).clone();
-    //~^ clone_on_copy
-}
-
-mod many_derefs {
-    struct A;
-    struct B;
-    struct C;
-    struct D;
-    #[derive(Copy, Clone)]
-    struct E;
-
-    macro_rules! impl_deref {
-        ($src:ident, $dst:ident) => {
-            impl std::ops::Deref for $src {
-                type Target = $dst;
-                fn deref(&self) -> &Self::Target {
-                    &$dst
-                }
-            }
-        };
-    }
-
-    impl_deref!(A, B);
-    impl_deref!(B, C);
-    impl_deref!(C, D);
-    impl std::ops::Deref for D {
-        type Target = &'static E;
-        fn deref(&self) -> &Self::Target {
-            &&E
-        }
-    }
-
-    fn go1() {
-        let a = A;
-        let _: E = a.clone();
-        //~^ clone_on_copy
-
-        let _: E = *****a;
-    }
-}
-
-mod issue2076 {
-    use std::rc::Rc;
-
-    macro_rules! try_opt {
-        ($expr: expr) => {
-            match $expr {
-                Some(value) => value,
-                None => return None,
-            }
-        };
-    }
-
-    fn func() -> Option<Rc<u8>> {
-        let rc = Rc::new(42);
-        Some(try_opt!(Some(rc)).clone())
-        //~^ clone_on_ref_ptr
-    }
-}
diff --git a/tests/ui/unnecessary_clone.stderr b/tests/ui/unnecessary_clone.stderr
deleted file mode 100644
index 17518e123d12e..0000000000000
--- a/tests/ui/unnecessary_clone.stderr
+++ /dev/null
@@ -1,62 +0,0 @@
-error: using `.clone()` on a ref-counted pointer
-  --> tests/ui/unnecessary_clone.rs:23:5
-   |
-LL |     rc.clone();
-   |     ^^^^^^^^^^ help: try: `std::rc::Rc::<bool>::clone(&rc)`
-   |
-   = note: `-D clippy::clone-on-ref-ptr` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::clone_on_ref_ptr)]`
-
-error: using `.clone()` on a ref-counted pointer
-  --> tests/ui/unnecessary_clone.rs:28:5
-   |
-LL |     arc.clone();
-   |     ^^^^^^^^^^^ help: try: `std::sync::Arc::<bool>::clone(&arc)`
-
-error: using `.clone()` on a ref-counted pointer
-  --> tests/ui/unnecessary_clone.rs:33:5
-   |
-LL |     rcweak.clone();
-   |     ^^^^^^^^^^^^^^ help: try: `std::rc::Weak::<bool>::clone(&rcweak)`
-
-error: using `.clone()` on a ref-counted pointer
-  --> tests/ui/unnecessary_clone.rs:38:5
-   |
-LL |     arc_weak.clone();
-   |     ^^^^^^^^^^^^^^^^ help: try: `std::sync::Weak::<bool>::clone(&arc_weak)`
-
-error: using `.clone()` on a ref-counted pointer
-  --> tests/ui/unnecessary_clone.rs:44:33
-   |
-LL |     let _: Arc<dyn SomeTrait> = x.clone();
-   |                                 ^^^^^^^^^ help: try: `std::sync::Arc::<SomeImpl>::clone(&x)`
-
-error: using `clone` on type `T` which implements the `Copy` trait
-  --> tests/ui/unnecessary_clone.rs:49:5
-   |
-LL |     t.clone();
-   |     ^^^^^^^^^ help: try removing the `clone` call: `t`
-   |
-   = note: `-D clippy::clone-on-copy` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::clone_on_copy)]`
-
-error: using `clone` on type `Option<T>` which implements the `Copy` trait
-  --> tests/ui/unnecessary_clone.rs:52:5
-   |
-LL |     Some(t).clone();
-   |     ^^^^^^^^^^^^^^^ help: try removing the `clone` call: `Some(t)`
-
-error: using `clone` on type `E` which implements the `Copy` trait
-  --> tests/ui/unnecessary_clone.rs:87:20
-   |
-LL |         let _: E = a.clone();
-   |                    ^^^^^^^^^ help: try dereferencing it: `*****a`
-
-error: using `.clone()` on a ref-counted pointer
-  --> tests/ui/unnecessary_clone.rs:108:14
-   |
-LL |         Some(try_opt!(Some(rc)).clone())
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::rc::Rc::<u8>::clone(&try_opt!(Some(rc)))`
-
-error: aborting due to 9 previous errors
-

From 58c7505d868515eb55971cf1ad8744c81d5ea7d2 Mon Sep 17 00:00:00 2001
From: Yotam Ofek <yotam.ofek@gmail.com>
Date: Tue, 23 Sep 2025 00:34:05 +0300
Subject: [PATCH 1308/1889] Make `render_example_with_highlighting` return an
 `impl fmt::Display`

---
 src/librustdoc/html/highlight.rs | 116 ++++++++++++++-----------------
 src/librustdoc/html/markdown.rs  |  17 +++--
 2 files changed, 62 insertions(+), 71 deletions(-)

diff --git a/src/librustdoc/html/highlight.rs b/src/librustdoc/html/highlight.rs
index 0e06361024b9f..3ddfb3470f2f1 100644
--- a/src/librustdoc/html/highlight.rs
+++ b/src/librustdoc/html/highlight.rs
@@ -8,6 +8,7 @@
 use std::borrow::Cow;
 use std::collections::VecDeque;
 use std::fmt::{self, Display, Write};
+use std::iter;
 
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_lexer::{Cursor, FrontmatterAllowed, LiteralKind, TokenKind};
@@ -15,8 +16,9 @@ use rustc_span::edition::Edition;
 use rustc_span::symbol::Symbol;
 use rustc_span::{BytePos, DUMMY_SP, Span};
 
-use super::format::{self, write_str};
+use super::format;
 use crate::clean::PrimitiveType;
+use crate::display::Joined as _;
 use crate::html::escape::EscapeBodyText;
 use crate::html::macro_expansion::ExpandedCode;
 use crate::html::render::{Context, LinkFromSrc};
@@ -51,26 +53,26 @@ pub(crate) enum Tooltip {
 /// Highlights `src` as an inline example, returning the HTML output.
 pub(crate) fn render_example_with_highlighting(
     src: &str,
-    out: &mut String,
-    tooltip: Tooltip,
+    tooltip: &Tooltip,
     playground_button: Option<&str>,
     extra_classes: &[String],
-) {
-    write_header(out, "rust-example-rendered", None, tooltip, extra_classes);
-    write_code(out, src, None, None, None);
-    write_footer(out, playground_button);
+) -> impl Display {
+    fmt::from_fn(move |f| {
+        write_header("rust-example-rendered", None, tooltip, extra_classes).fmt(f)?;
+        write_code(f, src, None, None, None);
+        write_footer(playground_button).fmt(f)
+    })
 }
 
 fn write_header(
-    out: &mut String,
     class: &str,
     extra_content: Option<&str>,
-    tooltip: Tooltip,
+    tooltip: &Tooltip,
     extra_classes: &[String],
-) {
-    write_str(
-        out,
-        format_args!(
+) -> impl Display {
+    fmt::from_fn(move |f| {
+        write!(
+            f,
             "<div class=\"example-wrap{}\">",
             match tooltip {
                 Tooltip::IgnoreAll | Tooltip::IgnoreSome(_) => " ignore",
@@ -79,58 +81,48 @@ fn write_header(
                 Tooltip::Edition(_) => " edition",
                 Tooltip::None => "",
             }
-        ),
-    );
-
-    if tooltip != Tooltip::None {
-        let tooltip = fmt::from_fn(|f| match &tooltip {
-            Tooltip::IgnoreAll => f.write_str("This example is not tested"),
-            Tooltip::IgnoreSome(platforms) => {
-                f.write_str("This example is not tested on ")?;
-                match &platforms[..] {
-                    [] => unreachable!(),
-                    [platform] => f.write_str(platform)?,
-                    [first, second] => write!(f, "{first} or {second}")?,
-                    [platforms @ .., last] => {
-                        for platform in platforms {
-                            write!(f, "{platform}, ")?;
+        )?;
+
+        if *tooltip != Tooltip::None {
+            let tooltip = fmt::from_fn(|f| match tooltip {
+                Tooltip::IgnoreAll => f.write_str("This example is not tested"),
+                Tooltip::IgnoreSome(platforms) => {
+                    f.write_str("This example is not tested on ")?;
+                    match &platforms[..] {
+                        [] => unreachable!(),
+                        [platform] => f.write_str(platform)?,
+                        [first, second] => write!(f, "{first} or {second}")?,
+                        [platforms @ .., last] => {
+                            for platform in platforms {
+                                write!(f, "{platform}, ")?;
+                            }
+                            write!(f, "or {last}")?;
                         }
-                        write!(f, "or {last}")?;
                     }
+                    Ok(())
                 }
-                Ok(())
-            }
-            Tooltip::CompileFail => f.write_str("This example deliberately fails to compile"),
-            Tooltip::ShouldPanic => f.write_str("This example panics"),
-            Tooltip::Edition(edition) => write!(f, "This example runs with edition {edition}"),
-            Tooltip::None => unreachable!(),
+                Tooltip::CompileFail => f.write_str("This example deliberately fails to compile"),
+                Tooltip::ShouldPanic => f.write_str("This example panics"),
+                Tooltip::Edition(edition) => write!(f, "This example runs with edition {edition}"),
+                Tooltip::None => unreachable!(),
+            });
+
+            write!(f, "<a href=\"#\" class=\"tooltip\" title=\"{tooltip}\">ⓘ</a>")?;
+        }
+
+        if let Some(extra) = extra_content {
+            f.write_str(extra)?;
+        }
+
+        let classes = fmt::from_fn(|f| {
+            iter::once("rust")
+                .chain(Some(class).filter(|class| !class.is_empty()))
+                .chain(extra_classes.iter().map(String::as_str))
+                .joined(" ", f)
         });
-        write_str(out, format_args!("<a href=\"#\" class=\"tooltip\" title=\"{tooltip}\">ⓘ</a>"));
-    }
 
-    if let Some(extra) = extra_content {
-        out.push_str(extra);
-    }
-    if class.is_empty() {
-        write_str(
-            out,
-            format_args!(
-                "<pre class=\"rust{}{}\">",
-                if extra_classes.is_empty() { "" } else { " " },
-                extra_classes.join(" ")
-            ),
-        );
-    } else {
-        write_str(
-            out,
-            format_args!(
-                "<pre class=\"rust {class}{}{}\">",
-                if extra_classes.is_empty() { "" } else { " " },
-                extra_classes.join(" ")
-            ),
-        );
-    }
-    write_str(out, format_args!("<code>"));
+        write!(f, "<pre class=\"{classes}\"><code>")
+    })
 }
 
 /// Check if two `Class` can be merged together. In the following rules, "unclassified" means `None`
@@ -577,8 +569,8 @@ pub(super) fn write_code(
     });
 }
 
-fn write_footer(out: &mut String, playground_button: Option<&str>) {
-    write_str(out, format_args!("</code></pre>{}</div>", playground_button.unwrap_or_default()));
+fn write_footer(playground_button: Option<&str>) -> impl Display {
+    fmt::from_fn(move |f| write!(f, "</code></pre>{}</div>", playground_button.unwrap_or_default()))
 }
 
 /// How a span of text is classified. Mostly corresponds to token kinds.
diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs
index 4addf2c3c9644..46923d1f69826 100644
--- a/src/librustdoc/html/markdown.rs
+++ b/src/librustdoc/html/markdown.rs
@@ -337,15 +337,14 @@ impl<'a, I: Iterator<Item = Event<'a>>> Iterator for CodeBlocks<'_, 'a, I> {
 
         // insert newline to clearly separate it from the
         // previous block so we can shorten the html output
-        let mut s = String::new();
-        s.push('\n');
-
-        highlight::render_example_with_highlighting(
-            &text,
-            &mut s,
-            tooltip,
-            playground_button.as_deref(),
-            &added_classes,
+        let s = format!(
+            "\n{}",
+            highlight::render_example_with_highlighting(
+                &text,
+                &tooltip,
+                playground_button.as_deref(),
+                &added_classes,
+            )
         );
         Some(Event::Html(s.into()))
     }

From aaff372f4b45f88dc3b28fe3c1c8ec22cb3b3411 Mon Sep 17 00:00:00 2001
From: Yotam Ofek <yotam.ofek@gmail.com>
Date: Tue, 23 Sep 2025 01:04:04 +0300
Subject: [PATCH 1309/1889] Remove `Tooltip::None` variant, use `Option::None`

---
 src/librustdoc/html/highlight.rs | 23 +++++++++++------------
 src/librustdoc/html/markdown.rs  | 30 +++++++++++++++++-------------
 2 files changed, 28 insertions(+), 25 deletions(-)

diff --git a/src/librustdoc/html/highlight.rs b/src/librustdoc/html/highlight.rs
index 3ddfb3470f2f1..b1257999c070c 100644
--- a/src/librustdoc/html/highlight.rs
+++ b/src/librustdoc/html/highlight.rs
@@ -47,13 +47,12 @@ pub(crate) enum Tooltip {
     CompileFail,
     ShouldPanic,
     Edition(Edition),
-    None,
 }
 
 /// Highlights `src` as an inline example, returning the HTML output.
 pub(crate) fn render_example_with_highlighting(
     src: &str,
-    tooltip: &Tooltip,
+    tooltip: Option<&Tooltip>,
     playground_button: Option<&str>,
     extra_classes: &[String],
 ) -> impl Display {
@@ -67,23 +66,24 @@ pub(crate) fn render_example_with_highlighting(
 fn write_header(
     class: &str,
     extra_content: Option<&str>,
-    tooltip: &Tooltip,
+    tooltip: Option<&Tooltip>,
     extra_classes: &[String],
 ) -> impl Display {
     fmt::from_fn(move |f| {
         write!(
             f,
             "<div class=\"example-wrap{}\">",
-            match tooltip {
-                Tooltip::IgnoreAll | Tooltip::IgnoreSome(_) => " ignore",
-                Tooltip::CompileFail => " compile_fail",
-                Tooltip::ShouldPanic => " should_panic",
-                Tooltip::Edition(_) => " edition",
-                Tooltip::None => "",
-            }
+            tooltip
+                .map(|tooltip| match tooltip {
+                    Tooltip::IgnoreAll | Tooltip::IgnoreSome(_) => " ignore",
+                    Tooltip::CompileFail => " compile_fail",
+                    Tooltip::ShouldPanic => " should_panic",
+                    Tooltip::Edition(_) => " edition",
+                })
+                .unwrap_or_default()
         )?;
 
-        if *tooltip != Tooltip::None {
+        if let Some(tooltip) = tooltip {
             let tooltip = fmt::from_fn(|f| match tooltip {
                 Tooltip::IgnoreAll => f.write_str("This example is not tested"),
                 Tooltip::IgnoreSome(platforms) => {
@@ -104,7 +104,6 @@ fn write_header(
                 Tooltip::CompileFail => f.write_str("This example deliberately fails to compile"),
                 Tooltip::ShouldPanic => f.write_str("This example panics"),
                 Tooltip::Edition(edition) => write!(f, "This example runs with edition {edition}"),
-                Tooltip::None => unreachable!(),
             });
 
             write!(f, "<a href=\"#\" class=\"tooltip\" title=\"{tooltip}\">ⓘ</a>")?;
diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs
index 46923d1f69826..7065de14c8ea7 100644
--- a/src/librustdoc/html/markdown.rs
+++ b/src/librustdoc/html/markdown.rs
@@ -321,18 +321,22 @@ impl<'a, I: Iterator<Item = Event<'a>>> Iterator for CodeBlocks<'_, 'a, I> {
             ))
         });
 
-        let tooltip = if ignore == Ignore::All {
-            highlight::Tooltip::IgnoreAll
-        } else if let Ignore::Some(platforms) = ignore {
-            highlight::Tooltip::IgnoreSome(platforms)
-        } else if compile_fail {
-            highlight::Tooltip::CompileFail
-        } else if should_panic {
-            highlight::Tooltip::ShouldPanic
-        } else if explicit_edition {
-            highlight::Tooltip::Edition(edition)
-        } else {
-            highlight::Tooltip::None
+        let tooltip = {
+            use highlight::Tooltip::*;
+
+            if ignore == Ignore::All {
+                Some(IgnoreAll)
+            } else if let Ignore::Some(platforms) = ignore {
+                Some(IgnoreSome(platforms))
+            } else if compile_fail {
+                Some(CompileFail)
+            } else if should_panic {
+                Some(ShouldPanic)
+            } else if explicit_edition {
+                Some(Edition(edition))
+            } else {
+                None
+            }
         };
 
         // insert newline to clearly separate it from the
@@ -341,7 +345,7 @@ impl<'a, I: Iterator<Item = Event<'a>>> Iterator for CodeBlocks<'_, 'a, I> {
             "\n{}",
             highlight::render_example_with_highlighting(
                 &text,
-                &tooltip,
+                tooltip.as_ref(),
                 playground_button.as_deref(),
                 &added_classes,
             )

From e697f206fe4eba49f8984ef2d436bc0cd19ff8fc Mon Sep 17 00:00:00 2001
From: Yotam Ofek <yotam.ofek@gmail.com>
Date: Tue, 23 Sep 2025 01:04:14 +0300
Subject: [PATCH 1310/1889] Remove unused param from `write_header`

---
 src/librustdoc/html/highlight.rs | 13 ++-----------
 1 file changed, 2 insertions(+), 11 deletions(-)

diff --git a/src/librustdoc/html/highlight.rs b/src/librustdoc/html/highlight.rs
index b1257999c070c..fe2b2fc603120 100644
--- a/src/librustdoc/html/highlight.rs
+++ b/src/librustdoc/html/highlight.rs
@@ -57,18 +57,13 @@ pub(crate) fn render_example_with_highlighting(
     extra_classes: &[String],
 ) -> impl Display {
     fmt::from_fn(move |f| {
-        write_header("rust-example-rendered", None, tooltip, extra_classes).fmt(f)?;
+        write_header("rust-example-rendered", tooltip, extra_classes).fmt(f)?;
         write_code(f, src, None, None, None);
         write_footer(playground_button).fmt(f)
     })
 }
 
-fn write_header(
-    class: &str,
-    extra_content: Option<&str>,
-    tooltip: Option<&Tooltip>,
-    extra_classes: &[String],
-) -> impl Display {
+fn write_header(class: &str, tooltip: Option<&Tooltip>, extra_classes: &[String]) -> impl Display {
     fmt::from_fn(move |f| {
         write!(
             f,
@@ -109,10 +104,6 @@ fn write_header(
             write!(f, "<a href=\"#\" class=\"tooltip\" title=\"{tooltip}\">ⓘ</a>")?;
         }
 
-        if let Some(extra) = extra_content {
-            f.write_str(extra)?;
-        }
-
         let classes = fmt::from_fn(|f| {
             iter::once("rust")
                 .chain(Some(class).filter(|class| !class.is_empty()))

From 38a2829c97e07e7a403d59424403561de4f91a3a Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Tue, 23 Sep 2025 16:58:45 +0200
Subject: [PATCH 1311/1889] doc(trait_checking): use `is_some_and`

---
 book/src/development/trait_checking.md | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/book/src/development/trait_checking.md b/book/src/development/trait_checking.md
index 6d01496eebe07..c6f6f6bd2f99e 100644
--- a/book/src/development/trait_checking.md
+++ b/book/src/development/trait_checking.md
@@ -24,12 +24,11 @@ use rustc_span::symbol::sym;
 
 impl LateLintPass<'_> for CheckIteratorTraitLint {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
-		let implements_iterator = cx.tcx.get_diagnostic_item(sym::Iterator).map_or(false, |id| {
-    		implements_trait(cx, cx.typeck_results().expr_ty(expr), id, &[])
-		});
-		if implements_iterator {
-			// [...]
-		}
+        let implements_iterator = (cx.tcx.get_diagnostic_item(sym::Iterator))
+            .is_some_and(|id| implements_trait(cx, cx.typeck_results().expr_ty(expr), id, &[]));
+        if implements_iterator {
+            // [...]
+        }
 
     }
 }

From 4fcafc9daad24e5811546896b80e4e18578bf9f3 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Tue, 23 Sep 2025 08:25:07 +0200
Subject: [PATCH 1312/1889] yeet fastpath

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

diff --git a/compiler/rustc_trait_selection/src/infer.rs b/compiler/rustc_trait_selection/src/infer.rs
index 4c50c44b84182..cd076d1cb692a 100644
--- a/compiler/rustc_trait_selection/src/infer.rs
+++ b/compiler/rustc_trait_selection/src/infer.rs
@@ -9,7 +9,7 @@ use rustc_middle::infer::canonical::{
     Canonical, CanonicalQueryInput, CanonicalQueryResponse, QueryResponse,
 };
 use rustc_middle::traits::query::NoSolution;
-use rustc_middle::ty::{self, GenericArg, Ty, TyCtxt, TypeFoldable, TypeVisitableExt, Upcast};
+use rustc_middle::ty::{self, GenericArg, Ty, TyCtxt, TypeFoldable, Upcast};
 use rustc_span::DUMMY_SP;
 use tracing::instrument;
 
@@ -31,19 +31,7 @@ impl<'tcx> InferCtxt<'tcx> {
 
     fn type_is_copy_modulo_regions(&self, param_env: ty::ParamEnv<'tcx>, ty: Ty<'tcx>) -> bool {
         let ty = self.resolve_vars_if_possible(ty);
-
-        // FIXME(#132279): This should be removed as it causes us to incorrectly
-        // handle opaques in their defining scope, and stalled coroutines.
-        if !self.next_trait_solver() && !(param_env, ty).has_infer() && !ty.has_coroutines() {
-            return self.tcx.type_is_copy_modulo_regions(self.typing_env(param_env), ty);
-        }
-
         let copy_def_id = self.tcx.require_lang_item(LangItem::Copy, DUMMY_SP);
-
-        // This can get called from typeck (by euv), and `moves_by_default`
-        // rightly refuses to work with inference variables, but
-        // moves_by_default has a cache, which we want to use in other
-        // cases.
         traits::type_known_to_meet_bound_modulo_regions(self, param_env, ty, copy_def_id)
     }
 

From 83532f8544e18dfc2025ab33e7c01fb27865667f Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Tue, 23 Sep 2025 17:08:29 +0200
Subject: [PATCH 1313/1889] remove test for no_core

---
 .../missing-copy-lang-item-issue-19660.rs     | 19 -------------------
 .../missing-copy-lang-item-issue-19660.stderr |  8 --------
 2 files changed, 27 deletions(-)
 delete mode 100644 tests/ui/lang-items/missing-copy-lang-item-issue-19660.rs
 delete mode 100644 tests/ui/lang-items/missing-copy-lang-item-issue-19660.stderr

diff --git a/tests/ui/lang-items/missing-copy-lang-item-issue-19660.rs b/tests/ui/lang-items/missing-copy-lang-item-issue-19660.rs
deleted file mode 100644
index 35d5d079c6894..0000000000000
--- a/tests/ui/lang-items/missing-copy-lang-item-issue-19660.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-#![feature(lang_items, no_core)]
-#![no_core]
-#![no_main]
-
-#[lang = "pointee_sized"]
-pub trait PointeeSized {}
-
-#[lang = "meta_sized"]
-pub trait MetaSized: PointeeSized {}
-
-#[lang = "sized"]
-trait Sized: MetaSized { }
-
-struct S;
-
-#[no_mangle]
-extern "C" fn main(argc: i32, _argv: *const *const u8) -> i32 {
-    argc //~ ERROR requires `copy` lang_item
-}
diff --git a/tests/ui/lang-items/missing-copy-lang-item-issue-19660.stderr b/tests/ui/lang-items/missing-copy-lang-item-issue-19660.stderr
deleted file mode 100644
index 7b9541f734fa8..0000000000000
--- a/tests/ui/lang-items/missing-copy-lang-item-issue-19660.stderr
+++ /dev/null
@@ -1,8 +0,0 @@
-error: requires `copy` lang_item
-  --> $DIR/missing-copy-lang-item-issue-19660.rs:18:5
-   |
-LL |     argc
-   |     ^^^^
-
-error: aborting due to 1 previous error
-

From af1b14bb9b1b3d301c1e8e0a989d814deaf054c9 Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Tue, 23 Sep 2025 17:13:35 +0200
Subject: [PATCH 1314/1889] std: move WinSock abstractions to `sys::pal`

---
 .../src/sys/net/connection/socket/windows.rs  | 80 +------------------
 library/std/src/sys/pal/windows/mod.rs        |  1 +
 library/std/src/sys/pal/windows/winsock.rs    | 80 +++++++++++++++++++
 3 files changed, 84 insertions(+), 77 deletions(-)
 create mode 100644 library/std/src/sys/pal/windows/winsock.rs

diff --git a/library/std/src/sys/net/connection/socket/windows.rs b/library/std/src/sys/net/connection/socket/windows.rs
index b71d8b1357b5a..5b6f4cedf1b77 100644
--- a/library/std/src/sys/net/connection/socket/windows.rs
+++ b/library/std/src/sys/net/connection/socket/windows.rs
@@ -8,9 +8,8 @@ use crate::net::{Shutdown, SocketAddr};
 use crate::os::windows::io::{
     AsRawSocket, AsSocket, BorrowedSocket, FromRawSocket, IntoRawSocket, OwnedSocket, RawSocket,
 };
-use crate::sync::atomic::Atomic;
-use crate::sync::atomic::Ordering::{AcqRel, Relaxed};
 use crate::sys::c;
+use crate::sys::pal::winsock::last_error;
 use crate::sys_common::{AsInner, FromInner, IntoInner};
 use crate::time::Duration;
 use crate::{cmp, mem, ptr, sys};
@@ -112,84 +111,11 @@ pub(super) mod netc {
     }
 }
 
+pub use crate::sys::pal::winsock::{cleanup, cvt, cvt_gai, cvt_r, startup as init};
+
 #[expect(missing_debug_implementations)]
 pub struct Socket(OwnedSocket);
 
-static WSA_INITIALIZED: Atomic<bool> = Atomic::<bool>::new(false);
-
-/// Checks whether the Windows socket interface has been started already, and
-/// if not, starts it.
-#[inline]
-pub fn init() {
-    if !WSA_INITIALIZED.load(Relaxed) {
-        wsa_startup();
-    }
-}
-
-#[cold]
-fn wsa_startup() {
-    unsafe {
-        let mut data: c::WSADATA = mem::zeroed();
-        let ret = c::WSAStartup(
-            0x202, // version 2.2
-            &mut data,
-        );
-        assert_eq!(ret, 0);
-        if WSA_INITIALIZED.swap(true, AcqRel) {
-            // If another thread raced with us and called WSAStartup first then call
-            // WSACleanup so it's as though WSAStartup was only called once.
-            c::WSACleanup();
-        }
-    }
-}
-
-pub fn cleanup() {
-    // We don't need to call WSACleanup here because exiting the process will cause
-    // the OS to clean everything for us, which is faster than doing it manually.
-    // See #141799.
-}
-
-/// Returns the last error from the Windows socket interface.
-fn last_error() -> io::Error {
-    io::Error::from_raw_os_error(unsafe { c::WSAGetLastError() })
-}
-
-#[doc(hidden)]
-pub trait IsMinusOne {
-    fn is_minus_one(&self) -> bool;
-}
-
-macro_rules! impl_is_minus_one {
-    ($($t:ident)*) => ($(impl IsMinusOne for $t {
-        fn is_minus_one(&self) -> bool {
-            *self == -1
-        }
-    })*)
-}
-
-impl_is_minus_one! { i8 i16 i32 i64 isize }
-
-/// Checks if the signed integer is the Windows constant `SOCKET_ERROR` (-1)
-/// and if so, returns the last error from the Windows socket interface. This
-/// function must be called before another call to the socket API is made.
-pub fn cvt<T: IsMinusOne>(t: T) -> io::Result<T> {
-    if t.is_minus_one() { Err(last_error()) } else { Ok(t) }
-}
-
-/// A variant of `cvt` for `getaddrinfo` which return 0 for a success.
-pub fn cvt_gai(err: c_int) -> io::Result<()> {
-    if err == 0 { Ok(()) } else { Err(last_error()) }
-}
-
-/// Just to provide the same interface as sys/pal/unix/net.rs
-pub fn cvt_r<T, F>(mut f: F) -> io::Result<T>
-where
-    T: IsMinusOne,
-    F: FnMut() -> T,
-{
-    cvt(f())
-}
-
 impl Socket {
     pub fn new(addr: &SocketAddr, ty: c_int) -> io::Result<Socket> {
         let family = match *addr {
diff --git a/library/std/src/sys/pal/windows/mod.rs b/library/std/src/sys/pal/windows/mod.rs
index 3357946b8f71d..85a4d3ca6db27 100644
--- a/library/std/src/sys/pal/windows/mod.rs
+++ b/library/std/src/sys/pal/windows/mod.rs
@@ -30,6 +30,7 @@ cfg_select! {
         pub use self::stack_overflow_uwp as stack_overflow;
     }
 }
+pub mod winsock;
 
 /// Map a [`Result<T, WinError>`] to [`io::Result<T>`](crate::io::Result<T>).
 pub trait IoResult<T> {
diff --git a/library/std/src/sys/pal/windows/winsock.rs b/library/std/src/sys/pal/windows/winsock.rs
new file mode 100644
index 0000000000000..b110a43ef3aa8
--- /dev/null
+++ b/library/std/src/sys/pal/windows/winsock.rs
@@ -0,0 +1,80 @@
+use super::c;
+use crate::ffi::c_int;
+use crate::sync::atomic::Atomic;
+use crate::sync::atomic::Ordering::{AcqRel, Relaxed};
+use crate::{io, mem};
+
+static WSA_STARTED: Atomic<bool> = Atomic::<bool>::new(false);
+
+/// Checks whether the Windows socket interface has been started already, and
+/// if not, starts it.
+#[inline]
+pub fn startup() {
+    if !WSA_STARTED.load(Relaxed) {
+        wsa_startup();
+    }
+}
+
+#[cold]
+fn wsa_startup() {
+    unsafe {
+        let mut data: c::WSADATA = mem::zeroed();
+        let ret = c::WSAStartup(
+            0x202, // version 2.2
+            &mut data,
+        );
+        assert_eq!(ret, 0);
+        if WSA_STARTED.swap(true, AcqRel) {
+            // If another thread raced with us and called WSAStartup first then call
+            // WSACleanup so it's as though WSAStartup was only called once.
+            c::WSACleanup();
+        }
+    }
+}
+
+pub fn cleanup() {
+    // We don't need to call WSACleanup here because exiting the process will cause
+    // the OS to clean everything for us, which is faster than doing it manually.
+    // See #141799.
+}
+
+/// Returns the last error from the Windows socket interface.
+pub fn last_error() -> io::Error {
+    io::Error::from_raw_os_error(unsafe { c::WSAGetLastError() })
+}
+
+#[doc(hidden)]
+pub trait IsMinusOne {
+    fn is_minus_one(&self) -> bool;
+}
+
+macro_rules! impl_is_minus_one {
+    ($($t:ident)*) => ($(impl IsMinusOne for $t {
+        fn is_minus_one(&self) -> bool {
+            *self == -1
+        }
+    })*)
+}
+
+impl_is_minus_one! { i8 i16 i32 i64 isize }
+
+/// Checks if the signed integer is the Windows constant `SOCKET_ERROR` (-1)
+/// and if so, returns the last error from the Windows socket interface. This
+/// function must be called before another call to the socket API is made.
+pub fn cvt<T: IsMinusOne>(t: T) -> io::Result<T> {
+    if t.is_minus_one() { Err(last_error()) } else { Ok(t) }
+}
+
+/// A variant of `cvt` for `getaddrinfo` which return 0 for a success.
+pub fn cvt_gai(err: c_int) -> io::Result<()> {
+    if err == 0 { Ok(()) } else { Err(last_error()) }
+}
+
+/// Just to provide the same interface as sys/pal/unix/net.rs
+pub fn cvt_r<T, F>(mut f: F) -> io::Result<T>
+where
+    T: IsMinusOne,
+    F: FnMut() -> T,
+{
+    cvt(f())
+}

From 42cf78f762ecad22de89d914904887afc073278f Mon Sep 17 00:00:00 2001
From: Augie Fackler <augie@google.com>
Date: Mon, 22 Sep 2025 15:44:30 -0400
Subject: [PATCH 1315/1889] llvm: update remarks support on LLVM 22

LLVM change dfbd76bda01e removed separate remark support entirely, but
it turns out we can just drop the parameter and everything appears to
work fine.

Fixes 146912 as far as I can tell (the test passes.)

@rustbot label llvm-main
---
 compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index 414274f24fb50..ef85ce153b88c 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -1779,9 +1779,14 @@ extern "C" void LLVMRustContextConfigureDiagnosticHandler(
     // Do not delete the file after we gather remarks
     RemarkFile->keep();
 
+#if LLVM_VERSION_GE(22, 0)
+    auto RemarkSerializer = remarks::createRemarkSerializer(
+        llvm::remarks::Format::YAML, RemarkFile->os());
+#else
     auto RemarkSerializer = remarks::createRemarkSerializer(
         llvm::remarks::Format::YAML, remarks::SerializerMode::Separate,
         RemarkFile->os());
+#endif
     if (Error E = RemarkSerializer.takeError()) {
       std::string Error = std::string("Cannot create remark serializer: ") +
                           toString(std::move(E));

From 60b35635e8084be2e4f8b55f170e8665edb8e275 Mon Sep 17 00:00:00 2001
From: ash <ashkernel02@gmail.com>
Date: Tue, 23 Sep 2025 12:37:59 -0600
Subject: [PATCH 1316/1889] revert change removing `has_infer` check. Commit
 conservatively patches for now, but more development proceeding. Also
 contains a more concise test

---
 compiler/rustc_middle/src/ty/util.rs            | 11 ++++++++++-
 tests/ui/type-inference/box_has_sigdrop.rs      |  9 +++++++++
 tests/ui/type-inference/box_has_sigdrop.stderr  | 17 +++++++++++++++++
 .../{has_sigdrop.rs => dropper_has_sigdrop.rs}  |  0
 4 files changed, 36 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/type-inference/box_has_sigdrop.rs
 create mode 100644 tests/ui/type-inference/box_has_sigdrop.stderr
 rename tests/ui/type-inference/{has_sigdrop.rs => dropper_has_sigdrop.rs} (100%)

diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs
index 4f039381e500d..a4422abc6883a 100644
--- a/compiler/rustc_middle/src/ty/util.rs
+++ b/compiler/rustc_middle/src/ty/util.rs
@@ -1368,7 +1368,6 @@ impl<'tcx> Ty<'tcx> {
     /// 2229 drop reorder migration analysis.
     #[inline]
     pub fn has_significant_drop(self, tcx: TyCtxt<'tcx>, typing_env: ty::TypingEnv<'tcx>) -> bool {
-        assert!(!self.has_non_region_infer());
         // Avoid querying in simple cases.
         match needs_drop_components(tcx, self) {
             Err(AlwaysRequiresDrop) => true,
@@ -1381,6 +1380,16 @@ impl<'tcx> Ty<'tcx> {
                     _ => self,
                 };
 
+                // FIXME
+                // We should be canonicalizing, or else moving this to a method of inference
+                // context, or *something* like that,
+                // but for now just avoid passing inference variables
+                // to queries that can't cope with them.
+                // Instead, conservatively return "true" (may change drop order).
+                if query_ty.has_infer() {
+                    return true;
+                }
+
                 // This doesn't depend on regions, so try to minimize distinct
                 // query keys used.
                 let erased = tcx.normalize_erasing_regions(typing_env, query_ty);
diff --git a/tests/ui/type-inference/box_has_sigdrop.rs b/tests/ui/type-inference/box_has_sigdrop.rs
new file mode 100644
index 0000000000000..3e801197a78e6
--- /dev/null
+++ b/tests/ui/type-inference/box_has_sigdrop.rs
@@ -0,0 +1,9 @@
+//@ should-fail
+//@ compile-flags: -Wrust-2021-incompatible-closure-captures
+// Inference, canonicalization, and significant drops should work nicely together.
+// Related issue: #86868
+
+fn main() {
+    let mut state = 0;
+    Box::new(move || state)
+}
diff --git a/tests/ui/type-inference/box_has_sigdrop.stderr b/tests/ui/type-inference/box_has_sigdrop.stderr
new file mode 100644
index 0000000000000..b61b6322c107f
--- /dev/null
+++ b/tests/ui/type-inference/box_has_sigdrop.stderr
@@ -0,0 +1,17 @@
+error[E0308]: mismatched types
+  --> $DIR/box_has_sigdrop.rs:8:5
+   |
+LL | fn main() {
+   |          - expected `()` because of default return type
+LL |     let mut state = 0;
+LL |     Box::new(move || state)
+   |     ^^^^^^^^^^^^^^^^^^^^^^^- help: consider using a semicolon here: `;`
+   |     |
+   |     expected `()`, found `Box<{closure@box_has_sigdrop.rs:8:14}>`
+   |
+   = note: expected unit type `()`
+                 found struct `Box<{closure@$DIR/box_has_sigdrop.rs:8:14: 8:21}>`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/type-inference/has_sigdrop.rs b/tests/ui/type-inference/dropper_has_sigdrop.rs
similarity index 100%
rename from tests/ui/type-inference/has_sigdrop.rs
rename to tests/ui/type-inference/dropper_has_sigdrop.rs

From 489f0179e789620c1b94b2451749a4d1ed7b80f4 Mon Sep 17 00:00:00 2001
From: Jack Huey <31162821+jackh726@users.noreply.github.com>
Date: Tue, 23 Sep 2025 02:51:21 -0400
Subject: [PATCH 1317/1889] Use lower_nextsolver::callable_item_signature
 instead of lower::callable_item_signature

---
 .../rust-analyzer/crates/hir-ty/src/db.rs     | 17 ++--
 .../crates/hir-ty/src/display.rs              |  6 +-
 .../crates/hir-ty/src/dyn_compatibility.rs    |  2 +-
 .../rust-analyzer/crates/hir-ty/src/lib.rs    |  4 +-
 .../rust-analyzer/crates/hir-ty/src/lower.rs  | 90 ++-----------------
 .../crates/hir-ty/src/method_resolution.rs    | 15 +++-
 .../crates/hir-ty/src/mir/lower.rs            | 14 ++-
 .../crates/hir-ty/src/next_solver/interner.rs |  2 +-
 .../crates/hir-ty/src/next_solver/mapping.rs  | 45 ++++++++++
 .../hir-ty/src/tests/method_resolution.rs     |  2 +-
 .../crates/hir-ty/src/tests/traits.rs         | 14 +--
 .../crates/hir-ty/src/variance.rs             | 19 ++--
 src/tools/rust-analyzer/crates/hir/src/lib.rs | 80 ++++++++++++++---
 .../ide-completion/src/context/analysis.rs    | 13 ++-
 .../crates/ide/src/inlay_hints/bind_pat.rs    |  2 +-
 .../crates/ide/src/signature_help.rs          |  4 +-
 16 files changed, 188 insertions(+), 141 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
index 6eb5f8defaa1b..84c6c0471b5b3 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
@@ -16,8 +16,8 @@ use smallvec::SmallVec;
 use triomphe::Arc;
 
 use crate::{
-    Binders, Const, ImplTraitId, ImplTraits, InferenceResult, PolyFnSig, Substitution,
-    TraitEnvironment, TraitRef, Ty, TyDefId, ValueTyDefId, chalk_db,
+    Binders, Const, ImplTraitId, ImplTraits, InferenceResult, Substitution, TraitEnvironment,
+    TraitRef, Ty, TyDefId, ValueTyDefId, chalk_db,
     consteval::ConstEvalError,
     drop::DropGlue,
     dyn_compatibility::DynCompatibilityViolation,
@@ -167,8 +167,11 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
     #[salsa::transparent]
     fn field_types(&self, var: VariantId) -> Arc<ArenaMap<LocalFieldId, Binders<Ty>>>;
 
-    #[salsa::invoke(crate::lower::callable_item_signature_query)]
-    fn callable_item_signature(&self, def: CallableDefId) -> PolyFnSig;
+    #[salsa::invoke(crate::lower_nextsolver::callable_item_signature_query)]
+    fn callable_item_signature<'db>(
+        &'db self,
+        def: CallableDefId,
+    ) -> crate::next_solver::EarlyBinder<'db, crate::next_solver::PolyFnSig<'db>>;
 
     #[salsa::invoke(crate::lower::return_type_impl_traits)]
     fn return_type_impl_traits(&self, def: FunctionId) -> Option<Arc<Binders<ImplTraits>>>;
@@ -354,12 +357,6 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
         ArenaMap<LocalFieldId, crate::next_solver::EarlyBinder<'db, crate::next_solver::Ty<'db>>>,
     >;
 
-    #[salsa::invoke(crate::lower_nextsolver::callable_item_signature_query)]
-    fn callable_item_signature_ns<'db>(
-        &'db self,
-        def: CallableDefId,
-    ) -> crate::next_solver::EarlyBinder<'db, crate::next_solver::PolyFnSig<'db>>;
-
     #[salsa::invoke(crate::lower_nextsolver::return_type_impl_traits)]
     fn return_type_impl_traits_ns<'db>(
         &'db self,
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 dc42304e1cab2..e11ce51cdb8f0 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
@@ -46,8 +46,8 @@ use span::Edition;
 use stdx::never;
 use triomphe::Arc;
 
-use crate::next_solver::infer::DbInternerInferExt;
 use crate::next_solver::infer::traits::ObligationCause;
+use crate::next_solver::{infer::DbInternerInferExt, mapping::NextSolverToChalk};
 use crate::{
     AliasEq, AliasTy, Binders, CallableDefId, CallableSig, ConcreteConst, Const, ConstScalar,
     ConstValue, DomainGoal, FnAbi, GenericArg, ImplTraitId, Interner, Lifetime, LifetimeData,
@@ -1298,7 +1298,9 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                 let def = def.0;
                 let sig = db
                     .callable_item_signature(def)
-                    .substitute(Interner, &convert_args_for_result(interner, args.as_slice()));
+                    .instantiate(interner, args)
+                    .skip_binder()
+                    .to_chalk(interner);
 
                 if f.display_kind.is_source_code() {
                     // `FnDef` is anonymous and there's no surface syntax for it. Show it as a
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
index b87c998217741..f033c511acd6a 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
@@ -329,7 +329,7 @@ where
         cb(MethodViolationCode::AsyncFn)?;
     }
 
-    let sig = db.callable_item_signature_ns(func.into());
+    let sig = db.callable_item_signature(func.into());
     if sig
         .skip_binder()
         .inputs()
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 05c5a7a28b9a9..c2acfc4142e89 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
@@ -578,8 +578,10 @@ impl CallableSig {
 
     pub fn from_def(db: &dyn HirDatabase, def: FnDefId, substs: &Substitution) -> CallableSig {
         let callable_def = ToChalk::from_chalk(db, def);
+        let interner = DbInterner::new_with(db, None, None);
+        let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);
         let sig = db.callable_item_signature(callable_def);
-        sig.substitute(Interner, substs)
+        sig.instantiate(interner, args).skip_binder().to_chalk(interner)
     }
     pub fn from_fn_ptr(fn_ptr: &FnPointer) -> CallableSig {
         CallableSig {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
index 756769a2174f1..598fd38b4b8e9 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
@@ -24,9 +24,9 @@ use chalk_ir::{
 
 use either::Either;
 use hir_def::{
-    AdtId, AssocItemId, CallableDefId, ConstId, ConstParamId, EnumId, EnumVariantId, FunctionId,
-    GenericDefId, GenericParamId, ImplId, ItemContainerId, LocalFieldId, Lookup, StaticId,
-    StructId, TypeAliasId, TypeOrConstParamId, UnionId, VariantId,
+    AdtId, AssocItemId, ConstId, ConstParamId, EnumId, EnumVariantId, FunctionId, GenericDefId,
+    GenericParamId, ImplId, ItemContainerId, LocalFieldId, Lookup, StaticId, StructId, TypeAliasId,
+    TypeOrConstParamId, UnionId, VariantId,
     builtin_type::BuiltinType,
     expr_store::{ExpressionStore, path::Path},
     hir::generics::{GenericParamDataRef, TypeOrConstParamData, WherePredicate},
@@ -45,10 +45,10 @@ use stdx::{impl_from, never};
 use triomphe::{Arc, ThinArc};
 
 use crate::{
-    AliasTy, Binders, BoundVar, CallableSig, Const, DebruijnIndex, DynTy, FnAbi, FnPointer, FnSig,
-    FnSubst, ImplTrait, ImplTraitId, ImplTraits, Interner, Lifetime, LifetimeData,
-    LifetimeOutlives, PolyFnSig, QuantifiedWhereClause, QuantifiedWhereClauses, Substitution,
-    TraitRef, TraitRefExt, Ty, TyBuilder, TyKind, WhereClause, all_super_traits,
+    AliasTy, Binders, BoundVar, Const, DebruijnIndex, DynTy, FnAbi, FnPointer, FnSig, FnSubst,
+    ImplTrait, ImplTraitId, ImplTraits, Interner, Lifetime, LifetimeData, LifetimeOutlives,
+    QuantifiedWhereClause, QuantifiedWhereClauses, Substitution, TraitRef, TraitRefExt, Ty,
+    TyBuilder, TyKind, WhereClause, all_super_traits,
     consteval::{intern_const_ref, path_to_const, unknown_const, unknown_const_as_generic},
     db::HirDatabase,
     error_lifetime,
@@ -824,15 +824,6 @@ impl<'a> TyLoweringContext<'a> {
     }
 }
 
-/// Build the signature of a callable item (function, struct or enum variant).
-pub(crate) fn callable_item_signature_query(db: &dyn HirDatabase, def: CallableDefId) -> PolyFnSig {
-    match def {
-        CallableDefId::FunctionId(f) => fn_sig_for_fn(db, f),
-        CallableDefId::StructId(s) => fn_sig_for_struct_constructor(db, s),
-        CallableDefId::EnumVariantId(e) => fn_sig_for_enum_variant_constructor(db, e),
-    }
-}
-
 fn named_associated_type_shorthand_candidates<R>(
     db: &dyn HirDatabase,
     // If the type parameter is defined in an impl and we're in a method, there
@@ -1312,73 +1303,6 @@ pub(crate) fn generic_defaults_with_diagnostics_cycle_result(
     (GenericDefaults(None), None)
 }
 
-fn fn_sig_for_fn(db: &dyn HirDatabase, def: FunctionId) -> PolyFnSig {
-    let data = db.function_signature(def);
-    let resolver = def.resolver(db);
-    let mut ctx_params = TyLoweringContext::new(
-        db,
-        &resolver,
-        &data.store,
-        def.into(),
-        LifetimeElisionKind::for_fn_params(&data),
-    )
-    .with_type_param_mode(ParamLoweringMode::Variable);
-    let params = data.params.iter().map(|&tr| ctx_params.lower_ty(tr));
-
-    let ret = match data.ret_type {
-        Some(ret_type) => {
-            let mut ctx_ret = TyLoweringContext::new(
-                db,
-                &resolver,
-                &data.store,
-                def.into(),
-                LifetimeElisionKind::for_fn_ret(),
-            )
-            .with_impl_trait_mode(ImplTraitLoweringMode::Opaque)
-            .with_type_param_mode(ParamLoweringMode::Variable);
-            ctx_ret.lower_ty(ret_type)
-        }
-        None => TyKind::Tuple(0, Substitution::empty(Interner)).intern(Interner),
-    };
-    let generics = generics(db, def.into());
-    let sig = CallableSig::from_params_and_return(
-        params,
-        ret,
-        data.is_varargs(),
-        if data.is_unsafe() { Safety::Unsafe } else { Safety::Safe },
-        data.abi.as_ref().map_or(FnAbi::Rust, FnAbi::from_symbol),
-    );
-    make_binders(db, &generics, sig)
-}
-
-fn fn_sig_for_struct_constructor(db: &dyn HirDatabase, def: StructId) -> PolyFnSig {
-    let field_tys = db.field_types(def.into());
-    let params = field_tys.iter().map(|(_, ty)| ty.skip_binders().clone());
-    let (ret, binders) = type_for_adt(db, def.into()).into_value_and_skipped_binders();
-    Binders::new(
-        binders,
-        CallableSig::from_params_and_return(params, ret, false, Safety::Safe, FnAbi::RustCall),
-    )
-}
-
-fn fn_sig_for_enum_variant_constructor(db: &dyn HirDatabase, def: EnumVariantId) -> PolyFnSig {
-    let field_tys = db.field_types(def.into());
-    let params = field_tys.iter().map(|(_, ty)| ty.skip_binders().clone());
-    let parent = def.lookup(db).parent;
-    let (ret, binders) = type_for_adt(db, parent.into()).into_value_and_skipped_binders();
-    Binders::new(
-        binders,
-        CallableSig::from_params_and_return(params, ret, false, Safety::Safe, FnAbi::RustCall),
-    )
-}
-
-fn type_for_adt(db: &dyn HirDatabase, adt: AdtId) -> Binders<Ty> {
-    let generics = generics(db, adt.into());
-    let subst = generics.bound_vars_subst(db, DebruijnIndex::INNERMOST);
-    let ty = TyKind::Adt(crate::AdtId(adt), subst).intern(Interner);
-    make_binders(db, &generics, ty)
-}
-
 pub(crate) fn type_for_type_alias_with_diagnostics_query(
     db: &dyn HirDatabase,
     t: TypeAliasId,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
index 66687490b4a45..93ef64272d14b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
@@ -1746,9 +1746,13 @@ fn is_valid_trait_method_candidate(
                         .fill_with_inference_vars(table)
                         .build();
 
+                    let args: crate::next_solver::GenericArgs<'_> =
+                        fn_subst.to_nextsolver(table.interner);
                     let sig = db.callable_item_signature(fn_id.into());
-                    let expected_receiver =
-                        sig.map(|s| s.params()[0].clone()).substitute(Interner, &fn_subst);
+                    let expected_receiver = sig
+                        .map_bound(|s| s.skip_binder().inputs_and_output.as_slice()[0])
+                        .instantiate(table.interner, args)
+                        .to_chalk(table.interner);
 
                     // FIXME: Clean up this mess with some context struct like rustc's `ProbeContext`
                     let variance = match mode {
@@ -1833,9 +1837,12 @@ fn is_valid_impl_fn_candidate(
             let fn_subst: crate::Substitution =
                 table.infer_ctxt.fresh_args_for_item(fn_id.into()).to_chalk(table.interner);
 
+            let args: crate::next_solver::GenericArgs<'_> = fn_subst.to_nextsolver(table.interner);
             let sig = db.callable_item_signature(fn_id.into());
-            let expected_receiver =
-                sig.map(|s| s.params()[0].clone()).substitute(Interner, &fn_subst);
+            let expected_receiver = sig
+                .map_bound(|s| s.skip_binder().inputs_and_output.as_slice()[0])
+                .instantiate(table.interner, args)
+                .to_chalk(table.interner);
 
             check_that!(table.unify(receiver_ty, &expected_receiver));
         }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
index 0416f4315d4dd..3e44e8c68ddaa 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/lower.rs
@@ -43,7 +43,10 @@ use crate::{
         Terminator, TerminatorKind, TupleFieldId, Ty, UnOp, VariantId, intern_const_scalar,
         return_slot,
     },
-    next_solver::{DbInterner, mapping::ChalkToNextSolver},
+    next_solver::{
+        DbInterner,
+        mapping::{ChalkToNextSolver, NextSolverToChalk},
+    },
     static_lifetime,
     traits::FnTrait,
     utils::ClosureSubst,
@@ -2207,8 +2210,13 @@ pub fn lower_to_mir(
             // otherwise it's an inline const, and has no parameter
             if let DefWithBodyId::FunctionId(fid) = owner {
                 let substs = TyBuilder::placeholder_subst(db, fid);
-                let callable_sig =
-                    db.callable_item_signature(fid.into()).substitute(Interner, &substs);
+                let interner = DbInterner::new_with(db, None, None);
+                let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);
+                let callable_sig = db
+                    .callable_item_signature(fid.into())
+                    .instantiate(interner, args)
+                    .skip_binder()
+                    .to_chalk(interner);
                 let mut params = callable_sig.params().iter();
                 let self_param = body.self_param.and_then(|id| Some((id, params.next()?.clone())));
                 break 'b ctx.lower_params_and_bindings(
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
index 3f61b9f02621b..1a14ac9a7457b 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
@@ -1225,7 +1225,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
         self,
         def_id: Self::FunctionId,
     ) -> EarlyBinder<Self, rustc_type_ir::Binder<Self, rustc_type_ir::FnSig<Self>>> {
-        self.db().callable_item_signature_ns(def_id.0)
+        self.db().callable_item_signature(def_id.0)
     }
 
     fn coroutine_movability(self, def_id: Self::CoroutineId) -> rustc_ast_ir::Movability {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
index 5dcb1e62329d0..f3f74f67c04de 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/mapping.rs
@@ -575,6 +575,17 @@ impl<
     }
 }
 
+impl<'db, T: NextSolverToChalk<'db, U>, U: HasInterner<Interner = Interner>>
+    NextSolverToChalk<'db, chalk_ir::Binders<U>> for rustc_type_ir::Binder<DbInterner<'db>, T>
+{
+    fn to_chalk(self, interner: DbInterner<'db>) -> chalk_ir::Binders<U> {
+        chalk_ir::Binders::new(
+            self.bound_vars().to_chalk(interner),
+            self.skip_binder().to_chalk(interner),
+        )
+    }
+}
+
 impl<'db> ChalkToNextSolver<'db, BoundVarKinds> for chalk_ir::VariableKinds<Interner> {
     fn to_nextsolver(&self, interner: DbInterner<'db>) -> BoundVarKinds {
         BoundVarKinds::new_from_iter(
@@ -584,6 +595,12 @@ impl<'db> ChalkToNextSolver<'db, BoundVarKinds> for chalk_ir::VariableKinds<Inte
     }
 }
 
+impl<'db> NextSolverToChalk<'db, chalk_ir::VariableKinds<Interner>> for BoundVarKinds {
+    fn to_chalk(self, interner: DbInterner<'db>) -> chalk_ir::VariableKinds<Interner> {
+        chalk_ir::VariableKinds::from_iter(Interner, self.iter().map(|v| v.to_chalk(interner)))
+    }
+}
+
 impl<'db> ChalkToNextSolver<'db, BoundVarKind> for chalk_ir::VariableKind<Interner> {
     fn to_nextsolver(&self, interner: DbInterner<'db>) -> BoundVarKind {
         match self {
@@ -594,6 +611,18 @@ impl<'db> ChalkToNextSolver<'db, BoundVarKind> for chalk_ir::VariableKind<Intern
     }
 }
 
+impl<'db> NextSolverToChalk<'db, chalk_ir::VariableKind<Interner>> for BoundVarKind {
+    fn to_chalk(self, interner: DbInterner<'db>) -> chalk_ir::VariableKind<Interner> {
+        match self {
+            BoundVarKind::Ty(_) => chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General),
+            BoundVarKind::Region(_) => chalk_ir::VariableKind::Lifetime,
+            BoundVarKind::Const => {
+                chalk_ir::VariableKind::Const(chalk_ir::TyKind::Error.intern(Interner))
+            }
+        }
+    }
+}
+
 impl<'db> ChalkToNextSolver<'db, GenericArg<'db>> for chalk_ir::GenericArg<Interner> {
     fn to_nextsolver(&self, interner: DbInterner<'db>) -> GenericArg<'db> {
         match self.data(Interner) {
@@ -1233,6 +1262,22 @@ where
     }
 }
 
+impl<'db> NextSolverToChalk<'db, crate::CallableSig> for rustc_type_ir::FnSig<DbInterner<'db>> {
+    fn to_chalk(self, interner: DbInterner<'db>) -> crate::CallableSig {
+        crate::CallableSig {
+            abi: self.abi,
+            is_varargs: self.c_variadic,
+            safety: match self.safety {
+                super::abi::Safety::Safe => chalk_ir::Safety::Safe,
+                super::abi::Safety::Unsafe => chalk_ir::Safety::Unsafe,
+            },
+            params_and_return: triomphe::Arc::from_iter(
+                self.inputs_and_output.iter().map(|ty| convert_ty_for_result(interner, ty)),
+            ),
+        }
+    }
+}
+
 pub fn convert_canonical_args_for_result<'db>(
     interner: DbInterner<'db>,
     args: Canonical<'db, Vec<GenericArg<'db>>>,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs
index 6a566a505579c..5ada14bc5342e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs
@@ -2053,7 +2053,7 @@ impl dyn Error + Send {
                                // ^^^^ expected Box<dyn Error + '?>, got Box<dyn Error + Send + '?>
                                // FIXME, type mismatch should not occur
         <dyn Error>::downcast(err).map_err(|_| loop {})
-      //^^^^^^^^^^^^^^^^^^^^^ type: fn downcast<{unknown}>(Box<dyn Error + 'static>) -> Result<Box<{unknown}>, Box<dyn Error + '?>>
+      //^^^^^^^^^^^^^^^^^^^^^ type: fn downcast<{unknown}>(Box<dyn Error + 'static>) -> Result<Box<{unknown}>, Box<dyn Error + 'static>>
     }
 }
 "#,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
index 41f8d4ed555f2..66faac09cc299 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/traits.rs
@@ -1487,8 +1487,8 @@ fn test(x: Box<dyn Trait<u64>>, y: &dyn Trait<u64>) {
             268..269 'x': Box<dyn Trait<u64> + '?>
             275..276 'y': &'? (dyn Trait<u64> + '?)
             286..287 'z': Box<dyn Trait<u64> + '?>
-            290..293 'bar': fn bar() -> Box<dyn Trait<u64> + '?>
-            290..295 'bar()': Box<dyn Trait<u64> + '?>
+            290..293 'bar': fn bar() -> Box<dyn Trait<u64> + 'static>
+            290..295 'bar()': Box<dyn Trait<u64> + 'static>
             301..302 'x': Box<dyn Trait<u64> + '?>
             301..308 'x.foo()': u64
             314..315 'y': &'? (dyn Trait<u64> + '?)
@@ -1535,7 +1535,7 @@ fn test(s: S<u32, i32>) {
             251..252 's': S<u32, i32>
             267..289 '{     ...z(); }': ()
             273..274 's': S<u32, i32>
-            273..280 's.bar()': &'? (dyn Trait<u32, i32> + '?)
+            273..280 's.bar()': &'? (dyn Trait<u32, i32> + 'static)
             273..286 's.bar().baz()': (u32, i32)
         "#]],
     );
@@ -1568,8 +1568,8 @@ fn test(x: Trait, y: &Trait) -> u64 {
             106..107 'x': dyn Trait + '?
             113..114 'y': &'? (dyn Trait + '?)
             124..125 'z': dyn Trait + '?
-            128..131 'bar': fn bar() -> dyn Trait + '?
-            128..133 'bar()': dyn Trait + '?
+            128..131 'bar': fn bar() -> dyn Trait + 'static
+            128..133 'bar()': dyn Trait + 'static
             139..140 'x': dyn Trait + '?
             139..146 'x.foo()': u64
             152..153 'y': &'? (dyn Trait + '?)
@@ -1597,7 +1597,7 @@ fn main() {
             47..48 '_': &'? (dyn Fn(S) + '?)
             58..60 '{}': ()
             71..105 '{     ...()); }': ()
-            77..78 'f': fn f(&'? (dyn Fn(S) + '?))
+            77..78 'f': fn f(&'? (dyn Fn(S) + 'static))
             77..102 'f(&|nu...foo())': ()
             79..101 '&|numb....foo()': &'? impl Fn(S)
             80..101 '|numbe....foo()': impl Fn(S)
@@ -2952,7 +2952,7 @@ fn test(x: &dyn Foo) {
             34..36 '{}': ()
             46..47 'x': &'? (dyn Foo + '?)
             59..74 '{     foo(x); }': ()
-            65..68 'foo': fn foo(&'? (dyn Foo + '?))
+            65..68 'foo': fn foo(&'? (dyn Foo + 'static))
             65..71 'foo(x)': ()
             69..70 'x': &'? (dyn Foo + '?)
         "#]],
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/variance.rs b/src/tools/rust-analyzer/crates/hir-ty/src/variance.rs
index 8593dba301b85..a17cf3782701a 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/variance.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/variance.rs
@@ -15,6 +15,8 @@
 
 use crate::db::HirDatabase;
 use crate::generics::{Generics, generics};
+use crate::next_solver::DbInterner;
+use crate::next_solver::mapping::{ChalkToNextSolver, NextSolverToChalk};
 use crate::{
     AliasTy, Const, ConstScalar, DynTyExt, GenericArg, GenericArgData, Interner, Lifetime,
     LifetimeData, Ty, TyKind,
@@ -238,14 +240,15 @@ impl Context<'_> {
             }
             GenericDefId::FunctionId(f) => {
                 let subst = self.generics.placeholder_subst(self.db);
-                self.add_constraints_from_sig(
-                    self.db
-                        .callable_item_signature(f.into())
-                        .substitute(Interner, &subst)
-                        .params_and_return
-                        .iter(),
-                    Variance::Covariant,
-                );
+                let interner = DbInterner::new_with(self.db, None, None);
+                let args: crate::next_solver::GenericArgs<'_> = subst.to_nextsolver(interner);
+                let sig = self
+                    .db
+                    .callable_item_signature(f.into())
+                    .instantiate(interner, args)
+                    .skip_binder()
+                    .to_chalk(interner);
+                self.add_constraints_from_sig(sig.params_and_return.iter(), Variance::Covariant);
             }
             _ => {}
         }
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index 8b440611e6ccd..709d165e0b8b0 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -2287,7 +2287,13 @@ impl Function {
     pub fn fn_ptr_type(self, db: &dyn HirDatabase) -> Type<'_> {
         let resolver = self.id.resolver(db);
         let substs = TyBuilder::placeholder_subst(db, self.id);
-        let callable_sig = db.callable_item_signature(self.id.into()).substitute(Interner, &substs);
+        let interner = DbInterner::new_with(db, None, None);
+        let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);
+        let callable_sig = db
+            .callable_item_signature(self.id.into())
+            .instantiate(interner, args)
+            .skip_binder()
+            .to_chalk(interner);
         let ty = TyKind::Function(callable_sig.to_fn_ptr()).intern(Interner);
         Type::new_with_resolver_inner(db, &resolver, ty)
     }
@@ -2296,8 +2302,14 @@ impl Function {
     pub fn ret_type(self, db: &dyn HirDatabase) -> Type<'_> {
         let resolver = self.id.resolver(db);
         let substs = TyBuilder::placeholder_subst(db, self.id);
-        let callable_sig = db.callable_item_signature(self.id.into()).substitute(Interner, &substs);
-        let ty = callable_sig.ret().clone();
+        let interner = DbInterner::new_with(db, None, None);
+        let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);
+        let ty = db
+            .callable_item_signature(self.id.into())
+            .instantiate(interner, args)
+            .skip_binder()
+            .output()
+            .to_chalk(interner);
         Type::new_with_resolver_inner(db, &resolver, ty)
     }
 
@@ -2326,8 +2338,14 @@ impl Function {
             parent_id.map(|id| TyBuilder::subst_for_def(db, id, None).fill(&mut filler).build());
         let substs = TyBuilder::subst_for_def(db, self.id, parent_substs).fill(&mut filler).build();
 
-        let callable_sig = db.callable_item_signature(self.id.into()).substitute(Interner, &substs);
-        let ty = callable_sig.ret().clone();
+        let interner = DbInterner::new_with(db, None, None);
+        let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);
+        let ty = db
+            .callable_item_signature(self.id.into())
+            .instantiate(interner, args)
+            .skip_binder()
+            .output()
+            .to_chalk(interner);
         Type::new_with_resolver_inner(db, &resolver, ty)
     }
 
@@ -2337,8 +2355,14 @@ impl Function {
         }
         let resolver = self.id.resolver(db);
         let substs = TyBuilder::placeholder_subst(db, self.id);
-        let callable_sig = db.callable_item_signature(self.id.into()).substitute(Interner, &substs);
-        let ret_ty = callable_sig.ret().clone();
+        let interner = DbInterner::new_with(db, None, None);
+        let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);
+        let ret_ty = db
+            .callable_item_signature(self.id.into())
+            .instantiate(interner, args)
+            .skip_binder()
+            .output()
+            .to_chalk(interner);
         for pred in ret_ty.impl_trait_bounds(db).into_iter().flatten() {
             if let WhereClause::AliasEq(output_eq) = pred.into_value_and_skipped_binders().0 {
                 return Type::new_with_resolver_inner(db, &resolver, output_eq.ty).into();
@@ -2358,7 +2382,13 @@ impl Function {
     pub fn assoc_fn_params(self, db: &dyn HirDatabase) -> Vec<Param<'_>> {
         let environment = db.trait_environment(self.id.into());
         let substs = TyBuilder::placeholder_subst(db, self.id);
-        let callable_sig = db.callable_item_signature(self.id.into()).substitute(Interner, &substs);
+        let interner = DbInterner::new_with(db, None, None);
+        let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);
+        let callable_sig = db
+            .callable_item_signature(self.id.into())
+            .instantiate(interner, args)
+            .skip_binder()
+            .to_chalk(interner);
         callable_sig
             .params()
             .iter()
@@ -2386,7 +2416,13 @@ impl Function {
     pub fn params_without_self(self, db: &dyn HirDatabase) -> Vec<Param<'_>> {
         let environment = db.trait_environment(self.id.into());
         let substs = TyBuilder::placeholder_subst(db, self.id);
-        let callable_sig = db.callable_item_signature(self.id.into()).substitute(Interner, &substs);
+        let interner = DbInterner::new_with(db, None, None);
+        let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);
+        let callable_sig = db
+            .callable_item_signature(self.id.into())
+            .instantiate(interner, args)
+            .skip_binder()
+            .to_chalk(interner);
         let skip = if db.function_signature(self.id).has_self_param() { 1 } else { 0 };
         callable_sig
             .params()
@@ -2436,7 +2472,13 @@ impl Function {
                 GenericArg::new(Interner, GenericArgData::Ty(ty))
             })
             .build();
-        let callable_sig = db.callable_item_signature(self.id.into()).substitute(Interner, &substs);
+        let interner = DbInterner::new_with(db, None, None);
+        let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);
+        let callable_sig = db
+            .callable_item_signature(self.id.into())
+            .instantiate(interner, args)
+            .skip_binder()
+            .to_chalk(interner);
         let skip = if db.function_signature(self.id).has_self_param() { 1 } else { 0 };
         callable_sig
             .params()
@@ -2731,8 +2773,13 @@ impl SelfParam {
 
     pub fn ty<'db>(&self, db: &'db dyn HirDatabase) -> Type<'db> {
         let substs = TyBuilder::placeholder_subst(db, self.func);
-        let callable_sig =
-            db.callable_item_signature(self.func.into()).substitute(Interner, &substs);
+        let interner = DbInterner::new_with(db, None, None);
+        let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);
+        let callable_sig = db
+            .callable_item_signature(self.func.into())
+            .instantiate(interner, args)
+            .skip_binder()
+            .to_chalk(interner);
         let environment = db.trait_environment(self.func.into());
         let ty = callable_sig.params()[0].clone();
         Type { env: environment, ty, _pd: PhantomCovariantLifetime::new() }
@@ -2764,8 +2811,13 @@ impl SelfParam {
         let parent_substs = TyBuilder::subst_for_def(db, parent_id, None).fill(&mut filler).build();
         let substs =
             TyBuilder::subst_for_def(db, self.func, Some(parent_substs)).fill(&mut filler).build();
-        let callable_sig =
-            db.callable_item_signature(self.func.into()).substitute(Interner, &substs);
+        let interner = DbInterner::new_with(db, None, None);
+        let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);
+        let callable_sig = db
+            .callable_item_signature(self.func.into())
+            .instantiate(interner, args)
+            .skip_binder()
+            .to_chalk(interner);
         let environment = db.trait_environment(self.func.into());
         let ty = callable_sig.params()[0].clone();
         Type { env: environment, ty, _pd: PhantomCovariantLifetime::new() }
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
index cdb1ad8b38e71..77a94403abb94 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs
@@ -1,6 +1,7 @@
 //! Module responsible for analyzing the code surrounding the cursor for completion.
 use std::iter;
 
+use base_db::salsa;
 use hir::{ExpandResult, InFile, Semantics, Type, TypeInfo, Variant};
 use ide_db::{RootDatabase, active_parameter::ActiveParameter};
 use itertools::Either;
@@ -85,9 +86,15 @@ pub(super) fn expand_and_analyze<'db>(
     let original_offset = expansion.original_offset + relative_offset;
     let token = expansion.original_file.token_at_offset(original_offset).left_biased()?;
 
-    analyze(sema, expansion, original_token, &token).map(|(analysis, expected, qualifier_ctx)| {
-        AnalysisResult { analysis, expected, qualifier_ctx, token, original_offset }
-    })
+    salsa::attach(sema.db, || analyze(sema, expansion, original_token, &token)).map(
+        |(analysis, expected, qualifier_ctx)| AnalysisResult {
+            analysis,
+            expected,
+            qualifier_ctx,
+            token,
+            original_offset,
+        },
+    )
 }
 
 fn token_at_offset_ignore_whitespace(file: &SyntaxNode, offset: TextSize) -> Option<SyntaxToken> {
diff --git a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/bind_pat.rs b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/bind_pat.rs
index 104740cbbf74a..b7c124139608b 100644
--- a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/bind_pat.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/bind_pat.rs
@@ -380,7 +380,7 @@ fn main() {
     let foo = foo4();
      // ^^^ &dyn Fn(f64, f64) -> u32
     let foo = foo5();
-     // ^^^ &dyn Fn(&dyn Fn(f64, f64) -> u32, f64) -> u32
+     // ^^^ &dyn Fn(&(dyn Fn(f64, f64) -> u32 + 'static), f64) -> u32
     let foo = foo6();
      // ^^^ impl Fn(f64, f64) -> u32
     let foo = foo7();
diff --git a/src/tools/rust-analyzer/crates/ide/src/signature_help.rs b/src/tools/rust-analyzer/crates/ide/src/signature_help.rs
index e74d997e97c52..6f55886adca48 100644
--- a/src/tools/rust-analyzer/crates/ide/src/signature_help.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/signature_help.rs
@@ -1097,8 +1097,8 @@ fn foo(mut r: impl WriteHandler<()>) {
 
                 By default this method stops actor's `Context`.
                 ------
-                fn finished(&mut self, ctx: &mut <impl WriteHandler<()> as Actor>::Context)
-                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+                fn finished(&mut self, ctx: &mut <impl WriteHandler<()> as Actor>::Context<()>)
+                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
             "#]],
         );
     }

From 8337750474dce91d285accf351c561582c1ede25 Mon Sep 17 00:00:00 2001
From: Jack Huey <31162821+jackh726@users.noreply.github.com>
Date: Tue, 23 Sep 2025 03:47:30 -0400
Subject: [PATCH 1318/1889] Remove all non-ns diagnostics queries, naming
 consistenly

---
 .../rust-analyzer/crates/hir-ty/src/db.rs     | 132 ++++++++----------
 .../crates/hir-ty/src/dyn_compatibility.rs    |   2 +-
 .../rust-analyzer/crates/hir-ty/src/lower.rs  |  64 ++-------
 .../crates/hir-ty/src/lower_nextsolver.rs     |  20 ++-
 .../crates/hir-ty/src/next_solver/interner.rs |   2 +-
 .../crates/hir-ty/src/tests/incremental.rs    |   6 -
 src/tools/rust-analyzer/crates/hir/src/lib.rs |  18 +--
 7 files changed, 90 insertions(+), 154 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
index 84c6c0471b5b3..42f7ec6b59fd3 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
@@ -121,9 +121,12 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
         def: TyDefId,
     ) -> crate::next_solver::EarlyBinder<'db, crate::next_solver::Ty<'db>>;
 
-    #[salsa::invoke(crate::lower::type_for_type_alias_with_diagnostics_query)]
-    #[salsa::cycle(cycle_result = crate::lower::type_for_type_alias_with_diagnostics_cycle_result)]
-    fn type_for_type_alias_with_diagnostics(&self, def: TypeAliasId) -> (Binders<Ty>, Diagnostics);
+    #[salsa::invoke(crate::lower_nextsolver::type_for_type_alias_with_diagnostics_query)]
+    #[salsa::cycle(cycle_result = crate::lower_nextsolver::type_for_type_alias_with_diagnostics_cycle_result)]
+    fn type_for_type_alias_with_diagnostics<'db>(
+        &'db self,
+        def: TypeAliasId,
+    ) -> (crate::next_solver::EarlyBinder<'db, crate::next_solver::Ty<'db>>, Diagnostics);
 
     /// Returns the type of the value of the given constant, or `None` if the `ValueTyDefId` is
     /// a `StructId` or `EnumVariantId` with a record constructor.
@@ -133,35 +136,56 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
         def: ValueTyDefId,
     ) -> Option<crate::next_solver::EarlyBinder<'db, crate::next_solver::Ty<'db>>>;
 
-    #[salsa::invoke(crate::lower::impl_self_ty_with_diagnostics_query)]
-    #[salsa::cycle(cycle_result = crate::lower::impl_self_ty_with_diagnostics_cycle_result)]
-    fn impl_self_ty_with_diagnostics(&self, def: ImplId) -> (Binders<Ty>, Diagnostics);
+    #[salsa::invoke(crate::lower_nextsolver::impl_self_ty_with_diagnostics_query)]
+    #[salsa::cycle(cycle_result = crate::lower_nextsolver::impl_self_ty_with_diagnostics_cycle_result)]
+    fn impl_self_ty_with_diagnostics<'db>(
+        &'db self,
+        def: ImplId,
+    ) -> (crate::next_solver::EarlyBinder<'db, crate::next_solver::Ty<'db>>, Diagnostics);
 
     #[salsa::invoke(crate::lower::impl_self_ty_query)]
     #[salsa::transparent]
     fn impl_self_ty(&self, def: ImplId) -> Binders<Ty>;
 
     // FIXME: Make this a non-interned query.
-    #[salsa::invoke_interned(crate::lower::const_param_ty_with_diagnostics_query)]
-    #[salsa::cycle(cycle_result = crate::lower::const_param_ty_with_diagnostics_cycle_result)]
-    fn const_param_ty_with_diagnostics(&self, def: ConstParamId) -> (Ty, Diagnostics);
+    #[salsa::invoke_interned(crate::lower_nextsolver::const_param_ty_with_diagnostics_query)]
+    #[salsa::cycle(cycle_result = crate::lower_nextsolver::const_param_ty_with_diagnostics_cycle_result)]
+    fn const_param_ty_with_diagnostics<'db>(
+        &'db self,
+        def: ConstParamId,
+    ) -> (crate::next_solver::Ty<'db>, Diagnostics);
 
-    #[salsa::invoke(crate::lower::const_param_ty_query)]
-    #[salsa::transparent]
+    // FIXME: Make this a non-interned query.
+    #[salsa::invoke_interned(crate::lower::const_param_ty_query)]
+    #[salsa::cycle(cycle_result = crate::lower::const_param_ty_cycle_result)]
     fn const_param_ty(&self, def: ConstParamId) -> Ty;
 
-    #[salsa::invoke(crate::lower::impl_trait_with_diagnostics_query)]
-    fn impl_trait_with_diagnostics(&self, def: ImplId) -> Option<(Binders<TraitRef>, Diagnostics)>;
+    #[salsa::invoke(crate::lower_nextsolver::impl_trait_with_diagnostics_query)]
+    fn impl_trait_with_diagnostics<'db>(
+        &'db self,
+        def: ImplId,
+    ) -> Option<(
+        crate::next_solver::EarlyBinder<'db, crate::next_solver::TraitRef<'db>>,
+        Diagnostics,
+    )>;
 
     #[salsa::invoke(crate::lower::impl_trait_query)]
     #[salsa::transparent]
     fn impl_trait(&self, def: ImplId) -> Option<Binders<TraitRef>>;
 
-    #[salsa::invoke(crate::lower::field_types_with_diagnostics_query)]
-    fn field_types_with_diagnostics(
-        &self,
+    #[salsa::invoke(crate::lower_nextsolver::field_types_with_diagnostics_query)]
+    fn field_types_with_diagnostics<'db>(
+        &'db self,
         var: VariantId,
-    ) -> (Arc<ArenaMap<LocalFieldId, Binders<Ty>>>, Diagnostics);
+    ) -> (
+        Arc<
+            ArenaMap<
+                LocalFieldId,
+                crate::next_solver::EarlyBinder<'db, crate::next_solver::Ty<'db>>,
+            >,
+        >,
+        Diagnostics,
+    );
 
     #[salsa::invoke(crate::lower::field_types_query)]
     #[salsa::transparent]
@@ -191,6 +215,21 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
     #[salsa::invoke(crate::lower::generic_predicates_query)]
     fn generic_predicates(&self, def: GenericDefId) -> GenericPredicates;
 
+    #[salsa::invoke(
+        crate::lower_nextsolver::generic_predicates_without_parent_with_diagnostics_query
+    )]
+    fn generic_predicates_without_parent_with_diagnostics<'db>(
+        &'db self,
+        def: GenericDefId,
+    ) -> (crate::lower_nextsolver::GenericPredicates<'db>, Diagnostics);
+
+    #[salsa::invoke(crate::lower_nextsolver::generic_predicates_without_parent_query)]
+    #[salsa::transparent]
+    fn generic_predicates_without_parent<'db>(
+        &'db self,
+        def: GenericDefId,
+    ) -> crate::lower_nextsolver::GenericPredicates<'db>;
+
     #[salsa::invoke(crate::lower_nextsolver::trait_environment_for_body_query)]
     #[salsa::transparent]
     fn trait_environment_for_body<'db>(&'db self, def: DefWithBodyId)
@@ -286,20 +325,6 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
 
     // next trait solver
 
-    #[salsa::invoke(crate::lower_nextsolver::type_for_type_alias_with_diagnostics_query)]
-    #[salsa::cycle(cycle_result = crate::lower_nextsolver::type_for_type_alias_with_diagnostics_cycle_result)]
-    fn type_for_type_alias_with_diagnostics_ns<'db>(
-        &'db self,
-        def: TypeAliasId,
-    ) -> (crate::next_solver::EarlyBinder<'db, crate::next_solver::Ty<'db>>, Diagnostics);
-
-    #[salsa::invoke(crate::lower_nextsolver::impl_self_ty_with_diagnostics_query)]
-    #[salsa::cycle(cycle_result = crate::lower_nextsolver::impl_self_ty_with_diagnostics_cycle_result)]
-    fn impl_self_ty_with_diagnostics_ns<'db>(
-        &'db self,
-        def: ImplId,
-    ) -> (crate::next_solver::EarlyBinder<'db, crate::next_solver::Ty<'db>>, Diagnostics);
-
     #[salsa::invoke(crate::lower_nextsolver::impl_self_ty_query)]
     #[salsa::transparent]
     fn impl_self_ty_ns<'db>(
@@ -307,26 +332,10 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
         def: ImplId,
     ) -> crate::next_solver::EarlyBinder<'db, crate::next_solver::Ty<'db>>;
 
-    // FIXME: Make this a non-interned query.
-    #[salsa::invoke_interned(crate::lower_nextsolver::const_param_ty_with_diagnostics_query)]
-    fn const_param_ty_with_diagnostics_ns<'db>(
-        &'db self,
-        def: ConstParamId,
-    ) -> (crate::next_solver::Ty<'db>, Diagnostics);
-
     #[salsa::invoke(crate::lower_nextsolver::const_param_ty_query)]
     #[salsa::transparent]
     fn const_param_ty_ns<'db>(&'db self, def: ConstParamId) -> crate::next_solver::Ty<'db>;
 
-    #[salsa::invoke(crate::lower_nextsolver::impl_trait_with_diagnostics_query)]
-    fn impl_trait_with_diagnostics_ns<'db>(
-        &'db self,
-        def: ImplId,
-    ) -> Option<(
-        crate::next_solver::EarlyBinder<'db, crate::next_solver::TraitRef<'db>>,
-        Diagnostics,
-    )>;
-
     #[salsa::invoke(crate::lower_nextsolver::impl_trait_query)]
     #[salsa::transparent]
     fn impl_trait_ns<'db>(
@@ -334,20 +343,6 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
         def: ImplId,
     ) -> Option<crate::next_solver::EarlyBinder<'db, crate::next_solver::TraitRef<'db>>>;
 
-    #[salsa::invoke(crate::lower_nextsolver::field_types_with_diagnostics_query)]
-    fn field_types_with_diagnostics_ns<'db>(
-        &'db self,
-        var: VariantId,
-    ) -> (
-        Arc<
-            ArenaMap<
-                LocalFieldId,
-                crate::next_solver::EarlyBinder<'db, crate::next_solver::Ty<'db>>,
-            >,
-        >,
-        Diagnostics,
-    );
-
     #[salsa::invoke(crate::lower_nextsolver::field_types_query)]
     #[salsa::transparent]
     fn field_types_ns<'db>(
@@ -383,21 +378,6 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
         &'db self,
         def: GenericDefId,
     ) -> crate::lower_nextsolver::GenericPredicates<'db>;
-
-    #[salsa::invoke(
-        crate::lower_nextsolver::generic_predicates_without_parent_with_diagnostics_query
-    )]
-    fn generic_predicates_without_parent_with_diagnostics_ns<'db>(
-        &'db self,
-        def: GenericDefId,
-    ) -> (crate::lower_nextsolver::GenericPredicates<'db>, Diagnostics);
-
-    #[salsa::invoke(crate::lower_nextsolver::generic_predicates_without_parent_query)]
-    #[salsa::transparent]
-    fn generic_predicates_without_parent_ns<'db>(
-        &'db self,
-        def: GenericDefId,
-    ) -> crate::lower_nextsolver::GenericPredicates<'db>;
 }
 
 #[test]
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
index f033c511acd6a..b2406a0889583 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/dyn_compatibility.rs
@@ -364,7 +364,7 @@ where
         cb(MethodViolationCode::UndispatchableReceiver)?;
     }
 
-    let predicates = &*db.generic_predicates_without_parent_ns(func.into());
+    let predicates = &*db.generic_predicates_without_parent(func.into());
     for pred in predicates {
         let pred = pred.kind().skip_binder();
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
index 598fd38b4b8e9..b55f9cd145e26 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
@@ -32,7 +32,7 @@ use hir_def::{
     hir::generics::{GenericParamDataRef, TypeOrConstParamData, WherePredicate},
     lang_item::LangItem,
     resolver::{HasResolver, LifetimeNs, Resolver, TypeNs},
-    signatures::{FunctionSignature, TraitFlags, TypeAliasFlags},
+    signatures::{FunctionSignature, TraitFlags},
     type_ref::{
         ConstRef, LifetimeRefId, LiteralConstRef, PathId, TraitBoundModifier,
         TraitRef as HirTraitRef, TypeBound, TypeRef, TypeRefId,
@@ -908,7 +908,7 @@ pub(crate) fn field_types_query(
     db: &dyn HirDatabase,
     variant_id: VariantId,
 ) -> Arc<ArenaMap<LocalFieldId, Binders<Ty>>> {
-    db.field_types_with_diagnostics(variant_id).0
+    field_types_with_diagnostics_query(db, variant_id).0
 }
 
 /// Build the type of all specific fields of a struct or enum variant.
@@ -1303,46 +1303,6 @@ pub(crate) fn generic_defaults_with_diagnostics_cycle_result(
     (GenericDefaults(None), None)
 }
 
-pub(crate) fn type_for_type_alias_with_diagnostics_query(
-    db: &dyn HirDatabase,
-    t: TypeAliasId,
-) -> (Binders<Ty>, Diagnostics) {
-    let generics = generics(db, t.into());
-    let type_alias_data = db.type_alias_signature(t);
-    let mut diags = None;
-    let inner = if type_alias_data.flags.contains(TypeAliasFlags::IS_EXTERN) {
-        TyKind::Foreign(crate::to_foreign_def_id(t)).intern(Interner)
-    } else {
-        let resolver = t.resolver(db);
-        let alias = db.type_alias_signature(t);
-        let mut ctx = TyLoweringContext::new(
-            db,
-            &resolver,
-            &alias.store,
-            t.into(),
-            LifetimeElisionKind::AnonymousReportError,
-        )
-        .with_impl_trait_mode(ImplTraitLoweringMode::Opaque)
-        .with_type_param_mode(ParamLoweringMode::Variable);
-        let res = alias
-            .ty
-            .map(|type_ref| ctx.lower_ty(type_ref))
-            .unwrap_or_else(|| TyKind::Error.intern(Interner));
-        diags = create_diagnostics(ctx.diagnostics);
-        res
-    };
-
-    (make_binders(db, &generics, inner), diags)
-}
-
-pub(crate) fn type_for_type_alias_with_diagnostics_cycle_result(
-    db: &dyn HirDatabase,
-    adt: TypeAliasId,
-) -> (Binders<Ty>, Diagnostics) {
-    let generics = generics(db, adt.into());
-    (make_binders(db, &generics, TyKind::Error.intern(Interner)), None)
-}
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum TyDefId {
     BuiltinType(BuiltinType),
@@ -1376,7 +1336,7 @@ impl ValueTyDefId {
 }
 
 pub(crate) fn impl_self_ty_query(db: &dyn HirDatabase, impl_id: ImplId) -> Binders<Ty> {
-    db.impl_self_ty_with_diagnostics(impl_id).0
+    impl_self_ty_with_diagnostics_query(db, impl_id).0
 }
 
 pub(crate) fn impl_self_ty_with_diagnostics_query(
@@ -1400,16 +1360,8 @@ pub(crate) fn impl_self_ty_with_diagnostics_query(
     )
 }
 
-pub(crate) fn impl_self_ty_with_diagnostics_cycle_result(
-    db: &dyn HirDatabase,
-    impl_id: ImplId,
-) -> (Binders<Ty>, Diagnostics) {
-    let generics = generics(db, impl_id.into());
-    (make_binders(db, &generics, TyKind::Error.intern(Interner)), None)
-}
-
 pub(crate) fn const_param_ty_query(db: &dyn HirDatabase, def: ConstParamId) -> Ty {
-    db.const_param_ty_with_diagnostics(def).0
+    const_param_ty_with_diagnostics_query(db, def).0
 }
 
 // returns None if def is a type arg
@@ -1437,16 +1389,16 @@ pub(crate) fn const_param_ty_with_diagnostics_query(
     (ty, create_diagnostics(ctx.diagnostics))
 }
 
-pub(crate) fn const_param_ty_with_diagnostics_cycle_result(
+pub(crate) fn const_param_ty_cycle_result(
     _: &dyn HirDatabase,
     _: crate::db::HirDatabaseData,
     _: ConstParamId,
-) -> (Ty, Diagnostics) {
-    (TyKind::Error.intern(Interner), None)
+) -> Ty {
+    TyKind::Error.intern(Interner)
 }
 
 pub(crate) fn impl_trait_query(db: &dyn HirDatabase, impl_id: ImplId) -> Option<Binders<TraitRef>> {
-    db.impl_trait_with_diagnostics(impl_id).map(|it| it.0)
+    impl_trait_with_diagnostics_query(db, impl_id).map(|it| it.0)
 }
 
 pub(crate) fn impl_trait_with_diagnostics_query(
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
index 1ca56feb099a1..a537d3a101710 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
@@ -904,7 +904,7 @@ pub(crate) fn impl_trait_query<'db>(
     db: &'db dyn HirDatabase,
     impl_id: ImplId,
 ) -> Option<EarlyBinder<'db, TraitRef<'db>>> {
-    db.impl_trait_with_diagnostics_ns(impl_id).map(|it| it.0)
+    db.impl_trait_with_diagnostics(impl_id).map(|it| it.0)
 }
 
 pub(crate) fn impl_trait_with_diagnostics_query<'db>(
@@ -986,7 +986,7 @@ pub(crate) fn ty_query<'db>(db: &'db dyn HirDatabase, def: TyDefId) -> EarlyBind
             AdtDef::new(it, interner),
             GenericArgs::identity_for_item(interner, it.into()),
         )),
-        TyDefId::TypeAliasId(it) => db.type_for_type_alias_with_diagnostics_ns(it).0,
+        TyDefId::TypeAliasId(it) => db.type_for_type_alias_with_diagnostics(it).0,
     }
 }
 
@@ -1131,7 +1131,7 @@ pub(crate) fn impl_self_ty_query<'db>(
     db: &'db dyn HirDatabase,
     impl_id: ImplId,
 ) -> EarlyBinder<'db, Ty<'db>> {
-    db.impl_self_ty_with_diagnostics_ns(impl_id).0
+    db.impl_self_ty_with_diagnostics(impl_id).0
 }
 
 pub(crate) fn impl_self_ty_with_diagnostics_query<'db>(
@@ -1162,7 +1162,7 @@ pub(crate) fn impl_self_ty_with_diagnostics_cycle_result(
 }
 
 pub(crate) fn const_param_ty_query<'db>(db: &'db dyn HirDatabase, def: ConstParamId) -> Ty<'db> {
-    db.const_param_ty_with_diagnostics_ns(def).0
+    db.const_param_ty_with_diagnostics(def).0
 }
 
 // returns None if def is a type arg
@@ -1191,11 +1191,21 @@ pub(crate) fn const_param_ty_with_diagnostics_query<'db>(
     (ty, create_diagnostics(ctx.diagnostics))
 }
 
+pub(crate) fn const_param_ty_with_diagnostics_cycle_result<'db>(
+    db: &'db dyn HirDatabase,
+    _: crate::db::HirDatabaseData,
+    def: ConstParamId,
+) -> (Ty<'db>, Diagnostics) {
+    let resolver = def.parent().resolver(db);
+    let interner = DbInterner::new_with(db, Some(resolver.krate()), None);
+    (Ty::new_error(interner, ErrorGuaranteed), None)
+}
+
 pub(crate) fn field_types_query<'db>(
     db: &'db dyn HirDatabase,
     variant_id: VariantId,
 ) -> Arc<ArenaMap<LocalFieldId, EarlyBinder<'db, Ty<'db>>>> {
-    db.field_types_with_diagnostics_ns(variant_id).0
+    db.field_types_with_diagnostics(variant_id).0
 }
 
 /// Build the type of all specific fields of a struct or enum variant.
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
index 1a14ac9a7457b..3ff9fde9768b2 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
@@ -1320,7 +1320,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
         self,
         def_id: Self::DefId,
     ) -> EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>> {
-        let predicates = self.db().generic_predicates_without_parent_ns(def_id.try_into().unwrap());
+        let predicates = self.db().generic_predicates_without_parent(def_id.try_into().unwrap());
         let predicates: Vec<_> = predicates.iter().cloned().collect();
         EarlyBinder::bind(predicates.into_iter())
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
index 0d922de9aeb07..cc5ad2045ed4f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
@@ -504,10 +504,8 @@ impl SomeStruct {
                 "crate_local_def_map",
                 "trait_impls_in_crate_shim",
                 "attrs_shim",
-                "impl_trait_with_diagnostics_shim",
                 "impl_signature_shim",
                 "impl_signature_with_source_map_shim",
-                "impl_self_ty_with_diagnostics_shim",
                 "struct_signature_shim",
                 "struct_signature_with_source_map_shim",
                 "attrs_shim",
@@ -608,8 +606,6 @@ fn main() {
                 "trait_impls_in_crate_shim",
                 "impl_trait_with_diagnostics_shim",
                 "impl_self_ty_with_diagnostics_shim",
-                "impl_trait_with_diagnostics_ns_shim",
-                "impl_self_ty_with_diagnostics_ns_shim",
                 "generic_predicates_ns_shim",
                 "value_ty_shim",
                 "generic_predicates_shim",
@@ -698,8 +694,6 @@ fn main() {
                 "trait_impls_in_crate_shim",
                 "impl_trait_with_diagnostics_shim",
                 "impl_self_ty_with_diagnostics_shim",
-                "impl_trait_with_diagnostics_ns_shim",
-                "impl_self_ty_with_diagnostics_ns_shim",
                 "generic_predicates_ns_shim",
                 "generic_predicates_shim",
             ]
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index 709d165e0b8b0..5592ca285fb01 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -682,7 +682,7 @@ impl Module {
                             push_ty_diagnostics(
                                 db,
                                 acc,
-                                db.field_types_with_diagnostics_ns(s.id.into()).1,
+                                db.field_types_with_diagnostics(s.id.into()).1,
                                 source_map,
                             );
                         }
@@ -694,7 +694,7 @@ impl Module {
                             push_ty_diagnostics(
                                 db,
                                 acc,
-                                db.field_types_with_diagnostics_ns(u.id.into()).1,
+                                db.field_types_with_diagnostics(u.id.into()).1,
                                 source_map,
                             );
                         }
@@ -724,7 +724,7 @@ impl Module {
                                 push_ty_diagnostics(
                                     db,
                                     acc,
-                                    db.field_types_with_diagnostics_ns(v.into()).1,
+                                    db.field_types_with_diagnostics(v.into()).1,
                                     source_map,
                                 );
                                 expr_store_diagnostics(db, acc, source_map);
@@ -740,7 +740,7 @@ impl Module {
                     push_ty_diagnostics(
                         db,
                         acc,
-                        db.type_for_type_alias_with_diagnostics_ns(type_alias.id).1,
+                        db.type_for_type_alias_with_diagnostics(type_alias.id).1,
                         &source_map,
                     );
                     acc.extend(def.diagnostics(db, style_lints));
@@ -915,13 +915,13 @@ impl Module {
             push_ty_diagnostics(
                 db,
                 acc,
-                db.impl_self_ty_with_diagnostics_ns(impl_def.id).1,
+                db.impl_self_ty_with_diagnostics(impl_def.id).1,
                 &source_map,
             );
             push_ty_diagnostics(
                 db,
                 acc,
-                db.impl_trait_with_diagnostics_ns(impl_def.id).and_then(|it| it.1),
+                db.impl_trait_with_diagnostics(impl_def.id).and_then(|it| it.1),
                 &source_map,
             );
 
@@ -3693,7 +3693,7 @@ impl AssocItem {
                 push_ty_diagnostics(
                     db,
                     acc,
-                    db.type_for_type_alias_with_diagnostics_ns(type_alias.id).1,
+                    db.type_for_type_alias_with_diagnostics(type_alias.id).1,
                     &db.type_alias_signature_with_source_map(type_alias.id).1,
                 );
                 for diag in hir_ty::diagnostics::incorrect_case(db, type_alias.id.into()) {
@@ -3821,7 +3821,7 @@ impl GenericDef {
         push_ty_diagnostics(
             db,
             acc,
-            db.generic_predicates_without_parent_with_diagnostics_ns(def).1,
+            db.generic_predicates_without_parent_with_diagnostics(def).1,
             &source_map,
         );
         for (param_id, param) in generics.iter_type_or_consts() {
@@ -3829,7 +3829,7 @@ impl GenericDef {
                 push_ty_diagnostics(
                     db,
                     acc,
-                    db.const_param_ty_with_diagnostics_ns(ConstParamId::from_unchecked(
+                    db.const_param_ty_with_diagnostics(ConstParamId::from_unchecked(
                         TypeOrConstParamId { parent: def, local_id: param_id },
                     ))
                     .1,

From 94bf6b4da632c9f34c082e0c6464d46cf1f6b2ed Mon Sep 17 00:00:00 2001
From: Jack Huey <31162821+jackh726@users.noreply.github.com>
Date: Tue, 23 Sep 2025 15:54:29 -0400
Subject: [PATCH 1319/1889] Be sure to instantiate and pass up trait refs in
 named_associated_type_shorthand_candidates

---
 .../crates/hir-ty/src/lower_nextsolver.rs     | 23 +++++++++++--------
 .../crates/ide/src/signature_help.rs          |  4 ++--
 2 files changed, 15 insertions(+), 12 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
index a537d3a101710..02774a63df422 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
@@ -1970,7 +1970,8 @@ fn named_associated_type_shorthand_candidates<'db, R>(
     let mut search = |t: TraitRef<'db>| -> Option<R> {
         let trait_id = t.def_id.0;
         let mut checked_traits = FxHashSet::default();
-        let mut check_trait = |trait_id: TraitId| {
+        let mut check_trait = |trait_ref: TraitRef<'db>| {
+            let trait_id = trait_ref.def_id.0;
             let name = &db.trait_signature(trait_id).name;
             tracing::debug!(?trait_id, ?name);
             if !checked_traits.insert(trait_id) {
@@ -1981,37 +1982,39 @@ fn named_associated_type_shorthand_candidates<'db, R>(
             tracing::debug!(?data.items);
             for (name, assoc_id) in &data.items {
                 if let &AssocItemId::TypeAliasId(alias) = assoc_id
-                    && let Some(ty) = check_alias(name, t, alias)
+                    && let Some(ty) = check_alias(name, trait_ref, alias)
                 {
                     return Some(ty);
                 }
             }
             None
         };
-        let mut stack: SmallVec<[_; 4]> = smallvec![trait_id];
-        while let Some(trait_def_id) = stack.pop() {
-            if let Some(alias) = check_trait(trait_def_id) {
+        let mut stack: SmallVec<[_; 4]> = smallvec![t];
+        while let Some(trait_ref) = stack.pop() {
+            if let Some(alias) = check_trait(trait_ref) {
                 return Some(alias);
             }
             for pred in generic_predicates_filtered_by(
                 db,
-                GenericDefId::TraitId(trait_def_id),
+                GenericDefId::TraitId(trait_ref.def_id.0),
                 PredicateFilter::SelfTrait,
                 // We are likely in the midst of lowering generic predicates of `def`.
                 // So, if we allow `pred == def` we might fall into an infinite recursion.
                 // Actually, we have already checked for the case `pred == def` above as we started
                 // with a stack including `trait_id`
-                |pred| pred != def && pred == GenericDefId::TraitId(trait_def_id),
+                |pred| pred != def && pred == GenericDefId::TraitId(trait_ref.def_id.0),
             )
             .0
             .deref()
             {
                 tracing::debug!(?pred);
-                let trait_id = match pred.kind().skip_binder() {
-                    rustc_type_ir::ClauseKind::Trait(pred) => pred.def_id(),
+                let sup_trait_ref = match pred.kind().skip_binder() {
+                    rustc_type_ir::ClauseKind::Trait(pred) => pred.trait_ref,
                     _ => continue,
                 };
-                stack.push(trait_id.0);
+                let sup_trait_ref =
+                    EarlyBinder::bind(sup_trait_ref).instantiate(interner, trait_ref.args);
+                stack.push(sup_trait_ref);
             }
             tracing::debug!(?stack);
         }
diff --git a/src/tools/rust-analyzer/crates/ide/src/signature_help.rs b/src/tools/rust-analyzer/crates/ide/src/signature_help.rs
index 6f55886adca48..e74d997e97c52 100644
--- a/src/tools/rust-analyzer/crates/ide/src/signature_help.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/signature_help.rs
@@ -1097,8 +1097,8 @@ fn foo(mut r: impl WriteHandler<()>) {
 
                 By default this method stops actor's `Context`.
                 ------
-                fn finished(&mut self, ctx: &mut <impl WriteHandler<()> as Actor>::Context<()>)
-                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+                fn finished(&mut self, ctx: &mut <impl WriteHandler<()> as Actor>::Context)
+                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
             "#]],
         );
     }

From e8a8e061bf0187efbb33d972e31ef2b5d9f6d529 Mon Sep 17 00:00:00 2001
From: ltdk <usr@ltdk.xyz>
Date: Mon, 22 Sep 2025 21:02:53 -0400
Subject: [PATCH 1320/1889] Make missed precondition-free float intrinsics safe

---
 .../rustc_hir_analysis/src/check/intrinsic.rs    |  8 ++++++++
 library/core/src/intrinsics/mod.rs               | 16 ++++++++--------
 library/core/src/num/f128.rs                     |  3 +--
 library/core/src/num/f16.rs                      |  3 +--
 library/core/src/num/f32.rs                      |  6 ++----
 library/core/src/num/f64.rs                      |  6 ++----
 6 files changed, 22 insertions(+), 20 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/check/intrinsic.rs b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
index 6faa67f6a904a..bc3448be5823e 100644
--- a/compiler/rustc_hir_analysis/src/check/intrinsic.rs
+++ b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
@@ -90,6 +90,10 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::contract_check_ensures
         | sym::contract_check_requires
         | sym::contract_checks
+        | sym::copysignf16
+        | sym::copysignf32
+        | sym::copysignf64
+        | sym::copysignf128
         | sym::cosf16
         | sym::cosf32
         | sym::cosf64
@@ -106,6 +110,10 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::expf32
         | sym::expf64
         | sym::expf128
+        | sym::fabsf16
+        | sym::fabsf32
+        | sym::fabsf64
+        | sym::fabsf128
         | sym::fadd_algebraic
         | sym::fdiv_algebraic
         | sym::floorf16
diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs
index a174ced5a2a63..eaf2738d8b7f5 100644
--- a/library/core/src/intrinsics/mod.rs
+++ b/library/core/src/intrinsics/mod.rs
@@ -3170,7 +3170,7 @@ pub const fn maximumf128(x: f128, y: f128) -> f128 {
 /// [`f16::abs`](../../std/primitive.f16.html#method.abs)
 #[rustc_nounwind]
 #[rustc_intrinsic]
-pub const unsafe fn fabsf16(x: f16) -> f16;
+pub const fn fabsf16(x: f16) -> f16;
 
 /// Returns the absolute value of an `f32`.
 ///
@@ -3179,7 +3179,7 @@ pub const unsafe fn fabsf16(x: f16) -> f16;
 #[rustc_nounwind]
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
-pub const unsafe fn fabsf32(x: f32) -> f32;
+pub const fn fabsf32(x: f32) -> f32;
 
 /// Returns the absolute value of an `f64`.
 ///
@@ -3188,7 +3188,7 @@ pub const unsafe fn fabsf32(x: f32) -> f32;
 #[rustc_nounwind]
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
-pub const unsafe fn fabsf64(x: f64) -> f64;
+pub const fn fabsf64(x: f64) -> f64;
 
 /// Returns the absolute value of an `f128`.
 ///
@@ -3196,7 +3196,7 @@ pub const unsafe fn fabsf64(x: f64) -> f64;
 /// [`f128::abs`](../../std/primitive.f128.html#method.abs)
 #[rustc_nounwind]
 #[rustc_intrinsic]
-pub const unsafe fn fabsf128(x: f128) -> f128;
+pub const fn fabsf128(x: f128) -> f128;
 
 /// Copies the sign from `y` to `x` for `f16` values.
 ///
@@ -3204,7 +3204,7 @@ pub const unsafe fn fabsf128(x: f128) -> f128;
 /// [`f16::copysign`](../../std/primitive.f16.html#method.copysign)
 #[rustc_nounwind]
 #[rustc_intrinsic]
-pub const unsafe fn copysignf16(x: f16, y: f16) -> f16;
+pub const fn copysignf16(x: f16, y: f16) -> f16;
 
 /// Copies the sign from `y` to `x` for `f32` values.
 ///
@@ -3213,7 +3213,7 @@ pub const unsafe fn copysignf16(x: f16, y: f16) -> f16;
 #[rustc_nounwind]
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
-pub const unsafe fn copysignf32(x: f32, y: f32) -> f32;
+pub const fn copysignf32(x: f32, y: f32) -> f32;
 /// Copies the sign from `y` to `x` for `f64` values.
 ///
 /// The stabilized version of this intrinsic is
@@ -3221,7 +3221,7 @@ pub const unsafe fn copysignf32(x: f32, y: f32) -> f32;
 #[rustc_nounwind]
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
-pub const unsafe fn copysignf64(x: f64, y: f64) -> f64;
+pub const fn copysignf64(x: f64, y: f64) -> f64;
 
 /// Copies the sign from `y` to `x` for `f128` values.
 ///
@@ -3229,7 +3229,7 @@ pub const unsafe fn copysignf64(x: f64, y: f64) -> f64;
 /// [`f128::copysign`](../../std/primitive.f128.html#method.copysign)
 #[rustc_nounwind]
 #[rustc_intrinsic]
-pub const unsafe fn copysignf128(x: f128, y: f128) -> f128;
+pub const fn copysignf128(x: f128, y: f128) -> f128;
 
 /// Generates the LLVM body for the automatic differentiation of `f` using Enzyme,
 /// with `df` as the derivative function and `args` as its arguments.
diff --git a/library/core/src/num/f128.rs b/library/core/src/num/f128.rs
index 6088fb6fa1786..54d2d1c5706b7 100644
--- a/library/core/src/num/f128.rs
+++ b/library/core/src/num/f128.rs
@@ -1366,8 +1366,7 @@ impl f128 {
     #[rustc_const_unstable(feature = "f128", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn copysign(self, sign: f128) -> f128 {
-        // SAFETY: this is actually a safe intrinsic
-        unsafe { intrinsics::copysignf128(self, sign) }
+        intrinsics::copysignf128(self, sign)
     }
 
     /// Float addition that allows optimizations based on algebraic rules.
diff --git a/library/core/src/num/f16.rs b/library/core/src/num/f16.rs
index 3f66c5973d4ac..f3e49544d259a 100644
--- a/library/core/src/num/f16.rs
+++ b/library/core/src/num/f16.rs
@@ -1343,8 +1343,7 @@ impl f16 {
     #[rustc_const_unstable(feature = "f16", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn copysign(self, sign: f16) -> f16 {
-        // SAFETY: this is actually a safe intrinsic
-        unsafe { intrinsics::copysignf16(self, sign) }
+        intrinsics::copysignf16(self, sign)
     }
 
     /// Float addition that allows optimizations based on algebraic rules.
diff --git a/library/core/src/num/f32.rs b/library/core/src/num/f32.rs
index ebce89e5b3da5..ded70c825af93 100644
--- a/library/core/src/num/f32.rs
+++ b/library/core/src/num/f32.rs
@@ -1449,8 +1449,7 @@ impl f32 {
     #[rustc_const_stable(feature = "const_float_methods", since = "1.85.0")]
     #[inline]
     pub const fn abs(self) -> f32 {
-        // SAFETY: this is actually a safe intrinsic
-        unsafe { intrinsics::fabsf32(self) }
+        intrinsics::fabsf32(self)
     }
 
     /// Returns a number that represents the sign of `self`.
@@ -1508,8 +1507,7 @@ impl f32 {
     #[stable(feature = "copysign", since = "1.35.0")]
     #[rustc_const_stable(feature = "const_float_methods", since = "1.85.0")]
     pub const fn copysign(self, sign: f32) -> f32 {
-        // SAFETY: this is actually a safe intrinsic
-        unsafe { intrinsics::copysignf32(self, sign) }
+        intrinsics::copysignf32(self, sign)
     }
 
     /// Float addition that allows optimizations based on algebraic rules.
diff --git a/library/core/src/num/f64.rs b/library/core/src/num/f64.rs
index 91e3949fc3900..3abdc7c108ab5 100644
--- a/library/core/src/num/f64.rs
+++ b/library/core/src/num/f64.rs
@@ -1447,8 +1447,7 @@ impl f64 {
     #[rustc_const_stable(feature = "const_float_methods", since = "1.85.0")]
     #[inline]
     pub const fn abs(self) -> f64 {
-        // SAFETY: this is actually a safe intrinsic
-        unsafe { intrinsics::fabsf64(self) }
+        intrinsics::fabsf64(self)
     }
 
     /// Returns a number that represents the sign of `self`.
@@ -1506,8 +1505,7 @@ impl f64 {
     #[rustc_const_stable(feature = "const_float_methods", since = "1.85.0")]
     #[inline]
     pub const fn copysign(self, sign: f64) -> f64 {
-        // SAFETY: this is actually a safe intrinsic
-        unsafe { intrinsics::copysignf64(self, sign) }
+        intrinsics::copysignf64(self, sign)
     }
 
     /// Float addition that allows optimizations based on algebraic rules.

From ace2e274db8165fc5bfeba1faf83e15095723229 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Tue, 23 Sep 2025 23:02:59 +0200
Subject: [PATCH 1321/1889] Cleanup: group code for `single_char_add_str` lint
 in one file

A lot of code was duplicated instead of being shared.
---
 clippy_lints/src/methods/mod.rs               |  2 -
 .../src/methods/single_char_add_str.rs        | 80 +++++++++++++++++--
 .../src/methods/single_char_insert_string.rs  | 67 ----------------
 .../src/methods/single_char_push_string.rs    | 65 ---------------
 4 files changed, 73 insertions(+), 141 deletions(-)
 delete mode 100644 clippy_lints/src/methods/single_char_insert_string.rs
 delete mode 100644 clippy_lints/src/methods/single_char_push_string.rs

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 8679689c8ad4d..3755ec37fb967 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -103,8 +103,6 @@ mod search_is_some;
 mod seek_from_current;
 mod seek_to_start_instead_of_rewind;
 mod single_char_add_str;
-mod single_char_insert_string;
-mod single_char_push_string;
 mod skip_while_next;
 mod sliced_string_as_bytes;
 mod stable_sort_primitive;
diff --git a/clippy_lints/src/methods/single_char_add_str.rs b/clippy_lints/src/methods/single_char_add_str.rs
index ef3d7acdc01ef..1248d1658d77e 100644
--- a/clippy_lints/src/methods/single_char_add_str.rs
+++ b/clippy_lints/src/methods/single_char_add_str.rs
@@ -1,14 +1,80 @@
-use crate::methods::{single_char_insert_string, single_char_push_string};
-use rustc_hir as hir;
+use super::SINGLE_CHAR_ADD_STR;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::{snippet_with_applicability, str_literal_to_char_literal};
+use rustc_ast::BorrowKind;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
+use rustc_middle::ty;
 use rustc_span::sym;
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, receiver: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>, args: &[Expr<'_>]) {
     if let Some(fn_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) {
-        match cx.tcx.get_diagnostic_name(fn_def_id) {
-            Some(sym::string_push_str) => single_char_push_string::check(cx, expr, receiver, args),
-            Some(sym::string_insert_str) => single_char_insert_string::check(cx, expr, receiver, args),
-            _ => {},
+        let mut applicability = Applicability::MachineApplicable;
+        let (short_name, arg, extra) = match cx.tcx.get_diagnostic_name(fn_def_id) {
+            Some(sym::string_insert_str) => (
+                "insert",
+                &args[1],
+                Some(|applicability| {
+                    format!(
+                        "{}, ",
+                        snippet_with_applicability(cx, args[0].span, "..", applicability)
+                    )
+                }),
+            ),
+            Some(sym::string_push_str) => ("push", &args[0], None),
+            _ => return,
+        };
+
+        if let Some(extension_string) = str_literal_to_char_literal(cx, arg, &mut applicability, false) {
+            let base_string_snippet =
+                snippet_with_applicability(cx, receiver.span.source_callsite(), "_", &mut applicability);
+            span_lint_and_sugg(
+                cx,
+                SINGLE_CHAR_ADD_STR,
+                expr.span,
+                format!("calling `{short_name}_str()` using a single-character string literal"),
+                format!("consider using `{short_name}` with a character literal"),
+                format!(
+                    "{base_string_snippet}.{short_name}({}{extension_string})",
+                    extra.map_or(String::new(), |f| f(&mut applicability))
+                ),
+                applicability,
+            );
+        } else if let ExprKind::AddrOf(BorrowKind::Ref, _, inner) = arg.kind
+            && let ExprKind::MethodCall(path_segment, method_arg, [], _) = inner.kind
+            && path_segment.ident.name == sym::to_string
+            && (is_ref_char(cx, method_arg) || is_char(cx, method_arg))
+        {
+            let base_string_snippet =
+                snippet_with_applicability(cx, receiver.span.source_callsite(), "_", &mut applicability);
+            let extension_string = match (
+                snippet_with_applicability(cx, method_arg.span.source_callsite(), "_", &mut applicability),
+                is_ref_char(cx, method_arg),
+            ) {
+                (snippet, false) => snippet,
+                (snippet, true) => format!("*{snippet}").into(),
+            };
+            span_lint_and_sugg(
+                cx,
+                SINGLE_CHAR_ADD_STR,
+                expr.span,
+                format!("calling `{short_name}_str()` using a single-character converted to string"),
+                format!("consider using `{short_name}` without `to_string()`"),
+                format!(
+                    "{base_string_snippet}.{short_name}({}{extension_string})",
+                    extra.map_or(String::new(), |f| f(&mut applicability))
+                ),
+                applicability,
+            );
         }
     }
 }
+
+fn is_ref_char(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    matches!(cx.typeck_results().expr_ty(expr).kind(), ty::Ref(_, ty, _) if ty.is_char())
+}
+
+fn is_char(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    cx.typeck_results().expr_ty(expr).is_char()
+}
diff --git a/clippy_lints/src/methods/single_char_insert_string.rs b/clippy_lints/src/methods/single_char_insert_string.rs
deleted file mode 100644
index 4a1d25deade90..0000000000000
--- a/clippy_lints/src/methods/single_char_insert_string.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::{snippet_with_applicability, str_literal_to_char_literal};
-use rustc_ast::BorrowKind;
-use rustc_errors::Applicability;
-use rustc_hir::{self as hir, ExprKind};
-use rustc_lint::LateContext;
-
-use super::SINGLE_CHAR_ADD_STR;
-
-/// lint for length-1 `str`s as argument for `insert_str`
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, receiver: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
-    let mut applicability = Applicability::MachineApplicable;
-    if let Some(extension_string) = str_literal_to_char_literal(cx, &args[1], &mut applicability, false) {
-        let base_string_snippet =
-            snippet_with_applicability(cx, receiver.span.source_callsite(), "_", &mut applicability);
-        let pos_arg = snippet_with_applicability(cx, args[0].span, "..", &mut applicability);
-        let sugg = format!("{base_string_snippet}.insert({pos_arg}, {extension_string})");
-        span_lint_and_sugg(
-            cx,
-            SINGLE_CHAR_ADD_STR,
-            expr.span,
-            "calling `insert_str()` using a single-character string literal",
-            "consider using `insert` with a character literal",
-            sugg,
-            applicability,
-        );
-    }
-
-    if let ExprKind::AddrOf(BorrowKind::Ref, _, arg) = &args[1].kind
-        && let ExprKind::MethodCall(path_segment, method_arg, [], _) = &arg.kind
-        && path_segment.ident.name == rustc_span::sym::to_string
-        && (is_ref_char(cx, method_arg) || is_char(cx, method_arg))
-    {
-        let base_string_snippet =
-            snippet_with_applicability(cx, receiver.span.source_callsite(), "..", &mut applicability);
-        let extension_string =
-            snippet_with_applicability(cx, method_arg.span.source_callsite(), "..", &mut applicability);
-        let pos_arg = snippet_with_applicability(cx, args[0].span, "..", &mut applicability);
-        let deref_string = if is_ref_char(cx, method_arg) { "*" } else { "" };
-
-        let sugg = format!("{base_string_snippet}.insert({pos_arg}, {deref_string}{extension_string})");
-        span_lint_and_sugg(
-            cx,
-            SINGLE_CHAR_ADD_STR,
-            expr.span,
-            "calling `insert_str()` using a single-character converted to string",
-            "consider using `insert` without `to_string()`",
-            sugg,
-            applicability,
-        );
-    }
-}
-
-fn is_ref_char(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
-    if cx.typeck_results().expr_ty(expr).is_ref()
-        && let rustc_middle::ty::Ref(_, ty, _) = cx.typeck_results().expr_ty(expr).kind()
-        && ty.is_char()
-    {
-        return true;
-    }
-
-    false
-}
-
-fn is_char(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
-    cx.typeck_results().expr_ty(expr).is_char()
-}
diff --git a/clippy_lints/src/methods/single_char_push_string.rs b/clippy_lints/src/methods/single_char_push_string.rs
deleted file mode 100644
index bc271d593925e..0000000000000
--- a/clippy_lints/src/methods/single_char_push_string.rs
+++ /dev/null
@@ -1,65 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::{snippet_with_applicability, str_literal_to_char_literal};
-use rustc_ast::BorrowKind;
-use rustc_errors::Applicability;
-use rustc_hir::{self as hir, ExprKind};
-use rustc_lint::LateContext;
-
-use super::SINGLE_CHAR_ADD_STR;
-
-/// lint for length-1 `str`s as argument for `push_str`
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, receiver: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
-    let mut applicability = Applicability::MachineApplicable;
-    if let Some(extension_string) = str_literal_to_char_literal(cx, &args[0], &mut applicability, false) {
-        let base_string_snippet =
-            snippet_with_applicability(cx, receiver.span.source_callsite(), "..", &mut applicability);
-        let sugg = format!("{base_string_snippet}.push({extension_string})");
-        span_lint_and_sugg(
-            cx,
-            SINGLE_CHAR_ADD_STR,
-            expr.span,
-            "calling `push_str()` using a single-character string literal",
-            "consider using `push` with a character literal",
-            sugg,
-            applicability,
-        );
-    }
-
-    if let ExprKind::AddrOf(BorrowKind::Ref, _, arg) = &args[0].kind
-        && let ExprKind::MethodCall(path_segment, method_arg, [], _) = &arg.kind
-        && path_segment.ident.name == rustc_span::sym::to_string
-        && (is_ref_char(cx, method_arg) || is_char(cx, method_arg))
-    {
-        let base_string_snippet =
-            snippet_with_applicability(cx, receiver.span.source_callsite(), "..", &mut applicability);
-        let extension_string =
-            snippet_with_applicability(cx, method_arg.span.source_callsite(), "..", &mut applicability);
-        let deref_string = if is_ref_char(cx, method_arg) { "*" } else { "" };
-
-        let sugg = format!("{base_string_snippet}.push({deref_string}{extension_string})");
-        span_lint_and_sugg(
-            cx,
-            SINGLE_CHAR_ADD_STR,
-            expr.span,
-            "calling `push_str()` using a single-character converted to string",
-            "consider using `push` without `to_string()`",
-            sugg,
-            applicability,
-        );
-    }
-}
-
-fn is_ref_char(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
-    if cx.typeck_results().expr_ty(expr).is_ref()
-        && let rustc_middle::ty::Ref(_, ty, _) = cx.typeck_results().expr_ty(expr).kind()
-        && ty.is_char()
-    {
-        return true;
-    }
-
-    false
-}
-
-fn is_char(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
-    cx.typeck_results().expr_ty(expr).is_char()
-}

From aa537824c40437d11d32c66fe16d4764b072c094 Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Wed, 24 Sep 2025 00:50:36 +0200
Subject: [PATCH 1322/1889] core: simplify `CStr::default()`

Just use a `CStr`-literal...
---
 library/core/src/ffi/c_str.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/library/core/src/ffi/c_str.rs b/library/core/src/ffi/c_str.rs
index d0b53e3a237f6..09d9b160700ca 100644
--- a/library/core/src/ffi/c_str.rs
+++ b/library/core/src/ffi/c_str.rs
@@ -179,9 +179,7 @@ impl fmt::Debug for CStr {
 impl Default for &CStr {
     #[inline]
     fn default() -> Self {
-        const SLICE: &[c_char] = &[0];
-        // SAFETY: `SLICE` is indeed pointing to a valid nul-terminated string.
-        unsafe { CStr::from_ptr(SLICE.as_ptr()) }
+        c""
     }
 }
 

From 95ddfa102af7f841c36ab8b207eb42571716b1cd Mon Sep 17 00:00:00 2001
From: dianqk <dianqk@dianqk.net>
Date: Wed, 24 Sep 2025 07:34:22 +0800
Subject: [PATCH 1323/1889] Update LLVM to 21.1.2

---
 src/llvm-project | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/llvm-project b/src/llvm-project
index 333793696b0a0..8c30b9c5098bd 160000
--- a/src/llvm-project
+++ b/src/llvm-project
@@ -1 +1 @@
-Subproject commit 333793696b0a08002acac6af983adc7a5233fc56
+Subproject commit 8c30b9c5098bdff1d3d9a2d460ee091cd1171e60

From ce677c7db80a245e1eee5b948dd6b20b4bba0423 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Tue, 23 Sep 2025 20:38:38 -0300
Subject: [PATCH 1324/1889] Update compiler/rustc_mir_transform/src/patch.rs

Co-authored-by: lcnr <rust@lcnr.de>
---
 compiler/rustc_mir_transform/src/patch.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/compiler/rustc_mir_transform/src/patch.rs b/compiler/rustc_mir_transform/src/patch.rs
index 8f2124405650a..d831ab50b1ac0 100644
--- a/compiler/rustc_mir_transform/src/patch.rs
+++ b/compiler/rustc_mir_transform/src/patch.rs
@@ -23,6 +23,8 @@ pub(crate) struct MirPatch<'tcx> {
     terminate_block: Option<(BasicBlock, UnwindTerminateReason)>,
     body_span: Span,
     next_local: usize,
+    /// The number of blocks at the start of the transformation. New blocks
+    /// get appended at the end.
     next_block: usize,
 }
 

From f5c6c9542ecfab74e654f9b7f1150d486560ae43 Mon Sep 17 00:00:00 2001
From: Caleb Zulawski <caleb.zulawski@gmail.com>
Date: Tue, 16 Sep 2025 02:23:24 -0400
Subject: [PATCH 1325/1889] Add an attribute to check the number of lanes in a
 SIMD vector after monomorphization

Unify zero-length and oversized SIMD errors
---
 .../src/attributes/crate_level.rs             | 36 ------------------
 .../src/attributes/rustc_internal.rs          | 18 +++++++++
 .../rustc_attr_parsing/src/attributes/util.rs | 37 ++++++++++++++++++-
 compiler/rustc_attr_parsing/src/context.rs    |  3 +-
 .../rustc_codegen_cranelift/src/common.rs     |  9 ++++-
 .../rustc_codegen_cranelift/src/global_asm.rs |  5 ++-
 compiler/rustc_codegen_gcc/src/context.rs     |  9 ++++-
 compiler/rustc_codegen_llvm/src/context.rs    | 11 +++++-
 compiler/rustc_feature/src/builtin_attrs.rs   |  6 +++
 .../rustc_hir/src/attrs/data_structures.rs    |  3 ++
 .../rustc_hir/src/attrs/encode_cross_crate.rs |  1 +
 .../src/hir_ty_lowering/cmse.rs               |  1 +
 compiler/rustc_middle/messages.ftl            |  6 +++
 compiler/rustc_middle/src/error.rs            |  6 +++
 compiler/rustc_middle/src/ty/layout.rs        | 26 +++++++++++++
 compiler/rustc_passes/src/check_attr.rs       |  1 +
 compiler/rustc_span/src/symbol.rs             |  1 +
 compiler/rustc_transmute/src/layout/tree.rs   |  1 +
 compiler/rustc_ty_utils/src/errors.rs         | 13 -------
 compiler/rustc_ty_utils/src/layout.rs         | 26 +++++++++++--
 .../html/templates/type_layout.html           |  5 +++
 tests/ui/simd/auxiliary/simd-lane-limit.rs    |  5 +++
 tests/ui/simd/monomorphize-too-long.rs        |  4 +-
 tests/ui/simd/monomorphize-too-long.stderr    |  6 ++-
 tests/ui/simd/monomorphize-zero-length.rs     |  4 +-
 tests/ui/simd/monomorphize-zero-length.stderr |  6 ++-
 tests/ui/simd/simd-lane-limit-err-npow2.rs    | 12 ++++++
 .../ui/simd/simd-lane-limit-err-npow2.stderr  |  8 ++++
 tests/ui/simd/simd-lane-limit-err.rs          | 11 ++++++
 tests/ui/simd/simd-lane-limit-err.stderr      |  8 ++++
 tests/ui/simd/simd-lane-limit-ok.rs           | 14 +++++++
 .../type-generic-monomorphisation-empty.rs    |  4 +-
 ...type-generic-monomorphisation-empty.stderr |  6 ++-
 ...type-generic-monomorphisation-oversized.rs |  5 +--
 ...-generic-monomorphisation-oversized.stderr |  6 ++-
 35 files changed, 245 insertions(+), 78 deletions(-)
 create mode 100644 tests/ui/simd/auxiliary/simd-lane-limit.rs
 create mode 100644 tests/ui/simd/simd-lane-limit-err-npow2.rs
 create mode 100644 tests/ui/simd/simd-lane-limit-err-npow2.stderr
 create mode 100644 tests/ui/simd/simd-lane-limit-err.rs
 create mode 100644 tests/ui/simd/simd-lane-limit-err.stderr
 create mode 100644 tests/ui/simd/simd-lane-limit-ok.rs

diff --git a/compiler/rustc_attr_parsing/src/attributes/crate_level.rs b/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
index 4611de4445997..00edafecd9a88 100644
--- a/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
@@ -1,40 +1,4 @@
-use std::num::IntErrorKind;
-
-use rustc_hir::limit::Limit;
-
 use super::prelude::*;
-use crate::session_diagnostics::LimitInvalid;
-
-impl<S: Stage> AcceptContext<'_, '_, S> {
-    fn parse_limit_int(&self, nv: &NameValueParser) -> Option<Limit> {
-        let Some(limit) = nv.value_as_str() else {
-            self.expected_string_literal(nv.value_span, Some(nv.value_as_lit()));
-            return None;
-        };
-
-        let error_str = match limit.as_str().parse() {
-            Ok(i) => return Some(Limit::new(i)),
-            Err(e) => match e.kind() {
-                IntErrorKind::PosOverflow => "`limit` is too large",
-                IntErrorKind::Empty => "`limit` must be a non-negative integer",
-                IntErrorKind::InvalidDigit => "not a valid integer",
-                IntErrorKind::NegOverflow => {
-                    panic!(
-                        "`limit` should never negatively overflow since we're parsing into a usize and we'd get Empty instead"
-                    )
-                }
-                IntErrorKind::Zero => {
-                    panic!("zero is a valid `limit` so should have returned Ok() when parsing")
-                }
-                kind => panic!("unimplemented IntErrorKind variant: {:?}", kind),
-            },
-        };
-
-        self.emit_err(LimitInvalid { span: self.attr_span, value_span: nv.value_span, error_str });
-
-        None
-    }
-}
 
 pub(crate) struct CrateNameParser;
 
diff --git a/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs b/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs
index a995549fc7c83..cf2f5c6c79024 100644
--- a/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs
@@ -49,3 +49,21 @@ impl<S: Stage> SingleAttributeParser<S> for RustcObjectLifetimeDefaultParser {
         Some(AttributeKind::RustcObjectLifetimeDefault)
     }
 }
+
+pub(crate) struct RustcSimdMonomorphizeLaneLimitParser;
+
+impl<S: Stage> SingleAttributeParser<S> for RustcSimdMonomorphizeLaneLimitParser {
+    const PATH: &[Symbol] = &[sym::rustc_simd_monomorphize_lane_limit];
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Struct)]);
+    const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N");
+
+    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
+        let ArgParser::NameValue(nv) = args else {
+            cx.expected_name_value(cx.attr_span, None);
+            return None;
+        };
+        Some(AttributeKind::RustcSimdMonomorphizeLaneLimit(cx.parse_limit_int(nv)?))
+    }
+}
diff --git a/compiler/rustc_attr_parsing/src/attributes/util.rs b/compiler/rustc_attr_parsing/src/attributes/util.rs
index 77e8c32e59d73..62b72798e9699 100644
--- a/compiler/rustc_attr_parsing/src/attributes/util.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/util.rs
@@ -1,11 +1,15 @@
+use std::num::IntErrorKind;
+
 use rustc_ast::LitKind;
 use rustc_ast::attr::AttributeExt;
 use rustc_feature::is_builtin_attr_name;
 use rustc_hir::RustcVersion;
+use rustc_hir::limit::Limit;
 use rustc_span::{Symbol, sym};
 
 use crate::context::{AcceptContext, Stage};
-use crate::parser::ArgParser;
+use crate::parser::{ArgParser, NameValueParser};
+use crate::session_diagnostics::LimitInvalid;
 
 /// Parse a rustc version number written inside string literal in an attribute,
 /// like appears in `since = "1.0.0"`. Suffixes like "-dev" and "-nightly" are
@@ -85,3 +89,34 @@ pub(crate) fn parse_single_integer<S: Stage>(
     };
     Some(num.0)
 }
+
+impl<S: Stage> AcceptContext<'_, '_, S> {
+    pub(crate) fn parse_limit_int(&self, nv: &NameValueParser) -> Option<Limit> {
+        let Some(limit) = nv.value_as_str() else {
+            self.expected_string_literal(nv.value_span, Some(nv.value_as_lit()));
+            return None;
+        };
+
+        let error_str = match limit.as_str().parse() {
+            Ok(i) => return Some(Limit::new(i)),
+            Err(e) => match e.kind() {
+                IntErrorKind::PosOverflow => "`limit` is too large",
+                IntErrorKind::Empty => "`limit` must be a non-negative integer",
+                IntErrorKind::InvalidDigit => "not a valid integer",
+                IntErrorKind::NegOverflow => {
+                    panic!(
+                        "`limit` should never negatively overflow since we're parsing into a usize and we'd get Empty instead"
+                    )
+                }
+                IntErrorKind::Zero => {
+                    panic!("zero is a valid `limit` so should have returned Ok() when parsing")
+                }
+                kind => panic!("unimplemented IntErrorKind variant: {:?}", kind),
+            },
+        };
+
+        self.emit_err(LimitInvalid { span: self.attr_span, value_span: nv.value_span, error_str });
+
+        None
+    }
+}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index d7998048be5af..72fe269b135a7 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -53,7 +53,7 @@ use crate::attributes::prototype::CustomMirParser;
 use crate::attributes::repr::{AlignParser, AlignStaticParser, ReprParser};
 use crate::attributes::rustc_internal::{
     RustcLayoutScalarValidRangeEnd, RustcLayoutScalarValidRangeStart,
-    RustcObjectLifetimeDefaultParser,
+    RustcObjectLifetimeDefaultParser, RustcSimdMonomorphizeLaneLimitParser,
 };
 use crate::attributes::semantics::MayDangleParser;
 use crate::attributes::stability::{
@@ -195,6 +195,7 @@ attribute_parsers!(
         Single<RustcLayoutScalarValidRangeEnd>,
         Single<RustcLayoutScalarValidRangeStart>,
         Single<RustcObjectLifetimeDefaultParser>,
+        Single<RustcSimdMonomorphizeLaneLimitParser>,
         Single<SanitizeParser>,
         Single<ShouldPanicParser>,
         Single<SkipDuringMethodDispatchParser>,
diff --git a/compiler/rustc_codegen_cranelift/src/common.rs b/compiler/rustc_codegen_cranelift/src/common.rs
index 2fbe5c02802ab..81b1814605a12 100644
--- a/compiler/rustc_codegen_cranelift/src/common.rs
+++ b/compiler/rustc_codegen_cranelift/src/common.rs
@@ -439,7 +439,10 @@ pub(crate) struct FullyMonomorphizedLayoutCx<'tcx>(pub(crate) TyCtxt<'tcx>);
 impl<'tcx> LayoutOfHelpers<'tcx> for FullyMonomorphizedLayoutCx<'tcx> {
     #[inline]
     fn handle_layout_err(&self, err: LayoutError<'tcx>, span: Span, ty: Ty<'tcx>) -> ! {
-        if let LayoutError::SizeOverflow(_) | LayoutError::ReferencesError(_) = err {
+        if let LayoutError::SizeOverflow(_)
+        | LayoutError::InvalidSimd { .. }
+        | LayoutError::ReferencesError(_) = err
+        {
             self.0.sess.dcx().span_fatal(span, err.to_string())
         } else {
             self.0
@@ -458,7 +461,9 @@ impl<'tcx> FnAbiOfHelpers<'tcx> for FullyMonomorphizedLayoutCx<'tcx> {
         span: Span,
         fn_abi_request: FnAbiRequest<'tcx>,
     ) -> ! {
-        if let FnAbiError::Layout(LayoutError::SizeOverflow(_)) = err {
+        if let FnAbiError::Layout(LayoutError::SizeOverflow(_) | LayoutError::InvalidSimd { .. }) =
+            err
+        {
             self.0.sess.dcx().emit_fatal(Spanned { span, node: err })
         } else {
             match fn_abi_request {
diff --git a/compiler/rustc_codegen_cranelift/src/global_asm.rs b/compiler/rustc_codegen_cranelift/src/global_asm.rs
index 203b443269fa7..1306c6aa5179c 100644
--- a/compiler/rustc_codegen_cranelift/src/global_asm.rs
+++ b/compiler/rustc_codegen_cranelift/src/global_asm.rs
@@ -42,7 +42,10 @@ impl<'tcx> AsmCodegenMethods<'tcx> for GlobalAsmContext<'_, 'tcx> {
 impl<'tcx> LayoutOfHelpers<'tcx> for GlobalAsmContext<'_, 'tcx> {
     #[inline]
     fn handle_layout_err(&self, err: LayoutError<'tcx>, span: Span, ty: Ty<'tcx>) -> ! {
-        if let LayoutError::SizeOverflow(_) | LayoutError::ReferencesError(_) = err {
+        if let LayoutError::SizeOverflow(_)
+        | LayoutError::InvalidSimd { .. }
+        | LayoutError::ReferencesError(_) = err
+        {
             self.tcx.sess.dcx().span_fatal(span, err.to_string())
         } else {
             self.tcx
diff --git a/compiler/rustc_codegen_gcc/src/context.rs b/compiler/rustc_codegen_gcc/src/context.rs
index 665cf22ddbaee..9815fb07eaae9 100644
--- a/compiler/rustc_codegen_gcc/src/context.rs
+++ b/compiler/rustc_codegen_gcc/src/context.rs
@@ -529,7 +529,10 @@ impl<'gcc, 'tcx> HasX86AbiOpt for CodegenCx<'gcc, 'tcx> {
 impl<'gcc, 'tcx> LayoutOfHelpers<'tcx> for CodegenCx<'gcc, 'tcx> {
     #[inline]
     fn handle_layout_err(&self, err: LayoutError<'tcx>, span: Span, ty: Ty<'tcx>) -> ! {
-        if let LayoutError::SizeOverflow(_) | LayoutError::ReferencesError(_) = err {
+        if let LayoutError::SizeOverflow(_)
+        | LayoutError::InvalidSimd { .. }
+        | LayoutError::ReferencesError(_) = err
+        {
             self.tcx.dcx().emit_fatal(respan(span, err.into_diagnostic()))
         } else {
             self.tcx.dcx().emit_fatal(ssa_errors::FailedToGetLayout { span, ty, err })
@@ -545,7 +548,9 @@ impl<'gcc, 'tcx> FnAbiOfHelpers<'tcx> for CodegenCx<'gcc, 'tcx> {
         span: Span,
         fn_abi_request: FnAbiRequest<'tcx>,
     ) -> ! {
-        if let FnAbiError::Layout(LayoutError::SizeOverflow(_)) = err {
+        if let FnAbiError::Layout(LayoutError::SizeOverflow(_) | LayoutError::InvalidSimd { .. }) =
+            err
+        {
             self.tcx.dcx().emit_fatal(respan(span, err))
         } else {
             match fn_abi_request {
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index a69fa54a54a4d..e4528efaa37b1 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -991,7 +991,10 @@ impl<'tcx, 'll> HasTypingEnv<'tcx> for CodegenCx<'ll, 'tcx> {
 impl<'tcx> LayoutOfHelpers<'tcx> for CodegenCx<'_, 'tcx> {
     #[inline]
     fn handle_layout_err(&self, err: LayoutError<'tcx>, span: Span, ty: Ty<'tcx>) -> ! {
-        if let LayoutError::SizeOverflow(_) | LayoutError::ReferencesError(_) = err {
+        if let LayoutError::SizeOverflow(_)
+        | LayoutError::ReferencesError(_)
+        | LayoutError::InvalidSimd { .. } = err
+        {
             self.tcx.dcx().emit_fatal(Spanned { span, node: err.into_diagnostic() })
         } else {
             self.tcx.dcx().emit_fatal(ssa_errors::FailedToGetLayout { span, ty, err })
@@ -1008,7 +1011,11 @@ impl<'tcx> FnAbiOfHelpers<'tcx> for CodegenCx<'_, 'tcx> {
         fn_abi_request: FnAbiRequest<'tcx>,
     ) -> ! {
         match err {
-            FnAbiError::Layout(LayoutError::SizeOverflow(_) | LayoutError::Cycle(_)) => {
+            FnAbiError::Layout(
+                LayoutError::SizeOverflow(_)
+                | LayoutError::Cycle(_)
+                | LayoutError::InvalidSimd { .. },
+            ) => {
                 self.tcx.dcx().emit_fatal(Spanned { span, node: err });
             }
             _ => match fn_abi_request {
diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs
index 129ab7eccb577..0d890b57de0d6 100644
--- a/compiler/rustc_feature/src/builtin_attrs.rs
+++ b/compiler/rustc_feature/src/builtin_attrs.rs
@@ -1203,6 +1203,12 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         "the `#[rustc_layout_scalar_valid_range_end]` attribute is just used to enable \
         niche optimizations in the standard library",
     ),
+    rustc_attr!(
+        rustc_simd_monomorphize_lane_limit, Normal, template!(NameValueStr: "N"), ErrorFollowing,
+        EncodeCrossCrate::Yes,
+        "the `#[rustc_simd_monomorphize_lane_limit]` attribute is just used by std::simd \
+        for better error messages",
+    ),
     rustc_attr!(
         rustc_nonnull_optimization_guaranteed, Normal, template!(Word), WarnFollowing,
         EncodeCrossCrate::Yes,
diff --git a/compiler/rustc_hir/src/attrs/data_structures.rs b/compiler/rustc_hir/src/attrs/data_structures.rs
index ea11a99efbc35..80cb641768471 100644
--- a/compiler/rustc_hir/src/attrs/data_structures.rs
+++ b/compiler/rustc_hir/src/attrs/data_structures.rs
@@ -642,6 +642,9 @@ pub enum AttributeKind {
     /// Represents `#[rustc_object_lifetime_default]`.
     RustcObjectLifetimeDefault,
 
+    /// Represents `#[rustc_simd_monomorphize_lane_limit = "N"]`.
+    RustcSimdMonomorphizeLaneLimit(Limit),
+
     /// Represents `#[sanitize]`
     ///
     /// the on set and off set are distjoint since there's a third option: unset.
diff --git a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
index 55521c1585402..968ea668efea1 100644
--- a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
+++ b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
@@ -85,6 +85,7 @@ impl AttributeKind {
             RustcLayoutScalarValidRangeEnd(..) => Yes,
             RustcLayoutScalarValidRangeStart(..) => Yes,
             RustcObjectLifetimeDefault => No,
+            RustcSimdMonomorphizeLaneLimit(..) => Yes, // Affects layout computation, which needs to work cross-crate
             Sanitize { .. } => No,
             ShouldPanic { .. } => No,
             SkipDuringMethodDispatch { .. } => No,
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 5088c63702e60..76b0ce985f0ca 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
@@ -213,6 +213,7 @@ fn should_emit_generic_error<'tcx>(abi: ExternAbi, layout_err: &'tcx LayoutError
         }
         Unknown(..)
         | SizeOverflow(..)
+        | InvalidSimd { .. }
         | NormalizationFailure(..)
         | ReferencesError(..)
         | Cycle(..) => {
diff --git a/compiler/rustc_middle/messages.ftl b/compiler/rustc_middle/messages.ftl
index 279ab9a9d8fbe..82f3df8da3b12 100644
--- a/compiler/rustc_middle/messages.ftl
+++ b/compiler/rustc_middle/messages.ftl
@@ -98,6 +98,12 @@ middle_layout_references_error =
 middle_layout_size_overflow =
     values of the type `{$ty}` are too big for the target architecture
 
+middle_layout_simd_too_many =
+    the SIMD type `{$ty}` has more elements than the limit {$max_lanes}
+
+middle_layout_simd_zero_length =
+    the SIMD type `{$ty}` has zero elements
+
 middle_layout_too_generic = the type `{$ty}` does not have a fixed layout
 
 middle_layout_unknown =
diff --git a/compiler/rustc_middle/src/error.rs b/compiler/rustc_middle/src/error.rs
index dad402ec69616..e15da827bda9b 100644
--- a/compiler/rustc_middle/src/error.rs
+++ b/compiler/rustc_middle/src/error.rs
@@ -141,6 +141,12 @@ pub enum LayoutError<'tcx> {
     #[diag(middle_layout_size_overflow)]
     Overflow { ty: Ty<'tcx> },
 
+    #[diag(middle_layout_simd_too_many)]
+    SimdTooManyLanes { ty: Ty<'tcx>, max_lanes: u64 },
+
+    #[diag(middle_layout_simd_zero_length)]
+    SimdZeroLength { ty: Ty<'tcx> },
+
     #[diag(middle_layout_normalization_failure)]
     NormalizationFailure { ty: Ty<'tcx>, failure_ty: String },
 
diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs
index 2114d080dfa43..47e561d9d3ce8 100644
--- a/compiler/rustc_middle/src/ty/layout.rs
+++ b/compiler/rustc_middle/src/ty/layout.rs
@@ -217,6 +217,15 @@ impl fmt::Display for ValidityRequirement {
     }
 }
 
+#[derive(Copy, Clone, Debug, HashStable, TyEncodable, TyDecodable)]
+pub enum SimdLayoutError {
+    /// The vector has 0 lanes.
+    ZeroLength,
+    /// The vector has more lanes than supported or permitted by
+    /// #\[rustc_simd_monomorphize_lane_limit\].
+    TooManyLanes(u64),
+}
+
 #[derive(Copy, Clone, Debug, HashStable, TyEncodable, TyDecodable)]
 pub enum LayoutError<'tcx> {
     /// A type doesn't have a sensible layout.
@@ -229,6 +238,8 @@ pub enum LayoutError<'tcx> {
     Unknown(Ty<'tcx>),
     /// The size of a type exceeds [`TargetDataLayout::obj_size_bound`].
     SizeOverflow(Ty<'tcx>),
+    /// A SIMD vector has invalid layout, such as zero-length or too many lanes.
+    InvalidSimd { ty: Ty<'tcx>, kind: SimdLayoutError },
     /// The layout can vary due to a generic parameter.
     ///
     /// Unlike `Unknown`, this variant is a "soft" error and indicates that the layout
@@ -256,6 +267,10 @@ impl<'tcx> LayoutError<'tcx> {
         match self {
             Unknown(_) => middle_layout_unknown,
             SizeOverflow(_) => middle_layout_size_overflow,
+            InvalidSimd { kind: SimdLayoutError::TooManyLanes(_), .. } => {
+                middle_layout_simd_too_many
+            }
+            InvalidSimd { kind: SimdLayoutError::ZeroLength, .. } => middle_layout_simd_zero_length,
             TooGeneric(_) => middle_layout_too_generic,
             NormalizationFailure(_, _) => middle_layout_normalization_failure,
             Cycle(_) => middle_layout_cycle,
@@ -270,6 +285,10 @@ impl<'tcx> LayoutError<'tcx> {
         match self {
             Unknown(ty) => E::Unknown { ty },
             SizeOverflow(ty) => E::Overflow { ty },
+            InvalidSimd { ty, kind: SimdLayoutError::TooManyLanes(max_lanes) } => {
+                E::SimdTooManyLanes { ty, max_lanes }
+            }
+            InvalidSimd { ty, kind: SimdLayoutError::ZeroLength } => E::SimdZeroLength { ty },
             TooGeneric(ty) => E::TooGeneric { ty },
             NormalizationFailure(ty, e) => {
                 E::NormalizationFailure { ty, failure_ty: e.get_type_for_failure() }
@@ -292,6 +311,12 @@ impl<'tcx> fmt::Display for LayoutError<'tcx> {
             LayoutError::SizeOverflow(ty) => {
                 write!(f, "values of the type `{ty}` are too big for the target architecture")
             }
+            LayoutError::InvalidSimd { ty, kind: SimdLayoutError::TooManyLanes(max_lanes) } => {
+                write!(f, "the SIMD type `{ty}` has more elements than the limit {max_lanes}")
+            }
+            LayoutError::InvalidSimd { ty, kind: SimdLayoutError::ZeroLength } => {
+                write!(f, "the SIMD type `{ty}` has zero elements")
+            }
             LayoutError::NormalizationFailure(t, e) => write!(
                 f,
                 "unable to determine layout for `{}` because `{}` cannot be normalized",
@@ -373,6 +398,7 @@ impl<'tcx> SizeSkeleton<'tcx> {
                 e @ LayoutError::Cycle(_)
                 | e @ LayoutError::Unknown(_)
                 | e @ LayoutError::SizeOverflow(_)
+                | e @ LayoutError::InvalidSimd { .. }
                 | e @ LayoutError::NormalizationFailure(..)
                 | e @ LayoutError::ReferencesError(_),
             ) => return Err(e),
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 2562d2e0b83c5..cabf28197413b 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -254,6 +254,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::MacroEscape( .. )
                     | AttributeKind::RustcLayoutScalarValidRangeStart(..)
                     | AttributeKind::RustcLayoutScalarValidRangeEnd(..)
+                    | AttributeKind::RustcSimdMonomorphizeLaneLimit(..)
                     | AttributeKind::ExportStable
                     | AttributeKind::FfiConst(..)
                     | AttributeKind::UnstableFeatureBound(..)
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index cdb0b5b58da6d..92a1fad47552b 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1937,6 +1937,7 @@ symbols! {
         rustc_regions,
         rustc_reservation_impl,
         rustc_serialize,
+        rustc_simd_monomorphize_lane_limit,
         rustc_skip_during_method_dispatch,
         rustc_specialization_trait,
         rustc_std_internal_symbol,
diff --git a/compiler/rustc_transmute/src/layout/tree.rs b/compiler/rustc_transmute/src/layout/tree.rs
index d7ea26a2ab1d0..a02e8ecf613f4 100644
--- a/compiler/rustc_transmute/src/layout/tree.rs
+++ b/compiler/rustc_transmute/src/layout/tree.rs
@@ -279,6 +279,7 @@ pub(crate) mod rustc {
                 LayoutError::Unknown(..)
                 | LayoutError::ReferencesError(..)
                 | LayoutError::TooGeneric(..)
+                | LayoutError::InvalidSimd { .. }
                 | LayoutError::NormalizationFailure(..) => Self::UnknownLayout,
                 LayoutError::SizeOverflow(..) => Self::SizeOverflow,
                 LayoutError::Cycle(err) => Self::TypeError(*err),
diff --git a/compiler/rustc_ty_utils/src/errors.rs b/compiler/rustc_ty_utils/src/errors.rs
index 0298e7e0e9511..f92c405242ce9 100644
--- a/compiler/rustc_ty_utils/src/errors.rs
+++ b/compiler/rustc_ty_utils/src/errors.rs
@@ -78,19 +78,6 @@ pub(crate) struct UnexpectedFnPtrAssociatedItem {
     pub span: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag(ty_utils_zero_length_simd_type)]
-pub(crate) struct ZeroLengthSimdType<'tcx> {
-    pub ty: Ty<'tcx>,
-}
-
-#[derive(Diagnostic)]
-#[diag(ty_utils_oversized_simd_type)]
-pub(crate) struct OversizedSimdType<'tcx> {
-    pub ty: Ty<'tcx>,
-    pub max_lanes: u64,
-}
-
 #[derive(Diagnostic)]
 #[diag(ty_utils_non_primitive_simd_type)]
 pub(crate) struct NonPrimitiveSimdType<'tcx> {
diff --git a/compiler/rustc_ty_utils/src/layout.rs b/compiler/rustc_ty_utils/src/layout.rs
index 79f7e228e2adc..5c4451ce264f0 100644
--- a/compiler/rustc_ty_utils/src/layout.rs
+++ b/compiler/rustc_ty_utils/src/layout.rs
@@ -7,11 +7,13 @@ use rustc_abi::{
     VariantIdx, Variants, WrappingRange,
 };
 use rustc_hashes::Hash64;
+use rustc_hir::attrs::AttributeKind;
+use rustc_hir::find_attr;
 use rustc_index::IndexVec;
 use rustc_middle::bug;
 use rustc_middle::query::Providers;
 use rustc_middle::ty::layout::{
-    FloatExt, HasTyCtxt, IntegerExt, LayoutCx, LayoutError, LayoutOf, TyAndLayout,
+    FloatExt, HasTyCtxt, IntegerExt, LayoutCx, LayoutError, LayoutOf, SimdLayoutError, TyAndLayout,
 };
 use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_middle::ty::{
@@ -22,7 +24,7 @@ use rustc_span::{Symbol, sym};
 use tracing::{debug, instrument};
 use {rustc_abi as abi, rustc_hir as hir};
 
-use crate::errors::{NonPrimitiveSimdType, OversizedSimdType, ZeroLengthSimdType};
+use crate::errors::NonPrimitiveSimdType;
 
 mod invariant;
 
@@ -120,11 +122,11 @@ fn map_error<'tcx>(
         }
         LayoutCalculatorError::ZeroLengthSimdType => {
             // Can't be caught in typeck if the array length is generic.
-            cx.tcx().dcx().emit_fatal(ZeroLengthSimdType { ty })
+            LayoutError::InvalidSimd { ty, kind: SimdLayoutError::ZeroLength }
         }
         LayoutCalculatorError::OversizedSimdType { max_lanes } => {
             // Can't be caught in typeck if the array length is generic.
-            cx.tcx().dcx().emit_fatal(OversizedSimdType { ty, max_lanes })
+            LayoutError::InvalidSimd { ty, kind: SimdLayoutError::TooManyLanes(max_lanes) }
         }
         LayoutCalculatorError::NonPrimitiveSimdType(field) => {
             // This error isn't caught in typeck, e.g., if
@@ -561,6 +563,22 @@ fn layout_of_uncached<'tcx>(
 
             let e_ly = cx.layout_of(e_ty)?;
 
+            // Check for the rustc_simd_monomorphize_lane_limit attribute and check the lane limit
+            if let Some(limit) = find_attr!(
+                tcx.get_all_attrs(def.did()),
+                AttributeKind::RustcSimdMonomorphizeLaneLimit(limit) => limit
+            ) {
+                if !limit.value_within_limit(e_len as usize) {
+                    return Err(map_error(
+                        &cx,
+                        ty,
+                        rustc_abi::LayoutCalculatorError::OversizedSimdType {
+                            max_lanes: limit.0 as u64,
+                        },
+                    ));
+                }
+            }
+
             map_layout(cx.calc.simd_type(e_ly, e_len, def.repr().packed()))?
         }
 
diff --git a/src/librustdoc/html/templates/type_layout.html b/src/librustdoc/html/templates/type_layout.html
index 0034552bdd3b7..49153d58fe98c 100644
--- a/src/librustdoc/html/templates/type_layout.html
+++ b/src/librustdoc/html/templates/type_layout.html
@@ -65,5 +65,10 @@ <h2 id="layout" class="section-header"> {# #}
             <strong>Note:</strong> Encountered an error during type layout; {#+ #}
             the type's layout depended on the type's layout itself. {# #}
         </p>
+        {% when Err(LayoutError::InvalidSimd {..}) %}
+        <p> {# #}
+            <strong>Note:</strong> Encountered an error during type layout; {#+ #}
+            the vector type had zero elements or too many elements. {# #}
+        </p>
         {% endmatch %}
 </div> {# #}
diff --git a/tests/ui/simd/auxiliary/simd-lane-limit.rs b/tests/ui/simd/auxiliary/simd-lane-limit.rs
new file mode 100644
index 0000000000000..dde6b880c62ec
--- /dev/null
+++ b/tests/ui/simd/auxiliary/simd-lane-limit.rs
@@ -0,0 +1,5 @@
+#![feature(rustc_attrs, repr_simd)]
+
+#[repr(simd, packed)]
+#[rustc_simd_monomorphize_lane_limit = "8"]
+pub struct Simd<T, const N: usize>(pub [T; N]);
diff --git a/tests/ui/simd/monomorphize-too-long.rs b/tests/ui/simd/monomorphize-too-long.rs
index 4fac987b0b5aa..9c83741519178 100644
--- a/tests/ui/simd/monomorphize-too-long.rs
+++ b/tests/ui/simd/monomorphize-too-long.rs
@@ -6,7 +6,5 @@
 struct Simd<T, const N: usize>([T; N]);
 
 fn main() {
-    let _too_big = Simd([1_u16; 54321]);
+    let _too_big = Simd([1_u16; 54321]); //~ ERROR the SIMD type `Simd<u16, 54321>` has more elements than the limit 32768
 }
-
-//~? ERROR monomorphising SIMD type `Simd<u16, 54321>` of length greater than 32768
diff --git a/tests/ui/simd/monomorphize-too-long.stderr b/tests/ui/simd/monomorphize-too-long.stderr
index 978eef307abd1..71bc78ef5c955 100644
--- a/tests/ui/simd/monomorphize-too-long.stderr
+++ b/tests/ui/simd/monomorphize-too-long.stderr
@@ -1,4 +1,8 @@
-error: monomorphising SIMD type `Simd<u16, 54321>` of length greater than 32768
+error: the SIMD type `Simd<u16, 54321>` has more elements than the limit 32768
+  --> $DIR/monomorphize-too-long.rs:9:9
+   |
+LL |     let _too_big = Simd([1_u16; 54321]);
+   |         ^^^^^^^^
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/simd/monomorphize-zero-length.rs b/tests/ui/simd/monomorphize-zero-length.rs
index d38870c572d97..f956197a61cf0 100644
--- a/tests/ui/simd/monomorphize-zero-length.rs
+++ b/tests/ui/simd/monomorphize-zero-length.rs
@@ -6,7 +6,5 @@
 struct Simd<T, const N: usize>([T; N]);
 
 fn main() {
-    let _empty = Simd([1.0; 0]);
+    let _empty = Simd([1.0; 0]); //~ ERROR the SIMD type `Simd<f64, 0>` has zero elements
 }
-
-//~? ERROR monomorphising SIMD type `Simd<f64, 0>` of zero length
diff --git a/tests/ui/simd/monomorphize-zero-length.stderr b/tests/ui/simd/monomorphize-zero-length.stderr
index 738c20fe51a46..66f26d95c9d97 100644
--- a/tests/ui/simd/monomorphize-zero-length.stderr
+++ b/tests/ui/simd/monomorphize-zero-length.stderr
@@ -1,4 +1,8 @@
-error: monomorphising SIMD type `Simd<f64, 0>` of zero length
+error: the SIMD type `Simd<f64, 0>` has zero elements
+  --> $DIR/monomorphize-zero-length.rs:9:9
+   |
+LL |     let _empty = Simd([1.0; 0]);
+   |         ^^^^^^
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/simd/simd-lane-limit-err-npow2.rs b/tests/ui/simd/simd-lane-limit-err-npow2.rs
new file mode 100644
index 0000000000000..d5c5c92e953db
--- /dev/null
+++ b/tests/ui/simd/simd-lane-limit-err-npow2.rs
@@ -0,0 +1,12 @@
+//@ build-fail
+//@ aux-crate:simd=simd-lane-limit.rs
+
+extern crate simd;
+
+use simd::Simd;
+
+fn main() {
+    // test non-power-of-two, since #[repr(simd, packed)] has unusual layout
+    let _x: Simd<i32, 24> = Simd([0; 24]);
+    //~^ ERROR the SIMD type `simd::Simd<i32, 24>` has more elements than the limit 8
+}
diff --git a/tests/ui/simd/simd-lane-limit-err-npow2.stderr b/tests/ui/simd/simd-lane-limit-err-npow2.stderr
new file mode 100644
index 0000000000000..fff26c4c1c1b0
--- /dev/null
+++ b/tests/ui/simd/simd-lane-limit-err-npow2.stderr
@@ -0,0 +1,8 @@
+error: the SIMD type `simd::Simd<i32, 24>` has more elements than the limit 8
+  --> $DIR/simd-lane-limit-err-npow2.rs:10:9
+   |
+LL |     let _x: Simd<i32, 24> = Simd([0; 24]);
+   |         ^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/simd/simd-lane-limit-err.rs b/tests/ui/simd/simd-lane-limit-err.rs
new file mode 100644
index 0000000000000..00390bdbdafac
--- /dev/null
+++ b/tests/ui/simd/simd-lane-limit-err.rs
@@ -0,0 +1,11 @@
+//@ build-fail
+//@ aux-crate:simd=simd-lane-limit.rs
+
+extern crate simd;
+
+use simd::Simd;
+
+fn main() {
+    let _x: Simd<i32, 16> = Simd([0; 16]);
+    //~^ ERROR the SIMD type `simd::Simd<i32, 16>` has more elements than the limit 8
+}
diff --git a/tests/ui/simd/simd-lane-limit-err.stderr b/tests/ui/simd/simd-lane-limit-err.stderr
new file mode 100644
index 0000000000000..3f2eaeda2d415
--- /dev/null
+++ b/tests/ui/simd/simd-lane-limit-err.stderr
@@ -0,0 +1,8 @@
+error: the SIMD type `simd::Simd<i32, 16>` has more elements than the limit 8
+  --> $DIR/simd-lane-limit-err.rs:9:9
+   |
+LL |     let _x: Simd<i32, 16> = Simd([0; 16]);
+   |         ^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/simd/simd-lane-limit-ok.rs b/tests/ui/simd/simd-lane-limit-ok.rs
new file mode 100644
index 0000000000000..52fd3158440ad
--- /dev/null
+++ b/tests/ui/simd/simd-lane-limit-ok.rs
@@ -0,0 +1,14 @@
+//@ build-pass
+//@ aux-crate:simd=simd-lane-limit.rs
+
+extern crate simd;
+
+use simd::Simd;
+
+fn main() {
+    let _x: Simd<i32, 4> = Simd([0; 4]);
+    let _y: Simd<i32, 8> = Simd([0; 8]);
+
+    // test non-power-of-two, since #[repr(simd, packed)] has unusual layout
+    let _z: Simd<i32, 6> = Simd([0; 6]);
+}
diff --git a/tests/ui/simd/type-generic-monomorphisation-empty.rs b/tests/ui/simd/type-generic-monomorphisation-empty.rs
index c08dc9fe3df2f..7c43b8914da63 100644
--- a/tests/ui/simd/type-generic-monomorphisation-empty.rs
+++ b/tests/ui/simd/type-generic-monomorphisation-empty.rs
@@ -6,7 +6,5 @@
 struct Simd<const N: usize>([f32; N]);
 
 fn main() {
-    let _ = Simd::<0>([]);
+    let _empty = Simd::<0>([]); //~ ERROR the SIMD type `Simd<0>` has zero elements
 }
-
-//~? ERROR monomorphising SIMD type `Simd<0>` of zero length
diff --git a/tests/ui/simd/type-generic-monomorphisation-empty.stderr b/tests/ui/simd/type-generic-monomorphisation-empty.stderr
index fc294607ae310..450db7e47db03 100644
--- a/tests/ui/simd/type-generic-monomorphisation-empty.stderr
+++ b/tests/ui/simd/type-generic-monomorphisation-empty.stderr
@@ -1,4 +1,8 @@
-error: monomorphising SIMD type `Simd<0>` of zero length
+error: the SIMD type `Simd<0>` has zero elements
+  --> $DIR/type-generic-monomorphisation-empty.rs:9:9
+   |
+LL |     let _empty = Simd::<0>([]);
+   |         ^^^^^^
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/simd/type-generic-monomorphisation-oversized.rs b/tests/ui/simd/type-generic-monomorphisation-oversized.rs
index efe3480317c9e..73a1f00e8c7f0 100644
--- a/tests/ui/simd/type-generic-monomorphisation-oversized.rs
+++ b/tests/ui/simd/type-generic-monomorphisation-oversized.rs
@@ -6,7 +6,6 @@
 struct Simd<const N: usize>([f32; N]);
 
 fn main() {
-    let _ = Simd::<65536>([0.; 65536]);
+    let _x = Simd::<65536>([0.; 65536]);
+    //~^ ERROR the SIMD type `Simd<65536>` has more elements than the limit 32768
 }
-
-//~? ERROR monomorphising SIMD type `Simd<65536>` of length greater than 32768
diff --git a/tests/ui/simd/type-generic-monomorphisation-oversized.stderr b/tests/ui/simd/type-generic-monomorphisation-oversized.stderr
index 39ff36799cc92..0065049abd68d 100644
--- a/tests/ui/simd/type-generic-monomorphisation-oversized.stderr
+++ b/tests/ui/simd/type-generic-monomorphisation-oversized.stderr
@@ -1,4 +1,8 @@
-error: monomorphising SIMD type `Simd<65536>` of length greater than 32768
+error: the SIMD type `Simd<65536>` has more elements than the limit 32768
+  --> $DIR/type-generic-monomorphisation-oversized.rs:9:9
+   |
+LL |     let _x = Simd::<65536>([0.; 65536]);
+   |         ^^
 
 error: aborting due to 1 previous error
 

From 60548ffaa3dafec019e52f39ab7a075d3f11e24e Mon Sep 17 00:00:00 2001
From: Caleb Zulawski <caleb.zulawski@gmail.com>
Date: Tue, 23 Sep 2025 22:14:25 -0400
Subject: [PATCH 1326/1889] Including spans in layout errors for all ADTs

---
 compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
index dc3a84b6a151a..7ecba13d7274c 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
@@ -469,8 +469,8 @@ pub(crate) fn spanned_type_di_node<'ll, 'tcx>(
         ty::CoroutineClosure(..) => build_closure_env_di_node(cx, unique_type_id),
         ty::Coroutine(..) => enums::build_coroutine_di_node(cx, unique_type_id),
         ty::Adt(def, ..) => match def.adt_kind() {
-            AdtKind::Struct => build_struct_type_di_node(cx, unique_type_id),
-            AdtKind::Union => build_union_type_di_node(cx, unique_type_id),
+            AdtKind::Struct => build_struct_type_di_node(cx, unique_type_id, span),
+            AdtKind::Union => build_union_type_di_node(cx, unique_type_id, span),
             AdtKind::Enum => enums::build_enum_type_di_node(cx, unique_type_id, span),
         },
         ty::Tuple(_) => build_tuple_type_di_node(cx, unique_type_id),
@@ -1066,6 +1066,7 @@ fn visibility_di_flags<'ll, 'tcx>(
 fn build_struct_type_di_node<'ll, 'tcx>(
     cx: &CodegenCx<'ll, 'tcx>,
     unique_type_id: UniqueTypeId<'tcx>,
+    span: Span,
 ) -> DINodeCreationResult<'ll> {
     let struct_type = unique_type_id.expect_ty();
     let ty::Adt(adt_def, _) = struct_type.kind() else {
@@ -1073,7 +1074,7 @@ fn build_struct_type_di_node<'ll, 'tcx>(
     };
     assert!(adt_def.is_struct());
     let containing_scope = get_namespace_for_item(cx, adt_def.did());
-    let struct_type_and_layout = cx.layout_of(struct_type);
+    let struct_type_and_layout = cx.spanned_layout_of(struct_type, span);
     let variant_def = adt_def.non_enum_variant();
     let def_location = if cx.sess().opts.unstable_opts.debug_info_type_line_numbers {
         Some(file_metadata_from_def_id(cx, Some(adt_def.did())))
@@ -1266,6 +1267,7 @@ fn build_closure_env_di_node<'ll, 'tcx>(
 fn build_union_type_di_node<'ll, 'tcx>(
     cx: &CodegenCx<'ll, 'tcx>,
     unique_type_id: UniqueTypeId<'tcx>,
+    span: Span,
 ) -> DINodeCreationResult<'ll> {
     let union_type = unique_type_id.expect_ty();
     let (union_def_id, variant_def) = match union_type.kind() {
@@ -1273,7 +1275,7 @@ fn build_union_type_di_node<'ll, 'tcx>(
         _ => bug!("build_union_type_di_node on a non-ADT"),
     };
     let containing_scope = get_namespace_for_item(cx, union_def_id);
-    let union_ty_and_layout = cx.layout_of(union_type);
+    let union_ty_and_layout = cx.spanned_layout_of(union_type, span);
     let type_name = compute_debuginfo_type_name(cx.tcx, union_type, false);
     let def_location = if cx.sess().opts.unstable_opts.debug_info_type_line_numbers {
         Some(file_metadata_from_def_id(cx, Some(union_def_id)))

From c9dc0e307ac643518ecf98373f86be5f68a197a0 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Wed, 24 Sep 2025 07:01:24 +0200
Subject: [PATCH 1327/1889] temporary-lifetime-extension-tuple-ctor.rs: make
 usable on all editions

Also
- add Reference id
- fix typo
---
 .../ui/lifetimes/temporary-lifetime-extension-tuple-ctor.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/ui/lifetimes/temporary-lifetime-extension-tuple-ctor.rs b/tests/ui/lifetimes/temporary-lifetime-extension-tuple-ctor.rs
index bb537f855a4ab..7de786dff3b77 100644
--- a/tests/ui/lifetimes/temporary-lifetime-extension-tuple-ctor.rs
+++ b/tests/ui/lifetimes/temporary-lifetime-extension-tuple-ctor.rs
@@ -1,4 +1,4 @@
-//@ edition:2024
+//@ reference: destructors.scope.lifetime-extension.exprs
 
 fn temp() -> String {
     String::from("Hello")
@@ -22,7 +22,7 @@ fn main() {
     let a = &temp();
     let b = Some(&temp());
     let c = Option::Some::<&String>(&temp());
-    use Option::Some as S;
+    use std::option::Option::Some as S;
     let d = S(&temp());
     let e = X(&temp());
     let f = Some(Ok::<_, ()>(std::borrow::Cow::Borrowed(if true {
@@ -31,6 +31,6 @@ fn main() {
         panic!()
     })));
     let some = Some; // Turn the ctor into a regular function.
-    let g = some(&temp()); //~ERROR temporary value dropped while borrowe
+    let g = some(&temp()); //~ERROR temporary value dropped while borrowed
     println!("{a:?} {b:?} {c:?} {d:?} {e:?} {f:?} {g:?}");
 }

From 763ef13d3c0ddda792617987b2f13dd40f67c266 Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Wed, 24 Sep 2025 05:45:12 +0000
Subject: [PATCH 1328/1889] Remove non-ns version of impl_self_ty and
 impl_trait

---
 .../crates/hir-ty/src/builder.rs              |  2 +-
 .../rust-analyzer/crates/hir-ty/src/db.rs     | 32 +++-----
 .../rust-analyzer/crates/hir-ty/src/infer.rs  |  4 +-
 .../crates/hir-ty/src/infer/path.rs           | 10 ++-
 .../rust-analyzer/crates/hir-ty/src/lower.rs  | 77 +++----------------
 .../crates/hir-ty/src/lower/path.rs           |  9 ++-
 .../crates/hir-ty/src/lower_nextsolver.rs     |  4 +-
 .../hir-ty/src/lower_nextsolver/path.rs       |  2 +-
 .../crates/hir-ty/src/method_resolution.rs    | 22 ++++--
 .../crates/hir-ty/src/mir/eval.rs             |  5 +-
 .../crates/hir-ty/src/next_solver/interner.rs |  8 +-
 .../crates/hir-ty/src/next_solver/solver.rs   |  6 +-
 .../crates/hir-ty/src/tests/incremental.rs    |  2 +
 .../hir-ty/src/tests/method_resolution.rs     |  2 +-
 src/tools/rust-analyzer/crates/hir/src/lib.rs | 19 +++--
 .../ide-completion/src/tests/type_pos.rs      | 18 ++---
 .../ide/src/inlay_hints/closing_brace.rs      |  2 +-
 17 files changed, 97 insertions(+), 127 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/builder.rs b/src/tools/rust-analyzer/crates/hir-ty/src/builder.rs
index 4957c69ae1656..5511587c71a46 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/builder.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/builder.rs
@@ -378,6 +378,6 @@ impl<'db> TyBuilder<EarlyBinder<'db, crate::next_solver::Ty<'db>>> {
         db: &'db dyn HirDatabase,
         def: hir_def::ImplId,
     ) -> TyBuilder<EarlyBinder<'db, crate::next_solver::Ty<'db>>> {
-        TyBuilder::subst_for_def(db, def, None).with_data(db.impl_self_ty_ns(def))
+        TyBuilder::subst_for_def(db, def, None).with_data(db.impl_self_ty(def))
     }
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
index 42f7ec6b59fd3..71fb3d44fb707 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
@@ -16,8 +16,8 @@ use smallvec::SmallVec;
 use triomphe::Arc;
 
 use crate::{
-    Binders, Const, ImplTraitId, ImplTraits, InferenceResult, Substitution, TraitEnvironment,
-    TraitRef, Ty, TyDefId, ValueTyDefId, chalk_db,
+    Binders, Const, ImplTraitId, ImplTraits, InferenceResult, Substitution, TraitEnvironment, Ty,
+    TyDefId, ValueTyDefId, chalk_db,
     consteval::ConstEvalError,
     drop::DropGlue,
     dyn_compatibility::DynCompatibilityViolation,
@@ -143,9 +143,12 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
         def: ImplId,
     ) -> (crate::next_solver::EarlyBinder<'db, crate::next_solver::Ty<'db>>, Diagnostics);
 
-    #[salsa::invoke(crate::lower::impl_self_ty_query)]
+    #[salsa::invoke(crate::lower_nextsolver::impl_self_ty_query)]
     #[salsa::transparent]
-    fn impl_self_ty(&self, def: ImplId) -> Binders<Ty>;
+    fn impl_self_ty<'db>(
+        &'db self,
+        def: ImplId,
+    ) -> crate::next_solver::EarlyBinder<'db, crate::next_solver::Ty<'db>>;
 
     // FIXME: Make this a non-interned query.
     #[salsa::invoke_interned(crate::lower_nextsolver::const_param_ty_with_diagnostics_query)]
@@ -169,9 +172,12 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
         Diagnostics,
     )>;
 
-    #[salsa::invoke(crate::lower::impl_trait_query)]
+    #[salsa::invoke(crate::lower_nextsolver::impl_trait_query)]
     #[salsa::transparent]
-    fn impl_trait(&self, def: ImplId) -> Option<Binders<TraitRef>>;
+    fn impl_trait<'db>(
+        &'db self,
+        def: ImplId,
+    ) -> Option<crate::next_solver::EarlyBinder<'db, crate::next_solver::TraitRef<'db>>>;
 
     #[salsa::invoke(crate::lower_nextsolver::field_types_with_diagnostics_query)]
     fn field_types_with_diagnostics<'db>(
@@ -325,24 +331,10 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
 
     // next trait solver
 
-    #[salsa::invoke(crate::lower_nextsolver::impl_self_ty_query)]
-    #[salsa::transparent]
-    fn impl_self_ty_ns<'db>(
-        &'db self,
-        def: ImplId,
-    ) -> crate::next_solver::EarlyBinder<'db, crate::next_solver::Ty<'db>>;
-
     #[salsa::invoke(crate::lower_nextsolver::const_param_ty_query)]
     #[salsa::transparent]
     fn const_param_ty_ns<'db>(&'db self, def: ConstParamId) -> crate::next_solver::Ty<'db>;
 
-    #[salsa::invoke(crate::lower_nextsolver::impl_trait_query)]
-    #[salsa::transparent]
-    fn impl_trait_ns<'db>(
-        &'db self,
-        def: ImplId,
-    ) -> Option<crate::next_solver::EarlyBinder<'db, crate::next_solver::TraitRef<'db>>>;
-
     #[salsa::invoke(crate::lower_nextsolver::field_types_query)]
     #[salsa::transparent]
     fn field_types_ns<'db>(
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
index 0a095ea644589..2c57a5e83d04e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
@@ -1787,7 +1787,9 @@ impl<'db> InferenceContext<'db> {
             TypeNs::SelfType(impl_id) => {
                 let generics = crate::generics::generics(self.db, impl_id.into());
                 let substs = generics.placeholder_subst(self.db);
-                let mut ty = self.db.impl_self_ty(impl_id).substitute(Interner, &substs);
+                let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);
+                let mut ty =
+                    self.db.impl_self_ty(impl_id).instantiate(interner, args).to_chalk(interner);
 
                 let Some(remaining_idx) = unresolved else {
                     drop(ctx);
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs
index 3a50b832cf19d..733f3c278806f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/path.rs
@@ -74,8 +74,11 @@ impl<'db> InferenceContext<'db> {
             }
             ValueNs::ImplSelf(impl_id) => {
                 let generics = crate::generics::generics(self.db, impl_id.into());
+                let interner = DbInterner::new_with(self.db, None, None);
                 let substs = generics.placeholder_subst(self.db);
-                let ty = self.db.impl_self_ty(impl_id).substitute(Interner, &substs);
+                let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);
+                let ty =
+                    self.db.impl_self_ty(impl_id).instantiate(interner, args).to_chalk(interner);
                 return if let Some((AdtId::StructId(struct_id), substs)) = ty.as_adt() {
                     Some(ValuePathResolution::GenericDef(
                         struct_id.into(),
@@ -359,10 +362,13 @@ impl<'db> InferenceContext<'db> {
         };
         let substs = match container {
             ItemContainerId::ImplId(impl_id) => {
+                let interner = DbInterner::new_with(self.db, None, None);
                 let impl_substs = TyBuilder::subst_for_def(self.db, impl_id, None)
                     .fill_with_inference_vars(&mut self.table)
                     .build();
-                let impl_self_ty = self.db.impl_self_ty(impl_id).substitute(Interner, &impl_substs);
+                let args: crate::next_solver::GenericArgs<'_> = impl_substs.to_nextsolver(interner);
+                let impl_self_ty =
+                    self.db.impl_self_ty(impl_id).instantiate(interner, args).to_chalk(interner);
                 self.unify(&impl_self_ty, &ty);
                 impl_substs
             }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
index b55f9cd145e26..0c197b27034bf 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower.rs
@@ -25,7 +25,7 @@ use chalk_ir::{
 use either::Either;
 use hir_def::{
     AdtId, AssocItemId, ConstId, ConstParamId, EnumId, EnumVariantId, FunctionId, GenericDefId,
-    GenericParamId, ImplId, ItemContainerId, LocalFieldId, Lookup, StaticId, StructId, TypeAliasId,
+    GenericParamId, ItemContainerId, LocalFieldId, Lookup, StaticId, StructId, TypeAliasId,
     TypeOrConstParamId, UnionId, VariantId,
     builtin_type::BuiltinType,
     expr_store::{ExpressionStore, path::Path},
@@ -34,8 +34,8 @@ use hir_def::{
     resolver::{HasResolver, LifetimeNs, Resolver, TypeNs},
     signatures::{FunctionSignature, TraitFlags},
     type_ref::{
-        ConstRef, LifetimeRefId, LiteralConstRef, PathId, TraitBoundModifier,
-        TraitRef as HirTraitRef, TypeBound, TypeRef, TypeRefId,
+        ConstRef, LifetimeRefId, LiteralConstRef, PathId, TraitBoundModifier, TypeBound, TypeRef,
+        TypeRefId,
     },
 };
 use hir_expand::name::Name;
@@ -59,6 +59,10 @@ use crate::{
     },
     make_binders,
     mapping::{from_chalk_trait_id, lt_to_placeholder_idx},
+    next_solver::{
+        DbInterner,
+        mapping::{ChalkToNextSolver, NextSolverToChalk},
+    },
     static_lifetime, to_chalk_trait_id, to_placeholder_idx,
     utils::all_super_trait_refs,
     variable_kinds_from_iter,
@@ -565,14 +569,6 @@ impl<'a> TyLoweringContext<'a> {
         Some((ctx.lower_trait_ref_from_resolved_path(resolved, explicit_self_ty, false), ctx))
     }
 
-    fn lower_trait_ref(
-        &mut self,
-        trait_ref: &HirTraitRef,
-        explicit_self_ty: Ty,
-    ) -> Option<TraitRef> {
-        self.lower_trait_ref_from_path(trait_ref.path, explicit_self_ty).map(|it| it.0)
-    }
-
     /// When lowering predicates from parents (impl, traits) for children defs (fns, consts, types), `generics` should
     /// contain the `Generics` for the **child**, while `predicate_owner` should contain the `GenericDefId` of the
     /// **parent**. This is important so we generate the correct bound var/placeholder.
@@ -851,21 +847,21 @@ fn named_associated_type_shorthand_candidates<R>(
         })
     };
 
+    let interner = DbInterner::new_with(db, None, None);
     match res {
         TypeNs::SelfType(impl_id) => {
-            // we're _in_ the impl -- the binders get added back later. Correct,
-            // but it would be nice to make this more explicit
-            let trait_ref = db.impl_trait(impl_id)?.into_value_and_skipped_binders().0;
+            let trait_ref = db.impl_trait(impl_id)?;
 
             let impl_id_as_generic_def: GenericDefId = impl_id.into();
             if impl_id_as_generic_def != def {
                 let subst = TyBuilder::subst_for_def(db, impl_id, None)
                     .fill_with_bound_vars(DebruijnIndex::INNERMOST, 0)
                     .build();
-                let trait_ref = subst.apply(trait_ref, Interner);
+                let args: crate::next_solver::GenericArgs<'_> = subst.to_nextsolver(interner);
+                let trait_ref = trait_ref.instantiate(interner, args).to_chalk(interner);
                 search(trait_ref)
             } else {
-                search(trait_ref)
+                search(trait_ref.skip_binder().to_chalk(interner))
             }
         }
         TypeNs::GenericParam(param_id) => {
@@ -1335,31 +1331,6 @@ impl ValueTyDefId {
     }
 }
 
-pub(crate) fn impl_self_ty_query(db: &dyn HirDatabase, impl_id: ImplId) -> Binders<Ty> {
-    impl_self_ty_with_diagnostics_query(db, impl_id).0
-}
-
-pub(crate) fn impl_self_ty_with_diagnostics_query(
-    db: &dyn HirDatabase,
-    impl_id: ImplId,
-) -> (Binders<Ty>, Diagnostics) {
-    let impl_data = db.impl_signature(impl_id);
-    let resolver = impl_id.resolver(db);
-    let generics = generics(db, impl_id.into());
-    let mut ctx = TyLoweringContext::new(
-        db,
-        &resolver,
-        &impl_data.store,
-        impl_id.into(),
-        LifetimeElisionKind::AnonymousCreateParameter { report_in_path: true },
-    )
-    .with_type_param_mode(ParamLoweringMode::Variable);
-    (
-        make_binders(db, &generics, ctx.lower_ty(impl_data.self_ty)),
-        create_diagnostics(ctx.diagnostics),
-    )
-}
-
 pub(crate) fn const_param_ty_query(db: &dyn HirDatabase, def: ConstParamId) -> Ty {
     const_param_ty_with_diagnostics_query(db, def).0
 }
@@ -1397,30 +1368,6 @@ pub(crate) fn const_param_ty_cycle_result(
     TyKind::Error.intern(Interner)
 }
 
-pub(crate) fn impl_trait_query(db: &dyn HirDatabase, impl_id: ImplId) -> Option<Binders<TraitRef>> {
-    impl_trait_with_diagnostics_query(db, impl_id).map(|it| it.0)
-}
-
-pub(crate) fn impl_trait_with_diagnostics_query(
-    db: &dyn HirDatabase,
-    impl_id: ImplId,
-) -> Option<(Binders<TraitRef>, Diagnostics)> {
-    let impl_data = db.impl_signature(impl_id);
-    let resolver = impl_id.resolver(db);
-    let mut ctx = TyLoweringContext::new(
-        db,
-        &resolver,
-        &impl_data.store,
-        impl_id.into(),
-        LifetimeElisionKind::AnonymousCreateParameter { report_in_path: true },
-    )
-    .with_type_param_mode(ParamLoweringMode::Variable);
-    let (self_ty, binders) = db.impl_self_ty(impl_id).into_value_and_skipped_binders();
-    let target_trait = impl_data.target_trait.as_ref()?;
-    let trait_ref = Binders::new(binders, ctx.lower_trait_ref(target_trait, self_ty)?);
-    Some((trait_ref, create_diagnostics(ctx.diagnostics)))
-}
-
 pub(crate) fn return_type_impl_traits(
     db: &dyn HirDatabase,
     def: hir_def::FunctionId,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs
index 279bbff7c0d9e..da9dd21183e8f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower/path.rs
@@ -255,8 +255,15 @@ impl<'a, 'b> PathLoweringContext<'a, 'b> {
                         // `def` can be either impl itself or item within, and we need impl itself
                         // now.
                         let generics = generics.parent_or_self();
+                        let interner = DbInterner::new_with(self.ctx.db, None, None);
                         let subst = generics.placeholder_subst(self.ctx.db);
-                        self.ctx.db.impl_self_ty(impl_id).substitute(Interner, &subst)
+                        let args: crate::next_solver::GenericArgs<'_> =
+                            subst.to_nextsolver(interner);
+                        self.ctx
+                            .db
+                            .impl_self_ty(impl_id)
+                            .instantiate(interner, args)
+                            .to_chalk(interner)
                     }
                     ParamLoweringMode::Variable => TyBuilder::impl_self_ty(self.ctx.db, impl_id)
                         .fill_with_bound_vars(self.ctx.in_binders, 0)
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
index 02774a63df422..84cd216b81218 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver.rs
@@ -920,7 +920,7 @@ pub(crate) fn impl_trait_with_diagnostics_query<'db>(
         impl_id.into(),
         LifetimeElisionKind::AnonymousCreateParameter { report_in_path: true },
     );
-    let self_ty = db.impl_self_ty_ns(impl_id).skip_binder();
+    let self_ty = db.impl_self_ty(impl_id).skip_binder();
     let target_trait = impl_data.target_trait.as_ref()?;
     let trait_ref = EarlyBinder::bind(ctx.lower_trait_ref(target_trait, self_ty)?);
     Some((trait_ref, create_diagnostics(ctx.diagnostics)))
@@ -2024,7 +2024,7 @@ fn named_associated_type_shorthand_candidates<'db, R>(
 
     match res {
         TypeNs::SelfType(impl_id) => {
-            let trait_ref = db.impl_trait_ns(impl_id)?;
+            let trait_ref = db.impl_trait(impl_id)?;
 
             // FIXME(next-solver): same method in `lower` checks for impl or not
             // Is that needed here?
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver/path.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver/path.rs
index 46dc66a8c8bae..0a9f34c9dabd6 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver/path.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lower_nextsolver/path.rs
@@ -287,7 +287,7 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
                     }
                 }
             }
-            TypeNs::SelfType(impl_id) => self.ctx.db.impl_self_ty_ns(impl_id).skip_binder(),
+            TypeNs::SelfType(impl_id) => self.ctx.db.impl_self_ty(impl_id).skip_binder(),
             TypeNs::AdtSelfType(adt) => {
                 let args = crate::next_solver::GenericArgs::identity_for_item(
                     self.ctx.interner,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
index 93ef64272d14b..61d3091a0c1d0 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
@@ -297,11 +297,12 @@ impl TraitImpls {
                     continue;
                 }
                 let target_trait = match db.impl_trait(impl_id) {
-                    Some(tr) => tr.skip_binders().hir_trait_id(),
+                    Some(tr) => tr.skip_binder().def_id.0,
                     None => continue,
                 };
-                let self_ty = db.impl_self_ty(impl_id);
-                let self_ty_fp = TyFingerprint::for_trait_impl(self_ty.skip_binders());
+                let interner = DbInterner::new_with(db, None, None);
+                let self_ty = db.impl_self_ty(impl_id).instantiate_identity().to_chalk(interner);
+                let self_ty_fp = TyFingerprint::for_trait_impl(&self_ty);
                 map.entry(target_trait).or_default().entry(self_ty_fp).or_default().push(impl_id);
             }
 
@@ -414,8 +415,8 @@ impl InherentImpls {
                     continue;
                 }
 
-                let self_ty = db.impl_self_ty(impl_id);
-                let self_ty = self_ty.skip_binders();
+                let interner = DbInterner::new_with(db, None, None);
+                let self_ty = &db.impl_self_ty(impl_id).instantiate_identity().to_chalk(interner);
 
                 match is_inherent_impl_coherent(db, def_map, impl_id, self_ty) {
                     true => {
@@ -897,10 +898,13 @@ fn find_matching_impl(
         table.run_in_snapshot(|table| {
             let impl_substs =
                 TyBuilder::subst_for_def(db, impl_, None).fill_with_inference_vars(table).build();
+            let args: crate::next_solver::GenericArgs<'_> =
+                impl_substs.to_nextsolver(table.interner);
             let trait_ref = db
                 .impl_trait(impl_)
                 .expect("non-trait method in find_matching_impl")
-                .substitute(Interner, &impl_substs);
+                .instantiate(table.interner, args)
+                .to_chalk(table.interner);
 
             if !table.unify(&trait_ref, &actual_trait_ref) {
                 return None;
@@ -1018,7 +1022,9 @@ pub fn check_orphan_rules(db: &dyn HirDatabase, impl_: ImplId) -> bool {
     let local_crate = impl_.lookup(db).container.krate();
     let is_local = |tgt_crate| tgt_crate == local_crate;
 
-    let trait_ref = impl_trait.substitute(Interner, &substs);
+    let interner = DbInterner::new_with(db, None, None);
+    let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);
+    let trait_ref = impl_trait.instantiate(interner, args).to_chalk(interner);
     let trait_id = from_chalk_trait_id(trait_ref.trait_id);
     if is_local(trait_id.module(db).krate()) {
         // trait to be implemented is local
@@ -1824,7 +1830,7 @@ fn is_valid_impl_fn_candidate(
         let _p = tracing::info_span!("subst_for_def").entered();
         let impl_subst = table.infer_ctxt.fresh_args_for_item(impl_id.into());
         let expect_self_ty = db
-            .impl_self_ty_ns(impl_id)
+            .impl_self_ty(impl_id)
             .instantiate(table.interner, &impl_subst)
             .to_chalk(table.interner);
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
index 3d7ad8d3b0693..fa63baa5d2ab8 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
@@ -432,9 +432,12 @@ impl MirEvalError {
                 let self_ = match func.lookup(db).container {
                     ItemContainerId::ImplId(impl_id) => Some({
                         let generics = crate::generics::generics(db, impl_id.into());
+                        let interner = DbInterner::new_with(db, None, None);
                         let substs = generics.placeholder_subst(db);
+                        let args: crate::next_solver::GenericArgs<'_> =
+                            substs.to_nextsolver(interner);
                         db.impl_self_ty(impl_id)
-                            .substitute(Interner, &substs)
+                            .instantiate(interner, args)
                             .display(db, display_target)
                             .to_string()
                     }),
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
index 3ff9fde9768b2..b72504a19cf0f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/interner.rs
@@ -1394,7 +1394,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
         self,
         impl_id: Self::ImplId,
     ) -> EarlyBinder<Self, impl IntoIterator<Item = Self::Clause>> {
-        let trait_ref = self.db().impl_trait_ns(impl_id.0).expect("expected an impl of trait");
+        let trait_ref = self.db().impl_trait(impl_id.0).expect("expected an impl of trait");
         trait_ref.map_bound(|trait_ref| {
             let clause: Clause<'_> = trait_ref.upcast(self);
             Clauses::new_from_iter(
@@ -1633,7 +1633,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
                 |impls| {
                     for i in impls.for_trait(trait_) {
                         use rustc_type_ir::TypeVisitable;
-                        let contains_errors = self.db().impl_trait_ns(i).map_or(false, |b| {
+                        let contains_errors = self.db().impl_trait(i).map_or(false, |b| {
                             b.skip_binder().visit_with(&mut ContainsTypeErrors).is_break()
                         });
                         if contains_errors {
@@ -1656,7 +1656,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
                     for fp in fps {
                         for i in impls.for_trait_and_self_ty(trait_, *fp) {
                             use rustc_type_ir::TypeVisitable;
-                            let contains_errors = self.db().impl_trait_ns(i).map_or(false, |b| {
+                            let contains_errors = self.db().impl_trait(i).map_or(false, |b| {
                                 b.skip_binder().visit_with(&mut ContainsTypeErrors).is_break()
                             });
                             if contains_errors {
@@ -1702,7 +1702,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
         impl_id: Self::ImplId,
     ) -> EarlyBinder<Self, rustc_type_ir::TraitRef<Self>> {
         let db = self.db();
-        db.impl_trait_ns(impl_id.0)
+        db.impl_trait(impl_id.0)
             // ImplIds for impls where the trait ref can't be resolved should never reach trait solving
             .expect("invalid impl passed to trait solver")
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
index 946e57e6cb741..a161423da4d76 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/solver.rs
@@ -156,16 +156,16 @@ impl<'db> SolverDelegate for SolverContext<'db> {
             SolverDefId::TypeAliasId(id) => id,
             _ => panic!("Unexpected SolverDefId"),
         };
-        let trait_ref = self
+        let trait_ = self
             .0
             .interner
             .db()
             .impl_trait(impl_id.0)
             // ImplIds for impls where the trait ref can't be resolved should never reach solver
             .expect("invalid impl passed to next-solver")
-            .into_value_and_skipped_binders()
+            .skip_binder()
+            .def_id
             .0;
-        let trait_ = trait_ref.hir_trait_id();
         let trait_data = trait_.trait_items(self.0.interner.db());
         let id =
             impl_id.0.impl_items(self.0.interner.db()).items.iter().find_map(|item| -> Option<_> {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
index cc5ad2045ed4f..8587c13e87f77 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/incremental.rs
@@ -504,8 +504,10 @@ impl SomeStruct {
                 "crate_local_def_map",
                 "trait_impls_in_crate_shim",
                 "attrs_shim",
+                "impl_trait_with_diagnostics_shim",
                 "impl_signature_shim",
                 "impl_signature_with_source_map_shim",
+                "impl_self_ty_with_diagnostics_shim",
                 "struct_signature_shim",
                 "struct_signature_with_source_map_shim",
                 "attrs_shim",
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs
index 5ada14bc5342e..2f8f666475668 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/method_resolution.rs
@@ -2050,7 +2050,7 @@ impl dyn Error + Send {
     /// Attempts to downcast the box to a concrete type.
     pub fn downcast<T: Error + 'static>(self: Box<Self>) -> Result<Box<T>, Box<dyn Error + Send>> {
         let err: Box<dyn Error> = self;
-                               // ^^^^ expected Box<dyn Error + '?>, got Box<dyn Error + Send + '?>
+                               // ^^^^ expected Box<dyn Error + '?>, got Box<dyn Error + Send + 'static>
                                // FIXME, type mismatch should not occur
         <dyn Error>::downcast(err).map_err(|_| loop {})
       //^^^^^^^^^^^^^^^^^^^^^ type: fn downcast<{unknown}>(Box<dyn Error + 'static>) -> Result<Box<{unknown}>, Box<dyn Error + 'static>>
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index 5592ca285fb01..c8ce46c4732cb 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -869,10 +869,13 @@ impl Module {
                     .collect();
 
                 if !missing.is_empty() {
-                    let self_ty = db.impl_self_ty(impl_def.id).substitute(
-                        Interner,
-                        &hir_ty::generics::generics(db, impl_def.id.into()).placeholder_subst(db),
-                    );
+                    let interner = DbInterner::new_with(db, None, None);
+                    let args: crate::next_solver::GenericArgs<'_> =
+                        hir_ty::generics::generics(db, impl_def.id.into())
+                            .placeholder_subst(db)
+                            .to_nextsolver(interner);
+                    let self_ty =
+                        db.impl_self_ty(impl_def.id).instantiate(interner, args).to_chalk(interner);
                     let self_ty = if let TyKind::Alias(AliasTy::Projection(projection)) =
                         self_ty.kind(Interner)
                     {
@@ -4546,21 +4549,23 @@ impl Impl {
     }
 
     pub fn trait_(self, db: &dyn HirDatabase) -> Option<Trait> {
-        let trait_ref = db.impl_trait_ns(self.id)?;
+        let trait_ref = db.impl_trait(self.id)?;
         let id = trait_ref.skip_binder().def_id;
         Some(Trait { id: id.0 })
     }
 
     pub fn trait_ref(self, db: &dyn HirDatabase) -> Option<TraitRef<'_>> {
-        let trait_ref = db.impl_trait_ns(self.id)?.instantiate_identity();
+        let trait_ref = db.impl_trait(self.id)?.instantiate_identity();
         let resolver = self.id.resolver(db);
         Some(TraitRef::new_with_resolver(db, &resolver, trait_ref))
     }
 
     pub fn self_ty(self, db: &dyn HirDatabase) -> Type<'_> {
         let resolver = self.id.resolver(db);
+        let interner = DbInterner::new_with(db, Some(resolver.krate()), None);
         let substs = TyBuilder::placeholder_subst(db, self.id);
-        let ty = db.impl_self_ty(self.id).substitute(Interner, &substs);
+        let args: crate::next_solver::GenericArgs<'_> = substs.to_nextsolver(interner);
+        let ty = db.impl_self_ty(self.id).instantiate(interner, args).to_chalk(interner);
         Type::new_with_resolver_inner(db, &resolver, ty)
     }
 
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/tests/type_pos.rs b/src/tools/rust-analyzer/crates/ide-completion/src/tests/type_pos.rs
index c7e2d058257e3..125e11e9e3589 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/tests/type_pos.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/tests/type_pos.rs
@@ -429,18 +429,18 @@ trait Tr<T> {
 impl Tr<$0
     "#,
         expect![[r#"
-            en Enum                    Enum
-            ma makro!(…) macro_rules! makro
+            en Enum                        Enum
+            ma makro!(…)     macro_rules! makro
             md module
-            sp Self       dyn Tr<{unknown}>
-            st Record                Record
-            st S                          S
-            st Tuple                  Tuple
-            st Unit                    Unit
+            sp Self dyn Tr<{unknown}> + 'static
+            st Record                    Record
+            st S                              S
+            st Tuple                      Tuple
+            st Unit                        Unit
             tt Tr
             tt Trait
-            un Union                  Union
-            bt u32                      u32
+            un Union                      Union
+            bt u32                          u32
             kw crate::
             kw self::
         "#]],
diff --git a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/closing_brace.rs b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/closing_brace.rs
index e80c9dc9d4732..9d246eda57e04 100644
--- a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/closing_brace.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/closing_brace.rs
@@ -191,7 +191,7 @@ impl Tr for () {
 //^ impl Tr for ()
 impl dyn Tr {
   }
-//^ impl dyn Tr
+//^ impl dyn Tr + 'static
 
 static S0: () = 0;
 static S1: () = {};

From 6e897949a5a1fb3bb70c5166cced9b24af879882 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Wed, 24 Sep 2025 14:36:09 +0800
Subject: [PATCH 1329/1889] Fix applicable on if-let-chain for invert_if

Example
---
```rust
fn f() { i$0f x && let Some(_) = Some(1) { 1 } else { 0 } }
```

**Before this PR**:

```rust
fn f() { if !(x && let Some(_) = Some(1)) { 0 } else { 1 } }
```

**After this PR**:

Assist not applicable
---
 .../crates/ide-assists/src/handlers/invert_if.rs     | 12 ++++++++++++
 .../crates/ide-db/src/syntax_helpers/node_ext.rs     |  5 +----
 2 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/invert_if.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/invert_if.rs
index d198870b023e6..7576d2fab976f 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/invert_if.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/invert_if.rs
@@ -124,6 +124,18 @@ mod tests {
         )
     }
 
+    #[test]
+    fn invert_if_doesnt_apply_with_if_let_chain() {
+        check_assist_not_applicable(
+            invert_if,
+            "fn f() { i$0f x && let Some(_) = Some(1) { 1 } else { 0 } }",
+        );
+        check_assist_not_applicable(
+            invert_if,
+            "fn f() { i$0f let Some(_) = Some(1) && x { 1 } else { 0 } }",
+        );
+    }
+
     #[test]
     fn invert_if_option_case() {
         check_assist(
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/syntax_helpers/node_ext.rs b/src/tools/rust-analyzer/crates/ide-db/src/syntax_helpers/node_ext.rs
index cefd8fd49676e..e1d140730edce 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/syntax_helpers/node_ext.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/syntax_helpers/node_ext.rs
@@ -265,10 +265,7 @@ pub fn is_pattern_cond(expr: ast::Expr) -> bool {
         ast::Expr::BinExpr(expr)
             if expr.op_kind() == Some(ast::BinaryOp::LogicOp(ast::LogicOp::And)) =>
         {
-            expr.lhs()
-                .map(is_pattern_cond)
-                .or_else(|| expr.rhs().map(is_pattern_cond))
-                .unwrap_or(false)
+            expr.lhs().map_or(false, is_pattern_cond) || expr.rhs().map_or(false, is_pattern_cond)
         }
         ast::Expr::ParenExpr(expr) => expr.expr().is_some_and(is_pattern_cond),
         ast::Expr::LetExpr(_) => true,

From 03fd823dbf39ebbd69f6e20e9d44c0cb893140c3 Mon Sep 17 00:00:00 2001
From: Ayush Singh <ayush@beagleboard.org>
Date: Wed, 24 Sep 2025 13:26:03 +0530
Subject: [PATCH 1330/1889] library: std: sys: pal: uefi: Add some comments

I seemed to have forgotten that since I am using GET_PROTOCOL attribute
for the std usecases, I did not need to close the protocols explicitly.
So adding these comments as a note to future self not to waste time on
the same thing again.

Signed-off-by: Ayush Singh <ayush@beagleboard.org>
---
 library/std/src/sys/pal/uefi/helpers.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/library/std/src/sys/pal/uefi/helpers.rs b/library/std/src/sys/pal/uefi/helpers.rs
index b50574de937aa..c0d69c3e0029a 100644
--- a/library/std/src/sys/pal/uefi/helpers.rs
+++ b/library/std/src/sys/pal/uefi/helpers.rs
@@ -92,6 +92,9 @@ pub(crate) fn locate_handles(mut guid: Guid) -> io::Result<Vec<NonNull<crate::ff
 ///
 /// Queries a handle to determine if it supports a specified protocol. If the protocol is
 /// supported by the handle, it opens the protocol on behalf of the calling agent.
+///
+/// The protocol is opened with the attribute GET_PROTOCOL, which means the caller is not required
+/// to close the protocol interface with `EFI_BOOT_SERVICES.CloseProtocol()`
 pub(crate) fn open_protocol<T>(
     handle: NonNull<crate::ffi::c_void>,
     mut protocol_guid: Guid,
@@ -473,6 +476,7 @@ impl<'a> crate::fmt::Debug for DevicePathNode<'a> {
     }
 }
 
+/// Protocols installed by Rust side on a handle.
 pub(crate) struct OwnedProtocol<T> {
     guid: r_efi::efi::Guid,
     handle: NonNull<crate::ffi::c_void>,

From 8e37f0f120ba8b77889bea3fc607004c89afffb4 Mon Sep 17 00:00:00 2001
From: sysrex <769991+sysrex@users.noreply.github.com>
Date: Wed, 24 Sep 2025 09:13:08 +0100
Subject: [PATCH 1331/1889] chore: remove discord references from the std
 library as well

---
 library/std/src/lib.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index 33e3bf0c085da..9266a0af2c83b 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -94,7 +94,7 @@
 //! pull-requests for your suggested changes.
 //!
 //! Contributions are appreciated! If you see a part of the docs that can be
-//! improved, submit a PR, or chat with us first on [Discord][rust-discord]
+//! improved, submit a PR, or chat with us first on [Zulip][rust-zulip]
 //! #docs.
 //!
 //! # A Tour of The Rust Standard Library
@@ -212,7 +212,7 @@
 //! [multithreading]: thread
 //! [other]: #what-is-in-the-standard-library-documentation
 //! [primitive types]: ../book/ch03-02-data-types.html
-//! [rust-discord]: https://discord.gg/rust-lang
+//! [rust-zulip]: https://rust-lang.zulipchat.com/
 //! [array]: prim@array
 //! [slice]: prim@slice
 

From 3378997867a9501beb3137f1ae508aadf1b9fc4b Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Wed, 24 Sep 2025 12:50:50 +0200
Subject: [PATCH 1332/1889] fix wording
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Rémy Rakic <remy.rakic+github@gmail.com>
---
 compiler/rustc_borrowck/src/type_check/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
index e05c5b224858b..be44dc955c213 100644
--- a/compiler/rustc_borrowck/src/type_check/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -540,7 +540,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         }
 
         // If there are nested bodies in promoteds, we also need to update their
-        // location to something in the actually body, not the promoted.
+        // location to something in the actual body, not the promoted.
         //
         // We don't update the constraint categories of the resulting constraints
         // as returns in nested bodies are a proper return, even if that nested body

From 32d24f9efa81a1c467da21c3ae2d93a6b00a9f5b Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Wed, 24 Sep 2025 13:02:27 +0200
Subject: [PATCH 1333/1889] allow bound regions in writeback

---
 compiler/rustc_hir_typeck/src/writeback.rs    |  6 +++--
 tests/crashes/117808.rs                       | 27 -------------------
 .../writeback-predicate-bound-region.rs       | 14 ++++++++++
 3 files changed, 18 insertions(+), 29 deletions(-)
 delete mode 100644 tests/crashes/117808.rs
 create mode 100644 tests/ui/traits/next-solver/writeback-predicate-bound-region.rs

diff --git a/compiler/rustc_hir_typeck/src/writeback.rs b/compiler/rustc_hir_typeck/src/writeback.rs
index 6192420898f6e..d01eeb9a4b691 100644
--- a/compiler/rustc_hir_typeck/src/writeback.rs
+++ b/compiler/rustc_hir_typeck/src/writeback.rs
@@ -1003,8 +1003,10 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Resolver<'cx, 'tcx> {
     }
 
     fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
-        debug_assert!(!r.is_bound(), "Should not be resolving bound region.");
-        self.fcx.tcx.lifetimes.re_erased
+        match r.kind() {
+            ty::ReBound(..) => r,
+            _ => self.fcx.tcx.lifetimes.re_erased,
+        }
     }
 
     fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
diff --git a/tests/crashes/117808.rs b/tests/crashes/117808.rs
deleted file mode 100644
index 2c727986dd07f..0000000000000
--- a/tests/crashes/117808.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-//@ known-bug: #117808
-//@ edition:2021
-//@ needs-rustc-debug-assertions
-
-use std::future::Future;
-
-fn hrc<R, F: for<'a> AsyncClosure<'a, (), R>>(f: F) -> F {
-    f
-}
-
-fn main() {
-    hrc(|x| async {});
-}
-
-trait AsyncClosure<'a, I, R>
-where
-    I: 'a,
-{
-}
-
-impl<'a, I, R, Fut, F> AsyncClosure<'a, I, R> for F
-where
-    I: 'a,
-    F: Fn(&'a I) -> Fut,
-    Fut: Future<Output = R> + Send + 'a,
-{
-}
diff --git a/tests/ui/traits/next-solver/writeback-predicate-bound-region.rs b/tests/ui/traits/next-solver/writeback-predicate-bound-region.rs
new file mode 100644
index 0000000000000..a7ed5dbcf086d
--- /dev/null
+++ b/tests/ui/traits/next-solver/writeback-predicate-bound-region.rs
@@ -0,0 +1,14 @@
+//@ edition: 2024
+//@ check-pass
+//@ compile-flags: -Znext-solver
+
+// This previously ICE'd during writeback when resolving
+// the stalled coroutine predicate due to its bound lifetime.
+
+trait Trait<'a> {}
+impl<'a, T: Send> Trait<'a> for T {}
+
+fn is_trait<T: for<'a> Trait<'a>>(_: T) {}
+fn main() {
+    is_trait(async {})
+}

From 2886ca496a8adff7424da8b19eeaffa9d392210c Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Wed, 24 Sep 2025 13:04:36 +0200
Subject: [PATCH 1334/1889] imrpove type_op failure ICE

---
 .../src/traits/query/type_op/custom.rs                      | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/compiler/rustc_trait_selection/src/traits/query/type_op/custom.rs b/compiler/rustc_trait_selection/src/traits/query/type_op/custom.rs
index 6ce68507d6521..a96cb738b81f0 100644
--- a/compiler/rustc_trait_selection/src/traits/query/type_op/custom.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/type_op/custom.rs
@@ -100,9 +100,9 @@ where
         } else if let Err(guar) = infcx.tcx.check_potentially_region_dependent_goals(root_def_id) {
             Err(guar)
         } else {
-            Err(infcx
-                .dcx()
-                .delayed_bug(format!("errors selecting obligation during MIR typeck: {errors:?}")))
+            Err(infcx.dcx().delayed_bug(format!(
+                "errors selecting obligation during MIR typeck: {name} {root_def_id:?} {errors:?}"
+            )))
         }
     })?;
 

From 0a41add6293d76b165968d70f95e7edbbe65fe11 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 22 Sep 2025 19:46:30 +0200
Subject: [PATCH 1335/1889] const-eval: improve and actually test the errors
 when pointers might be outside the range of a scalar

---
 compiler/rustc_const_eval/messages.ftl          |  4 ++--
 compiler/rustc_const_eval/src/errors.rs         |  7 +++----
 .../rustc_const_eval/src/interpret/validity.rs  |  5 +----
 .../rustc_middle/src/mir/interpret/error.rs     |  5 +----
 tests/ui/consts/const-eval/ub-nonnull.rs        |  4 ++++
 tests/ui/consts/const-eval/ub-nonnull.stderr    | 17 ++++++++++++++---
 tests/ui/consts/const-eval/ub-ref-ptr.rs        | 11 ++++++++++-
 tests/ui/consts/const-eval/ub-ref-ptr.stderr    | 17 ++++++++++++++---
 8 files changed, 49 insertions(+), 21 deletions(-)

diff --git a/compiler/rustc_const_eval/messages.ftl b/compiler/rustc_const_eval/messages.ftl
index 700d7c26752b6..97674aea540ca 100644
--- a/compiler/rustc_const_eval/messages.ftl
+++ b/compiler/rustc_const_eval/messages.ftl
@@ -479,11 +479,11 @@ const_eval_validation_never_val = {$front_matter}: encountered a value of the ne
 const_eval_validation_null_box = {$front_matter}: encountered a null box
 const_eval_validation_null_fn_ptr = {$front_matter}: encountered a null function pointer
 const_eval_validation_null_ref = {$front_matter}: encountered a null reference
-const_eval_validation_nullable_ptr_out_of_range = {$front_matter}: encountered a potentially null pointer, but expected something that cannot possibly fail to be {$in_range}
+const_eval_validation_nonnull_ptr_out_of_range = {$front_matter}: encountered a maybe-null pointer, but expected something that is definitely non-zero
 const_eval_validation_out_of_range = {$front_matter}: encountered {$value}, but expected something {$in_range}
 const_eval_validation_partial_pointer = {$front_matter}: encountered a partial pointer or a mix of pointers
 const_eval_validation_pointer_as_int = {$front_matter}: encountered a pointer, but {$expected}
-const_eval_validation_ptr_out_of_range = {$front_matter}: encountered a pointer, but expected something that cannot possibly fail to be {$in_range}
+const_eval_validation_ptr_out_of_range = {$front_matter}: encountered a pointer with unknown absolute address, but expected something that is definitely {$in_range}
 const_eval_validation_ref_to_uninhabited = {$front_matter}: encountered a reference pointing to uninhabited type {$ty}
 const_eval_validation_unaligned_box = {$front_matter}: encountered an unaligned box (required {$required_bytes} byte alignment but found {$found_bytes})
 const_eval_validation_unaligned_ref = {$front_matter}: encountered an unaligned reference (required {$required_bytes} byte alignment but found {$found_bytes})
diff --git a/compiler/rustc_const_eval/src/errors.rs b/compiler/rustc_const_eval/src/errors.rs
index 2d412ee5ec26e..29bddd59ffd59 100644
--- a/compiler/rustc_const_eval/src/errors.rs
+++ b/compiler/rustc_const_eval/src/errors.rs
@@ -668,7 +668,7 @@ impl<'tcx> ReportErrorExt for ValidationErrorInfo<'tcx> {
             MutableRefInConst => const_eval_validation_mutable_ref_in_const,
             NullFnPtr => const_eval_validation_null_fn_ptr,
             NeverVal => const_eval_validation_never_val,
-            NullablePtrOutOfRange { .. } => const_eval_validation_nullable_ptr_out_of_range,
+            NonnullPtrMaybeNull { .. } => const_eval_validation_nonnull_ptr_out_of_range,
             PtrOutOfRange { .. } => const_eval_validation_ptr_out_of_range,
             OutOfRange { .. } => const_eval_validation_out_of_range,
             UnsafeCellInImmutable => const_eval_validation_unsafe_cell,
@@ -804,9 +804,7 @@ impl<'tcx> ReportErrorExt for ValidationErrorInfo<'tcx> {
             | InvalidFnPtr { value } => {
                 err.arg("value", value);
             }
-            NullablePtrOutOfRange { range, max_value } | PtrOutOfRange { range, max_value } => {
-                add_range_arg(range, max_value, err)
-            }
+            PtrOutOfRange { range, max_value } => add_range_arg(range, max_value, err),
             OutOfRange { range, max_value, value } => {
                 err.arg("value", value);
                 add_range_arg(range, max_value, err);
@@ -826,6 +824,7 @@ impl<'tcx> ReportErrorExt for ValidationErrorInfo<'tcx> {
             | MutableRefToImmutable
             | MutableRefInConst
             | NullFnPtr
+            | NonnullPtrMaybeNull
             | NeverVal
             | UnsafeCellInImmutable
             | InvalidMetaSliceTooLarge { .. }
diff --git a/compiler/rustc_const_eval/src/interpret/validity.rs b/compiler/rustc_const_eval/src/interpret/validity.rs
index 9adc3fa463180..8648b83b8dcd2 100644
--- a/compiler/rustc_const_eval/src/interpret/validity.rs
+++ b/compiler/rustc_const_eval/src/interpret/validity.rs
@@ -819,10 +819,7 @@ impl<'rt, 'tcx, M: Machine<'tcx>> ValidityVisitor<'rt, 'tcx, M> {
                 if start == 1 && end == max_value {
                     // Only null is the niche. So make sure the ptr is NOT null.
                     if self.ecx.scalar_may_be_null(scalar)? {
-                        throw_validation_failure!(
-                            self.path,
-                            NullablePtrOutOfRange { range: valid_range, max_value }
-                        )
+                        throw_validation_failure!(self.path, NonnullPtrMaybeNull)
                     } else {
                         return interp_ok(());
                     }
diff --git a/compiler/rustc_middle/src/mir/interpret/error.rs b/compiler/rustc_middle/src/mir/interpret/error.rs
index 7c72a8ec243a8..1a9ae4bbceb4f 100644
--- a/compiler/rustc_middle/src/mir/interpret/error.rs
+++ b/compiler/rustc_middle/src/mir/interpret/error.rs
@@ -499,10 +499,7 @@ pub enum ValidationErrorKind<'tcx> {
     MutableRefInConst,
     NullFnPtr,
     NeverVal,
-    NullablePtrOutOfRange {
-        range: WrappingRange,
-        max_value: u128,
-    },
+    NonnullPtrMaybeNull,
     PtrOutOfRange {
         range: WrappingRange,
         max_value: u128,
diff --git a/tests/ui/consts/const-eval/ub-nonnull.rs b/tests/ui/consts/const-eval/ub-nonnull.rs
index 9164684262480..851f3996cd104 100644
--- a/tests/ui/consts/const-eval/ub-nonnull.rs
+++ b/tests/ui/consts/const-eval/ub-nonnull.rs
@@ -57,4 +57,8 @@ const NULL_FAT_PTR: NonNull<dyn Send> = unsafe {
     mem::transmute((0_usize, meta))
 };
 
+static S: u32 = 0; // just a static to construct a maybe-null pointer off of
+const MAYBE_NULL_PTR: NonNull<()> = unsafe { mem::transmute((&raw const S).wrapping_add(4)) };
+//~^ ERROR invalid value
+
 fn main() {}
diff --git a/tests/ui/consts/const-eval/ub-nonnull.stderr b/tests/ui/consts/const-eval/ub-nonnull.stderr
index 91c82efbc5ed1..e4486e3c500b9 100644
--- a/tests/ui/consts/const-eval/ub-nonnull.stderr
+++ b/tests/ui/consts/const-eval/ub-nonnull.stderr
@@ -9,7 +9,7 @@ LL | const NULL_PTR: NonNull<u8> = unsafe { mem::transmute(0usize) };
                HEX_DUMP
            }
 
-error[E0080]: in-bounds pointer arithmetic failed: attempting to offset pointer by 255 bytes, but got ALLOC1 which is only 1 byte from the end of the allocation
+error[E0080]: in-bounds pointer arithmetic failed: attempting to offset pointer by 255 bytes, but got ALLOC2 which is only 1 byte from the end of the allocation
   --> $DIR/ub-nonnull.rs:22:29
    |
 LL |     let out_of_bounds_ptr = &ptr[255];
@@ -37,7 +37,7 @@ LL | const NULL_USIZE: NonZero<usize> = unsafe { mem::transmute(0usize) };
                HEX_DUMP
            }
 
-error[E0080]: reading memory at ALLOC2[0x0..0x1], but memory is uninitialized at [0x0..0x1], and this operation requires initialized memory
+error[E0080]: reading memory at ALLOC3[0x0..0x1], but memory is uninitialized at [0x0..0x1], and this operation requires initialized memory
   --> $DIR/ub-nonnull.rs:36:38
    |
 LL | const UNINIT: NonZero<u8> = unsafe { MaybeUninit { uninit: () }.init };
@@ -80,6 +80,17 @@ LL | const NULL_FAT_PTR: NonNull<dyn Send> = unsafe {
                HEX_DUMP
            }
 
-error: aborting due to 8 previous errors
+error[E0080]: constructing invalid value: encountered a maybe-null pointer, but expected something that is definitely non-zero
+  --> $DIR/ub-nonnull.rs:61:1
+   |
+LL | const MAYBE_NULL_PTR: NonNull<()> = unsafe { mem::transmute((&raw const S).wrapping_add(4)) };
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
+   |
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
+               HEX_DUMP
+           }
+
+error: aborting due to 9 previous errors
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/ub-ref-ptr.rs b/tests/ui/consts/const-eval/ub-ref-ptr.rs
index d8e5102fcbe78..5ff9748af0c15 100644
--- a/tests/ui/consts/const-eval/ub-ref-ptr.rs
+++ b/tests/ui/consts/const-eval/ub-ref-ptr.rs
@@ -4,7 +4,7 @@
 //@ normalize-stderr: "([0-9a-f][0-9a-f] |__ |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
 //@ dont-require-annotations: NOTE
 //@ normalize-stderr: "0x[0-9](\.\.|\])" -> "0x%$1"
-
+#![feature(rustc_attrs)]
 #![allow(invalid_value)]
 
 use std::mem;
@@ -65,5 +65,14 @@ const UNALIGNED_READ: () = unsafe {
     ptr.read(); //~ ERROR accessing memory
 };
 
+// Check the general case of a pointer value not falling into the scalar valid range.
+#[rustc_layout_scalar_valid_range_start(1000)]
+pub struct High {
+    pointer: *const (),
+}
+static S: u32 = 0; // just a static to construct a pointer with unknown absolute address
+const INVALID_VALUE_PTR: High = unsafe { mem::transmute(&S) };
+//~^ ERROR invalid value
+
 
 fn main() {}
diff --git a/tests/ui/consts/const-eval/ub-ref-ptr.stderr b/tests/ui/consts/const-eval/ub-ref-ptr.stderr
index c45f66c29259c..9170cde94e2ad 100644
--- a/tests/ui/consts/const-eval/ub-ref-ptr.stderr
+++ b/tests/ui/consts/const-eval/ub-ref-ptr.stderr
@@ -103,7 +103,7 @@ LL | const USIZE_AS_BOX: Box<u8> = unsafe { mem::transmute(1337usize) };
                HEX_DUMP
            }
 
-error[E0080]: reading memory at ALLOC3[0x%..0x%], but memory is uninitialized at [0x%..0x%], and this operation requires initialized memory
+error[E0080]: reading memory at ALLOC4[0x%..0x%], but memory is uninitialized at [0x%..0x%], and this operation requires initialized memory
   --> $DIR/ub-ref-ptr.rs:49:41
    |
 LL | const UNINIT_PTR: *const i32 = unsafe { MaybeUninit { uninit: () }.init };
@@ -124,7 +124,7 @@ LL | const NULL_FN_PTR: fn() = unsafe { mem::transmute(0usize) };
                HEX_DUMP
            }
 
-error[E0080]: reading memory at ALLOC4[0x%..0x%], but memory is uninitialized at [0x%..0x%], and this operation requires initialized memory
+error[E0080]: reading memory at ALLOC5[0x%..0x%], but memory is uninitialized at [0x%..0x%], and this operation requires initialized memory
   --> $DIR/ub-ref-ptr.rs:54:38
    |
 LL | const UNINIT_FN_PTR: fn() = unsafe { MaybeUninit { uninit: () }.init };
@@ -162,6 +162,17 @@ error[E0080]: accessing memory based on pointer with alignment 1, but alignment
 LL |     ptr.read();
    |     ^^^^^^^^^^ evaluation of `UNALIGNED_READ` failed here
 
-error: aborting due to 15 previous errors
+error[E0080]: constructing invalid value: encountered a pointer with unknown absolute address, but expected something that is definitely greater or equal to 1000
+  --> $DIR/ub-ref-ptr.rs:74:1
+   |
+LL | const INVALID_VALUE_PTR: High = unsafe { mem::transmute(&S) };
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
+   |
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
+               HEX_DUMP
+           }
+
+error: aborting due to 16 previous errors
 
 For more information about this error, try `rustc --explain E0080`.

From 8328c3dada0c888b1c570f97314b3f697d4b2a96 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 24 Sep 2025 12:12:41 +0200
Subject: [PATCH 1336/1889] const validation: better error for maybe-null
 references

---
 compiler/rustc_const_eval/messages.ftl        | 10 +++-
 compiler/rustc_const_eval/src/errors.rs       | 10 ++--
 .../src/interpret/validity.rs                 | 13 ++++-
 .../rustc_middle/src/mir/interpret/error.rs   |  2 +
 src/tools/compiletest/src/runtest.rs          |  2 +-
 tests/ui/consts/const-eval/ub-ref-ptr.rs      | 12 +++-
 tests/ui/consts/const-eval/ub-ref-ptr.stderr  | 58 +++++++++++++------
 tests/ui/consts/const_transmute_type_id7.rs   | 16 +++++
 .../ui/consts/const_transmute_type_id7.stderr | 14 +++++
 9 files changed, 108 insertions(+), 29 deletions(-)
 create mode 100644 tests/ui/consts/const_transmute_type_id7.rs
 create mode 100644 tests/ui/consts/const_transmute_type_id7.stderr

diff --git a/compiler/rustc_const_eval/messages.ftl b/compiler/rustc_const_eval/messages.ftl
index 97674aea540ca..010ffa60c7a53 100644
--- a/compiler/rustc_const_eval/messages.ftl
+++ b/compiler/rustc_const_eval/messages.ftl
@@ -476,9 +476,15 @@ const_eval_validation_invalid_vtable_trait = {$front_matter}: wrong trait in wid
 const_eval_validation_mutable_ref_in_const = {$front_matter}: encountered mutable reference in `const` value
 const_eval_validation_mutable_ref_to_immutable = {$front_matter}: encountered mutable reference or box pointing to read-only memory
 const_eval_validation_never_val = {$front_matter}: encountered a value of the never type `!`
-const_eval_validation_null_box = {$front_matter}: encountered a null box
+const_eval_validation_null_box = {$front_matter}: encountered a {$maybe ->
+    [true] maybe-null
+    *[false] null
+  } box
 const_eval_validation_null_fn_ptr = {$front_matter}: encountered a null function pointer
-const_eval_validation_null_ref = {$front_matter}: encountered a null reference
+const_eval_validation_null_ref = {$front_matter}: encountered a {$maybe ->
+    [true] maybe-null
+    *[false] null
+  } reference
 const_eval_validation_nonnull_ptr_out_of_range = {$front_matter}: encountered a maybe-null pointer, but expected something that is definitely non-zero
 const_eval_validation_out_of_range = {$front_matter}: encountered {$value}, but expected something {$in_range}
 const_eval_validation_partial_pointer = {$front_matter}: encountered a partial pointer or a mix of pointers
diff --git a/compiler/rustc_const_eval/src/errors.rs b/compiler/rustc_const_eval/src/errors.rs
index 29bddd59ffd59..d352a6384245f 100644
--- a/compiler/rustc_const_eval/src/errors.rs
+++ b/compiler/rustc_const_eval/src/errors.rs
@@ -696,8 +696,8 @@ impl<'tcx> ReportErrorExt for ValidationErrorInfo<'tcx> {
             }
             UnalignedPtr { ptr_kind: PointerKind::Box, .. } => const_eval_validation_unaligned_box,
 
-            NullPtr { ptr_kind: PointerKind::Box } => const_eval_validation_null_box,
-            NullPtr { ptr_kind: PointerKind::Ref(_) } => const_eval_validation_null_ref,
+            NullPtr { ptr_kind: PointerKind::Box, .. } => const_eval_validation_null_box,
+            NullPtr { ptr_kind: PointerKind::Ref(_), .. } => const_eval_validation_null_ref,
             DanglingPtrNoProvenance { ptr_kind: PointerKind::Box, .. } => {
                 const_eval_validation_dangling_box_no_provenance
             }
@@ -820,8 +820,10 @@ impl<'tcx> ReportErrorExt for ValidationErrorInfo<'tcx> {
                 err.arg("vtable_dyn_type", vtable_dyn_type.to_string());
                 err.arg("expected_dyn_type", expected_dyn_type.to_string());
             }
-            NullPtr { .. }
-            | MutableRefToImmutable
+            NullPtr { maybe, .. } => {
+                err.arg("maybe", maybe);
+            }
+            MutableRefToImmutable
             | MutableRefInConst
             | NullFnPtr
             | NonnullPtrMaybeNull
diff --git a/compiler/rustc_const_eval/src/interpret/validity.rs b/compiler/rustc_const_eval/src/interpret/validity.rs
index 8648b83b8dcd2..5f088fe37e80b 100644
--- a/compiler/rustc_const_eval/src/interpret/validity.rs
+++ b/compiler/rustc_const_eval/src/interpret/validity.rs
@@ -511,7 +511,7 @@ impl<'rt, 'tcx, M: Machine<'tcx>> ValidityVisitor<'rt, 'tcx, M> {
                 CheckInAllocMsg::Dereferenceable, // will anyway be replaced by validity message
             ),
             self.path,
-            Ub(DanglingIntPointer { addr: 0, .. }) => NullPtr { ptr_kind },
+            Ub(DanglingIntPointer { addr: 0, .. }) => NullPtr { ptr_kind, maybe: false },
             Ub(DanglingIntPointer { addr: i, .. }) => DanglingPtrNoProvenance {
                 ptr_kind,
                 // FIXME this says "null pointer" when null but we need translate
@@ -538,8 +538,10 @@ impl<'rt, 'tcx, M: Machine<'tcx>> ValidityVisitor<'rt, 'tcx, M> {
         );
         // Make sure this is non-null. We checked dereferenceability above, but if `size` is zero
         // that does not imply non-null.
-        if self.ecx.scalar_may_be_null(Scalar::from_maybe_pointer(place.ptr(), self.ecx))? {
-            throw_validation_failure!(self.path, NullPtr { ptr_kind })
+        let scalar = Scalar::from_maybe_pointer(place.ptr(), self.ecx);
+        if self.ecx.scalar_may_be_null(scalar)? {
+            let maybe = !M::Provenance::OFFSET_IS_ADDR && matches!(scalar, Scalar::Ptr(..));
+            throw_validation_failure!(self.path, NullPtr { ptr_kind, maybe })
         }
         // Do not allow references to uninhabited types.
         if place.layout.is_uninhabited() {
@@ -757,6 +759,11 @@ impl<'rt, 'tcx, M: Machine<'tcx>> ValidityVisitor<'rt, 'tcx, M> {
                 } else {
                     // Otherwise (for standalone Miri), we have to still check it to be non-null.
                     if self.ecx.scalar_may_be_null(scalar)? {
+                        let maybe =
+                            !M::Provenance::OFFSET_IS_ADDR && matches!(scalar, Scalar::Ptr(..));
+                        // This can't be a "maybe-null" pointer since the check for this being
+                        // a fn ptr at all already ensures that the pointer is inbounds.
+                        assert!(!maybe);
                         throw_validation_failure!(self.path, NullFnPtr);
                     }
                 }
diff --git a/compiler/rustc_middle/src/mir/interpret/error.rs b/compiler/rustc_middle/src/mir/interpret/error.rs
index 1a9ae4bbceb4f..951aac503fee8 100644
--- a/compiler/rustc_middle/src/mir/interpret/error.rs
+++ b/compiler/rustc_middle/src/mir/interpret/error.rs
@@ -541,6 +541,8 @@ pub enum ValidationErrorKind<'tcx> {
     },
     NullPtr {
         ptr_kind: PointerKind,
+        /// Records whether this pointer is definitely null or just may be null.
+        maybe: bool,
     },
     DanglingPtrNoProvenance {
         ptr_kind: PointerKind,
diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index 89fb8eb4357b7..59bd3111ecf35 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -2655,7 +2655,7 @@ impl<'test> TestCx<'test> {
 
             // The alloc-id appears in pretty-printed allocations.
             normalized = static_regex!(
-                r"╾─*a(lloc)?([0-9]+)(\+0x[0-9]+)?(<imm>)?( \([0-9]+ ptr bytes\))?─*╼"
+                r"╾─*a(lloc)?([0-9]+)(\+0x[0-9a-f]+)?(<imm>)?( \([0-9]+ ptr bytes\))?─*╼"
             )
             .replace_all(&normalized, |caps: &Captures<'_>| {
                 // Renumber the captured index.
diff --git a/tests/ui/consts/const-eval/ub-ref-ptr.rs b/tests/ui/consts/const-eval/ub-ref-ptr.rs
index 5ff9748af0c15..a5fdde1f9a4e9 100644
--- a/tests/ui/consts/const-eval/ub-ref-ptr.rs
+++ b/tests/ui/consts/const-eval/ub-ref-ptr.rs
@@ -27,6 +27,11 @@ const NULL: &u16 = unsafe { mem::transmute(0usize) };
 const NULL_BOX: Box<u16> = unsafe { mem::transmute(0usize) };
 //~^ ERROR invalid value
 
+const MAYBE_NULL_BOX: Box<()> = unsafe { mem::transmute({
+//~^ ERROR maybe-null
+    let ref_ = &0u8;
+    (ref_ as *const u8).wrapping_add(10)
+}) };
 
 // It is very important that we reject this: We do promote `&(4 * REF_AS_USIZE)`,
 // but that would fail to compile; so we ended up breaking user code that would
@@ -57,7 +62,12 @@ const DANGLING_FN_PTR: fn() = unsafe { mem::transmute(13usize) };
 //~^ ERROR invalid value
 const DATA_FN_PTR: fn() = unsafe { mem::transmute(&13) };
 //~^ ERROR invalid value
-
+const MAYBE_NULL_FN_PTR: fn() = unsafe { mem::transmute({
+//~^ ERROR invalid value
+    fn fun() {}
+    let ptr = fun as fn();
+    (ptr as *const u8).wrapping_add(10)
+}) };
 
 const UNALIGNED_READ: () = unsafe {
     let x = &[0u8; 4];
diff --git a/tests/ui/consts/const-eval/ub-ref-ptr.stderr b/tests/ui/consts/const-eval/ub-ref-ptr.stderr
index 9170cde94e2ad..349a98f11be42 100644
--- a/tests/ui/consts/const-eval/ub-ref-ptr.stderr
+++ b/tests/ui/consts/const-eval/ub-ref-ptr.stderr
@@ -42,8 +42,19 @@ LL | const NULL_BOX: Box<u16> = unsafe { mem::transmute(0usize) };
                HEX_DUMP
            }
 
+error[E0080]: constructing invalid value: encountered a maybe-null box
+  --> $DIR/ub-ref-ptr.rs:30:1
+   |
+LL | const MAYBE_NULL_BOX: Box<()> = unsafe { mem::transmute({
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
+   |
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
+               HEX_DUMP
+           }
+
 error[E0080]: unable to turn pointer into integer
-  --> $DIR/ub-ref-ptr.rs:34:1
+  --> $DIR/ub-ref-ptr.rs:39:1
    |
 LL | const REF_AS_USIZE: usize = unsafe { mem::transmute(&0) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `REF_AS_USIZE` failed here
@@ -52,7 +63,7 @@ LL | const REF_AS_USIZE: usize = unsafe { mem::transmute(&0) };
    = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
 
 error[E0080]: unable to turn pointer into integer
-  --> $DIR/ub-ref-ptr.rs:37:39
+  --> $DIR/ub-ref-ptr.rs:42:39
    |
 LL | const REF_AS_USIZE_SLICE: &[usize] = &[unsafe { mem::transmute(&0) }];
    |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `REF_AS_USIZE_SLICE` failed here
@@ -61,13 +72,13 @@ LL | const REF_AS_USIZE_SLICE: &[usize] = &[unsafe { mem::transmute(&0) }];
    = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
 
 note: erroneous constant encountered
-  --> $DIR/ub-ref-ptr.rs:37:38
+  --> $DIR/ub-ref-ptr.rs:42:38
    |
 LL | const REF_AS_USIZE_SLICE: &[usize] = &[unsafe { mem::transmute(&0) }];
    |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0080]: unable to turn pointer into integer
-  --> $DIR/ub-ref-ptr.rs:40:86
+  --> $DIR/ub-ref-ptr.rs:45:86
    |
 LL | const REF_AS_USIZE_BOX_SLICE: Box<[usize]> = unsafe { mem::transmute::<&[usize], _>(&[mem::transmute(&0)]) };
    |                                                                                      ^^^^^^^^^^^^^^^^^^^^ evaluation of `REF_AS_USIZE_BOX_SLICE` failed here
@@ -76,13 +87,13 @@ LL | const REF_AS_USIZE_BOX_SLICE: Box<[usize]> = unsafe { mem::transmute::<&[us
    = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
 
 note: erroneous constant encountered
-  --> $DIR/ub-ref-ptr.rs:40:85
+  --> $DIR/ub-ref-ptr.rs:45:85
    |
 LL | const REF_AS_USIZE_BOX_SLICE: Box<[usize]> = unsafe { mem::transmute::<&[usize], _>(&[mem::transmute(&0)]) };
    |                                                                                     ^^^^^^^^^^^^^^^^^^^^^
 
 error[E0080]: constructing invalid value: encountered a dangling reference (0x539[noalloc] has no provenance)
-  --> $DIR/ub-ref-ptr.rs:43:1
+  --> $DIR/ub-ref-ptr.rs:48:1
    |
 LL | const USIZE_AS_REF: &'static u8 = unsafe { mem::transmute(1337usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -93,7 +104,7 @@ LL | const USIZE_AS_REF: &'static u8 = unsafe { mem::transmute(1337usize) };
            }
 
 error[E0080]: constructing invalid value: encountered a dangling box (0x539[noalloc] has no provenance)
-  --> $DIR/ub-ref-ptr.rs:46:1
+  --> $DIR/ub-ref-ptr.rs:51:1
    |
 LL | const USIZE_AS_BOX: Box<u8> = unsafe { mem::transmute(1337usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -103,8 +114,8 @@ LL | const USIZE_AS_BOX: Box<u8> = unsafe { mem::transmute(1337usize) };
                HEX_DUMP
            }
 
-error[E0080]: reading memory at ALLOC4[0x%..0x%], but memory is uninitialized at [0x%..0x%], and this operation requires initialized memory
-  --> $DIR/ub-ref-ptr.rs:49:41
+error[E0080]: reading memory at ALLOC6[0x%..0x%], but memory is uninitialized at [0x%..0x%], and this operation requires initialized memory
+  --> $DIR/ub-ref-ptr.rs:54:41
    |
 LL | const UNINIT_PTR: *const i32 = unsafe { MaybeUninit { uninit: () }.init };
    |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `UNINIT_PTR` failed here
@@ -114,7 +125,7 @@ LL | const UNINIT_PTR: *const i32 = unsafe { MaybeUninit { uninit: () }.init };
            }
 
 error[E0080]: constructing invalid value: encountered null pointer, but expected a function pointer
-  --> $DIR/ub-ref-ptr.rs:52:1
+  --> $DIR/ub-ref-ptr.rs:57:1
    |
 LL | const NULL_FN_PTR: fn() = unsafe { mem::transmute(0usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -124,8 +135,8 @@ LL | const NULL_FN_PTR: fn() = unsafe { mem::transmute(0usize) };
                HEX_DUMP
            }
 
-error[E0080]: reading memory at ALLOC5[0x%..0x%], but memory is uninitialized at [0x%..0x%], and this operation requires initialized memory
-  --> $DIR/ub-ref-ptr.rs:54:38
+error[E0080]: reading memory at ALLOC7[0x%..0x%], but memory is uninitialized at [0x%..0x%], and this operation requires initialized memory
+  --> $DIR/ub-ref-ptr.rs:59:38
    |
 LL | const UNINIT_FN_PTR: fn() = unsafe { MaybeUninit { uninit: () }.init };
    |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `UNINIT_FN_PTR` failed here
@@ -135,7 +146,7 @@ LL | const UNINIT_FN_PTR: fn() = unsafe { MaybeUninit { uninit: () }.init };
            }
 
 error[E0080]: constructing invalid value: encountered 0xd[noalloc], but expected a function pointer
-  --> $DIR/ub-ref-ptr.rs:56:1
+  --> $DIR/ub-ref-ptr.rs:61:1
    |
 LL | const DANGLING_FN_PTR: fn() = unsafe { mem::transmute(13usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -145,8 +156,8 @@ LL | const DANGLING_FN_PTR: fn() = unsafe { mem::transmute(13usize) };
                HEX_DUMP
            }
 
-error[E0080]: constructing invalid value: encountered ALLOC2<imm>, but expected a function pointer
-  --> $DIR/ub-ref-ptr.rs:58:1
+error[E0080]: constructing invalid value: encountered ALLOC3<imm>, but expected a function pointer
+  --> $DIR/ub-ref-ptr.rs:63:1
    |
 LL | const DATA_FN_PTR: fn() = unsafe { mem::transmute(&13) };
    | ^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -156,14 +167,25 @@ LL | const DATA_FN_PTR: fn() = unsafe { mem::transmute(&13) };
                HEX_DUMP
            }
 
+error[E0080]: constructing invalid value: encountered ALLOC4+0xa, but expected a function pointer
+  --> $DIR/ub-ref-ptr.rs:65:1
+   |
+LL | const MAYBE_NULL_FN_PTR: fn() = unsafe { mem::transmute({
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
+   |
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
+               HEX_DUMP
+           }
+
 error[E0080]: accessing memory based on pointer with alignment 1, but alignment 4 is required
-  --> $DIR/ub-ref-ptr.rs:65:5
+  --> $DIR/ub-ref-ptr.rs:75:5
    |
 LL |     ptr.read();
    |     ^^^^^^^^^^ evaluation of `UNALIGNED_READ` failed here
 
 error[E0080]: constructing invalid value: encountered a pointer with unknown absolute address, but expected something that is definitely greater or equal to 1000
-  --> $DIR/ub-ref-ptr.rs:74:1
+  --> $DIR/ub-ref-ptr.rs:84:1
    |
 LL | const INVALID_VALUE_PTR: High = unsafe { mem::transmute(&S) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -173,6 +195,6 @@ LL | const INVALID_VALUE_PTR: High = unsafe { mem::transmute(&S) };
                HEX_DUMP
            }
 
-error: aborting due to 16 previous errors
+error: aborting due to 18 previous errors
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const_transmute_type_id7.rs b/tests/ui/consts/const_transmute_type_id7.rs
new file mode 100644
index 0000000000000..73b8187a8007a
--- /dev/null
+++ b/tests/ui/consts/const_transmute_type_id7.rs
@@ -0,0 +1,16 @@
+//! Ensure a decent error message for maybe-null references.
+//! (see <https://github.com/rust-lang/rust/issues/146748>)
+
+// Strip out raw byte dumps to make comparison platform-independent:
+//@ normalize-stderr: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
+//@ normalize-stderr: "([0-9a-f][0-9a-f] |╾─*A(LLOC)?[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
+
+#![feature(const_trait_impl, const_cmp)]
+
+use std::any::TypeId;
+use std::mem::transmute;
+
+const A: [&(); 16 / size_of::<*const ()>()] = unsafe { transmute(TypeId::of::<i32>()) };
+//~^ERROR: maybe-null
+
+fn main() {}
diff --git a/tests/ui/consts/const_transmute_type_id7.stderr b/tests/ui/consts/const_transmute_type_id7.stderr
new file mode 100644
index 0000000000000..664975831f402
--- /dev/null
+++ b/tests/ui/consts/const_transmute_type_id7.stderr
@@ -0,0 +1,14 @@
+error[E0080]: constructing invalid value at [0]: encountered a maybe-null reference
+  --> $DIR/const_transmute_type_id7.rs:13:1
+   |
+LL | const A: [&(); 16 / size_of::<*const ()>()] = unsafe { transmute(TypeId::of::<i32>()) };
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
+   |
+   = note: the rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+   = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
+               HEX_DUMP
+           }
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0080`.

From a875f7779e3c3b9023bff24b6beca08e7be0e0e8 Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Wed, 24 Sep 2025 14:13:34 +0200
Subject: [PATCH 1337/1889] alloc: simplify `Default` for `Box<CStr>` and
 `Rc<CStr>`

---
 library/alloc/src/ffi/c_str.rs | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/library/alloc/src/ffi/c_str.rs b/library/alloc/src/ffi/c_str.rs
index b0c8c4b1ca4a7..3e78d680ea68a 100644
--- a/library/alloc/src/ffi/c_str.rs
+++ b/library/alloc/src/ffi/c_str.rs
@@ -970,17 +970,14 @@ impl Default for Rc<CStr> {
     /// This may or may not share an allocation with other Rcs on the same thread.
     #[inline]
     fn default() -> Self {
-        let rc = Rc::<[u8]>::from(*b"\0");
-        // `[u8]` has the same layout as `CStr`, and it is `NUL` terminated.
-        unsafe { Rc::from_raw(Rc::into_raw(rc) as *const CStr) }
+        Rc::from(c"")
     }
 }
 
 #[stable(feature = "default_box_extra", since = "1.17.0")]
 impl Default for Box<CStr> {
     fn default() -> Box<CStr> {
-        let boxed: Box<[u8]> = Box::from([0]);
-        unsafe { Box::from_raw(Box::into_raw(boxed) as *mut CStr) }
+        Box::from(c"")
     }
 }
 

From 0e7cc32633ea7c7978529d3d4478b17474383a18 Mon Sep 17 00:00:00 2001
From: Shoyu Vanilla <modulo641@gmail.com>
Date: Wed, 24 Sep 2025 21:28:50 +0900
Subject: [PATCH 1338/1889] Switch next-solver related rustc dependencies of
 r-a to crates.io ones

---
 .../rust-analyzer/crates/hir-def/src/lib.rs   |  4 ---
 .../rust-analyzer/crates/hir-ty/src/lib.rs    | 31 +++----------------
 .../crates/hir-ty/src/next_solver/consts.rs   |  2 --
 .../hir-ty/src/next_solver/predicate.rs       |  2 --
 .../crates/hir-ty/src/next_solver/ty.rs       |  2 --
 src/tools/rust-analyzer/crates/hir/src/lib.rs |  4 ---
 6 files changed, 5 insertions(+), 40 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-def/src/lib.rs b/src/tools/rust-analyzer/crates/hir-def/src/lib.rs
index 301d4cca0666c..e5c213ca937c8 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/lib.rs
@@ -15,10 +15,6 @@ extern crate rustc_parse_format;
 #[cfg(not(feature = "in-rust-tree"))]
 extern crate ra_ap_rustc_parse_format as rustc_parse_format;
 
-#[cfg(feature = "in-rust-tree")]
-extern crate rustc_abi;
-
-#[cfg(not(feature = "in-rust-tree"))]
 extern crate ra_ap_rustc_abi as rustc_abi;
 
 pub mod db;
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 451622ef7472b..2e59a488e6734 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
@@ -3,45 +3,24 @@
 
 #![cfg_attr(feature = "in-rust-tree", feature(rustc_private))]
 
-#[cfg(feature = "in-rust-tree")]
-extern crate rustc_index;
+// FIXME: We used to import `rustc_*` deps from `rustc_private` with `feature = "in-rust-tree" but
+// temporarily switched to crates.io versions due to hardships that working on them from rustc
+// demands corresponding changes on rust-analyzer at the same time.
+// For details, see the zulip discussion below:
+// https://rust-lang.zulipchat.com/#narrow/channel/185405-t-compiler.2Frust-analyzer/topic/relying.20on.20in-tree.20.60rustc_type_ir.60.2F.60rustc_next_trait_solver.60/with/541055689
 
-#[cfg(not(feature = "in-rust-tree"))]
 extern crate ra_ap_rustc_index as rustc_index;
 
-#[cfg(feature = "in-rust-tree")]
-extern crate rustc_abi;
-
-#[cfg(not(feature = "in-rust-tree"))]
 extern crate ra_ap_rustc_abi as rustc_abi;
 
-#[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;
 
-#[cfg(feature = "in-rust-tree")]
-extern crate rustc_ast_ir;
-
-#[cfg(not(feature = "in-rust-tree"))]
 extern crate ra_ap_rustc_ast_ir as rustc_ast_ir;
 
-#[cfg(feature = "in-rust-tree")]
-extern crate rustc_type_ir;
-
-#[cfg(not(feature = "in-rust-tree"))]
 extern crate ra_ap_rustc_type_ir as rustc_type_ir;
 
-#[cfg(feature = "in-rust-tree")]
-extern crate rustc_next_trait_solver;
-
-#[cfg(not(feature = "in-rust-tree"))]
 extern crate ra_ap_rustc_next_trait_solver as rustc_next_trait_solver;
 
-#[cfg(feature = "in-rust-tree")]
-extern crate rustc_data_structures as ena;
-
 mod builder;
 mod chalk_db;
 mod chalk_ext;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs
index 7ebefa76ed029..0b3582051bc07 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/consts.rs
@@ -36,8 +36,6 @@ impl<'db> Const<'db> {
             internee: kind,
             flags: flags.flags,
             outer_exclusive_binder: flags.outer_exclusive_binder,
-            #[cfg(feature = "in-rust-tree")]
-            stable_hash: ena::fingerprint::Fingerprint::ZERO,
         };
         Const::new_(interner.db(), InternedWrapperNoDebug(cached))
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/predicate.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/predicate.rs
index 86545415009a0..99b1354b6335f 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/predicate.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/predicate.rs
@@ -227,8 +227,6 @@ impl<'db> Predicate<'db> {
             internee: kind,
             flags: flags.flags,
             outer_exclusive_binder: flags.outer_exclusive_binder,
-            #[cfg(feature = "in-rust-tree")]
-            stable_hash: ena::fingerprint::Fingerprint::ZERO,
         };
         Predicate::new_(interner.db(), InternedWrapperNoDebug(cached))
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
index c7a747ade3e76..70139e8666948 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
@@ -60,8 +60,6 @@ impl<'db> Ty<'db> {
             internee: kind,
             flags: flags.flags,
             outer_exclusive_binder: flags.outer_exclusive_binder,
-            #[cfg(feature = "in-rust-tree")]
-            stable_hash: ena::fingerprint::Fingerprint::ZERO,
         };
         Ty::new_(interner.db(), InternedWrapperNoDebug(cached))
     }
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index f8dacf0fb863d..027a386abe8ce 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -20,10 +20,6 @@
 #![cfg_attr(feature = "in-rust-tree", feature(rustc_private))]
 #![recursion_limit = "512"]
 
-#[cfg(feature = "in-rust-tree")]
-extern crate rustc_type_ir;
-
-#[cfg(not(feature = "in-rust-tree"))]
 extern crate ra_ap_rustc_type_ir as rustc_type_ir;
 
 mod attrs;

From 7a0adc08786df857e810c9f6a5a0cb6cae32659b Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Wed, 24 Sep 2025 15:02:41 +0200
Subject: [PATCH 1339/1889] add test

---
 .../coroutine/copy-fast-path-query-cycle.rs   | 40 +++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 tests/ui/coroutine/copy-fast-path-query-cycle.rs

diff --git a/tests/ui/coroutine/copy-fast-path-query-cycle.rs b/tests/ui/coroutine/copy-fast-path-query-cycle.rs
new file mode 100644
index 0000000000000..644cba0d47af2
--- /dev/null
+++ b/tests/ui/coroutine/copy-fast-path-query-cycle.rs
@@ -0,0 +1,40 @@
+//@ edition: 2024
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
+//@ check-pass
+
+// Regression test for #146813. We previously used a pseudo-canonical
+// query during HIR typeck which caused a query cycle when looking at the
+// witness of a coroutine.
+
+use std::future::Future;
+
+trait ConnectMiddleware {}
+
+trait ConnectHandler: Sized {
+    fn with<M>(self, _: M) -> impl ConnectHandler
+    where
+        M: ConnectMiddleware,
+    {
+        LayeredConnectHandler
+    }
+}
+
+struct LayeredConnectHandler;
+impl ConnectHandler for LayeredConnectHandler {}
+impl<F> ConnectHandler for F where F: FnOnce() {}
+
+impl<F, Fut> ConnectMiddleware for F
+where
+    F: FnOnce() -> Fut,
+    Fut: Future<Output = ()> + Send,
+{
+}
+
+pub async fn fails() {
+    { || {} }
+        .with(async || ())
+        .with(async || ())
+        .with(async || ());
+}
+fn main() {}

From d91025316554f9cff948639ee34bf217ef724947 Mon Sep 17 00:00:00 2001
From: Nathaniel McCallum <nathaniel@mccallum.life>
Date: Sat, 13 Sep 2025 08:51:28 -0400
Subject: [PATCH 1340/1889] constify Default on Nanoseconds

---
 library/core/src/num/niche_types.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/library/core/src/num/niche_types.rs b/library/core/src/num/niche_types.rs
index 610d9d8cf92e0..9ac0eb72bdcbc 100644
--- a/library/core/src/num/niche_types.rs
+++ b/library/core/src/num/niche_types.rs
@@ -112,7 +112,8 @@ impl Nanoseconds {
     pub const ZERO: Self = unsafe { Nanoseconds::new_unchecked(0) };
 }
 
-impl Default for Nanoseconds {
+#[rustc_const_unstable(feature = "const_default", issue = "143894")]
+impl const Default for Nanoseconds {
     #[inline]
     fn default() -> Self {
         Self::ZERO

From 4acea466e42758468e6cd1de7c6173eabcd5f1b3 Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Wed, 24 Sep 2025 13:26:53 +0000
Subject: [PATCH 1341/1889] simplify setup_constraining_predicates, and note it
 is potentially cubic

---
 .../src/constrained_generic_params.rs         | 52 +++++++++----------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/constrained_generic_params.rs b/compiler/rustc_hir_analysis/src/constrained_generic_params.rs
index 366b3943a0589..44d7f3a5e8bc2 100644
--- a/compiler/rustc_hir_analysis/src/constrained_generic_params.rs
+++ b/compiler/rustc_hir_analysis/src/constrained_generic_params.rs
@@ -167,15 +167,20 @@ pub(crate) fn setup_constraining_predicates<'tcx>(
     // which is `O(nt)` where `t` is the depth of type-parameter constraints,
     // remembering that `t` should be less than 7 in practice.
     //
+    // FIXME(hkBst): the big-O bound above would be accurate for the number
+    // of calls to `parameters_for`, which itself is some O(complexity of type).
+    // That would make this potentially cubic instead of merely quadratic...
+    // ...unless we cache those `parameters_for` calls.
+    //
     // Basically, I iterate over all projections and swap every
     // "ready" projection to the start of the list, such that
     // all of the projections before `i` are topologically sorted
     // and constrain all the parameters in `input_parameters`.
     //
-    // In the example, `input_parameters` starts by containing `U` - which
-    // is constrained by the trait-ref - and so on the first pass we
+    // In the first example, `input_parameters` starts by containing `U`,
+    // which is constrained by the self type `U`. Then, on the first pass we
     // observe that `<U as Iterator>::Item = T` is a "ready" projection that
-    // constrains `T` and swap it to front. As it is the sole projection,
+    // constrains `T` and swap it to the front. As it is the sole projection,
     // no more swaps can take place afterwards, with the result being
     //   * <U as Iterator>::Item = T
     //   * T: Debug
@@ -193,33 +198,28 @@ pub(crate) fn setup_constraining_predicates<'tcx>(
         for j in i..predicates.len() {
             // Note that we don't have to care about binders here,
             // as the impl trait ref never contains any late-bound regions.
-            if let ty::ClauseKind::Projection(projection) = predicates[j].0.kind().skip_binder() {
-                // Special case: watch out for some kind of sneaky attempt
-                // to project out an associated type defined by this very
-                // trait.
-                let unbound_trait_ref = projection.projection_term.trait_ref(tcx);
-                if Some(unbound_trait_ref) == impl_trait_ref {
-                    continue;
-                }
-
-                // A projection depends on its input types and determines its output
-                // type. For example, if we have
-                //     `<<T as Bar>::Baz as Iterator>::Output = <U as Iterator>::Output`
-                // Then the projection only applies if `T` is known, but it still
-                // does not determine `U`.
+            if let ty::ClauseKind::Projection(projection) = predicates[j].0.kind().skip_binder() &&
+
+            // Special case: watch out for some kind of sneaky attempt to
+            // project out an associated type defined by this very trait.
+            !impl_trait_ref.is_some_and(|t| t == projection.projection_term.trait_ref(tcx)) &&
+
+            // A projection depends on its input types and determines its output
+            // type. For example, if we have
+            //     `<<T as Bar>::Baz as Iterator>::Output = <U as Iterator>::Output`
+            // then the projection only applies if `T` is known, but it still
+            // does not determine `U`.
+            {
                 let inputs = parameters_for(tcx, projection.projection_term, true);
                 let relies_only_on_inputs = inputs.iter().all(|p| input_parameters.contains(p));
-                if !relies_only_on_inputs {
-                    continue;
-                }
+                relies_only_on_inputs
+            } {
                 input_parameters.extend(parameters_for(tcx, projection.term, false));
-            } else {
-                continue;
+
+                predicates.swap(i, j);
+                i += 1;
+                changed = true;
             }
-            // fancy control flow to bypass borrow checker
-            predicates.swap(i, j);
-            i += 1;
-            changed = true;
         }
         debug!(
             "setup_constraining_predicates: predicates={:?} \

From 56734495e2fd485a7be1ba77da1bf18a0eca4636 Mon Sep 17 00:00:00 2001
From: BenjaminBrienen <Benjamin.Brienen@outlook.com>
Date: Wed, 24 Sep 2025 14:25:10 +0200
Subject: [PATCH 1342/1889] feature: Implement vec_try_remove Vec::try_remove
 is a non-panicking version of Vec::remove

---
 library/alloc/src/vec/mod.rs    | 32 ++++++++++++++++++++++++++++++--
 library/alloctests/tests/lib.rs |  1 +
 library/alloctests/tests/vec.rs | 15 +++++++++++++++
 3 files changed, 46 insertions(+), 2 deletions(-)

diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs
index ebdb86f98a857..694b7b2df08fe 100644
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -2173,9 +2173,37 @@ impl<T, A: Allocator> Vec<T, A> {
             panic!("removal index (is {index}) should be < len (is {len})");
         }
 
+        match self.try_remove(index) {
+            Some(elem) => elem,
+            None => assert_failed(index, self.len()),
+        }
+    }
+
+    /// Remove and return the element at position `index` within the vector,
+    /// shifting all elements after it to the left, or [`None`] if it does not
+    /// exist.
+    ///
+    /// Note: Because this shifts over the remaining elements, it has a
+    /// worst-case performance of *O*(*n*). If you'd like to remove
+    /// elements from the beginning of the `Vec`, consider using
+    /// [`VecDeque::pop_front`] instead.
+    ///
+    /// [`VecDeque::pop_front`]: crate::collections::VecDeque::pop_front
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(vec_try_remove)]
+    /// let mut v = vec![1, 2, 3];
+    /// assert_eq!(v.try_remove(0), Some(1));
+    /// assert_eq!(v.try_remove(2), None);
+    /// ```
+    #[unstable(feature = "vec_try_remove", issue = "146954")]
+    #[rustc_confusables("delete", "take", "remove")]
+    pub fn try_remove(&mut self, index: usize) -> Option<T> {
         let len = self.len();
         if index >= len {
-            assert_failed(index, len);
+            return None;
         }
         unsafe {
             // infallible
@@ -2191,7 +2219,7 @@ impl<T, A: Allocator> Vec<T, A> {
                 ptr::copy(ptr.add(1), ptr, len - index - 1);
             }
             self.set_len(len - 1);
-            ret
+            Some(ret)
         }
     }
 
diff --git a/library/alloctests/tests/lib.rs b/library/alloctests/tests/lib.rs
index 8c3ce156f3c1d..cba9883e148e2 100644
--- a/library/alloctests/tests/lib.rs
+++ b/library/alloctests/tests/lib.rs
@@ -41,6 +41,7 @@
 #![feature(unique_rc_arc)]
 #![feature(macro_metavar_expr_concat)]
 #![feature(vec_peek_mut)]
+#![feature(vec_try_remove)]
 #![allow(internal_features)]
 #![deny(fuzzy_provenance_casts)]
 #![deny(unsafe_op_in_unsafe_fn)]
diff --git a/library/alloctests/tests/vec.rs b/library/alloctests/tests/vec.rs
index 33a34daccbfd2..ea334ab0f143a 100644
--- a/library/alloctests/tests/vec.rs
+++ b/library/alloctests/tests/vec.rs
@@ -630,6 +630,21 @@ fn test_swap_remove_empty() {
     vec.swap_remove(0);
 }
 
+#[test]
+fn test_try_remove() {
+    let mut vec = vec![1, 2, 3];
+    // We are attempting to remove vec[0] which contains 1
+    assert_eq!(vec.try_remove(0), Some(1));
+    // Now `vec` looks like: [2, 3]
+    // We will now try to remove vec[2] which does not exist
+    // This should return `None`
+    assert_eq!(vec.try_remove(2), None);
+
+    // We will try the same thing with an empty vector
+    let mut v: Vec<u8> = vec![];
+    assert!(v.try_remove(0).is_none());
+}
+
 #[test]
 fn test_move_items() {
     let vec = vec![1, 2, 3];

From 30289353e8e04eff33a0e533b6b398c308b24025 Mon Sep 17 00:00:00 2001
From: tiif <pekyuan@gmail.com>
Date: Mon, 22 Sep 2025 15:50:22 +0000
Subject: [PATCH 1343/1889] Improve derive suggestion of const param

Make the suggestion not to remove the adt and use the name of the adt
variant
---
 .../src/error_reporting/traits/fulfillment_errors.rs  | 11 +++++++----
 .../forbid-non-structural_match-types.stderr          |  2 +-
 tests/ui/const-generics/issue-80471.stderr            |  4 ++--
 tests/ui/const-generics/issues/issue-97278.stderr     |  4 ++--
 .../ui/consts/refs_check_const_eq-issue-88384.stderr  |  4 ++--
 5 files changed, 14 insertions(+), 11 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 149f5e638b1ad..d485eb7266b28 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
@@ -1305,8 +1305,8 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 {
                     if ty.is_structural_eq_shallow(self.tcx) {
                         diag.span_suggestion(
-                            span,
-                            "add `#[derive(ConstParamTy)]` to the struct",
+                            span.shrink_to_lo(),
+                            format!("add `#[derive(ConstParamTy)]` to the {}", def.descr()),
                             "#[derive(ConstParamTy)]\n",
                             Applicability::MachineApplicable,
                         );
@@ -1314,8 +1314,11 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         // FIXME(adt_const_params): We should check there's not already an
                         // overlapping `Eq`/`PartialEq` impl.
                         diag.span_suggestion(
-                            span,
-                            "add `#[derive(ConstParamTy, PartialEq, Eq)]` to the struct",
+                            span.shrink_to_lo(),
+                            format!(
+                                "add `#[derive(ConstParamTy, PartialEq, Eq)]` to the {}",
+                                def.descr()
+                            ),
                             "#[derive(ConstParamTy, PartialEq, Eq)]\n",
                             Applicability::MachineApplicable,
                         );
diff --git a/tests/ui/const-generics/forbid-non-structural_match-types.stderr b/tests/ui/const-generics/forbid-non-structural_match-types.stderr
index 8ef629329f103..94afded9469e8 100644
--- a/tests/ui/const-generics/forbid-non-structural_match-types.stderr
+++ b/tests/ui/const-generics/forbid-non-structural_match-types.stderr
@@ -6,8 +6,8 @@ LL | struct D<const X: C>;
    |
 help: add `#[derive(ConstParamTy, PartialEq, Eq)]` to the struct
    |
-LL - struct C;
 LL + #[derive(ConstParamTy, PartialEq, Eq)]
+LL | struct C;
    |
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/const-generics/issue-80471.stderr b/tests/ui/const-generics/issue-80471.stderr
index 8cf3d68e5d691..fff2eb53cf126 100644
--- a/tests/ui/const-generics/issue-80471.stderr
+++ b/tests/ui/const-generics/issue-80471.stderr
@@ -4,10 +4,10 @@ error[E0741]: `Nat` must implement `ConstParamTy` to be used as the type of a co
 LL | fn foo<const N: Nat>() {}
    |                 ^^^
    |
-help: add `#[derive(ConstParamTy)]` to the struct
+help: add `#[derive(ConstParamTy)]` to the enum
    |
-LL - enum Nat {
 LL + #[derive(ConstParamTy)]
+LL | enum Nat {
    |
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/const-generics/issues/issue-97278.stderr b/tests/ui/const-generics/issues/issue-97278.stderr
index 4894ddb7b8db8..21a5fc94032c0 100644
--- a/tests/ui/const-generics/issues/issue-97278.stderr
+++ b/tests/ui/const-generics/issues/issue-97278.stderr
@@ -4,10 +4,10 @@ error[E0741]: `Bar` must implement `ConstParamTy` to be used as the type of a co
 LL | fn test<const BAR: Bar>() {}
    |                    ^^^
    |
-help: add `#[derive(ConstParamTy)]` to the struct
+help: add `#[derive(ConstParamTy)]` to the enum
    |
-LL - enum Bar {
 LL + #[derive(ConstParamTy)]
+LL | enum Bar {
    |
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/consts/refs_check_const_eq-issue-88384.stderr b/tests/ui/consts/refs_check_const_eq-issue-88384.stderr
index 65e4dc22c2887..62c5c52764115 100644
--- a/tests/ui/consts/refs_check_const_eq-issue-88384.stderr
+++ b/tests/ui/consts/refs_check_const_eq-issue-88384.stderr
@@ -15,8 +15,8 @@ LL | struct Foo<const T: CompileTimeSettings>;
    |
 help: add `#[derive(ConstParamTy)]` to the struct
    |
-LL - struct CompileTimeSettings {
 LL + #[derive(ConstParamTy)]
+LL | struct CompileTimeSettings {
    |
 
 error[E0741]: `CompileTimeSettings` must implement `ConstParamTy` to be used as the type of a const generic parameter
@@ -27,8 +27,8 @@ LL | impl<const T: CompileTimeSettings> Foo<T> {
    |
 help: add `#[derive(ConstParamTy)]` to the struct
    |
-LL - struct CompileTimeSettings {
 LL + #[derive(ConstParamTy)]
+LL | struct CompileTimeSettings {
    |
 
 error: aborting due to 2 previous errors; 1 warning emitted

From 5a4e53603631475335bab3e1416f4aca61172094 Mon Sep 17 00:00:00 2001
From: Iris Shi <0.0@owo.li>
Date: Wed, 24 Sep 2025 12:55:38 +0800
Subject: [PATCH 1344/1889] Fix infinite recursion in Path::eq with String

---
 library/std/src/path.rs   | 12 ++++++------
 library/std/tests/path.rs | 16 +++++++++++++---
 2 files changed, 19 insertions(+), 9 deletions(-)

diff --git a/library/std/src/path.rs b/library/std/src/path.rs
index 70ba502d68421..88d8a4f21cac5 100644
--- a/library/std/src/path.rs
+++ b/library/std/src/path.rs
@@ -2107,7 +2107,7 @@ impl PartialEq for PathBuf {
 impl cmp::PartialEq<str> for PathBuf {
     #[inline]
     fn eq(&self, other: &str) -> bool {
-        Path::eq(self, other)
+        self.as_path() == other
     }
 }
 
@@ -2115,7 +2115,7 @@ impl cmp::PartialEq<str> for PathBuf {
 impl cmp::PartialEq<PathBuf> for str {
     #[inline]
     fn eq(&self, other: &PathBuf) -> bool {
-        other == self
+        self == other.as_path()
     }
 }
 
@@ -2123,7 +2123,7 @@ impl cmp::PartialEq<PathBuf> for str {
 impl cmp::PartialEq<String> for PathBuf {
     #[inline]
     fn eq(&self, other: &String) -> bool {
-        **self == **other
+        self.as_path() == other.as_str()
     }
 }
 
@@ -2131,7 +2131,7 @@ impl cmp::PartialEq<String> for PathBuf {
 impl cmp::PartialEq<PathBuf> for String {
     #[inline]
     fn eq(&self, other: &PathBuf) -> bool {
-        other == self
+        self.as_str() == other.as_path()
     }
 }
 
@@ -3426,7 +3426,7 @@ impl cmp::PartialEq<Path> for str {
 impl cmp::PartialEq<String> for Path {
     #[inline]
     fn eq(&self, other: &String) -> bool {
-        self == &*other
+        self == other.as_str()
     }
 }
 
@@ -3434,7 +3434,7 @@ impl cmp::PartialEq<String> for Path {
 impl cmp::PartialEq<Path> for String {
     #[inline]
     fn eq(&self, other: &Path) -> bool {
-        other == self
+        self.as_str() == other
     }
 }
 
diff --git a/library/std/tests/path.rs b/library/std/tests/path.rs
index fa76c50597b05..837a14b808ff8 100644
--- a/library/std/tests/path.rs
+++ b/library/std/tests/path.rs
@@ -2528,7 +2528,17 @@ fn normalize_lexically() {
 }
 
 #[test]
-/// See issue#146183
-fn compare_path_to_str() {
-    assert!(&PathBuf::from("x") == "x");
+/// See issue#146183 and issue#146940
+fn compare_path_like_to_str_like() {
+    let path_buf = PathBuf::from("x");
+    let path = Path::new("x");
+    let s = String::from("x");
+    assert!(path == "x");
+    assert!("x" == path);
+    assert!(path == &s);
+    assert!(&s == path);
+    assert!(&path_buf == "x");
+    assert!("x" == &path_buf);
+    assert!(path_buf == s);
+    assert!(s == path_buf);
 }

From 6dafcaf6c85e235b259f1d2f1da3268bda74ab65 Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Wed, 24 Sep 2025 09:33:43 -0400
Subject: [PATCH 1345/1889] Update cargo submodule

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

diff --git a/src/tools/cargo b/src/tools/cargo
index 966f94733bbc9..f2932725b045d 160000
--- a/src/tools/cargo
+++ b/src/tools/cargo
@@ -1 +1 @@
-Subproject commit 966f94733bbc94ca51ff9f1e4c49ad250ebbdc50
+Subproject commit f2932725b045d361ff5f18ba02b1409dd1f44e71

From f509dff56d82de64c37080731cbada0ac4dde2b7 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 18 Sep 2025 21:55:05 +0200
Subject: [PATCH 1346/1889] f16_f128: enable some more tests in Miri

---
 library/coretests/tests/floats/mod.rs | 32 +++++++++++++--------------
 1 file changed, 15 insertions(+), 17 deletions(-)

diff --git a/library/coretests/tests/floats/mod.rs b/library/coretests/tests/floats/mod.rs
index d2b5722309445..d8a831af78d3e 100644
--- a/library/coretests/tests/floats/mod.rs
+++ b/library/coretests/tests/floats/mod.rs
@@ -1180,15 +1180,12 @@ float_test! {
     }
 }
 
-// FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
-// the intrinsics.
-
 float_test! {
     name: sqrt_domain,
     attrs: {
         const: #[cfg(false)],
-        f16: #[cfg(all(not(miri), target_has_reliable_f16_math))],
-        f128: #[cfg(all(not(miri), target_has_reliable_f128_math))],
+        f16: #[cfg(any(miri, target_has_reliable_f16_math))],
+        f128: #[cfg(any(miri, target_has_reliable_f128_math))],
     },
     test<Float> {
         assert!(Float::NAN.sqrt().is_nan());
@@ -1246,8 +1243,8 @@ float_test! {
 float_test! {
     name: total_cmp,
     attrs: {
-        f16: #[cfg(all(not(miri), target_has_reliable_f16_math))],
-        f128: #[cfg(all(not(miri), target_has_reliable_f128_math))],
+        f16: #[cfg(any(miri, target_has_reliable_f16_math))],
+        f128: #[cfg(any(miri, target_has_reliable_f128_math))],
     },
     test<Float> {
         use core::cmp::Ordering;
@@ -1355,8 +1352,8 @@ float_test! {
     name: total_cmp_s_nan,
     attrs: {
         const: #[cfg(false)],
-        f16: #[cfg(false)],
-        f128: #[cfg(all(not(miri), target_has_reliable_f128_math))],
+        f16: #[cfg(miri)],
+        f128: #[cfg(any(miri, target_has_reliable_f128_math))],
     },
     test<Float> {
         use core::cmp::Ordering;
@@ -1432,6 +1429,7 @@ float_test! {
     name: powi,
     attrs: {
         const: #[cfg(false)],
+        // FIXME(f16_f128): `powi` does not work in Miri for these types
         f16: #[cfg(all(not(miri), target_has_reliable_f16_math))],
         f128: #[cfg(all(not(miri), target_has_reliable_f128_math))],
     },
@@ -1452,8 +1450,8 @@ float_test! {
 float_test! {
     name: to_degrees,
     attrs: {
-        f16: #[cfg(target_has_reliable_f16)],
-        f128: #[cfg(target_has_reliable_f128)],
+        f16: #[cfg(any(miri, target_has_reliable_f16))],
+        f128: #[cfg(any(miri, target_has_reliable_f128))],
     },
     test<Float> {
         let pi: Float = Float::PI;
@@ -1473,8 +1471,8 @@ float_test! {
 float_test! {
     name: to_radians,
     attrs: {
-        f16: #[cfg(target_has_reliable_f16)],
-        f128: #[cfg(target_has_reliable_f128)],
+        f16: #[cfg(any(miri, target_has_reliable_f16))],
+        f128: #[cfg(any(miri, target_has_reliable_f128))],
     },
     test<Float> {
         let pi: Float = Float::PI;
@@ -1494,8 +1492,8 @@ float_test! {
 float_test! {
     name: to_algebraic,
     attrs: {
-        f16: #[cfg(target_has_reliable_f16)],
-        f128: #[cfg(target_has_reliable_f128)],
+        f16: #[cfg(any(miri, target_has_reliable_f16))],
+        f128: #[cfg(any(miri, target_has_reliable_f128))],
     },
     test<Float> {
         let a: Float = 123.0;
@@ -1518,8 +1516,8 @@ float_test! {
 float_test! {
     name: to_bits_conv,
     attrs: {
-        f16: #[cfg(target_has_reliable_f16)],
-        f128: #[cfg(target_has_reliable_f128)],
+        f16: #[cfg(any(miri, target_has_reliable_f16))],
+        f128: #[cfg(any(miri, target_has_reliable_f128))],
     },
     test<Float> {
         assert_biteq!(flt(1.0), Float::RAW_1);

From 431ef038a3b20e680687a98c4ad2507ae27a7b0a Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Wed, 24 Sep 2025 15:18:31 +0000
Subject: [PATCH 1347/1889] impl Ord for params and use unstable sort

---
 compiler/rustc_hir_analysis/src/constrained_generic_params.rs   | 2 +-
 .../rustc_hir_analysis/src/impl_wf_check/min_specialization.rs  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/constrained_generic_params.rs b/compiler/rustc_hir_analysis/src/constrained_generic_params.rs
index 366b3943a0589..2a633810cd701 100644
--- a/compiler/rustc_hir_analysis/src/constrained_generic_params.rs
+++ b/compiler/rustc_hir_analysis/src/constrained_generic_params.rs
@@ -4,7 +4,7 @@ use rustc_middle::ty::{self, Ty, TyCtxt, TypeFoldable, TypeSuperVisitable, TypeV
 use rustc_span::Span;
 use tracing::debug;
 
-#[derive(Clone, PartialEq, Eq, Hash, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub(crate) struct Parameter(pub u32);
 
 impl From<ty::ParamTy> for Parameter {
diff --git a/compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs b/compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs
index b38639ed8c624..13c744ab46139 100644
--- a/compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs
+++ b/compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs
@@ -275,7 +275,7 @@ fn check_duplicate_params<'tcx>(
     span: Span,
 ) -> Result<(), ErrorGuaranteed> {
     let mut base_params = cgp::parameters_for(tcx, parent_args, true);
-    base_params.sort_by_key(|param| param.0);
+    base_params.sort_unstable();
     if let (_, [duplicate, ..]) = base_params.partition_dedup() {
         let param = impl1_args[duplicate.0 as usize];
         return Err(tcx

From 4e62715541925e1a62aebb3b8a0f633a674b808d Mon Sep 17 00:00:00 2001
From: tiif <pekyuan@gmail.com>
Date: Fri, 19 Sep 2025 07:07:49 +0000
Subject: [PATCH 1348/1889] Improve the pretty print of UnstableFeature clause

---
 compiler/rustc_middle/src/ty/print/pretty.rs                | 3 +--
 .../const-generics/adt_const_params/unsized_field-1.stderr  | 6 +++---
 .../unstable_impl_coherence.disabled.stderr                 | 2 +-
 .../unstable_impl_coherence.enabled.stderr                  | 2 +-
 .../unstable_impl_method_selection.stderr                   | 2 +-
 5 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index 1b7ef8de8454a..8f7c8170f7adf 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -3177,8 +3177,7 @@ define_print! {
                 write!(p, "` can be evaluated")?;
             }
             ty::ClauseKind::UnstableFeature(symbol) => {
-                write!(p, "unstable feature: ")?;
-                write!(p, "`{symbol}`")?;
+                write!(p, "feature({symbol}) is enabled")?;
             }
         }
     }
diff --git a/tests/ui/const-generics/adt_const_params/unsized_field-1.stderr b/tests/ui/const-generics/adt_const_params/unsized_field-1.stderr
index a5ae5c726da86..134dbba0d63ab 100644
--- a/tests/ui/const-generics/adt_const_params/unsized_field-1.stderr
+++ b/tests/ui/const-generics/adt_const_params/unsized_field-1.stderr
@@ -7,7 +7,7 @@ LL |
 LL | struct A([u8]);
    |          ---- this field does not implement `ConstParamTy_`
    |
-note: the `ConstParamTy_` impl for `[u8]` requires that `unstable feature: `unsized_const_params``
+note: the `ConstParamTy_` impl for `[u8]` requires that `feature(unsized_const_params) is enabled`
   --> $DIR/unsized_field-1.rs:10:10
    |
 LL | struct A([u8]);
@@ -22,7 +22,7 @@ LL |
 LL | struct B(&'static [u8]);
    |          ------------- this field does not implement `ConstParamTy_`
    |
-note: the `ConstParamTy_` impl for `&'static [u8]` requires that `unstable feature: `unsized_const_params``
+note: the `ConstParamTy_` impl for `&'static [u8]` requires that `feature(unsized_const_params) is enabled`
   --> $DIR/unsized_field-1.rs:14:10
    |
 LL | struct B(&'static [u8]);
@@ -37,7 +37,7 @@ LL |
 LL | struct D(unsized_const_param::GenericNotUnsizedParam<&'static [u8]>);
    |          ---------------------------------------------------------- this field does not implement `ConstParamTy_`
    |
-note: the `ConstParamTy_` impl for `GenericNotUnsizedParam<&'static [u8]>` requires that `unstable feature: `unsized_const_params``
+note: the `ConstParamTy_` impl for `GenericNotUnsizedParam<&'static [u8]>` requires that `feature(unsized_const_params) is enabled`
   --> $DIR/unsized_field-1.rs:21:10
    |
 LL | struct D(unsized_const_param::GenericNotUnsizedParam<&'static [u8]>);
diff --git a/tests/ui/unstable-feature-bound/unstable_impl_coherence.disabled.stderr b/tests/ui/unstable-feature-bound/unstable_impl_coherence.disabled.stderr
index c3147558b03f9..afef024e1b9c1 100644
--- a/tests/ui/unstable-feature-bound/unstable_impl_coherence.disabled.stderr
+++ b/tests/ui/unstable-feature-bound/unstable_impl_coherence.disabled.stderr
@@ -6,7 +6,7 @@ LL | impl aux::Trait for LocalTy {}
    |
    = note: conflicting implementation in crate `unstable_impl_coherence_aux`:
            - impl<T> Trait for T
-             where unstable feature: `foo`;
+             where feature(foo) is enabled;
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/unstable-feature-bound/unstable_impl_coherence.enabled.stderr b/tests/ui/unstable-feature-bound/unstable_impl_coherence.enabled.stderr
index c3147558b03f9..afef024e1b9c1 100644
--- a/tests/ui/unstable-feature-bound/unstable_impl_coherence.enabled.stderr
+++ b/tests/ui/unstable-feature-bound/unstable_impl_coherence.enabled.stderr
@@ -6,7 +6,7 @@ LL | impl aux::Trait for LocalTy {}
    |
    = note: conflicting implementation in crate `unstable_impl_coherence_aux`:
            - impl<T> Trait for T
-             where unstable feature: `foo`;
+             where feature(foo) is enabled;
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/unstable-feature-bound/unstable_impl_method_selection.stderr b/tests/ui/unstable-feature-bound/unstable_impl_method_selection.stderr
index c2bb10f043b2e..840af730154d9 100644
--- a/tests/ui/unstable-feature-bound/unstable_impl_method_selection.stderr
+++ b/tests/ui/unstable-feature-bound/unstable_impl_method_selection.stderr
@@ -7,7 +7,7 @@ LL |     vec![].foo();
    = note: multiple `impl`s satisfying `Vec<_>: Trait` found in the `unstable_impl_method_selection_aux` crate:
            - impl Trait for Vec<u32>;
            - impl Trait for Vec<u64>
-             where unstable feature: `bar`;
+             where feature(bar) is enabled;
 
 error: aborting due to 1 previous error
 

From 5317b7be529eb1274dd255cbb2fab94e74475e12 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 24 Sep 2025 09:15:38 +0200
Subject: [PATCH 1349/1889] clean-up

---
 clippy_lints/src/methods/mod.rs         |   2 +-
 clippy_lints/src/methods/or_fun_call.rs | 356 ++++++++++++------------
 tests/ui/or_fun_call.fixed              |   1 -
 tests/ui/or_fun_call.rs                 |   1 -
 tests/ui/or_fun_call.stderr             |  90 +++---
 5 files changed, 223 insertions(+), 227 deletions(-)

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 3755ec37fb967..be1fcf136e92d 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -4460,7 +4460,7 @@ declare_clippy_lint! {
     /// Checks for calls to `Read::bytes` on types which don't implement `BufRead`.
     ///
     /// ### Why is this bad?
-    /// The default implementation calls `read` for each byte, which can be very inefficient for data that’s not in memory, such as `File`.
+    /// The default implementation calls `read` for each byte, which can be very inefficient for data that's not in memory, such as `File`.
     ///
     /// ### Example
     /// ```no_run
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 71b2f251eded6..1433c5c1307b2 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -18,7 +18,6 @@ use {rustc_ast as ast, rustc_hir as hir};
 use super::{OR_FUN_CALL, UNWRAP_OR_DEFAULT};
 
 /// Checks for the `OR_FUN_CALL` lint.
-#[expect(clippy::too_many_lines)]
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &hir::Expr<'_>,
@@ -27,184 +26,6 @@ pub(super) fn check<'tcx>(
     receiver: &'tcx hir::Expr<'_>,
     args: &'tcx [hir::Expr<'_>],
 ) {
-    /// Checks for `unwrap_or(T::new())`, `unwrap_or(T::default())`,
-    /// `or_insert(T::new())` or `or_insert(T::default())`.
-    /// Similarly checks for `unwrap_or_else(T::new)`, `unwrap_or_else(T::default)`,
-    /// `or_insert_with(T::new)` or `or_insert_with(T::default)`.
-    fn check_unwrap_or_default(
-        cx: &LateContext<'_>,
-        name: Symbol,
-        receiver: &hir::Expr<'_>,
-        fun: &hir::Expr<'_>,
-        call_expr: Option<&hir::Expr<'_>>,
-        span: Span,
-        method_span: Span,
-    ) -> bool {
-        if !expr_type_is_certain(cx, receiver) {
-            return false;
-        }
-
-        let is_new = |fun: &hir::Expr<'_>| {
-            if let hir::ExprKind::Path(ref qpath) = fun.kind {
-                let path = last_path_segment(qpath).ident.name;
-                matches!(path, sym::new)
-            } else {
-                false
-            }
-        };
-
-        let output_type_implements_default = |fun| {
-            let fun_ty = cx.typeck_results().expr_ty(fun);
-            if let ty::FnDef(def_id, args) = fun_ty.kind() {
-                let output_ty = cx.tcx.fn_sig(def_id).instantiate(cx.tcx, args).skip_binder().output();
-                cx.tcx
-                    .get_diagnostic_item(sym::Default)
-                    .is_some_and(|default_trait_id| implements_trait(cx, output_ty, default_trait_id, &[]))
-            } else {
-                false
-            }
-        };
-
-        let sugg = match (name, call_expr.is_some()) {
-            (sym::unwrap_or, true) | (sym::unwrap_or_else, false) => sym::unwrap_or_default,
-            (sym::or_insert, true) | (sym::or_insert_with, false) => sym::or_default,
-            _ => return false,
-        };
-
-        let receiver_ty = cx.typeck_results().expr_ty_adjusted(receiver).peel_refs();
-        let Some(suggested_method_def_id) = receiver_ty.ty_adt_def().and_then(|adt_def| {
-            cx.tcx
-                .inherent_impls(adt_def.did())
-                .iter()
-                .flat_map(|impl_id| cx.tcx.associated_items(impl_id).filter_by_name_unhygienic(sugg))
-                .find_map(|assoc| {
-                    if assoc.is_method() && cx.tcx.fn_sig(assoc.def_id).skip_binder().inputs().skip_binder().len() == 1
-                    {
-                        Some(assoc.def_id)
-                    } else {
-                        None
-                    }
-                })
-        }) else {
-            return false;
-        };
-        let in_sugg_method_implementation = {
-            matches!(
-                suggested_method_def_id.as_local(),
-                Some(local_def_id) if local_def_id == cx.tcx.hir_get_parent_item(receiver.hir_id).def_id
-            )
-        };
-        if in_sugg_method_implementation {
-            return false;
-        }
-
-        // `.unwrap_or(vec![])` is as readable as `.unwrap_or_default()`. And if the expression is a
-        // non-empty `Vec`, then it will not be a default value anyway. Bail out in all cases.
-        if call_expr.and_then(|call_expr| VecArgs::hir(cx, call_expr)).is_some() {
-            return false;
-        }
-
-        // needs to target Default::default in particular or be *::new and have a Default impl
-        // available
-        if (is_new(fun) && output_type_implements_default(fun))
-            || match call_expr {
-                Some(call_expr) => is_default_equivalent(cx, call_expr),
-                None => is_default_equivalent_call(cx, fun, None) || closure_body_returns_empty_to_string(cx, fun),
-            }
-        {
-            span_lint_and_sugg(
-                cx,
-                UNWRAP_OR_DEFAULT,
-                method_span.with_hi(span.hi()),
-                format!("use of `{name}` to construct default value"),
-                "try",
-                format!("{sugg}()"),
-                Applicability::MachineApplicable,
-            );
-
-            true
-        } else {
-            false
-        }
-    }
-
-    /// Checks for `*or(foo())`.
-    #[expect(clippy::too_many_arguments)]
-    fn check_or_fn_call<'tcx>(
-        cx: &LateContext<'tcx>,
-        name: Symbol,
-        method_span: Span,
-        self_expr: &hir::Expr<'_>,
-        arg: &'tcx hir::Expr<'_>,
-        // `Some` if fn has second argument
-        second_arg: Option<&hir::Expr<'_>>,
-        span: Span,
-        // None if lambda is required
-        fun_span: Option<Span>,
-    ) -> bool {
-        // (path, fn_has_argument, methods, suffix)
-        const KNOW_TYPES: [(Symbol, bool, &[Symbol], &str); 7] = [
-            (sym::BTreeEntry, false, &[sym::or_insert], "with"),
-            (sym::HashMapEntry, false, &[sym::or_insert], "with"),
-            (
-                sym::Option,
-                false,
-                &[sym::map_or, sym::ok_or, sym::or, sym::unwrap_or],
-                "else",
-            ),
-            (sym::Option, false, &[sym::get_or_insert], "with"),
-            (sym::Option, true, &[sym::and], "then"),
-            (sym::Result, true, &[sym::map_or, sym::or, sym::unwrap_or], "else"),
-            (sym::Result, true, &[sym::and], "then"),
-        ];
-
-        if KNOW_TYPES.iter().any(|k| k.2.contains(&name))
-            && switch_to_lazy_eval(cx, arg)
-            && !contains_return(arg)
-            && let self_ty = cx.typeck_results().expr_ty(self_expr)
-            && let Some(&(_, fn_has_arguments, _, suffix)) = KNOW_TYPES
-                .iter()
-                .find(|&&i| is_type_diagnostic_item(cx, self_ty, i.0) && i.2.contains(&name))
-        {
-            let ctxt = span.ctxt();
-            let mut app = Applicability::HasPlaceholders;
-            let sugg = {
-                let (snippet_span, use_lambda) = match (fn_has_arguments, fun_span) {
-                    (false, Some(fun_span)) => (fun_span, false),
-                    _ => (arg.span, true),
-                };
-
-                let snip = snippet_with_context(cx, snippet_span, ctxt, "..", &mut app).0;
-                let snip = if use_lambda {
-                    let l_arg = if fn_has_arguments { "_" } else { "" };
-                    format!("|{l_arg}| {snip}")
-                } else {
-                    snip.into_owned()
-                };
-
-                if let Some(f) = second_arg {
-                    let f = snippet_with_context(cx, f.span, ctxt, "..", &mut app).0;
-                    format!("{snip}, {f}")
-                } else {
-                    snip
-                }
-            };
-            let span_replace_word = method_span.with_hi(span.hi());
-            span_lint_and_sugg(
-                cx,
-                OR_FUN_CALL,
-                span_replace_word,
-                format!("function call inside of `{name}`"),
-                "try",
-                format!("{name}_{suffix}({sugg})"),
-                app,
-            );
-            true
-        } else {
-            false
-        }
-    }
-
     if let [arg] = args {
         let inner_arg = peel_blocks(arg);
         for_each_expr(cx, inner_arg, |ex| {
@@ -272,6 +93,183 @@ pub(super) fn check<'tcx>(
     }
 }
 
+/// Checks for `unwrap_or(T::new())`, `unwrap_or(T::default())`,
+/// `or_insert(T::new())` or `or_insert(T::default())`.
+/// Similarly checks for `unwrap_or_else(T::new)`, `unwrap_or_else(T::default)`,
+/// `or_insert_with(T::new)` or `or_insert_with(T::default)`.
+fn check_unwrap_or_default(
+    cx: &LateContext<'_>,
+    name: Symbol,
+    receiver: &hir::Expr<'_>,
+    fun: &hir::Expr<'_>,
+    call_expr: Option<&hir::Expr<'_>>,
+    span: Span,
+    method_span: Span,
+) -> bool {
+    if !expr_type_is_certain(cx, receiver) {
+        return false;
+    }
+
+    let is_new = |fun: &hir::Expr<'_>| {
+        if let hir::ExprKind::Path(ref qpath) = fun.kind {
+            let path = last_path_segment(qpath).ident.name;
+            matches!(path, sym::new)
+        } else {
+            false
+        }
+    };
+
+    let output_type_implements_default = |fun| {
+        let fun_ty = cx.typeck_results().expr_ty(fun);
+        if let ty::FnDef(def_id, args) = fun_ty.kind() {
+            let output_ty = cx.tcx.fn_sig(def_id).instantiate(cx.tcx, args).skip_binder().output();
+            cx.tcx
+                .get_diagnostic_item(sym::Default)
+                .is_some_and(|default_trait_id| implements_trait(cx, output_ty, default_trait_id, &[]))
+        } else {
+            false
+        }
+    };
+
+    let sugg = match (name, call_expr.is_some()) {
+        (sym::unwrap_or, true) | (sym::unwrap_or_else, false) => sym::unwrap_or_default,
+        (sym::or_insert, true) | (sym::or_insert_with, false) => sym::or_default,
+        _ => return false,
+    };
+
+    let receiver_ty = cx.typeck_results().expr_ty_adjusted(receiver).peel_refs();
+    let Some(suggested_method_def_id) = receiver_ty.ty_adt_def().and_then(|adt_def| {
+        cx.tcx
+            .inherent_impls(adt_def.did())
+            .iter()
+            .flat_map(|impl_id| cx.tcx.associated_items(impl_id).filter_by_name_unhygienic(sugg))
+            .find_map(|assoc| {
+                if assoc.is_method() && cx.tcx.fn_sig(assoc.def_id).skip_binder().inputs().skip_binder().len() == 1 {
+                    Some(assoc.def_id)
+                } else {
+                    None
+                }
+            })
+    }) else {
+        return false;
+    };
+    let in_sugg_method_implementation = {
+        matches!(
+            suggested_method_def_id.as_local(),
+            Some(local_def_id) if local_def_id == cx.tcx.hir_get_parent_item(receiver.hir_id).def_id
+        )
+    };
+    if in_sugg_method_implementation {
+        return false;
+    }
+
+    // `.unwrap_or(vec![])` is as readable as `.unwrap_or_default()`. And if the expression is a
+    // non-empty `Vec`, then it will not be a default value anyway. Bail out in all cases.
+    if call_expr.and_then(|call_expr| VecArgs::hir(cx, call_expr)).is_some() {
+        return false;
+    }
+
+    // needs to target Default::default in particular or be *::new and have a Default impl
+    // available
+    if (is_new(fun) && output_type_implements_default(fun))
+        || match call_expr {
+            Some(call_expr) => is_default_equivalent(cx, call_expr),
+            None => is_default_equivalent_call(cx, fun, None) || closure_body_returns_empty_to_string(cx, fun),
+        }
+    {
+        span_lint_and_sugg(
+            cx,
+            UNWRAP_OR_DEFAULT,
+            method_span.with_hi(span.hi()),
+            format!("use of `{name}` to construct default value"),
+            "try",
+            format!("{sugg}()"),
+            Applicability::MachineApplicable,
+        );
+
+        true
+    } else {
+        false
+    }
+}
+
+/// Checks for `*or(foo())`.
+#[expect(clippy::too_many_arguments)]
+fn check_or_fn_call<'tcx>(
+    cx: &LateContext<'tcx>,
+    name: Symbol,
+    method_span: Span,
+    self_expr: &hir::Expr<'_>,
+    arg: &'tcx hir::Expr<'_>,
+    // `Some` if fn has second argument
+    second_arg: Option<&hir::Expr<'_>>,
+    span: Span,
+    // None if lambda is required
+    fun_span: Option<Span>,
+) -> bool {
+    // (path, fn_has_argument, methods, suffix)
+    const KNOW_TYPES: [(Symbol, bool, &[Symbol], &str); 7] = [
+        (sym::BTreeEntry, false, &[sym::or_insert], "with"),
+        (sym::HashMapEntry, false, &[sym::or_insert], "with"),
+        (
+            sym::Option,
+            false,
+            &[sym::map_or, sym::ok_or, sym::or, sym::unwrap_or],
+            "else",
+        ),
+        (sym::Option, false, &[sym::get_or_insert], "with"),
+        (sym::Option, true, &[sym::and], "then"),
+        (sym::Result, true, &[sym::map_or, sym::or, sym::unwrap_or], "else"),
+        (sym::Result, true, &[sym::and], "then"),
+    ];
+
+    if KNOW_TYPES.iter().any(|k| k.2.contains(&name))
+        && switch_to_lazy_eval(cx, arg)
+        && !contains_return(arg)
+        && let self_ty = cx.typeck_results().expr_ty(self_expr)
+        && let Some(&(_, fn_has_arguments, _, suffix)) = KNOW_TYPES
+            .iter()
+            .find(|&&i| is_type_diagnostic_item(cx, self_ty, i.0) && i.2.contains(&name))
+    {
+        let ctxt = span.ctxt();
+        let mut app = Applicability::HasPlaceholders;
+        let sugg = {
+            let (snippet_span, use_lambda) = match (fn_has_arguments, fun_span) {
+                (false, Some(fun_span)) => (fun_span, false),
+                _ => (arg.span, true),
+            };
+
+            let snip = snippet_with_context(cx, snippet_span, ctxt, "..", &mut app).0;
+            let snip = if use_lambda {
+                let l_arg = if fn_has_arguments { "_" } else { "" };
+                format!("|{l_arg}| {snip}")
+            } else {
+                snip.into_owned()
+            };
+
+            if let Some(f) = second_arg {
+                let f = snippet_with_context(cx, f.span, ctxt, "..", &mut app).0;
+                format!("{snip}, {f}")
+            } else {
+                snip
+            }
+        };
+        let span_replace_word = method_span.with_hi(span.hi());
+        span_lint_and_sugg(
+            cx,
+            OR_FUN_CALL,
+            span_replace_word,
+            format!("function call inside of `{name}`"),
+            "try",
+            format!("{name}_{suffix}({sugg})"),
+            app,
+        );
+        true
+    } else {
+        false
+    }
+}
+
 fn closure_body_returns_empty_to_string(cx: &LateContext<'_>, e: &hir::Expr<'_>) -> bool {
     if let hir::ExprKind::Closure(&hir::Closure { body, .. }) = e.kind {
         let body = cx.tcx.hir_body(body);
diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index 7a0be97017ebc..f42e637328a11 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -1,5 +1,4 @@
 #![warn(clippy::or_fun_call)]
-#![allow(dead_code)]
 #![allow(
     clippy::borrow_as_ptr,
     clippy::uninlined_format_args,
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index 724af606de9cf..7d2bd32ca0b3b 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -1,5 +1,4 @@
 #![warn(clippy::or_fun_call)]
-#![allow(dead_code)]
 #![allow(
     clippy::borrow_as_ptr,
     clippy::uninlined_format_args,
diff --git a/tests/ui/or_fun_call.stderr b/tests/ui/or_fun_call.stderr
index 40b25f91154dd..551ca8f3b8016 100644
--- a/tests/ui/or_fun_call.stderr
+++ b/tests/ui/or_fun_call.stderr
@@ -1,5 +1,5 @@
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:53:22
+  --> tests/ui/or_fun_call.rs:52:22
    |
 LL |     with_constructor.unwrap_or(make());
    |                      ^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(make)`
@@ -8,7 +8,7 @@ LL |     with_constructor.unwrap_or(make());
    = help: to override `-D warnings` add `#[allow(clippy::or_fun_call)]`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:57:14
+  --> tests/ui/or_fun_call.rs:56:14
    |
 LL |     with_new.unwrap_or(Vec::new());
    |              ^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
@@ -17,205 +17,205 @@ LL |     with_new.unwrap_or(Vec::new());
    = help: to override `-D warnings` add `#[allow(clippy::unwrap_or_default)]`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:61:21
+  --> tests/ui/or_fun_call.rs:60:21
    |
 LL |     with_const_args.unwrap_or(Vec::with_capacity(12));
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| Vec::with_capacity(12))`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:65:14
+  --> tests/ui/or_fun_call.rs:64:14
    |
 LL |     with_err.unwrap_or(make());
    |              ^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|_| make())`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:69:19
+  --> tests/ui/or_fun_call.rs:68:19
    |
 LL |     with_err_args.unwrap_or(Vec::with_capacity(12));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|_| Vec::with_capacity(12))`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:73:24
+  --> tests/ui/or_fun_call.rs:72:24
    |
 LL |     with_default_trait.unwrap_or(Default::default());
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:77:23
+  --> tests/ui/or_fun_call.rs:76:23
    |
 LL |     with_default_type.unwrap_or(u64::default());
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:97:18
+  --> tests/ui/or_fun_call.rs:96:18
    |
 LL |     self_default.unwrap_or(<FakeDefault>::default());
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(<FakeDefault>::default)`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:101:18
+  --> tests/ui/or_fun_call.rs:100:18
    |
 LL |     real_default.unwrap_or(<FakeDefault as Default>::default());
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:105:14
+  --> tests/ui/or_fun_call.rs:104:14
    |
 LL |     with_vec.unwrap_or(Vec::new());
    |              ^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:109:21
+  --> tests/ui/or_fun_call.rs:108:21
    |
 LL |     without_default.unwrap_or(Foo::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(Foo::new)`
 
 error: use of `or_insert` to construct default value
-  --> tests/ui/or_fun_call.rs:113:19
+  --> tests/ui/or_fun_call.rs:112:19
    |
 LL |     map.entry(42).or_insert(String::new());
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert` to construct default value
-  --> tests/ui/or_fun_call.rs:117:23
+  --> tests/ui/or_fun_call.rs:116:23
    |
 LL |     map_vec.entry(42).or_insert(Vec::new());
    |                       ^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert` to construct default value
-  --> tests/ui/or_fun_call.rs:121:21
+  --> tests/ui/or_fun_call.rs:120:21
    |
 LL |     btree.entry(42).or_insert(String::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert` to construct default value
-  --> tests/ui/or_fun_call.rs:125:25
+  --> tests/ui/or_fun_call.rs:124:25
    |
 LL |     btree_vec.entry(42).or_insert(Vec::new());
    |                         ^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:129:21
+  --> tests/ui/or_fun_call.rs:128:21
    |
 LL |     let _ = stringy.unwrap_or(String::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `ok_or`
-  --> tests/ui/or_fun_call.rs:134:17
+  --> tests/ui/or_fun_call.rs:133:17
    |
 LL |     let _ = opt.ok_or(format!("{} world.", hello));
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `ok_or_else(|| format!("{} world.", hello))`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:139:21
+  --> tests/ui/or_fun_call.rs:138:21
    |
 LL |     let _ = Some(1).unwrap_or(map[&1]);
    |                     ^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| map[&1])`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:142:21
+  --> tests/ui/or_fun_call.rs:141:21
    |
 LL |     let _ = Some(1).unwrap_or(map[&1]);
    |                     ^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| map[&1])`
 
 error: function call inside of `or`
-  --> tests/ui/or_fun_call.rs:167:35
+  --> tests/ui/or_fun_call.rs:166:35
    |
 LL |     let _ = Some("a".to_string()).or(Some("b".to_string()));
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_else(|| Some("b".to_string()))`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:210:18
+  --> tests/ui/or_fun_call.rs:209:18
    |
 LL |             None.unwrap_or(ptr_to_ref(s));
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| ptr_to_ref(s))`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:218:14
+  --> tests/ui/or_fun_call.rs:217:14
    |
 LL |         None.unwrap_or(unsafe { ptr_to_ref(s) });
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| unsafe { ptr_to_ref(s) })`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:221:14
+  --> tests/ui/or_fun_call.rs:220:14
    |
 LL |         None.unwrap_or( unsafe { ptr_to_ref(s) }    );
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| unsafe { ptr_to_ref(s) })`
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:297:25
+  --> tests/ui/or_fun_call.rs:296:25
    |
 LL |         let _ = Some(4).map_or(g(), |v| v);
    |                         ^^^^^^^^^^^^^^^^^^ help: try: `map_or_else(g, |v| v)`
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:299:25
+  --> tests/ui/or_fun_call.rs:298:25
    |
 LL |         let _ = Some(4).map_or(g(), f);
    |                         ^^^^^^^^^^^^^^ help: try: `map_or_else(g, f)`
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:302:25
+  --> tests/ui/or_fun_call.rs:301:25
    |
 LL |         let _ = Some(4).map_or("asd".to_string().len() as i32, f);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map_or_else(|| "asd".to_string().len() as i32, f)`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:333:18
+  --> tests/ui/or_fun_call.rs:332:18
    |
 LL |         with_new.unwrap_or_else(Vec::new);
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:337:28
+  --> tests/ui/or_fun_call.rs:336:28
    |
 LL |         with_default_trait.unwrap_or_else(Default::default);
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:341:27
+  --> tests/ui/or_fun_call.rs:340:27
    |
 LL |         with_default_type.unwrap_or_else(u64::default);
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:345:22
+  --> tests/ui/or_fun_call.rs:344:22
    |
 LL |         real_default.unwrap_or_else(<FakeDefault as Default>::default);
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `or_insert_with` to construct default value
-  --> tests/ui/or_fun_call.rs:349:23
+  --> tests/ui/or_fun_call.rs:348:23
    |
 LL |         map.entry(42).or_insert_with(String::new);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert_with` to construct default value
-  --> tests/ui/or_fun_call.rs:353:25
+  --> tests/ui/or_fun_call.rs:352:25
    |
 LL |         btree.entry(42).or_insert_with(String::new);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:357:25
+  --> tests/ui/or_fun_call.rs:356:25
    |
 LL |         let _ = stringy.unwrap_or_else(String::new);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:399:17
+  --> tests/ui/or_fun_call.rs:398:17
    |
 LL |     let _ = opt.unwrap_or({ f() }); // suggest `.unwrap_or_else(f)`
    |                 ^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(f)`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:404:17
+  --> tests/ui/or_fun_call.rs:403:17
    |
 LL |     let _ = opt.unwrap_or(f() + 1); // suggest `.unwrap_or_else(|| f() + 1)`
    |                 ^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| f() + 1)`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:409:17
+  --> tests/ui/or_fun_call.rs:408:17
    |
 LL |       let _ = opt.unwrap_or({
    |  _________________^
@@ -235,55 +235,55 @@ LL ~     });
    |
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:415:17
+  --> tests/ui/or_fun_call.rs:414:17
    |
 LL |     let _ = opt.map_or(f() + 1, |v| v); // suggest `.map_or_else(|| f() + 1, |v| v)`
    |                 ^^^^^^^^^^^^^^^^^^^^^^ help: try: `map_or_else(|| f() + 1, |v| v)`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:420:17
+  --> tests/ui/or_fun_call.rs:419:17
    |
 LL |     let _ = opt.unwrap_or({ i32::default() });
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:427:21
+  --> tests/ui/or_fun_call.rs:426:21
    |
 LL |     let _ = opt_foo.unwrap_or(Foo { val: String::default() });
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| Foo { val: String::default() })`
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:442:19
+  --> tests/ui/or_fun_call.rs:441:19
    |
 LL |         let _ = x.map_or(g(), |v| v);
    |                   ^^^^^^^^^^^^^^^^^^ help: try: `map_or_else(|_| g(), |v| v)`
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:444:19
+  --> tests/ui/or_fun_call.rs:443:19
    |
 LL |         let _ = x.map_or(g(), f);
    |                   ^^^^^^^^^^^^^^ help: try: `map_or_else(|_| g(), f)`
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:447:19
+  --> tests/ui/or_fun_call.rs:446:19
    |
 LL |         let _ = x.map_or("asd".to_string().len() as i32, f);
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map_or_else(|_| "asd".to_string().len() as i32, f)`
 
 error: function call inside of `get_or_insert`
-  --> tests/ui/or_fun_call.rs:458:15
+  --> tests/ui/or_fun_call.rs:457:15
    |
 LL |     let _ = x.get_or_insert(g());
    |               ^^^^^^^^^^^^^^^^^^ help: try: `get_or_insert_with(g)`
 
 error: function call inside of `and`
-  --> tests/ui/or_fun_call.rs:468:15
+  --> tests/ui/or_fun_call.rs:467:15
    |
 LL |     let _ = x.and(g());
    |               ^^^^^^^^ help: try: `and_then(|_| g())`
 
 error: function call inside of `and`
-  --> tests/ui/or_fun_call.rs:478:15
+  --> tests/ui/or_fun_call.rs:477:15
    |
 LL |     let _ = x.and(g());
    |               ^^^^^^^^ help: try: `and_then(|_| g())`

From b2634e31c435aeff149c5660f9329a0578ad1e72 Mon Sep 17 00:00:00 2001
From: Tropical <42101043+Tropix126@users.noreply.github.com>
Date: Wed, 24 Sep 2025 12:10:15 -0500
Subject: [PATCH 1350/1889] std: add support for armv7a-vex-v5 target

Co-authored-by: Lewis McClelland <lewis@lewismcclelland.me>
---
 .../src/spec/targets/armv7a_vex_v5.rs         |   2 +-
 library/Cargo.lock                            |  10 +
 library/std/Cargo.toml                        |   7 +-
 library/std/build.rs                          |   1 +
 library/std/src/env.rs                        |   2 +
 library/std/src/sys/alloc/mod.rs              |   3 +
 library/std/src/sys/alloc/vexos.rs            |  96 +++
 library/std/src/sys/env_consts.rs             |  11 +
 library/std/src/sys/fs/mod.rs                 |   4 +
 library/std/src/sys/fs/vexos.rs               | 615 ++++++++++++++++++
 library/std/src/sys/pal/mod.rs                |   4 +
 library/std/src/sys/pal/vexos/mod.rs          |  80 +++
 library/std/src/sys/pal/vexos/time.rs         |  28 +
 library/std/src/sys/random/mod.rs             |   2 +
 library/std/src/sys/stdio/mod.rs              |   4 +
 library/std/src/sys/stdio/vexos.rs            | 100 +++
 library/std/src/sys/thread/mod.rs             |   7 +
 library/std/src/sys/thread/vexos.rs           |  17 +
 library/std/src/sys/thread_local/mod.rs       |   2 +
 .../src/platform-support/armv7a-vex-v5.md     |  26 +-
 src/tools/tidy/src/deps.rs                    |   1 +
 21 files changed, 1012 insertions(+), 10 deletions(-)
 create mode 100644 library/std/src/sys/alloc/vexos.rs
 create mode 100644 library/std/src/sys/fs/vexos.rs
 create mode 100644 library/std/src/sys/pal/vexos/mod.rs
 create mode 100644 library/std/src/sys/pal/vexos/time.rs
 create mode 100644 library/std/src/sys/stdio/vexos.rs
 create mode 100644 library/std/src/sys/thread/vexos.rs

diff --git a/compiler/rustc_target/src/spec/targets/armv7a_vex_v5.rs b/compiler/rustc_target/src/spec/targets/armv7a_vex_v5.rs
index e78f783997470..06dd26297758f 100644
--- a/compiler/rustc_target/src/spec/targets/armv7a_vex_v5.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7a_vex_v5.rs
@@ -34,7 +34,7 @@ pub(crate) fn target() -> Target {
             description: Some("ARMv7-A Cortex-A9 VEX V5 Brain".into()),
             tier: Some(3),
             host_tools: Some(false),
-            std: Some(false),
+            std: Some(true),
         },
         pointer_width: 32,
         data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
diff --git a/library/Cargo.lock b/library/Cargo.lock
index e4b3839847b1a..47fbf5169f491 100644
--- a/library/Cargo.lock
+++ b/library/Cargo.lock
@@ -326,6 +326,7 @@ dependencies = [
  "rustc-demangle",
  "std_detect",
  "unwind",
+ "vex-sdk",
  "wasi 0.11.1+wasi-snapshot-preview1",
  "wasi 0.14.4+wasi-0.2.4",
  "windows-targets 0.0.0",
@@ -379,6 +380,15 @@ dependencies = [
  "rustc-std-workspace-core",
 ]
 
+[[package]]
+name = "vex-sdk"
+version = "0.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89f74fce61d7a7ba1589da9634c6305a72befb7cc9150c1f872d87d8060f32b9"
+dependencies = [
+ "rustc-std-workspace-core",
+]
+
 [[package]]
 name = "wasi"
 version = "0.11.1+wasi-snapshot-preview1"
diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
index d28a7f0b46022..b4d349d66def9 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -62,7 +62,7 @@ path = "../windows_targets"
 rand = { version = "0.9.0", default-features = false, features = ["alloc"] }
 rand_xorshift = "0.4.0"
 
-[target.'cfg(any(all(target_family = "wasm", target_os = "unknown"), target_os = "xous", all(target_vendor = "fortanix", target_env = "sgx")))'.dependencies]
+[target.'cfg(any(all(target_family = "wasm", target_os = "unknown"), target_os = "xous", target_os = "vexos", all(target_vendor = "fortanix", target_env = "sgx")))'.dependencies]
 dlmalloc = { version = "0.2.10", features = ['rustc-dep-of-std'] }
 
 [target.x86_64-fortanix-unknown-sgx.dependencies]
@@ -89,6 +89,11 @@ wasip2 = { version = '0.14.4', features = [
 r-efi = { version = "5.2.0", features = ['rustc-dep-of-std'] }
 r-efi-alloc = { version = "2.0.0", features = ['rustc-dep-of-std'] }
 
+[target.'cfg(target_os = "vexos")'.dependencies]
+vex-sdk = { version = "0.27.0", features = [
+    'rustc-dep-of-std',
+], default-features = false }
+
 [features]
 backtrace = [
     'addr2line/rustc-dep-of-std',
diff --git a/library/std/build.rs b/library/std/build.rs
index ef695601a448a..8a5a785060c85 100644
--- a/library/std/build.rs
+++ b/library/std/build.rs
@@ -52,6 +52,7 @@ fn main() {
         || target_os == "rtems"
         || target_os == "nuttx"
         || target_os == "cygwin"
+        || target_os == "vexos"
 
         // See src/bootstrap/src/core/build_steps/synthetic_targets.rs
         || env::var("RUSTC_BOOTSTRAP_SYNTHETIC_TARGET").is_ok()
diff --git a/library/std/src/env.rs b/library/std/src/env.rs
index e457cd61c7596..6d716bd854433 100644
--- a/library/std/src/env.rs
+++ b/library/std/src/env.rs
@@ -1098,6 +1098,7 @@ pub mod consts {
     /// * `"redox"`
     /// * `"solaris"`
     /// * `"solid_asp3`
+    /// * `"vexos"`
     /// * `"vita"`
     /// * `"vxworks"`
     /// * `"xous"`
@@ -1148,6 +1149,7 @@ pub mod consts {
     ///
     /// <details><summary>Full list of possible values</summary>
     ///
+    /// * `"bin"`
     /// * `"exe"`
     /// * `"efi"`
     /// * `"js"`
diff --git a/library/std/src/sys/alloc/mod.rs b/library/std/src/sys/alloc/mod.rs
index 6d4b09494a3f5..2045b2fecc6ac 100644
--- a/library/std/src/sys/alloc/mod.rs
+++ b/library/std/src/sys/alloc/mod.rs
@@ -92,6 +92,9 @@ cfg_select! {
     target_os = "uefi" => {
         mod uefi;
     }
+    target_os = "vexos" => {
+        mod vexos;
+    }
     target_family = "wasm" => {
         mod wasm;
     }
diff --git a/library/std/src/sys/alloc/vexos.rs b/library/std/src/sys/alloc/vexos.rs
new file mode 100644
index 0000000000000..c1fb6896a89ae
--- /dev/null
+++ b/library/std/src/sys/alloc/vexos.rs
@@ -0,0 +1,96 @@
+// FIXME(static_mut_refs): Do not allow `static_mut_refs` lint
+#![allow(static_mut_refs)]
+
+use crate::alloc::{GlobalAlloc, Layout, System};
+use crate::ptr;
+use crate::sync::atomic::{AtomicBool, Ordering};
+
+// Symbols for heap section boundaries defined in the target's linkerscript
+unsafe extern "C" {
+    static mut __heap_start: u8;
+    static mut __heap_end: u8;
+}
+
+static mut DLMALLOC: dlmalloc::Dlmalloc<Vexos> = dlmalloc::Dlmalloc::new_with_allocator(Vexos);
+
+struct Vexos;
+
+unsafe impl dlmalloc::Allocator for Vexos {
+    /// Allocs system resources
+    fn alloc(&self, _size: usize) -> (*mut u8, usize, u32) {
+        static INIT: AtomicBool = AtomicBool::new(false);
+
+        if !INIT.swap(true, Ordering::Relaxed) {
+            // This target has no growable heap, as user memory has a fixed
+            // size/location and VEXos does not manage allocation for us.
+            unsafe {
+                (
+                    (&raw mut __heap_start).cast::<u8>(),
+                    (&raw const __heap_end).offset_from_unsigned(&raw const __heap_start),
+                    0,
+                )
+            }
+        } else {
+            (ptr::null_mut(), 0, 0)
+        }
+    }
+
+    fn remap(&self, _ptr: *mut u8, _oldsize: usize, _newsize: usize, _can_move: bool) -> *mut u8 {
+        ptr::null_mut()
+    }
+
+    fn free_part(&self, _ptr: *mut u8, _oldsize: usize, _newsize: usize) -> bool {
+        false
+    }
+
+    fn free(&self, _ptr: *mut u8, _size: usize) -> bool {
+        return false;
+    }
+
+    fn can_release_part(&self, _flags: u32) -> bool {
+        false
+    }
+
+    fn allocates_zeros(&self) -> bool {
+        false
+    }
+
+    fn page_size(&self) -> usize {
+        0x1000
+    }
+}
+
+#[stable(feature = "alloc_system_type", since = "1.28.0")]
+unsafe impl GlobalAlloc for System {
+    #[inline]
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        // SAFETY: DLMALLOC access is guaranteed to be safe because we are a single-threaded target, which
+        // guarantees unique and non-reentrant access to the allocator. As such, no allocator lock is used.
+        // Calling malloc() is safe because preconditions on this function match the trait method preconditions.
+        unsafe { DLMALLOC.malloc(layout.size(), layout.align()) }
+    }
+
+    #[inline]
+    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
+        // SAFETY: DLMALLOC access is guaranteed to be safe because we are a single-threaded target, which
+        // guarantees unique and non-reentrant access to the allocator. As such, no allocator lock is used.
+        // Calling calloc() is safe because preconditions on this function match the trait method preconditions.
+        unsafe { DLMALLOC.calloc(layout.size(), layout.align()) }
+    }
+
+    #[inline]
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+        // SAFETY: DLMALLOC access is guaranteed to be safe because we are a single-threaded target, which
+        // guarantees unique and non-reentrant access to the allocator. As such, no allocator lock is used.
+        // Calling free() is safe because preconditions on this function match the trait method preconditions.
+        unsafe { DLMALLOC.free(ptr, layout.size(), layout.align()) }
+    }
+
+    #[inline]
+    unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+        // SAFETY: DLMALLOC access is guaranteed to be safe because we are a single-threaded target, which
+        // guarantees unique and non-reentrant access to the allocator. As such, no allocator lock is used.
+        // Calling realloc() is safe because preconditions on this function match the trait method preconditions.
+        unsafe { DLMALLOC.realloc(ptr, layout.size(), layout.align(), new_size) }
+    }
+}
diff --git a/library/std/src/sys/env_consts.rs b/library/std/src/sys/env_consts.rs
index 711ba0a5f8a92..573f540483b1a 100644
--- a/library/std/src/sys/env_consts.rs
+++ b/library/std/src/sys/env_consts.rs
@@ -323,6 +323,17 @@ pub mod os {
     pub const EXE_EXTENSION: &str = "efi";
 }
 
+#[cfg(target_os = "vexos")]
+pub mod os {
+    pub const FAMILY: &str = "";
+    pub const OS: &str = "vexos";
+    pub const DLL_PREFIX: &str = "";
+    pub const DLL_SUFFIX: &str = "";
+    pub const DLL_EXTENSION: &str = "";
+    pub const EXE_SUFFIX: &str = ".bin";
+    pub const EXE_EXTENSION: &str = "bin";
+}
+
 #[cfg(target_os = "visionos")]
 pub mod os {
     pub const FAMILY: &str = "unix";
diff --git a/library/std/src/sys/fs/mod.rs b/library/std/src/sys/fs/mod.rs
index 0276bf6e64c8b..64f5a6b36d3db 100644
--- a/library/std/src/sys/fs/mod.rs
+++ b/library/std/src/sys/fs/mod.rs
@@ -35,6 +35,10 @@ cfg_select! {
         mod uefi;
         use uefi as imp;
     }
+    target_os = "vexos" => {
+        mod vexos;
+        use vexos as imp;
+    }
     target_os = "wasi" => {
         mod wasi;
         use wasi as imp;
diff --git a/library/std/src/sys/fs/vexos.rs b/library/std/src/sys/fs/vexos.rs
new file mode 100644
index 0000000000000..f642e7cb074ec
--- /dev/null
+++ b/library/std/src/sys/fs/vexos.rs
@@ -0,0 +1,615 @@
+use crate::ffi::{OsString, c_char};
+use crate::fmt;
+use crate::fs::TryLockError;
+use crate::hash::Hash;
+use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut, SeekFrom};
+use crate::path::{Path, PathBuf};
+use crate::sys::common::small_c_string::run_path_with_cstr;
+use crate::sys::time::SystemTime;
+use crate::sys::{unsupported, unsupported_err};
+
+#[expect(dead_code)]
+#[path = "unsupported.rs"]
+mod unsupported_fs;
+pub use unsupported_fs::{
+    DirBuilder, FileTimes, canonicalize, link, readlink, remove_dir_all, rename, rmdir, symlink,
+    unlink,
+};
+
+/// VEXos file descriptor.
+///
+/// This stores an opaque pointer to a [FatFs file object structure] managed by VEXos
+/// representing an open file on disk.
+///
+/// [FatFs file object structure]: https://github.com/Xilinx/embeddedsw/blob/master/lib/sw_services/xilffs/src/include/ff.h?rgh-link-date=2025-09-23T20%3A03%3A43Z#L215
+///
+/// # Safety
+///
+/// Since this platform uses a pointer to to an internal filesystem structure with a lifetime
+/// associated with it (rather than a UNIX-style file descriptor table), care must be taken to
+/// ensure that the pointer held by `FileDesc` is valid for as long as it exists.
+#[derive(Debug)]
+struct FileDesc(*mut vex_sdk::FIL);
+
+// SAFETY: VEXos's FDs can be used on a thread other than the one they were created on.
+unsafe impl Send for FileDesc {}
+// SAFETY: We assume an environment without threads (i.e. no RTOS).
+// (If there were threads, it is possible that a mutex would be required.)
+unsafe impl Sync for FileDesc {}
+
+pub struct File {
+    fd: FileDesc,
+}
+
+#[derive(Clone)]
+pub enum FileAttr {
+    Dir,
+    File { size: u64 },
+}
+
+pub struct ReadDir(!);
+
+pub struct DirEntry {
+    path: PathBuf,
+}
+
+#[derive(Clone, Debug)]
+pub struct OpenOptions {
+    read: bool,
+    write: bool,
+    append: bool,
+    truncate: bool,
+    create: bool,
+    create_new: bool,
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct FilePermissions {}
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
+pub struct FileType {
+    is_dir: bool,
+}
+
+impl FileAttr {
+    pub fn size(&self) -> u64 {
+        match self {
+            Self::File { size } => *size,
+            Self::Dir => 0,
+        }
+    }
+
+    pub fn perm(&self) -> FilePermissions {
+        FilePermissions {}
+    }
+
+    pub fn file_type(&self) -> FileType {
+        FileType { is_dir: matches!(self, FileAttr::Dir) }
+    }
+
+    pub fn modified(&self) -> io::Result<SystemTime> {
+        unsupported()
+    }
+
+    pub fn accessed(&self) -> io::Result<SystemTime> {
+        unsupported()
+    }
+
+    pub fn created(&self) -> io::Result<SystemTime> {
+        unsupported()
+    }
+}
+
+impl FilePermissions {
+    pub fn readonly(&self) -> bool {
+        false
+    }
+
+    pub fn set_readonly(&mut self, _readonly: bool) {
+        panic!("Perimissions do not exist")
+    }
+}
+
+impl FileType {
+    pub fn is_dir(&self) -> bool {
+        self.is_dir
+    }
+
+    pub fn is_file(&self) -> bool {
+        !self.is_dir
+    }
+
+    pub fn is_symlink(&self) -> bool {
+        // No symlinks in VEXos - entries are either files or directories.
+        false
+    }
+}
+
+impl fmt::Debug for ReadDir {
+    fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0
+    }
+}
+
+impl Iterator for ReadDir {
+    type Item = io::Result<DirEntry>;
+
+    fn next(&mut self) -> Option<io::Result<DirEntry>> {
+        self.0
+    }
+}
+
+impl DirEntry {
+    pub fn path(&self) -> PathBuf {
+        self.path.clone()
+    }
+
+    pub fn file_name(&self) -> OsString {
+        self.path.file_name().unwrap_or_default().into()
+    }
+
+    pub fn metadata(&self) -> io::Result<FileAttr> {
+        stat(&self.path)
+    }
+
+    pub fn file_type(&self) -> io::Result<FileType> {
+        Ok(self.metadata()?.file_type())
+    }
+}
+
+impl OpenOptions {
+    pub fn new() -> OpenOptions {
+        OpenOptions {
+            read: false,
+            write: false,
+            append: false,
+            truncate: false,
+            create: false,
+            create_new: false,
+        }
+    }
+
+    pub fn read(&mut self, read: bool) {
+        self.read = read;
+    }
+    pub fn write(&mut self, write: bool) {
+        self.write = write;
+    }
+    pub fn append(&mut self, append: bool) {
+        self.append = append;
+    }
+    pub fn truncate(&mut self, truncate: bool) {
+        self.truncate = truncate;
+    }
+    pub fn create(&mut self, create: bool) {
+        self.create = create;
+    }
+    pub fn create_new(&mut self, create_new: bool) {
+        self.create_new = create_new;
+    }
+}
+
+impl File {
+    pub fn open(path: &Path, opts: &OpenOptions) -> io::Result<File> {
+        run_path_with_cstr(path, &|path| {
+            // Enforce the invariants of `create_new`/`create`.
+            //
+            // Since VEXos doesn't have anything akin to POSIX's `oflags`, we need to enforce
+            // the requirements that `create_new` can't have an existing file and `!create`
+            // doesn't create a file ourselves.
+            if !opts.read && (opts.write || opts.append) && (opts.create_new || !opts.create) {
+                let status = unsafe { vex_sdk::vexFileStatus(path.as_ptr()) };
+
+                if opts.create_new && status != 0 {
+                    return Err(io::const_error!(io::ErrorKind::AlreadyExists, "file exists",));
+                } else if !opts.create && status == 0 {
+                    return Err(io::const_error!(
+                        io::ErrorKind::NotFound,
+                        "no such file or directory",
+                    ));
+                }
+            }
+
+            let file = match opts {
+                // read + write - unsupported
+                OpenOptions { read: true, write: true, .. } => {
+                    return Err(io::const_error!(
+                        io::ErrorKind::InvalidInput,
+                        "opening files with read and write access is unsupported on this target",
+                    ));
+                }
+
+                // read
+                OpenOptions {
+                    read: true,
+                    write: false,
+                    append: _,
+                    truncate: false,
+                    create: false,
+                    create_new: false,
+                } => unsafe { vex_sdk::vexFileOpen(path.as_ptr(), c"".as_ptr()) },
+
+                // append
+                OpenOptions {
+                    read: false,
+                    write: _,
+                    append: true,
+                    truncate: false,
+                    create: _,
+                    create_new: _,
+                } => unsafe { vex_sdk::vexFileOpenWrite(path.as_ptr()) },
+
+                // write
+                OpenOptions {
+                    read: false,
+                    write: true,
+                    append: false,
+                    truncate,
+                    create: _,
+                    create_new: _,
+                } => unsafe {
+                    if *truncate {
+                        vex_sdk::vexFileOpenCreate(path.as_ptr())
+                    } else {
+                        // Open in append, but jump to the start of the file.
+                        let fd = vex_sdk::vexFileOpenWrite(path.as_ptr());
+                        vex_sdk::vexFileSeek(fd, 0, 0);
+                        fd
+                    }
+                },
+
+                _ => {
+                    return Err(io::const_error!(io::ErrorKind::InvalidInput, "invalid argument"));
+                }
+            };
+
+            if file.is_null() {
+                Err(io::const_error!(io::ErrorKind::NotFound, "could not open file"))
+            } else {
+                Ok(Self { fd: FileDesc(file) })
+            }
+        })
+    }
+
+    pub fn file_attr(&self) -> io::Result<FileAttr> {
+        // `vexFileSize` returns -1 upon error, so u64::try_from will fail on error.
+        if let Ok(size) = u64::try_from(unsafe {
+            // SAFETY: `self.fd` contains a valid pointer to `FIL` for this struct's lifetime.
+            vex_sdk::vexFileSize(self.fd.0)
+        }) {
+            Ok(FileAttr::File { size })
+        } else {
+            Err(io::const_error!(io::ErrorKind::InvalidData, "failed to get file size"))
+        }
+    }
+
+    pub fn fsync(&self) -> io::Result<()> {
+        self.flush()
+    }
+
+    pub fn datasync(&self) -> io::Result<()> {
+        self.flush()
+    }
+
+    pub fn lock(&self) -> io::Result<()> {
+        unsupported()
+    }
+
+    pub fn lock_shared(&self) -> io::Result<()> {
+        unsupported()
+    }
+
+    pub fn try_lock(&self) -> Result<(), TryLockError> {
+        Err(TryLockError::Error(unsupported_err()))
+    }
+
+    pub fn try_lock_shared(&self) -> Result<(), TryLockError> {
+        Err(TryLockError::Error(unsupported_err()))
+    }
+
+    pub fn unlock(&self) -> io::Result<()> {
+        unsupported()
+    }
+
+    pub fn truncate(&self, _size: u64) -> io::Result<()> {
+        unsupported()
+    }
+
+    pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
+        let len = buf.len() as u32;
+        let buf_ptr = buf.as_mut_ptr();
+        let read = unsafe {
+            // SAFETY: `self.fd` contains a valid pointer to `FIL` for this struct's lifetime.
+            vex_sdk::vexFileRead(buf_ptr.cast::<c_char>(), 1, len, self.fd.0)
+        };
+
+        if read < 0 {
+            Err(io::const_error!(io::ErrorKind::Other, "could not read from file"))
+        } else {
+            Ok(read as usize)
+        }
+    }
+
+    pub fn read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
+        crate::io::default_read_vectored(|b| self.read(b), bufs)
+    }
+
+    #[inline]
+    pub fn is_read_vectored(&self) -> bool {
+        false
+    }
+
+    pub fn read_buf(&self, cursor: BorrowedCursor<'_>) -> io::Result<()> {
+        crate::io::default_read_buf(|b| self.read(b), cursor)
+    }
+
+    pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
+        let len = buf.len() as u32;
+        let buf_ptr = buf.as_ptr();
+        let written = unsafe {
+            // SAFETY: `self.fd` contains a valid pointer to `FIL` for this struct's lifetime.
+            vex_sdk::vexFileWrite(buf_ptr.cast_mut().cast::<c_char>(), 1, len, self.fd.0)
+        };
+
+        if written < 0 {
+            Err(io::const_error!(io::ErrorKind::Other, "could not write to file"))
+        } else {
+            Ok(written as usize)
+        }
+    }
+
+    pub fn write_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        crate::io::default_write_vectored(|b| self.write(b), bufs)
+    }
+
+    #[inline]
+    pub fn is_write_vectored(&self) -> bool {
+        false
+    }
+
+    pub fn flush(&self) -> io::Result<()> {
+        unsafe {
+            // SAFETY: `self.fd` contains a valid pointer to `FIL` for this struct's lifetime.
+            vex_sdk::vexFileSync(self.fd.0);
+        }
+        Ok(())
+    }
+
+    pub fn tell(&self) -> io::Result<u64> {
+        // SAFETY: `self.fd` contains a valid pointer to `FIL` for this struct's lifetime.
+        let position = unsafe { vex_sdk::vexFileTell(self.fd.0) };
+
+        position.try_into().map_err(|_| {
+            io::const_error!(io::ErrorKind::InvalidData, "failed to get current location in file")
+        })
+    }
+
+    pub fn size(&self) -> Option<io::Result<u64>> {
+        None
+    }
+
+    pub fn seek(&self, pos: SeekFrom) -> io::Result<u64> {
+        const SEEK_SET: i32 = 0;
+        const SEEK_CUR: i32 = 1;
+        const SEEK_END: i32 = 2;
+
+        fn try_convert_offset<T: TryInto<u32>>(offset: T) -> io::Result<u32> {
+            offset.try_into().map_err(|_| {
+                io::const_error!(
+                    io::ErrorKind::InvalidInput,
+                    "cannot seek to an offset too large to fit in a 32 bit integer",
+                )
+            })
+        }
+
+        // SAFETY: `self.fd` contains a valid pointer to `FIL` for this struct's lifetime.
+        match pos {
+            SeekFrom::Start(offset) => unsafe {
+                map_fresult(vex_sdk::vexFileSeek(self.fd.0, try_convert_offset(offset)?, SEEK_SET))?
+            },
+            SeekFrom::End(offset) => unsafe {
+                if offset >= 0 {
+                    map_fresult(vex_sdk::vexFileSeek(
+                        self.fd.0,
+                        try_convert_offset(offset)?,
+                        SEEK_END,
+                    ))?
+                } else {
+                    // `vexFileSeek` does not support seeking with negative offset, meaning
+                    // we have to calculate the offset from the end of the file ourselves.
+
+                    // Seek to the end of the file to get the end position in the open buffer.
+                    map_fresult(vex_sdk::vexFileSeek(self.fd.0, 0, SEEK_END))?;
+                    let end_position = self.tell()?;
+
+                    map_fresult(vex_sdk::vexFileSeek(
+                        self.fd.0,
+                        // NOTE: Files internally use a 32-bit representation for stream
+                        // position, so `end_position as i64` should never overflow.
+                        try_convert_offset(end_position as i64 + offset)?,
+                        SEEK_SET,
+                    ))?
+                }
+            },
+            SeekFrom::Current(offset) => unsafe {
+                if offset >= 0 {
+                    map_fresult(vex_sdk::vexFileSeek(
+                        self.fd.0,
+                        try_convert_offset(offset)?,
+                        SEEK_CUR,
+                    ))?
+                } else {
+                    // `vexFileSeek` does not support seeking with negative offset, meaning
+                    // we have to calculate the offset from the stream position ourselves.
+                    map_fresult(vex_sdk::vexFileSeek(
+                        self.fd.0,
+                        try_convert_offset((self.tell()? as i64) + offset)?,
+                        SEEK_SET,
+                    ))?
+                }
+            },
+        }
+
+        Ok(self.tell()?)
+    }
+
+    pub fn duplicate(&self) -> io::Result<File> {
+        unsupported()
+    }
+
+    pub fn set_permissions(&self, _perm: FilePermissions) -> io::Result<()> {
+        unsupported()
+    }
+
+    pub fn set_times(&self, _times: FileTimes) -> io::Result<()> {
+        unsupported()
+    }
+}
+
+impl fmt::Debug for File {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("File").field("fd", &self.fd.0).finish()
+    }
+}
+impl Drop for File {
+    fn drop(&mut self) {
+        unsafe { vex_sdk::vexFileClose(self.fd.0) };
+    }
+}
+
+pub fn readdir(_p: &Path) -> io::Result<ReadDir> {
+    // While there *is* a userspace function for reading file directories,
+    // the necessary implementation cannot currently be done cleanly, as
+    // VEXos does not expose directory length to user programs.
+    //
+    // This means that we would need to create a large fixed-length buffer
+    // and hope that the folder's contents didn't exceed that buffer's length,
+    // which obviously isn't behavior we want to rely on in the standard library.
+    unsupported()
+}
+
+pub fn set_perm(_p: &Path, _perm: FilePermissions) -> io::Result<()> {
+    unsupported()
+}
+
+pub fn exists(path: &Path) -> io::Result<bool> {
+    run_path_with_cstr(path, &|path| Ok(unsafe { vex_sdk::vexFileStatus(path.as_ptr()) } != 0))
+}
+
+pub fn stat(p: &Path) -> io::Result<FileAttr> {
+    // `vexFileStatus` returns 3 if the given path is a directory, 1 if the path is a
+    // file, or 0 if no such path exists.
+    const FILE_STATUS_DIR: u32 = 3;
+
+    run_path_with_cstr(p, &|c_path| {
+        let file_type = unsafe { vex_sdk::vexFileStatus(c_path.as_ptr()) };
+
+        // We can't get the size if its a directory because we cant open it as a file
+        if file_type == FILE_STATUS_DIR {
+            Ok(FileAttr::Dir)
+        } else {
+            let mut opts = OpenOptions::new();
+            opts.read(true);
+            let file = File::open(p, &opts)?;
+            file.file_attr()
+        }
+    })
+}
+
+pub fn lstat(p: &Path) -> io::Result<FileAttr> {
+    // Symlinks aren't supported in this filesystem
+    stat(p)
+}
+
+// Cannot use `copy` from `common` here, since `File::set_permissions` is unsupported on this target.
+pub fn copy(from: &Path, to: &Path) -> io::Result<u64> {
+    use crate::fs::File;
+
+    // NOTE: If `from` is a directory, this call should fail due to vexFileOpen* returning null.
+    let mut reader = File::open(from)?;
+    let mut writer = File::create(to)?;
+
+    io::copy(&mut reader, &mut writer)
+}
+
+fn map_fresult(fresult: vex_sdk::FRESULT) -> io::Result<()> {
+    // VEX uses a derivative of FatFs (Xilinx's xilffs library) for filesystem operations.
+    match fresult {
+        vex_sdk::FRESULT::FR_OK => Ok(()),
+        vex_sdk::FRESULT::FR_DISK_ERR => Err(io::const_error!(
+            io::ErrorKind::Uncategorized,
+            "internal function reported an unrecoverable hard error",
+        )),
+        vex_sdk::FRESULT::FR_INT_ERR => Err(io::const_error!(
+            io::ErrorKind::Uncategorized,
+            "internal error in filesystem runtime",
+        )),
+        vex_sdk::FRESULT::FR_NOT_READY => Err(io::const_error!(
+            io::ErrorKind::Uncategorized,
+            "the storage device could not be prepared to work",
+        )),
+        vex_sdk::FRESULT::FR_NO_FILE => Err(io::const_error!(
+            io::ErrorKind::NotFound,
+            "could not find the file in the directory"
+        )),
+        vex_sdk::FRESULT::FR_NO_PATH => Err(io::const_error!(
+            io::ErrorKind::NotFound,
+            "a directory in the path name could not be found",
+        )),
+        vex_sdk::FRESULT::FR_INVALID_NAME => Err(io::const_error!(
+            io::ErrorKind::InvalidInput,
+            "the given string is invalid as a path name",
+        )),
+        vex_sdk::FRESULT::FR_DENIED => Err(io::const_error!(
+            io::ErrorKind::PermissionDenied,
+            "the required access for this operation was denied",
+        )),
+        vex_sdk::FRESULT::FR_EXIST => Err(io::const_error!(
+            io::ErrorKind::AlreadyExists,
+            "an object with the same name already exists in the directory",
+        )),
+        vex_sdk::FRESULT::FR_INVALID_OBJECT => Err(io::const_error!(
+            io::ErrorKind::Uncategorized,
+            "invalid or null file/directory object",
+        )),
+        vex_sdk::FRESULT::FR_WRITE_PROTECTED => Err(io::const_error!(
+            io::ErrorKind::PermissionDenied,
+            "a write operation was performed on write-protected media",
+        )),
+        vex_sdk::FRESULT::FR_INVALID_DRIVE => Err(io::const_error!(
+            io::ErrorKind::InvalidInput,
+            "an invalid drive number was specified in the path name",
+        )),
+        vex_sdk::FRESULT::FR_NOT_ENABLED => Err(io::const_error!(
+            io::ErrorKind::Uncategorized,
+            "work area for the logical drive has not been registered",
+        )),
+        vex_sdk::FRESULT::FR_NO_FILESYSTEM => Err(io::const_error!(
+            io::ErrorKind::Uncategorized,
+            "valid FAT volume could not be found on the drive",
+        )),
+        vex_sdk::FRESULT::FR_MKFS_ABORTED => Err(io::const_error!(
+            io::ErrorKind::Uncategorized,
+            "failed to create filesystem volume"
+        )),
+        vex_sdk::FRESULT::FR_TIMEOUT => Err(io::const_error!(
+            io::ErrorKind::TimedOut,
+            "the function was canceled due to a timeout of thread-safe control",
+        )),
+        vex_sdk::FRESULT::FR_LOCKED => Err(io::const_error!(
+            io::ErrorKind::Uncategorized,
+            "the operation to the object was rejected by file sharing control",
+        )),
+        vex_sdk::FRESULT::FR_NOT_ENOUGH_CORE => {
+            Err(io::const_error!(io::ErrorKind::OutOfMemory, "not enough memory for the operation"))
+        }
+        vex_sdk::FRESULT::FR_TOO_MANY_OPEN_FILES => Err(io::const_error!(
+            io::ErrorKind::Uncategorized,
+            "maximum number of open files has been reached",
+        )),
+        vex_sdk::FRESULT::FR_INVALID_PARAMETER => {
+            Err(io::const_error!(io::ErrorKind::InvalidInput, "a given parameter was invalid"))
+        }
+        _ => unreachable!(), // C-style enum
+    }
+}
diff --git a/library/std/src/sys/pal/mod.rs b/library/std/src/sys/pal/mod.rs
index 513121c6d30ee..dd5e83ee570b6 100644
--- a/library/std/src/sys/pal/mod.rs
+++ b/library/std/src/sys/pal/mod.rs
@@ -45,6 +45,10 @@ cfg_select! {
         mod trusty;
         pub use self::trusty::*;
     }
+    target_os = "vexos" => {
+        mod vexos;
+        pub use self::vexos::*;
+    }
     all(target_os = "wasi", target_env = "p2") => {
         mod wasip2;
         pub use self::wasip2::*;
diff --git a/library/std/src/sys/pal/vexos/mod.rs b/library/std/src/sys/pal/vexos/mod.rs
new file mode 100644
index 0000000000000..61a34b0f68a30
--- /dev/null
+++ b/library/std/src/sys/pal/vexos/mod.rs
@@ -0,0 +1,80 @@
+#[path = "../unsupported/os.rs"]
+pub mod os;
+#[path = "../unsupported/pipe.rs"]
+pub mod pipe;
+pub mod time;
+
+#[expect(dead_code)]
+#[path = "../unsupported/common.rs"]
+mod unsupported_common;
+
+pub use unsupported_common::{
+    decode_error_kind, init, is_interrupted, unsupported, unsupported_err,
+};
+
+use crate::arch::global_asm;
+use crate::ptr;
+use crate::sys::stdio;
+use crate::time::{Duration, Instant};
+
+global_asm!(
+    r#"
+    .section .boot, "ax"
+    .global _boot
+
+    _boot:
+        ldr sp, =__stack_top @ Set up the user stack.
+        b _start             @ Jump to the Rust entrypoint.
+    "#
+);
+
+#[cfg(not(test))]
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn _start() -> ! {
+    unsafe extern "C" {
+        static mut __bss_start: u8;
+        static mut __bss_end: u8;
+
+        fn main() -> i32;
+    }
+
+    // Clear the .bss (uninitialized statics) section by filling it with zeroes.
+    // This is required, since the compiler assumes it will be zeroed on first access.
+    ptr::write_bytes(
+        &raw mut __bss_start,
+        0,
+        (&raw mut __bss_end).offset_from_unsigned(&raw mut __bss_start),
+    );
+
+    main();
+
+    cleanup();
+    abort_internal()
+}
+
+// SAFETY: must be called only once during runtime cleanup.
+// NOTE: this is not guaranteed to run, for example when the program aborts.
+pub unsafe fn cleanup() {
+    let exit_time = Instant::now();
+    const FLUSH_TIMEOUT: Duration = Duration::from_millis(15);
+
+    // Force the serial buffer to flush
+    while exit_time.elapsed() < FLUSH_TIMEOUT {
+        vex_sdk::vexTasksRun();
+
+        // If the buffer has been fully flushed, exit the loop
+        if vex_sdk::vexSerialWriteFree(stdio::STDIO_CHANNEL) == (stdio::STDOUT_BUF_SIZE as i32) {
+            break;
+        }
+    }
+}
+
+pub fn abort_internal() -> ! {
+    unsafe {
+        vex_sdk::vexSystemExitRequest();
+
+        loop {
+            vex_sdk::vexTasksRun();
+        }
+    }
+}
diff --git a/library/std/src/sys/pal/vexos/time.rs b/library/std/src/sys/pal/vexos/time.rs
new file mode 100644
index 0000000000000..f95d96cd27ac0
--- /dev/null
+++ b/library/std/src/sys/pal/vexos/time.rs
@@ -0,0 +1,28 @@
+use crate::time::Duration;
+
+#[expect(dead_code)]
+#[path = "../unsupported/time.rs"]
+mod unsupported_time;
+pub use unsupported_time::{SystemTime, UNIX_EPOCH};
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
+pub struct Instant(Duration);
+
+impl Instant {
+    pub fn now() -> Instant {
+        let micros = unsafe { vex_sdk::vexSystemHighResTimeGet() };
+        Self(Duration::from_micros(micros))
+    }
+
+    pub fn checked_sub_instant(&self, other: &Instant) -> Option<Duration> {
+        self.0.checked_sub(other.0)
+    }
+
+    pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> {
+        Some(Instant(self.0.checked_add(*other)?))
+    }
+
+    pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {
+        Some(Instant(self.0.checked_sub(*other)?))
+    }
+}
diff --git a/library/std/src/sys/random/mod.rs b/library/std/src/sys/random/mod.rs
index 1e0eec07b5006..3c5a4c82a9f1e 100644
--- a/library/std/src/sys/random/mod.rs
+++ b/library/std/src/sys/random/mod.rs
@@ -101,6 +101,7 @@ cfg_select! {
     any(
         all(target_family = "wasm", target_os = "unknown"),
         target_os = "xous",
+        target_os = "vexos",
     ) => {
         // FIXME: finally remove std support for wasm32-unknown-unknown
         // FIXME: add random data generation to xous
@@ -116,6 +117,7 @@ cfg_select! {
     all(target_family = "wasm", target_os = "unknown"),
     all(target_os = "wasi", target_env = "p2"),
     target_os = "xous",
+    target_os = "vexos",
 )))]
 pub fn hashmap_random_keys() -> (u64, u64) {
     let mut buf = [0; 16];
diff --git a/library/std/src/sys/stdio/mod.rs b/library/std/src/sys/stdio/mod.rs
index 7436e4d9de4da..404ac87792696 100644
--- a/library/std/src/sys/stdio/mod.rs
+++ b/library/std/src/sys/stdio/mod.rs
@@ -29,6 +29,10 @@ cfg_select! {
         mod uefi;
         pub use uefi::*;
     }
+    target_os = "vexos" => {
+        mod vexos;
+        pub use vexos::*;
+    }
     all(target_os = "wasi", target_env = "p1") => {
         mod wasip1;
         pub use wasip1::*;
diff --git a/library/std/src/sys/stdio/vexos.rs b/library/std/src/sys/stdio/vexos.rs
new file mode 100644
index 0000000000000..1f2251c6421d8
--- /dev/null
+++ b/library/std/src/sys/stdio/vexos.rs
@@ -0,0 +1,100 @@
+use crate::io;
+
+pub struct Stdin;
+pub struct Stdout;
+pub type Stderr = Stdout;
+
+pub const STDIO_CHANNEL: u32 = 1;
+
+impl Stdin {
+    pub const fn new() -> Stdin {
+        Stdin
+    }
+}
+
+impl io::Read for Stdin {
+    fn read(&mut self, mut buf: &mut [u8]) -> io::Result<usize> {
+        let mut count = 0;
+
+        for out_byte in buf.iter_mut() {
+            let byte = unsafe { vex_sdk::vexSerialReadChar(STDIO_CHANNEL) };
+            if byte < 0 {
+                break;
+            }
+
+            *out_byte = byte as u8;
+            count += 1;
+        }
+
+        Ok(count)
+    }
+}
+
+impl Stdout {
+    pub const fn new() -> Stdout {
+        Stdout
+    }
+}
+
+impl io::Write for Stdout {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let mut written = 0;
+
+        // HACK: VEXos holds an internal ringbuffer for serial writes that is flushed to USB1
+        // roughly every millisecond by `vexTasksRun`. For writes larger than 2048 bytes, we
+        // must block until that buffer is flushed to USB1 before writing the rest of `buf`.
+        //
+        // This is fairly nonstandard for a `write` implementation, but it avoids a guaranteed
+        // recursive panic when using macros such as `print!` to write large amounts of data
+        // (buf.len() > 2048) to stdout at once.
+        for chunk in buf.chunks(STDOUT_BUF_SIZE) {
+            if unsafe { vex_sdk::vexSerialWriteFree(STDIO_CHANNEL) as usize } < chunk.len() {
+                self.flush().unwrap();
+            }
+
+            let count: usize = unsafe {
+                vex_sdk::vexSerialWriteBuffer(STDIO_CHANNEL, chunk.as_ptr(), chunk.len() as u32)
+            }
+            .try_into()
+            .map_err(|_| {
+                io::const_error!(io::ErrorKind::Uncategorized, "internal write error occurred")
+            })?;
+
+            written += count;
+
+            // This is a sanity check to ensure that we don't end up with non-contiguous
+            // buffer writes. e.g. a chunk gets only partially written, but we continue
+            // attempting to write the remaining chunks.
+            //
+            // In practice, this should never really occur since the previous flush ensures
+            // enough space in FIFO to write the entire chunk to vexSerialWriteBuffer.
+            if count != chunk.len() {
+                break;
+            }
+        }
+
+        Ok(written)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        // This may block for up to a millisecond.
+        unsafe {
+            while (vex_sdk::vexSerialWriteFree(STDIO_CHANNEL) as usize) != STDOUT_BUF_SIZE {
+                vex_sdk::vexTasksRun();
+            }
+        }
+
+        Ok(())
+    }
+}
+
+pub const STDIN_BUF_SIZE: usize = 4096;
+pub const STDOUT_BUF_SIZE: usize = 2048;
+
+pub fn is_ebadf(_err: &io::Error) -> bool {
+    false
+}
+
+pub fn panic_output() -> Option<impl io::Write> {
+    Some(Stdout::new())
+}
diff --git a/library/std/src/sys/thread/mod.rs b/library/std/src/sys/thread/mod.rs
index 6bb7fc1a20e2f..3bd83dd760ac9 100644
--- a/library/std/src/sys/thread/mod.rs
+++ b/library/std/src/sys/thread/mod.rs
@@ -81,6 +81,13 @@ cfg_select! {
         ))]
         pub use unsupported::set_name;
     }
+    target_os = "vexos" => {
+        mod vexos;
+        pub use vexos::{sleep, yield_now};
+        #[expect(dead_code)]
+        mod unsupported;
+        pub use unsupported::{Thread, available_parallelism, current_os_id, set_name, DEFAULT_MIN_STACK_SIZE};
+    }
     all(target_os = "wasi", target_env = "p1") => {
         mod wasip1;
         pub use wasip1::{DEFAULT_MIN_STACK_SIZE, sleep, yield_now};
diff --git a/library/std/src/sys/thread/vexos.rs b/library/std/src/sys/thread/vexos.rs
new file mode 100644
index 0000000000000..d917dde4d0bc1
--- /dev/null
+++ b/library/std/src/sys/thread/vexos.rs
@@ -0,0 +1,17 @@
+use crate::time::{Duration, Instant};
+
+pub fn yield_now() {
+    unsafe {
+        vex_sdk::vexTasksRun();
+    }
+}
+
+pub fn sleep(dur: Duration) {
+    let start = Instant::now();
+
+    while start.elapsed() < dur {
+        unsafe {
+            vex_sdk::vexTasksRun();
+        }
+    }
+}
diff --git a/library/std/src/sys/thread_local/mod.rs b/library/std/src/sys/thread_local/mod.rs
index cff74857c4733..d5c795093cf04 100644
--- a/library/std/src/sys/thread_local/mod.rs
+++ b/library/std/src/sys/thread_local/mod.rs
@@ -29,6 +29,7 @@ cfg_select! {
         target_os = "uefi",
         target_os = "zkvm",
         target_os = "trusty",
+        target_os = "vexos",
     ) => {
         mod no_threads;
         pub use no_threads::{EagerStorage, LazyStorage, thread_local_inner};
@@ -98,6 +99,7 @@ pub(crate) mod guard {
             target_os = "uefi",
             target_os = "zkvm",
             target_os = "trusty",
+            target_os = "vexos",
         ) => {
             pub(crate) fn enable() {
                 // FIXME: Right now there is no concept of "thread exit" on
diff --git a/src/doc/rustc/src/platform-support/armv7a-vex-v5.md b/src/doc/rustc/src/platform-support/armv7a-vex-v5.md
index a7da1b16f7e3d..3677f8931dd68 100644
--- a/src/doc/rustc/src/platform-support/armv7a-vex-v5.md
+++ b/src/doc/rustc/src/platform-support/armv7a-vex-v5.md
@@ -4,7 +4,7 @@
 
 Allows compiling user programs for the [VEX V5 Brain](https://www.vexrobotics.com/276-4810.html), a microcontroller for educational and competitive robotics.
 
-Rust support for this target is not affiliated with VEX Robotics or IFI.
+Rust support for this target is not affiliated with VEX Robotics or IFI, and does not link to any official VEX SDK.
 
 ## Target maintainers
 
@@ -17,11 +17,24 @@ This target is maintained by members of the [vexide](https://github.com/vexide)
 
 ## Requirements
 
-This target is cross-compiled and currently requires `#![no_std]`. Dynamic linking is unsupported.
+This target is cross-compiled. Dynamic linking is unsupported.
 
-When compiling for this target, the "C" calling convention maps to AAPCS with VFP registers (hard float ABI) and the "system" calling convention maps to AAPCS without VFP registers (soft float ABI).
+`#![no_std]` crates can be built using `build-std` to build `core` and `panic_abort` and optionally `alloc`. Unwinding panics are not yet supported on this target.
 
-This target generates binaries in the ELF format that may uploaded to the brain with external tools.
+`std` has only partial support due platform limitations. Notably:
+- `std::process` and `std::net` are unimplemented. `std::thread` only supports sleeping and yielding, as this is a single-threaded environment.
+- `std::time` has full support for `Instant`, but no support for `SystemTime`.
+- `std::io` has full support for `stdin`/`stdout`/`stderr`. `stdout` and `stderr` both write to to USB channel 1 on this platform and are not differentiated.
+- `std::fs` has limited support for reading or writing to files. Directory operations, file deletion, and some file opening features are unsupported and will return errors.
+- A global allocator implemented on top of `dlmalloc` is provided.
+- Modules that do not need to interact with the OS beyond allocation such as `std::collections`, `std::hash`, `std::future`, `std::sync`, etc are fully supported.
+- Random number generation and hashing is insecure, as there is no reliable source of entropy on this platform.
+
+In order to support some APIs, users are expected to provide a supporting runtime SDK for `libstd` to link against. This library may be provided either by [`vex-sdk-build`](https://github.com/vexide/vex-sdk/tree/main/packages/vex-sdk-build) (which will download an official SDK from VEX) or through an open-source implementation such as [`vex-sdk-jumptable`](https://crates.io/crates/vex-sdk-jumptable).
+
+When compiling for this target, the "C" calling convention maps to AAPCS with VFP registers (hard float ABI) and the "system" calling convention maps to AAPCS without VFP registers (softfp ABI).
+
+This target generates binaries in the ELF format that may be uploaded to the brain with external tools.
 
 ## Building the target
 
@@ -29,10 +42,7 @@ You can build Rust with support for this target by adding it to the `target` lis
 
 ## 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.
+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.
 
 When the compiler builds a binary, an ELF build artifact will be produced. Additional tools are required for this artifact to be recognizable to VEXos as a user program.
 
diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs
index 568ec0c119896..7c5f823b57c76 100644
--- a/src/tools/tidy/src/deps.rs
+++ b/src/tools/tidy/src/deps.rs
@@ -575,6 +575,7 @@ const PERMITTED_STDLIB_DEPENDENCIES: &[&str] = &[
     "rustc-literal-escaper",
     "shlex",
     "unwinding",
+    "vex-sdk",
     "wasi",
     "windows-sys",
     "windows-targets",

From 7449d63ab7dc12de7e311f1bf56de51051bb68dc Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Wed, 24 Sep 2025 09:40:45 +0200
Subject: [PATCH 1351/1889] fix(or_fun_call): respect MSRV for
 `Result::unwrap_or_default` suggestion

---
 book/src/lint_configuration.md          |  1 +
 clippy_config/src/conf.rs               |  1 +
 clippy_lints/src/methods/mod.rs         |  2 +-
 clippy_lints/src/methods/or_fun_call.rs | 16 ++++++++++++---
 clippy_utils/src/msrvs.rs               |  2 +-
 tests/ui/or_fun_call.fixed              | 15 ++++++++++++++
 tests/ui/or_fun_call.rs                 | 15 ++++++++++++++
 tests/ui/or_fun_call.stderr             | 26 ++++++++++++++++++++++++-
 8 files changed, 72 insertions(+), 6 deletions(-)

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index c2d080cd96a1d..f8263bb8852ab 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -883,6 +883,7 @@ The minimum rust version that the project supports. Defaults to the `rust-versio
 * [`needless_borrow`](https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow)
 * [`non_std_lazy_statics`](https://rust-lang.github.io/rust-clippy/master/index.html#non_std_lazy_statics)
 * [`option_as_ref_deref`](https://rust-lang.github.io/rust-clippy/master/index.html#option_as_ref_deref)
+* [`or_fun_call`](https://rust-lang.github.io/rust-clippy/master/index.html#or_fun_call)
 * [`ptr_as_ptr`](https://rust-lang.github.io/rust-clippy/master/index.html#ptr_as_ptr)
 * [`question_mark`](https://rust-lang.github.io/rust-clippy/master/index.html#question_mark)
 * [`redundant_field_names`](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_field_names)
diff --git a/clippy_config/src/conf.rs b/clippy_config/src/conf.rs
index 2f28f6175ad82..e14e15a022f71 100644
--- a/clippy_config/src/conf.rs
+++ b/clippy_config/src/conf.rs
@@ -779,6 +779,7 @@ define_Conf! {
         needless_borrow,
         non_std_lazy_statics,
         option_as_ref_deref,
+        or_fun_call,
         ptr_as_ptr,
         question_mark,
         redundant_field_names,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index be1fcf136e92d..c18f20c17e2e2 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -4854,7 +4854,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             },
             ExprKind::MethodCall(method_call, receiver, args, _) => {
                 let method_span = method_call.ident.span;
-                or_fun_call::check(cx, expr, method_span, method_call.ident.name, receiver, args);
+                or_fun_call::check(cx, expr, method_span, method_call.ident.name, receiver, args, self.msrv);
                 expect_fun_call::check(
                     cx,
                     &self.format_args,
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 1433c5c1307b2..04e4503e4097f 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -3,6 +3,7 @@ use std::ops::ControlFlow;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::eager_or_lazy::switch_to_lazy_eval;
 use clippy_utils::higher::VecArgs;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::{expr_type_is_certain, implements_trait, is_type_diagnostic_item};
 use clippy_utils::visitors::for_each_expr;
@@ -25,6 +26,7 @@ pub(super) fn check<'tcx>(
     name: Symbol,
     receiver: &'tcx hir::Expr<'_>,
     args: &'tcx [hir::Expr<'_>],
+    msrv: Msrv,
 ) {
     if let [arg] = args {
         let inner_arg = peel_blocks(arg);
@@ -45,11 +47,11 @@ pub(super) fn check<'tcx>(
                     };
                     (!inner_fun_has_args
                         && !is_nested_expr
-                        && check_unwrap_or_default(cx, name, receiver, fun, Some(ex), expr.span, method_span))
+                        && check_unwrap_or_default(cx, name, receiver, fun, Some(ex), expr.span, method_span, msrv))
                         || check_or_fn_call(cx, name, method_span, receiver, arg, None, expr.span, fun_span)
                 },
                 hir::ExprKind::Path(..) | hir::ExprKind::Closure(..) if !is_nested_expr => {
-                    check_unwrap_or_default(cx, name, receiver, ex, None, expr.span, method_span)
+                    check_unwrap_or_default(cx, name, receiver, ex, None, expr.span, method_span, msrv)
                 },
                 hir::ExprKind::Index(..) | hir::ExprKind::MethodCall(..) => {
                     check_or_fn_call(cx, name, method_span, receiver, arg, None, expr.span, None)
@@ -97,6 +99,7 @@ pub(super) fn check<'tcx>(
 /// `or_insert(T::new())` or `or_insert(T::default())`.
 /// Similarly checks for `unwrap_or_else(T::new)`, `unwrap_or_else(T::default)`,
 /// `or_insert_with(T::new)` or `or_insert_with(T::default)`.
+#[expect(clippy::too_many_arguments)]
 fn check_unwrap_or_default(
     cx: &LateContext<'_>,
     name: Symbol,
@@ -105,7 +108,15 @@ fn check_unwrap_or_default(
     call_expr: Option<&hir::Expr<'_>>,
     span: Span,
     method_span: Span,
+    msrv: Msrv,
 ) -> bool {
+    let receiver_ty = cx.typeck_results().expr_ty_adjusted(receiver).peel_refs();
+
+    // Check MSRV, but only for `Result::unwrap_or_default`
+    if is_type_diagnostic_item(cx, receiver_ty, sym::Result) && !msrv.meets(cx, msrvs::RESULT_UNWRAP_OR_DEFAULT) {
+        return false;
+    }
+
     if !expr_type_is_certain(cx, receiver) {
         return false;
     }
@@ -137,7 +148,6 @@ fn check_unwrap_or_default(
         _ => return false,
     };
 
-    let receiver_ty = cx.typeck_results().expr_ty_adjusted(receiver).peel_refs();
     let Some(suggested_method_def_id) = receiver_ty.ty_adt_def().and_then(|adt_def| {
         cx.tcx
             .inherent_impls(adt_def.did())
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 6e07ed9ffcc4d..3cccce3975449 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -77,7 +77,7 @@ msrv_aliases! {
     1,24,0 { IS_ASCII_DIGIT, PTR_NULL }
     1,18,0 { HASH_MAP_RETAIN, HASH_SET_RETAIN }
     1,17,0 { FIELD_INIT_SHORTHAND, STATIC_IN_CONST, EXPECT_ERR }
-    1,16,0 { STR_REPEAT }
+    1,16,0 { STR_REPEAT, RESULT_UNWRAP_OR_DEFAULT }
     1,15,0 { MAYBE_BOUND_IN_WHERE }
     1,13,0 { QUESTION_MARK_OPERATOR }
 }
diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index f42e637328a11..386351aa39f51 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -478,4 +478,19 @@ fn test_result_and() {
     //~^ or_fun_call
 }
 
+#[clippy::msrv = "1.15"]
+fn below_msrv(opt: Option<i32>, res: Result<i32, ()>) {
+    let _ = opt.unwrap_or_default();
+    //~^ unwrap_or_default
+    let _ = res.unwrap_or_else(|_| Default::default());
+    //~^ or_fun_call
+}
+
+#[clippy::msrv = "1.16"]
+fn above_msrv(opt: Option<i32>, res: Result<i32, ()>) {
+    let _ = opt.unwrap_or_default();
+    //~^ unwrap_or_default
+    let _ = res.unwrap_or_default();
+    //~^ unwrap_or_default
+}
 fn main() {}
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index 7d2bd32ca0b3b..e27f9aa65c37a 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -478,4 +478,19 @@ fn test_result_and() {
     //~^ or_fun_call
 }
 
+#[clippy::msrv = "1.15"]
+fn below_msrv(opt: Option<i32>, res: Result<i32, ()>) {
+    let _ = opt.unwrap_or(Default::default());
+    //~^ unwrap_or_default
+    let _ = res.unwrap_or(Default::default());
+    //~^ or_fun_call
+}
+
+#[clippy::msrv = "1.16"]
+fn above_msrv(opt: Option<i32>, res: Result<i32, ()>) {
+    let _ = opt.unwrap_or(Default::default());
+    //~^ unwrap_or_default
+    let _ = res.unwrap_or(Default::default());
+    //~^ unwrap_or_default
+}
 fn main() {}
diff --git a/tests/ui/or_fun_call.stderr b/tests/ui/or_fun_call.stderr
index 551ca8f3b8016..6bce06ab20eb6 100644
--- a/tests/ui/or_fun_call.stderr
+++ b/tests/ui/or_fun_call.stderr
@@ -288,5 +288,29 @@ error: function call inside of `and`
 LL |     let _ = x.and(g());
    |               ^^^^^^^^ help: try: `and_then(|_| g())`
 
-error: aborting due to 45 previous errors
+error: use of `unwrap_or` to construct default value
+  --> tests/ui/or_fun_call.rs:483:17
+   |
+LL |     let _ = opt.unwrap_or(Default::default());
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
+
+error: function call inside of `unwrap_or`
+  --> tests/ui/or_fun_call.rs:485:17
+   |
+LL |     let _ = res.unwrap_or(Default::default());
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|_| Default::default())`
+
+error: use of `unwrap_or` to construct default value
+  --> tests/ui/or_fun_call.rs:491:17
+   |
+LL |     let _ = opt.unwrap_or(Default::default());
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
+
+error: use of `unwrap_or` to construct default value
+  --> tests/ui/or_fun_call.rs:493:17
+   |
+LL |     let _ = res.unwrap_or(Default::default());
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
+
+error: aborting due to 49 previous errors
 

From 9cb82d7ac849adf1bffb2d7e30f114db8d9a9208 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sun, 21 Sep 2025 23:22:31 +0200
Subject: [PATCH 1352/1889] fix(unnecessary_mut_passed): retain parens around
 the arguments

---
 clippy_lints/src/unnecessary_mut_passed.rs |  33 +++-
 tests/ui/unnecessary_mut_passed.fixed      |  20 +++
 tests/ui/unnecessary_mut_passed.rs         |  20 +++
 tests/ui/unnecessary_mut_passed.stderr     | 193 ++++++++++++++++++---
 4 files changed, 233 insertions(+), 33 deletions(-)

diff --git a/clippy_lints/src/unnecessary_mut_passed.rs b/clippy_lints/src/unnecessary_mut_passed.rs
index ec93ef97cfaf7..eb2d7639e91f7 100644
--- a/clippy_lints/src/unnecessary_mut_passed.rs
+++ b/clippy_lints/src/unnecessary_mut_passed.rs
@@ -1,5 +1,5 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::sugg::Sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::SpanRangeExt;
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability};
 use rustc_lint::{LateContext, LateLintPass};
@@ -87,16 +87,33 @@ fn check_arguments<'tcx>(
             if let ty::Ref(_, _, Mutability::Not) | ty::RawPtr(_, Mutability::Not) = parameter.kind()
                 && let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, arg) = argument.kind
             {
-                let mut applicability = Applicability::MachineApplicable;
-                let sugg = Sugg::hir_with_applicability(cx, arg, "_", &mut applicability).addr();
-                span_lint_and_sugg(
+                let applicability = Applicability::MachineApplicable;
+
+                let span_to_remove = {
+                    let span_until_arg = argument.span.until(arg.span);
+                    if let Some(Some(ref_pos)) = span_until_arg.with_source_text(cx, |src| {
+                        src
+                            // we don't use `strip_prefix` here, because `argument` might be enclosed in parens, in
+                            // which case `&` is no longer the prefix
+                            .find('&')
+                            // just a sanity check, in case some proc-macro messes up the spans
+                            .filter(|ref_pos| src[*ref_pos..].contains("mut"))
+                    }) && let Ok(lo) = u32::try_from(ref_pos + '&'.len_utf8())
+                    {
+                        span_until_arg.split_at(lo).1
+                    } else {
+                        return;
+                    }
+                };
+
+                span_lint_and_then(
                     cx,
                     UNNECESSARY_MUT_PASSED,
                     argument.span,
                     format!("the {fn_kind} `{name}` doesn't need a mutable reference"),
-                    "remove this `mut`",
-                    sugg.to_string(),
-                    applicability,
+                    |diag| {
+                        diag.span_suggestion_verbose(span_to_remove, "remove this `mut`", String::new(), applicability);
+                    },
                 );
             }
         }
diff --git a/tests/ui/unnecessary_mut_passed.fixed b/tests/ui/unnecessary_mut_passed.fixed
index 03d854099e644..63bbadb01dcb2 100644
--- a/tests/ui/unnecessary_mut_passed.fixed
+++ b/tests/ui/unnecessary_mut_passed.fixed
@@ -40,6 +40,7 @@ mod issue11268 {
 struct MyStruct;
 
 impl MyStruct {
+    fn takes_nothing(&self) {}
     fn takes_ref(&self, a: &i32) {}
     fn takes_refmut(&self, a: &mut i32) {}
     fn takes_ref_ref(&self, a: &&i32) {}
@@ -168,3 +169,22 @@ fn raw_ptrs(my_struct: MyStruct) {
     my_struct.takes_raw_mut(&raw mut n);
     my_struct.takes_raw_const(a);
 }
+
+#[expect(clippy::needless_borrow)]
+fn issue15722(mut my_struct: MyStruct) {
+    (&my_struct).takes_nothing();
+    //~^ unnecessary_mut_passed
+    (&my_struct).takes_nothing();
+
+    // Only put parens around the argument that used to have it
+    (&my_struct).takes_ref(&42);
+    //~^ unnecessary_mut_passed
+    //~| unnecessary_mut_passed
+    #[expect(clippy::double_parens)]
+    (&my_struct).takes_ref((&42));
+    //~^ unnecessary_mut_passed
+    //~| unnecessary_mut_passed
+    #[expect(clippy::double_parens)]
+    my_struct.takes_ref((&42));
+    //~^ unnecessary_mut_passed
+}
diff --git a/tests/ui/unnecessary_mut_passed.rs b/tests/ui/unnecessary_mut_passed.rs
index 80e3f50692770..b719ca1871b29 100644
--- a/tests/ui/unnecessary_mut_passed.rs
+++ b/tests/ui/unnecessary_mut_passed.rs
@@ -40,6 +40,7 @@ mod issue11268 {
 struct MyStruct;
 
 impl MyStruct {
+    fn takes_nothing(&self) {}
     fn takes_ref(&self, a: &i32) {}
     fn takes_refmut(&self, a: &mut i32) {}
     fn takes_ref_ref(&self, a: &&i32) {}
@@ -168,3 +169,22 @@ fn raw_ptrs(my_struct: MyStruct) {
     my_struct.takes_raw_mut(&raw mut n);
     my_struct.takes_raw_const(a);
 }
+
+#[expect(clippy::needless_borrow)]
+fn issue15722(mut my_struct: MyStruct) {
+    (&mut my_struct).takes_nothing();
+    //~^ unnecessary_mut_passed
+    (&my_struct).takes_nothing();
+
+    // Only put parens around the argument that used to have it
+    (&mut my_struct).takes_ref(&mut 42);
+    //~^ unnecessary_mut_passed
+    //~| unnecessary_mut_passed
+    #[expect(clippy::double_parens)]
+    (&mut my_struct).takes_ref((&mut 42));
+    //~^ unnecessary_mut_passed
+    //~| unnecessary_mut_passed
+    #[expect(clippy::double_parens)]
+    my_struct.takes_ref((&mut 42));
+    //~^ unnecessary_mut_passed
+}
diff --git a/tests/ui/unnecessary_mut_passed.stderr b/tests/ui/unnecessary_mut_passed.stderr
index c69a637bf4088..ace11027e3e25 100644
--- a/tests/ui/unnecessary_mut_passed.stderr
+++ b/tests/ui/unnecessary_mut_passed.stderr
@@ -1,77 +1,220 @@
 error: the function `takes_ref` doesn't need a mutable reference
-  --> tests/ui/unnecessary_mut_passed.rs:56:15
+  --> tests/ui/unnecessary_mut_passed.rs:57:15
    |
 LL |     takes_ref(&mut 42);
-   |               ^^^^^^^ help: remove this `mut`: `&42`
+   |               ^^^^^^^
    |
    = note: `-D clippy::unnecessary-mut-passed` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_mut_passed)]`
+help: remove this `mut`
+   |
+LL -     takes_ref(&mut 42);
+LL +     takes_ref(&42);
+   |
 
 error: the function `takes_ref_ref` doesn't need a mutable reference
-  --> tests/ui/unnecessary_mut_passed.rs:58:19
+  --> tests/ui/unnecessary_mut_passed.rs:59:19
    |
 LL |     takes_ref_ref(&mut &42);
-   |                   ^^^^^^^^ help: remove this `mut`: `&&42`
+   |                   ^^^^^^^^
+   |
+help: remove this `mut`
+   |
+LL -     takes_ref_ref(&mut &42);
+LL +     takes_ref_ref(&&42);
+   |
 
 error: the function `takes_ref_refmut` doesn't need a mutable reference
-  --> tests/ui/unnecessary_mut_passed.rs:60:22
+  --> tests/ui/unnecessary_mut_passed.rs:61:22
    |
 LL |     takes_ref_refmut(&mut &mut 42);
-   |                      ^^^^^^^^^^^^ help: remove this `mut`: `&&mut 42`
+   |                      ^^^^^^^^^^^^
+   |
+help: remove this `mut`
+   |
+LL -     takes_ref_refmut(&mut &mut 42);
+LL +     takes_ref_refmut(&&mut 42);
+   |
 
 error: the function `takes_raw_const` doesn't need a mutable reference
-  --> tests/ui/unnecessary_mut_passed.rs:62:21
+  --> tests/ui/unnecessary_mut_passed.rs:63:21
    |
 LL |     takes_raw_const(&mut 42);
-   |                     ^^^^^^^ help: remove this `mut`: `&42`
+   |                     ^^^^^^^
+   |
+help: remove this `mut`
+   |
+LL -     takes_raw_const(&mut 42);
+LL +     takes_raw_const(&42);
+   |
 
 error: the function `as_ptr` doesn't need a mutable reference
-  --> tests/ui/unnecessary_mut_passed.rs:66:12
+  --> tests/ui/unnecessary_mut_passed.rs:67:12
    |
 LL |     as_ptr(&mut 42);
-   |            ^^^^^^^ help: remove this `mut`: `&42`
+   |            ^^^^^^^
+   |
+help: remove this `mut`
+   |
+LL -     as_ptr(&mut 42);
+LL +     as_ptr(&42);
+   |
 
 error: the function `as_ptr` doesn't need a mutable reference
-  --> tests/ui/unnecessary_mut_passed.rs:69:12
+  --> tests/ui/unnecessary_mut_passed.rs:70:12
    |
 LL |     as_ptr(&mut &42);
-   |            ^^^^^^^^ help: remove this `mut`: `&&42`
+   |            ^^^^^^^^
+   |
+help: remove this `mut`
+   |
+LL -     as_ptr(&mut &42);
+LL +     as_ptr(&&42);
+   |
 
 error: the function `as_ptr` doesn't need a mutable reference
-  --> tests/ui/unnecessary_mut_passed.rs:72:12
+  --> tests/ui/unnecessary_mut_passed.rs:73:12
    |
 LL |     as_ptr(&mut &mut 42);
-   |            ^^^^^^^^^^^^ help: remove this `mut`: `&&mut 42`
+   |            ^^^^^^^^^^^^
+   |
+help: remove this `mut`
+   |
+LL -     as_ptr(&mut &mut 42);
+LL +     as_ptr(&&mut 42);
+   |
 
 error: the function `as_ptr` doesn't need a mutable reference
-  --> tests/ui/unnecessary_mut_passed.rs:75:12
+  --> tests/ui/unnecessary_mut_passed.rs:76:12
    |
 LL |     as_ptr(&mut 42);
-   |            ^^^^^^^ help: remove this `mut`: `&42`
+   |            ^^^^^^^
+   |
+help: remove this `mut`
+   |
+LL -     as_ptr(&mut 42);
+LL +     as_ptr(&42);
+   |
 
 error: the method `takes_ref` doesn't need a mutable reference
-  --> tests/ui/unnecessary_mut_passed.rs:80:25
+  --> tests/ui/unnecessary_mut_passed.rs:81:25
    |
 LL |     my_struct.takes_ref(&mut 42);
-   |                         ^^^^^^^ help: remove this `mut`: `&42`
+   |                         ^^^^^^^
+   |
+help: remove this `mut`
+   |
+LL -     my_struct.takes_ref(&mut 42);
+LL +     my_struct.takes_ref(&42);
+   |
 
 error: the method `takes_ref_ref` doesn't need a mutable reference
-  --> tests/ui/unnecessary_mut_passed.rs:82:29
+  --> tests/ui/unnecessary_mut_passed.rs:83:29
    |
 LL |     my_struct.takes_ref_ref(&mut &42);
-   |                             ^^^^^^^^ help: remove this `mut`: `&&42`
+   |                             ^^^^^^^^
+   |
+help: remove this `mut`
+   |
+LL -     my_struct.takes_ref_ref(&mut &42);
+LL +     my_struct.takes_ref_ref(&&42);
+   |
 
 error: the method `takes_ref_refmut` doesn't need a mutable reference
-  --> tests/ui/unnecessary_mut_passed.rs:84:32
+  --> tests/ui/unnecessary_mut_passed.rs:85:32
    |
 LL |     my_struct.takes_ref_refmut(&mut &mut 42);
-   |                                ^^^^^^^^^^^^ help: remove this `mut`: `&&mut 42`
+   |                                ^^^^^^^^^^^^
+   |
+help: remove this `mut`
+   |
+LL -     my_struct.takes_ref_refmut(&mut &mut 42);
+LL +     my_struct.takes_ref_refmut(&&mut 42);
+   |
 
 error: the method `takes_raw_const` doesn't need a mutable reference
-  --> tests/ui/unnecessary_mut_passed.rs:86:31
+  --> tests/ui/unnecessary_mut_passed.rs:87:31
    |
 LL |     my_struct.takes_raw_const(&mut 42);
-   |                               ^^^^^^^ help: remove this `mut`: `&42`
+   |                               ^^^^^^^
+   |
+help: remove this `mut`
+   |
+LL -     my_struct.takes_raw_const(&mut 42);
+LL +     my_struct.takes_raw_const(&42);
+   |
+
+error: the method `takes_nothing` doesn't need a mutable reference
+  --> tests/ui/unnecessary_mut_passed.rs:175:5
+   |
+LL |     (&mut my_struct).takes_nothing();
+   |     ^^^^^^^^^^^^^^^^
+   |
+help: remove this `mut`
+   |
+LL -     (&mut my_struct).takes_nothing();
+LL +     (&my_struct).takes_nothing();
+   |
+
+error: the method `takes_ref` doesn't need a mutable reference
+  --> tests/ui/unnecessary_mut_passed.rs:180:5
+   |
+LL |     (&mut my_struct).takes_ref(&mut 42);
+   |     ^^^^^^^^^^^^^^^^
+   |
+help: remove this `mut`
+   |
+LL -     (&mut my_struct).takes_ref(&mut 42);
+LL +     (&my_struct).takes_ref(&mut 42);
+   |
+
+error: the method `takes_ref` doesn't need a mutable reference
+  --> tests/ui/unnecessary_mut_passed.rs:180:32
+   |
+LL |     (&mut my_struct).takes_ref(&mut 42);
+   |                                ^^^^^^^
+   |
+help: remove this `mut`
+   |
+LL -     (&mut my_struct).takes_ref(&mut 42);
+LL +     (&mut my_struct).takes_ref(&42);
+   |
+
+error: the method `takes_ref` doesn't need a mutable reference
+  --> tests/ui/unnecessary_mut_passed.rs:184:5
+   |
+LL |     (&mut my_struct).takes_ref((&mut 42));
+   |     ^^^^^^^^^^^^^^^^
+   |
+help: remove this `mut`
+   |
+LL -     (&mut my_struct).takes_ref((&mut 42));
+LL +     (&my_struct).takes_ref((&mut 42));
+   |
+
+error: the method `takes_ref` doesn't need a mutable reference
+  --> tests/ui/unnecessary_mut_passed.rs:184:32
+   |
+LL |     (&mut my_struct).takes_ref((&mut 42));
+   |                                ^^^^^^^^^
+   |
+help: remove this `mut`
+   |
+LL -     (&mut my_struct).takes_ref((&mut 42));
+LL +     (&mut my_struct).takes_ref((&42));
+   |
+
+error: the method `takes_ref` doesn't need a mutable reference
+  --> tests/ui/unnecessary_mut_passed.rs:188:25
+   |
+LL |     my_struct.takes_ref((&mut 42));
+   |                         ^^^^^^^^^
+   |
+help: remove this `mut`
+   |
+LL -     my_struct.takes_ref((&mut 42));
+LL +     my_struct.takes_ref((&42));
+   |
 
-error: aborting due to 12 previous errors
+error: aborting due to 18 previous errors
 

From a3840d9592e764f48617bf178c4c00bdb0b8ab84 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Mon, 22 Sep 2025 08:59:36 +0300
Subject: [PATCH 1353/1889] Implement fallback properly

fallback.rs was ported straight from rustc (minus the lint parts).

This fixes the `!` regressions.
---
 src/tools/rust-analyzer/Cargo.lock            |  18 +
 src/tools/rust-analyzer/Cargo.toml            |   1 +
 .../rust-analyzer/crates/hir-ty/Cargo.toml    |   1 +
 .../crates/hir-ty/src/consteval.rs            |   2 +-
 .../crates/hir-ty/src/consteval/tests.rs      |  48 +-
 .../crates/hir-ty/src/consteval_nextsolver.rs |   2 +-
 .../rust-analyzer/crates/hir-ty/src/infer.rs  |  95 +++-
 .../crates/hir-ty/src/infer/coerce.rs         |  28 +-
 .../crates/hir-ty/src/infer/fallback.rs       | 439 ++++++++++++++++++
 .../crates/hir-ty/src/infer/unify.rs          | 332 ++++++-------
 .../crates/hir-ty/src/next_solver.rs          |   2 +-
 .../crates/hir-ty/src/next_solver/region.rs   |  10 +-
 .../crates/hir-ty/src/next_solver/ty.rs       |   9 +
 .../crates/hir-ty/src/tests/never_type.rs     |  10 +-
 .../crates/hir-ty/src/tests/regression.rs     |   2 +-
 .../crates/intern/src/symbol/symbols.rs       |   1 +
 16 files changed, 770 insertions(+), 230 deletions(-)
 create mode 100644 src/tools/rust-analyzer/crates/hir-ty/src/infer/fallback.rs

diff --git a/src/tools/rust-analyzer/Cargo.lock b/src/tools/rust-analyzer/Cargo.lock
index 17dea1ba4cdec..9d0f63d2bcecb 100644
--- a/src/tools/rust-analyzer/Cargo.lock
+++ b/src/tools/rust-analyzer/Cargo.lock
@@ -545,6 +545,12 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
+[[package]]
+name = "fixedbitset"
+version = "0.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
+
 [[package]]
 name = "flate2"
 version = "1.1.2"
@@ -775,6 +781,7 @@ dependencies = [
  "itertools",
  "la-arena 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "oorandom",
+ "petgraph",
  "project-model",
  "query-group-macro",
  "ra-ap-rustc_abi",
@@ -1594,6 +1601,17 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "petgraph"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54acf3a685220b533e437e264e4d932cfbdc4cc7ec0cd232ed73c08d03b8a7ca"
+dependencies = [
+ "fixedbitset",
+ "hashbrown 0.15.4",
+ "indexmap",
+]
+
 [[package]]
 name = "pin-project-lite"
 version = "0.2.16"
diff --git a/src/tools/rust-analyzer/Cargo.toml b/src/tools/rust-analyzer/Cargo.toml
index 0401367f78647..d3a4e375613eb 100644
--- a/src/tools/rust-analyzer/Cargo.toml
+++ b/src/tools/rust-analyzer/Cargo.toml
@@ -170,6 +170,7 @@ tracing-subscriber = { version = "0.3.20", default-features = false, features =
 triomphe = { version = "0.1.14", default-features = false, features = ["std"] }
 url = "2.5.4"
 xshell = "0.2.7"
+petgraph = { version = "0.8.2", default-features = false }
 
 # We need to freeze the version of the crate, as the raw-api feature is considered unstable
 dashmap = { version = "=6.1.0", features = ["raw-api", "inline"] }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/Cargo.toml b/src/tools/rust-analyzer/crates/hir-ty/Cargo.toml
index 138d02e5a6105..4013d19ad08eb 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/Cargo.toml
+++ b/src/tools/rust-analyzer/crates/hir-ty/Cargo.toml
@@ -34,6 +34,7 @@ rustc_apfloat = "0.2.3"
 query-group.workspace = true
 salsa.workspace = true
 salsa-macros.workspace = true
+petgraph.workspace = true
 
 ra-ap-rustc_abi.workspace = true
 ra-ap-rustc_index.workspace = true
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
index e2a8d1cedc284..b2daed425ef1c 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
@@ -327,7 +327,7 @@ pub(crate) fn eval_to_const(
     debruijn: DebruijnIndex,
 ) -> Const {
     let db = ctx.db;
-    let infer = ctx.clone().resolve_all();
+    let infer = ctx.fixme_resolve_all_clone();
     fn has_closure(body: &Body, expr: ExprId) -> bool {
         if matches!(body[expr], Expr::Closure { .. }) {
             return true;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs
index 299b73a7d6cc4..1586846bbe58d 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs
@@ -36,12 +36,12 @@ fn check_fail(
     error: impl FnOnce(ConstEvalError) -> bool,
 ) {
     let (db, file_id) = TestDB::with_single_file(ra_fixture);
-    match eval_goal(&db, file_id) {
+    salsa::attach(&db, || match eval_goal(&db, file_id) {
         Ok(_) => panic!("Expected fail, but it succeeded"),
         Err(e) => {
-            assert!(error(simplify(e.clone())), "Actual error was: {}", pretty_print_err(e, db))
+            assert!(error(simplify(e.clone())), "Actual error was: {}", pretty_print_err(e, &db))
         }
-    }
+    })
 }
 
 #[track_caller]
@@ -79,36 +79,38 @@ fn check_answer(
     check: impl FnOnce(&[u8], &MemoryMap<'_>),
 ) {
     let (db, file_ids) = TestDB::with_many_files(ra_fixture);
-    let file_id = *file_ids.last().unwrap();
-    let r = match eval_goal(&db, file_id) {
-        Ok(t) => t,
-        Err(e) => {
-            let err = pretty_print_err(e, db);
-            panic!("Error in evaluating goal: {err}");
-        }
-    };
-    match &r.data(Interner).value {
-        chalk_ir::ConstValue::Concrete(c) => match &c.interned {
-            ConstScalar::Bytes(b, mm) => {
-                check(b, mm);
+    salsa::attach(&db, || {
+        let file_id = *file_ids.last().unwrap();
+        let r = match eval_goal(&db, file_id) {
+            Ok(t) => t,
+            Err(e) => {
+                let err = pretty_print_err(e, &db);
+                panic!("Error in evaluating goal: {err}");
             }
-            x => panic!("Expected number but found {x:?}"),
-        },
-        _ => panic!("result of const eval wasn't a concrete const"),
-    }
+        };
+        match &r.data(Interner).value {
+            chalk_ir::ConstValue::Concrete(c) => match &c.interned {
+                ConstScalar::Bytes(b, mm) => {
+                    check(b, mm);
+                }
+                x => panic!("Expected number but found {x:?}"),
+            },
+            _ => panic!("result of const eval wasn't a concrete const"),
+        }
+    });
 }
 
-fn pretty_print_err(e: ConstEvalError, db: TestDB) -> String {
+fn pretty_print_err(e: ConstEvalError, db: &TestDB) -> String {
     let mut err = String::new();
     let span_formatter = |file, range| format!("{file:?} {range:?}");
     let display_target =
-        DisplayTarget::from_crate(&db, *db.all_crates().last().expect("no crate graph present"));
+        DisplayTarget::from_crate(db, *db.all_crates().last().expect("no crate graph present"));
     match e {
         ConstEvalError::MirLowerError(e) => {
-            e.pretty_print(&mut err, &db, span_formatter, display_target)
+            e.pretty_print(&mut err, db, span_formatter, display_target)
         }
         ConstEvalError::MirEvalError(e) => {
-            e.pretty_print(&mut err, &db, span_formatter, display_target)
+            e.pretty_print(&mut err, db, span_formatter, display_target)
         }
     }
     .unwrap();
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs
index 6e07d3afe5524..155f1336e41d4 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval_nextsolver.rs
@@ -222,7 +222,7 @@ pub(crate) fn const_eval_discriminant_variant(
 // and make this function private. See the fixme comment on `InferenceContext::resolve_all`.
 pub(crate) fn eval_to_const<'db>(expr: ExprId, ctx: &mut InferenceContext<'db>) -> Const<'db> {
     let interner = DbInterner::new_with(ctx.db, None, None);
-    let infer = ctx.clone().resolve_all();
+    let infer = ctx.fixme_resolve_all_clone();
     fn has_closure(body: &Body, expr: ExprId) -> bool {
         if matches!(body[expr], Expr::Closure { .. }) {
             return true;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
index fd10f923987f0..287afb039b457 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer.rs
@@ -19,6 +19,7 @@ pub(crate) mod closure;
 mod coerce;
 pub(crate) mod diagnostics;
 mod expr;
+mod fallback;
 mod mutability;
 mod pat;
 mod path;
@@ -53,16 +54,16 @@ use indexmap::IndexSet;
 use intern::sym;
 use la_arena::{ArenaMap, Entry};
 use rustc_hash::{FxHashMap, FxHashSet};
+use rustc_type_ir::inherent::Ty as _;
 use stdx::{always, never};
 use triomphe::Arc;
 
-use crate::db::InternedClosureId;
 use crate::{
     AliasEq, AliasTy, Binders, ClosureId, Const, DomainGoal, GenericArg, ImplTraitId, ImplTraitIdx,
     IncorrectGenericsLenKind, Interner, Lifetime, OpaqueTyId, ParamLoweringMode,
     PathLoweringDiagnostic, ProjectionTy, Substitution, TargetFeatures, TraitEnvironment, Ty,
     TyBuilder, TyExt,
-    db::HirDatabase,
+    db::{HirDatabase, InternedClosureId},
     fold_tys,
     generics::Generics,
     infer::{
@@ -75,6 +76,7 @@ use crate::{
     mir::MirSpan,
     next_solver::{
         self, DbInterner,
+        infer::{DefineOpaqueTypes, traits::ObligationCause},
         mapping::{ChalkToNextSolver, NextSolverToChalk},
     },
     static_lifetime, to_assoc_type_id,
@@ -138,6 +140,20 @@ pub(crate) fn infer_query(db: &dyn HirDatabase, def: DefWithBodyId) -> Arc<Infer
 
     ctx.infer_mut_body();
 
+    ctx.type_inference_fallback();
+
+    // Comment from rustc:
+    // Even though coercion casts provide type hints, we check casts after fallback for
+    // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
+    let cast_checks = std::mem::take(&mut ctx.deferred_cast_checks);
+    for mut cast in cast_checks.into_iter() {
+        if let Err(diag) = cast.check(&mut ctx) {
+            ctx.diagnostics.push(diag);
+        }
+    }
+
+    ctx.table.select_obligations_where_possible();
+
     ctx.infer_closures();
 
     Arc::new(ctx.resolve_all())
@@ -165,7 +181,6 @@ pub(crate) fn normalize(db: &dyn HirDatabase, trait_env: Arc<TraitEnvironment<'_
 
     let ty_with_vars = table.normalize_associated_types_in(ty);
     table.select_obligations_where_possible();
-    table.propagate_diverging_flag();
     table.resolve_completely(ty_with_vars)
 }
 
@@ -686,6 +701,25 @@ impl Index<BindingId> for InferenceResult {
     }
 }
 
+#[derive(Debug, Clone)]
+struct InternedStandardTypesNextSolver<'db> {
+    unit: crate::next_solver::Ty<'db>,
+    never: crate::next_solver::Ty<'db>,
+    i32: crate::next_solver::Ty<'db>,
+    f64: crate::next_solver::Ty<'db>,
+}
+
+impl<'db> InternedStandardTypesNextSolver<'db> {
+    fn new(interner: DbInterner<'db>) -> Self {
+        Self {
+            unit: crate::next_solver::Ty::new_unit(interner),
+            never: crate::next_solver::Ty::new(interner, crate::next_solver::TyKind::Never),
+            i32: crate::next_solver::Ty::new_int(interner, rustc_type_ir::IntTy::I32),
+            f64: crate::next_solver::Ty::new_float(interner, rustc_type_ir::FloatTy::F64),
+        }
+    }
+}
+
 /// The inference context contains all information needed during type inference.
 #[derive(Clone, Debug)]
 pub(crate) struct InferenceContext<'db> {
@@ -718,6 +752,7 @@ pub(crate) struct InferenceContext<'db> {
     resume_yield_tys: Option<(Ty, Ty)>,
     diverges: Diverges,
     breakables: Vec<BreakableContext<'db>>,
+    types: InternedStandardTypesNextSolver<'db>,
 
     /// Whether we are inside the pattern of a destructuring assignment.
     inside_assignment: bool,
@@ -798,11 +833,13 @@ impl<'db> InferenceContext<'db> {
         resolver: Resolver<'db>,
     ) -> Self {
         let trait_env = db.trait_environment_for_body(owner);
+        let table = unify::InferenceTable::new(db, trait_env);
         InferenceContext {
+            types: InternedStandardTypesNextSolver::new(table.interner),
             target_features: OnceCell::new(),
             generics: OnceCell::new(),
             result: InferenceResult::default(),
-            table: unify::InferenceTable::new(db, trait_env),
+            table,
             tuple_field_accesses_rev: Default::default(),
             return_ty: TyKind::Error.intern(Interner), // set in collect_* calls
             resume_yield_tys: None,
@@ -865,24 +902,33 @@ impl<'db> InferenceContext<'db> {
         self.result.has_errors = true;
     }
 
-    // FIXME: This function should be private in module. It is currently only used in the consteval, since we need
-    // `InferenceResult` in the middle of inference. See the fixme comment in `consteval::eval_to_const`. If you
-    // used this function for another workaround, mention it here. If you really need this function and believe that
-    // there is no problem in it being `pub(crate)`, remove this comment.
-    pub(crate) fn resolve_all(mut self) -> InferenceResult {
-        self.table.select_obligations_where_possible();
-        self.table.fallback_if_possible();
+    /// Clones `self` and calls `resolve_all()` on it.
+    // FIXME: Remove this.
+    pub(crate) fn fixme_resolve_all_clone(&self) -> InferenceResult {
+        let mut ctx = self.clone();
+
+        ctx.type_inference_fallback();
 
         // Comment from rustc:
         // Even though coercion casts provide type hints, we check casts after fallback for
         // backwards compatibility. This makes fallback a stronger type hint than a cast coercion.
-        let cast_checks = std::mem::take(&mut self.deferred_cast_checks);
+        let cast_checks = std::mem::take(&mut ctx.deferred_cast_checks);
         for mut cast in cast_checks.into_iter() {
-            if let Err(diag) = cast.check(&mut self) {
-                self.diagnostics.push(diag);
+            if let Err(diag) = cast.check(&mut ctx) {
+                ctx.diagnostics.push(diag);
             }
         }
 
+        ctx.table.select_obligations_where_possible();
+
+        ctx.resolve_all()
+    }
+
+    // FIXME: This function should be private in module. It is currently only used in the consteval, since we need
+    // `InferenceResult` in the middle of inference. See the fixme comment in `consteval::eval_to_const`. If you
+    // used this function for another workaround, mention it here. If you really need this function and believe that
+    // there is no problem in it being `pub(crate)`, remove this comment.
+    pub(crate) fn resolve_all(self) -> InferenceResult {
         let InferenceContext {
             mut table, mut result, tuple_field_accesses_rev, diagnostics, ..
         } = self;
@@ -914,11 +960,6 @@ impl<'db> InferenceContext<'db> {
             diagnostics: _,
         } = &mut result;
 
-        // FIXME resolve obligations as well (use Guidance if necessary)
-        table.select_obligations_where_possible();
-
-        // make sure diverging type variables are marked as such
-        table.propagate_diverging_flag();
         for ty in type_of_expr.values_mut() {
             *ty = table.resolve_completely(ty.clone());
             *has_errors = *has_errors || ty.contains_unknown();
@@ -1673,6 +1714,22 @@ impl<'db> InferenceContext<'db> {
         self.resolve_associated_type_with_params(inner_ty, assoc_ty, &[])
     }
 
+    fn demand_eqtype(
+        &mut self,
+        expected: crate::next_solver::Ty<'db>,
+        actual: crate::next_solver::Ty<'db>,
+    ) {
+        let result = self
+            .table
+            .infer_ctxt
+            .at(&ObligationCause::new(), self.table.trait_env.env)
+            .eq(DefineOpaqueTypes::Yes, expected, actual)
+            .map(|infer_ok| self.table.register_infer_ok(infer_ok));
+        if let Err(_err) = result {
+            // FIXME: Emit diagnostic.
+        }
+    }
+
     fn resolve_associated_type_with_params(
         &mut self,
         inner_ty: Ty,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
index 219b519e46bb8..62ce00a2e33d4 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
@@ -210,9 +210,8 @@ impl<'a, 'b, 'db> Coerce<'a, 'b, 'db> {
         // Coercing from `!` to any type is allowed:
         if a.is_never() {
             // If we're coercing into an inference var, mark it as possibly diverging.
-            // FIXME: rustc does this differently.
-            if let TyKind::Infer(rustc_type_ir::TyVar(b)) = b.kind() {
-                self.table.set_diverging(b.as_u32().into(), chalk_ir::TyVariableKind::General);
+            if b.is_infer() {
+                self.table.set_diverging(b);
             }
 
             if self.coerce_never {
@@ -1613,16 +1612,21 @@ fn coerce<'db>(
             chalk_ir::GenericArgData::Const(c) => c.inference_var(Interner),
         } == Some(iv))
     };
-    let fallback = |iv, kind, default, binder| match kind {
-        chalk_ir::VariableKind::Ty(_ty_kind) => find_var(iv)
-            .map_or(default, |i| crate::BoundVar::new(binder, i).to_ty(Interner).cast(Interner)),
-        chalk_ir::VariableKind::Lifetime => find_var(iv).map_or(default, |i| {
-            crate::BoundVar::new(binder, i).to_lifetime(Interner).cast(Interner)
-        }),
-        chalk_ir::VariableKind::Const(ty) => find_var(iv).map_or(default, |i| {
-            crate::BoundVar::new(binder, i).to_const(Interner, ty).cast(Interner)
-        }),
+    let fallback = |iv, kind, binder| match kind {
+        chalk_ir::VariableKind::Ty(_ty_kind) => find_var(iv).map_or_else(
+            || chalk_ir::TyKind::Error.intern(Interner).cast(Interner),
+            |i| crate::BoundVar::new(binder, i).to_ty(Interner).cast(Interner),
+        ),
+        chalk_ir::VariableKind::Lifetime => find_var(iv).map_or_else(
+            || crate::LifetimeData::Error.intern(Interner).cast(Interner),
+            |i| crate::BoundVar::new(binder, i).to_lifetime(Interner).cast(Interner),
+        ),
+        chalk_ir::VariableKind::Const(ty) => find_var(iv).map_or_else(
+            || crate::unknown_const(ty.clone()).cast(Interner),
+            |i| crate::BoundVar::new(binder, i).to_const(Interner, ty.clone()).cast(Interner),
+        ),
     };
     // FIXME also map the types in the adjustments
+    // FIXME: We don't fallback correctly since this is done on `InferenceContext` and we only have `InferenceTable`.
     Ok((adjustments, table.resolve_with_fallback(ty.to_chalk(table.interner), &fallback)))
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/fallback.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/fallback.rs
new file mode 100644
index 0000000000000..2022447ad4339
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/fallback.rs
@@ -0,0 +1,439 @@
+//! Fallback of infer vars to `!` and `i32`/`f64`.
+
+use intern::sym;
+use petgraph::{
+    Graph,
+    visit::{Dfs, Walker},
+};
+use rustc_hash::{FxBuildHasher, FxHashMap, FxHashSet};
+use rustc_type_ir::{
+    TyVid,
+    inherent::{IntoKind, Ty as _},
+};
+use tracing::debug;
+
+use crate::{
+    infer::InferenceContext,
+    next_solver::{CoercePredicate, PredicateKind, SubtypePredicate, Ty, TyKind},
+};
+
+#[derive(Copy, Clone)]
+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.
+    ContextDependent,
+    /// Always fallback to `!` (which should be equivalent to never falling back + not making
+    /// never-to-any coercions unless necessary)
+    ToNever,
+}
+
+impl<'db> InferenceContext<'db> {
+    pub(super) fn type_inference_fallback(&mut self) {
+        debug!(
+            "type-inference-fallback start obligations: {:#?}",
+            self.table.fulfillment_cx.pending_obligations()
+        );
+
+        // All type checking constraints were added, try to fallback unsolved variables.
+        self.table.select_obligations_where_possible();
+
+        debug!(
+            "type-inference-fallback post selection obligations: {:#?}",
+            self.table.fulfillment_cx.pending_obligations()
+        );
+
+        let fallback_occurred = self.fallback_types();
+
+        if !fallback_occurred {
+            return;
+        }
+
+        // We now see if we can make progress. This might cause us to
+        // unify inference variables for opaque types, since we may
+        // have unified some other type variables during the first
+        // phase of fallback. This means that we only replace
+        // inference variables with their underlying opaque types as a
+        // last resort.
+        //
+        // In code like this:
+        //
+        // ```rust
+        // type MyType = impl Copy;
+        // fn produce() -> MyType { true }
+        // fn bad_produce() -> MyType { panic!() }
+        // ```
+        //
+        // we want to unify the opaque inference variable in `bad_produce`
+        // with the diverging fallback for `panic!` (e.g. `()` or `!`).
+        // This will produce a nice error message about conflicting concrete
+        // types for `MyType`.
+        //
+        // If we had tried to fallback the opaque inference variable to `MyType`,
+        // we will generate a confusing type-check error that does not explicitly
+        // refer to opaque types.
+        self.table.select_obligations_where_possible();
+    }
+
+    fn diverging_fallback_behavior(&self) -> DivergingFallbackBehavior {
+        if self.krate().data(self.db).edition.at_least_2024() {
+            return DivergingFallbackBehavior::ToNever;
+        }
+
+        if self.resolver.def_map().is_unstable_feature_enabled(&sym::never_type_fallback) {
+            return DivergingFallbackBehavior::ContextDependent;
+        }
+
+        DivergingFallbackBehavior::ToUnit
+    }
+
+    fn fallback_types(&mut self) -> bool {
+        // Check if we have any unresolved variables. If not, no need for fallback.
+        let unresolved_variables = self.table.infer_ctxt.unresolved_variables();
+
+        if unresolved_variables.is_empty() {
+            return false;
+        }
+
+        let diverging_fallback_behavior = self.diverging_fallback_behavior();
+
+        let diverging_fallback =
+            self.calculate_diverging_fallback(&unresolved_variables, diverging_fallback_behavior);
+
+        // We do fallback in two passes, to try to generate
+        // better error messages.
+        // The first time, we do *not* replace opaque types.
+        let mut fallback_occurred = false;
+        for ty in unresolved_variables {
+            debug!("unsolved_variable = {:?}", ty);
+            fallback_occurred |= self.fallback_if_possible(ty, &diverging_fallback);
+        }
+
+        fallback_occurred
+    }
+
+    // Tries to apply a fallback to `ty` if it is an unsolved variable.
+    //
+    // - Unconstrained ints are replaced with `i32`.
+    //
+    // - Unconstrained floats are replaced with `f64`.
+    //
+    // - Non-numerics may get replaced with `()` or `!`, depending on
+    //   how they were categorized by `calculate_diverging_fallback`
+    //   (and the setting of `#![feature(never_type_fallback)]`).
+    //
+    // Fallback becomes very dubious if we have encountered
+    // type-checking errors. In that case, fallback to Error.
+    //
+    // Sets `FnCtxt::fallback_has_occurred` if fallback is performed
+    // during this call.
+    fn fallback_if_possible(
+        &mut self,
+        ty: Ty<'db>,
+        diverging_fallback: &FxHashMap<Ty<'db>, Ty<'db>>,
+    ) -> bool {
+        // Careful: we do NOT shallow-resolve `ty`. We know that `ty`
+        // is an unsolved variable, and we determine its fallback
+        // based solely on how it was created, not what other type
+        // variables it may have been unified with since then.
+        //
+        // The reason this matters is that other attempts at fallback
+        // may (in principle) conflict with this fallback, and we wish
+        // to generate a type error in that case. (However, this
+        // actually isn't true right now, because we're only using the
+        // builtin fallback rules. This would be true if we were using
+        // user-supplied fallbacks. But it's still useful to write the
+        // code to detect bugs.)
+        //
+        // (Note though that if we have a general type variable `?T`
+        // that is then unified with an integer type variable `?I`
+        // that ultimately never gets resolved to a special integral
+        // type, `?T` is not considered unsolved, but `?I` is. The
+        // same is true for float variables.)
+        let fallback = match ty.kind() {
+            TyKind::Infer(rustc_type_ir::IntVar(_)) => self.types.i32,
+            TyKind::Infer(rustc_type_ir::FloatVar(_)) => self.types.f64,
+            _ => match diverging_fallback.get(&ty) {
+                Some(&fallback_ty) => fallback_ty,
+                None => return false,
+            },
+        };
+        debug!("fallback_if_possible(ty={:?}): defaulting to `{:?}`", ty, fallback);
+
+        self.demand_eqtype(ty, fallback);
+        true
+    }
+
+    /// The "diverging fallback" system is rather complicated. This is
+    /// a result of our need to balance 'do the right thing' with
+    /// backwards compatibility.
+    ///
+    /// "Diverging" type variables are variables created when we
+    /// coerce a `!` type into an unbound type variable `?X`. If they
+    /// never wind up being constrained, the "right and natural" thing
+    /// is that `?X` should "fallback" to `!`. This means that e.g. an
+    /// expression like `Some(return)` will ultimately wind up with a
+    /// type like `Option<!>` (presuming it is not assigned or
+    /// constrained to have some other type).
+    ///
+    /// However, the fallback used to be `()` (before the `!` type was
+    /// added). Moreover, there are cases where the `!` type 'leaks
+    /// out' from dead code into type variables that affect live
+    /// code. The most common case is something like this:
+    ///
+    /// ```rust
+    /// # fn foo() -> i32 { 4 }
+    /// match foo() {
+    ///     22 => Default::default(), // call this type `?D`
+    ///     _ => return, // return has type `!`
+    /// } // call the type of this match `?M`
+    /// ```
+    ///
+    /// Here, coercing the type `!` into `?M` will create a diverging
+    /// type variable `?X` where `?X <: ?M`. We also have that `?D <:
+    /// ?M`. If `?M` winds up unconstrained, then `?X` will
+    /// fallback. If it falls back to `!`, then all the type variables
+    /// will wind up equal to `!` -- this includes the type `?D`
+    /// (since `!` doesn't implement `Default`, we wind up a "trait
+    /// not implemented" error in code like this). But since the
+    /// original fallback was `()`, this code used to compile with `?D
+    /// = ()`. This is somewhat surprising, since `Default::default()`
+    /// on its own would give an error because the types are
+    /// insufficiently constrained.
+    ///
+    /// Our solution to this dilemma is to modify diverging variables
+    /// so that they can *either* fallback to `!` (the default) or to
+    /// `()` (the backwards compatibility case). We decide which
+    /// fallback to use based on whether there is a coercion pattern
+    /// like this:
+    ///
+    /// ```ignore (not-rust)
+    /// ?Diverging -> ?V
+    /// ?NonDiverging -> ?V
+    /// ?V != ?NonDiverging
+    /// ```
+    ///
+    /// Here `?Diverging` represents some diverging type variable and
+    /// `?NonDiverging` represents some non-diverging type
+    /// variable. `?V` can be any type variable (diverging or not), so
+    /// long as it is not equal to `?NonDiverging`.
+    ///
+    /// Intuitively, what we are looking for is a case where a
+    /// "non-diverging" type variable (like `?M` in our example above)
+    /// is coerced *into* some variable `?V` that would otherwise
+    /// fallback to `!`. In that case, we make `?V` fallback to `!`,
+    /// along with anything that would flow into `?V`.
+    ///
+    /// The algorithm we use:
+    /// * Identify all variables that are coerced *into* by a
+    ///   diverging variable. Do this by iterating over each
+    ///   diverging, unsolved variable and finding all variables
+    ///   reachable from there. Call that set `D`.
+    /// * Walk over all unsolved, non-diverging variables, and find
+    ///   any variable that has an edge into `D`.
+    fn calculate_diverging_fallback(
+        &self,
+        unresolved_variables: &[Ty<'db>],
+        behavior: DivergingFallbackBehavior,
+    ) -> FxHashMap<Ty<'db>, Ty<'db>> {
+        debug!("calculate_diverging_fallback({:?})", unresolved_variables);
+
+        // Construct a coercion graph where an edge `A -> B` indicates
+        // a type variable is that is coerced
+        let coercion_graph = self.create_coercion_graph();
+
+        // Extract the unsolved type inference variable vids; note that some
+        // unsolved variables are integer/float variables and are excluded.
+        let unsolved_vids = unresolved_variables.iter().filter_map(|ty| ty.ty_vid());
+
+        // Compute the diverging root vids D -- that is, the root vid of
+        // those type variables that (a) are the target of a coercion from
+        // a `!` type and (b) have not yet been solved.
+        //
+        // These variables are the ones that are targets for fallback to
+        // either `!` or `()`.
+        let diverging_roots: FxHashSet<TyVid> = self
+            .table
+            .diverging_type_vars
+            .iter()
+            .map(|&ty| self.shallow_resolve(ty))
+            .filter_map(|ty| ty.ty_vid())
+            .map(|vid| self.table.infer_ctxt.root_var(vid))
+            .collect();
+        debug!(
+            "calculate_diverging_fallback: diverging_type_vars={:?}",
+            self.table.diverging_type_vars
+        );
+        debug!("calculate_diverging_fallback: diverging_roots={:?}", diverging_roots);
+
+        // Find all type variables that are reachable from a diverging
+        // type variable. These will typically default to `!`, unless
+        // we find later that they are *also* reachable from some
+        // other type variable outside this set.
+        let mut roots_reachable_from_diverging = Dfs::empty(&coercion_graph);
+        let mut diverging_vids = vec![];
+        let mut non_diverging_vids = vec![];
+        for unsolved_vid in unsolved_vids {
+            let root_vid = self.table.infer_ctxt.root_var(unsolved_vid);
+            debug!(
+                "calculate_diverging_fallback: unsolved_vid={:?} root_vid={:?} diverges={:?}",
+                unsolved_vid,
+                root_vid,
+                diverging_roots.contains(&root_vid),
+            );
+            if diverging_roots.contains(&root_vid) {
+                diverging_vids.push(unsolved_vid);
+                roots_reachable_from_diverging.move_to(root_vid.as_u32().into());
+
+                // drain the iterator to visit all nodes reachable from this node
+                while roots_reachable_from_diverging.next(&coercion_graph).is_some() {}
+            } else {
+                non_diverging_vids.push(unsolved_vid);
+            }
+        }
+
+        debug!(
+            "calculate_diverging_fallback: roots_reachable_from_diverging={:?}",
+            roots_reachable_from_diverging,
+        );
+
+        // Find all type variables N0 that are not reachable from a
+        // diverging variable, and then compute the set reachable from
+        // N0, which we call N. These are the *non-diverging* type
+        // variables. (Note that this set consists of "root variables".)
+        let mut roots_reachable_from_non_diverging = Dfs::empty(&coercion_graph);
+        for &non_diverging_vid in &non_diverging_vids {
+            let root_vid = self.table.infer_ctxt.root_var(non_diverging_vid);
+            if roots_reachable_from_diverging.discovered.contains(root_vid.as_usize()) {
+                continue;
+            }
+            roots_reachable_from_non_diverging.move_to(root_vid.as_u32().into());
+            while roots_reachable_from_non_diverging.next(&coercion_graph).is_some() {}
+        }
+        debug!(
+            "calculate_diverging_fallback: roots_reachable_from_non_diverging={:?}",
+            roots_reachable_from_non_diverging,
+        );
+
+        debug!("obligations: {:#?}", self.table.fulfillment_cx.pending_obligations());
+
+        // For each diverging variable, figure out whether it can
+        // reach a member of N. If so, it falls back to `()`. Else
+        // `!`.
+        let mut diverging_fallback =
+            FxHashMap::with_capacity_and_hasher(diverging_vids.len(), FxBuildHasher);
+
+        for &diverging_vid in &diverging_vids {
+            let diverging_ty = Ty::new_var(self.table.interner, diverging_vid);
+            let root_vid = self.table.infer_ctxt.root_var(diverging_vid);
+            let can_reach_non_diverging = Dfs::new(&coercion_graph, root_vid.as_u32().into())
+                .iter(&coercion_graph)
+                .any(|n| roots_reachable_from_non_diverging.discovered.contains(n.index()));
+
+            let mut fallback_to = |ty| {
+                diverging_fallback.insert(diverging_ty, ty);
+            };
+
+            match behavior {
+                DivergingFallbackBehavior::ToUnit => {
+                    debug!("fallback to () - legacy: {:?}", diverging_vid);
+                    fallback_to(self.types.unit);
+                }
+                DivergingFallbackBehavior::ContextDependent => {
+                    // FIXME: rustc does the following, but given this is only relevant when the unstable
+                    // `never_type_fallback` feature is active, I chose to not port this.
+                    // if found_infer_var_info.self_in_trait && found_infer_var_info.output {
+                    //     // This case falls back to () to ensure that the code pattern in
+                    //     // tests/ui/never_type/fallback-closure-ret.rs continues to
+                    //     // compile when never_type_fallback is enabled.
+                    //     //
+                    //     // This rule is not readily explainable from first principles,
+                    //     // but is rather intended as a patchwork fix to ensure code
+                    //     // which compiles before the stabilization of never type
+                    //     // fallback continues to work.
+                    //     //
+                    //     // Typically this pattern is encountered in a function taking a
+                    //     // closure as a parameter, where the return type of that closure
+                    //     // (checked by `relationship.output`) is expected to implement
+                    //     // some trait (checked by `relationship.self_in_trait`). This
+                    //     // can come up in non-closure cases too, so we do not limit this
+                    //     // rule to specifically `FnOnce`.
+                    //     //
+                    //     // When the closure's body is something like `panic!()`, the
+                    //     // return type would normally be inferred to `!`. However, it
+                    //     // needs to fall back to `()` in order to still compile, as the
+                    //     // trait is specifically implemented for `()` but not `!`.
+                    //     //
+                    //     // For details on the requirements for these relationships to be
+                    //     // set, see the relationship finding module in
+                    //     // compiler/rustc_trait_selection/src/traits/relationships.rs.
+                    //     debug!("fallback to () - found trait and projection: {:?}", diverging_vid);
+                    //     fallback_to(self.types.unit);
+                    // }
+                    if can_reach_non_diverging {
+                        debug!("fallback to () - reached non-diverging: {:?}", diverging_vid);
+                        fallback_to(self.types.unit);
+                    } else {
+                        debug!("fallback to ! - all diverging: {:?}", diverging_vid);
+                        fallback_to(self.types.never);
+                    }
+                }
+                DivergingFallbackBehavior::ToNever => {
+                    debug!(
+                        "fallback to ! - `rustc_never_type_mode = \"fallback_to_never\")`: {:?}",
+                        diverging_vid
+                    );
+                    fallback_to(self.types.never);
+                }
+            }
+        }
+
+        diverging_fallback
+    }
+
+    /// Returns a graph whose nodes are (unresolved) inference variables and where
+    /// an edge `?A -> ?B` indicates that the variable `?A` is coerced to `?B`.
+    fn create_coercion_graph(&self) -> Graph<(), ()> {
+        let pending_obligations = self.table.fulfillment_cx.pending_obligations();
+        let pending_obligations_len = pending_obligations.len();
+        debug!("create_coercion_graph: pending_obligations={:?}", pending_obligations);
+        let coercion_edges = pending_obligations
+            .into_iter()
+            .filter_map(|obligation| {
+                // The predicates we are looking for look like `Coerce(?A -> ?B)`.
+                // They will have no bound variables.
+                obligation.predicate.kind().no_bound_vars()
+            })
+            .filter_map(|atom| {
+                // We consider both subtyping and coercion to imply 'flow' from
+                // some position in the code `a` to a different position `b`.
+                // This is then used to determine which variables interact with
+                // live code, and as such must fall back to `()` to preserve
+                // soundness.
+                //
+                // In practice currently the two ways that this happens is
+                // coercion and subtyping.
+                let (a, b) = match atom {
+                    PredicateKind::Coerce(CoercePredicate { a, b }) => (a, b),
+                    PredicateKind::Subtype(SubtypePredicate { a_is_expected: _, a, b }) => (a, b),
+                    _ => return None,
+                };
+
+                let a_vid = self.root_vid(a)?;
+                let b_vid = self.root_vid(b)?;
+                Some((a_vid.as_u32(), b_vid.as_u32()))
+            });
+        let num_ty_vars = self.table.infer_ctxt.num_ty_vars();
+        let mut graph = Graph::with_capacity(num_ty_vars, pending_obligations_len);
+        for _ in 0..num_ty_vars {
+            graph.add_node(());
+        }
+        graph.extend_with_edges(coercion_edges);
+        graph
+    }
+
+    /// If `ty` is an unresolved type variable, returns its root vid.
+    fn root_vid(&self, ty: Ty<'db>) -> Option<TyVid> {
+        Some(self.table.infer_ctxt.root_var(self.shallow_resolve(ty).ty_vid()?))
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
index dd7e77ba8c098..108cf5b1a2b8e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
@@ -3,8 +3,7 @@
 use std::fmt;
 
 use chalk_ir::{
-    CanonicalVarKind, FloatTy, IntTy, TyVariableKind, cast::Cast, fold::TypeFoldable,
-    interner::HasInterner,
+    CanonicalVarKind, TyVariableKind, cast::Cast, fold::TypeFoldable, interner::HasInterner,
 };
 use either::Either;
 use hir_def::{AdtId, lang_item::LangItem};
@@ -12,7 +11,7 @@ use hir_expand::name::Name;
 use intern::sym;
 use rustc_hash::{FxHashMap, FxHashSet};
 use rustc_type_ir::{
-    FloatVid, IntVid, TyVid, TypeVisitableExt, UpcastFrom,
+    TyVid, TypeVisitableExt, UpcastFrom,
     inherent::{IntoKind, Span, Term as _, Ty as _},
     relate::{Relate, solver_relating::RelateExt},
     solve::{Certainty, GoalSource},
@@ -23,8 +22,8 @@ use triomphe::Arc;
 use super::{InferResult, InferenceContext, TypeError};
 use crate::{
     AliasTy, BoundVar, Canonical, Const, ConstValue, DebruijnIndex, GenericArg, GenericArgData,
-    InferenceVar, Interner, Lifetime, OpaqueTyId, ProjectionTy, Scalar, Substitution,
-    TraitEnvironment, Ty, TyExt, TyKind, VariableKind,
+    InferenceVar, Interner, Lifetime, OpaqueTyId, ProjectionTy, Substitution, TraitEnvironment, Ty,
+    TyExt, TyKind, VariableKind,
     consteval::unknown_const,
     db::HirDatabase,
     fold_generic_args, fold_tys_and_consts,
@@ -143,7 +142,6 @@ pub fn could_unify_deeply(
     let ty1_with_vars = table.normalize_associated_types_in(ty1_with_vars);
     let ty2_with_vars = table.normalize_associated_types_in(ty2_with_vars);
     table.select_obligations_where_possible();
-    table.propagate_diverging_flag();
     let ty1_with_vars = table.resolve_completely(ty1_with_vars);
     let ty2_with_vars = table.resolve_completely(ty2_with_vars);
     table.unify_deeply(&ty1_with_vars, &ty2_with_vars)
@@ -170,13 +168,19 @@ pub(crate) fn unify(
             GenericArgData::Const(c) => c.inference_var(Interner),
         } == Some(iv))
     };
-    let fallback = |iv, kind, default, binder| match kind {
-        chalk_ir::VariableKind::Ty(_ty_kind) => find_var(iv)
-            .map_or(default, |i| BoundVar::new(binder, i).to_ty(Interner).cast(Interner)),
-        chalk_ir::VariableKind::Lifetime => find_var(iv)
-            .map_or(default, |i| BoundVar::new(binder, i).to_lifetime(Interner).cast(Interner)),
-        chalk_ir::VariableKind::Const(ty) => find_var(iv)
-            .map_or(default, |i| BoundVar::new(binder, i).to_const(Interner, ty).cast(Interner)),
+    let fallback = |iv, kind, binder| match kind {
+        chalk_ir::VariableKind::Ty(_ty_kind) => find_var(iv).map_or_else(
+            || TyKind::Error.intern(Interner).cast(Interner),
+            |i| BoundVar::new(binder, i).to_ty(Interner).cast(Interner),
+        ),
+        chalk_ir::VariableKind::Lifetime => find_var(iv).map_or_else(
+            || crate::error_lifetime().cast(Interner),
+            |i| BoundVar::new(binder, i).to_lifetime(Interner).cast(Interner),
+        ),
+        chalk_ir::VariableKind::Const(ty) => find_var(iv).map_or_else(
+            || crate::unknown_const(ty.clone()).cast(Interner),
+            |i| BoundVar::new(binder, i).to_const(Interner, ty.clone()).cast(Interner),
+        ),
     };
     Some(Substitution::from_iter(
         Interner,
@@ -215,14 +219,13 @@ pub(crate) struct InferenceTable<'db> {
     pub(crate) trait_env: Arc<TraitEnvironment<'db>>,
     pub(crate) tait_coercion_table: Option<FxHashMap<OpaqueTyId, Ty>>,
     pub(crate) infer_ctxt: InferCtxt<'db>,
-    diverging_tys: FxHashSet<Ty>,
     pub(super) fulfillment_cx: FulfillmentCtxt<'db>,
+    pub(super) diverging_type_vars: FxHashSet<crate::next_solver::Ty<'db>>,
 }
 
 pub(crate) struct InferenceTableSnapshot<'db> {
     ctxt_snapshot: CombinedSnapshot,
     obligations: FulfillmentCtxt<'db>,
-    diverging_tys: FxHashSet<Ty>,
 }
 
 impl<'db> InferenceTable<'db> {
@@ -238,7 +241,7 @@ impl<'db> InferenceTable<'db> {
             tait_coercion_table: None,
             fulfillment_cx: FulfillmentCtxt::new(&infer_ctxt),
             infer_ctxt,
-            diverging_tys: FxHashSet::default(),
+            diverging_type_vars: FxHashSet::default(),
         }
     }
 
@@ -321,74 +324,8 @@ impl<'db> InferenceTable<'db> {
         }
     }
 
-    /// Chalk doesn't know about the `diverging` flag, so when it unifies two
-    /// type variables of which one is diverging, the chosen root might not be
-    /// diverging and we have no way of marking it as such at that time. This
-    /// function goes through all type variables and make sure their root is
-    /// marked as diverging if necessary, so that resolving them gives the right
-    /// result.
-    pub(super) fn propagate_diverging_flag(&mut self) {
-        let mut new_tys = FxHashSet::default();
-        for ty in self.diverging_tys.iter() {
-            match ty.kind(Interner) {
-                TyKind::InferenceVar(var, kind) => match kind {
-                    TyVariableKind::General => {
-                        let root = InferenceVar::from(
-                            self.infer_ctxt.root_var(TyVid::from_u32(var.index())).as_u32(),
-                        );
-                        if root.index() != var.index() {
-                            new_tys.insert(TyKind::InferenceVar(root, *kind).intern(Interner));
-                        }
-                    }
-                    TyVariableKind::Integer => {
-                        let root = InferenceVar::from(
-                            self.infer_ctxt
-                                .inner
-                                .borrow_mut()
-                                .int_unification_table()
-                                .find(IntVid::from_usize(var.index() as usize))
-                                .as_u32(),
-                        );
-                        if root.index() != var.index() {
-                            new_tys.insert(TyKind::InferenceVar(root, *kind).intern(Interner));
-                        }
-                    }
-                    TyVariableKind::Float => {
-                        let root = InferenceVar::from(
-                            self.infer_ctxt
-                                .inner
-                                .borrow_mut()
-                                .float_unification_table()
-                                .find(FloatVid::from_usize(var.index() as usize))
-                                .as_u32(),
-                        );
-                        if root.index() != var.index() {
-                            new_tys.insert(TyKind::InferenceVar(root, *kind).intern(Interner));
-                        }
-                    }
-                },
-                _ => {}
-            }
-        }
-        self.diverging_tys.extend(new_tys);
-    }
-
-    pub(super) fn set_diverging(&mut self, iv: InferenceVar, kind: TyVariableKind) {
-        self.diverging_tys.insert(TyKind::InferenceVar(iv, kind).intern(Interner));
-    }
-
-    fn fallback_value(&self, iv: InferenceVar, kind: TyVariableKind) -> Ty {
-        let is_diverging =
-            self.diverging_tys.contains(&TyKind::InferenceVar(iv, kind).intern(Interner));
-        if is_diverging {
-            return TyKind::Never.intern(Interner);
-        }
-        match kind {
-            TyVariableKind::General => TyKind::Error,
-            TyVariableKind::Integer => TyKind::Scalar(Scalar::Int(IntTy::I32)),
-            TyVariableKind::Float => TyKind::Scalar(Scalar::Float(FloatTy::F64)),
-        }
-        .intern(Interner)
+    pub(super) fn set_diverging(&mut self, ty: crate::next_solver::Ty<'db>) {
+        self.diverging_type_vars.insert(ty);
     }
 
     pub(crate) fn canonicalize<T>(&mut self, t: T) -> rustc_type_ir::Canonical<DbInterner<'db>, T>
@@ -529,7 +466,7 @@ impl<'db> InferenceTable<'db> {
 
         let ty = var.to_ty(Interner, kind);
         if diverging {
-            self.diverging_tys.insert(ty.clone());
+            self.diverging_type_vars.insert(ty.to_nextsolver(self.interner));
         }
         ty
     }
@@ -573,7 +510,7 @@ impl<'db> InferenceTable<'db> {
     pub(crate) fn resolve_with_fallback<T>(
         &mut self,
         t: T,
-        fallback: &dyn Fn(InferenceVar, VariableKind, GenericArg, DebruijnIndex) -> GenericArg,
+        fallback: &dyn Fn(InferenceVar, VariableKind, DebruijnIndex) -> GenericArg,
     ) -> T
     where
         T: HasInterner<Interner = Interner> + TypeFoldable<Interner>,
@@ -615,7 +552,7 @@ impl<'db> InferenceTable<'db> {
     fn resolve_with_fallback_inner<T>(
         &mut self,
         t: T,
-        fallback: &dyn Fn(InferenceVar, VariableKind, GenericArg, DebruijnIndex) -> GenericArg,
+        fallback: &dyn Fn(InferenceVar, VariableKind, DebruijnIndex) -> GenericArg,
     ) -> T
     where
         T: HasInterner<Interner = Interner> + TypeFoldable<Interner>,
@@ -632,53 +569,15 @@ impl<'db> InferenceTable<'db> {
         T: HasInterner<Interner = Interner> + TypeFoldable<Interner> + ChalkToNextSolver<'db, U>,
         U: NextSolverToChalk<'db, T> + rustc_type_ir::TypeFoldable<DbInterner<'db>>,
     {
-        let t = self.resolve_with_fallback(t, &|_, _, d, _| d);
-        let t = self.normalize_associated_types_in(t);
-        // let t = self.resolve_opaque_tys_in(t);
-        // Resolve again, because maybe normalization inserted infer vars.
-        self.resolve_with_fallback(t, &|_, _, d, _| d)
-    }
+        let value = t.to_nextsolver(self.interner);
+        let value = self.infer_ctxt.resolve_vars_if_possible(value);
 
-    /// Apply a fallback to unresolved scalar types. Integer type variables and float type
-    /// variables are replaced with i32 and f64, respectively.
-    ///
-    /// This method is only intended to be called just before returning inference results (i.e. in
-    /// `InferenceContext::resolve_all()`).
-    ///
-    /// FIXME: This method currently doesn't apply fallback to unconstrained general type variables
-    /// whereas rustc replaces them with `()` or `!`.
-    pub(super) fn fallback_if_possible(&mut self) {
-        let int_fallback = TyKind::Scalar(Scalar::Int(IntTy::I32)).intern(Interner);
-        let float_fallback = TyKind::Scalar(Scalar::Float(FloatTy::F64)).intern(Interner);
-
-        let int_vars = self.infer_ctxt.inner.borrow_mut().int_unification_table().len();
-        for v in 0..int_vars {
-            let var = InferenceVar::from(v as u32).to_ty(Interner, TyVariableKind::Integer);
-            let maybe_resolved = self.resolve_ty_shallow(&var);
-            if let TyKind::InferenceVar(_, kind) = maybe_resolved.kind(Interner) {
-                // I don't think we can ever unify these vars with float vars, but keep this here for now
-                let fallback = match kind {
-                    TyVariableKind::Integer => &int_fallback,
-                    TyVariableKind::Float => &float_fallback,
-                    TyVariableKind::General => unreachable!(),
-                };
-                self.unify(&var, fallback);
-            }
-        }
-        let float_vars = self.infer_ctxt.inner.borrow_mut().float_unification_table().len();
-        for v in 0..float_vars {
-            let var = InferenceVar::from(v as u32).to_ty(Interner, TyVariableKind::Float);
-            let maybe_resolved = self.resolve_ty_shallow(&var);
-            if let TyKind::InferenceVar(_, kind) = maybe_resolved.kind(Interner) {
-                // I don't think we can ever unify these vars with float vars, but keep this here for now
-                let fallback = match kind {
-                    TyVariableKind::Integer => &int_fallback,
-                    TyVariableKind::Float => &float_fallback,
-                    TyVariableKind::General => unreachable!(),
-                };
-                self.unify(&var, fallback);
-            }
-        }
+        let mut goals = vec![];
+        let value = value.fold_with(&mut resolve_completely::Resolver::new(self, true, &mut goals));
+
+        // FIXME(next-solver): Handle `goals`.
+
+        value.to_chalk(self.interner)
     }
 
     /// Unify two relatable values (e.g. `Ty`) and register new trait goals that arise from that.
@@ -829,15 +728,13 @@ impl<'db> InferenceTable<'db> {
 
     pub(crate) fn snapshot(&mut self) -> InferenceTableSnapshot<'db> {
         let ctxt_snapshot = self.infer_ctxt.start_snapshot();
-        let diverging_tys = self.diverging_tys.clone();
         let obligations = self.fulfillment_cx.clone();
-        InferenceTableSnapshot { ctxt_snapshot, diverging_tys, obligations }
+        InferenceTableSnapshot { ctxt_snapshot, obligations }
     }
 
     #[tracing::instrument(skip_all)]
     pub(crate) fn rollback_to(&mut self, snapshot: InferenceTableSnapshot<'db>) {
         self.infer_ctxt.rollback_to(snapshot.ctxt_snapshot);
-        self.diverging_tys = snapshot.diverging_tys;
         self.fulfillment_cx = snapshot.obligations;
     }
 
@@ -1166,14 +1063,10 @@ impl fmt::Debug for InferenceTable<'_> {
 mod resolve {
     use super::InferenceTable;
     use crate::{
-        ConcreteConst, Const, ConstData, ConstScalar, ConstValue, DebruijnIndex, GenericArg,
-        InferenceVar, Interner, Lifetime, Ty, TyVariableKind, VariableKind,
-        next_solver::mapping::NextSolverToChalk,
-    };
-    use chalk_ir::{
-        cast::Cast,
-        fold::{TypeFoldable, TypeFolder},
+        Const, DebruijnIndex, GenericArg, InferenceVar, Interner, Lifetime, Ty, TyVariableKind,
+        VariableKind, next_solver::mapping::NextSolverToChalk,
     };
+    use chalk_ir::fold::{TypeFoldable, TypeFolder};
     use rustc_type_ir::{FloatVid, IntVid, TyVid};
 
     #[derive(Debug, Copy, Clone, PartialEq, Eq)]
@@ -1187,7 +1080,7 @@ mod resolve {
     pub(super) struct Resolver<
         'a,
         'b,
-        F: Fn(InferenceVar, VariableKind, GenericArg, DebruijnIndex) -> GenericArg,
+        F: Fn(InferenceVar, VariableKind, DebruijnIndex) -> GenericArg,
     > {
         pub(super) table: &'a mut InferenceTable<'b>,
         pub(super) var_stack: &'a mut Vec<(InferenceVar, VarKind)>,
@@ -1195,7 +1088,7 @@ mod resolve {
     }
     impl<F> TypeFolder<Interner> for Resolver<'_, '_, F>
     where
-        F: Fn(InferenceVar, VariableKind, GenericArg, DebruijnIndex) -> GenericArg,
+        F: Fn(InferenceVar, VariableKind, DebruijnIndex) -> GenericArg,
     {
         fn as_dyn(&mut self) -> &mut dyn TypeFolder<Interner> {
             self
@@ -1217,8 +1110,7 @@ mod resolve {
                     let var = InferenceVar::from(vid.as_u32());
                     if self.var_stack.contains(&(var, VarKind::Ty(kind))) {
                         // recursive type
-                        let default = self.table.fallback_value(var, kind).cast(Interner);
-                        return (self.fallback)(var, VariableKind::Ty(kind), default, outer_binder)
+                        return (self.fallback)(var, VariableKind::Ty(kind), outer_binder)
                             .assert_ty_ref(Interner)
                             .clone();
                     }
@@ -1230,8 +1122,7 @@ mod resolve {
                         self.var_stack.pop();
                         result
                     } else {
-                        let default = self.table.fallback_value(var, kind).cast(Interner);
-                        (self.fallback)(var, VariableKind::Ty(kind), default, outer_binder)
+                        (self.fallback)(var, VariableKind::Ty(kind), outer_binder)
                             .assert_ty_ref(Interner)
                             .clone()
                     }
@@ -1247,8 +1138,7 @@ mod resolve {
                     let var = InferenceVar::from(vid.as_u32());
                     if self.var_stack.contains(&(var, VarKind::Ty(kind))) {
                         // recursive type
-                        let default = self.table.fallback_value(var, kind).cast(Interner);
-                        return (self.fallback)(var, VariableKind::Ty(kind), default, outer_binder)
+                        return (self.fallback)(var, VariableKind::Ty(kind), outer_binder)
                             .assert_ty_ref(Interner)
                             .clone();
                     }
@@ -1260,8 +1150,7 @@ mod resolve {
                         self.var_stack.pop();
                         result
                     } else {
-                        let default = self.table.fallback_value(var, kind).cast(Interner);
-                        (self.fallback)(var, VariableKind::Ty(kind), default, outer_binder)
+                        (self.fallback)(var, VariableKind::Ty(kind), outer_binder)
                             .assert_ty_ref(Interner)
                             .clone()
                     }
@@ -1277,8 +1166,7 @@ mod resolve {
                     let var = InferenceVar::from(vid.as_u32());
                     if self.var_stack.contains(&(var, VarKind::Ty(kind))) {
                         // recursive type
-                        let default = self.table.fallback_value(var, kind).cast(Interner);
-                        return (self.fallback)(var, VariableKind::Ty(kind), default, outer_binder)
+                        return (self.fallback)(var, VariableKind::Ty(kind), outer_binder)
                             .assert_ty_ref(Interner)
                             .clone();
                     }
@@ -1290,8 +1178,7 @@ mod resolve {
                         self.var_stack.pop();
                         result
                     } else {
-                        let default = self.table.fallback_value(var, kind).cast(Interner);
-                        (self.fallback)(var, VariableKind::Ty(kind), default, outer_binder)
+                        (self.fallback)(var, VariableKind::Ty(kind), outer_binder)
                             .assert_ty_ref(Interner)
                             .clone()
                     }
@@ -1310,15 +1197,9 @@ mod resolve {
                 .infer_ctxt
                 .root_const_var(rustc_type_ir::ConstVid::from_u32(var.index()));
             let var = InferenceVar::from(vid.as_u32());
-            let default = ConstData {
-                ty: ty.clone(),
-                value: ConstValue::Concrete(ConcreteConst { interned: ConstScalar::Unknown }),
-            }
-            .intern(Interner)
-            .cast(Interner);
             if self.var_stack.contains(&(var, VarKind::Const)) {
                 // recursive
-                return (self.fallback)(var, VariableKind::Const(ty), default, outer_binder)
+                return (self.fallback)(var, VariableKind::Const(ty), outer_binder)
                     .assert_const_ref(Interner)
                     .clone();
             }
@@ -1330,7 +1211,7 @@ mod resolve {
                 self.var_stack.pop();
                 result
             } else {
-                (self.fallback)(var, VariableKind::Const(ty), default, outer_binder)
+                (self.fallback)(var, VariableKind::Const(ty), outer_binder)
                     .assert_const_ref(Interner)
                     .clone()
             }
@@ -1349,3 +1230,124 @@ mod resolve {
         }
     }
 }
+
+mod resolve_completely {
+    use rustc_type_ir::{
+        DebruijnIndex, Flags, TypeFolder, TypeSuperFoldable,
+        inherent::{Const as _, Ty as _},
+    };
+
+    use crate::next_solver::Region;
+    use crate::{
+        infer::unify::InferenceTable,
+        next_solver::{
+            Const, DbInterner, ErrorGuaranteed, Goal, Predicate, Term, Ty,
+            infer::traits::ObligationCause,
+            normalize::deeply_normalize_with_skipped_universes_and_ambiguous_coroutine_goals,
+        },
+    };
+
+    pub(super) struct Resolver<'a, 'db> {
+        ctx: &'a mut InferenceTable<'db>,
+        /// Whether we should normalize, disabled when resolving predicates.
+        should_normalize: bool,
+        nested_goals: &'a mut Vec<Goal<'db, Predicate<'db>>>,
+    }
+
+    impl<'a, 'db> Resolver<'a, 'db> {
+        pub(super) fn new(
+            ctx: &'a mut InferenceTable<'db>,
+            should_normalize: bool,
+            nested_goals: &'a mut Vec<Goal<'db, Predicate<'db>>>,
+        ) -> Resolver<'a, 'db> {
+            Resolver { ctx, nested_goals, should_normalize }
+        }
+
+        fn handle_term<T>(
+            &mut self,
+            value: T,
+            outer_exclusive_binder: impl FnOnce(T) -> DebruijnIndex,
+        ) -> T
+        where
+            T: Into<Term<'db>> + TypeSuperFoldable<DbInterner<'db>> + Copy,
+        {
+            let value = if self.should_normalize {
+                let cause = ObligationCause::new();
+                let at = self.ctx.infer_ctxt.at(&cause, self.ctx.trait_env.env);
+                let universes = vec![None; outer_exclusive_binder(value).as_usize()];
+                match deeply_normalize_with_skipped_universes_and_ambiguous_coroutine_goals(
+                    at, value, universes,
+                ) {
+                    Ok((value, goals)) => {
+                        self.nested_goals.extend(goals);
+                        value
+                    }
+                    Err(_errors) => {
+                        // FIXME: Report the error.
+                        value
+                    }
+                }
+            } else {
+                value
+            };
+
+            value.fold_with(&mut ReplaceInferWithError { interner: self.ctx.interner })
+        }
+    }
+
+    impl<'cx, 'db> TypeFolder<DbInterner<'db>> for Resolver<'cx, 'db> {
+        fn cx(&self) -> DbInterner<'db> {
+            self.ctx.interner
+        }
+
+        fn fold_region(&mut self, r: Region<'db>) -> Region<'db> {
+            if r.is_var() { Region::error(self.ctx.interner) } else { r }
+        }
+
+        fn fold_ty(&mut self, ty: Ty<'db>) -> Ty<'db> {
+            self.handle_term(ty, |it| it.outer_exclusive_binder())
+        }
+
+        fn fold_const(&mut self, ct: Const<'db>) -> Const<'db> {
+            self.handle_term(ct, |it| it.outer_exclusive_binder())
+        }
+
+        fn fold_predicate(&mut self, predicate: Predicate<'db>) -> Predicate<'db> {
+            assert!(
+                !self.should_normalize,
+                "normalizing predicates in writeback is not generally sound"
+            );
+            predicate.super_fold_with(self)
+        }
+    }
+
+    struct ReplaceInferWithError<'db> {
+        interner: DbInterner<'db>,
+    }
+
+    impl<'db> TypeFolder<DbInterner<'db>> for ReplaceInferWithError<'db> {
+        fn cx(&self) -> DbInterner<'db> {
+            self.interner
+        }
+
+        fn fold_ty(&mut self, t: Ty<'db>) -> Ty<'db> {
+            if t.is_infer() {
+                Ty::new_error(self.interner, ErrorGuaranteed)
+            } else {
+                t.super_fold_with(self)
+            }
+        }
+
+        fn fold_const(&mut self, c: Const<'db>) -> Const<'db> {
+            if c.is_ct_infer() {
+                Const::new_error(self.interner, ErrorGuaranteed)
+            } else {
+                c.super_fold_with(self)
+            }
+        }
+
+        fn fold_region(&mut self, r: Region<'db>) -> Region<'db> {
+            if r.is_var() { Region::error(self.interner) } else { r }
+        }
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver.rs
index 073a02908deeb..ab167e88af2ef 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver.rs
@@ -13,7 +13,7 @@ pub(crate) mod inspect;
 pub mod interner;
 mod ir_print;
 pub mod mapping;
-mod normalize;
+pub mod normalize;
 pub mod obligation_ctxt;
 mod opaques;
 pub mod predicate;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/region.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/region.rs
index d6214d991560a..0bfd2b8003d05 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/region.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/region.rs
@@ -15,7 +15,7 @@ use super::{
     interner::{BoundVarKind, DbInterner, Placeholder},
 };
 
-type RegionKind<'db> = rustc_type_ir::RegionKind<DbInterner<'db>>;
+pub type RegionKind<'db> = rustc_type_ir::RegionKind<DbInterner<'db>>;
 
 #[salsa::interned(constructor = new_, debug)]
 pub struct Region<'db> {
@@ -53,6 +53,10 @@ impl<'db> Region<'db> {
         Region::new(interner, RegionKind::ReVar(v))
     }
 
+    pub fn new_erased(interner: DbInterner<'db>) -> Region<'db> {
+        Region::new(interner, RegionKind::ReErased)
+    }
+
     pub fn is_placeholder(&self) -> bool {
         matches!(self.inner(), RegionKind::RePlaceholder(..))
     }
@@ -61,6 +65,10 @@ impl<'db> Region<'db> {
         matches!(self.inner(), RegionKind::ReStatic)
     }
 
+    pub fn is_var(&self) -> bool {
+        matches!(self.inner(), RegionKind::ReVar(_))
+    }
+
     pub fn error(interner: DbInterner<'db>) -> Self {
         Region::new(interner, RegionKind::ReError(ErrorGuaranteed))
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
index c7a747ade3e76..16bf082b01a35 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/ty.rs
@@ -7,6 +7,7 @@ use hir_def::{GenericDefId, TypeOrConstParamId, TypeParamId};
 use intern::{Interned, Symbol, sym};
 use rustc_abi::{Float, Integer, Size};
 use rustc_ast_ir::{Mutability, try_visit, visit::VisitorResult};
+use rustc_type_ir::TyVid;
 use rustc_type_ir::{
     BoundVar, ClosureKind, CollectAndApply, FlagComputation, Flags, FloatTy, FloatVid, InferTy,
     IntTy, IntVid, Interner, TypeFoldable, TypeSuperFoldable, TypeSuperVisitable, TypeVisitable,
@@ -338,6 +339,14 @@ impl<'db> Ty<'db> {
         matches!(self.kind(), TyKind::Tuple(tys) if tys.inner().is_empty())
     }
 
+    #[inline]
+    pub fn ty_vid(self) -> Option<TyVid> {
+        match self.kind() {
+            TyKind::Infer(rustc_type_ir::TyVar(vid)) => Some(vid),
+            _ => None,
+        }
+    }
+
     /// Given a `fn` type, returns an equivalent `unsafe fn` type;
     /// that is, a `fn` type that is equivalent in every way for being
     /// unsafe.
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/never_type.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/never_type.rs
index af5290d720356..4d68179a88b82 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/never_type.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/never_type.rs
@@ -14,8 +14,6 @@ fn test() {
     );
 }
 
-// FIXME(next-solver): The never type fallback implemented in r-a no longer works properly because of
-// `Coerce` predicates. We should reimplement fallback like rustc.
 #[test]
 fn infer_never2() {
     check_types(
@@ -26,7 +24,7 @@ fn test() {
     let a = gen();
     if false { a } else { loop {} };
     a;
-} //^ {unknown}
+} //^ !
 "#,
     );
 }
@@ -41,7 +39,7 @@ fn test() {
     let a = gen();
     if false { loop {} } else { a };
     a;
-  //^ {unknown}
+  //^ !
 }
 "#,
     );
@@ -56,7 +54,7 @@ enum Option<T> { None, Some(T) }
 fn test() {
     let a = if true { Option::None } else { Option::Some(return) };
     a;
-} //^ Option<{unknown}>
+} //^ Option<!>
 "#,
     );
 }
@@ -220,7 +218,7 @@ fn test(a: i32) {
         _ => loop {},
     };
     i;
-} //^ {unknown}
+} //^ !
 "#,
     );
 }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
index a6215ef8fe4fe..00835aa03130c 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression.rs
@@ -1951,7 +1951,7 @@ fn main() {
     Alias::Braced;
   //^^^^^^^^^^^^^ {unknown}
     let Alias::Braced = loop {};
-      //^^^^^^^^^^^^^ {unknown}
+      //^^^^^^^^^^^^^ !
   let Alias::Braced(..) = loop {};
     //^^^^^^^^^^^^^^^^^ Enum
 
diff --git a/src/tools/rust-analyzer/crates/intern/src/symbol/symbols.rs b/src/tools/rust-analyzer/crates/intern/src/symbol/symbols.rs
index 1db4f8ecd6bab..920bdd9568fcf 100644
--- a/src/tools/rust-analyzer/crates/intern/src/symbol/symbols.rs
+++ b/src/tools/rust-analyzer/crates/intern/src/symbol/symbols.rs
@@ -516,4 +516,5 @@ define_symbols! {
     flags,
     precision,
     width,
+    never_type_fallback,
 }

From 60dd0df6e73e195b9779121bac7e2927ddcf48f2 Mon Sep 17 00:00:00 2001
From: Jules Bertholet <julesbertholet@quoi.xyz>
Date: Wed, 24 Sep 2025 13:52:33 -0400
Subject: [PATCH 1354/1889] Address review comments

---
 .../rustc_error_codes/src/error_codes/E0719.md |  2 +-
 .../src/hir_ty_lowering/bounds.rs              |  5 +++--
 .../src/hir_ty_lowering/dyn_trait.rs           |  6 ++++--
 .../src/hir_ty_lowering/mod.rs                 | 18 +++++++++++++++---
 4 files changed, 23 insertions(+), 8 deletions(-)

diff --git a/compiler/rustc_error_codes/src/error_codes/E0719.md b/compiler/rustc_error_codes/src/error_codes/E0719.md
index 17cbd2de49efd..6aec38b42a3b1 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0719.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0719.md
@@ -1,4 +1,4 @@
-An associated item value was specified more than once in a trait object.
+An associated item was specified more than once in a trait object.
 
 Erroneous code example:
 
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
index a8d75ba223ab3..a59520f16feb9 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
@@ -21,7 +21,8 @@ use tracing::{debug, instrument};
 use super::errors::GenericsArgsErrExtend;
 use crate::errors;
 use crate::hir_ty_lowering::{
-    AssocItemQSelf, FeedConstTy, HirTyLowerer, PredicateFilter, RegionInferReason,
+    AssocItemQSelf, FeedConstTy, HirTyLowerer, OverlappingAsssocItemConstraints, PredicateFilter,
+    RegionInferReason,
 };
 
 #[derive(Debug, Default)]
@@ -362,7 +363,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                         param_ty,
                         bounds,
                         predicate_filter,
-                        false,
+                        OverlappingAsssocItemConstraints::Allowed,
                     );
                 }
                 hir::GenericBound::Outlives(lifetime) => {
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_trait.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_trait.rs
index a4179776572d6..c0b1377308923 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_trait.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_trait.rs
@@ -23,7 +23,9 @@ use tracing::{debug, instrument};
 
 use super::HirTyLowerer;
 use crate::errors::SelfInTypeAlias;
-use crate::hir_ty_lowering::{GenericArgCountMismatch, PredicateFilter, RegionInferReason};
+use crate::hir_ty_lowering::{
+    GenericArgCountMismatch, OverlappingAsssocItemConstraints, PredicateFilter, RegionInferReason,
+};
 
 impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
     /// Lower a trait object type from the HIR to our internal notion of a type.
@@ -60,7 +62,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 dummy_self,
                 &mut user_written_bounds,
                 PredicateFilter::SelfOnly,
-                true,
+                OverlappingAsssocItemConstraints::Forbidden,
             );
             if let Err(GenericArgCountMismatch { invalid_args, .. }) = result.correct {
                 potential_assoc_types.extend(invalid_args);
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 0ff1fabd7b303..cc5c0d0ad6ce9 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -332,6 +332,15 @@ pub(crate) enum GenericArgPosition {
     MethodCall,
 }
 
+/// Whether to allow duplicate associated iten constraints in a trait ref, e.g.
+/// `Trait<Assoc = Ty, Assoc = Ty>`. This is forbidden in `dyn Trait<...>`
+/// but allowed everywhere else.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(crate) enum OverlappingAsssocItemConstraints {
+    Allowed,
+    Forbidden,
+}
+
 /// A marker denoting that the generic arguments that were
 /// provided did not match the respective generic parameters.
 #[derive(Clone, Debug)]
@@ -752,7 +761,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         self_ty: Ty<'tcx>,
         bounds: &mut Vec<(ty::Clause<'tcx>, Span)>,
         predicate_filter: PredicateFilter,
-        for_dyn: bool,
+        overlapping_assoc_item_constraints: OverlappingAsssocItemConstraints,
     ) -> GenericArgCountResult {
         let tcx = self.tcx();
 
@@ -909,7 +918,10 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             }
         }
 
-        let mut dup_constraints = FxIndexMap::default();
+        let mut dup_constraints = (overlapping_assoc_item_constraints
+            == OverlappingAsssocItemConstraints::Forbidden)
+            .then_some(FxIndexMap::default());
+
         for constraint in trait_segment.args().constraints {
             // Don't register any associated item constraints for negative bounds,
             // since we should have emitted an error for them earlier, and they
@@ -928,7 +940,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 poly_trait_ref,
                 constraint,
                 bounds,
-                for_dyn.then_some(&mut dup_constraints),
+                dup_constraints.as_mut(),
                 constraint.span,
                 predicate_filter,
             );

From a86f14072714fb817a6f60fa20be5a4e875d049f Mon Sep 17 00:00:00 2001
From: Ding Xiang Fei <dingxiangfei2009@protonmail.ch>
Date: Tue, 12 Aug 2025 06:39:50 +0800
Subject: [PATCH 1355/1889] do not materialise X in [X; 0] when X is unsizing a
 const

---
 .../src/builder/expr/as_rvalue.rs             | 21 ++++++++++++-
 ...no_local_for_coerced_const-issue-143671.rs | 30 +++++++++++++++++++
 2 files changed, 50 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/coercion/no_local_for_coerced_const-issue-143671.rs

diff --git a/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs b/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs
index a4ef6e9273921..d6dc12e5955a5 100644
--- a/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs
+++ b/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs
@@ -8,6 +8,7 @@ use rustc_middle::middle::region;
 use rustc_middle::mir::interpret::Scalar;
 use rustc_middle::mir::*;
 use rustc_middle::thir::*;
+use rustc_middle::ty::adjustment::PointerCoercion;
 use rustc_middle::ty::cast::{CastTy, mir_cast_kind};
 use rustc_middle::ty::util::IntTypeExt;
 use rustc_middle::ty::{self, Ty, UpvarArgs};
@@ -656,6 +657,24 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         block.and(rvalue)
     }
 
+    /// Recursively inspect a THIR expression and probe through unsizing
+    /// operations that can be const-folded today.
+    fn check_constness(&self, mut kind: &'a ExprKind<'tcx>) -> bool {
+        loop {
+            match kind {
+                &ExprKind::PointerCoercion {
+                    cast: PointerCoercion::Unsize,
+                    source: eid,
+                    is_from_as_cast: _,
+                }
+                | &ExprKind::Scope { region_scope: _, lint_level: _, value: eid } => {
+                    kind = &self.thir[eid].kind
+                }
+                _ => return matches!(Category::of(&kind), Some(Category::Constant)),
+            }
+        }
+    }
+
     fn build_zero_repeat(
         &mut self,
         mut block: BasicBlock,
@@ -666,7 +685,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         let this = self;
         let value_expr = &this.thir[value];
         let elem_ty = value_expr.ty;
-        if let Some(Category::Constant) = Category::of(&value_expr.kind) {
+        if this.check_constness(&value_expr.kind) {
             // Repeating a const does nothing
         } else {
             // For a non-const, we may need to generate an appropriate `Drop`
diff --git a/tests/ui/coercion/no_local_for_coerced_const-issue-143671.rs b/tests/ui/coercion/no_local_for_coerced_const-issue-143671.rs
new file mode 100644
index 0000000000000..eb814e9723c1c
--- /dev/null
+++ b/tests/ui/coercion/no_local_for_coerced_const-issue-143671.rs
@@ -0,0 +1,30 @@
+//@ run-pass
+
+#![feature(unsize)]
+#![feature(coerce_unsized)]
+
+use std::fmt::Display;
+use std::marker::Unsize;
+use std::ops::CoerceUnsized;
+
+#[repr(transparent)]
+struct X<'a, T: ?Sized> {
+    f: &'a T,
+}
+
+impl<'a, T: ?Sized> Drop for X<'a, T> {
+    fn drop(&mut self) {
+        panic!()
+    }
+}
+
+impl<'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<X<'a, U>> for X<'a, T> where
+    &'a T: CoerceUnsized<&'a U>
+{
+}
+
+const Y: X<'static, i32> = X { f: &0 };
+
+fn main() {
+    let _: [X<'static, dyn Display>; 0] = [Y; 0];
+}

From 120162e30ffa92308a6a3a76f2328467fbd10ced Mon Sep 17 00:00:00 2001
From: Ding Xiang Fei <dingxiangfei2009@protonmail.ch>
Date: Wed, 13 Aug 2025 02:26:04 +0800
Subject: [PATCH 1356/1889] add test fixture for newly allowed const expr

Signed-off-by: Ding Xiang Fei <dingxiangfei2009@protonmail.ch>
Co-authored-by: Theemathas Chirananthavat <theemathas@gmail.com>
---
 .../coercion/no_local_for_coerced_const-issue-143671.rs   | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/tests/ui/coercion/no_local_for_coerced_const-issue-143671.rs b/tests/ui/coercion/no_local_for_coerced_const-issue-143671.rs
index eb814e9723c1c..5924809f34c85 100644
--- a/tests/ui/coercion/no_local_for_coerced_const-issue-143671.rs
+++ b/tests/ui/coercion/no_local_for_coerced_const-issue-143671.rs
@@ -6,6 +6,7 @@
 use std::fmt::Display;
 use std::marker::Unsize;
 use std::ops::CoerceUnsized;
+use std::rc::Weak;
 
 #[repr(transparent)]
 struct X<'a, T: ?Sized> {
@@ -27,4 +28,11 @@ const Y: X<'static, i32> = X { f: &0 };
 
 fn main() {
     let _: [X<'static, dyn Display>; 0] = [Y; 0];
+    coercion_on_weak_in_const();
+}
+
+fn coercion_on_weak_in_const() {
+    const X: Weak<i32> = Weak::new();
+    const Y: [Weak<dyn Send>; 0] = [X; 0];
+    let _ = Y;
 }

From b77de834c031890c048f8164d4b5979d2511c00e Mon Sep 17 00:00:00 2001
From: Ding Xiang Fei <dingxiangfei2009@protonmail.ch>
Date: Thu, 25 Sep 2025 01:53:34 +0800
Subject: [PATCH 1357/1889] mark THIR use as candidate for constness check

---
 compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs    | 5 ++++-
 .../coercion/no_local_for_coerced_const-issue-143671.rs   | 8 ++++++++
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs b/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs
index d6dc12e5955a5..3a5839f2d404d 100644
--- a/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs
+++ b/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs
@@ -661,8 +661,11 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     /// operations that can be const-folded today.
     fn check_constness(&self, mut kind: &'a ExprKind<'tcx>) -> bool {
         loop {
+            debug!(?kind, "check_constness");
             match kind {
-                &ExprKind::PointerCoercion {
+                &ExprKind::ValueTypeAscription { source: eid, user_ty: _, user_ty_span: _ }
+                | &ExprKind::Use { source: eid }
+                | &ExprKind::PointerCoercion {
                     cast: PointerCoercion::Unsize,
                     source: eid,
                     is_from_as_cast: _,
diff --git a/tests/ui/coercion/no_local_for_coerced_const-issue-143671.rs b/tests/ui/coercion/no_local_for_coerced_const-issue-143671.rs
index 5924809f34c85..38479d9070b8d 100644
--- a/tests/ui/coercion/no_local_for_coerced_const-issue-143671.rs
+++ b/tests/ui/coercion/no_local_for_coerced_const-issue-143671.rs
@@ -29,6 +29,7 @@ const Y: X<'static, i32> = X { f: &0 };
 fn main() {
     let _: [X<'static, dyn Display>; 0] = [Y; 0];
     coercion_on_weak_in_const();
+    coercion_on_weak_as_cast();
 }
 
 fn coercion_on_weak_in_const() {
@@ -36,3 +37,10 @@ fn coercion_on_weak_in_const() {
     const Y: [Weak<dyn Send>; 0] = [X; 0];
     let _ = Y;
 }
+
+fn coercion_on_weak_as_cast() {
+    const Y: X<'static, i32> = X { f: &0 };
+    // What happens in the following code is that
+    // a constant is explicitly coerced into
+    let _a: [X<'static, dyn Display>; 0] = [Y as X<'static, dyn Display>; 0];
+}

From 5bec161ce12501695356492129ea8fc952a30f85 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Wed, 24 Sep 2025 10:34:52 -0700
Subject: [PATCH 1358/1889] rustdoc-search: stringdex update with more packing

Before:

    18M  build/x86_64-unknown-linux-gnu/doc/search.index/
    57M  build/x86_64-unknown-linux-gnu/compiler-doc/search.index/

After:

    16M  build/x86_64-unknown-linux-gnu/doc/search.index/
    49M  build/x86_64-unknown-linux-gnu/compiler-doc/search.index/
---
 Cargo.lock                                 |  4 +-
 src/librustdoc/Cargo.toml                  |  2 +-
 src/librustdoc/html/static/js/stringdex.js | 78 ++++++++++++++--------
 3 files changed, 54 insertions(+), 30 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index c2e635b4cfe65..7c2eb559b21e8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5233,9 +5233,9 @@ dependencies = [
 
 [[package]]
 name = "stringdex"
-version = "0.0.1-alpha9"
+version = "0.0.1-alpha10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7081029913fd7d591c0112182aba8c98ae886b4f12edb208130496cd17dc3c15"
+checksum = "0fa846a7d509d1828a4f90962dc09810e161abcada7fc6a921e92c168d0811d7"
 dependencies = [
  "stacker",
 ]
diff --git a/src/librustdoc/Cargo.toml b/src/librustdoc/Cargo.toml
index f37a8d85361f2..0d77fe64e30f8 100644
--- a/src/librustdoc/Cargo.toml
+++ b/src/librustdoc/Cargo.toml
@@ -21,7 +21,7 @@ rustdoc-json-types = { path = "../rustdoc-json-types" }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 smallvec = "1.8.1"
-stringdex = { version = "0.0.1-alpha9" }
+stringdex = { version = "0.0.1-alpha10" }
 tempfile = "3"
 threadpool = "1.8.1"
 tracing = "0.1"
diff --git a/src/librustdoc/html/static/js/stringdex.js b/src/librustdoc/html/static/js/stringdex.js
index 5bdc81e330efa..6299576d56439 100644
--- a/src/librustdoc/html/static/js/stringdex.js
+++ b/src/librustdoc/html/static/js/stringdex.js
@@ -1108,22 +1108,39 @@ function loadDatabase(hooks) {
                     const id2 = id1 + ((nodeid[4] << 8) | nodeid[5]);
                     leaves = RoaringBitmap.makeSingleton(id1)
                         .union(RoaringBitmap.makeSingleton(id2));
+                } else if (!isWhole && (nodeid[0] & 0xf0) === 0x80) {
+                    const id1 = ((nodeid[0] & 0x0f) << 16) | (nodeid[1] << 8) | nodeid[2];
+                    const id2 = id1 + ((nodeid[3] << 4) | ((nodeid[4] >> 4) & 0x0f));
+                    const id3 = id2 + (((nodeid[4] & 0x0f) << 8) | nodeid[5]);
+                    leaves = RoaringBitmap.makeSingleton(id1)
+                        .union(RoaringBitmap.makeSingleton(id2))
+                        .union(RoaringBitmap.makeSingleton(id3));
                 } else {
                     leaves = RoaringBitmap.makeSingleton(
                         (nodeid[2] << 24) | (nodeid[3] << 16) |
                         (nodeid[4] << 8) | nodeid[5],
                     );
                 }
-                const data = (nodeid[0] & 0x20) !== 0 ?
-                    Uint8Array.of(((nodeid[0] & 0x0f) << 4) | (nodeid[1] >> 4)) :
-                    EMPTY_UINT8;
-                newPromise = Promise.resolve(new PrefixSearchTree(
-                    EMPTY_SEARCH_TREE_BRANCHES,
-                    EMPTY_SEARCH_TREE_BRANCHES,
-                    data,
-                    isWhole ? leaves : EMPTY_BITMAP,
-                    isWhole ? EMPTY_BITMAP : leaves,
-                ));
+                if (isWhole) {
+                    const data = (nodeid[0] & 0x20) !== 0 ?
+                        Uint8Array.of(((nodeid[0] & 0x0f) << 4) | (nodeid[1] >> 4)) :
+                        EMPTY_UINT8;
+                    newPromise = Promise.resolve(new PrefixSearchTree(
+                        EMPTY_SEARCH_TREE_BRANCHES,
+                        EMPTY_SEARCH_TREE_BRANCHES,
+                        data,
+                        leaves,
+                        EMPTY_BITMAP,
+                    ));
+                } else {
+                    const data = (nodeid[0] & 0xf0) === 0x80 ? 0 : (
+                        ((nodeid[0] & 0x0f) << 4) | (nodeid[1] >> 4));
+                    newPromise = Promise.resolve(new SuffixSearchTree(
+                        EMPTY_SEARCH_TREE_BRANCHES,
+                        data,
+                        leaves,
+                    ));
+                }
             } else {
                 const hashHex = makeHexFromUint8Array(nodeid);
                 newPromise = new Promise((resolve, reject) => {
@@ -2748,6 +2765,7 @@ function loadDatabase(hooks) {
             // because that's the canonical, hashed version of the data
             let compression_tag = input[i];
             const is_pure_suffixes_only_node = (compression_tag & 0x01) !== 0;
+            let no_leaves_flag;
             if (compression_tag > 1) {
                 // compressed node
                 const is_long_compressed = (compression_tag & 0x04) !== 0;
@@ -2759,7 +2777,8 @@ function loadDatabase(hooks) {
                     compression_tag |= input[i] << 16;
                     i += 1;
                 }
-                let dlen = input[i];
+                let dlen = input[i] & 0x7F;
+                no_leaves_flag = input[i] & 0x80;
                 i += 1;
                 if (is_data_compressed) {
                     data = data_history[data_history.length - dlen - 1];
@@ -2786,10 +2805,15 @@ function loadDatabase(hooks) {
                 let whole;
                 let suffix;
                 if (is_pure_suffixes_only_node) {
-                    suffix = input[i] === 0 ?
-                        EMPTY_BITMAP1 :
-                        new RoaringBitmap(input, i);
-                    i += suffix.consumed_len_bytes;
+                    if (no_leaves_flag) {
+                        whole = EMPTY_BITMAP;
+                        suffix = EMPTY_BITMAP;
+                    } else {
+                        suffix = input[i] === 0 ?
+                            EMPTY_BITMAP1 :
+                            new RoaringBitmap(input, i);
+                        i += suffix.consumed_len_bytes;
+                    }
                     tree = new SuffixSearchTree(
                         branches,
                         dlen,
@@ -2807,7 +2831,7 @@ function loadDatabase(hooks) {
                     let ci = 0;
                     canonical[ci] = 1;
                     ci += 1;
-                    canonical[ci] = dlen;
+                    canonical[ci] = dlen | no_leaves_flag;
                     ci += 1;
                     canonical[ci] = input[coffset]; // suffix child count
                     ci += 1;
@@ -2821,10 +2845,9 @@ function loadDatabase(hooks) {
                     }
                     siphashOfBytes(canonical.subarray(0, clen), 0, 0, 0, 0, hash);
                 } else {
-                    if (input[i] === 0xff) {
+                    if (no_leaves_flag) {
                         whole = EMPTY_BITMAP;
-                        suffix = EMPTY_BITMAP1;
-                        i += 1;
+                        suffix = EMPTY_BITMAP;
                     } else {
                         whole = input[i] === 0 ?
                             EMPTY_BITMAP1 :
@@ -2856,7 +2879,7 @@ function loadDatabase(hooks) {
                     let ci = 0;
                     canonical[ci] = 0;
                     ci += 1;
-                    canonical[ci] = dlen;
+                    canonical[ci] = dlen | no_leaves_flag;
                     ci += 1;
                     canonical.set(data, ci);
                     ci += data.length;
@@ -2880,9 +2903,11 @@ function loadDatabase(hooks) {
                 }
                 hash[2] &= 0x7f;
             } else {
+                i += 1;
                 // uncompressed node
-                const dlen = input [i + 1];
-                i += 2;
+                const dlen = input[i] & 0x7F;
+                no_leaves_flag = input[i] & 0x80;
+                i += 1;
                 if (dlen === 0 || is_pure_suffixes_only_node) {
                     data = EMPTY_UINT8;
                 } else {
@@ -2897,16 +2922,15 @@ function loadDatabase(hooks) {
                 i += branches_consumed_len_bytes;
                 let whole;
                 let suffix;
-                if (is_pure_suffixes_only_node) {
+                if (no_leaves_flag) {
+                    whole = EMPTY_BITMAP;
+                    suffix = EMPTY_BITMAP;
+                } else if (is_pure_suffixes_only_node) {
                     whole = EMPTY_BITMAP;
                     suffix = input[i] === 0 ?
                         EMPTY_BITMAP1 :
                         new RoaringBitmap(input, i);
                     i += suffix.consumed_len_bytes;
-                } else if (input[i] === 0xff) {
-                    whole = EMPTY_BITMAP;
-                    suffix = EMPTY_BITMAP;
-                    i += 1;
                 } else {
                     whole = input[i] === 0 ?
                         EMPTY_BITMAP1 :

From d63a7ccc7cd9eab72a0ddca84625589d6ba0aec8 Mon Sep 17 00:00:00 2001
From: alexey semenyuk <alexsemenyuk88@gmail.com>
Date: Wed, 24 Sep 2025 23:41:07 +0500
Subject: [PATCH 1359/1889] Update actions/github-script to v8

---
 .github/workflows/lintcheck_summary.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/lintcheck_summary.yml b/.github/workflows/lintcheck_summary.yml
index 183258a964379..6768cd65701ac 100644
--- a/.github/workflows/lintcheck_summary.yml
+++ b/.github/workflows/lintcheck_summary.yml
@@ -35,7 +35,7 @@ jobs:
           github-token: ${{ github.token }}
 
       - name: Format comment
-        uses: actions/github-script@v7
+        uses: actions/github-script@v8
         with:
           script: |
             const fs = require("fs");

From a9554b4d5f2666b0bce66dfb8f70a41092c9265f Mon Sep 17 00:00:00 2001
From: Stepan Koltsov <stepan.koltsov@gmail.com>
Date: Wed, 24 Sep 2025 20:02:34 +0100
Subject: [PATCH 1360/1889] Clarify Display for error should not include source

---
 library/core/src/error.rs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/library/core/src/error.rs b/library/core/src/error.rs
index 92b3c83d1bf34..9ca91ee009ee9 100644
--- a/library/core/src/error.rs
+++ b/library/core/src/error.rs
@@ -16,13 +16,19 @@ use crate::fmt::{self, Debug, Display, Formatter};
 /// assert_eq!(err.to_string(), "invalid digit found in string");
 /// ```
 ///
+/// # Error source
+///
 /// Errors may provide cause information. [`Error::source()`] is generally
 /// used when errors cross "abstraction boundaries". If one module must report
 /// an error that is caused by an error from a lower-level module, it can allow
-/// accessing that error via [`Error::source()`]. This makes it possible for the
+/// accessing that error via `Error::source()`. This makes it possible for the
 /// high-level module to provide its own errors while also revealing some of the
 /// implementation for debugging.
 ///
+/// In error types that wrap an underlying error, the underlying error
+/// should be either returned by the outer error's `Error::source()`, or rendered
+/// by the outer error's `Display` implementation, but not both.
+///
 /// # Example
 ///
 /// Implementing the `Error` trait only requires that `Debug` and `Display` are implemented too.

From a00f24116e9bcecc8c73f9f7ec0c399964b37a92 Mon Sep 17 00:00:00 2001
From: Jeremy Smart <jeremy3141592@gmail.com>
Date: Thu, 18 Sep 2025 15:02:49 -0400
Subject: [PATCH 1361/1889] unstably constify float mul_add methods

Co-authored-by: Ralf Jung <post@ralfj.de>
---
 .../src/interpret/intrinsics.rs               | 46 +++++++++++++++++++
 .../rustc_const_eval/src/interpret/machine.rs |  8 ++++
 library/core/src/intrinsics/mod.rs            | 16 +++----
 library/core/src/num/f128.rs                  |  3 +-
 library/core/src/num/f16.rs                   |  3 +-
 library/core/src/num/f32.rs                   |  3 +-
 library/core/src/num/f64.rs                   |  3 +-
 library/coretests/tests/floats/f128.rs        | 18 --------
 library/coretests/tests/floats/f16.rs         | 18 --------
 library/coretests/tests/floats/f32.rs         | 21 ---------
 library/coretests/tests/floats/f64.rs         | 21 ---------
 library/coretests/tests/floats/mod.rs         | 39 +++++++++++++++-
 library/coretests/tests/lib.rs                |  1 +
 library/std/src/lib.rs                        |  1 +
 library/std/src/num/f32.rs                    |  3 +-
 library/std/src/num/f64.rs                    |  3 +-
 src/tools/miri/src/intrinsics/math.rs         | 41 -----------------
 src/tools/miri/src/machine.rs                 |  5 ++
 18 files changed, 118 insertions(+), 135 deletions(-)
 delete mode 100644 library/coretests/tests/floats/f32.rs
 delete mode 100644 library/coretests/tests/floats/f64.rs

diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
index 418dd658121db..785978b4d7111 100644
--- a/compiler/rustc_const_eval/src/interpret/intrinsics.rs
+++ b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -636,6 +636,14 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 dest,
                 rustc_apfloat::Round::NearestTiesToEven,
             )?,
+            sym::fmaf16 => self.fma_intrinsic::<Half>(args, dest)?,
+            sym::fmaf32 => self.fma_intrinsic::<Single>(args, dest)?,
+            sym::fmaf64 => self.fma_intrinsic::<Double>(args, dest)?,
+            sym::fmaf128 => self.fma_intrinsic::<Quad>(args, dest)?,
+            sym::fmuladdf16 => self.float_muladd_intrinsic::<Half>(args, dest)?,
+            sym::fmuladdf32 => self.float_muladd_intrinsic::<Single>(args, dest)?,
+            sym::fmuladdf64 => self.float_muladd_intrinsic::<Double>(args, dest)?,
+            sym::fmuladdf128 => self.float_muladd_intrinsic::<Quad>(args, dest)?,
 
             // Unsupported intrinsic: skip the return_to_block below.
             _ => return interp_ok(false),
@@ -1035,4 +1043,42 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         self.write_scalar(res, dest)?;
         interp_ok(())
     }
+
+    fn fma_intrinsic<F>(
+        &mut self,
+        args: &[OpTy<'tcx, M::Provenance>],
+        dest: &PlaceTy<'tcx, M::Provenance>,
+    ) -> InterpResult<'tcx, ()>
+    where
+        F: rustc_apfloat::Float + rustc_apfloat::FloatConvert<F> + Into<Scalar<M::Provenance>>,
+    {
+        let a: F = self.read_scalar(&args[0])?.to_float()?;
+        let b: F = self.read_scalar(&args[1])?.to_float()?;
+        let c: F = self.read_scalar(&args[2])?.to_float()?;
+
+        let res = a.mul_add(b, c).value;
+        let res = self.adjust_nan(res, &[a, b, c]);
+        self.write_scalar(res, dest)?;
+        interp_ok(())
+    }
+
+    fn float_muladd_intrinsic<F>(
+        &mut self,
+        args: &[OpTy<'tcx, M::Provenance>],
+        dest: &PlaceTy<'tcx, M::Provenance>,
+    ) -> InterpResult<'tcx, ()>
+    where
+        F: rustc_apfloat::Float + rustc_apfloat::FloatConvert<F> + Into<Scalar<M::Provenance>>,
+    {
+        let a: F = self.read_scalar(&args[0])?.to_float()?;
+        let b: F = self.read_scalar(&args[1])?.to_float()?;
+        let c: F = self.read_scalar(&args[2])?.to_float()?;
+
+        let fuse = M::float_fuse_mul_add(self);
+
+        let res = if fuse { a.mul_add(b, c).value } else { ((a * b).value + c).value };
+        let res = self.adjust_nan(res, &[a, b, c]);
+        self.write_scalar(res, dest)?;
+        interp_ok(())
+    }
 }
diff --git a/compiler/rustc_const_eval/src/interpret/machine.rs b/compiler/rustc_const_eval/src/interpret/machine.rs
index e22629993fba7..1725635e0b479 100644
--- a/compiler/rustc_const_eval/src/interpret/machine.rs
+++ b/compiler/rustc_const_eval/src/interpret/machine.rs
@@ -289,6 +289,9 @@ pub trait Machine<'tcx>: Sized {
         a
     }
 
+    /// Determines whether the `fmuladd` intrinsics fuse the multiply-add or use separate operations.
+    fn float_fuse_mul_add(_ecx: &mut InterpCx<'tcx, Self>) -> bool;
+
     /// Called before a basic block terminator is executed.
     #[inline]
     fn before_terminator(_ecx: &mut InterpCx<'tcx, Self>) -> InterpResult<'tcx> {
@@ -672,6 +675,11 @@ pub macro compile_time_machine(<$tcx: lifetime>) {
         match fn_val {}
     }
 
+    #[inline(always)]
+    fn float_fuse_mul_add(_ecx: &mut InterpCx<$tcx, Self>) -> bool {
+        true
+    }
+
     #[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
diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs
index a174ced5a2a63..98eec7303da6c 100644
--- a/library/core/src/intrinsics/mod.rs
+++ b/library/core/src/intrinsics/mod.rs
@@ -1312,28 +1312,28 @@ pub fn log2f128(x: f128) -> f128;
 /// [`f16::mul_add`](../../std/primitive.f16.html#method.mul_add)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn fmaf16(a: f16, b: f16, c: f16) -> f16;
+pub const fn fmaf16(a: f16, b: f16, c: f16) -> f16;
 /// Returns `a * b + c` for `f32` values.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::mul_add`](../../std/primitive.f32.html#method.mul_add)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn fmaf32(a: f32, b: f32, c: f32) -> f32;
+pub const fn fmaf32(a: f32, b: f32, c: f32) -> f32;
 /// Returns `a * b + c` for `f64` values.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::mul_add`](../../std/primitive.f64.html#method.mul_add)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn fmaf64(a: f64, b: f64, c: f64) -> f64;
+pub const fn fmaf64(a: f64, b: f64, c: f64) -> f64;
 /// Returns `a * b + c` for `f128` values.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::mul_add`](../../std/primitive.f128.html#method.mul_add)
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn fmaf128(a: f128, b: f128, c: f128) -> f128;
+pub const fn fmaf128(a: f128, b: f128, c: f128) -> f128;
 
 /// Returns `a * b + c` for `f16` values, non-deterministically executing
 /// either a fused multiply-add or two operations with rounding of the
@@ -1347,7 +1347,7 @@ pub fn fmaf128(a: f128, b: f128, c: f128) -> f128;
 /// example.
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn fmuladdf16(a: f16, b: f16, c: f16) -> f16;
+pub const fn fmuladdf16(a: f16, b: f16, c: f16) -> f16;
 /// Returns `a * b + c` for `f32` values, non-deterministically executing
 /// either a fused multiply-add or two operations with rounding of the
 /// intermediate result.
@@ -1360,7 +1360,7 @@ pub fn fmuladdf16(a: f16, b: f16, c: f16) -> f16;
 /// example.
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn fmuladdf32(a: f32, b: f32, c: f32) -> f32;
+pub const fn fmuladdf32(a: f32, b: f32, c: f32) -> f32;
 /// Returns `a * b + c` for `f64` values, non-deterministically executing
 /// either a fused multiply-add or two operations with rounding of the
 /// intermediate result.
@@ -1373,7 +1373,7 @@ pub fn fmuladdf32(a: f32, b: f32, c: f32) -> f32;
 /// example.
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn fmuladdf64(a: f64, b: f64, c: f64) -> f64;
+pub const fn fmuladdf64(a: f64, b: f64, c: f64) -> f64;
 /// Returns `a * b + c` for `f128` values, non-deterministically executing
 /// either a fused multiply-add or two operations with rounding of the
 /// intermediate result.
@@ -1386,7 +1386,7 @@ pub fn fmuladdf64(a: f64, b: f64, c: f64) -> f64;
 /// example.
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn fmuladdf128(a: f128, b: f128, c: f128) -> f128;
+pub const fn fmuladdf128(a: f128, b: f128, c: f128) -> f128;
 
 /// Returns the largest integer less than or equal to an `f16`.
 ///
diff --git a/library/core/src/num/f128.rs b/library/core/src/num/f128.rs
index 6088fb6fa1786..7653db0bf7db4 100644
--- a/library/core/src/num/f128.rs
+++ b/library/core/src/num/f128.rs
@@ -1659,7 +1659,8 @@ impl f128 {
     #[doc(alias = "fmaf128", alias = "fusedMultiplyAdd")]
     #[unstable(feature = "f128", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
-    pub fn mul_add(self, a: f128, b: f128) -> f128 {
+    #[rustc_const_unstable(feature = "const_mul_add", issue = "146724")]
+    pub const fn mul_add(self, a: f128, b: f128) -> f128 {
         intrinsics::fmaf128(self, a, b)
     }
 
diff --git a/library/core/src/num/f16.rs b/library/core/src/num/f16.rs
index 3f66c5973d4ac..58b4dfb4bdf84 100644
--- a/library/core/src/num/f16.rs
+++ b/library/core/src/num/f16.rs
@@ -1634,7 +1634,8 @@ impl f16 {
     #[unstable(feature = "f16", issue = "116909")]
     #[doc(alias = "fmaf16", alias = "fusedMultiplyAdd")]
     #[must_use = "method returns a new number and does not mutate the original value"]
-    pub fn mul_add(self, a: f16, b: f16) -> f16 {
+    #[rustc_const_unstable(feature = "const_mul_add", issue = "146724")]
+    pub const fn mul_add(self, a: f16, b: f16) -> f16 {
         intrinsics::fmaf16(self, a, b)
     }
 
diff --git a/library/core/src/num/f32.rs b/library/core/src/num/f32.rs
index ebce89e5b3da5..6ff7d24726b55 100644
--- a/library/core/src/num/f32.rs
+++ b/library/core/src/num/f32.rs
@@ -1799,7 +1799,8 @@ pub mod math {
     #[doc(alias = "fmaf", alias = "fusedMultiplyAdd")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     #[unstable(feature = "core_float_math", issue = "137578")]
-    pub fn mul_add(x: f32, y: f32, z: f32) -> f32 {
+    #[rustc_const_unstable(feature = "const_mul_add", issue = "146724")]
+    pub const fn mul_add(x: f32, y: f32, z: f32) -> f32 {
         intrinsics::fmaf32(x, y, z)
     }
 
diff --git a/library/core/src/num/f64.rs b/library/core/src/num/f64.rs
index 91e3949fc3900..f8529a5469bc8 100644
--- a/library/core/src/num/f64.rs
+++ b/library/core/src/num/f64.rs
@@ -1797,7 +1797,8 @@ pub mod math {
     #[doc(alias = "fma", alias = "fusedMultiplyAdd")]
     #[unstable(feature = "core_float_math", issue = "137578")]
     #[must_use = "method returns a new number and does not mutate the original value"]
-    pub fn mul_add(x: f64, a: f64, b: f64) -> f64 {
+    #[rustc_const_unstable(feature = "const_mul_add", issue = "146724")]
+    pub const fn mul_add(x: f64, a: f64, b: f64) -> f64 {
         intrinsics::fmaf64(x, a, b)
     }
 
diff --git a/library/coretests/tests/floats/f128.rs b/library/coretests/tests/floats/f128.rs
index d31eba863f5fe..62278bf96c3c1 100644
--- a/library/coretests/tests/floats/f128.rs
+++ b/library/coretests/tests/floats/f128.rs
@@ -20,24 +20,6 @@ const TOL_PRECISE: f128 = 1e-28;
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
-#[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f128_math)]
-fn test_mul_add() {
-    let nan: f128 = f128::NAN;
-    let inf: f128 = f128::INFINITY;
-    let neg_inf: f128 = f128::NEG_INFINITY;
-    assert_biteq!(12.3f128.mul_add(4.5, 6.7), 62.0500000000000000000000000000000037);
-    assert_biteq!((-12.3f128).mul_add(-4.5, -6.7), 48.6500000000000000000000000000000049);
-    assert_biteq!(0.0f128.mul_add(8.9, 1.2), 1.2);
-    assert_biteq!(3.4f128.mul_add(-0.0, 5.6), 5.6);
-    assert!(nan.mul_add(7.8, 9.0).is_nan());
-    assert_biteq!(inf.mul_add(7.8, 9.0), inf);
-    assert_biteq!(neg_inf.mul_add(7.8, 9.0), neg_inf);
-    assert_biteq!(8.9f128.mul_add(inf, 3.2), inf);
-    assert_biteq!((-3.2f128).mul_add(2.4, neg_inf), neg_inf);
-}
-
 #[test]
 #[cfg(any(miri, target_has_reliable_f128_math))]
 fn test_max_recip() {
diff --git a/library/coretests/tests/floats/f16.rs b/library/coretests/tests/floats/f16.rs
index 302fd0861d75d..7ffafd467a519 100644
--- a/library/coretests/tests/floats/f16.rs
+++ b/library/coretests/tests/floats/f16.rs
@@ -22,24 +22,6 @@ const TOL_P4: f16 = 10.0;
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
-#[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f16_math)]
-fn test_mul_add() {
-    let nan: f16 = f16::NAN;
-    let inf: f16 = f16::INFINITY;
-    let neg_inf: f16 = f16::NEG_INFINITY;
-    assert_biteq!(12.3f16.mul_add(4.5, 6.7), 62.031);
-    assert_biteq!((-12.3f16).mul_add(-4.5, -6.7), 48.625);
-    assert_biteq!(0.0f16.mul_add(8.9, 1.2), 1.2);
-    assert_biteq!(3.4f16.mul_add(-0.0, 5.6), 5.6);
-    assert!(nan.mul_add(7.8, 9.0).is_nan());
-    assert_biteq!(inf.mul_add(7.8, 9.0), inf);
-    assert_biteq!(neg_inf.mul_add(7.8, 9.0), neg_inf);
-    assert_biteq!(8.9f16.mul_add(inf, 3.2), inf);
-    assert_biteq!((-3.2f16).mul_add(2.4, neg_inf), neg_inf);
-}
-
 #[test]
 #[cfg(any(miri, target_has_reliable_f16_math))]
 fn test_max_recip() {
diff --git a/library/coretests/tests/floats/f32.rs b/library/coretests/tests/floats/f32.rs
deleted file mode 100644
index a1fe8b076501d..0000000000000
--- a/library/coretests/tests/floats/f32.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-use core::f32;
-
-use super::assert_biteq;
-
-// FIXME(#140515): mingw has an incorrect fma https://sourceforge.net/p/mingw-w64/bugs/848/
-#[cfg_attr(all(target_os = "windows", target_env = "gnu", not(target_abi = "llvm")), ignore)]
-#[test]
-fn test_mul_add() {
-    let nan: f32 = f32::NAN;
-    let inf: f32 = f32::INFINITY;
-    let neg_inf: f32 = f32::NEG_INFINITY;
-    assert_biteq!(f32::math::mul_add(12.3f32, 4.5, 6.7), 62.05);
-    assert_biteq!(f32::math::mul_add(-12.3f32, -4.5, -6.7), 48.65);
-    assert_biteq!(f32::math::mul_add(0.0f32, 8.9, 1.2), 1.2);
-    assert_biteq!(f32::math::mul_add(3.4f32, -0.0, 5.6), 5.6);
-    assert!(f32::math::mul_add(nan, 7.8, 9.0).is_nan());
-    assert_biteq!(f32::math::mul_add(inf, 7.8, 9.0), inf);
-    assert_biteq!(f32::math::mul_add(neg_inf, 7.8, 9.0), neg_inf);
-    assert_biteq!(f32::math::mul_add(8.9f32, inf, 3.2), inf);
-    assert_biteq!(f32::math::mul_add(-3.2f32, 2.4, neg_inf), neg_inf);
-}
diff --git a/library/coretests/tests/floats/f64.rs b/library/coretests/tests/floats/f64.rs
deleted file mode 100644
index 4c5a3d68d1fd6..0000000000000
--- a/library/coretests/tests/floats/f64.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-use core::f64;
-
-use super::assert_biteq;
-
-// FIXME(#140515): mingw has an incorrect fma https://sourceforge.net/p/mingw-w64/bugs/848/
-#[cfg_attr(all(target_os = "windows", target_env = "gnu", not(target_abi = "llvm")), ignore)]
-#[test]
-fn test_mul_add() {
-    let nan: f64 = f64::NAN;
-    let inf: f64 = f64::INFINITY;
-    let neg_inf: f64 = f64::NEG_INFINITY;
-    assert_biteq!(12.3f64.mul_add(4.5, 6.7), 62.050000000000004);
-    assert_biteq!((-12.3f64).mul_add(-4.5, -6.7), 48.650000000000006);
-    assert_biteq!(0.0f64.mul_add(8.9, 1.2), 1.2);
-    assert_biteq!(3.4f64.mul_add(-0.0, 5.6), 5.6);
-    assert!(nan.mul_add(7.8, 9.0).is_nan());
-    assert_biteq!(inf.mul_add(7.8, 9.0), inf);
-    assert_biteq!(neg_inf.mul_add(7.8, 9.0), neg_inf);
-    assert_biteq!(8.9f64.mul_add(inf, 3.2), inf);
-    assert_biteq!((-3.2f64).mul_add(2.4, neg_inf), neg_inf);
-}
diff --git a/library/coretests/tests/floats/mod.rs b/library/coretests/tests/floats/mod.rs
index 31515561c637b..9f52adcb6e200 100644
--- a/library/coretests/tests/floats/mod.rs
+++ b/library/coretests/tests/floats/mod.rs
@@ -34,6 +34,10 @@ trait TestableFloat: Sized {
     const RAW_12_DOT_5: Self;
     const RAW_1337: Self;
     const RAW_MINUS_14_DOT_25: Self;
+    /// The result of 12.3.mul_add(4.5, 6.7)
+    const MUL_ADD_RESULT: Self;
+    /// The result of (-12.3).mul_add(-4.5, -6.7)
+    const NEG_MUL_ADD_RESULT: Self;
 }
 
 impl TestableFloat for f16 {
@@ -58,6 +62,8 @@ impl TestableFloat for f16 {
     const RAW_12_DOT_5: Self = Self::from_bits(0x4a40);
     const RAW_1337: Self = Self::from_bits(0x6539);
     const RAW_MINUS_14_DOT_25: Self = Self::from_bits(0xcb20);
+    const MUL_ADD_RESULT: Self = 62.031;
+    const NEG_MUL_ADD_RESULT: Self = 48.625;
 }
 
 impl TestableFloat for f32 {
@@ -84,6 +90,8 @@ impl TestableFloat for f32 {
     const RAW_12_DOT_5: Self = Self::from_bits(0x41480000);
     const RAW_1337: Self = Self::from_bits(0x44a72000);
     const RAW_MINUS_14_DOT_25: Self = Self::from_bits(0xc1640000);
+    const MUL_ADD_RESULT: Self = 62.05;
+    const NEG_MUL_ADD_RESULT: Self = 48.65;
 }
 
 impl TestableFloat for f64 {
@@ -106,6 +114,8 @@ impl TestableFloat for f64 {
     const RAW_12_DOT_5: Self = Self::from_bits(0x4029000000000000);
     const RAW_1337: Self = Self::from_bits(0x4094e40000000000);
     const RAW_MINUS_14_DOT_25: Self = Self::from_bits(0xc02c800000000000);
+    const MUL_ADD_RESULT: Self = 62.050000000000004;
+    const NEG_MUL_ADD_RESULT: Self = 48.650000000000006;
 }
 
 impl TestableFloat for f128 {
@@ -128,6 +138,8 @@ impl TestableFloat for f128 {
     const RAW_12_DOT_5: Self = Self::from_bits(0x40029000000000000000000000000000);
     const RAW_1337: Self = Self::from_bits(0x40094e40000000000000000000000000);
     const RAW_MINUS_14_DOT_25: Self = Self::from_bits(0xc002c800000000000000000000000000);
+    const MUL_ADD_RESULT: Self = 62.0500000000000000000000000000000037;
+    const NEG_MUL_ADD_RESULT: Self = 48.6500000000000000000000000000000049;
 }
 
 /// Determine the tolerance for values of the argument type.
@@ -359,8 +371,6 @@ macro_rules! float_test {
 
 mod f128;
 mod f16;
-mod f32;
-mod f64;
 
 float_test! {
     name: num,
@@ -1542,3 +1552,28 @@ float_test! {
         assert_biteq!(Float::from_bits(masked_nan2), Float::from_bits(masked_nan2));
     }
 }
+
+float_test! {
+    name: mul_add,
+    attrs: {
+        f16: #[cfg(any(miri, target_has_reliable_f16))],
+        // FIXME(#140515): mingw has an incorrect fma https://sourceforge.net/p/mingw-w64/bugs/848/
+        f32: #[cfg_attr(all(target_os = "windows", target_env = "gnu", not(target_abi = "llvm")), ignore)],
+        f64: #[cfg_attr(all(target_os = "windows", target_env = "gnu", not(target_abi = "llvm")), ignore)],
+        f128: #[cfg(any(miri, target_has_reliable_f128))],
+    },
+    test<Float> {
+        let nan: Float = Float::NAN;
+        let inf: Float = Float::INFINITY;
+        let neg_inf: Float = Float::NEG_INFINITY;
+        assert_biteq!(flt(12.3).mul_add(4.5, 6.7), Float::MUL_ADD_RESULT);
+        assert_biteq!((flt(-12.3)).mul_add(-4.5, -6.7), Float::NEG_MUL_ADD_RESULT);
+        assert_biteq!(flt(0.0).mul_add(8.9, 1.2), 1.2);
+        assert_biteq!(flt(3.4).mul_add(-0.0, 5.6), 5.6);
+        assert!(nan.mul_add(7.8, 9.0).is_nan());
+        assert_biteq!(inf.mul_add(7.8, 9.0), inf);
+        assert_biteq!(neg_inf.mul_add(7.8, 9.0), neg_inf);
+        assert_biteq!(flt(8.9).mul_add(inf, 3.2), inf);
+        assert_biteq!((flt(-3.2)).mul_add(2.4, neg_inf), neg_inf);
+    }
+}
diff --git a/library/coretests/tests/lib.rs b/library/coretests/tests/lib.rs
index 5c519f3a499d2..a80d7f8b44d7d 100644
--- a/library/coretests/tests/lib.rs
+++ b/library/coretests/tests/lib.rs
@@ -20,6 +20,7 @@
 #![feature(const_convert)]
 #![feature(const_destruct)]
 #![feature(const_eval_select)]
+#![feature(const_mul_add)]
 #![feature(const_ops)]
 #![feature(const_option_ops)]
 #![feature(const_ref_cell)]
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index 45abd6bca8a5b..233e41aa34535 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -332,6 +332,7 @@
 #![feature(char_internals)]
 #![feature(clone_to_uninit)]
 #![feature(const_convert)]
+#![feature(const_mul_add)]
 #![feature(core_intrinsics)]
 #![feature(core_io_borrowed_buf)]
 #![feature(drop_guard)]
diff --git a/library/std/src/num/f32.rs b/library/std/src/num/f32.rs
index ac1d889cc3731..e7810e77e76f0 100644
--- a/library/std/src/num/f32.rs
+++ b/library/std/src/num/f32.rs
@@ -217,7 +217,8 @@ impl f32 {
     #[must_use = "method returns a new number and does not mutate the original value"]
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
-    pub fn mul_add(self, a: f32, b: f32) -> f32 {
+    #[rustc_const_unstable(feature = "const_mul_add", issue = "146724")]
+    pub const fn mul_add(self, a: f32, b: f32) -> f32 {
         core::f32::math::mul_add(self, a, b)
     }
 
diff --git a/library/std/src/num/f64.rs b/library/std/src/num/f64.rs
index 55c8593a0c0b1..cbebbfb1be166 100644
--- a/library/std/src/num/f64.rs
+++ b/library/std/src/num/f64.rs
@@ -217,7 +217,8 @@ impl f64 {
     #[must_use = "method returns a new number and does not mutate the original value"]
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
-    pub fn mul_add(self, a: f64, b: f64) -> f64 {
+    #[rustc_const_unstable(feature = "const_mul_add", issue = "146724")]
+    pub const fn mul_add(self, a: f64, b: f64) -> f64 {
         core::f64::math::mul_add(self, a, b)
     }
 
diff --git a/src/tools/miri/src/intrinsics/math.rs b/src/tools/miri/src/intrinsics/math.rs
index b9c99f2859468..0cc4342f0d55d 100644
--- a/src/tools/miri/src/intrinsics/math.rs
+++ b/src/tools/miri/src/intrinsics/math.rs
@@ -1,4 +1,3 @@
-use rand::Rng;
 use rustc_apfloat::{self, Float, FloatConvert, Round};
 use rustc_middle::mir;
 use rustc_middle::ty::{self, FloatTy};
@@ -39,46 +38,6 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             "sqrtf64" => sqrt::<rustc_apfloat::ieee::Double>(this, args, dest)?,
             "sqrtf128" => sqrt::<rustc_apfloat::ieee::Quad>(this, args, dest)?,
 
-            "fmaf32" => {
-                let [a, b, c] = check_intrinsic_arg_count(args)?;
-                let a = this.read_scalar(a)?.to_f32()?;
-                let b = this.read_scalar(b)?.to_f32()?;
-                let c = this.read_scalar(c)?.to_f32()?;
-                let res = a.mul_add(b, c).value;
-                let res = this.adjust_nan(res, &[a, b, c]);
-                this.write_scalar(res, dest)?;
-            }
-            "fmaf64" => {
-                let [a, b, c] = check_intrinsic_arg_count(args)?;
-                let a = this.read_scalar(a)?.to_f64()?;
-                let b = this.read_scalar(b)?.to_f64()?;
-                let c = this.read_scalar(c)?.to_f64()?;
-                let res = a.mul_add(b, c).value;
-                let res = this.adjust_nan(res, &[a, b, c]);
-                this.write_scalar(res, dest)?;
-            }
-
-            "fmuladdf32" => {
-                let [a, b, c] = check_intrinsic_arg_count(args)?;
-                let a = this.read_scalar(a)?.to_f32()?;
-                let b = this.read_scalar(b)?.to_f32()?;
-                let c = this.read_scalar(c)?.to_f32()?;
-                let fuse: bool = this.machine.float_nondet && this.machine.rng.get_mut().random();
-                let res = if fuse { a.mul_add(b, c).value } else { ((a * b).value + c).value };
-                let res = this.adjust_nan(res, &[a, b, c]);
-                this.write_scalar(res, dest)?;
-            }
-            "fmuladdf64" => {
-                let [a, b, c] = check_intrinsic_arg_count(args)?;
-                let a = this.read_scalar(a)?.to_f64()?;
-                let b = this.read_scalar(b)?.to_f64()?;
-                let c = this.read_scalar(c)?.to_f64()?;
-                let fuse: bool = this.machine.float_nondet && this.machine.rng.get_mut().random();
-                let res = if fuse { a.mul_add(b, c).value } else { ((a * b).value + c).value };
-                let res = this.adjust_nan(res, &[a, b, c]);
-                this.write_scalar(res, dest)?;
-            }
-
             #[rustfmt::skip]
             | "fadd_fast"
             | "fsub_fast"
diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index 04c8bee72c038..d307636e782fc 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -1293,6 +1293,11 @@ impl<'tcx> Machine<'tcx> for MiriMachine<'tcx> {
         ecx.equal_float_min_max(a, b)
     }
 
+    #[inline(always)]
+    fn float_fuse_mul_add(ecx: &mut InterpCx<'tcx, Self>) -> bool {
+        ecx.machine.float_nondet && ecx.machine.rng.get_mut().random()
+    }
+
     #[inline(always)]
     fn ub_checks(ecx: &InterpCx<'tcx, Self>) -> InterpResult<'tcx, bool> {
         interp_ok(ecx.tcx.sess.ub_checks())

From a22334371cb7d3cf358c025772292d5b8f2b9519 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Wed, 24 Sep 2025 21:49:12 +0200
Subject: [PATCH 1362/1889] Make install test target independent

---
 src/bootstrap/src/core/builder/tests.rs | 116 +++++++++++++-----------
 1 file changed, 61 insertions(+), 55 deletions(-)

diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index 87bea431a0588..e595ca5b28e1e 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -2857,63 +2857,69 @@ mod snapshot {
                     // Using backslashes fails with `--set`
                     "--set", &format!("install.prefix={}", ctx.dir().display()).replace("\\", "/"),
                     "--set", &format!("install.sysconfdir={}", ctx.dir().display()).replace("\\", "/"),
-                    "--set", "build.extended=true"
+                    "--set", "build.extended=true",
+                    // For Cranelift to be disted
+                    "--build", "x86_64-unknown-linux-gnu",
+                    "--host", "x86_64-unknown-linux-gnu"
                 ])
-                .render_steps(), @r"
-        [build] llvm <host>
-        [build] rustc 0 <host> -> rustc 1 <host>
-        [build] rustc 0 <host> -> WasmComponentLd 1 <host>
-        [build] rustc 0 <host> -> UnstableBookGen 1 <host>
-        [build] rustc 0 <host> -> Rustbook 1 <host>
-        [doc] unstable-book (book) <host>
-        [build] rustc 1 <host> -> std 1 <host>
-        [doc] book (book) <host>
-        [doc] book/first-edition (book) <host>
-        [doc] book/second-edition (book) <host>
-        [doc] book/2018-edition (book) <host>
-        [build] rustdoc 1 <host>
-        [doc] rustc 1 <host> -> standalone 2 <host>
-        [doc] rustc 1 <host> -> std 1 <host> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,rustc-std-workspace-core,std,std_detect,sysroot,test,unwind]
-        [build] rustc 1 <host> -> rustc 2 <host>
-        [build] rustc 1 <host> -> WasmComponentLd 2 <host>
-        [build] rustc 1 <host> -> error-index 2 <host>
-        [doc] rustc 1 <host> -> error-index 2 <host>
-        [doc] nomicon (book) <host>
-        [doc] rustc 1 <host> -> reference (book) 2 <host>
-        [doc] rustdoc (book) <host>
-        [doc] rust-by-example (book) <host>
-        [build] rustc 0 <host> -> LintDocs 1 <host>
-        [doc] rustc (book) <host>
-        [doc] cargo (book) <host>
-        [doc] clippy (book) <host>
-        [doc] embedded-book (book) <host>
-        [doc] edition-guide (book) <host>
-        [doc] style-guide (book) <host>
-        [doc] rustc 1 <host> -> releases 2 <host>
-        [build] rustc 0 <host> -> RustInstaller 1 <host>
-        [dist] docs <host>
-        [dist] rustc 1 <host> -> std 1 <host>
-        [build] rustdoc 2 <host>
-        [build] rustc 1 <host> -> rust-analyzer-proc-macro-srv 2 <host>
-        [build] rustc 0 <host> -> GenerateCopyright 1 <host>
-        [dist] rustc <host>
-        [build] rustc 1 <host> -> cargo 2 <host>
-        [dist] rustc 1 <host> -> cargo 2 <host>
-        [build] rustc 1 <host> -> rust-analyzer 2 <host>
-        [dist] rustc 1 <host> -> rust-analyzer 2 <host>
-        [build] rustc 1 <host> -> rustfmt 2 <host>
-        [build] rustc 1 <host> -> cargo-fmt 2 <host>
-        [dist] rustc 1 <host> -> rustfmt 2 <host>
-        [build] rustc 1 <host> -> clippy-driver 2 <host>
-        [build] rustc 1 <host> -> cargo-clippy 2 <host>
-        [dist] rustc 1 <host> -> clippy 2 <host>
-        [build] rustc 1 <host> -> miri 2 <host>
-        [build] rustc 1 <host> -> cargo-miri 2 <host>
-        [dist] rustc 1 <host> -> miri 2 <host>
+                .get_steps()
+                .render_with(RenderConfig {
+                    normalize_host: false
+                }), @r"
+        [build] llvm <x86_64-unknown-linux-gnu>
+        [build] rustc 0 <x86_64-unknown-linux-gnu> -> rustc 1 <x86_64-unknown-linux-gnu>
+        [build] rustc 0 <x86_64-unknown-linux-gnu> -> WasmComponentLd 1 <x86_64-unknown-linux-gnu>
+        [build] rustc 0 <x86_64-unknown-linux-gnu> -> UnstableBookGen 1 <x86_64-unknown-linux-gnu>
+        [build] rustc 0 <x86_64-unknown-linux-gnu> -> Rustbook 1 <x86_64-unknown-linux-gnu>
+        [doc] unstable-book (book) <x86_64-unknown-linux-gnu>
+        [build] rustc 1 <x86_64-unknown-linux-gnu> -> std 1 <x86_64-unknown-linux-gnu>
+        [doc] book (book) <x86_64-unknown-linux-gnu>
+        [doc] book/first-edition (book) <x86_64-unknown-linux-gnu>
+        [doc] book/second-edition (book) <x86_64-unknown-linux-gnu>
+        [doc] book/2018-edition (book) <x86_64-unknown-linux-gnu>
+        [build] rustdoc 1 <x86_64-unknown-linux-gnu>
+        [doc] rustc 1 <x86_64-unknown-linux-gnu> -> standalone 2 <x86_64-unknown-linux-gnu>
+        [doc] rustc 1 <x86_64-unknown-linux-gnu> -> std 1 <x86_64-unknown-linux-gnu> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,rustc-std-workspace-core,std,std_detect,sysroot,test,unwind]
+        [build] rustc 1 <x86_64-unknown-linux-gnu> -> rustc 2 <x86_64-unknown-linux-gnu>
+        [build] rustc 1 <x86_64-unknown-linux-gnu> -> WasmComponentLd 2 <x86_64-unknown-linux-gnu>
+        [build] rustc 1 <x86_64-unknown-linux-gnu> -> error-index 2 <x86_64-unknown-linux-gnu>
+        [doc] rustc 1 <x86_64-unknown-linux-gnu> -> error-index 2 <x86_64-unknown-linux-gnu>
+        [doc] nomicon (book) <x86_64-unknown-linux-gnu>
+        [doc] rustc 1 <x86_64-unknown-linux-gnu> -> reference (book) 2 <x86_64-unknown-linux-gnu>
+        [doc] rustdoc (book) <x86_64-unknown-linux-gnu>
+        [doc] rust-by-example (book) <x86_64-unknown-linux-gnu>
+        [build] rustc 0 <x86_64-unknown-linux-gnu> -> LintDocs 1 <x86_64-unknown-linux-gnu>
+        [doc] rustc (book) <x86_64-unknown-linux-gnu>
+        [doc] cargo (book) <x86_64-unknown-linux-gnu>
+        [doc] clippy (book) <x86_64-unknown-linux-gnu>
+        [doc] embedded-book (book) <x86_64-unknown-linux-gnu>
+        [doc] edition-guide (book) <x86_64-unknown-linux-gnu>
+        [doc] style-guide (book) <x86_64-unknown-linux-gnu>
+        [doc] rustc 1 <x86_64-unknown-linux-gnu> -> releases 2 <x86_64-unknown-linux-gnu>
+        [build] rustc 0 <x86_64-unknown-linux-gnu> -> RustInstaller 1 <x86_64-unknown-linux-gnu>
+        [dist] docs <x86_64-unknown-linux-gnu>
+        [dist] rustc 1 <x86_64-unknown-linux-gnu> -> std 1 <x86_64-unknown-linux-gnu>
+        [build] rustdoc 2 <x86_64-unknown-linux-gnu>
+        [build] rustc 1 <x86_64-unknown-linux-gnu> -> rust-analyzer-proc-macro-srv 2 <x86_64-unknown-linux-gnu>
+        [build] rustc 0 <x86_64-unknown-linux-gnu> -> GenerateCopyright 1 <x86_64-unknown-linux-gnu>
+        [dist] rustc <x86_64-unknown-linux-gnu>
+        [build] rustc 1 <x86_64-unknown-linux-gnu> -> cargo 2 <x86_64-unknown-linux-gnu>
+        [dist] rustc 1 <x86_64-unknown-linux-gnu> -> cargo 2 <x86_64-unknown-linux-gnu>
+        [build] rustc 1 <x86_64-unknown-linux-gnu> -> rust-analyzer 2 <x86_64-unknown-linux-gnu>
+        [dist] rustc 1 <x86_64-unknown-linux-gnu> -> rust-analyzer 2 <x86_64-unknown-linux-gnu>
+        [build] rustc 1 <x86_64-unknown-linux-gnu> -> rustfmt 2 <x86_64-unknown-linux-gnu>
+        [build] rustc 1 <x86_64-unknown-linux-gnu> -> cargo-fmt 2 <x86_64-unknown-linux-gnu>
+        [dist] rustc 1 <x86_64-unknown-linux-gnu> -> rustfmt 2 <x86_64-unknown-linux-gnu>
+        [build] rustc 1 <x86_64-unknown-linux-gnu> -> clippy-driver 2 <x86_64-unknown-linux-gnu>
+        [build] rustc 1 <x86_64-unknown-linux-gnu> -> cargo-clippy 2 <x86_64-unknown-linux-gnu>
+        [dist] rustc 1 <x86_64-unknown-linux-gnu> -> clippy 2 <x86_64-unknown-linux-gnu>
+        [build] rustc 1 <x86_64-unknown-linux-gnu> -> miri 2 <x86_64-unknown-linux-gnu>
+        [build] rustc 1 <x86_64-unknown-linux-gnu> -> cargo-miri 2 <x86_64-unknown-linux-gnu>
+        [dist] rustc 1 <x86_64-unknown-linux-gnu> -> miri 2 <x86_64-unknown-linux-gnu>
         [dist] src <>
-        [build] rustc 1 <host> -> rustc_codegen_cranelift 2 <host>
-        [dist] rustc 1 <host> -> rustc_codegen_cranelift 2 <host>
-        [build] rustc 1 <host> -> LlvmBitcodeLinker 2 <host>
+        [build] rustc 1 <x86_64-unknown-linux-gnu> -> rustc_codegen_cranelift 2 <x86_64-unknown-linux-gnu>
+        [dist] rustc 1 <x86_64-unknown-linux-gnu> -> rustc_codegen_cranelift 2 <x86_64-unknown-linux-gnu>
+        [build] rustc 1 <x86_64-unknown-linux-gnu> -> LlvmBitcodeLinker 2 <x86_64-unknown-linux-gnu>
         ");
     }
 

From 92859e98ee1a2101df8322a8581e4d638eb15078 Mon Sep 17 00:00:00 2001
From: Stepan Koltsov <stepan.koltsov@gmail.com>
Date: Wed, 24 Sep 2025 20:32:50 +0100
Subject: [PATCH 1363/1889] Repro duration_since regression from issue 146228

---
 library/std/src/sys/pal/hermit/time.rs | 11 +++++++++--
 library/std/src/sys/pal/unix/time.rs   | 27 ++++++++++++--------------
 library/std/tests/time.rs              | 16 +++++++++++++++
 3 files changed, 37 insertions(+), 17 deletions(-)

diff --git a/library/std/src/sys/pal/hermit/time.rs b/library/std/src/sys/pal/hermit/time.rs
index f76a5f96c8750..bd6fd5a3de428 100644
--- a/library/std/src/sys/pal/hermit/time.rs
+++ b/library/std/src/sys/pal/hermit/time.rs
@@ -26,15 +26,22 @@ impl Timespec {
     }
 
     fn sub_timespec(&self, other: &Timespec) -> Result<Duration, Duration> {
+        fn sub_ge_to_unsigned(a: i64, b: i64) -> u64 {
+            debug_assert!(a >= b);
+            a.wrapping_sub(b).cast_unsigned()
+        }
+
         if self >= other {
+            // Logic here is identical to Unix version of `Timestamp::sub_timespec`,
+            // check comments there why operations do not overflow.
             Ok(if self.t.tv_nsec >= other.t.tv_nsec {
                 Duration::new(
-                    (self.t.tv_sec - other.t.tv_sec) as u64,
+                    sub_ge_to_unsigned(self.t.tv_sec, other.t.tv_sec),
                     (self.t.tv_nsec - other.t.tv_nsec) as u32,
                 )
             } else {
                 Duration::new(
-                    (self.t.tv_sec - 1 - other.t.tv_sec) as u64,
+                    sub_ge_to_unsigned(self.t.tv_sec - 1, other.t.tv_sec),
                     (self.t.tv_nsec + NSEC_PER_SEC - other.t.tv_nsec) as u32,
                 )
             })
diff --git a/library/std/src/sys/pal/unix/time.rs b/library/std/src/sys/pal/unix/time.rs
index bd7f74fea6a9c..c207f41cad4b5 100644
--- a/library/std/src/sys/pal/unix/time.rs
+++ b/library/std/src/sys/pal/unix/time.rs
@@ -134,28 +134,25 @@ impl Timespec {
     }
 
     pub fn sub_timespec(&self, other: &Timespec) -> Result<Duration, Duration> {
+        // When a >= b, the difference fits in u64.
+        fn sub_ge_to_unsigned(a: i64, b: i64) -> u64 {
+            debug_assert!(a >= b);
+            a.wrapping_sub(b).cast_unsigned()
+        }
+
         if self >= other {
-            // NOTE(eddyb) two aspects of this `if`-`else` are required for LLVM
-            // to optimize it into a branchless form (see also #75545):
-            //
-            // 1. `self.tv_sec - other.tv_sec` shows up as a common expression
-            //    in both branches, i.e. the `else` must have its `- 1`
-            //    subtraction after the common one, not interleaved with it
-            //    (it used to be `self.tv_sec - 1 - other.tv_sec`)
-            //
-            // 2. the `Duration::new` call (or any other additional complexity)
-            //    is outside of the `if`-`else`, not duplicated in both branches
-            //
-            // Ideally this code could be rearranged such that it more
-            // directly expresses the lower-cost behavior we want from it.
             let (secs, nsec) = if self.tv_nsec.as_inner() >= other.tv_nsec.as_inner() {
                 (
-                    (self.tv_sec - other.tv_sec) as u64,
+                    sub_ge_to_unsigned(self.tv_sec, other.tv_sec),
                     self.tv_nsec.as_inner() - other.tv_nsec.as_inner(),
                 )
             } else {
+                // Following sequence of assertions explain why `self.tv_sec - 1` does not underflow.
+                debug_assert!(self.tv_nsec < other.tv_nsec);
+                debug_assert!(self.tv_sec > other.tv_sec);
+                debug_assert!(self.tv_sec > i64::MIN);
                 (
-                    (self.tv_sec - other.tv_sec - 1) as u64,
+                    sub_ge_to_unsigned(self.tv_sec - 1, other.tv_sec),
                     self.tv_nsec.as_inner() + (NSEC_PER_SEC as u32) - other.tv_nsec.as_inner(),
                 )
             };
diff --git a/library/std/tests/time.rs b/library/std/tests/time.rs
index 40709eae37cfc..be1948af91564 100644
--- a/library/std/tests/time.rs
+++ b/library/std/tests/time.rs
@@ -227,3 +227,19 @@ fn big_math() {
     check(instant.checked_add(Duration::from_secs(100)), Instant::checked_sub);
     check(instant.checked_add(Duration::from_secs(i64::MAX as _)), Instant::checked_sub);
 }
+
+#[test]
+#[cfg(unix)]
+fn system_time_duration_since_max_range_on_unix() {
+    // Repro regression https://github.com/rust-lang/rust/issues/146228
+
+    // Min and max values of `SystemTime` on Unix.
+    let min = SystemTime::UNIX_EPOCH - (Duration::new(i64::MAX as u64 + 1, 0));
+    let max = SystemTime::UNIX_EPOCH + (Duration::new(i64::MAX as u64, 999_999_999));
+
+    let delta_a = max.duration_since(min).expect("duration_since overflow");
+    let delta_b = min.duration_since(max).expect_err("duration_since overflow").duration();
+
+    assert_eq!(Duration::MAX, delta_a);
+    assert_eq!(Duration::MAX, delta_b);
+}

From 43057698c12e8ceab1f49eff8a3e5a38cc05f7db Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Wed, 24 Sep 2025 21:06:54 +0000
Subject: [PATCH 1364/1889] Tweak handling of "struct like start" where a
 struct isn't supported

This improves the case where someone tries to write a `match` expr where the patterns have type ascription syntax. Makes them less verbose, by giving up on the first encounter in the block, and makes them more accurate by only treating them as a struct literal if successfuly parsed as such.
---
 .../rustc_parse/src/parser/diagnostics.rs     | 40 ++++------
 compiler/rustc_parse/src/parser/expr.rs       | 61 +++++++++-----
 .../issues/issue-87086-colon-path-sep.rs      |  3 +-
 .../issues/issue-87086-colon-path-sep.stderr  | 20 ++---
 tests/ui/parser/type-ascription-in-pattern.rs | 17 ++--
 .../parser/type-ascription-in-pattern.stderr  | 80 +++++--------------
 6 files changed, 93 insertions(+), 128 deletions(-)

diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs
index a28af7833c387..a9fbd0fa33d5f 100644
--- a/compiler/rustc_parse/src/parser/diagnostics.rs
+++ b/compiler/rustc_parse/src/parser/diagnostics.rs
@@ -2748,28 +2748,7 @@ impl<'a> Parser<'a> {
         if token::Colon != self.token.kind {
             return first_pat;
         }
-        if !matches!(first_pat.kind, PatKind::Ident(_, _, None) | PatKind::Path(..))
-            || !self.look_ahead(1, |token| token.is_non_reserved_ident())
-        {
-            let mut snapshot_type = self.create_snapshot_for_diagnostic();
-            snapshot_type.bump(); // `:`
-            match snapshot_type.parse_ty() {
-                Err(inner_err) => {
-                    inner_err.cancel();
-                }
-                Ok(ty) => {
-                    let Err(mut err) = self.expected_one_of_not_found(&[], &[]) else {
-                        return first_pat;
-                    };
-                    err.span_label(ty.span, "specifying the type of a pattern isn't supported");
-                    self.restore_snapshot(snapshot_type);
-                    let span = first_pat.span.to(ty.span);
-                    first_pat = self.mk_pat(span, PatKind::Wild);
-                    err.emit();
-                }
-            }
-            return first_pat;
-        }
+
         // The pattern looks like it might be a path with a `::` -> `:` typo:
         // `match foo { bar:baz => {} }`
         let colon_span = self.token.span;
@@ -2857,7 +2836,13 @@ impl<'a> Parser<'a> {
                                 Applicability::MaybeIncorrect,
                             );
                         } else {
-                            first_pat = self.mk_pat(new_span, PatKind::Wild);
+                            first_pat = self.mk_pat(
+                                new_span,
+                                PatKind::Err(
+                                    self.dcx()
+                                        .span_delayed_bug(colon_span, "recovered bad path pattern"),
+                                ),
+                            );
                         }
                         self.restore_snapshot(snapshot_pat);
                     }
@@ -2870,7 +2855,14 @@ impl<'a> Parser<'a> {
                         err.span_label(ty.span, "specifying the type of a pattern isn't supported");
                         self.restore_snapshot(snapshot_type);
                         let new_span = first_pat.span.to(ty.span);
-                        first_pat = self.mk_pat(new_span, PatKind::Wild);
+                        first_pat =
+                            self.mk_pat(
+                                new_span,
+                                PatKind::Err(self.dcx().span_delayed_bug(
+                                    colon_span,
+                                    "recovered bad pattern with type",
+                                )),
+                            );
                     }
                 }
                 err.emit();
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index 81a5d48d94e8c..2f4158450d838 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -3612,36 +3612,55 @@ impl<'a> Parser<'a> {
         self.token.is_keyword(kw::Async) && self.is_gen_block(kw::Gen, 1)
     }
 
-    fn is_certainly_not_a_block(&self) -> bool {
-        // `{ ident, ` and `{ ident: ` cannot start a block.
-        self.look_ahead(1, |t| t.is_ident())
-            && self.look_ahead(2, |t| t == &token::Comma || t == &token::Colon)
-    }
-
     fn maybe_parse_struct_expr(
         &mut self,
         qself: &Option<Box<ast::QSelf>>,
         path: &ast::Path,
     ) -> Option<PResult<'a, Box<Expr>>> {
         let struct_allowed = !self.restrictions.contains(Restrictions::NO_STRUCT_LITERAL);
-        if struct_allowed || self.is_certainly_not_a_block() {
-            if let Err(err) = self.expect(exp!(OpenBrace)) {
-                return Some(Err(err));
+        let is_ident = self.look_ahead(1, |t| t.is_ident());
+        let is_comma = self.look_ahead(2, |t| t == &token::Comma);
+        let is_colon = self.look_ahead(2, |t| t == &token::Colon);
+        match (struct_allowed, is_ident, is_comma, is_colon) {
+            (false, true, true, _) | (false, true, _, true) => {
+                // We have something like `match foo { bar,` or `match foo { bar:`, which means the
+                // user might have meant to write a struct literal as part of the `match`
+                // discriminant.
+                let snapshot = self.create_snapshot_for_diagnostic();
+                if let Err(err) = self.expect(exp!(OpenBrace)) {
+                    return Some(Err(err));
+                }
+                match self.parse_expr_struct(qself.clone(), path.clone(), false) {
+                    Ok(expr) => {
+                        // This is a struct literal, but we don't accept them here.
+                        self.dcx().emit_err(errors::StructLiteralNotAllowedHere {
+                            span: expr.span,
+                            sub: errors::StructLiteralNotAllowedHereSugg {
+                                left: path.span.shrink_to_lo(),
+                                right: expr.span.shrink_to_hi(),
+                            },
+                        });
+                        Some(Ok(expr))
+                    }
+                    Err(err) => {
+                        // We couldn't parse a valid struct, rollback and let the parser emit an
+                        // error elsewhere.
+                        err.cancel();
+                        self.restore_snapshot(snapshot);
+                        None
+                    }
+                }
             }
-            let expr = self.parse_expr_struct(qself.clone(), path.clone(), true);
-            if let (Ok(expr), false) = (&expr, struct_allowed) {
-                // This is a struct literal, but we don't can't accept them here.
-                self.dcx().emit_err(errors::StructLiteralNotAllowedHere {
-                    span: expr.span,
-                    sub: errors::StructLiteralNotAllowedHereSugg {
-                        left: path.span.shrink_to_lo(),
-                        right: expr.span.shrink_to_hi(),
-                    },
-                });
+            (true, _, _, _) => {
+                // A struct is accepted here, try to parse it and rely on `parse_expr_struct` for
+                // any kind of recovery.
+                if let Err(err) = self.expect(exp!(OpenBrace)) {
+                    return Some(Err(err));
+                }
+                Some(self.parse_expr_struct(qself.clone(), path.clone(), true))
             }
-            return Some(expr);
+            (false, _, _, _) => None,
         }
-        None
     }
 
     pub(super) fn parse_struct_fields(
diff --git a/tests/ui/parser/issues/issue-87086-colon-path-sep.rs b/tests/ui/parser/issues/issue-87086-colon-path-sep.rs
index d081c06044f14..e1ea38f2795df 100644
--- a/tests/ui/parser/issues/issue-87086-colon-path-sep.rs
+++ b/tests/ui/parser/issues/issue-87086-colon-path-sep.rs
@@ -37,10 +37,9 @@ fn g1() {
         //~| HELP: maybe write a path separator here
         _ => {}
     }
-    if let Foo:Bar = f() { //~ WARN: irrefutable `if let` pattern
+    if let Foo:Bar = f() {
     //~^ ERROR: expected one of
     //~| HELP: maybe write a path separator here
-    //~| HELP: consider replacing the `if let` with a `let`
     }
 }
 
diff --git a/tests/ui/parser/issues/issue-87086-colon-path-sep.stderr b/tests/ui/parser/issues/issue-87086-colon-path-sep.stderr
index a9bad96f9af76..061586882e0c9 100644
--- a/tests/ui/parser/issues/issue-87086-colon-path-sep.stderr
+++ b/tests/ui/parser/issues/issue-87086-colon-path-sep.stderr
@@ -64,7 +64,7 @@ LL |     if let Foo::Bar = f() {
    |                +
 
 error: expected one of `@` or `|`, found `:`
-  --> $DIR/issue-87086-colon-path-sep.rs:49:16
+  --> $DIR/issue-87086-colon-path-sep.rs:48:16
    |
 LL |         ref qux: Foo::Baz => {}
    |                ^ -------- specifying the type of a pattern isn't supported
@@ -77,7 +77,7 @@ LL |         ref qux::Foo::Baz => {}
    |                ~~
 
 error: expected one of `@` or `|`, found `:`
-  --> $DIR/issue-87086-colon-path-sep.rs:58:16
+  --> $DIR/issue-87086-colon-path-sep.rs:57:16
    |
 LL |         mut qux: Foo::Baz => {}
    |                ^ -------- specifying the type of a pattern isn't supported
@@ -90,7 +90,7 @@ LL |         mut qux::Foo::Baz => {}
    |                ~~
 
 error: expected one of `@` or `|`, found `:`
-  --> $DIR/issue-87086-colon-path-sep.rs:69:12
+  --> $DIR/issue-87086-colon-path-sep.rs:68:12
    |
 LL |         Foo:Bar::Baz => {}
    |            ^-------- specifying the type of a pattern isn't supported
@@ -103,7 +103,7 @@ LL |         Foo::Bar::Baz => {}
    |             +
 
 error: expected one of `@` or `|`, found `:`
-  --> $DIR/issue-87086-colon-path-sep.rs:75:12
+  --> $DIR/issue-87086-colon-path-sep.rs:74:12
    |
 LL |         Foo:Bar => {}
    |            ^--- specifying the type of a pattern isn't supported
@@ -115,15 +115,5 @@ help: maybe write a path separator here
 LL |         Foo::Bar => {}
    |             +
 
-warning: irrefutable `if let` pattern
-  --> $DIR/issue-87086-colon-path-sep.rs:40:8
-   |
-LL |     if let Foo:Bar = f() {
-   |        ^^^^^^^^^^^^^^^^^
-   |
-   = note: this pattern will always match, so the `if let` is useless
-   = help: consider replacing the `if let` with a `let`
-   = note: `#[warn(irrefutable_let_patterns)]` on by default
-
-error: aborting due to 9 previous errors; 1 warning emitted
+error: aborting due to 9 previous errors
 
diff --git a/tests/ui/parser/type-ascription-in-pattern.rs b/tests/ui/parser/type-ascription-in-pattern.rs
index 18d7061d69c8d..75059d33db645 100644
--- a/tests/ui/parser/type-ascription-in-pattern.rs
+++ b/tests/ui/parser/type-ascription-in-pattern.rs
@@ -1,15 +1,16 @@
 fn foo(x: bool) -> i32 {
-    match x { //~ ERROR struct literals are not allowed here
-        x: i32 => x, //~ ERROR expected
-        true => 42., //~ ERROR expected identifier
-        false => 0.333, //~ ERROR expected identifier
+    match x {
+        x: i32 => x, //~ ERROR: expected
+        //~^ ERROR: mismatched types
+        true => 42.,
+        false => 0.333,
     }
-} //~ ERROR expected one of
+}
 
 fn main() {
     match foo(true) {
-        42: i32 => (), //~ ERROR expected
-        _: f64 => (), //~ ERROR expected
-        x: i32 => (), //~ ERROR expected
+        42: i32 => (), //~ ERROR: expected
+        _: f64 => (), //~ ERROR: expected
+        x: i32 => (), //~ ERROR: expected
     }
 }
diff --git a/tests/ui/parser/type-ascription-in-pattern.stderr b/tests/ui/parser/type-ascription-in-pattern.stderr
index 135879f208b2b..0919075499368 100644
--- a/tests/ui/parser/type-ascription-in-pattern.stderr
+++ b/tests/ui/parser/type-ascription-in-pattern.stderr
@@ -1,64 +1,18 @@
-error: expected one of `!`, `,`, `.`, `::`, `?`, `{`, `}`, or an operator, found `=>`
-  --> $DIR/type-ascription-in-pattern.rs:3:16
-   |
-LL |     match x {
-   |           - while parsing this struct
-LL |         x: i32 => x,
-   |               -^^ expected one of 8 possible tokens
-   |               |
-   |               help: try adding a comma: `,`
-
-error: expected identifier, found keyword `true`
-  --> $DIR/type-ascription-in-pattern.rs:4:9
-   |
-LL |     match x {
-   |           - while parsing this struct
-LL |         x: i32 => x,
-LL |         true => 42.,
-   |         ^^^^ expected identifier, found keyword
-
-error: expected identifier, found keyword `false`
-  --> $DIR/type-ascription-in-pattern.rs:5:9
-   |
-LL |     match x {
-   |           - while parsing this struct
-...
-LL |         false => 0.333,
-   |         ^^^^^ expected identifier, found keyword
-
-error: struct literals are not allowed here
-  --> $DIR/type-ascription-in-pattern.rs:2:11
-   |
-LL |       match x {
-   |  ___________^
-LL | |         x: i32 => x,
-LL | |         true => 42.,
-LL | |         false => 0.333,
-LL | |     }
-   | |_____^
-   |
-help: surround the struct literal with parentheses
+error: expected one of `@` or `|`, found `:`
+  --> $DIR/type-ascription-in-pattern.rs:3:10
    |
-LL ~     match (x {
 LL |         x: i32 => x,
-LL |         true => 42.,
-LL |         false => 0.333,
-LL ~     })
+   |          ^ --- specifying the type of a pattern isn't supported
+   |          |
+   |          expected one of `@` or `|`
    |
-
-error: expected one of `.`, `?`, `{`, or an operator, found `}`
-  --> $DIR/type-ascription-in-pattern.rs:7:1
+help: maybe write a path separator here
    |
-LL |     match x {
-   |     ----- while parsing this `match` expression
-...
-LL |     }
-   |      - expected one of `.`, `?`, `{`, or an operator
-LL | }
-   | ^ unexpected token
+LL |         x::i32 => x,
+   |          ~~
 
 error: expected one of `...`, `..=`, `..`, or `|`, found `:`
-  --> $DIR/type-ascription-in-pattern.rs:11:11
+  --> $DIR/type-ascription-in-pattern.rs:12:11
    |
 LL |         42: i32 => (),
    |           ^ --- specifying the type of a pattern isn't supported
@@ -66,7 +20,7 @@ LL |         42: i32 => (),
    |           expected one of `...`, `..=`, `..`, or `|`
 
 error: expected `|`, found `:`
-  --> $DIR/type-ascription-in-pattern.rs:12:10
+  --> $DIR/type-ascription-in-pattern.rs:13:10
    |
 LL |         _: f64 => (),
    |          ^ --- specifying the type of a pattern isn't supported
@@ -74,7 +28,7 @@ LL |         _: f64 => (),
    |          expected `|`
 
 error: expected one of `@` or `|`, found `:`
-  --> $DIR/type-ascription-in-pattern.rs:13:10
+  --> $DIR/type-ascription-in-pattern.rs:14:10
    |
 LL |         x: i32 => (),
    |          ^ --- specifying the type of a pattern isn't supported
@@ -86,5 +40,15 @@ help: maybe write a path separator here
 LL |         x::i32 => (),
    |          ~~
 
-error: aborting due to 8 previous errors
+error[E0308]: mismatched types
+  --> $DIR/type-ascription-in-pattern.rs:3:19
+   |
+LL | fn foo(x: bool) -> i32 {
+   |                    --- expected `i32` because of return type
+LL |     match x {
+LL |         x: i32 => x,
+   |                   ^ expected `i32`, found `bool`
+
+error: aborting due to 5 previous errors
 
+For more information about this error, try `rustc --explain E0308`.

From aa75d340353dd07bf347978360a9566831128e35 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Wed, 24 Sep 2025 23:47:05 +0200
Subject: [PATCH 1365/1889] Small string formatting cleanup

---
 compiler/rustc_interface/src/util.rs | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/compiler/rustc_interface/src/util.rs b/compiler/rustc_interface/src/util.rs
index 26e09c95e7698..76ccd12797e5e 100644
--- a/compiler/rustc_interface/src/util.rs
+++ b/compiler/rustc_interface/src/util.rs
@@ -386,8 +386,8 @@ fn get_codegen_sysroot(
                 .collect::<Vec<_>>()
                 .join("\n* ");
             let err = format!(
-                "failed to find a `codegen-backends` folder \
-                           in the sysroot candidates:\n* {candidates}"
+                "failed to find a `codegen-backends` folder in the sysroot candidates:\n\
+                 * {candidates}"
             );
             early_dcx.early_fatal(err);
         });
@@ -396,10 +396,8 @@ fn get_codegen_sysroot(
 
     let d = sysroot.read_dir().unwrap_or_else(|e| {
         let err = format!(
-            "failed to load default codegen backend, couldn't \
-                           read `{}`: {}",
+            "failed to load default codegen backend, couldn't read `{}`: {e}",
             sysroot.display(),
-            e
         );
         early_dcx.early_fatal(err);
     });

From 852da23a2d06de5a7821b1fdb356fe3a410b2d00 Mon Sep 17 00:00:00 2001
From: Adam Harvey <adam@adamharvey.name>
Date: Wed, 24 Sep 2025 15:56:38 -0700
Subject: [PATCH 1366/1889] Explicitly note `&[SocketAddr]` impl of
 `ToSocketAddrs`.

Although the examples below this list do imply that there's an impl of
`ToSocketAddrs` for `&[SocketAddr]`, it's not actually noted in the list
of default implementations.
---
 library/std/src/net/socket_addr.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/library/std/src/net/socket_addr.rs b/library/std/src/net/socket_addr.rs
index 5b56dd3f74472..8214ad381f1f7 100644
--- a/library/std/src/net/socket_addr.rs
+++ b/library/std/src/net/socket_addr.rs
@@ -28,6 +28,8 @@ use crate::{io, iter, option, slice, vec};
 ///    [`SocketAddr`] as expected by its [`FromStr`] implementation or a string like
 ///    `<host_name>:<port>` pair where `<port>` is a [`u16`] value.
 ///
+///  * <code>&[[SocketAddr]]</code>: all [`SocketAddr`] values in the slice will be used.
+///
 /// This trait allows constructing network objects like [`TcpStream`] or
 /// [`UdpSocket`] easily with values of various types for the bind/connection
 /// address. It is needed because sometimes one type is more appropriate than

From 16460273e0b980b8b34213eac9426066777a520b Mon Sep 17 00:00:00 2001
From: itsjunetime <junewelker@gmail.com>
Date: Wed, 24 Sep 2025 18:47:36 -0500
Subject: [PATCH 1367/1889] fix SCIP panicking due to salsa not attaching

---
 src/tools/rust-analyzer/crates/ide/src/static_index.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/ide/src/static_index.rs b/src/tools/rust-analyzer/crates/ide/src/static_index.rs
index 8214b4d1de22f..9911b85799b62 100644
--- a/src/tools/rust-analyzer/crates/ide/src/static_index.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/static_index.rs
@@ -278,7 +278,7 @@ impl StaticIndex<'_> {
         for token in tokens {
             let range = token.text_range();
             let node = token.parent().unwrap();
-            match get_definitions(&sema, token.clone()) {
+            match salsa::attach(self.db, || get_definitions(&sema, token.clone())) {
                 Some(it) => {
                     for i in it {
                         add_token(i, range, &node);

From fe440ec934995e499360dc05ae485f1ccbd0e694 Mon Sep 17 00:00:00 2001
From: Josh Stone <jistone@redhat.com>
Date: Wed, 24 Sep 2025 16:53:17 -0700
Subject: [PATCH 1368/1889] llvm: add a destructor to call releaseSerializer

---
 compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index ef85ce153b88c..9953f5e173168 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -1685,6 +1685,14 @@ extern "C" void LLVMRustContextConfigureDiagnosticHandler(
           RemarkStreamer(std::move(RemarkStreamer)),
           LlvmRemarkStreamer(std::move(LlvmRemarkStreamer)) {}
 
+#if LLVM_VERSION_GE(22, 0)
+    ~RustDiagnosticHandler() {
+      if (RemarkStreamer) {
+        RemarkStreamer->releaseSerializer();
+      }
+    }
+#endif
+
     virtual bool handleDiagnostics(const DiagnosticInfo &DI) override {
       // If this diagnostic is one of the optimization remark kinds, we can
       // check if it's enabled before emitting it. This can avoid many

From 137d4eaf12139af894da6c0b6fe74195d6b7b98c Mon Sep 17 00:00:00 2001
From: Sidney Cammeresi <sac@cheesecake.org>
Date: Sat, 20 Sep 2025 16:54:51 -0700
Subject: [PATCH 1369/1889] BTreeMap: Don't leak allocators when initializing
 nodes

Memory was allocated via `Box::leak` and thence intended to be tracked
and deallocated manually, but the allocator was also leaked, not
tracked, and never dropped.  Now it is dropped immediately.

According to my reading of the `Allocator` trait, if a copy of the
allocator remains live, then its allocations must remain live.  Since
the B-tree has a copy of the allocator that will only be dropped after
the nodes, it's safe to not store the allocator in each node (which
would be a much more intrusive change).
---
 library/alloc/src/collections/btree/map.rs  |  3 +++
 library/alloc/src/collections/btree/node.rs | 12 ++++++++++--
 2 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/library/alloc/src/collections/btree/map.rs b/library/alloc/src/collections/btree/map.rs
index cebd25c6039cc..e3b53b2fe291a 100644
--- a/library/alloc/src/collections/btree/map.rs
+++ b/library/alloc/src/collections/btree/map.rs
@@ -194,6 +194,9 @@ pub struct BTreeMap<
     root: Option<Root<K, V>>,
     length: usize,
     /// `ManuallyDrop` to control drop order (needs to be dropped after all the nodes).
+    // Although some of the accessory types store a copy of the allocator, the nodes do not.
+    // Because allocations will remain live as long as any copy (like this one) of the allocator
+    // is live, it's unnecessary to store the allocator in each node.
     pub(super) alloc: ManuallyDrop<A>,
     // For dropck; the `Box` avoids making the `Unpin` impl more strict than before
     _marker: PhantomData<crate::boxed::Box<(K, V), A>>,
diff --git a/library/alloc/src/collections/btree/node.rs b/library/alloc/src/collections/btree/node.rs
index b233e1740b7b7..77bd90f2c750c 100644
--- a/library/alloc/src/collections/btree/node.rs
+++ b/library/alloc/src/collections/btree/node.rs
@@ -224,7 +224,11 @@ impl<K, V> NodeRef<marker::Owned, K, V, marker::Leaf> {
     }
 
     fn from_new_leaf<A: Allocator + Clone>(leaf: Box<LeafNode<K, V>, A>) -> Self {
-        NodeRef { height: 0, node: NonNull::from(Box::leak(leaf)), _marker: PhantomData }
+        // The allocator must be dropped, not leaked.  See also `BTreeMap::alloc`.
+        let (leaf, _alloc) = Box::into_raw_with_allocator(leaf);
+        // SAFETY: the node was just allocated.
+        let node = unsafe { NonNull::new_unchecked(leaf) };
+        NodeRef { height: 0, node, _marker: PhantomData }
     }
 }
 
@@ -242,7 +246,11 @@ impl<K, V> NodeRef<marker::Owned, K, V, marker::Internal> {
         height: usize,
     ) -> Self {
         debug_assert!(height > 0);
-        let node = NonNull::from(Box::leak(internal)).cast();
+        // The allocator must be dropped, not leaked.  See also `BTreeMap::alloc`.
+        let (internal, _alloc) = Box::into_raw_with_allocator(internal);
+        // SAFETY: the node was just allocated.
+        let internal = unsafe { NonNull::new_unchecked(internal) };
+        let node = internal.cast();
         let mut this = NodeRef { height, node, _marker: PhantomData };
         this.borrow_mut().correct_all_childrens_parent_links();
         this

From 3280c210dd6e5f26595ff4857572f8feba678992 Mon Sep 17 00:00:00 2001
From: The rustc-josh-sync Cronjob Bot <github-actions@github.com>
Date: Thu, 25 Sep 2025 04:11:22 +0000
Subject: [PATCH 1370/1889] Prepare for merging from rust-lang/rust

This updates the rust-version file to caccb4d0368bd918ef6668af8e13834d07040417.
---
 src/tools/rust-analyzer/rust-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/rust-version b/src/tools/rust-analyzer/rust-version
index 02b217f7d80dc..8854fb95997bd 100644
--- a/src/tools/rust-analyzer/rust-version
+++ b/src/tools/rust-analyzer/rust-version
@@ -1 +1 @@
-21a19c297d4f5a03501d92ca251bd7a17073c08a
+caccb4d0368bd918ef6668af8e13834d07040417

From bc37dd4a724fc3e3043a46f488775dbe1bfd9649 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Wed, 24 Sep 2025 15:48:34 +0200
Subject: [PATCH 1371/1889] Remove an erroneous normalization step in
 `tests/run-make/linker-warning`

---
 tests/run-make/linker-warning/rmake.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/run-make/linker-warning/rmake.rs b/tests/run-make/linker-warning/rmake.rs
index 9ea706af50356..b0c40dd171d34 100644
--- a/tests/run-make/linker-warning/rmake.rs
+++ b/tests/run-make/linker-warning/rmake.rs
@@ -61,7 +61,6 @@ fn main() {
         diff()
             .expected_file("short-error.txt")
             .actual_text("(linker error)", out.stderr())
-            .normalize(r#"/rustc[^/_-]*/"#, "/rustc/")
             .normalize("libpanic_abort", "libpanic_unwind")
             .normalize(
                 regex::escape(

From 61792afab930c9726e11bf838999bfa1e5f6caad Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Lauren=C8=9Biu=20Nicola?= <lnicola@dend.ro>
Date: Thu, 25 Sep 2025 10:19:23 +0300
Subject: [PATCH 1372/1889] Also install rustfmt on stable

---
 src/tools/rust-analyzer/.github/workflows/ci.yaml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/tools/rust-analyzer/.github/workflows/ci.yaml b/src/tools/rust-analyzer/.github/workflows/ci.yaml
index 770652494f4a8..e87ece5b6524c 100644
--- a/src/tools/rust-analyzer/.github/workflows/ci.yaml
+++ b/src/tools/rust-analyzer/.github/workflows/ci.yaml
@@ -98,9 +98,9 @@ jobs:
         run: |
           rustup update --no-self-update stable
           rustup default stable
-          rustup component add --toolchain stable rust-src clippy
-          # We always use a nightly rustfmt, regardless of channel, because we need
-          # --file-lines.
+          rustup component add --toolchain stable rust-src clippy rustfmt
+          # We also install a nightly rustfmt, because we use `--file-lines` in
+          # a test.
           rustup toolchain install nightly --profile minimal --component rustfmt
       # https://github.com/actions-rust-lang/setup-rust-toolchain/blob/main/rust.json
       - name: Install Rust Problem Matcher

From 932f3a8ecd0158fcb70a54c8591dec70e43b53d8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Thu, 25 Sep 2025 09:29:10 +0200
Subject: [PATCH 1373/1889] rustdoc: Fix documentation for
 `--doctest-build-arg`

---
 src/doc/rustdoc/src/unstable-features.md | 26 +++++-------------------
 1 file changed, 5 insertions(+), 21 deletions(-)

diff --git a/src/doc/rustdoc/src/unstable-features.md b/src/doc/rustdoc/src/unstable-features.md
index 25c929a1dbada..4327a80cd0832 100644
--- a/src/doc/rustdoc/src/unstable-features.md
+++ b/src/doc/rustdoc/src/unstable-features.md
@@ -739,7 +739,7 @@ This flag can be passed multiple times to nest wrappers.
 
 ## Passing arguments to rustc when compiling doctests
 
-You can use the `--doctest-compilation-args` flag if you want to add options when compiling the
+You can use the `--doctest-build-arg` flag if you want to add options when compiling the
 doctest. For example if you have:
 
 ```rust,no_run
@@ -784,10 +784,10 @@ failures:
 test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.03s
 ```
 
-But if you can limit the lint level to warning by using `--doctest_compilation_args=--cap-lints=warn`:
+But if you can limit the lint level to warning by using `--doctest-build-arg=--cap-lints=warn`:
 
 ```console
-$ rustdoc --test --doctest_compilation_args=--cap-lints=warn file.rs
+$ rustdoc --test --doctest-build-arg=--cap-lints=warn file.rs
 
 running 1 test
 test tests/rustdoc-ui/doctest/rustflags.rs - Bar (line 5) ... ok
@@ -795,24 +795,8 @@ test tests/rustdoc-ui/doctest/rustflags.rs - Bar (line 5) ... ok
 test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.06s
 ```
 
-The parsing of arguments works as follows: if it encounters a `"` or a `'`, it will continue
-until it finds the character unescaped (without a prepending `\`). If not inside a string, a
-whitespace character will also split arguments. Example:
-
-```text
-"hello 'a'\" ok" how are   'you today?'
-```
-
-will be split as follows:
-
-```text
-[
-    "hello 'a'\" ok",
-    "how",
-    "are",
-    "you today?",
-]
-```
+In order to pass multiple arguments to the underlying compiler,
+pass `--doctest-build-arg ARG` for each argument `ARG`.
 
 ## `--generate-macro-expansion`: Generate macros expansion toggles in source code
 

From 13d512f2d57a4ad1b97cb0f543b3d85c4cbd1962 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Lauren=C8=9Biu=20Nicola?= <lnicola@dend.ro>
Date: Thu, 25 Sep 2025 10:54:58 +0300
Subject: [PATCH 1374/1889] Install cargo for proc-macro-srv tests

---
 src/tools/rust-analyzer/.github/workflows/ci.yaml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/.github/workflows/ci.yaml b/src/tools/rust-analyzer/.github/workflows/ci.yaml
index e87ece5b6524c..0eb57a605f828 100644
--- a/src/tools/rust-analyzer/.github/workflows/ci.yaml
+++ b/src/tools/rust-analyzer/.github/workflows/ci.yaml
@@ -56,8 +56,8 @@ jobs:
       # Install a pinned rustc commit to avoid surprises
       - name: Install Rust toolchain
         run: |
-          RUSTC_VERSION=`cat rust-version`
-          rustup-toolchain-install-master ${RUSTC_VERSION} -c rust-src -c rustfmt
+          RUSTC_VERSION=$(cat rust-version)
+          rustup-toolchain-install-master ${RUSTC_VERSION} -c cargo -c rust-src -c rustfmt
           rustup default ${RUSTC_VERSION}
 
       # Emulate a nightly toolchain, because the toolchain installed above does not have "nightly"

From d226e7aa93425ba2090f423642341a99ab047838 Mon Sep 17 00:00:00 2001
From: Nikita Popov <npopov@redhat.com>
Date: Fri, 19 Sep 2025 14:53:16 +0200
Subject: [PATCH 1375/1889] Use standard attribute logic for allocator shim

Use llfn_attrs_from_instance() to generate the attributes for the
allocator shim. This ensures that we generate all the usual
attributes (and don't get to find out one-by-one that a certain
attribute is important for a certain target). Additionally this
will enable emitting the allocator-specific attributes (not
included here).

This change is quite awkward because the allocator shim uses
SimpleCx, while llfn_attrs_from_instance uses CodegenCx. I've
switched it to use SimpleCx plus tcx/sess arguments where necessary.
If there's a simpler way to do this, I'd love to know about it...
---
 compiler/rustc_codegen_llvm/src/abi.rs        |   8 +-
 compiler/rustc_codegen_llvm/src/allocator.rs  |  25 +--
 compiler/rustc_codegen_llvm/src/attributes.rs | 191 ++++++++++--------
 compiler/rustc_codegen_llvm/src/base.rs       |   2 +-
 compiler/rustc_codegen_llvm/src/builder.rs    |   2 +-
 compiler/rustc_codegen_llvm/src/context.rs    |  10 +-
 compiler/rustc_codegen_llvm/src/declare.rs    |   2 +-
 7 files changed, 126 insertions(+), 114 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/abi.rs b/compiler/rustc_codegen_llvm/src/abi.rs
index 11be704116790..861227f7c2a70 100644
--- a/compiler/rustc_codegen_llvm/src/abi.rs
+++ b/compiler/rustc_codegen_llvm/src/abi.rs
@@ -538,7 +538,13 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
 
         // If the declaration has an associated instance, compute extra attributes based on that.
         if let Some(instance) = instance {
-            llfn_attrs_from_instance(cx, llfn, instance);
+            llfn_attrs_from_instance(
+                cx,
+                cx.tcx,
+                llfn,
+                &cx.tcx.codegen_instance_attrs(instance.def),
+                Some(instance),
+            );
         }
     }
 
diff --git a/compiler/rustc_codegen_llvm/src/allocator.rs b/compiler/rustc_codegen_llvm/src/allocator.rs
index df3e49279d976..abd6312039733 100644
--- a/compiler/rustc_codegen_llvm/src/allocator.rs
+++ b/compiler/rustc_codegen_llvm/src/allocator.rs
@@ -5,15 +5,16 @@ use rustc_ast::expand::allocator::{
 };
 use rustc_codegen_ssa::traits::BaseTypeCodegenMethods as _;
 use rustc_middle::bug;
+use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrs;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::config::{DebugInfo, OomStrategy};
 use rustc_symbol_mangling::mangle_internal_symbol;
-use smallvec::SmallVec;
 
+use crate::attributes::llfn_attrs_from_instance;
 use crate::builder::SBuilder;
 use crate::declare::declare_simple_fn;
 use crate::llvm::{self, FALSE, TRUE, Type, Value};
-use crate::{SimpleCx, attributes, debuginfo, llvm_util};
+use crate::{SimpleCx, attributes, debuginfo};
 
 pub(crate) unsafe fn codegen(
     tcx: TyCtxt<'_>,
@@ -149,18 +150,8 @@ fn create_wrapper_function(
         ty,
     );
 
-    let mut attrs = SmallVec::<[_; 2]>::new();
-
-    let target_cpu = llvm_util::target_cpu(tcx.sess);
-    let target_cpu_attr = llvm::CreateAttrStringValue(cx.llcx, "target-cpu", target_cpu);
-
-    let tune_cpu_attr = llvm_util::tune_cpu(tcx.sess)
-        .map(|tune_cpu| llvm::CreateAttrStringValue(cx.llcx, "tune-cpu", tune_cpu));
-
-    attrs.push(target_cpu_attr);
-    attrs.extend(tune_cpu_attr);
-
-    attributes::apply_to_llfn(llfn, llvm::AttributePlace::Function, &attrs);
+    let attrs = CodegenFnAttrs::new();
+    llfn_attrs_from_instance(cx, tcx, llfn, &attrs, None);
 
     let no_return = if no_return {
         // -> ! DIFlagNoReturn
@@ -171,12 +162,6 @@ fn create_wrapper_function(
         None
     };
 
-    if tcx.sess.must_emit_unwind_tables() {
-        let uwtable =
-            attributes::uwtable_attr(cx.llcx, tcx.sess.opts.unstable_opts.use_sync_unwind);
-        attributes::apply_to_llfn(llfn, llvm::AttributePlace::Function, &[uwtable]);
-    }
-
     let llbb = unsafe { llvm::LLVMAppendBasicBlockInContext(cx.llcx, llfn, c"entry".as_ptr()) };
     let mut bx = SBuilder::build(&cx, llbb);
 
diff --git a/compiler/rustc_codegen_llvm/src/attributes.rs b/compiler/rustc_codegen_llvm/src/attributes.rs
index dcf6b9454978c..8070ea0b3e927 100644
--- a/compiler/rustc_codegen_llvm/src/attributes.rs
+++ b/compiler/rustc_codegen_llvm/src/attributes.rs
@@ -1,20 +1,21 @@
 //! Set and unset common attributes on LLVM values.
-use rustc_codegen_ssa::traits::*;
 use rustc_hir::attrs::{InlineAttr, InstructionSetAttr, OptimizeAttr};
 use rustc_hir::def_id::DefId;
-use rustc_middle::middle::codegen_fn_attrs::{CodegenFnAttrFlags, PatchableFunctionEntry};
+use rustc_middle::middle::codegen_fn_attrs::{
+    CodegenFnAttrFlags, CodegenFnAttrs, PatchableFunctionEntry,
+};
 use rustc_middle::ty::{self, TyCtxt};
 use rustc_session::config::{BranchProtection, FunctionReturn, OptLevel, PAuthKey, PacRet};
 use rustc_symbol_mangling::mangle_internal_symbol;
 use rustc_target::spec::{FramePointer, SanitizerSet, StackProbeType, StackProtector};
 use smallvec::SmallVec;
 
-use crate::context::CodegenCx;
+use crate::context::SimpleCx;
 use crate::errors::SanitizerMemtagRequiresMte;
 use crate::llvm::AttributePlace::Function;
 use crate::llvm::{self, AllocKindFlags, Attribute, AttributeKind, AttributePlace, MemoryEffects};
 use crate::value::Value;
-use crate::{attributes, llvm_util};
+use crate::{Session, attributes, llvm_util};
 
 pub(crate) fn apply_to_llfn(llfn: &Value, idx: AttributePlace, attrs: &[&Attribute]) {
     if !attrs.is_empty() {
@@ -30,18 +31,19 @@ pub(crate) fn apply_to_callsite(callsite: &Value, idx: AttributePlace, attrs: &[
 
 /// Get LLVM attribute for the provided inline heuristic.
 pub(crate) fn inline_attr<'ll, 'tcx>(
-    cx: &CodegenCx<'ll, 'tcx>,
+    cx: &SimpleCx<'ll>,
+    tcx: TyCtxt<'tcx>,
     instance: ty::Instance<'tcx>,
 ) -> Option<&'ll Attribute> {
     // `optnone` requires `noinline`
-    let codegen_fn_attrs = cx.tcx.codegen_fn_attrs(instance.def_id());
+    let codegen_fn_attrs = tcx.codegen_fn_attrs(instance.def_id());
     let inline = match (codegen_fn_attrs.inline, &codegen_fn_attrs.optimize) {
         (_, OptimizeAttr::DoNotOptimize) => InlineAttr::Never,
-        (InlineAttr::None, _) if instance.def.requires_inline(cx.tcx) => InlineAttr::Hint,
+        (InlineAttr::None, _) if instance.def.requires_inline(tcx) => InlineAttr::Hint,
         (inline, _) => inline,
     };
 
-    if !cx.tcx.sess.opts.unstable_opts.inline_llvm {
+    if !tcx.sess.opts.unstable_opts.inline_llvm {
         // disable LLVM inlining
         return Some(AttributeKind::NoInline.create_attr(cx.llcx));
     }
@@ -51,7 +53,7 @@ pub(crate) fn inline_attr<'ll, 'tcx>(
             Some(AttributeKind::AlwaysInline.create_attr(cx.llcx))
         }
         InlineAttr::Never => {
-            if cx.sess().target.arch != "amdgpu" {
+            if tcx.sess.target.arch != "amdgpu" {
                 Some(AttributeKind::NoInline.create_attr(cx.llcx))
             } else {
                 None
@@ -63,12 +65,13 @@ pub(crate) fn inline_attr<'ll, 'tcx>(
 
 #[inline]
 fn patchable_function_entry_attrs<'ll>(
-    cx: &CodegenCx<'ll, '_>,
+    cx: &SimpleCx<'ll>,
+    sess: &Session,
     attr: Option<PatchableFunctionEntry>,
 ) -> SmallVec<[&'ll Attribute; 2]> {
     let mut attrs = SmallVec::new();
     let patchable_spec = attr.unwrap_or_else(|| {
-        PatchableFunctionEntry::from_config(cx.tcx.sess.opts.unstable_opts.patchable_function_entry)
+        PatchableFunctionEntry::from_config(sess.opts.unstable_opts.patchable_function_entry)
     });
     let entry = patchable_spec.entry();
     let prefix = patchable_spec.prefix();
@@ -91,12 +94,13 @@ fn patchable_function_entry_attrs<'ll>(
 
 /// Get LLVM sanitize attributes.
 #[inline]
-pub(crate) fn sanitize_attrs<'ll>(
-    cx: &CodegenCx<'ll, '_>,
+pub(crate) fn sanitize_attrs<'ll, 'tcx>(
+    cx: &SimpleCx<'ll>,
+    tcx: TyCtxt<'tcx>,
     no_sanitize: SanitizerSet,
 ) -> SmallVec<[&'ll Attribute; 4]> {
     let mut attrs = SmallVec::new();
-    let enabled = cx.tcx.sess.opts.unstable_opts.sanitizer - no_sanitize;
+    let enabled = tcx.sess.opts.unstable_opts.sanitizer - no_sanitize;
     if enabled.contains(SanitizerSet::ADDRESS) || enabled.contains(SanitizerSet::KERNELADDRESS) {
         attrs.push(llvm::AttributeKind::SanitizeAddress.create_attr(cx.llcx));
     }
@@ -114,11 +118,11 @@ pub(crate) fn sanitize_attrs<'ll>(
     }
     if enabled.contains(SanitizerSet::MEMTAG) {
         // Check to make sure the mte target feature is actually enabled.
-        let features = cx.tcx.global_backend_features(());
+        let features = tcx.global_backend_features(());
         let mte_feature =
             features.iter().map(|s| &s[..]).rfind(|n| ["+mte", "-mte"].contains(&&n[..]));
         if let None | Some("-mte") = mte_feature {
-            cx.tcx.dcx().emit_err(SanitizerMemtagRequiresMte);
+            tcx.dcx().emit_err(SanitizerMemtagRequiresMte);
         }
 
         attrs.push(llvm::AttributeKind::SanitizeMemTag.create_attr(cx.llcx));
@@ -139,9 +143,12 @@ pub(crate) fn uwtable_attr(llcx: &llvm::Context, use_sync_unwind: Option<bool>)
     llvm::CreateUWTableAttr(llcx, async_unwind)
 }
 
-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;
+pub(crate) fn frame_pointer_type_attr<'ll>(
+    cx: &SimpleCx<'ll>,
+    sess: &Session,
+) -> Option<&'ll Attribute> {
+    let mut fp = sess.target.frame_pointer;
+    let opts = &sess.opts;
     // "mcount" function relies on stack pointer.
     // See <https://sourceware.org/binutils/docs/gprof/Implementation.html>.
     if opts.unstable_opts.instrument_mcount {
@@ -156,8 +163,8 @@ pub(crate) fn frame_pointer_type_attr<'ll>(cx: &CodegenCx<'ll, '_>) -> Option<&'
     Some(llvm::CreateAttrStringValue(cx.llcx, "frame-pointer", attr_value))
 }
 
-fn function_return_attr<'ll>(cx: &CodegenCx<'ll, '_>) -> Option<&'ll Attribute> {
-    let function_return_attr = match cx.sess().opts.unstable_opts.function_return {
+fn function_return_attr<'ll>(cx: &SimpleCx<'ll>, sess: &Session) -> Option<&'ll Attribute> {
+    let function_return_attr = match sess.opts.unstable_opts.function_return {
         FunctionReturn::Keep => return None,
         FunctionReturn::ThunkExtern => AttributeKind::FnRetThunkExtern,
     };
@@ -167,17 +174,20 @@ fn function_return_attr<'ll>(cx: &CodegenCx<'ll, '_>) -> Option<&'ll Attribute>
 
 /// Tell LLVM what instrument function to insert.
 #[inline]
-fn instrument_function_attr<'ll>(cx: &CodegenCx<'ll, '_>) -> SmallVec<[&'ll Attribute; 4]> {
+fn instrument_function_attr<'ll>(
+    cx: &SimpleCx<'ll>,
+    sess: &Session,
+) -> SmallVec<[&'ll Attribute; 4]> {
     let mut attrs = SmallVec::new();
-    if cx.sess().opts.unstable_opts.instrument_mcount {
+    if sess.opts.unstable_opts.instrument_mcount {
         // Similar to `clang -pg` behavior. Handled by the
         // `post-inline-ee-instrument` LLVM pass.
 
         // The function name varies on platforms.
         // See test/CodeGen/mcount.c in clang.
-        let mcount_name = match &cx.sess().target.llvm_mcount_intrinsic {
+        let mcount_name = match &sess.target.llvm_mcount_intrinsic {
             Some(llvm_mcount_intrinsic) => llvm_mcount_intrinsic.as_ref(),
-            None => cx.sess().target.mcount.as_ref(),
+            None => sess.target.mcount.as_ref(),
         };
 
         attrs.push(llvm::CreateAttrStringValue(
@@ -186,7 +196,7 @@ fn instrument_function_attr<'ll>(cx: &CodegenCx<'ll, '_>) -> SmallVec<[&'ll Attr
             mcount_name,
         ));
     }
-    if let Some(options) = &cx.sess().opts.unstable_opts.instrument_xray {
+    if let Some(options) = &sess.opts.unstable_opts.instrument_xray {
         // XRay instrumentation is similar to __cyg_profile_func_{enter,exit}.
         // Function prologue and epilogue are instrumented with NOP sleds,
         // a runtime library later replaces them with detours into tracing code.
@@ -217,20 +227,20 @@ fn instrument_function_attr<'ll>(cx: &CodegenCx<'ll, '_>) -> SmallVec<[&'ll Attr
     attrs
 }
 
-fn nojumptables_attr<'ll>(cx: &CodegenCx<'ll, '_>) -> Option<&'ll Attribute> {
-    if !cx.sess().opts.unstable_opts.no_jump_tables {
+fn nojumptables_attr<'ll>(cx: &SimpleCx<'ll>, sess: &Session) -> Option<&'ll Attribute> {
+    if !sess.opts.unstable_opts.no_jump_tables {
         return None;
     }
 
     Some(llvm::CreateAttrStringValue(cx.llcx, "no-jump-tables", "true"))
 }
 
-fn probestack_attr<'ll>(cx: &CodegenCx<'ll, '_>) -> Option<&'ll Attribute> {
+fn probestack_attr<'ll, 'tcx>(cx: &SimpleCx<'ll>, tcx: TyCtxt<'tcx>) -> Option<&'ll Attribute> {
     // Currently stack probes seem somewhat incompatible with the address
     // sanitizer and thread sanitizer. With asan we're already protected from
     // stack overflow anyway so we don't really need stack probes regardless.
-    if cx
-        .sess()
+    if tcx
+        .sess
         .opts
         .unstable_opts
         .sanitizer
@@ -240,22 +250,22 @@ fn probestack_attr<'ll>(cx: &CodegenCx<'ll, '_>) -> Option<&'ll Attribute> {
     }
 
     // probestack doesn't play nice either with `-C profile-generate`.
-    if cx.sess().opts.cg.profile_generate.enabled() {
+    if tcx.sess.opts.cg.profile_generate.enabled() {
         return None;
     }
 
-    let attr_value = match cx.sess().target.stack_probes {
+    let attr_value = match tcx.sess.target.stack_probes {
         StackProbeType::None => return None,
         // Request LLVM to generate the probes inline. If the given LLVM version does not support
         // this, no probe is generated at all (even if the attribute is specified).
         StackProbeType::Inline => "inline-asm",
         // Flag our internal `__rust_probestack` function as the stack probe symbol.
         // This is defined in the `compiler-builtins` crate for each architecture.
-        StackProbeType::Call => &mangle_internal_symbol(cx.tcx, "__rust_probestack"),
+        StackProbeType::Call => &mangle_internal_symbol(tcx, "__rust_probestack"),
         // Pick from the two above based on the LLVM version.
         StackProbeType::InlineOrCall { min_llvm_version_for_inline } => {
             if llvm_util::get_version() < min_llvm_version_for_inline {
-                &mangle_internal_symbol(cx.tcx, "__rust_probestack")
+                &mangle_internal_symbol(tcx, "__rust_probestack")
             } else {
                 "inline-asm"
             }
@@ -264,8 +274,8 @@ fn probestack_attr<'ll>(cx: &CodegenCx<'ll, '_>) -> Option<&'ll Attribute> {
     Some(llvm::CreateAttrStringValue(cx.llcx, "probe-stack", attr_value))
 }
 
-fn stackprotector_attr<'ll>(cx: &CodegenCx<'ll, '_>) -> Option<&'ll Attribute> {
-    let sspattr = match cx.sess().stack_protector() {
+fn stackprotector_attr<'ll>(cx: &SimpleCx<'ll>, sess: &Session) -> Option<&'ll Attribute> {
+    let sspattr = match sess.stack_protector() {
         StackProtector::None => return None,
         StackProtector::All => AttributeKind::StackProtectReq,
         StackProtector::Strong => AttributeKind::StackProtectStrong,
@@ -275,33 +285,34 @@ fn stackprotector_attr<'ll>(cx: &CodegenCx<'ll, '_>) -> Option<&'ll Attribute> {
     Some(sspattr.create_attr(cx.llcx))
 }
 
-fn backchain_attr<'ll>(cx: &CodegenCx<'ll, '_>) -> Option<&'ll Attribute> {
-    if cx.sess().target.arch != "s390x" {
+fn backchain_attr<'ll>(cx: &SimpleCx<'ll>, sess: &Session) -> Option<&'ll Attribute> {
+    if sess.target.arch != "s390x" {
         return None;
     }
 
-    let requested_features = cx.sess().opts.cg.target_feature.split(',');
+    let requested_features = sess.opts.cg.target_feature.split(',');
     let found_positive = requested_features.clone().any(|r| r == "+backchain");
 
     if found_positive { Some(llvm::CreateAttrString(cx.llcx, "backchain")) } else { None }
 }
 
-pub(crate) fn target_cpu_attr<'ll>(cx: &CodegenCx<'ll, '_>) -> &'ll Attribute {
-    let target_cpu = llvm_util::target_cpu(cx.tcx.sess);
+pub(crate) fn target_cpu_attr<'ll>(cx: &SimpleCx<'ll>, sess: &Session) -> &'ll Attribute {
+    let target_cpu = llvm_util::target_cpu(sess);
     llvm::CreateAttrStringValue(cx.llcx, "target-cpu", target_cpu)
 }
 
-pub(crate) fn tune_cpu_attr<'ll>(cx: &CodegenCx<'ll, '_>) -> Option<&'ll Attribute> {
-    llvm_util::tune_cpu(cx.tcx.sess)
+pub(crate) fn tune_cpu_attr<'ll>(cx: &SimpleCx<'ll>, sess: &Session) -> Option<&'ll Attribute> {
+    llvm_util::tune_cpu(sess)
         .map(|tune_cpu| llvm::CreateAttrStringValue(cx.llcx, "tune-cpu", tune_cpu))
 }
 
 /// Get the `target-features` LLVM attribute.
-pub(crate) fn target_features_attr<'ll>(
-    cx: &CodegenCx<'ll, '_>,
+pub(crate) fn target_features_attr<'ll, 'tcx>(
+    cx: &SimpleCx<'ll>,
+    tcx: TyCtxt<'tcx>,
     function_features: Vec<String>,
 ) -> Option<&'ll Attribute> {
-    let global_features = cx.tcx.global_backend_features(()).iter().map(String::as_str);
+    let global_features = tcx.global_backend_features(()).iter().map(String::as_str);
     let function_features = function_features.iter().map(String::as_str);
     let target_features =
         global_features.chain(function_features).intersperse(",").collect::<String>();
@@ -311,22 +322,22 @@ pub(crate) fn target_features_attr<'ll>(
 
 /// Get the `NonLazyBind` LLVM attribute,
 /// if the codegen options allow skipping the PLT.
-pub(crate) fn non_lazy_bind_attr<'ll>(cx: &CodegenCx<'ll, '_>) -> Option<&'ll Attribute> {
+pub(crate) fn non_lazy_bind_attr<'ll>(
+    cx: &SimpleCx<'ll>,
+    sess: &Session,
+) -> 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))
-    } else {
-        None
-    }
+    if !sess.needs_plt() { Some(AttributeKind::NonLazyBind.create_attr(cx.llcx)) } else { None }
 }
 
 /// Get the default optimizations attrs for a function.
 #[inline]
 pub(crate) fn default_optimisation_attrs<'ll>(
-    cx: &CodegenCx<'ll, '_>,
+    cx: &SimpleCx<'ll>,
+    sess: &Session,
 ) -> SmallVec<[&'ll Attribute; 2]> {
     let mut attrs = SmallVec::new();
-    match cx.sess().opts.optimize {
+    match sess.opts.optimize {
         OptLevel::Size => {
             attrs.push(llvm::AttributeKind::OptimizeForSize.create_attr(cx.llcx));
         }
@@ -347,17 +358,18 @@ fn create_alloc_family_attr(llcx: &llvm::Context) -> &llvm::Attribute {
 /// Composite function which sets LLVM attributes for function depending on its AST (`#[attribute]`)
 /// attributes.
 pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>(
-    cx: &CodegenCx<'ll, 'tcx>,
+    cx: &SimpleCx<'ll>,
+    tcx: TyCtxt<'tcx>,
     llfn: &'ll Value,
-    instance: ty::Instance<'tcx>,
+    codegen_fn_attrs: &CodegenFnAttrs,
+    instance: Option<ty::Instance<'tcx>>,
 ) {
-    let codegen_fn_attrs = cx.tcx.codegen_instance_attrs(instance.def);
-
+    let sess = tcx.sess;
     let mut to_add = SmallVec::<[_; 16]>::new();
 
     match codegen_fn_attrs.optimize {
         OptimizeAttr::Default => {
-            to_add.extend(default_optimisation_attrs(cx));
+            to_add.extend(default_optimisation_attrs(cx, sess));
         }
         OptimizeAttr::DoNotOptimize => {
             to_add.push(llvm::AttributeKind::OptimizeNone.create_attr(cx.llcx));
@@ -369,21 +381,21 @@ pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>(
         OptimizeAttr::Speed => {}
     }
 
-    if cx.sess().must_emit_unwind_tables() {
-        to_add.push(uwtable_attr(cx.llcx, cx.sess().opts.unstable_opts.use_sync_unwind));
+    if sess.must_emit_unwind_tables() {
+        to_add.push(uwtable_attr(cx.llcx, sess.opts.unstable_opts.use_sync_unwind));
     }
 
-    if cx.sess().opts.unstable_opts.profile_sample_use.is_some() {
+    if sess.opts.unstable_opts.profile_sample_use.is_some() {
         to_add.push(llvm::CreateAttrString(cx.llcx, "use-sample-profile"));
     }
 
     // FIXME: none of these functions interact with source level attributes.
-    to_add.extend(frame_pointer_type_attr(cx));
-    to_add.extend(function_return_attr(cx));
-    to_add.extend(instrument_function_attr(cx));
-    to_add.extend(nojumptables_attr(cx));
-    to_add.extend(probestack_attr(cx));
-    to_add.extend(stackprotector_attr(cx));
+    to_add.extend(frame_pointer_type_attr(cx, sess));
+    to_add.extend(function_return_attr(cx, sess));
+    to_add.extend(instrument_function_attr(cx, sess));
+    to_add.extend(nojumptables_attr(cx, sess));
+    to_add.extend(probestack_attr(cx, tcx));
+    to_add.extend(stackprotector_attr(cx, sess));
 
     if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::NO_BUILTINS) {
         to_add.push(llvm::CreateAttrString(cx.llcx, "no-builtins"));
@@ -404,13 +416,13 @@ pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>(
         // not used.
     } else {
         // Do not set sanitizer attributes for naked functions.
-        to_add.extend(sanitize_attrs(cx, codegen_fn_attrs.no_sanitize));
+        to_add.extend(sanitize_attrs(cx, tcx, codegen_fn_attrs.no_sanitize));
 
         // For non-naked functions, set branch protection attributes on aarch64.
         if let Some(BranchProtection { bti, pac_ret, gcs }) =
-            cx.sess().opts.unstable_opts.branch_protection
+            sess.opts.unstable_opts.branch_protection
         {
-            assert!(cx.sess().target.arch == "aarch64");
+            assert!(sess.target.arch == "aarch64");
             if bti {
                 to_add.push(llvm::CreateAttrString(cx.llcx, "branch-target-enforcement"));
             }
@@ -438,14 +450,15 @@ pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>(
         || codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::ALLOCATOR_ZEROED)
     {
         to_add.push(create_alloc_family_attr(cx.llcx));
-        if let Some(zv) =
-            cx.tcx.get_attr(instance.def_id(), rustc_span::sym::rustc_allocator_zeroed_variant)
+        if let Some(instance) = instance
+            && let Some(zv) =
+                tcx.get_attr(instance.def_id(), rustc_span::sym::rustc_allocator_zeroed_variant)
             && let Some(name) = zv.value_str()
         {
             to_add.push(llvm::CreateAttrStringValue(
                 cx.llcx,
                 "alloc-variant-zeroed",
-                &mangle_internal_symbol(cx.tcx, name.as_str()),
+                &mangle_internal_symbol(tcx, name.as_str()),
             ));
         }
         // apply to argument place instead of function
@@ -490,18 +503,22 @@ pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>(
     if let Some(align) = codegen_fn_attrs.alignment {
         llvm::set_alignment(llfn, align);
     }
-    if let Some(backchain) = backchain_attr(cx) {
+    if let Some(backchain) = backchain_attr(cx, sess) {
         to_add.push(backchain);
     }
-    to_add.extend(patchable_function_entry_attrs(cx, codegen_fn_attrs.patchable_function_entry));
+    to_add.extend(patchable_function_entry_attrs(
+        cx,
+        sess,
+        codegen_fn_attrs.patchable_function_entry,
+    ));
 
     // Always annotate functions with the target-cpu they are compiled for.
     // Without this, ThinLTO won't inline Rust functions into Clang generated
     // functions (because Clang annotates functions this way too).
-    to_add.push(target_cpu_attr(cx));
+    to_add.push(target_cpu_attr(cx, sess));
     // tune-cpu is only conveyed through the attribute for our purpose.
     // The target doesn't care; the subtarget reads our attribute.
-    to_add.extend(tune_cpu_attr(cx));
+    to_add.extend(tune_cpu_attr(cx, sess));
 
     let function_features =
         codegen_fn_attrs.target_features.iter().map(|f| f.name.as_str()).collect::<Vec<&str>>();
@@ -509,7 +526,9 @@ pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>(
     // Apply function attributes as per usual if there are no user defined
     // target features otherwise this will get applied at the callsite.
     if function_features.is_empty() {
-        if let Some(inline_attr) = inline_attr(cx, instance) {
+        if let Some(instance) = instance
+            && let Some(inline_attr) = inline_attr(cx, tcx, instance)
+        {
             to_add.push(inline_attr);
         }
     }
@@ -517,7 +536,7 @@ pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>(
     let function_features = function_features
         .iter()
         // Convert to LLVMFeatures and filter out unavailable ones
-        .flat_map(|feat| llvm_util::to_llvm_features(cx.tcx.sess, feat))
+        .flat_map(|feat| llvm_util::to_llvm_features(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 {
@@ -526,20 +545,22 @@ pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>(
         }))
         .collect::<Vec<String>>();
 
-    if cx.tcx.sess.target.is_like_wasm {
+    if sess.target.is_like_wasm {
         // If this function is an import from the environment but the wasm
         // import has a specific module/name, apply them here.
-        if let Some(module) = wasm_import_module(cx.tcx, instance.def_id()) {
+        if let Some(instance) = instance
+            && let Some(module) = wasm_import_module(tcx, instance.def_id())
+        {
             to_add.push(llvm::CreateAttrStringValue(cx.llcx, "wasm-import-module", module));
 
             let name =
-                codegen_fn_attrs.symbol_name.unwrap_or_else(|| cx.tcx.item_name(instance.def_id()));
+                codegen_fn_attrs.symbol_name.unwrap_or_else(|| tcx.item_name(instance.def_id()));
             let name = name.as_str();
             to_add.push(llvm::CreateAttrStringValue(cx.llcx, "wasm-import-name", name));
         }
     }
 
-    to_add.extend(target_features_attr(cx, function_features));
+    to_add.extend(target_features_attr(cx, tcx, function_features));
 
     attributes::apply_to_llfn(llfn, Function, &to_add);
 }
diff --git a/compiler/rustc_codegen_llvm/src/base.rs b/compiler/rustc_codegen_llvm/src/base.rs
index 978134cc32b1c..6d12b511e9c81 100644
--- a/compiler/rustc_codegen_llvm/src/base.rs
+++ b/compiler/rustc_codegen_llvm/src/base.rs
@@ -105,7 +105,7 @@ pub(crate) fn compile_codegen_unit(
             if let Some(entry) =
                 maybe_create_entry_wrapper::<Builder<'_, '_, '_>>(&cx, cx.codegen_unit)
             {
-                let attrs = attributes::sanitize_attrs(&cx, SanitizerSet::empty());
+                let attrs = attributes::sanitize_attrs(&cx, tcx, SanitizerSet::empty());
                 attributes::apply_to_llfn(entry, llvm::AttributePlace::Function, &attrs);
             }
 
diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
index 0f17cc9063a87..a4dc4eb532f95 100644
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -1433,7 +1433,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
                 // If there is an inline attribute and a target feature that matches
                 // we will add the attribute to the callsite otherwise we'll omit
                 // this and not add the attribute to prevent soundness issues.
-                && let Some(inlining_rule) = attributes::inline_attr(&self.cx, instance)
+                && let Some(inlining_rule) = attributes::inline_attr(&self.cx, self.cx.tcx, instance)
                 && self.cx.tcx.is_target_feature_call_safe(
                     &fn_call_attrs.target_features,
                     &fn_defn_attrs.target_features,
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index 057f525c76f03..2478042a2e62f 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -876,7 +876,7 @@ impl<'ll, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
                 } else {
                     let fty = self.type_variadic_func(&[], self.type_i32());
                     let llfn = self.declare_cfn(name, llvm::UnnamedAddr::Global, fty);
-                    let target_cpu = attributes::target_cpu_attr(self);
+                    let target_cpu = attributes::target_cpu_attr(self, self.sess());
                     attributes::apply_to_llfn(llfn, llvm::AttributePlace::Function, &[target_cpu]);
                     llfn
                 }
@@ -891,15 +891,15 @@ impl<'ll, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
     }
 
     fn set_frame_pointer_type(&self, llfn: &'ll Value) {
-        if let Some(attr) = attributes::frame_pointer_type_attr(self) {
+        if let Some(attr) = attributes::frame_pointer_type_attr(self, self.sess()) {
             attributes::apply_to_llfn(llfn, llvm::AttributePlace::Function, &[attr]);
         }
     }
 
     fn apply_target_cpu_attr(&self, llfn: &'ll Value) {
         let mut attrs = SmallVec::<[_; 2]>::new();
-        attrs.push(attributes::target_cpu_attr(self));
-        attrs.extend(attributes::tune_cpu_attr(self));
+        attrs.push(attributes::target_cpu_attr(self, self.sess()));
+        attrs.extend(attributes::tune_cpu_attr(self, self.sess()));
         attributes::apply_to_llfn(llfn, llvm::AttributePlace::Function, &attrs);
     }
 
@@ -918,7 +918,7 @@ impl<'ll, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
             attributes::apply_to_llfn(
                 llfn,
                 llvm::AttributePlace::Function,
-                attributes::target_features_attr(self, vec![]).as_slice(),
+                attributes::target_features_attr(self, self.tcx, vec![]).as_slice(),
             );
             Some(llfn)
         } else {
diff --git a/compiler/rustc_codegen_llvm/src/declare.rs b/compiler/rustc_codegen_llvm/src/declare.rs
index 960a895a2031c..36cdb49883957 100644
--- a/compiler/rustc_codegen_llvm/src/declare.rs
+++ b/compiler/rustc_codegen_llvm/src/declare.rs
@@ -76,7 +76,7 @@ pub(crate) fn declare_raw_fn<'ll, 'tcx>(
         attrs.push(llvm::AttributeKind::NoRedZone.create_attr(cx.llcx));
     }
 
-    attrs.extend(attributes::non_lazy_bind_attr(cx));
+    attrs.extend(attributes::non_lazy_bind_attr(cx, cx.tcx.sess));
 
     attributes::apply_to_llfn(llfn, Function, &attrs);
 

From 85018f09f67bd54868fe12a4632bbd637a474853 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Thu, 25 Sep 2025 18:10:55 +1000
Subject: [PATCH 1376/1889] Use `LLVMDisposeTargetMachine`

---
 compiler/rustc_codegen_llvm/src/back/owned_target_machine.rs | 4 +---
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs                  | 3 ++-
 compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp             | 4 ----
 3 files changed, 3 insertions(+), 8 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/back/owned_target_machine.rs b/compiler/rustc_codegen_llvm/src/back/owned_target_machine.rs
index d5228f0e0dee1..903a882916ee8 100644
--- a/compiler/rustc_codegen_llvm/src/back/owned_target_machine.rs
+++ b/compiler/rustc_codegen_llvm/src/back/owned_target_machine.rs
@@ -95,8 +95,6 @@ impl Drop for OwnedTargetMachine {
         // SAFETY: constructing ensures we have a valid pointer created by
         // llvm::LLVMRustCreateTargetMachine OwnedTargetMachine is not copyable so there is no
         // double free or use after free.
-        unsafe {
-            llvm::LLVMRustDisposeTargetMachine(self.tm_unique.as_ptr());
-        }
+        unsafe { llvm::LLVMDisposeTargetMachine(self.tm_unique) };
     }
 }
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index fd972f371df49..38a6a31195438 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -1053,6 +1053,8 @@ unsafe extern "C" {
         SLen: c_uint,
     ) -> MetadataKindId;
 
+    pub(crate) fn LLVMDisposeTargetMachine(T: ptr::NonNull<TargetMachine>);
+
     // Create modules.
     pub(crate) fn LLVMModuleCreateWithNameInContext(
         ModuleID: *const c_char,
@@ -2499,7 +2501,6 @@ unsafe extern "C" {
         UseWasmEH: bool,
     ) -> *mut TargetMachine;
 
-    pub(crate) fn LLVMRustDisposeTargetMachine(T: *mut TargetMachine);
     pub(crate) fn LLVMRustAddLibraryInfo<'a>(
         PM: &PassManager<'a>,
         M: &'a Module,
diff --git a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
index 7518b40799bc1..013d68fa3e485 100644
--- a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
@@ -359,10 +359,6 @@ extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
   return wrap(TM);
 }
 
-extern "C" void LLVMRustDisposeTargetMachine(LLVMTargetMachineRef TM) {
-  delete unwrap(TM);
-}
-
 // Unfortunately, the LLVM C API doesn't provide a way to create the
 // TargetLibraryInfo pass, so we use this method to do so.
 extern "C" void LLVMRustAddLibraryInfo(LLVMPassManagerRef PMR, LLVMModuleRef M,

From 88e797784e21ecad4dc768109ede33c76293482e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Sun, 14 Sep 2025 01:12:34 +0200
Subject: [PATCH 1377/1889] rustdoc: Slightly clean up attr rendering

---
 src/librustdoc/html/render/mod.rs        | 145 ++++++++---------------
 src/librustdoc/html/render/print_item.rs |   8 +-
 2 files changed, 56 insertions(+), 97 deletions(-)

diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index cc2744e48c8f6..4b7822cd3a9f9 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -53,6 +53,7 @@ use rustc_ast::join_path_syms;
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_hir as hir;
 use rustc_hir::attrs::{AttributeKind, DeprecatedSince, Deprecation};
+use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, DefIdSet};
 use rustc_hir::{ConstStability, Mutability, RustcVersion, StabilityLevel, StableSince};
 use rustc_middle::ty::print::PrintTraitRefExt;
@@ -2924,99 +2925,56 @@ fn render_call_locations<W: fmt::Write>(
     w.write_str("</div>")
 }
 
-struct CodeAttribute(String);
-
-fn render_code_attribute(prefix: &str, code_attr: CodeAttribute, w: &mut impl fmt::Write) {
-    write!(
-        w,
-        "<div class=\"code-attribute\">{prefix}{attr}</div>",
-        prefix = prefix,
-        attr = code_attr.0
-    )
-    .unwrap();
-}
-
-// When an attribute is rendered inside a <code> tag, it is formatted using
-// a div to produce a newline after it.
 fn render_attributes_in_code(
     w: &mut impl fmt::Write,
     item: &clean::Item,
     prefix: &str,
     cx: &Context<'_>,
 ) {
-    for attr in attributes(item, cx.tcx(), cx.cache()) {
-        render_code_attribute(prefix, CodeAttribute(attr), w);
+    for attr in &item.attrs.other_attrs {
+        let hir::Attribute::Parsed(kind) = attr else { continue };
+        let attr = match kind {
+            AttributeKind::LinkSection { name, .. } => {
+                Cow::Owned(format!("#[unsafe(link_section = \"{name}\")]"))
+            }
+            AttributeKind::NoMangle(..) => Cow::Borrowed("#[unsafe(no_mangle)]"),
+            AttributeKind::ExportName { name, .. } => {
+                Cow::Owned(format!("#[unsafe(export_name = \"{name}\")]"))
+            }
+            AttributeKind::NonExhaustive(..) => Cow::Borrowed("#[non_exhaustive]"),
+            _ => continue,
+        };
+        render_code_attribute(prefix, attr.as_ref(), w);
     }
-}
 
-/// used for type aliases to only render their `repr` attribute.
-fn render_repr_attributes_in_code(
-    w: &mut impl fmt::Write,
-    cx: &Context<'_>,
-    def_id: DefId,
-    item_type: ItemType,
-) {
-    if let Some(repr) = repr_attributes(cx.tcx(), cx.cache(), def_id, item_type) {
-        render_code_attribute("", CodeAttribute(repr), w);
+    if let Some(def_id) = item.def_id()
+        && let Some(repr) = repr_attribute(cx.tcx(), cx.cache(), def_id)
+    {
+        render_code_attribute(prefix, &repr, w);
     }
 }
 
-/// Get a list of attributes excluding `#[repr]` to display.
-fn attributes_without_repr(item: &clean::Item) -> Vec<String> {
-    item.attrs
-        .other_attrs
-        .iter()
-        .filter_map(|attr| match attr {
-            hir::Attribute::Parsed(AttributeKind::LinkSection { name, .. }) => {
-                Some(format!("#[unsafe(link_section = \"{name}\")]"))
-            }
-            hir::Attribute::Parsed(AttributeKind::NoMangle(..)) => {
-                Some("#[unsafe(no_mangle)]".to_string())
-            }
-            hir::Attribute::Parsed(AttributeKind::ExportName { name, .. }) => {
-                Some(format!("#[unsafe(export_name = \"{name}\")]"))
-            }
-            hir::Attribute::Parsed(AttributeKind::NonExhaustive(..)) => {
-                Some("#[non_exhaustive]".to_string())
-            }
-            _ => None,
-        })
-        .collect()
-}
-
-/// Get a list of attributes to display on this item.
-fn attributes(item: &clean::Item, tcx: TyCtxt<'_>, cache: &Cache) -> Vec<String> {
-    let mut attrs = attributes_without_repr(item);
-
-    if let Some(repr_attr) = repr(item, tcx, cache) {
-        attrs.push(repr_attr);
+fn render_repr_attribute_in_code(w: &mut impl fmt::Write, cx: &Context<'_>, def_id: DefId) {
+    if let Some(repr) = repr_attribute(cx.tcx(), cx.cache(), def_id) {
+        render_code_attribute("", &repr, w);
     }
-    attrs
 }
 
-/// Returns a stringified `#[repr(...)]` attribute.
-fn repr(item: &clean::Item, tcx: TyCtxt<'_>, cache: &Cache) -> Option<String> {
-    repr_attributes(tcx, cache, item.def_id()?, item.type_())
+fn render_code_attribute(prefix: &str, attr: &str, w: &mut impl fmt::Write) {
+    write!(w, "<div class=\"code-attribute\">{prefix}{attr}</div>").unwrap();
 }
 
-/// Return a string representing the `#[repr]` attribute if present.
-pub(crate) fn repr_attributes(
-    tcx: TyCtxt<'_>,
+fn repr_attribute<'tcx>(
+    tcx: TyCtxt<'tcx>,
     cache: &Cache,
     def_id: DefId,
-    item_type: ItemType,
-) -> Option<String> {
-    use rustc_abi::IntegerType;
-
-    if !matches!(item_type, ItemType::Struct | ItemType::Enum | ItemType::Union) {
-        return None;
-    }
-    let adt = tcx.adt_def(def_id);
+) -> Option<Cow<'static, str>> {
+    let adt = match tcx.def_kind(def_id) {
+        DefKind::Struct | DefKind::Enum | DefKind::Union => tcx.adt_def(def_id),
+        _ => return None,
+    };
     let repr = adt.repr();
-    let mut out = Vec::new();
-    if repr.c() {
-        out.push("C");
-    }
+
     if repr.transparent() {
         // Render `repr(transparent)` iff the non-1-ZST field is public or at least one
         // field is public in case all fields are 1-ZST fields.
@@ -3033,34 +2991,35 @@ pub(crate) fn repr_attributes(
                     |field| field.vis.is_public(),
                 );
 
-        if render_transparent {
-            out.push("transparent");
-        }
+        // Since the transparent repr can't have any other reprs or
+        // repr modifiers beside it, we can safely return early here.
+        return render_transparent.then(|| "#[repr(transparent)]".into());
+    }
+
+    let mut result = Vec::<Cow<'_, _>>::new();
+
+    if repr.c() {
+        result.push("C".into());
     }
     if repr.simd() {
-        out.push("simd");
+        result.push("simd".into());
     }
-    let pack_s;
     if let Some(pack) = repr.pack {
-        pack_s = format!("packed({})", pack.bytes());
-        out.push(&pack_s);
+        result.push(format!("packed({})", pack.bytes()).into());
     }
-    let align_s;
     if let Some(align) = repr.align {
-        align_s = format!("align({})", align.bytes());
-        out.push(&align_s);
+        result.push(format!("align({})", align.bytes()).into());
     }
-    let int_s;
     if let Some(int) = repr.int {
-        int_s = match int {
-            IntegerType::Pointer(is_signed) => {
-                format!("{}size", if is_signed { 'i' } else { 'u' })
-            }
-            IntegerType::Fixed(size, is_signed) => {
-                format!("{}{}", if is_signed { 'i' } else { 'u' }, size.size().bytes() * 8)
+        let prefix = if int.is_signed() { 'i' } else { 'u' };
+        let int = match int {
+            rustc_abi::IntegerType::Pointer(_) => format!("{prefix}size"),
+            rustc_abi::IntegerType::Fixed(int, _) => {
+                format!("{prefix}{}", int.size().bytes() * 8)
             }
         };
-        out.push(&int_s);
+        result.push(int.into());
     }
-    if !out.is_empty() { Some(format!("#[repr({})]", out.join(", "))) } else { None }
+
+    (!result.is_empty()).then(|| format!("#[repr({})]", result.join(", ")).into())
 }
diff --git a/src/librustdoc/html/render/print_item.rs b/src/librustdoc/html/render/print_item.rs
index afa438f259690..adfc7481c73ae 100644
--- a/src/librustdoc/html/render/print_item.rs
+++ b/src/librustdoc/html/render/print_item.rs
@@ -21,7 +21,7 @@ use super::{
     collect_paths_for_type, document, ensure_trailing_slash, get_filtered_impls_for_reference,
     item_ty_to_section, notable_traits_button, notable_traits_json, render_all_impls,
     render_assoc_item, render_assoc_items, render_attributes_in_code, render_impl,
-    render_repr_attributes_in_code, render_rightside, render_stability_since_raw,
+    render_repr_attribute_in_code, render_rightside, render_stability_since_raw,
     render_stability_since_raw_with_extra, write_section_heading,
 };
 use crate::clean;
@@ -1555,7 +1555,7 @@ impl<'clean> DisplayEnum<'clean> {
         wrap_item(w, |w| {
             if is_type_alias {
                 // For now the only attributes we render for type aliases are `repr` attributes.
-                render_repr_attributes_in_code(w, cx, self.def_id, ItemType::Enum);
+                render_repr_attribute_in_code(w, cx, self.def_id);
             } else {
                 render_attributes_in_code(w, it, "", cx);
             }
@@ -2017,7 +2017,7 @@ impl<'a> DisplayStruct<'a> {
         wrap_item(w, |w| {
             if is_type_alias {
                 // For now the only attributes we render for type aliases are `repr` attributes.
-                render_repr_attributes_in_code(w, cx, self.def_id, ItemType::Struct);
+                render_repr_attribute_in_code(w, cx, self.def_id);
             } else {
                 render_attributes_in_code(w, it, "", cx);
             }
@@ -2371,7 +2371,7 @@ fn render_union(
     fmt::from_fn(move |mut f| {
         if is_type_alias {
             // For now the only attributes we render for type aliases are `repr` attributes.
-            render_repr_attributes_in_code(f, cx, def_id, ItemType::Union);
+            render_repr_attribute_in_code(f, cx, def_id);
         } else {
             render_attributes_in_code(f, it, "", cx);
         }

From d7d7725b8cbeea8db490c3b033773776ce8794f5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Sun, 14 Sep 2025 01:32:20 +0200
Subject: [PATCH 1378/1889] rustdoc: Fully escape link section and export name

Escape "special characters" (e.g., double quotes `"` and line breaks `\n`).
Escape HTML.

Lastly, add regression tests and clean up existing tests.
---
 src/librustdoc/html/render/mod.rs             |  4 ++--
 tests/rustdoc/attribute-rendering.rs          |  8 --------
 tests/rustdoc/attributes.rs                   | 12 +++++++++++
 tests/rustdoc/inline_cross/attributes.rs      | 17 ++++++++++++++--
 .../inline_cross/auxiliary/attributes.rs      |  9 +++++++++
 .../reexport/auxiliary/reexports-attrs.rs     | 14 -------------
 tests/rustdoc/reexport/reexport-attrs.rs      | 20 -------------------
 7 files changed, 38 insertions(+), 46 deletions(-)
 delete mode 100644 tests/rustdoc/attribute-rendering.rs
 delete mode 100644 tests/rustdoc/reexport/auxiliary/reexports-attrs.rs
 delete mode 100644 tests/rustdoc/reexport/reexport-attrs.rs

diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index 4b7822cd3a9f9..9280701ea3f8b 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -2935,11 +2935,11 @@ fn render_attributes_in_code(
         let hir::Attribute::Parsed(kind) = attr else { continue };
         let attr = match kind {
             AttributeKind::LinkSection { name, .. } => {
-                Cow::Owned(format!("#[unsafe(link_section = \"{name}\")]"))
+                Cow::Owned(format!("#[unsafe(link_section = {})]", Escape(&format!("{name:?}"))))
             }
             AttributeKind::NoMangle(..) => Cow::Borrowed("#[unsafe(no_mangle)]"),
             AttributeKind::ExportName { name, .. } => {
-                Cow::Owned(format!("#[unsafe(export_name = \"{name}\")]"))
+                Cow::Owned(format!("#[unsafe(export_name = {})]", Escape(&format!("{name:?}"))))
             }
             AttributeKind::NonExhaustive(..) => Cow::Borrowed("#[non_exhaustive]"),
             _ => continue,
diff --git a/tests/rustdoc/attribute-rendering.rs b/tests/rustdoc/attribute-rendering.rs
deleted file mode 100644
index fb40d0a9887cf..0000000000000
--- a/tests/rustdoc/attribute-rendering.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-#![crate_name = "foo"]
-
-//@ has 'foo/fn.f.html'
-//@ has - //*[@'class="code-attribute"]' '#[unsafe(export_name = "f")]'
-//@ has - //*[@'class="rust item-decl"]' 'pub fn f()'
-#[unsafe(export_name = "\
-f")]
-pub fn f() {}
diff --git a/tests/rustdoc/attributes.rs b/tests/rustdoc/attributes.rs
index 33e4e31bec6e3..429a42a7252cd 100644
--- a/tests/rustdoc/attributes.rs
+++ b/tests/rustdoc/attributes.rs
@@ -9,6 +9,18 @@ pub extern "C" fn f() {}
 #[unsafe(export_name = "bar")]
 pub extern "C" fn g() {}
 
+//@ has foo/fn.escape_special.html '//*[@class="code-attribute"]' \
+//                                 '#[unsafe(export_name = "\n\"\n")]'
+#[unsafe(export_name = "\n\"
+")]
+pub extern "C" fn escape_special() {}
+
+// issue: <https://github.com/rust-lang/rust/issues/142835>
+//@ has foo/fn.escape_html.html '//*[@class="code-attribute"]' \
+//                              '#[unsafe(export_name = "<script>alert()</script>")]'
+#[unsafe(export_name = "<script>alert()</script>")]
+pub extern "C" fn escape_html() {}
+
 //@ has foo/fn.example.html '//*[@class="code-attribute"]' '#[unsafe(link_section = ".text")]'
 #[unsafe(link_section = ".text")]
 pub extern "C" fn example() {}
diff --git a/tests/rustdoc/inline_cross/attributes.rs b/tests/rustdoc/inline_cross/attributes.rs
index 4747f8ad67c1f..1657b7bdc8f77 100644
--- a/tests/rustdoc/inline_cross/attributes.rs
+++ b/tests/rustdoc/inline_cross/attributes.rs
@@ -1,7 +1,20 @@
+// Ensure that we render attributes on inlined cross-crate re-exported items.
+// issue: <https://github.com/rust-lang/rust/issues/144004>
+
 //@ aux-crate:attributes=attributes.rs
 //@ edition:2021
 #![crate_name = "user"]
 
-//@ has 'user/struct.NonExhaustive.html'
-//@ has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[non_exhaustive]'
+//@ has 'user/fn.no_mangle.html' '//pre[@class="rust item-decl"]' '#[unsafe(no_mangle)]'
+pub use attributes::no_mangle;
+
+//@ has 'user/fn.link_section.html' '//pre[@class="rust item-decl"]' \
+//                                  '#[unsafe(link_section = ".here")]'
+pub use attributes::link_section;
+
+//@ has 'user/fn.export_name.html' '//pre[@class="rust item-decl"]' \
+//                                 '#[unsafe(export_name = "exonym")]'
+pub use attributes::export_name;
+
+//@ has 'user/struct.NonExhaustive.html' '//pre[@class="rust item-decl"]' '#[non_exhaustive]'
 pub use attributes::NonExhaustive;
diff --git a/tests/rustdoc/inline_cross/auxiliary/attributes.rs b/tests/rustdoc/inline_cross/auxiliary/attributes.rs
index c6f155d4ba5a9..6068d38558586 100644
--- a/tests/rustdoc/inline_cross/auxiliary/attributes.rs
+++ b/tests/rustdoc/inline_cross/auxiliary/attributes.rs
@@ -1,2 +1,11 @@
+#[unsafe(no_mangle)]
+pub fn no_mangle() {}
+
+#[unsafe(link_section = ".here")]
+pub fn link_section() {}
+
+#[unsafe(export_name = "exonym")]
+pub fn export_name() {}
+
 #[non_exhaustive]
 pub struct NonExhaustive;
diff --git a/tests/rustdoc/reexport/auxiliary/reexports-attrs.rs b/tests/rustdoc/reexport/auxiliary/reexports-attrs.rs
deleted file mode 100644
index 96fa8209cde84..0000000000000
--- a/tests/rustdoc/reexport/auxiliary/reexports-attrs.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-#[unsafe(no_mangle)]
-pub fn f0() {}
-
-#[unsafe(link_section = ".here")]
-pub fn f1() {}
-
-#[unsafe(export_name = "f2export")]
-pub fn f2() {}
-
-#[repr(u8)]
-pub enum T0 { V1 }
-
-#[non_exhaustive]
-pub enum T1 {}
diff --git a/tests/rustdoc/reexport/reexport-attrs.rs b/tests/rustdoc/reexport/reexport-attrs.rs
deleted file mode 100644
index aec0a11c0c6a0..0000000000000
--- a/tests/rustdoc/reexport/reexport-attrs.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//@ aux-build: reexports-attrs.rs
-
-#![crate_name = "foo"]
-
-extern crate reexports_attrs;
-
-//@ has 'foo/fn.f0.html' '//pre[@class="rust item-decl"]' '#[unsafe(no_mangle)]'
-pub use reexports_attrs::f0;
-
-//@ has 'foo/fn.f1.html' '//pre[@class="rust item-decl"]' '#[unsafe(link_section = ".here")]'
-pub use reexports_attrs::f1;
-
-//@ has 'foo/fn.f2.html' '//pre[@class="rust item-decl"]' '#[unsafe(export_name = "f2export")]'
-pub use reexports_attrs::f2;
-
-//@ has 'foo/enum.T0.html' '//pre[@class="rust item-decl"]' '#[repr(u8)]'
-pub use reexports_attrs::T0;
-
-//@ has 'foo/enum.T1.html' '//pre[@class="rust item-decl"]' '#[non_exhaustive]'
-pub use reexports_attrs::T1;

From 85c193a4ed9cf54a70d6d1edaf411b082d15fd13 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Sat, 17 May 2025 14:05:07 +0200
Subject: [PATCH 1379/1889] rustdoc: hide `#[repr(...)]` if it isn't part of
 the public ABI

---
 src/doc/rustdoc/src/advanced-features.md     |  20 ++-
 src/librustdoc/html/render/mod.rs            |  82 +++++++---
 tests/rustdoc-gui/src/test_docs/lib.rs       |   8 +-
 tests/rustdoc/auxiliary/ext-repr.rs          |   5 +
 tests/rustdoc/inline_cross/auxiliary/repr.rs |  42 -----
 tests/rustdoc/inline_cross/repr.rs           |  40 -----
 tests/rustdoc/repr.rs                        | 154 +++++++++++++++++--
 7 files changed, 229 insertions(+), 122 deletions(-)
 create mode 100644 tests/rustdoc/auxiliary/ext-repr.rs
 delete mode 100644 tests/rustdoc/inline_cross/auxiliary/repr.rs
 delete mode 100644 tests/rustdoc/inline_cross/repr.rs

diff --git a/src/doc/rustdoc/src/advanced-features.md b/src/doc/rustdoc/src/advanced-features.md
index c02c9aebe7eef..f49edb2ac78b4 100644
--- a/src/doc/rustdoc/src/advanced-features.md
+++ b/src/doc/rustdoc/src/advanced-features.md
@@ -89,20 +89,30 @@ https://doc.rust-lang.org/stable/std/?search=%s&go_to_first=true
 This URL adds the `go_to_first=true` query parameter which can be appended to any `rustdoc` search URL
 to automatically go to the first result.
 
-## `#[repr(transparent)]`: Documenting the transparent representation
+## `#[repr(...)]`: Documenting the representation of a type
+
+Generally, rustdoc only displays the representation of a given type if none of its variants are
+`#[doc(hidden)]` and if all of its fields are public and not `#[doc(hidden)]` since it's likely
+not meant to be considered part of the public ABI otherwise.
+
+Note that there's no way to overwrite that heuristic and force rustdoc to show the representation
+regardless.
+
+### `#[repr(transparent)]`
 
 You can read more about `#[repr(transparent)]` itself in the [Rust Reference][repr-trans-ref] and
 in the [Rustonomicon][repr-trans-nomicon].
 
 Since this representation is only considered part of the public ABI if the single field with non-trivial
-size or alignment is public and if the documentation does not state otherwise, Rustdoc helpfully displays
-the attribute if and only if the non-1-ZST field is public or at least one field is public in case all
-fields are 1-ZST fields. The term *1-ZST* refers to types that are one-aligned and zero-sized.
+size or alignment is public and if the documentation does not state otherwise, rustdoc helpfully displays
+the attribute if and only if the non-1-ZST field is public and not `#[doc(hidden)]` or
+– in case all fields are 1-ZST fields — at least one field is public and not `#[doc(hidden)]`.
+The term *1-ZST* refers to types that are one-aligned and zero-sized.
 
 It would seem that one can manually hide the attribute with `#[cfg_attr(not(doc), repr(transparent))]`
 if one wishes to declare the representation as private even if the non-1-ZST field is public.
 However, due to [current limitations][cross-crate-cfg-doc], this method is not always guaranteed to work.
-Therefore, if you would like to do so, you should always write it down in prose independently of whether
+Therefore, if you would like to do so, you should always write that down in prose independently of whether
 you use `cfg_attr` or not.
 
 [repr-trans-ref]: https://doc.rust-lang.org/reference/type-layout.html#the-transparent-representation
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index 9280701ea3f8b..143911cb104da 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -2964,6 +2964,10 @@ fn render_code_attribute(prefix: &str, attr: &str, w: &mut impl fmt::Write) {
     write!(w, "<div class=\"code-attribute\">{prefix}{attr}</div>").unwrap();
 }
 
+/// Compute the *public* `#[repr]` of the item given by `DefId`.
+///
+/// Read more about it here:
+/// <https://doc.rust-lang.org/nightly/rustdoc/advanced-features.html#repr-documenting-the-representation-of-a-type>.
 fn repr_attribute<'tcx>(
     tcx: TyCtxt<'tcx>,
     cache: &Cache,
@@ -2975,25 +2979,59 @@ fn repr_attribute<'tcx>(
     };
     let repr = adt.repr();
 
+    let is_visible = |def_id| cache.document_hidden || !tcx.is_doc_hidden(def_id);
+    let is_public_field = |field: &ty::FieldDef| {
+        (cache.document_private || field.vis.is_public()) && is_visible(field.did)
+    };
+
     if repr.transparent() {
-        // Render `repr(transparent)` iff the non-1-ZST field is public or at least one
-        // field is public in case all fields are 1-ZST fields.
-        let render_transparent = cache.document_private
-            || adt
-                .all_fields()
-                .find(|field| {
-                    let ty = field.ty(tcx, ty::GenericArgs::identity_for_item(tcx, field.did));
-                    tcx.layout_of(ty::TypingEnv::post_analysis(tcx, field.did).as_query_input(ty))
-                        .is_ok_and(|layout| !layout.is_1zst())
-                })
-                .map_or_else(
-                    || adt.all_fields().any(|field| field.vis.is_public()),
-                    |field| field.vis.is_public(),
-                );
+        // The transparent repr is public iff the non-1-ZST field is public and visible or
+        // – in case all fields are 1-ZST fields — at least one field is public and visible.
+        let is_public = 'is_public: {
+            // `#[repr(transparent)]` can only be applied to structs and single-variant enums.
+            let var = adt.variant(rustc_abi::FIRST_VARIANT); // the first and only variant
+
+            if !is_visible(var.def_id) {
+                break 'is_public false;
+            }
+
+            // Side note: There can only ever be one or zero non-1-ZST fields.
+            let non_1zst_field = var.fields.iter().find(|field| {
+                let ty = ty::TypingEnv::post_analysis(tcx, field.did)
+                    .as_query_input(tcx.type_of(field.did).instantiate_identity());
+                tcx.layout_of(ty).is_ok_and(|layout| !layout.is_1zst())
+            });
+
+            match non_1zst_field {
+                Some(field) => is_public_field(field),
+                None => var.fields.is_empty() || var.fields.iter().any(is_public_field),
+            }
+        };
 
         // Since the transparent repr can't have any other reprs or
         // repr modifiers beside it, we can safely return early here.
-        return render_transparent.then(|| "#[repr(transparent)]".into());
+        return is_public.then(|| "#[repr(transparent)]".into());
+    }
+
+    // Fast path which avoids looking through the variants and fields in
+    // the common case of no `#[repr]` or in the case of `#[repr(Rust)]`.
+    // FIXME: This check is not very robust / forward compatible!
+    if !repr.c()
+        && !repr.simd()
+        && repr.int.is_none()
+        && repr.pack.is_none()
+        && repr.align.is_none()
+    {
+        return None;
+    }
+
+    // The repr is public iff all components are public and visible.
+    let is_public = adt
+        .variants()
+        .iter()
+        .all(|variant| is_visible(variant.def_id) && variant.fields.iter().all(is_public_field));
+    if !is_public {
+        return None;
     }
 
     let mut result = Vec::<Cow<'_, _>>::new();
@@ -3004,12 +3042,6 @@ fn repr_attribute<'tcx>(
     if repr.simd() {
         result.push("simd".into());
     }
-    if let Some(pack) = repr.pack {
-        result.push(format!("packed({})", pack.bytes()).into());
-    }
-    if let Some(align) = repr.align {
-        result.push(format!("align({})", align.bytes()).into());
-    }
     if let Some(int) = repr.int {
         let prefix = if int.is_signed() { 'i' } else { 'u' };
         let int = match int {
@@ -3021,5 +3053,13 @@ fn repr_attribute<'tcx>(
         result.push(int.into());
     }
 
+    // Render modifiers last.
+    if let Some(pack) = repr.pack {
+        result.push(format!("packed({})", pack.bytes()).into());
+    }
+    if let Some(align) = repr.align {
+        result.push(format!("align({})", align.bytes()).into());
+    }
+
     (!result.is_empty()).then(|| format!("#[repr({})]", result.join(", ")).into())
 }
diff --git a/tests/rustdoc-gui/src/test_docs/lib.rs b/tests/rustdoc-gui/src/test_docs/lib.rs
index 42f2fbd93b1ee..de7c89a9fa375 100644
--- a/tests/rustdoc-gui/src/test_docs/lib.rs
+++ b/tests/rustdoc-gui/src/test_docs/lib.rs
@@ -459,10 +459,10 @@ pub fn safe_fn() {}
 
 #[repr(C)]
 pub struct WithGenerics<T: TraitWithNoDocblocks, S = String, E = WhoLetTheDogOut, P = i8> {
-    s: S,
-    t: T,
-    e: E,
-    p: P,
+    pub s: S,
+    pub t: T,
+    pub e: E,
+    pub p: P,
 }
 
 pub struct StructWithPublicUndocumentedFields {
diff --git a/tests/rustdoc/auxiliary/ext-repr.rs b/tests/rustdoc/auxiliary/ext-repr.rs
new file mode 100644
index 0000000000000..25acaa49449e6
--- /dev/null
+++ b/tests/rustdoc/auxiliary/ext-repr.rs
@@ -0,0 +1,5 @@
+#[repr(i8)]
+pub enum ReprI8 {
+    Var0,
+    Var1,
+}
diff --git a/tests/rustdoc/inline_cross/auxiliary/repr.rs b/tests/rustdoc/inline_cross/auxiliary/repr.rs
deleted file mode 100644
index 0211e1a86588f..0000000000000
--- a/tests/rustdoc/inline_cross/auxiliary/repr.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-#![feature(repr_simd)]
-
-#[repr(C, align(8))]
-pub struct ReprC {
-    field: u8,
-}
-#[repr(simd, packed(2))]
-pub struct ReprSimd {
-    field: [u8; 1],
-}
-#[repr(transparent)]
-pub struct ReprTransparent {
-    pub field: u8,
-}
-#[repr(isize)]
-pub enum ReprIsize {
-    Bla,
-}
-#[repr(u8)]
-pub enum ReprU8 {
-    Bla,
-}
-
-#[repr(transparent)] // private
-pub struct ReprTransparentPrivField {
-    field: u32, // non-1-ZST field
-}
-
-#[repr(transparent)] // public
-pub struct ReprTransparentPriv1ZstFields {
-    marker0: Marker,
-    pub main: u64, // non-1-ZST field
-    marker1: Marker,
-}
-
-#[repr(transparent)] // private
-pub struct ReprTransparentPrivFieldPub1ZstFields {
-    main: [u16; 0], // non-1-ZST field
-    pub marker: Marker,
-}
-
-pub struct Marker; // 1-ZST
diff --git a/tests/rustdoc/inline_cross/repr.rs b/tests/rustdoc/inline_cross/repr.rs
deleted file mode 100644
index d13e560b8d77f..0000000000000
--- a/tests/rustdoc/inline_cross/repr.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-// Regression test for <https://github.com/rust-lang/rust/issues/110698>.
-// This test ensures that the re-exported items still have the `#[repr(...)]` attribute.
-
-//@ aux-build:repr.rs
-
-#![crate_name = "foo"]
-
-extern crate repr;
-
-//@ has 'foo/struct.ReprC.html'
-//@ has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(C, align(8))]'
-pub use repr::ReprC;
-//@ has 'foo/struct.ReprSimd.html'
-//@ has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(simd, packed(2))]'
-pub use repr::ReprSimd;
-//@ has 'foo/struct.ReprTransparent.html'
-//@ has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(transparent)]'
-pub use repr::ReprTransparent;
-//@ has 'foo/enum.ReprIsize.html'
-//@ has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(isize)]'
-pub use repr::ReprIsize;
-//@ has 'foo/enum.ReprU8.html'
-//@ has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(u8)]'
-pub use repr::ReprU8;
-
-// Regression test for <https://github.com/rust-lang/rust/issues/90435>.
-// Check that we show `#[repr(transparent)]` iff the non-1-ZST field is public or at least one
-// field is public in case all fields are 1-ZST fields.
-
-//@ has 'foo/struct.ReprTransparentPrivField.html'
-//@ !has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(transparent)]'
-pub use repr::ReprTransparentPrivField;
-
-//@ has 'foo/struct.ReprTransparentPriv1ZstFields.html'
-//@ has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(transparent)]'
-pub use repr::ReprTransparentPriv1ZstFields;
-
-//@ has 'foo/struct.ReprTransparentPrivFieldPub1ZstFields.html'
-//@ !has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(transparent)]'
-pub use repr::ReprTransparentPrivFieldPub1ZstFields;
diff --git a/tests/rustdoc/repr.rs b/tests/rustdoc/repr.rs
index f4f683b3d81a2..1e8fad6ec0a66 100644
--- a/tests/rustdoc/repr.rs
+++ b/tests/rustdoc/repr.rs
@@ -1,29 +1,163 @@
-// Regression test for <https://github.com/rust-lang/rust/issues/90435>.
-// Check that we show `#[repr(transparent)]` iff the non-1-ZST field is public or at least one
-// field is public in case all fields are 1-ZST fields.
+// Test the rendering of `#[repr]` on ADTs.
+#![feature(repr_simd)] // only used for the `ReprSimd` test case
+
+// Check the "local case" (HIR cleaning) //
+
+// Don't render the default repr which is `Rust`.
+//@ has 'repr/struct.ReprDefault.html'
+//@ !has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(Rust)]'
+pub struct ReprDefault;
+
+// Don't render the `Rust` repr — even if given explicitly — since it's the default.
+//@ has 'repr/struct.ReprRust.html'
+//@ !has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(Rust)]'
+#[repr(Rust)] // omitted
+pub struct ReprRust;
+
+//@ has 'repr/struct.ReprCPubFields.html'
+//@ has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(C)]'
+#[repr(C)] // public
+pub struct ReprCPubFields {
+    pub a: u32,
+    pub b: u32,
+}
+
+//@ has 'repr/struct.ReprCPrivField.html'
+//@ !has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(C)]'
+#[repr(C)] // private...
+pub struct ReprCPrivField {
+    a: u32, // ...since this is private
+    pub b: u32,
+}
+
+//@ has 'repr/enum.ReprIsize.html'
+//@ has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(isize)]'
+#[repr(isize)] // public
+pub enum ReprIsize {
+    Bla,
+}
+
+//@ has 'repr/enum.ReprU32HiddenVariant.html'
+//@ !has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(u32)]'
+#[repr(u32)] // private...
+pub enum ReprU32HiddenVariant {
+    #[doc(hidden)]
+    Hidden, // ...since this is hidden
+    Public,
+}
+
+//@ has 'repr/struct.ReprAlignHiddenField.html'
+//@ !has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(align(4))]'
+#[repr(align(4))] // private...
+pub struct ReprAlignHiddenField {
+    #[doc(hidden)]
+    pub hidden: i16, // ...since this field is hidden
+}
+
+//@ has 'repr/struct.ReprSimd.html'
+//@ has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(simd, packed(2))]'
+#[repr(simd, packed(2))] // public
+pub struct ReprSimd {
+    pub field: [u8; 1],
+}
+
+//@ has 'repr/enum.ReprU32Align.html'
+//@ has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(u32, align(8))]'
+#[repr(u32, align(8))] // public
+pub enum ReprU32Align {
+    Variant(u16),
+}
+
+//@ has 'repr/enum.ReprCHiddenVariantField.html'
+//@ !has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(C)]'
+#[repr(C)] // private...
+pub enum ReprCHiddenVariantField {
+    Variant { #[doc(hidden)] field: () }, //...since this field is hidden
+}
 
 //@ has 'repr/struct.ReprTransparentPrivField.html'
 //@ !has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(transparent)]'
-#[repr(transparent)] // private
+#[repr(transparent)] // private...
 pub struct ReprTransparentPrivField {
-    field: u32, // non-1-ZST field
+    field: u32, // ...since the non-1-ZST field is private
 }
 
 //@ has 'repr/struct.ReprTransparentPriv1ZstFields.html'
 //@ has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(transparent)]'
-#[repr(transparent)] // public
+#[repr(transparent)] // public...
 pub struct ReprTransparentPriv1ZstFields {
     marker0: Marker,
-    pub main: u64, // non-1-ZST field
+    pub main: u64, // ...since the non-1-ZST field is public and visible
     marker1: Marker,
+} // the two private 1-ZST fields don't matter
+
+//@ has 'repr/struct.ReprTransparentPrivFieldPub1ZstField.html'
+//@ !has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(transparent)]'
+#[repr(transparent)] // private...
+pub struct ReprTransparentPrivFieldPub1ZstField {
+    main: [u16; 0], // ...since the non-1-ZST field is private
+    pub marker: Marker, // this public 1-ZST field doesn't matter
 }
 
 //@ has 'repr/struct.ReprTransparentPub1ZstField.html'
 //@ has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(transparent)]'
-#[repr(transparent)] // public
+#[repr(transparent)] // public...
 pub struct ReprTransparentPub1ZstField {
-    marker0: Marker,
-    pub marker1: Marker,
+    marker0: Marker, // ...since we don't have a non-1-ZST field...
+    pub marker1: Marker, // ...and this field is public and visible
+}
+
+//@ has 'repr/struct.ReprTransparentUnitStruct.html'
+//@ has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(transparent)]'
+#[repr(transparent)] // public
+pub struct ReprTransparentUnitStruct;
+
+//@ has 'repr/enum.ReprTransparentEnumUnitVariant.html'
+//@ has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(transparent)]'
+#[repr(transparent)] // public
+pub enum ReprTransparentEnumUnitVariant {
+    Variant,
+}
+
+//@ has 'repr/enum.ReprTransparentEnumHiddenUnitVariant.html'
+//@ !has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(transparent)]'
+#[repr(transparent)] // private
+pub enum ReprTransparentEnumHiddenUnitVariant {
+    #[doc(hidden)] Variant(u32),
+}
+
+//@ has 'repr/enum.ReprTransparentEnumPub1ZstField.html'
+//@ has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(transparent)]'
+#[repr(transparent)] // public...
+pub enum ReprTransparentEnumPub1ZstField {
+    Variant {
+        field: u64, // ...since the non-1-ZST field is public
+        #[doc(hidden)]
+        marker: Marker, // this hidden 1-ZST field doesn't matter
+    },
+}
+
+//@ has 'repr/enum.ReprTransparentEnumHidden1ZstField.html'
+//@ !has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(transparent)]'
+#[repr(transparent)] // private...
+pub enum ReprTransparentEnumHidden1ZstField {
+    Variant {
+        #[doc(hidden)]
+        field: u64, // ...since the non-1-ZST field is public
+    },
 }
 
 struct Marker; // 1-ZST
+
+// Check the "extern case" (middle cleaning) //
+
+// Internally, HIR and middle cleaning share `#[repr]` rendering.
+// Thus we'll only test the very basics in this section.
+
+//@ aux-build: ext-repr.rs
+extern crate ext_repr as ext;
+
+// Regression test for <https://github.com/rust-lang/rust/issues/110698>.
+//@ has 'repr/enum.ReprI8.html'
+//@ has - '//*[@class="rust item-decl"]//*[@class="code-attribute"]' '#[repr(i8)]'
+pub use ext::ReprI8;

From 747019ce4647dd2194c2d9e08d482e4d9c669069 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=2E=20Neusch=C3=A4fer?= <j.ne@posteo.net>
Date: Wed, 24 Sep 2025 07:28:32 +0000
Subject: [PATCH 1380/1889] bootstrap.py: Respect build.jobs while building
 bootstrap tool

On resource-constrained systems, it is vital to respect the value of
build.jobs, in order to avoid overwhelming the available memory.
---
 src/bootstrap/bootstrap.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/bootstrap/bootstrap.py b/src/bootstrap/bootstrap.py
index effd33d288fa6..8b1775178c915 100644
--- a/src/bootstrap/bootstrap.py
+++ b/src/bootstrap/bootstrap.py
@@ -596,6 +596,7 @@ def __init__(self, config_toml="", args=None):
         self.download_url = (
             os.getenv("RUSTUP_DIST_SERVER") or self.stage0_data["dist_server"]
         )
+        self.jobs = self.get_toml("jobs", "build") or "default"
 
         self.build = args.build or self.build_triple()
 
@@ -1144,6 +1145,7 @@ def build_bootstrap_cmd(self, env):
         args = [
             self.cargo(),
             "build",
+            "--jobs=" + self.jobs,
             "--manifest-path",
             os.path.join(self.rust_root, "src/bootstrap/Cargo.toml"),
             "-Zroot-dir=" + self.rust_root,

From d834935b57bcd4604727e8a1fa93e8785979eb5c Mon Sep 17 00:00:00 2001
From: DimitriiTrater <dima1603040@gmail.com>
Date: Thu, 11 Sep 2025 19:17:05 +0200
Subject: [PATCH 1381/1889] Fix atan2 inaccuracy in documentation

---
 library/std/src/num/f128.rs | 10 ++++++----
 library/std/src/num/f16.rs  | 10 ++++++----
 library/std/src/num/f32.rs  | 10 ++++++----
 library/std/src/num/f64.rs  | 10 ++++++----
 4 files changed, 24 insertions(+), 16 deletions(-)

diff --git a/library/std/src/num/f128.rs b/library/std/src/num/f128.rs
index b83692390b6bc..5a85c1daaf0ab 100644
--- a/library/std/src/num/f128.rs
+++ b/library/std/src/num/f128.rs
@@ -557,10 +557,12 @@ impl f128 {
 
     /// Computes the four quadrant arctangent of `self` (`y`) and `other` (`x`) in radians.
     ///
-    /// * `x = 0`, `y = 0`: `0`
-    /// * `x >= 0`: `arctan(y/x)` -> `[-pi/2, pi/2]`
-    /// * `y >= 0`: `arctan(y/x) + pi` -> `(pi/2, pi]`
-    /// * `y < 0`: `arctan(y/x) - pi` -> `(-pi, -pi/2)`
+    ///  | `x`     | `y`     | Piecewise Definition | Range         |
+    ///  |---------|---------|----------------------|---------------|
+    ///  | `>= +0` | `>= +0` | `arctan(y/x)`        | `[+0, +pi/2]` |
+    ///  | `>= +0` | `<= -0` | `arctan(y/x)`        | `[-pi/2, -0]` |
+    ///  | `<= -0` | `>= +0` | `arctan(y/x) + pi`   | `[+pi/2, +pi]`|
+    ///  | `<= -0` | `<= -0` | `arctan(y/x) - pi`   | `[-pi, -pi/2]`|
     ///
     /// # Unspecified precision
     ///
diff --git a/library/std/src/num/f16.rs b/library/std/src/num/f16.rs
index 5599528717cbe..cc10c41b9e7d7 100644
--- a/library/std/src/num/f16.rs
+++ b/library/std/src/num/f16.rs
@@ -522,10 +522,12 @@ impl f16 {
 
     /// Computes the four quadrant arctangent of `self` (`y`) and `other` (`x`) in radians.
     ///
-    /// * `x = 0`, `y = 0`: `0`
-    /// * `x >= 0`: `arctan(y/x)` -> `[-pi/2, pi/2]`
-    /// * `y >= 0`: `arctan(y/x) + pi` -> `(pi/2, pi]`
-    /// * `y < 0`: `arctan(y/x) - pi` -> `(-pi, -pi/2)`
+    ///  | `x`     | `y`     | Piecewise Definition | Range         |
+    ///  |---------|---------|----------------------|---------------|
+    ///  | `>= +0` | `>= +0` | `arctan(y/x)`        | `[+0, +pi/2]` |
+    ///  | `>= +0` | `<= -0` | `arctan(y/x)`        | `[-pi/2, -0]` |
+    ///  | `<= -0` | `>= +0` | `arctan(y/x) + pi`   | `[+pi/2, +pi]`|
+    ///  | `<= -0` | `<= -0` | `arctan(y/x) - pi`   | `[-pi, -pi/2]`|
     ///
     /// # Unspecified precision
     ///
diff --git a/library/std/src/num/f32.rs b/library/std/src/num/f32.rs
index 0247080a8d6be..72e5f4d4c410a 100644
--- a/library/std/src/num/f32.rs
+++ b/library/std/src/num/f32.rs
@@ -826,10 +826,12 @@ impl f32 {
 
     /// Computes the four quadrant arctangent of `self` (`y`) and `other` (`x`) in radians.
     ///
-    /// * `x = 0`, `y = 0`: `0`
-    /// * `x >= 0`: `arctan(y/x)` -> `[-pi/2, pi/2]`
-    /// * `y >= 0`: `arctan(y/x) + pi` -> `(pi/2, pi]`
-    /// * `y < 0`: `arctan(y/x) - pi` -> `(-pi, -pi/2)`
+    ///  | `x`     | `y`     | Piecewise Definition | Range         |
+    ///  |---------|---------|----------------------|---------------|
+    ///  | `>= +0` | `>= +0` | `arctan(y/x)`        | `[+0, +pi/2]` |
+    ///  | `>= +0` | `<= -0` | `arctan(y/x)`        | `[-pi/2, -0]` |
+    ///  | `<= -0` | `>= +0` | `arctan(y/x) + pi`   | `[+pi/2, +pi]`|
+    ///  | `<= -0` | `<= -0` | `arctan(y/x) - pi`   | `[-pi, -pi/2]`|
     ///
     /// # Unspecified precision
     ///
diff --git a/library/std/src/num/f64.rs b/library/std/src/num/f64.rs
index 1cfd3909d967e..5f3e793c3a711 100644
--- a/library/std/src/num/f64.rs
+++ b/library/std/src/num/f64.rs
@@ -826,10 +826,12 @@ impl f64 {
 
     /// Computes the four quadrant arctangent of `self` (`y`) and `other` (`x`) in radians.
     ///
-    /// * `x = 0`, `y = 0`: `0`
-    /// * `x >= 0`: `arctan(y/x)` -> `[-pi/2, pi/2]`
-    /// * `y >= 0`: `arctan(y/x) + pi` -> `(pi/2, pi]`
-    /// * `y < 0`: `arctan(y/x) - pi` -> `(-pi, -pi/2)`
+    ///  | `x`     | `y`     | Piecewise Definition | Range         |
+    ///  |---------|---------|----------------------|---------------|
+    ///  | `>= +0` | `>= +0` | `arctan(y/x)`        | `[+0, +pi/2]` |
+    ///  | `>= +0` | `<= -0` | `arctan(y/x)`        | `[-pi/2, -0]` |
+    ///  | `<= -0` | `>= +0` | `arctan(y/x) + pi`   | `[+pi/2, +pi]`|
+    ///  | `<= -0` | `<= -0` | `arctan(y/x) - pi`   | `[-pi, -pi/2]`|
     ///
     /// # Unspecified precision
     ///

From a9637efa275767c270829579f5282e5585043d19 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Thu, 25 Sep 2025 19:58:45 +0800
Subject: [PATCH 1382/1889] Fix fixes for unused raw variables

Example
---
```
fn main() {
    let $0r#type = 2;
}
```

**Before this PR**:

```rust
fn main() {
    let _r#type = 2;
}
```

**After this PR**:

```rust
fn main() {
    let _type = 2;
}
```
---
 .../src/handlers/unused_variables.rs           | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/unused_variables.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/unused_variables.rs
index a4f3ca0a26725..84e63acbc04f0 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/unused_variables.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/unused_variables.rs
@@ -6,7 +6,7 @@ use ide_db::{
     label::Label,
     source_change::SourceChange,
 };
-use syntax::{AstNode, Edition, TextRange};
+use syntax::{AstNode, Edition, TextRange, ToSmolStr};
 
 use crate::{Diagnostic, DiagnosticCode, DiagnosticsContext};
 
@@ -73,7 +73,8 @@ fn fixes(
     if is_in_marco {
         return None;
     }
-    let name = var_name.display(db, edition);
+    let name = var_name.display(db, edition).to_smolstr();
+    let name = name.strip_prefix("r#").unwrap_or(&name);
     let new_name = if is_shorthand_field { format!("{name}: _{name}") } else { format!("_{name}") };
 
     Some(vec![Assist {
@@ -231,6 +232,19 @@ fn main() {
         }
     }
 }
+"#,
+        );
+
+        check_fix(
+            r#"
+fn main() {
+    let $0r#type = 2;
+}
+"#,
+            r#"
+fn main() {
+    let _type = 2;
+}
 "#,
         );
     }

From c1cd1da668650d0e9e0f143f89a17387d96979c2 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Wed, 3 Sep 2025 20:07:19 +0800
Subject: [PATCH 1383/1889] Add let-chain support for convert_to_guarded_return

- And add early expression `None` in function `Option` return

Example
---
```rust
fn main() {
    if$0 let Ok(x) = Err(92)
        && x < 30
        && let Some(y) = Some(8)
    {
        foo(x, y);
    }
}
```
->
```rust
fn main() {
    let Ok(x) = Err(92) else { return };
    if x >= 30 {
        return;
    }
    let Some(y) = Some(8) else { return };
    foo(x, y);
}
```
---
 .../src/handlers/convert_to_guarded_return.rs | 217 +++++++++++++++---
 1 file changed, 179 insertions(+), 38 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_to_guarded_return.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_to_guarded_return.rs
index 2ea032fb62ba1..3dc4737ffc51f 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_to_guarded_return.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_to_guarded_return.rs
@@ -1,13 +1,11 @@
 use std::iter::once;
 
-use ide_db::{
-    syntax_helpers::node_ext::{is_pattern_cond, single_let},
-    ty_filter::TryEnum,
-};
+use hir::Semantics;
+use ide_db::{RootDatabase, ty_filter::TryEnum};
 use syntax::{
     AstNode,
     SyntaxKind::{FN, FOR_EXPR, LOOP_EXPR, WHILE_EXPR, WHITESPACE},
-    T,
+    SyntaxNode, T,
     ast::{
         self,
         edit::{AstNodeEdit, IndentLevel},
@@ -73,13 +71,7 @@ fn if_expr_to_guarded_return(
         return None;
     }
 
-    // Check if there is an IfLet that we can handle.
-    let (if_let_pat, cond_expr) = if is_pattern_cond(cond.clone()) {
-        let let_ = single_let(cond)?;
-        (Some(let_.pat()?), let_.expr()?)
-    } else {
-        (None, cond)
-    };
+    let let_chains = flat_let_chain(cond);
 
     let then_block = if_expr.then_branch()?;
     let then_block = then_block.stmt_list()?;
@@ -106,11 +98,7 @@ fn if_expr_to_guarded_return(
 
     let parent_container = parent_block.syntax().parent()?;
 
-    let early_expression: ast::Expr = match parent_container.kind() {
-        WHILE_EXPR | LOOP_EXPR | FOR_EXPR => make::expr_continue(None),
-        FN => make::expr_return(None),
-        _ => return None,
-    };
+    let early_expression: ast::Expr = early_expression(parent_container, &ctx.sema)?;
 
     then_block.syntax().first_child_or_token().map(|t| t.kind() == T!['{'])?;
 
@@ -132,32 +120,42 @@ fn if_expr_to_guarded_return(
         target,
         |edit| {
             let if_indent_level = IndentLevel::from_node(if_expr.syntax());
-            let replacement = match if_let_pat {
-                None => {
-                    // If.
-                    let new_expr = {
-                        let then_branch =
-                            make::block_expr(once(make::expr_stmt(early_expression).into()), None);
-                        let cond = invert_boolean_expression_legacy(cond_expr);
-                        make::expr_if(cond, then_branch, None).indent(if_indent_level)
-                    };
-                    new_expr.syntax().clone()
-                }
-                Some(pat) => {
+            let replacement = let_chains.into_iter().map(|expr| {
+                if let ast::Expr::LetExpr(let_expr) = &expr
+                    && let (Some(pat), Some(expr)) = (let_expr.pat(), let_expr.expr())
+                {
                     // If-let.
                     let let_else_stmt = make::let_else_stmt(
                         pat,
                         None,
-                        cond_expr,
-                        ast::make::tail_only_block_expr(early_expression),
+                        expr,
+                        ast::make::tail_only_block_expr(early_expression.clone()),
                     );
                     let let_else_stmt = let_else_stmt.indent(if_indent_level);
                     let_else_stmt.syntax().clone()
+                } else {
+                    // If.
+                    let new_expr = {
+                        let then_branch = make::block_expr(
+                            once(make::expr_stmt(early_expression.clone()).into()),
+                            None,
+                        );
+                        let cond = invert_boolean_expression_legacy(expr);
+                        make::expr_if(cond, then_branch, None).indent(if_indent_level)
+                    };
+                    new_expr.syntax().clone()
                 }
-            };
+            });
 
+            let newline = &format!("\n{if_indent_level}");
             let then_statements = replacement
-                .children_with_tokens()
+                .enumerate()
+                .flat_map(|(i, node)| {
+                    (i != 0)
+                        .then(|| make::tokens::whitespace(newline).into())
+                        .into_iter()
+                        .chain(node.children_with_tokens())
+                })
                 .chain(
                     then_block_items
                         .syntax()
@@ -201,11 +199,7 @@ fn let_stmt_to_guarded_return(
             let_stmt.syntax().parent()?.ancestors().find_map(ast::BlockExpr::cast)?;
         let parent_container = parent_block.syntax().parent()?;
 
-        match parent_container.kind() {
-            WHILE_EXPR | LOOP_EXPR | FOR_EXPR => make::expr_continue(None),
-            FN => make::expr_return(None),
-            _ => return None,
-        }
+        early_expression(parent_container, &ctx.sema)?
     };
 
     acc.add(
@@ -232,6 +226,44 @@ fn let_stmt_to_guarded_return(
     )
 }
 
+fn early_expression(
+    parent_container: SyntaxNode,
+    sema: &Semantics<'_, RootDatabase>,
+) -> Option<ast::Expr> {
+    if let Some(fn_) = ast::Fn::cast(parent_container.clone())
+        && let Some(fn_def) = sema.to_def(&fn_)
+        && let Some(TryEnum::Option) = TryEnum::from_ty(sema, &fn_def.ret_type(sema.db))
+    {
+        let none_expr = make::expr_path(make::ext::ident_path("None"));
+        return Some(make::expr_return(Some(none_expr)));
+    }
+    Some(match parent_container.kind() {
+        WHILE_EXPR | LOOP_EXPR | FOR_EXPR => make::expr_continue(None),
+        FN => make::expr_return(None),
+        _ => return None,
+    })
+}
+
+fn flat_let_chain(mut expr: ast::Expr) -> Vec<ast::Expr> {
+    let mut chains = vec![];
+
+    while let ast::Expr::BinExpr(bin_expr) = &expr
+        && bin_expr.op_kind() == Some(ast::BinaryOp::LogicOp(ast::LogicOp::And))
+        && let (Some(lhs), Some(rhs)) = (bin_expr.lhs(), bin_expr.rhs())
+    {
+        if let Some(last) = chains.pop_if(|last| !matches!(last, ast::Expr::LetExpr(_))) {
+            chains.push(make::expr_bin_op(rhs, ast::BinaryOp::LogicOp(ast::LogicOp::And), last));
+        } else {
+            chains.push(rhs);
+        }
+        expr = lhs;
+    }
+
+    chains.push(expr);
+    chains.reverse();
+    chains
+}
+
 #[cfg(test)]
 mod tests {
     use crate::tests::{check_assist, check_assist_not_applicable};
@@ -268,6 +300,37 @@ fn main() {
         );
     }
 
+    #[test]
+    fn convert_inside_fn_return_option() {
+        check_assist(
+            convert_to_guarded_return,
+            r#"
+//- minicore: option
+fn ret_option() -> Option<()> {
+    bar();
+    if$0 true {
+        foo();
+
+        // comment
+        bar();
+    }
+}
+"#,
+            r#"
+fn ret_option() -> Option<()> {
+    bar();
+    if false {
+        return None;
+    }
+    foo();
+
+    // comment
+    bar();
+}
+"#,
+        );
+    }
+
     #[test]
     fn convert_let_inside_fn() {
         check_assist(
@@ -316,6 +379,58 @@ fn main() {
         );
     }
 
+    #[test]
+    fn convert_if_let_chain_result() {
+        check_assist(
+            convert_to_guarded_return,
+            r#"
+fn main() {
+    if$0 let Ok(x) = Err(92)
+        && x < 30
+        && let Some(y) = Some(8)
+    {
+        foo(x, y);
+    }
+}
+"#,
+            r#"
+fn main() {
+    let Ok(x) = Err(92) else { return };
+    if x >= 30 {
+        return;
+    }
+    let Some(y) = Some(8) else { return };
+    foo(x, y);
+}
+"#,
+        );
+
+        check_assist(
+            convert_to_guarded_return,
+            r#"
+fn main() {
+    if$0 let Ok(x) = Err(92)
+        && x < 30
+        && y < 20
+        && let Some(y) = Some(8)
+    {
+        foo(x, y);
+    }
+}
+"#,
+            r#"
+fn main() {
+    let Ok(x) = Err(92) else { return };
+    if !(x < 30 && y < 20) {
+        return;
+    }
+    let Some(y) = Some(8) else { return };
+    foo(x, y);
+}
+"#,
+        );
+    }
+
     #[test]
     fn convert_let_ok_inside_fn() {
         check_assist(
@@ -560,6 +675,32 @@ fn main() {
         );
     }
 
+    #[test]
+    fn convert_let_stmt_inside_fn_return_option() {
+        check_assist(
+            convert_to_guarded_return,
+            r#"
+//- minicore: option
+fn foo() -> Option<i32> {
+    None
+}
+
+fn ret_option() -> Option<i32> {
+    let x$0 = foo();
+}
+"#,
+            r#"
+fn foo() -> Option<i32> {
+    None
+}
+
+fn ret_option() -> Option<i32> {
+    let Some(x) = foo() else { return None };
+}
+"#,
+        );
+    }
+
     #[test]
     fn convert_let_stmt_inside_loop() {
         check_assist(

From 079addf985d1902e8f79620697834c3ea3de84c8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Thu, 25 Sep 2025 15:07:34 +0200
Subject: [PATCH 1384/1889] Ensure that `--build-dir` is always specified in
 tests

---
 src/bootstrap/src/core/config/config.rs | 27 ++++---------------------
 1 file changed, 4 insertions(+), 23 deletions(-)

diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index 1e207380a0a1b..74a272c740bd3 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -642,12 +642,12 @@ impl Config {
         let llvm_assertions = llvm_assertions.unwrap_or(false);
         let mut target_config = HashMap::new();
         let mut channel = "dev".to_string();
+
+        let out = flags_build_dir.or_else(|| build_build_dir.map(PathBuf::from));
         let out = if cfg!(test) {
-            test_build_dir()
+            out.expect("--build-dir has to be specified in tests")
         } else {
-            flags_build_dir
-                .or_else(|| build_build_dir.map(PathBuf::from))
-                .unwrap_or_else(|| PathBuf::from("build"))
+            out.unwrap_or_else(|| PathBuf::from("build"))
         };
 
         // NOTE: Bootstrap spawns various commands with different working directories.
@@ -2490,22 +2490,3 @@ fn find_correct_section_for_field(field_name: &str) -> Vec<WouldBeValidFor> {
         })
         .collect()
 }
-
-/// Resolve the build directory used for tests.
-///
-/// - When tests are run through bootstrap (`x.py test`), the build system
-///   sets `CARGO_TARGET_DIR`, so we can trust and use it here.
-/// - When tests are run directly with cargo test, `CARGO_TARGET_DIR` will
-///   not be set. In that case we fall back to resolving relative to
-///   `CARGO_MANIFEST_DIR`, by walking two parents up and appending `build`.
-fn test_build_dir() -> PathBuf {
-    env::var_os("CARGO_TARGET_DIR")
-        .map(|value| Path::new(&value).parent().unwrap().to_path_buf())
-        .unwrap_or_else(|| {
-            let base = option_env!("CARGO_MANIFEST_DIR")
-                .map(PathBuf::from)
-                .unwrap_or_else(|| std::env::current_dir().expect("failed to get current dir"));
-
-            base.ancestors().nth(2).unwrap_or_else(|| Path::new(".")).join("build")
-        })
-}

From 56194654c6b9f2ba5eb077c0e535969f34c12e21 Mon Sep 17 00:00:00 2001
From: Zihan <zihanli0822@gmail.com>
Date: Tue, 23 Sep 2025 17:02:09 -0400
Subject: [PATCH 1385/1889] `filter_next`: check for `filter().next_back()`

changelog: [`filter_next`]: suggest replacing `filter().next_back()` with
`rfind()` for `DoubleEndedIterator`

Signed-off-by: Zihan <zihanli0822@gmail.com>
---
 clippy_lints/src/methods/filter_next.rs | 91 +++++++++++++++----------
 clippy_lints/src/methods/mod.rs         | 12 +++-
 clippy_utils/src/msrvs.rs               |  2 +-
 tests/ui/auxiliary/option_helpers.rs    |  4 ++
 tests/ui/methods.rs                     | 20 ++++++
 tests/ui/methods.stderr                 | 13 +++-
 tests/ui/methods_fixable.fixed          | 14 ++++
 tests/ui/methods_fixable.rs             | 14 ++++
 tests/ui/methods_fixable.stderr         | 14 +++-
 9 files changed, 143 insertions(+), 41 deletions(-)

diff --git a/clippy_lints/src/methods/filter_next.rs b/clippy_lints/src/methods/filter_next.rs
index 72f83b245a0cb..e1a9a79e20eea 100644
--- a/clippy_lints/src/methods/filter_next.rs
+++ b/clippy_lints/src/methods/filter_next.rs
@@ -10,51 +10,68 @@ use rustc_span::sym;
 
 use super::FILTER_NEXT;
 
-/// lint use of `filter().next()` for `Iterators`
+#[derive(Copy, Clone)]
+pub(super) enum Direction {
+    Forward,
+    Backward,
+}
+
+/// lint use of `filter().next()` for `Iterator` and `filter().next_back()` for
+/// `DoubleEndedIterator`
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx hir::Expr<'_>,
     recv: &'tcx hir::Expr<'_>,
     filter_arg: &'tcx hir::Expr<'_>,
+    direction: Direction,
 ) {
-    // lint if caller of `.filter().next()` is an Iterator
-    let recv_impls_iterator = cx
+    // lint if caller of `.filter().next()` is an Iterator or `.filter().next_back()` is a
+    // DoubleEndedIterator
+    let (required_trait, next_method, find_method) = match direction {
+        Direction::Forward => (sym::Iterator, "next", "find"),
+        Direction::Backward => (sym::DoubleEndedIterator, "next_back", "rfind"),
+    };
+    if !cx
         .tcx
-        .get_diagnostic_item(sym::Iterator)
-        .is_some_and(|id| implements_trait(cx, cx.typeck_results().expr_ty(recv), id, &[]));
-    if recv_impls_iterator {
-        let msg = "called `filter(..).next()` on an `Iterator`. This is more succinctly expressed by calling \
-                   `.find(..)` instead";
-        let filter_snippet = snippet(cx, filter_arg.span, "..");
-        if filter_snippet.lines().count() <= 1 {
-            let iter_snippet = snippet(cx, recv.span, "..");
-            // add note if not multi-line
-            span_lint_and_then(cx, FILTER_NEXT, expr.span, msg, |diag| {
-                let (applicability, pat) = if let Some(id) = path_to_local_with_projections(recv)
-                    && let hir::Node::Pat(pat) = cx.tcx.hir_node(id)
-                    && let hir::PatKind::Binding(BindingMode(_, Mutability::Not), _, ident, _) = pat.kind
-                {
-                    (Applicability::Unspecified, Some((pat.span, ident)))
-                } else {
-                    (Applicability::MachineApplicable, None)
-                };
+        .get_diagnostic_item(required_trait)
+        .is_some_and(|id| implements_trait(cx, cx.typeck_results().expr_ty(recv), id, &[]))
+    {
+        return;
+    }
+    let msg = format!(
+        "called `filter(..).{next_method}()` on an `{}`. This is more succinctly expressed by calling \
+                   `.{find_method}(..)` instead",
+        required_trait.as_str()
+    );
+    let filter_snippet = snippet(cx, filter_arg.span, "..");
+    if filter_snippet.lines().count() <= 1 {
+        let iter_snippet = snippet(cx, recv.span, "..");
+        // add note if not multi-line
+        span_lint_and_then(cx, FILTER_NEXT, expr.span, msg, |diag| {
+            let (applicability, pat) = if let Some(id) = path_to_local_with_projections(recv)
+                && let hir::Node::Pat(pat) = cx.tcx.hir_node(id)
+                && let hir::PatKind::Binding(BindingMode(_, Mutability::Not), _, ident, _) = pat.kind
+            {
+                (Applicability::Unspecified, Some((pat.span, ident)))
+            } else {
+                (Applicability::MachineApplicable, None)
+            };
 
-                diag.span_suggestion(
-                    expr.span,
-                    "try",
-                    format!("{iter_snippet}.find({filter_snippet})"),
-                    applicability,
-                );
+            diag.span_suggestion(
+                expr.span,
+                "try",
+                format!("{iter_snippet}.{find_method}({filter_snippet})"),
+                applicability,
+            );
 
-                if let Some((pat_span, ident)) = pat {
-                    diag.span_help(
-                        pat_span,
-                        format!("you will also need to make `{ident}` mutable, because `find` takes `&mut self`"),
-                    );
-                }
-            });
-        } else {
-            span_lint(cx, FILTER_NEXT, expr.span, msg);
-        }
+            if let Some((pat_span, ident)) = pat {
+                diag.span_help(
+                    pat_span,
+                    format!("you will also need to make `{ident}` mutable, because `{find_method}` takes `&mut self`"),
+                );
+            }
+        });
+    } else {
+        span_lint(cx, FILTER_NEXT, expr.span, msg);
     }
 }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 8679689c8ad4d..9b27a6c19e1fb 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -5369,7 +5369,9 @@ impl Methods {
                                 iter_overeager_cloned::Op::LaterCloned,
                                 false,
                             ),
-                            (sym::filter, [arg]) => filter_next::check(cx, expr, recv2, arg),
+                            (sym::filter, [arg]) => {
+                                filter_next::check(cx, expr, recv2, arg, filter_next::Direction::Forward);
+                            },
                             (sym::filter_map, [arg]) => filter_map_next::check(cx, expr, recv2, arg, self.msrv),
                             (sym::iter, []) => iter_next_slice::check(cx, expr, recv2),
                             (sym::skip, [arg]) => iter_skip_next::check(cx, expr, recv2, arg),
@@ -5379,6 +5381,14 @@ impl Methods {
                         }
                     }
                 },
+                (sym::next_back, []) => {
+                    if let Some((name2, recv2, args2, _, _)) = method_call(recv)
+                        && let (sym::filter, [arg]) = (name2, args2)
+                        && self.msrv.meets(cx, msrvs::DOUBLE_ENDED_ITERATOR_RFIND)
+                    {
+                        filter_next::check(cx, expr, recv2, arg, filter_next::Direction::Backward);
+                    }
+                },
                 (sym::nth, [n_arg]) => match method_call(recv) {
                     Some((sym::bytes, recv2, [], _, _)) => bytes_nth::check(cx, expr, recv2, n_arg),
                     Some((sym::cloned, recv2, [], _, _)) => iter_overeager_cloned::check(
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 6e07ed9ffcc4d..ad3d52193bf6e 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -72,7 +72,7 @@ msrv_aliases! {
     1,30,0 { ITERATOR_FIND_MAP, TOOL_ATTRIBUTES }
     1,29,0 { ITER_FLATTEN }
     1,28,0 { FROM_BOOL, REPEAT_WITH, SLICE_FROM_REF }
-    1,27,0 { ITERATOR_TRY_FOLD }
+    1,27,0 { ITERATOR_TRY_FOLD, DOUBLE_ENDED_ITERATOR_RFIND }
     1,26,0 { RANGE_INCLUSIVE, STRING_RETAIN, POINTER_ADD_SUB_METHODS }
     1,24,0 { IS_ASCII_DIGIT, PTR_NULL }
     1,18,0 { HASH_MAP_RETAIN, HASH_SET_RETAIN }
diff --git a/tests/ui/auxiliary/option_helpers.rs b/tests/ui/auxiliary/option_helpers.rs
index f9bc9436b0792..796d4dabf04d2 100644
--- a/tests/ui/auxiliary/option_helpers.rs
+++ b/tests/ui/auxiliary/option_helpers.rs
@@ -25,6 +25,10 @@ impl IteratorFalsePositives {
         self
     }
 
+    pub fn next_back(self) -> IteratorFalsePositives {
+        self
+    }
+
     pub fn find(self) -> Option<u32> {
         Some(self.foo)
     }
diff --git a/tests/ui/methods.rs b/tests/ui/methods.rs
index f73fe288b0f8c..9595888b99f83 100644
--- a/tests/ui/methods.rs
+++ b/tests/ui/methods.rs
@@ -135,6 +135,26 @@ fn filter_next() {
     let _ = foo.filter(42).next();
 }
 
+#[rustfmt::skip]
+fn filter_next_back() {
+    let v = vec![3, 2, 1, 0, -1, -2, -3];
+
+    // Multi-line case.
+    let _ = v.iter().filter(|&x| {
+    //~^ filter_next
+                                *x < 0
+                            }
+                   ).next_back();
+    
+    // Check that we don't lint if the caller is not an `Iterator`.
+    let foo = IteratorFalsePositives { foo: 0 };
+    let _ = foo.filter().next_back();
+
+    let foo = IteratorMethodFalsePositives {};
+    let _ = foo.filter(42).next_back();
+}
+
 fn main() {
     filter_next();
+    filter_next_back();
 }
diff --git a/tests/ui/methods.stderr b/tests/ui/methods.stderr
index b226ce7c65dab..45efea4ee01cd 100644
--- a/tests/ui/methods.stderr
+++ b/tests/ui/methods.stderr
@@ -24,5 +24,16 @@ LL | |                    ).next();
    = note: `-D clippy::filter-next` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::filter_next)]`
 
-error: aborting due to 2 previous errors
+error: called `filter(..).next_back()` on an `DoubleEndedIterator`. This is more succinctly expressed by calling `.rfind(..)` instead
+  --> tests/ui/methods.rs:143:13
+   |
+LL |       let _ = v.iter().filter(|&x| {
+   |  _____________^
+LL | |
+LL | |                                 *x < 0
+LL | |                             }
+LL | |                    ).next_back();
+   | |________________________________^
+
+error: aborting due to 3 previous errors
 
diff --git a/tests/ui/methods_fixable.fixed b/tests/ui/methods_fixable.fixed
index 49730d8115584..287d8d881ec28 100644
--- a/tests/ui/methods_fixable.fixed
+++ b/tests/ui/methods_fixable.fixed
@@ -8,4 +8,18 @@ fn main() {
     // Single-line case.
     let _ = v.iter().find(|&x| *x < 0);
     //~^ filter_next
+
+    let _ = v.iter().rfind(|&x| *x < 0);
+    //~^ filter_next
+}
+
+#[clippy::msrv = "1.27"]
+fn msrv_1_27() {
+    let _ = vec![1].into_iter().rfind(|&x| x < 0);
+    //~^ filter_next
+}
+
+#[clippy::msrv = "1.26"]
+fn msrv_1_26() {
+    let _ = vec![1].into_iter().filter(|&x| x < 0).next_back();
 }
diff --git a/tests/ui/methods_fixable.rs b/tests/ui/methods_fixable.rs
index a499b63b6f5bd..11ce1b63560db 100644
--- a/tests/ui/methods_fixable.rs
+++ b/tests/ui/methods_fixable.rs
@@ -8,4 +8,18 @@ fn main() {
     // Single-line case.
     let _ = v.iter().filter(|&x| *x < 0).next();
     //~^ filter_next
+
+    let _ = v.iter().filter(|&x| *x < 0).next_back();
+    //~^ filter_next
+}
+
+#[clippy::msrv = "1.27"]
+fn msrv_1_27() {
+    let _ = vec![1].into_iter().filter(|&x| x < 0).next_back();
+    //~^ filter_next
+}
+
+#[clippy::msrv = "1.26"]
+fn msrv_1_26() {
+    let _ = vec![1].into_iter().filter(|&x| x < 0).next_back();
 }
diff --git a/tests/ui/methods_fixable.stderr b/tests/ui/methods_fixable.stderr
index 852e7a224a6e3..d26b5e9ac271e 100644
--- a/tests/ui/methods_fixable.stderr
+++ b/tests/ui/methods_fixable.stderr
@@ -7,5 +7,17 @@ LL |     let _ = v.iter().filter(|&x| *x < 0).next();
    = note: `-D clippy::filter-next` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::filter_next)]`
 
-error: aborting due to 1 previous error
+error: called `filter(..).next_back()` on an `DoubleEndedIterator`. This is more succinctly expressed by calling `.rfind(..)` instead
+  --> tests/ui/methods_fixable.rs:12:13
+   |
+LL |     let _ = v.iter().filter(|&x| *x < 0).next_back();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `v.iter().rfind(|&x| *x < 0)`
+
+error: called `filter(..).next_back()` on an `DoubleEndedIterator`. This is more succinctly expressed by calling `.rfind(..)` instead
+  --> tests/ui/methods_fixable.rs:18:13
+   |
+LL |     let _ = vec![1].into_iter().filter(|&x| x < 0).next_back();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec![1].into_iter().rfind(|&x| x < 0)`
+
+error: aborting due to 3 previous errors
 

From 1947949f3d7212c181049d96e2665481d3bddc6b Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Thu, 25 Sep 2025 21:57:10 +0800
Subject: [PATCH 1386/1889] Fix not applicable for if-expr in let-stmt

Example
---
```rust
fn main() {
    let _x = loop {
        if$0 let Ok(x) = Err(92) {
            foo(x);
        }
    };
}
```

**Before**:

Assist not applicable

**After**:

```rust
fn main() {
    let _x = loop {
        let Ok(x) = Err(92) else { continue };
        foo(x);
    };
}
```
---
 .../src/handlers/convert_to_guarded_return.rs | 34 +++++++++++++++----
 1 file changed, 28 insertions(+), 6 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_to_guarded_return.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_to_guarded_return.rs
index 3dc4737ffc51f..aee9ce7878b29 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_to_guarded_return.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_to_guarded_return.rs
@@ -1,6 +1,7 @@
 use std::iter::once;
 
 use hir::Semantics;
+use either::Either;
 use ide_db::{RootDatabase, ty_filter::TryEnum};
 use syntax::{
     AstNode,
@@ -42,12 +43,9 @@ use crate::{
 // }
 // ```
 pub(crate) fn convert_to_guarded_return(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {
-    if let Some(let_stmt) = ctx.find_node_at_offset() {
-        let_stmt_to_guarded_return(let_stmt, acc, ctx)
-    } else if let Some(if_expr) = ctx.find_node_at_offset() {
-        if_expr_to_guarded_return(if_expr, acc, ctx)
-    } else {
-        None
+    match ctx.find_node_at_offset::<Either<ast::LetStmt, ast::IfExpr>>()? {
+        Either::Left(let_stmt) => let_stmt_to_guarded_return(let_stmt, acc, ctx),
+        Either::Right(if_expr) => if_expr_to_guarded_return(if_expr, acc, ctx),
     }
 }
 
@@ -379,6 +377,30 @@ fn main() {
         );
     }
 
+    #[test]
+    fn convert_if_let_result_inside_let() {
+        check_assist(
+            convert_to_guarded_return,
+            r#"
+fn main() {
+    let _x = loop {
+        if$0 let Ok(x) = Err(92) {
+            foo(x);
+        }
+    };
+}
+"#,
+            r#"
+fn main() {
+    let _x = loop {
+        let Ok(x) = Err(92) else { continue };
+        foo(x);
+    };
+}
+"#,
+        );
+    }
+
     #[test]
     fn convert_if_let_chain_result() {
         check_assist(

From 11c35cd0bcb6e0c285be031f10d14d64bbf2bd9c Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Thu, 25 Sep 2025 21:57:45 +0800
Subject: [PATCH 1387/1889] Add applicable in closure for
 convert_to_guarded_return

Example
---
```rust
fn main() {
    let _f = || {
        bar();
        if$0 true {
            foo();

            // comment
            bar();
        }
    }
}
```
->
```rust
fn main() {
    let _f = || {
        bar();
        if false {
            return;
        }
        foo();

        // comment
        bar();
    }
}
```
---
 .../src/handlers/convert_to_guarded_return.rs | 54 +++++++++++++++++--
 1 file changed, 49 insertions(+), 5 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_to_guarded_return.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_to_guarded_return.rs
index aee9ce7878b29..82213ae3217e7 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_to_guarded_return.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_to_guarded_return.rs
@@ -1,11 +1,11 @@
 use std::iter::once;
 
-use hir::Semantics;
 use either::Either;
+use hir::{Semantics, TypeInfo};
 use ide_db::{RootDatabase, ty_filter::TryEnum};
 use syntax::{
     AstNode,
-    SyntaxKind::{FN, FOR_EXPR, LOOP_EXPR, WHILE_EXPR, WHITESPACE},
+    SyntaxKind::{CLOSURE_EXPR, FN, FOR_EXPR, LOOP_EXPR, WHILE_EXPR, WHITESPACE},
     SyntaxNode, T,
     ast::{
         self,
@@ -228,16 +228,26 @@ fn early_expression(
     parent_container: SyntaxNode,
     sema: &Semantics<'_, RootDatabase>,
 ) -> Option<ast::Expr> {
+    let return_none_expr = || {
+        let none_expr = make::expr_path(make::ext::ident_path("None"));
+        make::expr_return(Some(none_expr))
+    };
     if let Some(fn_) = ast::Fn::cast(parent_container.clone())
         && let Some(fn_def) = sema.to_def(&fn_)
         && let Some(TryEnum::Option) = TryEnum::from_ty(sema, &fn_def.ret_type(sema.db))
     {
-        let none_expr = make::expr_path(make::ext::ident_path("None"));
-        return Some(make::expr_return(Some(none_expr)));
+        return Some(return_none_expr());
+    }
+    if let Some(body) = ast::ClosureExpr::cast(parent_container.clone()).and_then(|it| it.body())
+        && let Some(ret_ty) = sema.type_of_expr(&body).map(TypeInfo::original)
+        && let Some(TryEnum::Option) = TryEnum::from_ty(sema, &ret_ty)
+    {
+        return Some(return_none_expr());
     }
+
     Some(match parent_container.kind() {
         WHILE_EXPR | LOOP_EXPR | FOR_EXPR => make::expr_continue(None),
-        FN => make::expr_return(None),
+        FN | CLOSURE_EXPR => make::expr_return(None),
         _ => return None,
     })
 }
@@ -329,6 +339,40 @@ fn ret_option() -> Option<()> {
         );
     }
 
+    #[test]
+    fn convert_inside_closure() {
+        check_assist(
+            convert_to_guarded_return,
+            r#"
+fn main() {
+    let _f = || {
+        bar();
+        if$0 true {
+            foo();
+
+            // comment
+            bar();
+        }
+    }
+}
+"#,
+            r#"
+fn main() {
+    let _f = || {
+        bar();
+        if false {
+            return;
+        }
+        foo();
+
+        // comment
+        bar();
+    }
+}
+"#,
+        );
+    }
+
     #[test]
     fn convert_let_inside_fn() {
         check_assist(

From 89a3a445bfb31637549e4f1a652869f631416c73 Mon Sep 17 00:00:00 2001
From: Josh Triplett <josh@joshtriplett.org>
Date: Thu, 25 Sep 2025 07:18:36 -0700
Subject: [PATCH 1388/1889] mbe: macro_check: Fix function comments referencing
 non-existent parameters

Several functions had comments referencing a non-existent `valid`
parameter. Remove those. The `guar` parameter that handles errors is
already documented.

In the process, remove another duplicate reference to an
already-documented parameter (`binders`).
---
 compiler/rustc_expand/src/mbe/macro_check.rs | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/compiler/rustc_expand/src/mbe/macro_check.rs b/compiler/rustc_expand/src/mbe/macro_check.rs
index ebd6e887f7d28..0eae44a05e783 100644
--- a/compiler/rustc_expand/src/mbe/macro_check.rs
+++ b/compiler/rustc_expand/src/mbe/macro_check.rs
@@ -210,8 +210,7 @@ pub(super) fn check_meta_variables(
     guar.map_or(Ok(()), Err)
 }
 
-/// Checks `lhs` as part of the LHS of a macro definition, extends `binders` with new binders, and
-/// sets `valid` to false in case of errors.
+/// Checks `lhs` as part of the LHS of a macro definition.
 ///
 /// Arguments:
 /// - `psess` is used to emit diagnostics and lints
@@ -306,8 +305,7 @@ fn get_binder_info<'a>(
     binders.get(&name).or_else(|| macros.find_map(|state| state.binders.get(&name)))
 }
 
-/// Checks `rhs` as part of the RHS of a macro definition and sets `valid` to false in case of
-/// errors.
+/// Checks `rhs` as part of the RHS of a macro definition.
 ///
 /// Arguments:
 /// - `psess` is used to emit diagnostics and lints
@@ -372,7 +370,7 @@ enum NestedMacroState {
 }
 
 /// Checks `tts` as part of the RHS of a macro definition, tries to recognize nested macro
-/// definitions, and sets `valid` to false in case of errors.
+/// definitions.
 ///
 /// Arguments:
 /// - `psess` is used to emit diagnostics and lints
@@ -491,8 +489,7 @@ fn check_nested_occurrences(
     }
 }
 
-/// Checks the body of nested macro, returns where the check stopped, and sets `valid` to false in
-/// case of errors.
+/// Checks the body of nested macro, returns where the check stopped.
 ///
 /// The token trees are checked as long as they look like a list of (LHS) => {RHS} token trees. This
 /// check is a best-effort to detect a macro definition. It returns the position in `tts` where we

From 9877b26fd14d32064b1f944dd1e79c9c8faccf16 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 25 Sep 2025 16:42:45 +0200
Subject: [PATCH 1389/1889] Correctly display merged doctest compilation time

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

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index 95bd31729de18..9499258f983a1 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -404,11 +404,15 @@ pub(crate) fn run_tests(
             std::mem::drop(temp_dir.take());
             times.display_times();
         });
+    } else {
+        // If the first condition branch exited successfully, `test_main_with_exit_callback` will
+        // not exit the process. So to prevent displaying the times twice, we put it behind an
+        // `else` condition.
+        times.display_times();
     }
+    // We ensure temp dir destructor is called.
+    std::mem::drop(temp_dir);
     if nb_errors != 0 {
-        // We ensure temp dir destructor is called.
-        std::mem::drop(temp_dir);
-        times.display_times();
         std::process::exit(test::ERROR_EXIT_CODE);
     }
 }

From 9e3f7487e9e572aee95381688bda52525d79b005 Mon Sep 17 00:00:00 2001
From: Josh Triplett <josh@joshtriplett.org>
Date: Thu, 25 Sep 2025 07:43:25 -0700
Subject: [PATCH 1390/1889] mbe: Simplify check_redundant_vis_repetition

Eliminate a use of `map_or` in favor of a match.

Inline some variable definitions that don't add clarity, and that
prevent short-circuiting.
---
 compiler/rustc_expand/src/mbe/macro_rules.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_expand/src/mbe/macro_rules.rs b/compiler/rustc_expand/src/mbe/macro_rules.rs
index 1d147a0385c68..74b7de7e12bc8 100644
--- a/compiler/rustc_expand/src/mbe/macro_rules.rs
+++ b/compiler/rustc_expand/src/mbe/macro_rules.rs
@@ -894,12 +894,12 @@ fn check_redundant_vis_repetition(
     seq: &SequenceRepetition,
     span: &DelimSpan,
 ) {
-    let is_zero_or_one: bool = seq.kleene.op == KleeneOp::ZeroOrOne;
-    let is_vis = seq.tts.first().map_or(false, |tt| {
-        matches!(tt, mbe::TokenTree::MetaVarDecl { kind: NonterminalKind::Vis, .. })
-    });
-
-    if is_vis && is_zero_or_one {
+    if seq.kleene.op == KleeneOp::ZeroOrOne
+        && matches!(
+            seq.tts.first(),
+            Some(mbe::TokenTree::MetaVarDecl { kind: NonterminalKind::Vis, .. })
+        )
+    {
         err.note("a `vis` fragment can already be empty");
         err.multipart_suggestion(
             "remove the `$(` and `)?`",

From 7e58c9110521d960cb97e730dfe700b3ec64c9ab Mon Sep 17 00:00:00 2001
From: helldawg <116204326+helldawg@users.noreply.github.com>
Date: Fri, 19 Sep 2025 04:59:14 +0300
Subject: [PATCH 1391/1889] usize/isize range matching error clarification

---
 .../src/thir/pattern/check_match.rs           |  8 +++----
 ...ture-gate-precise_pointer_size_matching.rs |  4 ++--
 ...-gate-precise_pointer_size_matching.stderr |  4 ++--
 .../pointer-sized-int.deny.stderr             | 22 +++++++++----------
 .../precise_pointer_matching-message.rs       |  4 ++--
 .../precise_pointer_matching-message.stderr   |  4 ++--
 ...pes-containing-non-exhaustive-types.stderr | 16 +++++++-------
 7 files changed, 31 insertions(+), 31 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 ae67bb5075e8f..3929a97eed8f2 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -1275,13 +1275,13 @@ fn report_non_exhaustive_match<'p, 'tcx>(
             if ty.is_ptr_sized_integral() {
                 if ty.inner() == cx.tcx.types.usize {
                     err.note(format!(
-                        "`{ty}` does not have a fixed maximum value, so half-open ranges are \
-                         necessary to match exhaustively",
+                        "`{ty}::MAX` is not treated as exhaustive, \
+                        so half-open ranges are necessary to match exhaustively",
                     ));
                 } else if ty.inner() == cx.tcx.types.isize {
                     err.note(format!(
-                        "`{ty}` does not have fixed minimum and maximum values, so half-open \
-                         ranges are necessary to match exhaustively",
+                        "`{ty}::MIN` and `{ty}::MAX` are not treated as exhaustive, \
+                        so half-open ranges are necessary to match exhaustively",
                     ));
                 }
             } else if ty.inner() == cx.tcx.types.str_ {
diff --git a/tests/ui/feature-gates/feature-gate-precise_pointer_size_matching.rs b/tests/ui/feature-gates/feature-gate-precise_pointer_size_matching.rs
index b4dc1fd45564d..e37e405d1aff0 100644
--- a/tests/ui/feature-gates/feature-gate-precise_pointer_size_matching.rs
+++ b/tests/ui/feature-gates/feature-gate-precise_pointer_size_matching.rs
@@ -3,7 +3,7 @@ fn main() {
         //~^ ERROR non-exhaustive patterns: `usize::MAX..` not covered
         //~| NOTE pattern `usize::MAX..` not covered
         //~| NOTE the matched value is of type `usize`
-        //~| NOTE `usize` does not have a fixed maximum value
+        //~| NOTE `usize::MAX` is not treated as exhaustive, so half-open ranges are necessary to match exhaustively
         0..=usize::MAX => {}
     }
 
@@ -11,7 +11,7 @@ fn main() {
         //~^ ERROR non-exhaustive patterns: `..isize::MIN` and `isize::MAX..` not covered
         //~| NOTE patterns `..isize::MIN` and `isize::MAX..` not covered
         //~| NOTE the matched value is of type `isize`
-        //~| NOTE `isize` does not have fixed minimum and maximum values
+        //~| NOTE `isize::MIN` and `isize::MAX` are not treated as exhaustive, so half-open ranges are necessary to match exhaustively
         isize::MIN..=isize::MAX => {}
     }
 }
diff --git a/tests/ui/feature-gates/feature-gate-precise_pointer_size_matching.stderr b/tests/ui/feature-gates/feature-gate-precise_pointer_size_matching.stderr
index c89dcaf727ac3..cfb00d6e74128 100644
--- a/tests/ui/feature-gates/feature-gate-precise_pointer_size_matching.stderr
+++ b/tests/ui/feature-gates/feature-gate-precise_pointer_size_matching.stderr
@@ -5,7 +5,7 @@ LL |     match 0usize {
    |           ^^^^^^ pattern `usize::MAX..` not covered
    |
    = note: the matched value is of type `usize`
-   = note: `usize` does not have a fixed maximum value, so half-open ranges are necessary to match exhaustively
+   = note: `usize::MAX` is not treated as exhaustive, so half-open ranges are necessary to match exhaustively
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
    |
 LL ~         0..=usize::MAX => {},
@@ -19,7 +19,7 @@ LL |     match 0isize {
    |           ^^^^^^ patterns `..isize::MIN` and `isize::MAX..` not covered
    |
    = note: the matched value is of type `isize`
-   = note: `isize` does not have fixed minimum and maximum values, so half-open ranges are necessary to match exhaustively
+   = note: `isize::MIN` and `isize::MAX` are not treated as exhaustive, so half-open ranges are necessary to match exhaustively
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern, a match arm with multiple or-patterns as shown, or multiple match arms
    |
 LL ~         isize::MIN..=isize::MAX => {},
diff --git a/tests/ui/pattern/usefulness/integer-ranges/pointer-sized-int.deny.stderr b/tests/ui/pattern/usefulness/integer-ranges/pointer-sized-int.deny.stderr
index 7caee64a33fbc..099d6e862434c 100644
--- a/tests/ui/pattern/usefulness/integer-ranges/pointer-sized-int.deny.stderr
+++ b/tests/ui/pattern/usefulness/integer-ranges/pointer-sized-int.deny.stderr
@@ -5,7 +5,7 @@ LL |     match 0usize {
    |           ^^^^^^ pattern `usize::MAX..` not covered
    |
    = note: the matched value is of type `usize`
-   = note: `usize` does not have a fixed maximum value, so half-open ranges are necessary to match exhaustively
+   = note: `usize::MAX` is not treated as exhaustive, so half-open ranges are necessary to match exhaustively
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
    |
 LL ~         0..=usize::MAX => {},
@@ -19,7 +19,7 @@ LL |     match 0isize {
    |           ^^^^^^ patterns `..isize::MIN` and `isize::MAX..` not covered
    |
    = note: the matched value is of type `isize`
-   = note: `isize` does not have fixed minimum and maximum values, so half-open ranges are necessary to match exhaustively
+   = note: `isize::MIN` and `isize::MAX` are not treated as exhaustive, so half-open ranges are necessary to match exhaustively
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern, a match arm with multiple or-patterns as shown, or multiple match arms
    |
 LL ~         isize::MIN..=isize::MAX => {},
@@ -33,7 +33,7 @@ LL |     m!(0usize, 0..=usize::MAX);
    |        ^^^^^^ pattern `usize::MAX..` not covered
    |
    = note: the matched value is of type `usize`
-   = note: `usize` does not have a fixed maximum value, so half-open ranges are necessary to match exhaustively
+   = note: `usize::MAX` is not treated as exhaustive, so half-open ranges are necessary to match exhaustively
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
    |
 LL |         match $s { $($t)+ => {}, usize::MAX.. => todo!() }
@@ -46,7 +46,7 @@ LL |     m!(0usize, 0..5 | 5..=usize::MAX);
    |        ^^^^^^ pattern `usize::MAX..` not covered
    |
    = note: the matched value is of type `usize`
-   = note: `usize` does not have a fixed maximum value, so half-open ranges are necessary to match exhaustively
+   = note: `usize::MAX` is not treated as exhaustive, so half-open ranges are necessary to match exhaustively
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
    |
 LL |         match $s { $($t)+ => {}, usize::MAX.. => todo!() }
@@ -59,7 +59,7 @@ LL |     m!(0usize, 0..usize::MAX | usize::MAX);
    |        ^^^^^^ pattern `usize::MAX..` not covered
    |
    = note: the matched value is of type `usize`
-   = note: `usize` does not have a fixed maximum value, so half-open ranges are necessary to match exhaustively
+   = note: `usize::MAX` is not treated as exhaustive, so half-open ranges are necessary to match exhaustively
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
    |
 LL |         match $s { $($t)+ => {}, usize::MAX.. => todo!() }
@@ -72,7 +72,7 @@ LL |     m!((0usize, true), (0..5, true) | (5..=usize::MAX, true) | (0..=usize::
    |        ^^^^^^^^^^^^^^ pattern `(usize::MAX.., _)` not covered
    |
    = note: the matched value is of type `(usize, bool)`
-   = note: `usize` does not have a fixed maximum value, so half-open ranges are necessary to match exhaustively
+   = note: `usize::MAX` is not treated as exhaustive, so half-open ranges are necessary to match exhaustively
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
    |
 LL |         match $s { $($t)+ => {}, (usize::MAX.., _) => todo!() }
@@ -85,7 +85,7 @@ LL |     m!(0isize, isize::MIN..=isize::MAX);
    |        ^^^^^^ patterns `..isize::MIN` and `isize::MAX..` not covered
    |
    = note: the matched value is of type `isize`
-   = note: `isize` does not have fixed minimum and maximum values, so half-open ranges are necessary to match exhaustively
+   = note: `isize::MIN` and `isize::MAX` are not treated as exhaustive, so half-open ranges are necessary to match exhaustively
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern, a match arm with multiple or-patterns as shown, or multiple match arms
    |
 LL |         match $s { $($t)+ => {}, ..isize::MIN | isize::MAX.. => todo!() }
@@ -98,7 +98,7 @@ LL |     m!(0isize, isize::MIN..5 | 5..=isize::MAX);
    |        ^^^^^^ patterns `..isize::MIN` and `isize::MAX..` not covered
    |
    = note: the matched value is of type `isize`
-   = note: `isize` does not have fixed minimum and maximum values, so half-open ranges are necessary to match exhaustively
+   = note: `isize::MIN` and `isize::MAX` are not treated as exhaustive, so half-open ranges are necessary to match exhaustively
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern, a match arm with multiple or-patterns as shown, or multiple match arms
    |
 LL |         match $s { $($t)+ => {}, ..isize::MIN | isize::MAX.. => todo!() }
@@ -111,7 +111,7 @@ LL |     m!(0isize, isize::MIN..=-1 | 0 | 1..=isize::MAX);
    |        ^^^^^^ patterns `..isize::MIN` and `isize::MAX..` not covered
    |
    = note: the matched value is of type `isize`
-   = note: `isize` does not have fixed minimum and maximum values, so half-open ranges are necessary to match exhaustively
+   = note: `isize::MIN` and `isize::MAX` are not treated as exhaustive, so half-open ranges are necessary to match exhaustively
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern, a match arm with multiple or-patterns as shown, or multiple match arms
    |
 LL |         match $s { $($t)+ => {}, ..isize::MIN | isize::MAX.. => todo!() }
@@ -124,7 +124,7 @@ LL |     m!(0isize, isize::MIN..isize::MAX | isize::MAX);
    |        ^^^^^^ patterns `..isize::MIN` and `isize::MAX..` not covered
    |
    = note: the matched value is of type `isize`
-   = note: `isize` does not have fixed minimum and maximum values, so half-open ranges are necessary to match exhaustively
+   = note: `isize::MIN` and `isize::MAX` are not treated as exhaustive, so half-open ranges are necessary to match exhaustively
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern, a match arm with multiple or-patterns as shown, or multiple match arms
    |
 LL |         match $s { $($t)+ => {}, ..isize::MIN | isize::MAX.. => todo!() }
@@ -137,7 +137,7 @@ LL |         (0isize, true),
    |         ^^^^^^^^^^^^^^ patterns `(..isize::MIN, _)` and `(isize::MAX.., _)` not covered
    |
    = note: the matched value is of type `(isize, bool)`
-   = note: `isize` does not have fixed minimum and maximum values, so half-open ranges are necessary to match exhaustively
+   = note: `isize::MIN` and `isize::MAX` are not treated as exhaustive, so half-open ranges are necessary to match exhaustively
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern, a match arm with multiple or-patterns as shown, or multiple match arms
    |
 LL |         match $s { $($t)+ => {}, (..isize::MIN, _) | (isize::MAX.., _) => todo!() }
diff --git a/tests/ui/pattern/usefulness/integer-ranges/precise_pointer_matching-message.rs b/tests/ui/pattern/usefulness/integer-ranges/precise_pointer_matching-message.rs
index d60f479c0d155..6a0106134b50a 100644
--- a/tests/ui/pattern/usefulness/integer-ranges/precise_pointer_matching-message.rs
+++ b/tests/ui/pattern/usefulness/integer-ranges/precise_pointer_matching-message.rs
@@ -4,7 +4,7 @@ fn main() {
         //~^ ERROR non-exhaustive patterns: `usize::MAX..` not covered
         //~| NOTE pattern `usize::MAX..` not covered
         //~| NOTE the matched value is of type `usize`
-        //~| NOTE `usize` does not have a fixed maximum value
+        //~| NOTE `usize::MAX` is not treated as exhaustive, so half-open ranges are necessary to match exhaustively
         0..=usize::MAX => {}
     }
 
@@ -12,7 +12,7 @@ fn main() {
         //~^ ERROR non-exhaustive patterns: `..isize::MIN` and `isize::MAX..` not covered
         //~| NOTE patterns `..isize::MIN` and `isize::MAX..` not covered
         //~| NOTE the matched value is of type `isize`
-        //~| NOTE `isize` does not have fixed minimum and maximum values
+        //~| NOTE `isize::MIN` and `isize::MAX` are not treated as exhaustive, so half-open ranges are necessary to match exhaustively
         isize::MIN..=isize::MAX => {}
     }
 }
diff --git a/tests/ui/pattern/usefulness/integer-ranges/precise_pointer_matching-message.stderr b/tests/ui/pattern/usefulness/integer-ranges/precise_pointer_matching-message.stderr
index 36743aa810296..fefe7f46ead9d 100644
--- a/tests/ui/pattern/usefulness/integer-ranges/precise_pointer_matching-message.stderr
+++ b/tests/ui/pattern/usefulness/integer-ranges/precise_pointer_matching-message.stderr
@@ -5,7 +5,7 @@ LL |     match 0usize {
    |           ^^^^^^ pattern `usize::MAX..` not covered
    |
    = note: the matched value is of type `usize`
-   = note: `usize` does not have a fixed maximum value, so half-open ranges are necessary to match exhaustively
+   = note: `usize::MAX` is not treated as exhaustive, so half-open ranges are necessary to match exhaustively
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
    |
 LL ~         0..=usize::MAX => {},
@@ -19,7 +19,7 @@ LL |     match 0isize {
    |           ^^^^^^ patterns `..isize::MIN` and `isize::MAX..` not covered
    |
    = note: the matched value is of type `isize`
-   = note: `isize` does not have fixed minimum and maximum values, so half-open ranges are necessary to match exhaustively
+   = note: `isize::MIN` and `isize::MAX` are not treated as exhaustive, so half-open ranges are necessary to match exhaustively
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern, a match arm with multiple or-patterns as shown, or multiple match arms
    |
 LL ~         isize::MIN..=isize::MAX => {},
diff --git a/tests/ui/pattern/usefulness/issue-85222-types-containing-non-exhaustive-types.stderr b/tests/ui/pattern/usefulness/issue-85222-types-containing-non-exhaustive-types.stderr
index c31411018bc46..9d7b53093df98 100644
--- a/tests/ui/pattern/usefulness/issue-85222-types-containing-non-exhaustive-types.stderr
+++ b/tests/ui/pattern/usefulness/issue-85222-types-containing-non-exhaustive-types.stderr
@@ -5,7 +5,7 @@ LL |     match 0 {
    |           ^ pattern `usize::MAX..` not covered
    |
    = note: the matched value is of type `usize`
-   = note: `usize` does not have a fixed maximum value, so half-open ranges are necessary to match exhaustively
+   = note: `usize::MAX` is not treated as exhaustive, so half-open ranges are necessary to match exhaustively
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
    |
 LL ~         1..=usize::MAX => (),
@@ -19,7 +19,7 @@ LL |     match (0usize, 0usize) {
    |           ^^^^^^^^^^^^^^^^ pattern `(usize::MAX.., _)` not covered
    |
    = note: the matched value is of type `(usize, usize)`
-   = note: `usize` does not have a fixed maximum value, so half-open ranges are necessary to match exhaustively
+   = note: `usize::MAX` is not treated as exhaustive, so half-open ranges are necessary to match exhaustively
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
    |
 LL ~         (1..=usize::MAX, 1..=usize::MAX) => (),
@@ -33,7 +33,7 @@ LL |     match (0isize, 0usize) {
    |           ^^^^^^^^^^^^^^^^ patterns `(..isize::MIN, _)` and `(isize::MAX.., _)` not covered
    |
    = note: the matched value is of type `(isize, usize)`
-   = note: `isize` does not have fixed minimum and maximum values, so half-open ranges are necessary to match exhaustively
+   = note: `isize::MIN` and `isize::MAX` are not treated as exhaustive, so half-open ranges are necessary to match exhaustively
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern, a match arm with multiple or-patterns as shown, or multiple match arms
    |
 LL ~         (isize::MIN..=isize::MAX, 1..=usize::MAX) => (),
@@ -70,7 +70,7 @@ note: `Option<usize>` defined here
    |
    = note: not covered
    = note: the matched value is of type `Option<usize>`
-   = note: `usize` does not have a fixed maximum value, so half-open ranges are necessary to match exhaustively
+   = note: `usize::MAX` is not treated as exhaustive, so half-open ranges are necessary to match exhaustively
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
    |
 LL ~         None => (),
@@ -93,7 +93,7 @@ note: `Option<Option<Option<usize>>>` defined here
    |
    = note: not covered
    = note: the matched value is of type `Option<Option<Option<usize>>>`
-   = note: `usize` does not have a fixed maximum value, so half-open ranges are necessary to match exhaustively
+   = note: `usize::MAX` is not treated as exhaustive, so half-open ranges are necessary to match exhaustively
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
    |
 LL ~         None => (),
@@ -112,7 +112,7 @@ note: `A<usize>` defined here
 LL | struct A<T> {
    |        ^
    = note: the matched value is of type `A<usize>`
-   = note: `usize` does not have a fixed maximum value, so half-open ranges are necessary to match exhaustively
+   = note: `usize::MAX` is not treated as exhaustive, so half-open ranges are necessary to match exhaustively
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
    |
 LL ~         A { a: 1..=usize::MAX } => (),
@@ -131,7 +131,7 @@ note: `B<isize, usize>` defined here
 LL | struct B<T, U>(T, U);
    |        ^
    = note: the matched value is of type `B<isize, usize>`
-   = note: `isize` does not have fixed minimum and maximum values, so half-open ranges are necessary to match exhaustively
+   = note: `isize::MIN` and `isize::MAX` are not treated as exhaustive, so half-open ranges are necessary to match exhaustively
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern, a match arm with multiple or-patterns as shown, or multiple match arms
    |
 LL ~         B(isize::MIN..=isize::MAX, 1..=usize::MAX) => (),
@@ -150,7 +150,7 @@ note: `B<isize, usize>` defined here
 LL | struct B<T, U>(T, U);
    |        ^
    = note: the matched value is of type `B<isize, usize>`
-   = note: `usize` does not have a fixed maximum value, so half-open ranges are necessary to match exhaustively
+   = note: `usize::MAX` is not treated as exhaustive, so half-open ranges are necessary to match exhaustively
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
    |
 LL ~         B(_, 1..=usize::MAX) => (),

From 185ae698aabe0f6f7cc5ef7eeed13a556bce5334 Mon Sep 17 00:00:00 2001
From: Tim 'Piepmatz' Hesse <git+github@cptpiepmatz.de>
Date: Thu, 25 Sep 2025 17:52:24 +0200
Subject: [PATCH 1392/1889] add doc for `NonZero*` const creation

---
 library/core/src/num/nonzero.rs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/library/core/src/num/nonzero.rs b/library/core/src/num/nonzero.rs
index 1b7c28bb95aab..d9184e3c9c229 100644
--- a/library/core/src/num/nonzero.rs
+++ b/library/core/src/num/nonzero.rs
@@ -548,6 +548,18 @@ macro_rules! nonzero_integer {
         #[doc = concat!("assert_eq!(align_of::<", stringify!($Ty), ">(), align_of::<Option<", stringify!($Ty), ">>());")]
         /// ```
         ///
+        /// # Compile-time creation
+        ///
+        /// Since both [`Option::unwrap()`] and [`Option::expect()`] are `const`, it is possible to
+        /// define a new
+        #[doc = concat!("`", stringify!($Ty), "`")]
+        /// at compile time via:
+        /// ```
+        #[doc = concat!("use std::num::", stringify!($Ty), ";")]
+        ///
+        #[doc = concat!("const TEN: ", stringify!($Ty), " = ", stringify!($Ty) , r#"::new(10).expect("ten is non-zero");"#)]
+        /// ```
+        ///
         /// [null pointer optimization]: crate::option#representation
         #[$stability]
         pub type $Ty = NonZero<$Int>;

From 191c7ed10f68c6891ba66e342fa58342e16db402 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Thu, 25 Sep 2025 17:32:17 +0200
Subject: [PATCH 1393/1889] Make `cargo test` work again

---
 src/bootstrap/src/core/config/config.rs | 38 +++++++++++++++++++------
 1 file changed, 30 insertions(+), 8 deletions(-)

diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index 74a272c740bd3..07a6616be0c98 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -414,15 +414,17 @@ impl Config {
         // Set config values based on flags.
         let mut exec_ctx = ExecutionContext::new(flags_verbose, flags_cmd.fail_fast());
         exec_ctx.set_dry_run(if flags_dry_run { DryRun::UserSelected } else { DryRun::Disabled });
-        let mut src = {
+
+        let default_src_dir = {
             let manifest_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
             // Undo `src/bootstrap`
             manifest_dir.parent().unwrap().parent().unwrap().to_owned()
         };
-
-        if let Some(src_) = compute_src_directory(flags_src, &exec_ctx) {
-            src = src_;
-        }
+        let src = if let Some(s) = compute_src_directory(flags_src, &exec_ctx) {
+            s
+        } else {
+            default_src_dir.clone()
+        };
 
         #[cfg(test)]
         {
@@ -659,6 +661,10 @@ impl Config {
             out
         };
 
+        let default_stage0_rustc_path = |dir: &Path| {
+            dir.join(host_target).join("stage0").join("bin").join(exe("rustc", host_target))
+        };
+
         if cfg!(test) {
             // When configuring bootstrap for tests, make sure to set the rustc and Cargo to the
             // same ones used to call the tests (if custom ones are not defined in the toml). If we
@@ -667,6 +673,22 @@ impl Config {
             // Cargo in their bootstrap.toml.
             build_rustc = build_rustc.take().or(std::env::var_os("RUSTC").map(|p| p.into()));
             build_cargo = build_cargo.take().or(std::env::var_os("CARGO").map(|p| p.into()));
+
+            // If we are running only `cargo test` (and not `x test bootstrap`), which is useful
+            // e.g. for debugging bootstrap itself, then we won't have RUSTC and CARGO set to the
+            // proper paths.
+            // We thus "guess" that the build directory is located at <src>/build, and try to load
+            // rustc and cargo from there
+            let is_test_outside_x = std::env::var("CARGO_TARGET_DIR").is_err();
+            if is_test_outside_x && build_rustc.is_none() {
+                let stage0_rustc = default_stage0_rustc_path(&default_src_dir.join("build"));
+                assert!(
+                    stage0_rustc.exists(),
+                    "Trying to run cargo test without having a stage0 rustc available in {}",
+                    stage0_rustc.display()
+                );
+                build_rustc = Some(stage0_rustc);
+            }
         }
 
         if !flags_skip_stage0_validation {
@@ -700,7 +722,7 @@ impl Config {
 
         let initial_rustc = build_rustc.unwrap_or_else(|| {
             download_beta_toolchain(&dwn_ctx, &out);
-            out.join(host_target).join("stage0").join("bin").join(exe("rustc", host_target))
+            default_stage0_rustc_path(&out)
         });
 
         let initial_sysroot = t!(PathBuf::from_str(
@@ -1540,11 +1562,11 @@ impl Config {
                                 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 bootstrap.toml: {e}");
                                 exit!(2);
-                            },
+                            }
                         };
 
                         let current_config_toml = Self::get_toml(config_path).unwrap();

From 5595f437c7b82b1ca18f77f8834fe9398b682153 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Thu, 25 Sep 2025 18:12:39 +0200
Subject: [PATCH 1394/1889] Remove `verbose_than` function

---
 src/bootstrap/src/core/build_steps/compile.rs |  7 +------
 src/bootstrap/src/lib.rs                      | 13 ++++---------
 2 files changed, 5 insertions(+), 15 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index 14104d7d1d783..b47b4f248a9ac 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -1902,12 +1902,7 @@ impl Step for Sysroot {
                 if !path.parent().is_none_or(|p| p.ends_with(&suffix)) {
                     return true;
                 }
-                if !filtered_files.iter().all(|f| f != path.file_name().unwrap()) {
-                    builder.verbose_than(1, || println!("ignoring {}", path.display()));
-                    false
-                } else {
-                    true
-                }
+                filtered_files.iter().all(|f| f != path.file_name().unwrap())
             });
         }
 
diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs
index e953fe2945e48..db963f9c6f990 100644
--- a/src/bootstrap/src/lib.rs
+++ b/src/bootstrap/src/lib.rs
@@ -1092,13 +1092,6 @@ impl Build {
         self.verbosity > level
     }
 
-    /// Runs a function if verbosity is greater than `level`.
-    fn verbose_than(&self, level: usize, f: impl Fn()) {
-        if self.is_verbose_than(level) {
-            f()
-        }
-    }
-
     fn info(&self, msg: &str) {
         match self.config.get_dry_run() {
             DryRun::SelfCheck => (),
@@ -1816,7 +1809,6 @@ impl Build {
         if self.config.dry_run() {
             return;
         }
-        self.verbose_than(1, || println!("Copy/Link {src:?} to {dst:?}"));
         if src == dst {
             return;
         }
@@ -1933,7 +1925,10 @@ impl Build {
             return;
         }
         let dst = dstdir.join(src.file_name().unwrap());
-        self.verbose_than(1, || println!("Install {src:?} to {dst:?}"));
+
+        #[cfg(feature = "tracing")]
+        let _span = trace_io!("install", ?src, ?dst);
+
         t!(fs::create_dir_all(dstdir));
         if !src.exists() {
             panic!("ERROR: File \"{}\" not found!", src.display());

From 5a6e3cccebd9cac06af815f0480ad58d14182480 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Thu, 25 Sep 2025 18:14:33 +0200
Subject: [PATCH 1395/1889] Remove `is_verbose_than` function

---
 src/bootstrap/src/core/builder/cargo.rs | 2 +-
 src/bootstrap/src/lib.rs                | 5 -----
 2 files changed, 1 insertion(+), 6 deletions(-)

diff --git a/src/bootstrap/src/core/builder/cargo.rs b/src/bootstrap/src/core/builder/cargo.rs
index ee2bb710674c0..9fc4ce669c2a5 100644
--- a/src/bootstrap/src/core/builder/cargo.rs
+++ b/src/bootstrap/src/core/builder/cargo.rs
@@ -1139,7 +1139,7 @@ impl Builder<'_> {
             cargo.env("RUSTC_BACKTRACE_ON_ICE", "1");
         }
 
-        if self.is_verbose_than(1) {
+        if self.verbosity >= 2 {
             // This provides very useful logs especially when debugging build cache-related stuff.
             cargo.env("CARGO_LOG", "cargo::core::compiler::fingerprint=info");
         }
diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs
index db963f9c6f990..75cc79e6689c8 100644
--- a/src/bootstrap/src/lib.rs
+++ b/src/bootstrap/src/lib.rs
@@ -1087,11 +1087,6 @@ impl Build {
         })
     }
 
-    /// Check if verbosity is greater than the `level`
-    pub fn is_verbose_than(&self, level: usize) -> bool {
-        self.verbosity > level
-    }
-
     fn info(&self, msg: &str) {
         match self.config.get_dry_run() {
             DryRun::SelfCheck => (),

From 0374df1b50d227f173c07631b390b271efb04ae6 Mon Sep 17 00:00:00 2001
From: LorrensP-2158466 <lorrens.pantelis@student.uhasselt.be>
Date: Fri, 5 Sep 2025 08:34:00 +0200
Subject: [PATCH 1396/1889] Introduce and use CmCell during import resolution.

---
 .../rustc_resolve/src/build_reduced_graph.rs  |  19 +--
 compiler/rustc_resolve/src/imports.rs         |  26 ++--
 compiler/rustc_resolve/src/lib.rs             | 128 +++++++++++++++---
 compiler/rustc_resolve/src/macros.rs          |   2 +-
 4 files changed, 135 insertions(+), 40 deletions(-)

diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
index fa3c06059b3da..c10b6ca7e71b5 100644
--- a/compiler/rustc_resolve/src/build_reduced_graph.rs
+++ b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -5,7 +5,6 @@
 //! unexpanded macros in the fragment are visited and registered.
 //! Imports are also considered items and placed into modules here, but not resolved yet.
 
-use std::cell::Cell;
 use std::sync::Arc;
 
 use rustc_ast::visit::{self, AssocCtxt, Visitor, WalkItemKind};
@@ -35,6 +34,7 @@ use crate::Namespace::{MacroNS, TypeNS, ValueNS};
 use crate::def_collector::collect_definitions;
 use crate::imports::{ImportData, ImportKind};
 use crate::macros::{MacroRulesBinding, MacroRulesScope, MacroRulesScopeRef};
+use crate::ref_mut::CmCell;
 use crate::{
     BindingKey, ExternPreludeEntry, Finalize, MacroData, Module, ModuleKind, ModuleOrUniformRoot,
     NameBinding, ParentScope, PathResult, ResolutionError, Resolver, Segment, Used,
@@ -87,7 +87,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         // because they can be fetched by glob imports from those modules, and bring traits
         // into scope both directly and through glob imports.
         let key = BindingKey::new_disambiguated(ident, ns, || {
-            parent.underscore_disambiguator.update(|d| d + 1);
+            // FIXME(batched): Will be fixed in batched resolution.
+            parent.underscore_disambiguator.update_unchecked(|d| d + 1);
             parent.underscore_disambiguator.get()
         });
         if self
@@ -477,7 +478,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
             kind,
             parent_scope: self.parent_scope,
             module_path,
-            imported_module: Cell::new(None),
+            imported_module: CmCell::new(None),
             span,
             use_span: item.span,
             use_span_with_attributes: item.span_with_attributes(),
@@ -505,7 +506,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                     });
                 }
             }
-            ImportKind::Glob { .. } => current_module.globs.borrow_mut().push(import),
+            ImportKind::Glob { .. } => current_module.globs.borrow_mut(self.r).push(import),
             _ => unreachable!(),
         }
     }
@@ -668,7 +669,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
             }
             ast::UseTreeKind::Glob => {
                 if !ast::attr::contains_name(&item.attrs, sym::prelude_import) {
-                    let kind = ImportKind::Glob { max_vis: Cell::new(None), id };
+                    let kind = ImportKind::Glob { max_vis: CmCell::new(None), id };
                     self.add_import(prefix, kind, use_tree.span, item, root_span, item.id, vis);
                 } else {
                     // Resolve the prelude import early.
@@ -971,7 +972,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
             kind: ImportKind::ExternCrate { source: orig_name, target: ident, id: item.id },
             root_id: item.id,
             parent_scope: self.parent_scope,
-            imported_module: Cell::new(module),
+            imported_module: CmCell::new(module),
             has_attributes: !item.attrs.is_empty(),
             use_span_with_attributes: item.span_with_attributes(),
             use_span: item.span,
@@ -1103,7 +1104,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                 kind: ImportKind::MacroUse { warn_private },
                 root_id: item.id,
                 parent_scope: this.parent_scope,
-                imported_module: Cell::new(Some(ModuleOrUniformRoot::Module(module))),
+                imported_module: CmCell::new(Some(ModuleOrUniformRoot::Module(module))),
                 use_span_with_attributes: item.span_with_attributes(),
                 has_attributes: !item.attrs.is_empty(),
                 use_span: item.span,
@@ -1196,7 +1197,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
     /// directly into its parent scope's module.
     fn visit_invoc_in_module(&mut self, id: NodeId) -> MacroRulesScopeRef<'ra> {
         let invoc_id = self.visit_invoc(id);
-        self.parent_scope.module.unexpanded_invocations.borrow_mut().insert(invoc_id);
+        self.parent_scope.module.unexpanded_invocations.borrow_mut(self.r).insert(invoc_id);
         self.r.arenas.alloc_macro_rules_scope(MacroRulesScope::Invocation(invoc_id))
     }
 
@@ -1274,7 +1275,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                     kind: ImportKind::MacroExport,
                     root_id: item.id,
                     parent_scope: self.parent_scope,
-                    imported_module: Cell::new(None),
+                    imported_module: CmCell::new(None),
                     has_attributes: false,
                     use_span_with_attributes: span,
                     use_span: span,
diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
index d7fc028287ff5..2370bf8093943 100644
--- a/compiler/rustc_resolve/src/imports.rs
+++ b/compiler/rustc_resolve/src/imports.rs
@@ -1,6 +1,5 @@
 //! A bunch of methods and structures more or less related to resolving imports.
 
-use std::cell::Cell;
 use std::mem;
 
 use rustc_ast::NodeId;
@@ -32,6 +31,7 @@ use crate::errors::{
     CannotBeReexportedPrivateNS, CannotDetermineImportResolution, CannotGlobImportAllCrates,
     ConsiderAddingMacroExport, ConsiderMarkingAsPub, ConsiderMarkingAsPubCrate,
 };
+use crate::ref_mut::CmCell;
 use crate::{
     AmbiguityError, AmbiguityKind, BindingKey, CmResolver, Determinacy, Finalize, ImportSuggestion,
     Module, ModuleOrUniformRoot, NameBinding, NameBindingData, NameBindingKind, ParentScope,
@@ -68,7 +68,7 @@ pub(crate) enum ImportKind<'ra> {
         /// It will directly use `source` when the format is `use prefix::source`.
         target: Ident,
         /// Bindings introduced by the import.
-        bindings: PerNS<Cell<PendingBinding<'ra>>>,
+        bindings: PerNS<CmCell<PendingBinding<'ra>>>,
         /// `true` for `...::{self [as target]}` imports, `false` otherwise.
         type_ns_only: bool,
         /// Did this import result from a nested import? ie. `use foo::{bar, baz};`
@@ -89,7 +89,7 @@ pub(crate) enum ImportKind<'ra> {
     Glob {
         // The visibility of the greatest re-export.
         // n.b. `max_vis` is only used in `finalize_import` to check for re-export errors.
-        max_vis: Cell<Option<Visibility>>,
+        max_vis: CmCell<Option<Visibility>>,
         id: NodeId,
     },
     ExternCrate {
@@ -182,7 +182,7 @@ pub(crate) struct ImportData<'ra> {
     /// |`use ::foo`      | `ModuleOrUniformRoot::ExternPrelude`          | 2018+ editions |
     /// |`use ::foo`      | `ModuleOrUniformRoot::ModuleAndExternPrelude` | a special case in 2015 edition |
     /// |`use foo`        | `ModuleOrUniformRoot::CurrentScope`           | - |
-    pub imported_module: Cell<Option<ModuleOrUniformRoot<'ra>>>,
+    pub imported_module: CmCell<Option<ModuleOrUniformRoot<'ra>>>,
     pub vis: Visibility,
 
     /// Span of the visibility.
@@ -320,7 +320,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             && (vis == import_vis
                 || max_vis.get().is_none_or(|max_vis| vis.is_at_least(max_vis, self.tcx)))
         {
-            max_vis.set(Some(vis.expect_local()))
+            // FIXME(batched): Will be fixed in batched import resolution.
+            max_vis.set_unchecked(Some(vis.expect_local()))
         }
 
         self.arenas.alloc_name_binding(NameBindingData {
@@ -349,7 +350,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         // because they can be fetched by glob imports from those modules, and bring traits
         // into scope both directly and through glob imports.
         let key = BindingKey::new_disambiguated(ident, ns, || {
-            module.underscore_disambiguator.update(|d| d + 1);
+            // FIXME(batched): Will be fixed in batched resolution.
+            module.underscore_disambiguator.update_unchecked(|d| d + 1);
             module.underscore_disambiguator.get()
         });
         self.update_local_resolution(module, key, warn_ambiguity, |this, resolution| {
@@ -482,7 +484,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             }
         };
 
-        let Ok(glob_importers) = module.glob_importers.try_borrow_mut() else {
+        let Ok(glob_importers) = module.glob_importers.try_borrow_mut_unchecked() else {
             return t;
         };
 
@@ -862,7 +864,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             }
         };
 
-        import.imported_module.set(Some(module));
+        // FIXME(batched): Will be fixed in batched import resolution.
+        import.imported_module.set_unchecked(Some(module));
         let (source, target, bindings, type_ns_only) = match import.kind {
             ImportKind::Single { source, target, ref bindings, type_ns_only, .. } => {
                 (source, target, bindings, type_ns_only)
@@ -937,7 +940,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         PendingBinding::Pending
                     }
                 };
-                bindings[ns].set(binding);
+                // FIXME(batched): Will be fixed in batched import resolution.
+                bindings[ns].set_unchecked(binding);
             }
         });
 
@@ -1508,7 +1512,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         }
 
         // Add to module's glob_importers
-        module.glob_importers.borrow_mut().push(import);
+        module.glob_importers.borrow_mut_unchecked().push(import);
 
         // Ensure that `resolutions` isn't borrowed during `try_define`,
         // since it might get updated via a glob cycle.
@@ -1550,7 +1554,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     // reporting conflicts, and reporting unresolved imports.
     fn finalize_resolutions_in(&mut self, module: Module<'ra>) {
         // Since import resolution is finished, globs will not define any more names.
-        *module.globs.borrow_mut() = Vec::new();
+        *module.globs.borrow_mut(self) = Vec::new();
 
         let Some(def_id) = module.opt_def_id() else { return };
 
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index 0dea6ae332735..245bcdac81e86 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -19,6 +19,7 @@
 #![feature(default_field_values)]
 #![feature(if_let_guard)]
 #![feature(iter_intersperse)]
+#![feature(ptr_as_ref_unchecked)]
 #![feature(rustc_attrs)]
 #![feature(rustdoc_internals)]
 #![recursion_limit = "256"]
@@ -26,7 +27,7 @@
 
 use std::cell::{Cell, Ref, RefCell};
 use std::collections::BTreeSet;
-use std::fmt;
+use std::fmt::{self};
 use std::sync::Arc;
 
 use diagnostics::{ImportSuggestion, LabelSuggestion, Suggestion};
@@ -95,6 +96,8 @@ pub mod rustdoc;
 
 pub use macros::registered_tools_ast;
 
+use crate::ref_mut::{CmCell, CmRefCell};
+
 rustc_fluent_macro::fluent_messages! { "../messages.ftl" }
 
 #[derive(Debug)]
@@ -592,22 +595,22 @@ struct ModuleData<'ra> {
     /// Resolutions in modules from other crates are not populated until accessed.
     lazy_resolutions: Resolutions<'ra>,
     /// True if this is a module from other crate that needs to be populated on access.
-    populate_on_access: Cell<bool>,
+    populate_on_access: Cell<bool>, // FIXME(parallel): Use an atomic in parallel import resolution
     /// Used to disambiguate underscore items (`const _: T = ...`) in the module.
-    underscore_disambiguator: Cell<u32>,
+    underscore_disambiguator: CmCell<u32>,
 
     /// Macro invocations that can expand into items in this module.
-    unexpanded_invocations: RefCell<FxHashSet<LocalExpnId>>,
+    unexpanded_invocations: CmRefCell<FxHashSet<LocalExpnId>>,
 
     /// Whether `#[no_implicit_prelude]` is active.
     no_implicit_prelude: bool,
 
-    glob_importers: RefCell<Vec<Import<'ra>>>,
-    globs: RefCell<Vec<Import<'ra>>>,
+    glob_importers: CmRefCell<Vec<Import<'ra>>>,
+    globs: CmRefCell<Vec<Import<'ra>>>,
 
     /// Used to memoize the traits in this module for faster searches through all traits in scope.
     traits:
-        RefCell<Option<Box<[(Macros20NormalizedIdent, NameBinding<'ra>, Option<Module<'ra>>)]>>>,
+        CmRefCell<Option<Box<[(Macros20NormalizedIdent, NameBinding<'ra>, Option<Module<'ra>>)]>>>,
 
     /// Span of the module itself. Used for error reporting.
     span: Span,
@@ -656,12 +659,12 @@ impl<'ra> ModuleData<'ra> {
             kind,
             lazy_resolutions: Default::default(),
             populate_on_access: Cell::new(is_foreign),
-            underscore_disambiguator: Cell::new(0),
+            underscore_disambiguator: CmCell::new(0),
             unexpanded_invocations: Default::default(),
             no_implicit_prelude,
-            glob_importers: RefCell::new(Vec::new()),
-            globs: RefCell::new(Vec::new()),
-            traits: RefCell::new(None),
+            glob_importers: CmRefCell::new(Vec::new()),
+            globs: CmRefCell::new(Vec::new()),
+            traits: CmRefCell::new(None),
             span,
             expansion,
             self_binding,
@@ -696,7 +699,7 @@ impl<'ra> Module<'ra> {
 
     /// This modifies `self` in place. The traits will be stored in `self.traits`.
     fn ensure_traits<'tcx>(self, resolver: &impl AsRef<Resolver<'ra, 'tcx>>) {
-        let mut traits = self.traits.borrow_mut();
+        let mut traits = self.traits.borrow_mut(resolver.as_ref());
         if traits.is_none() {
             let mut collected_traits = Vec::new();
             self.for_each_child(resolver, |r, name, ns, binding| {
@@ -1974,6 +1977,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
     fn resolutions(&self, module: Module<'ra>) -> &'ra Resolutions<'ra> {
         if module.populate_on_access.get() {
+            // FIXME(batched): Will be fixed in batched import resolution.
             module.populate_on_access.set(false);
             self.build_reduced_graph_external(module);
         }
@@ -2502,9 +2506,20 @@ pub fn provide(providers: &mut Providers) {
     providers.registered_tools = macros::registered_tools;
 }
 
+/// A wrapper around `&mut Resolver` that may be mutable or immutable, depending on a conditions.
+///
+/// `Cm` stands for "conditionally mutable".
+///
+/// Prefer constructing it through [`Resolver::cm`] to ensure correctness.
+type CmResolver<'r, 'ra, 'tcx> = ref_mut::RefOrMut<'r, Resolver<'ra, 'tcx>>;
+
 mod ref_mut {
+    use std::cell::{BorrowMutError, Cell, Ref, RefCell, RefMut};
+    use std::fmt;
     use std::ops::Deref;
 
+    use crate::Resolver;
+
     /// A wrapper around a mutable reference that conditionally allows mutable access.
     pub(crate) struct RefOrMut<'a, T> {
         p: &'a mut T,
@@ -2553,11 +2568,86 @@ mod ref_mut {
             self.p
         }
     }
-}
 
-/// A wrapper around `&mut Resolver` that may be mutable or immutable, depending on a conditions.
-///
-/// `Cm` stands for "conditionally mutable".
-///
-/// Prefer constructing it through [`Resolver::cm`] to ensure correctness.
-type CmResolver<'r, 'ra, 'tcx> = ref_mut::RefOrMut<'r, Resolver<'ra, 'tcx>>;
+    /// A wrapper around a [`Cell`] that only allows mutation based on a condition in the resolver.
+    #[derive(Default)]
+    pub(crate) struct CmCell<T>(Cell<T>);
+
+    impl<T: Copy + fmt::Debug> fmt::Debug for CmCell<T> {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            f.debug_tuple("CmCell").field(&self.get()).finish()
+        }
+    }
+
+    impl<T: Copy> Clone for CmCell<T> {
+        #[inline]
+        fn clone(&self) -> CmCell<T> {
+            CmCell::new(self.get())
+        }
+    }
+
+    impl<T: Copy> CmCell<T> {
+        pub(crate) const fn get(&self) -> T {
+            self.0.get()
+        }
+
+        pub(crate) fn update_unchecked(&self, f: impl FnOnce(T) -> T)
+        where
+            T: Copy,
+        {
+            let old = self.get();
+            self.set_unchecked(f(old));
+        }
+    }
+
+    impl<T> CmCell<T> {
+        pub(crate) const fn new(value: T) -> CmCell<T> {
+            CmCell(Cell::new(value))
+        }
+
+        pub(crate) fn set_unchecked(&self, val: T) {
+            self.0.set(val);
+        }
+
+        pub(crate) fn into_inner(self) -> T {
+            self.0.into_inner()
+        }
+    }
+
+    /// A wrapper around a [`RefCell`] that only allows mutable borrows based on a condition in the resolver.
+    #[derive(Default)]
+    pub(crate) struct CmRefCell<T>(RefCell<T>);
+
+    impl<T> CmRefCell<T> {
+        pub(crate) const fn new(value: T) -> CmRefCell<T> {
+            CmRefCell(RefCell::new(value))
+        }
+
+        #[inline]
+        #[track_caller]
+        pub(crate) fn borrow_mut_unchecked(&self) -> RefMut<'_, T> {
+            self.0.borrow_mut()
+        }
+
+        #[inline]
+        #[track_caller]
+        pub(crate) fn borrow_mut<'ra, 'tcx>(&self, r: &Resolver<'ra, 'tcx>) -> RefMut<'_, T> {
+            if r.assert_speculative {
+                panic!("Not allowed to mutably borrow a CmRefCell during speculative resolution");
+            }
+            self.borrow_mut_unchecked()
+        }
+
+        #[inline]
+        #[track_caller]
+        pub(crate) fn try_borrow_mut_unchecked(&self) -> Result<RefMut<'_, T>, BorrowMutError> {
+            self.0.try_borrow_mut()
+        }
+
+        #[inline]
+        #[track_caller]
+        pub(crate) fn borrow(&self) -> Ref<'_, T> {
+            self.0.borrow()
+        }
+    }
+}
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs
index 5fa87b4cd9b68..3b6ef88c5303a 100644
--- a/compiler/rustc_resolve/src/macros.rs
+++ b/compiler/rustc_resolve/src/macros.rs
@@ -189,7 +189,7 @@ impl<'ra, 'tcx> ResolverExpand for Resolver<'ra, 'tcx> {
         let output_macro_rules_scope = self.build_reduced_graph(fragment, parent_scope);
         self.output_macro_rules_scopes.insert(expansion, output_macro_rules_scope);
 
-        parent_scope.module.unexpanded_invocations.borrow_mut().remove(&expansion);
+        parent_scope.module.unexpanded_invocations.borrow_mut(self).remove(&expansion);
         if let Some(unexpanded_invocations) =
             self.impl_unexpanded_invocations.get_mut(&self.invocation_parent(expansion))
         {

From 8ea9122c9b9465982424f7254a9cd88147e85642 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Thu, 25 Sep 2025 18:16:56 +0200
Subject: [PATCH 1397/1889] Rename `verbose` to `do_if_verbose`

---
 src/bootstrap/src/core/build_steps/compile.rs |  7 ++++---
 src/bootstrap/src/core/build_steps/dist.rs    |  2 +-
 src/bootstrap/src/core/build_steps/gcc.rs     |  2 +-
 src/bootstrap/src/core/build_steps/test.rs    |  6 +++---
 src/bootstrap/src/core/builder/mod.rs         |  4 ++--
 src/bootstrap/src/core/config/config.rs       |  6 +++---
 src/bootstrap/src/core/download.rs            | 18 ++++++++++--------
 src/bootstrap/src/lib.rs                      | 10 +++++-----
 src/bootstrap/src/utils/build_stamp.rs        |  2 +-
 src/bootstrap/src/utils/cc_detect.rs          | 10 +++++-----
 src/bootstrap/src/utils/exec.rs               |  6 +++---
 src/bootstrap/src/utils/render_tests.rs       |  2 +-
 src/bootstrap/src/utils/tarball.rs            |  2 +-
 13 files changed, 40 insertions(+), 37 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index b47b4f248a9ac..e699922f4dc05 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -1832,8 +1832,9 @@ impl Step for Sysroot {
         let sysroot = sysroot_dir(compiler.stage);
         trace!(stage = ?compiler.stage, ?sysroot);
 
-        builder
-            .verbose(|| println!("Removing sysroot {} to avoid caching bugs", sysroot.display()));
+        builder.do_if_verbose(|| {
+            println!("Removing sysroot {} to avoid caching bugs", sysroot.display())
+        });
         let _ = fs::remove_dir_all(&sysroot);
         t!(fs::create_dir_all(&sysroot));
 
@@ -2591,7 +2592,7 @@ pub fn stream_cargo(
         cmd.arg(arg);
     }
 
-    builder.verbose(|| println!("running: {cmd:?}"));
+    builder.do_if_verbose(|| println!("running: {cmd:?}"));
 
     let streaming_command = cmd.stream_capture_stdout(&builder.config.exec_ctx);
 
diff --git a/src/bootstrap/src/core/build_steps/dist.rs b/src/bootstrap/src/core/build_steps/dist.rs
index 99a1062109adc..b79d2cb413db7 100644
--- a/src/bootstrap/src/core/build_steps/dist.rs
+++ b/src/bootstrap/src/core/build_steps/dist.rs
@@ -2304,7 +2304,7 @@ fn maybe_install_llvm(
         let mut cmd = command(host_llvm_config);
         cmd.cached();
         cmd.arg("--libfiles");
-        builder.verbose(|| println!("running {cmd:?}"));
+        builder.do_if_verbose(|| println!("running {cmd:?}"));
         let files = cmd.run_capture_stdout(builder).stdout();
         let build_llvm_out = &builder.llvm_out(builder.config.host_target);
         let target_llvm_out = &builder.llvm_out(target);
diff --git a/src/bootstrap/src/core/build_steps/gcc.rs b/src/bootstrap/src/core/build_steps/gcc.rs
index 717dea37e9e61..17ab8c4e2f479 100644
--- a/src/bootstrap/src/core/build_steps/gcc.rs
+++ b/src/bootstrap/src/core/build_steps/gcc.rs
@@ -128,7 +128,7 @@ fn try_download_gcc(builder: &Builder<'_>, target: TargetSelection) -> Option<Pa
         &builder.config,
         builder.config.rust_info.is_managed_git_subrepository(),
     );
-    builder.verbose(|| {
+    builder.do_if_verbose(|| {
         eprintln!("GCC freshness: {source:?}");
     });
     match source {
diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index e7f5879b5f51a..ca2731819e7e0 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -582,11 +582,11 @@ impl Miri {
         // We re-use the `cargo` from above.
         cargo.arg("--print-sysroot");
 
-        builder.verbose(|| println!("running: {cargo:?}"));
+        builder.do_if_verbose(|| println!("running: {cargo:?}"));
         let stdout = cargo.run_capture_stdout(builder).stdout();
         // Output is "<sysroot>\n".
         let sysroot = stdout.trim_end();
-        builder.verbose(|| println!("`cargo miri setup --print-sysroot` said: {sysroot:?}"));
+        builder.do_if_verbose(|| println!("`cargo miri setup --print-sysroot` said: {sysroot:?}"));
         PathBuf::from(sysroot)
     }
 }
@@ -2675,7 +2675,7 @@ fn markdown_test(builder: &Builder<'_>, compiler: Compiler, markdown: &Path) ->
         return true;
     }
 
-    builder.verbose(|| println!("doc tests for: {}", markdown.display()));
+    builder.do_if_verbose(|| println!("doc tests for: {}", markdown.display()));
     let mut cmd = builder.rustdoc_cmd(compiler);
     builder.add_rust_test_threads(&mut cmd);
     // allow for unstable options such as new editions
diff --git a/src/bootstrap/src/core/builder/mod.rs b/src/bootstrap/src/core/builder/mod.rs
index 8226b4325b6b8..049d2647bec49 100644
--- a/src/bootstrap/src/core/builder/mod.rs
+++ b/src/bootstrap/src/core/builder/mod.rs
@@ -545,7 +545,7 @@ impl StepDescription {
         if !builder.config.skip.is_empty()
             && !matches!(builder.config.get_dry_run(), DryRun::SelfCheck)
         {
-            builder.verbose(|| {
+            builder.do_if_verbose(|| {
                 println!(
                     "{:?} not skipped for {:?} -- not in {:?}",
                     pathset, self.name, builder.config.skip
@@ -947,7 +947,7 @@ impl Step for Libdir {
             // Sysroot`).
             if !builder.download_rustc() {
                 let sysroot_target_libdir = sysroot.join(self.target).join("lib");
-                builder.verbose(|| {
+                builder.do_if_verbose(|| {
                     eprintln!(
                         "Removing sysroot {} to avoid caching bugs",
                         sysroot_target_libdir.display()
diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index dd2d5a1fd5332..fb7c334491b34 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -1571,8 +1571,8 @@ impl Config {
     }
 
     /// Runs a function if verbosity is greater than 0
-    pub fn verbose(&self, f: impl Fn()) {
-        self.exec_ctx.verbose(f);
+    pub fn do_if_verbose(&self, f: impl Fn()) {
+        self.exec_ctx.do_if_verbose(f);
     }
 
     pub fn any_sanitizers_to_build(&self) -> bool {
@@ -2061,7 +2061,7 @@ pub fn download_ci_rustc_commit<'a>(
         // Look for a version to compare to based on the current commit.
         // Only commits merged by bors will have CI artifacts.
         let freshness = check_path_modifications_(dwn_ctx, RUSTC_IF_UNCHANGED_ALLOWED_PATHS);
-        dwn_ctx.exec_ctx.verbose(|| {
+        dwn_ctx.exec_ctx.do_if_verbose(|| {
             eprintln!("rustc freshness: {freshness:?}");
         });
         match freshness {
diff --git a/src/bootstrap/src/core/download.rs b/src/bootstrap/src/core/download.rs
index 2f3c80559c0ef..37871f0fe1e28 100644
--- a/src/bootstrap/src/core/download.rs
+++ b/src/bootstrap/src/core/download.rs
@@ -106,7 +106,7 @@ enum DownloadSource {
 /// Functions that are only ever called once, but named for clarity and to avoid thousand-line functions.
 impl Config {
     pub(crate) fn download_clippy(&self) -> PathBuf {
-        self.verbose(|| println!("downloading stage0 clippy artifacts"));
+        self.do_if_verbose(|| println!("downloading stage0 clippy artifacts"));
 
         let date = &self.stage0_metadata.compiler.date;
         let version = &self.stage0_metadata.compiler.version;
@@ -151,7 +151,9 @@ impl Config {
     }
 
     pub(crate) fn download_ci_rustc(&self, commit: &str) {
-        self.verbose(|| println!("using downloaded stage2 artifacts from CI (commit {commit})"));
+        self.do_if_verbose(|| {
+            println!("using downloaded stage2 artifacts from CI (commit {commit})")
+        });
 
         let version = self.artifact_version_part(commit);
         // download-rustc doesn't need its own cargo, it can just use beta's. But it does need the
@@ -258,7 +260,7 @@ impl Config {
         let llvm_root = self.ci_llvm_root();
         let llvm_freshness =
             detect_llvm_freshness(self, self.rust_info.is_managed_git_subrepository());
-        self.verbose(|| {
+        self.do_if_verbose(|| {
             eprintln!("LLVM freshness: {llvm_freshness:?}");
         });
         let llvm_sha = match llvm_freshness {
@@ -557,7 +559,7 @@ pub(crate) fn download_beta_toolchain<'a>(dwn_ctx: impl AsRef<DownloadContext<'a
 #[cfg(not(test))]
 pub(crate) fn download_beta_toolchain<'a>(dwn_ctx: impl AsRef<DownloadContext<'a>>, out: &Path) {
     let dwn_ctx = dwn_ctx.as_ref();
-    dwn_ctx.exec_ctx.verbose(|| {
+    dwn_ctx.exec_ctx.do_if_verbose(|| {
         println!("downloading stage0 beta artifacts");
     });
 
@@ -812,7 +814,7 @@ fn download_component<'a>(
                 unpack(dwn_ctx.exec_ctx, &tarball, &bin_root, prefix);
                 return;
             } else {
-                dwn_ctx.exec_ctx.verbose(|| {
+                dwn_ctx.exec_ctx.do_if_verbose(|| {
                     println!(
                         "ignoring cached file {} due to failed verification",
                         tarball.display()
@@ -853,7 +855,7 @@ download-rustc = false
 pub(crate) fn verify(exec_ctx: &ExecutionContext, path: &Path, expected: &str) -> bool {
     use sha2::Digest;
 
-    exec_ctx.verbose(|| {
+    exec_ctx.do_if_verbose(|| {
         println!("verifying {}", path.display());
     });
 
@@ -934,7 +936,7 @@ fn unpack(exec_ctx: &ExecutionContext, tarball: &Path, dst: &Path, pattern: &str
         short_path = short_path.strip_prefix(pattern).unwrap_or(short_path);
         let dst_path = dst.join(short_path);
 
-        exec_ctx.verbose(|| {
+        exec_ctx.do_if_verbose(|| {
             println!("extracting {} to {}", original_path.display(), dst.display());
         });
 
@@ -965,7 +967,7 @@ fn download_file<'a>(
 ) {
     let dwn_ctx = dwn_ctx.as_ref();
 
-    dwn_ctx.exec_ctx.verbose(|| {
+    dwn_ctx.exec_ctx.do_if_verbose(|| {
         println!("download {url}");
     });
     // Use a temporary file in case we crash while downloading, to avoid a corrupt download in cache/.
diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs
index 75cc79e6689c8..4f4d35673d5d1 100644
--- a/src/bootstrap/src/lib.rs
+++ b/src/bootstrap/src/lib.rs
@@ -415,7 +415,7 @@ macro_rules! forward {
 }
 
 forward! {
-    verbose(f: impl Fn()),
+    do_if_verbose(f: impl Fn()),
     is_verbose() -> bool,
     create(path: &Path, s: &str),
     remove(f: &Path),
@@ -601,11 +601,11 @@ impl Build {
             .unwrap()
             .trim();
         if local_release.split('.').take(2).eq(version.split('.').take(2)) {
-            build.verbose(|| println!("auto-detected local-rebuild {local_release}"));
+            build.do_if_verbose(|| println!("auto-detected local-rebuild {local_release}"));
             build.local_rebuild = true;
         }
 
-        build.verbose(|| println!("finding compilers"));
+        build.do_if_verbose(|| println!("finding compilers"));
         utils::cc_detect::fill_compilers(&mut build);
         // When running `setup`, the profile is about to change, so any requirements we have now may
         // be different on the next invocation. Don't check for them until the next time x.py is
@@ -613,7 +613,7 @@ impl Build {
         //
         // Similarly, for `setup` we don't actually need submodules or cargo metadata.
         if !matches!(build.config.cmd, Subcommand::Setup { .. }) {
-            build.verbose(|| println!("running sanity check"));
+            build.do_if_verbose(|| println!("running sanity check"));
             crate::core::sanity::check(&mut build);
 
             // Make sure we update these before gathering metadata so we don't get an error about missing
@@ -631,7 +631,7 @@ impl Build {
             // Now, update all existing submodules.
             build.update_existing_submodules();
 
-            build.verbose(|| println!("learning about cargo"));
+            build.do_if_verbose(|| println!("learning about cargo"));
             crate::core::metadata::build(&mut build);
         }
 
diff --git a/src/bootstrap/src/utils/build_stamp.rs b/src/bootstrap/src/utils/build_stamp.rs
index 4c35388a181aa..5cd68f6d4fe7f 100644
--- a/src/bootstrap/src/utils/build_stamp.rs
+++ b/src/bootstrap/src/utils/build_stamp.rs
@@ -112,7 +112,7 @@ pub fn clear_if_dirty(builder: &Builder<'_>, dir: &Path, input: &Path) -> bool {
     let stamp = BuildStamp::new(dir);
     let mut cleared = false;
     if mtime(stamp.path()) < mtime(input) {
-        builder.verbose(|| println!("Dirty - {}", dir.display()));
+        builder.do_if_verbose(|| println!("Dirty - {}", dir.display()));
         let _ = fs::remove_dir_all(dir);
         cleared = true;
     } else if stamp.path().exists() {
diff --git a/src/bootstrap/src/utils/cc_detect.rs b/src/bootstrap/src/utils/cc_detect.rs
index d3926df9650ce..0662ae304ac06 100644
--- a/src/bootstrap/src/utils/cc_detect.rs
+++ b/src/bootstrap/src/utils/cc_detect.rs
@@ -137,16 +137,16 @@ pub fn fill_target_compiler(build: &mut Build, target: TargetSelection) {
         build.cxx.insert(target, compiler);
     }
 
-    build.verbose(|| println!("CC_{} = {:?}", target.triple, build.cc(target)));
-    build.verbose(|| println!("CFLAGS_{} = {cflags:?}", target.triple));
+    build.do_if_verbose(|| println!("CC_{} = {:?}", target.triple, build.cc(target)));
+    build.do_if_verbose(|| println!("CFLAGS_{} = {cflags:?}", target.triple));
     if let Ok(cxx) = build.cxx(target) {
         let mut cxxflags = build.cc_handled_clags(target, CLang::Cxx);
         cxxflags.extend(build.cc_unhandled_cflags(target, GitRepo::Rustc, CLang::Cxx));
-        build.verbose(|| println!("CXX_{} = {cxx:?}", target.triple));
-        build.verbose(|| println!("CXXFLAGS_{} = {cxxflags:?}", target.triple));
+        build.do_if_verbose(|| println!("CXX_{} = {cxx:?}", target.triple));
+        build.do_if_verbose(|| println!("CXXFLAGS_{} = {cxxflags:?}", target.triple));
     }
     if let Some(ar) = ar {
-        build.verbose(|| println!("AR_{} = {ar:?}", target.triple));
+        build.do_if_verbose(|| println!("AR_{} = {ar:?}", target.triple));
         build.ar.insert(target, ar);
     }
 
diff --git a/src/bootstrap/src/utils/exec.rs b/src/bootstrap/src/utils/exec.rs
index e09f3086b777c..f875e6e1af75c 100644
--- a/src/bootstrap/src/utils/exec.rs
+++ b/src/bootstrap/src/utils/exec.rs
@@ -630,7 +630,7 @@ impl ExecutionContext {
         &self.dry_run
     }
 
-    pub fn verbose(&self, f: impl Fn()) {
+    pub fn do_if_verbose(&self, f: impl Fn()) {
         if self.is_verbose() {
             f()
         }
@@ -686,7 +686,7 @@ impl ExecutionContext {
 
         if let Some(cached_output) = self.command_cache.get(&fingerprint) {
             command.mark_as_executed();
-            self.verbose(|| println!("Cache hit: {command:?}"));
+            self.do_if_verbose(|| println!("Cache hit: {command:?}"));
             self.profiler.record_cache_hit(fingerprint);
             return DeferredCommand { state: CommandState::Cached(cached_output) };
         }
@@ -713,7 +713,7 @@ impl ExecutionContext {
             };
         }
 
-        self.verbose(|| {
+        self.do_if_verbose(|| {
             println!("running: {command:?} (created at {created_at}, executed at {executed_at})")
         });
 
diff --git a/src/bootstrap/src/utils/render_tests.rs b/src/bootstrap/src/utils/render_tests.rs
index 90fd57d976d3f..e90a7ef42324a 100644
--- a/src/bootstrap/src/utils/render_tests.rs
+++ b/src/bootstrap/src/utils/render_tests.rs
@@ -48,7 +48,7 @@ pub(crate) fn try_run_tests(
 }
 
 fn run_tests(builder: &Builder<'_>, cmd: &mut BootstrapCommand, stream: bool) -> bool {
-    builder.verbose(|| println!("running: {cmd:?}"));
+    builder.do_if_verbose(|| println!("running: {cmd:?}"));
 
     let Some(mut streaming_command) = cmd.stream_capture_stdout(&builder.config.exec_ctx) else {
         return true;
diff --git a/src/bootstrap/src/utils/tarball.rs b/src/bootstrap/src/utils/tarball.rs
index 7b77b21293413..079afb7a00548 100644
--- a/src/bootstrap/src/utils/tarball.rs
+++ b/src/bootstrap/src/utils/tarball.rs
@@ -356,7 +356,7 @@ impl<'a> Tarball<'a> {
 
         // For `x install` tarball files aren't needed, so we can speed up the process by not producing them.
         let compression_profile = if self.builder.kind == Kind::Install {
-            self.builder.verbose(|| {
+            self.builder.do_if_verbose(|| {
                 println!("Forcing dist.compression-profile = 'no-op' for `x install`.")
             });
             // "no-op" indicates that the rust-installer won't produce compressed tarball sources.

From a2d286992409d8077a03e0994a3839abdbfccc90 Mon Sep 17 00:00:00 2001
From: Josh Stone <jistone@redhat.com>
Date: Wed, 24 Sep 2025 09:56:57 -0700
Subject: [PATCH 1398/1889] Add `clippy::unconditional_recursion` to `./x
 clippy ci`

The clippy lint catches some things that rustc's equivalent builtin lint
does not, for example rust-lang/rust#146940:

    error: function cannot return without recursing
        --> library/std/src/path.rs:3428:5
         |
    3428 | /     fn eq(&self, other: &String) -> bool {
    3429 | |         self == &*other
    3430 | |     }
         | |_____^
         |
    note: recursive call site
        --> library/std/src/path.rs:3429:9
         |
    3429 |         self == &*other
         |         ^^^^^^^^^^^^^^^
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unconditional_recursion
         = note: requested on the command line with `-D clippy::unconditional-recursion`
---
 src/bootstrap/src/core/build_steps/clippy.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/bootstrap/src/core/build_steps/clippy.rs b/src/bootstrap/src/core/build_steps/clippy.rs
index 2083c675e1fdd..d5b15d7908646 100644
--- a/src/bootstrap/src/core/build_steps/clippy.rs
+++ b/src/bootstrap/src/core/build_steps/clippy.rs
@@ -564,6 +564,7 @@ impl Step for CI {
                 "clippy::same_item_push".into(),
                 "clippy::single_char_add_str".into(),
                 "clippy::to_string_in_format_args".into(),
+                "clippy::unconditional_recursion".into(),
             ],
             forbid: vec![],
         };
@@ -591,6 +592,7 @@ impl Step for CI {
                 "clippy::same_item_push".into(),
                 "clippy::single_char_add_str".into(),
                 "clippy::to_string_in_format_args".into(),
+                "clippy::unconditional_recursion".into(),
             ],
             forbid: vec![],
         };

From f89660e4aa018401ca993f0df190e5f4c4a6799b Mon Sep 17 00:00:00 2001
From: Vadim Petrochenkov <vadim.petrochenkov@gmail.com>
Date: Fri, 1 Aug 2025 21:55:11 +0300
Subject: [PATCH 1399/1889] resolve: Do not finalize shadowed bindings

I.e. do not mark them as used, or non-speculative loaded, or similar.
Previously they were sometimes finalized during early resolution, causing issues like https://github.com/rust-lang/rust/pull/144793#issuecomment-3168108005.
---
 compiler/rustc_macros/src/query.rs                 |  2 +-
 compiler/rustc_resolve/src/ident.rs                | 11 ++++++-----
 library/alloctests/tests/lib.rs                    |  1 -
 library/std/src/sys/pal/unix/stack_overflow.rs     |  2 +-
 src/tools/clippy/tests/ui/useless_attribute.fixed  |  2 +-
 src/tools/clippy/tests/ui/useless_attribute.rs     |  2 +-
 .../crates/hir-expand/src/builtin/derive_macro.rs  |  2 +-
 .../crates/hir-expand/src/builtin/fn_macro.rs      |  2 +-
 .../crates/hir-expand/src/builtin/quote.rs         |  2 --
 src/tools/rustfmt/src/config/mod.rs                |  1 -
 tests/ui/resolve/unused-macro-import.rs            | 13 +++++++++++++
 tests/ui/resolve/unused-macro-import.stderr        | 14 ++++++++++++++
 12 files changed, 39 insertions(+), 15 deletions(-)
 create mode 100644 tests/ui/resolve/unused-macro-import.rs
 create mode 100644 tests/ui/resolve/unused-macro-import.stderr

diff --git a/compiler/rustc_macros/src/query.rs b/compiler/rustc_macros/src/query.rs
index 5821ffa3a302d..5d32950875adb 100644
--- a/compiler/rustc_macros/src/query.rs
+++ b/compiler/rustc_macros/src/query.rs
@@ -5,7 +5,7 @@ use syn::punctuated::Punctuated;
 use syn::spanned::Spanned;
 use syn::{
     AttrStyle, Attribute, Block, Error, Expr, Ident, Pat, ReturnType, Token, Type, braced,
-    parenthesized, parse_macro_input, parse_quote, token,
+    parenthesized, parse_macro_input, token,
 };
 
 mod kw {
diff --git a/compiler/rustc_resolve/src/ident.rs b/compiler/rustc_resolve/src/ident.rs
index 35051675fd8dc..51489019950ad 100644
--- a/compiler/rustc_resolve/src/ident.rs
+++ b/compiler/rustc_resolve/src/ident.rs
@@ -492,14 +492,13 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         _ => Err(Determinacy::Determined),
                     },
                     Scope::Module(module, derive_fallback_lint_id) => {
-                        // FIXME: use `finalize_scope` here.
                         let (adjusted_parent_scope, adjusted_finalize) =
                             if matches!(scope_set, ScopeSet::ModuleAndExternPrelude(..)) {
-                                (parent_scope, finalize)
+                                (parent_scope, finalize_scope!())
                             } else {
                                 (
                                     &ParentScope { module, ..*parent_scope },
-                                    finalize.map(|f| Finalize { used: Used::Scope, ..f }),
+                                    finalize_scope!().map(|f| Finalize { used: Used::Scope, ..f }),
                                 )
                             };
                         let binding = this.reborrow().resolve_ident_in_module_unadjusted(
@@ -557,8 +556,10 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         None => Err(Determinacy::Determined),
                     },
                     Scope::ExternPreludeItems => {
-                        // FIXME: use `finalize_scope` here.
-                        match this.reborrow().extern_prelude_get_item(ident, finalize.is_some()) {
+                        match this
+                            .reborrow()
+                            .extern_prelude_get_item(ident, finalize_scope!().is_some())
+                        {
                             Some(binding) => {
                                 extern_prelude_item_binding = Some(binding);
                                 Ok((binding, Flags::empty()))
diff --git a/library/alloctests/tests/lib.rs b/library/alloctests/tests/lib.rs
index 8c3ce156f3c1d..4947b38ba89e4 100644
--- a/library/alloctests/tests/lib.rs
+++ b/library/alloctests/tests/lib.rs
@@ -46,7 +46,6 @@
 #![deny(unsafe_op_in_unsafe_fn)]
 
 extern crate alloc;
-extern crate test;
 
 use std::hash::{DefaultHasher, Hash, Hasher};
 
diff --git a/library/std/src/sys/pal/unix/stack_overflow.rs b/library/std/src/sys/pal/unix/stack_overflow.rs
index 0d2100d66bc09..51463eef5b778 100644
--- a/library/std/src/sys/pal/unix/stack_overflow.rs
+++ b/library/std/src/sys/pal/unix/stack_overflow.rs
@@ -72,7 +72,7 @@ mod imp {
     use crate::sync::OnceLock;
     use crate::sync::atomic::{Atomic, AtomicBool, AtomicPtr, AtomicUsize, Ordering};
     use crate::sys::pal::unix::os;
-    use crate::{io, mem, panic, ptr};
+    use crate::{io, mem, ptr};
 
     // Signal handler for the SIGSEGV and SIGBUS handlers. We've got guard pages
     // (unmapped pages) at the end of every thread's stack, so if a thread ends
diff --git a/src/tools/clippy/tests/ui/useless_attribute.fixed b/src/tools/clippy/tests/ui/useless_attribute.fixed
index 15070dd9c2ca6..e0bc23e0788c6 100644
--- a/src/tools/clippy/tests/ui/useless_attribute.fixed
+++ b/src/tools/clippy/tests/ui/useless_attribute.fixed
@@ -153,7 +153,7 @@ pub mod redundant_imports_issue {
         () => {};
     }
 
-    #[expect(redundant_imports)]
+    #[expect(unused_imports)]
     pub(crate) use empty;
 
     empty!();
diff --git a/src/tools/clippy/tests/ui/useless_attribute.rs b/src/tools/clippy/tests/ui/useless_attribute.rs
index 3f530de7fd8e3..30a4c354b238a 100644
--- a/src/tools/clippy/tests/ui/useless_attribute.rs
+++ b/src/tools/clippy/tests/ui/useless_attribute.rs
@@ -153,7 +153,7 @@ pub mod redundant_imports_issue {
         () => {};
     }
 
-    #[expect(redundant_imports)]
+    #[expect(unused_imports)]
     pub(crate) use empty;
 
     empty!();
diff --git a/src/tools/rust-analyzer/crates/hir-expand/src/builtin/derive_macro.rs b/src/tools/rust-analyzer/crates/hir-expand/src/builtin/derive_macro.rs
index 15e68ff95cd57..0fa412ad7fa2c 100644
--- a/src/tools/rust-analyzer/crates/hir-expand/src/builtin/derive_macro.rs
+++ b/src/tools/rust-analyzer/crates/hir-expand/src/builtin/derive_macro.rs
@@ -12,7 +12,7 @@ use tracing::debug;
 
 use crate::{
     ExpandError, ExpandResult, MacroCallId,
-    builtin::quote::{dollar_crate, quote},
+    builtin::quote::dollar_crate,
     db::ExpandDatabase,
     hygiene::span_with_def_site_ctxt,
     name::{self, AsName, Name},
diff --git a/src/tools/rust-analyzer/crates/hir-expand/src/builtin/fn_macro.rs b/src/tools/rust-analyzer/crates/hir-expand/src/builtin/fn_macro.rs
index ec34461376165..6fe63f249cd4a 100644
--- a/src/tools/rust-analyzer/crates/hir-expand/src/builtin/fn_macro.rs
+++ b/src/tools/rust-analyzer/crates/hir-expand/src/builtin/fn_macro.rs
@@ -19,7 +19,7 @@ use syntax_bridge::syntax_node_to_token_tree;
 
 use crate::{
     EditionedFileId, ExpandError, ExpandResult, Lookup as _, MacroCallId,
-    builtin::quote::{WithDelimiter, dollar_crate, quote},
+    builtin::quote::{WithDelimiter, dollar_crate},
     db::ExpandDatabase,
     hygiene::{span_with_call_site_ctxt, span_with_def_site_ctxt},
     name,
diff --git a/src/tools/rust-analyzer/crates/hir-expand/src/builtin/quote.rs b/src/tools/rust-analyzer/crates/hir-expand/src/builtin/quote.rs
index 70c38d4d7c75b..84dd4a24d901f 100644
--- a/src/tools/rust-analyzer/crates/hir-expand/src/builtin/quote.rs
+++ b/src/tools/rust-analyzer/crates/hir-expand/src/builtin/quote.rs
@@ -229,8 +229,6 @@ mod tests {
     use span::{Edition, ROOT_ERASED_FILE_AST_ID, SpanAnchor, SyntaxContext};
     use syntax::{TextRange, TextSize};
 
-    use super::quote;
-
     const DUMMY: tt::Span = tt::Span {
         range: TextRange::empty(TextSize::new(0)),
         anchor: SpanAnchor {
diff --git a/src/tools/rustfmt/src/config/mod.rs b/src/tools/rustfmt/src/config/mod.rs
index 6b63108c037eb..525953bf4458b 100644
--- a/src/tools/rustfmt/src/config/mod.rs
+++ b/src/tools/rustfmt/src/config/mod.rs
@@ -516,7 +516,6 @@ mod test {
     #[allow(dead_code)]
     mod mock {
         use super::super::*;
-        use crate::config_option_with_style_edition_default;
         use rustfmt_config_proc_macro::config_type;
 
         #[config_type]
diff --git a/tests/ui/resolve/unused-macro-import.rs b/tests/ui/resolve/unused-macro-import.rs
new file mode 100644
index 0000000000000..e85f7a43993f4
--- /dev/null
+++ b/tests/ui/resolve/unused-macro-import.rs
@@ -0,0 +1,13 @@
+//@ check-pass
+
+#![warn(unused_imports)]
+
+#[macro_export]
+macro_rules! mac { () => {} }
+
+fn main() {
+    // Unused, `mac` as `macro_rules!` is already in scope and has higher priority.
+    use crate::mac; //~ WARN unused import: `crate::mac`
+
+    mac!();
+}
diff --git a/tests/ui/resolve/unused-macro-import.stderr b/tests/ui/resolve/unused-macro-import.stderr
new file mode 100644
index 0000000000000..5f9813808a0aa
--- /dev/null
+++ b/tests/ui/resolve/unused-macro-import.stderr
@@ -0,0 +1,14 @@
+warning: unused import: `crate::mac`
+  --> $DIR/unused-macro-import.rs:10:9
+   |
+LL |     use crate::mac;
+   |         ^^^^^^^^^^
+   |
+note: the lint level is defined here
+  --> $DIR/unused-macro-import.rs:3:9
+   |
+LL | #![warn(unused_imports)]
+   |         ^^^^^^^^^^^^^^
+
+warning: 1 warning emitted
+

From 283aad06e9a9145b963119b2b061db92ada9d680 Mon Sep 17 00:00:00 2001
From: Vadim Petrochenkov <vadim.petrochenkov@gmail.com>
Date: Fri, 1 Aug 2025 21:55:11 +0300
Subject: [PATCH 1400/1889] resolve: Do not finalize shadowed bindings

I.e. do not mark them as used, or non-speculative loaded, or similar.
Previously they were sometimes finalized during early resolution, causing issues like https://github.com/rust-lang/rust/pull/144793#issuecomment-3168108005.
---
 tests/ui/useless_attribute.fixed | 2 +-
 tests/ui/useless_attribute.rs    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/ui/useless_attribute.fixed b/tests/ui/useless_attribute.fixed
index 15070dd9c2ca6..e0bc23e0788c6 100644
--- a/tests/ui/useless_attribute.fixed
+++ b/tests/ui/useless_attribute.fixed
@@ -153,7 +153,7 @@ pub mod redundant_imports_issue {
         () => {};
     }
 
-    #[expect(redundant_imports)]
+    #[expect(unused_imports)]
     pub(crate) use empty;
 
     empty!();
diff --git a/tests/ui/useless_attribute.rs b/tests/ui/useless_attribute.rs
index 3f530de7fd8e3..30a4c354b238a 100644
--- a/tests/ui/useless_attribute.rs
+++ b/tests/ui/useless_attribute.rs
@@ -153,7 +153,7 @@ pub mod redundant_imports_issue {
         () => {};
     }
 
-    #[expect(redundant_imports)]
+    #[expect(unused_imports)]
     pub(crate) use empty;
 
     empty!();

From bd39ea463f30fd51be0b4587191c67cd53bf6658 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Thu, 25 Sep 2025 00:17:03 +0200
Subject: [PATCH 1401/1889] inline `clippy_utils::ptr` into
 `needless_pass_by_value`

..and make it less generic, thanks to all the callers being known
---
 clippy_lints/src/needless_pass_by_value.rs | 63 +++++++++++++++++-----
 clippy_utils/src/lib.rs                    |  1 -
 clippy_utils/src/ptr.rs                    | 52 ------------------
 3 files changed, 51 insertions(+), 65 deletions(-)
 delete mode 100644 clippy_utils/src/ptr.rs

diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index 32ded96c1236f..455d1426aa8cb 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -1,16 +1,16 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::ptr::get_spans;
 use clippy_utils::source::{SpanRangeExt, snippet};
 use clippy_utils::ty::{
     implements_trait, implements_trait_with_env_from_iter, is_copy, is_type_diagnostic_item, is_type_lang_item,
 };
-use clippy_utils::{is_self, peel_hir_ty_options};
+use clippy_utils::visitors::{Descend, for_each_expr_without_closures};
+use clippy_utils::{is_self, path_to_local_id, peel_hir_ty_options, strip_pat_refs, sym};
 use rustc_abi::ExternAbi;
 use rustc_errors::{Applicability, Diag};
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
-    Attribute, BindingMode, Body, FnDecl, GenericArg, HirId, HirIdSet, Impl, ItemKind, LangItem, Mutability, Node,
-    PatKind, QPath, TyKind,
+    Attribute, BindingMode, Body, ExprKind, FnDecl, GenericArg, HirId, HirIdSet, Impl, ItemKind, LangItem, Mutability,
+    Node, PatKind, QPath, TyKind,
 };
 use rustc_hir_typeck::expr_use_visitor as euv;
 use rustc_lint::{LateContext, LateLintPass};
@@ -19,10 +19,13 @@ use rustc_middle::ty::{self, Ty, TypeVisitableExt};
 use rustc_session::declare_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::symbol::kw;
-use rustc_span::{Span, sym};
+use rustc_span::{Span, Symbol};
 use rustc_trait_selection::traits;
 use rustc_trait_selection::traits::misc::type_allowed_to_implement_copy;
 
+use std::borrow::Cow;
+use std::ops::ControlFlow;
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for functions taking arguments by value, but not
@@ -217,7 +220,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
                     }
 
                     if is_type_diagnostic_item(cx, ty, sym::Vec)
-                        && let Some(clone_spans) = get_spans(cx, Some(body.id()), idx, &[(sym::clone, ".to_owned()")])
+                        && let Some(clone_spans) = get_spans(cx, body, idx, &[(sym::clone, ".to_owned()")])
                         && let TyKind::Path(QPath::Resolved(_, path)) = input.kind
                         && let Some(elem_ty) = path
                             .segments
@@ -260,12 +263,8 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
                     }
 
                     if is_type_lang_item(cx, ty, LangItem::String)
-                        && let Some(clone_spans) = get_spans(
-                            cx,
-                            Some(body.id()),
-                            idx,
-                            &[(sym::clone, ".to_string()"), (sym::as_str, "")],
-                        )
+                        && let Some(clone_spans) =
+                            get_spans(cx, body, idx, &[(sym::clone, ".to_string()"), (sym::as_str, "")])
                     {
                         diag.span_suggestion(
                             input.span,
@@ -340,3 +339,43 @@ impl<'tcx> euv::Delegate<'tcx> for MovedVariablesCtxt {
 
     fn fake_read(&mut self, _: &rustc_hir_typeck::expr_use_visitor::PlaceWithHirId<'tcx>, _: FakeReadCause, _: HirId) {}
 }
+
+fn get_spans<'tcx>(
+    cx: &LateContext<'tcx>,
+    body: &'tcx Body<'_>,
+    idx: usize,
+    replacements: &[(Symbol, &'static str)],
+) -> Option<Vec<(Span, Cow<'static, str>)>> {
+    if let PatKind::Binding(_, binding_id, _, _) = strip_pat_refs(body.params[idx].pat).kind {
+        extract_clone_suggestions(cx, binding_id, replacements, body)
+    } else {
+        Some(vec![])
+    }
+}
+
+fn extract_clone_suggestions<'tcx>(
+    cx: &LateContext<'tcx>,
+    id: HirId,
+    replace: &[(Symbol, &'static str)],
+    body: &'tcx Body<'_>,
+) -> Option<Vec<(Span, Cow<'static, str>)>> {
+    let mut spans = Vec::new();
+    for_each_expr_without_closures(body, |e| {
+        if let ExprKind::MethodCall(seg, recv, [], _) = e.kind
+            && path_to_local_id(recv, id)
+        {
+            if seg.ident.name == sym::capacity {
+                return ControlFlow::Break(());
+            }
+            for &(fn_name, suffix) in replace {
+                if seg.ident.name == fn_name {
+                    spans.push((e.span, snippet(cx, recv.span, "_") + suffix));
+                    return ControlFlow::Continue(Descend::No);
+                }
+            }
+        }
+        ControlFlow::Continue(Descend::Yes)
+    })
+    .is_none()
+    .then_some(spans)
+}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index feadc0ecf659a..d6586625a1e5e 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -63,7 +63,6 @@ pub mod mir;
 pub mod msrvs;
 pub mod numeric_literal;
 pub mod paths;
-pub mod ptr;
 pub mod qualify_min_const_fn;
 pub mod source;
 pub mod str_utils;
diff --git a/clippy_utils/src/ptr.rs b/clippy_utils/src/ptr.rs
deleted file mode 100644
index 5847e916e340f..0000000000000
--- a/clippy_utils/src/ptr.rs
+++ /dev/null
@@ -1,52 +0,0 @@
-use crate::source::snippet;
-use crate::visitors::{Descend, for_each_expr_without_closures};
-use crate::{path_to_local_id, strip_pat_refs, sym};
-use core::ops::ControlFlow;
-use rustc_hir::{Body, BodyId, ExprKind, HirId, PatKind};
-use rustc_lint::LateContext;
-use rustc_span::{Span, Symbol};
-use std::borrow::Cow;
-
-pub fn get_spans(
-    cx: &LateContext<'_>,
-    opt_body_id: Option<BodyId>,
-    idx: usize,
-    replacements: &[(Symbol, &'static str)],
-) -> Option<Vec<(Span, Cow<'static, str>)>> {
-    if let Some(body) = opt_body_id.map(|id| cx.tcx.hir_body(id)) {
-        if let PatKind::Binding(_, binding_id, _, _) = strip_pat_refs(body.params[idx].pat).kind {
-            extract_clone_suggestions(cx, binding_id, replacements, body)
-        } else {
-            Some(vec![])
-        }
-    } else {
-        Some(vec![])
-    }
-}
-
-fn extract_clone_suggestions<'tcx>(
-    cx: &LateContext<'tcx>,
-    id: HirId,
-    replace: &[(Symbol, &'static str)],
-    body: &'tcx Body<'_>,
-) -> Option<Vec<(Span, Cow<'static, str>)>> {
-    let mut spans = Vec::new();
-    for_each_expr_without_closures(body, |e| {
-        if let ExprKind::MethodCall(seg, recv, [], _) = e.kind
-            && path_to_local_id(recv, id)
-        {
-            if seg.ident.name == sym::capacity {
-                return ControlFlow::Break(());
-            }
-            for &(fn_name, suffix) in replace {
-                if seg.ident.name == fn_name {
-                    spans.push((e.span, snippet(cx, recv.span, "_") + suffix));
-                    return ControlFlow::Continue(Descend::No);
-                }
-            }
-        }
-        ControlFlow::Continue(Descend::Yes)
-    })
-    .is_none()
-    .then_some(spans)
-}

From 9316d4508c42d5e6d91480aec34f66462801ee5d Mon Sep 17 00:00:00 2001
From: Noratrieb <48135649+Noratrieb@users.noreply.github.com>
Date: Thu, 25 Sep 2025 20:36:58 +0200
Subject: [PATCH 1402/1889] Remove most `#[track_caller]` from allocating Vec
 methods

They cause significant binary size overhead while contributing little
value.

Also removes them from the wrapping String methods that do not panic.
---
 .../alloc/src/collections/vec_deque/mod.rs    | 27 -------------
 .../src/collections/vec_deque/spec_extend.rs  |  6 ---
 .../collections/vec_deque/spec_from_iter.rs   |  1 -
 library/alloc/src/raw_vec/mod.rs              | 17 ---------
 library/alloc/src/string.rs                   | 13 -------
 library/alloc/src/vec/cow.rs                  |  1 -
 library/alloc/src/vec/in_place_collect.rs     |  2 -
 library/alloc/src/vec/mod.rs                  | 38 -------------------
 library/alloc/src/vec/spec_extend.rs          |  6 ---
 library/alloc/src/vec/spec_from_elem.rs       |  4 --
 library/alloc/src/vec/spec_from_iter.rs       |  2 -
 .../alloc/src/vec/spec_from_iter_nested.rs    |  2 -
 library/alloc/src/vec/splice.rs               |  2 -
 tests/ui/hygiene/panic-location.run.stderr    |  2 +-
 14 files changed, 1 insertion(+), 122 deletions(-)

diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs
index d589860524b82..ac619a42d356d 100644
--- a/library/alloc/src/collections/vec_deque/mod.rs
+++ b/library/alloc/src/collections/vec_deque/mod.rs
@@ -103,7 +103,6 @@ pub struct VecDeque<
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: Clone, A: Allocator + Clone> Clone for VecDeque<T, A> {
-    #[track_caller]
     fn clone(&self) -> Self {
         let mut deq = Self::with_capacity_in(self.len(), self.allocator().clone());
         deq.extend(self.iter().cloned());
@@ -114,7 +113,6 @@ impl<T: Clone, A: Allocator + Clone> Clone for VecDeque<T, A> {
     ///
     /// This method is preferred over simply assigning `source.clone()` to `self`,
     /// as it avoids reallocation if possible.
-    #[track_caller]
     fn clone_from(&mut self, source: &Self) {
         self.clear();
         self.extend(source.iter().cloned());
@@ -577,7 +575,6 @@ impl<T> VecDeque<T> {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     #[must_use]
-    #[track_caller]
     pub fn with_capacity(capacity: usize) -> VecDeque<T> {
         Self::with_capacity_in(capacity, Global)
     }
@@ -633,7 +630,6 @@ impl<T, A: Allocator> VecDeque<T, A> {
     /// let deque: VecDeque<u32> = VecDeque::with_capacity(10);
     /// ```
     #[unstable(feature = "allocator_api", issue = "32838")]
-    #[track_caller]
     pub fn with_capacity_in(capacity: usize, alloc: A) -> VecDeque<T, A> {
         VecDeque { head: 0, len: 0, buf: RawVec::with_capacity_in(capacity, alloc) }
     }
@@ -799,7 +795,6 @@ impl<T, A: Allocator> VecDeque<T, A> {
     ///
     /// [`reserve`]: VecDeque::reserve
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[track_caller]
     pub fn reserve_exact(&mut self, additional: usize) {
         let new_cap = self.len.checked_add(additional).expect("capacity overflow");
         let old_cap = self.capacity();
@@ -830,7 +825,6 @@ impl<T, A: Allocator> VecDeque<T, A> {
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     #[cfg_attr(not(test), rustc_diagnostic_item = "vecdeque_reserve")]
-    #[track_caller]
     pub fn reserve(&mut self, additional: usize) {
         let new_cap = self.len.checked_add(additional).expect("capacity overflow");
         let old_cap = self.capacity();
@@ -962,7 +956,6 @@ impl<T, A: Allocator> VecDeque<T, A> {
     /// assert!(buf.capacity() >= 4);
     /// ```
     #[stable(feature = "deque_extras_15", since = "1.5.0")]
-    #[track_caller]
     pub fn shrink_to_fit(&mut self) {
         self.shrink_to(0);
     }
@@ -988,7 +981,6 @@ impl<T, A: Allocator> VecDeque<T, A> {
     /// assert!(buf.capacity() >= 4);
     /// ```
     #[stable(feature = "shrink_to", since = "1.56.0")]
-    #[track_caller]
     pub fn shrink_to(&mut self, min_capacity: usize) {
         let target_cap = min_capacity.max(self.len);
 
@@ -1891,7 +1883,6 @@ impl<T, A: Allocator> VecDeque<T, A> {
     /// assert_eq!(d.front(), Some(&2));
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[track_caller]
     pub fn push_front(&mut self, value: T) {
         let _ = self.push_front_mut(value);
     }
@@ -1910,7 +1901,6 @@ impl<T, A: Allocator> VecDeque<T, A> {
     /// assert_eq!(d.front(), Some(&7));
     /// ```
     #[unstable(feature = "push_mut", issue = "135974")]
-    #[track_caller]
     #[must_use = "if you don't need a reference to the value, use `VecDeque::push_front` instead"]
     pub fn push_front_mut(&mut self, value: T) -> &mut T {
         if self.is_full() {
@@ -1937,7 +1927,6 @@ impl<T, A: Allocator> VecDeque<T, A> {
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     #[rustc_confusables("push", "put", "append")]
-    #[track_caller]
     pub fn push_back(&mut self, value: T) {
         let _ = self.push_back_mut(value);
     }
@@ -1956,7 +1945,6 @@ impl<T, A: Allocator> VecDeque<T, A> {
     /// assert_eq!(d.back(), Some(&10));
     /// ```
     #[unstable(feature = "push_mut", issue = "135974")]
-    #[track_caller]
     #[must_use = "if you don't need a reference to the value, use `VecDeque::push_back` instead"]
     pub fn push_back_mut(&mut self, value: T) -> &mut T {
         if self.is_full() {
@@ -2071,7 +2059,6 @@ impl<T, A: Allocator> VecDeque<T, A> {
     /// assert_eq!(vec_deque, &['a', 'd', 'b', 'c', 'e']);
     /// ```
     #[stable(feature = "deque_extras_15", since = "1.5.0")]
-    #[track_caller]
     pub fn insert(&mut self, index: usize, value: T) {
         let _ = self.insert_mut(index, value);
     }
@@ -2099,7 +2086,6 @@ impl<T, A: Allocator> VecDeque<T, A> {
     /// assert_eq!(vec_deque, &[1, 12, 2, 3]);
     /// ```
     #[unstable(feature = "push_mut", issue = "135974")]
-    #[track_caller]
     #[must_use = "if you don't need a reference to the value, use `VecDeque::insert` instead"]
     pub fn insert_mut(&mut self, index: usize, value: T) -> &mut T {
         assert!(index <= self.len(), "index out of bounds");
@@ -2205,7 +2191,6 @@ impl<T, A: Allocator> VecDeque<T, A> {
     #[inline]
     #[must_use = "use `.truncate()` if you don't need the other half"]
     #[stable(feature = "split_off", since = "1.4.0")]
-    #[track_caller]
     pub fn split_off(&mut self, at: usize) -> Self
     where
         A: Clone,
@@ -2272,7 +2257,6 @@ impl<T, A: Allocator> VecDeque<T, A> {
     /// ```
     #[inline]
     #[stable(feature = "append", since = "1.4.0")]
-    #[track_caller]
     pub fn append(&mut self, other: &mut Self) {
         if T::IS_ZST {
             self.len = self.len.checked_add(other.len).expect("capacity overflow");
@@ -2395,7 +2379,6 @@ impl<T, A: Allocator> VecDeque<T, A> {
     // be called in cold paths.
     // This may panic or abort
     #[inline(never)]
-    #[track_caller]
     fn grow(&mut self) {
         // Extend or possibly remove this assertion when valid use-cases for growing the
         // buffer without it being full emerge
@@ -2434,7 +2417,6 @@ impl<T, A: Allocator> VecDeque<T, A> {
     /// assert_eq!(buf, [5, 10, 101, 102, 103]);
     /// ```
     #[stable(feature = "vec_resize_with", since = "1.33.0")]
-    #[track_caller]
     pub fn resize_with(&mut self, new_len: usize, generator: impl FnMut() -> T) {
         let len = self.len;
 
@@ -2981,7 +2963,6 @@ impl<T: Clone, A: Allocator> VecDeque<T, A> {
     /// assert_eq!(buf, [5, 10, 20, 20, 20]);
     /// ```
     #[stable(feature = "deque_extras", since = "1.16.0")]
-    #[track_caller]
     pub fn resize(&mut self, new_len: usize, value: T) {
         if new_len > self.len() {
             let extra = new_len - self.len();
@@ -3101,7 +3082,6 @@ impl<T, A: Allocator> IndexMut<usize> for VecDeque<T, A> {
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> FromIterator<T> for VecDeque<T> {
-    #[track_caller]
     fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> VecDeque<T> {
         SpecFromIter::spec_from_iter(iter.into_iter())
     }
@@ -3141,19 +3121,16 @@ impl<'a, T, A: Allocator> IntoIterator for &'a mut VecDeque<T, A> {
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T, A: Allocator> Extend<T> for VecDeque<T, A> {
-    #[track_caller]
     fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
         <Self as SpecExtend<T, I::IntoIter>>::spec_extend(self, iter.into_iter());
     }
 
     #[inline]
-    #[track_caller]
     fn extend_one(&mut self, elem: T) {
         self.push_back(elem);
     }
 
     #[inline]
-    #[track_caller]
     fn extend_reserve(&mut self, additional: usize) {
         self.reserve(additional);
     }
@@ -3169,19 +3146,16 @@ impl<T, A: Allocator> Extend<T> for VecDeque<T, A> {
 
 #[stable(feature = "extend_ref", since = "1.2.0")]
 impl<'a, T: 'a + Copy, A: Allocator> Extend<&'a T> for VecDeque<T, A> {
-    #[track_caller]
     fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
         self.spec_extend(iter.into_iter());
     }
 
     #[inline]
-    #[track_caller]
     fn extend_one(&mut self, &elem: &'a T) {
         self.push_back(elem);
     }
 
     #[inline]
-    #[track_caller]
     fn extend_reserve(&mut self, additional: usize) {
         self.reserve(additional);
     }
@@ -3279,7 +3253,6 @@ impl<T, const N: usize> From<[T; N]> for VecDeque<T> {
     /// let deq2: VecDeque<_> = [1, 2, 3, 4].into();
     /// assert_eq!(deq1, deq2);
     /// ```
-    #[track_caller]
     fn from(arr: [T; N]) -> Self {
         let mut deq = VecDeque::with_capacity(N);
         let arr = ManuallyDrop::new(arr);
diff --git a/library/alloc/src/collections/vec_deque/spec_extend.rs b/library/alloc/src/collections/vec_deque/spec_extend.rs
index 7c7072c4c3a1b..6c2199135e08a 100644
--- a/library/alloc/src/collections/vec_deque/spec_extend.rs
+++ b/library/alloc/src/collections/vec_deque/spec_extend.rs
@@ -8,7 +8,6 @@ use crate::vec;
 
 // Specialization trait used for VecDeque::extend
 pub(super) trait SpecExtend<T, I> {
-    #[track_caller]
     fn spec_extend(&mut self, iter: I);
 }
 
@@ -16,7 +15,6 @@ impl<T, I, A: Allocator> SpecExtend<T, I> for VecDeque<T, A>
 where
     I: Iterator<Item = T>,
 {
-    #[track_caller]
     default fn spec_extend(&mut self, mut iter: I) {
         // This function should be the moral equivalent of:
         //
@@ -47,7 +45,6 @@ impl<T, I, A: Allocator> SpecExtend<T, I> for VecDeque<T, A>
 where
     I: TrustedLen<Item = T>,
 {
-    #[track_caller]
     default fn spec_extend(&mut self, iter: I) {
         // This is the case for a TrustedLen iterator.
         let (low, high) = iter.size_hint();
@@ -81,7 +78,6 @@ where
 
 #[cfg(not(test))]
 impl<T, A: Allocator> SpecExtend<T, vec::IntoIter<T>> for VecDeque<T, A> {
-    #[track_caller]
     fn spec_extend(&mut self, mut iterator: vec::IntoIter<T>) {
         let slice = iterator.as_slice();
         self.reserve(slice.len());
@@ -99,7 +95,6 @@ where
     I: Iterator<Item = &'a T>,
     T: Copy,
 {
-    #[track_caller]
     default fn spec_extend(&mut self, iterator: I) {
         self.spec_extend(iterator.copied())
     }
@@ -109,7 +104,6 @@ impl<'a, T: 'a, A: Allocator> SpecExtend<&'a T, slice::Iter<'a, T>> for VecDeque
 where
     T: Copy,
 {
-    #[track_caller]
     fn spec_extend(&mut self, iterator: slice::Iter<'a, T>) {
         let slice = iterator.as_slice();
         self.reserve(slice.len());
diff --git a/library/alloc/src/collections/vec_deque/spec_from_iter.rs b/library/alloc/src/collections/vec_deque/spec_from_iter.rs
index c80a30c2103dd..557666ea3b874 100644
--- a/library/alloc/src/collections/vec_deque/spec_from_iter.rs
+++ b/library/alloc/src/collections/vec_deque/spec_from_iter.rs
@@ -9,7 +9,6 @@ impl<T, I> SpecFromIter<T, I> for VecDeque<T>
 where
     I: Iterator<Item = T>,
 {
-    #[track_caller]
     default fn spec_from_iter(iterator: I) -> Self {
         // Since converting is O(1) now, just re-use the `Vec` logic for
         // anything where we can't do something extra-special for `VecDeque`,
diff --git a/library/alloc/src/raw_vec/mod.rs b/library/alloc/src/raw_vec/mod.rs
index 1d4a1f592a99a..bc9692f5b6c2f 100644
--- a/library/alloc/src/raw_vec/mod.rs
+++ b/library/alloc/src/raw_vec/mod.rs
@@ -24,7 +24,6 @@ mod tests;
 // only one location which panics rather than a bunch throughout the module.
 #[cfg(not(no_global_oom_handling))]
 #[cfg_attr(not(panic = "immediate-abort"), inline(never))]
-#[track_caller]
 fn capacity_overflow() -> ! {
     panic!("capacity overflow");
 }
@@ -123,7 +122,6 @@ impl<T> RawVec<T, Global> {
     #[cfg(not(any(no_global_oom_handling, test)))]
     #[must_use]
     #[inline]
-    #[track_caller]
     pub(crate) fn with_capacity(capacity: usize) -> Self {
         Self { inner: RawVecInner::with_capacity(capacity, T::LAYOUT), _marker: PhantomData }
     }
@@ -132,7 +130,6 @@ impl<T> RawVec<T, Global> {
     #[cfg(not(any(no_global_oom_handling, test)))]
     #[must_use]
     #[inline]
-    #[track_caller]
     pub(crate) fn with_capacity_zeroed(capacity: usize) -> Self {
         Self {
             inner: RawVecInner::with_capacity_zeroed_in(capacity, Global, T::LAYOUT),
@@ -145,7 +142,6 @@ impl RawVecInner<Global> {
     #[cfg(not(any(no_global_oom_handling, test)))]
     #[must_use]
     #[inline]
-    #[track_caller]
     fn with_capacity(capacity: usize, elem_layout: Layout) -> Self {
         match Self::try_allocate_in(capacity, AllocInit::Uninitialized, Global, elem_layout) {
             Ok(res) => res,
@@ -186,7 +182,6 @@ impl<T, A: Allocator> RawVec<T, A> {
     /// allocator for the returned `RawVec`.
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    #[track_caller]
     pub(crate) fn with_capacity_in(capacity: usize, alloc: A) -> Self {
         Self {
             inner: RawVecInner::with_capacity_in(capacity, alloc, T::LAYOUT),
@@ -208,7 +203,6 @@ impl<T, A: Allocator> RawVec<T, A> {
     /// of allocator for the returned `RawVec`.
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    #[track_caller]
     pub(crate) fn with_capacity_zeroed_in(capacity: usize, alloc: A) -> Self {
         Self {
             inner: RawVecInner::with_capacity_zeroed_in(capacity, alloc, T::LAYOUT),
@@ -328,7 +322,6 @@ impl<T, A: Allocator> RawVec<T, A> {
     /// Aborts on OOM.
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    #[track_caller]
     pub(crate) fn reserve(&mut self, len: usize, additional: usize) {
         // SAFETY: All calls on self.inner pass T::LAYOUT as the elem_layout
         unsafe { self.inner.reserve(len, additional, T::LAYOUT) }
@@ -338,7 +331,6 @@ impl<T, A: Allocator> RawVec<T, A> {
     /// caller to ensure `len == self.capacity()`.
     #[cfg(not(no_global_oom_handling))]
     #[inline(never)]
-    #[track_caller]
     pub(crate) fn grow_one(&mut self) {
         // SAFETY: All calls on self.inner pass T::LAYOUT as the elem_layout
         unsafe { self.inner.grow_one(T::LAYOUT) }
@@ -372,7 +364,6 @@ impl<T, A: Allocator> RawVec<T, A> {
     ///
     /// Aborts on OOM.
     #[cfg(not(no_global_oom_handling))]
-    #[track_caller]
     pub(crate) fn reserve_exact(&mut self, len: usize, additional: usize) {
         // SAFETY: All calls on self.inner pass T::LAYOUT as the elem_layout
         unsafe { self.inner.reserve_exact(len, additional, T::LAYOUT) }
@@ -399,7 +390,6 @@ impl<T, A: Allocator> RawVec<T, A> {
     ///
     /// Aborts on OOM.
     #[cfg(not(no_global_oom_handling))]
-    #[track_caller]
     #[inline]
     pub(crate) fn shrink_to_fit(&mut self, cap: usize) {
         // SAFETY: All calls on self.inner pass T::LAYOUT as the elem_layout
@@ -425,7 +415,6 @@ impl<A: Allocator> RawVecInner<A> {
 
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    #[track_caller]
     fn with_capacity_in(capacity: usize, alloc: A, elem_layout: Layout) -> Self {
         match Self::try_allocate_in(capacity, AllocInit::Uninitialized, alloc, elem_layout) {
             Ok(this) => {
@@ -450,7 +439,6 @@ impl<A: Allocator> RawVecInner<A> {
 
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    #[track_caller]
     fn with_capacity_zeroed_in(capacity: usize, alloc: A, elem_layout: Layout) -> Self {
         match Self::try_allocate_in(capacity, AllocInit::Zeroed, alloc, elem_layout) {
             Ok(res) => res,
@@ -553,7 +541,6 @@ impl<A: Allocator> RawVecInner<A> {
     /// - `elem_layout`'s size must be a multiple of its alignment
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    #[track_caller]
     unsafe fn reserve(&mut self, len: usize, additional: usize, elem_layout: Layout) {
         // Callers expect this function to be very cheap when there is already sufficient capacity.
         // Therefore, we move all the resizing and error-handling logic from grow_amortized and
@@ -585,7 +572,6 @@ impl<A: Allocator> RawVecInner<A> {
     /// - `elem_layout`'s size must be a multiple of its alignment
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    #[track_caller]
     unsafe fn grow_one(&mut self, elem_layout: Layout) {
         // SAFETY: Precondition passed to caller
         if let Err(err) = unsafe { self.grow_amortized(self.cap.as_inner(), 1, elem_layout) } {
@@ -621,7 +607,6 @@ impl<A: Allocator> RawVecInner<A> {
     ///   initially construct `self`
     /// - `elem_layout`'s size must be a multiple of its alignment
     #[cfg(not(no_global_oom_handling))]
-    #[track_caller]
     unsafe fn reserve_exact(&mut self, len: usize, additional: usize, elem_layout: Layout) {
         // SAFETY: Precondition passed to caller
         if let Err(err) = unsafe { self.try_reserve_exact(len, additional, elem_layout) } {
@@ -659,7 +644,6 @@ impl<A: Allocator> RawVecInner<A> {
     /// - `cap` must be less than or equal to `self.capacity(elem_layout.size())`
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    #[track_caller]
     unsafe fn shrink_to_fit(&mut self, cap: usize, elem_layout: Layout) {
         if let Err(err) = unsafe { self.shrink(cap, elem_layout) } {
             handle_error(err);
@@ -872,7 +856,6 @@ where
 #[cfg(not(no_global_oom_handling))]
 #[cold]
 #[optimize(size)]
-#[track_caller]
 fn handle_error(e: TryReserveError) -> ! {
     match e.kind() {
         CapacityOverflow => capacity_overflow(),
diff --git a/library/alloc/src/string.rs b/library/alloc/src/string.rs
index e669c4708ad09..ae30cabf5af5b 100644
--- a/library/alloc/src/string.rs
+++ b/library/alloc/src/string.rs
@@ -1105,7 +1105,6 @@ impl String {
     /// ```
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    #[track_caller]
     #[stable(feature = "rust1", since = "1.0.0")]
     #[rustc_confusables("append", "push")]
     #[rustc_diagnostic_item = "string_push_str"]
@@ -1208,7 +1207,6 @@ impl String {
     /// ```
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    #[track_caller]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn reserve(&mut self, additional: usize) {
         self.vec.reserve(additional)
@@ -1260,7 +1258,6 @@ impl String {
     #[cfg(not(no_global_oom_handling))]
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[track_caller]
     pub fn reserve_exact(&mut self, additional: usize) {
         self.vec.reserve_exact(additional)
     }
@@ -1356,7 +1353,6 @@ impl String {
     /// ```
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    #[track_caller]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn shrink_to_fit(&mut self) {
         self.vec.shrink_to_fit()
@@ -1384,7 +1380,6 @@ impl String {
     /// ```
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    #[track_caller]
     #[stable(feature = "shrink_to", since = "1.56.0")]
     pub fn shrink_to(&mut self, min_capacity: usize) {
         self.vec.shrink_to(min_capacity)
@@ -1406,7 +1401,6 @@ impl String {
     #[cfg(not(no_global_oom_handling))]
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[track_caller]
     pub fn push(&mut self, ch: char) {
         let len = self.len();
         let ch_len = ch.len_utf8();
@@ -2115,7 +2109,6 @@ impl String {
     #[stable(feature = "box_str", since = "1.4.0")]
     #[must_use = "`self` will be dropped if the result is not used"]
     #[inline]
-    #[track_caller]
     pub fn into_boxed_str(self) -> Box<str> {
         let slice = self.vec.into_boxed_slice();
         unsafe { from_boxed_utf8_unchecked(slice) }
@@ -2293,7 +2286,6 @@ impl Error for FromUtf16Error {}
 #[cfg(not(no_global_oom_handling))]
 #[stable(feature = "rust1", since = "1.0.0")]
 impl Clone for String {
-    #[track_caller]
     fn clone(&self) -> Self {
         String { vec: self.vec.clone() }
     }
@@ -2302,7 +2294,6 @@ impl Clone for String {
     ///
     /// This method is preferred over simply assigning `source.clone()` to `self`,
     /// as it avoids reallocation if possible.
-    #[track_caller]
     fn clone_from(&mut self, source: &Self) {
         self.vec.clone_from(&source.vec);
     }
@@ -2477,13 +2468,11 @@ impl<'a> Extend<Cow<'a, str>> for String {
 #[unstable(feature = "ascii_char", issue = "110998")]
 impl Extend<core::ascii::Char> for String {
     #[inline]
-    #[track_caller]
     fn extend<I: IntoIterator<Item = core::ascii::Char>>(&mut self, iter: I) {
         self.vec.extend(iter.into_iter().map(|c| c.to_u8()));
     }
 
     #[inline]
-    #[track_caller]
     fn extend_one(&mut self, c: core::ascii::Char) {
         self.vec.push(c.to_u8());
     }
@@ -2493,13 +2482,11 @@ impl Extend<core::ascii::Char> for String {
 #[unstable(feature = "ascii_char", issue = "110998")]
 impl<'a> Extend<&'a core::ascii::Char> for String {
     #[inline]
-    #[track_caller]
     fn extend<I: IntoIterator<Item = &'a core::ascii::Char>>(&mut self, iter: I) {
         self.extend(iter.into_iter().cloned());
     }
 
     #[inline]
-    #[track_caller]
     fn extend_one(&mut self, c: &'a core::ascii::Char) {
         self.vec.push(c.to_u8());
     }
diff --git a/library/alloc/src/vec/cow.rs b/library/alloc/src/vec/cow.rs
index 4deb35efffc14..c18091705a636 100644
--- a/library/alloc/src/vec/cow.rs
+++ b/library/alloc/src/vec/cow.rs
@@ -58,7 +58,6 @@ impl<'a, T> FromIterator<T> for Cow<'a, [T]>
 where
     T: Clone,
 {
-    #[track_caller]
     fn from_iter<I: IntoIterator<Item = T>>(it: I) -> Cow<'a, [T]> {
         Cow::Owned(FromIterator::from_iter(it))
     }
diff --git a/library/alloc/src/vec/in_place_collect.rs b/library/alloc/src/vec/in_place_collect.rs
index b98a118048f2d..8a7c0b92eccf6 100644
--- a/library/alloc/src/vec/in_place_collect.rs
+++ b/library/alloc/src/vec/in_place_collect.rs
@@ -229,7 +229,6 @@ where
     I: Iterator<Item = T> + InPlaceCollect,
     <I as SourceIter>::Source: AsVecIntoIter,
 {
-    #[track_caller]
     default fn from_iter(iterator: I) -> Self {
         // Select the implementation in const eval to avoid codegen of the dead branch to improve compile times.
         let fun: fn(I) -> Vec<T> = const {
@@ -247,7 +246,6 @@ where
     }
 }
 
-#[track_caller]
 fn from_iter_in_place<I, T>(mut iterator: I) -> Vec<T>
 where
     I: Iterator<Item = T> + InPlaceCollect,
diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs
index ebdb86f98a857..81b405253a1b4 100644
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -515,7 +515,6 @@ impl<T> Vec<T> {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[must_use]
     #[rustc_diagnostic_item = "vec_with_capacity"]
-    #[track_caller]
     pub fn with_capacity(capacity: usize) -> Self {
         Self::with_capacity_in(capacity, Global)
     }
@@ -926,7 +925,6 @@ impl<T, A: Allocator> Vec<T, A> {
     #[cfg(not(no_global_oom_handling))]
     #[inline]
     #[unstable(feature = "allocator_api", issue = "32838")]
-    #[track_caller]
     pub fn with_capacity_in(capacity: usize, alloc: A) -> Self {
         Vec { buf: RawVec::with_capacity_in(capacity, alloc), len: 0 }
     }
@@ -1335,7 +1333,6 @@ impl<T, A: Allocator> Vec<T, A> {
     /// ```
     #[cfg(not(no_global_oom_handling))]
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[track_caller]
     #[rustc_diagnostic_item = "vec_reserve"]
     pub fn reserve(&mut self, additional: usize) {
         self.buf.reserve(self.len, additional);
@@ -1367,7 +1364,6 @@ impl<T, A: Allocator> Vec<T, A> {
     /// ```
     #[cfg(not(no_global_oom_handling))]
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[track_caller]
     pub fn reserve_exact(&mut self, additional: usize) {
         self.buf.reserve_exact(self.len, additional);
     }
@@ -1471,7 +1467,6 @@ impl<T, A: Allocator> Vec<T, A> {
     /// ```
     #[cfg(not(no_global_oom_handling))]
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[track_caller]
     #[inline]
     pub fn shrink_to_fit(&mut self) {
         // The capacity is never less than the length, and there's nothing to do when
@@ -1502,7 +1497,6 @@ impl<T, A: Allocator> Vec<T, A> {
     /// ```
     #[cfg(not(no_global_oom_handling))]
     #[stable(feature = "shrink_to", since = "1.56.0")]
-    #[track_caller]
     pub fn shrink_to(&mut self, min_capacity: usize) {
         if self.capacity() > min_capacity {
             self.buf.shrink_to_fit(cmp::max(self.len, min_capacity));
@@ -1536,7 +1530,6 @@ impl<T, A: Allocator> Vec<T, A> {
     /// ```
     #[cfg(not(no_global_oom_handling))]
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[track_caller]
     pub fn into_boxed_slice(mut self) -> Box<[T], A> {
         unsafe {
             self.shrink_to_fit();
@@ -2021,7 +2014,6 @@ impl<T, A: Allocator> Vec<T, A> {
     pub fn swap_remove(&mut self, index: usize) -> T {
         #[cold]
         #[cfg_attr(not(panic = "immediate-abort"), inline(never))]
-        #[track_caller]
         #[optimize(size)]
         fn assert_failed(index: usize, len: usize) -> ! {
             panic!("swap_remove index (is {index}) should be < len (is {len})");
@@ -2540,7 +2532,6 @@ impl<T, A: Allocator> Vec<T, A> {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     #[rustc_confusables("push_back", "put", "append")]
-    #[track_caller]
     pub fn push(&mut self, value: T) {
         let _ = self.push_mut(value);
     }
@@ -2617,7 +2608,6 @@ impl<T, A: Allocator> Vec<T, A> {
     #[cfg(not(no_global_oom_handling))]
     #[inline]
     #[unstable(feature = "push_mut", issue = "135974")]
-    #[track_caller]
     #[must_use = "if you don't need a reference to the value, use `Vec::push` instead"]
     pub fn push_mut(&mut self, value: T) -> &mut T {
         // Inform codegen that the length does not change across grow_one().
@@ -2765,7 +2755,6 @@ impl<T, A: Allocator> Vec<T, A> {
     #[cfg(not(no_global_oom_handling))]
     #[inline]
     #[stable(feature = "append", since = "1.4.0")]
-    #[track_caller]
     pub fn append(&mut self, other: &mut Self) {
         unsafe {
             self.append_elements(other.as_slice() as _);
@@ -2776,7 +2765,6 @@ impl<T, A: Allocator> Vec<T, A> {
     /// Appends elements to `self` from other buffer.
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    #[track_caller]
     unsafe fn append_elements(&mut self, other: *const [T]) {
         let count = other.len();
         self.reserve(count);
@@ -3011,7 +2999,6 @@ impl<T, A: Allocator> Vec<T, A> {
     /// ```
     #[cfg(not(no_global_oom_handling))]
     #[stable(feature = "vec_resize_with", since = "1.33.0")]
-    #[track_caller]
     pub fn resize_with<F>(&mut self, new_len: usize, f: F)
     where
         F: FnMut() -> T,
@@ -3276,7 +3263,6 @@ impl<T: Clone, A: Allocator> Vec<T, A> {
     /// ```
     #[cfg(not(no_global_oom_handling))]
     #[stable(feature = "vec_resize", since = "1.5.0")]
-    #[track_caller]
     pub fn resize(&mut self, new_len: usize, value: T) {
         let len = self.len();
 
@@ -3307,7 +3293,6 @@ impl<T: Clone, A: Allocator> Vec<T, A> {
     /// [`extend`]: Vec::extend
     #[cfg(not(no_global_oom_handling))]
     #[stable(feature = "vec_extend_from_slice", since = "1.6.0")]
-    #[track_caller]
     pub fn extend_from_slice(&mut self, other: &[T]) {
         self.spec_extend(other.iter())
     }
@@ -3338,7 +3323,6 @@ impl<T: Clone, A: Allocator> Vec<T, A> {
     /// ```
     #[cfg(not(no_global_oom_handling))]
     #[stable(feature = "vec_extend_from_within", since = "1.53.0")]
-    #[track_caller]
     pub fn extend_from_within<R>(&mut self, src: R)
     where
         R: RangeBounds<usize>,
@@ -3399,7 +3383,6 @@ impl<T, A: Allocator, const N: usize> Vec<[T; N], A> {
 
 impl<T: Clone, A: Allocator> Vec<T, A> {
     #[cfg(not(no_global_oom_handling))]
-    #[track_caller]
     /// Extend the vector by `n` clones of value.
     fn extend_with(&mut self, n: usize, value: T) {
         self.reserve(n);
@@ -3460,7 +3443,6 @@ impl<T: PartialEq, A: Allocator> Vec<T, A> {
 #[cfg(not(no_global_oom_handling))]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_diagnostic_item = "vec_from_elem"]
-#[track_caller]
 pub fn from_elem<T: Clone>(elem: T, n: usize) -> Vec<T> {
     <T as SpecFromElem>::from_elem(elem, n, Global)
 }
@@ -3468,7 +3450,6 @@ pub fn from_elem<T: Clone>(elem: T, n: usize) -> Vec<T> {
 #[doc(hidden)]
 #[cfg(not(no_global_oom_handling))]
 #[unstable(feature = "allocator_api", issue = "32838")]
-#[track_caller]
 pub fn from_elem_in<T: Clone, A: Allocator>(elem: T, n: usize, alloc: A) -> Vec<T, A> {
     <T as SpecFromElem>::from_elem(elem, n, alloc)
 }
@@ -3559,7 +3540,6 @@ unsafe impl<T, A: Allocator> ops::DerefPure for Vec<T, A> {}
 #[cfg(not(no_global_oom_handling))]
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: Clone, A: Allocator + Clone> Clone for Vec<T, A> {
-    #[track_caller]
     fn clone(&self) -> Self {
         let alloc = self.allocator().clone();
         <[T]>::to_vec_in(&**self, alloc)
@@ -3587,7 +3567,6 @@ impl<T: Clone, A: Allocator + Clone> Clone for Vec<T, A> {
     /// // And no reallocation occurred
     /// assert_eq!(yp, y.as_ptr());
     /// ```
-    #[track_caller]
     fn clone_from(&mut self, source: &Self) {
         crate::slice::SpecCloneIntoVec::clone_into(source.as_slice(), self);
     }
@@ -3678,7 +3657,6 @@ impl<T, I: SliceIndex<[T]>, A: Allocator> IndexMut<I> for Vec<T, A> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> FromIterator<T> for Vec<T> {
     #[inline]
-    #[track_caller]
     fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Vec<T> {
         <Self as SpecFromIter<T, I::IntoIter>>::from_iter(iter.into_iter())
     }
@@ -3747,19 +3725,16 @@ impl<'a, T, A: Allocator> IntoIterator for &'a mut Vec<T, A> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T, A: Allocator> Extend<T> for Vec<T, A> {
     #[inline]
-    #[track_caller]
     fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
         <Self as SpecExtend<T, I::IntoIter>>::spec_extend(self, iter.into_iter())
     }
 
     #[inline]
-    #[track_caller]
     fn extend_one(&mut self, item: T) {
         self.push(item);
     }
 
     #[inline]
-    #[track_caller]
     fn extend_reserve(&mut self, additional: usize) {
         self.reserve(additional);
     }
@@ -3779,7 +3754,6 @@ impl<T, A: Allocator> Vec<T, A> {
     // leaf method to which various SpecFrom/SpecExtend implementations delegate when
     // they have no further optimizations to apply
     #[cfg(not(no_global_oom_handling))]
-    #[track_caller]
     fn extend_desugared<I: Iterator<Item = T>>(&mut self, mut iterator: I) {
         // This is the case for a general iterator.
         //
@@ -3807,7 +3781,6 @@ impl<T, A: Allocator> Vec<T, A> {
     // specific extend for `TrustedLen` iterators, called both by the specializations
     // and internal places where resolving specialization makes compilation slower
     #[cfg(not(no_global_oom_handling))]
-    #[track_caller]
     fn extend_trusted(&mut self, iterator: impl iter::TrustedLen<Item = T>) {
         let (low, high) = iterator.size_hint();
         if let Some(additional) = high {
@@ -3985,19 +3958,16 @@ impl<T, A: Allocator> Vec<T, A> {
 #[cfg(not(no_global_oom_handling))]
 #[stable(feature = "extend_ref", since = "1.2.0")]
 impl<'a, T: Copy + 'a, A: Allocator> Extend<&'a T> for Vec<T, A> {
-    #[track_caller]
     fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
         self.spec_extend(iter.into_iter())
     }
 
     #[inline]
-    #[track_caller]
     fn extend_one(&mut self, &item: &'a T) {
         self.push(item);
     }
 
     #[inline]
-    #[track_caller]
     fn extend_reserve(&mut self, additional: usize) {
         self.reserve(additional);
     }
@@ -4108,7 +4078,6 @@ impl<T: Clone> From<&[T]> for Vec<T> {
     /// ```
     /// assert_eq!(Vec::from(&[1, 2, 3][..]), vec![1, 2, 3]);
     /// ```
-    #[track_caller]
     fn from(s: &[T]) -> Vec<T> {
         s.to_vec()
     }
@@ -4124,7 +4093,6 @@ impl<T: Clone> From<&mut [T]> for Vec<T> {
     /// ```
     /// assert_eq!(Vec::from(&mut [1, 2, 3][..]), vec![1, 2, 3]);
     /// ```
-    #[track_caller]
     fn from(s: &mut [T]) -> Vec<T> {
         s.to_vec()
     }
@@ -4140,7 +4108,6 @@ impl<T: Clone, const N: usize> From<&[T; N]> for Vec<T> {
     /// ```
     /// assert_eq!(Vec::from(&[1, 2, 3]), vec![1, 2, 3]);
     /// ```
-    #[track_caller]
     fn from(s: &[T; N]) -> Vec<T> {
         Self::from(s.as_slice())
     }
@@ -4156,7 +4123,6 @@ impl<T: Clone, const N: usize> From<&mut [T; N]> for Vec<T> {
     /// ```
     /// assert_eq!(Vec::from(&mut [1, 2, 3]), vec![1, 2, 3]);
     /// ```
-    #[track_caller]
     fn from(s: &mut [T; N]) -> Vec<T> {
         Self::from(s.as_mut_slice())
     }
@@ -4172,7 +4138,6 @@ impl<T, const N: usize> From<[T; N]> for Vec<T> {
     /// ```
     /// assert_eq!(Vec::from([1, 2, 3]), vec![1, 2, 3]);
     /// ```
-    #[track_caller]
     fn from(s: [T; N]) -> Vec<T> {
         <[T]>::into_vec(Box::new(s))
     }
@@ -4197,7 +4162,6 @@ where
     /// let b: Cow<'_, [i32]> = Cow::Borrowed(&[1, 2, 3]);
     /// assert_eq!(Vec::from(o), Vec::from(b));
     /// ```
-    #[track_caller]
     fn from(s: Cow<'a, [T]>) -> Vec<T> {
         s.into_owned()
     }
@@ -4244,7 +4208,6 @@ impl<T, A: Allocator> From<Vec<T, A>> for Box<[T], A> {
     ///
     /// assert_eq!(Box::from(vec), vec![1, 2, 3].into_boxed_slice());
     /// ```
-    #[track_caller]
     fn from(v: Vec<T, A>) -> Self {
         v.into_boxed_slice()
     }
@@ -4260,7 +4223,6 @@ impl From<&str> for Vec<u8> {
     /// ```
     /// assert_eq!(Vec::from("123"), vec![b'1', b'2', b'3']);
     /// ```
-    #[track_caller]
     fn from(s: &str) -> Vec<u8> {
         From::from(s.as_bytes())
     }
diff --git a/library/alloc/src/vec/spec_extend.rs b/library/alloc/src/vec/spec_extend.rs
index b98db669059f9..7085bceef5baa 100644
--- a/library/alloc/src/vec/spec_extend.rs
+++ b/library/alloc/src/vec/spec_extend.rs
@@ -6,7 +6,6 @@ use crate::alloc::Allocator;
 
 // Specialization trait used for Vec::extend
 pub(super) trait SpecExtend<T, I> {
-    #[track_caller]
     fn spec_extend(&mut self, iter: I);
 }
 
@@ -14,7 +13,6 @@ impl<T, I, A: Allocator> SpecExtend<T, I> for Vec<T, A>
 where
     I: Iterator<Item = T>,
 {
-    #[track_caller]
     default fn spec_extend(&mut self, iter: I) {
         self.extend_desugared(iter)
     }
@@ -24,14 +22,12 @@ impl<T, I, A: Allocator> SpecExtend<T, I> for Vec<T, A>
 where
     I: TrustedLen<Item = T>,
 {
-    #[track_caller]
     default fn spec_extend(&mut self, iterator: I) {
         self.extend_trusted(iterator)
     }
 }
 
 impl<T, A: Allocator> SpecExtend<T, IntoIter<T>> for Vec<T, A> {
-    #[track_caller]
     fn spec_extend(&mut self, mut iterator: IntoIter<T>) {
         unsafe {
             self.append_elements(iterator.as_slice() as _);
@@ -45,7 +41,6 @@ where
     I: Iterator<Item = &'a T>,
     T: Clone,
 {
-    #[track_caller]
     default fn spec_extend(&mut self, iterator: I) {
         self.spec_extend(iterator.cloned())
     }
@@ -55,7 +50,6 @@ impl<'a, T: 'a, A: Allocator> SpecExtend<&'a T, slice::Iter<'a, T>> for Vec<T, A
 where
     T: Copy,
 {
-    #[track_caller]
     fn spec_extend(&mut self, iterator: slice::Iter<'a, T>) {
         let slice = iterator.as_slice();
         unsafe { self.append_elements(slice) };
diff --git a/library/alloc/src/vec/spec_from_elem.rs b/library/alloc/src/vec/spec_from_elem.rs
index 6c7b4d89f2da7..96d701e15d487 100644
--- a/library/alloc/src/vec/spec_from_elem.rs
+++ b/library/alloc/src/vec/spec_from_elem.rs
@@ -10,7 +10,6 @@ pub(super) trait SpecFromElem: Sized {
 }
 
 impl<T: Clone> SpecFromElem for T {
-    #[track_caller]
     default fn from_elem<A: Allocator>(elem: Self, n: usize, alloc: A) -> Vec<Self, A> {
         let mut v = Vec::with_capacity_in(n, alloc);
         v.extend_with(n, elem);
@@ -20,7 +19,6 @@ impl<T: Clone> SpecFromElem for T {
 
 impl<T: Clone + IsZero> SpecFromElem for T {
     #[inline]
-    #[track_caller]
     default fn from_elem<A: Allocator>(elem: T, n: usize, alloc: A) -> Vec<T, A> {
         if elem.is_zero() {
             return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n };
@@ -33,7 +31,6 @@ impl<T: Clone + IsZero> SpecFromElem for T {
 
 impl SpecFromElem for i8 {
     #[inline]
-    #[track_caller]
     fn from_elem<A: Allocator>(elem: i8, n: usize, alloc: A) -> Vec<i8, A> {
         if elem == 0 {
             return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n };
@@ -49,7 +46,6 @@ impl SpecFromElem for i8 {
 
 impl SpecFromElem for u8 {
     #[inline]
-    #[track_caller]
     fn from_elem<A: Allocator>(elem: u8, n: usize, alloc: A) -> Vec<u8, A> {
         if elem == 0 {
             return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n };
diff --git a/library/alloc/src/vec/spec_from_iter.rs b/library/alloc/src/vec/spec_from_iter.rs
index ad7688e1c59f0..e1f0b639bdfd6 100644
--- a/library/alloc/src/vec/spec_from_iter.rs
+++ b/library/alloc/src/vec/spec_from_iter.rs
@@ -29,14 +29,12 @@ impl<T, I> SpecFromIter<T, I> for Vec<T>
 where
     I: Iterator<Item = T>,
 {
-    #[track_caller]
     default fn from_iter(iterator: I) -> Self {
         SpecFromIterNested::from_iter(iterator)
     }
 }
 
 impl<T> SpecFromIter<T, IntoIter<T>> for Vec<T> {
-    #[track_caller]
     fn from_iter(iterator: IntoIter<T>) -> Self {
         // A common case is passing a vector into a function which immediately
         // re-collects into a vector. We can short circuit this if the IntoIter
diff --git a/library/alloc/src/vec/spec_from_iter_nested.rs b/library/alloc/src/vec/spec_from_iter_nested.rs
index 22eed238798cf..77f7761d22f95 100644
--- a/library/alloc/src/vec/spec_from_iter_nested.rs
+++ b/library/alloc/src/vec/spec_from_iter_nested.rs
@@ -15,7 +15,6 @@ impl<T, I> SpecFromIterNested<T, I> for Vec<T>
 where
     I: Iterator<Item = T>,
 {
-    #[track_caller]
     default fn from_iter(mut iterator: I) -> Self {
         // Unroll the first iteration, as the vector is going to be
         // expanded on this iteration in every case when the iterable is not
@@ -48,7 +47,6 @@ impl<T, I> SpecFromIterNested<T, I> for Vec<T>
 where
     I: TrustedLen<Item = T>,
 {
-    #[track_caller]
     fn from_iter(iterator: I) -> Self {
         let mut vector = match iterator.size_hint() {
             (_, Some(upper)) => Vec::with_capacity(upper),
diff --git a/library/alloc/src/vec/splice.rs b/library/alloc/src/vec/splice.rs
index ed1a0dda76d29..d571e35828aeb 100644
--- a/library/alloc/src/vec/splice.rs
+++ b/library/alloc/src/vec/splice.rs
@@ -52,7 +52,6 @@ impl<I: Iterator, A: Allocator> ExactSizeIterator for Splice<'_, I, A> {}
 
 #[stable(feature = "vec_splice", since = "1.21.0")]
 impl<I: Iterator, A: Allocator> Drop for Splice<'_, I, A> {
-    #[track_caller]
     fn drop(&mut self) {
         self.drain.by_ref().for_each(drop);
         // At this point draining is done and the only remaining tasks are splicing
@@ -124,7 +123,6 @@ impl<T, A: Allocator> Drain<'_, T, A> {
     }
 
     /// Makes room for inserting more elements before the tail.
-    #[track_caller]
     unsafe fn move_tail(&mut self, additional: usize) {
         let vec = unsafe { self.vec.as_mut() };
         let len = self.tail_start + self.tail_len;
diff --git a/tests/ui/hygiene/panic-location.run.stderr b/tests/ui/hygiene/panic-location.run.stderr
index d28ab86418345..bd74e96fd8cc7 100644
--- a/tests/ui/hygiene/panic-location.run.stderr
+++ b/tests/ui/hygiene/panic-location.run.stderr
@@ -1,4 +1,4 @@
 
-thread 'main' ($TID) panicked at $DIR/panic-location.rs:LL:CC:
+thread 'main' ($TID) panicked at library/alloc/src/raw_vec/mod.rs:LL:CC:
 capacity overflow
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

From c98b3b2da46146956b982e4ae1747c3614a461fd Mon Sep 17 00:00:00 2001
From: Akrm Al-Hakimi <alhakimiakrmj@gmail.com>
Date: Thu, 25 Sep 2025 13:57:59 -0400
Subject: [PATCH 1403/1889] const_caller_location: edit FIXME to explain use of
 `DUMMY_SP`

Co-authored-by: Ralf Jung <post@ralfj.de>
---
 compiler/rustc_const_eval/src/util/caller_location.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_const_eval/src/util/caller_location.rs b/compiler/rustc_const_eval/src/util/caller_location.rs
index 5249b32eca469..4e7c8310007b8 100644
--- a/compiler/rustc_const_eval/src/util/caller_location.rs
+++ b/compiler/rustc_const_eval/src/util/caller_location.rs
@@ -61,7 +61,7 @@ pub(crate) fn const_caller_location_provider(
     trace!("const_caller_location: {}:{}:{}", file, line, col);
     let mut ecx = mk_eval_cx_to_read_const_val(
         tcx,
-        rustc_span::DUMMY_SP, // FIXME: use a proper span here?
+        rustc_span::DUMMY_SP, // This interpreter cannot fail, so the span is irrelevant.
         ty::TypingEnv::fully_monomorphized(),
         CanAccessMutGlobal::No,
     );

From b9037f97e38acc698af1260cad5d31ca07ac616a Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Thu, 25 Sep 2025 13:04:34 -0700
Subject: [PATCH 1404/1889] rustdoc-search: use the same ID for entry and path
 to same item

This decreases the size of the compiler-doc from 57MiB to 56MiB.
---
 src/librustdoc/html/render/search_index.rs | 32 ++++++++++++++++------
 1 file changed, 24 insertions(+), 8 deletions(-)

diff --git a/src/librustdoc/html/render/search_index.rs b/src/librustdoc/html/render/search_index.rs
index 3ffce61f7c613..74cf2b1812330 100644
--- a/src/librustdoc/html/render/search_index.rs
+++ b/src/librustdoc/html/render/search_index.rs
@@ -241,6 +241,26 @@ impl SerializedSearchIndex {
         self.alias_pointers.push(alias_pointer);
         index
     }
+    fn add_entry(&mut self, name: Symbol, entry_data: EntryData, desc: String) -> usize {
+        let fqp = if let Some(module_path_index) = entry_data.module_path {
+            let mut fqp = self.path_data[module_path_index].as_ref().unwrap().module_path.clone();
+            fqp.push(Symbol::intern(&self.names[module_path_index]));
+            fqp.push(name);
+            fqp
+        } else {
+            vec![name]
+        };
+        if let Some(&other_path) = self.crate_paths_index.get(&(entry_data.ty, fqp))
+            && self.entry_data[other_path].is_none()
+            && self.descs[other_path].is_empty()
+        {
+            self.entry_data[other_path] = Some(entry_data);
+            self.descs[other_path] = desc;
+            other_path
+        } else {
+            self.push(name.as_str().to_string(), None, Some(entry_data), desc, None, None, None)
+        }
+    }
     fn push_path(&mut self, name: String, path_data: PathData) -> usize {
         self.push(name, Some(path_data), None, String::new(), None, None, None)
     }
@@ -1516,10 +1536,9 @@ pub(crate) fn build_index(
             .as_ref()
             .map(|path| serialized_index.get_id_by_module_path(path));
 
-        let new_entry_id = serialized_index.push(
-            item.name.as_str().to_string(),
-            None,
-            Some(EntryData {
+        let new_entry_id = serialized_index.add_entry(
+            item.name,
+            EntryData {
                 ty: item.ty,
                 parent: item.parent_idx,
                 module_path,
@@ -1538,11 +1557,8 @@ pub(crate) fn build_index(
                     None
                 },
                 krate: crate_idx,
-            }),
+            },
             item.desc.to_string(),
-            None, // filled in after all the types have been indexed
-            None,
-            None,
         );
 
         // Aliases

From e0f22df8b9376c86496eb7facaadd7b27ef6e4a8 Mon Sep 17 00:00:00 2001
From: Oblarg <emichaelbrnett@gmail.com>
Date: Thu, 25 Sep 2025 12:11:11 -0400
Subject: [PATCH 1405/1889] fix transcriber error in declarative macros for
 negative integer literal const generic params

---
 .../crates/mbe/src/expander/transcriber.rs    | 14 ++-
 .../rust-analyzer/crates/mbe/src/tests.rs     | 97 +++++++++++++++++++
 2 files changed, 110 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/mbe/src/expander/transcriber.rs b/src/tools/rust-analyzer/crates/mbe/src/expander/transcriber.rs
index 2c046df10f5e5..3e4ab8bdc1d8d 100644
--- a/src/tools/rust-analyzer/crates/mbe/src/expander/transcriber.rs
+++ b/src/tools/rust-analyzer/crates/mbe/src/expander/transcriber.rs
@@ -401,7 +401,19 @@ fn expand_var(
                     let sub = sub.strip_invisible();
                     let mut span = id;
                     marker(&mut span);
-                    let wrap_in_parens = !matches!(sub.flat_tokens(), [tt::TokenTree::Leaf(_)])
+
+                    // Check if this is a simple negative literal (MINUS + LITERAL)
+                    // that should not be wrapped in parentheses
+                    let is_negative_literal = matches!(
+                        sub.flat_tokens(),
+                        [
+                            tt::TokenTree::Leaf(tt::Leaf::Punct(tt::Punct { char: '-', .. })),
+                            tt::TokenTree::Leaf(tt::Leaf::Literal(_))
+                        ]
+                    );
+
+                    let wrap_in_parens = !is_negative_literal
+                        && !matches!(sub.flat_tokens(), [tt::TokenTree::Leaf(_)])
                         && sub.try_into_subtree().is_none_or(|it| {
                             it.top_subtree().delimiter.kind == tt::DelimiterKind::Invisible
                         });
diff --git a/src/tools/rust-analyzer/crates/mbe/src/tests.rs b/src/tools/rust-analyzer/crates/mbe/src/tests.rs
index 56034516ef3b2..589e169d30a3d 100644
--- a/src/tools/rust-analyzer/crates/mbe/src/tests.rs
+++ b/src/tools/rust-analyzer/crates/mbe/src/tests.rs
@@ -476,3 +476,100 @@ fn minus_belongs_to_literal() {
             --"#]],
     );
 }
+
+#[test]
+fn negative_literals_in_const_generics() {
+    // Test that negative literals work correctly in declarative macros
+    // when used as const generic arguments. The issue was that expressions
+    // like -1 would be wrapped in parentheses, creating invalid syntax
+    // Foo::<(-1)> instead of the correct Foo::<-1>.
+    let decl = r#"
+($val:expr) => {
+    struct Foo<const I: i16> {
+        pub value: i16,
+    }
+
+    impl<const I: i16> Foo<I> {
+        pub fn new(value: i16) -> Self {
+            Self { value }
+        }
+    }
+
+    Foo::<$val>::new($val)
+};
+"#;
+    let check = |args, expect| check(Edition::CURRENT, Edition::CURRENT, decl, args, expect);
+
+    // Test negative integer literal - should produce Foo::<-1>, not Foo::<(-1)>
+    check(
+        "-1",
+        expect![[r#"
+            SUBTREE $$ 1:Root[0000, 0]@0..2#ROOT2024 1:Root[0000, 0]@0..2#ROOT2024
+              IDENT   struct 0:Root[0000, 0]@22..28#ROOT2024
+              IDENT   Foo 0:Root[0000, 0]@29..32#ROOT2024
+              PUNCH   < [alone] 0:Root[0000, 0]@32..33#ROOT2024
+              IDENT   const 0:Root[0000, 0]@33..38#ROOT2024
+              IDENT   I 0:Root[0000, 0]@39..40#ROOT2024
+              PUNCH   : [alone] 0:Root[0000, 0]@40..41#ROOT2024
+              IDENT   i16 0:Root[0000, 0]@42..45#ROOT2024
+              PUNCH   > [alone] 0:Root[0000, 0]@45..46#ROOT2024
+              SUBTREE {} 0:Root[0000, 0]@47..48#ROOT2024 0:Root[0000, 0]@77..78#ROOT2024
+                IDENT   pub 0:Root[0000, 0]@57..60#ROOT2024
+                IDENT   value 0:Root[0000, 0]@61..66#ROOT2024
+                PUNCH   : [alone] 0:Root[0000, 0]@66..67#ROOT2024
+                IDENT   i16 0:Root[0000, 0]@68..71#ROOT2024
+                PUNCH   , [alone] 0:Root[0000, 0]@71..72#ROOT2024
+              IDENT   impl 0:Root[0000, 0]@84..88#ROOT2024
+              PUNCH   < [alone] 0:Root[0000, 0]@88..89#ROOT2024
+              IDENT   const 0:Root[0000, 0]@89..94#ROOT2024
+              IDENT   I 0:Root[0000, 0]@95..96#ROOT2024
+              PUNCH   : [alone] 0:Root[0000, 0]@96..97#ROOT2024
+              IDENT   i16 0:Root[0000, 0]@98..101#ROOT2024
+              PUNCH   > [alone] 0:Root[0000, 0]@101..102#ROOT2024
+              IDENT   Foo 0:Root[0000, 0]@103..106#ROOT2024
+              PUNCH   < [alone] 0:Root[0000, 0]@106..107#ROOT2024
+              IDENT   I 0:Root[0000, 0]@107..108#ROOT2024
+              PUNCH   > [alone] 0:Root[0000, 0]@108..109#ROOT2024
+              SUBTREE {} 0:Root[0000, 0]@110..111#ROOT2024 0:Root[0000, 0]@194..195#ROOT2024
+                IDENT   pub 0:Root[0000, 0]@120..123#ROOT2024
+                IDENT   fn 0:Root[0000, 0]@124..126#ROOT2024
+                IDENT   new 0:Root[0000, 0]@127..130#ROOT2024
+                SUBTREE () 0:Root[0000, 0]@130..131#ROOT2024 0:Root[0000, 0]@141..142#ROOT2024
+                  IDENT   value 0:Root[0000, 0]@131..136#ROOT2024
+                  PUNCH   : [alone] 0:Root[0000, 0]@136..137#ROOT2024
+                  IDENT   i16 0:Root[0000, 0]@138..141#ROOT2024
+                PUNCH   - [joint] 0:Root[0000, 0]@143..144#ROOT2024
+                PUNCH   > [alone] 0:Root[0000, 0]@144..145#ROOT2024
+                IDENT   Self 0:Root[0000, 0]@146..150#ROOT2024
+                SUBTREE {} 0:Root[0000, 0]@151..152#ROOT2024 0:Root[0000, 0]@188..189#ROOT2024
+                  IDENT   Self 0:Root[0000, 0]@165..169#ROOT2024
+                  SUBTREE {} 0:Root[0000, 0]@170..171#ROOT2024 0:Root[0000, 0]@178..179#ROOT2024
+                    IDENT   value 0:Root[0000, 0]@172..177#ROOT2024
+              IDENT   Foo 0:Root[0000, 0]@201..204#ROOT2024
+              PUNCH   : [joint] 0:Root[0000, 0]@204..205#ROOT2024
+              PUNCH   : [joint] 0:Root[0000, 0]@205..206#ROOT2024
+              PUNCH   < [joint] 0:Root[0000, 0]@206..207#ROOT2024
+              PUNCH   - [alone] 1:Root[0000, 0]@0..1#ROOT2024
+              LITERAL Integer 1 1:Root[0000, 0]@1..2#ROOT2024
+              PUNCH   > [joint] 0:Root[0000, 0]@211..212#ROOT2024
+              PUNCH   : [joint] 0:Root[0000, 0]@212..213#ROOT2024
+              PUNCH   : [alone] 0:Root[0000, 0]@213..214#ROOT2024
+              IDENT   new 0:Root[0000, 0]@214..217#ROOT2024
+              SUBTREE () 0:Root[0000, 0]@217..218#ROOT2024 0:Root[0000, 0]@222..223#ROOT2024
+                PUNCH   - [alone] 1:Root[0000, 0]@0..1#ROOT2024
+                LITERAL Integer 1 1:Root[0000, 0]@1..2#ROOT2024
+
+            struct Foo<const I:i16>{
+                pub value:i16,
+            }
+            impl <const I:i16>Foo<I>{
+                pub fn new(value:i16) -> Self {
+                    Self {
+                        value
+                    }
+                }
+
+                }
+            Foo::<-1>::new(-1)"#]],
+    );
+}

From 8daad494b11ae5d0e5282be485625687bcf27e37 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Thu, 25 Sep 2025 14:13:26 -0700
Subject: [PATCH 1406/1889] rustdoc: put the toolbar on the all item index

---
 src/librustdoc/html/render/mod.rs          | 7 ++++++-
 src/librustdoc/html/render/write_shared.rs | 9 +++++++--
 2 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index 6d684449b6d2e..bb494de19d9bd 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -601,7 +601,12 @@ impl AllTypes {
         }
 
         fmt::from_fn(|f| {
-            f.write_str("<h1>List of all items</h1>")?;
+            f.write_str(
+                "<div class=\"main-heading\">\
+                    <h1>List of all items</h1>\
+                    <rustdoc-toolbar></rustdoc-toolbar>\
+                </div>",
+            )?;
             // Note: print_entries does not escape the title, because we know the current set of titles
             // doesn't require escaping.
             print_entries(&self.structs, ItemSection::Structs).fmt(f)?;
diff --git a/src/librustdoc/html/render/write_shared.rs b/src/librustdoc/html/render/write_shared.rs
index e37a5246a7684..3a1db805d01cf 100644
--- a/src/librustdoc/html/render/write_shared.rs
+++ b/src/librustdoc/html/render/write_shared.rs
@@ -386,8 +386,13 @@ impl CratesIndexPart {
         let layout = &cx.shared.layout;
         let style_files = &cx.shared.style_files;
         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 content = format!(
+            "<div class=\"main-heading\">\
+                <h1>List of all crates</h1>\
+                <rustdoc-toolbar></rustdoc-toolbar>\
+            </div>\
+            <ul class=\"all-items\">{DELIMITER}</ul>"
+        );
         let template = layout::render(layout, &page, "", content, style_files);
         SortedTemplate::from_template(&template, DELIMITER)
             .expect("Object Replacement Character (U+FFFC) should not appear in the --index-page")

From 0ede3fe48c0d373d3673459218e1b9e7eaa667b8 Mon Sep 17 00:00:00 2001
From: Tropical <42101043+Tropix126@users.noreply.github.com>
Date: Thu, 25 Sep 2025 16:34:20 -0500
Subject: [PATCH 1407/1889] std: fix warning in VEXos stdio module

---
 library/std/src/sys/stdio/vexos.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/std/src/sys/stdio/vexos.rs b/library/std/src/sys/stdio/vexos.rs
index 1f2251c6421d8..9a391feb7a8a1 100644
--- a/library/std/src/sys/stdio/vexos.rs
+++ b/library/std/src/sys/stdio/vexos.rs
@@ -13,7 +13,7 @@ impl Stdin {
 }
 
 impl io::Read for Stdin {
-    fn read(&mut self, mut buf: &mut [u8]) -> io::Result<usize> {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         let mut count = 0;
 
         for out_byte in buf.iter_mut() {

From 9dce3e8556022599c1323cdad6a0d87d6991c8b5 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Thu, 25 Sep 2025 15:16:16 -0700
Subject: [PATCH 1408/1889] rustdoc-search: add descriptive comment to
 space-saving hack

---
 src/librustdoc/html/render/search_index.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/librustdoc/html/render/search_index.rs b/src/librustdoc/html/render/search_index.rs
index 74cf2b1812330..7b21c68d2e949 100644
--- a/src/librustdoc/html/render/search_index.rs
+++ b/src/librustdoc/html/render/search_index.rs
@@ -241,6 +241,9 @@ impl SerializedSearchIndex {
         self.alias_pointers.push(alias_pointer);
         index
     }
+    /// Add potential search result to the database and return the row ID.
+    ///
+    /// The returned ID can be used to attach more data to the search result.
     fn add_entry(&mut self, name: Symbol, entry_data: EntryData, desc: String) -> usize {
         let fqp = if let Some(module_path_index) = entry_data.module_path {
             let mut fqp = self.path_data[module_path_index].as_ref().unwrap().module_path.clone();
@@ -250,6 +253,11 @@ impl SerializedSearchIndex {
         } else {
             vec![name]
         };
+        // If a path with the same name already exists, but no entry does,
+        // we can fill in the entry without having to allocate a new row ID.
+        //
+        // Because paths and entries both share the same index, using the same
+        // ID saves space by making the tree smaller.
         if let Some(&other_path) = self.crate_paths_index.get(&(entry_data.ty, fqp))
             && self.entry_data[other_path].is_none()
             && self.descs[other_path].is_empty()

From 7a9b6d94d41720a206d0e52e4827bac45d9a7bc3 Mon Sep 17 00:00:00 2001
From: Augie Fackler <augie@google.com>
Date: Thu, 25 Sep 2025 18:12:33 -0400
Subject: [PATCH 1409/1889] PassWrapper: update for new PGOOptions args in LLVM
 22

This changed in upstream change a5569b4bd7f8.

@rustbot label llvm-main
---
 compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
index 013d68fa3e485..136b6e9bf50fd 100644
--- a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
@@ -573,21 +573,37 @@ extern "C" LLVMRustResult LLVMRustOptimize(
   if (PGOGenPath) {
     assert(!PGOUsePath && !PGOSampleUsePath);
     PGOOpt = PGOOptions(
+#if LLVM_VERSION_GE(22, 0)
+        PGOGenPath, "", "", "", PGOOptions::IRInstr, PGOOptions::NoCSAction,
+#else
         PGOGenPath, "", "", "", FS, PGOOptions::IRInstr, PGOOptions::NoCSAction,
+#endif
         PGOOptions::ColdFuncOpt::Default, DebugInfoForProfiling);
   } else if (PGOUsePath) {
     assert(!PGOSampleUsePath);
     PGOOpt = PGOOptions(
+#if LLVM_VERSION_GE(22, 0)
+        PGOUsePath, "", "", "", PGOOptions::IRUse, PGOOptions::NoCSAction,
+#else
         PGOUsePath, "", "", "", FS, PGOOptions::IRUse, PGOOptions::NoCSAction,
+#endif
         PGOOptions::ColdFuncOpt::Default, DebugInfoForProfiling);
   } else if (PGOSampleUsePath) {
     PGOOpt =
+#if LLVM_VERSION_GE(22, 0)
+        PGOOptions(PGOSampleUsePath, "", "", "", PGOOptions::SampleUse,
+#else
         PGOOptions(PGOSampleUsePath, "", "", "", FS, PGOOptions::SampleUse,
+#endif
                    PGOOptions::NoCSAction, PGOOptions::ColdFuncOpt::Default,
                    DebugInfoForProfiling);
   } else if (DebugInfoForProfiling) {
     PGOOpt = PGOOptions(
+#if LLVM_VERSION_GE(22, 0)
+        "", "", "", "", PGOOptions::NoAction, PGOOptions::NoCSAction,
+#else
         "", "", "", "", FS, PGOOptions::NoAction, PGOOptions::NoCSAction,
+#endif
         PGOOptions::ColdFuncOpt::Default, DebugInfoForProfiling);
   }
 

From 51ae86dec97f4db86f624f609c41f6bf5e620301 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Thu, 25 Sep 2025 15:23:49 -0700
Subject: [PATCH 1410/1889] rustdoc-search: add test case for all/index.html
 search

---
 tests/rustdoc-gui/search-title.goml    | 12 ++++++++++++
 tests/rustdoc-gui/src/test_docs/lib.rs |  1 +
 2 files changed, 13 insertions(+)

diff --git a/tests/rustdoc-gui/search-title.goml b/tests/rustdoc-gui/search-title.goml
index 83321a05f2bbb..5808ed845a3b1 100644
--- a/tests/rustdoc-gui/search-title.goml
+++ b/tests/rustdoc-gui/search-title.goml
@@ -20,3 +20,15 @@ assert-document-property: {"title": '"another one" Search - Rust'}
 press-key: "Escape"
 
 assert-document-property: {"title": |title|}
+
+// check that all.html does it correctly, too.
+go-to: "file://" + |DOC_PATH| + "/test_docs/all.html"
+assert-document-property: {"title": "List of all items in this crate"}
+call-function: ("perform-search", {"query": "verify"})
+assert-document-property: {"title": '"verify" Search - Rust'}
+
+// check that index.html does it correctly, too.
+go-to: "file://" + |DOC_PATH| + "/index.html"
+assert-document-property: {"title": "Index of crates"}
+call-function: ("perform-search", {"query": "verify"})
+assert-document-property: {"title": '"verify" Search - Rust'}
diff --git a/tests/rustdoc-gui/src/test_docs/lib.rs b/tests/rustdoc-gui/src/test_docs/lib.rs
index 42f2fbd93b1ee..08523d0df2f2e 100644
--- a/tests/rustdoc-gui/src/test_docs/lib.rs
+++ b/tests/rustdoc-gui/src/test_docs/lib.rs
@@ -1,3 +1,4 @@
+//@ compile-flags: --enable-index-page -Z unstable-options
 //! The point of this crate is to be able to have enough different "kinds" of
 //! documentation generated so we can test each different features.
 #![doc(html_playground_url="https://play.rust-lang.org/")]

From 1a37374973f2d57c7c1c18a8371aa99607adfad8 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Sun, 21 Sep 2025 03:46:07 +0000
Subject: [PATCH 1411/1889] JumpThreading: Avoid computing dominators to
 identify loop headers.

---
 .../rustc_mir_transform/src/jump_threading.rs | 40 +++++++++++--------
 1 file changed, 23 insertions(+), 17 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/jump_threading.rs b/compiler/rustc_mir_transform/src/jump_threading.rs
index f9e642e28ebd7..c69660108d9a3 100644
--- a/compiler/rustc_mir_transform/src/jump_threading.rs
+++ b/compiler/rustc_mir_transform/src/jump_threading.rs
@@ -84,7 +84,7 @@ impl<'tcx> crate::MirPass<'tcx> for JumpThreading {
             body,
             arena,
             map: Map::new(tcx, body, Some(MAX_PLACES)),
-            loop_headers: loop_headers(body),
+            maybe_loop_headers: maybe_loop_headers(body),
             opportunities: Vec::new(),
         };
 
@@ -100,7 +100,7 @@ impl<'tcx> crate::MirPass<'tcx> for JumpThreading {
 
         // Verify that we do not thread through a loop header.
         for to in opportunities.iter() {
-            assert!(to.chain.iter().all(|&block| !finder.loop_headers.contains(block)));
+            assert!(to.chain.iter().all(|&block| !finder.maybe_loop_headers.contains(block)));
         }
         OpportunitySet::new(body, opportunities).apply(body);
     }
@@ -124,7 +124,7 @@ struct TOFinder<'a, 'tcx> {
     ecx: InterpCx<'tcx, DummyMachine>,
     body: &'a Body<'tcx>,
     map: Map<'tcx>,
-    loop_headers: DenseBitSet<BasicBlock>,
+    maybe_loop_headers: DenseBitSet<BasicBlock>,
     /// We use an arena to avoid cloning the slices when cloning `state`.
     arena: &'a DroplessArena,
     opportunities: Vec<ThreadingOpportunity>,
@@ -190,7 +190,7 @@ impl<'a, 'tcx> TOFinder<'a, 'tcx> {
     #[instrument(level = "trace", skip(self))]
     fn start_from_switch(&mut self, bb: BasicBlock) {
         let bbdata = &self.body[bb];
-        if bbdata.is_cleanup || self.loop_headers.contains(bb) {
+        if bbdata.is_cleanup || self.maybe_loop_headers.contains(bb) {
             return;
         }
         let Some((discr, targets)) = bbdata.terminator().kind.as_switch() else { return };
@@ -235,7 +235,7 @@ impl<'a, 'tcx> TOFinder<'a, 'tcx> {
         depth: usize,
     ) {
         // Do not thread through loop headers.
-        if self.loop_headers.contains(bb) {
+        if self.maybe_loop_headers.contains(bb) {
             return;
         }
 
@@ -833,20 +833,26 @@ enum Update {
     Decr,
 }
 
-/// Compute the set of loop headers in the given body. We define a loop header as a block which has
-/// at least a predecessor which it dominates. This definition is only correct for reducible CFGs.
-/// But if the CFG is already irreducible, there is no point in trying much harder.
-/// is already irreducible.
-fn loop_headers(body: &Body<'_>) -> DenseBitSet<BasicBlock> {
-    let mut loop_headers = DenseBitSet::new_empty(body.basic_blocks.len());
-    let dominators = body.basic_blocks.dominators();
-    // Only visit reachable blocks.
-    for (bb, bbdata) in traversal::preorder(body) {
+/// Compute the set of loop headers in the given body. A loop header is usually defined as a block
+/// which dominates one of its predecessors. This definition is only correct for reducible CFGs.
+/// However, computing dominators is expensive, so we approximate according to the post-order
+/// traversal order. A loop header for us is a block which is visited after its predecessor in
+/// post-order. This is ok as we mostly need a heuristic.
+fn maybe_loop_headers(body: &Body<'_>) -> DenseBitSet<BasicBlock> {
+    let mut maybe_loop_headers = DenseBitSet::new_empty(body.basic_blocks.len());
+    let mut visited = DenseBitSet::new_empty(body.basic_blocks.len());
+    for (bb, bbdata) in traversal::postorder(body) {
+        let _new = visited.insert(bb);
+        debug_assert!(_new);
+
+        // Post-order means we visit successors before the block for acyclic CFGs.
+        // If the successor is not visited yet, consider it a loop header.
         for succ in bbdata.terminator().successors() {
-            if dominators.dominates(succ, bb) {
-                loop_headers.insert(succ);
+            if !visited.contains(succ) {
+                maybe_loop_headers.insert(succ);
             }
         }
     }
-    loop_headers
+
+    maybe_loop_headers
 }

From 5de617e71f7ab7f70f13381033c09f1c6ad55e0f Mon Sep 17 00:00:00 2001
From: Jules Bertholet <julesbertholet@quoi.xyz>
Date: Thu, 25 Sep 2025 23:57:59 -0400
Subject: [PATCH 1412/1889] Rename ui test items

---
 .../duplicate-bound-err.rs                    | 18 ++--
 .../duplicate-bound-err.stderr                | 24 ++---
 .../associated-type-bounds/duplicate-bound.rs | 90 +++++++++----------
 3 files changed, 66 insertions(+), 66 deletions(-)

diff --git a/tests/ui/associated-type-bounds/duplicate-bound-err.rs b/tests/ui/associated-type-bounds/duplicate-bound-err.rs
index 50db5de7ca768..01cc05f2545f1 100644
--- a/tests/ui/associated-type-bounds/duplicate-bound-err.rs
+++ b/tests/ui/associated-type-bounds/duplicate-bound-err.rs
@@ -5,31 +5,31 @@
 
 use std::iter;
 
-fn frpit1() -> impl Iterator<Item: Copy, Item: Send> {
+fn rpit1() -> impl Iterator<Item: Copy, Item: Send> {
     iter::empty()
     //~^ ERROR type annotations needed
 }
-fn frpit2() -> impl Iterator<Item: Copy, Item: Copy> {
+fn rpit2() -> impl Iterator<Item: Copy, Item: Copy> {
     iter::empty()
     //~^ ERROR type annotations needed
 }
-fn frpit3() -> impl Iterator<Item: 'static, Item: 'static> {
+fn rpit3() -> impl Iterator<Item: 'static, Item: 'static> {
     iter::empty()
     //~^ ERROR type annotations needed
 }
 
-type ETAI1<T: Iterator<Item: Copy, Item: Send>> = impl Copy;
+type Tait1<T: Iterator<Item: Copy, Item: Send>> = impl Copy;
 //~^ ERROR unconstrained opaque type
-type ETAI2<T: Iterator<Item: Copy, Item: Copy>> = impl Copy;
+type Tait2<T: Iterator<Item: Copy, Item: Copy>> = impl Copy;
 //~^ ERROR unconstrained opaque type
-type ETAI3<T: Iterator<Item: 'static, Item: 'static>> = impl Copy;
+type Tait3<T: Iterator<Item: 'static, Item: 'static>> = impl Copy;
 //~^ ERROR unconstrained opaque type
 
-type ETAI4 = impl Iterator<Item: Copy, Item: Send>;
+type Tait4 = impl Iterator<Item: Copy, Item: Send>;
 //~^ ERROR unconstrained opaque type
-type ETAI5 = impl Iterator<Item: Copy, Item: Copy>;
+type Tait5 = impl Iterator<Item: Copy, Item: Copy>;
 //~^ ERROR unconstrained opaque type
-type ETAI6 = impl Iterator<Item: 'static, Item: 'static>;
+type Tait6 = impl Iterator<Item: 'static, Item: 'static>;
 //~^ ERROR unconstrained opaque type
 
 fn mismatch() -> impl Iterator<Item: Copy, Item: Send> {
diff --git a/tests/ui/associated-type-bounds/duplicate-bound-err.stderr b/tests/ui/associated-type-bounds/duplicate-bound-err.stderr
index 6c1dc03676c79..1737d0dc5a385 100644
--- a/tests/ui/associated-type-bounds/duplicate-bound-err.stderr
+++ b/tests/ui/associated-type-bounds/duplicate-bound-err.stderr
@@ -34,50 +34,50 @@ LL |     iter::empty::<T>()
 error: unconstrained opaque type
   --> $DIR/duplicate-bound-err.rs:21:51
    |
-LL | type ETAI1<T: Iterator<Item: Copy, Item: Send>> = impl Copy;
+LL | type Tait1<T: Iterator<Item: Copy, Item: Send>> = impl Copy;
    |                                                   ^^^^^^^^^
    |
-   = note: `ETAI1` must be used in combination with a concrete type within the same crate
+   = note: `Tait1` must be used in combination with a concrete type within the same crate
 
 error: unconstrained opaque type
   --> $DIR/duplicate-bound-err.rs:23:51
    |
-LL | type ETAI2<T: Iterator<Item: Copy, Item: Copy>> = impl Copy;
+LL | type Tait2<T: Iterator<Item: Copy, Item: Copy>> = impl Copy;
    |                                                   ^^^^^^^^^
    |
-   = note: `ETAI2` must be used in combination with a concrete type within the same crate
+   = note: `Tait2` must be used in combination with a concrete type within the same crate
 
 error: unconstrained opaque type
   --> $DIR/duplicate-bound-err.rs:25:57
    |
-LL | type ETAI3<T: Iterator<Item: 'static, Item: 'static>> = impl Copy;
+LL | type Tait3<T: Iterator<Item: 'static, Item: 'static>> = impl Copy;
    |                                                         ^^^^^^^^^
    |
-   = note: `ETAI3` must be used in combination with a concrete type within the same crate
+   = note: `Tait3` must be used in combination with a concrete type within the same crate
 
 error: unconstrained opaque type
   --> $DIR/duplicate-bound-err.rs:28:14
    |
-LL | type ETAI4 = impl Iterator<Item: Copy, Item: Send>;
+LL | type Tait4 = impl Iterator<Item: Copy, Item: Send>;
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: `ETAI4` must be used in combination with a concrete type within the same crate
+   = note: `Tait4` must be used in combination with a concrete type within the same crate
 
 error: unconstrained opaque type
   --> $DIR/duplicate-bound-err.rs:30:14
    |
-LL | type ETAI5 = impl Iterator<Item: Copy, Item: Copy>;
+LL | type Tait5 = impl Iterator<Item: Copy, Item: Copy>;
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: `ETAI5` must be used in combination with a concrete type within the same crate
+   = note: `Tait5` must be used in combination with a concrete type within the same crate
 
 error: unconstrained opaque type
   --> $DIR/duplicate-bound-err.rs:32:14
    |
-LL | type ETAI6 = impl Iterator<Item: 'static, Item: 'static>;
+LL | type Tait6 = impl Iterator<Item: 'static, Item: 'static>;
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: `ETAI6` must be used in combination with a concrete type within the same crate
+   = note: `Tait6` must be used in combination with a concrete type within the same crate
 
 error[E0277]: `*const ()` cannot be sent between threads safely
   --> $DIR/duplicate-bound-err.rs:35:18
diff --git a/tests/ui/associated-type-bounds/duplicate-bound.rs b/tests/ui/associated-type-bounds/duplicate-bound.rs
index 97b2b3905a55e..696710d76f6df 100644
--- a/tests/ui/associated-type-bounds/duplicate-bound.rs
+++ b/tests/ui/associated-type-bounds/duplicate-bound.rs
@@ -7,84 +7,84 @@
 use std::iter;
 use std::mem::ManuallyDrop;
 
-struct SI1<T: Iterator<Item: Copy, Item: Send>> {
+struct Si1<T: Iterator<Item: Copy, Item: Send>> {
     f: T,
 }
-struct SI2<T: Iterator<Item: Copy, Item: Copy>> {
+struct Si2<T: Iterator<Item: Copy, Item: Copy>> {
     f: T,
 }
-struct SI3<T: Iterator<Item: 'static, Item: 'static>> {
+struct Si3<T: Iterator<Item: 'static, Item: 'static>> {
     f: T,
 }
-struct SW1<T>
+struct Sw1<T>
 where
     T: Iterator<Item: Copy, Item: Send>,
 {
     f: T,
 }
-struct SW2<T>
+struct Sw2<T>
 where
     T: Iterator<Item: Copy, Item: Copy>,
 {
     f: T,
 }
-struct SW3<T>
+struct Sw3<T>
 where
     T: Iterator<Item: 'static, Item: 'static>,
 {
     f: T,
 }
 
-enum EI1<T: Iterator<Item: Copy, Item: Send>> {
+enum Ei1<T: Iterator<Item: Copy, Item: Send>> {
     V(T),
 }
-enum EI2<T: Iterator<Item: Copy, Item: Copy>> {
+enum Ei2<T: Iterator<Item: Copy, Item: Copy>> {
     V(T),
 }
-enum EI3<T: Iterator<Item: 'static, Item: 'static>> {
+enum Ei3<T: Iterator<Item: 'static, Item: 'static>> {
     V(T),
 }
-enum EW1<T>
+enum Ew1<T>
 where
     T: Iterator<Item: Copy, Item: Send>,
 {
     V(T),
 }
-enum EW2<T>
+enum Ew2<T>
 where
     T: Iterator<Item: Copy, Item: Copy>,
 {
     V(T),
 }
-enum EW3<T>
+enum Ew3<T>
 where
     T: Iterator<Item: 'static, Item: 'static>,
 {
     V(T),
 }
 
-union UI1<T: Iterator<Item: Copy, Item: Send>> {
+union Ui1<T: Iterator<Item: Copy, Item: Send>> {
     f: ManuallyDrop<T>,
 }
-union UI2<T: Iterator<Item: Copy, Item: Copy>> {
+union Ui2<T: Iterator<Item: Copy, Item: Copy>> {
     f: ManuallyDrop<T>,
 }
-union UI3<T: Iterator<Item: 'static, Item: 'static>> {
+union Ui3<T: Iterator<Item: 'static, Item: 'static>> {
     f: ManuallyDrop<T>,
 }
-union UW1<T>
+union Uw1<T>
 where
     T: Iterator<Item: Copy, Item: Send>,
 {
     f: ManuallyDrop<T>,
 }
-union UW2<T>
+union Uw2<T>
 where
     T: Iterator<Item: Copy, Item: Copy>,
 {
     f: ManuallyDrop<T>,
 }
-union UW3<T>
+union Uw3<T>
 where
     T: Iterator<Item: 'static, Item: 'static>,
 {
@@ -110,78 +110,78 @@ where
 {
 }
 
-fn frpit1() -> impl Iterator<Item: Copy, Item: Send> {
+fn rpit1() -> impl Iterator<Item: Copy, Item: Send> {
     iter::empty::<u32>()
 }
-fn frpit2() -> impl Iterator<Item: Copy, Item: Copy> {
+fn rpit2() -> impl Iterator<Item: Copy, Item: Copy> {
     iter::empty::<u32>()
 }
-fn frpit3() -> impl Iterator<Item: 'static, Item: 'static> {
+fn rpit3() -> impl Iterator<Item: 'static, Item: 'static> {
     iter::empty::<u32>()
 }
-fn fapit1(_: impl Iterator<Item: Copy, Item: Send>) {}
-fn fapit2(_: impl Iterator<Item: Copy, Item: Copy>) {}
-fn fapit3(_: impl Iterator<Item: 'static, Item: 'static>) {}
+fn apit1(_: impl Iterator<Item: Copy, Item: Send>) {}
+fn apit2(_: impl Iterator<Item: Copy, Item: Copy>) {}
+fn apit3(_: impl Iterator<Item: 'static, Item: 'static>) {}
 
-type TAI1<T: Iterator<Item: Copy, Item: Send>> = T;
-type TAI2<T: Iterator<Item: Copy, Item: Copy>> = T;
-type TAI3<T: Iterator<Item: 'static, Item: 'static>> = T;
-type TAW1<T>
+type Tait1<T: Iterator<Item: Copy, Item: Send>> = T;
+type Tait2<T: Iterator<Item: Copy, Item: Copy>> = T;
+type Tait3<T: Iterator<Item: 'static, Item: 'static>> = T;
+type Taw1<T>
 where
     T: Iterator<Item: Copy, Item: Send>,
 = T;
-type TAW2<T>
+type Taw2<T>
 where
     T: Iterator<Item: Copy, Item: Copy>,
 = T;
-type TAW3<T>
+type Taw3<T>
 where
     T: Iterator<Item: 'static, Item: 'static>,
 = T;
 
-trait TRI1<T: Iterator<Item: Copy, Item: Send>> {}
-trait TRI2<T: Iterator<Item: Copy, Item: Copy>> {}
-trait TRI3<T: Iterator<Item: 'static, Item: 'static>> {}
-trait TRS1: Iterator<Item: Copy, Item: Send> {}
-trait TRS2: Iterator<Item: Copy, Item: Copy> {}
-trait TRS3: Iterator<Item: 'static, Item: 'static> {}
-trait TRW1<T>
+trait Tri1<T: Iterator<Item: Copy, Item: Send>> {}
+trait Tri2<T: Iterator<Item: Copy, Item: Copy>> {}
+trait Tri3<T: Iterator<Item: 'static, Item: 'static>> {}
+trait Trs1: Iterator<Item: Copy, Item: Send> {}
+trait Trs2: Iterator<Item: Copy, Item: Copy> {}
+trait Trs3: Iterator<Item: 'static, Item: 'static> {}
+trait Trw1<T>
 where
     T: Iterator<Item: Copy, Item: Send>,
 {
 }
-trait TRW2<T>
+trait Trw2<T>
 where
     T: Iterator<Item: Copy, Item: Copy>,
 {
 }
-trait TRW3<T>
+trait Trw3<T>
 where
     T: Iterator<Item: 'static, Item: 'static>,
 {
 }
-trait TRSW1
+trait Trsw1
 where
     Self: Iterator<Item: Copy, Item: Send>,
 {
 }
-trait TRSW2
+trait Trsw2
 where
     Self: Iterator<Item: Copy, Item: Copy>,
 {
 }
-trait TRSW3
+trait Trsw3
 where
     Self: Iterator<Item: 'static, Item: 'static>,
 {
 }
-trait TRA1 {
+trait Tra1 {
     type A: Iterator<Item: Copy, Item: Send>;
 }
-trait TRA2 {
+trait Tra2 {
     type A: Iterator<Item: Copy, Item: Copy>;
 }
-trait TRA3 {
+trait Tra3 {
     type A: Iterator<Item: 'static, Item: 'static>;
 }
 

From 68c0e97cc6d084424cd2eb9001d63a0989b03655 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fabian=20Gr=C3=BCnbichler?= <f.gruenbichler@proxmox.com>
Date: Thu, 25 Sep 2025 11:34:08 +0200
Subject: [PATCH 1413/1889] re-order normalizations in run-make linker-warning
 test
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

otherwise a buildroot containing `libpanic_abort` would be mangled before being
replaced by the build root placeholder value..

e.g., running `./x.py test --verbose tests/run-make/linker-warning` with rustc
checked out in ~/ext/rustc-libpanic_abort will result in (output slightly shortened):

```
running 1 tests
test [run-make] tests/run-make/linker-warning ... FAILED

failures:

---- [run-make] tests/run-make/linker-warning stdout ----

------rustc stdout------------------------------

------rustc stderr------------------------------

------------------------------------------

error: rmake recipe failed to complete
status: exit status: 101
command: cd "/home/user/ext/rustc-libpanic_abort/build/x86_64-unknown-linux-gnu/test/run-make/linker-warning/rmake_out" && env -u RUSTFLAGS -u __RUSTC_DEBUG_ASSERTIONS_ENABLED -u __STD_DEBUG_ASSERTIONS_ENABLED AR="ar" BUILD_ROOT="/home/user/ext/rustc-libpanic_abort/build/x86_64-unknown-linux-gnu" CC="cc" CC_DEFAULT_FLAGS="-ffunction-sections -fdata-sections -fPIC -m64" CXX="c++" CXX_DEFAULT_FLAGS="-ffunction-sections -fdata-sections -fPIC -m64" HOST_RUSTC_DYLIB_PATH="/home/user/ext/rustc-libpanic_abort/build/x86_64-unknown-linux-gnu/stage1/lib" LD_LIBRARY_PATH="/home/user/ext/rustc-libpanic_abort/build/x86_64-unknown-linux-gnu/bootstrap-tools/x86_64-unknown-linux-gnu/release/deps:/home/user/ext/rustc-libpanic_abort/build/x86_64-unknown-linux-gnu/stage0/lib/rustlib/x86_64-unknown-linux-gnu/lib" LD_LIB_PATH_ENVVAR="LD_LIBRARY_PATH" LLVM_BIN_DIR="/home/user/ext/rustc-libpanic_abort/build/x86_64-unknown-linux-gnu/ci-llvm/bin" LLVM_COMPONENTS="<...>" LLVM_FILECHECK="/home/user/ext/rustc-libpanic_abort/build/x86_64-unknown-linux-gnu/ci-llvm/bin/FileCheck" NODE="/usr/bin/node" PYTHON="/usr/bin/python3" RUSTC="/home/user/ext/rustc-libpanic_abort/build/x86_64-unknown-linux-gnu/stage1/bin/rustc" RUSTDOC="/home/user/ext/rustc-libpanic_abort/build/x86_64-unknown-linux-gnu/stage1/bin/rustdoc" SOURCE_ROOT="/home/user/ext/rustc-libpanic_abort" TARGET="x86_64-unknown-linux-gnu" TARGET_EXE_DYLIB_PATH="/home/user/ext/rustc-libpanic_abort/build/x86_64-unknown-linux-gnu/stage1/lib/rustlib/x86_64-unknown-linux-gnu/lib" "/home/user/ext/rustc-libpanic_abort/build/x86_64-unknown-linux-gnu/test/run-make/linker-warning/rmake"
stdout: none
--- stderr -------------------------------

thread 'main' panicked at /home/user/ext/rustc-libpanic_abort/tests/run-make/linker-warning/rmake.rs:74:14:
test failed: `short-error.txt` is different from `(linker error)`

--- short-error.txt
+++ (linker error)
@@ -1,6 +1,6 @@
 error: linking with `./fake-linker` failed: exit status: 1
   |
-  = note:  "./fake-linker" "-m64" "/symbols.o" "<2 object files omitted>" "-Wl,--as-needed" "-Wl,-Bstatic" "/build-root/test/run-make/linker-warning/rmake_out/{libfoo,libbar}.rlib" "<sysroot>/lib/rustlib/x86_64-unknown-linux-gnu/lib/{libstd-*,libpanic_unwind-*,libobject-*,libmemchr-*,libaddr2line-*,libgimli-*,libcfg_if-*,librustc_demangle-*,libstd_detect-*,libhashbrown-*,librustc_std_workspace_alloc-*,libminiz_oxide-*,libadler2-*,libunwind-*,liblibc-*,librustc_std_workspace_core-*,liballoc-*,libcore-*,libcompiler_builtins-*}.rlib" "-Wl,-Bdynamic" "-lgcc_s" "-lutil" "-lrt" "-lpthread" "-lm" "-ldl" "-lc" "-L" "/raw-dylibs" "-Wl,--eh-frame-hdr" "-Wl,-z,noexecstack" "-L" "/build-root/test/run-make/linker-warning/rmake_out" "-L" "<sysroot>/lib/rustlib/x86_64-unknown-linux-gnu/lib" "-o" "main" "-Wl,--gc-sections" "-pie" "-Wl,-z,relro,-z,now" "-nodefaultlibs" "run_make_error"
+  = note:  "./fake-linker" "-m64" "/symbols.o" "<2 object files omitted>" "-Wl,--as-needed" "-Wl,-Bstatic" "/home/user/ext/rustc-libpanic_unwind/build/x86_64-unknown-linux-gnu/test/run-make/linker-warning/rmake_out/{libfoo,libbar}.rlib" "<sysroot>/lib/rustlib/x86_64-unknown-linux-gnu/lib/{libstd-*,libpanic_unwind-*,libobject-*,libmemchr-*,libaddr2line-*,libgimli-*,libcfg_if-*,librustc_demangle-*,libstd_detect-*,libhashbrown-*,librustc_std_workspace_alloc-*,libminiz_oxide-*,libadler2-*,libunwind-*,liblibc-*,librustc_std_workspace_core-*,liballoc-*,libcore-*,libcompiler_builtins-*}.rlib" "-Wl,-Bdynamic" "-lgcc_s" "-lutil" "-lrt" "-lpthread" "-lm" "-ldl" "-lc" "-L" "/raw-dylibs" "-Wl,--eh-frame-hdr" "-Wl,-z,noexecstack" "-L" "/home/user/ext/rustc-libpanic_unwind/build/x86_64-unknown-linux-gnu/test/run-make/linker-warning/rmake_out" "-L" "<sysroot>/lib/rustlib/x86_64-unknown-linux-gnu/lib" "-o" "main" "-Wl,--gc-sections" "-pie" "-Wl,-z,relro,-z,now" "-nodefaultlibs" "run_make_error"
   = note: some arguments are omitted. use `--verbose` to show all linker arguments
   = note: error: baz

[..]
```

without this fix.

Signed-off-by: Fabian Grünbichler <f.gruenbichler@proxmox.com>
---
 tests/run-make/linker-warning/rmake.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/run-make/linker-warning/rmake.rs b/tests/run-make/linker-warning/rmake.rs
index b0c40dd171d34..a31b08d6c6956 100644
--- a/tests/run-make/linker-warning/rmake.rs
+++ b/tests/run-make/linker-warning/rmake.rs
@@ -61,13 +61,13 @@ fn main() {
         diff()
             .expected_file("short-error.txt")
             .actual_text("(linker error)", out.stderr())
-            .normalize("libpanic_abort", "libpanic_unwind")
             .normalize(
                 regex::escape(
                     run_make_support::build_root().canonicalize().unwrap().to_str().unwrap(),
                 ),
                 "/build-root",
             )
+            .normalize("libpanic_abort", "libpanic_unwind")
             .normalize(r#""[^"]*\/symbols.o""#, "\"/symbols.o\"")
             .normalize(r#""[^"]*\/raw-dylibs""#, "\"/raw-dylibs\"")
             .run();

From 38284d10dc45b3bb2c9aa412dce1e5b1e16c639a Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Tue, 23 Sep 2025 13:18:33 +0800
Subject: [PATCH 1414/1889] Fix expand rest pattern in tuple and slice pattern

Assist: expand_tuple_rest_pattern

Fills fields by replacing rest pattern in tuple patterns.

Example
---
```
fn foo(bar: (char, i32, i32)) {
    let (ch, ..$0) = bar;
}
```
->
```
fn foo(bar: (char, i32, i32)) {
    let (ch, _1, _2) = bar;
}
```

---

Assist: expand_slice_rest_pattern

Fills fields by replacing rest pattern in slice patterns.

Example
---
```
fn foo(bar: [i32; 3]) {
    let [first, ..$0] = bar;
}
```
->
```
fn foo(bar: [i32; 3]) {
    let [first, _1, _2] = bar;
}
```
---
 .../src/handlers/expand_rest_pattern.rs       | 274 ++++++++++++++++--
 .../crates/ide-assists/src/tests/generated.rs |  34 +++
 2 files changed, 289 insertions(+), 19 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/expand_rest_pattern.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/expand_rest_pattern.rs
index 932166adb0a02..b746099e72791 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/expand_rest_pattern.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/expand_rest_pattern.rs
@@ -113,9 +113,7 @@ fn expand_tuple_struct_rest_pattern(
     };
 
     let rest_pat = rest_pat.into();
-    let mut pats = pat.fields();
-    let prefix_count = pats.by_ref().position(|p| p == rest_pat)?;
-    let suffix_count = pats.count();
+    let (prefix_count, suffix_count) = calculate_counts(&rest_pat, pat.fields())?;
 
     if fields.len().saturating_sub(prefix_count).saturating_sub(suffix_count) == 0 {
         cov_mark::hit!(no_missing_fields_tuple_struct);
@@ -141,19 +139,13 @@ fn expand_tuple_struct_rest_pattern(
                 pat.fields()
                     .take(prefix_count)
                     .chain(fields[prefix_count..fields.len() - suffix_count].iter().map(|f| {
-                        make.ident_pat(
-                            false,
-                            false,
-                            match name_gen.for_type(
-                                &f.ty(ctx.sema.db).to_type(ctx.sema.db),
-                                ctx.sema.db,
-                                ctx.edition(),
-                            ) {
-                                Some(name) => make.name(&name),
-                                None => make.name(&format!("_{}", f.index())),
-                            },
+                        gen_unnamed_pat(
+                            ctx,
+                            &make,
+                            &mut name_gen,
+                            &f.ty(ctx.db()).to_type(ctx.sema.db),
+                            f.index(),
                         )
-                        .into()
                     }))
                     .chain(pat.fields().skip(prefix_count + 1)),
             );
@@ -166,6 +158,134 @@ fn expand_tuple_struct_rest_pattern(
     )
 }
 
+// Assist: expand_tuple_rest_pattern
+//
+// Fills fields by replacing rest pattern in tuple patterns.
+//
+// ```
+// fn foo(bar: (char, i32, i32)) {
+//     let (ch, ..$0) = bar;
+// }
+// ```
+// ->
+// ```
+// fn foo(bar: (char, i32, i32)) {
+//     let (ch, _1, _2) = bar;
+// }
+// ```
+fn expand_tuple_rest_pattern(
+    acc: &mut Assists,
+    ctx: &AssistContext<'_>,
+    pat: ast::TuplePat,
+    rest_pat: ast::RestPat,
+) -> Option<()> {
+    let fields = ctx.sema.type_of_pat(&pat.clone().into())?.original.tuple_fields(ctx.db());
+    let len = fields.len();
+
+    let rest_pat = rest_pat.into();
+    let (prefix_count, suffix_count) = calculate_counts(&rest_pat, pat.fields())?;
+
+    if len.saturating_sub(prefix_count).saturating_sub(suffix_count) == 0 {
+        cov_mark::hit!(no_missing_fields_tuple);
+        return None;
+    }
+
+    let old_range = ctx.sema.original_range_opt(pat.syntax())?;
+    if old_range.file_id != ctx.file_id() {
+        return None;
+    }
+
+    acc.add(
+        AssistId::refactor_rewrite("expand_tuple_rest_pattern"),
+        "Fill tuple fields",
+        rest_pat.syntax().text_range(),
+        |builder| {
+            let make = SyntaxFactory::with_mappings();
+            let mut editor = builder.make_editor(rest_pat.syntax());
+
+            let mut name_gen = NameGenerator::new_from_scope_locals(ctx.sema.scope(pat.syntax()));
+            let new_pat = make.tuple_pat(
+                pat.fields()
+                    .take(prefix_count)
+                    .chain(fields[prefix_count..len - suffix_count].iter().enumerate().map(
+                        |(index, ty)| {
+                            gen_unnamed_pat(ctx, &make, &mut name_gen, ty, prefix_count + index)
+                        },
+                    ))
+                    .chain(pat.fields().skip(prefix_count + 1)),
+            );
+
+            editor.replace(pat.syntax(), new_pat.syntax());
+
+            editor.add_mappings(make.finish_with_mappings());
+            builder.add_file_edits(ctx.vfs_file_id(), editor);
+        },
+    )
+}
+
+// Assist: expand_slice_rest_pattern
+//
+// Fills fields by replacing rest pattern in slice patterns.
+//
+// ```
+// fn foo(bar: [i32; 3]) {
+//     let [first, ..$0] = bar;
+// }
+// ```
+// ->
+// ```
+// fn foo(bar: [i32; 3]) {
+//     let [first, _1, _2] = bar;
+// }
+// ```
+fn expand_slice_rest_pattern(
+    acc: &mut Assists,
+    ctx: &AssistContext<'_>,
+    pat: ast::SlicePat,
+    rest_pat: ast::RestPat,
+) -> Option<()> {
+    let (ty, len) = ctx.sema.type_of_pat(&pat.clone().into())?.original.as_array(ctx.db())?;
+
+    let rest_pat = rest_pat.into();
+    let (prefix_count, suffix_count) = calculate_counts(&rest_pat, pat.pats())?;
+
+    if len.saturating_sub(prefix_count).saturating_sub(suffix_count) == 0 {
+        cov_mark::hit!(no_missing_fields_slice);
+        return None;
+    }
+
+    let old_range = ctx.sema.original_range_opt(pat.syntax())?;
+    if old_range.file_id != ctx.file_id() {
+        return None;
+    }
+
+    acc.add(
+        AssistId::refactor_rewrite("expand_slice_rest_pattern"),
+        "Fill slice fields",
+        rest_pat.syntax().text_range(),
+        |builder| {
+            let make = SyntaxFactory::with_mappings();
+            let mut editor = builder.make_editor(rest_pat.syntax());
+
+            let mut name_gen = NameGenerator::new_from_scope_locals(ctx.sema.scope(pat.syntax()));
+            let new_pat = make.slice_pat(
+                pat.pats()
+                    .take(prefix_count)
+                    .chain(
+                        (prefix_count..len - suffix_count)
+                            .map(|index| gen_unnamed_pat(ctx, &make, &mut name_gen, &ty, index)),
+                    )
+                    .chain(pat.pats().skip(prefix_count + 1)),
+            );
+
+            editor.replace(pat.syntax(), new_pat.syntax());
+
+            editor.add_mappings(make.finish_with_mappings());
+            builder.add_file_edits(ctx.vfs_file_id(), editor);
+        },
+    )
+}
+
 pub(crate) fn expand_rest_pattern(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {
     let rest_pat = ctx.find_node_at_offset::<ast::RestPat>()?;
     let parent = rest_pat.syntax().parent()?;
@@ -173,15 +293,40 @@ pub(crate) fn expand_rest_pattern(acc: &mut Assists, ctx: &AssistContext<'_>) ->
         match parent {
             ast::RecordPatFieldList(it) => expand_record_rest_pattern(acc, ctx, it.syntax().parent().and_then(ast::RecordPat::cast)?, rest_pat),
             ast::TupleStructPat(it) => expand_tuple_struct_rest_pattern(acc, ctx, it, rest_pat),
-            // FIXME
-            // ast::TuplePat(it) => (),
-            // FIXME
-            // ast::SlicePat(it) => (),
+            ast::TuplePat(it) => expand_tuple_rest_pattern(acc, ctx, it, rest_pat),
+            ast::SlicePat(it) => expand_slice_rest_pattern(acc, ctx, it, rest_pat),
             _ => None,
         }
     }
 }
 
+fn gen_unnamed_pat(
+    ctx: &AssistContext<'_>,
+    make: &SyntaxFactory,
+    name_gen: &mut NameGenerator,
+    ty: &hir::Type<'_>,
+    index: usize,
+) -> ast::Pat {
+    make.ident_pat(
+        false,
+        false,
+        match name_gen.for_type(ty, ctx.sema.db, ctx.edition()) {
+            Some(name) => make.name(&name),
+            None => make.name(&format!("_{index}")),
+        },
+    )
+    .into()
+}
+
+fn calculate_counts(
+    rest_pat: &ast::Pat,
+    mut pats: ast::AstChildren<ast::Pat>,
+) -> Option<(usize, usize)> {
+    let prefix_count = pats.by_ref().position(|p| p == *rest_pat)?;
+    let suffix_count = pats.count();
+    Some((prefix_count, suffix_count))
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -351,6 +496,79 @@ fn foo(bar: Bar) {
         )
     }
 
+    #[test]
+    fn fill_tuple_with_fields() {
+        check_assist(
+            expand_rest_pattern,
+            r#"
+fn foo(bar: (char, i32, i32)) {
+    let (ch, ..$0) = bar;
+}
+"#,
+            r#"
+fn foo(bar: (char, i32, i32)) {
+    let (ch, _1, _2) = bar;
+}
+"#,
+        );
+        check_assist(
+            expand_rest_pattern,
+            r#"
+fn foo(bar: (char, i32, i32)) {
+    let (ch, ..$0, end) = bar;
+}
+"#,
+            r#"
+fn foo(bar: (char, i32, i32)) {
+    let (ch, _1, end) = bar;
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn fill_array_with_fields() {
+        check_assist(
+            expand_rest_pattern,
+            r#"
+fn foo(bar: [i32; 4]) {
+    let [first, ..$0] = bar;
+}
+"#,
+            r#"
+fn foo(bar: [i32; 4]) {
+    let [first, _1, _2, _3] = bar;
+}
+"#,
+        );
+        check_assist(
+            expand_rest_pattern,
+            r#"
+fn foo(bar: [i32; 4]) {
+    let [first, second, ..$0] = bar;
+}
+"#,
+            r#"
+fn foo(bar: [i32; 4]) {
+    let [first, second, _2, _3] = bar;
+}
+"#,
+        );
+        check_assist(
+            expand_rest_pattern,
+            r#"
+fn foo(bar: [i32; 4]) {
+    let [first, second, ..$0, end] = bar;
+}
+"#,
+            r#"
+fn foo(bar: [i32; 4]) {
+    let [first, second, _2, end] = bar;
+}
+"#,
+        );
+    }
+
     #[test]
     fn fill_fields_struct_generated_by_macro() {
         check_assist(
@@ -486,6 +704,8 @@ fn bar(foo: Foo) {
         // This is still possible even though it's meaningless
         cov_mark::check!(no_missing_fields);
         cov_mark::check!(no_missing_fields_tuple_struct);
+        cov_mark::check!(no_missing_fields_tuple);
+        cov_mark::check!(no_missing_fields_slice);
         check_assist_not_applicable(
             expand_rest_pattern,
             r#"
@@ -523,6 +743,22 @@ struct Bar(Y, Z)
 fn foo(bar: Bar) {
     let Bar(y, ..$0, z) = bar;
 }
+"#,
+        );
+        check_assist_not_applicable(
+            expand_rest_pattern,
+            r#"
+fn foo(bar: (i32, i32)) {
+    let (y, ..$0, z) = bar;
+}
+"#,
+        );
+        check_assist_not_applicable(
+            expand_rest_pattern,
+            r#"
+fn foo(bar: [i32; 2]) {
+    let [y, ..$0, z] = bar;
+}
 "#,
         );
     }
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/tests/generated.rs b/src/tools/rust-analyzer/crates/ide-assists/src/tests/generated.rs
index 71ffaa23fc640..e7f91ff3fbc14 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/tests/generated.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/tests/generated.rs
@@ -1041,6 +1041,40 @@ fn foo(bar: Bar) {
     )
 }
 
+#[test]
+fn doctest_expand_slice_rest_pattern() {
+    check_doc_test(
+        "expand_slice_rest_pattern",
+        r#####"
+fn foo(bar: [i32; 3]) {
+    let [first, ..$0] = bar;
+}
+"#####,
+        r#####"
+fn foo(bar: [i32; 3]) {
+    let [first, _1, _2] = bar;
+}
+"#####,
+    )
+}
+
+#[test]
+fn doctest_expand_tuple_rest_pattern() {
+    check_doc_test(
+        "expand_tuple_rest_pattern",
+        r#####"
+fn foo(bar: (char, i32, i32)) {
+    let (ch, ..$0) = bar;
+}
+"#####,
+        r#####"
+fn foo(bar: (char, i32, i32)) {
+    let (ch, _1, _2) = bar;
+}
+"#####,
+    )
+}
+
 #[test]
 fn doctest_expand_tuple_struct_rest_pattern() {
     check_doc_test(

From aa5a21450a070fdea66a07d3cab3b69e6735c328 Mon Sep 17 00:00:00 2001
From: beepster4096 <19316085+beepster4096@users.noreply.github.com>
Date: Thu, 25 Sep 2025 20:54:54 -0700
Subject: [PATCH 1415/1889] ProjectionElem::Subtype -> CastKind::Subtype

---
 .../src/diagnostics/conflict_errors.rs        |  1 -
 .../rustc_borrowck/src/diagnostics/mod.rs     |  7 +++---
 .../src/diagnostics/mutability_errors.rs      |  1 -
 compiler/rustc_borrowck/src/lib.rs            |  4 ----
 .../rustc_borrowck/src/places_conflict.rs     |  2 --
 compiler/rustc_borrowck/src/prefixes.rs       |  3 ---
 compiler/rustc_borrowck/src/type_check/mod.rs |  9 +++----
 compiler/rustc_codegen_cranelift/src/base.rs  |  4 ++--
 .../src/value_and_place.rs                    |  2 +-
 compiler/rustc_codegen_ssa/src/mir/analyze.rs |  4 ----
 compiler/rustc_codegen_ssa/src/mir/operand.rs |  5 ----
 compiler/rustc_codegen_ssa/src/mir/place.rs   |  1 -
 compiler/rustc_codegen_ssa/src/mir/rvalue.rs  |  8 +++++--
 .../src/check_consts/qualifs.rs               |  1 -
 .../rustc_const_eval/src/interpret/cast.rs    |  2 +-
 .../src/interpret/projection.rs               |  2 --
 compiler/rustc_middle/src/mir/pretty.rs       |  4 ----
 compiler/rustc_middle/src/mir/statement.rs    |  8 ++-----
 compiler/rustc_middle/src/mir/syntax.rs       | 24 +++++++++----------
 compiler/rustc_middle/src/mir/visit.rs        |  6 -----
 .../src/builder/expr/as_place.rs              |  3 +--
 .../src/move_paths/builder.rs                 |  5 +---
 .../src/add_subtyping_projections.rs          |  3 +--
 .../src/dataflow_const_prop.rs                |  2 +-
 compiler/rustc_mir_transform/src/gvn.rs       |  3 +--
 .../src/known_panics_lint.rs                  |  2 +-
 .../rustc_mir_transform/src/promote_consts.rs |  1 -
 compiler/rustc_mir_transform/src/validate.rs  | 24 +++++++------------
 compiler/rustc_public/src/mir/body.rs         | 11 ++-------
 compiler/rustc_public/src/mir/visit.rs        |  2 --
 .../src/unstable/convert/internal.rs          |  3 ---
 .../src/unstable/convert/stable/mir.rs        |  2 +-
 32 files changed, 47 insertions(+), 112 deletions(-)

diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
index 7e20a5133e07f..a5b16b508388f 100644
--- a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
@@ -3974,7 +3974,6 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                         }
                         ProjectionElem::ConstantIndex { .. }
                         | ProjectionElem::Subslice { .. }
-                        | ProjectionElem::Subtype(_)
                         | ProjectionElem::Index(_)
                         | ProjectionElem::UnwrapUnsafeBinder(_) => kind,
                     },
diff --git a/compiler/rustc_borrowck/src/diagnostics/mod.rs b/compiler/rustc_borrowck/src/diagnostics/mod.rs
index 5642cdf87fded..e13c1c712d8d7 100644
--- a/compiler/rustc_borrowck/src/diagnostics/mod.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/mod.rs
@@ -402,7 +402,6 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                 ProjectionElem::Downcast(..) if opt.including_downcast => return None,
                 ProjectionElem::Downcast(..) => (),
                 ProjectionElem::OpaqueCast(..) => (),
-                ProjectionElem::Subtype(..) => (),
                 ProjectionElem::UnwrapUnsafeBinder(_) => (),
                 ProjectionElem::Field(field, _ty) => {
                     // FIXME(project-rfc_2229#36): print capture precisely here.
@@ -484,9 +483,9 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                     PlaceRef { local, projection: proj_base }.ty(self.body, self.infcx.tcx)
                 }
                 ProjectionElem::Downcast(..) => place.ty(self.body, self.infcx.tcx),
-                ProjectionElem::Subtype(ty)
-                | ProjectionElem::OpaqueCast(ty)
-                | ProjectionElem::UnwrapUnsafeBinder(ty) => PlaceTy::from_ty(*ty),
+                ProjectionElem::OpaqueCast(ty) | ProjectionElem::UnwrapUnsafeBinder(ty) => {
+                    PlaceTy::from_ty(*ty)
+                }
                 ProjectionElem::Field(_, field_type) => PlaceTy::from_ty(*field_type),
             },
         };
diff --git a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
index 6d69040c711d9..727cf19cd8bb3 100644
--- a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
@@ -192,7 +192,6 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                     [
                         ..,
                         ProjectionElem::Index(_)
-                        | ProjectionElem::Subtype(_)
                         | ProjectionElem::ConstantIndex { .. }
                         | ProjectionElem::OpaqueCast { .. }
                         | ProjectionElem::Subslice { .. }
diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs
index 4c380ddcf7084..cc27b9e5dde61 100644
--- a/compiler/rustc_borrowck/src/lib.rs
+++ b/compiler/rustc_borrowck/src/lib.rs
@@ -1989,10 +1989,8 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                 },
                 // `OpaqueCast`: only transmutes the type, so no moves there.
                 // `Downcast`  : only changes information about a `Place` without moving.
-                // `Subtype`   : only transmutes the type, so no moves.
                 // So it's safe to skip these.
                 ProjectionElem::OpaqueCast(_)
-                | ProjectionElem::Subtype(_)
                 | ProjectionElem::Downcast(_, _)
                 | ProjectionElem::UnwrapUnsafeBinder(_) => (),
             }
@@ -2218,7 +2216,6 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
         for (place_base, elem) in place.iter_projections().rev() {
             match elem {
                 ProjectionElem::Index(_/*operand*/) |
-                ProjectionElem::Subtype(_) |
                 ProjectionElem::OpaqueCast(_) |
                 ProjectionElem::ConstantIndex { .. } |
                 // assigning to P[i] requires P to be valid.
@@ -2610,7 +2607,6 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                     | ProjectionElem::Index(..)
                     | ProjectionElem::ConstantIndex { .. }
                     | ProjectionElem::Subslice { .. }
-                    | ProjectionElem::Subtype(..)
                     | ProjectionElem::OpaqueCast { .. }
                     | ProjectionElem::Downcast(..)
                     | ProjectionElem::UnwrapUnsafeBinder(_) => {
diff --git a/compiler/rustc_borrowck/src/places_conflict.rs b/compiler/rustc_borrowck/src/places_conflict.rs
index cf3e82426e8a0..60676ac6b8644 100644
--- a/compiler/rustc_borrowck/src/places_conflict.rs
+++ b/compiler/rustc_borrowck/src/places_conflict.rs
@@ -249,7 +249,6 @@ fn place_components_conflict<'tcx>(
                 | (ProjectionElem::ConstantIndex { .. }, _, _)
                 | (ProjectionElem::Subslice { .. }, _, _)
                 | (ProjectionElem::OpaqueCast { .. }, _, _)
-                | (ProjectionElem::Subtype(_), _, _)
                 | (ProjectionElem::Downcast { .. }, _, _)
                 | (ProjectionElem::UnwrapUnsafeBinder(_), _, _) => {
                     // Recursive case. This can still be disjoint on a
@@ -510,7 +509,6 @@ fn place_projection_conflict<'tcx>(
             | ProjectionElem::Field(..)
             | ProjectionElem::Index(..)
             | ProjectionElem::ConstantIndex { .. }
-            | ProjectionElem::Subtype(_)
             | ProjectionElem::OpaqueCast { .. }
             | ProjectionElem::Subslice { .. }
             | ProjectionElem::Downcast(..),
diff --git a/compiler/rustc_borrowck/src/prefixes.rs b/compiler/rustc_borrowck/src/prefixes.rs
index 83cca38a5c090..9e51264d8edcb 100644
--- a/compiler/rustc_borrowck/src/prefixes.rs
+++ b/compiler/rustc_borrowck/src/prefixes.rs
@@ -77,9 +77,6 @@ impl<'tcx> Iterator for Prefixes<'tcx> {
                         | ProjectionElem::Index(_) => {
                             cursor = cursor_base;
                         }
-                        ProjectionElem::Subtype(..) => {
-                            panic!("Subtype projection is not allowed before borrow check")
-                        }
                         ProjectionElem::Deref => {
                             match self.kind {
                                 PrefixSet::Shallow => {
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
index 606d3d95d9e65..781fb5ba113ab 100644
--- a/compiler/rustc_borrowck/src/type_check/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -1558,6 +1558,9 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                             ),
                         }
                     }
+                    CastKind::Subtype => {
+                        bug!("CastKind::Subtype shouldn't exist in borrowck")
+                    }
                 }
             }
 
@@ -1882,9 +1885,6 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                 )
                 .unwrap();
             }
-            ProjectionElem::Subtype(_) => {
-                bug!("ProjectionElem::Subtype shouldn't exist in borrowck")
-            }
         }
     }
 }
@@ -2412,9 +2412,6 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                 | ProjectionElem::UnwrapUnsafeBinder(_) => {
                     // other field access
                 }
-                ProjectionElem::Subtype(_) => {
-                    bug!("ProjectionElem::Subtype shouldn't exist in borrowck")
-                }
             }
         }
     }
diff --git a/compiler/rustc_codegen_cranelift/src/base.rs b/compiler/rustc_codegen_cranelift/src/base.rs
index 41e11e1de6163..a2f844642f85e 100644
--- a/compiler/rustc_codegen_cranelift/src/base.rs
+++ b/compiler/rustc_codegen_cranelift/src/base.rs
@@ -789,7 +789,7 @@ fn codegen_stmt<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, cur_block: Block, stmt:
                     let operand = codegen_operand(fx, operand);
                     crate::unsize::coerce_unsized_into(fx, operand, lval);
                 }
-                Rvalue::Cast(CastKind::Transmute, ref operand, _to_ty) => {
+                Rvalue::Cast(CastKind::Transmute | CastKind::Subtype, ref operand, _to_ty) => {
                     let operand = codegen_operand(fx, operand);
                     lval.write_cvalue_transmute(fx, operand);
                 }
@@ -996,7 +996,7 @@ pub(crate) fn codegen_place<'tcx>(
                 cplace = cplace.place_deref(fx);
             }
             PlaceElem::OpaqueCast(ty) => bug!("encountered OpaqueCast({ty}) in codegen"),
-            PlaceElem::Subtype(ty) | PlaceElem::UnwrapUnsafeBinder(ty) => {
+            PlaceElem::UnwrapUnsafeBinder(ty) => {
                 cplace = cplace.place_transmute_type(fx, fx.monomorphize(ty));
             }
             PlaceElem::Field(field, _ty) => {
diff --git a/compiler/rustc_codegen_cranelift/src/value_and_place.rs b/compiler/rustc_codegen_cranelift/src/value_and_place.rs
index 4519fa1a270e4..25bba48a9e3af 100644
--- a/compiler/rustc_codegen_cranelift/src/value_and_place.rs
+++ b/compiler/rustc_codegen_cranelift/src/value_and_place.rs
@@ -660,7 +660,7 @@ impl<'tcx> CPlace<'tcx> {
         }
     }
 
-    /// Used for `ProjectionElem::Subtype`, `ty` has to be monomorphized before
+    /// Used for `ProjectionElem::UnwrapUnsafeBinder`, `ty` has to be monomorphized before
     /// passed on.
     pub(crate) fn place_transmute_type(
         self,
diff --git a/compiler/rustc_codegen_ssa/src/mir/analyze.rs b/compiler/rustc_codegen_ssa/src/mir/analyze.rs
index c2c023af090a5..45bc545194682 100644
--- a/compiler/rustc_codegen_ssa/src/mir/analyze.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/analyze.rs
@@ -150,10 +150,6 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'b, 'tcx>> LocalAnalyzer<'a, 'b, 'tcx, Bx>
                     {
                         layout.for_variant(self.fx.cx, vidx)
                     }
-                    mir::PlaceElem::Subtype(subtype_ty) => {
-                        let subtype_ty = self.fx.monomorphize(subtype_ty);
-                        self.fx.cx.layout_of(subtype_ty)
-                    }
                     _ => {
                         self.locals[place_ref.local] = LocalKind::Memory;
                         return;
diff --git a/compiler/rustc_codegen_ssa/src/mir/operand.rs b/compiler/rustc_codegen_ssa/src/mir/operand.rs
index d851c3329802c..5f7f87fc69206 100644
--- a/compiler/rustc_codegen_ssa/src/mir/operand.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/operand.rs
@@ -956,11 +956,6 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                             let layout = o.layout.for_variant(bx.cx(), vidx);
                             o = OperandRef { val: o.val, layout }
                         }
-                        mir::PlaceElem::Subtype(subtype_ty) => {
-                            let subtype_ty = self.monomorphize(subtype_ty);
-                            let layout = self.cx.layout_of(subtype_ty);
-                            o = OperandRef { val: o.val, layout }
-                        }
                         _ => return None,
                     }
                 }
diff --git a/compiler/rustc_codegen_ssa/src/mir/place.rs b/compiler/rustc_codegen_ssa/src/mir/place.rs
index 0090be9fdef06..50f56f913a51e 100644
--- a/compiler/rustc_codegen_ssa/src/mir/place.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/place.rs
@@ -347,7 +347,6 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 mir::ProjectionElem::OpaqueCast(ty) => {
                     bug!("encountered OpaqueCast({ty}) in codegen")
                 }
-                mir::ProjectionElem::Subtype(ty) => cg_base.project_type(bx, self.monomorphize(ty)),
                 mir::ProjectionElem::UnwrapUnsafeBinder(ty) => {
                     cg_base.project_type(bx, self.monomorphize(ty))
                 }
diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
index 2602bf82095c5..69478d078cc05 100644
--- a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -86,7 +86,11 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 }
             }
 
-            mir::Rvalue::Cast(mir::CastKind::Transmute, ref operand, _ty) => {
+            mir::Rvalue::Cast(
+                mir::CastKind::Transmute | mir::CastKind::Subtype,
+                ref operand,
+                _ty,
+            ) => {
                 let src = self.codegen_operand(bx, operand);
                 self.codegen_transmute(bx, src, dest);
             }
@@ -486,7 +490,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                                 bug!("Unsupported cast of {operand:?} to {cast:?}");
                             })
                     }
-                    mir::CastKind::Transmute => {
+                    mir::CastKind::Transmute | mir::CastKind::Subtype => {
                         self.codegen_transmute_operand(bx, operand, cast)
                     }
                 };
diff --git a/compiler/rustc_const_eval/src/check_consts/qualifs.rs b/compiler/rustc_const_eval/src/check_consts/qualifs.rs
index 34d1fdd8c8694..8a6827bca2bd6 100644
--- a/compiler/rustc_const_eval/src/check_consts/qualifs.rs
+++ b/compiler/rustc_const_eval/src/check_consts/qualifs.rs
@@ -293,7 +293,6 @@ where
             ProjectionElem::Index(index) if in_local(index) => return true,
 
             ProjectionElem::Deref
-            | ProjectionElem::Subtype(_)
             | ProjectionElem::Field(_, _)
             | ProjectionElem::OpaqueCast(_)
             | ProjectionElem::ConstantIndex { .. }
diff --git a/compiler/rustc_const_eval/src/interpret/cast.rs b/compiler/rustc_const_eval/src/interpret/cast.rs
index 0075740e03178..b058d4b8ad446 100644
--- a/compiler/rustc_const_eval/src/interpret/cast.rs
+++ b/compiler/rustc_const_eval/src/interpret/cast.rs
@@ -133,7 +133,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 }
             }
 
-            CastKind::Transmute => {
+            CastKind::Transmute | CastKind::Subtype => {
                 assert!(src.layout.is_sized());
                 assert!(dest.layout.is_sized());
                 assert_eq!(cast_ty, dest.layout.ty); // we otherwise ignore `cast_ty` enirely...
diff --git a/compiler/rustc_const_eval/src/interpret/projection.rs b/compiler/rustc_const_eval/src/interpret/projection.rs
index d05871bfc773c..2fd1657f6ba3a 100644
--- a/compiler/rustc_const_eval/src/interpret/projection.rs
+++ b/compiler/rustc_const_eval/src/interpret/projection.rs
@@ -395,8 +395,6 @@ where
                 span_bug!(self.cur_span(), "OpaqueCast({ty}) encountered after borrowck")
             }
             UnwrapUnsafeBinder(target) => base.transmute(self.layout_of(target)?, self)?,
-            // We don't want anything happening here, this is here as a dummy.
-            Subtype(_) => base.transmute(base.layout(), self)?,
             Field(field, _) => self.project_field(base, field)?,
             Downcast(_, variant) => self.project_downcast(base, variant)?,
             Deref => self.deref_pointer(&base.to_op(self)?)?.into(),
diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
index 96148fd5b9269..350d75c2ee772 100644
--- a/compiler/rustc_middle/src/mir/pretty.rs
+++ b/compiler/rustc_middle/src/mir/pretty.rs
@@ -1274,7 +1274,6 @@ fn pre_fmt_projection(projection: &[PlaceElem<'_>], fmt: &mut Formatter<'_>) ->
     for &elem in projection.iter().rev() {
         match elem {
             ProjectionElem::OpaqueCast(_)
-            | ProjectionElem::Subtype(_)
             | ProjectionElem::Downcast(_, _)
             | ProjectionElem::Field(_, _) => {
                 write!(fmt, "(")?;
@@ -1300,9 +1299,6 @@ fn post_fmt_projection(projection: &[PlaceElem<'_>], fmt: &mut Formatter<'_>) ->
             ProjectionElem::OpaqueCast(ty) => {
                 write!(fmt, " as {ty})")?;
             }
-            ProjectionElem::Subtype(ty) => {
-                write!(fmt, " as subtype {ty})")?;
-            }
             ProjectionElem::Downcast(Some(name), _index) => {
                 write!(fmt, " as {name})")?;
             }
diff --git a/compiler/rustc_middle/src/mir/statement.rs b/compiler/rustc_middle/src/mir/statement.rs
index 28294b47e90f2..e009fe05b53e6 100644
--- a/compiler/rustc_middle/src/mir/statement.rs
+++ b/compiler/rustc_middle/src/mir/statement.rs
@@ -222,7 +222,6 @@ impl<'tcx> PlaceTy<'tcx> {
                 fty,
             )),
             ProjectionElem::OpaqueCast(ty) => PlaceTy::from_ty(handle_opaque_cast_and_subtype(ty)),
-            ProjectionElem::Subtype(ty) => PlaceTy::from_ty(handle_opaque_cast_and_subtype(ty)),
 
             // FIXME(unsafe_binders): Rename `handle_opaque_cast_and_subtype` to be more general.
             ProjectionElem::UnwrapUnsafeBinder(ty) => {
@@ -244,7 +243,6 @@ impl<V, T> ProjectionElem<V, T> {
             Self::Field(_, _)
             | Self::Index(_)
             | Self::OpaqueCast(_)
-            | Self::Subtype(_)
             | Self::ConstantIndex { .. }
             | Self::Subslice { .. }
             | Self::Downcast(_, _)
@@ -259,7 +257,6 @@ impl<V, T> ProjectionElem<V, T> {
             Self::Deref | Self::Index(_) => false,
             Self::Field(_, _)
             | Self::OpaqueCast(_)
-            | Self::Subtype(_)
             | Self::ConstantIndex { .. }
             | Self::Subslice { .. }
             | Self::Downcast(_, _)
@@ -286,7 +283,6 @@ impl<V, T> ProjectionElem<V, T> {
             | Self::Field(_, _) => true,
             Self::ConstantIndex { from_end: true, .. }
             | Self::Index(_)
-            | Self::Subtype(_)
             | Self::OpaqueCast(_)
             | Self::Subslice { .. } => false,
 
@@ -319,7 +315,6 @@ impl<V, T> ProjectionElem<V, T> {
                 ProjectionElem::Subslice { from, to, from_end }
             }
             ProjectionElem::OpaqueCast(ty) => ProjectionElem::OpaqueCast(t(ty)),
-            ProjectionElem::Subtype(ty) => ProjectionElem::Subtype(t(ty)),
             ProjectionElem::UnwrapUnsafeBinder(ty) => ProjectionElem::UnwrapUnsafeBinder(t(ty)),
             ProjectionElem::Index(val) => ProjectionElem::Index(v(val)?),
         })
@@ -706,7 +701,8 @@ impl<'tcx> Rvalue<'tcx> {
                 | CastKind::PtrToPtr
                 | CastKind::PointerCoercion(_, _)
                 | CastKind::PointerWithExposedProvenance
-                | CastKind::Transmute,
+                | CastKind::Transmute
+                | CastKind::Subtype,
                 _,
                 _,
             )
diff --git a/compiler/rustc_middle/src/mir/syntax.rs b/compiler/rustc_middle/src/mir/syntax.rs
index e6c8512564edc..a823c365394f7 100644
--- a/compiler/rustc_middle/src/mir/syntax.rs
+++ b/compiler/rustc_middle/src/mir/syntax.rs
@@ -1275,18 +1275,6 @@ pub enum ProjectionElem<V, T> {
     /// A transmute from an unsafe binder to the type that it wraps. This is a projection
     /// of a place, so it doesn't necessarily constitute a move out of the binder.
     UnwrapUnsafeBinder(T),
-
-    /// A `Subtype(T)` projection is applied to any `StatementKind::Assign` where
-    /// type of lvalue doesn't match the type of rvalue, the primary goal is making subtyping
-    /// explicit during optimizations and codegen.
-    ///
-    /// This projection doesn't impact the runtime behavior of the program except for potentially changing
-    /// some type metadata of the interpreter or codegen backend.
-    ///
-    /// This goal is achieved with mir_transform pass `Subtyper`, which runs right after
-    /// borrowchecker, as we only care about subtyping that can affect trait selection and
-    /// `TypeId`.
-    Subtype(T),
 }
 
 /// Alias for projections as they appear in places, where the base is a place
@@ -1513,6 +1501,18 @@ pub enum CastKind {
     /// MIR is well-formed if the input and output types have different sizes,
     /// but running a transmute between differently-sized types is UB.
     Transmute,
+
+    /// A `Subtype` cast is applied to any `StatementKind::Assign` where
+    /// type of lvalue doesn't match the type of rvalue, the primary goal is making subtyping
+    /// explicit during optimizations and codegen.
+    ///
+    /// This cast doesn't impact the runtime behavior of the program except for potentially changing
+    /// some type metadata of the interpreter or codegen backend.
+    ///
+    /// This goal is achieved with mir_transform pass `Subtyper`, which runs right after
+    /// borrowchecker, as we only care about subtyping that can affect trait selection and
+    /// `TypeId`.
+    Subtype,
 }
 
 /// Represents how a [`CastKind::PointerCoercion`] was constructed.
diff --git a/compiler/rustc_middle/src/mir/visit.rs b/compiler/rustc_middle/src/mir/visit.rs
index 81df239dee42d..f392347780051 100644
--- a/compiler/rustc_middle/src/mir/visit.rs
+++ b/compiler/rustc_middle/src/mir/visit.rs
@@ -1166,11 +1166,6 @@ macro_rules! visit_place_fns {
                     self.visit_ty(&mut new_ty, TyContext::Location(location));
                     if ty != new_ty { Some(PlaceElem::OpaqueCast(new_ty)) } else { None }
                 }
-                PlaceElem::Subtype(ty) => {
-                    let mut new_ty = ty;
-                    self.visit_ty(&mut new_ty, TyContext::Location(location));
-                    if ty != new_ty { Some(PlaceElem::Subtype(new_ty)) } else { None }
-                }
                 PlaceElem::UnwrapUnsafeBinder(ty) => {
                     let mut new_ty = ty;
                     self.visit_ty(&mut new_ty, TyContext::Location(location));
@@ -1244,7 +1239,6 @@ macro_rules! visit_place_fns {
         ) {
             match elem {
                 ProjectionElem::OpaqueCast(ty)
-                | ProjectionElem::Subtype(ty)
                 | ProjectionElem::Field(_, ty)
                 | ProjectionElem::UnwrapUnsafeBinder(ty) => {
                     self.visit_ty(ty, TyContext::Location(location));
diff --git a/compiler/rustc_mir_build/src/builder/expr/as_place.rs b/compiler/rustc_mir_build/src/builder/expr/as_place.rs
index 5a6bd2f413c2d..5e7a57d51a9ca 100644
--- a/compiler/rustc_mir_build/src/builder/expr/as_place.rs
+++ b/compiler/rustc_mir_build/src/builder/expr/as_place.rs
@@ -103,7 +103,7 @@ fn convert_to_hir_projections_and_truncate_for_capture(
             }
             ProjectionElem::UnwrapUnsafeBinder(_) => HirProjectionKind::UnwrapUnsafeBinder,
             // These do not affect anything, they just make sure we know the right type.
-            ProjectionElem::OpaqueCast(_) | ProjectionElem::Subtype(..) => continue,
+            ProjectionElem::OpaqueCast(_) => continue,
             ProjectionElem::Index(..)
             | ProjectionElem::ConstantIndex { .. }
             | ProjectionElem::Subslice { .. } => {
@@ -802,7 +802,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     ProjectionElem::Field(..)
                     | ProjectionElem::Downcast(..)
                     | ProjectionElem::OpaqueCast(..)
-                    | ProjectionElem::Subtype(..)
                     | ProjectionElem::ConstantIndex { .. }
                     | ProjectionElem::Subslice { .. }
                     | ProjectionElem::UnwrapUnsafeBinder(_) => (),
diff --git a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
index 72d4cd72c2bcf..434f106302f5d 100644
--- a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
+++ b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
@@ -227,11 +227,8 @@ impl<'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> MoveDataBuilder<'a, 'tcx, F> {
                 ProjectionElem::UnwrapUnsafeBinder(_) => {}
                 // `OpaqueCast`:Only transmutes the type, so no moves there.
                 // `Downcast`  :Only changes information about a `Place` without moving.
-                // `Subtype`   :Only transmutes the type, so moves.
                 // So it's safe to skip these.
-                ProjectionElem::OpaqueCast(_)
-                | ProjectionElem::Subtype(_)
-                | ProjectionElem::Downcast(_, _) => (),
+                ProjectionElem::OpaqueCast(_) | ProjectionElem::Downcast(_, _) => (),
             }
             let elem_ty = PlaceTy::from_ty(place_ty).projection_ty(tcx, elem).ty;
             if !(self.filter)(elem_ty) {
diff --git a/compiler/rustc_mir_transform/src/add_subtyping_projections.rs b/compiler/rustc_mir_transform/src/add_subtyping_projections.rs
index be4f84d64d03f..a6a60fddf9097 100644
--- a/compiler/rustc_mir_transform/src/add_subtyping_projections.rs
+++ b/compiler/rustc_mir_transform/src/add_subtyping_projections.rs
@@ -40,8 +40,7 @@ impl<'a, 'tcx> MutVisitor<'tcx> for SubTypeChecker<'a, 'tcx> {
                 .new_temp(rval_ty, self.local_decls[place.as_ref().local].source_info.span);
             let new_place = Place::from(temp);
             self.patcher.add_assign(location, new_place, rvalue.clone());
-            let subtyped = new_place.project_deeper(&[ProjectionElem::Subtype(place_ty)], self.tcx);
-            *rvalue = Rvalue::Use(Operand::Move(subtyped));
+            *rvalue = Rvalue::Cast(CastKind::Subtype, Operand::Move(new_place), place_ty);
         }
     }
 }
diff --git a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
index 5c984984d3cc3..d250cdea7e805 100644
--- a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
+++ b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
@@ -440,7 +440,7 @@ impl<'a, 'tcx> ConstAnalysis<'a, 'tcx> {
                     FlatSet::Top => FlatSet::Top,
                 }
             }
-            Rvalue::Cast(CastKind::Transmute, operand, _) => {
+            Rvalue::Cast(CastKind::Transmute | CastKind::Subtype, operand, _) => {
                 match self.eval_operand(operand, state) {
                     FlatSet::Elem(op) => self.wrap_immediate(*op),
                     FlatSet::Bottom => FlatSet::Bottom,
diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index ebec3d125003d..eb59ae830ae13 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -656,7 +656,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                     let res = self.ecx.float_to_float_or_int(&value, ty).discard_err()?;
                     res.into()
                 }
-                CastKind::Transmute => {
+                CastKind::Transmute | CastKind::Subtype => {
                     let value = self.evaluated[value].as_ref()?;
                     // `offset` for immediates generally only supports projections that match the
                     // type of the immediate. However, as a HACK, we exploit that it can also do
@@ -788,7 +788,6 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                 ProjectionElem::Subslice { from, to, from_end }
             }
             ProjectionElem::OpaqueCast(_) => ProjectionElem::OpaqueCast(()),
-            ProjectionElem::Subtype(_) => ProjectionElem::Subtype(()),
             ProjectionElem::UnwrapUnsafeBinder(_) => ProjectionElem::UnwrapUnsafeBinder(()),
         };
 
diff --git a/compiler/rustc_mir_transform/src/known_panics_lint.rs b/compiler/rustc_mir_transform/src/known_panics_lint.rs
index aaacc5866a2ae..0686dca9962d6 100644
--- a/compiler/rustc_mir_transform/src/known_panics_lint.rs
+++ b/compiler/rustc_mir_transform/src/known_panics_lint.rs
@@ -637,7 +637,7 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
                     let res = self.ecx.float_to_float_or_int(&value, to).discard_err()?;
                     res.into()
                 }
-                CastKind::Transmute => {
+                CastKind::Transmute | CastKind::Subtype => {
                     let value = self.eval_operand(value)?;
                     let to = self.ecx.layout_of(to).ok()?;
                     // `offset` for immediates only supports scalar/scalar-pair ABIs,
diff --git a/compiler/rustc_mir_transform/src/promote_consts.rs b/compiler/rustc_mir_transform/src/promote_consts.rs
index a0b0c8c990f33..48ddf5a1bcabb 100644
--- a/compiler/rustc_mir_transform/src/promote_consts.rs
+++ b/compiler/rustc_mir_transform/src/promote_consts.rs
@@ -292,7 +292,6 @@ impl<'tcx> Validator<'_, 'tcx> {
         match elem {
             // Recurse directly.
             ProjectionElem::ConstantIndex { .. }
-            | ProjectionElem::Subtype(_)
             | ProjectionElem::Subslice { .. }
             | ProjectionElem::UnwrapUnsafeBinder(_) => {}
 
diff --git a/compiler/rustc_mir_transform/src/validate.rs b/compiler/rustc_mir_transform/src/validate.rs
index c8a9a88dc3fe3..cbabb982df8b8 100644
--- a/compiler/rustc_mir_transform/src/validate.rs
+++ b/compiler/rustc_mir_transform/src/validate.rs
@@ -814,22 +814,6 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                     }
                 }
             }
-            ProjectionElem::Subtype(ty) => {
-                if !util::sub_types(
-                    self.tcx,
-                    self.typing_env,
-                    ty,
-                    place_ref.ty(&self.body.local_decls, self.tcx).ty,
-                ) {
-                    self.fail(
-                        location,
-                        format!(
-                            "Failed subtyping {ty} and {}",
-                            place_ref.ty(&self.body.local_decls, self.tcx).ty
-                        ),
-                    )
-                }
-            }
             ProjectionElem::UnwrapUnsafeBinder(unwrapped_ty) => {
                 let binder_ty = place_ref.ty(&self.body.local_decls, self.tcx);
                 let ty::UnsafeBinder(binder_ty) = *binder_ty.ty.kind() else {
@@ -1331,6 +1315,14 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                             );
                         }
                     }
+                    CastKind::Subtype => {
+                        if !util::sub_types(self.tcx, self.typing_env, op_ty, *target_type) {
+                            self.fail(
+                                location,
+                                format!("Failed subtyping {op_ty} and {target_type}"),
+                            )
+                        }
+                    }
                 }
             }
             Rvalue::NullaryOp(NullOp::OffsetOf(indices), container) => {
diff --git a/compiler/rustc_public/src/mir/body.rs b/compiler/rustc_public/src/mir/body.rs
index 276adacd99e06..7bd06fee721ce 100644
--- a/compiler/rustc_public/src/mir/body.rs
+++ b/compiler/rustc_public/src/mir/body.rs
@@ -836,14 +836,6 @@ pub enum ProjectionElem {
     /// Like an explicit cast from an opaque type to a concrete type, but without
     /// requiring an intermediate variable.
     OpaqueCast(Ty),
-
-    /// A `Subtype(T)` projection is applied to any `StatementKind::Assign` where
-    /// type of lvalue doesn't match the type of rvalue, the primary goal is making subtyping
-    /// explicit during optimizations and codegen.
-    ///
-    /// This projection doesn't impact the runtime behavior of the program except for potentially changing
-    /// some type metadata of the interpreter or codegen backend.
-    Subtype(Ty),
 }
 
 #[derive(Clone, Debug, Eq, PartialEq, Serialize)]
@@ -1028,6 +1020,7 @@ pub enum CastKind {
     PtrToPtr,
     FnPtrToPtr,
     Transmute,
+    Subtype,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq, Hash, Serialize)]
@@ -1089,7 +1082,7 @@ impl ProjectionElem {
                 Self::subslice_ty(ty, *from, *to, *from_end)
             }
             ProjectionElem::Downcast(_) => Ok(ty),
-            ProjectionElem::OpaqueCast(ty) | ProjectionElem::Subtype(ty) => Ok(*ty),
+            ProjectionElem::OpaqueCast(ty) => Ok(*ty),
         }
     }
 
diff --git a/compiler/rustc_public/src/mir/visit.rs b/compiler/rustc_public/src/mir/visit.rs
index 04c4d4d2a82d7..7563c9ca00820 100644
--- a/compiler/rustc_public/src/mir/visit.rs
+++ b/compiler/rustc_public/src/mir/visit.rs
@@ -471,7 +471,6 @@ macro_rules! visit_place_fns {
                 ProjectionElem::Subslice { from: _, to: _, from_end: _ } => {}
                 ProjectionElem::Downcast(_idx) => {}
                 ProjectionElem::OpaqueCast(ty) => self.visit_ty(ty, location),
-                ProjectionElem::Subtype(ty) => self.visit_ty(ty, location),
             }
         }
     };
@@ -512,7 +511,6 @@ macro_rules! visit_place_fns {
                 ProjectionElem::Subslice { from: _, to: _, from_end: _ } => {}
                 ProjectionElem::Downcast(_idx) => {}
                 ProjectionElem::OpaqueCast(ty) => self.visit_ty(ty, location),
-                ProjectionElem::Subtype(ty) => self.visit_ty(ty, location),
             }
         }
     };
diff --git a/compiler/rustc_public/src/unstable/convert/internal.rs b/compiler/rustc_public/src/unstable/convert/internal.rs
index dc9abd88614d3..064fb6c6803a5 100644
--- a/compiler/rustc_public/src/unstable/convert/internal.rs
+++ b/compiler/rustc_public/src/unstable/convert/internal.rs
@@ -703,9 +703,6 @@ impl RustcInternal for ProjectionElem {
             ProjectionElem::OpaqueCast(ty) => {
                 rustc_middle::mir::PlaceElem::OpaqueCast(ty.internal(tables, tcx))
             }
-            ProjectionElem::Subtype(ty) => {
-                rustc_middle::mir::PlaceElem::Subtype(ty.internal(tables, tcx))
-            }
         }
     }
 }
diff --git a/compiler/rustc_public/src/unstable/convert/stable/mir.rs b/compiler/rustc_public/src/unstable/convert/stable/mir.rs
index b10af6526ead5..62ab91d17baee 100644
--- a/compiler/rustc_public/src/unstable/convert/stable/mir.rs
+++ b/compiler/rustc_public/src/unstable/convert/stable/mir.rs
@@ -356,6 +356,7 @@ impl<'tcx> Stable<'tcx> for mir::CastKind {
             PtrToPtr => crate::mir::CastKind::PtrToPtr,
             FnPtrToPtr => crate::mir::CastKind::FnPtrToPtr,
             Transmute => crate::mir::CastKind::Transmute,
+            Subtype => crate::mir::CastKind::Subtype,
         }
     }
 }
@@ -453,7 +454,6 @@ impl<'tcx> Stable<'tcx> for mir::PlaceElem<'tcx> {
             // found at https://github.com/rust-lang/rust/pull/117517#issuecomment-1811683486
             Downcast(_, idx) => crate::mir::ProjectionElem::Downcast(idx.stable(tables, cx)),
             OpaqueCast(ty) => crate::mir::ProjectionElem::OpaqueCast(ty.stable(tables, cx)),
-            Subtype(ty) => crate::mir::ProjectionElem::Subtype(ty.stable(tables, cx)),
             UnwrapUnsafeBinder(..) => todo!("FIXME(unsafe_binders):"),
         }
     }

From 78ff5ddad940c245ba2ace56c8d4aa33e1bb6338 Mon Sep 17 00:00:00 2001
From: Yotam Ofek <yotam.ofek@gmail.com>
Date: Tue, 23 Sep 2025 20:40:28 +0300
Subject: [PATCH 1416/1889] Remove usages of `write_str` from
 `render_assoc_items_inner`

---
 src/librustdoc/html/format.rs     |  4 ---
 src/librustdoc/html/render/mod.rs | 59 ++++++++++++-------------------
 2 files changed, 22 insertions(+), 41 deletions(-)

diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
index ecaff4cdf43af..856e637a4587b 100644
--- a/src/librustdoc/html/format.rs
+++ b/src/librustdoc/html/format.rs
@@ -37,10 +37,6 @@ use crate::html::escape::{Escape, EscapeBodyText};
 use crate::html::render::Context;
 use crate::passes::collect_intra_doc_links::UrlFragment;
 
-pub(crate) fn write_str(s: &mut String, f: fmt::Arguments<'_>) {
-    s.write_fmt(f).unwrap();
-}
-
 pub(crate) fn print_generic_bounds(
     bounds: &[clean::GenericBound],
     cx: &Context<'_>,
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index 9a14137a6e801..8c9953c469b9f 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -1472,12 +1472,10 @@ fn render_assoc_items_inner(
                 )
             }
         };
-        let mut impls_buf = String::new();
-        for i in &non_trait {
-            write_str(
-                &mut impls_buf,
-                format_args!(
-                    "{}",
+        let impls_buf = fmt::from_fn(|f| {
+            non_trait
+                .iter()
+                .map(|i| {
                     render_impl(
                         cx,
                         i,
@@ -1493,9 +1491,11 @@ fn render_assoc_items_inner(
                             toggle_open_by_default: true,
                         },
                     )
-                ),
-            );
-        }
+                })
+                .joined("", f)
+        })
+        .to_string();
+
         if !impls_buf.is_empty() {
             write!(
                 w,
@@ -1805,27 +1805,19 @@ fn render_impl(
                                 document_item_info(cx, it, Some(parent))
                                     .render_into(&mut info_buffer)
                                     .unwrap();
-                                write_str(
-                                    &mut doc_buffer,
-                                    format_args!("{}", document_full(item, cx, HeadingOffset::H5)),
-                                );
+                                doc_buffer = document_full(item, cx, HeadingOffset::H5).to_string();
                                 short_documented = false;
                             } else {
                                 // In case the item isn't documented,
                                 // provide short documentation from the trait.
-                                write_str(
-                                    &mut doc_buffer,
-                                    format_args!(
-                                        "{}",
-                                        document_short(
-                                            it,
-                                            cx,
-                                            link,
-                                            parent,
-                                            rendering_params.show_def_docs,
-                                        )
-                                    ),
-                                );
+                                doc_buffer = document_short(
+                                    it,
+                                    cx,
+                                    link,
+                                    parent,
+                                    rendering_params.show_def_docs,
+                                )
+                                .to_string();
                             }
                         }
                     } else {
@@ -1833,21 +1825,14 @@ fn render_impl(
                             .render_into(&mut info_buffer)
                             .unwrap();
                         if rendering_params.show_def_docs {
-                            write_str(
-                                &mut doc_buffer,
-                                format_args!("{}", document_full(item, cx, HeadingOffset::H5)),
-                            );
+                            doc_buffer = document_full(item, cx, HeadingOffset::H5).to_string();
                             short_documented = false;
                         }
                     }
                 } else {
-                    write_str(
-                        &mut doc_buffer,
-                        format_args!(
-                            "{}",
-                            document_short(item, cx, link, parent, rendering_params.show_def_docs)
-                        ),
-                    );
+                    doc_buffer =
+                        document_short(item, cx, link, parent, rendering_params.show_def_docs)
+                            .to_string();
                 }
             }
             let mut w = if short_documented && trait_.is_some() {

From 82fecf0ee3e362bf20b46d7867fe25f9af4e82d8 Mon Sep 17 00:00:00 2001
From: Yotam Ofek <yotam.ofek@gmail.com>
Date: Tue, 23 Sep 2025 20:40:31 +0300
Subject: [PATCH 1417/1889] Cleanup `notable_traits_decl`

---
 src/librustdoc/html/render/mod.rs | 119 ++++++++++++++++--------------
 1 file changed, 63 insertions(+), 56 deletions(-)

diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index 8c9953c469b9f..878af36e4ff1d 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -77,7 +77,6 @@ use crate::html::escape::Escape;
 use crate::html::format::{
     Ending, HrefError, PrintWithSpace, href, print_abi_with_space, print_constness_with_space,
     print_default_space, print_generic_bounds, print_where_clause, visibility_print_with_space,
-    write_str,
 };
 use crate::html::markdown::{
     HeadingOffset, IdMap, Markdown, MarkdownItemInfo, MarkdownSummaryLine,
@@ -1647,69 +1646,77 @@ fn notable_traits_button(ty: &clean::Type, cx: &Context<'_>) -> Option<impl fmt:
 }
 
 fn notable_traits_decl(ty: &clean::Type, cx: &Context<'_>) -> (String, String) {
-    let mut out = String::new();
-
     let did = ty.def_id(cx.cache()).expect("notable_traits_button already checked this");
 
     let impls = cx.cache().impls.get(&did).expect("notable_traits_button already checked this");
 
-    for i in impls {
-        let impl_ = i.inner_impl();
-        if impl_.polarity != ty::ImplPolarity::Positive {
-            continue;
-        }
-
-        if !ty.is_doc_subtype_of(&impl_.for_, cx.cache()) {
-            // Two different types might have the same did,
-            // without actually being the same.
-            continue;
-        }
-        if let Some(trait_) = &impl_.trait_ {
-            let trait_did = trait_.def_id();
-
-            if cx.cache().traits.get(&trait_did).is_some_and(|t| t.is_notable_trait(cx.tcx())) {
-                if out.is_empty() {
-                    write_str(
-                        &mut out,
-                        format_args!(
-                            "<h3>Notable traits for <code>{}</code></h3>\
-                            <pre><code>",
-                            impl_.for_.print(cx)
-                        ),
-                    );
+    let out = fmt::from_fn(|f| {
+        let mut notable_impls = impls
+            .iter()
+            .map(|impl_| impl_.inner_impl())
+            .filter(|impl_| impl_.polarity == ty::ImplPolarity::Positive)
+            .filter(|impl_| {
+                // Two different types might have the same did, without actually being the same.
+                ty.is_doc_subtype_of(&impl_.for_, cx.cache())
+            })
+            .filter_map(|impl_| {
+                if let Some(trait_) = &impl_.trait_
+                    && let trait_did = trait_.def_id()
+                    && let Some(trait_) = cx.cache().traits.get(&trait_did)
+                    && trait_.is_notable_trait(cx.tcx())
+                {
+                    Some((impl_, trait_did))
+                } else {
+                    None
                 }
+            })
+            .peekable();
 
-                write_str(
-                    &mut out,
-                    format_args!("<div class=\"where\">{}</div>", impl_.print(false, cx)),
-                );
-                for it in &impl_.items {
-                    if let clean::AssocTypeItem(ref tydef, ref _bounds) = it.kind {
-                        let empty_set = FxIndexSet::default();
-                        let src_link = AssocItemLink::GotoSource(trait_did.into(), &empty_set);
-                        write_str(
-                            &mut out,
-                            format_args!(
-                                "<div class=\"where\">    {};</div>",
-                                assoc_type(
-                                    it,
-                                    &tydef.generics,
-                                    &[], // intentionally leaving out bounds
-                                    Some(&tydef.type_),
-                                    src_link,
-                                    0,
-                                    cx,
-                                )
-                            ),
-                        );
-                    }
-                }
+        let has_notable_impl = if let Some((impl_, _)) = notable_impls.peek() {
+            write!(
+                f,
+                "<h3>Notable traits for <code>{}</code></h3>\
+                <pre><code>",
+                impl_.for_.print(cx)
+            )?;
+            true
+        } else {
+            false
+        };
+
+        for (impl_, trait_did) in notable_impls {
+            write!(f, "<div class=\"where\">{}</div>", impl_.print(false, cx))?;
+            for it in &impl_.items {
+                let clean::AssocTypeItem(tydef, ..) = &it.kind else {
+                    continue;
+                };
+
+                let empty_set = FxIndexSet::default();
+                let src_link = AssocItemLink::GotoSource(trait_did.into(), &empty_set);
+
+                write!(
+                    f,
+                    "<div class=\"where\">    {};</div>",
+                    assoc_type(
+                        it,
+                        &tydef.generics,
+                        &[], // intentionally leaving out bounds
+                        Some(&tydef.type_),
+                        src_link,
+                        0,
+                        cx,
+                    )
+                )?;
             }
         }
-    }
-    if out.is_empty() {
-        out.push_str("</code></pre>");
-    }
+
+        if !has_notable_impl {
+            f.write_str("</code></pre>")?;
+        }
+
+        Ok(())
+    })
+    .to_string();
 
     (format!("{:#}", ty.print(cx)), out)
 }

From a40032d9e38a9237e61f8b909e5387b388698c15 Mon Sep 17 00:00:00 2001
From: Yotam Ofek <yotam.ofek@gmail.com>
Date: Tue, 23 Sep 2025 23:17:25 +0300
Subject: [PATCH 1418/1889] Simplify notable traits map serialization

---
 src/librustdoc/Cargo.toml         |  2 +-
 src/librustdoc/html/render/mod.rs | 23 ++++-------------------
 2 files changed, 5 insertions(+), 20 deletions(-)

diff --git a/src/librustdoc/Cargo.toml b/src/librustdoc/Cargo.toml
index f37a8d85361f2..0988d099eb4ff 100644
--- a/src/librustdoc/Cargo.toml
+++ b/src/librustdoc/Cargo.toml
@@ -12,7 +12,7 @@ path = "lib.rs"
 arrayvec = { version = "0.7", default-features = false }
 askama = { version = "0.14", default-features = false, features = ["alloc", "config", "derive"] }
 base64 = "0.21.7"
-indexmap = "2"
+indexmap = { version = "2", features = ["serde"] }
 itertools = "0.12"
 minifier = { version = "0.3.5", default-features = false }
 pulldown-cmark-escape = { version = "0.11.0", features = ["simd"] }
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index 878af36e4ff1d..d3b35ec727c57 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -48,6 +48,7 @@ use std::path::PathBuf;
 use std::{fs, str};
 
 use askama::Template;
+use indexmap::IndexMap;
 use itertools::Either;
 use rustc_ast::join_path_syms;
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
@@ -60,8 +61,6 @@ use rustc_middle::ty::print::PrintTraitRefExt;
 use rustc_middle::ty::{self, TyCtxt};
 use rustc_span::symbol::{Symbol, sym};
 use rustc_span::{BytePos, DUMMY_SP, FileName, RealFileName};
-use serde::ser::SerializeMap;
-use serde::{Serialize, Serializer};
 use tracing::{debug, info};
 
 pub(crate) use self::context::*;
@@ -1722,23 +1721,9 @@ fn notable_traits_decl(ty: &clean::Type, cx: &Context<'_>) -> (String, String) {
 }
 
 fn notable_traits_json<'a>(tys: impl Iterator<Item = &'a clean::Type>, cx: &Context<'_>) -> String {
-    let mut mp: Vec<(String, String)> = tys.map(|ty| notable_traits_decl(ty, cx)).collect();
-    mp.sort_by(|(name1, _html1), (name2, _html2)| name1.cmp(name2));
-    struct NotableTraitsMap(Vec<(String, String)>);
-    impl Serialize for NotableTraitsMap {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: Serializer,
-        {
-            let mut map = serializer.serialize_map(Some(self.0.len()))?;
-            for item in &self.0 {
-                map.serialize_entry(&item.0, &item.1)?;
-            }
-            map.end()
-        }
-    }
-    serde_json::to_string(&NotableTraitsMap(mp))
-        .expect("serialize (string, string) -> json object cannot fail")
+    let mut mp = tys.map(|ty| notable_traits_decl(ty, cx)).collect::<IndexMap<_, _>>();
+    mp.sort_unstable_keys();
+    serde_json::to_string(&mp).expect("serialize (string, string) -> json object cannot fail")
 }
 
 #[derive(Clone, Copy, Debug)]

From 93a96bf29c22d05894ca343b624cd09048aa7bb7 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Fri, 26 Sep 2025 16:53:45 +0800
Subject: [PATCH 1419/1889] Migrate `replace_arith_op` assist to use
 `SyntaxEditor`

---
 .../src/handlers/replace_arith_op.rs          | 27 ++++++++++---------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_arith_op.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_arith_op.rs
index 94ac1c342d302..a3fb851fb0e29 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_arith_op.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_arith_op.rs
@@ -1,7 +1,7 @@
 use ide_db::assists::{AssistId, GroupLabel};
 use syntax::{
-    AstNode, TextRange,
-    ast::{self, ArithOp, BinaryOp},
+    AstNode,
+    ast::{self, ArithOp, BinaryOp, syntax_factory::SyntaxFactory},
 };
 
 use crate::assist_context::{AssistContext, Assists};
@@ -71,28 +71,31 @@ pub(crate) fn replace_arith_with_wrapping(
 
 fn replace_arith(acc: &mut Assists, ctx: &AssistContext<'_>, kind: ArithKind) -> Option<()> {
     let (lhs, op, rhs) = parse_binary_op(ctx)?;
+    let op_expr = lhs.syntax().parent()?;
 
     if !is_primitive_int(ctx, &lhs) || !is_primitive_int(ctx, &rhs) {
         return None;
     }
 
-    let start = lhs.syntax().text_range().start();
-    let end = rhs.syntax().text_range().end();
-    let range = TextRange::new(start, end);
-
     acc.add_group(
         &GroupLabel("Replace arithmetic...".into()),
         kind.assist_id(),
         kind.label(),
-        range,
+        op_expr.text_range(),
         |builder| {
+            let mut edit = builder.make_editor(rhs.syntax());
+            let make = SyntaxFactory::with_mappings();
             let method_name = kind.method_name(op);
 
-            if lhs.precedence().needs_parentheses_in(ast::prec::ExprPrecedence::Postfix) {
-                builder.replace(range, format!("({lhs}).{method_name}({rhs})"))
-            } else {
-                builder.replace(range, format!("{lhs}.{method_name}({rhs})"))
-            }
+            let needs_parentheses =
+                lhs.precedence().needs_parentheses_in(ast::prec::ExprPrecedence::Postfix);
+            let receiver = if needs_parentheses { make.expr_paren(lhs).into() } else { lhs };
+            let arith_expr =
+                make.expr_method_call(receiver, make.name_ref(&method_name), make.arg_list([rhs]));
+            edit.replace(op_expr, arith_expr.syntax());
+
+            edit.add_mappings(make.finish_with_mappings());
+            builder.add_file_edits(ctx.vfs_file_id(), edit);
         },
     )
 }

From fc703ec5c88e678a4931f7bb8ed86efc141775f7 Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Thu, 25 Sep 2025 09:30:31 +0000
Subject: [PATCH 1420/1889] fix doc comments to be more standard

---
 compiler/rustc_mir_build/src/builder/mod.rs |  6 +-----
 compiler/rustc_privacy/src/lib.rs           | 22 ++++-----------------
 2 files changed, 5 insertions(+), 23 deletions(-)

diff --git a/compiler/rustc_mir_build/src/builder/mod.rs b/compiler/rustc_mir_build/src/builder/mod.rs
index cdb2c5561ce6a..7ca94e655fb20 100644
--- a/compiler/rustc_mir_build/src/builder/mod.rs
+++ b/compiler/rustc_mir_build/src/builder/mod.rs
@@ -395,12 +395,10 @@ enum NeedsTemporary {
     Maybe,
 }
 
-///////////////////////////////////////////////////////////////////////////
 /// The `BlockAnd` "monad" packages up the new basic block along with a
 /// produced value (sometimes just unit, of course). The `unpack!`
 /// macro (and methods below) makes working with `BlockAnd` much more
 /// convenient.
-
 #[must_use = "if you don't use one of these results, you're leaving a dangling edge"]
 struct BlockAnd<T>(BasicBlock, T);
 
@@ -438,9 +436,7 @@ macro_rules! unpack {
     }};
 }
 
-///////////////////////////////////////////////////////////////////////////
-/// the main entry point for building MIR for a function
-
+/// The main entry point for building MIR for a function.
 fn construct_fn<'tcx>(
     tcx: TyCtxt<'tcx>,
     fn_def: LocalDefId,
diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
index 1bddbd03cc3d3..c9dbb204f61f7 100644
--- a/compiler/rustc_privacy/src/lib.rs
+++ b/compiler/rustc_privacy/src/lib.rs
@@ -45,7 +45,7 @@ use tracing::debug;
 rustc_fluent_macro::fluent_messages! { "../messages.ftl" }
 
 ////////////////////////////////////////////////////////////////////////////////
-/// Generic infrastructure used to implement specific visitors below.
+// Generic infrastructure used to implement specific visitors below.
 ////////////////////////////////////////////////////////////////////////////////
 
 struct LazyDefPathStr<'tcx> {
@@ -309,10 +309,7 @@ fn min(vis1: ty::Visibility, vis2: ty::Visibility, tcx: TyCtxt<'_>) -> ty::Visib
     if vis1.is_at_least(vis2, tcx) { vis2 } else { vis1 }
 }
 
-////////////////////////////////////////////////////////////////////////////////
 /// Visitor used to determine impl visibility and reachability.
-////////////////////////////////////////////////////////////////////////////////
-
 struct FindMin<'a, 'tcx, VL: VisibilityLike, const SHALLOW: bool> {
     tcx: TyCtxt<'tcx>,
     effective_visibilities: &'a EffectiveVisibilities,
@@ -387,10 +384,7 @@ impl VisibilityLike for EffectiveVisibility {
     }
 }
 
-////////////////////////////////////////////////////////////////////////////////
 /// The embargo visitor, used to determine the exports of the AST.
-////////////////////////////////////////////////////////////////////////////////
-
 struct EmbargoVisitor<'tcx> {
     tcx: TyCtxt<'tcx>,
 
@@ -849,9 +843,7 @@ impl<'tcx> DefIdVisitor<'tcx> for ReachEverythingInTheInterfaceVisitor<'_, 'tcx>
     }
 }
 
-////////////////////////////////////////////////////////////////////////////////
 /// Visitor, used for EffectiveVisibilities table checking
-////////////////////////////////////////////////////////////////////////////////
 pub struct TestReachabilityVisitor<'a, 'tcx> {
     tcx: TyCtxt<'tcx>,
     effective_visibilities: &'a EffectiveVisibilities,
@@ -909,13 +901,11 @@ impl<'a, 'tcx> TestReachabilityVisitor<'a, 'tcx> {
     }
 }
 
-//////////////////////////////////////////////////////////////////////////////////////
 /// Name privacy visitor, checks privacy and reports violations.
+///
 /// Most of name privacy checks are performed during the main resolution phase,
 /// or later in type checking when field accesses and associated items are resolved.
 /// This pass performs remaining checks for fields in struct expressions and patterns.
-//////////////////////////////////////////////////////////////////////////////////////
-
 struct NamePrivacyVisitor<'tcx> {
     tcx: TyCtxt<'tcx>,
     maybe_typeck_results: Option<&'tcx ty::TypeckResults<'tcx>>,
@@ -1120,12 +1110,10 @@ impl<'tcx> Visitor<'tcx> for NamePrivacyVisitor<'tcx> {
     }
 }
 
-////////////////////////////////////////////////////////////////////////////////////////////
 /// Type privacy visitor, checks types for privacy and reports violations.
+///
 /// Both explicitly written types and inferred types of expressions and patterns are checked.
 /// Checks are performed on "semantic" types regardless of names and their hygiene.
-////////////////////////////////////////////////////////////////////////////////////////////
-
 struct TypePrivacyVisitor<'tcx> {
     tcx: TyCtxt<'tcx>,
     module_def_id: LocalModDefId,
@@ -1345,13 +1333,11 @@ impl<'tcx> DefIdVisitor<'tcx> for TypePrivacyVisitor<'tcx> {
     }
 }
 
-///////////////////////////////////////////////////////////////////////////////
 /// SearchInterfaceForPrivateItemsVisitor traverses an item's interface and
 /// finds any private components in it.
+///
 /// PrivateItemsInPublicInterfacesVisitor ensures there are no private types
 /// and traits in public interfaces.
-///////////////////////////////////////////////////////////////////////////////
-
 struct SearchInterfaceForPrivateItemsVisitor<'tcx> {
     tcx: TyCtxt<'tcx>,
     item_def_id: LocalDefId,

From 7a2c1730336e487eed37e97014b7864ebd81962b Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 25 Sep 2025 15:25:27 +0200
Subject: [PATCH 1421/1889] Add new `tyalias` intra-doc link disambiguator

---
 src/librustdoc/passes/collect_intra_doc_links.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs
index 0da42f38251cc..79d74c3c4eb90 100644
--- a/src/librustdoc/passes/collect_intra_doc_links.rs
+++ b/src/librustdoc/passes/collect_intra_doc_links.rs
@@ -130,6 +130,7 @@ impl Res {
             DefKind::Static { .. } => "static",
             DefKind::Field => "field",
             DefKind::Variant | DefKind::Ctor(..) => "variant",
+            DefKind::TyAlias => "tyalias",
             // Now handle things that don't have a specific disambiguator
             _ => match kind
                 .ns()
@@ -1708,6 +1709,7 @@ impl Disambiguator {
                 "value" => NS(Namespace::ValueNS),
                 "macro" => NS(Namespace::MacroNS),
                 "prim" | "primitive" => Primitive,
+                "tyalias" | "typealias" => Kind(DefKind::TyAlias),
                 _ => return Err((format!("unknown disambiguator `{prefix}`"), 0..idx)),
             };
 

From dba45cde68ba25b7fa790e4e36593b6fd55d6d8a Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 25 Sep 2025 15:25:51 +0200
Subject: [PATCH 1422/1889] Add tests for new `tyalias` intra-doc link
 disambiguator

---
 .../type-alias-primitive-suggestion.rs        | 21 ++++++++++
 .../type-alias-primitive-suggestion.stderr    | 39 +++++++++++++++++++
 .../intra-doc/type-alias-primitive.rs         | 14 +++++++
 .../rustdoc/intra-doc/type-alias-primitive.rs | 21 ++++++++++
 4 files changed, 95 insertions(+)
 create mode 100644 tests/rustdoc-ui/intra-doc/type-alias-primitive-suggestion.rs
 create mode 100644 tests/rustdoc-ui/intra-doc/type-alias-primitive-suggestion.stderr
 create mode 100644 tests/rustdoc-ui/intra-doc/type-alias-primitive.rs
 create mode 100644 tests/rustdoc/intra-doc/type-alias-primitive.rs

diff --git a/tests/rustdoc-ui/intra-doc/type-alias-primitive-suggestion.rs b/tests/rustdoc-ui/intra-doc/type-alias-primitive-suggestion.rs
new file mode 100644
index 0000000000000..c4527c626d9c5
--- /dev/null
+++ b/tests/rustdoc-ui/intra-doc/type-alias-primitive-suggestion.rs
@@ -0,0 +1,21 @@
+// Ensure that no warning is emitted if the disambiguator is used for type alias.
+// Regression test for <https://github.com/rust-lang/rust/issues/146855>.
+
+#![deny(rustdoc::broken_intra_doc_links)]
+
+pub struct Foo;
+
+#[allow(non_camel_case_types)]
+pub type f32 = Foo;
+
+/// This function returns [`f32`].
+//~^ ERROR: `f32` is both a type alias and a primitive type
+//~| HELP: to link to the type alias, prefix with `tyalias@`
+//~| HELP: to link to the primitive type, prefix with `prim@`
+pub fn my_fn() -> f32 {}
+
+/// This function returns [type@f32].
+//~^ ERROR: `f32` is both a type alias and a primitive type
+//~| HELP: to link to the type alias, prefix with `tyalias@`
+//~| HELP: to link to the primitive type, prefix with `prim@`
+pub fn my_fn2() -> f32 {}
diff --git a/tests/rustdoc-ui/intra-doc/type-alias-primitive-suggestion.stderr b/tests/rustdoc-ui/intra-doc/type-alias-primitive-suggestion.stderr
new file mode 100644
index 0000000000000..c99e7d1d10434
--- /dev/null
+++ b/tests/rustdoc-ui/intra-doc/type-alias-primitive-suggestion.stderr
@@ -0,0 +1,39 @@
+error: `f32` is both a type alias and a primitive type
+  --> $DIR/type-alias-primitive-suggestion.rs:11:29
+   |
+LL | /// This function returns [`f32`].
+   |                             ^^^ ambiguous link
+   |
+note: the lint level is defined here
+  --> $DIR/type-alias-primitive-suggestion.rs:4:9
+   |
+LL | #![deny(rustdoc::broken_intra_doc_links)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: to link to the type alias, prefix with `tyalias@`
+   |
+LL | /// This function returns [`tyalias@f32`].
+   |                             ++++++++
+help: to link to the primitive type, prefix with `prim@`
+   |
+LL | /// This function returns [`prim@f32`].
+   |                             +++++
+
+error: `f32` is both a type alias and a primitive type
+  --> $DIR/type-alias-primitive-suggestion.rs:17:28
+   |
+LL | /// This function returns [type@f32].
+   |                            ^^^^^^^^ ambiguous link
+   |
+help: to link to the type alias, prefix with `tyalias@`
+   |
+LL - /// This function returns [type@f32].
+LL + /// This function returns [tyalias@f32].
+   |
+help: to link to the primitive type, prefix with `prim@`
+   |
+LL - /// This function returns [type@f32].
+LL + /// This function returns [prim@f32].
+   |
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/rustdoc-ui/intra-doc/type-alias-primitive.rs b/tests/rustdoc-ui/intra-doc/type-alias-primitive.rs
new file mode 100644
index 0000000000000..62b2c83eeca47
--- /dev/null
+++ b/tests/rustdoc-ui/intra-doc/type-alias-primitive.rs
@@ -0,0 +1,14 @@
+// Ensure that no warning is emitted if the disambiguator is used for type alias.
+// Regression test for <https://github.com/rust-lang/rust/issues/146855>.
+
+//@ check-pass
+
+#![deny(rustdoc::broken_intra_doc_links)]
+
+pub struct Foo;
+
+#[allow(non_camel_case_types)]
+pub type f32 = Foo;
+
+/// This function returns [`tyalias@f32`] and not [`prim@f32`].
+pub fn my_fn() -> f32 {}
diff --git a/tests/rustdoc/intra-doc/type-alias-primitive.rs b/tests/rustdoc/intra-doc/type-alias-primitive.rs
new file mode 100644
index 0000000000000..7504166cbcce2
--- /dev/null
+++ b/tests/rustdoc/intra-doc/type-alias-primitive.rs
@@ -0,0 +1,21 @@
+// Ensure that no warning is emitted if the disambiguator is used for type alias.
+// Regression test for <https://github.com/rust-lang/rust/issues/146855>.
+
+#![crate_name = "foo"]
+#![deny(rustdoc::broken_intra_doc_links)]
+
+pub struct Foo;
+
+#[allow(non_camel_case_types)]
+pub type f32 = Foo;
+
+/// This function returns [`tyalias@f32`] and not [bla][`prim@f32`].
+//@ has 'foo/fn.my_fn.html'
+//@ has - '//a[@href="type.f32.html"]' "f32"
+//@ has - '//a[@href="{{channel}}/std/primitive.f32.html"]' "bla"
+pub fn my_fn() -> f32 { 0. }
+
+/// This function returns [`typealias@f32`].
+//@ has 'foo/fn.my_other_fn.html'
+//@ has - '//a[@href="type.f32.html"]' "f32"
+pub fn my_other_fn() -> f32 { 0. }

From 62c457bb02488dc6df95c574f34dd0ce444475dd Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 25 Sep 2025 15:27:00 +0200
Subject: [PATCH 1423/1889] Mention `tyalias` in intra-doc link rustdoc book
 chapter

---
 .../rustdoc/src/write-documentation/linking-to-items-by-name.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustdoc/src/write-documentation/linking-to-items-by-name.md b/src/doc/rustdoc/src/write-documentation/linking-to-items-by-name.md
index 5e7854834028a..b1495b2575e23 100644
--- a/src/doc/rustdoc/src/write-documentation/linking-to-items-by-name.md
+++ b/src/doc/rustdoc/src/write-documentation/linking-to-items-by-name.md
@@ -90,7 +90,7 @@ fn Foo() {}
 These prefixes will be stripped when displayed in the documentation, so `[struct@Foo]` will be
 rendered as `Foo`. The following prefixes are available: `struct`, `enum`, `trait`, `union`,
 `mod`, `module`, `const`, `constant`, `fn`, `function`, `field`, `variant`, `method`, `derive`,
-`type`, `value`, `macro`, `prim` or `primitive`.
+`type`, `value`, `macro`, `tyalias`, `typealias`, `prim` or `primitive`.
 
 You can also disambiguate for functions by adding `()` after the function name,
 or for macros by adding `!` after the macro name. The macro `!` can be followed by `()`, `{}`,

From 4a0c7cc730a5434574c41a6073d9efb92141af1a Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Fri, 26 Sep 2025 13:48:22 +0200
Subject: [PATCH 1424/1889] fix cycle head usages tracking

---
 .../src/solve/search_graph.rs                 |  22 ++-
 .../rustc_type_ir/src/search_graph/mod.rs     | 141 ++++++++++++------
 .../ignore-head-usages-provisional-cache.rs   |  55 +++++++
 3 files changed, 166 insertions(+), 52 deletions(-)
 create mode 100644 tests/ui/traits/next-solver/cycles/ignore-head-usages-provisional-cache.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 aa9dfc9a9a265..4ae2af59a7031 100644
--- a/compiler/rustc_next_trait_solver/src/solve/search_graph.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/search_graph.rs
@@ -74,13 +74,21 @@ where
         }
     }
 
-    fn is_initial_provisional_result(
-        cx: Self::Cx,
-        kind: PathKind,
-        input: CanonicalInput<I>,
-        result: QueryResult<I>,
-    ) -> bool {
-        Self::initial_provisional_result(cx, kind, input) == result
+    fn is_initial_provisional_result(result: QueryResult<I>) -> Option<PathKind> {
+        match result {
+            Ok(response) => {
+                if has_no_inference_or_external_constraints(response) {
+                    if response.value.certainty == Certainty::Yes {
+                        return Some(PathKind::Coinductive);
+                    } else if response.value.certainty == Certainty::overflow(false) {
+                        return Some(PathKind::Unknown);
+                    }
+                }
+
+                None
+            }
+            Err(NoSolution) => Some(PathKind::Inductive),
+        }
     }
 
     fn on_stack_overflow(cx: I, input: CanonicalInput<I>) -> QueryResult<I> {
diff --git a/compiler/rustc_type_ir/src/search_graph/mod.rs b/compiler/rustc_type_ir/src/search_graph/mod.rs
index 8f8f019510fe8..a7902cd021038 100644
--- a/compiler/rustc_type_ir/src/search_graph/mod.rs
+++ b/compiler/rustc_type_ir/src/search_graph/mod.rs
@@ -86,12 +86,7 @@ pub trait Delegate: Sized {
         kind: PathKind,
         input: <Self::Cx as Cx>::Input,
     ) -> <Self::Cx as Cx>::Result;
-    fn is_initial_provisional_result(
-        cx: Self::Cx,
-        kind: PathKind,
-        input: <Self::Cx as Cx>::Input,
-        result: <Self::Cx as Cx>::Result,
-    ) -> bool;
+    fn is_initial_provisional_result(result: <Self::Cx as Cx>::Result) -> Option<PathKind>;
     fn on_stack_overflow(cx: Self::Cx, input: <Self::Cx as Cx>::Input) -> <Self::Cx as Cx>::Result;
     fn on_fixpoint_overflow(
         cx: Self::Cx,
@@ -215,6 +210,27 @@ impl HeadUsages {
         let HeadUsages { inductive, unknown, coinductive, forced_ambiguity } = self;
         inductive == 0 && unknown == 0 && coinductive == 0 && forced_ambiguity == 0
     }
+
+    fn is_single(self, path_kind: PathKind) -> bool {
+        match path_kind {
+            PathKind::Inductive => matches!(
+                self,
+                HeadUsages { inductive: _, unknown: 0, coinductive: 0, forced_ambiguity: 0 },
+            ),
+            PathKind::Unknown => matches!(
+                self,
+                HeadUsages { inductive: 0, unknown: _, coinductive: 0, forced_ambiguity: 0 },
+            ),
+            PathKind::Coinductive => matches!(
+                self,
+                HeadUsages { inductive: 0, unknown: 0, coinductive: _, forced_ambiguity: 0 },
+            ),
+            PathKind::ForcedAmbiguity => matches!(
+                self,
+                HeadUsages { inductive: 0, unknown: 0, coinductive: 0, forced_ambiguity: _ },
+            ),
+        }
+    }
 }
 
 #[derive(Debug, Default)]
@@ -888,7 +904,29 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             !entries.is_empty()
         });
     }
+}
+
+/// We need to rebase provisional cache entries when popping one of their cycle
+/// heads from the stack. This may not necessarily mean that we've actually
+/// reached a fixpoint for that cycle head, which impacts the way we rebase
+/// provisional cache entries.
+enum RebaseReason {
+    NoCycleUsages,
+    Ambiguity,
+    Overflow,
+    /// We've actually reached a fixpoint.
+    ///
+    /// This either happens in the first evaluation step for the cycle head.
+    /// In this case the used provisional result depends on the cycle `PathKind`.
+    /// We store this path kind to check whether the the provisional cache entry
+    /// we're rebasing relied on the same cycles.
+    ///
+    /// In later iterations cycles always return `stack_entry.provisional_result`
+    /// so we no longer depend on the `PathKind`. We store `None` in that case.
+    ReachedFixpoint(Option<PathKind>),
+}
 
+impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D, X> {
     /// 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
@@ -908,8 +946,9 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
     /// 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,
+        rebase_reason: RebaseReason,
     ) {
         let popped_head_index = self.stack.next_index();
         #[allow(rustc::potential_query_instability)]
@@ -927,6 +966,10 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
                     return true;
                 };
 
+                let Some(new_highest_head_index) = heads.opt_highest_cycle_head_index() else {
+                    return false;
+                };
+
                 // We're rebasing an entry `e` over a head `p`. This head
                 // has a number of own heads `h` it depends on.
                 //
@@ -977,22 +1020,37 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
                         let eph = ep.extend_with_paths(ph);
                         heads.insert(head_index, eph, head.usages);
                     }
-                }
 
-                let Some(head_index) = heads.opt_highest_cycle_head_index() else {
-                    return false;
-                };
+                    // The provisional cache entry does depend on the provisional result
+                    // of the popped cycle head. We need to mutate the result of our
+                    // provisional cache entry in case we did not reach a fixpoint.
+                    match rebase_reason {
+                        // If the cycle head does not actually depend on itself, then
+                        // the provisional result used by the provisional cache entry
+                        // is not actually equal to the final provisional result. We
+                        // need to discard the provisional cache entry in this case.
+                        RebaseReason::NoCycleUsages => return false,
+                        RebaseReason::Ambiguity => {
+                            *result = D::propagate_ambiguity(cx, input, *result);
+                        }
+                        RebaseReason::Overflow => *result = D::on_fixpoint_overflow(cx, input),
+                        RebaseReason::ReachedFixpoint(None) => {}
+                        RebaseReason::ReachedFixpoint(Some(path_kind)) => {
+                            if !popped_head.usages.is_single(path_kind) {
+                                return false;
+                            }
+                        }
+                    };
+                }
 
                 // We now care about the path from the next highest cycle head to the
                 // provisional cache entry.
                 *path_from_head = path_from_head.extend(Self::cycle_path_kind(
                     &self.stack,
                     stack_entry.step_kind_from_parent,
-                    head_index,
+                    new_highest_head_index,
                 ));
-                // 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()
@@ -1209,33 +1267,19 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
     /// Whether we've reached a fixpoint when evaluating a cycle head.
     fn reached_fixpoint(
         &mut self,
-        cx: X,
         stack_entry: &StackEntry<X>,
         usages: HeadUsages,
         result: X::Result,
-    ) -> bool {
+    ) -> Result<Option<PathKind>, ()> {
         let provisional_result = stack_entry.provisional_result;
-        if usages.is_empty() {
-            true
-        } else if let Some(provisional_result) = provisional_result {
-            provisional_result == result
+        if let Some(provisional_result) = provisional_result {
+            if provisional_result == result { Ok(None) } else { Err(()) }
+        } else if let Some(path_kind) = D::is_initial_provisional_result(result)
+            .filter(|&path_kind| usages.is_single(path_kind))
+        {
+            Ok(Some(path_kind))
         } else {
-            let check = |k| D::is_initial_provisional_result(cx, k, stack_entry.input, result);
-            match usages {
-                HeadUsages { inductive: _, unknown: 0, coinductive: 0, forced_ambiguity: 0 } => {
-                    check(PathKind::Inductive)
-                }
-                HeadUsages { inductive: 0, unknown: _, coinductive: 0, forced_ambiguity: 0 } => {
-                    check(PathKind::Unknown)
-                }
-                HeadUsages { inductive: 0, unknown: 0, coinductive: _, forced_ambiguity: 0 } => {
-                    check(PathKind::Coinductive)
-                }
-                HeadUsages { inductive: 0, unknown: 0, coinductive: 0, forced_ambiguity: _ } => {
-                    check(PathKind::ForcedAmbiguity)
-                }
-                _ => false,
-            }
+            Err(())
         }
     }
 
@@ -1280,8 +1324,19 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             // is equal to the provisional result of the previous iteration, or because
             // this was only the head 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, usages, result) {
-                self.rebase_provisional_cache_entries(&stack_entry, |_, result| result);
+            if let Ok(fixpoint) = self.reached_fixpoint(&stack_entry, usages, result) {
+                self.rebase_provisional_cache_entries(
+                    cx,
+                    &stack_entry,
+                    RebaseReason::ReachedFixpoint(fixpoint),
+                );
+                return EvaluationResult::finalize(stack_entry, encountered_overflow, result);
+            } else if usages.is_empty() {
+                self.rebase_provisional_cache_entries(
+                    cx,
+                    &stack_entry,
+                    RebaseReason::NoCycleUsages,
+                );
                 return EvaluationResult::finalize(stack_entry, encountered_overflow, result);
             }
 
@@ -1298,9 +1353,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             // we also taint all provisional cache entries which depend on the
             // current goal.
             if D::is_ambiguous_result(result) {
-                self.rebase_provisional_cache_entries(&stack_entry, |input, _| {
-                    D::propagate_ambiguity(cx, input, result)
-                });
+                self.rebase_provisional_cache_entries(cx, &stack_entry, RebaseReason::Ambiguity);
                 return EvaluationResult::finalize(stack_entry, encountered_overflow, result);
             };
 
@@ -1310,9 +1363,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             if i >= D::FIXPOINT_STEP_LIMIT {
                 debug!("canonical cycle overflow");
                 let result = D::on_fixpoint_overflow(cx, input);
-                self.rebase_provisional_cache_entries(&stack_entry, |input, _| {
-                    D::on_fixpoint_overflow(cx, input)
-                });
+                self.rebase_provisional_cache_entries(cx, &stack_entry, RebaseReason::Overflow);
                 return EvaluationResult::finalize(stack_entry, encountered_overflow, result);
             }
 
diff --git a/tests/ui/traits/next-solver/cycles/ignore-head-usages-provisional-cache.rs b/tests/ui/traits/next-solver/cycles/ignore-head-usages-provisional-cache.rs
new file mode 100644
index 0000000000000..9a33ae536442f
--- /dev/null
+++ b/tests/ui/traits/next-solver/cycles/ignore-head-usages-provisional-cache.rs
@@ -0,0 +1,55 @@
+//@ compile-flags: -Znext-solver
+//@ check-pass
+
+// A regression test for trait-system-refactor-initiative#232. We've
+// previously incorrectly rebased provisional cache entries even if
+// the cycle head didn't reach a fixpoint as it did not depend on any
+// cycles itself.
+//
+// Just because the result of a goal does not depend on its own provisional
+// result, it does not mean its nested goals don't depend on its result.
+struct B;
+struct C;
+struct D;
+
+pub trait Trait {
+    type Output;
+}
+macro_rules! k {
+    ($t:ty) => {
+        <$t as Trait>::Output
+    };
+}
+
+trait CallB<T1, T2> {
+    type Output;
+    type Return;
+}
+
+trait CallC<T1> {
+    type Output;
+    type Return;
+}
+
+trait CallD<T1, T2> {
+    type Output;
+}
+
+fn foo<X, Y>()
+where
+    X: Trait,
+    Y: Trait,
+    D: CallD<k![X], k![Y]>,
+    C: CallC<<D as CallD<k![X], k![Y]>>::Output>,
+    <C as CallC<<D as CallD<k![X], k![Y]>>::Output>>::Output: Trait,
+    B: CallB<
+            <C as CallC<<D as CallD<k![X], k![Y]>>::Output>>::Return,
+            <C as CallC<<D as CallD<k![X], k![Y]>>::Output>>::Output,
+        >,
+    <B as CallB<
+        <C as CallC<<D as CallD<k![X], k![Y]>>::Output>>::Return,
+        <C as CallC<<D as CallD<k![X], k![Y]>>::Output>>::Output,
+    >>::Output: Trait<Output = ()>,
+{
+}
+fn main() {}

From 4e44d58bbc199ff7c17a98b283621a6df327d60f Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Fri, 26 Sep 2025 14:51:13 +0200
Subject: [PATCH 1425/1889] rename `search_graph::Delegate` fns

---
 .../src/solve/search_graph.rs                       |  4 ++--
 compiler/rustc_type_ir/src/search_graph/mod.rs      | 13 ++++++++-----
 2 files changed, 10 insertions(+), 7 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 4ae2af59a7031..109c8476ccb16 100644
--- a/compiler/rustc_next_trait_solver/src/solve/search_graph.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/search_graph.rs
@@ -91,11 +91,11 @@ where
         }
     }
 
-    fn on_stack_overflow(cx: I, input: CanonicalInput<I>) -> QueryResult<I> {
+    fn stack_overflow_result(cx: I, input: CanonicalInput<I>) -> QueryResult<I> {
         response_no_constraints(cx, input, Certainty::overflow(true))
     }
 
-    fn on_fixpoint_overflow(cx: I, input: CanonicalInput<I>) -> QueryResult<I> {
+    fn fixpoint_overflow_result(cx: I, input: CanonicalInput<I>) -> QueryResult<I> {
         response_no_constraints(cx, input, Certainty::overflow(false))
     }
 
diff --git a/compiler/rustc_type_ir/src/search_graph/mod.rs b/compiler/rustc_type_ir/src/search_graph/mod.rs
index a7902cd021038..7aa58d096d5c0 100644
--- a/compiler/rustc_type_ir/src/search_graph/mod.rs
+++ b/compiler/rustc_type_ir/src/search_graph/mod.rs
@@ -87,8 +87,11 @@ pub trait Delegate: Sized {
         input: <Self::Cx as Cx>::Input,
     ) -> <Self::Cx as Cx>::Result;
     fn is_initial_provisional_result(result: <Self::Cx as Cx>::Result) -> Option<PathKind>;
-    fn on_stack_overflow(cx: Self::Cx, input: <Self::Cx as Cx>::Input) -> <Self::Cx as Cx>::Result;
-    fn on_fixpoint_overflow(
+    fn stack_overflow_result(
+        cx: Self::Cx,
+        input: <Self::Cx as Cx>::Input,
+    ) -> <Self::Cx as Cx>::Result;
+    fn fixpoint_overflow_result(
         cx: Self::Cx,
         input: <Self::Cx as Cx>::Input,
     ) -> <Self::Cx as Cx>::Result;
@@ -885,7 +888,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         }
 
         debug!("encountered stack overflow");
-        D::on_stack_overflow(cx, input)
+        D::stack_overflow_result(cx, input)
     }
 
     /// When reevaluating a goal with a changed provisional result, all provisional cache entry
@@ -1033,7 +1036,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D, X> {
                         RebaseReason::Ambiguity => {
                             *result = D::propagate_ambiguity(cx, input, *result);
                         }
-                        RebaseReason::Overflow => *result = D::on_fixpoint_overflow(cx, input),
+                        RebaseReason::Overflow => *result = D::fixpoint_overflow_result(cx, input),
                         RebaseReason::ReachedFixpoint(None) => {}
                         RebaseReason::ReachedFixpoint(Some(path_kind)) => {
                             if !popped_head.usages.is_single(path_kind) {
@@ -1362,7 +1365,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D, X> {
             i += 1;
             if i >= D::FIXPOINT_STEP_LIMIT {
                 debug!("canonical cycle overflow");
-                let result = D::on_fixpoint_overflow(cx, input);
+                let result = D::fixpoint_overflow_result(cx, input);
                 self.rebase_provisional_cache_entries(cx, &stack_entry, RebaseReason::Overflow);
                 return EvaluationResult::finalize(stack_entry, encountered_overflow, result);
             }

From a535c7be5444fb6584eecc99f53e6cdb710ff70f Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 26 Sep 2025 13:59:06 +0200
Subject: [PATCH 1426/1889] Ignore more failing ui tests for GCC backend

---
 .../array-slice-vec/box-of-array-of-drop-1.rs |   1 +
 .../array-slice-vec/box-of-array-of-drop-2.rs |   1 +
 tests/ui/array-slice-vec/nested-vec-3.rs      |   1 +
 tests/ui/array-slice-vec/slice-panic-1.rs     |   1 +
 tests/ui/array-slice-vec/slice-panic-2.rs     |   1 +
 .../asm/global-asm-isnt-really-a-mir-body.rs  |   1 +
 tests/ui/asm/x86_64/goto.rs                   |   1 +
 tests/ui/asm/x86_64/goto.stderr               |   4 +-
 tests/ui/asm/x86_64/srcloc.rs                 |   1 +
 tests/ui/asm/x86_64/srcloc.stderr             |  50 ++++-----
 tests/ui/attributes/fn-align-dyn.rs           |   1 +
 tests/ui/attributes/main-removed-2/main.rs    |   1 +
 .../backtrace/synchronized-panic-handler.rs   |   1 +
 .../synchronized-panic-handler.run.stderr     |   4 +-
 tests/ui/box/unit/unwind-unique.rs            |   1 +
 tests/ui/c-variadic/inherent-method.rs        |   1 +
 tests/ui/c-variadic/trait-method.rs           |   1 +
 tests/ui/c-variadic/valid.rs                  |   1 +
 .../assume-incomplete.rs                      |   1 +
 .../codegen/issue-82833-slice-miscompile.rs   |   1 +
 tests/ui/codegen/llvm-args-invalid-flag.rs    |   1 +
 tests/ui/codegen/remark-flag-functionality.rs |   1 +
 .../codegen/virtual-function-elimination.rs   |   1 +
 tests/ui/coroutine/gen_block_panic.rs         |   1 +
 tests/ui/coroutine/gen_block_panic.stderr     |   2 +-
 tests/ui/delegation/fn-header-variadic.rs     |   1 +
 tests/ui/delegation/fn-header-variadic.stderr |   4 +-
 tests/ui/drop/drop-trait-enum.rs              |   1 +
 tests/ui/drop/terminate-in-initializer.rs     |   1 +
 .../callee_is_track_caller.rs                 |   1 +
 .../callee_is_track_caller.stderr             |   2 +-
 .../callee_is_track_caller_polymorphic.rs     |   1 +
 .../callee_is_track_caller_polymorphic.stderr |   2 +-
 tests/ui/explicit-tail-calls/drop-order.rs    |   1 +
 tests/ui/explicit-tail-calls/indexer.rs       |   1 +
 tests/ui/explicit-tail-calls/recursion-etc.rs |   1 +
 tests/ui/extern/extern-types-field-offset.rs  |   1 +
 ...llow-unwind-when-calling-panic-directly.rs |   1 +
 ...sue-64655-extern-rust-must-allow-unwind.rs |   1 +
 ...at-args-capture-from-pm-first-arg-macro.rs |   1 +
 ...rgs-capture-from-pm-first-arg-macro.stderr |   2 +-
 tests/ui/frontmatter/proc-macro-observer.rs   |   1 +
 .../issue-77523-def-site-async-await.rs       |   1 +
 .../precise-capturing/external-macro.rs       |   1 +
 .../invalid-llvm-passes.rs                    |   1 +
 tests/ui/issues/issue-25089.rs                |   1 +
 tests/ui/issues/issue-26655.rs                |   1 +
 tests/ui/issues/issue-29485.rs                |   1 +
 tests/ui/issues/issue-30018-panic.rs          |   1 +
 tests/ui/issues/issue-44056.rs                |   1 +
 .../issues/issue-68696-catch-during-unwind.rs |   1 +
 .../common-linkage-non-zero-init.rs           |   1 +
 .../raw-dylib/elf/glibc-x86_64.rs             |   1 +
 .../ui/linking/no-gc-encapsulation-symbols.rs |   1 +
 ...nused-qualification-in-derive-expansion.rs |   1 +
 tests/ui/lto/debuginfo-lto-alloc.rs           |   1 +
 tests/ui/lto/debuginfo-lto.rs                 |   1 +
 tests/ui/lto/dwarf-mixed-versions-lto.rs      |   1 +
 tests/ui/lto/fat-lto.rs                       |   1 +
 tests/ui/lto/issue-100772.rs                  |   1 +
 tests/ui/lto/lto-duplicate-symbols.rs         |   1 +
 tests/ui/lto/lto-many-codegen-units.rs        |   1 +
 tests/ui/lto/lto-rustc-loads-linker-plugin.rs |   1 +
 tests/ui/lto/lto-still-runs-thread-dtors.rs   |   1 +
 tests/ui/macros/same-sequence-span.rs         |   1 +
 tests/ui/macros/same-sequence-span.stderr     |  12 +-
 .../ui/numbers-arithmetic/int-abs-overflow.rs |   1 +
 tests/ui/numbers-arithmetic/issue-8460.rs     |   1 +
 tests/ui/panic-runtime/lto-unwind.rs          |   1 +
 tests/ui/panics/oom-panic-unwind.rs           |   1 +
 .../panics/panic-handler-chain-update-hook.rs |   1 +
 tests/ui/panics/panic-handler-chain.rs        |   1 +
 tests/ui/panics/panic-handler-flail-wildly.rs |   1 +
 tests/ui/panics/panic-handler-set-twice.rs    |   1 +
 tests/ui/panics/panic-in-dtor-drops-fields.rs |   1 +
 tests/ui/panics/panic-recover-propagate.rs    |   1 +
 .../panics/rvalue-cleanup-during-box-panic.rs |   1 +
 .../panics/unwind-force-no-unwind-tables.rs   |   1 +
 ...971-outer-attr-following-inner-attr-ice.rs |   1 +
 ...outer-attr-following-inner-attr-ice.stderr |   2 +-
 .../unicode-control-codepoints-macros.rs      |   1 +
 .../unicode-control-codepoints-macros.stderr  |  10 +-
 .../parser/tuple-index-suffix-proc-macro.rs   |   1 +
 .../tuple-index-suffix-proc-macro.stderr      |   8 +-
 tests/ui/proc-macro/add-impl.rs               |   1 +
 .../ambiguous-builtin-attrs-test.rs           |   1 +
 .../ambiguous-builtin-attrs-test.stderr       |   2 +-
 .../ui/proc-macro/ambiguous-builtin-attrs.rs  |   1 +
 .../proc-macro/ambiguous-builtin-attrs.stderr |  30 ++---
 tests/ui/proc-macro/append-impl.rs            |   1 +
 tests/ui/proc-macro/attr-args.rs              |   1 +
 tests/ui/proc-macro/attr-invalid-exprs.rs     |   1 +
 tests/ui/proc-macro/attr-invalid-exprs.stderr |   6 +-
 tests/ui/proc-macro/attr-on-trait.rs          |   1 +
 tests/ui/proc-macro/bang-macro.rs             |   1 +
 tests/ui/proc-macro/call-site.rs              |   1 +
 tests/ui/proc-macro/count_compound_ops.rs     |   1 +
 tests/ui/proc-macro/derive-bad.rs             |   1 +
 tests/ui/proc-macro/derive-bad.stderr         |   6 +-
 .../ui/proc-macro/derive-helper-shadowing.rs  |   1 +
 .../proc-macro/derive-helper-shadowing.stderr |  18 +--
 tests/ui/proc-macro/derive-same-struct.rs     |   1 +
 tests/ui/proc-macro/edition-imports-2018.rs   |   1 +
 tests/ui/proc-macro/env.rs                    |   1 +
 tests/ui/proc-macro/expand-expr.rs            |   3 +-
 tests/ui/proc-macro/expand-expr.stderr        |  14 +--
 tests/ui/proc-macro/expand-to-unstable.rs     |   1 +
 tests/ui/proc-macro/expand-to-unstable.stderr |   2 +-
 tests/ui/proc-macro/expand-with-a-macro.rs    |   1 +
 .../ui/proc-macro/gen-macro-rules-hygiene.rs  |   1 +
 .../proc-macro/gen-macro-rules-hygiene.stderr |   6 +-
 tests/ui/proc-macro/gen-macro-rules.rs        |   1 +
 tests/ui/proc-macro/generate-mod.rs           |   1 +
 tests/ui/proc-macro/generate-mod.stderr       |  28 ++---
 tests/ui/proc-macro/hygiene_example.rs        |   1 +
 tests/ui/proc-macro/is-available.rs           |   1 +
 .../issue-104884-trait-impl-sugg-err.rs       |   1 +
 .../issue-104884-trait-impl-sugg-err.stderr   |  18 +--
 tests/ui/proc-macro/issue-107113-wrap.rs      |   1 +
 tests/ui/proc-macro/issue-107113-wrap.stderr  |   2 +-
 tests/ui/proc-macro/issue-118809.rs           |   1 +
 tests/ui/proc-macro/issue-118809.stderr       |   4 +-
 tests/ui/proc-macro/issue-38586.rs            |   1 +
 tests/ui/proc-macro/issue-38586.stderr        |   2 +-
 .../issue-59191-replace-root-with-fn.rs       |   1 +
 tests/ui/proc-macro/issue-79148.rs            |   1 +
 tests/ui/proc-macro/issue-79148.stderr        |   4 +-
 tests/ui/proc-macro/issue-83510.rs            |   1 +
 tests/ui/proc-macro/issue-83510.stderr        |   8 +-
 tests/ui/proc-macro/issue-91800.rs            |   1 +
 tests/ui/proc-macro/issue-91800.stderr        |  14 +--
 tests/ui/proc-macro/lifetimes-rpass.rs        |   1 +
 tests/ui/proc-macro/lints_in_proc_macros.rs   |   1 +
 .../ui/proc-macro/lints_in_proc_macros.stderr |   2 +-
 tests/ui/proc-macro/load-two.rs               |   1 +
 .../proc-macro/macro-crate-multi-decorator.rs |   1 +
 .../proc-macro/macro_rules_edition_from_pm.rs |   1 +
 tests/ui/proc-macro/match-expander.rs         |   1 +
 tests/ui/proc-macro/match-expander.stderr     |   2 +-
 tests/ui/proc-macro/mixed-site-span.rs        |   1 +
 tests/ui/proc-macro/mixed-site-span.stderr    | 104 +++++++++---------
 tests/ui/proc-macro/modify-ast.rs             |   1 +
 tests/ui/proc-macro/parent-source-spans.rs    |   1 +
 .../ui/proc-macro/parent-source-spans.stderr  |  42 +++----
 tests/ui/proc-macro/quote/basic.rs            |   1 +
 tests/ui/proc-macro/span-api-tests.rs         |   1 +
 tests/ui/proc-macro/span-from-proc-macro.rs   |   1 +
 .../ui/proc-macro/span-from-proc-macro.stderr |   8 +-
 tests/ui/proc-macro/weird-hygiene.rs          |   1 +
 tests/ui/proc-macro/weird-hygiene.stderr      |   4 +-
 tests/ui/process/multi-panic.rs               |   1 +
 tests/ui/resolve/prelude-order.rs             |   1 +
 tests/ui/resolve/prelude-order.stderr         |  10 +-
 .../edition-spans.rs                          |   1 +
 tests/ui/runtime/backtrace-debuginfo.rs       |   1 +
 tests/ui/runtime/out-of-stack.rs              |   1 +
 .../suggestions-not-always-applicable.fixed   |   1 +
 .../suggestions-not-always-applicable.rs      |   1 +
 .../rust-2021/reserved-prefixes-via-macro.rs  |   1 +
 .../reserved-guarded-strings-via-macro.rs     |   1 +
 .../unsafe-attributes-from-pm.rs              |   1 +
 .../sanitizer/cfi/transparent-has-regions.rs  |   1 +
 .../issue-111184-cfi-coroutine-witness.rs     |   1 +
 tests/ui/sepcomp/sepcomp-lib-lto.rs           |   1 +
 tests/ui/sepcomp/sepcomp-unwind.rs            |   1 +
 .../ui/simd/intrinsic/generic-arithmetic-2.rs |   1 +
 .../intrinsic/generic-arithmetic-2.stderr     |  56 +++++-----
 tests/ui/simd/intrinsic/generic-elements.rs   |   1 +
 .../ui/simd/intrinsic/generic-elements.stderr |  42 +++----
 tests/ui/simd/masked-load-store-build-fail.rs |   1 +
 .../simd/masked-load-store-build-fail.stderr  |  16 +--
 .../monomorphize-shuffle-index.generic.stderr |   2 +-
 tests/ui/simd/monomorphize-shuffle-index.rs   |   1 +
 tests/ui/simd/not-out-of-bounds.rs            |   1 +
 tests/ui/simd/not-out-of-bounds.stderr        |  18 +--
 .../unit-like-struct-drop-run.rs              |   1 +
 tests/ui/suggestions/issue-61963.rs           |   1 +
 tests/ui/suggestions/issue-61963.stderr       |   6 +-
 tests/ui/suggestions/suggest-ref-macro.rs     |   1 +
 tests/ui/suggestions/suggest-ref-macro.stderr |  12 +-
 .../test-attrs/test-panic-while-printing.rs   |   1 +
 tests/ui/threads-sendsync/task-stderr.rs      |   1 +
 tests/ui/threads-sendsync/unwind-resource.rs  |   1 +
 tests/ui/traits/clone-unwind-rc-cleanup.rs    |   1 +
 ...alid-sugg-for-derive-macro-issue-136343.rs |   1 +
 ...-sugg-for-derive-macro-issue-136343.stderr |   2 +-
 186 files changed, 440 insertions(+), 297 deletions(-)

diff --git a/tests/ui/array-slice-vec/box-of-array-of-drop-1.rs b/tests/ui/array-slice-vec/box-of-array-of-drop-1.rs
index c7c05946c4ca9..5f4e381c983a2 100644
--- a/tests/ui/array-slice-vec/box-of-array-of-drop-1.rs
+++ b/tests/ui/array-slice-vec/box-of-array-of-drop-1.rs
@@ -1,6 +1,7 @@
 //@ run-pass
 //@ needs-unwind
 //@ needs-threads
+//@ ignore-backends: gcc
 
 #![allow(overflowing_literals)]
 
diff --git a/tests/ui/array-slice-vec/box-of-array-of-drop-2.rs b/tests/ui/array-slice-vec/box-of-array-of-drop-2.rs
index 98175a26ec0d1..ea37d3e721264 100644
--- a/tests/ui/array-slice-vec/box-of-array-of-drop-2.rs
+++ b/tests/ui/array-slice-vec/box-of-array-of-drop-2.rs
@@ -1,6 +1,7 @@
 //@ run-pass
 //@ needs-unwind
 //@ needs-threads
+//@ ignore-backends: gcc
 
 #![allow(overflowing_literals)]
 
diff --git a/tests/ui/array-slice-vec/nested-vec-3.rs b/tests/ui/array-slice-vec/nested-vec-3.rs
index 51975743742cf..e3c04ed6f6bf0 100644
--- a/tests/ui/array-slice-vec/nested-vec-3.rs
+++ b/tests/ui/array-slice-vec/nested-vec-3.rs
@@ -1,6 +1,7 @@
 //@ run-pass
 //@ needs-unwind
 //@ needs-threads
+//@ ignore-backends: gcc
 
 #![allow(overflowing_literals)]
 
diff --git a/tests/ui/array-slice-vec/slice-panic-1.rs b/tests/ui/array-slice-vec/slice-panic-1.rs
index a745dff96afc7..d7c1098fa2bda 100644
--- a/tests/ui/array-slice-vec/slice-panic-1.rs
+++ b/tests/ui/array-slice-vec/slice-panic-1.rs
@@ -1,6 +1,7 @@
 //@ run-pass
 //@ needs-unwind
 //@ needs-threads
+//@ ignore-backends: gcc
 
 // Test that if a slicing expr[..] fails, the correct cleanups happen.
 
diff --git a/tests/ui/array-slice-vec/slice-panic-2.rs b/tests/ui/array-slice-vec/slice-panic-2.rs
index 483a4cbe245db..157e716a95d49 100644
--- a/tests/ui/array-slice-vec/slice-panic-2.rs
+++ b/tests/ui/array-slice-vec/slice-panic-2.rs
@@ -1,6 +1,7 @@
 //@ run-pass
 //@ needs-unwind
 //@ needs-threads
+//@ ignore-backends: gcc
 
 // Test that if a slicing expr[..] fails, the correct cleanups happen.
 
diff --git a/tests/ui/asm/global-asm-isnt-really-a-mir-body.rs b/tests/ui/asm/global-asm-isnt-really-a-mir-body.rs
index aef25d057d4ba..94dab4235e093 100644
--- a/tests/ui/asm/global-asm-isnt-really-a-mir-body.rs
+++ b/tests/ui/asm/global-asm-isnt-really-a-mir-body.rs
@@ -18,6 +18,7 @@
 
 //@ build-pass
 //@ needs-asm-support
+//@ ignore-backends: gcc
 
 use std::arch::global_asm;
 
diff --git a/tests/ui/asm/x86_64/goto.rs b/tests/ui/asm/x86_64/goto.rs
index 00a8e588f9673..c1dbce0d1c912 100644
--- a/tests/ui/asm/x86_64/goto.rs
+++ b/tests/ui/asm/x86_64/goto.rs
@@ -1,6 +1,7 @@
 //@ only-x86_64
 //@ run-pass
 //@ needs-asm-support
+//@ ignore-backends: gcc
 
 #![deny(unreachable_code)]
 #![feature(asm_goto_with_outputs)]
diff --git a/tests/ui/asm/x86_64/goto.stderr b/tests/ui/asm/x86_64/goto.stderr
index 78b726b3f3d31..f8f09f32f6cbc 100644
--- a/tests/ui/asm/x86_64/goto.stderr
+++ b/tests/ui/asm/x86_64/goto.stderr
@@ -1,5 +1,5 @@
 warning: unreachable statement
-  --> $DIR/goto.rs:143:9
+  --> $DIR/goto.rs:144:9
    |
 LL | /         asm!(
 LL | |             "jmp {}",
@@ -13,7 +13,7 @@ LL |           unreachable!();
    |           ^^^^^^^^^^^^^^ unreachable statement
    |
 note: the lint level is defined here
-  --> $DIR/goto.rs:133:8
+  --> $DIR/goto.rs:134:8
    |
 LL | #[warn(unreachable_code)]
    |        ^^^^^^^^^^^^^^^^
diff --git a/tests/ui/asm/x86_64/srcloc.rs b/tests/ui/asm/x86_64/srcloc.rs
index 2938bafe5e70c..f4ffa8c5c3b2c 100644
--- a/tests/ui/asm/x86_64/srcloc.rs
+++ b/tests/ui/asm/x86_64/srcloc.rs
@@ -1,6 +1,7 @@
 //@ only-x86_64
 //@ build-fail
 //@ compile-flags: -Ccodegen-units=1
+//@ ignore-backends: gcc
 
 use std::arch::asm;
 
diff --git a/tests/ui/asm/x86_64/srcloc.stderr b/tests/ui/asm/x86_64/srcloc.stderr
index bb4e855163d77..b2079120ec065 100644
--- a/tests/ui/asm/x86_64/srcloc.stderr
+++ b/tests/ui/asm/x86_64/srcloc.stderr
@@ -1,5 +1,5 @@
 error: invalid instruction mnemonic 'invalid_instruction'
-  --> $DIR/srcloc.rs:11:15
+  --> $DIR/srcloc.rs:12:15
    |
 LL |         asm!("invalid_instruction");
    |               ^^^^^^^^^^^^^^^^^^^
@@ -11,7 +11,7 @@ LL |     invalid_instruction
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction'
-  --> $DIR/srcloc.rs:15:13
+  --> $DIR/srcloc.rs:16:13
    |
 LL |             invalid_instruction
    |             ^^^^^^^^^^^^^^^^^^^
@@ -23,7 +23,7 @@ LL |             invalid_instruction
    |             ^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction'
-  --> $DIR/srcloc.rs:20:13
+  --> $DIR/srcloc.rs:21:13
    |
 LL |             invalid_instruction
    |             ^^^^^^^^^^^^^^^^^^^
@@ -35,7 +35,7 @@ LL |             invalid_instruction
    |             ^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction'
-  --> $DIR/srcloc.rs:26:13
+  --> $DIR/srcloc.rs:27:13
    |
 LL |             invalid_instruction
    |             ^^^^^^^^^^^^^^^^^^^
@@ -47,7 +47,7 @@ LL |             invalid_instruction
    |             ^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction'
-  --> $DIR/srcloc.rs:33:13
+  --> $DIR/srcloc.rs:34:13
    |
 LL |             invalid_instruction
    |             ^^^^^^^^^^^^^^^^^^^
@@ -59,7 +59,7 @@ LL |             invalid_instruction
    |             ^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction'
-  --> $DIR/srcloc.rs:38:14
+  --> $DIR/srcloc.rs:39:14
    |
 LL |         asm!(concat!("invalid", "_", "instruction"));
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -71,7 +71,7 @@ LL |     invalid_instruction
    |     ^^^^^^^^^^^^^^^^^^^
 
 warning: scale factor without index register is ignored
-  --> $DIR/srcloc.rs:41:15
+  --> $DIR/srcloc.rs:42:15
    |
 LL |         asm!("movaps %xmm3, (%esi, 2)", options(att_syntax));
    |               ^^^^^^^^^^^^^^^^^^^^^^^
@@ -83,7 +83,7 @@ LL |     movaps %xmm3, (%esi, 2)
    |                          ^
 
 error: invalid instruction mnemonic 'invalid_instruction'
-  --> $DIR/srcloc.rs:45:14
+  --> $DIR/srcloc.rs:46:14
    |
 LL |             "invalid_instruction",
    |              ^^^^^^^^^^^^^^^^^^^
@@ -95,7 +95,7 @@ LL |     invalid_instruction
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction'
-  --> $DIR/srcloc.rs:51:14
+  --> $DIR/srcloc.rs:52:14
    |
 LL |             "invalid_instruction",
    |              ^^^^^^^^^^^^^^^^^^^
@@ -107,7 +107,7 @@ LL | invalid_instruction
    | ^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction'
-  --> $DIR/srcloc.rs:58:14
+  --> $DIR/srcloc.rs:59:14
    |
 LL |             "invalid_instruction",
    |              ^^^^^^^^^^^^^^^^^^^
@@ -119,7 +119,7 @@ LL | invalid_instruction
    | ^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction'
-  --> $DIR/srcloc.rs:65:13
+  --> $DIR/srcloc.rs:66:13
    |
 LL |             concat!("invalid", "_", "instruction"),
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -131,7 +131,7 @@ LL | invalid_instruction
    | ^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction'
-  --> $DIR/srcloc.rs:72:13
+  --> $DIR/srcloc.rs:73:13
    |
 LL |             concat!("invalid", "_", "instruction"),
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -143,7 +143,7 @@ LL | invalid_instruction
    | ^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction1'
-  --> $DIR/srcloc.rs:79:14
+  --> $DIR/srcloc.rs:80:14
    |
 LL |             "invalid_instruction1",
    |              ^^^^^^^^^^^^^^^^^^^^
@@ -155,7 +155,7 @@ LL |     invalid_instruction1
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction2'
-  --> $DIR/srcloc.rs:80:14
+  --> $DIR/srcloc.rs:81:14
    |
 LL |             "invalid_instruction2",
    |              ^^^^^^^^^^^^^^^^^^^^
@@ -167,7 +167,7 @@ LL | invalid_instruction2
    | ^^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction1'
-  --> $DIR/srcloc.rs:86:13
+  --> $DIR/srcloc.rs:87:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction1", "\n",
@@ -182,7 +182,7 @@ LL |     invalid_instruction1
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction2'
-  --> $DIR/srcloc.rs:86:13
+  --> $DIR/srcloc.rs:87:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction1", "\n",
@@ -197,7 +197,7 @@ LL | invalid_instruction2
    | ^^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction1'
-  --> $DIR/srcloc.rs:95:13
+  --> $DIR/srcloc.rs:96:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction1", "\n",
@@ -212,7 +212,7 @@ LL |     invalid_instruction1
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction2'
-  --> $DIR/srcloc.rs:95:13
+  --> $DIR/srcloc.rs:96:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction1", "\n",
@@ -227,7 +227,7 @@ LL | invalid_instruction2
    | ^^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction3'
-  --> $DIR/srcloc.rs:99:13
+  --> $DIR/srcloc.rs:100:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction3", "\n",
@@ -242,7 +242,7 @@ LL | invalid_instruction3
    | ^^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction4'
-  --> $DIR/srcloc.rs:99:13
+  --> $DIR/srcloc.rs:100:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction3", "\n",
@@ -257,7 +257,7 @@ LL | invalid_instruction4
    | ^^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction1'
-  --> $DIR/srcloc.rs:110:13
+  --> $DIR/srcloc.rs:111:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction1", "\n",
@@ -272,7 +272,7 @@ LL |     invalid_instruction1
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction2'
-  --> $DIR/srcloc.rs:110:13
+  --> $DIR/srcloc.rs:111:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction1", "\n",
@@ -287,7 +287,7 @@ LL | invalid_instruction2
    | ^^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction3'
-  --> $DIR/srcloc.rs:114:13
+  --> $DIR/srcloc.rs:115:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction3", "\n",
@@ -302,7 +302,7 @@ LL | invalid_instruction3
    | ^^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction4'
-  --> $DIR/srcloc.rs:114:13
+  --> $DIR/srcloc.rs:115:13
    |
 LL | /             concat!(
 LL | |                 "invalid", "_", "instruction3", "\n",
@@ -317,7 +317,7 @@ LL | invalid_instruction4
    | ^^^^^^^^^^^^^^^^^^^^
 
 error: invalid instruction mnemonic 'invalid_instruction'
-  --> $DIR/srcloc.rs:127:14
+  --> $DIR/srcloc.rs:128:14
    |
 LL |             "invalid_instruction"
    |              ^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/attributes/fn-align-dyn.rs b/tests/ui/attributes/fn-align-dyn.rs
index 3778c75a2caa7..91e2dab65a3cc 100644
--- a/tests/ui/attributes/fn-align-dyn.rs
+++ b/tests/ui/attributes/fn-align-dyn.rs
@@ -1,5 +1,6 @@
 //@ run-pass
 //@ ignore-wasm32 aligning functions is not currently supported on wasm (#143368)
+//@ ignore-backends: gcc
 
 // FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
 #![feature(rustc_attrs)]
diff --git a/tests/ui/attributes/main-removed-2/main.rs b/tests/ui/attributes/main-removed-2/main.rs
index 53696d68ced07..21a05dc4b40be 100644
--- a/tests/ui/attributes/main-removed-2/main.rs
+++ b/tests/ui/attributes/main-removed-2/main.rs
@@ -2,6 +2,7 @@
 //@ proc-macro: tokyo.rs
 //@ compile-flags:--extern tokyo
 //@ edition:2021
+//@ ignore-backends: gcc
 
 use tokyo::main;
 
diff --git a/tests/ui/backtrace/synchronized-panic-handler.rs b/tests/ui/backtrace/synchronized-panic-handler.rs
index 29431ae3c458a..ef7cc1faec8de 100644
--- a/tests/ui/backtrace/synchronized-panic-handler.rs
+++ b/tests/ui/backtrace/synchronized-panic-handler.rs
@@ -4,6 +4,7 @@
 //@ exec-env:RUST_BACKTRACE=0
 //@ needs-threads
 //@ needs-unwind
+//@ ignore-backends: gcc
 use std::thread;
 const PANIC_MESSAGE: &str = "oops oh no woe is me";
 
diff --git a/tests/ui/backtrace/synchronized-panic-handler.run.stderr b/tests/ui/backtrace/synchronized-panic-handler.run.stderr
index c604d49c193c5..5296a0d39ff30 100644
--- a/tests/ui/backtrace/synchronized-panic-handler.run.stderr
+++ b/tests/ui/backtrace/synchronized-panic-handler.run.stderr
@@ -1,7 +1,7 @@
 
-thread '<unnamed>' ($TID) panicked at $DIR/synchronized-panic-handler.rs:11:5:
+thread '<unnamed>' ($TID) panicked at $DIR/synchronized-panic-handler.rs:12:5:
 oops oh no woe is me
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 
-thread '<unnamed>' ($TID) panicked at $DIR/synchronized-panic-handler.rs:11:5:
+thread '<unnamed>' ($TID) panicked at $DIR/synchronized-panic-handler.rs:12:5:
 oops oh no woe is me
diff --git a/tests/ui/box/unit/unwind-unique.rs b/tests/ui/box/unit/unwind-unique.rs
index 1da55c45ee969..ed549f50a740a 100644
--- a/tests/ui/box/unit/unwind-unique.rs
+++ b/tests/ui/box/unit/unwind-unique.rs
@@ -1,6 +1,7 @@
 //@ run-pass
 //@ needs-unwind
 //@ needs-threads
+//@ ignore-backends: gcc
 
 use std::thread;
 
diff --git a/tests/ui/c-variadic/inherent-method.rs b/tests/ui/c-variadic/inherent-method.rs
index 537bae7b3f0f4..c5256aaa1fea3 100644
--- a/tests/ui/c-variadic/inherent-method.rs
+++ b/tests/ui/c-variadic/inherent-method.rs
@@ -1,4 +1,5 @@
 //@ run-pass
+//@ ignore-backends: gcc
 #![feature(c_variadic)]
 
 #[repr(transparent)]
diff --git a/tests/ui/c-variadic/trait-method.rs b/tests/ui/c-variadic/trait-method.rs
index 97da0706a3a18..876a303f53ba5 100644
--- a/tests/ui/c-variadic/trait-method.rs
+++ b/tests/ui/c-variadic/trait-method.rs
@@ -1,4 +1,5 @@
 //@ run-pass
+//@ ignore-backends: gcc
 #![feature(c_variadic)]
 
 #[repr(transparent)]
diff --git a/tests/ui/c-variadic/valid.rs b/tests/ui/c-variadic/valid.rs
index 5a0b32026dc7a..8b42eb4932906 100644
--- a/tests/ui/c-variadic/valid.rs
+++ b/tests/ui/c-variadic/valid.rs
@@ -1,4 +1,5 @@
 //@ run-pass
+//@ ignore-backends: gcc
 #![feature(c_variadic)]
 
 // In rust (and C23 and above) `...` can be the only argument.
diff --git a/tests/ui/cfg/assume-incomplete-release/assume-incomplete.rs b/tests/ui/cfg/assume-incomplete-release/assume-incomplete.rs
index cafb7389e29fa..2ca004d9a906d 100644
--- a/tests/ui/cfg/assume-incomplete-release/assume-incomplete.rs
+++ b/tests/ui/cfg/assume-incomplete-release/assume-incomplete.rs
@@ -2,6 +2,7 @@
 //@ proc-macro: ver-cfg-rel.rs
 //@ revisions: assume no_assume
 //@ [assume]compile-flags: -Z assume-incomplete-release
+//@ ignore-backends: gcc
 
 #![feature(cfg_version)]
 
diff --git a/tests/ui/codegen/issue-82833-slice-miscompile.rs b/tests/ui/codegen/issue-82833-slice-miscompile.rs
index 32eac923a6361..e0cb871662967 100644
--- a/tests/ui/codegen/issue-82833-slice-miscompile.rs
+++ b/tests/ui/codegen/issue-82833-slice-miscompile.rs
@@ -1,5 +1,6 @@
 //@ run-pass
 //@ compile-flags: -Ccodegen-units=1 -Cllvm-args=--inline-threshold=0 -Clink-dead-code -Copt-level=0 -Cdebuginfo=2
+//@ ignore-backends: gcc
 
 // Make sure LLVM does not miscompile this.
 
diff --git a/tests/ui/codegen/llvm-args-invalid-flag.rs b/tests/ui/codegen/llvm-args-invalid-flag.rs
index a8fa55a220a58..f88a7101abda1 100644
--- a/tests/ui/codegen/llvm-args-invalid-flag.rs
+++ b/tests/ui/codegen/llvm-args-invalid-flag.rs
@@ -1,6 +1,7 @@
 //@ compile-flags: -Cllvm-args=-not-a-real-llvm-arg
 //@ normalize-stderr: "--help" -> "-help"
 //@ normalize-stderr: "\n(\n|.)*" -> ""
+//@ ignore-backends: gcc
 
 // I'm seeing "--help" locally, but "-help" in CI, so I'm normalizing it to just "-help".
 
diff --git a/tests/ui/codegen/remark-flag-functionality.rs b/tests/ui/codegen/remark-flag-functionality.rs
index 797c55ba830c1..4cfc5f5c8ec19 100644
--- a/tests/ui/codegen/remark-flag-functionality.rs
+++ b/tests/ui/codegen/remark-flag-functionality.rs
@@ -17,6 +17,7 @@
 
 //@ dont-check-compiler-stderr
 //@ dont-require-annotations: NOTE
+//@ ignore-backends: gcc
 
 #[no_mangle]
 #[inline(never)]
diff --git a/tests/ui/codegen/virtual-function-elimination.rs b/tests/ui/codegen/virtual-function-elimination.rs
index 3cbeb1293e50a..90fc86f95c5c6 100644
--- a/tests/ui/codegen/virtual-function-elimination.rs
+++ b/tests/ui/codegen/virtual-function-elimination.rs
@@ -2,6 +2,7 @@
 //@ compile-flags: -Zvirtual-function-elimination=true -Clto=true
 //@ only-x86_64
 //@ no-prefer-dynamic
+//@ ignore-backends: gcc
 
 // issue #123955
 pub fn test0() {
diff --git a/tests/ui/coroutine/gen_block_panic.rs b/tests/ui/coroutine/gen_block_panic.rs
index b6362d5046a3b..5417ed583e8ca 100644
--- a/tests/ui/coroutine/gen_block_panic.rs
+++ b/tests/ui/coroutine/gen_block_panic.rs
@@ -1,6 +1,7 @@
 //@ edition: 2024
 //@ run-pass
 //@ needs-unwind
+//@ ignore-backends: gcc
 #![feature(gen_blocks)]
 
 fn main() {
diff --git a/tests/ui/coroutine/gen_block_panic.stderr b/tests/ui/coroutine/gen_block_panic.stderr
index a43c9e03691a5..d0a146e7baf9a 100644
--- a/tests/ui/coroutine/gen_block_panic.stderr
+++ b/tests/ui/coroutine/gen_block_panic.stderr
@@ -1,5 +1,5 @@
 warning: unreachable statement
-  --> $DIR/gen_block_panic.rs:10:9
+  --> $DIR/gen_block_panic.rs:11:9
    |
 LL |         panic!("foo");
    |         ------------- any code following this expression is unreachable
diff --git a/tests/ui/delegation/fn-header-variadic.rs b/tests/ui/delegation/fn-header-variadic.rs
index 2c83d64d0b3ff..346c49f08e5d3 100644
--- a/tests/ui/delegation/fn-header-variadic.rs
+++ b/tests/ui/delegation/fn-header-variadic.rs
@@ -1,4 +1,5 @@
 //@ aux-crate:fn_header_aux=fn-header-aux.rs
+//@ ignore-backends: gcc
 
 #![feature(c_variadic)]
 #![feature(fn_delegation)]
diff --git a/tests/ui/delegation/fn-header-variadic.stderr b/tests/ui/delegation/fn-header-variadic.stderr
index 688a965fb4d5c..c2d7672939fcc 100644
--- a/tests/ui/delegation/fn-header-variadic.stderr
+++ b/tests/ui/delegation/fn-header-variadic.stderr
@@ -1,5 +1,5 @@
 error: delegation to C-variadic functions is not allowed
-  --> $DIR/fn-header-variadic.rs:11:17
+  --> $DIR/fn-header-variadic.rs:12:17
    |
 LL |     pub unsafe extern "C" fn variadic_fn(n: usize, mut args: ...) {}
    |     ------------------------------------------------------------- callee defined here
@@ -8,7 +8,7 @@ LL | reuse to_reuse::variadic_fn;
    |                 ^^^^^^^^^^^
 
 error: delegation to C-variadic functions is not allowed
-  --> $DIR/fn-header-variadic.rs:13:22
+  --> $DIR/fn-header-variadic.rs:14:22
    |
 LL | reuse fn_header_aux::variadic_fn_extern;
    |                      ^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/drop/drop-trait-enum.rs b/tests/ui/drop/drop-trait-enum.rs
index 5a88d959ec6fa..efb6b2a912ab1 100644
--- a/tests/ui/drop/drop-trait-enum.rs
+++ b/tests/ui/drop/drop-trait-enum.rs
@@ -4,6 +4,7 @@
 #![allow(unused_variables)]
 //@ needs-threads
 //@ needs-unwind
+//@ ignore-backends: gcc
 
 use std::thread;
 use std::sync::mpsc::{channel, Sender};
diff --git a/tests/ui/drop/terminate-in-initializer.rs b/tests/ui/drop/terminate-in-initializer.rs
index 24ec39fe09638..5dd8fe43c71e3 100644
--- a/tests/ui/drop/terminate-in-initializer.rs
+++ b/tests/ui/drop/terminate-in-initializer.rs
@@ -1,6 +1,7 @@
 //@ run-pass
 //@ needs-unwind
 //@ needs-threads
+//@ ignore-backends: gcc
 
 // Issue #787
 // Don't try to clean up uninitialized locals
diff --git a/tests/ui/explicit-tail-calls/callee_is_track_caller.rs b/tests/ui/explicit-tail-calls/callee_is_track_caller.rs
index b85b335844b02..1246a3801fc36 100644
--- a/tests/ui/explicit-tail-calls/callee_is_track_caller.rs
+++ b/tests/ui/explicit-tail-calls/callee_is_track_caller.rs
@@ -1,5 +1,6 @@
 //@ run-pass
 //@ ignore-pass
+//@ ignore-backends: gcc
 #![expect(incomplete_features)]
 #![feature(explicit_tail_calls)]
 
diff --git a/tests/ui/explicit-tail-calls/callee_is_track_caller.stderr b/tests/ui/explicit-tail-calls/callee_is_track_caller.stderr
index e1a251d156f76..020a0542a57fd 100644
--- a/tests/ui/explicit-tail-calls/callee_is_track_caller.stderr
+++ b/tests/ui/explicit-tail-calls/callee_is_track_caller.stderr
@@ -1,5 +1,5 @@
 warning: tail calling a function marked with `#[track_caller]` has no special effect
-  --> $DIR/callee_is_track_caller.rs:7:12
+  --> $DIR/callee_is_track_caller.rs:8:12
    |
 LL |     become b(x);
    |            ^^^^
diff --git a/tests/ui/explicit-tail-calls/callee_is_track_caller_polymorphic.rs b/tests/ui/explicit-tail-calls/callee_is_track_caller_polymorphic.rs
index 33384de83eb74..51688897b4001 100644
--- a/tests/ui/explicit-tail-calls/callee_is_track_caller_polymorphic.rs
+++ b/tests/ui/explicit-tail-calls/callee_is_track_caller_polymorphic.rs
@@ -1,5 +1,6 @@
 //@ run-pass
 //@ ignore-pass
+//@ ignore-backends: gcc
 #![expect(incomplete_features)]
 #![feature(explicit_tail_calls)]
 
diff --git a/tests/ui/explicit-tail-calls/callee_is_track_caller_polymorphic.stderr b/tests/ui/explicit-tail-calls/callee_is_track_caller_polymorphic.stderr
index 5a1c40509ad3a..7b4c144acffa5 100644
--- a/tests/ui/explicit-tail-calls/callee_is_track_caller_polymorphic.stderr
+++ b/tests/ui/explicit-tail-calls/callee_is_track_caller_polymorphic.stderr
@@ -1,5 +1,5 @@
 warning: tail calling a function marked with `#[track_caller]` has no special effect
-  --> $DIR/callee_is_track_caller_polymorphic.rs:7:12
+  --> $DIR/callee_is_track_caller_polymorphic.rs:8:12
    |
 LL |     become T::f();
    |            ^^^^^^
diff --git a/tests/ui/explicit-tail-calls/drop-order.rs b/tests/ui/explicit-tail-calls/drop-order.rs
index 58e1afbdf0c51..ff6e2f09f57ce 100644
--- a/tests/ui/explicit-tail-calls/drop-order.rs
+++ b/tests/ui/explicit-tail-calls/drop-order.rs
@@ -1,4 +1,5 @@
 //@ run-pass
+//@ ignore-backends: gcc
 #![expect(incomplete_features)]
 #![feature(explicit_tail_calls)]
 use std::cell::RefCell;
diff --git a/tests/ui/explicit-tail-calls/indexer.rs b/tests/ui/explicit-tail-calls/indexer.rs
index 5644506b2f584..c26d9774ce780 100644
--- a/tests/ui/explicit-tail-calls/indexer.rs
+++ b/tests/ui/explicit-tail-calls/indexer.rs
@@ -1,4 +1,5 @@
 //@ run-pass
+//@ ignore-backends: gcc
 // Indexing taken from
 // https://github.com/phi-go/rfcs/blob/guaranteed-tco/text%2F0000-explicit-tail-calls.md#tail-call-elimination
 // no other test has utilized the "function table"
diff --git a/tests/ui/explicit-tail-calls/recursion-etc.rs b/tests/ui/explicit-tail-calls/recursion-etc.rs
index 8c89ceb7869aa..c22401d23799d 100644
--- a/tests/ui/explicit-tail-calls/recursion-etc.rs
+++ b/tests/ui/explicit-tail-calls/recursion-etc.rs
@@ -1,4 +1,5 @@
 //@ run-pass
+//@ ignore-backends: gcc
 #![expect(incomplete_features)]
 #![feature(explicit_tail_calls)]
 
diff --git a/tests/ui/extern/extern-types-field-offset.rs b/tests/ui/extern/extern-types-field-offset.rs
index 035f063cd502c..7a5f36da20917 100644
--- a/tests/ui/extern/extern-types-field-offset.rs
+++ b/tests/ui/extern/extern-types-field-offset.rs
@@ -2,6 +2,7 @@
 //@ check-run-results
 //@ exec-env:RUST_BACKTRACE=0
 //@ normalize-stderr: "(core/src/panicking\.rs):[0-9]+:[0-9]+" -> "$1:$$LINE:$$COL"
+//@ ignore-backends: gcc
 #![feature(extern_types)]
 
 extern "C" {
diff --git a/tests/ui/extern/issue-64655-allow-unwind-when-calling-panic-directly.rs b/tests/ui/extern/issue-64655-allow-unwind-when-calling-panic-directly.rs
index 1cd52b70315c1..4d0afa1cdfa64 100644
--- a/tests/ui/extern/issue-64655-allow-unwind-when-calling-panic-directly.rs
+++ b/tests/ui/extern/issue-64655-allow-unwind-when-calling-panic-directly.rs
@@ -21,6 +21,7 @@
 //@[no]compile-flags: -C lto=no
 //@[thin]compile-flags: -C lto=thin
 //@[fat]compile-flags: -C lto=fat
+//@ ignore-backends: gcc
 
 #![feature(panic_internals)]
 
diff --git a/tests/ui/extern/issue-64655-extern-rust-must-allow-unwind.rs b/tests/ui/extern/issue-64655-extern-rust-must-allow-unwind.rs
index a44eb3828d0a9..1fc3409c1f900 100644
--- a/tests/ui/extern/issue-64655-extern-rust-must-allow-unwind.rs
+++ b/tests/ui/extern/issue-64655-extern-rust-must-allow-unwind.rs
@@ -48,6 +48,7 @@
 //@[fat1]compile-flags: -C opt-level=1 -C lto=fat
 //@[fat2]compile-flags: -C opt-level=2 -C lto=fat
 //@[fat3]compile-flags: -C opt-level=3 -C lto=fat
+//@ ignore-backends: gcc
 
 fn main() {
     use std::sync::atomic::{AtomicUsize, Ordering};
diff --git a/tests/ui/fmt/format-args-capture-from-pm-first-arg-macro.rs b/tests/ui/fmt/format-args-capture-from-pm-first-arg-macro.rs
index 26d483e43ae50..794b51c7a8a25 100644
--- a/tests/ui/fmt/format-args-capture-from-pm-first-arg-macro.rs
+++ b/tests/ui/fmt/format-args-capture-from-pm-first-arg-macro.rs
@@ -1,4 +1,5 @@
 //@ proc-macro: format-string-proc-macro.rs
+//@ ignore-backends: gcc
 
 extern crate format_string_proc_macro;
 
diff --git a/tests/ui/fmt/format-args-capture-from-pm-first-arg-macro.stderr b/tests/ui/fmt/format-args-capture-from-pm-first-arg-macro.stderr
index e7ed2a76e6af1..c341c6ee4c513 100644
--- a/tests/ui/fmt/format-args-capture-from-pm-first-arg-macro.stderr
+++ b/tests/ui/fmt/format-args-capture-from-pm-first-arg-macro.stderr
@@ -1,5 +1,5 @@
 error: there is no argument named `x`
-  --> $DIR/format-args-capture-from-pm-first-arg-macro.rs:6:5
+  --> $DIR/format-args-capture-from-pm-first-arg-macro.rs:7:5
    |
 LL |     format_string_proc_macro::bad_format_args_captures!();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/frontmatter/proc-macro-observer.rs b/tests/ui/frontmatter/proc-macro-observer.rs
index 6c4c8c572897e..5237a0e982a6f 100644
--- a/tests/ui/frontmatter/proc-macro-observer.rs
+++ b/tests/ui/frontmatter/proc-macro-observer.rs
@@ -1,6 +1,7 @@
 //@ check-pass
 //@ proc-macro: makro.rs
 //@ edition: 2021
+//@ ignore-backends: gcc
 
 // Check that a proc-macro doesn't try to parse frontmatter and instead treats
 // it as a regular Rust token sequence. See `auxiliary/makro.rs` for details.
diff --git a/tests/ui/hygiene/issue-77523-def-site-async-await.rs b/tests/ui/hygiene/issue-77523-def-site-async-await.rs
index ad6bd5e0b78bc..0a279682b71bb 100644
--- a/tests/ui/hygiene/issue-77523-def-site-async-await.rs
+++ b/tests/ui/hygiene/issue-77523-def-site-async-await.rs
@@ -1,5 +1,6 @@
 //@ build-pass
 //@ aux-build:def-site-async-await.rs
+//@ ignore-backends: gcc
 
 // Regression test for issue #77523
 // Tests that we don't ICE when an unusual combination
diff --git a/tests/ui/impl-trait/precise-capturing/external-macro.rs b/tests/ui/impl-trait/precise-capturing/external-macro.rs
index 9d4d8a1bb119a..1342ecd58dcf2 100644
--- a/tests/ui/impl-trait/precise-capturing/external-macro.rs
+++ b/tests/ui/impl-trait/precise-capturing/external-macro.rs
@@ -6,6 +6,7 @@
 //@ aux-crate: no_use_macro=no-use-macro.rs
 //@ edition: 2024
 //@ check-pass
+//@ ignore-backends: gcc
 
 no_use_pm::pm_rpit!{}
 
diff --git a/tests/ui/invalid-compile-flags/invalid-llvm-passes.rs b/tests/ui/invalid-compile-flags/invalid-llvm-passes.rs
index 832821c9c883f..2ed0014f8b0ef 100644
--- a/tests/ui/invalid-compile-flags/invalid-llvm-passes.rs
+++ b/tests/ui/invalid-compile-flags/invalid-llvm-passes.rs
@@ -1,5 +1,6 @@
 //@ build-fail
 //@ compile-flags: -Cpasses=unknown-pass
+//@ ignore-backends: gcc
 
 fn main() {}
 
diff --git a/tests/ui/issues/issue-25089.rs b/tests/ui/issues/issue-25089.rs
index 929738c3e794d..63fdf64cea946 100644
--- a/tests/ui/issues/issue-25089.rs
+++ b/tests/ui/issues/issue-25089.rs
@@ -1,6 +1,7 @@
 //@ run-pass
 //@ needs-unwind
 //@ needs-threads
+//@ ignore-backends: gcc
 
 use std::thread;
 
diff --git a/tests/ui/issues/issue-26655.rs b/tests/ui/issues/issue-26655.rs
index 416472b0b269e..32c4b33a8c967 100644
--- a/tests/ui/issues/issue-26655.rs
+++ b/tests/ui/issues/issue-26655.rs
@@ -1,6 +1,7 @@
 //@ run-pass
 //@ needs-unwind
 //@ needs-threads
+//@ ignore-backends: gcc
 
 // Check that the destructors of simple enums are run on unwinding
 
diff --git a/tests/ui/issues/issue-29485.rs b/tests/ui/issues/issue-29485.rs
index a44bcd49c6a9c..8e6436cb11e34 100644
--- a/tests/ui/issues/issue-29485.rs
+++ b/tests/ui/issues/issue-29485.rs
@@ -3,6 +3,7 @@
 //@ aux-build:issue-29485.rs
 //@ needs-unwind
 //@ needs-threads
+//@ ignore-backends: gcc
 
 #[feature(recover)]
 
diff --git a/tests/ui/issues/issue-30018-panic.rs b/tests/ui/issues/issue-30018-panic.rs
index 591848b6f7b4e..09b832bb59d02 100644
--- a/tests/ui/issues/issue-30018-panic.rs
+++ b/tests/ui/issues/issue-30018-panic.rs
@@ -6,6 +6,7 @@
 
 //@ needs-unwind
 //@ needs-threads
+//@ ignore-backends: gcc
 
 struct Foo;
 
diff --git a/tests/ui/issues/issue-44056.rs b/tests/ui/issues/issue-44056.rs
index 12e4f018466f0..37d7b00cf7f0e 100644
--- a/tests/ui/issues/issue-44056.rs
+++ b/tests/ui/issues/issue-44056.rs
@@ -2,5 +2,6 @@
 //@ only-x86_64
 //@ no-prefer-dynamic
 //@ compile-flags: -Ctarget-feature=+avx -Clto
+//@ ignore-backends: gcc
 
 fn main() {}
diff --git a/tests/ui/issues/issue-68696-catch-during-unwind.rs b/tests/ui/issues/issue-68696-catch-during-unwind.rs
index 80d63b0cde705..655879e186929 100644
--- a/tests/ui/issues/issue-68696-catch-during-unwind.rs
+++ b/tests/ui/issues/issue-68696-catch-during-unwind.rs
@@ -4,6 +4,7 @@
 // entering the catch_unwind.
 //
 //@ run-pass
+//@ ignore-backends: gcc
 
 use std::panic::catch_unwind;
 
diff --git a/tests/ui/linkage-attr/common-linkage-non-zero-init.rs b/tests/ui/linkage-attr/common-linkage-non-zero-init.rs
index e5de08a7a28bb..512616251c2f7 100644
--- a/tests/ui/linkage-attr/common-linkage-non-zero-init.rs
+++ b/tests/ui/linkage-attr/common-linkage-non-zero-init.rs
@@ -3,6 +3,7 @@
 //@ known-bug: #109681
 //@ ignore-wasm32 this appears to SIGABRT on wasm, not fail cleanly
 //@ compile-flags: -Z verify-llvm-ir
+//@ ignore-backends: gcc
 
 // This test verifies that we continue to hit the LLVM error for common linkage with non-zero
 // initializers, since it generates invalid LLVM IR.
diff --git a/tests/ui/linkage-attr/raw-dylib/elf/glibc-x86_64.rs b/tests/ui/linkage-attr/raw-dylib/elf/glibc-x86_64.rs
index 57492ed2d0e1f..62d352facd178 100644
--- a/tests/ui/linkage-attr/raw-dylib/elf/glibc-x86_64.rs
+++ b/tests/ui/linkage-attr/raw-dylib/elf/glibc-x86_64.rs
@@ -3,6 +3,7 @@
 //@ run-pass
 //@ compile-flags: -Cpanic=abort
 //@ edition: 2024
+//@ ignore-backends: gcc
 
 #![allow(incomplete_features)]
 #![feature(raw_dylib_elf)]
diff --git a/tests/ui/linking/no-gc-encapsulation-symbols.rs b/tests/ui/linking/no-gc-encapsulation-symbols.rs
index 36d69969199ce..c60f35b55eb2f 100644
--- a/tests/ui/linking/no-gc-encapsulation-symbols.rs
+++ b/tests/ui/linking/no-gc-encapsulation-symbols.rs
@@ -5,6 +5,7 @@
 //
 //@ build-pass
 //@ only-x86_64-unknown-linux-gnu
+//@ ignore-backends: gcc
 
 unsafe extern "Rust" {
     // The __start_ section name is magical for the linker,
diff --git a/tests/ui/lint/unused-qualification-in-derive-expansion.rs b/tests/ui/lint/unused-qualification-in-derive-expansion.rs
index b2067e22c4443..bf095c6449d8f 100644
--- a/tests/ui/lint/unused-qualification-in-derive-expansion.rs
+++ b/tests/ui/lint/unused-qualification-in-derive-expansion.rs
@@ -1,5 +1,6 @@
 //@ run-pass
 //@ proc-macro: add-impl.rs
+//@ ignore-backends: gcc
 
 #![forbid(unused_qualifications)]
 
diff --git a/tests/ui/lto/debuginfo-lto-alloc.rs b/tests/ui/lto/debuginfo-lto-alloc.rs
index d6855f8760d52..7c82d978a0753 100644
--- a/tests/ui/lto/debuginfo-lto-alloc.rs
+++ b/tests/ui/lto/debuginfo-lto-alloc.rs
@@ -12,6 +12,7 @@
 //@ compile-flags: --test -C debuginfo=2 -C lto=fat
 //@ no-prefer-dynamic
 //@ incremental
+//@ ignore-backends: gcc
 
 extern crate alloc;
 
diff --git a/tests/ui/lto/debuginfo-lto.rs b/tests/ui/lto/debuginfo-lto.rs
index f189a1df05673..6d8b836235cc5 100644
--- a/tests/ui/lto/debuginfo-lto.rs
+++ b/tests/ui/lto/debuginfo-lto.rs
@@ -7,6 +7,7 @@
 //@ aux-build:debuginfo-lto-aux.rs
 //@ compile-flags: -C lto -g
 //@ no-prefer-dynamic
+//@ ignore-backends: gcc
 
 extern crate debuginfo_lto_aux;
 
diff --git a/tests/ui/lto/dwarf-mixed-versions-lto.rs b/tests/ui/lto/dwarf-mixed-versions-lto.rs
index 900274eb22f44..8ed3afa5e33ae 100644
--- a/tests/ui/lto/dwarf-mixed-versions-lto.rs
+++ b/tests/ui/lto/dwarf-mixed-versions-lto.rs
@@ -7,6 +7,7 @@
 //@ compile-flags: -C lto -g -Cdwarf-version=5
 //@ no-prefer-dynamic
 //@ build-pass
+//@ ignore-backends: gcc
 
 extern crate dwarf_mixed_versions_lto_aux;
 
diff --git a/tests/ui/lto/fat-lto.rs b/tests/ui/lto/fat-lto.rs
index 73d6801a25acb..fe00d7feb3773 100644
--- a/tests/ui/lto/fat-lto.rs
+++ b/tests/ui/lto/fat-lto.rs
@@ -1,6 +1,7 @@
 //@ run-pass
 //@ compile-flags: -Clto=fat
 //@ no-prefer-dynamic
+//@ ignore-backends: gcc
 
 fn main() {
     println!("hello!");
diff --git a/tests/ui/lto/issue-100772.rs b/tests/ui/lto/issue-100772.rs
index 9468e20894ace..e07d44e3be880 100644
--- a/tests/ui/lto/issue-100772.rs
+++ b/tests/ui/lto/issue-100772.rs
@@ -3,6 +3,7 @@
 //@ compile-flags: -Ccodegen-units=1 -Clto -Ctarget-feature=-crt-static -Zsanitizer=cfi -C unsafe-allow-abi-mismatch=sanitizer
 //@ no-prefer-dynamic
 //@ only-x86_64-unknown-linux-gnu
+//@ ignore-backends: gcc
 
 #![feature(allocator_api)]
 
diff --git a/tests/ui/lto/lto-duplicate-symbols.rs b/tests/ui/lto/lto-duplicate-symbols.rs
index a62ab2e22172b..08465eb0fb27a 100644
--- a/tests/ui/lto/lto-duplicate-symbols.rs
+++ b/tests/ui/lto/lto-duplicate-symbols.rs
@@ -4,6 +4,7 @@
 //@ compile-flags: -C lto
 //@ no-prefer-dynamic
 //@ normalize-stderr: "lto-duplicate-symbols2\.lto_duplicate_symbols2\.[0-9a-zA-Z]+-cgu" -> "lto-duplicate-symbols2.lto_duplicate_symbols2.HASH-cgu"
+//@ ignore-backends: gcc
 extern crate lto_duplicate_symbols1;
 extern crate lto_duplicate_symbols2;
 
diff --git a/tests/ui/lto/lto-many-codegen-units.rs b/tests/ui/lto/lto-many-codegen-units.rs
index fb6636fb81514..6761510e4274d 100644
--- a/tests/ui/lto/lto-many-codegen-units.rs
+++ b/tests/ui/lto/lto-many-codegen-units.rs
@@ -1,6 +1,7 @@
 //@ run-pass
 //@ compile-flags: -C lto -C codegen-units=8
 //@ no-prefer-dynamic
+//@ ignore-backends: gcc
 
 fn main() {
 }
diff --git a/tests/ui/lto/lto-rustc-loads-linker-plugin.rs b/tests/ui/lto/lto-rustc-loads-linker-plugin.rs
index 18e937cb29a62..2be320f0bffca 100644
--- a/tests/ui/lto/lto-rustc-loads-linker-plugin.rs
+++ b/tests/ui/lto/lto-rustc-loads-linker-plugin.rs
@@ -2,6 +2,7 @@
 //@ aux-build:lto-rustc-loads-linker-plugin.rs
 //@ run-pass
 //@ no-prefer-dynamic
+//@ ignore-backends: gcc
 
 // This test ensures that if a dependency was compiled with
 // `-Clinker-plugin-lto` then we can compile with `-Clto` and still link against
diff --git a/tests/ui/lto/lto-still-runs-thread-dtors.rs b/tests/ui/lto/lto-still-runs-thread-dtors.rs
index 900368496ebde..9a97677773cca 100644
--- a/tests/ui/lto/lto-still-runs-thread-dtors.rs
+++ b/tests/ui/lto/lto-still-runs-thread-dtors.rs
@@ -2,6 +2,7 @@
 //@ compile-flags: -C lto
 //@ no-prefer-dynamic
 //@ needs-threads
+//@ ignore-backends: gcc
 
 // FIXME(static_mut_refs): this could use an atomic
 #![allow(static_mut_refs)]
diff --git a/tests/ui/macros/same-sequence-span.rs b/tests/ui/macros/same-sequence-span.rs
index dfaf669a769a6..9fae847a4e2fa 100644
--- a/tests/ui/macros/same-sequence-span.rs
+++ b/tests/ui/macros/same-sequence-span.rs
@@ -1,4 +1,5 @@
 //@ proc-macro: proc_macro_sequence.rs
+//@ ignore-backends: gcc
 
 // Regression test for issue #62831: Check that multiple sequences with the same span in the
 // left-hand side of a macro definition behave as if they had unique spans, and in particular that
diff --git a/tests/ui/macros/same-sequence-span.stderr b/tests/ui/macros/same-sequence-span.stderr
index 34df201f5a5c7..1ca89b6b595c8 100644
--- a/tests/ui/macros/same-sequence-span.stderr
+++ b/tests/ui/macros/same-sequence-span.stderr
@@ -1,5 +1,5 @@
 error: `$x:expr` may be followed by `$y:tt`, which is not allowed for `expr` fragments
-  --> $DIR/same-sequence-span.rs:14:18
+  --> $DIR/same-sequence-span.rs:15:18
    |
 LL |     (1 $x:expr $($y:tt,)*
    |                  ^^^^^ not allowed after `expr` fragments
@@ -7,7 +7,7 @@ LL |     (1 $x:expr $($y:tt,)*
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$x:expr` may be followed by `=`, which is not allowed for `expr` fragments
-  --> $DIR/same-sequence-span.rs:15:18
+  --> $DIR/same-sequence-span.rs:16:18
    |
 LL |                $(= $z:tt)*
    |                  ^ not allowed after `expr` fragments
@@ -15,10 +15,10 @@ LL |                $(= $z:tt)*
    = note: allowed there are: `=>`, `,` or `;`
 
 error: `$x:expr` may be followed by `$y:tt`, which is not allowed for `expr` fragments
-  --> $DIR/same-sequence-span.rs:19:1
+  --> $DIR/same-sequence-span.rs:20:1
    |
-LL | | macro_rules! manual_foo {
-   | |__________________________^not allowed after `expr` fragments
+LL | | // `proc_macro_sequence.rs`.
+   | |_____________________________^not allowed after `expr` fragments
 ...
 LL |   proc_macro_sequence::make_foo!();
    |   ^-------------------------------
@@ -30,7 +30,7 @@ LL |   proc_macro_sequence::make_foo!();
    = note: this error originates in the macro `proc_macro_sequence::make_foo` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: `$x:expr` may be followed by `=`, which is not allowed for `expr` fragments
-  --> $DIR/same-sequence-span.rs:19:1
+  --> $DIR/same-sequence-span.rs:20:1
    |
 LL | proc_macro_sequence::make_foo!();
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not allowed after `expr` fragments
diff --git a/tests/ui/numbers-arithmetic/int-abs-overflow.rs b/tests/ui/numbers-arithmetic/int-abs-overflow.rs
index 6397f62d06551..fd4a5a6052b83 100644
--- a/tests/ui/numbers-arithmetic/int-abs-overflow.rs
+++ b/tests/ui/numbers-arithmetic/int-abs-overflow.rs
@@ -2,6 +2,7 @@
 //@ compile-flags: -C overflow-checks=on
 //@ needs-threads
 //@ needs-unwind
+//@ ignore-backends: gcc
 
 use std::thread;
 
diff --git a/tests/ui/numbers-arithmetic/issue-8460.rs b/tests/ui/numbers-arithmetic/issue-8460.rs
index 87867fdc93e41..52df432669f12 100644
--- a/tests/ui/numbers-arithmetic/issue-8460.rs
+++ b/tests/ui/numbers-arithmetic/issue-8460.rs
@@ -2,6 +2,7 @@
 #![allow(unused_must_use)]
 //@ needs-threads
 //@ needs-unwind
+//@ ignore-backends: gcc
 #![feature(rustc_attrs)]
 
 use std::thread;
diff --git a/tests/ui/panic-runtime/lto-unwind.rs b/tests/ui/panic-runtime/lto-unwind.rs
index 93275052f8527..bafc6d5aaa5c5 100644
--- a/tests/ui/panic-runtime/lto-unwind.rs
+++ b/tests/ui/panic-runtime/lto-unwind.rs
@@ -3,6 +3,7 @@
 //@ needs-unwind
 //@ no-prefer-dynamic
 //@ needs-subprocess
+//@ ignore-backends: gcc
 
 use std::process::Command;
 use std::env;
diff --git a/tests/ui/panics/oom-panic-unwind.rs b/tests/ui/panics/oom-panic-unwind.rs
index 5974ad91406f3..4f7939ce60b20 100644
--- a/tests/ui/panics/oom-panic-unwind.rs
+++ b/tests/ui/panics/oom-panic-unwind.rs
@@ -5,6 +5,7 @@
 //@ no-prefer-dynamic
 //@ needs-unwind
 //@ only-linux
+//@ ignore-backends: gcc
 
 use std::hint::black_box;
 use std::mem::forget;
diff --git a/tests/ui/panics/panic-handler-chain-update-hook.rs b/tests/ui/panics/panic-handler-chain-update-hook.rs
index 662ea9e978f70..2ae79ad236ef2 100644
--- a/tests/ui/panics/panic-handler-chain-update-hook.rs
+++ b/tests/ui/panics/panic-handler-chain-update-hook.rs
@@ -3,6 +3,7 @@
 #![allow(stable_features)]
 
 //@ needs-threads
+//@ ignore-backends: gcc
 
 #![feature(std_panic)]
 #![feature(panic_update_hook)]
diff --git a/tests/ui/panics/panic-handler-chain.rs b/tests/ui/panics/panic-handler-chain.rs
index fea71ad9ec4e3..cc591c1d9992d 100644
--- a/tests/ui/panics/panic-handler-chain.rs
+++ b/tests/ui/panics/panic-handler-chain.rs
@@ -1,6 +1,7 @@
 //@ run-pass
 //@ needs-unwind
 //@ needs-threads
+//@ ignore-backends: gcc
 #![allow(stable_features)]
 
 #![feature(std_panic)]
diff --git a/tests/ui/panics/panic-handler-flail-wildly.rs b/tests/ui/panics/panic-handler-flail-wildly.rs
index d42dfd68d9cf8..d5f5195d38121 100644
--- a/tests/ui/panics/panic-handler-flail-wildly.rs
+++ b/tests/ui/panics/panic-handler-flail-wildly.rs
@@ -5,6 +5,7 @@
 #![allow(unused_must_use)]
 
 //@ needs-threads
+//@ ignore-backends: gcc
 
 #![feature(std_panic)]
 
diff --git a/tests/ui/panics/panic-handler-set-twice.rs b/tests/ui/panics/panic-handler-set-twice.rs
index 5f670d5f49298..ca4ed65f5683d 100644
--- a/tests/ui/panics/panic-handler-set-twice.rs
+++ b/tests/ui/panics/panic-handler-set-twice.rs
@@ -6,6 +6,7 @@
 #![feature(std_panic)]
 
 //@ needs-threads
+//@ ignore-backends: gcc
 
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::panic;
diff --git a/tests/ui/panics/panic-in-dtor-drops-fields.rs b/tests/ui/panics/panic-in-dtor-drops-fields.rs
index 38eb6d0acfb81..db07923433752 100644
--- a/tests/ui/panics/panic-in-dtor-drops-fields.rs
+++ b/tests/ui/panics/panic-in-dtor-drops-fields.rs
@@ -4,6 +4,7 @@
 #![allow(non_upper_case_globals)]
 
 //@ needs-threads
+//@ ignore-backends: gcc
 
 use std::thread;
 
diff --git a/tests/ui/panics/panic-recover-propagate.rs b/tests/ui/panics/panic-recover-propagate.rs
index ef6ae4fd7887d..36ca279bdbd25 100644
--- a/tests/ui/panics/panic-recover-propagate.rs
+++ b/tests/ui/panics/panic-recover-propagate.rs
@@ -1,6 +1,7 @@
 //@ run-pass
 //@ needs-unwind
 //@ needs-threads
+//@ ignore-backends: gcc
 
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::panic;
diff --git a/tests/ui/panics/rvalue-cleanup-during-box-panic.rs b/tests/ui/panics/rvalue-cleanup-during-box-panic.rs
index 84c5d85d7e096..03571f111aac0 100644
--- a/tests/ui/panics/rvalue-cleanup-during-box-panic.rs
+++ b/tests/ui/panics/rvalue-cleanup-during-box-panic.rs
@@ -21,6 +21,7 @@
 // scenario worth testing.
 
 //@ needs-threads
+//@ ignore-backends: gcc
 
 use std::thread;
 
diff --git a/tests/ui/panics/unwind-force-no-unwind-tables.rs b/tests/ui/panics/unwind-force-no-unwind-tables.rs
index 2226e4dd03ebc..715f288fff10e 100644
--- a/tests/ui/panics/unwind-force-no-unwind-tables.rs
+++ b/tests/ui/panics/unwind-force-no-unwind-tables.rs
@@ -6,6 +6,7 @@
 //@ needs-unwind
 //@ ignore-windows target requires uwtable
 //@ compile-flags: -C panic=unwind -C force-unwind-tables=n
+//@ ignore-backends: gcc
 
 use std::panic::{self, AssertUnwindSafe};
 
diff --git a/tests/ui/parser/issues/issue-89971-outer-attr-following-inner-attr-ice.rs b/tests/ui/parser/issues/issue-89971-outer-attr-following-inner-attr-ice.rs
index 461890e63e37b..c82efe79e4d0f 100644
--- a/tests/ui/parser/issues/issue-89971-outer-attr-following-inner-attr-ice.rs
+++ b/tests/ui/parser/issues/issue-89971-outer-attr-following-inner-attr-ice.rs
@@ -1,4 +1,5 @@
 //@ proc-macro: issue-89971-outer-attr-following-inner-attr-ice.rs
+//@ ignore-backends: gcc
 
 #[macro_use]
 extern crate issue_89971_outer_attr_following_inner_attr_ice;
diff --git a/tests/ui/parser/issues/issue-89971-outer-attr-following-inner-attr-ice.stderr b/tests/ui/parser/issues/issue-89971-outer-attr-following-inner-attr-ice.stderr
index 51df17c7cc670..392e7d0321f03 100644
--- a/tests/ui/parser/issues/issue-89971-outer-attr-following-inner-attr-ice.stderr
+++ b/tests/ui/parser/issues/issue-89971-outer-attr-following-inner-attr-ice.stderr
@@ -1,5 +1,5 @@
 error: an inner attribute is not permitted in this context
-  --> $DIR/issue-89971-outer-attr-following-inner-attr-ice.rs:11:1
+  --> $DIR/issue-89971-outer-attr-following-inner-attr-ice.rs:12:1
    |
 LL | #![deny(missing_docs)]
    | ^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/parser/macro/unicode-control-codepoints-macros.rs b/tests/ui/parser/macro/unicode-control-codepoints-macros.rs
index 775c50779760a..701e7dfa30a39 100644
--- a/tests/ui/parser/macro/unicode-control-codepoints-macros.rs
+++ b/tests/ui/parser/macro/unicode-control-codepoints-macros.rs
@@ -1,6 +1,7 @@
 // Regression test for #140281
 //@ edition: 2021
 //@ proc-macro: unicode-control.rs
+//@ ignore-backends: gcc
 
 extern crate unicode_control;
 use unicode_control::*;
diff --git a/tests/ui/parser/macro/unicode-control-codepoints-macros.stderr b/tests/ui/parser/macro/unicode-control-codepoints-macros.stderr
index ca813399eac27..22fb1b945c654 100644
--- a/tests/ui/parser/macro/unicode-control-codepoints-macros.stderr
+++ b/tests/ui/parser/macro/unicode-control-codepoints-macros.stderr
@@ -1,5 +1,5 @@
 error: unicode codepoint changing visible direction of text present in doc comment
-  --> $DIR/unicode-control-codepoints-macros.rs:20:9
+  --> $DIR/unicode-control-codepoints-macros.rs:21:9
    |
 LL |         /// �test� RTL in doc in vec
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this doc comment contains invisible unicode text flow control codepoints
@@ -10,7 +10,7 @@ LL |         /// �test� RTL in doc in vec
    = note: `#[deny(text_direction_codepoint_in_literal)]` on by default
 
 error: unicode codepoint changing visible direction of text present in doc comment
-  --> $DIR/unicode-control-codepoints-macros.rs:25:9
+  --> $DIR/unicode-control-codepoints-macros.rs:26:9
    |
 LL | /         /**
 LL | |          * �test� RTL in doc in macro
@@ -22,7 +22,7 @@ LL | |          */
    = note: if you want to keep them but make them visible in your source code, you can escape them: '\u{202e}', '\u{2066}'
 
 error: unicode codepoint changing visible direction of text present in doc comment
-  --> $DIR/unicode-control-codepoints-macros.rs:32:9
+  --> $DIR/unicode-control-codepoints-macros.rs:33:9
    |
 LL | /         /**
 LL | |          * �test� RTL in doc in macro
@@ -34,7 +34,7 @@ LL | |          */
    = note: if you want to keep them but make them visible in your source code, you can escape them: '\u{202e}', '\u{2066}'
 
 error: unicode codepoint changing visible direction of text present in doc comment
-  --> $DIR/unicode-control-codepoints-macros.rs:40:9
+  --> $DIR/unicode-control-codepoints-macros.rs:41:9
    |
 LL |         /// �test� RTL in doc in proc macro
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this doc comment contains invisible unicode text flow control codepoints
@@ -44,7 +44,7 @@ LL |         /// �test� RTL in doc in proc macro
    = note: if you want to keep them but make them visible in your source code, you can escape them: '\u{202e}', '\u{2066}'
 
 error: unicode codepoint changing visible direction of text present in doc comment
-  --> $DIR/unicode-control-codepoints-macros.rs:45:9
+  --> $DIR/unicode-control-codepoints-macros.rs:46:9
    |
 LL |         /// �test� RTL in doc in proc macro
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this doc comment contains invisible unicode text flow control codepoints
diff --git a/tests/ui/parser/tuple-index-suffix-proc-macro.rs b/tests/ui/parser/tuple-index-suffix-proc-macro.rs
index 557c67738d30f..2463897381ec2 100644
--- a/tests/ui/parser/tuple-index-suffix-proc-macro.rs
+++ b/tests/ui/parser/tuple-index-suffix-proc-macro.rs
@@ -3,6 +3,7 @@
 //! Like `tuple-index-suffix.rs`, but exercises the proc-macro interaction.
 
 //@ proc-macro: tuple-index-suffix-proc-macro-aux.rs
+//@ ignore-backends: gcc
 
 extern crate tuple_index_suffix_proc_macro_aux;
 use tuple_index_suffix_proc_macro_aux as aux;
diff --git a/tests/ui/parser/tuple-index-suffix-proc-macro.stderr b/tests/ui/parser/tuple-index-suffix-proc-macro.stderr
index 47d179d355513..a242af5a789f7 100644
--- a/tests/ui/parser/tuple-index-suffix-proc-macro.stderr
+++ b/tests/ui/parser/tuple-index-suffix-proc-macro.stderr
@@ -1,23 +1,23 @@
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix-proc-macro.rs:17:28
+  --> $DIR/tuple-index-suffix-proc-macro.rs:18:28
    |
 LL |     aux::bad_tup_indexing!(0usize);
    |                            ^^^^^^ invalid suffix `usize`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix-proc-macro.rs:19:47
+  --> $DIR/tuple-index-suffix-proc-macro.rs:20:47
    |
 LL |     aux::bad_tup_struct_indexing!(tup_struct, 0isize);
    |                                               ^^^^^^ invalid suffix `isize`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix-proc-macro.rs:24:28
+  --> $DIR/tuple-index-suffix-proc-macro.rs:25:28
    |
 LL |     aux::bad_tup_indexing!(0u8);
    |                            ^^^ invalid suffix `u8`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix-proc-macro.rs:26:47
+  --> $DIR/tuple-index-suffix-proc-macro.rs:27:47
    |
 LL |     aux::bad_tup_struct_indexing!(tup_struct, 0u64);
    |                                               ^^^^ invalid suffix `u64`
diff --git a/tests/ui/proc-macro/add-impl.rs b/tests/ui/proc-macro/add-impl.rs
index 2299f05c2e7fa..645e9321bba04 100644
--- a/tests/ui/proc-macro/add-impl.rs
+++ b/tests/ui/proc-macro/add-impl.rs
@@ -1,5 +1,6 @@
 //@ run-pass
 //@ proc-macro: add-impl.rs
+//@ ignore-backends: gcc
 
 #[macro_use]
 extern crate add_impl;
diff --git a/tests/ui/proc-macro/ambiguous-builtin-attrs-test.rs b/tests/ui/proc-macro/ambiguous-builtin-attrs-test.rs
index 8ee2223822a3c..e580e0784b34e 100644
--- a/tests/ui/proc-macro/ambiguous-builtin-attrs-test.rs
+++ b/tests/ui/proc-macro/ambiguous-builtin-attrs-test.rs
@@ -1,5 +1,6 @@
 //@ proc-macro: builtin-attrs.rs
 //@ compile-flags:--test
+//@ ignore-backends: gcc
 
 #![feature(decl_macro, test)]
 
diff --git a/tests/ui/proc-macro/ambiguous-builtin-attrs-test.stderr b/tests/ui/proc-macro/ambiguous-builtin-attrs-test.stderr
index 346cebf639d17..e5de873cf31f8 100644
--- a/tests/ui/proc-macro/ambiguous-builtin-attrs-test.stderr
+++ b/tests/ui/proc-macro/ambiguous-builtin-attrs-test.stderr
@@ -1,5 +1,5 @@
 error[E0425]: cannot find value `NonExistent` in this scope
-  --> $DIR/ambiguous-builtin-attrs-test.rs:19:5
+  --> $DIR/ambiguous-builtin-attrs-test.rs:20:5
    |
 LL |     NonExistent;
    |     ^^^^^^^^^^^ not found in this scope
diff --git a/tests/ui/proc-macro/ambiguous-builtin-attrs.rs b/tests/ui/proc-macro/ambiguous-builtin-attrs.rs
index edc7748eff3da..63d3c79055ca2 100644
--- a/tests/ui/proc-macro/ambiguous-builtin-attrs.rs
+++ b/tests/ui/proc-macro/ambiguous-builtin-attrs.rs
@@ -1,5 +1,6 @@
 //@ edition:2018
 //@ proc-macro: builtin-attrs.rs
+//@ ignore-backends: gcc
 #![feature(decl_macro)] //~ ERROR `feature` is ambiguous
 
 extern crate builtin_attrs;
diff --git a/tests/ui/proc-macro/ambiguous-builtin-attrs.stderr b/tests/ui/proc-macro/ambiguous-builtin-attrs.stderr
index 0f4ddc065a742..ff7894a41eab0 100644
--- a/tests/ui/proc-macro/ambiguous-builtin-attrs.stderr
+++ b/tests/ui/proc-macro/ambiguous-builtin-attrs.stderr
@@ -1,11 +1,11 @@
 error[E0425]: cannot find value `NonExistent` in this scope
-  --> $DIR/ambiguous-builtin-attrs.rs:34:5
+  --> $DIR/ambiguous-builtin-attrs.rs:35:5
    |
 LL |     NonExistent;
    |     ^^^^^^^^^^^ not found in this scope
 
 error[E0659]: `repr` is ambiguous
-  --> $DIR/ambiguous-builtin-attrs.rs:9:3
+  --> $DIR/ambiguous-builtin-attrs.rs:10:3
    |
 LL | #[repr(C)]
    |   ^^^^ ambiguous name
@@ -13,14 +13,14 @@ LL | #[repr(C)]
    = note: ambiguous because of a name conflict with a builtin attribute
    = note: `repr` could refer to a built-in attribute
 note: `repr` could also refer to the attribute macro imported here
-  --> $DIR/ambiguous-builtin-attrs.rs:6:5
+  --> $DIR/ambiguous-builtin-attrs.rs:7:5
    |
 LL | use builtin_attrs::*;
    |     ^^^^^^^^^^^^^^^^
    = help: use `crate::repr` to refer to this attribute macro unambiguously
 
 error[E0659]: `repr` is ambiguous
-  --> $DIR/ambiguous-builtin-attrs.rs:11:19
+  --> $DIR/ambiguous-builtin-attrs.rs:12:19
    |
 LL | #[cfg_attr(all(), repr(C))]
    |                   ^^^^ ambiguous name
@@ -28,14 +28,14 @@ LL | #[cfg_attr(all(), repr(C))]
    = note: ambiguous because of a name conflict with a builtin attribute
    = note: `repr` could refer to a built-in attribute
 note: `repr` could also refer to the attribute macro imported here
-  --> $DIR/ambiguous-builtin-attrs.rs:6:5
+  --> $DIR/ambiguous-builtin-attrs.rs:7:5
    |
 LL | use builtin_attrs::*;
    |     ^^^^^^^^^^^^^^^^
    = help: use `crate::repr` to refer to this attribute macro unambiguously
 
 error[E0659]: `repr` is ambiguous
-  --> $DIR/ambiguous-builtin-attrs.rs:20:34
+  --> $DIR/ambiguous-builtin-attrs.rs:21:34
    |
 LL | fn non_macro_expanded_location<#[repr(C)] T>() {
    |                                  ^^^^ ambiguous name
@@ -43,14 +43,14 @@ LL | fn non_macro_expanded_location<#[repr(C)] T>() {
    = note: ambiguous because of a name conflict with a builtin attribute
    = note: `repr` could refer to a built-in attribute
 note: `repr` could also refer to the attribute macro imported here
-  --> $DIR/ambiguous-builtin-attrs.rs:6:5
+  --> $DIR/ambiguous-builtin-attrs.rs:7:5
    |
 LL | use builtin_attrs::*;
    |     ^^^^^^^^^^^^^^^^
    = help: use `crate::repr` to refer to this attribute macro unambiguously
 
 error[E0659]: `repr` is ambiguous
-  --> $DIR/ambiguous-builtin-attrs.rs:24:11
+  --> $DIR/ambiguous-builtin-attrs.rs:25:11
    |
 LL |         #[repr(C)]
    |           ^^^^ ambiguous name
@@ -58,14 +58,14 @@ LL |         #[repr(C)]
    = note: ambiguous because of a name conflict with a builtin attribute
    = note: `repr` could refer to a built-in attribute
 note: `repr` could also refer to the attribute macro imported here
-  --> $DIR/ambiguous-builtin-attrs.rs:6:5
+  --> $DIR/ambiguous-builtin-attrs.rs:7:5
    |
 LL | use builtin_attrs::*;
    |     ^^^^^^^^^^^^^^^^
    = help: use `crate::repr` to refer to this attribute macro unambiguously
 
 error[E0659]: `allow` is ambiguous
-  --> $DIR/ambiguous-builtin-attrs.rs:38:3
+  --> $DIR/ambiguous-builtin-attrs.rs:39:3
    |
 LL | #[allow(unused)]
    |   ^^^^^ ambiguous name
@@ -73,14 +73,14 @@ LL | #[allow(unused)]
    = note: ambiguous because of a name conflict with a builtin attribute
    = note: `allow` could refer to a built-in attribute
 note: `allow` could also refer to the built-in attribute imported here
-  --> $DIR/ambiguous-builtin-attrs.rs:37:5
+  --> $DIR/ambiguous-builtin-attrs.rs:38:5
    |
 LL | use deny as allow;
    |     ^^^^^^^^^^^^^
    = help: use `crate::allow` to refer to this built-in attribute unambiguously
 
 error[E0659]: `feature` is ambiguous
-  --> $DIR/ambiguous-builtin-attrs.rs:3:4
+  --> $DIR/ambiguous-builtin-attrs.rs:4:4
    |
 LL | #![feature(decl_macro)]
    |    ^^^^^^^ ambiguous name
@@ -88,20 +88,20 @@ LL | #![feature(decl_macro)]
    = note: ambiguous because of a name conflict with a builtin attribute
    = note: `feature` could refer to a built-in attribute
 note: `feature` could also refer to the attribute macro imported here
-  --> $DIR/ambiguous-builtin-attrs.rs:6:5
+  --> $DIR/ambiguous-builtin-attrs.rs:7:5
    |
 LL | use builtin_attrs::*;
    |     ^^^^^^^^^^^^^^^^
    = help: use `crate::feature` to refer to this attribute macro unambiguously
 
 error[E0517]: attribute should be applied to a struct, enum, or union
-  --> $DIR/ambiguous-builtin-attrs.rs:20:39
+  --> $DIR/ambiguous-builtin-attrs.rs:21:39
    |
 LL | fn non_macro_expanded_location<#[repr(C)] T>() {
    |                                       ^   - not a struct, enum, or union
 
 error[E0517]: attribute should be applied to a struct, enum, or union
-  --> $DIR/ambiguous-builtin-attrs.rs:24:16
+  --> $DIR/ambiguous-builtin-attrs.rs:25:16
    |
 LL |         #[repr(C)]
    |                ^
diff --git a/tests/ui/proc-macro/append-impl.rs b/tests/ui/proc-macro/append-impl.rs
index c0f208460b297..48d21968de0ce 100644
--- a/tests/ui/proc-macro/append-impl.rs
+++ b/tests/ui/proc-macro/append-impl.rs
@@ -1,5 +1,6 @@
 //@ run-pass
 //@ proc-macro: append-impl.rs
+//@ ignore-backends: gcc
 
 #![allow(warnings)]
 
diff --git a/tests/ui/proc-macro/attr-args.rs b/tests/ui/proc-macro/attr-args.rs
index 1d3e0f725d250..4109b450a8ab3 100644
--- a/tests/ui/proc-macro/attr-args.rs
+++ b/tests/ui/proc-macro/attr-args.rs
@@ -1,5 +1,6 @@
 //@ run-pass
 //@ proc-macro: attr-args.rs
+//@ ignore-backends: gcc
 
 #![allow(warnings)]
 
diff --git a/tests/ui/proc-macro/attr-invalid-exprs.rs b/tests/ui/proc-macro/attr-invalid-exprs.rs
index f476858a32ba1..bdfc0587b3b02 100644
--- a/tests/ui/proc-macro/attr-invalid-exprs.rs
+++ b/tests/ui/proc-macro/attr-invalid-exprs.rs
@@ -1,6 +1,7 @@
 //! Attributes producing expressions in invalid locations
 
 //@ proc-macro: attr-stmt-expr.rs
+//@ ignore-backends: gcc
 
 #![feature(proc_macro_hygiene)]
 #![feature(stmt_expr_attributes)]
diff --git a/tests/ui/proc-macro/attr-invalid-exprs.stderr b/tests/ui/proc-macro/attr-invalid-exprs.stderr
index 0d500c871453f..43241e1e6fd5c 100644
--- a/tests/ui/proc-macro/attr-invalid-exprs.stderr
+++ b/tests/ui/proc-macro/attr-invalid-exprs.stderr
@@ -1,11 +1,11 @@
 error: expected expression, found end of macro arguments
-  --> $DIR/attr-invalid-exprs.rs:12:13
+  --> $DIR/attr-invalid-exprs.rs:13:13
    |
 LL |     let _ = #[no_output] "Hello, world!";
    |             ^^^^^^^^^^^^
 
 error: macro expansion ignores `,` and any tokens following
-  --> $DIR/attr-invalid-exprs.rs:15:13
+  --> $DIR/attr-invalid-exprs.rs:16:13
    |
 LL |     let _ = #[duplicate] "Hello, world!";
    |             ^^^^^^^^^^^^ caused by the macro expansion here
@@ -17,7 +17,7 @@ LL |     let _ = #[duplicate]; "Hello, world!";
    |                         +
 
 error: macro expansion ignores `,` and any tokens following
-  --> $DIR/attr-invalid-exprs.rs:24:9
+  --> $DIR/attr-invalid-exprs.rs:25:9
    |
 LL |         #[duplicate]
    |         ^^^^^^^^^^^^ caused by the macro expansion here
diff --git a/tests/ui/proc-macro/attr-on-trait.rs b/tests/ui/proc-macro/attr-on-trait.rs
index e95760a837c05..345653864f841 100644
--- a/tests/ui/proc-macro/attr-on-trait.rs
+++ b/tests/ui/proc-macro/attr-on-trait.rs
@@ -1,5 +1,6 @@
 //@ run-pass
 //@ proc-macro: attr-on-trait.rs
+//@ ignore-backends: gcc
 
 extern crate attr_on_trait;
 
diff --git a/tests/ui/proc-macro/bang-macro.rs b/tests/ui/proc-macro/bang-macro.rs
index 2287e34c5dda9..75f40de242ec9 100644
--- a/tests/ui/proc-macro/bang-macro.rs
+++ b/tests/ui/proc-macro/bang-macro.rs
@@ -1,5 +1,6 @@
 //@ run-pass
 //@ proc-macro: bang-macro.rs
+//@ ignore-backends: gcc
 
 extern crate bang_macro;
 use bang_macro::rewrite;
diff --git a/tests/ui/proc-macro/call-site.rs b/tests/ui/proc-macro/call-site.rs
index 9c285e1ed117a..5de4061b2a948 100644
--- a/tests/ui/proc-macro/call-site.rs
+++ b/tests/ui/proc-macro/call-site.rs
@@ -1,5 +1,6 @@
 //@ check-pass
 //@ proc-macro: call-site.rs
+//@ ignore-backends: gcc
 
 extern crate call_site;
 
diff --git a/tests/ui/proc-macro/count_compound_ops.rs b/tests/ui/proc-macro/count_compound_ops.rs
index 20b0b87817e2f..fe90e7bfbe49a 100644
--- a/tests/ui/proc-macro/count_compound_ops.rs
+++ b/tests/ui/proc-macro/count_compound_ops.rs
@@ -1,5 +1,6 @@
 //@ run-pass
 //@ proc-macro: count_compound_ops.rs
+//@ ignore-backends: gcc
 
 extern crate count_compound_ops;
 use count_compound_ops::count_compound_ops;
diff --git a/tests/ui/proc-macro/derive-bad.rs b/tests/ui/proc-macro/derive-bad.rs
index 9b237c731dbe4..9b9a2bc33c946 100644
--- a/tests/ui/proc-macro/derive-bad.rs
+++ b/tests/ui/proc-macro/derive-bad.rs
@@ -1,4 +1,5 @@
 //@ proc-macro: derive-bad.rs
+//@ ignore-backends: gcc
 
 #[macro_use]
 extern crate derive_bad;
diff --git a/tests/ui/proc-macro/derive-bad.stderr b/tests/ui/proc-macro/derive-bad.stderr
index 43e97f40ba884..8a252e826efff 100644
--- a/tests/ui/proc-macro/derive-bad.stderr
+++ b/tests/ui/proc-macro/derive-bad.stderr
@@ -1,5 +1,5 @@
 error: expected `:`, found `}`
-  --> $DIR/derive-bad.rs:6:10
+  --> $DIR/derive-bad.rs:7:10
    |
 LL | #[derive(A)]
    |          ^
@@ -10,13 +10,13 @@ LL | #[derive(A)]
    = note: this error originates in the derive macro `A` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: proc-macro derive produced unparsable tokens
-  --> $DIR/derive-bad.rs:6:10
+  --> $DIR/derive-bad.rs:7:10
    |
 LL | #[derive(A)]
    |          ^
 
 error[E0428]: the name `A` is defined multiple times
-  --> $DIR/derive-bad.rs:9:1
+  --> $DIR/derive-bad.rs:10:1
    |
 LL | #[derive(A)]
    |          - previous definition of the type `A` here
diff --git a/tests/ui/proc-macro/derive-helper-shadowing.rs b/tests/ui/proc-macro/derive-helper-shadowing.rs
index ee883be33526c..5ddd914d1026c 100644
--- a/tests/ui/proc-macro/derive-helper-shadowing.rs
+++ b/tests/ui/proc-macro/derive-helper-shadowing.rs
@@ -1,6 +1,7 @@
 //@ edition:2018
 //@ proc-macro: test-macros.rs
 //@ proc-macro: derive-helper-shadowing.rs
+//@ ignore-backends: gcc
 
 #[macro_use]
 extern crate test_macros;
diff --git a/tests/ui/proc-macro/derive-helper-shadowing.stderr b/tests/ui/proc-macro/derive-helper-shadowing.stderr
index 2e4ddd19b7e1f..90b42e8d6e228 100644
--- a/tests/ui/proc-macro/derive-helper-shadowing.stderr
+++ b/tests/ui/proc-macro/derive-helper-shadowing.stderr
@@ -1,17 +1,17 @@
 error: cannot use a derive helper attribute through an import
-  --> $DIR/derive-helper-shadowing.rs:42:15
+  --> $DIR/derive-helper-shadowing.rs:43:15
    |
 LL |             #[renamed]
    |               ^^^^^^^
    |
 note: the derive helper attribute imported here
-  --> $DIR/derive-helper-shadowing.rs:41:17
+  --> $DIR/derive-helper-shadowing.rs:42:17
    |
 LL |             use empty_helper as renamed;
    |                 ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: cannot find attribute `empty_helper` in this scope
-  --> $DIR/derive-helper-shadowing.rs:38:22
+  --> $DIR/derive-helper-shadowing.rs:39:22
    |
 LL |             #[derive(GenHelperUse)]
    |                      ^^^^^^^^^^^^
@@ -24,7 +24,7 @@ LL +             use empty_helper;
    |
 
 error: cannot find attribute `empty_helper` in this scope
-  --> $DIR/derive-helper-shadowing.rs:14:11
+  --> $DIR/derive-helper-shadowing.rs:15:11
    |
 LL |         #[empty_helper]
    |           ^^^^^^^^^^^^
@@ -40,26 +40,26 @@ LL +             use crate::empty_helper;
    |
 
 error[E0659]: `empty_helper` is ambiguous
-  --> $DIR/derive-helper-shadowing.rs:19:3
+  --> $DIR/derive-helper-shadowing.rs:20:3
    |
 LL | #[empty_helper]
    |   ^^^^^^^^^^^^ ambiguous name
    |
    = note: ambiguous because of a name conflict with a derive helper attribute
 note: `empty_helper` could refer to the derive helper attribute defined here
-  --> $DIR/derive-helper-shadowing.rs:22:10
+  --> $DIR/derive-helper-shadowing.rs:23:10
    |
 LL | #[derive(Empty)]
    |          ^^^^^
 note: `empty_helper` could also refer to the attribute macro imported here
-  --> $DIR/derive-helper-shadowing.rs:10:5
+  --> $DIR/derive-helper-shadowing.rs:11:5
    |
 LL | use test_macros::empty_attr as empty_helper;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = help: use `crate::empty_helper` to refer to this attribute macro unambiguously
 
 error: derive helper attribute is used before it is introduced
-  --> $DIR/derive-helper-shadowing.rs:19:3
+  --> $DIR/derive-helper-shadowing.rs:20:3
    |
 LL | #[empty_helper]
    |   ^^^^^^^^^^^^
@@ -76,7 +76,7 @@ error: aborting due to 5 previous errors
 For more information about this error, try `rustc --explain E0659`.
 Future incompatibility report: Future breakage diagnostic:
 error: derive helper attribute is used before it is introduced
-  --> $DIR/derive-helper-shadowing.rs:19:3
+  --> $DIR/derive-helper-shadowing.rs:20:3
    |
 LL | #[empty_helper]
    |   ^^^^^^^^^^^^
diff --git a/tests/ui/proc-macro/derive-same-struct.rs b/tests/ui/proc-macro/derive-same-struct.rs
index f7669ba1480b2..04ab08dc76e5b 100644
--- a/tests/ui/proc-macro/derive-same-struct.rs
+++ b/tests/ui/proc-macro/derive-same-struct.rs
@@ -3,6 +3,7 @@
 #![allow(path_statements)]
 #![allow(dead_code)]
 //@ proc-macro: derive-same-struct.rs
+//@ ignore-backends: gcc
 
 #[macro_use]
 extern crate derive_same_struct;
diff --git a/tests/ui/proc-macro/edition-imports-2018.rs b/tests/ui/proc-macro/edition-imports-2018.rs
index a3808d9dce823..af9eed74adb9b 100644
--- a/tests/ui/proc-macro/edition-imports-2018.rs
+++ b/tests/ui/proc-macro/edition-imports-2018.rs
@@ -1,6 +1,7 @@
 //@ check-pass
 //@ edition:2018
 //@ proc-macro: edition-imports-2015.rs
+//@ ignore-backends: gcc
 
 #[macro_use]
 extern crate edition_imports_2015;
diff --git a/tests/ui/proc-macro/env.rs b/tests/ui/proc-macro/env.rs
index 94e3b09e5269b..fc248f8835964 100644
--- a/tests/ui/proc-macro/env.rs
+++ b/tests/ui/proc-macro/env.rs
@@ -2,6 +2,7 @@
 //@ run-pass
 //@ rustc-env: THE_CONST=1
 //@ compile-flags: -Zunstable-options --env-set THE_CONST=12 --env-set ANOTHER=4
+//@ ignore-backends: gcc
 
 #![crate_name = "foo"]
 
diff --git a/tests/ui/proc-macro/expand-expr.rs b/tests/ui/proc-macro/expand-expr.rs
index 8a4ed9768d53a..1e058abe3bc1b 100644
--- a/tests/ui/proc-macro/expand-expr.rs
+++ b/tests/ui/proc-macro/expand-expr.rs
@@ -1,4 +1,5 @@
 //@ proc-macro: expand-expr.rs
+//@ ignore-backends: gcc
 // no-remap-src-base: check_expand_expr_file!() fails when enabled.
 
 #![feature(concat_bytes)]
@@ -10,7 +11,7 @@ use expand_expr::{
 
 // Check builtin macros can be expanded.
 
-expand_expr_is!(13u32, line!());
+expand_expr_is!(14u32, line!());
 expand_expr_is!(24u32, column!());
 
 expand_expr_is!("Hello, World!", concat!("Hello, ", "World", "!"));
diff --git a/tests/ui/proc-macro/expand-expr.stderr b/tests/ui/proc-macro/expand-expr.stderr
index 8b1df177cfa6d..fd5f672adf5c0 100644
--- a/tests/ui/proc-macro/expand-expr.stderr
+++ b/tests/ui/proc-macro/expand-expr.stderr
@@ -1,29 +1,29 @@
 error: expected one of `.`, `?`, or an operator, found `;`
-  --> $DIR/expand-expr.rs:108:27
+  --> $DIR/expand-expr.rs:109:27
    |
 LL | expand_expr_fail!("string"; hello);
    |                           ^ expected one of `.`, `?`, or an operator
 
 error: expected expression, found `$`
-  --> $DIR/expand-expr.rs:111:19
+  --> $DIR/expand-expr.rs:112:19
    |
 LL | expand_expr_fail!($);
    |                   ^ expected expression
 
 error: expected expression, found `$`
-  --> $DIR/expand-expr.rs:112:29
+  --> $DIR/expand-expr.rs:113:29
    |
 LL | expand_expr_fail!(echo_tts!($));
    |                             ^ expected expression
 
 error: expected expression, found `$`
-  --> $DIR/expand-expr.rs:113:28
+  --> $DIR/expand-expr.rs:114:28
    |
 LL | expand_expr_fail!(echo_pm!($));
    |                            ^ expected expression
 
 error: macro expansion ignores `hello` and any tokens following
-  --> $DIR/expand-expr.rs:117:47
+  --> $DIR/expand-expr.rs:118:47
    |
 LL | expand_expr_is!("string", echo_tts!("string"; hello));
    |                           --------------------^^^^^- caused by the macro expansion here
@@ -35,7 +35,7 @@ LL | expand_expr_is!("string", echo_tts!("string"; hello););
    |                                                     +
 
 error: macro expansion ignores `;` and any tokens following
-  --> $DIR/expand-expr.rs:118:44
+  --> $DIR/expand-expr.rs:119:44
    |
 LL | expand_expr_is!("string", echo_pm!("string"; hello));
    |                           -----------------^------- caused by the macro expansion here
@@ -47,7 +47,7 @@ LL | expand_expr_is!("string", echo_pm!("string"; hello););
    |                                                    +
 
 error: recursion limit reached while expanding `recursive_expand!`
-  --> $DIR/expand-expr.rs:126:16
+  --> $DIR/expand-expr.rs:127:16
    |
 LL | const _: u32 = recursive_expand!();
    |                ^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/proc-macro/expand-to-unstable.rs b/tests/ui/proc-macro/expand-to-unstable.rs
index 8968471ebd872..37bfeab1fe71e 100644
--- a/tests/ui/proc-macro/expand-to-unstable.rs
+++ b/tests/ui/proc-macro/expand-to-unstable.rs
@@ -1,4 +1,5 @@
 //@ proc-macro: derive-unstable.rs
+//@ ignore-backends: gcc
 
 #![allow(warnings)]
 
diff --git a/tests/ui/proc-macro/expand-to-unstable.stderr b/tests/ui/proc-macro/expand-to-unstable.stderr
index 563c7ae8f9561..255f80501ea73 100644
--- a/tests/ui/proc-macro/expand-to-unstable.stderr
+++ b/tests/ui/proc-macro/expand-to-unstable.stderr
@@ -1,5 +1,5 @@
 error[E0658]: use of unstable library feature `core_intrinsics`: intrinsics are unlikely to ever be stabilized, instead they should be used through stabilized interfaces in the rest of the standard library
-  --> $DIR/expand-to-unstable.rs:8:10
+  --> $DIR/expand-to-unstable.rs:9:10
    |
 LL | #[derive(Unstable)]
    |          ^^^^^^^^
diff --git a/tests/ui/proc-macro/expand-with-a-macro.rs b/tests/ui/proc-macro/expand-with-a-macro.rs
index e5baf3601db0a..aa02cefbec684 100644
--- a/tests/ui/proc-macro/expand-with-a-macro.rs
+++ b/tests/ui/proc-macro/expand-with-a-macro.rs
@@ -1,6 +1,7 @@
 //@ run-pass
 //@ needs-unwind
 //@ proc-macro: expand-with-a-macro.rs
+//@ ignore-backends: gcc
 
 
 #![deny(warnings)]
diff --git a/tests/ui/proc-macro/gen-macro-rules-hygiene.rs b/tests/ui/proc-macro/gen-macro-rules-hygiene.rs
index 3deec94fa3411..fb7c830c2edf4 100644
--- a/tests/ui/proc-macro/gen-macro-rules-hygiene.rs
+++ b/tests/ui/proc-macro/gen-macro-rules-hygiene.rs
@@ -3,6 +3,7 @@
 // `$crate` refers to the crate that defines `macro_rules` and not the outer transparent macro.
 
 //@ proc-macro: gen-macro-rules-hygiene.rs
+//@ ignore-backends: gcc
 
 #[macro_use]
 extern crate gen_macro_rules_hygiene;
diff --git a/tests/ui/proc-macro/gen-macro-rules-hygiene.stderr b/tests/ui/proc-macro/gen-macro-rules-hygiene.stderr
index df7c4f72eb0b6..e904b43aaae06 100644
--- a/tests/ui/proc-macro/gen-macro-rules-hygiene.stderr
+++ b/tests/ui/proc-macro/gen-macro-rules-hygiene.stderr
@@ -1,5 +1,5 @@
 error[E0426]: use of undeclared label `'label_use`
-  --> $DIR/gen-macro-rules-hygiene.rs:12:1
+  --> $DIR/gen-macro-rules-hygiene.rs:13:1
    |
 LL | gen_macro_rules!();
    | ^^^^^^^^^^^^^^^^^^ undeclared label `'label_use`
@@ -10,7 +10,7 @@ LL |         generated!();
    = note: this error originates in the macro `generated` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0425]: cannot find value `local_use` in this scope
-  --> $DIR/gen-macro-rules-hygiene.rs:12:1
+  --> $DIR/gen-macro-rules-hygiene.rs:13:1
    |
 LL | gen_macro_rules!();
    | ^^^^^^^^^^^^^^^^^^ help: a local variable with a similar name exists: `local_def`
@@ -21,7 +21,7 @@ LL |         generated!();
    = note: this error originates in the macro `generated` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0425]: cannot find value `local_def` in this scope
-  --> $DIR/gen-macro-rules-hygiene.rs:21:9
+  --> $DIR/gen-macro-rules-hygiene.rs:22:9
    |
 LL |         local_def;
    |         ^^^^^^^^^ help: a local variable with a similar name exists: `local_use`
diff --git a/tests/ui/proc-macro/gen-macro-rules.rs b/tests/ui/proc-macro/gen-macro-rules.rs
index 121d029e2e346..8ee38b2cc2795 100644
--- a/tests/ui/proc-macro/gen-macro-rules.rs
+++ b/tests/ui/proc-macro/gen-macro-rules.rs
@@ -2,6 +2,7 @@
 
 //@ check-pass
 //@ proc-macro: gen-macro-rules.rs
+//@ ignore-backends: gcc
 
 extern crate gen_macro_rules as repro;
 
diff --git a/tests/ui/proc-macro/generate-mod.rs b/tests/ui/proc-macro/generate-mod.rs
index 729bfc1db6674..0a1629e75ec17 100644
--- a/tests/ui/proc-macro/generate-mod.rs
+++ b/tests/ui/proc-macro/generate-mod.rs
@@ -1,6 +1,7 @@
 // Modules generated by transparent proc macros still acts as barriers for names (issue #50504).
 
 //@ proc-macro: generate-mod.rs
+//@ ignore-backends: gcc
 
 extern crate generate_mod;
 
diff --git a/tests/ui/proc-macro/generate-mod.stderr b/tests/ui/proc-macro/generate-mod.stderr
index 142ff1abeed6b..03cf8c35188ac 100644
--- a/tests/ui/proc-macro/generate-mod.stderr
+++ b/tests/ui/proc-macro/generate-mod.stderr
@@ -1,5 +1,5 @@
 error[E0412]: cannot find type `FromOutside` in this scope
-  --> $DIR/generate-mod.rs:9:1
+  --> $DIR/generate-mod.rs:10:1
    |
 LL | generate_mod::check!();
    | ^^^^^^^^^^^^^^^^^^^^^^ not found in this scope
@@ -9,7 +9,7 @@ LL | generate_mod::check!();
    = note: this error originates in the macro `generate_mod::check` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0412]: cannot find type `Outer` in this scope
-  --> $DIR/generate-mod.rs:9:1
+  --> $DIR/generate-mod.rs:10:1
    |
 LL | generate_mod::check!();
    | ^^^^^^^^^^^^^^^^^^^^^^ not found in this scope
@@ -19,7 +19,7 @@ LL | generate_mod::check!();
    = note: this error originates in the macro `generate_mod::check` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0412]: cannot find type `FromOutside` in this scope
-  --> $DIR/generate-mod.rs:12:1
+  --> $DIR/generate-mod.rs:13:1
    |
 LL | #[generate_mod::check_attr]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ not found in this scope
@@ -29,7 +29,7 @@ LL | #[generate_mod::check_attr]
    = note: this error originates in the attribute macro `generate_mod::check_attr` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0412]: cannot find type `OuterAttr` in this scope
-  --> $DIR/generate-mod.rs:12:1
+  --> $DIR/generate-mod.rs:13:1
    |
 LL | #[generate_mod::check_attr]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ not found in this scope
@@ -39,7 +39,7 @@ LL | #[generate_mod::check_attr]
    = note: this error originates in the attribute macro `generate_mod::check_attr` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: cannot find type `FromOutside` in this scope
-  --> $DIR/generate-mod.rs:16:10
+  --> $DIR/generate-mod.rs:17:10
    |
 LL | #[derive(generate_mod::CheckDerive)]
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^ names from parent modules are not accessible without an explicit import
@@ -50,7 +50,7 @@ LL | #[derive(generate_mod::CheckDerive)]
    = note: this error originates in the derive macro `generate_mod::CheckDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: cannot find type `OuterDerive` in this scope
-  --> $DIR/generate-mod.rs:16:10
+  --> $DIR/generate-mod.rs:17:10
    |
 LL | #[derive(generate_mod::CheckDerive)]
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^ names from parent modules are not accessible without an explicit import
@@ -60,7 +60,7 @@ LL | #[derive(generate_mod::CheckDerive)]
    = note: this error originates in the derive macro `generate_mod::CheckDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: cannot find type `FromOutside` in this scope
-  --> $DIR/generate-mod.rs:23:14
+  --> $DIR/generate-mod.rs:24:14
    |
 LL |     #[derive(generate_mod::CheckDerive)]
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^ names from parent modules are not accessible without an explicit import
@@ -70,7 +70,7 @@ LL |     #[derive(generate_mod::CheckDerive)]
    = note: this error originates in the derive macro `generate_mod::CheckDerive` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: cannot find type `OuterDerive` in this scope
-  --> $DIR/generate-mod.rs:23:14
+  --> $DIR/generate-mod.rs:24:14
    |
 LL |     #[derive(generate_mod::CheckDerive)]
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^ names from parent modules are not accessible without an explicit import
@@ -84,7 +84,7 @@ error: aborting due to 8 previous errors
 For more information about this error, try `rustc --explain E0412`.
 Future incompatibility report: Future breakage diagnostic:
 error: cannot find type `FromOutside` in this scope
-  --> $DIR/generate-mod.rs:16:10
+  --> $DIR/generate-mod.rs:17:10
    |
 LL | #[derive(generate_mod::CheckDerive)]
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^ names from parent modules are not accessible without an explicit import
@@ -96,7 +96,7 @@ LL | #[derive(generate_mod::CheckDerive)]
 
 Future breakage diagnostic:
 error: cannot find type `OuterDerive` in this scope
-  --> $DIR/generate-mod.rs:16:10
+  --> $DIR/generate-mod.rs:17:10
    |
 LL | #[derive(generate_mod::CheckDerive)]
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^ names from parent modules are not accessible without an explicit import
@@ -108,7 +108,7 @@ LL | #[derive(generate_mod::CheckDerive)]
 
 Future breakage diagnostic:
 error: cannot find type `FromOutside` in this scope
-  --> $DIR/generate-mod.rs:23:14
+  --> $DIR/generate-mod.rs:24:14
    |
 LL |     #[derive(generate_mod::CheckDerive)]
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^ names from parent modules are not accessible without an explicit import
@@ -120,7 +120,7 @@ LL |     #[derive(generate_mod::CheckDerive)]
 
 Future breakage diagnostic:
 error: cannot find type `OuterDerive` in this scope
-  --> $DIR/generate-mod.rs:23:14
+  --> $DIR/generate-mod.rs:24:14
    |
 LL |     #[derive(generate_mod::CheckDerive)]
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^ names from parent modules are not accessible without an explicit import
@@ -132,7 +132,7 @@ LL |     #[derive(generate_mod::CheckDerive)]
 
 Future breakage diagnostic:
 warning: cannot find type `FromOutside` in this scope
-  --> $DIR/generate-mod.rs:30:10
+  --> $DIR/generate-mod.rs:31:10
    |
 LL | #[derive(generate_mod::CheckDeriveLint)] // OK, lint is suppressed
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ names from parent modules are not accessible without an explicit import
@@ -143,7 +143,7 @@ LL | #[derive(generate_mod::CheckDeriveLint)] // OK, lint is suppressed
 
 Future breakage diagnostic:
 warning: cannot find type `OuterDeriveLint` in this scope
-  --> $DIR/generate-mod.rs:30:10
+  --> $DIR/generate-mod.rs:31:10
    |
 LL | #[derive(generate_mod::CheckDeriveLint)] // OK, lint is suppressed
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ names from parent modules are not accessible without an explicit import
diff --git a/tests/ui/proc-macro/hygiene_example.rs b/tests/ui/proc-macro/hygiene_example.rs
index 84b5e345608aa..f74f22fb3b0e0 100644
--- a/tests/ui/proc-macro/hygiene_example.rs
+++ b/tests/ui/proc-macro/hygiene_example.rs
@@ -1,5 +1,6 @@
 //@ check-pass
 //@ aux-build:hygiene_example.rs
+//@ ignore-backends: gcc
 
 extern crate hygiene_example;
 use hygiene_example::hello;
diff --git a/tests/ui/proc-macro/is-available.rs b/tests/ui/proc-macro/is-available.rs
index faee560d7a975..9e9cf5d11b661 100644
--- a/tests/ui/proc-macro/is-available.rs
+++ b/tests/ui/proc-macro/is-available.rs
@@ -3,6 +3,7 @@
 extern crate proc_macro;
 
 //@ proc-macro: is-available.rs
+//@ ignore-backends: gcc
 extern crate is_available;
 
 fn main() {
diff --git a/tests/ui/proc-macro/issue-104884-trait-impl-sugg-err.rs b/tests/ui/proc-macro/issue-104884-trait-impl-sugg-err.rs
index abdd6bf136dcf..d420f2641daf5 100644
--- a/tests/ui/proc-macro/issue-104884-trait-impl-sugg-err.rs
+++ b/tests/ui/proc-macro/issue-104884-trait-impl-sugg-err.rs
@@ -1,4 +1,5 @@
 //@ proc-macro: issue-104884.rs
+//@ ignore-backends: gcc
 
 use std::collections::BinaryHeap;
 
diff --git a/tests/ui/proc-macro/issue-104884-trait-impl-sugg-err.stderr b/tests/ui/proc-macro/issue-104884-trait-impl-sugg-err.stderr
index f3ed9e5761d67..b7aed4a8485a8 100644
--- a/tests/ui/proc-macro/issue-104884-trait-impl-sugg-err.stderr
+++ b/tests/ui/proc-macro/issue-104884-trait-impl-sugg-err.stderr
@@ -1,11 +1,11 @@
 error[E0277]: can't compare `PriorityQueue<T>` with `PriorityQueue<T>`
-  --> $DIR/issue-104884-trait-impl-sugg-err.rs:13:10
+  --> $DIR/issue-104884-trait-impl-sugg-err.rs:14:10
    |
 LL | #[derive(PartialOrd, AddImpl)]
    |          ^^^^^^^^^^ no implementation for `PriorityQueue<T> == PriorityQueue<T>`
    |
 help: the trait `PartialEq` is not implemented for `PriorityQueue<T>`
-  --> $DIR/issue-104884-trait-impl-sugg-err.rs:20:1
+  --> $DIR/issue-104884-trait-impl-sugg-err.rs:21:1
    |
 LL | struct PriorityQueue<T>(BinaryHeap<PriorityQueueEntry<T>>);
    | ^^^^^^^^^^^^^^^^^^^^^^^
@@ -13,13 +13,13 @@ note: required by a bound in `PartialOrd`
   --> $SRC_DIR/core/src/cmp.rs:LL:COL
 
 error[E0277]: the trait bound `PriorityQueue<T>: Eq` is not satisfied
-  --> $DIR/issue-104884-trait-impl-sugg-err.rs:13:22
+  --> $DIR/issue-104884-trait-impl-sugg-err.rs:14:22
    |
 LL | #[derive(PartialOrd, AddImpl)]
    |                      ^^^^^^^ unsatisfied trait bound
    |
 help: the trait `Eq` is not implemented for `PriorityQueue<T>`
-  --> $DIR/issue-104884-trait-impl-sugg-err.rs:20:1
+  --> $DIR/issue-104884-trait-impl-sugg-err.rs:21:1
    |
 LL | struct PriorityQueue<T>(BinaryHeap<PriorityQueueEntry<T>>);
    | ^^^^^^^^^^^^^^^^^^^^^^^
@@ -28,13 +28,13 @@ note: required by a bound in `Ord`
    = note: this error originates in the derive macro `AddImpl` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0277]: can't compare `T` with `T`
-  --> $DIR/issue-104884-trait-impl-sugg-err.rs:13:22
+  --> $DIR/issue-104884-trait-impl-sugg-err.rs:14:22
    |
 LL | #[derive(PartialOrd, AddImpl)]
    |                      ^^^^^^^ no implementation for `T < T` and `T > T`
    |
 note: required for `PriorityQueue<T>` to implement `PartialOrd`
-  --> $DIR/issue-104884-trait-impl-sugg-err.rs:13:10
+  --> $DIR/issue-104884-trait-impl-sugg-err.rs:14:10
    |
 LL | #[derive(PartialOrd, AddImpl)]
    |          ^^^^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
@@ -42,7 +42,7 @@ note: required by a bound in `Ord`
   --> $SRC_DIR/core/src/cmp.rs:LL:COL
 
 error[E0277]: can't compare `BinaryHeap<PriorityQueueEntry<T>>` with `_`
-  --> $DIR/issue-104884-trait-impl-sugg-err.rs:20:25
+  --> $DIR/issue-104884-trait-impl-sugg-err.rs:21:25
    |
 LL | #[derive(PartialOrd, AddImpl)]
    |          ---------- in this derive macro expansion
@@ -53,7 +53,7 @@ LL | struct PriorityQueue<T>(BinaryHeap<PriorityQueueEntry<T>>);
    = help: the trait `PartialOrd<_>` is not implemented for `BinaryHeap<PriorityQueueEntry<T>>`
 
 error[E0599]: no method named `cmp` found for struct `BinaryHeap<PriorityQueueEntry<T>>` in the current scope
-  --> $DIR/issue-104884-trait-impl-sugg-err.rs:13:22
+  --> $DIR/issue-104884-trait-impl-sugg-err.rs:14:22
    |
 LL | #[derive(PartialOrd, AddImpl)]
    |                      ^^^^^^^ `BinaryHeap<PriorityQueueEntry<T>>` is not an iterator
@@ -61,7 +61,7 @@ LL | #[derive(PartialOrd, AddImpl)]
    = note: this error originates in the derive macro `AddImpl` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0609]: no field `height` on type `&PriorityQueue<T>`
-  --> $DIR/issue-104884-trait-impl-sugg-err.rs:13:22
+  --> $DIR/issue-104884-trait-impl-sugg-err.rs:14:22
    |
 LL | #[derive(PartialOrd, AddImpl)]
    |                      ^^^^^^^ unknown field
diff --git a/tests/ui/proc-macro/issue-107113-wrap.rs b/tests/ui/proc-macro/issue-107113-wrap.rs
index 2799e79bb1cb4..a46cf893d90e8 100644
--- a/tests/ui/proc-macro/issue-107113-wrap.rs
+++ b/tests/ui/proc-macro/issue-107113-wrap.rs
@@ -1,5 +1,6 @@
 //@ edition:2021
 //@ proc-macro: issue-107113.rs
+//@ ignore-backends: gcc
 
 #[macro_use]
 extern crate issue_107113;
diff --git a/tests/ui/proc-macro/issue-107113-wrap.stderr b/tests/ui/proc-macro/issue-107113-wrap.stderr
index b541051147d53..9b5b0333256e6 100644
--- a/tests/ui/proc-macro/issue-107113-wrap.stderr
+++ b/tests/ui/proc-macro/issue-107113-wrap.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/issue-107113-wrap.rs:7:1
+  --> $DIR/issue-107113-wrap.rs:8:1
    |
 LL | #[issue_107113::main]
    | ^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/proc-macro/issue-118809.rs b/tests/ui/proc-macro/issue-118809.rs
index a6a3956981a78..3ceede7e885cf 100644
--- a/tests/ui/proc-macro/issue-118809.rs
+++ b/tests/ui/proc-macro/issue-118809.rs
@@ -1,4 +1,5 @@
 //@ proc-macro: issue-118809.rs
+//@ ignore-backends: gcc
 
 #[macro_use]
 extern crate issue_118809;
diff --git a/tests/ui/proc-macro/issue-118809.stderr b/tests/ui/proc-macro/issue-118809.stderr
index 30b09fd4006bf..98329fea11940 100644
--- a/tests/ui/proc-macro/issue-118809.stderr
+++ b/tests/ui/proc-macro/issue-118809.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/issue-118809.rs:6:10
+  --> $DIR/issue-118809.rs:7:10
    |
 LL | #[derive(Deserialize)]
    |          ^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL | #[derive(Deserialize)]
    |          arguments to this enum variant are incorrect
    |
 help: the type constructed contains `u32` due to the type of the argument passed
-  --> $DIR/issue-118809.rs:6:10
+  --> $DIR/issue-118809.rs:7:10
    |
 LL | #[derive(Deserialize)]
    |          ^^^^^^^^^^^ this argument influences the type of `Some`
diff --git a/tests/ui/proc-macro/issue-38586.rs b/tests/ui/proc-macro/issue-38586.rs
index 88dbb8037bebd..c9623fd383b1a 100644
--- a/tests/ui/proc-macro/issue-38586.rs
+++ b/tests/ui/proc-macro/issue-38586.rs
@@ -1,4 +1,5 @@
 //@ proc-macro: issue-38586.rs
+//@ ignore-backends: gcc
 
 #[macro_use]
 extern crate issue_38586;
diff --git a/tests/ui/proc-macro/issue-38586.stderr b/tests/ui/proc-macro/issue-38586.stderr
index 0049155645078..e49d4c83e2734 100644
--- a/tests/ui/proc-macro/issue-38586.stderr
+++ b/tests/ui/proc-macro/issue-38586.stderr
@@ -1,5 +1,5 @@
 error[E0425]: cannot find value `foo` in this scope
-  --> $DIR/issue-38586.rs:6:10
+  --> $DIR/issue-38586.rs:7:10
    |
 LL | #[derive(A)]
    |          ^ not found in this scope
diff --git a/tests/ui/proc-macro/issue-59191-replace-root-with-fn.rs b/tests/ui/proc-macro/issue-59191-replace-root-with-fn.rs
index df236cce6d2a8..988641b2b9c48 100644
--- a/tests/ui/proc-macro/issue-59191-replace-root-with-fn.rs
+++ b/tests/ui/proc-macro/issue-59191-replace-root-with-fn.rs
@@ -4,6 +4,7 @@
 //@ edition:2018
 //@ proc-macro: issue-59191.rs
 //@ needs-unwind (affects error output)
+//@ ignore-backends: gcc
 
 #![feature(custom_inner_attributes)]
 #![issue_59191::no_main]
diff --git a/tests/ui/proc-macro/issue-79148.rs b/tests/ui/proc-macro/issue-79148.rs
index b2248759b5f8e..7ce6216c842a6 100644
--- a/tests/ui/proc-macro/issue-79148.rs
+++ b/tests/ui/proc-macro/issue-79148.rs
@@ -1,5 +1,6 @@
 //@ proc-macro: re-export.rs
 //@ edition:2018
+//@ ignore-backends: gcc
 
 extern crate re_export;
 
diff --git a/tests/ui/proc-macro/issue-79148.stderr b/tests/ui/proc-macro/issue-79148.stderr
index 8adc4c6e0dbe4..80a5b1a0855f7 100644
--- a/tests/ui/proc-macro/issue-79148.stderr
+++ b/tests/ui/proc-macro/issue-79148.stderr
@@ -1,11 +1,11 @@
 error[E0364]: `Variant` is only public within the crate, and cannot be re-exported outside
-  --> $DIR/issue-79148.rs:8:1
+  --> $DIR/issue-79148.rs:9:1
    |
 LL | cause_ice!();
    | ^^^^^^^^^^^^
    |
 note: consider marking `Variant` as `pub` in the imported module
-  --> $DIR/issue-79148.rs:8:1
+  --> $DIR/issue-79148.rs:9:1
    |
 LL | cause_ice!();
    | ^^^^^^^^^^^^
diff --git a/tests/ui/proc-macro/issue-83510.rs b/tests/ui/proc-macro/issue-83510.rs
index 67469511fc367..d49e1867f1d67 100644
--- a/tests/ui/proc-macro/issue-83510.rs
+++ b/tests/ui/proc-macro/issue-83510.rs
@@ -1,4 +1,5 @@
 //@ proc-macro: issue-83510.rs
+//@ ignore-backends: gcc
 
 extern crate issue_83510;
 
diff --git a/tests/ui/proc-macro/issue-83510.stderr b/tests/ui/proc-macro/issue-83510.stderr
index e59b77af3dc39..a7c3f5a1d5b67 100644
--- a/tests/ui/proc-macro/issue-83510.stderr
+++ b/tests/ui/proc-macro/issue-83510.stderr
@@ -1,5 +1,5 @@
 error[E0412]: cannot find type `Foo` in this scope
-  --> $DIR/issue-83510.rs:5:1
+  --> $DIR/issue-83510.rs:6:1
    |
 LL | issue_83510::dance_like_you_want_to_ice!();
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not found in this scope
@@ -7,7 +7,7 @@ LL | issue_83510::dance_like_you_want_to_ice!();
    = note: this error originates in the macro `issue_83510::dance_like_you_want_to_ice` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0404]: expected trait, found struct `Box`
-  --> $DIR/issue-83510.rs:5:1
+  --> $DIR/issue-83510.rs:6:1
    |
 LL | issue_83510::dance_like_you_want_to_ice!();
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not a trait
@@ -15,7 +15,7 @@ LL | issue_83510::dance_like_you_want_to_ice!();
    = note: this error originates in the macro `issue_83510::dance_like_you_want_to_ice` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0405]: cannot find trait `Baz` in this scope
-  --> $DIR/issue-83510.rs:5:1
+  --> $DIR/issue-83510.rs:6:1
    |
 LL | issue_83510::dance_like_you_want_to_ice!();
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not found in this scope
@@ -23,7 +23,7 @@ LL | issue_83510::dance_like_you_want_to_ice!();
    = note: this error originates in the macro `issue_83510::dance_like_you_want_to_ice` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0658]: inherent associated types are unstable
-  --> $DIR/issue-83510.rs:5:1
+  --> $DIR/issue-83510.rs:6:1
    |
 LL | issue_83510::dance_like_you_want_to_ice!();
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/proc-macro/issue-91800.rs b/tests/ui/proc-macro/issue-91800.rs
index 8cecfad32b55b..79cbf8632f009 100644
--- a/tests/ui/proc-macro/issue-91800.rs
+++ b/tests/ui/proc-macro/issue-91800.rs
@@ -1,4 +1,5 @@
 //@ proc-macro: issue-91800-macro.rs
+//@ ignore-backends: gcc
 
 #[macro_use]
 extern crate issue_91800_macro;
diff --git a/tests/ui/proc-macro/issue-91800.stderr b/tests/ui/proc-macro/issue-91800.stderr
index 63ebc0a552e33..be5a8ece38404 100644
--- a/tests/ui/proc-macro/issue-91800.stderr
+++ b/tests/ui/proc-macro/issue-91800.stderr
@@ -1,5 +1,5 @@
 error: macros that expand to items must be delimited with braces or followed by a semicolon
-  --> $DIR/issue-91800.rs:6:10
+  --> $DIR/issue-91800.rs:7:10
    |
 LL | #[derive(MyTrait)]
    |          ^^^^^^^
@@ -7,13 +7,13 @@ LL | #[derive(MyTrait)]
    = note: this error originates in the derive macro `MyTrait` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: proc-macro derive produced unparsable tokens
-  --> $DIR/issue-91800.rs:6:10
+  --> $DIR/issue-91800.rs:7:10
    |
 LL | #[derive(MyTrait)]
    |          ^^^^^^^
 
 error: 
-  --> $DIR/issue-91800.rs:6:10
+  --> $DIR/issue-91800.rs:7:10
    |
 LL | #[derive(MyTrait)]
    |          ^^^^^^^
@@ -21,7 +21,7 @@ LL | #[derive(MyTrait)]
    = note: this error originates in the derive macro `MyTrait` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: macros that expand to items must be delimited with braces or followed by a semicolon
-  --> $DIR/issue-91800.rs:10:1
+  --> $DIR/issue-91800.rs:11:1
    |
 LL | #[attribute_macro]
    | ^^^^^^^^^^^^^^^^^^
@@ -29,7 +29,7 @@ LL | #[attribute_macro]
    = note: this error originates in the attribute macro `attribute_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: 
-  --> $DIR/issue-91800.rs:10:1
+  --> $DIR/issue-91800.rs:11:1
    |
 LL | #[attribute_macro]
    | ^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL | #[attribute_macro]
    = note: this error originates in the attribute macro `attribute_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: macros that expand to items must be delimited with braces or followed by a semicolon
-  --> $DIR/issue-91800.rs:15:1
+  --> $DIR/issue-91800.rs:16:1
    |
 LL | fn_macro! {}
    | ^^^^^^^^^^^^
@@ -45,7 +45,7 @@ LL | fn_macro! {}
    = note: this error originates in the macro `fn_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: 
-  --> $DIR/issue-91800.rs:15:1
+  --> $DIR/issue-91800.rs:16:1
    |
 LL | fn_macro! {}
    | ^^^^^^^^^^^^
diff --git a/tests/ui/proc-macro/lifetimes-rpass.rs b/tests/ui/proc-macro/lifetimes-rpass.rs
index c462b27722f7e..9b794e695cd1c 100644
--- a/tests/ui/proc-macro/lifetimes-rpass.rs
+++ b/tests/ui/proc-macro/lifetimes-rpass.rs
@@ -2,6 +2,7 @@
 
 #![allow(unused_variables)]
 //@ proc-macro: lifetimes-rpass.rs
+//@ ignore-backends: gcc
 
 extern crate lifetimes_rpass as lifetimes;
 use lifetimes::*;
diff --git a/tests/ui/proc-macro/lints_in_proc_macros.rs b/tests/ui/proc-macro/lints_in_proc_macros.rs
index 6714b8b6e1d5f..2c22c787982eb 100644
--- a/tests/ui/proc-macro/lints_in_proc_macros.rs
+++ b/tests/ui/proc-macro/lints_in_proc_macros.rs
@@ -1,4 +1,5 @@
 //@ proc-macro: bang_proc_macro2.rs
+//@ ignore-backends: gcc
 
 extern crate bang_proc_macro2;
 
diff --git a/tests/ui/proc-macro/lints_in_proc_macros.stderr b/tests/ui/proc-macro/lints_in_proc_macros.stderr
index 244d218608be7..016b236bda881 100644
--- a/tests/ui/proc-macro/lints_in_proc_macros.stderr
+++ b/tests/ui/proc-macro/lints_in_proc_macros.stderr
@@ -1,5 +1,5 @@
 error[E0425]: cannot find value `foobar2` in this scope
-  --> $DIR/lints_in_proc_macros.rs:9:5
+  --> $DIR/lints_in_proc_macros.rs:10:5
    |
 LL |     bang_proc_macro2!();
    |     ^^^^^^^^^^^^^^^^^^^ help: a local variable with a similar name exists: `foobar`
diff --git a/tests/ui/proc-macro/load-two.rs b/tests/ui/proc-macro/load-two.rs
index 608379949e665..197e7845db33b 100644
--- a/tests/ui/proc-macro/load-two.rs
+++ b/tests/ui/proc-macro/load-two.rs
@@ -4,6 +4,7 @@
 #![allow(dead_code)]
 //@ proc-macro: derive-atob.rs
 //@ proc-macro: derive-ctod.rs
+//@ ignore-backends: gcc
 
 #[macro_use]
 extern crate derive_atob;
diff --git a/tests/ui/proc-macro/macro-crate-multi-decorator.rs b/tests/ui/proc-macro/macro-crate-multi-decorator.rs
index c4f02e7adfcbc..e247c9526a4c9 100644
--- a/tests/ui/proc-macro/macro-crate-multi-decorator.rs
+++ b/tests/ui/proc-macro/macro-crate-multi-decorator.rs
@@ -2,6 +2,7 @@
 
 //@ check-pass
 //@ proc-macro: duplicate.rs
+//@ ignore-backends: gcc
 
 #[macro_use]
 extern crate duplicate;
diff --git a/tests/ui/proc-macro/macro_rules_edition_from_pm.rs b/tests/ui/proc-macro/macro_rules_edition_from_pm.rs
index 8fc7d9097493d..fc3ae3ef2c814 100644
--- a/tests/ui/proc-macro/macro_rules_edition_from_pm.rs
+++ b/tests/ui/proc-macro/macro_rules_edition_from_pm.rs
@@ -7,6 +7,7 @@
 //@[edition2021] edition:2021
 //@[edition2024] edition:2024
 //@ check-pass
+//@ ignore-backends: gcc
 
 // This checks how the expr fragment specifier works.
 macro_rules_edition_pm::make_edition_macro!{}
diff --git a/tests/ui/proc-macro/match-expander.rs b/tests/ui/proc-macro/match-expander.rs
index 23e5746c540f7..b7245c7e682c1 100644
--- a/tests/ui/proc-macro/match-expander.rs
+++ b/tests/ui/proc-macro/match-expander.rs
@@ -1,4 +1,5 @@
 //@ proc-macro: match-expander.rs
+//@ ignore-backends: gcc
 // Ensure that we don't point at macro invocation when providing inference contexts.
 
 #[macro_use]
diff --git a/tests/ui/proc-macro/match-expander.stderr b/tests/ui/proc-macro/match-expander.stderr
index b77468ec60a5e..d2423336b1d22 100644
--- a/tests/ui/proc-macro/match-expander.stderr
+++ b/tests/ui/proc-macro/match-expander.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/match-expander.rs:8:5
+  --> $DIR/match-expander.rs:9:5
    |
 LL |     match_expander::matcher!();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `S`, found `bool`
diff --git a/tests/ui/proc-macro/mixed-site-span.rs b/tests/ui/proc-macro/mixed-site-span.rs
index 442b440c1211a..98a022632cd59 100644
--- a/tests/ui/proc-macro/mixed-site-span.rs
+++ b/tests/ui/proc-macro/mixed-site-span.rs
@@ -2,6 +2,7 @@
 
 //@ aux-build: token-site-span.rs
 //@ proc-macro: mixed-site-span.rs
+//@ ignore-backends: gcc
 
 extern crate mixed_site_span;
 extern crate token_site_span;
diff --git a/tests/ui/proc-macro/mixed-site-span.stderr b/tests/ui/proc-macro/mixed-site-span.stderr
index d62031a853c05..2d2d55fe148d5 100644
--- a/tests/ui/proc-macro/mixed-site-span.stderr
+++ b/tests/ui/proc-macro/mixed-site-span.stderr
@@ -1,5 +1,5 @@
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:47:5
+  --> $DIR/mixed-site-span.rs:48:5
    |
 LL |     invoke_with_crate!{input proc_macro_item}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `proc_macro_item` in the root
@@ -7,7 +7,7 @@ LL |     invoke_with_crate!{input proc_macro_item}
    = note: this error originates in the macro `invoke_with_crate` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:48:5
+  --> $DIR/mixed-site-span.rs:49:5
    |
 LL |     invoke_with_ident!{input proc_macro_item}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `proc_macro_item` in the root
@@ -15,7 +15,7 @@ LL |     invoke_with_ident!{input proc_macro_item}
    = note: this error originates in the macro `invoke_with_ident` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:49:5
+  --> $DIR/mixed-site-span.rs:50:5
    |
 LL |     invoke_with_crate!{call proc_macro_item}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `proc_macro_item` in the root
@@ -23,7 +23,7 @@ LL |     invoke_with_crate!{call proc_macro_item}
    = note: this error originates in the macro `with_crate` which comes from the expansion of the macro `invoke_with_crate` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:50:5
+  --> $DIR/mixed-site-span.rs:51:5
    |
 LL |     invoke_with_ident!{call proc_macro_item}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `proc_macro_item` in the root
@@ -31,7 +31,7 @@ LL |     invoke_with_ident!{call proc_macro_item}
    = note: this error originates in the macro `with_crate` which comes from the expansion of the macro `invoke_with_ident` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:51:5
+  --> $DIR/mixed-site-span.rs:52:5
    |
 LL |     invoke_with_ident!{hello call proc_macro_item}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `proc_macro_item` in the root
@@ -39,7 +39,7 @@ LL |     invoke_with_ident!{hello call proc_macro_item}
    = note: this error originates in the macro `with_crate` which comes from the expansion of the macro `invoke_with_ident` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0432]: unresolved import `$crate::proc_macro_item`
-  --> $DIR/mixed-site-span.rs:54:5
+  --> $DIR/mixed-site-span.rs:55:5
    |
 LL |     invoke_with_ident!{krate input proc_macro_item}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^---------------^
@@ -50,7 +50,7 @@ LL |     invoke_with_ident!{krate input proc_macro_item}
    = note: this error originates in the macro `with_crate` which comes from the expansion of the macro `invoke_with_ident` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0432]: unresolved import `$crate::proc_macro_item`
-  --> $DIR/mixed-site-span.rs:55:5
+  --> $DIR/mixed-site-span.rs:56:5
    |
 LL |     with_crate!{krate input proc_macro_item}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^---------------^
@@ -61,7 +61,7 @@ LL |     with_crate!{krate input proc_macro_item}
    = note: this error originates in the macro `with_crate` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:56:5
+  --> $DIR/mixed-site-span.rs:57:5
    |
 LL |     with_crate!{krate call proc_macro_item}
    |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^
@@ -72,7 +72,7 @@ LL |     with_crate!{krate call proc_macro_item}
    = note: this error originates in the macro `with_crate` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:60:28
+  --> $DIR/mixed-site-span.rs:61:28
    |
 LL |         invoke_with_ident!{$crate input proc_macro_item}
    |                            ^^^^^^       --------------- help: a similar name exists in the module: `proc_macro_rules`
@@ -85,7 +85,7 @@ LL |     test!();
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:61:21
+  --> $DIR/mixed-site-span.rs:62:21
    |
 LL |         with_crate!{$crate input proc_macro_item}
    |                     ^^^^^^       --------------- help: a similar name exists in the module: `proc_macro_rules`
@@ -98,7 +98,7 @@ LL |     test!();
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:62:9
+  --> $DIR/mixed-site-span.rs:63:9
    |
 LL |         with_crate!{$crate call proc_macro_item}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^---------------^
@@ -112,7 +112,7 @@ LL |     test!();
    = note: this error originates in the macro `with_crate` which comes from the expansion of the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:67:5
+  --> $DIR/mixed-site-span.rs:68:5
    |
 LL |     test!();
    |     ^^^^^^^ no `proc_macro_item` in the root
@@ -120,7 +120,7 @@ LL |     test!();
    = note: this error originates in the macro `with_crate` which comes from the expansion of the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0432]: unresolved import `$crate::TokenItem`
-  --> $DIR/mixed-site-span.rs:87:5
+  --> $DIR/mixed-site-span.rs:88:5
    |
 LL |     invoke_with_ident!{krate input TokenItem}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `TokenItem` in the root
@@ -133,7 +133,7 @@ LL |     quote!(use $krate::$ident as token_site_span::TokenItem as _;)
    |                                  +++++++++++++++++++++++++++++
 
 error[E0432]: unresolved import `$crate::TokenItem`
-  --> $DIR/mixed-site-span.rs:88:5
+  --> $DIR/mixed-site-span.rs:89:5
    |
 LL |     with_crate!{krate input TokenItem}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `TokenItem` in the root
@@ -146,7 +146,7 @@ LL |     quote!(use $krate::$ident as token_site_span::TokenItem as _;)
    |                                  +++++++++++++++++++++++++++++
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:89:5
+  --> $DIR/mixed-site-span.rs:90:5
    |
 LL |     with_crate!{krate call TokenItem}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `TokenItem` in the root
@@ -159,7 +159,7 @@ LL +     token_site_span::TokenItem as _
    |
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:92:5
+  --> $DIR/mixed-site-span.rs:93:5
    |
 LL |     invoke_with_crate!{mixed TokenItem}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `TokenItem` in the root
@@ -173,7 +173,7 @@ LL +     ($s:ident $i:ident) => { token_site_span::TokenItem as _ };
    |
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:93:5
+  --> $DIR/mixed-site-span.rs:94:5
    |
 LL |     invoke_with_ident!{mixed TokenItem}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `TokenItem` in the root
@@ -187,7 +187,7 @@ LL +     ($s:ident $i:ident) => { token_site_span::TokenItem as _ };
    |
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:94:5
+  --> $DIR/mixed-site-span.rs:95:5
    |
 LL |     invoke_with_ident!{krate mixed TokenItem}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `TokenItem` in the root
@@ -201,7 +201,7 @@ LL +     ($m:ident $s:ident $i:ident) => { token_site_span::TokenItem as _ };
    |
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:95:5
+  --> $DIR/mixed-site-span.rs:96:5
    |
 LL |     with_crate!{krate mixed TokenItem}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `TokenItem` in the root
@@ -214,7 +214,7 @@ LL +     token_site_span::TokenItem as _
    |
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:99:28
+  --> $DIR/mixed-site-span.rs:100:28
    |
 LL |         invoke_with_ident!{$crate input TokenItem}
    |                            ^^^^^^ no `TokenItem` in the root
@@ -230,7 +230,7 @@ LL +         invoke_with_ident!{token_site_span::TokenItem as _ input TokenItem}
    |
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:100:21
+  --> $DIR/mixed-site-span.rs:101:21
    |
 LL |         with_crate!{$crate input TokenItem}
    |                     ^^^^^^ no `TokenItem` in the root
@@ -246,7 +246,7 @@ LL +         with_crate!{token_site_span::TokenItem as _ input TokenItem}
    |
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:101:9
+  --> $DIR/mixed-site-span.rs:102:9
    |
 LL |         with_crate!{$crate call TokenItem}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `TokenItem` in the root
@@ -262,7 +262,7 @@ LL +         token_site_span::TokenItem as _
    |
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:108:5
+  --> $DIR/mixed-site-span.rs:109:5
    |
 LL |     test!();
    |     ^^^^^^^ no `TokenItem` in the root
@@ -276,7 +276,7 @@ LL +     ($m:ident $s:ident $i:ident) => { token_site_span::TokenItem as _ };
    |
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:105:9
+  --> $DIR/mixed-site-span.rs:106:9
    |
 LL |         with_crate!{$crate mixed TokenItem}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `TokenItem` in the root
@@ -292,7 +292,7 @@ LL +         token_site_span::TokenItem as _
    |
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:129:5
+  --> $DIR/mixed-site-span.rs:130:5
    |
 LL |     invoke_with_crate!{input ItemUse}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
@@ -306,7 +306,7 @@ LL +     ($s:ident $i:ident) => { with_crate!{ItemUse as _ $s $i} };
    |
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:130:5
+  --> $DIR/mixed-site-span.rs:131:5
    |
 LL |     invoke_with_ident!{input ItemUse}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
@@ -320,7 +320,7 @@ LL +     ($s:ident $i:ident) => { with_crate!{ItemUse as _ $s $i} };
    |
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:133:5
+  --> $DIR/mixed-site-span.rs:134:5
    |
 LL |     invoke_with_crate!{mixed ItemUse}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
@@ -334,7 +334,7 @@ LL +     ($s:ident $i:ident) => { ItemUse as _ };
    |
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:134:5
+  --> $DIR/mixed-site-span.rs:135:5
    |
 LL |     invoke_with_ident!{mixed ItemUse}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
@@ -348,7 +348,7 @@ LL +     ($s:ident $i:ident) => { ItemUse as _ };
    |
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:135:5
+  --> $DIR/mixed-site-span.rs:136:5
    |
 LL |     invoke_with_ident!{krate mixed ItemUse}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
@@ -362,7 +362,7 @@ LL +     ($m:ident $s:ident $i:ident) => { ItemUse as _ };
    |
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:136:5
+  --> $DIR/mixed-site-span.rs:137:5
    |
 LL |     with_crate!{krate mixed ItemUse}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
@@ -375,7 +375,7 @@ LL +     ItemUse as _
    |
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:138:5
+  --> $DIR/mixed-site-span.rs:139:5
    |
 LL |     invoke_with_crate!{call ItemUse}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
@@ -389,7 +389,7 @@ LL +     ($s:ident $i:ident) => { ItemUse as _ };
    |
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:139:5
+  --> $DIR/mixed-site-span.rs:140:5
    |
 LL |     invoke_with_ident!{call ItemUse}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
@@ -403,7 +403,7 @@ LL +     ($s:ident $i:ident) => { ItemUse as _ };
    |
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:140:5
+  --> $DIR/mixed-site-span.rs:141:5
    |
 LL |     invoke_with_ident!{hello call ItemUse}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
@@ -417,7 +417,7 @@ LL +     ($m:ident $s:ident $i:ident) => { ItemUse as _ };
    |
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:148:5
+  --> $DIR/mixed-site-span.rs:149:5
    |
 LL |     test!();
    |     ^^^^^^^ no `ItemUse` in the root
@@ -431,7 +431,7 @@ LL +     ($m:ident $s:ident $i:ident) => { ItemUse as _ };
    |
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:144:9
+  --> $DIR/mixed-site-span.rs:145:9
    |
 LL |         with_crate!{$crate mixed ItemUse}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
@@ -447,7 +447,7 @@ LL +         ItemUse as _
    |
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:148:5
+  --> $DIR/mixed-site-span.rs:149:5
    |
 LL |     test!();
    |     ^^^^^^^ no `ItemUse` in the root
@@ -461,7 +461,7 @@ LL +     ($m:ident $s:ident $i:ident) => { ItemUse as _ };
    |
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:153:1
+  --> $DIR/mixed-site-span.rs:154:1
    |
 LL | use_input_crate!{proc_macro_item}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `proc_macro_item` in the root
@@ -469,7 +469,7 @@ LL | use_input_crate!{proc_macro_item}
    = note: this error originates in the macro `use_input_crate` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:154:1
+  --> $DIR/mixed-site-span.rs:155:1
    |
 LL | use_input_krate!{proc_macro_item}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `proc_macro_item` in the root
@@ -477,7 +477,7 @@ LL | use_input_krate!{proc_macro_item}
    = note: this error originates in the macro `use_input_krate` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:157:1
+  --> $DIR/mixed-site-span.rs:158:1
    |
 LL | use_call_crate!{proc_macro_item}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `proc_macro_item` in the root
@@ -485,7 +485,7 @@ LL | use_call_crate!{proc_macro_item}
    = note: this error originates in the macro `use_call_crate` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:158:1
+  --> $DIR/mixed-site-span.rs:159:1
    |
 LL | use_call_krate!{proc_macro_item}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `proc_macro_item` in the root
@@ -493,7 +493,7 @@ LL | use_call_krate!{proc_macro_item}
    = note: this error originates in the macro `use_call_krate` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:163:1
+  --> $DIR/mixed-site-span.rs:164:1
    |
 LL | use_mixed_crate!{TokenItem}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `TokenItem` in the root
@@ -507,7 +507,7 @@ LL +     token_site_span::TokenItem as _
    |
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:164:1
+  --> $DIR/mixed-site-span.rs:165:1
    |
 LL | use_mixed_krate!{TokenItem}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `TokenItem` in the root
@@ -521,7 +521,7 @@ LL + token_site_span::TokenItem as _
    |
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:169:1
+  --> $DIR/mixed-site-span.rs:170:1
    |
 LL | use_input_crate!{ItemUse}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
@@ -529,7 +529,7 @@ LL | use_input_crate!{ItemUse}
    = note: this error originates in the macro `use_input_crate` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:170:1
+  --> $DIR/mixed-site-span.rs:171:1
    |
 LL | use_input_krate!{ItemUse}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
@@ -537,7 +537,7 @@ LL | use_input_krate!{ItemUse}
    = note: this error originates in the macro `use_input_krate` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:171:1
+  --> $DIR/mixed-site-span.rs:172:1
    |
 LL | use_mixed_crate!{ItemUse}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
@@ -545,7 +545,7 @@ LL | use_mixed_crate!{ItemUse}
    = note: this error originates in the macro `use_mixed_crate` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:172:1
+  --> $DIR/mixed-site-span.rs:173:1
    |
 LL | use_mixed_krate!{ItemUse}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
@@ -553,7 +553,7 @@ LL | use_mixed_krate!{ItemUse}
    = note: this error originates in the macro `use_mixed_krate` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:173:1
+  --> $DIR/mixed-site-span.rs:174:1
    |
 LL | use_call_crate!{ItemUse}
    | ^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
@@ -561,7 +561,7 @@ LL | use_call_crate!{ItemUse}
    = note: this error originates in the macro `use_call_crate` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0432]: unresolved import `$crate`
-  --> $DIR/mixed-site-span.rs:174:1
+  --> $DIR/mixed-site-span.rs:175:1
    |
 LL | use_call_krate!{ItemUse}
    | ^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
@@ -569,7 +569,7 @@ LL | use_call_krate!{ItemUse}
    = note: this error originates in the macro `use_call_krate` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0426]: use of undeclared label `'label_use`
-  --> $DIR/mixed-site-span.rs:21:9
+  --> $DIR/mixed-site-span.rs:22:9
    |
 LL |         proc_macro_rules!();
    |         ^^^^^^^^^^^^^^^^^^^ undeclared label `'label_use`
@@ -577,7 +577,7 @@ LL |         proc_macro_rules!();
    = note: this error originates in the macro `proc_macro_rules` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0412]: cannot find type `ItemUse` in crate `$crate`
-  --> $DIR/mixed-site-span.rs:21:9
+  --> $DIR/mixed-site-span.rs:22:9
    |
 LL |         proc_macro_rules!();
    |         ^^^^^^^^^^^^^^^^^^^ not found in `$crate`
@@ -589,7 +589,7 @@ LL + use ItemUse;
    |
 
 error[E0425]: cannot find value `local_use` in this scope
-  --> $DIR/mixed-site-span.rs:21:9
+  --> $DIR/mixed-site-span.rs:22:9
    |
 LL |         proc_macro_rules!();
    |         ^^^^^^^^^^^^^^^^^^^ help: a local variable with a similar name exists: `local_def`
@@ -597,7 +597,7 @@ LL |         proc_macro_rules!();
    = note: this error originates in the macro `proc_macro_rules` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0425]: cannot find value `local_def` in this scope
-  --> $DIR/mixed-site-span.rs:26:9
+  --> $DIR/mixed-site-span.rs:27:9
    |
 LL |         local_def;
    |         ^^^^^^^^^ help: a local variable with a similar name exists: `local_use`
diff --git a/tests/ui/proc-macro/modify-ast.rs b/tests/ui/proc-macro/modify-ast.rs
index 9e890f3ebaad9..75aea597ed576 100644
--- a/tests/ui/proc-macro/modify-ast.rs
+++ b/tests/ui/proc-macro/modify-ast.rs
@@ -1,5 +1,6 @@
 //@ run-pass
 //@ proc-macro: modify-ast.rs
+//@ ignore-backends: gcc
 
 extern crate modify_ast;
 
diff --git a/tests/ui/proc-macro/parent-source-spans.rs b/tests/ui/proc-macro/parent-source-spans.rs
index cc3ac795f7f17..f675f6fb6f7da 100644
--- a/tests/ui/proc-macro/parent-source-spans.rs
+++ b/tests/ui/proc-macro/parent-source-spans.rs
@@ -1,4 +1,5 @@
 //@ proc-macro: parent-source-spans.rs
+//@ ignore-backends: gcc
 
 #![feature(decl_macro)]
 
diff --git a/tests/ui/proc-macro/parent-source-spans.stderr b/tests/ui/proc-macro/parent-source-spans.stderr
index db1eed5e4588e..28a70eea873d1 100644
--- a/tests/ui/proc-macro/parent-source-spans.stderr
+++ b/tests/ui/proc-macro/parent-source-spans.stderr
@@ -1,5 +1,5 @@
 error: first final: "hello"
-  --> $DIR/parent-source-spans.rs:16:12
+  --> $DIR/parent-source-spans.rs:17:12
    |
 LL |     three!($a, $b);
    |            ^^
@@ -10,7 +10,7 @@ LL |     one!("hello", "world");
    = note: this error originates in the macro `two` which comes from the expansion of the macro `one` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: second final: "world"
-  --> $DIR/parent-source-spans.rs:16:16
+  --> $DIR/parent-source-spans.rs:17:16
    |
 LL |     three!($a, $b);
    |                ^^
@@ -21,7 +21,7 @@ LL |     one!("hello", "world");
    = note: this error originates in the macro `two` which comes from the expansion of the macro `one` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: first parent: "hello"
-  --> $DIR/parent-source-spans.rs:10:5
+  --> $DIR/parent-source-spans.rs:11:5
    |
 LL |     two!($a, $b);
    |     ^^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL |     one!("hello", "world");
    = note: this error originates in the macro `one` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: second parent: "world"
-  --> $DIR/parent-source-spans.rs:10:5
+  --> $DIR/parent-source-spans.rs:11:5
    |
 LL |     two!($a, $b);
    |     ^^^^^^^^^^^^
@@ -43,31 +43,31 @@ LL |     one!("hello", "world");
    = note: this error originates in the macro `one` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: first grandparent: "hello"
-  --> $DIR/parent-source-spans.rs:36:5
+  --> $DIR/parent-source-spans.rs:37:5
    |
 LL |     one!("hello", "world");
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: second grandparent: "world"
-  --> $DIR/parent-source-spans.rs:36:5
+  --> $DIR/parent-source-spans.rs:37:5
    |
 LL |     one!("hello", "world");
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: first source: "hello"
-  --> $DIR/parent-source-spans.rs:36:5
+  --> $DIR/parent-source-spans.rs:37:5
    |
 LL |     one!("hello", "world");
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: second source: "world"
-  --> $DIR/parent-source-spans.rs:36:5
+  --> $DIR/parent-source-spans.rs:37:5
    |
 LL |     one!("hello", "world");
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: first final: "yay"
-  --> $DIR/parent-source-spans.rs:16:12
+  --> $DIR/parent-source-spans.rs:17:12
    |
 LL |     three!($a, $b);
    |            ^^
@@ -78,7 +78,7 @@ LL |     two!("yay", "rust");
    = note: this error originates in the macro `two` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: second final: "rust"
-  --> $DIR/parent-source-spans.rs:16:16
+  --> $DIR/parent-source-spans.rs:17:16
    |
 LL |     three!($a, $b);
    |                ^^
@@ -89,55 +89,55 @@ LL |     two!("yay", "rust");
    = note: this error originates in the macro `two` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: first parent: "yay"
-  --> $DIR/parent-source-spans.rs:42:5
+  --> $DIR/parent-source-spans.rs:43:5
    |
 LL |     two!("yay", "rust");
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: second parent: "rust"
-  --> $DIR/parent-source-spans.rs:42:5
+  --> $DIR/parent-source-spans.rs:43:5
    |
 LL |     two!("yay", "rust");
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: first source: "yay"
-  --> $DIR/parent-source-spans.rs:42:5
+  --> $DIR/parent-source-spans.rs:43:5
    |
 LL |     two!("yay", "rust");
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: second source: "rust"
-  --> $DIR/parent-source-spans.rs:42:5
+  --> $DIR/parent-source-spans.rs:43:5
    |
 LL |     two!("yay", "rust");
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: first final: "hip"
-  --> $DIR/parent-source-spans.rs:48:12
+  --> $DIR/parent-source-spans.rs:49:12
    |
 LL |     three!("hip", "hop");
    |            ^^^^^
 
 error: second final: "hop"
-  --> $DIR/parent-source-spans.rs:48:19
+  --> $DIR/parent-source-spans.rs:49:19
    |
 LL |     three!("hip", "hop");
    |                   ^^^^^
 
 error: first source: "hip"
-  --> $DIR/parent-source-spans.rs:48:12
+  --> $DIR/parent-source-spans.rs:49:12
    |
 LL |     three!("hip", "hop");
    |            ^^^^^
 
 error: second source: "hop"
-  --> $DIR/parent-source-spans.rs:48:19
+  --> $DIR/parent-source-spans.rs:49:19
    |
 LL |     three!("hip", "hop");
    |                   ^^^^^
 
 error[E0425]: cannot find value `ok` in this scope
-  --> $DIR/parent-source-spans.rs:29:5
+  --> $DIR/parent-source-spans.rs:30:5
    |
 LL |     parent_source_spans!($($tokens)*);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: a tuple variant with a similar name exists: `Ok`
@@ -152,7 +152,7 @@ LL |     one!("hello", "world");
    = note: this error originates in the macro `parent_source_spans` which comes from the expansion of the macro `one` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0425]: cannot find value `ok` in this scope
-  --> $DIR/parent-source-spans.rs:29:5
+  --> $DIR/parent-source-spans.rs:30:5
    |
 LL |     parent_source_spans!($($tokens)*);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: a tuple variant with a similar name exists: `Ok`
@@ -167,7 +167,7 @@ LL |     two!("yay", "rust");
    = note: this error originates in the macro `parent_source_spans` which comes from the expansion of the macro `two` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0425]: cannot find value `ok` in this scope
-  --> $DIR/parent-source-spans.rs:29:5
+  --> $DIR/parent-source-spans.rs:30:5
    |
 LL |     parent_source_spans!($($tokens)*);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: a tuple variant with a similar name exists: `Ok`
diff --git a/tests/ui/proc-macro/quote/basic.rs b/tests/ui/proc-macro/quote/basic.rs
index 0336dbb785623..4c6fb2408fb49 100644
--- a/tests/ui/proc-macro/quote/basic.rs
+++ b/tests/ui/proc-macro/quote/basic.rs
@@ -1,5 +1,6 @@
 //@ run-pass
 //@ proc-macro: basic.rs
+//@ ignore-backends: gcc
 
 extern crate basic;
 
diff --git a/tests/ui/proc-macro/span-api-tests.rs b/tests/ui/proc-macro/span-api-tests.rs
index 792859ed05b16..12832ba116397 100644
--- a/tests/ui/proc-macro/span-api-tests.rs
+++ b/tests/ui/proc-macro/span-api-tests.rs
@@ -2,6 +2,7 @@
 //@ proc-macro: span-api-tests.rs
 //@ aux-build:span-test-macros.rs
 //@ compile-flags: -Ztranslate-remapped-path-to-local-path=yes
+//@ ignore-backends: gcc
 
 #[macro_use]
 extern crate span_test_macros;
diff --git a/tests/ui/proc-macro/span-from-proc-macro.rs b/tests/ui/proc-macro/span-from-proc-macro.rs
index 4e12a695a5c09..24a28d53476c1 100644
--- a/tests/ui/proc-macro/span-from-proc-macro.rs
+++ b/tests/ui/proc-macro/span-from-proc-macro.rs
@@ -1,6 +1,7 @@
 //@ proc-macro: custom-quote.rs
 //@ proc-macro: span-from-proc-macro.rs
 //@ compile-flags: -Z macro-backtrace
+//@ ignore-backends: gcc
 
 #[macro_use]
 extern crate span_from_proc_macro;
diff --git a/tests/ui/proc-macro/span-from-proc-macro.stderr b/tests/ui/proc-macro/span-from-proc-macro.stderr
index c79ab04eadf4e..945a5620fac48 100644
--- a/tests/ui/proc-macro/span-from-proc-macro.stderr
+++ b/tests/ui/proc-macro/span-from-proc-macro.stderr
@@ -7,7 +7,7 @@ LL | pub fn error_from_attribute(_args: TokenStream, _input: TokenStream) -> Tok
 LL |             field: MissingType
    |                    ^^^^^^^^^^^ not found in this scope
    |
-  ::: $DIR/span-from-proc-macro.rs:8:1
+  ::: $DIR/span-from-proc-macro.rs:9:1
    |
 LL | #[error_from_attribute]
    | ----------------------- in this attribute macro expansion
@@ -21,7 +21,7 @@ LL | pub fn error_from_derive(_input: TokenStream) -> TokenStream {
 LL |             Variant(OtherMissingType)
    |                     ^^^^^^^^^^^^^^^^ not found in this scope
    |
-  ::: $DIR/span-from-proc-macro.rs:11:10
+  ::: $DIR/span-from-proc-macro.rs:12:10
    |
 LL | #[derive(ErrorFromDerive)]
    |          --------------- in this derive macro expansion
@@ -35,7 +35,7 @@ LL |     custom_quote::custom_quote! {
 LL |         my_ident
    |         ^^^^^^^^ not found in this scope
    |
-  ::: $DIR/span-from-proc-macro.rs:16:5
+  ::: $DIR/span-from-proc-macro.rs:17:5
    |
 LL |     other_error_from_bang!();
    |     ------------------------ in this macro invocation
@@ -51,7 +51,7 @@ LL |             let bang_error: bool = 25;
 LL | pub fn error_from_bang(_input: TokenStream) -> TokenStream {
    | ---------------------------------------------------------- in this expansion of `error_from_bang!`
    |
-  ::: $DIR/span-from-proc-macro.rs:15:5
+  ::: $DIR/span-from-proc-macro.rs:16:5
    |
 LL |     error_from_bang!();
    |     ------------------ in this macro invocation
diff --git a/tests/ui/proc-macro/weird-hygiene.rs b/tests/ui/proc-macro/weird-hygiene.rs
index de55484109ae3..8d8427d0e417e 100644
--- a/tests/ui/proc-macro/weird-hygiene.rs
+++ b/tests/ui/proc-macro/weird-hygiene.rs
@@ -1,4 +1,5 @@
 //@ proc-macro: weird-hygiene.rs
+//@ ignore-backends: gcc
 
 #![feature(stmt_expr_attributes)]
 #![feature(proc_macro_hygiene)]
diff --git a/tests/ui/proc-macro/weird-hygiene.stderr b/tests/ui/proc-macro/weird-hygiene.stderr
index 256e68e8970e6..0cfac3f89a045 100644
--- a/tests/ui/proc-macro/weird-hygiene.stderr
+++ b/tests/ui/proc-macro/weird-hygiene.stderr
@@ -1,5 +1,5 @@
 error[E0425]: cannot find value `hidden_ident` in this scope
-  --> $DIR/weird-hygiene.rs:23:43
+  --> $DIR/weird-hygiene.rs:24:43
    |
 LL |             Value = (stringify!($tokens + hidden_ident), 1).1
    |                                           ^^^^^^^^^^^^ not found in this scope
@@ -10,7 +10,7 @@ LL |     other!(50);
    = note: this error originates in the macro `inner` which comes from the expansion of the macro `other` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0425]: cannot find value `hidden_ident` in this scope
-  --> $DIR/weird-hygiene.rs:34:13
+  --> $DIR/weird-hygiene.rs:35:13
    |
 LL |             hidden_ident
    |             ^^^^^^^^^^^^ not found in this scope
diff --git a/tests/ui/process/multi-panic.rs b/tests/ui/process/multi-panic.rs
index 1fddffeb770a3..67bbd16fba75e 100644
--- a/tests/ui/process/multi-panic.rs
+++ b/tests/ui/process/multi-panic.rs
@@ -1,6 +1,7 @@
 //@ run-pass
 //@ needs-subprocess
 //@ needs-unwind
+//@ ignore-backends: gcc
 
 fn check_for_no_backtrace(test: std::process::Output) {
     assert!(!test.status.success());
diff --git a/tests/ui/resolve/prelude-order.rs b/tests/ui/resolve/prelude-order.rs
index a3f194270d483..c6683bdff22a6 100644
--- a/tests/ui/resolve/prelude-order.rs
+++ b/tests/ui/resolve/prelude-order.rs
@@ -1,5 +1,6 @@
 //@ proc-macro:macro_helpers.rs
 //@ compile-flags: --crate-type=lib
+//@ ignore-backends: gcc
 
 /* There are 5 preludes and 3 namespaces. Test the order in which they are resolved.
  * See https://doc.rust-lang.org/nightly/reference/names/preludes.html.
diff --git a/tests/ui/resolve/prelude-order.stderr b/tests/ui/resolve/prelude-order.stderr
index 1b9cc94285aa5..4dad39fb6d240 100644
--- a/tests/ui/resolve/prelude-order.stderr
+++ b/tests/ui/resolve/prelude-order.stderr
@@ -1,17 +1,17 @@
 error[E0433]: failed to resolve: could not find `inner` in `type_ns`
-  --> $DIR/prelude-order.rs:61:12
+  --> $DIR/prelude-order.rs:62:12
    |
 LL | #[type_ns::inner]
    |            ^^^^^ could not find `inner` in `type_ns`
 
 error[E0433]: failed to resolve: could not find `inner` in `usize`
-  --> $DIR/prelude-order.rs:73:10
+  --> $DIR/prelude-order.rs:74:10
    |
 LL | #[usize::inner]
    |          ^^^^^ could not find `inner` in `usize`
 
 error[E0573]: expected type, found crate `Option`
-  --> $DIR/prelude-order.rs:79:12
+  --> $DIR/prelude-order.rs:80:12
    |
 LL | fn e2() -> Option<i32> { None }
    |            ^^^^^^^^^^^ not a type
@@ -22,7 +22,7 @@ LL + use std::option::Option;
    |
 
 error[E0308]: mismatched types
-  --> $DIR/prelude-order.rs:82:1
+  --> $DIR/prelude-order.rs:83:1
    |
 LL | #[test]
    | ^^^^^^^- help: try adding a return type: `-> &'static str`
@@ -32,7 +32,7 @@ LL | #[test]
    = note: this error originates in the attribute macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0308]: mismatched types
-  --> $DIR/prelude-order.rs:86:1
+  --> $DIR/prelude-order.rs:87:1
    |
 LL | #[global_allocator]
    | ^^^^^^^^^^^^^^^^^^^- help: try adding a return type: `-> &'static str`
diff --git a/tests/ui/rfcs/rfc-3348-c-string-literals/edition-spans.rs b/tests/ui/rfcs/rfc-3348-c-string-literals/edition-spans.rs
index 414d5518e1fb0..2387dfb2bc575 100644
--- a/tests/ui/rfcs/rfc-3348-c-string-literals/edition-spans.rs
+++ b/tests/ui/rfcs/rfc-3348-c-string-literals/edition-spans.rs
@@ -7,6 +7,7 @@
 //@ check-pass
 
 //@ proc-macro: count.rs
+//@ ignore-backends: gcc
 extern crate count;
 
 const _: () = {
diff --git a/tests/ui/runtime/backtrace-debuginfo.rs b/tests/ui/runtime/backtrace-debuginfo.rs
index 5e91f22aec029..d3b4d057e6d0f 100644
--- a/tests/ui/runtime/backtrace-debuginfo.rs
+++ b/tests/ui/runtime/backtrace-debuginfo.rs
@@ -19,6 +19,7 @@
 // FIXME(#117097): backtrace (possibly unwinding mechanism) seems to be different on at least
 // `i686-mingw` (32-bit windows-gnu)? cc #128911.
 //@ ignore-windows-gnu
+//@ ignore-backends: gcc
 
 use std::env;
 
diff --git a/tests/ui/runtime/out-of-stack.rs b/tests/ui/runtime/out-of-stack.rs
index 913d3637c8f2b..3e092728f2929 100644
--- a/tests/ui/runtime/out-of-stack.rs
+++ b/tests/ui/runtime/out-of-stack.rs
@@ -10,6 +10,7 @@
 //@ ignore-tvos stack overflow handlers aren't enabled
 //@ ignore-watchos stack overflow handlers aren't enabled
 //@ ignore-visionos stack overflow handlers aren't enabled
+//@ ignore-backends: gcc
 
 #![feature(rustc_private)]
 
diff --git a/tests/ui/rust-2018/suggestions-not-always-applicable.fixed b/tests/ui/rust-2018/suggestions-not-always-applicable.fixed
index e3070ba150b6d..3a42434494d84 100644
--- a/tests/ui/rust-2018/suggestions-not-always-applicable.fixed
+++ b/tests/ui/rust-2018/suggestions-not-always-applicable.fixed
@@ -3,6 +3,7 @@
 //@ run-rustfix
 //@ rustfix-only-machine-applicable
 //@ check-pass
+//@ ignore-backends: gcc
 
 #![warn(rust_2018_compatibility)]
 
diff --git a/tests/ui/rust-2018/suggestions-not-always-applicable.rs b/tests/ui/rust-2018/suggestions-not-always-applicable.rs
index e3070ba150b6d..3a42434494d84 100644
--- a/tests/ui/rust-2018/suggestions-not-always-applicable.rs
+++ b/tests/ui/rust-2018/suggestions-not-always-applicable.rs
@@ -3,6 +3,7 @@
 //@ run-rustfix
 //@ rustfix-only-machine-applicable
 //@ check-pass
+//@ ignore-backends: gcc
 
 #![warn(rust_2018_compatibility)]
 
diff --git a/tests/ui/rust-2021/reserved-prefixes-via-macro.rs b/tests/ui/rust-2021/reserved-prefixes-via-macro.rs
index eec1b859c2033..456649f23ca67 100644
--- a/tests/ui/rust-2021/reserved-prefixes-via-macro.rs
+++ b/tests/ui/rust-2021/reserved-prefixes-via-macro.rs
@@ -1,6 +1,7 @@
 //@ run-pass
 //@ edition:2021
 //@ proc-macro: reserved-prefixes-macro-2018.rs
+//@ ignore-backends: gcc
 
 extern crate reserved_prefixes_macro_2018 as m2018;
 
diff --git a/tests/ui/rust-2024/reserved-guarded-strings-via-macro.rs b/tests/ui/rust-2024/reserved-guarded-strings-via-macro.rs
index ead2ab40b77ac..ddb32c2671739 100644
--- a/tests/ui/rust-2024/reserved-guarded-strings-via-macro.rs
+++ b/tests/ui/rust-2024/reserved-guarded-strings-via-macro.rs
@@ -1,6 +1,7 @@
 //@ run-pass
 //@ edition:2024
 //@ proc-macro: reserved-guarded-strings-macro-2021.rs
+//@ ignore-backends: gcc
 
 extern crate reserved_guarded_strings_macro_2021 as m2021;
 
diff --git a/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes-from-pm.rs b/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes-from-pm.rs
index e2c504e708c55..8b7073649b7a2 100644
--- a/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes-from-pm.rs
+++ b/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes-from-pm.rs
@@ -6,6 +6,7 @@
 //@[edition2021] edition:2021
 //@[edition2024] edition:2024
 //@ proc-macro: unsafe-attributes-pm.rs
+//@ ignore-backends: gcc
 
 unsafe_attributes_pm::missing_unsafe!();
 
diff --git a/tests/ui/sanitizer/cfi/transparent-has-regions.rs b/tests/ui/sanitizer/cfi/transparent-has-regions.rs
index b82850133c100..3e9893df23c92 100644
--- a/tests/ui/sanitizer/cfi/transparent-has-regions.rs
+++ b/tests/ui/sanitizer/cfi/transparent-has-regions.rs
@@ -3,6 +3,7 @@
 //@ no-prefer-dynamic
 //@ only-x86_64-unknown-linux-gnu
 //@ build-pass
+//@ ignore-backends: gcc
 
 pub trait Trait {}
 
diff --git a/tests/ui/sanitizer/issue-111184-cfi-coroutine-witness.rs b/tests/ui/sanitizer/issue-111184-cfi-coroutine-witness.rs
index be81c7bd0cac1..ac2b95b639820 100644
--- a/tests/ui/sanitizer/issue-111184-cfi-coroutine-witness.rs
+++ b/tests/ui/sanitizer/issue-111184-cfi-coroutine-witness.rs
@@ -7,6 +7,7 @@
 //@ no-prefer-dynamic
 //@ only-x86_64-unknown-linux-gnu
 //@ build-pass
+//@ ignore-backends: gcc
 
 use std::future::Future;
 
diff --git a/tests/ui/sepcomp/sepcomp-lib-lto.rs b/tests/ui/sepcomp/sepcomp-lib-lto.rs
index 2166a8fd031ff..f47ea25a4fc58 100644
--- a/tests/ui/sepcomp/sepcomp-lib-lto.rs
+++ b/tests/ui/sepcomp/sepcomp-lib-lto.rs
@@ -5,6 +5,7 @@
 //@ aux-build:sepcomp_lib.rs
 //@ compile-flags: -C lto -g
 //@ no-prefer-dynamic
+//@ ignore-backends: gcc
 
 extern crate sepcomp_lib;
 use sepcomp_lib::a::one;
diff --git a/tests/ui/sepcomp/sepcomp-unwind.rs b/tests/ui/sepcomp/sepcomp-unwind.rs
index 95591676b5eed..0038e887c4ee6 100644
--- a/tests/ui/sepcomp/sepcomp-unwind.rs
+++ b/tests/ui/sepcomp/sepcomp-unwind.rs
@@ -3,6 +3,7 @@
 #![allow(dead_code)]
 //@ compile-flags: -C codegen-units=3
 //@ needs-threads
+//@ ignore-backends: gcc
 
 // Test unwinding through multiple compilation units.
 
diff --git a/tests/ui/simd/intrinsic/generic-arithmetic-2.rs b/tests/ui/simd/intrinsic/generic-arithmetic-2.rs
index caec607d6fe79..d67ff6b33b79b 100644
--- a/tests/ui/simd/intrinsic/generic-arithmetic-2.rs
+++ b/tests/ui/simd/intrinsic/generic-arithmetic-2.rs
@@ -1,4 +1,5 @@
 //@ build-fail
+//@ ignore-backends: gcc
 
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
diff --git a/tests/ui/simd/intrinsic/generic-arithmetic-2.stderr b/tests/ui/simd/intrinsic/generic-arithmetic-2.stderr
index a27a8d721fb05..a2646c8e84872 100644
--- a/tests/ui/simd/intrinsic/generic-arithmetic-2.stderr
+++ b/tests/ui/simd/intrinsic/generic-arithmetic-2.stderr
@@ -1,167 +1,167 @@
 error[E0511]: invalid monomorphization of `simd_add` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:68:9
+  --> $DIR/generic-arithmetic-2.rs:69:9
    |
 LL |         simd_add(0, 0);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_sub` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:70:9
+  --> $DIR/generic-arithmetic-2.rs:71:9
    |
 LL |         simd_sub(0, 0);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_mul` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:72:9
+  --> $DIR/generic-arithmetic-2.rs:73:9
    |
 LL |         simd_mul(0, 0);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_div` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:74:9
+  --> $DIR/generic-arithmetic-2.rs:75:9
    |
 LL |         simd_div(0, 0);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shl` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:76:9
+  --> $DIR/generic-arithmetic-2.rs:77:9
    |
 LL |         simd_shl(0, 0);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shr` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:78:9
+  --> $DIR/generic-arithmetic-2.rs:79:9
    |
 LL |         simd_shr(0, 0);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_funnel_shl` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:80:9
+  --> $DIR/generic-arithmetic-2.rs:81:9
    |
 LL |         simd_funnel_shl(0, 0, 0);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_funnel_shr` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:82:9
+  --> $DIR/generic-arithmetic-2.rs:83:9
    |
 LL |         simd_funnel_shr(0, 0, 0);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_and` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:84:9
+  --> $DIR/generic-arithmetic-2.rs:85:9
    |
 LL |         simd_and(0, 0);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_or` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:86:9
+  --> $DIR/generic-arithmetic-2.rs:87:9
    |
 LL |         simd_or(0, 0);
    |         ^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_xor` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:88:9
+  --> $DIR/generic-arithmetic-2.rs:89:9
    |
 LL |         simd_xor(0, 0);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_neg` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:91:9
+  --> $DIR/generic-arithmetic-2.rs:92:9
    |
 LL |         simd_neg(0);
    |         ^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_bswap` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:93:9
+  --> $DIR/generic-arithmetic-2.rs:94:9
    |
 LL |         simd_bswap(0);
    |         ^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_bitreverse` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:95:9
+  --> $DIR/generic-arithmetic-2.rs:96:9
    |
 LL |         simd_bitreverse(0);
    |         ^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_ctlz` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:97:9
+  --> $DIR/generic-arithmetic-2.rs:98:9
    |
 LL |         simd_ctlz(0);
    |         ^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_cttz` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:99:9
+  --> $DIR/generic-arithmetic-2.rs:100:9
    |
 LL |         simd_cttz(0);
    |         ^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shl` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:102:9
+  --> $DIR/generic-arithmetic-2.rs:103:9
    |
 LL |         simd_shl(z, z);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shr` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:104:9
+  --> $DIR/generic-arithmetic-2.rs:105:9
    |
 LL |         simd_shr(z, z);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_funnel_shl` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:106:9
+  --> $DIR/generic-arithmetic-2.rs:107:9
    |
 LL |         simd_funnel_shl(z, z, z);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_funnel_shr` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:108:9
+  --> $DIR/generic-arithmetic-2.rs:109:9
    |
 LL |         simd_funnel_shr(z, z, z);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_and` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:110:9
+  --> $DIR/generic-arithmetic-2.rs:111:9
    |
 LL |         simd_and(z, z);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_or` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:112:9
+  --> $DIR/generic-arithmetic-2.rs:113:9
    |
 LL |         simd_or(z, z);
    |         ^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_xor` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:114:9
+  --> $DIR/generic-arithmetic-2.rs:115:9
    |
 LL |         simd_xor(z, z);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_bswap` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:116:9
+  --> $DIR/generic-arithmetic-2.rs:117:9
    |
 LL |         simd_bswap(z);
    |         ^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_bitreverse` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:118:9
+  --> $DIR/generic-arithmetic-2.rs:119:9
    |
 LL |         simd_bitreverse(z);
    |         ^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_ctlz` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:120:9
+  --> $DIR/generic-arithmetic-2.rs:121:9
    |
 LL |         simd_ctlz(z);
    |         ^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_ctpop` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:122:9
+  --> $DIR/generic-arithmetic-2.rs:123:9
    |
 LL |         simd_ctpop(z);
    |         ^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_cttz` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:124:9
+  --> $DIR/generic-arithmetic-2.rs:125:9
    |
 LL |         simd_cttz(z);
    |         ^^^^^^^^^^^^
diff --git a/tests/ui/simd/intrinsic/generic-elements.rs b/tests/ui/simd/intrinsic/generic-elements.rs
index 905299a928971..08d1e3ce944d9 100644
--- a/tests/ui/simd/intrinsic/generic-elements.rs
+++ b/tests/ui/simd/intrinsic/generic-elements.rs
@@ -1,4 +1,5 @@
 //@ build-fail
+//@ ignore-backends: gcc
 
 #![feature(
     repr_simd,
diff --git a/tests/ui/simd/intrinsic/generic-elements.stderr b/tests/ui/simd/intrinsic/generic-elements.stderr
index 3779aa86cee19..a32a923633b4c 100644
--- a/tests/ui/simd/intrinsic/generic-elements.stderr
+++ b/tests/ui/simd/intrinsic/generic-elements.stderr
@@ -1,125 +1,125 @@
 error[E0511]: invalid monomorphization of `simd_insert` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-elements.rs:51:9
+  --> $DIR/generic-elements.rs:52:9
    |
 LL |         simd_insert(0, 0, 0);
    |         ^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_insert` intrinsic: expected inserted type `i32` (element of input `i32x4`), found `f64`
-  --> $DIR/generic-elements.rs:53:9
+  --> $DIR/generic-elements.rs:54:9
    |
 LL |         simd_insert(x, 0, 1.0);
    |         ^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_extract` intrinsic: expected return type `i32` (element of input `i32x4`), found `f32`
-  --> $DIR/generic-elements.rs:55:9
+  --> $DIR/generic-elements.rs:56:9
    |
 LL |         simd_extract::<_, f32>(x, 0);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-elements.rs:59:9
+  --> $DIR/generic-elements.rs:60:9
    |
 LL |         simd_shuffle::<i32, _, i32>(0, 0, IDX2);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-elements.rs:62:9
+  --> $DIR/generic-elements.rs:63:9
    |
 LL |         simd_shuffle::<i32, _, i32>(0, 0, IDX4);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-elements.rs:65:9
+  --> $DIR/generic-elements.rs:66:9
    |
 LL |         simd_shuffle::<i32, _, i32>(0, 0, IDX8);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: expected return element type `i32` (element of input `i32x4`), found `f32x2` with element type `f32`
-  --> $DIR/generic-elements.rs:68:9
+  --> $DIR/generic-elements.rs:69:9
    |
 LL |         simd_shuffle::<_, _, f32x2>(x, x, IDX2);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: expected return element type `i32` (element of input `i32x4`), found `f32x4` with element type `f32`
-  --> $DIR/generic-elements.rs:70:9
+  --> $DIR/generic-elements.rs:71:9
    |
 LL |         simd_shuffle::<_, _, f32x4>(x, x, IDX4);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: expected return element type `i32` (element of input `i32x4`), found `f32x8` with element type `f32`
-  --> $DIR/generic-elements.rs:72:9
+  --> $DIR/generic-elements.rs:73:9
    |
 LL |         simd_shuffle::<_, _, f32x8>(x, x, IDX8);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: expected return type of length 2, found `i32x8` with length 8
-  --> $DIR/generic-elements.rs:75:9
+  --> $DIR/generic-elements.rs:76:9
    |
 LL |         simd_shuffle::<_, _, i32x8>(x, x, IDX2);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: expected return type of length 4, found `i32x8` with length 8
-  --> $DIR/generic-elements.rs:77:9
+  --> $DIR/generic-elements.rs:78:9
    |
 LL |         simd_shuffle::<_, _, i32x8>(x, x, IDX4);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: expected return type of length 8, found `i32x2` with length 2
-  --> $DIR/generic-elements.rs:79:9
+  --> $DIR/generic-elements.rs:80:9
    |
 LL |         simd_shuffle::<_, _, i32x2>(x, x, IDX8);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle_const_generic` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-elements.rs:83:9
+  --> $DIR/generic-elements.rs:84:9
    |
 LL |         simd_shuffle_const_generic::<i32, i32, I2>(0, 0);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle_const_generic` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-elements.rs:86:9
+  --> $DIR/generic-elements.rs:87:9
    |
 LL |         simd_shuffle_const_generic::<i32, i32, I4>(0, 0);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle_const_generic` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-elements.rs:89:9
+  --> $DIR/generic-elements.rs:90:9
    |
 LL |         simd_shuffle_const_generic::<i32, i32, I8>(0, 0);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle_const_generic` intrinsic: expected return element type `i32` (element of input `i32x4`), found `f32x2` with element type `f32`
-  --> $DIR/generic-elements.rs:92:9
+  --> $DIR/generic-elements.rs:93:9
    |
 LL |         simd_shuffle_const_generic::<_, f32x2, I2>(x, x);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle_const_generic` intrinsic: expected return element type `i32` (element of input `i32x4`), found `f32x4` with element type `f32`
-  --> $DIR/generic-elements.rs:94:9
+  --> $DIR/generic-elements.rs:95:9
    |
 LL |         simd_shuffle_const_generic::<_, f32x4, I4>(x, x);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle_const_generic` intrinsic: expected return element type `i32` (element of input `i32x4`), found `f32x8` with element type `f32`
-  --> $DIR/generic-elements.rs:96:9
+  --> $DIR/generic-elements.rs:97:9
    |
 LL |         simd_shuffle_const_generic::<_, f32x8, I8>(x, x);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle_const_generic` intrinsic: expected return type of length 2, found `i32x8` with length 8
-  --> $DIR/generic-elements.rs:99:9
+  --> $DIR/generic-elements.rs:100:9
    |
 LL |         simd_shuffle_const_generic::<_, i32x8, I2>(x, x);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle_const_generic` intrinsic: expected return type of length 4, found `i32x8` with length 8
-  --> $DIR/generic-elements.rs:101:9
+  --> $DIR/generic-elements.rs:102:9
    |
 LL |         simd_shuffle_const_generic::<_, i32x8, I4>(x, x);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle_const_generic` intrinsic: expected return type of length 8, found `i32x2` with length 2
-  --> $DIR/generic-elements.rs:103:9
+  --> $DIR/generic-elements.rs:104:9
    |
 LL |         simd_shuffle_const_generic::<_, i32x2, I8>(x, x);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/simd/masked-load-store-build-fail.rs b/tests/ui/simd/masked-load-store-build-fail.rs
index 4b6cc17683c2c..c711b6dfd9770 100644
--- a/tests/ui/simd/masked-load-store-build-fail.rs
+++ b/tests/ui/simd/masked-load-store-build-fail.rs
@@ -1,4 +1,5 @@
 //@ build-fail
+//@ ignore-backends: gcc
 #![feature(repr_simd, core_intrinsics)]
 
 use std::intrinsics::simd::{simd_masked_load, simd_masked_store};
diff --git a/tests/ui/simd/masked-load-store-build-fail.stderr b/tests/ui/simd/masked-load-store-build-fail.stderr
index 7f09841b59710..b9158f46ea9aa 100644
--- a/tests/ui/simd/masked-load-store-build-fail.stderr
+++ b/tests/ui/simd/masked-load-store-build-fail.stderr
@@ -1,47 +1,47 @@
 error[E0511]: invalid monomorphization of `simd_masked_load` intrinsic: expected third argument with length 8 (same as input type `Simd<i8, 8>`), found `Simd<u8, 4>` with length 4
-  --> $DIR/masked-load-store-build-fail.rs:15:9
+  --> $DIR/masked-load-store-build-fail.rs:16:9
    |
 LL |         simd_masked_load(Simd::<i8, 8>([-1, 0, -1, -1, 0, 0, 0, 0]), arr.as_ptr(), default);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_masked_load` intrinsic: expected element type `u8` of second argument `*const i8` to be a pointer to the element type `u8` of the first argument `Simd<u8, 4>`, found `u8` != `*_ u8`
-  --> $DIR/masked-load-store-build-fail.rs:18:9
+  --> $DIR/masked-load-store-build-fail.rs:19:9
    |
 LL |         simd_masked_load(Simd::<i8, 4>([-1, 0, -1, -1]), arr.as_ptr() as *const i8, default);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_masked_load` intrinsic: expected element type `u32` of second argument `*const u8` to be a pointer to the element type `u32` of the first argument `Simd<u32, 4>`, found `u32` != `*_ u32`
-  --> $DIR/masked-load-store-build-fail.rs:21:9
+  --> $DIR/masked-load-store-build-fail.rs:22:9
    |
 LL |         simd_masked_load(Simd::<i8, 4>([-1, 0, -1, -1]), arr.as_ptr(), Simd::<u32, 4>([9; 4]));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_masked_load` intrinsic: expected mask element type to be an integer, found `f32`
-  --> $DIR/masked-load-store-build-fail.rs:24:9
+  --> $DIR/masked-load-store-build-fail.rs:25:9
    |
 LL |         simd_masked_load(Simd::<f32, 4>([1.0, 0.0, 1.0, 1.0]), arr.as_ptr(), default);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_masked_store` intrinsic: expected element type `u32` of second argument `*const u8` to be a pointer to the element type `u32` of the first argument `Simd<u32, 4>`, found `u32` != `*mut u32`
-  --> $DIR/masked-load-store-build-fail.rs:27:9
+  --> $DIR/masked-load-store-build-fail.rs:28:9
    |
 LL |         simd_masked_store(Simd([-1i8; 4]), arr.as_ptr(), Simd([5u32; 4]));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_masked_store` intrinsic: expected element type `u8` of second argument `*const u8` to be a pointer to the element type `u8` of the first argument `Simd<u8, 4>`, found `u8` != `*mut u8`
-  --> $DIR/masked-load-store-build-fail.rs:30:9
+  --> $DIR/masked-load-store-build-fail.rs:31:9
    |
 LL |         simd_masked_store(Simd([-1i8; 4]), arr.as_ptr(), Simd([5u8; 4]));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_masked_store` intrinsic: expected third argument with length 4 (same as input type `Simd<i8, 4>`), found `Simd<u8, 2>` with length 2
-  --> $DIR/masked-load-store-build-fail.rs:33:9
+  --> $DIR/masked-load-store-build-fail.rs:34:9
    |
 LL |         simd_masked_store(Simd([-1i8; 4]), arr.as_mut_ptr(), Simd([5u8; 2]));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_masked_store` intrinsic: expected mask element type to be an integer, found `f32`
-  --> $DIR/masked-load-store-build-fail.rs:36:9
+  --> $DIR/masked-load-store-build-fail.rs:37:9
    |
 LL |         simd_masked_store(Simd([1f32; 4]), arr.as_mut_ptr(), Simd([5u8; 4]));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/simd/monomorphize-shuffle-index.generic.stderr b/tests/ui/simd/monomorphize-shuffle-index.generic.stderr
index b0742bc5ef806..c82adbf8d4c58 100644
--- a/tests/ui/simd/monomorphize-shuffle-index.generic.stderr
+++ b/tests/ui/simd/monomorphize-shuffle-index.generic.stderr
@@ -1,5 +1,5 @@
 error: overly complex generic constant
-  --> $DIR/monomorphize-shuffle-index.rs:36:51
+  --> $DIR/monomorphize-shuffle-index.rs:37:51
    |
 LL |         return simd_shuffle_const_generic::<_, _, { &Self::I.0 }>(a, b);
    |                                                   ^^----------^^
diff --git a/tests/ui/simd/monomorphize-shuffle-index.rs b/tests/ui/simd/monomorphize-shuffle-index.rs
index 1490f8e2319f0..ba952cdb0dc60 100644
--- a/tests/ui/simd/monomorphize-shuffle-index.rs
+++ b/tests/ui/simd/monomorphize-shuffle-index.rs
@@ -1,6 +1,7 @@
 //@ revisions: old generic generic_with_fn
 //@[old]run-pass
 //@[generic_with_fn]run-pass
+//@ ignore-backends: gcc
 #![feature(
     repr_simd,
     core_intrinsics,
diff --git a/tests/ui/simd/not-out-of-bounds.rs b/tests/ui/simd/not-out-of-bounds.rs
index 4bd2a69edbf5e..c80c90e3ab9bd 100644
--- a/tests/ui/simd/not-out-of-bounds.rs
+++ b/tests/ui/simd/not-out-of-bounds.rs
@@ -1,4 +1,5 @@
 //@ build-fail
+//@ ignore-backends: gcc
 #![allow(non_camel_case_types)]
 #![feature(repr_simd, core_intrinsics)]
 
diff --git a/tests/ui/simd/not-out-of-bounds.stderr b/tests/ui/simd/not-out-of-bounds.stderr
index 4b6bda93e4561..734c21fbf4158 100644
--- a/tests/ui/simd/not-out-of-bounds.stderr
+++ b/tests/ui/simd/not-out-of-bounds.stderr
@@ -1,5 +1,5 @@
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: SIMD index #0 is out of bounds (limit 4)
-  --> $DIR/not-out-of-bounds.rs:52:21
+  --> $DIR/not-out-of-bounds.rs:53:21
    |
 LL |                     $y(vec1, vec2, IDX)
    |                     ^^^^^^^^^^^^^^^^^^^
@@ -10,7 +10,7 @@ LL |     test_shuffle_lanes!(2, u8x2, simd_shuffle);
    = note: this error originates in the macro `test_shuffle_lanes` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: SIMD index #0 is out of bounds (limit 8)
-  --> $DIR/not-out-of-bounds.rs:52:21
+  --> $DIR/not-out-of-bounds.rs:53:21
    |
 LL |                     $y(vec1, vec2, IDX)
    |                     ^^^^^^^^^^^^^^^^^^^
@@ -21,7 +21,7 @@ LL |     test_shuffle_lanes!(4, u8x4, simd_shuffle);
    = note: this error originates in the macro `test_shuffle_lanes` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: SIMD index #0 is out of bounds (limit 16)
-  --> $DIR/not-out-of-bounds.rs:52:21
+  --> $DIR/not-out-of-bounds.rs:53:21
    |
 LL |                     $y(vec1, vec2, IDX)
    |                     ^^^^^^^^^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL |     test_shuffle_lanes!(8, u8x8, simd_shuffle);
    = note: this error originates in the macro `test_shuffle_lanes` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: SIMD index #0 is out of bounds (limit 32)
-  --> $DIR/not-out-of-bounds.rs:52:21
+  --> $DIR/not-out-of-bounds.rs:53:21
    |
 LL |                     $y(vec1, vec2, IDX)
    |                     ^^^^^^^^^^^^^^^^^^^
@@ -43,7 +43,7 @@ LL |     test_shuffle_lanes!(16, u8x16, simd_shuffle);
    = note: this error originates in the macro `test_shuffle_lanes` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: SIMD index #0 is out of bounds (limit 64)
-  --> $DIR/not-out-of-bounds.rs:52:21
+  --> $DIR/not-out-of-bounds.rs:53:21
    |
 LL |                     $y(vec1, vec2, IDX)
    |                     ^^^^^^^^^^^^^^^^^^^
@@ -54,7 +54,7 @@ LL |     test_shuffle_lanes!(32, u8x32, simd_shuffle);
    = note: this error originates in the macro `test_shuffle_lanes` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: SIMD index #0 is out of bounds (limit 128)
-  --> $DIR/not-out-of-bounds.rs:52:21
+  --> $DIR/not-out-of-bounds.rs:53:21
    |
 LL |                     $y(vec1, vec2, IDX)
    |                     ^^^^^^^^^^^^^^^^^^^
@@ -65,19 +65,19 @@ LL |     test_shuffle_lanes!(64, u8x64, simd_shuffle);
    = note: this error originates in the macro `test_shuffle_lanes` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: SIMD index #0 is out of bounds (limit 4)
-  --> $DIR/not-out-of-bounds.rs:77:23
+  --> $DIR/not-out-of-bounds.rs:78:23
    |
 LL |         let _: u8x2 = simd_shuffle(v, v, I);
    |                       ^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_insert` intrinsic: SIMD index #1 is out of bounds (limit 2)
-  --> $DIR/not-out-of-bounds.rs:83:9
+  --> $DIR/not-out-of-bounds.rs:84:9
    |
 LL |         simd_insert(v, 2, 0u8);
    |         ^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_extract` intrinsic: SIMD index #1 is out of bounds (limit 2)
-  --> $DIR/not-out-of-bounds.rs:84:24
+  --> $DIR/not-out-of-bounds.rs:85:24
    |
 LL |         let _val: u8 = simd_extract(v, 2);
    |                        ^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/structs-enums/unit-like-struct-drop-run.rs b/tests/ui/structs-enums/unit-like-struct-drop-run.rs
index 3d00871837cf8..5e3fc5931bdc5 100644
--- a/tests/ui/structs-enums/unit-like-struct-drop-run.rs
+++ b/tests/ui/structs-enums/unit-like-struct-drop-run.rs
@@ -1,6 +1,7 @@
 //@ run-pass
 //@ needs-unwind
 //@ needs-threads
+//@ ignore-backends: gcc
 
 // Make sure the destructor is run for unit-like structs.
 
diff --git a/tests/ui/suggestions/issue-61963.rs b/tests/ui/suggestions/issue-61963.rs
index 77e4b21f5dbd5..bf0680b986038 100644
--- a/tests/ui/suggestions/issue-61963.rs
+++ b/tests/ui/suggestions/issue-61963.rs
@@ -1,6 +1,7 @@
 //@ edition: 2015
 //@ proc-macro: issue-61963.rs
 //@ proc-macro: issue-61963-1.rs
+//@ ignore-backends: gcc
 #![deny(bare_trait_objects)]
 
 #[macro_use]
diff --git a/tests/ui/suggestions/issue-61963.stderr b/tests/ui/suggestions/issue-61963.stderr
index ffdeef12bb7f1..f9146a619ec45 100644
--- a/tests/ui/suggestions/issue-61963.stderr
+++ b/tests/ui/suggestions/issue-61963.stderr
@@ -1,5 +1,5 @@
 error: trait objects without an explicit `dyn` are deprecated
-  --> $DIR/issue-61963.rs:23:14
+  --> $DIR/issue-61963.rs:24:14
    |
 LL |     bar: Box<Bar>,
    |              ^^^
@@ -7,7 +7,7 @@ LL |     bar: Box<Bar>,
    = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
    = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/warnings-promoted-to-error.html>
 note: the lint level is defined here
-  --> $DIR/issue-61963.rs:4:9
+  --> $DIR/issue-61963.rs:5:9
    |
 LL | #![deny(bare_trait_objects)]
    |         ^^^^^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL |     bar: Box<dyn Bar>,
    |              +++
 
 error: trait objects without an explicit `dyn` are deprecated
-  --> $DIR/issue-61963.rs:19:1
+  --> $DIR/issue-61963.rs:20:1
    |
 LL | pub struct Foo {
    | ^^^
diff --git a/tests/ui/suggestions/suggest-ref-macro.rs b/tests/ui/suggestions/suggest-ref-macro.rs
index 2f31af33782cb..41a2acf90628a 100644
--- a/tests/ui/suggestions/suggest-ref-macro.rs
+++ b/tests/ui/suggestions/suggest-ref-macro.rs
@@ -1,5 +1,6 @@
 // run-check
 //@ proc-macro: proc-macro-type-error.rs
+//@ ignore-backends: gcc
 
 extern crate proc_macro_type_error;
 
diff --git a/tests/ui/suggestions/suggest-ref-macro.stderr b/tests/ui/suggestions/suggest-ref-macro.stderr
index 08bc9e86a50f8..2a52c1e244502 100644
--- a/tests/ui/suggestions/suggest-ref-macro.stderr
+++ b/tests/ui/suggestions/suggest-ref-macro.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/suggest-ref-macro.rs:8:1
+  --> $DIR/suggest-ref-macro.rs:9:1
    |
 LL | #[hello]
    | ^^^^^^^^
@@ -8,14 +8,14 @@ LL | #[hello]
    | arguments to this function are incorrect
    |
 note: function defined here
-  --> $DIR/suggest-ref-macro.rs:8:1
+  --> $DIR/suggest-ref-macro.rs:9:1
    |
 LL | #[hello]
    | ^^^^^^^^
    = note: this error originates in the attribute macro `hello` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-ref-macro.rs:15:11
+  --> $DIR/suggest-ref-macro.rs:16:11
    |
 LL |         x(123);
    |         - ^^^ expected `&mut i32`, found integer
@@ -26,7 +26,7 @@ LL |     bla!();
    |     ------ in this macro invocation
    |
 note: function defined here
-  --> $DIR/suggest-ref-macro.rs:11:4
+  --> $DIR/suggest-ref-macro.rs:12:4
    |
 LL | fn x(_: &mut i32) {}
    |    ^ -----------
@@ -37,7 +37,7 @@ LL |         x(&mut 123);
    |           ++++
 
 error[E0308]: mismatched types
-  --> $DIR/suggest-ref-macro.rs:26:10
+  --> $DIR/suggest-ref-macro.rs:27:10
    |
 LL |         x($v)
    |         - arguments to this function are incorrect
@@ -46,7 +46,7 @@ LL |     bla!(456);
    |          ^^^ expected `&mut i32`, found integer
    |
 note: function defined here
-  --> $DIR/suggest-ref-macro.rs:11:4
+  --> $DIR/suggest-ref-macro.rs:12:4
    |
 LL | fn x(_: &mut i32) {}
    |    ^ -----------
diff --git a/tests/ui/test-attrs/test-panic-while-printing.rs b/tests/ui/test-attrs/test-panic-while-printing.rs
index a50a15fbe5af5..49e8d9c7afdf1 100644
--- a/tests/ui/test-attrs/test-panic-while-printing.rs
+++ b/tests/ui/test-attrs/test-panic-while-printing.rs
@@ -1,6 +1,7 @@
 //@ compile-flags:--test
 //@ run-pass
 //@ needs-unwind
+//@ ignore-backends: gcc
 
 use std::fmt;
 use std::fmt::{Display, Formatter};
diff --git a/tests/ui/threads-sendsync/task-stderr.rs b/tests/ui/threads-sendsync/task-stderr.rs
index 3934084e02a0a..f54b5a5cc5f68 100644
--- a/tests/ui/threads-sendsync/task-stderr.rs
+++ b/tests/ui/threads-sendsync/task-stderr.rs
@@ -1,6 +1,7 @@
 //@ run-pass
 //@ needs-threads
 //@ needs-unwind
+//@ ignore-backends: gcc
 
 #![feature(internal_output_capture)]
 
diff --git a/tests/ui/threads-sendsync/unwind-resource.rs b/tests/ui/threads-sendsync/unwind-resource.rs
index ec27a1846fef2..c5fbfc5bf5b03 100644
--- a/tests/ui/threads-sendsync/unwind-resource.rs
+++ b/tests/ui/threads-sendsync/unwind-resource.rs
@@ -3,6 +3,7 @@
 
 #![allow(non_camel_case_types)]
 //@ needs-threads
+//@ ignore-backends: gcc
 
 use std::sync::mpsc::{channel, Sender};
 use std::thread;
diff --git a/tests/ui/traits/clone-unwind-rc-cleanup.rs b/tests/ui/traits/clone-unwind-rc-cleanup.rs
index cd02050ea2746..dab48a1b4c6cf 100644
--- a/tests/ui/traits/clone-unwind-rc-cleanup.rs
+++ b/tests/ui/traits/clone-unwind-rc-cleanup.rs
@@ -2,6 +2,7 @@
 
 //@ run-pass
 //@ needs-unwind
+//@ ignore-backends: gcc
 
 #![allow(unused_variables)]
 #![allow(unused_imports)]
diff --git a/tests/ui/typeck/invalid-sugg-for-derive-macro-issue-136343.rs b/tests/ui/typeck/invalid-sugg-for-derive-macro-issue-136343.rs
index c08030fc5c150..81c2d778b057f 100644
--- a/tests/ui/typeck/invalid-sugg-for-derive-macro-issue-136343.rs
+++ b/tests/ui/typeck/invalid-sugg-for-derive-macro-issue-136343.rs
@@ -1,4 +1,5 @@
 //@ proc-macro: derive-demo-issue-136343.rs
+//@ ignore-backends: gcc
 
 #[macro_use]
 extern crate derive_demo_issue_136343;
diff --git a/tests/ui/typeck/invalid-sugg-for-derive-macro-issue-136343.stderr b/tests/ui/typeck/invalid-sugg-for-derive-macro-issue-136343.stderr
index 0b9c1d9123aab..d69eaae533551 100644
--- a/tests/ui/typeck/invalid-sugg-for-derive-macro-issue-136343.stderr
+++ b/tests/ui/typeck/invalid-sugg-for-derive-macro-issue-136343.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/invalid-sugg-for-derive-macro-issue-136343.rs:6:10
+  --> $DIR/invalid-sugg-for-derive-macro-issue-136343.rs:7:10
    |
 LL | #[derive(Sample)]
    |          ^^^^^^

From 1acd65cd6dffb34a2c8576ebc3874527a9f601e0 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Mon, 22 Sep 2025 14:09:03 +0200
Subject: [PATCH 1427/1889] predefined opaques use `List`

---
 compiler/rustc_middle/src/arena.rs            |  1 -
 compiler/rustc_middle/src/traits/solve.rs     | 45 +------------------
 compiler/rustc_middle/src/ty/context.rs       | 10 ++---
 .../rustc_middle/src/ty/structural_impls.rs   |  1 +
 .../src/canonical/mod.rs                      |  8 ++--
 .../src/solve/eval_ctxt/mod.rs                |  7 ++-
 compiler/rustc_type_ir/src/interner.rs        |  8 ++--
 compiler/rustc_type_ir/src/solve/mod.rs       | 13 ------
 8 files changed, 16 insertions(+), 77 deletions(-)

diff --git a/compiler/rustc_middle/src/arena.rs b/compiler/rustc_middle/src/arena.rs
index 52fbe19c9f2d7..fa6a2db38ef9c 100644
--- a/compiler/rustc_middle/src/arena.rs
+++ b/compiler/rustc_middle/src/arena.rs
@@ -109,7 +109,6 @@ macro_rules! arena_types {
                     rustc_middle::ty::EarlyBinder<'tcx, rustc_middle::ty::Ty<'tcx>>
                 >,
             [] external_constraints: rustc_middle::traits::solve::ExternalConstraintsData<rustc_middle::ty::TyCtxt<'tcx>>,
-            [] predefined_opaques_in_body: rustc_middle::traits::solve::PredefinedOpaquesData<rustc_middle::ty::TyCtxt<'tcx>>,
             [decode] doc_link_resolutions: rustc_hir::def::DocLinkResMap,
             [] stripped_cfg_items: rustc_hir::attrs::StrippedCfgItem,
             [] mod_child: rustc_middle::metadata::ModChild,
diff --git a/compiler/rustc_middle/src/traits/solve.rs b/compiler/rustc_middle/src/traits/solve.rs
index ef5223de0e825..3343f27033301 100644
--- a/compiler/rustc_middle/src/traits/solve.rs
+++ b/compiler/rustc_middle/src/traits/solve.rs
@@ -4,7 +4,7 @@ use rustc_type_ir as ir;
 pub use rustc_type_ir::solve::*;
 
 use crate::ty::{
-    self, FallibleTypeFolder, TyCtxt, TypeFoldable, TypeFolder, TypeVisitable, TypeVisitor,
+    self, FallibleTypeFolder, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeVisitable, TypeVisitor,
     try_visit,
 };
 
@@ -15,16 +15,7 @@ pub type CandidateSource<'tcx> = ir::solve::CandidateSource<TyCtxt<'tcx>>;
 pub type CanonicalInput<'tcx, P = ty::Predicate<'tcx>> = ir::solve::CanonicalInput<TyCtxt<'tcx>, P>;
 pub type CanonicalResponse<'tcx> = ir::solve::CanonicalResponse<TyCtxt<'tcx>>;
 
-#[derive(Debug, PartialEq, Eq, Copy, Clone, Hash, HashStable)]
-pub struct PredefinedOpaques<'tcx>(pub(crate) Interned<'tcx, PredefinedOpaquesData<TyCtxt<'tcx>>>);
-
-impl<'tcx> std::ops::Deref for PredefinedOpaques<'tcx> {
-    type Target = PredefinedOpaquesData<TyCtxt<'tcx>>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
+pub type PredefinedOpaques<'tcx> = &'tcx ty::List<(ty::OpaqueTypeKey<'tcx>, Ty<'tcx>)>;
 
 #[derive(Debug, PartialEq, Eq, Copy, Clone, Hash, HashStable)]
 pub struct ExternalConstraints<'tcx>(
@@ -93,35 +84,3 @@ impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for ExternalConstraints<'tcx> {
         self.normalization_nested_goals.visit_with(visitor)
     }
 }
-
-// FIXME: Having to clone `region_constraints` for folding feels bad and
-// probably isn't great wrt performance.
-//
-// Not sure how to fix this, maybe we should also intern `opaque_types` and
-// `region_constraints` here or something.
-impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for PredefinedOpaques<'tcx> {
-    fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
-        self,
-        folder: &mut F,
-    ) -> Result<Self, F::Error> {
-        Ok(FallibleTypeFolder::cx(folder).mk_predefined_opaques_in_body(PredefinedOpaquesData {
-            opaque_types: self
-                .opaque_types
-                .iter()
-                .map(|opaque| opaque.try_fold_with(folder))
-                .collect::<Result<_, F::Error>>()?,
-        }))
-    }
-
-    fn fold_with<F: TypeFolder<TyCtxt<'tcx>>>(self, folder: &mut F) -> Self {
-        TypeFolder::cx(folder).mk_predefined_opaques_in_body(PredefinedOpaquesData {
-            opaque_types: self.opaque_types.iter().map(|opaque| opaque.fold_with(folder)).collect(),
-        })
-    }
-}
-
-impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for PredefinedOpaques<'tcx> {
-    fn visit_with<V: TypeVisitor<TyCtxt<'tcx>>>(&self, visitor: &mut V) -> V::Result {
-        self.opaque_types.visit_with(visitor)
-    }
-}
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 7d3e2c9965dad..aa34651464518 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -74,8 +74,7 @@ use crate::query::{IntoQueryParam, LocalCrate, Providers, TyCtxtAt};
 use crate::thir::Thir;
 use crate::traits;
 use crate::traits::solve::{
-    self, CanonicalInput, ExternalConstraints, ExternalConstraintsData, PredefinedOpaques,
-    PredefinedOpaquesData, QueryResult, inspect,
+    self, CanonicalInput, ExternalConstraints, ExternalConstraintsData, QueryResult, inspect,
 };
 use crate::ty::predicate::ExistentialPredicateStableCmpExt as _;
 use crate::ty::{
@@ -116,7 +115,7 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
 
     fn mk_predefined_opaques_in_body(
         self,
-        data: PredefinedOpaquesData<Self>,
+        data: &[(ty::OpaqueTypeKey<'tcx>, Ty<'tcx>)],
     ) -> Self::PredefinedOpaques {
         self.mk_predefined_opaques_in_body(data)
     }
@@ -941,7 +940,7 @@ pub struct CtxtInterners<'tcx> {
     layout: InternedSet<'tcx, LayoutData<FieldIdx, VariantIdx>>,
     adt_def: InternedSet<'tcx, AdtDefData>,
     external_constraints: InternedSet<'tcx, ExternalConstraintsData<TyCtxt<'tcx>>>,
-    predefined_opaques_in_body: InternedSet<'tcx, PredefinedOpaquesData<TyCtxt<'tcx>>>,
+    predefined_opaques_in_body: InternedSet<'tcx, List<(ty::OpaqueTypeKey<'tcx>, Ty<'tcx>)>>,
     fields: InternedSet<'tcx, List<FieldIdx>>,
     local_def_ids: InternedSet<'tcx, List<LocalDefId>>,
     captures: InternedSet<'tcx, List<&'tcx ty::CapturedPlace<'tcx>>>,
@@ -2748,8 +2747,6 @@ direct_interners! {
     adt_def: pub mk_adt_def_from_data(AdtDefData): AdtDef -> AdtDef<'tcx>,
     external_constraints: pub mk_external_constraints(ExternalConstraintsData<TyCtxt<'tcx>>):
         ExternalConstraints -> ExternalConstraints<'tcx>,
-    predefined_opaques_in_body: pub mk_predefined_opaques_in_body(PredefinedOpaquesData<TyCtxt<'tcx>>):
-        PredefinedOpaques -> PredefinedOpaques<'tcx>,
 }
 
 macro_rules! slice_interners {
@@ -2786,6 +2783,7 @@ slice_interners!(
     offset_of: pub mk_offset_of((VariantIdx, FieldIdx)),
     patterns: pub mk_patterns(Pattern<'tcx>),
     outlives: pub mk_outlives(ty::ArgOutlivesPredicate<'tcx>),
+    predefined_opaques_in_body: pub mk_predefined_opaques_in_body((ty::OpaqueTypeKey<'tcx>, Ty<'tcx>)),
 );
 
 impl<'tcx> TyCtxt<'tcx> {
diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs
index 11d109b463d90..8dc4dfd677ba8 100644
--- a/compiler/rustc_middle/src/ty/structural_impls.rs
+++ b/compiler/rustc_middle/src/ty/structural_impls.rs
@@ -796,6 +796,7 @@ macro_rules! list_fold {
 
 list_fold! {
     &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>> : mk_poly_existential_predicates,
+    &'tcx ty::List<(ty::OpaqueTypeKey<'tcx>, Ty<'tcx>)>: mk_predefined_opaques_in_body,
     &'tcx ty::List<PlaceElem<'tcx>> : mk_place_elems,
     &'tcx ty::List<ty::Pattern<'tcx>> : mk_patterns,
     &'tcx ty::List<ty::ArgOutlivesPredicate<'tcx>> : mk_outlives,
diff --git a/compiler/rustc_next_trait_solver/src/canonical/mod.rs b/compiler/rustc_next_trait_solver/src/canonical/mod.rs
index e3520e238ed37..b036ee6df7ecf 100644
--- a/compiler/rustc_next_trait_solver/src/canonical/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/canonical/mod.rs
@@ -25,7 +25,7 @@ use crate::delegate::SolverDelegate;
 use crate::resolve::eager_resolve_vars;
 use crate::solve::{
     CanonicalInput, CanonicalResponse, Certainty, ExternalConstraintsData, Goal,
-    NestedNormalizationGoals, PredefinedOpaquesData, QueryInput, Response, inspect,
+    NestedNormalizationGoals, QueryInput, Response, inspect,
 };
 
 pub mod canonicalizer;
@@ -53,7 +53,7 @@ impl<I: Interner, T> ResponseT<I> for inspect::State<I, T> {
 pub(super) fn canonicalize_goal<D, I>(
     delegate: &D,
     goal: Goal<I, I::Predicate>,
-    opaque_types: Vec<(ty::OpaqueTypeKey<I>, I::Ty)>,
+    opaque_types: &[(ty::OpaqueTypeKey<I>, I::Ty)],
 ) -> (Vec<I::GenericArg>, CanonicalInput<I, I::Predicate>)
 where
     D: SolverDelegate<Interner = I>,
@@ -65,9 +65,7 @@ where
         &mut orig_values,
         QueryInput {
             goal,
-            predefined_opaques_in_body: delegate
-                .cx()
-                .mk_predefined_opaques_in_body(PredefinedOpaquesData { opaque_types }),
+            predefined_opaques_in_body: delegate.cx().mk_predefined_opaques_in_body(opaque_types),
         },
     );
     let query_input = ty::CanonicalQueryInput { canonical, typing_mode: delegate.typing_mode() };
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
index bb86357a85f8a..9b32e4876075d 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
@@ -357,7 +357,7 @@ where
         f: impl FnOnce(&mut EvalCtxt<'_, D>, Goal<I, I::Predicate>) -> R,
     ) -> R {
         let (ref delegate, input, var_values) = D::build_with_canonical(cx, &canonical_input);
-        for &(key, ty) in &input.predefined_opaques_in_body.opaque_types {
+        for (key, ty) in input.predefined_opaques_in_body.iter() {
             let prev = delegate.register_hidden_type_in_storage(key, ty, I::Span::dummy());
             // It may be possible that two entries in the opaque type storage end up
             // with the same key after resolving contained inference variables.
@@ -467,7 +467,7 @@ where
         let opaque_types = self.delegate.clone_opaque_types_lookup_table();
         let (goal, opaque_types) = eager_resolve_vars(self.delegate, (goal, opaque_types));
 
-        let (orig_values, canonical_goal) = canonicalize_goal(self.delegate, goal, opaque_types);
+        let (orig_values, canonical_goal) = canonicalize_goal(self.delegate, goal, &opaque_types);
         let canonical_result = self.search_graph.evaluate_goal(
             self.cx(),
             canonical_goal,
@@ -548,7 +548,6 @@ where
                             .canonical
                             .value
                             .predefined_opaques_in_body
-                            .opaque_types
                             .len(),
                         stalled_vars,
                         sub_roots,
@@ -1557,7 +1556,7 @@ pub(super) fn evaluate_root_goal_for_proof_tree<D: SolverDelegate<Interner = I>,
     let opaque_types = delegate.clone_opaque_types_lookup_table();
     let (goal, opaque_types) = eager_resolve_vars(delegate, (goal, opaque_types));
 
-    let (orig_values, canonical_goal) = canonicalize_goal(delegate, goal, opaque_types);
+    let (orig_values, canonical_goal) = canonicalize_goal(delegate, goal, &opaque_types);
 
     let (canonical_result, final_revision) =
         delegate.cx().evaluate_root_goal_for_proof_tree_raw(canonical_goal);
diff --git a/compiler/rustc_type_ir/src/interner.rs b/compiler/rustc_type_ir/src/interner.rs
index cf58aec14a680..886d1a78bcbfd 100644
--- a/compiler/rustc_type_ir/src/interner.rs
+++ b/compiler/rustc_type_ir/src/interner.rs
@@ -11,9 +11,7 @@ use crate::inherent::*;
 use crate::ir_print::IrPrint;
 use crate::lang_items::{SolverAdtLangItem, SolverLangItem, SolverTraitLangItem};
 use crate::relate::Relate;
-use crate::solve::{
-    CanonicalInput, ExternalConstraintsData, PredefinedOpaquesData, QueryResult, inspect,
-};
+use crate::solve::{CanonicalInput, ExternalConstraintsData, QueryResult, inspect};
 use crate::visit::{Flags, TypeVisitable};
 use crate::{self as ty, CanonicalParamEnvCacheEntry, search_graph};
 
@@ -70,10 +68,10 @@ pub trait Interner:
         + Hash
         + Eq
         + TypeFoldable<Self>
-        + Deref<Target = PredefinedOpaquesData<Self>>;
+        + SliceLike<Item = (ty::OpaqueTypeKey<Self>, Self::Ty)>;
     fn mk_predefined_opaques_in_body(
         self,
-        data: PredefinedOpaquesData<Self>,
+        data: &[(ty::OpaqueTypeKey<Self>, Self::Ty)],
     ) -> Self::PredefinedOpaques;
 
     type LocalDefIds: Copy
diff --git a/compiler/rustc_type_ir/src/solve/mod.rs b/compiler/rustc_type_ir/src/solve/mod.rs
index 1a1606d82685c..9d9a8e4984786 100644
--- a/compiler/rustc_type_ir/src/solve/mod.rs
+++ b/compiler/rustc_type_ir/src/solve/mod.rs
@@ -109,19 +109,6 @@ pub struct QueryInput<I: Interner, P> {
 
 impl<I: Interner, P: Eq> Eq for QueryInput<I, P> {}
 
-/// Opaques that are defined in the inference context before a query is called.
-#[derive_where(Clone, Hash, PartialEq, Debug, Default; I: Interner)]
-#[derive(TypeVisitable_Generic, TypeFoldable_Generic)]
-#[cfg_attr(
-    feature = "nightly",
-    derive(Decodable_NoContext, Encodable_NoContext, HashStable_NoContext)
-)]
-pub struct PredefinedOpaquesData<I: Interner> {
-    pub opaque_types: Vec<(ty::OpaqueTypeKey<I>, I::Ty)>,
-}
-
-impl<I: Interner> Eq for PredefinedOpaquesData<I> {}
-
 /// Possible ways the given goal can be proven.
 #[derive_where(Clone, Copy, Hash, PartialEq, Debug; I: Interner)]
 pub enum CandidateSource<I: Interner> {

From b70a15f5f62f17f1bea1a0260fe629143cf55316 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Mon, 22 Sep 2025 14:26:08 +0200
Subject: [PATCH 1428/1889] predefined opaques to `method_autoderef_steps`

---
 compiler/rustc_hir_typeck/src/method/probe.rs | 49 +++++++++++++++----
 compiler/rustc_middle/src/query/mod.rs        |  6 +--
 compiler/rustc_middle/src/traits/query.rs     | 12 ++++-
 compiler/rustc_middle/src/ty/context.rs       | 11 ++++-
 4 files changed, 63 insertions(+), 15 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/method/probe.rs b/compiler/rustc_hir_typeck/src/method/probe.rs
index 4185f7f6996c8..e0cd1f20080a6 100644
--- a/compiler/rustc_hir_typeck/src/method/probe.rs
+++ b/compiler/rustc_hir_typeck/src/method/probe.rs
@@ -13,7 +13,7 @@ use rustc_hir::def::DefKind;
 use rustc_hir_analysis::autoderef::{self, Autoderef};
 use rustc_infer::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse};
 use rustc_infer::infer::{BoundRegionConversionTime, DefineOpaqueTypes, InferOk, TyCtxtInferExt};
-use rustc_infer::traits::ObligationCauseCode;
+use rustc_infer::traits::{ObligationCauseCode, query};
 use rustc_middle::middle::stability;
 use rustc_middle::ty::elaborate::supertrait_def_ids;
 use rustc_middle::ty::fast_reject::{DeepRejectCtxt, TreatParams, simplify_type};
@@ -30,7 +30,7 @@ use rustc_span::edit_distance::{
 use rustc_span::{DUMMY_SP, Ident, Span, Symbol, sym};
 use rustc_trait_selection::error_reporting::infer::need_type_info::TypeAnnotationNeeded;
 use rustc_trait_selection::infer::InferCtxtExt as _;
-use rustc_trait_selection::traits::query::CanonicalTyGoal;
+use rustc_trait_selection::traits::query::CanonicalMethodAutoderefStepsGoal;
 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt;
 use rustc_trait_selection::traits::query::method_autoderef::{
     CandidateStep, MethodAutoderefBadTy, MethodAutoderefStepsResult,
@@ -389,10 +389,16 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         OP: FnOnce(ProbeContext<'_, 'tcx>) -> Result<R, MethodError<'tcx>>,
     {
         let mut orig_values = OriginalQueryValues::default();
-        let query_input = self.canonicalize_query(
-            ParamEnvAnd { param_env: self.param_env, value: self_ty },
-            &mut orig_values,
-        );
+        let predefined_opaques_in_body = if self.next_trait_solver() {
+            self.tcx.mk_predefined_opaques_in_body_from_iter(
+                self.inner.borrow_mut().opaque_types().iter_opaque_types().map(|(k, v)| (k, v.ty)),
+            )
+        } else {
+            ty::List::empty()
+        };
+        let value = query::MethodAutoderefSteps { predefined_opaques_in_body, self_ty };
+        let query_input = self
+            .canonicalize_query(ParamEnvAnd { param_env: self.param_env, value }, &mut orig_values);
 
         let steps = match mode {
             Mode::MethodCall => self.tcx.method_autoderef_steps(query_input),
@@ -403,8 +409,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 // special handling for this "trivial case" is a good idea.
 
                 let infcx = &self.infcx;
-                let (ParamEnvAnd { param_env: _, value: self_ty }, var_values) =
+                let (ParamEnvAnd { param_env: _, value }, var_values) =
                     infcx.instantiate_canonical(span, &query_input.canonical);
+                let query::MethodAutoderefSteps { predefined_opaques_in_body: _, self_ty } = value;
                 debug!(?self_ty, ?query_input, "probe_op: Mode::Path");
                 MethodAutoderefStepsResult {
                     steps: infcx.tcx.arena.alloc_from_iter([CandidateStep {
@@ -553,12 +560,33 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
 pub(crate) fn method_autoderef_steps<'tcx>(
     tcx: TyCtxt<'tcx>,
-    goal: CanonicalTyGoal<'tcx>,
+    goal: CanonicalMethodAutoderefStepsGoal<'tcx>,
 ) -> MethodAutoderefStepsResult<'tcx> {
     debug!("method_autoderef_steps({:?})", goal);
 
     let (ref infcx, goal, inference_vars) = tcx.infer_ctxt().build_with_canonical(DUMMY_SP, &goal);
-    let ParamEnvAnd { param_env, value: self_ty } = goal;
+    let ParamEnvAnd {
+        param_env,
+        value: query::MethodAutoderefSteps { predefined_opaques_in_body, self_ty },
+    } = goal;
+    for (key, ty) in predefined_opaques_in_body {
+        let prev =
+            infcx.register_hidden_type_in_storage(key, ty::OpaqueHiddenType { span: DUMMY_SP, ty });
+        // It may be possible that two entries in the opaque type storage end up
+        // with the same key after resolving contained inference variables.
+        //
+        // We could put them in the duplicate list but don't have to. The opaques we
+        // encounter here are already tracked in the caller, so there's no need to
+        // also store them here. We'd take them out when computing the query response
+        // and then discard them, as they're already present in the input.
+        //
+        // Ideally we'd drop duplicate opaque type definitions when computing
+        // the canonical input. This is more annoying to implement and may cause a
+        // perf regression, so we do it inside of the query for now.
+        if let Some(prev) = prev {
+            debug!(?key, ?ty, ?prev, "ignore duplicate in `opaque_types_storage`");
+        }
+    }
 
     // If arbitrary self types is not enabled, we follow the chain of
     // `Deref<Target=T>`. If arbitrary self types is enabled, we instead
@@ -655,7 +683,8 @@ pub(crate) fn method_autoderef_steps<'tcx>(
     };
 
     debug!("method_autoderef_steps: steps={:?} opt_bad_ty={:?}", steps, opt_bad_ty);
-
+    // Need to empty the opaque types storage before it gets dropped.
+    let _ = infcx.take_opaque_types();
     MethodAutoderefStepsResult {
         steps: tcx.arena.alloc_from_iter(steps),
         opt_bad_ty: opt_bad_ty.map(|ty| &*tcx.arena.alloc(ty)),
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 0e645a3aae45b..326df9239aa08 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -124,7 +124,7 @@ use crate::query::plumbing::{
 };
 use crate::traits::query::{
     CanonicalAliasGoal, CanonicalDropckOutlivesGoal, CanonicalImpliedOutlivesBoundsGoal,
-    CanonicalPredicateGoal, CanonicalTyGoal, CanonicalTypeOpAscribeUserTypeGoal,
+    CanonicalMethodAutoderefStepsGoal, CanonicalPredicateGoal, CanonicalTypeOpAscribeUserTypeGoal,
     CanonicalTypeOpNormalizeGoal, CanonicalTypeOpProvePredicateGoal, DropckConstraint,
     DropckOutlivesResult, MethodAutoderefStepsResult, NoSolution, NormalizationResult,
     OutlivesBound,
@@ -2559,9 +2559,9 @@ rustc_queries! {
     }
 
     query method_autoderef_steps(
-        goal: CanonicalTyGoal<'tcx>
+        goal: CanonicalMethodAutoderefStepsGoal<'tcx>
     ) -> MethodAutoderefStepsResult<'tcx> {
-        desc { "computing autoderef types for `{}`", goal.canonical.value.value }
+        desc { "computing autoderef types for `{}`", goal.canonical.value.value.self_ty }
     }
 
     /// Used by `-Znext-solver` to compute proof trees.
diff --git a/compiler/rustc_middle/src/traits/query.rs b/compiler/rustc_middle/src/traits/query.rs
index 3f6faa1a572d9..c1b7c9b9b4e23 100644
--- a/compiler/rustc_middle/src/traits/query.rs
+++ b/compiler/rustc_middle/src/traits/query.rs
@@ -10,6 +10,7 @@ use rustc_span::Span;
 
 use crate::error::DropCheckOverflow;
 use crate::infer::canonical::{Canonical, CanonicalQueryInput, QueryResponse};
+use crate::traits::solve;
 pub use crate::traits::solve::NoSolution;
 use crate::ty::{self, GenericArg, Ty, TyCtxt};
 
@@ -67,7 +68,16 @@ pub mod type_op {
 pub type CanonicalAliasGoal<'tcx> =
     CanonicalQueryInput<'tcx, ty::ParamEnvAnd<'tcx, ty::AliasTy<'tcx>>>;
 
-pub type CanonicalTyGoal<'tcx> = CanonicalQueryInput<'tcx, ty::ParamEnvAnd<'tcx, Ty<'tcx>>>;
+pub type CanonicalMethodAutoderefStepsGoal<'tcx> =
+    CanonicalQueryInput<'tcx, ty::ParamEnvAnd<'tcx, MethodAutoderefSteps<'tcx>>>;
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, HashStable, TypeFoldable, TypeVisitable)]
+pub struct MethodAutoderefSteps<'tcx> {
+    /// The list of opaque types currently in the storage.
+    ///
+    /// Only used by the new solver for now.
+    pub predefined_opaques_in_body: solve::PredefinedOpaques<'tcx>,
+    pub self_ty: Ty<'tcx>,
+}
 
 pub type CanonicalPredicateGoal<'tcx> =
     CanonicalQueryInput<'tcx, ty::ParamEnvAnd<'tcx, ty::Predicate<'tcx>>>;
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index aa34651464518..a42af7bb3e3f8 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -74,7 +74,8 @@ use crate::query::{IntoQueryParam, LocalCrate, Providers, TyCtxtAt};
 use crate::thir::Thir;
 use crate::traits;
 use crate::traits::solve::{
-    self, CanonicalInput, ExternalConstraints, ExternalConstraintsData, QueryResult, inspect,
+    self, CanonicalInput, ExternalConstraints, ExternalConstraintsData, PredefinedOpaques,
+    QueryResult, inspect,
 };
 use crate::ty::predicate::ExistentialPredicateStableCmpExt as _;
 use crate::ty::{
@@ -3127,6 +3128,14 @@ impl<'tcx> TyCtxt<'tcx> {
         T::collect_and_apply(iter, |xs| self.mk_poly_existential_predicates(xs))
     }
 
+    pub fn mk_predefined_opaques_in_body_from_iter<I, T>(self, iter: I) -> T::Output
+    where
+        I: Iterator<Item = T>,
+        T: CollectAndApply<(ty::OpaqueTypeKey<'tcx>, Ty<'tcx>), PredefinedOpaques<'tcx>>,
+    {
+        T::collect_and_apply(iter, |xs| self.mk_predefined_opaques_in_body(xs))
+    }
+
     pub fn mk_clauses_from_iter<I, T>(self, iter: I) -> T::Output
     where
         I: Iterator<Item = T>,

From 70f6493f261810b07d69ab0ffb661cf4ed8a97a7 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Tue, 23 Sep 2025 15:25:35 +0200
Subject: [PATCH 1429/1889] remove unnecessary structurally resolve

`autoderef` already resolved and `method_autoderef_steps` makes
sure we won't encounter an inference variable
---
 compiler/rustc_hir_typeck/src/method/confirm.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/method/confirm.rs b/compiler/rustc_hir_typeck/src/method/confirm.rs
index a23910a2006c9..b23e7ae8e77bc 100644
--- a/compiler/rustc_hir_typeck/src/method/confirm.rs
+++ b/compiler/rustc_hir_typeck/src/method/confirm.rs
@@ -172,7 +172,7 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
         // Commit the autoderefs by calling `autoderef` again, but this
         // time writing the results into the various typeck results.
         let mut autoderef = self.autoderef(self.call_expr.span, unadjusted_self_ty);
-        let Some((ty, n)) = autoderef.nth(pick.autoderefs) else {
+        let Some((mut target, n)) = autoderef.nth(pick.autoderefs) else {
             return Ty::new_error_with_message(
                 self.tcx,
                 DUMMY_SP,
@@ -182,8 +182,6 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
         assert_eq!(n, pick.autoderefs);
 
         let mut adjustments = self.adjust_steps(&autoderef);
-        let mut target = self.structurally_resolve_type(autoderef.span(), ty);
-
         match pick.autoref_or_ptr_adjustment {
             Some(probe::AutorefOrPtrAdjustment::Autoref { mutbl, unsize }) => {
                 let region = self.next_region_var(RegionVariableOrigin::Autoref(self.span));

From 6b379b560df483307958f2a606a1dd514fff36ca Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Tue, 23 Sep 2025 15:32:25 +0200
Subject: [PATCH 1430/1889] use `try_structurally_resolve_type` for method
 receiver

We'll still error due to the `opt_bad_ty` of `method_autoderef_steps`.
This slightly worsens the span of `infer_var.method()` which is now the
same as for `Box::new(infer_var).method()`.

Unlike `structurally_resolve_type`, `probe_op` does not check whether
the infcx is already tainted, so this results in 2 previously not emitted
errors.
---
 compiler/rustc_hir_typeck/src/expr.rs                |  3 +--
 compiler/rustc_hir_typeck/src/method/probe.rs        |  2 ++
 .../obligation-with-leaking-placeholders.next.stderr |  2 +-
 .../ui/impl-trait/call_method_ambiguous.next.stderr  |  2 +-
 .../call_method_on_inherent_impl.next.stderr         |  2 +-
 .../call_method_on_inherent_impl_ref.next.stderr     |  2 +-
 .../hidden-type-is-opaque-2.default.stderr           |  4 ++--
 .../impl-trait/hidden-type-is-opaque-2.next.stderr   |  4 ++--
 tests/ui/impl-trait/method-resolution4.next.stderr   |  4 ++--
 tests/ui/impl-trait/recursive-bound-eval.next.stderr |  4 ++--
 .../incompat-call-after-qualified-path-0.stderr      |  2 +-
 .../incompat-call-after-qualified-path-1.stderr      |  2 +-
 tests/ui/issues/issue-2151.stderr                    |  2 +-
 tests/ui/lazy-type-alias-impl-trait/branches3.stderr |  8 ++++----
 tests/ui/proc-macro/quote/not-repeatable.rs          |  4 +++-
 tests/ui/proc-macro/quote/not-repeatable.stderr      | 11 +++++++++--
 .../copy-inference-side-effects-are-lazy.stderr      |  4 ++--
 .../ui/span/issue-42234-unknown-receiver-type.stderr |  4 +++-
 .../closures_in_branches.stderr                      |  4 ++--
 ...d_resolution_trait_method_from_opaque.next.stderr |  4 ++--
 .../ui/type-inference/regression-issue-81317.stderr  |  2 +-
 tests/ui/typeck/issue-13853.rs                       |  2 +-
 tests/ui/typeck/issue-13853.stderr                   | 12 +++++++++---
 23 files changed, 54 insertions(+), 36 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index 7adbee7ff2855..d1ce0afddf91c 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -1633,8 +1633,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         expected: Expectation<'tcx>,
     ) -> Ty<'tcx> {
         let rcvr_t = self.check_expr(rcvr);
-        // no need to check for bot/err -- callee does that
-        let rcvr_t = self.structurally_resolve_type(rcvr.span, rcvr_t);
+        let rcvr_t = self.try_structurally_resolve_type(rcvr.span, rcvr_t);
 
         match self.lookup_method(rcvr_t, segment, segment.ident.span, expr, rcvr, args) {
             Ok(method) => {
diff --git a/compiler/rustc_hir_typeck/src/method/probe.rs b/compiler/rustc_hir_typeck/src/method/probe.rs
index e0cd1f20080a6..3311c14105549 100644
--- a/compiler/rustc_hir_typeck/src/method/probe.rs
+++ b/compiler/rustc_hir_typeck/src/method/probe.rs
@@ -486,6 +486,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     ty::Infer(ty::TyVar(_)) => {
                         let raw_ptr_call = bad_ty.reached_raw_pointer
                             && !self.tcx.features().arbitrary_self_types();
+                        // FIXME: Ideally we'd use the span of the self-expr here,
+                        // not of the method path.
                         let mut err = self.err_ctxt().emit_inference_failure_err(
                             self.body_id,
                             span,
diff --git a/tests/ui/closures/deduce-signature/obligation-with-leaking-placeholders.next.stderr b/tests/ui/closures/deduce-signature/obligation-with-leaking-placeholders.next.stderr
index 3d667f12371ab..4bb9047b3035d 100644
--- a/tests/ui/closures/deduce-signature/obligation-with-leaking-placeholders.next.stderr
+++ b/tests/ui/closures/deduce-signature/obligation-with-leaking-placeholders.next.stderr
@@ -5,7 +5,7 @@ LL |     needs_foo(|x| {
    |                ^
 ...
 LL |         x.to_string();
-   |         - type must be known at this point
+   |           --------- type must be known at this point
    |
 help: consider giving this closure parameter an explicit type
    |
diff --git a/tests/ui/impl-trait/call_method_ambiguous.next.stderr b/tests/ui/impl-trait/call_method_ambiguous.next.stderr
index 5251555f57421..0def594daf1cc 100644
--- a/tests/ui/impl-trait/call_method_ambiguous.next.stderr
+++ b/tests/ui/impl-trait/call_method_ambiguous.next.stderr
@@ -5,7 +5,7 @@ LL |         let mut iter = foo(n - 1, m);
    |             ^^^^^^^^
 LL |
 LL |         assert_eq!(iter.get(), 1);
-   |                    ---- type must be known at this point
+   |                         --- type must be known at this point
    |
 help: consider giving `iter` an explicit type
    |
diff --git a/tests/ui/impl-trait/call_method_on_inherent_impl.next.stderr b/tests/ui/impl-trait/call_method_on_inherent_impl.next.stderr
index 271051f120abc..7bbf5f5153a59 100644
--- a/tests/ui/impl-trait/call_method_on_inherent_impl.next.stderr
+++ b/tests/ui/impl-trait/call_method_on_inherent_impl.next.stderr
@@ -5,7 +5,7 @@ LL |         let x = my_foo();
    |             ^
 LL |
 LL |         x.my_debug();
-   |         - type must be known at this point
+   |           -------- type must be known at this point
    |
 help: consider giving `x` an explicit type
    |
diff --git a/tests/ui/impl-trait/call_method_on_inherent_impl_ref.next.stderr b/tests/ui/impl-trait/call_method_on_inherent_impl_ref.next.stderr
index 7202cb6f90a6f..5dea3a715e9bc 100644
--- a/tests/ui/impl-trait/call_method_on_inherent_impl_ref.next.stderr
+++ b/tests/ui/impl-trait/call_method_on_inherent_impl_ref.next.stderr
@@ -5,7 +5,7 @@ LL |         let x = my_foo();
    |             ^
 LL |
 LL |         x.my_debug();
-   |         - type must be known at this point
+   |           -------- type must be known at this point
    |
 help: consider giving `x` an explicit type
    |
diff --git a/tests/ui/impl-trait/hidden-type-is-opaque-2.default.stderr b/tests/ui/impl-trait/hidden-type-is-opaque-2.default.stderr
index dca0a7b0a1a9f..cb383b2db3893 100644
--- a/tests/ui/impl-trait/hidden-type-is-opaque-2.default.stderr
+++ b/tests/ui/impl-trait/hidden-type-is-opaque-2.default.stderr
@@ -5,7 +5,7 @@ LL |     Thunk::new(|mut cont| {
    |                 ^^^^^^^^
 LL |
 LL |         cont.reify_as();
-   |         ---- type must be known at this point
+   |              -------- type must be known at this point
    |
 help: consider giving this closure parameter an explicit type
    |
@@ -19,7 +19,7 @@ LL |     Thunk::new(|mut cont| {
    |                 ^^^^^^^^
 LL |
 LL |         cont.reify_as();
-   |         ---- type must be known at this point
+   |              -------- type must be known at this point
    |
 help: consider giving this closure parameter an explicit type
    |
diff --git a/tests/ui/impl-trait/hidden-type-is-opaque-2.next.stderr b/tests/ui/impl-trait/hidden-type-is-opaque-2.next.stderr
index dca0a7b0a1a9f..cb383b2db3893 100644
--- a/tests/ui/impl-trait/hidden-type-is-opaque-2.next.stderr
+++ b/tests/ui/impl-trait/hidden-type-is-opaque-2.next.stderr
@@ -5,7 +5,7 @@ LL |     Thunk::new(|mut cont| {
    |                 ^^^^^^^^
 LL |
 LL |         cont.reify_as();
-   |         ---- type must be known at this point
+   |              -------- type must be known at this point
    |
 help: consider giving this closure parameter an explicit type
    |
@@ -19,7 +19,7 @@ LL |     Thunk::new(|mut cont| {
    |                 ^^^^^^^^
 LL |
 LL |         cont.reify_as();
-   |         ---- type must be known at this point
+   |              -------- type must be known at this point
    |
 help: consider giving this closure parameter an explicit type
    |
diff --git a/tests/ui/impl-trait/method-resolution4.next.stderr b/tests/ui/impl-trait/method-resolution4.next.stderr
index 0524f49f98e58..47a9aac19ecc3 100644
--- a/tests/ui/impl-trait/method-resolution4.next.stderr
+++ b/tests/ui/impl-trait/method-resolution4.next.stderr
@@ -1,8 +1,8 @@
 error[E0282]: type annotations needed
-  --> $DIR/method-resolution4.rs:13:9
+  --> $DIR/method-resolution4.rs:13:20
    |
 LL |         foo(false).next().unwrap();
-   |         ^^^^^^^^^^ cannot infer type
+   |                    ^^^^ cannot infer type
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/impl-trait/recursive-bound-eval.next.stderr b/tests/ui/impl-trait/recursive-bound-eval.next.stderr
index 4bab290d71c3c..e94f0a59a1d22 100644
--- a/tests/ui/impl-trait/recursive-bound-eval.next.stderr
+++ b/tests/ui/impl-trait/recursive-bound-eval.next.stderr
@@ -1,8 +1,8 @@
 error[E0282]: type annotations needed
-  --> $DIR/recursive-bound-eval.rs:20:13
+  --> $DIR/recursive-bound-eval.rs:20:28
    |
 LL |     move || recursive_fn().parse()
-   |             ^^^^^^^^^^^^^^ cannot infer type
+   |                            ^^^^^ cannot infer type
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/inference/need_type_info/incompat-call-after-qualified-path-0.stderr b/tests/ui/inference/need_type_info/incompat-call-after-qualified-path-0.stderr
index 10056bdf3d4f4..ba1c81c4518a7 100644
--- a/tests/ui/inference/need_type_info/incompat-call-after-qualified-path-0.stderr
+++ b/tests/ui/inference/need_type_info/incompat-call-after-qualified-path-0.stderr
@@ -2,7 +2,7 @@ error[E0282]: type annotations needed
   --> $DIR/incompat-call-after-qualified-path-0.rs:21:6
    |
 LL |   f(|a, b| a.cmp(b));
-   |      ^     - type must be known at this point
+   |      ^       --- type must be known at this point
    |
 help: consider giving this closure parameter an explicit type
    |
diff --git a/tests/ui/inference/need_type_info/incompat-call-after-qualified-path-1.stderr b/tests/ui/inference/need_type_info/incompat-call-after-qualified-path-1.stderr
index 632a9b99f84ef..93bba3625b540 100644
--- a/tests/ui/inference/need_type_info/incompat-call-after-qualified-path-1.stderr
+++ b/tests/ui/inference/need_type_info/incompat-call-after-qualified-path-1.stderr
@@ -2,7 +2,7 @@ error[E0282]: type annotations needed
   --> $DIR/incompat-call-after-qualified-path-1.rs:25:6
    |
 LL |   f(|a, b| a.cmp(b));
-   |      ^     - type must be known at this point
+   |      ^       --- type must be known at this point
    |
 help: consider giving this closure parameter an explicit type
    |
diff --git a/tests/ui/issues/issue-2151.stderr b/tests/ui/issues/issue-2151.stderr
index b130f162414d0..59fef42eb5e8b 100644
--- a/tests/ui/issues/issue-2151.stderr
+++ b/tests/ui/issues/issue-2151.stderr
@@ -4,7 +4,7 @@ error[E0282]: type annotations needed
 LL |     let x = panic!();
    |         ^
 LL |     x.clone();
-   |     - type must be known at this point
+   |       ----- type must be known at this point
    |
 help: consider giving `x` an explicit type
    |
diff --git a/tests/ui/lazy-type-alias-impl-trait/branches3.stderr b/tests/ui/lazy-type-alias-impl-trait/branches3.stderr
index 117d189867bd7..539673bc343ce 100644
--- a/tests/ui/lazy-type-alias-impl-trait/branches3.stderr
+++ b/tests/ui/lazy-type-alias-impl-trait/branches3.stderr
@@ -2,7 +2,7 @@ error[E0282]: type annotations needed
   --> $DIR/branches3.rs:9:10
    |
 LL |         |s| s.len()
-   |          ^  - type must be known at this point
+   |          ^    --- type must be known at this point
    |
 help: consider giving this closure parameter an explicit type
    |
@@ -13,7 +13,7 @@ error[E0282]: type annotations needed
   --> $DIR/branches3.rs:18:10
    |
 LL |         |s| s.len()
-   |          ^  - type must be known at this point
+   |          ^    --- type must be known at this point
    |
 help: consider giving this closure parameter an explicit type
    |
@@ -24,7 +24,7 @@ error[E0282]: type annotations needed
   --> $DIR/branches3.rs:26:10
    |
 LL |         |s| s.len()
-   |          ^  - type must be known at this point
+   |          ^    --- type must be known at this point
    |
 help: consider giving this closure parameter an explicit type
    |
@@ -35,7 +35,7 @@ error[E0282]: type annotations needed
   --> $DIR/branches3.rs:33:10
    |
 LL |         |s| s.len()
-   |          ^  - type must be known at this point
+   |          ^    --- type must be known at this point
    |
 help: consider giving this closure parameter an explicit type
    |
diff --git a/tests/ui/proc-macro/quote/not-repeatable.rs b/tests/ui/proc-macro/quote/not-repeatable.rs
index 0291e4ddf88d6..373f0e74dbdac 100644
--- a/tests/ui/proc-macro/quote/not-repeatable.rs
+++ b/tests/ui/proc-macro/quote/not-repeatable.rs
@@ -8,5 +8,7 @@ struct Ipv4Addr;
 
 fn main() {
     let ip = Ipv4Addr;
-    let _ = quote! { $($ip)* }; //~ ERROR the method `quote_into_iter` exists for struct `Ipv4Addr`, but its trait bounds were not satisfied
+    let _ = quote! { $($ip)* };
+    //~^ ERROR the method `quote_into_iter` exists for struct `Ipv4Addr`, but its trait bounds were not satisfied
+    //~| ERROR type annotations needed
 }
diff --git a/tests/ui/proc-macro/quote/not-repeatable.stderr b/tests/ui/proc-macro/quote/not-repeatable.stderr
index aeda08d7de68b..ff31799abb007 100644
--- a/tests/ui/proc-macro/quote/not-repeatable.stderr
+++ b/tests/ui/proc-macro/quote/not-repeatable.stderr
@@ -20,6 +20,13 @@ note: the traits `Iterator` and `ToTokens` must be implemented
   --> $SRC_DIR/proc_macro/src/to_tokens.rs:LL:COL
   --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
 
-error: aborting due to 1 previous error
+error[E0282]: type annotations needed
+  --> $DIR/not-repeatable.rs:11:13
+   |
+LL |     let _ = quote! { $($ip)* };
+   |             ^^^^^^^^^^^^^^^^^^ cannot infer type
+
+error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0599`.
+Some errors have detailed explanations: E0282, E0599.
+For more information about an error, try `rustc --explain E0282`.
diff --git a/tests/ui/repeat-expr/copy-inference-side-effects-are-lazy.stderr b/tests/ui/repeat-expr/copy-inference-side-effects-are-lazy.stderr
index ba44beb76dbb7..b8a8f927542f0 100644
--- a/tests/ui/repeat-expr/copy-inference-side-effects-are-lazy.stderr
+++ b/tests/ui/repeat-expr/copy-inference-side-effects-are-lazy.stderr
@@ -5,9 +5,9 @@ LL |     let x = [Foo(PhantomData); 2];
    |         ^
 LL |
 LL |     extract(x).max(2);
-   |     ---------- type must be known at this point
+   |                --- type must be known at this point
    |
-help: consider giving `x` an explicit type, where the type for type parameter `T` is specified
+help: consider giving `x` an explicit type, where the placeholders `_` are specified
    |
 LL |     let x: [Foo<T>; 2] = [Foo(PhantomData); 2];
    |          +++++++++++++
diff --git a/tests/ui/span/issue-42234-unknown-receiver-type.stderr b/tests/ui/span/issue-42234-unknown-receiver-type.stderr
index 10308ec07da5a..71ac4f53b3f4f 100644
--- a/tests/ui/span/issue-42234-unknown-receiver-type.stderr
+++ b/tests/ui/span/issue-42234-unknown-receiver-type.stderr
@@ -4,7 +4,7 @@ error[E0282]: type annotations needed
 LL |     let x: Option<_> = None;
    |                        ^^^^ cannot infer type of the type parameter `T` declared on the enum `Option`
 LL |     x.unwrap().method_that_could_exist_on_some_type();
-   |     ---------- type must be known at this point
+   |                ------------------------------------ type must be known at this point
    |
 help: consider specifying the generic argument
    |
@@ -16,6 +16,8 @@ error[E0282]: type annotations needed
    |
 LL |         .sum::<_>()
    |          ^^^ cannot infer type of the type parameter `S` declared on the method `sum`
+LL |         .to_string()
+   |          --------- type must be known at this point
    |
 
 error: aborting due to 2 previous errors
diff --git a/tests/ui/type-alias-impl-trait/closures_in_branches.stderr b/tests/ui/type-alias-impl-trait/closures_in_branches.stderr
index 849ffd214f07d..559bc57d90638 100644
--- a/tests/ui/type-alias-impl-trait/closures_in_branches.stderr
+++ b/tests/ui/type-alias-impl-trait/closures_in_branches.stderr
@@ -2,7 +2,7 @@ error[E0282]: type annotations needed
   --> $DIR/closures_in_branches.rs:8:10
    |
 LL |         |x| x.len()
-   |          ^  - type must be known at this point
+   |          ^    --- type must be known at this point
    |
 help: consider giving this closure parameter an explicit type
    |
@@ -13,7 +13,7 @@ error[E0282]: type annotations needed
   --> $DIR/closures_in_branches.rs:22:10
    |
 LL |         |x| x.len()
-   |          ^  - type must be known at this point
+   |          ^    --- type must be known at this point
    |
 help: consider giving this closure parameter an explicit type
    |
diff --git a/tests/ui/type-alias-impl-trait/method_resolution_trait_method_from_opaque.next.stderr b/tests/ui/type-alias-impl-trait/method_resolution_trait_method_from_opaque.next.stderr
index bbdd3923821ff..5aae334ccbd2f 100644
--- a/tests/ui/type-alias-impl-trait/method_resolution_trait_method_from_opaque.next.stderr
+++ b/tests/ui/type-alias-impl-trait/method_resolution_trait_method_from_opaque.next.stderr
@@ -1,8 +1,8 @@
 error[E0282]: type annotations needed
-  --> $DIR/method_resolution_trait_method_from_opaque.rs:28:9
+  --> $DIR/method_resolution_trait_method_from_opaque.rs:28:18
    |
 LL |         self.bar.next().unwrap();
-   |         ^^^^^^^^ cannot infer type
+   |                  ^^^^ cannot infer type
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-inference/regression-issue-81317.stderr b/tests/ui/type-inference/regression-issue-81317.stderr
index fcd3fca06e18b..a070b50e31175 100644
--- a/tests/ui/type-inference/regression-issue-81317.stderr
+++ b/tests/ui/type-inference/regression-issue-81317.stderr
@@ -5,7 +5,7 @@ LL |     let iv = S ^ index.into();
    |         ^^
 LL |
 LL |     &iv.to_bytes_be();
-   |      -- type must be known at this point
+   |         ----------- type must be known at this point
    |
 help: consider giving `iv` an explicit type
    |
diff --git a/tests/ui/typeck/issue-13853.rs b/tests/ui/typeck/issue-13853.rs
index ac9886d2e7249..ed44d5062614f 100644
--- a/tests/ui/typeck/issue-13853.rs
+++ b/tests/ui/typeck/issue-13853.rs
@@ -25,7 +25,7 @@ impl Node for Stuff {
 
 fn iterate<N: Node, G: Graph<N>>(graph: &G) {
     for node in graph.iter() { //~ ERROR no method named `iter` found
-        node.zomg();
+        node.zomg(); //~ ERROR type annotations needed
     }
 }
 
diff --git a/tests/ui/typeck/issue-13853.stderr b/tests/ui/typeck/issue-13853.stderr
index 45363c87d29df..9b8698d6ed2c0 100644
--- a/tests/ui/typeck/issue-13853.stderr
+++ b/tests/ui/typeck/issue-13853.stderr
@@ -17,6 +17,12 @@ error[E0599]: no method named `iter` found for reference `&G` in the current sco
 LL |     for node in graph.iter() {
    |                       ^^^^ method not found in `&G`
 
+error[E0282]: type annotations needed
+  --> $DIR/issue-13853.rs:28:14
+   |
+LL |         node.zomg();
+   |              ^^^^ cannot infer type
+
 error[E0308]: mismatched types
   --> $DIR/issue-13853.rs:37:13
    |
@@ -37,7 +43,7 @@ help: consider borrowing here
 LL |     iterate(&graph);
    |             +
 
-error: aborting due to 3 previous errors
+error: aborting due to 4 previous errors
 
-Some errors have detailed explanations: E0308, E0599.
-For more information about an error, try `rustc --explain E0308`.
+Some errors have detailed explanations: E0282, E0308, E0599.
+For more information about an error, try `rustc --explain E0282`.

From 148fd9ad3c434c26a952e01e37c35aa26cb8315c Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Tue, 23 Sep 2025 17:33:24 +0200
Subject: [PATCH 1431/1889] allow method calls on opaques

---
 compiler/rustc_hir_typeck/src/method/probe.rs | 209 +++++++++++++++---
 .../src/infer/canonical/query_response.rs     |  23 +-
 compiler/rustc_middle/src/traits/query.rs     |   1 +
 .../src/solve/eval_ctxt/mod.rs                |   3 +-
 .../rustc_next_trait_solver/src/solve/mod.rs  |   1 +
 .../src/traits/query/evaluate_obligation.rs   |  11 +-
 .../call_method_ambiguous.next.stderr         |  17 --
 tests/ui/impl-trait/call_method_ambiguous.rs  |   3 +-
 .../call_method_on_inherent_impl.next.stderr  |  17 --
 .../call_method_on_inherent_impl.rs           |   3 +-
 ...inherent_impl_on_rigid_type.current.stderr |   2 +-
 ...on_inherent_impl_on_rigid_type.next.stderr |  18 +-
 ...l_method_on_inherent_impl_on_rigid_type.rs |   3 +-
 ...d_on_inherent_impl_ref-err.current.stderr} |   4 +-
 ...ethod_on_inherent_impl_ref-err.next.stderr |  19 ++
 .../call_method_on_inherent_impl_ref-err.rs   |  24 ++
 ...=> call_method_on_inherent_impl_ref-ok.rs} |  12 +-
 ...ll_method_on_inherent_impl_ref.next.stderr |  31 ---
 .../impl-trait/method-resolution4.next.stderr |   9 -
 tests/ui/impl-trait/method-resolution4.rs     |   3 +-
 ...olution5-deref-no-constrain.current.stderr |  19 ++
 .../method-resolution5-deref-no-constrain.rs  |  23 ++
 .../ui/impl-trait/method-resolution5-deref.rs |  30 +++
 .../recursive-bound-eval.next.stderr          |   9 -
 tests/ui/impl-trait/recursive-bound-eval.rs   |   6 +-
 .../recursive-coroutine-boxed.next.stderr     |  17 --
 .../impl-trait/recursive-coroutine-boxed.rs   |   3 +-
 ...ution_trait_method_from_opaque.next.stderr |   8 +-
 28 files changed, 357 insertions(+), 171 deletions(-)
 delete mode 100644 tests/ui/impl-trait/call_method_ambiguous.next.stderr
 delete mode 100644 tests/ui/impl-trait/call_method_on_inherent_impl.next.stderr
 rename tests/ui/impl-trait/{call_method_on_inherent_impl_ref.current.stderr => call_method_on_inherent_impl_ref-err.current.stderr} (84%)
 create mode 100644 tests/ui/impl-trait/call_method_on_inherent_impl_ref-err.next.stderr
 create mode 100644 tests/ui/impl-trait/call_method_on_inherent_impl_ref-err.rs
 rename tests/ui/impl-trait/{call_method_on_inherent_impl_ref.rs => call_method_on_inherent_impl_ref-ok.rs} (54%)
 delete mode 100644 tests/ui/impl-trait/call_method_on_inherent_impl_ref.next.stderr
 delete mode 100644 tests/ui/impl-trait/method-resolution4.next.stderr
 create mode 100644 tests/ui/impl-trait/method-resolution5-deref-no-constrain.current.stderr
 create mode 100644 tests/ui/impl-trait/method-resolution5-deref-no-constrain.rs
 create mode 100644 tests/ui/impl-trait/method-resolution5-deref.rs
 delete mode 100644 tests/ui/impl-trait/recursive-bound-eval.next.stderr
 delete mode 100644 tests/ui/impl-trait/recursive-coroutine-boxed.next.stderr

diff --git a/compiler/rustc_hir_typeck/src/method/probe.rs b/compiler/rustc_hir_typeck/src/method/probe.rs
index 3311c14105549..e34ee6258b85b 100644
--- a/compiler/rustc_hir_typeck/src/method/probe.rs
+++ b/compiler/rustc_hir_typeck/src/method/probe.rs
@@ -13,7 +13,7 @@ use rustc_hir::def::DefKind;
 use rustc_hir_analysis::autoderef::{self, Autoderef};
 use rustc_infer::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse};
 use rustc_infer::infer::{BoundRegionConversionTime, DefineOpaqueTypes, InferOk, TyCtxtInferExt};
-use rustc_infer::traits::{ObligationCauseCode, query};
+use rustc_infer::traits::{ObligationCauseCode, PredicateObligation, query};
 use rustc_middle::middle::stability;
 use rustc_middle::ty::elaborate::supertrait_def_ids;
 use rustc_middle::ty::fast_reject::{DeepRejectCtxt, TreatParams, simplify_type};
@@ -30,6 +30,7 @@ use rustc_span::edit_distance::{
 use rustc_span::{DUMMY_SP, Ident, Span, Symbol, sym};
 use rustc_trait_selection::error_reporting::infer::need_type_info::TypeAnnotationNeeded;
 use rustc_trait_selection::infer::InferCtxtExt as _;
+use rustc_trait_selection::solve::Goal;
 use rustc_trait_selection::traits::query::CanonicalMethodAutoderefStepsGoal;
 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt;
 use rustc_trait_selection::traits::query::method_autoderef::{
@@ -417,6 +418,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     steps: infcx.tcx.arena.alloc_from_iter([CandidateStep {
                         self_ty: self
                             .make_query_response_ignoring_pending_obligations(var_values, self_ty),
+                        self_ty_is_opaque: false,
                         autoderefs: 0,
                         from_unsafe_deref: false,
                         unsize: false,
@@ -590,6 +592,17 @@ pub(crate) fn method_autoderef_steps<'tcx>(
         }
     }
 
+    // We accept not-yet-defined opaque types in the autoderef
+    // chain to support recursive calls. We do error if the final
+    // infer var is not an opaque.
+    let self_ty_is_opaque = |ty: Ty<'_>| {
+        if let &ty::Infer(ty::TyVar(vid)) = ty.kind() {
+            infcx.has_opaques_with_sub_unified_hidden_type(vid)
+        } else {
+            false
+        }
+    };
+
     // If arbitrary self types is not enabled, we follow the chain of
     // `Deref<Target=T>`. If arbitrary self types is enabled, we instead
     // follow the chain of `Receiver<Target=T>`, but we also record whether
@@ -623,6 +636,7 @@ pub(crate) fn method_autoderef_steps<'tcx>(
                 let step = CandidateStep {
                     self_ty: infcx
                         .make_query_response_ignoring_pending_obligations(inference_vars, ty),
+                    self_ty_is_opaque: self_ty_is_opaque(ty),
                     autoderefs: d,
                     from_unsafe_deref: reached_raw_pointer,
                     unsize: false,
@@ -643,6 +657,7 @@ pub(crate) fn method_autoderef_steps<'tcx>(
                 let step = CandidateStep {
                     self_ty: infcx
                         .make_query_response_ignoring_pending_obligations(inference_vars, ty),
+                    self_ty_is_opaque: self_ty_is_opaque(ty),
                     autoderefs: d,
                     from_unsafe_deref: reached_raw_pointer,
                     unsize: false,
@@ -659,7 +674,11 @@ pub(crate) fn method_autoderef_steps<'tcx>(
     };
     let final_ty = autoderef_via_deref.final_ty();
     let opt_bad_ty = match final_ty.kind() {
-        ty::Infer(ty::TyVar(_)) | ty::Error(_) => Some(MethodAutoderefBadTy {
+        ty::Infer(ty::TyVar(_)) if !self_ty_is_opaque(final_ty) => Some(MethodAutoderefBadTy {
+            reached_raw_pointer,
+            ty: infcx.make_query_response_ignoring_pending_obligations(inference_vars, final_ty),
+        }),
+        ty::Error(_) => Some(MethodAutoderefBadTy {
             reached_raw_pointer,
             ty: infcx.make_query_response_ignoring_pending_obligations(inference_vars, final_ty),
         }),
@@ -670,6 +689,7 @@ pub(crate) fn method_autoderef_steps<'tcx>(
                     inference_vars,
                     Ty::new_slice(infcx.tcx, *elem_ty),
                 ),
+                self_ty_is_opaque: false,
                 autoderefs,
                 // this could be from an unsafe deref if we had
                 // a *mut/const [T; N]
@@ -1234,7 +1254,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
                 !step.self_ty.value.references_error() && !step.from_unsafe_deref
             })
             .find_map(|step| {
-                let InferOk { value: self_ty, obligations: _ } = self
+                let InferOk { value: self_ty, obligations: instantiate_self_ty_obligations } = self
                     .fcx
                     .probe_instantiate_query_response(
                         self.span,
@@ -1245,7 +1265,12 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
                         span_bug!(self.span, "{:?} was applicable but now isn't?", step.self_ty)
                     });
 
-                let by_value_pick = self.pick_by_value_method(step, self_ty, pick_diag_hints);
+                let by_value_pick = self.pick_by_value_method(
+                    step,
+                    self_ty,
+                    &instantiate_self_ty_obligations,
+                    pick_diag_hints,
+                );
 
                 // Check for shadowing of a by-reference method by a by-value method (see comments on check_for_shadowing)
                 if let Some(by_value_pick) = by_value_pick {
@@ -1256,6 +1281,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
                                     by_value_pick,
                                     step,
                                     self_ty,
+                                    &instantiate_self_ty_obligations,
                                     mutbl,
                                     track_unstable_candidates,
                                 ) {
@@ -1270,6 +1296,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
                 let autoref_pick = self.pick_autorefd_method(
                     step,
                     self_ty,
+                    &instantiate_self_ty_obligations,
                     hir::Mutability::Not,
                     pick_diag_hints,
                     None,
@@ -1283,6 +1310,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
                                 autoref_pick,
                                 step,
                                 self_ty,
+                                &instantiate_self_ty_obligations,
                                 hir::Mutability::Mut,
                                 track_unstable_candidates,
                             ) {
@@ -1319,12 +1347,27 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
                 self.pick_autorefd_method(
                     step,
                     self_ty,
+                    &instantiate_self_ty_obligations,
                     hir::Mutability::Mut,
                     pick_diag_hints,
                     None,
                 )
-                .or_else(|| self.pick_const_ptr_method(step, self_ty, pick_diag_hints))
-                .or_else(|| self.pick_reborrow_pin_method(step, self_ty, pick_diag_hints))
+                .or_else(|| {
+                    self.pick_const_ptr_method(
+                        step,
+                        self_ty,
+                        &instantiate_self_ty_obligations,
+                        pick_diag_hints,
+                    )
+                })
+                .or_else(|| {
+                    self.pick_reborrow_pin_method(
+                        step,
+                        self_ty,
+                        &instantiate_self_ty_obligations,
+                        pick_diag_hints,
+                    )
+                })
             })
     }
 
@@ -1348,6 +1391,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
         possible_shadower: &Pick<'tcx>,
         step: &CandidateStep<'tcx>,
         self_ty: Ty<'tcx>,
+        instantiate_self_ty_obligations: &[PredicateObligation<'tcx>],
         mutbl: hir::Mutability,
         track_unstable_candidates: bool,
     ) -> Result<(), MethodError<'tcx>> {
@@ -1412,6 +1456,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
         let potentially_shadowed_pick = self.pick_autorefd_method(
             step,
             self_ty,
+            instantiate_self_ty_obligations,
             mutbl,
             &mut pick_diag_hints,
             Some(&pick_constraints),
@@ -1438,13 +1483,14 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
         &self,
         step: &CandidateStep<'tcx>,
         self_ty: Ty<'tcx>,
+        instantiate_self_ty_obligations: &[PredicateObligation<'tcx>],
         pick_diag_hints: &mut PickDiagHints<'_, 'tcx>,
     ) -> Option<PickResult<'tcx>> {
         if step.unsize {
             return None;
         }
 
-        self.pick_method(self_ty, pick_diag_hints, None).map(|r| {
+        self.pick_method(self_ty, instantiate_self_ty_obligations, pick_diag_hints, None).map(|r| {
             r.map(|mut pick| {
                 pick.autoderefs = step.autoderefs;
 
@@ -1481,6 +1527,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
         &self,
         step: &CandidateStep<'tcx>,
         self_ty: Ty<'tcx>,
+        instantiate_self_ty_obligations: &[PredicateObligation<'tcx>],
         mutbl: hir::Mutability,
         pick_diag_hints: &mut PickDiagHints<'_, 'tcx>,
         pick_constraints: Option<&PickConstraintsForShadowed>,
@@ -1497,7 +1544,13 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
         let region = tcx.lifetimes.re_erased;
 
         let autoref_ty = Ty::new_ref(tcx, region, self_ty, mutbl);
-        self.pick_method(autoref_ty, pick_diag_hints, pick_constraints).map(|r| {
+        self.pick_method(
+            autoref_ty,
+            instantiate_self_ty_obligations,
+            pick_diag_hints,
+            pick_constraints,
+        )
+        .map(|r| {
             r.map(|mut pick| {
                 pick.autoderefs = step.autoderefs;
                 pick.autoref_or_ptr_adjustment =
@@ -1513,6 +1566,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
         &self,
         step: &CandidateStep<'tcx>,
         self_ty: Ty<'tcx>,
+        instantiate_self_ty_obligations: &[PredicateObligation<'tcx>],
         pick_diag_hints: &mut PickDiagHints<'_, 'tcx>,
     ) -> Option<PickResult<'tcx>> {
         if !self.tcx.features().pin_ergonomics() {
@@ -1534,14 +1588,16 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
 
         let region = self.tcx.lifetimes.re_erased;
         let autopin_ty = Ty::new_pinned_ref(self.tcx, region, inner_ty, hir::Mutability::Not);
-        self.pick_method(autopin_ty, pick_diag_hints, None).map(|r| {
-            r.map(|mut pick| {
-                pick.autoderefs = step.autoderefs;
-                pick.autoref_or_ptr_adjustment =
-                    Some(AutorefOrPtrAdjustment::ReborrowPin(hir::Mutability::Not));
-                pick
-            })
-        })
+        self.pick_method(autopin_ty, instantiate_self_ty_obligations, pick_diag_hints, None).map(
+            |r| {
+                r.map(|mut pick| {
+                    pick.autoderefs = step.autoderefs;
+                    pick.autoref_or_ptr_adjustment =
+                        Some(AutorefOrPtrAdjustment::ReborrowPin(hir::Mutability::Not));
+                    pick
+                })
+            },
+        )
     }
 
     /// If `self_ty` is `*mut T` then this picks `*const T` methods. The reason why we have a
@@ -1551,6 +1607,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
         &self,
         step: &CandidateStep<'tcx>,
         self_ty: Ty<'tcx>,
+        instantiate_self_ty_obligations: &[PredicateObligation<'tcx>],
         pick_diag_hints: &mut PickDiagHints<'_, 'tcx>,
     ) -> Option<PickResult<'tcx>> {
         // Don't convert an unsized reference to ptr
@@ -1563,18 +1620,21 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
         };
 
         let const_ptr_ty = Ty::new_imm_ptr(self.tcx, ty);
-        self.pick_method(const_ptr_ty, pick_diag_hints, None).map(|r| {
-            r.map(|mut pick| {
-                pick.autoderefs = step.autoderefs;
-                pick.autoref_or_ptr_adjustment = Some(AutorefOrPtrAdjustment::ToConstPtr);
-                pick
-            })
-        })
+        self.pick_method(const_ptr_ty, instantiate_self_ty_obligations, pick_diag_hints, None).map(
+            |r| {
+                r.map(|mut pick| {
+                    pick.autoderefs = step.autoderefs;
+                    pick.autoref_or_ptr_adjustment = Some(AutorefOrPtrAdjustment::ToConstPtr);
+                    pick
+                })
+            },
+        )
     }
 
     fn pick_method(
         &self,
         self_ty: Ty<'tcx>,
+        instantiate_self_ty_obligations: &[PredicateObligation<'tcx>],
         pick_diag_hints: &mut PickDiagHints<'_, 'tcx>,
         pick_constraints: Option<&PickConstraintsForShadowed>,
     ) -> Option<PickResult<'tcx>> {
@@ -1584,8 +1644,13 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
             [("inherent", &self.inherent_candidates), ("extension", &self.extension_candidates)]
         {
             debug!("searching {} candidates", kind);
-            let res =
-                self.consider_candidates(self_ty, candidates, pick_diag_hints, pick_constraints);
+            let res = self.consider_candidates(
+                self_ty,
+                instantiate_self_ty_obligations,
+                candidates,
+                pick_diag_hints,
+                pick_constraints,
+            );
             if let Some(pick) = res {
                 return Some(pick);
             }
@@ -1594,6 +1659,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
         if self.private_candidate.get().is_none() {
             if let Some(Ok(pick)) = self.consider_candidates(
                 self_ty,
+                instantiate_self_ty_obligations,
                 &self.private_candidates,
                 &mut PickDiagHints {
                     unstable_candidates: None,
@@ -1610,6 +1676,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
     fn consider_candidates(
         &self,
         self_ty: Ty<'tcx>,
+        instantiate_self_ty_obligations: &[PredicateObligation<'tcx>],
         candidates: &[Candidate<'tcx>],
         pick_diag_hints: &mut PickDiagHints<'_, 'tcx>,
         pick_constraints: Option<&PickConstraintsForShadowed>,
@@ -1626,6 +1693,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
                     probe,
                     self.consider_probe(
                         self_ty,
+                        instantiate_self_ty_obligations,
                         probe,
                         &mut pick_diag_hints.unsatisfied_predicates,
                     ),
@@ -1810,10 +1878,11 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
         }
     }
 
-    #[instrument(level = "trace", skip(self, possibly_unsatisfied_predicates), ret)]
+    #[instrument(level = "debug", skip(self, possibly_unsatisfied_predicates), ret)]
     fn consider_probe(
         &self,
         self_ty: Ty<'tcx>,
+        instantiate_self_ty_obligations: &[PredicateObligation<'tcx>],
         probe: &Candidate<'tcx>,
         possibly_unsatisfied_predicates: &mut Vec<(
             ty::Predicate<'tcx>,
@@ -1821,8 +1890,6 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
             Option<ObligationCause<'tcx>>,
         )>,
     ) -> ProbeResult {
-        debug!("consider_probe: self_ty={:?} probe={:?}", self_ty, probe);
-
         self.probe(|snapshot| {
             let outer_universe = self.universe();
 
@@ -1830,6 +1897,21 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
             let cause = &self.misc(self.span);
             let ocx = ObligationCtxt::new_with_diagnostics(self);
 
+            // Subtle: we're not *really* instantiating the current self type while
+            // probing, but instead fully recompute the autoderef steps once we've got
+            // a final `Pick`. We can't nicely handle these obligations outside of a probe.
+            //
+            // We simply handle them for each candidate here for now. That's kinda scuffed
+            // and ideally we just put them into the `FnCtxt` right away. We need to consider
+            // them to deal with defining uses in `method_autoderef_steps`.
+            if self.next_trait_solver() {
+                ocx.register_obligations(instantiate_self_ty_obligations.iter().cloned());
+                let errors = ocx.select_where_possible();
+                if !errors.is_empty() {
+                    unreachable!("unexpected autoderef error {errors:?}");
+                }
+            }
+
             let mut trait_predicate = None;
             let (mut xform_self_ty, mut xform_ret_ty);
 
@@ -2072,6 +2154,12 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
                 }
             }
 
+            if self.infcx.next_trait_solver() {
+                if self.should_reject_candidate_due_to_opaque_treated_as_rigid(trait_predicate) {
+                    result = ProbeResult::NoMatch;
+                }
+            }
+
             // Previously, method probe used `evaluate_predicate` to determine if a predicate
             // was impossible to satisfy. This did a leak check, so we must also do a leak
             // check here to prevent backwards-incompatible ambiguity being introduced. See
@@ -2085,6 +2173,71 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
         })
     }
 
+    /// Trait candidates for not-yet-defined opaque types are a somewhat hacky.
+    ///
+    /// We want to only accept trait methods if they were hold even if the
+    /// opaque types were rigid. To handle this, we both check that for trait
+    /// candidates the goal were to hold even when treating opaques as rigid,
+    /// see [OpaqueTypesJank](rustc_trait_selection::solve::OpaqueTypesJank).
+    ///
+    /// We also check that all opaque types encountered as self types in the
+    /// autoderef chain don't get constrained when applying the candidate.
+    /// Importantly, this also handles calling methods taking `&self` on
+    /// `impl Trait` to reject the "by-self" candidate.
+    ///
+    /// This needs to happen at the end of `consider_probe` as we need to take
+    /// all the constraints from that into account.
+    #[instrument(level = "debug", skip(self), ret)]
+    fn should_reject_candidate_due_to_opaque_treated_as_rigid(
+        &self,
+        trait_predicate: Option<ty::Predicate<'tcx>>,
+    ) -> bool {
+        // Check whether the trait candidate would not be applicable if the
+        // opaque type were rigid.
+        if let Some(predicate) = trait_predicate {
+            let goal = Goal { param_env: self.param_env, predicate };
+            if !self.infcx.goal_may_hold_opaque_types_jank(goal) {
+                return true;
+            }
+        }
+
+        // Check whether any opaque types in the autoderef chain have been
+        // constrained.
+        for step in self.steps {
+            if step.self_ty_is_opaque {
+                debug!(?step.autoderefs, ?step.self_ty, "self_type_is_opaque");
+                let constrained_opaque = self.probe(|_| {
+                    // If we fail to instantiate the self type of this
+                    // step, this part of the deref-chain is no longer
+                    // reachable. In this case we don't care about opaque
+                    // types there.
+                    let Ok(ok) = self.fcx.probe_instantiate_query_response(
+                        self.span,
+                        self.orig_steps_var_values,
+                        &step.self_ty,
+                    ) else {
+                        debug!("failed to instantiate self_ty");
+                        return false;
+                    };
+                    let ocx = ObligationCtxt::new(self);
+                    let self_ty = ocx.register_infer_ok_obligations(ok);
+                    if !ocx.select_where_possible().is_empty() {
+                        debug!("failed to prove instantiate self_ty obligations");
+                        return false;
+                    }
+
+                    !self.resolve_vars_if_possible(self_ty).is_ty_var()
+                });
+                if constrained_opaque {
+                    debug!("opaque type has been constrained");
+                    return true;
+                }
+            }
+        }
+
+        false
+    }
+
     /// Sometimes we get in a situation where we have multiple probes that are all impls of the
     /// same trait, but we don't know which impl to use. In this case, since in all cases the
     /// external interface of the method can be determined from the trait, it's ok not to decide.
diff --git a/compiler/rustc_infer/src/infer/canonical/query_response.rs b/compiler/rustc_infer/src/infer/canonical/query_response.rs
index 5d1b4be9e57bb..a20cd31113ab1 100644
--- a/compiler/rustc_infer/src/infer/canonical/query_response.rs
+++ b/compiler/rustc_infer/src/infer/canonical/query_response.rs
@@ -85,11 +85,32 @@ impl<'tcx> InferCtxt<'tcx> {
     where
         T: Debug + TypeFoldable<TyCtxt<'tcx>>,
     {
+        // While we ignore region constraints and pending obligations,
+        // we do return constrained opaque types to avoid unconstrained
+        // inference variables in the response. This is still slightly
+        // insufficient as ambiguous `Projection` obligations have the
+        // same issue.
+        //
+        // FIXME(-Znext-solver): We could alternatively extend the `var_values`
+        // each time we call `make_query_response_ignoring_pending_obligations`
+        // and equate inference variables created inside of the query this way.
+        // This is what we do for `CanonicalState` and is probably a bit nicer.
+        let opaque_types = if self.next_trait_solver() {
+            self.inner
+                .borrow_mut()
+                .opaque_type_storage
+                .iter_opaque_types()
+                .map(|(k, v)| (k, v.ty))
+                .collect()
+        } else {
+            vec![]
+        };
+
         self.canonicalize_response(QueryResponse {
             var_values: inference_vars,
             region_constraints: QueryRegionConstraints::default(),
             certainty: Certainty::Proven, // Ambiguities are OK!
-            opaque_types: vec![],
+            opaque_types,
             value: answer,
         })
     }
diff --git a/compiler/rustc_middle/src/traits/query.rs b/compiler/rustc_middle/src/traits/query.rs
index c1b7c9b9b4e23..c5cd7c54e4e86 100644
--- a/compiler/rustc_middle/src/traits/query.rs
+++ b/compiler/rustc_middle/src/traits/query.rs
@@ -154,6 +154,7 @@ impl<'tcx> FromIterator<DropckConstraint<'tcx>> for DropckConstraint<'tcx> {
 #[derive(Debug, HashStable)]
 pub struct CandidateStep<'tcx> {
     pub self_ty: Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>,
+    pub self_ty_is_opaque: bool,
     pub autoderefs: usize,
     /// `true` if the type results from a dereference of a raw pointer.
     /// when assembling candidates, we include these steps, but not when
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
index 9b32e4876075d..85110530ae9bc 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
@@ -194,7 +194,7 @@ where
     D: SolverDelegate<Interner = I>,
     I: Interner,
 {
-    #[instrument(level = "debug", skip(self))]
+    #[instrument(level = "debug", skip(self), ret)]
     fn evaluate_root_goal(
         &self,
         goal: Goal<I, I::Predicate>,
@@ -206,6 +206,7 @@ where
         })
     }
 
+    #[instrument(level = "debug", skip(self), ret)]
     fn root_goal_may_hold_opaque_types_jank(
         &self,
         goal: Goal<Self::Interner, <Self::Interner as Interner>::Predicate>,
diff --git a/compiler/rustc_next_trait_solver/src/solve/mod.rs b/compiler/rustc_next_trait_solver/src/solve/mod.rs
index afb86aaf8ab21..a58caeecc33c5 100644
--- a/compiler/rustc_next_trait_solver/src/solve/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/mod.rs
@@ -381,6 +381,7 @@ where
 }
 
 /// The result of evaluating a goal.
+#[derive_where(Debug; I: Interner)]
 pub struct GoalEvaluation<I: Interner> {
     /// The goal we've evaluated. This is the input goal, but potentially with its
     /// inference variables resolved. This never applies any inference constraints
diff --git a/compiler/rustc_trait_selection/src/traits/query/evaluate_obligation.rs b/compiler/rustc_trait_selection/src/traits/query/evaluate_obligation.rs
index ae731505abfa5..34e0176d213f1 100644
--- a/compiler/rustc_trait_selection/src/traits/query/evaluate_obligation.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/evaluate_obligation.rs
@@ -1,6 +1,6 @@
 use rustc_infer::traits::solve::Goal;
 use rustc_macros::extension;
-use rustc_middle::span_bug;
+use rustc_middle::{span_bug, ty};
 use rustc_next_trait_solver::solve::SolverDelegateEvalExt;
 
 use crate::infer::InferCtxt;
@@ -22,7 +22,7 @@ impl<'tcx> InferCtxt<'tcx> {
     /// for more details.
     fn predicate_may_hold_opaque_types_jank(&self, obligation: &PredicateObligation<'tcx>) -> bool {
         if self.next_trait_solver() {
-            <&SolverDelegate<'tcx>>::from(self).root_goal_may_hold_opaque_types_jank(Goal::new(
+            self.goal_may_hold_opaque_types_jank(Goal::new(
                 self.tcx,
                 obligation.param_env,
                 obligation.predicate,
@@ -32,6 +32,13 @@ impl<'tcx> InferCtxt<'tcx> {
         }
     }
 
+    /// See the comment on [OpaqueTypesJank](crate::solve::OpaqueTypesJank)
+    /// for more details.
+    fn goal_may_hold_opaque_types_jank(&self, goal: Goal<'tcx, ty::Predicate<'tcx>>) -> bool {
+        assert!(self.next_trait_solver());
+        <&SolverDelegate<'tcx>>::from(self).root_goal_may_hold_opaque_types_jank(goal)
+    }
+
     /// Evaluates whether the predicate can be satisfied in the given
     /// `ParamEnv`, and returns `false` if not certain. However, this is
     /// not entirely accurate if inference variables are involved.
diff --git a/tests/ui/impl-trait/call_method_ambiguous.next.stderr b/tests/ui/impl-trait/call_method_ambiguous.next.stderr
deleted file mode 100644
index 0def594daf1cc..0000000000000
--- a/tests/ui/impl-trait/call_method_ambiguous.next.stderr
+++ /dev/null
@@ -1,17 +0,0 @@
-error[E0282]: type annotations needed
-  --> $DIR/call_method_ambiguous.rs:26:13
-   |
-LL |         let mut iter = foo(n - 1, m);
-   |             ^^^^^^^^
-LL |
-LL |         assert_eq!(iter.get(), 1);
-   |                         --- type must be known at this point
-   |
-help: consider giving `iter` an explicit type
-   |
-LL |         let mut iter: /* Type */ = foo(n - 1, m);
-   |                     ++++++++++++
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/impl-trait/call_method_ambiguous.rs b/tests/ui/impl-trait/call_method_ambiguous.rs
index 6bcafc8ce1494..021d6c22f79dd 100644
--- a/tests/ui/impl-trait/call_method_ambiguous.rs
+++ b/tests/ui/impl-trait/call_method_ambiguous.rs
@@ -1,6 +1,6 @@
 //@ revisions: current next
 //@[next] compile-flags: -Znext-solver
-//@[current] run-pass
+//@ run-pass
 
 trait Get {
     fn get(&mut self) -> u32;
@@ -24,7 +24,6 @@ where
 fn foo(n: usize, m: &mut ()) -> impl Get + use<'_> {
     if n > 0 {
         let mut iter = foo(n - 1, m);
-        //[next]~^ ERROR type annotations needed
         assert_eq!(iter.get(), 1);
     }
     m
diff --git a/tests/ui/impl-trait/call_method_on_inherent_impl.next.stderr b/tests/ui/impl-trait/call_method_on_inherent_impl.next.stderr
deleted file mode 100644
index 7bbf5f5153a59..0000000000000
--- a/tests/ui/impl-trait/call_method_on_inherent_impl.next.stderr
+++ /dev/null
@@ -1,17 +0,0 @@
-error[E0282]: type annotations needed
-  --> $DIR/call_method_on_inherent_impl.rs:18:13
-   |
-LL |         let x = my_foo();
-   |             ^
-LL |
-LL |         x.my_debug();
-   |           -------- type must be known at this point
-   |
-help: consider giving `x` an explicit type
-   |
-LL |         let x: /* Type */ = my_foo();
-   |              ++++++++++++
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/impl-trait/call_method_on_inherent_impl.rs b/tests/ui/impl-trait/call_method_on_inherent_impl.rs
index 0e333c3260a2f..1dd38bc671730 100644
--- a/tests/ui/impl-trait/call_method_on_inherent_impl.rs
+++ b/tests/ui/impl-trait/call_method_on_inherent_impl.rs
@@ -1,6 +1,6 @@
 //@ revisions: current next
 //@[next] compile-flags: -Znext-solver
-//@[current] check-pass
+//@ check-pass
 
 trait MyDebug {
     fn my_debug(&self);
@@ -16,7 +16,6 @@ where
 fn my_foo() -> impl std::fmt::Debug {
     if false {
         let x = my_foo();
-        //[next]~^ ERROR type annotations needed
         x.my_debug();
     }
     ()
diff --git a/tests/ui/impl-trait/call_method_on_inherent_impl_on_rigid_type.current.stderr b/tests/ui/impl-trait/call_method_on_inherent_impl_on_rigid_type.current.stderr
index 6ecb2b05fc56b..e710466447043 100644
--- a/tests/ui/impl-trait/call_method_on_inherent_impl_on_rigid_type.current.stderr
+++ b/tests/ui/impl-trait/call_method_on_inherent_impl_on_rigid_type.current.stderr
@@ -1,5 +1,5 @@
 error[E0599]: no method named `my_debug` found for reference `&impl Debug` in the current scope
-  --> $DIR/call_method_on_inherent_impl_on_rigid_type.rs:16:11
+  --> $DIR/call_method_on_inherent_impl_on_rigid_type.rs:15:11
    |
 LL |         x.my_debug();
    |           ^^^^^^^^ method not found in `&impl Debug`
diff --git a/tests/ui/impl-trait/call_method_on_inherent_impl_on_rigid_type.next.stderr b/tests/ui/impl-trait/call_method_on_inherent_impl_on_rigid_type.next.stderr
index 5fb0b8f1d14b2..de808259d40dc 100644
--- a/tests/ui/impl-trait/call_method_on_inherent_impl_on_rigid_type.next.stderr
+++ b/tests/ui/impl-trait/call_method_on_inherent_impl_on_rigid_type.next.stderr
@@ -1,17 +1,15 @@
-error[E0282]: type annotations needed for `&_`
-  --> $DIR/call_method_on_inherent_impl_on_rigid_type.rs:14:13
+error[E0599]: no method named `my_debug` found for reference `&_` in the current scope
+  --> $DIR/call_method_on_inherent_impl_on_rigid_type.rs:15:11
    |
-LL |         let x = &my_foo();
-   |             ^
-LL |
 LL |         x.my_debug();
-   |           -------- type must be known at this point
+   |           ^^^^^^^^ method not found in `&_`
    |
-help: consider giving `x` an explicit type, where the placeholders `_` are specified
+   = help: items from traits can only be used if the trait is implemented and in scope
+help: trait `MyDebug` which provides `my_debug` is implemented but not in scope; perhaps you want to import it
+   |
+LL + use MyDebug;
    |
-LL |         let x: &_ = &my_foo();
-   |              ++++
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0282`.
+For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/impl-trait/call_method_on_inherent_impl_on_rigid_type.rs b/tests/ui/impl-trait/call_method_on_inherent_impl_on_rigid_type.rs
index 7fb2ff3b2bcc6..0c9909efa1ba1 100644
--- a/tests/ui/impl-trait/call_method_on_inherent_impl_on_rigid_type.rs
+++ b/tests/ui/impl-trait/call_method_on_inherent_impl_on_rigid_type.rs
@@ -12,9 +12,8 @@ impl MyDebug for &() {
 fn my_foo() -> impl std::fmt::Debug {
     if false {
         let x = &my_foo();
-        //[next]~^ ERROR: type annotations needed
         x.my_debug();
-        //[current]~^ ERROR: no method named `my_debug`
+        //~^ ERROR: no method named `my_debug`
     }
     ()
 }
diff --git a/tests/ui/impl-trait/call_method_on_inherent_impl_ref.current.stderr b/tests/ui/impl-trait/call_method_on_inherent_impl_ref-err.current.stderr
similarity index 84%
rename from tests/ui/impl-trait/call_method_on_inherent_impl_ref.current.stderr
rename to tests/ui/impl-trait/call_method_on_inherent_impl_ref-err.current.stderr
index fb51bb7b4173b..71acbd1497d93 100644
--- a/tests/ui/impl-trait/call_method_on_inherent_impl_ref.current.stderr
+++ b/tests/ui/impl-trait/call_method_on_inherent_impl_ref-err.current.stderr
@@ -1,5 +1,5 @@
 error[E0599]: no method named `my_debug` found for opaque type `impl Debug` in the current scope
-  --> $DIR/call_method_on_inherent_impl_ref.rs:19:11
+  --> $DIR/call_method_on_inherent_impl_ref-err.rs:18:11
    |
 LL |     fn my_debug(&self);
    |        -------- the method is available for `&impl Debug` here
@@ -9,7 +9,7 @@ LL |         x.my_debug();
    |
    = help: items from traits can only be used if the trait is implemented and in scope
 note: `MyDebug` defines an item `my_debug`, perhaps you need to implement it
-  --> $DIR/call_method_on_inherent_impl_ref.rs:4:1
+  --> $DIR/call_method_on_inherent_impl_ref-err.rs:4:1
    |
 LL | trait MyDebug {
    | ^^^^^^^^^^^^^
diff --git a/tests/ui/impl-trait/call_method_on_inherent_impl_ref-err.next.stderr b/tests/ui/impl-trait/call_method_on_inherent_impl_ref-err.next.stderr
new file mode 100644
index 0000000000000..523505e980221
--- /dev/null
+++ b/tests/ui/impl-trait/call_method_on_inherent_impl_ref-err.next.stderr
@@ -0,0 +1,19 @@
+error[E0599]: no method named `my_debug` found for type `_` in the current scope
+  --> $DIR/call_method_on_inherent_impl_ref-err.rs:18:11
+   |
+LL |     fn my_debug(&self);
+   |        -------- the method is available for `&_` here
+...
+LL |         x.my_debug();
+   |           ^^^^^^^^ method not found in `_`
+   |
+   = help: items from traits can only be used if the trait is implemented and in scope
+note: `MyDebug` defines an item `my_debug`, perhaps you need to implement it
+  --> $DIR/call_method_on_inherent_impl_ref-err.rs:4:1
+   |
+LL | trait MyDebug {
+   | ^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/impl-trait/call_method_on_inherent_impl_ref-err.rs b/tests/ui/impl-trait/call_method_on_inherent_impl_ref-err.rs
new file mode 100644
index 0000000000000..0ed09bc76a41e
--- /dev/null
+++ b/tests/ui/impl-trait/call_method_on_inherent_impl_ref-err.rs
@@ -0,0 +1,24 @@
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
+
+trait MyDebug {
+    fn my_debug(&self);
+}
+
+impl<T> MyDebug for &T
+where
+    T: std::fmt::Debug,
+{
+    fn my_debug(&self) {}
+}
+
+fn my_foo() -> impl std::fmt::Debug {
+    if false {
+        let x = my_foo();
+        x.my_debug();
+        //~^ ERROR no method named `my_debug` found
+    }
+    ()
+}
+
+fn main() {}
diff --git a/tests/ui/impl-trait/call_method_on_inherent_impl_ref.rs b/tests/ui/impl-trait/call_method_on_inherent_impl_ref-ok.rs
similarity index 54%
rename from tests/ui/impl-trait/call_method_on_inherent_impl_ref.rs
rename to tests/ui/impl-trait/call_method_on_inherent_impl_ref-ok.rs
index 4e4098b37f93b..40739d6a0ce4b 100644
--- a/tests/ui/impl-trait/call_method_on_inherent_impl_ref.rs
+++ b/tests/ui/impl-trait/call_method_on_inherent_impl_ref-ok.rs
@@ -1,5 +1,6 @@
 //@ revisions: current next
 //@[next] compile-flags: -Znext-solver
+//@ check-pass
 
 trait MyDebug {
     fn my_debug(&self);
@@ -12,20 +13,9 @@ where
     fn my_debug(&self) {}
 }
 
-fn my_foo() -> impl std::fmt::Debug {
-    if false {
-        let x = my_foo();
-        //[next]~^ ERROR type annotations needed
-        x.my_debug();
-        //[current]~^ ERROR no method named `my_debug` found
-    }
-    ()
-}
-
 fn my_bar() -> impl std::fmt::Debug {
     if false {
         let x = &my_bar();
-        //[next]~^ ERROR type annotations needed
         x.my_debug();
     }
     ()
diff --git a/tests/ui/impl-trait/call_method_on_inherent_impl_ref.next.stderr b/tests/ui/impl-trait/call_method_on_inherent_impl_ref.next.stderr
deleted file mode 100644
index 5dea3a715e9bc..0000000000000
--- a/tests/ui/impl-trait/call_method_on_inherent_impl_ref.next.stderr
+++ /dev/null
@@ -1,31 +0,0 @@
-error[E0282]: type annotations needed
-  --> $DIR/call_method_on_inherent_impl_ref.rs:17:13
-   |
-LL |         let x = my_foo();
-   |             ^
-LL |
-LL |         x.my_debug();
-   |           -------- type must be known at this point
-   |
-help: consider giving `x` an explicit type
-   |
-LL |         let x: /* Type */ = my_foo();
-   |              ++++++++++++
-
-error[E0282]: type annotations needed for `&_`
-  --> $DIR/call_method_on_inherent_impl_ref.rs:27:13
-   |
-LL |         let x = &my_bar();
-   |             ^
-LL |
-LL |         x.my_debug();
-   |           -------- type must be known at this point
-   |
-help: consider giving `x` an explicit type, where the placeholders `_` are specified
-   |
-LL |         let x: &_ = &my_bar();
-   |              ++++
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/impl-trait/method-resolution4.next.stderr b/tests/ui/impl-trait/method-resolution4.next.stderr
deleted file mode 100644
index 47a9aac19ecc3..0000000000000
--- a/tests/ui/impl-trait/method-resolution4.next.stderr
+++ /dev/null
@@ -1,9 +0,0 @@
-error[E0282]: type annotations needed
-  --> $DIR/method-resolution4.rs:13:20
-   |
-LL |         foo(false).next().unwrap();
-   |                    ^^^^ cannot infer type
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/impl-trait/method-resolution4.rs b/tests/ui/impl-trait/method-resolution4.rs
index 90e7850cad51e..f90a9309cdab8 100644
--- a/tests/ui/impl-trait/method-resolution4.rs
+++ b/tests/ui/impl-trait/method-resolution4.rs
@@ -6,12 +6,11 @@
 
 //@ revisions: current next
 //@[next] compile-flags: -Znext-solver
-//@[current] check-pass
+//@ check-pass
 
 fn foo(b: bool) -> impl Iterator<Item = ()> {
     if b {
         foo(false).next().unwrap();
-        //[next]~^ ERROR type annotations needed
     }
     std::iter::empty()
 }
diff --git a/tests/ui/impl-trait/method-resolution5-deref-no-constrain.current.stderr b/tests/ui/impl-trait/method-resolution5-deref-no-constrain.current.stderr
new file mode 100644
index 0000000000000..08578de426ade
--- /dev/null
+++ b/tests/ui/impl-trait/method-resolution5-deref-no-constrain.current.stderr
@@ -0,0 +1,19 @@
+error[E0308]: mismatched types
+  --> $DIR/method-resolution5-deref-no-constrain.rs:20:5
+   |
+LL | fn via_deref() -> impl Deref<Target = Foo> {
+   |                                       --- expected `&Foo` because of return type
+...
+LL |     Box::new(Foo)
+   |     ^^^^^^^^^^^^^ expected `&Foo`, found `Box<Foo>`
+   |
+   = note: expected reference `&Foo`
+                 found struct `Box<Foo>`
+help: consider borrowing here
+   |
+LL |     &Box::new(Foo)
+   |     +
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/impl-trait/method-resolution5-deref-no-constrain.rs b/tests/ui/impl-trait/method-resolution5-deref-no-constrain.rs
new file mode 100644
index 0000000000000..2c41f62b9fda5
--- /dev/null
+++ b/tests/ui/impl-trait/method-resolution5-deref-no-constrain.rs
@@ -0,0 +1,23 @@
+//! The recursive method call yields the opaque type. We want
+//! to use the impl candidate for `Foo` here without constraining
+//! the opaque to `&Foo`.
+
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
+//@[next] check-pass
+
+use std::ops::Deref;
+struct Foo;
+impl Foo {
+    fn method(&self) {}
+}
+fn via_deref() -> impl Deref<Target = Foo> {
+    // Currently errors on stable, but should not
+    if false {
+        via_deref().method();
+    }
+
+    Box::new(Foo)
+    //[current]~^ ERROR mismatched types
+}
+fn main() {}
diff --git a/tests/ui/impl-trait/method-resolution5-deref.rs b/tests/ui/impl-trait/method-resolution5-deref.rs
new file mode 100644
index 0000000000000..6133a8efe244d
--- /dev/null
+++ b/tests/ui/impl-trait/method-resolution5-deref.rs
@@ -0,0 +1,30 @@
+//! The recursive method call yields the opaque type. We want
+//! to use the trait candidate for `impl Foo` here while not
+//! applying it for the `impl Deref`.
+
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
+//@ check-pass
+
+use std::ops::Deref;
+trait Foo {
+    fn method(&self) {}
+}
+impl Foo for u32 {}
+fn via_deref() -> impl Deref<Target = impl Foo> {
+    if false {
+        via_deref().method();
+    }
+
+    Box::new(1u32)
+}
+
+fn via_deref_nested() -> Box<impl Deref<Target = impl Foo>> {
+    if false {
+        via_deref_nested().method();
+    }
+
+    Box::new(Box::new(1u32))
+}
+
+fn main() {}
diff --git a/tests/ui/impl-trait/recursive-bound-eval.next.stderr b/tests/ui/impl-trait/recursive-bound-eval.next.stderr
deleted file mode 100644
index e94f0a59a1d22..0000000000000
--- a/tests/ui/impl-trait/recursive-bound-eval.next.stderr
+++ /dev/null
@@ -1,9 +0,0 @@
-error[E0282]: type annotations needed
-  --> $DIR/recursive-bound-eval.rs:20:28
-   |
-LL |     move || recursive_fn().parse()
-   |                            ^^^^^ cannot infer type
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/impl-trait/recursive-bound-eval.rs b/tests/ui/impl-trait/recursive-bound-eval.rs
index 7859c8983fc89..058b12e5651e3 100644
--- a/tests/ui/impl-trait/recursive-bound-eval.rs
+++ b/tests/ui/impl-trait/recursive-bound-eval.rs
@@ -1,10 +1,9 @@
 //! Test that we can evaluate nested obligations when invoking methods on recursive calls on
 //! an RPIT.
 
-//@revisions: next current
+//@ revisions: next current
 //@[next] compile-flags: -Znext-solver
-
-//@[current] check-pass
+//@ check-pass
 
 pub trait Parser<E> {
     fn parse(&self) -> E;
@@ -18,7 +17,6 @@ impl<E, T: Fn() -> E> Parser<E> for T {
 
 pub fn recursive_fn<E>() -> impl Parser<E> {
     move || recursive_fn().parse()
-    //[next]~^ ERROR: type annotations needed
 }
 
 fn main() {}
diff --git a/tests/ui/impl-trait/recursive-coroutine-boxed.next.stderr b/tests/ui/impl-trait/recursive-coroutine-boxed.next.stderr
deleted file mode 100644
index 5ce6eb0fc3989..0000000000000
--- a/tests/ui/impl-trait/recursive-coroutine-boxed.next.stderr
+++ /dev/null
@@ -1,17 +0,0 @@
-error[E0282]: type annotations needed
-  --> $DIR/recursive-coroutine-boxed.rs:11:23
-   |
-LL |         let mut gen = Box::pin(foo());
-   |                       ^^^^^^^^ cannot infer type of the type parameter `T` declared on the struct `Box`
-LL |
-LL |         let mut r = gen.as_mut().resume(());
-   |                         ------ type must be known at this point
-   |
-help: consider specifying the generic argument
-   |
-LL |         let mut gen = Box::<T>::pin(foo());
-   |                          +++++
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/impl-trait/recursive-coroutine-boxed.rs b/tests/ui/impl-trait/recursive-coroutine-boxed.rs
index 306edc3591e98..932023d103dc4 100644
--- a/tests/ui/impl-trait/recursive-coroutine-boxed.rs
+++ b/tests/ui/impl-trait/recursive-coroutine-boxed.rs
@@ -1,7 +1,7 @@
 //@ revisions: current next
 //@ ignore-compare-mode-next-solver (explicit revisions)
-//@[current] check-pass
 //@[next] compile-flags: -Znext-solver
+//@ check-pass
 #![feature(coroutines, coroutine_trait)]
 
 use std::ops::{Coroutine, CoroutineState};
@@ -9,7 +9,6 @@ use std::ops::{Coroutine, CoroutineState};
 fn foo() -> impl Coroutine<Yield = (), Return = ()> {
     #[coroutine] || {
         let mut gen = Box::pin(foo());
-        //[next]~^ ERROR type annotations needed
         let mut r = gen.as_mut().resume(());
         while let CoroutineState::Yielded(v) = r {
             yield v;
diff --git a/tests/ui/type-alias-impl-trait/method_resolution_trait_method_from_opaque.next.stderr b/tests/ui/type-alias-impl-trait/method_resolution_trait_method_from_opaque.next.stderr
index 5aae334ccbd2f..37bde4b18a45b 100644
--- a/tests/ui/type-alias-impl-trait/method_resolution_trait_method_from_opaque.next.stderr
+++ b/tests/ui/type-alias-impl-trait/method_resolution_trait_method_from_opaque.next.stderr
@@ -2,7 +2,13 @@ error[E0282]: type annotations needed
   --> $DIR/method_resolution_trait_method_from_opaque.rs:28:18
    |
 LL |         self.bar.next().unwrap();
-   |                  ^^^^ cannot infer type
+   |                  ^^^^
+   |
+help: try using a fully qualified path to specify the expected types
+   |
+LL -         self.bar.next().unwrap();
+LL +         <_ as Iterator>::next(&mut self.bar).unwrap();
+   |
 
 error: aborting due to 1 previous error
 

From eebf871feaca10886f80a76a36b3771e960c047e Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Wed, 24 Sep 2025 10:08:00 +0200
Subject: [PATCH 1432/1889] move tests

---
 tests/ui/impl-trait/{ => method}/method-resolution.rs             | 0
 tests/ui/impl-trait/{ => method}/method-resolution2.next.stderr   | 0
 tests/ui/impl-trait/{ => method}/method-resolution2.rs            | 0
 .../ui/impl-trait/{ => method}/method-resolution3.current.stderr  | 0
 tests/ui/impl-trait/{ => method}/method-resolution3.next.stderr   | 0
 tests/ui/impl-trait/{ => method}/method-resolution3.rs            | 0
 tests/ui/impl-trait/{ => method}/method-resolution4.rs            | 0
 .../method-resolution5-deref-no-constrain.current.stderr          | 0
 .../{ => method}/method-resolution5-deref-no-constrain.rs         | 0
 tests/ui/impl-trait/{ => method}/method-resolution5-deref.rs      | 0
 10 files changed, 0 insertions(+), 0 deletions(-)
 rename tests/ui/impl-trait/{ => method}/method-resolution.rs (100%)
 rename tests/ui/impl-trait/{ => method}/method-resolution2.next.stderr (100%)
 rename tests/ui/impl-trait/{ => method}/method-resolution2.rs (100%)
 rename tests/ui/impl-trait/{ => method}/method-resolution3.current.stderr (100%)
 rename tests/ui/impl-trait/{ => method}/method-resolution3.next.stderr (100%)
 rename tests/ui/impl-trait/{ => method}/method-resolution3.rs (100%)
 rename tests/ui/impl-trait/{ => method}/method-resolution4.rs (100%)
 rename tests/ui/impl-trait/{ => method}/method-resolution5-deref-no-constrain.current.stderr (100%)
 rename tests/ui/impl-trait/{ => method}/method-resolution5-deref-no-constrain.rs (100%)
 rename tests/ui/impl-trait/{ => method}/method-resolution5-deref.rs (100%)

diff --git a/tests/ui/impl-trait/method-resolution.rs b/tests/ui/impl-trait/method/method-resolution.rs
similarity index 100%
rename from tests/ui/impl-trait/method-resolution.rs
rename to tests/ui/impl-trait/method/method-resolution.rs
diff --git a/tests/ui/impl-trait/method-resolution2.next.stderr b/tests/ui/impl-trait/method/method-resolution2.next.stderr
similarity index 100%
rename from tests/ui/impl-trait/method-resolution2.next.stderr
rename to tests/ui/impl-trait/method/method-resolution2.next.stderr
diff --git a/tests/ui/impl-trait/method-resolution2.rs b/tests/ui/impl-trait/method/method-resolution2.rs
similarity index 100%
rename from tests/ui/impl-trait/method-resolution2.rs
rename to tests/ui/impl-trait/method/method-resolution2.rs
diff --git a/tests/ui/impl-trait/method-resolution3.current.stderr b/tests/ui/impl-trait/method/method-resolution3.current.stderr
similarity index 100%
rename from tests/ui/impl-trait/method-resolution3.current.stderr
rename to tests/ui/impl-trait/method/method-resolution3.current.stderr
diff --git a/tests/ui/impl-trait/method-resolution3.next.stderr b/tests/ui/impl-trait/method/method-resolution3.next.stderr
similarity index 100%
rename from tests/ui/impl-trait/method-resolution3.next.stderr
rename to tests/ui/impl-trait/method/method-resolution3.next.stderr
diff --git a/tests/ui/impl-trait/method-resolution3.rs b/tests/ui/impl-trait/method/method-resolution3.rs
similarity index 100%
rename from tests/ui/impl-trait/method-resolution3.rs
rename to tests/ui/impl-trait/method/method-resolution3.rs
diff --git a/tests/ui/impl-trait/method-resolution4.rs b/tests/ui/impl-trait/method/method-resolution4.rs
similarity index 100%
rename from tests/ui/impl-trait/method-resolution4.rs
rename to tests/ui/impl-trait/method/method-resolution4.rs
diff --git a/tests/ui/impl-trait/method-resolution5-deref-no-constrain.current.stderr b/tests/ui/impl-trait/method/method-resolution5-deref-no-constrain.current.stderr
similarity index 100%
rename from tests/ui/impl-trait/method-resolution5-deref-no-constrain.current.stderr
rename to tests/ui/impl-trait/method/method-resolution5-deref-no-constrain.current.stderr
diff --git a/tests/ui/impl-trait/method-resolution5-deref-no-constrain.rs b/tests/ui/impl-trait/method/method-resolution5-deref-no-constrain.rs
similarity index 100%
rename from tests/ui/impl-trait/method-resolution5-deref-no-constrain.rs
rename to tests/ui/impl-trait/method/method-resolution5-deref-no-constrain.rs
diff --git a/tests/ui/impl-trait/method-resolution5-deref.rs b/tests/ui/impl-trait/method/method-resolution5-deref.rs
similarity index 100%
rename from tests/ui/impl-trait/method-resolution5-deref.rs
rename to tests/ui/impl-trait/method/method-resolution5-deref.rs

From d6fe5334185385372d1fe8f1c9df8f5d3e7be788 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Wed, 24 Sep 2025 10:28:52 +0200
Subject: [PATCH 1433/1889] add tests

---
 .../method/broken-deref-chain.current.stderr  | 19 ++++++++
 .../impl-trait/method/broken-deref-chain.rs   | 47 +++++++++++++++++++
 .../would-constrain-opaque.current.stderr     | 29 ++++++++++++
 .../method/would-constrain-opaque.next.stderr | 27 +++++++++++
 .../method/would-constrain-opaque.rs          | 39 +++++++++++++++
 5 files changed, 161 insertions(+)
 create mode 100644 tests/ui/impl-trait/method/broken-deref-chain.current.stderr
 create mode 100644 tests/ui/impl-trait/method/broken-deref-chain.rs
 create mode 100644 tests/ui/impl-trait/method/would-constrain-opaque.current.stderr
 create mode 100644 tests/ui/impl-trait/method/would-constrain-opaque.next.stderr
 create mode 100644 tests/ui/impl-trait/method/would-constrain-opaque.rs

diff --git a/tests/ui/impl-trait/method/broken-deref-chain.current.stderr b/tests/ui/impl-trait/method/broken-deref-chain.current.stderr
new file mode 100644
index 0000000000000..726f076b183bd
--- /dev/null
+++ b/tests/ui/impl-trait/method/broken-deref-chain.current.stderr
@@ -0,0 +1,19 @@
+error[E0308]: mismatched types
+  --> $DIR/broken-deref-chain.rs:41:30
+   |
+LL | fn trait_method() -> impl Trait {
+   |                      ---------- the found opaque type
+...
+LL |         x.trait_method();
+   |         - here the type of `x` is inferred to be `Foo<u32, impl Trait>`
+LL |         let _: Foo<i32, _> = x; // Test that we did not apply the deref step
+   |                -----------   ^ expected `Foo<i32, _>`, found `Foo<u32, impl Trait>`
+   |                |
+   |                expected due to this
+   |
+   = note: expected struct `Foo<i32, _>`
+              found struct `Foo<u32, impl Trait>`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/impl-trait/method/broken-deref-chain.rs b/tests/ui/impl-trait/method/broken-deref-chain.rs
new file mode 100644
index 0000000000000..8b45e044f4332
--- /dev/null
+++ b/tests/ui/impl-trait/method/broken-deref-chain.rs
@@ -0,0 +1,47 @@
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
+//@[next] check-pass
+
+// An annoying edge case of method selection. While computing the deref-chain
+// constrains `T` to `u32`, the final method candidate does not and instead
+// constrains to `i32`. In this case, we no longer check that the opaque
+// remains unconstrained. Both method calls in this test constrain the opaque
+// to `i32`.
+use std::ops::Deref;
+
+struct Foo<T, U>(T, U);
+impl<U> Deref for Foo<u32, U> {
+    type Target = U;
+    fn deref(&self) -> &Self::Target {
+        &self.1
+    }
+}
+
+impl Foo<i32, i32> {
+    fn method(&self) {}
+}
+fn inherent_method() -> impl Sized {
+    if false {
+        let x = Foo(Default::default(), inherent_method());
+        x.method();
+        let _: Foo<i32, _> = x; // Test that we did not apply the deref step
+    }
+    1i32
+}
+
+trait Trait {
+    fn trait_method(&self) {}
+}
+impl Trait for Foo<i32, i32> {}
+impl Trait for i32 {}
+fn trait_method() -> impl Trait {
+    if false {
+        let x = Foo(Default::default(), trait_method());
+        x.trait_method();
+        let _: Foo<i32, _> = x; // Test that we did not apply the deref step
+        //[current]~^ ERROR mismatched types
+    }
+    1i32
+}
+
+fn main() {}
diff --git a/tests/ui/impl-trait/method/would-constrain-opaque.current.stderr b/tests/ui/impl-trait/method/would-constrain-opaque.current.stderr
new file mode 100644
index 0000000000000..60533a39c536f
--- /dev/null
+++ b/tests/ui/impl-trait/method/would-constrain-opaque.current.stderr
@@ -0,0 +1,29 @@
+error[E0599]: no method named `method` found for reference `&impl Sized` in the current scope
+  --> $DIR/would-constrain-opaque.rs:28:11
+   |
+LL |         x.method();
+   |           ^^^^^^ method not found in `&impl Sized`
+   |
+   = help: items from traits can only be used if the trait is implemented and in scope
+note: `Trait` defines an item `method`, perhaps you need to implement it
+  --> $DIR/would-constrain-opaque.rs:15:1
+   |
+LL | trait Trait: Sized {
+   | ^^^^^^^^^^^^^^^^^^
+
+error[E0599]: no method named `method` found for reference `&impl Sized` in the current scope
+  --> $DIR/would-constrain-opaque.rs:30:11
+   |
+LL |         x.method();
+   |           ^^^^^^ method not found in `&impl Sized`
+   |
+   = help: items from traits can only be used if the trait is implemented and in scope
+note: `Trait` defines an item `method`, perhaps you need to implement it
+  --> $DIR/would-constrain-opaque.rs:15:1
+   |
+LL | trait Trait: Sized {
+   | ^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/impl-trait/method/would-constrain-opaque.next.stderr b/tests/ui/impl-trait/method/would-constrain-opaque.next.stderr
new file mode 100644
index 0000000000000..23a4ceb826a6e
--- /dev/null
+++ b/tests/ui/impl-trait/method/would-constrain-opaque.next.stderr
@@ -0,0 +1,27 @@
+error[E0599]: no method named `method` found for reference `&_` in the current scope
+  --> $DIR/would-constrain-opaque.rs:28:11
+   |
+LL |         x.method();
+   |           ^^^^^^ method not found in `&_`
+   |
+   = help: items from traits can only be used if the trait is implemented and in scope
+help: trait `Trait` which provides `method` is implemented but not in scope; perhaps you want to import it
+   |
+LL + use Trait;
+   |
+
+error[E0599]: no method named `method` found for reference `&_` in the current scope
+  --> $DIR/would-constrain-opaque.rs:30:11
+   |
+LL |         x.method();
+   |           ^^^^^^ method not found in `&_`
+   |
+   = help: items from traits can only be used if the trait is implemented and in scope
+help: trait `Trait` which provides `method` is implemented but not in scope; perhaps you want to import it
+   |
+LL + use Trait;
+   |
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/impl-trait/method/would-constrain-opaque.rs b/tests/ui/impl-trait/method/would-constrain-opaque.rs
new file mode 100644
index 0000000000000..8dd322825296b
--- /dev/null
+++ b/tests/ui/impl-trait/method/would-constrain-opaque.rs
@@ -0,0 +1,39 @@
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
+
+// If we don't treat `impl Sized` as rigid, the first call would
+// resolve to the trait method, constraining the opaque, while the
+// second call would resolve to the inherent method.
+//
+// We avoid cases like this by rejecting candidates which constrain
+// opaque types encountered in the autoderef chain.
+//
+// FIXME(-Znext-solver): ideally we would note that the inference variable
+// is an opaque type in the error message and change this to a type annotations
+// needed error.
+
+trait Trait: Sized {
+    fn method(self) {}
+}
+impl Trait for &Foo {}
+
+struct Foo;
+impl Foo {
+    fn method(&self) {}
+}
+
+fn define_opaque(b: bool) -> impl Sized {
+    if b {
+        let x = &define_opaque(false);
+        x.method();
+        //~^ ERROR no method named `method` found for reference
+        x.method();
+        //~^ ERROR no method named `method` found for reference
+    }
+
+    Foo
+}
+
+fn main() {
+    define_opaque(true);
+}

From c2e39c2f20c568b96fe89c751e65bbbe9116231c Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Fri, 26 Sep 2025 16:37:03 +0200
Subject: [PATCH 1434/1889] review

---
 compiler/rustc_hir_typeck/src/method/probe.rs         |  9 +++++++++
 .../rustc_infer/src/infer/canonical/query_response.rs | 11 ++++-------
 2 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/method/probe.rs b/compiler/rustc_hir_typeck/src/method/probe.rs
index e34ee6258b85b..12f80a197b1b8 100644
--- a/compiler/rustc_hir_typeck/src/method/probe.rs
+++ b/compiler/rustc_hir_typeck/src/method/probe.rs
@@ -2192,6 +2192,15 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
         &self,
         trait_predicate: Option<ty::Predicate<'tcx>>,
     ) -> bool {
+        // This function is what hacky and doesn't perfectly do what we want it to.
+        // It's not soundness critical and we should be able to freely improve this
+        // in the future.
+        //
+        // Some concrete edge cases include the fact that `goal_may_hold_opaque_types_jank`
+        // also fails if there are any constraints opaques which are never used as a self
+        // type. We also allow where-bounds which are currently ambiguous but end up
+        // constraining an opaque later on.
+
         // Check whether the trait candidate would not be applicable if the
         // opaque type were rigid.
         if let Some(predicate) = trait_predicate {
diff --git a/compiler/rustc_infer/src/infer/canonical/query_response.rs b/compiler/rustc_infer/src/infer/canonical/query_response.rs
index a20cd31113ab1..b3959113d5dc9 100644
--- a/compiler/rustc_infer/src/infer/canonical/query_response.rs
+++ b/compiler/rustc_infer/src/infer/canonical/query_response.rs
@@ -87,14 +87,11 @@ impl<'tcx> InferCtxt<'tcx> {
     {
         // While we ignore region constraints and pending obligations,
         // we do return constrained opaque types to avoid unconstrained
-        // inference variables in the response. This is still slightly
-        // insufficient as ambiguous `Projection` obligations have the
-        // same issue.
+        // inference variables in the response. This is important as we want
+        // to check that opaques in deref steps stay unconstrained.
         //
-        // FIXME(-Znext-solver): We could alternatively extend the `var_values`
-        // each time we call `make_query_response_ignoring_pending_obligations`
-        // and equate inference variables created inside of the query this way.
-        // This is what we do for `CanonicalState` and is probably a bit nicer.
+        // This doesn't handle the more general case for non-opaques as
+        // ambiguous `Projection` obligations have same the issue.
         let opaque_types = if self.next_trait_solver() {
             self.inner
                 .borrow_mut()

From 07bb89f98d485a888796fabb322af06d222a5cd8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=2E=20Neusch=C3=A4fer?= <j.ne@posteo.net>
Date: Fri, 26 Sep 2025 17:48:16 +0200
Subject: [PATCH 1435/1889] Update memchr to 2.7.6

memchr 2.7.6 contains a bugfix for aarch64_be
---
 src/tools/rust-analyzer/Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/Cargo.lock b/src/tools/rust-analyzer/Cargo.lock
index 9d0f63d2bcecb..086f38f06a52d 100644
--- a/src/tools/rust-analyzer/Cargo.lock
+++ b/src/tools/rust-analyzer/Cargo.lock
@@ -1334,9 +1334,9 @@ dependencies = [
 
 [[package]]
 name = "memchr"
-version = "2.7.5"
+version = "2.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0"
+checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
 
 [[package]]
 name = "memmap2"

From c0e0d4b68d38a92c19f42d3003074b5b6e7b65c8 Mon Sep 17 00:00:00 2001
From: Li-yao Xia <lysxia@gmail.com>
Date: Fri, 26 Sep 2025 18:14:31 +0200
Subject: [PATCH 1436/1889] Make `def_path_hash_to_def_id` not panic when
 passed an invalid hash

---
 compiler/rustc_metadata/src/rmeta/decoder.rs             | 2 +-
 compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs | 4 ++--
 compiler/rustc_metadata/src/rmeta/def_path_hash_map.rs   | 9 +++++----
 compiler/rustc_middle/src/hooks/mod.rs                   | 2 +-
 compiler/rustc_middle/src/ty/context.rs                  | 2 +-
 5 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/compiler/rustc_metadata/src/rmeta/decoder.rs b/compiler/rustc_metadata/src/rmeta/decoder.rs
index 0c8d1f32e991e..b895feb906247 100644
--- a/compiler/rustc_metadata/src/rmeta/decoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/decoder.rs
@@ -1555,7 +1555,7 @@ impl<'a> CrateMetadataRef<'a> {
     }
 
     #[inline]
-    fn def_path_hash_to_def_index(self, hash: DefPathHash) -> DefIndex {
+    fn def_path_hash_to_def_index(self, hash: DefPathHash) -> Option<DefIndex> {
         self.def_path_hash_map.def_path_hash_to_def_index(&hash)
     }
 
diff --git a/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs b/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs
index 11fef3be5d09b..df3add316ec23 100644
--- a/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs
+++ b/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs
@@ -691,8 +691,8 @@ fn provide_cstore_hooks(providers: &mut Providers) {
             .get(&stable_crate_id)
             .unwrap_or_else(|| bug!("uninterned StableCrateId: {stable_crate_id:?}"));
         assert_ne!(cnum, LOCAL_CRATE);
-        let def_index = cstore.get_crate_data(cnum).def_path_hash_to_def_index(hash);
-        DefId { krate: cnum, index: def_index }
+        let def_index = cstore.get_crate_data(cnum).def_path_hash_to_def_index(hash)?;
+        Some(DefId { krate: cnum, index: def_index })
     };
 
     providers.hooks.expn_hash_to_expn_id = |tcx, cnum, index_guess, hash| {
diff --git a/compiler/rustc_metadata/src/rmeta/def_path_hash_map.rs b/compiler/rustc_metadata/src/rmeta/def_path_hash_map.rs
index f3917b55782b0..a17b3e1047d09 100644
--- a/compiler/rustc_metadata/src/rmeta/def_path_hash_map.rs
+++ b/compiler/rustc_metadata/src/rmeta/def_path_hash_map.rs
@@ -12,11 +12,12 @@ pub(crate) enum DefPathHashMapRef<'tcx> {
 
 impl DefPathHashMapRef<'_> {
     #[inline]
-    pub(crate) fn def_path_hash_to_def_index(&self, def_path_hash: &DefPathHash) -> DefIndex {
+    pub(crate) fn def_path_hash_to_def_index(
+        &self,
+        def_path_hash: &DefPathHash,
+    ) -> Option<DefIndex> {
         match *self {
-            DefPathHashMapRef::OwnedFromMetadata(ref map) => {
-                map.get(&def_path_hash.local_hash()).unwrap()
-            }
+            DefPathHashMapRef::OwnedFromMetadata(ref map) => map.get(&def_path_hash.local_hash()),
             DefPathHashMapRef::BorrowedFromTcx(_) => {
                 panic!("DefPathHashMap::BorrowedFromTcx variant only exists for serialization")
             }
diff --git a/compiler/rustc_middle/src/hooks/mod.rs b/compiler/rustc_middle/src/hooks/mod.rs
index 9d2f0a4523713..dc6a3334a4c8b 100644
--- a/compiler/rustc_middle/src/hooks/mod.rs
+++ b/compiler/rustc_middle/src/hooks/mod.rs
@@ -77,7 +77,7 @@ declare_hooks! {
     /// session, if it still exists. This is used during incremental compilation to
     /// turn a deserialized `DefPathHash` into its current `DefId`.
     /// Will fetch a DefId from a DefPathHash for a foreign crate.
-    hook def_path_hash_to_def_id_extern(hash: DefPathHash, stable_crate_id: StableCrateId) -> DefId;
+    hook def_path_hash_to_def_id_extern(hash: DefPathHash, stable_crate_id: StableCrateId) -> Option<DefId>;
 
     /// Returns `true` if we should codegen an instance in the local crate, or returns `false` if we
     /// can just link to the upstream crate and therefore don't need a mono item.
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 7d3e2c9965dad..a961e04cf79c0 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -2012,7 +2012,7 @@ impl<'tcx> TyCtxt<'tcx> {
         if stable_crate_id == self.stable_crate_id(LOCAL_CRATE) {
             Some(self.untracked.definitions.read().local_def_path_hash_to_def_id(hash)?.to_def_id())
         } else {
-            Some(self.def_path_hash_to_def_id_extern(hash, stable_crate_id))
+            self.def_path_hash_to_def_id_extern(hash, stable_crate_id)
         }
     }
 

From 4c7292aba3c7b61708e49a5ec0061d5d901affad Mon Sep 17 00:00:00 2001
From: Augie Fackler <augie@google.com>
Date: Fri, 26 Sep 2025 13:27:34 -0400
Subject: [PATCH 1437/1889] PassWrapper: drop unused variable for LLVM 22+

---
 compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
index 136b6e9bf50fd..b7637b29bca53 100644
--- a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
@@ -569,7 +569,9 @@ extern "C" LLVMRustResult LLVMRustOptimize(
   }
 
   std::optional<PGOOptions> PGOOpt;
+#if LLVM_VERSION_LE(22, 0)
   auto FS = vfs::getRealFileSystem();
+#endif
   if (PGOGenPath) {
     assert(!PGOUsePath && !PGOSampleUsePath);
     PGOOpt = PGOOptions(

From 99456cc015114874319744a07afc1ba94a32315a Mon Sep 17 00:00:00 2001
From: Augie Fackler <augie@google.com>
Date: Fri, 26 Sep 2025 13:32:03 -0400
Subject: [PATCH 1438/1889] tests: use max-llvm-major-version instead of
 ignore-llvm-version

---
 .../codegen-llvm/issues/issue-122600-ptr-discriminant-update.rs | 2 +-
 tests/codegen-llvm/vec_pop_push_noop.rs                         | 2 +-
 tests/codegen-llvm/vecdeque_pop_push.rs                         | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/codegen-llvm/issues/issue-122600-ptr-discriminant-update.rs b/tests/codegen-llvm/issues/issue-122600-ptr-discriminant-update.rs
index 631468d8c217a..a0b453fac8e93 100644
--- a/tests/codegen-llvm/issues/issue-122600-ptr-discriminant-update.rs
+++ b/tests/codegen-llvm/issues/issue-122600-ptr-discriminant-update.rs
@@ -1,6 +1,6 @@
 //@ compile-flags: -Copt-level=3
 //@ revisions: new old
-//@ [old] ignore-llvm-version: 22 - 99
+//@ [old] max-llvm-major-version: 21
 //@ [new] min-llvm-version: 22
 
 #![crate_type = "lib"]
diff --git a/tests/codegen-llvm/vec_pop_push_noop.rs b/tests/codegen-llvm/vec_pop_push_noop.rs
index fadc6e99dc7a6..977c220b3baef 100644
--- a/tests/codegen-llvm/vec_pop_push_noop.rs
+++ b/tests/codegen-llvm/vec_pop_push_noop.rs
@@ -1,6 +1,6 @@
 //@ compile-flags: -Copt-level=3
 //@ revisions: new old
-//@ [old] ignore-llvm-version: 22 - 99
+//@ [old] max-llvm-major-version: 21
 //@ [new] min-llvm-version: 22
 
 #![crate_type = "lib"]
diff --git a/tests/codegen-llvm/vecdeque_pop_push.rs b/tests/codegen-llvm/vecdeque_pop_push.rs
index 7886db3fedeba..6f9ad6674d6cd 100644
--- a/tests/codegen-llvm/vecdeque_pop_push.rs
+++ b/tests/codegen-llvm/vecdeque_pop_push.rs
@@ -1,6 +1,6 @@
 //@ compile-flags: -Copt-level=3
 //@ revisions: new old
-//@ [old] ignore-llvm-version: 22 - 99
+//@ [old] max-llvm-major-version: 21
 //@ [new] min-llvm-version: 22
 
 #![crate_type = "lib"]

From 77c6acc74ecd44ba7eb5a73c934dffdff7340133 Mon Sep 17 00:00:00 2001
From: Augie Fackler <augie@google.com>
Date: Thu, 6 Mar 2025 22:10:42 -0500
Subject: [PATCH 1439/1889] debuginfo: add an unstable flag to write split
 DWARF to an explicit directory

Bazel requires knowledge of outputs from actions at analysis time,
including file or directory name. In order to work around the lack of
predictable output name for dwo files, we group the dwo files in a
subdirectory of --out-dir as a post-processing step before returning
control to bazel. Unfortunately some debugging workflows rely on
directly opening the dwo file rather than loading the merged dwp file,
and our trick of moving the files breaks those users. We can't just
hardlink the file or copy it, because with remote build execution we
wouldn't end up with the un-moved file copied back to the developer's
workstation. As a fix, we add this unstable flag that causes dwo files
to be written to a build-system-controllable location, which then lets
bazel hoover up the dwo files, but the objects also have the correct
path for the dwo files.
---
 compiler/rustc_interface/src/util.rs  |  2 ++
 compiler/rustc_session/src/config.rs  | 12 +++++++++++-
 compiler/rustc_session/src/options.rs |  2 ++
 3 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_interface/src/util.rs b/compiler/rustc_interface/src/util.rs
index 76ccd12797e5e..58ec72b5b45b5 100644
--- a/compiler/rustc_interface/src/util.rs
+++ b/compiler/rustc_interface/src/util.rs
@@ -542,6 +542,7 @@ pub fn build_output_filenames(attrs: &[ast::Attribute], sess: &Session) -> Outpu
                 stem,
                 None,
                 sess.io.temps_dir.clone(),
+                sess.opts.unstable_opts.split_dwarf_out_dir.clone(),
                 sess.opts.cg.extra_filename.clone(),
                 sess.opts.output_types.clone(),
             )
@@ -571,6 +572,7 @@ pub fn build_output_filenames(attrs: &[ast::Attribute], sess: &Session) -> Outpu
                 out_filestem,
                 ofile,
                 sess.io.temps_dir.clone(),
+                sess.opts.unstable_opts.split_dwarf_out_dir.clone(),
                 sess.opts.cg.extra_filename.clone(),
                 sess.opts.output_types.clone(),
             )
diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs
index ebb6a93b1dd18..93be50f0a26cb 100644
--- a/compiler/rustc_session/src/config.rs
+++ b/compiler/rustc_session/src/config.rs
@@ -1193,6 +1193,7 @@ pub struct OutputFilenames {
     filestem: String,
     pub single_output_file: Option<OutFileName>,
     temps_directory: Option<PathBuf>,
+    explicit_dwo_out_directory: Option<PathBuf>,
     pub outputs: OutputTypes,
 }
 
@@ -1225,6 +1226,7 @@ impl OutputFilenames {
         out_filestem: String,
         single_output_file: Option<OutFileName>,
         temps_directory: Option<PathBuf>,
+        explicit_dwo_out_directory: Option<PathBuf>,
         extra: String,
         outputs: OutputTypes,
     ) -> Self {
@@ -1232,6 +1234,7 @@ impl OutputFilenames {
             out_directory,
             single_output_file,
             temps_directory,
+            explicit_dwo_out_directory,
             outputs,
             crate_stem: format!("{out_crate_name}{extra}"),
             filestem: format!("{out_filestem}{extra}"),
@@ -1281,7 +1284,14 @@ impl OutputFilenames {
         codegen_unit_name: &str,
         invocation_temp: Option<&str>,
     ) -> PathBuf {
-        self.temp_path_ext_for_cgu(DWARF_OBJECT_EXT, codegen_unit_name, invocation_temp)
+        let p = self.temp_path_ext_for_cgu(DWARF_OBJECT_EXT, codegen_unit_name, invocation_temp);
+        if let Some(dwo_out) = &self.explicit_dwo_out_directory {
+            let mut o = dwo_out.clone();
+            o.push(p.file_name().unwrap());
+            o
+        } else {
+            p
+        }
     }
 
     /// Like `temp_path`, but also supports things where there is no corresponding
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
index b2cc169f12cb7..9287e032dc4c9 100644
--- a/compiler/rustc_session/src/options.rs
+++ b/compiler/rustc_session/src/options.rs
@@ -2633,6 +2633,8 @@ written to standard error output)"),
                  file which is ignored by the linker
         `single`: sections which do not require relocation are written into object file but ignored
                   by the linker"),
+    split_dwarf_out_dir : Option<PathBuf> = (None, parse_opt_pathbuf, [TRACKED],
+        "location for writing split DWARF objects (`.dwo`) if enabled"),
     split_lto_unit: Option<bool> = (None, parse_opt_bool, [TRACKED],
         "enable LTO unit splitting (default: no)"),
     src_hash_algorithm: Option<SourceFileHashAlgorithm> = (None, parse_src_file_hash, [TRACKED],

From 2e904c4d078967abff213637a45386e2676c3757 Mon Sep 17 00:00:00 2001
From: Joshua Rayton <joshua.rayton@gmail.com>
Date: Fri, 26 Sep 2025 18:17:31 +0100
Subject: [PATCH 1440/1889] update issue number for more_float_constants

---
 library/core/src/num/f128.rs | 12 ++++++------
 library/core/src/num/f16.rs  | 12 ++++++------
 library/core/src/num/f32.rs  | 12 ++++++------
 library/core/src/num/f64.rs  | 12 ++++++------
 4 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/library/core/src/num/f128.rs b/library/core/src/num/f128.rs
index 73ca3fbb142c8..4fe4735e304c9 100644
--- a/library/core/src/num/f128.rs
+++ b/library/core/src/num/f128.rs
@@ -33,12 +33,12 @@ pub mod consts {
 
     /// The golden ratio (φ)
     #[unstable(feature = "f128", issue = "116909")]
-    // Also, #[unstable(feature = "more_float_constants", issue = "103883")]
+    // Also, #[unstable(feature = "more_float_constants", issue = "146939")]
     pub const PHI: f128 = 1.61803398874989484820458683436563811772030917980576286213545_f128;
 
     /// The Euler-Mascheroni constant (γ)
     #[unstable(feature = "f128", issue = "116909")]
-    // Also, #[unstable(feature = "more_float_constants", issue = "103883")]
+    // Also, #[unstable(feature = "more_float_constants", issue = "146939")]
     pub const EGAMMA: f128 = 0.577215664901532860606512090082402431042159335939923598805767_f128;
 
     /// π/2
@@ -67,14 +67,14 @@ pub mod consts {
 
     /// 1/sqrt(π)
     #[unstable(feature = "f128", issue = "116909")]
-    // Also, #[unstable(feature = "more_float_constants", issue = "103883")]
+    // Also, #[unstable(feature = "more_float_constants", issue = "146939")]
     pub const FRAC_1_SQRT_PI: f128 =
         0.564189583547756286948079451560772585844050629328998856844086_f128;
 
     /// 1/sqrt(2π)
     #[doc(alias = "FRAC_1_SQRT_TAU")]
     #[unstable(feature = "f128", issue = "116909")]
-    // Also, #[unstable(feature = "more_float_constants", issue = "103883")]
+    // Also, #[unstable(feature = "more_float_constants", issue = "146939")]
     pub const FRAC_1_SQRT_2PI: f128 =
         0.398942280401432677939946059934381868475858631164934657665926_f128;
 
@@ -98,12 +98,12 @@ pub mod consts {
 
     /// sqrt(3)
     #[unstable(feature = "f128", issue = "116909")]
-    // Also, #[unstable(feature = "more_float_constants", issue = "103883")]
+    // Also, #[unstable(feature = "more_float_constants", issue = "146939")]
     pub const SQRT_3: f128 = 1.73205080756887729352744634150587236694280525381038062805581_f128;
 
     /// 1/sqrt(3)
     #[unstable(feature = "f128", issue = "116909")]
-    // Also, #[unstable(feature = "more_float_constants", issue = "103883")]
+    // Also, #[unstable(feature = "more_float_constants", issue = "146939")]
     pub const FRAC_1_SQRT_3: f128 =
         0.577350269189625764509148780501957455647601751270126876018602_f128;
 
diff --git a/library/core/src/num/f16.rs b/library/core/src/num/f16.rs
index a9dbade0e6599..0bea6bc8801d8 100644
--- a/library/core/src/num/f16.rs
+++ b/library/core/src/num/f16.rs
@@ -35,12 +35,12 @@ pub mod consts {
 
     /// The golden ratio (φ)
     #[unstable(feature = "f16", issue = "116909")]
-    // Also, #[unstable(feature = "more_float_constants", issue = "103883")]
+    // Also, #[unstable(feature = "more_float_constants", issue = "146939")]
     pub const PHI: f16 = 1.618033988749894848204586834365638118_f16;
 
     /// The Euler-Mascheroni constant (γ)
     #[unstable(feature = "f16", issue = "116909")]
-    // Also, #[unstable(feature = "more_float_constants", issue = "103883")]
+    // Also, #[unstable(feature = "more_float_constants", issue = "146939")]
     pub const EGAMMA: f16 = 0.577215664901532860606512090082402431_f16;
 
     /// π/2
@@ -69,13 +69,13 @@ pub mod consts {
 
     /// 1/sqrt(π)
     #[unstable(feature = "f16", issue = "116909")]
-    // Also, #[unstable(feature = "more_float_constants", issue = "103883")]
+    // Also, #[unstable(feature = "more_float_constants", issue = "146939")]
     pub const FRAC_1_SQRT_PI: f16 = 0.564189583547756286948079451560772586_f16;
 
     /// 1/sqrt(2π)
     #[doc(alias = "FRAC_1_SQRT_TAU")]
     #[unstable(feature = "f16", issue = "116909")]
-    // Also, #[unstable(feature = "more_float_constants", issue = "103883")]
+    // Also, #[unstable(feature = "more_float_constants", issue = "146939")]
     pub const FRAC_1_SQRT_2PI: f16 = 0.398942280401432677939946059934381868_f16;
 
     /// 2/π
@@ -96,12 +96,12 @@ pub mod consts {
 
     /// sqrt(3)
     #[unstable(feature = "f16", issue = "116909")]
-    // Also, #[unstable(feature = "more_float_constants", issue = "103883")]
+    // Also, #[unstable(feature = "more_float_constants", issue = "146939")]
     pub const SQRT_3: f16 = 1.732050807568877293527446341505872367_f16;
 
     /// 1/sqrt(3)
     #[unstable(feature = "f16", issue = "116909")]
-    // Also, #[unstable(feature = "more_float_constants", issue = "103883")]
+    // Also, #[unstable(feature = "more_float_constants", issue = "146939")]
     pub const FRAC_1_SQRT_3: f16 = 0.577350269189625764509148780501957456_f16;
 
     /// Euler's number (e)
diff --git a/library/core/src/num/f32.rs b/library/core/src/num/f32.rs
index 53474cd3e9058..e380cc698f574 100644
--- a/library/core/src/num/f32.rs
+++ b/library/core/src/num/f32.rs
@@ -291,11 +291,11 @@ pub mod consts {
     pub const TAU: f32 = 6.28318530717958647692528676655900577_f32;
 
     /// The golden ratio (φ)
-    #[unstable(feature = "more_float_constants", issue = "103883")]
+    #[unstable(feature = "more_float_constants", issue = "146939")]
     pub const PHI: f32 = 1.618033988749894848204586834365638118_f32;
 
     /// The Euler-Mascheroni constant (γ)
-    #[unstable(feature = "more_float_constants", issue = "103883")]
+    #[unstable(feature = "more_float_constants", issue = "146939")]
     pub const EGAMMA: f32 = 0.577215664901532860606512090082402431_f32;
 
     /// π/2
@@ -323,12 +323,12 @@ pub mod consts {
     pub const FRAC_1_PI: f32 = 0.318309886183790671537767526745028724_f32;
 
     /// 1/sqrt(π)
-    #[unstable(feature = "more_float_constants", issue = "103883")]
+    #[unstable(feature = "more_float_constants", issue = "146939")]
     pub const FRAC_1_SQRT_PI: f32 = 0.564189583547756286948079451560772586_f32;
 
     /// 1/sqrt(2π)
     #[doc(alias = "FRAC_1_SQRT_TAU")]
-    #[unstable(feature = "more_float_constants", issue = "103883")]
+    #[unstable(feature = "more_float_constants", issue = "146939")]
     pub const FRAC_1_SQRT_2PI: f32 = 0.398942280401432677939946059934381868_f32;
 
     /// 2/π
@@ -348,11 +348,11 @@ pub mod consts {
     pub const FRAC_1_SQRT_2: f32 = 0.707106781186547524400844362104849039_f32;
 
     /// sqrt(3)
-    #[unstable(feature = "more_float_constants", issue = "103883")]
+    #[unstable(feature = "more_float_constants", issue = "146939")]
     pub const SQRT_3: f32 = 1.732050807568877293527446341505872367_f32;
 
     /// 1/sqrt(3)
-    #[unstable(feature = "more_float_constants", issue = "103883")]
+    #[unstable(feature = "more_float_constants", issue = "146939")]
     pub const FRAC_1_SQRT_3: f32 = 0.577350269189625764509148780501957456_f32;
 
     /// Euler's number (e)
diff --git a/library/core/src/num/f64.rs b/library/core/src/num/f64.rs
index 78113a60bbc28..ff7449fd996ce 100644
--- a/library/core/src/num/f64.rs
+++ b/library/core/src/num/f64.rs
@@ -291,11 +291,11 @@ pub mod consts {
     pub const TAU: f64 = 6.28318530717958647692528676655900577_f64;
 
     /// The golden ratio (φ)
-    #[unstable(feature = "more_float_constants", issue = "103883")]
+    #[unstable(feature = "more_float_constants", issue = "146939")]
     pub const PHI: f64 = 1.618033988749894848204586834365638118_f64;
 
     /// The Euler-Mascheroni constant (γ)
-    #[unstable(feature = "more_float_constants", issue = "103883")]
+    #[unstable(feature = "more_float_constants", issue = "146939")]
     pub const EGAMMA: f64 = 0.577215664901532860606512090082402431_f64;
 
     /// π/2
@@ -323,12 +323,12 @@ pub mod consts {
     pub const FRAC_1_PI: f64 = 0.318309886183790671537767526745028724_f64;
 
     /// 1/sqrt(π)
-    #[unstable(feature = "more_float_constants", issue = "103883")]
+    #[unstable(feature = "more_float_constants", issue = "146939")]
     pub const FRAC_1_SQRT_PI: f64 = 0.564189583547756286948079451560772586_f64;
 
     /// 1/sqrt(2π)
     #[doc(alias = "FRAC_1_SQRT_TAU")]
-    #[unstable(feature = "more_float_constants", issue = "103883")]
+    #[unstable(feature = "more_float_constants", issue = "146939")]
     pub const FRAC_1_SQRT_2PI: f64 = 0.398942280401432677939946059934381868_f64;
 
     /// 2/π
@@ -348,11 +348,11 @@ pub mod consts {
     pub const FRAC_1_SQRT_2: f64 = 0.707106781186547524400844362104849039_f64;
 
     /// sqrt(3)
-    #[unstable(feature = "more_float_constants", issue = "103883")]
+    #[unstable(feature = "more_float_constants", issue = "146939")]
     pub const SQRT_3: f64 = 1.732050807568877293527446341505872367_f64;
 
     /// 1/sqrt(3)
-    #[unstable(feature = "more_float_constants", issue = "103883")]
+    #[unstable(feature = "more_float_constants", issue = "146939")]
     pub const FRAC_1_SQRT_3: f64 = 0.577350269189625764509148780501957456_f64;
 
     /// Euler's number (e)

From c0de794949f652b368fa107c3b52d0515f1f3859 Mon Sep 17 00:00:00 2001
From: David Carlier <devnexen@gmail.com>
Date: Tue, 29 Apr 2025 19:01:08 +0100
Subject: [PATCH 1441/1889] std::net: update tcp deferaccept delay type to
 Duration.

---
 library/std/src/os/net/linux_ext/tcp.rs       | 23 +++++++++++--------
 library/std/src/os/net/linux_ext/tests.rs     | 11 +++++----
 .../std/src/sys/net/connection/socket/unix.rs |  9 ++++----
 3 files changed, 26 insertions(+), 17 deletions(-)

diff --git a/library/std/src/os/net/linux_ext/tcp.rs b/library/std/src/os/net/linux_ext/tcp.rs
index fde53ec4257bd..dbefc91a979a5 100644
--- a/library/std/src/os/net/linux_ext/tcp.rs
+++ b/library/std/src/os/net/linux_ext/tcp.rs
@@ -4,6 +4,7 @@
 
 use crate::sealed::Sealed;
 use crate::sys_common::AsInner;
+use crate::time::Duration;
 use crate::{io, net};
 
 /// Os-specific extensions for [`TcpStream`]
@@ -59,11 +60,13 @@ pub trait TcpStreamExt: Sealed {
 
     /// A socket listener will be awakened solely when data arrives.
     ///
-    /// The `accept` argument set the delay in seconds until the
+    /// The `accept` argument set the maximum delay until the
     /// data is available to read, reducing the number of short lived
     /// connections without data to process.
     /// Contrary to other platforms `SO_ACCEPTFILTER` feature equivalent, there is
     /// no necessity to set it after the `listen` call.
+    /// Note that the delay is expressed as Duration from user's perspective
+    /// the call rounds it down to the nearest second expressible as a `c_int`.
     ///
     /// See [`man 7 tcp`](https://man7.org/linux/man-pages/man7/tcp.7.html)
     ///
@@ -73,16 +76,17 @@ pub trait TcpStreamExt: Sealed {
     /// #![feature(tcp_deferaccept)]
     /// use std::net::TcpStream;
     /// use std::os::linux::net::TcpStreamExt;
+    /// use std::time::Duration;
     ///
     /// let stream = TcpStream::connect("127.0.0.1:8080")
     ///         .expect("Couldn't connect to the server...");
-    /// stream.set_deferaccept(1).expect("set_deferaccept call failed");
+    /// stream.set_deferaccept(Duration::from_secs(1u64)).expect("set_deferaccept call failed");
     /// ```
     #[unstable(feature = "tcp_deferaccept", issue = "119639")]
     #[cfg(target_os = "linux")]
-    fn set_deferaccept(&self, accept: u32) -> io::Result<()>;
+    fn set_deferaccept(&self, accept: Duration) -> io::Result<()>;
 
-    /// Gets the accept delay value (in seconds) of the `TCP_DEFER_ACCEPT` option.
+    /// Gets the accept delay value of the `TCP_DEFER_ACCEPT` option.
     ///
     /// For more information about this option, see [`TcpStreamExt::set_deferaccept`].
     ///
@@ -92,15 +96,16 @@ pub trait TcpStreamExt: Sealed {
     /// #![feature(tcp_deferaccept)]
     /// use std::net::TcpStream;
     /// use std::os::linux::net::TcpStreamExt;
+    /// use std::time::Duration;
     ///
     /// let stream = TcpStream::connect("127.0.0.1:8080")
     ///         .expect("Couldn't connect to the server...");
-    /// stream.set_deferaccept(1).expect("set_deferaccept call failed");
-    /// assert_eq!(stream.deferaccept().unwrap_or(0), 1);
+    /// stream.set_deferaccept(Duration::from_secs(1u64)).expect("set_deferaccept call failed");
+    /// assert_eq!(stream.deferaccept().unwrap(), Duration::from_secs(1u64));
     /// ```
     #[unstable(feature = "tcp_deferaccept", issue = "119639")]
     #[cfg(target_os = "linux")]
-    fn deferaccept(&self) -> io::Result<u32>;
+    fn deferaccept(&self) -> io::Result<Duration>;
 }
 
 #[stable(feature = "tcp_quickack", since = "1.89.0")]
@@ -117,12 +122,12 @@ impl TcpStreamExt for net::TcpStream {
     }
 
     #[cfg(target_os = "linux")]
-    fn set_deferaccept(&self, accept: u32) -> io::Result<()> {
+    fn set_deferaccept(&self, accept: Duration) -> io::Result<()> {
         self.as_inner().as_inner().set_deferaccept(accept)
     }
 
     #[cfg(target_os = "linux")]
-    fn deferaccept(&self) -> io::Result<u32> {
+    fn deferaccept(&self) -> io::Result<Duration> {
         self.as_inner().as_inner().deferaccept()
     }
 }
diff --git a/library/std/src/os/net/linux_ext/tests.rs b/library/std/src/os/net/linux_ext/tests.rs
index 12f35696abc5c..0758b426ccc59 100644
--- a/library/std/src/os/net/linux_ext/tests.rs
+++ b/library/std/src/os/net/linux_ext/tests.rs
@@ -32,6 +32,7 @@ fn deferaccept() {
     use crate::net::test::next_test_ip4;
     use crate::net::{TcpListener, TcpStream};
     use crate::os::net::linux_ext::tcp::TcpStreamExt;
+    use crate::time::Duration;
 
     macro_rules! t {
         ($e:expr) => {
@@ -43,10 +44,12 @@ fn deferaccept() {
     }
 
     let addr = next_test_ip4();
+    let one = Duration::from_secs(1u64);
+    let zero = Duration::from_secs(0u64);
     let _listener = t!(TcpListener::bind(&addr));
     let stream = t!(TcpStream::connect(&("localhost", addr.port())));
-    stream.set_deferaccept(1).expect("set_deferaccept failed");
-    assert_eq!(stream.deferaccept().unwrap(), 1);
-    stream.set_deferaccept(0).expect("set_deferaccept failed");
-    assert_eq!(stream.deferaccept().unwrap(), 0);
+    stream.set_deferaccept(one).expect("set_deferaccept failed");
+    assert_eq!(stream.deferaccept().unwrap(), one);
+    stream.set_deferaccept(zero).expect("set_deferaccept failed");
+    assert_eq!(stream.deferaccept().unwrap(), zero);
 }
diff --git a/library/std/src/sys/net/connection/socket/unix.rs b/library/std/src/sys/net/connection/socket/unix.rs
index 8b5970d1494e5..86b966242bf38 100644
--- a/library/std/src/sys/net/connection/socket/unix.rs
+++ b/library/std/src/sys/net/connection/socket/unix.rs
@@ -485,14 +485,15 @@ impl Socket {
 
     // bionic libc makes no use of this flag
     #[cfg(target_os = "linux")]
-    pub fn set_deferaccept(&self, accept: u32) -> io::Result<()> {
-        setsockopt(self, libc::IPPROTO_TCP, libc::TCP_DEFER_ACCEPT, accept as c_int)
+    pub fn set_deferaccept(&self, accept: Duration) -> io::Result<()> {
+        let val = cmp::min(accept.as_secs(), c_int::MAX as u64) as c_int;
+        setsockopt(self, libc::IPPROTO_TCP, libc::TCP_DEFER_ACCEPT, val)
     }
 
     #[cfg(target_os = "linux")]
-    pub fn deferaccept(&self) -> io::Result<u32> {
+    pub fn deferaccept(&self) -> io::Result<Duration> {
         let raw: c_int = getsockopt(self, libc::IPPROTO_TCP, libc::TCP_DEFER_ACCEPT)?;
-        Ok(raw as u32)
+        Ok(Duration::from_secs(raw as _))
     }
 
     #[cfg(any(target_os = "freebsd", target_os = "netbsd"))]

From a4e87e940620bc0e61caa7c42b1edc53c0aee7cb Mon Sep 17 00:00:00 2001
From: Jules Bertholet <julesbertholet@quoi.xyz>
Date: Wed, 10 Sep 2025 17:11:47 -0400
Subject: [PATCH 1442/1889] Support `#[rustc_align_static]` inside
 `thread_local!`

---
 library/std/src/sys/thread_local/mod.rs       |   2 +-
 .../std/src/sys/thread_local/native/eager.rs  |   4 +-
 .../std/src/sys/thread_local/native/lazy.rs   |   4 +-
 .../std/src/sys/thread_local/native/mod.rs    |  12 +-
 .../std/src/sys/thread_local/no_threads.rs    |  70 +++--
 library/std/src/sys/thread_local/os.rs        | 127 +++++++--
 library/std/src/thread/local.rs               | 229 +++++++++++++--
 library/std/src/thread/mod.rs                 |   1 +
 library/std/tests/thread.rs                   |   2 +
 src/tools/miri/tests/pass/static_align.rs     |  60 ++++
 .../feature-gate-static_align-thread_local.rs |  11 +
 tests/ui/static/static-align.rs               |  84 +++++-
 tests/ui/thread-local/long-docs.rs            | 266 ++++++++++++++++++
 tests/ui/thread-local/no-unstable.rs          |  17 ++
 tests/ui/thread-local/no-unstable.stderr      |  57 ++++
 15 files changed, 872 insertions(+), 74 deletions(-)
 create mode 100644 tests/ui/feature-gates/feature-gate-static_align-thread_local.rs
 create mode 100644 tests/ui/thread-local/long-docs.rs
 create mode 100644 tests/ui/thread-local/no-unstable.rs
 create mode 100644 tests/ui/thread-local/no-unstable.stderr

diff --git a/library/std/src/sys/thread_local/mod.rs b/library/std/src/sys/thread_local/mod.rs
index cff74857c4733..970022233cfaf 100644
--- a/library/std/src/sys/thread_local/mod.rs
+++ b/library/std/src/sys/thread_local/mod.rs
@@ -41,7 +41,7 @@ cfg_select! {
     }
     _ => {
         mod os;
-        pub use os::{Storage, thread_local_inner};
+        pub use os::{Storage, thread_local_inner, value_align};
         pub(crate) use os::{LocalPointer, local_pointer};
     }
 }
diff --git a/library/std/src/sys/thread_local/native/eager.rs b/library/std/src/sys/thread_local/native/eager.rs
index fd48c4f720216..23abad645c1a3 100644
--- a/library/std/src/sys/thread_local/native/eager.rs
+++ b/library/std/src/sys/thread_local/native/eager.rs
@@ -10,9 +10,11 @@ enum State {
 }
 
 #[allow(missing_debug_implementations)]
+#[repr(C)]
 pub struct Storage<T> {
-    state: Cell<State>,
+    // This field must be first, for correctness of `#[rustc_align_static]`
     val: UnsafeCell<T>,
+    state: Cell<State>,
 }
 
 impl<T> Storage<T> {
diff --git a/library/std/src/sys/thread_local/native/lazy.rs b/library/std/src/sys/thread_local/native/lazy.rs
index b556dd9aa25ed..02939a74fc089 100644
--- a/library/std/src/sys/thread_local/native/lazy.rs
+++ b/library/std/src/sys/thread_local/native/lazy.rs
@@ -27,9 +27,11 @@ enum State<D> {
 }
 
 #[allow(missing_debug_implementations)]
+#[repr(C)]
 pub struct Storage<T, D> {
-    state: Cell<State<D>>,
+    // This field must be first, for correctness of `#[rustc_align_static]`
     value: UnsafeCell<MaybeUninit<T>>,
+    state: Cell<State<D>>,
 }
 
 impl<T, D> Storage<T, D>
diff --git a/library/std/src/sys/thread_local/native/mod.rs b/library/std/src/sys/thread_local/native/mod.rs
index a5dffe3c45883..9544721b923b8 100644
--- a/library/std/src/sys/thread_local/native/mod.rs
+++ b/library/std/src/sys/thread_local/native/mod.rs
@@ -54,7 +54,7 @@ pub macro thread_local_inner {
     // test in `tests/thread.rs` if these types are renamed.
 
     // Used to generate the `LocalKey` value for const-initialized thread locals.
-    (@key $t:ty, const $init:expr) => {{
+    (@key $t:ty, $(#[$align_attr:meta])*, const $init:expr) => {{
         const __INIT: $t = $init;
 
         unsafe {
@@ -62,6 +62,7 @@ pub macro thread_local_inner {
                 if $crate::mem::needs_drop::<$t>() {
                     |_| {
                         #[thread_local]
+                        $(#[$align_attr])*
                         static VAL: $crate::thread::local_impl::EagerStorage<$t>
                             = $crate::thread::local_impl::EagerStorage::new(__INIT);
                         VAL.get()
@@ -69,6 +70,7 @@ pub macro thread_local_inner {
                 } else {
                     |_| {
                         #[thread_local]
+                        $(#[$align_attr])*
                         static VAL: $t = __INIT;
                         &VAL
                     }
@@ -78,7 +80,7 @@ pub macro thread_local_inner {
     }},
 
     // used to generate the `LocalKey` value for `thread_local!`
-    (@key $t:ty, $init:expr) => {{
+    (@key $t:ty, $(#[$align_attr:meta])*, $init:expr) => {{
         #[inline]
         fn __init() -> $t {
             $init
@@ -89,6 +91,7 @@ pub macro thread_local_inner {
                 if $crate::mem::needs_drop::<$t>() {
                     |init| {
                         #[thread_local]
+                        $(#[$align_attr])*
                         static VAL: $crate::thread::local_impl::LazyStorage<$t, ()>
                             = $crate::thread::local_impl::LazyStorage::new();
                         VAL.get_or_init(init, __init)
@@ -96,6 +99,7 @@ pub macro thread_local_inner {
                 } else {
                     |init| {
                         #[thread_local]
+                        $(#[$align_attr])*
                         static VAL: $crate::thread::local_impl::LazyStorage<$t, !>
                             = $crate::thread::local_impl::LazyStorage::new();
                         VAL.get_or_init(init, __init)
@@ -104,9 +108,9 @@ pub macro thread_local_inner {
             })
         }
     }},
-    ($(#[$attr:meta])* $vis:vis $name:ident, $t:ty, $($init:tt)*) => {
+    ($(#[$attr:meta])* $vis:vis $name:ident, $t:ty, $(#[$align_attr:meta])*, $($init:tt)*) => {
         $(#[$attr])* $vis const $name: $crate::thread::LocalKey<$t> =
-            $crate::thread::local_impl::thread_local_inner!(@key $t, $($init)*);
+            $crate::thread::local_impl::thread_local_inner!(@key $t, $(#[$align_attr])*, $($init)*);
     },
 }
 
diff --git a/library/std/src/sys/thread_local/no_threads.rs b/library/std/src/sys/thread_local/no_threads.rs
index 4da01a84acf68..4d6a4464cfa8c 100644
--- a/library/std/src/sys/thread_local/no_threads.rs
+++ b/library/std/src/sys/thread_local/no_threads.rs
@@ -2,6 +2,7 @@
 //! thread locals and we can instead just use plain statics!
 
 use crate::cell::{Cell, UnsafeCell};
+use crate::mem::MaybeUninit;
 use crate::ptr;
 
 #[doc(hidden)]
@@ -11,12 +12,13 @@ use crate::ptr;
 #[rustc_macro_transparency = "semitransparent"]
 pub macro thread_local_inner {
     // used to generate the `LocalKey` value for const-initialized thread locals
-    (@key $t:ty, const $init:expr) => {{
+    (@key $t:ty, $(#[$align_attr:meta])*, const $init:expr) => {{
         const __INIT: $t = $init;
 
         // NOTE: Please update the shadowing test in `tests/thread.rs` if these types are renamed.
         unsafe {
             $crate::thread::LocalKey::new(|_| {
+                $(#[$align_attr])*
                 static VAL: $crate::thread::local_impl::EagerStorage<$t> =
                     $crate::thread::local_impl::EagerStorage { value: __INIT };
                 &VAL.value
@@ -25,27 +27,27 @@ pub macro thread_local_inner {
     }},
 
     // used to generate the `LocalKey` value for `thread_local!`
-    (@key $t:ty, $init:expr) => {{
+    (@key $t:ty, $(#[$align_attr:meta])*, $init:expr) => {{
         #[inline]
         fn __init() -> $t { $init }
 
         unsafe {
-            use $crate::thread::LocalKey;
-            use $crate::thread::local_impl::LazyStorage;
-
-            LocalKey::new(|init| {
-                static VAL: LazyStorage<$t> = LazyStorage::new();
+            $crate::thread::LocalKey::new(|init| {
+                $(#[$align_attr])*
+                static VAL: $crate::thread::local_impl::LazyStorage<$t> = $crate::thread::local_impl::LazyStorage::new();
                 VAL.get(init, __init)
             })
         }
     }},
-    ($(#[$attr:meta])* $vis:vis $name:ident, $t:ty, $($init:tt)*) => {
+
+    ($(#[$attr:meta])* $vis:vis $name:ident, $t:ty, $(#[$align_attr:meta])*, $($init:tt)*) => {
         $(#[$attr])* $vis const $name: $crate::thread::LocalKey<$t> =
-            $crate::thread::local_impl::thread_local_inner!(@key $t, $($init)*);
+            $crate::thread::local_impl::thread_local_inner!(@key $t, $(#[$align_attr])*, $($init)*);
     },
 }
 
 #[allow(missing_debug_implementations)]
+#[repr(transparent)] // Required for correctness of `#[rustc_align_static]`
 pub struct EagerStorage<T> {
     pub value: T,
 }
@@ -53,14 +55,27 @@ pub struct EagerStorage<T> {
 // SAFETY: the target doesn't have threads.
 unsafe impl<T> Sync for EagerStorage<T> {}
 
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum State {
+    Initial,
+    Alive,
+    Destroying,
+}
+
 #[allow(missing_debug_implementations)]
+#[repr(C)]
 pub struct LazyStorage<T> {
-    value: UnsafeCell<Option<T>>,
+    // This field must be first, for correctness of `#[rustc_align_static]`
+    value: UnsafeCell<MaybeUninit<T>>,
+    state: Cell<State>,
 }
 
 impl<T> LazyStorage<T> {
     pub const fn new() -> LazyStorage<T> {
-        LazyStorage { value: UnsafeCell::new(None) }
+        LazyStorage {
+            value: UnsafeCell::new(MaybeUninit::uninit()),
+            state: Cell::new(State::Initial),
+        }
     }
 
     /// Gets a pointer to the TLS value, potentially initializing it with the
@@ -70,24 +85,39 @@ impl<T> LazyStorage<T> {
     /// has occurred.
     #[inline]
     pub fn get(&'static self, i: Option<&mut Option<T>>, f: impl FnOnce() -> T) -> *const T {
-        let value = unsafe { &*self.value.get() };
-        match value {
-            Some(v) => v,
-            None => self.initialize(i, f),
+        if self.state.get() == State::Alive {
+            self.value.get() as *const T
+        } else {
+            self.initialize(i, f)
         }
     }
 
     #[cold]
     fn initialize(&'static self, i: Option<&mut Option<T>>, f: impl FnOnce() -> T) -> *const T {
         let value = i.and_then(Option::take).unwrap_or_else(f);
-        // Destroy the old value, after updating the TLS variable as the
-        // destructor might reference it.
+
+        // Destroy the old value if it is initialized
         // FIXME(#110897): maybe panic on recursive initialization.
+        if self.state.get() == State::Alive {
+            self.state.set(State::Destroying);
+            // Safety: we check for no initialization during drop below
+            unsafe {
+                ptr::drop_in_place(self.value.get() as *mut T);
+            }
+            self.state.set(State::Initial);
+        }
+
+        // Guard against initialization during drop
+        if self.state.get() == State::Destroying {
+            panic!("Attempted to initialize thread-local while it is being dropped");
+        }
+
         unsafe {
-            self.value.get().replace(Some(value));
+            self.value.get().write(MaybeUninit::new(value));
         }
-        // SAFETY: we just set this to `Some`.
-        unsafe { (*self.value.get()).as_ref().unwrap_unchecked() }
+        self.state.set(State::Alive);
+
+        self.value.get() as *const T
     }
 }
 
diff --git a/library/std/src/sys/thread_local/os.rs b/library/std/src/sys/thread_local/os.rs
index fe6af27db3a17..77746b203a321 100644
--- a/library/std/src/sys/thread_local/os.rs
+++ b/library/std/src/sys/thread_local/os.rs
@@ -1,5 +1,6 @@
 use super::key::{Key, LazyKey, get, set};
 use super::{abort_on_dtor_unwind, guard};
+use crate::alloc::Layout;
 use crate::cell::Cell;
 use crate::marker::PhantomData;
 use crate::ptr;
@@ -10,17 +11,12 @@ use crate::ptr;
 #[unstable(feature = "thread_local_internals", issue = "none")]
 #[rustc_macro_transparency = "semitransparent"]
 pub macro thread_local_inner {
-    // used to generate the `LocalKey` value for const-initialized thread locals
-    (@key $t:ty, const $init:expr) => {
-        $crate::thread::local_impl::thread_local_inner!(@key $t, { const INIT_EXPR: $t = $init; INIT_EXPR })
-    },
-
     // NOTE: we cannot import `Storage` or `LocalKey` with a `use` because that can shadow user
     // provided type or type alias with a matching name. Please update the shadowing test in
     // `tests/thread.rs` if these types are renamed.
 
     // used to generate the `LocalKey` value for `thread_local!`.
-    (@key $t:ty, $init:expr) => {{
+    (@key $t:ty, $($(#[$($align_attr:tt)*])+)?, $init:expr) => {{
         #[inline]
         fn __init() -> $t { $init }
 
@@ -29,37 +25,99 @@ pub macro thread_local_inner {
         // in `tests/thread.rs` if these types are renamed.
         unsafe {
             $crate::thread::LocalKey::new(|init| {
-                static VAL: $crate::thread::local_impl::Storage<$t>
+                static VAL: $crate::thread::local_impl::Storage<$t, {
+                    $({
+                        // Ensure that attributes have valid syntax
+                        // and that the proper feature gate is enabled
+                        $(#[$($align_attr)*])+
+                        #[allow(unused)]
+                        static DUMMY: () = ();
+                    })?
+
+                    #[allow(unused_mut)]
+                    let mut final_align = $crate::thread::local_impl::value_align::<$t>();
+                    $($($crate::thread::local_impl::thread_local_inner!(@align final_align, $($align_attr)*);)+)?
+                    final_align
+                }>
                     = $crate::thread::local_impl::Storage::new();
                 VAL.get(init, __init)
             })
         }
     }},
-    ($(#[$attr:meta])* $vis:vis $name:ident, $t:ty, $($init:tt)*) => {
+
+    // process a single `rustc_align_static` attribute
+    (@align $final_align:ident, rustc_align_static($($align:tt)*) $(, $($attr_rest:tt)+)?) => {
+        let new_align: $crate::primitive::usize = $($align)*;
+        if new_align > $final_align {
+            $final_align = new_align;
+        }
+
+        $($crate::thread::local_impl::thread_local_inner!(@align $final_align, $($attr_rest)+);)?
+    },
+
+    // process a single `cfg_attr` attribute
+    // by translating it into a `cfg`ed block and recursing.
+    // https://doc.rust-lang.org/reference/conditional-compilation.html#railroad-ConfigurationPredicate
+
+    (@align $final_align:ident, cfg_attr(true, $($cfg_rhs:tt)*) $(, $($attr_rest:tt)+)?) => {
+        #[cfg(true)]
+        {
+            $crate::thread::local_impl::thread_local_inner!(@align $final_align, $($cfg_rhs)*);
+        }
+
+        $($crate::thread::local_impl::thread_local_inner!(@align $final_align, $($attr_rest)+);)?
+    },
+
+    (@align $final_align:ident, cfg_attr(false, $($cfg_rhs:tt)*) $(, $($attr_rest:tt)+)?) => {
+        #[cfg(false)]
+        {
+            $crate::thread::local_impl::thread_local_inner!(@align $final_align, $($cfg_rhs)*);
+        }
+
+        $($crate::thread::local_impl::thread_local_inner!(@align $final_align, $($attr_rest)+);)?
+    },
+
+    (@align $final_align:ident, cfg_attr($cfg_pred:meta, $($cfg_rhs:tt)*) $(, $($attr_rest:tt)+)?) => {
+        #[cfg($cfg_pred)]
+        {
+            $crate::thread::local_impl::thread_local_inner!(@align $final_align, $($cfg_rhs)*);
+        }
+
+        $($crate::thread::local_impl::thread_local_inner!(@align $final_align, $($attr_rest)+);)?
+    },
+
+    ($(#[$attr:meta])* $vis:vis $name:ident, $t:ty, $(#[$($align_attr:tt)*])*, $($init:tt)*) => {
         $(#[$attr])* $vis const $name: $crate::thread::LocalKey<$t> =
-            $crate::thread::local_impl::thread_local_inner!(@key $t, $($init)*);
+            $crate::thread::local_impl::thread_local_inner!(@key $t, $(#[$($align_attr)*])*, $($init)*);
     },
 }
 
 /// Use a regular global static to store this key; the state provided will then be
 /// thread-local.
+/// INVARIANT: ALIGN must be a valid alignment, and no less than `value_align::<T>`.
 #[allow(missing_debug_implementations)]
-pub struct Storage<T> {
+pub struct Storage<T, const ALIGN: usize> {
     key: LazyKey,
     marker: PhantomData<Cell<T>>,
 }
 
-unsafe impl<T> Sync for Storage<T> {}
+unsafe impl<T, const ALIGN: usize> Sync for Storage<T, ALIGN> {}
 
+#[repr(C)]
 struct Value<T: 'static> {
+    // This field must be first, for correctness of `#[rustc_align_static]`
     value: T,
     // INVARIANT: if this value is stored under a TLS key, `key` must be that `key`.
     key: Key,
 }
 
-impl<T: 'static> Storage<T> {
-    pub const fn new() -> Storage<T> {
-        Storage { key: LazyKey::new(Some(destroy_value::<T>)), marker: PhantomData }
+pub const fn value_align<T: 'static>() -> usize {
+    crate::mem::align_of::<Value<T>>()
+}
+
+impl<T: 'static, const ALIGN: usize> Storage<T, ALIGN> {
+    pub const fn new() -> Storage<T, ALIGN> {
+        Storage { key: LazyKey::new(Some(destroy_value::<T, ALIGN>)), marker: PhantomData }
     }
 
     /// Gets a pointer to the TLS value, potentially initializing it with the
@@ -95,8 +153,15 @@ impl<T: 'static> Storage<T> {
             return ptr::null();
         }
 
-        let value = Box::new(Value { value: i.and_then(Option::take).unwrap_or_else(f), key });
-        let ptr = Box::into_raw(value);
+        // Manually allocate with the requested alignment
+        let layout = Layout::new::<Value<T>>().align_to(ALIGN).unwrap();
+        let ptr: *mut Value<T> = (unsafe { crate::alloc::alloc(layout) }).cast();
+        if ptr.is_null() {
+            crate::alloc::handle_alloc_error(layout);
+        }
+        unsafe {
+            ptr.write(Value { value: i.and_then(Option::take).unwrap_or_else(f), key });
+        }
 
         // SAFETY:
         // * key came from a `LazyKey` and is thus correct.
@@ -114,7 +179,10 @@ impl<T: 'static> Storage<T> {
             // initializer has already returned and the next scope only starts
             // after we return the pointer. Therefore, there can be no references
             // to the old value.
-            drop(unsafe { Box::from_raw(old) });
+            unsafe {
+                old.drop_in_place();
+                crate::alloc::dealloc(old.cast(), layout);
+            }
         }
 
         // SAFETY: We just created this value above.
@@ -122,7 +190,7 @@ impl<T: 'static> Storage<T> {
     }
 }
 
-unsafe extern "C" fn destroy_value<T: 'static>(ptr: *mut u8) {
+unsafe extern "C" fn destroy_value<T: 'static, const ALIGN: usize>(ptr: *mut u8) {
     // SAFETY:
     //
     // The OS TLS ensures that this key contains a null value when this
@@ -133,13 +201,22 @@ unsafe extern "C" fn destroy_value<T: 'static>(ptr: *mut u8) {
     // Note that to prevent an infinite loop we reset it back to null right
     // before we return from the destructor ourselves.
     abort_on_dtor_unwind(|| {
-        let ptr = unsafe { Box::from_raw(ptr as *mut Value<T>) };
-        let key = ptr.key;
-        // SAFETY: `key` is the TLS key `ptr` was stored under.
-        unsafe { set(key, ptr::without_provenance_mut(1)) };
-        drop(ptr);
-        // SAFETY: `key` is the TLS key `ptr` was stored under.
-        unsafe { set(key, ptr::null_mut()) };
+        let value_ptr: *mut Value<T> = ptr.cast();
+        unsafe {
+            let key = (*value_ptr).key;
+
+            // SAFETY: `key` is the TLS key `ptr` was stored under.
+            set(key, ptr::without_provenance_mut(1));
+
+            // drop and deallocate the value
+            let layout =
+                Layout::from_size_align_unchecked(crate::mem::size_of::<Value<T>>(), ALIGN);
+            value_ptr.drop_in_place();
+            crate::alloc::dealloc(ptr, layout);
+
+            // SAFETY: `key` is the TLS key `ptr` was stored under.
+            set(key, ptr::null_mut());
+        };
         // Make sure that the runtime cleanup will be performed
         // after the next round of TLS destruction.
         guard::enable();
diff --git a/library/std/src/thread/local.rs b/library/std/src/thread/local.rs
index 0a6f2e5d5088b..70df7e724cafc 100644
--- a/library/std/src/thread/local.rs
+++ b/library/std/src/thread/local.rs
@@ -132,6 +132,212 @@ impl<T: 'static> fmt::Debug for LocalKey<T> {
     }
 }
 
+#[doc(hidden)]
+#[allow_internal_unstable(thread_local_internals)]
+#[unstable(feature = "thread_local_internals", issue = "none")]
+#[rustc_macro_transparency = "semitransparent"]
+pub macro thread_local_process_attrs {
+
+    // Parse `cfg_attr` to figure out whether it's a `rustc_align_static`.
+    // Each `cfg_attr` can have zero or more attributes on the RHS, and can be nested.
+
+    // finished parsing the `cfg_attr`, it had no `rustc_align_static`
+    (
+        [] [$(#[$($prev_other_attrs:tt)*])*];
+        @processing_cfg_attr { pred: ($($predicate:tt)*), rhs: [] };
+        [$($prev_align_attrs_ret:tt)*] [$($prev_other_attrs_ret:tt)*];
+        $($rest:tt)*
+    ) => (
+        $crate::thread::local_impl::thread_local_process_attrs!(
+            [$($prev_align_attrs_ret)*] [$($prev_other_attrs_ret)* #[cfg_attr($($predicate)*, $($($prev_other_attrs)*),*)]];
+            $($rest)*
+        );
+    ),
+
+    // finished parsing the `cfg_attr`, it had nothing but `rustc_align_static`
+    (
+        [$(#[$($prev_align_attrs:tt)*])+] [];
+        @processing_cfg_attr { pred: ($($predicate:tt)*), rhs: [] };
+        [$($prev_align_attrs_ret:tt)*] [$($prev_other_attrs_ret:tt)*];
+        $($rest:tt)*
+    ) => (
+        $crate::thread::local_impl::thread_local_process_attrs!(
+            [$($prev_align_attrs_ret)*  #[cfg_attr($($predicate)*, $($($prev_align_attrs)*),+)]] [$($prev_other_attrs_ret)*];
+            $($rest)*
+        );
+    ),
+
+    // finished parsing the `cfg_attr`, it had a mix of `rustc_align_static` and other attrs
+    (
+        [$(#[$($prev_align_attrs:tt)*])+] [$(#[$($prev_other_attrs:tt)*])+];
+        @processing_cfg_attr { pred: ($($predicate:tt)*), rhs: [] };
+        [$($prev_align_attrs_ret:tt)*] [$($prev_other_attrs_ret:tt)*];
+        $($rest:tt)*
+    ) => (
+        $crate::thread::local_impl::thread_local_process_attrs!(
+            [$($prev_align_attrs_ret)*  #[cfg_attr($($predicate)*, $($($prev_align_attrs)*),+)]] [$($prev_other_attrs_ret)* #[cfg_attr($($predicate)*, $($($prev_other_attrs)*),+)]];
+            $($rest)*
+        );
+    ),
+
+    // it's a `rustc_align_static`
+    (
+        [$($prev_align_attrs:tt)*] [$($prev_other_attrs:tt)*];
+        @processing_cfg_attr { pred: ($($predicate:tt)*), rhs: [rustc_align_static($($align_static_args:tt)*) $(, $($attr_rhs:tt)*)?] };
+        $($rest:tt)*
+    ) => (
+        $crate::thread::local_impl::thread_local_process_attrs!(
+            [$($prev_align_attrs)* #[rustc_align_static($($align_static_args)*)]] [$($prev_other_attrs)*];
+            @processing_cfg_attr { pred: ($($predicate)*), rhs: [$($($attr_rhs)*)?] };
+            $($rest)*
+        );
+    ),
+
+    // it's a nested `cfg_attr(true, ...)`; recurse into RHS
+    (
+        [$($prev_align_attrs:tt)*] [$($prev_other_attrs:tt)*];
+        @processing_cfg_attr { pred: ($($predicate:tt)*), rhs: [cfg_attr(true, $($cfg_rhs:tt)*) $(, $($attr_rhs:tt)*)?] };
+        $($rest:tt)*
+    ) => (
+        $crate::thread::local_impl::thread_local_process_attrs!(
+            [] [];
+            @processing_cfg_attr { pred: (true), rhs: [$($cfg_rhs)*] };
+            [$($prev_align_attrs)*] [$($prev_other_attrs)*];
+            @processing_cfg_attr { pred: ($($predicate)*), rhs: [$($($attr_rhs)*)?] };
+            $($rest)*
+        );
+    ),
+
+    // it's a nested `cfg_attr(false, ...)`; recurse into RHS
+    (
+        [$($prev_align_attrs:tt)*] [$($prev_other_attrs:tt)*];
+        @processing_cfg_attr { pred: ($($predicate:tt)*), rhs: [cfg_attr(false, $($cfg_rhs:tt)*) $(, $($attr_rhs:tt)*)?] };
+        $($rest:tt)*
+    ) => (
+        $crate::thread::local_impl::thread_local_process_attrs!(
+            [] [];
+            @processing_cfg_attr { pred: (false), rhs: [$($cfg_rhs)*] };
+            [$($prev_align_attrs)*] [$($prev_other_attrs)*];
+            @processing_cfg_attr { pred: ($($predicate)*), rhs: [$($($attr_rhs)*)?] };
+            $($rest)*
+        );
+    ),
+
+
+    // it's a nested `cfg_attr(..., ...)`; recurse into RHS
+    (
+        [$($prev_align_attrs:tt)*] [$($prev_other_attrs:tt)*];
+        @processing_cfg_attr { pred: ($($predicate:tt)*), rhs: [cfg_attr($cfg_lhs:meta, $($cfg_rhs:tt)*) $(, $($attr_rhs:tt)*)?] };
+        $($rest:tt)*
+    ) => (
+        $crate::thread::local_impl::thread_local_process_attrs!(
+            [] [];
+            @processing_cfg_attr { pred: ($cfg_lhs), rhs: [$($cfg_rhs)*] };
+            [$($prev_align_attrs)*] [$($prev_other_attrs)*];
+            @processing_cfg_attr { pred: ($($predicate)*), rhs: [$($($attr_rhs)*)?] };
+            $($rest)*
+        );
+    ),
+
+    // it's some other attribute
+    (
+        [$($prev_align_attrs:tt)*] [$($prev_other_attrs:tt)*];
+        @processing_cfg_attr { pred: ($($predicate:tt)*), rhs: [$meta:meta $(, $($attr_rhs:tt)*)?] };
+        $($rest:tt)*
+    ) => (
+        $crate::thread::local_impl::thread_local_process_attrs!(
+            [$($prev_align_attrs)*] [$($prev_other_attrs)* #[$meta]];
+            @processing_cfg_attr { pred: ($($predicate)*), rhs: [$($($attr_rhs)*)?] };
+            $($rest)*
+        );
+    ),
+
+
+    // Separate attributes into `rustc_align_static` and everything else:
+
+    // `rustc_align_static` attribute
+    ([$($prev_align_attrs:tt)*] [$($prev_other_attrs:tt)*]; #[rustc_align_static $($attr_rest:tt)*] $($rest:tt)*) => (
+        $crate::thread::local_impl::thread_local_process_attrs!(
+            [$($prev_align_attrs)* #[rustc_align_static $($attr_rest)*]] [$($prev_other_attrs)*];
+            $($rest)*
+        );
+    ),
+
+    // `cfg_attr(true, ...)` attribute; parse it
+    ([$($prev_align_attrs:tt)*] [$($prev_other_attrs:tt)*]; #[cfg_attr(true, $($cfg_rhs:tt)*)] $($rest:tt)*) => (
+        $crate::thread::local_impl::thread_local_process_attrs!(
+            [] [];
+            @processing_cfg_attr { pred: (true), rhs: [$($cfg_rhs)*] };
+            [$($prev_align_attrs)*] [$($prev_other_attrs)*];
+            $($rest)*
+        );
+    ),
+
+    // `cfg_attr(false, ...)` attribute; parse it
+    ([$($prev_align_attrs:tt)*] [$($prev_other_attrs:tt)*]; #[cfg_attr(false, $($cfg_rhs:tt)*)] $($rest:tt)*) => (
+        $crate::thread::local_impl::thread_local_process_attrs!(
+            [] [];
+            @processing_cfg_attr { pred: (false), rhs: [$($cfg_rhs)*] };
+            [$($prev_align_attrs)*] [$($prev_other_attrs)*];
+            $($rest)*
+        );
+    ),
+
+    // `cfg_attr(..., ...)` attribute; parse it
+    ([$($prev_align_attrs:tt)*] [$($prev_other_attrs:tt)*]; #[cfg_attr($cfg_pred:meta, $($cfg_rhs:tt)*)] $($rest:tt)*) => (
+        $crate::thread::local_impl::thread_local_process_attrs!(
+            [] [];
+            @processing_cfg_attr { pred: ($cfg_pred), rhs: [$($cfg_rhs)*] };
+            [$($prev_align_attrs)*] [$($prev_other_attrs)*];
+            $($rest)*
+        );
+    ),
+
+    // doc comment not followed by any other attributes; process it all at once to avoid blowing recursion limit
+    ([$($prev_align_attrs:tt)*] [$($prev_other_attrs:tt)*]; $(#[doc $($doc_rhs:tt)*])+ $vis:vis static $($rest:tt)*) => (
+        $crate::thread::local_impl::thread_local_process_attrs!(
+            [$($prev_align_attrs)*] [$($prev_other_attrs)* $(#[doc $($doc_rhs)*])+];
+            $vis static $($rest)*
+        );
+    ),
+
+    // 8 lines of doc comment; process them all at once to avoid blowing recursion limit
+    ([$($prev_align_attrs:tt)*] [$($prev_other_attrs:tt)*];
+     #[doc $($doc_rhs_1:tt)*] #[doc $($doc_rhs_2:tt)*] #[doc $($doc_rhs_3:tt)*] #[doc $($doc_rhs_4:tt)*]
+     #[doc $($doc_rhs_5:tt)*] #[doc $($doc_rhs_6:tt)*] #[doc $($doc_rhs_7:tt)*] #[doc $($doc_rhs_8:tt)*]
+     $($rest:tt)*) => (
+        $crate::thread::local_impl::thread_local_process_attrs!(
+            [$($prev_align_attrs)*] [$($prev_other_attrs)*
+            #[doc $($doc_rhs_1)*] #[doc $($doc_rhs_2)*] #[doc $($doc_rhs_3)*] #[doc $($doc_rhs_4)*]
+            #[doc $($doc_rhs_5)*] #[doc $($doc_rhs_6)*] #[doc $($doc_rhs_7)*] #[doc $($doc_rhs_8)*]];
+            $($rest)*
+        );
+    ),
+
+    // other attribute
+    ([$($prev_align_attrs:tt)*] [$($prev_other_attrs:tt)*]; #[$($attr:tt)*] $($rest:tt)*) => (
+        $crate::thread::local_impl::thread_local_process_attrs!(
+            [$($prev_align_attrs)*] [$($prev_other_attrs)* #[$($attr)*]];
+            $($rest)*
+        );
+    ),
+
+
+    // Delegate to `thread_local_inner` once attributes are fully categorized:
+
+    // process `const` declaration and recurse
+    ([$($align_attrs:tt)*] [$($other_attrs:tt)*]; $vis:vis static $name:ident: $t:ty = const $init:block $(; $($($rest:tt)+)?)?) => (
+        $crate::thread::local_impl::thread_local_inner!($($other_attrs)* $vis $name, $t, $($align_attrs)*, const $init);
+        $($($crate::thread::local_impl::thread_local_process_attrs!([] []; $($rest)+);)?)?
+    ),
+
+    // process non-`const` declaration and recurse
+    ([$($align_attrs:tt)*] [$($other_attrs:tt)*]; $vis:vis static $name:ident: $t:ty = $init:expr $(; $($($rest:tt)+)?)?) => (
+        $crate::thread::local_impl::thread_local_inner!($($other_attrs)* $vis $name, $t, $($align_attrs)*, $init);
+        $($($crate::thread::local_impl::thread_local_process_attrs!([] []; $($rest)+);)?)?
+    ),
+}
+
 /// Declare a new thread local storage key of type [`std::thread::LocalKey`].
 ///
 /// # Syntax
@@ -182,28 +388,11 @@ impl<T: 'static> fmt::Debug for LocalKey<T> {
 #[cfg_attr(not(test), rustc_diagnostic_item = "thread_local_macro")]
 #[allow_internal_unstable(thread_local_internals)]
 macro_rules! thread_local {
-    // empty (base case for the recursion)
     () => {};
 
-    ($(#[$attr:meta])* $vis:vis static $name:ident: $t:ty = const $init:block; $($rest:tt)*) => (
-        $crate::thread::local_impl::thread_local_inner!($(#[$attr])* $vis $name, $t, const $init);
-        $crate::thread_local!($($rest)*);
-    );
-
-    ($(#[$attr:meta])* $vis:vis static $name:ident: $t:ty = const $init:block) => (
-        $crate::thread::local_impl::thread_local_inner!($(#[$attr])* $vis $name, $t, const $init);
-    );
-
-    // process multiple declarations
-    ($(#[$attr:meta])* $vis:vis static $name:ident: $t:ty = $init:expr; $($rest:tt)*) => (
-        $crate::thread::local_impl::thread_local_inner!($(#[$attr])* $vis $name, $t, $init);
-        $crate::thread_local!($($rest)*);
-    );
-
-    // handle a single declaration
-    ($(#[$attr:meta])* $vis:vis static $name:ident: $t:ty = $init:expr) => (
-        $crate::thread::local_impl::thread_local_inner!($(#[$attr])* $vis $name, $t, $init);
-    );
+    ($($tt:tt)+) => {
+        $crate::thread::local_impl::thread_local_process_attrs!([] []; $($tt)+);
+    };
 }
 
 /// An error returned by [`LocalKey::try_with`](struct.LocalKey.html#method.try_with).
diff --git a/library/std/src/thread/mod.rs b/library/std/src/thread/mod.rs
index 4d09b2b4e9d2e..f320c287db32f 100644
--- a/library/std/src/thread/mod.rs
+++ b/library/std/src/thread/mod.rs
@@ -205,6 +205,7 @@ pub use self::local::{AccessError, LocalKey};
 #[doc(hidden)]
 #[unstable(feature = "thread_local_internals", issue = "none")]
 pub mod local_impl {
+    pub use super::local::thread_local_process_attrs;
     pub use crate::sys::thread_local::*;
 }
 
diff --git a/library/std/tests/thread.rs b/library/std/tests/thread.rs
index 29f220d8a70a0..dc8eadd75148b 100644
--- a/library/std/tests/thread.rs
+++ b/library/std/tests/thread.rs
@@ -66,6 +66,8 @@ fn thread_local_hygeiene() {
     type Storage = ();
     type LazyStorage = ();
     type EagerStorage = ();
+    #[allow(non_camel_case_types)]
+    type usize = ();
     thread_local! {
         static A: LocalKey = const { () };
         static B: Storage = const { () };
diff --git a/src/tools/miri/tests/pass/static_align.rs b/src/tools/miri/tests/pass/static_align.rs
index f292f028568b6..bc6a9bf8af7dc 100644
--- a/src/tools/miri/tests/pass/static_align.rs
+++ b/src/tools/miri/tests/pass/static_align.rs
@@ -1,4 +1,7 @@
 #![feature(static_align)]
+#![deny(non_upper_case_globals)]
+
+use std::cell::Cell;
 
 // When a static uses `align(N)`, its address should be a multiple of `N`.
 
@@ -8,7 +11,64 @@ static FOO: u64 = 0;
 #[rustc_align_static(512)]
 static BAR: u64 = 0;
 
+struct HasDrop(*const HasDrop);
+
+impl Drop for HasDrop {
+    fn drop(&mut self) {
+        assert_eq!(core::ptr::from_mut(self).cast_const(), self.0);
+    }
+}
+
+thread_local! {
+    #[rustc_align_static(4096)]
+    static LOCAL: u64 = 0;
+
+    #[allow(unused_mut, reason = "test attribute handling")]
+    #[cfg_attr(true, rustc_align_static(4096))]
+    static CONST_LOCAL: u64 = const { 0 };
+
+    #[cfg_attr(any(true), cfg_attr(true, rustc_align_static(4096)))]
+    #[allow(unused_mut, reason = "test attribute handling")]
+    static HASDROP_LOCAL: Cell<HasDrop> = Cell::new(HasDrop(core::ptr::null()));
+
+    /// I love doc comments.
+    #[allow(unused_mut, reason = "test attribute handling")]
+    #[cfg_attr(all(),
+      cfg_attr(any(true),
+      cfg_attr(true, rustc_align_static(4096))))]
+    #[allow(unused_mut, reason = "test attribute handling")]
+    /// I love doc comments.
+    static HASDROP_CONST_LOCAL: Cell<HasDrop> = const { Cell::new(HasDrop(core::ptr::null())) };
+
+    #[cfg_attr(true,)]
+    #[cfg_attr(false,)]
+    #[cfg_attr(
+        true,
+        rustc_align_static(32),
+        cfg_attr(true, allow(non_upper_case_globals, reason = "test attribute handling")),
+        cfg_attr(false,)
+    )]
+    #[cfg_attr(false, rustc_align_static(0))]
+    static more_attr_testing: u64 = 0;
+}
+
+fn thread_local_ptr<T>(key: &'static std::thread::LocalKey<T>) -> *const T {
+    key.with(|local| core::ptr::from_ref::<T>(local))
+}
+
 fn main() {
     assert!(core::ptr::from_ref(&FOO).addr().is_multiple_of(256));
     assert!(core::ptr::from_ref(&BAR).addr().is_multiple_of(512));
+
+    assert!(thread_local_ptr(&LOCAL).addr().is_multiple_of(4096));
+    assert!(thread_local_ptr(&CONST_LOCAL).addr().is_multiple_of(4096));
+    assert!(thread_local_ptr(&HASDROP_LOCAL).addr().is_multiple_of(4096));
+    assert!(thread_local_ptr(&HASDROP_CONST_LOCAL).addr().is_multiple_of(4096));
+    assert!(thread_local_ptr(&more_attr_testing).addr().is_multiple_of(32));
+
+    // Test that address (and therefore alignment) is maintained during drop
+    let hasdrop_ptr = thread_local_ptr(&HASDROP_LOCAL);
+    core::mem::forget(HASDROP_LOCAL.replace(HasDrop(hasdrop_ptr.cast())));
+    let hasdrop_const_ptr = thread_local_ptr(&HASDROP_CONST_LOCAL);
+    core::mem::forget(HASDROP_CONST_LOCAL.replace(HasDrop(hasdrop_const_ptr.cast())));
 }
diff --git a/tests/ui/feature-gates/feature-gate-static_align-thread_local.rs b/tests/ui/feature-gates/feature-gate-static_align-thread_local.rs
new file mode 100644
index 0000000000000..29d4facffce95
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-static_align-thread_local.rs
@@ -0,0 +1,11 @@
+// The feature gate error may be emitted twice, but only on certain targets
+//@ dont-require-annotations: ERROR
+//@ dont-check-compiler-stderr
+
+#![crate_type = "lib"]
+
+thread_local! {
+    //~^ ERROR the `#[rustc_align_static]` attribute is an experimental feature
+    #[rustc_align_static(16)]
+    static THREAD_LOCAL: u16 = 0;
+}
diff --git a/tests/ui/static/static-align.rs b/tests/ui/static/static-align.rs
index 93241db09f949..e2db7c01adf29 100644
--- a/tests/ui/static/static-align.rs
+++ b/tests/ui/static/static-align.rs
@@ -1,10 +1,14 @@
 //@ run-pass
+//@ compile-flags: --cfg FOURTY_TWO="42" --cfg TRUE --check-cfg=cfg(FOURTY_TWO,values("42")) --check-cfg=cfg(TRUE)
 #![feature(static_align)]
+#![deny(non_upper_case_globals)]
+
+use std::cell::Cell;
 
 #[rustc_align_static(64)]
 static A: u8 = 0;
 
-#[rustc_align_static(64)]
+#[rustc_align_static(4096)]
 static B: u8 = 0;
 
 #[rustc_align_static(128)]
@@ -17,10 +21,86 @@ unsafe extern "C" {
     static C: u64;
 }
 
+struct HasDrop(*const HasDrop);
+
+impl Drop for HasDrop {
+    fn drop(&mut self) {
+        assert_eq!(core::ptr::from_mut(self).cast_const(), self.0);
+    }
+}
+
+thread_local! {
+    #[rustc_align_static(4096)]
+    static LOCAL: u64 = 0;
+
+    #[allow(unused_mut, reason = "test attribute handling")]
+    #[cfg_attr(true, rustc_align_static(4096))]
+    static CONST_LOCAL: u64 = const { 0 };
+
+    #[cfg_attr(any(true), cfg_attr(true, rustc_align_static(4096)))]
+    #[allow(unused_mut, reason = "test attribute handling")]
+    static HASDROP_LOCAL: Cell<HasDrop> = Cell::new(HasDrop(core::ptr::null()));
+
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    #[allow(unused_mut, reason = "test attribute handling")]
+    #[cfg_attr(TRUE,
+      cfg_attr(FOURTY_TWO = "42",
+      cfg_attr(all(),
+      cfg_attr(any(true),
+      cfg_attr(true, rustc_align_static(4096))))))]
+    #[allow(unused_mut, reason = "test attribute handling")]
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    static HASDROP_CONST_LOCAL: Cell<HasDrop> = const { Cell::new(HasDrop(core::ptr::null())) };
+
+    #[cfg_attr(TRUE,)]
+    #[cfg_attr(true,)]
+    #[cfg_attr(false,)]
+    #[cfg_attr(
+        TRUE,
+        rustc_align_static(32),
+        cfg_attr(true, allow(non_upper_case_globals, reason = "test attribute handling")),
+        cfg_attr(false,)
+    )]
+    #[cfg_attr(false, rustc_align_static(0))]
+    static more_attr_testing: u64 = 0;
+}
+
+fn thread_local_ptr<T>(key: &'static std::thread::LocalKey<T>) -> *const T {
+    key.with(|local| core::ptr::from_ref::<T>(local))
+}
+
 fn main() {
     assert!(core::ptr::from_ref(&A).addr().is_multiple_of(64));
-    assert!(core::ptr::from_ref(&B).addr().is_multiple_of(64));
+    assert!(core::ptr::from_ref(&B).addr().is_multiple_of(4096));
 
     assert!(core::ptr::from_ref(&EXPORTED).addr().is_multiple_of(128));
     unsafe { assert!(core::ptr::from_ref(&C).addr().is_multiple_of(128)) };
+
+    assert!(thread_local_ptr(&LOCAL).addr().is_multiple_of(4096));
+    assert!(thread_local_ptr(&CONST_LOCAL).addr().is_multiple_of(4096));
+    assert!(thread_local_ptr(&HASDROP_LOCAL).addr().is_multiple_of(4096));
+    assert!(thread_local_ptr(&HASDROP_CONST_LOCAL).addr().is_multiple_of(4096));
+    assert!(thread_local_ptr(&more_attr_testing).addr().is_multiple_of(32));
+
+    // Test that address (and therefore alignment) is maintained during drop
+    let hasdrop_ptr = thread_local_ptr(&HASDROP_LOCAL);
+    core::mem::forget(HASDROP_LOCAL.replace(HasDrop(hasdrop_ptr.cast())));
+    let hasdrop_const_ptr = thread_local_ptr(&HASDROP_CONST_LOCAL);
+    core::mem::forget(HASDROP_CONST_LOCAL.replace(HasDrop(hasdrop_const_ptr.cast())));
 }
diff --git a/tests/ui/thread-local/long-docs.rs b/tests/ui/thread-local/long-docs.rs
new file mode 100644
index 0000000000000..0577d0b27c285
--- /dev/null
+++ b/tests/ui/thread-local/long-docs.rs
@@ -0,0 +1,266 @@
+//@ check-pass
+
+thread_local! {
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    pub static LONG_DOCS: () = ();
+
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    /// I love doc comments.
+    #[allow(unused_mut, reason = "testing")]
+    pub static LONG_DOCS_2: () = ();
+}
+
+fn main() {}
diff --git a/tests/ui/thread-local/no-unstable.rs b/tests/ui/thread-local/no-unstable.rs
new file mode 100644
index 0000000000000..3de7985e62dbd
--- /dev/null
+++ b/tests/ui/thread-local/no-unstable.rs
@@ -0,0 +1,17 @@
+thread_local! {
+    //~^ ERROR: use of an internal attribute [E0658]
+    //~| ERROR: use of an internal attribute [E0658]
+    //~| ERROR: `#[used(linker)]` is currently unstable [E0658]
+    //~| ERROR: `#[used]` attribute cannot be used on constants
+
+    #[rustc_dummy = 17]
+    pub static FOO: () = ();
+
+    #[cfg_attr(true, rustc_dummy = 17)]
+    pub static BAR: () = ();
+
+    #[used(linker)]
+    pub static BAZ: () = ();
+}
+
+fn main() {}
diff --git a/tests/ui/thread-local/no-unstable.stderr b/tests/ui/thread-local/no-unstable.stderr
new file mode 100644
index 0000000000000..fc2541894e743
--- /dev/null
+++ b/tests/ui/thread-local/no-unstable.stderr
@@ -0,0 +1,57 @@
+error[E0658]: use of an internal attribute
+  --> $DIR/no-unstable.rs:1:1
+   |
+LL | / thread_local! {
+...  |
+LL | |     pub static BAZ: () = ();
+LL | | }
+   | |_^
+   |
+   = help: add `#![feature(rustc_attrs)]` to the crate attributes to enable
+   = note: the `#[rustc_dummy]` attribute is an internal implementation detail that will never be stable
+   = note: the `#[rustc_dummy]` attribute is used for rustc unit tests
+   = note: this error originates in the macro `$crate::thread::local_impl::thread_local_inner` which comes from the expansion of the macro `thread_local` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0658]: use of an internal attribute
+  --> $DIR/no-unstable.rs:1:1
+   |
+LL | / thread_local! {
+...  |
+LL | |     pub static BAZ: () = ();
+LL | | }
+   | |_^
+   |
+   = help: add `#![feature(rustc_attrs)]` to the crate attributes to enable
+   = note: the `#[rustc_dummy]` attribute is an internal implementation detail that will never be stable
+   = note: the `#[rustc_dummy]` attribute is used for rustc unit tests
+   = note: this error originates in the macro `$crate::thread::local_impl::thread_local_process_attrs` which comes from the expansion of the macro `thread_local` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0658]: `#[used(linker)]` is currently unstable
+  --> $DIR/no-unstable.rs:1:1
+   |
+LL | / thread_local! {
+...  |
+LL | |     pub static BAZ: () = ();
+LL | | }
+   | |_^
+   |
+   = note: see issue #93798 <https://github.com/rust-lang/rust/issues/93798> for more information
+   = help: add `#![feature(used_with_arg)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+   = note: this error originates in the macro `$crate::thread::local_impl::thread_local_inner` which comes from the expansion of the macro `thread_local` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: `#[used]` attribute cannot be used on constants
+  --> $DIR/no-unstable.rs:1:1
+   |
+LL | / thread_local! {
+...  |
+LL | |     pub static BAZ: () = ();
+LL | | }
+   | |_^
+   |
+   = help: `#[used]` can only be applied to statics
+   = note: this error originates in the macro `$crate::thread::local_impl::thread_local_inner` which comes from the expansion of the macro `thread_local` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0658`.

From 852aa20c90cca64426516f46c3d89cfd57086ae8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Thu, 25 Sep 2025 22:45:07 +0200
Subject: [PATCH 1443/1889] Rename `rust.use-lld` to
 `rust.bootstrap-override-lld`

---
 bootstrap.example.toml                        |  7 ++-
 src/bootstrap/src/core/build_steps/compile.rs |  4 +-
 src/bootstrap/src/core/config/config.rs       | 20 ++++++--
 src/bootstrap/src/core/config/mod.rs          |  2 +-
 src/bootstrap/src/core/config/tests.rs        | 36 +++++++++++---
 src/bootstrap/src/core/config/toml/rust.rs    | 49 ++++++++++++-------
 src/bootstrap/src/lib.rs                      | 12 ++---
 src/bootstrap/src/utils/change_tracker.rs     |  5 ++
 src/bootstrap/src/utils/helpers.rs            | 28 +++++++----
 .../dist-aarch64-linux/Dockerfile             |  2 +-
 .../host-x86_64/dist-x86_64-linux/Dockerfile  |  2 +-
 11 files changed, 113 insertions(+), 54 deletions(-)

diff --git a/bootstrap.example.toml b/bootstrap.example.toml
index 0cd571134ef15..0a39c6d8f247d 100644
--- a/bootstrap.example.toml
+++ b/bootstrap.example.toml
@@ -768,8 +768,7 @@
 # make this default to false.
 #rust.lld = false in all cases, except on `x86_64-unknown-linux-gnu` as described above, where it is true
 
-# Indicates whether LLD will be used to link Rust crates during bootstrap on
-# supported platforms.
+# Indicates if we should override the linker used to link Rust crates during bootstrap to be LLD.
 # If set to `true` or `"external"`, a global `lld` binary that has to be in $PATH
 # will be used.
 # If set to `"self-contained"`, rust-lld from the snapshot compiler will be used.
@@ -777,7 +776,7 @@
 # On MSVC, LLD will not be used if we're cross linking.
 #
 # Explicitly setting the linker for a target will override this option when targeting MSVC.
-#rust.use-lld = false
+#rust.bootstrap-override-lld = false
 
 # Indicates whether some LLVM tools, like llvm-objdump, will be made available in the
 # sysroot.
@@ -950,7 +949,7 @@
 # Linker to be used to bootstrap Rust code. Note that the
 # default value is platform specific, and if not specified it may also depend on
 # what platform is crossing to what platform.
-# Setting this will override the `use-lld` option for Rust code when targeting MSVC.
+# Setting this will override the `bootstrap-override-lld` option for Rust code when targeting MSVC.
 #linker = "cc" (path)
 
 # Should rustc and the standard library be built with split debuginfo? Default
diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index e699922f4dc05..cdd9a44a199c9 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -1219,7 +1219,7 @@ pub fn rustc_cargo(
     // us a faster startup time. However GNU ld < 2.40 will error if we try to link a shared object
     // with direct references to protected symbols, so for now we only use protected symbols if
     // linking with LLD is enabled.
-    if builder.build.config.lld_mode.is_used() {
+    if builder.build.config.bootstrap_override_lld.is_used() {
         cargo.rustflag("-Zdefault-visibility=protected");
     }
 
@@ -1256,7 +1256,7 @@ pub fn rustc_cargo(
     // is already on by default in MSVC optimized builds, which is interpreted as --icf=all:
     // https://github.com/llvm/llvm-project/blob/3329cec2f79185bafd678f310fafadba2a8c76d2/lld/COFF/Driver.cpp#L1746
     // https://github.com/rust-lang/rust/blob/f22819bcce4abaff7d1246a56eec493418f9f4ee/compiler/rustc_codegen_ssa/src/back/linker.rs#L827
-    if builder.config.lld_mode.is_used() && !build_compiler.host.is_msvc() {
+    if builder.config.bootstrap_override_lld.is_used() && !build_compiler.host.is_msvc() {
         cargo.rustflag("-Clink-args=-Wl,--icf=all");
     }
 
diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index 6d9e3b54156e0..271ce4cb950bb 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -41,7 +41,7 @@ use crate::core::config::toml::gcc::Gcc;
 use crate::core::config::toml::install::Install;
 use crate::core::config::toml::llvm::Llvm;
 use crate::core::config::toml::rust::{
-    LldMode, Rust, RustOptimize, check_incompatible_options_for_ci_rustc,
+    BootstrapOverrideLld, Rust, RustOptimize, check_incompatible_options_for_ci_rustc,
     default_lld_opt_in_targets, parse_codegen_backends,
 };
 use crate::core::config::toml::target::Target;
@@ -174,7 +174,7 @@ pub struct Config {
     pub llvm_from_ci: bool,
     pub llvm_build_config: HashMap<String, String>,
 
-    pub lld_mode: LldMode,
+    pub bootstrap_override_lld: BootstrapOverrideLld,
     pub lld_enabled: bool,
     pub llvm_tools_enabled: bool,
     pub llvm_bitcode_linker_enabled: bool,
@@ -567,7 +567,8 @@ impl Config {
             frame_pointers: rust_frame_pointers,
             stack_protector: rust_stack_protector,
             strip: rust_strip,
-            lld_mode: rust_lld_mode,
+            bootstrap_override_lld: rust_bootstrap_override_lld,
+            bootstrap_override_lld_legacy: rust_bootstrap_override_lld_legacy,
             std_features: rust_std_features,
             break_on_ice: rust_break_on_ice,
         } = toml.rust.unwrap_or_default();
@@ -615,6 +616,15 @@ impl Config {
 
         let Gcc { download_ci_gcc: gcc_download_ci_gcc } = toml.gcc.unwrap_or_default();
 
+        if rust_bootstrap_override_lld.is_some() && rust_bootstrap_override_lld_legacy.is_some() {
+            panic!(
+                "Cannot use both `rust.use-lld` and `rust.bootstrap-override-lld`. Please use only `rust.bootstrap-override-lld`"
+            );
+        }
+
+        let bootstrap_override_lld =
+            rust_bootstrap_override_lld.or(rust_bootstrap_override_lld_legacy).unwrap_or_default();
+
         if rust_optimize.as_ref().is_some_and(|v| matches!(v, RustOptimize::Bool(false))) {
             eprintln!(
                 "WARNING: setting `optimize` to `false` is known to cause errors and \
@@ -960,7 +970,7 @@ impl Config {
 
         let initial_rustfmt = build_rustfmt.or_else(|| maybe_download_rustfmt(&dwn_ctx, &out));
 
-        if matches!(rust_lld_mode.unwrap_or_default(), LldMode::SelfContained)
+        if matches!(bootstrap_override_lld, BootstrapOverrideLld::SelfContained)
             && !lld_enabled
             && flags_stage.unwrap_or(0) > 0
         {
@@ -1172,6 +1182,7 @@ impl Config {
             backtrace_on_ice: rust_backtrace_on_ice.unwrap_or(false),
             bindir: install_bindir.map(PathBuf::from).unwrap_or("bin".into()),
             bootstrap_cache_path: build_bootstrap_cache_path,
+            bootstrap_override_lld,
             bypass_bootstrap_lock: flags_bypass_bootstrap_lock,
             cargo_info,
             cargo_native_static: build_cargo_native_static.unwrap_or(false),
@@ -1238,7 +1249,6 @@ impl Config {
             libdir: install_libdir.map(PathBuf::from),
             library_docs_private_items: build_library_docs_private_items.unwrap_or(false),
             lld_enabled,
-            lld_mode: rust_lld_mode.unwrap_or_default(),
             lldb: build_lldb.map(PathBuf::from),
             llvm_allow_old_toolchain: llvm_allow_old_toolchain.unwrap_or(false),
             llvm_assertions,
diff --git a/src/bootstrap/src/core/config/mod.rs b/src/bootstrap/src/core/config/mod.rs
index 05a5dfc0bc5a8..56b87823a3654 100644
--- a/src/bootstrap/src/core/config/mod.rs
+++ b/src/bootstrap/src/core/config/mod.rs
@@ -37,7 +37,7 @@ use serde_derive::Deserialize;
 pub use target_selection::TargetSelection;
 pub use toml::BUILDER_CONFIG_FILENAME;
 pub use toml::change_id::ChangeId;
-pub use toml::rust::LldMode;
+pub use toml::rust::BootstrapOverrideLld;
 pub use toml::target::Target;
 
 use crate::Display;
diff --git a/src/bootstrap/src/core/config/tests.rs b/src/bootstrap/src/core/config/tests.rs
index 4f2df76a15658..e19604d4ab12f 100644
--- a/src/bootstrap/src/core/config/tests.rs
+++ b/src/bootstrap/src/core/config/tests.rs
@@ -17,7 +17,9 @@ use crate::core::build_steps::clippy::{LintConfig, get_clippy_rules_in_order};
 use crate::core::build_steps::llvm::LLVM_INVALIDATION_PATHS;
 use crate::core::build_steps::{llvm, test};
 use crate::core::config::toml::TomlConfig;
-use crate::core::config::{CompilerBuiltins, LldMode, StringOrBool, Target, TargetSelection};
+use crate::core::config::{
+    BootstrapOverrideLld, CompilerBuiltins, StringOrBool, Target, TargetSelection,
+};
 use crate::utils::tests::TestCtx;
 use crate::utils::tests::git::git_test;
 
@@ -222,11 +224,33 @@ fn verify_file_integrity() {
 
 #[test]
 fn rust_lld() {
-    assert!(matches!(parse("").lld_mode, LldMode::Unused));
-    assert!(matches!(parse("rust.use-lld = \"self-contained\"").lld_mode, LldMode::SelfContained));
-    assert!(matches!(parse("rust.use-lld = \"external\"").lld_mode, LldMode::External));
-    assert!(matches!(parse("rust.use-lld = true").lld_mode, LldMode::External));
-    assert!(matches!(parse("rust.use-lld = false").lld_mode, LldMode::Unused));
+    assert!(matches!(parse("").bootstrap_override_lld, BootstrapOverrideLld::None));
+    assert!(matches!(
+        parse("rust.bootstrap-override-lld = \"self-contained\"").bootstrap_override_lld,
+        BootstrapOverrideLld::SelfContained
+    ));
+    assert!(matches!(
+        parse("rust.bootstrap-override-lld = \"external\"").bootstrap_override_lld,
+        BootstrapOverrideLld::External
+    ));
+    assert!(matches!(
+        parse("rust.bootstrap-override-lld = true").bootstrap_override_lld,
+        BootstrapOverrideLld::External
+    ));
+    assert!(matches!(
+        parse("rust.bootstrap-override-lld = false").bootstrap_override_lld,
+        BootstrapOverrideLld::None
+    ));
+
+    // Also check the legacy options
+    assert!(matches!(
+        parse("rust.use-lld = true").bootstrap_override_lld,
+        BootstrapOverrideLld::External
+    ));
+    assert!(matches!(
+        parse("rust.use-lld = false").bootstrap_override_lld,
+        BootstrapOverrideLld::None
+    ));
 }
 
 #[test]
diff --git a/src/bootstrap/src/core/config/toml/rust.rs b/src/bootstrap/src/core/config/toml/rust.rs
index e5987d7040aaf..ca9e0d0bc98e7 100644
--- a/src/bootstrap/src/core/config/toml/rust.rs
+++ b/src/bootstrap/src/core/config/toml/rust.rs
@@ -45,7 +45,9 @@ define_config! {
         codegen_backends: Option<Vec<String>> = "codegen-backends",
         llvm_bitcode_linker: Option<bool> = "llvm-bitcode-linker",
         lld: Option<bool> = "lld",
-        lld_mode: Option<LldMode> = "use-lld",
+        bootstrap_override_lld: Option<BootstrapOverrideLld> = "bootstrap-override-lld",
+        // FIXME: Remove this option in Spring 2026
+        bootstrap_override_lld_legacy: Option<BootstrapOverrideLld> = "use-lld",
         llvm_tools: Option<bool> = "llvm-tools",
         deny_warnings: Option<bool> = "deny-warnings",
         backtrace_on_ice: Option<bool> = "backtrace-on-ice",
@@ -70,22 +72,33 @@ define_config! {
     }
 }
 
-/// LLD in bootstrap works like this:
-/// - Self-contained lld: use `rust-lld` from the compiler's sysroot
+/// Determines if we should override the linker used for linking Rust code built
+/// during the bootstrapping process to be LLD.
+///
+/// The primary use-case for this is to make local (re)builds of Rust code faster
+/// when using bootstrap.
+///
+/// This does not affect the *behavior* of the built/distributed compiler when invoked
+/// outside of bootstrap.
+/// It might affect its performance/binary size though, as that can depend on the
+/// linker that links rustc.
+///
+/// There are two ways of overriding the linker to be LLD:
+/// - Self-contained LLD: use `rust-lld` from the compiler's sysroot
 /// - External: use an external `lld` binary
 ///
 /// It is configured depending on the target:
 /// 1) Everything except MSVC
-/// - Self-contained: `-Clinker-flavor=gnu-lld-cc -Clink-self-contained=+linker`
-/// - External: `-Clinker-flavor=gnu-lld-cc`
+/// - Self-contained: `-Clinker-features=+lld -Clink-self-contained=+linker`
+/// - External: `-Clinker-features=+lld`
 /// 2) MSVC
 /// - Self-contained: `-Clinker=<path to rust-lld>`
 /// - External: `-Clinker=lld`
 #[derive(Copy, Clone, Default, Debug, PartialEq)]
-pub enum LldMode {
-    /// Do not use LLD
+pub enum BootstrapOverrideLld {
+    /// Do not override the linker LLD
     #[default]
-    Unused,
+    None,
     /// Use `rust-lld` from the compiler's sysroot
     SelfContained,
     /// Use an externally provided `lld` binary.
@@ -94,16 +107,16 @@ pub enum LldMode {
     External,
 }
 
-impl LldMode {
+impl BootstrapOverrideLld {
     pub fn is_used(&self) -> bool {
         match self {
-            LldMode::SelfContained | LldMode::External => true,
-            LldMode::Unused => false,
+            BootstrapOverrideLld::SelfContained | BootstrapOverrideLld::External => true,
+            BootstrapOverrideLld::None => false,
         }
     }
 }
 
-impl<'de> Deserialize<'de> for LldMode {
+impl<'de> Deserialize<'de> for BootstrapOverrideLld {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: Deserializer<'de>,
@@ -111,7 +124,7 @@ impl<'de> Deserialize<'de> for LldMode {
         struct LldModeVisitor;
 
         impl serde::de::Visitor<'_> for LldModeVisitor {
-            type Value = LldMode;
+            type Value = BootstrapOverrideLld;
 
             fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                 formatter.write_str("one of true, 'self-contained' or 'external'")
@@ -121,7 +134,7 @@ impl<'de> Deserialize<'de> for LldMode {
             where
                 E: serde::de::Error,
             {
-                Ok(if v { LldMode::External } else { LldMode::Unused })
+                Ok(if v { BootstrapOverrideLld::External } else { BootstrapOverrideLld::None })
             }
 
             fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
@@ -129,8 +142,8 @@ impl<'de> Deserialize<'de> for LldMode {
                 E: serde::de::Error,
             {
                 match v {
-                    "external" => Ok(LldMode::External),
-                    "self-contained" => Ok(LldMode::SelfContained),
+                    "external" => Ok(BootstrapOverrideLld::External),
+                    "self-contained" => Ok(BootstrapOverrideLld::SelfContained),
                     _ => Err(E::custom(format!("unknown mode {v}"))),
                 }
             }
@@ -311,7 +324,6 @@ pub fn check_incompatible_options_for_ci_rustc(
         lto,
         stack_protector,
         strip,
-        lld_mode,
         jemalloc,
         rpath,
         channel,
@@ -359,6 +371,8 @@ pub fn check_incompatible_options_for_ci_rustc(
         frame_pointers: _,
         break_on_ice: _,
         parallel_frontend_threads: _,
+        bootstrap_override_lld: _,
+        bootstrap_override_lld_legacy: _,
     } = ci_rust_config;
 
     // There are two kinds of checks for CI rustc incompatible options:
@@ -374,7 +388,6 @@ pub fn check_incompatible_options_for_ci_rustc(
     err!(current_rust_config.debuginfo_level_rustc, debuginfo_level_rustc, "rust");
     err!(current_rust_config.rpath, rpath, "rust");
     err!(current_rust_config.strip, strip, "rust");
-    err!(current_rust_config.lld_mode, lld_mode, "rust");
     err!(current_rust_config.llvm_tools, llvm_tools, "rust");
     err!(current_rust_config.llvm_bitcode_linker, llvm_bitcode_linker, "rust");
     err!(current_rust_config.jemalloc, jemalloc, "rust");
diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs
index 4f4d35673d5d1..d798639cc967e 100644
--- a/src/bootstrap/src/lib.rs
+++ b/src/bootstrap/src/lib.rs
@@ -35,7 +35,7 @@ use utils::exec::ExecutionContext;
 
 use crate::core::builder;
 use crate::core::builder::Kind;
-use crate::core::config::{DryRun, LldMode, LlvmLibunwind, TargetSelection, flags};
+use crate::core::config::{BootstrapOverrideLld, DryRun, LlvmLibunwind, TargetSelection, flags};
 use crate::utils::exec::{BootstrapCommand, command};
 use crate::utils::helpers::{self, dir_is_empty, exe, libdir, set_file_times, split_debuginfo};
 
@@ -1358,14 +1358,14 @@ impl Build {
             && !target.is_msvc()
         {
             Some(self.cc(target))
-        } else if self.config.lld_mode.is_used()
+        } else if self.config.bootstrap_override_lld.is_used()
             && self.is_lld_direct_linker(target)
             && self.host_target == target
         {
-            match self.config.lld_mode {
-                LldMode::SelfContained => Some(self.initial_lld.clone()),
-                LldMode::External => Some("lld".into()),
-                LldMode::Unused => None,
+            match self.config.bootstrap_override_lld {
+                BootstrapOverrideLld::SelfContained => Some(self.initial_lld.clone()),
+                BootstrapOverrideLld::External => Some("lld".into()),
+                BootstrapOverrideLld::None => None,
             }
         } else {
             None
diff --git a/src/bootstrap/src/utils/change_tracker.rs b/src/bootstrap/src/utils/change_tracker.rs
index 6b187578c31ec..f311c84bec9b5 100644
--- a/src/bootstrap/src/utils/change_tracker.rs
+++ b/src/bootstrap/src/utils/change_tracker.rs
@@ -556,4 +556,9 @@ pub const CONFIG_CHANGE_HISTORY: &[ChangeInfo] = &[
         severity: ChangeSeverity::Info,
         summary: "New option `build.windows-rc` that will override which resource compiler on Windows will be used to compile Rust.",
     },
+    ChangeInfo {
+        change_id: 99999,
+        severity: ChangeSeverity::Warning,
+        summary: "The `rust.use-lld` option has been renamed to `rust.bootstrap-override-lld`. Note that it only serves for overriding the linker used when building Rust code in bootstrap to be LLD.",
+    },
 ];
diff --git a/src/bootstrap/src/utils/helpers.rs b/src/bootstrap/src/utils/helpers.rs
index e802c0214ddcb..faada9a111db8 100644
--- a/src/bootstrap/src/utils/helpers.rs
+++ b/src/bootstrap/src/utils/helpers.rs
@@ -12,7 +12,7 @@ use std::{env, fs, io, panic, str};
 
 use object::read::archive::ArchiveFile;
 
-use crate::LldMode;
+use crate::BootstrapOverrideLld;
 use crate::core::builder::Builder;
 use crate::core::config::{Config, TargetSelection};
 use crate::utils::exec::{BootstrapCommand, command};
@@ -357,15 +357,19 @@ pub fn get_clang_cl_resource_dir(builder: &Builder<'_>, clang_cl_path: &str) ->
 /// Returns a flag that configures LLD to use only a single thread.
 /// If we use an external LLD, we need to find out which version is it to know which flag should we
 /// pass to it (LLD older than version 10 had a different flag).
-fn lld_flag_no_threads(builder: &Builder<'_>, lld_mode: LldMode, is_windows: bool) -> &'static str {
+fn lld_flag_no_threads(
+    builder: &Builder<'_>,
+    bootstrap_override_lld: BootstrapOverrideLld,
+    is_windows: bool,
+) -> &'static str {
     static LLD_NO_THREADS: OnceLock<(&'static str, &'static str)> = OnceLock::new();
 
     let new_flags = ("/threads:1", "--threads=1");
     let old_flags = ("/no-threads", "--no-threads");
 
     let (windows_flag, other_flag) = LLD_NO_THREADS.get_or_init(|| {
-        let newer_version = match lld_mode {
-            LldMode::External => {
+        let newer_version = match bootstrap_override_lld {
+            BootstrapOverrideLld::External => {
                 let mut cmd = command("lld");
                 cmd.arg("-flavor").arg("ld").arg("--version");
                 let out = cmd.run_capture_stdout(builder).stdout();
@@ -422,24 +426,28 @@ pub fn linker_flags(
     lld_threads: LldThreads,
 ) -> Vec<String> {
     let mut args = vec![];
-    if !builder.is_lld_direct_linker(target) && builder.config.lld_mode.is_used() {
-        match builder.config.lld_mode {
-            LldMode::External => {
+    if !builder.is_lld_direct_linker(target) && builder.config.bootstrap_override_lld.is_used() {
+        match builder.config.bootstrap_override_lld {
+            BootstrapOverrideLld::External => {
                 args.push("-Clinker-features=+lld".to_string());
                 args.push("-Zunstable-options".to_string());
             }
-            LldMode::SelfContained => {
+            BootstrapOverrideLld::SelfContained => {
                 args.push("-Clinker-features=+lld".to_string());
                 args.push("-Clink-self-contained=+linker".to_string());
                 args.push("-Zunstable-options".to_string());
             }
-            LldMode::Unused => unreachable!(),
+            BootstrapOverrideLld::None => unreachable!(),
         };
 
         if matches!(lld_threads, LldThreads::No) {
             args.push(format!(
                 "-Clink-arg=-Wl,{}",
-                lld_flag_no_threads(builder, builder.config.lld_mode, target.is_windows())
+                lld_flag_no_threads(
+                    builder,
+                    builder.config.bootstrap_override_lld,
+                    target.is_windows()
+                )
             ));
         }
     }
diff --git a/src/ci/docker/host-aarch64/dist-aarch64-linux/Dockerfile b/src/ci/docker/host-aarch64/dist-aarch64-linux/Dockerfile
index e726329753f24..3abca36fe70db 100644
--- a/src/ci/docker/host-aarch64/dist-aarch64-linux/Dockerfile
+++ b/src/ci/docker/host-aarch64/dist-aarch64-linux/Dockerfile
@@ -91,7 +91,7 @@ ENV RUST_CONFIGURE_ARGS \
       --set llvm.ninja=false \
       --set rust.debug-assertions=false \
       --set rust.jemalloc \
-      --set rust.use-lld=true \
+      --set rust.bootstrap-override-lld=true \
       --set rust.lto=thin \
       --set rust.codegen-units=1
 
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 01f19eac1d2fa..cb57478761994 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
@@ -92,7 +92,7 @@ ENV RUST_CONFIGURE_ARGS \
       --set llvm.ninja=false \
       --set llvm.libzstd=true \
       --set rust.jemalloc \
-      --set rust.use-lld=true \
+      --set rust.bootstrap-override-lld=true \
       --set rust.lto=thin \
       --set rust.codegen-units=1
 

From b550688258ddc29618ebd2fa0b6b4a518f12c0e4 Mon Sep 17 00:00:00 2001
From: beepster4096 <19316085+beepster4096@users.noreply.github.com>
Date: Fri, 26 Sep 2025 12:17:06 -0700
Subject: [PATCH 1444/1889] castkind::subtype in clippy

---
 src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

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 2bda6d50373cd..cc98fac45c7cb 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
@@ -141,7 +141,8 @@ fn check_rvalue<'tcx>(
             | CastKind::FloatToFloat
             | CastKind::FnPtrToPtr
             | CastKind::PtrToPtr
-            | CastKind::PointerCoercion(PointerCoercion::MutToConstPointer | PointerCoercion::ArrayToPointer, _),
+            | CastKind::PointerCoercion(PointerCoercion::MutToConstPointer | PointerCoercion::ArrayToPointer, _)
+            | CastKind::Subtype,
             operand,
             _,
         ) => check_operand(cx, operand, span, body, msrv),
@@ -312,7 +313,6 @@ fn check_place<'tcx>(
             | ProjectionElem::OpaqueCast(..)
             | ProjectionElem::Downcast(..)
             | ProjectionElem::Subslice { .. }
-            | ProjectionElem::Subtype(_)
             | ProjectionElem::Index(_)
             | ProjectionElem::UnwrapUnsafeBinder(_) => {},
         }

From 36d6327fa46a949d217b691fc7fb978359ca636b Mon Sep 17 00:00:00 2001
From: beepster4096 <19316085+beepster4096@users.noreply.github.com>
Date: Fri, 26 Sep 2025 12:17:06 -0700
Subject: [PATCH 1445/1889] castkind::subtype in clippy

---
 clippy_utils/src/qualify_min_const_fn.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/clippy_utils/src/qualify_min_const_fn.rs b/clippy_utils/src/qualify_min_const_fn.rs
index 2bda6d50373cd..cc98fac45c7cb 100644
--- a/clippy_utils/src/qualify_min_const_fn.rs
+++ b/clippy_utils/src/qualify_min_const_fn.rs
@@ -141,7 +141,8 @@ fn check_rvalue<'tcx>(
             | CastKind::FloatToFloat
             | CastKind::FnPtrToPtr
             | CastKind::PtrToPtr
-            | CastKind::PointerCoercion(PointerCoercion::MutToConstPointer | PointerCoercion::ArrayToPointer, _),
+            | CastKind::PointerCoercion(PointerCoercion::MutToConstPointer | PointerCoercion::ArrayToPointer, _)
+            | CastKind::Subtype,
             operand,
             _,
         ) => check_operand(cx, operand, span, body, msrv),
@@ -312,7 +313,6 @@ fn check_place<'tcx>(
             | ProjectionElem::OpaqueCast(..)
             | ProjectionElem::Downcast(..)
             | ProjectionElem::Subslice { .. }
-            | ProjectionElem::Subtype(_)
             | ProjectionElem::Index(_)
             | ProjectionElem::UnwrapUnsafeBinder(_) => {},
         }

From bd860bdf267644810c8efb4a8d74fdbd0ff8383c Mon Sep 17 00:00:00 2001
From: Augie Fackler <raf@durin42.com>
Date: Fri, 26 Sep 2025 15:38:30 -0400
Subject: [PATCH 1446/1889] Fix typo in LLVM_VERSION_ macro use

Co-authored-by: Nikita Popov <github@npopov.com>
---
 compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
index b7637b29bca53..2e9fd6754f124 100644
--- a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
@@ -569,7 +569,7 @@ extern "C" LLVMRustResult LLVMRustOptimize(
   }
 
   std::optional<PGOOptions> PGOOpt;
-#if LLVM_VERSION_LE(22, 0)
+#if LLVM_VERSION_LT(22, 0)
   auto FS = vfs::getRealFileSystem();
 #endif
   if (PGOGenPath) {

From 9d5adff08cafbb93a53c6f72fcec8cdf89d06e49 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 26 Sep 2025 19:45:06 +0000
Subject: [PATCH 1447/1889] Bump tar-fs from 2.1.3 to 2.1.4 in /editors/code

Bumps [tar-fs](https://github.com/mafintosh/tar-fs) from 2.1.3 to 2.1.4.
- [Commits](https://github.com/mafintosh/tar-fs/compare/v2.1.3...v2.1.4)

---
updated-dependencies:
- dependency-name: tar-fs
  dependency-version: 2.1.4
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 src/tools/rust-analyzer/editors/code/package-lock.json | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/tools/rust-analyzer/editors/code/package-lock.json b/src/tools/rust-analyzer/editors/code/package-lock.json
index ad8708e00c519..e35a159cbc3fd 100644
--- a/src/tools/rust-analyzer/editors/code/package-lock.json
+++ b/src/tools/rust-analyzer/editors/code/package-lock.json
@@ -6405,9 +6405,9 @@
             }
         },
         "node_modules/tar-fs": {
-            "version": "2.1.3",
-            "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-2.1.3.tgz",
-            "integrity": "sha512-090nwYJDmlhwFwEW3QQl+vaNnxsO2yVsd45eTKRBzSzu+hlb1w2K9inVq5b0ngXuLVqQ4ApvsUHHnu/zQNkWAg==",
+            "version": "2.1.4",
+            "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-2.1.4.tgz",
+            "integrity": "sha512-mDAjwmZdh7LTT6pNleZ05Yt65HC3E+NiQzl672vQG38jIrehtJk/J3mNwIg+vShQPcLF/LV7CMnDW6vjj6sfYQ==",
             "dev": true,
             "license": "MIT",
             "optional": true,

From eb3fb457f14c419b58fc8b20d72efcea94e06d9f Mon Sep 17 00:00:00 2001
From: Augie Fackler <augie@google.com>
Date: Fri, 26 Sep 2025 15:37:44 -0400
Subject: [PATCH 1448/1889] split-dwarf: add documentation and test coverage

---
 .../src/compiler-flags/split-dwarf-out-dir.md |   7 +
 .../src/external_deps/rustc.rs                |   7 +
 tests/run-make/split-debuginfo/rmake.rs       | 150 ++++++++++++++++--
 3 files changed, 152 insertions(+), 12 deletions(-)
 create mode 100644 src/doc/unstable-book/src/compiler-flags/split-dwarf-out-dir.md

diff --git a/src/doc/unstable-book/src/compiler-flags/split-dwarf-out-dir.md b/src/doc/unstable-book/src/compiler-flags/split-dwarf-out-dir.md
new file mode 100644
index 0000000000000..a2070730b42f8
--- /dev/null
+++ b/src/doc/unstable-book/src/compiler-flags/split-dwarf-out-dir.md
@@ -0,0 +1,7 @@
+# `split-dwarf-out-dir`
+
+On systems which use DWARF debug info this flag causes `.dwo` files produced
+by `-C split-debuginfo` to be written to the specified directory rather than
+placed next to the object files. This is mostly useful if you have a build
+system which needs to control where to find compile outputs without running the
+compiler and have to put your `.dwo` files in a separate directory.
diff --git a/src/tools/run-make-support/src/external_deps/rustc.rs b/src/tools/run-make-support/src/external_deps/rustc.rs
index b74b1d5e166fc..b461a24a06168 100644
--- a/src/tools/run-make-support/src/external_deps/rustc.rs
+++ b/src/tools/run-make-support/src/external_deps/rustc.rs
@@ -366,6 +366,13 @@ impl Rustc {
         self
     }
 
+    pub fn split_dwarf_out_dir(&mut self, out_dir: Option<&str>) -> &mut Self {
+        if let Some(out_dir) = out_dir {
+            self.cmd.arg(format!("-Zsplit-dwarf-out-dir={out_dir}"));
+        }
+        self
+    }
+
     /// Pass the `--verbose` flag.
     pub fn verbose(&mut self) -> &mut Self {
         self.cmd.arg("--verbose");
diff --git a/tests/run-make/split-debuginfo/rmake.rs b/tests/run-make/split-debuginfo/rmake.rs
index e8de5aed17260..e53b710107812 100644
--- a/tests/run-make/split-debuginfo/rmake.rs
+++ b/tests/run-make/split-debuginfo/rmake.rs
@@ -187,6 +187,25 @@ enum UnstableOptions {
     Unspecified,
 }
 
+#[track_caller]
+fn dwo_out_filenames(dwo_out: Option<&str>) -> BTreeSet<String> {
+    let dwo_out = if let Some(d) = dwo_out {
+        d
+    } else {
+        return BTreeSet::new();
+    };
+    let files = shallow_find_files(dwo_out, |path| {
+        // Fiilter out source files
+        !has_extension(path, "rs")
+    });
+    files
+        .iter()
+        .map(|p| {
+            format!("{}/{}", dwo_out, p.file_name().unwrap().to_os_string().into_string().unwrap())
+        })
+        .collect()
+}
+
 #[track_caller]
 fn cwd_filenames() -> BTreeSet<String> {
     let files = shallow_find_files(cwd(), |path| {
@@ -196,6 +215,17 @@ fn cwd_filenames() -> BTreeSet<String> {
     files.iter().map(|p| p.file_name().unwrap().to_os_string().into_string().unwrap()).collect()
 }
 
+#[track_caller]
+fn dwo_out_dwo_filenames(dwo_out: &str) -> BTreeSet<String> {
+    let files = shallow_find_files(dwo_out, |p| has_extension(p, "dwo"));
+    files
+        .iter()
+        .map(|p| {
+            format!("{}/{}", dwo_out, p.file_name().unwrap().to_os_string().into_string().unwrap())
+        })
+        .collect()
+}
+
 #[track_caller]
 fn cwd_dwo_filenames() -> BTreeSet<String> {
     let files = shallow_find_files(cwd(), |path| has_extension(path, "dwo"));
@@ -376,17 +406,19 @@ mod shared_linux_other_tests {
         lto: LinkerPluginLto,
         remap_path_prefix: RemapPathPrefix,
         remap_path_scope: RemapPathScope,
+        split_dwarf_output_directory: Option<&str>,
     ) {
         run_in_tmpdir(|| {
             println!(
-                "checking: unstable_options={:?} + split_kind={:?} + level={:?} + split_dwarf_kind={:?} + lto={:?} + remap_path_prefix={:?} + remap_path_scope={:?}",
+                "checking: unstable_options={:?} + split_kind={:?} + level={:?} + split_dwarf_kind={:?} + lto={:?} + remap_path_prefix={:?} + remap_path_scope={:?} + split_dwarf_out_dir={:?}",
                 unstable_options,
                 split_kind,
                 level,
                 split_dwarf_kind,
                 lto,
                 remap_path_prefix,
-                remap_path_scope
+                remap_path_scope,
+                split_dwarf_output_directory,
             );
 
             match cross_crate_test {
@@ -398,6 +430,7 @@ mod shared_linux_other_tests {
                     lto,
                     remap_path_prefix,
                     remap_path_scope,
+                    split_dwarf_output_directory,
                 ),
                 CrossCrateTest::No => simple_split_debuginfo(
                     unstable_options,
@@ -407,6 +440,7 @@ mod shared_linux_other_tests {
                     lto,
                     remap_path_prefix,
                     remap_path_scope,
+                    split_dwarf_output_directory,
                 ),
             }
         });
@@ -420,7 +454,11 @@ mod shared_linux_other_tests {
         lto: LinkerPluginLto,
         remap_path_prefix: RemapPathPrefix,
         remap_path_scope: RemapPathScope,
+        split_dwarf_output_directory: Option<&str>,
     ) {
+        if let Some(dwo_out) = split_dwarf_output_directory {
+            run_make_support::rfs::create_dir(dwo_out);
+        }
         match (split_kind, level, split_dwarf_kind, lto, remap_path_prefix, remap_path_scope) {
             // packed-crosscrate-split
             // - Debuginfo in `.dwo` files
@@ -531,13 +569,19 @@ mod shared_linux_other_tests {
                     .input("bar.rs")
                     .crate_type("lib")
                     .split_debuginfo(split_kind.cli_value())
+                    .split_dwarf_out_dir(split_dwarf_output_directory)
                     .debuginfo(level.cli_value())
                     .arg(format!("-Zsplit-dwarf-kind={}", split_dwarf_kind.cli_value()))
                     .run();
 
-                let bar_found_files = cwd_filenames();
+                let mut bar_found_files = cwd_filenames();
+                bar_found_files.append(&mut dwo_out_filenames(split_dwarf_output_directory));
 
-                let bar_dwo_files = cwd_dwo_filenames();
+                let bar_dwo_files = if let Some(dwo_out) = split_dwarf_output_directory {
+                    dwo_out_dwo_filenames(dwo_out)
+                } else {
+                    cwd_dwo_filenames()
+                };
                 assert_eq!(bar_dwo_files.len(), 1);
 
                 let mut bar_expected_files = BTreeSet::new();
@@ -553,13 +597,19 @@ mod shared_linux_other_tests {
                     .extern_("bar", "libbar.rlib")
                     .input("main.rs")
                     .split_debuginfo(split_kind.cli_value())
+                    .split_dwarf_out_dir(split_dwarf_output_directory)
                     .debuginfo(level.cli_value())
                     .arg(format!("-Zsplit-dwarf-kind={}", split_dwarf_kind.cli_value()))
                     .run();
 
-                let overall_found_files = cwd_filenames();
+                let mut overall_found_files = cwd_filenames();
+                overall_found_files.append(&mut dwo_out_filenames(split_dwarf_output_directory));
 
-                let overall_dwo_files = cwd_dwo_filenames();
+                let overall_dwo_files = if let Some(dwo_out) = split_dwarf_output_directory {
+                    dwo_out_dwo_filenames(dwo_out)
+                } else {
+                    cwd_dwo_filenames()
+                };
                 assert_eq!(overall_dwo_files.len(), 2);
 
                 let mut overall_expected_files = BTreeSet::new();
@@ -648,7 +698,11 @@ mod shared_linux_other_tests {
         lto: LinkerPluginLto,
         remap_path_prefix: RemapPathPrefix,
         remap_path_scope: RemapPathScope,
+        split_dwarf_output_directory: Option<&str>,
     ) {
+        if let Some(dwo_out) = split_dwarf_output_directory {
+            run_make_support::rfs::create_dir(dwo_out);
+        }
         match (split_kind, level, split_dwarf_kind, lto, remap_path_prefix, remap_path_scope) {
             // off (unspecified):
             // - Debuginfo in `.o` files
@@ -921,14 +975,19 @@ mod shared_linux_other_tests {
                 rustc(unstable_options)
                     .input("foo.rs")
                     .split_debuginfo(split_kind.cli_value())
+                    .split_dwarf_out_dir(split_dwarf_output_directory)
                     .debuginfo(level.cli_value())
                     .arg(format!("-Zsplit-dwarf-kind={}", split_dwarf_kind.cli_value()))
                     .run();
-                let found_files = cwd_filenames();
-
-                let dwo_files = cwd_dwo_filenames();
+                let mut found_files = cwd_filenames();
+                found_files.append(&mut dwo_out_filenames(split_dwarf_output_directory));
+
+                let dwo_files = if let Some(dwo_dir) = split_dwarf_output_directory {
+                    dwo_out_dwo_filenames(dwo_dir)
+                } else {
+                    cwd_dwo_filenames()
+                };
                 assert_eq!(dwo_files.len(), 1);
-
                 let mut expected_files = BTreeSet::new();
                 expected_files.extend(dwo_files);
                 expected_files.insert("foo".to_string());
@@ -1056,14 +1115,20 @@ mod shared_linux_other_tests {
                 rustc(unstable_options)
                     .input("foo.rs")
                     .split_debuginfo(split_kind.cli_value())
+                    .split_dwarf_out_dir(split_dwarf_output_directory)
                     .debuginfo(level.cli_value())
                     .arg(format!("-Zsplit-dwarf-kind={}", split_dwarf_kind.cli_value()))
                     .remap_path_prefix(cwd(), remapped_prefix)
                     .run();
 
-                let found_files = cwd_filenames();
+                let mut found_files = cwd_filenames();
+                found_files.append(&mut dwo_out_filenames(split_dwarf_output_directory));
 
-                let dwo_files = cwd_dwo_filenames();
+                let dwo_files = if let Some(dwo_out) = split_dwarf_output_directory {
+                    dwo_out_dwo_filenames(dwo_out)
+                } else {
+                    cwd_dwo_filenames()
+                };
                 assert_eq!(dwo_files.len(), 1);
 
                 let mut expected_files = BTreeSet::new();
@@ -1358,6 +1423,7 @@ fn main() {
             LinkerPluginLto::Unspecified,
             RemapPathPrefix::Unspecified,
             RemapPathScope::Unspecified,
+            None,
         );
 
         // off
@@ -1370,6 +1436,7 @@ fn main() {
             LinkerPluginLto::Unspecified,
             RemapPathPrefix::Unspecified,
             RemapPathScope::Unspecified,
+            None,
         );
 
         // packed-split
@@ -1382,6 +1449,7 @@ fn main() {
             LinkerPluginLto::Unspecified,
             RemapPathPrefix::Unspecified,
             RemapPathScope::Unspecified,
+            None,
         );
 
         // packed-single
@@ -1394,6 +1462,7 @@ fn main() {
             LinkerPluginLto::Unspecified,
             RemapPathPrefix::Unspecified,
             RemapPathScope::Unspecified,
+            None,
         );
 
         // packed-lto-split
@@ -1406,6 +1475,7 @@ fn main() {
             LinkerPluginLto::Yes,
             RemapPathPrefix::Unspecified,
             RemapPathScope::Unspecified,
+            None,
         );
 
         // packed-lto-single
@@ -1418,6 +1488,7 @@ fn main() {
             LinkerPluginLto::Yes,
             RemapPathPrefix::Unspecified,
             RemapPathScope::Unspecified,
+            None,
         );
 
         // FIXME: the remapping tests probably need to be reworked, see
@@ -1433,6 +1504,7 @@ fn main() {
             LinkerPluginLto::Unspecified,
             RemapPathPrefix::Yes { remapped_prefix: "/__MY_REMAPPED_PATH__" },
             RemapPathScope::Unspecified,
+            None,
         );
 
         // packed-remapped-single
@@ -1445,6 +1517,7 @@ fn main() {
             LinkerPluginLto::Unspecified,
             RemapPathPrefix::Yes { remapped_prefix: "/__MY_REMAPPED_PATH__" },
             RemapPathScope::Unspecified,
+            None,
         );
 
         // packed-remapped-scope
@@ -1457,6 +1530,7 @@ fn main() {
             LinkerPluginLto::Unspecified,
             RemapPathPrefix::Yes { remapped_prefix: "/__MY_REMAPPED_PATH__" },
             RemapPathScope::Yes("debuginfo"),
+            None,
         );
 
         // packed-remapped-wrong-scope
@@ -1469,6 +1543,7 @@ fn main() {
             LinkerPluginLto::Unspecified,
             RemapPathPrefix::Yes { remapped_prefix: "/__MY_REMAPPED_PATH__" },
             RemapPathScope::Yes("macro"),
+            None,
         );
 
         // packed-crosscrate-split
@@ -1481,6 +1556,7 @@ fn main() {
             LinkerPluginLto::Unspecified,
             RemapPathPrefix::Unspecified,
             RemapPathScope::Unspecified,
+            None,
         );
 
         // packed-crosscrate-single
@@ -1493,6 +1569,7 @@ fn main() {
             LinkerPluginLto::Unspecified,
             RemapPathPrefix::Unspecified,
             RemapPathScope::Unspecified,
+            None,
         );
 
         // unpacked-split
@@ -1505,6 +1582,20 @@ fn main() {
             LinkerPluginLto::Unspecified,
             RemapPathPrefix::Unspecified,
             RemapPathScope::Unspecified,
+            None,
+        );
+
+        // unpacked-split with split-dwarf-out-dir
+        shared_linux_other_tests::split_debuginfo(
+            CrossCrateTest::No,
+            UnstableOptions::Yes,
+            SplitDebuginfo::Unpacked,
+            DebuginfoLevel::Full,
+            SplitDwarfKind::Split,
+            LinkerPluginLto::Unspecified,
+            RemapPathPrefix::Unspecified,
+            RemapPathScope::Unspecified,
+            Some("other-dir"),
         );
 
         // unpacked-single
@@ -1517,6 +1608,7 @@ fn main() {
             LinkerPluginLto::Unspecified,
             RemapPathPrefix::Unspecified,
             RemapPathScope::Unspecified,
+            None,
         );
 
         // unpacked-lto-split
@@ -1529,6 +1621,7 @@ fn main() {
             LinkerPluginLto::Yes,
             RemapPathPrefix::Unspecified,
             RemapPathScope::Unspecified,
+            None,
         );
 
         // unpacked-lto-single
@@ -1541,6 +1634,7 @@ fn main() {
             LinkerPluginLto::Yes,
             RemapPathPrefix::Unspecified,
             RemapPathScope::Unspecified,
+            None,
         );
 
         // unpacked-remapped-split
@@ -1553,6 +1647,20 @@ fn main() {
             LinkerPluginLto::Unspecified,
             RemapPathPrefix::Yes { remapped_prefix: "/__MY_REMAPPED_PATH__" },
             RemapPathScope::Unspecified,
+            None,
+        );
+
+        // unpacked-remapped-split with split-dwarf-out-dir
+        shared_linux_other_tests::split_debuginfo(
+            CrossCrateTest::No,
+            UnstableOptions::Yes,
+            SplitDebuginfo::Unpacked,
+            DebuginfoLevel::Full,
+            SplitDwarfKind::Split,
+            LinkerPluginLto::Unspecified,
+            RemapPathPrefix::Yes { remapped_prefix: "/__MY_REMAPPED_PATH__" },
+            RemapPathScope::Unspecified,
+            Some("other-dir"),
         );
 
         // unpacked-remapped-single
@@ -1565,6 +1673,7 @@ fn main() {
             LinkerPluginLto::Unspecified,
             RemapPathPrefix::Yes { remapped_prefix: "/__MY_REMAPPED_PATH__" },
             RemapPathScope::Unspecified,
+            None,
         );
 
         // unpacked-remapped-scope
@@ -1577,6 +1686,7 @@ fn main() {
             LinkerPluginLto::Unspecified,
             RemapPathPrefix::Yes { remapped_prefix: "/__MY_REMAPPED_PATH__" },
             RemapPathScope::Yes("debuginfo"),
+            None,
         );
 
         // unpacked-remapped-wrong-scope
@@ -1589,6 +1699,7 @@ fn main() {
             LinkerPluginLto::Unspecified,
             RemapPathPrefix::Yes { remapped_prefix: "/__MY_REMAPPED_PATH__" },
             RemapPathScope::Yes("macro"),
+            None,
         );
 
         // unpacked-crosscrate-split
@@ -1601,6 +1712,20 @@ fn main() {
             LinkerPluginLto::Unspecified,
             RemapPathPrefix::Unspecified,
             RemapPathScope::Unspecified,
+            None,
+        );
+
+        // unpacked-crosscrate-split with split-dwarf-out-dir
+        shared_linux_other_tests::split_debuginfo(
+            CrossCrateTest::Yes,
+            UnstableOptions::Yes,
+            SplitDebuginfo::Unpacked,
+            DebuginfoLevel::Full,
+            SplitDwarfKind::Split,
+            LinkerPluginLto::Unspecified,
+            RemapPathPrefix::Unspecified,
+            RemapPathScope::Unspecified,
+            Some("other-dir"),
         );
 
         // unpacked-crosscrate-single
@@ -1613,6 +1738,7 @@ fn main() {
             LinkerPluginLto::Unspecified,
             RemapPathPrefix::Unspecified,
             RemapPathScope::Unspecified,
+            None,
         );
     }
 }

From b7e444de16d5945908657200d59af608d8c6232c Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 25 Sep 2025 16:43:01 +0200
Subject: [PATCH 1449/1889] Add regression test for merged doctests compilation
 time display

---
 .../doctests-compilation-time-info/rmake.rs   | 119 ++++++++++++++++++
 .../doctests-merge/doctest-2024.stdout        |   1 +
 tests/run-make/doctests-merge/rmake.rs        |   2 +
 .../doctest/doctest-output.edition2015.stdout |   6 +-
 .../doctest/doctest-output.edition2024.stdout |   7 +-
 tests/rustdoc-ui/doctest/doctest-output.rs    |   2 +
 .../doctest/merged-ignore-no_run.rs           |   2 +
 .../doctest/merged-ignore-no_run.stdout       |   5 +-
 8 files changed, 136 insertions(+), 8 deletions(-)
 create mode 100644 tests/run-make/doctests-compilation-time-info/rmake.rs

diff --git a/tests/run-make/doctests-compilation-time-info/rmake.rs b/tests/run-make/doctests-compilation-time-info/rmake.rs
new file mode 100644
index 0000000000000..2bcf664923f2a
--- /dev/null
+++ b/tests/run-make/doctests-compilation-time-info/rmake.rs
@@ -0,0 +1,119 @@
+//@ ignore-cross-compile (needs to run doctests)
+
+use run_make_support::rfs::write;
+use run_make_support::{cwd, rustdoc};
+
+fn assert_presence_of_compilation_time_report(
+    content: &str,
+    success: bool,
+    should_contain_compile_time: bool,
+) {
+    let mut cmd = rustdoc();
+    let file = cwd().join("foo.rs");
+
+    write(&file, content);
+    cmd.input(&file).arg("--test").edition("2024").env("RUST_BACKTRACE", "0");
+    let output = if success { cmd.run() } else { cmd.run_fail() };
+
+    assert_eq!(
+        output
+            .stdout_utf8()
+            .split("all doctests ran in ")
+            .last()
+            .is_some_and(|s| s.contains("; merged doctests compilation took")),
+        should_contain_compile_time,
+    );
+}
+
+fn main() {
+    // Checking with only successful merged doctests.
+    assert_presence_of_compilation_time_report(
+        "\
+//! ```
+//! let x = 12;
+//! ```",
+        true,
+        true,
+    );
+    // Checking with only failing merged doctests.
+    assert_presence_of_compilation_time_report(
+        "\
+//! ```
+//! panic!();
+//! ```",
+        false,
+        true,
+    );
+    // Checking with mix of successful doctests.
+    assert_presence_of_compilation_time_report(
+        "\
+//! ```
+//! let x = 12;
+//! ```
+//!
+//! ```compile_fail
+//! let x
+//! ```",
+        true,
+        true,
+    );
+    // Checking with mix of failing doctests.
+    assert_presence_of_compilation_time_report(
+        "\
+//! ```
+//! panic!();
+//! ```
+//!
+//! ```compile_fail
+//! let x
+//! ```",
+        false,
+        true,
+    );
+    // Checking with mix of failing doctests (v2).
+    assert_presence_of_compilation_time_report(
+        "\
+//! ```
+//! let x = 12;
+//! ```
+//!
+//! ```compile_fail
+//! let x = 12;
+//! ```",
+        false,
+        true,
+    );
+    // Checking with mix of failing doctests (v3).
+    assert_presence_of_compilation_time_report(
+        "\
+//! ```
+//! panic!();
+//! ```
+//!
+//! ```compile_fail
+//! let x = 12;
+//! ```",
+        false,
+        true,
+    );
+    // Checking with successful non-merged doctests.
+    assert_presence_of_compilation_time_report(
+        "\
+//! ```compile_fail
+//! let x
+//! ```",
+        true,
+        // If there is no merged doctests, then we should not display compilation time.
+        false,
+    );
+    // Checking with failing non-merged doctests.
+    assert_presence_of_compilation_time_report(
+        "\
+//! ```compile_fail
+//! let x = 12;
+//! ```",
+        false,
+        // If there is no merged doctests, then we should not display compilation time.
+        false,
+    );
+}
diff --git a/tests/run-make/doctests-merge/doctest-2024.stdout b/tests/run-make/doctests-merge/doctest-2024.stdout
index 7da08d68faae3..a7e139bbd23dc 100644
--- a/tests/run-make/doctests-merge/doctest-2024.stdout
+++ b/tests/run-make/doctests-merge/doctest-2024.stdout
@@ -5,3 +5,4 @@ test doctest.rs - init (line 8) ... ok
 
 test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
 
+all doctests ran in $TIME; merged doctests compilation took $TIME
diff --git a/tests/run-make/doctests-merge/rmake.rs b/tests/run-make/doctests-merge/rmake.rs
index 7893d4988ebba..f2a1e8e13ddfe 100644
--- a/tests/run-make/doctests-merge/rmake.rs
+++ b/tests/run-make/doctests-merge/rmake.rs
@@ -20,6 +20,8 @@ fn test_and_compare(input_file: &str, stdout_file: &str, edition: &str, dep: &Pa
         .expected_file(stdout_file)
         .actual_text("output", output.stdout_utf8())
         .normalize(r#"finished in \d+\.\d+s"#, "finished in $$TIME")
+        .normalize(r#"ran in \d+\.\d+s"#, "ran in $$TIME")
+        .normalize(r#"compilation took \d+\.\d+s"#, "compilation took $$TIME")
         .run();
 }
 
diff --git a/tests/rustdoc-ui/doctest/doctest-output.edition2015.stdout b/tests/rustdoc-ui/doctest/doctest-output.edition2015.stdout
index 0e2e30390ad93..2ff7174577e87 100644
--- a/tests/rustdoc-ui/doctest/doctest-output.edition2015.stdout
+++ b/tests/rustdoc-ui/doctest/doctest-output.edition2015.stdout
@@ -1,8 +1,8 @@
 
 running 3 tests
-test $DIR/doctest-output.rs - (line 12) ... ok
-test $DIR/doctest-output.rs - ExpandedStruct (line 28) ... ok
-test $DIR/doctest-output.rs - foo::bar (line 22) ... ok
+test $DIR/doctest-output.rs - (line 14) ... ok
+test $DIR/doctest-output.rs - ExpandedStruct (line 30) ... ok
+test $DIR/doctest-output.rs - foo::bar (line 24) ... ok
 
 test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
 
diff --git a/tests/rustdoc-ui/doctest/doctest-output.edition2024.stdout b/tests/rustdoc-ui/doctest/doctest-output.edition2024.stdout
index 0e2e30390ad93..20bfd7e7086eb 100644
--- a/tests/rustdoc-ui/doctest/doctest-output.edition2024.stdout
+++ b/tests/rustdoc-ui/doctest/doctest-output.edition2024.stdout
@@ -1,8 +1,9 @@
 
 running 3 tests
-test $DIR/doctest-output.rs - (line 12) ... ok
-test $DIR/doctest-output.rs - ExpandedStruct (line 28) ... ok
-test $DIR/doctest-output.rs - foo::bar (line 22) ... ok
+test $DIR/doctest-output.rs - (line 14) ... ok
+test $DIR/doctest-output.rs - ExpandedStruct (line 30) ... ok
+test $DIR/doctest-output.rs - foo::bar (line 24) ... ok
 
 test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
 
+all doctests ran in $TIME; merged doctests compilation took $TIME
diff --git a/tests/rustdoc-ui/doctest/doctest-output.rs b/tests/rustdoc-ui/doctest/doctest-output.rs
index 04bd1813b4c81..943f59e8b1565 100644
--- a/tests/rustdoc-ui/doctest/doctest-output.rs
+++ b/tests/rustdoc-ui/doctest/doctest-output.rs
@@ -7,6 +7,8 @@
 //@[edition2024]compile-flags:--test --test-args=--test-threads=1
 //@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
 //@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "ran in \d+\.\d+s" -> "ran in $$TIME"
+//@ normalize-stdout: "compilation took \d+\.\d+s" -> "compilation took $$TIME"
 //@ check-pass
 
 //! ```
diff --git a/tests/rustdoc-ui/doctest/merged-ignore-no_run.rs b/tests/rustdoc-ui/doctest/merged-ignore-no_run.rs
index 7dac64e6de420..f92bea74bfef4 100644
--- a/tests/rustdoc-ui/doctest/merged-ignore-no_run.rs
+++ b/tests/rustdoc-ui/doctest/merged-ignore-no_run.rs
@@ -2,6 +2,8 @@
 //@ compile-flags:--test --test-args=--test-threads=1
 //@ normalize-stdout: "tests/rustdoc-ui/doctest" -> "$$DIR"
 //@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout: "ran in \d+\.\d+s" -> "ran in $$TIME"
+//@ normalize-stdout: "compilation took \d+\.\d+s" -> "compilation took $$TIME"
 //@ check-pass
 
 /// ```ignore (test)
diff --git a/tests/rustdoc-ui/doctest/merged-ignore-no_run.stdout b/tests/rustdoc-ui/doctest/merged-ignore-no_run.stdout
index a32da0aeb9649..6714cdb0b8098 100644
--- a/tests/rustdoc-ui/doctest/merged-ignore-no_run.stdout
+++ b/tests/rustdoc-ui/doctest/merged-ignore-no_run.stdout
@@ -1,7 +1,8 @@
 
 running 2 tests
-test $DIR/merged-ignore-no_run.rs - ignored (line 7) ... ignored
-test $DIR/merged-ignore-no_run.rs - no_run (line 12) - compile ... ok
+test $DIR/merged-ignore-no_run.rs - ignored (line 9) ... ignored
+test $DIR/merged-ignore-no_run.rs - no_run (line 14) - compile ... ok
 
 test result: ok. 1 passed; 0 failed; 1 ignored; 0 measured; 0 filtered out; finished in $TIME
 
+all doctests ran in $TIME; merged doctests compilation took $TIME

From d13a5b0a6c12837007c51f229cb8c58b614cfb5b Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Fri, 26 Sep 2025 20:44:06 +0000
Subject: [PATCH 1450/1889] Handle self-loops too.

---
 compiler/rustc_mir_transform/src/jump_threading.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/jump_threading.rs b/compiler/rustc_mir_transform/src/jump_threading.rs
index c69660108d9a3..68298767e7fd8 100644
--- a/compiler/rustc_mir_transform/src/jump_threading.rs
+++ b/compiler/rustc_mir_transform/src/jump_threading.rs
@@ -842,9 +842,6 @@ fn maybe_loop_headers(body: &Body<'_>) -> DenseBitSet<BasicBlock> {
     let mut maybe_loop_headers = DenseBitSet::new_empty(body.basic_blocks.len());
     let mut visited = DenseBitSet::new_empty(body.basic_blocks.len());
     for (bb, bbdata) in traversal::postorder(body) {
-        let _new = visited.insert(bb);
-        debug_assert!(_new);
-
         // Post-order means we visit successors before the block for acyclic CFGs.
         // If the successor is not visited yet, consider it a loop header.
         for succ in bbdata.terminator().successors() {
@@ -852,6 +849,11 @@ fn maybe_loop_headers(body: &Body<'_>) -> DenseBitSet<BasicBlock> {
                 maybe_loop_headers.insert(succ);
             }
         }
+
+        // Only mark `bb` as visited after we checked the successors, in case we have a self-loop.
+        //     bb1: goto -> bb1;
+        let _new = visited.insert(bb);
+        debug_assert!(_new);
     }
 
     maybe_loop_headers

From e88fa086fb597041a207a9bb5df0654628d57b1a Mon Sep 17 00:00:00 2001
From: Aapo Alasuutari <aapo.alasuutari@gmail.com>
Date: Sat, 27 Sep 2025 01:11:01 +0300
Subject: [PATCH 1451/1889] move Reborrow to ops, fix fmt issues

---
 library/core/src/marker.rs                          | 8 --------
 library/core/src/ops/mod.rs                         | 2 +-
 library/core/src/ops/reborrow.rs                    | 8 +++++++-
 tests/ui/feature-gates/feature-gate-reborrow.rs     | 2 +-
 tests/ui/feature-gates/feature-gate-reborrow.stderr | 4 ++--
 tests/ui/reborrow/custom_mut.rs                     | 2 +-
 tests/ui/reborrow/custom_mut_coerce_shared.rs       | 3 +--
 tests/ui/reborrow/custom_mut_coerce_shared.stderr   | 4 ++--
 tests/ui/reborrow/option_mut.rs                     | 2 +-
 tests/ui/reborrow/option_mut.stderr                 | 4 ++--
 tests/ui/reborrow/pin_mut.rs                        | 2 +-
 tests/ui/reborrow/pin_mut.stderr                    | 4 ++--
 tests/ui/reborrow/pin_mut_coerce_shared.rs          | 1 -
 13 files changed, 21 insertions(+), 25 deletions(-)

diff --git a/library/core/src/marker.rs b/library/core/src/marker.rs
index d03d7a43469a7..fc715207d5dad 100644
--- a/library/core/src/marker.rs
+++ b/library/core/src/marker.rs
@@ -1364,11 +1364,3 @@ pub macro CoercePointee($item:item) {
 pub trait CoercePointeeValidated {
     /* compiler built-in */
 }
-
-/// Allows value to be reborrowed as exclusive, creating a copy of the value
-/// that disables the source for reads and writes for the lifetime of the copy.
-#[lang = "reborrow"]
-#[unstable(feature = "reborrow", issue = "145612")]
-pub trait Reborrow {
-    // Empty.
-}
diff --git a/library/core/src/ops/mod.rs b/library/core/src/ops/mod.rs
index 9814f5d5795c6..ab1ad407ee282 100644
--- a/library/core/src/ops/mod.rs
+++ b/library/core/src/ops/mod.rs
@@ -191,7 +191,7 @@ pub use self::range::{OneSidedRange, OneSidedRangeBound};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use self::range::{Range, RangeFrom, RangeFull, RangeTo};
 #[unstable(feature = "reborrow", issue = "145612")]
-pub use self::reborrow::CoerceShared;
+pub use self::reborrow::{CoerceShared, Reborrow};
 #[unstable(feature = "try_trait_v2_residual", issue = "91285")]
 pub use self::try_trait::Residual;
 #[unstable(feature = "try_trait_v2_yeet", issue = "96374")]
diff --git a/library/core/src/ops/reborrow.rs b/library/core/src/ops/reborrow.rs
index 90288f766d502..f83f4233a4de5 100644
--- a/library/core/src/ops/reborrow.rs
+++ b/library/core/src/ops/reborrow.rs
@@ -1,4 +1,10 @@
-use crate::marker::Reborrow;
+/// Allows value to be reborrowed as exclusive, creating a copy of the value
+/// that disables the source for reads and writes for the lifetime of the copy.
+#[lang = "reborrow"]
+#[unstable(feature = "reborrow", issue = "145612")]
+pub trait Reborrow {
+    // Empty.
+}
 
 /// Allows reborrowable value to be reborrowed as shared, creating a copy
 /// that disables the source for writes for the lifetime of the copy.
diff --git a/tests/ui/feature-gates/feature-gate-reborrow.rs b/tests/ui/feature-gates/feature-gate-reborrow.rs
index f016f6c6bfa59..96eecfb28a106 100644
--- a/tests/ui/feature-gates/feature-gate-reborrow.rs
+++ b/tests/ui/feature-gates/feature-gate-reborrow.rs
@@ -1,3 +1,3 @@
-use std::marker::Reborrow; //~ ERROR  use of unstable library feature `reborrow`
+use std::ops::Reborrow; //~ ERROR  use of unstable library feature `reborrow`
 
 fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-reborrow.stderr b/tests/ui/feature-gates/feature-gate-reborrow.stderr
index 5e3033f3bf1fe..1224909f564bc 100644
--- a/tests/ui/feature-gates/feature-gate-reborrow.stderr
+++ b/tests/ui/feature-gates/feature-gate-reborrow.stderr
@@ -1,8 +1,8 @@
 error[E0658]: use of unstable library feature `reborrow`
   --> $DIR/feature-gate-reborrow.rs:1:5
    |
-LL | use std::marker::Reborrow;
-   |     ^^^^^^^^^^^^^^^^^^^^^
+LL | use std::ops::Reborrow;
+   |     ^^^^^^^^^^^^^^^^^^
    |
    = note: see issue #145612 <https://github.com/rust-lang/rust/issues/145612> for more information
    = help: add `#![feature(reborrow)]` to the crate attributes to enable
diff --git a/tests/ui/reborrow/custom_mut.rs b/tests/ui/reborrow/custom_mut.rs
index b55a5e6faa3dc..1e7c469323822 100644
--- a/tests/ui/reborrow/custom_mut.rs
+++ b/tests/ui/reborrow/custom_mut.rs
@@ -1,5 +1,5 @@
 #![feature(reborrow)]
-use std::marker::Reborrow;
+use std::ops::Reborrow;
 
 struct CustomMut<'a, T>(&'a mut T);
 impl<'a, T> Reborrow for CustomMut<'a, T> {}
diff --git a/tests/ui/reborrow/custom_mut_coerce_shared.rs b/tests/ui/reborrow/custom_mut_coerce_shared.rs
index 28d802aabffe5..e2d25835c093a 100644
--- a/tests/ui/reborrow/custom_mut_coerce_shared.rs
+++ b/tests/ui/reborrow/custom_mut_coerce_shared.rs
@@ -1,6 +1,5 @@
 #![feature(reborrow)]
-use std::marker::Reborrow;
-use std::ops::CoerceShared;
+use std::ops::{CoerceShared, Reborrow};
 
 struct CustomMut<'a, T>(&'a mut T);
 impl<'a, T> Reborrow for CustomMut<'a, T> {}
diff --git a/tests/ui/reborrow/custom_mut_coerce_shared.stderr b/tests/ui/reborrow/custom_mut_coerce_shared.stderr
index 90d8a98160543..508651badc0a4 100644
--- a/tests/ui/reborrow/custom_mut_coerce_shared.stderr
+++ b/tests/ui/reborrow/custom_mut_coerce_shared.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/custom_mut_coerce_shared.rs:24:12
+  --> $DIR/custom_mut_coerce_shared.rs:23:12
    |
 LL |     method(a);
    |     ------ ^ expected `CustomRef<'_, ()>`, found `CustomMut<'_, ()>`
@@ -9,7 +9,7 @@ LL |     method(a);
    = note: expected struct `CustomRef<'_, ()>`
               found struct `CustomMut<'_, ()>`
 note: function defined here
-  --> $DIR/custom_mut_coerce_shared.rs:20:4
+  --> $DIR/custom_mut_coerce_shared.rs:19:4
    |
 LL | fn method(a: CustomRef<'_, ()>) {}
    |    ^^^^^^ --------------------
diff --git a/tests/ui/reborrow/option_mut.rs b/tests/ui/reborrow/option_mut.rs
index 60b7145a7b2e3..04d8301772de9 100644
--- a/tests/ui/reborrow/option_mut.rs
+++ b/tests/ui/reborrow/option_mut.rs
@@ -1,4 +1,4 @@
-fn method(a: Option<& mut ()>) {}
+fn method(a: Option<&mut ()>) {}
 
 fn main() {
     let a = Some(&mut ());
diff --git a/tests/ui/reborrow/option_mut.stderr b/tests/ui/reborrow/option_mut.stderr
index 497319d2e9035..d665e266079ea 100644
--- a/tests/ui/reborrow/option_mut.stderr
+++ b/tests/ui/reborrow/option_mut.stderr
@@ -11,8 +11,8 @@ LL |     let _ = method(a);
 note: consider changing this parameter type in function `method` to borrow instead if owning the value isn't necessary
   --> $DIR/option_mut.rs:1:14
    |
-LL | fn method(a: Option<& mut ()>) {}
-   |    ------    ^^^^^^^^^^^^^^^^ this parameter takes ownership of the value
+LL | fn method(a: Option<&mut ()>) {}
+   |    ------    ^^^^^^^^^^^^^^^ this parameter takes ownership of the value
    |    |
    |    in this function
 
diff --git a/tests/ui/reborrow/pin_mut.rs b/tests/ui/reborrow/pin_mut.rs
index 966106969943a..959cb14f8c9ad 100644
--- a/tests/ui/reborrow/pin_mut.rs
+++ b/tests/ui/reborrow/pin_mut.rs
@@ -1,6 +1,6 @@
 use std::pin::Pin;
 
-fn method(a: Pin<& mut ()>) {}
+fn method(a: Pin<&mut ()>) {}
 
 fn main() {
     let a = &mut ();
diff --git a/tests/ui/reborrow/pin_mut.stderr b/tests/ui/reborrow/pin_mut.stderr
index 8a10e2d9af269..64e3f603e1110 100644
--- a/tests/ui/reborrow/pin_mut.stderr
+++ b/tests/ui/reborrow/pin_mut.stderr
@@ -11,8 +11,8 @@ LL |     let _ = method(a);
 note: consider changing this parameter type in function `method` to borrow instead if owning the value isn't necessary
   --> $DIR/pin_mut.rs:3:14
    |
-LL | fn method(a: Pin<& mut ()>) {}
-   |    ------    ^^^^^^^^^^^^^ this parameter takes ownership of the value
+LL | fn method(a: Pin<&mut ()>) {}
+   |    ------    ^^^^^^^^^^^^ this parameter takes ownership of the value
    |    |
    |    in this function
 
diff --git a/tests/ui/reborrow/pin_mut_coerce_shared.rs b/tests/ui/reborrow/pin_mut_coerce_shared.rs
index fd529195fe01e..06af0b765d046 100644
--- a/tests/ui/reborrow/pin_mut_coerce_shared.rs
+++ b/tests/ui/reborrow/pin_mut_coerce_shared.rs
@@ -10,5 +10,4 @@ fn main() {
     //~| NOTE arguments to this function are incorrect
     //~| NOTE types differ in mutability
     //~| NOTE expected struct `Pin<&()>`
-    //~| NOTE    found struct `Pin<&mut ()>`
 }

From 413f095a85adb21331f6e64cf030ead124a6ba07 Mon Sep 17 00:00:00 2001
From: beepster4096 <19316085+beepster4096@users.noreply.github.com>
Date: Fri, 26 Sep 2025 15:37:19 -0700
Subject: [PATCH 1452/1889] this ice now requires -Zvalidate-mir

also slightly minimized the test
---
 tests/crashes/120016.rs | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/tests/crashes/120016.rs b/tests/crashes/120016.rs
index 7eda330e7adea..12f54dbc3d92c 100644
--- a/tests/crashes/120016.rs
+++ b/tests/crashes/120016.rs
@@ -1,19 +1,19 @@
 //@ known-bug: #120016
-//@ compile-flags: -Zcrate-attr=feature(const_async_blocks)
+//@ compile-flags: -Zvalidate-mir
 //@ edition: 2021
 
-#![feature(type_alias_impl_trait, const_async_blocks)]
+#![feature(type_alias_impl_trait)]
 
 struct Bug {
     V1: [(); {
-        type F = impl std::future::Future<Output = impl Sized>;
+        type F = impl Sized;
         #[define_opaque(F)]
         fn concrete_use() -> F {
-            //~^ ERROR to be a future that resolves to `u8`, but it resolves to `()`
-            async {}
+            //~^ ERROR
+            1i32
         }
-        let f: F = async { 1 };
-        //~^ ERROR `async` blocks are not allowed in constants
+        let f: F = 0u32;
+
         1
     }],
 }

From 4e9716fbc5fb0f85d838ee9350ade2be5c2a6201 Mon Sep 17 00:00:00 2001
From: Mark Rousskov <mark.simulacrum@gmail.com>
Date: Sun, 14 Sep 2025 10:30:29 -0400
Subject: [PATCH 1453/1889] Update CURRENT_RUSTC_VERSION post-bump

---
 compiler/rustc_feature/src/accepted.rs        |  6 +-
 compiler/rustc_feature/src/removed.rs         |  4 +-
 compiler/rustc_feature/src/unstable.rs        | 18 +++---
 library/alloc/src/boxed.rs                    |  2 +-
 library/alloc/src/collections/btree/map.rs    | 10 +--
 library/alloc/src/collections/btree/set.rs    | 10 +--
 library/alloc/src/rc.rs                       |  2 +-
 library/alloc/src/sync.rs                     |  2 +-
 library/core/src/any.rs                       |  2 +-
 library/core/src/array/mod.rs                 |  6 +-
 library/core/src/cell.rs                      |  4 +-
 library/core/src/iter/adapters/chain.rs       |  2 +-
 library/core/src/iter/adapters/mod.rs         |  2 +-
 library/core/src/iter/mod.rs                  |  2 +-
 library/core/src/iter/traits/accum.rs         |  2 +-
 library/core/src/net/ip_addr.rs               | 12 ++--
 library/core/src/num/int_macros.rs            | 56 ++++++++--------
 library/core/src/num/uint_macros.rs           | 64 +++++++++----------
 library/core/src/ptr/mod.rs                   |  4 +-
 library/core/src/str/mod.rs                   |  8 +--
 library/core/src/sync/atomic.rs               | 14 ++--
 library/core/src/time.rs                      |  8 +--
 library/std/src/ffi/os_str.rs                 |  2 +-
 library/std/src/os/windows/ffi.rs             |  2 +-
 library/std/src/panic.rs                      |  2 +-
 library/std/src/path.rs                       | 24 +++----
 .../src/platform-support/apple-ios-macabi.md  |  2 +-
 .../rustc/src/platform-support/apple-ios.md   |  2 +-
 .../feature-gate-sanitize.stderr              |  2 +-
 29 files changed, 138 insertions(+), 138 deletions(-)

diff --git a/compiler/rustc_feature/src/accepted.rs b/compiler/rustc_feature/src/accepted.rs
index 6af4cfb0e562e..364a1202b05c2 100644
--- a/compiler/rustc_feature/src/accepted.rs
+++ b/compiler/rustc_feature/src/accepted.rs
@@ -205,7 +205,7 @@ declare_features! (
     (accepted, extended_key_value_attributes, "1.54.0", Some(78835)),
     /// Allows using `aapcs`, `efiapi`, `sysv64` and `win64` as calling conventions
     /// for functions with varargs.
-    (accepted, extended_varargs_abi_support, "CURRENT_RUSTC_VERSION", Some(100189)),
+    (accepted, extended_varargs_abi_support, "1.91.0", Some(100189)),
     /// Allows resolving absolute paths as paths from other crates.
     (accepted, extern_absolute_paths, "1.30.0", Some(44660)),
     /// Allows `extern crate foo as bar;`. This puts `bar` into extern prelude.
@@ -400,7 +400,7 @@ declare_features! (
     /// Allows use of `&foo[a..b]` as a slicing syntax.
     (accepted, slicing_syntax, "1.0.0", None),
     /// Allows use of `sse4a` target feature.
-    (accepted, sse4a_target_feature, "CURRENT_RUSTC_VERSION", Some(44839)),
+    (accepted, sse4a_target_feature, "1.91.0", Some(44839)),
     /// Allows elision of `'static` lifetimes in `static`s and `const`s.
     (accepted, static_in_const, "1.17.0", Some(35897)),
     /// Allows the definition recursive static items.
@@ -414,7 +414,7 @@ declare_features! (
     /// Allows the use of `#[target_feature]` on safe functions.
     (accepted, target_feature_11, "1.86.0", Some(69098)),
     /// Allows use of `tbm` target feature.
-    (accepted, tbm_target_feature, "CURRENT_RUSTC_VERSION", Some(44839)),
+    (accepted, tbm_target_feature, "1.91.0", Some(44839)),
     /// Allows `fn main()` with return types which implements `Termination` (RFC 1937).
     (accepted, termination_trait, "1.26.0", Some(43301)),
     /// Allows `#[test]` functions where the return type implements `Termination` (RFC 1937).
diff --git a/compiler/rustc_feature/src/removed.rs b/compiler/rustc_feature/src/removed.rs
index e37fc6b7bfcce..32115535e9941 100644
--- a/compiler/rustc_feature/src/removed.rs
+++ b/compiler/rustc_feature/src/removed.rs
@@ -192,7 +192,7 @@ declare_features! (
     (removed, no_debug, "1.43.0", Some(29721), Some("removed due to lack of demand"), 69667),
     // Allows the use of `no_sanitize` attribute.
     /// The feature was renamed to `sanitize` and the attribute to `#[sanitize(xyz = "on|off")]`
-    (removed, no_sanitize, "CURRENT_RUSTC_VERSION", Some(39699), Some(r#"renamed to sanitize(xyz = "on|off")"#), 142681),
+    (removed, no_sanitize, "1.91.0", Some(39699), Some(r#"renamed to sanitize(xyz = "on|off")"#), 142681),
     /// Note: this feature was previously recorded in a separate
     /// `STABLE_REMOVED` list because it, uniquely, was once stable but was
     /// then removed. But there was no utility storing it separately, so now
@@ -203,7 +203,7 @@ declare_features! (
     (removed, object_safe_for_dispatch, "1.83.0", Some(43561),
      Some("renamed to `dyn_compatible_for_dispatch`"), 131511),
     /// Allows using `#[omit_gdb_pretty_printer_section]`.
-    (removed, omit_gdb_pretty_printer_section, "CURRENT_RUSTC_VERSION", None, None, 144738),
+    (removed, omit_gdb_pretty_printer_section, "1.91.0", None, None, 144738),
     /// Allows using `#[on_unimplemented(..)]` on traits.
     /// (Moved to `rustc_attrs`.)
     (removed, on_unimplemented, "1.40.0", None, None, 65794),
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 93e5588146e14..6ef0df72365ec 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -327,7 +327,7 @@ declare_features! (
     (unstable, m68k_target_feature, "1.85.0", Some(134328)),
     (unstable, mips_target_feature, "1.27.0", Some(44839)),
     (unstable, movrs_target_feature, "1.88.0", Some(137976)),
-    (unstable, nvptx_target_feature, "CURRENT_RUSTC_VERSION", Some(44839)),
+    (unstable, nvptx_target_feature, "1.91.0", Some(44839)),
     (unstable, powerpc_target_feature, "1.27.0", Some(44839)),
     (unstable, prfchw_target_feature, "1.78.0", Some(44839)),
     (unstable, riscv_target_feature, "1.45.0", Some(44839)),
@@ -471,7 +471,7 @@ declare_features! (
     /// Allows deref patterns.
     (incomplete, deref_patterns, "1.79.0", Some(87121)),
     /// Allows deriving the From trait on single-field structs.
-    (unstable, derive_from, "CURRENT_RUSTC_VERSION", Some(144889)),
+    (unstable, derive_from, "1.91.0", Some(144889)),
     /// Tells rustdoc to automatically generate `#[doc(cfg(...))]`.
     (unstable, doc_auto_cfg, "1.58.0", Some(43781)),
     /// Allows `#[doc(cfg(...))]`.
@@ -481,7 +481,7 @@ declare_features! (
     /// Allows `#[doc(masked)]`.
     (unstable, doc_masked, "1.21.0", Some(44027)),
     /// Allows features to allow target_feature to better interact with traits.
-    (incomplete, effective_target_features, "CURRENT_RUSTC_VERSION", Some(143352)),
+    (incomplete, effective_target_features, "1.91.0", Some(143352)),
     /// Allows the .use postfix syntax `x.use` and use closures `use |x| { ... }`
     (incomplete, ergonomic_clones, "1.87.0", Some(132290)),
     /// Allows exhaustive pattern matching on types that contain uninhabited types.
@@ -554,9 +554,9 @@ declare_features! (
     /// Allows fused `loop`/`match` for direct intraprocedural jumps.
     (incomplete, loop_match, "1.90.0", Some(132306)),
     /// Allow `macro_rules!` attribute rules
-    (unstable, macro_attr, "CURRENT_RUSTC_VERSION", Some(83527)),
+    (unstable, macro_attr, "1.91.0", Some(83527)),
     /// Allow `macro_rules!` derive rules
-    (unstable, macro_derive, "CURRENT_RUSTC_VERSION", Some(143549)),
+    (unstable, macro_derive, "1.91.0", Some(143549)),
     /// Give access to additional metadata about declarative macro meta-variables.
     (unstable, macro_metavar_expr, "1.61.0", Some(83527)),
     /// Provides a way to concatenate identifiers using metavariable expressions.
@@ -613,7 +613,7 @@ declare_features! (
     (unstable, proc_macro_hygiene, "1.30.0", Some(54727)),
     /// Allows the use of raw-dylibs on ELF platforms
     (incomplete, raw_dylib_elf, "1.87.0", Some(135694)),
-    (unstable, reborrow, "CURRENT_RUSTC_VERSION", Some(145612)),
+    (unstable, reborrow, "1.91.0", Some(145612)),
     /// 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
@@ -627,13 +627,13 @@ declare_features! (
     /// Allows `extern "rust-cold"`.
     (unstable, rust_cold_cc, "1.63.0", Some(97544)),
     /// Allows the use of the `sanitize` attribute.
-    (unstable, sanitize, "CURRENT_RUSTC_VERSION", Some(39699)),
+    (unstable, sanitize, "1.91.0", Some(39699)),
     /// Allows the use of SIMD types in functions declared in `extern` blocks.
     (unstable, simd_ffi, "1.0.0", Some(27731)),
     /// Allows specialization of implementations (RFC 1210).
     (incomplete, specialization, "1.7.0", Some(31844)),
     /// Allows using `#[rustc_align_static(...)]` on static items.
-    (unstable, static_align, "CURRENT_RUSTC_VERSION", Some(146177)),
+    (unstable, static_align, "1.91.0", Some(146177)),
     /// Allows attributes on expressions and non-item statements.
     (unstable, stmt_expr_attributes, "1.6.0", Some(15701)),
     /// Allows lints part of the strict provenance effort.
@@ -645,7 +645,7 @@ declare_features! (
     /// Allows subtrait items to shadow supertrait items.
     (unstable, supertrait_item_shadowing, "1.86.0", Some(89151)),
     /// Allows the use of target_feature when a function is marked inline(always).
-    (unstable, target_feature_inline_always, "CURRENT_RUSTC_VERSION", Some(145574)),
+    (unstable, target_feature_inline_always, "1.91.0", Some(145574)),
     /// Allows using `#[thread_local]` on `static` items.
     (unstable, thread_local, "1.0.0", Some(29594)),
     /// Allows defining `trait X = A + B;` alias items.
diff --git a/library/alloc/src/boxed.rs b/library/alloc/src/boxed.rs
index 1c549f7b6ba16..5a63d90b95fa0 100644
--- a/library/alloc/src/boxed.rs
+++ b/library/alloc/src/boxed.rs
@@ -1706,7 +1706,7 @@ impl Default for Box<str> {
 }
 
 #[cfg(not(no_global_oom_handling))]
-#[stable(feature = "pin_default_impls", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "pin_default_impls", since = "1.91.0")]
 impl<T> Default for Pin<Box<T>>
 where
     T: ?Sized,
diff --git a/library/alloc/src/collections/btree/map.rs b/library/alloc/src/collections/btree/map.rs
index e3b53b2fe291a..9dfbbd913225a 100644
--- a/library/alloc/src/collections/btree/map.rs
+++ b/library/alloc/src/collections/btree/map.rs
@@ -1456,7 +1456,7 @@ impl<K, V, A: Allocator + Clone> BTreeMap<K, V, A> {
     /// assert_eq!(low.keys().copied().collect::<Vec<_>>(), [0, 1, 2, 3]);
     /// assert_eq!(high.keys().copied().collect::<Vec<_>>(), [4, 5, 6, 7]);
     /// ```
-    #[stable(feature = "btree_extract_if", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "btree_extract_if", since = "1.91.0")]
     pub fn extract_if<F, R>(&mut self, range: R, pred: F) -> ExtractIf<'_, K, V, R, F, A>
     where
         K: Ord,
@@ -1943,7 +1943,7 @@ impl<K, V> Default for Values<'_, K, V> {
 }
 
 /// An iterator produced by calling `extract_if` on BTreeMap.
-#[stable(feature = "btree_extract_if", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "btree_extract_if", since = "1.91.0")]
 #[must_use = "iterators are lazy and do nothing unless consumed"]
 pub struct ExtractIf<
     'a,
@@ -1976,7 +1976,7 @@ pub(super) struct ExtractIfInner<'a, K, V, R> {
     range: R,
 }
 
-#[stable(feature = "btree_extract_if", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "btree_extract_if", since = "1.91.0")]
 impl<K, V, R, F, A> fmt::Debug for ExtractIf<'_, K, V, R, F, A>
 where
     K: fmt::Debug,
@@ -1988,7 +1988,7 @@ where
     }
 }
 
-#[stable(feature = "btree_extract_if", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "btree_extract_if", since = "1.91.0")]
 impl<K, V, R, F, A: Allocator + Clone> Iterator for ExtractIf<'_, K, V, R, F, A>
 where
     K: PartialOrd,
@@ -2062,7 +2062,7 @@ impl<'a, K, V, R> ExtractIfInner<'a, K, V, R> {
     }
 }
 
-#[stable(feature = "btree_extract_if", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "btree_extract_if", since = "1.91.0")]
 impl<K, V, R, F> FusedIterator for ExtractIf<'_, K, V, R, F>
 where
     K: PartialOrd,
diff --git a/library/alloc/src/collections/btree/set.rs b/library/alloc/src/collections/btree/set.rs
index e6b0a1f632321..6e6996bcbd69b 100644
--- a/library/alloc/src/collections/btree/set.rs
+++ b/library/alloc/src/collections/btree/set.rs
@@ -1218,7 +1218,7 @@ impl<T, A: Allocator + Clone> BTreeSet<T, A> {
     /// assert_eq!(low.into_iter().collect::<Vec<_>>(), [0, 1, 2, 3]);
     /// assert_eq!(high.into_iter().collect::<Vec<_>>(), [4, 5, 6, 7]);
     /// ```
-    #[stable(feature = "btree_extract_if", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "btree_extract_if", since = "1.91.0")]
     pub fn extract_if<F, R>(&mut self, range: R, pred: F) -> ExtractIf<'_, T, R, F, A>
     where
         T: Ord,
@@ -1553,7 +1553,7 @@ impl<'a, T, A: Allocator + Clone> IntoIterator for &'a BTreeSet<T, A> {
 }
 
 /// An iterator produced by calling `extract_if` on BTreeSet.
-#[stable(feature = "btree_extract_if", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "btree_extract_if", since = "1.91.0")]
 #[must_use = "iterators are lazy and do nothing unless consumed"]
 pub struct ExtractIf<
     'a,
@@ -1568,7 +1568,7 @@ pub struct ExtractIf<
     alloc: A,
 }
 
-#[stable(feature = "btree_extract_if", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "btree_extract_if", since = "1.91.0")]
 impl<T, R, F, A> fmt::Debug for ExtractIf<'_, T, R, F, A>
 where
     T: fmt::Debug,
@@ -1581,7 +1581,7 @@ where
     }
 }
 
-#[stable(feature = "btree_extract_if", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "btree_extract_if", since = "1.91.0")]
 impl<T, R, F, A: Allocator + Clone> Iterator for ExtractIf<'_, T, R, F, A>
 where
     T: PartialOrd,
@@ -1601,7 +1601,7 @@ where
     }
 }
 
-#[stable(feature = "btree_extract_if", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "btree_extract_if", since = "1.91.0")]
 impl<T, R, F, A: Allocator + Clone> FusedIterator for ExtractIf<'_, T, R, F, A>
 where
     T: PartialOrd,
diff --git a/library/alloc/src/rc.rs b/library/alloc/src/rc.rs
index aed3357afbf4b..627e5c7f976a5 100644
--- a/library/alloc/src/rc.rs
+++ b/library/alloc/src/rc.rs
@@ -2377,7 +2377,7 @@ impl<T> Default for Rc<[T]> {
 }
 
 #[cfg(not(no_global_oom_handling))]
-#[stable(feature = "pin_default_impls", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "pin_default_impls", since = "1.91.0")]
 impl<T> Default for Pin<Rc<T>>
 where
     T: ?Sized,
diff --git a/library/alloc/src/sync.rs b/library/alloc/src/sync.rs
index a466b74944c5d..3a8695d34a80b 100644
--- a/library/alloc/src/sync.rs
+++ b/library/alloc/src/sync.rs
@@ -3636,7 +3636,7 @@ impl<T> Default for Arc<[T]> {
 }
 
 #[cfg(not(no_global_oom_handling))]
-#[stable(feature = "pin_default_impls", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "pin_default_impls", since = "1.91.0")]
 impl<T> Default for Pin<Arc<T>>
 where
     T: ?Sized,
diff --git a/library/core/src/any.rs b/library/core/src/any.rs
index 76ea2d18a82f4..3ab95438c3ff3 100644
--- a/library/core/src/any.rs
+++ b/library/core/src/any.rs
@@ -774,7 +774,7 @@ impl TypeId {
     /// ```
     #[must_use]
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_stable(feature = "const_type_id", since = "CURRENT_RUSTC_VERSION")]
+    #[rustc_const_stable(feature = "const_type_id", since = "1.91.0")]
     pub const fn of<T: ?Sized + 'static>() -> TypeId {
         const { intrinsics::type_id::<T>() }
     }
diff --git a/library/core/src/array/mod.rs b/library/core/src/array/mod.rs
index d713e575b58d3..0dc10758a8560 100644
--- a/library/core/src/array/mod.rs
+++ b/library/core/src/array/mod.rs
@@ -49,7 +49,7 @@ pub use iter::IntoIter;
 /// ```
 #[inline]
 #[must_use = "cloning is often expensive and is not expected to have side effects"]
-#[stable(feature = "array_repeat", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "array_repeat", since = "1.91.0")]
 pub fn repeat<T: Clone, const N: usize>(val: T) -> [T; N] {
     from_trusted_iterator(repeat_n(val, N))
 }
@@ -627,7 +627,7 @@ impl<T, const N: usize> [T; N] {
     /// assert_eq!(strings.len(), 3);
     /// ```
     #[stable(feature = "array_methods", since = "1.77.0")]
-    #[rustc_const_stable(feature = "const_array_each_ref", since = "CURRENT_RUSTC_VERSION")]
+    #[rustc_const_stable(feature = "const_array_each_ref", since = "1.91.0")]
     pub const fn each_ref(&self) -> [&T; N] {
         let mut buf = [null::<T>(); N];
 
@@ -658,7 +658,7 @@ impl<T, const N: usize> [T; N] {
     /// assert_eq!(floats, [0.0, 2.7, -1.0]);
     /// ```
     #[stable(feature = "array_methods", since = "1.77.0")]
-    #[rustc_const_stable(feature = "const_array_each_ref", since = "CURRENT_RUSTC_VERSION")]
+    #[rustc_const_stable(feature = "const_array_each_ref", since = "1.91.0")]
     pub const fn each_mut(&mut self) -> [&mut T; N] {
         let mut buf = [null_mut::<T>(); N];
 
diff --git a/library/core/src/cell.rs b/library/core/src/cell.rs
index 7d4a66640b106..6aadb7a86cd19 100644
--- a/library/core/src/cell.rs
+++ b/library/core/src/cell.rs
@@ -705,8 +705,8 @@ impl<T, const N: usize> Cell<[T; N]> {
     /// let cell_array: &Cell<[i32; 3]> = Cell::from_mut(&mut array);
     /// let array_cell: &[Cell<i32>; 3] = cell_array.as_array_of_cells();
     /// ```
-    #[stable(feature = "as_array_of_cells", since = "CURRENT_RUSTC_VERSION")]
-    #[rustc_const_stable(feature = "as_array_of_cells", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "as_array_of_cells", since = "1.91.0")]
+    #[rustc_const_stable(feature = "as_array_of_cells", since = "1.91.0")]
     pub const fn as_array_of_cells(&self) -> &[Cell<T>; N] {
         // SAFETY: `Cell<T>` has the same memory layout as `T`.
         unsafe { &*(self as *const Cell<[T; N]> as *const [Cell<T>; N]) }
diff --git a/library/core/src/iter/adapters/chain.rs b/library/core/src/iter/adapters/chain.rs
index 3ebdf7b472796..0ece54554d464 100644
--- a/library/core/src/iter/adapters/chain.rs
+++ b/library/core/src/iter/adapters/chain.rs
@@ -60,7 +60,7 @@ impl<A, B> Chain<A, B> {
 /// assert_eq!(iter.next(), Some(6));
 /// assert_eq!(iter.next(), None);
 /// ```
-#[stable(feature = "iter_chain", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "iter_chain", since = "1.91.0")]
 pub fn chain<A, B>(a: A, b: B) -> Chain<A::IntoIter, B::IntoIter>
 where
     A: IntoIterator,
diff --git a/library/core/src/iter/adapters/mod.rs b/library/core/src/iter/adapters/mod.rs
index 6c6de0a4e5c98..1ff5093922b6d 100644
--- a/library/core/src/iter/adapters/mod.rs
+++ b/library/core/src/iter/adapters/mod.rs
@@ -32,7 +32,7 @@ mod zip;
 pub use self::array_chunks::ArrayChunks;
 #[unstable(feature = "std_internals", issue = "none")]
 pub use self::by_ref_sized::ByRefSized;
-#[stable(feature = "iter_chain", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "iter_chain", since = "1.91.0")]
 pub use self::chain::chain;
 #[stable(feature = "iter_cloned", since = "1.1.0")]
 pub use self::cloned::Cloned;
diff --git a/library/core/src/iter/mod.rs b/library/core/src/iter/mod.rs
index bc07324f5204c..c7e1c4ef767ba 100644
--- a/library/core/src/iter/mod.rs
+++ b/library/core/src/iter/mod.rs
@@ -404,7 +404,7 @@ pub use self::adapters::StepBy;
 pub use self::adapters::TrustedRandomAccess;
 #[unstable(feature = "trusted_random_access", issue = "none")]
 pub use self::adapters::TrustedRandomAccessNoCoerce;
-#[stable(feature = "iter_chain", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "iter_chain", since = "1.91.0")]
 pub use self::adapters::chain;
 pub(crate) use self::adapters::try_process;
 #[stable(feature = "iter_zip", since = "1.59.0")]
diff --git a/library/core/src/iter/traits/accum.rs b/library/core/src/iter/traits/accum.rs
index 3b805139ded17..375b5ef52859f 100644
--- a/library/core/src/iter/traits/accum.rs
+++ b/library/core/src/iter/traits/accum.rs
@@ -148,7 +148,7 @@ macro_rules! saturating_integer_sum_product {
         saturating_integer_sum_product!(@impls Saturating(0), Saturating(1),
                 "The short-circuiting behavior of this implementation is unspecified. If you care about \
                 short-circuiting, use [`Iterator::fold`] directly.",
-                #[stable(feature = "saturating_iter_arith", since = "CURRENT_RUSTC_VERSION")],
+                #[stable(feature = "saturating_iter_arith", since = "1.91.0")],
                 $(Saturating<$a>)*);
     );
 }
diff --git a/library/core/src/net/ip_addr.rs b/library/core/src/net/ip_addr.rs
index 9779fb8fe4d5e..a1bfd774710d5 100644
--- a/library/core/src/net/ip_addr.rs
+++ b/library/core/src/net/ip_addr.rs
@@ -631,8 +631,8 @@ impl Ipv4Addr {
     /// let addr = Ipv4Addr::from_octets([13u8, 12u8, 11u8, 10u8]);
     /// assert_eq!(Ipv4Addr::new(13, 12, 11, 10), addr);
     /// ```
-    #[stable(feature = "ip_from", since = "CURRENT_RUSTC_VERSION")]
-    #[rustc_const_stable(feature = "ip_from", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "ip_from", since = "1.91.0")]
+    #[rustc_const_stable(feature = "ip_from", since = "1.91.0")]
     #[must_use]
     #[inline]
     pub const fn from_octets(octets: [u8; 4]) -> Ipv4Addr {
@@ -1478,8 +1478,8 @@ impl Ipv6Addr {
     ///     addr
     /// );
     /// ```
-    #[stable(feature = "ip_from", since = "CURRENT_RUSTC_VERSION")]
-    #[rustc_const_stable(feature = "ip_from", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "ip_from", since = "1.91.0")]
+    #[rustc_const_stable(feature = "ip_from", since = "1.91.0")]
     #[must_use]
     #[inline]
     pub const fn from_segments(segments: [u16; 8]) -> Ipv6Addr {
@@ -2043,8 +2043,8 @@ impl Ipv6Addr {
     ///     addr
     /// );
     /// ```
-    #[stable(feature = "ip_from", since = "CURRENT_RUSTC_VERSION")]
-    #[rustc_const_stable(feature = "ip_from", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "ip_from", since = "1.91.0")]
+    #[rustc_const_stable(feature = "ip_from", since = "1.91.0")]
     #[must_use]
     #[inline]
     pub const fn from_octets(octets: [u8; 16]) -> Ipv6Addr {
diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs
index 0d80c40fb2363..c3460a6409069 100644
--- a/library/core/src/num/int_macros.rs
+++ b/library/core/src/num/int_macros.rs
@@ -519,8 +519,8 @@ macro_rules! int_impl {
         /// ```should_panic
         #[doc = concat!("let _ = (", stringify!($SelfT), "::MAX - 2).strict_add(3);")]
         /// ```
-        #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
-        #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "strict_overflow_ops", since = "1.91.0")]
+        #[rustc_const_stable(feature = "strict_overflow_ops", since = "1.91.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
@@ -609,8 +609,8 @@ macro_rules! int_impl {
         /// ```should_panic
         #[doc = concat!("let _ = (", stringify!($SelfT), "::MAX - 2).strict_add_unsigned(3);")]
         /// ```
-        #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
-        #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "strict_overflow_ops", since = "1.91.0")]
+        #[rustc_const_stable(feature = "strict_overflow_ops", since = "1.91.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
@@ -659,8 +659,8 @@ macro_rules! int_impl {
         /// ```should_panic
         #[doc = concat!("let _ = (", stringify!($SelfT), "::MIN + 2).strict_sub(3);")]
         /// ```
-        #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
-        #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "strict_overflow_ops", since = "1.91.0")]
+        #[rustc_const_stable(feature = "strict_overflow_ops", since = "1.91.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
@@ -749,8 +749,8 @@ macro_rules! int_impl {
         /// ```should_panic
         #[doc = concat!("let _ = (", stringify!($SelfT), "::MIN + 2).strict_sub_unsigned(3);")]
         /// ```
-        #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
-        #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "strict_overflow_ops", since = "1.91.0")]
+        #[rustc_const_stable(feature = "strict_overflow_ops", since = "1.91.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
@@ -799,8 +799,8 @@ macro_rules! int_impl {
         /// ``` should_panic
         #[doc = concat!("let _ = ", stringify!($SelfT), "::MAX.strict_mul(2);")]
         /// ```
-        #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
-        #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "strict_overflow_ops", since = "1.91.0")]
+        #[rustc_const_stable(feature = "strict_overflow_ops", since = "1.91.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
@@ -906,8 +906,8 @@ macro_rules! int_impl {
         /// ```should_panic
         #[doc = concat!("let _ = (1", stringify!($SelfT), ").strict_div(0);")]
         /// ```
-        #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
-        #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "strict_overflow_ops", since = "1.91.0")]
+        #[rustc_const_stable(feature = "strict_overflow_ops", since = "1.91.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
@@ -973,8 +973,8 @@ macro_rules! int_impl {
         /// ```should_panic
         #[doc = concat!("let _ = (1", stringify!($SelfT), ").strict_div_euclid(0);")]
         /// ```
-        #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
-        #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "strict_overflow_ops", since = "1.91.0")]
+        #[rustc_const_stable(feature = "strict_overflow_ops", since = "1.91.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
@@ -1139,8 +1139,8 @@ macro_rules! int_impl {
         /// ```should_panic
         #[doc = concat!("let _ = ", stringify!($SelfT), "::MIN.strict_rem(-1);")]
         /// ```
-        #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
-        #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "strict_overflow_ops", since = "1.91.0")]
+        #[rustc_const_stable(feature = "strict_overflow_ops", since = "1.91.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
@@ -1205,8 +1205,8 @@ macro_rules! int_impl {
         /// ```should_panic
         #[doc = concat!("let _ = ", stringify!($SelfT), "::MIN.strict_rem_euclid(-1);")]
         /// ```
-        #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
-        #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "strict_overflow_ops", since = "1.91.0")]
+        #[rustc_const_stable(feature = "strict_overflow_ops", since = "1.91.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
@@ -1286,8 +1286,8 @@ macro_rules! int_impl {
         /// ```should_panic
         #[doc = concat!("let _ = ", stringify!($SelfT), "::MIN.strict_neg();")]
         /// ```
-        #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
-        #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "strict_overflow_ops", since = "1.91.0")]
+        #[rustc_const_stable(feature = "strict_overflow_ops", since = "1.91.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
@@ -1342,8 +1342,8 @@ macro_rules! int_impl {
         /// ```should_panic
         #[doc = concat!("let _ = 0x1", stringify!($SelfT), ".strict_shl(129);")]
         /// ```
-        #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
-        #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "strict_overflow_ops", since = "1.91.0")]
+        #[rustc_const_stable(feature = "strict_overflow_ops", since = "1.91.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
@@ -1517,8 +1517,8 @@ macro_rules! int_impl {
         /// ```should_panic
         #[doc = concat!("let _ = 0x10", stringify!($SelfT), ".strict_shr(128);")]
         /// ```
-        #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
-        #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "strict_overflow_ops", since = "1.91.0")]
+        #[rustc_const_stable(feature = "strict_overflow_ops", since = "1.91.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
@@ -1693,8 +1693,8 @@ macro_rules! int_impl {
         /// ```should_panic
         #[doc = concat!("let _ = ", stringify!($SelfT), "::MIN.strict_abs();")]
         /// ```
-        #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
-        #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "strict_overflow_ops", since = "1.91.0")]
+        #[rustc_const_stable(feature = "strict_overflow_ops", since = "1.91.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
@@ -1762,8 +1762,8 @@ macro_rules! int_impl {
         /// ```should_panic
         #[doc = concat!("let _ = ", stringify!($SelfT), "::MAX.strict_pow(2);")]
         /// ```
-        #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
-        #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "strict_overflow_ops", since = "1.91.0")]
+        #[rustc_const_stable(feature = "strict_overflow_ops", since = "1.91.0")]
         #[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 d68c7be9865b1..752498bfbd815 100644
--- a/library/core/src/num/uint_macros.rs
+++ b/library/core/src/num/uint_macros.rs
@@ -667,8 +667,8 @@ macro_rules! uint_impl {
         /// ```should_panic
         #[doc = concat!("let _ = (", stringify!($SelfT), "::MAX - 2).strict_add(3);")]
         /// ```
-        #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
-        #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "strict_overflow_ops", since = "1.91.0")]
+        #[rustc_const_stable(feature = "strict_overflow_ops", since = "1.91.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
@@ -762,8 +762,8 @@ macro_rules! uint_impl {
         /// ```should_panic
         #[doc = concat!("let _ = (", stringify!($SelfT), "::MAX - 2).strict_add_signed(3);")]
         /// ```
-        #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
-        #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "strict_overflow_ops", since = "1.91.0")]
+        #[rustc_const_stable(feature = "strict_overflow_ops", since = "1.91.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
@@ -821,8 +821,8 @@ macro_rules! uint_impl {
         /// ```should_panic
         #[doc = concat!("let _ = 0", stringify!($SelfT), ".strict_sub(1);")]
         /// ```
-        #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
-        #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "strict_overflow_ops", since = "1.91.0")]
+        #[rustc_const_stable(feature = "strict_overflow_ops", since = "1.91.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
@@ -946,8 +946,8 @@ macro_rules! uint_impl {
         /// ```should_panic
         #[doc = concat!("let _ = (", stringify!($SelfT), "::MAX).strict_sub_signed(-1);")]
         /// ```
-        #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
-        #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "strict_overflow_ops", since = "1.91.0")]
+        #[rustc_const_stable(feature = "strict_overflow_ops", since = "1.91.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
@@ -1002,8 +1002,8 @@ macro_rules! uint_impl {
             "::MAX), Some(0));"
         )]
         /// ```
-        #[stable(feature = "unsigned_signed_diff", since = "CURRENT_RUSTC_VERSION")]
-        #[rustc_const_stable(feature = "unsigned_signed_diff", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "unsigned_signed_diff", since = "1.91.0")]
+        #[rustc_const_stable(feature = "unsigned_signed_diff", since = "1.91.0")]
         #[inline]
         pub const fn checked_signed_diff(self, rhs: Self) -> Option<$SignedT> {
             let res = self.wrapping_sub(rhs) as $SignedT;
@@ -1055,8 +1055,8 @@ macro_rules! uint_impl {
         /// ``` should_panic
         #[doc = concat!("let _ = ", stringify!($SelfT), "::MAX.strict_mul(2);")]
         /// ```
-        #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
-        #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "strict_overflow_ops", since = "1.91.0")]
+        #[rustc_const_stable(feature = "strict_overflow_ops", since = "1.91.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
@@ -1151,8 +1151,8 @@ macro_rules! uint_impl {
         /// ```should_panic
         #[doc = concat!("let _ = (1", stringify!($SelfT), ").strict_div(0);")]
         /// ```
-        #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
-        #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "strict_overflow_ops", since = "1.91.0")]
+        #[rustc_const_stable(feature = "strict_overflow_ops", since = "1.91.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline(always)]
@@ -1205,8 +1205,8 @@ macro_rules! uint_impl {
         /// ```should_panic
         #[doc = concat!("let _ = (1", stringify!($SelfT), ").strict_div_euclid(0);")]
         /// ```
-        #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
-        #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "strict_overflow_ops", since = "1.91.0")]
+        #[rustc_const_stable(feature = "strict_overflow_ops", since = "1.91.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline(always)]
@@ -1353,8 +1353,8 @@ macro_rules! uint_impl {
         /// ```should_panic
         #[doc = concat!("let _ = 5", stringify!($SelfT), ".strict_rem(0);")]
         /// ```
-        #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
-        #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "strict_overflow_ops", since = "1.91.0")]
+        #[rustc_const_stable(feature = "strict_overflow_ops", since = "1.91.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline(always)]
@@ -1409,8 +1409,8 @@ macro_rules! uint_impl {
         /// ```should_panic
         #[doc = concat!("let _ = 5", stringify!($SelfT), ".strict_rem_euclid(0);")]
         /// ```
-        #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
-        #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "strict_overflow_ops", since = "1.91.0")]
+        #[rustc_const_stable(feature = "strict_overflow_ops", since = "1.91.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline(always)]
@@ -1694,8 +1694,8 @@ macro_rules! uint_impl {
         /// ```should_panic
         #[doc = concat!("let _ = 1", stringify!($SelfT), ".strict_neg();")]
         /// ```
-        #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
-        #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "strict_overflow_ops", since = "1.91.0")]
+        #[rustc_const_stable(feature = "strict_overflow_ops", since = "1.91.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
@@ -1750,8 +1750,8 @@ macro_rules! uint_impl {
         /// ```should_panic
         #[doc = concat!("let _ = 0x10", stringify!($SelfT), ".strict_shl(129);")]
         /// ```
-        #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
-        #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "strict_overflow_ops", since = "1.91.0")]
+        #[rustc_const_stable(feature = "strict_overflow_ops", since = "1.91.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
@@ -1922,8 +1922,8 @@ macro_rules! uint_impl {
         /// ```should_panic
         #[doc = concat!("let _ = 0x10", stringify!($SelfT), ".strict_shr(129);")]
         /// ```
-        #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
-        #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "strict_overflow_ops", since = "1.91.0")]
+        #[rustc_const_stable(feature = "strict_overflow_ops", since = "1.91.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
@@ -2104,8 +2104,8 @@ macro_rules! uint_impl {
         /// ```should_panic
         #[doc = concat!("let _ = ", stringify!($SelfT), "::MAX.strict_pow(2);")]
         /// ```
-        #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
-        #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "strict_overflow_ops", since = "1.91.0")]
+        #[rustc_const_stable(feature = "strict_overflow_ops", since = "1.91.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
@@ -2682,7 +2682,7 @@ macro_rules! uint_impl {
         ///
         /// assert_eq!((sum1, sum0), (9, 6));
         /// ```
-        #[stable(feature = "unsigned_bigint_helpers", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "unsigned_bigint_helpers", since = "1.91.0")]
         #[rustc_const_unstable(feature = "bigint_helper_methods", issue = "85532")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
@@ -2774,7 +2774,7 @@ macro_rules! uint_impl {
         ///
         #[doc = concat!("assert_eq!((diff1, diff0), (3, ", stringify!($SelfT), "::MAX));")]
         /// ```
-        #[stable(feature = "unsigned_bigint_helpers", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "unsigned_bigint_helpers", since = "1.91.0")]
         #[rustc_const_unstable(feature = "bigint_helper_methods", issue = "85532")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
@@ -2991,7 +2991,7 @@ macro_rules! uint_impl {
         ///     789_u16.wrapping_mul(456).wrapping_add(123),
         /// );
         /// ```
-        #[stable(feature = "unsigned_bigint_helpers", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "unsigned_bigint_helpers", since = "1.91.0")]
         #[rustc_const_unstable(feature = "bigint_helper_methods", issue = "85532")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
@@ -3057,7 +3057,7 @@ macro_rules! uint_impl {
         ///     u32::to_le_bytes(0xcffc982d)
         /// );
         /// ```
-        #[stable(feature = "unsigned_bigint_helpers", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "unsigned_bigint_helpers", since = "1.91.0")]
         #[rustc_const_unstable(feature = "bigint_helper_methods", issue = "85532")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
diff --git a/library/core/src/ptr/mod.rs b/library/core/src/ptr/mod.rs
index 625024373ef47..b29d267654252 100644
--- a/library/core/src/ptr/mod.rs
+++ b/library/core/src/ptr/mod.rs
@@ -975,7 +975,7 @@ pub const fn dangling_mut<T>() -> *mut T {
 #[must_use]
 #[inline(always)]
 #[stable(feature = "exposed_provenance", since = "1.84.0")]
-#[rustc_const_stable(feature = "const_exposed_provenance", since = "CURRENT_RUSTC_VERSION")]
+#[rustc_const_stable(feature = "const_exposed_provenance", since = "1.91.0")]
 #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
 #[allow(fuzzy_provenance_casts)] // this *is* the explicit provenance API one should use instead
 pub const fn with_exposed_provenance<T>(addr: usize) -> *const T {
@@ -1016,7 +1016,7 @@ pub const fn with_exposed_provenance<T>(addr: usize) -> *const T {
 #[must_use]
 #[inline(always)]
 #[stable(feature = "exposed_provenance", since = "1.84.0")]
-#[rustc_const_stable(feature = "const_exposed_provenance", since = "CURRENT_RUSTC_VERSION")]
+#[rustc_const_stable(feature = "const_exposed_provenance", since = "1.91.0")]
 #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
 #[allow(fuzzy_provenance_casts)] // this *is* the explicit provenance API one should use instead
 pub const fn with_exposed_provenance_mut<T>(addr: usize) -> *mut T {
diff --git a/library/core/src/str/mod.rs b/library/core/src/str/mod.rs
index 2e473d348b0b2..3a5efa7d83511 100644
--- a/library/core/src/str/mod.rs
+++ b/library/core/src/str/mod.rs
@@ -404,8 +404,8 @@ impl str {
     /// assert_eq!(closest, 10);
     /// assert_eq!(&s[..closest], "❤️🧡");
     /// ```
-    #[stable(feature = "round_char_boundary", since = "CURRENT_RUSTC_VERSION")]
-    #[rustc_const_stable(feature = "round_char_boundary", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "round_char_boundary", since = "1.91.0")]
+    #[rustc_const_stable(feature = "round_char_boundary", since = "1.91.0")]
     #[inline]
     pub const fn floor_char_boundary(&self, index: usize) -> usize {
         if index >= self.len() {
@@ -447,8 +447,8 @@ impl str {
     /// assert_eq!(closest, 14);
     /// assert_eq!(&s[..closest], "❤️🧡💛");
     /// ```
-    #[stable(feature = "round_char_boundary", since = "CURRENT_RUSTC_VERSION")]
-    #[rustc_const_stable(feature = "round_char_boundary", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "round_char_boundary", since = "1.91.0")]
+    #[rustc_const_stable(feature = "round_char_boundary", since = "1.91.0")]
     #[inline]
     pub const fn ceil_char_boundary(&self, index: usize) -> usize {
         if index >= self.len() {
diff --git a/library/core/src/sync/atomic.rs b/library/core/src/sync/atomic.rs
index 1b4a54b1b7a78..30a42d4eb5e64 100644
--- a/library/core/src/sync/atomic.rs
+++ b/library/core/src/sync/atomic.rs
@@ -2208,7 +2208,7 @@ impl<T> AtomicPtr<T> {
     /// ```
     #[inline]
     #[cfg(target_has_atomic = "ptr")]
-    #[stable(feature = "strict_provenance_atomic_ptr", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "strict_provenance_atomic_ptr", since = "1.91.0")]
     #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
     pub fn fetch_ptr_add(&self, val: usize, order: Ordering) -> *mut T {
         self.fetch_byte_add(val.wrapping_mul(size_of::<T>()), order)
@@ -2252,7 +2252,7 @@ impl<T> AtomicPtr<T> {
     /// ```
     #[inline]
     #[cfg(target_has_atomic = "ptr")]
-    #[stable(feature = "strict_provenance_atomic_ptr", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "strict_provenance_atomic_ptr", since = "1.91.0")]
     #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
     pub fn fetch_ptr_sub(&self, val: usize, order: Ordering) -> *mut T {
         self.fetch_byte_sub(val.wrapping_mul(size_of::<T>()), order)
@@ -2286,7 +2286,7 @@ impl<T> AtomicPtr<T> {
     /// ```
     #[inline]
     #[cfg(target_has_atomic = "ptr")]
-    #[stable(feature = "strict_provenance_atomic_ptr", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "strict_provenance_atomic_ptr", since = "1.91.0")]
     #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
     pub fn fetch_byte_add(&self, val: usize, order: Ordering) -> *mut T {
         // SAFETY: data races are prevented by atomic intrinsics.
@@ -2321,7 +2321,7 @@ impl<T> AtomicPtr<T> {
     /// ```
     #[inline]
     #[cfg(target_has_atomic = "ptr")]
-    #[stable(feature = "strict_provenance_atomic_ptr", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "strict_provenance_atomic_ptr", since = "1.91.0")]
     #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
     pub fn fetch_byte_sub(&self, val: usize, order: Ordering) -> *mut T {
         // SAFETY: data races are prevented by atomic intrinsics.
@@ -2371,7 +2371,7 @@ impl<T> AtomicPtr<T> {
     /// ```
     #[inline]
     #[cfg(target_has_atomic = "ptr")]
-    #[stable(feature = "strict_provenance_atomic_ptr", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "strict_provenance_atomic_ptr", since = "1.91.0")]
     #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
     pub fn fetch_or(&self, val: usize, order: Ordering) -> *mut T {
         // SAFETY: data races are prevented by atomic intrinsics.
@@ -2420,7 +2420,7 @@ impl<T> AtomicPtr<T> {
     /// ```
     #[inline]
     #[cfg(target_has_atomic = "ptr")]
-    #[stable(feature = "strict_provenance_atomic_ptr", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "strict_provenance_atomic_ptr", since = "1.91.0")]
     #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
     pub fn fetch_and(&self, val: usize, order: Ordering) -> *mut T {
         // SAFETY: data races are prevented by atomic intrinsics.
@@ -2467,7 +2467,7 @@ impl<T> AtomicPtr<T> {
     /// ```
     #[inline]
     #[cfg(target_has_atomic = "ptr")]
-    #[stable(feature = "strict_provenance_atomic_ptr", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "strict_provenance_atomic_ptr", since = "1.91.0")]
     #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
     pub fn fetch_xor(&self, val: usize, order: Ordering) -> *mut T {
         // SAFETY: data races are prevented by atomic intrinsics.
diff --git a/library/core/src/time.rs b/library/core/src/time.rs
index d205bc376f125..f721fcd6156cf 100644
--- a/library/core/src/time.rs
+++ b/library/core/src/time.rs
@@ -416,8 +416,8 @@ impl Duration {
     /// assert_eq!(6 * 60 * 60, duration.as_secs());
     /// assert_eq!(0, duration.subsec_nanos());
     /// ```
-    #[stable(feature = "duration_constructors_lite", since = "CURRENT_RUSTC_VERSION")]
-    #[rustc_const_stable(feature = "duration_constructors_lite", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "duration_constructors_lite", since = "1.91.0")]
+    #[rustc_const_stable(feature = "duration_constructors_lite", since = "1.91.0")]
     #[must_use]
     #[inline]
     pub const fn from_hours(hours: u64) -> Duration {
@@ -444,8 +444,8 @@ impl Duration {
     /// assert_eq!(10 * 60, duration.as_secs());
     /// assert_eq!(0, duration.subsec_nanos());
     /// ```
-    #[stable(feature = "duration_constructors_lite", since = "CURRENT_RUSTC_VERSION")]
-    #[rustc_const_stable(feature = "duration_constructors_lite", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "duration_constructors_lite", since = "1.91.0")]
+    #[rustc_const_stable(feature = "duration_constructors_lite", since = "1.91.0")]
     #[must_use]
     #[inline]
     pub const fn from_mins(mins: u64) -> Duration {
diff --git a/library/std/src/ffi/os_str.rs b/library/std/src/ffi/os_str.rs
index a39565d215924..6c098034eea3b 100644
--- a/library/std/src/ffi/os_str.rs
+++ b/library/std/src/ffi/os_str.rs
@@ -137,7 +137,7 @@ impl OsString {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[must_use]
     #[inline]
-    #[rustc_const_stable(feature = "const_pathbuf_osstring_new", since = "CURRENT_RUSTC_VERSION")]
+    #[rustc_const_stable(feature = "const_pathbuf_osstring_new", since = "1.91.0")]
     pub const fn new() -> OsString {
         OsString { inner: Buf::from_string(String::new()) }
     }
diff --git a/library/std/src/os/windows/ffi.rs b/library/std/src/os/windows/ffi.rs
index 345d5b74285e1..20e5383dc09e0 100644
--- a/library/std/src/os/windows/ffi.rs
+++ b/library/std/src/os/windows/ffi.rs
@@ -141,7 +141,7 @@ impl OsStrExt for OsStr {
 pub struct EncodeWide<'a> {
     inner: alloc::wtf8::EncodeWide<'a>,
 }
-#[stable(feature = "encode_wide_debug", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "encode_wide_debug", since = "1.91.0")]
 impl fmt::Debug for EncodeWide<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Debug::fmt(&self.inner, f)
diff --git a/library/std/src/panic.rs b/library/std/src/panic.rs
index 5e8d2f8e78ec7..1997785885d34 100644
--- a/library/std/src/panic.rs
+++ b/library/std/src/panic.rs
@@ -122,7 +122,7 @@ impl<'a> PanicHookInfo<'a> {
     /// ```
     #[must_use]
     #[inline]
-    #[stable(feature = "panic_payload_as_str", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "panic_payload_as_str", since = "1.91.0")]
     pub fn payload_as_str(&self) -> Option<&str> {
         if let Some(s) = self.payload.downcast_ref::<&str>() {
             Some(s)
diff --git a/library/std/src/path.rs b/library/std/src/path.rs
index 88d8a4f21cac5..718c7c2e3b1a6 100644
--- a/library/std/src/path.rs
+++ b/library/std/src/path.rs
@@ -1191,7 +1191,7 @@ impl PathBuf {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[must_use]
     #[inline]
-    #[rustc_const_stable(feature = "const_pathbuf_osstring_new", since = "CURRENT_RUSTC_VERSION")]
+    #[rustc_const_stable(feature = "const_pathbuf_osstring_new", since = "1.91.0")]
     pub const fn new() -> PathBuf {
         PathBuf { inner: OsString::new() }
     }
@@ -1594,7 +1594,7 @@ impl PathBuf {
     /// p.add_extension("");
     /// assert_eq!(Path::new("/feel/the.formatted.dark"), p.as_path());
     /// ```
-    #[stable(feature = "path_add_extension", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "path_add_extension", since = "1.91.0")]
     pub fn add_extension<S: AsRef<OsStr>>(&mut self, extension: S) -> bool {
         self._add_extension(extension.as_ref())
     }
@@ -2103,7 +2103,7 @@ impl PartialEq for PathBuf {
     }
 }
 
-#[stable(feature = "eq_str_for_path", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "eq_str_for_path", since = "1.91.0")]
 impl cmp::PartialEq<str> for PathBuf {
     #[inline]
     fn eq(&self, other: &str) -> bool {
@@ -2111,7 +2111,7 @@ impl cmp::PartialEq<str> for PathBuf {
     }
 }
 
-#[stable(feature = "eq_str_for_path", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "eq_str_for_path", since = "1.91.0")]
 impl cmp::PartialEq<PathBuf> for str {
     #[inline]
     fn eq(&self, other: &PathBuf) -> bool {
@@ -2119,7 +2119,7 @@ impl cmp::PartialEq<PathBuf> for str {
     }
 }
 
-#[stable(feature = "eq_str_for_path", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "eq_str_for_path", since = "1.91.0")]
 impl cmp::PartialEq<String> for PathBuf {
     #[inline]
     fn eq(&self, other: &String) -> bool {
@@ -2127,7 +2127,7 @@ impl cmp::PartialEq<String> for PathBuf {
     }
 }
 
-#[stable(feature = "eq_str_for_path", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "eq_str_for_path", since = "1.91.0")]
 impl cmp::PartialEq<PathBuf> for String {
     #[inline]
     fn eq(&self, other: &PathBuf) -> bool {
@@ -2724,7 +2724,7 @@ impl Path {
     ///
     /// [`Path::file_stem`]: Path::file_stem
     ///
-    #[stable(feature = "path_file_prefix", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "path_file_prefix", since = "1.91.0")]
     #[must_use]
     pub fn file_prefix(&self) -> Option<&OsStr> {
         self.file_name().map(split_file_at_dot).and_then(|(before, _after)| Some(before))
@@ -2888,7 +2888,7 @@ impl Path {
     /// assert_eq!(path.with_added_extension("xz"), PathBuf::from("foo.tar.gz.xz"));
     /// assert_eq!(path.with_added_extension("").with_added_extension("txt"), PathBuf::from("foo.tar.gz.txt"));
     /// ```
-    #[stable(feature = "path_add_extension", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "path_add_extension", since = "1.91.0")]
     pub fn with_added_extension<S: AsRef<OsStr>>(&self, extension: S) -> PathBuf {
         let mut new_path = self.to_path_buf();
         new_path.add_extension(extension);
@@ -3405,7 +3405,7 @@ impl PartialEq for Path {
     }
 }
 
-#[stable(feature = "eq_str_for_path", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "eq_str_for_path", since = "1.91.0")]
 impl cmp::PartialEq<str> for Path {
     #[inline]
     fn eq(&self, other: &str) -> bool {
@@ -3414,7 +3414,7 @@ impl cmp::PartialEq<str> for Path {
     }
 }
 
-#[stable(feature = "eq_str_for_path", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "eq_str_for_path", since = "1.91.0")]
 impl cmp::PartialEq<Path> for str {
     #[inline]
     fn eq(&self, other: &Path) -> bool {
@@ -3422,7 +3422,7 @@ impl cmp::PartialEq<Path> for str {
     }
 }
 
-#[stable(feature = "eq_str_for_path", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "eq_str_for_path", since = "1.91.0")]
 impl cmp::PartialEq<String> for Path {
     #[inline]
     fn eq(&self, other: &String) -> bool {
@@ -3430,7 +3430,7 @@ impl cmp::PartialEq<String> for Path {
     }
 }
 
-#[stable(feature = "eq_str_for_path", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "eq_str_for_path", since = "1.91.0")]
 impl cmp::PartialEq<Path> for String {
     #[inline]
     fn eq(&self, other: &Path) -> bool {
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 c6f68f7a1e812..0d0acaa3bef28 100644
--- a/src/doc/rustc/src/platform-support/apple-ios-macabi.md
+++ b/src/doc/rustc/src/platform-support/apple-ios-macabi.md
@@ -57,7 +57,7 @@ $ rustc --target aarch64-apple-ios-macabi your-code.rs
 ```
 
 The target can be differentiated from the iOS targets with the
-`target_env = "macabi"` cfg (or `target_abi = "macabi"` before Rust CURRENT_RUSTC_VERSION).
+`target_env = "macabi"` cfg (or `target_abi = "macabi"` before Rust 1.91.0).
 
 ```rust
 if cfg!(target_env = "macabi") {
diff --git a/src/doc/rustc/src/platform-support/apple-ios.md b/src/doc/rustc/src/platform-support/apple-ios.md
index 3ac1470475468..5de87dc349eb5 100644
--- a/src/doc/rustc/src/platform-support/apple-ios.md
+++ b/src/doc/rustc/src/platform-support/apple-ios.md
@@ -73,7 +73,7 @@ $ cargo +nightly build -Zbuild-std --target armv7s-apple-ios
 
 The simulator variants can be differentiated from the variants running
 on-device with the `target_env = "sim"` cfg (or `target_abi = "sim"` before
-Rust CURRENT_RUSTC_VERSION).
+Rust 1.91.0).
 
 ```rust
 if cfg!(all(target_vendor = "apple", target_env = "sim")) {
diff --git a/tests/ui/feature-gates/feature-gate-sanitize.stderr b/tests/ui/feature-gates/feature-gate-sanitize.stderr
index 513999636a95c..59e8b69de2e3d 100644
--- a/tests/ui/feature-gates/feature-gate-sanitize.stderr
+++ b/tests/ui/feature-gates/feature-gate-sanitize.stderr
@@ -4,7 +4,7 @@ error[E0557]: feature has been removed
 LL | #![feature(no_sanitize)]
    |            ^^^^^^^^^^^ feature has been removed
    |
-   = note: removed in CURRENT_RUSTC_VERSION; see <https://github.com/rust-lang/rust/pull/142681> for more information
+   = note: removed in 1.91.0; see <https://github.com/rust-lang/rust/pull/142681> for more information
    = note: renamed to sanitize(xyz = "on|off")
 
 error[E0658]: the `#[sanitize]` attribute is an experimental feature

From 201f299ef6039886042ad8dd7c76a4fbd1a77a3f Mon Sep 17 00:00:00 2001
From: Mark Rousskov <mark.simulacrum@gmail.com>
Date: Mon, 15 Sep 2025 22:01:36 -0400
Subject: [PATCH 1454/1889] Apply cfg(bootstrap) replacement

---
 compiler/rustc_const_eval/src/lib.rs         |  1 -
 compiler/rustc_index/src/idx.rs              |  6 ------
 compiler/rustc_lint_defs/src/builtin.rs      | 11 ++++-------
 compiler/rustc_middle/src/lib.rs             |  1 -
 compiler/rustc_span/src/lib.rs               |  1 -
 src/bootstrap/src/core/sanity.rs             |  4 ----
 src/librustdoc/lib.rs                        |  1 -
 src/tools/clippy/clippy_lints/src/lib.rs     |  1 -
 src/tools/clippy/tests/missing-test-files.rs |  1 -
 src/tools/miri/src/lib.rs                    |  1 -
 src/tools/miri/tests/panic/mir-validation.rs |  5 -----
 tests/ui/track-diagnostics/track.rs          |  7 +------
 tests/ui/track-diagnostics/track.stderr      |  6 +++---
 13 files changed, 8 insertions(+), 38 deletions(-)

diff --git a/compiler/rustc_const_eval/src/lib.rs b/compiler/rustc_const_eval/src/lib.rs
index 8ace560d85d16..9c0ec4e51a0c3 100644
--- a/compiler/rustc_const_eval/src/lib.rs
+++ b/compiler/rustc_const_eval/src/lib.rs
@@ -1,7 +1,6 @@
 // tidy-alphabetical-start
 #![allow(internal_features)]
 #![allow(rustc::diagnostic_outside_of_impl)]
-#![cfg_attr(bootstrap, feature(strict_overflow_ops))]
 #![doc(rust_logo)]
 #![feature(array_try_map)]
 #![feature(assert_matches)]
diff --git a/compiler/rustc_index/src/idx.rs b/compiler/rustc_index/src/idx.rs
index 9cd7134659c55..2fb2008f9a3dc 100644
--- a/compiler/rustc_index/src/idx.rs
+++ b/compiler/rustc_index/src/idx.rs
@@ -130,12 +130,6 @@ impl<I: Idx, T> IntoSliceIdx<I, [T]> for core::range::RangeFrom<I> {
 impl<I: Idx, T> IntoSliceIdx<I, [T]> for core::range::RangeInclusive<I> {
     type Output = core::range::RangeInclusive<usize>;
     #[inline]
-    #[cfg(bootstrap)]
-    fn into_slice_idx(self) -> Self::Output {
-        core::range::RangeInclusive { start: self.start.index(), end: self.end.index() }
-    }
-    #[inline]
-    #[cfg(not(bootstrap))]
     fn into_slice_idx(self) -> Self::Output {
         core::range::RangeInclusive { start: self.start.index(), last: self.last.index() }
     }
diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs
index 3d0974d5d2809..939f3d088b12f 100644
--- a/compiler/rustc_lint_defs/src/builtin.rs
+++ b/compiler/rustc_lint_defs/src/builtin.rs
@@ -2309,10 +2309,10 @@ declare_lint! {
     /// ### Example
     ///
     /// ```rust
-    /// #![cfg_attr(not(bootstrap), feature(sanitize))]
+    /// #![feature(sanitize)]
     ///
     /// #[inline(always)]
-    /// #[cfg_attr(not(bootstrap), sanitize(address = "off"))]
+    /// #[sanitize(address = "off")]
     /// fn x() {}
     ///
     /// fn main() {
@@ -4837,16 +4837,13 @@ declare_lint! {
     ///
     /// ### Example
     ///
-    #[cfg_attr(not(bootstrap), doc = "```rust,compile_fail")]
-    #[cfg_attr(bootstrap, doc = "```rust")]
+    /// ```rust,compile_fail
     /// #![doc = in_root!()]
     ///
     /// macro_rules! in_root { () => { "" } }
     ///
     /// fn main() {}
-    #[cfg_attr(not(bootstrap), doc = "```")]
-    #[cfg_attr(bootstrap, doc = "```")]
-    // ^ Needed to avoid tidy warning about odd number of backticks
+    /// ```
     ///
     /// {{produces}}
     ///
diff --git a/compiler/rustc_middle/src/lib.rs b/compiler/rustc_middle/src/lib.rs
index 5023b2740eff4..754a258eef93d 100644
--- a/compiler/rustc_middle/src/lib.rs
+++ b/compiler/rustc_middle/src/lib.rs
@@ -29,7 +29,6 @@
 #![allow(rustc::diagnostic_outside_of_impl)]
 #![allow(rustc::direct_use_of_rustc_type_ir)]
 #![allow(rustc::untranslatable_diagnostic)]
-#![cfg_attr(bootstrap, feature(round_char_boundary))]
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
 #![doc(rust_logo)]
 #![feature(allocator_api)]
diff --git a/compiler/rustc_span/src/lib.rs b/compiler/rustc_span/src/lib.rs
index e95b743b1ce29..35dbbe58db9a4 100644
--- a/compiler/rustc_span/src/lib.rs
+++ b/compiler/rustc_span/src/lib.rs
@@ -17,7 +17,6 @@
 
 // tidy-alphabetical-start
 #![allow(internal_features)]
-#![cfg_attr(bootstrap, feature(round_char_boundary))]
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
 #![doc(rust_logo)]
 #![feature(array_windows)]
diff --git a/src/bootstrap/src/core/sanity.rs b/src/bootstrap/src/core/sanity.rs
index 91d80c96e4268..eaa9e3a6a3e9d 100644
--- a/src/bootstrap/src/core/sanity.rs
+++ b/src/bootstrap/src/core/sanity.rs
@@ -33,11 +33,7 @@ pub struct Finder {
 //
 // Targets can be removed from this list once they are present in the stage0 compiler (usually by updating the beta compiler of the bootstrap).
 const STAGE0_MISSING_TARGETS: &[&str] = &[
-    "armv7a-vex-v5",
-    "riscv64a23-unknown-linux-gnu",
     // just a dummy comment so the list doesn't get onelined
-    "aarch64_be-unknown-hermit",
-    "aarch64_be-unknown-none-softfloat",
     "x86_64-unknown-motor",
 ];
 
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index 5d8f8f4bed125..c4f24e09ddbfa 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -1,5 +1,4 @@
 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(round_char_boundary))]
 #![doc(
     html_root_url = "https://doc.rust-lang.org/nightly/",
     html_playground_url = "https://play.rust-lang.org/"
diff --git a/src/tools/clippy/clippy_lints/src/lib.rs b/src/tools/clippy/clippy_lints/src/lib.rs
index c56fa257b0689..b0083b99f175f 100644
--- a/src/tools/clippy/clippy_lints/src/lib.rs
+++ b/src/tools/clippy/clippy_lints/src/lib.rs
@@ -7,7 +7,6 @@
 #![feature(iter_intersperse)]
 #![feature(iter_partition_in_place)]
 #![feature(never_type)]
-#![cfg_attr(bootstrap, feature(round_char_boundary))]
 #![feature(rustc_private)]
 #![feature(stmt_expr_attributes)]
 #![feature(unwrap_infallible)]
diff --git a/src/tools/clippy/tests/missing-test-files.rs b/src/tools/clippy/tests/missing-test-files.rs
index 63f960c92fa32..9fff3132498d8 100644
--- a/src/tools/clippy/tests/missing-test-files.rs
+++ b/src/tools/clippy/tests/missing-test-files.rs
@@ -1,6 +1,5 @@
 #![warn(rust_2018_idioms, unused_lifetimes)]
 #![allow(clippy::assertions_on_constants)]
-#![cfg_attr(bootstrap, feature(path_file_prefix))]
 
 use std::cmp::Ordering;
 use std::ffi::OsStr;
diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
index 7f5f25b9f66b2..1f82f154b0b3f 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -1,4 +1,3 @@
-#![cfg_attr(bootstrap, feature(strict_overflow_ops))]
 #![feature(abort_unwind)]
 #![feature(cfg_select)]
 #![feature(rustc_private)]
diff --git a/src/tools/miri/tests/panic/mir-validation.rs b/src/tools/miri/tests/panic/mir-validation.rs
index b9097f2e8c533..2d0d530754d8c 100644
--- a/src/tools/miri/tests/panic/mir-validation.rs
+++ b/src/tools/miri/tests/panic/mir-validation.rs
@@ -9,11 +9,6 @@
 // and we don't even get a regular panic; rustc aborts with a different exit code instead.
 //@ignore-host: windows
 
-// FIXME: this tests a crash in rustc. For stage1, rustc is built with the downloaded standard
-// library which doesn't yet print the thread ID. Normalization can be removed at the stage bump.
-// For the grep: cfg(bootstrap)
-//@normalize-stderr-test: "thread 'rustc' panicked" -> "thread 'rustc' ($$TID) panicked"
-
 #![feature(custom_mir, core_intrinsics)]
 use core::intrinsics::mir::*;
 
diff --git a/tests/ui/track-diagnostics/track.rs b/tests/ui/track-diagnostics/track.rs
index 9ce0a4a555acd..2d6d6170fe0b4 100644
--- a/tests/ui/track-diagnostics/track.rs
+++ b/tests/ui/track-diagnostics/track.rs
@@ -13,13 +13,8 @@
 // top of this file are present, then assume all args are present.
 //@ normalize-stderr: "note: compiler flags: .*-Z ui-testing.*-Z track-diagnostics" -> "note: compiler flags: ... -Z ui-testing ... -Z track-diagnostics"
 
-// FIXME: this tests a crash in rustc. For stage1, rustc is built with the downloaded standard
-// library which doesn't yet print the thread ID. Normalization can be removed at the stage bump.
-// For the grep: cfg(bootstrap)
-//@normalize-stderr: "thread 'rustc' panicked" -> "thread 'rustc' ($$TID) panicked"
-
 fn main() {
-    break rust
+    break rust;
     //~^ ERROR cannot find value `rust` in this scope
     //~| NOTE created at
     //~| ERROR `break` outside of a loop or labeled block
diff --git a/tests/ui/track-diagnostics/track.stderr b/tests/ui/track-diagnostics/track.stderr
index bc04ded379df8..76b4bd14f5cd6 100644
--- a/tests/ui/track-diagnostics/track.stderr
+++ b/tests/ui/track-diagnostics/track.stderr
@@ -1,7 +1,7 @@
 error[E0425]: cannot find value `rust` in this scope
   --> $DIR/track.rs:LL:CC
    |
-LL |     break rust
+LL |     break rust;
    |           ^^^^ not found in this scope
    |
    = note: -Ztrack-diagnostics: created at compiler/rustc_resolve/src/late/diagnostics.rs:LL:CC
@@ -9,7 +9,7 @@ LL |     break rust
 error[E0268]: `break` outside of a loop or labeled block
   --> $DIR/track.rs:LL:CC
    |
-LL |     break rust
+LL |     break rust;
    |     ^^^^^^^^^^ cannot `break` outside of a loop or labeled block
    |
    = note: -Ztrack-diagnostics: created at compiler/rustc_hir_typeck/src/loops.rs:LL:CC
@@ -17,7 +17,7 @@ LL |     break rust
 error: internal compiler error: It looks like you're trying to break rust; would you like some ICE?
   --> $DIR/track.rs:LL:CC
    |
-LL |     break rust
+LL |     break rust;
    |     ^^^^^^^^^^
    |
    = note: -Ztrack-diagnostics: created at compiler/rustc_hir_typeck/src/lib.rs:LL:CC

From 54669d7db41952d4c04d735d2c6702d1b2022fed Mon Sep 17 00:00:00 2001
From: Mark Rousskov <mark.simulacrum@gmail.com>
Date: Mon, 15 Sep 2025 22:04:38 -0400
Subject: [PATCH 1455/1889] Bump stage0

---
 src/stage0 | 1000 ++++++++++++++++++++++++++--------------------------
 1 file changed, 500 insertions(+), 500 deletions(-)

diff --git a/src/stage0 b/src/stage0
index a705cd1c760d6..6d2f0402f4acf 100644
--- a/src/stage0
+++ b/src/stage0
@@ -13,506 +13,506 @@ nightly_branch=master
 # All changes below this comment will be overridden the next time the
 # tool is executed.
 
-compiler_date=2025-08-05
+compiler_date=2025-09-16
 compiler_version=beta
-rustfmt_date=2025-09-05
+rustfmt_date=2025-09-16
 rustfmt_version=nightly
 
-dist/2025-08-05/rustc-beta-aarch64-apple-darwin.tar.gz=b9d8f74da46aeadb6c650a4ccfc3c2de08e229e4211a198fa2914103f09f579d
-dist/2025-08-05/rustc-beta-aarch64-apple-darwin.tar.xz=493ed87c65bac5593c104373a3277ddc2330072796704e4b6800c531326da860
-dist/2025-08-05/rustc-beta-aarch64-pc-windows-gnullvm.tar.gz=6c20a3b2e4d3ef9a54b1fe4f50c71895d4d8557d6960f887ef4958c0f2a19eab
-dist/2025-08-05/rustc-beta-aarch64-pc-windows-gnullvm.tar.xz=d6bffc013745c0d69f4cf7ab4f747f8ad885e3b1b77fa56c2e7de8808e278294
-dist/2025-08-05/rustc-beta-aarch64-pc-windows-msvc.tar.gz=3b6bf7e2aff93854346c1d0970cf207c049c17c5ea6ee299dcdb1fd92e996fc0
-dist/2025-08-05/rustc-beta-aarch64-pc-windows-msvc.tar.xz=8241fdc7c673499091700cfcfafe10f3b70bf91918a3b7204a73d2b28445cfa5
-dist/2025-08-05/rustc-beta-aarch64-unknown-linux-gnu.tar.gz=36a093e6c99f227e293ebcaebc89e58166e3da7447d2499069c616610fb4e691
-dist/2025-08-05/rustc-beta-aarch64-unknown-linux-gnu.tar.xz=7cad77f36dcabbe77d603b8b3b4bfa83488a3af2e9b815f698f544de148c77a8
-dist/2025-08-05/rustc-beta-aarch64-unknown-linux-musl.tar.gz=421980aa1ef5467f59c1a8ad43415d69057c9277fdc91d1d5c2b53c246e8bbe9
-dist/2025-08-05/rustc-beta-aarch64-unknown-linux-musl.tar.xz=0ba5b4cd4f5975a58cf86331de5a3c80fb2fd620d50797360a5af4ebf2bba575
-dist/2025-08-05/rustc-beta-arm-unknown-linux-gnueabi.tar.gz=13b3e61ca606bfdf90d46a8873ca4f14fa07ad8bd77364f1a85f557f31ba7299
-dist/2025-08-05/rustc-beta-arm-unknown-linux-gnueabi.tar.xz=f6a1991e55af549d6cd59ddbebb6d2289d90d1e37b2a9449d7831b4c117a54bf
-dist/2025-08-05/rustc-beta-arm-unknown-linux-gnueabihf.tar.gz=a5533df1ae642bcea571aa6c2b5eda16a56c6cd597906081840bb7531f7b02a3
-dist/2025-08-05/rustc-beta-arm-unknown-linux-gnueabihf.tar.xz=2a7187ad6d0215f07d0472880e117556508780e37df6e2a1a7fdbb67fd8dc87e
-dist/2025-08-05/rustc-beta-armv7-unknown-linux-gnueabihf.tar.gz=3ae6e7d83ae3e1c5c8030ba93b9103addaf11f0f8807f1fbf813305d8e6a9188
-dist/2025-08-05/rustc-beta-armv7-unknown-linux-gnueabihf.tar.xz=324d6de1a8e4d9c1dd13cc86665fd06cb167d4a3ea55607cd5353300733f480e
-dist/2025-08-05/rustc-beta-i686-pc-windows-gnu.tar.gz=0bc4b50638818008e054af245d4e987ce5e55fdc56e19d31c18e8c0165f860ab
-dist/2025-08-05/rustc-beta-i686-pc-windows-gnu.tar.xz=b0e5343207a9684d5efe81e536d23135df07bebd869dcad69c632811e1e37137
-dist/2025-08-05/rustc-beta-i686-pc-windows-msvc.tar.gz=c3231335a50402989d4e08857fd7194a3fe5384d2aa34153a25a3f2955a942ef
-dist/2025-08-05/rustc-beta-i686-pc-windows-msvc.tar.xz=be578fcbfe32e40fd9688e618927ddcce88e7e08a279778d4c3399eb46e8ae29
-dist/2025-08-05/rustc-beta-i686-unknown-linux-gnu.tar.gz=96b2cdda499b63aadb76b37a4895623a4806c5c8db8f6edeaeb1b812d337192f
-dist/2025-08-05/rustc-beta-i686-unknown-linux-gnu.tar.xz=f6496eabe0efcc09c7a4994cc4825e9c3e494c8ca7679cfcbd38a699438e1b74
-dist/2025-08-05/rustc-beta-loongarch64-unknown-linux-gnu.tar.gz=3403d7be2f49387149ce075b427f8eaa306066db9fd4ec69de61dc01f6834037
-dist/2025-08-05/rustc-beta-loongarch64-unknown-linux-gnu.tar.xz=8cb3a329ef3632afc1f709b9f9b99a2ab7f5c18590590ddacf64f1b3e5a3ff69
-dist/2025-08-05/rustc-beta-loongarch64-unknown-linux-musl.tar.gz=9485ce37e99a6a53b5521683bec65d015a730a41c4c3f3baa19226edd211fc39
-dist/2025-08-05/rustc-beta-loongarch64-unknown-linux-musl.tar.xz=450d91ad61a23f69560e53c7001aec047bd17fb4831bafb97e7226162bb3c0f4
-dist/2025-08-05/rustc-beta-powerpc-unknown-linux-gnu.tar.gz=dc9ff117a7dd3e685c634e8668d78022f66f6e58dc449fbe5f398688ed2dae0a
-dist/2025-08-05/rustc-beta-powerpc-unknown-linux-gnu.tar.xz=7dbc936f94d531040601d6fc02d9db87335a1b7927637494c9e208a43f012010
-dist/2025-08-05/rustc-beta-powerpc64-unknown-linux-gnu.tar.gz=4a68557cf53063817ee651f5838ad2c3de93a647b9002fe3c82f0372cbd71708
-dist/2025-08-05/rustc-beta-powerpc64-unknown-linux-gnu.tar.xz=f5ae9c4ba17d2941e8fa947d9712a8db8dbbdecbcfa4330988d02b9299fbc814
-dist/2025-08-05/rustc-beta-powerpc64le-unknown-linux-gnu.tar.gz=ad33c48172c3b9abbd95b9dd3c1d38d5f6bc25fe84b95e492b6cdad27ef1bf19
-dist/2025-08-05/rustc-beta-powerpc64le-unknown-linux-gnu.tar.xz=89d40fb02cded4e8d9b3e177f07e1b984481d493015a2532dfdb5b8aaf5ffa94
-dist/2025-08-05/rustc-beta-powerpc64le-unknown-linux-musl.tar.gz=a5ab7a321363502609a4ec5464be96629c693395503c8ce285990db3c556a775
-dist/2025-08-05/rustc-beta-powerpc64le-unknown-linux-musl.tar.xz=7e3b5afc7858857d5840bd6e788fd88449555e2fbe4c9a206ee3552e61dd79b0
-dist/2025-08-05/rustc-beta-riscv64gc-unknown-linux-gnu.tar.gz=fde633217cf77d6fc6f901d84619f681a1fd1e42be75960809bab4806528a451
-dist/2025-08-05/rustc-beta-riscv64gc-unknown-linux-gnu.tar.xz=69541c68f31a401229d770ef2ea6d032104fe928db845eae23f04c40db021a8d
-dist/2025-08-05/rustc-beta-s390x-unknown-linux-gnu.tar.gz=dc257bbab4790dbc3f9df70853eadce198dd5f6f47c8e830254ee2b21c6c79a3
-dist/2025-08-05/rustc-beta-s390x-unknown-linux-gnu.tar.xz=d5a9d5c555241b231eacc0584db0b540ee2982e8bd66cf8568064aab4beb0c94
-dist/2025-08-05/rustc-beta-sparcv9-sun-solaris.tar.gz=96b25f8ce6db2f9d9b7e8da75839d1bd4c97011bebd2544633ab2061e4460bb3
-dist/2025-08-05/rustc-beta-sparcv9-sun-solaris.tar.xz=88438d143441da62bf5415857aab3490697f7f413b7de41cd113bac1480ea7de
-dist/2025-08-05/rustc-beta-x86_64-apple-darwin.tar.gz=f59175ef402489c1dd2f6a8984ecb66314240a8e4f7c55e5d92017fc025fa4ee
-dist/2025-08-05/rustc-beta-x86_64-apple-darwin.tar.xz=21de96e49395252e6eb5b175ee794acad78ccd4ac081303a8da7ec84bf2b6ab1
-dist/2025-08-05/rustc-beta-x86_64-pc-solaris.tar.gz=164a9b76347131d78fb81519627ab50f13a313d8da13d09f7fa479a41c519458
-dist/2025-08-05/rustc-beta-x86_64-pc-solaris.tar.xz=0f91f1f4b8880944341d82894b830a70f8a60837687829e0ab9626f3281ddd1b
-dist/2025-08-05/rustc-beta-x86_64-pc-windows-gnu.tar.gz=634711ae22708a5ae57bb2022fd22257664a8510b59975f4b4ad4b9a8acf475b
-dist/2025-08-05/rustc-beta-x86_64-pc-windows-gnu.tar.xz=b72c0d3f5800e92b91d1361e52b28ff622aeb1f1cbdff2efd22c2f2a3315dd68
-dist/2025-08-05/rustc-beta-x86_64-pc-windows-gnullvm.tar.gz=668f3a8b48092721bb6e1a01440776d6b906850a11e1bcc37a50bb13ef8d7b04
-dist/2025-08-05/rustc-beta-x86_64-pc-windows-gnullvm.tar.xz=e06a183829e09448e76daaf8c317b52d11fac7d16ad191ef61b8f7a806eb9414
-dist/2025-08-05/rustc-beta-x86_64-pc-windows-msvc.tar.gz=564849501d1e41fe776f5443b87c9500621adef97eff05d2c03d539ea3c886da
-dist/2025-08-05/rustc-beta-x86_64-pc-windows-msvc.tar.xz=6a1c1cc47c0e8b6aaad215d4d4e8b770b96336e9f2a0317fcf0511b662966bfd
-dist/2025-08-05/rustc-beta-x86_64-unknown-freebsd.tar.gz=560bcc4d150f4e22f5598d61fce86c9baeda1b57bda837270f7cac78cfc12b19
-dist/2025-08-05/rustc-beta-x86_64-unknown-freebsd.tar.xz=cdfe207645068b4659b0f979cae177723c5f211084f45ae9180b2d93ee83fce6
-dist/2025-08-05/rustc-beta-x86_64-unknown-illumos.tar.gz=5a362ca0c686b0e0666824df3f304ec49d7d419abb08473fece69d41e96ee625
-dist/2025-08-05/rustc-beta-x86_64-unknown-illumos.tar.xz=fb4e7b12b5223545f6fd57754744f03dd6807b6801e97f9f0fe07bc371efed62
-dist/2025-08-05/rustc-beta-x86_64-unknown-linux-gnu.tar.gz=74225a1889120c0174a056e7ca7656f38e8788137ee3d29df857567ae0605692
-dist/2025-08-05/rustc-beta-x86_64-unknown-linux-gnu.tar.xz=2d37542e88f84a0501841e12865262142fec0efef9ca729d26a3c333f16e465d
-dist/2025-08-05/rustc-beta-x86_64-unknown-linux-musl.tar.gz=156eabc89e1ee9558b9de6f60b1bc47c81ab33ae20fa946c4ad4e32b7f30c221
-dist/2025-08-05/rustc-beta-x86_64-unknown-linux-musl.tar.xz=0cf9e649b9020fcfd25282ae1edb1ac59560b7d6d0f79ff7ff3b62871ff25d86
-dist/2025-08-05/rustc-beta-x86_64-unknown-netbsd.tar.gz=8db86a95b22efc2ff2f344e301171813375ccfd2aacad61d3aa84a63f573647a
-dist/2025-08-05/rustc-beta-x86_64-unknown-netbsd.tar.xz=68c10c6431b4433d4de5d24a9bb6ebabe99769b077cdd80ab5e0ee67a273035e
-dist/2025-08-05/rust-std-beta-aarch64-apple-darwin.tar.gz=872e61e6d6915c02de0b9437b910f6f37f5e11c83347bbe2284a59c31aa27ac3
-dist/2025-08-05/rust-std-beta-aarch64-apple-darwin.tar.xz=748516af852836f06efa927cc96bdd2ad6b012d0262e87bdec97a112212cc24a
-dist/2025-08-05/rust-std-beta-aarch64-apple-ios.tar.gz=2c1cf24819ec790d124c7ace59c12a903250eefdad6362b40c779a97b732459e
-dist/2025-08-05/rust-std-beta-aarch64-apple-ios.tar.xz=b2fd6df9653b6c0bc13d4331355b3b9a4756886ba46d6c744687bf7bbd8e4630
-dist/2025-08-05/rust-std-beta-aarch64-apple-ios-macabi.tar.gz=c266b75c66ea17b174ce8a746bbad78bca58bd72c3cdda603f20a868f9b3b00c
-dist/2025-08-05/rust-std-beta-aarch64-apple-ios-macabi.tar.xz=da5558b25c82a5fc1b66786b035212c5d0df2d4124da3e581e15636f29547dd0
-dist/2025-08-05/rust-std-beta-aarch64-apple-ios-sim.tar.gz=8441032f41e142faebe78e84501344180447121602a2000d1310d7a716cf3695
-dist/2025-08-05/rust-std-beta-aarch64-apple-ios-sim.tar.xz=48713adfa5605addd97e13312f6bc4cf103c06623f67705732684b51d0bed8b1
-dist/2025-08-05/rust-std-beta-aarch64-linux-android.tar.gz=1eb2bbc5fac670aa5867546f1caf1378591d5c0d3a3800ca1dd052645fea0cd6
-dist/2025-08-05/rust-std-beta-aarch64-linux-android.tar.xz=ae5e8aedcc5c8bf719e8ed788d52cc69daf64dfcf878e8497b45454c1c582c56
-dist/2025-08-05/rust-std-beta-aarch64-pc-windows-gnullvm.tar.gz=bedf5d7663acb4e1afed9dea4b5b8e9b7f0e0dd68e311d3597819ddd028576f7
-dist/2025-08-05/rust-std-beta-aarch64-pc-windows-gnullvm.tar.xz=e19fd9dc6d9e774e30a9e4a16ac5d6d1fd3300eb880c09f6b61cc63d52370629
-dist/2025-08-05/rust-std-beta-aarch64-pc-windows-msvc.tar.gz=8ad111b1e8e19fdc5bd33d82a1f6d88b9c1809e27531af9d9fed2e37f75edeb4
-dist/2025-08-05/rust-std-beta-aarch64-pc-windows-msvc.tar.xz=332976524e42b4d7b2763a28cae3ebbc3eec03465c098df26e81242294277de4
-dist/2025-08-05/rust-std-beta-aarch64-unknown-fuchsia.tar.gz=92f4737a1775c1fed9311b8949950c6606ca34d272f787d222923555fb69f98b
-dist/2025-08-05/rust-std-beta-aarch64-unknown-fuchsia.tar.xz=2f1ebaa974dc3c6b39c43e38cf6d9f5c6fba0d46229a0423be676d817905850c
-dist/2025-08-05/rust-std-beta-aarch64-unknown-linux-gnu.tar.gz=798dafd6f581f367dfed9763b62b35e77466f87ae8252a52f503f1c1bf58f1a5
-dist/2025-08-05/rust-std-beta-aarch64-unknown-linux-gnu.tar.xz=c4434727604a2773f73e8919a6e967c7c487d75684514cacbe59fb2d6a5f0d29
-dist/2025-08-05/rust-std-beta-aarch64-unknown-linux-musl.tar.gz=c48d4e44b0e94f341e7ab2f9d47b08280930152a53dff20d6c9140739fbd2898
-dist/2025-08-05/rust-std-beta-aarch64-unknown-linux-musl.tar.xz=8cac54d6a39c13dd0f38fde523a852c5db7f61a7f05b3e3ad0f78c7f59513d02
-dist/2025-08-05/rust-std-beta-aarch64-unknown-linux-ohos.tar.gz=5c3d7ea7ac6ab60311fb49c5a2f04a92266bc8a675d7f333219177a91b400f9b
-dist/2025-08-05/rust-std-beta-aarch64-unknown-linux-ohos.tar.xz=f1f9f8a71fc5903bf720d39bedaadab16363b37f9e99817d7cf27b7122ad1ad0
-dist/2025-08-05/rust-std-beta-aarch64-unknown-none.tar.gz=ceffb671e87556b304e63cf01572e1cad8c8cfa0b33ccd1a373b033c60696376
-dist/2025-08-05/rust-std-beta-aarch64-unknown-none.tar.xz=a9a9b17f2b4fdf45f46359726e0c28f6a1289a7abf81fdbe1ae180b2f550aa60
-dist/2025-08-05/rust-std-beta-aarch64-unknown-none-softfloat.tar.gz=9f6f6a121e3b19b7b3b2c85dcd13544c12af18cc5544403e29ea8bbd5b13fecc
-dist/2025-08-05/rust-std-beta-aarch64-unknown-none-softfloat.tar.xz=5b0f0059dd5d837fad74aaf2971fb135229b030a832268106be512557cc7a611
-dist/2025-08-05/rust-std-beta-aarch64-unknown-uefi.tar.gz=67166c7d6d7210ca97c3610abfa126234653d0e26658bbea64d574852fad04fe
-dist/2025-08-05/rust-std-beta-aarch64-unknown-uefi.tar.xz=05f72e7c0ebbf7b41bf3e773bbbc073ca9c71417a80dec8f3916dafbe0cdcf7b
-dist/2025-08-05/rust-std-beta-arm-linux-androideabi.tar.gz=bdf103a29035659972f35bb9060ba8df5ca9b7b068e3c094d758331a5e667144
-dist/2025-08-05/rust-std-beta-arm-linux-androideabi.tar.xz=8fa8b6994b4e04fec77a6657db0fde4e4cb9336466ce0c4f3e2b154709969c93
-dist/2025-08-05/rust-std-beta-arm-unknown-linux-gnueabi.tar.gz=4298510905c958e45291c2fbc4c54bfed9fdafbd48636896fe00a73e94f700ba
-dist/2025-08-05/rust-std-beta-arm-unknown-linux-gnueabi.tar.xz=79e0e393f5286429755faee738ed110fb1cc51b83aec3c94194e903f0b938d73
-dist/2025-08-05/rust-std-beta-arm-unknown-linux-gnueabihf.tar.gz=37278a621e2449b9030045c174c71f3ddf74e70b49b5f247c36fea1b1654979f
-dist/2025-08-05/rust-std-beta-arm-unknown-linux-gnueabihf.tar.xz=3ac094e855f7593a22a56ec40923384a0e25265645d05b2a46dde2612d9c6cf9
-dist/2025-08-05/rust-std-beta-arm-unknown-linux-musleabi.tar.gz=b5bc7d83a3c59764cdc169ae349e01cd052b8ab054eb13b4f2a1cd02ddd7fd6c
-dist/2025-08-05/rust-std-beta-arm-unknown-linux-musleabi.tar.xz=2f8558fee897543da620531e500f3a73c5aac4ea815b7bd418945103dedde530
-dist/2025-08-05/rust-std-beta-arm-unknown-linux-musleabihf.tar.gz=2e812427b5169e7de22b720776208ae92f9075c5509f6b9ad8666b9866232735
-dist/2025-08-05/rust-std-beta-arm-unknown-linux-musleabihf.tar.xz=e544363209177357386f220d6c4101b1d86d84c03e51254ff459ca42ef187107
-dist/2025-08-05/rust-std-beta-arm64ec-pc-windows-msvc.tar.gz=778c947235bb0023ca26dc0592e4d3cb9ad9665c3316d57822c173ba2b5e231e
-dist/2025-08-05/rust-std-beta-arm64ec-pc-windows-msvc.tar.xz=3a5bf7620e1b24e1f72968f5cc28cc58acc9b5739f2c08f5c4b9e449d8c551a1
-dist/2025-08-05/rust-std-beta-armebv7r-none-eabi.tar.gz=fcace82dc77156a6e7c658fc5abe4992075cfe822fb18a1edfca1967102a6adc
-dist/2025-08-05/rust-std-beta-armebv7r-none-eabi.tar.xz=9616372693902e89b55de55b62009a59baccb11ccb63710a475856deca70655c
-dist/2025-08-05/rust-std-beta-armebv7r-none-eabihf.tar.gz=2c596de7d22a4762908676d4e048f5075cbf2d66c5f7a03afb96e709f2d080ca
-dist/2025-08-05/rust-std-beta-armebv7r-none-eabihf.tar.xz=b1ff9e3fe11acc22fa5ad46530dff62bfceac9df6fcbd3da7999535a00dd2e3e
-dist/2025-08-05/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.gz=e033e4bfc11a5bcb7f0645426fac899f7d071236a228300ca2022935997b17fd
-dist/2025-08-05/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.xz=919587b40e2bc6c6e8f496244c357c04d5e53b8adb9b3f274432943fd789a1a4
-dist/2025-08-05/rust-std-beta-armv5te-unknown-linux-musleabi.tar.gz=392a1f0528e4b783e5fd0be74efbec58eb3b0ebd69c3855675301ebf96b76c4a
-dist/2025-08-05/rust-std-beta-armv5te-unknown-linux-musleabi.tar.xz=183144eb89cc1a035c04d50c4060e159ca5099fec71f4f25801a924fa013d04a
-dist/2025-08-05/rust-std-beta-armv7-linux-androideabi.tar.gz=f968b761773b76f151b39dce0f3757f59eee2d8b70373d1419e0986429885d7d
-dist/2025-08-05/rust-std-beta-armv7-linux-androideabi.tar.xz=fecda678541a151b76f3874e710e875a662a9165eaf1cf12b081ea55ea18a38b
-dist/2025-08-05/rust-std-beta-armv7-unknown-linux-gnueabi.tar.gz=300d7e8adaad86ddeff643109d0c83a87e41a056171f9d48b0b6108719003325
-dist/2025-08-05/rust-std-beta-armv7-unknown-linux-gnueabi.tar.xz=acb8f61c97efae6e95aaabe1cab1300bc3cc3a1dc2066c7e2376ad6a9994971c
-dist/2025-08-05/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.gz=5e90333cb68f3161f8cb30e69d4ebe46f6653998651c72a87a795ab02c11dade
-dist/2025-08-05/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.xz=355bc516a7a6454eaacc66eadaa4d640cb3ffc7b5400a01bb4bdccf4470ae650
-dist/2025-08-05/rust-std-beta-armv7-unknown-linux-musleabi.tar.gz=8daa2c4c4dd9e8a1b9ee8a60f2cab0dab81aaf1e7a9d732093979ccdeac8bf60
-dist/2025-08-05/rust-std-beta-armv7-unknown-linux-musleabi.tar.xz=52b78d85f8e9e19da83504bb523aecf7b641d15c1de2f9b988bedf52912636d4
-dist/2025-08-05/rust-std-beta-armv7-unknown-linux-musleabihf.tar.gz=c63000f15b52881c20f40cf1468afd4f3a2a6a84e944357fe6532c7d0e281b3a
-dist/2025-08-05/rust-std-beta-armv7-unknown-linux-musleabihf.tar.xz=53fc3486e4d805386c1ac4d6a1007a9b5461ae606c9c820951b720b45dc8f35c
-dist/2025-08-05/rust-std-beta-armv7-unknown-linux-ohos.tar.gz=315fc371ac2cddeb65c87bd50369e28247c16ca55fdab527e88899e01adc9efe
-dist/2025-08-05/rust-std-beta-armv7-unknown-linux-ohos.tar.xz=d7999aff0a39c63709977f5c18d79b575f8bfb467fbacf4f1b41cd26b52a6701
-dist/2025-08-05/rust-std-beta-armv7a-none-eabi.tar.gz=0707721586e8929811c2904e4136d31f5c415e3f00bfa88dbb920360aa9deea9
-dist/2025-08-05/rust-std-beta-armv7a-none-eabi.tar.xz=bedfd1a808f758f5088ea0fcb746d3ccf11730945e2b07220e93829c0d5c472a
-dist/2025-08-05/rust-std-beta-armv7r-none-eabi.tar.gz=315fadb161b3be540b7a276ebe15b1f8d4bdf73b46c1633e39f698014aca8eb1
-dist/2025-08-05/rust-std-beta-armv7r-none-eabi.tar.xz=4bc2fcd9dee2ee44914da0e6af3763c7ddcbe3ebd9fb20c1d552a0226cd877d7
-dist/2025-08-05/rust-std-beta-armv7r-none-eabihf.tar.gz=9c8be30130709ff94a9718091559a752530f0eeb21be80fc3cca0665e85ae0dc
-dist/2025-08-05/rust-std-beta-armv7r-none-eabihf.tar.xz=f0dd0bd30ed70c3a022016d8bbed54a6e942571f2e4c773bd8b4198d7dccdb5c
-dist/2025-08-05/rust-std-beta-i586-unknown-linux-gnu.tar.gz=ca6c3b8af1c44deaf7dce9e8d4c8786a5801226b30beaa646067d393eeaa0ee8
-dist/2025-08-05/rust-std-beta-i586-unknown-linux-gnu.tar.xz=4e96f0e5f2e3eda60ca2b6d9ce234ae74c5eb2412a7e2c0c571eaf792dca6e28
-dist/2025-08-05/rust-std-beta-i586-unknown-linux-musl.tar.gz=60c736e3ac2aa5b9ceedcd73e39efa12bc9b889ef85f548170f80fbf2b05dfa0
-dist/2025-08-05/rust-std-beta-i586-unknown-linux-musl.tar.xz=fe636d893e38c32a163a88ece160d5b5ea61a3fa63463d4e4f425d229c2927f1
-dist/2025-08-05/rust-std-beta-i686-linux-android.tar.gz=9e62d61041187a91b74c81fe77cd6802a7e38c5a535412c71850426f6a48f37c
-dist/2025-08-05/rust-std-beta-i686-linux-android.tar.xz=862d3d5442fb011b917f565aaadb201c22e7b2ecd6a68c0c410b3335741c1c22
-dist/2025-08-05/rust-std-beta-i686-pc-windows-gnu.tar.gz=05a8da51c477e2c2ce4ea12d41c8afaaf0d226a6b933b6c55fd3584b39103366
-dist/2025-08-05/rust-std-beta-i686-pc-windows-gnu.tar.xz=cf15b3d2011ceb57064d0b2285defee7df8628c3bf2b95f7f2ac92a449546d4f
-dist/2025-08-05/rust-std-beta-i686-pc-windows-gnullvm.tar.gz=fe11b777eae25d823f40352e47272222c2de8edc2d271eb4f6e7ff508efa198d
-dist/2025-08-05/rust-std-beta-i686-pc-windows-gnullvm.tar.xz=a7bb6f223e3542e613eaa7f2b9d9974be71cd2debf8426faa50cfb63fde681fd
-dist/2025-08-05/rust-std-beta-i686-pc-windows-msvc.tar.gz=5fbd709698d80b3227a8bc6cbecfc597e99dede3824c751e1d166cac2c5862dc
-dist/2025-08-05/rust-std-beta-i686-pc-windows-msvc.tar.xz=92fd2a6a5dbe53f68e9ba3ce40cd3beea95ba9d6a2f1293f7f3d917f34739a66
-dist/2025-08-05/rust-std-beta-i686-unknown-freebsd.tar.gz=182acad6cea45855f66646d437ee44ddb1f85c2c998cc5c7a4bbb025ca0d9da9
-dist/2025-08-05/rust-std-beta-i686-unknown-freebsd.tar.xz=53f8bfaabff1dbc47929a99a92025a31c1e272bf6a8091c4f95d33557dfe9ea1
-dist/2025-08-05/rust-std-beta-i686-unknown-linux-gnu.tar.gz=b80dd4e77c56256f7a7f837bf84129d19e1a4aa08a0ca7e2881402371a7e4395
-dist/2025-08-05/rust-std-beta-i686-unknown-linux-gnu.tar.xz=52efb657f28303b0747cf281c972653abfbeb4bf6d0b841f8bbab7f08c5d7310
-dist/2025-08-05/rust-std-beta-i686-unknown-linux-musl.tar.gz=323abc9766231dca10c225b3ec567c694c0ff6f6eddcc30d728a0f08aa6d2186
-dist/2025-08-05/rust-std-beta-i686-unknown-linux-musl.tar.xz=8998ce49f1be28bcd837831f1d7b79b0b339bc74ced42adb6d997ed016e90e88
-dist/2025-08-05/rust-std-beta-i686-unknown-uefi.tar.gz=07261ce98c95839b8714f40e07cbffa32c10fc7c59394dc87b07e144564c5fef
-dist/2025-08-05/rust-std-beta-i686-unknown-uefi.tar.xz=fb6eb023b9722a44e63bcd48fd88c61cf41453842a211107c84039c6883409e5
-dist/2025-08-05/rust-std-beta-loongarch64-unknown-linux-gnu.tar.gz=d0a52888f5ef3107ecdbf28b918eb516a9176ae8695079a81a22d1b7ca0e29bd
-dist/2025-08-05/rust-std-beta-loongarch64-unknown-linux-gnu.tar.xz=c14a477558a6c924e05e1b58bd9df60f5e4966c7f0da294dd38e3bd89c1dc5f6
-dist/2025-08-05/rust-std-beta-loongarch64-unknown-linux-musl.tar.gz=bbb93219393948d055df44edcdfff4b03ca251205c545d6f1bd53ade5f314d52
-dist/2025-08-05/rust-std-beta-loongarch64-unknown-linux-musl.tar.xz=48b437a8afe240828c0377a6baa276500f125661f1bc888ebd1ea546f0497f4a
-dist/2025-08-05/rust-std-beta-loongarch64-unknown-none.tar.gz=fcec6b60a1a22dcd04b8409d38103496d76bb4297ded9f1f092743bd05f0bd54
-dist/2025-08-05/rust-std-beta-loongarch64-unknown-none.tar.xz=2f4aacb734b5a1dd522b4836035ab213db675508b9ff9a1bdc0c2df3ea9d39d1
-dist/2025-08-05/rust-std-beta-loongarch64-unknown-none-softfloat.tar.gz=aad8445e9a5deb4a466ebed84cab101bbe8ef49530315c0349d93e2062ae65a8
-dist/2025-08-05/rust-std-beta-loongarch64-unknown-none-softfloat.tar.xz=906e1cbd1e3b22eb5c378417646baf18b00acb274ee4198ea59ea356f4f1a0da
-dist/2025-08-05/rust-std-beta-nvptx64-nvidia-cuda.tar.gz=b0d7e8daae2eff0c660b6e01bc76258550b9bfbdbf95c104019db7c797339ef5
-dist/2025-08-05/rust-std-beta-nvptx64-nvidia-cuda.tar.xz=c0bffdbb4de90486cad1a26df997006c142f1acc7ed39419975c10b0d09c6217
-dist/2025-08-05/rust-std-beta-powerpc-unknown-linux-gnu.tar.gz=3c845cade37fe2b1cfe3087c69f9ecb3e0eec32d2558701c677d4c21ea9e08db
-dist/2025-08-05/rust-std-beta-powerpc-unknown-linux-gnu.tar.xz=15830d827258f6c3386fa09da66e06ff0460098b46432e28b4e96bd36d61e787
-dist/2025-08-05/rust-std-beta-powerpc64-unknown-linux-gnu.tar.gz=4b63d9260253f1d3a0168ed367792284584b87aa936fc76262e9fe0ad83c7fa1
-dist/2025-08-05/rust-std-beta-powerpc64-unknown-linux-gnu.tar.xz=dfba70ad94524437fc8ec5e4684239eceb76678112776915f02502b80cb0afac
-dist/2025-08-05/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.gz=3d96bebe611a0167a43060312cbfa2fe4000b9949772ee44ffd27226acd006c8
-dist/2025-08-05/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.xz=44e95c2756f52129b8bd21d7d4ad7ec8e05e43192f3bc894cba4a371b579a6d8
-dist/2025-08-05/rust-std-beta-powerpc64le-unknown-linux-musl.tar.gz=ca5b7c47b63fa8e005078cb73d111462c438b764909ca106933837ac93d5780f
-dist/2025-08-05/rust-std-beta-powerpc64le-unknown-linux-musl.tar.xz=b102756451c18003ad1b132d25d333ed1a0e4959b87d2904a6e407fc02a7e422
-dist/2025-08-05/rust-std-beta-riscv32i-unknown-none-elf.tar.gz=a592e995b40d3b1eb69cb1f7cd3c100713ea092742ab6ec5769e8df8551ffa16
-dist/2025-08-05/rust-std-beta-riscv32i-unknown-none-elf.tar.xz=af9cd91be3d667cf31b535862882537a406f49932f58308f283228b20fc7bd76
-dist/2025-08-05/rust-std-beta-riscv32im-unknown-none-elf.tar.gz=bf9e9d0f8c4ce8041c6e628e1b637ac0cb316f865f97a43cf2bf522e255c5ec1
-dist/2025-08-05/rust-std-beta-riscv32im-unknown-none-elf.tar.xz=c3e56d71c1586559212f701508ee94f0bfa7801e7d2fdc62c062dcce8a0d040d
-dist/2025-08-05/rust-std-beta-riscv32imac-unknown-none-elf.tar.gz=068023ed1f1dea01f2523f3b2b9ef41b22a301ceafa0526ebaa757481d14408a
-dist/2025-08-05/rust-std-beta-riscv32imac-unknown-none-elf.tar.xz=1e3db6625ebb12a8c735cf4e8658a33bac7bca461de1e516860843d50027ee7d
-dist/2025-08-05/rust-std-beta-riscv32imafc-unknown-none-elf.tar.gz=aeb986eef375fa1ebb179668c6778c587d1af8b9e1ff50e5b56f9a3b48f1d8df
-dist/2025-08-05/rust-std-beta-riscv32imafc-unknown-none-elf.tar.xz=45d314189b9327645f6490628157fce32b7b59eccdf57676be0c31e1247f5385
-dist/2025-08-05/rust-std-beta-riscv32imc-unknown-none-elf.tar.gz=82d6e6549c80e62d392654693a28528f2ea540652f3ec0810b6646968cae6509
-dist/2025-08-05/rust-std-beta-riscv32imc-unknown-none-elf.tar.xz=805ffe0a6dfbc886f0ba93ac9ce796c110ea6d0a64b2d6209cdadd56cd2a570f
-dist/2025-08-05/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.gz=941c683ef7d013166c7f3439ee1229f80a367405f55bab9072dd12725364db6b
-dist/2025-08-05/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.xz=8b666222443b3954a7550b14ef919b7ab038e6a4a2355386e42c9acbe28f2024
-dist/2025-08-05/rust-std-beta-riscv64gc-unknown-linux-musl.tar.gz=80f740bd004b98d5c090fe280ef5e372e4bff7a34dc2ba4940204cf02f50bb93
-dist/2025-08-05/rust-std-beta-riscv64gc-unknown-linux-musl.tar.xz=b69ad00f5d60c63fa6d7b32c4d7006d195540d902f8390754c7db92a9221973d
-dist/2025-08-05/rust-std-beta-riscv64gc-unknown-none-elf.tar.gz=ed52f0f9bac7b9d7ec49226eea471e44fecf0416608a5b169d35b12d009e9c1b
-dist/2025-08-05/rust-std-beta-riscv64gc-unknown-none-elf.tar.xz=d4dc1b096b26814f14e1e23717cef10f3f63cdc6902e345916e015a99851cb69
-dist/2025-08-05/rust-std-beta-riscv64imac-unknown-none-elf.tar.gz=aa1de02a79f16bb4affb50c3ba0e719352c9925fc57f22f989eed3f7df1a8e5c
-dist/2025-08-05/rust-std-beta-riscv64imac-unknown-none-elf.tar.xz=a36e2749e118f995417f0de9c9835db4b36f8ed6d76d8805510853984f648c5b
-dist/2025-08-05/rust-std-beta-s390x-unknown-linux-gnu.tar.gz=32e6e3672d3c379a1defb6c661eca6f2ce342784feaceafec004bdaa89a0b226
-dist/2025-08-05/rust-std-beta-s390x-unknown-linux-gnu.tar.xz=a449f0392193ab8a48a30b0a8c0c57b0a02747ae8302d08b3be89d475f1b8291
-dist/2025-08-05/rust-std-beta-sparc64-unknown-linux-gnu.tar.gz=a4e0901c13d3c534e176fdf824a97e5a6ca66a198b73a132b957d41b1f198261
-dist/2025-08-05/rust-std-beta-sparc64-unknown-linux-gnu.tar.xz=64720eab59f7c958aadd360b8e2dc5696760d62e9f5f44daba890fc55a4fb6a1
-dist/2025-08-05/rust-std-beta-sparcv9-sun-solaris.tar.gz=8d5d3be06cfe5431b9a8e965fe06837efe531c365e8d46ee8cdc8e9da19099f0
-dist/2025-08-05/rust-std-beta-sparcv9-sun-solaris.tar.xz=913d7fc4aa75ac2175aa52891f9086d48065d96007885e0caf5feb628953a86d
-dist/2025-08-05/rust-std-beta-thumbv6m-none-eabi.tar.gz=ca59366093c472f19381fdc71aacf6b3d659750a8a3bd8894191a42c8c3b82f9
-dist/2025-08-05/rust-std-beta-thumbv6m-none-eabi.tar.xz=e16dc610520f4748ffca99b235e58a544e7f97ca4cf99cbebbeb106ed4acffd1
-dist/2025-08-05/rust-std-beta-thumbv7em-none-eabi.tar.gz=08a281c1bd56149ebd05531fe405a621383ad440fcf273fec04e0792f325d669
-dist/2025-08-05/rust-std-beta-thumbv7em-none-eabi.tar.xz=a9f7eadfa375061835f139bbb870a5692b727de8a85fb8177d8fabd0588e28cd
-dist/2025-08-05/rust-std-beta-thumbv7em-none-eabihf.tar.gz=f996d8b1aae894af11407ac90c277e161acd58378307548ffaa2fa0a4314f3d7
-dist/2025-08-05/rust-std-beta-thumbv7em-none-eabihf.tar.xz=48b9e7d257ad1fac0b23b3a7d6b3ae8afb5dd19db7b5dd2a59ddfe51364db72f
-dist/2025-08-05/rust-std-beta-thumbv7m-none-eabi.tar.gz=1061c6b8794aa4e1f66ff17d91934bb9711c6064362cca7bca1d7cdd4f9189cb
-dist/2025-08-05/rust-std-beta-thumbv7m-none-eabi.tar.xz=974b1078724ac06757d7899fde62f623e61c86ac0853cdbf02a252b13383e55a
-dist/2025-08-05/rust-std-beta-thumbv7neon-linux-androideabi.tar.gz=a4fd4047a744bea871a54af311f27a08b5f7c8f04e5e62f7abf292689378ab4f
-dist/2025-08-05/rust-std-beta-thumbv7neon-linux-androideabi.tar.xz=19c31d2a0982689228eb58522ac7610d33cfcc1b5f72ee2e41e218695a49d09d
-dist/2025-08-05/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.gz=8b5e150d6950866734b025e58b3714c4acfe631785fc464e6fe3cbedd98709d0
-dist/2025-08-05/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.xz=23ca585e084fb548488e17adaea92e16ac98340fe146073046d1bfbe6faa325f
-dist/2025-08-05/rust-std-beta-thumbv8m.base-none-eabi.tar.gz=d31bcb162cd2ee40a69acb2c201c07c233b8c2710bc07ad322263121f0d422db
-dist/2025-08-05/rust-std-beta-thumbv8m.base-none-eabi.tar.xz=67354653ab11222806f4a688c11be6dc80468785e14a8b58f2285a695c53c5a2
-dist/2025-08-05/rust-std-beta-thumbv8m.main-none-eabi.tar.gz=ad61d8510d82ca1094a893879d7148446e2880dd1d172b9e8a420772b0b4611b
-dist/2025-08-05/rust-std-beta-thumbv8m.main-none-eabi.tar.xz=5c1ddf66949a40265effbc76ac3da59efb1bb3349dbe2a8037b8215375647fdb
-dist/2025-08-05/rust-std-beta-thumbv8m.main-none-eabihf.tar.gz=4895c9a6659e831cdacd314ff2ca4c968fd368c6bf9308f334468cb07892ae56
-dist/2025-08-05/rust-std-beta-thumbv8m.main-none-eabihf.tar.xz=f64a05715457288b36dd16fcbbdd91816829b889047c277841f3f4972bcc6076
-dist/2025-08-05/rust-std-beta-wasm32-unknown-emscripten.tar.gz=3b144570ddc44868a6609f921028b23f994de337c54a96fccaf976abe4e2ceff
-dist/2025-08-05/rust-std-beta-wasm32-unknown-emscripten.tar.xz=355a1bc09dd4163a416cb78e55ec998e95b8acbb9b072dbd3a8e34f5e95d3378
-dist/2025-08-05/rust-std-beta-wasm32-unknown-unknown.tar.gz=52213b11d29f02d4531495c9d35ee7022ef6b8400a8386b8728156b33d2a9eed
-dist/2025-08-05/rust-std-beta-wasm32-unknown-unknown.tar.xz=1f282c355a1499fc2a212705700fbb8de7e568dbdc5d43d3c895af86fe9f735b
-dist/2025-08-05/rust-std-beta-wasm32-wasip1.tar.gz=f40da6445acb1e854625a02b1078f670874e75d763168430d0ca17ef3b9bae26
-dist/2025-08-05/rust-std-beta-wasm32-wasip1.tar.xz=a0e59495bacc1bceaeec940273fcc6d1505c283de9e2a60ee7d492f2a7efec3d
-dist/2025-08-05/rust-std-beta-wasm32-wasip1-threads.tar.gz=4b4eb08ab33ff2a300828c65a9636f32428dfec784bf115aa53856b5336d61d5
-dist/2025-08-05/rust-std-beta-wasm32-wasip1-threads.tar.xz=54ae55557d66f922112a42aa2c296841f5919907ccd81354f0dbe1b0517867f8
-dist/2025-08-05/rust-std-beta-wasm32-wasip2.tar.gz=b625337e6180ec57abbed063de5bf384949254c46a5fbbb12804a3dbd0d1c3a6
-dist/2025-08-05/rust-std-beta-wasm32-wasip2.tar.xz=5a098a042f5586e7e1b7444bf64edf3dcc535d75226fa44be420c0d42b90c25c
-dist/2025-08-05/rust-std-beta-wasm32v1-none.tar.gz=b11ed27b745437b39ea9699f7fd5413bdb25019720569b9940f1cbac4849344c
-dist/2025-08-05/rust-std-beta-wasm32v1-none.tar.xz=3dd3f07214429f36a088a89c3de7404659d1b584895ff5b7938845fd4a669f27
-dist/2025-08-05/rust-std-beta-x86_64-apple-darwin.tar.gz=14522f13786b81727646acfcb18c81b3f78b24bf522ebaf65adba416971d9939
-dist/2025-08-05/rust-std-beta-x86_64-apple-darwin.tar.xz=b78a1df21a97c25d9977a69bf778190fbf34947c6837f895aeeb53c870083438
-dist/2025-08-05/rust-std-beta-x86_64-apple-ios.tar.gz=a5d57bef3b09c4a4e6789d756cbec9e9459261ab70c94a406d4519eb2da992ec
-dist/2025-08-05/rust-std-beta-x86_64-apple-ios.tar.xz=1b461aaf03e808d26bcae49417f04b71ad1432f266f0b25b3d6b26a67b7f8953
-dist/2025-08-05/rust-std-beta-x86_64-apple-ios-macabi.tar.gz=6c7a3326abd3fb7c878af095699164237f97ce5827bd428d8aad5c9818b2098c
-dist/2025-08-05/rust-std-beta-x86_64-apple-ios-macabi.tar.xz=427684c9613ce04737837a594987bb1eb81d1d3f5ea2a1b19c2b76b3be32ab62
-dist/2025-08-05/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.gz=2e10607e6eb7fb3168fe593f1d260b52ac578d590cc6788555346cf9bac9f586
-dist/2025-08-05/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.xz=256331077a036bfed1650177cd1a886aeb4ce9aa9ce2a35f5450767f5e06aee6
-dist/2025-08-05/rust-std-beta-x86_64-linux-android.tar.gz=b5943cc4d10bf039d9b52e56713a99e8edb21d9de3655450d16c557c9013f47e
-dist/2025-08-05/rust-std-beta-x86_64-linux-android.tar.xz=ceeb89fa082b98c8d50c043cfd2e4bb8ac1d98943859a75d74a555ffda8d0a5d
-dist/2025-08-05/rust-std-beta-x86_64-pc-solaris.tar.gz=98d9d51da4b74a2a1899be7f0dd8d3c0f980fb4ce96fddd1c2dedb76e174984b
-dist/2025-08-05/rust-std-beta-x86_64-pc-solaris.tar.xz=0fed1f0452475bf10d3ec0bfef12e9fe05bb117910d871f4099bdd4ca947d74b
-dist/2025-08-05/rust-std-beta-x86_64-pc-windows-gnu.tar.gz=f458eab66adc91aba026a434cab47bbbd98a9d5e7d0f5a1a1979e0e6a89c8e7e
-dist/2025-08-05/rust-std-beta-x86_64-pc-windows-gnu.tar.xz=bfdc3bb5b66a525281236b01513f49d96d644e4cd62ce89eb59a8179fe4707b0
-dist/2025-08-05/rust-std-beta-x86_64-pc-windows-gnullvm.tar.gz=b543f21106bc3a72d31a5c49118553187cbb0d2e630ea943aa97d3ae5bb4c40f
-dist/2025-08-05/rust-std-beta-x86_64-pc-windows-gnullvm.tar.xz=9056c113ee03defb6cd33acbed9829712b57ef3606623169d28416be4110a31a
-dist/2025-08-05/rust-std-beta-x86_64-pc-windows-msvc.tar.gz=c66ff2e88c79f3fe574f9ef7822d5d2e6f73efe3ebe67c6bd35096622b668d1c
-dist/2025-08-05/rust-std-beta-x86_64-pc-windows-msvc.tar.xz=45765252e930a96badbf06eb04ec092bb989c0ce2067aaab52b7ddc72ea511b8
-dist/2025-08-05/rust-std-beta-x86_64-unknown-freebsd.tar.gz=9b3d68e86e0ce6a484bf615313f98bd289db73899a55cecfa5b7955b4b0878f4
-dist/2025-08-05/rust-std-beta-x86_64-unknown-freebsd.tar.xz=bd48292b8582167a5e89ebe521c9754495403968c184b925df8b2ec1da344fc3
-dist/2025-08-05/rust-std-beta-x86_64-unknown-fuchsia.tar.gz=b4c6c046299391beb2f50eff198f4c9b6571b6c1748dd621bdd154694fffce3a
-dist/2025-08-05/rust-std-beta-x86_64-unknown-fuchsia.tar.xz=a30857c8f066191b64d7b52378fae8790814a251ca452c80710bd9a49c5c0c85
-dist/2025-08-05/rust-std-beta-x86_64-unknown-illumos.tar.gz=1ee4b264021b510342c2ed96da0dacf5cf1704874de3bf9380642433defb3e0a
-dist/2025-08-05/rust-std-beta-x86_64-unknown-illumos.tar.xz=ca431d4426cfba2efd408b8822f9aeb0961d81373c6154a0b7eeb957abebc33b
-dist/2025-08-05/rust-std-beta-x86_64-unknown-linux-gnu.tar.gz=ebba9fa476d5b0a42054a6b6ca51526efd7c2cf5ac34eb8af119bfa69f3f0a5c
-dist/2025-08-05/rust-std-beta-x86_64-unknown-linux-gnu.tar.xz=d4498920cce484a8b3a5cdf8ee856d80cf1379f9782169340dfff2597b530598
-dist/2025-08-05/rust-std-beta-x86_64-unknown-linux-gnux32.tar.gz=20c37745f3ee13c2c81dfc77a80919cc0448180f6be0be56d7fb5239e5651294
-dist/2025-08-05/rust-std-beta-x86_64-unknown-linux-gnux32.tar.xz=dd319a6c381b372ba230d86bd07a089cd2431656c7c765f029e8e10d60bbd778
-dist/2025-08-05/rust-std-beta-x86_64-unknown-linux-musl.tar.gz=d0c20b13113eb62c9a78a796418386d0352f4221095de272018af6d5ec6bd9f1
-dist/2025-08-05/rust-std-beta-x86_64-unknown-linux-musl.tar.xz=d0e1001e8e5af571f0fd53115ec873091a33e4943dd27a16ccd74dcd8c71abce
-dist/2025-08-05/rust-std-beta-x86_64-unknown-linux-ohos.tar.gz=4be537d5fb6c0d867a131539ef4b0872f9f6d175ba0517fed50b1d463c615157
-dist/2025-08-05/rust-std-beta-x86_64-unknown-linux-ohos.tar.xz=ca034c852a4c9099a062f55c5e479bd700f2ffd89a3b2c2c7354df54e41057a8
-dist/2025-08-05/rust-std-beta-x86_64-unknown-netbsd.tar.gz=11b5a73da1f560c218cecf9a71d6b2173df1fbe276e63e20e1e85f2dc48579bf
-dist/2025-08-05/rust-std-beta-x86_64-unknown-netbsd.tar.xz=2de6a8850076e9c1edd8aa3e13902ebbc599da9637f88da347858007f8e5c212
-dist/2025-08-05/rust-std-beta-x86_64-unknown-none.tar.gz=dacb8aa48387ad15380a094104bbcfabdcdd5f88e189d9203fd3e3f466b92fa3
-dist/2025-08-05/rust-std-beta-x86_64-unknown-none.tar.xz=ce2eb95efe252de2ecbe619b3805b01ec84863a9b30330dc4ad5683d67d7c9d8
-dist/2025-08-05/rust-std-beta-x86_64-unknown-redox.tar.gz=bf28f90b1b24eabd80da75262bd260ee811ef30a1ba94bdeb7a005f132ceeead
-dist/2025-08-05/rust-std-beta-x86_64-unknown-redox.tar.xz=99aa3603b7fdc84893a02e66a774e147439a1cfd77ba63818c58b11ae692058d
-dist/2025-08-05/rust-std-beta-x86_64-unknown-uefi.tar.gz=75c57e4a9367a6fbee02f8857da2dd4bce8bd20c8946a3c2460a77cb95af0972
-dist/2025-08-05/rust-std-beta-x86_64-unknown-uefi.tar.xz=552c14c20d1f786c8350882a32618951de0a06e0636fa3b8d69f2ffab7e7561d
-dist/2025-08-05/cargo-beta-aarch64-apple-darwin.tar.gz=4723292f91e645d3f86474ed55e52eae4f35af7458602d3da9d38b0a513cfeef
-dist/2025-08-05/cargo-beta-aarch64-apple-darwin.tar.xz=d0150ce874376c41950966b0385f011ebbbd5ef4955deec7829d8ccb669e9e86
-dist/2025-08-05/cargo-beta-aarch64-pc-windows-gnullvm.tar.gz=fb0a8a8dff4d42f9491ed9a0223a9541bbaf8691c831b5536220494c479b21e3
-dist/2025-08-05/cargo-beta-aarch64-pc-windows-gnullvm.tar.xz=6bd35ea43ab877d84bff4b32b965371b942b10c6f6feabb3a5b481a4c84513fc
-dist/2025-08-05/cargo-beta-aarch64-pc-windows-msvc.tar.gz=3437221155f338e81f55dea9d715b3958fe7d3a260d77d14725e62d0780bfc76
-dist/2025-08-05/cargo-beta-aarch64-pc-windows-msvc.tar.xz=94886636f7bf805809a8a1ac99b514036c5db1755ccfed61cb6cd01d57d244a3
-dist/2025-08-05/cargo-beta-aarch64-unknown-linux-gnu.tar.gz=7f167793fc72f5fdb6bbed97e96684cfa089f9932d3a64239bc755fe7603e7a3
-dist/2025-08-05/cargo-beta-aarch64-unknown-linux-gnu.tar.xz=1018ea99c4142db9fbf386547dee8396dc27d3d3608085a1b0b0e97e2d0172c7
-dist/2025-08-05/cargo-beta-aarch64-unknown-linux-musl.tar.gz=8e03af7a838e81c12c395ed76151aa6ead12b3e60effa3b0d775508118149058
-dist/2025-08-05/cargo-beta-aarch64-unknown-linux-musl.tar.xz=507de5fbe92e144dd37dc34123ee58b9e46805c85eccd4a759a117020578d742
-dist/2025-08-05/cargo-beta-arm-unknown-linux-gnueabi.tar.gz=263ad4a9ed084dd76b6ea62d377fa470043f78e0343f7fb80d5c9b50659d8977
-dist/2025-08-05/cargo-beta-arm-unknown-linux-gnueabi.tar.xz=ed850f484ee870172b721ab6824f0a15b41dd80ffc623557aa58a5b839d992c5
-dist/2025-08-05/cargo-beta-arm-unknown-linux-gnueabihf.tar.gz=afb4cdac4a3c28fe08fbba8b98962eec6c625f6a10a52ee8cc988881852b79dd
-dist/2025-08-05/cargo-beta-arm-unknown-linux-gnueabihf.tar.xz=7f332d11e74d76efe236a7858021a626d31fb856d9ad0745369b99d9fdfe3b44
-dist/2025-08-05/cargo-beta-armv7-unknown-linux-gnueabihf.tar.gz=5c0c79bbf734c0ce18001cf27605f6728d83d24bc97ea5c78b423fb9faf46d96
-dist/2025-08-05/cargo-beta-armv7-unknown-linux-gnueabihf.tar.xz=3aff39ef7b9e8adc2e6bca19c2940287c4e091ad7ce4503c46334e6969ce0c95
-dist/2025-08-05/cargo-beta-i686-pc-windows-gnu.tar.gz=af99a5778ab4c9cea122897bcd3ea1626893156fb71346d66a584553d6531469
-dist/2025-08-05/cargo-beta-i686-pc-windows-gnu.tar.xz=8425eda844728c0353b4c7edc4636141dad265e461addf009cfa1a224df0e7cd
-dist/2025-08-05/cargo-beta-i686-pc-windows-msvc.tar.gz=46d1b318b6cf826d8e7e694e54ce5b9c651dc2f8facf32ddebe21fc32e1e8dc4
-dist/2025-08-05/cargo-beta-i686-pc-windows-msvc.tar.xz=bef58a9f31aa3434152f79b2e271958fb07e925c938a569d1c9431f7764d19f1
-dist/2025-08-05/cargo-beta-i686-unknown-linux-gnu.tar.gz=c432ae4d909a21336a6645b85a90ec541818424bb76da16b19979a61a11845b2
-dist/2025-08-05/cargo-beta-i686-unknown-linux-gnu.tar.xz=053c02b341219d583caba881e525eae2cbb125ecc188e1b43d641fd7f3f027f2
-dist/2025-08-05/cargo-beta-loongarch64-unknown-linux-gnu.tar.gz=40542d76adaebdbc3fb16047a8324d439abba0485d227253614beddcc3cee2dd
-dist/2025-08-05/cargo-beta-loongarch64-unknown-linux-gnu.tar.xz=d25210467dabf91917eefad9a5a415a3912a31b37ce1fd3d755b6c72b3a6ce8a
-dist/2025-08-05/cargo-beta-loongarch64-unknown-linux-musl.tar.gz=09755de73380c39daf64208df9708613ed6f8790e2f5cf79e80cb7826fd74f28
-dist/2025-08-05/cargo-beta-loongarch64-unknown-linux-musl.tar.xz=e8eab1aa5b41c04b518d43a86849307cbfec76df13c834a460c546ab6b170089
-dist/2025-08-05/cargo-beta-powerpc-unknown-linux-gnu.tar.gz=93398391d308bd0c08fa2a7bab7bb6a38b78400280cbe765604a3da9d6caeb47
-dist/2025-08-05/cargo-beta-powerpc-unknown-linux-gnu.tar.xz=ed37a7c5a8c62db06e709779b81d1e013975feeb82c185c76bb3d218aa142cc4
-dist/2025-08-05/cargo-beta-powerpc64-unknown-linux-gnu.tar.gz=a398b3ff0967b1ec2fdc2716a6b2c3a04defc14ebed577d93e45040aa5552dc8
-dist/2025-08-05/cargo-beta-powerpc64-unknown-linux-gnu.tar.xz=51d6a1a3e71713157a4e6291023b8393e21334a952a947f82f9636a725989281
-dist/2025-08-05/cargo-beta-powerpc64le-unknown-linux-gnu.tar.gz=cef935747fe5205c3c5944f4dcf80e3111d2859616e7d727b8a5c77abe2d9fef
-dist/2025-08-05/cargo-beta-powerpc64le-unknown-linux-gnu.tar.xz=fcb8aee743adcc3796b564570e0ad6d9950031160ba9a6cafbd92af2f0a0c213
-dist/2025-08-05/cargo-beta-powerpc64le-unknown-linux-musl.tar.gz=73b2c9676122e842a73a8a9890f1e1aac426f75449a99b4fc0ae3f5dd5ce238e
-dist/2025-08-05/cargo-beta-powerpc64le-unknown-linux-musl.tar.xz=ba293bb860349ee4732c5363d38b5e386544a25f65ef8ee33850061bc84bfe64
-dist/2025-08-05/cargo-beta-riscv64gc-unknown-linux-gnu.tar.gz=bff3ac251a42b1664a544706185826a4d9137cde990620dc73951252d2d7fb41
-dist/2025-08-05/cargo-beta-riscv64gc-unknown-linux-gnu.tar.xz=61056d4405af01b4b1c3134af8e83ed86473d0846beb41d3ab72df92edf316a6
-dist/2025-08-05/cargo-beta-s390x-unknown-linux-gnu.tar.gz=f89a30322a3621c4737f932788f4ca78c83b9f2845e324c4944522f35d44baf1
-dist/2025-08-05/cargo-beta-s390x-unknown-linux-gnu.tar.xz=394d522c9553182cf5f496e2b5324499c1845c0a0621fa527aaa925946b58d21
-dist/2025-08-05/cargo-beta-sparcv9-sun-solaris.tar.gz=0b18adbb22b34448576e6a3ba637c7565d369e1c994474337bed48b3cd0b0231
-dist/2025-08-05/cargo-beta-sparcv9-sun-solaris.tar.xz=c57709b87524d29661f77df3e3585bae4776fb3fb6de3874edb942f724543a89
-dist/2025-08-05/cargo-beta-x86_64-apple-darwin.tar.gz=c8faf66575d43fcbc03376225ac22d571def08ed1fc239d468c15929d9ecd393
-dist/2025-08-05/cargo-beta-x86_64-apple-darwin.tar.xz=538d81c3fe2b5a9edfc1e99655120d37fa159dcf761e1ddbe5233115e39b38b1
-dist/2025-08-05/cargo-beta-x86_64-pc-solaris.tar.gz=a2fb63b0a2cc3d3ea9523c8ffe61ba9ccb367dff136e6fc39aeea6400034363c
-dist/2025-08-05/cargo-beta-x86_64-pc-solaris.tar.xz=02e8990865ef8f14a31e4d0f17be4cc0cbecda7e82e062b4b9cfdb99dd45156d
-dist/2025-08-05/cargo-beta-x86_64-pc-windows-gnu.tar.gz=ba86f300cd40cb3cb23ac41970246ce54c03ee153f86127a379fecda930c020b
-dist/2025-08-05/cargo-beta-x86_64-pc-windows-gnu.tar.xz=3bc0bf2da392ac52bcf2aa1dc19bea1a86bd7a4fe246feaae862a792c82ec476
-dist/2025-08-05/cargo-beta-x86_64-pc-windows-gnullvm.tar.gz=68a2a34e656395fabd42d20b7008d96b2a86e9a47caa52e6e2613ccb3b1b2d8f
-dist/2025-08-05/cargo-beta-x86_64-pc-windows-gnullvm.tar.xz=1e2e31fe2306e26bfe58c49a99cc89664e8a7857c2c18ad74c20cdb35bd3c586
-dist/2025-08-05/cargo-beta-x86_64-pc-windows-msvc.tar.gz=5fa21f665aa40fab1896bd4a49dc5608b4b453d26f4b975771908634c699ab8e
-dist/2025-08-05/cargo-beta-x86_64-pc-windows-msvc.tar.xz=adc5900506d399246960445c1e2d59f0c4b2a5cfeff9972f1617de030ce82bfa
-dist/2025-08-05/cargo-beta-x86_64-unknown-freebsd.tar.gz=a2bbb1d5fa283e77ddbbc0c8d69e36b9c2bbb01912f302f522af48c2187327b3
-dist/2025-08-05/cargo-beta-x86_64-unknown-freebsd.tar.xz=11e1a51740a728f5825364a8679b28454a68e7efc96320730f9b58a8fc2e6fae
-dist/2025-08-05/cargo-beta-x86_64-unknown-illumos.tar.gz=9993f4130b5ce50898e530e7411efe6923a36b5d56459ab672b1395717fe69bb
-dist/2025-08-05/cargo-beta-x86_64-unknown-illumos.tar.xz=0a41315ced9f4fdce9c1877a4c27e5cca6e494f5dc8c2560334a5b75d42f495e
-dist/2025-08-05/cargo-beta-x86_64-unknown-linux-gnu.tar.gz=6b8f74b1c850093acb7227306caaed4581d70d015ebb0bb5f924af1c8bee7bd1
-dist/2025-08-05/cargo-beta-x86_64-unknown-linux-gnu.tar.xz=f6f7bb4e4f1156329946d83bad5893e508645dd76b9ce522a53ea673791da006
-dist/2025-08-05/cargo-beta-x86_64-unknown-linux-musl.tar.gz=68c829663d6166661563704e25a6e85a973705e12efc9265a23264b9ffbff4d7
-dist/2025-08-05/cargo-beta-x86_64-unknown-linux-musl.tar.xz=2c40e68c9978e58250f0e017b5cdb2fc390f26ef96324129c489f55898784488
-dist/2025-08-05/cargo-beta-x86_64-unknown-netbsd.tar.gz=65166585138bc6f09f54f88ee889aea6d4e63019d64a684798341d6b332ce99d
-dist/2025-08-05/cargo-beta-x86_64-unknown-netbsd.tar.xz=97491edef98b3a13b0571907555bf5867be13ec8fd4af69142db92a8deaf8586
-dist/2025-08-05/clippy-beta-aarch64-apple-darwin.tar.gz=b933611d47ccbcf5aad43f1134cc72ac708fdf59bace0dab75cfe139e2357373
-dist/2025-08-05/clippy-beta-aarch64-apple-darwin.tar.xz=c3d473e366db3b271cbe438b3a5531e9c5a72e28248d94de0f81ee93a8a2e7cd
-dist/2025-08-05/clippy-beta-aarch64-pc-windows-gnullvm.tar.gz=e5b4fc054121eb13b21171b2e851dc1c824e11aad1257dc92b4ca9e332898b40
-dist/2025-08-05/clippy-beta-aarch64-pc-windows-gnullvm.tar.xz=40bddcdd9186cfb9f8763e8e289087c15c2c8b8ab78f41ba7380cdb08fedb0da
-dist/2025-08-05/clippy-beta-aarch64-pc-windows-msvc.tar.gz=7e7c47305708ae073ed8d86e621a3c0be0e135b2480508814665f24121588a56
-dist/2025-08-05/clippy-beta-aarch64-pc-windows-msvc.tar.xz=c4a5bfe2d48a2301adb4f7524cccd64f4a3ccecf985f131972a13bd221346454
-dist/2025-08-05/clippy-beta-aarch64-unknown-linux-gnu.tar.gz=dd26d49359f6010e94e04198067f83c83e81618546d1cf51606d157a02b4938f
-dist/2025-08-05/clippy-beta-aarch64-unknown-linux-gnu.tar.xz=e7c9834067311a87f547450108718582991498a102dfcba0e1a99671205e9bc2
-dist/2025-08-05/clippy-beta-aarch64-unknown-linux-musl.tar.gz=b584c26e267b0f7e105f65c436c12cfd6d9b8f2b92f9662a4797fa5e95455e11
-dist/2025-08-05/clippy-beta-aarch64-unknown-linux-musl.tar.xz=6b0eaadfea879cfc8c758fce002ffe77e34484e167c496ac0659dcc789dfc080
-dist/2025-08-05/clippy-beta-arm-unknown-linux-gnueabi.tar.gz=eebd0632971888cb3bcc3b07a06f25a47af594ce5606e8e1e069fe85ec702e5c
-dist/2025-08-05/clippy-beta-arm-unknown-linux-gnueabi.tar.xz=946d6791e4e15ffca6195bd7c9bd2d160b9c65468fddc800948f41adc8fec597
-dist/2025-08-05/clippy-beta-arm-unknown-linux-gnueabihf.tar.gz=3862815aa14e8122b70b39c1137088e0c2a724900d2d13ac2b37a1a430b23a1f
-dist/2025-08-05/clippy-beta-arm-unknown-linux-gnueabihf.tar.xz=8278e11b7ea2bc035e6de21f826a775d66273a9031195d8b887752137424f2e0
-dist/2025-08-05/clippy-beta-armv7-unknown-linux-gnueabihf.tar.gz=83a847698eeafcbd3288d59013157d3d2a11b90b521ebadf1b26dac90877d11f
-dist/2025-08-05/clippy-beta-armv7-unknown-linux-gnueabihf.tar.xz=308de9cedc422c2051661df74024ab26c59b86368fbf50ce4dd7b2b2907ccc8f
-dist/2025-08-05/clippy-beta-i686-pc-windows-gnu.tar.gz=95fe71a1f8e68f0f3a5306dfa04e269c636ad036908e201c1b4ed7a3f99b1dc7
-dist/2025-08-05/clippy-beta-i686-pc-windows-gnu.tar.xz=5b8c928be909433fb005498a92d2fb3ff535f31c68a5e134523f9731cacb029a
-dist/2025-08-05/clippy-beta-i686-pc-windows-msvc.tar.gz=d736ec4f447f6b204f250b044b406b4e4b96f014887b6f7755b037e211aad3af
-dist/2025-08-05/clippy-beta-i686-pc-windows-msvc.tar.xz=8a4ac568284aabb994964323465c7287715d3dd4ab881271a4746d2ae5390ffc
-dist/2025-08-05/clippy-beta-i686-unknown-linux-gnu.tar.gz=d8b87338abdb4123eb25dd778d038c516c5bd472e1426b5a5f74f25126957039
-dist/2025-08-05/clippy-beta-i686-unknown-linux-gnu.tar.xz=ebb6dcc1b038deff6a966062ca3a966d3426f8932e5aeba398636a2d2e9be0c0
-dist/2025-08-05/clippy-beta-loongarch64-unknown-linux-gnu.tar.gz=51bf4e84be5b677ad9afba442d9567b96f59209219cddad5eb3f49b788bd8fe2
-dist/2025-08-05/clippy-beta-loongarch64-unknown-linux-gnu.tar.xz=e63e3346089c7f300bdc73521def20cd2a012f8de98b8b05a653e85f3516371c
-dist/2025-08-05/clippy-beta-loongarch64-unknown-linux-musl.tar.gz=aeb3782ca34a0ac47420109c241041ebbc029050a690a5c828c865108f56ca18
-dist/2025-08-05/clippy-beta-loongarch64-unknown-linux-musl.tar.xz=80dabbd511bd5bdfc944d7613a02c9bdac702abf2de916222a37e59a92c2e577
-dist/2025-08-05/clippy-beta-powerpc-unknown-linux-gnu.tar.gz=9307396973615663330474ec145efebd4246c6bae5d979a80b6d93f832af0137
-dist/2025-08-05/clippy-beta-powerpc-unknown-linux-gnu.tar.xz=fb2a34f9472d2c1beb1381e9ff8bca23d9058c978fdb2e52a3c7f0cba8305c59
-dist/2025-08-05/clippy-beta-powerpc64-unknown-linux-gnu.tar.gz=e985eebd182d78604861ce60aba5078e98a9a078b76752da8fabcfc5fa471fc3
-dist/2025-08-05/clippy-beta-powerpc64-unknown-linux-gnu.tar.xz=1092ddf60ba04418f91c1e51f9c9da1e0d6b61dbdb104fc8028043dc1a33caec
-dist/2025-08-05/clippy-beta-powerpc64le-unknown-linux-gnu.tar.gz=bf0238a4909fa15034f067d5a51e38e43c91e69f29f51c39246d5c0b23925042
-dist/2025-08-05/clippy-beta-powerpc64le-unknown-linux-gnu.tar.xz=39caa6aedcd746ed1c4745e207cf8cd65de7b774f15e8892987ce2c3fdde543e
-dist/2025-08-05/clippy-beta-powerpc64le-unknown-linux-musl.tar.gz=b19ef1a8cdc21925887ced0c594ff5ab658bf66a0d137c01b6375fcdd0de8e35
-dist/2025-08-05/clippy-beta-powerpc64le-unknown-linux-musl.tar.xz=0ec300c1e791f946503db692e602680acf11857715b9ecc87cb446ac10d2527c
-dist/2025-08-05/clippy-beta-riscv64gc-unknown-linux-gnu.tar.gz=e7c8fe214ffd70599648cfacb50b3457597b479d320bf8383869dda8b0559d42
-dist/2025-08-05/clippy-beta-riscv64gc-unknown-linux-gnu.tar.xz=d8ba0c42074c2a94dff3b05f2388f17225044485abd0459e155928f4762c8988
-dist/2025-08-05/clippy-beta-s390x-unknown-linux-gnu.tar.gz=510b9c9ca885a8e91c3d25f14cbfb34a7a927d374fa1a9149678d7ed9c4e4c2c
-dist/2025-08-05/clippy-beta-s390x-unknown-linux-gnu.tar.xz=b53697799d99beb46fc17b3cca8ccfdc4ecbf7f3e1fd47f031852f07fb749ea0
-dist/2025-08-05/clippy-beta-sparcv9-sun-solaris.tar.gz=f3109a1dd87c23256057fcc94d3fade0b49d20a51040b4fbdda366f5b7c9b58e
-dist/2025-08-05/clippy-beta-sparcv9-sun-solaris.tar.xz=ba265d781254d0b032d836a440c94c31ca33bc136e027ad05332cfc0cf40bf54
-dist/2025-08-05/clippy-beta-x86_64-apple-darwin.tar.gz=74c49a7cd4b6605b9a43961415fcaed1197b8f5aca798efd4b62a15d837b956b
-dist/2025-08-05/clippy-beta-x86_64-apple-darwin.tar.xz=69128daabb11fd29720752bb13d83ef4bb3faa1d4aea8d525da2cb04f42b6010
-dist/2025-08-05/clippy-beta-x86_64-pc-solaris.tar.gz=e1975507778e448ac9b3040f330340f3a7d54e6dd40357494e3d891008375364
-dist/2025-08-05/clippy-beta-x86_64-pc-solaris.tar.xz=43c142c870116f4c2408f4b3208680b81390a4b37805f5a32696ad17bb313b48
-dist/2025-08-05/clippy-beta-x86_64-pc-windows-gnu.tar.gz=ccd8806b6614edb270a2816cf0dc3b6376046fe58d258d296ffb222929d42d91
-dist/2025-08-05/clippy-beta-x86_64-pc-windows-gnu.tar.xz=21148cd754493da3cdf72adc8da19ebfca1da8d642e1bef51782772241b48084
-dist/2025-08-05/clippy-beta-x86_64-pc-windows-gnullvm.tar.gz=5a7cecb6c054a71ec5b1fb284f6bf2c069925fffcc1757ac631e8a2d08b116b0
-dist/2025-08-05/clippy-beta-x86_64-pc-windows-gnullvm.tar.xz=b451057a4a75341924072fe26334eefce8b6eaa3edd79d3226eb02c1c99fcdb3
-dist/2025-08-05/clippy-beta-x86_64-pc-windows-msvc.tar.gz=74e9cea693203c6217934549694a240460dda2818b144bac5777f41c44a06d53
-dist/2025-08-05/clippy-beta-x86_64-pc-windows-msvc.tar.xz=bd90fc3fc80f28ce415dc1cfd105d17ec5ecfc63fae017baeec734bf94f5d71b
-dist/2025-08-05/clippy-beta-x86_64-unknown-freebsd.tar.gz=fb61d60d6c66a4632911944b5c7858b8c055ab8ae5a194d78e7d7ba18b65e940
-dist/2025-08-05/clippy-beta-x86_64-unknown-freebsd.tar.xz=bbc7b2aa6f05ecf391a757ffc5b6fa6e0989d00f7e8fa48b83faca8996f99dd1
-dist/2025-08-05/clippy-beta-x86_64-unknown-illumos.tar.gz=10e8be6eb15269cb2d0573e19e3a5004dbbd2b14e2f016d6b9c60713e22f716b
-dist/2025-08-05/clippy-beta-x86_64-unknown-illumos.tar.xz=c3748db93829d3f5d9c5498592d247468125ca301ef238c41e42d37b7b90c6a4
-dist/2025-08-05/clippy-beta-x86_64-unknown-linux-gnu.tar.gz=5a0365eda14ac1a366f3c480a2358eccbfcbfce86323711d7fcfdcfd85652b42
-dist/2025-08-05/clippy-beta-x86_64-unknown-linux-gnu.tar.xz=908576635e79fe589583f18bd6ace4c488cd11ed0c59501082bb0b397df24f39
-dist/2025-08-05/clippy-beta-x86_64-unknown-linux-musl.tar.gz=79fd42cffac98024308c511144b716d18693b902dbdc1c4b88645bc7d4ae7109
-dist/2025-08-05/clippy-beta-x86_64-unknown-linux-musl.tar.xz=a3a616554ed25630df9f8cef37a5d36573e6f722b1f6b4220ff4885e2d3a60de
-dist/2025-08-05/clippy-beta-x86_64-unknown-netbsd.tar.gz=ad1849cb72ccfd52ba17a34d90f65226726e5044f7ffbe975c74f23643d87d98
-dist/2025-08-05/clippy-beta-x86_64-unknown-netbsd.tar.xz=608001728598164e234f176d0c6cfe7317dde27fb4cbb8ad1c2452289e83bf30
-dist/2025-09-05/rustfmt-nightly-aarch64-apple-darwin.tar.gz=6fd7eece7221e76c2596e0472e7311fdced87e9fab26d2a4673a3242fe779bd3
-dist/2025-09-05/rustfmt-nightly-aarch64-apple-darwin.tar.xz=1a662a55931f58be9ac05841360305f277f8b1e36f99bd0a2ee4d2cc92b7ad14
-dist/2025-09-05/rustfmt-nightly-aarch64-pc-windows-gnullvm.tar.gz=d1c3c52cf61522697d726b32ed28d7b8b4cfadf30ec57f242e8c7f9f8e09f692
-dist/2025-09-05/rustfmt-nightly-aarch64-pc-windows-gnullvm.tar.xz=2cc7cbbfa06803a2fe422ed3266f6eb519360b403c83f92259cc1b83f5ddca45
-dist/2025-09-05/rustfmt-nightly-aarch64-pc-windows-msvc.tar.gz=61f525d050d1ff4a29cc7240912d84c9c091f25195b58411af9ef176175a3200
-dist/2025-09-05/rustfmt-nightly-aarch64-pc-windows-msvc.tar.xz=504b8ace2ab7ac13be143d95ed74d94940e8706ef9f53b7778da215840337e20
-dist/2025-09-05/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.gz=ff48bd98d109310638822f5813042583900e2b70edd45fccd871c7c03dd1c2e6
-dist/2025-09-05/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.xz=b3de2bba7858e76cdafd326f3072e4c5b534ca9b679ea62caeffb07722e9a3c9
-dist/2025-09-05/rustfmt-nightly-aarch64-unknown-linux-musl.tar.gz=8ca4caedc50f09995dad7bc6e001cc863c524e28c45c186022ded589f3728709
-dist/2025-09-05/rustfmt-nightly-aarch64-unknown-linux-musl.tar.xz=8f2cfb052f9697052d89bb729d17d74583af3fa0be98f18a3c44ea518a8f4855
-dist/2025-09-05/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.gz=b12ac2a38b379bf0de4a92f29ca40e1955c45273e798edd1a72bd40253de70f1
-dist/2025-09-05/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.xz=87fb7185aa46f3810e09479dc8fafb66d13b41f4f40e9c4e866ea77fa47b1bb6
-dist/2025-09-05/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.gz=be1e8377f3d10f4f8a07ae06ab9f649f9d2fc9cfc395abaa5f0ad10a95c4fe7a
-dist/2025-09-05/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.xz=60646799fdacdafec9e0ed81357b5db70f85bb1241fe775e71b8ad3feb686116
-dist/2025-09-05/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.gz=ed8cade9b846efb5ac121aa70ac188fbd2e61fa9402fe68c80b2cbd3ee32ccbd
-dist/2025-09-05/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.xz=0d0bfbd9cd4123e0404fe476a6f16eec6e435ce28d328dc0dd0aad257b295d64
-dist/2025-09-05/rustfmt-nightly-i686-pc-windows-gnu.tar.gz=bd411db34707c36d5b60f14bba776b0b89b69d4266007a3b591c467a17ef053c
-dist/2025-09-05/rustfmt-nightly-i686-pc-windows-gnu.tar.xz=f0f2a6a81177ae6d06ff9b8f4a5bdf3bc8b26710aaf0f09258b32f7f710722c0
-dist/2025-09-05/rustfmt-nightly-i686-pc-windows-msvc.tar.gz=b49130da444e01fe4ef997b649aada8978b8dcca60dd38cf9e7400a7c7569e1b
-dist/2025-09-05/rustfmt-nightly-i686-pc-windows-msvc.tar.xz=0195cdddc74cba2bf17eaa1d53edb1a2bc0e34cdf13c7b25a34ad9729a2635b8
-dist/2025-09-05/rustfmt-nightly-i686-unknown-linux-gnu.tar.gz=1141897495ddca10fd6d9476a624b6a340fc2bfc619148e183bcf355a0078b18
-dist/2025-09-05/rustfmt-nightly-i686-unknown-linux-gnu.tar.xz=81b31bc8b3d431120005c3c8eeff3ed194dd18e56220c175c3250855cbdcddbe
-dist/2025-09-05/rustfmt-nightly-loongarch64-unknown-linux-gnu.tar.gz=10a27070239e7dfcf701669c8d93ecb2d310b9fde768639a2bf5be62cd13528d
-dist/2025-09-05/rustfmt-nightly-loongarch64-unknown-linux-gnu.tar.xz=0ac4a529f4f62a94d5ae4cc8a4a52f0e7d57296ac0884258dcc5478e6b0b1785
-dist/2025-09-05/rustfmt-nightly-loongarch64-unknown-linux-musl.tar.gz=9d0ed6778fc4f0601be1e317438cf95c414fcab6d3207c635babb4f3a6faf2b0
-dist/2025-09-05/rustfmt-nightly-loongarch64-unknown-linux-musl.tar.xz=e40b607faf2f37c9d654cc0b60c47ea155893a3b62236cd66728f68665becb18
-dist/2025-09-05/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.gz=46c029ebbfa35972b0b9e366d17c41ff8e278e01ce12634d5e3146cbf6d1a32e
-dist/2025-09-05/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.xz=8d1462fd09b04a94bfb1c1841c522430b644961995bf0e19e7c8fa150628e7c7
-dist/2025-09-05/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.gz=5827684ccb4d38956e77858ddeadeaff2d92905c67093207bed0f38202268151
-dist/2025-09-05/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.xz=975c7d7beb5b66caed7d507aaec092fdf33de2308f4dc7de46fe74e5e15b5352
-dist/2025-09-05/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.gz=8829677ab0f898c98badf22dad61094cf53c6d599b2cc76142d3d792a44f3770
-dist/2025-09-05/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.xz=3d961bead4010f8a488a065ac8a4153e3c747dfcd7d5f7eeba1cad00767a7ac5
-dist/2025-09-05/rustfmt-nightly-powerpc64le-unknown-linux-musl.tar.gz=0138c30ebe74e8ee838d9eef31c7882812bb52d2304f2de7c23c47dedd6a5032
-dist/2025-09-05/rustfmt-nightly-powerpc64le-unknown-linux-musl.tar.xz=bdb4b7b3c89a30c79f51b5fa33a2a29fc8313f8193bc43ee611e8ce7d80382d2
-dist/2025-09-05/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.gz=8e440dd400bf3eb4a144318459e111069a64bb309a5a51eeb0f0383dc48ee55f
-dist/2025-09-05/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.xz=f623e1d7d38d94965d7653fdf4a272630b2b6dec81662fbbe5d2573f2f3f3b8f
-dist/2025-09-05/rustfmt-nightly-s390x-unknown-linux-gnu.tar.gz=f46a8278352d5a981c6746b876fe19df3093090a866d20d24cd5cb081136b1c0
-dist/2025-09-05/rustfmt-nightly-s390x-unknown-linux-gnu.tar.xz=fdf8b44c6f110a33ad7f969e651ad396c880a85545aadfee8a24ca3cbed35974
-dist/2025-09-05/rustfmt-nightly-sparcv9-sun-solaris.tar.gz=59d778dea354867d64c809b40443ca0762c685dd0e5361971daab04aa7c5a5ad
-dist/2025-09-05/rustfmt-nightly-sparcv9-sun-solaris.tar.xz=18628b2888d77281fc9b2ac5636ce4ec444ab0e47bbe0e8a08238f90040c20a3
-dist/2025-09-05/rustfmt-nightly-x86_64-apple-darwin.tar.gz=169d9f2ee4a0c726040f4940370d1162502aa6568a0a442c92cad3fbc7bd95c2
-dist/2025-09-05/rustfmt-nightly-x86_64-apple-darwin.tar.xz=7f955cfa1ab07819f31cd904b0a79c67cae70090aabc7dafffdc1f3f67463248
-dist/2025-09-05/rustfmt-nightly-x86_64-pc-solaris.tar.gz=d2cc32d6be1d0f1a8654400f0418d16e789b62db3fbc0cca0d0d492615bcf6e2
-dist/2025-09-05/rustfmt-nightly-x86_64-pc-solaris.tar.xz=3dbc29c923a6a2809a8ef561d2ad375211b09dcb107bceabbf510ab0d7b471f0
-dist/2025-09-05/rustfmt-nightly-x86_64-pc-windows-gnu.tar.gz=d9b4ca2abf1062e888b31f31f517ccc6b451bd2bfdae915ec3984bc88a8be91a
-dist/2025-09-05/rustfmt-nightly-x86_64-pc-windows-gnu.tar.xz=00c6d92b6e82ae58e682e72c974f2dcc865820567ba44ed008e4759dfdbdca87
-dist/2025-09-05/rustfmt-nightly-x86_64-pc-windows-gnullvm.tar.gz=e75424d0aece8d548b2c9d896291288615d08ff2a37f1c4844a70839c612e633
-dist/2025-09-05/rustfmt-nightly-x86_64-pc-windows-gnullvm.tar.xz=cce9578d9b35bd8192a26e2dc7d7f7e7d5b9f08c7d73b3f4dde08208b448b063
-dist/2025-09-05/rustfmt-nightly-x86_64-pc-windows-msvc.tar.gz=ac4282e06b0972033f974c63d2c6cbf194d4e66a1c811f443d3fa0b886868825
-dist/2025-09-05/rustfmt-nightly-x86_64-pc-windows-msvc.tar.xz=a2465b31855861d0e0eea072bb366480acf2bafdd7fdfdab79c809d8bbf8d8e4
-dist/2025-09-05/rustfmt-nightly-x86_64-unknown-freebsd.tar.gz=30c22a97066a5711f207c1919a1d74a328540da0d9d6f85a0cc044174049c927
-dist/2025-09-05/rustfmt-nightly-x86_64-unknown-freebsd.tar.xz=40987da0b665940f9c406cfbb4889dc101d73846730b0bdfa1382d051297ad08
-dist/2025-09-05/rustfmt-nightly-x86_64-unknown-illumos.tar.gz=443ba10092122fbba9854abb4aa9d2e71d8e5e65b99fae6dd572909bf50f28c5
-dist/2025-09-05/rustfmt-nightly-x86_64-unknown-illumos.tar.xz=10285942b9140efc9897965cb3a4204145e774bd1b0c2690d45d8b04498fb917
-dist/2025-09-05/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.gz=b09af4fe367df416bce622654d9e3dfb610c564f5e6d14b200d949340595673c
-dist/2025-09-05/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.xz=1f9a585a017cee5a05190377cab105603f039fbefd9b4934278dc555dfca91b0
-dist/2025-09-05/rustfmt-nightly-x86_64-unknown-linux-musl.tar.gz=24f911745fcc9f120e44acccb98f54dc6406e492915410aae17efdd00e2752c3
-dist/2025-09-05/rustfmt-nightly-x86_64-unknown-linux-musl.tar.xz=48eb58ba1d58701dbff341e19fb6d446ed937cc410207b35297babafa29dd889
-dist/2025-09-05/rustfmt-nightly-x86_64-unknown-netbsd.tar.gz=c2d1cfdcd8a08bde3f9a635eaf2d6d2fbd82e4cabbbd459e3c47e64bf1581f11
-dist/2025-09-05/rustfmt-nightly-x86_64-unknown-netbsd.tar.xz=ed1775b4fd3d7d1203f8749f70328ea4ade802fa0a76c4d7ab3e2d63ca1535af
-dist/2025-09-05/rustc-nightly-aarch64-apple-darwin.tar.gz=4b64c4148e5cdd6585a4200125cc394c6a998da3686ef758f37742ec2d33d573
-dist/2025-09-05/rustc-nightly-aarch64-apple-darwin.tar.xz=fd45182f9db059bdc17f2c465dbaae22589eb8e8d2d88776437a34ddca3b7153
-dist/2025-09-05/rustc-nightly-aarch64-pc-windows-gnullvm.tar.gz=c14f2d7f391492d150f2f2f91af413266649cbdbdb042fc8b660b3cb141b80c7
-dist/2025-09-05/rustc-nightly-aarch64-pc-windows-gnullvm.tar.xz=d72ea1c571fe2376ef05cfd15fb3207ee2d27c3c851f3391dfbb082c06a5bdd0
-dist/2025-09-05/rustc-nightly-aarch64-pc-windows-msvc.tar.gz=3a485d8fd8d58fdfbc1216e51414aa4d90f0c7285a99abea0fa5935d2337251b
-dist/2025-09-05/rustc-nightly-aarch64-pc-windows-msvc.tar.xz=7317060a29eecd2e28d47f0ff8780150059756b07e2bc9137c3877be8af593b7
-dist/2025-09-05/rustc-nightly-aarch64-unknown-linux-gnu.tar.gz=58a53ae147de1beb0a53629898bf7c51097351271be3713a2e2344b86a4080a4
-dist/2025-09-05/rustc-nightly-aarch64-unknown-linux-gnu.tar.xz=f79d2730843dbea9e9588fd1c1b0d854441969d8f93f76021f06af2efe22b845
-dist/2025-09-05/rustc-nightly-aarch64-unknown-linux-musl.tar.gz=eddf23e28b8067021e80883faf2eb1d6d3005a6e8419a1232b84236bea286f78
-dist/2025-09-05/rustc-nightly-aarch64-unknown-linux-musl.tar.xz=4f0af1a66050f5e2d9d48b696349b9ccd420bdcfdb88b251a6655cc22a11949b
-dist/2025-09-05/rustc-nightly-arm-unknown-linux-gnueabi.tar.gz=fd2f0446e3c993d746e8a5f72ccebd8b0a49172316ac1d1c58bad10596becbf3
-dist/2025-09-05/rustc-nightly-arm-unknown-linux-gnueabi.tar.xz=0b06e7ba47621819b4e59e048e5d336b3d6978e906c7363f06bbc804e49f1046
-dist/2025-09-05/rustc-nightly-arm-unknown-linux-gnueabihf.tar.gz=97d7c34b53628f28e6636fae738a18d0f1f4c60a9febddfb7145e6b91fcf3fdc
-dist/2025-09-05/rustc-nightly-arm-unknown-linux-gnueabihf.tar.xz=323025215bf851024a7eb6566ad7dc5719832d81e8d46e70adaece98adc5644b
-dist/2025-09-05/rustc-nightly-armv7-unknown-linux-gnueabihf.tar.gz=3017e03222d030448ffe2805624143540197bd6d3b3e93f9f73469ace25ae4be
-dist/2025-09-05/rustc-nightly-armv7-unknown-linux-gnueabihf.tar.xz=4f6e86b185fb54f7a0b7d09a0faae7daac722351354f6abebd388efb3037dfa0
-dist/2025-09-05/rustc-nightly-i686-pc-windows-gnu.tar.gz=292c3770b96cde97072d70c58234488f955ed5582b7c3044c6de66891e73d639
-dist/2025-09-05/rustc-nightly-i686-pc-windows-gnu.tar.xz=6855d3fd9040fb4da554fd732eaf8a1c723921c35bb8a8efb31c78af69b2e4ec
-dist/2025-09-05/rustc-nightly-i686-pc-windows-msvc.tar.gz=64a86a2971ed9934bbb6aaa0afc2a7f747da463afb55b51a7c5fdbdaa294e437
-dist/2025-09-05/rustc-nightly-i686-pc-windows-msvc.tar.xz=c98f1fc3e077b8c8eb3e526c416a6551c08c62e58be57b4a4c7d59670bc435f9
-dist/2025-09-05/rustc-nightly-i686-unknown-linux-gnu.tar.gz=5481c97d788899f896473380dde0877808489bc4a0ed6d98265558631fa67a57
-dist/2025-09-05/rustc-nightly-i686-unknown-linux-gnu.tar.xz=afadaae945c0b9a8b50dbdee28791e0c03c880cb22d3c20996eeb7fab94df0bf
-dist/2025-09-05/rustc-nightly-loongarch64-unknown-linux-gnu.tar.gz=18b276a2464b6c5a817d72384f25442c7619cac05b2d8d0af212c0dad96ccfc6
-dist/2025-09-05/rustc-nightly-loongarch64-unknown-linux-gnu.tar.xz=b74323cd2dbee966eebe8e63e24fae026ecd900a025e9167cca0341e50333cc3
-dist/2025-09-05/rustc-nightly-loongarch64-unknown-linux-musl.tar.gz=916dc5144107d9173479b320b55b0a95d2d42156c69fbdb0f21377d825fe0892
-dist/2025-09-05/rustc-nightly-loongarch64-unknown-linux-musl.tar.xz=3a83da72aa4a6553ecd957af35a05274528dc79f87d24d8470c20b8b4478b05b
-dist/2025-09-05/rustc-nightly-powerpc-unknown-linux-gnu.tar.gz=59e031b6b79a1f11406c0640e1a357f2941967ea8c034a94148d60928038e58e
-dist/2025-09-05/rustc-nightly-powerpc-unknown-linux-gnu.tar.xz=53f0e33cf2651d5dc8931ec5af8f04994188d8f9a10a5c61bd72cc822df34501
-dist/2025-09-05/rustc-nightly-powerpc64-unknown-linux-gnu.tar.gz=0eec56e3b725d918cb21e494a803b2e38eb6d744f64f1a82481a4c704eb7c1f0
-dist/2025-09-05/rustc-nightly-powerpc64-unknown-linux-gnu.tar.xz=5efc97abb235f349c6cc952b4a1e4dae7d56d70b0f8b8da2a1060b85f9b734fd
-dist/2025-09-05/rustc-nightly-powerpc64le-unknown-linux-gnu.tar.gz=cb45bbcdf8841b1ac184a0aacc909f153c830e8051260e09ca4e32c1f048e2fb
-dist/2025-09-05/rustc-nightly-powerpc64le-unknown-linux-gnu.tar.xz=1c9ddddb90d45612e4fd190fb71e527b523df13146343dde200580fb2b638794
-dist/2025-09-05/rustc-nightly-powerpc64le-unknown-linux-musl.tar.gz=3a9bdd4d14e8f121d3051944ee83a901b5ca4c0921f2d01e34596fb7450b49e3
-dist/2025-09-05/rustc-nightly-powerpc64le-unknown-linux-musl.tar.xz=732b9abb8a80191884fe1ff1d4d923cc1b74c21b81e6327bc5979ae526337400
-dist/2025-09-05/rustc-nightly-riscv64gc-unknown-linux-gnu.tar.gz=1826e74200fe286478e1659ab88ea86b43efa7b023074d00dbc814d80bebc883
-dist/2025-09-05/rustc-nightly-riscv64gc-unknown-linux-gnu.tar.xz=c30b52d0f474fd6193bb1b3e147fb79fa8cc31e5db38444f023d84d1c2d93d12
-dist/2025-09-05/rustc-nightly-s390x-unknown-linux-gnu.tar.gz=c330067621ed25d8383f27e494346eca4d7d4866e48f331f2ec897ff1c386e56
-dist/2025-09-05/rustc-nightly-s390x-unknown-linux-gnu.tar.xz=cb4097ea582a83a94cab80ff2f36b6f7141c140d75c30b1d261a1ddd4ea45bd4
-dist/2025-09-05/rustc-nightly-sparcv9-sun-solaris.tar.gz=0af19e764f10333017a3ab66020b82c7185ad648d1230b68f10977e0affb937f
-dist/2025-09-05/rustc-nightly-sparcv9-sun-solaris.tar.xz=a22cfb55cdd122dd99bf3566eabd781bb2ecded90c71a41fd33b1e0588bcc39c
-dist/2025-09-05/rustc-nightly-x86_64-apple-darwin.tar.gz=163a07b91e36e85c6c41368598793667414cdc6cadc980866811234539f3aec3
-dist/2025-09-05/rustc-nightly-x86_64-apple-darwin.tar.xz=76711800685b39b3b75945395682062c40efe3195f9979784bf318837e21768a
-dist/2025-09-05/rustc-nightly-x86_64-pc-solaris.tar.gz=69142a6c04703c3c8309c6fdf66b25831bf9efa3ee70cc93da4b5b75f901b29a
-dist/2025-09-05/rustc-nightly-x86_64-pc-solaris.tar.xz=7e535f4aa136284e4bdfd4d56891caac6844dab91e1b711fa3914a5974dfcb60
-dist/2025-09-05/rustc-nightly-x86_64-pc-windows-gnu.tar.gz=ff0ea563126ff28df297258001d9fac4dbd85788b5d27a0f5d6be75306f21139
-dist/2025-09-05/rustc-nightly-x86_64-pc-windows-gnu.tar.xz=6b66adcaa9a5332979591464242423897f59276e9e2cbeb9ab038a72e72c3a5c
-dist/2025-09-05/rustc-nightly-x86_64-pc-windows-gnullvm.tar.gz=64cac5e377bc115a8f8176719575903e695337941db43cfb35546d65c0723130
-dist/2025-09-05/rustc-nightly-x86_64-pc-windows-gnullvm.tar.xz=11e2765e4b3e2296ea05ecf735cf7b5f7beb08d76d12449cfae67f88bab02819
-dist/2025-09-05/rustc-nightly-x86_64-pc-windows-msvc.tar.gz=c7d15ae7cd5af774ae70e63fec3ba8723b85fa4c4640917b3960907eedb30b39
-dist/2025-09-05/rustc-nightly-x86_64-pc-windows-msvc.tar.xz=55036567af270cdac046fb4306e515787ca6ef5073617311fac79fb87ffe9366
-dist/2025-09-05/rustc-nightly-x86_64-unknown-freebsd.tar.gz=2d24470d2bb4c4d2605c15f1b2654cc45805384babb73b1960e8aea0b8cc227d
-dist/2025-09-05/rustc-nightly-x86_64-unknown-freebsd.tar.xz=fa41782cb2e22aba30d1619db1f478c0305944ceb4de1d1001f221c5c68c104e
-dist/2025-09-05/rustc-nightly-x86_64-unknown-illumos.tar.gz=d0f9785f76c59f3a67a499cfff4a5639f3ae05cbc76750b867faaa60b7d67f78
-dist/2025-09-05/rustc-nightly-x86_64-unknown-illumos.tar.xz=925e473c6e31d8811879a805358cfd2e5ab8f4de836c270d02dc8403771bed3a
-dist/2025-09-05/rustc-nightly-x86_64-unknown-linux-gnu.tar.gz=ebac845114b89dfe7d0efc0cfe8820902faad617ed21eb2a701d73cf7b544a85
-dist/2025-09-05/rustc-nightly-x86_64-unknown-linux-gnu.tar.xz=2512a5462e3f46c95ed4aba4228282a357b3e0694e9db117a857196448fe7bcc
-dist/2025-09-05/rustc-nightly-x86_64-unknown-linux-musl.tar.gz=b4a5d364b84464e9a92140fff50349d4942b8d970b64150a4bc6d720cc6c4a4e
-dist/2025-09-05/rustc-nightly-x86_64-unknown-linux-musl.tar.xz=6c57c2edc305737530f8551d789ee79ff952f42a0d52d6f8d7d7f1ea2027cfca
-dist/2025-09-05/rustc-nightly-x86_64-unknown-netbsd.tar.gz=f3192ded327875d5a27fb50c690e3fce36669e8f71c47de304dc21edad573ff9
-dist/2025-09-05/rustc-nightly-x86_64-unknown-netbsd.tar.xz=11359e4731866f6a788e5699867e45befdf1ad49ef35c0aba22af76d3f327cc3
+dist/2025-09-16/rustc-beta-aarch64-apple-darwin.tar.gz=3e3fbcf51f2632b8890b38537ea5446147b85fd62b21798b4fb2a032a4abd6c9
+dist/2025-09-16/rustc-beta-aarch64-apple-darwin.tar.xz=296ef2ae4dc8b4f411423a4384821e5b8e305be809b55522a0f02c97b83ce14a
+dist/2025-09-16/rustc-beta-aarch64-pc-windows-gnullvm.tar.gz=fe7026f1310a84f3490d0ffb8476bddc36992fcb2d7e450c036aae6bbbb218ef
+dist/2025-09-16/rustc-beta-aarch64-pc-windows-gnullvm.tar.xz=70bd356d7f39ff1ef8511941671caae84f43d3a9ab493ed131467d27bf5c53f1
+dist/2025-09-16/rustc-beta-aarch64-pc-windows-msvc.tar.gz=9b0f42d2713c20d1df9e401410f874f04ffbff2e0c61d19d2f8689d4e55da562
+dist/2025-09-16/rustc-beta-aarch64-pc-windows-msvc.tar.xz=086ff4c532289581325b1cb5c629f899418dd392249d3c0bd2137a0d73ebccca
+dist/2025-09-16/rustc-beta-aarch64-unknown-linux-gnu.tar.gz=4860148593cc5f5662cb89c9484d71af472223b8a9f9644e6709802154e7d02d
+dist/2025-09-16/rustc-beta-aarch64-unknown-linux-gnu.tar.xz=a7f290455c134c72518267e7dfc5a51d550497ffcf539dac3b41c57486e1d370
+dist/2025-09-16/rustc-beta-aarch64-unknown-linux-musl.tar.gz=7a17d7a65ca7c933de8829e5991f991d917df7007c122fc55d64efa0fe53344a
+dist/2025-09-16/rustc-beta-aarch64-unknown-linux-musl.tar.xz=6ab69fc25888475048dc5eac7adc7f6b02295dc7de7d0e92aad5ff562c500322
+dist/2025-09-16/rustc-beta-arm-unknown-linux-gnueabi.tar.gz=00ff0a967ee41642e6b316b190485a7d04c6749ff571e55cf73548b0e7d74b05
+dist/2025-09-16/rustc-beta-arm-unknown-linux-gnueabi.tar.xz=ce2c11e633e367544a70b0a3ad998a2d680277e62ece3eacbf350fa1ada6332a
+dist/2025-09-16/rustc-beta-arm-unknown-linux-gnueabihf.tar.gz=ded847d958f0417fba13e71ded42cee387387076b4426b2f2002d53dd998c27c
+dist/2025-09-16/rustc-beta-arm-unknown-linux-gnueabihf.tar.xz=54ee1d25f57db5d1c2b153533362ecb7fd326b8dd46b8240367ea865a059ca68
+dist/2025-09-16/rustc-beta-armv7-unknown-linux-gnueabihf.tar.gz=8f964d41f6608ba04d2d84f5532a057654f3f328b19bc6ee4b9a88f6f64dcec7
+dist/2025-09-16/rustc-beta-armv7-unknown-linux-gnueabihf.tar.xz=b6a34332cb027345f54f75e03cee1c65345e8671df081e8dd23111d2233bf6e6
+dist/2025-09-16/rustc-beta-i686-pc-windows-gnu.tar.gz=760c5f1bc081a14b4df2e0c6a1ce80d96b63e15e0b751cfe535eb5775aa9e34b
+dist/2025-09-16/rustc-beta-i686-pc-windows-gnu.tar.xz=4376609352714e1e30a4b0c57fe43beb2b0edccda412e18e11c3b8b3092a87d0
+dist/2025-09-16/rustc-beta-i686-pc-windows-msvc.tar.gz=3d0f08e30f4ae2cb513548f66cc6405ba0c2cc74e826c04cf0bdad3d3c14bcfa
+dist/2025-09-16/rustc-beta-i686-pc-windows-msvc.tar.xz=a68b01fb491496bb2b8861af9b900a2960f4ea9f64f0946caa09c043ecb3df2f
+dist/2025-09-16/rustc-beta-i686-unknown-linux-gnu.tar.gz=3b56ab8e485b3e4bd5c0f1e1ff30389acb9d0d0e0662ff834fb3a855157c965a
+dist/2025-09-16/rustc-beta-i686-unknown-linux-gnu.tar.xz=fe871e45e0d987dcaa6a30df8394c54da0204965686a089d6903fff75b8a01e5
+dist/2025-09-16/rustc-beta-loongarch64-unknown-linux-gnu.tar.gz=71d53cb70f1962379614c86b07fdea7c1b343587a56734d39aa7de29667d6629
+dist/2025-09-16/rustc-beta-loongarch64-unknown-linux-gnu.tar.xz=658f204ab2536ad3b56f238c55c5c6cf3bd7794aceff379f0f5492d28841b5bc
+dist/2025-09-16/rustc-beta-loongarch64-unknown-linux-musl.tar.gz=0fe154b5b305259a36b80b9b53894336ceba1562155c05cf92debc5d7bb7e645
+dist/2025-09-16/rustc-beta-loongarch64-unknown-linux-musl.tar.xz=27357f4331d5c357a7b20002571276e2d77e58384095fd3a6910d44a0d85aa87
+dist/2025-09-16/rustc-beta-powerpc-unknown-linux-gnu.tar.gz=bf87cb1717fad96abbb86091c44de6bdeed2bd60437ffa9037d27dda1c71cdbe
+dist/2025-09-16/rustc-beta-powerpc-unknown-linux-gnu.tar.xz=778d126b47dc5ef07085c5c760399130219cda6221f6f4ec57c26ebdd7e33299
+dist/2025-09-16/rustc-beta-powerpc64-unknown-linux-gnu.tar.gz=eae03019370901fb49b708c76d001ec9e3df27e7fa1ea9ceb2200640e9d6dfea
+dist/2025-09-16/rustc-beta-powerpc64-unknown-linux-gnu.tar.xz=61c1b21acc668bdf36cbf64f2b53348d997ffc9997c6ad282d10226e86740044
+dist/2025-09-16/rustc-beta-powerpc64le-unknown-linux-gnu.tar.gz=057eb2050b31110529a80e27c6df0c95a14bb1f7c568b487dd3a718755a74d27
+dist/2025-09-16/rustc-beta-powerpc64le-unknown-linux-gnu.tar.xz=cb3078b44dbb6793ac98a28bd6bd7076c28ae13c5ddd1aa02310ec89130b6575
+dist/2025-09-16/rustc-beta-powerpc64le-unknown-linux-musl.tar.gz=9a5109124546788b802be36d9415bf0d5bfcc087389156c65a2e30672e10e7b1
+dist/2025-09-16/rustc-beta-powerpc64le-unknown-linux-musl.tar.xz=6987de797339aa2f231485897b0a498a841a49f1d0b83fa7e98c0a76767cbe44
+dist/2025-09-16/rustc-beta-riscv64gc-unknown-linux-gnu.tar.gz=17cd423d53f6d8fe53dff7abada43d545a2de14136eae7cd02b958f9fe93f5a0
+dist/2025-09-16/rustc-beta-riscv64gc-unknown-linux-gnu.tar.xz=740945fe14eeea917d64ff47e997ca17be1e0f14dca30632a9fbfb560405b040
+dist/2025-09-16/rustc-beta-s390x-unknown-linux-gnu.tar.gz=52e15e3a56a16b2989b34f0a051ff06fb8dd51be3e6874c41a4ba1e2128d35ff
+dist/2025-09-16/rustc-beta-s390x-unknown-linux-gnu.tar.xz=6f998aede2a805d8159f2ea63dda76a7d25eb9cdbd26863394aacfa6d80de084
+dist/2025-09-16/rustc-beta-sparcv9-sun-solaris.tar.gz=45c85ec3de0a773b2c2f4b624abe28c3a906020e1ce6ceded75c0099a1fc1899
+dist/2025-09-16/rustc-beta-sparcv9-sun-solaris.tar.xz=d811ff717ebc59aa9bc5c26ee4b8dcfdb3d2f5a1759179eccf549c8a765fb3dd
+dist/2025-09-16/rustc-beta-x86_64-apple-darwin.tar.gz=d31302c29a9efe362d2be87b83b229d5369b2462cea133f9b1b4c7c4cf0f26dd
+dist/2025-09-16/rustc-beta-x86_64-apple-darwin.tar.xz=b8f9f0b2e4c681da9bf7fbac2fc22ec2f44c136b368821bfea5a5ab29d85527a
+dist/2025-09-16/rustc-beta-x86_64-pc-solaris.tar.gz=498902a6de8cae1494aae6223604381c4e109a38c14649f6e27b075d3f26a685
+dist/2025-09-16/rustc-beta-x86_64-pc-solaris.tar.xz=1cfaeae163fcd4dd2ff44a80c245012576ecb4257d7d763a51f2d7e58878a29b
+dist/2025-09-16/rustc-beta-x86_64-pc-windows-gnu.tar.gz=d4c6fa5158c83500d30ef44e129889408dbc49ec862c985a1c36820d3550e94d
+dist/2025-09-16/rustc-beta-x86_64-pc-windows-gnu.tar.xz=17bd90bfd6603b24d26397acac55e4b2c23b0dc574834de7bc1f8c2c720aab97
+dist/2025-09-16/rustc-beta-x86_64-pc-windows-gnullvm.tar.gz=d270c52fec5ef2e9f009cc3e697b6188320fbeb5445092c7a11af67e520cc9f0
+dist/2025-09-16/rustc-beta-x86_64-pc-windows-gnullvm.tar.xz=81f91fc07821af63606268821a039578a7c9b09b8c0e96b85163831fee92e6a5
+dist/2025-09-16/rustc-beta-x86_64-pc-windows-msvc.tar.gz=233356bbd9a46168663752d7dcab67e7ae3ae732fab410bc8adb84230e22398f
+dist/2025-09-16/rustc-beta-x86_64-pc-windows-msvc.tar.xz=5f33d8b3a064235c23dfd2edfa8b5f6f2c5075d26529f81881501b8323eae60d
+dist/2025-09-16/rustc-beta-x86_64-unknown-freebsd.tar.gz=fda4fa10690458ee7db6081267458e47113e854d65695c95813039400772e263
+dist/2025-09-16/rustc-beta-x86_64-unknown-freebsd.tar.xz=570cd878e440b5d70a0d5fc90917b92a6b8b544a2e6844baafee1fef22d32732
+dist/2025-09-16/rustc-beta-x86_64-unknown-illumos.tar.gz=f8b7273e16de291fad24f2ebbd928b55007a75605fc25ddc35a4967f17e709f6
+dist/2025-09-16/rustc-beta-x86_64-unknown-illumos.tar.xz=77d7f5de006a9d0c56a2cf79423a5702bff445f6e34b4935326d3db30ac8b086
+dist/2025-09-16/rustc-beta-x86_64-unknown-linux-gnu.tar.gz=f61a57a75252d63930630af7d597f3046b7f7f09691cd6ff8c3a080871fa19de
+dist/2025-09-16/rustc-beta-x86_64-unknown-linux-gnu.tar.xz=b56298c4ba7a955ecb9135bba06ff6bdb7f4df94b6d64c99460e90e5a022fb87
+dist/2025-09-16/rustc-beta-x86_64-unknown-linux-musl.tar.gz=c6fec77bf71bf35ded56cf70eca28a94e083e0af458b00ed665eedf9270abd73
+dist/2025-09-16/rustc-beta-x86_64-unknown-linux-musl.tar.xz=bce669d29a995189e9d99f686b1f9535ad82cc877a106c89af5b423bef8a9d6f
+dist/2025-09-16/rustc-beta-x86_64-unknown-netbsd.tar.gz=cb1a0f5ff6d9c28b83f9c82fcfbf404b2920a7da8233d957e43fe001d5190318
+dist/2025-09-16/rustc-beta-x86_64-unknown-netbsd.tar.xz=25953b44e3b196e89b5dc6028805517f42f6367c6b990a930ba44f63dce0a855
+dist/2025-09-16/rust-std-beta-aarch64-apple-darwin.tar.gz=8ada740b1af444b98c3df74f5f810a05036b6195e6b54115a7e34bed23a30d1c
+dist/2025-09-16/rust-std-beta-aarch64-apple-darwin.tar.xz=1211a726975c1a9fbd679156644b83c446cab4d6eb7728d3dc38db6c949b997f
+dist/2025-09-16/rust-std-beta-aarch64-apple-ios.tar.gz=58e7ec536d9bee83dcbcdad819c4a27689f02a20acbc75ffcb6ceeec7929da4f
+dist/2025-09-16/rust-std-beta-aarch64-apple-ios.tar.xz=f0afe719f83531e0c22d0621b9137d30bacd17ffcc9d0188e9cee2a71f10afa0
+dist/2025-09-16/rust-std-beta-aarch64-apple-ios-macabi.tar.gz=e1f067b248dfcf1d6efbc589a0938ceeaa81087d041889d65b90f4f82aeb35ff
+dist/2025-09-16/rust-std-beta-aarch64-apple-ios-macabi.tar.xz=182ad0986236f21ba93d49ed3dbec72e54cbc88d18adf77848e87f497b7b2f05
+dist/2025-09-16/rust-std-beta-aarch64-apple-ios-sim.tar.gz=cd367dce5dc4a5d209db298f97070e55ec16caa8931ef17a189bf5d7f5c21212
+dist/2025-09-16/rust-std-beta-aarch64-apple-ios-sim.tar.xz=b51aba09d7ced8b69e15ec9ca381379cf9f910c1f89109c8764cc15d51fd8293
+dist/2025-09-16/rust-std-beta-aarch64-linux-android.tar.gz=89154dba00da80cd67cff7e9beb1f68721bae9686e1fcff1379a2a4f549eec79
+dist/2025-09-16/rust-std-beta-aarch64-linux-android.tar.xz=d373ed69ed30521b2f724deac051662bcc7d4a919c1ff9f56b59ef028f07dcf0
+dist/2025-09-16/rust-std-beta-aarch64-pc-windows-gnullvm.tar.gz=9e84923928671f76762752a559d0e9a54f513b2f518eaad3da6f5772e46183c0
+dist/2025-09-16/rust-std-beta-aarch64-pc-windows-gnullvm.tar.xz=9170e87332e2a74624fa1dbaddb725f6cb331a8f65a5b0b2781c04aa58bc48fe
+dist/2025-09-16/rust-std-beta-aarch64-pc-windows-msvc.tar.gz=929786491660eedf2cb6c02036ce560043a7bec349bde762effa53ba59d17c81
+dist/2025-09-16/rust-std-beta-aarch64-pc-windows-msvc.tar.xz=72b395a15c0af1c92434a95010fec5435343190c3b90d55d2c7d17d3d4c6da52
+dist/2025-09-16/rust-std-beta-aarch64-unknown-fuchsia.tar.gz=36245bab64c4757821ca0732fe88fb5620601035f50bcd2d061386903abe7027
+dist/2025-09-16/rust-std-beta-aarch64-unknown-fuchsia.tar.xz=4c1bfe4453d36d554956f7ebb169bb81912815a28960bd7caf977940109573f1
+dist/2025-09-16/rust-std-beta-aarch64-unknown-linux-gnu.tar.gz=080603e3b117d3654b2e0b88ec172f4c5319ebadf9386074e7e6f0c466e9c90a
+dist/2025-09-16/rust-std-beta-aarch64-unknown-linux-gnu.tar.xz=4ea35b78b18a121bd3b0165d9f3278f3a454e108564e02b6c7d7133a33a99788
+dist/2025-09-16/rust-std-beta-aarch64-unknown-linux-musl.tar.gz=9c5b7188fed949b0462f9d6c45221b8b98e7feebdc4f8bc2d6d0d652cf3b3c24
+dist/2025-09-16/rust-std-beta-aarch64-unknown-linux-musl.tar.xz=31514db13f19dea13e47b8eff9fd8daec6bd0a73816aefadb94ad4e771d6a902
+dist/2025-09-16/rust-std-beta-aarch64-unknown-linux-ohos.tar.gz=a540735416f0b264444281865e1ed450c5bd58275f73426191cfb547b674ea7a
+dist/2025-09-16/rust-std-beta-aarch64-unknown-linux-ohos.tar.xz=9922ad22f002f5df232d8ed1dcdcd23a5e1a0a5b4b27e27c3b5fbd5b39087d03
+dist/2025-09-16/rust-std-beta-aarch64-unknown-none.tar.gz=618073f52e27d3ebd15b028398524a12e3bd91d4147e70b2160430e03ecdb178
+dist/2025-09-16/rust-std-beta-aarch64-unknown-none.tar.xz=3fa92c9383ac122c4b9ea2a00ff9f38d94b52c384b418b13ea573115daa07563
+dist/2025-09-16/rust-std-beta-aarch64-unknown-none-softfloat.tar.gz=33c4825523ef0e27b038111d3504cfbb4e049fcc3e136ddec186268346b647d9
+dist/2025-09-16/rust-std-beta-aarch64-unknown-none-softfloat.tar.xz=4487b93a8c7ac712328c98a660948e795e833f4edd3c92449df5472de6e320b9
+dist/2025-09-16/rust-std-beta-aarch64-unknown-uefi.tar.gz=f0c275d8bd220dc066541e6f2c7e41b6d019d698fa2b613c1f9c87ab4e29f4af
+dist/2025-09-16/rust-std-beta-aarch64-unknown-uefi.tar.xz=daed68a82600fe2f3652ae87e4c491460891906fcd06ae206bc794c354771564
+dist/2025-09-16/rust-std-beta-arm-linux-androideabi.tar.gz=9fa058b5bd0ac5af231cc5ee31f67cf3f16b361a41aceb43b17c81d8e180d16e
+dist/2025-09-16/rust-std-beta-arm-linux-androideabi.tar.xz=c6868144f5f5fdfc0d993f66fa91a01a91e0288014a7ab5d6233a93447508852
+dist/2025-09-16/rust-std-beta-arm-unknown-linux-gnueabi.tar.gz=5cd076f756c63e54067d780167da3e35bcb04f487fefa093028b0cd3435a2fcb
+dist/2025-09-16/rust-std-beta-arm-unknown-linux-gnueabi.tar.xz=3322a270f3696fc2254536608ebc49e047ad59e1a01493381c9c52f813bcb8ae
+dist/2025-09-16/rust-std-beta-arm-unknown-linux-gnueabihf.tar.gz=8bed8176ed380d974c2bc6df5314ac385ca6b72a623a8d16c00b753932a64db9
+dist/2025-09-16/rust-std-beta-arm-unknown-linux-gnueabihf.tar.xz=d557f55446ba39a1b3335ff1e4196ab40effa4ba42b2ce91bbde93738fd93da0
+dist/2025-09-16/rust-std-beta-arm-unknown-linux-musleabi.tar.gz=12a56e9f5c9caf4e262b9361af5ea5b62ec29b18ffdb807cda83655c531670b5
+dist/2025-09-16/rust-std-beta-arm-unknown-linux-musleabi.tar.xz=82b28e64f6278cb24573d699b14826a51be465b68cb48e767a26f1938221f5c4
+dist/2025-09-16/rust-std-beta-arm-unknown-linux-musleabihf.tar.gz=a3076f1f12895062e42a8ceacd5c06a3156b5a553c708615fddb975366d9424a
+dist/2025-09-16/rust-std-beta-arm-unknown-linux-musleabihf.tar.xz=4bf81edd4a193e6850bccbffb66c6005b1b99322192e87183d684dd9ec528cad
+dist/2025-09-16/rust-std-beta-arm64ec-pc-windows-msvc.tar.gz=2170d924f4ccc579baf862171934029505d476170825397580154dfab860d4a8
+dist/2025-09-16/rust-std-beta-arm64ec-pc-windows-msvc.tar.xz=dc3bdf6f93b32aa19987d149ed7da7616f3785f67a63fcf1e0d1aebeb8007d67
+dist/2025-09-16/rust-std-beta-armebv7r-none-eabi.tar.gz=2863a22ce3663edd346d730cac4bbdef3b9cd2ea2cd5907dcbc61220833e24e8
+dist/2025-09-16/rust-std-beta-armebv7r-none-eabi.tar.xz=74a752daef0446ed260845b016b3e57d20de4e914102713e0c3b652329f9f6f1
+dist/2025-09-16/rust-std-beta-armebv7r-none-eabihf.tar.gz=8fc3fcf203da0fa6f321abbda405ba0121dbd898ea02513431a5ca3dd5e6e16d
+dist/2025-09-16/rust-std-beta-armebv7r-none-eabihf.tar.xz=65cfd5061c4db0963b28f7bc636ece115ff7b812710ba9f902977f5014bdeafd
+dist/2025-09-16/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.gz=1cb760fdde8e9d84c5caa787488f0bb05c5e649f411b666f2d6a5440126f5992
+dist/2025-09-16/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.xz=9146b64438a68c506a93ae3c4d4d1a928358b562fac3b7513a95c8098cebdae0
+dist/2025-09-16/rust-std-beta-armv5te-unknown-linux-musleabi.tar.gz=9df691f77c95a0bdf5c45fc546c2319863cdca4d433780fe8c7cd146496382b8
+dist/2025-09-16/rust-std-beta-armv5te-unknown-linux-musleabi.tar.xz=bba043357ba6c78fd46430c169710a264109ee5dadb79b98075744bac273418c
+dist/2025-09-16/rust-std-beta-armv7-linux-androideabi.tar.gz=ab5726ae0472a8563b7e1e0dd6de32e1e9ee2dca45259bd1d382a24167919c61
+dist/2025-09-16/rust-std-beta-armv7-linux-androideabi.tar.xz=5af2a58f78fcd9dbcf1fac95cb50633ab9128e1e728960c0025e310a5528326f
+dist/2025-09-16/rust-std-beta-armv7-unknown-linux-gnueabi.tar.gz=9ff1f79f8c03756b41f8386995dbb011387982a657262c013579d0866a18ff1d
+dist/2025-09-16/rust-std-beta-armv7-unknown-linux-gnueabi.tar.xz=32dd8b2be52449b4e592a87acfba122b80990d2993fa81b48b81c0de4afb1533
+dist/2025-09-16/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.gz=7420a4ecd9ebb55b6864a22fedec9def0585f8460eaebbcd9e236cac2ae0a6a8
+dist/2025-09-16/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.xz=75de468d6d4041d77e5757118c3c93df6319f30ba6372fdc8e859b9e48f27d81
+dist/2025-09-16/rust-std-beta-armv7-unknown-linux-musleabi.tar.gz=96f7dbe5d4bfe852b22f971cb59b7fa0981fd7fdc9e8d28fd1b6f6ae3bc59bfa
+dist/2025-09-16/rust-std-beta-armv7-unknown-linux-musleabi.tar.xz=4166e6b0c28eca8a507f1d3c83948ba09361198466eeb648f491d9850e884df9
+dist/2025-09-16/rust-std-beta-armv7-unknown-linux-musleabihf.tar.gz=035c4db6428b912280ac56bb520bad29255b3c30bec0e89839721443109a7ce5
+dist/2025-09-16/rust-std-beta-armv7-unknown-linux-musleabihf.tar.xz=4a94449dd1f02d748c79ec1aed3907cbce97dc5641e5be3b3011234ef3517987
+dist/2025-09-16/rust-std-beta-armv7-unknown-linux-ohos.tar.gz=94006dd7c1a1d6cb28972369a0b0c429de992d541549d4b292fd6b737eacce24
+dist/2025-09-16/rust-std-beta-armv7-unknown-linux-ohos.tar.xz=bb5cce4d13f2ae9d9d6f254d021d516189f29b6e78f3c1824e0803f7856ce7e9
+dist/2025-09-16/rust-std-beta-armv7a-none-eabi.tar.gz=453d62c4392ffd108233b7ce9b6abf0cc04b28a63bbbc5b979927ed7e9f8481f
+dist/2025-09-16/rust-std-beta-armv7a-none-eabi.tar.xz=9b4093e7735ffe3c79f16f99a412492588a6652242e2a18c0f278e24e34cb333
+dist/2025-09-16/rust-std-beta-armv7r-none-eabi.tar.gz=293dcff7ac56a7f52fbfa1afef9fa2b4a3e14b9b418c5a56e12e8c7cc76c963f
+dist/2025-09-16/rust-std-beta-armv7r-none-eabi.tar.xz=75f3737b88d197769d999b484aeb6aff705696fdccec8f3772c7a1e10630b146
+dist/2025-09-16/rust-std-beta-armv7r-none-eabihf.tar.gz=3d988af87a2c90efc5674f77baf67f5933fe60ae6ab9f4eb4256f14d98446824
+dist/2025-09-16/rust-std-beta-armv7r-none-eabihf.tar.xz=e91a15900421a8a445a7a0038923ad197fea4ec19e972ba7ff75fd4dd7d7ac12
+dist/2025-09-16/rust-std-beta-i586-unknown-linux-gnu.tar.gz=19795fe21f305ed033354d127f8e9e7aa0e9d7c67f756d22beb161aaeb9a0742
+dist/2025-09-16/rust-std-beta-i586-unknown-linux-gnu.tar.xz=8afa409edf8dfb45eab3565add6dde2fa71118008ee1e7e1416fb8dc11f66fde
+dist/2025-09-16/rust-std-beta-i586-unknown-linux-musl.tar.gz=43aaa9101863b6a419330ec75f0ffde61faf2a27f050947d2a200e5a705dd085
+dist/2025-09-16/rust-std-beta-i586-unknown-linux-musl.tar.xz=86ac890f2aaee4382a126ad9e667d53039dbca550aa548090706bdc308749962
+dist/2025-09-16/rust-std-beta-i686-linux-android.tar.gz=c3df364048b9af096c607a8e5639dc37d470ab125441ea04a2f2241766338bd5
+dist/2025-09-16/rust-std-beta-i686-linux-android.tar.xz=556bb5e7e4effb543c04a64cba683b81a6ffaa319cf1d053482968767480b9b9
+dist/2025-09-16/rust-std-beta-i686-pc-windows-gnu.tar.gz=8c141a8c3b4cdbc2eff61d2a557fa602b9039dd54ff2000d0a0b790ae58c0879
+dist/2025-09-16/rust-std-beta-i686-pc-windows-gnu.tar.xz=3995a3c391e242663533680600a38343396e2a73b6876b1dd691d83dd143eac7
+dist/2025-09-16/rust-std-beta-i686-pc-windows-gnullvm.tar.gz=3da461c03124d6ca148ed1d4cc80be4bd0d9f4610df95770ca800d72ef6c2b4f
+dist/2025-09-16/rust-std-beta-i686-pc-windows-gnullvm.tar.xz=7eaba102d1ce8ea0461657dcce62a5f8826f2154f56f89e9385e75fdc763c399
+dist/2025-09-16/rust-std-beta-i686-pc-windows-msvc.tar.gz=d1e31c04ff2145122df2ab05af6e2ba1091d1788741234cc39524f1289886187
+dist/2025-09-16/rust-std-beta-i686-pc-windows-msvc.tar.xz=330aca62a0cb38342ce6eda427c6074651ddd0c83c4b28b53ddc736edf049ee5
+dist/2025-09-16/rust-std-beta-i686-unknown-freebsd.tar.gz=48dabb6775c14d23bf04a8c5c26f2e4d6af369dff6d506aa08cf2a08d75a5d8d
+dist/2025-09-16/rust-std-beta-i686-unknown-freebsd.tar.xz=db97db17addbf5d4e314f77ac9bb232a661042edf7beeed73b252e44c6439fe8
+dist/2025-09-16/rust-std-beta-i686-unknown-linux-gnu.tar.gz=3abbec5a87dfe240bbdaf6e9a92acb2d8e6e684983803daadc7750290da71264
+dist/2025-09-16/rust-std-beta-i686-unknown-linux-gnu.tar.xz=568aec0d1427a2d866c7550dfc770be13401902741999410d4dc2e7772ec0a57
+dist/2025-09-16/rust-std-beta-i686-unknown-linux-musl.tar.gz=0739e8dcab50c87156cb3e52a18b57da6040fffd9509561fb3046e81be953a40
+dist/2025-09-16/rust-std-beta-i686-unknown-linux-musl.tar.xz=8ed8a4b1f402593db73fc2e9540664d9e4e12b8e1b5f027e56b2f3c4784a8995
+dist/2025-09-16/rust-std-beta-i686-unknown-uefi.tar.gz=40a2726131ef0e6102667bcc8ea9a64b4b19f12d58696ab434b74f9abf37cee0
+dist/2025-09-16/rust-std-beta-i686-unknown-uefi.tar.xz=500b0018fe01e9a9949ca077bb69426078a2774e83b95319d09bab5d3f6d0e04
+dist/2025-09-16/rust-std-beta-loongarch64-unknown-linux-gnu.tar.gz=64aadbe1da544e2f08cafb217ec1ad341b8e2adc660f60502f700773983d059a
+dist/2025-09-16/rust-std-beta-loongarch64-unknown-linux-gnu.tar.xz=e864959561ee49a0ae680f93307929d0e16013d2ef0743a525c5d592faa10704
+dist/2025-09-16/rust-std-beta-loongarch64-unknown-linux-musl.tar.gz=c709c58bb18b5a9385e07998dfe31e3ade0661fbfd4811907a6e7cfffbfe2e6c
+dist/2025-09-16/rust-std-beta-loongarch64-unknown-linux-musl.tar.xz=e797481997def9fe0a6466b31439d1eeb4b299c92cde3a25a7fdd557611f0888
+dist/2025-09-16/rust-std-beta-loongarch64-unknown-none.tar.gz=79d43f32d6830a0d3c9e1e8fca3ba87db44e692cc70431ac6cabea5bc59b8f0b
+dist/2025-09-16/rust-std-beta-loongarch64-unknown-none.tar.xz=4d158a9d4f4e1943b2d00fd19adad762c35af24200742440bccfea62304272b8
+dist/2025-09-16/rust-std-beta-loongarch64-unknown-none-softfloat.tar.gz=f0c460fee60c913463d9c1fbe369287ab436cc7e2882487afef457c78cf86ad3
+dist/2025-09-16/rust-std-beta-loongarch64-unknown-none-softfloat.tar.xz=f15e2baff9b0ce68ca7e1595f00b21c45bff33a1b75fbf05a8f04b096295aa0f
+dist/2025-09-16/rust-std-beta-nvptx64-nvidia-cuda.tar.gz=102c4017e11cc3407f4871aaade7f3292c8cdc92707a243788e0e4a62604cce0
+dist/2025-09-16/rust-std-beta-nvptx64-nvidia-cuda.tar.xz=6eaad8877694af02a10d18ce609b6678d96e75f87a1684b67279c9915601bd3b
+dist/2025-09-16/rust-std-beta-powerpc-unknown-linux-gnu.tar.gz=26139715f7faac9be6e458ee1be840db044692a518cd0fde29c59454405d3063
+dist/2025-09-16/rust-std-beta-powerpc-unknown-linux-gnu.tar.xz=0edf1c0a3b8ce5dc76f1ade2dceb91f96a5afa3e54c7f25f3d3320dabeab06f2
+dist/2025-09-16/rust-std-beta-powerpc64-unknown-linux-gnu.tar.gz=dbdd4f2cb5cacdf2656f83f0dc0b2101613cc344819e9ba8e790406e17d16b16
+dist/2025-09-16/rust-std-beta-powerpc64-unknown-linux-gnu.tar.xz=a6dd7f0416ceea63ac723d4aeaf9cbd8d7ed8ed7d5b8925b3317cee75b9138df
+dist/2025-09-16/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.gz=424eabcd66e922cb61757842c46afd298cac2e1ff809b593f6f409732261f4a3
+dist/2025-09-16/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.xz=7ac3a7e79c5b3c498daad88a6f926544eaf59d04711cf20ba05c1391544a4335
+dist/2025-09-16/rust-std-beta-powerpc64le-unknown-linux-musl.tar.gz=9e21d985a6702a96161aeb9ea6d1e12eb52136c7433b2ca5597c07b85a954939
+dist/2025-09-16/rust-std-beta-powerpc64le-unknown-linux-musl.tar.xz=69658c2818ff575eefbda5e64a2a6f253ce21f587a72afb2727466a923ec508f
+dist/2025-09-16/rust-std-beta-riscv32i-unknown-none-elf.tar.gz=25da1a37707d9dbac16d91f5177eaa5244f4280758f3b5a0bfbb09b5ae190720
+dist/2025-09-16/rust-std-beta-riscv32i-unknown-none-elf.tar.xz=52f6a0752e9db84c0efa49826988dd64f32930799ce2e057b3a6a20a5c696181
+dist/2025-09-16/rust-std-beta-riscv32im-unknown-none-elf.tar.gz=9f4f18ca2d1d4d7e8785f3ae61084aeaee7581d7eac2c7c883557cf30888cb57
+dist/2025-09-16/rust-std-beta-riscv32im-unknown-none-elf.tar.xz=2ef831047ada8f706fa30a655e8a2b17c15c1f10e65c66a0d3577085ff1e80c2
+dist/2025-09-16/rust-std-beta-riscv32imac-unknown-none-elf.tar.gz=9420edabe9112cb1ab9fee01dea1bdb30a866b4633205f287767c07fb57f4630
+dist/2025-09-16/rust-std-beta-riscv32imac-unknown-none-elf.tar.xz=ed7b43b375dc7c30e1bd1add31940192978ad86c5c6684b54b24252117e92008
+dist/2025-09-16/rust-std-beta-riscv32imafc-unknown-none-elf.tar.gz=cbb03936548c947633b7dff7952653aef98ae25d1ff79b8f8549e87158b6cac6
+dist/2025-09-16/rust-std-beta-riscv32imafc-unknown-none-elf.tar.xz=c957ec9bc4b1345bc805b506caeeee9350e9f07d31d4177796f461cce7e7a341
+dist/2025-09-16/rust-std-beta-riscv32imc-unknown-none-elf.tar.gz=46fd5976d8bd59a89ebd2c74cc246b9727516b28cb9b1a839ac06340d738a4bf
+dist/2025-09-16/rust-std-beta-riscv32imc-unknown-none-elf.tar.xz=a7640744bef500db2e7ebaafc4c93e73acb31b61faf47decef61ed46db73c001
+dist/2025-09-16/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.gz=537dd37985108561d6e0afe76238193fa33f1e600aba44b484a15d1f40d68142
+dist/2025-09-16/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.xz=bda3e2c4b93d864dd75bf64e08ba3d2ac9719581fb890c62073078d2005bd634
+dist/2025-09-16/rust-std-beta-riscv64gc-unknown-linux-musl.tar.gz=3edbf40890f0f52cb61c0ec8665a43d230e6e148dd4afbdbd7ca8ad53a0a2b8d
+dist/2025-09-16/rust-std-beta-riscv64gc-unknown-linux-musl.tar.xz=a515cc391e794e397ce34eb994f3a1c35cff7e7e31d54a859141000a52397c70
+dist/2025-09-16/rust-std-beta-riscv64gc-unknown-none-elf.tar.gz=d45fbe65a55b3010fd8994d3effec67f96d86593d37b6fefeb956f4a6b282e50
+dist/2025-09-16/rust-std-beta-riscv64gc-unknown-none-elf.tar.xz=13f9c87c6bed3b905ec7564fb79517e891b4a70d6c5191a876844199780f7a81
+dist/2025-09-16/rust-std-beta-riscv64imac-unknown-none-elf.tar.gz=e55f12443bf8c44e27d585bc1c38472e3175bb9d7913af55ab3bcd8f23498146
+dist/2025-09-16/rust-std-beta-riscv64imac-unknown-none-elf.tar.xz=5cde9db69b110f1766da147105e3a8d879dd36c69b2367416228024d183b12b0
+dist/2025-09-16/rust-std-beta-s390x-unknown-linux-gnu.tar.gz=3fb23f12e07d3b4ef59a637fe68c2ad1799aead28c65cf3d5d136dfea4c12eb9
+dist/2025-09-16/rust-std-beta-s390x-unknown-linux-gnu.tar.xz=999b7f7813d0d868bbda410fa37d26ba737d443a99ad74d8c2b0ecbc24fb1af3
+dist/2025-09-16/rust-std-beta-sparc64-unknown-linux-gnu.tar.gz=12e756fe1f5b57a752916b7397b981e288cc30b5861b16c5a710778c372be42a
+dist/2025-09-16/rust-std-beta-sparc64-unknown-linux-gnu.tar.xz=0d0ad94937379ac571397b7f10ec5aa20cccf5401aae16ad4d18582dc609055e
+dist/2025-09-16/rust-std-beta-sparcv9-sun-solaris.tar.gz=4bbe087dae754754f4dc1c05aaf664c5e0dd4429932feba88aab744e7c5b7472
+dist/2025-09-16/rust-std-beta-sparcv9-sun-solaris.tar.xz=dfa49be70f7ee3989cec7f634cf84e3b418f48882af8b69540e41f2ffb8cc216
+dist/2025-09-16/rust-std-beta-thumbv6m-none-eabi.tar.gz=598622e28c6ce111f4d47e2172a0657c3b0ca62c42895836376b1959fc2e094a
+dist/2025-09-16/rust-std-beta-thumbv6m-none-eabi.tar.xz=359bb98d293e1cea22a505377ce49ba95095c735b50b7d404ce4f36d84bdfec4
+dist/2025-09-16/rust-std-beta-thumbv7em-none-eabi.tar.gz=d1f994c835b1d72a665eeb7aa4683a09ac60c1977766b066c817c3eb37ad3a4a
+dist/2025-09-16/rust-std-beta-thumbv7em-none-eabi.tar.xz=22e8605af621866d82f2bdcd8089a561e10f4055624aa6dff5d704b953b7d547
+dist/2025-09-16/rust-std-beta-thumbv7em-none-eabihf.tar.gz=8e862615db8daf2c063d27f1860bd083fadefd459634e61b946ca05b8747308d
+dist/2025-09-16/rust-std-beta-thumbv7em-none-eabihf.tar.xz=8c9b3d2913242cd2e7fc690e02bd28690fa50b7278befa8b57ec9b7eec4f34e4
+dist/2025-09-16/rust-std-beta-thumbv7m-none-eabi.tar.gz=fa79d4e07630821149b151bc5673205a479570bfd971e66e874e75b5046bdfc5
+dist/2025-09-16/rust-std-beta-thumbv7m-none-eabi.tar.xz=f6f3c14f35d3b5fd01a6244f802d99e261e529bc6d4a6c5749b1cfccd524c16b
+dist/2025-09-16/rust-std-beta-thumbv7neon-linux-androideabi.tar.gz=194bc6660b3d4809d5f709e7f82159141e90b31d2318cd550b4deab65e108fe6
+dist/2025-09-16/rust-std-beta-thumbv7neon-linux-androideabi.tar.xz=36534004068562d8678a3cd73f8f82b50406aad6daeecf348246375da3bae720
+dist/2025-09-16/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.gz=622ec13126461d4d6c1f7eb3fc387279c03ffbb96fdbbfcc7c22c2433e62232d
+dist/2025-09-16/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.xz=a8162987ddefbde68e2931fc824371aa71d595106488a48732b67ec45f36ac4a
+dist/2025-09-16/rust-std-beta-thumbv8m.base-none-eabi.tar.gz=6d7f31ee7fd8633d8497cddfbe05a1ca064c4d45f50066e86cd82fe4b40b93d5
+dist/2025-09-16/rust-std-beta-thumbv8m.base-none-eabi.tar.xz=9b3309e290007406d410b8ee86ecef887d5c48b515b11cf7827baef23a0c4a7d
+dist/2025-09-16/rust-std-beta-thumbv8m.main-none-eabi.tar.gz=74fd7db50be0b77e7a44d1a32afc76f2a438fb789ea32f3ce1ceff00ccbf030c
+dist/2025-09-16/rust-std-beta-thumbv8m.main-none-eabi.tar.xz=e7736bc6c78eba1947ca6ec4ae5d875de192f44755ade737ce1e367f294576d8
+dist/2025-09-16/rust-std-beta-thumbv8m.main-none-eabihf.tar.gz=d8905fddbae4ae3e39439fe5234cd05454034d9f2a847056766bbe41126405f1
+dist/2025-09-16/rust-std-beta-thumbv8m.main-none-eabihf.tar.xz=94628c4c60615b15f1c5b331a803d4d1963289b770ba54adc4458e52d17397fe
+dist/2025-09-16/rust-std-beta-wasm32-unknown-emscripten.tar.gz=68c53c1069b29461573c68b5df7ae2e30b4b7dd682cde70f26a200854525c012
+dist/2025-09-16/rust-std-beta-wasm32-unknown-emscripten.tar.xz=cc1a4d61bc45832fa1ae19ecc1347d084249f1be3553fb33d33f0e5d8df5fe5d
+dist/2025-09-16/rust-std-beta-wasm32-unknown-unknown.tar.gz=a33ed15817407053144b8a6041dab287a390b3338dafcd1b02418b3dbe18b024
+dist/2025-09-16/rust-std-beta-wasm32-unknown-unknown.tar.xz=f0df12d2767da7528c614f5bdf6a9c6bec831b4020eed357409d3fc7fb0c869c
+dist/2025-09-16/rust-std-beta-wasm32-wasip1.tar.gz=86634e652b087947b914b590a2e978ef1d29d09b69afff63a682f26b6dcac41d
+dist/2025-09-16/rust-std-beta-wasm32-wasip1.tar.xz=04e2a9c6914b17664443b674827ab706869a81200c885e97779df0da98682612
+dist/2025-09-16/rust-std-beta-wasm32-wasip1-threads.tar.gz=3fef167485111064b1d468e5664d9173e24dbf20406165f92293f304457aeee0
+dist/2025-09-16/rust-std-beta-wasm32-wasip1-threads.tar.xz=7e12cabce073a54fbd4c97d3169e34e4beb3872a161c7c082e148b0d4adb2f7b
+dist/2025-09-16/rust-std-beta-wasm32-wasip2.tar.gz=3b8f3e6d4ce34bc8c5300b77bdf875b04a69f87f73d930439bacf56f061f667f
+dist/2025-09-16/rust-std-beta-wasm32-wasip2.tar.xz=056ad523469276f90f185b72696b20c6b47f57b5721544a20f6e765cc51769fc
+dist/2025-09-16/rust-std-beta-wasm32v1-none.tar.gz=fee626762c4bee195d800883ba15d890604280f0cddb08aa64a6199fc4591635
+dist/2025-09-16/rust-std-beta-wasm32v1-none.tar.xz=7bc289363efb2d5555e9742bf619decc2454cb784c133db55a71be4c0aed9f90
+dist/2025-09-16/rust-std-beta-x86_64-apple-darwin.tar.gz=51cf2f8f249da5df653efb073c81047583bc7bf952a4b03d6d05c9fecb7fa0c7
+dist/2025-09-16/rust-std-beta-x86_64-apple-darwin.tar.xz=4e380037df6b548916136138069e76139dbc069688ec717632c30a07854d0739
+dist/2025-09-16/rust-std-beta-x86_64-apple-ios.tar.gz=b232b73befda81ffaf0d1db7838e2057c503cf2f4f1e95f0706cfd0faf77d853
+dist/2025-09-16/rust-std-beta-x86_64-apple-ios.tar.xz=1431fa936f5909e4e92894c7e2074d3db879c10cf3f2344b050f9c77965d1373
+dist/2025-09-16/rust-std-beta-x86_64-apple-ios-macabi.tar.gz=fb0a1f0228c051a85440933358f7c00d47c4ce44a15a0b0025b00331ec53f876
+dist/2025-09-16/rust-std-beta-x86_64-apple-ios-macabi.tar.xz=b725c62998a3b28caa1f89549230ff275af854a3d04cdb6562f19be7e8a1af31
+dist/2025-09-16/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.gz=b9588bd0c684a50e0d73717f5ae5c2f0e36a90052126d2c4a539e5a116eeb4e0
+dist/2025-09-16/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.xz=70affff2a14340109f86ec585b65bed16e77612ac7b939336245cc15f7f6c300
+dist/2025-09-16/rust-std-beta-x86_64-linux-android.tar.gz=fb9fc9bbfef414092ad1082d7529fa2efc52adc849a7f45da3d5688d5f6df1d2
+dist/2025-09-16/rust-std-beta-x86_64-linux-android.tar.xz=3fd9b4d89e7ee604f842f7915b90bb02a0c44f8a4694a2d10f94efe7bbf0840c
+dist/2025-09-16/rust-std-beta-x86_64-pc-solaris.tar.gz=caa39b90ac5ff710cc76828ca52c784e48518b9c3f1c58cb6f6603a7d05f87b7
+dist/2025-09-16/rust-std-beta-x86_64-pc-solaris.tar.xz=6034b44e5e7bca888027a21d8a4b1229c08fd22b744b83ab817d487aa5e6db56
+dist/2025-09-16/rust-std-beta-x86_64-pc-windows-gnu.tar.gz=6e7a9aa27a85a09c603fb624ea1cc56120ccbf5b4fed1be8d0097232cd1bf849
+dist/2025-09-16/rust-std-beta-x86_64-pc-windows-gnu.tar.xz=00f6c500331f2f75ba9c56f896db1420c353e8c0fae450da6b5806794cd58fc7
+dist/2025-09-16/rust-std-beta-x86_64-pc-windows-gnullvm.tar.gz=9279908bfa629467d619143e5e0abbcec7a843dddd0f6737994f636edb171e90
+dist/2025-09-16/rust-std-beta-x86_64-pc-windows-gnullvm.tar.xz=f1eca139e01d2a8a2627c064f3cc14d7a2016c50738fdc19d3d586f225066f79
+dist/2025-09-16/rust-std-beta-x86_64-pc-windows-msvc.tar.gz=1fdcf7de3772c24733474e5c0f3e64b56ca627e5a235b890ba0efa2265648d79
+dist/2025-09-16/rust-std-beta-x86_64-pc-windows-msvc.tar.xz=23f9e2447316fda77b7a5af90c160c89d9f5ed735c7d5715cc2850b92fd1cfe6
+dist/2025-09-16/rust-std-beta-x86_64-unknown-freebsd.tar.gz=8dbdbe296c35e64170b9d1e7361a90aa260e456ea7ae4bd969db1dbcad976532
+dist/2025-09-16/rust-std-beta-x86_64-unknown-freebsd.tar.xz=9469e49e425349514f2bd224ccc64903c163bb481a425e01122bd3bf00ebc90d
+dist/2025-09-16/rust-std-beta-x86_64-unknown-fuchsia.tar.gz=6e97622b123772e4deaf91b81d1925fe2d39b87f567b96437c03c16a0982b709
+dist/2025-09-16/rust-std-beta-x86_64-unknown-fuchsia.tar.xz=0affcbb44870daa9410887cea10844ad1f48b4e1aec053274e86e39b42aba360
+dist/2025-09-16/rust-std-beta-x86_64-unknown-illumos.tar.gz=3023abaa7f221946e1e9cd40d4a607e8c57bddf8a250a27e0d58dd95a51ef877
+dist/2025-09-16/rust-std-beta-x86_64-unknown-illumos.tar.xz=1e76ba54bdd6673428efae1407e0e5991115f59885159e68e9d63cdfda9ca7dc
+dist/2025-09-16/rust-std-beta-x86_64-unknown-linux-gnu.tar.gz=92db1c0d785820c128bf4ad05b567b17871d2f01ef902052a90839e3fe744979
+dist/2025-09-16/rust-std-beta-x86_64-unknown-linux-gnu.tar.xz=233d981cbd309a03b16c5a80037faf992c47548cedf5ab4593db41554ffb8525
+dist/2025-09-16/rust-std-beta-x86_64-unknown-linux-gnux32.tar.gz=fe3fd22ad099bae73ffcf1a4881ee2f2c520c6108ac27ca0c64fc5111ec02230
+dist/2025-09-16/rust-std-beta-x86_64-unknown-linux-gnux32.tar.xz=027738f65f61fb77ceff38d9342915ca8344e0a1323e7659a1a5159c99c4a811
+dist/2025-09-16/rust-std-beta-x86_64-unknown-linux-musl.tar.gz=e6527497065541fc4701e71efd0a896a8048b653454a75f27765e5b7b6ac748d
+dist/2025-09-16/rust-std-beta-x86_64-unknown-linux-musl.tar.xz=807862fb874b7bee60b2740ed2df2454d8be50b0877d34b7bea796cfda69d583
+dist/2025-09-16/rust-std-beta-x86_64-unknown-linux-ohos.tar.gz=17259bb2f4bb1183ecb187296ae9afef58aa2f8e816d2764caf48aa3900fd66c
+dist/2025-09-16/rust-std-beta-x86_64-unknown-linux-ohos.tar.xz=e459cff284cd0ee388ab65c945bfca4c64b32fd268ee66c2cd8abc325580ed12
+dist/2025-09-16/rust-std-beta-x86_64-unknown-netbsd.tar.gz=5a60ff084d1da42324d6956510a68b3b83a47b432b48e2228e58f52dc8c01b69
+dist/2025-09-16/rust-std-beta-x86_64-unknown-netbsd.tar.xz=9d6823b8b1605f748f1d7af5c52bed1dd926a1d5fbd01ea9a8f939f3648b7800
+dist/2025-09-16/rust-std-beta-x86_64-unknown-none.tar.gz=57b0a2838c59feb0808462fc043c9a85a292f0025104dd6de3c5e78d4d71894d
+dist/2025-09-16/rust-std-beta-x86_64-unknown-none.tar.xz=e5a5cd9c861b29d11ae110dd4b239d5069dd0aac57202bfa440e15869f5c7e9e
+dist/2025-09-16/rust-std-beta-x86_64-unknown-redox.tar.gz=f9cdee694af41422f785126fda566891357295b5fae56268188bbf2978b92089
+dist/2025-09-16/rust-std-beta-x86_64-unknown-redox.tar.xz=8c7668ceb1611dafd9bb9ffa6de9a11e39d049cebeba05e2dfa889e69d94a54c
+dist/2025-09-16/rust-std-beta-x86_64-unknown-uefi.tar.gz=33045879d1aebfb17faf93bd471bb4c4ee3b9a787c57704814ab2dd301ac8ba6
+dist/2025-09-16/rust-std-beta-x86_64-unknown-uefi.tar.xz=28018cd9cd16e428790600decff5c7df749fe500861ecd3853895ebe69fb7100
+dist/2025-09-16/cargo-beta-aarch64-apple-darwin.tar.gz=f0642e83a5a6c8654d724e4929c0e58a4c07c330eae58fc4794ab94721b2732c
+dist/2025-09-16/cargo-beta-aarch64-apple-darwin.tar.xz=13cd17e3f35cc0214b25b65463b2394f3642ff8acf4e13af20b442b0100556a3
+dist/2025-09-16/cargo-beta-aarch64-pc-windows-gnullvm.tar.gz=fa047b7d7ad4ab64b85ca7beef052a66a89c60f976b099364eb3acfd2867c3fc
+dist/2025-09-16/cargo-beta-aarch64-pc-windows-gnullvm.tar.xz=df3a9254c4f329454dae9428d88f6c3e69ee8a120bf2eb380193eee63620ed69
+dist/2025-09-16/cargo-beta-aarch64-pc-windows-msvc.tar.gz=e5b608ae84d9258bccee0ecbefaefbaf34b989cd656f096692ea84c6f8d78645
+dist/2025-09-16/cargo-beta-aarch64-pc-windows-msvc.tar.xz=8ad0c0d49f7f6ebc5cce4a2b76036c2d0eb8adb38ce11125e2b36a1291b8ebd7
+dist/2025-09-16/cargo-beta-aarch64-unknown-linux-gnu.tar.gz=f454f83f4ffe0095d3285011b3abae11b0331d87d398ff95622e9091ee09826a
+dist/2025-09-16/cargo-beta-aarch64-unknown-linux-gnu.tar.xz=29c83085c7d51874e943b429999cf7709c0cdc422b1254a5e587aecd653430b4
+dist/2025-09-16/cargo-beta-aarch64-unknown-linux-musl.tar.gz=8f85db99809ae593abb4806ffced52abf048dfae81891ab68ef4c83f11f03fb2
+dist/2025-09-16/cargo-beta-aarch64-unknown-linux-musl.tar.xz=e5f004172331f658c3027084950360e1d60bd0cf3cca83fa43cf7fc251cefd37
+dist/2025-09-16/cargo-beta-arm-unknown-linux-gnueabi.tar.gz=1aae91a92e1d41e9c53ede795f91e7dccd3dea687d84151e507f4d3af089f15a
+dist/2025-09-16/cargo-beta-arm-unknown-linux-gnueabi.tar.xz=369b8686197e4be3883c3225bb9c186b17839552c91117750abf428255df9c8f
+dist/2025-09-16/cargo-beta-arm-unknown-linux-gnueabihf.tar.gz=b2e9a3c467ca2847f4ef55241b05a4f5151ca2608e05a43e5101c62d9d6a399d
+dist/2025-09-16/cargo-beta-arm-unknown-linux-gnueabihf.tar.xz=aaf6bfeb90e732627ae98f4b86083b3a902e31a951b98b3b5e94b67ffa6771a8
+dist/2025-09-16/cargo-beta-armv7-unknown-linux-gnueabihf.tar.gz=75bcce21bcd655a537b77aeca644f5279ace4f782a97d1e82de3cbe76a7df6ee
+dist/2025-09-16/cargo-beta-armv7-unknown-linux-gnueabihf.tar.xz=287800d221906551a50922caf0637049f3490e17c65d62119c6a26ce48d5ffa8
+dist/2025-09-16/cargo-beta-i686-pc-windows-gnu.tar.gz=89a6059faab9a3e912dc2baae766ed232d38c240c90f503bb2b486225457e8f5
+dist/2025-09-16/cargo-beta-i686-pc-windows-gnu.tar.xz=96e5b7238f543edbcfb16022ec6aa6d3643add1f7b4b0febc3e35ff9d173c075
+dist/2025-09-16/cargo-beta-i686-pc-windows-msvc.tar.gz=39ed55c1619ade6fc49fefa5ba5bfbb67aa34e53d35384a35c37d0681596b9ba
+dist/2025-09-16/cargo-beta-i686-pc-windows-msvc.tar.xz=d9ce7d301af311d58d1b4342855b70dfbe0fa8bb365b78bd83822e58a7ce9086
+dist/2025-09-16/cargo-beta-i686-unknown-linux-gnu.tar.gz=2dc0a357f58462c5474cb5c83445bb17d22450056fc77d3a92c844f104e1c96e
+dist/2025-09-16/cargo-beta-i686-unknown-linux-gnu.tar.xz=c2e4f00fc345a77da5f13642d6b65a77df553ac0cb596fa34f837d76fac460c8
+dist/2025-09-16/cargo-beta-loongarch64-unknown-linux-gnu.tar.gz=e1b5e490a00eecf93d7c591628c8d231eadb8c68104978b623fc16c5369248e8
+dist/2025-09-16/cargo-beta-loongarch64-unknown-linux-gnu.tar.xz=c2f91d72d2977168eb12179abd98b4d18f67de4ed455856f7af18a860ff5b1c5
+dist/2025-09-16/cargo-beta-loongarch64-unknown-linux-musl.tar.gz=7fa229d54c917a4872efbc2e9eb9181f5b1133aa44508548e94e4529ab099cd4
+dist/2025-09-16/cargo-beta-loongarch64-unknown-linux-musl.tar.xz=359d7ec4bc7e0eed1c936bff9cee56bc3a132a488499cb83a8e7561222893c66
+dist/2025-09-16/cargo-beta-powerpc-unknown-linux-gnu.tar.gz=fe514bf5afccb535517decb4c3120375eefc36def2190d60f4f0f6d796af1b79
+dist/2025-09-16/cargo-beta-powerpc-unknown-linux-gnu.tar.xz=d3d1307f3f60e9d8ee9f199441185bcb52a7bf5de460302291b178ef282a457e
+dist/2025-09-16/cargo-beta-powerpc64-unknown-linux-gnu.tar.gz=e7c77c9baf683994bf180b8906d55a2117f5bff85fec6c602a6f1912c39b2817
+dist/2025-09-16/cargo-beta-powerpc64-unknown-linux-gnu.tar.xz=207e6fe0baedb7f19e8a0437e24cfb9b46d4131a141863c93a52d00f1b049d8d
+dist/2025-09-16/cargo-beta-powerpc64le-unknown-linux-gnu.tar.gz=87433380a70642842f7dcf4a4c8614cbc136a18198837e631dce419e99ae71b8
+dist/2025-09-16/cargo-beta-powerpc64le-unknown-linux-gnu.tar.xz=207106c6e7c129fe19940da029360f8ce42f29468836a094a2b02156121888ed
+dist/2025-09-16/cargo-beta-powerpc64le-unknown-linux-musl.tar.gz=ad90e19faff850cbb03eb04195943a9f65169d6a7b030422f0310f8c053e61c3
+dist/2025-09-16/cargo-beta-powerpc64le-unknown-linux-musl.tar.xz=7abcb3c3cf3710fcf41d67664137bd0c823792a70cbd82004e0cbbef58446f44
+dist/2025-09-16/cargo-beta-riscv64gc-unknown-linux-gnu.tar.gz=7acc6031840a56c47dd2d52a6ce169663ffadb108e92743b22a6dd9a7227baa4
+dist/2025-09-16/cargo-beta-riscv64gc-unknown-linux-gnu.tar.xz=a2ae500b6c44abeb6cbb42a07a37a8e0ded707fdc1e3f4d6159aaec404912f5c
+dist/2025-09-16/cargo-beta-s390x-unknown-linux-gnu.tar.gz=3a69ae63bde95a6dd4020395b90e821e4342fa1b45b00d12ea30f3b1c643ef59
+dist/2025-09-16/cargo-beta-s390x-unknown-linux-gnu.tar.xz=231b1b052018ab851c57563d3c3b4a943cc01f99e3ca6795dfb6a1315d2577c8
+dist/2025-09-16/cargo-beta-sparcv9-sun-solaris.tar.gz=41677b7f137d6509bf7e0fa2eaeefd91d03316e566136d37d006fd98a2a4c28d
+dist/2025-09-16/cargo-beta-sparcv9-sun-solaris.tar.xz=f5b4057e69c50258c3edf00dd71f47951833ae892b121641d8d3a0bd38991838
+dist/2025-09-16/cargo-beta-x86_64-apple-darwin.tar.gz=edfe3b23fe5824b5ae763871f133cce684ace0999afd38e9a7b2a08f17b12ac0
+dist/2025-09-16/cargo-beta-x86_64-apple-darwin.tar.xz=173ec4d3c129530c33623f2ec6a5fdc5d739ecfd24f7372f3713ea94aeab8eb1
+dist/2025-09-16/cargo-beta-x86_64-pc-solaris.tar.gz=fe0f57ea7eafb5e157a04cd753b4f6b733245fa8e9baddccf581cec0a7ea2ed4
+dist/2025-09-16/cargo-beta-x86_64-pc-solaris.tar.xz=61ac8a524964f2179c8195d821382597bc8641eace9ba1c27e81453ab8c347e0
+dist/2025-09-16/cargo-beta-x86_64-pc-windows-gnu.tar.gz=44200f95def8558a8b7b85c11533841786d3fd17331e13056dd7ce25de667b2c
+dist/2025-09-16/cargo-beta-x86_64-pc-windows-gnu.tar.xz=7144031f2f69bb3bba08cca81e15dc557424c096f9555678b1bd1dd5f4891360
+dist/2025-09-16/cargo-beta-x86_64-pc-windows-gnullvm.tar.gz=a7a9c76ec0cb87a725c44336cad0182cbf2c1e06d19cbfa0311501541c08c852
+dist/2025-09-16/cargo-beta-x86_64-pc-windows-gnullvm.tar.xz=0b66de9c68f0ec42a410a898468dd67f147284911803207053a01fb2d29b65d7
+dist/2025-09-16/cargo-beta-x86_64-pc-windows-msvc.tar.gz=de26ef4d9091775cceb21af53cb1177922f8eb93763c0e333e59205dcb05ffa5
+dist/2025-09-16/cargo-beta-x86_64-pc-windows-msvc.tar.xz=e6823ffc56d1136d02384acd09e73b6e45ee197c2126b49aa95df832704b9d24
+dist/2025-09-16/cargo-beta-x86_64-unknown-freebsd.tar.gz=dd0656bae2fbf483ebe641ed952499f0127897b09fe14273046cc8e0c7611825
+dist/2025-09-16/cargo-beta-x86_64-unknown-freebsd.tar.xz=6c8b65ac66bf730f9c5bb7caffc75ab1912439d033130438d98ebdaa1a2b922a
+dist/2025-09-16/cargo-beta-x86_64-unknown-illumos.tar.gz=5c3f38613b4d2f26643bab1a6db5b769f58878e47168dc92bc2c7b2fe9559ae1
+dist/2025-09-16/cargo-beta-x86_64-unknown-illumos.tar.xz=046ee0c80efe70375179c95461af5724cb00eb9ecc1d995e4a629d316d853686
+dist/2025-09-16/cargo-beta-x86_64-unknown-linux-gnu.tar.gz=b6da1a94fa5718c5a1be4d67d6422d28e62365a433d82f11fe7f09149690e78e
+dist/2025-09-16/cargo-beta-x86_64-unknown-linux-gnu.tar.xz=5b8aeabb11e88e4cb02c766c11c0d3d826ded4d08874a11127d8f73f033b0072
+dist/2025-09-16/cargo-beta-x86_64-unknown-linux-musl.tar.gz=00f191b30c29d46e503bfdc49c112ac5295bb67caa091333b0caf210e08d3f01
+dist/2025-09-16/cargo-beta-x86_64-unknown-linux-musl.tar.xz=750060cc199fac6990597a9859234392f4c0a5405d87d1234fc7990032b4c138
+dist/2025-09-16/cargo-beta-x86_64-unknown-netbsd.tar.gz=12513081e2bd88c666881e77e3c4935c710cd6132d9ec48cf9049ac7ece5dd9f
+dist/2025-09-16/cargo-beta-x86_64-unknown-netbsd.tar.xz=b1338ed261e33b0fa3e8a63c8930835d87d352ec10011bd4d626c44fa0b0392b
+dist/2025-09-16/clippy-beta-aarch64-apple-darwin.tar.gz=668e7fb88b52ad92634fc4d39885843b4893fbb9f34062e8c4fa870f0e71fbbe
+dist/2025-09-16/clippy-beta-aarch64-apple-darwin.tar.xz=a0fbf1903d1a95c6ca98ce98a3e639110022480d56c20e175e4fadf211baadda
+dist/2025-09-16/clippy-beta-aarch64-pc-windows-gnullvm.tar.gz=6593c10385d78ba68b38b8815e5c7aead991d83d9f689a42f4a2911a5f7f0450
+dist/2025-09-16/clippy-beta-aarch64-pc-windows-gnullvm.tar.xz=856303f96ed6bd1be89295dffccfc944cd70ce3d1921afc9366f19c6ac800b60
+dist/2025-09-16/clippy-beta-aarch64-pc-windows-msvc.tar.gz=e60f30cba9fe154e7446cf5b7114e7f8c153937eb58cca4cb24dad1b8dd453af
+dist/2025-09-16/clippy-beta-aarch64-pc-windows-msvc.tar.xz=24ae9f98df0f2320271b8250234f571b64a4b5ce983a083f45966e58f39b1c94
+dist/2025-09-16/clippy-beta-aarch64-unknown-linux-gnu.tar.gz=aeaf3ed45a8feda550b2043fcbc55ca9fa3eb95141dfecabb794fa9003d76a3b
+dist/2025-09-16/clippy-beta-aarch64-unknown-linux-gnu.tar.xz=3187bb767e36aee12059f1d2b77697aa57f71a3c478930c4901dfcd25d414369
+dist/2025-09-16/clippy-beta-aarch64-unknown-linux-musl.tar.gz=c2c23a91b2cccd4978fe612f22c33773833c87719259bd0d501e5a2523f3c689
+dist/2025-09-16/clippy-beta-aarch64-unknown-linux-musl.tar.xz=b7902a5d4dafd1301fb573148b6d1164b9365e976a9019151b66aa93b88e93bf
+dist/2025-09-16/clippy-beta-arm-unknown-linux-gnueabi.tar.gz=69e95f21ef2f59df25ee56c2dc10ed5306ca5b41299acea22d2d87d967d17575
+dist/2025-09-16/clippy-beta-arm-unknown-linux-gnueabi.tar.xz=24343efbed86314a6c292659ee0625cdc30bd655eec8009d8e2209a659dcda12
+dist/2025-09-16/clippy-beta-arm-unknown-linux-gnueabihf.tar.gz=404b0db1d121ad8fb1a43ecadaa84a79f976a68dbf088ed47fb31245e293445e
+dist/2025-09-16/clippy-beta-arm-unknown-linux-gnueabihf.tar.xz=f4fbf3a39e1b5d61a481109da644e44e58371c00a3224b187dfbe39827615a33
+dist/2025-09-16/clippy-beta-armv7-unknown-linux-gnueabihf.tar.gz=fabfcb98b0d9d69e5d022e40ab572d2e84c604dc8d4ba2c88d44501c2a7390ff
+dist/2025-09-16/clippy-beta-armv7-unknown-linux-gnueabihf.tar.xz=8c289d02256ff36412231b320c723becc8d83d5acf9c2325541367eb66f6443a
+dist/2025-09-16/clippy-beta-i686-pc-windows-gnu.tar.gz=13838c1fa366173219023000810ba180899b843f7d5c54ffb415c7a517f5af80
+dist/2025-09-16/clippy-beta-i686-pc-windows-gnu.tar.xz=a86b22e78175f89ff2b4dd40b9fbe91b4447914b226d7ef7d020903ed2c9581f
+dist/2025-09-16/clippy-beta-i686-pc-windows-msvc.tar.gz=fc2a9397912c6651e04dca0475dc74fcb9a50f370a0ef7f9c7987158dfc58d55
+dist/2025-09-16/clippy-beta-i686-pc-windows-msvc.tar.xz=bf4be32251bac244540759795afe760be13a134580cae8e3fd5956d8ed45b254
+dist/2025-09-16/clippy-beta-i686-unknown-linux-gnu.tar.gz=10580cdb4078d6a27e511ef71ed1a50f67202c1ba145fe315b63f2786ecf6428
+dist/2025-09-16/clippy-beta-i686-unknown-linux-gnu.tar.xz=5ef51556bc3b002a97e7b9f092ce280ee3b5c4a6b02a8d382d87a3f56d90eb04
+dist/2025-09-16/clippy-beta-loongarch64-unknown-linux-gnu.tar.gz=34756f99178d5be61df2375f4161aacfb05fbe4d38e9259bb7a01f71e842d67d
+dist/2025-09-16/clippy-beta-loongarch64-unknown-linux-gnu.tar.xz=1d10a5f1ac3bb2bbd84c421cdd1978865fccd214c08a341c7b6527c6674205bb
+dist/2025-09-16/clippy-beta-loongarch64-unknown-linux-musl.tar.gz=c0fc0dcc1a78960b53de22703e7764bb64bf35762127a8f272b45e95e64c7bc1
+dist/2025-09-16/clippy-beta-loongarch64-unknown-linux-musl.tar.xz=f41d1ac85d5714c6fbab9986ced2c80bafdf8251f37f16a5a9da994356b5912e
+dist/2025-09-16/clippy-beta-powerpc-unknown-linux-gnu.tar.gz=6f2cae468cc556a4083771c6e3e610f759cad00b7af7255db32d461d6e4f3dcd
+dist/2025-09-16/clippy-beta-powerpc-unknown-linux-gnu.tar.xz=6df81ef270b67457b96ae04da2801c2a80f9604df9c902e74140ab4b154a10ab
+dist/2025-09-16/clippy-beta-powerpc64-unknown-linux-gnu.tar.gz=fa4b89d3144ae42ac8c69f85f7b63f46cbbaefa1c3063f719a75dbf8e3ec39b2
+dist/2025-09-16/clippy-beta-powerpc64-unknown-linux-gnu.tar.xz=944976f337f4c27176ac614abc918a2bb037d30c554ba5e92e180d7247089cb9
+dist/2025-09-16/clippy-beta-powerpc64le-unknown-linux-gnu.tar.gz=30da372a7d750fc5e8509cd2265522b7d3d24ab8c37af24076fd0c6f48d47ea4
+dist/2025-09-16/clippy-beta-powerpc64le-unknown-linux-gnu.tar.xz=dfc5382049b525b461b5bd343f214f357bd3cf1a66d4d226658538639f4ca85a
+dist/2025-09-16/clippy-beta-powerpc64le-unknown-linux-musl.tar.gz=f5f500c286fc90f4b7808d45a77beaecd7ae3d5c99522dbc80f09132f078fbe3
+dist/2025-09-16/clippy-beta-powerpc64le-unknown-linux-musl.tar.xz=5a5da7891fae2f8fd1fba6a537cb3f26cf0aa73f0e36d01181fa20a82be3536c
+dist/2025-09-16/clippy-beta-riscv64gc-unknown-linux-gnu.tar.gz=538b09d45dbcfed24f521a29f5107a1b39efd8c3217991c21eb6c55603ab267c
+dist/2025-09-16/clippy-beta-riscv64gc-unknown-linux-gnu.tar.xz=e95cc43b991ab4d0f16c593171231bc134538f64ca40ddcdcbf5d2b73bce3307
+dist/2025-09-16/clippy-beta-s390x-unknown-linux-gnu.tar.gz=37b1903fc1e58f57574a2a6ad23014443d72d6e8aec35df0168028acc813c8ba
+dist/2025-09-16/clippy-beta-s390x-unknown-linux-gnu.tar.xz=04d65883b79cda42a26c0581349fbeb7023a25bb73db2e525483fc4895386e97
+dist/2025-09-16/clippy-beta-sparcv9-sun-solaris.tar.gz=057cb0d5ba11a7679a17d87304d1301cf583c86ad2faa23fc449d3cedf0ea1be
+dist/2025-09-16/clippy-beta-sparcv9-sun-solaris.tar.xz=8cf1abf779a8a5a18561f643a8fff9863909be7c3f8bc84be2d817fc262a1215
+dist/2025-09-16/clippy-beta-x86_64-apple-darwin.tar.gz=a1301c459894d6d9837b98ec8af238b26c401b860a78d458e34c3d747a8b5de3
+dist/2025-09-16/clippy-beta-x86_64-apple-darwin.tar.xz=af863a3fcae2193f8cc26d9b62854bcba6e029b0bef0f2151321bbabfc931c3a
+dist/2025-09-16/clippy-beta-x86_64-pc-solaris.tar.gz=5a3176859e8f783d8bf687d578100dabdd8196e52290a9de6b6902463b4f193e
+dist/2025-09-16/clippy-beta-x86_64-pc-solaris.tar.xz=93e37f354b89c94434c3c294cc54522ed503687ef62bb70a146196262993ce1c
+dist/2025-09-16/clippy-beta-x86_64-pc-windows-gnu.tar.gz=6403ea6cc8c3c3f83f29d894153ba3bc956b19fc213c11ed13d1117620fa543b
+dist/2025-09-16/clippy-beta-x86_64-pc-windows-gnu.tar.xz=a9ed248496eacebd88e33715b30253d9d2730087cff24427b34cf07b2eb89a1f
+dist/2025-09-16/clippy-beta-x86_64-pc-windows-gnullvm.tar.gz=5a72c9e26e4d59d013243d0d2416fe5280f2eb915f760470b4501731d8e8e05e
+dist/2025-09-16/clippy-beta-x86_64-pc-windows-gnullvm.tar.xz=078dd02a254accc28ee8b26a5e4b3349f013c629bd1da49948f0071184727ab9
+dist/2025-09-16/clippy-beta-x86_64-pc-windows-msvc.tar.gz=288ff79cc4cc4aec96d6ecd92c733e18aca2c846c87359e77d825cf57817c1e0
+dist/2025-09-16/clippy-beta-x86_64-pc-windows-msvc.tar.xz=fbc1421027dc77265be5d106d6db139a6a33b4e5ade0b1eba17e17a4ea59483f
+dist/2025-09-16/clippy-beta-x86_64-unknown-freebsd.tar.gz=1fc82034c6b8b38d60788ea3addaeea8ef4448d467def0a92bea750d060c4d39
+dist/2025-09-16/clippy-beta-x86_64-unknown-freebsd.tar.xz=3a3b7d4f98df124bc7c73ae46f0c776320c1a92c0d1dd7d7caa0d138e7068a3f
+dist/2025-09-16/clippy-beta-x86_64-unknown-illumos.tar.gz=f02880e995ed24f200b5c1711f2951e7eaeecc4ab144e50d866f11959e8fbeec
+dist/2025-09-16/clippy-beta-x86_64-unknown-illumos.tar.xz=a99652b13a6c3570bcdc41638a59b6d68b76562000ceb60a57128ee5065778f1
+dist/2025-09-16/clippy-beta-x86_64-unknown-linux-gnu.tar.gz=657275ab960c8c65b55b22bdbff5040440a039c9631017645a37506771f3d443
+dist/2025-09-16/clippy-beta-x86_64-unknown-linux-gnu.tar.xz=4ababcc7ffc0976218e62bd55666ff06e01350ecc790ae06effb2767521e169c
+dist/2025-09-16/clippy-beta-x86_64-unknown-linux-musl.tar.gz=5c454d363e6f8615aaf4d93e39306972e65a544f3a973c034333022aee321f33
+dist/2025-09-16/clippy-beta-x86_64-unknown-linux-musl.tar.xz=327cb34aff228c3fbc3efb389ddab0b50e5e135145602a8f9e5227fb70a462a8
+dist/2025-09-16/clippy-beta-x86_64-unknown-netbsd.tar.gz=87426803e7fc0bebdec6ae46f8ce536d947bdc57294e592599cb54d9d98d3d50
+dist/2025-09-16/clippy-beta-x86_64-unknown-netbsd.tar.xz=021d69fe47201dc89f394d084b70491d15718b24ceeba56e7cda18e3572f0309
+dist/2025-09-16/rustfmt-nightly-aarch64-apple-darwin.tar.gz=fa289216a17ce0b4fce43862f80087e4bcdaae7b20eac1f3776488b3986db45c
+dist/2025-09-16/rustfmt-nightly-aarch64-apple-darwin.tar.xz=1dade784b9caf54bc3ec5c9021d7c4ed1307f11f71d12af46961926a4ad6f7d4
+dist/2025-09-16/rustfmt-nightly-aarch64-pc-windows-gnullvm.tar.gz=0f221f2e4d5bece40307c4f7b095dd377ffadce916750c27bd7a2d5663eb6b37
+dist/2025-09-16/rustfmt-nightly-aarch64-pc-windows-gnullvm.tar.xz=3d7cdda977ddd4a49f27a2fcf9e0027ce9aebcc5f250e25c3788b6bb5169e8b0
+dist/2025-09-16/rustfmt-nightly-aarch64-pc-windows-msvc.tar.gz=28a44723d3c4da225592786db74f58af4af952b13112469910b5a2f58a7eb20f
+dist/2025-09-16/rustfmt-nightly-aarch64-pc-windows-msvc.tar.xz=7b4b9f2804488f90bdc9b4f5ac19aaaa9b82cff02c86b95aa0b7df0c805502b5
+dist/2025-09-16/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.gz=df6b42adce548127a2a549bc7b6e574de86c22533641c5bc725c1d5ad62af651
+dist/2025-09-16/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.xz=07d680aa64743ec6e8c417ff14747567fa6056738d6ed8c06db2c63c544f5201
+dist/2025-09-16/rustfmt-nightly-aarch64-unknown-linux-musl.tar.gz=66262bcc6e4fdffef1e9966bedaae64f27169980987425323fbf3a73ad46792d
+dist/2025-09-16/rustfmt-nightly-aarch64-unknown-linux-musl.tar.xz=f8125405f6437be0357eb594fc74842d6995e113b2475fd8fef6f778dddba539
+dist/2025-09-16/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.gz=bcf9fdad0b5209b1e12fd81a18927698f468995e708dd56e8212f977d4ac39a8
+dist/2025-09-16/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.xz=f7a7289e5f48ecf9ddbb214e6ab47280789a14065960f40a92d8dde3e1df57b4
+dist/2025-09-16/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.gz=e463b2bd6236463c68b2d0377bb33adff0daf17fc47dfe8f0857043b793a847d
+dist/2025-09-16/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.xz=96c15e4bbfb17be75003ada804b2da5bd750889c783e110a5a3481f045ecbfc7
+dist/2025-09-16/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.gz=6e53b146000b91f569aa5807e69dca726068d2c23e4a44c344592ef7a96927ec
+dist/2025-09-16/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.xz=a59f630b27fb33d188ba0dfcd3563a69bced49dfbc0fc1545b0c750bed41506f
+dist/2025-09-16/rustfmt-nightly-i686-pc-windows-gnu.tar.gz=ab6b4c2728dc0381f92af8b9f9c730507709e40ca7da89700bfca9b7adb93034
+dist/2025-09-16/rustfmt-nightly-i686-pc-windows-gnu.tar.xz=71950a1d4c6b04868cec2fcdd7c80bbdc675ed5c25917c774e3b6445bdff21c3
+dist/2025-09-16/rustfmt-nightly-i686-pc-windows-msvc.tar.gz=fd25c154f34b662d69a6d5cace59ebd605a1c4085a14ff8b8d597f5cb7324e95
+dist/2025-09-16/rustfmt-nightly-i686-pc-windows-msvc.tar.xz=15a2a897028e11992d2cae90d2a00f730a65f8b62ad500ff82c2fa83767b866e
+dist/2025-09-16/rustfmt-nightly-i686-unknown-linux-gnu.tar.gz=9516f97a5807b07d37e95a258b9cd60305c2b0429911c2425716e7f77a556eb2
+dist/2025-09-16/rustfmt-nightly-i686-unknown-linux-gnu.tar.xz=f665d43854449cb4ade4c518671ac5fef4a9640d276ff7d90c51c1bed08f9909
+dist/2025-09-16/rustfmt-nightly-loongarch64-unknown-linux-gnu.tar.gz=5de565b08f2641f3a7b58f79f5c63905859d39573f105ba05addcd4db5cb30de
+dist/2025-09-16/rustfmt-nightly-loongarch64-unknown-linux-gnu.tar.xz=0f3d7e4b91b6cab8ec9c534ae0f82ba79c57d621f25baa2b408bd2844edbc017
+dist/2025-09-16/rustfmt-nightly-loongarch64-unknown-linux-musl.tar.gz=7a33a965a41fd3958df003506da405a42cd459bc8689aea530b4a66122eccd3f
+dist/2025-09-16/rustfmt-nightly-loongarch64-unknown-linux-musl.tar.xz=b38a0cd88bec44e60b52e414237f50352900afb66e3f2b829acf92de5c060e3c
+dist/2025-09-16/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.gz=64cc62b309d4be3b004356637d726776c6765cee590cb0ca244e2bc3feb6368a
+dist/2025-09-16/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.xz=bf873d8101d8f2f3574387011749b3375298c7a828ba1ebed91536adf50be1be
+dist/2025-09-16/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.gz=3fba5ef7cdf564801de103e7724ac0d9096cdfd8340c75df09bc0ddc1e71a74f
+dist/2025-09-16/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.xz=c5a8af0f0689aabd52a337eb11a601877cd9f74efa2734d872f2752413551aea
+dist/2025-09-16/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.gz=4f1d6e182fbe1fc1a87949651e64a7f6896c3b359b7937b02d2c02b8e9db952e
+dist/2025-09-16/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.xz=29f7583b6f0af1239194c8d936a9f7e38f58920f6a4888d26ea1a48ab8c72235
+dist/2025-09-16/rustfmt-nightly-powerpc64le-unknown-linux-musl.tar.gz=f937a74b730cc1d064e0b4be538fa5bd51f636f8a5979367cff3a611d7893f45
+dist/2025-09-16/rustfmt-nightly-powerpc64le-unknown-linux-musl.tar.xz=d208b1998db3a896ea9c7c79ded0ad6ca4de452d3b6e696ffeeca44fe9fbc58b
+dist/2025-09-16/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.gz=6816dc3cdd53c883a7cad8e7237c1e22264dfdf6e1a8033b41887a52cd43a8bc
+dist/2025-09-16/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.xz=904b26d880f6b364458e9d0f682cab3a136b3498f27c913d6f422de6fa822e60
+dist/2025-09-16/rustfmt-nightly-s390x-unknown-linux-gnu.tar.gz=373a93410cc2fae30b952b036487417ec9e6211cd2e1980e60352329444a4376
+dist/2025-09-16/rustfmt-nightly-s390x-unknown-linux-gnu.tar.xz=8e1e328f2312cf458f8d7288624c11cc5f39bd7c8feef62147216689a5c28a13
+dist/2025-09-16/rustfmt-nightly-sparcv9-sun-solaris.tar.gz=8f22b6753dcad78a46cdc98251b27672bfa94f2ee11a655705fd7fa8a469ae82
+dist/2025-09-16/rustfmt-nightly-sparcv9-sun-solaris.tar.xz=b719b7167321d4be13eaea674f713269c35e4d34dcecaca38e32cb72aa8632c4
+dist/2025-09-16/rustfmt-nightly-x86_64-apple-darwin.tar.gz=63006d28e754c6e6afc5cea25527d4ea628ba084f0af52a36b676faf73f22e07
+dist/2025-09-16/rustfmt-nightly-x86_64-apple-darwin.tar.xz=b74a4e9726b5acf7133511b855088aa3ca9eaf5e5cd73a6d3b054e8a263ed6f1
+dist/2025-09-16/rustfmt-nightly-x86_64-pc-solaris.tar.gz=a3625dc34b971fd11e3d2f895a4933f4ec6b1e01475385cfd02e4eded528a99f
+dist/2025-09-16/rustfmt-nightly-x86_64-pc-solaris.tar.xz=1309352fa233debe6b1a06664da7f8d6db9e8b18afb60ca5709ca6a5ec657198
+dist/2025-09-16/rustfmt-nightly-x86_64-pc-windows-gnu.tar.gz=b765f3a632f74d7624ad10afb1875716b836dd6e5836736fbed6ce5fe7b00594
+dist/2025-09-16/rustfmt-nightly-x86_64-pc-windows-gnu.tar.xz=b74f1b6e563790926629952d25199eed14fa15e94845c962c79ac56df64cd18e
+dist/2025-09-16/rustfmt-nightly-x86_64-pc-windows-gnullvm.tar.gz=365e182e871e46e9f54b2265996c4531ae44b5f93a2208a5debcff5367026692
+dist/2025-09-16/rustfmt-nightly-x86_64-pc-windows-gnullvm.tar.xz=34712b98cd806caf8507b3afb292cd7bbf41599a395847336f617a9c952f911a
+dist/2025-09-16/rustfmt-nightly-x86_64-pc-windows-msvc.tar.gz=d04e6573a9253d4c5bf512f7b65415f08389c499d0024ac3990110ec1859b24e
+dist/2025-09-16/rustfmt-nightly-x86_64-pc-windows-msvc.tar.xz=98de7fe5863ce17a6f3c35ef9baff92124c5a398a008d80394a1ddc61fd29390
+dist/2025-09-16/rustfmt-nightly-x86_64-unknown-freebsd.tar.gz=01f052f3ec99702f7747610c3a5fd0a440a7a38bc5f4da93be9e6db48b599f3e
+dist/2025-09-16/rustfmt-nightly-x86_64-unknown-freebsd.tar.xz=38dcd9d9fedce55d75ea7151937cbdc4f6f76d92eb8039840e520faaa870182f
+dist/2025-09-16/rustfmt-nightly-x86_64-unknown-illumos.tar.gz=0341b4b7e5287aecafb3097334eeff773c83d5267c3a1c6edcea6c6ae1ee29fd
+dist/2025-09-16/rustfmt-nightly-x86_64-unknown-illumos.tar.xz=42ac68f632ca2d78b9b4647bde709eab84765f4376722ecb560d099cde89c7f8
+dist/2025-09-16/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.gz=af7491f1d5fee8a52768397966b75ca4104400e7023f373dd8b188aab4ae1b35
+dist/2025-09-16/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.xz=38cae1811a0e18ddaf094d3931d8d532c5eaba03fa2cc1149380ff9393e8f84a
+dist/2025-09-16/rustfmt-nightly-x86_64-unknown-linux-musl.tar.gz=631cf4d825237406f2992f44f26086672886b61fac0d7ff7a4991b25ec756ebb
+dist/2025-09-16/rustfmt-nightly-x86_64-unknown-linux-musl.tar.xz=ee52ab0c86918b2a155098cac489f5e639c0abd7064539d0e8a6a7502ca33c54
+dist/2025-09-16/rustfmt-nightly-x86_64-unknown-netbsd.tar.gz=67de842ff1f8cf99b0ad88ecefc17fa36359fa718e3fc04f243ad8c1595987bd
+dist/2025-09-16/rustfmt-nightly-x86_64-unknown-netbsd.tar.xz=349480a812b9861112e80ab86d3e80318d239af5212b314b3a7299dbbaffbf8e
+dist/2025-09-16/rustc-nightly-aarch64-apple-darwin.tar.gz=fe1ffcb90bdca92a61470c4f7cdf7bcdb4e7bf7c685ac0b92eb3a22509d88963
+dist/2025-09-16/rustc-nightly-aarch64-apple-darwin.tar.xz=b55d2837dcd2bdfbe8444e29d0f36ea584451c4f0b7fb7e9bcd77279e8cd820c
+dist/2025-09-16/rustc-nightly-aarch64-pc-windows-gnullvm.tar.gz=c303271dfc8ccd2c997e5ad88e2c3fbab6b9a188331217dbd46a6d96a53852ff
+dist/2025-09-16/rustc-nightly-aarch64-pc-windows-gnullvm.tar.xz=0d82ddfbeaf9380773bc91f294651609bc928cf53ce95fa89fc4a0f04e54ac67
+dist/2025-09-16/rustc-nightly-aarch64-pc-windows-msvc.tar.gz=6a8a14c5180e4cbd23bf144cf11dec5f47b769a717aeac03546d5cda83b766ab
+dist/2025-09-16/rustc-nightly-aarch64-pc-windows-msvc.tar.xz=915239fd57032010740ba9aebea3e018581993d2ae5d2ebab9ca42d73e48077d
+dist/2025-09-16/rustc-nightly-aarch64-unknown-linux-gnu.tar.gz=932a75ac114cb08c0eef0ef2189b463885a6d64334e25899ff386196ec59fc4e
+dist/2025-09-16/rustc-nightly-aarch64-unknown-linux-gnu.tar.xz=fcff7229b11ec8925d39830ce62892265f655ff272d9e3a167f102cb0cd8f098
+dist/2025-09-16/rustc-nightly-aarch64-unknown-linux-musl.tar.gz=3ae873418d17f15d46a1de95e945aa1e00d737b688e196d565031947b9dc420d
+dist/2025-09-16/rustc-nightly-aarch64-unknown-linux-musl.tar.xz=036eb7c219c6e1c447c5e6ee6d4635dcbcf4c1274c5a14f0dbe5eaee3f175f1b
+dist/2025-09-16/rustc-nightly-arm-unknown-linux-gnueabi.tar.gz=16484c845c672c775970f0108a8c336a11d2a2e4dd5f76bb5d1b74da1e436484
+dist/2025-09-16/rustc-nightly-arm-unknown-linux-gnueabi.tar.xz=9004db0b31113fa8ef0cd44318d0df62e76b8d30ac2a6332f6d483513e4ee7dd
+dist/2025-09-16/rustc-nightly-arm-unknown-linux-gnueabihf.tar.gz=6b3c245279a006b0516df26ca686f56cdf6233740d8c8b18bc19c5aefa84dbad
+dist/2025-09-16/rustc-nightly-arm-unknown-linux-gnueabihf.tar.xz=ecd58877e63d7d209a67ccb5a6e7693af38f2e249ce04001605ac49fcec45edf
+dist/2025-09-16/rustc-nightly-armv7-unknown-linux-gnueabihf.tar.gz=d5370d72328bd22b2fc79661061352c99d3288604bd1ed58ae2b798586db5f70
+dist/2025-09-16/rustc-nightly-armv7-unknown-linux-gnueabihf.tar.xz=5b8a6f255601c33bfd215b646b8ff164390e1eb7df69aeaf7be65d97dd9f426d
+dist/2025-09-16/rustc-nightly-i686-pc-windows-gnu.tar.gz=74ff396b8dfb28aa91692aced5ffa76f3e270d4c5a2e47b12eda5c4534e92bf3
+dist/2025-09-16/rustc-nightly-i686-pc-windows-gnu.tar.xz=953e50c365d084ffeac61d1279f89943e81b43922c6721f5e55f211d0fc61902
+dist/2025-09-16/rustc-nightly-i686-pc-windows-msvc.tar.gz=c3485374a990da572cab859f6cadbdf252d32e07d550e0f20fcee24be543050c
+dist/2025-09-16/rustc-nightly-i686-pc-windows-msvc.tar.xz=ea4afaf63f5b5c92f7feea4b82ae751f6f8bf8f54126d7007bc72d4815352628
+dist/2025-09-16/rustc-nightly-i686-unknown-linux-gnu.tar.gz=0635e9a84313f572d1883841f91bb49c7e7fed9a6dc5db751f00e7b00f140ce2
+dist/2025-09-16/rustc-nightly-i686-unknown-linux-gnu.tar.xz=8904638b6ab37416eedacfcb03c7b87fdcbe1fcd0e3a80e0e5f410c671959d44
+dist/2025-09-16/rustc-nightly-loongarch64-unknown-linux-gnu.tar.gz=3fab80f207dd5e8f5c276deb11512d55b5e97b3dffe44c1f0249e0c331ce2b68
+dist/2025-09-16/rustc-nightly-loongarch64-unknown-linux-gnu.tar.xz=95dd7df11dd2b9f27f8fc9e88f37ada794f9e0443cf1291c554f47485eee84dd
+dist/2025-09-16/rustc-nightly-loongarch64-unknown-linux-musl.tar.gz=a4e7d3c55c7acce10b1f0b59afb9e70d32c651b87a4d1381e945fc07543e474d
+dist/2025-09-16/rustc-nightly-loongarch64-unknown-linux-musl.tar.xz=f2ca377351093829123525578451c60987c3943be1783e396ab3d5f34e7735cd
+dist/2025-09-16/rustc-nightly-powerpc-unknown-linux-gnu.tar.gz=b7e5d9c1ecde1b69b17d29a3ac6d15af0e734a7666381f1adefd0bc31ea2c397
+dist/2025-09-16/rustc-nightly-powerpc-unknown-linux-gnu.tar.xz=1c18dca6d3ac47b8223ab1e67e94640f402ba8f2ab787b38ba85c49ca8143acb
+dist/2025-09-16/rustc-nightly-powerpc64-unknown-linux-gnu.tar.gz=0850c609f864638538f4a960ba34307045d74d10d462949e9728b2e14cf5eafc
+dist/2025-09-16/rustc-nightly-powerpc64-unknown-linux-gnu.tar.xz=ed4433fd1004935913d5a48faf78bcc4d2517f45e08032995414c69e4ede78ef
+dist/2025-09-16/rustc-nightly-powerpc64le-unknown-linux-gnu.tar.gz=9f54367ce8c0f2f1cbb29f84e403a8aebf9a3ec7d2675faa744e8c28b2adcd0f
+dist/2025-09-16/rustc-nightly-powerpc64le-unknown-linux-gnu.tar.xz=c1ebb094ca29b4fbb30326ae9ef99804d9f6ecee0bcb5633ce0236ea90058a13
+dist/2025-09-16/rustc-nightly-powerpc64le-unknown-linux-musl.tar.gz=c39f9dd4ad6f7939d114a9204a72cc22cf9a3d97ef3b496eff2bd78f55ff4e1d
+dist/2025-09-16/rustc-nightly-powerpc64le-unknown-linux-musl.tar.xz=cf218f8da409b2cdfe3820db1ce882e5d10f8a24a77b600cee9f00e85e747d13
+dist/2025-09-16/rustc-nightly-riscv64gc-unknown-linux-gnu.tar.gz=b64731d52f06f0b08fcc6dd64e9319d91fde2e48fd71d2b193f32ff770b81357
+dist/2025-09-16/rustc-nightly-riscv64gc-unknown-linux-gnu.tar.xz=07fac144d37f87e5f7b3a9521ef79789d7ab33cd529bb27c1b95238a28602857
+dist/2025-09-16/rustc-nightly-s390x-unknown-linux-gnu.tar.gz=727ca4ef70eb8cae09f73762202aee2b7998bc97c000571223991347a5408712
+dist/2025-09-16/rustc-nightly-s390x-unknown-linux-gnu.tar.xz=787ae447f764bf727c7debf6543b1ec22ebcf463832eb4d1279ec0f6824c2955
+dist/2025-09-16/rustc-nightly-sparcv9-sun-solaris.tar.gz=9f80d6add413e65dc6ab0e3d44b62f24134c6b3ee0bcc604ab66b3fdcd4fa0fe
+dist/2025-09-16/rustc-nightly-sparcv9-sun-solaris.tar.xz=3075e68b1f8a7b7a1c9489afdc2c9a38b1f0107865229497b2c9a7215853ef08
+dist/2025-09-16/rustc-nightly-x86_64-apple-darwin.tar.gz=685ffc70ff08c696321ebae272d09ba7f9e62f221929fa703e8cf21ba790df58
+dist/2025-09-16/rustc-nightly-x86_64-apple-darwin.tar.xz=29bd3bbb0f082cebf2dfef6d89a50dc5f33be231fe9d3e5bd2bb9b0b9bf53f90
+dist/2025-09-16/rustc-nightly-x86_64-pc-solaris.tar.gz=720e21f5ece47547b4cd91d5be89d67ce5334fa23a70921e7d60b0642b53a2d2
+dist/2025-09-16/rustc-nightly-x86_64-pc-solaris.tar.xz=d1e4d96e6f390ab2b6b1f435f5be61a69e01555f5bb66d58b2571f363cce8d26
+dist/2025-09-16/rustc-nightly-x86_64-pc-windows-gnu.tar.gz=2e1a315af7faa1f67c35e927fd0f3a0c96fecf0da1a2b3269ced7846d99d9100
+dist/2025-09-16/rustc-nightly-x86_64-pc-windows-gnu.tar.xz=7cb11ec687244e19a31996a3a802a8d0851cecd444abc5a8e65a10a037f67f4f
+dist/2025-09-16/rustc-nightly-x86_64-pc-windows-gnullvm.tar.gz=89010bc8a19cfafa6bc9714dd90cdcbb31cb85362846b8072cb41a3e8e7583ee
+dist/2025-09-16/rustc-nightly-x86_64-pc-windows-gnullvm.tar.xz=e84050c777e73941cb28f39e72a992b6a4a63100541f5b3fb288cf91fa1b0bd2
+dist/2025-09-16/rustc-nightly-x86_64-pc-windows-msvc.tar.gz=ffd857605275d71bf7e09eff94bc5fbc9cef222b1c076f1b7aee72f980e4c470
+dist/2025-09-16/rustc-nightly-x86_64-pc-windows-msvc.tar.xz=f28f28f07e98cb1bb43e93501cb43bd88b91b9913257f4de5c7154f0f9653d41
+dist/2025-09-16/rustc-nightly-x86_64-unknown-freebsd.tar.gz=66fe447d3f4526514b146633375efd40373dc28fe0262302be75afdf736986c2
+dist/2025-09-16/rustc-nightly-x86_64-unknown-freebsd.tar.xz=4d929f5079cd7a1c878631288765441aed538956d496881c89465aede623d94a
+dist/2025-09-16/rustc-nightly-x86_64-unknown-illumos.tar.gz=feed1caa5d31ab01cd4dc3c4b6b893c5d291fca9c470430f83c2cc90d26418b5
+dist/2025-09-16/rustc-nightly-x86_64-unknown-illumos.tar.xz=2f2b4e9e9a42f255cf66565012c63b2b2c0a13309dbce94d5135cd3280a8fc67
+dist/2025-09-16/rustc-nightly-x86_64-unknown-linux-gnu.tar.gz=f96e122b71d41b4889b18a0cee173822d509d8be9eaf28a3fec111df1a5dc5be
+dist/2025-09-16/rustc-nightly-x86_64-unknown-linux-gnu.tar.xz=ee8914df087f4e20c322851f322220e2f4885a316627c464881d086024e84b54
+dist/2025-09-16/rustc-nightly-x86_64-unknown-linux-musl.tar.gz=b226b4edc64f4ed91a9cb616600ece61c12f5da72ca4b62f13669e849de7ebe5
+dist/2025-09-16/rustc-nightly-x86_64-unknown-linux-musl.tar.xz=9a3d98e0fec50ab589027f1d5973ec583b062581b1a1cd59470bb4fb6c51c463
+dist/2025-09-16/rustc-nightly-x86_64-unknown-netbsd.tar.gz=bd0d47aaa630abc01d2f36f9c2a99577254aa3428abf1d666d5520c4fa990844
+dist/2025-09-16/rustc-nightly-x86_64-unknown-netbsd.tar.xz=863edf8589fe1f3f1728222ee49960457d9edd2abc521557f28562e546e27b81

From 714fdacdf8f2c07950e3f3ddd1999cba10b828af Mon Sep 17 00:00:00 2001
From: Mark Rousskov <mark.simulacrum@gmail.com>
Date: Mon, 15 Sep 2025 22:01:36 -0400
Subject: [PATCH 1456/1889] Apply cfg(bootstrap) replacement

---
 clippy_lints/src/lib.rs     | 1 -
 tests/missing-test-files.rs | 1 -
 2 files changed, 2 deletions(-)

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c56fa257b0689..b0083b99f175f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -7,7 +7,6 @@
 #![feature(iter_intersperse)]
 #![feature(iter_partition_in_place)]
 #![feature(never_type)]
-#![cfg_attr(bootstrap, feature(round_char_boundary))]
 #![feature(rustc_private)]
 #![feature(stmt_expr_attributes)]
 #![feature(unwrap_infallible)]
diff --git a/tests/missing-test-files.rs b/tests/missing-test-files.rs
index 63f960c92fa32..9fff3132498d8 100644
--- a/tests/missing-test-files.rs
+++ b/tests/missing-test-files.rs
@@ -1,6 +1,5 @@
 #![warn(rust_2018_idioms, unused_lifetimes)]
 #![allow(clippy::assertions_on_constants)]
-#![cfg_attr(bootstrap, feature(path_file_prefix))]
 
 use std::cmp::Ordering;
 use std::ffi::OsStr;

From 97f64374a9f34012c8884dbd629a896ec6ed8475 Mon Sep 17 00:00:00 2001
From: Daniel Verkamp <daniel@drv.nu>
Date: Fri, 26 Sep 2025 16:30:08 -0700
Subject: [PATCH 1457/1889] formatting_options: fix alternate docs 0b/0o mixup

The descriptions of the alternate forms of Octal and Binary were swapped
in the doc comment for FormattingOptions::alternate().
---
 library/core/src/fmt/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/library/core/src/fmt/mod.rs b/library/core/src/fmt/mod.rs
index b6de892530892..fcd2e52101ff0 100644
--- a/library/core/src/fmt/mod.rs
+++ b/library/core/src/fmt/mod.rs
@@ -386,8 +386,8 @@ impl FormattingOptions {
     /// used. The alternate forms are:
     /// - [`Debug`] : pretty-print the [`Debug`] formatting (adds linebreaks and indentation)
     /// - [`LowerHex`] as well as [`UpperHex`] - precedes the argument with a `0x`
-    /// - [`Octal`] - precedes the argument with a `0b`
-    /// - [`Binary`] - precedes the argument with a `0o`
+    /// - [`Octal`] - precedes the argument with a `0o`
+    /// - [`Binary`] - precedes the argument with a `0b`
     #[unstable(feature = "formatting_options", issue = "118117")]
     pub const fn alternate(&mut self, alternate: bool) -> &mut Self {
         if alternate {

From bb48c162b62ce20c5f51b6a435ca2ba7bb918d7e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Wed, 24 Sep 2025 23:25:29 +0000
Subject: [PATCH 1458/1889] Simplify logic slightly

---
 compiler/rustc_parse/src/parser/expr.rs | 37 +++++++++++++++----------
 1 file changed, 22 insertions(+), 15 deletions(-)

diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index 2f4158450d838..8046abcd70bd0 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -3612,20 +3612,36 @@ impl<'a> Parser<'a> {
         self.token.is_keyword(kw::Async) && self.is_gen_block(kw::Gen, 1)
     }
 
+    fn is_likely_struct_lit(&self) -> bool {
+        // `{ ident, ` and `{ ident: ` cannot start a block.
+        self.look_ahead(1, |t| t.is_ident())
+            && self.look_ahead(2, |t| t == &token::Comma || t == &token::Colon)
+    }
+
     fn maybe_parse_struct_expr(
         &mut self,
         qself: &Option<Box<ast::QSelf>>,
         path: &ast::Path,
     ) -> Option<PResult<'a, Box<Expr>>> {
         let struct_allowed = !self.restrictions.contains(Restrictions::NO_STRUCT_LITERAL);
-        let is_ident = self.look_ahead(1, |t| t.is_ident());
-        let is_comma = self.look_ahead(2, |t| t == &token::Comma);
-        let is_colon = self.look_ahead(2, |t| t == &token::Colon);
-        match (struct_allowed, is_ident, is_comma, is_colon) {
-            (false, true, true, _) | (false, true, _, true) => {
+        match (struct_allowed, self.is_likely_struct_lit()) {
+            // A struct literal isn't expected and one is pretty much assured not to be present. The
+            // only situation that isn't detected is when a struct with a single field was attempted
+            // in a place where a struct literal wasn't expected, but regular parser errors apply.
+            // Happy path.
+            (false, false) => None,
+            (true, _) => {
+                // A struct is accepted here, try to parse it and rely on `parse_expr_struct` for
+                // any kind of recovery. Happy path.
+                if let Err(err) = self.expect(exp!(OpenBrace)) {
+                    return Some(Err(err));
+                }
+                Some(self.parse_expr_struct(qself.clone(), path.clone(), true))
+            }
+            (false, true) => {
                 // We have something like `match foo { bar,` or `match foo { bar:`, which means the
                 // user might have meant to write a struct literal as part of the `match`
-                // discriminant.
+                // discriminant. This is done purely for error recovery.
                 let snapshot = self.create_snapshot_for_diagnostic();
                 if let Err(err) = self.expect(exp!(OpenBrace)) {
                     return Some(Err(err));
@@ -3651,15 +3667,6 @@ impl<'a> Parser<'a> {
                     }
                 }
             }
-            (true, _, _, _) => {
-                // A struct is accepted here, try to parse it and rely on `parse_expr_struct` for
-                // any kind of recovery.
-                if let Err(err) = self.expect(exp!(OpenBrace)) {
-                    return Some(Err(err));
-                }
-                Some(self.parse_expr_struct(qself.clone(), path.clone(), true))
-            }
-            (false, _, _, _) => None,
         }
     }
 

From fe3e124e8a4e5ba3dd92b99359bd6f4905eded19 Mon Sep 17 00:00:00 2001
From: "U. Lasiotus" <lasiotus@motor-os.org>
Date: Fri, 26 Sep 2025 17:05:30 -0700
Subject: [PATCH 1459/1889] doc: fix a typo in platform-support.md

---
 src/doc/rustc/src/SUMMARY.md          | 1 +
 src/doc/rustc/src/platform-support.md | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/doc/rustc/src/SUMMARY.md b/src/doc/rustc/src/SUMMARY.md
index 619eebd15bd37..67882bb38132a 100644
--- a/src/doc/rustc/src/SUMMARY.md
+++ b/src/doc/rustc/src/SUMMARY.md
@@ -121,6 +121,7 @@
     - [\*-unknown-hermit](platform-support/hermit.md)
     - [\*-unknown-freebsd](platform-support/freebsd.md)
     - [\*-unknown-managarm-mlibc](platform-support/managarm.md)
+    - [\*-unknown-motor](platform-support/motor.md)
     - [\*-unknown-netbsd\*](platform-support/netbsd.md)
     - [\*-unknown-openbsd](platform-support/openbsd.md)
     - [\*-unknown-redox](platform-support/redox.md)
diff --git a/src/doc/rustc/src/platform-support.md b/src/doc/rustc/src/platform-support.md
index 99c8e365f5cf5..b29d01a138733 100644
--- a/src/doc/rustc/src/platform-support.md
+++ b/src/doc/rustc/src/platform-support.md
@@ -431,7 +431,7 @@ target | std | host | notes
 `x86_64-unknown-l4re-uclibc` | ? |  |
 [`x86_64-unknown-linux-none`](platform-support/x86_64-unknown-linux-none.md) | * |  | 64-bit Linux with no libc
 [`x86_64-unknown-managarm-mlibc`](platform-support/managarm.md) | ? |   | x86_64 Managarm
-[`x86_64-unknown-motor`[(platform-support/motor.md) | ? |  | x86_64 Motor OS
+[`x86_64-unknown-motor`](platform-support/motor.md) | ? |  | x86_64 Motor OS
 [`x86_64-unknown-openbsd`](platform-support/openbsd.md) | ✓ | ✓ | 64-bit OpenBSD
 [`x86_64-unknown-trusty`](platform-support/trusty.md) | ✓ |  |
 `x86_64-uwp-windows-gnu` | ✓ |  |

From d8a1edc718537fc595dc731fcb89f17378de6af2 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sat, 27 Sep 2025 18:23:18 +1000
Subject: [PATCH 1460/1889] Use `PanicHookInfo::payload_as_str` now that it's
 stable in beta

---
 src/tools/compiletest/src/panic_hook.rs | 15 +--------------
 1 file changed, 1 insertion(+), 14 deletions(-)

diff --git a/src/tools/compiletest/src/panic_hook.rs b/src/tools/compiletest/src/panic_hook.rs
index 1661ca6dabe8a..4f1e2547518f0 100644
--- a/src/tools/compiletest/src/panic_hook.rs
+++ b/src/tools/compiletest/src/panic_hook.rs
@@ -42,7 +42,7 @@ fn custom_panic_hook(default_hook: &PanicHook, info: &panic::PanicHookInfo<'_>)
 
     let thread = thread::current().name().unwrap_or("(test runner)").to_owned();
     let location = get_location(info);
-    let payload = payload_as_str(info).unwrap_or("Box<dyn Any>");
+    let payload = info.payload_as_str().unwrap_or("Box<dyn Any>");
     let backtrace = Backtrace::capture();
 
     writeln!(out, "\nthread '{thread}' panicked at {location}:\n{payload}").unwrap();
@@ -72,19 +72,6 @@ fn get_location<'a>(info: &'a PanicHookInfo<'_>) -> &'a dyn Display {
     }
 }
 
-/// FIXME(Zalathar): Replace with `PanicHookInfo::payload_as_str` when that's
-/// stable in beta.
-fn payload_as_str<'a>(info: &'a PanicHookInfo<'_>) -> Option<&'a str> {
-    let payload = info.payload();
-    if let Some(s) = payload.downcast_ref::<&str>() {
-        Some(s)
-    } else if let Some(s) = payload.downcast_ref::<String>() {
-        Some(s)
-    } else {
-        None
-    }
-}
-
 fn rust_backtrace_full() -> bool {
     static RUST_BACKTRACE_FULL: LazyLock<bool> =
         LazyLock::new(|| matches!(env::var("RUST_BACKTRACE").as_deref(), Ok("full")));

From 95c146a0c1ff987c8263a2ddb7dced4e5b545842 Mon Sep 17 00:00:00 2001
From: Simon Sapin <simon.sapin@exyr.org>
Date: Fri, 26 Sep 2025 15:55:42 +0200
Subject: [PATCH 1461/1889] Fix tracking issue number for feature(macro_attr)

The ability to define an attribute macro with `macro_rules!` is tracked at https://github.com/rust-lang/rust/issues/143547, not https://github.com/rust-lang/rust/issues/83527
---
 compiler/rustc_feature/src/unstable.rs                | 2 +-
 tests/ui/feature-gates/feature-gate-macro-attr.stderr | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 6ef0df72365ec..158cf8d2db32f 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -554,7 +554,7 @@ declare_features! (
     /// Allows fused `loop`/`match` for direct intraprocedural jumps.
     (incomplete, loop_match, "1.90.0", Some(132306)),
     /// Allow `macro_rules!` attribute rules
-    (unstable, macro_attr, "1.91.0", Some(83527)),
+    (unstable, macro_attr, "1.91.0", Some(143547)),
     /// Allow `macro_rules!` derive rules
     (unstable, macro_derive, "1.91.0", Some(143549)),
     /// Give access to additional metadata about declarative macro meta-variables.
diff --git a/tests/ui/feature-gates/feature-gate-macro-attr.stderr b/tests/ui/feature-gates/feature-gate-macro-attr.stderr
index b58418527c5b0..75bc93e80271a 100644
--- a/tests/ui/feature-gates/feature-gate-macro-attr.stderr
+++ b/tests/ui/feature-gates/feature-gate-macro-attr.stderr
@@ -4,7 +4,7 @@ error[E0658]: `macro_rules!` attributes are unstable
 LL | macro_rules! myattr { attr() {} => {} }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: see issue #83527 <https://github.com/rust-lang/rust/issues/83527> for more information
+   = note: see issue #143547 <https://github.com/rust-lang/rust/issues/143547> for more information
    = help: add `#![feature(macro_attr)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 

From 7c00bccd3b3eb6717e3c801123107962e671e48f Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sat, 29 Mar 2025 00:53:59 +0100
Subject: [PATCH 1462/1889] Implement RFC 3631

---
 compiler/rustc_ast_passes/src/feature_gate.rs |   2 -
 compiler/rustc_passes/messages.ftl            |   9 +
 compiler/rustc_passes/src/check_attr.rs       |  53 ++-
 compiler/rustc_passes/src/errors.rs           |  14 +-
 compiler/rustc_span/src/symbol.rs             |   4 +
 library/alloc/src/lib.rs                      |  29 +-
 library/core/src/lib.rs                       |  69 ++--
 library/std/src/lib.rs                        |  16 +-
 src/librustdoc/clean/cfg.rs                   |  30 ++
 src/librustdoc/clean/inline.rs                |  15 +-
 src/librustdoc/clean/mod.rs                   |  10 +-
 src/librustdoc/clean/types.rs                 | 302 ++++++++++++++----
 src/librustdoc/doctest/rust.rs                |  11 +-
 src/librustdoc/formats/cache.rs               |   2 -
 src/librustdoc/passes/propagate_doc_cfg.rs    | 134 +++++---
 src/librustdoc/visit_ast.rs                   |  27 --
 16 files changed, 518 insertions(+), 209 deletions(-)

diff --git a/compiler/rustc_ast_passes/src/feature_gate.rs b/compiler/rustc_ast_passes/src/feature_gate.rs
index 9ab5b0b354726..fe9cc8e61ed5b 100644
--- a/compiler/rustc_ast_passes/src/feature_gate.rs
+++ b/compiler/rustc_ast_passes/src/feature_gate.rs
@@ -182,8 +182,6 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
 
                 gate_doc!(
                     "experimental" {
-                        cfg => doc_cfg
-                        cfg_hide => doc_cfg_hide
                         masked => doc_masked
                         notable_trait => doc_notable_trait
                     }
diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index 870e0a90b5421..19014f37c6628 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -143,6 +143,15 @@ passes_doc_attribute_not_attribute =
 passes_doc_cfg_hide_takes_list =
     `#[doc(cfg_hide(...))]` takes a list of attributes
 
+passes_doc_auto_cfg_expects_hide_or_show =
+    `only "hide" or "show" are allowed in "#[doc(auto_cfg(...))]"`
+
+passes_doc_auto_cfg_hide_show_expects_list =
+    `#![doc(auto_cfg({$attr_name}(...)))]` only expects a list of items
+
+passes_doc_auto_cfg_wrong_literal =
+    `expected boolean for #[doc(auto_cfg = ...)]`
+
 passes_doc_expect_str =
     doc {$attr_name} attribute expects a string: #[doc({$attr_name} = "a")]
 
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 007353f136d56..3dc232a35ec3a 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -1160,16 +1160,43 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         }
     }
 
-    /// Check that the `#![doc(cfg_hide(...))]` attribute only contains a list of attributes.
-    ///
-    fn check_doc_cfg_hide(&self, meta: &MetaItemInner, hir_id: HirId) {
-        if meta.meta_item_list().is_none() {
-            self.tcx.emit_node_span_lint(
-                INVALID_DOC_ATTRIBUTES,
-                hir_id,
-                meta.span(),
-                errors::DocCfgHideTakesList,
-            );
+    /// Check that the `#![doc(auto_cfg(..))]` attribute has expected input.
+    fn check_doc_auto_cfg(&self, meta: &MetaItemInner, hir_id: HirId) {
+        let MetaItemInner::MetaItem(meta) = meta else {
+            unreachable!();
+        };
+        match &meta.kind {
+            MetaItemKind::Word => {}
+            MetaItemKind::NameValue(lit) => {
+                if !matches!(lit.kind, LitKind::Bool(_)) {
+                    self.tcx.emit_node_span_lint(
+                        INVALID_DOC_ATTRIBUTES,
+                        hir_id,
+                        meta.span,
+                        errors::DocAutoCfgWrongLiteral,
+                    );
+                }
+            }
+            MetaItemKind::List(list) => {
+                for item in list {
+                    let Some(attr_name) = item.name() else { continue };
+                    if attr_name != sym::hide && attr_name != sym::show {
+                        self.tcx.emit_node_span_lint(
+                            INVALID_DOC_ATTRIBUTES,
+                            hir_id,
+                            meta.span,
+                            errors::DocAutoCfgExpectsHideOrShow,
+                        );
+                    } else if item.meta_item_list().is_none() {
+                        self.tcx.emit_node_span_lint(
+                            INVALID_DOC_ATTRIBUTES,
+                            hir_id,
+                            meta.span,
+                            errors::DocAutoCfgHideShowExpectsList { attr_name: attr_name.as_str() },
+                        );
+                    }
+                }
+            }
         }
     }
 
@@ -1245,10 +1272,8 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                             self.check_attr_crate_level(attr, style, meta, hir_id);
                         }
 
-                        Some(sym::cfg_hide) => {
-                            if self.check_attr_crate_level(attr, style, meta, hir_id) {
-                                self.check_doc_cfg_hide(meta, hir_id);
-                            }
+                        Some(sym::auto_cfg) => {
+                            self.check_doc_auto_cfg(meta, hir_id);
                         }
 
                         Some(sym::inline | sym::no_inline) => {
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index cfd6b9e6dffaf..6cc0bd6ce48bd 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -309,8 +309,18 @@ pub(crate) struct DocTestLiteral;
 pub(crate) struct DocTestTakesList;
 
 #[derive(LintDiagnostic)]
-#[diag(passes_doc_cfg_hide_takes_list)]
-pub(crate) struct DocCfgHideTakesList;
+#[diag(passes_doc_auto_cfg_wrong_literal)]
+pub(crate) struct DocAutoCfgWrongLiteral;
+
+#[derive(LintDiagnostic)]
+#[diag(passes_doc_auto_cfg_expects_hide_or_show)]
+pub(crate) struct DocAutoCfgExpectsHideOrShow;
+
+#[derive(LintDiagnostic)]
+#[diag(passes_doc_auto_cfg_hide_show_expects_list)]
+pub(crate) struct DocAutoCfgHideShowExpectsList<'a> {
+    pub attr_name: &'a str,
+}
 
 #[derive(LintDiagnostic)]
 #[diag(passes_doc_test_unknown_any)]
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index faf32523baae7..e80a98994dbba 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -545,6 +545,7 @@ symbols! {
         attributes,
         audit_that,
         augmented_assignments,
+        auto_cfg,
         auto_traits,
         autodiff,
         autodiff_forward,
@@ -1149,6 +1150,8 @@ symbols! {
         hashset_iter_ty,
         hexagon_target_feature,
         hidden,
+        hidden_cfg,
+        hide,
         hint,
         homogeneous_aggregate,
         host,
@@ -1987,6 +1990,7 @@ symbols! {
         shl_assign,
         shorter_tail_lifetimes,
         should_panic,
+        show,
         shr,
         shr_assign,
         sig_dfl,
diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs
index cba1ce40f75d5..243fdc2e8436f 100644
--- a/library/alloc/src/lib.rs
+++ b/library/alloc/src/lib.rs
@@ -64,14 +64,27 @@
     issue_tracker_base_url = "https://github.com/rust-lang/rust/issues/",
     test(no_crate_inject, attr(allow(unused_variables), deny(warnings)))
 )]
-#![doc(cfg_hide(
-    not(test),
-    no_global_oom_handling,
-    not(no_global_oom_handling),
-    not(no_rc),
-    not(no_sync),
-    target_has_atomic = "ptr"
-))]
+#![cfg_attr(
+    bootstrap,
+    doc(cfg_hide(
+        not(test),
+        no_global_oom_handling,
+        not(no_global_oom_handling),
+        not(no_rc),
+        not(no_sync),
+        target_has_atomic = "ptr"
+    ))
+)]
+#![cfg_attr(
+    not(bootstrap),
+    doc(auto_cfg(hide(
+        test,
+        no_global_oom_handling,
+        no_rc,
+        no_sync,
+        target_has_atomic = "ptr"
+    )))
+)]
 #![doc(rust_logo)]
 #![feature(rustdoc_internals)]
 #![no_std]
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 5d52bfb1b125f..32a3d6c7042aa 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -51,27 +51,54 @@
     test(attr(allow(dead_code, deprecated, unused_variables, unused_mut)))
 )]
 #![doc(rust_logo)]
-#![doc(cfg_hide(
-    no_fp_fmt_parse,
-    target_pointer_width = "16",
-    target_pointer_width = "32",
-    target_pointer_width = "64",
-    target_has_atomic = "8",
-    target_has_atomic = "16",
-    target_has_atomic = "32",
-    target_has_atomic = "64",
-    target_has_atomic = "ptr",
-    target_has_atomic_equal_alignment = "8",
-    target_has_atomic_equal_alignment = "16",
-    target_has_atomic_equal_alignment = "32",
-    target_has_atomic_equal_alignment = "64",
-    target_has_atomic_equal_alignment = "ptr",
-    target_has_atomic_load_store = "8",
-    target_has_atomic_load_store = "16",
-    target_has_atomic_load_store = "32",
-    target_has_atomic_load_store = "64",
-    target_has_atomic_load_store = "ptr",
-))]
+#![cfg_attr(
+    bootstrap,
+    doc(cfg_hide(
+        no_fp_fmt_parse,
+        target_pointer_width = "16",
+        target_pointer_width = "32",
+        target_pointer_width = "64",
+        target_has_atomic = "8",
+        target_has_atomic = "16",
+        target_has_atomic = "32",
+        target_has_atomic = "64",
+        target_has_atomic = "ptr",
+        target_has_atomic_equal_alignment = "8",
+        target_has_atomic_equal_alignment = "16",
+        target_has_atomic_equal_alignment = "32",
+        target_has_atomic_equal_alignment = "64",
+        target_has_atomic_equal_alignment = "ptr",
+        target_has_atomic_load_store = "8",
+        target_has_atomic_load_store = "16",
+        target_has_atomic_load_store = "32",
+        target_has_atomic_load_store = "64",
+        target_has_atomic_load_store = "ptr",
+    ))
+)]
+#![cfg_attr(
+    not(bootstrap),
+    doc(auto_cfg(hide(
+        no_fp_fmt_parse,
+        target_pointer_width = "16",
+        target_pointer_width = "32",
+        target_pointer_width = "64",
+        target_has_atomic = "8",
+        target_has_atomic = "16",
+        target_has_atomic = "32",
+        target_has_atomic = "64",
+        target_has_atomic = "ptr",
+        target_has_atomic_equal_alignment = "8",
+        target_has_atomic_equal_alignment = "16",
+        target_has_atomic_equal_alignment = "32",
+        target_has_atomic_equal_alignment = "64",
+        target_has_atomic_equal_alignment = "ptr",
+        target_has_atomic_load_store = "8",
+        target_has_atomic_load_store = "16",
+        target_has_atomic_load_store = "32",
+        target_has_atomic_load_store = "64",
+        target_has_atomic_load_store = "ptr",
+    )))
+)]
 #![no_core]
 #![rustc_coherence_is_core]
 #![rustc_preserve_ub_checks]
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index 233e41aa34535..93c91b615258d 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -235,7 +235,21 @@
     test(attr(allow(dead_code, deprecated, unused_variables, unused_mut)))
 )]
 #![doc(rust_logo)]
-#![doc(cfg_hide(not(test), no_global_oom_handling, not(no_global_oom_handling)))]
+#![cfg_attr(
+    bootstrap,
+    doc(cfg_hide(
+        not(test),
+        no_global_oom_handling,
+        not(no_global_oom_handling)
+    ))
+)]
+#![cfg_attr(
+    not(bootstrap),
+    doc(auto_cfg(hide(
+        test,
+        no_global_oom_handling,
+    )))
+)]
 // Don't link to std. We are std.
 #![no_std]
 // Tell the compiler to link to either panic_abort or panic_unwind
diff --git a/src/librustdoc/clean/cfg.rs b/src/librustdoc/clean/cfg.rs
index 8feca1367fc9e..aa614b73dea72 100644
--- a/src/librustdoc/clean/cfg.rs
+++ b/src/librustdoc/clean/cfg.rs
@@ -256,6 +256,36 @@ impl Cfg {
     fn omit_preposition(&self) -> bool {
         matches!(self, Cfg::True | Cfg::False)
     }
+
+    pub(crate) fn strip_hidden(&self, hidden: &FxHashSet<Cfg>) -> Option<Self> {
+        match self {
+            Self::True | Self::False => Some(self.clone()),
+            Self::Cfg(..) => {
+                if !hidden.contains(self) {
+                    Some(self.clone())
+                } else {
+                    None
+                }
+            }
+            Self::Not(cfg) => {
+                if let Some(cfg) = cfg.strip_hidden(hidden) {
+                    Some(Self::Not(Box::new(cfg)))
+                } else {
+                    None
+                }
+            }
+            Self::Any(cfgs) => {
+                let cfgs =
+                    cfgs.iter().filter_map(|cfg| cfg.strip_hidden(hidden)).collect::<Vec<_>>();
+                if cfgs.is_empty() { None } else { Some(Self::Any(cfgs)) }
+            }
+            Self::All(cfgs) => {
+                let cfgs =
+                    cfgs.iter().filter_map(|cfg| cfg.strip_hidden(hidden)).collect::<Vec<_>>();
+                if cfgs.is_empty() { None } else { Some(Self::All(cfgs)) }
+            }
+        }
+    }
 }
 
 impl ops::Not for Cfg {
diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs
index 8461e15c6c3f5..8ffa6033c9b0d 100644
--- a/src/librustdoc/clean/inline.rs
+++ b/src/librustdoc/clean/inline.rs
@@ -19,10 +19,10 @@ use tracing::{debug, trace};
 
 use super::{Item, extract_cfg_from_attrs};
 use crate::clean::{
-    self, Attributes, ImplKind, ItemId, Type, clean_bound_vars, clean_generics, clean_impl_item,
-    clean_middle_assoc_item, clean_middle_field, clean_middle_ty, clean_poly_fn_sig,
-    clean_trait_ref_with_constraints, clean_ty, clean_ty_alias_inner_type, clean_ty_generics,
-    clean_variant_def, utils,
+    self, Attributes, CfgInfo, ImplKind, ItemId, Type, clean_bound_vars, clean_generics,
+    clean_impl_item, clean_middle_assoc_item, clean_middle_field, clean_middle_ty,
+    clean_poly_fn_sig, clean_trait_ref_with_constraints, clean_ty, clean_ty_alias_inner_type,
+    clean_ty_generics, clean_variant_def, utils,
 };
 use crate::core::DocContext;
 use crate::formats::item_type::ItemType;
@@ -409,6 +409,7 @@ pub(crate) fn merge_attrs(
     cx: &mut DocContext<'_>,
     old_attrs: &[hir::Attribute],
     new_attrs: Option<(&[hir::Attribute], Option<LocalDefId>)>,
+    cfg_info: &mut CfgInfo,
 ) -> (clean::Attributes, Option<Arc<clean::cfg::Cfg>>) {
     // NOTE: If we have additional attributes (from a re-export),
     // always insert them first. This ensure that re-export
@@ -423,12 +424,12 @@ pub(crate) fn merge_attrs(
             } else {
                 Attributes::from_hir(&both)
             },
-            extract_cfg_from_attrs(both.iter(), cx.tcx, &cx.cache.hidden_cfg),
+            extract_cfg_from_attrs(both.iter(), cx.tcx, cfg_info),
         )
     } else {
         (
             Attributes::from_hir(old_attrs),
-            extract_cfg_from_attrs(old_attrs.iter(), cx.tcx, &cx.cache.hidden_cfg),
+            extract_cfg_from_attrs(old_attrs.iter(), cx.tcx, cfg_info),
         )
     }
 }
@@ -604,7 +605,7 @@ pub(crate) fn build_impl(
         });
     }
 
-    let (merged_attrs, cfg) = merge_attrs(cx, load_attrs(cx, did), attrs);
+    let (merged_attrs, cfg) = merge_attrs(cx, load_attrs(cx, did), attrs, &mut CfgInfo::default());
     trace!("merged_attrs={merged_attrs:?}");
 
     trace!(
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 0afb969d5c84f..c6339dd475593 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -212,18 +212,10 @@ fn generate_item_with_correct_attrs(
         // We only keep the item's attributes.
         target_attrs.iter().map(|attr| (Cow::Borrowed(attr), None)).collect()
     };
-    let cfg = extract_cfg_from_attrs(
-        attrs.iter().map(move |(attr, _)| match attr {
-            Cow::Borrowed(attr) => *attr,
-            Cow::Owned(attr) => attr,
-        }),
-        cx.tcx,
-        &cx.cache.hidden_cfg,
-    );
     let attrs = Attributes::from_hir_iter(attrs.iter().map(|(attr, did)| (&**attr, *did)), false);
 
     let name = renamed.or(Some(name));
-    let mut item = Item::from_def_id_and_attrs_and_parts(def_id, name, kind, attrs, cfg);
+    let mut item = Item::from_def_id_and_attrs_and_parts(def_id, name, kind, attrs, None);
     // FIXME (GuillaumeGomez): Should we also make `inline_stmt_id` a `Vec` instead of an `Option`?
     item.inner.inline_stmt_id = import_ids.first().copied();
     item
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index ff513c71035d7..63e8357801c05 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -6,7 +6,8 @@ use std::{fmt, iter};
 use arrayvec::ArrayVec;
 use itertools::Either;
 use rustc_abi::{ExternAbi, VariantIdx};
-use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
+use rustc_ast::ast::{LitKind, MetaItemInner, MetaItemKind};
+use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_hir::attrs::{AttributeKind, DeprecatedSince, Deprecation};
 use rustc_hir::def::{CtorKind, DefKind, Res};
 use rustc_hir::def_id::{CrateNum, DefId, LOCAL_CRATE, LocalDefId};
@@ -467,7 +468,7 @@ impl Item {
             name,
             kind,
             Attributes::from_hir(hir_attrs),
-            extract_cfg_from_attrs(hir_attrs.iter(), cx.tcx, &cx.cache.hidden_cfg),
+            None,
         )
     }
 
@@ -902,30 +903,6 @@ impl ItemKind {
             | AttributeItem => [].iter(),
         }
     }
-
-    /// Returns `true` if this item does not appear inside an impl block.
-    pub(crate) fn is_non_assoc(&self) -> bool {
-        matches!(
-            self,
-            StructItem(_)
-                | UnionItem(_)
-                | EnumItem(_)
-                | TraitItem(_)
-                | ModuleItem(_)
-                | ExternCrateItem { .. }
-                | FunctionItem(_)
-                | TypeAliasItem(_)
-                | StaticItem(_)
-                | ConstantItem(_)
-                | TraitAliasItem(_)
-                | ForeignFunctionItem(_, _)
-                | ForeignStaticItem(_, _)
-                | ForeignTypeItem
-                | MacroItem(_)
-                | ProcMacroItem(_)
-                | PrimitiveItem(_)
-        )
-    }
 }
 
 #[derive(Clone, Debug)]
@@ -945,14 +922,85 @@ pub(crate) fn hir_attr_lists<'a, I: IntoIterator<Item = &'a hir::Attribute>>(
         .flatten()
 }
 
+#[derive(Clone, Debug)]
+pub(crate) struct CfgInfo {
+    hidden_cfg: FxHashSet<Cfg>,
+    current_cfg: Cfg,
+    doc_auto_cfg_active: bool,
+    parent_is_doc_cfg: bool,
+}
+
+impl Default for CfgInfo {
+    fn default() -> Self {
+        Self {
+            hidden_cfg: [
+                Cfg::Cfg(sym::test, None),
+                Cfg::Cfg(sym::doc, None),
+                Cfg::Cfg(sym::doctest, None),
+            ]
+            .into_iter()
+            .collect(),
+            current_cfg: Cfg::True,
+            doc_auto_cfg_active: true,
+            parent_is_doc_cfg: false,
+        }
+    }
+}
+
+fn show_hide_show_conflict_error(
+    tcx: TyCtxt<'_>,
+    item_span: rustc_span::Span,
+    previous: rustc_span::Span,
+) {
+    let mut diag = tcx.sess.dcx().struct_span_err(
+        item_span,
+        format!(
+            "same `cfg` was in `auto_cfg(hide(...))` and `auto_cfg(show(...))` on the same item"
+        ),
+    );
+    diag.span_note(previous, "first change was here");
+    diag.emit();
+}
+
+fn handle_auto_cfg_hide_show(
+    tcx: TyCtxt<'_>,
+    cfg_info: &mut CfgInfo,
+    sub_attr: &MetaItemInner,
+    is_show: bool,
+    new_show_attrs: &mut FxHashMap<(Symbol, Option<Symbol>), rustc_span::Span>,
+    new_hide_attrs: &mut FxHashMap<(Symbol, Option<Symbol>), rustc_span::Span>,
+) {
+    if let MetaItemInner::MetaItem(item) = sub_attr
+        && let MetaItemKind::List(items) = &item.kind
+    {
+        for item in items {
+            // Cfg parsing errors should already have been reported in `rustc_passes::check_attr`.
+            if let Ok(Cfg::Cfg(key, value)) = Cfg::parse(item) {
+                if is_show {
+                    if let Some(span) = new_hide_attrs.get(&(key, value)) {
+                        show_hide_show_conflict_error(tcx, item.span(), *span);
+                    } else {
+                        new_show_attrs.insert((key, value), item.span());
+                    }
+                    cfg_info.hidden_cfg.remove(&Cfg::Cfg(key, value));
+                } else {
+                    if let Some(span) = new_show_attrs.get(&(key, value)) {
+                        show_hide_show_conflict_error(tcx, item.span(), *span);
+                    } else {
+                        new_hide_attrs.insert((key, value), item.span());
+                    }
+                    cfg_info.hidden_cfg.insert(Cfg::Cfg(key, value));
+                }
+            }
+        }
+    }
+}
+
 pub(crate) fn extract_cfg_from_attrs<'a, I: Iterator<Item = &'a hir::Attribute> + Clone>(
     attrs: I,
     tcx: TyCtxt<'_>,
-    hidden_cfg: &FxHashSet<Cfg>,
+    cfg_info: &mut CfgInfo,
 ) -> Option<Arc<Cfg>> {
-    let doc_cfg_active = tcx.features().doc_cfg();
-    let doc_auto_cfg_active = tcx.features().doc_auto_cfg();
-
     fn single<T: IntoIterator>(it: T) -> Option<T::Item> {
         let mut iter = it.into_iter();
         let item = iter.next()?;
@@ -962,56 +1010,168 @@ pub(crate) fn extract_cfg_from_attrs<'a, I: Iterator<Item = &'a hir::Attribute>
         Some(item)
     }
 
-    let mut cfg = if doc_cfg_active || doc_auto_cfg_active {
-        let mut doc_cfg = attrs
-            .clone()
-            .filter(|attr| attr.has_name(sym::doc))
-            .flat_map(|attr| attr.meta_item_list().unwrap_or_default())
-            .filter(|attr| attr.has_name(sym::cfg))
-            .peekable();
-        if doc_cfg.peek().is_some() && doc_cfg_active {
-            let sess = tcx.sess;
-
-            doc_cfg.fold(Cfg::True, |mut cfg, item| {
-                if let Some(cfg_mi) =
-                    item.meta_item().and_then(|item| rustc_expand::config::parse_cfg(item, sess))
+    let mut new_show_attrs = FxHashMap::default();
+    let mut new_hide_attrs = FxHashMap::default();
+
+    let mut doc_cfg = attrs
+        .clone()
+        .filter(|attr| attr.has_name(sym::doc))
+        .flat_map(|attr| attr.meta_item_list().unwrap_or_default())
+        .filter(|attr| attr.has_name(sym::cfg))
+        .peekable();
+    // If the item uses `doc(cfg(...))`, then we ignore the other `cfg(...)` attributes.
+    if doc_cfg.peek().is_some() {
+        let sess = tcx.sess;
+        // We overwrite existing `cfg`.
+        if !cfg_info.parent_is_doc_cfg {
+            cfg_info.current_cfg = Cfg::True;
+            cfg_info.parent_is_doc_cfg = true;
+        }
+        for attr in doc_cfg {
+            if let Some(cfg_mi) =
+                attr.meta_item().and_then(|attr| rustc_expand::config::parse_cfg(attr, sess))
+            {
+                match Cfg::parse(cfg_mi) {
+                    Ok(new_cfg) => cfg_info.current_cfg &= new_cfg,
+                    Err(e) => {
+                        sess.dcx().span_err(e.span, e.msg);
+                    }
+                }
+            }
+        }
+    } else {
+        cfg_info.parent_is_doc_cfg = false;
+    }
+
+    let mut changed_auto_active_status = None;
+
+    // First we get all `doc(auto_cfg)` attributes.
+    for attr in attrs.clone() {
+        if let Some(ident) = attr.ident()
+            && ident.name == sym::doc
+            && let Some(attrs) = attr.meta_item_list()
+        {
+            for attr in attrs.iter().filter(|attr| attr.has_name(sym::auto_cfg)) {
+                let MetaItemInner::MetaItem(attr) = attr else {
+                    continue;
+                };
+                match &attr.kind {
+                    MetaItemKind::Word => {
+                        if let Some(first_change) = changed_auto_active_status {
+                            if !cfg_info.doc_auto_cfg_active {
+                                tcx.sess.dcx().struct_span_err(
+                                    vec![first_change, attr.span],
+                                    "`auto_cfg` was disabled and enabled more than once on the same item",
+                                ).emit();
+                                return None;
+                            }
+                        } else {
+                            changed_auto_active_status = Some(attr.span);
+                        }
+                        cfg_info.doc_auto_cfg_active = true;
+                    }
+                    MetaItemKind::NameValue(lit) => {
+                        if let LitKind::Bool(value) = lit.kind {
+                            if let Some(first_change) = changed_auto_active_status {
+                                if cfg_info.doc_auto_cfg_active != value {
+                                    tcx.sess.dcx().struct_span_err(
+                                        vec![first_change, attr.span],
+                                        "`auto_cfg` was disabled and enabled more than once on the same item",
+                                    ).emit();
+                                    return None;
+                                }
+                            } else {
+                                changed_auto_active_status = Some(attr.span);
+                            }
+                            cfg_info.doc_auto_cfg_active = value;
+                        }
+                    }
+                    MetaItemKind::List(sub_attrs) => {
+                        if let Some(first_change) = changed_auto_active_status {
+                            if !cfg_info.doc_auto_cfg_active {
+                                tcx.sess.dcx().struct_span_err(
+                                    vec![first_change, attr.span],
+                                    "`auto_cfg` was disabled and enabled more than once on the same item",
+                                ).emit();
+                                return None;
+                            }
+                        } else {
+                            changed_auto_active_status = Some(attr.span);
+                        }
+                        // Whatever happens next, the feature is enabled again.
+                        cfg_info.doc_auto_cfg_active = true;
+                        for sub_attr in sub_attrs.iter() {
+                            if let Some(ident) = sub_attr.ident()
+                                && (ident.name == sym::show || ident.name == sym::hide)
+                            {
+                                handle_auto_cfg_hide_show(
+                                    tcx,
+                                    cfg_info,
+                                    &sub_attr,
+                                    ident.name == sym::show,
+                                    &mut new_show_attrs,
+                                    &mut new_hide_attrs,
+                                );
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // If there is no `doc(cfg())`, then we retrieve the `cfg()` attributes (because
+    // `doc(cfg())` overrides `cfg()`).
+    for attr in attrs {
+        let Some(ident) = attr.ident() else { continue };
+        match ident.name {
+            sym::cfg | sym::cfg_trace if !cfg_info.parent_is_doc_cfg => {
+                if let Some(attr) = single(attr.meta_item_list()?)
+                    && let Ok(new_cfg) = Cfg::parse(&attr)
                 {
-                    match Cfg::parse(cfg_mi) {
-                        Ok(new_cfg) => cfg &= new_cfg,
-                        Err(e) => {
-                            sess.dcx().span_err(e.span, e.msg);
+                    cfg_info.current_cfg &= new_cfg;
+                }
+            }
+            // treat #[target_feature(enable = "feat")] attributes as if they were
+            // #[doc(cfg(target_feature = "feat"))] attributes as well
+            sym::target_feature
+                if let Some(attrs) = attr.meta_item_list() =>
+            {
+                for attr in attrs {
+                    if attr.has_name(sym::enable) && attr.value_str().is_some() {
+                        // Clone `enable = "feat"`, change to `target_feature = "feat"`.
+                        // Unwrap is safe because `value_str` succeeded above.
+                        let mut meta = attr.meta_item().unwrap().clone();
+                        meta.path =
+                            ast::Path::from_ident(Ident::with_dummy_span(sym::target_feature));
+
+                        if let Ok(feat_cfg) = Cfg::parse(&ast::MetaItemInner::MetaItem(meta)) {
+                            cfg_info.current_cfg &= feat_cfg;
                         }
                     }
                 }
-                cfg
-            })
-        } else if doc_auto_cfg_active {
-            // If there is no `doc(cfg())`, then we retrieve the `cfg()` attributes (because
-            // `doc(cfg())` overrides `cfg()`).
-            attrs
-                .clone()
-                .filter(|attr| attr.has_name(sym::cfg_trace))
-                .filter_map(|attr| single(attr.meta_item_list()?))
-                .filter_map(|attr| Cfg::parse_without(attr.meta_item()?, hidden_cfg).ok().flatten())
-                .fold(Cfg::True, |cfg, new_cfg| cfg & new_cfg)
+            }
+            _ => {}
+        }
+    }
+
+    // If `doc(auto_cfg)` feature is disabled and `doc(cfg())` wasn't used, there is nothing
+    // to be done here.
+    if !cfg_info.doc_auto_cfg_active && !cfg_info.parent_is_doc_cfg {
+        None
+    } else if cfg_info.parent_is_doc_cfg {
+        if cfg_info.current_cfg == Cfg::True {
+            None
         } else {
-            Cfg::True
+            Some(Arc::new(cfg_info.current_cfg.clone()))
         }
     } else {
-        Cfg::True
-    };
-
-    // treat #[target_feature(enable = "feat")] attributes as if they were
-    // #[doc(cfg(target_feature = "feat"))] attributes as well
-    if let Some(features) =
-        find_attr!(attrs, AttributeKind::TargetFeature { features, .. } => features)
-    {
-        for (feature, _) in features {
-            cfg &= Cfg::Cfg(sym::target_feature, Some(*feature));
+        // Since we always want to collect all `cfg` items, we remove the hidden ones afterward.
+        match cfg_info.current_cfg.strip_hidden(&cfg_info.hidden_cfg) {
+            None | Some(Cfg::True) => None,
+            Some(cfg) => Some(Arc::new(cfg)),
         }
     }
-
-    if cfg == Cfg::True { None } else { Some(Arc::new(cfg)) }
 }
 
 pub(crate) trait NestedAttributesExt {
diff --git a/src/librustdoc/doctest/rust.rs b/src/librustdoc/doctest/rust.rs
index f5ec828187a50..b9367b880057f 100644
--- a/src/librustdoc/doctest/rust.rs
+++ b/src/librustdoc/doctest/rust.rs
@@ -5,7 +5,6 @@ use std::env;
 use std::sync::Arc;
 
 use rustc_ast_pretty::pprust;
-use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::def_id::{CRATE_DEF_ID, LocalDefId};
 use rustc_hir::{self as hir, CRATE_HIR_ID, intravisit};
 use rustc_middle::hir::nested_filter;
@@ -15,7 +14,7 @@ use rustc_span::source_map::SourceMap;
 use rustc_span::{BytePos, DUMMY_SP, FileName, Pos, Span, sym};
 
 use super::{DocTestVisitor, ScrapedDocTest};
-use crate::clean::{Attributes, extract_cfg_from_attrs};
+use crate::clean::{Attributes, CfgInfo, extract_cfg_from_attrs};
 use crate::html::markdown::{self, ErrorCodes, LangString, MdRelLine};
 
 struct RustCollector {
@@ -120,9 +119,11 @@ impl HirCollector<'_> {
         nested: F,
     ) {
         let ast_attrs = self.tcx.hir_attrs(self.tcx.local_def_id_to_hir_id(def_id));
-        if let Some(ref cfg) =
-            extract_cfg_from_attrs(ast_attrs.iter(), self.tcx, &FxHashSet::default())
-            && !cfg.matches(&self.tcx.sess.psess)
+        if let Some(ref cfg) = extract_cfg_from_attrs(
+            ast_attrs.iter(),
+            self.tcx,
+            &mut CfgInfo::default(),
+        ) && !cfg.matches(&self.tcx.sess.psess)
         {
             return;
         }
diff --git a/src/librustdoc/formats/cache.rs b/src/librustdoc/formats/cache.rs
index 29b4c4caaf86d..a19d254ea95f8 100644
--- a/src/librustdoc/formats/cache.rs
+++ b/src/librustdoc/formats/cache.rs
@@ -125,8 +125,6 @@ pub(crate) struct Cache {
     ///
     /// Links are indexed by the DefId of the item they document.
     pub(crate) intra_doc_links: FxHashMap<ItemId, FxIndexSet<clean::ItemLink>>,
-    /// Cfg that have been hidden via #![doc(cfg_hide(...))]
-    pub(crate) hidden_cfg: FxHashSet<clean::cfg::Cfg>,
 
     /// Contains the list of `DefId`s which have been inlined. It is used when generating files
     /// to check if a stripped item should get its file generated or not: if it's inside a
diff --git a/src/librustdoc/passes/propagate_doc_cfg.rs b/src/librustdoc/passes/propagate_doc_cfg.rs
index eddafa9ba8e49..957a1f56c7189 100644
--- a/src/librustdoc/passes/propagate_doc_cfg.rs
+++ b/src/librustdoc/passes/propagate_doc_cfg.rs
@@ -2,11 +2,15 @@
 
 use std::sync::Arc;
 
+use rustc_ast::token::{Token, TokenKind};
+use rustc_ast::tokenstream::{TokenStream, TokenTree};
 use rustc_hir::def_id::LocalDefId;
+use rustc_hir::{AttrArgs, Attribute};
+use rustc_span::symbol::sym;
 
 use crate::clean::cfg::Cfg;
 use crate::clean::inline::{load_attrs, merge_attrs};
-use crate::clean::{Crate, Item, ItemKind};
+use crate::clean::{CfgInfo, Crate, Item, ItemKind};
 use crate::core::DocContext;
 use crate::fold::DocFolder;
 use crate::passes::Pass;
@@ -18,70 +22,119 @@ pub(crate) const PROPAGATE_DOC_CFG: Pass = Pass {
 };
 
 pub(crate) fn propagate_doc_cfg(cr: Crate, cx: &mut DocContext<'_>) -> Crate {
-    CfgPropagator { parent_cfg: None, parent: None, cx }.fold_crate(cr)
+    CfgPropagator { parent_cfg: None, parent: None, cx, cfg_info: CfgInfo::default() }
+        .fold_crate(cr)
 }
 
 struct CfgPropagator<'a, 'tcx> {
     parent_cfg: Option<Arc<Cfg>>,
     parent: Option<LocalDefId>,
     cx: &'a mut DocContext<'tcx>,
+    cfg_info: CfgInfo,
 }
 
-impl CfgPropagator<'_, '_> {
-    // Some items need to merge their attributes with their parents' otherwise a few of them
-    // (mostly `cfg` ones) will be missing.
-    fn merge_with_parent_attributes(&mut self, item: &mut Item) {
-        let check_parent = match &item.kind {
-            // impl blocks can be in different modules with different cfg and we need to get them
-            // as well.
-            ItemKind::ImplItem(_) => false,
-            kind if kind.is_non_assoc() => true,
-            _ => return,
-        };
+fn should_retain(token: &TokenTree) -> bool {
+    // We only keep `doc(cfg)` items.
+    matches!(
+        token,
+        TokenTree::Token(
+            Token {
+                kind: TokenKind::Ident(
+                    ident,
+                    _,
+                ),
+                ..
+            },
+            _,
+        ) if *ident == sym::cfg,
+    )
+}
 
-        let Some(def_id) = item.item_id.as_def_id().and_then(|def_id| def_id.as_local()) else {
-            return;
-        };
+fn filter_tokens_from_list(args_tokens: &TokenStream) -> Vec<TokenTree> {
+    let mut tokens = Vec::with_capacity(args_tokens.len());
+    let mut skip_next_delimited = false;
+    for token in args_tokens.iter() {
+        match token {
+            TokenTree::Delimited(..) => {
+                if !skip_next_delimited {
+                    tokens.push(token.clone());
+                }
+                skip_next_delimited = false;
+            }
+            token if should_retain(token) => {
+                skip_next_delimited = false;
+                tokens.push(token.clone());
+            }
+            _ => {
+                skip_next_delimited = true;
+            }
+        }
+    }
+    tokens
+}
 
-        if check_parent {
-            let expected_parent = self.cx.tcx.opt_local_parent(def_id);
-            // If parents are different, it means that `item` is a reexport and we need
-            // to compute the actual `cfg` by iterating through its "real" parents.
-            if self.parent.is_some() && self.parent == expected_parent {
-                return;
+// We only care about `#[cfg()]` and `#[doc(cfg())]`, we discard everything else.
+fn add_only_cfg_attributes(attrs: &mut Vec<Attribute>, new_attrs: &[Attribute]) {
+    for attr in new_attrs {
+        if attr.is_doc_comment() {
+            continue;
+        }
+        let mut attr = attr.clone();
+        if let Attribute::Unparsed(ref mut normal) = attr
+            && let [ident] = &*normal.path.segments
+        {
+            let ident = ident.name;
+            if ident == sym::doc
+                && let AttrArgs::Delimited(args) = &mut normal.args
+            {
+                let tokens = filter_tokens_from_list(&args.tokens);
+                args.tokens = TokenStream::new(tokens);
+                attrs.push(attr);
+            } else if ident == sym::cfg_trace {
+                // If it's a `cfg()` attribute, we keep it.
+                attrs.push(attr);
             }
         }
+    }
+}
 
+impl CfgPropagator<'_, '_> {
+    // Some items need to merge their attributes with their parents' otherwise a few of them
+    // (mostly `cfg` ones) will be missing.
+    fn merge_with_parent_attributes(&mut self, item: &mut Item) {
         let mut attrs = Vec::new();
-        let mut next_def_id = def_id;
-        while let Some(parent_def_id) = self.cx.tcx.opt_local_parent(next_def_id) {
-            attrs.extend_from_slice(load_attrs(self.cx, parent_def_id.to_def_id()));
-            next_def_id = parent_def_id;
+        // We only need to merge an item attributes with its parent's in case it's an impl as an
+        // impl might not be defined in the same module as the item it implements.
+        //
+        // Otherwise, `cfg_info` already tracks everything we need so nothing else to do!
+        if matches!(item.kind, ItemKind::ImplItem(_))
+            && let Some(def_id) = item.item_id.as_def_id().and_then(|def_id| def_id.as_local())
+        {
+            let mut next_def_id = def_id;
+            while let Some(parent_def_id) = self.cx.tcx.opt_local_parent(next_def_id) {
+                let x = load_attrs(self.cx, parent_def_id.to_def_id());
+                add_only_cfg_attributes(&mut attrs, x);
+                next_def_id = parent_def_id;
+            }
         }
 
-        let (_, cfg) =
-            merge_attrs(self.cx, item.attrs.other_attrs.as_slice(), Some((&attrs, None)));
+        let (_, cfg) = merge_attrs(
+            self.cx,
+            item.attrs.other_attrs.as_slice(),
+            Some((&attrs, None)),
+            &mut self.cfg_info,
+        );
         item.inner.cfg = cfg;
     }
 }
 
 impl DocFolder for CfgPropagator<'_, '_> {
     fn fold_item(&mut self, mut item: Item) -> Option<Item> {
+        let old_cfg_info = self.cfg_info.clone();
         let old_parent_cfg = self.parent_cfg.clone();
 
         self.merge_with_parent_attributes(&mut item);
-
-        let new_cfg = match (self.parent_cfg.take(), item.inner.cfg.take()) {
-            (None, None) => None,
-            (Some(rc), None) | (None, Some(rc)) => Some(rc),
-            (Some(mut a), Some(b)) => {
-                let b = Arc::try_unwrap(b).unwrap_or_else(|rc| Cfg::clone(&rc));
-                *Arc::make_mut(&mut a) &= b;
-                Some(a)
-            }
-        };
-        self.parent_cfg = new_cfg.clone();
-        item.inner.cfg = new_cfg;
+        self.parent_cfg = item.inner.cfg.clone();
 
         let old_parent =
             if let Some(def_id) = item.item_id.as_def_id().and_then(|def_id| def_id.as_local()) {
@@ -90,6 +143,7 @@ impl DocFolder for CfgPropagator<'_, '_> {
                 self.parent.take()
             };
         let result = self.fold_item_recur(item);
+        self.cfg_info = old_cfg_info;
         self.parent_cfg = old_parent_cfg;
         self.parent = old_parent;
 
diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs
index cd28322f5901c..ac67871b0cb73 100644
--- a/src/librustdoc/visit_ast.rs
+++ b/src/librustdoc/visit_ast.rs
@@ -17,7 +17,6 @@ use rustc_span::def_id::{CRATE_DEF_ID, LOCAL_CRATE};
 use rustc_span::symbol::{Symbol, kw, sym};
 use tracing::debug;
 
-use crate::clean::cfg::Cfg;
 use crate::clean::utils::{inherits_doc_hidden, should_ignore_res};
 use crate::clean::{NestedAttributesExt, hir_attr_lists, reexport_chain};
 use crate::core;
@@ -178,32 +177,6 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
             }
         }
 
-        self.cx.cache.hidden_cfg = self
-            .cx
-            .tcx
-            .hir_attrs(CRATE_HIR_ID)
-            .iter()
-            .filter(|attr| attr.has_name(sym::doc))
-            .flat_map(|attr| attr.meta_item_list().into_iter().flatten())
-            .filter(|attr| attr.has_name(sym::cfg_hide))
-            .flat_map(|attr| {
-                attr.meta_item_list()
-                    .unwrap_or(&[])
-                    .iter()
-                    .filter_map(|attr| {
-                        Cfg::parse(attr)
-                            .map_err(|e| self.cx.sess().dcx().span_err(e.span, e.msg))
-                            .ok()
-                    })
-                    .collect::<Vec<_>>()
-            })
-            .chain([
-                Cfg::Cfg(sym::test, None),
-                Cfg::Cfg(sym::doc, None),
-                Cfg::Cfg(sym::doctest, None),
-            ])
-            .collect();
-
         self.cx.cache.exact_paths = self.exact_paths;
         top_level_module
     }

From 6537278e114a98ea6f2c80d7d7ffacb2868be770 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sat, 29 Mar 2025 00:54:22 +0100
Subject: [PATCH 1463/1889] Update rustdoc tests

---
 tests/rustdoc-ui/cfg-hide-show-conflict.rs    |  2 ++
 .../rustdoc-ui/cfg-hide-show-conflict.stderr  | 14 +++++++++
 tests/rustdoc-ui/feature-gate-doc_cfg_hide.rs |  5 ++--
 .../feature-gate-doc_cfg_hide.stderr          | 11 +++----
 tests/rustdoc-ui/invalid-cfg.rs               |  2 +-
 tests/rustdoc-ui/lints/doc_cfg_hide.rs        |  9 ++----
 tests/rustdoc-ui/lints/doc_cfg_hide.stderr    | 29 ++++++-------------
 tests/rustdoc/doc-cfg/doc-cfg-hide.rs         |  8 ++---
 .../rustdoc/doc-cfg/doc-cfg-implicit-gate.rs  |  2 +-
 tests/rustdoc/doc_auto_cfg_reexports.rs       | 21 ++++++++++++++
 10 files changed, 61 insertions(+), 42 deletions(-)
 create mode 100644 tests/rustdoc-ui/cfg-hide-show-conflict.rs
 create mode 100644 tests/rustdoc-ui/cfg-hide-show-conflict.stderr
 create mode 100644 tests/rustdoc/doc_auto_cfg_reexports.rs

diff --git a/tests/rustdoc-ui/cfg-hide-show-conflict.rs b/tests/rustdoc-ui/cfg-hide-show-conflict.rs
new file mode 100644
index 0000000000000..a8a50fe15c7e1
--- /dev/null
+++ b/tests/rustdoc-ui/cfg-hide-show-conflict.rs
@@ -0,0 +1,2 @@
+#![doc(auto_cfg(hide(target_os = "linux")))]
+#![doc(auto_cfg(show(windows, target_os = "linux")))] //~ ERROR
diff --git a/tests/rustdoc-ui/cfg-hide-show-conflict.stderr b/tests/rustdoc-ui/cfg-hide-show-conflict.stderr
new file mode 100644
index 0000000000000..d2d0564606a54
--- /dev/null
+++ b/tests/rustdoc-ui/cfg-hide-show-conflict.stderr
@@ -0,0 +1,14 @@
+error: same `cfg` was in `auto_cfg(hide(...))` and `auto_cfg(show(...))` on the same item
+  --> $DIR/cfg-hide-show-conflict.rs:2:31
+   |
+LL | #![doc(auto_cfg(show(windows, target_os = "linux")))]
+   |                               ^^^^^^^^^^^^^^^^^^^
+   |
+note: first change was here
+  --> $DIR/cfg-hide-show-conflict.rs:1:22
+   |
+LL | #![doc(auto_cfg(hide(target_os = "linux")))]
+   |                      ^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/rustdoc-ui/feature-gate-doc_cfg_hide.rs b/tests/rustdoc-ui/feature-gate-doc_cfg_hide.rs
index 17812018b9b7a..e49285a01b812 100644
--- a/tests/rustdoc-ui/feature-gate-doc_cfg_hide.rs
+++ b/tests/rustdoc-ui/feature-gate-doc_cfg_hide.rs
@@ -1,5 +1,6 @@
-#![doc(cfg_hide(test))]
-//~^ ERROR `#[doc(cfg_hide)]` is experimental
+// FIXME: Remove this file once feature is removed
+
+#![doc(cfg_hide(test))] //~ ERROR
 
 #[cfg(not(test))]
 pub fn public_fn() {}
diff --git a/tests/rustdoc-ui/feature-gate-doc_cfg_hide.stderr b/tests/rustdoc-ui/feature-gate-doc_cfg_hide.stderr
index 55135986ffe76..b3eee2af7f733 100644
--- a/tests/rustdoc-ui/feature-gate-doc_cfg_hide.stderr
+++ b/tests/rustdoc-ui/feature-gate-doc_cfg_hide.stderr
@@ -1,13 +1,10 @@
-error[E0658]: `#[doc(cfg_hide)]` is experimental
-  --> $DIR/feature-gate-doc_cfg_hide.rs:1:1
+error: unknown `doc` attribute `cfg_hide`
+  --> $DIR/feature-gate-doc_cfg_hide.rs:3:8
    |
 LL | #![doc(cfg_hide(test))]
-   | ^^^^^^^^^^^^^^^^^^^^^^^
+   |        ^^^^^^^^^^^^^^
    |
-   = note: see issue #43781 <https://github.com/rust-lang/rust/issues/43781> for more information
-   = help: add `#![feature(doc_cfg_hide)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+   = note: `#[deny(invalid_doc_attributes)]` on by default
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/rustdoc-ui/invalid-cfg.rs b/tests/rustdoc-ui/invalid-cfg.rs
index d237b8605c068..aff36286c535c 100644
--- a/tests/rustdoc-ui/invalid-cfg.rs
+++ b/tests/rustdoc-ui/invalid-cfg.rs
@@ -1,4 +1,4 @@
 #![feature(doc_cfg)]
 #[doc(cfg = "x")] //~ ERROR not followed by parentheses
 #[doc(cfg(x, y))] //~ ERROR multiple `cfg` predicates
-struct S {}
+pub struct S {}
diff --git a/tests/rustdoc-ui/lints/doc_cfg_hide.rs b/tests/rustdoc-ui/lints/doc_cfg_hide.rs
index 9a8bce2a92aa5..abf5631847906 100644
--- a/tests/rustdoc-ui/lints/doc_cfg_hide.rs
+++ b/tests/rustdoc-ui/lints/doc_cfg_hide.rs
@@ -1,7 +1,2 @@
-#![feature(doc_cfg_hide)]
-
-#![doc(cfg_hide = "test")] //~ ERROR
-#![doc(cfg_hide)] //~ ERROR
-
-#[doc(cfg_hide(doc))] //~ ERROR
-pub fn foo() {}
+#![doc(auto_cfg(hide = "test"))] //~ ERROR
+#![doc(auto_cfg(hide))] //~ ERROR
diff --git a/tests/rustdoc-ui/lints/doc_cfg_hide.stderr b/tests/rustdoc-ui/lints/doc_cfg_hide.stderr
index 0c9d0879b0ac7..bb0e52eb666ad 100644
--- a/tests/rustdoc-ui/lints/doc_cfg_hide.stderr
+++ b/tests/rustdoc-ui/lints/doc_cfg_hide.stderr
@@ -1,27 +1,16 @@
-error: this attribute can only be applied at the crate level
-  --> $DIR/doc_cfg_hide.rs:6:7
+error: `#![doc(auto_cfg(hide(...)))]` only expects a list of items
+  --> $DIR/doc_cfg_hide.rs:1:8
    |
-LL | #[doc(cfg_hide(doc))]
-   |       ^^^^^^^^^^^^^
+LL | #![doc(auto_cfg(hide = "test"))]
+   |        ^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: read <https://doc.rust-lang.org/nightly/rustdoc/the-doc-attribute.html#at-the-crate-level> for more information
    = note: `#[deny(invalid_doc_attributes)]` on by default
-help: to apply to the crate, use an inner attribute
-   |
-LL | #![doc(cfg_hide(doc))]
-   |  +
-
-error: `#[doc(cfg_hide(...))]` takes a list of attributes
-  --> $DIR/doc_cfg_hide.rs:3:8
-   |
-LL | #![doc(cfg_hide = "test")]
-   |        ^^^^^^^^^^^^^^^^^
 
-error: `#[doc(cfg_hide(...))]` takes a list of attributes
-  --> $DIR/doc_cfg_hide.rs:4:8
+error: `#![doc(auto_cfg(hide(...)))]` only expects a list of items
+  --> $DIR/doc_cfg_hide.rs:2:8
    |
-LL | #![doc(cfg_hide)]
-   |        ^^^^^^^^
+LL | #![doc(auto_cfg(hide))]
+   |        ^^^^^^^^^^^^^^
 
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
 
diff --git a/tests/rustdoc/doc-cfg/doc-cfg-hide.rs b/tests/rustdoc/doc-cfg/doc-cfg-hide.rs
index ceb1f99fae0d1..cf906ede7e13f 100644
--- a/tests/rustdoc/doc-cfg/doc-cfg-hide.rs
+++ b/tests/rustdoc/doc-cfg/doc-cfg-hide.rs
@@ -1,7 +1,7 @@
 #![crate_name = "oud"]
-#![feature(doc_auto_cfg, doc_cfg, doc_cfg_hide)]
+#![feature(doc_auto_cfg, doc_cfg, doc_cfg_hide, no_core)]
 
-#![doc(cfg_hide(feature = "solecism"))]
+#![doc(auto_cfg(hide(feature = "solecism")))]
 
 //@ has 'oud/struct.Solecism.html'
 //@ count   - '//*[@class="stab portability"]' 0
@@ -18,7 +18,7 @@ pub struct Scribacious;
 
 //@ has 'oud/struct.Hyperdulia.html'
 //@ count   - '//*[@class="stab portability"]' 1
-//@ matches - '//*[@class="stab portability"]' 'crate feature hyperdulia'
+//@ matches - '//*[@class="stab portability"]' 'crate features hyperdulia only'
 //@ compile-flags:--cfg feature="hyperdulia"
 #[cfg(feature = "solecism")]
 #[cfg(feature = "hyperdulia")]
@@ -26,7 +26,7 @@ pub struct Hyperdulia;
 
 //@ has 'oud/struct.Oystercatcher.html'
 //@ count   - '//*[@class="stab portability"]' 1
-//@ matches - '//*[@class="stab portability"]' 'crate feature oystercatcher only'
+//@ matches - '//*[@class="stab portability"]' 'crate features oystercatcher only'
 //@ compile-flags:--cfg feature="oystercatcher"
 #[cfg(all(feature = "solecism", feature = "oystercatcher"))]
 pub struct Oystercatcher;
diff --git a/tests/rustdoc/doc-cfg/doc-cfg-implicit-gate.rs b/tests/rustdoc/doc-cfg/doc-cfg-implicit-gate.rs
index b5b8d0f427bf7..27923893bddae 100644
--- a/tests/rustdoc/doc-cfg/doc-cfg-implicit-gate.rs
+++ b/tests/rustdoc/doc-cfg/doc-cfg-implicit-gate.rs
@@ -2,6 +2,6 @@
 #![crate_name = "xenogenous"]
 
 //@ has 'xenogenous/struct.Worricow.html'
-//@ count   - '//*[@class="stab portability"]' 0
+//@ count   - '//*[@class="stab portability"]' 1
 #[cfg(feature = "worricow")]
 pub struct Worricow;
diff --git a/tests/rustdoc/doc_auto_cfg_reexports.rs b/tests/rustdoc/doc_auto_cfg_reexports.rs
new file mode 100644
index 0000000000000..f226c52e2ebf9
--- /dev/null
+++ b/tests/rustdoc/doc_auto_cfg_reexports.rs
@@ -0,0 +1,21 @@
+// Checks that `cfg` are correctly applied on inlined reexports.
+
+#![crate_name = "foo"]
+
+// Check with `std` item.
+//@ has 'foo/index.html' '//*[@class="stab portability"]' 'Non-moustache'
+//@ has 'foo/struct.C.html' '//*[@class="stab portability"]' \
+//      'Available on non-crate feature moustache only.'
+#[cfg(not(feature = "moustache"))]
+pub use std::cell::RefCell as C;
+
+// Check with local item.
+mod x {
+    pub struct B;
+}
+
+//@ has 'foo/index.html' '//*[@class="stab portability"]' 'Non-pistache'
+//@ has 'foo/struct.B.html' '//*[@class="stab portability"]' \
+//      'Available on non-crate feature pistache only.'
+#[cfg(not(feature = "pistache"))]
+pub use crate::x::B;

From 2d82c99f1e4a4e50b47f75d767b0d1d957357c1a Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 1 Apr 2025 17:01:00 +0200
Subject: [PATCH 1464/1889] Add "global" rustdoc test for RFC 3631

---
 tests/rustdoc/doc_auto_cfg.rs | 80 +++++++++++++++++++++++++++++++++++
 1 file changed, 80 insertions(+)
 create mode 100644 tests/rustdoc/doc_auto_cfg.rs

diff --git a/tests/rustdoc/doc_auto_cfg.rs b/tests/rustdoc/doc_auto_cfg.rs
new file mode 100644
index 0000000000000..cb7c0e3f5950c
--- /dev/null
+++ b/tests/rustdoc/doc_auto_cfg.rs
@@ -0,0 +1,80 @@
+// Test covering RFC 3631 features.
+
+#![crate_name = "foo"]
+#![feature(no_core)]
+#![no_core]
+#![no_std]
+
+#![doc(auto_cfg(hide(feature = "hidden")))]
+
+//@ has 'foo/index.html'
+//@ !has - '//*[@class="stab portability"]' 'Non-moustache'
+//@ has - '//*[@class="stab portability"]' 'Non-pistache'
+//@ count - '//*[@class="stab portability"]' 1
+
+//@ has 'foo/m/index.html'
+//@ count - '//*[@title="Available on non-crate feature `hidden` only"]' 2
+#[cfg(not(feature = "hidden"))]
+pub mod m {
+    //@ count 'foo/m/struct.A.html' '//*[@class="stab portability"]' 0
+    pub struct A;
+
+    //@ has 'foo/m/inner/index.html' '//*[@class="stab portability"]' 'Available on non-crate feature hidden only.'
+    #[doc(auto_cfg(show(feature = "hidden")))]
+    pub mod inner {
+        //@ has 'foo/m/inner/struct.B.html' '//*[@class="stab portability"]' 'Available on non-crate feature hidden only.'
+        pub struct B;
+
+        //@ count 'foo/m/inner/struct.A.html' '//*[@class="stab portability"]' 0
+        #[doc(auto_cfg(hide(feature = "hidden")))]
+        pub struct A;
+    }
+
+    //@ has 'foo/m/struct.B.html' '//*[@class="stab portability"]' 'Available on non-crate feature hidden only.'
+    #[doc(auto_cfg(show(feature = "hidden")))]
+    pub struct B;
+}
+
+//@ count 'foo/n/index.html' '//*[@title="Available on non-crate feature `moustache` only"]' 3
+//@ count - '//dl/dt' 4
+#[cfg(not(feature = "moustache"))]
+#[doc(auto_cfg = false)]
+pub mod n {
+    // Should not have `moustache` listed.
+    //@ count 'foo/n/struct.X.html' '//*[@class="stab portability"]' 0
+    pub struct X;
+
+    // Should re-enable `auto_cfg` and make `moustache` listed.
+    //@ has 'foo/n/struct.Y.html' '//*[@class="stab portability"]' \
+    //  'Available on non-crate feature moustache only.'
+    #[doc(auto_cfg)]
+    pub struct Y;
+
+    // Should re-enable `auto_cfg` and make `moustache` listed for itself
+    // and for `Y`.
+    //@ has 'foo/n/inner/index.html' '//*[@class="stab portability"]' \
+    //  'Available on non-crate feature moustache only.'
+    #[doc(auto_cfg = true)]
+    pub mod inner {
+        //@ has 'foo/n/inner/struct.Y.html' '//*[@class="stab portability"]' \
+        //  'Available on non-crate feature moustache only.'
+        pub struct Y;
+    }
+
+    // Should re-enable `auto_cfg` and make `moustache` listed.
+    //@ has 'foo/n/struct.Z.html' '//*[@class="stab portability"]' \
+    //  'Available on non-crate feature moustache only.'
+    #[doc(auto_cfg(hide(feature = "hidden")))]
+    pub struct Z;
+}
+
+// Checking inheritance.
+//@ has 'foo/o/index.html' '//*[@class="stab portability"]' \
+//  'Available on non-crate feature pistache only.'
+#[doc(cfg(not(feature = "pistache")))]
+pub mod o {
+    //@ has 'foo/o/struct.A.html' '//*[@class="stab portability"]' \
+    //  'Available on non-crate feature pistache and non-crate feature tarte only.'
+    #[doc(cfg(not(feature = "tarte")))]
+    pub struct A;
+}

From 63aefe0737d0df886955f5a3aa68db865cd97f1b Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 1 Apr 2025 17:24:28 +0200
Subject: [PATCH 1465/1889] Strenghten checks for `doc(auto_cfg(show/hide))`
 attributes

---
 compiler/rustc_passes/messages.ftl         |  3 +++
 compiler/rustc_passes/src/check_attr.rs    | 15 ++++++++++++++-
 compiler/rustc_passes/src/errors.rs        |  6 ++++++
 library/alloc/src/lib.rs                   |  1 -
 library/std/src/lib.rs                     |  8 +-------
 tests/rustdoc-ui/lints/doc_cfg_hide.rs     |  1 +
 tests/rustdoc-ui/lints/doc_cfg_hide.stderr |  8 +++++++-
 7 files changed, 32 insertions(+), 10 deletions(-)

diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index 19014f37c6628..8326ddaf194d7 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -149,6 +149,9 @@ passes_doc_auto_cfg_expects_hide_or_show =
 passes_doc_auto_cfg_hide_show_expects_list =
     `#![doc(auto_cfg({$attr_name}(...)))]` only expects a list of items
 
+passes_doc_auto_cfg_hide_show_unexpected_item =
+    `#![doc(auto_cfg({$attr_name}(...)))]` only accepts identifiers or key/values items
+
 passes_doc_auto_cfg_wrong_literal =
     `expected boolean for #[doc(auto_cfg = ...)]`
 
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 3dc232a35ec3a..38b67e2f9dc5f 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -1187,7 +1187,20 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                             meta.span,
                             errors::DocAutoCfgExpectsHideOrShow,
                         );
-                    } else if item.meta_item_list().is_none() {
+                    } else if let Some(list) = item.meta_item_list() {
+                        for item in list {
+                            if item.meta_item_list().is_some() {
+                                self.tcx.emit_node_span_lint(
+                                    INVALID_DOC_ATTRIBUTES,
+                                    hir_id,
+                                    item.span(),
+                                    errors::DocAutoCfgHideShowUnexpectedItem {
+                                        attr_name: attr_name.as_str(),
+                                    },
+                                );
+                            }
+                        }
+                    } else {
                         self.tcx.emit_node_span_lint(
                             INVALID_DOC_ATTRIBUTES,
                             hir_id,
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index 6cc0bd6ce48bd..1d2428c4f9a05 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -322,6 +322,12 @@ pub(crate) struct DocAutoCfgHideShowExpectsList<'a> {
     pub attr_name: &'a str,
 }
 
+#[derive(LintDiagnostic)]
+#[diag(passes_doc_auto_cfg_hide_show_unexpected_item)]
+pub(crate) struct DocAutoCfgHideShowUnexpectedItem<'a> {
+    pub attr_name: &'a str,
+}
+
 #[derive(LintDiagnostic)]
 #[diag(passes_doc_test_unknown_any)]
 pub(crate) struct DocTestUnknownAny {
diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs
index 243fdc2e8436f..dc5d243e8823a 100644
--- a/library/alloc/src/lib.rs
+++ b/library/alloc/src/lib.rs
@@ -78,7 +78,6 @@
 #![cfg_attr(
     not(bootstrap),
     doc(auto_cfg(hide(
-        test,
         no_global_oom_handling,
         no_rc,
         no_sync,
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index 93c91b615258d..ecd354f599e4c 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -243,13 +243,7 @@
         not(no_global_oom_handling)
     ))
 )]
-#![cfg_attr(
-    not(bootstrap),
-    doc(auto_cfg(hide(
-        test,
-        no_global_oom_handling,
-    )))
-)]
+#![cfg_attr(not(bootstrap), doc(auto_cfg(hide(no_global_oom_handling))))]
 // Don't link to std. We are std.
 #![no_std]
 // Tell the compiler to link to either panic_abort or panic_unwind
diff --git a/tests/rustdoc-ui/lints/doc_cfg_hide.rs b/tests/rustdoc-ui/lints/doc_cfg_hide.rs
index abf5631847906..4f2625d00ce43 100644
--- a/tests/rustdoc-ui/lints/doc_cfg_hide.rs
+++ b/tests/rustdoc-ui/lints/doc_cfg_hide.rs
@@ -1,2 +1,3 @@
 #![doc(auto_cfg(hide = "test"))] //~ ERROR
 #![doc(auto_cfg(hide))] //~ ERROR
+#![doc(auto_cfg(hide(not(windows))))] //~ ERROR
diff --git a/tests/rustdoc-ui/lints/doc_cfg_hide.stderr b/tests/rustdoc-ui/lints/doc_cfg_hide.stderr
index bb0e52eb666ad..22501d63c3fb9 100644
--- a/tests/rustdoc-ui/lints/doc_cfg_hide.stderr
+++ b/tests/rustdoc-ui/lints/doc_cfg_hide.stderr
@@ -12,5 +12,11 @@ error: `#![doc(auto_cfg(hide(...)))]` only expects a list of items
 LL | #![doc(auto_cfg(hide))]
    |        ^^^^^^^^^^^^^^
 
-error: aborting due to 2 previous errors
+error: `#![doc(auto_cfg(hide(...)))]` only accepts identifiers or key/values items
+  --> $DIR/doc_cfg_hide.rs:3:22
+   |
+LL | #![doc(auto_cfg(hide(not(windows))))]
+   |                      ^^^^^^^^^^^^
+
+error: aborting due to 3 previous errors
 

From 4847eaf6d25473ad1b8dab4d8d6cd62520f55e0e Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 1 Apr 2025 17:49:08 +0200
Subject: [PATCH 1466/1889] Remove useless code in `propagate_doc_cfg.rs`

---
 src/librustdoc/passes/propagate_doc_cfg.rs | 19 +------------------
 1 file changed, 1 insertion(+), 18 deletions(-)

diff --git a/src/librustdoc/passes/propagate_doc_cfg.rs b/src/librustdoc/passes/propagate_doc_cfg.rs
index 957a1f56c7189..1425687cd2698 100644
--- a/src/librustdoc/passes/propagate_doc_cfg.rs
+++ b/src/librustdoc/passes/propagate_doc_cfg.rs
@@ -1,14 +1,10 @@
 //! Propagates [`#[doc(cfg(...))]`](https://github.com/rust-lang/rust/issues/43781) to child items.
 
-use std::sync::Arc;
-
 use rustc_ast::token::{Token, TokenKind};
 use rustc_ast::tokenstream::{TokenStream, TokenTree};
-use rustc_hir::def_id::LocalDefId;
 use rustc_hir::{AttrArgs, Attribute};
 use rustc_span::symbol::sym;
 
-use crate::clean::cfg::Cfg;
 use crate::clean::inline::{load_attrs, merge_attrs};
 use crate::clean::{CfgInfo, Crate, Item, ItemKind};
 use crate::core::DocContext;
@@ -22,13 +18,10 @@ pub(crate) const PROPAGATE_DOC_CFG: Pass = Pass {
 };
 
 pub(crate) fn propagate_doc_cfg(cr: Crate, cx: &mut DocContext<'_>) -> Crate {
-    CfgPropagator { parent_cfg: None, parent: None, cx, cfg_info: CfgInfo::default() }
-        .fold_crate(cr)
+    CfgPropagator { cx, cfg_info: CfgInfo::default() }.fold_crate(cr)
 }
 
 struct CfgPropagator<'a, 'tcx> {
-    parent_cfg: Option<Arc<Cfg>>,
-    parent: Option<LocalDefId>,
     cx: &'a mut DocContext<'tcx>,
     cfg_info: CfgInfo,
 }
@@ -131,21 +124,11 @@ impl CfgPropagator<'_, '_> {
 impl DocFolder for CfgPropagator<'_, '_> {
     fn fold_item(&mut self, mut item: Item) -> Option<Item> {
         let old_cfg_info = self.cfg_info.clone();
-        let old_parent_cfg = self.parent_cfg.clone();
 
         self.merge_with_parent_attributes(&mut item);
-        self.parent_cfg = item.inner.cfg.clone();
 
-        let old_parent =
-            if let Some(def_id) = item.item_id.as_def_id().and_then(|def_id| def_id.as_local()) {
-                self.parent.replace(def_id)
-            } else {
-                self.parent.take()
-            };
         let result = self.fold_item_recur(item);
         self.cfg_info = old_cfg_info;
-        self.parent_cfg = old_parent_cfg;
-        self.parent = old_parent;
 
         Some(result)
     }

From 18df897221c57941956f77ef1f92261cf983577d Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 7 Apr 2025 16:18:27 +0200
Subject: [PATCH 1467/1889] Remove ui test for doc_cfg feature gate

---
 tests/ui/feature-gates/feature-gate-doc_cfg.rs     |  6 +++++-
 tests/ui/feature-gates/feature-gate-doc_cfg.stderr | 13 -------------
 2 files changed, 5 insertions(+), 14 deletions(-)
 delete mode 100644 tests/ui/feature-gates/feature-gate-doc_cfg.stderr

diff --git a/tests/ui/feature-gates/feature-gate-doc_cfg.rs b/tests/ui/feature-gates/feature-gate-doc_cfg.rs
index b12b8a1057182..83053e8c8bfd6 100644
--- a/tests/ui/feature-gates/feature-gate-doc_cfg.rs
+++ b/tests/ui/feature-gates/feature-gate-doc_cfg.rs
@@ -1,2 +1,6 @@
-#[doc(cfg(unix))] //~ ERROR: `#[doc(cfg)]` is experimental
+//@ build-pass
+
+// FIXME: Remove this test once `doc_cfg` feature is completely removed.
+
+#[doc(cfg(unix))]
 fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-doc_cfg.stderr b/tests/ui/feature-gates/feature-gate-doc_cfg.stderr
deleted file mode 100644
index 5315aaeeb3edb..0000000000000
--- a/tests/ui/feature-gates/feature-gate-doc_cfg.stderr
+++ /dev/null
@@ -1,13 +0,0 @@
-error[E0658]: `#[doc(cfg)]` is experimental
-  --> $DIR/feature-gate-doc_cfg.rs:1:1
-   |
-LL | #[doc(cfg(unix))]
-   | ^^^^^^^^^^^^^^^^^
-   |
-   = note: see issue #43781 <https://github.com/rust-lang/rust/issues/43781> for more information
-   = help: add `#![feature(doc_cfg)]` to the crate attributes to enable
-   = 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`.

From d6ba93a3fee59a08820ee09ab7b3096ccfe99219 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 7 Apr 2025 17:07:21 +0200
Subject: [PATCH 1468/1889] Remove `doc_cfg` related content from rustdoc book
 unstable features chapter

---
 src/doc/rustdoc/src/unstable-features.md | 82 ------------------------
 1 file changed, 82 deletions(-)

diff --git a/src/doc/rustdoc/src/unstable-features.md b/src/doc/rustdoc/src/unstable-features.md
index 4327a80cd0832..a8856c2ecc776 100644
--- a/src/doc/rustdoc/src/unstable-features.md
+++ b/src/doc/rustdoc/src/unstable-features.md
@@ -56,88 +56,6 @@ It is also not emitted for foreign items, aliases, extern crates and imports.
 These features operate by extending the `#[doc]` attribute, and thus can be caught by the compiler
 and enabled with a `#![feature(...)]` attribute in your crate.
 
-### `#[doc(cfg)]`: Recording what platforms or features are required for code to be present
-
- * Tracking issue: [#43781](https://github.com/rust-lang/rust/issues/43781)
-
-You can use `#[doc(cfg(...))]` to tell Rustdoc exactly which platform items appear on.
-This has two effects:
-
-1. doctests will only run on the appropriate platforms, and
-2. When Rustdoc renders documentation for that item, it will be accompanied by a banner explaining
-   that the item is only available on certain platforms.
-
-`#[doc(cfg)]` is intended to be used alongside [`#[cfg(doc)]`][cfg-doc].
-For example, `#[cfg(any(windows, doc))]` will preserve the item either on Windows or during the
-documentation process. Then, adding a new attribute `#[doc(cfg(windows))]` will tell Rustdoc that
-the item is supposed to be used on Windows. For example:
-
-```rust
-#![feature(doc_cfg)]
-
-/// Token struct that can only be used on Windows.
-#[cfg(any(windows, doc))]
-#[doc(cfg(windows))]
-pub struct WindowsToken;
-
-/// Token struct that can only be used on Unix.
-#[cfg(any(unix, doc))]
-#[doc(cfg(unix))]
-pub struct UnixToken;
-
-/// Token struct that is only available with the `serde` feature
-#[cfg(feature = "serde")]
-#[doc(cfg(feature = "serde"))]
-#[derive(serde::Deserialize)]
-pub struct SerdeToken;
-```
-
-In this sample, the tokens will only appear on their respective platforms, but they will both appear
-in documentation.
-
-`#[doc(cfg(...))]` was introduced to be used by the standard library and currently requires the
-`#![feature(doc_cfg)]` feature gate. For more information, see [its chapter in the Unstable
-Book][unstable-doc-cfg] and [its tracking issue][issue-doc-cfg].
-
-### `doc_auto_cfg`: Automatically generate `#[doc(cfg)]`
-
- * Tracking issue: [#43781](https://github.com/rust-lang/rust/issues/43781)
-
-`doc_auto_cfg` is an extension to the `#[doc(cfg)]` feature. With it, you don't need to add
-`#[doc(cfg(...)]` anymore unless you want to override the default behaviour. So if we take the
-previous source code:
-
-```rust
-#![feature(doc_auto_cfg)]
-
-/// Token struct that can only be used on Windows.
-#[cfg(any(windows, doc))]
-pub struct WindowsToken;
-
-/// Token struct that can only be used on Unix.
-#[cfg(any(unix, doc))]
-pub struct UnixToken;
-
-/// Token struct that is only available with the `serde` feature
-#[cfg(feature = "serde")]
-#[derive(serde::Deserialize)]
-pub struct SerdeToken;
-```
-
-It'll render almost the same, the difference being that `doc` will also be displayed. To fix this,
-you can use `doc_cfg_hide`:
-
-```rust
-#![feature(doc_cfg_hide)]
-#![doc(cfg_hide(doc))]
-```
-
-And `doc` won't show up anymore!
-
-[cfg-doc]: ./advanced-features.md
-[unstable-doc-cfg]: ../unstable-book/language-features/doc-cfg.html
-[issue-doc-cfg]: https://github.com/rust-lang/rust/issues/43781
-
 ### Adding your trait to the "Notable traits" dialog
 
  * Tracking issue: [#45040](https://github.com/rust-lang/rust/issues/45040)

From bb34332858fa6c675cbbaf421ad3986df22d86ef Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 11 Apr 2025 11:53:49 +0200
Subject: [PATCH 1469/1889] Update book for `doc_cfg` feature

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

diff --git a/src/doc/rustdoc/src/unstable-features.md b/src/doc/rustdoc/src/unstable-features.md
index a8856c2ecc776..cfa1936f3d7fc 100644
--- a/src/doc/rustdoc/src/unstable-features.md
+++ b/src/doc/rustdoc/src/unstable-features.md
@@ -719,3 +719,271 @@ pass `--doctest-build-arg ARG` for each argument `ARG`.
 ## `--generate-macro-expansion`: Generate macros expansion toggles in source code
 
 This flag enables the generation of toggles to expand macros in the HTML source code pages.
+
+## `#[doc(cfg)]`
+
+This feature aims at providing rustdoc users the possibility to add visual markers to the rendered documentation to know under which conditions an item is available (currently possible through the following unstable features: `doc_cfg`, `doc_auto_cfg` and `doc_cfg_hide`).
+
+It does not aim to allow having a same item with different `cfg`s to appear more than once in the generated documentation.
+
+It does not aim to document items which are *inactive* under the current configuration (i.e., “`cfg`ed out”).
+
+This features adds the following attributes:
+
+ * `#[doc(auto_cfg)]`/`#[doc(auto_cfg = true)]`/`#[doc(auto_cfg = false)]`
+ * `#[doc(cfg(...))]`
+ * `#![doc(auto_cfg(hide(...)))]` / `#[doc(auto_cfg(show(...)))]`
+
+All of these attributes can be added to a module or to the crate root, and they will be inherited by the child items unless another attribute overrides it. This is why "opposite" attributes like `auto_cfg(hide(...))` and `auto_cfg(show(...))` are provided: they allow a child item to override its parent.
+
+### `#[doc(auto_cfg)`/`#[doc(auto_cfg = true)]`/`#[doc(auto_cfg = false)]`
+
+By default, `#[doc(auto_cfg)]` is enabled at the crate-level. When it's enabled, Rustdoc will automatically display `cfg(...)` compatibility information as-if the same `#[doc(cfg(...))]` had been specified.
+
+This attribute impacts the item on which it is used and its descendants.
+
+So if we take back the previous example:
+
+```rust
+#[cfg(feature = "futures-io")]
+pub mod futures {}
+```
+
+There's no need to "duplicate" the `cfg` into a `doc(cfg())` to make Rustdoc display it.
+
+In some situations, the detailed conditional compilation rules used to implement the feature might not serve as good documentation (for example, the list of supported platforms might be very long, and it might be better to document them in one place). To turn it off, add the `#[doc(auto_cfg = false)]` attribute on the item.
+
+If no argument is specified (ie `#[doc(auto_cfg)]`), it's the same as writing `#[doc(auto_cfg = true)]`.
+
+### `#[doc(cfg(...))]`
+
+This attribute provides a standardized format to override `#[cfg()]` attributes to document conditionally available items. Example:
+
+```rust,ignore (nightly)
+// the "real" cfg condition
+#[cfg(feature = "futures-io")]
+// the `doc(cfg())` so it's displayed to the readers
+#[doc(cfg(feature = "futures-io"))]
+pub mod futures {}
+```
+
+It will display in the documentation for this module:
+
+```text
+This is supported on feature="futures-io" only.
+```
+
+You can use it to display information in generated documentation, whether or not there is a `#[cfg()]` attribute:
+
+```rust,ignore (nightly)
+#[doc(cfg(feature = "futures-io"))]
+pub mod futures {}
+```
+
+It will be displayed exactly the same as the previous code.
+
+This attribute has the same syntax as conditional compilation, but it only causes documentation to be added. This means `#[doc(cfg(not(windows)))]` will not cause your docs to be hidden on non-windows targets, even though `#[cfg(not(windows))]` does do that.
+
+If `doc(auto_cfg)` is enabled on the item, `doc(cfg)` will override it anyway so in the two previous examples, even if the `doc(auto_cfg)` feature was enabled, it would still display the same thing.
+
+This attribute works on modules and on items.
+
+### `#[doc(auto_cfg(hide(...)))]`
+
+This attribute is used to prevent some `cfg` to be generated in the visual markers. It only applies to `#[doc(auto_cfg = true)]`, not to `#[doc(cfg(...))]`. So in the previous example:
+
+```rust,ignore (nightly)
+#[cfg(any(unix, feature = "futures-io"))]
+pub mod futures {}
+```
+
+It currently displays both `unix` and `feature = "futures-io"` into the documentation, which is not great. To prevent the `unix` cfg to ever be displayed, you can use this attribute at the crate root level:
+
+```rust,ignore (nightly)
+#![doc(auto_cfg(hide(unix)))]
+```
+
+Or directly on a given item/module as it covers any of the item's descendants:
+
+```rust,ignore (nightly)
+#[doc(auto_cfg(hide(unix)))]
+#[cfg(any(unix, feature = "futures-io"))]
+pub mod futures {
+    // `futures` and all its descendants won't display "unix" in their cfgs.
+}
+```
+
+Then, the `unix` cfg will never be displayed into the documentation.
+
+Rustdoc currently hides `doc` and `doctest` attributes by default and reserves the right to change the list of "hidden by default" attributes.
+
+The attribute accepts only a list of identifiers or key/value items. So you can write:
+
+```rust,ignore (nightly)
+#[doc(auto_cfg(hide(unix, doctest, feature = "something")))]
+#[doc(auto_cfg(hide()))]
+```
+
+But you cannot write:
+
+```rust,ignore (nightly)
+#[doc(auto_cfg(hide(not(unix))))]
+```
+
+So if we use `doc(auto_cfg(hide(unix)))`, it means it will hide all mentions of `unix`:
+
+```rust,ignore (nightly)
+#[cfg(unix)] // nothing displayed
+#[cfg(any(unix))] // nothing displayed
+#[cfg(any(unix, windows))] // only `windows` displayed
+```
+
+However, it only impacts the `unix` cfg, not the feature:
+
+```rust,ignore (nightly)
+#[cfg(feature = "unix")] // `feature = "unix"` is displayed
+```
+
+If `cfg_auto(show(...))` and `cfg_auto(hide(...))` are used to show/hide a same `cfg` on a same item, it'll emit an error. Example:
+
+```rust,ignore (nightly)
+#[doc(auto_cfg(hide(unix)))]
+#[doc(auto_cfg(show(unix)))] // Error!
+pub fn foo() {}
+```
+
+Using this attribute will re-enable `auto_cfg` if it was disabled at this location:
+
+```rust,ignore (nightly)
+#[doc(auto_cfg = false)] // Disabling `auto_cfg`
+pub fn foo() {}
+```
+
+And using `doc(auto_cfg)` will re-enable it:
+
+```rust,ignore (nightly)
+#[doc(auto_cfg = false)] // Disabling `auto_cfg`
+pub mod module {
+    #[doc(auto_cfg(hide(unix)))] // `auto_cfg` is re-enabled.
+    pub fn foo() {}
+}
+```
+
+However, using `doc(auto_cfg = ...)` and `doc(auto_cfg(...))` on the same item will emit an error:
+
+```rust,ignore (nightly)
+#[doc(auto_cfg = false)]
+#[doc(auto_cfg(hide(unix)))] // error
+pub fn foo() {}
+```
+
+The reason behind this is that `doc(auto_cfg = ...)` enables or disables the feature, whereas `doc(auto_cfg(...))` enables it unconditionally, making the first attribute to appear useless as it will be overidden by the next `doc(auto_cfg)` attribute.
+
+### `#[doc(auto_cfg(show(...)))]`
+
+This attribute does the opposite of `#[doc(auto_cfg(hide(...)))]`: if you used `#[doc(auto_cfg(hide(...)))]` and want to revert its effect on an item and its descendants, you can use `#[doc(auto_cfg(show(...)))]`.
+It only applies to `#[doc(auto_cfg = true)]`, not to `#[doc(cfg(...))]`.
+
+For example:
+
+```rust,ignore (nightly)
+#[doc(auto_cfg(hide(unix)))]
+#[cfg(any(unix, feature = "futures-io"))]
+pub mod futures {
+    // `futures` and all its descendants won't display "unix" in their cfgs.
+    #[doc(auto_cfg(show(unix)))]
+    pub mod child {
+        // `child` and all its descendants will display "unix" in their cfgs.
+    }
+}
+```
+
+The attribute accepts only a list of identifiers or key/value items. So you can write:
+
+```rust,ignore (nightly)
+#[doc(auto_cfg(show(unix, doctest, feature = "something")))]
+#[doc(auto_cfg(show()))]
+```
+
+But you cannot write:
+
+```rust,ignore (nightly)
+#[doc(auto_cfg(show(not(unix))))]
+```
+
+If `auto_cfg(show(...))` and `auto_cfg(hide(...))` are used to show/hide a same `cfg` on a same item, it'll emit an error. Example:
+
+```rust,ignore (nightly)
+#[doc(auto_cfg(show(unix)))]
+#[doc(auto_cfg(hide(unix)))] // Error!
+pub fn foo() {}
+```
+
+Using this attribute will re-enable `auto_cfg` if it was disabled at this location:
+
+```rust,ignore (nightly)
+#[doc(auto_cfg = false)] // Disabling `auto_cfg`
+#[doc(auto_cfg(show(unix)))] // `auto_cfg` is re-enabled.
+pub fn foo() {}
+```
+
+## Inheritance
+
+Rustdoc merges `cfg` attributes from parent modules to its children. For example, in this case, the module `non_unix` will describe the entire compatibility matrix for the module, and not just its directly attached information:
+
+```rust,ignore (nightly)
+#[doc(cfg(any(windows, unix)))]
+pub mod desktop {
+    #[doc(cfg(not(unix)))]
+    pub mod non_unix {
+        // ...
+    }
+}
+```
+
+This code will display:
+
+```text
+Available on (Windows or Unix) and non-Unix only.
+```
+
+### Re-exports and inlining
+
+`cfg` attributes of a re-export are never merged with the re-exported item(s) attributes except if the re-export has the `#[doc(inline)]` attribute. In this case, the `cfg` of the re-exported item will be merged with the re-export's.
+
+When talking about "attributes merge", we mean that if the re-export has `#[cfg(unix)]` and the re-exported item has `#[cfg(feature = "foo")]`, you will only see `cfg(unix)` on the re-export and only `cfg(feature = "foo")` on the re-exported item, unless the re-export has `#[doc(inline)]`, then you will only see the re-exported item with both `cfg(unix)` and `cfg(feature = "foo")`.
+
+Example:
+
+```rust,ignore (nightly)
+#[doc(cfg(any(windows, unix)))]
+pub mod desktop {
+    #[doc(cfg(not(unix)))]
+    pub mod non_unix {
+        // code
+    }
+}
+
+#[doc(cfg(target_os = "freebsd"))]
+pub use desktop::non_unix as non_unix_desktop;
+#[doc(cfg(target_os = "macos"))]
+#[doc(inline)]
+pub use desktop::non_unix as inlined_non_unix_desktop;
+```
+
+In this example, `non_unix_desktop` will only display `cfg(target_os = "freeebsd")` and not display any `cfg` from `desktop::non_unix`.
+
+On the contrary, `inlined_non_unix_desktop` will have cfgs from both the re-export and the re-exported item.
+
+So that also means that if a crate re-exports a foreign item, unless it has `#[doc(inline)]`, the `cfg` and `doc(cfg)` attributes will not be visible:
+
+```rust,ignore (nightly)
+// dep:
+#[cfg(feature = "a")]
+pub struct S;
+
+// crate using dep:
+
+// There will be no mention of `feature = "a"` in the documentation.
+pub use dep::S as Y;
+```

From ed05315867b7dd17a456beaabc3faf36357f9447 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 11 Apr 2025 12:02:48 +0200
Subject: [PATCH 1470/1889] Rename `CfgInfo::doc_auto_cfg_active` into
 `auto_cfg_active`

---
 src/librustdoc/clean/types.rs | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index 63e8357801c05..2ec97a57087a1 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -926,7 +926,7 @@ pub(crate) fn hir_attr_lists<'a, I: IntoIterator<Item = &'a hir::Attribute>>(
 pub(crate) struct CfgInfo {
     hidden_cfg: FxHashSet<Cfg>,
     current_cfg: Cfg,
-    doc_auto_cfg_active: bool,
+    auto_cfg_active: bool,
     parent_is_doc_cfg: bool,
 }
 
@@ -941,7 +941,7 @@ impl Default for CfgInfo {
             .into_iter()
             .collect(),
             current_cfg: Cfg::True,
-            doc_auto_cfg_active: true,
+            auto_cfg_active: true,
             parent_is_doc_cfg: false,
         }
     }
@@ -1058,7 +1058,7 @@ pub(crate) fn extract_cfg_from_attrs<'a, I: Iterator<Item = &'a hir::Attribute>
                 match &attr.kind {
                     MetaItemKind::Word => {
                         if let Some(first_change) = changed_auto_active_status {
-                            if !cfg_info.doc_auto_cfg_active {
+                            if !cfg_info.auto_cfg_active {
                                 tcx.sess.dcx().struct_span_err(
                                     vec![first_change, attr.span],
                                     "`auto_cfg` was disabled and enabled more than once on the same item",
@@ -1068,12 +1068,12 @@ pub(crate) fn extract_cfg_from_attrs<'a, I: Iterator<Item = &'a hir::Attribute>
                         } else {
                             changed_auto_active_status = Some(attr.span);
                         }
-                        cfg_info.doc_auto_cfg_active = true;
+                        cfg_info.auto_cfg_active = true;
                     }
                     MetaItemKind::NameValue(lit) => {
                         if let LitKind::Bool(value) = lit.kind {
                             if let Some(first_change) = changed_auto_active_status {
-                                if cfg_info.doc_auto_cfg_active != value {
+                                if cfg_info.auto_cfg_active != value {
                                     tcx.sess.dcx().struct_span_err(
                                         vec![first_change, attr.span],
                                         "`auto_cfg` was disabled and enabled more than once on the same item",
@@ -1083,12 +1083,12 @@ pub(crate) fn extract_cfg_from_attrs<'a, I: Iterator<Item = &'a hir::Attribute>
                             } else {
                                 changed_auto_active_status = Some(attr.span);
                             }
-                            cfg_info.doc_auto_cfg_active = value;
+                            cfg_info.auto_cfg_active = value;
                         }
                     }
                     MetaItemKind::List(sub_attrs) => {
                         if let Some(first_change) = changed_auto_active_status {
-                            if !cfg_info.doc_auto_cfg_active {
+                            if !cfg_info.auto_cfg_active {
                                 tcx.sess.dcx().struct_span_err(
                                     vec![first_change, attr.span],
                                     "`auto_cfg` was disabled and enabled more than once on the same item",
@@ -1099,7 +1099,7 @@ pub(crate) fn extract_cfg_from_attrs<'a, I: Iterator<Item = &'a hir::Attribute>
                             changed_auto_active_status = Some(attr.span);
                         }
                         // Whatever happens next, the feature is enabled again.
-                        cfg_info.doc_auto_cfg_active = true;
+                        cfg_info.auto_cfg_active = true;
                         for sub_attr in sub_attrs.iter() {
                             if let Some(ident) = sub_attr.ident()
                                 && (ident.name == sym::show || ident.name == sym::hide)
@@ -1157,7 +1157,7 @@ pub(crate) fn extract_cfg_from_attrs<'a, I: Iterator<Item = &'a hir::Attribute>
 
     // If `doc(auto_cfg)` feature is disabled and `doc(cfg())` wasn't used, there is nothing
     // to be done here.
-    if !cfg_info.doc_auto_cfg_active && !cfg_info.parent_is_doc_cfg {
+    if !cfg_info.auto_cfg_active && !cfg_info.parent_is_doc_cfg {
         None
     } else if cfg_info.parent_is_doc_cfg {
         if cfg_info.current_cfg == Cfg::True {

From c06a076634e4feab47e133fe6325af9659bab082 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 11 Apr 2025 14:32:31 +0200
Subject: [PATCH 1471/1889] Put back the `doc_cfg` code behind a nightly
 feature

---
 compiler/rustc_ast_passes/src/feature_gate.rs       |  1 +
 src/librustdoc/passes/propagate_doc_cfg.rs          |  6 +++++-
 tests/rustdoc-ui/cfg-hide-show-conflict.rs          |  1 +
 tests/rustdoc-ui/cfg-hide-show-conflict.stderr      |  4 ++--
 tests/rustdoc-ui/lints/doc_cfg_hide.rs              |  1 +
 tests/rustdoc-ui/lints/doc_cfg_hide.stderr          |  6 +++---
 tests/rustdoc/doc-auto-cfg.rs                       |  2 +-
 tests/rustdoc/doc-cfg/doc-cfg-hide.rs               |  2 +-
 tests/rustdoc/doc-cfg/doc-cfg-implicit-gate.rs      |  1 +
 tests/rustdoc/doc_auto_cfg.rs                       |  5 +----
 tests/rustdoc/doc_auto_cfg_reexports.rs             |  1 +
 tests/rustdoc/impl/doc_auto_cfg_nested_impl.rs      |  2 +-
 .../doc_auto_cfg-reexport-foreign-113982.rs         |  2 +-
 .../glob-reexport-attribute-merge-doc-auto-cfg.rs   |  2 +-
 tests/ui/feature-gates/feature-gate-doc_cfg.rs      |  6 +-----
 tests/ui/feature-gates/feature-gate-doc_cfg.stderr  | 13 +++++++++++++
 16 files changed, 35 insertions(+), 20 deletions(-)
 create mode 100644 tests/ui/feature-gates/feature-gate-doc_cfg.stderr

diff --git a/compiler/rustc_ast_passes/src/feature_gate.rs b/compiler/rustc_ast_passes/src/feature_gate.rs
index fe9cc8e61ed5b..35531378784b3 100644
--- a/compiler/rustc_ast_passes/src/feature_gate.rs
+++ b/compiler/rustc_ast_passes/src/feature_gate.rs
@@ -182,6 +182,7 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
 
                 gate_doc!(
                     "experimental" {
+                        cfg => doc_cfg
                         masked => doc_masked
                         notable_trait => doc_notable_trait
                     }
diff --git a/src/librustdoc/passes/propagate_doc_cfg.rs b/src/librustdoc/passes/propagate_doc_cfg.rs
index 1425687cd2698..802f2fbe569cd 100644
--- a/src/librustdoc/passes/propagate_doc_cfg.rs
+++ b/src/librustdoc/passes/propagate_doc_cfg.rs
@@ -18,7 +18,11 @@ pub(crate) const PROPAGATE_DOC_CFG: Pass = Pass {
 };
 
 pub(crate) fn propagate_doc_cfg(cr: Crate, cx: &mut DocContext<'_>) -> Crate {
-    CfgPropagator { cx, cfg_info: CfgInfo::default() }.fold_crate(cr)
+    if cx.tcx.features().doc_cfg() {
+        CfgPropagator { cx, cfg_info: CfgInfo::default() }.fold_crate(cr)
+    } else {
+        cr
+    }
 }
 
 struct CfgPropagator<'a, 'tcx> {
diff --git a/tests/rustdoc-ui/cfg-hide-show-conflict.rs b/tests/rustdoc-ui/cfg-hide-show-conflict.rs
index a8a50fe15c7e1..8e98b95c85bb9 100644
--- a/tests/rustdoc-ui/cfg-hide-show-conflict.rs
+++ b/tests/rustdoc-ui/cfg-hide-show-conflict.rs
@@ -1,2 +1,3 @@
+#![feature(doc_cfg)]
 #![doc(auto_cfg(hide(target_os = "linux")))]
 #![doc(auto_cfg(show(windows, target_os = "linux")))] //~ ERROR
diff --git a/tests/rustdoc-ui/cfg-hide-show-conflict.stderr b/tests/rustdoc-ui/cfg-hide-show-conflict.stderr
index d2d0564606a54..22231e82cd7bf 100644
--- a/tests/rustdoc-ui/cfg-hide-show-conflict.stderr
+++ b/tests/rustdoc-ui/cfg-hide-show-conflict.stderr
@@ -1,11 +1,11 @@
 error: same `cfg` was in `auto_cfg(hide(...))` and `auto_cfg(show(...))` on the same item
-  --> $DIR/cfg-hide-show-conflict.rs:2:31
+  --> $DIR/cfg-hide-show-conflict.rs:3:31
    |
 LL | #![doc(auto_cfg(show(windows, target_os = "linux")))]
    |                               ^^^^^^^^^^^^^^^^^^^
    |
 note: first change was here
-  --> $DIR/cfg-hide-show-conflict.rs:1:22
+  --> $DIR/cfg-hide-show-conflict.rs:2:22
    |
 LL | #![doc(auto_cfg(hide(target_os = "linux")))]
    |                      ^^^^^^^^^^^^^^^^^^^
diff --git a/tests/rustdoc-ui/lints/doc_cfg_hide.rs b/tests/rustdoc-ui/lints/doc_cfg_hide.rs
index 4f2625d00ce43..397b21393e5c7 100644
--- a/tests/rustdoc-ui/lints/doc_cfg_hide.rs
+++ b/tests/rustdoc-ui/lints/doc_cfg_hide.rs
@@ -1,3 +1,4 @@
+#![feature(doc_cfg)]
 #![doc(auto_cfg(hide = "test"))] //~ ERROR
 #![doc(auto_cfg(hide))] //~ ERROR
 #![doc(auto_cfg(hide(not(windows))))] //~ ERROR
diff --git a/tests/rustdoc-ui/lints/doc_cfg_hide.stderr b/tests/rustdoc-ui/lints/doc_cfg_hide.stderr
index 22501d63c3fb9..0e9db5a30d83b 100644
--- a/tests/rustdoc-ui/lints/doc_cfg_hide.stderr
+++ b/tests/rustdoc-ui/lints/doc_cfg_hide.stderr
@@ -1,5 +1,5 @@
 error: `#![doc(auto_cfg(hide(...)))]` only expects a list of items
-  --> $DIR/doc_cfg_hide.rs:1:8
+  --> $DIR/doc_cfg_hide.rs:2:8
    |
 LL | #![doc(auto_cfg(hide = "test"))]
    |        ^^^^^^^^^^^^^^^^^^^^^^^
@@ -7,13 +7,13 @@ LL | #![doc(auto_cfg(hide = "test"))]
    = note: `#[deny(invalid_doc_attributes)]` on by default
 
 error: `#![doc(auto_cfg(hide(...)))]` only expects a list of items
-  --> $DIR/doc_cfg_hide.rs:2:8
+  --> $DIR/doc_cfg_hide.rs:3:8
    |
 LL | #![doc(auto_cfg(hide))]
    |        ^^^^^^^^^^^^^^
 
 error: `#![doc(auto_cfg(hide(...)))]` only accepts identifiers or key/values items
-  --> $DIR/doc_cfg_hide.rs:3:22
+  --> $DIR/doc_cfg_hide.rs:4:22
    |
 LL | #![doc(auto_cfg(hide(not(windows))))]
    |                      ^^^^^^^^^^^^
diff --git a/tests/rustdoc/doc-auto-cfg.rs b/tests/rustdoc/doc-auto-cfg.rs
index b3fe8922fd788..e56cf18d08a0c 100644
--- a/tests/rustdoc/doc-auto-cfg.rs
+++ b/tests/rustdoc/doc-auto-cfg.rs
@@ -1,4 +1,4 @@
-#![feature(doc_auto_cfg)]
+#![feature(doc_cfg)]
 #![crate_name = "foo"]
 
 //@ has foo/fn.foo.html
diff --git a/tests/rustdoc/doc-cfg/doc-cfg-hide.rs b/tests/rustdoc/doc-cfg/doc-cfg-hide.rs
index cf906ede7e13f..e919206d3a478 100644
--- a/tests/rustdoc/doc-cfg/doc-cfg-hide.rs
+++ b/tests/rustdoc/doc-cfg/doc-cfg-hide.rs
@@ -1,5 +1,5 @@
 #![crate_name = "oud"]
-#![feature(doc_auto_cfg, doc_cfg, doc_cfg_hide, no_core)]
+#![feature(doc_cfg)]
 
 #![doc(auto_cfg(hide(feature = "solecism")))]
 
diff --git a/tests/rustdoc/doc-cfg/doc-cfg-implicit-gate.rs b/tests/rustdoc/doc-cfg/doc-cfg-implicit-gate.rs
index 27923893bddae..9ae8b8fca4f7a 100644
--- a/tests/rustdoc/doc-cfg/doc-cfg-implicit-gate.rs
+++ b/tests/rustdoc/doc-cfg/doc-cfg-implicit-gate.rs
@@ -1,4 +1,5 @@
 //@ compile-flags:--cfg feature="worricow"
+#![feature(doc_cfg)]
 #![crate_name = "xenogenous"]
 
 //@ has 'xenogenous/struct.Worricow.html'
diff --git a/tests/rustdoc/doc_auto_cfg.rs b/tests/rustdoc/doc_auto_cfg.rs
index cb7c0e3f5950c..19ef174c1778d 100644
--- a/tests/rustdoc/doc_auto_cfg.rs
+++ b/tests/rustdoc/doc_auto_cfg.rs
@@ -1,10 +1,7 @@
 // Test covering RFC 3631 features.
 
 #![crate_name = "foo"]
-#![feature(no_core)]
-#![no_core]
-#![no_std]
-
+#![feature(doc_cfg)]
 #![doc(auto_cfg(hide(feature = "hidden")))]
 
 //@ has 'foo/index.html'
diff --git a/tests/rustdoc/doc_auto_cfg_reexports.rs b/tests/rustdoc/doc_auto_cfg_reexports.rs
index f226c52e2ebf9..f6315e9d49dde 100644
--- a/tests/rustdoc/doc_auto_cfg_reexports.rs
+++ b/tests/rustdoc/doc_auto_cfg_reexports.rs
@@ -1,6 +1,7 @@
 // Checks that `cfg` are correctly applied on inlined reexports.
 
 #![crate_name = "foo"]
+#![feature(doc_cfg)]
 
 // Check with `std` item.
 //@ has 'foo/index.html' '//*[@class="stab portability"]' 'Non-moustache'
diff --git a/tests/rustdoc/impl/doc_auto_cfg_nested_impl.rs b/tests/rustdoc/impl/doc_auto_cfg_nested_impl.rs
index f85d7b236372d..f24ebcd52acb6 100644
--- a/tests/rustdoc/impl/doc_auto_cfg_nested_impl.rs
+++ b/tests/rustdoc/impl/doc_auto_cfg_nested_impl.rs
@@ -1,6 +1,6 @@
 // Regression test for <https://github.com/rust-lang/rust/issues/101129>.
 
-#![feature(doc_auto_cfg)]
+#![feature(doc_cfg)]
 #![crate_type = "lib"]
 #![crate_name = "foo"]
 
diff --git a/tests/rustdoc/reexport/doc_auto_cfg-reexport-foreign-113982.rs b/tests/rustdoc/reexport/doc_auto_cfg-reexport-foreign-113982.rs
index 76b25127a9c64..f8ec4afc0313e 100644
--- a/tests/rustdoc/reexport/doc_auto_cfg-reexport-foreign-113982.rs
+++ b/tests/rustdoc/reexport/doc_auto_cfg-reexport-foreign-113982.rs
@@ -1,7 +1,7 @@
 //@ aux-build: issue-113982-doc_auto_cfg-reexport-foreign.rs
 
 // https://github.com/rust-lang/rust/issues/113982
-#![feature(no_core, doc_auto_cfg)]
+#![feature(no_core, doc_cfg)]
 #![no_core]
 #![crate_name = "foo"]
 
diff --git a/tests/rustdoc/reexport/glob-reexport-attribute-merge-doc-auto-cfg.rs b/tests/rustdoc/reexport/glob-reexport-attribute-merge-doc-auto-cfg.rs
index d0a2165ec8abb..0aed2b0c46208 100644
--- a/tests/rustdoc/reexport/glob-reexport-attribute-merge-doc-auto-cfg.rs
+++ b/tests/rustdoc/reexport/glob-reexport-attribute-merge-doc-auto-cfg.rs
@@ -2,7 +2,7 @@
 // the reexported item whereas glob reexports do with the `doc_auto_cfg` feature.
 
 #![crate_name = "foo"]
-#![feature(doc_auto_cfg)]
+#![feature(doc_cfg)]
 
 //@ has 'foo/index.html'
 // There are two items.
diff --git a/tests/ui/feature-gates/feature-gate-doc_cfg.rs b/tests/ui/feature-gates/feature-gate-doc_cfg.rs
index 83053e8c8bfd6..213a5a8c5a988 100644
--- a/tests/ui/feature-gates/feature-gate-doc_cfg.rs
+++ b/tests/ui/feature-gates/feature-gate-doc_cfg.rs
@@ -1,6 +1,2 @@
-//@ build-pass
-
-// FIXME: Remove this test once `doc_cfg` feature is completely removed.
-
-#[doc(cfg(unix))]
+#[doc(cfg(unix))] //~ ERROR
 fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-doc_cfg.stderr b/tests/ui/feature-gates/feature-gate-doc_cfg.stderr
new file mode 100644
index 0000000000000..5315aaeeb3edb
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-doc_cfg.stderr
@@ -0,0 +1,13 @@
+error[E0658]: `#[doc(cfg)]` is experimental
+  --> $DIR/feature-gate-doc_cfg.rs:1:1
+   |
+LL | #[doc(cfg(unix))]
+   | ^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #43781 <https://github.com/rust-lang/rust/issues/43781> for more information
+   = help: add `#![feature(doc_cfg)]` to the crate attributes to enable
+   = 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`.

From 1561efe41afe40c1afaf3d11316ef754d9a8f9a9 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 27 May 2025 17:14:46 +0200
Subject: [PATCH 1472/1889] Add code documentation, improve code and improve
 error message

---
 compiler/rustc_passes/messages.ftl         |  2 +-
 compiler/rustc_passes/src/check_attr.rs    |  9 +++------
 src/librustdoc/clean/types.rs              | 13 +++++++++++++
 src/librustdoc/passes/propagate_doc_cfg.rs | 14 +++++++++-----
 tests/rustdoc-ui/lints/doc_cfg_hide.stderr |  4 ++--
 5 files changed, 28 insertions(+), 14 deletions(-)

diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index 8326ddaf194d7..a9a0f6d8b516b 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -147,7 +147,7 @@ passes_doc_auto_cfg_expects_hide_or_show =
     `only "hide" or "show" are allowed in "#[doc(auto_cfg(...))]"`
 
 passes_doc_auto_cfg_hide_show_expects_list =
-    `#![doc(auto_cfg({$attr_name}(...)))]` only expects a list of items
+    `#![doc(auto_cfg({$attr_name}(...)))]` expects a list of items
 
 passes_doc_auto_cfg_hide_show_unexpected_item =
     `#![doc(auto_cfg({$attr_name}(...)))]` only accepts identifiers or key/values items
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 38b67e2f9dc5f..c521467b556c1 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -10,7 +10,7 @@ use std::collections::hash_map::Entry;
 use std::slice;
 
 use rustc_abi::{Align, ExternAbi, Size};
-use rustc_ast::{AttrStyle, LitKind, MetaItemInner, MetaItemKind, ast};
+use rustc_ast::{AttrStyle, LitKind, MetaItem, MetaItemInner, MetaItemKind, ast};
 use rustc_attr_parsing::{AttributeParser, Late};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::{Applicability, DiagCtxtHandle, IntoDiagArg, MultiSpan, StashKey};
@@ -1161,10 +1161,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
     }
 
     /// Check that the `#![doc(auto_cfg(..))]` attribute has expected input.
-    fn check_doc_auto_cfg(&self, meta: &MetaItemInner, hir_id: HirId) {
-        let MetaItemInner::MetaItem(meta) = meta else {
-            unreachable!();
-        };
+    fn check_doc_auto_cfg(&self, meta: &MetaItem, hir_id: HirId) {
         match &meta.kind {
             MetaItemKind::Word => {}
             MetaItemKind::NameValue(lit) => {
@@ -1286,7 +1283,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         }
 
                         Some(sym::auto_cfg) => {
-                            self.check_doc_auto_cfg(meta, hir_id);
+                            self.check_doc_auto_cfg(i_meta, hir_id);
                         }
 
                         Some(sym::inline | sym::no_inline) => {
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index 2ec97a57087a1..545f1ef6da4a3 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -922,11 +922,19 @@ pub(crate) fn hir_attr_lists<'a, I: IntoIterator<Item = &'a hir::Attribute>>(
         .flatten()
 }
 
+/// This type keeps track of (doc) cfg information as we go down the item tree.
 #[derive(Clone, Debug)]
 pub(crate) struct CfgInfo {
+    /// List of `doc(auto_cfg(hide(...)))` cfgs.
     hidden_cfg: FxHashSet<Cfg>,
+    /// Current computed `cfg`. Each time we enter a new item, this field is updated as well while
+    /// taking into account the `hidden_cfg` information.
     current_cfg: Cfg,
+    /// Whether the `doc(auto_cfg())` feature is enabled or not at this point.
     auto_cfg_active: bool,
+    /// If the parent item used `doc(cfg(...))`, then we don't want to overwrite `current_cfg`,
+    /// instead we will concatenate with it. However, if it's not the case, we need to overwrite
+    /// `current_cfg`.
     parent_is_doc_cfg: bool,
 }
 
@@ -962,6 +970,11 @@ fn show_hide_show_conflict_error(
     diag.emit();
 }
 
+/// This function checks if a same `cfg` is present in both `auto_cfg(hide(...))` and
+/// `auto_cfg(show(...))` on the same item. If so, it emits an error.
+///
+/// Because we go through a list of `cfg`s, we keep track of the `cfg`s we saw in `new_show_attrs`
+/// and in `new_hide_attrs` arguments.
 fn handle_auto_cfg_hide_show(
     tcx: TyCtxt<'_>,
     cfg_info: &mut CfgInfo,
diff --git a/src/librustdoc/passes/propagate_doc_cfg.rs b/src/librustdoc/passes/propagate_doc_cfg.rs
index 802f2fbe569cd..ea77065ac0799 100644
--- a/src/librustdoc/passes/propagate_doc_cfg.rs
+++ b/src/librustdoc/passes/propagate_doc_cfg.rs
@@ -30,7 +30,8 @@ struct CfgPropagator<'a, 'tcx> {
     cfg_info: CfgInfo,
 }
 
-fn should_retain(token: &TokenTree) -> bool {
+/// Returns true if the provided `token` is a `cfg` ident.
+fn is_cfg_token(token: &TokenTree) -> bool {
     // We only keep `doc(cfg)` items.
     matches!(
         token,
@@ -47,7 +48,9 @@ fn should_retain(token: &TokenTree) -> bool {
     )
 }
 
-fn filter_tokens_from_list(args_tokens: &TokenStream) -> Vec<TokenTree> {
+/// We only want to keep `#[cfg()]` and `#[doc(cfg())]` attributes so we rebuild a vec of
+/// `TokenTree` with only the tokens we're interested into.
+fn filter_non_cfg_tokens_from_list(args_tokens: &TokenStream) -> Vec<TokenTree> {
     let mut tokens = Vec::with_capacity(args_tokens.len());
     let mut skip_next_delimited = false;
     for token in args_tokens.iter() {
@@ -58,7 +61,7 @@ fn filter_tokens_from_list(args_tokens: &TokenStream) -> Vec<TokenTree> {
                 }
                 skip_next_delimited = false;
             }
-            token if should_retain(token) => {
+            token if is_cfg_token(token) => {
                 skip_next_delimited = false;
                 tokens.push(token.clone());
             }
@@ -70,7 +73,8 @@ fn filter_tokens_from_list(args_tokens: &TokenStream) -> Vec<TokenTree> {
     tokens
 }
 
-// We only care about `#[cfg()]` and `#[doc(cfg())]`, we discard everything else.
+/// This function goes through the attributes list (`new_attrs`) and extract the `cfg` tokens from
+/// it and put them into `attrs`.
 fn add_only_cfg_attributes(attrs: &mut Vec<Attribute>, new_attrs: &[Attribute]) {
     for attr in new_attrs {
         if attr.is_doc_comment() {
@@ -84,7 +88,7 @@ fn add_only_cfg_attributes(attrs: &mut Vec<Attribute>, new_attrs: &[Attribute])
             if ident == sym::doc
                 && let AttrArgs::Delimited(args) = &mut normal.args
             {
-                let tokens = filter_tokens_from_list(&args.tokens);
+                let tokens = filter_non_cfg_tokens_from_list(&args.tokens);
                 args.tokens = TokenStream::new(tokens);
                 attrs.push(attr);
             } else if ident == sym::cfg_trace {
diff --git a/tests/rustdoc-ui/lints/doc_cfg_hide.stderr b/tests/rustdoc-ui/lints/doc_cfg_hide.stderr
index 0e9db5a30d83b..9e820a77b5e54 100644
--- a/tests/rustdoc-ui/lints/doc_cfg_hide.stderr
+++ b/tests/rustdoc-ui/lints/doc_cfg_hide.stderr
@@ -1,4 +1,4 @@
-error: `#![doc(auto_cfg(hide(...)))]` only expects a list of items
+error: `#![doc(auto_cfg(hide(...)))]` expects a list of items
   --> $DIR/doc_cfg_hide.rs:2:8
    |
 LL | #![doc(auto_cfg(hide = "test"))]
@@ -6,7 +6,7 @@ LL | #![doc(auto_cfg(hide = "test"))]
    |
    = note: `#[deny(invalid_doc_attributes)]` on by default
 
-error: `#![doc(auto_cfg(hide(...)))]` only expects a list of items
+error: `#![doc(auto_cfg(hide(...)))]` expects a list of items
   --> $DIR/doc_cfg_hide.rs:3:8
    |
 LL | #![doc(auto_cfg(hide))]

From 553308b11503eafac6341b82f345bd62b09ba317 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 29 May 2025 18:39:08 +0200
Subject: [PATCH 1473/1889] Improve code and better check `doc(cfg(...))`
 attributes

---
 compiler/rustc_ast_passes/src/feature_gate.rs |  1 +
 compiler/rustc_passes/messages.ftl            |  2 +-
 compiler/rustc_passes/src/check_attr.rs       | 23 ++++-
 compiler/rustc_span/src/symbol.rs             |  1 -
 src/librustdoc/clean/inline.rs                |  4 +
 src/librustdoc/clean/types.rs                 | 89 +++++++++++--------
 tests/rustdoc-ui/doc-cfg.rs                   |  9 ++
 tests/rustdoc-ui/doc-cfg.stderr               | 66 ++++++++++----
 tests/rustdoc-ui/feature-gate-doc_cfg.rs      |  6 ++
 tests/rustdoc-ui/feature-gate-doc_cfg.stderr  | 63 +++++++++++++
 tests/rustdoc-ui/feature-gate-doc_cfg_hide.rs |  8 --
 .../feature-gate-doc_cfg_hide.stderr          | 10 ---
 tests/rustdoc-ui/lints/doc_cfg_hide.stderr    |  2 +-
 13 files changed, 209 insertions(+), 75 deletions(-)
 create mode 100644 tests/rustdoc-ui/feature-gate-doc_cfg.rs
 create mode 100644 tests/rustdoc-ui/feature-gate-doc_cfg.stderr
 delete mode 100644 tests/rustdoc-ui/feature-gate-doc_cfg_hide.rs
 delete mode 100644 tests/rustdoc-ui/feature-gate-doc_cfg_hide.stderr

diff --git a/compiler/rustc_ast_passes/src/feature_gate.rs b/compiler/rustc_ast_passes/src/feature_gate.rs
index 35531378784b3..608ccfefeb69d 100644
--- a/compiler/rustc_ast_passes/src/feature_gate.rs
+++ b/compiler/rustc_ast_passes/src/feature_gate.rs
@@ -183,6 +183,7 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
                 gate_doc!(
                     "experimental" {
                         cfg => doc_cfg
+                        auto_cfg => doc_cfg
                         masked => doc_masked
                         notable_trait => doc_notable_trait
                     }
diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index a9a0f6d8b516b..a5ff169e638c9 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -150,7 +150,7 @@ passes_doc_auto_cfg_hide_show_expects_list =
     `#![doc(auto_cfg({$attr_name}(...)))]` expects a list of items
 
 passes_doc_auto_cfg_hide_show_unexpected_item =
-    `#![doc(auto_cfg({$attr_name}(...)))]` only accepts identifiers or key/values items
+    `#![doc(auto_cfg({$attr_name}(...)))]` only accepts identifiers or key/value items
 
 passes_doc_auto_cfg_wrong_literal =
     `expected boolean for #[doc(auto_cfg = ...)]`
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index c521467b556c1..88b49c781e75c 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -1176,7 +1176,15 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             }
             MetaItemKind::List(list) => {
                 for item in list {
-                    let Some(attr_name) = item.name() else { continue };
+                    let Some(attr_name) = item.name() else {
+                        self.tcx.emit_node_span_lint(
+                            INVALID_DOC_ATTRIBUTES,
+                            hir_id,
+                            meta.span,
+                            errors::DocAutoCfgExpectsHideOrShow,
+                        );
+                        continue;
+                    };
                     if attr_name != sym::hide && attr_name != sym::show {
                         self.tcx.emit_node_span_lint(
                             INVALID_DOC_ATTRIBUTES,
@@ -1195,6 +1203,19 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                                         attr_name: attr_name.as_str(),
                                     },
                                 );
+                            } else if match item {
+                                MetaItemInner::Lit(_) => true,
+                                // We already checked above that it's not a list.
+                                MetaItemInner::MetaItem(meta) => meta.path.segments.len() != 1,
+                            } {
+                                self.tcx.emit_node_span_lint(
+                                    INVALID_DOC_ATTRIBUTES,
+                                    hir_id,
+                                    item.span(),
+                                    errors::DocAutoCfgHideShowUnexpectedItem {
+                                        attr_name: attr_name.as_str(),
+                                    },
+                                );
                             }
                         }
                     } else {
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index e80a98994dbba..18c3faed9329a 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1150,7 +1150,6 @@ symbols! {
         hashset_iter_ty,
         hexagon_target_feature,
         hidden,
-        hidden_cfg,
         hide,
         hint,
         homogeneous_aggregate,
diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs
index 8ffa6033c9b0d..8beea0580de2d 100644
--- a/src/librustdoc/clean/inline.rs
+++ b/src/librustdoc/clean/inline.rs
@@ -605,6 +605,10 @@ pub(crate) fn build_impl(
         });
     }
 
+    // In here, we pass an empty `CfgInfo` because the computation of `cfg` happens later, so it
+    // doesn't matter at this point.
+    //
+    // We need to pass this empty `CfgInfo` because `merge_attrs` is used when computing the `cfg`.
     let (merged_attrs, cfg) = merge_attrs(cx, load_attrs(cx, did), attrs, &mut CfgInfo::default());
     trace!("merged_attrs={merged_attrs:?}");
 
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index 545f1ef6da4a3..605b77109a061 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -970,8 +970,10 @@ fn show_hide_show_conflict_error(
     diag.emit();
 }
 
-/// This function checks if a same `cfg` is present in both `auto_cfg(hide(...))` and
-/// `auto_cfg(show(...))` on the same item. If so, it emits an error.
+/// This functions updates the `hidden_cfg` field of the provided `cfg_info` argument.
+///
+/// It also checks if a same `cfg` is present in both `auto_cfg(hide(...))` and
+/// `auto_cfg(show(...))` on the same item and emits an error if it's the case.
 ///
 /// Because we go through a list of `cfg`s, we keep track of the `cfg`s we saw in `new_show_attrs`
 /// and in `new_hide_attrs` arguments.
@@ -1023,6 +1025,31 @@ pub(crate) fn extract_cfg_from_attrs<'a, I: Iterator<Item = &'a hir::Attribute>
         Some(item)
     }
 
+    fn check_changed_auto_active_status(
+        changed_auto_active_status: &mut Option<rustc_span::Span>,
+        attr: &ast::MetaItem,
+        cfg_info: &mut CfgInfo,
+        tcx: TyCtxt<'_>,
+        new_value: bool,
+    ) -> bool {
+        if let Some(first_change) = changed_auto_active_status {
+            if cfg_info.auto_cfg_active != new_value {
+                tcx.sess
+                    .dcx()
+                    .struct_span_err(
+                        vec![*first_change, attr.span],
+                        "`auto_cfg` was disabled and enabled more than once on the same item",
+                    )
+                    .emit();
+                return true;
+            }
+        } else {
+            *changed_auto_active_status = Some(attr.span);
+        }
+        cfg_info.auto_cfg_active = new_value;
+        false
+    }
+
     let mut new_show_attrs = FxHashMap::default();
     let mut new_hide_attrs = FxHashMap::default();
 
@@ -1070,49 +1097,39 @@ pub(crate) fn extract_cfg_from_attrs<'a, I: Iterator<Item = &'a hir::Attribute>
                 };
                 match &attr.kind {
                     MetaItemKind::Word => {
-                        if let Some(first_change) = changed_auto_active_status {
-                            if !cfg_info.auto_cfg_active {
-                                tcx.sess.dcx().struct_span_err(
-                                    vec![first_change, attr.span],
-                                    "`auto_cfg` was disabled and enabled more than once on the same item",
-                                ).emit();
-                                return None;
-                            }
-                        } else {
-                            changed_auto_active_status = Some(attr.span);
+                        if check_changed_auto_active_status(
+                            &mut changed_auto_active_status,
+                            attr,
+                            cfg_info,
+                            tcx,
+                            true,
+                        ) {
+                            return None;
                         }
-                        cfg_info.auto_cfg_active = true;
                     }
                     MetaItemKind::NameValue(lit) => {
                         if let LitKind::Bool(value) = lit.kind {
-                            if let Some(first_change) = changed_auto_active_status {
-                                if cfg_info.auto_cfg_active != value {
-                                    tcx.sess.dcx().struct_span_err(
-                                        vec![first_change, attr.span],
-                                        "`auto_cfg` was disabled and enabled more than once on the same item",
-                                    ).emit();
-                                    return None;
-                                }
-                            } else {
-                                changed_auto_active_status = Some(attr.span);
+                            if check_changed_auto_active_status(
+                                &mut changed_auto_active_status,
+                                attr,
+                                cfg_info,
+                                tcx,
+                                value,
+                            ) {
+                                return None;
                             }
-                            cfg_info.auto_cfg_active = value;
                         }
                     }
                     MetaItemKind::List(sub_attrs) => {
-                        if let Some(first_change) = changed_auto_active_status {
-                            if !cfg_info.auto_cfg_active {
-                                tcx.sess.dcx().struct_span_err(
-                                    vec![first_change, attr.span],
-                                    "`auto_cfg` was disabled and enabled more than once on the same item",
-                                ).emit();
-                                return None;
-                            }
-                        } else {
-                            changed_auto_active_status = Some(attr.span);
+                        if check_changed_auto_active_status(
+                            &mut changed_auto_active_status,
+                            attr,
+                            cfg_info,
+                            tcx,
+                            true,
+                        ) {
+                            return None;
                         }
-                        // Whatever happens next, the feature is enabled again.
-                        cfg_info.auto_cfg_active = true;
                         for sub_attr in sub_attrs.iter() {
                             if let Some(ident) = sub_attr.ident()
                                 && (ident.name == sym::show || ident.name == sym::hide)
diff --git a/tests/rustdoc-ui/doc-cfg.rs b/tests/rustdoc-ui/doc-cfg.rs
index 14943bbc3418e..9840c305290ae 100644
--- a/tests/rustdoc-ui/doc-cfg.rs
+++ b/tests/rustdoc-ui/doc-cfg.rs
@@ -8,4 +8,13 @@
 //~^^ WARN unexpected `cfg` condition name: `bar`
 #[doc(cfg())] //~ ERROR
 #[doc(cfg(foo, bar))] //~ ERROR
+#[doc(auto_cfg(42))] //~ ERROR
+#[doc(auto_cfg(hide(true)))] //~ ERROR
+#[doc(auto_cfg(hide(42)))] //~ ERROR
+#[doc(auto_cfg(hide("a")))] //~ ERROR
+#[doc(auto_cfg(hide(foo::bar)))] //~ ERROR
+// Shouldn't lint
+#[doc(auto_cfg(hide(windows)))]
+#[doc(auto_cfg(hide(feature = "windows")))]
+#[doc(auto_cfg(hide(foo)))]
 pub fn foo() {}
diff --git a/tests/rustdoc-ui/doc-cfg.stderr b/tests/rustdoc-ui/doc-cfg.stderr
index 1233ee010de21..36ca18eed8fc8 100644
--- a/tests/rustdoc-ui/doc-cfg.stderr
+++ b/tests/rustdoc-ui/doc-cfg.stderr
@@ -1,26 +1,34 @@
-error: `cfg` predicate is not specified
-  --> $DIR/doc-cfg.rs:3:7
+error: `only "hide" or "show" are allowed in "#[doc(auto_cfg(...))]"`
+  --> $DIR/doc-cfg.rs:11:7
    |
-LL | #[doc(cfg(), cfg(foo, bar))]
-   |       ^^^^^ help: expected syntax is: `cfg(/* predicate */)`
+LL | #[doc(auto_cfg(42))]
+   |       ^^^^^^^^^^^^
+   |
+   = note: `#[deny(invalid_doc_attributes)]` on by default
 
-error: multiple `cfg` predicates are specified
-  --> $DIR/doc-cfg.rs:3:23
+error: `#![doc(auto_cfg(hide(...)))]` only accepts identifiers or key/value items
+  --> $DIR/doc-cfg.rs:12:21
    |
-LL | #[doc(cfg(), cfg(foo, bar))]
-   |                       ^^^
+LL | #[doc(auto_cfg(hide(true)))]
+   |                     ^^^^
 
-error: `cfg` predicate is not specified
-  --> $DIR/doc-cfg.rs:9:7
+error: `#![doc(auto_cfg(hide(...)))]` only accepts identifiers or key/value items
+  --> $DIR/doc-cfg.rs:13:21
    |
-LL | #[doc(cfg())]
-   |       ^^^^^ help: expected syntax is: `cfg(/* predicate */)`
+LL | #[doc(auto_cfg(hide(42)))]
+   |                     ^^
 
-error: multiple `cfg` predicates are specified
-  --> $DIR/doc-cfg.rs:10:16
+error: `#![doc(auto_cfg(hide(...)))]` only accepts identifiers or key/value items
+  --> $DIR/doc-cfg.rs:14:21
    |
-LL | #[doc(cfg(foo, bar))]
-   |                ^^^
+LL | #[doc(auto_cfg(hide("a")))]
+   |                     ^^^
+
+error: `#![doc(auto_cfg(hide(...)))]` only accepts identifiers or key/value items
+  --> $DIR/doc-cfg.rs:15:21
+   |
+LL | #[doc(auto_cfg(hide(foo::bar)))]
+   |                     ^^^^^^^^
 
 warning: unexpected `cfg` condition name: `foo`
   --> $DIR/doc-cfg.rs:6:11
@@ -42,5 +50,29 @@ LL | #[doc(cfg(foo), cfg(bar))]
    = help: to expect this configuration use `--check-cfg=cfg(bar)`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
 
-error: aborting due to 4 previous errors; 2 warnings emitted
+error: `cfg` predicate is not specified
+  --> $DIR/doc-cfg.rs:3:7
+   |
+LL | #[doc(cfg(), cfg(foo, bar))]
+   |       ^^^^^ help: expected syntax is: `cfg(/* predicate */)`
+
+error: multiple `cfg` predicates are specified
+  --> $DIR/doc-cfg.rs:3:23
+   |
+LL | #[doc(cfg(), cfg(foo, bar))]
+   |                       ^^^
+
+error: `cfg` predicate is not specified
+  --> $DIR/doc-cfg.rs:9:7
+   |
+LL | #[doc(cfg())]
+   |       ^^^^^ help: expected syntax is: `cfg(/* predicate */)`
+
+error: multiple `cfg` predicates are specified
+  --> $DIR/doc-cfg.rs:10:16
+   |
+LL | #[doc(cfg(foo, bar))]
+   |                ^^^
+
+error: aborting due to 9 previous errors; 2 warnings emitted
 
diff --git a/tests/rustdoc-ui/feature-gate-doc_cfg.rs b/tests/rustdoc-ui/feature-gate-doc_cfg.rs
new file mode 100644
index 0000000000000..b474a1524bc19
--- /dev/null
+++ b/tests/rustdoc-ui/feature-gate-doc_cfg.rs
@@ -0,0 +1,6 @@
+#![doc(auto_cfg)] //~ ERROR
+#![doc(auto_cfg(false))] //~ ERROR
+#![doc(auto_cfg(true))] //~ ERROR
+#![doc(auto_cfg(hide(feature = "solecism")))] //~ ERROR
+#![doc(auto_cfg(show(feature = "bla")))] //~ ERROR
+#![doc(cfg(feature = "solecism"))] //~ ERROR
diff --git a/tests/rustdoc-ui/feature-gate-doc_cfg.stderr b/tests/rustdoc-ui/feature-gate-doc_cfg.stderr
new file mode 100644
index 0000000000000..68a86c1abb777
--- /dev/null
+++ b/tests/rustdoc-ui/feature-gate-doc_cfg.stderr
@@ -0,0 +1,63 @@
+error[E0658]: `#[doc(auto_cfg)]` is experimental
+  --> $DIR/feature-gate-doc_cfg.rs:1:1
+   |
+LL | #![doc(auto_cfg)]
+   | ^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #43781 <https://github.com/rust-lang/rust/issues/43781> for more information
+   = help: add `#![feature(doc_cfg)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: `#[doc(auto_cfg)]` is experimental
+  --> $DIR/feature-gate-doc_cfg.rs:2:1
+   |
+LL | #![doc(auto_cfg(false))]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #43781 <https://github.com/rust-lang/rust/issues/43781> for more information
+   = help: add `#![feature(doc_cfg)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: `#[doc(auto_cfg)]` is experimental
+  --> $DIR/feature-gate-doc_cfg.rs:3:1
+   |
+LL | #![doc(auto_cfg(true))]
+   | ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #43781 <https://github.com/rust-lang/rust/issues/43781> for more information
+   = help: add `#![feature(doc_cfg)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: `#[doc(auto_cfg)]` is experimental
+  --> $DIR/feature-gate-doc_cfg.rs:4:1
+   |
+LL | #![doc(auto_cfg(hide(feature = "solecism")))]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #43781 <https://github.com/rust-lang/rust/issues/43781> for more information
+   = help: add `#![feature(doc_cfg)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: `#[doc(auto_cfg)]` is experimental
+  --> $DIR/feature-gate-doc_cfg.rs:5:1
+   |
+LL | #![doc(auto_cfg(show(feature = "bla")))]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #43781 <https://github.com/rust-lang/rust/issues/43781> for more information
+   = help: add `#![feature(doc_cfg)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: `#[doc(cfg)]` is experimental
+  --> $DIR/feature-gate-doc_cfg.rs:6:1
+   |
+LL | #![doc(cfg(feature = "solecism"))]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #43781 <https://github.com/rust-lang/rust/issues/43781> for more information
+   = help: add `#![feature(doc_cfg)]` to the crate attributes to enable
+   = 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/rustdoc-ui/feature-gate-doc_cfg_hide.rs b/tests/rustdoc-ui/feature-gate-doc_cfg_hide.rs
deleted file mode 100644
index e49285a01b812..0000000000000
--- a/tests/rustdoc-ui/feature-gate-doc_cfg_hide.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-// FIXME: Remove this file once feature is removed
-
-#![doc(cfg_hide(test))] //~ ERROR
-
-#[cfg(not(test))]
-pub fn public_fn() {}
-#[cfg(test)]
-pub fn internal_use_only() {}
diff --git a/tests/rustdoc-ui/feature-gate-doc_cfg_hide.stderr b/tests/rustdoc-ui/feature-gate-doc_cfg_hide.stderr
deleted file mode 100644
index b3eee2af7f733..0000000000000
--- a/tests/rustdoc-ui/feature-gate-doc_cfg_hide.stderr
+++ /dev/null
@@ -1,10 +0,0 @@
-error: unknown `doc` attribute `cfg_hide`
-  --> $DIR/feature-gate-doc_cfg_hide.rs:3:8
-   |
-LL | #![doc(cfg_hide(test))]
-   |        ^^^^^^^^^^^^^^
-   |
-   = note: `#[deny(invalid_doc_attributes)]` on by default
-
-error: aborting due to 1 previous error
-
diff --git a/tests/rustdoc-ui/lints/doc_cfg_hide.stderr b/tests/rustdoc-ui/lints/doc_cfg_hide.stderr
index 9e820a77b5e54..c63c8d607fa02 100644
--- a/tests/rustdoc-ui/lints/doc_cfg_hide.stderr
+++ b/tests/rustdoc-ui/lints/doc_cfg_hide.stderr
@@ -12,7 +12,7 @@ error: `#![doc(auto_cfg(hide(...)))]` expects a list of items
 LL | #![doc(auto_cfg(hide))]
    |        ^^^^^^^^^^^^^^
 
-error: `#![doc(auto_cfg(hide(...)))]` only accepts identifiers or key/values items
+error: `#![doc(auto_cfg(hide(...)))]` only accepts identifiers or key/value items
   --> $DIR/doc_cfg_hide.rs:4:22
    |
 LL | #![doc(auto_cfg(hide(not(windows))))]

From fccba2c341b65b62f513c0b7ee8842f134f3cbcd Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 29 May 2025 21:54:16 +0200
Subject: [PATCH 1474/1889] Remove `doc_cfg_hide` feature

---
 compiler/rustc_feature/src/unstable.rs | 2 --
 compiler/rustc_span/src/symbol.rs      | 1 -
 library/alloc/src/lib.rs               | 2 +-
 library/core/src/lib.rs                | 2 +-
 library/std/src/lib.rs                 | 3 ++-
 5 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 6ef0df72365ec..4dc961cb92773 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -476,8 +476,6 @@ declare_features! (
     (unstable, doc_auto_cfg, "1.58.0", Some(43781)),
     /// Allows `#[doc(cfg(...))]`.
     (unstable, doc_cfg, "1.21.0", Some(43781)),
-    /// Allows `#[doc(cfg_hide(...))]`.
-    (unstable, doc_cfg_hide, "1.57.0", Some(43781)),
     /// Allows `#[doc(masked)]`.
     (unstable, doc_masked, "1.21.0", Some(44027)),
     /// Allows features to allow target_feature to better interact with traits.
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 18c3faed9329a..79f00e2e94dea 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -878,7 +878,6 @@ symbols! {
         doc_alias,
         doc_auto_cfg,
         doc_cfg,
-        doc_cfg_hide,
         doc_keyword,
         doc_masked,
         doc_notable_trait,
diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs
index dc5d243e8823a..24d7e6216a0dd 100644
--- a/library/alloc/src/lib.rs
+++ b/library/alloc/src/lib.rs
@@ -207,7 +207,7 @@
 //
 // Rustdoc features:
 #![feature(doc_cfg)]
-#![feature(doc_cfg_hide)]
+#![cfg_attr(bootstrap, feature(doc_cfg_hide))]
 // Technically, this is a bug in rustdoc: rustdoc sees the documentation on `#[lang = slice_alloc]`
 // blocks is for `&[T]`, which also has documentation using this feature in `core`, and gets mad
 // that the feature-gate isn't enabled. Ideally, it wouldn't check for the feature gate for docs
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 32a3d6c7042aa..b1e559065fe49 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -161,6 +161,7 @@
 //
 // Language features:
 // tidy-alphabetical-start
+#![cfg_attr(bootstrap, feature(doc_cfg_hide))]
 #![feature(abi_unadjusted)]
 #![feature(adt_const_params)]
 #![feature(allow_internal_unsafe)]
@@ -176,7 +177,6 @@
 #![feature(deprecated_suggestion)]
 #![feature(derive_const)]
 #![feature(doc_cfg)]
-#![feature(doc_cfg_hide)]
 #![feature(doc_notable_trait)]
 #![feature(extern_types)]
 #![feature(f16)]
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index ecd354f599e4c..ff997ff7603be 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -278,6 +278,8 @@
 // tidy-alphabetical-start
 
 // stabilization was reverted after it hit beta
+#![cfg_attr(bootstrap, feature(doc_cfg_hide))]
+#![cfg_attr(not(bootstrap), feature(autodiff))]
 #![feature(alloc_error_handler)]
 #![feature(allocator_internals)]
 #![feature(allow_internal_unsafe)]
@@ -293,7 +295,6 @@
 #![feature(decl_macro)]
 #![feature(deprecated_suggestion)]
 #![feature(doc_cfg)]
-#![feature(doc_cfg_hide)]
 #![feature(doc_masked)]
 #![feature(doc_notable_trait)]
 #![feature(dropck_eyepatch)]

From a7ed9bf6c7473827b7c876679a2a633facec09b8 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 2 Jun 2025 22:19:33 +0200
Subject: [PATCH 1475/1889] fmt

---
 library/alloc/src/lib.rs       | 7 +------
 library/std/src/lib.rs         | 6 +-----
 src/librustdoc/doctest/rust.rs | 8 +++-----
 3 files changed, 5 insertions(+), 16 deletions(-)

diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs
index 24d7e6216a0dd..7499db8bf2c1d 100644
--- a/library/alloc/src/lib.rs
+++ b/library/alloc/src/lib.rs
@@ -77,12 +77,7 @@
 )]
 #![cfg_attr(
     not(bootstrap),
-    doc(auto_cfg(hide(
-        no_global_oom_handling,
-        no_rc,
-        no_sync,
-        target_has_atomic = "ptr"
-    )))
+    doc(auto_cfg(hide(no_global_oom_handling, no_rc, no_sync, target_has_atomic = "ptr")))
 )]
 #![doc(rust_logo)]
 #![feature(rustdoc_internals)]
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index ff997ff7603be..c8fe5c55e9709 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -237,11 +237,7 @@
 #![doc(rust_logo)]
 #![cfg_attr(
     bootstrap,
-    doc(cfg_hide(
-        not(test),
-        no_global_oom_handling,
-        not(no_global_oom_handling)
-    ))
+    doc(cfg_hide(not(test), no_global_oom_handling, not(no_global_oom_handling)))
 )]
 #![cfg_attr(not(bootstrap), doc(auto_cfg(hide(no_global_oom_handling))))]
 // Don't link to std. We are std.
diff --git a/src/librustdoc/doctest/rust.rs b/src/librustdoc/doctest/rust.rs
index b9367b880057f..4d3f976c2a6d5 100644
--- a/src/librustdoc/doctest/rust.rs
+++ b/src/librustdoc/doctest/rust.rs
@@ -119,11 +119,9 @@ impl HirCollector<'_> {
         nested: F,
     ) {
         let ast_attrs = self.tcx.hir_attrs(self.tcx.local_def_id_to_hir_id(def_id));
-        if let Some(ref cfg) = extract_cfg_from_attrs(
-            ast_attrs.iter(),
-            self.tcx,
-            &mut CfgInfo::default(),
-        ) && !cfg.matches(&self.tcx.sess.psess)
+        if let Some(ref cfg) =
+            extract_cfg_from_attrs(ast_attrs.iter(), self.tcx, &mut CfgInfo::default())
+            && !cfg.matches(&self.tcx.sess.psess)
         {
             return;
         }

From ec00723ba153c72124f8271b6dc15540f23e6832 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Wed, 4 Jun 2025 13:34:41 +0200
Subject: [PATCH 1476/1889] Fix autodiff feature activation

---
 library/std/src/lib.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index c8fe5c55e9709..501c22cfb4947 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -275,7 +275,6 @@
 
 // stabilization was reverted after it hit beta
 #![cfg_attr(bootstrap, feature(doc_cfg_hide))]
-#![cfg_attr(not(bootstrap), feature(autodiff))]
 #![feature(alloc_error_handler)]
 #![feature(allocator_internals)]
 #![feature(allow_internal_unsafe)]

From 254a2139f6c4b251d9210843d2e7d7952ef9f40d Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 10 Jun 2025 17:44:14 +0200
Subject: [PATCH 1477/1889] Remove `cfg(bootstrap)` for `doc_cfg` feature
 following #141925

---
 library/alloc/src/lib.rs | 17 +---------
 library/core/src/lib.rs  | 70 ++++++++++++----------------------------
 library/std/src/lib.rs   |  7 +---
 3 files changed, 23 insertions(+), 71 deletions(-)

diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs
index 7499db8bf2c1d..fc3266b74793c 100644
--- a/library/alloc/src/lib.rs
+++ b/library/alloc/src/lib.rs
@@ -64,21 +64,7 @@
     issue_tracker_base_url = "https://github.com/rust-lang/rust/issues/",
     test(no_crate_inject, attr(allow(unused_variables), deny(warnings)))
 )]
-#![cfg_attr(
-    bootstrap,
-    doc(cfg_hide(
-        not(test),
-        no_global_oom_handling,
-        not(no_global_oom_handling),
-        not(no_rc),
-        not(no_sync),
-        target_has_atomic = "ptr"
-    ))
-)]
-#![cfg_attr(
-    not(bootstrap),
-    doc(auto_cfg(hide(no_global_oom_handling, no_rc, no_sync, target_has_atomic = "ptr")))
-)]
+#![doc(auto_cfg(hide(no_global_oom_handling, no_rc, no_sync, target_has_atomic = "ptr")))]
 #![doc(rust_logo)]
 #![feature(rustdoc_internals)]
 #![no_std]
@@ -202,7 +188,6 @@
 //
 // Rustdoc features:
 #![feature(doc_cfg)]
-#![cfg_attr(bootstrap, feature(doc_cfg_hide))]
 // Technically, this is a bug in rustdoc: rustdoc sees the documentation on `#[lang = slice_alloc]`
 // blocks is for `&[T]`, which also has documentation using this feature in `core`, and gets mad
 // that the feature-gate isn't enabled. Ideally, it wouldn't check for the feature gate for docs
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index b1e559065fe49..54adf97f10020 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -51,54 +51,27 @@
     test(attr(allow(dead_code, deprecated, unused_variables, unused_mut)))
 )]
 #![doc(rust_logo)]
-#![cfg_attr(
-    bootstrap,
-    doc(cfg_hide(
-        no_fp_fmt_parse,
-        target_pointer_width = "16",
-        target_pointer_width = "32",
-        target_pointer_width = "64",
-        target_has_atomic = "8",
-        target_has_atomic = "16",
-        target_has_atomic = "32",
-        target_has_atomic = "64",
-        target_has_atomic = "ptr",
-        target_has_atomic_equal_alignment = "8",
-        target_has_atomic_equal_alignment = "16",
-        target_has_atomic_equal_alignment = "32",
-        target_has_atomic_equal_alignment = "64",
-        target_has_atomic_equal_alignment = "ptr",
-        target_has_atomic_load_store = "8",
-        target_has_atomic_load_store = "16",
-        target_has_atomic_load_store = "32",
-        target_has_atomic_load_store = "64",
-        target_has_atomic_load_store = "ptr",
-    ))
-)]
-#![cfg_attr(
-    not(bootstrap),
-    doc(auto_cfg(hide(
-        no_fp_fmt_parse,
-        target_pointer_width = "16",
-        target_pointer_width = "32",
-        target_pointer_width = "64",
-        target_has_atomic = "8",
-        target_has_atomic = "16",
-        target_has_atomic = "32",
-        target_has_atomic = "64",
-        target_has_atomic = "ptr",
-        target_has_atomic_equal_alignment = "8",
-        target_has_atomic_equal_alignment = "16",
-        target_has_atomic_equal_alignment = "32",
-        target_has_atomic_equal_alignment = "64",
-        target_has_atomic_equal_alignment = "ptr",
-        target_has_atomic_load_store = "8",
-        target_has_atomic_load_store = "16",
-        target_has_atomic_load_store = "32",
-        target_has_atomic_load_store = "64",
-        target_has_atomic_load_store = "ptr",
-    )))
-)]
+#![doc(auto_cfg(hide(
+    no_fp_fmt_parse,
+    target_pointer_width = "16",
+    target_pointer_width = "32",
+    target_pointer_width = "64",
+    target_has_atomic = "8",
+    target_has_atomic = "16",
+    target_has_atomic = "32",
+    target_has_atomic = "64",
+    target_has_atomic = "ptr",
+    target_has_atomic_equal_alignment = "8",
+    target_has_atomic_equal_alignment = "16",
+    target_has_atomic_equal_alignment = "32",
+    target_has_atomic_equal_alignment = "64",
+    target_has_atomic_equal_alignment = "ptr",
+    target_has_atomic_load_store = "8",
+    target_has_atomic_load_store = "16",
+    target_has_atomic_load_store = "32",
+    target_has_atomic_load_store = "64",
+    target_has_atomic_load_store = "ptr",
+)))]
 #![no_core]
 #![rustc_coherence_is_core]
 #![rustc_preserve_ub_checks]
@@ -161,7 +134,6 @@
 //
 // Language features:
 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(doc_cfg_hide))]
 #![feature(abi_unadjusted)]
 #![feature(adt_const_params)]
 #![feature(allow_internal_unsafe)]
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index 501c22cfb4947..61b7d170b8ba6 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -235,11 +235,7 @@
     test(attr(allow(dead_code, deprecated, unused_variables, unused_mut)))
 )]
 #![doc(rust_logo)]
-#![cfg_attr(
-    bootstrap,
-    doc(cfg_hide(not(test), no_global_oom_handling, not(no_global_oom_handling)))
-)]
-#![cfg_attr(not(bootstrap), doc(auto_cfg(hide(no_global_oom_handling))))]
+#![doc(auto_cfg(hide(no_global_oom_handling)))]
 // Don't link to std. We are std.
 #![no_std]
 // Tell the compiler to link to either panic_abort or panic_unwind
@@ -274,7 +270,6 @@
 // tidy-alphabetical-start
 
 // stabilization was reverted after it hit beta
-#![cfg_attr(bootstrap, feature(doc_cfg_hide))]
 #![feature(alloc_error_handler)]
 #![feature(allocator_internals)]
 #![feature(allow_internal_unsafe)]

From 6fecff45d915b31eee3170f32fedb6db045611f1 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 1 Jul 2025 17:00:21 +0200
Subject: [PATCH 1478/1889] Fix `tests/rustdoc/target-feature.rs` test by
 adding missing `#![feature(doc_cfg)]`

---
 tests/rustdoc/target-feature.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/rustdoc/target-feature.rs b/tests/rustdoc/target-feature.rs
index 59a08a0ca949e..f2686f81fbff0 100644
--- a/tests/rustdoc/target-feature.rs
+++ b/tests/rustdoc/target-feature.rs
@@ -1,3 +1,5 @@
+#![feature(doc_cfg)]
+
 #![crate_name = "foo"]
 
 //@ has 'foo/index.html'

From ef8b2a26caccba46584e4753c3091218d4a2e17d Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 3 Jul 2025 20:05:02 +0200
Subject: [PATCH 1479/1889] Correctly handle target_feature in rustdoc cfg

---
 src/librustdoc/clean/types.rs | 37 +++++++++++------------------------
 1 file changed, 11 insertions(+), 26 deletions(-)

diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index 605b77109a061..c8e9f3dc479f6 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -1153,35 +1153,20 @@ pub(crate) fn extract_cfg_from_attrs<'a, I: Iterator<Item = &'a hir::Attribute>
     // If there is no `doc(cfg())`, then we retrieve the `cfg()` attributes (because
     // `doc(cfg())` overrides `cfg()`).
     for attr in attrs {
-        let Some(ident) = attr.ident() else { continue };
-        match ident.name {
-            sym::cfg | sym::cfg_trace if !cfg_info.parent_is_doc_cfg => {
-                if let Some(attr) = single(attr.meta_item_list()?)
-                    && let Ok(new_cfg) = Cfg::parse(&attr)
-                {
-                    cfg_info.current_cfg &= new_cfg;
-                }
-            }
+        if let hir::Attribute::Parsed(AttributeKind::TargetFeature { features, .. }) = attr {
             // treat #[target_feature(enable = "feat")] attributes as if they were
             // #[doc(cfg(target_feature = "feat"))] attributes as well
-            sym::target_feature
-                if let Some(attrs) = attr.meta_item_list() =>
-            {
-                for attr in attrs {
-                    if attr.has_name(sym::enable) && attr.value_str().is_some() {
-                        // Clone `enable = "feat"`, change to `target_feature = "feat"`.
-                        // Unwrap is safe because `value_str` succeeded above.
-                        let mut meta = attr.meta_item().unwrap().clone();
-                        meta.path =
-                            ast::Path::from_ident(Ident::with_dummy_span(sym::target_feature));
-
-                        if let Ok(feat_cfg) = Cfg::parse(&ast::MetaItemInner::MetaItem(meta)) {
-                            cfg_info.current_cfg &= feat_cfg;
-                        }
-                    }
-                }
+            for (feature, _) in features {
+                cfg_info.current_cfg &= Cfg::Cfg(sym::target_feature, Some(*feature));
             }
-            _ => {}
+            continue;
+        } else if !cfg_info.parent_is_doc_cfg
+            && let Some(ident) = attr.ident()
+            && matches!(ident.name, sym::cfg | sym::cfg_trace)
+            && let Some(attr) = single(attr.meta_item_list()?)
+            && let Ok(new_cfg) = Cfg::parse(&attr)
+        {
+            cfg_info.current_cfg &= new_cfg;
         }
     }
 

From 77885fef2cd9a7f9daa4f95336f0cfdeb62b3016 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 26 Aug 2025 16:03:12 +0200
Subject: [PATCH 1480/1889] Improve code comments and extend tests for
 `doc_cfg` feature

---
 src/librustdoc/clean/types.rs           |  6 ++++--
 tests/rustdoc-ui/doc-cfg.rs             |  2 ++
 tests/rustdoc-ui/doc-cfg.stderr         | 14 +++++++++++++-
 tests/rustdoc/doc_auto_cfg_reexports.rs | 13 +++++++++++++
 4 files changed, 32 insertions(+), 3 deletions(-)

diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index c8e9f3dc479f6..8b8cf19d8e418 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -925,7 +925,8 @@ pub(crate) fn hir_attr_lists<'a, I: IntoIterator<Item = &'a hir::Attribute>>(
 /// This type keeps track of (doc) cfg information as we go down the item tree.
 #[derive(Clone, Debug)]
 pub(crate) struct CfgInfo {
-    /// List of `doc(auto_cfg(hide(...)))` cfgs.
+    /// List of currently active `doc(auto_cfg(hide(...)))` cfgs,minus currently active
+    /// `doc(auto_cfg(show(...)))` cfgs.
     hidden_cfg: FxHashSet<Cfg>,
     /// Current computed `cfg`. Each time we enter a new item, this field is updated as well while
     /// taking into account the `hidden_cfg` information.
@@ -1181,7 +1182,8 @@ pub(crate) fn extract_cfg_from_attrs<'a, I: Iterator<Item = &'a hir::Attribute>
             Some(Arc::new(cfg_info.current_cfg.clone()))
         }
     } else {
-        // Since we always want to collect all `cfg` items, we remove the hidden ones afterward.
+        // If `doc(auto_cfg)` feature is enabled, we want to collect all `cfg` items, we remove the
+        // hidden ones afterward.
         match cfg_info.current_cfg.strip_hidden(&cfg_info.hidden_cfg) {
             None | Some(Cfg::True) => None,
             Some(cfg) => Some(Arc::new(cfg)),
diff --git a/tests/rustdoc-ui/doc-cfg.rs b/tests/rustdoc-ui/doc-cfg.rs
index 9840c305290ae..d72643e23556b 100644
--- a/tests/rustdoc-ui/doc-cfg.rs
+++ b/tests/rustdoc-ui/doc-cfg.rs
@@ -13,6 +13,8 @@
 #[doc(auto_cfg(hide(42)))] //~ ERROR
 #[doc(auto_cfg(hide("a")))] //~ ERROR
 #[doc(auto_cfg(hide(foo::bar)))] //~ ERROR
+#[doc(auto_cfg = 42)] //~ ERROR
+#[doc(auto_cfg = "a")] //~ ERROR
 // Shouldn't lint
 #[doc(auto_cfg(hide(windows)))]
 #[doc(auto_cfg(hide(feature = "windows")))]
diff --git a/tests/rustdoc-ui/doc-cfg.stderr b/tests/rustdoc-ui/doc-cfg.stderr
index 36ca18eed8fc8..13f62e50d907c 100644
--- a/tests/rustdoc-ui/doc-cfg.stderr
+++ b/tests/rustdoc-ui/doc-cfg.stderr
@@ -30,6 +30,18 @@ error: `#![doc(auto_cfg(hide(...)))]` only accepts identifiers or key/value item
 LL | #[doc(auto_cfg(hide(foo::bar)))]
    |                     ^^^^^^^^
 
+error: `expected boolean for #[doc(auto_cfg = ...)]`
+  --> $DIR/doc-cfg.rs:16:7
+   |
+LL | #[doc(auto_cfg = 42)]
+   |       ^^^^^^^^^^^^^
+
+error: `expected boolean for #[doc(auto_cfg = ...)]`
+  --> $DIR/doc-cfg.rs:17:7
+   |
+LL | #[doc(auto_cfg = "a")]
+   |       ^^^^^^^^^^^^^^
+
 warning: unexpected `cfg` condition name: `foo`
   --> $DIR/doc-cfg.rs:6:11
    |
@@ -74,5 +86,5 @@ error: multiple `cfg` predicates are specified
 LL | #[doc(cfg(foo, bar))]
    |                ^^^
 
-error: aborting due to 9 previous errors; 2 warnings emitted
+error: aborting due to 11 previous errors; 2 warnings emitted
 
diff --git a/tests/rustdoc/doc_auto_cfg_reexports.rs b/tests/rustdoc/doc_auto_cfg_reexports.rs
index f6315e9d49dde..ecfe9aabcfed4 100644
--- a/tests/rustdoc/doc_auto_cfg_reexports.rs
+++ b/tests/rustdoc/doc_auto_cfg_reexports.rs
@@ -20,3 +20,16 @@ mod x {
 //      'Available on non-crate feature pistache only.'
 #[cfg(not(feature = "pistache"))]
 pub use crate::x::B;
+
+// Now checking that `cfg`s are not applied on non-inlined reexports.
+pub mod pub_sub_mod {
+    //@ has 'foo/pub_sub_mod/index.html'
+    // There should be only only item with `cfg` note.
+    //@ count - '//*[@class="stab portability"]' 1
+    // And obviously the item should be "blabla".
+    //@ has - '//dt' 'blablaNon-pistache'
+    #[cfg(not(feature = "pistache"))]
+    pub fn blabla() {}
+
+    pub use self::blabla as another;
+}

From 653e1036ed5a343a7be7b2a73096c138efc51523 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 22 Sep 2025 13:58:02 +0200
Subject: [PATCH 1481/1889] Apply first review round suggestions

---
 compiler/rustc_feature/src/removed.rs      |  2 ++
 compiler/rustc_passes/messages.ftl         |  4 ++--
 compiler/rustc_span/src/symbol.rs          |  1 +
 src/librustdoc/passes/propagate_doc_cfg.rs | 14 +-------------
 src/librustdoc/visit_ast.rs                |  2 +-
 tests/rustdoc-ui/doc-cfg.stderr            |  6 +++---
 6 files changed, 10 insertions(+), 19 deletions(-)

diff --git a/compiler/rustc_feature/src/removed.rs b/compiler/rustc_feature/src/removed.rs
index 32115535e9941..71365da316cef 100644
--- a/compiler/rustc_feature/src/removed.rs
+++ b/compiler/rustc_feature/src/removed.rs
@@ -101,6 +101,8 @@ declare_features! (
      Some("never properly implemented; requires significant design work"), 127655),
     /// Allows deriving traits as per `SmartPointer` specification
     (removed, derive_smart_pointer, "1.84.0", Some(123430), Some("replaced by `CoercePointee`"), 131284),
+    /// Allows `#[doc(cfg_hide(...))]`.
+    (removed, doc_cfg_hide, "1.57.0", Some(43781), Some("merged into `doc_cfg`"), 138907),
     /// Allows using `#[doc(keyword = "...")]`.
     (removed, doc_keyword, "1.58.0", Some(51315),
      Some("merged into `#![feature(rustdoc_internals)]`"), 90420),
diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index a5ff169e638c9..21fc1124c2f5d 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -144,7 +144,7 @@ passes_doc_cfg_hide_takes_list =
     `#[doc(cfg_hide(...))]` takes a list of attributes
 
 passes_doc_auto_cfg_expects_hide_or_show =
-    `only "hide" or "show" are allowed in "#[doc(auto_cfg(...))]"`
+    only `hide` or `show` are allowed in `#[doc(auto_cfg(...))]`
 
 passes_doc_auto_cfg_hide_show_expects_list =
     `#![doc(auto_cfg({$attr_name}(...)))]` expects a list of items
@@ -153,7 +153,7 @@ passes_doc_auto_cfg_hide_show_unexpected_item =
     `#![doc(auto_cfg({$attr_name}(...)))]` only accepts identifiers or key/value items
 
 passes_doc_auto_cfg_wrong_literal =
-    `expected boolean for #[doc(auto_cfg = ...)]`
+    expected boolean for `#[doc(auto_cfg = ...)]`
 
 passes_doc_expect_str =
     doc {$attr_name} attribute expects a string: #[doc({$attr_name} = "a")]
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 79f00e2e94dea..18c3faed9329a 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -878,6 +878,7 @@ symbols! {
         doc_alias,
         doc_auto_cfg,
         doc_cfg,
+        doc_cfg_hide,
         doc_keyword,
         doc_masked,
         doc_notable_trait,
diff --git a/src/librustdoc/passes/propagate_doc_cfg.rs b/src/librustdoc/passes/propagate_doc_cfg.rs
index ea77065ac0799..4bcb60a9a40de 100644
--- a/src/librustdoc/passes/propagate_doc_cfg.rs
+++ b/src/librustdoc/passes/propagate_doc_cfg.rs
@@ -33,19 +33,7 @@ struct CfgPropagator<'a, 'tcx> {
 /// Returns true if the provided `token` is a `cfg` ident.
 fn is_cfg_token(token: &TokenTree) -> bool {
     // We only keep `doc(cfg)` items.
-    matches!(
-        token,
-        TokenTree::Token(
-            Token {
-                kind: TokenKind::Ident(
-                    ident,
-                    _,
-                ),
-                ..
-            },
-            _,
-        ) if *ident == sym::cfg,
-    )
+    matches!(token, TokenTree::Token(Token { kind: TokenKind::Ident(sym::cfg, _,), .. }, _,),)
 }
 
 /// We only want to keep `#[cfg()]` and `#[doc(cfg())]` attributes so we rebuild a vec of
diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs
index ac67871b0cb73..dc9889cec2193 100644
--- a/src/librustdoc/visit_ast.rs
+++ b/src/librustdoc/visit_ast.rs
@@ -9,7 +9,7 @@ use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def::{DefKind, MacroKinds, Res};
 use rustc_hir::def_id::{DefId, DefIdMap, LocalDefId, LocalDefIdSet};
 use rustc_hir::intravisit::{Visitor, walk_body, walk_item};
-use rustc_hir::{CRATE_HIR_ID, Node, find_attr};
+use rustc_hir::{Node, find_attr};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::TyCtxt;
 use rustc_span::Span;
diff --git a/tests/rustdoc-ui/doc-cfg.stderr b/tests/rustdoc-ui/doc-cfg.stderr
index 13f62e50d907c..49e8c324facfd 100644
--- a/tests/rustdoc-ui/doc-cfg.stderr
+++ b/tests/rustdoc-ui/doc-cfg.stderr
@@ -1,4 +1,4 @@
-error: `only "hide" or "show" are allowed in "#[doc(auto_cfg(...))]"`
+error: only `hide` or `show` are allowed in `#[doc(auto_cfg(...))]`
   --> $DIR/doc-cfg.rs:11:7
    |
 LL | #[doc(auto_cfg(42))]
@@ -30,13 +30,13 @@ error: `#![doc(auto_cfg(hide(...)))]` only accepts identifiers or key/value item
 LL | #[doc(auto_cfg(hide(foo::bar)))]
    |                     ^^^^^^^^
 
-error: `expected boolean for #[doc(auto_cfg = ...)]`
+error: expected boolean for `#[doc(auto_cfg = ...)]`
   --> $DIR/doc-cfg.rs:16:7
    |
 LL | #[doc(auto_cfg = 42)]
    |       ^^^^^^^^^^^^^
 
-error: `expected boolean for #[doc(auto_cfg = ...)]`
+error: expected boolean for `#[doc(auto_cfg = ...)]`
   --> $DIR/doc-cfg.rs:17:7
    |
 LL | #[doc(auto_cfg = "a")]

From 9362ab549f87e535eeba12c5d42f584ff55ff886 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 25 Sep 2025 11:33:58 +0200
Subject: [PATCH 1482/1889] Improve code and fix typo

---
 compiler/rustc_passes/messages.ftl         |  3 --
 compiler/rustc_passes/src/check_attr.rs    | 41 +++++++--------------
 compiler/rustc_passes/src/errors.rs        |  8 ++---
 compiler/rustc_span/src/symbol.rs          |  1 -
 src/doc/rustdoc/src/unstable-features.md   | 42 +++++++++++-----------
 src/librustdoc/clean/types.rs              | 10 +++---
 src/librustdoc/passes/propagate_doc_cfg.rs |  3 +-
 7 files changed, 43 insertions(+), 65 deletions(-)

diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index 21fc1124c2f5d..df4016dfa1b82 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -140,9 +140,6 @@ passes_doc_attribute_not_attribute =
     nonexistent builtin attribute `{$attribute}` used in `#[doc(attribute = "...")]`
     .help = only existing builtin attributes are allowed in core/std
 
-passes_doc_cfg_hide_takes_list =
-    `#[doc(cfg_hide(...))]` takes a list of attributes
-
 passes_doc_auto_cfg_expects_hide_or_show =
     only `hide` or `show` are allowed in `#[doc(auto_cfg(...))]`
 
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 88b49c781e75c..4ea237cfa0321 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -1160,7 +1160,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         }
     }
 
-    /// Check that the `#![doc(auto_cfg(..))]` attribute has expected input.
+    /// Check that the `#![doc(auto_cfg)]` attribute has the expected input.
     fn check_doc_auto_cfg(&self, meta: &MetaItem, hir_id: HirId) {
         match &meta.kind {
             MetaItemKind::Word => {}
@@ -1176,7 +1176,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             }
             MetaItemKind::List(list) => {
                 for item in list {
-                    let Some(attr_name) = item.name() else {
+                    let Some(attr_name @ (sym::hide | sym::show)) = item.name() else {
                         self.tcx.emit_node_span_lint(
                             INVALID_DOC_ATTRIBUTES,
                             hir_id,
@@ -1185,36 +1185,21 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         );
                         continue;
                     };
-                    if attr_name != sym::hide && attr_name != sym::show {
-                        self.tcx.emit_node_span_lint(
-                            INVALID_DOC_ATTRIBUTES,
-                            hir_id,
-                            meta.span,
-                            errors::DocAutoCfgExpectsHideOrShow,
-                        );
-                    } else if let Some(list) = item.meta_item_list() {
+                    if let Some(list) = item.meta_item_list() {
                         for item in list {
-                            if item.meta_item_list().is_some() {
-                                self.tcx.emit_node_span_lint(
-                                    INVALID_DOC_ATTRIBUTES,
-                                    hir_id,
-                                    item.span(),
-                                    errors::DocAutoCfgHideShowUnexpectedItem {
-                                        attr_name: attr_name.as_str(),
-                                    },
-                                );
-                            } else if match item {
-                                MetaItemInner::Lit(_) => true,
-                                // We already checked above that it's not a list.
-                                MetaItemInner::MetaItem(meta) => meta.path.segments.len() != 1,
-                            } {
+                            let valid = item.meta_item().is_some_and(|meta| {
+                                meta.path.segments.len() == 1
+                                    && matches!(
+                                        &meta.kind,
+                                        MetaItemKind::Word | MetaItemKind::NameValue(_)
+                                    )
+                            });
+                            if !valid {
                                 self.tcx.emit_node_span_lint(
                                     INVALID_DOC_ATTRIBUTES,
                                     hir_id,
                                     item.span(),
-                                    errors::DocAutoCfgHideShowUnexpectedItem {
-                                        attr_name: attr_name.as_str(),
-                                    },
+                                    errors::DocAutoCfgHideShowUnexpectedItem { attr_name },
                                 );
                             }
                         }
@@ -1223,7 +1208,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                             INVALID_DOC_ATTRIBUTES,
                             hir_id,
                             meta.span,
-                            errors::DocAutoCfgHideShowExpectsList { attr_name: attr_name.as_str() },
+                            errors::DocAutoCfgHideShowExpectsList { attr_name },
                         );
                     }
                 }
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index 1d2428c4f9a05..f0726014e0afa 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -318,14 +318,14 @@ pub(crate) struct DocAutoCfgExpectsHideOrShow;
 
 #[derive(LintDiagnostic)]
 #[diag(passes_doc_auto_cfg_hide_show_expects_list)]
-pub(crate) struct DocAutoCfgHideShowExpectsList<'a> {
-    pub attr_name: &'a str,
+pub(crate) struct DocAutoCfgHideShowExpectsList {
+    pub attr_name: Symbol,
 }
 
 #[derive(LintDiagnostic)]
 #[diag(passes_doc_auto_cfg_hide_show_unexpected_item)]
-pub(crate) struct DocAutoCfgHideShowUnexpectedItem<'a> {
-    pub attr_name: &'a str,
+pub(crate) struct DocAutoCfgHideShowUnexpectedItem {
+    pub attr_name: Symbol,
 }
 
 #[derive(LintDiagnostic)]
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 18c3faed9329a..cd422da0c1c83 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -629,7 +629,6 @@ symbols! {
         cfg_emscripten_wasm_eh,
         cfg_eval,
         cfg_fmt_debug,
-        cfg_hide,
         cfg_overflow_checks,
         cfg_panic,
         cfg_relocation_model,
diff --git a/src/doc/rustdoc/src/unstable-features.md b/src/doc/rustdoc/src/unstable-features.md
index cfa1936f3d7fc..04d3c0cd630f5 100644
--- a/src/doc/rustdoc/src/unstable-features.md
+++ b/src/doc/rustdoc/src/unstable-features.md
@@ -720,9 +720,9 @@ pass `--doctest-build-arg ARG` for each argument `ARG`.
 
 This flag enables the generation of toggles to expand macros in the HTML source code pages.
 
-## `#[doc(cfg)]`
+## `#[doc(cfg)]` and `#[doc(auto_cfg)]`
 
-This feature aims at providing rustdoc users the possibility to add visual markers to the rendered documentation to know under which conditions an item is available (currently possible through the following unstable features: `doc_cfg`, `doc_auto_cfg` and `doc_cfg_hide`).
+This feature aims at providing rustdoc users the possibility to add visual markers to the rendered documentation to know under which conditions an item is available (currently possible through the following unstable feature: `doc_cfg`).
 
 It does not aim to allow having a same item with different `cfg`s to appear more than once in the generated documentation.
 
@@ -736,25 +736,6 @@ This features adds the following attributes:
 
 All of these attributes can be added to a module or to the crate root, and they will be inherited by the child items unless another attribute overrides it. This is why "opposite" attributes like `auto_cfg(hide(...))` and `auto_cfg(show(...))` are provided: they allow a child item to override its parent.
 
-### `#[doc(auto_cfg)`/`#[doc(auto_cfg = true)]`/`#[doc(auto_cfg = false)]`
-
-By default, `#[doc(auto_cfg)]` is enabled at the crate-level. When it's enabled, Rustdoc will automatically display `cfg(...)` compatibility information as-if the same `#[doc(cfg(...))]` had been specified.
-
-This attribute impacts the item on which it is used and its descendants.
-
-So if we take back the previous example:
-
-```rust
-#[cfg(feature = "futures-io")]
-pub mod futures {}
-```
-
-There's no need to "duplicate" the `cfg` into a `doc(cfg())` to make Rustdoc display it.
-
-In some situations, the detailed conditional compilation rules used to implement the feature might not serve as good documentation (for example, the list of supported platforms might be very long, and it might be better to document them in one place). To turn it off, add the `#[doc(auto_cfg = false)]` attribute on the item.
-
-If no argument is specified (ie `#[doc(auto_cfg)]`), it's the same as writing `#[doc(auto_cfg = true)]`.
-
 ### `#[doc(cfg(...))]`
 
 This attribute provides a standardized format to override `#[cfg()]` attributes to document conditionally available items. Example:
@@ -927,6 +908,25 @@ Using this attribute will re-enable `auto_cfg` if it was disabled at this locati
 pub fn foo() {}
 ```
 
+### `#[doc(auto_cfg)`/`#[doc(auto_cfg = true)]`/`#[doc(auto_cfg = false)]`
+
+By default, `#[doc(auto_cfg)]` is enabled at the crate-level. When it's enabled, Rustdoc will automatically display `cfg(...)` compatibility information as-if the same `#[doc(cfg(...))]` had been specified.
+
+This attribute impacts the item on which it is used and its descendants.
+
+So if we take back the previous example:
+
+```rust
+#[cfg(feature = "futures-io")]
+pub mod futures {}
+```
+
+There's no need to "duplicate" the `cfg` into a `doc(cfg())` to make Rustdoc display it.
+
+In some situations, the detailed conditional compilation rules used to implement the feature might not serve as good documentation (for example, the list of supported platforms might be very long, and it might be better to document them in one place). To turn it off, add the `#[doc(auto_cfg = false)]` attribute on the item.
+
+If no argument is specified (ie `#[doc(auto_cfg)]`), it's the same as writing `#[doc(auto_cfg = true)]`.
+
 ## Inheritance
 
 Rustdoc merges `cfg` attributes from parent modules to its children. For example, in this case, the module `non_unix` will describe the entire compatibility matrix for the module, and not just its directly attached information:
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index 8b8cf19d8e418..c2cf39c4be06e 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -925,7 +925,7 @@ pub(crate) fn hir_attr_lists<'a, I: IntoIterator<Item = &'a hir::Attribute>>(
 /// This type keeps track of (doc) cfg information as we go down the item tree.
 #[derive(Clone, Debug)]
 pub(crate) struct CfgInfo {
-    /// List of currently active `doc(auto_cfg(hide(...)))` cfgs,minus currently active
+    /// List of currently active `doc(auto_cfg(hide(...)))` cfgs, minus currently active
     /// `doc(auto_cfg(show(...)))` cfgs.
     hidden_cfg: FxHashSet<Cfg>,
     /// Current computed `cfg`. Each time we enter a new item, this field is updated as well while
@@ -942,13 +942,11 @@ pub(crate) struct CfgInfo {
 impl Default for CfgInfo {
     fn default() -> Self {
         Self {
-            hidden_cfg: [
+            hidden_cfg: FxHashSet::from_iter([
                 Cfg::Cfg(sym::test, None),
                 Cfg::Cfg(sym::doc, None),
                 Cfg::Cfg(sym::doctest, None),
-            ]
-            .into_iter()
-            .collect(),
+            ]),
             current_cfg: Cfg::True,
             auto_cfg_active: true,
             parent_is_doc_cfg: false,
@@ -990,7 +988,7 @@ fn handle_auto_cfg_hide_show(
         && let MetaItemKind::List(items) = &item.kind
     {
         for item in items {
-            // Cfg parsing errors should already have been reported in `rustc_passes::check_attr`.
+            // FIXME: Report in case `Cfg::parse` reports an error?
             if let Ok(Cfg::Cfg(key, value)) = Cfg::parse(item) {
                 if is_show {
                     if let Some(span) = new_hide_attrs.get(&(key, value)) {
diff --git a/src/librustdoc/passes/propagate_doc_cfg.rs b/src/librustdoc/passes/propagate_doc_cfg.rs
index 4bcb60a9a40de..d5b20f2b9410c 100644
--- a/src/librustdoc/passes/propagate_doc_cfg.rs
+++ b/src/librustdoc/passes/propagate_doc_cfg.rs
@@ -97,9 +97,8 @@ impl CfgPropagator<'_, '_> {
         //
         // Otherwise, `cfg_info` already tracks everything we need so nothing else to do!
         if matches!(item.kind, ItemKind::ImplItem(_))
-            && let Some(def_id) = item.item_id.as_def_id().and_then(|def_id| def_id.as_local())
+            && let Some(mut next_def_id) = item.item_id.as_local_def_id()
         {
-            let mut next_def_id = def_id;
             while let Some(parent_def_id) = self.cx.tcx.opt_local_parent(next_def_id) {
                 let x = load_attrs(self.cx, parent_def_id.to_def_id());
                 add_only_cfg_attributes(&mut attrs, x);

From 6cccea8731c5f8540d65c2458a36655a4b8793f3 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 26 Sep 2025 14:46:04 +0200
Subject: [PATCH 1483/1889] Remove `doc_auto_cfg` feature as well

---
 compiler/rustc_feature/src/removed.rs     | 2 ++
 compiler/rustc_feature/src/unstable.rs    | 2 --
 tests/rustdoc-gui/src/lib2/lib.rs         | 1 -
 tests/rustdoc/doc-cfg/doc-cfg-implicit.rs | 2 +-
 tests/rustdoc/reexport/reexport-cfg.rs    | 2 +-
 5 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/compiler/rustc_feature/src/removed.rs b/compiler/rustc_feature/src/removed.rs
index 71365da316cef..3c51f91331a6a 100644
--- a/compiler/rustc_feature/src/removed.rs
+++ b/compiler/rustc_feature/src/removed.rs
@@ -101,6 +101,8 @@ declare_features! (
      Some("never properly implemented; requires significant design work"), 127655),
     /// Allows deriving traits as per `SmartPointer` specification
     (removed, derive_smart_pointer, "1.84.0", Some(123430), Some("replaced by `CoercePointee`"), 131284),
+    /// Tells rustdoc to automatically generate `#[doc(cfg(...))]`.
+    (removed, doc_auto_cfg, "1.58.0", Some(43781), Some("merged into `doc_cfg`"), 138907),
     /// Allows `#[doc(cfg_hide(...))]`.
     (removed, doc_cfg_hide, "1.57.0", Some(43781), Some("merged into `doc_cfg`"), 138907),
     /// Allows using `#[doc(keyword = "...")]`.
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 4dc961cb92773..b286ae3eb23ba 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -472,8 +472,6 @@ declare_features! (
     (incomplete, deref_patterns, "1.79.0", Some(87121)),
     /// Allows deriving the From trait on single-field structs.
     (unstable, derive_from, "1.91.0", Some(144889)),
-    /// Tells rustdoc to automatically generate `#[doc(cfg(...))]`.
-    (unstable, doc_auto_cfg, "1.58.0", Some(43781)),
     /// Allows `#[doc(cfg(...))]`.
     (unstable, doc_cfg, "1.21.0", Some(43781)),
     /// Allows `#[doc(masked)]`.
diff --git a/tests/rustdoc-gui/src/lib2/lib.rs b/tests/rustdoc-gui/src/lib2/lib.rs
index 8db754f91ce61..400488cbe8570 100644
--- a/tests/rustdoc-gui/src/lib2/lib.rs
+++ b/tests/rustdoc-gui/src/lib2/lib.rs
@@ -1,7 +1,6 @@
 // ignore-tidy-linelength
 
 #![feature(doc_cfg)]
-#![feature(doc_auto_cfg)]
 
 pub mod another_folder;
 pub mod another_mod;
diff --git a/tests/rustdoc/doc-cfg/doc-cfg-implicit.rs b/tests/rustdoc/doc-cfg/doc-cfg-implicit.rs
index 69b10867ee3ac..c092675ee5cf9 100644
--- a/tests/rustdoc/doc-cfg/doc-cfg-implicit.rs
+++ b/tests/rustdoc/doc-cfg/doc-cfg-implicit.rs
@@ -1,5 +1,5 @@
 #![crate_name = "funambulism"]
-#![feature(doc_auto_cfg, doc_cfg)]
+#![feature(doc_cfg)]
 
 //@ has 'funambulism/struct.Disorbed.html'
 //@ count   - '//*[@class="stab portability"]' 1
diff --git a/tests/rustdoc/reexport/reexport-cfg.rs b/tests/rustdoc/reexport/reexport-cfg.rs
index 73b6682431663..b624e5acf502e 100644
--- a/tests/rustdoc/reexport/reexport-cfg.rs
+++ b/tests/rustdoc/reexport/reexport-cfg.rs
@@ -2,7 +2,7 @@
 // include `cfg`s from the previous chained items.
 
 #![crate_name = "foo"]
-#![feature(doc_auto_cfg, doc_cfg)]
+#![feature(doc_cfg)]
 
 mod foo {
     #[cfg(not(feature = "foo"))]

From 660a3486fc6da2c3599a167d73d849178f98bc17 Mon Sep 17 00:00:00 2001
From: Noratrieb <48135649+Noratrieb@users.noreply.github.com>
Date: Sat, 27 Sep 2025 13:37:29 +0200
Subject: [PATCH 1484/1889] Skip stack overflow handler for
 panic=immediate-abort

std installs guard pages and a signal handler to ensure that stackoverflows 1) terminate abruptly and 2) print an nice message. Even for panic=immediate-abort, 1) is desirable, we don't want silent data corruption there. But 2) is completely unnecessary, as users deliberately *don't* want nice messages, they want minimum binary size.

Therefore, skip the entire guard signal handler setup, which saves a lot of bytes.

I tested this with a hello world binary using fat LTO, build-std, panic=immediate-abort, opt-level=s, strip=debuginfo.

`size` reports significant savings:

```
   text	   data	    bss	    dec	    hex	filename
  15252	   1032	    104	  16388	   4004	tiny-before
   6881	    964	     48	   7893	   1ed5	tiny-after2
```

`nm -U` goes from 71 to 56, getting rid of a bunch of stack overflow related symbols. The disk size goes from `31k` to `24k`.

The impact on the error message is minimal, as the message was already
missing.

before:
```
fish: Job 1, './tiny-so-before' terminated by signal SIGABRT (Abort)
```

after:
```
fish: Job 1, './tiny-so-after' terminated by signal SIGSEGV (Address boundary error)
```
---
 library/std/src/sys/pal/unix/stack_overflow.rs | 12 +++++++++++-
 library/std/src/sys/pal/windows/mod.rs         |  3 ++-
 2 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/library/std/src/sys/pal/unix/stack_overflow.rs b/library/std/src/sys/pal/unix/stack_overflow.rs
index 0d2100d66bc09..08a3cee64bab2 100644
--- a/library/std/src/sys/pal/unix/stack_overflow.rs
+++ b/library/std/src/sys/pal/unix/stack_overflow.rs
@@ -148,6 +148,13 @@ mod imp {
 
         let mut guard_page_range = unsafe { install_main_guard() };
 
+        // Even for panic=immediate-abort, installing the guard pages is important for soundness.
+        // That said, we do not care about giving nice stackoverflow messages via our custom
+        // signal handler, just exit early and let the user enjoy the segfault.
+        if cfg!(panic = "immediate-abort") {
+            return;
+        }
+
         // SAFETY: assuming all platforms define struct sigaction as "zero-initializable"
         let mut action: sigaction = unsafe { mem::zeroed() };
         for &signal in &[SIGSEGV, SIGBUS] {
@@ -179,6 +186,9 @@ mod imp {
     /// Must be called only once
     #[forbid(unsafe_op_in_unsafe_fn)]
     pub unsafe fn cleanup() {
+        if cfg!(panic = "immediate-abort") {
+            return;
+        }
         // FIXME: I probably cause more bugs than I'm worth!
         // see https://github.com/rust-lang/rust/issues/111272
         unsafe { drop_handler(MAIN_ALTSTACK.load(Ordering::Relaxed)) };
@@ -230,7 +240,7 @@ mod imp {
     /// Mutates the alternate signal stack
     #[forbid(unsafe_op_in_unsafe_fn)]
     pub unsafe fn make_handler(main_thread: bool, thread_name: Option<Box<str>>) -> Handler {
-        if !NEED_ALTSTACK.load(Ordering::Acquire) {
+        if cfg!(panic = "immediate-abort") || !NEED_ALTSTACK.load(Ordering::Acquire) {
             return Handler::null();
         }
 
diff --git a/library/std/src/sys/pal/windows/mod.rs b/library/std/src/sys/pal/windows/mod.rs
index 3357946b8f71d..b7578b01584bf 100644
--- a/library/std/src/sys/pal/windows/mod.rs
+++ b/library/std/src/sys/pal/windows/mod.rs
@@ -22,7 +22,8 @@ pub mod os;
 pub mod pipe;
 pub mod time;
 cfg_select! {
-    not(target_vendor = "uwp") => {
+    // We don't care about printing nice error messages for panic=immediate-abort
+    all(not(target_vendor = "uwp"), not(panic = "immediate-abort")) => {
         pub mod stack_overflow;
     }
     _ => {

From 07ed247d3c28670449f142b54b025fc429ac318a Mon Sep 17 00:00:00 2001
From: Mads Marquart <mads@marquart.dk>
Date: Sat, 27 Sep 2025 14:40:38 +0200
Subject: [PATCH 1485/1889] Ignore crash test that doesn't crash on Apple
 platforms

This wasn't caught by CI, because debug assertions aren't enabled there.
---
 tests/crashes/120175.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/crashes/120175.rs b/tests/crashes/120175.rs
index e441454bed294..e06da5a8e0ae0 100644
--- a/tests/crashes/120175.rs
+++ b/tests/crashes/120175.rs
@@ -1,5 +1,6 @@
 //@ known-bug: #120175
 //@ needs-rustc-debug-assertions
+//@ ignore-apple (raw-dylib doesn't work on Apple targets yet)
 
 #![feature(extern_types)]
 #![feature(raw_dylib_elf)]

From d42acf522ff234e187aef2de8c6903bc94efe444 Mon Sep 17 00:00:00 2001
From: Erick Tryzelaar <etryzelaar@google.com>
Date: Sat, 7 Jun 2025 03:24:35 +0000
Subject: [PATCH 1486/1889] Include additional hashes in src/stage0

This patch changes `bump-stage0` to include:

* The sha256 hash of the channel manifest used to create `src/stage0`.
* The rust and rustfmt git commit in `src/stage0`.
* Hashes of all the artifacts, like the source tarball, in `src/stage0`.

Combined this will allow for:

* Projects that bootstrap their own compiler, such as Fuchsia, or users
  of [bootstrap], to build their compilers offline without needing to
  communicate with static.rust-lang.org.

* Auditors to detect if the channel manifest, and all the artifacts
  inside the manifest, were modified after it was used to generate
  `src/stage0`. Furthermore, if they did find modified artifacts, they
  could determine if the Rust Signing Key was compromised by checking if
  any modified file was signed properly.

Finally, it allows regeneration of `src/stage0` when specifying both the
day of the build for rust, and the day of the build for rustfmt, which
can allow a maintainer to regenerate `src/stage0` to verify nothing
changed.

[bootstrap]: https://github.com/dtolnay/bootstrap
[mrustc]: https://github.com/thepowersgang/mrustc
---
 Cargo.lock                            |  2 +
 src/bootstrap/src/core/download.rs    |  2 +-
 src/build_helper/src/stage0_parser.rs | 14 ++++
 src/tools/bump-stage0/Cargo.toml      |  2 +
 src/tools/bump-stage0/src/main.rs     | 97 ++++++++++++++++++++++++---
 5 files changed, 105 insertions(+), 12 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 3d4a1bf6a7880..715d580e051d1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -334,8 +334,10 @@ dependencies = [
  "anyhow",
  "build_helper",
  "curl",
+ "hex",
  "indexmap",
  "serde",
+ "sha2",
  "toml 0.8.23",
 ]
 
diff --git a/src/bootstrap/src/core/download.rs b/src/bootstrap/src/core/download.rs
index 37871f0fe1e28..a096d116e73fa 100644
--- a/src/bootstrap/src/core/download.rs
+++ b/src/bootstrap/src/core/download.rs
@@ -506,7 +506,7 @@ pub(crate) fn maybe_download_rustfmt<'a>(
         return Some(PathBuf::new());
     }
 
-    let VersionMetadata { date, version } = dwn_ctx.stage0_metadata.rustfmt.as_ref()?;
+    let VersionMetadata { date, version, .. } = dwn_ctx.stage0_metadata.rustfmt.as_ref()?;
     let channel = format!("{version}-{date}");
 
     let host = dwn_ctx.host_target;
diff --git a/src/build_helper/src/stage0_parser.rs b/src/build_helper/src/stage0_parser.rs
index 2723f4aa7b914..3f3297dcd2bb1 100644
--- a/src/build_helper/src/stage0_parser.rs
+++ b/src/build_helper/src/stage0_parser.rs
@@ -10,6 +10,8 @@ pub struct Stage0 {
 
 #[derive(Default, Clone)]
 pub struct VersionMetadata {
+    pub channel_manifest_hash: String,
+    pub git_commit_hash: String,
     pub date: String,
     pub version: String,
 }
@@ -50,9 +52,21 @@ pub fn parse_stage0_file() -> Stage0 {
             "git_merge_commit_email" => stage0.config.git_merge_commit_email = value.to_owned(),
             "nightly_branch" => stage0.config.nightly_branch = value.to_owned(),
 
+            "compiler_channel_manifest_hash" => {
+                stage0.compiler.channel_manifest_hash = value.to_owned()
+            }
+            "compiler_git_commit_hash" => stage0.compiler.git_commit_hash = value.to_owned(),
             "compiler_date" => stage0.compiler.date = value.to_owned(),
             "compiler_version" => stage0.compiler.version = value.to_owned(),
 
+            "rustfmt_channel_manifest_hash" => {
+                stage0.rustfmt.get_or_insert(VersionMetadata::default()).channel_manifest_hash =
+                    value.to_owned();
+            }
+            "rustfmt_git_commit_hash" => {
+                stage0.rustfmt.get_or_insert(VersionMetadata::default()).git_commit_hash =
+                    value.to_owned();
+            }
             "rustfmt_date" => {
                 stage0.rustfmt.get_or_insert(VersionMetadata::default()).date = value.to_owned();
             }
diff --git a/src/tools/bump-stage0/Cargo.toml b/src/tools/bump-stage0/Cargo.toml
index 79097f2c18916..943b8453ef850 100644
--- a/src/tools/bump-stage0/Cargo.toml
+++ b/src/tools/bump-stage0/Cargo.toml
@@ -9,6 +9,8 @@ edition = "2021"
 anyhow = "1.0.34"
 build_helper = { path = "../../build_helper" }
 curl = "0.4.38"
+hex = "0.4.3"
 indexmap = { version = "2.0.0", features = ["serde"] }
 serde = { version = "1.0.125", features = ["derive"] }
 toml = "0.8.23"
+sha2 = "0.10.1"
diff --git a/src/tools/bump-stage0/src/main.rs b/src/tools/bump-stage0/src/main.rs
index faed748785f46..079e7b1ce71ee 100644
--- a/src/tools/bump-stage0/src/main.rs
+++ b/src/tools/bump-stage0/src/main.rs
@@ -4,6 +4,7 @@ use anyhow::{Context, Error};
 use build_helper::stage0_parser::{Stage0Config, VersionMetadata, parse_stage0_file};
 use curl::easy::Easy;
 use indexmap::IndexMap;
+use sha2::{Digest, Sha256};
 
 const PATH: &str = "src/stage0";
 const COMPILER_COMPONENTS: &[&str] = &["rustc", "rust-std", "cargo", "clippy-preview"];
@@ -13,13 +14,14 @@ struct Tool {
     config: Stage0Config,
 
     channel: Channel,
-    date: Option<String>,
+    compiler_date: Option<String>,
+    rustfmt_date: Option<String>,
     version: [u16; 3],
     checksums: IndexMap<String, String>,
 }
 
 impl Tool {
-    fn new(date: Option<String>) -> Result<Self, Error> {
+    fn new(compiler_date: Option<String>, rustfmt_date: Option<String>) -> Result<Self, Error> {
         let channel = match std::fs::read_to_string("src/ci/channel")?.trim() {
             "stable" => Channel::Stable,
             "beta" => Channel::Beta,
@@ -38,7 +40,14 @@ impl Tool {
 
         let existing = parse_stage0_file();
 
-        Ok(Self { channel, version, date, config: existing.config, checksums: IndexMap::new() })
+        Ok(Self {
+            channel,
+            version,
+            compiler_date,
+            rustfmt_date,
+            config: existing.config,
+            checksums: IndexMap::new(),
+        })
     }
 
     fn update_stage0_file(mut self) -> Result<(), Error> {
@@ -78,10 +87,21 @@ impl Tool {
         file_content.push_str("\n");
 
         let compiler = self.detect_compiler()?;
+        file_content.push_str(&format!(
+            "compiler_channel_manifest_hash={}\n",
+            compiler.channel_manifest_hash
+        ));
+        file_content.push_str(&format!("compiler_git_commit_hash={}\n", compiler.git_commit_hash));
         file_content.push_str(&format!("compiler_date={}\n", compiler.date));
         file_content.push_str(&format!("compiler_version={}\n", compiler.version));
 
         if let Some(rustfmt) = self.detect_rustfmt()? {
+            file_content.push_str(&format!(
+                "rustfmt_channel_manifest_hash={}\n",
+                rustfmt.channel_manifest_hash
+            ));
+            file_content
+                .push_str(&format!("rustfmt_git_commit_hash={}\n", rustfmt.git_commit_hash));
             file_content.push_str(&format!("rustfmt_date={}\n", rustfmt.date));
             file_content.push_str(&format!("rustfmt_version={}\n", rustfmt.version));
         }
@@ -112,9 +132,16 @@ impl Tool {
             Channel::Nightly => "beta".to_string(),
         };
 
-        let manifest = fetch_manifest(&self.config, &channel, self.date.as_deref())?;
+        let (manifest, manifest_hash) =
+            fetch_manifest(&self.config, &channel, self.compiler_date.as_deref())?;
         self.collect_checksums(&manifest, COMPILER_COMPONENTS)?;
         Ok(VersionMetadata {
+            channel_manifest_hash: manifest_hash,
+            git_commit_hash: manifest.pkg["rust"]
+                .git_commit_hash
+                .as_ref()
+                .expect("invalid git_commit_hash")
+                .into(),
             date: manifest.date,
             version: if self.channel == Channel::Nightly {
                 "beta".to_string()
@@ -138,9 +165,19 @@ impl Tool {
             return Ok(None);
         }
 
-        let manifest = fetch_manifest(&self.config, "nightly", self.date.as_deref())?;
+        let (manifest, manifest_hash) =
+            fetch_manifest(&self.config, "nightly", self.rustfmt_date.as_deref())?;
         self.collect_checksums(&manifest, RUSTFMT_COMPONENTS)?;
-        Ok(Some(VersionMetadata { date: manifest.date, version: "nightly".into() }))
+        Ok(Some(VersionMetadata {
+            channel_manifest_hash: manifest_hash,
+            git_commit_hash: manifest.pkg["rust"]
+                .git_commit_hash
+                .as_ref()
+                .expect("invalid git_commit_hash")
+                .into(),
+            date: manifest.date,
+            version: "nightly".into(),
+        }))
     }
 
     fn collect_checksums(&mut self, manifest: &Manifest, components: &[&str]) -> Result<(), Error> {
@@ -164,12 +201,29 @@ impl Tool {
                 }
             }
         }
+        for artifact in manifest.artifacts.values() {
+            for targets in artifact.target.values() {
+                for target in targets {
+                    let url = target
+                        .url
+                        .strip_prefix(&prefix)
+                        .ok_or_else(|| {
+                            anyhow::anyhow!(
+                                "url doesn't start with dist server base: {}",
+                                target.url
+                            )
+                        })?
+                        .to_string();
+                    self.checksums.insert(url, target.hash_sha256.clone());
+                }
+            }
+        }
         Ok(())
     }
 }
 
 fn main() -> Result<(), Error> {
-    let tool = Tool::new(std::env::args().nth(1))?;
+    let tool = Tool::new(std::env::args().nth(1), std::env::args().nth(2))?;
     tool.update_stage0_file()?;
     Ok(())
 }
@@ -178,18 +232,24 @@ fn fetch_manifest(
     config: &Stage0Config,
     channel: &str,
     date: Option<&str>,
-) -> Result<Manifest, Error> {
+) -> Result<(Manifest, String), Error> {
     let url = if let Some(date) = date {
         format!("{}/dist/{}/channel-rust-{}.toml", config.dist_server, date, channel)
     } else {
         format!("{}/dist/channel-rust-{}.toml", config.dist_server, channel)
     };
 
+    let manifest_bytes = http_get(&url)?;
+
+    let mut sha256 = Sha256::new();
+    sha256.update(&manifest_bytes);
+    let manifest_hash = hex::encode(sha256.finalize());
+
     // FIXME: on newer `toml` (>= `0.9.*`), use `toml::from_slice`. For now, we use the most recent
     // `toml` available in-tree which is `0.8.*`, so we have to do an additional dance here.
-    let response = http_get(&url)?;
-    let response = String::from_utf8(response)?;
-    Ok(toml::from_str(&response)?)
+    let manifest_str = String::from_utf8(manifest_bytes)?;
+    let manifest = toml::from_str(&manifest_str)?;
+    Ok((manifest, manifest_hash))
 }
 
 fn http_get(url: &str) -> Result<Vec<u8>, Error> {
@@ -219,11 +279,14 @@ enum Channel {
 struct Manifest {
     date: String,
     pkg: IndexMap<String, ManifestPackage>,
+    artifacts: IndexMap<String, ManifestArtifact>,
 }
 
 #[derive(Debug, serde::Serialize, serde::Deserialize)]
 struct ManifestPackage {
     version: String,
+    #[serde(default)]
+    git_commit_hash: Option<String>,
     target: IndexMap<String, ManifestTargetPackage>,
 }
 
@@ -234,3 +297,15 @@ struct ManifestTargetPackage {
     xz_url: Option<String>,
     xz_hash: Option<String>,
 }
+
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+struct ManifestArtifact {
+    target: IndexMap<String, Vec<ManifestTargetArtifact>>,
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "kebab-case")]
+struct ManifestTargetArtifact {
+    url: String,
+    hash_sha256: String,
+}

From 76bb0d1870b0023d6184ee4b714e2cf4ad1d96d4 Mon Sep 17 00:00:00 2001
From: Mark Rousskov <mark.simulacrum@gmail.com>
Date: Sat, 27 Sep 2025 08:45:40 -0400
Subject: [PATCH 1487/1889] Update stage0 per previous commmit

---
 src/stage0 | 1022 +++++++++++++++++++++++++++-------------------------
 1 file changed, 522 insertions(+), 500 deletions(-)

diff --git a/src/stage0 b/src/stage0
index 6d2f0402f4acf..556ced41d3da8 100644
--- a/src/stage0
+++ b/src/stage0
@@ -13,506 +13,528 @@ nightly_branch=master
 # All changes below this comment will be overridden the next time the
 # tool is executed.
 
-compiler_date=2025-09-16
+compiler_channel_manifest_hash=55f3014ea3a3b17cfa5060d9188fd13d13b065456661a3d670dd061719713f32
+compiler_git_commit_hash=bb624dcb4c8ab987e10c0808d92d76f3b84dd117
+compiler_date=2025-09-21
 compiler_version=beta
-rustfmt_date=2025-09-16
+rustfmt_channel_manifest_hash=2f19b9b74a17d0283264a227ed552d7df6729929fcb73b2d5bb321feed8a5c85
+rustfmt_git_commit_hash=54a8a1db604e4caff93e26e167ad4a6fde9f0681
+rustfmt_date=2025-09-27
 rustfmt_version=nightly
 
-dist/2025-09-16/rustc-beta-aarch64-apple-darwin.tar.gz=3e3fbcf51f2632b8890b38537ea5446147b85fd62b21798b4fb2a032a4abd6c9
-dist/2025-09-16/rustc-beta-aarch64-apple-darwin.tar.xz=296ef2ae4dc8b4f411423a4384821e5b8e305be809b55522a0f02c97b83ce14a
-dist/2025-09-16/rustc-beta-aarch64-pc-windows-gnullvm.tar.gz=fe7026f1310a84f3490d0ffb8476bddc36992fcb2d7e450c036aae6bbbb218ef
-dist/2025-09-16/rustc-beta-aarch64-pc-windows-gnullvm.tar.xz=70bd356d7f39ff1ef8511941671caae84f43d3a9ab493ed131467d27bf5c53f1
-dist/2025-09-16/rustc-beta-aarch64-pc-windows-msvc.tar.gz=9b0f42d2713c20d1df9e401410f874f04ffbff2e0c61d19d2f8689d4e55da562
-dist/2025-09-16/rustc-beta-aarch64-pc-windows-msvc.tar.xz=086ff4c532289581325b1cb5c629f899418dd392249d3c0bd2137a0d73ebccca
-dist/2025-09-16/rustc-beta-aarch64-unknown-linux-gnu.tar.gz=4860148593cc5f5662cb89c9484d71af472223b8a9f9644e6709802154e7d02d
-dist/2025-09-16/rustc-beta-aarch64-unknown-linux-gnu.tar.xz=a7f290455c134c72518267e7dfc5a51d550497ffcf539dac3b41c57486e1d370
-dist/2025-09-16/rustc-beta-aarch64-unknown-linux-musl.tar.gz=7a17d7a65ca7c933de8829e5991f991d917df7007c122fc55d64efa0fe53344a
-dist/2025-09-16/rustc-beta-aarch64-unknown-linux-musl.tar.xz=6ab69fc25888475048dc5eac7adc7f6b02295dc7de7d0e92aad5ff562c500322
-dist/2025-09-16/rustc-beta-arm-unknown-linux-gnueabi.tar.gz=00ff0a967ee41642e6b316b190485a7d04c6749ff571e55cf73548b0e7d74b05
-dist/2025-09-16/rustc-beta-arm-unknown-linux-gnueabi.tar.xz=ce2c11e633e367544a70b0a3ad998a2d680277e62ece3eacbf350fa1ada6332a
-dist/2025-09-16/rustc-beta-arm-unknown-linux-gnueabihf.tar.gz=ded847d958f0417fba13e71ded42cee387387076b4426b2f2002d53dd998c27c
-dist/2025-09-16/rustc-beta-arm-unknown-linux-gnueabihf.tar.xz=54ee1d25f57db5d1c2b153533362ecb7fd326b8dd46b8240367ea865a059ca68
-dist/2025-09-16/rustc-beta-armv7-unknown-linux-gnueabihf.tar.gz=8f964d41f6608ba04d2d84f5532a057654f3f328b19bc6ee4b9a88f6f64dcec7
-dist/2025-09-16/rustc-beta-armv7-unknown-linux-gnueabihf.tar.xz=b6a34332cb027345f54f75e03cee1c65345e8671df081e8dd23111d2233bf6e6
-dist/2025-09-16/rustc-beta-i686-pc-windows-gnu.tar.gz=760c5f1bc081a14b4df2e0c6a1ce80d96b63e15e0b751cfe535eb5775aa9e34b
-dist/2025-09-16/rustc-beta-i686-pc-windows-gnu.tar.xz=4376609352714e1e30a4b0c57fe43beb2b0edccda412e18e11c3b8b3092a87d0
-dist/2025-09-16/rustc-beta-i686-pc-windows-msvc.tar.gz=3d0f08e30f4ae2cb513548f66cc6405ba0c2cc74e826c04cf0bdad3d3c14bcfa
-dist/2025-09-16/rustc-beta-i686-pc-windows-msvc.tar.xz=a68b01fb491496bb2b8861af9b900a2960f4ea9f64f0946caa09c043ecb3df2f
-dist/2025-09-16/rustc-beta-i686-unknown-linux-gnu.tar.gz=3b56ab8e485b3e4bd5c0f1e1ff30389acb9d0d0e0662ff834fb3a855157c965a
-dist/2025-09-16/rustc-beta-i686-unknown-linux-gnu.tar.xz=fe871e45e0d987dcaa6a30df8394c54da0204965686a089d6903fff75b8a01e5
-dist/2025-09-16/rustc-beta-loongarch64-unknown-linux-gnu.tar.gz=71d53cb70f1962379614c86b07fdea7c1b343587a56734d39aa7de29667d6629
-dist/2025-09-16/rustc-beta-loongarch64-unknown-linux-gnu.tar.xz=658f204ab2536ad3b56f238c55c5c6cf3bd7794aceff379f0f5492d28841b5bc
-dist/2025-09-16/rustc-beta-loongarch64-unknown-linux-musl.tar.gz=0fe154b5b305259a36b80b9b53894336ceba1562155c05cf92debc5d7bb7e645
-dist/2025-09-16/rustc-beta-loongarch64-unknown-linux-musl.tar.xz=27357f4331d5c357a7b20002571276e2d77e58384095fd3a6910d44a0d85aa87
-dist/2025-09-16/rustc-beta-powerpc-unknown-linux-gnu.tar.gz=bf87cb1717fad96abbb86091c44de6bdeed2bd60437ffa9037d27dda1c71cdbe
-dist/2025-09-16/rustc-beta-powerpc-unknown-linux-gnu.tar.xz=778d126b47dc5ef07085c5c760399130219cda6221f6f4ec57c26ebdd7e33299
-dist/2025-09-16/rustc-beta-powerpc64-unknown-linux-gnu.tar.gz=eae03019370901fb49b708c76d001ec9e3df27e7fa1ea9ceb2200640e9d6dfea
-dist/2025-09-16/rustc-beta-powerpc64-unknown-linux-gnu.tar.xz=61c1b21acc668bdf36cbf64f2b53348d997ffc9997c6ad282d10226e86740044
-dist/2025-09-16/rustc-beta-powerpc64le-unknown-linux-gnu.tar.gz=057eb2050b31110529a80e27c6df0c95a14bb1f7c568b487dd3a718755a74d27
-dist/2025-09-16/rustc-beta-powerpc64le-unknown-linux-gnu.tar.xz=cb3078b44dbb6793ac98a28bd6bd7076c28ae13c5ddd1aa02310ec89130b6575
-dist/2025-09-16/rustc-beta-powerpc64le-unknown-linux-musl.tar.gz=9a5109124546788b802be36d9415bf0d5bfcc087389156c65a2e30672e10e7b1
-dist/2025-09-16/rustc-beta-powerpc64le-unknown-linux-musl.tar.xz=6987de797339aa2f231485897b0a498a841a49f1d0b83fa7e98c0a76767cbe44
-dist/2025-09-16/rustc-beta-riscv64gc-unknown-linux-gnu.tar.gz=17cd423d53f6d8fe53dff7abada43d545a2de14136eae7cd02b958f9fe93f5a0
-dist/2025-09-16/rustc-beta-riscv64gc-unknown-linux-gnu.tar.xz=740945fe14eeea917d64ff47e997ca17be1e0f14dca30632a9fbfb560405b040
-dist/2025-09-16/rustc-beta-s390x-unknown-linux-gnu.tar.gz=52e15e3a56a16b2989b34f0a051ff06fb8dd51be3e6874c41a4ba1e2128d35ff
-dist/2025-09-16/rustc-beta-s390x-unknown-linux-gnu.tar.xz=6f998aede2a805d8159f2ea63dda76a7d25eb9cdbd26863394aacfa6d80de084
-dist/2025-09-16/rustc-beta-sparcv9-sun-solaris.tar.gz=45c85ec3de0a773b2c2f4b624abe28c3a906020e1ce6ceded75c0099a1fc1899
-dist/2025-09-16/rustc-beta-sparcv9-sun-solaris.tar.xz=d811ff717ebc59aa9bc5c26ee4b8dcfdb3d2f5a1759179eccf549c8a765fb3dd
-dist/2025-09-16/rustc-beta-x86_64-apple-darwin.tar.gz=d31302c29a9efe362d2be87b83b229d5369b2462cea133f9b1b4c7c4cf0f26dd
-dist/2025-09-16/rustc-beta-x86_64-apple-darwin.tar.xz=b8f9f0b2e4c681da9bf7fbac2fc22ec2f44c136b368821bfea5a5ab29d85527a
-dist/2025-09-16/rustc-beta-x86_64-pc-solaris.tar.gz=498902a6de8cae1494aae6223604381c4e109a38c14649f6e27b075d3f26a685
-dist/2025-09-16/rustc-beta-x86_64-pc-solaris.tar.xz=1cfaeae163fcd4dd2ff44a80c245012576ecb4257d7d763a51f2d7e58878a29b
-dist/2025-09-16/rustc-beta-x86_64-pc-windows-gnu.tar.gz=d4c6fa5158c83500d30ef44e129889408dbc49ec862c985a1c36820d3550e94d
-dist/2025-09-16/rustc-beta-x86_64-pc-windows-gnu.tar.xz=17bd90bfd6603b24d26397acac55e4b2c23b0dc574834de7bc1f8c2c720aab97
-dist/2025-09-16/rustc-beta-x86_64-pc-windows-gnullvm.tar.gz=d270c52fec5ef2e9f009cc3e697b6188320fbeb5445092c7a11af67e520cc9f0
-dist/2025-09-16/rustc-beta-x86_64-pc-windows-gnullvm.tar.xz=81f91fc07821af63606268821a039578a7c9b09b8c0e96b85163831fee92e6a5
-dist/2025-09-16/rustc-beta-x86_64-pc-windows-msvc.tar.gz=233356bbd9a46168663752d7dcab67e7ae3ae732fab410bc8adb84230e22398f
-dist/2025-09-16/rustc-beta-x86_64-pc-windows-msvc.tar.xz=5f33d8b3a064235c23dfd2edfa8b5f6f2c5075d26529f81881501b8323eae60d
-dist/2025-09-16/rustc-beta-x86_64-unknown-freebsd.tar.gz=fda4fa10690458ee7db6081267458e47113e854d65695c95813039400772e263
-dist/2025-09-16/rustc-beta-x86_64-unknown-freebsd.tar.xz=570cd878e440b5d70a0d5fc90917b92a6b8b544a2e6844baafee1fef22d32732
-dist/2025-09-16/rustc-beta-x86_64-unknown-illumos.tar.gz=f8b7273e16de291fad24f2ebbd928b55007a75605fc25ddc35a4967f17e709f6
-dist/2025-09-16/rustc-beta-x86_64-unknown-illumos.tar.xz=77d7f5de006a9d0c56a2cf79423a5702bff445f6e34b4935326d3db30ac8b086
-dist/2025-09-16/rustc-beta-x86_64-unknown-linux-gnu.tar.gz=f61a57a75252d63930630af7d597f3046b7f7f09691cd6ff8c3a080871fa19de
-dist/2025-09-16/rustc-beta-x86_64-unknown-linux-gnu.tar.xz=b56298c4ba7a955ecb9135bba06ff6bdb7f4df94b6d64c99460e90e5a022fb87
-dist/2025-09-16/rustc-beta-x86_64-unknown-linux-musl.tar.gz=c6fec77bf71bf35ded56cf70eca28a94e083e0af458b00ed665eedf9270abd73
-dist/2025-09-16/rustc-beta-x86_64-unknown-linux-musl.tar.xz=bce669d29a995189e9d99f686b1f9535ad82cc877a106c89af5b423bef8a9d6f
-dist/2025-09-16/rustc-beta-x86_64-unknown-netbsd.tar.gz=cb1a0f5ff6d9c28b83f9c82fcfbf404b2920a7da8233d957e43fe001d5190318
-dist/2025-09-16/rustc-beta-x86_64-unknown-netbsd.tar.xz=25953b44e3b196e89b5dc6028805517f42f6367c6b990a930ba44f63dce0a855
-dist/2025-09-16/rust-std-beta-aarch64-apple-darwin.tar.gz=8ada740b1af444b98c3df74f5f810a05036b6195e6b54115a7e34bed23a30d1c
-dist/2025-09-16/rust-std-beta-aarch64-apple-darwin.tar.xz=1211a726975c1a9fbd679156644b83c446cab4d6eb7728d3dc38db6c949b997f
-dist/2025-09-16/rust-std-beta-aarch64-apple-ios.tar.gz=58e7ec536d9bee83dcbcdad819c4a27689f02a20acbc75ffcb6ceeec7929da4f
-dist/2025-09-16/rust-std-beta-aarch64-apple-ios.tar.xz=f0afe719f83531e0c22d0621b9137d30bacd17ffcc9d0188e9cee2a71f10afa0
-dist/2025-09-16/rust-std-beta-aarch64-apple-ios-macabi.tar.gz=e1f067b248dfcf1d6efbc589a0938ceeaa81087d041889d65b90f4f82aeb35ff
-dist/2025-09-16/rust-std-beta-aarch64-apple-ios-macabi.tar.xz=182ad0986236f21ba93d49ed3dbec72e54cbc88d18adf77848e87f497b7b2f05
-dist/2025-09-16/rust-std-beta-aarch64-apple-ios-sim.tar.gz=cd367dce5dc4a5d209db298f97070e55ec16caa8931ef17a189bf5d7f5c21212
-dist/2025-09-16/rust-std-beta-aarch64-apple-ios-sim.tar.xz=b51aba09d7ced8b69e15ec9ca381379cf9f910c1f89109c8764cc15d51fd8293
-dist/2025-09-16/rust-std-beta-aarch64-linux-android.tar.gz=89154dba00da80cd67cff7e9beb1f68721bae9686e1fcff1379a2a4f549eec79
-dist/2025-09-16/rust-std-beta-aarch64-linux-android.tar.xz=d373ed69ed30521b2f724deac051662bcc7d4a919c1ff9f56b59ef028f07dcf0
-dist/2025-09-16/rust-std-beta-aarch64-pc-windows-gnullvm.tar.gz=9e84923928671f76762752a559d0e9a54f513b2f518eaad3da6f5772e46183c0
-dist/2025-09-16/rust-std-beta-aarch64-pc-windows-gnullvm.tar.xz=9170e87332e2a74624fa1dbaddb725f6cb331a8f65a5b0b2781c04aa58bc48fe
-dist/2025-09-16/rust-std-beta-aarch64-pc-windows-msvc.tar.gz=929786491660eedf2cb6c02036ce560043a7bec349bde762effa53ba59d17c81
-dist/2025-09-16/rust-std-beta-aarch64-pc-windows-msvc.tar.xz=72b395a15c0af1c92434a95010fec5435343190c3b90d55d2c7d17d3d4c6da52
-dist/2025-09-16/rust-std-beta-aarch64-unknown-fuchsia.tar.gz=36245bab64c4757821ca0732fe88fb5620601035f50bcd2d061386903abe7027
-dist/2025-09-16/rust-std-beta-aarch64-unknown-fuchsia.tar.xz=4c1bfe4453d36d554956f7ebb169bb81912815a28960bd7caf977940109573f1
-dist/2025-09-16/rust-std-beta-aarch64-unknown-linux-gnu.tar.gz=080603e3b117d3654b2e0b88ec172f4c5319ebadf9386074e7e6f0c466e9c90a
-dist/2025-09-16/rust-std-beta-aarch64-unknown-linux-gnu.tar.xz=4ea35b78b18a121bd3b0165d9f3278f3a454e108564e02b6c7d7133a33a99788
-dist/2025-09-16/rust-std-beta-aarch64-unknown-linux-musl.tar.gz=9c5b7188fed949b0462f9d6c45221b8b98e7feebdc4f8bc2d6d0d652cf3b3c24
-dist/2025-09-16/rust-std-beta-aarch64-unknown-linux-musl.tar.xz=31514db13f19dea13e47b8eff9fd8daec6bd0a73816aefadb94ad4e771d6a902
-dist/2025-09-16/rust-std-beta-aarch64-unknown-linux-ohos.tar.gz=a540735416f0b264444281865e1ed450c5bd58275f73426191cfb547b674ea7a
-dist/2025-09-16/rust-std-beta-aarch64-unknown-linux-ohos.tar.xz=9922ad22f002f5df232d8ed1dcdcd23a5e1a0a5b4b27e27c3b5fbd5b39087d03
-dist/2025-09-16/rust-std-beta-aarch64-unknown-none.tar.gz=618073f52e27d3ebd15b028398524a12e3bd91d4147e70b2160430e03ecdb178
-dist/2025-09-16/rust-std-beta-aarch64-unknown-none.tar.xz=3fa92c9383ac122c4b9ea2a00ff9f38d94b52c384b418b13ea573115daa07563
-dist/2025-09-16/rust-std-beta-aarch64-unknown-none-softfloat.tar.gz=33c4825523ef0e27b038111d3504cfbb4e049fcc3e136ddec186268346b647d9
-dist/2025-09-16/rust-std-beta-aarch64-unknown-none-softfloat.tar.xz=4487b93a8c7ac712328c98a660948e795e833f4edd3c92449df5472de6e320b9
-dist/2025-09-16/rust-std-beta-aarch64-unknown-uefi.tar.gz=f0c275d8bd220dc066541e6f2c7e41b6d019d698fa2b613c1f9c87ab4e29f4af
-dist/2025-09-16/rust-std-beta-aarch64-unknown-uefi.tar.xz=daed68a82600fe2f3652ae87e4c491460891906fcd06ae206bc794c354771564
-dist/2025-09-16/rust-std-beta-arm-linux-androideabi.tar.gz=9fa058b5bd0ac5af231cc5ee31f67cf3f16b361a41aceb43b17c81d8e180d16e
-dist/2025-09-16/rust-std-beta-arm-linux-androideabi.tar.xz=c6868144f5f5fdfc0d993f66fa91a01a91e0288014a7ab5d6233a93447508852
-dist/2025-09-16/rust-std-beta-arm-unknown-linux-gnueabi.tar.gz=5cd076f756c63e54067d780167da3e35bcb04f487fefa093028b0cd3435a2fcb
-dist/2025-09-16/rust-std-beta-arm-unknown-linux-gnueabi.tar.xz=3322a270f3696fc2254536608ebc49e047ad59e1a01493381c9c52f813bcb8ae
-dist/2025-09-16/rust-std-beta-arm-unknown-linux-gnueabihf.tar.gz=8bed8176ed380d974c2bc6df5314ac385ca6b72a623a8d16c00b753932a64db9
-dist/2025-09-16/rust-std-beta-arm-unknown-linux-gnueabihf.tar.xz=d557f55446ba39a1b3335ff1e4196ab40effa4ba42b2ce91bbde93738fd93da0
-dist/2025-09-16/rust-std-beta-arm-unknown-linux-musleabi.tar.gz=12a56e9f5c9caf4e262b9361af5ea5b62ec29b18ffdb807cda83655c531670b5
-dist/2025-09-16/rust-std-beta-arm-unknown-linux-musleabi.tar.xz=82b28e64f6278cb24573d699b14826a51be465b68cb48e767a26f1938221f5c4
-dist/2025-09-16/rust-std-beta-arm-unknown-linux-musleabihf.tar.gz=a3076f1f12895062e42a8ceacd5c06a3156b5a553c708615fddb975366d9424a
-dist/2025-09-16/rust-std-beta-arm-unknown-linux-musleabihf.tar.xz=4bf81edd4a193e6850bccbffb66c6005b1b99322192e87183d684dd9ec528cad
-dist/2025-09-16/rust-std-beta-arm64ec-pc-windows-msvc.tar.gz=2170d924f4ccc579baf862171934029505d476170825397580154dfab860d4a8
-dist/2025-09-16/rust-std-beta-arm64ec-pc-windows-msvc.tar.xz=dc3bdf6f93b32aa19987d149ed7da7616f3785f67a63fcf1e0d1aebeb8007d67
-dist/2025-09-16/rust-std-beta-armebv7r-none-eabi.tar.gz=2863a22ce3663edd346d730cac4bbdef3b9cd2ea2cd5907dcbc61220833e24e8
-dist/2025-09-16/rust-std-beta-armebv7r-none-eabi.tar.xz=74a752daef0446ed260845b016b3e57d20de4e914102713e0c3b652329f9f6f1
-dist/2025-09-16/rust-std-beta-armebv7r-none-eabihf.tar.gz=8fc3fcf203da0fa6f321abbda405ba0121dbd898ea02513431a5ca3dd5e6e16d
-dist/2025-09-16/rust-std-beta-armebv7r-none-eabihf.tar.xz=65cfd5061c4db0963b28f7bc636ece115ff7b812710ba9f902977f5014bdeafd
-dist/2025-09-16/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.gz=1cb760fdde8e9d84c5caa787488f0bb05c5e649f411b666f2d6a5440126f5992
-dist/2025-09-16/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.xz=9146b64438a68c506a93ae3c4d4d1a928358b562fac3b7513a95c8098cebdae0
-dist/2025-09-16/rust-std-beta-armv5te-unknown-linux-musleabi.tar.gz=9df691f77c95a0bdf5c45fc546c2319863cdca4d433780fe8c7cd146496382b8
-dist/2025-09-16/rust-std-beta-armv5te-unknown-linux-musleabi.tar.xz=bba043357ba6c78fd46430c169710a264109ee5dadb79b98075744bac273418c
-dist/2025-09-16/rust-std-beta-armv7-linux-androideabi.tar.gz=ab5726ae0472a8563b7e1e0dd6de32e1e9ee2dca45259bd1d382a24167919c61
-dist/2025-09-16/rust-std-beta-armv7-linux-androideabi.tar.xz=5af2a58f78fcd9dbcf1fac95cb50633ab9128e1e728960c0025e310a5528326f
-dist/2025-09-16/rust-std-beta-armv7-unknown-linux-gnueabi.tar.gz=9ff1f79f8c03756b41f8386995dbb011387982a657262c013579d0866a18ff1d
-dist/2025-09-16/rust-std-beta-armv7-unknown-linux-gnueabi.tar.xz=32dd8b2be52449b4e592a87acfba122b80990d2993fa81b48b81c0de4afb1533
-dist/2025-09-16/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.gz=7420a4ecd9ebb55b6864a22fedec9def0585f8460eaebbcd9e236cac2ae0a6a8
-dist/2025-09-16/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.xz=75de468d6d4041d77e5757118c3c93df6319f30ba6372fdc8e859b9e48f27d81
-dist/2025-09-16/rust-std-beta-armv7-unknown-linux-musleabi.tar.gz=96f7dbe5d4bfe852b22f971cb59b7fa0981fd7fdc9e8d28fd1b6f6ae3bc59bfa
-dist/2025-09-16/rust-std-beta-armv7-unknown-linux-musleabi.tar.xz=4166e6b0c28eca8a507f1d3c83948ba09361198466eeb648f491d9850e884df9
-dist/2025-09-16/rust-std-beta-armv7-unknown-linux-musleabihf.tar.gz=035c4db6428b912280ac56bb520bad29255b3c30bec0e89839721443109a7ce5
-dist/2025-09-16/rust-std-beta-armv7-unknown-linux-musleabihf.tar.xz=4a94449dd1f02d748c79ec1aed3907cbce97dc5641e5be3b3011234ef3517987
-dist/2025-09-16/rust-std-beta-armv7-unknown-linux-ohos.tar.gz=94006dd7c1a1d6cb28972369a0b0c429de992d541549d4b292fd6b737eacce24
-dist/2025-09-16/rust-std-beta-armv7-unknown-linux-ohos.tar.xz=bb5cce4d13f2ae9d9d6f254d021d516189f29b6e78f3c1824e0803f7856ce7e9
-dist/2025-09-16/rust-std-beta-armv7a-none-eabi.tar.gz=453d62c4392ffd108233b7ce9b6abf0cc04b28a63bbbc5b979927ed7e9f8481f
-dist/2025-09-16/rust-std-beta-armv7a-none-eabi.tar.xz=9b4093e7735ffe3c79f16f99a412492588a6652242e2a18c0f278e24e34cb333
-dist/2025-09-16/rust-std-beta-armv7r-none-eabi.tar.gz=293dcff7ac56a7f52fbfa1afef9fa2b4a3e14b9b418c5a56e12e8c7cc76c963f
-dist/2025-09-16/rust-std-beta-armv7r-none-eabi.tar.xz=75f3737b88d197769d999b484aeb6aff705696fdccec8f3772c7a1e10630b146
-dist/2025-09-16/rust-std-beta-armv7r-none-eabihf.tar.gz=3d988af87a2c90efc5674f77baf67f5933fe60ae6ab9f4eb4256f14d98446824
-dist/2025-09-16/rust-std-beta-armv7r-none-eabihf.tar.xz=e91a15900421a8a445a7a0038923ad197fea4ec19e972ba7ff75fd4dd7d7ac12
-dist/2025-09-16/rust-std-beta-i586-unknown-linux-gnu.tar.gz=19795fe21f305ed033354d127f8e9e7aa0e9d7c67f756d22beb161aaeb9a0742
-dist/2025-09-16/rust-std-beta-i586-unknown-linux-gnu.tar.xz=8afa409edf8dfb45eab3565add6dde2fa71118008ee1e7e1416fb8dc11f66fde
-dist/2025-09-16/rust-std-beta-i586-unknown-linux-musl.tar.gz=43aaa9101863b6a419330ec75f0ffde61faf2a27f050947d2a200e5a705dd085
-dist/2025-09-16/rust-std-beta-i586-unknown-linux-musl.tar.xz=86ac890f2aaee4382a126ad9e667d53039dbca550aa548090706bdc308749962
-dist/2025-09-16/rust-std-beta-i686-linux-android.tar.gz=c3df364048b9af096c607a8e5639dc37d470ab125441ea04a2f2241766338bd5
-dist/2025-09-16/rust-std-beta-i686-linux-android.tar.xz=556bb5e7e4effb543c04a64cba683b81a6ffaa319cf1d053482968767480b9b9
-dist/2025-09-16/rust-std-beta-i686-pc-windows-gnu.tar.gz=8c141a8c3b4cdbc2eff61d2a557fa602b9039dd54ff2000d0a0b790ae58c0879
-dist/2025-09-16/rust-std-beta-i686-pc-windows-gnu.tar.xz=3995a3c391e242663533680600a38343396e2a73b6876b1dd691d83dd143eac7
-dist/2025-09-16/rust-std-beta-i686-pc-windows-gnullvm.tar.gz=3da461c03124d6ca148ed1d4cc80be4bd0d9f4610df95770ca800d72ef6c2b4f
-dist/2025-09-16/rust-std-beta-i686-pc-windows-gnullvm.tar.xz=7eaba102d1ce8ea0461657dcce62a5f8826f2154f56f89e9385e75fdc763c399
-dist/2025-09-16/rust-std-beta-i686-pc-windows-msvc.tar.gz=d1e31c04ff2145122df2ab05af6e2ba1091d1788741234cc39524f1289886187
-dist/2025-09-16/rust-std-beta-i686-pc-windows-msvc.tar.xz=330aca62a0cb38342ce6eda427c6074651ddd0c83c4b28b53ddc736edf049ee5
-dist/2025-09-16/rust-std-beta-i686-unknown-freebsd.tar.gz=48dabb6775c14d23bf04a8c5c26f2e4d6af369dff6d506aa08cf2a08d75a5d8d
-dist/2025-09-16/rust-std-beta-i686-unknown-freebsd.tar.xz=db97db17addbf5d4e314f77ac9bb232a661042edf7beeed73b252e44c6439fe8
-dist/2025-09-16/rust-std-beta-i686-unknown-linux-gnu.tar.gz=3abbec5a87dfe240bbdaf6e9a92acb2d8e6e684983803daadc7750290da71264
-dist/2025-09-16/rust-std-beta-i686-unknown-linux-gnu.tar.xz=568aec0d1427a2d866c7550dfc770be13401902741999410d4dc2e7772ec0a57
-dist/2025-09-16/rust-std-beta-i686-unknown-linux-musl.tar.gz=0739e8dcab50c87156cb3e52a18b57da6040fffd9509561fb3046e81be953a40
-dist/2025-09-16/rust-std-beta-i686-unknown-linux-musl.tar.xz=8ed8a4b1f402593db73fc2e9540664d9e4e12b8e1b5f027e56b2f3c4784a8995
-dist/2025-09-16/rust-std-beta-i686-unknown-uefi.tar.gz=40a2726131ef0e6102667bcc8ea9a64b4b19f12d58696ab434b74f9abf37cee0
-dist/2025-09-16/rust-std-beta-i686-unknown-uefi.tar.xz=500b0018fe01e9a9949ca077bb69426078a2774e83b95319d09bab5d3f6d0e04
-dist/2025-09-16/rust-std-beta-loongarch64-unknown-linux-gnu.tar.gz=64aadbe1da544e2f08cafb217ec1ad341b8e2adc660f60502f700773983d059a
-dist/2025-09-16/rust-std-beta-loongarch64-unknown-linux-gnu.tar.xz=e864959561ee49a0ae680f93307929d0e16013d2ef0743a525c5d592faa10704
-dist/2025-09-16/rust-std-beta-loongarch64-unknown-linux-musl.tar.gz=c709c58bb18b5a9385e07998dfe31e3ade0661fbfd4811907a6e7cfffbfe2e6c
-dist/2025-09-16/rust-std-beta-loongarch64-unknown-linux-musl.tar.xz=e797481997def9fe0a6466b31439d1eeb4b299c92cde3a25a7fdd557611f0888
-dist/2025-09-16/rust-std-beta-loongarch64-unknown-none.tar.gz=79d43f32d6830a0d3c9e1e8fca3ba87db44e692cc70431ac6cabea5bc59b8f0b
-dist/2025-09-16/rust-std-beta-loongarch64-unknown-none.tar.xz=4d158a9d4f4e1943b2d00fd19adad762c35af24200742440bccfea62304272b8
-dist/2025-09-16/rust-std-beta-loongarch64-unknown-none-softfloat.tar.gz=f0c460fee60c913463d9c1fbe369287ab436cc7e2882487afef457c78cf86ad3
-dist/2025-09-16/rust-std-beta-loongarch64-unknown-none-softfloat.tar.xz=f15e2baff9b0ce68ca7e1595f00b21c45bff33a1b75fbf05a8f04b096295aa0f
-dist/2025-09-16/rust-std-beta-nvptx64-nvidia-cuda.tar.gz=102c4017e11cc3407f4871aaade7f3292c8cdc92707a243788e0e4a62604cce0
-dist/2025-09-16/rust-std-beta-nvptx64-nvidia-cuda.tar.xz=6eaad8877694af02a10d18ce609b6678d96e75f87a1684b67279c9915601bd3b
-dist/2025-09-16/rust-std-beta-powerpc-unknown-linux-gnu.tar.gz=26139715f7faac9be6e458ee1be840db044692a518cd0fde29c59454405d3063
-dist/2025-09-16/rust-std-beta-powerpc-unknown-linux-gnu.tar.xz=0edf1c0a3b8ce5dc76f1ade2dceb91f96a5afa3e54c7f25f3d3320dabeab06f2
-dist/2025-09-16/rust-std-beta-powerpc64-unknown-linux-gnu.tar.gz=dbdd4f2cb5cacdf2656f83f0dc0b2101613cc344819e9ba8e790406e17d16b16
-dist/2025-09-16/rust-std-beta-powerpc64-unknown-linux-gnu.tar.xz=a6dd7f0416ceea63ac723d4aeaf9cbd8d7ed8ed7d5b8925b3317cee75b9138df
-dist/2025-09-16/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.gz=424eabcd66e922cb61757842c46afd298cac2e1ff809b593f6f409732261f4a3
-dist/2025-09-16/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.xz=7ac3a7e79c5b3c498daad88a6f926544eaf59d04711cf20ba05c1391544a4335
-dist/2025-09-16/rust-std-beta-powerpc64le-unknown-linux-musl.tar.gz=9e21d985a6702a96161aeb9ea6d1e12eb52136c7433b2ca5597c07b85a954939
-dist/2025-09-16/rust-std-beta-powerpc64le-unknown-linux-musl.tar.xz=69658c2818ff575eefbda5e64a2a6f253ce21f587a72afb2727466a923ec508f
-dist/2025-09-16/rust-std-beta-riscv32i-unknown-none-elf.tar.gz=25da1a37707d9dbac16d91f5177eaa5244f4280758f3b5a0bfbb09b5ae190720
-dist/2025-09-16/rust-std-beta-riscv32i-unknown-none-elf.tar.xz=52f6a0752e9db84c0efa49826988dd64f32930799ce2e057b3a6a20a5c696181
-dist/2025-09-16/rust-std-beta-riscv32im-unknown-none-elf.tar.gz=9f4f18ca2d1d4d7e8785f3ae61084aeaee7581d7eac2c7c883557cf30888cb57
-dist/2025-09-16/rust-std-beta-riscv32im-unknown-none-elf.tar.xz=2ef831047ada8f706fa30a655e8a2b17c15c1f10e65c66a0d3577085ff1e80c2
-dist/2025-09-16/rust-std-beta-riscv32imac-unknown-none-elf.tar.gz=9420edabe9112cb1ab9fee01dea1bdb30a866b4633205f287767c07fb57f4630
-dist/2025-09-16/rust-std-beta-riscv32imac-unknown-none-elf.tar.xz=ed7b43b375dc7c30e1bd1add31940192978ad86c5c6684b54b24252117e92008
-dist/2025-09-16/rust-std-beta-riscv32imafc-unknown-none-elf.tar.gz=cbb03936548c947633b7dff7952653aef98ae25d1ff79b8f8549e87158b6cac6
-dist/2025-09-16/rust-std-beta-riscv32imafc-unknown-none-elf.tar.xz=c957ec9bc4b1345bc805b506caeeee9350e9f07d31d4177796f461cce7e7a341
-dist/2025-09-16/rust-std-beta-riscv32imc-unknown-none-elf.tar.gz=46fd5976d8bd59a89ebd2c74cc246b9727516b28cb9b1a839ac06340d738a4bf
-dist/2025-09-16/rust-std-beta-riscv32imc-unknown-none-elf.tar.xz=a7640744bef500db2e7ebaafc4c93e73acb31b61faf47decef61ed46db73c001
-dist/2025-09-16/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.gz=537dd37985108561d6e0afe76238193fa33f1e600aba44b484a15d1f40d68142
-dist/2025-09-16/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.xz=bda3e2c4b93d864dd75bf64e08ba3d2ac9719581fb890c62073078d2005bd634
-dist/2025-09-16/rust-std-beta-riscv64gc-unknown-linux-musl.tar.gz=3edbf40890f0f52cb61c0ec8665a43d230e6e148dd4afbdbd7ca8ad53a0a2b8d
-dist/2025-09-16/rust-std-beta-riscv64gc-unknown-linux-musl.tar.xz=a515cc391e794e397ce34eb994f3a1c35cff7e7e31d54a859141000a52397c70
-dist/2025-09-16/rust-std-beta-riscv64gc-unknown-none-elf.tar.gz=d45fbe65a55b3010fd8994d3effec67f96d86593d37b6fefeb956f4a6b282e50
-dist/2025-09-16/rust-std-beta-riscv64gc-unknown-none-elf.tar.xz=13f9c87c6bed3b905ec7564fb79517e891b4a70d6c5191a876844199780f7a81
-dist/2025-09-16/rust-std-beta-riscv64imac-unknown-none-elf.tar.gz=e55f12443bf8c44e27d585bc1c38472e3175bb9d7913af55ab3bcd8f23498146
-dist/2025-09-16/rust-std-beta-riscv64imac-unknown-none-elf.tar.xz=5cde9db69b110f1766da147105e3a8d879dd36c69b2367416228024d183b12b0
-dist/2025-09-16/rust-std-beta-s390x-unknown-linux-gnu.tar.gz=3fb23f12e07d3b4ef59a637fe68c2ad1799aead28c65cf3d5d136dfea4c12eb9
-dist/2025-09-16/rust-std-beta-s390x-unknown-linux-gnu.tar.xz=999b7f7813d0d868bbda410fa37d26ba737d443a99ad74d8c2b0ecbc24fb1af3
-dist/2025-09-16/rust-std-beta-sparc64-unknown-linux-gnu.tar.gz=12e756fe1f5b57a752916b7397b981e288cc30b5861b16c5a710778c372be42a
-dist/2025-09-16/rust-std-beta-sparc64-unknown-linux-gnu.tar.xz=0d0ad94937379ac571397b7f10ec5aa20cccf5401aae16ad4d18582dc609055e
-dist/2025-09-16/rust-std-beta-sparcv9-sun-solaris.tar.gz=4bbe087dae754754f4dc1c05aaf664c5e0dd4429932feba88aab744e7c5b7472
-dist/2025-09-16/rust-std-beta-sparcv9-sun-solaris.tar.xz=dfa49be70f7ee3989cec7f634cf84e3b418f48882af8b69540e41f2ffb8cc216
-dist/2025-09-16/rust-std-beta-thumbv6m-none-eabi.tar.gz=598622e28c6ce111f4d47e2172a0657c3b0ca62c42895836376b1959fc2e094a
-dist/2025-09-16/rust-std-beta-thumbv6m-none-eabi.tar.xz=359bb98d293e1cea22a505377ce49ba95095c735b50b7d404ce4f36d84bdfec4
-dist/2025-09-16/rust-std-beta-thumbv7em-none-eabi.tar.gz=d1f994c835b1d72a665eeb7aa4683a09ac60c1977766b066c817c3eb37ad3a4a
-dist/2025-09-16/rust-std-beta-thumbv7em-none-eabi.tar.xz=22e8605af621866d82f2bdcd8089a561e10f4055624aa6dff5d704b953b7d547
-dist/2025-09-16/rust-std-beta-thumbv7em-none-eabihf.tar.gz=8e862615db8daf2c063d27f1860bd083fadefd459634e61b946ca05b8747308d
-dist/2025-09-16/rust-std-beta-thumbv7em-none-eabihf.tar.xz=8c9b3d2913242cd2e7fc690e02bd28690fa50b7278befa8b57ec9b7eec4f34e4
-dist/2025-09-16/rust-std-beta-thumbv7m-none-eabi.tar.gz=fa79d4e07630821149b151bc5673205a479570bfd971e66e874e75b5046bdfc5
-dist/2025-09-16/rust-std-beta-thumbv7m-none-eabi.tar.xz=f6f3c14f35d3b5fd01a6244f802d99e261e529bc6d4a6c5749b1cfccd524c16b
-dist/2025-09-16/rust-std-beta-thumbv7neon-linux-androideabi.tar.gz=194bc6660b3d4809d5f709e7f82159141e90b31d2318cd550b4deab65e108fe6
-dist/2025-09-16/rust-std-beta-thumbv7neon-linux-androideabi.tar.xz=36534004068562d8678a3cd73f8f82b50406aad6daeecf348246375da3bae720
-dist/2025-09-16/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.gz=622ec13126461d4d6c1f7eb3fc387279c03ffbb96fdbbfcc7c22c2433e62232d
-dist/2025-09-16/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.xz=a8162987ddefbde68e2931fc824371aa71d595106488a48732b67ec45f36ac4a
-dist/2025-09-16/rust-std-beta-thumbv8m.base-none-eabi.tar.gz=6d7f31ee7fd8633d8497cddfbe05a1ca064c4d45f50066e86cd82fe4b40b93d5
-dist/2025-09-16/rust-std-beta-thumbv8m.base-none-eabi.tar.xz=9b3309e290007406d410b8ee86ecef887d5c48b515b11cf7827baef23a0c4a7d
-dist/2025-09-16/rust-std-beta-thumbv8m.main-none-eabi.tar.gz=74fd7db50be0b77e7a44d1a32afc76f2a438fb789ea32f3ce1ceff00ccbf030c
-dist/2025-09-16/rust-std-beta-thumbv8m.main-none-eabi.tar.xz=e7736bc6c78eba1947ca6ec4ae5d875de192f44755ade737ce1e367f294576d8
-dist/2025-09-16/rust-std-beta-thumbv8m.main-none-eabihf.tar.gz=d8905fddbae4ae3e39439fe5234cd05454034d9f2a847056766bbe41126405f1
-dist/2025-09-16/rust-std-beta-thumbv8m.main-none-eabihf.tar.xz=94628c4c60615b15f1c5b331a803d4d1963289b770ba54adc4458e52d17397fe
-dist/2025-09-16/rust-std-beta-wasm32-unknown-emscripten.tar.gz=68c53c1069b29461573c68b5df7ae2e30b4b7dd682cde70f26a200854525c012
-dist/2025-09-16/rust-std-beta-wasm32-unknown-emscripten.tar.xz=cc1a4d61bc45832fa1ae19ecc1347d084249f1be3553fb33d33f0e5d8df5fe5d
-dist/2025-09-16/rust-std-beta-wasm32-unknown-unknown.tar.gz=a33ed15817407053144b8a6041dab287a390b3338dafcd1b02418b3dbe18b024
-dist/2025-09-16/rust-std-beta-wasm32-unknown-unknown.tar.xz=f0df12d2767da7528c614f5bdf6a9c6bec831b4020eed357409d3fc7fb0c869c
-dist/2025-09-16/rust-std-beta-wasm32-wasip1.tar.gz=86634e652b087947b914b590a2e978ef1d29d09b69afff63a682f26b6dcac41d
-dist/2025-09-16/rust-std-beta-wasm32-wasip1.tar.xz=04e2a9c6914b17664443b674827ab706869a81200c885e97779df0da98682612
-dist/2025-09-16/rust-std-beta-wasm32-wasip1-threads.tar.gz=3fef167485111064b1d468e5664d9173e24dbf20406165f92293f304457aeee0
-dist/2025-09-16/rust-std-beta-wasm32-wasip1-threads.tar.xz=7e12cabce073a54fbd4c97d3169e34e4beb3872a161c7c082e148b0d4adb2f7b
-dist/2025-09-16/rust-std-beta-wasm32-wasip2.tar.gz=3b8f3e6d4ce34bc8c5300b77bdf875b04a69f87f73d930439bacf56f061f667f
-dist/2025-09-16/rust-std-beta-wasm32-wasip2.tar.xz=056ad523469276f90f185b72696b20c6b47f57b5721544a20f6e765cc51769fc
-dist/2025-09-16/rust-std-beta-wasm32v1-none.tar.gz=fee626762c4bee195d800883ba15d890604280f0cddb08aa64a6199fc4591635
-dist/2025-09-16/rust-std-beta-wasm32v1-none.tar.xz=7bc289363efb2d5555e9742bf619decc2454cb784c133db55a71be4c0aed9f90
-dist/2025-09-16/rust-std-beta-x86_64-apple-darwin.tar.gz=51cf2f8f249da5df653efb073c81047583bc7bf952a4b03d6d05c9fecb7fa0c7
-dist/2025-09-16/rust-std-beta-x86_64-apple-darwin.tar.xz=4e380037df6b548916136138069e76139dbc069688ec717632c30a07854d0739
-dist/2025-09-16/rust-std-beta-x86_64-apple-ios.tar.gz=b232b73befda81ffaf0d1db7838e2057c503cf2f4f1e95f0706cfd0faf77d853
-dist/2025-09-16/rust-std-beta-x86_64-apple-ios.tar.xz=1431fa936f5909e4e92894c7e2074d3db879c10cf3f2344b050f9c77965d1373
-dist/2025-09-16/rust-std-beta-x86_64-apple-ios-macabi.tar.gz=fb0a1f0228c051a85440933358f7c00d47c4ce44a15a0b0025b00331ec53f876
-dist/2025-09-16/rust-std-beta-x86_64-apple-ios-macabi.tar.xz=b725c62998a3b28caa1f89549230ff275af854a3d04cdb6562f19be7e8a1af31
-dist/2025-09-16/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.gz=b9588bd0c684a50e0d73717f5ae5c2f0e36a90052126d2c4a539e5a116eeb4e0
-dist/2025-09-16/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.xz=70affff2a14340109f86ec585b65bed16e77612ac7b939336245cc15f7f6c300
-dist/2025-09-16/rust-std-beta-x86_64-linux-android.tar.gz=fb9fc9bbfef414092ad1082d7529fa2efc52adc849a7f45da3d5688d5f6df1d2
-dist/2025-09-16/rust-std-beta-x86_64-linux-android.tar.xz=3fd9b4d89e7ee604f842f7915b90bb02a0c44f8a4694a2d10f94efe7bbf0840c
-dist/2025-09-16/rust-std-beta-x86_64-pc-solaris.tar.gz=caa39b90ac5ff710cc76828ca52c784e48518b9c3f1c58cb6f6603a7d05f87b7
-dist/2025-09-16/rust-std-beta-x86_64-pc-solaris.tar.xz=6034b44e5e7bca888027a21d8a4b1229c08fd22b744b83ab817d487aa5e6db56
-dist/2025-09-16/rust-std-beta-x86_64-pc-windows-gnu.tar.gz=6e7a9aa27a85a09c603fb624ea1cc56120ccbf5b4fed1be8d0097232cd1bf849
-dist/2025-09-16/rust-std-beta-x86_64-pc-windows-gnu.tar.xz=00f6c500331f2f75ba9c56f896db1420c353e8c0fae450da6b5806794cd58fc7
-dist/2025-09-16/rust-std-beta-x86_64-pc-windows-gnullvm.tar.gz=9279908bfa629467d619143e5e0abbcec7a843dddd0f6737994f636edb171e90
-dist/2025-09-16/rust-std-beta-x86_64-pc-windows-gnullvm.tar.xz=f1eca139e01d2a8a2627c064f3cc14d7a2016c50738fdc19d3d586f225066f79
-dist/2025-09-16/rust-std-beta-x86_64-pc-windows-msvc.tar.gz=1fdcf7de3772c24733474e5c0f3e64b56ca627e5a235b890ba0efa2265648d79
-dist/2025-09-16/rust-std-beta-x86_64-pc-windows-msvc.tar.xz=23f9e2447316fda77b7a5af90c160c89d9f5ed735c7d5715cc2850b92fd1cfe6
-dist/2025-09-16/rust-std-beta-x86_64-unknown-freebsd.tar.gz=8dbdbe296c35e64170b9d1e7361a90aa260e456ea7ae4bd969db1dbcad976532
-dist/2025-09-16/rust-std-beta-x86_64-unknown-freebsd.tar.xz=9469e49e425349514f2bd224ccc64903c163bb481a425e01122bd3bf00ebc90d
-dist/2025-09-16/rust-std-beta-x86_64-unknown-fuchsia.tar.gz=6e97622b123772e4deaf91b81d1925fe2d39b87f567b96437c03c16a0982b709
-dist/2025-09-16/rust-std-beta-x86_64-unknown-fuchsia.tar.xz=0affcbb44870daa9410887cea10844ad1f48b4e1aec053274e86e39b42aba360
-dist/2025-09-16/rust-std-beta-x86_64-unknown-illumos.tar.gz=3023abaa7f221946e1e9cd40d4a607e8c57bddf8a250a27e0d58dd95a51ef877
-dist/2025-09-16/rust-std-beta-x86_64-unknown-illumos.tar.xz=1e76ba54bdd6673428efae1407e0e5991115f59885159e68e9d63cdfda9ca7dc
-dist/2025-09-16/rust-std-beta-x86_64-unknown-linux-gnu.tar.gz=92db1c0d785820c128bf4ad05b567b17871d2f01ef902052a90839e3fe744979
-dist/2025-09-16/rust-std-beta-x86_64-unknown-linux-gnu.tar.xz=233d981cbd309a03b16c5a80037faf992c47548cedf5ab4593db41554ffb8525
-dist/2025-09-16/rust-std-beta-x86_64-unknown-linux-gnux32.tar.gz=fe3fd22ad099bae73ffcf1a4881ee2f2c520c6108ac27ca0c64fc5111ec02230
-dist/2025-09-16/rust-std-beta-x86_64-unknown-linux-gnux32.tar.xz=027738f65f61fb77ceff38d9342915ca8344e0a1323e7659a1a5159c99c4a811
-dist/2025-09-16/rust-std-beta-x86_64-unknown-linux-musl.tar.gz=e6527497065541fc4701e71efd0a896a8048b653454a75f27765e5b7b6ac748d
-dist/2025-09-16/rust-std-beta-x86_64-unknown-linux-musl.tar.xz=807862fb874b7bee60b2740ed2df2454d8be50b0877d34b7bea796cfda69d583
-dist/2025-09-16/rust-std-beta-x86_64-unknown-linux-ohos.tar.gz=17259bb2f4bb1183ecb187296ae9afef58aa2f8e816d2764caf48aa3900fd66c
-dist/2025-09-16/rust-std-beta-x86_64-unknown-linux-ohos.tar.xz=e459cff284cd0ee388ab65c945bfca4c64b32fd268ee66c2cd8abc325580ed12
-dist/2025-09-16/rust-std-beta-x86_64-unknown-netbsd.tar.gz=5a60ff084d1da42324d6956510a68b3b83a47b432b48e2228e58f52dc8c01b69
-dist/2025-09-16/rust-std-beta-x86_64-unknown-netbsd.tar.xz=9d6823b8b1605f748f1d7af5c52bed1dd926a1d5fbd01ea9a8f939f3648b7800
-dist/2025-09-16/rust-std-beta-x86_64-unknown-none.tar.gz=57b0a2838c59feb0808462fc043c9a85a292f0025104dd6de3c5e78d4d71894d
-dist/2025-09-16/rust-std-beta-x86_64-unknown-none.tar.xz=e5a5cd9c861b29d11ae110dd4b239d5069dd0aac57202bfa440e15869f5c7e9e
-dist/2025-09-16/rust-std-beta-x86_64-unknown-redox.tar.gz=f9cdee694af41422f785126fda566891357295b5fae56268188bbf2978b92089
-dist/2025-09-16/rust-std-beta-x86_64-unknown-redox.tar.xz=8c7668ceb1611dafd9bb9ffa6de9a11e39d049cebeba05e2dfa889e69d94a54c
-dist/2025-09-16/rust-std-beta-x86_64-unknown-uefi.tar.gz=33045879d1aebfb17faf93bd471bb4c4ee3b9a787c57704814ab2dd301ac8ba6
-dist/2025-09-16/rust-std-beta-x86_64-unknown-uefi.tar.xz=28018cd9cd16e428790600decff5c7df749fe500861ecd3853895ebe69fb7100
-dist/2025-09-16/cargo-beta-aarch64-apple-darwin.tar.gz=f0642e83a5a6c8654d724e4929c0e58a4c07c330eae58fc4794ab94721b2732c
-dist/2025-09-16/cargo-beta-aarch64-apple-darwin.tar.xz=13cd17e3f35cc0214b25b65463b2394f3642ff8acf4e13af20b442b0100556a3
-dist/2025-09-16/cargo-beta-aarch64-pc-windows-gnullvm.tar.gz=fa047b7d7ad4ab64b85ca7beef052a66a89c60f976b099364eb3acfd2867c3fc
-dist/2025-09-16/cargo-beta-aarch64-pc-windows-gnullvm.tar.xz=df3a9254c4f329454dae9428d88f6c3e69ee8a120bf2eb380193eee63620ed69
-dist/2025-09-16/cargo-beta-aarch64-pc-windows-msvc.tar.gz=e5b608ae84d9258bccee0ecbefaefbaf34b989cd656f096692ea84c6f8d78645
-dist/2025-09-16/cargo-beta-aarch64-pc-windows-msvc.tar.xz=8ad0c0d49f7f6ebc5cce4a2b76036c2d0eb8adb38ce11125e2b36a1291b8ebd7
-dist/2025-09-16/cargo-beta-aarch64-unknown-linux-gnu.tar.gz=f454f83f4ffe0095d3285011b3abae11b0331d87d398ff95622e9091ee09826a
-dist/2025-09-16/cargo-beta-aarch64-unknown-linux-gnu.tar.xz=29c83085c7d51874e943b429999cf7709c0cdc422b1254a5e587aecd653430b4
-dist/2025-09-16/cargo-beta-aarch64-unknown-linux-musl.tar.gz=8f85db99809ae593abb4806ffced52abf048dfae81891ab68ef4c83f11f03fb2
-dist/2025-09-16/cargo-beta-aarch64-unknown-linux-musl.tar.xz=e5f004172331f658c3027084950360e1d60bd0cf3cca83fa43cf7fc251cefd37
-dist/2025-09-16/cargo-beta-arm-unknown-linux-gnueabi.tar.gz=1aae91a92e1d41e9c53ede795f91e7dccd3dea687d84151e507f4d3af089f15a
-dist/2025-09-16/cargo-beta-arm-unknown-linux-gnueabi.tar.xz=369b8686197e4be3883c3225bb9c186b17839552c91117750abf428255df9c8f
-dist/2025-09-16/cargo-beta-arm-unknown-linux-gnueabihf.tar.gz=b2e9a3c467ca2847f4ef55241b05a4f5151ca2608e05a43e5101c62d9d6a399d
-dist/2025-09-16/cargo-beta-arm-unknown-linux-gnueabihf.tar.xz=aaf6bfeb90e732627ae98f4b86083b3a902e31a951b98b3b5e94b67ffa6771a8
-dist/2025-09-16/cargo-beta-armv7-unknown-linux-gnueabihf.tar.gz=75bcce21bcd655a537b77aeca644f5279ace4f782a97d1e82de3cbe76a7df6ee
-dist/2025-09-16/cargo-beta-armv7-unknown-linux-gnueabihf.tar.xz=287800d221906551a50922caf0637049f3490e17c65d62119c6a26ce48d5ffa8
-dist/2025-09-16/cargo-beta-i686-pc-windows-gnu.tar.gz=89a6059faab9a3e912dc2baae766ed232d38c240c90f503bb2b486225457e8f5
-dist/2025-09-16/cargo-beta-i686-pc-windows-gnu.tar.xz=96e5b7238f543edbcfb16022ec6aa6d3643add1f7b4b0febc3e35ff9d173c075
-dist/2025-09-16/cargo-beta-i686-pc-windows-msvc.tar.gz=39ed55c1619ade6fc49fefa5ba5bfbb67aa34e53d35384a35c37d0681596b9ba
-dist/2025-09-16/cargo-beta-i686-pc-windows-msvc.tar.xz=d9ce7d301af311d58d1b4342855b70dfbe0fa8bb365b78bd83822e58a7ce9086
-dist/2025-09-16/cargo-beta-i686-unknown-linux-gnu.tar.gz=2dc0a357f58462c5474cb5c83445bb17d22450056fc77d3a92c844f104e1c96e
-dist/2025-09-16/cargo-beta-i686-unknown-linux-gnu.tar.xz=c2e4f00fc345a77da5f13642d6b65a77df553ac0cb596fa34f837d76fac460c8
-dist/2025-09-16/cargo-beta-loongarch64-unknown-linux-gnu.tar.gz=e1b5e490a00eecf93d7c591628c8d231eadb8c68104978b623fc16c5369248e8
-dist/2025-09-16/cargo-beta-loongarch64-unknown-linux-gnu.tar.xz=c2f91d72d2977168eb12179abd98b4d18f67de4ed455856f7af18a860ff5b1c5
-dist/2025-09-16/cargo-beta-loongarch64-unknown-linux-musl.tar.gz=7fa229d54c917a4872efbc2e9eb9181f5b1133aa44508548e94e4529ab099cd4
-dist/2025-09-16/cargo-beta-loongarch64-unknown-linux-musl.tar.xz=359d7ec4bc7e0eed1c936bff9cee56bc3a132a488499cb83a8e7561222893c66
-dist/2025-09-16/cargo-beta-powerpc-unknown-linux-gnu.tar.gz=fe514bf5afccb535517decb4c3120375eefc36def2190d60f4f0f6d796af1b79
-dist/2025-09-16/cargo-beta-powerpc-unknown-linux-gnu.tar.xz=d3d1307f3f60e9d8ee9f199441185bcb52a7bf5de460302291b178ef282a457e
-dist/2025-09-16/cargo-beta-powerpc64-unknown-linux-gnu.tar.gz=e7c77c9baf683994bf180b8906d55a2117f5bff85fec6c602a6f1912c39b2817
-dist/2025-09-16/cargo-beta-powerpc64-unknown-linux-gnu.tar.xz=207e6fe0baedb7f19e8a0437e24cfb9b46d4131a141863c93a52d00f1b049d8d
-dist/2025-09-16/cargo-beta-powerpc64le-unknown-linux-gnu.tar.gz=87433380a70642842f7dcf4a4c8614cbc136a18198837e631dce419e99ae71b8
-dist/2025-09-16/cargo-beta-powerpc64le-unknown-linux-gnu.tar.xz=207106c6e7c129fe19940da029360f8ce42f29468836a094a2b02156121888ed
-dist/2025-09-16/cargo-beta-powerpc64le-unknown-linux-musl.tar.gz=ad90e19faff850cbb03eb04195943a9f65169d6a7b030422f0310f8c053e61c3
-dist/2025-09-16/cargo-beta-powerpc64le-unknown-linux-musl.tar.xz=7abcb3c3cf3710fcf41d67664137bd0c823792a70cbd82004e0cbbef58446f44
-dist/2025-09-16/cargo-beta-riscv64gc-unknown-linux-gnu.tar.gz=7acc6031840a56c47dd2d52a6ce169663ffadb108e92743b22a6dd9a7227baa4
-dist/2025-09-16/cargo-beta-riscv64gc-unknown-linux-gnu.tar.xz=a2ae500b6c44abeb6cbb42a07a37a8e0ded707fdc1e3f4d6159aaec404912f5c
-dist/2025-09-16/cargo-beta-s390x-unknown-linux-gnu.tar.gz=3a69ae63bde95a6dd4020395b90e821e4342fa1b45b00d12ea30f3b1c643ef59
-dist/2025-09-16/cargo-beta-s390x-unknown-linux-gnu.tar.xz=231b1b052018ab851c57563d3c3b4a943cc01f99e3ca6795dfb6a1315d2577c8
-dist/2025-09-16/cargo-beta-sparcv9-sun-solaris.tar.gz=41677b7f137d6509bf7e0fa2eaeefd91d03316e566136d37d006fd98a2a4c28d
-dist/2025-09-16/cargo-beta-sparcv9-sun-solaris.tar.xz=f5b4057e69c50258c3edf00dd71f47951833ae892b121641d8d3a0bd38991838
-dist/2025-09-16/cargo-beta-x86_64-apple-darwin.tar.gz=edfe3b23fe5824b5ae763871f133cce684ace0999afd38e9a7b2a08f17b12ac0
-dist/2025-09-16/cargo-beta-x86_64-apple-darwin.tar.xz=173ec4d3c129530c33623f2ec6a5fdc5d739ecfd24f7372f3713ea94aeab8eb1
-dist/2025-09-16/cargo-beta-x86_64-pc-solaris.tar.gz=fe0f57ea7eafb5e157a04cd753b4f6b733245fa8e9baddccf581cec0a7ea2ed4
-dist/2025-09-16/cargo-beta-x86_64-pc-solaris.tar.xz=61ac8a524964f2179c8195d821382597bc8641eace9ba1c27e81453ab8c347e0
-dist/2025-09-16/cargo-beta-x86_64-pc-windows-gnu.tar.gz=44200f95def8558a8b7b85c11533841786d3fd17331e13056dd7ce25de667b2c
-dist/2025-09-16/cargo-beta-x86_64-pc-windows-gnu.tar.xz=7144031f2f69bb3bba08cca81e15dc557424c096f9555678b1bd1dd5f4891360
-dist/2025-09-16/cargo-beta-x86_64-pc-windows-gnullvm.tar.gz=a7a9c76ec0cb87a725c44336cad0182cbf2c1e06d19cbfa0311501541c08c852
-dist/2025-09-16/cargo-beta-x86_64-pc-windows-gnullvm.tar.xz=0b66de9c68f0ec42a410a898468dd67f147284911803207053a01fb2d29b65d7
-dist/2025-09-16/cargo-beta-x86_64-pc-windows-msvc.tar.gz=de26ef4d9091775cceb21af53cb1177922f8eb93763c0e333e59205dcb05ffa5
-dist/2025-09-16/cargo-beta-x86_64-pc-windows-msvc.tar.xz=e6823ffc56d1136d02384acd09e73b6e45ee197c2126b49aa95df832704b9d24
-dist/2025-09-16/cargo-beta-x86_64-unknown-freebsd.tar.gz=dd0656bae2fbf483ebe641ed952499f0127897b09fe14273046cc8e0c7611825
-dist/2025-09-16/cargo-beta-x86_64-unknown-freebsd.tar.xz=6c8b65ac66bf730f9c5bb7caffc75ab1912439d033130438d98ebdaa1a2b922a
-dist/2025-09-16/cargo-beta-x86_64-unknown-illumos.tar.gz=5c3f38613b4d2f26643bab1a6db5b769f58878e47168dc92bc2c7b2fe9559ae1
-dist/2025-09-16/cargo-beta-x86_64-unknown-illumos.tar.xz=046ee0c80efe70375179c95461af5724cb00eb9ecc1d995e4a629d316d853686
-dist/2025-09-16/cargo-beta-x86_64-unknown-linux-gnu.tar.gz=b6da1a94fa5718c5a1be4d67d6422d28e62365a433d82f11fe7f09149690e78e
-dist/2025-09-16/cargo-beta-x86_64-unknown-linux-gnu.tar.xz=5b8aeabb11e88e4cb02c766c11c0d3d826ded4d08874a11127d8f73f033b0072
-dist/2025-09-16/cargo-beta-x86_64-unknown-linux-musl.tar.gz=00f191b30c29d46e503bfdc49c112ac5295bb67caa091333b0caf210e08d3f01
-dist/2025-09-16/cargo-beta-x86_64-unknown-linux-musl.tar.xz=750060cc199fac6990597a9859234392f4c0a5405d87d1234fc7990032b4c138
-dist/2025-09-16/cargo-beta-x86_64-unknown-netbsd.tar.gz=12513081e2bd88c666881e77e3c4935c710cd6132d9ec48cf9049ac7ece5dd9f
-dist/2025-09-16/cargo-beta-x86_64-unknown-netbsd.tar.xz=b1338ed261e33b0fa3e8a63c8930835d87d352ec10011bd4d626c44fa0b0392b
-dist/2025-09-16/clippy-beta-aarch64-apple-darwin.tar.gz=668e7fb88b52ad92634fc4d39885843b4893fbb9f34062e8c4fa870f0e71fbbe
-dist/2025-09-16/clippy-beta-aarch64-apple-darwin.tar.xz=a0fbf1903d1a95c6ca98ce98a3e639110022480d56c20e175e4fadf211baadda
-dist/2025-09-16/clippy-beta-aarch64-pc-windows-gnullvm.tar.gz=6593c10385d78ba68b38b8815e5c7aead991d83d9f689a42f4a2911a5f7f0450
-dist/2025-09-16/clippy-beta-aarch64-pc-windows-gnullvm.tar.xz=856303f96ed6bd1be89295dffccfc944cd70ce3d1921afc9366f19c6ac800b60
-dist/2025-09-16/clippy-beta-aarch64-pc-windows-msvc.tar.gz=e60f30cba9fe154e7446cf5b7114e7f8c153937eb58cca4cb24dad1b8dd453af
-dist/2025-09-16/clippy-beta-aarch64-pc-windows-msvc.tar.xz=24ae9f98df0f2320271b8250234f571b64a4b5ce983a083f45966e58f39b1c94
-dist/2025-09-16/clippy-beta-aarch64-unknown-linux-gnu.tar.gz=aeaf3ed45a8feda550b2043fcbc55ca9fa3eb95141dfecabb794fa9003d76a3b
-dist/2025-09-16/clippy-beta-aarch64-unknown-linux-gnu.tar.xz=3187bb767e36aee12059f1d2b77697aa57f71a3c478930c4901dfcd25d414369
-dist/2025-09-16/clippy-beta-aarch64-unknown-linux-musl.tar.gz=c2c23a91b2cccd4978fe612f22c33773833c87719259bd0d501e5a2523f3c689
-dist/2025-09-16/clippy-beta-aarch64-unknown-linux-musl.tar.xz=b7902a5d4dafd1301fb573148b6d1164b9365e976a9019151b66aa93b88e93bf
-dist/2025-09-16/clippy-beta-arm-unknown-linux-gnueabi.tar.gz=69e95f21ef2f59df25ee56c2dc10ed5306ca5b41299acea22d2d87d967d17575
-dist/2025-09-16/clippy-beta-arm-unknown-linux-gnueabi.tar.xz=24343efbed86314a6c292659ee0625cdc30bd655eec8009d8e2209a659dcda12
-dist/2025-09-16/clippy-beta-arm-unknown-linux-gnueabihf.tar.gz=404b0db1d121ad8fb1a43ecadaa84a79f976a68dbf088ed47fb31245e293445e
-dist/2025-09-16/clippy-beta-arm-unknown-linux-gnueabihf.tar.xz=f4fbf3a39e1b5d61a481109da644e44e58371c00a3224b187dfbe39827615a33
-dist/2025-09-16/clippy-beta-armv7-unknown-linux-gnueabihf.tar.gz=fabfcb98b0d9d69e5d022e40ab572d2e84c604dc8d4ba2c88d44501c2a7390ff
-dist/2025-09-16/clippy-beta-armv7-unknown-linux-gnueabihf.tar.xz=8c289d02256ff36412231b320c723becc8d83d5acf9c2325541367eb66f6443a
-dist/2025-09-16/clippy-beta-i686-pc-windows-gnu.tar.gz=13838c1fa366173219023000810ba180899b843f7d5c54ffb415c7a517f5af80
-dist/2025-09-16/clippy-beta-i686-pc-windows-gnu.tar.xz=a86b22e78175f89ff2b4dd40b9fbe91b4447914b226d7ef7d020903ed2c9581f
-dist/2025-09-16/clippy-beta-i686-pc-windows-msvc.tar.gz=fc2a9397912c6651e04dca0475dc74fcb9a50f370a0ef7f9c7987158dfc58d55
-dist/2025-09-16/clippy-beta-i686-pc-windows-msvc.tar.xz=bf4be32251bac244540759795afe760be13a134580cae8e3fd5956d8ed45b254
-dist/2025-09-16/clippy-beta-i686-unknown-linux-gnu.tar.gz=10580cdb4078d6a27e511ef71ed1a50f67202c1ba145fe315b63f2786ecf6428
-dist/2025-09-16/clippy-beta-i686-unknown-linux-gnu.tar.xz=5ef51556bc3b002a97e7b9f092ce280ee3b5c4a6b02a8d382d87a3f56d90eb04
-dist/2025-09-16/clippy-beta-loongarch64-unknown-linux-gnu.tar.gz=34756f99178d5be61df2375f4161aacfb05fbe4d38e9259bb7a01f71e842d67d
-dist/2025-09-16/clippy-beta-loongarch64-unknown-linux-gnu.tar.xz=1d10a5f1ac3bb2bbd84c421cdd1978865fccd214c08a341c7b6527c6674205bb
-dist/2025-09-16/clippy-beta-loongarch64-unknown-linux-musl.tar.gz=c0fc0dcc1a78960b53de22703e7764bb64bf35762127a8f272b45e95e64c7bc1
-dist/2025-09-16/clippy-beta-loongarch64-unknown-linux-musl.tar.xz=f41d1ac85d5714c6fbab9986ced2c80bafdf8251f37f16a5a9da994356b5912e
-dist/2025-09-16/clippy-beta-powerpc-unknown-linux-gnu.tar.gz=6f2cae468cc556a4083771c6e3e610f759cad00b7af7255db32d461d6e4f3dcd
-dist/2025-09-16/clippy-beta-powerpc-unknown-linux-gnu.tar.xz=6df81ef270b67457b96ae04da2801c2a80f9604df9c902e74140ab4b154a10ab
-dist/2025-09-16/clippy-beta-powerpc64-unknown-linux-gnu.tar.gz=fa4b89d3144ae42ac8c69f85f7b63f46cbbaefa1c3063f719a75dbf8e3ec39b2
-dist/2025-09-16/clippy-beta-powerpc64-unknown-linux-gnu.tar.xz=944976f337f4c27176ac614abc918a2bb037d30c554ba5e92e180d7247089cb9
-dist/2025-09-16/clippy-beta-powerpc64le-unknown-linux-gnu.tar.gz=30da372a7d750fc5e8509cd2265522b7d3d24ab8c37af24076fd0c6f48d47ea4
-dist/2025-09-16/clippy-beta-powerpc64le-unknown-linux-gnu.tar.xz=dfc5382049b525b461b5bd343f214f357bd3cf1a66d4d226658538639f4ca85a
-dist/2025-09-16/clippy-beta-powerpc64le-unknown-linux-musl.tar.gz=f5f500c286fc90f4b7808d45a77beaecd7ae3d5c99522dbc80f09132f078fbe3
-dist/2025-09-16/clippy-beta-powerpc64le-unknown-linux-musl.tar.xz=5a5da7891fae2f8fd1fba6a537cb3f26cf0aa73f0e36d01181fa20a82be3536c
-dist/2025-09-16/clippy-beta-riscv64gc-unknown-linux-gnu.tar.gz=538b09d45dbcfed24f521a29f5107a1b39efd8c3217991c21eb6c55603ab267c
-dist/2025-09-16/clippy-beta-riscv64gc-unknown-linux-gnu.tar.xz=e95cc43b991ab4d0f16c593171231bc134538f64ca40ddcdcbf5d2b73bce3307
-dist/2025-09-16/clippy-beta-s390x-unknown-linux-gnu.tar.gz=37b1903fc1e58f57574a2a6ad23014443d72d6e8aec35df0168028acc813c8ba
-dist/2025-09-16/clippy-beta-s390x-unknown-linux-gnu.tar.xz=04d65883b79cda42a26c0581349fbeb7023a25bb73db2e525483fc4895386e97
-dist/2025-09-16/clippy-beta-sparcv9-sun-solaris.tar.gz=057cb0d5ba11a7679a17d87304d1301cf583c86ad2faa23fc449d3cedf0ea1be
-dist/2025-09-16/clippy-beta-sparcv9-sun-solaris.tar.xz=8cf1abf779a8a5a18561f643a8fff9863909be7c3f8bc84be2d817fc262a1215
-dist/2025-09-16/clippy-beta-x86_64-apple-darwin.tar.gz=a1301c459894d6d9837b98ec8af238b26c401b860a78d458e34c3d747a8b5de3
-dist/2025-09-16/clippy-beta-x86_64-apple-darwin.tar.xz=af863a3fcae2193f8cc26d9b62854bcba6e029b0bef0f2151321bbabfc931c3a
-dist/2025-09-16/clippy-beta-x86_64-pc-solaris.tar.gz=5a3176859e8f783d8bf687d578100dabdd8196e52290a9de6b6902463b4f193e
-dist/2025-09-16/clippy-beta-x86_64-pc-solaris.tar.xz=93e37f354b89c94434c3c294cc54522ed503687ef62bb70a146196262993ce1c
-dist/2025-09-16/clippy-beta-x86_64-pc-windows-gnu.tar.gz=6403ea6cc8c3c3f83f29d894153ba3bc956b19fc213c11ed13d1117620fa543b
-dist/2025-09-16/clippy-beta-x86_64-pc-windows-gnu.tar.xz=a9ed248496eacebd88e33715b30253d9d2730087cff24427b34cf07b2eb89a1f
-dist/2025-09-16/clippy-beta-x86_64-pc-windows-gnullvm.tar.gz=5a72c9e26e4d59d013243d0d2416fe5280f2eb915f760470b4501731d8e8e05e
-dist/2025-09-16/clippy-beta-x86_64-pc-windows-gnullvm.tar.xz=078dd02a254accc28ee8b26a5e4b3349f013c629bd1da49948f0071184727ab9
-dist/2025-09-16/clippy-beta-x86_64-pc-windows-msvc.tar.gz=288ff79cc4cc4aec96d6ecd92c733e18aca2c846c87359e77d825cf57817c1e0
-dist/2025-09-16/clippy-beta-x86_64-pc-windows-msvc.tar.xz=fbc1421027dc77265be5d106d6db139a6a33b4e5ade0b1eba17e17a4ea59483f
-dist/2025-09-16/clippy-beta-x86_64-unknown-freebsd.tar.gz=1fc82034c6b8b38d60788ea3addaeea8ef4448d467def0a92bea750d060c4d39
-dist/2025-09-16/clippy-beta-x86_64-unknown-freebsd.tar.xz=3a3b7d4f98df124bc7c73ae46f0c776320c1a92c0d1dd7d7caa0d138e7068a3f
-dist/2025-09-16/clippy-beta-x86_64-unknown-illumos.tar.gz=f02880e995ed24f200b5c1711f2951e7eaeecc4ab144e50d866f11959e8fbeec
-dist/2025-09-16/clippy-beta-x86_64-unknown-illumos.tar.xz=a99652b13a6c3570bcdc41638a59b6d68b76562000ceb60a57128ee5065778f1
-dist/2025-09-16/clippy-beta-x86_64-unknown-linux-gnu.tar.gz=657275ab960c8c65b55b22bdbff5040440a039c9631017645a37506771f3d443
-dist/2025-09-16/clippy-beta-x86_64-unknown-linux-gnu.tar.xz=4ababcc7ffc0976218e62bd55666ff06e01350ecc790ae06effb2767521e169c
-dist/2025-09-16/clippy-beta-x86_64-unknown-linux-musl.tar.gz=5c454d363e6f8615aaf4d93e39306972e65a544f3a973c034333022aee321f33
-dist/2025-09-16/clippy-beta-x86_64-unknown-linux-musl.tar.xz=327cb34aff228c3fbc3efb389ddab0b50e5e135145602a8f9e5227fb70a462a8
-dist/2025-09-16/clippy-beta-x86_64-unknown-netbsd.tar.gz=87426803e7fc0bebdec6ae46f8ce536d947bdc57294e592599cb54d9d98d3d50
-dist/2025-09-16/clippy-beta-x86_64-unknown-netbsd.tar.xz=021d69fe47201dc89f394d084b70491d15718b24ceeba56e7cda18e3572f0309
-dist/2025-09-16/rustfmt-nightly-aarch64-apple-darwin.tar.gz=fa289216a17ce0b4fce43862f80087e4bcdaae7b20eac1f3776488b3986db45c
-dist/2025-09-16/rustfmt-nightly-aarch64-apple-darwin.tar.xz=1dade784b9caf54bc3ec5c9021d7c4ed1307f11f71d12af46961926a4ad6f7d4
-dist/2025-09-16/rustfmt-nightly-aarch64-pc-windows-gnullvm.tar.gz=0f221f2e4d5bece40307c4f7b095dd377ffadce916750c27bd7a2d5663eb6b37
-dist/2025-09-16/rustfmt-nightly-aarch64-pc-windows-gnullvm.tar.xz=3d7cdda977ddd4a49f27a2fcf9e0027ce9aebcc5f250e25c3788b6bb5169e8b0
-dist/2025-09-16/rustfmt-nightly-aarch64-pc-windows-msvc.tar.gz=28a44723d3c4da225592786db74f58af4af952b13112469910b5a2f58a7eb20f
-dist/2025-09-16/rustfmt-nightly-aarch64-pc-windows-msvc.tar.xz=7b4b9f2804488f90bdc9b4f5ac19aaaa9b82cff02c86b95aa0b7df0c805502b5
-dist/2025-09-16/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.gz=df6b42adce548127a2a549bc7b6e574de86c22533641c5bc725c1d5ad62af651
-dist/2025-09-16/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.xz=07d680aa64743ec6e8c417ff14747567fa6056738d6ed8c06db2c63c544f5201
-dist/2025-09-16/rustfmt-nightly-aarch64-unknown-linux-musl.tar.gz=66262bcc6e4fdffef1e9966bedaae64f27169980987425323fbf3a73ad46792d
-dist/2025-09-16/rustfmt-nightly-aarch64-unknown-linux-musl.tar.xz=f8125405f6437be0357eb594fc74842d6995e113b2475fd8fef6f778dddba539
-dist/2025-09-16/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.gz=bcf9fdad0b5209b1e12fd81a18927698f468995e708dd56e8212f977d4ac39a8
-dist/2025-09-16/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.xz=f7a7289e5f48ecf9ddbb214e6ab47280789a14065960f40a92d8dde3e1df57b4
-dist/2025-09-16/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.gz=e463b2bd6236463c68b2d0377bb33adff0daf17fc47dfe8f0857043b793a847d
-dist/2025-09-16/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.xz=96c15e4bbfb17be75003ada804b2da5bd750889c783e110a5a3481f045ecbfc7
-dist/2025-09-16/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.gz=6e53b146000b91f569aa5807e69dca726068d2c23e4a44c344592ef7a96927ec
-dist/2025-09-16/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.xz=a59f630b27fb33d188ba0dfcd3563a69bced49dfbc0fc1545b0c750bed41506f
-dist/2025-09-16/rustfmt-nightly-i686-pc-windows-gnu.tar.gz=ab6b4c2728dc0381f92af8b9f9c730507709e40ca7da89700bfca9b7adb93034
-dist/2025-09-16/rustfmt-nightly-i686-pc-windows-gnu.tar.xz=71950a1d4c6b04868cec2fcdd7c80bbdc675ed5c25917c774e3b6445bdff21c3
-dist/2025-09-16/rustfmt-nightly-i686-pc-windows-msvc.tar.gz=fd25c154f34b662d69a6d5cace59ebd605a1c4085a14ff8b8d597f5cb7324e95
-dist/2025-09-16/rustfmt-nightly-i686-pc-windows-msvc.tar.xz=15a2a897028e11992d2cae90d2a00f730a65f8b62ad500ff82c2fa83767b866e
-dist/2025-09-16/rustfmt-nightly-i686-unknown-linux-gnu.tar.gz=9516f97a5807b07d37e95a258b9cd60305c2b0429911c2425716e7f77a556eb2
-dist/2025-09-16/rustfmt-nightly-i686-unknown-linux-gnu.tar.xz=f665d43854449cb4ade4c518671ac5fef4a9640d276ff7d90c51c1bed08f9909
-dist/2025-09-16/rustfmt-nightly-loongarch64-unknown-linux-gnu.tar.gz=5de565b08f2641f3a7b58f79f5c63905859d39573f105ba05addcd4db5cb30de
-dist/2025-09-16/rustfmt-nightly-loongarch64-unknown-linux-gnu.tar.xz=0f3d7e4b91b6cab8ec9c534ae0f82ba79c57d621f25baa2b408bd2844edbc017
-dist/2025-09-16/rustfmt-nightly-loongarch64-unknown-linux-musl.tar.gz=7a33a965a41fd3958df003506da405a42cd459bc8689aea530b4a66122eccd3f
-dist/2025-09-16/rustfmt-nightly-loongarch64-unknown-linux-musl.tar.xz=b38a0cd88bec44e60b52e414237f50352900afb66e3f2b829acf92de5c060e3c
-dist/2025-09-16/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.gz=64cc62b309d4be3b004356637d726776c6765cee590cb0ca244e2bc3feb6368a
-dist/2025-09-16/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.xz=bf873d8101d8f2f3574387011749b3375298c7a828ba1ebed91536adf50be1be
-dist/2025-09-16/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.gz=3fba5ef7cdf564801de103e7724ac0d9096cdfd8340c75df09bc0ddc1e71a74f
-dist/2025-09-16/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.xz=c5a8af0f0689aabd52a337eb11a601877cd9f74efa2734d872f2752413551aea
-dist/2025-09-16/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.gz=4f1d6e182fbe1fc1a87949651e64a7f6896c3b359b7937b02d2c02b8e9db952e
-dist/2025-09-16/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.xz=29f7583b6f0af1239194c8d936a9f7e38f58920f6a4888d26ea1a48ab8c72235
-dist/2025-09-16/rustfmt-nightly-powerpc64le-unknown-linux-musl.tar.gz=f937a74b730cc1d064e0b4be538fa5bd51f636f8a5979367cff3a611d7893f45
-dist/2025-09-16/rustfmt-nightly-powerpc64le-unknown-linux-musl.tar.xz=d208b1998db3a896ea9c7c79ded0ad6ca4de452d3b6e696ffeeca44fe9fbc58b
-dist/2025-09-16/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.gz=6816dc3cdd53c883a7cad8e7237c1e22264dfdf6e1a8033b41887a52cd43a8bc
-dist/2025-09-16/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.xz=904b26d880f6b364458e9d0f682cab3a136b3498f27c913d6f422de6fa822e60
-dist/2025-09-16/rustfmt-nightly-s390x-unknown-linux-gnu.tar.gz=373a93410cc2fae30b952b036487417ec9e6211cd2e1980e60352329444a4376
-dist/2025-09-16/rustfmt-nightly-s390x-unknown-linux-gnu.tar.xz=8e1e328f2312cf458f8d7288624c11cc5f39bd7c8feef62147216689a5c28a13
-dist/2025-09-16/rustfmt-nightly-sparcv9-sun-solaris.tar.gz=8f22b6753dcad78a46cdc98251b27672bfa94f2ee11a655705fd7fa8a469ae82
-dist/2025-09-16/rustfmt-nightly-sparcv9-sun-solaris.tar.xz=b719b7167321d4be13eaea674f713269c35e4d34dcecaca38e32cb72aa8632c4
-dist/2025-09-16/rustfmt-nightly-x86_64-apple-darwin.tar.gz=63006d28e754c6e6afc5cea25527d4ea628ba084f0af52a36b676faf73f22e07
-dist/2025-09-16/rustfmt-nightly-x86_64-apple-darwin.tar.xz=b74a4e9726b5acf7133511b855088aa3ca9eaf5e5cd73a6d3b054e8a263ed6f1
-dist/2025-09-16/rustfmt-nightly-x86_64-pc-solaris.tar.gz=a3625dc34b971fd11e3d2f895a4933f4ec6b1e01475385cfd02e4eded528a99f
-dist/2025-09-16/rustfmt-nightly-x86_64-pc-solaris.tar.xz=1309352fa233debe6b1a06664da7f8d6db9e8b18afb60ca5709ca6a5ec657198
-dist/2025-09-16/rustfmt-nightly-x86_64-pc-windows-gnu.tar.gz=b765f3a632f74d7624ad10afb1875716b836dd6e5836736fbed6ce5fe7b00594
-dist/2025-09-16/rustfmt-nightly-x86_64-pc-windows-gnu.tar.xz=b74f1b6e563790926629952d25199eed14fa15e94845c962c79ac56df64cd18e
-dist/2025-09-16/rustfmt-nightly-x86_64-pc-windows-gnullvm.tar.gz=365e182e871e46e9f54b2265996c4531ae44b5f93a2208a5debcff5367026692
-dist/2025-09-16/rustfmt-nightly-x86_64-pc-windows-gnullvm.tar.xz=34712b98cd806caf8507b3afb292cd7bbf41599a395847336f617a9c952f911a
-dist/2025-09-16/rustfmt-nightly-x86_64-pc-windows-msvc.tar.gz=d04e6573a9253d4c5bf512f7b65415f08389c499d0024ac3990110ec1859b24e
-dist/2025-09-16/rustfmt-nightly-x86_64-pc-windows-msvc.tar.xz=98de7fe5863ce17a6f3c35ef9baff92124c5a398a008d80394a1ddc61fd29390
-dist/2025-09-16/rustfmt-nightly-x86_64-unknown-freebsd.tar.gz=01f052f3ec99702f7747610c3a5fd0a440a7a38bc5f4da93be9e6db48b599f3e
-dist/2025-09-16/rustfmt-nightly-x86_64-unknown-freebsd.tar.xz=38dcd9d9fedce55d75ea7151937cbdc4f6f76d92eb8039840e520faaa870182f
-dist/2025-09-16/rustfmt-nightly-x86_64-unknown-illumos.tar.gz=0341b4b7e5287aecafb3097334eeff773c83d5267c3a1c6edcea6c6ae1ee29fd
-dist/2025-09-16/rustfmt-nightly-x86_64-unknown-illumos.tar.xz=42ac68f632ca2d78b9b4647bde709eab84765f4376722ecb560d099cde89c7f8
-dist/2025-09-16/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.gz=af7491f1d5fee8a52768397966b75ca4104400e7023f373dd8b188aab4ae1b35
-dist/2025-09-16/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.xz=38cae1811a0e18ddaf094d3931d8d532c5eaba03fa2cc1149380ff9393e8f84a
-dist/2025-09-16/rustfmt-nightly-x86_64-unknown-linux-musl.tar.gz=631cf4d825237406f2992f44f26086672886b61fac0d7ff7a4991b25ec756ebb
-dist/2025-09-16/rustfmt-nightly-x86_64-unknown-linux-musl.tar.xz=ee52ab0c86918b2a155098cac489f5e639c0abd7064539d0e8a6a7502ca33c54
-dist/2025-09-16/rustfmt-nightly-x86_64-unknown-netbsd.tar.gz=67de842ff1f8cf99b0ad88ecefc17fa36359fa718e3fc04f243ad8c1595987bd
-dist/2025-09-16/rustfmt-nightly-x86_64-unknown-netbsd.tar.xz=349480a812b9861112e80ab86d3e80318d239af5212b314b3a7299dbbaffbf8e
-dist/2025-09-16/rustc-nightly-aarch64-apple-darwin.tar.gz=fe1ffcb90bdca92a61470c4f7cdf7bcdb4e7bf7c685ac0b92eb3a22509d88963
-dist/2025-09-16/rustc-nightly-aarch64-apple-darwin.tar.xz=b55d2837dcd2bdfbe8444e29d0f36ea584451c4f0b7fb7e9bcd77279e8cd820c
-dist/2025-09-16/rustc-nightly-aarch64-pc-windows-gnullvm.tar.gz=c303271dfc8ccd2c997e5ad88e2c3fbab6b9a188331217dbd46a6d96a53852ff
-dist/2025-09-16/rustc-nightly-aarch64-pc-windows-gnullvm.tar.xz=0d82ddfbeaf9380773bc91f294651609bc928cf53ce95fa89fc4a0f04e54ac67
-dist/2025-09-16/rustc-nightly-aarch64-pc-windows-msvc.tar.gz=6a8a14c5180e4cbd23bf144cf11dec5f47b769a717aeac03546d5cda83b766ab
-dist/2025-09-16/rustc-nightly-aarch64-pc-windows-msvc.tar.xz=915239fd57032010740ba9aebea3e018581993d2ae5d2ebab9ca42d73e48077d
-dist/2025-09-16/rustc-nightly-aarch64-unknown-linux-gnu.tar.gz=932a75ac114cb08c0eef0ef2189b463885a6d64334e25899ff386196ec59fc4e
-dist/2025-09-16/rustc-nightly-aarch64-unknown-linux-gnu.tar.xz=fcff7229b11ec8925d39830ce62892265f655ff272d9e3a167f102cb0cd8f098
-dist/2025-09-16/rustc-nightly-aarch64-unknown-linux-musl.tar.gz=3ae873418d17f15d46a1de95e945aa1e00d737b688e196d565031947b9dc420d
-dist/2025-09-16/rustc-nightly-aarch64-unknown-linux-musl.tar.xz=036eb7c219c6e1c447c5e6ee6d4635dcbcf4c1274c5a14f0dbe5eaee3f175f1b
-dist/2025-09-16/rustc-nightly-arm-unknown-linux-gnueabi.tar.gz=16484c845c672c775970f0108a8c336a11d2a2e4dd5f76bb5d1b74da1e436484
-dist/2025-09-16/rustc-nightly-arm-unknown-linux-gnueabi.tar.xz=9004db0b31113fa8ef0cd44318d0df62e76b8d30ac2a6332f6d483513e4ee7dd
-dist/2025-09-16/rustc-nightly-arm-unknown-linux-gnueabihf.tar.gz=6b3c245279a006b0516df26ca686f56cdf6233740d8c8b18bc19c5aefa84dbad
-dist/2025-09-16/rustc-nightly-arm-unknown-linux-gnueabihf.tar.xz=ecd58877e63d7d209a67ccb5a6e7693af38f2e249ce04001605ac49fcec45edf
-dist/2025-09-16/rustc-nightly-armv7-unknown-linux-gnueabihf.tar.gz=d5370d72328bd22b2fc79661061352c99d3288604bd1ed58ae2b798586db5f70
-dist/2025-09-16/rustc-nightly-armv7-unknown-linux-gnueabihf.tar.xz=5b8a6f255601c33bfd215b646b8ff164390e1eb7df69aeaf7be65d97dd9f426d
-dist/2025-09-16/rustc-nightly-i686-pc-windows-gnu.tar.gz=74ff396b8dfb28aa91692aced5ffa76f3e270d4c5a2e47b12eda5c4534e92bf3
-dist/2025-09-16/rustc-nightly-i686-pc-windows-gnu.tar.xz=953e50c365d084ffeac61d1279f89943e81b43922c6721f5e55f211d0fc61902
-dist/2025-09-16/rustc-nightly-i686-pc-windows-msvc.tar.gz=c3485374a990da572cab859f6cadbdf252d32e07d550e0f20fcee24be543050c
-dist/2025-09-16/rustc-nightly-i686-pc-windows-msvc.tar.xz=ea4afaf63f5b5c92f7feea4b82ae751f6f8bf8f54126d7007bc72d4815352628
-dist/2025-09-16/rustc-nightly-i686-unknown-linux-gnu.tar.gz=0635e9a84313f572d1883841f91bb49c7e7fed9a6dc5db751f00e7b00f140ce2
-dist/2025-09-16/rustc-nightly-i686-unknown-linux-gnu.tar.xz=8904638b6ab37416eedacfcb03c7b87fdcbe1fcd0e3a80e0e5f410c671959d44
-dist/2025-09-16/rustc-nightly-loongarch64-unknown-linux-gnu.tar.gz=3fab80f207dd5e8f5c276deb11512d55b5e97b3dffe44c1f0249e0c331ce2b68
-dist/2025-09-16/rustc-nightly-loongarch64-unknown-linux-gnu.tar.xz=95dd7df11dd2b9f27f8fc9e88f37ada794f9e0443cf1291c554f47485eee84dd
-dist/2025-09-16/rustc-nightly-loongarch64-unknown-linux-musl.tar.gz=a4e7d3c55c7acce10b1f0b59afb9e70d32c651b87a4d1381e945fc07543e474d
-dist/2025-09-16/rustc-nightly-loongarch64-unknown-linux-musl.tar.xz=f2ca377351093829123525578451c60987c3943be1783e396ab3d5f34e7735cd
-dist/2025-09-16/rustc-nightly-powerpc-unknown-linux-gnu.tar.gz=b7e5d9c1ecde1b69b17d29a3ac6d15af0e734a7666381f1adefd0bc31ea2c397
-dist/2025-09-16/rustc-nightly-powerpc-unknown-linux-gnu.tar.xz=1c18dca6d3ac47b8223ab1e67e94640f402ba8f2ab787b38ba85c49ca8143acb
-dist/2025-09-16/rustc-nightly-powerpc64-unknown-linux-gnu.tar.gz=0850c609f864638538f4a960ba34307045d74d10d462949e9728b2e14cf5eafc
-dist/2025-09-16/rustc-nightly-powerpc64-unknown-linux-gnu.tar.xz=ed4433fd1004935913d5a48faf78bcc4d2517f45e08032995414c69e4ede78ef
-dist/2025-09-16/rustc-nightly-powerpc64le-unknown-linux-gnu.tar.gz=9f54367ce8c0f2f1cbb29f84e403a8aebf9a3ec7d2675faa744e8c28b2adcd0f
-dist/2025-09-16/rustc-nightly-powerpc64le-unknown-linux-gnu.tar.xz=c1ebb094ca29b4fbb30326ae9ef99804d9f6ecee0bcb5633ce0236ea90058a13
-dist/2025-09-16/rustc-nightly-powerpc64le-unknown-linux-musl.tar.gz=c39f9dd4ad6f7939d114a9204a72cc22cf9a3d97ef3b496eff2bd78f55ff4e1d
-dist/2025-09-16/rustc-nightly-powerpc64le-unknown-linux-musl.tar.xz=cf218f8da409b2cdfe3820db1ce882e5d10f8a24a77b600cee9f00e85e747d13
-dist/2025-09-16/rustc-nightly-riscv64gc-unknown-linux-gnu.tar.gz=b64731d52f06f0b08fcc6dd64e9319d91fde2e48fd71d2b193f32ff770b81357
-dist/2025-09-16/rustc-nightly-riscv64gc-unknown-linux-gnu.tar.xz=07fac144d37f87e5f7b3a9521ef79789d7ab33cd529bb27c1b95238a28602857
-dist/2025-09-16/rustc-nightly-s390x-unknown-linux-gnu.tar.gz=727ca4ef70eb8cae09f73762202aee2b7998bc97c000571223991347a5408712
-dist/2025-09-16/rustc-nightly-s390x-unknown-linux-gnu.tar.xz=787ae447f764bf727c7debf6543b1ec22ebcf463832eb4d1279ec0f6824c2955
-dist/2025-09-16/rustc-nightly-sparcv9-sun-solaris.tar.gz=9f80d6add413e65dc6ab0e3d44b62f24134c6b3ee0bcc604ab66b3fdcd4fa0fe
-dist/2025-09-16/rustc-nightly-sparcv9-sun-solaris.tar.xz=3075e68b1f8a7b7a1c9489afdc2c9a38b1f0107865229497b2c9a7215853ef08
-dist/2025-09-16/rustc-nightly-x86_64-apple-darwin.tar.gz=685ffc70ff08c696321ebae272d09ba7f9e62f221929fa703e8cf21ba790df58
-dist/2025-09-16/rustc-nightly-x86_64-apple-darwin.tar.xz=29bd3bbb0f082cebf2dfef6d89a50dc5f33be231fe9d3e5bd2bb9b0b9bf53f90
-dist/2025-09-16/rustc-nightly-x86_64-pc-solaris.tar.gz=720e21f5ece47547b4cd91d5be89d67ce5334fa23a70921e7d60b0642b53a2d2
-dist/2025-09-16/rustc-nightly-x86_64-pc-solaris.tar.xz=d1e4d96e6f390ab2b6b1f435f5be61a69e01555f5bb66d58b2571f363cce8d26
-dist/2025-09-16/rustc-nightly-x86_64-pc-windows-gnu.tar.gz=2e1a315af7faa1f67c35e927fd0f3a0c96fecf0da1a2b3269ced7846d99d9100
-dist/2025-09-16/rustc-nightly-x86_64-pc-windows-gnu.tar.xz=7cb11ec687244e19a31996a3a802a8d0851cecd444abc5a8e65a10a037f67f4f
-dist/2025-09-16/rustc-nightly-x86_64-pc-windows-gnullvm.tar.gz=89010bc8a19cfafa6bc9714dd90cdcbb31cb85362846b8072cb41a3e8e7583ee
-dist/2025-09-16/rustc-nightly-x86_64-pc-windows-gnullvm.tar.xz=e84050c777e73941cb28f39e72a992b6a4a63100541f5b3fb288cf91fa1b0bd2
-dist/2025-09-16/rustc-nightly-x86_64-pc-windows-msvc.tar.gz=ffd857605275d71bf7e09eff94bc5fbc9cef222b1c076f1b7aee72f980e4c470
-dist/2025-09-16/rustc-nightly-x86_64-pc-windows-msvc.tar.xz=f28f28f07e98cb1bb43e93501cb43bd88b91b9913257f4de5c7154f0f9653d41
-dist/2025-09-16/rustc-nightly-x86_64-unknown-freebsd.tar.gz=66fe447d3f4526514b146633375efd40373dc28fe0262302be75afdf736986c2
-dist/2025-09-16/rustc-nightly-x86_64-unknown-freebsd.tar.xz=4d929f5079cd7a1c878631288765441aed538956d496881c89465aede623d94a
-dist/2025-09-16/rustc-nightly-x86_64-unknown-illumos.tar.gz=feed1caa5d31ab01cd4dc3c4b6b893c5d291fca9c470430f83c2cc90d26418b5
-dist/2025-09-16/rustc-nightly-x86_64-unknown-illumos.tar.xz=2f2b4e9e9a42f255cf66565012c63b2b2c0a13309dbce94d5135cd3280a8fc67
-dist/2025-09-16/rustc-nightly-x86_64-unknown-linux-gnu.tar.gz=f96e122b71d41b4889b18a0cee173822d509d8be9eaf28a3fec111df1a5dc5be
-dist/2025-09-16/rustc-nightly-x86_64-unknown-linux-gnu.tar.xz=ee8914df087f4e20c322851f322220e2f4885a316627c464881d086024e84b54
-dist/2025-09-16/rustc-nightly-x86_64-unknown-linux-musl.tar.gz=b226b4edc64f4ed91a9cb616600ece61c12f5da72ca4b62f13669e849de7ebe5
-dist/2025-09-16/rustc-nightly-x86_64-unknown-linux-musl.tar.xz=9a3d98e0fec50ab589027f1d5973ec583b062581b1a1cd59470bb4fb6c51c463
-dist/2025-09-16/rustc-nightly-x86_64-unknown-netbsd.tar.gz=bd0d47aaa630abc01d2f36f9c2a99577254aa3428abf1d666d5520c4fa990844
-dist/2025-09-16/rustc-nightly-x86_64-unknown-netbsd.tar.xz=863edf8589fe1f3f1728222ee49960457d9edd2abc521557f28562e546e27b81
+dist/2025-09-21/rustc-beta-aarch64-apple-darwin.tar.gz=08f8aee2085d8da9041fa9f4c7c6d79b5b1c06c544a3e2309f353844e1250bd0
+dist/2025-09-21/rustc-beta-aarch64-apple-darwin.tar.xz=a36bed31d0f600ca8e8efc19322fe05a88e31bc218078e79c8ca0e7c3d582b20
+dist/2025-09-21/rustc-beta-aarch64-pc-windows-gnullvm.tar.gz=2b6b8f275d1b03ed7bc05e631378c0b462d274b7f1f038f2feec752b29993b10
+dist/2025-09-21/rustc-beta-aarch64-pc-windows-gnullvm.tar.xz=13adf0b39c176761adcf754671911d5309cf04348ef9f93fcf8c09afa6b70da0
+dist/2025-09-21/rustc-beta-aarch64-pc-windows-msvc.tar.gz=568566c82dd296babbd5588d0c69f23c5b5bfd32b3b25e493e6d45f15d645db7
+dist/2025-09-21/rustc-beta-aarch64-pc-windows-msvc.tar.xz=8357fb4ec176279416cabc0edbb2f7c3d4c812975867c8dd490fd2ee30ed1d1f
+dist/2025-09-21/rustc-beta-aarch64-unknown-linux-gnu.tar.gz=a885d01f6f5043bacb3bf4820777e29ab45aac4dbdfed75ee71a3de01b056e05
+dist/2025-09-21/rustc-beta-aarch64-unknown-linux-gnu.tar.xz=3a2bed859214bbea2cdd13675eaf480e62c01646efed26067ba7078e6dd8591f
+dist/2025-09-21/rustc-beta-aarch64-unknown-linux-musl.tar.gz=4b66e79a48d172eb674ba7e6b4eea91ebda2351d6d253deef90010ffc48d4801
+dist/2025-09-21/rustc-beta-aarch64-unknown-linux-musl.tar.xz=131f270aee35b36ae02959abe032c77e1de0c75f23f7c61bbca1e2c18a23f4f9
+dist/2025-09-21/rustc-beta-arm-unknown-linux-gnueabi.tar.gz=d8c38594dfd1ef17c9ceb2ea614be730f4647fa5e75e80b5bc12d235216ecbf4
+dist/2025-09-21/rustc-beta-arm-unknown-linux-gnueabi.tar.xz=1643434757b590b1586e9074e82be3cc9e50e5551212d5f2040fdd8feba8f1e2
+dist/2025-09-21/rustc-beta-arm-unknown-linux-gnueabihf.tar.gz=1619461791fa6c2b8750043a41acd285bdf1f32d376af675343be3449bb7e5b8
+dist/2025-09-21/rustc-beta-arm-unknown-linux-gnueabihf.tar.xz=cd2ed3ae30cf77b5530a2ebee13daeb1419ceec2ab18f754d07b081dd6a607c1
+dist/2025-09-21/rustc-beta-armv7-unknown-linux-gnueabihf.tar.gz=b0703e79530bd836df864facbfb5065c3e5e8b3a457e4ef55b4f7a4d362b9ba8
+dist/2025-09-21/rustc-beta-armv7-unknown-linux-gnueabihf.tar.xz=a647780abbe8d36049edd90857b3baab556ac9b61caaef1d98307fe92fc20453
+dist/2025-09-21/rustc-beta-i686-pc-windows-gnu.tar.gz=c7ec1f853b96edbf1a914b8345b025c87641225e0c49507bbffd88f2da05b8f4
+dist/2025-09-21/rustc-beta-i686-pc-windows-gnu.tar.xz=53803baae3061eb164f34900f5867cfdf3bf50733ca0a6bda674b491bc0250b8
+dist/2025-09-21/rustc-beta-i686-pc-windows-msvc.tar.gz=a0f9192059b9989db0c4dba57b5eae9cace1b8e6f8bb2362b028c7f36e34d44c
+dist/2025-09-21/rustc-beta-i686-pc-windows-msvc.tar.xz=f8c237af5f0e2fe293671ddfe7fcf90f6e2b161a52314b2eb622f2a1b23ba3fc
+dist/2025-09-21/rustc-beta-i686-unknown-linux-gnu.tar.gz=da2a42e5a76e95460a348ba70cdf1c5c6ade82eb6ad3796935158bbf5859b602
+dist/2025-09-21/rustc-beta-i686-unknown-linux-gnu.tar.xz=c98df2f0156c3065179f50d55dafda8c5db1f2eae99ecb3f568a8861299be289
+dist/2025-09-21/rustc-beta-loongarch64-unknown-linux-gnu.tar.gz=1149494d96b4ce949308620a360a365c4304b8ee8f8c9512a35f08048aa13c78
+dist/2025-09-21/rustc-beta-loongarch64-unknown-linux-gnu.tar.xz=c906f519bc65a3a7514a62f8920d334bc10623a76dd2d3464af88065b79cb334
+dist/2025-09-21/rustc-beta-loongarch64-unknown-linux-musl.tar.gz=e3a9dd7ae0179ebb7659024532b9f3cca9ac4cdf62c0ae411b00d8f8768aaa34
+dist/2025-09-21/rustc-beta-loongarch64-unknown-linux-musl.tar.xz=d9f3428d80a7b72b15c62bd3306628820f73b64f48de37ea079699b733bda048
+dist/2025-09-21/rustc-beta-powerpc-unknown-linux-gnu.tar.gz=4b52241a8b65a9a42db2a75e057176a99e3b434907f498c4b6b9da104e138c72
+dist/2025-09-21/rustc-beta-powerpc-unknown-linux-gnu.tar.xz=40f3a5fc7478b40153ab20e3f14a6d838c80dda529481735e898de989a31f963
+dist/2025-09-21/rustc-beta-powerpc64-unknown-linux-gnu.tar.gz=f5aa411dfe614ed288351fa4b17d1e2935501c804c0ad51f22e3db71617b17ea
+dist/2025-09-21/rustc-beta-powerpc64-unknown-linux-gnu.tar.xz=b9efeb2e185e43775d309d083d8c4f45e30e18b7af71b9c45e397af6bc723fcf
+dist/2025-09-21/rustc-beta-powerpc64le-unknown-linux-gnu.tar.gz=38b6a69885e4dac48f7c3128ff1e88d0bf2d0ce1fbd6a5baa9dda62bca0b2b08
+dist/2025-09-21/rustc-beta-powerpc64le-unknown-linux-gnu.tar.xz=8576ae6d787b0f8b127bb2dbeee213cc6093ba92dc7d5ff08f463d56e2e6ce90
+dist/2025-09-21/rustc-beta-powerpc64le-unknown-linux-musl.tar.gz=5e91ce627e900da2606782ae60598843a6ba17593a7eb0dcc8f5f9a1cc20676d
+dist/2025-09-21/rustc-beta-powerpc64le-unknown-linux-musl.tar.xz=fe24fad781f829838592e6670655dcff52002ae720f987868fd4b17eb9ed631e
+dist/2025-09-21/rustc-beta-riscv64gc-unknown-linux-gnu.tar.gz=170ccaaa94eb7c813bcedf2afb37cb0c696c5f48ca9d93238ee8cf26efc5bafa
+dist/2025-09-21/rustc-beta-riscv64gc-unknown-linux-gnu.tar.xz=db5a862a260fe8688e3b1da1161948eed5361723a296bb27dcc62758eaa2b873
+dist/2025-09-21/rustc-beta-s390x-unknown-linux-gnu.tar.gz=c764aa7b70dacf7ac3ef5d2184d021304b633309b771f24d62375fa64791614f
+dist/2025-09-21/rustc-beta-s390x-unknown-linux-gnu.tar.xz=69eedf71d20924d9729684e27a3a8cebc60efa7c0e7a3f8b6fe664f469a36788
+dist/2025-09-21/rustc-beta-sparcv9-sun-solaris.tar.gz=efb9d78cc395774e05353615c029ed674c1ba55204ae9be3d022abda9f5c6d9c
+dist/2025-09-21/rustc-beta-sparcv9-sun-solaris.tar.xz=e8de37de871888886bb58d915f3a27bfd8c30a912ea3f3af4abf52f66708268f
+dist/2025-09-21/rustc-beta-x86_64-apple-darwin.tar.gz=b945ef94a4efdc0fdd4a66c3708cb95a97592c922652af06d8d1b6bbaaf71660
+dist/2025-09-21/rustc-beta-x86_64-apple-darwin.tar.xz=876a6080177df194c14d0984f112692295a21186b05bd03a77d0a304dec5ad51
+dist/2025-09-21/rustc-beta-x86_64-pc-solaris.tar.gz=d7c0b4fb19c785ed3a0c16d903cef266438031c3a43b1721d19864a1923d3cb4
+dist/2025-09-21/rustc-beta-x86_64-pc-solaris.tar.xz=b4a5494890bd92b85f66054523b26e9aae5e74b3177c9eae64740ed7fa1d4da4
+dist/2025-09-21/rustc-beta-x86_64-pc-windows-gnu.tar.gz=ea55aab0bd57f0cd6568a6e78c9d0a3727fb7cfaf8ada9379084091244b3221b
+dist/2025-09-21/rustc-beta-x86_64-pc-windows-gnu.tar.xz=426009c68fa78001b34f8b329cac7634dd8921c569061f45972058b770206f9f
+dist/2025-09-21/rustc-beta-x86_64-pc-windows-gnullvm.tar.gz=c79a925f6f2b406db97732e22e1b245ef2c7d1291a574b0d55a861d3c7e5d766
+dist/2025-09-21/rustc-beta-x86_64-pc-windows-gnullvm.tar.xz=0f46e118b67656fe16c484589ee0213654cd6edfbe5a29d641aa810bddcc8c62
+dist/2025-09-21/rustc-beta-x86_64-pc-windows-msvc.tar.gz=d7b5fb269841039af498a6d0be2cbd70cb7b65f6a9918a2b6c022cadfdb30fcd
+dist/2025-09-21/rustc-beta-x86_64-pc-windows-msvc.tar.xz=dfef15ca4fcf06622953296ebec960e446402ce542e2f264c12c0c03b9a476ce
+dist/2025-09-21/rustc-beta-x86_64-unknown-freebsd.tar.gz=09994a33e03f50212cabee85294dfb684fafcef95e1de5b082540d01d92df1ce
+dist/2025-09-21/rustc-beta-x86_64-unknown-freebsd.tar.xz=a0e3409ec6f6b02517c8f9d0e00a0627434f6b06a5360da286c46ceab9d12ab1
+dist/2025-09-21/rustc-beta-x86_64-unknown-illumos.tar.gz=01daeea1f1f10d84444b56e8e74e3a451c54e65832234b2caa2ce0a63c0a9ea1
+dist/2025-09-21/rustc-beta-x86_64-unknown-illumos.tar.xz=6299fa81533b9362d1cdbf7984506fcbc26f7d9e857a942f081f5325c87cc4c4
+dist/2025-09-21/rustc-beta-x86_64-unknown-linux-gnu.tar.gz=cafaecb5158fcf39b676baf2d0060fb8b31558be0e442389755ae33a3e7bb42f
+dist/2025-09-21/rustc-beta-x86_64-unknown-linux-gnu.tar.xz=5d3c1fceba5285bc54f5a327841ecb8893e719ba874e483c904b903f4dc293ed
+dist/2025-09-21/rustc-beta-x86_64-unknown-linux-musl.tar.gz=290a07f32c769f74d21c57a856b3aa39da89e2f086e53c42f3333d1f9ffb5673
+dist/2025-09-21/rustc-beta-x86_64-unknown-linux-musl.tar.xz=8bb354230d3da85bb0fc280c3e95ceadd9f7522d231fe787be8c82aa072ad506
+dist/2025-09-21/rustc-beta-x86_64-unknown-netbsd.tar.gz=af3c98fb99b419cfe50433f5f4a046065066183b248708ec8800253867c678df
+dist/2025-09-21/rustc-beta-x86_64-unknown-netbsd.tar.xz=0ea09297621d3b735b2931f6472f95e1587d38f6fb0df7fdf5e427fa3baec4a1
+dist/2025-09-21/rust-std-beta-aarch64-apple-darwin.tar.gz=8c08542fe69e9fd5b2256d17d84427ac206c9e79e265fddbcdf12d1af4e5d913
+dist/2025-09-21/rust-std-beta-aarch64-apple-darwin.tar.xz=7ddd43d1e32a829ffa9a7a798e1339d0569e773d841d8b7ad33701664373b8ae
+dist/2025-09-21/rust-std-beta-aarch64-apple-ios.tar.gz=bf3df6d2eb7e5515ae86bb970b5c145140f8e9d503e636fcfc435d47797b650a
+dist/2025-09-21/rust-std-beta-aarch64-apple-ios.tar.xz=fbb88375a8c0c5e41d35e4838ecbd31e4ad1b96e22eb689ae37dd50322545d39
+dist/2025-09-21/rust-std-beta-aarch64-apple-ios-macabi.tar.gz=26e9fb3607dfeab90500bac3e9eaa23170f7f22a4738ae6b58e2e89e0c87f72a
+dist/2025-09-21/rust-std-beta-aarch64-apple-ios-macabi.tar.xz=6c9622771203bf342d59673bb1f53fe715b4255f0860feb6b19be57de2ef9f92
+dist/2025-09-21/rust-std-beta-aarch64-apple-ios-sim.tar.gz=a9c15e05b58adede5d08d7628de75d47d5c38ca60fad87dca8b8c9801050ee1a
+dist/2025-09-21/rust-std-beta-aarch64-apple-ios-sim.tar.xz=bd847e7952c02312e36900766a71a5284c221b177ddef0b9cb071c5f6186a70b
+dist/2025-09-21/rust-std-beta-aarch64-linux-android.tar.gz=2dbfa47893553b2868c375bedda6c4e08c33bbfa9cc96ff6e89ccf0525f8b14b
+dist/2025-09-21/rust-std-beta-aarch64-linux-android.tar.xz=6b83da57cd768bad91a820d698bd18ae60586b0920950ea14105d6f23b4b1db8
+dist/2025-09-21/rust-std-beta-aarch64-pc-windows-gnullvm.tar.gz=a71a57f26812c2e1529c10e2e02b8d9b466564065a8a10ceb69f22cb76e83814
+dist/2025-09-21/rust-std-beta-aarch64-pc-windows-gnullvm.tar.xz=29f8789707c545e45680acd30a329fa28613dd247ce7c91d65b13a10c0c21202
+dist/2025-09-21/rust-std-beta-aarch64-pc-windows-msvc.tar.gz=07067546648ac6e784f9d5f6455534b62b9eb5cd86805c327b98505a0caeb2d8
+dist/2025-09-21/rust-std-beta-aarch64-pc-windows-msvc.tar.xz=f224f6b979ceef56ef8a10eaf063a6ea072d405a52ef123b720d44925b530d36
+dist/2025-09-21/rust-std-beta-aarch64-unknown-fuchsia.tar.gz=756534ef3e62c80481e4886348bc80632ca68ec9c49045d71838dc7ef0751373
+dist/2025-09-21/rust-std-beta-aarch64-unknown-fuchsia.tar.xz=c6eee692a79106d7733c1cbc525b241b6d88a53ee08242e494d286eb0ad3024a
+dist/2025-09-21/rust-std-beta-aarch64-unknown-linux-gnu.tar.gz=4843b5a6d3e8b89a54ab91e44768bb023178c8cc7cd745639d9a616f2331d9a2
+dist/2025-09-21/rust-std-beta-aarch64-unknown-linux-gnu.tar.xz=89a808aade0a91043bef23f3e3f38d193b4f02b6556f01cbaf103c43ce428478
+dist/2025-09-21/rust-std-beta-aarch64-unknown-linux-musl.tar.gz=6c09b424925e89957fb1921887b7034c3d3adf012571415b9930e1d0119bed41
+dist/2025-09-21/rust-std-beta-aarch64-unknown-linux-musl.tar.xz=3c34d71b74adb145302772db2a5c565235576a14c42eca0a270b0e9e67ac9032
+dist/2025-09-21/rust-std-beta-aarch64-unknown-linux-ohos.tar.gz=70225984fa7ad361126efd9cbd40fe9dcf4756866b23079e4dbde5ec51f3a10d
+dist/2025-09-21/rust-std-beta-aarch64-unknown-linux-ohos.tar.xz=e696cf9ac5b4b0e16e3947377424515c761697541351d0924b61a37557394828
+dist/2025-09-21/rust-std-beta-aarch64-unknown-none.tar.gz=7b754105300a911c24f7483b7eb482d076f5f98e16f685215d06df3dab1fdcba
+dist/2025-09-21/rust-std-beta-aarch64-unknown-none.tar.xz=8168916ec457eaeb32ad1d274ce67666d6ff8fdf662f32bc6e17656ef4ff7c81
+dist/2025-09-21/rust-std-beta-aarch64-unknown-none-softfloat.tar.gz=1ff511547185b42b801ce51f84985767d580c08f183b15033e8ae05274b7f90c
+dist/2025-09-21/rust-std-beta-aarch64-unknown-none-softfloat.tar.xz=263e10d4226c5328cb41299466b82e154fa1c94c67fc3a185a0bb9a6639bebad
+dist/2025-09-21/rust-std-beta-aarch64-unknown-uefi.tar.gz=eb3710b6ccbde9a265217a4e64f2c62bb22bcc79dd58a48381cc81c5e95073d4
+dist/2025-09-21/rust-std-beta-aarch64-unknown-uefi.tar.xz=b1c231790f55fd9a3dfcb9e6c946f34afb3bf96c57bb9d8615894d81aed44f95
+dist/2025-09-21/rust-std-beta-arm-linux-androideabi.tar.gz=0d12ed3a2980fce0d71d728d6c2840eac36a3e3ae93f2dfc3cb391d56c20cbf1
+dist/2025-09-21/rust-std-beta-arm-linux-androideabi.tar.xz=2219966a5e884a94c324b74872a2a4a12378d595cae10b53958190acc05ccd45
+dist/2025-09-21/rust-std-beta-arm-unknown-linux-gnueabi.tar.gz=286c12975e333cdf9c7ad0b21217e3b83682047c37c1dba766cff4a201bab40b
+dist/2025-09-21/rust-std-beta-arm-unknown-linux-gnueabi.tar.xz=9e56db5ac01ae18077551117348fe56050426f521e41f217ac3d71c23eff4d88
+dist/2025-09-21/rust-std-beta-arm-unknown-linux-gnueabihf.tar.gz=f52e699638e352d9f816a21965a5696acc5fd77325ff074f93c27587292bca19
+dist/2025-09-21/rust-std-beta-arm-unknown-linux-gnueabihf.tar.xz=d0a4abaa489bfc6f2f7d2305e8edbd502b12f247357ba4cda541786377648108
+dist/2025-09-21/rust-std-beta-arm-unknown-linux-musleabi.tar.gz=7ee043969e94b14ea74e083fd3edb9e0639d68c2bdd7ebdb188e98b36c854fcb
+dist/2025-09-21/rust-std-beta-arm-unknown-linux-musleabi.tar.xz=8ce6bafaae0e8217bdb138d104955ce7f0a747ef915aebb181cf3047beb4456f
+dist/2025-09-21/rust-std-beta-arm-unknown-linux-musleabihf.tar.gz=8e5c901df3f932bac7dad635bc1197ffbee4884c0a101632d51a32f23c875cdb
+dist/2025-09-21/rust-std-beta-arm-unknown-linux-musleabihf.tar.xz=166a1d949b6847e9bf102a89f9a417a30d8ac25a35fe3f732d6a513a7674af85
+dist/2025-09-21/rust-std-beta-arm64ec-pc-windows-msvc.tar.gz=8660de6d0d97fdffe3bbcfd5ffc7e11bbfe9c43f80067ba17845414958778845
+dist/2025-09-21/rust-std-beta-arm64ec-pc-windows-msvc.tar.xz=8b563eb032535c58c487d4ad992a12a106208861e45ea78c342e940b9356ebf1
+dist/2025-09-21/rust-std-beta-armebv7r-none-eabi.tar.gz=cd761b3f761198cc6ac64809eaa28ac299b67ba48d964298db3f5b4ea52f3623
+dist/2025-09-21/rust-std-beta-armebv7r-none-eabi.tar.xz=071864464c52c37bd102fad26b5d28f31aa9e06d34ee868a33ead297c3e20a4d
+dist/2025-09-21/rust-std-beta-armebv7r-none-eabihf.tar.gz=402c044cdaad16d2b60365b6894250aa43424902c0b3f0526e849d7d0d452315
+dist/2025-09-21/rust-std-beta-armebv7r-none-eabihf.tar.xz=0028e17d0164bbb8166ddaad815874123fcc326dffef4740389ff2cb069a3e2b
+dist/2025-09-21/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.gz=0b9be6bfa168756361aa5feb7802133c4cbebd3fd20d75d32a4385b716417a9f
+dist/2025-09-21/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.xz=1893fcd9b16f0c334257cbc78dc416cc048d7c1603ba632ed7300bbf6c0bffb0
+dist/2025-09-21/rust-std-beta-armv5te-unknown-linux-musleabi.tar.gz=5aa03609f57d6c959673963b633adf194ea240b3604ba6635a6ef5fbe5c519d3
+dist/2025-09-21/rust-std-beta-armv5te-unknown-linux-musleabi.tar.xz=8f075eb3b1ed0bdfde8af08ee69778af2d2e896d1cdf17035657d1a84c85e856
+dist/2025-09-21/rust-std-beta-armv7-linux-androideabi.tar.gz=1499f0b4c3a4838dbd7b0df7303fbe7e157dfaec396b5ee1a6ae6a727ea3122a
+dist/2025-09-21/rust-std-beta-armv7-linux-androideabi.tar.xz=f0ad36dd56abf6c03395bfc246209bce90aba1887dee81a2841f7e1013f93850
+dist/2025-09-21/rust-std-beta-armv7-unknown-linux-gnueabi.tar.gz=4a430fa04ef3d23dcf1d5e1f69c37127a5fb58e883ac52c8885125e0f578cde9
+dist/2025-09-21/rust-std-beta-armv7-unknown-linux-gnueabi.tar.xz=6fab12ecab36252aa1a4f6aa523ae1546f534548394e2585e96a869b87656806
+dist/2025-09-21/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.gz=4081b51910cb95fbacafc9518ee5891e1131af79a8348635c13765706c18c3ea
+dist/2025-09-21/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.xz=ed9a56e0e8b4e0f639afd9c6c75c4adfeddc7ce0aaa9132591f774754f412b6e
+dist/2025-09-21/rust-std-beta-armv7-unknown-linux-musleabi.tar.gz=571a08bf8eaa522017b0aa67fb78b344590fde57ab3425575c01ceb3b258c557
+dist/2025-09-21/rust-std-beta-armv7-unknown-linux-musleabi.tar.xz=e50728c440ae8fc9d154a3893914126d4486ca7dd197891b78531f7d5d081211
+dist/2025-09-21/rust-std-beta-armv7-unknown-linux-musleabihf.tar.gz=1f8570de307fbc59e962ef6b419009d57fb05b2e1d5fc9ade9d425e3c9977cfe
+dist/2025-09-21/rust-std-beta-armv7-unknown-linux-musleabihf.tar.xz=35db980cea1ba70003374a738f20af63d54796e9181b8cf0e9d0626e0935a9a2
+dist/2025-09-21/rust-std-beta-armv7-unknown-linux-ohos.tar.gz=ba5a8487dbb60851fc927dc24ee58186aa6e74d42dbf5202df7981a456b5f8f7
+dist/2025-09-21/rust-std-beta-armv7-unknown-linux-ohos.tar.xz=f763ae3e33f4785ff505eb068ed6515aff8ffcdb9895595d23c2cea519e26355
+dist/2025-09-21/rust-std-beta-armv7a-none-eabi.tar.gz=3cd90f1a7c14a732a951026458a976fd5e833f212c6f6433f8de348b7b742b9c
+dist/2025-09-21/rust-std-beta-armv7a-none-eabi.tar.xz=237f44f2b9984743f71ef0cab8d693092748fd2da25cabd3468e3e45ca20e2bc
+dist/2025-09-21/rust-std-beta-armv7r-none-eabi.tar.gz=ec38043fd7877d45331414d059d0198d055ab724e84c077ca75a2902afbb2d6b
+dist/2025-09-21/rust-std-beta-armv7r-none-eabi.tar.xz=f511909286f3e1cb52f0e698722bec1a3cfb750e19bb2fa781bfff225620ca8c
+dist/2025-09-21/rust-std-beta-armv7r-none-eabihf.tar.gz=556365cb3ed473222e1b135be77086214f3f94f863817de4a87ee7d75456b824
+dist/2025-09-21/rust-std-beta-armv7r-none-eabihf.tar.xz=8483d2550782e253cdace51fe24249fbd6bd0b10a850c75e62dc60f803be17b0
+dist/2025-09-21/rust-std-beta-i586-unknown-linux-gnu.tar.gz=0ed5faa9e8e73f4e7b9e75741d000954558bafeaf776a6e61a4e44ac120b91e9
+dist/2025-09-21/rust-std-beta-i586-unknown-linux-gnu.tar.xz=665d5a0debd829f3682572e4c3578d41bec58b01df10cc8c71ca66d326a3579f
+dist/2025-09-21/rust-std-beta-i586-unknown-linux-musl.tar.gz=c59dcbce2435a5826161d4319dcf84e128f9fa4c0bf075fab2a26c2bfb5d9887
+dist/2025-09-21/rust-std-beta-i586-unknown-linux-musl.tar.xz=13a2292936e289941be4a02903051eadb076bb44368494d530cf66832978f46f
+dist/2025-09-21/rust-std-beta-i686-linux-android.tar.gz=5d23e660218e04a7dc4aaf940959619ec9aa14bf5574a554c0d8f377910ed017
+dist/2025-09-21/rust-std-beta-i686-linux-android.tar.xz=cffd08cc85df3cc661d8a572e940316da06754b61893efcd9ad3b7db09a0e6ee
+dist/2025-09-21/rust-std-beta-i686-pc-windows-gnu.tar.gz=91743434207475f4404707cf7a203b46f032a041184a729ddcaeca280b2fac05
+dist/2025-09-21/rust-std-beta-i686-pc-windows-gnu.tar.xz=1f0240a71bf5a3bd74e1ae960c1aae440c3b3e32e6c62835287f78cc777f0d7f
+dist/2025-09-21/rust-std-beta-i686-pc-windows-gnullvm.tar.gz=ec5907cfb6faafcc20f3d7cdb22fd7836c9c2d7cb4871c48e64732bb7f5dcba5
+dist/2025-09-21/rust-std-beta-i686-pc-windows-gnullvm.tar.xz=e7e8453b9dafc3c8c222455f5327fc8cde127f8dc877991688afd3c2f23675f5
+dist/2025-09-21/rust-std-beta-i686-pc-windows-msvc.tar.gz=50dd40b16e8ea85fd7ca67583d5cae80910d36531a7babe13a94cb638015a1d3
+dist/2025-09-21/rust-std-beta-i686-pc-windows-msvc.tar.xz=dafeb013333acc8a3a4181358584851b47c5f21138d8164ccfd6863b171309ba
+dist/2025-09-21/rust-std-beta-i686-unknown-freebsd.tar.gz=91d741bfd158f22f4dea8bf768c5fb60ca05f5dc64cd5a848428b8dfe8beccbf
+dist/2025-09-21/rust-std-beta-i686-unknown-freebsd.tar.xz=12ddbbb201a973148979a99ccbac3c65690010dd2f6984fa390fe5e63a28dbda
+dist/2025-09-21/rust-std-beta-i686-unknown-linux-gnu.tar.gz=975e30f37f03afb47777a38edcd535df6729311cc0acb587d417ebff694df796
+dist/2025-09-21/rust-std-beta-i686-unknown-linux-gnu.tar.xz=bc95dd6129e90c9275e0340962993de7a0842040bdfcde9aa419f227d79dbf31
+dist/2025-09-21/rust-std-beta-i686-unknown-linux-musl.tar.gz=1c937cce8b40567851578790512fe079c0aa828374a3bb76423d685357388576
+dist/2025-09-21/rust-std-beta-i686-unknown-linux-musl.tar.xz=b42d227d63f0b3352d4d66f1198294c2f4df574c48fff794ac3483cef869c2bf
+dist/2025-09-21/rust-std-beta-i686-unknown-uefi.tar.gz=0e8c239ce3b8701c4a26b46aca9a700083667ffc3228d796ba0ba6d0728c6826
+dist/2025-09-21/rust-std-beta-i686-unknown-uefi.tar.xz=54cba2405dfa2a23164bb8e7de5e0d6a6a6523f36b0763f077d2bfec1f303576
+dist/2025-09-21/rust-std-beta-loongarch64-unknown-linux-gnu.tar.gz=72db70ab9289bce8ace5da246432d2a00552b4cd9ebef7930b563e04d1cdebf1
+dist/2025-09-21/rust-std-beta-loongarch64-unknown-linux-gnu.tar.xz=5b578548a62dfd3902920719acd17550f45d0e9106049cbdc1f36c8907a8291f
+dist/2025-09-21/rust-std-beta-loongarch64-unknown-linux-musl.tar.gz=993fdc6d1894f823b3782fe180ac40a3ad7baba110f2eff68d9e38e8f79a95a4
+dist/2025-09-21/rust-std-beta-loongarch64-unknown-linux-musl.tar.xz=b5161bd0064bfb312cf156ec4689a3f5922c7df24468660e1046798c8984938c
+dist/2025-09-21/rust-std-beta-loongarch64-unknown-none.tar.gz=670ef40754ac30a2edb65384de65f028a4f8e96dca49fd0bb5eb2d9d6020e906
+dist/2025-09-21/rust-std-beta-loongarch64-unknown-none.tar.xz=b9aa6311d6a3e428f151fc6720147ea8759092545b05cad3f16b6e563d523813
+dist/2025-09-21/rust-std-beta-loongarch64-unknown-none-softfloat.tar.gz=5c4c2e6bdc6d3c79578a3fd581064ba6aeb21fd9311a39a62bf58b36e7ea00cc
+dist/2025-09-21/rust-std-beta-loongarch64-unknown-none-softfloat.tar.xz=8e272682e98ff8b139da621d7273cf71efa407538ea176d873a1ea7e22246ebd
+dist/2025-09-21/rust-std-beta-nvptx64-nvidia-cuda.tar.gz=0781275b356176417c21c1bd1a4068fe2a42dc6de9b34695c937d5ba94b98ad6
+dist/2025-09-21/rust-std-beta-nvptx64-nvidia-cuda.tar.xz=8747e3e686fbf41389a8ad958596577670f0626a610d380b0a775e704bc6c6be
+dist/2025-09-21/rust-std-beta-powerpc-unknown-linux-gnu.tar.gz=95e8443355571edf645d75d31a33277f0d6f7161f8592ec213a407bc4839819c
+dist/2025-09-21/rust-std-beta-powerpc-unknown-linux-gnu.tar.xz=4abcda8b23d17f6e6681329b54215f37cca5fc1f3383e58dd60c38220f5528de
+dist/2025-09-21/rust-std-beta-powerpc64-unknown-linux-gnu.tar.gz=a24d3b7db647c114c95f7da40ca2001085d935ebffcc17e269af5be636ec1f2a
+dist/2025-09-21/rust-std-beta-powerpc64-unknown-linux-gnu.tar.xz=7579f587df01fb55211e6a0a61ed96f14955b7f56990e679715157b06b49fe79
+dist/2025-09-21/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.gz=ea071da90747334a786f1e4784e39c11058d7f7719e498a8b6ae29672a999abb
+dist/2025-09-21/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.xz=d612ed01011c1e7f24b08318029523f6b7ffb12ec38b1f41ebcedf463f924430
+dist/2025-09-21/rust-std-beta-powerpc64le-unknown-linux-musl.tar.gz=722b93d6c5e1f9a326461bb920fafef62cc8257ff67732c3f65ecc540782a504
+dist/2025-09-21/rust-std-beta-powerpc64le-unknown-linux-musl.tar.xz=5b5010f550b317facbd599fa363d633e0540836145717f35ffa0bff14ec80558
+dist/2025-09-21/rust-std-beta-riscv32i-unknown-none-elf.tar.gz=7dea77dc10830754d5aa9a6e5ae3272e4955cab8df1e20f0784901ca6a60c49d
+dist/2025-09-21/rust-std-beta-riscv32i-unknown-none-elf.tar.xz=f212b4afaaa954809af920d3fb3de76a611d387910e6162b902fad8f38f36c49
+dist/2025-09-21/rust-std-beta-riscv32im-unknown-none-elf.tar.gz=3f81a7134f44a87b7724a510e4cd4209ab52fb03fee3dc051c26bc0612e4b1af
+dist/2025-09-21/rust-std-beta-riscv32im-unknown-none-elf.tar.xz=cd9db852c6f7e454e94161379c032e3ccabfcdaeddd74e8f612870ef39eb230f
+dist/2025-09-21/rust-std-beta-riscv32imac-unknown-none-elf.tar.gz=6da7d7c9cdc05fc3b86930d98fe9828ecef02b5b3cead51252fe9f131ab5f9e2
+dist/2025-09-21/rust-std-beta-riscv32imac-unknown-none-elf.tar.xz=97ad71f7f63f2c3b01ba822164df457d88331880bd21837a18354fffd1b38918
+dist/2025-09-21/rust-std-beta-riscv32imafc-unknown-none-elf.tar.gz=9a5d94e1a77159a4bbf4fe7490019fff763daeb24dc2b8c732442275619f9ffd
+dist/2025-09-21/rust-std-beta-riscv32imafc-unknown-none-elf.tar.xz=dc5826fef922a6987650b491957b17693c49d1ab26b618efacbb1bb0b5a9b1bc
+dist/2025-09-21/rust-std-beta-riscv32imc-unknown-none-elf.tar.gz=1b9c1cc0648fc86fdaaf23e6793fa826f3639bab9d42e1bbe2c70f19cecc11a8
+dist/2025-09-21/rust-std-beta-riscv32imc-unknown-none-elf.tar.xz=90cb9c376894a122f3872a77a653e3decf95f1eef54ba7980846165e6f34377f
+dist/2025-09-21/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.gz=22069b14b3eab5f3bd24a0f10185a5484022ac60fb7b2b5cb0019281bee79a4d
+dist/2025-09-21/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.xz=395f2975bc86a63736ba7661985db038efa5f5982459add18201c97e4b1a9200
+dist/2025-09-21/rust-std-beta-riscv64gc-unknown-linux-musl.tar.gz=7932c8dbc9727a85dbf2ad28066cef1da46cf0ced358aea0e78a254fc1e423f9
+dist/2025-09-21/rust-std-beta-riscv64gc-unknown-linux-musl.tar.xz=69b8ce57a0c459ca57353cd8302deba6791a19dcf54e16b8d07f76b44e3c65fa
+dist/2025-09-21/rust-std-beta-riscv64gc-unknown-none-elf.tar.gz=27717f0b8b51f90c7e1579a2e3fa781f2a19064872133a951e60200c05db1df8
+dist/2025-09-21/rust-std-beta-riscv64gc-unknown-none-elf.tar.xz=d6cccdb4ca0856ce1d314c03779c082ee0dff153aa6bf9ea050ca3d0a395dc1c
+dist/2025-09-21/rust-std-beta-riscv64imac-unknown-none-elf.tar.gz=9fd58b7c529d530e8b894a24e7f3a33d291d7305357c7cf52bbe708cde28c381
+dist/2025-09-21/rust-std-beta-riscv64imac-unknown-none-elf.tar.xz=f62de7e74f558a27bc2ef04897ad2f4fdfc162a17f21fde8efb2ba15435d80f2
+dist/2025-09-21/rust-std-beta-s390x-unknown-linux-gnu.tar.gz=3e97b06bc72aa51aafd2d2f65b4c4d9ab08599c2616729b79dbd9c51886ab6f4
+dist/2025-09-21/rust-std-beta-s390x-unknown-linux-gnu.tar.xz=8f149e17d654de210a71ace9db03f23bd1a80d0e2c17f8336da2b1ec2315c8a0
+dist/2025-09-21/rust-std-beta-sparc64-unknown-linux-gnu.tar.gz=ae6f3a738f1793fb9659e7613811b2ac151e91e3d8e470166b6ae615e5a285b2
+dist/2025-09-21/rust-std-beta-sparc64-unknown-linux-gnu.tar.xz=92af1bc3beaf80a763aac682a15957d82771fc619d446fb4327f4e8be229438d
+dist/2025-09-21/rust-std-beta-sparcv9-sun-solaris.tar.gz=b1f5ef77e28e9ed25050b130299a1c431a851df8b11bd457393fd464a7a9c35a
+dist/2025-09-21/rust-std-beta-sparcv9-sun-solaris.tar.xz=e5d744447649c57f8238c7d020f405559185d644b9739cae53c6963cdb380ea1
+dist/2025-09-21/rust-std-beta-thumbv6m-none-eabi.tar.gz=964c824519d8f352ea049766c428e6409549f7a4921c50f91dc548f2ec7f65f0
+dist/2025-09-21/rust-std-beta-thumbv6m-none-eabi.tar.xz=2f3b6d4781b21902e5f6986b75f3a0617198bad4741d4a9b957ab5ae2beab05d
+dist/2025-09-21/rust-std-beta-thumbv7em-none-eabi.tar.gz=7a95faa851ac8dff7f57cfa42169018b29683fbe06dbcf29e2cb311a0c880e84
+dist/2025-09-21/rust-std-beta-thumbv7em-none-eabi.tar.xz=deb1eafb4cdad0391bad8dd0657577d4c0960fb7fad7b7552ef1e662c4c1f12a
+dist/2025-09-21/rust-std-beta-thumbv7em-none-eabihf.tar.gz=1b35c7e25986065e63dfe8e8a1824bf13b62daa5777f32b140f03d0f4fe5cd1e
+dist/2025-09-21/rust-std-beta-thumbv7em-none-eabihf.tar.xz=335b28756025f8454ae7c6ef6760a512f0b59385cdeacc7dca0ea1bfe5e9a703
+dist/2025-09-21/rust-std-beta-thumbv7m-none-eabi.tar.gz=2291b4c7f27fa0408f394c48390cfd6c7144db5cc4e51c8891c3bb24300b8421
+dist/2025-09-21/rust-std-beta-thumbv7m-none-eabi.tar.xz=16b6104ae79bc0f3fa6d862c72cb3f35a9f67bbea7f9aee7b2a3b0c810225c6b
+dist/2025-09-21/rust-std-beta-thumbv7neon-linux-androideabi.tar.gz=6a7f167dd4c457d6185ee47dc206d19d6ca93e3e0418b21c0745d84c53995e64
+dist/2025-09-21/rust-std-beta-thumbv7neon-linux-androideabi.tar.xz=4fb366719cdadec26e88d64154b2b1b459affe5b894b426a0509681d173cf823
+dist/2025-09-21/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.gz=3ff578be0c8b1171c5c2d0aaa3f4fc20f3a252f5adf050bd5856b201cc22841f
+dist/2025-09-21/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.xz=16c518c3daf87722a5e2556e92e97d429a06b2ed2c79380989db04ffa4791279
+dist/2025-09-21/rust-std-beta-thumbv8m.base-none-eabi.tar.gz=b1d67e62ac198fcff25c29e731f2dca9eba3fbb09adb29db68d823b0ad63e85b
+dist/2025-09-21/rust-std-beta-thumbv8m.base-none-eabi.tar.xz=ac586b0a3cd91eb2928861ded895b96a85880851df2f3e63c2391cb38d98d140
+dist/2025-09-21/rust-std-beta-thumbv8m.main-none-eabi.tar.gz=93cfb0ceb07879366ecb4e00caf5b4459574852943363b0d6fd3293c4a0c27eb
+dist/2025-09-21/rust-std-beta-thumbv8m.main-none-eabi.tar.xz=879724fc40ca55193760b3739387dc237587e91c30e334709d5453e07840d4d0
+dist/2025-09-21/rust-std-beta-thumbv8m.main-none-eabihf.tar.gz=7eb1217837173f0974f7a0fc69b0e9fea484f2d457f3b193ca3b2c04ed83bcd9
+dist/2025-09-21/rust-std-beta-thumbv8m.main-none-eabihf.tar.xz=c38af1e6560589be7a0733508b800e68bb5b57f2ec3c5452fb14000cf9ef2fa0
+dist/2025-09-21/rust-std-beta-wasm32-unknown-emscripten.tar.gz=9475cb292c64491c545a02df4deae77d4174d77db18a84c8db635ae6de691b8e
+dist/2025-09-21/rust-std-beta-wasm32-unknown-emscripten.tar.xz=6e477e9ea0e5bac0b567deacfba3c236ceda28fab4d63c011d6bc54ac22c8570
+dist/2025-09-21/rust-std-beta-wasm32-unknown-unknown.tar.gz=eb7bf16e819eabe3f685bb8dd09bfff31d35d87cf03535195c411ec1738b6647
+dist/2025-09-21/rust-std-beta-wasm32-unknown-unknown.tar.xz=05a2bc1539b02ef314b268fc2860836c111705b872d5d56ba6ea511cb47e7169
+dist/2025-09-21/rust-std-beta-wasm32-wasip1.tar.gz=aa34f89676c72a3ce5df82cd819466631ed91896dd7a1b64fb4ca9a97595e254
+dist/2025-09-21/rust-std-beta-wasm32-wasip1.tar.xz=ad5756f4ce3e0309d04746609abdee2152fae66383b2b13d338c900b8f787060
+dist/2025-09-21/rust-std-beta-wasm32-wasip1-threads.tar.gz=36c42b952305d381718c36f34c4d5c1705aec71f946eee56c685eae56f9c40d1
+dist/2025-09-21/rust-std-beta-wasm32-wasip1-threads.tar.xz=c0285e26be272e3e832a74f22960899ac0f350dc6764701df748541ddbf69377
+dist/2025-09-21/rust-std-beta-wasm32-wasip2.tar.gz=198d4cb5195fa1e992cec8bf84716eed1ade0e9a8cc3981f3fb3cb9971e2796d
+dist/2025-09-21/rust-std-beta-wasm32-wasip2.tar.xz=0fd2cd8923741931aa17d1571a5f8c20c9b0e96d74dc75ab47cd9245586bfa03
+dist/2025-09-21/rust-std-beta-wasm32v1-none.tar.gz=cef69dbdfbd0352bf781c1e59129c29c17a6c1367aa00184be309c56f8f29dfe
+dist/2025-09-21/rust-std-beta-wasm32v1-none.tar.xz=a412840ff9550e447a2608a9c26ec02e969b2579bfe5c635a3af0cccd011922f
+dist/2025-09-21/rust-std-beta-x86_64-apple-darwin.tar.gz=290fefcf45ff24a79459c44523bfbbeeaf9eb9bf3e7e64fcab64368fe21ed2d7
+dist/2025-09-21/rust-std-beta-x86_64-apple-darwin.tar.xz=176634d6797df21873c317b93cecfc32f415b3248139a32bfdbee83607e734c1
+dist/2025-09-21/rust-std-beta-x86_64-apple-ios.tar.gz=639916204bcc229bd5d5fd1ccb455d9a962a11d05388252c1e5e310d424f1ef6
+dist/2025-09-21/rust-std-beta-x86_64-apple-ios.tar.xz=c0c597f428fdc8f2f89e26c0e5d9debef45ec449b869ea0a738102a8727e8da4
+dist/2025-09-21/rust-std-beta-x86_64-apple-ios-macabi.tar.gz=debfb6dfe448e345cc934e5a0d09715ca899ed9593c26eab07c58c41683113f4
+dist/2025-09-21/rust-std-beta-x86_64-apple-ios-macabi.tar.xz=a9b6b2de9e26182f5a37a8ff56487916379809b2afe9e14d34ee55f98d526267
+dist/2025-09-21/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.gz=2517ded939281e8722e5ca6d2cdff6a78a4fa39b5828a3048d9f25a3ec40bbea
+dist/2025-09-21/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.xz=7e8efa9cb373f580c46fa348b1f76acb46456c71fb6afea2b22d5a16b90ce28a
+dist/2025-09-21/rust-std-beta-x86_64-linux-android.tar.gz=2bb9470fe62c5c1e1d31f63544b2bedb833c07c5305448e46283b48d8a575d65
+dist/2025-09-21/rust-std-beta-x86_64-linux-android.tar.xz=66a024fd9bda49ff4db5d70a2dc094708ef73c027ad0aa7dcbd7cea8449b151f
+dist/2025-09-21/rust-std-beta-x86_64-pc-solaris.tar.gz=104b17a08a01593195921a56153a2b54782640f9dbf9e59c7da9f29afe3fe4aa
+dist/2025-09-21/rust-std-beta-x86_64-pc-solaris.tar.xz=c3950a3a8bdd1326ab7d0ac08dc2a4f5c354e9ef6447324145cbe9fdef54f026
+dist/2025-09-21/rust-std-beta-x86_64-pc-windows-gnu.tar.gz=d1d998991c9c8107f919c851d327d730beb6d4f4937a9f8dd2de2fbade1c1dd6
+dist/2025-09-21/rust-std-beta-x86_64-pc-windows-gnu.tar.xz=654322ad813f9414e7ba2c5c5cb141db234d73b9ad237595d844dad564917a98
+dist/2025-09-21/rust-std-beta-x86_64-pc-windows-gnullvm.tar.gz=6b9323f0bc1055dbf3e5fb4ec5fa09f28b7a0cd04ee8bb40e727d85d1a5225b5
+dist/2025-09-21/rust-std-beta-x86_64-pc-windows-gnullvm.tar.xz=3ea958ef88fc3334e98556fd3bcc00264d9dd75cccf6f19f6f5514ec447d0557
+dist/2025-09-21/rust-std-beta-x86_64-pc-windows-msvc.tar.gz=ddfbb760544eb8a7562cc8fab7cf313d45f490dacde3575329f627546971db0b
+dist/2025-09-21/rust-std-beta-x86_64-pc-windows-msvc.tar.xz=25f8e1279fc8647e117c6f3dbf3f4059e7ddc058cf6e02b43f499a72bee6ebbe
+dist/2025-09-21/rust-std-beta-x86_64-unknown-freebsd.tar.gz=2941d17a2370ecab1e839236ba092c065cfa1b94e448a77a5851dab9ec2f1a59
+dist/2025-09-21/rust-std-beta-x86_64-unknown-freebsd.tar.xz=ff2aae7c2e37e48f500df5876c3a26d3dd10affd04e888ce54a4635a5345efa6
+dist/2025-09-21/rust-std-beta-x86_64-unknown-fuchsia.tar.gz=1cdbbbdf1aa9c6e764493576adbd962e004ff029b064089be35910768f409579
+dist/2025-09-21/rust-std-beta-x86_64-unknown-fuchsia.tar.xz=8196d32e28630a3ccc1dc96d9abb3efb5f2090b7bdce9963b2579995f575435c
+dist/2025-09-21/rust-std-beta-x86_64-unknown-illumos.tar.gz=bbe4419e2d9f5bee75f6c1f7b0cf272100e3a37aebc28bc626820c886fabec47
+dist/2025-09-21/rust-std-beta-x86_64-unknown-illumos.tar.xz=2fc8f8ccd022152a87a447079169340218d7541b3513eed36cf7af20d5f565ce
+dist/2025-09-21/rust-std-beta-x86_64-unknown-linux-gnu.tar.gz=222198fa6b782010beac1710693ee1aeac1ad7eb9ac183625128de788a1a4bfd
+dist/2025-09-21/rust-std-beta-x86_64-unknown-linux-gnu.tar.xz=b60da22feb82c21128a151013c690cdef1c291de33e1b6ada5dcc95d3bff3899
+dist/2025-09-21/rust-std-beta-x86_64-unknown-linux-gnux32.tar.gz=31ab3940e428fe58ac584c33072be16d31edb0c16df379d9847cb904947126cc
+dist/2025-09-21/rust-std-beta-x86_64-unknown-linux-gnux32.tar.xz=8304e2e4440e0a91b05bfe58bd44e7087c28c2682a1a5f5b659e2aba708463fb
+dist/2025-09-21/rust-std-beta-x86_64-unknown-linux-musl.tar.gz=c15ecaa46a814cfd5fa27b29aed9e0e578a652b8f6392b916341d30172da7ede
+dist/2025-09-21/rust-std-beta-x86_64-unknown-linux-musl.tar.xz=08a84716ed6bc70a58841c5d61216a781b8a947bbb5fb5ebde757e537a2e5dd3
+dist/2025-09-21/rust-std-beta-x86_64-unknown-linux-ohos.tar.gz=5f1a8ed2093099b18cc83eddb304234f201f8ab137ae950c73329156570ba975
+dist/2025-09-21/rust-std-beta-x86_64-unknown-linux-ohos.tar.xz=ebcd581394fd243eac3d683e334d73ef3d3bbaf7de28bd4082329683e2c770c1
+dist/2025-09-21/rust-std-beta-x86_64-unknown-netbsd.tar.gz=430f4b7f7eceb5e633bccafa9acf08095c1aa4b3dfaa94734fcd331b3d69ca44
+dist/2025-09-21/rust-std-beta-x86_64-unknown-netbsd.tar.xz=2e403587de5c02ba9c5f9f2515d4c9fdffde59cec28c8dcafdfe40d03e4f3152
+dist/2025-09-21/rust-std-beta-x86_64-unknown-none.tar.gz=84d695e6f19706fdd7c01dbfc4607f310e8495f57c29bad2476e00c7bb269646
+dist/2025-09-21/rust-std-beta-x86_64-unknown-none.tar.xz=6e12698afd8a6743a9a6a011ad67ab16d5a40b6dbf1d09104b8294ea95fc2636
+dist/2025-09-21/rust-std-beta-x86_64-unknown-redox.tar.gz=cadafa58684734fc43417742d9151aea36b62f82aa3cd7b858140ce31e9a6ce6
+dist/2025-09-21/rust-std-beta-x86_64-unknown-redox.tar.xz=f1089cab004cb67134bbac6d8acb09b4dd5e02010e069790e13970b004ca4ab5
+dist/2025-09-21/rust-std-beta-x86_64-unknown-uefi.tar.gz=2dbc6eec98b7d730fe2ba982d78f7331346e9018146597200340256d28c0aaf2
+dist/2025-09-21/rust-std-beta-x86_64-unknown-uefi.tar.xz=8a5896f3301a6238984114cf52f7f234bdcb712cb6d914093159ecc82904ba7e
+dist/2025-09-21/cargo-beta-aarch64-apple-darwin.tar.gz=4c6172e8523576deaa6c83274dbd993338d545a794e42aca3c074450d7e7cea0
+dist/2025-09-21/cargo-beta-aarch64-apple-darwin.tar.xz=5e8978daaaed1304e94c071ab5414ce90eb9c7bd1c4f1c8c5f4ff515f6558851
+dist/2025-09-21/cargo-beta-aarch64-pc-windows-gnullvm.tar.gz=49cba73291916ddf2e4912d4ea02add165f2786ad7f7b8885628d92579cbebd8
+dist/2025-09-21/cargo-beta-aarch64-pc-windows-gnullvm.tar.xz=d60a0a176b7d15606f6ee31b67d4a5ac6735e5a0b012022e9212fe723bddec48
+dist/2025-09-21/cargo-beta-aarch64-pc-windows-msvc.tar.gz=dfd4aa83d38a6236789676ef02c81382f0741671ed9a973cd74d37c65b3f111a
+dist/2025-09-21/cargo-beta-aarch64-pc-windows-msvc.tar.xz=8ab6cd565993b58c6e2169bfb468c441dd385c5336081c45f6a60608522ce549
+dist/2025-09-21/cargo-beta-aarch64-unknown-linux-gnu.tar.gz=eb361e2d12c90c9380112ef48b81db1b41f04b4ae08cd061fe1caa46cca9ce6b
+dist/2025-09-21/cargo-beta-aarch64-unknown-linux-gnu.tar.xz=e9f4c66995b8e955e86a67c44fd8d7f6e7349645393bfa605c6c1bb0afc7b930
+dist/2025-09-21/cargo-beta-aarch64-unknown-linux-musl.tar.gz=dc88806e5ac4004a9a3cb24f0c850fde2c22b0e38e6ad84bd570069043485bfc
+dist/2025-09-21/cargo-beta-aarch64-unknown-linux-musl.tar.xz=e103f1d074ab105d03a88066363d2b103508ec95c18cbf8b1f92d0f473ddbf40
+dist/2025-09-21/cargo-beta-arm-unknown-linux-gnueabi.tar.gz=e35bcf36bd7578cdbccb60d554feb19f8376fd41850e4e8046e0b2f931040c01
+dist/2025-09-21/cargo-beta-arm-unknown-linux-gnueabi.tar.xz=ff1b46781284948aaf8c8f582203877ffda5a78d86c266bf724fbb08503a6e80
+dist/2025-09-21/cargo-beta-arm-unknown-linux-gnueabihf.tar.gz=dd657b5eb50264c90fafbd967b20768d9e4df14ef179902420b3f9a3e2145271
+dist/2025-09-21/cargo-beta-arm-unknown-linux-gnueabihf.tar.xz=3f821c437963aec534cdbd686f719eb86bfe41cf254ed5395730f7827d45a68a
+dist/2025-09-21/cargo-beta-armv7-unknown-linux-gnueabihf.tar.gz=7874b945f3d77e2a8ca308e5400a2411ab4f615f45a036bd9fab8a74434c309d
+dist/2025-09-21/cargo-beta-armv7-unknown-linux-gnueabihf.tar.xz=39523f09c76473d10b91ee946523976e01dc337d2af067f08168f1d9cb44226a
+dist/2025-09-21/cargo-beta-i686-pc-windows-gnu.tar.gz=43b095acb25cf5c0dbfffc6fbc864c2b2415251931b149b282d5e70844fc2c50
+dist/2025-09-21/cargo-beta-i686-pc-windows-gnu.tar.xz=6cac1a1a6d74765f4233908920d295761570ddcd8cf3638bbc8f8eb427084b92
+dist/2025-09-21/cargo-beta-i686-pc-windows-msvc.tar.gz=7f4314596e6ea01a35b9e2e250227a74b5d4bd772ac8d33d12bd44f8c11b37e5
+dist/2025-09-21/cargo-beta-i686-pc-windows-msvc.tar.xz=eeaca23bf3cafbd01cdcef890d02ecd622d3ccfd6d9830f1e599d29acfa371bb
+dist/2025-09-21/cargo-beta-i686-unknown-linux-gnu.tar.gz=e79e3a25bb790c5f6ed9e81a0559a55750a1a3e35250f0fc5fd92c195625aa28
+dist/2025-09-21/cargo-beta-i686-unknown-linux-gnu.tar.xz=1fe31a0e463736a9ae90ef11c1e3c7b7972eb82779ecdf5b6bff1f643684a014
+dist/2025-09-21/cargo-beta-loongarch64-unknown-linux-gnu.tar.gz=917db09ef343b6702c1410c2c68070c4bcfd90f6951591490a6a237290a4aed3
+dist/2025-09-21/cargo-beta-loongarch64-unknown-linux-gnu.tar.xz=222010f8428a3d165801d95a820b639ac930747af3cb4a42a25548330585f73e
+dist/2025-09-21/cargo-beta-loongarch64-unknown-linux-musl.tar.gz=7e949bc169a58e450e58088fd716aac9a05f5fca0790d94dd211ce823c2c5d36
+dist/2025-09-21/cargo-beta-loongarch64-unknown-linux-musl.tar.xz=dfeb99ac76e18160aee7ff1c878b44b9fdb725f7be28609e637bd372aab448a3
+dist/2025-09-21/cargo-beta-powerpc-unknown-linux-gnu.tar.gz=523103d950944aed52578002dd372207b3bb38e4130b4b11097b03f7d55345c9
+dist/2025-09-21/cargo-beta-powerpc-unknown-linux-gnu.tar.xz=db5c4ce1a1a4d87cca4fb64a6c533cc5ab1c94e25e69b26e13808b0fa5e853e9
+dist/2025-09-21/cargo-beta-powerpc64-unknown-linux-gnu.tar.gz=68479082544f7f68a2fe073ed3d35e1895643f8ab9abe9d0e968efa9f342de36
+dist/2025-09-21/cargo-beta-powerpc64-unknown-linux-gnu.tar.xz=8878cf473faf120efb80bac0564b193f3baa14a9027fb4c060574e6fc921edcc
+dist/2025-09-21/cargo-beta-powerpc64le-unknown-linux-gnu.tar.gz=eb37177cdbc9e2b7f9b74856b351bb764e5c2603366fd92a5c863cbad26e6940
+dist/2025-09-21/cargo-beta-powerpc64le-unknown-linux-gnu.tar.xz=92734c444e0156e16c8d8998a8432b24d9d01b82da15123508d0002eb008b9bb
+dist/2025-09-21/cargo-beta-powerpc64le-unknown-linux-musl.tar.gz=502d5d2ec61d9fcd5b92caa0b4f0aaa11f27fccb7ec4736e05beca313f306585
+dist/2025-09-21/cargo-beta-powerpc64le-unknown-linux-musl.tar.xz=e00bc0ef1784b2f7b1fdbb757cd50342cacc49f7f5d2d3f7b36f9f4eca23882c
+dist/2025-09-21/cargo-beta-riscv64gc-unknown-linux-gnu.tar.gz=3e00c4c0d64977ddd2fcece9407a01f92ec9b44ea37d72ebbdb77cf0c532163c
+dist/2025-09-21/cargo-beta-riscv64gc-unknown-linux-gnu.tar.xz=3be5932af030c758a84bc09cbb1c2bc5abecc4e7d8a82de58c2a069ad36e737e
+dist/2025-09-21/cargo-beta-s390x-unknown-linux-gnu.tar.gz=aefcadb257bbcf93dda58526390962316b4e579707c043c45e52bfd4d7a097dc
+dist/2025-09-21/cargo-beta-s390x-unknown-linux-gnu.tar.xz=3d163f9fdc2b8b0f5cbbf846caf1dccaee07984d8783250e8988ef447e53663d
+dist/2025-09-21/cargo-beta-sparcv9-sun-solaris.tar.gz=bc1692d8d75654012a823adb40b87d3b5721b19beb49a30b404a6c78f431c944
+dist/2025-09-21/cargo-beta-sparcv9-sun-solaris.tar.xz=ff7f36d7832b094b9ca2132df4851cf0ca50c9fc2de3d55bb6c75b46dd028f10
+dist/2025-09-21/cargo-beta-x86_64-apple-darwin.tar.gz=1a67e618eeadf362e868bf2cb35c1a312db83d1a59cee38f61794e45cba3ba4e
+dist/2025-09-21/cargo-beta-x86_64-apple-darwin.tar.xz=28c0ae4f78f37abe27a3db5e5fb8c78c51a98b71cd0c4c69f9256b5d4064e78d
+dist/2025-09-21/cargo-beta-x86_64-pc-solaris.tar.gz=c2da94328a164d889ebbbcd5f403068126e8f28ebc0c4ff7bf5cde1e8cc380b4
+dist/2025-09-21/cargo-beta-x86_64-pc-solaris.tar.xz=4fb30f600f8a10f43bfbf4361fbc7e906217007d46d65731b1bae0007eaca783
+dist/2025-09-21/cargo-beta-x86_64-pc-windows-gnu.tar.gz=86e23a551906f961a8a05b50185185de683f824a69bc739c3786e4f2004d83f8
+dist/2025-09-21/cargo-beta-x86_64-pc-windows-gnu.tar.xz=860562d5c50c60233d088886dd22b23c0c40504107b04cdfb51506c631d948ba
+dist/2025-09-21/cargo-beta-x86_64-pc-windows-gnullvm.tar.gz=b568148f13e609e6cbb7e2b424c13a8b85126c8ef84f3b884043aab204352615
+dist/2025-09-21/cargo-beta-x86_64-pc-windows-gnullvm.tar.xz=7983768e6c77334eedd563cea4cd51cbf85d5234d1952801783016f07f1d6ce7
+dist/2025-09-21/cargo-beta-x86_64-pc-windows-msvc.tar.gz=839f7866c75750a5fdc0e7b9fdf37e0b60e71be916b496a9be3ecedc87473c2c
+dist/2025-09-21/cargo-beta-x86_64-pc-windows-msvc.tar.xz=5d0e3c8e9082a00be80cc3924e12b7d9d067f9ecfbe14dd1e1bfadff55d2bccd
+dist/2025-09-21/cargo-beta-x86_64-unknown-freebsd.tar.gz=8c22ee4fb01955f20d04dba271b44e69718266d70610fbd979565d95df316e6b
+dist/2025-09-21/cargo-beta-x86_64-unknown-freebsd.tar.xz=6356f4d133c3820736f82c4eb2857548b5255af4ead57f1f8e66ebc6aaa628ed
+dist/2025-09-21/cargo-beta-x86_64-unknown-illumos.tar.gz=43523fa8da79aca1e5a618c10ea031404250cdf1a41b0da369ed6efd05c4190e
+dist/2025-09-21/cargo-beta-x86_64-unknown-illumos.tar.xz=c9a1b43c762b3658b0fac5145c6314a1c9e416d025ac22958fc0809fbb24d1e0
+dist/2025-09-21/cargo-beta-x86_64-unknown-linux-gnu.tar.gz=ba780983f067e7dbcce49dd4d39a0d3c0002dbe7dba73eb2a98d7eae17f70931
+dist/2025-09-21/cargo-beta-x86_64-unknown-linux-gnu.tar.xz=07aa13a5411a49238b31191a0797d63b74120a1fa9b5658a67f6c1065271c30c
+dist/2025-09-21/cargo-beta-x86_64-unknown-linux-musl.tar.gz=96e6367138d6ff9ae2ca4343f3d5277b5fce39fe6909cfccdd57f1867eb9b021
+dist/2025-09-21/cargo-beta-x86_64-unknown-linux-musl.tar.xz=83e6fb5196805c9bdfca4e80e76e185a885da0820108e98e1fc7ef4aeea7f1e5
+dist/2025-09-21/cargo-beta-x86_64-unknown-netbsd.tar.gz=422fdb2cc97767f235d6abb29dbb0e802b320e11c743f794f8ad13160e4c7c7c
+dist/2025-09-21/cargo-beta-x86_64-unknown-netbsd.tar.xz=75c4aee9a720fa55ac5e80c58a890efbf88c57fbd2c57043b9f29bdbd6ae0e3b
+dist/2025-09-21/clippy-beta-aarch64-apple-darwin.tar.gz=de39b5014bffa7e20ae1f981616664703828428b6b1a74a6fee80fbab446e74e
+dist/2025-09-21/clippy-beta-aarch64-apple-darwin.tar.xz=d5ad3181f6978604f725db8607daf39ee20cbbb6ade35bb50ae7b032b0b62e9f
+dist/2025-09-21/clippy-beta-aarch64-pc-windows-gnullvm.tar.gz=a4f5538776b2f1f31bef81f37615d9bc3495080174fe83be0c549508923c9e9b
+dist/2025-09-21/clippy-beta-aarch64-pc-windows-gnullvm.tar.xz=a78a56cf381483703f120c596d6921b04aface91847310e20da53aa887a2e603
+dist/2025-09-21/clippy-beta-aarch64-pc-windows-msvc.tar.gz=06a6ee3aa204812322d0b9946ea31dbc5045e59253891fea7e079d4c7e1de894
+dist/2025-09-21/clippy-beta-aarch64-pc-windows-msvc.tar.xz=a4f0add69dad90f0dd7c47966b12f6cb7a4c6e34cc1b44e4a816d359659ae012
+dist/2025-09-21/clippy-beta-aarch64-unknown-linux-gnu.tar.gz=9d88fade821957052581f65765ae84286eee07e0985504d5a7324f615649a506
+dist/2025-09-21/clippy-beta-aarch64-unknown-linux-gnu.tar.xz=0c278a9aaa1ae41bd9bd96f52fed50b1a11a65822024fd01a9eacfa3aa8f1de9
+dist/2025-09-21/clippy-beta-aarch64-unknown-linux-musl.tar.gz=7d04aeb77402ca2ad964b6430ad75d0ec08a68efb505573f5e134664a5aae044
+dist/2025-09-21/clippy-beta-aarch64-unknown-linux-musl.tar.xz=d28207a804219edccb110160ffdf1c1525248ac225df89f4d11e3538a5dd0dcb
+dist/2025-09-21/clippy-beta-arm-unknown-linux-gnueabi.tar.gz=2433be238da05b6dbf44a74537e48a1dcd96fc03a8059ab78e553833546f1b97
+dist/2025-09-21/clippy-beta-arm-unknown-linux-gnueabi.tar.xz=74d5920785504fbc0c1e0237a4ee4e8355ffeba2c4bd9471c38d44e3ae52ef4d
+dist/2025-09-21/clippy-beta-arm-unknown-linux-gnueabihf.tar.gz=f83867145c740302ad81912f8e39433aac19fa5312f14d35aee2b59638660299
+dist/2025-09-21/clippy-beta-arm-unknown-linux-gnueabihf.tar.xz=420c7b7b6cf54eb27fc3446223ab03a3f90628b47d6b4ae66e432380b57661ad
+dist/2025-09-21/clippy-beta-armv7-unknown-linux-gnueabihf.tar.gz=14eefaa624591a49d6d2a3af9663ea4f3aca804d3563f668c734d9e18cc0b39b
+dist/2025-09-21/clippy-beta-armv7-unknown-linux-gnueabihf.tar.xz=14e8371566643fdf146117d06b9fa77aa886360d3696d9e43482f288338822b6
+dist/2025-09-21/clippy-beta-i686-pc-windows-gnu.tar.gz=b7ceb33faebadc67294e1df3f08d8d9760a6a17ca1ad30f26da3c586487a14c6
+dist/2025-09-21/clippy-beta-i686-pc-windows-gnu.tar.xz=f0a3f41a65d90119a4c66c6a2007d1f1a75a24e86d9a572837c4410b02af426b
+dist/2025-09-21/clippy-beta-i686-pc-windows-msvc.tar.gz=dbdf0cae38daed8bee11eb63d7c3f1c5d019777c238495149baa5ccb10af0f37
+dist/2025-09-21/clippy-beta-i686-pc-windows-msvc.tar.xz=adc49c09b72ff46d3d03f31c8c641675af389ba99c4c517149a10ae471c37c25
+dist/2025-09-21/clippy-beta-i686-unknown-linux-gnu.tar.gz=793ace0c8927a48caf443b794de097895f9e503299da07da13238a56ea8ac07e
+dist/2025-09-21/clippy-beta-i686-unknown-linux-gnu.tar.xz=22b9b2b27d0b6b1fd88d67b18d34a4a91207e6b64ba8d47dbfd0c58763d429b3
+dist/2025-09-21/clippy-beta-loongarch64-unknown-linux-gnu.tar.gz=101437e0f1bdc8ca07455d92c87bc32914a5047f6c9d7b7ab9e34799c5d4a5a3
+dist/2025-09-21/clippy-beta-loongarch64-unknown-linux-gnu.tar.xz=afd8c55fa82482a852b564511c4fdddf12abbffc0bbee1b0b4155fd1d6c04105
+dist/2025-09-21/clippy-beta-loongarch64-unknown-linux-musl.tar.gz=df33c329856ed057d069a479181b4fa97fd4a11d109abfa32d6b46c36215e6f3
+dist/2025-09-21/clippy-beta-loongarch64-unknown-linux-musl.tar.xz=ca8451dfcb5b919c1a6510616c8e93dfb15914e689cb30f7debf4c1a4aef58fe
+dist/2025-09-21/clippy-beta-powerpc-unknown-linux-gnu.tar.gz=1b738f58256186f0b530375ea2da804aa1834a908412e56767c9a44b134cfd68
+dist/2025-09-21/clippy-beta-powerpc-unknown-linux-gnu.tar.xz=93333f47a041d4ddea4fd9ad3fb3ab43c40fcee4fabe6405190fa26d6bfe3e2a
+dist/2025-09-21/clippy-beta-powerpc64-unknown-linux-gnu.tar.gz=2f0da38cf8efcda85634249df5398bb99f3b34982fb4509a0a3171437d809ab0
+dist/2025-09-21/clippy-beta-powerpc64-unknown-linux-gnu.tar.xz=fb3d68e09e40cbf7d6c330c3866c37c759ed728c1d8cbeb6e8e834f6a1fce1c9
+dist/2025-09-21/clippy-beta-powerpc64le-unknown-linux-gnu.tar.gz=7cb5fdfebbc0565e2d883da09815dfb626104afe39c01b169a919a82f62df607
+dist/2025-09-21/clippy-beta-powerpc64le-unknown-linux-gnu.tar.xz=d6705b1e6722e3faf5b863fb319cd811fcb27f4a564e633f164f02f8699c9255
+dist/2025-09-21/clippy-beta-powerpc64le-unknown-linux-musl.tar.gz=ea33f22a67f7c8354e7421129bfcbfb4bce7d909fcfa6a64a3107d82be69d213
+dist/2025-09-21/clippy-beta-powerpc64le-unknown-linux-musl.tar.xz=081e303cf123ddc162633d4d1e3adef4e6fd39598f60ac9dd75c76230df39ddb
+dist/2025-09-21/clippy-beta-riscv64gc-unknown-linux-gnu.tar.gz=76ac5dc8b8284437e5fe81cb4978460a6aa5c4a857c4f14246dfabf1831998f4
+dist/2025-09-21/clippy-beta-riscv64gc-unknown-linux-gnu.tar.xz=2ed67a738a07e9d07c1db7789cc5ebe7af033334670fcb1ce84441b9e474ec0c
+dist/2025-09-21/clippy-beta-s390x-unknown-linux-gnu.tar.gz=d5a7e6cfdd099ed18e54d88dc1d740b90d1f7d2f22d1fe6ca7960b7319b0783a
+dist/2025-09-21/clippy-beta-s390x-unknown-linux-gnu.tar.xz=78231b81d8e612a4c41828428ba2e9af926f2119308b291c8ce81a5233c3c6a6
+dist/2025-09-21/clippy-beta-sparcv9-sun-solaris.tar.gz=a1b0086259586a26f6ca65b02adea83b953989a508385d58fa56c7eafb770227
+dist/2025-09-21/clippy-beta-sparcv9-sun-solaris.tar.xz=b58151b098d58b19bc900f72813138799e2e568a5ad3038528045e5ac562606e
+dist/2025-09-21/clippy-beta-x86_64-apple-darwin.tar.gz=62ecc253fa747ec67ae11c7a1672661cbac7d78c1001654e17ca5c0e3bd72d91
+dist/2025-09-21/clippy-beta-x86_64-apple-darwin.tar.xz=b7e9785d3ab00163a0070b7772a4354e9503cdb8456d1a2b0708920658aac614
+dist/2025-09-21/clippy-beta-x86_64-pc-solaris.tar.gz=783d47012b943cd4497c2e0e854cd7727b0957518178165cc1cbc4dc5e6509ff
+dist/2025-09-21/clippy-beta-x86_64-pc-solaris.tar.xz=94efccbbe73b2f15f5f86c90324b3adbd1b58bbdb81ea9c32d7efaf067bc6795
+dist/2025-09-21/clippy-beta-x86_64-pc-windows-gnu.tar.gz=8b12cc5e7b9b7e0b234a29886c81455878e806067c025cf3d26eef4a52e08bc5
+dist/2025-09-21/clippy-beta-x86_64-pc-windows-gnu.tar.xz=35fc298fd25949b491c54bfa2f40c963d7ca530b65ac8e52031edf17624b3d05
+dist/2025-09-21/clippy-beta-x86_64-pc-windows-gnullvm.tar.gz=824e1590e12bcad69b43912068e27585466fcc5cf7a2f92f41f727aa39cbcaad
+dist/2025-09-21/clippy-beta-x86_64-pc-windows-gnullvm.tar.xz=6fad67e180d0eb0d551b2101dc27bf6846ae2840c63d1ef05588691d055e3806
+dist/2025-09-21/clippy-beta-x86_64-pc-windows-msvc.tar.gz=1353d8c3310d53576d94aa744fe0844b5527d8b54fe43a692042be78b0fca6f5
+dist/2025-09-21/clippy-beta-x86_64-pc-windows-msvc.tar.xz=a7ca6fecd77dc44f3102abad7fbe1fa3846d9ff6ea98a25d4c3bd703800894d2
+dist/2025-09-21/clippy-beta-x86_64-unknown-freebsd.tar.gz=33b5f8dd6a0ef045ad19df4327259a468ece00b250d9fbfe1be7c0f293f874ce
+dist/2025-09-21/clippy-beta-x86_64-unknown-freebsd.tar.xz=1bd56197e30fc325c7482aa7a42006a7ad9a0ffad9f3d74d209e98582d2897e4
+dist/2025-09-21/clippy-beta-x86_64-unknown-illumos.tar.gz=0ba3c497472c34de44bda2485d3b964cdab83e3700b44ffd8b41037ccf59a932
+dist/2025-09-21/clippy-beta-x86_64-unknown-illumos.tar.xz=040302a04decb3cfcd599b329db3f17e5f96b7aa4b8174d6f2b17ba19c991853
+dist/2025-09-21/clippy-beta-x86_64-unknown-linux-gnu.tar.gz=21fde20675c5f786b5da4f1be39785d1106f748d88a6609fd4976bfe372e6817
+dist/2025-09-21/clippy-beta-x86_64-unknown-linux-gnu.tar.xz=217255d6ea157f7b06aa66d033dca6239bbc296bc14ff3f0017d5c68bb4d1022
+dist/2025-09-21/clippy-beta-x86_64-unknown-linux-musl.tar.gz=7be4202a658df30aeba451e6dd4f740068dbcc769fe0eaa9a7eb8cb2c2e264ff
+dist/2025-09-21/clippy-beta-x86_64-unknown-linux-musl.tar.xz=d2cf3cfa0c5c67d57867586709c274e320c1a76418ffe7dcf65b271448d4de06
+dist/2025-09-21/clippy-beta-x86_64-unknown-netbsd.tar.gz=91f510466f2a8606efc746a5be209a1f0ffe1e20b803f9c54ee91786053cabbc
+dist/2025-09-21/clippy-beta-x86_64-unknown-netbsd.tar.xz=2c17d3a00885495f81cb8606ceb78674f63396b3c2a0b3415bb2e62ab39f9d87
+dist/2025-09-21/rust-beta-aarch64-pc-windows-msvc.msi=d5e39b0a1deaaeaf956e57da755e16255b265e80722428625783e7be0835cbb8
+dist/2025-09-21/rust-beta-i686-pc-windows-gnu.msi=edcb39b92d1e84c7d6b0d2559e37be673795a14e807e77e40b32dcaac8b9d415
+dist/2025-09-21/rust-beta-i686-pc-windows-msvc.msi=dac7d64336aa8fcc77761910392efc845aa2137fff8be8df980b02d48809bbd4
+dist/2025-09-21/rust-beta-x86_64-pc-windows-gnu.msi=44e1e8298714b11bc7cc44184f2b20aa39fbadc23f8b2b86005e74879b8430f8
+dist/2025-09-21/rust-beta-x86_64-pc-windows-msvc.msi=4c673f514c7f0f9bf780c2448fa4a4bbe4e4db618d6a9931bd092a6116d432fa
+dist/2025-09-21/rust-beta-aarch64-apple-darwin.pkg=4a23353da7a58deac032341011c7bdb78f069ff4bda97d837c67e54454e6e1af
+dist/2025-09-21/rust-beta-x86_64-apple-darwin.pkg=5e02da3f6ab8791426060ca40ac7c719451f6f5acba06ec27c273e6f2590cad6
+dist/2025-09-21/rustc-beta-src.tar.gz=22b0288ca9f949cac41260370afd4e6e487c1e3430f6aef23340b50ec4e4ea9b
+dist/2025-09-21/rustc-beta-src.tar.xz=31f4b8b4b3471e7063da5038fe5072e44293705ec65b2c272f8d4cdd37875ff1
+dist/2025-09-27/rustfmt-nightly-aarch64-apple-darwin.tar.gz=78627de068d788f65482cdb2763b27fb7570a197b97056ad16f9f6117fccff8a
+dist/2025-09-27/rustfmt-nightly-aarch64-apple-darwin.tar.xz=d6c4252e895d303337ce1c8edf2fcfd02078b81007e785ff7a15f773a1789e3e
+dist/2025-09-27/rustfmt-nightly-aarch64-pc-windows-gnullvm.tar.gz=d65ef7c1348a74dc1b042c30281ec57c2619a25bdfd8151223415f9d6e067fc5
+dist/2025-09-27/rustfmt-nightly-aarch64-pc-windows-gnullvm.tar.xz=dcd986e9560c45eae6f1d0ee0bce9ad2365d101f4c9b792062557cb26a26152e
+dist/2025-09-27/rustfmt-nightly-aarch64-pc-windows-msvc.tar.gz=8b5a164ee78ee9bf76c1ac9d95f63743cc0b05cff9823d42b88d596ee34c9b52
+dist/2025-09-27/rustfmt-nightly-aarch64-pc-windows-msvc.tar.xz=da675f08931285b2d59be0b8cda46f7489855ec9cc07a608d17e4c0f1e6de486
+dist/2025-09-27/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.gz=7a1b11c66f3832e0ccd390441a921cd50a25ae87e641bb856966fd81cd3d5d59
+dist/2025-09-27/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.xz=5f6aa12529624b66f1de643afe6805cf5484c57e3a7c791f85023d28b590dac2
+dist/2025-09-27/rustfmt-nightly-aarch64-unknown-linux-musl.tar.gz=0cc213fabdad76e6ff699f2f0462c8b3dfe5bdc6b14131fc2c87d915a8fdabbb
+dist/2025-09-27/rustfmt-nightly-aarch64-unknown-linux-musl.tar.xz=ca84ce0de6d11b69ddc691f4edca1474e66b513f695fab738374942d57ab8b83
+dist/2025-09-27/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.gz=dc0f391a0ac09a8ae2271443584dc8f1338bc0b89b50ee82d47599912fb74c52
+dist/2025-09-27/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.xz=d4bebefbc157ecde2fbf7f7ef6a6d8c703d264f56e2ca8a80b7c241b8e14f862
+dist/2025-09-27/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.gz=672fd91b880195a0fb2eb294129c0ec465aa3be217451fd4b835b2c3294d4c1b
+dist/2025-09-27/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.xz=4aa45c993b82f9d9f6b8bf79db2d04acb83cd70147c9ecb1804a3c8258a6c022
+dist/2025-09-27/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.gz=3a8fef72bf471ea1c575c3a6d3a0ffb957fd862f55afb0d40b39c85ff7fc1f13
+dist/2025-09-27/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.xz=08854b212790685caa928e37aa7fe50009590050873c390d2999d6b814bcd2bc
+dist/2025-09-27/rustfmt-nightly-i686-pc-windows-gnu.tar.gz=e99f0d4b314c59b7564e85be580477e751e46acf30752b970c36aa9719e10995
+dist/2025-09-27/rustfmt-nightly-i686-pc-windows-gnu.tar.xz=ba3b9a0e0c44c6edc1396915034efe9e7f59e0724271fd6c1fd4805382e95677
+dist/2025-09-27/rustfmt-nightly-i686-pc-windows-msvc.tar.gz=40f42081d1d2eec00bf49f62c12d75e5e5c345e2a4d8da4fa0741239aea72218
+dist/2025-09-27/rustfmt-nightly-i686-pc-windows-msvc.tar.xz=1b9ef88c7ea98880835d8c298625e2bdd219af46eabb18b8c18c92882d81d054
+dist/2025-09-27/rustfmt-nightly-i686-unknown-linux-gnu.tar.gz=2ff88b8231c70044e9b35c3855515d143aac1b3d7a82bfc84833f76f45539c97
+dist/2025-09-27/rustfmt-nightly-i686-unknown-linux-gnu.tar.xz=e07bab9116c10576b7ab01e26af72bdc97bd34a56aa2468e188e58864b030c33
+dist/2025-09-27/rustfmt-nightly-loongarch64-unknown-linux-gnu.tar.gz=766a69e69be097f710a7c175dbfa39b20970135a6fe420457191e095de5fab1e
+dist/2025-09-27/rustfmt-nightly-loongarch64-unknown-linux-gnu.tar.xz=ad4a38853cb9e6bb6029dbb2ffedf4b49dfc7cb696edbcb561b204bfa89fd8d8
+dist/2025-09-27/rustfmt-nightly-loongarch64-unknown-linux-musl.tar.gz=f08d5f5ac31fda285b81069709a74eb382450543c4d22289980a9ef94a473fac
+dist/2025-09-27/rustfmt-nightly-loongarch64-unknown-linux-musl.tar.xz=40bb1e41db10d4c6b22e46c0f8b5fa1a6ad06cd5f3102c189705380383444323
+dist/2025-09-27/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.gz=d3bf8c8c186c94a0190ae73386839e53dd6ea76cd81e9132438fb7f245d955c5
+dist/2025-09-27/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.xz=665dce6b1a464e1969e3901d7bd293d35a85d5a50ad976600566dcc2a9c46b58
+dist/2025-09-27/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.gz=a28c82ea8a7e2bbd61043e89994cf2be71ead745b3fa782d0653a99fd81bfa64
+dist/2025-09-27/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.xz=3c5cc78a7e311f73c39030f42b8f1d3dd0e54e09f4d636be6a581a829f15483d
+dist/2025-09-27/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.gz=372c476dc902ffb7ebb8ab8934a89d1bbddf9df9c810bc6d90d3afab984b8205
+dist/2025-09-27/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.xz=cf2e738c44ea95d71090bc3526d8c7c70e4554667449f4705614c93444e817a9
+dist/2025-09-27/rustfmt-nightly-powerpc64le-unknown-linux-musl.tar.gz=47f215d0c639f0a4bb67423c65c5b87a06cbecd47ea53484b57c9b7d87c6791b
+dist/2025-09-27/rustfmt-nightly-powerpc64le-unknown-linux-musl.tar.xz=9085b66b2e8e3460f0993896ca3d684395001ab4ed37a16947ce1d15d5aa224b
+dist/2025-09-27/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.gz=0f07ac40b25eeef46a4f4a0d34cf50c9336407f2d7f23c05c47fe35f3a7a1d49
+dist/2025-09-27/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.xz=ce08e9b33e75eb504f28ba23e1cc3003c0aa503fbdceb04271bd533613713160
+dist/2025-09-27/rustfmt-nightly-s390x-unknown-linux-gnu.tar.gz=4e64fc0ec680a294308f897131f8ab185872dc68cd1312fbe1a306ed6e53ba26
+dist/2025-09-27/rustfmt-nightly-s390x-unknown-linux-gnu.tar.xz=b46d423db54a90944276cee172b8cf0ea70562c01537c37c65f3ea17c13a47fe
+dist/2025-09-27/rustfmt-nightly-sparcv9-sun-solaris.tar.gz=3a84501e05cc7430f91903dbb0de0946621d05c095459c47dde3cf7e662e771f
+dist/2025-09-27/rustfmt-nightly-sparcv9-sun-solaris.tar.xz=0107d3c129e1a18a814d5c213b6445aa7ecb7dd95507641d2cb3d0c39293818c
+dist/2025-09-27/rustfmt-nightly-x86_64-apple-darwin.tar.gz=c58e0a2db9b3933539a20614b143e6575f6aa1459ee35af4d67210dd572e6af0
+dist/2025-09-27/rustfmt-nightly-x86_64-apple-darwin.tar.xz=0cd4d7a8cfedc2787bacebbb2fa481d5efe3d56ba476ef8799c34325c40283e1
+dist/2025-09-27/rustfmt-nightly-x86_64-pc-solaris.tar.gz=ad3fdf81b7b00ee670b05ed2bdc05f79a9c066104d797dc7eaa4d767dfe2eeae
+dist/2025-09-27/rustfmt-nightly-x86_64-pc-solaris.tar.xz=df79594ece4b8753d8215672004e9071a8c10c8ece8c86d1d3608c8d7c3f0486
+dist/2025-09-27/rustfmt-nightly-x86_64-pc-windows-gnu.tar.gz=cb800c92a8f899d148adc96283818aa81c115b73555c047e07a67d738e9cd2c9
+dist/2025-09-27/rustfmt-nightly-x86_64-pc-windows-gnu.tar.xz=09f6d95c49725c36bace10c8e119d6850dabee1dcdebac264074e296f9e8ab48
+dist/2025-09-27/rustfmt-nightly-x86_64-pc-windows-gnullvm.tar.gz=e061a3925b95a99dffb17d34c85803bbcac4604f95da2674872f0725d82cdda4
+dist/2025-09-27/rustfmt-nightly-x86_64-pc-windows-gnullvm.tar.xz=1090793fe09cd2ec4c54063600c1999f5e53a9ddc5c5d74e4f5e85dc6f2ef98f
+dist/2025-09-27/rustfmt-nightly-x86_64-pc-windows-msvc.tar.gz=f3978135d4a9bf2537625e38866fca74ca1f0655fc9fae736bf87d257d6cd0d5
+dist/2025-09-27/rustfmt-nightly-x86_64-pc-windows-msvc.tar.xz=03814722fe9798b503ab7d8284c67e84cf18a9a2f179fe227e3313d0ae3e2cff
+dist/2025-09-27/rustfmt-nightly-x86_64-unknown-freebsd.tar.gz=d5a477ce3f220016f097f8949fc2eb1c700c612e97105804156e82264e7ba787
+dist/2025-09-27/rustfmt-nightly-x86_64-unknown-freebsd.tar.xz=0fe90bad20ee599e4e57c46d4bf700c5775c484f0a8bfb2ce4957d2aa2df90cb
+dist/2025-09-27/rustfmt-nightly-x86_64-unknown-illumos.tar.gz=6d48ed9c944fb01655d4025c4aa3b719813cfef040fecff1f59b8b51a0b9510d
+dist/2025-09-27/rustfmt-nightly-x86_64-unknown-illumos.tar.xz=34d5a066b9f5bcef81b38badcc96f295150c2b2a96c35621235bdcc54ce92158
+dist/2025-09-27/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.gz=61a6a8feaf0490e3db169e86e85989538bff994fb76481a81a1ae02222c7ba59
+dist/2025-09-27/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.xz=cd94e20b4985964442b080454c2b628bcb435898e50bc2de55799cc51cd75f16
+dist/2025-09-27/rustfmt-nightly-x86_64-unknown-linux-musl.tar.gz=c2912263d24904ee5b1014a98d5b349754a6fa1bd66498f607cc62ebcf903cc3
+dist/2025-09-27/rustfmt-nightly-x86_64-unknown-linux-musl.tar.xz=8ad5b1284c91798a01fd25b3b690f88b55026e109471e759d4cecdefd1f83a39
+dist/2025-09-27/rustfmt-nightly-x86_64-unknown-netbsd.tar.gz=e0f52a6511c36c2ece175bc993861cffe0cc72a2e1b56b1def246e09f70d3a75
+dist/2025-09-27/rustfmt-nightly-x86_64-unknown-netbsd.tar.xz=229b92a2c0ef8ab1ac588858bb371ea0ed3449dec82a11ca7386df6efb2f65b7
+dist/2025-09-27/rustc-nightly-aarch64-apple-darwin.tar.gz=de7af74b8c91fb87b20df2d65b536fe6f49cc632b1f0c52a1e65a215fd5e4a06
+dist/2025-09-27/rustc-nightly-aarch64-apple-darwin.tar.xz=7a3e8c68f0bf4d393393628bd85d22242eee59605e3d56e0e94d06163ee2d4e9
+dist/2025-09-27/rustc-nightly-aarch64-pc-windows-gnullvm.tar.gz=2826132a82eb5adaabe2fdadc76ddc21460834365085ff2a113d934c11870a41
+dist/2025-09-27/rustc-nightly-aarch64-pc-windows-gnullvm.tar.xz=47980ea13cb887d85f8e501ca2b5d6e4b77ba8f229b2cfb9a1f28426c60d87a9
+dist/2025-09-27/rustc-nightly-aarch64-pc-windows-msvc.tar.gz=10dc98065c0b19d737ea93506df1ac399c33190edb3f6bbc51d6c1697e910f8a
+dist/2025-09-27/rustc-nightly-aarch64-pc-windows-msvc.tar.xz=d791bf9c54ccdb02da34e408aa93e0680f19a3bfbed1e5dbd61b57f1e1f38fdd
+dist/2025-09-27/rustc-nightly-aarch64-unknown-linux-gnu.tar.gz=ba6e33f6efa2f5a97790e29bb72c89bd460d758244dc9dfa4684e01bc75b6656
+dist/2025-09-27/rustc-nightly-aarch64-unknown-linux-gnu.tar.xz=4e38e862770ed0215720445e56fb027570e4f3c09d63a7f68cdacbff482b4cec
+dist/2025-09-27/rustc-nightly-aarch64-unknown-linux-musl.tar.gz=b126fbef234c0b67df42fb0568580b3d95ce98b7346095c3762214fcdece14a5
+dist/2025-09-27/rustc-nightly-aarch64-unknown-linux-musl.tar.xz=07af694d0ab0b55b18bd437ec9edb965f451f1bbb8334e1667f87d1d8e8354b2
+dist/2025-09-27/rustc-nightly-arm-unknown-linux-gnueabi.tar.gz=6901b57b0fe7182a45b1934e1d7a006ba353daf114ea7601563caade4de1b2c2
+dist/2025-09-27/rustc-nightly-arm-unknown-linux-gnueabi.tar.xz=c1af7bcb75c1ce5975e606aacb2d3decaf7a8470cd347d4caf75f11f84d3122f
+dist/2025-09-27/rustc-nightly-arm-unknown-linux-gnueabihf.tar.gz=8f29e493bd15175ed2a72d50857cbcc07992194c0b38d2b0a4660217b04b8276
+dist/2025-09-27/rustc-nightly-arm-unknown-linux-gnueabihf.tar.xz=fe478ade162b6b5d33808f4872de54e0b9dedd84e9e420480a370a2555d28cbc
+dist/2025-09-27/rustc-nightly-armv7-unknown-linux-gnueabihf.tar.gz=f03a3368f41969d061a9ec2e87af512c346f9e82b6286eea65dbce33de90391e
+dist/2025-09-27/rustc-nightly-armv7-unknown-linux-gnueabihf.tar.xz=c771ab34e5bab9344be3dab9315225296e41b3fa70cfe59fd3e0b287c4985fc2
+dist/2025-09-27/rustc-nightly-i686-pc-windows-gnu.tar.gz=9f5555633f1f1462285c0eb39aa42d0beb45cdb3b45c524483e4e4c6b76b6551
+dist/2025-09-27/rustc-nightly-i686-pc-windows-gnu.tar.xz=ae8c171fa20a49d7323bb5e6a36b262947caae260adb942204206aada00bcfaf
+dist/2025-09-27/rustc-nightly-i686-pc-windows-msvc.tar.gz=2b50b6d9027d5b480dcd2693a551bf80db7d3dae802bfd9a825b68a50ab022a6
+dist/2025-09-27/rustc-nightly-i686-pc-windows-msvc.tar.xz=d4b396eb0256cd62718751f3a52498dba992ba063ed77e5d675da8dc06a6751e
+dist/2025-09-27/rustc-nightly-i686-unknown-linux-gnu.tar.gz=f74acd9ecd35d10040e388d5224a9c88e66348dca09930d89068e87a0371a7d8
+dist/2025-09-27/rustc-nightly-i686-unknown-linux-gnu.tar.xz=92bb07e968cbbbfcf1bc7d0ecdd1a088b8c2975691bbf6ed846bc69708e34f13
+dist/2025-09-27/rustc-nightly-loongarch64-unknown-linux-gnu.tar.gz=7b756904c495de2d37993d71fe1e70e182c232aa408296c6ba05f71a94423406
+dist/2025-09-27/rustc-nightly-loongarch64-unknown-linux-gnu.tar.xz=522114675fb36949b953491d9a5fa0db39d22118f015f8ce92a120eab39244b0
+dist/2025-09-27/rustc-nightly-loongarch64-unknown-linux-musl.tar.gz=2309e49988ec8c35ef17f7293d6b2a787589eb38bba217a8f9429446713cc2a4
+dist/2025-09-27/rustc-nightly-loongarch64-unknown-linux-musl.tar.xz=820950e1cbfe6d973e1835532f9e201fe215d149bc415ac7ea011b16bf6b7bc8
+dist/2025-09-27/rustc-nightly-powerpc-unknown-linux-gnu.tar.gz=6fe053425d6b840c72352a88021c3b2b6deb389986575cb5e7b8c5991e86d039
+dist/2025-09-27/rustc-nightly-powerpc-unknown-linux-gnu.tar.xz=d62cad3e6a7dbab7cbefa493e78a0b7d7e8f724dcd766ae03b6715c325594fe5
+dist/2025-09-27/rustc-nightly-powerpc64-unknown-linux-gnu.tar.gz=8bc6b3d521f5117bd3f9321d9d086e928fecf548be58edc71b257269e68ad21c
+dist/2025-09-27/rustc-nightly-powerpc64-unknown-linux-gnu.tar.xz=d08a0ed4adb7fdf451d39c1dd56171d6ce345b10cf905515c07ac5eb66f7d030
+dist/2025-09-27/rustc-nightly-powerpc64le-unknown-linux-gnu.tar.gz=02ac6a9c23c1dfaf12e26b466bb33057787c28f2bfe8503b998a5d5aa55a4370
+dist/2025-09-27/rustc-nightly-powerpc64le-unknown-linux-gnu.tar.xz=77709b47a9d99657e03c77f32183b2127e75488df59cd000ed20cad5868afd5d
+dist/2025-09-27/rustc-nightly-powerpc64le-unknown-linux-musl.tar.gz=b811bfae5380ffe89e2f48f6c0e6f293e8db33461a1fda94a85759d3464100c4
+dist/2025-09-27/rustc-nightly-powerpc64le-unknown-linux-musl.tar.xz=bc41de8c0c65d912b5d6be06f3b12b3e4be1c20c1dc6ce1b7f5226e7d3ab3ae2
+dist/2025-09-27/rustc-nightly-riscv64gc-unknown-linux-gnu.tar.gz=110b42065218c2607b01edb83d41425176d7f065fac52c5836bed0d2215fc5b3
+dist/2025-09-27/rustc-nightly-riscv64gc-unknown-linux-gnu.tar.xz=97e3a41b0718ea14be4b7320aa4efc7f19b3feeabc7aa9079ce4ea487cad8064
+dist/2025-09-27/rustc-nightly-s390x-unknown-linux-gnu.tar.gz=4e1fd4ed9df5ae921380e3396159053c87623a9ee1c7bcc1f897674c9165714d
+dist/2025-09-27/rustc-nightly-s390x-unknown-linux-gnu.tar.xz=1e2833f165f7b255731fb1d26bd6026f5b6152ed91ac70d8dceb4f692ea9a66f
+dist/2025-09-27/rustc-nightly-sparcv9-sun-solaris.tar.gz=8113fa75d9ad92c411c71b6769f2af4450ed3ae285be1ebf10afe022abe52661
+dist/2025-09-27/rustc-nightly-sparcv9-sun-solaris.tar.xz=150128e8dde149bfbb2071cc933844ff87931cb856939db922eab98230ab7bb1
+dist/2025-09-27/rustc-nightly-x86_64-apple-darwin.tar.gz=727f7ae1f1e5fe51a3722105211cef3eb92f792cd054857ffef7bf858d0963cd
+dist/2025-09-27/rustc-nightly-x86_64-apple-darwin.tar.xz=295672b0d6afb6e80f25dfd6d1643414f976eab6da00a5babf377ecede580e56
+dist/2025-09-27/rustc-nightly-x86_64-pc-solaris.tar.gz=3505cebc0659388e110d1e55a5eca94ac945d75b3320f16ed9ded08629a91638
+dist/2025-09-27/rustc-nightly-x86_64-pc-solaris.tar.xz=515d5a5046dd2c4b3ac2b21a6dd4bc834eba20d08b902ed396e0b62101978210
+dist/2025-09-27/rustc-nightly-x86_64-pc-windows-gnu.tar.gz=838ce3f625b6dfb87f0271770515988d3b3f1535d75353b8f0f4a69074c1ceac
+dist/2025-09-27/rustc-nightly-x86_64-pc-windows-gnu.tar.xz=186eae6c01ecfc67facc96ac75d8518c31de1bf8897d82bc587941c3f686f4c3
+dist/2025-09-27/rustc-nightly-x86_64-pc-windows-gnullvm.tar.gz=76e5d092c78b663c2d75ee9d95f6c60d1ecb509b440312f4a8ad333d58de54b8
+dist/2025-09-27/rustc-nightly-x86_64-pc-windows-gnullvm.tar.xz=69ffcda8f985b3c5b78b18f0eea037890f2efc205f0b7cc4b788f1b35a3b7eb1
+dist/2025-09-27/rustc-nightly-x86_64-pc-windows-msvc.tar.gz=2b08c563daa21d817bdac9c8dd81021a80967e7e671a312c2990575e3622b928
+dist/2025-09-27/rustc-nightly-x86_64-pc-windows-msvc.tar.xz=2e54f6a6b6e096be1f717361d2e474b2ca94957ee006d5fa62910ff3d85cf05b
+dist/2025-09-27/rustc-nightly-x86_64-unknown-freebsd.tar.gz=6e00949c5d3a2f0ba86f1d89f54278f09e58f043cfd00d1f5df984835228d28d
+dist/2025-09-27/rustc-nightly-x86_64-unknown-freebsd.tar.xz=46d9945d5361b758448454c4778a42ce01b4cff7370b9988d5e7b2c7d889d24f
+dist/2025-09-27/rustc-nightly-x86_64-unknown-illumos.tar.gz=83f3d4d069729a72da4b96067400b812367e0a81284bfe3cd73b1939fb81db9c
+dist/2025-09-27/rustc-nightly-x86_64-unknown-illumos.tar.xz=110ca4f2630368f1c94084332d825964f3852bc9e70db8ec738de2cd4f450f2a
+dist/2025-09-27/rustc-nightly-x86_64-unknown-linux-gnu.tar.gz=e1ad313cbe777997222bbdd4b26a5b4c21da50b6378e434501c58219137dad77
+dist/2025-09-27/rustc-nightly-x86_64-unknown-linux-gnu.tar.xz=2ab176057835fabd55e6e2372b036c245be44c0705198557ef2a16d187ea9457
+dist/2025-09-27/rustc-nightly-x86_64-unknown-linux-musl.tar.gz=3e643ce549e9db3768c478b37f088afbf9b2f63dc0275bfdf7c2cbb48ac4fef8
+dist/2025-09-27/rustc-nightly-x86_64-unknown-linux-musl.tar.xz=597c47ff84de68f317b0672d5564a3121edd88cbf5dd3d27192d133ca4ac05a8
+dist/2025-09-27/rustc-nightly-x86_64-unknown-netbsd.tar.gz=5f948f48d64420119f1bd1a90952a04cec074ca45bda8d46f020163cb2809016
+dist/2025-09-27/rustc-nightly-x86_64-unknown-netbsd.tar.xz=977612fd1ed20d57b95e577dd9b3632209fb1f376f46c66467e2a2ccdd7d29f0
+dist/2025-09-27/rust-nightly-aarch64-pc-windows-msvc.msi=b39edbdc83f4329be0e194be1b7e002e764153628bb107bdc77e6f8c2331abe1
+dist/2025-09-27/rust-nightly-i686-pc-windows-gnu.msi=d023b88f94d2d25b4a29c03d4e1243484fd7a20d67753fd3e9a10e6f39069df8
+dist/2025-09-27/rust-nightly-i686-pc-windows-msvc.msi=8441a5f6e8650613b5b9c0c2778bc88bcf259fd4f3acd226a6ec52f1b4a960cb
+dist/2025-09-27/rust-nightly-x86_64-pc-windows-gnu.msi=15a83b7056623d30dc1d47560151ec79e2cb7db1d229069085e73b782347e8e7
+dist/2025-09-27/rust-nightly-x86_64-pc-windows-msvc.msi=607a9219272d8b41fd6bedf884515d3584471c75be19f9353c1c67826c115aea
+dist/2025-09-27/rust-nightly-aarch64-apple-darwin.pkg=55cc7129e581244dcbc567eb905183ff3e45edc8847fc58cb350394e6df55e96
+dist/2025-09-27/rust-nightly-x86_64-apple-darwin.pkg=a6add14a01bfd77634e67425db47cf63144dbc0b618beeaa4f37be2d7103146c
+dist/2025-09-27/rustc-nightly-src.tar.gz=419d5aea9252c3a9377fcfefe0a0e91b7be1354b9c33e36e346c547c4a9ec3eb
+dist/2025-09-27/rustc-nightly-src.tar.xz=fd454f13408f045e3ba1d4618699a3c6e42fcc66902c37972aa3729bb681d951

From 760ed37769c4902c97c874d324978472ce02f9ba Mon Sep 17 00:00:00 2001
From: Jeremy Soller <jackpot51@gmail.com>
Date: Sat, 27 Sep 2025 08:25:47 -0600
Subject: [PATCH 1488/1889] redox: switch to colon as path separator

---
 library/std/src/sys/pal/unix/os.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/std/src/sys/pal/unix/os.rs b/library/std/src/sys/pal/unix/os.rs
index f0b6068e06c0f..7c9f3b7992f77 100644
--- a/library/std/src/sys/pal/unix/os.rs
+++ b/library/std/src/sys/pal/unix/os.rs
@@ -16,7 +16,7 @@ use crate::{fmt, io, iter, mem, ptr, slice, str};
 
 const TMPBUF_SZ: usize = 128;
 
-const PATH_SEPARATOR: u8 = if cfg!(target_os = "redox") { b';' } else { b':' };
+const PATH_SEPARATOR: u8 = b':';
 
 unsafe extern "C" {
     #[cfg(not(any(target_os = "dragonfly", target_os = "vxworks", target_os = "rtems")))]

From 35e582f9828a515c94946eb03910d563d6d38427 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Sat, 27 Sep 2025 17:03:26 +0200
Subject: [PATCH 1489/1889] Library: Remove remaining private `#[repr]`
 workarounds

Co-authored-by: David Tolnay <dtolnay@gmail.com>
---
 library/core/src/ffi/mod.rs        | 2 +-
 library/core/src/ffi/va_list.rs    | 8 ++++----
 library/core/src/os/darwin/objc.rs | 4 ++--
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/library/core/src/ffi/mod.rs b/library/core/src/ffi/mod.rs
index 0bc98e2ea8645..1356ca217c9a2 100644
--- a/library/core/src/ffi/mod.rs
+++ b/library/core/src/ffi/mod.rs
@@ -56,7 +56,7 @@ pub use self::primitives::{c_ptrdiff_t, c_size_t, c_ssize_t};
 //     be UB.
 #[doc = include_str!("c_void.md")]
 #[lang = "c_void"]
-#[cfg_attr(not(doc), repr(u8))] // An implementation detail we don't want to show up in rustdoc
+#[repr(u8)]
 #[stable(feature = "core_c_void", since = "1.30.0")]
 pub enum c_void {
     #[unstable(
diff --git a/library/core/src/ffi/va_list.rs b/library/core/src/ffi/va_list.rs
index 0d4ccb5aeb28c..46ccf330d1c22 100644
--- a/library/core/src/ffi/va_list.rs
+++ b/library/core/src/ffi/va_list.rs
@@ -25,7 +25,7 @@ crate::cfg_select! {
         ///
         /// [AArch64 Procedure Call Standard]:
         /// http://infocenter.arm.com/help/topic/com.arm.doc.ihi0055b/IHI0055B_aapcs64.pdf
-        #[cfg_attr(not(doc), repr(C))] // work around https://github.com/rust-lang/rust/issues/66401
+        #[repr(C)]
         #[derive(Debug)]
         #[lang = "va_list"]
         pub struct VaListImpl<'f> {
@@ -39,7 +39,7 @@ crate::cfg_select! {
     }
     all(target_arch = "powerpc", not(target_os = "uefi"), not(windows)) => {
         /// PowerPC ABI implementation of a `va_list`.
-        #[cfg_attr(not(doc), repr(C))] // work around https://github.com/rust-lang/rust/issues/66401
+        #[repr(C)]
         #[derive(Debug)]
         #[lang = "va_list"]
         pub struct VaListImpl<'f> {
@@ -53,7 +53,7 @@ crate::cfg_select! {
     }
     target_arch = "s390x" => {
         /// s390x ABI implementation of a `va_list`.
-        #[cfg_attr(not(doc), repr(C))] // work around https://github.com/rust-lang/rust/issues/66401
+        #[repr(C)]
         #[derive(Debug)]
         #[lang = "va_list"]
         pub struct VaListImpl<'f> {
@@ -66,7 +66,7 @@ crate::cfg_select! {
     }
     all(target_arch = "x86_64", not(target_os = "uefi"), not(windows)) => {
         /// x86_64 ABI implementation of a `va_list`.
-        #[cfg_attr(not(doc), repr(C))] // work around https://github.com/rust-lang/rust/issues/66401
+        #[repr(C)]
         #[derive(Debug)]
         #[lang = "va_list"]
         pub struct VaListImpl<'f> {
diff --git a/library/core/src/os/darwin/objc.rs b/library/core/src/os/darwin/objc.rs
index 928cb54e82c79..df3aab867e83d 100644
--- a/library/core/src/os/darwin/objc.rs
+++ b/library/core/src/os/darwin/objc.rs
@@ -6,7 +6,7 @@
 use crate::fmt;
 
 /// Equivalent to Objective-C’s `struct objc_class` type.
-#[cfg_attr(not(doc), repr(u8))] // An implementation detail we don't want to show up in rustdoc
+#[repr(u8)]
 pub enum objc_class {
     #[unstable(
         feature = "objc_class_variant",
@@ -31,7 +31,7 @@ impl fmt::Debug for objc_class {
 }
 
 /// Equivalent to Objective-C’s `struct objc_selector` type.
-#[cfg_attr(not(doc), repr(u8))] // An implementation detail we don't want to show up in rustdoc
+#[repr(u8)]
 pub enum objc_selector {
     #[unstable(
         feature = "objc_selector_variant",

From 9878be7787a6239b9651eeaccb040778051038f6 Mon Sep 17 00:00:00 2001
From: Mads Marquart <mads@marquart.dk>
Date: Sat, 13 Sep 2025 17:20:34 +0200
Subject: [PATCH 1490/1889] Re-enable assertions on macOS

---
 src/ci/github-actions/jobs.yml | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/src/ci/github-actions/jobs.yml b/src/ci/github-actions/jobs.yml
index b3e3fe7d96aab..8303699ce8a68 100644
--- a/src/ci/github-actions/jobs.yml
+++ b/src/ci/github-actions/jobs.yml
@@ -431,9 +431,6 @@ auto:
       MACOSX_DEPLOYMENT_TARGET: 10.12
       MACOSX_STD_DEPLOYMENT_TARGET: 10.12
       SELECT_XCODE: /Applications/Xcode_15.2.app
-      NO_LLVM_ASSERTIONS: 1
-      NO_DEBUG_ASSERTIONS: 1
-      NO_OVERFLOW_CHECKS: 1
       DIST_REQUIRE_ALL_TOOLS: 1
       CODEGEN_BACKENDS: llvm,cranelift
     <<: *job-macos
@@ -449,9 +446,6 @@ auto:
       MACOSX_DEPLOYMENT_TARGET: 10.12
       MACOSX_STD_DEPLOYMENT_TARGET: 10.12
       SELECT_XCODE: /Applications/Xcode_15.2.app
-      NO_LLVM_ASSERTIONS: 1
-      NO_DEBUG_ASSERTIONS: 1
-      NO_OVERFLOW_CHECKS: 1
     <<: *job-macos
 
   - name: dist-aarch64-apple
@@ -471,9 +465,6 @@ auto:
       # supports the hardware.
       MACOSX_DEPLOYMENT_TARGET: 11.0
       MACOSX_STD_DEPLOYMENT_TARGET: 11.0
-      NO_LLVM_ASSERTIONS: 1
-      NO_DEBUG_ASSERTIONS: 1
-      NO_OVERFLOW_CHECKS: 1
       DIST_REQUIRE_ALL_TOOLS: 1
       CODEGEN_BACKENDS: llvm,cranelift
     <<: *job-macos
@@ -493,9 +484,6 @@ auto:
       # supports the hardware, so only need to test it there.
       MACOSX_DEPLOYMENT_TARGET: 11.0
       MACOSX_STD_DEPLOYMENT_TARGET: 11.0
-      NO_LLVM_ASSERTIONS: 1
-      NO_DEBUG_ASSERTIONS: 1
-      NO_OVERFLOW_CHECKS: 1
     <<: *job-macos
 
   ######################

From aef976ed4c73dab044002b39817509110ddf2cf2 Mon Sep 17 00:00:00 2001
From: Shunpoco <tkngsnsk313320@gmail.com>
Date: Sat, 27 Sep 2025 14:10:06 +0100
Subject: [PATCH 1491/1889] Add auto extra-checks in pre-push script

It enables automatic check changes of Python/C++/JS
before pushing the changes to remote repository.
Those checks happen only when the target type of file is changed.
Otherwise it does not install any dependencies (venv and/or node_modules).
Note that shellcheck and spellcheck are not included in this change, because:
1. Unlike venv/node_modules, shellcheck is not installed automatically by the command, and
2. spellcheck is built whenever pre-push script is run, it forces developer to wait extra time
So not to break the current productivity, this commit skips them.
---
 src/etc/pre-push.sh | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/etc/pre-push.sh b/src/etc/pre-push.sh
index 7bacc943f258b..33ed2f0e406b1 100755
--- a/src/etc/pre-push.sh
+++ b/src/etc/pre-push.sh
@@ -26,7 +26,10 @@ ROOT_DIR="$(git rev-parse --show-toplevel)"
 echo "Running pre-push script $ROOT_DIR/x test tidy"
 
 cd "$ROOT_DIR"
-./x test tidy --set build.locked-deps=true
+# The env var is necessary for printing diffs in py (fmt/lint) and cpp.
+TIDY_PRINT_DIFF=1 ./x test tidy \
+    --set build.locked-deps=true \
+    --extra-checks auto:py,auto:cpp,auto:js
 if [ $? -ne 0 ]; then
     echo "You may use \`git push --no-verify\` to skip this check."
     exit 1

From b3631e1174e222bf1dadf1549cfd0f717ebf6d64 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Tue, 16 Sep 2025 11:52:17 -0700
Subject: [PATCH 1492/1889] improve empty attribute diagnostic

---
 compiler/rustc_attr_parsing/messages.ftl       | 10 +++++++++-
 compiler/rustc_attr_parsing/src/context.rs     |  7 ++++++-
 compiler/rustc_attr_parsing/src/lints.rs       | 18 ++++++++++++------
 .../src/session_diagnostics.rs                 |  3 +++
 compiler/rustc_hir/src/lints.rs                | 15 ++++++++-------
 tests/ui/attributes/empty-repr.stderr          |  1 +
 tests/ui/empty/empty-attributes.stderr         |  4 ++++
 tests/ui/macros/macro-use-all-and-none.stderr  |  3 ++-
 tests/ui/repr/repr-empty-packed.stderr         |  1 +
 9 files changed, 46 insertions(+), 16 deletions(-)

diff --git a/compiler/rustc_attr_parsing/messages.ftl b/compiler/rustc_attr_parsing/messages.ftl
index 81ec17077c13c..6c5346e83554b 100644
--- a/compiler/rustc_attr_parsing/messages.ftl
+++ b/compiler/rustc_attr_parsing/messages.ftl
@@ -8,7 +8,15 @@ attr_parsing_deprecated_item_suggestion =
 
 attr_parsing_empty_attribute =
     unused attribute
-    .suggestion = remove this attribute
+    .suggestion = {$valid_without_list ->
+        [true] remove these parentheses
+        *[other] remove this attribute
+    }
+    .note = {$valid_without_list ->
+        [true] using `{$attr_path}` with an empty list is equivalent to not using a list at all
+        *[other] using `{$attr_path}` with an empty list has no effect
+    }
+
 
 attr_parsing_invalid_target = `#[{$name}]` attribute cannot be used on {$target}
     .help = `#[{$name}]` can {$only}be applied to {$applied}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index d7ccf3c78069c..e8bb4caa41664 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -597,7 +597,12 @@ impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
     }
 
     pub(crate) fn warn_empty_attribute(&mut self, span: Span) {
-        self.emit_lint(AttributeLintKind::EmptyAttribute { first_span: span }, span);
+        let attr_path = self.attr_path.clone();
+        let valid_without_list = self.template.word;
+        self.emit_lint(
+            AttributeLintKind::EmptyAttribute { first_span: span, attr_path, valid_without_list },
+            span,
+        );
     }
 }
 
diff --git a/compiler/rustc_attr_parsing/src/lints.rs b/compiler/rustc_attr_parsing/src/lints.rs
index ab8ba0daf1f10..3a2a370466961 100644
--- a/compiler/rustc_attr_parsing/src/lints.rs
+++ b/compiler/rustc_attr_parsing/src/lints.rs
@@ -43,12 +43,18 @@ pub fn emit_attribute_lint<L: LintEmitter>(lint: &AttributeLint<L::Id>, lint_emi
                     ),
                 },
             ),
-        AttributeLintKind::EmptyAttribute { first_span } => lint_emitter.emit_node_span_lint(
-            rustc_session::lint::builtin::UNUSED_ATTRIBUTES,
-            *id,
-            *first_span,
-            session_diagnostics::EmptyAttributeList { attr_span: *first_span },
-        ),
+        AttributeLintKind::EmptyAttribute { first_span, attr_path, valid_without_list } => {
+            lint_emitter.emit_node_span_lint(
+                rustc_session::lint::builtin::UNUSED_ATTRIBUTES,
+                *id,
+                *first_span,
+                session_diagnostics::EmptyAttributeList {
+                    attr_span: *first_span,
+                    attr_path: attr_path.clone(),
+                    valid_without_list: *valid_without_list,
+                },
+            )
+        }
         AttributeLintKind::InvalidTarget { name, target, applied, only } => lint_emitter
             .emit_node_span_lint(
                 // This check is here because `deprecated` had its own lint group and removing this would be a breaking change
diff --git a/compiler/rustc_attr_parsing/src/session_diagnostics.rs b/compiler/rustc_attr_parsing/src/session_diagnostics.rs
index 2c2b14c8a68bc..1194ac5872cb2 100644
--- a/compiler/rustc_attr_parsing/src/session_diagnostics.rs
+++ b/compiler/rustc_attr_parsing/src/session_diagnostics.rs
@@ -503,9 +503,12 @@ pub(crate) struct EmptyConfusables {
 
 #[derive(LintDiagnostic)]
 #[diag(attr_parsing_empty_attribute)]
+#[note]
 pub(crate) struct EmptyAttributeList {
     #[suggestion(code = "", applicability = "machine-applicable")]
     pub attr_span: Span,
+    pub attr_path: AttrPath,
+    pub valid_without_list: bool,
 }
 
 #[derive(LintDiagnostic)]
diff --git a/compiler/rustc_hir/src/lints.rs b/compiler/rustc_hir/src/lints.rs
index b7a0a6a0c197f..c9de6f6b5d526 100644
--- a/compiler/rustc_hir/src/lints.rs
+++ b/compiler/rustc_hir/src/lints.rs
@@ -31,6 +31,12 @@ pub struct AttributeLint<Id> {
 
 #[derive(Clone, Debug, HashStable_Generic)]
 pub enum AttributeLintKind {
+    /// Copy of `IllFormedAttributeInput`
+    /// specifically for the `invalid_macro_export_arguments` lint until that is removed,
+    /// see <https://github.com/rust-lang/rust/pull/143857#issuecomment-3079175663>
+    InvalidMacroExportArguments {
+        suggestions: Vec<String>,
+    },
     UnusedDuplicate {
         this: Span,
         other: Span,
@@ -41,13 +47,8 @@ pub enum AttributeLintKind {
     },
     EmptyAttribute {
         first_span: Span,
-    },
-
-    /// Copy of `IllFormedAttributeInput`
-    /// specifically for the `invalid_macro_export_arguments` lint until that is removed,
-    /// see <https://github.com/rust-lang/rust/pull/143857#issuecomment-3079175663>
-    InvalidMacroExportArguments {
-        suggestions: Vec<String>,
+        attr_path: AttrPath,
+        valid_without_list: bool,
     },
     InvalidTarget {
         name: AttrPath,
diff --git a/tests/ui/attributes/empty-repr.stderr b/tests/ui/attributes/empty-repr.stderr
index 92901fa170c25..6dfa2df75b737 100644
--- a/tests/ui/attributes/empty-repr.stderr
+++ b/tests/ui/attributes/empty-repr.stderr
@@ -4,6 +4,7 @@ error: unused attribute
 LL | #[repr()]
    | ^^^^^^^^^ help: remove this attribute
    |
+   = note: using `repr` with an empty list has no effect
 note: the lint level is defined here
   --> $DIR/empty-repr.rs:4:9
    |
diff --git a/tests/ui/empty/empty-attributes.stderr b/tests/ui/empty/empty-attributes.stderr
index f0be56ddc6aa4..41dc790737dd1 100644
--- a/tests/ui/empty/empty-attributes.stderr
+++ b/tests/ui/empty/empty-attributes.stderr
@@ -56,12 +56,16 @@ error: unused attribute
    |
 LL | #[repr()]
    | ^^^^^^^^^ help: remove this attribute
+   |
+   = note: using `repr` with an empty list has no effect
 
 error: unused attribute
   --> $DIR/empty-attributes.rs:12:1
    |
 LL | #[target_feature()]
    | ^^^^^^^^^^^^^^^^^^^ help: remove this attribute
+   |
+   = note: using `target_feature` with an empty list has no effect
 
 error: aborting due to 8 previous errors
 
diff --git a/tests/ui/macros/macro-use-all-and-none.stderr b/tests/ui/macros/macro-use-all-and-none.stderr
index a5efb065a21b1..b4c05adcb33d0 100644
--- a/tests/ui/macros/macro-use-all-and-none.stderr
+++ b/tests/ui/macros/macro-use-all-and-none.stderr
@@ -2,8 +2,9 @@ warning: unused attribute
   --> $DIR/macro-use-all-and-none.rs:7:12
    |
 LL | #[macro_use()]
-   |            ^^ help: remove this attribute
+   |            ^^ help: remove these parentheses
    |
+   = note: using `macro_use` with an empty list is equivalent to not using a list at all
 note: the lint level is defined here
   --> $DIR/macro-use-all-and-none.rs:4:9
    |
diff --git a/tests/ui/repr/repr-empty-packed.stderr b/tests/ui/repr/repr-empty-packed.stderr
index 6565b2e8c1dca..adf32c9552967 100644
--- a/tests/ui/repr/repr-empty-packed.stderr
+++ b/tests/ui/repr/repr-empty-packed.stderr
@@ -15,6 +15,7 @@ error: unused attribute
 LL | #[repr()]
    | ^^^^^^^^^ help: remove this attribute
    |
+   = note: using `repr` with an empty list has no effect
 note: the lint level is defined here
   --> $DIR/repr-empty-packed.rs:2:9
    |

From fa53de656ec9318d9462dcadcfd851685c3dcaf1 Mon Sep 17 00:00:00 2001
From: Martin Nordholts <martin.nordholts@codetale.se>
Date: Sat, 27 Sep 2025 19:40:48 +0200
Subject: [PATCH 1493/1889] tests: Remove ignore-android directive for fixed
 issue

---
 tests/ui/test-attrs/test-panic-abort-nocapture.rs         | 1 -
 tests/ui/test-attrs/test-panic-abort-nocapture.run.stderr | 4 ++--
 tests/ui/test-attrs/test-panic-abort.rs                   | 1 -
 tests/ui/test-attrs/test-panic-abort.run.stdout           | 2 +-
 4 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/tests/ui/test-attrs/test-panic-abort-nocapture.rs b/tests/ui/test-attrs/test-panic-abort-nocapture.rs
index 6a1025ea087c0..7c78d432fa087 100644
--- a/tests/ui/test-attrs/test-panic-abort-nocapture.rs
+++ b/tests/ui/test-attrs/test-panic-abort-nocapture.rs
@@ -6,7 +6,6 @@
 //@ exec-env:RUST_BACKTRACE=0
 //@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 
-//@ ignore-android #120567
 //@ needs-subprocess
 
 #![cfg(test)]
diff --git a/tests/ui/test-attrs/test-panic-abort-nocapture.run.stderr b/tests/ui/test-attrs/test-panic-abort-nocapture.run.stderr
index 8d7c62f8ec700..d8f65a78261f8 100644
--- a/tests/ui/test-attrs/test-panic-abort-nocapture.run.stderr
+++ b/tests/ui/test-attrs/test-panic-abort-nocapture.run.stderr
@@ -1,11 +1,11 @@
 
-thread 'main' ($TID) panicked at $DIR/test-panic-abort-nocapture.rs:32:5:
+thread 'main' ($TID) panicked at $DIR/test-panic-abort-nocapture.rs:31:5:
 assertion `left == right` failed
   left: 2
  right: 4
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 
-thread 'main' ($TID) panicked at $DIR/test-panic-abort-nocapture.rs:26:5:
+thread 'main' ($TID) panicked at $DIR/test-panic-abort-nocapture.rs:25:5:
 assertion `left == right` failed
   left: 2
  right: 4
diff --git a/tests/ui/test-attrs/test-panic-abort.rs b/tests/ui/test-attrs/test-panic-abort.rs
index 6c9b641fb6fba..13a30223399e5 100644
--- a/tests/ui/test-attrs/test-panic-abort.rs
+++ b/tests/ui/test-attrs/test-panic-abort.rs
@@ -6,7 +6,6 @@
 //@ exec-env:RUST_BACKTRACE=0
 //@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 
-//@ ignore-android #120567
 //@ needs-subprocess
 
 #![cfg(test)]
diff --git a/tests/ui/test-attrs/test-panic-abort.run.stdout b/tests/ui/test-attrs/test-panic-abort.run.stdout
index 4d65c05b94402..ca247f7da4180 100644
--- a/tests/ui/test-attrs/test-panic-abort.run.stdout
+++ b/tests/ui/test-attrs/test-panic-abort.run.stdout
@@ -18,7 +18,7 @@ testing123
 ---- it_fails stderr ----
 testing321
 
-thread 'main' ($TID) panicked at $DIR/test-panic-abort.rs:37:5:
+thread 'main' ($TID) panicked at $DIR/test-panic-abort.rs:36:5:
 assertion `left == right` failed
   left: 2
  right: 5

From 19d0e728496afa1ba6a5f9817201b7d57337c14c Mon Sep 17 00:00:00 2001
From: David Carlier <devnexen@gmail.com>
Date: Sat, 27 Sep 2025 20:38:45 +0100
Subject: [PATCH 1494/1889] fix build for android

---
 library/std/src/os/net/linux_ext/tcp.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/library/std/src/os/net/linux_ext/tcp.rs b/library/std/src/os/net/linux_ext/tcp.rs
index dbefc91a979a5..3f9b2bd3f4b43 100644
--- a/library/std/src/os/net/linux_ext/tcp.rs
+++ b/library/std/src/os/net/linux_ext/tcp.rs
@@ -4,6 +4,7 @@
 
 use crate::sealed::Sealed;
 use crate::sys_common::AsInner;
+#[cfg(target_os = "linux")]
 use crate::time::Duration;
 use crate::{io, net};
 

From 4d32b9a1783343d42a9864fe3d2115daa2cb425e Mon Sep 17 00:00:00 2001
From: Jules Bertholet <julesbertholet@quoi.xyz>
Date: Sat, 27 Sep 2025 15:47:06 -0400
Subject: [PATCH 1495/1889] Hoist non-platform-specific code out of
 `thread_local_inner!`

---
 library/std/src/sys/thread_local/native/mod.rs   | 4 ----
 library/std/src/sys/thread_local/no_threads.rs   | 5 -----
 library/std/src/sys/thread_local/os.rs           | 5 -----
 library/std/src/thread/local.rs                  | 8 ++++++--
 tests/ui/macros/macro-local-data-key-priv.stderr | 2 +-
 tests/ui/thread-local/no-unstable.stderr         | 6 +++---
 6 files changed, 10 insertions(+), 20 deletions(-)

diff --git a/library/std/src/sys/thread_local/native/mod.rs b/library/std/src/sys/thread_local/native/mod.rs
index 9544721b923b8..5dc142408047e 100644
--- a/library/std/src/sys/thread_local/native/mod.rs
+++ b/library/std/src/sys/thread_local/native/mod.rs
@@ -108,10 +108,6 @@ pub macro thread_local_inner {
             })
         }
     }},
-    ($(#[$attr:meta])* $vis:vis $name:ident, $t:ty, $(#[$align_attr:meta])*, $($init:tt)*) => {
-        $(#[$attr])* $vis const $name: $crate::thread::LocalKey<$t> =
-            $crate::thread::local_impl::thread_local_inner!(@key $t, $(#[$align_attr])*, $($init)*);
-    },
 }
 
 #[rustc_macro_transparency = "semitransparent"]
diff --git a/library/std/src/sys/thread_local/no_threads.rs b/library/std/src/sys/thread_local/no_threads.rs
index 4d6a4464cfa8c..409dfb19518d9 100644
--- a/library/std/src/sys/thread_local/no_threads.rs
+++ b/library/std/src/sys/thread_local/no_threads.rs
@@ -39,11 +39,6 @@ pub macro thread_local_inner {
             })
         }
     }},
-
-    ($(#[$attr:meta])* $vis:vis $name:ident, $t:ty, $(#[$align_attr:meta])*, $($init:tt)*) => {
-        $(#[$attr])* $vis const $name: $crate::thread::LocalKey<$t> =
-            $crate::thread::local_impl::thread_local_inner!(@key $t, $(#[$align_attr])*, $($init)*);
-    },
 }
 
 #[allow(missing_debug_implementations)]
diff --git a/library/std/src/sys/thread_local/os.rs b/library/std/src/sys/thread_local/os.rs
index 77746b203a321..b488f12fe841f 100644
--- a/library/std/src/sys/thread_local/os.rs
+++ b/library/std/src/sys/thread_local/os.rs
@@ -85,11 +85,6 @@ pub macro thread_local_inner {
 
         $($crate::thread::local_impl::thread_local_inner!(@align $final_align, $($attr_rest)+);)?
     },
-
-    ($(#[$attr:meta])* $vis:vis $name:ident, $t:ty, $(#[$($align_attr:tt)*])*, $($init:tt)*) => {
-        $(#[$attr])* $vis const $name: $crate::thread::LocalKey<$t> =
-            $crate::thread::local_impl::thread_local_inner!(@key $t, $(#[$($align_attr)*])*, $($init)*);
-    },
 }
 
 /// Use a regular global static to store this key; the state provided will then be
diff --git a/library/std/src/thread/local.rs b/library/std/src/thread/local.rs
index 70df7e724cafc..4259a4d1f3b7c 100644
--- a/library/std/src/thread/local.rs
+++ b/library/std/src/thread/local.rs
@@ -327,13 +327,17 @@ pub macro thread_local_process_attrs {
 
     // process `const` declaration and recurse
     ([$($align_attrs:tt)*] [$($other_attrs:tt)*]; $vis:vis static $name:ident: $t:ty = const $init:block $(; $($($rest:tt)+)?)?) => (
-        $crate::thread::local_impl::thread_local_inner!($($other_attrs)* $vis $name, $t, $($align_attrs)*, const $init);
+        $($other_attrs)* $vis const $name: $crate::thread::LocalKey<$t> =
+            $crate::thread::local_impl::thread_local_inner!(@key $t, $($align_attrs)*, const $init);
+
         $($($crate::thread::local_impl::thread_local_process_attrs!([] []; $($rest)+);)?)?
     ),
 
     // process non-`const` declaration and recurse
     ([$($align_attrs:tt)*] [$($other_attrs:tt)*]; $vis:vis static $name:ident: $t:ty = $init:expr $(; $($($rest:tt)+)?)?) => (
-        $crate::thread::local_impl::thread_local_inner!($($other_attrs)* $vis $name, $t, $($align_attrs)*, $init);
+        $($other_attrs)* $vis const $name: $crate::thread::LocalKey<$t> =
+            $crate::thread::local_impl::thread_local_inner!(@key $t, $($align_attrs)*, $init);
+
         $($($crate::thread::local_impl::thread_local_process_attrs!([] []; $($rest)+);)?)?
     ),
 }
diff --git a/tests/ui/macros/macro-local-data-key-priv.stderr b/tests/ui/macros/macro-local-data-key-priv.stderr
index e93bd11046d09..8df1aec140d0e 100644
--- a/tests/ui/macros/macro-local-data-key-priv.stderr
+++ b/tests/ui/macros/macro-local-data-key-priv.stderr
@@ -9,7 +9,7 @@ note: the constant `baz` is defined here
    |
 LL |     thread_local!(static baz: f64 = 0.0);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = note: this error originates in the macro `$crate::thread::local_impl::thread_local_inner` which comes from the expansion of the macro `thread_local` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `$crate::thread::local_impl::thread_local_process_attrs` which comes from the expansion of the macro `thread_local` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/thread-local/no-unstable.stderr b/tests/ui/thread-local/no-unstable.stderr
index fc2541894e743..fbcd804d91785 100644
--- a/tests/ui/thread-local/no-unstable.stderr
+++ b/tests/ui/thread-local/no-unstable.stderr
@@ -10,7 +10,7 @@ LL | | }
    = help: add `#![feature(rustc_attrs)]` to the crate attributes to enable
    = note: the `#[rustc_dummy]` attribute is an internal implementation detail that will never be stable
    = note: the `#[rustc_dummy]` attribute is used for rustc unit tests
-   = note: this error originates in the macro `$crate::thread::local_impl::thread_local_inner` which comes from the expansion of the macro `thread_local` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `$crate::thread::local_impl::thread_local_process_attrs` which comes from the expansion of the macro `thread_local` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0658]: use of an internal attribute
   --> $DIR/no-unstable.rs:1:1
@@ -38,7 +38,7 @@ LL | | }
    = note: see issue #93798 <https://github.com/rust-lang/rust/issues/93798> for more information
    = help: add `#![feature(used_with_arg)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-   = note: this error originates in the macro `$crate::thread::local_impl::thread_local_inner` which comes from the expansion of the macro `thread_local` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `$crate::thread::local_impl::thread_local_process_attrs` which comes from the expansion of the macro `thread_local` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: `#[used]` attribute cannot be used on constants
   --> $DIR/no-unstable.rs:1:1
@@ -50,7 +50,7 @@ LL | | }
    | |_^
    |
    = help: `#[used]` can only be applied to statics
-   = note: this error originates in the macro `$crate::thread::local_impl::thread_local_inner` which comes from the expansion of the macro `thread_local` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `$crate::thread::local_impl::thread_local_process_attrs` which comes from the expansion of the macro `thread_local` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 4 previous errors
 

From 4d411775139e1bc39c2752d78e40f2bcecb5304b Mon Sep 17 00:00:00 2001
From: Boxy Uwu <rust@boxyuwu.dev>
Date: Sat, 27 Sep 2025 22:58:02 +0100
Subject: [PATCH 1496/1889] Rename various "concrete opaque type" terminology
 to say "hidden type"

---
 compiler/rustc_borrowck/src/lib.rs            |  7 +-
 .../rustc_borrowck/src/region_infer/mod.rs    |  4 +-
 .../src/region_infer/opaque_types/mod.rs      | 79 +++++++------------
 compiler/rustc_borrowck/src/root_cx.rs        | 22 +++---
 .../rustc_hir_analysis/src/check/check.rs     |  4 +-
 .../src/collect/type_of/opaque.rs             | 12 +--
 compiler/rustc_hir_typeck/src/opaque_types.rs | 19 +++--
 compiler/rustc_hir_typeck/src/writeback.rs    | 28 +++----
 compiler/rustc_middle/src/arena.rs            |  2 +-
 compiler/rustc_middle/src/mir/query.rs        |  7 +-
 compiler/rustc_middle/src/query/mod.rs        |  2 +-
 .../rustc_middle/src/ty/typeck_results.rs     |  4 +-
 compiler/rustc_pattern_analysis/src/rustc.rs  |  4 +-
 .../src/traits/select/mod.rs                  |  2 +-
 compiler/rustc_type_ir/src/infer_ctxt.rs      |  2 +-
 15 files changed, 82 insertions(+), 116 deletions(-)

diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs
index 4c380ddcf7084..d799eb1f8c6ef 100644
--- a/compiler/rustc_borrowck/src/lib.rs
+++ b/compiler/rustc_borrowck/src/lib.rs
@@ -116,10 +116,7 @@ pub fn provide(providers: &mut Providers) {
 /// Provider for `query mir_borrowck`. Similar to `typeck`, this must
 /// only be called for typeck roots which will then borrowck all
 /// nested bodies as well.
-fn mir_borrowck(
-    tcx: TyCtxt<'_>,
-    def: LocalDefId,
-) -> Result<&ConcreteOpaqueTypes<'_>, ErrorGuaranteed> {
+fn mir_borrowck(tcx: TyCtxt<'_>, def: LocalDefId) -> Result<&HiddenTypes<'_>, ErrorGuaranteed> {
     assert!(!tcx.is_typeck_child(def.to_def_id()));
     let (input_body, _) = tcx.mir_promoted(def);
     debug!("run query mir_borrowck: {}", tcx.def_path_str(def));
@@ -130,7 +127,7 @@ fn mir_borrowck(
         Err(guar)
     } else if input_body.should_skip() {
         debug!("Skipping borrowck because of injected body");
-        let opaque_types = ConcreteOpaqueTypes(Default::default());
+        let opaque_types = HiddenTypes(Default::default());
         Ok(tcx.arena.alloc(opaque_types))
     } else {
         let mut root_cx = BorrowCheckRootCtxt::new(tcx, def, None);
diff --git a/compiler/rustc_borrowck/src/region_infer/mod.rs b/compiler/rustc_borrowck/src/region_infer/mod.rs
index 0910e8ef4b37b..e98c60e633805 100644
--- a/compiler/rustc_borrowck/src/region_infer/mod.rs
+++ b/compiler/rustc_borrowck/src/region_infer/mod.rs
@@ -1382,10 +1382,10 @@ impl<'tcx> RegionInferenceContext<'tcx> {
     }
 
     /// The constraints we get from equating the hidden type of each use of an opaque
-    /// with its final concrete type may end up getting preferred over other, potentially
+    /// with its final hidden type may end up getting preferred over other, potentially
     /// longer constraint paths.
     ///
-    /// Given that we compute the final concrete type by relying on this existing constraint
+    /// Given that we compute the final hidden type by relying on this existing constraint
     /// path, this can easily end up hiding the actual reason for why we require these regions
     /// to be equal.
     ///
diff --git a/compiler/rustc_borrowck/src/region_infer/opaque_types/mod.rs b/compiler/rustc_borrowck/src/region_infer/opaque_types/mod.rs
index 0af636aa734ca..6aa3345d4d423 100644
--- a/compiler/rustc_borrowck/src/region_infer/opaque_types/mod.rs
+++ b/compiler/rustc_borrowck/src/region_infer/opaque_types/mod.rs
@@ -8,7 +8,7 @@ use rustc_infer::infer::outlives::env::RegionBoundPairs;
 use rustc_infer::infer::{InferCtxt, NllRegionVariableOrigin, OpaqueTypeStorageEntries};
 use rustc_infer::traits::ObligationCause;
 use rustc_macros::extension;
-use rustc_middle::mir::{Body, ConcreteOpaqueTypes, ConstraintCategory};
+use rustc_middle::mir::{Body, ConstraintCategory, HiddenTypes};
 use rustc_middle::ty::{
     self, DefiningScopeKind, EarlyBinder, FallibleTypeFolder, GenericArg, GenericArgsRef,
     OpaqueHiddenType, OpaqueTypeKey, Region, RegionVid, Ty, TyCtxt, TypeFoldable,
@@ -129,9 +129,9 @@ fn nll_var_to_universal_region<'tcx>(
 /// Collect all defining uses of opaque types inside of this typeck root. This
 /// expects the hidden type to be mapped to the definition parameters of the opaque
 /// and errors if we end up with distinct hidden types.
-fn add_concrete_opaque_type<'tcx>(
+fn add_hidden_type<'tcx>(
     tcx: TyCtxt<'tcx>,
-    concrete_opaque_types: &mut ConcreteOpaqueTypes<'tcx>,
+    hidden_types: &mut HiddenTypes<'tcx>,
     def_id: LocalDefId,
     hidden_ty: OpaqueHiddenType<'tcx>,
 ) {
@@ -139,7 +139,7 @@ fn add_concrete_opaque_type<'tcx>(
     // back to the opaque type definition. E.g. we may have `OpaqueType<X, Y>` mapped to
     // `(X, Y)` and `OpaqueType<Y, X>` mapped to `(Y, X)`, and those are the same, but we
     // only know that once we convert the generic parameters to those of the opaque type.
-    if let Some(prev) = concrete_opaque_types.0.get_mut(&def_id) {
+    if let Some(prev) = hidden_types.0.get_mut(&def_id) {
         if prev.ty != hidden_ty.ty {
             let guar = hidden_ty.ty.error_reported().err().unwrap_or_else(|| {
                 let (Ok(e) | Err(e)) = prev.build_mismatch_error(&hidden_ty, tcx).map(|d| d.emit());
@@ -151,15 +151,15 @@ fn add_concrete_opaque_type<'tcx>(
         // FIXME(oli-obk): collect multiple spans for better diagnostics down the road.
         prev.span = prev.span.substitute_dummy(hidden_ty.span);
     } else {
-        concrete_opaque_types.0.insert(def_id, hidden_ty);
+        hidden_types.0.insert(def_id, hidden_ty);
     }
 }
 
-fn get_concrete_opaque_type<'tcx>(
-    concrete_opaque_types: &ConcreteOpaqueTypes<'tcx>,
+fn get_hidden_type<'tcx>(
+    hidden_types: &HiddenTypes<'tcx>,
     def_id: LocalDefId,
 ) -> Option<EarlyBinder<'tcx, OpaqueHiddenType<'tcx>>> {
-    concrete_opaque_types.0.get(&def_id).map(|ty| EarlyBinder::bind(*ty))
+    hidden_types.0.get(&def_id).map(|ty| EarlyBinder::bind(*ty))
 }
 
 #[derive(Debug)]
@@ -173,22 +173,22 @@ struct DefiningUse<'tcx> {
 }
 
 /// This computes the actual hidden types of the opaque types and maps them to their
-/// definition sites. Outside of registering the computed concrete types this function
+/// definition sites. Outside of registering the computed hidden types this function
 /// does not mutate the current borrowck state.
 ///
 /// While it may fail to infer the hidden type and return errors, we always apply
-/// the computed concrete hidden type to all opaque type uses to check whether they
+/// the computed hidden type to all opaque type uses to check whether they
 /// are correct. This is necessary to support non-defining uses of opaques in their
 /// defining scope.
 ///
 /// It also means that this whole function is not really soundness critical as we
 /// recheck all uses of the opaques regardless.
-pub(crate) fn compute_concrete_opaque_types<'tcx>(
+pub(crate) fn compute_hidden_types<'tcx>(
     infcx: &BorrowckInferCtxt<'tcx>,
     universal_region_relations: &Frozen<UniversalRegionRelations<'tcx>>,
     constraints: &MirTypeckRegionConstraints<'tcx>,
     location_map: Rc<DenseLocationMap>,
-    concrete_opaque_types: &mut ConcreteOpaqueTypes<'tcx>,
+    hidden_types: &mut HiddenTypes<'tcx>,
     opaque_types: &[(OpaqueTypeKey<'tcx>, OpaqueHiddenType<'tcx>)],
 ) -> Vec<DeferredOpaqueTypeError<'tcx>> {
     let mut errors = Vec::new();
@@ -201,8 +201,7 @@ pub(crate) fn compute_concrete_opaque_types<'tcx>(
     // We start by checking each use of an opaque type during type check and
     // check whether the generic arguments of the opaque type are fully
     // universal, if so, it's a defining use.
-    let defining_uses =
-        collect_defining_uses(&mut rcx, concrete_opaque_types, opaque_types, &mut errors);
+    let defining_uses = collect_defining_uses(&mut rcx, hidden_types, opaque_types, &mut errors);
 
     // We now compute and apply member constraints for all regions in the hidden
     // types of each defining use. This mutates the region values of the `rcx` which
@@ -210,21 +209,16 @@ pub(crate) fn compute_concrete_opaque_types<'tcx>(
     apply_member_constraints(&mut rcx, &defining_uses);
 
     // After applying member constraints, we now check whether all member regions ended
-    // up equal to one of their choice regions and compute the actual concrete type of
+    // up equal to one of their choice regions and compute the actual hidden type of
     // the opaque type definition. This is stored in the `root_cx`.
-    compute_concrete_types_from_defining_uses(
-        &rcx,
-        concrete_opaque_types,
-        &defining_uses,
-        &mut errors,
-    );
+    compute_hidden_types_from_defining_uses(&rcx, hidden_types, &defining_uses, &mut errors);
     errors
 }
 
 #[instrument(level = "debug", skip_all, ret)]
 fn collect_defining_uses<'tcx>(
     rcx: &mut RegionCtxt<'_, 'tcx>,
-    concrete_opaque_types: &mut ConcreteOpaqueTypes<'tcx>,
+    hidden_types: &mut HiddenTypes<'tcx>,
     opaque_types: &[(OpaqueTypeKey<'tcx>, OpaqueHiddenType<'tcx>)],
     errors: &mut Vec<DeferredOpaqueTypeError<'tcx>>,
 ) -> Vec<DefiningUse<'tcx>> {
@@ -244,9 +238,9 @@ fn collect_defining_uses<'tcx>(
             // with `TypingMode::Borrowck`.
             if infcx.tcx.use_typing_mode_borrowck() {
                 match err {
-                    NonDefiningUseReason::Tainted(guar) => add_concrete_opaque_type(
+                    NonDefiningUseReason::Tainted(guar) => add_hidden_type(
                         infcx.tcx,
-                        concrete_opaque_types,
+                        hidden_types,
                         opaque_type_key.def_id,
                         OpaqueHiddenType::new_error(infcx.tcx, guar),
                     ),
@@ -277,9 +271,9 @@ fn collect_defining_uses<'tcx>(
     defining_uses
 }
 
-fn compute_concrete_types_from_defining_uses<'tcx>(
+fn compute_hidden_types_from_defining_uses<'tcx>(
     rcx: &RegionCtxt<'_, 'tcx>,
-    concrete_opaque_types: &mut ConcreteOpaqueTypes<'tcx>,
+    hidden_types: &mut HiddenTypes<'tcx>,
     defining_uses: &[DefiningUse<'tcx>],
     errors: &mut Vec<DeferredOpaqueTypeError<'tcx>>,
 ) {
@@ -358,9 +352,9 @@ fn compute_concrete_types_from_defining_uses<'tcx>(
                 },
             ));
         }
-        add_concrete_opaque_type(
+        add_hidden_type(
             tcx,
-            concrete_opaque_types,
+            hidden_types,
             opaque_type_key.def_id,
             OpaqueHiddenType { span: hidden_type.span, ty },
         );
@@ -489,20 +483,20 @@ impl<'tcx> FallibleTypeFolder<TyCtxt<'tcx>> for ToArgRegionsFolder<'_, 'tcx> {
 ///
 /// It does this by equating the hidden type of each use with the instantiated final
 /// hidden type of the opaque.
-pub(crate) fn apply_computed_concrete_opaque_types<'tcx>(
+pub(crate) fn apply_hidden_types<'tcx>(
     infcx: &BorrowckInferCtxt<'tcx>,
     body: &Body<'tcx>,
     universal_regions: &UniversalRegions<'tcx>,
     region_bound_pairs: &RegionBoundPairs<'tcx>,
     known_type_outlives_obligations: &[ty::PolyTypeOutlivesPredicate<'tcx>],
     constraints: &mut MirTypeckRegionConstraints<'tcx>,
-    concrete_opaque_types: &mut ConcreteOpaqueTypes<'tcx>,
+    hidden_types: &mut HiddenTypes<'tcx>,
     opaque_types: &[(OpaqueTypeKey<'tcx>, OpaqueHiddenType<'tcx>)],
 ) -> Vec<DeferredOpaqueTypeError<'tcx>> {
     let tcx = infcx.tcx;
     let mut errors = Vec::new();
     for &(key, hidden_type) in opaque_types {
-        let Some(expected) = get_concrete_opaque_type(concrete_opaque_types, key.def_id) else {
+        let Some(expected) = get_hidden_type(hidden_types, key.def_id) else {
             if !tcx.use_typing_mode_borrowck() {
                 if let ty::Alias(ty::Opaque, alias_ty) = hidden_type.ty.kind()
                     && alias_ty.def_id == key.def_id.to_def_id()
@@ -521,12 +515,7 @@ pub(crate) fn apply_computed_concrete_opaque_types<'tcx>(
                 hidden_type.span,
                 "non-defining use in the defining scope with no defining uses",
             );
-            add_concrete_opaque_type(
-                tcx,
-                concrete_opaque_types,
-                key.def_id,
-                OpaqueHiddenType::new_error(tcx, guar),
-            );
+            add_hidden_type(tcx, hidden_types, key.def_id, OpaqueHiddenType::new_error(tcx, guar));
             continue;
         };
 
@@ -566,18 +555,13 @@ pub(crate) fn apply_computed_concrete_opaque_types<'tcx>(
                 "equating opaque types",
             ),
         ) {
-            add_concrete_opaque_type(
-                tcx,
-                concrete_opaque_types,
-                key.def_id,
-                OpaqueHiddenType::new_error(tcx, guar),
-            );
+            add_hidden_type(tcx, hidden_types, key.def_id, OpaqueHiddenType::new_error(tcx, guar));
         }
     }
     errors
 }
 
-/// In theory `apply_concrete_opaque_types` could introduce new uses of opaque types.
+/// In theory `apply_hidden_types` could introduce new uses of opaque types.
 /// We do not check these new uses so this could be unsound.
 ///
 /// We detect any new uses and simply delay a bug if they occur. If this results in
@@ -682,13 +666,6 @@ impl<'tcx> InferCtxt<'tcx> {
     ///
     /// (*) C1 and C2 were introduced in the comments on
     /// `register_member_constraints`. Read that comment for more context.
-    ///
-    /// # Parameters
-    ///
-    /// - `def_id`, the `impl Trait` type
-    /// - `args`, the args used to instantiate this opaque type
-    /// - `instantiated_ty`, the inferred type C1 -- fully resolved, lifted version of
-    ///   `opaque_defn.concrete_ty`
     #[instrument(level = "debug", skip(self))]
     fn infer_opaque_definition_from_instantiation(
         &self,
diff --git a/compiler/rustc_borrowck/src/root_cx.rs b/compiler/rustc_borrowck/src/root_cx.rs
index cd4e9683f2d87..d9599bbdd4611 100644
--- a/compiler/rustc_borrowck/src/root_cx.rs
+++ b/compiler/rustc_borrowck/src/root_cx.rs
@@ -12,12 +12,12 @@ use smallvec::SmallVec;
 use crate::consumers::BorrowckConsumer;
 use crate::nll::compute_closure_requirements_modulo_opaques;
 use crate::region_infer::opaque_types::{
-    apply_computed_concrete_opaque_types, clone_and_resolve_opaque_types,
-    compute_concrete_opaque_types, detect_opaque_types_added_while_handling_opaque_types,
+    apply_hidden_types, clone_and_resolve_opaque_types, compute_hidden_types,
+    detect_opaque_types_added_while_handling_opaque_types,
 };
 use crate::type_check::{Locations, constraint_conversion};
 use crate::{
-    ClosureRegionRequirements, CollectRegionConstraintsResult, ConcreteOpaqueTypes,
+    ClosureRegionRequirements, CollectRegionConstraintsResult, HiddenTypes,
     PropagatedBorrowCheckResults, borrowck_check_region_constraints,
     borrowck_collect_region_constraints,
 };
@@ -27,7 +27,7 @@ use crate::{
 pub(super) struct BorrowCheckRootCtxt<'tcx> {
     pub tcx: TyCtxt<'tcx>,
     root_def_id: LocalDefId,
-    concrete_opaque_types: ConcreteOpaqueTypes<'tcx>,
+    hidden_types: HiddenTypes<'tcx>,
     /// The region constraints computed by [borrowck_collect_region_constraints]. This uses
     /// an [FxIndexMap] to guarantee that iterating over it visits nested bodies before
     /// their parents.
@@ -49,7 +49,7 @@ impl<'tcx> BorrowCheckRootCtxt<'tcx> {
         BorrowCheckRootCtxt {
             tcx,
             root_def_id,
-            concrete_opaque_types: Default::default(),
+            hidden_types: Default::default(),
             collect_region_constraints_results: Default::default(),
             propagated_borrowck_results: Default::default(),
             tainted_by_errors: None,
@@ -72,11 +72,11 @@ impl<'tcx> BorrowCheckRootCtxt<'tcx> {
         &self.propagated_borrowck_results[&nested_body_def_id].used_mut_upvars
     }
 
-    pub(super) fn finalize(self) -> Result<&'tcx ConcreteOpaqueTypes<'tcx>, ErrorGuaranteed> {
+    pub(super) fn finalize(self) -> Result<&'tcx HiddenTypes<'tcx>, ErrorGuaranteed> {
         if let Some(guar) = self.tainted_by_errors {
             Err(guar)
         } else {
-            Ok(self.tcx.arena.alloc(self.concrete_opaque_types))
+            Ok(self.tcx.arena.alloc(self.hidden_types))
         }
     }
 
@@ -88,12 +88,12 @@ impl<'tcx> BorrowCheckRootCtxt<'tcx> {
                 &input.universal_region_relations,
                 &mut input.constraints,
             );
-            input.deferred_opaque_type_errors = compute_concrete_opaque_types(
+            input.deferred_opaque_type_errors = compute_hidden_types(
                 &input.infcx,
                 &input.universal_region_relations,
                 &input.constraints,
                 Rc::clone(&input.location_map),
-                &mut self.concrete_opaque_types,
+                &mut self.hidden_types,
                 &opaque_types,
             );
             per_body_info.push((num_entries, opaque_types));
@@ -103,14 +103,14 @@ impl<'tcx> BorrowCheckRootCtxt<'tcx> {
             self.collect_region_constraints_results.values_mut().zip(per_body_info)
         {
             if input.deferred_opaque_type_errors.is_empty() {
-                input.deferred_opaque_type_errors = apply_computed_concrete_opaque_types(
+                input.deferred_opaque_type_errors = apply_hidden_types(
                     &input.infcx,
                     &input.body_owned,
                     &input.universal_region_relations.universal_regions,
                     &input.region_bound_pairs,
                     &input.known_type_outlives_obligations,
                     &mut input.constraints,
-                    &mut self.concrete_opaque_types,
+                    &mut self.hidden_types,
                     &opaque_types,
                 );
             }
diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
index 886ebddc75c97..e1e6860e43004 100644
--- a/compiler/rustc_hir_analysis/src/check/check.rs
+++ b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -219,7 +219,7 @@ fn check_opaque(tcx: TyCtxt<'_>, def_id: LocalDefId) {
 
     // HACK(jynelson): trying to infer the type of `impl trait` breaks documenting
     // `async-std` (and `pub async fn` in general).
-    // Since rustdoc doesn't care about the concrete type behind `impl Trait`, just don't look at it!
+    // Since rustdoc doesn't care about the hidden type behind `impl Trait`, just don't look at it!
     // See https://github.com/rust-lang/rust/issues/75100
     if tcx.sess.opts.actually_rustdoc {
         return;
@@ -252,7 +252,7 @@ pub(super) fn check_opaque_for_cycles<'tcx>(
     Ok(())
 }
 
-/// Check that the concrete type behind `impl Trait` actually implements `Trait`.
+/// Check that the hidden type behind `impl Trait` actually implements `Trait`.
 ///
 /// This is mostly checked at the places that specify the opaque type, but we
 /// check those cases in the `param_env` of that function, which may have
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 b6d898886ac4d..a02990fe4abaf 100644
--- a/compiler/rustc_hir_analysis/src/collect/type_of/opaque.rs
+++ b/compiler/rustc_hir_analysis/src/collect/type_of/opaque.rs
@@ -177,7 +177,7 @@ impl<'tcx> TaitConstraintLocator<'tcx> {
                 let tables = tcx.typeck(item_def_id);
                 if let Some(guar) = tables.tainted_by_errors {
                     self.insert_found(ty::OpaqueHiddenType::new_error(tcx, guar));
-                } else if let Some(&hidden_type) = tables.concrete_opaque_types.get(&self.def_id) {
+                } else if let Some(&hidden_type) = tables.hidden_types.get(&self.def_id) {
                     self.insert_found(hidden_type);
                 } else {
                     self.non_defining_use_in_defining_scope(item_def_id);
@@ -185,8 +185,8 @@ impl<'tcx> TaitConstraintLocator<'tcx> {
             }
             DefiningScopeKind::MirBorrowck => match tcx.mir_borrowck(item_def_id) {
                 Err(guar) => self.insert_found(ty::OpaqueHiddenType::new_error(tcx, guar)),
-                Ok(concrete_opaque_types) => {
-                    if let Some(&hidden_type) = concrete_opaque_types.0.get(&self.def_id) {
+                Ok(hidden_types) => {
+                    if let Some(&hidden_type) = hidden_types.0.get(&self.def_id) {
                         debug!(?hidden_type, "found constraint");
                         self.insert_found(hidden_type);
                     } else if let Err(guar) = tcx
@@ -247,7 +247,7 @@ pub(super) fn find_opaque_ty_constraints_for_rpit<'tcx>(
             let tables = tcx.typeck(owner_def_id);
             if let Some(guar) = tables.tainted_by_errors {
                 Ty::new_error(tcx, guar)
-            } else if let Some(hidden_ty) = tables.concrete_opaque_types.get(&def_id) {
+            } else if let Some(hidden_ty) = tables.hidden_types.get(&def_id) {
                 hidden_ty.ty
             } else {
                 assert!(!tcx.next_trait_solver_globally());
@@ -261,8 +261,8 @@ pub(super) fn find_opaque_ty_constraints_for_rpit<'tcx>(
             }
         }
         DefiningScopeKind::MirBorrowck => match tcx.mir_borrowck(owner_def_id) {
-            Ok(concrete_opaque_types) => {
-                if let Some(hidden_ty) = concrete_opaque_types.0.get(&def_id) {
+            Ok(hidden_types) => {
+                if let Some(hidden_ty) = hidden_types.0.get(&def_id) {
                     hidden_ty.ty
                 } else {
                     let hir_ty = tcx.type_of_opaque_hir_typeck(def_id).instantiate_identity();
diff --git a/compiler/rustc_hir_typeck/src/opaque_types.rs b/compiler/rustc_hir_typeck/src/opaque_types.rs
index 5cefa506b5a06..a47fa202acfe3 100644
--- a/compiler/rustc_hir_typeck/src/opaque_types.rs
+++ b/compiler/rustc_hir_typeck/src/opaque_types.rs
@@ -15,7 +15,7 @@ use crate::FnCtxt;
 
 impl<'tcx> FnCtxt<'_, 'tcx> {
     /// This takes all the opaque type uses during HIR typeck. It first computes
-    /// the concrete hidden type by iterating over all defining uses.
+    /// the hidden type by iterating over all defining uses.
     ///
     /// A use during HIR typeck is defining if all non-lifetime arguments are
     /// unique generic parameters and the hidden type does not reference any
@@ -35,8 +35,8 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
         }
         debug!(?opaque_types);
 
-        self.compute_concrete_opaque_types(&opaque_types);
-        self.apply_computed_concrete_opaque_types(&opaque_types);
+        self.compute_hidden_types(&opaque_types);
+        self.apply_hidden_types(&opaque_types);
     }
 }
 
@@ -71,7 +71,7 @@ impl<'tcx> UsageKind<'tcx> {
 }
 
 impl<'tcx> FnCtxt<'_, 'tcx> {
-    fn compute_concrete_opaque_types(
+    fn compute_hidden_types(
         &mut self,
         opaque_types: &[(OpaqueTypeKey<'tcx>, OpaqueHiddenType<'tcx>)],
     ) {
@@ -142,7 +142,7 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
 
             self.typeck_results
                 .borrow_mut()
-                .concrete_opaque_types
+                .hidden_types
                 .insert(def_id, OpaqueHiddenType::new_error(tcx, guar));
             self.set_tainted_by_errors(guar);
         }
@@ -161,7 +161,7 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
         ) {
             match err {
                 NonDefiningUseReason::Tainted(guar) => {
-                    self.typeck_results.borrow_mut().concrete_opaque_types.insert(
+                    self.typeck_results.borrow_mut().hidden_types.insert(
                         opaque_type_key.def_id,
                         OpaqueHiddenType::new_error(self.tcx, guar),
                     );
@@ -197,20 +197,19 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
         let prev = self
             .typeck_results
             .borrow_mut()
-            .concrete_opaque_types
+            .hidden_types
             .insert(opaque_type_key.def_id, hidden_type);
         assert!(prev.is_none());
         UsageKind::HasDefiningUse
     }
 
-    fn apply_computed_concrete_opaque_types(
+    fn apply_hidden_types(
         &mut self,
         opaque_types: &[(OpaqueTypeKey<'tcx>, OpaqueHiddenType<'tcx>)],
     ) {
         let tcx = self.tcx;
         for &(key, hidden_type) in opaque_types {
-            let expected =
-                *self.typeck_results.borrow_mut().concrete_opaque_types.get(&key.def_id).unwrap();
+            let expected = *self.typeck_results.borrow_mut().hidden_types.get(&key.def_id).unwrap();
 
             let expected = EarlyBinder::bind(expected.ty).instantiate(tcx, key.args);
             self.demand_eqtype(hidden_type.span, expected, hidden_type.ty);
diff --git a/compiler/rustc_hir_typeck/src/writeback.rs b/compiler/rustc_hir_typeck/src/writeback.rs
index d01eeb9a4b691..697029e55f7cb 100644
--- a/compiler/rustc_hir_typeck/src/writeback.rs
+++ b/compiler/rustc_hir_typeck/src/writeback.rs
@@ -550,13 +550,12 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
     fn visit_opaque_types_next(&mut self) {
         let mut fcx_typeck_results = self.fcx.typeck_results.borrow_mut();
         assert_eq!(fcx_typeck_results.hir_owner, self.typeck_results.hir_owner);
-        for hidden_ty in fcx_typeck_results.concrete_opaque_types.values() {
+        for hidden_ty in fcx_typeck_results.hidden_types.values() {
             assert!(!hidden_ty.has_infer());
         }
 
-        assert_eq!(self.typeck_results.concrete_opaque_types.len(), 0);
-        self.typeck_results.concrete_opaque_types =
-            mem::take(&mut fcx_typeck_results.concrete_opaque_types);
+        assert_eq!(self.typeck_results.hidden_types.len(), 0);
+        self.typeck_results.hidden_types = mem::take(&mut fcx_typeck_results.hidden_types);
     }
 
     #[instrument(skip(self), level = "debug")]
@@ -588,7 +587,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
                 hidden_type.span,
                 DefiningScopeKind::HirTypeck,
             ) {
-                self.typeck_results.concrete_opaque_types.insert(
+                self.typeck_results.hidden_types.insert(
                     opaque_type_key.def_id,
                     ty::OpaqueHiddenType::new_error(tcx, err.report(self.fcx)),
                 );
@@ -600,16 +599,11 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
                 DefiningScopeKind::HirTypeck,
             );
 
-            if let Some(prev) = self
-                .typeck_results
-                .concrete_opaque_types
-                .insert(opaque_type_key.def_id, hidden_type)
+            if let Some(prev) =
+                self.typeck_results.hidden_types.insert(opaque_type_key.def_id, hidden_type)
             {
-                let entry = &mut self
-                    .typeck_results
-                    .concrete_opaque_types
-                    .get_mut(&opaque_type_key.def_id)
-                    .unwrap();
+                let entry =
+                    &mut self.typeck_results.hidden_types.get_mut(&opaque_type_key.def_id).unwrap();
                 if prev.ty != hidden_type.ty {
                     if let Some(guar) = self.typeck_results.tainted_by_errors {
                         entry.ty = Ty::new_error(tcx, guar);
@@ -628,7 +622,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
 
         let recursive_opaques: Vec<_> = self
             .typeck_results
-            .concrete_opaque_types
+            .hidden_types
             .iter()
             .filter(|&(&def_id, hidden_ty)| {
                 hidden_ty
@@ -636,7 +630,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
                     .visit_with(&mut HasRecursiveOpaque {
                         def_id,
                         seen: Default::default(),
-                        opaques: &self.typeck_results.concrete_opaque_types,
+                        opaques: &self.typeck_results.hidden_types,
                         tcx,
                     })
                     .is_break()
@@ -651,7 +645,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
                 .with_code(E0720)
                 .emit();
             self.typeck_results
-                .concrete_opaque_types
+                .hidden_types
                 .insert(def_id, OpaqueHiddenType { span, ty: Ty::new_error(tcx, guar) });
         }
     }
diff --git a/compiler/rustc_middle/src/arena.rs b/compiler/rustc_middle/src/arena.rs
index fa6a2db38ef9c..a63030b114527 100644
--- a/compiler/rustc_middle/src/arena.rs
+++ b/compiler/rustc_middle/src/arena.rs
@@ -27,7 +27,7 @@ macro_rules! arena_types {
                     rustc_middle::mir::Body<'tcx>
                 >,
             [decode] typeck_results: rustc_middle::ty::TypeckResults<'tcx>,
-            [decode] borrowck_result: rustc_middle::mir::ConcreteOpaqueTypes<'tcx>,
+            [decode] borrowck_result: rustc_middle::mir::HiddenTypes<'tcx>,
             [] resolver: rustc_data_structures::steal::Steal<(
                 rustc_middle::ty::ResolverAstLowering,
                 std::sync::Arc<rustc_ast::Crate>,
diff --git a/compiler/rustc_middle/src/mir/query.rs b/compiler/rustc_middle/src/mir/query.rs
index a509c40c89cd6..791565e387e8d 100644
--- a/compiler/rustc_middle/src/mir/query.rs
+++ b/compiler/rustc_middle/src/mir/query.rs
@@ -84,11 +84,10 @@ impl Debug for CoroutineLayout<'_> {
     }
 }
 
-/// All the opaque types that are restricted to concrete types
-/// by this function. Unlike the value in `TypeckResults`, this has
-/// unerased regions.
+/// All the opaque types that have had their hidden type fully computed.
+/// Unlike the value in `TypeckResults`, this has unerased regions.
 #[derive(Default, Debug, TyEncodable, TyDecodable, HashStable)]
-pub struct ConcreteOpaqueTypes<'tcx>(pub FxIndexMap<LocalDefId, OpaqueHiddenType<'tcx>>);
+pub struct HiddenTypes<'tcx>(pub FxIndexMap<LocalDefId, OpaqueHiddenType<'tcx>>);
 
 /// The result of the `mir_const_qualif` query.
 ///
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 326df9239aa08..1efb29c788d49 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -1244,7 +1244,7 @@ rustc_queries! {
 
     /// Borrow-checks the given typeck root, e.g. functions, const/static items,
     /// and its children, e.g. closures, inline consts.
-    query mir_borrowck(key: LocalDefId) -> Result<&'tcx mir::ConcreteOpaqueTypes<'tcx>, ErrorGuaranteed> {
+    query mir_borrowck(key: LocalDefId) -> Result<&'tcx mir::HiddenTypes<'tcx>, ErrorGuaranteed> {
         desc { |tcx| "borrow-checking `{}`", tcx.def_path_str(key) }
     }
 
diff --git a/compiler/rustc_middle/src/ty/typeck_results.rs b/compiler/rustc_middle/src/ty/typeck_results.rs
index 8dd80aab946d4..944bd9756a957 100644
--- a/compiler/rustc_middle/src/ty/typeck_results.rs
+++ b/compiler/rustc_middle/src/ty/typeck_results.rs
@@ -167,7 +167,7 @@ pub struct TypeckResults<'tcx> {
     /// We also store the type here, so that the compiler can use it as a hint
     /// for figuring out hidden types, even if they are only set in dead code
     /// (which doesn't show up in MIR).
-    pub concrete_opaque_types: FxIndexMap<LocalDefId, ty::OpaqueHiddenType<'tcx>>,
+    pub hidden_types: FxIndexMap<LocalDefId, ty::OpaqueHiddenType<'tcx>>,
 
     /// Tracks the minimum captures required for a closure;
     /// see `MinCaptureInformationMap` for more details.
@@ -250,7 +250,7 @@ impl<'tcx> TypeckResults<'tcx> {
             coercion_casts: Default::default(),
             used_trait_imports: Default::default(),
             tainted_by_errors: None,
-            concrete_opaque_types: Default::default(),
+            hidden_types: Default::default(),
             closure_min_captures: Default::default(),
             closure_fake_reads: Default::default(),
             rvalue_scopes: Default::default(),
diff --git a/compiler/rustc_pattern_analysis/src/rustc.rs b/compiler/rustc_pattern_analysis/src/rustc.rs
index d9f8085083ebd..0652461e97501 100644
--- a/compiler/rustc_pattern_analysis/src/rustc.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc.rs
@@ -120,7 +120,7 @@ impl<'p, 'tcx: 'p> fmt::Debug for RustcPatCtxt<'p, 'tcx> {
 impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
     /// Type inference occasionally gives us opaque types in places where corresponding patterns
     /// have more specific types. To avoid inconsistencies as well as detect opaque uninhabited
-    /// types, we use the corresponding concrete type if possible.
+    /// types, we use the corresponding hidden type if possible.
     // FIXME(#132279): This will be unnecessary once we have a TypingMode which supports revealing
     // opaque types defined in a body.
     #[inline]
@@ -146,7 +146,7 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
     /// know it.
     fn reveal_opaque_key(&self, key: OpaqueTypeKey<'tcx>) -> Option<Ty<'tcx>> {
         self.typeck_results
-            .concrete_opaque_types
+            .hidden_types
             .get(&key.def_id)
             .map(|x| ty::EarlyBinder::bind(x.ty).instantiate(self.tcx, key.args))
     }
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
index 1dd31990ab73e..fb4f28412d428 100644
--- a/compiler/rustc_trait_selection/src/traits/select/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -2359,7 +2359,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
                 if self.infcx.can_define_opaque_ty(def_id) {
                     unreachable!()
                 } else {
-                    // We can resolve the `impl Trait` to its concrete type,
+                    // We can resolve the opaque type to its hidden type,
                     // which enforces a DAG between the functions requiring
                     // the auto trait bounds in question.
                     match self.tcx().type_of_opaque(def_id) {
diff --git a/compiler/rustc_type_ir/src/infer_ctxt.rs b/compiler/rustc_type_ir/src/infer_ctxt.rs
index f743b84bce689..feafcee7bad9e 100644
--- a/compiler/rustc_type_ir/src/infer_ctxt.rs
+++ b/compiler/rustc_type_ir/src/infer_ctxt.rs
@@ -80,7 +80,7 @@ pub enum TypingMode<I: Interner> {
     /// the old solver as well.
     PostBorrowckAnalysis { defined_opaque_types: I::LocalDefIds },
     /// After analysis, mostly during codegen and MIR optimizations, we're able to
-    /// reveal all opaque types. As the concrete type should *never* be observable
+    /// reveal all opaque types. As the hidden type should *never* be observable
     /// directly by the user, this should not be used by checks which may expose
     /// such details to the user.
     ///

From 3a20a4d0a5463edb5fca2adfbe0522042a9ce752 Mon Sep 17 00:00:00 2001
From: Sebastian Speitel <sebastian.speitel@fem.tu-ilmenau.de>
Date: Sun, 28 Sep 2025 00:51:57 +0200
Subject: [PATCH 1497/1889] Fix typo

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

diff --git a/library/std/src/io/mod.rs b/library/std/src/io/mod.rs
index a45edd08e8ccc..25a4661a0bc9c 100644
--- a/library/std/src/io/mod.rs
+++ b/library/std/src/io/mod.rs
@@ -3234,7 +3234,7 @@ fn inlined_slow_read_byte<R: Read>(reader: &mut R) -> Option<Result<u8>> {
     }
 }
 
-// Used by `BufReader::spec_read_byte`, for which the `inline(ever)` is
+// Used by `BufReader::spec_read_byte`, for which the `inline(never)` is
 // important.
 #[inline(never)]
 fn uninlined_slow_read_byte<R: Read>(reader: &mut R) -> Option<Result<u8>> {

From fdacc0cf5f11769427cb86c3133051314f9e8485 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Sun, 28 Sep 2025 08:41:15 +0800
Subject: [PATCH 1498/1889] Add `all` `any` and `not` attribute completions

Example
---
`#[cfg($0)]` -> `#[cfg(any($0))]`
---
 .../src/completions/attribute/cfg.rs          | 30 +++++++++++++----
 .../ide-completion/src/tests/attribute.rs     | 32 +++++++++++++++++++
 2 files changed, 56 insertions(+), 6 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/attribute/cfg.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/attribute/cfg.rs
index 1676a8467c85f..b2e8efde8bebc 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/attribute/cfg.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/attribute/cfg.rs
@@ -53,15 +53,33 @@ pub(crate) fn complete_cfg(acc: &mut Completions, ctx: &CompletionContext<'_>) {
                 acc.add(item.build(ctx.db));
             }),
         },
-        None => ctx.krate.potential_cfg(ctx.db).get_cfg_keys().cloned().unique().for_each(|s| {
-            let s = s.as_str();
-            let item =
-                CompletionItem::new(SymbolKind::BuiltinAttr, ctx.source_range(), s, ctx.edition);
-            acc.add(item.build(ctx.db));
-        }),
+        None => ctx
+            .krate
+            .potential_cfg(ctx.db)
+            .get_cfg_keys()
+            .unique()
+            .map(|s| (s.as_str(), ""))
+            .chain(CFG_CONDITION.iter().copied())
+            .for_each(|(s, snippet)| {
+                let mut item = CompletionItem::new(
+                    SymbolKind::BuiltinAttr,
+                    ctx.source_range(),
+                    s,
+                    ctx.edition,
+                );
+                if let Some(cap) = ctx.config.snippet_cap
+                    && !snippet.is_empty()
+                {
+                    item.insert_snippet(cap, snippet);
+                }
+                acc.add(item.build(ctx.db));
+            }),
     }
 }
 
+const CFG_CONDITION: &[(&str, &str)] =
+    &[("all", "all($0)"), ("any", "any($0)"), ("not", "not($0)")];
+
 const KNOWN_ARCH: [&str; 20] = [
     "aarch64",
     "arm",
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/tests/attribute.rs b/src/tools/rust-analyzer/crates/ide-completion/src/tests/attribute.rs
index 30e1e108c6c40..1d2a9c7c8d3ce 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/tests/attribute.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/tests/attribute.rs
@@ -815,7 +815,10 @@ mod cfg {
 #[cfg($0)]
 "#,
             expect![[r#"
+                ba all
+                ba any
                 ba dbg
+                ba not
                 ba opt_level
                 ba test
                 ba true
@@ -827,7 +830,10 @@ mod cfg {
 #[cfg(b$0)]
 "#,
             expect![[r#"
+                ba all
+                ba any
                 ba dbg
+                ba not
                 ba opt_level
                 ba test
                 ba true
@@ -843,7 +849,10 @@ mod cfg {
 #[cfg_attr($0)]
 "#,
             expect![[r#"
+                ba all
+                ba any
                 ba dbg
+                ba not
                 ba opt_level
                 ba test
                 ba true
@@ -855,7 +864,10 @@ mod cfg {
 #[cfg_attr(b$0)]
 "#,
             expect![[r#"
+                ba all
+                ba any
                 ba dbg
+                ba not
                 ba opt_level
                 ba test
                 ba true
@@ -867,7 +879,10 @@ mod cfg {
 #[cfg_attr($0, allow(deprecated))]
 "#,
             expect![[r#"
+                ba all
+                ba any
                 ba dbg
+                ba not
                 ba opt_level
                 ba test
                 ba true
@@ -879,7 +894,10 @@ mod cfg {
 #[cfg_attr(b$0, allow(deprecated))]
 "#,
             expect![[r#"
+                ba all
+                ba any
                 ba dbg
+                ba not
                 ba opt_level
                 ba test
                 ba true
@@ -904,6 +922,20 @@ mod cfg {
             "#]],
         );
     }
+
+    #[test]
+    fn inside_conditional() {
+        check_edit(
+            "all",
+            r#"
+//- /main.rs cfg:test,dbg=false,opt_level=2
+#[cfg($0)]
+"#,
+            r#"
+#[cfg(all($0))]
+"#,
+        );
+    }
 }
 
 mod derive {

From c1259aa26fead9a9d365c4436d5ceb00cad88bbe Mon Sep 17 00:00:00 2001
From: WANG Rui <wangrui@loongson.cn>
Date: Thu, 28 Aug 2025 23:31:46 +0800
Subject: [PATCH 1499/1889] Add LSX accelerated implementation for source file
 analysis

This patch introduces an LSX-optimized version of `analyze_source_file`
for the `loongarch64` target. Similar to existing SSE2 implementation
for x86, this version:

- Processes 16-byte chunks at a time using LSX vector intrinsics.
- Quickly identifies newlines in ASCII-only chunks.
- Falls back to the generic implementation when multi-byte UTF-8
  characters are detected or in the tail portion.
---
 .../rustc_span/src/analyze_source_file.rs     | 109 +++++++++++++++++-
 compiler/rustc_span/src/lib.rs                |   1 +
 2 files changed, 107 insertions(+), 3 deletions(-)

diff --git a/compiler/rustc_span/src/analyze_source_file.rs b/compiler/rustc_span/src/analyze_source_file.rs
index c32593a6d95ab..bb2cda77dffff 100644
--- a/compiler/rustc_span/src/analyze_source_file.rs
+++ b/compiler/rustc_span/src/analyze_source_file.rs
@@ -81,8 +81,8 @@ cfg_select! {
                 // use `loadu`, which supports unaligned loading.
                 let chunk = unsafe { _mm_loadu_si128(chunk.as_ptr() as *const __m128i) };
 
-                // For character in the chunk, see if its byte value is < 0, which
-                // indicates that it's part of a UTF-8 char.
+                // For each character in the chunk, see if its byte value is < 0,
+                // which indicates that it's part of a UTF-8 char.
                 let multibyte_test = _mm_cmplt_epi8(chunk, _mm_set1_epi8(0));
                 // Create a bit mask from the comparison results.
                 let multibyte_mask = _mm_movemask_epi8(multibyte_test);
@@ -132,8 +132,111 @@ cfg_select! {
             }
         }
     }
+    target_arch = "loongarch64" => {
+        fn analyze_source_file_dispatch(
+            src: &str,
+            lines: &mut Vec<RelativeBytePos>,
+            multi_byte_chars: &mut Vec<MultiByteChar>,
+        ) {
+            use std::arch::is_loongarch_feature_detected;
+
+            if is_loongarch_feature_detected!("lsx") {
+                unsafe {
+                    analyze_source_file_lsx(src, lines, multi_byte_chars);
+                }
+            } else {
+                analyze_source_file_generic(
+                    src,
+                    src.len(),
+                    RelativeBytePos::from_u32(0),
+                    lines,
+                    multi_byte_chars,
+                );
+            }
+        }
+
+        /// Checks 16 byte chunks of text at a time. If the chunk contains
+        /// something other than printable ASCII characters and newlines, the
+        /// function falls back to the generic implementation. Otherwise it uses
+        /// LSX intrinsics to quickly find all newlines.
+        #[target_feature(enable = "lsx")]
+        unsafe fn analyze_source_file_lsx(
+            src: &str,
+            lines: &mut Vec<RelativeBytePos>,
+            multi_byte_chars: &mut Vec<MultiByteChar>,
+        ) {
+            use std::arch::loongarch64::*;
+
+            const CHUNK_SIZE: usize = 16;
+
+            let (chunks, tail) = src.as_bytes().as_chunks::<CHUNK_SIZE>();
+
+            // This variable keeps track of where we should start decoding a
+            // chunk. If a multi-byte character spans across chunk boundaries,
+            // we need to skip that part in the next chunk because we already
+            // handled it.
+            let mut intra_chunk_offset = 0;
+
+            for (chunk_index, chunk) in chunks.iter().enumerate() {
+                // All LSX memory instructions support unaligned access, so using
+                // vld is fine.
+                let chunk = unsafe { lsx_vld::<0>(chunk.as_ptr() as *const i8) };
+
+                // For each character in the chunk, see if its byte value is < 0,
+                // which indicates that it's part of a UTF-8 char.
+                let multibyte_mask = lsx_vmskltz_b(chunk);
+                // Create a bit mask from the comparison results.
+                let multibyte_mask = lsx_vpickve2gr_w::<0>(multibyte_mask);
+
+                // If the bit mask is all zero, we only have ASCII chars here:
+                if multibyte_mask == 0 {
+                    assert!(intra_chunk_offset == 0);
+
+                    // Check for newlines in the chunk
+                    let newlines_test = lsx_vseqi_b::<{b'\n' as i32}>(chunk);
+                    let newlines_mask = lsx_vmskltz_b(newlines_test);
+                    let mut newlines_mask = lsx_vpickve2gr_w::<0>(newlines_mask);
+
+                    let output_offset = RelativeBytePos::from_usize(chunk_index * CHUNK_SIZE + 1);
+
+                    while newlines_mask != 0 {
+                        let index = newlines_mask.trailing_zeros();
+
+                        lines.push(RelativeBytePos(index) + output_offset);
+
+                        // Clear the bit, so we can find the next one.
+                        newlines_mask &= newlines_mask - 1;
+                    }
+                } else {
+                    // The slow path.
+                    // There are multibyte chars in here, fallback to generic decoding.
+                    let scan_start = chunk_index * CHUNK_SIZE + intra_chunk_offset;
+                    intra_chunk_offset = analyze_source_file_generic(
+                        &src[scan_start..],
+                        CHUNK_SIZE - intra_chunk_offset,
+                        RelativeBytePos::from_usize(scan_start),
+                        lines,
+                        multi_byte_chars,
+                    );
+                }
+            }
+
+            // There might still be a tail left to analyze
+            let tail_start = src.len() - tail.len() + intra_chunk_offset;
+            if tail_start < src.len() {
+                analyze_source_file_generic(
+                    &src[tail_start..],
+                    src.len() - tail_start,
+                    RelativeBytePos::from_usize(tail_start),
+                    lines,
+                    multi_byte_chars,
+                );
+            }
+        }
+    }
     _ => {
-        // The target (or compiler version) does not support SSE2 ...
+        // The target (or compiler version) does not support vector instructions
+        // our specialized implementations need (x86 SSE2, loongarch64 LSX)...
         fn analyze_source_file_dispatch(
             src: &str,
             lines: &mut Vec<RelativeBytePos>,
diff --git a/compiler/rustc_span/src/lib.rs b/compiler/rustc_span/src/lib.rs
index 35dbbe58db9a4..ededbea57e966 100644
--- a/compiler/rustc_span/src/lib.rs
+++ b/compiler/rustc_span/src/lib.rs
@@ -17,6 +17,7 @@
 
 // tidy-alphabetical-start
 #![allow(internal_features)]
+#![cfg_attr(target_arch = "loongarch64", feature(stdarch_loongarch))]
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
 #![doc(rust_logo)]
 #![feature(array_windows)]

From 0d658fe156c077e0f37068d5788f6c375d555b54 Mon Sep 17 00:00:00 2001
From: Nik Revenco <pm@nikrev.com>
Date: Sun, 28 Sep 2025 00:55:47 +0100
Subject: [PATCH 1500/1889] test: add `keyword/soup.rs`

---
 tests/ui/keyword/soup.rs | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 tests/ui/keyword/soup.rs

diff --git a/tests/ui/keyword/soup.rs b/tests/ui/keyword/soup.rs
new file mode 100644
index 0000000000000..c4dbe3fb48341
--- /dev/null
+++ b/tests/ui/keyword/soup.rs
@@ -0,0 +1,30 @@
+//@ edition:2024
+//@ check-pass
+
+#![allow(unused_imports)]
+#![allow(missing_abi)]
+#![allow(unused_macros)]
+#![allow(non_camel_case_types)]
+#![allow(unreachable_code)]
+#![allow(unused_variables)]
+#![allow(dead_code)]
+#![allow(unused_must_use)]
+
+// all 48 keywords in 300 characters
+mod x {
+    pub(super) struct X;
+    use Ok;
+    impl X {
+        pub(in crate) async fn x(self: Self, x: &'static &'_ dyn for<> Fn()) where {
+            unsafe extern { safe fn x(); }
+            macro_rules! x { () => {}; }
+            if 'x: loop {
+                return match while let true = break 'x false { continue } {
+                    ref x => { &raw mut x; async { const { enum A {} } }.await as () },
+                };
+            } { type x = X; } else { move || { trait x { } union B { x: () } }; }
+        }
+    }
+}
+
+fn main() {}

From b3f3e36c72952736be5b9e0360ee5b86148f2c29 Mon Sep 17 00:00:00 2001
From: Jubilee Young <workingjubilee@gmail.com>
Date: Sat, 27 Sep 2025 20:00:54 -0700
Subject: [PATCH 1501/1889] compiler: remove AbiAlign inside TargetDataLayout

This maintains AbiAlign usage in public API and most of the compiler,
but direct access of these fields is now in terms of Align only.
---
 compiler/rustc_abi/src/callconv/reg.rs        | 22 ++---
 compiler/rustc_abi/src/layout.rs              | 65 +++++++-------
 compiler/rustc_abi/src/layout/simple.rs       | 27 +++---
 compiler/rustc_abi/src/lib.rs                 | 85 +++++++++----------
 compiler/rustc_codegen_llvm/src/consts.rs     |  4 +-
 compiler/rustc_codegen_llvm/src/intrinsic.rs  |  2 +-
 compiler/rustc_codegen_llvm/src/va_arg.rs     |  8 +-
 compiler/rustc_session/src/config/cfg.rs      | 10 +--
 compiler/rustc_target/src/callconv/mips.rs    |  2 +-
 compiler/rustc_target/src/callconv/mips64.rs  |  4 +-
 compiler/rustc_target/src/callconv/mod.rs     |  2 +-
 compiler/rustc_target/src/callconv/sparc.rs   |  2 +-
 compiler/rustc_target/src/callconv/sparc64.rs |  2 +-
 13 files changed, 115 insertions(+), 120 deletions(-)

diff --git a/compiler/rustc_abi/src/callconv/reg.rs b/compiler/rustc_abi/src/callconv/reg.rs
index 8cf140dbaad4e..66c8056d0c2af 100644
--- a/compiler/rustc_abi/src/callconv/reg.rs
+++ b/compiler/rustc_abi/src/callconv/reg.rs
@@ -42,22 +42,22 @@ impl Reg {
         let dl = cx.data_layout();
         match self.kind {
             RegKind::Integer => match self.size.bits() {
-                1 => dl.i1_align.abi,
-                2..=8 => dl.i8_align.abi,
-                9..=16 => dl.i16_align.abi,
-                17..=32 => dl.i32_align.abi,
-                33..=64 => dl.i64_align.abi,
-                65..=128 => dl.i128_align.abi,
+                1 => dl.i1_align,
+                2..=8 => dl.i8_align,
+                9..=16 => dl.i16_align,
+                17..=32 => dl.i32_align,
+                33..=64 => dl.i64_align,
+                65..=128 => dl.i128_align,
                 _ => panic!("unsupported integer: {self:?}"),
             },
             RegKind::Float => match self.size.bits() {
-                16 => dl.f16_align.abi,
-                32 => dl.f32_align.abi,
-                64 => dl.f64_align.abi,
-                128 => dl.f128_align.abi,
+                16 => dl.f16_align,
+                32 => dl.f32_align,
+                64 => dl.f64_align,
+                128 => dl.f128_align,
                 _ => panic!("unsupported float: {self:?}"),
             },
-            RegKind::Vector => dl.llvmlike_vector_align(self.size).abi,
+            RegKind::Vector => dl.llvmlike_vector_align(self.size),
         }
     }
 }
diff --git a/compiler/rustc_abi/src/layout.rs b/compiler/rustc_abi/src/layout.rs
index 5004d0c80220f..09b4322e299b8 100644
--- a/compiler/rustc_abi/src/layout.rs
+++ b/compiler/rustc_abi/src/layout.rs
@@ -174,11 +174,11 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
             // Non-power-of-two vectors have padding up to the next power-of-two.
             // If we're a packed repr, remove the padding while keeping the alignment as close
             // to a vector as possible.
-            (BackendRepr::Memory { sized: true }, AbiAlign { abi: Align::max_aligned_factor(size) })
+            (BackendRepr::Memory { sized: true }, Align::max_aligned_factor(size))
         } else {
             (BackendRepr::SimdVector { element: e_repr, count }, dl.llvmlike_vector_align(size))
         };
-        let size = size.align_to(align.abi);
+        let size = size.align_to(align);
 
         Ok(LayoutData {
             variants: Variants::Single { index: VariantIdx::new(0) },
@@ -190,7 +190,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
             largest_niche: elt.largest_niche,
             uninhabited: false,
             size,
-            align,
+            align: AbiAlign::new(align),
             max_repr_align: None,
             unadjusted_abi_align: elt.align.abi,
             randomization_seed: elt.randomization_seed.wrapping_add(Hash64::new(count)),
@@ -388,7 +388,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
                 return Err(LayoutCalculatorError::UnexpectedUnsized(*field));
             }
 
-            align = align.max(field.align);
+            align = align.max(field.align.abi);
             max_repr_align = max_repr_align.max(field.max_repr_align);
             size = cmp::max(size, field.size);
 
@@ -423,13 +423,13 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
         }
 
         if let Some(pack) = repr.pack {
-            align = align.min(AbiAlign::new(pack));
+            align = align.min(pack);
         }
         // The unadjusted ABI alignment does not include repr(align), but does include repr(pack).
         // See documentation on `LayoutData::unadjusted_abi_align`.
-        let unadjusted_abi_align = align.abi;
+        let unadjusted_abi_align = align;
         if let Some(repr_align) = repr.align {
-            align = align.max(AbiAlign::new(repr_align));
+            align = align.max(repr_align);
         }
         // `align` must not be modified after this, or `unadjusted_abi_align` could be inaccurate.
         let align = align;
@@ -441,14 +441,12 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
             Ok(Some((repr, _))) => match repr {
                 // Mismatched alignment (e.g. union is #[repr(packed)]): disable opt
                 BackendRepr::Scalar(_) | BackendRepr::ScalarPair(_, _)
-                    if repr.scalar_align(dl).unwrap() != align.abi =>
+                    if repr.scalar_align(dl).unwrap() != align =>
                 {
                     BackendRepr::Memory { sized: true }
                 }
                 // Vectors require at least element alignment, else disable the opt
-                BackendRepr::SimdVector { element, count: _ }
-                    if element.align(dl).abi > align.abi =>
-                {
+                BackendRepr::SimdVector { element, count: _ } if element.align(dl).abi > align => {
                     BackendRepr::Memory { sized: true }
                 }
                 // the alignment tests passed and we can use this
@@ -474,8 +472,8 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
             backend_repr,
             largest_niche: None,
             uninhabited: false,
-            align,
-            size: size.align_to(align.abi),
+            align: AbiAlign::new(align),
+            size: size.align_to(align),
             max_repr_align,
             unadjusted_abi_align,
             randomization_seed: combined_seed,
@@ -611,7 +609,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
 
             let mut align = dl.aggregate_align;
             let mut max_repr_align = repr.align;
-            let mut unadjusted_abi_align = align.abi;
+            let mut unadjusted_abi_align = align;
 
             let mut variant_layouts = variants
                 .iter_enumerated()
@@ -619,7 +617,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
                     let mut st = self.univariant(v, repr, StructKind::AlwaysSized).ok()?;
                     st.variants = Variants::Single { index: j };
 
-                    align = align.max(st.align);
+                    align = align.max(st.align.abi);
                     max_repr_align = max_repr_align.max(st.max_repr_align);
                     unadjusted_abi_align = unadjusted_abi_align.max(st.unadjusted_abi_align);
 
@@ -646,7 +644,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
             let (niche_start, niche_scalar) = niche.reserve(dl, count)?;
             let niche_offset = niche.offset;
             let niche_size = niche.value.size(dl);
-            let size = variant_layouts[largest_variant_index].size.align_to(align.abi);
+            let size = variant_layouts[largest_variant_index].size.align_to(align);
 
             let all_variants_fit = variant_layouts.iter_enumerated_mut().all(|(i, layout)| {
                 if i == largest_variant_index {
@@ -699,7 +697,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
                 .iter_enumerated()
                 .all(|(i, layout)| i == largest_variant_index || layout.size == Size::ZERO);
             let same_size = size == variant_layouts[largest_variant_index].size;
-            let same_align = align == variant_layouts[largest_variant_index].align;
+            let same_align = align == variant_layouts[largest_variant_index].align.abi;
 
             let uninhabited = variant_layouts.iter().all(|v| v.is_uninhabited());
             let abi = if same_size && same_align && others_zst {
@@ -746,7 +744,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
                 largest_niche,
                 uninhabited,
                 size,
-                align,
+                align: AbiAlign::new(align),
                 max_repr_align,
                 unadjusted_abi_align,
                 randomization_seed: combined_seed,
@@ -818,7 +816,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
 
         let mut align = dl.aggregate_align;
         let mut max_repr_align = repr.align;
-        let mut unadjusted_abi_align = align.abi;
+        let mut unadjusted_abi_align = align;
 
         let mut size = Size::ZERO;
 
@@ -860,7 +858,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
                     }
                 }
                 size = cmp::max(size, st.size);
-                align = align.max(st.align);
+                align = align.max(st.align.abi);
                 max_repr_align = max_repr_align.max(st.max_repr_align);
                 unadjusted_abi_align = unadjusted_abi_align.max(st.unadjusted_abi_align);
                 Ok(st)
@@ -868,7 +866,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
             .collect::<Result<IndexVec<VariantIdx, _>, _>>()?;
 
         // Align the maximum variant size to the largest alignment.
-        size = size.align_to(align.abi);
+        size = size.align_to(align);
 
         // FIXME(oli-obk): deduplicate and harden these checks
         if size.bytes() >= dl.obj_size_bound() {
@@ -1042,7 +1040,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
                 };
                 if pair_offsets[FieldIdx::new(0)] == Size::ZERO
                     && pair_offsets[FieldIdx::new(1)] == *offset
-                    && align == pair.align
+                    && align == pair.align.abi
                     && size == pair.size
                 {
                     // We can use `ScalarPair` only when it matches our
@@ -1066,7 +1064,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
                     // Also need to bump up the size and alignment, so that the entire value fits
                     // in here.
                     variant.size = cmp::max(variant.size, size);
-                    variant.align.abi = cmp::max(variant.align.abi, align.abi);
+                    variant.align.abi = cmp::max(variant.align.abi, align);
                 }
             }
         }
@@ -1092,7 +1090,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
             largest_niche,
             uninhabited,
             backend_repr: abi,
-            align,
+            align: AbiAlign::new(align),
             size,
             max_repr_align,
             unadjusted_abi_align,
@@ -1288,7 +1286,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
         if let StructKind::Prefixed(prefix_size, prefix_align) = kind {
             let prefix_align =
                 if let Some(pack) = pack { prefix_align.min(pack) } else { prefix_align };
-            align = align.max(AbiAlign::new(prefix_align));
+            align = align.max(prefix_align);
             offset = prefix_size.align_to(prefix_align);
         }
         for &i in &inverse_memory_index {
@@ -1312,7 +1310,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
                 field.align
             };
             offset = offset.align_to(field_align.abi);
-            align = align.max(field_align);
+            align = align.max(field_align.abi);
             max_repr_align = max_repr_align.max(field.max_repr_align);
 
             debug!("univariant offset: {:?} field: {:#?}", offset, field);
@@ -1339,9 +1337,9 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
 
         // The unadjusted ABI alignment does not include repr(align), but does include repr(pack).
         // See documentation on `LayoutData::unadjusted_abi_align`.
-        let unadjusted_abi_align = align.abi;
+        let unadjusted_abi_align = align;
         if let Some(repr_align) = repr.align {
-            align = align.max(AbiAlign::new(repr_align));
+            align = align.max(repr_align);
         }
         // `align` must not be modified after this point, or `unadjusted_abi_align` could be inaccurate.
         let align = align;
@@ -1360,7 +1358,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
             debug_assert!(inverse_memory_index.iter().copied().eq(fields.indices()));
             inverse_memory_index.into_iter().map(|it| it.index() as u32).collect()
         };
-        let size = min_size.align_to(align.abi);
+        let size = min_size.align_to(align);
         // FIXME(oli-obk): deduplicate and harden these checks
         if size.bytes() >= dl.obj_size_bound() {
             return Err(LayoutCalculatorError::SizeOverflow);
@@ -1383,8 +1381,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
                     layout_of_single_non_zst_field = Some(field);
 
                     // Field fills the struct and it has a scalar or scalar pair ABI.
-                    if offsets[i].bytes() == 0 && align.abi == field.align.abi && size == field.size
-                    {
+                    if offsets[i].bytes() == 0 && align == field.align.abi && size == field.size {
                         match field.backend_repr {
                             // For plain scalars, or vectors of them, we can't unpack
                             // newtypes for `#[repr(C)]`, as that affects C ABIs.
@@ -1428,7 +1425,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
                             };
                             if offsets[i] == pair_offsets[FieldIdx::new(0)]
                                 && offsets[j] == pair_offsets[FieldIdx::new(1)]
-                                && align == pair.align
+                                && align == pair.align.abi
                                 && size == pair.size
                             {
                                 // We can use `ScalarPair` only when it matches our
@@ -1450,7 +1447,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
                 Some(l) => l.unadjusted_abi_align,
                 None => {
                     // `repr(transparent)` with all ZST fields.
-                    align.abi
+                    align
                 }
             }
         } else {
@@ -1465,7 +1462,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
             backend_repr: abi,
             largest_niche,
             uninhabited,
-            align,
+            align: AbiAlign::new(align),
             size,
             max_repr_align,
             unadjusted_abi_align,
diff --git a/compiler/rustc_abi/src/layout/simple.rs b/compiler/rustc_abi/src/layout/simple.rs
index 0d0706defc2e5..b3807c8727396 100644
--- a/compiler/rustc_abi/src/layout/simple.rs
+++ b/compiler/rustc_abi/src/layout/simple.rs
@@ -4,7 +4,8 @@ use rustc_hashes::Hash64;
 use rustc_index::{Idx, IndexVec};
 
 use crate::{
-    BackendRepr, FieldsShape, HasDataLayout, LayoutData, Niche, Primitive, Scalar, Size, Variants,
+    AbiAlign, BackendRepr, FieldsShape, HasDataLayout, LayoutData, Niche, Primitive, Scalar, Size,
+    Variants,
 };
 
 /// "Simple" layout constructors that cannot fail.
@@ -20,10 +21,10 @@ impl<FieldIdx: Idx, VariantIdx: Idx> LayoutData<FieldIdx, VariantIdx> {
             backend_repr: BackendRepr::Memory { sized },
             largest_niche: None,
             uninhabited: false,
-            align: dl.i8_align,
+            align: AbiAlign::new(dl.i8_align),
             size: Size::ZERO,
             max_repr_align: None,
-            unadjusted_abi_align: dl.i8_align.abi,
+            unadjusted_abi_align: dl.i8_align,
             randomization_seed: Hash64::new(0),
         }
     }
@@ -37,10 +38,10 @@ impl<FieldIdx: Idx, VariantIdx: Idx> LayoutData<FieldIdx, VariantIdx> {
             backend_repr: BackendRepr::Memory { sized: true },
             largest_niche: None,
             uninhabited: true,
-            align: dl.i8_align,
+            align: AbiAlign::new(dl.i8_align),
             size: Size::ZERO,
             max_repr_align: None,
-            unadjusted_abi_align: dl.i8_align.abi,
+            unadjusted_abi_align: dl.i8_align,
             randomization_seed: Hash64::ZERO,
         }
     }
@@ -89,10 +90,10 @@ impl<FieldIdx: Idx, VariantIdx: Idx> LayoutData<FieldIdx, VariantIdx> {
 
     pub fn scalar_pair<C: HasDataLayout>(cx: &C, a: Scalar, b: Scalar) -> Self {
         let dl = cx.data_layout();
-        let b_align = b.align(dl);
-        let align = a.align(dl).max(b_align).max(dl.aggregate_align);
-        let b_offset = a.size(dl).align_to(b_align.abi);
-        let size = (b_offset + b.size(dl)).align_to(align.abi);
+        let b_align = b.align(dl).abi;
+        let align = a.align(dl).abi.max(b_align).max(dl.aggregate_align);
+        let b_offset = a.size(dl).align_to(b_align);
+        let size = (b_offset + b.size(dl)).align_to(align);
 
         // HACK(nox): We iter on `b` and then `a` because `max_by_key`
         // returns the last maximum.
@@ -112,10 +113,10 @@ impl<FieldIdx: Idx, VariantIdx: Idx> LayoutData<FieldIdx, VariantIdx> {
             backend_repr: BackendRepr::ScalarPair(a, b),
             largest_niche,
             uninhabited: false,
-            align,
+            align: AbiAlign::new(align),
             size,
             max_repr_align: None,
-            unadjusted_abi_align: align.abi,
+            unadjusted_abi_align: align,
             randomization_seed: Hash64::new(combined_seed),
         }
     }
@@ -138,10 +139,10 @@ impl<FieldIdx: Idx, VariantIdx: Idx> LayoutData<FieldIdx, VariantIdx> {
             backend_repr: BackendRepr::Memory { sized: true },
             largest_niche: None,
             uninhabited: true,
-            align: dl.i8_align,
+            align: AbiAlign::new(dl.i8_align),
             size: Size::ZERO,
             max_repr_align: None,
-            unadjusted_abi_align: dl.i8_align.abi,
+            unadjusted_abi_align: dl.i8_align,
             randomization_seed: Hash64::ZERO,
         }
     }
diff --git a/compiler/rustc_abi/src/lib.rs b/compiler/rustc_abi/src/lib.rs
index 369874521e57e..fe7148d1d5729 100644
--- a/compiler/rustc_abi/src/lib.rs
+++ b/compiler/rustc_abi/src/lib.rs
@@ -229,7 +229,7 @@ pub struct PointerSpec {
     /// The size of the bitwise representation of the pointer.
     pointer_size: Size,
     /// The alignment of pointers for this address space
-    pointer_align: AbiAlign,
+    pointer_align: Align,
     /// The size of the value a pointer can be offset by in this address space.
     pointer_offset: Size,
     /// Pointers into this address space contain extra metadata
@@ -242,20 +242,20 @@ pub struct PointerSpec {
 #[derive(Debug, PartialEq, Eq)]
 pub struct TargetDataLayout {
     pub endian: Endian,
-    pub i1_align: AbiAlign,
-    pub i8_align: AbiAlign,
-    pub i16_align: AbiAlign,
-    pub i32_align: AbiAlign,
-    pub i64_align: AbiAlign,
-    pub i128_align: AbiAlign,
-    pub f16_align: AbiAlign,
-    pub f32_align: AbiAlign,
-    pub f64_align: AbiAlign,
-    pub f128_align: AbiAlign,
-    pub aggregate_align: AbiAlign,
+    pub i1_align: Align,
+    pub i8_align: Align,
+    pub i16_align: Align,
+    pub i32_align: Align,
+    pub i64_align: Align,
+    pub i128_align: Align,
+    pub f16_align: Align,
+    pub f32_align: Align,
+    pub f64_align: Align,
+    pub f128_align: Align,
+    pub aggregate_align: Align,
 
     /// Alignments for vector types.
-    pub vector_align: Vec<(Size, AbiAlign)>,
+    pub vector_align: Vec<(Size, Align)>,
 
     pub default_address_space: AddressSpace,
     pub default_address_space_pointer_spec: PointerSpec,
@@ -282,25 +282,25 @@ impl Default for TargetDataLayout {
         let align = |bits| Align::from_bits(bits).unwrap();
         TargetDataLayout {
             endian: Endian::Big,
-            i1_align: AbiAlign::new(align(8)),
-            i8_align: AbiAlign::new(align(8)),
-            i16_align: AbiAlign::new(align(16)),
-            i32_align: AbiAlign::new(align(32)),
-            i64_align: AbiAlign::new(align(32)),
-            i128_align: AbiAlign::new(align(32)),
-            f16_align: AbiAlign::new(align(16)),
-            f32_align: AbiAlign::new(align(32)),
-            f64_align: AbiAlign::new(align(64)),
-            f128_align: AbiAlign::new(align(128)),
-            aggregate_align: AbiAlign { abi: align(8) },
+            i1_align: align(8),
+            i8_align: align(8),
+            i16_align: align(16),
+            i32_align: align(32),
+            i64_align: align(32),
+            i128_align: align(32),
+            f16_align: align(16),
+            f32_align: align(32),
+            f64_align: align(64),
+            f128_align: align(128),
+            aggregate_align: align(8),
             vector_align: vec![
-                (Size::from_bits(64), AbiAlign::new(align(64))),
-                (Size::from_bits(128), AbiAlign::new(align(128))),
+                (Size::from_bits(64), align(64)),
+                (Size::from_bits(128), align(128)),
             ],
             default_address_space: AddressSpace::ZERO,
             default_address_space_pointer_spec: PointerSpec {
                 pointer_size: Size::from_bits(64),
-                pointer_align: AbiAlign::new(align(64)),
+                pointer_align: align(64),
                 pointer_offset: Size::from_bits(64),
                 _is_fat: false,
             },
@@ -360,7 +360,7 @@ impl TargetDataLayout {
                     .map_err(|err| TargetDataLayoutErrors::InvalidAlignment { cause, err })
             };
             let abi = parse_bits(s, "alignment", cause)?;
-            Ok(AbiAlign::new(align_from_bits(abi)?))
+            Ok(align_from_bits(abi)?)
         };
 
         // Parse an alignment sequence, possibly in the form `<align>[:<preferred_alignment>]`,
@@ -596,7 +596,7 @@ impl TargetDataLayout {
 
     /// psABI-mandated alignment for a vector type, if any
     #[inline]
-    fn cabi_vector_align(&self, vec_size: Size) -> Option<AbiAlign> {
+    fn cabi_vector_align(&self, vec_size: Size) -> Option<Align> {
         self.vector_align
             .iter()
             .find(|(size, _align)| *size == vec_size)
@@ -605,10 +605,9 @@ impl TargetDataLayout {
 
     /// an alignment resembling the one LLVM would pick for a vector
     #[inline]
-    pub fn llvmlike_vector_align(&self, vec_size: Size) -> AbiAlign {
-        self.cabi_vector_align(vec_size).unwrap_or(AbiAlign::new(
-            Align::from_bytes(vec_size.bytes().next_power_of_two()).unwrap(),
-        ))
+    pub fn llvmlike_vector_align(&self, vec_size: Size) -> Align {
+        self.cabi_vector_align(vec_size)
+            .unwrap_or(Align::from_bytes(vec_size.bytes().next_power_of_two()).unwrap())
     }
 
     /// Get the pointer size in the default data address space.
@@ -654,21 +653,19 @@ impl TargetDataLayout {
     /// Get the pointer alignment in the default data address space.
     #[inline]
     pub fn pointer_align(&self) -> AbiAlign {
-        self.default_address_space_pointer_spec.pointer_align
+        AbiAlign::new(self.default_address_space_pointer_spec.pointer_align)
     }
 
     /// Get the pointer alignment in a specific address space.
     #[inline]
     pub fn pointer_align_in(&self, c: AddressSpace) -> AbiAlign {
-        if c == self.default_address_space {
-            return self.default_address_space_pointer_spec.pointer_align;
-        }
-
-        if let Some(e) = self.address_space_info.iter().find(|(a, _)| a == &c) {
+        AbiAlign::new(if c == self.default_address_space {
+            self.default_address_space_pointer_spec.pointer_align
+        } else if let Some(e) = self.address_space_info.iter().find(|(a, _)| a == &c) {
             e.1.pointer_align
         } else {
             panic!("Use of unknown address space {c:?}");
-        }
+        })
     }
 }
 
@@ -1185,13 +1182,13 @@ impl Integer {
         use Integer::*;
         let dl = cx.data_layout();
 
-        match self {
+        AbiAlign::new(match self {
             I8 => dl.i8_align,
             I16 => dl.i16_align,
             I32 => dl.i32_align,
             I64 => dl.i64_align,
             I128 => dl.i128_align,
-        }
+        })
     }
 
     /// Returns the largest signed value that can be represented by this Integer.
@@ -1311,12 +1308,12 @@ impl Float {
         use Float::*;
         let dl = cx.data_layout();
 
-        match self {
+        AbiAlign::new(match self {
             F16 => dl.f16_align,
             F32 => dl.f32_align,
             F64 => dl.f64_align,
             F128 => dl.f128_align,
-        }
+        })
     }
 }
 
diff --git a/compiler/rustc_codegen_llvm/src/consts.rs b/compiler/rustc_codegen_llvm/src/consts.rs
index a110ecbb75d95..40375ef651092 100644
--- a/compiler/rustc_codegen_llvm/src/consts.rs
+++ b/compiler/rustc_codegen_llvm/src/consts.rs
@@ -564,7 +564,7 @@ impl<'ll> CodegenCx<'ll, '_> {
         let g = self.define_global(&sym, llty).unwrap_or_else(|| {
             bug!("symbol `{}` is already defined", sym);
         });
-        set_global_alignment(self, g, self.tcx.data_layout.i8_align.abi);
+        set_global_alignment(self, g, self.tcx.data_layout.i8_align);
         llvm::set_initializer(g, llval);
         llvm::set_linkage(g, llvm::Linkage::PrivateLinkage);
         llvm::set_section(g, c"__TEXT,__cstring,cstring_literals");
@@ -680,7 +680,7 @@ impl<'ll> CodegenCx<'ll, '_> {
         let methname_g = self.define_global(&methname_sym, methname_llty).unwrap_or_else(|| {
             bug!("symbol `{}` is already defined", methname_sym);
         });
-        set_global_alignment(self, methname_g, self.tcx.data_layout.i8_align.abi);
+        set_global_alignment(self, methname_g, self.tcx.data_layout.i8_align);
         llvm::set_initializer(methname_g, methname_llval);
         llvm::set_linkage(methname_g, llvm::Linkage::PrivateLinkage);
         llvm::set_section(
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
index 50398a32142eb..94a74e27bbcb4 100644
--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -1047,7 +1047,7 @@ fn codegen_emcc_try<'ll, 'tcx>(
         // create an alloca and pass a pointer to that.
         let ptr_size = bx.tcx().data_layout.pointer_size();
         let ptr_align = bx.tcx().data_layout.pointer_align().abi;
-        let i8_align = bx.tcx().data_layout.i8_align.abi;
+        let i8_align = bx.tcx().data_layout.i8_align;
         // Required in order for there to be no padding between the fields.
         assert!(i8_align <= ptr_align);
         let catch_data = bx.alloca(2 * ptr_size, ptr_align);
diff --git a/compiler/rustc_codegen_llvm/src/va_arg.rs b/compiler/rustc_codegen_llvm/src/va_arg.rs
index ab08125217ff5..4d6fc3e19c5c6 100644
--- a/compiler/rustc_codegen_llvm/src/va_arg.rs
+++ b/compiler/rustc_codegen_llvm/src/va_arg.rs
@@ -291,7 +291,7 @@ fn emit_powerpc_va_arg<'ll, 'tcx>(
         bx.inbounds_ptradd(va_list_addr, bx.const_usize(1)) // fpr
     };
 
-    let mut num_regs = bx.load(bx.type_i8(), num_regs_addr, dl.i8_align.abi);
+    let mut num_regs = bx.load(bx.type_i8(), num_regs_addr, dl.i8_align);
 
     // "Align" the register count when the type is passed as `i64`.
     if is_i64 || (is_f64 && is_soft_float_abi) {
@@ -329,7 +329,7 @@ fn emit_powerpc_va_arg<'ll, 'tcx>(
         // Increase the used-register count.
         let reg_incr = if is_i64 || (is_f64 && is_soft_float_abi) { 2 } else { 1 };
         let new_num_regs = bx.add(num_regs, bx.cx.const_u8(reg_incr));
-        bx.store(new_num_regs, num_regs_addr, dl.i8_align.abi);
+        bx.store(new_num_regs, num_regs_addr, dl.i8_align);
 
         bx.br(end);
 
@@ -339,7 +339,7 @@ fn emit_powerpc_va_arg<'ll, 'tcx>(
     let mem_addr = {
         bx.switch_to_block(in_mem);
 
-        bx.store(bx.const_u8(max_regs), num_regs_addr, dl.i8_align.abi);
+        bx.store(bx.const_u8(max_regs), num_regs_addr, dl.i8_align);
 
         // Everything in the overflow area is rounded up to a size of at least 4.
         let overflow_area_align = Align::from_bytes(4).unwrap();
@@ -813,7 +813,7 @@ fn emit_xtensa_va_arg<'ll, 'tcx>(
     let va_ndx_offset = va_reg_offset + 4;
     let offset_ptr = bx.inbounds_ptradd(va_list_addr, bx.cx.const_usize(va_ndx_offset));
 
-    let offset = bx.load(bx.type_i32(), offset_ptr, bx.tcx().data_layout.i32_align.abi);
+    let offset = bx.load(bx.type_i32(), offset_ptr, bx.tcx().data_layout.i32_align);
     let offset = round_up_to_alignment(bx, offset, layout.align.abi);
 
     let slot_size = layout.size.align_to(Align::from_bytes(4).unwrap()).bytes() as i32;
diff --git a/compiler/rustc_session/src/config/cfg.rs b/compiler/rustc_session/src/config/cfg.rs
index f3d91ce4a5dd8..a72f6201dcea2 100644
--- a/compiler/rustc_session/src/config/cfg.rs
+++ b/compiler/rustc_session/src/config/cfg.rs
@@ -259,11 +259,11 @@ pub(crate) fn default_configuration(sess: &Session) -> Cfg {
     });
     let mut has_atomic = false;
     for (i, align) in [
-        (8, layout.i8_align.abi),
-        (16, layout.i16_align.abi),
-        (32, layout.i32_align.abi),
-        (64, layout.i64_align.abi),
-        (128, layout.i128_align.abi),
+        (8, layout.i8_align),
+        (16, layout.i16_align),
+        (32, layout.i32_align),
+        (64, layout.i64_align),
+        (128, layout.i128_align),
     ] {
         if i >= sess.target.min_atomic_width() && i <= sess.target.max_atomic_width() {
             if !has_atomic {
diff --git a/compiler/rustc_target/src/callconv/mips.rs b/compiler/rustc_target/src/callconv/mips.rs
index 48a01da865b7c..8ffd7bd177849 100644
--- a/compiler/rustc_target/src/callconv/mips.rs
+++ b/compiler/rustc_target/src/callconv/mips.rs
@@ -24,7 +24,7 @@ where
     }
     let dl = cx.data_layout();
     let size = arg.layout.size;
-    let align = arg.layout.align.max(dl.i32_align).min(dl.i64_align).abi;
+    let align = arg.layout.align.abi.max(dl.i32_align).min(dl.i64_align);
 
     if arg.layout.is_aggregate() {
         let pad_i32 = !offset.is_aligned(align);
diff --git a/compiler/rustc_target/src/callconv/mips64.rs b/compiler/rustc_target/src/callconv/mips64.rs
index 0209838bec181..8386a15933c98 100644
--- a/compiler/rustc_target/src/callconv/mips64.rs
+++ b/compiler/rustc_target/src/callconv/mips64.rs
@@ -110,9 +110,9 @@ where
                 // We only care about aligned doubles
                 if let BackendRepr::Scalar(scalar) = field.backend_repr {
                     if scalar.primitive() == Primitive::Float(Float::F64) {
-                        if offset.is_aligned(dl.f64_align.abi) {
+                        if offset.is_aligned(dl.f64_align) {
                             // Insert enough integers to cover [last_offset, offset)
-                            assert!(last_offset.is_aligned(dl.f64_align.abi));
+                            assert!(last_offset.is_aligned(dl.f64_align));
                             for _ in 0..((offset - last_offset).bits() / 64)
                                 .min((prefix.len() - prefix_index) as u64)
                             {
diff --git a/compiler/rustc_target/src/callconv/mod.rs b/compiler/rustc_target/src/callconv/mod.rs
index 7a7c63c475b04..c59af581a1fe4 100644
--- a/compiler/rustc_target/src/callconv/mod.rs
+++ b/compiler/rustc_target/src/callconv/mod.rs
@@ -332,7 +332,7 @@ impl CastTarget {
         self.prefix
             .iter()
             .filter_map(|x| x.map(|reg| reg.align(cx)))
-            .fold(cx.data_layout().aggregate_align.abi.max(self.rest.align(cx)), |acc, align| {
+            .fold(cx.data_layout().aggregate_align.max(self.rest.align(cx)), |acc, align| {
                 acc.max(align)
             })
     }
diff --git a/compiler/rustc_target/src/callconv/sparc.rs b/compiler/rustc_target/src/callconv/sparc.rs
index 48a01da865b7c..8ffd7bd177849 100644
--- a/compiler/rustc_target/src/callconv/sparc.rs
+++ b/compiler/rustc_target/src/callconv/sparc.rs
@@ -24,7 +24,7 @@ where
     }
     let dl = cx.data_layout();
     let size = arg.layout.size;
-    let align = arg.layout.align.max(dl.i32_align).min(dl.i64_align).abi;
+    let align = arg.layout.align.abi.max(dl.i32_align).min(dl.i64_align);
 
     if arg.layout.is_aggregate() {
         let pad_i32 = !offset.is_aligned(align);
diff --git a/compiler/rustc_target/src/callconv/sparc64.rs b/compiler/rustc_target/src/callconv/sparc64.rs
index ecc9067ced35e..62c8ed1dc21b1 100644
--- a/compiler/rustc_target/src/callconv/sparc64.rs
+++ b/compiler/rustc_target/src/callconv/sparc64.rs
@@ -29,7 +29,7 @@ where
 
     data.has_float = true;
 
-    if !data.last_offset.is_aligned(dl.f64_align.abi) && data.last_offset < offset {
+    if !data.last_offset.is_aligned(dl.f64_align) && data.last_offset < offset {
         if data.prefix_index == data.prefix.len() {
             return data;
         }

From 77c96c031b40298a013befa2d3ebf11f459f9275 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Tue, 5 Aug 2025 23:07:11 +0200
Subject: [PATCH 1502/1889] clean-up

---
 tests/ui/double_parens.rs     |  9 +--------
 tests/ui/double_parens.stderr | 10 +++++-----
 2 files changed, 6 insertions(+), 13 deletions(-)

diff --git a/tests/ui/double_parens.rs b/tests/ui/double_parens.rs
index 7c976015b4e79..1e03033615950 100644
--- a/tests/ui/double_parens.rs
+++ b/tests/ui/double_parens.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::double_parens)]
-#![allow(dead_code, clippy::eq_op)]
+#![expect(clippy::eq_op)]
 #![feature(custom_inner_attributes)]
 #![rustfmt::skip]
 
@@ -14,32 +14,26 @@ impl DummyStruct {
 fn simple_double_parens() -> i32 {
     ((0))
     //~^ double_parens
-
-
 }
 
 fn fn_double_parens() {
     dummy_fn((0));
     //~^ double_parens
-
 }
 
 fn method_double_parens(x: DummyStruct) {
     x.dummy_method((0));
     //~^ double_parens
-
 }
 
 fn tuple_double_parens() -> (i32, i32) {
     ((1, 2))
     //~^ double_parens
-
 }
 
 fn unit_double_parens() {
     (())
     //~^ double_parens
-
 }
 
 fn fn_tuple_ok() {
@@ -63,7 +57,6 @@ fn inside_macro() {
     assert_eq!((1, 2), (1, 2), "Error");
     assert_eq!(((1, 2)), (1, 2), "Error");
     //~^ double_parens
-
 }
 
 fn main() {}
diff --git a/tests/ui/double_parens.stderr b/tests/ui/double_parens.stderr
index e119f54949b1f..da48219c97e10 100644
--- a/tests/ui/double_parens.stderr
+++ b/tests/ui/double_parens.stderr
@@ -8,31 +8,31 @@ LL |     ((0))
    = help: to override `-D warnings` add `#[allow(clippy::double_parens)]`
 
 error: consider removing unnecessary double parentheses
-  --> tests/ui/double_parens.rs:22:14
+  --> tests/ui/double_parens.rs:20:14
    |
 LL |     dummy_fn((0));
    |              ^^^
 
 error: consider removing unnecessary double parentheses
-  --> tests/ui/double_parens.rs:28:20
+  --> tests/ui/double_parens.rs:25:20
    |
 LL |     x.dummy_method((0));
    |                    ^^^
 
 error: consider removing unnecessary double parentheses
-  --> tests/ui/double_parens.rs:34:5
+  --> tests/ui/double_parens.rs:30:5
    |
 LL |     ((1, 2))
    |     ^^^^^^^^
 
 error: consider removing unnecessary double parentheses
-  --> tests/ui/double_parens.rs:40:5
+  --> tests/ui/double_parens.rs:35:5
    |
 LL |     (())
    |     ^^^^
 
 error: consider removing unnecessary double parentheses
-  --> tests/ui/double_parens.rs:64:16
+  --> tests/ui/double_parens.rs:58:16
    |
 LL |     assert_eq!(((1, 2)), (1, 2), "Error");
    |                ^^^^^^^^

From dbef783309a6692bd0e6573055f3e6252d444708 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Fri, 22 Aug 2025 18:13:08 +0200
Subject: [PATCH 1503/1889] call args "args" in the `Call` case as well

since that's what they are
---
 clippy_lints/src/double_parens.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/clippy_lints/src/double_parens.rs b/clippy_lints/src/double_parens.rs
index 4dd8f01ee7090..73078547c695d 100644
--- a/clippy_lints/src/double_parens.rs
+++ b/clippy_lints/src/double_parens.rs
@@ -42,11 +42,11 @@ impl EarlyLintPass for DoubleParens {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
         let span = match &expr.kind {
             ExprKind::Paren(in_paren) if matches!(in_paren.kind, ExprKind::Paren(_) | ExprKind::Tup(_)) => expr.span,
-            ExprKind::Call(_, params)
-                if let [param] = &**params
-                    && let ExprKind::Paren(_) = param.kind =>
+            ExprKind::Call(_, args)
+                if let [args] = &**args
+                    && let ExprKind::Paren(_) = args.kind =>
             {
-                param.span
+                args.span
             },
             ExprKind::MethodCall(call)
                 if let [arg] = &*call.args

From 6a6b4a3ba8ef0793f275e9eb8351f8acea72e8f1 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Fri, 22 Aug 2025 18:14:04 +0200
Subject: [PATCH 1504/1889] combine the `Call` and `MethodCall` cases

---
 clippy_lints/src/double_parens.rs | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/clippy_lints/src/double_parens.rs b/clippy_lints/src/double_parens.rs
index 73078547c695d..d014efcde48dd 100644
--- a/clippy_lints/src/double_parens.rs
+++ b/clippy_lints/src/double_parens.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint;
-use rustc_ast::ast::{Expr, ExprKind};
+use rustc_ast::ast::{Expr, ExprKind, MethodCall};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::declare_lint_pass;
 
@@ -42,18 +42,12 @@ impl EarlyLintPass for DoubleParens {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
         let span = match &expr.kind {
             ExprKind::Paren(in_paren) if matches!(in_paren.kind, ExprKind::Paren(_) | ExprKind::Tup(_)) => expr.span,
-            ExprKind::Call(_, args)
+            ExprKind::Call(_, args) | ExprKind::MethodCall(box MethodCall { args, .. })
                 if let [args] = &**args
                     && let ExprKind::Paren(_) = args.kind =>
             {
                 args.span
             },
-            ExprKind::MethodCall(call)
-                if let [arg] = &*call.args
-                    && let ExprKind::Paren(_) = arg.kind =>
-            {
-                arg.span
-            },
             _ => return,
         };
         if !expr.span.from_expansion() {

From 82b2eb13f8ed8777c97cdceb94137a4ed73d43f6 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Fri, 22 Aug 2025 18:18:03 +0200
Subject: [PATCH 1505/1889] add structured suggestions

---
 clippy_lints/src/double_parens.rs | 62 ++++++++++++++++++++++--------
 tests/ui/double_parens.fixed      | 63 +++++++++++++++++++++++++++++++
 tests/ui/double_parens.rs         |  1 +
 tests/ui/double_parens.stderr     | 28 +++++++-------
 4 files changed, 124 insertions(+), 30 deletions(-)
 create mode 100644 tests/ui/double_parens.fixed

diff --git a/clippy_lints/src/double_parens.rs b/clippy_lints/src/double_parens.rs
index d014efcde48dd..ab6e477121207 100644
--- a/clippy_lints/src/double_parens.rs
+++ b/clippy_lints/src/double_parens.rs
@@ -1,5 +1,7 @@
-use clippy_utils::diagnostics::span_lint;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::{HasSession, snippet_with_applicability};
 use rustc_ast::ast::{Expr, ExprKind, MethodCall};
+use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::declare_lint_pass;
 
@@ -24,7 +26,7 @@ declare_clippy_lint! {
     /// Use instead:
     /// ```no_run
     /// fn simple_no_parens() -> i32 {
-    ///     0
+    ///     (0)
     /// }
     ///
     /// # fn foo(bar: usize) {}
@@ -40,23 +42,51 @@ declare_lint_pass!(DoubleParens => [DOUBLE_PARENS]);
 
 impl EarlyLintPass for DoubleParens {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
-        let span = match &expr.kind {
-            ExprKind::Paren(in_paren) if matches!(in_paren.kind, ExprKind::Paren(_) | ExprKind::Tup(_)) => expr.span,
+        if expr.span.from_expansion() {
+            return;
+        }
+
+        match &expr.kind {
+            // ((..))
+            // ^^^^^^ expr
+            //  ^^^^  inner
+            ExprKind::Paren(inner) if matches!(inner.kind, ExprKind::Paren(_) | ExprKind::Tup(_)) => {
+                // suggest removing the outer parens
+                let mut applicability = Applicability::MachineApplicable;
+                let sugg = snippet_with_applicability(cx.sess(), inner.span, "_", &mut applicability);
+                span_lint_and_sugg(
+                    cx,
+                    DOUBLE_PARENS,
+                    expr.span,
+                    "unnecessary parentheses",
+                    "remove them",
+                    sugg.to_string(),
+                    applicability,
+                );
+            },
+
+            // func((n))
+            // ^^^^^^^^^ expr
+            //      ^^^  arg
+            //       ^   inner
             ExprKind::Call(_, args) | ExprKind::MethodCall(box MethodCall { args, .. })
-                if let [args] = &**args
-                    && let ExprKind::Paren(_) = args.kind =>
+                if let [arg] = &**args
+                    && let ExprKind::Paren(inner) = &arg.kind =>
             {
-                args.span
+                // suggest removing the inner parens
+                let mut applicability = Applicability::MachineApplicable;
+                let sugg = snippet_with_applicability(cx.sess(), inner.span, "_", &mut applicability);
+                span_lint_and_sugg(
+                    cx,
+                    DOUBLE_PARENS,
+                    arg.span,
+                    "unnecessary parentheses",
+                    "remove them",
+                    sugg.to_string(),
+                    applicability,
+                );
             },
-            _ => return,
-        };
-        if !expr.span.from_expansion() {
-            span_lint(
-                cx,
-                DOUBLE_PARENS,
-                span,
-                "consider removing unnecessary double parentheses",
-            );
+            _ => {},
         }
     }
 }
diff --git a/tests/ui/double_parens.fixed b/tests/ui/double_parens.fixed
new file mode 100644
index 0000000000000..7fa116942fe85
--- /dev/null
+++ b/tests/ui/double_parens.fixed
@@ -0,0 +1,63 @@
+#![warn(clippy::double_parens)]
+#![expect(clippy::eq_op)]
+#![feature(custom_inner_attributes)]
+#![rustfmt::skip]
+
+fn dummy_fn<T>(_: T) {}
+
+struct DummyStruct;
+
+impl DummyStruct {
+    fn dummy_method<T>(self, _: T) {}
+}
+
+fn simple_double_parens() -> i32 {
+    (0)
+    //~^ double_parens
+}
+
+fn fn_double_parens() {
+    dummy_fn(0);
+    //~^ double_parens
+}
+
+fn method_double_parens(x: DummyStruct) {
+    x.dummy_method(0);
+    //~^ double_parens
+}
+
+fn tuple_double_parens() -> (i32, i32) {
+    (1, 2)
+    //~^ double_parens
+}
+
+#[allow(clippy::unused_unit)]
+fn unit_double_parens() {
+    ()
+    //~^ double_parens
+}
+
+fn fn_tuple_ok() {
+    dummy_fn((1, 2));
+}
+
+fn method_tuple_ok(x: DummyStruct) {
+    x.dummy_method((1, 2));
+}
+
+fn fn_unit_ok() {
+    dummy_fn(());
+}
+
+fn method_unit_ok(x: DummyStruct) {
+    x.dummy_method(());
+}
+
+// Issue #3206
+fn inside_macro() {
+    assert_eq!((1, 2), (1, 2), "Error");
+    assert_eq!((1, 2), (1, 2), "Error");
+    //~^ double_parens
+}
+
+fn main() {}
diff --git a/tests/ui/double_parens.rs b/tests/ui/double_parens.rs
index 1e03033615950..8730b4b124689 100644
--- a/tests/ui/double_parens.rs
+++ b/tests/ui/double_parens.rs
@@ -31,6 +31,7 @@ fn tuple_double_parens() -> (i32, i32) {
     //~^ double_parens
 }
 
+#[allow(clippy::unused_unit)]
 fn unit_double_parens() {
     (())
     //~^ double_parens
diff --git a/tests/ui/double_parens.stderr b/tests/ui/double_parens.stderr
index da48219c97e10..2b37877ccdd86 100644
--- a/tests/ui/double_parens.stderr
+++ b/tests/ui/double_parens.stderr
@@ -1,41 +1,41 @@
-error: consider removing unnecessary double parentheses
+error: unnecessary parentheses
   --> tests/ui/double_parens.rs:15:5
    |
 LL |     ((0))
-   |     ^^^^^
+   |     ^^^^^ help: remove them: `(0)`
    |
    = note: `-D clippy::double-parens` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::double_parens)]`
 
-error: consider removing unnecessary double parentheses
+error: unnecessary parentheses
   --> tests/ui/double_parens.rs:20:14
    |
 LL |     dummy_fn((0));
-   |              ^^^
+   |              ^^^ help: remove them: `0`
 
-error: consider removing unnecessary double parentheses
+error: unnecessary parentheses
   --> tests/ui/double_parens.rs:25:20
    |
 LL |     x.dummy_method((0));
-   |                    ^^^
+   |                    ^^^ help: remove them: `0`
 
-error: consider removing unnecessary double parentheses
+error: unnecessary parentheses
   --> tests/ui/double_parens.rs:30:5
    |
 LL |     ((1, 2))
-   |     ^^^^^^^^
+   |     ^^^^^^^^ help: remove them: `(1, 2)`
 
-error: consider removing unnecessary double parentheses
-  --> tests/ui/double_parens.rs:35:5
+error: unnecessary parentheses
+  --> tests/ui/double_parens.rs:36:5
    |
 LL |     (())
-   |     ^^^^
+   |     ^^^^ help: remove them: `()`
 
-error: consider removing unnecessary double parentheses
-  --> tests/ui/double_parens.rs:58:16
+error: unnecessary parentheses
+  --> tests/ui/double_parens.rs:59:16
    |
 LL |     assert_eq!(((1, 2)), (1, 2), "Error");
-   |                ^^^^^^^^
+   |                ^^^^^^^^ help: remove them: `(1, 2)`
 
 error: aborting due to 6 previous errors
 

From cc7bd291cdd76f1e1ef83223ec7bec4077646ac7 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sun, 28 Sep 2025 17:17:44 +1000
Subject: [PATCH 1506/1889] Fix change-tracker entry for 147046

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

diff --git a/src/bootstrap/src/utils/change_tracker.rs b/src/bootstrap/src/utils/change_tracker.rs
index f311c84bec9b5..0123bd6340e50 100644
--- a/src/bootstrap/src/utils/change_tracker.rs
+++ b/src/bootstrap/src/utils/change_tracker.rs
@@ -557,7 +557,7 @@ pub const CONFIG_CHANGE_HISTORY: &[ChangeInfo] = &[
         summary: "New option `build.windows-rc` that will override which resource compiler on Windows will be used to compile Rust.",
     },
     ChangeInfo {
-        change_id: 99999,
+        change_id: 147046,
         severity: ChangeSeverity::Warning,
         summary: "The `rust.use-lld` option has been renamed to `rust.bootstrap-override-lld`. Note that it only serves for overriding the linker used when building Rust code in bootstrap to be LLD.",
     },

From e99364ea357957b33460664fc496a3a8c218494e Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 23 Sep 2025 18:12:33 +1000
Subject: [PATCH 1507/1889] Remove old-output-capture from compiletest

---
 src/tools/compiletest/src/common.rs   |  9 -------
 src/tools/compiletest/src/executor.rs | 35 ++++++++-------------------
 src/tools/compiletest/src/lib.rs      | 32 ------------------------
 3 files changed, 10 insertions(+), 66 deletions(-)

diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
index 6da102b1b5f11..6d9599489180b 100644
--- a/src/tools/compiletest/src/common.rs
+++ b/src/tools/compiletest/src/common.rs
@@ -661,18 +661,10 @@ pub struct Config {
     pub builtin_cfg_names: OnceLock<HashSet<String>>,
     pub supported_crate_types: OnceLock<HashSet<String>>,
 
-    /// FIXME: this is why we still need to depend on *staged* `std`, it's because we currently rely
-    /// on `#![feature(internal_output_capture)]` for [`std::io::set_output_capture`] to implement
-    /// `libtest`-esque `--no-capture`.
-    ///
     /// FIXME: rename this to the more canonical `no_capture`, or better, invert this to `capture`
     /// to avoid `!nocapture` double-negatives.
     pub nocapture: bool,
 
-    /// True if the experimental new output-capture implementation should be
-    /// used, avoiding the need for `#![feature(internal_output_capture)]`.
-    pub new_output_capture: bool,
-
     /// Needed both to construct [`build_helper::git::GitConfig`].
     pub nightly_branch: String,
     pub git_merge_commit_email: String,
@@ -790,7 +782,6 @@ impl Config {
             builtin_cfg_names: Default::default(),
             supported_crate_types: Default::default(),
             nocapture: Default::default(),
-            new_output_capture: Default::default(),
             nightly_branch: Default::default(),
             git_merge_commit_email: Default::default(),
             profiler_runtime: Default::default(),
diff --git a/src/tools/compiletest/src/executor.rs b/src/tools/compiletest/src/executor.rs
index c8e13d4457383..c7aca6d1c5aaa 100644
--- a/src/tools/compiletest/src/executor.rs
+++ b/src/tools/compiletest/src/executor.rs
@@ -9,8 +9,8 @@ use std::borrow::Cow;
 use std::collections::HashMap;
 use std::hash::{BuildHasherDefault, DefaultHasher};
 use std::num::NonZero;
-use std::sync::{Arc, Mutex, mpsc};
-use std::{env, hint, io, mem, panic, thread};
+use std::sync::{Arc, mpsc};
+use std::{env, hint, mem, panic, thread};
 
 use camino::Utf8PathBuf;
 
@@ -130,10 +130,6 @@ fn run_test_inner(
         panic_hook::set_capture_buf(Default::default());
     }
 
-    if let CaptureKind::Old { ref buf } = capture {
-        io::set_output_capture(Some(Arc::clone(buf)));
-    }
-
     let stdout = capture.stdout();
     let stderr = capture.stderr();
 
@@ -144,9 +140,6 @@ fn run_test_inner(
         // Forward any captured panic message to (captured) stderr.
         write!(stderr, "{panic_buf}");
     }
-    if matches!(capture, CaptureKind::Old { .. }) {
-        io::set_output_capture(None);
-    }
 
     let outcome = match (should_panic, panic_payload) {
         (ShouldPanic::No, None) | (ShouldPanic::Yes, Some(_)) => TestOutcome::Succeeded,
@@ -167,31 +160,24 @@ enum CaptureKind {
     /// runners, whose output is always captured.)
     None,
 
-    /// Use the old output-capture implementation, which relies on the unstable
-    /// library feature `#![feature(internal_output_capture)]`.
-    Old { buf: Arc<Mutex<Vec<u8>>> },
-
-    /// Use the new output-capture implementation, which only uses stable Rust.
-    New { buf: output_capture::CaptureBuf },
+    /// Capture all console output that would be printed by test runners via
+    /// their `stdout` and `stderr` trait objects, or via the custom panic hook.
+    Capture { buf: output_capture::CaptureBuf },
 }
 
 impl CaptureKind {
     fn for_config(config: &Config) -> Self {
         if config.nocapture {
             Self::None
-        } else if config.new_output_capture {
-            Self::New { buf: output_capture::CaptureBuf::new() }
         } else {
-            // Create a capure buffer for `io::set_output_capture`.
-            Self::Old { buf: Default::default() }
+            Self::Capture { buf: output_capture::CaptureBuf::new() }
         }
     }
 
     fn should_set_panic_hook(&self) -> bool {
         match self {
             Self::None => false,
-            Self::Old { .. } => true,
-            Self::New { .. } => true,
+            Self::Capture { .. } => true,
         }
     }
 
@@ -205,16 +191,15 @@ impl CaptureKind {
 
     fn capture_buf_or<'a>(&'a self, fallback: &'a dyn ConsoleOut) -> &'a dyn ConsoleOut {
         match self {
-            Self::None | Self::Old { .. } => fallback,
-            Self::New { buf } => buf,
+            Self::None => fallback,
+            Self::Capture { buf } => buf,
         }
     }
 
     fn into_inner(self) -> Option<Vec<u8>> {
         match self {
             Self::None => None,
-            Self::Old { buf } => Some(buf.lock().unwrap_or_else(|e| e.into_inner()).to_vec()),
-            Self::New { buf } => Some(buf.into_inner().into()),
+            Self::Capture { buf } => Some(buf.into_inner().into()),
         }
     }
 }
diff --git a/src/tools/compiletest/src/lib.rs b/src/tools/compiletest/src/lib.rs
index ce2a3d4b5fbb2..15e31dadf9711 100644
--- a/src/tools/compiletest/src/lib.rs
+++ b/src/tools/compiletest/src/lib.rs
@@ -1,9 +1,4 @@
 #![crate_name = "compiletest"]
-// Needed by the "new" test executor that does not depend on libtest.
-// FIXME(Zalathar): We should be able to get rid of `internal_output_capture`,
-// by having `runtest` manually capture all of its println-like output instead.
-// That would result in compiletest being written entirely in stable Rust!
-#![feature(internal_output_capture)]
 
 #[cfg(test)]
 mod tests;
@@ -178,12 +173,6 @@ pub fn parse_config(args: Vec<String>) -> Config {
         // FIXME: Temporarily retained so we can point users to `--no-capture`
         .optflag("", "nocapture", "")
         .optflag("", "no-capture", "don't capture stdout/stderr of tests")
-        .optopt(
-            "N",
-            "new-output-capture",
-            "enables or disables the new output-capture implementation",
-            "off|on",
-        )
         .optflag("", "profiler-runtime", "is the profiler runtime enabled for this target")
         .optflag("h", "help", "show this message")
         .reqopt("", "channel", "current Rust channel", "CHANNEL")
@@ -480,14 +469,6 @@ pub fn parse_config(args: Vec<String>) -> Config {
         supported_crate_types: OnceLock::new(),
 
         nocapture: matches.opt_present("no-capture"),
-        new_output_capture: {
-            let value = matches
-                .opt_str("new-output-capture")
-                .or_else(|| env::var("COMPILETEST_NEW_OUTPUT_CAPTURE").ok())
-                .unwrap_or_else(|| "on".to_owned());
-            parse_bool_option(&value)
-                .unwrap_or_else(|| panic!("unknown `--new-output-capture` value `{value}` given"))
-        },
 
         nightly_branch: matches.opt_str("nightly-branch").unwrap(),
         git_merge_commit_email: matches.opt_str("git-merge-commit-email").unwrap(),
@@ -503,19 +484,6 @@ pub fn parse_config(args: Vec<String>) -> Config {
     }
 }
 
-/// Parses the same set of boolean values accepted by rustc command-line arguments.
-///
-/// Accepting all of these values is more complicated than just picking one
-/// pair, but has the advantage that contributors who are used to rustc
-/// shouldn't have to think about which values are legal.
-fn parse_bool_option(value: &str) -> Option<bool> {
-    match value {
-        "off" | "no" | "n" | "false" => Some(false),
-        "on" | "yes" | "y" | "true" => Some(true),
-        _ => None,
-    }
-}
-
 pub fn opt_str(maybestr: &Option<String>) -> &str {
     match *maybestr {
         None => "(none)",

From 7b8ae74da119e9ba025baeca60c22376f30d1307 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 23 Sep 2025 21:38:11 +1000
Subject: [PATCH 1508/1889] Add a bootstrap snapshot test for `x test
 compiletest`

---
 src/bootstrap/src/core/builder/tests.rs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index a3c8380a3c7d6..66771fbf41c0a 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -2145,6 +2145,18 @@ mod snapshot {
         ");
     }
 
+    #[test]
+    fn test_compiletest_self_test() {
+        let ctx = TestCtx::new();
+        let steps = ctx.config("test").arg("compiletest").render_steps();
+        insta::assert_snapshot!(steps, @r"
+        [build] llvm <host>
+        [build] rustc 0 <host> -> rustc 1 <host>
+        [build] rustc 1 <host> -> std 1 <host>
+        [build] rustdoc 1 <host>
+        ");
+    }
+
     #[test]
     fn test_compiletest_suites_stage1() {
         let ctx = TestCtx::new();

From 193f7179cca1c3b01eb7f2587616a95999e51903 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 23 Sep 2025 18:22:56 +1000
Subject: [PATCH 1509/1889] Build and test compiletest as a stage0 bootstrap
 tool

---
 src/bootstrap/src/core/build_steps/check.rs | 11 +++-----
 src/bootstrap/src/core/build_steps/test.rs  | 29 ++++++++++-----------
 src/bootstrap/src/core/build_steps/tool.rs  | 18 +++----------
 src/bootstrap/src/core/builder/tests.rs     | 18 +------------
 src/bootstrap/src/core/config/config.rs     |  7 ++---
 src/bootstrap/src/core/config/mod.rs        | 10 +++++--
 src/bootstrap/src/core/config/toml/build.rs |  2 ++
 src/bootstrap/src/lib.rs                    |  4 +--
 src/bootstrap/src/utils/change_tracker.rs   |  5 ++++
 9 files changed, 40 insertions(+), 64 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/check.rs b/src/bootstrap/src/core/build_steps/check.rs
index 043457f64e57a..27f259d420798 100644
--- a/src/bootstrap/src/core/build_steps/check.rs
+++ b/src/bootstrap/src/core/build_steps/check.rs
@@ -8,8 +8,8 @@ use crate::core::build_steps::compile::{
 };
 use crate::core::build_steps::tool;
 use crate::core::build_steps::tool::{
-    COMPILETEST_ALLOW_FEATURES, SourceType, TEST_FLOAT_PARSE_ALLOW_FEATURES, ToolTargetBuildMode,
-    get_tool_target_compiler, prepare_tool_cargo,
+    SourceType, TEST_FLOAT_PARSE_ALLOW_FEATURES, ToolTargetBuildMode, get_tool_target_compiler,
+    prepare_tool_cargo,
 };
 use crate::core::builder::{
     self, Alias, Builder, Cargo, Kind, RunConfig, ShouldRun, Step, StepMetadata, crate_description,
@@ -825,12 +825,7 @@ tool_check_step!(CoverageDump {
 // so this is mainly for people working on compiletest to run locally.
 tool_check_step!(Compiletest {
     path: "src/tools/compiletest",
-    mode: |builder: &Builder<'_>| if builder.config.compiletest_use_stage0_libtest {
-        Mode::ToolBootstrap
-    } else {
-        Mode::ToolStd
-    },
-    allow_features: COMPILETEST_ALLOW_FEATURES,
+    mode: |_builder| Mode::ToolBootstrap,
     default: false,
 });
 
diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index ca2731819e7e0..00aea8feab7de 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -18,8 +18,8 @@ use crate::core::build_steps::llvm::get_llvm_version;
 use crate::core::build_steps::run::get_completion_paths;
 use crate::core::build_steps::synthetic_targets::MirOptPanicAbortSyntheticTarget;
 use crate::core::build_steps::tool::{
-    self, COMPILETEST_ALLOW_FEATURES, RustcPrivateCompilers, SourceType,
-    TEST_FLOAT_PARSE_ALLOW_FEATURES, Tool, ToolTargetBuildMode, get_tool_target_compiler,
+    self, RustcPrivateCompilers, SourceType, TEST_FLOAT_PARSE_ALLOW_FEATURES, Tool,
+    ToolTargetBuildMode, get_tool_target_compiler,
 };
 use crate::core::build_steps::toolstate::ToolState;
 use crate::core::build_steps::{compile, dist, llvm};
@@ -36,7 +36,7 @@ use crate::utils::helpers::{
     linker_args, linker_flags, t, target_supports_cranelift_backend, up_to_date,
 };
 use crate::utils::render_tests::{add_flags_and_try_run_tests, try_run_tests};
-use crate::{CLang, CodegenBackendKind, DocTests, GitRepo, Mode, PathSet, debug, envify};
+use crate::{CLang, CodegenBackendKind, DocTests, GitRepo, Mode, PathSet, envify};
 
 const ADB_TEST_DIR: &str = "/data/local/tmp/work";
 
@@ -786,26 +786,26 @@ impl Step for CompiletestTest {
     fn run(self, builder: &Builder<'_>) {
         let host = self.host;
 
+        // Now that compiletest uses only stable Rust, building it always uses
+        // the stage 0 compiler. However, some of its unit tests need to be able
+        // to query information from an in-tree compiler, so we treat `--stage`
+        // as selecting the stage of that secondary compiler.
+
         if builder.top_stage == 0 && !builder.config.compiletest_allow_stage0 {
             eprintln!("\
-ERROR: `--stage 0` runs compiletest self-tests against the stage0 (precompiled) compiler, not the in-tree compiler, and will almost always cause tests to fail
+ERROR: `--stage 0` causes compiletest to query information from the stage0 (precompiled) compiler, instead of the in-tree compiler, which can cause some tests to fail inappropriately
 NOTE: if you're sure you want to do this, please open an issue as to why. In the meantime, you can override this with `--set build.compiletest-allow-stage0=true`."
             );
             crate::exit!(1);
         }
 
-        let compiler = builder.compiler(builder.top_stage, host);
-        debug!(?compiler);
+        let bootstrap_compiler = builder.compiler(0, host);
+        let staged_compiler = builder.compiler(builder.top_stage, host);
 
-        // We need `ToolStd` for the locally-built sysroot because
-        // compiletest uses unstable features of the `test` crate.
-        builder.std(compiler, host);
         let mut cargo = tool::prepare_tool_cargo(
             builder,
-            compiler,
-            // compiletest uses libtest internals; make it use the in-tree std to make sure it never
-            // breaks when std sources change.
-            Mode::ToolStd,
+            bootstrap_compiler,
+            Mode::ToolBootstrap,
             host,
             Kind::Test,
             "src/tools/compiletest",
@@ -816,9 +816,8 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
         // Used for `compiletest` self-tests to have the path to the *staged* compiler. Getting this
         // right is important, as `compiletest` is intended to only support one target spec JSON
         // format, namely that of the staged compiler.
-        cargo.env("TEST_RUSTC", builder.rustc(compiler));
+        cargo.env("TEST_RUSTC", builder.rustc(staged_compiler));
 
-        cargo.allow_features(COMPILETEST_ALLOW_FEATURES);
         run_cargo_test(cargo, &[], &[], "compiletest self test", host, builder);
     }
 }
diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
index 4f096d50ea5c3..819e903020c8e 100644
--- a/src/bootstrap/src/core/build_steps/tool.rs
+++ b/src/bootstrap/src/core/build_steps/tool.rs
@@ -380,7 +380,6 @@ macro_rules! bootstrap_tool {
     ($(
         $name:ident, $path:expr, $tool_name:expr
         $(,is_external_tool = $external:expr)*
-        $(,is_unstable_tool = $unstable:expr)*
         $(,allow_features = $allow_features:expr)?
         $(,submodules = $submodules:expr)?
         $(,artifact_kind = $artifact_kind:expr)?
@@ -438,19 +437,11 @@ macro_rules! bootstrap_tool {
                     }
                 )*
 
-                let is_unstable = false $(|| $unstable)*;
-                let compiletest_wants_stage0 = $tool_name == "compiletest" && builder.config.compiletest_use_stage0_libtest;
-
                 builder.ensure(ToolBuild {
                     build_compiler: self.compiler,
                     target: self.target,
                     tool: $tool_name,
-                    mode: if is_unstable && !compiletest_wants_stage0 {
-                        // use in-tree libraries for unstable features
-                        Mode::ToolStd
-                    } else {
-                        Mode::ToolBootstrap
-                    },
+                    mode: Mode::ToolBootstrap,
                     path: $path,
                     source_type: if false $(|| $external)* {
                         SourceType::Submodule
@@ -483,8 +474,6 @@ macro_rules! bootstrap_tool {
     }
 }
 
-pub(crate) const COMPILETEST_ALLOW_FEATURES: &str = "internal_output_capture";
-
 bootstrap_tool!(
     // This is marked as an external tool because it includes dependencies
     // from submodules. Trying to keep the lints in sync between all the repos
@@ -495,7 +484,7 @@ bootstrap_tool!(
     Tidy, "src/tools/tidy", "tidy";
     Linkchecker, "src/tools/linkchecker", "linkchecker";
     CargoTest, "src/tools/cargotest", "cargotest";
-    Compiletest, "src/tools/compiletest", "compiletest", is_unstable_tool = true, allow_features = COMPILETEST_ALLOW_FEATURES;
+    Compiletest, "src/tools/compiletest", "compiletest";
     BuildManifest, "src/tools/build-manifest", "build-manifest";
     RemoteTestClient, "src/tools/remote-test-client", "remote-test-client";
     RustInstaller, "src/tools/rust-installer", "rust-installer";
@@ -509,8 +498,7 @@ bootstrap_tool!(
     CollectLicenseMetadata, "src/tools/collect-license-metadata", "collect-license-metadata";
     GenerateCopyright, "src/tools/generate-copyright", "generate-copyright";
     GenerateWindowsSys, "src/tools/generate-windows-sys", "generate-windows-sys";
-    // rustdoc-gui-test has a crate dependency on compiletest, so it needs the same unstable features.
-    RustdocGUITest, "src/tools/rustdoc-gui-test", "rustdoc-gui-test", is_unstable_tool = true, allow_features = COMPILETEST_ALLOW_FEATURES;
+    RustdocGUITest, "src/tools/rustdoc-gui-test", "rustdoc-gui-test";
     CoverageDump, "src/tools/coverage-dump", "coverage-dump";
     UnicodeTableGenerator, "src/tools/unicode-table-generator", "unicode-table-generator";
     FeaturesStatusDump, "src/tools/features-status-dump", "features-status-dump";
diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index 66771fbf41c0a..88df469e9a099 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -2004,21 +2004,6 @@ mod snapshot {
                 .render_steps(), @"[check] rustc 0 <host> -> Compiletest 1 <host>");
     }
 
-    #[test]
-    fn check_compiletest_stage1_libtest() {
-        let ctx = TestCtx::new();
-        insta::assert_snapshot!(
-            ctx.config("check")
-                .path("compiletest")
-                .args(&["--set", "build.compiletest-use-stage0-libtest=false"])
-                .render_steps(), @r"
-        [build] llvm <host>
-        [build] rustc 0 <host> -> rustc 1 <host>
-        [build] rustc 1 <host> -> std 1 <host>
-        [check] rustc 1 <host> -> Compiletest 2 <host>
-        ");
-    }
-
     #[test]
     fn check_codegen() {
         let ctx = TestCtx::new();
@@ -2152,8 +2137,7 @@ mod snapshot {
         insta::assert_snapshot!(steps, @r"
         [build] llvm <host>
         [build] rustc 0 <host> -> rustc 1 <host>
-        [build] rustc 1 <host> -> std 1 <host>
-        [build] rustdoc 1 <host>
+        [build] rustdoc 0 <host>
         ");
     }
 
diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index 271ce4cb950bb..1fcc1174e856c 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -310,9 +310,6 @@ pub struct Config {
     /// sources.
     pub compiletest_allow_stage0: bool,
 
-    /// Whether to use the precompiled stage0 libtest with compiletest.
-    pub compiletest_use_stage0_libtest: bool,
-
     /// Default value for `--extra-checks`
     pub tidy_extra_checks: Option<String>,
     pub is_running_on_ci: bool,
@@ -497,7 +494,8 @@ impl Config {
             optimized_compiler_builtins: build_optimized_compiler_builtins,
             jobs: build_jobs,
             compiletest_diff_tool: build_compiletest_diff_tool,
-            compiletest_use_stage0_libtest: build_compiletest_use_stage0_libtest,
+            // No longer has any effect; kept (for now) to avoid breaking people's configs.
+            compiletest_use_stage0_libtest: _,
             tidy_extra_checks: build_tidy_extra_checks,
             ccache: build_ccache,
             exclude: build_exclude,
@@ -1197,7 +1195,6 @@ impl Config {
             compiler_docs: build_compiler_docs.unwrap_or(false),
             compiletest_allow_stage0: build_compiletest_allow_stage0.unwrap_or(false),
             compiletest_diff_tool: build_compiletest_diff_tool,
-            compiletest_use_stage0_libtest: build_compiletest_use_stage0_libtest.unwrap_or(true),
             config: toml_path,
             configure_args: build_configure_args.unwrap_or_default(),
             control_flow_guard: rust_control_flow_guard.unwrap_or(false),
diff --git a/src/bootstrap/src/core/config/mod.rs b/src/bootstrap/src/core/config/mod.rs
index 56b87823a3654..007ed4aaba13f 100644
--- a/src/bootstrap/src/core/config/mod.rs
+++ b/src/bootstrap/src/core/config/mod.rs
@@ -47,11 +47,17 @@ use crate::str::FromStr;
 #[macro_export]
 macro_rules! define_config {
     ($(#[$attr:meta])* struct $name:ident {
-        $($field:ident: Option<$field_ty:ty> = $field_key:literal,)*
+        $(
+            $(#[$field_attr:meta])*
+            $field:ident: Option<$field_ty:ty> = $field_key:literal,
+        )*
     }) => {
         $(#[$attr])*
         pub struct $name {
-            $(pub $field: Option<$field_ty>,)*
+            $(
+                $(#[$field_attr])*
+                pub $field: Option<$field_ty>,
+            )*
         }
 
         impl Merge for $name {
diff --git a/src/bootstrap/src/core/config/toml/build.rs b/src/bootstrap/src/core/config/toml/build.rs
index a9d4d3961c9b7..c63673dd98089 100644
--- a/src/bootstrap/src/core/config/toml/build.rs
+++ b/src/bootstrap/src/core/config/toml/build.rs
@@ -70,6 +70,8 @@ define_config! {
         jobs: Option<u32> = "jobs",
         compiletest_diff_tool: Option<String> = "compiletest-diff-tool",
         compiletest_allow_stage0: Option<bool> = "compiletest-allow-stage0",
+        /// No longer has any effect; kept (for now) to avoid breaking people's configs.
+        /// FIXME(#146929): Remove this in 2026.
         compiletest_use_stage0_libtest: Option<bool> = "compiletest-use-stage0-libtest",
         tidy_extra_checks: Option<String> = "tidy-extra-checks",
         ccache: Option<StringOrBool> = "ccache",
diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs
index d798639cc967e..dd30f05b72832 100644
--- a/src/bootstrap/src/lib.rs
+++ b/src/bootstrap/src/lib.rs
@@ -327,8 +327,8 @@ pub enum Mode {
     ToolTarget,
 
     /// Build a tool which uses the locally built std, placing output in the
-    /// "stageN-tools" directory. Its usage is quite rare, mainly used by
-    /// compiletest which needs libtest.
+    /// "stageN-tools" directory. Its usage is quite rare; historically it was
+    /// needed by compiletest, but now it is mainly used by `test-float-parse`.
     ToolStd,
 
     /// Build a tool which uses the `rustc_private` mechanism, and thus
diff --git a/src/bootstrap/src/utils/change_tracker.rs b/src/bootstrap/src/utils/change_tracker.rs
index 0123bd6340e50..853fc4e6623e9 100644
--- a/src/bootstrap/src/utils/change_tracker.rs
+++ b/src/bootstrap/src/utils/change_tracker.rs
@@ -561,4 +561,9 @@ pub const CONFIG_CHANGE_HISTORY: &[ChangeInfo] = &[
         severity: ChangeSeverity::Warning,
         summary: "The `rust.use-lld` option has been renamed to `rust.bootstrap-override-lld`. Note that it only serves for overriding the linker used when building Rust code in bootstrap to be LLD.",
     },
+    ChangeInfo {
+        change_id: 146929,
+        severity: ChangeSeverity::Info,
+        summary: "`compiletest` is now always built with the stage 0 compiler, so `build.compiletest-use-stage0-libtest` has no effect.",
+    },
 ];

From 8b1879864b4487c89ee414fa64abe42440fa922b Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 23 Sep 2025 22:05:12 +1000
Subject: [PATCH 1510/1889] `tool_check_step!` no longer needs a builder to
 determine mode

---
 src/bootstrap/src/core/build_steps/check.rs | 44 +++++++++------------
 1 file changed, 18 insertions(+), 26 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/check.rs b/src/bootstrap/src/core/build_steps/check.rs
index 27f259d420798..20c54a28dda83 100644
--- a/src/bootstrap/src/core/build_steps/check.rs
+++ b/src/bootstrap/src/core/build_steps/check.rs
@@ -654,7 +654,7 @@ macro_rules! tool_check_step {
             // The part of this path after the final '/' is also used as a display name.
             path: $path:literal
             $(, alt_path: $alt_path:literal )*
-            // Closure that returns `Mode` based on the passed `&Builder<'_>`
+            // `Mode` to use when checking this tool
             , mode: $mode:expr
             // Subset of nightly features that are allowed to be used when checking
             $(, allow_features: $allow_features:expr )?
@@ -682,8 +682,7 @@ macro_rules! tool_check_step {
 
             fn make_run(run: RunConfig<'_>) {
                 let target = run.target;
-                let builder = run.builder;
-                let mode = $mode(builder);
+                let mode: Mode = $mode;
 
                 let compiler = prepare_compiler_for_check(run.builder, target, mode);
 
@@ -704,7 +703,7 @@ macro_rules! tool_check_step {
                     _value
                 };
                 let extra_features: &[&str] = &[$($($enable_features),*)?];
-                let mode = $mode(builder);
+                let mode: Mode = $mode;
                 run_tool_check_step(builder, compiler, target, $path, mode, allow_features, extra_features);
             }
 
@@ -767,57 +766,50 @@ fn run_tool_check_step(
 tool_check_step!(Rustdoc {
     path: "src/tools/rustdoc",
     alt_path: "src/librustdoc",
-    mode: |_builder| Mode::ToolRustcPrivate
+    mode: Mode::ToolRustcPrivate
 });
 // Clippy, miri and Rustfmt are hybrids. They are external tools, but use a git subtree instead
 // of a submodule. Since the SourceType only drives the deny-warnings
 // behavior, treat it as in-tree so that any new warnings in clippy will be
 // rejected.
-tool_check_step!(Clippy { path: "src/tools/clippy", mode: |_builder| Mode::ToolRustcPrivate });
-tool_check_step!(Miri { path: "src/tools/miri", mode: |_builder| Mode::ToolRustcPrivate });
-tool_check_step!(CargoMiri {
-    path: "src/tools/miri/cargo-miri",
-    mode: |_builder| Mode::ToolRustcPrivate
-});
-tool_check_step!(Rustfmt { path: "src/tools/rustfmt", mode: |_builder| Mode::ToolRustcPrivate });
+tool_check_step!(Clippy { path: "src/tools/clippy", mode: Mode::ToolRustcPrivate });
+tool_check_step!(Miri { path: "src/tools/miri", mode: Mode::ToolRustcPrivate });
+tool_check_step!(CargoMiri { path: "src/tools/miri/cargo-miri", mode: Mode::ToolRustcPrivate });
+tool_check_step!(Rustfmt { path: "src/tools/rustfmt", mode: Mode::ToolRustcPrivate });
 tool_check_step!(RustAnalyzer {
     path: "src/tools/rust-analyzer",
-    mode: |_builder| Mode::ToolRustcPrivate,
+    mode: Mode::ToolRustcPrivate,
     allow_features: tool::RustAnalyzer::ALLOW_FEATURES,
     enable_features: ["in-rust-tree"],
 });
 tool_check_step!(MiroptTestTools {
     path: "src/tools/miropt-test-tools",
-    mode: |_builder| Mode::ToolBootstrap
+    mode: Mode::ToolBootstrap
 });
 // We want to test the local std
 tool_check_step!(TestFloatParse {
     path: "src/tools/test-float-parse",
-    mode: |_builder| Mode::ToolStd,
+    mode: Mode::ToolStd,
     allow_features: TEST_FLOAT_PARSE_ALLOW_FEATURES
 });
 tool_check_step!(FeaturesStatusDump {
     path: "src/tools/features-status-dump",
-    mode: |_builder| Mode::ToolBootstrap
+    mode: Mode::ToolBootstrap
 });
 
-tool_check_step!(Bootstrap {
-    path: "src/bootstrap",
-    mode: |_builder| Mode::ToolBootstrap,
-    default: false
-});
+tool_check_step!(Bootstrap { path: "src/bootstrap", mode: Mode::ToolBootstrap, default: false });
 
 // `run-make-support` will be built as part of suitable run-make compiletest test steps, but support
 // check to make it easier to work on.
 tool_check_step!(RunMakeSupport {
     path: "src/tools/run-make-support",
-    mode: |_builder| Mode::ToolBootstrap,
+    mode: Mode::ToolBootstrap,
     default: false
 });
 
 tool_check_step!(CoverageDump {
     path: "src/tools/coverage-dump",
-    mode: |_builder| Mode::ToolBootstrap,
+    mode: Mode::ToolBootstrap,
     default: false
 });
 
@@ -825,18 +817,18 @@ tool_check_step!(CoverageDump {
 // so this is mainly for people working on compiletest to run locally.
 tool_check_step!(Compiletest {
     path: "src/tools/compiletest",
-    mode: |_builder| Mode::ToolBootstrap,
+    mode: Mode::ToolBootstrap,
     default: false,
 });
 
 tool_check_step!(Linkchecker {
     path: "src/tools/linkchecker",
-    mode: |_builder| Mode::ToolBootstrap,
+    mode: Mode::ToolBootstrap,
     default: false
 });
 
 tool_check_step!(BumpStage0 {
     path: "src/tools/bump-stage0",
-    mode: |_builder| Mode::ToolBootstrap,
+    mode: Mode::ToolBootstrap,
     default: false
 });

From 5e9cab39213b892fdb5eb24d2d27f1ab0918ce46 Mon Sep 17 00:00:00 2001
From: Shunpoco <tkngsnsk313320@gmail.com>
Date: Sun, 28 Sep 2025 09:46:20 +0100
Subject: [PATCH 1511/1889] modify ensure_version_or_cargo_install to check
 existing binary

Current implementation uses bin_name to check if it exists,
but it should use tool_root_dir/tool_bin_dir/bin_name instead.
Otherwise the check fails every time, hence the function falls back to
install the binary.
---
 src/tools/tidy/src/lib.rs | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/tools/tidy/src/lib.rs b/src/tools/tidy/src/lib.rs
index 0bfee93796be1..874a758bd9b38 100644
--- a/src/tools/tidy/src/lib.rs
+++ b/src/tools/tidy/src/lib.rs
@@ -167,12 +167,16 @@ pub fn ensure_version_or_cargo_install(
     bin_name: &str,
     version: &str,
 ) -> io::Result<PathBuf> {
+    let tool_root_dir = build_dir.join("misc-tools");
+    let tool_bin_dir = tool_root_dir.join("bin");
+    let bin_path = tool_bin_dir.join(bin_name).with_extension(env::consts::EXE_EXTENSION);
+
     // ignore the process exit code here and instead just let the version number check fail.
     // we also importantly don't return if the program wasn't installed,
     // instead we want to continue to the fallback.
     'ck: {
         // FIXME: rewrite as if-let chain once this crate is 2024 edition.
-        let Ok(output) = Command::new(bin_name).arg("--version").output() else {
+        let Ok(output) = Command::new(&bin_path).arg("--version").output() else {
             break 'ck;
         };
         let Ok(s) = str::from_utf8(&output.stdout) else {
@@ -182,12 +186,10 @@ pub fn ensure_version_or_cargo_install(
             break 'ck;
         };
         if v == version {
-            return Ok(PathBuf::from(bin_name));
+            return Ok(bin_path);
         }
     }
 
-    let tool_root_dir = build_dir.join("misc-tools");
-    let tool_bin_dir = tool_root_dir.join("bin");
     eprintln!("building external tool {bin_name} from package {pkg_name}@{version}");
     // use --force to ensure that if the required version is bumped, we update it.
     // use --target-dir to ensure we have a build cache so repeated invocations aren't slow.
@@ -213,7 +215,6 @@ pub fn ensure_version_or_cargo_install(
     if !cargo_exit_code.success() {
         return Err(io::Error::other("cargo install failed"));
     }
-    let bin_path = tool_bin_dir.join(bin_name).with_extension(env::consts::EXE_EXTENSION);
     assert!(
         matches!(bin_path.try_exists(), Ok(true)),
         "cargo install did not produce the expected binary"

From b613be223dfc2151bc7aea15019b5ee04607621c Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Fri, 22 Aug 2025 18:19:10 +0200
Subject: [PATCH 1512/1889] fix a bug while we're at it

---
 clippy_lints/src/double_parens.rs | 57 ++++++++++++++++---------------
 tests/ui/double_parens.fixed      | 40 ++++++++++++++++++++--
 tests/ui/double_parens.rs         | 40 ++++++++++++++++++++--
 tests/ui/double_parens.stderr     | 31 ++++++++++++++++-
 4 files changed, 136 insertions(+), 32 deletions(-)

diff --git a/clippy_lints/src/double_parens.rs b/clippy_lints/src/double_parens.rs
index ab6e477121207..bddf4702fb340 100644
--- a/clippy_lints/src/double_parens.rs
+++ b/clippy_lints/src/double_parens.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::{HasSession, snippet_with_applicability};
+use clippy_utils::source::{HasSession, snippet_with_applicability, snippet_with_context};
 use rustc_ast::ast::{Expr, ExprKind, MethodCall};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
@@ -42,27 +42,28 @@ declare_lint_pass!(DoubleParens => [DOUBLE_PARENS]);
 
 impl EarlyLintPass for DoubleParens {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
-        if expr.span.from_expansion() {
-            return;
-        }
-
         match &expr.kind {
             // ((..))
             // ^^^^^^ expr
             //  ^^^^  inner
             ExprKind::Paren(inner) if matches!(inner.kind, ExprKind::Paren(_) | ExprKind::Tup(_)) => {
                 // suggest removing the outer parens
-                let mut applicability = Applicability::MachineApplicable;
-                let sugg = snippet_with_applicability(cx.sess(), inner.span, "_", &mut applicability);
-                span_lint_and_sugg(
-                    cx,
-                    DOUBLE_PARENS,
-                    expr.span,
-                    "unnecessary parentheses",
-                    "remove them",
-                    sugg.to_string(),
-                    applicability,
-                );
+                if expr.span.eq_ctxt(inner.span) {
+                    let mut applicability = Applicability::MachineApplicable;
+                    // We don't need to use `snippet_with_context` here, because:
+                    // - if `inner`'s `ctxt` is from macro, we don't lint in the first place (see the check above)
+                    // - otherwise, calling `snippet_with_applicability` on a not-from-macro span is fine
+                    let sugg = snippet_with_applicability(cx.sess(), inner.span, "_", &mut applicability);
+                    span_lint_and_sugg(
+                        cx,
+                        DOUBLE_PARENS,
+                        expr.span,
+                        "unnecessary parentheses",
+                        "remove them",
+                        sugg.to_string(),
+                        applicability,
+                    );
+                }
             },
 
             // func((n))
@@ -74,17 +75,19 @@ impl EarlyLintPass for DoubleParens {
                     && let ExprKind::Paren(inner) = &arg.kind =>
             {
                 // suggest removing the inner parens
-                let mut applicability = Applicability::MachineApplicable;
-                let sugg = snippet_with_applicability(cx.sess(), inner.span, "_", &mut applicability);
-                span_lint_and_sugg(
-                    cx,
-                    DOUBLE_PARENS,
-                    arg.span,
-                    "unnecessary parentheses",
-                    "remove them",
-                    sugg.to_string(),
-                    applicability,
-                );
+                if expr.span.eq_ctxt(arg.span) {
+                    let mut applicability = Applicability::MachineApplicable;
+                    let sugg = snippet_with_context(cx.sess(), inner.span, arg.span.ctxt(), "_", &mut applicability).0;
+                    span_lint_and_sugg(
+                        cx,
+                        DOUBLE_PARENS,
+                        arg.span,
+                        "unnecessary parentheses",
+                        "remove them",
+                        sugg.to_string(),
+                        applicability,
+                    );
+                }
             },
             _ => {},
         }
diff --git a/tests/ui/double_parens.fixed b/tests/ui/double_parens.fixed
index 7fa116942fe85..dedc513438d11 100644
--- a/tests/ui/double_parens.fixed
+++ b/tests/ui/double_parens.fixed
@@ -1,5 +1,5 @@
 #![warn(clippy::double_parens)]
-#![expect(clippy::eq_op)]
+#![expect(clippy::eq_op, clippy::no_effect)]
 #![feature(custom_inner_attributes)]
 #![rustfmt::skip]
 
@@ -8,7 +8,7 @@ fn dummy_fn<T>(_: T) {}
 struct DummyStruct;
 
 impl DummyStruct {
-    fn dummy_method<T>(self, _: T) {}
+    fn dummy_method<T>(&self, _: T) {}
 }
 
 fn simple_double_parens() -> i32 {
@@ -60,4 +60,40 @@ fn inside_macro() {
     //~^ double_parens
 }
 
+fn issue9000(x: DummyStruct) {
+    macro_rules! foo {
+        () => {(100)}
+    }
+    // don't lint: the inner paren comes from the macro expansion
+    (foo!());
+    dummy_fn(foo!());
+    x.dummy_method(foo!());
+
+    macro_rules! baz {
+        ($n:literal) => {($n)}
+    }
+    // don't lint: don't get confused by the expression inside the inner paren
+    // having the same `ctxt` as the overall expression
+    // (this is a bug that happened during the development of the fix)
+    (baz!(100));
+    dummy_fn(baz!(100));
+    x.dummy_method(baz!(100));
+
+    // should lint: both parens are from inside the macro
+    macro_rules! bar {
+        () => {(100)}
+        //~^ double_parens
+    }
+    bar!();
+
+    // should lint: both parens are from outside the macro;
+    // make sure to suggest the macro unexpanded
+    (vec![1, 2]);
+    //~^ double_parens
+    dummy_fn(vec![1, 2]);
+    //~^ double_parens
+    x.dummy_method(vec![1, 2]);
+    //~^ double_parens
+}
+
 fn main() {}
diff --git a/tests/ui/double_parens.rs b/tests/ui/double_parens.rs
index 8730b4b124689..27f252485b714 100644
--- a/tests/ui/double_parens.rs
+++ b/tests/ui/double_parens.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::double_parens)]
-#![expect(clippy::eq_op)]
+#![expect(clippy::eq_op, clippy::no_effect)]
 #![feature(custom_inner_attributes)]
 #![rustfmt::skip]
 
@@ -8,7 +8,7 @@ fn dummy_fn<T>(_: T) {}
 struct DummyStruct;
 
 impl DummyStruct {
-    fn dummy_method<T>(self, _: T) {}
+    fn dummy_method<T>(&self, _: T) {}
 }
 
 fn simple_double_parens() -> i32 {
@@ -60,4 +60,40 @@ fn inside_macro() {
     //~^ double_parens
 }
 
+fn issue9000(x: DummyStruct) {
+    macro_rules! foo {
+        () => {(100)}
+    }
+    // don't lint: the inner paren comes from the macro expansion
+    (foo!());
+    dummy_fn(foo!());
+    x.dummy_method(foo!());
+
+    macro_rules! baz {
+        ($n:literal) => {($n)}
+    }
+    // don't lint: don't get confused by the expression inside the inner paren
+    // having the same `ctxt` as the overall expression
+    // (this is a bug that happened during the development of the fix)
+    (baz!(100));
+    dummy_fn(baz!(100));
+    x.dummy_method(baz!(100));
+
+    // should lint: both parens are from inside the macro
+    macro_rules! bar {
+        () => {((100))}
+        //~^ double_parens
+    }
+    bar!();
+
+    // should lint: both parens are from outside the macro;
+    // make sure to suggest the macro unexpanded
+    ((vec![1, 2]));
+    //~^ double_parens
+    dummy_fn((vec![1, 2]));
+    //~^ double_parens
+    x.dummy_method((vec![1, 2]));
+    //~^ double_parens
+}
+
 fn main() {}
diff --git a/tests/ui/double_parens.stderr b/tests/ui/double_parens.stderr
index 2b37877ccdd86..3a740e44cacf3 100644
--- a/tests/ui/double_parens.stderr
+++ b/tests/ui/double_parens.stderr
@@ -37,5 +37,34 @@ error: unnecessary parentheses
 LL |     assert_eq!(((1, 2)), (1, 2), "Error");
    |                ^^^^^^^^ help: remove them: `(1, 2)`
 
-error: aborting due to 6 previous errors
+error: unnecessary parentheses
+  --> tests/ui/double_parens.rs:84:16
+   |
+LL |         () => {((100))}
+   |                ^^^^^^^ help: remove them: `(100)`
+...
+LL |     bar!();
+   |     ------ in this macro invocation
+   |
+   = note: this error originates in the macro `bar` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: unnecessary parentheses
+  --> tests/ui/double_parens.rs:91:5
+   |
+LL |     ((vec![1, 2]));
+   |     ^^^^^^^^^^^^^^ help: remove them: `(vec![1, 2])`
+
+error: unnecessary parentheses
+  --> tests/ui/double_parens.rs:93:14
+   |
+LL |     dummy_fn((vec![1, 2]));
+   |              ^^^^^^^^^^^^ help: remove them: `vec![1, 2]`
+
+error: unnecessary parentheses
+  --> tests/ui/double_parens.rs:95:20
+   |
+LL |     x.dummy_method((vec![1, 2]));
+   |                    ^^^^^^^^^^^^ help: remove them: `vec![1, 2]`
+
+error: aborting due to 10 previous errors
 

From bb1081e5a9a85081d944c885939809a08db84dd3 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Tue, 5 Aug 2025 11:58:48 +0200
Subject: [PATCH 1513/1889] move unfixable stuff to a separate file

---
 tests/ui/mut_mut.rs               |  9 +++-----
 tests/ui/mut_mut.stderr           | 18 ++++++++--------
 tests/ui/mut_mut_unfixable.rs     | 34 ++++++++++++++++++++++++++++++
 tests/ui/mut_mut_unfixable.stderr | 35 +++++++++++++++++++++++++++++++
 4 files changed, 81 insertions(+), 15 deletions(-)
 create mode 100644 tests/ui/mut_mut_unfixable.rs
 create mode 100644 tests/ui/mut_mut_unfixable.stderr

diff --git a/tests/ui/mut_mut.rs b/tests/ui/mut_mut.rs
index bbcdbc89b6a4b..d006578b3d284 100644
--- a/tests/ui/mut_mut.rs
+++ b/tests/ui/mut_mut.rs
@@ -12,9 +12,8 @@
 extern crate proc_macros;
 use proc_macros::{external, inline_macros};
 
-fn fun(x: &mut &mut u32) -> bool {
+fn fun(x: &mut &mut u32) {
     //~^ mut_mut
-    **x > 0
 }
 
 fn less_fun(x: *mut *mut u32) {
@@ -37,19 +36,17 @@ fn main() {
         //~^ mut_mut
     }
 
-    if fun(x) {
+    {
         let y: &mut &mut u32 = &mut &mut 2;
         //~^ mut_mut
         //~| mut_mut
-        **y + **x;
     }
 
-    if fun(x) {
+    {
         let y: &mut &mut &mut u32 = &mut &mut &mut 2;
         //~^ mut_mut
         //~| mut_mut
         //~| mut_mut
-        ***y + **x;
     }
 
     let mut z = inline!(&mut $(&mut 3u32));
diff --git a/tests/ui/mut_mut.stderr b/tests/ui/mut_mut.stderr
index 74b0c9ba145a9..8517c4e5ad89f 100644
--- a/tests/ui/mut_mut.stderr
+++ b/tests/ui/mut_mut.stderr
@@ -1,20 +1,20 @@
 error: generally you want to avoid `&mut &mut _` if possible
   --> tests/ui/mut_mut.rs:15:11
    |
-LL | fn fun(x: &mut &mut u32) -> bool {
+LL | fn fun(x: &mut &mut u32) {
    |           ^^^^^^^^^^^^^
    |
    = note: `-D clippy::mut-mut` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::mut_mut)]`
 
 error: generally you want to avoid `&mut &mut _` if possible
-  --> tests/ui/mut_mut.rs:33:17
+  --> tests/ui/mut_mut.rs:32:17
    |
 LL |     let mut x = &mut &mut 1u32;
    |                 ^^^^^^^^^^^^^^
 
 error: generally you want to avoid `&mut &mut _` if possible
-  --> tests/ui/mut_mut.rs:55:25
+  --> tests/ui/mut_mut.rs:52:25
    |
 LL |     let mut z = inline!(&mut $(&mut 3u32));
    |                         ^
@@ -22,37 +22,37 @@ LL |     let mut z = inline!(&mut $(&mut 3u32));
    = note: this error originates in the macro `__inline_mac_fn_main` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: this expression mutably borrows a mutable reference. Consider reborrowing
-  --> tests/ui/mut_mut.rs:36:21
+  --> tests/ui/mut_mut.rs:35:21
    |
 LL |         let mut y = &mut x;
    |                     ^^^^^^
 
 error: generally you want to avoid `&mut &mut _` if possible
-  --> tests/ui/mut_mut.rs:41:32
+  --> tests/ui/mut_mut.rs:40:32
    |
 LL |         let y: &mut &mut u32 = &mut &mut 2;
    |                                ^^^^^^^^^^^
 
 error: generally you want to avoid `&mut &mut _` if possible
-  --> tests/ui/mut_mut.rs:41:16
+  --> tests/ui/mut_mut.rs:40:16
    |
 LL |         let y: &mut &mut u32 = &mut &mut 2;
    |                ^^^^^^^^^^^^^
 
 error: generally you want to avoid `&mut &mut _` if possible
-  --> tests/ui/mut_mut.rs:48:37
+  --> tests/ui/mut_mut.rs:46:37
    |
 LL |         let y: &mut &mut &mut u32 = &mut &mut &mut 2;
    |                                     ^^^^^^^^^^^^^^^^
 
 error: generally you want to avoid `&mut &mut _` if possible
-  --> tests/ui/mut_mut.rs:48:16
+  --> tests/ui/mut_mut.rs:46:16
    |
 LL |         let y: &mut &mut &mut u32 = &mut &mut &mut 2;
    |                ^^^^^^^^^^^^^^^^^^
 
 error: generally you want to avoid `&mut &mut _` if possible
-  --> tests/ui/mut_mut.rs:48:21
+  --> tests/ui/mut_mut.rs:46:21
    |
 LL |         let y: &mut &mut &mut u32 = &mut &mut &mut 2;
    |                     ^^^^^^^^^^^^^
diff --git a/tests/ui/mut_mut_unfixable.rs b/tests/ui/mut_mut_unfixable.rs
new file mode 100644
index 0000000000000..db0552a86ec9b
--- /dev/null
+++ b/tests/ui/mut_mut_unfixable.rs
@@ -0,0 +1,34 @@
+//@no-rustfix
+
+#![warn(clippy::mut_mut)]
+#![allow(unused)]
+#![expect(clippy::no_effect)]
+
+//! removing the extra `&mut`s will break the derefs
+
+fn fun(x: &mut &mut u32) -> bool {
+    //~^ mut_mut
+    **x > 0
+}
+
+fn main() {
+    let mut x = &mut &mut 1u32;
+    //~^ mut_mut
+    {
+        let mut y = &mut x;
+        //~^ mut_mut
+        ***y + **x;
+    }
+
+    if fun(x) {
+        let y = &mut &mut 2;
+        //~^ mut_mut
+        **y + **x;
+    }
+
+    if fun(x) {
+        let y = &mut &mut &mut 2;
+        //~^ mut_mut
+        ***y + **x;
+    }
+}
diff --git a/tests/ui/mut_mut_unfixable.stderr b/tests/ui/mut_mut_unfixable.stderr
new file mode 100644
index 0000000000000..bb0363ef7ed9c
--- /dev/null
+++ b/tests/ui/mut_mut_unfixable.stderr
@@ -0,0 +1,35 @@
+error: generally you want to avoid `&mut &mut _` if possible
+  --> tests/ui/mut_mut_unfixable.rs:9:11
+   |
+LL | fn fun(x: &mut &mut u32) -> bool {
+   |           ^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::mut-mut` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::mut_mut)]`
+
+error: generally you want to avoid `&mut &mut _` if possible
+  --> tests/ui/mut_mut_unfixable.rs:15:17
+   |
+LL |     let mut x = &mut &mut 1u32;
+   |                 ^^^^^^^^^^^^^^
+
+error: this expression mutably borrows a mutable reference. Consider reborrowing
+  --> tests/ui/mut_mut_unfixable.rs:18:21
+   |
+LL |         let mut y = &mut x;
+   |                     ^^^^^^
+
+error: generally you want to avoid `&mut &mut _` if possible
+  --> tests/ui/mut_mut_unfixable.rs:24:17
+   |
+LL |         let y = &mut &mut 2;
+   |                 ^^^^^^^^^^^
+
+error: generally you want to avoid `&mut &mut _` if possible
+  --> tests/ui/mut_mut_unfixable.rs:30:17
+   |
+LL |         let y = &mut &mut &mut 2;
+   |                 ^^^^^^^^^^^^^^^^
+
+error: aborting due to 5 previous errors
+

From a4fba850a90a3a7f9a33d872de09795d9801743f Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sun, 3 Aug 2025 23:32:07 +0200
Subject: [PATCH 1514/1889] sugg on expr 1

---
 clippy_lints/src/mut_mut.rs       | 13 ++++-
 tests/ui/mut_mut.fixed            | 94 +++++++++++++++++++++++++++++++
 tests/ui/mut_mut.stderr           |  4 +-
 tests/ui/mut_mut_unfixable.stderr |  4 +-
 4 files changed, 108 insertions(+), 7 deletions(-)
 create mode 100644 tests/ui/mut_mut.fixed

diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs
index d98c70e7f5a85..c8b4ad3f7722c 100644
--- a/clippy_lints/src/mut_mut.rs
+++ b/clippy_lints/src/mut_mut.rs
@@ -1,5 +1,7 @@
-use clippy_utils::diagnostics::{span_lint, span_lint_hir};
+use clippy_utils::diagnostics::{span_lint, span_lint_hir, span_lint_hir_and_then};
 use clippy_utils::higher;
+use clippy_utils::sugg::Sugg;
+use rustc_errors::Applicability;
 use rustc_hir::{self as hir, AmbigArg, intravisit};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty;
@@ -80,12 +82,17 @@ impl<'tcx> intravisit::Visitor<'tcx> for MutVisitor<'_, 'tcx> {
             } else if let ty::Ref(_, ty, hir::Mutability::Mut) = self.cx.typeck_results().expr_ty(e).kind()
                 && ty.peel_refs().is_sized(self.cx.tcx, self.cx.typing_env())
             {
-                span_lint_hir(
+                let mut applicability = Applicability::MaybeIncorrect;
+                let sugg = Sugg::hir_with_applicability(self.cx, e, "..", &mut applicability).mut_addr_deref();
+                span_lint_hir_and_then(
                     self.cx,
                     MUT_MUT,
                     expr.hir_id,
                     expr.span,
-                    "this expression mutably borrows a mutable reference. Consider reborrowing",
+                    "this expression mutably borrows a mutable reference",
+                    |diag| {
+                        diag.span_suggestion(expr.span, "reborrow instead", sugg, applicability);
+                    },
                 );
             }
         }
diff --git a/tests/ui/mut_mut.fixed b/tests/ui/mut_mut.fixed
new file mode 100644
index 0000000000000..cbce826b6e85d
--- /dev/null
+++ b/tests/ui/mut_mut.fixed
@@ -0,0 +1,94 @@
+//@aux-build:proc_macros.rs
+
+#![warn(clippy::mut_mut)]
+#![allow(unused)]
+#![allow(
+    clippy::no_effect,
+    clippy::uninlined_format_args,
+    clippy::unnecessary_operation,
+    clippy::needless_pass_by_ref_mut
+)]
+
+extern crate proc_macros;
+use proc_macros::{external, inline_macros};
+
+fn fun(x: &mut &mut u32) {
+    //~^ mut_mut
+}
+
+fn less_fun(x: *mut *mut u32) {
+    let y = x;
+}
+
+macro_rules! mut_ptr {
+    ($p:expr) => {
+        &mut $p
+    };
+}
+
+#[allow(unused_mut, unused_variables)]
+#[inline_macros]
+fn main() {
+    let mut x = &mut &mut 1u32;
+    //~^ mut_mut
+    {
+        let mut y = &mut *x;
+        //~^ mut_mut
+    }
+
+    {
+        let y: &mut &mut u32 = &mut &mut 2;
+        //~^ mut_mut
+        //~| mut_mut
+    }
+
+    {
+        let y: &mut &mut &mut u32 = &mut &mut &mut 2;
+        //~^ mut_mut
+        //~| mut_mut
+        //~| mut_mut
+    }
+
+    let mut z = inline!(&mut $(&mut 3u32));
+    //~^ mut_mut
+}
+
+fn issue939() {
+    let array = [5, 6, 7, 8, 9];
+    let mut args = array.iter().skip(2);
+    for &arg in &mut args {
+        println!("{}", arg);
+    }
+
+    let args = &mut args;
+    for arg in args {
+        println!(":{}", arg);
+    }
+}
+
+fn issue6922() {
+    // do not lint from an external macro
+    external!(let mut_mut_ty: &mut &mut u32 = &mut &mut 1u32;);
+}
+
+mod issue9035 {
+    use std::fmt::Display;
+
+    struct Foo<'a> {
+        inner: &'a mut dyn Display,
+    }
+
+    impl Foo<'_> {
+        fn foo(&mut self) {
+            let hlp = &mut self.inner;
+            bar(hlp);
+        }
+    }
+
+    fn bar(_: &mut impl Display) {}
+}
+
+fn allow_works() {
+    #[allow(clippy::mut_mut)]
+    let _ = &mut &mut 1;
+}
diff --git a/tests/ui/mut_mut.stderr b/tests/ui/mut_mut.stderr
index 8517c4e5ad89f..aa4731e8fe041 100644
--- a/tests/ui/mut_mut.stderr
+++ b/tests/ui/mut_mut.stderr
@@ -21,11 +21,11 @@ LL |     let mut z = inline!(&mut $(&mut 3u32));
    |
    = note: this error originates in the macro `__inline_mac_fn_main` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: this expression mutably borrows a mutable reference. Consider reborrowing
+error: this expression mutably borrows a mutable reference
   --> tests/ui/mut_mut.rs:35:21
    |
 LL |         let mut y = &mut x;
-   |                     ^^^^^^
+   |                     ^^^^^^ help: reborrow instead: `&mut *x`
 
 error: generally you want to avoid `&mut &mut _` if possible
   --> tests/ui/mut_mut.rs:40:32
diff --git a/tests/ui/mut_mut_unfixable.stderr b/tests/ui/mut_mut_unfixable.stderr
index bb0363ef7ed9c..835b272258d39 100644
--- a/tests/ui/mut_mut_unfixable.stderr
+++ b/tests/ui/mut_mut_unfixable.stderr
@@ -13,11 +13,11 @@ error: generally you want to avoid `&mut &mut _` if possible
 LL |     let mut x = &mut &mut 1u32;
    |                 ^^^^^^^^^^^^^^
 
-error: this expression mutably borrows a mutable reference. Consider reborrowing
+error: this expression mutably borrows a mutable reference
   --> tests/ui/mut_mut_unfixable.rs:18:21
    |
 LL |         let mut y = &mut x;
-   |                     ^^^^^^
+   |                     ^^^^^^ help: reborrow instead: `&mut *x`
 
 error: generally you want to avoid `&mut &mut _` if possible
   --> tests/ui/mut_mut_unfixable.rs:24:17

From 70be286cefb2dae0a708e0351c09a6a1170cbd54 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Tue, 5 Aug 2025 12:14:09 +0200
Subject: [PATCH 1515/1889] sugg on expr 2

---
 clippy_lints/src/mut_mut.rs       | 11 ++++++++---
 tests/ui/mut_mut.fixed            |  8 ++++----
 tests/ui/mut_mut.stderr           | 16 ++++++++--------
 tests/ui/mut_mut_unfixable.stderr | 12 ++++++------
 4 files changed, 26 insertions(+), 21 deletions(-)

diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs
index c8b4ad3f7722c..0feed460d2ed7 100644
--- a/clippy_lints/src/mut_mut.rs
+++ b/clippy_lints/src/mut_mut.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{span_lint, span_lint_hir, span_lint_hir_and_then};
+use clippy_utils::diagnostics::{span_lint, span_lint_hir_and_then};
 use clippy_utils::higher;
 use clippy_utils::sugg::Sugg;
 use rustc_errors::Applicability;
@@ -72,12 +72,17 @@ impl<'tcx> intravisit::Visitor<'tcx> for MutVisitor<'_, 'tcx> {
             intravisit::walk_expr(self, body);
         } else if let hir::ExprKind::AddrOf(hir::BorrowKind::Ref, hir::Mutability::Mut, e) = expr.kind {
             if let hir::ExprKind::AddrOf(hir::BorrowKind::Ref, hir::Mutability::Mut, _) = e.kind {
-                span_lint_hir(
+                let mut applicability = Applicability::MaybeIncorrect;
+                let sugg = Sugg::hir_with_applicability(self.cx, e, "..", &mut applicability);
+                span_lint_hir_and_then(
                     self.cx,
                     MUT_MUT,
                     expr.hir_id,
                     expr.span,
-                    "generally you want to avoid `&mut &mut _` if possible",
+                    "an expression of form `&mut &mut _`",
+                    |diag| {
+                        diag.span_suggestion(expr.span, "remove the extra `&mut`", sugg, applicability);
+                    },
                 );
             } else if let ty::Ref(_, ty, hir::Mutability::Mut) = self.cx.typeck_results().expr_ty(e).kind()
                 && ty.peel_refs().is_sized(self.cx.tcx, self.cx.typing_env())
diff --git a/tests/ui/mut_mut.fixed b/tests/ui/mut_mut.fixed
index cbce826b6e85d..c6b318d765104 100644
--- a/tests/ui/mut_mut.fixed
+++ b/tests/ui/mut_mut.fixed
@@ -29,7 +29,7 @@ macro_rules! mut_ptr {
 #[allow(unused_mut, unused_variables)]
 #[inline_macros]
 fn main() {
-    let mut x = &mut &mut 1u32;
+    let mut x = &mut 1u32;
     //~^ mut_mut
     {
         let mut y = &mut *x;
@@ -37,19 +37,19 @@ fn main() {
     }
 
     {
-        let y: &mut &mut u32 = &mut &mut 2;
+        let y: &mut &mut u32 = &mut 2;
         //~^ mut_mut
         //~| mut_mut
     }
 
     {
-        let y: &mut &mut &mut u32 = &mut &mut &mut 2;
+        let y: &mut &mut &mut u32 = &mut &mut 2;
         //~^ mut_mut
         //~| mut_mut
         //~| mut_mut
     }
 
-    let mut z = inline!(&mut $(&mut 3u32));
+    let mut z = inline!(&mut 3u32mut $(&mut 3u32));
     //~^ mut_mut
 }
 
diff --git a/tests/ui/mut_mut.stderr b/tests/ui/mut_mut.stderr
index aa4731e8fe041..f21de359e64f7 100644
--- a/tests/ui/mut_mut.stderr
+++ b/tests/ui/mut_mut.stderr
@@ -7,17 +7,17 @@ LL | fn fun(x: &mut &mut u32) {
    = note: `-D clippy::mut-mut` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::mut_mut)]`
 
-error: generally you want to avoid `&mut &mut _` if possible
+error: an expression of form `&mut &mut _`
   --> tests/ui/mut_mut.rs:32:17
    |
 LL |     let mut x = &mut &mut 1u32;
-   |                 ^^^^^^^^^^^^^^
+   |                 ^^^^^^^^^^^^^^ help: remove the extra `&mut`: `&mut 1u32`
 
-error: generally you want to avoid `&mut &mut _` if possible
+error: an expression of form `&mut &mut _`
   --> tests/ui/mut_mut.rs:52:25
    |
 LL |     let mut z = inline!(&mut $(&mut 3u32));
-   |                         ^
+   |                         ^ help: remove the extra `&mut`: `&mut 3u32`
    |
    = note: this error originates in the macro `__inline_mac_fn_main` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -27,11 +27,11 @@ error: this expression mutably borrows a mutable reference
 LL |         let mut y = &mut x;
    |                     ^^^^^^ help: reborrow instead: `&mut *x`
 
-error: generally you want to avoid `&mut &mut _` if possible
+error: an expression of form `&mut &mut _`
   --> tests/ui/mut_mut.rs:40:32
    |
 LL |         let y: &mut &mut u32 = &mut &mut 2;
-   |                                ^^^^^^^^^^^
+   |                                ^^^^^^^^^^^ help: remove the extra `&mut`: `&mut 2`
 
 error: generally you want to avoid `&mut &mut _` if possible
   --> tests/ui/mut_mut.rs:40:16
@@ -39,11 +39,11 @@ error: generally you want to avoid `&mut &mut _` if possible
 LL |         let y: &mut &mut u32 = &mut &mut 2;
    |                ^^^^^^^^^^^^^
 
-error: generally you want to avoid `&mut &mut _` if possible
+error: an expression of form `&mut &mut _`
   --> tests/ui/mut_mut.rs:46:37
    |
 LL |         let y: &mut &mut &mut u32 = &mut &mut &mut 2;
-   |                                     ^^^^^^^^^^^^^^^^
+   |                                     ^^^^^^^^^^^^^^^^ help: remove the extra `&mut`: `&mut &mut 2`
 
 error: generally you want to avoid `&mut &mut _` if possible
   --> tests/ui/mut_mut.rs:46:16
diff --git a/tests/ui/mut_mut_unfixable.stderr b/tests/ui/mut_mut_unfixable.stderr
index 835b272258d39..129e5b24387e1 100644
--- a/tests/ui/mut_mut_unfixable.stderr
+++ b/tests/ui/mut_mut_unfixable.stderr
@@ -7,11 +7,11 @@ LL | fn fun(x: &mut &mut u32) -> bool {
    = note: `-D clippy::mut-mut` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::mut_mut)]`
 
-error: generally you want to avoid `&mut &mut _` if possible
+error: an expression of form `&mut &mut _`
   --> tests/ui/mut_mut_unfixable.rs:15:17
    |
 LL |     let mut x = &mut &mut 1u32;
-   |                 ^^^^^^^^^^^^^^
+   |                 ^^^^^^^^^^^^^^ help: remove the extra `&mut`: `&mut 1u32`
 
 error: this expression mutably borrows a mutable reference
   --> tests/ui/mut_mut_unfixable.rs:18:21
@@ -19,17 +19,17 @@ error: this expression mutably borrows a mutable reference
 LL |         let mut y = &mut x;
    |                     ^^^^^^ help: reborrow instead: `&mut *x`
 
-error: generally you want to avoid `&mut &mut _` if possible
+error: an expression of form `&mut &mut _`
   --> tests/ui/mut_mut_unfixable.rs:24:17
    |
 LL |         let y = &mut &mut 2;
-   |                 ^^^^^^^^^^^
+   |                 ^^^^^^^^^^^ help: remove the extra `&mut`: `&mut 2`
 
-error: generally you want to avoid `&mut &mut _` if possible
+error: an expression of form `&mut &mut _`
   --> tests/ui/mut_mut_unfixable.rs:30:17
    |
 LL |         let y = &mut &mut &mut 2;
-   |                 ^^^^^^^^^^^^^^^^
+   |                 ^^^^^^^^^^^^^^^^ help: remove the extra `&mut`: `&mut &mut 2`
 
 error: aborting due to 5 previous errors
 

From 269870a5f9b48117ba9bac65e8b9549df421e9c2 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Mon, 4 Aug 2025 20:21:19 +0200
Subject: [PATCH 1516/1889] fix: don't lint in macro calls

---
 clippy_lints/src/mut_mut.rs |  3 +++
 tests/ui/mut_mut.fixed      |  3 +--
 tests/ui/mut_mut.rs         |  1 -
 tests/ui/mut_mut.stderr     | 10 +---------
 4 files changed, 5 insertions(+), 12 deletions(-)

diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs
index 0feed460d2ed7..376d7214c267d 100644
--- a/clippy_lints/src/mut_mut.rs
+++ b/clippy_lints/src/mut_mut.rs
@@ -72,6 +72,9 @@ impl<'tcx> intravisit::Visitor<'tcx> for MutVisitor<'_, 'tcx> {
             intravisit::walk_expr(self, body);
         } else if let hir::ExprKind::AddrOf(hir::BorrowKind::Ref, hir::Mutability::Mut, e) = expr.kind {
             if let hir::ExprKind::AddrOf(hir::BorrowKind::Ref, hir::Mutability::Mut, _) = e.kind {
+                if !expr.span.eq_ctxt(e.span) {
+                    return;
+                }
                 let mut applicability = Applicability::MaybeIncorrect;
                 let sugg = Sugg::hir_with_applicability(self.cx, e, "..", &mut applicability);
                 span_lint_hir_and_then(
diff --git a/tests/ui/mut_mut.fixed b/tests/ui/mut_mut.fixed
index c6b318d765104..137306064b439 100644
--- a/tests/ui/mut_mut.fixed
+++ b/tests/ui/mut_mut.fixed
@@ -49,8 +49,7 @@ fn main() {
         //~| mut_mut
     }
 
-    let mut z = inline!(&mut 3u32mut $(&mut 3u32));
-    //~^ mut_mut
+    let mut z = inline!(&mut $(&mut 3u32));
 }
 
 fn issue939() {
diff --git a/tests/ui/mut_mut.rs b/tests/ui/mut_mut.rs
index d006578b3d284..92ecfbfc02d12 100644
--- a/tests/ui/mut_mut.rs
+++ b/tests/ui/mut_mut.rs
@@ -50,7 +50,6 @@ fn main() {
     }
 
     let mut z = inline!(&mut $(&mut 3u32));
-    //~^ mut_mut
 }
 
 fn issue939() {
diff --git a/tests/ui/mut_mut.stderr b/tests/ui/mut_mut.stderr
index f21de359e64f7..5f7c9b4fe23f0 100644
--- a/tests/ui/mut_mut.stderr
+++ b/tests/ui/mut_mut.stderr
@@ -13,14 +13,6 @@ error: an expression of form `&mut &mut _`
 LL |     let mut x = &mut &mut 1u32;
    |                 ^^^^^^^^^^^^^^ help: remove the extra `&mut`: `&mut 1u32`
 
-error: an expression of form `&mut &mut _`
-  --> tests/ui/mut_mut.rs:52:25
-   |
-LL |     let mut z = inline!(&mut $(&mut 3u32));
-   |                         ^ help: remove the extra `&mut`: `&mut 3u32`
-   |
-   = note: this error originates in the macro `__inline_mac_fn_main` (in Nightly builds, run with -Z macro-backtrace for more info)
-
 error: this expression mutably borrows a mutable reference
   --> tests/ui/mut_mut.rs:35:21
    |
@@ -57,5 +49,5 @@ error: generally you want to avoid `&mut &mut _` if possible
 LL |         let y: &mut &mut &mut u32 = &mut &mut &mut 2;
    |                     ^^^^^^^^^^^^^
 
-error: aborting due to 9 previous errors
+error: aborting due to 8 previous errors
 

From 729d92cf0405ef8ee06e76b9e59b4892caa173f0 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Mon, 4 Aug 2025 00:12:47 +0200
Subject: [PATCH 1517/1889] sugg on ty

---
 clippy_lints/src/mut_mut.rs       | 16 +++++++++++-----
 tests/ui/mut_mut.stderr           | 16 ++++++++--------
 tests/ui/mut_mut_unfixable.stderr |  4 ++--
 3 files changed, 21 insertions(+), 15 deletions(-)

diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs
index 376d7214c267d..7d7d4fa542c19 100644
--- a/clippy_lints/src/mut_mut.rs
+++ b/clippy_lints/src/mut_mut.rs
@@ -1,5 +1,6 @@
-use clippy_utils::diagnostics::{span_lint, span_lint_hir_and_then};
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
 use clippy_utils::higher;
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
 use rustc_errors::Applicability;
 use rustc_hir::{self as hir, AmbigArg, intravisit};
@@ -37,15 +38,20 @@ impl<'tcx> LateLintPass<'tcx> for MutMut {
     fn check_ty(&mut self, cx: &LateContext<'tcx>, ty: &'tcx hir::Ty<'_, AmbigArg>) {
         if let hir::TyKind::Ref(_, mty) = ty.kind
             && mty.mutbl == hir::Mutability::Mut
-            && let hir::TyKind::Ref(_, mty) = mty.ty.kind
-            && mty.mutbl == hir::Mutability::Mut
+            && let hir::TyKind::Ref(_, mty2) = mty.ty.kind
+            && mty2.mutbl == hir::Mutability::Mut
             && !ty.span.in_external_macro(cx.sess().source_map())
         {
-            span_lint(
+            let mut applicability = Applicability::MaybeIncorrect;
+            let sugg = snippet_with_applicability(cx.sess(), mty.ty.span, "..", &mut applicability);
+            span_lint_and_sugg(
                 cx,
                 MUT_MUT,
                 ty.span,
-                "generally you want to avoid `&mut &mut _` if possible",
+                "a type of form `&mut &mut _`",
+                "remove the extra `&mut`",
+                sugg.to_string(),
+                applicability,
             );
         }
     }
diff --git a/tests/ui/mut_mut.stderr b/tests/ui/mut_mut.stderr
index 5f7c9b4fe23f0..341ac643417c7 100644
--- a/tests/ui/mut_mut.stderr
+++ b/tests/ui/mut_mut.stderr
@@ -1,8 +1,8 @@
-error: generally you want to avoid `&mut &mut _` if possible
+error: a type of form `&mut &mut _`
   --> tests/ui/mut_mut.rs:15:11
    |
 LL | fn fun(x: &mut &mut u32) {
-   |           ^^^^^^^^^^^^^
+   |           ^^^^^^^^^^^^^ help: remove the extra `&mut`: `&mut u32`
    |
    = note: `-D clippy::mut-mut` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::mut_mut)]`
@@ -25,11 +25,11 @@ error: an expression of form `&mut &mut _`
 LL |         let y: &mut &mut u32 = &mut &mut 2;
    |                                ^^^^^^^^^^^ help: remove the extra `&mut`: `&mut 2`
 
-error: generally you want to avoid `&mut &mut _` if possible
+error: a type of form `&mut &mut _`
   --> tests/ui/mut_mut.rs:40:16
    |
 LL |         let y: &mut &mut u32 = &mut &mut 2;
-   |                ^^^^^^^^^^^^^
+   |                ^^^^^^^^^^^^^ help: remove the extra `&mut`: `&mut u32`
 
 error: an expression of form `&mut &mut _`
   --> tests/ui/mut_mut.rs:46:37
@@ -37,17 +37,17 @@ error: an expression of form `&mut &mut _`
 LL |         let y: &mut &mut &mut u32 = &mut &mut &mut 2;
    |                                     ^^^^^^^^^^^^^^^^ help: remove the extra `&mut`: `&mut &mut 2`
 
-error: generally you want to avoid `&mut &mut _` if possible
+error: a type of form `&mut &mut _`
   --> tests/ui/mut_mut.rs:46:16
    |
 LL |         let y: &mut &mut &mut u32 = &mut &mut &mut 2;
-   |                ^^^^^^^^^^^^^^^^^^
+   |                ^^^^^^^^^^^^^^^^^^ help: remove the extra `&mut`: `&mut &mut u32`
 
-error: generally you want to avoid `&mut &mut _` if possible
+error: a type of form `&mut &mut _`
   --> tests/ui/mut_mut.rs:46:21
    |
 LL |         let y: &mut &mut &mut u32 = &mut &mut &mut 2;
-   |                     ^^^^^^^^^^^^^
+   |                     ^^^^^^^^^^^^^ help: remove the extra `&mut`: `&mut u32`
 
 error: aborting due to 8 previous errors
 
diff --git a/tests/ui/mut_mut_unfixable.stderr b/tests/ui/mut_mut_unfixable.stderr
index 129e5b24387e1..da820f766d027 100644
--- a/tests/ui/mut_mut_unfixable.stderr
+++ b/tests/ui/mut_mut_unfixable.stderr
@@ -1,8 +1,8 @@
-error: generally you want to avoid `&mut &mut _` if possible
+error: a type of form `&mut &mut _`
   --> tests/ui/mut_mut_unfixable.rs:9:11
    |
 LL | fn fun(x: &mut &mut u32) -> bool {
-   |           ^^^^^^^^^^^^^
+   |           ^^^^^^^^^^^^^ help: remove the extra `&mut`: `&mut u32`
    |
    = note: `-D clippy::mut-mut` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::mut_mut)]`

From c6971c22c1450abaa9f4913db60725df85632e21 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Tue, 5 Aug 2025 12:37:20 +0200
Subject: [PATCH 1518/1889] only lint once on 3+ `&mut`s

for some reason this seems to already be the case with exprs, so only do
it for tys
---
 clippy_lints/src/lib.rs     |  2 +-
 clippy_lints/src/mut_mut.rs | 20 +++++++++++++++++---
 tests/ui/mut_mut.fixed      |  7 +++----
 tests/ui/mut_mut.rs         |  1 -
 tests/ui/mut_mut.stderr     |  8 +-------
 5 files changed, 22 insertions(+), 16 deletions(-)

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 51dabee78e9fb..733113fe0d332 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -482,7 +482,7 @@ pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Co
     store.register_late_pass(|_| Box::new(needless_for_each::NeedlessForEach));
     store.register_late_pass(|_| Box::new(misc::LintPass));
     store.register_late_pass(|_| Box::new(eta_reduction::EtaReduction));
-    store.register_late_pass(|_| Box::new(mut_mut::MutMut));
+    store.register_late_pass(|_| Box::new(mut_mut::MutMut::default()));
     store.register_late_pass(|_| Box::new(unnecessary_mut_passed::UnnecessaryMutPassed));
     store.register_late_pass(|_| Box::<significant_drop_tightening::SignificantDropTightening<'_>>::default());
     store.register_late_pass(|_| Box::new(len_zero::LenZero));
diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs
index 7d7d4fa542c19..968d99143c4b1 100644
--- a/clippy_lints/src/mut_mut.rs
+++ b/clippy_lints/src/mut_mut.rs
@@ -2,11 +2,12 @@ use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
 use clippy_utils::higher;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
+use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
-use rustc_hir::{self as hir, AmbigArg, intravisit};
+use rustc_hir::{self as hir, AmbigArg, HirId, intravisit};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty;
-use rustc_session::declare_lint_pass;
+use rustc_session::impl_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -28,7 +29,12 @@ declare_clippy_lint! {
     "usage of double-mut refs, e.g., `&mut &mut ...`"
 }
 
-declare_lint_pass!(MutMut => [MUT_MUT]);
+impl_lint_pass!(MutMut => [MUT_MUT]);
+
+#[derive(Default)]
+pub(crate) struct MutMut {
+    seen_tys: FxHashSet<HirId>,
+}
 
 impl<'tcx> LateLintPass<'tcx> for MutMut {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx hir::Block<'_>) {
@@ -42,6 +48,14 @@ impl<'tcx> LateLintPass<'tcx> for MutMut {
             && mty2.mutbl == hir::Mutability::Mut
             && !ty.span.in_external_macro(cx.sess().source_map())
         {
+            if self.seen_tys.contains(&ty.hir_id) {
+                // we have 2+ `&mut`s, e.g., `&mut &mut &mut x`
+                // and we have already flagged on the outermost `&mut &mut (&mut x)`,
+                // so don't flag the inner `&mut &mut (x)`
+                return;
+            }
+            self.seen_tys.insert(mty.ty.hir_id);
+
             let mut applicability = Applicability::MaybeIncorrect;
             let sugg = snippet_with_applicability(cx.sess(), mty.ty.span, "..", &mut applicability);
             span_lint_and_sugg(
diff --git a/tests/ui/mut_mut.fixed b/tests/ui/mut_mut.fixed
index 137306064b439..d89129e70b004 100644
--- a/tests/ui/mut_mut.fixed
+++ b/tests/ui/mut_mut.fixed
@@ -12,7 +12,7 @@
 extern crate proc_macros;
 use proc_macros::{external, inline_macros};
 
-fn fun(x: &mut &mut u32) {
+fn fun(x: &mut u32) {
     //~^ mut_mut
 }
 
@@ -37,16 +37,15 @@ fn main() {
     }
 
     {
-        let y: &mut &mut u32 = &mut 2;
+        let y: &mut u32 = &mut 2;
         //~^ mut_mut
         //~| mut_mut
     }
 
     {
-        let y: &mut &mut &mut u32 = &mut &mut 2;
+        let y: &mut &mut u32 = &mut &mut 2;
         //~^ mut_mut
         //~| mut_mut
-        //~| mut_mut
     }
 
     let mut z = inline!(&mut $(&mut 3u32));
diff --git a/tests/ui/mut_mut.rs b/tests/ui/mut_mut.rs
index 92ecfbfc02d12..bbec48011a17e 100644
--- a/tests/ui/mut_mut.rs
+++ b/tests/ui/mut_mut.rs
@@ -46,7 +46,6 @@ fn main() {
         let y: &mut &mut &mut u32 = &mut &mut &mut 2;
         //~^ mut_mut
         //~| mut_mut
-        //~| mut_mut
     }
 
     let mut z = inline!(&mut $(&mut 3u32));
diff --git a/tests/ui/mut_mut.stderr b/tests/ui/mut_mut.stderr
index 341ac643417c7..b30a64d8fe74c 100644
--- a/tests/ui/mut_mut.stderr
+++ b/tests/ui/mut_mut.stderr
@@ -43,11 +43,5 @@ error: a type of form `&mut &mut _`
 LL |         let y: &mut &mut &mut u32 = &mut &mut &mut 2;
    |                ^^^^^^^^^^^^^^^^^^ help: remove the extra `&mut`: `&mut &mut u32`
 
-error: a type of form `&mut &mut _`
-  --> tests/ui/mut_mut.rs:46:21
-   |
-LL |         let y: &mut &mut &mut u32 = &mut &mut &mut 2;
-   |                     ^^^^^^^^^^^^^ help: remove the extra `&mut`: `&mut u32`
-
-error: aborting due to 8 previous errors
+error: aborting due to 7 previous errors
 

From 4053c446541940e878b7a9b4a92cb2c4696b3340 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Tue, 5 Aug 2025 13:31:04 +0200
Subject: [PATCH 1519/1889] misc: import more from `hir`

---
 clippy_lints/src/mut_mut.rs | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs
index 968d99143c4b1..574c0c8f8de0b 100644
--- a/clippy_lints/src/mut_mut.rs
+++ b/clippy_lints/src/mut_mut.rs
@@ -4,7 +4,7 @@ use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
-use rustc_hir::{self as hir, AmbigArg, HirId, intravisit};
+use rustc_hir::{self as hir, AmbigArg, BorrowKind, Expr, ExprKind, HirId, Mutability, TyKind, intravisit};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty;
 use rustc_session::impl_lint_pass;
@@ -42,10 +42,10 @@ impl<'tcx> LateLintPass<'tcx> for MutMut {
     }
 
     fn check_ty(&mut self, cx: &LateContext<'tcx>, ty: &'tcx hir::Ty<'_, AmbigArg>) {
-        if let hir::TyKind::Ref(_, mty) = ty.kind
-            && mty.mutbl == hir::Mutability::Mut
-            && let hir::TyKind::Ref(_, mty2) = mty.ty.kind
-            && mty2.mutbl == hir::Mutability::Mut
+        if let TyKind::Ref(_, mty) = ty.kind
+            && mty.mutbl == Mutability::Mut
+            && let TyKind::Ref(_, mty2) = mty.ty.kind
+            && mty2.mutbl == Mutability::Mut
             && !ty.span.in_external_macro(cx.sess().source_map())
         {
             if self.seen_tys.contains(&ty.hir_id) {
@@ -76,7 +76,7 @@ pub struct MutVisitor<'a, 'tcx> {
 }
 
 impl<'tcx> intravisit::Visitor<'tcx> for MutVisitor<'_, 'tcx> {
-    fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
         if expr.span.in_external_macro(self.cx.sess().source_map()) {
             return;
         }
@@ -90,8 +90,8 @@ impl<'tcx> intravisit::Visitor<'tcx> for MutVisitor<'_, 'tcx> {
             // Let's ignore the generated code.
             intravisit::walk_expr(self, arg);
             intravisit::walk_expr(self, body);
-        } else if let hir::ExprKind::AddrOf(hir::BorrowKind::Ref, hir::Mutability::Mut, e) = expr.kind {
-            if let hir::ExprKind::AddrOf(hir::BorrowKind::Ref, hir::Mutability::Mut, _) = e.kind {
+        } else if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, e) = expr.kind {
+            if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, _) = e.kind {
                 if !expr.span.eq_ctxt(e.span) {
                     return;
                 }
@@ -107,7 +107,7 @@ impl<'tcx> intravisit::Visitor<'tcx> for MutVisitor<'_, 'tcx> {
                         diag.span_suggestion(expr.span, "remove the extra `&mut`", sugg, applicability);
                     },
                 );
-            } else if let ty::Ref(_, ty, hir::Mutability::Mut) = self.cx.typeck_results().expr_ty(e).kind()
+            } else if let ty::Ref(_, ty, Mutability::Mut) = self.cx.typeck_results().expr_ty(e).kind()
                 && ty.peel_refs().is_sized(self.cx.tcx, self.cx.typing_env())
             {
                 let mut applicability = Applicability::MaybeIncorrect;

From 9a1b2bcc9f82f14e8a5215a2a7b9229c7f1df390 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Tue, 5 Aug 2025 13:49:43 +0200
Subject: [PATCH 1520/1889] peel _all_ extra `&mut`s

see
https://rust-lang.zulipchat.com/#narrow/channel/257328-clippy/topic/problem.20when.20suggestion.20only.20removes.20one.20.22level.22.20of.20a.20lint/near/532889973
---
 clippy_lints/src/mut_mut.rs       | 47 ++++++++++++++++++++++++++++---
 tests/ui/mut_mut.fixed            |  2 +-
 tests/ui/mut_mut.stderr           |  4 +--
 tests/ui/mut_mut_unfixable.stderr |  2 +-
 4 files changed, 47 insertions(+), 8 deletions(-)

diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs
index 574c0c8f8de0b..d66daf0c785f8 100644
--- a/clippy_lints/src/mut_mut.rs
+++ b/clippy_lints/src/mut_mut.rs
@@ -56,14 +56,30 @@ impl<'tcx> LateLintPass<'tcx> for MutMut {
             }
             self.seen_tys.insert(mty.ty.hir_id);
 
+            // if there is an even longer chain, like `&mut &mut &mut x`, suggest peeling off
+            // all extra ones at once
+            let (mut t, mut t2) = (mty.ty, mty2.ty);
+            let mut many_muts = false;
+            loop {
+                if let TyKind::Ref(_, next) = t2.kind
+                    && next.mutbl == Mutability::Mut
+                {
+                    (t, t2) = (t2, next.ty);
+                    many_muts = true;
+                } else {
+                    break;
+                }
+            }
+
             let mut applicability = Applicability::MaybeIncorrect;
-            let sugg = snippet_with_applicability(cx.sess(), mty.ty.span, "..", &mut applicability);
+            let sugg = snippet_with_applicability(cx.sess(), t.span, "..", &mut applicability);
+            let suffix = if many_muts { "s" } else { "" };
             span_lint_and_sugg(
                 cx,
                 MUT_MUT,
                 ty.span,
                 "a type of form `&mut &mut _`",
-                "remove the extra `&mut`",
+                format!("remove the extra `&mut`{suffix}"),
                 sugg.to_string(),
                 applicability,
             );
@@ -91,12 +107,30 @@ impl<'tcx> intravisit::Visitor<'tcx> for MutVisitor<'_, 'tcx> {
             intravisit::walk_expr(self, arg);
             intravisit::walk_expr(self, body);
         } else if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, e) = expr.kind {
-            if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, _) = e.kind {
+            if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, e2) = e.kind {
                 if !expr.span.eq_ctxt(e.span) {
                     return;
                 }
+
+                // if there is an even longer chain, like `&mut &mut &mut x`, suggest peeling off
+                // all extra ones at once
+                let (mut e, mut e2) = (e, e2);
+                let mut many_muts = false;
+                loop {
+                    if !e.span.eq_ctxt(e2.span) {
+                        return;
+                    }
+                    if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, next) = e2.kind {
+                        (e, e2) = (e2, next);
+                        many_muts = true;
+                    } else {
+                        break;
+                    }
+                }
+
                 let mut applicability = Applicability::MaybeIncorrect;
                 let sugg = Sugg::hir_with_applicability(self.cx, e, "..", &mut applicability);
+                let suffix = if many_muts { "s" } else { "" };
                 span_lint_hir_and_then(
                     self.cx,
                     MUT_MUT,
@@ -104,7 +138,12 @@ impl<'tcx> intravisit::Visitor<'tcx> for MutVisitor<'_, 'tcx> {
                     expr.span,
                     "an expression of form `&mut &mut _`",
                     |diag| {
-                        diag.span_suggestion(expr.span, "remove the extra `&mut`", sugg, applicability);
+                        diag.span_suggestion(
+                            expr.span,
+                            format!("remove the extra `&mut`{suffix}"),
+                            sugg,
+                            applicability,
+                        );
                     },
                 );
             } else if let ty::Ref(_, ty, Mutability::Mut) = self.cx.typeck_results().expr_ty(e).kind()
diff --git a/tests/ui/mut_mut.fixed b/tests/ui/mut_mut.fixed
index d89129e70b004..f9a7f5dcb5a15 100644
--- a/tests/ui/mut_mut.fixed
+++ b/tests/ui/mut_mut.fixed
@@ -43,7 +43,7 @@ fn main() {
     }
 
     {
-        let y: &mut &mut u32 = &mut &mut 2;
+        let y: &mut u32 = &mut 2;
         //~^ mut_mut
         //~| mut_mut
     }
diff --git a/tests/ui/mut_mut.stderr b/tests/ui/mut_mut.stderr
index b30a64d8fe74c..85e9c5649b89a 100644
--- a/tests/ui/mut_mut.stderr
+++ b/tests/ui/mut_mut.stderr
@@ -35,13 +35,13 @@ error: an expression of form `&mut &mut _`
   --> tests/ui/mut_mut.rs:46:37
    |
 LL |         let y: &mut &mut &mut u32 = &mut &mut &mut 2;
-   |                                     ^^^^^^^^^^^^^^^^ help: remove the extra `&mut`: `&mut &mut 2`
+   |                                     ^^^^^^^^^^^^^^^^ help: remove the extra `&mut`s: `&mut 2`
 
 error: a type of form `&mut &mut _`
   --> tests/ui/mut_mut.rs:46:16
    |
 LL |         let y: &mut &mut &mut u32 = &mut &mut &mut 2;
-   |                ^^^^^^^^^^^^^^^^^^ help: remove the extra `&mut`: `&mut &mut u32`
+   |                ^^^^^^^^^^^^^^^^^^ help: remove the extra `&mut`s: `&mut u32`
 
 error: aborting due to 7 previous errors
 
diff --git a/tests/ui/mut_mut_unfixable.stderr b/tests/ui/mut_mut_unfixable.stderr
index da820f766d027..e967ed3537256 100644
--- a/tests/ui/mut_mut_unfixable.stderr
+++ b/tests/ui/mut_mut_unfixable.stderr
@@ -29,7 +29,7 @@ error: an expression of form `&mut &mut _`
   --> tests/ui/mut_mut_unfixable.rs:30:17
    |
 LL |         let y = &mut &mut &mut 2;
-   |                 ^^^^^^^^^^^^^^^^ help: remove the extra `&mut`: `&mut &mut 2`
+   |                 ^^^^^^^^^^^^^^^^ help: remove the extra `&mut`s: `&mut 2`
 
 error: aborting due to 5 previous errors
 

From 554680683f69f142e97d502b941c0ce8797ad0c6 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Tue, 5 Aug 2025 14:06:50 +0200
Subject: [PATCH 1521/1889] remember all the nested types while we loop

see https://rust-lang.zulipchat.com/#narrow/channel/25732
---
 clippy_lints/src/mut_mut.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs
index d66daf0c785f8..75b8aa9c90cc1 100644
--- a/clippy_lints/src/mut_mut.rs
+++ b/clippy_lints/src/mut_mut.rs
@@ -54,13 +54,15 @@ impl<'tcx> LateLintPass<'tcx> for MutMut {
                 // so don't flag the inner `&mut &mut (x)`
                 return;
             }
-            self.seen_tys.insert(mty.ty.hir_id);
 
             // if there is an even longer chain, like `&mut &mut &mut x`, suggest peeling off
             // all extra ones at once
             let (mut t, mut t2) = (mty.ty, mty2.ty);
             let mut many_muts = false;
             loop {
+                // this should allow us to remember all the nested types, so that the `contains`
+                // above fails faster
+                self.seen_tys.insert(t.hir_id);
                 if let TyKind::Ref(_, next) = t2.kind
                     && next.mutbl == Mutability::Mut
                 {

From 75b68606bc11529c2dd0e0f12dd317b74d40409c Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Tue, 5 Aug 2025 14:12:41 +0200
Subject: [PATCH 1522/1889] add an unfixable case

as recommended in
https://rust-lang.zulipchat.com/#narrow/channel/257328-clippy/topic/problem.20when.20suggestion.20only.20removes.20one.20.22level.22.20of.20a.20lint/near/532894687
---
 tests/ui/mut_mut_unfixable.rs     | 8 ++++++++
 tests/ui/mut_mut_unfixable.stderr | 8 +++++++-
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/tests/ui/mut_mut_unfixable.rs b/tests/ui/mut_mut_unfixable.rs
index db0552a86ec9b..271cb7b968898 100644
--- a/tests/ui/mut_mut_unfixable.rs
+++ b/tests/ui/mut_mut_unfixable.rs
@@ -31,4 +31,12 @@ fn main() {
         //~^ mut_mut
         ***y + **x;
     }
+
+    if fun(x) {
+        // The lint will remove the extra `&mut`, but the result will still be a `&mut` of an expr
+        // of type `&mut _` (x), so the lint will fire again. That's because we've decided that
+        // doing both fixes in one run is not worth it, given how improbable code like this is.
+        let y = &mut &mut x;
+        //~^ mut_mut
+    }
 }
diff --git a/tests/ui/mut_mut_unfixable.stderr b/tests/ui/mut_mut_unfixable.stderr
index e967ed3537256..cf66eb2ed1eca 100644
--- a/tests/ui/mut_mut_unfixable.stderr
+++ b/tests/ui/mut_mut_unfixable.stderr
@@ -31,5 +31,11 @@ error: an expression of form `&mut &mut _`
 LL |         let y = &mut &mut &mut 2;
    |                 ^^^^^^^^^^^^^^^^ help: remove the extra `&mut`s: `&mut 2`
 
-error: aborting due to 5 previous errors
+error: an expression of form `&mut &mut _`
+  --> tests/ui/mut_mut_unfixable.rs:39:17
+   |
+LL |         let y = &mut &mut x;
+   |                 ^^^^^^^^^^^ help: remove the extra `&mut`: `&mut x`
+
+error: aborting due to 6 previous errors
 

From dc534c49b3ce818ade236527149a94a51ea91a34 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Tue, 5 Aug 2025 14:14:41 +0200
Subject: [PATCH 1523/1889] doc: add more examples, and a "Use instead"
 section, don't be condescending

---
 clippy_lints/src/mut_mut.rs | 23 +++++++++++++++++------
 1 file changed, 17 insertions(+), 6 deletions(-)

diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs
index 75b8aa9c90cc1..588afd85afb02 100644
--- a/clippy_lints/src/mut_mut.rs
+++ b/clippy_lints/src/mut_mut.rs
@@ -14,19 +14,30 @@ declare_clippy_lint! {
     /// Checks for instances of `mut mut` references.
     ///
     /// ### Why is this bad?
-    /// Multiple `mut`s don't add anything meaningful to the
-    /// source. This is either a copy'n'paste error, or it shows a fundamental
-    /// misunderstanding of references.
+    /// This is usually just a typo or a misunderstanding of how references work.
     ///
     /// ### Example
     /// ```no_run
-    /// # let mut y = 1;
-    /// let x = &mut &mut y;
+    /// let x = &mut &mut 1;
+    ///
+    /// let mut x = &mut 1;
+    /// let y = &mut x;
+    ///
+    /// fn foo(x: &mut &mut u32) {}
+    /// ```
+    /// Use instead
+    /// ```no_run
+    /// let x = &mut 1;
+    ///
+    /// let mut x = &mut 1;
+    /// let y = &mut *x; // reborrow
+    ///
+    /// fn foo(x: &mut u32) {}
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub MUT_MUT,
     pedantic,
-    "usage of double-mut refs, e.g., `&mut &mut ...`"
+    "usage of double mut-refs, e.g., `&mut &mut ...`"
 }
 
 impl_lint_pass!(MutMut => [MUT_MUT]);

From e52fe65d9a34c7759ff22c210126c22d5a95fc48 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Beno=C3=AEt=20du=20Garreau?= <benoit@dugarreau.fr>
Date: Sun, 28 Sep 2025 15:19:19 +0200
Subject: [PATCH 1524/1889] Move more code to `RawVec::finish_grow`

This move a branch and more code into the cold method `finish_grow`,
which means that less code is inlined at each `try_reserve` site.
Additionally, this reduces the amount of parameters, so they can all be
passed by registers.
---
 library/alloc/src/raw_vec/mod.rs | 95 ++++++++++++++------------------
 1 file changed, 40 insertions(+), 55 deletions(-)

diff --git a/library/alloc/src/raw_vec/mod.rs b/library/alloc/src/raw_vec/mod.rs
index bc9692f5b6c2f..236e33e2f450e 100644
--- a/library/alloc/src/raw_vec/mod.rs
+++ b/library/alloc/src/raw_vec/mod.rs
@@ -668,8 +668,7 @@ impl<A: Allocator> RawVecInner<A> {
     /// - `elem_layout` must be valid for `self`, i.e. it must be the same `elem_layout` used to
     ///   initially construct `self`
     /// - `elem_layout`'s size must be a multiple of its alignment
-    /// - The sum of `len` and `additional` must be greater than or equal to
-    ///   `self.capacity(elem_layout.size())`
+    /// - The sum of `len` and `additional` must be greater than the current capacity
     unsafe fn grow_amortized(
         &mut self,
         len: usize,
@@ -693,16 +692,12 @@ impl<A: Allocator> RawVecInner<A> {
         let cap = cmp::max(self.cap.as_inner() * 2, required_cap);
         let cap = cmp::max(min_non_zero_cap(elem_layout.size()), cap);
 
-        let new_layout = layout_array(cap, elem_layout)?;
-
         // SAFETY:
-        // - For the `current_memory` call: Precondition passed to caller
-        // - For the `finish_grow` call: Precondition passed to caller
-        //   + `current_memory` does the right thing
-        let ptr =
-            unsafe { finish_grow(new_layout, self.current_memory(elem_layout), &mut self.alloc)? };
+        // - cap >= len + additional
+        // - other preconditions passed to caller
+        let ptr = unsafe { self.finish_grow(cap, elem_layout)? };
 
-        // SAFETY: layout_array would have resulted in a capacity overflow if we tried to allocate more than `isize::MAX` items
+        // SAFETY: `finish_grow` would have failed if `cap > isize::MAX`
         unsafe { self.set_ptr_and_cap(ptr, cap) };
         Ok(())
     }
@@ -711,8 +706,7 @@ impl<A: Allocator> RawVecInner<A> {
     /// - `elem_layout` must be valid for `self`, i.e. it must be the same `elem_layout` used to
     ///   initially construct `self`
     /// - `elem_layout`'s size must be a multiple of its alignment
-    /// - The sum of `len` and `additional` must be greater than or equal to
-    ///   `self.capacity(elem_layout.size())`
+    /// - The sum of `len` and `additional` must be greater than the current capacity
     unsafe fn grow_exact(
         &mut self,
         len: usize,
@@ -726,21 +720,44 @@ impl<A: Allocator> RawVecInner<A> {
         }
 
         let cap = len.checked_add(additional).ok_or(CapacityOverflow)?;
-        let new_layout = layout_array(cap, elem_layout)?;
 
-        // SAFETY:
-        // - For the `current_memory` call: Precondition passed to caller
-        // - For the `finish_grow` call: Precondition passed to caller
-        //   + `current_memory` does the right thing
-        let ptr =
-            unsafe { finish_grow(new_layout, self.current_memory(elem_layout), &mut self.alloc)? };
-        // SAFETY: layout_array would have resulted in a capacity overflow if we tried to allocate more than `isize::MAX` items
-        unsafe {
-            self.set_ptr_and_cap(ptr, cap);
-        }
+        // SAFETY: preconditions passed to caller
+        let ptr = unsafe { self.finish_grow(cap, elem_layout)? };
+
+        // SAFETY: `finish_grow` would have failed if `cap > isize::MAX`
+        unsafe { self.set_ptr_and_cap(ptr, cap) };
         Ok(())
     }
 
+    /// # Safety
+    /// - `elem_layout` must be valid for `self`, i.e. it must be the same `elem_layout` used to
+    ///   initially construct `self`
+    /// - `elem_layout`'s size must be a multiple of its alignment
+    /// - `cap` must be greater than the current capacity
+    // not marked inline(never) since we want optimizers to be able to observe the specifics of this
+    // function, see tests/codegen-llvm/vec-reserve-extend.rs.
+    #[cold]
+    unsafe fn finish_grow(
+        &self,
+        cap: usize,
+        elem_layout: Layout,
+    ) -> Result<NonNull<[u8]>, TryReserveError> {
+        let new_layout = layout_array(cap, elem_layout)?;
+
+        let memory = if let Some((ptr, old_layout)) = unsafe { self.current_memory(elem_layout) } {
+            debug_assert_eq!(old_layout.align(), new_layout.align());
+            unsafe {
+                // The allocator checks for alignment equality
+                hint::assert_unchecked(old_layout.align() == new_layout.align());
+                self.alloc.grow(ptr, old_layout, new_layout)
+            }
+        } else {
+            self.alloc.allocate(new_layout)
+        };
+
+        memory.map_err(|_| AllocError { layout: new_layout, non_exhaustive: () }.into())
+    }
+
     /// # Safety
     /// - `elem_layout` must be valid for `self`, i.e. it must be the same `elem_layout` used to
     ///   initially construct `self`
@@ -820,38 +837,6 @@ impl<A: Allocator> RawVecInner<A> {
     }
 }
 
-/// # Safety
-/// If `current_memory` matches `Some((ptr, old_layout))`:
-/// - `ptr` must denote a block of memory *currently allocated* via `alloc`
-/// - `old_layout` must *fit* that block of memory
-/// - `new_layout` must have the same alignment as `old_layout`
-/// - `new_layout.size()` must be greater than or equal to `old_layout.size()`
-/// If `current_memory` is `None`, this function is safe.
-// not marked inline(never) since we want optimizers to be able to observe the specifics of this
-// function, see tests/codegen-llvm/vec-reserve-extend.rs.
-#[cold]
-unsafe fn finish_grow<A>(
-    new_layout: Layout,
-    current_memory: Option<(NonNull<u8>, Layout)>,
-    alloc: &mut A,
-) -> Result<NonNull<[u8]>, TryReserveError>
-where
-    A: Allocator,
-{
-    let memory = if let Some((ptr, old_layout)) = current_memory {
-        debug_assert_eq!(old_layout.align(), new_layout.align());
-        unsafe {
-            // The allocator checks for alignment equality
-            hint::assert_unchecked(old_layout.align() == new_layout.align());
-            alloc.grow(ptr, old_layout, new_layout)
-        }
-    } else {
-        alloc.allocate(new_layout)
-    };
-
-    memory.map_err(|_| AllocError { layout: new_layout, non_exhaustive: () }.into())
-}
-
 // Central function for reserve error handling.
 #[cfg(not(no_global_oom_handling))]
 #[cold]

From 6b4febeeb7be931c9317bf987604bbd94967cd94 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sun, 28 Sep 2025 15:39:57 +0200
Subject: [PATCH 1525/1889] simplify and inline `is_async_fn`

---
 clippy_lints/src/cognitive_complexity.rs |  4 ++--
 clippy_lints/src/implicit_return.rs      |  4 ++--
 clippy_utils/src/lib.rs                  | 11 +----------
 3 files changed, 5 insertions(+), 14 deletions(-)

diff --git a/clippy_lints/src/cognitive_complexity.rs b/clippy_lints/src/cognitive_complexity.rs
index 7646aa48b7726..c0f30e456d8db 100644
--- a/clippy_lints/src/cognitive_complexity.rs
+++ b/clippy_lints/src/cognitive_complexity.rs
@@ -3,7 +3,7 @@ use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::{IntoSpan, SpanRangeExt};
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::for_each_expr_without_closures;
-use clippy_utils::{LimitStack, get_async_fn_body, is_async_fn, sym};
+use clippy_utils::{LimitStack, get_async_fn_body, sym};
 use core::ops::ControlFlow;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Attribute, Body, Expr, ExprKind, FnDecl};
@@ -147,7 +147,7 @@ impl<'tcx> LateLintPass<'tcx> for CognitiveComplexity {
         def_id: LocalDefId,
     ) {
         if !cx.tcx.has_attr(def_id, sym::test) {
-            let expr = if is_async_fn(kind) {
+            let expr = if kind.asyncness().is_async() {
                 match get_async_fn_body(cx.tcx, body) {
                     Some(b) => b,
                     None => {
diff --git a/clippy_lints/src/implicit_return.rs b/clippy_lints/src/implicit_return.rs
index 076017a247b4b..6ed478b2708a3 100644
--- a/clippy_lints/src/implicit_return.rs
+++ b/clippy_lints/src/implicit_return.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context, walk_span_to_context};
 use clippy_utils::visitors::for_each_expr_without_closures;
-use clippy_utils::{desugar_await, get_async_closure_expr, get_async_fn_body, is_async_fn, is_from_proc_macro};
+use clippy_utils::{desugar_await, get_async_closure_expr, get_async_fn_body, is_from_proc_macro};
 use core::ops::ControlFlow;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
@@ -240,7 +240,7 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitReturn {
             return;
         }
 
-        let expr = if is_async_fn(kind) {
+        let expr = if kind.asyncness().is_async() {
             match get_async_fn_body(cx.tcx, body) {
                 Some(e) => e,
                 None => return,
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index d6586625a1e5e..708491df77079 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -98,7 +98,7 @@ use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{DefId, LocalDefId, LocalModDefId};
 use rustc_hir::definitions::{DefPath, DefPathData};
 use rustc_hir::hir_id::{HirIdMap, HirIdSet};
-use rustc_hir::intravisit::{FnKind, Visitor, walk_expr};
+use rustc_hir::intravisit::{Visitor, walk_expr};
 use rustc_hir::{
     self as hir, Arm, BindingMode, Block, BlockCheckMode, Body, ByRef, Closure, ConstArgKind, CoroutineDesugaring,
     CoroutineKind, CoroutineSource, Destination, Expr, ExprField, ExprKind, FnDecl, FnRetTy, GenericArg, GenericArgs,
@@ -1854,15 +1854,6 @@ pub fn if_sequence<'tcx>(mut expr: &'tcx Expr<'tcx>) -> (Vec<&'tcx Expr<'tcx>>,
     (conds, blocks)
 }
 
-/// Checks if the given function kind is an async function.
-pub fn is_async_fn(kind: FnKind<'_>) -> bool {
-    match kind {
-        FnKind::ItemFn(_, _, header) => header.asyncness.is_async(),
-        FnKind::Method(_, sig) => sig.header.asyncness.is_async(),
-        FnKind::Closure => false,
-    }
-}
-
 /// Peels away all the compiler generated code surrounding the body of an async closure.
 pub fn get_async_closure_expr<'tcx>(tcx: TyCtxt<'tcx>, expr: &Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
     if let ExprKind::Closure(&Closure {

From 7a7cb05f11a81e261e22f9ae291755b6343f7095 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Sat, 27 Sep 2025 13:28:25 +0000
Subject: [PATCH 1526/1889] Do not validate MIR if code does not type-check.

---
 compiler/rustc_interface/src/passes.rs | 26 ++++++++++++++------------
 tests/crashes/129095.rs                | 13 -------------
 tests/crashes/134174.rs                | 17 -----------------
 tests/crashes/134654.rs                | 15 ---------------
 tests/crashes/135570.rs                | 15 ---------------
 tests/crashes/136381.rs                | 18 ------------------
 tests/crashes/137190-1.rs              | 10 ----------
 tests/crashes/137468.rs                | 16 ----------------
 8 files changed, 14 insertions(+), 116 deletions(-)
 delete mode 100644 tests/crashes/129095.rs
 delete mode 100644 tests/crashes/134174.rs
 delete mode 100644 tests/crashes/134654.rs
 delete mode 100644 tests/crashes/135570.rs
 delete mode 100644 tests/crashes/136381.rs
 delete mode 100644 tests/crashes/137190-1.rs
 delete mode 100644 tests/crashes/137468.rs

diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs
index 761a5c8091822..c1bba0b01975e 100644
--- a/compiler/rustc_interface/src/passes.rs
+++ b/compiler/rustc_interface/src/passes.rs
@@ -1122,18 +1122,6 @@ fn run_required_analyses(tcx: TyCtxt<'_>) {
 
     sess.time("layout_testing", || layout_test::test_layout(tcx));
     sess.time("abi_testing", || abi_test::test_abi(tcx));
-
-    // If `-Zvalidate-mir` is set, we also want to compute the final MIR for each item
-    // (either its `mir_for_ctfe` or `optimized_mir`) since that helps uncover any bugs
-    // in MIR optimizations that may only be reachable through codegen, or other codepaths
-    // that requires the optimized/ctfe MIR, coroutine bodies, or evaluating consts.
-    if tcx.sess.opts.unstable_opts.validate_mir {
-        sess.time("ensuring_final_MIR_is_computable", || {
-            tcx.par_hir_body_owners(|def_id| {
-                tcx.instance_mir(ty::InstanceKind::Item(def_id.into()));
-            });
-        });
-    }
 }
 
 /// Runs the type-checking, region checking and other miscellaneous analysis
@@ -1199,6 +1187,20 @@ fn analysis(tcx: TyCtxt<'_>, (): ()) {
         // we will fail to emit overlap diagnostics. Thus we invoke it here unconditionally.
         let _ = tcx.all_diagnostic_items(());
     });
+
+    // If `-Zvalidate-mir` is set, we also want to compute the final MIR for each item
+    // (either its `mir_for_ctfe` or `optimized_mir`) since that helps uncover any bugs
+    // in MIR optimizations that may only be reachable through codegen, or other codepaths
+    // that requires the optimized/ctfe MIR, coroutine bodies, or evaluating consts.
+    // Nevertheless, wait after type checking is finished, as optimizing code that does not
+    // type-check is very prone to ICEs.
+    if tcx.sess.opts.unstable_opts.validate_mir {
+        sess.time("ensuring_final_MIR_is_computable", || {
+            tcx.par_hir_body_owners(|def_id| {
+                tcx.instance_mir(ty::InstanceKind::Item(def_id.into()));
+            });
+        });
+    }
 }
 
 /// Runs the codegen backend, after which the AST and analysis can
diff --git a/tests/crashes/129095.rs b/tests/crashes/129095.rs
deleted file mode 100644
index b1bb74708c2d7..0000000000000
--- a/tests/crashes/129095.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ known-bug: rust-lang/rust#129095
-//@ compile-flags: -Zmir-enable-passes=+GVN -Zmir-enable-passes=+Inline -Zvalidate-mir
-
-#![feature(adt_const_params, unsized_const_params)]
-#![allow(incomplete_features)]
-
-pub fn function_with_bytes<const BYTES: &'static [u8; 4]>() -> &'static [u8] {
-    BYTES
-}
-
-pub fn main() {
-    assert_eq!(function_with_bytes::<b"AAAAA">(), &[0x41, 0x41, 0x41, 0x41]);
-}
diff --git a/tests/crashes/134174.rs b/tests/crashes/134174.rs
deleted file mode 100644
index 899cdc6faf358..0000000000000
--- a/tests/crashes/134174.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ known-bug: #134175
-//@compile-flags: -Zvalidate-mir -Zinline-mir=yes
-use std::vec::IntoIter;
-
-pub(crate) trait Foo: Iterator<Item = <Self as Foo>::Key> {
-    type Key;
-}
-
-impl Foo for IntoIter<i16> {}
-
-fn sum_foo<F: Foo<Key = i32>>(f: F) -> i32 {
-    f.fold(0, |a, b| a + b)
-}
-
-fn main() {
-    let x = sum_foo(vec![11, 10, 1].into_iter());
-}
diff --git a/tests/crashes/134654.rs b/tests/crashes/134654.rs
deleted file mode 100644
index f2323fe4ecdcd..0000000000000
--- a/tests/crashes/134654.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//@ known-bug: #134654
-//@ compile-flags: -Zmir-enable-passes=+GVN -Zmir-enable-passes=+Inline -Zvalidate-mir
-//@ only-x86_64
-
-#![feature(adt_const_params, unsized_const_params)]
-#![allow(incomplete_features)]
-
-fn function_with_bytes<const BYTES:
-    &'static [u8; 0xa9008fb6c9d81e42_0e25730562a601c8_u128]>() -> &'static [u8] {
-    BYTES
-}
-
-fn main() {
-    function_with_bytes::<b"aa">() == &[];
-}
diff --git a/tests/crashes/135570.rs b/tests/crashes/135570.rs
deleted file mode 100644
index 7919ceb26d50d..0000000000000
--- a/tests/crashes/135570.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//@ known-bug: #135570
-//@compile-flags: -Zvalidate-mir -Zmir-enable-passes=+Inline -Copt-level=0 -Zmir-enable-passes=+GVN
-//@ only-x86_64
-
-#![feature(adt_const_params, unsized_const_params)]
-#![allow(incomplete_features)]
-
-fn function_with_bytes<const BYTES: &'static [u8; 0xc7b889180b67b07d_bc1a3c88783d35b5_u128]>(
-) -> &'static [u8] {
-    BYTES
-}
-
-fn main() {
-    function_with_bytes::<b"aa">() == &[];
-}
diff --git a/tests/crashes/136381.rs b/tests/crashes/136381.rs
deleted file mode 100644
index 13ccc14a2c5be..0000000000000
--- a/tests/crashes/136381.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-//@ known-bug: #136381
-//@ compile-flags: -Zvalidate-mir -Zmir-enable-passes=+GVN
-#![feature(trait_upcasting)]
-
-trait A {}
-trait B: A {
-    fn c(&self);
-}
-impl B for i32 {
-    fn c(self) {
-        todo!();
-    }
-}
-
-fn main() {
-    let baz: &dyn B = &1;
-    let bar: &dyn A = baz;
-}
diff --git a/tests/crashes/137190-1.rs b/tests/crashes/137190-1.rs
deleted file mode 100644
index bdfe883b71207..0000000000000
--- a/tests/crashes/137190-1.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ known-bug: #137190
-//@ compile-flags: -Zmir-opt-level=2 -Zvalidate-mir
-trait A {
-    fn b(&self);
-}
-trait C: A {}
-impl C for () {}
-fn main() {
-    (&() as &dyn C as &dyn A).b();
-}
diff --git a/tests/crashes/137468.rs b/tests/crashes/137468.rs
deleted file mode 100644
index cceb0502bd21b..0000000000000
--- a/tests/crashes/137468.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//@ known-bug: #137468
-//@ compile-flags: -Copt-level=0 -Zmir-enable-passes=+GVN -Zvalidate-mir
-trait Supertrait<T> {}
-
-trait Identity {
-    type Selff;
-}
-
-trait Trait<P>: Supertrait<()> + Supertrait<<P as Identity>::Selff> {}
-
-impl<P> Trait<P> for () {}
-
-fn main() {
-    let x: &dyn Trait<()> = &();
-    let x: &dyn Supertrait<()> = x;
-}

From 7fcbc5ea465a4e280d3b7a84fc3f781e9a120ed0 Mon Sep 17 00:00:00 2001
From: Antoni Boucher <bouanto@zoho.com>
Date: Sun, 28 Sep 2025 12:08:44 -0400
Subject: [PATCH 1527/1889] Add a leading dash to linker plugin arguments in
 the gcc codegen

---
 compiler/rustc_codegen_cranelift/src/lib.rs         |  4 ++++
 compiler/rustc_codegen_gcc/src/lib.rs               |  4 ++++
 compiler/rustc_codegen_llvm/src/lib.rs              | 13 ++++++++++++-
 compiler/rustc_codegen_ssa/src/back/link.rs         |  6 ++++++
 compiler/rustc_codegen_ssa/src/back/linker.rs       | 13 +++++++++++--
 compiler/rustc_codegen_ssa/src/traits/backend.rs    | 11 ++++++++++-
 .../codegen-backend/auxiliary/the_backend.rs        |  4 ++++
 7 files changed, 51 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_codegen_cranelift/src/lib.rs b/compiler/rustc_codegen_cranelift/src/lib.rs
index 8e34436fb5e0a..5fd7c4d4f41bb 100644
--- a/compiler/rustc_codegen_cranelift/src/lib.rs
+++ b/compiler/rustc_codegen_cranelift/src/lib.rs
@@ -165,6 +165,10 @@ impl CodegenBackend for CraneliftCodegenBackend {
         ""
     }
 
+    fn name(&self) -> &'static str {
+        "cranelift"
+    }
+
     fn init(&self, sess: &Session) {
         use rustc_session::config::{InstrumentCoverage, Lto};
         match sess.lto() {
diff --git a/compiler/rustc_codegen_gcc/src/lib.rs b/compiler/rustc_codegen_gcc/src/lib.rs
index f76f933cad4a5..ec7eab8489ab8 100644
--- a/compiler/rustc_codegen_gcc/src/lib.rs
+++ b/compiler/rustc_codegen_gcc/src/lib.rs
@@ -184,6 +184,10 @@ impl CodegenBackend for GccCodegenBackend {
         crate::DEFAULT_LOCALE_RESOURCE
     }
 
+    fn name(&self) -> &'static str {
+        "gcc"
+    }
+
     fn init(&self, _sess: &Session) {
         #[cfg(feature = "master")]
         {
diff --git a/compiler/rustc_codegen_llvm/src/lib.rs b/compiler/rustc_codegen_llvm/src/lib.rs
index 13bdb7cb1a274..e96eb304c50cb 100644
--- a/compiler/rustc_codegen_llvm/src/lib.rs
+++ b/compiler/rustc_codegen_llvm/src/lib.rs
@@ -231,6 +231,10 @@ impl CodegenBackend for LlvmCodegenBackend {
         crate::DEFAULT_LOCALE_RESOURCE
     }
 
+    fn name(&self) -> &'static str {
+        "llvm"
+    }
+
     fn init(&self, sess: &Session) {
         llvm_util::init(sess); // Make sure llvm is inited
     }
@@ -349,7 +353,14 @@ impl CodegenBackend for LlvmCodegenBackend {
 
         // Run the linker on any artifacts that resulted from the LLVM run.
         // This should produce either a finished executable or library.
-        link_binary(sess, &LlvmArchiveBuilderBuilder, codegen_results, metadata, outputs);
+        link_binary(
+            sess,
+            &LlvmArchiveBuilderBuilder,
+            codegen_results,
+            metadata,
+            outputs,
+            self.name(),
+        );
     }
 }
 
diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
index d6c304c1b1475..db2f2dd65b0b5 100644
--- a/compiler/rustc_codegen_ssa/src/back/link.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -79,6 +79,7 @@ pub fn link_binary(
     codegen_results: CodegenResults,
     metadata: EncodedMetadata,
     outputs: &OutputFilenames,
+    codegen_backend: &'static str,
 ) {
     let _timer = sess.timer("link_binary");
     let output_metadata = sess.opts.output_types.contains_key(&OutputType::Metadata);
@@ -154,6 +155,7 @@ pub fn link_binary(
                         &codegen_results,
                         &metadata,
                         path.as_ref(),
+                        codegen_backend,
                     );
                 }
             }
@@ -680,6 +682,7 @@ fn link_natively(
     codegen_results: &CodegenResults,
     metadata: &EncodedMetadata,
     tmpdir: &Path,
+    codegen_backend: &'static str,
 ) {
     info!("preparing {:?} to {:?}", crate_type, out_filename);
     let (linker_path, flavor) = linker_and_flavor(sess);
@@ -705,6 +708,7 @@ fn link_natively(
         codegen_results,
         metadata,
         self_contained_components,
+        codegen_backend,
     );
 
     linker::disable_localization(&mut cmd);
@@ -2208,6 +2212,7 @@ fn linker_with_args(
     codegen_results: &CodegenResults,
     metadata: &EncodedMetadata,
     self_contained_components: LinkSelfContainedComponents,
+    codegen_backend: &'static str,
 ) -> Command {
     let self_contained_crt_objects = self_contained_components.is_crt_objects_enabled();
     let cmd = &mut *super::linker::get_linker(
@@ -2216,6 +2221,7 @@ fn linker_with_args(
         flavor,
         self_contained_components.are_any_components_enabled(),
         &codegen_results.crate_info.target_cpu,
+        codegen_backend,
     );
     let link_output_kind = link_output_kind(sess, crate_type);
 
diff --git a/compiler/rustc_codegen_ssa/src/back/linker.rs b/compiler/rustc_codegen_ssa/src/back/linker.rs
index 624ab1b50848d..e644a43f88340 100644
--- a/compiler/rustc_codegen_ssa/src/back/linker.rs
+++ b/compiler/rustc_codegen_ssa/src/back/linker.rs
@@ -52,6 +52,7 @@ pub(crate) fn get_linker<'a>(
     flavor: LinkerFlavor,
     self_contained: bool,
     target_cpu: &'a str,
+    codegen_backend: &'static str,
 ) -> Box<dyn Linker + 'a> {
     let msvc_tool = find_msvc_tools::find_tool(&sess.target.arch, "link.exe");
 
@@ -154,6 +155,7 @@ pub(crate) fn get_linker<'a>(
             is_ld: cc == Cc::No,
             is_gnu: flavor.is_gnu(),
             uses_lld: flavor.uses_lld(),
+            codegen_backend,
         }) as Box<dyn Linker>,
         LinkerFlavor::Msvc(..) => Box::new(MsvcLinker { cmd, sess }) as Box<dyn Linker>,
         LinkerFlavor::EmCc => Box::new(EmLinker { cmd, sess }) as Box<dyn Linker>,
@@ -367,6 +369,7 @@ struct GccLinker<'a> {
     is_ld: bool,
     is_gnu: bool,
     uses_lld: bool,
+    codegen_backend: &'static str,
 }
 
 impl<'a> GccLinker<'a> {
@@ -423,9 +426,15 @@ impl<'a> GccLinker<'a> {
         if let Some(path) = &self.sess.opts.unstable_opts.profile_sample_use {
             self.link_arg(&format!("-plugin-opt=sample-profile={}", path.display()));
         };
+        let prefix = if self.codegen_backend == "gcc" {
+            // The GCC linker plugin requires a leading dash.
+            "-"
+        } else {
+            ""
+        };
         self.link_args(&[
-            &format!("-plugin-opt={opt_level}"),
-            &format!("-plugin-opt=mcpu={}", self.target_cpu),
+            &format!("-plugin-opt={prefix}{opt_level}"),
+            &format!("-plugin-opt={prefix}mcpu={}", self.target_cpu),
         ]);
     }
 
diff --git a/compiler/rustc_codegen_ssa/src/traits/backend.rs b/compiler/rustc_codegen_ssa/src/traits/backend.rs
index 29ec7eb1da3b3..2400160075e2d 100644
--- a/compiler/rustc_codegen_ssa/src/traits/backend.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/backend.rs
@@ -41,6 +41,8 @@ pub trait CodegenBackend {
     /// Called before `init` so that all other functions are able to emit translatable diagnostics.
     fn locale_resource(&self) -> &'static str;
 
+    fn name(&self) -> &'static str;
+
     fn init(&self, _sess: &Session) {}
 
     fn print(&self, _req: &PrintRequest, _out: &mut String, _sess: &Session) {}
@@ -96,7 +98,14 @@ pub trait CodegenBackend {
         metadata: EncodedMetadata,
         outputs: &OutputFilenames,
     ) {
-        link_binary(sess, &ArArchiveBuilderBuilder, codegen_results, metadata, outputs);
+        link_binary(
+            sess,
+            &ArArchiveBuilderBuilder,
+            codegen_results,
+            metadata,
+            outputs,
+            self.name(),
+        );
     }
 }
 
diff --git a/tests/ui-fulldeps/codegen-backend/auxiliary/the_backend.rs b/tests/ui-fulldeps/codegen-backend/auxiliary/the_backend.rs
index 8449479287f0f..48f328f4fad36 100644
--- a/tests/ui-fulldeps/codegen-backend/auxiliary/the_backend.rs
+++ b/tests/ui-fulldeps/codegen-backend/auxiliary/the_backend.rs
@@ -33,6 +33,10 @@ impl CodegenBackend for TheBackend {
         ""
     }
 
+    fn name(&self) -> &'static str {
+        "the-backend"
+    }
+
     fn codegen_crate(&self, tcx: TyCtxt<'_>) -> Box<dyn Any> {
         Box::new(CodegenResults {
             modules: vec![],

From 599e8db8389111d5c27934c5294879d9caf262e1 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Sat, 27 Sep 2025 00:14:32 +0000
Subject: [PATCH 1528/1889] Use MirPatch in simplify_branches.

---
 compiler/rustc_mir_transform/src/patch.rs     | 30 +++++++++++++++----
 .../src/simplify_branches.rs                  | 19 +++++++-----
 2 files changed, 37 insertions(+), 12 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/patch.rs b/compiler/rustc_mir_transform/src/patch.rs
index d831ab50b1ac0..cc8ea76011bf6 100644
--- a/compiler/rustc_mir_transform/src/patch.rs
+++ b/compiler/rustc_mir_transform/src/patch.rs
@@ -11,6 +11,8 @@ use tracing::debug;
 /// once with `apply`. This is useful for MIR transformation passes.
 pub(crate) struct MirPatch<'tcx> {
     term_patch_map: FxHashMap<BasicBlock, TerminatorKind<'tcx>>,
+    /// Set of statements that should be replaced by `Nop`.
+    nop_statements: Vec<Location>,
     new_blocks: Vec<BasicBlockData<'tcx>>,
     new_statements: Vec<(Location, StatementKind<'tcx>)>,
     new_locals: Vec<LocalDecl<'tcx>>,
@@ -33,6 +35,7 @@ impl<'tcx> MirPatch<'tcx> {
     pub(crate) fn new(body: &Body<'tcx>) -> Self {
         let mut result = MirPatch {
             term_patch_map: Default::default(),
+            nop_statements: vec![],
             new_blocks: vec![],
             new_statements: vec![],
             new_locals: vec![],
@@ -212,6 +215,15 @@ impl<'tcx> MirPatch<'tcx> {
         self.term_patch_map.insert(block, new);
     }
 
+    /// Mark given statement to be replaced by a `Nop`.
+    ///
+    /// This method only works on statements from the initial body, and cannot be used to remove
+    /// statements from `add_statement` or `add_assign`.
+    #[tracing::instrument(level = "debug", skip(self))]
+    pub(crate) fn nop_statement(&mut self, loc: Location) {
+        self.nop_statements.push(loc);
+    }
+
     /// Queues the insertion of a statement at a given location. The statement
     /// currently at that location, and all statements that follow, are shifted
     /// down. If multiple statements are queued for addition at the same
@@ -257,11 +269,8 @@ impl<'tcx> MirPatch<'tcx> {
         bbs.extend(self.new_blocks);
         body.local_decls.extend(self.new_locals);
 
-        // The order in which we patch terminators does not change the result.
-        #[allow(rustc::potential_query_instability)]
-        for (src, patch) in self.term_patch_map {
-            debug!("MirPatch: patching block {:?}", src);
-            bbs[src].terminator_mut().kind = patch;
+        for loc in self.nop_statements {
+            bbs[loc.block].statements[loc.statement_index].make_nop();
         }
 
         let mut new_statements = self.new_statements;
@@ -285,6 +294,17 @@ impl<'tcx> MirPatch<'tcx> {
                 .insert(loc.statement_index, Statement::new(source_info, stmt));
             delta += 1;
         }
+
+        // The order in which we patch terminators does not change the result.
+        #[allow(rustc::potential_query_instability)]
+        for (src, patch) in self.term_patch_map {
+            debug!("MirPatch: patching block {:?}", src);
+            let bb = &mut bbs[src];
+            if let TerminatorKind::Unreachable = patch {
+                bb.statements.clear();
+            }
+            bb.terminator_mut().kind = patch;
+        }
     }
 
     fn source_info_for_index(data: &BasicBlockData<'_>, loc: Location) -> SourceInfo {
diff --git a/compiler/rustc_mir_transform/src/simplify_branches.rs b/compiler/rustc_mir_transform/src/simplify_branches.rs
index 886f4d6e50900..ed94a058ec6d9 100644
--- a/compiler/rustc_mir_transform/src/simplify_branches.rs
+++ b/compiler/rustc_mir_transform/src/simplify_branches.rs
@@ -2,6 +2,8 @@ use rustc_middle::mir::*;
 use rustc_middle::ty::TyCtxt;
 use tracing::trace;
 
+use crate::patch::MirPatch;
+
 pub(super) enum SimplifyConstCondition {
     AfterConstProp,
     Final,
@@ -19,8 +21,10 @@ impl<'tcx> crate::MirPass<'tcx> for SimplifyConstCondition {
     fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
         trace!("Running SimplifyConstCondition on {:?}", body.source);
         let typing_env = body.typing_env(tcx);
-        'blocks: for block in body.basic_blocks_mut() {
-            for stmt in block.statements.iter_mut() {
+        let mut patch = MirPatch::new(body);
+
+        'blocks: for (bb, block) in body.basic_blocks.iter_enumerated() {
+            for (statement_index, stmt) in block.statements.iter().enumerate() {
                 // Simplify `assume` of a known value: either a NOP or unreachable.
                 if let StatementKind::Intrinsic(box ref intrinsic) = stmt.kind
                     && let NonDivergingIntrinsic::Assume(discr) = intrinsic
@@ -28,17 +32,16 @@ impl<'tcx> crate::MirPass<'tcx> for SimplifyConstCondition {
                     && let Some(constant) = c.const_.try_eval_bool(tcx, typing_env)
                 {
                     if constant {
-                        stmt.make_nop();
+                        patch.nop_statement(Location { block: bb, statement_index });
                     } else {
-                        block.statements.clear();
-                        block.terminator_mut().kind = TerminatorKind::Unreachable;
+                        patch.patch_terminator(bb, TerminatorKind::Unreachable);
                         continue 'blocks;
                     }
                 }
             }
 
-            let terminator = block.terminator_mut();
-            terminator.kind = match terminator.kind {
+            let terminator = block.terminator();
+            let terminator = match terminator.kind {
                 TerminatorKind::SwitchInt {
                     discr: Operand::Constant(ref c), ref targets, ..
                 } => {
@@ -58,7 +61,9 @@ impl<'tcx> crate::MirPass<'tcx> for SimplifyConstCondition {
                 },
                 _ => continue,
             };
+            patch.patch_terminator(bb, terminator);
         }
+        patch.apply(body);
     }
 
     fn is_required(&self) -> bool {

From 632f2cb8a47cc16d7e1e6231ac25ba4711c32be8 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sun, 28 Sep 2025 22:32:21 +0200
Subject: [PATCH 1529/1889] Remove one loop in `extract_cfg_from_attrs`

---
 src/librustdoc/clean/types.rs | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index c2cf39c4be06e..d4f0a196eda8d 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -1085,7 +1085,7 @@ pub(crate) fn extract_cfg_from_attrs<'a, I: Iterator<Item = &'a hir::Attribute>
     let mut changed_auto_active_status = None;
 
     // First we get all `doc(auto_cfg)` attributes.
-    for attr in attrs.clone() {
+    for attr in attrs {
         if let Some(ident) = attr.ident()
             && ident.name == sym::doc
             && let Some(attrs) = attr.meta_item_list()
@@ -1146,13 +1146,9 @@ pub(crate) fn extract_cfg_from_attrs<'a, I: Iterator<Item = &'a hir::Attribute>
                     }
                 }
             }
-        }
-    }
-
-    // If there is no `doc(cfg())`, then we retrieve the `cfg()` attributes (because
-    // `doc(cfg())` overrides `cfg()`).
-    for attr in attrs {
-        if let hir::Attribute::Parsed(AttributeKind::TargetFeature { features, .. }) = attr {
+        // If there is no `doc(cfg())`, then we retrieve the `cfg()` attributes (because
+        // `doc(cfg())` overrides `cfg()`).
+        } else if let hir::Attribute::Parsed(AttributeKind::TargetFeature { features, .. }) = attr {
             // treat #[target_feature(enable = "feat")] attributes as if they were
             // #[doc(cfg(target_feature = "feat"))] attributes as well
             for (feature, _) in features {

From c3e0b29e79f347edf7e0ae559bfec2d3cdf353d8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Fri, 29 Aug 2025 19:35:22 +0000
Subject: [PATCH 1530/1889] Point at fn bound that introduced lifetime
 obligation

```
error[E0597]: `c` does not live long enough
  --> $DIR/without-precise-captures-we-are-powerless.rs:19:20
   |
LL | fn simple<'a>(x: &'a i32) {
   |           -- lifetime `'a` defined here
...
LL |     let c = async move || { println!("{}", *x); };
   |         - binding `c` declared here
LL |     outlives::<'a>(c());
   |     ---------------^---
   |     |              |
   |     |              borrowed value does not live long enough
   |     argument requires that `c` is borrowed for `'a`
LL |     outlives::<'a>(call_once(c));
LL | }
   | - `c` dropped here while still borrowed
   |
note: requirement that `c` is borrowed for `'a` introduced here
  --> $DIR/without-precise-captures-we-are-powerless.rs:7:33
   |
LL | fn outlives<'a>(_: impl Sized + 'a) {}
   |                                 ^^
```

When encountering a `ConstraintCategory::Predicate` in a funtion call, point at the `Span` for that `Predicate` to explain where the lifetime obligation originates from.
---
 .../rustc_borrowck/src/borrowck_errors.rs     |  2 +-
 .../src/diagnostics/conflict_errors.rs        |  9 +++
 ...thout-precise-captures-we-are-powerless.rs | 14 +++++
 ...t-precise-captures-we-are-powerless.stderr | 57 ++++++++++++++++++-
 ...ation-not-general-enough-ice-133252.stderr |  6 ++
 .../precise-capturing/migration-note.rs       |  2 +
 .../precise-capturing/migration-note.stderr   | 54 +++++++++++-------
 ...er-to-static-comparing-against-free.stderr |  6 ++
 .../propagate-multiple-requirements.stderr    |  6 ++
 .../nll/local-outlives-static-via-hrtb.stderr | 10 ++++
 ...insensitive-scopes-issue-117146.nll.stderr |  5 ++
 ...sitive-scopes-issue-117146.polonius.stderr |  5 ++
 .../regions-infer-proc-static-upvar.stderr    |  6 ++
 .../regions-pattern-typing-issue-19552.stderr |  6 ++
 tests/ui/static/static-lifetime-bound.stderr  |  6 ++
 15 files changed, 170 insertions(+), 24 deletions(-)

diff --git a/compiler/rustc_borrowck/src/borrowck_errors.rs b/compiler/rustc_borrowck/src/borrowck_errors.rs
index c9be5575da5ce..bc985cbe13353 100644
--- a/compiler/rustc_borrowck/src/borrowck_errors.rs
+++ b/compiler/rustc_borrowck/src/borrowck_errors.rs
@@ -426,7 +426,7 @@ impl<'infcx, 'tcx> crate::MirBorrowckCtxt<'_, 'infcx, 'tcx> {
     }
 
     pub(crate) fn path_does_not_live_long_enough(&self, span: Span, path: &str) -> Diag<'infcx> {
-        struct_span_code_err!(self.dcx(), span, E0597, "{} does not live long enough", path,)
+        struct_span_code_err!(self.dcx(), span, E0597, "{} does not live long enough", path)
     }
 
     pub(crate) fn cannot_return_reference_to_local(
diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
index 7e20a5133e07f..3b268f538cf2d 100644
--- a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
@@ -3031,6 +3031,15 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
 
         let mut err = self.path_does_not_live_long_enough(borrow_span, &name);
 
+        if let BorrowExplanation::MustBeValidFor { ref path, region_name, .. } = explanation {
+            for constraint in path {
+                if let ConstraintCategory::Predicate(pred) = constraint.category
+                    && !pred.is_dummy()
+                {
+                    err.span_note(pred, format!("requirement that {name} is borrowed for `{region_name}` introduced here"));
+                }
+            }
+        }
         if let Some(annotation) = self.annotate_argument_and_return_for_borrow(borrow) {
             let region_name = annotation.emit(self, &mut err);
 
diff --git a/tests/ui/async-await/async-closures/without-precise-captures-we-are-powerless.rs b/tests/ui/async-await/async-closures/without-precise-captures-we-are-powerless.rs
index 19a31d1889b84..f97ec779b32cf 100644
--- a/tests/ui/async-await/async-closures/without-precise-captures-we-are-powerless.rs
+++ b/tests/ui/async-await/async-closures/without-precise-captures-we-are-powerless.rs
@@ -44,4 +44,18 @@ fn through_field_and_ref_move<'a>(x: &S<'a>) {
     outlives::<'a>(call_once(c)); //~ ERROR explicit lifetime required in the type of `x`
 }
 
+struct T;
+impl T {
+    fn outlives<'a>(&'a self, _: impl Sized + 'a) {}
+}
+fn through_method<'a>(x: &'a i32) {
+    let c = async || { println!("{}", *x); }; //~ ERROR `x` does not live long enough
+    T.outlives::<'a>(c());
+    T.outlives::<'a>(call_once(c));
+
+    let c = async move || { println!("{}", *x); };
+    T.outlives::<'a>(c()); //~ ERROR `c` does not live long enough
+    T.outlives::<'a>(call_once(c));
+}
+
 fn main() {}
diff --git a/tests/ui/async-await/async-closures/without-precise-captures-we-are-powerless.stderr b/tests/ui/async-await/async-closures/without-precise-captures-we-are-powerless.stderr
index b7259074bf64b..e99ff763b9a2d 100644
--- a/tests/ui/async-await/async-closures/without-precise-captures-we-are-powerless.stderr
+++ b/tests/ui/async-await/async-closures/without-precise-captures-we-are-powerless.stderr
@@ -28,6 +28,12 @@ LL |     outlives::<'a>(c());
 LL |     outlives::<'a>(call_once(c));
 LL | }
    | - `c` dropped here while still borrowed
+   |
+note: requirement that `c` is borrowed for `'a` introduced here
+  --> $DIR/without-precise-captures-we-are-powerless.rs:7:33
+   |
+LL | fn outlives<'a>(_: impl Sized + 'a) {}
+   |                                 ^^
 
 error[E0597]: `x` does not live long enough
   --> $DIR/without-precise-captures-we-are-powerless.rs:26:13
@@ -73,6 +79,12 @@ LL |     outlives::<'a>(c());
 LL |     outlives::<'a>(call_once(c));
 LL | }
    | - `c` dropped here while still borrowed
+   |
+note: requirement that `c` is borrowed for `'a` introduced here
+  --> $DIR/without-precise-captures-we-are-powerless.rs:7:33
+   |
+LL | fn outlives<'a>(_: impl Sized + 'a) {}
+   |                                 ^^
 
 error[E0505]: cannot move out of `c` because it is borrowed
   --> $DIR/without-precise-captures-we-are-powerless.rs:32:30
@@ -129,6 +141,12 @@ LL |     outlives::<'a>(c());
 LL |     outlives::<'a>(call_once(c));
 LL | }
    | - `c` dropped here while still borrowed
+   |
+note: requirement that `c` is borrowed for `'a` introduced here
+  --> $DIR/without-precise-captures-we-are-powerless.rs:7:33
+   |
+LL | fn outlives<'a>(_: impl Sized + 'a) {}
+   |                                 ^^
 
 error[E0621]: explicit lifetime required in the type of `x`
   --> $DIR/without-precise-captures-we-are-powerless.rs:44:5
@@ -141,7 +159,44 @@ help: add explicit lifetime `'a` to the type of `x`
 LL | fn through_field_and_ref_move<'a>(x: &'a S<'a>) {
    |                                       ++
 
-error: aborting due to 10 previous errors
+error[E0597]: `x` does not live long enough
+  --> $DIR/without-precise-captures-we-are-powerless.rs:52:13
+   |
+LL | fn through_method<'a>(x: &'a i32) {
+   |                   -- lifetime `'a` defined here
+LL |     let c = async || { println!("{}", *x); };
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ borrowed value does not live long enough
+LL |     T.outlives::<'a>(c());
+LL |     T.outlives::<'a>(call_once(c));
+   |     ------------------------------ argument requires that `x` is borrowed for `'a`
+...
+LL | }
+   |  - `x` dropped here while still borrowed
+
+error[E0597]: `c` does not live long enough
+  --> $DIR/without-precise-captures-we-are-powerless.rs:57:22
+   |
+LL | fn through_method<'a>(x: &'a i32) {
+   |                   -- lifetime `'a` defined here
+...
+LL |     let c = async move || { println!("{}", *x); };
+   |         - binding `c` declared here
+LL |     T.outlives::<'a>(c());
+   |     -----------------^---
+   |     |                |
+   |     |                borrowed value does not live long enough
+   |     argument requires that `c` is borrowed for `'a`
+LL |     T.outlives::<'a>(call_once(c));
+LL | }
+   | - `c` dropped here while still borrowed
+   |
+note: requirement that `c` is borrowed for `'a` introduced here
+  --> $DIR/without-precise-captures-we-are-powerless.rs:49:47
+   |
+LL |     fn outlives<'a>(&'a self, _: impl Sized + 'a) {}
+   |                                               ^^
+
+error: aborting due to 12 previous errors
 
 Some errors have detailed explanations: E0505, E0597, E0621.
 For more information about an error, try `rustc --explain E0505`.
diff --git a/tests/ui/borrowck/implementation-not-general-enough-ice-133252.stderr b/tests/ui/borrowck/implementation-not-general-enough-ice-133252.stderr
index 5389226f7a7a4..393f7b1a61dfa 100644
--- a/tests/ui/borrowck/implementation-not-general-enough-ice-133252.stderr
+++ b/tests/ui/borrowck/implementation-not-general-enough-ice-133252.stderr
@@ -22,6 +22,12 @@ LL |         force_send(async_load(&not_static));
 ...
 LL |     }
    |     - `not_static` dropped here while still borrowed
+   |
+note: requirement that `not_static` is borrowed for `'1` introduced here
+  --> $DIR/implementation-not-general-enough-ice-133252.rs:16:18
+   |
+LL | fn force_send<T: Send>(_: T) {}
+   |                  ^^^^
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/impl-trait/precise-capturing/migration-note.rs b/tests/ui/impl-trait/precise-capturing/migration-note.rs
index 7587e89409aaa..25b594e9b1ec7 100644
--- a/tests/ui/impl-trait/precise-capturing/migration-note.rs
+++ b/tests/ui/impl-trait/precise-capturing/migration-note.rs
@@ -32,6 +32,7 @@ fn needs_static() {
     //~| NOTE borrowed value does not live long enoug
 
     fn needs_static(_: impl Sized + 'static) {}
+    //~^ NOTE requirement that `x` is borrowed for `'static` introduced here
     needs_static(a);
     //~^ NOTE argument requires that `x` is borrowed for `'static`
 }
@@ -79,6 +80,7 @@ fn needs_static_mut() {
     //~| NOTE borrowed value does not live long enough
 
     fn needs_static(_: impl Sized + 'static) {}
+    //~^ NOTE requirement that `x` is borrowed for `'static` introduced here
     needs_static(a);
     //~^ NOTE argument requires that `x` is borrowed for `'static`
 }
diff --git a/tests/ui/impl-trait/precise-capturing/migration-note.stderr b/tests/ui/impl-trait/precise-capturing/migration-note.stderr
index aa0f640009158..e42a6f15c7e58 100644
--- a/tests/ui/impl-trait/precise-capturing/migration-note.stderr
+++ b/tests/ui/impl-trait/precise-capturing/migration-note.stderr
@@ -1,5 +1,5 @@
 error[E0597]: `x` does not live long enough
-  --> $DIR/migration-note.rs:182:17
+  --> $DIR/migration-note.rs:184:17
    |
 LL |     let x = vec![0];
    |         - binding `x` declared here
@@ -50,6 +50,11 @@ LL |
 LL | }
    | - `x` dropped here while still borrowed
    |
+note: requirement that `x` is borrowed for `'static` introduced here
+  --> $DIR/migration-note.rs:34:37
+   |
+LL |     fn needs_static(_: impl Sized + 'static) {}
+   |                                     ^^^^^^^
 note: this call may capture more lifetimes than intended, because Rust 2024 has adjusted the `impl Trait` lifetime capture rules
   --> $DIR/migration-note.rs:29:13
    |
@@ -61,7 +66,7 @@ LL | fn display_len<T>(x: &Vec<T>) -> impl Display + use<T> {
    |                                               ++++++++
 
 error[E0505]: cannot move out of `x` because it is borrowed
-  --> $DIR/migration-note.rs:48:8
+  --> $DIR/migration-note.rs:49:8
    |
 LL |     let x = vec![1];
    |         - binding `x` declared here
@@ -76,7 +81,7 @@ LL | }
    | - borrow might be used here, when `a` is dropped and runs the destructor for type `impl std::fmt::Display`
    |
 note: this call may capture more lifetimes than intended, because Rust 2024 has adjusted the `impl Trait` lifetime capture rules
-  --> $DIR/migration-note.rs:43:13
+  --> $DIR/migration-note.rs:44:13
    |
 LL |     let a = display_len(&x);
    |             ^^^^^^^^^^^^^^^
@@ -90,7 +95,7 @@ LL |     let a = display_len(&x.clone());
    |                           ++++++++
 
 error[E0499]: cannot borrow `x` as mutable more than once at a time
-  --> $DIR/migration-note.rs:66:5
+  --> $DIR/migration-note.rs:67:5
    |
 LL |     let a = display_len_mut(&mut x);
    |                             ------ first mutable borrow occurs here
@@ -102,7 +107,7 @@ LL |     println!("{a}");
    |                - first borrow later used here
    |
 note: this call may capture more lifetimes than intended, because Rust 2024 has adjusted the `impl Trait` lifetime capture rules
-  --> $DIR/migration-note.rs:63:13
+  --> $DIR/migration-note.rs:64:13
    |
 LL |     let a = display_len_mut(&mut x);
    |             ^^^^^^^^^^^^^^^^^^^^^^^
@@ -112,7 +117,7 @@ LL | fn display_len_mut<T>(x: &mut Vec<T>) -> impl Display + use<T> {
    |                                                       ++++++++
 
 error[E0597]: `x` does not live long enough
-  --> $DIR/migration-note.rs:76:29
+  --> $DIR/migration-note.rs:77:29
    |
 LL |     let mut x = vec![1];
    |         ----- binding `x` declared here
@@ -126,8 +131,13 @@ LL |
 LL | }
    | - `x` dropped here while still borrowed
    |
+note: requirement that `x` is borrowed for `'static` introduced here
+  --> $DIR/migration-note.rs:82:37
+   |
+LL |     fn needs_static(_: impl Sized + 'static) {}
+   |                                     ^^^^^^^
 note: this call may capture more lifetimes than intended, because Rust 2024 has adjusted the `impl Trait` lifetime capture rules
-  --> $DIR/migration-note.rs:76:13
+  --> $DIR/migration-note.rs:77:13
    |
 LL |     let a = display_len_mut(&mut x);
    |             ^^^^^^^^^^^^^^^^^^^^^^^
@@ -137,7 +147,7 @@ LL | fn display_len_mut<T>(x: &mut Vec<T>) -> impl Display + use<T> {
    |                                                       ++++++++
 
 error[E0505]: cannot move out of `x` because it is borrowed
-  --> $DIR/migration-note.rs:95:8
+  --> $DIR/migration-note.rs:97:8
    |
 LL |     let mut x = vec![1];
    |         ----- binding `x` declared here
@@ -152,7 +162,7 @@ LL | }
    | - borrow might be used here, when `a` is dropped and runs the destructor for type `impl std::fmt::Display`
    |
 note: this call may capture more lifetimes than intended, because Rust 2024 has adjusted the `impl Trait` lifetime capture rules
-  --> $DIR/migration-note.rs:90:13
+  --> $DIR/migration-note.rs:92:13
    |
 LL |     let a = display_len_mut(&mut x);
    |             ^^^^^^^^^^^^^^^^^^^^^^^
@@ -166,7 +176,7 @@ LL |     let a = display_len_mut(&mut x.clone());
    |                                   ++++++++
 
 error[E0506]: cannot assign to `s.f` because it is borrowed
-  --> $DIR/migration-note.rs:115:5
+  --> $DIR/migration-note.rs:117:5
    |
 LL |     let a = display_field(&s.f);
    |                           ---- `s.f` is borrowed here
@@ -178,7 +188,7 @@ LL |     println!("{a}");
    |                - borrow later used here
    |
 note: this call may capture more lifetimes than intended, because Rust 2024 has adjusted the `impl Trait` lifetime capture rules
-  --> $DIR/migration-note.rs:112:13
+  --> $DIR/migration-note.rs:114:13
    |
 LL |     let a = display_field(&s.f);
    |             ^^^^^^^^^^^^^^^^^^^
@@ -188,7 +198,7 @@ LL | fn display_field<T: Copy + Display>(t: &T) -> impl Display + use<T> {
    |                                                            ++++++++
 
 error[E0506]: cannot assign to `s.f` because it is borrowed
-  --> $DIR/migration-note.rs:131:5
+  --> $DIR/migration-note.rs:133:5
    |
 LL |     let a = display_field(&mut s.f);
    |                           -------- `s.f` is borrowed here
@@ -200,7 +210,7 @@ LL |     println!("{a}");
    |                - borrow later used here
    |
 note: this call may capture more lifetimes than intended, because Rust 2024 has adjusted the `impl Trait` lifetime capture rules
-  --> $DIR/migration-note.rs:128:13
+  --> $DIR/migration-note.rs:130:13
    |
 LL |     let a = display_field(&mut s.f);
    |             ^^^^^^^^^^^^^^^^^^^^^^^
@@ -210,7 +220,7 @@ LL | fn display_field<T: Copy + Display>(t: &T) -> impl Display + use<T> {
    |                                                            ++++++++
 
 error[E0503]: cannot use `s.f` because it was mutably borrowed
-  --> $DIR/migration-note.rs:143:5
+  --> $DIR/migration-note.rs:145:5
    |
 LL |     let a = display_field(&mut s.f);
    |                           -------- `s.f` is borrowed here
@@ -222,7 +232,7 @@ LL |     println!("{a}");
    |                - borrow later used here
    |
 note: this call may capture more lifetimes than intended, because Rust 2024 has adjusted the `impl Trait` lifetime capture rules
-  --> $DIR/migration-note.rs:140:13
+  --> $DIR/migration-note.rs:142:13
    |
 LL |     let a = display_field(&mut s.f);
    |             ^^^^^^^^^^^^^^^^^^^^^^^
@@ -232,7 +242,7 @@ LL | fn display_field<T: Copy + Display>(t: &T) -> impl Display + use<T> {
    |                                                            ++++++++
 
 error[E0597]: `z.f` does not live long enough
-  --> $DIR/migration-note.rs:159:25
+  --> $DIR/migration-note.rs:161:25
    |
 LL |         let z = Z { f: vec![1] };
    |             - binding `z` declared here
@@ -248,7 +258,7 @@ LL | }
    |
    = note: values in a scope are dropped in the opposite order they are defined
 note: this call may capture more lifetimes than intended, because Rust 2024 has adjusted the `impl Trait` lifetime capture rules
-  --> $DIR/migration-note.rs:159:13
+  --> $DIR/migration-note.rs:161:13
    |
 LL |         x = display_len(&z.f);
    |             ^^^^^^^^^^^^^^^^^
@@ -258,7 +268,7 @@ LL | fn display_len<T>(x: &Vec<T>) -> impl Display + use<T> {
    |                                               ++++++++
 
 error[E0716]: temporary value dropped while borrowed
-  --> $DIR/migration-note.rs:170:40
+  --> $DIR/migration-note.rs:172:40
    |
 LL |     let x = { let x = display_len(&mut vec![0]); x };
    |                                        ^^^^^^^ - - borrow later used here
@@ -268,7 +278,7 @@ LL |     let x = { let x = display_len(&mut vec![0]); x };
    |
    = note: consider using a `let` binding to create a longer lived value
 note: this call may capture more lifetimes than intended, because Rust 2024 has adjusted the `impl Trait` lifetime capture rules
-  --> $DIR/migration-note.rs:170:23
+  --> $DIR/migration-note.rs:172:23
    |
 LL |     let x = { let x = display_len(&mut vec![0]); x };
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -279,7 +289,7 @@ LL | fn display_len<T>(x: &Vec<T>) -> impl Display + use<T> {
    |                                               ++++++++
 
 error[E0505]: cannot move out of `x` because it is borrowed
-  --> $DIR/migration-note.rs:198:10
+  --> $DIR/migration-note.rs:200:10
    |
 LL |     let x = String::new();
    |         - binding `x` declared here
@@ -294,12 +304,12 @@ LL | }
    | - borrow might be used here, when `y` is dropped and runs the destructor for type `impl Sized`
    |
 note: this call may capture more lifetimes than intended, because Rust 2024 has adjusted the `impl Trait` lifetime capture rules
-  --> $DIR/migration-note.rs:195:13
+  --> $DIR/migration-note.rs:197:13
    |
 LL |     let y = capture_apit(&x);
    |             ^^^^^^^^^^^^^^^^
 note: you could use a `use<...>` bound to explicitly specify captures, but argument-position `impl Trait`s are not nameable
-  --> $DIR/migration-note.rs:189:21
+  --> $DIR/migration-note.rs:191:21
    |
 LL | fn capture_apit(x: &impl Sized) -> impl Sized {}
    |                     ^^^^^^^^^^
diff --git a/tests/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-comparing-against-free.stderr b/tests/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-comparing-against-free.stderr
index e13653f342342..136da57daec1b 100644
--- a/tests/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-comparing-against-free.stderr
+++ b/tests/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-comparing-against-free.stderr
@@ -69,6 +69,12 @@ LL |         cell_x.set(cell_a.get()); // forces 'a: 'x, implies 'a = 'static ->
 LL |     })
 LL | }
    | - `a` dropped here while still borrowed
+   |
+note: requirement that `a` is borrowed for `'static` introduced here
+  --> $DIR/propagate-approximated-shorter-to-static-comparing-against-free.rs:13:8
+   |
+LL |     F: for<'x> FnOnce(Cell<&'a u32>, Cell<&'x u32>),
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/nll/closure-requirements/propagate-multiple-requirements.stderr b/tests/ui/nll/closure-requirements/propagate-multiple-requirements.stderr
index 15f48d88c379b..8e18f546ebd4d 100644
--- a/tests/ui/nll/closure-requirements/propagate-multiple-requirements.stderr
+++ b/tests/ui/nll/closure-requirements/propagate-multiple-requirements.stderr
@@ -13,6 +13,12 @@ LL |         z = &local_arr;
 ...
 LL | }
    | - `local_arr` dropped here while still borrowed
+   |
+note: requirement that `local_arr` is borrowed for `'static` introduced here
+  --> $DIR/propagate-multiple-requirements.rs:4:21
+   |
+LL | fn once<S, T, U, F: FnOnce(S, T) -> U>(f: F, s: S, t: T) -> U {
+   |                     ^^^^^^^^^^^^^^^^^
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/local-outlives-static-via-hrtb.stderr b/tests/ui/nll/local-outlives-static-via-hrtb.stderr
index a98f11ce51363..cc01a3cfc0b90 100644
--- a/tests/ui/nll/local-outlives-static-via-hrtb.stderr
+++ b/tests/ui/nll/local-outlives-static-via-hrtb.stderr
@@ -12,6 +12,11 @@ LL |     assert_static_via_hrtb_with_assoc_type(&&local);
 LL | }
    | - `local` dropped here while still borrowed
    |
+note: requirement that `local` is borrowed for `'static` introduced here
+  --> $DIR/local-outlives-static-via-hrtb.rs:15:53
+   |
+LL | fn assert_static_via_hrtb<G>(_: G) where for<'a> G: Outlives<'a> {}
+   |                                                     ^^^^^^^^^^^^
 note: due to a current limitation of the type system, this implies a `'static` lifetime
   --> $DIR/local-outlives-static-via-hrtb.rs:15:42
    |
@@ -32,6 +37,11 @@ LL |     assert_static_via_hrtb_with_assoc_type(&&local);
 LL | }
    | - `local` dropped here while still borrowed
    |
+note: requirement that `local` is borrowed for `'static` introduced here
+  --> $DIR/local-outlives-static-via-hrtb.rs:19:30
+   |
+LL |     for<'a> &'a T: Reference<AssociatedType = &'a ()>,
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^
 note: due to a current limitation of the type system, this implies a `'static` lifetime
   --> $DIR/local-outlives-static-via-hrtb.rs:19:5
    |
diff --git a/tests/ui/nll/polonius/location-insensitive-scopes-issue-117146.nll.stderr b/tests/ui/nll/polonius/location-insensitive-scopes-issue-117146.nll.stderr
index 6e47b8e59f5c6..56ad78ba4b424 100644
--- a/tests/ui/nll/polonius/location-insensitive-scopes-issue-117146.nll.stderr
+++ b/tests/ui/nll/polonius/location-insensitive-scopes-issue-117146.nll.stderr
@@ -13,6 +13,11 @@ LL |     let b = |_| &a;
 LL | }
    | - `a` dropped here while still borrowed
    |
+note: requirement that `a` is borrowed for `'static` introduced here
+  --> $DIR/location-insensitive-scopes-issue-117146.rs:20:22
+   |
+LL | fn bad<F: Fn(&()) -> &()>(_: F) {}
+   |                      ^^^
 note: due to a current limitation of the type system, this implies a `'static` lifetime
   --> $DIR/location-insensitive-scopes-issue-117146.rs:20:11
    |
diff --git a/tests/ui/nll/polonius/location-insensitive-scopes-issue-117146.polonius.stderr b/tests/ui/nll/polonius/location-insensitive-scopes-issue-117146.polonius.stderr
index 6e47b8e59f5c6..56ad78ba4b424 100644
--- a/tests/ui/nll/polonius/location-insensitive-scopes-issue-117146.polonius.stderr
+++ b/tests/ui/nll/polonius/location-insensitive-scopes-issue-117146.polonius.stderr
@@ -13,6 +13,11 @@ LL |     let b = |_| &a;
 LL | }
    | - `a` dropped here while still borrowed
    |
+note: requirement that `a` is borrowed for `'static` introduced here
+  --> $DIR/location-insensitive-scopes-issue-117146.rs:20:22
+   |
+LL | fn bad<F: Fn(&()) -> &()>(_: F) {}
+   |                      ^^^
 note: due to a current limitation of the type system, this implies a `'static` lifetime
   --> $DIR/location-insensitive-scopes-issue-117146.rs:20:11
    |
diff --git a/tests/ui/regions/regions-infer-proc-static-upvar.stderr b/tests/ui/regions/regions-infer-proc-static-upvar.stderr
index 919fcffdc531e..1a76b5f00f943 100644
--- a/tests/ui/regions/regions-infer-proc-static-upvar.stderr
+++ b/tests/ui/regions/regions-infer-proc-static-upvar.stderr
@@ -11,6 +11,12 @@ LL | |     });
    | |______- argument requires that `x` is borrowed for `'static`
 LL |   }
    |   - `x` dropped here while still borrowed
+   |
+note: requirement that `x` is borrowed for `'static` introduced here
+  --> $DIR/regions-infer-proc-static-upvar.rs:4:19
+   |
+LL | fn foo<F:FnOnce()+'static>(_p: F) { }
+   |                   ^^^^^^^
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/regions/regions-pattern-typing-issue-19552.stderr b/tests/ui/regions/regions-pattern-typing-issue-19552.stderr
index 1d3d5e831c39c..2c8ce20f09e46 100644
--- a/tests/ui/regions/regions-pattern-typing-issue-19552.stderr
+++ b/tests/ui/regions/regions-pattern-typing-issue-19552.stderr
@@ -10,6 +10,12 @@ LL |         [ word ] => { assert_static(word); }
 LL |     }
 LL | }
    | - `line` dropped here while still borrowed
+   |
+note: requirement that `line` is borrowed for `'static` introduced here
+  --> $DIR/regions-pattern-typing-issue-19552.rs:1:21
+   |
+LL | fn assert_static<T: 'static>(_t: T) {}
+   |                     ^^^^^^^
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/static/static-lifetime-bound.stderr b/tests/ui/static/static-lifetime-bound.stderr
index 8b0d3a0bf4cf4..e530e4669d7f6 100644
--- a/tests/ui/static/static-lifetime-bound.stderr
+++ b/tests/ui/static/static-lifetime-bound.stderr
@@ -10,6 +10,12 @@ LL |     f(&x);
    |     argument requires that `x` is borrowed for `'static`
 LL | }
    | - `x` dropped here while still borrowed
+   |
+note: requirement that `x` is borrowed for `'static` introduced here
+  --> $DIR/static-lifetime-bound.rs:1:10
+   |
+LL | fn f<'a: 'static>(_: &'a i32) {}
+   |          ^^^^^^^
 
 error: aborting due to 1 previous error
 

From 7a0319f01d08e541c8e16febaa68c5fa8b66b586 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Fri, 29 Aug 2025 20:14:01 +0000
Subject: [PATCH 1531/1889] Point at lifetime requirement origin in more cases

---
 .../rustc_borrowck/src/borrowck_errors.rs     |  2 +-
 .../src/diagnostics/conflict_errors.rs        | 17 +---------------
 .../src/diagnostics/explain_borrow.rs         | 13 ++++++++++++
 ...t-precise-captures-we-are-powerless.stderr | 14 +++++++++----
 .../borrowck/fn-item-check-type-params.stderr | 12 +++++++++++
 ...ation-not-general-enough-ice-133252.stderr |  2 +-
 tests/ui/borrowck/issue-17545.stderr          |  3 +++
 .../bugs/hrtb-implied-1.stderr                |  5 +++++
 .../precise-capturing/migration-note.rs       |  4 ++--
 .../precise-capturing/migration-note.stderr   |  4 ++--
 ...er-to-static-comparing-against-free.stderr |  2 +-
 .../propagate-multiple-requirements.stderr    |  2 +-
 .../nll/local-outlives-static-via-hrtb.stderr | 20 +++++++++----------
 ...insensitive-scopes-issue-117146.nll.stderr | 10 +++++-----
 ...sitive-scopes-issue-117146.polonius.stderr | 10 +++++-----
 .../regions-infer-proc-static-upvar.stderr    |  2 +-
 .../regions-pattern-typing-issue-19552.stderr |  2 +-
 tests/ui/static/static-lifetime-bound.stderr  |  2 +-
 tests/ui/static/static-region-bound.stderr    |  6 ++++++
 .../wf-in-where-clause-static.current.stderr  |  6 ++++++
 .../wf/wf-in-where-clause-static.next.stderr  |  6 ++++++
 21 files changed, 93 insertions(+), 51 deletions(-)

diff --git a/compiler/rustc_borrowck/src/borrowck_errors.rs b/compiler/rustc_borrowck/src/borrowck_errors.rs
index bc985cbe13353..7c9011505d64c 100644
--- a/compiler/rustc_borrowck/src/borrowck_errors.rs
+++ b/compiler/rustc_borrowck/src/borrowck_errors.rs
@@ -480,7 +480,7 @@ impl<'infcx, 'tcx> crate::MirBorrowckCtxt<'_, 'infcx, 'tcx> {
     }
 
     pub(crate) fn temporary_value_borrowed_for_too_long(&self, span: Span) -> Diag<'infcx> {
-        struct_span_code_err!(self.dcx(), span, E0716, "temporary value dropped while borrowed",)
+        struct_span_code_err!(self.dcx(), span, E0716, "temporary value dropped while borrowed")
     }
 }
 
diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
index 3b268f538cf2d..efb622e2155ca 100644
--- a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
@@ -2992,6 +2992,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
         self.buffer_error(err);
     }
 
+    #[tracing::instrument(level = "debug", skip(self, explanation))]
     fn report_local_value_does_not_live_long_enough(
         &self,
         location: Location,
@@ -3001,13 +3002,6 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
         borrow_spans: UseSpans<'tcx>,
         explanation: BorrowExplanation<'tcx>,
     ) -> Diag<'infcx> {
-        debug!(
-            "report_local_value_does_not_live_long_enough(\
-             {:?}, {:?}, {:?}, {:?}, {:?}\
-             )",
-            location, name, borrow, drop_span, borrow_spans
-        );
-
         let borrow_span = borrow_spans.var_or_use_path_span();
         if let BorrowExplanation::MustBeValidFor {
             category,
@@ -3031,15 +3025,6 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
 
         let mut err = self.path_does_not_live_long_enough(borrow_span, &name);
 
-        if let BorrowExplanation::MustBeValidFor { ref path, region_name, .. } = explanation {
-            for constraint in path {
-                if let ConstraintCategory::Predicate(pred) = constraint.category
-                    && !pred.is_dummy()
-                {
-                    err.span_note(pred, format!("requirement that {name} is borrowed for `{region_name}` introduced here"));
-                }
-            }
-        }
         if let Some(annotation) = self.annotate_argument_and_return_for_borrow(borrow) {
             let region_name = annotation.emit(self, &mut err);
 
diff --git a/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs b/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs
index 7ca07bb9b4348..a0ea8b0855699 100644
--- a/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs
@@ -416,6 +416,19 @@ impl<'tcx> BorrowExplanation<'tcx> {
                 {
                     self.add_object_lifetime_default_note(tcx, err, unsize_ty);
                 }
+
+                for constraint in path {
+                    if let ConstraintCategory::Predicate(pred) = constraint.category
+                        && !pred.is_dummy()
+                    {
+                        err.span_note(
+                            pred,
+                            format!("requirement for `{region_name}` introduced here"),
+                        );
+                        break;
+                    }
+                }
+
                 self.add_lifetime_bound_suggestion_to_diagnostic(err, &category, span, region_name);
             }
             _ => {}
diff --git a/tests/ui/async-await/async-closures/without-precise-captures-we-are-powerless.stderr b/tests/ui/async-await/async-closures/without-precise-captures-we-are-powerless.stderr
index e99ff763b9a2d..e0776c81dff3d 100644
--- a/tests/ui/async-await/async-closures/without-precise-captures-we-are-powerless.stderr
+++ b/tests/ui/async-await/async-closures/without-precise-captures-we-are-powerless.stderr
@@ -29,7 +29,7 @@ LL |     outlives::<'a>(call_once(c));
 LL | }
    | - `c` dropped here while still borrowed
    |
-note: requirement that `c` is borrowed for `'a` introduced here
+note: requirement for `'a` introduced here
   --> $DIR/without-precise-captures-we-are-powerless.rs:7:33
    |
 LL | fn outlives<'a>(_: impl Sized + 'a) {}
@@ -80,7 +80,7 @@ LL |     outlives::<'a>(call_once(c));
 LL | }
    | - `c` dropped here while still borrowed
    |
-note: requirement that `c` is borrowed for `'a` introduced here
+note: requirement for `'a` introduced here
   --> $DIR/without-precise-captures-we-are-powerless.rs:7:33
    |
 LL | fn outlives<'a>(_: impl Sized + 'a) {}
@@ -101,6 +101,12 @@ LL |     outlives::<'a>(c());
    |     argument requires that `c` is borrowed for `'a`
 LL |     outlives::<'a>(call_once(c));
    |                              ^ move out of `c` occurs here
+   |
+note: requirement for `'a` introduced here
+  --> $DIR/without-precise-captures-we-are-powerless.rs:7:33
+   |
+LL | fn outlives<'a>(_: impl Sized + 'a) {}
+   |                                 ^^
 
 error[E0597]: `x` does not live long enough
   --> $DIR/without-precise-captures-we-are-powerless.rs:36:13
@@ -142,7 +148,7 @@ LL |     outlives::<'a>(call_once(c));
 LL | }
    | - `c` dropped here while still borrowed
    |
-note: requirement that `c` is borrowed for `'a` introduced here
+note: requirement for `'a` introduced here
   --> $DIR/without-precise-captures-we-are-powerless.rs:7:33
    |
 LL | fn outlives<'a>(_: impl Sized + 'a) {}
@@ -190,7 +196,7 @@ LL |     T.outlives::<'a>(call_once(c));
 LL | }
    | - `c` dropped here while still borrowed
    |
-note: requirement that `c` is borrowed for `'a` introduced here
+note: requirement for `'a` introduced here
   --> $DIR/without-precise-captures-we-are-powerless.rs:49:47
    |
 LL |     fn outlives<'a>(&'a self, _: impl Sized + 'a) {}
diff --git a/tests/ui/borrowck/fn-item-check-type-params.stderr b/tests/ui/borrowck/fn-item-check-type-params.stderr
index aafb7e66ef55f..8da0201134b03 100644
--- a/tests/ui/borrowck/fn-item-check-type-params.stderr
+++ b/tests/ui/borrowck/fn-item-check-type-params.stderr
@@ -27,6 +27,12 @@ LL |     want(&String::new(), extend_lt);
    |     |     |
    |     |     creates a temporary value which is freed while still in use
    |     argument requires that borrow lasts for `'static`
+   |
+note: requirement for `'static` introduced here
+  --> $DIR/fn-item-check-type-params.rs:47:33
+   |
+LL |     fn want<I, O>(_: I, _: impl Fn(I) -> O) {}
+   |                                 ^^^^^^^^^^
 
 error[E0716]: temporary value dropped while borrowed
   --> $DIR/fn-item-check-type-params.rs:54:26
@@ -36,6 +42,12 @@ LL |     let val = extend_lt(&String::from("blah blah blah"));
    |               |          |
    |               |          creates a temporary value which is freed while still in use
    |               argument requires that borrow lasts for `'static`
+   |
+note: requirement for `'static` introduced here
+  --> $DIR/fn-item-check-type-params.rs:22:21
+   |
+LL |     (T, Option<U>): Displayable,
+   |                     ^^^^^^^^^^^
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/borrowck/implementation-not-general-enough-ice-133252.stderr b/tests/ui/borrowck/implementation-not-general-enough-ice-133252.stderr
index 393f7b1a61dfa..dab969586efd8 100644
--- a/tests/ui/borrowck/implementation-not-general-enough-ice-133252.stderr
+++ b/tests/ui/borrowck/implementation-not-general-enough-ice-133252.stderr
@@ -23,7 +23,7 @@ LL |         force_send(async_load(&not_static));
 LL |     }
    |     - `not_static` dropped here while still borrowed
    |
-note: requirement that `not_static` is borrowed for `'1` introduced here
+note: requirement for `'1` introduced here
   --> $DIR/implementation-not-general-enough-ice-133252.rs:16:18
    |
 LL | fn force_send<T: Send>(_: T) {}
diff --git a/tests/ui/borrowck/issue-17545.stderr b/tests/ui/borrowck/issue-17545.stderr
index 45e977e39477e..dc0a84b0ab42a 100644
--- a/tests/ui/borrowck/issue-17545.stderr
+++ b/tests/ui/borrowck/issue-17545.stderr
@@ -10,6 +10,9 @@ LL | |     ));
    | |      -- temporary value is freed at the end of this statement
    | |______|
    |        argument requires that borrow lasts for `'a`
+   |
+note: requirement for `'a` introduced here
+  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/generic-associated-types/bugs/hrtb-implied-1.stderr b/tests/ui/generic-associated-types/bugs/hrtb-implied-1.stderr
index 8bb72833e301c..72f9a477dafcc 100644
--- a/tests/ui/generic-associated-types/bugs/hrtb-implied-1.stderr
+++ b/tests/ui/generic-associated-types/bugs/hrtb-implied-1.stderr
@@ -14,6 +14,11 @@ note: due to a current limitation of the type system, this implies a `'static` l
    |
 LL |     for<'a> I::Item<'a>: Debug,
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+note: requirement for `'static` introduced here
+  --> $DIR/hrtb-implied-1.rs:26:26
+   |
+LL |     for<'a> I::Item<'a>: Debug,
+   |                          ^^^^^
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/impl-trait/precise-capturing/migration-note.rs b/tests/ui/impl-trait/precise-capturing/migration-note.rs
index 25b594e9b1ec7..211def3332002 100644
--- a/tests/ui/impl-trait/precise-capturing/migration-note.rs
+++ b/tests/ui/impl-trait/precise-capturing/migration-note.rs
@@ -32,7 +32,7 @@ fn needs_static() {
     //~| NOTE borrowed value does not live long enoug
 
     fn needs_static(_: impl Sized + 'static) {}
-    //~^ NOTE requirement that `x` is borrowed for `'static` introduced here
+    //~^ NOTE requirement for `'static` introduced here
     needs_static(a);
     //~^ NOTE argument requires that `x` is borrowed for `'static`
 }
@@ -80,7 +80,7 @@ fn needs_static_mut() {
     //~| NOTE borrowed value does not live long enough
 
     fn needs_static(_: impl Sized + 'static) {}
-    //~^ NOTE requirement that `x` is borrowed for `'static` introduced here
+    //~^ NOTE requirement for `'static` introduced here
     needs_static(a);
     //~^ NOTE argument requires that `x` is borrowed for `'static`
 }
diff --git a/tests/ui/impl-trait/precise-capturing/migration-note.stderr b/tests/ui/impl-trait/precise-capturing/migration-note.stderr
index e42a6f15c7e58..c06b14a41139b 100644
--- a/tests/ui/impl-trait/precise-capturing/migration-note.stderr
+++ b/tests/ui/impl-trait/precise-capturing/migration-note.stderr
@@ -50,7 +50,7 @@ LL |
 LL | }
    | - `x` dropped here while still borrowed
    |
-note: requirement that `x` is borrowed for `'static` introduced here
+note: requirement for `'static` introduced here
   --> $DIR/migration-note.rs:34:37
    |
 LL |     fn needs_static(_: impl Sized + 'static) {}
@@ -131,7 +131,7 @@ LL |
 LL | }
    | - `x` dropped here while still borrowed
    |
-note: requirement that `x` is borrowed for `'static` introduced here
+note: requirement for `'static` introduced here
   --> $DIR/migration-note.rs:82:37
    |
 LL |     fn needs_static(_: impl Sized + 'static) {}
diff --git a/tests/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-comparing-against-free.stderr b/tests/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-comparing-against-free.stderr
index 136da57daec1b..eb110e868aa58 100644
--- a/tests/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-comparing-against-free.stderr
+++ b/tests/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-comparing-against-free.stderr
@@ -70,7 +70,7 @@ LL |     })
 LL | }
    | - `a` dropped here while still borrowed
    |
-note: requirement that `a` is borrowed for `'static` introduced here
+note: requirement for `'static` introduced here
   --> $DIR/propagate-approximated-shorter-to-static-comparing-against-free.rs:13:8
    |
 LL |     F: for<'x> FnOnce(Cell<&'a u32>, Cell<&'x u32>),
diff --git a/tests/ui/nll/closure-requirements/propagate-multiple-requirements.stderr b/tests/ui/nll/closure-requirements/propagate-multiple-requirements.stderr
index 8e18f546ebd4d..51e4d77c91a1b 100644
--- a/tests/ui/nll/closure-requirements/propagate-multiple-requirements.stderr
+++ b/tests/ui/nll/closure-requirements/propagate-multiple-requirements.stderr
@@ -14,7 +14,7 @@ LL |         z = &local_arr;
 LL | }
    | - `local_arr` dropped here while still borrowed
    |
-note: requirement that `local_arr` is borrowed for `'static` introduced here
+note: requirement for `'static` introduced here
   --> $DIR/propagate-multiple-requirements.rs:4:21
    |
 LL | fn once<S, T, U, F: FnOnce(S, T) -> U>(f: F, s: S, t: T) -> U {
diff --git a/tests/ui/nll/local-outlives-static-via-hrtb.stderr b/tests/ui/nll/local-outlives-static-via-hrtb.stderr
index cc01a3cfc0b90..ff2be3a2b28ec 100644
--- a/tests/ui/nll/local-outlives-static-via-hrtb.stderr
+++ b/tests/ui/nll/local-outlives-static-via-hrtb.stderr
@@ -12,16 +12,16 @@ LL |     assert_static_via_hrtb_with_assoc_type(&&local);
 LL | }
    | - `local` dropped here while still borrowed
    |
-note: requirement that `local` is borrowed for `'static` introduced here
-  --> $DIR/local-outlives-static-via-hrtb.rs:15:53
-   |
-LL | fn assert_static_via_hrtb<G>(_: G) where for<'a> G: Outlives<'a> {}
-   |                                                     ^^^^^^^^^^^^
 note: due to a current limitation of the type system, this implies a `'static` lifetime
   --> $DIR/local-outlives-static-via-hrtb.rs:15:42
    |
 LL | fn assert_static_via_hrtb<G>(_: G) where for<'a> G: Outlives<'a> {}
    |                                          ^^^^^^^^^^^^^^^^^^^^^^^
+note: requirement for `'static` introduced here
+  --> $DIR/local-outlives-static-via-hrtb.rs:15:53
+   |
+LL | fn assert_static_via_hrtb<G>(_: G) where for<'a> G: Outlives<'a> {}
+   |                                                     ^^^^^^^^^^^^
 
 error[E0597]: `local` does not live long enough
   --> $DIR/local-outlives-static-via-hrtb.rs:25:45
@@ -37,16 +37,16 @@ LL |     assert_static_via_hrtb_with_assoc_type(&&local);
 LL | }
    | - `local` dropped here while still borrowed
    |
-note: requirement that `local` is borrowed for `'static` introduced here
-  --> $DIR/local-outlives-static-via-hrtb.rs:19:30
-   |
-LL |     for<'a> &'a T: Reference<AssociatedType = &'a ()>,
-   |                              ^^^^^^^^^^^^^^^^^^^^^^^
 note: due to a current limitation of the type system, this implies a `'static` lifetime
   --> $DIR/local-outlives-static-via-hrtb.rs:19:5
    |
 LL |     for<'a> &'a T: Reference<AssociatedType = &'a ()>,
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+note: requirement for `'static` introduced here
+  --> $DIR/local-outlives-static-via-hrtb.rs:19:30
+   |
+LL |     for<'a> &'a T: Reference<AssociatedType = &'a ()>,
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/nll/polonius/location-insensitive-scopes-issue-117146.nll.stderr b/tests/ui/nll/polonius/location-insensitive-scopes-issue-117146.nll.stderr
index 56ad78ba4b424..fdc3fc059c534 100644
--- a/tests/ui/nll/polonius/location-insensitive-scopes-issue-117146.nll.stderr
+++ b/tests/ui/nll/polonius/location-insensitive-scopes-issue-117146.nll.stderr
@@ -13,16 +13,16 @@ LL |     let b = |_| &a;
 LL | }
    | - `a` dropped here while still borrowed
    |
-note: requirement that `a` is borrowed for `'static` introduced here
-  --> $DIR/location-insensitive-scopes-issue-117146.rs:20:22
-   |
-LL | fn bad<F: Fn(&()) -> &()>(_: F) {}
-   |                      ^^^
 note: due to a current limitation of the type system, this implies a `'static` lifetime
   --> $DIR/location-insensitive-scopes-issue-117146.rs:20:11
    |
 LL | fn bad<F: Fn(&()) -> &()>(_: F) {}
    |           ^^^^^^^^^^^^^^
+note: requirement for `'static` introduced here
+  --> $DIR/location-insensitive-scopes-issue-117146.rs:20:22
+   |
+LL | fn bad<F: Fn(&()) -> &()>(_: F) {}
+   |                      ^^^
 
 error: implementation of `Fn` is not general enough
   --> $DIR/location-insensitive-scopes-issue-117146.rs:13:5
diff --git a/tests/ui/nll/polonius/location-insensitive-scopes-issue-117146.polonius.stderr b/tests/ui/nll/polonius/location-insensitive-scopes-issue-117146.polonius.stderr
index 56ad78ba4b424..fdc3fc059c534 100644
--- a/tests/ui/nll/polonius/location-insensitive-scopes-issue-117146.polonius.stderr
+++ b/tests/ui/nll/polonius/location-insensitive-scopes-issue-117146.polonius.stderr
@@ -13,16 +13,16 @@ LL |     let b = |_| &a;
 LL | }
    | - `a` dropped here while still borrowed
    |
-note: requirement that `a` is borrowed for `'static` introduced here
-  --> $DIR/location-insensitive-scopes-issue-117146.rs:20:22
-   |
-LL | fn bad<F: Fn(&()) -> &()>(_: F) {}
-   |                      ^^^
 note: due to a current limitation of the type system, this implies a `'static` lifetime
   --> $DIR/location-insensitive-scopes-issue-117146.rs:20:11
    |
 LL | fn bad<F: Fn(&()) -> &()>(_: F) {}
    |           ^^^^^^^^^^^^^^
+note: requirement for `'static` introduced here
+  --> $DIR/location-insensitive-scopes-issue-117146.rs:20:22
+   |
+LL | fn bad<F: Fn(&()) -> &()>(_: F) {}
+   |                      ^^^
 
 error: implementation of `Fn` is not general enough
   --> $DIR/location-insensitive-scopes-issue-117146.rs:13:5
diff --git a/tests/ui/regions/regions-infer-proc-static-upvar.stderr b/tests/ui/regions/regions-infer-proc-static-upvar.stderr
index 1a76b5f00f943..ff833de0ad012 100644
--- a/tests/ui/regions/regions-infer-proc-static-upvar.stderr
+++ b/tests/ui/regions/regions-infer-proc-static-upvar.stderr
@@ -12,7 +12,7 @@ LL | |     });
 LL |   }
    |   - `x` dropped here while still borrowed
    |
-note: requirement that `x` is borrowed for `'static` introduced here
+note: requirement for `'static` introduced here
   --> $DIR/regions-infer-proc-static-upvar.rs:4:19
    |
 LL | fn foo<F:FnOnce()+'static>(_p: F) { }
diff --git a/tests/ui/regions/regions-pattern-typing-issue-19552.stderr b/tests/ui/regions/regions-pattern-typing-issue-19552.stderr
index 2c8ce20f09e46..76cd18dfa1329 100644
--- a/tests/ui/regions/regions-pattern-typing-issue-19552.stderr
+++ b/tests/ui/regions/regions-pattern-typing-issue-19552.stderr
@@ -11,7 +11,7 @@ LL |     }
 LL | }
    | - `line` dropped here while still borrowed
    |
-note: requirement that `line` is borrowed for `'static` introduced here
+note: requirement for `'static` introduced here
   --> $DIR/regions-pattern-typing-issue-19552.rs:1:21
    |
 LL | fn assert_static<T: 'static>(_t: T) {}
diff --git a/tests/ui/static/static-lifetime-bound.stderr b/tests/ui/static/static-lifetime-bound.stderr
index e530e4669d7f6..354a1327beead 100644
--- a/tests/ui/static/static-lifetime-bound.stderr
+++ b/tests/ui/static/static-lifetime-bound.stderr
@@ -11,7 +11,7 @@ LL |     f(&x);
 LL | }
    | - `x` dropped here while still borrowed
    |
-note: requirement that `x` is borrowed for `'static` introduced here
+note: requirement for `'static` introduced here
   --> $DIR/static-lifetime-bound.rs:1:10
    |
 LL | fn f<'a: 'static>(_: &'a i32) {}
diff --git a/tests/ui/static/static-region-bound.stderr b/tests/ui/static/static-region-bound.stderr
index a47c94571022d..e7747216a57b1 100644
--- a/tests/ui/static/static-region-bound.stderr
+++ b/tests/ui/static/static-region-bound.stderr
@@ -7,6 +7,12 @@ LL |     f(x);
    |     ---- argument requires that borrow lasts for `'static`
 LL | }
    | - temporary value is freed at the end of this statement
+   |
+note: requirement for `'static` introduced here
+  --> $DIR/static-region-bound.rs:3:8
+   |
+LL | fn f<T:'static>(_: T) {}
+   |        ^^^^^^^
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/wf/wf-in-where-clause-static.current.stderr b/tests/ui/wf/wf-in-where-clause-static.current.stderr
index d0bb89884c68a..53cc6093f540b 100644
--- a/tests/ui/wf/wf-in-where-clause-static.current.stderr
+++ b/tests/ui/wf/wf-in-where-clause-static.current.stderr
@@ -6,6 +6,12 @@ LL |     let s = foo(&String::from("blah blah blah"));
    |             |    |
    |             |    creates a temporary value which is freed while still in use
    |             argument requires that borrow lasts for `'static`
+   |
+note: requirement for `'static` introduced here
+  --> $DIR/wf-in-where-clause-static.rs:12:17
+   |
+LL |     &'static S: Static,
+   |                 ^^^^^^
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/wf/wf-in-where-clause-static.next.stderr b/tests/ui/wf/wf-in-where-clause-static.next.stderr
index d0bb89884c68a..53cc6093f540b 100644
--- a/tests/ui/wf/wf-in-where-clause-static.next.stderr
+++ b/tests/ui/wf/wf-in-where-clause-static.next.stderr
@@ -6,6 +6,12 @@ LL |     let s = foo(&String::from("blah blah blah"));
    |             |    |
    |             |    creates a temporary value which is freed while still in use
    |             argument requires that borrow lasts for `'static`
+   |
+note: requirement for `'static` introduced here
+  --> $DIR/wf-in-where-clause-static.rs:12:17
+   |
+LL |     &'static S: Static,
+   |                 ^^^^^^
 
 error: aborting due to 1 previous error
 

From 4973903cd204dd2cd36e15267de72ed6d954e3a6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sun, 31 Aug 2025 20:42:01 +0000
Subject: [PATCH 1532/1889] reword note

---
 .../rustc_borrowck/src/diagnostics/explain_borrow.rs   |  2 +-
 .../without-precise-captures-we-are-powerless.stderr   | 10 +++++-----
 tests/ui/borrowck/fn-item-check-type-params.stderr     |  4 ++--
 ...implementation-not-general-enough-ice-133252.stderr |  2 +-
 tests/ui/borrowck/issue-17545.stderr                   |  2 +-
 .../bugs/hrtb-implied-1.stderr                         |  2 +-
 .../ui/impl-trait/precise-capturing/migration-note.rs  |  4 ++--
 .../impl-trait/precise-capturing/migration-note.stderr |  4 ++--
 ...ted-shorter-to-static-comparing-against-free.stderr |  2 +-
 .../propagate-multiple-requirements.stderr             |  2 +-
 tests/ui/nll/local-outlives-static-via-hrtb.stderr     |  4 ++--
 ...location-insensitive-scopes-issue-117146.nll.stderr |  2 +-
 ...ion-insensitive-scopes-issue-117146.polonius.stderr |  2 +-
 .../ui/regions/regions-infer-proc-static-upvar.stderr  |  2 +-
 .../regions/regions-pattern-typing-issue-19552.stderr  |  2 +-
 tests/ui/static/static-lifetime-bound.stderr           |  2 +-
 tests/ui/static/static-region-bound.stderr             |  2 +-
 tests/ui/wf/wf-in-where-clause-static.current.stderr   |  2 +-
 tests/ui/wf/wf-in-where-clause-static.next.stderr      |  2 +-
 19 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs b/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs
index a0ea8b0855699..66c43a07c80ce 100644
--- a/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs
@@ -423,7 +423,7 @@ impl<'tcx> BorrowExplanation<'tcx> {
                     {
                         err.span_note(
                             pred,
-                            format!("requirement for `{region_name}` introduced here"),
+                            format!("requirement that the value outlives `{region_name}` introduced here"),
                         );
                         break;
                     }
diff --git a/tests/ui/async-await/async-closures/without-precise-captures-we-are-powerless.stderr b/tests/ui/async-await/async-closures/without-precise-captures-we-are-powerless.stderr
index e0776c81dff3d..4aae9807dd2e4 100644
--- a/tests/ui/async-await/async-closures/without-precise-captures-we-are-powerless.stderr
+++ b/tests/ui/async-await/async-closures/without-precise-captures-we-are-powerless.stderr
@@ -29,7 +29,7 @@ LL |     outlives::<'a>(call_once(c));
 LL | }
    | - `c` dropped here while still borrowed
    |
-note: requirement for `'a` introduced here
+note: requirement that the value outlives `'a` introduced here
   --> $DIR/without-precise-captures-we-are-powerless.rs:7:33
    |
 LL | fn outlives<'a>(_: impl Sized + 'a) {}
@@ -80,7 +80,7 @@ LL |     outlives::<'a>(call_once(c));
 LL | }
    | - `c` dropped here while still borrowed
    |
-note: requirement for `'a` introduced here
+note: requirement that the value outlives `'a` introduced here
   --> $DIR/without-precise-captures-we-are-powerless.rs:7:33
    |
 LL | fn outlives<'a>(_: impl Sized + 'a) {}
@@ -102,7 +102,7 @@ LL |     outlives::<'a>(c());
 LL |     outlives::<'a>(call_once(c));
    |                              ^ move out of `c` occurs here
    |
-note: requirement for `'a` introduced here
+note: requirement that the value outlives `'a` introduced here
   --> $DIR/without-precise-captures-we-are-powerless.rs:7:33
    |
 LL | fn outlives<'a>(_: impl Sized + 'a) {}
@@ -148,7 +148,7 @@ LL |     outlives::<'a>(call_once(c));
 LL | }
    | - `c` dropped here while still borrowed
    |
-note: requirement for `'a` introduced here
+note: requirement that the value outlives `'a` introduced here
   --> $DIR/without-precise-captures-we-are-powerless.rs:7:33
    |
 LL | fn outlives<'a>(_: impl Sized + 'a) {}
@@ -196,7 +196,7 @@ LL |     T.outlives::<'a>(call_once(c));
 LL | }
    | - `c` dropped here while still borrowed
    |
-note: requirement for `'a` introduced here
+note: requirement that the value outlives `'a` introduced here
   --> $DIR/without-precise-captures-we-are-powerless.rs:49:47
    |
 LL |     fn outlives<'a>(&'a self, _: impl Sized + 'a) {}
diff --git a/tests/ui/borrowck/fn-item-check-type-params.stderr b/tests/ui/borrowck/fn-item-check-type-params.stderr
index 8da0201134b03..7a0a7752a14b2 100644
--- a/tests/ui/borrowck/fn-item-check-type-params.stderr
+++ b/tests/ui/borrowck/fn-item-check-type-params.stderr
@@ -28,7 +28,7 @@ LL |     want(&String::new(), extend_lt);
    |     |     creates a temporary value which is freed while still in use
    |     argument requires that borrow lasts for `'static`
    |
-note: requirement for `'static` introduced here
+note: requirement that the value outlives `'static` introduced here
   --> $DIR/fn-item-check-type-params.rs:47:33
    |
 LL |     fn want<I, O>(_: I, _: impl Fn(I) -> O) {}
@@ -43,7 +43,7 @@ LL |     let val = extend_lt(&String::from("blah blah blah"));
    |               |          creates a temporary value which is freed while still in use
    |               argument requires that borrow lasts for `'static`
    |
-note: requirement for `'static` introduced here
+note: requirement that the value outlives `'static` introduced here
   --> $DIR/fn-item-check-type-params.rs:22:21
    |
 LL |     (T, Option<U>): Displayable,
diff --git a/tests/ui/borrowck/implementation-not-general-enough-ice-133252.stderr b/tests/ui/borrowck/implementation-not-general-enough-ice-133252.stderr
index dab969586efd8..7b840d54ed038 100644
--- a/tests/ui/borrowck/implementation-not-general-enough-ice-133252.stderr
+++ b/tests/ui/borrowck/implementation-not-general-enough-ice-133252.stderr
@@ -23,7 +23,7 @@ LL |         force_send(async_load(&not_static));
 LL |     }
    |     - `not_static` dropped here while still borrowed
    |
-note: requirement for `'1` introduced here
+note: requirement that the value outlives `'1` introduced here
   --> $DIR/implementation-not-general-enough-ice-133252.rs:16:18
    |
 LL | fn force_send<T: Send>(_: T) {}
diff --git a/tests/ui/borrowck/issue-17545.stderr b/tests/ui/borrowck/issue-17545.stderr
index dc0a84b0ab42a..63fd57cd2336f 100644
--- a/tests/ui/borrowck/issue-17545.stderr
+++ b/tests/ui/borrowck/issue-17545.stderr
@@ -11,7 +11,7 @@ LL | |     ));
    | |______|
    |        argument requires that borrow lasts for `'a`
    |
-note: requirement for `'a` introduced here
+note: requirement that the value outlives `'a` introduced here
   --> $SRC_DIR/core/src/ops/function.rs:LL:COL
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/generic-associated-types/bugs/hrtb-implied-1.stderr b/tests/ui/generic-associated-types/bugs/hrtb-implied-1.stderr
index 72f9a477dafcc..77a637c470cc2 100644
--- a/tests/ui/generic-associated-types/bugs/hrtb-implied-1.stderr
+++ b/tests/ui/generic-associated-types/bugs/hrtb-implied-1.stderr
@@ -14,7 +14,7 @@ note: due to a current limitation of the type system, this implies a `'static` l
    |
 LL |     for<'a> I::Item<'a>: Debug,
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
-note: requirement for `'static` introduced here
+note: requirement that the value outlives `'static` introduced here
   --> $DIR/hrtb-implied-1.rs:26:26
    |
 LL |     for<'a> I::Item<'a>: Debug,
diff --git a/tests/ui/impl-trait/precise-capturing/migration-note.rs b/tests/ui/impl-trait/precise-capturing/migration-note.rs
index 211def3332002..412d8af98845e 100644
--- a/tests/ui/impl-trait/precise-capturing/migration-note.rs
+++ b/tests/ui/impl-trait/precise-capturing/migration-note.rs
@@ -32,7 +32,7 @@ fn needs_static() {
     //~| NOTE borrowed value does not live long enoug
 
     fn needs_static(_: impl Sized + 'static) {}
-    //~^ NOTE requirement for `'static` introduced here
+    //~^ NOTE requirement that the value outlives `'static` introduced here
     needs_static(a);
     //~^ NOTE argument requires that `x` is borrowed for `'static`
 }
@@ -80,7 +80,7 @@ fn needs_static_mut() {
     //~| NOTE borrowed value does not live long enough
 
     fn needs_static(_: impl Sized + 'static) {}
-    //~^ NOTE requirement for `'static` introduced here
+    //~^ NOTE requirement that the value outlives `'static` introduced here
     needs_static(a);
     //~^ NOTE argument requires that `x` is borrowed for `'static`
 }
diff --git a/tests/ui/impl-trait/precise-capturing/migration-note.stderr b/tests/ui/impl-trait/precise-capturing/migration-note.stderr
index c06b14a41139b..880e7878477af 100644
--- a/tests/ui/impl-trait/precise-capturing/migration-note.stderr
+++ b/tests/ui/impl-trait/precise-capturing/migration-note.stderr
@@ -50,7 +50,7 @@ LL |
 LL | }
    | - `x` dropped here while still borrowed
    |
-note: requirement for `'static` introduced here
+note: requirement that the value outlives `'static` introduced here
   --> $DIR/migration-note.rs:34:37
    |
 LL |     fn needs_static(_: impl Sized + 'static) {}
@@ -131,7 +131,7 @@ LL |
 LL | }
    | - `x` dropped here while still borrowed
    |
-note: requirement for `'static` introduced here
+note: requirement that the value outlives `'static` introduced here
   --> $DIR/migration-note.rs:82:37
    |
 LL |     fn needs_static(_: impl Sized + 'static) {}
diff --git a/tests/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-comparing-against-free.stderr b/tests/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-comparing-against-free.stderr
index eb110e868aa58..af07745a00af4 100644
--- a/tests/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-comparing-against-free.stderr
+++ b/tests/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-comparing-against-free.stderr
@@ -70,7 +70,7 @@ LL |     })
 LL | }
    | - `a` dropped here while still borrowed
    |
-note: requirement for `'static` introduced here
+note: requirement that the value outlives `'static` introduced here
   --> $DIR/propagate-approximated-shorter-to-static-comparing-against-free.rs:13:8
    |
 LL |     F: for<'x> FnOnce(Cell<&'a u32>, Cell<&'x u32>),
diff --git a/tests/ui/nll/closure-requirements/propagate-multiple-requirements.stderr b/tests/ui/nll/closure-requirements/propagate-multiple-requirements.stderr
index 51e4d77c91a1b..4136ac418deb4 100644
--- a/tests/ui/nll/closure-requirements/propagate-multiple-requirements.stderr
+++ b/tests/ui/nll/closure-requirements/propagate-multiple-requirements.stderr
@@ -14,7 +14,7 @@ LL |         z = &local_arr;
 LL | }
    | - `local_arr` dropped here while still borrowed
    |
-note: requirement for `'static` introduced here
+note: requirement that the value outlives `'static` introduced here
   --> $DIR/propagate-multiple-requirements.rs:4:21
    |
 LL | fn once<S, T, U, F: FnOnce(S, T) -> U>(f: F, s: S, t: T) -> U {
diff --git a/tests/ui/nll/local-outlives-static-via-hrtb.stderr b/tests/ui/nll/local-outlives-static-via-hrtb.stderr
index ff2be3a2b28ec..263d271b6b3d0 100644
--- a/tests/ui/nll/local-outlives-static-via-hrtb.stderr
+++ b/tests/ui/nll/local-outlives-static-via-hrtb.stderr
@@ -17,7 +17,7 @@ note: due to a current limitation of the type system, this implies a `'static` l
    |
 LL | fn assert_static_via_hrtb<G>(_: G) where for<'a> G: Outlives<'a> {}
    |                                          ^^^^^^^^^^^^^^^^^^^^^^^
-note: requirement for `'static` introduced here
+note: requirement that the value outlives `'static` introduced here
   --> $DIR/local-outlives-static-via-hrtb.rs:15:53
    |
 LL | fn assert_static_via_hrtb<G>(_: G) where for<'a> G: Outlives<'a> {}
@@ -42,7 +42,7 @@ note: due to a current limitation of the type system, this implies a `'static` l
    |
 LL |     for<'a> &'a T: Reference<AssociatedType = &'a ()>,
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-note: requirement for `'static` introduced here
+note: requirement that the value outlives `'static` introduced here
   --> $DIR/local-outlives-static-via-hrtb.rs:19:30
    |
 LL |     for<'a> &'a T: Reference<AssociatedType = &'a ()>,
diff --git a/tests/ui/nll/polonius/location-insensitive-scopes-issue-117146.nll.stderr b/tests/ui/nll/polonius/location-insensitive-scopes-issue-117146.nll.stderr
index fdc3fc059c534..804b3f00a2642 100644
--- a/tests/ui/nll/polonius/location-insensitive-scopes-issue-117146.nll.stderr
+++ b/tests/ui/nll/polonius/location-insensitive-scopes-issue-117146.nll.stderr
@@ -18,7 +18,7 @@ note: due to a current limitation of the type system, this implies a `'static` l
    |
 LL | fn bad<F: Fn(&()) -> &()>(_: F) {}
    |           ^^^^^^^^^^^^^^
-note: requirement for `'static` introduced here
+note: requirement that the value outlives `'static` introduced here
   --> $DIR/location-insensitive-scopes-issue-117146.rs:20:22
    |
 LL | fn bad<F: Fn(&()) -> &()>(_: F) {}
diff --git a/tests/ui/nll/polonius/location-insensitive-scopes-issue-117146.polonius.stderr b/tests/ui/nll/polonius/location-insensitive-scopes-issue-117146.polonius.stderr
index fdc3fc059c534..804b3f00a2642 100644
--- a/tests/ui/nll/polonius/location-insensitive-scopes-issue-117146.polonius.stderr
+++ b/tests/ui/nll/polonius/location-insensitive-scopes-issue-117146.polonius.stderr
@@ -18,7 +18,7 @@ note: due to a current limitation of the type system, this implies a `'static` l
    |
 LL | fn bad<F: Fn(&()) -> &()>(_: F) {}
    |           ^^^^^^^^^^^^^^
-note: requirement for `'static` introduced here
+note: requirement that the value outlives `'static` introduced here
   --> $DIR/location-insensitive-scopes-issue-117146.rs:20:22
    |
 LL | fn bad<F: Fn(&()) -> &()>(_: F) {}
diff --git a/tests/ui/regions/regions-infer-proc-static-upvar.stderr b/tests/ui/regions/regions-infer-proc-static-upvar.stderr
index ff833de0ad012..158d74ed06d94 100644
--- a/tests/ui/regions/regions-infer-proc-static-upvar.stderr
+++ b/tests/ui/regions/regions-infer-proc-static-upvar.stderr
@@ -12,7 +12,7 @@ LL | |     });
 LL |   }
    |   - `x` dropped here while still borrowed
    |
-note: requirement for `'static` introduced here
+note: requirement that the value outlives `'static` introduced here
   --> $DIR/regions-infer-proc-static-upvar.rs:4:19
    |
 LL | fn foo<F:FnOnce()+'static>(_p: F) { }
diff --git a/tests/ui/regions/regions-pattern-typing-issue-19552.stderr b/tests/ui/regions/regions-pattern-typing-issue-19552.stderr
index 76cd18dfa1329..a8fd827bc6951 100644
--- a/tests/ui/regions/regions-pattern-typing-issue-19552.stderr
+++ b/tests/ui/regions/regions-pattern-typing-issue-19552.stderr
@@ -11,7 +11,7 @@ LL |     }
 LL | }
    | - `line` dropped here while still borrowed
    |
-note: requirement for `'static` introduced here
+note: requirement that the value outlives `'static` introduced here
   --> $DIR/regions-pattern-typing-issue-19552.rs:1:21
    |
 LL | fn assert_static<T: 'static>(_t: T) {}
diff --git a/tests/ui/static/static-lifetime-bound.stderr b/tests/ui/static/static-lifetime-bound.stderr
index 354a1327beead..51be79be5db8a 100644
--- a/tests/ui/static/static-lifetime-bound.stderr
+++ b/tests/ui/static/static-lifetime-bound.stderr
@@ -11,7 +11,7 @@ LL |     f(&x);
 LL | }
    | - `x` dropped here while still borrowed
    |
-note: requirement for `'static` introduced here
+note: requirement that the value outlives `'static` introduced here
   --> $DIR/static-lifetime-bound.rs:1:10
    |
 LL | fn f<'a: 'static>(_: &'a i32) {}
diff --git a/tests/ui/static/static-region-bound.stderr b/tests/ui/static/static-region-bound.stderr
index e7747216a57b1..8472738daa49c 100644
--- a/tests/ui/static/static-region-bound.stderr
+++ b/tests/ui/static/static-region-bound.stderr
@@ -8,7 +8,7 @@ LL |     f(x);
 LL | }
    | - temporary value is freed at the end of this statement
    |
-note: requirement for `'static` introduced here
+note: requirement that the value outlives `'static` introduced here
   --> $DIR/static-region-bound.rs:3:8
    |
 LL | fn f<T:'static>(_: T) {}
diff --git a/tests/ui/wf/wf-in-where-clause-static.current.stderr b/tests/ui/wf/wf-in-where-clause-static.current.stderr
index 53cc6093f540b..788fe2c3faa07 100644
--- a/tests/ui/wf/wf-in-where-clause-static.current.stderr
+++ b/tests/ui/wf/wf-in-where-clause-static.current.stderr
@@ -7,7 +7,7 @@ LL |     let s = foo(&String::from("blah blah blah"));
    |             |    creates a temporary value which is freed while still in use
    |             argument requires that borrow lasts for `'static`
    |
-note: requirement for `'static` introduced here
+note: requirement that the value outlives `'static` introduced here
   --> $DIR/wf-in-where-clause-static.rs:12:17
    |
 LL |     &'static S: Static,
diff --git a/tests/ui/wf/wf-in-where-clause-static.next.stderr b/tests/ui/wf/wf-in-where-clause-static.next.stderr
index 53cc6093f540b..788fe2c3faa07 100644
--- a/tests/ui/wf/wf-in-where-clause-static.next.stderr
+++ b/tests/ui/wf/wf-in-where-clause-static.next.stderr
@@ -7,7 +7,7 @@ LL |     let s = foo(&String::from("blah blah blah"));
    |             |    creates a temporary value which is freed while still in use
    |             argument requires that borrow lasts for `'static`
    |
-note: requirement for `'static` introduced here
+note: requirement that the value outlives `'static` introduced here
   --> $DIR/wf-in-where-clause-static.rs:12:17
    |
 LL |     &'static S: Static,

From 58f5260b960004090bfa9e7ef5068d6554ac9f33 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sun, 28 Sep 2025 20:58:44 +0000
Subject: [PATCH 1533/1889] Address review comment

---
 .../src/diagnostics/explain_borrow.rs         | 24 +++++++++++--------
 1 file changed, 14 insertions(+), 10 deletions(-)

diff --git a/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs b/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs
index 66c43a07c80ce..67e33b37416c4 100644
--- a/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs
@@ -417,16 +417,20 @@ impl<'tcx> BorrowExplanation<'tcx> {
                     self.add_object_lifetime_default_note(tcx, err, unsize_ty);
                 }
 
-                for constraint in path {
-                    if let ConstraintCategory::Predicate(pred) = constraint.category
-                        && !pred.is_dummy()
-                    {
-                        err.span_note(
-                            pred,
-                            format!("requirement that the value outlives `{region_name}` introduced here"),
-                        );
-                        break;
-                    }
+                if let Some(pred) = path
+                    .iter()
+                    .filter_map(|constraint| match constraint.category {
+                        ConstraintCategory::Predicate(pred) if !pred.is_dummy() => Some(pred),
+                        _ => None,
+                    })
+                    .next()
+                {
+                    err.span_note(
+                        pred,
+                        format!(
+                            "requirement that the value outlives `{region_name}` introduced here"
+                        ),
+                    );
                 }
 
                 self.add_lifetime_bound_suggestion_to_diagnostic(err, &category, span, region_name);

From c5313fed76a99942edb4c7f94607fa3d2d6da21c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sun, 28 Sep 2025 21:13:53 +0000
Subject: [PATCH 1534/1889] Point at multiple outlives requirements instead of
 just the first one

```
error[E0716]: temporary value dropped while borrowed
  --> $DIR/multiple-sources-for-outlives-requirement.rs:5:38
   |
LL | fn foo<'b>() {
   |        -- lifetime `'b` defined here
LL |     outlives_indir::<'_, 'b, _>(&mut 1u32);
   |     ---------------------------------^^^^-- temporary value is freed at the end of this statement
   |     |                                |
   |     |                                creates a temporary value which is freed while still in use
   |     argument requires that borrow lasts for `'b`
   |
note: requirements that the value outlives `'b` introduced here
  --> $DIR/multiple-sources-for-outlives-requirement.rs:1:23
   |
LL | fn outlives_indir<'a: 'b, 'b, T: 'a>(_x: T) {}
   |                       ^^         ^^
```
---
 .../src/diagnostics/explain_borrow.rs         | 13 +++++++-----
 ...ltiple-sources-for-outlives-requirement.rs | 11 ++++++++++
 ...le-sources-for-outlives-requirement.stderr | 20 +++++++++++++++++++
 3 files changed, 39 insertions(+), 5 deletions(-)
 create mode 100644 tests/ui/regions/multiple-sources-for-outlives-requirement.rs
 create mode 100644 tests/ui/regions/multiple-sources-for-outlives-requirement.stderr

diff --git a/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs b/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs
index 67e33b37416c4..638d89f5bcbdb 100644
--- a/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs
@@ -417,18 +417,21 @@ impl<'tcx> BorrowExplanation<'tcx> {
                     self.add_object_lifetime_default_note(tcx, err, unsize_ty);
                 }
 
-                if let Some(pred) = path
+                let mut preds = path
                     .iter()
                     .filter_map(|constraint| match constraint.category {
                         ConstraintCategory::Predicate(pred) if !pred.is_dummy() => Some(pred),
                         _ => None,
                     })
-                    .next()
-                {
+                    .collect::<Vec<Span>>();
+                preds.sort();
+                preds.dedup();
+                if !preds.is_empty() {
+                    let s = if preds.len() == 1 { "" } else { "s" };
                     err.span_note(
-                        pred,
+                        preds,
                         format!(
-                            "requirement that the value outlives `{region_name}` introduced here"
+                            "requirement{s} that the value outlives `{region_name}` introduced here"
                         ),
                     );
                 }
diff --git a/tests/ui/regions/multiple-sources-for-outlives-requirement.rs b/tests/ui/regions/multiple-sources-for-outlives-requirement.rs
new file mode 100644
index 0000000000000..720cd1cf6eecb
--- /dev/null
+++ b/tests/ui/regions/multiple-sources-for-outlives-requirement.rs
@@ -0,0 +1,11 @@
+fn outlives_indir<'a: 'b, 'b, T: 'a>(_x: T) {}
+//~^ NOTE: requirements that the value outlives `'b` introduced here
+
+fn foo<'b>() { //~ NOTE: lifetime `'b` defined here
+    outlives_indir::<'_, 'b, _>(&mut 1u32); //~ ERROR: temporary value dropped while borrowed
+    //~^ NOTE: argument requires that borrow lasts for `'b`
+    //~| NOTE: creates a temporary value which is freed while still in use
+    //~| NOTE: temporary value is freed at the end of this statement
+}
+
+fn main() {}
diff --git a/tests/ui/regions/multiple-sources-for-outlives-requirement.stderr b/tests/ui/regions/multiple-sources-for-outlives-requirement.stderr
new file mode 100644
index 0000000000000..4cdaf950e155c
--- /dev/null
+++ b/tests/ui/regions/multiple-sources-for-outlives-requirement.stderr
@@ -0,0 +1,20 @@
+error[E0716]: temporary value dropped while borrowed
+  --> $DIR/multiple-sources-for-outlives-requirement.rs:5:38
+   |
+LL | fn foo<'b>() {
+   |        -- lifetime `'b` defined here
+LL |     outlives_indir::<'_, 'b, _>(&mut 1u32);
+   |     ---------------------------------^^^^-- temporary value is freed at the end of this statement
+   |     |                                |
+   |     |                                creates a temporary value which is freed while still in use
+   |     argument requires that borrow lasts for `'b`
+   |
+note: requirements that the value outlives `'b` introduced here
+  --> $DIR/multiple-sources-for-outlives-requirement.rs:1:23
+   |
+LL | fn outlives_indir<'a: 'b, 'b, T: 'a>(_x: T) {}
+   |                       ^^         ^^
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0716`.

From 8f7d61b9efe1f44701f87fe4647eb1f39d20f434 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Mon, 25 Nov 2024 21:52:08 +0000
Subject: [PATCH 1535/1889] Detect unconstructable re-exported tuple structs

When a tuple-struct is re-exported that has inaccessible fields at the `use` scope, the type's constructor cannot be accessed through that re-export. We now account for this case and extend the resulting resolution error. We also check if the constructor would be accessible directly, not through the re-export, and if so, we suggest using the full path instead.

```
error[E0423]: cannot initialize a tuple struct which contains private fields
  --> $DIR/ctor-not-accessible-due-to-inaccessible-field-in-reexport.rs:12:33
   |
LL |             let crate::Foo(x) = crate::Foo(42);
   |                                 ^^^^^^^^^^
   |
note: the type is accessed through this re-export, but the type's constructor is not visible in this import's scope due to private fields
  --> $DIR/ctor-not-accessible-due-to-inaccessible-field-in-reexport.rs:3:9
   |
LL | pub use my_mod::Foo;
   |         ^^^^^^^^^^^
help: the type can be constructed directly, because its fields are available from the current scope
   |
LL |             let crate::Foo(x) = crate::my_mod::Foo(42);
   |                                 ~~~~~~~~~~~~~~~~~~
```

Fix #133343.
---
 compiler/rustc_resolve/src/ident.rs           | 33 +++++++
 .../rustc_resolve/src/late/diagnostics.rs     | 99 ++++++++++++-------
 compiler/rustc_resolve/src/lib.rs             |  6 ++
 ...ue-to-inaccessible-field-in-reexport.fixed | 20 ++++
 ...e-due-to-inaccessible-field-in-reexport.rs | 20 ++++
 ...e-to-inaccessible-field-in-reexport.stderr | 36 +++++++
 6 files changed, 181 insertions(+), 33 deletions(-)
 create mode 100644 tests/ui/privacy/ctor-not-accessible-due-to-inaccessible-field-in-reexport.fixed
 create mode 100644 tests/ui/privacy/ctor-not-accessible-due-to-inaccessible-field-in-reexport.rs
 create mode 100644 tests/ui/privacy/ctor-not-accessible-due-to-inaccessible-field-in-reexport.stderr

diff --git a/compiler/rustc_resolve/src/ident.rs b/compiler/rustc_resolve/src/ident.rs
index 51489019950ad..4415300777f98 100644
--- a/compiler/rustc_resolve/src/ident.rs
+++ b/compiler/rustc_resolve/src/ident.rs
@@ -901,6 +901,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 binding,
                 if resolution.non_glob_binding.is_some() { resolution.glob_binding } else { None },
                 parent_scope,
+                module,
                 finalize,
                 shadowing,
             );
@@ -1025,6 +1026,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         binding: Option<NameBinding<'ra>>,
         shadowed_glob: Option<NameBinding<'ra>>,
         parent_scope: &ParentScope<'ra>,
+        module: Module<'ra>,
         finalize: Finalize,
         shadowing: Shadowing,
     ) -> Result<NameBinding<'ra>, (Determinacy, Weak)> {
@@ -1076,6 +1078,37 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             self.macro_expanded_macro_export_errors.insert((path_span, binding.span));
         }
 
+        // If we encounter a re-export for a type with private fields, it will not be able to
+        // be constructed through this re-export. We track that case here to expand later
+        // privacy errors with appropriate information.
+        if let Res::Def(_, def_id) = binding.res() {
+            let struct_ctor = match def_id.as_local() {
+                Some(def_id) => self.struct_constructors.get(&def_id).cloned(),
+                None => {
+                    let ctor = self.cstore().ctor_untracked(def_id);
+                    ctor.map(|(ctor_kind, ctor_def_id)| {
+                        let ctor_res = Res::Def(
+                            DefKind::Ctor(rustc_hir::def::CtorOf::Struct, ctor_kind),
+                            ctor_def_id,
+                        );
+                        let ctor_vis = self.tcx.visibility(ctor_def_id);
+                        let field_visibilities = self
+                            .tcx
+                            .associated_item_def_ids(def_id)
+                            .iter()
+                            .map(|field_id| self.tcx.visibility(field_id))
+                            .collect();
+                        (ctor_res, ctor_vis, field_visibilities)
+                    })
+                }
+            };
+            if let Some((_, _, fields)) = struct_ctor
+                && fields.iter().any(|vis| !self.is_accessible_from(*vis, module))
+            {
+                self.inaccessible_ctor_reexport.insert(path_span, binding.span);
+            }
+        }
+
         self.record_use(ident, binding, used);
         return Ok(binding);
     }
diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs
index 9e3c093883661..8c2ddda7f9834 100644
--- a/compiler/rustc_resolve/src/late/diagnostics.rs
+++ b/compiler/rustc_resolve/src/late/diagnostics.rs
@@ -1942,44 +1942,77 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
                     return true;
                 };
 
+                let update_message =
+                    |this: &mut Self, err: &mut Diag<'_>, source: &PathSource<'_, '_, '_>| {
+                        match source {
+                            // e.g. `if let Enum::TupleVariant(field1, field2) = _`
+                            PathSource::TupleStruct(_, pattern_spans) => {
+                                err.primary_message(
+                                "cannot match against a tuple struct which contains private fields",
+                            );
+
+                                // Use spans of the tuple struct pattern.
+                                Some(Vec::from(*pattern_spans))
+                            }
+                            // e.g. `let _ = Enum::TupleVariant(field1, field2);`
+                            PathSource::Expr(Some(Expr {
+                                kind: ExprKind::Call(path, args),
+                                span: call_span,
+                                ..
+                            })) => {
+                                err.primary_message(
+                                "cannot initialize a tuple struct which contains private fields",
+                            );
+                                this.suggest_alternative_construction_methods(
+                                    def_id,
+                                    err,
+                                    path.span,
+                                    *call_span,
+                                    &args[..],
+                                );
+                                // Use spans of the tuple struct definition.
+                                this.r
+                                    .field_idents(def_id)
+                                    .map(|fields| fields.iter().map(|f| f.span).collect::<Vec<_>>())
+                            }
+                            _ => None,
+                        }
+                    };
                 let is_accessible = self.r.is_accessible_from(ctor_vis, self.parent_scope.module);
+                if let Some(use_span) = self.r.inaccessible_ctor_reexport.get(&span)
+                    && is_accessible
+                {
+                    err.span_note(
+                        *use_span,
+                        "the type is accessed through this re-export, but the type's constructor \
+                         is not visible in this import's scope due to private fields",
+                    );
+                    if is_accessible
+                        && fields
+                            .iter()
+                            .all(|vis| self.r.is_accessible_from(*vis, self.parent_scope.module))
+                    {
+                        err.span_suggestion_verbose(
+                            span,
+                            "the type can be constructed directly, because its fields are \
+                             available from the current scope",
+                            // Using `tcx.def_path_str` causes the compiler to hang.
+                            // We don't need to handle foreign crate types because in that case you
+                            // can't access the ctor either way.
+                            format!(
+                                "crate{}", // The method already has leading `::`.
+                                self.r.tcx.def_path(def_id).to_string_no_crate_verbose(),
+                            ),
+                            Applicability::MachineApplicable,
+                        );
+                    }
+                    update_message(self, err, &source);
+                }
                 if !is_expected(ctor_def) || is_accessible {
                     return true;
                 }
 
-                let field_spans = match source {
-                    // e.g. `if let Enum::TupleVariant(field1, field2) = _`
-                    PathSource::TupleStruct(_, pattern_spans) => {
-                        err.primary_message(
-                            "cannot match against a tuple struct which contains private fields",
-                        );
-
-                        // Use spans of the tuple struct pattern.
-                        Some(Vec::from(pattern_spans))
-                    }
-                    // e.g. `let _ = Enum::TupleVariant(field1, field2);`
-                    PathSource::Expr(Some(Expr {
-                        kind: ExprKind::Call(path, args),
-                        span: call_span,
-                        ..
-                    })) => {
-                        err.primary_message(
-                            "cannot initialize a tuple struct which contains private fields",
-                        );
-                        self.suggest_alternative_construction_methods(
-                            def_id,
-                            err,
-                            path.span,
-                            *call_span,
-                            &args[..],
-                        );
-                        // Use spans of the tuple struct definition.
-                        self.r
-                            .field_idents(def_id)
-                            .map(|fields| fields.iter().map(|f| f.span).collect::<Vec<_>>())
-                    }
-                    _ => None,
-                };
+                let field_spans = update_message(self, err, &source);
 
                 if let Some(spans) =
                     field_spans.filter(|spans| spans.len() > 0 && fields.len() == spans.len())
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index 8959068b2a677..b44b1c966a431 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -1167,6 +1167,11 @@ pub struct Resolver<'ra, 'tcx> {
     /// Crate-local macro expanded `macro_export` referred to by a module-relative path.
     macro_expanded_macro_export_errors: BTreeSet<(Span, Span)> = BTreeSet::new(),
 
+    /// When a type is re-exported that has an inaccessible constructor because it has fields that
+    /// are inaccessible from the import's scope, we mark that as the type won't be able to be built
+    /// through the re-export. We use this information to extend the existing diagnostic.
+    inaccessible_ctor_reexport: FxHashMap<Span, Span>,
+
     arenas: &'ra ResolverArenas<'ra>,
     dummy_binding: NameBinding<'ra>,
     builtin_types_bindings: FxHashMap<Symbol, NameBinding<'ra>>,
@@ -1595,6 +1600,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             glob_map: Default::default(),
             used_imports: FxHashSet::default(),
             maybe_unused_trait_imports: Default::default(),
+            inaccessible_ctor_reexport: Default::default(),
 
             arenas,
             dummy_binding: arenas.new_pub_res_binding(Res::Err, DUMMY_SP, LocalExpnId::ROOT),
diff --git a/tests/ui/privacy/ctor-not-accessible-due-to-inaccessible-field-in-reexport.fixed b/tests/ui/privacy/ctor-not-accessible-due-to-inaccessible-field-in-reexport.fixed
new file mode 100644
index 0000000000000..63cc3333b6b77
--- /dev/null
+++ b/tests/ui/privacy/ctor-not-accessible-due-to-inaccessible-field-in-reexport.fixed
@@ -0,0 +1,20 @@
+#![allow(dead_code, unused_variables)]
+//@ run-rustfix
+pub use my_mod::Foo;
+//~^ NOTE the type is accessed through this re-export, but the type's constructor is not visible in this import's scope due to private fields
+//~| NOTE the type is accessed through this re-export, but the type's constructor is not visible in this import's scope due to private fields
+
+mod my_mod {
+    pub struct Foo(u32);
+
+    mod my_sub_mod {
+        fn my_func() {
+            let crate::my_mod::Foo(x) = crate::my_mod::Foo(42);
+            //~^ ERROR cannot initialize a tuple struct which contains private fields
+            //~| HELP the type can be constructed directly, because its fields are available from the current scope
+            //~| ERROR cannot match against a tuple struct which contains private fields
+            //~| HELP the type can be constructed directly, because its fields are available from the current scope
+        }
+    }
+}
+fn main() {}
diff --git a/tests/ui/privacy/ctor-not-accessible-due-to-inaccessible-field-in-reexport.rs b/tests/ui/privacy/ctor-not-accessible-due-to-inaccessible-field-in-reexport.rs
new file mode 100644
index 0000000000000..0b695f9065459
--- /dev/null
+++ b/tests/ui/privacy/ctor-not-accessible-due-to-inaccessible-field-in-reexport.rs
@@ -0,0 +1,20 @@
+#![allow(dead_code, unused_variables)]
+//@ run-rustfix
+pub use my_mod::Foo;
+//~^ NOTE the type is accessed through this re-export, but the type's constructor is not visible in this import's scope due to private fields
+//~| NOTE the type is accessed through this re-export, but the type's constructor is not visible in this import's scope due to private fields
+
+mod my_mod {
+    pub struct Foo(u32);
+
+    mod my_sub_mod {
+        fn my_func() {
+            let crate::Foo(x) = crate::Foo(42);
+            //~^ ERROR cannot initialize a tuple struct which contains private fields
+            //~| HELP the type can be constructed directly, because its fields are available from the current scope
+            //~| ERROR cannot match against a tuple struct which contains private fields
+            //~| HELP the type can be constructed directly, because its fields are available from the current scope
+        }
+    }
+}
+fn main() {}
diff --git a/tests/ui/privacy/ctor-not-accessible-due-to-inaccessible-field-in-reexport.stderr b/tests/ui/privacy/ctor-not-accessible-due-to-inaccessible-field-in-reexport.stderr
new file mode 100644
index 0000000000000..6ab324cb32f39
--- /dev/null
+++ b/tests/ui/privacy/ctor-not-accessible-due-to-inaccessible-field-in-reexport.stderr
@@ -0,0 +1,36 @@
+error[E0423]: cannot initialize a tuple struct which contains private fields
+  --> $DIR/ctor-not-accessible-due-to-inaccessible-field-in-reexport.rs:12:33
+   |
+LL |             let crate::Foo(x) = crate::Foo(42);
+   |                                 ^^^^^^^^^^
+   |
+note: the type is accessed through this re-export, but the type's constructor is not visible in this import's scope due to private fields
+  --> $DIR/ctor-not-accessible-due-to-inaccessible-field-in-reexport.rs:3:9
+   |
+LL | pub use my_mod::Foo;
+   |         ^^^^^^^^^^^
+help: the type can be constructed directly, because its fields are available from the current scope
+   |
+LL |             let crate::Foo(x) = crate::my_mod::Foo(42);
+   |                                        ++++++++
+
+error[E0532]: cannot match against a tuple struct which contains private fields
+  --> $DIR/ctor-not-accessible-due-to-inaccessible-field-in-reexport.rs:12:17
+   |
+LL |             let crate::Foo(x) = crate::Foo(42);
+   |                 ^^^^^^^^^^
+   |
+note: the type is accessed through this re-export, but the type's constructor is not visible in this import's scope due to private fields
+  --> $DIR/ctor-not-accessible-due-to-inaccessible-field-in-reexport.rs:3:9
+   |
+LL | pub use my_mod::Foo;
+   |         ^^^^^^^^^^^
+help: the type can be constructed directly, because its fields are available from the current scope
+   |
+LL |             let crate::my_mod::Foo(x) = crate::Foo(42);
+   |                        ++++++++
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0423, E0532.
+For more information about an error, try `rustc --explain E0423`.

From 0c9d0dfe046f0674f0507df564504ac3bac862d9 Mon Sep 17 00:00:00 2001
From: Jubilee Young <workingjubilee@gmail.com>
Date: Sun, 28 Sep 2025 14:40:39 -0700
Subject: [PATCH 1536/1889] remove explicit deref of AbiAlign for most methods

Much of the compiler calls functions on Align projected from AbiAlign.
AbiAlign impls Deref to its inner Align, so we can simplify these away.
Also, it will minimize disruption when AbiAlign is removed.

For now, preserve usages that might resolve to PartialOrd or PartialEq,
as those have odd inference.
---
 compiler/rustc_abi/src/layout.rs                       |  6 +++---
 compiler/rustc_abi/src/lib.rs                          |  2 +-
 compiler/rustc_codegen_cranelift/src/abi/comments.rs   |  2 +-
 compiler/rustc_codegen_cranelift/src/abi/pass_mode.rs  |  2 +-
 compiler/rustc_codegen_cranelift/src/base.rs           |  2 +-
 compiler/rustc_codegen_cranelift/src/debuginfo/mod.rs  |  2 +-
 .../rustc_codegen_cranelift/src/debuginfo/types.rs     |  6 ++----
 compiler/rustc_codegen_cranelift/src/unsize.rs         |  6 +++---
 .../rustc_codegen_cranelift/src/value_and_place.rs     |  6 +++---
 compiler/rustc_codegen_gcc/src/context.rs              |  6 +++---
 compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs  |  2 +-
 .../src/debuginfo/metadata/enums/native.rs             |  4 ++--
 compiler/rustc_codegen_llvm/src/intrinsic.rs           |  2 +-
 compiler/rustc_codegen_llvm/src/va_arg.rs              |  4 ++--
 compiler/rustc_codegen_ssa/src/mir/rvalue.rs           |  2 +-
 compiler/rustc_codegen_ssa/src/size_of_val.rs          |  8 ++++----
 compiler/rustc_const_eval/src/interpret/operator.rs    |  2 +-
 compiler/rustc_const_eval/src/util/alignment.rs        |  2 +-
 .../src/util/check_validity_requirement.rs             |  2 +-
 .../rustc_hir_analysis/src/hir_ty_lowering/cmse.rs     |  2 +-
 compiler/rustc_middle/src/ty/vtable.rs                 |  2 +-
 .../rustc_mir_transform/src/dataflow_const_prop.rs     |  2 +-
 compiler/rustc_mir_transform/src/gvn.rs                |  2 +-
 compiler/rustc_mir_transform/src/known_panics_lint.rs  |  2 +-
 compiler/rustc_target/src/callconv/arm.rs              |  2 +-
 compiler/rustc_target/src/callconv/loongarch.rs        |  2 +-
 compiler/rustc_target/src/callconv/nvptx64.rs          |  4 ++--
 compiler/rustc_target/src/callconv/powerpc64.rs        |  2 +-
 compiler/rustc_target/src/callconv/riscv.rs            |  2 +-
 compiler/rustc_target/src/callconv/xtensa.rs           |  2 +-
 compiler/rustc_transmute/src/layout/tree.rs            |  2 +-
 compiler/rustc_ty_utils/src/layout.rs                  | 10 +++++-----
 compiler/rustc_ty_utils/src/layout/invariant.rs        |  6 +++---
 .../clippy_lints/src/casts/cast_ptr_alignment.rs       |  4 ++--
 .../clippy_lints/src/casts/manual_dangling_ptr.rs      |  2 +-
 src/tools/miri/src/machine.rs                          |  2 +-
 .../rust-analyzer/crates/hir-ty/src/layout/tests.rs    |  4 ++--
 src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs  |  6 +++---
 .../rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs   |  4 ++--
 src/tools/rust-analyzer/crates/hir/src/lib.rs          |  2 +-
 40 files changed, 66 insertions(+), 68 deletions(-)

diff --git a/compiler/rustc_abi/src/layout.rs b/compiler/rustc_abi/src/layout.rs
index 5004d0c80220f..d56fbb5cb94f2 100644
--- a/compiler/rustc_abi/src/layout.rs
+++ b/compiler/rustc_abi/src/layout.rs
@@ -1169,7 +1169,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
                 // To allow unsizing `&Foo<Type>` -> `&Foo<dyn Trait>`, the layout of the struct must
                 // not depend on the layout of the tail.
                 let max_field_align =
-                    fields_excluding_tail.iter().map(|f| f.align.abi.bytes()).max().unwrap_or(1);
+                    fields_excluding_tail.iter().map(|f| f.align.bytes()).max().unwrap_or(1);
                 let largest_niche_size = fields_excluding_tail
                     .iter()
                     .filter_map(|f| f.largest_niche)
@@ -1189,7 +1189,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
                     } else {
                         // Returns `log2(effective-align)`. The calculation assumes that size is an
                         // integer multiple of align, except for ZSTs.
-                        let align = layout.align.abi.bytes();
+                        let align = layout.align.bytes();
                         let size = layout.size.bytes();
                         let niche_size = layout.largest_niche.map(|n| n.available(dl)).unwrap_or(0);
                         // Group [u8; 4] with align-4 or [u8; 6] with align-2 fields.
@@ -1488,7 +1488,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
         for i in layout.fields.index_by_increasing_offset() {
             let offset = layout.fields.offset(i);
             let f = &fields[FieldIdx::new(i)];
-            write!(s, "[o{}a{}s{}", offset.bytes(), f.align.abi.bytes(), f.size.bytes()).unwrap();
+            write!(s, "[o{}a{}s{}", offset.bytes(), f.align.bytes(), f.size.bytes()).unwrap();
             if let Some(n) = f.largest_niche {
                 write!(
                     s,
diff --git a/compiler/rustc_abi/src/lib.rs b/compiler/rustc_abi/src/lib.rs
index 369874521e57e..9a364f9be184a 100644
--- a/compiler/rustc_abi/src/lib.rs
+++ b/compiler/rustc_abi/src/lib.rs
@@ -2159,7 +2159,7 @@ impl<FieldIdx: Idx, VariantIdx: Idx> LayoutData<FieldIdx, VariantIdx> {
 
     /// Returns `true` if the type is sized and a 1-ZST (meaning it has size 0 and alignment 1).
     pub fn is_1zst(&self) -> bool {
-        self.is_sized() && self.size.bytes() == 0 && self.align.abi.bytes() == 1
+        self.is_sized() && self.size.bytes() == 0 && self.align.bytes() == 1
     }
 
     /// Returns `true` if the type is a ZST and not unsized.
diff --git a/compiler/rustc_codegen_cranelift/src/abi/comments.rs b/compiler/rustc_codegen_cranelift/src/abi/comments.rs
index c74efeb59f3fc..d1b2b9a502ac2 100644
--- a/compiler/rustc_codegen_cranelift/src/abi/comments.rs
+++ b/compiler/rustc_codegen_cranelift/src/abi/comments.rs
@@ -89,7 +89,7 @@ pub(super) fn add_local_place_comments<'tcx>(
         format!("{:?}", local),
         format!("{:?}", ty),
         size.bytes(),
-        align.abi.bytes(),
+        align.bytes(),
         if extra.is_empty() { "" } else { "                " },
         extra,
     ));
diff --git a/compiler/rustc_codegen_cranelift/src/abi/pass_mode.rs b/compiler/rustc_codegen_cranelift/src/abi/pass_mode.rs
index 2031842062d97..7a909a740b054 100644
--- a/compiler/rustc_codegen_cranelift/src/abi/pass_mode.rs
+++ b/compiler/rustc_codegen_cranelift/src/abi/pass_mode.rs
@@ -233,7 +233,7 @@ pub(super) fn from_casted_value<'tcx>(
         // It may also be smaller for example when the type is a wrapper around an integer with a
         // larger alignment than the integer.
         std::cmp::max(abi_param_size, layout_size),
-        u32::try_from(layout.align.abi.bytes()).unwrap(),
+        u32::try_from(layout.align.bytes()).unwrap(),
     );
     let mut block_params_iter = block_params.iter().copied();
     for (offset, _) in abi_params {
diff --git a/compiler/rustc_codegen_cranelift/src/base.rs b/compiler/rustc_codegen_cranelift/src/base.rs
index 41e11e1de6163..2cc5b82ddd345 100644
--- a/compiler/rustc_codegen_cranelift/src/base.rs
+++ b/compiler/rustc_codegen_cranelift/src/base.rs
@@ -846,7 +846,7 @@ fn codegen_stmt<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, cur_block: Block, stmt:
                     let layout = fx.layout_of(fx.monomorphize(ty));
                     let val = match null_op {
                         NullOp::SizeOf => layout.size.bytes(),
-                        NullOp::AlignOf => layout.align.abi.bytes(),
+                        NullOp::AlignOf => layout.align.bytes(),
                         NullOp::OffsetOf(fields) => fx
                             .tcx
                             .offset_of_subfield(
diff --git a/compiler/rustc_codegen_cranelift/src/debuginfo/mod.rs b/compiler/rustc_codegen_cranelift/src/debuginfo/mod.rs
index 286e02b986b3c..4c438742f3d22 100644
--- a/compiler/rustc_codegen_cranelift/src/debuginfo/mod.rs
+++ b/compiler/rustc_codegen_cranelift/src/debuginfo/mod.rs
@@ -304,7 +304,7 @@ impl DebugContext {
         entry.set(gimli::DW_AT_decl_file, AttributeValue::FileIndex(Some(file_id)));
         entry.set(gimli::DW_AT_decl_line, AttributeValue::Udata(line));
 
-        entry.set(gimli::DW_AT_alignment, AttributeValue::Udata(static_layout.align.abi.bytes()));
+        entry.set(gimli::DW_AT_alignment, AttributeValue::Udata(static_layout.align.bytes()));
 
         let mut expr = Expression::new();
         expr.op_addr(address_for_data(data_id));
diff --git a/compiler/rustc_codegen_cranelift/src/debuginfo/types.rs b/compiler/rustc_codegen_cranelift/src/debuginfo/types.rs
index 25b922c8be4c7..0d49f32373caa 100644
--- a/compiler/rustc_codegen_cranelift/src/debuginfo/types.rs
+++ b/compiler/rustc_codegen_cranelift/src/debuginfo/types.rs
@@ -166,7 +166,7 @@ impl DebugContext {
         let tuple_entry = self.dwarf.unit.get_mut(tuple_type_id);
         tuple_entry.set(gimli::DW_AT_name, AttributeValue::StringRef(self.dwarf.strings.add(name)));
         tuple_entry.set(gimli::DW_AT_byte_size, AttributeValue::Udata(layout.size.bytes()));
-        tuple_entry.set(gimli::DW_AT_alignment, AttributeValue::Udata(layout.align.abi.bytes()));
+        tuple_entry.set(gimli::DW_AT_alignment, AttributeValue::Udata(layout.align.bytes()));
 
         for (i, (ty, dw_ty)) in components.into_iter().enumerate() {
             let member_id = self.dwarf.unit.add(tuple_type_id, gimli::DW_TAG_member);
@@ -178,9 +178,7 @@ impl DebugContext {
             member_entry.set(gimli::DW_AT_type, AttributeValue::UnitRef(dw_ty));
             member_entry.set(
                 gimli::DW_AT_alignment,
-                AttributeValue::Udata(
-                    FullyMonomorphizedLayoutCx(tcx).layout_of(ty).align.abi.bytes(),
-                ),
+                AttributeValue::Udata(FullyMonomorphizedLayoutCx(tcx).layout_of(ty).align.bytes()),
             );
             member_entry.set(
                 gimli::DW_AT_data_member_location,
diff --git a/compiler/rustc_codegen_cranelift/src/unsize.rs b/compiler/rustc_codegen_cranelift/src/unsize.rs
index 643c7feb89a26..d994f3e32ec3c 100644
--- a/compiler/rustc_codegen_cranelift/src/unsize.rs
+++ b/compiler/rustc_codegen_cranelift/src/unsize.rs
@@ -167,7 +167,7 @@ pub(crate) fn size_and_align_of<'tcx>(
     if layout.is_sized() {
         return (
             fx.bcx.ins().iconst(fx.pointer_type, layout.size.bytes() as i64),
-            fx.bcx.ins().iconst(fx.pointer_type, layout.align.abi.bytes() as i64),
+            fx.bcx.ins().iconst(fx.pointer_type, layout.align.bytes() as i64),
         );
     }
 
@@ -186,7 +186,7 @@ pub(crate) fn size_and_align_of<'tcx>(
             // times the unit size.
             (
                 fx.bcx.ins().imul_imm(info.unwrap(), unit.size.bytes() as i64),
-                fx.bcx.ins().iconst(fx.pointer_type, unit.align.abi.bytes() as i64),
+                fx.bcx.ins().iconst(fx.pointer_type, unit.align.bytes() as i64),
             )
         }
         ty::Foreign(_) => {
@@ -224,7 +224,7 @@ pub(crate) fn size_and_align_of<'tcx>(
             let unsized_offset_unadjusted = layout.fields.offset(i).bytes();
             let unsized_offset_unadjusted =
                 fx.bcx.ins().iconst(fx.pointer_type, unsized_offset_unadjusted as i64);
-            let sized_align = layout.align.abi.bytes();
+            let sized_align = layout.align.bytes();
             let sized_align = fx.bcx.ins().iconst(fx.pointer_type, sized_align as i64);
 
             // Recurse to get the size of the dynamically sized field (must be
diff --git a/compiler/rustc_codegen_cranelift/src/value_and_place.rs b/compiler/rustc_codegen_cranelift/src/value_and_place.rs
index 4519fa1a270e4..04e10cf17088c 100644
--- a/compiler/rustc_codegen_cranelift/src/value_and_place.rs
+++ b/compiler/rustc_codegen_cranelift/src/value_and_place.rs
@@ -383,7 +383,7 @@ impl<'tcx> CPlace<'tcx> {
 
         let stack_slot = fx.create_stack_slot(
             u32::try_from(layout.size.bytes()).unwrap(),
-            u32::try_from(layout.align.abi.bytes()).unwrap(),
+            u32::try_from(layout.align.bytes()).unwrap(),
         );
         CPlace { inner: CPlaceInner::Addr(stack_slot, None), layout }
     }
@@ -641,8 +641,8 @@ impl<'tcx> CPlace<'tcx> {
                         let size = dst_layout.size.bytes();
                         // `emit_small_memory_copy` uses `u8` for alignments, just use the maximum
                         // alignment that fits in a `u8` if the actual alignment is larger.
-                        let src_align = src_layout.align.abi.bytes().try_into().unwrap_or(128);
-                        let dst_align = dst_layout.align.abi.bytes().try_into().unwrap_or(128);
+                        let src_align = src_layout.align.bytes().try_into().unwrap_or(128);
+                        let dst_align = dst_layout.align.bytes().try_into().unwrap_or(128);
                         fx.bcx.emit_small_memory_copy(
                             fx.target_config,
                             to_addr,
diff --git a/compiler/rustc_codegen_gcc/src/context.rs b/compiler/rustc_codegen_gcc/src/context.rs
index 9815fb07eaae9..c9ae96777de44 100644
--- a/compiler/rustc_codegen_gcc/src/context.rs
+++ b/compiler/rustc_codegen_gcc/src/context.rs
@@ -147,7 +147,7 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
             let layout = tcx
                 .layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(rust_type))
                 .unwrap();
-            let align = layout.align.abi.bytes();
+            let align = layout.align.bytes();
             // For types with size 1, the alignment can be 1 and only 1
             // So, we can skip the call to ``get_aligned`.
             // In the future, we can add a GCC API to query the type align,
@@ -186,9 +186,9 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
             (i128_type, u128_type)
         } else {
             /*let layout = tcx.layout_of(ParamEnv::reveal_all().and(tcx.types.i128)).unwrap();
-            let i128_align = layout.align.abi.bytes();
+            let i128_align = layout.align.bytes();
             let layout = tcx.layout_of(ParamEnv::reveal_all().and(tcx.types.u128)).unwrap();
-            let u128_align = layout.align.abi.bytes();*/
+            let u128_align = layout.align.bytes();*/
 
             // TODO(antoyo): re-enable the alignment when libgccjit fixed the issue in
             // gcc_jit_context_new_array_constructor (it should not use reinterpret_cast).
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
index 4b74c04ed7ae0..1e4ace4ca922c 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
@@ -1043,7 +1043,7 @@ fn create_member_type<'ll, 'tcx>(
             file_metadata,
             line_number,
             layout.size.bits(),
-            layout.align.abi.bits() as u32,
+            layout.align.bits() as u32,
             offset.bits(),
             flags,
             type_di_node,
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 62d38d463aba7..1ae6e6e5eecab 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/native.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/native.rs
@@ -289,7 +289,7 @@ fn build_enum_variant_part_di_node<'ll, 'tcx>(
                 file_metadata,
                 line_number,
                 enum_type_and_layout.size.bits(),
-                enum_type_and_layout.align.abi.bits() as u32,
+                enum_type_and_layout.align.bits() as u32,
                 DIFlags::FlagZero,
                 tag_member_di_node,
                 create_DIArray(DIB(cx), &[]),
@@ -449,7 +449,7 @@ fn build_enum_variant_member_di_node<'ll, 'tcx>(
             file_di_node,
             line_number,
             enum_type_and_layout.size.bits(),
-            enum_type_and_layout.align.abi.bits() as u32,
+            enum_type_and_layout.align.bits() as u32,
             Size::ZERO.bits(),
             discr,
             DIFlags::FlagZero,
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
index 013108d1286e1..ba80352916b08 100644
--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -297,7 +297,7 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                 let align = if name == sym::unaligned_volatile_load {
                     1
                 } else {
-                    result.layout.align.abi.bytes() as u32
+                    result.layout.align.bytes() as u32
                 };
                 unsafe {
                     llvm::LLVMSetAlignment(load, align);
diff --git a/compiler/rustc_codegen_llvm/src/va_arg.rs b/compiler/rustc_codegen_llvm/src/va_arg.rs
index d48c7cf874a0a..b2c60db9c679a 100644
--- a/compiler/rustc_codegen_llvm/src/va_arg.rs
+++ b/compiler/rustc_codegen_llvm/src/va_arg.rs
@@ -193,7 +193,7 @@ fn emit_aapcs_va_arg<'ll, 'tcx>(
     // the offset again.
 
     bx.switch_to_block(maybe_reg);
-    if gr_type && layout.align.abi.bytes() > 8 {
+    if gr_type && layout.align.bytes() > 8 {
         reg_off_v = bx.add(reg_off_v, bx.const_i32(15));
         reg_off_v = bx.and(reg_off_v, bx.const_i32(-16));
     }
@@ -761,7 +761,7 @@ fn x86_64_sysv64_va_arg_from_memory<'ll, 'tcx>(
     // byte boundary if alignment needed by type exceeds 8 byte boundary.
     // It isn't stated explicitly in the standard, but in practice we use
     // alignment greater than 16 where necessary.
-    if layout.layout.align.abi.bytes() > 8 {
+    if layout.layout.align.bytes() > 8 {
         unreachable!("all instances of VaArgSafe have an alignment <= 8");
     }
 
diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
index 2602bf82095c5..0a4b0f8d49498 100644
--- a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -617,7 +617,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                     }
                     mir::NullOp::AlignOf => {
                         assert!(bx.cx().type_is_sized(ty));
-                        let val = layout.align.abi.bytes();
+                        let val = layout.align.bytes();
                         bx.cx().const_usize(val)
                     }
                     mir::NullOp::OffsetOf(fields) => {
diff --git a/compiler/rustc_codegen_ssa/src/size_of_val.rs b/compiler/rustc_codegen_ssa/src/size_of_val.rs
index 577012151e49f..e1bd8014d7a2f 100644
--- a/compiler/rustc_codegen_ssa/src/size_of_val.rs
+++ b/compiler/rustc_codegen_ssa/src/size_of_val.rs
@@ -21,7 +21,7 @@ pub fn size_and_align_of_dst<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
     trace!("size_and_align_of_dst(ty={}, info={:?}): layout: {:?}", t, info, layout);
     if layout.is_sized() {
         let size = bx.const_usize(layout.size.bytes());
-        let align = bx.const_usize(layout.align.abi.bytes());
+        let align = bx.const_usize(layout.align.bytes());
         return (size, align);
     }
     match t.kind() {
@@ -49,7 +49,7 @@ pub fn size_and_align_of_dst<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
                 // All slice sizes must fit into `isize`, so this multiplication cannot
                 // wrap -- neither signed nor unsigned.
                 bx.unchecked_sumul(info.unwrap(), bx.const_usize(unit.size.bytes())),
-                bx.const_usize(unit.align.abi.bytes()),
+                bx.const_usize(unit.align.bytes()),
             )
         }
         ty::Foreign(_) => {
@@ -82,7 +82,7 @@ pub fn size_and_align_of_dst<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
 
             // This function does not return so we can now return whatever we want.
             let size = bx.const_usize(layout.size.bytes());
-            let align = bx.const_usize(layout.align.abi.bytes());
+            let align = bx.const_usize(layout.align.bytes());
             (size, align)
         }
         ty::Adt(..) | ty::Tuple(..) => {
@@ -94,7 +94,7 @@ pub fn size_and_align_of_dst<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
 
             let i = layout.fields.count() - 1;
             let unsized_offset_unadjusted = layout.fields.offset(i).bytes();
-            let sized_align = layout.align.abi.bytes();
+            let sized_align = layout.align.bytes();
             debug!(
                 "DST {} offset of dyn field: {}, statically sized align: {}",
                 t, unsized_offset_unadjusted, sized_align
diff --git a/compiler/rustc_const_eval/src/interpret/operator.rs b/compiler/rustc_const_eval/src/interpret/operator.rs
index 74f8a0a7b093c..f0819423aa0fa 100644
--- a/compiler/rustc_const_eval/src/interpret/operator.rs
+++ b/compiler/rustc_const_eval/src/interpret/operator.rs
@@ -528,7 +528,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 if !layout.is_sized() {
                     span_bug!(self.cur_span(), "unsized type for `NullaryOp::AlignOf`");
                 }
-                let val = layout.align.abi.bytes();
+                let val = layout.align.bytes();
                 ImmTy::from_uint(val, usize_layout())
             }
             OffsetOf(fields) => {
diff --git a/compiler/rustc_const_eval/src/util/alignment.rs b/compiler/rustc_const_eval/src/util/alignment.rs
index 9507b24f603eb..9aafc7efd8a6a 100644
--- a/compiler/rustc_const_eval/src/util/alignment.rs
+++ b/compiler/rustc_const_eval/src/util/alignment.rs
@@ -37,7 +37,7 @@ where
             debug!(
                 "is_disaligned({:?}) - align = {}, packed = {}; not disaligned",
                 place,
-                layout.align.abi.bytes(),
+                layout.align.bytes(),
                 pack.bytes()
             );
             false
diff --git a/compiler/rustc_const_eval/src/util/check_validity_requirement.rs b/compiler/rustc_const_eval/src/util/check_validity_requirement.rs
index b1f2959875051..1dea7e4252d7f 100644
--- a/compiler/rustc_const_eval/src/util/check_validity_requirement.rs
+++ b/compiler/rustc_const_eval/src/util/check_validity_requirement.rs
@@ -129,7 +129,7 @@ fn check_validity_requirement_lax<'tcx>(
     if let Some(pointee) = this.ty.builtin_deref(false) {
         let pointee = cx.layout_of(pointee)?;
         // We need to ensure that the LLVM attributes `aligned` and `dereferenceable(size)` are satisfied.
-        if pointee.align.abi.bytes() > 1 {
+        if pointee.align.bytes() > 1 {
             // 0x01-filling is not aligned.
             return Ok(false);
         }
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 81deb35920afb..0458fa1204e81 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
@@ -138,7 +138,7 @@ fn is_valid_cmse_inputs<'tcx>(
     for (index, ty) in fn_sig.inputs().iter().enumerate() {
         let layout = tcx.layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(*ty))?;
 
-        let align = layout.layout.align().abi.bytes();
+        let align = layout.layout.align().bytes();
         let size = layout.layout.size().bytes();
 
         accum += size;
diff --git a/compiler/rustc_middle/src/ty/vtable.rs b/compiler/rustc_middle/src/ty/vtable.rs
index e2f09fdcb4b43..a3e9054fdcb8b 100644
--- a/compiler/rustc_middle/src/ty/vtable.rs
+++ b/compiler/rustc_middle/src/ty/vtable.rs
@@ -104,7 +104,7 @@ pub(super) fn vtable_allocation_provider<'tcx>(
         .expect("failed to build vtable representation");
     assert!(layout.is_sized(), "can't create a vtable for an unsized type");
     let size = layout.size.bytes();
-    let align = layout.align.abi.bytes();
+    let align = layout.align.bytes();
 
     let ptr_size = tcx.data_layout.pointer_size();
     let ptr_align = tcx.data_layout.pointer_align().abi;
diff --git a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
index 5c984984d3cc3..491e910ff6f84 100644
--- a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
+++ b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
@@ -476,7 +476,7 @@ impl<'a, 'tcx> ConstAnalysis<'a, 'tcx> {
                 };
                 let val = match null_op {
                     NullOp::SizeOf if layout.is_sized() => layout.size.bytes(),
-                    NullOp::AlignOf if layout.is_sized() => layout.align.abi.bytes(),
+                    NullOp::AlignOf if layout.is_sized() => layout.align.bytes(),
                     NullOp::OffsetOf(fields) => self
                         .ecx
                         .tcx
diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index ebec3d125003d..29f6879aacd0f 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -618,7 +618,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                 }
                 let val = match null_op {
                     NullOp::SizeOf => arg_layout.size.bytes(),
-                    NullOp::AlignOf => arg_layout.align.abi.bytes(),
+                    NullOp::AlignOf => arg_layout.align.bytes(),
                     NullOp::OffsetOf(fields) => self
                         .ecx
                         .tcx
diff --git a/compiler/rustc_mir_transform/src/known_panics_lint.rs b/compiler/rustc_mir_transform/src/known_panics_lint.rs
index aaacc5866a2ae..5fffba55f17b6 100644
--- a/compiler/rustc_mir_transform/src/known_panics_lint.rs
+++ b/compiler/rustc_mir_transform/src/known_panics_lint.rs
@@ -609,7 +609,7 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
                 let op_layout = self.ecx.layout_of(ty).ok()?;
                 let val = match null_op {
                     NullOp::SizeOf => op_layout.size.bytes(),
-                    NullOp::AlignOf => op_layout.align.abi.bytes(),
+                    NullOp::AlignOf => op_layout.align.bytes(),
                     NullOp::OffsetOf(fields) => self
                         .tcx
                         .offset_of_subfield(self.typing_env, op_layout, fields.iter())
diff --git a/compiler/rustc_target/src/callconv/arm.rs b/compiler/rustc_target/src/callconv/arm.rs
index 70830fa07b6ea..abc9a404e2ea4 100644
--- a/compiler/rustc_target/src/callconv/arm.rs
+++ b/compiler/rustc_target/src/callconv/arm.rs
@@ -77,7 +77,7 @@ where
         }
     }
 
-    let align = arg.layout.align.abi.bytes();
+    let align = arg.layout.align.bytes();
     let total = arg.layout.size;
     arg.cast_to(Uniform::consecutive(if align <= 4 { Reg::i32() } else { Reg::i64() }, total));
 }
diff --git a/compiler/rustc_target/src/callconv/loongarch.rs b/compiler/rustc_target/src/callconv/loongarch.rs
index 9213d73e24eac..bc3c9601fa3d3 100644
--- a/compiler/rustc_target/src/callconv/loongarch.rs
+++ b/compiler/rustc_target/src/callconv/loongarch.rs
@@ -322,7 +322,7 @@ fn classify_arg<'a, Ty, C>(
     }
 
     let total = arg.layout.size;
-    let align = arg.layout.align.abi.bits();
+    let align = arg.layout.align.bits();
 
     // "Scalars wider than 2✕XLEN are passed by reference and are replaced in
     // the argument list with the address."
diff --git a/compiler/rustc_target/src/callconv/nvptx64.rs b/compiler/rustc_target/src/callconv/nvptx64.rs
index 44977de7fcbc2..dc32dd87a7e76 100644
--- a/compiler/rustc_target/src/callconv/nvptx64.rs
+++ b/compiler/rustc_target/src/callconv/nvptx64.rs
@@ -21,7 +21,7 @@ fn classify_arg<Ty>(arg: &mut ArgAbi<'_, Ty>) {
 
 /// the pass mode used for aggregates in arg and ret position
 fn classify_aggregate<Ty>(arg: &mut ArgAbi<'_, Ty>) {
-    let align_bytes = arg.layout.align.abi.bytes();
+    let align_bytes = arg.layout.align.bytes();
     let size = arg.layout.size;
 
     let reg = match align_bytes {
@@ -60,7 +60,7 @@ where
     //     "`extern \"ptx-kernel\"` doesn't allow passing types other than primitives and structs"
     // );
 
-    let align_bytes = arg.layout.align.abi.bytes();
+    let align_bytes = arg.layout.align.bytes();
 
     let unit = match align_bytes {
         1 => Reg::i8(),
diff --git a/compiler/rustc_target/src/callconv/powerpc64.rs b/compiler/rustc_target/src/callconv/powerpc64.rs
index 89ec85e4b6664..be1d13816eff7 100644
--- a/compiler/rustc_target/src/callconv/powerpc64.rs
+++ b/compiler/rustc_target/src/callconv/powerpc64.rs
@@ -89,7 +89,7 @@ where
         // Aggregates larger than i64 should be padded at the tail to fill out a whole number
         // of i64s or i128s, depending on the aggregate alignment. Always use an array for
         // this, even if there is only a single element.
-        let reg = if arg.layout.align.abi.bytes() > 8 { Reg::i128() } else { Reg::i64() };
+        let reg = if arg.layout.align.bytes() > 8 { Reg::i128() } else { Reg::i64() };
         arg.cast_to(Uniform::consecutive(
             reg,
             size.align_to(Align::from_bytes(reg.size.bytes()).unwrap()),
diff --git a/compiler/rustc_target/src/callconv/riscv.rs b/compiler/rustc_target/src/callconv/riscv.rs
index 161e2c1645f9a..16de3fe070dd4 100644
--- a/compiler/rustc_target/src/callconv/riscv.rs
+++ b/compiler/rustc_target/src/callconv/riscv.rs
@@ -328,7 +328,7 @@ fn classify_arg<'a, Ty, C>(
     }
 
     let total = arg.layout.size;
-    let align = arg.layout.align.abi.bits();
+    let align = arg.layout.align.bits();
 
     // "Scalars wider than 2✕XLEN are passed by reference and are replaced in
     // the argument list with the address."
diff --git a/compiler/rustc_target/src/callconv/xtensa.rs b/compiler/rustc_target/src/callconv/xtensa.rs
index a73a70a1a0c07..561ee98787dee 100644
--- a/compiler/rustc_target/src/callconv/xtensa.rs
+++ b/compiler/rustc_target/src/callconv/xtensa.rs
@@ -48,7 +48,7 @@ where
     }
 
     let size = arg.layout.size.bits();
-    let needed_align = arg.layout.align.abi.bits();
+    let needed_align = arg.layout.align.bits();
     let mut must_use_stack = false;
 
     // Determine the number of GPRs needed to pass the current argument
diff --git a/compiler/rustc_transmute/src/layout/tree.rs b/compiler/rustc_transmute/src/layout/tree.rs
index a02e8ecf613f4..7f626e8c4e886 100644
--- a/compiler/rustc_transmute/src/layout/tree.rs
+++ b/compiler/rustc_transmute/src/layout/tree.rs
@@ -361,7 +361,7 @@ pub(crate) mod rustc {
 
                 ty::Ref(region, ty, mutability) => {
                     let layout = layout_of(cx, *ty)?;
-                    let referent_align = layout.align.abi.bytes_usize();
+                    let referent_align = layout.align.bytes_usize();
                     let referent_size = layout.size.bytes_usize();
 
                     Ok(Tree::Ref(Reference {
diff --git a/compiler/rustc_ty_utils/src/layout.rs b/compiler/rustc_ty_utils/src/layout.rs
index f59bc2117d537..317d101dafe05 100644
--- a/compiler/rustc_ty_utils/src/layout.rs
+++ b/compiler/rustc_ty_utils/src/layout.rs
@@ -795,7 +795,7 @@ fn variant_info_for_adt<'tcx>(
                     name,
                     offset: offset.bytes(),
                     size: field_layout.size.bytes(),
-                    align: field_layout.align.abi.bytes(),
+                    align: field_layout.align.bytes(),
                     type_name: None,
                 }
             })
@@ -804,7 +804,7 @@ fn variant_info_for_adt<'tcx>(
         VariantInfo {
             name: n,
             kind: if layout.is_unsized() { SizeKind::Min } else { SizeKind::Exact },
-            align: layout.align.abi.bytes(),
+            align: layout.align.bytes(),
             size: if min_size.bytes() == 0 { layout.size.bytes() } else { min_size.bytes() },
             fields: field_info,
         }
@@ -877,7 +877,7 @@ fn variant_info_for_coroutine<'tcx>(
                 name: *name,
                 offset: offset.bytes(),
                 size: field_layout.size.bytes(),
-                align: field_layout.align.abi.bytes(),
+                align: field_layout.align.bytes(),
                 type_name: None,
             }
         })
@@ -905,7 +905,7 @@ fn variant_info_for_coroutine<'tcx>(
                         }),
                         offset: offset.bytes(),
                         size: field_layout.size.bytes(),
-                        align: field_layout.align.abi.bytes(),
+                        align: field_layout.align.bytes(),
                         // Include the type name if there is no field name, or if the name is the
                         // __awaitee placeholder symbol which means a child future being `.await`ed.
                         type_name: (field_name.is_none() || field_name == Some(sym::__awaitee))
@@ -946,7 +946,7 @@ fn variant_info_for_coroutine<'tcx>(
                 name: Some(Symbol::intern(&ty::CoroutineArgs::variant_name(variant_idx))),
                 kind: SizeKind::Exact,
                 size: variant_size.bytes(),
-                align: variant_layout.align.abi.bytes(),
+                align: variant_layout.align.bytes(),
                 fields,
             }
         })
diff --git a/compiler/rustc_ty_utils/src/layout/invariant.rs b/compiler/rustc_ty_utils/src/layout/invariant.rs
index 1311ee31182c6..b768269215fa2 100644
--- a/compiler/rustc_ty_utils/src/layout/invariant.rs
+++ b/compiler/rustc_ty_utils/src/layout/invariant.rs
@@ -8,7 +8,7 @@ use rustc_middle::ty::layout::{HasTyCtxt, LayoutCx, TyAndLayout};
 pub(super) fn layout_sanity_check<'tcx>(cx: &LayoutCx<'tcx>, layout: &TyAndLayout<'tcx>) {
     let tcx = cx.tcx();
 
-    if !layout.size.bytes().is_multiple_of(layout.align.abi.bytes()) {
+    if !layout.size.bytes().is_multiple_of(layout.align.bytes()) {
         bug!("size is not a multiple of align, in the following layout:\n{layout:#?}");
     }
     if layout.size.bytes() >= tcx.data_layout.obj_size_bound() {
@@ -300,8 +300,8 @@ pub(super) fn layout_sanity_check<'tcx>(cx: &LayoutCx<'tcx>, layout: &TyAndLayou
                 if variant.align.abi > layout.align.abi {
                     bug!(
                         "Type with alignment {} bytes has variant with alignment {} bytes: {layout:#?}",
-                        layout.align.abi.bytes(),
-                        variant.align.abi.bytes(),
+                        layout.align.bytes(),
+                        variant.align.bytes(),
                     )
                 }
                 // Skip empty variants.
diff --git a/src/tools/clippy/clippy_lints/src/casts/cast_ptr_alignment.rs b/src/tools/clippy/clippy_lints/src/casts/cast_ptr_alignment.rs
index d78da9396faf3..7d14ba7fcf132 100644
--- a/src/tools/clippy/clippy_lints/src/casts/cast_ptr_alignment.rs
+++ b/src/tools/clippy/clippy_lints/src/casts/cast_ptr_alignment.rs
@@ -43,8 +43,8 @@ fn lint_cast_ptr_alignment<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, cast_f
             expr.span,
             format!(
                 "casting from `{cast_from}` to a more-strictly-aligned pointer (`{cast_to}`) ({} < {} bytes)",
-                from_layout.align.abi.bytes(),
-                to_layout.align.abi.bytes(),
+                from_layout.align.bytes(),
+                to_layout.align.bytes(),
             ),
         );
     }
diff --git a/src/tools/clippy/clippy_lints/src/casts/manual_dangling_ptr.rs b/src/tools/clippy/clippy_lints/src/casts/manual_dangling_ptr.rs
index 92910cf8adf5d..ff5320719aa28 100644
--- a/src/tools/clippy/clippy_lints/src/casts/manual_dangling_ptr.rs
+++ b/src/tools/clippy/clippy_lints/src/casts/manual_dangling_ptr.rs
@@ -72,7 +72,7 @@ fn is_literal_aligned(cx: &LateContext<'_>, lit: &Spanned<LitKind>, to: &Ty<'_>)
     cx.tcx
         .layout_of(cx.typing_env().as_query_input(to_mid_ty))
         .is_ok_and(|layout| {
-            let align = u128::from(layout.align.abi.bytes());
+            let align = u128::from(layout.align.bytes());
             u128::from(val) <= align
         })
 }
diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index d307636e782fc..412640a112c09 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -1341,7 +1341,7 @@ impl<'tcx> Machine<'tcx> for MiriMachine<'tcx> {
                     name = ecx.tcx.def_path_str(def_id),
                     krate = ecx.tcx.crate_name(def_id.krate),
                     decl_size = extern_decl_layout.size.bytes(),
-                    decl_align = extern_decl_layout.align.abi.bytes(),
+                    decl_align = extern_decl_layout.align.bytes(),
                     shim_size = info.size.bytes(),
                     shim_align = info.align.bytes(),
                 )
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs
index 523ddad94666b..8be5eaca63b80 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout/tests.rs
@@ -150,7 +150,7 @@ fn check_size_and_align(
 ) {
     let l = eval_goal(ra_fixture, minicore).unwrap();
     assert_eq!(l.size.bytes(), size, "size mismatch");
-    assert_eq!(l.align.abi.bytes(), align, "align mismatch");
+    assert_eq!(l.align.bytes(), align, "align mismatch");
 }
 
 #[track_caller]
@@ -162,7 +162,7 @@ fn check_size_and_align_expr(
 ) {
     let l = eval_expr(ra_fixture, minicore).unwrap();
     assert_eq!(l.size.bytes(), size, "size mismatch");
-    assert_eq!(l.align.abi.bytes(), align, "align mismatch");
+    assert_eq!(l.align.bytes(), align, "align mismatch");
 }
 
 #[track_caller]
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
index 3e658cb93ed8a..fc7d97fff4659 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval.rs
@@ -2085,7 +2085,7 @@ impl<'db> Evaluator<'db> {
         if let Some(layout) = self.layout_cache.borrow().get(&ty.to_nextsolver(interner)) {
             return Ok(layout
                 .is_sized()
-                .then(|| (layout.size.bytes_usize(), layout.align.abi.bytes() as usize)));
+                .then(|| (layout.size.bytes_usize(), layout.align.bytes() as usize)));
         }
         if let DefWithBodyId::VariantId(f) = locals.body.owner
             && let Some((AdtId::EnumId(e), _)) = ty.as_adt()
@@ -2104,7 +2104,7 @@ impl<'db> Evaluator<'db> {
         let layout = layout?;
         Ok(layout
             .is_sized()
-            .then(|| (layout.size.bytes_usize(), layout.align.abi.bytes() as usize)))
+            .then(|| (layout.size.bytes_usize(), layout.align.bytes() as usize)))
     }
 
     /// A version of `self.size_of` which returns error if the type is unsized. `what` argument should
@@ -2797,7 +2797,7 @@ impl<'db> Evaluator<'db> {
                     )?;
                     // FIXME: there is some leak here
                     let size = layout.size.bytes_usize();
-                    let addr = self.heap_allocate(size, layout.align.abi.bytes() as usize)?;
+                    let addr = self.heap_allocate(size, layout.align.bytes() as usize)?;
                     self.write_memory(addr, &result)?;
                     IntervalAndTy { interval: Interval { addr, size }, ty }
                 };
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs
index f67778b0f12f3..38480493048ec 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir/eval/shim.rs
@@ -767,7 +767,7 @@ impl Evaluator<'_> {
                         "align_of generic arg is not provided".into(),
                     ));
                 };
-                let align = self.layout(ty.to_nextsolver(interner))?.align.abi.bytes();
+                let align = self.layout(ty.to_nextsolver(interner))?.align.bytes();
                 destination.write_from_bytes(self, &align.to_le_bytes()[0..destination.size])
             }
             "size_of_val" => {
@@ -1431,7 +1431,7 @@ impl Evaluator<'_> {
                     field_types.iter().next_back().unwrap().1.clone().substitute(Interner, subst);
                 let sized_part_size =
                     layout.fields.offset(field_types.iter().count() - 1).bytes_usize();
-                let sized_part_align = layout.align.abi.bytes() as usize;
+                let sized_part_align = layout.align.bytes() as usize;
                 let (unsized_part_size, unsized_part_align) =
                     self.size_align_of_unsized(&last_field_ty, metadata, locals)?;
                 let align = sized_part_align.max(unsized_part_align) as isize;
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index 027a386abe8ce..17767955d474f 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -6094,7 +6094,7 @@ impl Layout {
     }
 
     pub fn align(&self) -> u64 {
-        self.0.align.abi.bytes()
+        self.0.align.bytes()
     }
 
     pub fn niches(&self) -> Option<u128> {

From 30f284d15befc66143fee59918ffac209a0ae657 Mon Sep 17 00:00:00 2001
From: Jubilee Young <workingjubilee@gmail.com>
Date: Sun, 28 Sep 2025 14:40:39 -0700
Subject: [PATCH 1537/1889] remove explicit deref of AbiAlign for most methods

Much of the compiler calls functions on Align projected from AbiAlign.
AbiAlign impls Deref to its inner Align, so we can simplify these away.
Also, it will minimize disruption when AbiAlign is removed.

For now, preserve usages that might resolve to PartialOrd or PartialEq,
as those have odd inference.
---
 clippy_lints/src/casts/cast_ptr_alignment.rs  | 4 ++--
 clippy_lints/src/casts/manual_dangling_ptr.rs | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/clippy_lints/src/casts/cast_ptr_alignment.rs b/clippy_lints/src/casts/cast_ptr_alignment.rs
index d78da9396faf3..7d14ba7fcf132 100644
--- a/clippy_lints/src/casts/cast_ptr_alignment.rs
+++ b/clippy_lints/src/casts/cast_ptr_alignment.rs
@@ -43,8 +43,8 @@ fn lint_cast_ptr_alignment<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, cast_f
             expr.span,
             format!(
                 "casting from `{cast_from}` to a more-strictly-aligned pointer (`{cast_to}`) ({} < {} bytes)",
-                from_layout.align.abi.bytes(),
-                to_layout.align.abi.bytes(),
+                from_layout.align.bytes(),
+                to_layout.align.bytes(),
             ),
         );
     }
diff --git a/clippy_lints/src/casts/manual_dangling_ptr.rs b/clippy_lints/src/casts/manual_dangling_ptr.rs
index 92910cf8adf5d..ff5320719aa28 100644
--- a/clippy_lints/src/casts/manual_dangling_ptr.rs
+++ b/clippy_lints/src/casts/manual_dangling_ptr.rs
@@ -72,7 +72,7 @@ fn is_literal_aligned(cx: &LateContext<'_>, lit: &Spanned<LitKind>, to: &Ty<'_>)
     cx.tcx
         .layout_of(cx.typing_env().as_query_input(to_mid_ty))
         .is_ok_and(|layout| {
-            let align = u128::from(layout.align.abi.bytes());
+            let align = u128::from(layout.align.bytes());
             u128::from(val) <= align
         })
 }

From b71c4690409e8ce98a502216623a9264efaaa3e4 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sun, 28 Sep 2025 18:44:19 +1000
Subject: [PATCH 1538/1889] Fix some crash-test directives

---
 tests/crashes/125772.rs | 2 +-
 tests/crashes/131292.rs | 2 +-
 tests/crashes/34127.rs  | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/crashes/125772.rs b/tests/crashes/125772.rs
index 2965cfc9e7c3c..2b6cffd9463a9 100644
--- a/tests/crashes/125772.rs
+++ b/tests/crashes/125772.rs
@@ -1,5 +1,5 @@
 //@ known-bug: rust-lang/rust#125772
-//@ only-x86_64
+//@ only-64bit
 #![feature(generic_const_exprs)]
 
 struct Outer<const A: i64, const B: i64>();
diff --git a/tests/crashes/131292.rs b/tests/crashes/131292.rs
index 01e0eca0bd6d6..05b93d06b0553 100644
--- a/tests/crashes/131292.rs
+++ b/tests/crashes/131292.rs
@@ -1,5 +1,5 @@
 //@ known-bug: #131292
-//@ only-x86_64
+//@ needs-asm-support
 use std::arch::asm;
 
 unsafe fn f6() {
diff --git a/tests/crashes/34127.rs b/tests/crashes/34127.rs
index ea36b48ecba07..26ebe722475f3 100644
--- a/tests/crashes/34127.rs
+++ b/tests/crashes/34127.rs
@@ -1,6 +1,6 @@
 //@ compile-flags: -g -Copt-level=0 -Z verify-llvm-ir
 //@ known-bug: #34127
-//@ only-x86_64
+//@ only-64bit
 
 pub fn main() {
 let _a = [(); 1 << 63];

From eceb48534a4fdabfaf378ea02a2c5cd43b8c52a5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Mon, 29 Sep 2025 03:28:52 +0000
Subject: [PATCH 1539/1889] Make replacement suggestion `_` in type verbose

```
error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
  --> $DIR/in-signature.rs:6:21
   |
LL | fn arr_fn() -> [u8; _] {
   |                     ^ not allowed in type signatures
   |
help: replace with the correct return type
   |
LL - fn arr_fn() -> [u8; _] {
LL + fn arr_fn() -> [u8; 3] {
   |
```
---
 compiler/rustc_hir_analysis/src/collect.rs    |   4 +-
 .../generic_arg_infer/in-signature.stderr     |  36 +++--
 tests/ui/error-codes/E0121.stderr             |  11 +-
 tests/ui/fn/issue-80179.stderr                |  21 ++-
 tests/ui/fn/suggest-return-closure.stderr     |  30 ++--
 tests/ui/fn/suggest-return-future.stderr      |  22 ++-
 ...r-return-ty-for-fn-sig-issue-125488.stderr |  44 ++++--
 tests/ui/suggestions/return-cycle-2.stderr    |  11 +-
 tests/ui/suggestions/return-cycle.stderr      |  11 +-
 ...uggest-fn-ptr-for-fn-item-in-fn-ret.stderr |  11 +-
 .../type-alias-impl-trait/issue-77179.stderr  |  11 +-
 tests/ui/typeck/issue-80779.stderr            |  22 ++-
 tests/ui/typeck/issue-98260.stderr            |  11 +-
 .../typeck_type_placeholder_item.stderr       | 141 +++++++++++-------
 .../typeck_type_placeholder_item_help.stderr  |  11 +-
 tests/ui/variance/leaking-unnameables.stderr  |  11 +-
 16 files changed, 258 insertions(+), 150 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
index b72e743f95b0f..02baaec37138c 100644
--- a/compiler/rustc_hir_analysis/src/collect.rs
+++ b/compiler/rustc_hir_analysis/src/collect.rs
@@ -1140,7 +1140,7 @@ fn recover_infer_ret_ty<'tcx>(
     // recursive function definition to leak out into the fn sig.
     let mut recovered_ret_ty = None;
     if let Some(suggestable_ret_ty) = ret_ty.make_suggestable(tcx, false, None) {
-        diag.span_suggestion(
+        diag.span_suggestion_verbose(
             infer_ret_ty.span,
             "replace with the correct return type",
             suggestable_ret_ty,
@@ -1152,7 +1152,7 @@ fn recover_infer_ret_ty<'tcx>(
         tcx.param_env(def_id),
         ret_ty,
     ) {
-        diag.span_suggestion(
+        diag.span_suggestion_verbose(
             infer_ret_ty.span,
             "replace with an appropriate return type",
             sugg,
diff --git a/tests/ui/const-generics/generic_arg_infer/in-signature.stderr b/tests/ui/const-generics/generic_arg_infer/in-signature.stderr
index b6f2662a93932..d7a7ab52c83de 100644
--- a/tests/ui/const-generics/generic_arg_infer/in-signature.stderr
+++ b/tests/ui/const-generics/generic_arg_infer/in-signature.stderr
@@ -2,29 +2,39 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/in-signature.rs:6:21
    |
 LL | fn arr_fn() -> [u8; _] {
-   |                -----^-
-   |                |    |
-   |                |    not allowed in type signatures
-   |                help: replace with the correct return type: `[u8; 3]`
+   |                     ^ not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL - fn arr_fn() -> [u8; _] {
+LL + fn arr_fn() -> [u8; 3] {
+   |
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
   --> $DIR/in-signature.rs:11:24
    |
 LL | fn ty_fn() -> Bar<i32, _> {
-   |               ---------^-
-   |               |        |
-   |               |        not allowed in type signatures
-   |               help: replace with the correct return type: `Bar<i32, 3>`
+   |                        ^ not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL - fn ty_fn() -> Bar<i32, _> {
+LL + fn ty_fn() -> Bar<i32, 3> {
+   |
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
   --> $DIR/in-signature.rs:16:25
    |
 LL | fn ty_fn_mixed() -> Bar<_, _> {
-   |                     ----^--^-
-   |                     |   |  |
-   |                     |   |  not allowed in type signatures
-   |                     |   not allowed in type signatures
-   |                     help: replace with the correct return type: `Bar<i32, 3>`
+   |                         ^  ^ not allowed in type signatures
+   |                         |
+   |                         not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL - fn ty_fn_mixed() -> Bar<_, _> {
+LL + fn ty_fn_mixed() -> Bar<i32, 3> {
+   |
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for constants
   --> $DIR/in-signature.rs:21:20
diff --git a/tests/ui/error-codes/E0121.stderr b/tests/ui/error-codes/E0121.stderr
index b169373f64399..074929c4e74f9 100644
--- a/tests/ui/error-codes/E0121.stderr
+++ b/tests/ui/error-codes/E0121.stderr
@@ -2,10 +2,13 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/E0121.rs:1:13
    |
 LL | fn foo() -> _ { 5 }
-   |             ^
-   |             |
-   |             not allowed in type signatures
-   |             help: replace with the correct return type: `i32`
+   |             ^ not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL - fn foo() -> _ { 5 }
+LL + fn foo() -> i32 { 5 }
+   |
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for static variables
   --> $DIR/E0121.rs:3:13
diff --git a/tests/ui/fn/issue-80179.stderr b/tests/ui/fn/issue-80179.stderr
index f5d6c44db7511..95158da3cff6c 100644
--- a/tests/ui/fn/issue-80179.stderr
+++ b/tests/ui/fn/issue-80179.stderr
@@ -2,21 +2,26 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/issue-80179.rs:10:24
    |
 LL | fn returns_fn_ptr() -> _ {
-   |                        ^
-   |                        |
-   |                        not allowed in type signatures
-   |                        help: replace with the correct return type: `fn() -> i32`
+   |                        ^ not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL - fn returns_fn_ptr() -> _ {
+LL + fn returns_fn_ptr() -> fn() -> i32 {
+   |
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
   --> $DIR/issue-80179.rs:18:25
    |
 LL | fn returns_closure() -> _ {
-   |                         ^
-   |                         |
-   |                         not allowed in type signatures
-   |                         help: replace with an appropriate return type: `impl Fn() -> i32`
+   |                         ^ not allowed in type signatures
    |
    = note: for more information on `Fn` traits and closure types, see https://doc.rust-lang.org/book/ch13-01-closures.html
+help: replace with an appropriate return type
+   |
+LL - fn returns_closure() -> _ {
+LL + fn returns_closure() -> impl Fn() -> i32 {
+   |
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/fn/suggest-return-closure.stderr b/tests/ui/fn/suggest-return-closure.stderr
index 1860d1ca5d927..0639c23c75ade 100644
--- a/tests/ui/fn/suggest-return-closure.stderr
+++ b/tests/ui/fn/suggest-return-closure.stderr
@@ -2,34 +2,40 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/suggest-return-closure.rs:1:17
    |
 LL | fn fn_once() -> _ {
-   |                 ^
-   |                 |
-   |                 not allowed in type signatures
-   |                 help: replace with an appropriate return type: `impl FnOnce()`
+   |                 ^ not allowed in type signatures
    |
    = note: for more information on `Fn` traits and closure types, see https://doc.rust-lang.org/book/ch13-01-closures.html
+help: replace with an appropriate return type
+   |
+LL - fn fn_once() -> _ {
+LL + fn fn_once() -> impl FnOnce() {
+   |
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
   --> $DIR/suggest-return-closure.rs:13:16
    |
 LL | fn fn_mut() -> _ {
-   |                ^
-   |                |
-   |                not allowed in type signatures
-   |                help: replace with an appropriate return type: `impl FnMut(char)`
+   |                ^ not allowed in type signatures
    |
    = note: for more information on `Fn` traits and closure types, see https://doc.rust-lang.org/book/ch13-01-closures.html
+help: replace with an appropriate return type
+   |
+LL - fn fn_mut() -> _ {
+LL + fn fn_mut() -> impl FnMut(char) {
+   |
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
   --> $DIR/suggest-return-closure.rs:33:13
    |
 LL | fn fun() -> _ {
-   |             ^
-   |             |
-   |             not allowed in type signatures
-   |             help: replace with an appropriate return type: `impl Fn() -> i32`
+   |             ^ not allowed in type signatures
    |
    = note: for more information on `Fn` traits and closure types, see https://doc.rust-lang.org/book/ch13-01-closures.html
+help: replace with an appropriate return type
+   |
+LL - fn fun() -> _ {
+LL + fn fun() -> impl Fn() -> i32 {
+   |
 
 error[E0596]: cannot borrow `x` as mutable, as it is not declared as mutable
   --> $DIR/suggest-return-closure.rs:24:9
diff --git a/tests/ui/fn/suggest-return-future.stderr b/tests/ui/fn/suggest-return-future.stderr
index a4c8b5d8c4b5d..7c097e5067132 100644
--- a/tests/ui/fn/suggest-return-future.stderr
+++ b/tests/ui/fn/suggest-return-future.stderr
@@ -2,19 +2,25 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/suggest-return-future.rs:7:13
    |
 LL | fn foo() -> _ {
-   |             ^
-   |             |
-   |             not allowed in type signatures
-   |             help: replace with an appropriate return type: `impl Future<Output = i32>`
+   |             ^ not allowed in type signatures
+   |
+help: replace with an appropriate return type
+   |
+LL - fn foo() -> _ {
+LL + fn foo() -> impl Future<Output = i32> {
+   |
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
   --> $DIR/suggest-return-future.rs:15:13
    |
 LL | fn bar() -> _ {
-   |             ^
-   |             |
-   |             not allowed in type signatures
-   |             help: replace with an appropriate return type: `impl Future<Output = i32>`
+   |             ^ not allowed in type signatures
+   |
+help: replace with an appropriate return type
+   |
+LL - fn bar() -> _ {
+LL + fn bar() -> impl Future<Output = i32> {
+   |
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/return/infer-return-ty-for-fn-sig-issue-125488.stderr b/tests/ui/return/infer-return-ty-for-fn-sig-issue-125488.stderr
index 8b7c5e1681ad1..839e4265e031c 100644
--- a/tests/ui/return/infer-return-ty-for-fn-sig-issue-125488.stderr
+++ b/tests/ui/return/infer-return-ty-for-fn-sig-issue-125488.stderr
@@ -2,37 +2,49 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/infer-return-ty-for-fn-sig-issue-125488.rs:8:24
    |
 LL |     fn f1(s: S<'_>) -> _ {
-   |                        ^
-   |                        |
-   |                        not allowed in type signatures
-   |                        help: replace with the correct return type: `S<'_>`
+   |                        ^ not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL -     fn f1(s: S<'_>) -> _ {
+LL +     fn f1(s: S<'_>) -> S<'_> {
+   |
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
   --> $DIR/infer-return-ty-for-fn-sig-issue-125488.rs:13:24
    |
 LL |     fn f2(s: S<'_>) -> _ {
-   |                        ^
-   |                        |
-   |                        not allowed in type signatures
-   |                        help: replace with the correct return type: `S<'_>`
+   |                        ^ not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL -     fn f2(s: S<'_>) -> _ {
+LL +     fn f2(s: S<'_>) -> S<'_> {
+   |
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
   --> $DIR/infer-return-ty-for-fn-sig-issue-125488.rs:23:24
    |
 LL |     fn f3(s: S<'_>) -> _ {
-   |                        ^
-   |                        |
-   |                        not allowed in type signatures
-   |                        help: replace with the correct return type: `S<'_>`
+   |                        ^ not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL -     fn f3(s: S<'_>) -> _ {
+LL +     fn f3(s: S<'_>) -> S<'_> {
+   |
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
   --> $DIR/infer-return-ty-for-fn-sig-issue-125488.rs:28:24
    |
 LL |     fn f4(s: S<'_>) -> _ {
-   |                        ^
-   |                        |
-   |                        not allowed in type signatures
-   |                        help: replace with the correct return type: `S<'_>`
+   |                        ^ not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL -     fn f4(s: S<'_>) -> _ {
+LL +     fn f4(s: S<'_>) -> S<'_> {
+   |
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/suggestions/return-cycle-2.stderr b/tests/ui/suggestions/return-cycle-2.stderr
index 23de2309e8778..e852cd34a72a3 100644
--- a/tests/ui/suggestions/return-cycle-2.stderr
+++ b/tests/ui/suggestions/return-cycle-2.stderr
@@ -2,10 +2,13 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/return-cycle-2.rs:6:34
    |
 LL |     fn as_ref(_: i32, _: i32) -> _ {
-   |                                  ^
-   |                                  |
-   |                                  not allowed in type signatures
-   |                                  help: replace with the correct return type: `Token<&'static T>`
+   |                                  ^ not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL -     fn as_ref(_: i32, _: i32) -> _ {
+LL +     fn as_ref(_: i32, _: i32) -> Token<&'static T> {
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/return-cycle.stderr b/tests/ui/suggestions/return-cycle.stderr
index 604704904410b..cd46c2daa40bc 100644
--- a/tests/ui/suggestions/return-cycle.stderr
+++ b/tests/ui/suggestions/return-cycle.stderr
@@ -2,10 +2,13 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/return-cycle.rs:6:17
    |
 LL |     fn new() -> _ {
-   |                 ^
-   |                 |
-   |                 not allowed in type signatures
-   |                 help: replace with the correct return type: `Token<()>`
+   |                 ^ not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL -     fn new() -> _ {
+LL +     fn new() -> Token<()> {
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/suggest-fn-ptr-for-fn-item-in-fn-ret.stderr b/tests/ui/suggestions/suggest-fn-ptr-for-fn-item-in-fn-ret.stderr
index bf7790e2307e0..9880dd95d8644 100644
--- a/tests/ui/suggestions/suggest-fn-ptr-for-fn-item-in-fn-ret.stderr
+++ b/tests/ui/suggestions/suggest-fn-ptr-for-fn-item-in-fn-ret.stderr
@@ -2,10 +2,13 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/suggest-fn-ptr-for-fn-item-in-fn-ret.rs:7:13
    |
 LL | fn bar() -> _ { Wrapper(foo) }
-   |             ^
-   |             |
-   |             not allowed in type signatures
-   |             help: replace with the correct return type: `Wrapper<fn()>`
+   |             ^ not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL - fn bar() -> _ { Wrapper(foo) }
+LL + fn bar() -> Wrapper<fn()> { Wrapper(foo) }
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/type-alias-impl-trait/issue-77179.stderr b/tests/ui/type-alias-impl-trait/issue-77179.stderr
index c0f197ec48c37..222edfb90a7b3 100644
--- a/tests/ui/type-alias-impl-trait/issue-77179.stderr
+++ b/tests/ui/type-alias-impl-trait/issue-77179.stderr
@@ -11,10 +11,13 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/issue-77179.rs:8:22
    |
 LL | fn test() -> Pointer<_> {
-   |              --------^-
-   |              |       |
-   |              |       not allowed in type signatures
-   |              help: replace with the correct return type: `Pointer<i32>`
+   |                      ^ not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL - fn test() -> Pointer<_> {
+LL + fn test() -> Pointer<i32> {
+   |
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for functions
   --> $DIR/issue-77179.rs:19:25
diff --git a/tests/ui/typeck/issue-80779.stderr b/tests/ui/typeck/issue-80779.stderr
index 2261ba616545f..90c80fa2ea6fd 100644
--- a/tests/ui/typeck/issue-80779.stderr
+++ b/tests/ui/typeck/issue-80779.stderr
@@ -2,19 +2,25 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/issue-80779.rs:10:28
    |
 LL | pub fn g(_: T<'static>) -> _ {}
-   |                            ^
-   |                            |
-   |                            not allowed in type signatures
-   |                            help: replace with the correct return type: `()`
+   |                            ^ not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL - pub fn g(_: T<'static>) -> _ {}
+LL + pub fn g(_: T<'static>) -> () {}
+   |
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
   --> $DIR/issue-80779.rs:5:29
    |
 LL | pub fn f<'a>(val: T<'a>) -> _ {
-   |                             ^
-   |                             |
-   |                             not allowed in type signatures
-   |                             help: replace with the correct return type: `()`
+   |                             ^ not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL - pub fn f<'a>(val: T<'a>) -> _ {
+LL + pub fn f<'a>(val: T<'a>) -> () {
+   |
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/typeck/issue-98260.stderr b/tests/ui/typeck/issue-98260.stderr
index b7debd335b0fb..f380db55cdffc 100644
--- a/tests/ui/typeck/issue-98260.stderr
+++ b/tests/ui/typeck/issue-98260.stderr
@@ -2,10 +2,13 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/issue-98260.rs:3:27
    |
 LL |     fn a(aa: B) -> Result<_, B> {
-   |                    -------^----
-   |                    |      |
-   |                    |      not allowed in type signatures
-   |                    help: replace with the correct return type: `Result<(), B>`
+   |                           ^ not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL -     fn a(aa: B) -> Result<_, B> {
+LL +     fn a(aa: B) -> Result<(), B> {
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/typeck/typeck_type_placeholder_item.stderr b/tests/ui/typeck/typeck_type_placeholder_item.stderr
index 87750ee6dc140..240dc1ae8ab9e 100644
--- a/tests/ui/typeck/typeck_type_placeholder_item.stderr
+++ b/tests/ui/typeck/typeck_type_placeholder_item.stderr
@@ -48,20 +48,27 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/typeck_type_placeholder_item.rs:7:14
    |
 LL | fn test() -> _ { 5 }
-   |              ^
-   |              |
-   |              not allowed in type signatures
-   |              help: replace with the correct return type: `i32`
+   |              ^ not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL - fn test() -> _ { 5 }
+LL + fn test() -> i32 { 5 }
+   |
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
   --> $DIR/typeck_type_placeholder_item.rs:10:16
    |
 LL | fn test2() -> (_, _) { (5, 5) }
-   |               -^--^-
-   |               ||  |
-   |               ||  not allowed in type signatures
-   |               |not allowed in type signatures
-   |               help: replace with the correct return type: `(i32, i32)`
+   |                ^  ^ not allowed in type signatures
+   |                |
+   |                not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL - fn test2() -> (_, _) { (5, 5) }
+LL + fn test2() -> (i32, i32) { (5, 5) }
+   |
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for static variables
   --> $DIR/typeck_type_placeholder_item.rs:13:15
@@ -189,19 +196,25 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/typeck_type_placeholder_item.rs:47:26
    |
 LL | fn test11(x: &usize) -> &_ {
-   |                         -^
-   |                         ||
-   |                         |not allowed in type signatures
-   |                         help: replace with the correct return type: `&&usize`
+   |                          ^ not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL - fn test11(x: &usize) -> &_ {
+LL + fn test11(x: &usize) -> &&usize {
+   |
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
   --> $DIR/typeck_type_placeholder_item.rs:52:52
    |
 LL | unsafe fn test12(x: *const usize) -> *const *const _ {
-   |                                      --------------^
-   |                                      |             |
-   |                                      |             not allowed in type signatures
-   |                                      help: replace with the correct return type: `*const *const usize`
+   |                                                    ^ not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL - unsafe fn test12(x: *const usize) -> *const *const _ {
+LL + unsafe fn test12(x: *const usize) -> *const *const usize {
+   |
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for methods
   --> $DIR/typeck_type_placeholder_item.rs:58:24
@@ -261,20 +274,27 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/typeck_type_placeholder_item.rs:80:21
    |
 LL |     fn fn_test() -> _ { 5 }
-   |                     ^
-   |                     |
-   |                     not allowed in type signatures
-   |                     help: replace with the correct return type: `i32`
+   |                     ^ not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL -     fn fn_test() -> _ { 5 }
+LL +     fn fn_test() -> i32 { 5 }
+   |
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
   --> $DIR/typeck_type_placeholder_item.rs:83:23
    |
 LL |     fn fn_test2() -> (_, _) { (5, 5) }
-   |                      -^--^-
-   |                      ||  |
-   |                      ||  not allowed in type signatures
-   |                      |not allowed in type signatures
-   |                      help: replace with the correct return type: `(i32, i32)`
+   |                       ^  ^ not allowed in type signatures
+   |                       |
+   |                       not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL -     fn fn_test2() -> (_, _) { (5, 5) }
+LL +     fn fn_test2() -> (i32, i32) { (5, 5) }
+   |
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for static variables
   --> $DIR/typeck_type_placeholder_item.rs:86:22
@@ -374,20 +394,27 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/typeck_type_placeholder_item.rs:134:30
    |
 LL |     fn fn_test12(x: i32) -> (_, _) { (x, x) }
-   |                             -^--^-
-   |                             ||  |
-   |                             ||  not allowed in type signatures
-   |                             |not allowed in type signatures
-   |                             help: replace with the correct return type: `(i32, i32)`
+   |                              ^  ^ not allowed in type signatures
+   |                              |
+   |                              not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL -     fn fn_test12(x: i32) -> (_, _) { (x, x) }
+LL +     fn fn_test12(x: i32) -> (i32, i32) { (x, x) }
+   |
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for return types
   --> $DIR/typeck_type_placeholder_item.rs:137:33
    |
 LL |     fn fn_test13(x: _) -> (i32, _) { (x, x) }
-   |                           ------^-
-   |                           |     |
-   |                           |     not allowed in type signatures
-   |                           help: replace with the correct return type: `(i32, i32)`
+   |                                 ^ not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL -     fn fn_test13(x: _) -> (i32, _) { (x, x) }
+LL +     fn fn_test13(x: _) -> (i32, i32) { (x, x) }
+   |
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for methods
   --> $DIR/typeck_type_placeholder_item.rs:142:31
@@ -528,10 +555,13 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/typeck_type_placeholder_item.rs:226:31
    |
 LL | fn value() -> Option<&'static _> {
-   |               ----------------^-
-   |               |               |
-   |               |               not allowed in type signatures
-   |               help: replace with the correct return type: `Option<&'static u8>`
+   |                               ^ not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL - fn value() -> Option<&'static _> {
+LL + fn value() -> Option<&'static u8> {
+   |
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for constants
   --> $DIR/typeck_type_placeholder_item.rs:231:17
@@ -549,10 +579,13 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/typeck_type_placeholder_item.rs:235:31
    |
 LL | fn evens_squared(n: usize) -> _ {
-   |                               ^
-   |                               |
-   |                               not allowed in type signatures
-   |                               help: replace with an appropriate return type: `impl Iterator<Item = usize>`
+   |                               ^ not allowed in type signatures
+   |
+help: replace with an appropriate return type
+   |
+LL - fn evens_squared(n: usize) -> _ {
+LL + fn evens_squared(n: usize) -> impl Iterator<Item = usize> {
+   |
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for constants
   --> $DIR/typeck_type_placeholder_item.rs:240:10
@@ -570,10 +603,13 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/typeck_type_placeholder_item.rs:40:24
    |
 LL |     fn test9(&self) -> _ { () }
-   |                        ^
-   |                        |
-   |                        not allowed in type signatures
-   |                        help: replace with the correct return type: `()`
+   |                        ^ not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL -     fn test9(&self) -> _ { () }
+LL +     fn test9(&self) -> () { () }
+   |
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for methods
   --> $DIR/typeck_type_placeholder_item.rs:43:27
@@ -585,10 +621,13 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/typeck_type_placeholder_item.rs:107:31
    |
 LL |         fn fn_test9(&self) -> _ { () }
-   |                               ^
-   |                               |
-   |                               not allowed in type signatures
-   |                               help: replace with the correct return type: `()`
+   |                               ^ not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL -         fn fn_test9(&self) -> _ { () }
+LL +         fn fn_test9(&self) -> () { () }
+   |
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for methods
   --> $DIR/typeck_type_placeholder_item.rs:110:34
diff --git a/tests/ui/typeck/typeck_type_placeholder_item_help.stderr b/tests/ui/typeck/typeck_type_placeholder_item_help.stderr
index 2fce00e7a8e9f..3f21ff6d4ec9f 100644
--- a/tests/ui/typeck/typeck_type_placeholder_item_help.stderr
+++ b/tests/ui/typeck/typeck_type_placeholder_item_help.stderr
@@ -2,10 +2,13 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/typeck_type_placeholder_item_help.rs:4:15
    |
 LL | fn test1() -> _ { Some(42) }
-   |               ^
-   |               |
-   |               not allowed in type signatures
-   |               help: replace with the correct return type: `Option<i32>`
+   |               ^ not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL - fn test1() -> _ { Some(42) }
+LL + fn test1() -> Option<i32> { Some(42) }
+   |
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for constants
   --> $DIR/typeck_type_placeholder_item_help.rs:7:14
diff --git a/tests/ui/variance/leaking-unnameables.stderr b/tests/ui/variance/leaking-unnameables.stderr
index 92afe952801d0..59bdc33040de7 100644
--- a/tests/ui/variance/leaking-unnameables.stderr
+++ b/tests/ui/variance/leaking-unnameables.stderr
@@ -2,10 +2,13 @@ error[E0121]: the placeholder `_` is not allowed within types on item signatures
   --> $DIR/leaking-unnameables.rs:8:18
    |
 LL | pub fn f<T>() -> _ {
-   |                  ^
-   |                  |
-   |                  not allowed in type signatures
-   |                  help: replace with the correct return type: `fn()`
+   |                  ^ not allowed in type signatures
+   |
+help: replace with the correct return type
+   |
+LL - pub fn f<T>() -> _ {
+LL + pub fn f<T>() -> fn() {
+   |
 
 error: aborting due to 1 previous error
 

From 50171eb172a9418e8a20ad7d813d256305add5f0 Mon Sep 17 00:00:00 2001
From: The rustc-josh-sync Cronjob Bot <github-actions@github.com>
Date: Mon, 29 Sep 2025 04:07:42 +0000
Subject: [PATCH 1540/1889] Prepare for merging from rust-lang/rust

This updates the rust-version file to f957826bff7a68b267ce75b1ea56352aed0cca0a.
---
 src/tools/rust-analyzer/rust-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/rust-version b/src/tools/rust-analyzer/rust-version
index 8854fb95997bd..1f90d4e5e498a 100644
--- a/src/tools/rust-analyzer/rust-version
+++ b/src/tools/rust-analyzer/rust-version
@@ -1 +1 @@
-caccb4d0368bd918ef6668af8e13834d07040417
+f957826bff7a68b267ce75b1ea56352aed0cca0a

From 68a7c250788833305f73f816b284aafa9e62370a Mon Sep 17 00:00:00 2001
From: Yotam Ofek <yotam.ofek@gmail.com>
Date: Sat, 27 Sep 2025 20:57:50 +0300
Subject: [PATCH 1541/1889] Use `Iterator::eq` and (dogfood) `eq_by` in
 compiler and library

---
 compiler/rustc_ast/src/ast.rs                     |  3 +--
 compiler/rustc_ast/src/lib.rs                     |  1 +
 compiler/rustc_ast/src/tokenstream.rs             |  4 +---
 compiler/rustc_attr_parsing/src/parser.rs         |  2 +-
 compiler/rustc_builtin_macros/src/autodiff.rs     |  3 +--
 .../src/deriving/coerce_pointee.rs                | 15 ++++-----------
 compiler/rustc_builtin_macros/src/format.rs       |  2 +-
 compiler/rustc_builtin_macros/src/lib.rs          |  1 +
 compiler/rustc_hir/src/hir.rs                     |  5 +----
 compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs   |  4 +---
 compiler/rustc_hir_typeck/src/lib.rs              |  1 +
 compiler/rustc_hir_typeck/src/method/suggest.rs   |  4 +---
 compiler/rustc_parse/src/lib.rs                   |  1 +
 .../rustc_parse/src/parser/tokenstream/tests.rs   |  2 +-
 library/alloc/src/collections/btree/map.rs        |  2 +-
 src/librustdoc/clean/types.rs                     |  2 +-
 src/librustdoc/lib.rs                             |  1 +
 17 files changed, 20 insertions(+), 33 deletions(-)

diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index 3e8fddd9954e2..082d5e88ac754 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -114,8 +114,7 @@ impl PartialEq<Symbol> for Path {
 impl PartialEq<&[Symbol]> for Path {
     #[inline]
     fn eq(&self, names: &&[Symbol]) -> bool {
-        self.segments.len() == names.len()
-            && self.segments.iter().zip(names.iter()).all(|(s1, s2)| s1 == s2)
+        self.segments.iter().eq(*names)
     }
 }
 
diff --git a/compiler/rustc_ast/src/lib.rs b/compiler/rustc_ast/src/lib.rs
index f1951049b4760..5fe218776e539 100644
--- a/compiler/rustc_ast/src/lib.rs
+++ b/compiler/rustc_ast/src/lib.rs
@@ -15,6 +15,7 @@
 #![feature(associated_type_defaults)]
 #![feature(box_patterns)]
 #![feature(if_let_guard)]
+#![feature(iter_order_by)]
 #![feature(macro_metavar_expr)]
 #![feature(rustdoc_internals)]
 #![recursion_limit = "256"]
diff --git a/compiler/rustc_ast/src/tokenstream.rs b/compiler/rustc_ast/src/tokenstream.rs
index a5d8fbfac612a..4111182c3b7dc 100644
--- a/compiler/rustc_ast/src/tokenstream.rs
+++ b/compiler/rustc_ast/src/tokenstream.rs
@@ -48,9 +48,7 @@ impl TokenTree {
         match (self, other) {
             (TokenTree::Token(token, _), TokenTree::Token(token2, _)) => token.kind == token2.kind,
             (TokenTree::Delimited(.., delim, tts), TokenTree::Delimited(.., delim2, tts2)) => {
-                delim == delim2
-                    && tts.len() == tts2.len()
-                    && tts.iter().zip(tts2.iter()).all(|(a, b)| a.eq_unspanned(b))
+                delim == delim2 && tts.iter().eq_by(tts2.iter(), |a, b| a.eq_unspanned(b))
             }
             _ => false,
         }
diff --git a/compiler/rustc_attr_parsing/src/parser.rs b/compiler/rustc_attr_parsing/src/parser.rs
index 4f903594225e0..3f4f567901575 100644
--- a/compiler/rustc_attr_parsing/src/parser.rs
+++ b/compiler/rustc_attr_parsing/src/parser.rs
@@ -49,7 +49,7 @@ impl<'a> PathParser<'a> {
     }
 
     pub fn segments_is(&self, segments: &[Symbol]) -> bool {
-        self.len() == segments.len() && self.segments().zip(segments).all(|(a, b)| a.name == *b)
+        self.segments().map(|segment| &segment.name).eq(segments)
     }
 
     pub fn word(&self) -> Option<Ident> {
diff --git a/compiler/rustc_builtin_macros/src/autodiff.rs b/compiler/rustc_builtin_macros/src/autodiff.rs
index f4a923797e2d3..ddc59bfe1414a 100644
--- a/compiler/rustc_builtin_macros/src/autodiff.rs
+++ b/compiler/rustc_builtin_macros/src/autodiff.rs
@@ -377,8 +377,7 @@ mod llvm_enzyme {
                 (ast::AttrKind::Normal(a), ast::AttrKind::Normal(b)) => {
                     let a = &a.item.path;
                     let b = &b.item.path;
-                    a.segments.len() == b.segments.len()
-                        && a.segments.iter().zip(b.segments.iter()).all(|(a, b)| a.ident == b.ident)
+                    a.segments.iter().eq_by(&b.segments, |a, b| a.ident == b.ident)
                 }
                 _ => false,
             }
diff --git a/compiler/rustc_builtin_macros/src/deriving/coerce_pointee.rs b/compiler/rustc_builtin_macros/src/deriving/coerce_pointee.rs
index 75db5d77783eb..5b378de8bbddc 100644
--- a/compiler/rustc_builtin_macros/src/deriving/coerce_pointee.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/coerce_pointee.rs
@@ -356,21 +356,14 @@ fn contains_maybe_sized_bound(bounds: &[GenericBound]) -> bool {
     bounds.iter().any(is_maybe_sized_bound)
 }
 
-fn path_segment_is_exact_match(path_segments: &[ast::PathSegment], syms: &[Symbol]) -> bool {
-    path_segments.iter().zip(syms).all(|(segment, &symbol)| segment.ident.name == symbol)
-}
-
 fn is_sized_marker(path: &ast::Path) -> bool {
     const CORE_UNSIZE: [Symbol; 3] = [sym::core, sym::marker, sym::Sized];
     const STD_UNSIZE: [Symbol; 3] = [sym::std, sym::marker, sym::Sized];
-    if path.segments.len() == 4 && path.is_global() {
-        path_segment_is_exact_match(&path.segments[1..], &CORE_UNSIZE)
-            || path_segment_is_exact_match(&path.segments[1..], &STD_UNSIZE)
-    } else if path.segments.len() == 3 {
-        path_segment_is_exact_match(&path.segments, &CORE_UNSIZE)
-            || path_segment_is_exact_match(&path.segments, &STD_UNSIZE)
+    let segments = || path.segments.iter().map(|segment| segment.ident.name);
+    if path.is_global() {
+        segments().skip(1).eq(CORE_UNSIZE) || segments().skip(1).eq(STD_UNSIZE)
     } else {
-        *path == sym::Sized
+        segments().eq(CORE_UNSIZE) || segments().eq(STD_UNSIZE) || *path == sym::Sized
     }
 }
 
diff --git a/compiler/rustc_builtin_macros/src/format.rs b/compiler/rustc_builtin_macros/src/format.rs
index d70888205a51b..bffc0407e8112 100644
--- a/compiler/rustc_builtin_macros/src/format.rs
+++ b/compiler/rustc_builtin_macros/src/format.rs
@@ -768,7 +768,7 @@ fn report_missing_placeholders(
 
     if !found_foreign && invalid_refs.is_empty() {
         // Show example if user didn't use any format specifiers
-        let show_example = used.iter().all(|used| !used);
+        let show_example = !used.contains(&true);
 
         if !show_example {
             if unused.len() > 1 {
diff --git a/compiler/rustc_builtin_macros/src/lib.rs b/compiler/rustc_builtin_macros/src/lib.rs
index 4541e2cd3b41d..57cf62ea61212 100644
--- a/compiler/rustc_builtin_macros/src/lib.rs
+++ b/compiler/rustc_builtin_macros/src/lib.rs
@@ -11,6 +11,7 @@
 #![feature(box_patterns)]
 #![feature(decl_macro)]
 #![feature(if_let_guard)]
+#![feature(iter_order_by)]
 #![feature(proc_macro_internals)]
 #![feature(proc_macro_quote)]
 #![feature(rustdoc_internals)]
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index 493236718a86a..bc1c47e95c3ae 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -1298,10 +1298,7 @@ impl AttributeExt for Attribute {
     #[inline]
     fn path_matches(&self, name: &[Symbol]) -> bool {
         match &self {
-            Attribute::Unparsed(n) => {
-                n.path.segments.len() == name.len()
-                    && n.path.segments.iter().zip(name).all(|(s, n)| s.name == *n)
-            }
+            Attribute::Unparsed(n) => n.path.segments.iter().map(|ident| &ident.name).eq(name),
             _ => false,
         }
     }
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
index 7ca8580e09866..c8943d4634e29 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -2803,9 +2803,7 @@ impl<'a, 'b, 'tcx> ArgMatchingCtxt<'a, 'b, 'tcx> {
         if let Some((assoc, fn_sig)) = self.similar_assoc(call_name)
             && fn_sig.inputs()[1..]
                 .iter()
-                .zip(input_types.iter())
-                .all(|(expected, found)| self.may_coerce(*expected, *found))
-            && fn_sig.inputs()[1..].len() == input_types.len()
+                .eq_by(input_types, |expected, found| self.may_coerce(*expected, found))
         {
             let assoc_name = assoc.name();
             err.span_suggestion_verbose(
diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
index 43a23822fd1e3..acc0481e457fd 100644
--- a/compiler/rustc_hir_typeck/src/lib.rs
+++ b/compiler/rustc_hir_typeck/src/lib.rs
@@ -5,6 +5,7 @@
 #![feature(box_patterns)]
 #![feature(if_let_guard)]
 #![feature(iter_intersperse)]
+#![feature(iter_order_by)]
 #![feature(never_type)]
 // tidy-alphabetical-end
 
diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index 024b9ee08c222..44602e6289940 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -1914,9 +1914,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         if let Some(ref args) = call_args
                             && fn_sig.inputs()[1..]
                                 .iter()
-                                .zip(args.into_iter())
-                                .all(|(expected, found)| self.may_coerce(*expected, *found))
-                            && fn_sig.inputs()[1..].len() == args.len()
+                                .eq_by(args, |expected, found| self.may_coerce(*expected, *found))
                         {
                             err.span_suggestion_verbose(
                                 item_name.span,
diff --git a/compiler/rustc_parse/src/lib.rs b/compiler/rustc_parse/src/lib.rs
index 88b67d792deb9..c26c7b9122afa 100644
--- a/compiler/rustc_parse/src/lib.rs
+++ b/compiler/rustc_parse/src/lib.rs
@@ -9,6 +9,7 @@
 #![feature(default_field_values)]
 #![feature(if_let_guard)]
 #![feature(iter_intersperse)]
+#![feature(iter_order_by)]
 #![recursion_limit = "256"]
 // tidy-alphabetical-end
 
diff --git a/compiler/rustc_parse/src/parser/tokenstream/tests.rs b/compiler/rustc_parse/src/parser/tokenstream/tests.rs
index 19b2c98f5af82..63177a727449e 100644
--- a/compiler/rustc_parse/src/parser/tokenstream/tests.rs
+++ b/compiler/rustc_parse/src/parser/tokenstream/tests.rs
@@ -15,7 +15,7 @@ fn sp(a: u32, b: u32) -> Span {
 }
 
 fn cmp_token_stream(a: &TokenStream, b: &TokenStream) -> bool {
-    a.len() == b.len() && a.iter().zip(b.iter()).all(|(x, y)| x.eq_unspanned(y))
+    a.iter().eq_by(b.iter(), |x, y| x.eq_unspanned(y))
 }
 
 #[test]
diff --git a/library/alloc/src/collections/btree/map.rs b/library/alloc/src/collections/btree/map.rs
index 9dfbbd913225a..adcb444d08c66 100644
--- a/library/alloc/src/collections/btree/map.rs
+++ b/library/alloc/src/collections/btree/map.rs
@@ -2413,7 +2413,7 @@ impl<K, V> Default for BTreeMap<K, V> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<K: PartialEq, V: PartialEq, A: Allocator + Clone> PartialEq for BTreeMap<K, V, A> {
     fn eq(&self, other: &BTreeMap<K, V, A>) -> bool {
-        self.len() == other.len() && self.iter().zip(other).all(|(a, b)| a == b)
+        self.iter().eq(other)
     }
 }
 
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index c2cf39c4be06e..4eb32585ffb97 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -1685,7 +1685,7 @@ impl Type {
         match (self_cleared, other_cleared) {
             // Recursive cases.
             (Type::Tuple(a), Type::Tuple(b)) => {
-                a.len() == b.len() && a.iter().zip(b).all(|(a, b)| a.is_doc_subtype_of(b, cache))
+                a.iter().eq_by(b, |a, b| a.is_doc_subtype_of(b, cache))
             }
             (Type::Slice(a), Type::Slice(b)) => a.is_doc_subtype_of(b, cache),
             (Type::Array(a, al), Type::Array(b, bl)) => al == bl && a.is_doc_subtype_of(b, cache),
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index c4f24e09ddbfa..d7ffb25f8bd81 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -13,6 +13,7 @@
 #![feature(if_let_guard)]
 #![feature(iter_advance_by)]
 #![feature(iter_intersperse)]
+#![feature(iter_order_by)]
 #![feature(rustc_private)]
 #![feature(test)]
 #![warn(rustc::internal)]

From 97333f8c9a0f774cc8d0025bbc51848e1f60427d Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Tue, 23 Sep 2025 17:14:51 +0200
Subject: [PATCH 1542/1889] std: implement `hostname`

---
 library/std/src/net/hostname.rs               | 22 +++++++
 library/std/src/net/mod.rs                    |  6 +-
 library/std/src/sys/net/hostname/mod.rs       | 14 +++++
 library/std/src/sys/net/hostname/unix.rs      | 62 +++++++++++++++++++
 .../std/src/sys/net/hostname/unsupported.rs   |  6 ++
 library/std/src/sys/net/hostname/windows.rs   | 24 +++++++
 library/std/src/sys/net/mod.rs                |  3 +
 .../std/src/sys/pal/windows/c/bindings.txt    |  2 +
 .../std/src/sys/pal/windows/c/windows_sys.rs  |  2 +
 9 files changed, 140 insertions(+), 1 deletion(-)
 create mode 100644 library/std/src/net/hostname.rs
 create mode 100644 library/std/src/sys/net/hostname/mod.rs
 create mode 100644 library/std/src/sys/net/hostname/unix.rs
 create mode 100644 library/std/src/sys/net/hostname/unsupported.rs
 create mode 100644 library/std/src/sys/net/hostname/windows.rs

diff --git a/library/std/src/net/hostname.rs b/library/std/src/net/hostname.rs
new file mode 100644
index 0000000000000..b1010cec60058
--- /dev/null
+++ b/library/std/src/net/hostname.rs
@@ -0,0 +1,22 @@
+use crate::ffi::OsString;
+
+/// Returns the system hostname.
+///
+/// This can error out in platform-specific error cases;
+/// for example, uefi and wasm, where hostnames aren't
+/// supported.
+///
+/// # Underlying system calls
+///
+/// | Platform | System call                                                                                             |
+/// |----------|---------------------------------------------------------------------------------------------------------|
+/// | UNIX     | [`gethostname`](https://www.man7.org/linux/man-pages/man2/gethostname.2.html)                           |
+/// | Windows  | [`GetHostNameW`](https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-gethostnamew) |
+///
+/// Note that platform-specific behavior [may change in the future][changes].
+///
+/// [changes]: crate::io#platform-specific-behavior
+#[unstable(feature = "gethostname", issue = "135142")]
+pub fn hostname() -> crate::io::Result<OsString> {
+    crate::sys::net::hostname()
+}
diff --git a/library/std/src/net/mod.rs b/library/std/src/net/mod.rs
index 40f1a93e39ded..3e4447eb33f2a 100644
--- a/library/std/src/net/mod.rs
+++ b/library/std/src/net/mod.rs
@@ -1,7 +1,8 @@
 //! Networking primitives for TCP/UDP communication.
 //!
 //! This module provides networking functionality for the Transmission Control and User
-//! Datagram Protocols, as well as types for IP and socket addresses.
+//! Datagram Protocols, as well as types for IP and socket addresses and functions related
+//! to network properties.
 //!
 //! # Organization
 //!
@@ -24,6 +25,8 @@
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use core::net::AddrParseError;
 
+#[unstable(feature = "gethostname", issue = "135142")]
+pub use self::hostname::hostname;
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use self::ip_addr::{IpAddr, Ipv4Addr, Ipv6Addr, Ipv6MulticastScope};
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -35,6 +38,7 @@ pub use self::tcp::{Incoming, TcpListener, TcpStream};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use self::udp::UdpSocket;
 
+mod hostname;
 mod ip_addr;
 mod socket_addr;
 mod tcp;
diff --git a/library/std/src/sys/net/hostname/mod.rs b/library/std/src/sys/net/hostname/mod.rs
new file mode 100644
index 0000000000000..a4b5b76059d30
--- /dev/null
+++ b/library/std/src/sys/net/hostname/mod.rs
@@ -0,0 +1,14 @@
+cfg_select! {
+    target_family = "unix" => {
+        mod unix;
+        pub use unix::hostname;
+    }
+    target_os = "windows" => {
+        mod windows;
+        pub use windows::hostname;
+    }
+    _ => {
+        mod unsupported;
+        pub use unsupported::hostname;
+    }
+}
diff --git a/library/std/src/sys/net/hostname/unix.rs b/library/std/src/sys/net/hostname/unix.rs
new file mode 100644
index 0000000000000..bc6fa82a38f0d
--- /dev/null
+++ b/library/std/src/sys/net/hostname/unix.rs
@@ -0,0 +1,62 @@
+use crate::ffi::OsString;
+use crate::io;
+use crate::os::unix::ffi::OsStringExt;
+use crate::sys::pal::os::errno;
+
+pub fn hostname() -> io::Result<OsString> {
+    // Query the system for the maximum host name length.
+    let host_name_max = match unsafe { libc::sysconf(libc::_SC_HOST_NAME_MAX) } {
+        // If this fails (possibly because there is no maximum length), then
+        // assume a maximum length of _POSIX_HOST_NAME_MAX (255).
+        -1 => 255,
+        max => max as usize,
+    };
+
+    // Reserve space for the nul terminator too.
+    let mut buf = Vec::<u8>::try_with_capacity(host_name_max + 1)?;
+    loop {
+        // SAFETY: `buf.capacity()` bytes of `buf` are writable.
+        let r = unsafe { libc::gethostname(buf.as_mut_ptr().cast(), buf.capacity()) };
+        match (r != 0).then(errno) {
+            None => {
+                // Unfortunately, the UNIX specification says that the name will
+                // be truncated if it does not fit in the buffer, without returning
+                // an error. As additionally, the truncated name may still be null-
+                // terminated, there is no reliable way to  detect truncation.
+                // Fortunately, most platforms ignore what the specification says
+                // and return an error (mostly ENAMETOOLONG). Should that not be
+                // the case, the following detects truncation if the null-terminator
+                // was omitted. Note that this check does not impact performance at
+                // all as we need to find the length of the string anyways.
+                //
+                // Use `strnlen` as it does not place an initialization requirement
+                // on the bytes after the nul terminator.
+                //
+                // SAFETY: `buf.capacity()` bytes of `buf` are accessible, and are
+                // initialized up to and including a possible nul terminator.
+                let len = unsafe { libc::strnlen(buf.as_ptr().cast(), buf.capacity()) };
+                if len < buf.capacity() {
+                    // If the string is nul-terminated, we assume that is has not
+                    // been truncated, as the capacity *should be* enough to hold
+                    // `HOST_NAME_MAX` bytes.
+                    // SAFETY: `len + 1` bytes have been initialized (we exclude
+                    // the nul terminator from the string).
+                    unsafe { buf.set_len(len) };
+                    return Ok(OsString::from_vec(buf));
+                }
+            }
+            // As `buf.capacity()` is always less than or equal to `isize::MAX`
+            // (Rust allocations cannot exceed that limit), the only way `EINVAL`
+            // can be returned is if the system uses `EINVAL` to report that the
+            // name does not fit in the provided buffer. In that case (or in the
+            // case of `ENAMETOOLONG`), resize the buffer and try again.
+            Some(libc::EINVAL | libc::ENAMETOOLONG) => {}
+            // Other error codes (e.g. EPERM) have nothing to do with the buffer
+            // size and should be returned to the user.
+            Some(err) => return Err(io::Error::from_raw_os_error(err)),
+        }
+
+        // Resize the buffer (according to `Vec`'s resizing rules) and try again.
+        buf.try_reserve(buf.capacity() + 1)?;
+    }
+}
diff --git a/library/std/src/sys/net/hostname/unsupported.rs b/library/std/src/sys/net/hostname/unsupported.rs
new file mode 100644
index 0000000000000..d868f68f32dd2
--- /dev/null
+++ b/library/std/src/sys/net/hostname/unsupported.rs
@@ -0,0 +1,6 @@
+use crate::ffi::OsString;
+use crate::io::{Error, Result};
+
+pub fn hostname() -> Result<OsString> {
+    Err(Error::UNSUPPORTED_PLATFORM)
+}
diff --git a/library/std/src/sys/net/hostname/windows.rs b/library/std/src/sys/net/hostname/windows.rs
new file mode 100644
index 0000000000000..24eed100f32d4
--- /dev/null
+++ b/library/std/src/sys/net/hostname/windows.rs
@@ -0,0 +1,24 @@
+use crate::ffi::OsString;
+use crate::io::Result;
+use crate::mem::MaybeUninit;
+use crate::os::windows::ffi::OsStringExt;
+use crate::sys::pal::c;
+use crate::sys::pal::winsock::{self, cvt};
+
+pub fn hostname() -> Result<OsString> {
+    winsock::startup();
+
+    // The documentation of GetHostNameW says that a buffer size of 256 is
+    // always enough.
+    let mut buffer = [const { MaybeUninit::<u16>::uninit() }; 256];
+    // SAFETY: these parameters specify a valid, writable region of memory.
+    cvt(unsafe { c::GetHostNameW(buffer.as_mut_ptr().cast(), buffer.len() as i32) })?;
+    // Use `lstrlenW` here as it does not require the bytes after the nul
+    // terminator to be initialized.
+    // SAFETY: if `GetHostNameW` returns successfully, the name is nul-terminated.
+    let len = unsafe { c::lstrlenW(buffer.as_ptr().cast()) };
+    // SAFETY: the length of the name is `len`, hence `len` bytes have been
+    //         initialized by `GetHostNameW`.
+    let name = unsafe { buffer[..len as usize].assume_init_ref() };
+    Ok(OsString::from_wide(name))
+}
diff --git a/library/std/src/sys/net/mod.rs b/library/std/src/sys/net/mod.rs
index dffc4ea7f81ad..bfe5cf5312875 100644
--- a/library/std/src/sys/net/mod.rs
+++ b/library/std/src/sys/net/mod.rs
@@ -2,3 +2,6 @@
 /// `UdpSocket` as well as related functionality like DNS resolving.
 mod connection;
 pub use connection::*;
+
+mod hostname;
+pub use hostname::hostname;
diff --git a/library/std/src/sys/pal/windows/c/bindings.txt b/library/std/src/sys/pal/windows/c/bindings.txt
index abc1c19827fe7..9009aa09f48ed 100644
--- a/library/std/src/sys/pal/windows/c/bindings.txt
+++ b/library/std/src/sys/pal/windows/c/bindings.txt
@@ -2170,6 +2170,7 @@ GetFileType
 GETFINALPATHNAMEBYHANDLE_FLAGS
 GetFinalPathNameByHandleW
 GetFullPathNameW
+GetHostNameW
 GetLastError
 GetModuleFileNameW
 GetModuleHandleA
@@ -2270,6 +2271,7 @@ LPPROGRESS_ROUTINE
 LPPROGRESS_ROUTINE_CALLBACK_REASON
 LPTHREAD_START_ROUTINE
 LPWSAOVERLAPPED_COMPLETION_ROUTINE
+lstrlenW
 M128A
 MAX_PATH
 MAXIMUM_REPARSE_DATA_BUFFER_SIZE
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 989a1246650cd..98f277b33780c 100644
--- a/library/std/src/sys/pal/windows/c/windows_sys.rs
+++ b/library/std/src/sys/pal/windows/c/windows_sys.rs
@@ -49,6 +49,7 @@ windows_targets::link!("kernel32.dll" "system" fn GetFileSizeEx(hfile : HANDLE,
 windows_targets::link!("kernel32.dll" "system" fn GetFileType(hfile : HANDLE) -> FILE_TYPE);
 windows_targets::link!("kernel32.dll" "system" fn GetFinalPathNameByHandleW(hfile : HANDLE, lpszfilepath : PWSTR, cchfilepath : u32, dwflags : GETFINALPATHNAMEBYHANDLE_FLAGS) -> u32);
 windows_targets::link!("kernel32.dll" "system" fn GetFullPathNameW(lpfilename : PCWSTR, nbufferlength : u32, lpbuffer : PWSTR, lpfilepart : *mut PWSTR) -> u32);
+windows_targets::link!("ws2_32.dll" "system" fn GetHostNameW(name : PWSTR, namelen : i32) -> i32);
 windows_targets::link!("kernel32.dll" "system" fn GetLastError() -> WIN32_ERROR);
 windows_targets::link!("kernel32.dll" "system" fn GetModuleFileNameW(hmodule : HMODULE, lpfilename : PWSTR, nsize : u32) -> u32);
 windows_targets::link!("kernel32.dll" "system" fn GetModuleHandleA(lpmodulename : PCSTR) -> HMODULE);
@@ -134,6 +135,7 @@ windows_targets::link!("ws2_32.dll" "system" fn getsockname(s : SOCKET, name : *
 windows_targets::link!("ws2_32.dll" "system" fn getsockopt(s : SOCKET, level : i32, optname : i32, optval : PSTR, optlen : *mut i32) -> i32);
 windows_targets::link!("ws2_32.dll" "system" fn ioctlsocket(s : SOCKET, cmd : i32, argp : *mut u32) -> i32);
 windows_targets::link!("ws2_32.dll" "system" fn listen(s : SOCKET, backlog : i32) -> i32);
+windows_targets::link!("kernel32.dll" "system" fn lstrlenW(lpstring : PCWSTR) -> i32);
 windows_targets::link!("ws2_32.dll" "system" fn recv(s : SOCKET, buf : PSTR, len : i32, flags : SEND_RECV_FLAGS) -> i32);
 windows_targets::link!("ws2_32.dll" "system" fn recvfrom(s : SOCKET, buf : PSTR, len : i32, flags : i32, from : *mut SOCKADDR, fromlen : *mut i32) -> i32);
 windows_targets::link!("ws2_32.dll" "system" fn select(nfds : i32, readfds : *mut FD_SET, writefds : *mut FD_SET, exceptfds : *mut FD_SET, timeout : *const TIMEVAL) -> i32);

From 04ee9915897ba66a768440e1aaeaf1e63f14ba02 Mon Sep 17 00:00:00 2001
From: Daniel McNab <36049421+DJMcNab@users.noreply.github.com>
Date: Sun, 28 Sep 2025 13:16:10 +0100
Subject: [PATCH 1543/1889] Fix removed version of `doc_auto_cfg`,
 `doc_cfg_hide`

---
 compiler/rustc_feature/src/removed.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_feature/src/removed.rs b/compiler/rustc_feature/src/removed.rs
index 3c51f91331a6a..539d67e0b6bc8 100644
--- a/compiler/rustc_feature/src/removed.rs
+++ b/compiler/rustc_feature/src/removed.rs
@@ -102,9 +102,9 @@ declare_features! (
     /// Allows deriving traits as per `SmartPointer` specification
     (removed, derive_smart_pointer, "1.84.0", Some(123430), Some("replaced by `CoercePointee`"), 131284),
     /// Tells rustdoc to automatically generate `#[doc(cfg(...))]`.
-    (removed, doc_auto_cfg, "1.58.0", Some(43781), Some("merged into `doc_cfg`"), 138907),
+    (removed, doc_auto_cfg, "CURRENT_RUSTC_VERSION", Some(43781), Some("merged into `doc_cfg`"), 138907),
     /// Allows `#[doc(cfg_hide(...))]`.
-    (removed, doc_cfg_hide, "1.57.0", Some(43781), Some("merged into `doc_cfg`"), 138907),
+    (removed, doc_cfg_hide, "CURRENT_RUSTC_VERSION", Some(43781), Some("merged into `doc_cfg`"), 138907),
     /// Allows using `#[doc(keyword = "...")]`.
     (removed, doc_keyword, "1.58.0", Some(51315),
      Some("merged into `#![feature(rustdoc_internals)]`"), 90420),

From 9c97ba700e8d4059f8394efa19e6e9487def7afb Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Mon, 29 Sep 2025 11:20:40 +0200
Subject: [PATCH 1544/1889] add joboet to library review rotation

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

diff --git a/triagebot.toml b/triagebot.toml
index 2d58c616bc278..a04f8d2807235 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -1382,6 +1382,7 @@ libs = [
     "@tgross35",
     "@thomcc",
     "@ibraheemdev",
+    "@joboet",
 ]
 infra-ci = [
     "@Mark-Simulacrum",

From af8fd78142bf394ac904402adb736f4c2f1efbc6 Mon Sep 17 00:00:00 2001
From: Nikita Popov <npopov@redhat.com>
Date: Mon, 29 Sep 2025 11:24:20 +0200
Subject: [PATCH 1545/1889] Emit allocator attributes for allocator shim

This emits the same attributes we place on allocator declarations
(and allocator definitions using `#[global_allocator]`) on the
definitions in the allocator shim as well, making sure that the
attributes are not lost if the allocator shim participates in LTO.
---
 compiler/rustc_codegen_llvm/src/allocator.rs | 30 +++++++++++++++++---
 1 file changed, 26 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/allocator.rs b/compiler/rustc_codegen_llvm/src/allocator.rs
index abd6312039733..896d6755c7527 100644
--- a/compiler/rustc_codegen_llvm/src/allocator.rs
+++ b/compiler/rustc_codegen_llvm/src/allocator.rs
@@ -5,9 +5,10 @@ use rustc_ast::expand::allocator::{
 };
 use rustc_codegen_ssa::traits::BaseTypeCodegenMethods as _;
 use rustc_middle::bug;
-use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrs;
+use rustc_middle::middle::codegen_fn_attrs::{CodegenFnAttrFlags, CodegenFnAttrs};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::config::{DebugInfo, OomStrategy};
+use rustc_span::sym;
 use rustc_symbol_mangling::mangle_internal_symbol;
 
 use crate::attributes::llfn_attrs_from_instance;
@@ -59,7 +60,26 @@ pub(crate) unsafe fn codegen(
             let from_name = mangle_internal_symbol(tcx, &global_fn_name(method.name));
             let to_name = mangle_internal_symbol(tcx, &default_fn_name(method.name));
 
-            create_wrapper_function(tcx, &cx, &from_name, Some(&to_name), &args, output, false);
+            let alloc_attr_flag = match method.name {
+                sym::alloc => CodegenFnAttrFlags::ALLOCATOR,
+                sym::dealloc => CodegenFnAttrFlags::DEALLOCATOR,
+                sym::realloc => CodegenFnAttrFlags::REALLOCATOR,
+                sym::alloc_zeroed => CodegenFnAttrFlags::ALLOCATOR_ZEROED,
+                _ => unreachable!("Unknown allocator method!"),
+            };
+
+            let mut attrs = CodegenFnAttrs::new();
+            attrs.flags |= alloc_attr_flag;
+            create_wrapper_function(
+                tcx,
+                &cx,
+                &from_name,
+                Some(&to_name),
+                &args,
+                output,
+                false,
+                &attrs,
+            );
         }
     }
 
@@ -72,6 +92,7 @@ pub(crate) unsafe fn codegen(
         &[usize, usize], // size, align
         None,
         true,
+        &CodegenFnAttrs::new(),
     );
 
     unsafe {
@@ -93,6 +114,7 @@ pub(crate) unsafe fn codegen(
             &[],
             None,
             false,
+            &CodegenFnAttrs::new(),
         );
     }
 
@@ -139,6 +161,7 @@ fn create_wrapper_function(
     args: &[&Type],
     output: Option<&Type>,
     no_return: bool,
+    attrs: &CodegenFnAttrs,
 ) {
     let ty = cx.type_func(args, output.unwrap_or_else(|| cx.type_void()));
     let llfn = declare_simple_fn(
@@ -150,8 +173,7 @@ fn create_wrapper_function(
         ty,
     );
 
-    let attrs = CodegenFnAttrs::new();
-    llfn_attrs_from_instance(cx, tcx, llfn, &attrs, None);
+    llfn_attrs_from_instance(cx, tcx, llfn, attrs, None);
 
     let no_return = if no_return {
         // -> ! DIFlagNoReturn

From 2e63708d39553ed882a20a198cdc0f269bb6cd30 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 29 Sep 2025 13:43:25 +0200
Subject: [PATCH 1546/1889] Improve code comments

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

diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index d4f0a196eda8d..e4d33416883cb 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -1084,7 +1084,7 @@ pub(crate) fn extract_cfg_from_attrs<'a, I: Iterator<Item = &'a hir::Attribute>
 
     let mut changed_auto_active_status = None;
 
-    // First we get all `doc(auto_cfg)` attributes.
+    // We get all `doc(auto_cfg)`, `cfg` and `target_feature` attributes.
     for attr in attrs {
         if let Some(ident) = attr.ident()
             && ident.name == sym::doc
@@ -1146,11 +1146,9 @@ pub(crate) fn extract_cfg_from_attrs<'a, I: Iterator<Item = &'a hir::Attribute>
                     }
                 }
             }
-        // If there is no `doc(cfg())`, then we retrieve the `cfg()` attributes (because
-        // `doc(cfg())` overrides `cfg()`).
         } else if let hir::Attribute::Parsed(AttributeKind::TargetFeature { features, .. }) = attr {
-            // treat #[target_feature(enable = "feat")] attributes as if they were
-            // #[doc(cfg(target_feature = "feat"))] attributes as well
+            // Treat `#[target_feature(enable = "feat")]` attributes as if they were
+            // `#[doc(cfg(target_feature = "feat"))]` attributes as well.
             for (feature, _) in features {
                 cfg_info.current_cfg &= Cfg::Cfg(sym::target_feature, Some(*feature));
             }

From f6e223cdb5b848f2eca1ce06aac9f9f1b764abf2 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Mon, 29 Sep 2025 00:21:27 +0200
Subject: [PATCH 1547/1889] clean-up

---
 clippy_lints/src/methods/mod.rs               | 181 ++++++++----------
 .../src/methods/wrong_self_convention.rs      |  36 ++--
 2 files changed, 97 insertions(+), 120 deletions(-)

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index a1cdab9cc491b..195d91c4e66b1 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -149,13 +149,12 @@ use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::macros::FormatArgsStorage;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::ty::{contains_ty_adt_constructor_opaque, implements_trait, is_copy, is_type_diagnostic_item};
+use clippy_utils::ty::{contains_ty_adt_constructor_opaque, implements_trait, is_copy};
 use clippy_utils::{contains_return, is_bool, is_trait_method, iter_input_pats, peel_blocks, return_ty, sym};
 pub use path_ends_with_ext::DEFAULT_ALLOWED_DOTFILES;
 use rustc_abi::ExternAbi;
 use rustc_data_structures::fx::FxHashSet;
-use rustc_hir as hir;
-use rustc_hir::{Expr, ExprKind, Node, Stmt, StmtKind, TraitItem, TraitItemKind};
+use rustc_hir::{self as hir, Expr, ExprKind, Node, Stmt, StmtKind, TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty::{self, TraitRef, Ty};
 use rustc_session::impl_lint_pass;
@@ -4889,13 +4888,13 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
         if impl_item.span.in_external_macro(cx.sess().source_map()) {
             return;
         }
-        let name = impl_item.ident.name;
-        let parent = cx.tcx.hir_get_parent_item(impl_item.hir_id()).def_id;
-        let item = cx.tcx.hir_expect_item(parent);
-        let self_ty = cx.tcx.type_of(item.owner_id).instantiate_identity();
-
-        let implements_trait = matches!(item.kind, hir::ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }));
         if let hir::ImplItemKind::Fn(ref sig, id) = impl_item.kind {
+            let name = impl_item.ident.name;
+            let parent = cx.tcx.hir_get_parent_item(impl_item.hir_id()).def_id;
+            let item = cx.tcx.hir_expect_item(parent);
+            let self_ty = cx.tcx.type_of(item.owner_id).instantiate_identity();
+
+            let implements_trait = matches!(item.kind, hir::ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }));
             let method_sig = cx.tcx.fn_sig(impl_item.owner_id).instantiate_identity();
             let method_sig = cx.tcx.instantiate_bound_regions_with_erased(method_sig);
             let first_arg_ty_opt = method_sig.inputs().iter().next().copied();
@@ -4908,9 +4907,8 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                         && method_config.output_type.matches(&sig.decl.output)
                         // in case there is no first arg, since we already have checked the number of arguments
                         // it's should be always true
-                        && first_arg_ty_opt.is_none_or(|first_arg_ty| method_config
-                            .self_kind.matches(cx, self_ty, first_arg_ty)
-                            )
+                        && first_arg_ty_opt
+                            .is_none_or(|first_arg_ty| method_config.self_kind.matches(cx, self_ty, first_arg_ty))
                         && fn_header_equals(method_config.fn_header, sig.header)
                         && method_config.lifetime_param_cond(impl_item)
                     {
@@ -4948,21 +4946,14 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                     false,
                 );
             }
-        }
-
-        // if this impl block implements a trait, lint in trait definition instead
-        if implements_trait {
-            return;
-        }
 
-        if let hir::ImplItemKind::Fn(_, _) = impl_item.kind {
-            let ret_ty = return_ty(cx, impl_item.owner_id);
-
-            if contains_ty_adt_constructor_opaque(cx, ret_ty, self_ty) {
-                return;
-            }
-
-            if name == sym::new && ret_ty != self_ty {
+            // if this impl block implements a trait, lint in trait definition instead
+            if !implements_trait
+                && impl_item.ident.name == sym::new
+                && let ret_ty = return_ty(cx, impl_item.owner_id)
+                && ret_ty != self_ty
+                && !contains_ty_adt_constructor_opaque(cx, ret_ty, self_ty)
+            {
                 span_lint(
                     cx,
                     NEW_RET_NO_SELF,
@@ -4978,41 +4969,41 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             return;
         }
 
-        if let TraitItemKind::Fn(ref sig, _) = item.kind
-            && sig.decl.implicit_self.has_implicit_self()
-            && let Some(first_arg_hir_ty) = sig.decl.inputs.first()
-            && let Some(&first_arg_ty) = cx
-                .tcx
-                .fn_sig(item.owner_id)
-                .instantiate_identity()
-                .inputs()
-                .skip_binder()
-                .first()
-        {
-            let self_ty = TraitRef::identity(cx.tcx, item.owner_id.to_def_id()).self_ty();
-            wrong_self_convention::check(
-                cx,
-                item.ident.name,
-                self_ty,
-                first_arg_ty,
-                first_arg_hir_ty.span,
-                false,
-                true,
-            );
-        }
+        if let TraitItemKind::Fn(ref sig, _) = item.kind {
+            if sig.decl.implicit_self.has_implicit_self()
+                && let Some(first_arg_hir_ty) = sig.decl.inputs.first()
+                && let Some(&first_arg_ty) = cx
+                    .tcx
+                    .fn_sig(item.owner_id)
+                    .instantiate_identity()
+                    .inputs()
+                    .skip_binder()
+                    .first()
+            {
+                let self_ty = TraitRef::identity(cx.tcx, item.owner_id.to_def_id()).self_ty();
+                wrong_self_convention::check(
+                    cx,
+                    item.ident.name,
+                    self_ty,
+                    first_arg_ty,
+                    first_arg_hir_ty.span,
+                    false,
+                    true,
+                );
+            }
 
-        if item.ident.name == sym::new
-            && let TraitItemKind::Fn(_, _) = item.kind
-            && let ret_ty = return_ty(cx, item.owner_id)
-            && let self_ty = TraitRef::identity(cx.tcx, item.owner_id.to_def_id()).self_ty()
-            && !ret_ty.contains(self_ty)
-        {
-            span_lint(
-                cx,
-                NEW_RET_NO_SELF,
-                item.span,
-                "methods called `new` usually return `Self`",
-            );
+            if item.ident.name == sym::new
+                && let ret_ty = return_ty(cx, item.owner_id)
+                && let self_ty = TraitRef::identity(cx.tcx, item.owner_id.to_def_id()).self_ty()
+                && !ret_ty.contains(self_ty)
+            {
+                span_lint(
+                    cx,
+                    NEW_RET_NO_SELF,
+                    item.span,
+                    "methods called `new` usually return `Self`",
+                );
+            }
         }
     }
 }
@@ -5776,36 +5767,36 @@ impl ShouldImplTraitCase {
 
 #[rustfmt::skip]
 const TRAIT_METHODS: [ShouldImplTraitCase; 30] = [
-    ShouldImplTraitCase::new("std::ops::Add", sym::add,  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::convert::AsMut", sym::as_mut,  1,  FN_HEADER,  SelfKind::RefMut,  OutType::Ref, true),
-    ShouldImplTraitCase::new("std::convert::AsRef", sym::as_ref,  1,  FN_HEADER,  SelfKind::Ref,  OutType::Ref, true),
-    ShouldImplTraitCase::new("std::ops::BitAnd", sym::bitand,  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::ops::BitOr", sym::bitor,  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::ops::BitXor", sym::bitxor,  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::borrow::Borrow", sym::borrow,  1,  FN_HEADER,  SelfKind::Ref,  OutType::Ref, true),
-    ShouldImplTraitCase::new("std::borrow::BorrowMut", sym::borrow_mut,  1,  FN_HEADER,  SelfKind::RefMut,  OutType::Ref, true),
-    ShouldImplTraitCase::new("std::clone::Clone", sym::clone,  1,  FN_HEADER,  SelfKind::Ref,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::cmp::Ord", sym::cmp,  2,  FN_HEADER,  SelfKind::Ref,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::default::Default", kw::Default,  0,  FN_HEADER,  SelfKind::No,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::ops::Deref", sym::deref,  1,  FN_HEADER,  SelfKind::Ref,  OutType::Ref, true),
-    ShouldImplTraitCase::new("std::ops::DerefMut", sym::deref_mut,  1,  FN_HEADER,  SelfKind::RefMut,  OutType::Ref, true),
-    ShouldImplTraitCase::new("std::ops::Div", sym::div,  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::ops::Drop", sym::drop,  1,  FN_HEADER,  SelfKind::RefMut,  OutType::Unit, true),
-    ShouldImplTraitCase::new("std::cmp::PartialEq", sym::eq,  2,  FN_HEADER,  SelfKind::Ref,  OutType::Bool, true),
-    ShouldImplTraitCase::new("std::iter::FromIterator", sym::from_iter,  1,  FN_HEADER,  SelfKind::No,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::str::FromStr", sym::from_str,  1,  FN_HEADER,  SelfKind::No,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::hash::Hash", sym::hash,  2,  FN_HEADER,  SelfKind::Ref,  OutType::Unit, true),
-    ShouldImplTraitCase::new("std::ops::Index", sym::index,  2,  FN_HEADER,  SelfKind::Ref,  OutType::Ref, true),
-    ShouldImplTraitCase::new("std::ops::IndexMut", sym::index_mut,  2,  FN_HEADER,  SelfKind::RefMut,  OutType::Ref, true),
-    ShouldImplTraitCase::new("std::iter::IntoIterator", sym::into_iter,  1,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::ops::Mul", sym::mul,  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::ops::Neg", sym::neg,  1,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::iter::Iterator", sym::next,  1,  FN_HEADER,  SelfKind::RefMut,  OutType::Any, false),
-    ShouldImplTraitCase::new("std::ops::Not", sym::not,  1,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::ops::Rem", sym::rem,  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::ops::Shl", sym::shl,  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::ops::Shr", sym::shr,  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::ops::Sub", sym::sub,  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::ops::Add",           sym::add,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::convert::AsMut",     sym::as_mut,     1,  FN_HEADER, SelfKind::RefMut, OutType::Ref,  true ),
+    ShouldImplTraitCase::new("std::convert::AsRef",     sym::as_ref,     1,  FN_HEADER, SelfKind::Ref,    OutType::Ref,  true ),
+    ShouldImplTraitCase::new("std::ops::BitAnd",        sym::bitand,     2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::ops::BitOr",         sym::bitor,      2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::ops::BitXor",        sym::bitxor,     2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::borrow::Borrow",     sym::borrow,     1,  FN_HEADER, SelfKind::Ref,    OutType::Ref,  true ),
+    ShouldImplTraitCase::new("std::borrow::BorrowMut",  sym::borrow_mut, 1,  FN_HEADER, SelfKind::RefMut, OutType::Ref,  true ),
+    ShouldImplTraitCase::new("std::clone::Clone",       sym::clone,      1,  FN_HEADER, SelfKind::Ref,    OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::cmp::Ord",           sym::cmp,        2,  FN_HEADER, SelfKind::Ref,    OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::default::Default",   kw::Default,     0,  FN_HEADER, SelfKind::No,     OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::ops::Deref",         sym::deref,      1,  FN_HEADER, SelfKind::Ref,    OutType::Ref,  true ),
+    ShouldImplTraitCase::new("std::ops::DerefMut",      sym::deref_mut,  1,  FN_HEADER, SelfKind::RefMut, OutType::Ref,  true ),
+    ShouldImplTraitCase::new("std::ops::Div",           sym::div,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::ops::Drop",          sym::drop,       1,  FN_HEADER, SelfKind::RefMut, OutType::Unit, true ),
+    ShouldImplTraitCase::new("std::cmp::PartialEq",     sym::eq,         2,  FN_HEADER, SelfKind::Ref,    OutType::Bool, true ),
+    ShouldImplTraitCase::new("std::iter::FromIterator", sym::from_iter,  1,  FN_HEADER, SelfKind::No,     OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::str::FromStr",       sym::from_str,   1,  FN_HEADER, SelfKind::No,     OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::hash::Hash",         sym::hash,       2,  FN_HEADER, SelfKind::Ref,    OutType::Unit, true ),
+    ShouldImplTraitCase::new("std::ops::Index",         sym::index,      2,  FN_HEADER, SelfKind::Ref,    OutType::Ref,  true ),
+    ShouldImplTraitCase::new("std::ops::IndexMut",      sym::index_mut,  2,  FN_HEADER, SelfKind::RefMut, OutType::Ref,  true ),
+    ShouldImplTraitCase::new("std::iter::IntoIterator", sym::into_iter,  1,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::ops::Mul",           sym::mul,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::ops::Neg",           sym::neg,        1,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::iter::Iterator",     sym::next,       1,  FN_HEADER, SelfKind::RefMut, OutType::Any,  false),
+    ShouldImplTraitCase::new("std::ops::Not",           sym::not,        1,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::ops::Rem",           sym::rem,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::ops::Shl",           sym::shl,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::ops::Shr",           sym::shr,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::ops::Sub",           sym::sub,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
 ];
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
@@ -5823,12 +5814,10 @@ impl SelfKind {
                 true
             } else if let Some(boxed_ty) = ty.boxed_ty() {
                 boxed_ty == parent_ty
-            } else if is_type_diagnostic_item(cx, ty, sym::Rc) || is_type_diagnostic_item(cx, ty, sym::Arc) {
-                if let ty::Adt(_, args) = ty.kind() {
-                    args.types().next() == Some(parent_ty)
-                } else {
-                    false
-                }
+            } else if let ty::Adt(adt, args) = ty.kind()
+                && matches!(cx.tcx.get_diagnostic_name(adt.did()), Some(sym::Rc | sym::Arc))
+            {
+                args.types().next() == Some(parent_ty)
             } else {
                 false
             }
diff --git a/clippy_lints/src/methods/wrong_self_convention.rs b/clippy_lints/src/methods/wrong_self_convention.rs
index ad9b3c3645425..249119d549bac 100644
--- a/clippy_lints/src/methods/wrong_self_convention.rs
+++ b/clippy_lints/src/methods/wrong_self_convention.rs
@@ -1,6 +1,7 @@
 use crate::methods::SelfKind;
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::is_copy;
+use itertools::Itertools;
 use rustc_lint::LateContext;
 use rustc_middle::ty::Ty;
 use rustc_span::{Span, Symbol};
@@ -61,20 +62,20 @@ impl Convention {
 impl fmt::Display for Convention {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         match *self {
-            Self::Eq(this) => format!("`{this}`").fmt(f),
-            Self::StartsWith(this) => format!("`{this}*`").fmt(f),
-            Self::EndsWith(this) => format!("`*{this}`").fmt(f),
-            Self::NotEndsWith(this) => format!("`~{this}`").fmt(f),
+            Self::Eq(this) => write!(f, "`{this}`"),
+            Self::StartsWith(this) => write!(f, "`{this}*`"),
+            Self::EndsWith(this) => write!(f, "`*{this}`"),
+            Self::NotEndsWith(this) => write!(f, "`~{this}`"),
             Self::IsSelfTypeCopy(is_true) => {
-                format!("`self` type is{} `Copy`", if is_true { "" } else { " not" }).fmt(f)
+                write!(f, "`self` type is{} `Copy`", if is_true { "" } else { " not" })
             },
             Self::ImplementsTrait(is_true) => {
                 let (negation, s_suffix) = if is_true { ("", "s") } else { (" does not", "") };
-                format!("method{negation} implement{s_suffix} a trait").fmt(f)
+                write!(f, "method{negation} implement{s_suffix} a trait")
             },
             Self::IsTraitItem(is_true) => {
                 let suffix = if is_true { " is" } else { " is not" };
-                format!("method{suffix} a trait item").fmt(f)
+                write!(f, "method{suffix} a trait item")
             },
         }
     }
@@ -115,18 +116,9 @@ pub(super) fn check<'tcx>(
 
                     let s = conventions
                         .iter()
-                        .filter_map(|conv| {
-                            if (cut_ends_with_conv && matches!(conv, Convention::NotEndsWith(_)))
-                                || matches!(conv, Convention::ImplementsTrait(_))
-                                || matches!(conv, Convention::IsTraitItem(_))
-                            {
-                                None
-                            } else {
-                                Some(conv.to_string())
-                            }
-                        })
-                        .collect::<Vec<_>>()
-                        .join(" and ");
+                        .filter(|conv| !(cut_ends_with_conv && matches!(conv, Convention::NotEndsWith(_))))
+                        .filter(|conv| !matches!(conv, Convention::ImplementsTrait(_) | Convention::IsTraitItem(_)))
+                        .format(" and ");
 
                     format!("methods with the following characteristics: ({s})")
                 } else {
@@ -140,11 +132,7 @@ pub(super) fn check<'tcx>(
                 first_arg_span,
                 format!(
                     "{suggestion} usually take {}",
-                    &self_kinds
-                        .iter()
-                        .map(|k| k.description())
-                        .collect::<Vec<_>>()
-                        .join(" or ")
+                    self_kinds.iter().map(|k| k.description()).format(" or ")
                 ),
                 None,
                 "consider choosing a less ambiguous name",

From 26a9a371ee3fa8731815cbff5b397d66457afc4c Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sun, 28 Sep 2025 23:46:30 +0200
Subject: [PATCH 1548/1889] clean-up: extract `should_implement_trait`

Also put `SelfKind` into `lib.rs`, since it's shared with
`wrong_self_convention` -- not `utils.rs`, because it's not really a
utility function
---
 clippy_lints/src/methods/lib.rs               |  70 ++++++
 clippy_lints/src/methods/mod.rs               | 229 +-----------------
 .../src/methods/should_implement_trait.rs     | 165 +++++++++++++
 .../src/methods/wrong_self_convention.rs      |   2 +-
 4 files changed, 247 insertions(+), 219 deletions(-)
 create mode 100644 clippy_lints/src/methods/lib.rs
 create mode 100644 clippy_lints/src/methods/should_implement_trait.rs

diff --git a/clippy_lints/src/methods/lib.rs b/clippy_lints/src/methods/lib.rs
new file mode 100644
index 0000000000000..84038283bcf8f
--- /dev/null
+++ b/clippy_lints/src/methods/lib.rs
@@ -0,0 +1,70 @@
+use clippy_utils::sym;
+use clippy_utils::ty::{implements_trait, is_copy};
+use rustc_hir::Mutability;
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, Ty};
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub(super) enum SelfKind {
+    Value,
+    Ref,
+    RefMut,
+    No, // When we want the first argument type to be different than `Self`
+}
+
+impl SelfKind {
+    pub(super) fn matches<'a>(self, cx: &LateContext<'a>, parent_ty: Ty<'a>, ty: Ty<'a>) -> bool {
+        fn matches_value<'a>(cx: &LateContext<'a>, parent_ty: Ty<'a>, ty: Ty<'a>) -> bool {
+            if ty == parent_ty {
+                true
+            } else if let Some(boxed_ty) = ty.boxed_ty() {
+                boxed_ty == parent_ty
+            } else if let ty::Adt(adt_def, args) = ty.kind()
+                && matches!(cx.tcx.get_diagnostic_name(adt_def.did()), Some(sym::Rc | sym::Arc))
+            {
+                args.types().next() == Some(parent_ty)
+            } else {
+                false
+            }
+        }
+
+        fn matches_ref<'a>(cx: &LateContext<'a>, mutability: Mutability, parent_ty: Ty<'a>, ty: Ty<'a>) -> bool {
+            if let ty::Ref(_, t, m) = *ty.kind() {
+                return m == mutability && t == parent_ty;
+            }
+
+            let trait_sym = match mutability {
+                Mutability::Not => sym::AsRef,
+                Mutability::Mut => sym::AsMut,
+            };
+
+            let Some(trait_def_id) = cx.tcx.get_diagnostic_item(trait_sym) else {
+                return false;
+            };
+            implements_trait(cx, ty, trait_def_id, &[parent_ty.into()])
+        }
+
+        fn matches_none<'a>(cx: &LateContext<'a>, parent_ty: Ty<'a>, ty: Ty<'a>) -> bool {
+            !matches_value(cx, parent_ty, ty)
+                && !matches_ref(cx, Mutability::Not, parent_ty, ty)
+                && !matches_ref(cx, Mutability::Mut, parent_ty, ty)
+        }
+
+        match self {
+            Self::Value => matches_value(cx, parent_ty, ty),
+            Self::Ref => matches_ref(cx, Mutability::Not, parent_ty, ty) || ty == parent_ty && is_copy(cx, ty),
+            Self::RefMut => matches_ref(cx, Mutability::Mut, parent_ty, ty),
+            Self::No => matches_none(cx, parent_ty, ty),
+        }
+    }
+
+    #[must_use]
+    pub(super) fn description(self) -> &'static str {
+        match self {
+            Self::Value => "`self` by value",
+            Self::Ref => "`self` by reference",
+            Self::RefMut => "`self` by mutable reference",
+            Self::No => "no `self`",
+        }
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 195d91c4e66b1..8c2948e4a74e6 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -55,6 +55,7 @@ mod iter_skip_zero;
 mod iter_with_drain;
 mod iterator_step_by_zero;
 mod join_absolute_paths;
+mod lib;
 mod manual_c_str_literals;
 mod manual_contains;
 mod manual_inspect;
@@ -102,6 +103,7 @@ mod return_and_then;
 mod search_is_some;
 mod seek_from_current;
 mod seek_to_start_instead_of_rewind;
+mod should_implement_trait;
 mod single_char_add_str;
 mod skip_while_next;
 mod sliced_string_as_bytes;
@@ -146,19 +148,18 @@ mod zst_offset;
 
 use clippy_config::Conf;
 use clippy_utils::consts::{ConstEvalCtxt, Constant};
-use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
+use clippy_utils::diagnostics::span_lint;
 use clippy_utils::macros::FormatArgsStorage;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::ty::{contains_ty_adt_constructor_opaque, implements_trait, is_copy};
-use clippy_utils::{contains_return, is_bool, is_trait_method, iter_input_pats, peel_blocks, return_ty, sym};
+use clippy_utils::ty::contains_ty_adt_constructor_opaque;
+use clippy_utils::{contains_return, is_trait_method, iter_input_pats, peel_blocks, return_ty, sym};
 pub use path_ends_with_ext::DEFAULT_ALLOWED_DOTFILES;
-use rustc_abi::ExternAbi;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::{self as hir, Expr, ExprKind, Node, Stmt, StmtKind, TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::ty::{self, TraitRef, Ty};
+use rustc_middle::ty::TraitRef;
 use rustc_session::impl_lint_pass;
-use rustc_span::{Span, Symbol, kw};
+use rustc_span::{Span, Symbol};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -4888,47 +4889,17 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
         if impl_item.span.in_external_macro(cx.sess().source_map()) {
             return;
         }
+
         if let hir::ImplItemKind::Fn(ref sig, id) = impl_item.kind {
-            let name = impl_item.ident.name;
             let parent = cx.tcx.hir_get_parent_item(impl_item.hir_id()).def_id;
             let item = cx.tcx.hir_expect_item(parent);
             let self_ty = cx.tcx.type_of(item.owner_id).instantiate_identity();
-
             let implements_trait = matches!(item.kind, hir::ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }));
+
             let method_sig = cx.tcx.fn_sig(impl_item.owner_id).instantiate_identity();
             let method_sig = cx.tcx.instantiate_bound_regions_with_erased(method_sig);
             let first_arg_ty_opt = method_sig.inputs().iter().next().copied();
-            // if this impl block implements a trait, lint in trait definition instead
-            if !implements_trait && cx.effective_visibilities.is_exported(impl_item.owner_id.def_id) {
-                // check missing trait implementations
-                for method_config in &TRAIT_METHODS {
-                    if name == method_config.method_name
-                        && sig.decl.inputs.len() == method_config.param_count
-                        && method_config.output_type.matches(&sig.decl.output)
-                        // in case there is no first arg, since we already have checked the number of arguments
-                        // it's should be always true
-                        && first_arg_ty_opt
-                            .is_none_or(|first_arg_ty| method_config.self_kind.matches(cx, self_ty, first_arg_ty))
-                        && fn_header_equals(method_config.fn_header, sig.header)
-                        && method_config.lifetime_param_cond(impl_item)
-                    {
-                        span_lint_and_help(
-                            cx,
-                            SHOULD_IMPLEMENT_TRAIT,
-                            impl_item.span,
-                            format!(
-                                "method `{}` can be confused for the standard trait method `{}::{}`",
-                                method_config.method_name, method_config.trait_name, method_config.method_name
-                            ),
-                            None,
-                            format!(
-                                "consider implementing the trait `{}` or choosing a less ambiguous method name",
-                                method_config.trait_name
-                            ),
-                        );
-                    }
-                }
-            }
+            should_implement_trait::check_impl_item(cx, impl_item, self_ty, implements_trait, first_arg_ty_opt, sig);
 
             if sig.decl.implicit_self.has_implicit_self()
                 && !(self.avoid_breaking_exported_api
@@ -4938,7 +4909,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             {
                 wrong_self_convention::check(
                     cx,
-                    name,
+                    impl_item.ident.name,
                     self_ty,
                     first_arg_ty,
                     first_arg.pat.span,
@@ -5711,181 +5682,3 @@ fn lint_binary_expr_with_method_call(cx: &LateContext<'_>, info: &mut BinaryExpr
     lint_with_both_lhs_and_rhs!(chars_next_cmp_with_unwrap::check, cx, info);
     lint_with_both_lhs_and_rhs!(chars_last_cmp_with_unwrap::check, cx, info);
 }
-
-const FN_HEADER: hir::FnHeader = hir::FnHeader {
-    safety: hir::HeaderSafety::Normal(hir::Safety::Safe),
-    constness: hir::Constness::NotConst,
-    asyncness: hir::IsAsync::NotAsync,
-    abi: ExternAbi::Rust,
-};
-
-struct ShouldImplTraitCase {
-    trait_name: &'static str,
-    method_name: Symbol,
-    param_count: usize,
-    fn_header: hir::FnHeader,
-    // implicit self kind expected (none, self, &self, ...)
-    self_kind: SelfKind,
-    // checks against the output type
-    output_type: OutType,
-    // certain methods with explicit lifetimes can't implement the equivalent trait method
-    lint_explicit_lifetime: bool,
-}
-impl ShouldImplTraitCase {
-    const fn new(
-        trait_name: &'static str,
-        method_name: Symbol,
-        param_count: usize,
-        fn_header: hir::FnHeader,
-        self_kind: SelfKind,
-        output_type: OutType,
-        lint_explicit_lifetime: bool,
-    ) -> ShouldImplTraitCase {
-        ShouldImplTraitCase {
-            trait_name,
-            method_name,
-            param_count,
-            fn_header,
-            self_kind,
-            output_type,
-            lint_explicit_lifetime,
-        }
-    }
-
-    fn lifetime_param_cond(&self, impl_item: &hir::ImplItem<'_>) -> bool {
-        self.lint_explicit_lifetime
-            || !impl_item.generics.params.iter().any(|p| {
-                matches!(
-                    p.kind,
-                    hir::GenericParamKind::Lifetime {
-                        kind: hir::LifetimeParamKind::Explicit
-                    }
-                )
-            })
-    }
-}
-
-#[rustfmt::skip]
-const TRAIT_METHODS: [ShouldImplTraitCase; 30] = [
-    ShouldImplTraitCase::new("std::ops::Add",           sym::add,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::convert::AsMut",     sym::as_mut,     1,  FN_HEADER, SelfKind::RefMut, OutType::Ref,  true ),
-    ShouldImplTraitCase::new("std::convert::AsRef",     sym::as_ref,     1,  FN_HEADER, SelfKind::Ref,    OutType::Ref,  true ),
-    ShouldImplTraitCase::new("std::ops::BitAnd",        sym::bitand,     2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::ops::BitOr",         sym::bitor,      2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::ops::BitXor",        sym::bitxor,     2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::borrow::Borrow",     sym::borrow,     1,  FN_HEADER, SelfKind::Ref,    OutType::Ref,  true ),
-    ShouldImplTraitCase::new("std::borrow::BorrowMut",  sym::borrow_mut, 1,  FN_HEADER, SelfKind::RefMut, OutType::Ref,  true ),
-    ShouldImplTraitCase::new("std::clone::Clone",       sym::clone,      1,  FN_HEADER, SelfKind::Ref,    OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::cmp::Ord",           sym::cmp,        2,  FN_HEADER, SelfKind::Ref,    OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::default::Default",   kw::Default,     0,  FN_HEADER, SelfKind::No,     OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::ops::Deref",         sym::deref,      1,  FN_HEADER, SelfKind::Ref,    OutType::Ref,  true ),
-    ShouldImplTraitCase::new("std::ops::DerefMut",      sym::deref_mut,  1,  FN_HEADER, SelfKind::RefMut, OutType::Ref,  true ),
-    ShouldImplTraitCase::new("std::ops::Div",           sym::div,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::ops::Drop",          sym::drop,       1,  FN_HEADER, SelfKind::RefMut, OutType::Unit, true ),
-    ShouldImplTraitCase::new("std::cmp::PartialEq",     sym::eq,         2,  FN_HEADER, SelfKind::Ref,    OutType::Bool, true ),
-    ShouldImplTraitCase::new("std::iter::FromIterator", sym::from_iter,  1,  FN_HEADER, SelfKind::No,     OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::str::FromStr",       sym::from_str,   1,  FN_HEADER, SelfKind::No,     OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::hash::Hash",         sym::hash,       2,  FN_HEADER, SelfKind::Ref,    OutType::Unit, true ),
-    ShouldImplTraitCase::new("std::ops::Index",         sym::index,      2,  FN_HEADER, SelfKind::Ref,    OutType::Ref,  true ),
-    ShouldImplTraitCase::new("std::ops::IndexMut",      sym::index_mut,  2,  FN_HEADER, SelfKind::RefMut, OutType::Ref,  true ),
-    ShouldImplTraitCase::new("std::iter::IntoIterator", sym::into_iter,  1,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::ops::Mul",           sym::mul,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::ops::Neg",           sym::neg,        1,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::iter::Iterator",     sym::next,       1,  FN_HEADER, SelfKind::RefMut, OutType::Any,  false),
-    ShouldImplTraitCase::new("std::ops::Not",           sym::not,        1,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::ops::Rem",           sym::rem,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::ops::Shl",           sym::shl,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::ops::Shr",           sym::shr,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::ops::Sub",           sym::sub,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
-];
-
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-enum SelfKind {
-    Value,
-    Ref,
-    RefMut,
-    No, // When we want the first argument type to be different than `Self`
-}
-
-impl SelfKind {
-    fn matches<'a>(self, cx: &LateContext<'a>, parent_ty: Ty<'a>, ty: Ty<'a>) -> bool {
-        fn matches_value<'a>(cx: &LateContext<'a>, parent_ty: Ty<'a>, ty: Ty<'a>) -> bool {
-            if ty == parent_ty {
-                true
-            } else if let Some(boxed_ty) = ty.boxed_ty() {
-                boxed_ty == parent_ty
-            } else if let ty::Adt(adt, args) = ty.kind()
-                && matches!(cx.tcx.get_diagnostic_name(adt.did()), Some(sym::Rc | sym::Arc))
-            {
-                args.types().next() == Some(parent_ty)
-            } else {
-                false
-            }
-        }
-
-        fn matches_ref<'a>(cx: &LateContext<'a>, mutability: hir::Mutability, parent_ty: Ty<'a>, ty: Ty<'a>) -> bool {
-            if let ty::Ref(_, t, m) = *ty.kind() {
-                return m == mutability && t == parent_ty;
-            }
-
-            let trait_sym = match mutability {
-                hir::Mutability::Not => sym::AsRef,
-                hir::Mutability::Mut => sym::AsMut,
-            };
-
-            let Some(trait_def_id) = cx.tcx.get_diagnostic_item(trait_sym) else {
-                return false;
-            };
-            implements_trait(cx, ty, trait_def_id, &[parent_ty.into()])
-        }
-
-        fn matches_none<'a>(cx: &LateContext<'a>, parent_ty: Ty<'a>, ty: Ty<'a>) -> bool {
-            !matches_value(cx, parent_ty, ty)
-                && !matches_ref(cx, hir::Mutability::Not, parent_ty, ty)
-                && !matches_ref(cx, hir::Mutability::Mut, parent_ty, ty)
-        }
-
-        match self {
-            Self::Value => matches_value(cx, parent_ty, ty),
-            Self::Ref => matches_ref(cx, hir::Mutability::Not, parent_ty, ty) || ty == parent_ty && is_copy(cx, ty),
-            Self::RefMut => matches_ref(cx, hir::Mutability::Mut, parent_ty, ty),
-            Self::No => matches_none(cx, parent_ty, ty),
-        }
-    }
-
-    #[must_use]
-    fn description(self) -> &'static str {
-        match self {
-            Self::Value => "`self` by value",
-            Self::Ref => "`self` by reference",
-            Self::RefMut => "`self` by mutable reference",
-            Self::No => "no `self`",
-        }
-    }
-}
-
-#[derive(Clone, Copy)]
-enum OutType {
-    Unit,
-    Bool,
-    Any,
-    Ref,
-}
-
-impl OutType {
-    fn matches(self, ty: &hir::FnRetTy<'_>) -> bool {
-        let is_unit = |ty: &hir::Ty<'_>| matches!(ty.kind, hir::TyKind::Tup(&[]));
-        match (self, ty) {
-            (Self::Unit, &hir::FnRetTy::DefaultReturn(_)) => true,
-            (Self::Unit, &hir::FnRetTy::Return(ty)) if is_unit(ty) => true,
-            (Self::Bool, &hir::FnRetTy::Return(ty)) if is_bool(ty) => true,
-            (Self::Any, &hir::FnRetTy::Return(ty)) if !is_unit(ty) => true,
-            (Self::Ref, &hir::FnRetTy::Return(ty)) => matches!(ty.kind, hir::TyKind::Ref(_, _)),
-            _ => false,
-        }
-    }
-}
-
-fn fn_header_equals(expected: hir::FnHeader, actual: hir::FnHeader) -> bool {
-    expected.constness == actual.constness && expected.safety == actual.safety && expected.asyncness == actual.asyncness
-}
diff --git a/clippy_lints/src/methods/should_implement_trait.rs b/clippy_lints/src/methods/should_implement_trait.rs
new file mode 100644
index 0000000000000..3f6600159a2f0
--- /dev/null
+++ b/clippy_lints/src/methods/should_implement_trait.rs
@@ -0,0 +1,165 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::{is_bool, sym};
+use rustc_abi::ExternAbi;
+use rustc_hir as hir;
+use rustc_hir::{FnSig, ImplItem};
+use rustc_lint::LateContext;
+use rustc_middle::ty::Ty;
+use rustc_span::{Symbol, kw};
+
+use super::SHOULD_IMPLEMENT_TRAIT;
+use super::lib::SelfKind;
+
+pub(super) fn check_impl_item<'tcx>(
+    cx: &LateContext<'tcx>,
+    impl_item: &'tcx ImplItem<'_>,
+    self_ty: Ty<'tcx>,
+    impl_implements_trait: bool,
+    first_arg_ty_opt: Option<Ty<'tcx>>,
+    sig: &FnSig<'_>,
+) {
+    // if this impl block implements a trait, lint in trait definition instead
+    if !impl_implements_trait && cx.effective_visibilities.is_exported(impl_item.owner_id.def_id) {
+        // check missing trait implementations
+        for method_config in &TRAIT_METHODS {
+            if impl_item.ident.name == method_config.method_name
+                && sig.decl.inputs.len() == method_config.param_count
+                && method_config.output_type.matches(&sig.decl.output)
+                // in case there is no first arg, since we already have checked the number of arguments
+                // it's should be always true
+                && first_arg_ty_opt
+                    .is_none_or(|first_arg_ty| method_config.self_kind.matches(cx, self_ty, first_arg_ty))
+                && fn_header_equals(method_config.fn_header, sig.header)
+                && method_config.lifetime_param_cond(impl_item)
+            {
+                span_lint_and_help(
+                    cx,
+                    SHOULD_IMPLEMENT_TRAIT,
+                    impl_item.span,
+                    format!(
+                        "method `{}` can be confused for the standard trait method `{}::{}`",
+                        method_config.method_name, method_config.trait_name, method_config.method_name
+                    ),
+                    None,
+                    format!(
+                        "consider implementing the trait `{}` or choosing a less ambiguous method name",
+                        method_config.trait_name
+                    ),
+                );
+            }
+        }
+    }
+}
+
+const FN_HEADER: hir::FnHeader = hir::FnHeader {
+    safety: hir::HeaderSafety::Normal(hir::Safety::Safe),
+    constness: hir::Constness::NotConst,
+    asyncness: hir::IsAsync::NotAsync,
+    abi: ExternAbi::Rust,
+};
+
+struct ShouldImplTraitCase {
+    trait_name: &'static str,
+    method_name: Symbol,
+    param_count: usize,
+    fn_header: hir::FnHeader,
+    // implicit self kind expected (none, self, &self, ...)
+    self_kind: SelfKind,
+    // checks against the output type
+    output_type: OutType,
+    // certain methods with explicit lifetimes can't implement the equivalent trait method
+    lint_explicit_lifetime: bool,
+}
+impl ShouldImplTraitCase {
+    const fn new(
+        trait_name: &'static str,
+        method_name: Symbol,
+        param_count: usize,
+        fn_header: hir::FnHeader,
+        self_kind: SelfKind,
+        output_type: OutType,
+        lint_explicit_lifetime: bool,
+    ) -> ShouldImplTraitCase {
+        ShouldImplTraitCase {
+            trait_name,
+            method_name,
+            param_count,
+            fn_header,
+            self_kind,
+            output_type,
+            lint_explicit_lifetime,
+        }
+    }
+
+    fn lifetime_param_cond(&self, impl_item: &ImplItem<'_>) -> bool {
+        self.lint_explicit_lifetime
+            || !impl_item.generics.params.iter().any(|p| {
+                matches!(
+                    p.kind,
+                    hir::GenericParamKind::Lifetime {
+                        kind: hir::LifetimeParamKind::Explicit
+                    }
+                )
+            })
+    }
+}
+
+#[rustfmt::skip]
+const TRAIT_METHODS: [ShouldImplTraitCase; 30] = [
+    ShouldImplTraitCase::new("std::ops::Add",           sym::add,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::convert::AsMut",     sym::as_mut,     1,  FN_HEADER, SelfKind::RefMut, OutType::Ref,  true ),
+    ShouldImplTraitCase::new("std::convert::AsRef",     sym::as_ref,     1,  FN_HEADER, SelfKind::Ref,    OutType::Ref,  true ),
+    ShouldImplTraitCase::new("std::ops::BitAnd",        sym::bitand,     2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::ops::BitOr",         sym::bitor,      2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::ops::BitXor",        sym::bitxor,     2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::borrow::Borrow",     sym::borrow,     1,  FN_HEADER, SelfKind::Ref,    OutType::Ref,  true ),
+    ShouldImplTraitCase::new("std::borrow::BorrowMut",  sym::borrow_mut, 1,  FN_HEADER, SelfKind::RefMut, OutType::Ref,  true ),
+    ShouldImplTraitCase::new("std::clone::Clone",       sym::clone,      1,  FN_HEADER, SelfKind::Ref,    OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::cmp::Ord",           sym::cmp,        2,  FN_HEADER, SelfKind::Ref,    OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::default::Default",   kw::Default,     0,  FN_HEADER, SelfKind::No,     OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::ops::Deref",         sym::deref,      1,  FN_HEADER, SelfKind::Ref,    OutType::Ref,  true ),
+    ShouldImplTraitCase::new("std::ops::DerefMut",      sym::deref_mut,  1,  FN_HEADER, SelfKind::RefMut, OutType::Ref,  true ),
+    ShouldImplTraitCase::new("std::ops::Div",           sym::div,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::ops::Drop",          sym::drop,       1,  FN_HEADER, SelfKind::RefMut, OutType::Unit, true ),
+    ShouldImplTraitCase::new("std::cmp::PartialEq",     sym::eq,         2,  FN_HEADER, SelfKind::Ref,    OutType::Bool, true ),
+    ShouldImplTraitCase::new("std::iter::FromIterator", sym::from_iter,  1,  FN_HEADER, SelfKind::No,     OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::str::FromStr",       sym::from_str,   1,  FN_HEADER, SelfKind::No,     OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::hash::Hash",         sym::hash,       2,  FN_HEADER, SelfKind::Ref,    OutType::Unit, true ),
+    ShouldImplTraitCase::new("std::ops::Index",         sym::index,      2,  FN_HEADER, SelfKind::Ref,    OutType::Ref,  true ),
+    ShouldImplTraitCase::new("std::ops::IndexMut",      sym::index_mut,  2,  FN_HEADER, SelfKind::RefMut, OutType::Ref,  true ),
+    ShouldImplTraitCase::new("std::iter::IntoIterator", sym::into_iter,  1,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::ops::Mul",           sym::mul,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::ops::Neg",           sym::neg,        1,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::iter::Iterator",     sym::next,       1,  FN_HEADER, SelfKind::RefMut, OutType::Any,  false),
+    ShouldImplTraitCase::new("std::ops::Not",           sym::not,        1,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::ops::Rem",           sym::rem,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::ops::Shl",           sym::shl,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::ops::Shr",           sym::shr,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::ops::Sub",           sym::sub,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
+];
+
+#[derive(Clone, Copy)]
+enum OutType {
+    Unit,
+    Bool,
+    Any,
+    Ref,
+}
+
+impl OutType {
+    fn matches(self, ty: &hir::FnRetTy<'_>) -> bool {
+        let is_unit = |ty: &hir::Ty<'_>| matches!(ty.kind, hir::TyKind::Tup(&[]));
+        match (self, ty) {
+            (Self::Unit, &hir::FnRetTy::DefaultReturn(_)) => true,
+            (Self::Unit, &hir::FnRetTy::Return(ty)) if is_unit(ty) => true,
+            (Self::Bool, &hir::FnRetTy::Return(ty)) if is_bool(ty) => true,
+            (Self::Any, &hir::FnRetTy::Return(ty)) if !is_unit(ty) => true,
+            (Self::Ref, &hir::FnRetTy::Return(ty)) => matches!(ty.kind, hir::TyKind::Ref(_, _)),
+            _ => false,
+        }
+    }
+}
+
+fn fn_header_equals(expected: hir::FnHeader, actual: hir::FnHeader) -> bool {
+    expected.constness == actual.constness && expected.safety == actual.safety && expected.asyncness == actual.asyncness
+}
diff --git a/clippy_lints/src/methods/wrong_self_convention.rs b/clippy_lints/src/methods/wrong_self_convention.rs
index 249119d549bac..74b297c13621e 100644
--- a/clippy_lints/src/methods/wrong_self_convention.rs
+++ b/clippy_lints/src/methods/wrong_self_convention.rs
@@ -1,4 +1,3 @@
-use crate::methods::SelfKind;
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::is_copy;
 use itertools::Itertools;
@@ -8,6 +7,7 @@ use rustc_span::{Span, Symbol};
 use std::fmt;
 
 use super::WRONG_SELF_CONVENTION;
+use super::lib::SelfKind;
 
 #[rustfmt::skip]
 const CONVENTIONS: [(&[Convention], &[SelfKind]); 9] = [

From 2d2d143a18249dbdf2709991d95e29e378f0c66c Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Mon, 29 Sep 2025 01:45:13 +0200
Subject: [PATCH 1549/1889] fix: respect crate's edition

---
 .../src/methods/should_implement_trait.rs     |  66 ++++---
 ...tderr => method_list_1.edition2015.stderr} |  30 +--
 .../method_list_1.edition2021.stderr          | 184 ++++++++++++++++++
 tests/ui/should_impl_trait/method_list_1.rs   |   3 +
 .../method_list_2.edition2015.stderr          | 172 ++++++++++++++++
 .../method_list_2.edition2021.stderr          | 184 ++++++++++++++++++
 tests/ui/should_impl_trait/method_list_2.rs   |   5 +-
 7 files changed, 598 insertions(+), 46 deletions(-)
 rename tests/ui/should_impl_trait/{method_list_1.stderr => method_list_1.edition2015.stderr} (86%)
 create mode 100644 tests/ui/should_impl_trait/method_list_1.edition2021.stderr
 create mode 100644 tests/ui/should_impl_trait/method_list_2.edition2015.stderr
 create mode 100644 tests/ui/should_impl_trait/method_list_2.edition2021.stderr

diff --git a/clippy_lints/src/methods/should_implement_trait.rs b/clippy_lints/src/methods/should_implement_trait.rs
index 3f6600159a2f0..5f13b8c7e91df 100644
--- a/clippy_lints/src/methods/should_implement_trait.rs
+++ b/clippy_lints/src/methods/should_implement_trait.rs
@@ -5,6 +5,7 @@ use rustc_hir as hir;
 use rustc_hir::{FnSig, ImplItem};
 use rustc_lint::LateContext;
 use rustc_middle::ty::Ty;
+use rustc_span::edition::Edition::{self, Edition2015, Edition2021};
 use rustc_span::{Symbol, kw};
 
 use super::SHOULD_IMPLEMENT_TRAIT;
@@ -31,6 +32,7 @@ pub(super) fn check_impl_item<'tcx>(
                     .is_none_or(|first_arg_ty| method_config.self_kind.matches(cx, self_ty, first_arg_ty))
                 && fn_header_equals(method_config.fn_header, sig.header)
                 && method_config.lifetime_param_cond(impl_item)
+                && method_config.in_prelude_since <= cx.tcx.sess.edition()
             {
                 span_lint_and_help(
                     cx,
@@ -69,8 +71,10 @@ struct ShouldImplTraitCase {
     output_type: OutType,
     // certain methods with explicit lifetimes can't implement the equivalent trait method
     lint_explicit_lifetime: bool,
+    in_prelude_since: Edition,
 }
 impl ShouldImplTraitCase {
+    #[expect(clippy::too_many_arguments)]
     const fn new(
         trait_name: &'static str,
         method_name: Symbol,
@@ -79,6 +83,7 @@ impl ShouldImplTraitCase {
         self_kind: SelfKind,
         output_type: OutType,
         lint_explicit_lifetime: bool,
+        in_prelude_since: Edition,
     ) -> ShouldImplTraitCase {
         ShouldImplTraitCase {
             trait_name,
@@ -88,6 +93,7 @@ impl ShouldImplTraitCase {
             self_kind,
             output_type,
             lint_explicit_lifetime,
+            in_prelude_since,
         }
     }
 
@@ -106,36 +112,36 @@ impl ShouldImplTraitCase {
 
 #[rustfmt::skip]
 const TRAIT_METHODS: [ShouldImplTraitCase; 30] = [
-    ShouldImplTraitCase::new("std::ops::Add",           sym::add,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::convert::AsMut",     sym::as_mut,     1,  FN_HEADER, SelfKind::RefMut, OutType::Ref,  true ),
-    ShouldImplTraitCase::new("std::convert::AsRef",     sym::as_ref,     1,  FN_HEADER, SelfKind::Ref,    OutType::Ref,  true ),
-    ShouldImplTraitCase::new("std::ops::BitAnd",        sym::bitand,     2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::ops::BitOr",         sym::bitor,      2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::ops::BitXor",        sym::bitxor,     2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::borrow::Borrow",     sym::borrow,     1,  FN_HEADER, SelfKind::Ref,    OutType::Ref,  true ),
-    ShouldImplTraitCase::new("std::borrow::BorrowMut",  sym::borrow_mut, 1,  FN_HEADER, SelfKind::RefMut, OutType::Ref,  true ),
-    ShouldImplTraitCase::new("std::clone::Clone",       sym::clone,      1,  FN_HEADER, SelfKind::Ref,    OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::cmp::Ord",           sym::cmp,        2,  FN_HEADER, SelfKind::Ref,    OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::default::Default",   kw::Default,     0,  FN_HEADER, SelfKind::No,     OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::ops::Deref",         sym::deref,      1,  FN_HEADER, SelfKind::Ref,    OutType::Ref,  true ),
-    ShouldImplTraitCase::new("std::ops::DerefMut",      sym::deref_mut,  1,  FN_HEADER, SelfKind::RefMut, OutType::Ref,  true ),
-    ShouldImplTraitCase::new("std::ops::Div",           sym::div,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::ops::Drop",          sym::drop,       1,  FN_HEADER, SelfKind::RefMut, OutType::Unit, true ),
-    ShouldImplTraitCase::new("std::cmp::PartialEq",     sym::eq,         2,  FN_HEADER, SelfKind::Ref,    OutType::Bool, true ),
-    ShouldImplTraitCase::new("std::iter::FromIterator", sym::from_iter,  1,  FN_HEADER, SelfKind::No,     OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::str::FromStr",       sym::from_str,   1,  FN_HEADER, SelfKind::No,     OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::hash::Hash",         sym::hash,       2,  FN_HEADER, SelfKind::Ref,    OutType::Unit, true ),
-    ShouldImplTraitCase::new("std::ops::Index",         sym::index,      2,  FN_HEADER, SelfKind::Ref,    OutType::Ref,  true ),
-    ShouldImplTraitCase::new("std::ops::IndexMut",      sym::index_mut,  2,  FN_HEADER, SelfKind::RefMut, OutType::Ref,  true ),
-    ShouldImplTraitCase::new("std::iter::IntoIterator", sym::into_iter,  1,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::ops::Mul",           sym::mul,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::ops::Neg",           sym::neg,        1,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::iter::Iterator",     sym::next,       1,  FN_HEADER, SelfKind::RefMut, OutType::Any,  false),
-    ShouldImplTraitCase::new("std::ops::Not",           sym::not,        1,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::ops::Rem",           sym::rem,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::ops::Shl",           sym::shl,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::ops::Shr",           sym::shr,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
-    ShouldImplTraitCase::new("std::ops::Sub",           sym::sub,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true ),
+    ShouldImplTraitCase::new("std::ops::Add",           sym::add,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::convert::AsMut",     sym::as_mut,     1,  FN_HEADER, SelfKind::RefMut, OutType::Ref,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::convert::AsRef",     sym::as_ref,     1,  FN_HEADER, SelfKind::Ref,    OutType::Ref,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::BitAnd",        sym::bitand,     2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::BitOr",         sym::bitor,      2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::BitXor",        sym::bitxor,     2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::borrow::Borrow",     sym::borrow,     1,  FN_HEADER, SelfKind::Ref,    OutType::Ref,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::borrow::BorrowMut",  sym::borrow_mut, 1,  FN_HEADER, SelfKind::RefMut, OutType::Ref,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::clone::Clone",       sym::clone,      1,  FN_HEADER, SelfKind::Ref,    OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::cmp::Ord",           sym::cmp,        2,  FN_HEADER, SelfKind::Ref,    OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::default::Default",   kw::Default,     0,  FN_HEADER, SelfKind::No,     OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::Deref",         sym::deref,      1,  FN_HEADER, SelfKind::Ref,    OutType::Ref,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::DerefMut",      sym::deref_mut,  1,  FN_HEADER, SelfKind::RefMut, OutType::Ref,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::Div",           sym::div,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::Drop",          sym::drop,       1,  FN_HEADER, SelfKind::RefMut, OutType::Unit, true,  Edition2015),
+    ShouldImplTraitCase::new("std::cmp::PartialEq",     sym::eq,         2,  FN_HEADER, SelfKind::Ref,    OutType::Bool, true,  Edition2015),
+    ShouldImplTraitCase::new("std::iter::FromIterator", sym::from_iter,  1,  FN_HEADER, SelfKind::No,     OutType::Any,  true,  Edition2021),
+    ShouldImplTraitCase::new("std::str::FromStr",       sym::from_str,   1,  FN_HEADER, SelfKind::No,     OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::hash::Hash",         sym::hash,       2,  FN_HEADER, SelfKind::Ref,    OutType::Unit, true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::Index",         sym::index,      2,  FN_HEADER, SelfKind::Ref,    OutType::Ref,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::IndexMut",      sym::index_mut,  2,  FN_HEADER, SelfKind::RefMut, OutType::Ref,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::iter::IntoIterator", sym::into_iter,  1,  FN_HEADER, SelfKind::Value,  OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::Mul",           sym::mul,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::Neg",           sym::neg,        1,  FN_HEADER, SelfKind::Value,  OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::iter::Iterator",     sym::next,       1,  FN_HEADER, SelfKind::RefMut, OutType::Any,  false, Edition2015),
+    ShouldImplTraitCase::new("std::ops::Not",           sym::not,        1,  FN_HEADER, SelfKind::Value,  OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::Rem",           sym::rem,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::Shl",           sym::shl,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::Shr",           sym::shr,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::Sub",           sym::sub,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true,  Edition2015),
 ];
 
 #[derive(Clone, Copy)]
diff --git a/tests/ui/should_impl_trait/method_list_1.stderr b/tests/ui/should_impl_trait/method_list_1.edition2015.stderr
similarity index 86%
rename from tests/ui/should_impl_trait/method_list_1.stderr
rename to tests/ui/should_impl_trait/method_list_1.edition2015.stderr
index 5609d6a21a360..0312fa8f04fae 100644
--- a/tests/ui/should_impl_trait/method_list_1.stderr
+++ b/tests/ui/should_impl_trait/method_list_1.edition2015.stderr
@@ -1,5 +1,5 @@
 error: method `add` can be confused for the standard trait method `std::ops::Add::add`
-  --> tests/ui/should_impl_trait/method_list_1.rs:24:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:27:5
    |
 LL | /     pub fn add(self, other: T) -> T {
 LL | |
@@ -13,7 +13,7 @@ LL | |     }
    = help: to override `-D warnings` add `#[allow(clippy::should_implement_trait)]`
 
 error: method `as_mut` can be confused for the standard trait method `std::convert::AsMut::as_mut`
-  --> tests/ui/should_impl_trait/method_list_1.rs:30:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:33:5
    |
 LL | /     pub fn as_mut(&mut self) -> &mut T {
 LL | |
@@ -25,7 +25,7 @@ LL | |     }
    = help: consider implementing the trait `std::convert::AsMut` or choosing a less ambiguous method name
 
 error: method `as_ref` can be confused for the standard trait method `std::convert::AsRef::as_ref`
-  --> tests/ui/should_impl_trait/method_list_1.rs:36:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:39:5
    |
 LL | /     pub fn as_ref(&self) -> &T {
 LL | |
@@ -37,7 +37,7 @@ LL | |     }
    = help: consider implementing the trait `std::convert::AsRef` or choosing a less ambiguous method name
 
 error: method `bitand` can be confused for the standard trait method `std::ops::BitAnd::bitand`
-  --> tests/ui/should_impl_trait/method_list_1.rs:42:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:45:5
    |
 LL | /     pub fn bitand(self, rhs: T) -> T {
 LL | |
@@ -49,7 +49,7 @@ LL | |     }
    = help: consider implementing the trait `std::ops::BitAnd` or choosing a less ambiguous method name
 
 error: method `bitor` can be confused for the standard trait method `std::ops::BitOr::bitor`
-  --> tests/ui/should_impl_trait/method_list_1.rs:48:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:51:5
    |
 LL | /     pub fn bitor(self, rhs: Self) -> Self {
 LL | |
@@ -61,7 +61,7 @@ LL | |     }
    = help: consider implementing the trait `std::ops::BitOr` or choosing a less ambiguous method name
 
 error: method `bitxor` can be confused for the standard trait method `std::ops::BitXor::bitxor`
-  --> tests/ui/should_impl_trait/method_list_1.rs:54:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:57:5
    |
 LL | /     pub fn bitxor(self, rhs: Self) -> Self {
 LL | |
@@ -73,7 +73,7 @@ LL | |     }
    = help: consider implementing the trait `std::ops::BitXor` or choosing a less ambiguous method name
 
 error: method `borrow` can be confused for the standard trait method `std::borrow::Borrow::borrow`
-  --> tests/ui/should_impl_trait/method_list_1.rs:60:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:63:5
    |
 LL | /     pub fn borrow(&self) -> &str {
 LL | |
@@ -85,7 +85,7 @@ LL | |     }
    = help: consider implementing the trait `std::borrow::Borrow` or choosing a less ambiguous method name
 
 error: method `borrow_mut` can be confused for the standard trait method `std::borrow::BorrowMut::borrow_mut`
-  --> tests/ui/should_impl_trait/method_list_1.rs:66:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:69:5
    |
 LL | /     pub fn borrow_mut(&mut self) -> &mut str {
 LL | |
@@ -97,7 +97,7 @@ LL | |     }
    = help: consider implementing the trait `std::borrow::BorrowMut` or choosing a less ambiguous method name
 
 error: method `clone` can be confused for the standard trait method `std::clone::Clone::clone`
-  --> tests/ui/should_impl_trait/method_list_1.rs:72:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:75:5
    |
 LL | /     pub fn clone(&self) -> Self {
 LL | |
@@ -109,7 +109,7 @@ LL | |     }
    = help: consider implementing the trait `std::clone::Clone` or choosing a less ambiguous method name
 
 error: method `cmp` can be confused for the standard trait method `std::cmp::Ord::cmp`
-  --> tests/ui/should_impl_trait/method_list_1.rs:78:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:81:5
    |
 LL | /     pub fn cmp(&self, other: &Self) -> Self {
 LL | |
@@ -121,7 +121,7 @@ LL | |     }
    = help: consider implementing the trait `std::cmp::Ord` or choosing a less ambiguous method name
 
 error: method `default` can be confused for the standard trait method `std::default::Default::default`
-  --> tests/ui/should_impl_trait/method_list_1.rs:84:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:87:5
    |
 LL | /     pub fn default() -> Self {
 LL | |
@@ -133,7 +133,7 @@ LL | |     }
    = help: consider implementing the trait `std::default::Default` or choosing a less ambiguous method name
 
 error: method `deref` can be confused for the standard trait method `std::ops::Deref::deref`
-  --> tests/ui/should_impl_trait/method_list_1.rs:90:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:93:5
    |
 LL | /     pub fn deref(&self) -> &Self {
 LL | |
@@ -145,7 +145,7 @@ LL | |     }
    = help: consider implementing the trait `std::ops::Deref` or choosing a less ambiguous method name
 
 error: method `deref_mut` can be confused for the standard trait method `std::ops::DerefMut::deref_mut`
-  --> tests/ui/should_impl_trait/method_list_1.rs:96:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:99:5
    |
 LL | /     pub fn deref_mut(&mut self) -> &mut Self {
 LL | |
@@ -157,7 +157,7 @@ LL | |     }
    = help: consider implementing the trait `std::ops::DerefMut` or choosing a less ambiguous method name
 
 error: method `div` can be confused for the standard trait method `std::ops::Div::div`
-  --> tests/ui/should_impl_trait/method_list_1.rs:102:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:105:5
    |
 LL | /     pub fn div(self, rhs: Self) -> Self {
 LL | |
@@ -169,7 +169,7 @@ LL | |     }
    = help: consider implementing the trait `std::ops::Div` or choosing a less ambiguous method name
 
 error: method `drop` can be confused for the standard trait method `std::ops::Drop::drop`
-  --> tests/ui/should_impl_trait/method_list_1.rs:108:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:111:5
    |
 LL | /     pub fn drop(&mut self) {
 LL | |
diff --git a/tests/ui/should_impl_trait/method_list_1.edition2021.stderr b/tests/ui/should_impl_trait/method_list_1.edition2021.stderr
new file mode 100644
index 0000000000000..0312fa8f04fae
--- /dev/null
+++ b/tests/ui/should_impl_trait/method_list_1.edition2021.stderr
@@ -0,0 +1,184 @@
+error: method `add` can be confused for the standard trait method `std::ops::Add::add`
+  --> tests/ui/should_impl_trait/method_list_1.rs:27:5
+   |
+LL | /     pub fn add(self, other: T) -> T {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Add` or choosing a less ambiguous method name
+   = note: `-D clippy::should-implement-trait` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::should_implement_trait)]`
+
+error: method `as_mut` can be confused for the standard trait method `std::convert::AsMut::as_mut`
+  --> tests/ui/should_impl_trait/method_list_1.rs:33:5
+   |
+LL | /     pub fn as_mut(&mut self) -> &mut T {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::convert::AsMut` or choosing a less ambiguous method name
+
+error: method `as_ref` can be confused for the standard trait method `std::convert::AsRef::as_ref`
+  --> tests/ui/should_impl_trait/method_list_1.rs:39:5
+   |
+LL | /     pub fn as_ref(&self) -> &T {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::convert::AsRef` or choosing a less ambiguous method name
+
+error: method `bitand` can be confused for the standard trait method `std::ops::BitAnd::bitand`
+  --> tests/ui/should_impl_trait/method_list_1.rs:45:5
+   |
+LL | /     pub fn bitand(self, rhs: T) -> T {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::BitAnd` or choosing a less ambiguous method name
+
+error: method `bitor` can be confused for the standard trait method `std::ops::BitOr::bitor`
+  --> tests/ui/should_impl_trait/method_list_1.rs:51:5
+   |
+LL | /     pub fn bitor(self, rhs: Self) -> Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::BitOr` or choosing a less ambiguous method name
+
+error: method `bitxor` can be confused for the standard trait method `std::ops::BitXor::bitxor`
+  --> tests/ui/should_impl_trait/method_list_1.rs:57:5
+   |
+LL | /     pub fn bitxor(self, rhs: Self) -> Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::BitXor` or choosing a less ambiguous method name
+
+error: method `borrow` can be confused for the standard trait method `std::borrow::Borrow::borrow`
+  --> tests/ui/should_impl_trait/method_list_1.rs:63:5
+   |
+LL | /     pub fn borrow(&self) -> &str {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::borrow::Borrow` or choosing a less ambiguous method name
+
+error: method `borrow_mut` can be confused for the standard trait method `std::borrow::BorrowMut::borrow_mut`
+  --> tests/ui/should_impl_trait/method_list_1.rs:69:5
+   |
+LL | /     pub fn borrow_mut(&mut self) -> &mut str {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::borrow::BorrowMut` or choosing a less ambiguous method name
+
+error: method `clone` can be confused for the standard trait method `std::clone::Clone::clone`
+  --> tests/ui/should_impl_trait/method_list_1.rs:75:5
+   |
+LL | /     pub fn clone(&self) -> Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::clone::Clone` or choosing a less ambiguous method name
+
+error: method `cmp` can be confused for the standard trait method `std::cmp::Ord::cmp`
+  --> tests/ui/should_impl_trait/method_list_1.rs:81:5
+   |
+LL | /     pub fn cmp(&self, other: &Self) -> Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::cmp::Ord` or choosing a less ambiguous method name
+
+error: method `default` can be confused for the standard trait method `std::default::Default::default`
+  --> tests/ui/should_impl_trait/method_list_1.rs:87:5
+   |
+LL | /     pub fn default() -> Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::default::Default` or choosing a less ambiguous method name
+
+error: method `deref` can be confused for the standard trait method `std::ops::Deref::deref`
+  --> tests/ui/should_impl_trait/method_list_1.rs:93:5
+   |
+LL | /     pub fn deref(&self) -> &Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Deref` or choosing a less ambiguous method name
+
+error: method `deref_mut` can be confused for the standard trait method `std::ops::DerefMut::deref_mut`
+  --> tests/ui/should_impl_trait/method_list_1.rs:99:5
+   |
+LL | /     pub fn deref_mut(&mut self) -> &mut Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::DerefMut` or choosing a less ambiguous method name
+
+error: method `div` can be confused for the standard trait method `std::ops::Div::div`
+  --> tests/ui/should_impl_trait/method_list_1.rs:105:5
+   |
+LL | /     pub fn div(self, rhs: Self) -> Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Div` or choosing a less ambiguous method name
+
+error: method `drop` can be confused for the standard trait method `std::ops::Drop::drop`
+  --> tests/ui/should_impl_trait/method_list_1.rs:111:5
+   |
+LL | /     pub fn drop(&mut self) {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Drop` or choosing a less ambiguous method name
+
+error: aborting due to 15 previous errors
+
diff --git a/tests/ui/should_impl_trait/method_list_1.rs b/tests/ui/should_impl_trait/method_list_1.rs
index e8de0e04c0c4c..bbb04c0c5aa12 100644
--- a/tests/ui/should_impl_trait/method_list_1.rs
+++ b/tests/ui/should_impl_trait/method_list_1.rs
@@ -1,3 +1,6 @@
+//@revisions: edition2015 edition2021
+//@[edition2015] edition:2015
+//@[edition2021] edition:2021
 #![allow(
     clippy::missing_errors_doc,
     clippy::needless_pass_by_value,
diff --git a/tests/ui/should_impl_trait/method_list_2.edition2015.stderr b/tests/ui/should_impl_trait/method_list_2.edition2015.stderr
new file mode 100644
index 0000000000000..259815908fee0
--- /dev/null
+++ b/tests/ui/should_impl_trait/method_list_2.edition2015.stderr
@@ -0,0 +1,172 @@
+error: method `eq` can be confused for the standard trait method `std::cmp::PartialEq::eq`
+  --> tests/ui/should_impl_trait/method_list_2.rs:28:5
+   |
+LL | /     pub fn eq(&self, other: &Self) -> bool {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::cmp::PartialEq` or choosing a less ambiguous method name
+   = note: `-D clippy::should-implement-trait` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::should_implement_trait)]`
+
+error: method `from_str` can be confused for the standard trait method `std::str::FromStr::from_str`
+  --> tests/ui/should_impl_trait/method_list_2.rs:40:5
+   |
+LL | /     pub fn from_str(s: &str) -> Result<Self, Self> {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::str::FromStr` or choosing a less ambiguous method name
+
+error: method `hash` can be confused for the standard trait method `std::hash::Hash::hash`
+  --> tests/ui/should_impl_trait/method_list_2.rs:46:5
+   |
+LL | /     pub fn hash(&self, state: &mut T) {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::hash::Hash` or choosing a less ambiguous method name
+
+error: method `index` can be confused for the standard trait method `std::ops::Index::index`
+  --> tests/ui/should_impl_trait/method_list_2.rs:52:5
+   |
+LL | /     pub fn index(&self, index: usize) -> &Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Index` or choosing a less ambiguous method name
+
+error: method `index_mut` can be confused for the standard trait method `std::ops::IndexMut::index_mut`
+  --> tests/ui/should_impl_trait/method_list_2.rs:58:5
+   |
+LL | /     pub fn index_mut(&mut self, index: usize) -> &mut Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::IndexMut` or choosing a less ambiguous method name
+
+error: method `into_iter` can be confused for the standard trait method `std::iter::IntoIterator::into_iter`
+  --> tests/ui/should_impl_trait/method_list_2.rs:64:5
+   |
+LL | /     pub fn into_iter(self) -> Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::iter::IntoIterator` or choosing a less ambiguous method name
+
+error: method `mul` can be confused for the standard trait method `std::ops::Mul::mul`
+  --> tests/ui/should_impl_trait/method_list_2.rs:70:5
+   |
+LL | /     pub fn mul(self, rhs: Self) -> Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Mul` or choosing a less ambiguous method name
+
+error: method `neg` can be confused for the standard trait method `std::ops::Neg::neg`
+  --> tests/ui/should_impl_trait/method_list_2.rs:76:5
+   |
+LL | /     pub fn neg(self) -> Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Neg` or choosing a less ambiguous method name
+
+error: method `next` can be confused for the standard trait method `std::iter::Iterator::next`
+  --> tests/ui/should_impl_trait/method_list_2.rs:82:5
+   |
+LL | /     pub fn next(&mut self) -> Option<Self> {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::iter::Iterator` or choosing a less ambiguous method name
+
+error: method `not` can be confused for the standard trait method `std::ops::Not::not`
+  --> tests/ui/should_impl_trait/method_list_2.rs:88:5
+   |
+LL | /     pub fn not(self) -> Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Not` or choosing a less ambiguous method name
+
+error: method `rem` can be confused for the standard trait method `std::ops::Rem::rem`
+  --> tests/ui/should_impl_trait/method_list_2.rs:94:5
+   |
+LL | /     pub fn rem(self, rhs: Self) -> Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Rem` or choosing a less ambiguous method name
+
+error: method `shl` can be confused for the standard trait method `std::ops::Shl::shl`
+  --> tests/ui/should_impl_trait/method_list_2.rs:100:5
+   |
+LL | /     pub fn shl(self, rhs: Self) -> Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Shl` or choosing a less ambiguous method name
+
+error: method `shr` can be confused for the standard trait method `std::ops::Shr::shr`
+  --> tests/ui/should_impl_trait/method_list_2.rs:106:5
+   |
+LL | /     pub fn shr(self, rhs: Self) -> Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Shr` or choosing a less ambiguous method name
+
+error: method `sub` can be confused for the standard trait method `std::ops::Sub::sub`
+  --> tests/ui/should_impl_trait/method_list_2.rs:112:5
+   |
+LL | /     pub fn sub(self, rhs: Self) -> Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Sub` or choosing a less ambiguous method name
+
+error: aborting due to 14 previous errors
+
diff --git a/tests/ui/should_impl_trait/method_list_2.edition2021.stderr b/tests/ui/should_impl_trait/method_list_2.edition2021.stderr
new file mode 100644
index 0000000000000..2f90b61e7a176
--- /dev/null
+++ b/tests/ui/should_impl_trait/method_list_2.edition2021.stderr
@@ -0,0 +1,184 @@
+error: method `eq` can be confused for the standard trait method `std::cmp::PartialEq::eq`
+  --> tests/ui/should_impl_trait/method_list_2.rs:28:5
+   |
+LL | /     pub fn eq(&self, other: &Self) -> bool {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::cmp::PartialEq` or choosing a less ambiguous method name
+   = note: `-D clippy::should-implement-trait` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::should_implement_trait)]`
+
+error: method `from_iter` can be confused for the standard trait method `std::iter::FromIterator::from_iter`
+  --> tests/ui/should_impl_trait/method_list_2.rs:34:5
+   |
+LL | /     pub fn from_iter<T>(iter: T) -> Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::iter::FromIterator` or choosing a less ambiguous method name
+
+error: method `from_str` can be confused for the standard trait method `std::str::FromStr::from_str`
+  --> tests/ui/should_impl_trait/method_list_2.rs:40:5
+   |
+LL | /     pub fn from_str(s: &str) -> Result<Self, Self> {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::str::FromStr` or choosing a less ambiguous method name
+
+error: method `hash` can be confused for the standard trait method `std::hash::Hash::hash`
+  --> tests/ui/should_impl_trait/method_list_2.rs:46:5
+   |
+LL | /     pub fn hash(&self, state: &mut T) {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::hash::Hash` or choosing a less ambiguous method name
+
+error: method `index` can be confused for the standard trait method `std::ops::Index::index`
+  --> tests/ui/should_impl_trait/method_list_2.rs:52:5
+   |
+LL | /     pub fn index(&self, index: usize) -> &Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Index` or choosing a less ambiguous method name
+
+error: method `index_mut` can be confused for the standard trait method `std::ops::IndexMut::index_mut`
+  --> tests/ui/should_impl_trait/method_list_2.rs:58:5
+   |
+LL | /     pub fn index_mut(&mut self, index: usize) -> &mut Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::IndexMut` or choosing a less ambiguous method name
+
+error: method `into_iter` can be confused for the standard trait method `std::iter::IntoIterator::into_iter`
+  --> tests/ui/should_impl_trait/method_list_2.rs:64:5
+   |
+LL | /     pub fn into_iter(self) -> Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::iter::IntoIterator` or choosing a less ambiguous method name
+
+error: method `mul` can be confused for the standard trait method `std::ops::Mul::mul`
+  --> tests/ui/should_impl_trait/method_list_2.rs:70:5
+   |
+LL | /     pub fn mul(self, rhs: Self) -> Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Mul` or choosing a less ambiguous method name
+
+error: method `neg` can be confused for the standard trait method `std::ops::Neg::neg`
+  --> tests/ui/should_impl_trait/method_list_2.rs:76:5
+   |
+LL | /     pub fn neg(self) -> Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Neg` or choosing a less ambiguous method name
+
+error: method `next` can be confused for the standard trait method `std::iter::Iterator::next`
+  --> tests/ui/should_impl_trait/method_list_2.rs:82:5
+   |
+LL | /     pub fn next(&mut self) -> Option<Self> {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::iter::Iterator` or choosing a less ambiguous method name
+
+error: method `not` can be confused for the standard trait method `std::ops::Not::not`
+  --> tests/ui/should_impl_trait/method_list_2.rs:88:5
+   |
+LL | /     pub fn not(self) -> Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Not` or choosing a less ambiguous method name
+
+error: method `rem` can be confused for the standard trait method `std::ops::Rem::rem`
+  --> tests/ui/should_impl_trait/method_list_2.rs:94:5
+   |
+LL | /     pub fn rem(self, rhs: Self) -> Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Rem` or choosing a less ambiguous method name
+
+error: method `shl` can be confused for the standard trait method `std::ops::Shl::shl`
+  --> tests/ui/should_impl_trait/method_list_2.rs:100:5
+   |
+LL | /     pub fn shl(self, rhs: Self) -> Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Shl` or choosing a less ambiguous method name
+
+error: method `shr` can be confused for the standard trait method `std::ops::Shr::shr`
+  --> tests/ui/should_impl_trait/method_list_2.rs:106:5
+   |
+LL | /     pub fn shr(self, rhs: Self) -> Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Shr` or choosing a less ambiguous method name
+
+error: method `sub` can be confused for the standard trait method `std::ops::Sub::sub`
+  --> tests/ui/should_impl_trait/method_list_2.rs:112:5
+   |
+LL | /     pub fn sub(self, rhs: Self) -> Self {
+LL | |
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Sub` or choosing a less ambiguous method name
+
+error: aborting due to 15 previous errors
+
diff --git a/tests/ui/should_impl_trait/method_list_2.rs b/tests/ui/should_impl_trait/method_list_2.rs
index 1f25ab3938a3d..4dfbe7e0f9f4d 100644
--- a/tests/ui/should_impl_trait/method_list_2.rs
+++ b/tests/ui/should_impl_trait/method_list_2.rs
@@ -1,3 +1,6 @@
+//@revisions: edition2015 edition2021
+//@[edition2015] edition:2015
+//@[edition2021] edition:2021
 #![allow(
     clippy::missing_errors_doc,
     clippy::needless_pass_by_value,
@@ -29,7 +32,7 @@ impl T {
     }
 
     pub fn from_iter<T>(iter: T) -> Self {
-        //~^ should_implement_trait
+        //~[edition2021]^ should_implement_trait
 
         unimplemented!()
     }

From 5df0be398845fa8b239f3e722c25b8369498df5c Mon Sep 17 00:00:00 2001
From: Jake Goulding <jake.goulding@gmail.com>
Date: Tue, 26 Aug 2025 08:52:54 -0400
Subject: [PATCH 1550/1889] Make macOS dist build configuration match where
 reasonable

---
 src/ci/github-actions/jobs.yml | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/src/ci/github-actions/jobs.yml b/src/ci/github-actions/jobs.yml
index 8303699ce8a68..4384ec7676975 100644
--- a/src/ci/github-actions/jobs.yml
+++ b/src/ci/github-actions/jobs.yml
@@ -430,7 +430,8 @@ auto:
       # Ensure that host tooling is built to support our minimum support macOS version.
       MACOSX_DEPLOYMENT_TARGET: 10.12
       MACOSX_STD_DEPLOYMENT_TARGET: 10.12
-      SELECT_XCODE: /Applications/Xcode_15.2.app
+      SELECT_XCODE: /Applications/Xcode_15.4.app
+      USE_XCODE_CLANG: 1
       DIST_REQUIRE_ALL_TOOLS: 1
       CODEGEN_BACKENDS: llvm,cranelift
     <<: *job-macos
@@ -450,21 +451,24 @@ auto:
 
   - name: dist-aarch64-apple
     env:
-      SCRIPT: ./x.py dist bootstrap --include-default-paths --host=aarch64-apple-darwin --target=aarch64-apple-darwin
+      SCRIPT: >-
+        ./x.py dist bootstrap
+        --include-default-paths
+        --host=aarch64-apple-darwin
+        --target=aarch64-apple-darwin
       RUST_CONFIGURE_ARGS: >-
         --enable-full-tools
         --enable-sanitizers
         --enable-profiler
         --set rust.jemalloc
-        --set llvm.ninja=false
         --set rust.lto=thin
         --set rust.codegen-units=1
-      SELECT_XCODE: /Applications/Xcode_15.4.app
-      USE_XCODE_CLANG: 1
       # Aarch64 tooling only needs to support macOS 11.0 and up as nothing else
       # supports the hardware.
       MACOSX_DEPLOYMENT_TARGET: 11.0
       MACOSX_STD_DEPLOYMENT_TARGET: 11.0
+      SELECT_XCODE: /Applications/Xcode_15.4.app
+      USE_XCODE_CLANG: 1
       DIST_REQUIRE_ALL_TOOLS: 1
       CODEGEN_BACKENDS: llvm,cranelift
     <<: *job-macos

From 098a56890f25eaca5063988b0b0840fad83db250 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Mon, 29 Sep 2025 13:52:33 +0200
Subject: [PATCH 1551/1889] Fn-trait goals, eagerly instantiate binder

to avoid overflow from proving `for<'a> opaque<'a>: Sized`
---
 .../src/solve/assembly/structural_traits.rs   |   5 +-
 .../src/solve/effect_goals.rs                 |  21 ++-
 .../src/solve/normalizes_to/mod.rs            | 135 ++++++++----------
 .../src/solve/trait_goals.rs                  |  46 +++---
 4 files changed, 90 insertions(+), 117 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 c40739d12e680..9b3dc1f691fb3 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
@@ -664,7 +664,7 @@ fn coroutine_closure_to_ambiguous_coroutine<I: Interner>(
 pub(in crate::solve) fn extract_fn_def_from_const_callable<I: Interner>(
     cx: I,
     self_ty: I::Ty,
-) -> Result<(ty::Binder<I, (I::FnInputTys, I::Ty)>, I::FunctionId, I::GenericArgs), NoSolution> {
+) -> Result<(ty::Binder<I, (I::Ty, I::Ty)>, I::FunctionId, I::GenericArgs), NoSolution> {
     match self_ty.kind() {
         ty::FnDef(def_id, args) => {
             let sig = cx.fn_sig(def_id);
@@ -673,7 +673,8 @@ pub(in crate::solve) fn extract_fn_def_from_const_callable<I: Interner>(
                 && cx.fn_is_const(def_id)
             {
                 Ok((
-                    sig.instantiate(cx, args).map_bound(|sig| (sig.inputs(), sig.output())),
+                    sig.instantiate(cx, args)
+                        .map_bound(|sig| (Ty::new_tup(cx, sig.inputs().as_slice()), sig.output())),
                     def_id,
                     args,
                 ))
diff --git a/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs b/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
index cb72c1cd92b84..65a5edf6b7250 100644
--- a/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
@@ -234,12 +234,12 @@ where
         let self_ty = goal.predicate.self_ty();
         let (inputs_and_output, def_id, args) =
             structural_traits::extract_fn_def_from_const_callable(cx, self_ty)?;
+        let (inputs, output) = ecx.instantiate_binder_with_infer(inputs_and_output);
 
         // A built-in `Fn` impl only holds if the output is sized.
         // (FIXME: technically we only need to check this if the type is a fn ptr...)
-        let output_is_sized_pred = inputs_and_output.map_bound(|(_, output)| {
-            ty::TraitRef::new(cx, cx.require_trait_lang_item(SolverTraitLangItem::Sized), [output])
-        });
+        let output_is_sized_pred =
+            ty::TraitRef::new(cx, cx.require_trait_lang_item(SolverTraitLangItem::Sized), [output]);
         let requirements = cx
             .const_conditions(def_id.into())
             .iter_instantiated(cx, args)
@@ -251,15 +251,12 @@ where
             })
             .chain([(GoalSource::ImplWhereBound, goal.with(cx, output_is_sized_pred))]);
 
-        let pred = inputs_and_output
-            .map_bound(|(inputs, _)| {
-                ty::TraitRef::new(
-                    cx,
-                    goal.predicate.def_id(),
-                    [goal.predicate.self_ty(), Ty::new_tup(cx, inputs.as_slice())],
-                )
-            })
-            .to_host_effect_clause(cx, goal.predicate.constness);
+        let pred = ty::Binder::dummy(ty::TraitRef::new(
+            cx,
+            goal.predicate.def_id(),
+            [goal.predicate.self_ty(), inputs],
+        ))
+        .to_host_effect_clause(cx, goal.predicate.constness);
 
         Self::probe_and_consider_implied_clause(
             ecx,
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 653c59c5d4241..0674b3d42ab4d 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
@@ -451,23 +451,22 @@ where
                     return ecx.forced_ambiguity(MaybeCause::Ambiguity);
                 }
             };
+        let (inputs, output) = ecx.instantiate_binder_with_infer(tupled_inputs_and_output);
 
         // A built-in `Fn` impl only holds if the output is sized.
         // (FIXME: technically we only need to check this if the type is a fn ptr...)
-        let output_is_sized_pred = tupled_inputs_and_output.map_bound(|(_, output)| {
-            ty::TraitRef::new(cx, cx.require_trait_lang_item(SolverTraitLangItem::Sized), [output])
-        });
+        let output_is_sized_pred =
+            ty::TraitRef::new(cx, cx.require_trait_lang_item(SolverTraitLangItem::Sized), [output]);
 
-        let pred = tupled_inputs_and_output
-            .map_bound(|(inputs, output)| ty::ProjectionPredicate {
-                projection_term: ty::AliasTerm::new(
-                    cx,
-                    goal.predicate.def_id(),
-                    [goal.predicate.self_ty(), inputs],
-                ),
-                term: output.into(),
-            })
-            .upcast(cx);
+        let pred = ty::ProjectionPredicate {
+            projection_term: ty::AliasTerm::new(
+                cx,
+                goal.predicate.def_id(),
+                [goal.predicate.self_ty(), inputs],
+            ),
+            term: output.into(),
+        }
+        .upcast(cx);
 
         Self::probe_and_consider_implied_clause(
             ecx,
@@ -497,76 +496,56 @@ where
                 goal_kind,
                 env_region,
             )?;
+        let AsyncCallableRelevantTypes {
+            tupled_inputs_ty,
+            output_coroutine_ty,
+            coroutine_return_ty,
+        } = ecx.instantiate_binder_with_infer(tupled_inputs_and_output_and_coroutine);
 
         // A built-in `AsyncFn` impl only holds if the output is sized.
         // (FIXME: technically we only need to check this if the type is a fn ptr...)
-        let output_is_sized_pred = tupled_inputs_and_output_and_coroutine.map_bound(
-            |AsyncCallableRelevantTypes { output_coroutine_ty: output_ty, .. }| {
-                ty::TraitRef::new(
-                    cx,
-                    cx.require_trait_lang_item(SolverTraitLangItem::Sized),
-                    [output_ty],
-                )
-            },
+        let output_is_sized_pred = ty::TraitRef::new(
+            cx,
+            cx.require_trait_lang_item(SolverTraitLangItem::Sized),
+            [output_coroutine_ty],
         );
 
-        let pred = tupled_inputs_and_output_and_coroutine
-            .map_bound(
-                |AsyncCallableRelevantTypes {
-                     tupled_inputs_ty,
-                     output_coroutine_ty,
-                     coroutine_return_ty,
-                 }| {
-                    let (projection_term, term) = if cx
-                        .is_lang_item(goal.predicate.def_id(), SolverLangItem::CallOnceFuture)
-                    {
-                        (
-                            ty::AliasTerm::new(
-                                cx,
-                                goal.predicate.def_id(),
-                                [goal.predicate.self_ty(), tupled_inputs_ty],
-                            ),
-                            output_coroutine_ty.into(),
-                        )
-                    } else if cx
-                        .is_lang_item(goal.predicate.def_id(), SolverLangItem::CallRefFuture)
-                    {
-                        (
-                            ty::AliasTerm::new(
-                                cx,
-                                goal.predicate.def_id(),
-                                [
-                                    I::GenericArg::from(goal.predicate.self_ty()),
-                                    tupled_inputs_ty.into(),
-                                    env_region.into(),
-                                ],
-                            ),
-                            output_coroutine_ty.into(),
-                        )
-                    } else if cx
-                        .is_lang_item(goal.predicate.def_id(), SolverLangItem::AsyncFnOnceOutput)
-                    {
-                        (
-                            ty::AliasTerm::new(
-                                cx,
-                                goal.predicate.def_id(),
-                                [
-                                    I::GenericArg::from(goal.predicate.self_ty()),
-                                    tupled_inputs_ty.into(),
-                                ],
-                            ),
-                            coroutine_return_ty.into(),
-                        )
-                    } else {
-                        panic!(
-                            "no such associated type in `AsyncFn*`: {:?}",
-                            goal.predicate.def_id()
-                        )
-                    };
-                    ty::ProjectionPredicate { projection_term, term }
-                },
-            )
-            .upcast(cx);
+        let (projection_term, term) =
+            if cx.is_lang_item(goal.predicate.def_id(), SolverLangItem::CallOnceFuture) {
+                (
+                    ty::AliasTerm::new(
+                        cx,
+                        goal.predicate.def_id(),
+                        [goal.predicate.self_ty(), tupled_inputs_ty],
+                    ),
+                    output_coroutine_ty.into(),
+                )
+            } else if cx.is_lang_item(goal.predicate.def_id(), SolverLangItem::CallRefFuture) {
+                (
+                    ty::AliasTerm::new(
+                        cx,
+                        goal.predicate.def_id(),
+                        [
+                            I::GenericArg::from(goal.predicate.self_ty()),
+                            tupled_inputs_ty.into(),
+                            env_region.into(),
+                        ],
+                    ),
+                    output_coroutine_ty.into(),
+                )
+            } else if cx.is_lang_item(goal.predicate.def_id(), SolverLangItem::AsyncFnOnceOutput) {
+                (
+                    ty::AliasTerm::new(
+                        cx,
+                        goal.predicate.def_id(),
+                        [goal.predicate.self_ty(), tupled_inputs_ty],
+                    ),
+                    coroutine_return_ty.into(),
+                )
+            } else {
+                panic!("no such associated type in `AsyncFn*`: {:?}", goal.predicate.def_id())
+            };
+        let pred = ty::ProjectionPredicate { projection_term, term }.upcast(cx);
 
         Self::probe_and_consider_implied_clause(
             ecx,
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 3974114e9b43c..e790ecd595be7 100644
--- a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
@@ -369,18 +369,16 @@ where
                     return ecx.forced_ambiguity(MaybeCause::Ambiguity);
                 }
             };
+        let (inputs, output) = ecx.instantiate_binder_with_infer(tupled_inputs_and_output);
 
         // A built-in `Fn` impl only holds if the output is sized.
         // (FIXME: technically we only need to check this if the type is a fn ptr...)
-        let output_is_sized_pred = tupled_inputs_and_output.map_bound(|(_, output)| {
-            ty::TraitRef::new(cx, cx.require_trait_lang_item(SolverTraitLangItem::Sized), [output])
-        });
+        let output_is_sized_pred =
+            ty::TraitRef::new(cx, cx.require_trait_lang_item(SolverTraitLangItem::Sized), [output]);
 
-        let pred = tupled_inputs_and_output
-            .map_bound(|(inputs, _)| {
-                ty::TraitRef::new(cx, goal.predicate.def_id(), [goal.predicate.self_ty(), inputs])
-            })
-            .upcast(cx);
+        let pred =
+            ty::TraitRef::new(cx, goal.predicate.def_id(), [goal.predicate.self_ty(), inputs])
+                .upcast(cx);
         Self::probe_and_consider_implied_clause(
             ecx,
             CandidateSource::BuiltinImpl(BuiltinImplSource::Misc),
@@ -408,28 +406,26 @@ where
                 // This region doesn't matter because we're throwing away the coroutine type
                 Region::new_static(cx),
             )?;
+        let AsyncCallableRelevantTypes {
+            tupled_inputs_ty,
+            output_coroutine_ty,
+            coroutine_return_ty: _,
+        } = ecx.instantiate_binder_with_infer(tupled_inputs_and_output_and_coroutine);
 
         // A built-in `AsyncFn` impl only holds if the output is sized.
         // (FIXME: technically we only need to check this if the type is a fn ptr...)
-        let output_is_sized_pred = tupled_inputs_and_output_and_coroutine.map_bound(
-            |AsyncCallableRelevantTypes { output_coroutine_ty, .. }| {
-                ty::TraitRef::new(
-                    cx,
-                    cx.require_trait_lang_item(SolverTraitLangItem::Sized),
-                    [output_coroutine_ty],
-                )
-            },
+        let output_is_sized_pred = ty::TraitRef::new(
+            cx,
+            cx.require_trait_lang_item(SolverTraitLangItem::Sized),
+            [output_coroutine_ty],
         );
 
-        let pred = tupled_inputs_and_output_and_coroutine
-            .map_bound(|AsyncCallableRelevantTypes { tupled_inputs_ty, .. }| {
-                ty::TraitRef::new(
-                    cx,
-                    goal.predicate.def_id(),
-                    [goal.predicate.self_ty(), tupled_inputs_ty],
-                )
-            })
-            .upcast(cx);
+        let pred = ty::TraitRef::new(
+            cx,
+            goal.predicate.def_id(),
+            [goal.predicate.self_ty(), tupled_inputs_ty],
+        )
+        .upcast(cx);
         Self::probe_and_consider_implied_clause(
             ecx,
             CandidateSource::BuiltinImpl(BuiltinImplSource::Misc),

From 0f2b79c36dcc4ec66125d6fa87694c7f5d39ebe8 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Mon, 29 Sep 2025 13:57:41 +0200
Subject: [PATCH 1552/1889] add tests

---
 .../opaques/overflow-hr-fn-trait-sized-1.rs   | 25 +++++++++++++++++++
 .../opaques/overflow-hr-fn-trait-sized-2.rs   | 14 +++++++++++
 2 files changed, 39 insertions(+)
 create mode 100644 tests/ui/traits/next-solver/opaques/overflow-hr-fn-trait-sized-1.rs
 create mode 100644 tests/ui/traits/next-solver/opaques/overflow-hr-fn-trait-sized-2.rs

diff --git a/tests/ui/traits/next-solver/opaques/overflow-hr-fn-trait-sized-1.rs b/tests/ui/traits/next-solver/opaques/overflow-hr-fn-trait-sized-1.rs
new file mode 100644
index 0000000000000..e35e48dfcecbd
--- /dev/null
+++ b/tests/ui/traits/next-solver/opaques/overflow-hr-fn-trait-sized-1.rs
@@ -0,0 +1,25 @@
+//@ ignore-compare-mode-next-solver
+//@ compile-flags: -Znext-solver
+//@ check-pass
+
+// Regression test for trait-system-refactor-initiative#220. Builtin `Fn`-trait
+// candidates required `for<'latebound> Output<'latebound>: Sized` which ended
+// up resulting in overflow if the return type is an opaque in the defining scope.
+//
+// We now eagerly instantiate the binder of the function definition which avoids
+// that overflow by relating the lifetime of the opaque to something from the
+// input.
+fn flat_map<T, F, I, G>(_: F, _: G)
+where
+    F: FnOnce(T) -> I,
+    I: Iterator,
+    G: Fn(<I as Iterator>::Item) -> usize,
+{
+}
+
+fn rarw<'a>(_: &'a ()) -> impl Iterator<Item = &'a str> {
+    flat_map(rarw, |x| x.len());
+    std::iter::empty()
+}
+
+fn main() {}
diff --git a/tests/ui/traits/next-solver/opaques/overflow-hr-fn-trait-sized-2.rs b/tests/ui/traits/next-solver/opaques/overflow-hr-fn-trait-sized-2.rs
new file mode 100644
index 0000000000000..1d64e422d8938
--- /dev/null
+++ b/tests/ui/traits/next-solver/opaques/overflow-hr-fn-trait-sized-2.rs
@@ -0,0 +1,14 @@
+//@ ignore-compare-mode-next-solver
+//@ compile-flags: -Znext-solver
+//@ check-pass
+
+// Regression test for trait-system-refactor-initiative#204, see
+// the sibling test for more details.
+
+fn constrain<'a, F: FnOnce(&'a ())>(_: F) {}
+fn foo<'a>(_: &'a ()) -> impl Sized + use<'a> {
+    constrain(foo);
+    ()
+}
+
+fn main() {}

From 07806a1132f156ffad8c9edaed08825cd09fbce5 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Mon, 29 Sep 2025 13:57:51 +0200
Subject: [PATCH 1553/1889] cleanup `try_evaluate_added_goals`

---
 .../src/solve/eval_ctxt/mod.rs                | 19 +++++--------------
 1 file changed, 5 insertions(+), 14 deletions(-)

diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
index 85110530ae9bc..f25003bbfe92a 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
@@ -633,28 +633,19 @@ where
     // the certainty of all the goals.
     #[instrument(level = "trace", skip(self))]
     pub(super) fn try_evaluate_added_goals(&mut self) -> Result<Certainty, NoSolution> {
-        let mut response = Ok(Certainty::overflow(false));
         for _ in 0..FIXPOINT_STEP_LIMIT {
-            // FIXME: This match is a bit ugly, it might be nice to change the inspect
-            // stuff to use a closure instead. which should hopefully simplify this a bit.
             match self.evaluate_added_goals_step() {
-                Ok(Some(cert)) => {
-                    response = Ok(cert);
-                    break;
-                }
                 Ok(None) => {}
+                Ok(Some(cert)) => return Ok(cert),
                 Err(NoSolution) => {
-                    response = Err(NoSolution);
-                    break;
+                    self.tainted = Err(NoSolution);
+                    return Err(NoSolution);
                 }
             }
         }
 
-        if response.is_err() {
-            self.tainted = Err(NoSolution);
-        }
-
-        response
+        debug!("try_evaluate_added_goals: encountered overflow");
+        Ok(Certainty::overflow(false))
     }
 
     /// Iterate over all added goals: returning `Ok(Some(_))` in case we can stop rerunning.

From 9f667cdd243d905848ccfc031f4c1373828c9a7d Mon Sep 17 00:00:00 2001
From: Jules Bertholet <julesbertholet@quoi.xyz>
Date: Mon, 29 Sep 2025 10:34:19 -0400
Subject: [PATCH 1554/1889] Add `overlapping_assoc_constraints` param to
 `lower_bounds`

---
 .../src/collect/item_bounds.rs                | 20 ++++++++++++++++---
 .../src/collect/predicates_of.rs              | 18 +++++++++++++++--
 .../src/hir_ty_lowering/bounds.rs             |  4 +++-
 .../src/hir_ty_lowering/mod.rs                |  1 +
 4 files changed, 37 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/collect/item_bounds.rs b/compiler/rustc_hir_analysis/src/collect/item_bounds.rs
index ba54fa8cc0dbf..9841fafc82c1b 100644
--- a/compiler/rustc_hir_analysis/src/collect/item_bounds.rs
+++ b/compiler/rustc_hir_analysis/src/collect/item_bounds.rs
@@ -12,7 +12,7 @@ use tracing::{debug, instrument};
 
 use super::ItemCtxt;
 use super::predicates_of::assert_only_contains_predicates_from;
-use crate::hir_ty_lowering::{HirTyLowerer, PredicateFilter};
+use crate::hir_ty_lowering::{HirTyLowerer, OverlappingAsssocItemConstraints, PredicateFilter};
 
 /// For associated types we include both bounds written on the type
 /// (`type X: Trait`) and predicates from the trait: `where Self::X: Trait`.
@@ -37,7 +37,14 @@ fn associated_type_bounds<'tcx>(
 
         let icx = ItemCtxt::new(tcx, assoc_item_def_id);
         let mut bounds = Vec::new();
-        icx.lowerer().lower_bounds(item_ty, hir_bounds, &mut bounds, ty::List::empty(), filter);
+        icx.lowerer().lower_bounds(
+            item_ty,
+            hir_bounds,
+            &mut bounds,
+            ty::List::empty(),
+            filter,
+            OverlappingAsssocItemConstraints::Allowed,
+        );
 
         match filter {
             PredicateFilter::All
@@ -347,7 +354,14 @@ fn opaque_type_bounds<'tcx>(
     ty::print::with_reduced_queries!({
         let icx = ItemCtxt::new(tcx, opaque_def_id);
         let mut bounds = Vec::new();
-        icx.lowerer().lower_bounds(item_ty, hir_bounds, &mut bounds, ty::List::empty(), filter);
+        icx.lowerer().lower_bounds(
+            item_ty,
+            hir_bounds,
+            &mut bounds,
+            ty::List::empty(),
+            filter,
+            OverlappingAsssocItemConstraints::Allowed,
+        );
         // Implicit bounds are added to opaque types unless a `?Trait` bound is found
         match filter {
             PredicateFilter::All
diff --git a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
index dd3590f9ac5dc..ffdf2a2f4c0c8 100644
--- a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
@@ -18,7 +18,9 @@ use super::item_bounds::explicit_item_bounds_with_filter;
 use crate::collect::ItemCtxt;
 use crate::constrained_generic_params as cgp;
 use crate::delegation::inherit_predicates_for_delegation_item;
-use crate::hir_ty_lowering::{HirTyLowerer, PredicateFilter, RegionInferReason};
+use crate::hir_ty_lowering::{
+    HirTyLowerer, OverlappingAsssocItemConstraints, 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 `explicit_predicates_of`, plus
@@ -187,6 +189,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
             &mut bounds,
             ty::List::empty(),
             PredicateFilter::All,
+            OverlappingAsssocItemConstraints::Allowed,
         );
         icx.lowerer().add_sizedness_bounds(
             &mut bounds,
@@ -289,6 +292,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
                     &mut bounds,
                     bound_vars,
                     PredicateFilter::All,
+                    OverlappingAsssocItemConstraints::Allowed,
                 );
                 predicates.extend(bounds);
             }
@@ -659,7 +663,14 @@ pub(super) fn implied_predicates_with_filter<'tcx>(
 
     let self_param_ty = tcx.types.self_param;
     let mut bounds = Vec::new();
-    icx.lowerer().lower_bounds(self_param_ty, superbounds, &mut bounds, ty::List::empty(), filter);
+    icx.lowerer().lower_bounds(
+        self_param_ty,
+        superbounds,
+        &mut bounds,
+        ty::List::empty(),
+        filter,
+        OverlappingAsssocItemConstraints::Allowed,
+    );
     match filter {
         PredicateFilter::All
         | PredicateFilter::SelfOnly
@@ -984,6 +995,7 @@ impl<'tcx> ItemCtxt<'tcx> {
                 &mut bounds,
                 bound_vars,
                 filter,
+                OverlappingAsssocItemConstraints::Allowed,
             );
         }
 
@@ -1063,6 +1075,7 @@ pub(super) fn const_conditions<'tcx>(
                     &mut bounds,
                     bound_vars,
                     PredicateFilter::ConstIfConst,
+                    OverlappingAsssocItemConstraints::Allowed,
                 );
             }
             _ => {}
@@ -1083,6 +1096,7 @@ pub(super) fn const_conditions<'tcx>(
             &mut bounds,
             ty::List::empty(),
             PredicateFilter::ConstIfConst,
+            OverlappingAsssocItemConstraints::Allowed,
         );
     }
 
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
index a59520f16feb9..8682fdc54942b 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
@@ -339,6 +339,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         bounds: &mut Vec<(ty::Clause<'tcx>, Span)>,
         bound_vars: &'tcx ty::List<ty::BoundVariableKind>,
         predicate_filter: PredicateFilter,
+        overlapping_assoc_constraints: OverlappingAsssocItemConstraints,
     ) where
         'tcx: 'hir,
     {
@@ -363,7 +364,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                         param_ty,
                         bounds,
                         predicate_filter,
-                        OverlappingAsssocItemConstraints::Allowed,
+                        overlapping_assoc_constraints,
                     );
                 }
                 hir::GenericBound::Outlives(lifetime) => {
@@ -604,6 +605,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                             bounds,
                             projection_ty.bound_vars(),
                             predicate_filter,
+                            OverlappingAsssocItemConstraints::Allowed,
                         );
                     }
                     PredicateFilter::SelfOnly
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 cc5c0d0ad6ce9..eb660804c2b52 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -2497,6 +2497,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                     &mut bounds,
                     ty::List::empty(),
                     PredicateFilter::All,
+                    OverlappingAsssocItemConstraints::Allowed,
                 );
                 self.add_sizedness_bounds(
                     &mut bounds,

From adf9cbd69ccd9c1e973fe179fbf3e53b23b4a5ae Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Tue, 12 Nov 2024 18:31:54 +0000
Subject: [PATCH 1555/1889] Add a dummy codegen backend

This allows building a rustc capable of running the frontend without any
backend present. While this may not seem all that useful, it allows
running the frontend of rustc to report errors or running miri to
interpret a program without any backend present. This is useful when you
are trying to say run miri in the browser as upstream LLVM can't be
compiled for wasm yet. Or to run rustc itself in miri like I did a while
ago and caught some UB.
---
 compiler/rustc_interface/src/util.rs | 74 ++++++++++++++++++++++++++--
 1 file changed, 70 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_interface/src/util.rs b/compiler/rustc_interface/src/util.rs
index 76ccd12797e5e..6a6e64773f353 100644
--- a/compiler/rustc_interface/src/util.rs
+++ b/compiler/rustc_interface/src/util.rs
@@ -1,3 +1,4 @@
+use std::any::Any;
 use std::env::consts::{DLL_PREFIX, DLL_SUFFIX};
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicBool, Ordering};
@@ -6,13 +7,20 @@ use std::{env, thread};
 
 use rustc_ast as ast;
 use rustc_attr_parsing::{ShouldEmit, validate_attr};
+use rustc_codegen_ssa::back::archive::ArArchiveBuilderBuilder;
+use rustc_codegen_ssa::back::link::link_binary;
 use rustc_codegen_ssa::traits::CodegenBackend;
+use rustc_codegen_ssa::{CodegenResults, CrateInfo};
+use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::jobserver::Proxy;
 use rustc_data_structures::sync;
 use rustc_errors::LintBuffer;
-use rustc_metadata::{DylibError, load_symbol_from_dylib};
-use rustc_middle::ty::CurrentGcx;
-use rustc_session::config::{Cfg, OutFileName, OutputFilenames, OutputTypes, Sysroot, host_tuple};
+use rustc_metadata::{DylibError, EncodedMetadata, load_symbol_from_dylib};
+use rustc_middle::dep_graph::{WorkProduct, WorkProductId};
+use rustc_middle::ty::{CurrentGcx, TyCtxt};
+use rustc_session::config::{
+    Cfg, CrateType, OutFileName, OutputFilenames, OutputTypes, Sysroot, host_tuple,
+};
 use rustc_session::output::{CRATE_TYPES, categorize_crate_type};
 use rustc_session::{EarlyDiagCtxt, Session, filesearch, lint};
 use rustc_span::edit_distance::find_best_match_for_name;
@@ -316,12 +324,13 @@ pub fn get_codegen_backend(
         let backend = backend_name
             .or(target.default_codegen_backend.as_deref())
             .or(option_env!("CFG_DEFAULT_CODEGEN_BACKEND"))
-            .unwrap_or("llvm");
+            .unwrap_or("dummy");
 
         match backend {
             filename if filename.contains('.') => {
                 load_backend_from_dylib(early_dcx, filename.as_ref())
             }
+            "dummy" => || Box::new(DummyCodegenBackend),
             #[cfg(feature = "llvm")]
             "llvm" => rustc_codegen_llvm::LlvmCodegenBackend::new,
             backend_name => get_codegen_sysroot(early_dcx, sysroot, backend_name),
@@ -334,6 +343,63 @@ pub fn get_codegen_backend(
     unsafe { load() }
 }
 
+struct DummyCodegenBackend;
+
+impl CodegenBackend for DummyCodegenBackend {
+    fn locale_resource(&self) -> &'static str {
+        ""
+    }
+
+    fn name(&self) -> &'static str {
+        "dummy"
+    }
+
+    fn codegen_crate<'tcx>(&self, tcx: TyCtxt<'tcx>) -> Box<dyn Any> {
+        Box::new(CodegenResults {
+            modules: vec![],
+            allocator_module: None,
+            crate_info: CrateInfo::new(tcx, String::new()),
+        })
+    }
+
+    fn join_codegen(
+        &self,
+        ongoing_codegen: Box<dyn Any>,
+        _sess: &Session,
+        _outputs: &OutputFilenames,
+    ) -> (CodegenResults, FxIndexMap<WorkProductId, WorkProduct>) {
+        (*ongoing_codegen.downcast().unwrap(), FxIndexMap::default())
+    }
+
+    fn link(
+        &self,
+        sess: &Session,
+        codegen_results: CodegenResults,
+        metadata: EncodedMetadata,
+        outputs: &OutputFilenames,
+    ) {
+        // JUSTIFICATION: TyCtxt no longer available here
+        #[allow(rustc::bad_opt_access)]
+        if sess.opts.crate_types.iter().any(|&crate_type| crate_type != CrateType::Rlib) {
+            #[allow(rustc::untranslatable_diagnostic)]
+            #[allow(rustc::diagnostic_outside_of_impl)]
+            sess.dcx().fatal(format!(
+                "crate type {} not supported by the dummy codegen backend",
+                sess.opts.crate_types[0],
+            ));
+        }
+
+        link_binary(
+            sess,
+            &ArArchiveBuilderBuilder,
+            codegen_results,
+            metadata,
+            outputs,
+            self.name(),
+        );
+    }
+}
+
 // This is used for rustdoc, but it uses similar machinery to codegen backend
 // loading, so we leave the code here. It is potentially useful for other tools
 // that want to invoke the rustc binary while linking to rustc as well.

From 66b664c9961e54282fbaccef72f90dfa7dd1418f Mon Sep 17 00:00:00 2001
From: Boxy Uwu <rust@boxyuwu.dev>
Date: Mon, 29 Sep 2025 16:05:44 +0100
Subject: [PATCH 1556/1889] more rename

---
 compiler/rustc_borrowck/src/lib.rs            |  7 +++--
 .../src/region_infer/opaque_types/mod.rs      | 29 +++++++++++--------
 compiler/rustc_borrowck/src/root_cx.rs        | 14 ++++-----
 compiler/rustc_hir_typeck/src/opaque_types.rs |  8 ++---
 compiler/rustc_middle/src/arena.rs            |  2 +-
 compiler/rustc_middle/src/mir/query.rs        |  2 +-
 compiler/rustc_middle/src/query/mod.rs        |  2 +-
 7 files changed, 36 insertions(+), 28 deletions(-)

diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs
index d799eb1f8c6ef..268cb47fd1261 100644
--- a/compiler/rustc_borrowck/src/lib.rs
+++ b/compiler/rustc_borrowck/src/lib.rs
@@ -116,7 +116,10 @@ pub fn provide(providers: &mut Providers) {
 /// Provider for `query mir_borrowck`. Similar to `typeck`, this must
 /// only be called for typeck roots which will then borrowck all
 /// nested bodies as well.
-fn mir_borrowck(tcx: TyCtxt<'_>, def: LocalDefId) -> Result<&HiddenTypes<'_>, ErrorGuaranteed> {
+fn mir_borrowck(
+    tcx: TyCtxt<'_>,
+    def: LocalDefId,
+) -> Result<&DefinitionSiteHiddenTypes<'_>, ErrorGuaranteed> {
     assert!(!tcx.is_typeck_child(def.to_def_id()));
     let (input_body, _) = tcx.mir_promoted(def);
     debug!("run query mir_borrowck: {}", tcx.def_path_str(def));
@@ -127,7 +130,7 @@ fn mir_borrowck(tcx: TyCtxt<'_>, def: LocalDefId) -> Result<&HiddenTypes<'_>, Er
         Err(guar)
     } else if input_body.should_skip() {
         debug!("Skipping borrowck because of injected body");
-        let opaque_types = HiddenTypes(Default::default());
+        let opaque_types = DefinitionSiteHiddenTypes(Default::default());
         Ok(tcx.arena.alloc(opaque_types))
     } else {
         let mut root_cx = BorrowCheckRootCtxt::new(tcx, def, None);
diff --git a/compiler/rustc_borrowck/src/region_infer/opaque_types/mod.rs b/compiler/rustc_borrowck/src/region_infer/opaque_types/mod.rs
index 6aa3345d4d423..8d89f3e0d8700 100644
--- a/compiler/rustc_borrowck/src/region_infer/opaque_types/mod.rs
+++ b/compiler/rustc_borrowck/src/region_infer/opaque_types/mod.rs
@@ -8,7 +8,7 @@ use rustc_infer::infer::outlives::env::RegionBoundPairs;
 use rustc_infer::infer::{InferCtxt, NllRegionVariableOrigin, OpaqueTypeStorageEntries};
 use rustc_infer::traits::ObligationCause;
 use rustc_macros::extension;
-use rustc_middle::mir::{Body, ConstraintCategory, HiddenTypes};
+use rustc_middle::mir::{Body, ConstraintCategory, DefinitionSiteHiddenTypes};
 use rustc_middle::ty::{
     self, DefiningScopeKind, EarlyBinder, FallibleTypeFolder, GenericArg, GenericArgsRef,
     OpaqueHiddenType, OpaqueTypeKey, Region, RegionVid, Ty, TyCtxt, TypeFoldable,
@@ -131,7 +131,7 @@ fn nll_var_to_universal_region<'tcx>(
 /// and errors if we end up with distinct hidden types.
 fn add_hidden_type<'tcx>(
     tcx: TyCtxt<'tcx>,
-    hidden_types: &mut HiddenTypes<'tcx>,
+    hidden_types: &mut DefinitionSiteHiddenTypes<'tcx>,
     def_id: LocalDefId,
     hidden_ty: OpaqueHiddenType<'tcx>,
 ) {
@@ -156,7 +156,7 @@ fn add_hidden_type<'tcx>(
 }
 
 fn get_hidden_type<'tcx>(
-    hidden_types: &HiddenTypes<'tcx>,
+    hidden_types: &DefinitionSiteHiddenTypes<'tcx>,
     def_id: LocalDefId,
 ) -> Option<EarlyBinder<'tcx, OpaqueHiddenType<'tcx>>> {
     hidden_types.0.get(&def_id).map(|ty| EarlyBinder::bind(*ty))
@@ -183,12 +183,12 @@ struct DefiningUse<'tcx> {
 ///
 /// It also means that this whole function is not really soundness critical as we
 /// recheck all uses of the opaques regardless.
-pub(crate) fn compute_hidden_types<'tcx>(
+pub(crate) fn compute_definition_site_hidden_types<'tcx>(
     infcx: &BorrowckInferCtxt<'tcx>,
     universal_region_relations: &Frozen<UniversalRegionRelations<'tcx>>,
     constraints: &MirTypeckRegionConstraints<'tcx>,
     location_map: Rc<DenseLocationMap>,
-    hidden_types: &mut HiddenTypes<'tcx>,
+    hidden_types: &mut DefinitionSiteHiddenTypes<'tcx>,
     opaque_types: &[(OpaqueTypeKey<'tcx>, OpaqueHiddenType<'tcx>)],
 ) -> Vec<DeferredOpaqueTypeError<'tcx>> {
     let mut errors = Vec::new();
@@ -211,14 +211,19 @@ pub(crate) fn compute_hidden_types<'tcx>(
     // After applying member constraints, we now check whether all member regions ended
     // up equal to one of their choice regions and compute the actual hidden type of
     // the opaque type definition. This is stored in the `root_cx`.
-    compute_hidden_types_from_defining_uses(&rcx, hidden_types, &defining_uses, &mut errors);
+    compute_definition_site_hidden_types_from_defining_uses(
+        &rcx,
+        hidden_types,
+        &defining_uses,
+        &mut errors,
+    );
     errors
 }
 
 #[instrument(level = "debug", skip_all, ret)]
 fn collect_defining_uses<'tcx>(
     rcx: &mut RegionCtxt<'_, 'tcx>,
-    hidden_types: &mut HiddenTypes<'tcx>,
+    hidden_types: &mut DefinitionSiteHiddenTypes<'tcx>,
     opaque_types: &[(OpaqueTypeKey<'tcx>, OpaqueHiddenType<'tcx>)],
     errors: &mut Vec<DeferredOpaqueTypeError<'tcx>>,
 ) -> Vec<DefiningUse<'tcx>> {
@@ -271,9 +276,9 @@ fn collect_defining_uses<'tcx>(
     defining_uses
 }
 
-fn compute_hidden_types_from_defining_uses<'tcx>(
+fn compute_definition_site_hidden_types_from_defining_uses<'tcx>(
     rcx: &RegionCtxt<'_, 'tcx>,
-    hidden_types: &mut HiddenTypes<'tcx>,
+    hidden_types: &mut DefinitionSiteHiddenTypes<'tcx>,
     defining_uses: &[DefiningUse<'tcx>],
     errors: &mut Vec<DeferredOpaqueTypeError<'tcx>>,
 ) {
@@ -483,14 +488,14 @@ impl<'tcx> FallibleTypeFolder<TyCtxt<'tcx>> for ToArgRegionsFolder<'_, 'tcx> {
 ///
 /// It does this by equating the hidden type of each use with the instantiated final
 /// hidden type of the opaque.
-pub(crate) fn apply_hidden_types<'tcx>(
+pub(crate) fn apply_definition_site_hidden_types<'tcx>(
     infcx: &BorrowckInferCtxt<'tcx>,
     body: &Body<'tcx>,
     universal_regions: &UniversalRegions<'tcx>,
     region_bound_pairs: &RegionBoundPairs<'tcx>,
     known_type_outlives_obligations: &[ty::PolyTypeOutlivesPredicate<'tcx>],
     constraints: &mut MirTypeckRegionConstraints<'tcx>,
-    hidden_types: &mut HiddenTypes<'tcx>,
+    hidden_types: &mut DefinitionSiteHiddenTypes<'tcx>,
     opaque_types: &[(OpaqueTypeKey<'tcx>, OpaqueHiddenType<'tcx>)],
 ) -> Vec<DeferredOpaqueTypeError<'tcx>> {
     let tcx = infcx.tcx;
@@ -561,7 +566,7 @@ pub(crate) fn apply_hidden_types<'tcx>(
     errors
 }
 
-/// In theory `apply_hidden_types` could introduce new uses of opaque types.
+/// In theory `apply_definition_site_hidden_types` could introduce new uses of opaque types.
 /// We do not check these new uses so this could be unsound.
 ///
 /// We detect any new uses and simply delay a bug if they occur. If this results in
diff --git a/compiler/rustc_borrowck/src/root_cx.rs b/compiler/rustc_borrowck/src/root_cx.rs
index d9599bbdd4611..21c11e1287353 100644
--- a/compiler/rustc_borrowck/src/root_cx.rs
+++ b/compiler/rustc_borrowck/src/root_cx.rs
@@ -12,12 +12,12 @@ use smallvec::SmallVec;
 use crate::consumers::BorrowckConsumer;
 use crate::nll::compute_closure_requirements_modulo_opaques;
 use crate::region_infer::opaque_types::{
-    apply_hidden_types, clone_and_resolve_opaque_types, compute_hidden_types,
-    detect_opaque_types_added_while_handling_opaque_types,
+    apply_definition_site_hidden_types, clone_and_resolve_opaque_types,
+    compute_definition_site_hidden_types, detect_opaque_types_added_while_handling_opaque_types,
 };
 use crate::type_check::{Locations, constraint_conversion};
 use crate::{
-    ClosureRegionRequirements, CollectRegionConstraintsResult, HiddenTypes,
+    ClosureRegionRequirements, CollectRegionConstraintsResult, DefinitionSiteHiddenTypes,
     PropagatedBorrowCheckResults, borrowck_check_region_constraints,
     borrowck_collect_region_constraints,
 };
@@ -27,7 +27,7 @@ use crate::{
 pub(super) struct BorrowCheckRootCtxt<'tcx> {
     pub tcx: TyCtxt<'tcx>,
     root_def_id: LocalDefId,
-    hidden_types: HiddenTypes<'tcx>,
+    hidden_types: DefinitionSiteHiddenTypes<'tcx>,
     /// The region constraints computed by [borrowck_collect_region_constraints]. This uses
     /// an [FxIndexMap] to guarantee that iterating over it visits nested bodies before
     /// their parents.
@@ -72,7 +72,7 @@ impl<'tcx> BorrowCheckRootCtxt<'tcx> {
         &self.propagated_borrowck_results[&nested_body_def_id].used_mut_upvars
     }
 
-    pub(super) fn finalize(self) -> Result<&'tcx HiddenTypes<'tcx>, ErrorGuaranteed> {
+    pub(super) fn finalize(self) -> Result<&'tcx DefinitionSiteHiddenTypes<'tcx>, ErrorGuaranteed> {
         if let Some(guar) = self.tainted_by_errors {
             Err(guar)
         } else {
@@ -88,7 +88,7 @@ impl<'tcx> BorrowCheckRootCtxt<'tcx> {
                 &input.universal_region_relations,
                 &mut input.constraints,
             );
-            input.deferred_opaque_type_errors = compute_hidden_types(
+            input.deferred_opaque_type_errors = compute_definition_site_hidden_types(
                 &input.infcx,
                 &input.universal_region_relations,
                 &input.constraints,
@@ -103,7 +103,7 @@ impl<'tcx> BorrowCheckRootCtxt<'tcx> {
             self.collect_region_constraints_results.values_mut().zip(per_body_info)
         {
             if input.deferred_opaque_type_errors.is_empty() {
-                input.deferred_opaque_type_errors = apply_hidden_types(
+                input.deferred_opaque_type_errors = apply_definition_site_hidden_types(
                     &input.infcx,
                     &input.body_owned,
                     &input.universal_region_relations.universal_regions,
diff --git a/compiler/rustc_hir_typeck/src/opaque_types.rs b/compiler/rustc_hir_typeck/src/opaque_types.rs
index a47fa202acfe3..4c1fe69405e91 100644
--- a/compiler/rustc_hir_typeck/src/opaque_types.rs
+++ b/compiler/rustc_hir_typeck/src/opaque_types.rs
@@ -35,8 +35,8 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
         }
         debug!(?opaque_types);
 
-        self.compute_hidden_types(&opaque_types);
-        self.apply_hidden_types(&opaque_types);
+        self.compute_definition_site_hidden_types(&opaque_types);
+        self.apply_definition_site_hidden_types(&opaque_types);
     }
 }
 
@@ -71,7 +71,7 @@ impl<'tcx> UsageKind<'tcx> {
 }
 
 impl<'tcx> FnCtxt<'_, 'tcx> {
-    fn compute_hidden_types(
+    fn compute_definition_site_hidden_types(
         &mut self,
         opaque_types: &[(OpaqueTypeKey<'tcx>, OpaqueHiddenType<'tcx>)],
     ) {
@@ -203,7 +203,7 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
         UsageKind::HasDefiningUse
     }
 
-    fn apply_hidden_types(
+    fn apply_definition_site_hidden_types(
         &mut self,
         opaque_types: &[(OpaqueTypeKey<'tcx>, OpaqueHiddenType<'tcx>)],
     ) {
diff --git a/compiler/rustc_middle/src/arena.rs b/compiler/rustc_middle/src/arena.rs
index a63030b114527..feaad5bb96eb9 100644
--- a/compiler/rustc_middle/src/arena.rs
+++ b/compiler/rustc_middle/src/arena.rs
@@ -27,7 +27,7 @@ macro_rules! arena_types {
                     rustc_middle::mir::Body<'tcx>
                 >,
             [decode] typeck_results: rustc_middle::ty::TypeckResults<'tcx>,
-            [decode] borrowck_result: rustc_middle::mir::HiddenTypes<'tcx>,
+            [decode] borrowck_result: rustc_middle::mir::DefinitionSiteHiddenTypes<'tcx>,
             [] resolver: rustc_data_structures::steal::Steal<(
                 rustc_middle::ty::ResolverAstLowering,
                 std::sync::Arc<rustc_ast::Crate>,
diff --git a/compiler/rustc_middle/src/mir/query.rs b/compiler/rustc_middle/src/mir/query.rs
index 791565e387e8d..2e6c9f207e26b 100644
--- a/compiler/rustc_middle/src/mir/query.rs
+++ b/compiler/rustc_middle/src/mir/query.rs
@@ -87,7 +87,7 @@ impl Debug for CoroutineLayout<'_> {
 /// All the opaque types that have had their hidden type fully computed.
 /// Unlike the value in `TypeckResults`, this has unerased regions.
 #[derive(Default, Debug, TyEncodable, TyDecodable, HashStable)]
-pub struct HiddenTypes<'tcx>(pub FxIndexMap<LocalDefId, OpaqueHiddenType<'tcx>>);
+pub struct DefinitionSiteHiddenTypes<'tcx>(pub FxIndexMap<LocalDefId, OpaqueHiddenType<'tcx>>);
 
 /// The result of the `mir_const_qualif` query.
 ///
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 1efb29c788d49..895c8c0295a04 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -1244,7 +1244,7 @@ rustc_queries! {
 
     /// Borrow-checks the given typeck root, e.g. functions, const/static items,
     /// and its children, e.g. closures, inline consts.
-    query mir_borrowck(key: LocalDefId) -> Result<&'tcx mir::HiddenTypes<'tcx>, ErrorGuaranteed> {
+    query mir_borrowck(key: LocalDefId) -> Result<&'tcx mir::DefinitionSiteHiddenTypes<'tcx>, ErrorGuaranteed> {
         desc { |tcx| "borrow-checking `{}`", tcx.def_path_str(key) }
     }
 

From f4a865fea72cbbd1478cada7af19c1bcf0b9d588 Mon Sep 17 00:00:00 2001
From: Oblarg <emichaelbrnett@gmail.com>
Date: Mon, 29 Sep 2025 11:04:24 -0400
Subject: [PATCH 1557/1889] move test per review feedback

---
 .../crates/ide/src/hover/tests.rs             | 42 ++++++++
 .../rust-analyzer/crates/mbe/src/tests.rs     | 97 -------------------
 2 files changed, 42 insertions(+), 97 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs b/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
index 1ea11a215f83d..8bc0b3f6ab3b9 100644
--- a/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
@@ -4796,6 +4796,48 @@ fn main() {
     );
 }
 
+#[test]
+fn const_generic_negative_literal_macro_expansion() {
+    // Test that negative literals work correctly in const generics
+    // when used through macro expansion. This ensures the transcriber
+    // doesn't wrap negative literals in parentheses, which would create
+    // invalid syntax like Foo::<(-1)> instead of Foo::<-1>.
+    check(
+        r#"
+struct Foo<const I: i16> {
+    pub value: i16,
+}
+
+impl<const I: i16> Foo<I> {
+    pub fn new(value: i16) -> Self {
+        Self { value }
+    }
+}
+
+macro_rules! create_foo {
+    ($val:expr) => {
+        Foo::<$val>::new($val)
+    };
+}
+
+fn main() {
+    let v$0alue = create_foo!(-1);
+}
+"#,
+        expect![[r#"
+            *value*
+
+            ```rust
+            let value: Foo<-1>
+            ```
+
+            ---
+
+            size = 2, align = 2, no Drop
+        "#]],
+    );
+}
+
 #[test]
 fn hover_self_param_shows_type() {
     check(
diff --git a/src/tools/rust-analyzer/crates/mbe/src/tests.rs b/src/tools/rust-analyzer/crates/mbe/src/tests.rs
index 589e169d30a3d..56034516ef3b2 100644
--- a/src/tools/rust-analyzer/crates/mbe/src/tests.rs
+++ b/src/tools/rust-analyzer/crates/mbe/src/tests.rs
@@ -476,100 +476,3 @@ fn minus_belongs_to_literal() {
             --"#]],
     );
 }
-
-#[test]
-fn negative_literals_in_const_generics() {
-    // Test that negative literals work correctly in declarative macros
-    // when used as const generic arguments. The issue was that expressions
-    // like -1 would be wrapped in parentheses, creating invalid syntax
-    // Foo::<(-1)> instead of the correct Foo::<-1>.
-    let decl = r#"
-($val:expr) => {
-    struct Foo<const I: i16> {
-        pub value: i16,
-    }
-
-    impl<const I: i16> Foo<I> {
-        pub fn new(value: i16) -> Self {
-            Self { value }
-        }
-    }
-
-    Foo::<$val>::new($val)
-};
-"#;
-    let check = |args, expect| check(Edition::CURRENT, Edition::CURRENT, decl, args, expect);
-
-    // Test negative integer literal - should produce Foo::<-1>, not Foo::<(-1)>
-    check(
-        "-1",
-        expect![[r#"
-            SUBTREE $$ 1:Root[0000, 0]@0..2#ROOT2024 1:Root[0000, 0]@0..2#ROOT2024
-              IDENT   struct 0:Root[0000, 0]@22..28#ROOT2024
-              IDENT   Foo 0:Root[0000, 0]@29..32#ROOT2024
-              PUNCH   < [alone] 0:Root[0000, 0]@32..33#ROOT2024
-              IDENT   const 0:Root[0000, 0]@33..38#ROOT2024
-              IDENT   I 0:Root[0000, 0]@39..40#ROOT2024
-              PUNCH   : [alone] 0:Root[0000, 0]@40..41#ROOT2024
-              IDENT   i16 0:Root[0000, 0]@42..45#ROOT2024
-              PUNCH   > [alone] 0:Root[0000, 0]@45..46#ROOT2024
-              SUBTREE {} 0:Root[0000, 0]@47..48#ROOT2024 0:Root[0000, 0]@77..78#ROOT2024
-                IDENT   pub 0:Root[0000, 0]@57..60#ROOT2024
-                IDENT   value 0:Root[0000, 0]@61..66#ROOT2024
-                PUNCH   : [alone] 0:Root[0000, 0]@66..67#ROOT2024
-                IDENT   i16 0:Root[0000, 0]@68..71#ROOT2024
-                PUNCH   , [alone] 0:Root[0000, 0]@71..72#ROOT2024
-              IDENT   impl 0:Root[0000, 0]@84..88#ROOT2024
-              PUNCH   < [alone] 0:Root[0000, 0]@88..89#ROOT2024
-              IDENT   const 0:Root[0000, 0]@89..94#ROOT2024
-              IDENT   I 0:Root[0000, 0]@95..96#ROOT2024
-              PUNCH   : [alone] 0:Root[0000, 0]@96..97#ROOT2024
-              IDENT   i16 0:Root[0000, 0]@98..101#ROOT2024
-              PUNCH   > [alone] 0:Root[0000, 0]@101..102#ROOT2024
-              IDENT   Foo 0:Root[0000, 0]@103..106#ROOT2024
-              PUNCH   < [alone] 0:Root[0000, 0]@106..107#ROOT2024
-              IDENT   I 0:Root[0000, 0]@107..108#ROOT2024
-              PUNCH   > [alone] 0:Root[0000, 0]@108..109#ROOT2024
-              SUBTREE {} 0:Root[0000, 0]@110..111#ROOT2024 0:Root[0000, 0]@194..195#ROOT2024
-                IDENT   pub 0:Root[0000, 0]@120..123#ROOT2024
-                IDENT   fn 0:Root[0000, 0]@124..126#ROOT2024
-                IDENT   new 0:Root[0000, 0]@127..130#ROOT2024
-                SUBTREE () 0:Root[0000, 0]@130..131#ROOT2024 0:Root[0000, 0]@141..142#ROOT2024
-                  IDENT   value 0:Root[0000, 0]@131..136#ROOT2024
-                  PUNCH   : [alone] 0:Root[0000, 0]@136..137#ROOT2024
-                  IDENT   i16 0:Root[0000, 0]@138..141#ROOT2024
-                PUNCH   - [joint] 0:Root[0000, 0]@143..144#ROOT2024
-                PUNCH   > [alone] 0:Root[0000, 0]@144..145#ROOT2024
-                IDENT   Self 0:Root[0000, 0]@146..150#ROOT2024
-                SUBTREE {} 0:Root[0000, 0]@151..152#ROOT2024 0:Root[0000, 0]@188..189#ROOT2024
-                  IDENT   Self 0:Root[0000, 0]@165..169#ROOT2024
-                  SUBTREE {} 0:Root[0000, 0]@170..171#ROOT2024 0:Root[0000, 0]@178..179#ROOT2024
-                    IDENT   value 0:Root[0000, 0]@172..177#ROOT2024
-              IDENT   Foo 0:Root[0000, 0]@201..204#ROOT2024
-              PUNCH   : [joint] 0:Root[0000, 0]@204..205#ROOT2024
-              PUNCH   : [joint] 0:Root[0000, 0]@205..206#ROOT2024
-              PUNCH   < [joint] 0:Root[0000, 0]@206..207#ROOT2024
-              PUNCH   - [alone] 1:Root[0000, 0]@0..1#ROOT2024
-              LITERAL Integer 1 1:Root[0000, 0]@1..2#ROOT2024
-              PUNCH   > [joint] 0:Root[0000, 0]@211..212#ROOT2024
-              PUNCH   : [joint] 0:Root[0000, 0]@212..213#ROOT2024
-              PUNCH   : [alone] 0:Root[0000, 0]@213..214#ROOT2024
-              IDENT   new 0:Root[0000, 0]@214..217#ROOT2024
-              SUBTREE () 0:Root[0000, 0]@217..218#ROOT2024 0:Root[0000, 0]@222..223#ROOT2024
-                PUNCH   - [alone] 1:Root[0000, 0]@0..1#ROOT2024
-                LITERAL Integer 1 1:Root[0000, 0]@1..2#ROOT2024
-
-            struct Foo<const I:i16>{
-                pub value:i16,
-            }
-            impl <const I:i16>Foo<I>{
-                pub fn new(value:i16) -> Self {
-                    Self {
-                        value
-                    }
-                }
-
-                }
-            Foo::<-1>::new(-1)"#]],
-    );
-}

From 1a16755ea02e36828b1a235c3051a8f8341a741d Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Mon, 29 Sep 2025 15:55:38 +0000
Subject: [PATCH 1558/1889] flatten conditional block

---
 .../rustc_hir_analysis/src/constrained_generic_params.rs     | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/constrained_generic_params.rs b/compiler/rustc_hir_analysis/src/constrained_generic_params.rs
index 44d7f3a5e8bc2..6bcf06399e06e 100644
--- a/compiler/rustc_hir_analysis/src/constrained_generic_params.rs
+++ b/compiler/rustc_hir_analysis/src/constrained_generic_params.rs
@@ -209,11 +209,8 @@ pub(crate) fn setup_constraining_predicates<'tcx>(
             //     `<<T as Bar>::Baz as Iterator>::Output = <U as Iterator>::Output`
             // then the projection only applies if `T` is known, but it still
             // does not determine `U`.
+                parameters_for(tcx, projection.projection_term, true).iter().all(|p| input_parameters.contains(p))
             {
-                let inputs = parameters_for(tcx, projection.projection_term, true);
-                let relies_only_on_inputs = inputs.iter().all(|p| input_parameters.contains(p));
-                relies_only_on_inputs
-            } {
                 input_parameters.extend(parameters_for(tcx, projection.term, false));
 
                 predicates.swap(i, j);

From 06a6dcd4d276826a7600302c08a0d448e23c1d33 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 29 Sep 2025 14:27:21 +0200
Subject: [PATCH 1559/1889] Move doc cfg propagation pass before items
 stripping passes

---
 src/librustdoc/passes/mod.rs               | 4 ++--
 tests/rustdoc-ui/issues/issue-91713.stdout | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/librustdoc/passes/mod.rs b/src/librustdoc/passes/mod.rs
index 475d05b7d0e76..f45df8d2d0d5c 100644
--- a/src/librustdoc/passes/mod.rs
+++ b/src/librustdoc/passes/mod.rs
@@ -77,11 +77,11 @@ pub(crate) enum Condition {
 pub(crate) const PASSES: &[Pass] = &[
     CHECK_DOC_CFG,
     CHECK_DOC_TEST_VISIBILITY,
+    PROPAGATE_DOC_CFG,
     STRIP_ALIASED_NON_LOCAL,
     STRIP_HIDDEN,
     STRIP_PRIVATE,
     STRIP_PRIV_IMPORTS,
-    PROPAGATE_DOC_CFG,
     PROPAGATE_STABILITY,
     COLLECT_INTRA_DOC_LINKS,
     COLLECT_TRAIT_IMPLS,
@@ -94,11 +94,11 @@ pub(crate) const DEFAULT_PASSES: &[ConditionalPass] = &[
     ConditionalPass::always(COLLECT_TRAIT_IMPLS),
     ConditionalPass::always(CHECK_DOC_TEST_VISIBILITY),
     ConditionalPass::always(CHECK_DOC_CFG),
+    ConditionalPass::always(COLLECT_INTRA_DOC_LINKS),
     ConditionalPass::always(STRIP_ALIASED_NON_LOCAL),
     ConditionalPass::new(STRIP_HIDDEN, WhenNotDocumentHidden),
     ConditionalPass::new(STRIP_PRIVATE, WhenNotDocumentPrivate),
     ConditionalPass::new(STRIP_PRIV_IMPORTS, WhenDocumentPrivate),
-    ConditionalPass::always(COLLECT_INTRA_DOC_LINKS),
     ConditionalPass::always(PROPAGATE_DOC_CFG),
     ConditionalPass::always(PROPAGATE_STABILITY),
     ConditionalPass::always(RUN_LINTS),
diff --git a/tests/rustdoc-ui/issues/issue-91713.stdout b/tests/rustdoc-ui/issues/issue-91713.stdout
index 30aadfe89f424..d34714be6c942 100644
--- a/tests/rustdoc-ui/issues/issue-91713.stdout
+++ b/tests/rustdoc-ui/issues/issue-91713.stdout
@@ -1,11 +1,11 @@
 Available passes for running rustdoc:
        check-doc-cfg - checks `#[doc(cfg(...))]` for stability feature and unexpected cfgs
 check_doc_test_visibility - run various visibility-related lints on doctests
+   propagate-doc-cfg - propagates `#[doc(cfg(...))]` to child items
 strip-aliased-non-local - strips all non-local private aliased items from the output
         strip-hidden - strips all `#[doc(hidden)]` items from the output
        strip-private - strips all private items from a crate which cannot be seen externally, implies strip-priv-imports
   strip-priv-imports - strips all private import statements (`use`, `extern crate`) from a crate
-   propagate-doc-cfg - propagates `#[doc(cfg(...))]` to child items
  propagate-stability - propagates stability to child items
 collect-intra-doc-links - resolves intra-doc links
  collect-trait-impls - retrieves trait impls for items in the crate
@@ -16,11 +16,11 @@ Default passes for rustdoc:
  collect-trait-impls
 check_doc_test_visibility
        check-doc-cfg
+collect-intra-doc-links
 strip-aliased-non-local
         strip-hidden  (when not --document-hidden-items)
        strip-private  (when not --document-private-items)
   strip-priv-imports  (when --document-private-items)
-collect-intra-doc-links
    propagate-doc-cfg
  propagate-stability
            run-lints

From 9119eba24de69902ba421151691d7a294d96fa04 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 29 Sep 2025 14:31:21 +0200
Subject: [PATCH 1560/1889] Add regression test for doc cfg applied on public
 items inside private items

---
 tests/rustdoc/doc-auto-cfg-public-in-private.rs | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 tests/rustdoc/doc-auto-cfg-public-in-private.rs

diff --git a/tests/rustdoc/doc-auto-cfg-public-in-private.rs b/tests/rustdoc/doc-auto-cfg-public-in-private.rs
new file mode 100644
index 0000000000000..b78e3f1b932c2
--- /dev/null
+++ b/tests/rustdoc/doc-auto-cfg-public-in-private.rs
@@ -0,0 +1,16 @@
+// This test ensures that even though private items are removed from generated docs,
+// their `cfg`s will still impact their child items.
+
+#![feature(doc_cfg)]
+#![crate_name = "foo"]
+
+pub struct X;
+
+#[cfg(not(feature = "blob"))]
+fn foo() {
+    impl X {
+        //@ has 'foo/struct.X.html'
+        //@ has - '//*[@class="stab portability"]' 'Available on non-crate feature blob only.'
+        pub fn bar() {}
+    }
+}

From 92e65dc4d485e464204346557c228374a8828f7c Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Mon, 29 Sep 2025 18:39:39 +0200
Subject: [PATCH 1561/1889] how-to-build-and-run.md: replace "rm build" with "x
 clean --all"

---
 src/doc/rustc-dev-guide/src/building/how-to-build-and-run.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/src/building/how-to-build-and-run.md b/src/doc/rustc-dev-guide/src/building/how-to-build-and-run.md
index 36610f28854b5..f8ee9629f0474 100644
--- a/src/doc/rustc-dev-guide/src/building/how-to-build-and-run.md
+++ b/src/doc/rustc-dev-guide/src/building/how-to-build-and-run.md
@@ -187,7 +187,7 @@ Alternatively, you can write `bootstrap.toml` by hand. See `bootstrap.example.to
 settings and explanations of them. See `src/bootstrap/defaults` for common settings to change.
 
 If you have already built `rustc` and you change settings related to LLVM, then you may have to
-execute `rm -rf build` for subsequent configuration changes to take effect. Note that `./x
+execute `./x clean --all` for subsequent configuration changes to take effect. Note that `./x
 clean` will not cause a rebuild of LLVM.
 
 ## Common `x` commands

From eaeca967785ef51145016839bb7f8ceec876ae1c Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Mon, 29 Sep 2025 18:58:03 +0200
Subject: [PATCH 1562/1889] how-to-build-and-run.md: update "building compiler"
 section

---
 .../src/building/how-to-build-and-run.md        | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/building/how-to-build-and-run.md b/src/doc/rustc-dev-guide/src/building/how-to-build-and-run.md
index 36610f28854b5..fb4da9c187eaf 100644
--- a/src/doc/rustc-dev-guide/src/building/how-to-build-and-run.md
+++ b/src/doc/rustc-dev-guide/src/building/how-to-build-and-run.md
@@ -226,16 +226,17 @@ Once you've created a `bootstrap.toml`, you are now ready to run
 `x`. There are a lot of options here, but let's start with what is
 probably the best "go to" command for building a local compiler:
 
-```bash
-./x build library
+```console
+./x build rustc
 ```
 
-This may *look* like it only builds the standard library, but that is not the case.
-What this command does is the following:
+What this command does is build `rustc` using the stage0 compiler and stage0 `std`.
+
+To build `rustc` with the in-tree `std`, use this command instead:
 
-- Build `rustc` using the stage0 compiler
-  - This produces the stage1 compiler
-- Build `std` using the stage1 compiler
+```console
+./x build rustc --stage 2
+```
 
 This final product (stage1 compiler + libs built using that compiler)
 is what you need to build other Rust programs (unless you use `#![no_std]` or
@@ -253,7 +254,7 @@ signature of some function, you can use `./x check` instead for a much faster bu
 
 Note that this whole command just gives you a subset of the full `rustc`
 build. The **full** `rustc` build (what you get with `./x build
---stage 2 compiler/rustc`) has quite a few more steps:
+--stage 2 rustc`) has quite a few more steps:
 
 - Build `rustc` with the stage1 compiler.
   - The resulting compiler here is called the "stage2" compiler, which uses stage1 std from the previous command.

From 17cecfd311848f10c60014fe4714b1475ee545d5 Mon Sep 17 00:00:00 2001
From: yanglsh <yanglsh@shanghaitech.edu.cn>
Date: Tue, 30 Sep 2025 02:00:06 +0800
Subject: [PATCH 1563/1889] fix: `new_without_default` FP on private type with
 trait impl

---
 clippy_lints/src/new_without_default.rs |  2 +-
 tests/ui/new_without_default.fixed      | 20 ++++++++++++++++++++
 tests/ui/new_without_default.rs         | 20 ++++++++++++++++++++
 3 files changed, 41 insertions(+), 1 deletion(-)

diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index b598a390005ba..ab7b09c48a7fe 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -94,7 +94,7 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
                             return;
                         }
                         if sig.decl.inputs.is_empty()
-                            && cx.effective_visibilities.is_reachable(impl_item.owner_id.def_id)
+                            && cx.effective_visibilities.is_exported(impl_item.owner_id.def_id)
                             && let self_ty = cx.tcx.type_of(item.owner_id).instantiate_identity()
                             && self_ty == return_ty(cx, impl_item.owner_id)
                             && let Some(default_trait_id) = cx.tcx.get_diagnostic_item(sym::Default)
diff --git a/tests/ui/new_without_default.fixed b/tests/ui/new_without_default.fixed
index 277c335cd8851..b5558cd3086cc 100644
--- a/tests/ui/new_without_default.fixed
+++ b/tests/ui/new_without_default.fixed
@@ -322,3 +322,23 @@ where
         Self { _kv: None }
     }
 }
+
+mod issue15778 {
+    pub struct Foo(Vec<i32>);
+
+    impl Foo {
+        pub fn new() -> Self {
+            Self(Vec::new())
+        }
+    }
+
+    impl<'a> IntoIterator for &'a Foo {
+        type Item = &'a i32;
+
+        type IntoIter = std::slice::Iter<'a, i32>;
+
+        fn into_iter(self) -> Self::IntoIter {
+            self.0.as_slice().iter()
+        }
+    }
+}
diff --git a/tests/ui/new_without_default.rs b/tests/ui/new_without_default.rs
index f2844897c93d9..be598c81718f5 100644
--- a/tests/ui/new_without_default.rs
+++ b/tests/ui/new_without_default.rs
@@ -265,3 +265,23 @@ where
         Self { _kv: None }
     }
 }
+
+mod issue15778 {
+    pub struct Foo(Vec<i32>);
+
+    impl Foo {
+        pub fn new() -> Self {
+            Self(Vec::new())
+        }
+    }
+
+    impl<'a> IntoIterator for &'a Foo {
+        type Item = &'a i32;
+
+        type IntoIter = std::slice::Iter<'a, i32>;
+
+        fn into_iter(self) -> Self::IntoIter {
+            self.0.as_slice().iter()
+        }
+    }
+}

From 642feb7e562edcc5d95bbc2e6ca27438fcd3b35f Mon Sep 17 00:00:00 2001
From: yanglsh <yanglsh@shanghaitech.edu.cn>
Date: Tue, 30 Sep 2025 02:28:54 +0800
Subject: [PATCH 1564/1889] fix: `if_then_some_else_none` FP when return exists
 in block expr

---
 clippy_lints/src/if_then_some_else_none.rs |  1 +
 tests/ui/if_then_some_else_none.fixed      | 12 ++++++++++++
 tests/ui/if_then_some_else_none.rs         | 12 ++++++++++++
 3 files changed, 25 insertions(+)

diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index b50d91f101463..f9fee292837ea 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -79,6 +79,7 @@ impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
             && !is_in_const_context(cx)
             && self.msrv.meets(cx, msrvs::BOOL_THEN)
             && !contains_return(then_block.stmts)
+            && then_block.expr.is_none_or(|expr| !contains_return(expr))
         {
             let method_name = if switch_to_eager_eval(cx, expr) && self.msrv.meets(cx, msrvs::BOOL_THEN_SOME) {
                 sym::then_some
diff --git a/tests/ui/if_then_some_else_none.fixed b/tests/ui/if_then_some_else_none.fixed
index 0fd130609aee2..7da9401a308f7 100644
--- a/tests/ui/if_then_some_else_none.fixed
+++ b/tests/ui/if_then_some_else_none.fixed
@@ -206,3 +206,15 @@ fn dont_lint_inside_macros() {
     }
     let _: Option<u32> = mac!(true, 42);
 }
+
+mod issue15770 {
+    fn maybe_error() -> Result<u32, &'static str> {
+        Err("error!")
+    }
+
+    pub fn trying(b: bool) -> Result<(), &'static str> {
+        let _x: Option<u32> = if b { Some(maybe_error()?) } else { None };
+        // Process _x locally
+        Ok(())
+    }
+}
diff --git a/tests/ui/if_then_some_else_none.rs b/tests/ui/if_then_some_else_none.rs
index 640828aa9bf6b..02962f83ce8aa 100644
--- a/tests/ui/if_then_some_else_none.rs
+++ b/tests/ui/if_then_some_else_none.rs
@@ -262,3 +262,15 @@ fn dont_lint_inside_macros() {
     }
     let _: Option<u32> = mac!(true, 42);
 }
+
+mod issue15770 {
+    fn maybe_error() -> Result<u32, &'static str> {
+        Err("error!")
+    }
+
+    pub fn trying(b: bool) -> Result<(), &'static str> {
+        let _x: Option<u32> = if b { Some(maybe_error()?) } else { None };
+        // Process _x locally
+        Ok(())
+    }
+}

From c3e4d2bb90c71040adc120e3322fa2e3696152ab Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Mon, 29 Sep 2025 19:21:21 +0200
Subject: [PATCH 1565/1889] clean-up

---
 clippy_lints/src/unit_types/let_unit_value.rs | 25 +++++++++++++++++--
 tests/ui/let_unit.fixed                       | 15 +++++------
 tests/ui/let_unit.rs                          | 15 +++++------
 tests/ui/let_unit.stderr                      | 10 ++++----
 4 files changed, 40 insertions(+), 25 deletions(-)

diff --git a/clippy_lints/src/unit_types/let_unit_value.rs b/clippy_lints/src/unit_types/let_unit_value.rs
index d5b6c17585494..1f05617a746f3 100644
--- a/clippy_lints/src/unit_types/let_unit_value.rs
+++ b/clippy_lints/src/unit_types/let_unit_value.rs
@@ -89,15 +89,30 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, format_args: &FormatArgsStorag
                         walk_body(&mut visitor, body);
 
                         let mut has_in_format_capture = false;
-                        suggestions.extend(visitor.spans.iter().filter_map(|span| match span {
+                        suggestions.extend(visitor.spans.into_iter().filter_map(|span| match span {
                             MaybeInFormatCapture::Yes => {
                                 has_in_format_capture = true;
                                 None
                             },
-                            MaybeInFormatCapture::No(span) => Some((*span, "()".to_string())),
+                            MaybeInFormatCapture::No(span) => Some((span, "()".to_string())),
                         }));
 
                         if has_in_format_capture {
+                            // In a case like this:
+                            // ```
+                            // let unit = returns_unit();
+                            // eprintln!("{unit}");
+                            // ```
+                            // we can't remove the `unit` binding and replace its uses with a `()`,
+                            // because the `eprintln!` would break.
+                            //
+                            // So do the following instead:
+                            // ```
+                            // let unit = ();
+                            // returns_unit();
+                            // eprintln!("{unit}");
+                            // ```
+                            // TODO: find a less awkward way to do this
                             suggestions.push((
                                 init.span,
                                 format!("();\n{}", reindent_multiline(&snip, false, indent_of(cx, local.span))),
@@ -132,6 +147,12 @@ struct UnitVariableCollector<'a, 'tcx> {
     macro_call: Option<&'a FormatArgs>,
 }
 
+/// Whether the unit variable is captured in a `format!`:
+///
+/// ```ignore
+/// let unit = ();
+/// eprintln!("{unit}");
+/// ```
 enum MaybeInFormatCapture {
     Yes,
     No(Span),
diff --git a/tests/ui/let_unit.fixed b/tests/ui/let_unit.fixed
index 381d4cac4622b..d640c6a916d03 100644
--- a/tests/ui/let_unit.fixed
+++ b/tests/ui/let_unit.fixed
@@ -1,5 +1,5 @@
 #![warn(clippy::let_unit_value)]
-#![allow(unused, clippy::no_effect, clippy::needless_late_init, path_statements)]
+#![allow(clippy::no_effect, clippy::needless_late_init, path_statements)]
 
 macro_rules! let_and_return {
     ($n:expr) => {{
@@ -15,12 +15,12 @@ fn main() {
     if true {
         // do not lint this, since () is explicit
         let _a = ();
-        let () = dummy();
+        let () = returns_unit();
         let () = ();
-        () = dummy();
+        () = returns_unit();
         () = ();
         let _a: () = ();
-        let _a: () = dummy();
+        let _a: () = returns_unit();
     }
 
     consume_units_with_for_loop(); // should be fine as well
@@ -30,7 +30,7 @@ fn main() {
     let_and_return!(()) // should be fine
 }
 
-fn dummy() {}
+fn returns_unit() {}
 
 // Related to issue #1964
 fn consume_units_with_for_loop() {
@@ -181,8 +181,6 @@ async fn issue10433() {
 pub async fn issue11502(a: ()) {}
 
 pub fn issue12594() {
-    fn returns_unit() {}
-
     fn returns_result<T>(res: T) -> Result<T, ()> {
         Ok(res)
     }
@@ -200,11 +198,10 @@ pub fn issue12594() {
 }
 
 fn issue15061() {
-    fn return_unit() {}
     fn do_something(x: ()) {}
 
     let res = ();
-    return_unit();
+    returns_unit();
     //~^ let_unit_value
     do_something(());
     println!("{res:?}");
diff --git a/tests/ui/let_unit.rs b/tests/ui/let_unit.rs
index cdfc74991c40d..d966d2ec0a5c1 100644
--- a/tests/ui/let_unit.rs
+++ b/tests/ui/let_unit.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::let_unit_value)]
-#![allow(unused, clippy::no_effect, clippy::needless_late_init, path_statements)]
+#![allow(clippy::no_effect, clippy::needless_late_init, path_statements)]
 
 macro_rules! let_and_return {
     ($n:expr) => {{
@@ -15,12 +15,12 @@ fn main() {
     if true {
         // do not lint this, since () is explicit
         let _a = ();
-        let () = dummy();
+        let () = returns_unit();
         let () = ();
-        () = dummy();
+        () = returns_unit();
         () = ();
         let _a: () = ();
-        let _a: () = dummy();
+        let _a: () = returns_unit();
     }
 
     consume_units_with_for_loop(); // should be fine as well
@@ -30,7 +30,7 @@ fn main() {
     let_and_return!(()) // should be fine
 }
 
-fn dummy() {}
+fn returns_unit() {}
 
 // Related to issue #1964
 fn consume_units_with_for_loop() {
@@ -181,8 +181,6 @@ async fn issue10433() {
 pub async fn issue11502(a: ()) {}
 
 pub fn issue12594() {
-    fn returns_unit() {}
-
     fn returns_result<T>(res: T) -> Result<T, ()> {
         Ok(res)
     }
@@ -200,10 +198,9 @@ pub fn issue12594() {
 }
 
 fn issue15061() {
-    fn return_unit() {}
     fn do_something(x: ()) {}
 
-    let res = return_unit();
+    let res = returns_unit();
     //~^ let_unit_value
     do_something(res);
     println!("{res:?}");
diff --git a/tests/ui/let_unit.stderr b/tests/ui/let_unit.stderr
index 637c9ff686bdb..4d9bbbe310749 100644
--- a/tests/ui/let_unit.stderr
+++ b/tests/ui/let_unit.stderr
@@ -55,7 +55,7 @@ LL +     };
    |
 
 error: this let-binding has unit value
-  --> tests/ui/let_unit.rs:192:9
+  --> tests/ui/let_unit.rs:190:9
    |
 LL |         let res = returns_unit();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -69,15 +69,15 @@ LL ~         returns_result(()).unwrap();
    |
 
 error: this let-binding has unit value
-  --> tests/ui/let_unit.rs:206:5
+  --> tests/ui/let_unit.rs:203:5
    |
-LL |     let res = return_unit();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     let res = returns_unit();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: replace variable usages with `()`
    |
 LL ~     let res = ();
-LL ~     return_unit();
+LL ~     returns_unit();
 LL |
 LL ~     do_something(());
    |

From 48ee4705ddf68c452525b931355cf546a1bba023 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Mon, 29 Sep 2025 21:16:15 +0200
Subject: [PATCH 1566/1889] fix: actually use the `Applicability`

---
 clippy_lints/src/unit_types/let_unit_value.rs | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/clippy_lints/src/unit_types/let_unit_value.rs b/clippy_lints/src/unit_types/let_unit_value.rs
index 1f05617a746f3..80a99cfd0544b 100644
--- a/clippy_lints/src/unit_types/let_unit_value.rs
+++ b/clippy_lints/src/unit_types/let_unit_value.rs
@@ -117,11 +117,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, format_args: &FormatArgsStorag
                                 init.span,
                                 format!("();\n{}", reindent_multiline(&snip, false, indent_of(cx, local.span))),
                             ));
-                            diag.multipart_suggestion(
-                                "replace variable usages with `()`",
-                                suggestions,
-                                Applicability::MachineApplicable,
-                            );
+                            diag.multipart_suggestion("replace variable usages with `()`", suggestions, app);
                             return;
                         }
                     }
@@ -132,7 +128,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, format_args: &FormatArgsStorag
                     } else {
                         "omit the `let` binding and replace variable usages with `()`"
                     };
-                    diag.multipart_suggestion(message, suggestions, Applicability::MachineApplicable);
+                    diag.multipart_suggestion(message, suggestions, app);
                 },
             );
         }

From f6dd112a0ae3e017828dd49a5dc4e5edd648bca6 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Mon, 29 Sep 2025 19:20:47 +0200
Subject: [PATCH 1567/1889] fix: create the suggestion "differentially"

---
 clippy_lints/src/unit_types/let_unit_value.rs | 18 +++--
 tests/ui/let_unit.fixed                       | 31 +++++++-
 tests/ui/let_unit.rs                          | 30 ++++++-
 tests/ui/let_unit.stderr                      | 78 +++++++++++++------
 4 files changed, 118 insertions(+), 39 deletions(-)

diff --git a/clippy_lints/src/unit_types/let_unit_value.rs b/clippy_lints/src/unit_types/let_unit_value.rs
index 80a99cfd0544b..424aa14cd6863 100644
--- a/clippy_lints/src/unit_types/let_unit_value.rs
+++ b/clippy_lints/src/unit_types/let_unit_value.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::macros::{FormatArgsStorage, find_format_arg_expr, is_format_macro, root_macro_call_first_node};
-use clippy_utils::source::{indent_of, reindent_multiline, snippet_with_context};
+use clippy_utils::source::{snippet_indent, walk_span_to_context};
 use clippy_utils::visitors::{for_each_local_assignment, for_each_value_source};
 use core::ops::ControlFlow;
 use rustc_ast::{FormatArgs, FormatArgumentKind};
@@ -74,10 +74,10 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, format_args: &FormatArgsStorag
                 "this let-binding has unit value",
                 |diag| {
                     let mut suggestions = Vec::new();
+                    let init_new_span = walk_span_to_context(init.span, local.span.ctxt()).unwrap();
 
                     // Suggest omitting the `let` binding
-                    let mut app = Applicability::MachineApplicable;
-                    let snip = snippet_with_context(cx, init.span, local.span.ctxt(), "()", &mut app).0;
+                    let app = Applicability::MachineApplicable;
 
                     // If this is a binding pattern, we need to add suggestions to remove any usages
                     // of the variable
@@ -114,21 +114,23 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, format_args: &FormatArgsStorag
                             // ```
                             // TODO: find a less awkward way to do this
                             suggestions.push((
-                                init.span,
-                                format!("();\n{}", reindent_multiline(&snip, false, indent_of(cx, local.span))),
+                                init_new_span.shrink_to_lo(),
+                                format!("();\n{}", snippet_indent(cx, local.span).as_deref().unwrap_or("")),
                             ));
-                            diag.multipart_suggestion("replace variable usages with `()`", suggestions, app);
+                            diag.multipart_suggestion_verbose("replace variable usages with `()`", suggestions, app);
                             return;
                         }
                     }
 
-                    suggestions.push((local.span, format!("{snip};")));
+                    // let local = returns_unit();
+                    // ^^^^^^^^^^^^ remove this
+                    suggestions.push((local.span.until(init_new_span), String::new()));
                     let message = if suggestions.len() == 1 {
                         "omit the `let` binding"
                     } else {
                         "omit the `let` binding and replace variable usages with `()`"
                     };
-                    diag.multipart_suggestion(message, suggestions, app);
+                    diag.multipart_suggestion_verbose(message, suggestions, app);
                 },
             );
         }
diff --git a/tests/ui/let_unit.fixed b/tests/ui/let_unit.fixed
index d640c6a916d03..e8517f18e788b 100644
--- a/tests/ui/let_unit.fixed
+++ b/tests/ui/let_unit.fixed
@@ -1,5 +1,10 @@
 #![warn(clippy::let_unit_value)]
-#![allow(clippy::no_effect, clippy::needless_late_init, path_statements)]
+#![allow(
+    clippy::no_effect,
+    clippy::needless_late_init,
+    path_statements,
+    clippy::match_single_binding
+)]
 
 macro_rules! let_and_return {
     ($n:expr) => {{
@@ -197,12 +202,30 @@ pub fn issue12594() {
     }
 }
 
-fn issue15061() {
-    fn do_something(x: ()) {}
+fn takes_unit(x: ()) {}
 
+fn issue15061() {
     let res = ();
     returns_unit();
     //~^ let_unit_value
-    do_something(());
+    takes_unit(());
+    println!("{res:?}");
+}
+
+fn issue15771() {
+    match "Example String" {
+        _ => returns_unit(),
+        //~^ let_unit_value
+    }
+
+    if true {}
+    //~^ let_unit_value
+}
+
+fn issue_15784() {
+    let res = ();
+    eprintln!("I return unit");
+    //~^ let_unit_value
+    takes_unit(());
     println!("{res:?}");
 }
diff --git a/tests/ui/let_unit.rs b/tests/ui/let_unit.rs
index d966d2ec0a5c1..3f6f0139b2fec 100644
--- a/tests/ui/let_unit.rs
+++ b/tests/ui/let_unit.rs
@@ -1,5 +1,10 @@
 #![warn(clippy::let_unit_value)]
-#![allow(clippy::no_effect, clippy::needless_late_init, path_statements)]
+#![allow(
+    clippy::no_effect,
+    clippy::needless_late_init,
+    path_statements,
+    clippy::match_single_binding
+)]
 
 macro_rules! let_and_return {
     ($n:expr) => {{
@@ -197,11 +202,28 @@ pub fn issue12594() {
     }
 }
 
-fn issue15061() {
-    fn do_something(x: ()) {}
+fn takes_unit(x: ()) {}
 
+fn issue15061() {
     let res = returns_unit();
     //~^ let_unit_value
-    do_something(res);
+    takes_unit(res);
+    println!("{res:?}");
+}
+
+fn issue15771() {
+    match "Example String" {
+        _ => _ = returns_unit(),
+        //~^ let_unit_value
+    }
+
+    _ = if true {}
+    //~^ let_unit_value
+}
+
+fn issue_15784() {
+    let res = eprintln!("I return unit");
+    //~^ let_unit_value
+    takes_unit(res);
     println!("{res:?}");
 }
diff --git a/tests/ui/let_unit.stderr b/tests/ui/let_unit.stderr
index 4d9bbbe310749..8ced32ab828f7 100644
--- a/tests/ui/let_unit.stderr
+++ b/tests/ui/let_unit.stderr
@@ -1,14 +1,19 @@
 error: this let-binding has unit value
-  --> tests/ui/let_unit.rs:11:5
+  --> tests/ui/let_unit.rs:16:5
    |
 LL |     let _x = println!("x");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^ help: omit the `let` binding: `println!("x");`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::let-unit-value` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::let_unit_value)]`
+help: omit the `let` binding
+   |
+LL -     let _x = println!("x");
+LL +     println!("x");
+   |
 
 error: this let-binding has unit value
-  --> tests/ui/let_unit.rs:60:5
+  --> tests/ui/let_unit.rs:65:5
    |
 LL | /     let _ = v
 LL | |
@@ -21,18 +26,12 @@ LL | |         .unwrap();
    |
 help: omit the `let` binding
    |
-LL ~     v
-LL +
-LL +         .into_iter()
-LL +         .map(|i| i * 2)
-LL +         .filter(|i| i.is_multiple_of(2))
-LL +         .map(|_| ())
-LL +         .next()
-LL +         .unwrap();
+LL -     let _ = v
+LL +     v
    |
 
 error: this let-binding has unit value
-  --> tests/ui/let_unit.rs:110:5
+  --> tests/ui/let_unit.rs:115:5
    |
 LL | /     let x = match Some(0) {
 LL | |
@@ -45,17 +44,12 @@ LL | |     };
    |
 help: omit the `let` binding
    |
-LL ~     match Some(0) {
-LL +
-LL +         None => f2(1),
-LL +         Some(0) => f(),
-LL +         Some(1) => f2(3),
-LL +         Some(_) => (),
-LL +     };
+LL -     let x = match Some(0) {
+LL +     match Some(0) {
    |
 
 error: this let-binding has unit value
-  --> tests/ui/let_unit.rs:190:9
+  --> tests/ui/let_unit.rs:195:9
    |
 LL |         let res = returns_unit();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -69,7 +63,7 @@ LL ~         returns_result(()).unwrap();
    |
 
 error: this let-binding has unit value
-  --> tests/ui/let_unit.rs:203:5
+  --> tests/ui/let_unit.rs:208:5
    |
 LL |     let res = returns_unit();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -79,8 +73,46 @@ help: replace variable usages with `()`
 LL ~     let res = ();
 LL ~     returns_unit();
 LL |
-LL ~     do_something(());
+LL ~     takes_unit(());
+   |
+
+error: this let-binding has unit value
+  --> tests/ui/let_unit.rs:216:14
+   |
+LL |         _ => _ = returns_unit(),
+   |              ^^^^^^^^^^^^^^^^^^
+   |
+help: omit the `let` binding
+   |
+LL -         _ => _ = returns_unit(),
+LL +         _ => returns_unit(),
+   |
+
+error: this let-binding has unit value
+  --> tests/ui/let_unit.rs:220:5
+   |
+LL |     _ = if true {}
+   |     ^^^^^^^^^^^^^^
+   |
+help: omit the `let` binding
+   |
+LL -     _ = if true {}
+LL +     if true {}
+   |
+
+error: this let-binding has unit value
+  --> tests/ui/let_unit.rs:225:5
+   |
+LL |     let res = eprintln!("I return unit");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace variable usages with `()`
+   |
+LL ~     let res = ();
+LL ~     eprintln!("I return unit");
+LL |
+LL ~     takes_unit(());
    |
 
-error: aborting due to 5 previous errors
+error: aborting due to 8 previous errors
 

From 9bb4081fb0977c1a8923fff6ebe60fc882bcac1d Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Mon, 29 Sep 2025 23:42:01 +0200
Subject: [PATCH 1568/1889] remove `reverse_{encode, decode}!`

---
 library/proc_macro/src/bridge/client.rs |  2 +-
 library/proc_macro/src/bridge/mod.rs    | 20 --------------------
 library/proc_macro/src/bridge/server.rs |  2 +-
 3 files changed, 2 insertions(+), 22 deletions(-)

diff --git a/library/proc_macro/src/bridge/client.rs b/library/proc_macro/src/bridge/client.rs
index e7d547966a5d5..4e519e56a1ed4 100644
--- a/library/proc_macro/src/bridge/client.rs
+++ b/library/proc_macro/src/bridge/client.rs
@@ -144,7 +144,7 @@ macro_rules! define_client_side {
 
                     buf.clear();
                     api_tags::Method::$name(api_tags::$name::$method).encode(&mut buf, &mut ());
-                    reverse_encode!(buf; $($arg),*);
+                    $($arg.encode(&mut buf, &mut ());)*
 
                     buf = bridge.dispatch.call(buf);
 
diff --git a/library/proc_macro/src/bridge/mod.rs b/library/proc_macro/src/bridge/mod.rs
index d60a76fff5dc5..7fd67ba465ef4 100644
--- a/library/proc_macro/src/bridge/mod.rs
+++ b/library/proc_macro/src/bridge/mod.rs
@@ -119,26 +119,6 @@ macro_rules! with_api_handle_types {
     };
 }
 
-// FIXME(eddyb) this calls `encode` for each argument, but in reverse,
-// to match the ordering in `reverse_decode`.
-macro_rules! reverse_encode {
-    ($writer:ident;) => {};
-    ($writer:ident; $first:ident $(, $rest:ident)*) => {
-        reverse_encode!($writer; $($rest),*);
-        $first.encode(&mut $writer, &mut ());
-    }
-}
-
-// FIXME(eddyb) this calls `decode` for each argument, but in reverse,
-// to avoid borrow conflicts from borrows started by `&mut` arguments.
-macro_rules! reverse_decode {
-    ($reader:ident, $s:ident;) => {};
-    ($reader:ident, $s:ident; $first:ident: $first_ty:ty $(, $rest:ident: $rest_ty:ty)*) => {
-        reverse_decode!($reader, $s; $($rest: $rest_ty),*);
-        let $first = <$first_ty>::decode(&mut $reader, $s);
-    }
-}
-
 #[allow(unsafe_code)]
 mod arena;
 #[allow(unsafe_code)]
diff --git a/library/proc_macro/src/bridge/server.rs b/library/proc_macro/src/bridge/server.rs
index 5beda7c3c96e5..724ccbd96c59b 100644
--- a/library/proc_macro/src/bridge/server.rs
+++ b/library/proc_macro/src/bridge/server.rs
@@ -178,7 +178,7 @@ macro_rules! define_dispatcher_impl {
                     $(api_tags::Method::$name(m) => match m {
                         $(api_tags::$name::$method => {
                             let mut call_method = || {
-                                reverse_decode!(reader, handle_store; $($arg: $arg_ty),*);
+                                $(let $arg = <$arg_ty>::decode(&mut reader, handle_store);)*
                                 $name::$method(server, $($arg),*)
                             };
                             // HACK(eddyb) don't use `panic::catch_unwind` in a panic.

From 23f340061395300415d551fdac92d28ca2f2fbfb Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Tue, 30 Sep 2025 00:01:17 +0200
Subject: [PATCH 1569/1889] remove unused `#![feature(stmt_expr_attributes)]`

---
 library/proc_macro/src/lib.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/library/proc_macro/src/lib.rs b/library/proc_macro/src/lib.rs
index 162b4fdcc8ae2..613abd7024e3f 100644
--- a/library/proc_macro/src/lib.rs
+++ b/library/proc_macro/src/lib.rs
@@ -27,7 +27,6 @@
 #![feature(panic_can_unwind)]
 #![feature(restricted_std)]
 #![feature(rustc_attrs)]
-#![feature(stmt_expr_attributes)]
 #![feature(extend_one)]
 #![recursion_limit = "256"]
 #![allow(internal_features)]

From d7773f6b1c220d43946bce8010847837ad334b74 Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Tue, 30 Sep 2025 00:09:12 +0200
Subject: [PATCH 1570/1889] explicitly implement `!Send` and `!Sync`

---
 library/proc_macro/src/bridge/client.rs  | 17 ++++++-----------
 library/proc_macro/src/bridge/closure.rs |  4 +---
 library/proc_macro/src/bridge/mod.rs     |  8 +++-----
 library/proc_macro/src/bridge/server.rs  | 14 ++------------
 4 files changed, 12 insertions(+), 31 deletions(-)

diff --git a/library/proc_macro/src/bridge/client.rs b/library/proc_macro/src/bridge/client.rs
index 4e519e56a1ed4..92558f2b7d9cc 100644
--- a/library/proc_macro/src/bridge/client.rs
+++ b/library/proc_macro/src/bridge/client.rs
@@ -26,18 +26,16 @@ macro_rules! define_client_handles {
         $(
             pub(crate) struct $oty {
                 handle: handle::Handle,
-                // Prevent Send and Sync impls. `!Send`/`!Sync` is the usual
-                // way of doing this, but that requires unstable features.
-                // rust-analyzer uses this code and avoids unstable features.
-                _marker: PhantomData<*mut ()>,
             }
 
+            impl !Send for $oty {}
+            impl !Sync for $oty {}
+
             // Forward `Drop::drop` to the inherent `drop` method.
             impl Drop for $oty {
                 fn drop(&mut self) {
                     $oty {
                         handle: self.handle,
-                        _marker: PhantomData,
                     }.drop();
                 }
             }
@@ -64,7 +62,6 @@ macro_rules! define_client_handles {
                 fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
                     $oty {
                         handle: handle::Handle::decode(r, s),
-                        _marker: PhantomData,
                     }
                 }
             }
@@ -74,12 +71,11 @@ macro_rules! define_client_handles {
             #[derive(Copy, Clone, PartialEq, Eq, Hash)]
             pub(crate) struct $ity {
                 handle: handle::Handle,
-                // Prevent Send and Sync impls. `!Send`/`!Sync` is the usual
-                // way of doing this, but that requires unstable features.
-                // rust-analyzer uses this code and avoids unstable features.
-                _marker: PhantomData<*mut ()>,
             }
 
+            impl !Send for $ity {}
+            impl !Sync for $ity {}
+
             impl<S> Encode<S> for $ity {
                 fn encode(self, w: &mut Writer, s: &mut S) {
                     self.handle.encode(w, s);
@@ -90,7 +86,6 @@ macro_rules! define_client_handles {
                 fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
                     $ity {
                         handle: handle::Handle::decode(r, s),
-                        _marker: PhantomData,
                     }
                 }
             }
diff --git a/library/proc_macro/src/bridge/closure.rs b/library/proc_macro/src/bridge/closure.rs
index e0e688434dce5..e5133907854b2 100644
--- a/library/proc_macro/src/bridge/closure.rs
+++ b/library/proc_macro/src/bridge/closure.rs
@@ -6,9 +6,7 @@ use std::marker::PhantomData;
 pub(super) struct Closure<'a, A, R> {
     call: unsafe extern "C" fn(*mut Env, A) -> R,
     env: *mut Env,
-    // Prevent Send and Sync impls. `!Send`/`!Sync` is the usual way of doing
-    // this, but that requires unstable features. rust-analyzer uses this code
-    // and avoids unstable features.
+    // Prevent Send and Sync impls.
     //
     // The `'a` lifetime parameter represents the lifetime of `Env`.
     _marker: PhantomData<*mut &'a mut ()>,
diff --git a/library/proc_macro/src/bridge/mod.rs b/library/proc_macro/src/bridge/mod.rs
index 7fd67ba465ef4..1b09deb6bfe60 100644
--- a/library/proc_macro/src/bridge/mod.rs
+++ b/library/proc_macro/src/bridge/mod.rs
@@ -160,13 +160,11 @@ pub struct BridgeConfig<'a> {
 
     /// If 'true', always invoke the default panic hook
     force_show_panics: bool,
-
-    // Prevent Send and Sync impls. `!Send`/`!Sync` is the usual way of doing
-    // this, but that requires unstable features. rust-analyzer uses this code
-    // and avoids unstable features.
-    _marker: marker::PhantomData<*mut ()>,
 }
 
+impl !Send for BridgeConfig<'_> {}
+impl !Sync for BridgeConfig<'_> {}
+
 #[forbid(unsafe_code)]
 #[allow(non_camel_case_types)]
 mod api_tags {
diff --git a/library/proc_macro/src/bridge/server.rs b/library/proc_macro/src/bridge/server.rs
index 724ccbd96c59b..0bb30698aa1d7 100644
--- a/library/proc_macro/src/bridge/server.rs
+++ b/library/proc_macro/src/bridge/server.rs
@@ -295,12 +295,7 @@ impl ExecutionStrategy for SameThread {
 
         let mut dispatch = |buf| dispatcher.dispatch(buf);
 
-        run_client(BridgeConfig {
-            input,
-            dispatch: (&mut dispatch).into(),
-            force_show_panics,
-            _marker: marker::PhantomData,
-        })
+        run_client(BridgeConfig { input, dispatch: (&mut dispatch).into(), force_show_panics })
     }
 }
 
@@ -331,12 +326,7 @@ where
                 client.recv().expect("server died while client waiting for reply")
             };
 
-            run_client(BridgeConfig {
-                input,
-                dispatch: (&mut dispatch).into(),
-                force_show_panics,
-                _marker: marker::PhantomData,
-            })
+            run_client(BridgeConfig { input, dispatch: (&mut dispatch).into(), force_show_panics })
         });
 
         while let Some(b) = server.recv() {

From 73f6b08022944d24fb5b623494a18cc95df21802 Mon Sep 17 00:00:00 2001
From: Jynn Nelson <jynn.nelson@ferrous-systems.com>
Date: Mon, 22 Sep 2025 10:59:39 -0700
Subject: [PATCH 1571/1889] Don't condition RUSTDOC_LIBDIR on `--no-doc`

In d94e7ff065cd393a645eb3e9c96ce0418856e95d, `rustdoc_path` was changed
to ignore `want_rustdoc` (which is just whether `--no-doc` was passed).
But RUSTDOC_LIBDIR wasn't kept in sync. Rather than trying to keep
`rustdoc_path` in sync with `RUSTDOC_LIBDIR`, just pass LIBDIR to the
rustc shim unconditionally.

This fix allows calling `ensure(doc::Step)` from a non-doc top-level
Step, even if `--no-doc` was present in the command line.
---
 src/bootstrap/src/core/builder/cargo.rs | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

diff --git a/src/bootstrap/src/core/builder/cargo.rs b/src/bootstrap/src/core/builder/cargo.rs
index 9fc4ce669c2a5..a404aec512091 100644
--- a/src/bootstrap/src/core/builder/cargo.rs
+++ b/src/bootstrap/src/core/builder/cargo.rs
@@ -10,7 +10,7 @@ use crate::core::config::flags::Color;
 use crate::utils::build_stamp;
 use crate::utils::helpers::{self, LldThreads, check_cfg_arg, linker_args, linker_flags};
 use crate::{
-    BootstrapCommand, CLang, Compiler, Config, DocTests, DryRun, EXTRA_CHECK_CFGS, GitRepo, Mode,
+    BootstrapCommand, CLang, Compiler, Config, DryRun, EXTRA_CHECK_CFGS, GitRepo, Mode,
     RemapScheme, TargetSelection, command, prepare_behaviour_dump_dir, t,
 };
 
@@ -851,8 +851,6 @@ impl Builder<'_> {
 
         rustflags.arg("-Zmacro-backtrace");
 
-        let want_rustdoc = self.doc_tests != DocTests::No;
-
         // Clear the output directory if the real rustc we're using has changed;
         // Cargo cannot detect this as it thinks rustc is bootstrap/debug/rustc.
         //
@@ -881,7 +879,8 @@ impl Builder<'_> {
             .env("RUSTC_REAL", self.rustc(compiler))
             .env("RUSTC_STAGE", build_compiler_stage.to_string())
             .env("RUSTC_SYSROOT", sysroot)
-            .env("RUSTC_LIBDIR", libdir)
+            .env("RUSTC_LIBDIR", &libdir)
+            .env("RUSTDOC_LIBDIR", libdir)
             .env("RUSTDOC", self.bootstrap_out.join("rustdoc"))
             .env("RUSTDOC_REAL", rustdoc_path)
             .env("RUSTC_ERROR_METADATA_DST", self.extended_error_dir());
@@ -919,11 +918,6 @@ impl Builder<'_> {
             rustflags.arg(&format!("-Zstack-protector={stack_protector}"));
         }
 
-        if !matches!(cmd_kind, Kind::Build | Kind::Check | Kind::Clippy | Kind::Fix) && want_rustdoc
-        {
-            cargo.env("RUSTDOC_LIBDIR", self.rustc_libdir(compiler));
-        }
-
         let debuginfo_level = match mode {
             Mode::Rustc | Mode::Codegen => self.config.rust_debuginfo_level_rustc,
             Mode::Std => self.config.rust_debuginfo_level_std,

From 93355f1c7b279866718f76609450cfa1b8cc9973 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Fri, 19 Sep 2025 20:17:07 +0200
Subject: [PATCH 1572/1889] clean-up

- reduce indentation
- use `snippet_with_applicability`
---
 clippy_lints/src/new_without_default.rs | 170 ++++++++++++------------
 tests/ui/new_without_default.fixed      |   1 -
 tests/ui/new_without_default.rs         |   1 -
 tests/ui/new_without_default.stderr     |  18 +--
 4 files changed, 92 insertions(+), 98 deletions(-)

diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index ab7b09c48a7fe..5a409a811c30a 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::return_ty;
-use clippy_utils::source::snippet;
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::DiagExt;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -58,103 +58,99 @@ impl_lint_pass!(NewWithoutDefault => [NEW_WITHOUT_DEFAULT]);
 
 impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
-        if let hir::ItemKind::Impl(hir::Impl {
+        let hir::ItemKind::Impl(hir::Impl {
             of_trait: None,
             generics,
             self_ty: impl_self_ty,
             ..
         }) = item.kind
+        else {
+            return;
+        };
+
+        for assoc_item in cx
+            .tcx
+            .associated_items(item.owner_id.def_id)
+            .filter_by_name_unhygienic(sym::new)
         {
-            for assoc_item in cx
-                .tcx
-                .associated_items(item.owner_id.def_id)
-                .filter_by_name_unhygienic(sym::new)
+            if let AssocKind::Fn { has_self: false, .. } = assoc_item.kind
+                && let impl_item = cx
+                    .tcx
+                    .hir_node_by_def_id(assoc_item.def_id.expect_local())
+                    .expect_impl_item()
+                && !impl_item.span.in_external_macro(cx.sess().source_map())
+                && let hir::ImplItemKind::Fn(ref sig, _) = impl_item.kind
+                && let id = impl_item.owner_id
+                // can't be implemented for unsafe new
+                && !sig.header.is_unsafe()
+                // shouldn't be implemented when it is hidden in docs
+                && !cx.tcx.is_doc_hidden(impl_item.owner_id.def_id)
+                // when the result of `new()` depends on a parameter we should not require
+                // an impl of `Default`
+                && impl_item.generics.params.is_empty()
+                && sig.decl.inputs.is_empty()
+                && cx.effective_visibilities.is_exported(impl_item.owner_id.def_id)
+                && let self_ty = cx.tcx.type_of(item.owner_id).instantiate_identity()
+                && self_ty == return_ty(cx, impl_item.owner_id)
+                && let Some(default_trait_id) = cx.tcx.get_diagnostic_item(sym::Default)
             {
-                if let AssocKind::Fn { has_self: false, .. } = assoc_item.kind {
-                    let impl_item = cx
-                        .tcx
-                        .hir_node_by_def_id(assoc_item.def_id.expect_local())
-                        .expect_impl_item();
-                    if impl_item.span.in_external_macro(cx.sess().source_map()) {
-                        return;
-                    }
-                    if let hir::ImplItemKind::Fn(ref sig, _) = impl_item.kind {
-                        let id = impl_item.owner_id;
-                        if sig.header.is_unsafe() {
-                            // can't be implemented for unsafe new
-                            return;
-                        }
-                        if cx.tcx.is_doc_hidden(impl_item.owner_id.def_id) {
-                            // shouldn't be implemented when it is hidden in docs
-                            return;
-                        }
-                        if !impl_item.generics.params.is_empty() {
-                            // when the result of `new()` depends on a parameter we should not require
-                            // an impl of `Default`
-                            return;
-                        }
-                        if sig.decl.inputs.is_empty()
-                            && cx.effective_visibilities.is_exported(impl_item.owner_id.def_id)
-                            && let self_ty = cx.tcx.type_of(item.owner_id).instantiate_identity()
-                            && self_ty == return_ty(cx, impl_item.owner_id)
-                            && let Some(default_trait_id) = cx.tcx.get_diagnostic_item(sym::Default)
+                if self.impling_types.is_none() {
+                    let mut impls = HirIdSet::default();
+                    for &d in cx.tcx.local_trait_impls(default_trait_id) {
+                        let ty = cx.tcx.type_of(d).instantiate_identity();
+                        if let Some(ty_def) = ty.ty_adt_def()
+                            && let Some(local_def_id) = ty_def.did().as_local()
                         {
-                            if self.impling_types.is_none() {
-                                let mut impls = HirIdSet::default();
-                                for &d in cx.tcx.local_trait_impls(default_trait_id) {
-                                    let ty = cx.tcx.type_of(d).instantiate_identity();
-                                    if let Some(ty_def) = ty.ty_adt_def()
-                                        && let Some(local_def_id) = ty_def.did().as_local()
-                                    {
-                                        impls.insert(cx.tcx.local_def_id_to_hir_id(local_def_id));
-                                    }
-                                }
-                                self.impling_types = Some(impls);
-                            }
-
-                            // Check if a Default implementation exists for the Self type, regardless of
-                            // generics
-                            if let Some(ref impling_types) = self.impling_types
-                                && let self_def = cx.tcx.type_of(item.owner_id).instantiate_identity()
-                                && let Some(self_def) = self_def.ty_adt_def()
-                                && let Some(self_local_did) = self_def.did().as_local()
-                                && let self_id = cx.tcx.local_def_id_to_hir_id(self_local_did)
-                                && impling_types.contains(&self_id)
-                            {
-                                return;
-                            }
-
-                            let generics_sugg = snippet(cx, generics.span, "");
-                            let where_clause_sugg = if generics.has_where_clause_predicates {
-                                format!("\n{}\n", snippet(cx, generics.where_clause_span, ""))
-                            } else {
-                                String::new()
-                            };
-                            let self_ty_fmt = self_ty.to_string();
-                            let self_type_snip = snippet(cx, impl_self_ty.span, &self_ty_fmt);
-                            span_lint_hir_and_then(
-                                cx,
-                                NEW_WITHOUT_DEFAULT,
-                                id.into(),
-                                impl_item.span,
-                                format!("you should consider adding a `Default` implementation for `{self_type_snip}`"),
-                                |diag| {
-                                    diag.suggest_prepend_item(
-                                        cx,
-                                        item.span,
-                                        "try adding this",
-                                        &create_new_without_default_suggest_msg(
-                                            &self_type_snip,
-                                            &generics_sugg,
-                                            &where_clause_sugg,
-                                        ),
-                                        Applicability::MachineApplicable,
-                                    );
-                                },
-                            );
+                            impls.insert(cx.tcx.local_def_id_to_hir_id(local_def_id));
                         }
                     }
+                    self.impling_types = Some(impls);
                 }
+
+                // Check if a Default implementation exists for the Self type, regardless of
+                // generics
+                if let Some(ref impling_types) = self.impling_types
+                    && let self_def = cx.tcx.type_of(item.owner_id).instantiate_identity()
+                    && let Some(self_def) = self_def.ty_adt_def()
+                    && let Some(self_local_did) = self_def.did().as_local()
+                    && let self_id = cx.tcx.local_def_id_to_hir_id(self_local_did)
+                    && impling_types.contains(&self_id)
+                {
+                    return;
+                }
+
+                let mut app = Applicability::MachineApplicable;
+                let generics_sugg = snippet_with_applicability(cx, generics.span, "", &mut app);
+                let where_clause_sugg = if generics.has_where_clause_predicates {
+                    format!(
+                        "\n{}\n",
+                        snippet_with_applicability(cx, generics.where_clause_span, "", &mut app)
+                    )
+                } else {
+                    String::new()
+                };
+                let self_ty_fmt = self_ty.to_string();
+                let self_type_snip = snippet_with_applicability(cx, impl_self_ty.span, &self_ty_fmt, &mut app);
+                span_lint_hir_and_then(
+                    cx,
+                    NEW_WITHOUT_DEFAULT,
+                    id.into(),
+                    impl_item.span,
+                    format!("you should consider adding a `Default` implementation for `{self_type_snip}`"),
+                    |diag| {
+                        diag.suggest_prepend_item(
+                            cx,
+                            item.span,
+                            "try adding this",
+                            &create_new_without_default_suggest_msg(
+                                &self_type_snip,
+                                &generics_sugg,
+                                &where_clause_sugg,
+                            ),
+                            app,
+                        );
+                    },
+                );
             }
         }
     }
diff --git a/tests/ui/new_without_default.fixed b/tests/ui/new_without_default.fixed
index b5558cd3086cc..4eb2a9903b9a8 100644
--- a/tests/ui/new_without_default.fixed
+++ b/tests/ui/new_without_default.fixed
@@ -1,5 +1,4 @@
 #![allow(
-    dead_code,
     clippy::missing_safety_doc,
     clippy::extra_unused_lifetimes,
     clippy::extra_unused_type_parameters,
diff --git a/tests/ui/new_without_default.rs b/tests/ui/new_without_default.rs
index be598c81718f5..cfcff1e3ac3d0 100644
--- a/tests/ui/new_without_default.rs
+++ b/tests/ui/new_without_default.rs
@@ -1,5 +1,4 @@
 #![allow(
-    dead_code,
     clippy::missing_safety_doc,
     clippy::extra_unused_lifetimes,
     clippy::extra_unused_type_parameters,
diff --git a/tests/ui/new_without_default.stderr b/tests/ui/new_without_default.stderr
index 70a65aba464b8..a0b4d3704f56c 100644
--- a/tests/ui/new_without_default.stderr
+++ b/tests/ui/new_without_default.stderr
@@ -1,5 +1,5 @@
 error: you should consider adding a `Default` implementation for `Foo`
-  --> tests/ui/new_without_default.rs:13:5
+  --> tests/ui/new_without_default.rs:12:5
    |
 LL | /     pub fn new() -> Foo {
 LL | |
@@ -20,7 +20,7 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `Bar`
-  --> tests/ui/new_without_default.rs:23:5
+  --> tests/ui/new_without_default.rs:22:5
    |
 LL | /     pub fn new() -> Self {
 LL | |
@@ -39,7 +39,7 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `LtKo<'c>`
-  --> tests/ui/new_without_default.rs:89:5
+  --> tests/ui/new_without_default.rs:88:5
    |
 LL | /     pub fn new() -> LtKo<'c> {
 LL | |
@@ -58,7 +58,7 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `Const`
-  --> tests/ui/new_without_default.rs:123:5
+  --> tests/ui/new_without_default.rs:122:5
    |
 LL | /     pub const fn new() -> Const {
 LL | |
@@ -76,7 +76,7 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `NewNotEqualToDerive`
-  --> tests/ui/new_without_default.rs:184:5
+  --> tests/ui/new_without_default.rs:183:5
    |
 LL | /     pub fn new() -> Self {
 LL | |
@@ -95,7 +95,7 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `FooGenerics<T>`
-  --> tests/ui/new_without_default.rs:194:5
+  --> tests/ui/new_without_default.rs:193:5
    |
 LL | /     pub fn new() -> Self {
 LL | |
@@ -114,7 +114,7 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `BarGenerics<T>`
-  --> tests/ui/new_without_default.rs:203:5
+  --> tests/ui/new_without_default.rs:202:5
    |
 LL | /     pub fn new() -> Self {
 LL | |
@@ -133,7 +133,7 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `Foo<T>`
-  --> tests/ui/new_without_default.rs:216:9
+  --> tests/ui/new_without_default.rs:215:9
    |
 LL | /         pub fn new() -> Self {
 LL | |
@@ -154,7 +154,7 @@ LL ~     impl<T> Foo<T> {
    |
 
 error: you should consider adding a `Default` implementation for `MyStruct<K, V>`
-  --> tests/ui/new_without_default.rs:263:5
+  --> tests/ui/new_without_default.rs:262:5
    |
 LL | /     pub fn new() -> Self {
 LL | |

From 7a04adae7d68f9a404e5843039479b954cfa0bb5 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Fri, 19 Sep 2025 22:21:16 +0200
Subject: [PATCH 1573/1889] fix(new_without_default): if `new` has `#[cfg]`,
 copy that onto `impl Default`

---
 clippy_lints/src/new_without_default.rs | 30 +++++++--
 tests/ui/new_without_default.fixed      | 68 +++++++++++++++++++++
 tests/ui/new_without_default.rs         | 40 ++++++++++++
 tests/ui/new_without_default.stderr     | 81 ++++++++++++++++++++++++-
 4 files changed, 213 insertions(+), 6 deletions(-)

diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index 5a409a811c30a..6fc034b6fc5d2 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -74,10 +74,8 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
             .filter_by_name_unhygienic(sym::new)
         {
             if let AssocKind::Fn { has_self: false, .. } = assoc_item.kind
-                && let impl_item = cx
-                    .tcx
-                    .hir_node_by_def_id(assoc_item.def_id.expect_local())
-                    .expect_impl_item()
+                && let assoc_item_hir_id = cx.tcx.local_def_id_to_hir_id(assoc_item.def_id.expect_local())
+                && let impl_item = cx.tcx.hir_node(assoc_item_hir_id).expect_impl_item()
                 && !impl_item.span.in_external_macro(cx.sess().source_map())
                 && let hir::ImplItemKind::Fn(ref sig, _) = impl_item.kind
                 && let id = impl_item.owner_id
@@ -120,6 +118,26 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
                 }
 
                 let mut app = Applicability::MachineApplicable;
+                let attrs_sugg = {
+                    let mut sugg = String::new();
+                    for attr in cx.tcx.hir_attrs(assoc_item_hir_id) {
+                        if !attr.has_name(sym::cfg_trace) {
+                            // This might be some other attribute that the `impl Default` ought to inherit.
+                            // But it could also be one of the many attributes that:
+                            // - can't be put on an impl block -- like `#[inline]`
+                            // - we can't even build a suggestion for, since `Attribute::span` may panic.
+                            //
+                            // Because of all that, remain on the safer side -- don't inherit this attr, and just
+                            // reduce the applicability
+                            app = Applicability::MaybeIncorrect;
+                            continue;
+                        }
+
+                        sugg.push_str(&snippet_with_applicability(cx.sess(), attr.span(), "_", &mut app));
+                        sugg.push('\n');
+                    }
+                    sugg
+                };
                 let generics_sugg = snippet_with_applicability(cx, generics.span, "", &mut app);
                 let where_clause_sugg = if generics.has_where_clause_predicates {
                     format!(
@@ -143,6 +161,7 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
                             item.span,
                             "try adding this",
                             &create_new_without_default_suggest_msg(
+                                &attrs_sugg,
                                 &self_type_snip,
                                 &generics_sugg,
                                 &where_clause_sugg,
@@ -157,13 +176,14 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
 }
 
 fn create_new_without_default_suggest_msg(
+    attrs_sugg: &str,
     self_type_snip: &str,
     generics_sugg: &str,
     where_clause_sugg: &str,
 ) -> String {
     #[rustfmt::skip]
     format!(
-"impl{generics_sugg} Default for {self_type_snip}{where_clause_sugg} {{
+"{attrs_sugg}impl{generics_sugg} Default for {self_type_snip}{where_clause_sugg} {{
     fn default() -> Self {{
         Self::new()
     }}
diff --git a/tests/ui/new_without_default.fixed b/tests/ui/new_without_default.fixed
index 4eb2a9903b9a8..9a5e90b48065c 100644
--- a/tests/ui/new_without_default.fixed
+++ b/tests/ui/new_without_default.fixed
@@ -322,6 +322,74 @@ where
     }
 }
 
+// From issue #14552, but with `#[cfg]`s that are actually `true` in the uitest context
+
+pub struct NewWithCfg;
+#[cfg(not(test))]
+impl Default for NewWithCfg {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl NewWithCfg {
+    #[cfg(not(test))]
+    pub fn new() -> Self {
+        //~^ new_without_default
+        unimplemented!()
+    }
+}
+
+pub struct NewWith2Cfgs;
+#[cfg(not(test))]
+#[cfg(panic = "unwind")]
+impl Default for NewWith2Cfgs {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl NewWith2Cfgs {
+    #[cfg(not(test))]
+    #[cfg(panic = "unwind")]
+    pub fn new() -> Self {
+        //~^ new_without_default
+        unimplemented!()
+    }
+}
+
+pub struct NewWithExtraneous;
+impl Default for NewWithExtraneous {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl NewWithExtraneous {
+    #[inline]
+    pub fn new() -> Self {
+        //~^ new_without_default
+        unimplemented!()
+    }
+}
+
+pub struct NewWithCfgAndExtraneous;
+#[cfg(not(test))]
+impl Default for NewWithCfgAndExtraneous {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl NewWithCfgAndExtraneous {
+    #[cfg(not(test))]
+    #[inline]
+    pub fn new() -> Self {
+        //~^ new_without_default
+        unimplemented!()
+    }
+}
+
 mod issue15778 {
     pub struct Foo(Vec<i32>);
 
diff --git a/tests/ui/new_without_default.rs b/tests/ui/new_without_default.rs
index cfcff1e3ac3d0..f7466aa321896 100644
--- a/tests/ui/new_without_default.rs
+++ b/tests/ui/new_without_default.rs
@@ -265,6 +265,46 @@ where
     }
 }
 
+// From issue #14552, but with `#[cfg]`s that are actually `true` in the uitest context
+
+pub struct NewWithCfg;
+impl NewWithCfg {
+    #[cfg(not(test))]
+    pub fn new() -> Self {
+        //~^ new_without_default
+        unimplemented!()
+    }
+}
+
+pub struct NewWith2Cfgs;
+impl NewWith2Cfgs {
+    #[cfg(not(test))]
+    #[cfg(panic = "unwind")]
+    pub fn new() -> Self {
+        //~^ new_without_default
+        unimplemented!()
+    }
+}
+
+pub struct NewWithExtraneous;
+impl NewWithExtraneous {
+    #[inline]
+    pub fn new() -> Self {
+        //~^ new_without_default
+        unimplemented!()
+    }
+}
+
+pub struct NewWithCfgAndExtraneous;
+impl NewWithCfgAndExtraneous {
+    #[cfg(not(test))]
+    #[inline]
+    pub fn new() -> Self {
+        //~^ new_without_default
+        unimplemented!()
+    }
+}
+
 mod issue15778 {
     pub struct Foo(Vec<i32>);
 
diff --git a/tests/ui/new_without_default.stderr b/tests/ui/new_without_default.stderr
index a0b4d3704f56c..1e0d5e2131994 100644
--- a/tests/ui/new_without_default.stderr
+++ b/tests/ui/new_without_default.stderr
@@ -174,5 +174,84 @@ LL +     }
 LL + }
    |
 
-error: aborting due to 9 previous errors
+error: you should consider adding a `Default` implementation for `NewWithCfg`
+  --> tests/ui/new_without_default.rs:273:5
+   |
+LL | /     pub fn new() -> Self {
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+help: try adding this
+   |
+LL + #[cfg(not(test))]
+LL + impl Default for NewWithCfg {
+LL +     fn default() -> Self {
+LL +         Self::new()
+LL +     }
+LL + }
+LL | impl NewWithCfg {
+   |
+
+error: you should consider adding a `Default` implementation for `NewWith2Cfgs`
+  --> tests/ui/new_without_default.rs:283:5
+   |
+LL | /     pub fn new() -> Self {
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+help: try adding this
+   |
+LL + #[cfg(not(test))]
+LL + #[cfg(panic = "unwind")]
+LL + impl Default for NewWith2Cfgs {
+LL +     fn default() -> Self {
+LL +         Self::new()
+LL +     }
+LL + }
+LL | impl NewWith2Cfgs {
+   |
+
+error: you should consider adding a `Default` implementation for `NewWithExtraneous`
+  --> tests/ui/new_without_default.rs:292:5
+   |
+LL | /     pub fn new() -> Self {
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+help: try adding this
+   |
+LL + impl Default for NewWithExtraneous {
+LL +     fn default() -> Self {
+LL +         Self::new()
+LL +     }
+LL + }
+   |
+
+error: you should consider adding a `Default` implementation for `NewWithCfgAndExtraneous`
+  --> tests/ui/new_without_default.rs:302:5
+   |
+LL | /     pub fn new() -> Self {
+LL | |
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+help: try adding this
+   |
+LL + #[cfg(not(test))]
+LL + impl Default for NewWithCfgAndExtraneous {
+LL +     fn default() -> Self {
+LL +         Self::new()
+LL +     }
+LL + }
+LL | impl NewWithCfgAndExtraneous {
+   |
+
+error: aborting due to 13 previous errors
 

From 505a2084e683662e1521b3ba64e23e9271f8e192 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Mon, 29 Sep 2025 22:57:14 +1000
Subject: [PATCH 1574/1889] Split off a separate name/value parser for
 debuginfo test commands

---
 src/tools/compiletest/src/directives.rs       |  2 +-
 src/tools/compiletest/src/runtest/debugger.rs | 27 ++++++++++---------
 .../compiletest/src/runtest/debuginfo.rs      |  6 ++---
 3 files changed, 19 insertions(+), 16 deletions(-)

diff --git a/src/tools/compiletest/src/directives.rs b/src/tools/compiletest/src/directives.rs
index e84a22787668d..e864594ade2e8 100644
--- a/src/tools/compiletest/src/directives.rs
+++ b/src/tools/compiletest/src/directives.rs
@@ -1121,7 +1121,7 @@ impl Config {
         line.starts_with("no-") && self.parse_name_directive(&line[3..], directive)
     }
 
-    pub fn parse_name_value_directive(
+    fn parse_name_value_directive(
         &self,
         line: &str,
         directive: &str,
diff --git a/src/tools/compiletest/src/runtest/debugger.rs b/src/tools/compiletest/src/runtest/debugger.rs
index ba824124e875d..3d439e98eb7e1 100644
--- a/src/tools/compiletest/src/runtest/debugger.rs
+++ b/src/tools/compiletest/src/runtest/debugger.rs
@@ -4,7 +4,6 @@ use std::io::{BufRead, BufReader};
 
 use camino::{Utf8Path, Utf8PathBuf};
 
-use crate::common::Config;
 use crate::runtest::ProcRes;
 
 /// Representation of information to invoke a debugger and check its output
@@ -20,11 +19,7 @@ pub(super) struct DebuggerCommands {
 }
 
 impl DebuggerCommands {
-    pub fn parse_from(
-        file: &Utf8Path,
-        config: &Config,
-        debugger_prefix: &str,
-    ) -> Result<Self, String> {
+    pub fn parse_from(file: &Utf8Path, debugger_prefix: &str) -> Result<Self, String> {
         let command_directive = format!("{debugger_prefix}-command");
         let check_directive = format!("{debugger_prefix}-check");
 
@@ -47,14 +42,10 @@ impl DebuggerCommands {
                 continue;
             };
 
-            if let Some(command) =
-                config.parse_name_value_directive(&line, &command_directive, file, line_no)
-            {
+            if let Some(command) = parse_name_value(&line, &command_directive) {
                 commands.push(command);
             }
-            if let Some(pattern) =
-                config.parse_name_value_directive(&line, &check_directive, file, line_no)
-            {
+            if let Some(pattern) = parse_name_value(&line, &check_directive) {
                 check_lines.push((line_no, pattern));
             }
         }
@@ -114,6 +105,18 @@ impl DebuggerCommands {
     }
 }
 
+/// Split off from the main `parse_name_value_directive`, so that improvements
+/// to directive handling aren't held back by debuginfo test commands.
+fn parse_name_value(line: &str, name: &str) -> Option<String> {
+    if let Some(after_name) = line.strip_prefix(name)
+        && let Some(value) = after_name.strip_prefix(':')
+    {
+        Some(value.to_owned())
+    } else {
+        None
+    }
+}
+
 /// Check that the pattern in `check_line` applies to `line`. Returns `true` if they do match.
 fn check_single_line(line: &str, check_line: &str) -> bool {
     // Allow check lines to leave parts unspecified (e.g., uninitialized
diff --git a/src/tools/compiletest/src/runtest/debuginfo.rs b/src/tools/compiletest/src/runtest/debuginfo.rs
index 071c0863b7e9f..9175a38ffa5c9 100644
--- a/src/tools/compiletest/src/runtest/debuginfo.rs
+++ b/src/tools/compiletest/src/runtest/debuginfo.rs
@@ -59,7 +59,7 @@ impl TestCx<'_> {
         }
 
         // Parse debugger commands etc from test files
-        let dbg_cmds = DebuggerCommands::parse_from(&self.testpaths.file, self.config, "cdb")
+        let dbg_cmds = DebuggerCommands::parse_from(&self.testpaths.file, "cdb")
             .unwrap_or_else(|e| self.fatal(&e));
 
         // https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/debugger-commands
@@ -130,7 +130,7 @@ impl TestCx<'_> {
     }
 
     fn run_debuginfo_gdb_test_no_opt(&self) {
-        let dbg_cmds = DebuggerCommands::parse_from(&self.testpaths.file, self.config, "gdb")
+        let dbg_cmds = DebuggerCommands::parse_from(&self.testpaths.file, "gdb")
             .unwrap_or_else(|e| self.fatal(&e));
         let mut cmds = dbg_cmds.commands.join("\n");
 
@@ -397,7 +397,7 @@ impl TestCx<'_> {
         }
 
         // Parse debugger commands etc from test files
-        let dbg_cmds = DebuggerCommands::parse_from(&self.testpaths.file, self.config, "lldb")
+        let dbg_cmds = DebuggerCommands::parse_from(&self.testpaths.file, "lldb")
             .unwrap_or_else(|e| self.fatal(&e));
 
         // Write debugger script:

From ffaf607cf2743f1206a739e02f7b194a4767f9a8 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 30 Sep 2025 12:20:42 +1000
Subject: [PATCH 1575/1889] Remove `parse_negative_name_directive`

This isn't actually used for anything, and its presence complicates the
migration to `DirectiveLine`.
---
 src/tools/compiletest/src/directives.rs | 18 ++----------------
 1 file changed, 2 insertions(+), 16 deletions(-)

diff --git a/src/tools/compiletest/src/directives.rs b/src/tools/compiletest/src/directives.rs
index e864594ade2e8..01a663b016f7d 100644
--- a/src/tools/compiletest/src/directives.rs
+++ b/src/tools/compiletest/src/directives.rs
@@ -1117,10 +1117,6 @@ impl Config {
             && matches!(line.as_bytes().get(directive.len()), None | Some(&b' ') | Some(&b':'))
     }
 
-    fn parse_negative_name_directive(&self, line: &str, directive: &str) -> bool {
-        line.starts_with("no-") && self.parse_name_directive(&line[3..], directive)
-    }
-
     fn parse_name_value_directive(
         &self,
         line: &str,
@@ -1149,18 +1145,8 @@ impl Config {
     }
 
     fn set_name_directive(&self, line: &str, directive: &str, value: &mut bool) {
-        match value {
-            true => {
-                if self.parse_negative_name_directive(line, directive) {
-                    *value = false;
-                }
-            }
-            false => {
-                if self.parse_name_directive(line, directive) {
-                    *value = true;
-                }
-            }
-        }
+        // If the flag is already true, don't bother looking at the directive.
+        *value = *value || self.parse_name_directive(line, directive);
     }
 
     fn set_name_value_directive<T>(

From e491056ac5722bd404dd6c326c76f457eb08b467 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Mon, 29 Sep 2025 22:25:23 +1000
Subject: [PATCH 1576/1889] Pass around `DirectiveLine` instead of bare strings

---
 src/tools/compiletest/src/directives.rs       | 197 +++++++-----------
 .../compiletest/src/directives/auxiliary.rs   |  35 ++--
 src/tools/compiletest/src/directives/cfg.rs   |  14 +-
 src/tools/compiletest/src/directives/needs.rs |   6 +-
 4 files changed, 107 insertions(+), 145 deletions(-)

diff --git a/src/tools/compiletest/src/directives.rs b/src/tools/compiletest/src/directives.rs
index 01a663b016f7d..e6916610190e6 100644
--- a/src/tools/compiletest/src/directives.rs
+++ b/src/tools/compiletest/src/directives.rs
@@ -63,9 +63,10 @@ impl EarlyProps {
             &mut poisoned,
             testfile,
             rdr,
-            &mut |DirectiveLine { line_number, raw_directive: ln, .. }| {
-                parse_and_update_aux(config, ln, testfile, line_number, &mut props.aux);
-                config.parse_and_update_revisions(testfile, line_number, ln, &mut props.revisions);
+            // (dummy comment to force args into vertical layout)
+            &mut |ref ln: DirectiveLine<'_>| {
+                parse_and_update_aux(config, ln, testfile, &mut props.aux);
+                config.parse_and_update_revisions(testfile, ln, &mut props.revisions);
             },
         );
 
@@ -367,8 +368,8 @@ impl TestProps {
                 &mut poisoned,
                 testfile,
                 file,
-                &mut |directive @ DirectiveLine { line_number, raw_directive: ln, .. }| {
-                    if !directive.applies_to_test_revision(test_revision) {
+                &mut |ref ln: DirectiveLine<'_>| {
+                    if !ln.applies_to_test_revision(test_revision) {
                         return;
                     }
 
@@ -378,7 +379,6 @@ impl TestProps {
                         ln,
                         ERROR_PATTERN,
                         testfile,
-                        line_number,
                         &mut self.error_patterns,
                         |r| r,
                     );
@@ -386,7 +386,6 @@ impl TestProps {
                         ln,
                         REGEX_ERROR_PATTERN,
                         testfile,
-                        line_number,
                         &mut self.regex_error_patterns,
                         |r| r,
                     );
@@ -395,7 +394,6 @@ impl TestProps {
                         ln,
                         DOC_FLAGS,
                         testfile,
-                        line_number,
                         &mut self.doc_flags,
                         |r| r,
                     );
@@ -414,7 +412,7 @@ impl TestProps {
                     }
 
                     if let Some(flags) =
-                        config.parse_name_value_directive(ln, COMPILE_FLAGS, testfile, line_number)
+                        config.parse_name_value_directive(ln, COMPILE_FLAGS, testfile)
                     {
                         let flags = split_flags(&flags);
                         for flag in &flags {
@@ -425,39 +423,28 @@ impl TestProps {
                         self.compile_flags.extend(flags);
                     }
                     if config
-                        .parse_name_value_directive(
-                            ln,
-                            INCORRECT_COMPILER_FLAGS,
-                            testfile,
-                            line_number,
-                        )
+                        .parse_name_value_directive(ln, INCORRECT_COMPILER_FLAGS, testfile)
                         .is_some()
                     {
                         panic!("`compiler-flags` directive should be spelled `compile-flags`");
                     }
 
-                    if let Some(edition) = config.parse_edition(ln, testfile, line_number) {
+                    if let Some(edition) = config.parse_edition(ln, testfile) {
                         // The edition is added at the start, since flags from //@compile-flags must
                         // be passed to rustc last.
                         self.compile_flags.insert(0, format!("--edition={}", edition.trim()));
                         has_edition = true;
                     }
 
-                    config.parse_and_update_revisions(
-                        testfile,
-                        line_number,
-                        ln,
-                        &mut self.revisions,
-                    );
+                    config.parse_and_update_revisions(testfile, ln, &mut self.revisions);
 
-                    if let Some(flags) =
-                        config.parse_name_value_directive(ln, RUN_FLAGS, testfile, line_number)
+                    if let Some(flags) = config.parse_name_value_directive(ln, RUN_FLAGS, testfile)
                     {
                         self.run_flags.extend(split_flags(&flags));
                     }
 
                     if self.pp_exact.is_none() {
-                        self.pp_exact = config.parse_pp_exact(ln, testfile, line_number);
+                        self.pp_exact = config.parse_pp_exact(ln, testfile);
                     }
 
                     config.set_name_directive(ln, SHOULD_ICE, &mut self.should_ice);
@@ -479,9 +466,7 @@ impl TestProps {
                     );
                     config.set_name_directive(ln, NO_PREFER_DYNAMIC, &mut self.no_prefer_dynamic);
 
-                    if let Some(m) =
-                        config.parse_name_value_directive(ln, PRETTY_MODE, testfile, line_number)
-                    {
+                    if let Some(m) = config.parse_name_value_directive(ln, PRETTY_MODE, testfile) {
                         self.pretty_mode = m;
                     }
 
@@ -492,13 +477,12 @@ impl TestProps {
                     );
 
                     // Call a helper method to deal with aux-related directives.
-                    parse_and_update_aux(config, ln, testfile, line_number, &mut self.aux);
+                    parse_and_update_aux(config, ln, testfile, &mut self.aux);
 
                     config.push_name_value_directive(
                         ln,
                         EXEC_ENV,
                         testfile,
-                        line_number,
                         &mut self.exec_env,
                         Config::parse_env,
                     );
@@ -506,7 +490,6 @@ impl TestProps {
                         ln,
                         UNSET_EXEC_ENV,
                         testfile,
-                        line_number,
                         &mut self.unset_exec_env,
                         |r| r.trim().to_owned(),
                     );
@@ -514,7 +497,6 @@ impl TestProps {
                         ln,
                         RUSTC_ENV,
                         testfile,
-                        line_number,
                         &mut self.rustc_env,
                         Config::parse_env,
                     );
@@ -522,7 +504,6 @@ impl TestProps {
                         ln,
                         UNSET_RUSTC_ENV,
                         testfile,
-                        line_number,
                         &mut self.unset_rustc_env,
                         |r| r.trim().to_owned(),
                     );
@@ -530,7 +511,6 @@ impl TestProps {
                         ln,
                         FORBID_OUTPUT,
                         testfile,
-                        line_number,
                         &mut self.forbid_output,
                         |r| r,
                     );
@@ -566,7 +546,7 @@ impl TestProps {
                     }
 
                     if let Some(code) = config
-                        .parse_name_value_directive(ln, FAILURE_STATUS, testfile, line_number)
+                        .parse_name_value_directive(ln, FAILURE_STATUS, testfile)
                         .and_then(|code| code.trim().parse::<i32>().ok())
                     {
                         self.failure_status = Some(code);
@@ -588,7 +568,6 @@ impl TestProps {
                         ln,
                         ASSEMBLY_OUTPUT,
                         testfile,
-                        line_number,
                         &mut self.assembly_output,
                         |r| r.trim().to_string(),
                     );
@@ -602,7 +581,7 @@ impl TestProps {
                     // Unlike the other `name_value_directive`s this needs to be handled manually,
                     // because it sets a `bool` flag.
                     if let Some(known_bug) =
-                        config.parse_name_value_directive(ln, KNOWN_BUG, testfile, line_number)
+                        config.parse_name_value_directive(ln, KNOWN_BUG, testfile)
                     {
                         let known_bug = known_bug.trim();
                         if known_bug == "unknown"
@@ -632,24 +611,20 @@ impl TestProps {
                         ln,
                         TEST_MIR_PASS,
                         testfile,
-                        line_number,
                         &mut self.mir_unit_test,
                         |s| s.trim().to_string(),
                     );
                     config.set_name_directive(ln, REMAP_SRC_BASE, &mut self.remap_src_base);
 
                     if let Some(flags) =
-                        config.parse_name_value_directive(ln, LLVM_COV_FLAGS, testfile, line_number)
+                        config.parse_name_value_directive(ln, LLVM_COV_FLAGS, testfile)
                     {
                         self.llvm_cov_flags.extend(split_flags(&flags));
                     }
 
-                    if let Some(flags) = config.parse_name_value_directive(
-                        ln,
-                        FILECHECK_FLAGS,
-                        testfile,
-                        line_number,
-                    ) {
+                    if let Some(flags) =
+                        config.parse_name_value_directive(ln, FILECHECK_FLAGS, testfile)
+                    {
                         self.filecheck_flags.extend(split_flags(&flags));
                     }
 
@@ -661,7 +636,6 @@ impl TestProps {
                         ln,
                         directives::CORE_STUBS_COMPILE_FLAGS,
                         testfile,
-                        line_number,
                     ) {
                         let flags = split_flags(&flags);
                         for flag in &flags {
@@ -672,12 +646,9 @@ impl TestProps {
                         self.core_stubs_compile_flags.extend(flags);
                     }
 
-                    if let Some(err_kind) = config.parse_name_value_directive(
-                        ln,
-                        DONT_REQUIRE_ANNOTATIONS,
-                        testfile,
-                        line_number,
-                    ) {
+                    if let Some(err_kind) =
+                        config.parse_name_value_directive(ln, DONT_REQUIRE_ANNOTATIONS, testfile)
+                    {
                         self.dont_require_annotations
                             .insert(ErrorKind::expect_from_user_str(err_kind.trim()));
                     }
@@ -734,7 +705,7 @@ impl TestProps {
         }
     }
 
-    fn update_fail_mode(&mut self, ln: &str, config: &Config) {
+    fn update_fail_mode(&mut self, ln: &DirectiveLine<'_>, config: &Config) {
         let check_ui = |mode: &str| {
             // Mode::Crashes may need build-fail in order to trigger llvm errors or stack overflows
             if config.mode != TestMode::Ui && config.mode != TestMode::Crashes {
@@ -769,7 +740,12 @@ impl TestProps {
         }
     }
 
-    fn update_pass_mode(&mut self, ln: &str, revision: Option<&str>, config: &Config) {
+    fn update_pass_mode(
+        &mut self,
+        ln: &DirectiveLine<'_>,
+        revision: Option<&str>,
+        config: &Config,
+    ) {
         let check_no_run = |s| match (config.mode, s) {
             (TestMode::Ui, _) => (),
             (TestMode::Crashes, _) => (),
@@ -814,7 +790,7 @@ impl TestProps {
         self.pass_mode
     }
 
-    pub fn update_add_core_stubs(&mut self, ln: &str, config: &Config) {
+    fn update_add_core_stubs(&mut self, ln: &DirectiveLine<'_>, config: &Config) {
         let add_core_stubs = config.parse_name_directive(ln, directives::ADD_CORE_STUBS);
         if add_core_stubs {
             if !matches!(config.mode, TestMode::Ui | TestMode::Codegen | TestMode::Assembly) {
@@ -905,10 +881,12 @@ pub(crate) struct CheckDirectiveResult<'ln> {
     trailing_directive: Option<&'ln str>,
 }
 
-pub(crate) fn check_directive<'a>(
-    directive_ln: &'a str,
+fn check_directive<'a>(
+    directive_ln: &DirectiveLine<'a>,
     mode: TestMode,
 ) -> CheckDirectiveResult<'a> {
+    let &DirectiveLine { raw_directive: directive_ln, .. } = directive_ln;
+
     let (directive_name, post) = directive_ln.split_once([':', ' ']).unwrap_or((directive_ln, ""));
 
     let is_known_directive = KNOWN_DIRECTIVE_NAMES.contains(&directive_name)
@@ -980,7 +958,7 @@ fn iter_directives(
         // Perform unknown directive check on Rust files.
         if testfile.extension() == Some("rs") {
             let CheckDirectiveResult { is_known_directive, trailing_directive } =
-                check_directive(directive_line.raw_directive, mode);
+                check_directive(&directive_line, mode);
 
             if !is_known_directive {
                 *poisoned = true;
@@ -1014,8 +992,7 @@ impl Config {
     fn parse_and_update_revisions(
         &self,
         testfile: &Utf8Path,
-        line_number: usize,
-        line: &str,
+        line: &DirectiveLine<'_>,
         existing: &mut Vec<String>,
     ) {
         const FORBIDDEN_REVISION_NAMES: [&str; 2] = [
@@ -1028,8 +1005,7 @@ impl Config {
         const FILECHECK_FORBIDDEN_REVISION_NAMES: [&str; 9] =
             ["CHECK", "COM", "NEXT", "SAME", "EMPTY", "NOT", "COUNT", "DAG", "LABEL"];
 
-        if let Some(raw) = self.parse_name_value_directive(line, "revisions", testfile, line_number)
-        {
+        if let Some(raw) = self.parse_name_value_directive(line, "revisions", testfile) {
             if self.mode == TestMode::RunMake {
                 panic!("`run-make` mode tests do not support revisions: {}", testfile);
             }
@@ -1074,13 +1050,8 @@ impl Config {
         (name.to_owned(), value.to_owned())
     }
 
-    fn parse_pp_exact(
-        &self,
-        line: &str,
-        testfile: &Utf8Path,
-        line_number: usize,
-    ) -> Option<Utf8PathBuf> {
-        if let Some(s) = self.parse_name_value_directive(line, "pp-exact", testfile, line_number) {
+    fn parse_pp_exact(&self, line: &DirectiveLine<'_>, testfile: &Utf8Path) -> Option<Utf8PathBuf> {
+        if let Some(s) = self.parse_name_value_directive(line, "pp-exact", testfile) {
             Some(Utf8PathBuf::from(&s))
         } else if self.parse_name_directive(line, "pp-exact") {
             testfile.file_name().map(Utf8PathBuf::from)
@@ -1089,7 +1060,9 @@ impl Config {
         }
     }
 
-    fn parse_custom_normalization(&self, raw_directive: &str) -> Option<NormalizeRule> {
+    fn parse_custom_normalization(&self, line: &DirectiveLine<'_>) -> Option<NormalizeRule> {
+        let &DirectiveLine { raw_directive, .. } = line;
+
         // FIXME(Zalathar): Integrate name/value splitting into `DirectiveLine`
         // instead of doing it here.
         let (directive_name, raw_value) = raw_directive.split_once(':')?;
@@ -1110,7 +1083,9 @@ impl Config {
         Some(NormalizeRule { kind, regex, replacement })
     }
 
-    fn parse_name_directive(&self, line: &str, directive: &str) -> bool {
+    fn parse_name_directive(&self, line: &DirectiveLine<'_>, directive: &str) -> bool {
+        let &DirectiveLine { raw_directive: line, .. } = line;
+
         // Ensure the directive is a whole word. Do not match "ignore-x86" when
         // the line says "ignore-x86_64".
         line.starts_with(directive)
@@ -1119,11 +1094,12 @@ impl Config {
 
     fn parse_name_value_directive(
         &self,
-        line: &str,
+        line: &DirectiveLine<'_>,
         directive: &str,
         testfile: &Utf8Path,
-        line_number: usize,
     ) -> Option<String> {
+        let &DirectiveLine { line_number, raw_directive: line, .. } = line;
+
         let colon = directive.len();
         if line.starts_with(directive) && line.as_bytes().get(colon) == Some(&b':') {
             let value = line[(colon + 1)..].to_owned();
@@ -1140,42 +1116,37 @@ impl Config {
         }
     }
 
-    fn parse_edition(&self, line: &str, testfile: &Utf8Path, line_number: usize) -> Option<String> {
-        self.parse_name_value_directive(line, "edition", testfile, line_number)
+    fn parse_edition(&self, line: &DirectiveLine<'_>, testfile: &Utf8Path) -> Option<String> {
+        self.parse_name_value_directive(line, "edition", testfile)
     }
 
-    fn set_name_directive(&self, line: &str, directive: &str, value: &mut bool) {
+    fn set_name_directive(&self, line: &DirectiveLine<'_>, directive: &str, value: &mut bool) {
         // If the flag is already true, don't bother looking at the directive.
         *value = *value || self.parse_name_directive(line, directive);
     }
 
     fn set_name_value_directive<T>(
         &self,
-        line: &str,
+        line: &DirectiveLine<'_>,
         directive: &str,
         testfile: &Utf8Path,
-        line_number: usize,
         value: &mut Option<T>,
         parse: impl FnOnce(String) -> T,
     ) {
         if value.is_none() {
-            *value =
-                self.parse_name_value_directive(line, directive, testfile, line_number).map(parse);
+            *value = self.parse_name_value_directive(line, directive, testfile).map(parse);
         }
     }
 
     fn push_name_value_directive<T>(
         &self,
-        line: &str,
+        line: &DirectiveLine<'_>,
         directive: &str,
         testfile: &Utf8Path,
-        line_number: usize,
         values: &mut Vec<T>,
         parse: impl FnOnce(String) -> T,
     ) {
-        if let Some(value) =
-            self.parse_name_value_directive(line, directive, testfile, line_number).map(parse)
-        {
+        if let Some(value) = self.parse_name_value_directive(line, directive, testfile).map(parse) {
             values.push(value);
         }
     }
@@ -1468,8 +1439,8 @@ pub(crate) fn make_test_description<R: Read>(
         &mut local_poisoned,
         path,
         src,
-        &mut |directive @ DirectiveLine { line_number, raw_directive: ln, .. }| {
-            if !directive.applies_to_test_revision(test_revision) {
+        &mut |ref ln @ DirectiveLine { line_number, .. }| {
+            if !ln.applies_to_test_revision(test_revision) {
                 return;
             }
 
@@ -1493,9 +1464,9 @@ pub(crate) fn make_test_description<R: Read>(
             decision!(cfg::handle_ignore(config, ln));
             decision!(cfg::handle_only(config, ln));
             decision!(needs::handle_needs(&cache.needs, config, ln));
-            decision!(ignore_llvm(config, path, ln, line_number));
-            decision!(ignore_backends(config, path, ln, line_number));
-            decision!(needs_backends(config, path, ln, line_number));
+            decision!(ignore_llvm(config, path, ln));
+            decision!(ignore_backends(config, path, ln));
+            decision!(needs_backends(config, path, ln));
             decision!(ignore_cdb(config, ln));
             decision!(ignore_gdb(config, ln));
             decision!(ignore_lldb(config, ln));
@@ -1535,7 +1506,9 @@ pub(crate) fn make_test_description<R: Read>(
     }
 }
 
-fn ignore_cdb(config: &Config, line: &str) -> IgnoreDecision {
+fn ignore_cdb(config: &Config, line: &DirectiveLine<'_>) -> IgnoreDecision {
+    let &DirectiveLine { raw_directive: line, .. } = line;
+
     if config.debugger != Some(Debugger::Cdb) {
         return IgnoreDecision::Continue;
     }
@@ -1558,7 +1531,9 @@ fn ignore_cdb(config: &Config, line: &str) -> IgnoreDecision {
     IgnoreDecision::Continue
 }
 
-fn ignore_gdb(config: &Config, line: &str) -> IgnoreDecision {
+fn ignore_gdb(config: &Config, line: &DirectiveLine<'_>) -> IgnoreDecision {
+    let &DirectiveLine { raw_directive: line, .. } = line;
+
     if config.debugger != Some(Debugger::Gdb) {
         return IgnoreDecision::Continue;
     }
@@ -1606,7 +1581,9 @@ fn ignore_gdb(config: &Config, line: &str) -> IgnoreDecision {
     IgnoreDecision::Continue
 }
 
-fn ignore_lldb(config: &Config, line: &str) -> IgnoreDecision {
+fn ignore_lldb(config: &Config, line: &DirectiveLine<'_>) -> IgnoreDecision {
+    let &DirectiveLine { raw_directive: line, .. } = line;
+
     if config.debugger != Some(Debugger::Lldb) {
         return IgnoreDecision::Continue;
     }
@@ -1628,14 +1605,9 @@ fn ignore_lldb(config: &Config, line: &str) -> IgnoreDecision {
     IgnoreDecision::Continue
 }
 
-fn ignore_backends(
-    config: &Config,
-    path: &Utf8Path,
-    line: &str,
-    line_number: usize,
-) -> IgnoreDecision {
+fn ignore_backends(config: &Config, path: &Utf8Path, line: &DirectiveLine<'_>) -> IgnoreDecision {
     if let Some(backends_to_ignore) =
-        config.parse_name_value_directive(line, "ignore-backends", path, line_number)
+        config.parse_name_value_directive(line, "ignore-backends", path)
     {
         for backend in backends_to_ignore.split_whitespace().map(|backend| {
             match CodegenBackend::try_from(backend) {
@@ -1655,15 +1627,8 @@ fn ignore_backends(
     IgnoreDecision::Continue
 }
 
-fn needs_backends(
-    config: &Config,
-    path: &Utf8Path,
-    line: &str,
-    line_number: usize,
-) -> IgnoreDecision {
-    if let Some(needed_backends) =
-        config.parse_name_value_directive(line, "needs-backends", path, line_number)
-    {
+fn needs_backends(config: &Config, path: &Utf8Path, line: &DirectiveLine<'_>) -> IgnoreDecision {
+    if let Some(needed_backends) = config.parse_name_value_directive(line, "needs-backends", path) {
         if !needed_backends
             .split_whitespace()
             .map(|backend| match CodegenBackend::try_from(backend) {
@@ -1685,9 +1650,9 @@ fn needs_backends(
     IgnoreDecision::Continue
 }
 
-fn ignore_llvm(config: &Config, path: &Utf8Path, line: &str, line_number: usize) -> IgnoreDecision {
+fn ignore_llvm(config: &Config, path: &Utf8Path, line: &DirectiveLine<'_>) -> IgnoreDecision {
     if let Some(needed_components) =
-        config.parse_name_value_directive(line, "needs-llvm-components", path, line_number)
+        config.parse_name_value_directive(line, "needs-llvm-components", path)
     {
         let components: HashSet<_> = config.llvm_components.split_whitespace().collect();
         if let Some(missing_component) = needed_components
@@ -1709,7 +1674,7 @@ fn ignore_llvm(config: &Config, path: &Utf8Path, line: &str, line_number: usize)
         // Note that these `min` versions will check for not just major versions.
 
         if let Some(version_string) =
-            config.parse_name_value_directive(line, "min-llvm-version", path, line_number)
+            config.parse_name_value_directive(line, "min-llvm-version", path)
         {
             let min_version = extract_llvm_version(&version_string);
             // Ignore if actual version is smaller than the minimum required version.
@@ -1721,7 +1686,7 @@ fn ignore_llvm(config: &Config, path: &Utf8Path, line: &str, line_number: usize)
                 };
             }
         } else if let Some(version_string) =
-            config.parse_name_value_directive(line, "max-llvm-major-version", path, line_number)
+            config.parse_name_value_directive(line, "max-llvm-major-version", path)
         {
             let max_version = extract_llvm_version(&version_string);
             // Ignore if actual major version is larger than the maximum required major version.
@@ -1735,7 +1700,7 @@ fn ignore_llvm(config: &Config, path: &Utf8Path, line: &str, line_number: usize)
                 };
             }
         } else if let Some(version_string) =
-            config.parse_name_value_directive(line, "min-system-llvm-version", path, line_number)
+            config.parse_name_value_directive(line, "min-system-llvm-version", path)
         {
             let min_version = extract_llvm_version(&version_string);
             // Ignore if using system LLVM and actual version
@@ -1748,7 +1713,7 @@ fn ignore_llvm(config: &Config, path: &Utf8Path, line: &str, line_number: usize)
                 };
             }
         } else if let Some(version_range) =
-            config.parse_name_value_directive(line, "ignore-llvm-version", path, line_number)
+            config.parse_name_value_directive(line, "ignore-llvm-version", path)
         {
             // Syntax is: "ignore-llvm-version: <version1> [- <version2>]"
             let (v_min, v_max) =
@@ -1774,7 +1739,7 @@ fn ignore_llvm(config: &Config, path: &Utf8Path, line: &str, line_number: usize)
                 }
             }
         } else if let Some(version_string) =
-            config.parse_name_value_directive(line, "exact-llvm-major-version", path, line_number)
+            config.parse_name_value_directive(line, "exact-llvm-major-version", path)
         {
             // Syntax is "exact-llvm-major-version: <version>"
             let version = extract_llvm_version(&version_string);
diff --git a/src/tools/compiletest/src/directives/auxiliary.rs b/src/tools/compiletest/src/directives/auxiliary.rs
index 7c1ed2e700624..0675a6feac3f0 100644
--- a/src/tools/compiletest/src/directives/auxiliary.rs
+++ b/src/tools/compiletest/src/directives/auxiliary.rs
@@ -7,6 +7,7 @@ use camino::Utf8Path;
 
 use super::directives::{AUX_BIN, AUX_BUILD, AUX_CODEGEN_BACKEND, AUX_CRATE, PROC_MACRO};
 use crate::common::Config;
+use crate::directives::DirectiveLine;
 
 /// Properties parsed from `aux-*` test directives.
 #[derive(Clone, Debug, Default)]
@@ -45,40 +46,28 @@ impl AuxProps {
 /// and update [`AuxProps`] accordingly.
 pub(super) fn parse_and_update_aux(
     config: &Config,
-    ln: &str,
+    directive_line: &DirectiveLine<'_>,
     testfile: &Utf8Path,
-    line_number: usize,
     aux: &mut AuxProps,
 ) {
+    let &DirectiveLine { raw_directive: ln, .. } = directive_line;
+
     if !(ln.starts_with("aux-") || ln.starts_with("proc-macro")) {
         return;
     }
 
-    config.push_name_value_directive(ln, AUX_BUILD, testfile, line_number, &mut aux.builds, |r| {
+    let ln = directive_line;
+
+    config.push_name_value_directive(ln, AUX_BUILD, testfile, &mut aux.builds, |r| {
         r.trim().to_string()
     });
-    config.push_name_value_directive(ln, AUX_BIN, testfile, line_number, &mut aux.bins, |r| {
+    config
+        .push_name_value_directive(ln, AUX_BIN, testfile, &mut aux.bins, |r| r.trim().to_string());
+    config.push_name_value_directive(ln, AUX_CRATE, testfile, &mut aux.crates, parse_aux_crate);
+    config.push_name_value_directive(ln, PROC_MACRO, testfile, &mut aux.proc_macros, |r| {
         r.trim().to_string()
     });
-    config.push_name_value_directive(
-        ln,
-        AUX_CRATE,
-        testfile,
-        line_number,
-        &mut aux.crates,
-        parse_aux_crate,
-    );
-    config.push_name_value_directive(
-        ln,
-        PROC_MACRO,
-        testfile,
-        line_number,
-        &mut aux.proc_macros,
-        |r| r.trim().to_string(),
-    );
-    if let Some(r) =
-        config.parse_name_value_directive(ln, AUX_CODEGEN_BACKEND, testfile, line_number)
-    {
+    if let Some(r) = config.parse_name_value_directive(ln, AUX_CODEGEN_BACKEND, testfile) {
         aux.codegen_backend = Some(r.trim().to_owned());
     }
 }
diff --git a/src/tools/compiletest/src/directives/cfg.rs b/src/tools/compiletest/src/directives/cfg.rs
index 802a1d63d1f20..62a4b88a33a6e 100644
--- a/src/tools/compiletest/src/directives/cfg.rs
+++ b/src/tools/compiletest/src/directives/cfg.rs
@@ -1,12 +1,14 @@
 use std::collections::HashSet;
 
 use crate::common::{CompareMode, Config, Debugger};
-use crate::directives::IgnoreDecision;
+use crate::directives::{DirectiveLine, IgnoreDecision};
 
 const EXTRA_ARCHS: &[&str] = &["spirv"];
 
-pub(super) fn handle_ignore(config: &Config, line: &str) -> IgnoreDecision {
+pub(super) fn handle_ignore(config: &Config, line: &DirectiveLine<'_>) -> IgnoreDecision {
     let parsed = parse_cfg_name_directive(config, line, "ignore");
+    let &DirectiveLine { raw_directive: line, .. } = line;
+
     match parsed.outcome {
         MatchOutcome::NoMatch => IgnoreDecision::Continue,
         MatchOutcome::Match => IgnoreDecision::Ignore {
@@ -21,8 +23,10 @@ pub(super) fn handle_ignore(config: &Config, line: &str) -> IgnoreDecision {
     }
 }
 
-pub(super) fn handle_only(config: &Config, line: &str) -> IgnoreDecision {
+pub(super) fn handle_only(config: &Config, line: &DirectiveLine<'_>) -> IgnoreDecision {
     let parsed = parse_cfg_name_directive(config, line, "only");
+    let &DirectiveLine { raw_directive: line, .. } = line;
+
     match parsed.outcome {
         MatchOutcome::Match => IgnoreDecision::Continue,
         MatchOutcome::NoMatch => IgnoreDecision::Ignore {
@@ -43,9 +47,11 @@ pub(super) fn handle_only(config: &Config, line: &str) -> IgnoreDecision {
 /// or `only-windows`.
 fn parse_cfg_name_directive<'a>(
     config: &Config,
-    line: &'a str,
+    line: &'a DirectiveLine<'a>,
     prefix: &str,
 ) -> ParsedNameDirective<'a> {
+    let &DirectiveLine { raw_directive: line, .. } = line;
+
     if !line.as_bytes().starts_with(prefix.as_bytes()) {
         return ParsedNameDirective::not_a_directive();
     }
diff --git a/src/tools/compiletest/src/directives/needs.rs b/src/tools/compiletest/src/directives/needs.rs
index 3b7a9478717f4..c8a729d8aab68 100644
--- a/src/tools/compiletest/src/directives/needs.rs
+++ b/src/tools/compiletest/src/directives/needs.rs
@@ -1,10 +1,10 @@
 use crate::common::{Config, KNOWN_CRATE_TYPES, KNOWN_TARGET_HAS_ATOMIC_WIDTHS, Sanitizer};
-use crate::directives::{IgnoreDecision, llvm_has_libzstd};
+use crate::directives::{DirectiveLine, IgnoreDecision, llvm_has_libzstd};
 
 pub(super) fn handle_needs(
     cache: &CachedNeedsConditions,
     config: &Config,
-    ln: &str,
+    ln: &DirectiveLine<'_>,
 ) -> IgnoreDecision {
     // Note that we intentionally still put the needs- prefix here to make the file show up when
     // grepping for a directive name, even though we could technically strip that.
@@ -181,6 +181,8 @@ pub(super) fn handle_needs(
         },
     ];
 
+    let &DirectiveLine { raw_directive: ln, .. } = ln;
+
     let (name, rest) = match ln.split_once([':', ' ']) {
         Some((name, rest)) => (name, Some(rest)),
         None => (ln, None),

From 0fd6f1113b7209d24d4954ef99165aba09ed27f7 Mon Sep 17 00:00:00 2001
From: Tomoaki Kobayashi <tomoaki.kobayashi.t3@alumni.tohoku.ac.jp>
Date: Thu, 18 Sep 2025 14:23:58 +0900
Subject: [PATCH 1577/1889] Add test for unuseful span in type error in some
 format_args!() invocations

---
 .../errors/span-format_args-issue-140578.rs   | 31 ++++++++++++
 .../span-format_args-issue-140578.stderr      | 49 +++++++++++++++++++
 2 files changed, 80 insertions(+)
 create mode 100644 tests/ui/errors/span-format_args-issue-140578.rs
 create mode 100644 tests/ui/errors/span-format_args-issue-140578.stderr

diff --git a/tests/ui/errors/span-format_args-issue-140578.rs b/tests/ui/errors/span-format_args-issue-140578.rs
new file mode 100644
index 0000000000000..d086fde09f7b4
--- /dev/null
+++ b/tests/ui/errors/span-format_args-issue-140578.rs
@@ -0,0 +1,31 @@
+fn check_format_args() {
+  print!("{:?} {a} {a:?}", [], a = 1 + 1);
+  //~^ ERROR type annotations needed
+}
+
+fn check_format_args_nl() {
+  println!("{:?} {a} {a:?}", [], a = 1 + 1);
+  //~^ ERROR type annotations needed
+}
+
+fn check_multi1() {
+  println!("{:?} {:?} {a} {a:?}", [], [], a = 1 + 1);
+  //~^ ERROR type annotations needed
+}
+
+fn check_multi2() {
+  println!("{:?} {:?} {a} {a:?} {b:?}", [], [], a = 1 + 1, b = []);
+  //~^ ERROR type annotations needed
+}
+
+fn check_unformatted() {
+  println!(" //~ ERROR type annotations needed
+  {:?} {:?}
+{a}
+{a:?}",
+        [],
+ [],
+a = 1 + 1);
+}
+
+fn main() {}
diff --git a/tests/ui/errors/span-format_args-issue-140578.stderr b/tests/ui/errors/span-format_args-issue-140578.stderr
new file mode 100644
index 0000000000000..4c19b4919594e
--- /dev/null
+++ b/tests/ui/errors/span-format_args-issue-140578.stderr
@@ -0,0 +1,49 @@
+error[E0282]: type annotations needed
+  --> $DIR/span-format_args-issue-140578.rs:2:3
+   |
+LL |   print!("{:?} {a} {a:?}", [], a = 1 + 1);
+   |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type
+   |
+   = note: this error originates in the macro `print` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0282]: type annotations needed
+  --> $DIR/span-format_args-issue-140578.rs:7:3
+   |
+LL |   println!("{:?} {a} {a:?}", [], a = 1 + 1);
+   |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type
+   |
+   = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0282]: type annotations needed
+  --> $DIR/span-format_args-issue-140578.rs:12:3
+   |
+LL |   println!("{:?} {:?} {a} {a:?}", [], [], a = 1 + 1);
+   |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type
+   |
+   = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0282]: type annotations needed
+  --> $DIR/span-format_args-issue-140578.rs:17:3
+   |
+LL |   println!("{:?} {:?} {a} {a:?} {b:?}", [], [], a = 1 + 1, b = []);
+   |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type
+   |
+   = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0282]: type annotations needed
+  --> $DIR/span-format_args-issue-140578.rs:22:3
+   |
+LL | /   println!("
+LL | |   {:?} {:?}
+LL | | {a}
+LL | | {a:?}",
+LL | |         [],
+LL | |  [],
+LL | | a = 1 + 1);
+   | |__________^ cannot infer type
+   |
+   = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 5 previous errors
+
+For more information about this error, try `rustc --explain E0282`.

From 1f8bef51e30a087a8b8843c19762952a50087a71 Mon Sep 17 00:00:00 2001
From: Walnut <39544927+Walnut356@users.noreply.github.com>
Date: Tue, 30 Sep 2025 03:04:23 -0500
Subject: [PATCH 1578/1889] fix tuple child creation

---
 src/etc/lldb_providers.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/etc/lldb_providers.py b/src/etc/lldb_providers.py
index 65f18baa937e7..3eb964d2fbab9 100644
--- a/src/etc/lldb_providers.py
+++ b/src/etc/lldb_providers.py
@@ -761,7 +761,8 @@ def get_child_index(self, name: str) -> int:
 
     def get_child_at_index(self, index: int) -> SBValue:
         child: SBValue = self.valobj.GetChildAtIndex(index)
-        return child.CreateChildAtOffset(str(index), 0, child.GetType())
+        offset = self.valobj.GetType().GetFieldAtIndex(index).byte_offset
+        return self.valobj.CreateChildAtOffset(str(index), offset, child.GetType())
 
     def update(self):
         pass
@@ -772,7 +773,7 @@ def has_children(self) -> bool:
     def get_type_name(self) -> str:
         name = self.valobj.GetTypeName()
         # remove "tuple$<" and ">", str.removeprefix and str.removesuffix require python 3.9+
-        name = name[7:-1]
+        name = name[7:-1].strip()
         return "(" + name + ")"
 
 

From b13b87a1c3ee3c61b21c4273a87f0b65ccabdde8 Mon Sep 17 00:00:00 2001
From: Tomoaki Kobayashi <tomoaki.kobayashi.t3@alumni.tohoku.ac.jp>
Date: Thu, 18 Sep 2025 14:42:56 +0900
Subject: [PATCH 1579/1889] Fix unuseful span in type error in some
 format_args!() invocations

---
 .../src/error_reporting/traits/mod.rs         | 45 +++++++++++++++----
 .../errors/span-format_args-issue-140578.rs   |  3 +-
 .../span-format_args-issue-140578.stderr      | 42 ++++++++---------
 ...745-avoid-expr-from-macro-expansion.stderr |  6 +--
 4 files changed, 60 insertions(+), 36 deletions(-)

diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/mod.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/mod.rs
index b3d1b8e3888a1..9052031ce4fd8 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/mod.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/mod.rs
@@ -21,7 +21,7 @@ use rustc_infer::traits::{
 };
 use rustc_middle::ty::print::{PrintTraitRefExt as _, with_no_trimmed_paths};
 use rustc_middle::ty::{self, Ty, TyCtxt};
-use rustc_span::{ErrorGuaranteed, ExpnKind, Span};
+use rustc_span::{DesugaringKind, ErrorGuaranteed, ExpnKind, Span};
 use tracing::{info, instrument};
 
 pub use self::overflow::*;
@@ -154,9 +154,20 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             })
             .collect();
 
-        // Ensure `T: Sized`, `T: MetaSized`, `T: PointeeSized` and `T: WF` obligations come last.
+        // Ensure `T: Sized`, `T: MetaSized`, `T: PointeeSized` and `T: WF` obligations come last,
+        // and `Subtype` obligations from `FormatLiteral` desugarings come first.
         // This lets us display diagnostics with more relevant type information and hide redundant
         // E0282 errors.
+        #[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+        enum ErrorSortKey {
+            SubtypeFormat(usize, usize),
+            OtherKind,
+            SizedTrait,
+            MetaSizedTrait,
+            PointeeSizedTrait,
+            Coerce,
+            WellFormed,
+        }
         errors.sort_by_key(|e| {
             let maybe_sizedness_did = match e.obligation.predicate.kind().skip_binder() {
                 ty::PredicateKind::Clause(ty::ClauseKind::Trait(pred)) => Some(pred.def_id()),
@@ -165,12 +176,30 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             };
 
             match e.obligation.predicate.kind().skip_binder() {
-                _ if maybe_sizedness_did == self.tcx.lang_items().sized_trait() => 1,
-                _ if maybe_sizedness_did == self.tcx.lang_items().meta_sized_trait() => 2,
-                _ if maybe_sizedness_did == self.tcx.lang_items().pointee_sized_trait() => 3,
-                ty::PredicateKind::Coerce(_) => 4,
-                ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(_)) => 5,
-                _ => 0,
+                ty::PredicateKind::Subtype(_)
+                    if matches!(
+                        e.obligation.cause.span.desugaring_kind(),
+                        Some(DesugaringKind::FormatLiteral { .. })
+                    ) =>
+                {
+                    let (_, row, col, ..) =
+                        self.tcx.sess.source_map().span_to_location_info(e.obligation.cause.span);
+                    ErrorSortKey::SubtypeFormat(row, col)
+                }
+                _ if maybe_sizedness_did == self.tcx.lang_items().sized_trait() => {
+                    ErrorSortKey::SizedTrait
+                }
+                _ if maybe_sizedness_did == self.tcx.lang_items().meta_sized_trait() => {
+                    ErrorSortKey::MetaSizedTrait
+                }
+                _ if maybe_sizedness_did == self.tcx.lang_items().pointee_sized_trait() => {
+                    ErrorSortKey::PointeeSizedTrait
+                }
+                ty::PredicateKind::Coerce(_) => ErrorSortKey::Coerce,
+                ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(_)) => {
+                    ErrorSortKey::WellFormed
+                }
+                _ => ErrorSortKey::OtherKind,
             }
         });
 
diff --git a/tests/ui/errors/span-format_args-issue-140578.rs b/tests/ui/errors/span-format_args-issue-140578.rs
index d086fde09f7b4..8c91ded833753 100644
--- a/tests/ui/errors/span-format_args-issue-140578.rs
+++ b/tests/ui/errors/span-format_args-issue-140578.rs
@@ -19,11 +19,12 @@ fn check_multi2() {
 }
 
 fn check_unformatted() {
-  println!(" //~ ERROR type annotations needed
+  println!("
   {:?} {:?}
 {a}
 {a:?}",
         [],
+        //~^ ERROR type annotations needed
  [],
 a = 1 + 1);
 }
diff --git a/tests/ui/errors/span-format_args-issue-140578.stderr b/tests/ui/errors/span-format_args-issue-140578.stderr
index 4c19b4919594e..6a273e5cd515c 100644
--- a/tests/ui/errors/span-format_args-issue-140578.stderr
+++ b/tests/ui/errors/span-format_args-issue-140578.stderr
@@ -1,48 +1,42 @@
 error[E0282]: type annotations needed
-  --> $DIR/span-format_args-issue-140578.rs:2:3
+  --> $DIR/span-format_args-issue-140578.rs:2:28
    |
 LL |   print!("{:?} {a} {a:?}", [], a = 1 + 1);
-   |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type
+   |                            ^^ cannot infer type
    |
-   = note: this error originates in the macro `print` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `$crate::format_args` which comes from the expansion of the macro `print` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0282]: type annotations needed
-  --> $DIR/span-format_args-issue-140578.rs:7:3
+  --> $DIR/span-format_args-issue-140578.rs:7:30
    |
 LL |   println!("{:?} {a} {a:?}", [], a = 1 + 1);
-   |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type
+   |                              ^^ cannot infer type
    |
-   = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0282]: type annotations needed
-  --> $DIR/span-format_args-issue-140578.rs:12:3
+  --> $DIR/span-format_args-issue-140578.rs:12:35
    |
 LL |   println!("{:?} {:?} {a} {a:?}", [], [], a = 1 + 1);
-   |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type
+   |                                   ^^ cannot infer type
    |
-   = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0282]: type annotations needed
-  --> $DIR/span-format_args-issue-140578.rs:17:3
+  --> $DIR/span-format_args-issue-140578.rs:17:41
    |
 LL |   println!("{:?} {:?} {a} {a:?} {b:?}", [], [], a = 1 + 1, b = []);
-   |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type
+   |                                         ^^ cannot infer type
    |
-   = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0282]: type annotations needed
-  --> $DIR/span-format_args-issue-140578.rs:22:3
-   |
-LL | /   println!("
-LL | |   {:?} {:?}
-LL | | {a}
-LL | | {a:?}",
-LL | |         [],
-LL | |  [],
-LL | | a = 1 + 1);
-   | |__________^ cannot infer type
-   |
-   = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
+  --> $DIR/span-format_args-issue-140578.rs:26:9
+   |
+LL |         [],
+   |         ^^ cannot infer type
+   |
+   = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 5 previous errors
 
diff --git a/tests/ui/inference/need_type_info/issue-107745-avoid-expr-from-macro-expansion.stderr b/tests/ui/inference/need_type_info/issue-107745-avoid-expr-from-macro-expansion.stderr
index a78941f9e11be..3de317d2af6d1 100644
--- a/tests/ui/inference/need_type_info/issue-107745-avoid-expr-from-macro-expansion.stderr
+++ b/tests/ui/inference/need_type_info/issue-107745-avoid-expr-from-macro-expansion.stderr
@@ -1,10 +1,10 @@
 error[E0282]: type annotations needed
-  --> $DIR/issue-107745-avoid-expr-from-macro-expansion.rs:17:5
+  --> $DIR/issue-107745-avoid-expr-from-macro-expansion.rs:17:22
    |
 LL |     println!("{:?}", []);
-   |     ^^^^^^^^^^^^^^^^^^^^ cannot infer type
+   |                      ^^ cannot infer type
    |
-   = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 1 previous error
 

From d615d2ff34566c399862cfe0feb96d05767ce5ce Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Tue, 30 Sep 2025 11:59:08 +0200
Subject: [PATCH 1580/1889] std: call WinSock cleanup function directly instead
 of through its reexport

---
 library/std/src/sys/net/connection/socket/windows.rs | 2 +-
 library/std/src/sys/pal/windows/mod.rs               | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/library/std/src/sys/net/connection/socket/windows.rs b/library/std/src/sys/net/connection/socket/windows.rs
index 5b6f4cedf1b77..2221023a21252 100644
--- a/library/std/src/sys/net/connection/socket/windows.rs
+++ b/library/std/src/sys/net/connection/socket/windows.rs
@@ -111,7 +111,7 @@ pub(super) mod netc {
     }
 }
 
-pub use crate::sys::pal::winsock::{cleanup, cvt, cvt_gai, cvt_r, startup as init};
+pub use crate::sys::pal::winsock::{cvt, cvt_gai, cvt_r, startup as init};
 
 #[expect(missing_debug_implementations)]
 pub struct Socket(OwnedSocket);
diff --git a/library/std/src/sys/pal/windows/mod.rs b/library/std/src/sys/pal/windows/mod.rs
index 18ab34982676c..a5f060080130f 100644
--- a/library/std/src/sys/pal/windows/mod.rs
+++ b/library/std/src/sys/pal/windows/mod.rs
@@ -58,7 +58,7 @@ pub unsafe fn init(_argc: isize, _argv: *const *const u8, _sigpipe: u8) {
 // SAFETY: must be called only once during runtime cleanup.
 // NOTE: this is not guaranteed to run, for example when the program aborts.
 pub unsafe fn cleanup() {
-    crate::sys::net::cleanup();
+    winsock::cleanup();
 }
 
 #[inline]

From 5139facb365c40e5b0ddedf221cd62347a2a4504 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Tue, 30 Sep 2025 12:02:43 +0200
Subject: [PATCH 1581/1889] add tests

---
 .../src/solve/assembly/mod.rs                 |  5 +-
 .../ui/indexing/ambiguity-after-deref-step.rs |  9 +++
 .../ambiguity-after-deref-step.stderr         | 17 ++++++
 .../forced-ambiguity-typenum-ice.rs           | 60 +++++++++++++++++++
 4 files changed, 90 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/indexing/ambiguity-after-deref-step.rs
 create mode 100644 tests/ui/indexing/ambiguity-after-deref-step.stderr
 create mode 100644 tests/ui/traits/next-solver/forced-ambiguity-typenum-ice.rs

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 a2e6ef6f0fe8b..d58c264841c85 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
@@ -473,7 +473,10 @@ where
         // fails to reach a fixpoint but ends up getting an error after
         // running for some additional step.
         //
-        // cc trait-system-refactor-initiative#105
+        // FIXME(@lcnr): While I believe an error here to be possible, we
+        // currently don't have any test which actually triggers it. @lqd
+        // created a minimization for an ICE in typenum, but that one no
+        // longer fails here. cc trait-system-refactor-initiative#105.
         let source = CandidateSource::BuiltinImpl(BuiltinImplSource::Misc);
         let certainty = Certainty::Maybe { cause, opaque_types_jank: OpaqueTypesJank::AllGood };
         self.probe_trait_candidate(source)
diff --git a/tests/ui/indexing/ambiguity-after-deref-step.rs b/tests/ui/indexing/ambiguity-after-deref-step.rs
new file mode 100644
index 0000000000000..2dd95eed097ca
--- /dev/null
+++ b/tests/ui/indexing/ambiguity-after-deref-step.rs
@@ -0,0 +1,9 @@
+// Regression test making sure that indexing fails with an ambiguity
+// error if one of the deref-steps encounters an inference variable.
+
+fn main() {
+    let x = &Default::default();
+    //~^ ERROR type annotations needed for `&_`
+    x[1];
+    let _: &Vec<()> = x;
+}
diff --git a/tests/ui/indexing/ambiguity-after-deref-step.stderr b/tests/ui/indexing/ambiguity-after-deref-step.stderr
new file mode 100644
index 0000000000000..c7ddd4731c7cb
--- /dev/null
+++ b/tests/ui/indexing/ambiguity-after-deref-step.stderr
@@ -0,0 +1,17 @@
+error[E0282]: type annotations needed for `&_`
+  --> $DIR/ambiguity-after-deref-step.rs:5:9
+   |
+LL |     let x = &Default::default();
+   |         ^
+LL |
+LL |     x[1];
+   |     - type must be known at this point
+   |
+help: consider giving `x` an explicit type, where the placeholders `_` are specified
+   |
+LL |     let x: &_ = &Default::default();
+   |          ++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/traits/next-solver/forced-ambiguity-typenum-ice.rs b/tests/ui/traits/next-solver/forced-ambiguity-typenum-ice.rs
new file mode 100644
index 0000000000000..679d6b1fb165a
--- /dev/null
+++ b/tests/ui/traits/next-solver/forced-ambiguity-typenum-ice.rs
@@ -0,0 +1,60 @@
+//@ compile-flags: -Znext-solver
+//@ check-pass
+
+// Regression test for trait-system-refactor-initiative#105. We previously encountered
+// an ICE in typenum as `forced_ambiguity` failed. While this test no longer causes
+// `forced_ambiguity` to error, we still want to use it as a regression test.
+
+pub struct UInt<U, B> {
+    _msb: U,
+    _lsb: B,
+}
+pub struct B1;
+pub trait Sub<Rhs> {
+    type Output;
+}
+impl<U, B> Sub<B1> for UInt<UInt<U, B>, B1> {
+    type Output = ();
+}
+impl<U> Sub<B1> for UInt<U, ()>
+where
+    U: Sub<B1>,
+    U::Output: Send,
+{
+    type Output = ();
+}
+
+pub trait Op<N, R, I> {
+    fn op(&self) {
+        unimplemented!()
+    }
+}
+trait OpIf<N, R, I> {}
+
+impl<N, Ur, Br, I> Op<N, UInt<Ur, Br>, I> for ()
+where
+    N: Sub<I>,
+    (): OpIf<N, UInt<UInt<Ur, Br>, N::Output>, I>,
+{
+}
+impl<N, R, Ui, Bi> OpIf<N, R, UInt<Ui, Bi>> for ()
+where
+    UInt<Ui, Bi>: Sub<B1>,
+    (): Op<N, R, <UInt<Ui, Bi> as Sub<B1>>::Output>,
+{
+}
+impl<N, R> OpIf<N, R, ()> for () where R: Sub<N> {}
+
+pub trait Compute {
+    type Output;
+}
+
+pub fn repro<Ul, Bl>()
+where
+    UInt<Ul, Bl>: Compute,
+    <UInt<Ul, Bl> as Compute>::Output: Sub<B1>,
+    (): Op<UInt<(), Bl>, (), ()>,
+{
+    ().op();
+}
+fn main() {}

From cd40bbfe2965a42ae8336ebd70fc7fb9c81d22e0 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Mon, 29 Sep 2025 20:53:06 +1000
Subject: [PATCH 1582/1889] Move `MetadataKindId` into its own submodule

---
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs         | 11 +----------
 .../rustc_codegen_llvm/src/llvm/metadata_kind.rs    | 13 +++++++++++++
 compiler/rustc_codegen_llvm/src/llvm/mod.rs         |  2 ++
 3 files changed, 16 insertions(+), 10 deletions(-)
 create mode 100644 compiler/rustc_codegen_llvm/src/llvm/metadata_kind.rs

diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index afd2991a09c3a..83867cc2dce66 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -29,6 +29,7 @@ use super::debuginfo::{
     DITemplateTypeParameter, DIType, DebugEmissionKind, DebugNameTableKind,
 };
 use crate::llvm;
+use crate::llvm::MetadataKindId;
 
 /// In the LLVM-C API, boolean values are passed as `typedef int LLVMBool`,
 /// which has a different ABI from Rust or C++ `bool`.
@@ -1035,16 +1036,6 @@ pub(crate) type GetSymbolsCallback =
     unsafe extern "C" fn(*mut c_void, *const c_char) -> *mut c_void;
 pub(crate) type GetSymbolsErrorCallback = unsafe extern "C" fn(*const c_char) -> *mut c_void;
 
-#[derive(Copy, Clone)]
-#[repr(transparent)]
-pub(crate) struct MetadataKindId(c_uint);
-
-impl From<MetadataType> for MetadataKindId {
-    fn from(value: MetadataType) -> Self {
-        Self(value as c_uint)
-    }
-}
-
 unsafe extern "C" {
     // Create and destroy contexts.
     pub(crate) fn LLVMContextDispose(C: &'static mut Context);
diff --git a/compiler/rustc_codegen_llvm/src/llvm/metadata_kind.rs b/compiler/rustc_codegen_llvm/src/llvm/metadata_kind.rs
new file mode 100644
index 0000000000000..926eb78935205
--- /dev/null
+++ b/compiler/rustc_codegen_llvm/src/llvm/metadata_kind.rs
@@ -0,0 +1,13 @@
+use libc::c_uint;
+
+use crate::llvm::MetadataType;
+
+#[derive(Copy, Clone)]
+#[repr(transparent)]
+pub(crate) struct MetadataKindId(c_uint);
+
+impl From<MetadataType> for MetadataKindId {
+    fn from(value: MetadataType) -> Self {
+        Self(value as c_uint)
+    }
+}
diff --git a/compiler/rustc_codegen_llvm/src/llvm/mod.rs b/compiler/rustc_codegen_llvm/src/llvm/mod.rs
index 1115d82fa85d3..2333fbe7a7656 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/mod.rs
@@ -13,11 +13,13 @@ pub(crate) use self::CallConv::*;
 pub(crate) use self::CodeGenOptSize::*;
 pub(crate) use self::MetadataType::*;
 pub(crate) use self::ffi::*;
+pub(crate) use self::metadata_kind::MetadataKindId;
 use crate::common::AsCCharPtr;
 
 pub(crate) mod diagnostic;
 pub(crate) mod enzyme_ffi;
 mod ffi;
+mod metadata_kind;
 
 pub(crate) use self::enzyme_ffi::*;
 

From 906bf49ade52d7485a6c8a0756f020ade3a342b6 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Mon, 29 Sep 2025 20:21:33 +1000
Subject: [PATCH 1583/1889] Declare all "fixed" metadata kinds as
 `MetadataKindId`

---
 .../src/llvm/metadata_kind.rs                 | 64 +++++++++++++++++++
 .../rustc_llvm/llvm-wrapper/RustWrapper.cpp   | 52 +++++++++++++++
 2 files changed, 116 insertions(+)

diff --git a/compiler/rustc_codegen_llvm/src/llvm/metadata_kind.rs b/compiler/rustc_codegen_llvm/src/llvm/metadata_kind.rs
index 926eb78935205..4d00356c61627 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/metadata_kind.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/metadata_kind.rs
@@ -11,3 +11,67 @@ impl From<MetadataType> for MetadataKindId {
         Self(value as c_uint)
     }
 }
+
+macro_rules! declare_fixed_metadata_kinds {
+    (
+        $(
+            FIXED_MD_KIND($variant:ident, $value:literal)
+        )*
+    ) => {
+        // Use a submodule to group all declarations into one `#[expect(..)]`.
+        #[expect(dead_code)]
+        mod fixed_kinds {
+            use super::MetadataKindId;
+            $(
+                #[expect(non_upper_case_globals)]
+                pub(crate) const $variant: MetadataKindId = MetadataKindId($value);
+            )*
+        }
+    };
+}
+
+// Must be kept in sync with the corresponding static assertions in `RustWrapper.cpp`.
+declare_fixed_metadata_kinds! {
+    FIXED_MD_KIND(MD_dbg, 0)
+    FIXED_MD_KIND(MD_tbaa, 1)
+    FIXED_MD_KIND(MD_prof, 2)
+    FIXED_MD_KIND(MD_fpmath, 3)
+    FIXED_MD_KIND(MD_range, 4)
+    FIXED_MD_KIND(MD_tbaa_struct, 5)
+    FIXED_MD_KIND(MD_invariant_load, 6)
+    FIXED_MD_KIND(MD_alias_scope, 7)
+    FIXED_MD_KIND(MD_noalias, 8)
+    FIXED_MD_KIND(MD_nontemporal, 9)
+    FIXED_MD_KIND(MD_mem_parallel_loop_access, 10)
+    FIXED_MD_KIND(MD_nonnull, 11)
+    FIXED_MD_KIND(MD_dereferenceable, 12)
+    FIXED_MD_KIND(MD_dereferenceable_or_null, 13)
+    FIXED_MD_KIND(MD_make_implicit, 14)
+    FIXED_MD_KIND(MD_unpredictable, 15)
+    FIXED_MD_KIND(MD_invariant_group, 16)
+    FIXED_MD_KIND(MD_align, 17)
+    FIXED_MD_KIND(MD_loop, 18)
+    FIXED_MD_KIND(MD_type, 19)
+    FIXED_MD_KIND(MD_section_prefix, 20)
+    FIXED_MD_KIND(MD_absolute_symbol, 21)
+    FIXED_MD_KIND(MD_associated, 22)
+    FIXED_MD_KIND(MD_callees, 23)
+    FIXED_MD_KIND(MD_irr_loop, 24)
+    FIXED_MD_KIND(MD_access_group, 25)
+    FIXED_MD_KIND(MD_callback, 26)
+    FIXED_MD_KIND(MD_preserve_access_index, 27)
+    FIXED_MD_KIND(MD_vcall_visibility, 28)
+    FIXED_MD_KIND(MD_noundef, 29)
+    FIXED_MD_KIND(MD_annotation, 30)
+    FIXED_MD_KIND(MD_nosanitize, 31)
+    FIXED_MD_KIND(MD_func_sanitize, 32)
+    FIXED_MD_KIND(MD_exclude, 33)
+    FIXED_MD_KIND(MD_memprof, 34)
+    FIXED_MD_KIND(MD_callsite, 35)
+    FIXED_MD_KIND(MD_kcfi_type, 36)
+    FIXED_MD_KIND(MD_pcsections, 37)
+    FIXED_MD_KIND(MD_DIAssignID, 38)
+    FIXED_MD_KIND(MD_coro_outside_frame, 39)
+    FIXED_MD_KIND(MD_mmra, 40)
+    FIXED_MD_KIND(MD_noalias_addrspace, 41)
+}
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index 4a77812591893..2b83ea24ac61c 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -1824,3 +1824,55 @@ extern "C" size_t LLVMRustEnzymeGetMaxTypeDepth() {
   return 6; // Default fallback depth
 }
 #endif
+
+// Statically assert that the fixed metadata kind IDs declared in
+// `metadata_kind.rs` match the ones actually used by LLVM.
+#define FIXED_MD_KIND(VARIANT, VALUE)                                          \
+  static_assert(::llvm::LLVMContext::VARIANT == VALUE);
+// Must be kept in sync with the corresponding list in `metadata_kind.rs`.
+FIXED_MD_KIND(MD_dbg, 0)
+FIXED_MD_KIND(MD_tbaa, 1)
+FIXED_MD_KIND(MD_prof, 2)
+FIXED_MD_KIND(MD_fpmath, 3)
+FIXED_MD_KIND(MD_range, 4)
+FIXED_MD_KIND(MD_tbaa_struct, 5)
+FIXED_MD_KIND(MD_invariant_load, 6)
+FIXED_MD_KIND(MD_alias_scope, 7)
+FIXED_MD_KIND(MD_noalias, 8)
+FIXED_MD_KIND(MD_nontemporal, 9)
+FIXED_MD_KIND(MD_mem_parallel_loop_access, 10)
+FIXED_MD_KIND(MD_nonnull, 11)
+FIXED_MD_KIND(MD_dereferenceable, 12)
+FIXED_MD_KIND(MD_dereferenceable_or_null, 13)
+FIXED_MD_KIND(MD_make_implicit, 14)
+FIXED_MD_KIND(MD_unpredictable, 15)
+FIXED_MD_KIND(MD_invariant_group, 16)
+FIXED_MD_KIND(MD_align, 17)
+FIXED_MD_KIND(MD_loop, 18)
+FIXED_MD_KIND(MD_type, 19)
+FIXED_MD_KIND(MD_section_prefix, 20)
+FIXED_MD_KIND(MD_absolute_symbol, 21)
+FIXED_MD_KIND(MD_associated, 22)
+FIXED_MD_KIND(MD_callees, 23)
+FIXED_MD_KIND(MD_irr_loop, 24)
+FIXED_MD_KIND(MD_access_group, 25)
+FIXED_MD_KIND(MD_callback, 26)
+FIXED_MD_KIND(MD_preserve_access_index, 27)
+FIXED_MD_KIND(MD_vcall_visibility, 28)
+FIXED_MD_KIND(MD_noundef, 29)
+FIXED_MD_KIND(MD_annotation, 30)
+FIXED_MD_KIND(MD_nosanitize, 31)
+FIXED_MD_KIND(MD_func_sanitize, 32)
+FIXED_MD_KIND(MD_exclude, 33)
+FIXED_MD_KIND(MD_memprof, 34)
+FIXED_MD_KIND(MD_callsite, 35)
+FIXED_MD_KIND(MD_kcfi_type, 36)
+FIXED_MD_KIND(MD_pcsections, 37)
+FIXED_MD_KIND(MD_DIAssignID, 38)
+FIXED_MD_KIND(MD_coro_outside_frame, 39)
+FIXED_MD_KIND(MD_mmra, 40)
+FIXED_MD_KIND(MD_noalias_addrspace, 41)
+// If some fixed metadata kinds are not present and consistent in all supported
+// LLVM versions, it's fine to omit them from this list; in that case Rust-side
+// code cannot declare them as fixed IDs and must look them up by name instead.
+#undef FIXED_MD_KIND

From cc6329a9bcd78c4531e9713775e2936fe223e601 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 30 Sep 2025 20:05:23 +1000
Subject: [PATCH 1584/1889] Replace `MetadataType` with the `MetadataKindId`
 constants

---
 compiler/rustc_codegen_llvm/src/context.rs    |  6 ++--
 .../src/debuginfo/metadata.rs                 |  8 ++---
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs   | 33 ++++---------------
 .../src/llvm/metadata_kind.rs                 |  8 +----
 compiler/rustc_codegen_llvm/src/llvm/mod.rs   |  3 +-
 compiler/rustc_codegen_llvm/src/type_.rs      |  8 ++---
 6 files changed, 17 insertions(+), 49 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index aa5c17269fb84..b1da6f7c74061 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -34,7 +34,7 @@ use smallvec::SmallVec;
 use crate::back::write::to_llvm_code_model;
 use crate::callee::get_fn;
 use crate::debuginfo::metadata::apply_vcall_visibility_metadata;
-use crate::llvm::Metadata;
+use crate::llvm::{Metadata, MetadataKindId};
 use crate::type_::Type;
 use crate::value::Value;
 use crate::{attributes, common, coverageinfo, debuginfo, llvm, llvm_util};
@@ -1006,11 +1006,11 @@ impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX> {
     pub(crate) fn set_metadata<'a>(
         &self,
         val: &'a Value,
-        kind_id: impl Into<llvm::MetadataKindId>,
+        kind_id: MetadataKindId,
         md: &'ll Metadata,
     ) {
         let node = self.get_metadata_value(md);
-        llvm::LLVMSetMetadata(val, kind_id.into(), node);
+        llvm::LLVMSetMetadata(val, kind_id, node);
     }
 }
 
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
index 1e4ace4ca922c..bc20c75941349 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
@@ -1611,16 +1611,12 @@ pub(crate) fn apply_vcall_visibility_metadata<'ll, 'tcx>(
         let v = [llvm::LLVMValueAsMetadata(cx.const_usize(0)), typeid];
         llvm::LLVMRustGlobalAddMetadata(
             vtable,
-            llvm::MD_type as c_uint,
+            llvm::MD_type,
             llvm::LLVMMDNodeInContext2(cx.llcx, v.as_ptr(), v.len()),
         );
         let vcall_visibility = llvm::LLVMValueAsMetadata(cx.const_u64(vcall_visibility as u64));
         let vcall_visibility_metadata = llvm::LLVMMDNodeInContext2(cx.llcx, &vcall_visibility, 1);
-        llvm::LLVMGlobalSetMetadata(
-            vtable,
-            llvm::MetadataType::MD_vcall_visibility as c_uint,
-            vcall_visibility_metadata,
-        );
+        llvm::LLVMGlobalSetMetadata(vtable, llvm::MD_vcall_visibility, vcall_visibility_metadata);
     }
 }
 
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 83867cc2dce66..f17de168ca434 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -514,31 +514,6 @@ pub(crate) enum FileType {
     ObjectFile,
 }
 
-/// LLVMMetadataType
-#[derive(Copy, Clone)]
-#[repr(C)]
-#[expect(dead_code, reason = "Some variants are unused, but are kept to match LLVM-C")]
-pub(crate) enum MetadataType {
-    MD_dbg = 0,
-    MD_tbaa = 1,
-    MD_prof = 2,
-    MD_fpmath = 3,
-    MD_range = 4,
-    MD_tbaa_struct = 5,
-    MD_invariant_load = 6,
-    MD_alias_scope = 7,
-    MD_noalias = 8,
-    MD_nontemporal = 9,
-    MD_mem_parallel_loop_access = 10,
-    MD_nonnull = 11,
-    MD_unpredictable = 15,
-    MD_align = 17,
-    MD_type = 19,
-    MD_vcall_visibility = 28,
-    MD_noundef = 29,
-    MD_kcfi_type = 36,
-}
-
 /// Must match the layout of `LLVMInlineAsmDialect`.
 #[derive(Copy, Clone, PartialEq)]
 #[repr(C)]
@@ -1130,7 +1105,11 @@ unsafe extern "C" {
     pub(crate) fn LLVMSetValueName2(Val: &Value, Name: *const c_char, NameLen: size_t);
     pub(crate) fn LLVMReplaceAllUsesWith<'a>(OldVal: &'a Value, NewVal: &'a Value);
     pub(crate) safe fn LLVMSetMetadata<'a>(Val: &'a Value, KindID: MetadataKindId, Node: &'a Value);
-    pub(crate) fn LLVMGlobalSetMetadata<'a>(Val: &'a Value, KindID: c_uint, Metadata: &'a Metadata);
+    pub(crate) fn LLVMGlobalSetMetadata<'a>(
+        Val: &'a Value,
+        KindID: MetadataKindId,
+        Metadata: &'a Metadata,
+    );
     pub(crate) safe fn LLVMValueAsMetadata(Node: &Value) -> &Metadata;
 
     // Operations on constants of any type
@@ -2050,7 +2029,7 @@ unsafe extern "C" {
     // Operations on all values
     pub(crate) fn LLVMRustGlobalAddMetadata<'a>(
         Val: &'a Value,
-        KindID: c_uint,
+        KindID: MetadataKindId,
         Metadata: &'a Metadata,
     );
     pub(crate) fn LLVMRustIsNonGVFunctionPointerTy(Val: &Value) -> bool;
diff --git a/compiler/rustc_codegen_llvm/src/llvm/metadata_kind.rs b/compiler/rustc_codegen_llvm/src/llvm/metadata_kind.rs
index 4d00356c61627..a8a671b5c85f1 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/metadata_kind.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/metadata_kind.rs
@@ -1,17 +1,11 @@
 use libc::c_uint;
 
-use crate::llvm::MetadataType;
+pub(crate) use self::fixed_kinds::*;
 
 #[derive(Copy, Clone)]
 #[repr(transparent)]
 pub(crate) struct MetadataKindId(c_uint);
 
-impl From<MetadataType> for MetadataKindId {
-    fn from(value: MetadataType) -> Self {
-        Self(value as c_uint)
-    }
-}
-
 macro_rules! declare_fixed_metadata_kinds {
     (
         $(
diff --git a/compiler/rustc_codegen_llvm/src/llvm/mod.rs b/compiler/rustc_codegen_llvm/src/llvm/mod.rs
index 2333fbe7a7656..9a53dacb1dfdd 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/mod.rs
@@ -11,9 +11,8 @@ use rustc_llvm::RustString;
 
 pub(crate) use self::CallConv::*;
 pub(crate) use self::CodeGenOptSize::*;
-pub(crate) use self::MetadataType::*;
 pub(crate) use self::ffi::*;
-pub(crate) use self::metadata_kind::MetadataKindId;
+pub(crate) use self::metadata_kind::*;
 use crate::common::AsCCharPtr;
 
 pub(crate) mod diagnostic;
diff --git a/compiler/rustc_codegen_llvm/src/type_.rs b/compiler/rustc_codegen_llvm/src/type_.rs
index 9ecaf5f24fe15..5b97898a4b888 100644
--- a/compiler/rustc_codegen_llvm/src/type_.rs
+++ b/compiler/rustc_codegen_llvm/src/type_.rs
@@ -306,7 +306,7 @@ impl<'ll, 'tcx> TypeMembershipCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
             let v = [llvm::LLVMValueAsMetadata(self.const_usize(0)), typeid_metadata];
             llvm::LLVMRustGlobalAddMetadata(
                 function,
-                llvm::MD_type as c_uint,
+                llvm::MD_type,
                 llvm::LLVMMDNodeInContext2(self.llcx, v.as_ptr(), v.len()),
             )
         }
@@ -318,7 +318,7 @@ impl<'ll, 'tcx> TypeMembershipCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
             let v = [llvm::LLVMValueAsMetadata(self.const_usize(0)), typeid_metadata];
             llvm::LLVMGlobalSetMetadata(
                 function,
-                llvm::MD_type as c_uint,
+                llvm::MD_type,
                 llvm::LLVMMDNodeInContext2(self.llcx, v.as_ptr(), v.len()),
             )
         }
@@ -333,7 +333,7 @@ impl<'ll, 'tcx> TypeMembershipCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         unsafe {
             llvm::LLVMRustGlobalAddMetadata(
                 function,
-                llvm::MD_kcfi_type as c_uint,
+                llvm::MD_kcfi_type,
                 llvm::LLVMMDNodeInContext2(
                     self.llcx,
                     &llvm::LLVMValueAsMetadata(kcfi_type_metadata),
@@ -348,7 +348,7 @@ impl<'ll, 'tcx> TypeMembershipCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         unsafe {
             llvm::LLVMGlobalSetMetadata(
                 function,
-                llvm::MD_kcfi_type as c_uint,
+                llvm::MD_kcfi_type,
                 llvm::LLVMMDNodeInContext2(
                     self.llcx,
                     &llvm::LLVMValueAsMetadata(kcfi_type_metadata),

From eba1416c015803aab6d3ac0b7efebb28165b50ab Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Tue, 30 Sep 2025 12:43:36 +0200
Subject: [PATCH 1585/1889] std: improve internal socket functions

---
 .../std/src/sys/net/connection/socket/mod.rs  | 96 +++++++++++++------
 1 file changed, 69 insertions(+), 27 deletions(-)

diff --git a/library/std/src/sys/net/connection/socket/mod.rs b/library/std/src/sys/net/connection/socket/mod.rs
index 1dd06e97bbabd..8a758947cc2d6 100644
--- a/library/std/src/sys/net/connection/socket/mod.rs
+++ b/library/std/src/sys/net/connection/socket/mod.rs
@@ -3,6 +3,7 @@ mod tests;
 
 use crate::ffi::{c_int, c_void};
 use crate::io::{self, BorrowedCursor, ErrorKind, IoSlice, IoSliceMut};
+use crate::mem::MaybeUninit;
 use crate::net::{
     Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs,
 };
@@ -177,6 +178,11 @@ fn socket_addr_to_c(addr: &SocketAddr) -> (SocketAddrCRepr, c::socklen_t) {
     }
 }
 
+/// Converts the C socket address stored in `storage` to a Rust `SocketAddr`.
+///
+/// # Safety
+/// * `storage` must contain a valid C socket address whose length is no larger
+///   than `len`.
 unsafe fn socket_addr_from_c(
     storage: *const c::sockaddr_storage,
     len: usize,
@@ -202,49 +208,85 @@ unsafe fn socket_addr_from_c(
 // sockaddr and misc bindings
 ////////////////////////////////////////////////////////////////////////////////
 
-pub fn setsockopt<T>(
+/// Sets the value of a socket option.
+///
+/// # Safety
+/// `T` must be the type associated with the given socket option.
+pub unsafe fn setsockopt<T>(
     sock: &Socket,
     level: c_int,
     option_name: c_int,
     option_value: T,
 ) -> io::Result<()> {
-    unsafe {
-        cvt(c::setsockopt(
+    let option_len = size_of::<T>() as c::socklen_t;
+    // SAFETY:
+    // * `sock` is opened for the duration of this call, as `sock` owns the socket.
+    // * the pointer to `option_value` is readable at a size of `size_of::<T>`
+    //   bytes
+    // * the value of `option_value` has a valid type for the given socket option
+    //   (guaranteed by caller).
+    cvt(unsafe {
+        c::setsockopt(
             sock.as_raw(),
             level,
             option_name,
             (&raw const option_value) as *const _,
-            size_of::<T>() as c::socklen_t,
-        ))?;
-        Ok(())
-    }
+            option_len,
+        )
+    })?;
+    Ok(())
 }
 
-pub fn getsockopt<T: Copy>(sock: &Socket, level: c_int, option_name: c_int) -> io::Result<T> {
-    unsafe {
-        let mut option_value: T = mem::zeroed();
-        let mut option_len = size_of::<T>() as c::socklen_t;
-        cvt(c::getsockopt(
+/// Gets the value of a socket option.
+///
+/// # Safety
+/// `T` must be the type associated with the given socket option.
+pub unsafe fn getsockopt<T: Copy>(
+    sock: &Socket,
+    level: c_int,
+    option_name: c_int,
+) -> io::Result<T> {
+    let mut option_value = MaybeUninit::<T>::zeroed();
+    let mut option_len = size_of::<T>() as c::socklen_t;
+
+    // SAFETY:
+    // * `sock` is opened for the duration of this call, as `sock` owns the socket.
+    // * the pointer to `option_value` is writable and the stack allocation has
+    //   space for `size_of::<T>` bytes.
+    cvt(unsafe {
+        c::getsockopt(
             sock.as_raw(),
             level,
             option_name,
-            (&raw mut option_value) as *mut _,
+            option_value.as_mut_ptr().cast(),
             &mut option_len,
-        ))?;
-        Ok(option_value)
-    }
-}
-
-fn sockname<F>(f: F) -> io::Result<SocketAddr>
+        )
+    })?;
+
+    // SAFETY: the `getsockopt` call succeeded and the caller guarantees that
+    //         `T` is the type of this option, thus `option_value` must have
+    //         been initialized by the system.
+    Ok(unsafe { option_value.assume_init() })
+}
+
+/// Wraps a call to a platform function that returns a socket address.
+///
+/// # Safety
+/// * if `f` returns a success (i.e. `cvt` returns `Ok` when called on the
+///   return value), the buffer provided to `f` must have been initialized
+///   with a valid C socket address, the length of which must be written
+///   to the second argument.
+unsafe fn sockname<F>(f: F) -> io::Result<SocketAddr>
 where
     F: FnOnce(*mut c::sockaddr, *mut c::socklen_t) -> c_int,
 {
-    unsafe {
-        let mut storage: c::sockaddr_storage = mem::zeroed();
-        let mut len = size_of_val(&storage) as c::socklen_t;
-        cvt(f((&raw mut storage) as *mut _, &mut len))?;
-        socket_addr_from_c(&storage, len as usize)
-    }
+    let mut storage = MaybeUninit::<c::sockaddr_storage>::zeroed();
+    let mut len = size_of::<c::sockaddr_storage>() as c::socklen_t;
+    cvt(f(storage.as_mut_ptr().cast(), &mut len))?;
+    // SAFETY:
+    // The caller guarantees that the storage has been successfully initialized
+    // and its size written to `len` if `f` returns a success.
+    unsafe { socket_addr_from_c(storage.as_ptr(), len as usize) }
 }
 
 #[cfg(target_os = "android")]
@@ -546,8 +588,8 @@ impl TcpListener {
         // The `accept` function will fill in the storage with the address,
         // so we don't need to zero it here.
         // reference: https://linux.die.net/man/2/accept4
-        let mut storage: mem::MaybeUninit<c::sockaddr_storage> = mem::MaybeUninit::uninit();
-        let mut len = size_of_val(&storage) as c::socklen_t;
+        let mut storage = MaybeUninit::<c::sockaddr_storage>::uninit();
+        let mut len = size_of::<c::sockaddr_storage>() as c::socklen_t;
         let sock = self.inner.accept(storage.as_mut_ptr() as *mut _, &mut len)?;
         let addr = unsafe { socket_addr_from_c(storage.as_ptr(), len as usize)? };
         Ok((TcpStream { inner: sock }, addr))

From 817e181ee80256d93156bbb8ba0a1daafb3cf4fc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Mon, 29 Sep 2025 15:00:10 +0200
Subject: [PATCH 1586/1889] test bevy compute_implied_bounds hack with new
 trait solver

---
 tests/ui/implied-bounds/bevy_world_query.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/tests/ui/implied-bounds/bevy_world_query.rs b/tests/ui/implied-bounds/bevy_world_query.rs
index 6548c03d1b00c..e2750bcf957ea 100644
--- a/tests/ui/implied-bounds/bevy_world_query.rs
+++ b/tests/ui/implied-bounds/bevy_world_query.rs
@@ -1,6 +1,8 @@
-#![crate_name = "bevy_ecs"]
-
 //@ check-pass
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
+#![crate_name = "bevy_ecs"]
 
 // We currently special case bevy from erroring on incorrect implied bounds
 // from normalization (issue #109628).

From fef865731cdf89995f8e8667641701843b4a3168 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Tue, 30 Sep 2025 15:40:54 +0300
Subject: [PATCH 1587/1889] Impl `std::error::Error` for `SyntaxError`

---
 src/tools/rust-analyzer/crates/syntax/src/syntax_error.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/syntax/src/syntax_error.rs b/src/tools/rust-analyzer/crates/syntax/src/syntax_error.rs
index dc6130bd6415c..1c902893abc64 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/syntax_error.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/syntax_error.rs
@@ -42,3 +42,5 @@ impl fmt::Display for SyntaxError {
         self.0.fmt(f)
     }
 }
+
+impl std::error::Error for SyntaxError {}

From 198777a08e74e2b7a59ed9b7a8b2561eaddc160e Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Tue, 30 Sep 2025 15:03:40 +0200
Subject: [PATCH 1588/1889] remove unnecessary test directives

---
 .../trait-upcasting/illegal-upcast-to-impl-opaque.rs       | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/tests/ui/traits/trait-upcasting/illegal-upcast-to-impl-opaque.rs b/tests/ui/traits/trait-upcasting/illegal-upcast-to-impl-opaque.rs
index 2760c1696b56d..f603ff1ec80ec 100644
--- a/tests/ui/traits/trait-upcasting/illegal-upcast-to-impl-opaque.rs
+++ b/tests/ui/traits/trait-upcasting/illegal-upcast-to-impl-opaque.rs
@@ -1,12 +1,5 @@
 //@ revisions: current next
 //@[next] compile-flags: -Znext-solver
-//@[next] failure-status: 101
-//@[next] known-bug: unknown
-//@[next] normalize-stderr: "note: .*\n\n" -> ""
-//@[next] normalize-stderr: "thread 'rustc' panicked.*\n.*\n" -> ""
-//@[next] normalize-stderr: "(error: internal compiler error: [^:]+):\d+:\d+: " -> "$1:LL:CC: "
-//@[next] normalize-stderr: "delayed at .*" -> ""
-//@[next] rustc-env:RUST_BACKTRACE=0
 //@ check-pass
 
 trait Super {

From 9e79fac0354b2a87515c30e94754413ef99b3675 Mon Sep 17 00:00:00 2001
From: Taiki Endo <te316e89@gmail.com>
Date: Tue, 30 Sep 2025 22:39:10 +0900
Subject: [PATCH 1589/1889] Add repr(align(2)) to RcInner and ArcInner

---
 library/alloc/src/rc.rs   |  4 +++-
 library/alloc/src/sync.rs | 16 +++++++++-------
 2 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/library/alloc/src/rc.rs b/library/alloc/src/rc.rs
index fcb466778a3fb..e8527b18f0706 100644
--- a/library/alloc/src/rc.rs
+++ b/library/alloc/src/rc.rs
@@ -277,7 +277,9 @@ use crate::vec::Vec;
 // This is repr(C) to future-proof against possible field-reordering, which
 // would interfere with otherwise safe [into|from]_raw() of transmutable
 // inner types.
-#[repr(C)]
+// repr(align(2)) (forcing alignment to at least 2) is required because usize
+// has 1-byte alignment on AVR.
+#[repr(C, align(2))]
 struct RcInner<T: ?Sized> {
     strong: Cell<usize>,
     weak: Cell<usize>,
diff --git a/library/alloc/src/sync.rs b/library/alloc/src/sync.rs
index 32396cccb8fca..6bab3b7056f67 100644
--- a/library/alloc/src/sync.rs
+++ b/library/alloc/src/sync.rs
@@ -341,7 +341,7 @@ pub struct Weak<
     // but it is not necessarily a valid pointer.
     // `Weak::new` sets this to `usize::MAX` so that it doesn’t need
     // to allocate space on the heap. That's not a value a real pointer
-    // will ever have because RcInner has alignment at least 2.
+    // will ever have because ArcInner has alignment at least 2.
     ptr: NonNull<ArcInner<T>>,
     alloc: A,
 }
@@ -366,7 +366,9 @@ impl<T: ?Sized, A: Allocator> fmt::Debug for Weak<T, A> {
 // This is repr(C) to future-proof against possible field-reordering, which
 // would interfere with otherwise safe [into|from]_raw() of transmutable
 // inner types.
-#[repr(C)]
+// Unlike RcInner, repr(align(2)) is not strictly required because atomic types
+// have the alignment same as its size, but we use it for consistency and clarity.
+#[repr(C, align(2))]
 struct ArcInner<T: ?Sized> {
     strong: Atomic<usize>,
 
@@ -1622,9 +1624,9 @@ impl<T: ?Sized, A: Allocator> Arc<T, A> {
     pub fn as_ptr(this: &Self) -> *const T {
         let ptr: *mut ArcInner<T> = NonNull::as_ptr(this.ptr);
 
-        // SAFETY: This cannot go through Deref::deref or RcInnerPtr::inner because
+        // SAFETY: This cannot go through Deref::deref or ArcInnerPtr::inner because
         // this is required to retain raw/mut provenance such that e.g. `get_mut` can
-        // write through the pointer after the Rc is recovered through `from_raw`.
+        // write through the pointer after the Arc is recovered through `from_raw`.
         unsafe { &raw mut (*ptr).data }
     }
 
@@ -2459,7 +2461,7 @@ impl<T: ?Sized, A: Allocator> Arc<T, A> {
     /// If any other `Arc` or [`Weak`] pointers to the same allocation exist, then
     /// they must not be dereferenced or have active borrows for the duration
     /// of the returned borrow, and their inner type must be exactly the same as the
-    /// inner type of this Rc (including lifetimes). This is trivially the case if no
+    /// inner type of this Arc (including lifetimes). This is trivially the case if no
     /// such pointers exist, for example immediately after `Arc::new`.
     ///
     /// # Examples
@@ -3031,7 +3033,7 @@ impl<T: ?Sized, A: Allocator> Weak<T, A> {
             // Otherwise, we're guaranteed the pointer came from a nondangling Weak.
             // SAFETY: data_offset is safe to call, as ptr references a real (potentially dropped) T.
             let offset = unsafe { data_offset(ptr) };
-            // Thus, we reverse the offset to get the whole RcInner.
+            // Thus, we reverse the offset to get the whole ArcInner.
             // SAFETY: the pointer originated from a Weak, so this offset is safe.
             unsafe { ptr.byte_sub(offset) as *mut ArcInner<T> }
         };
@@ -4024,7 +4026,7 @@ impl<T: ?Sized, A: Allocator> Unpin for Arc<T, A> {}
 /// valid instance of T, but the T is allowed to be dropped.
 unsafe fn data_offset<T: ?Sized>(ptr: *const T) -> usize {
     // Align the unsized value to the end of the ArcInner.
-    // Because RcInner is repr(C), it will always be the last field in memory.
+    // Because ArcInner is repr(C), it will always be the last field in memory.
     // SAFETY: since the only unsized types possible are slices, trait objects,
     // and extern types, the input safety requirement is currently enough to
     // satisfy the requirements of align_of_val_raw; this is an implementation

From 5f54d8bfd8e5921dc5eb5bbe0799907ed4ca1916 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Tue, 30 Sep 2025 16:08:48 +0200
Subject: [PATCH 1590/1889] Remove usage of `compiletest-use-stage0-libtest`
 from CI

---
 src/bootstrap/defaults/bootstrap.dist.toml            | 2 --
 src/ci/citool/tests/test-jobs.yml                     | 2 +-
 src/ci/docker/host-x86_64/pr-check-1/Dockerfile       | 1 -
 src/ci/docker/host-x86_64/x86_64-gnu-tools/Dockerfile | 1 -
 4 files changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/bootstrap/defaults/bootstrap.dist.toml b/src/bootstrap/defaults/bootstrap.dist.toml
index b111a20f8d868..bb0592ce947ab 100644
--- a/src/bootstrap/defaults/bootstrap.dist.toml
+++ b/src/bootstrap/defaults/bootstrap.dist.toml
@@ -7,8 +7,6 @@ test-stage = 2
 doc-stage = 2
 # When compiling from source, you usually want all tools.
 extended = true
-# Use libtest built from the source tree instead of the precompiled one from stage 0.
-compiletest-use-stage0-libtest = false
 
 # Most users installing from source want to build all parts of the project from source.
 [llvm]
diff --git a/src/ci/citool/tests/test-jobs.yml b/src/ci/citool/tests/test-jobs.yml
index d82b3e7648e17..512c806285746 100644
--- a/src/ci/citool/tests/test-jobs.yml
+++ b/src/ci/citool/tests/test-jobs.yml
@@ -27,7 +27,7 @@ runners:
     <<: *base-job
 envs:
   env-x86_64-apple-tests: &env-x86_64-apple-tests
-    SCRIPT: ./x.py check compiletest --set build.compiletest-use-stage0-libtest=true && ./x.py --stage 2 test --skip tests/ui --skip tests/rustdoc -- --exact
+    SCRIPT: ./x.py check compiletest && ./x.py --stage 2 test --skip tests/ui --skip tests/rustdoc -- --exact
     RUST_CONFIGURE_ARGS: --build=x86_64-apple-darwin --enable-sanitizers --enable-profiler --set rust.jemalloc
     RUSTC_RETRY_LINKER_ON_SEGFAULT: 1
     # Ensure that host tooling is tested on our minimum supported macOS version.
diff --git a/src/ci/docker/host-x86_64/pr-check-1/Dockerfile b/src/ci/docker/host-x86_64/pr-check-1/Dockerfile
index 04ac0f33daf05..776bbb12e445b 100644
--- a/src/ci/docker/host-x86_64/pr-check-1/Dockerfile
+++ b/src/ci/docker/host-x86_64/pr-check-1/Dockerfile
@@ -43,7 +43,6 @@ ENV SCRIPT \
   python3 ../x.py check bootstrap && \
   /scripts/check-default-config-profiles.sh && \
   python3 ../x.py build src/tools/build-manifest && \
-  python3 ../x.py check compiletest --set build.compiletest-use-stage0-libtest=true && \
   python3 ../x.py check --target=i686-pc-windows-gnu --host=i686-pc-windows-gnu && \
   python3 ../x.py check --set build.optimized-compiler-builtins=false core alloc std --target=aarch64-unknown-linux-gnu,i686-pc-windows-msvc,i686-unknown-linux-gnu,x86_64-apple-darwin,x86_64-pc-windows-gnu,x86_64-pc-windows-msvc && \
   /scripts/validate-toolstate.sh && \
diff --git a/src/ci/docker/host-x86_64/x86_64-gnu-tools/Dockerfile b/src/ci/docker/host-x86_64/x86_64-gnu-tools/Dockerfile
index 95357d229374c..278e40eb71fac 100644
--- a/src/ci/docker/host-x86_64/x86_64-gnu-tools/Dockerfile
+++ b/src/ci/docker/host-x86_64/x86_64-gnu-tools/Dockerfile
@@ -90,5 +90,4 @@ ENV HOST_TARGET x86_64-unknown-linux-gnu
 COPY scripts/shared.sh /scripts/
 
 ENV SCRIPT /tmp/checktools.sh ../x.py && \
-  python3 ../x.py check compiletest --set build.compiletest-use-stage0-libtest=true && \
   python3 ../x.py test tests/rustdoc-gui --stage 2 --test-args "'--jobs 1'"

From aa1263e7684341a73b600eaf0bbc70067e196243 Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Tue, 30 Sep 2025 16:55:21 +0200
Subject: [PATCH 1591/1889] std: add missing unsafe blocks

---
 .../src/sys/net/connection/socket/hermit.rs   |  14 +-
 .../std/src/sys/net/connection/socket/mod.rs  |  88 +++++-----
 .../src/sys/net/connection/socket/solid.rs    |  14 +-
 .../std/src/sys/net/connection/socket/unix.rs | 152 +++++++++---------
 .../src/sys/net/connection/socket/wasip2.rs   |  10 +-
 .../src/sys/net/connection/socket/windows.rs  |  14 +-
 6 files changed, 156 insertions(+), 136 deletions(-)

diff --git a/library/std/src/sys/net/connection/socket/hermit.rs b/library/std/src/sys/net/connection/socket/hermit.rs
index 5200eaa5786ad..0c105ed20fa7e 100644
--- a/library/std/src/sys/net/connection/socket/hermit.rs
+++ b/library/std/src/sys/net/connection/socket/hermit.rs
@@ -242,11 +242,11 @@ impl Socket {
             None => netc::timeval { tv_sec: 0, tv_usec: 0 },
         };
 
-        setsockopt(self, netc::SOL_SOCKET, kind, timeout)
+        unsafe { setsockopt(self, netc::SOL_SOCKET, kind, timeout) }
     }
 
     pub fn timeout(&self, kind: i32) -> io::Result<Option<Duration>> {
-        let raw: netc::timeval = getsockopt(self, netc::SOL_SOCKET, kind)?;
+        let raw: netc::timeval = unsafe { getsockopt(self, netc::SOL_SOCKET, kind)? };
         if raw.tv_sec == 0 && raw.tv_usec == 0 {
             Ok(None)
         } else {
@@ -272,22 +272,22 @@ impl Socket {
             l_linger: linger.unwrap_or_default().as_secs() as libc::c_int,
         };
 
-        setsockopt(self, netc::SOL_SOCKET, netc::SO_LINGER, linger)
+        unsafe { setsockopt(self, netc::SOL_SOCKET, netc::SO_LINGER, linger) }
     }
 
     pub fn linger(&self) -> io::Result<Option<Duration>> {
-        let val: netc::linger = getsockopt(self, netc::SOL_SOCKET, netc::SO_LINGER)?;
+        let val: netc::linger = unsafe { getsockopt(self, netc::SOL_SOCKET, netc::SO_LINGER)? };
 
         Ok((val.l_onoff != 0).then(|| Duration::from_secs(val.l_linger as u64)))
     }
 
     pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> {
         let value: i32 = if nodelay { 1 } else { 0 };
-        setsockopt(self, netc::IPPROTO_TCP, netc::TCP_NODELAY, value)
+        unsafe { setsockopt(self, netc::IPPROTO_TCP, netc::TCP_NODELAY, value) }
     }
 
     pub fn nodelay(&self) -> io::Result<bool> {
-        let raw: i32 = getsockopt(self, netc::IPPROTO_TCP, netc::TCP_NODELAY)?;
+        let raw: i32 = unsafe { getsockopt(self, netc::IPPROTO_TCP, netc::TCP_NODELAY)? };
         Ok(raw != 0)
     }
 
@@ -304,7 +304,7 @@ impl Socket {
     }
 
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
-        let raw: c_int = getsockopt(self, libc::SOL_SOCKET, libc::SO_ERROR)?;
+        let raw: c_int = unsafe { getsockopt(self, libc::SOL_SOCKET, libc::SO_ERROR)? };
         if raw == 0 { Ok(None) } else { Ok(Some(io::Error::from_raw_os_error(raw as i32))) }
     }
 
diff --git a/library/std/src/sys/net/connection/socket/mod.rs b/library/std/src/sys/net/connection/socket/mod.rs
index 8a758947cc2d6..d01a52b861091 100644
--- a/library/std/src/sys/net/connection/socket/mod.rs
+++ b/library/std/src/sys/net/connection/socket/mod.rs
@@ -442,11 +442,11 @@ impl TcpStream {
     }
 
     pub fn peer_addr(&self) -> io::Result<SocketAddr> {
-        sockname(|buf, len| unsafe { c::getpeername(self.inner.as_raw(), buf, len) })
+        unsafe { sockname(|buf, len| c::getpeername(self.inner.as_raw(), buf, len)) }
     }
 
     pub fn socket_addr(&self) -> io::Result<SocketAddr> {
-        sockname(|buf, len| unsafe { c::getsockname(self.inner.as_raw(), buf, len) })
+        unsafe { sockname(|buf, len| c::getsockname(self.inner.as_raw(), buf, len)) }
     }
 
     pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {
@@ -474,11 +474,11 @@ impl TcpStream {
     }
 
     pub fn set_ttl(&self, ttl: u32) -> io::Result<()> {
-        setsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL, ttl as c_int)
+        unsafe { setsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL, ttl as c_int) }
     }
 
     pub fn ttl(&self) -> io::Result<u32> {
-        let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL)?;
+        let raw: c_int = unsafe { getsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL)? };
         Ok(raw as u32)
     }
 
@@ -545,7 +545,9 @@ impl TcpListener {
             // which allows “socket hijacking”, so we explicitly don't set it here.
             // https://docs.microsoft.com/en-us/windows/win32/winsock/using-so-reuseaddr-and-so-exclusiveaddruse
             #[cfg(not(windows))]
-            setsockopt(&sock, c::SOL_SOCKET, c::SO_REUSEADDR, 1 as c_int)?;
+            unsafe {
+                setsockopt(&sock, c::SOL_SOCKET, c::SO_REUSEADDR, 1 as c_int)?
+            };
 
             // Bind our new socket
             let (addr, len) = socket_addr_to_c(addr);
@@ -581,7 +583,7 @@ impl TcpListener {
     }
 
     pub fn socket_addr(&self) -> io::Result<SocketAddr> {
-        sockname(|buf, len| unsafe { c::getsockname(self.inner.as_raw(), buf, len) })
+        unsafe { sockname(|buf, len| c::getsockname(self.inner.as_raw(), buf, len)) }
     }
 
     pub fn accept(&self) -> io::Result<(TcpStream, SocketAddr)> {
@@ -600,20 +602,20 @@ impl TcpListener {
     }
 
     pub fn set_ttl(&self, ttl: u32) -> io::Result<()> {
-        setsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL, ttl as c_int)
+        unsafe { setsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL, ttl as c_int) }
     }
 
     pub fn ttl(&self) -> io::Result<u32> {
-        let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL)?;
+        let raw: c_int = unsafe { getsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL)? };
         Ok(raw as u32)
     }
 
     pub fn set_only_v6(&self, only_v6: bool) -> io::Result<()> {
-        setsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_V6ONLY, only_v6 as c_int)
+        unsafe { setsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_V6ONLY, only_v6 as c_int) }
     }
 
     pub fn only_v6(&self) -> io::Result<bool> {
-        let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_V6ONLY)?;
+        let raw: c_int = unsafe { getsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_V6ONLY)? };
         Ok(raw != 0)
     }
 
@@ -676,11 +678,11 @@ impl UdpSocket {
     }
 
     pub fn peer_addr(&self) -> io::Result<SocketAddr> {
-        sockname(|buf, len| unsafe { c::getpeername(self.inner.as_raw(), buf, len) })
+        unsafe { sockname(|buf, len| c::getpeername(self.inner.as_raw(), buf, len)) }
     }
 
     pub fn socket_addr(&self) -> io::Result<SocketAddr> {
-        sockname(|buf, len| unsafe { c::getsockname(self.inner.as_raw(), buf, len) })
+        unsafe { sockname(|buf, len| c::getsockname(self.inner.as_raw(), buf, len)) }
     }
 
     pub fn recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
@@ -728,48 +730,62 @@ impl UdpSocket {
     }
 
     pub fn set_broadcast(&self, broadcast: bool) -> io::Result<()> {
-        setsockopt(&self.inner, c::SOL_SOCKET, c::SO_BROADCAST, broadcast as c_int)
+        unsafe { setsockopt(&self.inner, c::SOL_SOCKET, c::SO_BROADCAST, broadcast as c_int) }
     }
 
     pub fn broadcast(&self) -> io::Result<bool> {
-        let raw: c_int = getsockopt(&self.inner, c::SOL_SOCKET, c::SO_BROADCAST)?;
+        let raw: c_int = unsafe { getsockopt(&self.inner, c::SOL_SOCKET, c::SO_BROADCAST)? };
         Ok(raw != 0)
     }
 
     pub fn set_multicast_loop_v4(&self, multicast_loop_v4: bool) -> io::Result<()> {
-        setsockopt(
-            &self.inner,
-            c::IPPROTO_IP,
-            c::IP_MULTICAST_LOOP,
-            multicast_loop_v4 as IpV4MultiCastType,
-        )
+        unsafe {
+            setsockopt(
+                &self.inner,
+                c::IPPROTO_IP,
+                c::IP_MULTICAST_LOOP,
+                multicast_loop_v4 as IpV4MultiCastType,
+            )
+        }
     }
 
     pub fn multicast_loop_v4(&self) -> io::Result<bool> {
-        let raw: IpV4MultiCastType = getsockopt(&self.inner, c::IPPROTO_IP, c::IP_MULTICAST_LOOP)?;
+        let raw: IpV4MultiCastType =
+            unsafe { getsockopt(&self.inner, c::IPPROTO_IP, c::IP_MULTICAST_LOOP)? };
         Ok(raw != 0)
     }
 
     pub fn set_multicast_ttl_v4(&self, multicast_ttl_v4: u32) -> io::Result<()> {
-        setsockopt(
-            &self.inner,
-            c::IPPROTO_IP,
-            c::IP_MULTICAST_TTL,
-            multicast_ttl_v4 as IpV4MultiCastType,
-        )
+        unsafe {
+            setsockopt(
+                &self.inner,
+                c::IPPROTO_IP,
+                c::IP_MULTICAST_TTL,
+                multicast_ttl_v4 as IpV4MultiCastType,
+            )
+        }
     }
 
     pub fn multicast_ttl_v4(&self) -> io::Result<u32> {
-        let raw: IpV4MultiCastType = getsockopt(&self.inner, c::IPPROTO_IP, c::IP_MULTICAST_TTL)?;
+        let raw: IpV4MultiCastType =
+            unsafe { getsockopt(&self.inner, c::IPPROTO_IP, c::IP_MULTICAST_TTL)? };
         Ok(raw as u32)
     }
 
     pub fn set_multicast_loop_v6(&self, multicast_loop_v6: bool) -> io::Result<()> {
-        setsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_MULTICAST_LOOP, multicast_loop_v6 as c_int)
+        unsafe {
+            setsockopt(
+                &self.inner,
+                c::IPPROTO_IPV6,
+                c::IPV6_MULTICAST_LOOP,
+                multicast_loop_v6 as c_int,
+            )
+        }
     }
 
     pub fn multicast_loop_v6(&self) -> io::Result<bool> {
-        let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_MULTICAST_LOOP)?;
+        let raw: c_int =
+            unsafe { getsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_MULTICAST_LOOP)? };
         Ok(raw != 0)
     }
 
@@ -778,7 +794,7 @@ impl UdpSocket {
             imr_multiaddr: ip_v4_addr_to_c(multiaddr),
             imr_interface: ip_v4_addr_to_c(interface),
         };
-        setsockopt(&self.inner, c::IPPROTO_IP, c::IP_ADD_MEMBERSHIP, mreq)
+        unsafe { setsockopt(&self.inner, c::IPPROTO_IP, c::IP_ADD_MEMBERSHIP, mreq) }
     }
 
     pub fn join_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> {
@@ -786,7 +802,7 @@ impl UdpSocket {
             ipv6mr_multiaddr: ip_v6_addr_to_c(multiaddr),
             ipv6mr_interface: to_ipv6mr_interface(interface),
         };
-        setsockopt(&self.inner, c::IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, mreq)
+        unsafe { setsockopt(&self.inner, c::IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, mreq) }
     }
 
     pub fn leave_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> io::Result<()> {
@@ -794,7 +810,7 @@ impl UdpSocket {
             imr_multiaddr: ip_v4_addr_to_c(multiaddr),
             imr_interface: ip_v4_addr_to_c(interface),
         };
-        setsockopt(&self.inner, c::IPPROTO_IP, c::IP_DROP_MEMBERSHIP, mreq)
+        unsafe { setsockopt(&self.inner, c::IPPROTO_IP, c::IP_DROP_MEMBERSHIP, mreq) }
     }
 
     pub fn leave_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> io::Result<()> {
@@ -802,15 +818,15 @@ impl UdpSocket {
             ipv6mr_multiaddr: ip_v6_addr_to_c(multiaddr),
             ipv6mr_interface: to_ipv6mr_interface(interface),
         };
-        setsockopt(&self.inner, c::IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP, mreq)
+        unsafe { setsockopt(&self.inner, c::IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP, mreq) }
     }
 
     pub fn set_ttl(&self, ttl: u32) -> io::Result<()> {
-        setsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL, ttl as c_int)
+        unsafe { setsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL, ttl as c_int) }
     }
 
     pub fn ttl(&self) -> io::Result<u32> {
-        let raw: c_int = getsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL)?;
+        let raw: c_int = unsafe { getsockopt(&self.inner, c::IPPROTO_IP, c::IP_TTL)? };
         Ok(raw as u32)
     }
 
diff --git a/library/std/src/sys/net/connection/socket/solid.rs b/library/std/src/sys/net/connection/socket/solid.rs
index 94bb605c1007c..dfde5513f909f 100644
--- a/library/std/src/sys/net/connection/socket/solid.rs
+++ b/library/std/src/sys/net/connection/socket/solid.rs
@@ -303,11 +303,11 @@ impl Socket {
             }
             None => netc::timeval { tv_sec: 0, tv_usec: 0 },
         };
-        setsockopt(self, netc::SOL_SOCKET, kind, timeout)
+        unsafe { setsockopt(self, netc::SOL_SOCKET, kind, timeout) }
     }
 
     pub fn timeout(&self, kind: c_int) -> io::Result<Option<Duration>> {
-        let raw: netc::timeval = getsockopt(self, netc::SOL_SOCKET, kind)?;
+        let raw: netc::timeval = unsafe { getsockopt(self, netc::SOL_SOCKET, kind)? };
         if raw.tv_sec == 0 && raw.tv_usec == 0 {
             Ok(None)
         } else {
@@ -333,21 +333,21 @@ impl Socket {
             l_linger: linger.unwrap_or_default().as_secs() as netc::c_int,
         };
 
-        setsockopt(self, netc::SOL_SOCKET, netc::SO_LINGER, linger)
+        unsafe { setsockopt(self, netc::SOL_SOCKET, netc::SO_LINGER, linger) }
     }
 
     pub fn linger(&self) -> io::Result<Option<Duration>> {
-        let val: netc::linger = getsockopt(self, netc::SOL_SOCKET, netc::SO_LINGER)?;
+        let val: netc::linger = unsafe { getsockopt(self, netc::SOL_SOCKET, netc::SO_LINGER)? };
 
         Ok((val.l_onoff != 0).then(|| Duration::from_secs(val.l_linger as u64)))
     }
 
     pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> {
-        setsockopt(self, netc::IPPROTO_TCP, netc::TCP_NODELAY, nodelay as c_int)
+        unsafe { setsockopt(self, netc::IPPROTO_TCP, netc::TCP_NODELAY, nodelay as c_int) }
     }
 
     pub fn nodelay(&self) -> io::Result<bool> {
-        let raw: c_int = getsockopt(self, netc::IPPROTO_TCP, netc::TCP_NODELAY)?;
+        let raw: c_int = unsafe { getsockopt(self, netc::IPPROTO_TCP, netc::TCP_NODELAY)? };
         Ok(raw != 0)
     }
 
@@ -360,7 +360,7 @@ impl Socket {
     }
 
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
-        let raw: c_int = getsockopt(self, netc::SOL_SOCKET, netc::SO_ERROR)?;
+        let raw: c_int = unsafe { getsockopt(self, netc::SOL_SOCKET, netc::SO_ERROR)? };
         if raw == 0 { Ok(None) } else { Ok(Some(io::Error::from_raw_os_error(raw as i32))) }
     }
 
diff --git a/library/std/src/sys/net/connection/socket/unix.rs b/library/std/src/sys/net/connection/socket/unix.rs
index a191576d93b9d..3f05449903fd1 100644
--- a/library/std/src/sys/net/connection/socket/unix.rs
+++ b/library/std/src/sys/net/connection/socket/unix.rs
@@ -72,47 +72,45 @@ impl Socket {
     }
 
     pub fn new_raw(fam: c_int, ty: c_int) -> io::Result<Socket> {
-        unsafe {
-            cfg_select! {
-                any(
-                    target_os = "android",
-                    target_os = "dragonfly",
-                    target_os = "freebsd",
-                    target_os = "illumos",
-                    target_os = "hurd",
-                    target_os = "linux",
-                    target_os = "netbsd",
-                    target_os = "openbsd",
-                    target_os = "cygwin",
-                    target_os = "nto",
-                    target_os = "solaris",
-                ) => {
-                    // On platforms that support it we pass the SOCK_CLOEXEC
-                    // flag to atomically create the socket and set it as
-                    // CLOEXEC. On Linux this was added in 2.6.27.
-                    let fd = cvt(libc::socket(fam, ty | libc::SOCK_CLOEXEC, 0))?;
-                    let socket = Socket(FileDesc::from_raw_fd(fd));
-
-                    // DragonFlyBSD, FreeBSD and NetBSD use `SO_NOSIGPIPE` as a `setsockopt`
-                    // flag to disable `SIGPIPE` emission on socket.
-                    #[cfg(any(target_os = "freebsd", target_os = "netbsd", target_os = "dragonfly"))]
-                    setsockopt(&socket, libc::SOL_SOCKET, libc::SO_NOSIGPIPE, 1)?;
-
-                    Ok(socket)
-                }
-                _ => {
-                    let fd = cvt(libc::socket(fam, ty, 0))?;
-                    let fd = FileDesc::from_raw_fd(fd);
-                    fd.set_cloexec()?;
-                    let socket = Socket(fd);
+        cfg_select! {
+            any(
+                target_os = "android",
+                target_os = "dragonfly",
+                target_os = "freebsd",
+                target_os = "illumos",
+                target_os = "hurd",
+                target_os = "linux",
+                target_os = "netbsd",
+                target_os = "openbsd",
+                target_os = "cygwin",
+                target_os = "nto",
+                target_os = "solaris",
+            ) => {
+                // On platforms that support it we pass the SOCK_CLOEXEC
+                // flag to atomically create the socket and set it as
+                // CLOEXEC. On Linux this was added in 2.6.27.
+                let fd = cvt(unsafe { libc::socket(fam, ty | libc::SOCK_CLOEXEC, 0) })?;
+                let socket = Socket(unsafe { FileDesc::from_raw_fd(fd) });
+
+                // DragonFlyBSD, FreeBSD and NetBSD use `SO_NOSIGPIPE` as a `setsockopt`
+                // flag to disable `SIGPIPE` emission on socket.
+                #[cfg(any(target_os = "freebsd", target_os = "netbsd", target_os = "dragonfly"))]
+                unsafe { setsockopt(&socket, libc::SOL_SOCKET, libc::SO_NOSIGPIPE, 1)? };
+
+                Ok(socket)
+            }
+            _ => {
+                let fd = cvt(unsafe { libc::socket(fam, ty, 0) })?;
+                let fd = unsafe { FileDesc::from_raw_fd(fd) };
+                fd.set_cloexec()?;
+                let socket = Socket(fd);
 
-                    // macOS and iOS use `SO_NOSIGPIPE` as a `setsockopt`
-                    // flag to disable `SIGPIPE` emission on socket.
-                    #[cfg(target_vendor = "apple")]
-                    setsockopt(&socket, libc::SOL_SOCKET, libc::SO_NOSIGPIPE, 1)?;
+                // macOS and iOS use `SO_NOSIGPIPE` as a `setsockopt`
+                // flag to disable `SIGPIPE` emission on socket.
+                #[cfg(target_vendor = "apple")]
+                unsafe { setsockopt(&socket, libc::SOL_SOCKET, libc::SO_NOSIGPIPE, 1)? };
 
-                    Ok(socket)
-                }
+                Ok(socket)
             }
         }
     }
@@ -413,11 +411,11 @@ impl Socket {
             }
             None => libc::timeval { tv_sec: 0, tv_usec: 0 },
         };
-        setsockopt(self, libc::SOL_SOCKET, kind, timeout)
+        unsafe { setsockopt(self, libc::SOL_SOCKET, kind, timeout) }
     }
 
     pub fn timeout(&self, kind: libc::c_int) -> io::Result<Option<Duration>> {
-        let raw: libc::timeval = getsockopt(self, libc::SOL_SOCKET, kind)?;
+        let raw: libc::timeval = unsafe { getsockopt(self, libc::SOL_SOCKET, kind)? };
         if raw.tv_sec == 0 && raw.tv_usec == 0 {
             Ok(None)
         } else {
@@ -444,7 +442,7 @@ impl Socket {
             l_linger: linger.unwrap_or_default().as_secs() as libc::c_int,
         };
 
-        setsockopt(self, libc::SOL_SOCKET, SO_LINGER, linger)
+        unsafe { setsockopt(self, libc::SOL_SOCKET, SO_LINGER, linger) }
     }
 
     #[cfg(target_os = "cygwin")]
@@ -454,32 +452,32 @@ impl Socket {
             l_linger: linger.unwrap_or_default().as_secs() as libc::c_ushort,
         };
 
-        setsockopt(self, libc::SOL_SOCKET, SO_LINGER, linger)
+        unsafe { setsockopt(self, libc::SOL_SOCKET, SO_LINGER, linger) }
     }
 
     pub fn linger(&self) -> io::Result<Option<Duration>> {
-        let val: libc::linger = getsockopt(self, libc::SOL_SOCKET, SO_LINGER)?;
+        let val: libc::linger = unsafe { getsockopt(self, libc::SOL_SOCKET, SO_LINGER)? };
 
         Ok((val.l_onoff != 0).then(|| Duration::from_secs(val.l_linger as u64)))
     }
 
     pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> {
-        setsockopt(self, libc::IPPROTO_TCP, libc::TCP_NODELAY, nodelay as c_int)
+        unsafe { setsockopt(self, libc::IPPROTO_TCP, libc::TCP_NODELAY, nodelay as c_int) }
     }
 
     pub fn nodelay(&self) -> io::Result<bool> {
-        let raw: c_int = getsockopt(self, libc::IPPROTO_TCP, libc::TCP_NODELAY)?;
+        let raw: c_int = unsafe { getsockopt(self, libc::IPPROTO_TCP, libc::TCP_NODELAY)? };
         Ok(raw != 0)
     }
 
     #[cfg(any(target_os = "android", target_os = "linux", target_os = "cygwin"))]
     pub fn set_quickack(&self, quickack: bool) -> io::Result<()> {
-        setsockopt(self, libc::IPPROTO_TCP, libc::TCP_QUICKACK, quickack as c_int)
+        unsafe { setsockopt(self, libc::IPPROTO_TCP, libc::TCP_QUICKACK, quickack as c_int) }
     }
 
     #[cfg(any(target_os = "android", target_os = "linux", target_os = "cygwin"))]
     pub fn quickack(&self) -> io::Result<bool> {
-        let raw: c_int = getsockopt(self, libc::IPPROTO_TCP, libc::TCP_QUICKACK)?;
+        let raw: c_int = unsafe { getsockopt(self, libc::IPPROTO_TCP, libc::TCP_QUICKACK)? };
         Ok(raw != 0)
     }
 
@@ -487,12 +485,12 @@ impl Socket {
     #[cfg(target_os = "linux")]
     pub fn set_deferaccept(&self, accept: Duration) -> io::Result<()> {
         let val = cmp::min(accept.as_secs(), c_int::MAX as u64) as c_int;
-        setsockopt(self, libc::IPPROTO_TCP, libc::TCP_DEFER_ACCEPT, val)
+        unsafe { setsockopt(self, libc::IPPROTO_TCP, libc::TCP_DEFER_ACCEPT, val) }
     }
 
     #[cfg(target_os = "linux")]
     pub fn deferaccept(&self) -> io::Result<Duration> {
-        let raw: c_int = getsockopt(self, libc::IPPROTO_TCP, libc::TCP_DEFER_ACCEPT)?;
+        let raw: c_int = unsafe { getsockopt(self, libc::IPPROTO_TCP, libc::TCP_DEFER_ACCEPT)? };
         Ok(Duration::from_secs(raw as _))
     }
 
@@ -506,21 +504,23 @@ impl Socket {
             }
             let mut arg: libc::accept_filter_arg = unsafe { mem::zeroed() };
             arg.af_name = buf;
-            setsockopt(self, libc::SOL_SOCKET, libc::SO_ACCEPTFILTER, &mut arg)
+            unsafe { setsockopt(self, libc::SOL_SOCKET, libc::SO_ACCEPTFILTER, &mut arg) }
         } else {
-            setsockopt(
-                self,
-                libc::SOL_SOCKET,
-                libc::SO_ACCEPTFILTER,
-                core::ptr::null_mut() as *mut c_void,
-            )
+            unsafe {
+                setsockopt(
+                    self,
+                    libc::SOL_SOCKET,
+                    libc::SO_ACCEPTFILTER,
+                    core::ptr::null_mut() as *mut c_void,
+                )
+            }
         }
     }
 
     #[cfg(any(target_os = "freebsd", target_os = "netbsd"))]
     pub fn acceptfilter(&self) -> io::Result<&CStr> {
         let arg: libc::accept_filter_arg =
-            getsockopt(self, libc::SOL_SOCKET, libc::SO_ACCEPTFILTER)?;
+            unsafe { getsockopt(self, libc::SOL_SOCKET, libc::SO_ACCEPTFILTER)? };
         let s: &[u8] =
             unsafe { core::slice::from_raw_parts(arg.af_name.as_ptr() as *const u8, 16) };
         let name = CStr::from_bytes_with_nul(s).unwrap();
@@ -531,53 +531,57 @@ impl Socket {
     pub fn set_exclbind(&self, excl: bool) -> io::Result<()> {
         // not yet on libc crate
         const SO_EXCLBIND: i32 = 0x1015;
-        setsockopt(self, libc::SOL_SOCKET, SO_EXCLBIND, excl)
+        unsafe { setsockopt(self, libc::SOL_SOCKET, SO_EXCLBIND, excl) }
     }
 
     #[cfg(any(target_os = "solaris", target_os = "illumos"))]
     pub fn exclbind(&self) -> io::Result<bool> {
         // not yet on libc crate
         const SO_EXCLBIND: i32 = 0x1015;
-        let raw: c_int = getsockopt(self, libc::SOL_SOCKET, SO_EXCLBIND)?;
+        let raw: c_int = unsafe { getsockopt(self, libc::SOL_SOCKET, SO_EXCLBIND)? };
         Ok(raw != 0)
     }
 
     #[cfg(any(target_os = "android", target_os = "linux", target_os = "cygwin"))]
     pub fn set_passcred(&self, passcred: bool) -> io::Result<()> {
-        setsockopt(self, libc::SOL_SOCKET, libc::SO_PASSCRED, passcred as libc::c_int)
+        unsafe { setsockopt(self, libc::SOL_SOCKET, libc::SO_PASSCRED, passcred as libc::c_int) }
     }
 
     #[cfg(any(target_os = "android", target_os = "linux", target_os = "cygwin"))]
     pub fn passcred(&self) -> io::Result<bool> {
-        let passcred: libc::c_int = getsockopt(self, libc::SOL_SOCKET, libc::SO_PASSCRED)?;
+        let passcred: libc::c_int =
+            unsafe { getsockopt(self, libc::SOL_SOCKET, libc::SO_PASSCRED)? };
         Ok(passcred != 0)
     }
 
     #[cfg(target_os = "netbsd")]
     pub fn set_local_creds(&self, local_creds: bool) -> io::Result<()> {
-        setsockopt(self, 0 as libc::c_int, libc::LOCAL_CREDS, local_creds as libc::c_int)
+        unsafe { setsockopt(self, 0 as libc::c_int, libc::LOCAL_CREDS, local_creds as libc::c_int) }
     }
 
     #[cfg(target_os = "netbsd")]
     pub fn local_creds(&self) -> io::Result<bool> {
-        let local_creds: libc::c_int = getsockopt(self, 0 as libc::c_int, libc::LOCAL_CREDS)?;
+        let local_creds: libc::c_int =
+            unsafe { getsockopt(self, 0 as libc::c_int, libc::LOCAL_CREDS)? };
         Ok(local_creds != 0)
     }
 
     #[cfg(target_os = "freebsd")]
     pub fn set_local_creds_persistent(&self, local_creds_persistent: bool) -> io::Result<()> {
-        setsockopt(
-            self,
-            libc::AF_LOCAL,
-            libc::LOCAL_CREDS_PERSISTENT,
-            local_creds_persistent as libc::c_int,
-        )
+        unsafe {
+            setsockopt(
+                self,
+                libc::AF_LOCAL,
+                libc::LOCAL_CREDS_PERSISTENT,
+                local_creds_persistent as libc::c_int,
+            )
+        }
     }
 
     #[cfg(target_os = "freebsd")]
     pub fn local_creds_persistent(&self) -> io::Result<bool> {
         let local_creds_persistent: libc::c_int =
-            getsockopt(self, libc::AF_LOCAL, libc::LOCAL_CREDS_PERSISTENT)?;
+            unsafe { getsockopt(self, libc::AF_LOCAL, libc::LOCAL_CREDS_PERSISTENT)? };
         Ok(local_creds_persistent != 0)
     }
 
@@ -590,7 +594,7 @@ impl Socket {
     #[cfg(target_os = "vita")]
     pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
         let option = nonblocking as libc::c_int;
-        setsockopt(self, libc::SOL_SOCKET, libc::SO_NONBLOCK, option)
+        unsafe { setsockopt(self, libc::SOL_SOCKET, libc::SO_NONBLOCK, option) }
     }
 
     #[cfg(any(target_os = "solaris", target_os = "illumos"))]
@@ -608,11 +612,11 @@ impl Socket {
         let option = libc::SO_USER_COOKIE;
         #[cfg(target_os = "openbsd")]
         let option = libc::SO_RTABLE;
-        setsockopt(self, libc::SOL_SOCKET, option, mark as libc::c_int)
+        unsafe { setsockopt(self, libc::SOL_SOCKET, option, mark as libc::c_int) }
     }
 
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
-        let raw: c_int = getsockopt(self, libc::SOL_SOCKET, libc::SO_ERROR)?;
+        let raw: c_int = unsafe { getsockopt(self, libc::SOL_SOCKET, libc::SO_ERROR)? };
         if raw == 0 { Ok(None) } else { Ok(Some(io::Error::from_raw_os_error(raw as i32))) }
     }
 
diff --git a/library/std/src/sys/net/connection/socket/wasip2.rs b/library/std/src/sys/net/connection/socket/wasip2.rs
index c77c50fece1a9..fbd89f3c8b054 100644
--- a/library/std/src/sys/net/connection/socket/wasip2.rs
+++ b/library/std/src/sys/net/connection/socket/wasip2.rs
@@ -270,11 +270,11 @@ impl Socket {
             }
             None => netc::timeval { tv_sec: 0, tv_usec: 0 },
         };
-        setsockopt(self, netc::SOL_SOCKET, kind, timeout)
+        unsafe { setsockopt(self, netc::SOL_SOCKET, kind, timeout) }
     }
 
     pub fn timeout(&self, kind: c_int) -> io::Result<Option<Duration>> {
-        let raw: netc::timeval = getsockopt(self, netc::SOL_SOCKET, kind)?;
+        let raw: netc::timeval = unsafe { getsockopt(self, netc::SOL_SOCKET, kind)? };
         if raw.tv_sec == 0 && raw.tv_usec == 0 {
             Ok(None)
         } else {
@@ -303,11 +303,11 @@ impl Socket {
     }
 
     pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> {
-        setsockopt(self, netc::IPPROTO_TCP, netc::TCP_NODELAY, nodelay as c_int)
+        unsafe { setsockopt(self, netc::IPPROTO_TCP, netc::TCP_NODELAY, nodelay as c_int) }
     }
 
     pub fn nodelay(&self) -> io::Result<bool> {
-        let raw: c_int = getsockopt(self, netc::IPPROTO_TCP, netc::TCP_NODELAY)?;
+        let raw: c_int = unsafe { getsockopt(self, netc::IPPROTO_TCP, netc::TCP_NODELAY)? };
         Ok(raw != 0)
     }
 
@@ -317,7 +317,7 @@ impl Socket {
     }
 
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
-        let raw: c_int = getsockopt(self, netc::SOL_SOCKET, netc::SO_ERROR)?;
+        let raw: c_int = unsafe { getsockopt(self, netc::SOL_SOCKET, netc::SO_ERROR)? };
         if raw == 0 { Ok(None) } else { Ok(Some(io::Error::from_raw_os_error(raw as i32))) }
     }
 
diff --git a/library/std/src/sys/net/connection/socket/windows.rs b/library/std/src/sys/net/connection/socket/windows.rs
index 2221023a21252..2fdebe6c90d84 100644
--- a/library/std/src/sys/net/connection/socket/windows.rs
+++ b/library/std/src/sys/net/connection/socket/windows.rs
@@ -384,11 +384,11 @@ impl Socket {
             }
             None => 0,
         };
-        setsockopt(self, c::SOL_SOCKET, kind, timeout)
+        unsafe { setsockopt(self, c::SOL_SOCKET, kind, timeout) }
     }
 
     pub fn timeout(&self, kind: c_int) -> io::Result<Option<Duration>> {
-        let raw: u32 = getsockopt(self, c::SOL_SOCKET, kind)?;
+        let raw: u32 = unsafe { getsockopt(self, c::SOL_SOCKET, kind)? };
         if raw == 0 {
             Ok(None)
         } else {
@@ -421,26 +421,26 @@ impl Socket {
             l_linger: linger.unwrap_or_default().as_secs() as c_ushort,
         };
 
-        setsockopt(self, c::SOL_SOCKET, c::SO_LINGER, linger)
+        unsafe { setsockopt(self, c::SOL_SOCKET, c::SO_LINGER, linger) }
     }
 
     pub fn linger(&self) -> io::Result<Option<Duration>> {
-        let val: c::LINGER = getsockopt(self, c::SOL_SOCKET, c::SO_LINGER)?;
+        let val: c::LINGER = unsafe { getsockopt(self, c::SOL_SOCKET, c::SO_LINGER)? };
 
         Ok((val.l_onoff != 0).then(|| Duration::from_secs(val.l_linger as u64)))
     }
 
     pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> {
-        setsockopt(self, c::IPPROTO_TCP, c::TCP_NODELAY, nodelay as c::BOOL)
+        unsafe { setsockopt(self, c::IPPROTO_TCP, c::TCP_NODELAY, nodelay as c::BOOL) }
     }
 
     pub fn nodelay(&self) -> io::Result<bool> {
-        let raw: c::BOOL = getsockopt(self, c::IPPROTO_TCP, c::TCP_NODELAY)?;
+        let raw: c::BOOL = unsafe { getsockopt(self, c::IPPROTO_TCP, c::TCP_NODELAY)? };
         Ok(raw != 0)
     }
 
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
-        let raw: c_int = getsockopt(self, c::SOL_SOCKET, c::SO_ERROR)?;
+        let raw: c_int = unsafe { getsockopt(self, c::SOL_SOCKET, c::SO_ERROR)? };
         if raw == 0 { Ok(None) } else { Ok(Some(io::Error::from_raw_os_error(raw as i32))) }
     }
 

From 1da0092218e4b7bbc25034c3e5b98cb85a01a619 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Tue, 30 Sep 2025 13:05:45 +0200
Subject: [PATCH 1592/1889] `redundant_pattern_match`: clean-up

- cast `&[Arm]` to `&[Arm; 2]` early on to hopefully avoid bounds checks
- use `if let [pattern] = X { .. }` instead of
  `if let patterns = X { let pattern = patterns[0]; .. }`
- use `Symbol`s instead of `&str`s
- reduce indentation
---
 .../src/matches/redundant_pattern_match.rs    | 147 ++++++++----------
 1 file changed, 67 insertions(+), 80 deletions(-)

diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index c936c96f9719a..9d0115791838c 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -269,66 +269,61 @@ fn find_method_sugg_for_if_let<'tcx>(
 }
 
 pub(super) fn check_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, op: &Expr<'_>, arms: &[Arm<'_>]) {
-    if arms.len() == 2 {
-        let node_pair = (&arms[0].pat.kind, &arms[1].pat.kind);
-
-        if let Some((good_method, maybe_guard)) = found_good_method(cx, arms, node_pair) {
-            let span = is_expn_of(expr.span, sym::matches).unwrap_or(expr.span.to(op.span));
-            let result_expr = match &op.kind {
-                ExprKind::AddrOf(_, _, borrowed) => borrowed,
-                _ => op,
-            };
-            let mut app = Applicability::MachineApplicable;
-            let receiver_sugg = Sugg::hir_with_applicability(cx, result_expr, "_", &mut app).maybe_paren();
-            let mut sugg = format!("{receiver_sugg}.{good_method}");
-
-            if let Some(guard) = maybe_guard {
-                // wow, the HIR for match guards in `PAT if let PAT = expr && expr => ...` is annoying!
-                // `guard` here is `Guard::If` with the let expression somewhere deep in the tree of exprs,
-                // counter to the intuition that it should be `Guard::IfLet`, so we need another check
-                // to see that there aren't any let chains anywhere in the guard, as that would break
-                // if we suggest `t.is_none() && (let X = y && z)` for:
-                // `match t { None if let X = y && z => true, _ => false }`
-                let has_nested_let_chain = for_each_expr_without_closures(guard, |expr| {
-                    if matches!(expr.kind, ExprKind::Let(..)) {
-                        ControlFlow::Break(())
-                    } else {
-                        ControlFlow::Continue(())
-                    }
-                })
-                .is_some();
-
-                if has_nested_let_chain {
-                    return;
+    if let Ok(arms) = arms.try_into() // TODO: use `slice::as_array` once stabilized
+        && let Some((good_method, maybe_guard)) = found_good_method(cx, arms)
+    {
+        let span = is_expn_of(expr.span, sym::matches).unwrap_or(expr.span.to(op.span));
+        let result_expr = match &op.kind {
+            ExprKind::AddrOf(_, _, borrowed) => borrowed,
+            _ => op,
+        };
+        let mut app = Applicability::MachineApplicable;
+        let receiver_sugg = Sugg::hir_with_applicability(cx, result_expr, "_", &mut app).maybe_paren();
+        let mut sugg = format!("{receiver_sugg}.{good_method}");
+
+        if let Some(guard) = maybe_guard {
+            // wow, the HIR for match guards in `PAT if let PAT = expr && expr => ...` is annoying!
+            // `guard` here is `Guard::If` with the let expression somewhere deep in the tree of exprs,
+            // counter to the intuition that it should be `Guard::IfLet`, so we need another check
+            // to see that there aren't any let chains anywhere in the guard, as that would break
+            // if we suggest `t.is_none() && (let X = y && z)` for:
+            // `match t { None if let X = y && z => true, _ => false }`
+            let has_nested_let_chain = for_each_expr_without_closures(guard, |expr| {
+                if matches!(expr.kind, ExprKind::Let(..)) {
+                    ControlFlow::Break(())
+                } else {
+                    ControlFlow::Continue(())
                 }
+            })
+            .is_some();
 
-                let guard = Sugg::hir(cx, guard, "..");
-                let _ = write!(sugg, " && {}", guard.maybe_paren());
+            if has_nested_let_chain {
+                return;
             }
 
-            span_lint_and_sugg(
-                cx,
-                REDUNDANT_PATTERN_MATCHING,
-                span,
-                format!("redundant pattern matching, consider using `{good_method}`"),
-                "try",
-                sugg,
-                app,
-            );
+            let guard = Sugg::hir(cx, guard, "..");
+            let _ = write!(sugg, " && {}", guard.maybe_paren());
         }
+
+        span_lint_and_sugg(
+            cx,
+            REDUNDANT_PATTERN_MATCHING,
+            span,
+            format!("redundant pattern matching, consider using `{good_method}`"),
+            "try",
+            sugg,
+            app,
+        );
     }
 }
 
 fn found_good_method<'tcx>(
     cx: &LateContext<'_>,
-    arms: &'tcx [Arm<'tcx>],
-    node: (&PatKind<'_>, &PatKind<'_>),
+    arms: &'tcx [Arm<'tcx>; 2],
 ) -> Option<(&'static str, Option<&'tcx Expr<'tcx>>)> {
-    match node {
-        (PatKind::TupleStruct(path_left, patterns_left, _), PatKind::TupleStruct(path_right, patterns_right, _))
-            if patterns_left.len() == 1 && patterns_right.len() == 1 =>
-        {
-            if let (PatKind::Wild, PatKind::Wild) = (&patterns_left[0].kind, &patterns_right[0].kind) {
+    match (&arms[0].pat.kind, &arms[1].pat.kind) {
+        (PatKind::TupleStruct(path_left, [pattern_left], _), PatKind::TupleStruct(path_right, [pattern_right], _)) => {
+            if let (PatKind::Wild, PatKind::Wild) = (&pattern_left.kind, &pattern_right.kind) {
                 find_good_method_for_match(
                     cx,
                     arms,
@@ -356,7 +351,7 @@ fn found_good_method<'tcx>(
             }
         },
         (
-            PatKind::TupleStruct(path_left, patterns, _),
+            PatKind::TupleStruct(path_left, [pattern], _),
             PatKind::Expr(PatExpr {
                 kind: PatExprKind::Path(path_right),
                 ..
@@ -367,9 +362,9 @@ fn found_good_method<'tcx>(
                 kind: PatExprKind::Path(path_left),
                 ..
             }),
-            PatKind::TupleStruct(path_right, patterns, _),
-        ) if patterns.len() == 1 => {
-            if let PatKind::Wild = patterns[0].kind {
+            PatKind::TupleStruct(path_right, [pattern], _),
+        ) => {
+            if let PatKind::Wild = pattern.kind {
                 find_good_method_for_match(
                     cx,
                     arms,
@@ -396,8 +391,8 @@ fn found_good_method<'tcx>(
                 None
             }
         },
-        (PatKind::TupleStruct(path_left, patterns, _), PatKind::Wild) if patterns.len() == 1 => {
-            if let PatKind::Wild = patterns[0].kind {
+        (PatKind::TupleStruct(path_left, [pattern], _), PatKind::Wild) => {
+            if let PatKind::Wild = pattern.kind {
                 get_good_method(cx, arms, path_left)
             } else {
                 None
@@ -426,31 +421,23 @@ fn get_ident(path: &QPath<'_>) -> Option<rustc_span::symbol::Ident> {
 
 fn get_good_method<'tcx>(
     cx: &LateContext<'_>,
-    arms: &'tcx [Arm<'tcx>],
+    arms: &'tcx [Arm<'tcx>; 2],
     path_left: &QPath<'_>,
 ) -> Option<(&'static str, Option<&'tcx Expr<'tcx>>)> {
-    if let Some(name) = get_ident(path_left) {
-        let (expected_item_left, should_be_left, should_be_right) = match name.as_str() {
-            "Ok" => (Item::Lang(ResultOk), "is_ok()", "is_err()"),
-            "Err" => (Item::Lang(ResultErr), "is_err()", "is_ok()"),
-            "Some" => (Item::Lang(OptionSome), "is_some()", "is_none()"),
-            "None" => (Item::Lang(OptionNone), "is_none()", "is_some()"),
-            "Ready" => (Item::Lang(PollReady), "is_ready()", "is_pending()"),
-            "Pending" => (Item::Lang(PollPending), "is_pending()", "is_ready()"),
-            "V4" => (Item::Diag(sym::IpAddr, sym::V4), "is_ipv4()", "is_ipv6()"),
-            "V6" => (Item::Diag(sym::IpAddr, sym::V6), "is_ipv6()", "is_ipv4()"),
-            _ => return None,
-        };
-        return find_good_method_for_matches_macro(
-            cx,
-            arms,
-            path_left,
-            expected_item_left,
-            should_be_left,
-            should_be_right,
-        );
-    }
-    None
+    let ident = get_ident(path_left)?;
+
+    let (expected_item_left, should_be_left, should_be_right) = match ident.name {
+        sym::Ok => (Item::Lang(ResultOk), "is_ok()", "is_err()"),
+        sym::Err => (Item::Lang(ResultErr), "is_err()", "is_ok()"),
+        sym::Some => (Item::Lang(OptionSome), "is_some()", "is_none()"),
+        sym::None => (Item::Lang(OptionNone), "is_none()", "is_some()"),
+        sym::Ready => (Item::Lang(PollReady), "is_ready()", "is_pending()"),
+        sym::Pending => (Item::Lang(PollPending), "is_pending()", "is_ready()"),
+        sym::V4 => (Item::Diag(sym::IpAddr, sym::V4), "is_ipv4()", "is_ipv6()"),
+        sym::V6 => (Item::Diag(sym::IpAddr, sym::V6), "is_ipv6()", "is_ipv4()"),
+        _ => return None,
+    };
+    find_good_method_for_matches_macro(cx, arms, path_left, expected_item_left, should_be_left, should_be_right)
 }
 
 #[derive(Clone, Copy)]
@@ -490,7 +477,7 @@ fn is_pat_variant(cx: &LateContext<'_>, pat: &Pat<'_>, path: &QPath<'_>, expecte
 #[expect(clippy::too_many_arguments)]
 fn find_good_method_for_match<'a, 'tcx>(
     cx: &LateContext<'_>,
-    arms: &'tcx [Arm<'tcx>],
+    arms: &'tcx [Arm<'tcx>; 2],
     path_left: &QPath<'_>,
     path_right: &QPath<'_>,
     expected_item_left: Item,
@@ -525,7 +512,7 @@ fn find_good_method_for_match<'a, 'tcx>(
 
 fn find_good_method_for_matches_macro<'a, 'tcx>(
     cx: &LateContext<'_>,
-    arms: &'tcx [Arm<'tcx>],
+    arms: &'tcx [Arm<'tcx>; 2],
     path_left: &QPath<'_>,
     expected_item_left: Item,
     should_be_left: &'a str,

From bf6f75f98ebb5304800d45e58d08ed8a5cc7c584 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Tue, 30 Sep 2025 18:07:27 +0300
Subject: [PATCH 1593/1889] Add regression test for another (long-standing) bug
 fixed by the new solver

---
 .../hir-ty/src/tests/regression/new_solver.rs | 24 ++++++++++++++++++-
 1 file changed, 23 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
index c7711f31bf262..adc35cc9bc1cf 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests/regression/new_solver.rs
@@ -1,6 +1,6 @@
 use expect_test::expect;
 
-use crate::tests::{check_infer, check_no_mismatches};
+use crate::tests::{check_infer, check_no_mismatches, check_types};
 
 #[test]
 fn regression_20365() {
@@ -450,3 +450,25 @@ fn main() {
     "#,
     );
 }
+
+#[test]
+fn double_into_iter() {
+    check_types(
+        r#"
+//- minicore: iterator
+
+fn intoiter_issue<A, B>(foo: A)
+where
+    A: IntoIterator<Item = B>,
+    B: IntoIterator<Item = usize>,
+{
+    for x in foo {
+    //  ^ B
+        for m in x {
+        //  ^ usize
+        }
+    }
+}
+"#,
+    );
+}

From 3534594029ed1495290e013647a1f53da561f7f1 Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Tue, 30 Sep 2025 17:10:22 +0200
Subject: [PATCH 1594/1889] std: merge address family computation

---
 library/std/src/os/unix/net/datagram.rs          |  2 +-
 library/std/src/os/unix/net/listener.rs          |  4 ++--
 library/std/src/os/unix/net/stream.rs            |  4 ++--
 .../std/src/sys/net/connection/socket/hermit.rs  | 10 +---------
 library/std/src/sys/net/connection/socket/mod.rs | 15 +++++++++++----
 .../std/src/sys/net/connection/socket/solid.rs   | 16 +++-------------
 .../std/src/sys/net/connection/socket/unix.rs    | 14 +++-----------
 .../std/src/sys/net/connection/socket/wasip2.rs  | 12 ++----------
 .../std/src/sys/net/connection/socket/windows.rs |  6 +-----
 9 files changed, 26 insertions(+), 57 deletions(-)

diff --git a/library/std/src/os/unix/net/datagram.rs b/library/std/src/os/unix/net/datagram.rs
index 469bfbb0d837f..163267be1e5c1 100644
--- a/library/std/src/os/unix/net/datagram.rs
+++ b/library/std/src/os/unix/net/datagram.rs
@@ -159,7 +159,7 @@ impl UnixDatagram {
     /// ```
     #[stable(feature = "unix_socket", since = "1.10.0")]
     pub fn unbound() -> io::Result<UnixDatagram> {
-        let inner = Socket::new_raw(libc::AF_UNIX, libc::SOCK_DGRAM)?;
+        let inner = Socket::new(libc::AF_UNIX, libc::SOCK_DGRAM)?;
         Ok(UnixDatagram(inner))
     }
 
diff --git a/library/std/src/os/unix/net/listener.rs b/library/std/src/os/unix/net/listener.rs
index 27428c9eb2855..5b4659e261883 100644
--- a/library/std/src/os/unix/net/listener.rs
+++ b/library/std/src/os/unix/net/listener.rs
@@ -71,7 +71,7 @@ impl UnixListener {
     #[stable(feature = "unix_socket", since = "1.10.0")]
     pub fn bind<P: AsRef<Path>>(path: P) -> io::Result<UnixListener> {
         unsafe {
-            let inner = Socket::new_raw(libc::AF_UNIX, libc::SOCK_STREAM)?;
+            let inner = Socket::new(libc::AF_UNIX, libc::SOCK_STREAM)?;
             let (addr, len) = sockaddr_un(path.as_ref())?;
             #[cfg(any(
                 target_os = "windows",
@@ -136,7 +136,7 @@ impl UnixListener {
     #[stable(feature = "unix_socket_abstract", since = "1.70.0")]
     pub fn bind_addr(socket_addr: &SocketAddr) -> io::Result<UnixListener> {
         unsafe {
-            let inner = Socket::new_raw(libc::AF_UNIX, libc::SOCK_STREAM)?;
+            let inner = Socket::new(libc::AF_UNIX, libc::SOCK_STREAM)?;
             #[cfg(target_os = "linux")]
             const backlog: core::ffi::c_int = -1;
             #[cfg(not(target_os = "linux"))]
diff --git a/library/std/src/os/unix/net/stream.rs b/library/std/src/os/unix/net/stream.rs
index ea4171a7d2877..851ff7f08795b 100644
--- a/library/std/src/os/unix/net/stream.rs
+++ b/library/std/src/os/unix/net/stream.rs
@@ -105,7 +105,7 @@ impl UnixStream {
     #[stable(feature = "unix_socket", since = "1.10.0")]
     pub fn connect<P: AsRef<Path>>(path: P) -> io::Result<UnixStream> {
         unsafe {
-            let inner = Socket::new_raw(libc::AF_UNIX, libc::SOCK_STREAM)?;
+            let inner = Socket::new(libc::AF_UNIX, libc::SOCK_STREAM)?;
             let (addr, len) = sockaddr_un(path.as_ref())?;
 
             cvt(libc::connect(inner.as_raw_fd(), (&raw const addr) as *const _, len))?;
@@ -139,7 +139,7 @@ impl UnixStream {
     #[stable(feature = "unix_socket_abstract", since = "1.70.0")]
     pub fn connect_addr(socket_addr: &SocketAddr) -> io::Result<UnixStream> {
         unsafe {
-            let inner = Socket::new_raw(libc::AF_UNIX, libc::SOCK_STREAM)?;
+            let inner = Socket::new(libc::AF_UNIX, libc::SOCK_STREAM)?;
             cvt(libc::connect(
                 inner.as_raw_fd(),
                 (&raw const socket_addr.addr) as *const _,
diff --git a/library/std/src/sys/net/connection/socket/hermit.rs b/library/std/src/sys/net/connection/socket/hermit.rs
index 0c105ed20fa7e..2f5c6fa31d407 100644
--- a/library/std/src/sys/net/connection/socket/hermit.rs
+++ b/library/std/src/sys/net/connection/socket/hermit.rs
@@ -37,15 +37,7 @@ pub fn init() {}
 pub struct Socket(FileDesc);
 
 impl Socket {
-    pub fn new(addr: &SocketAddr, ty: i32) -> io::Result<Socket> {
-        let fam = match *addr {
-            SocketAddr::V4(..) => netc::AF_INET,
-            SocketAddr::V6(..) => netc::AF_INET6,
-        };
-        Socket::new_raw(fam, ty)
-    }
-
-    pub fn new_raw(fam: i32, ty: i32) -> io::Result<Socket> {
+    pub fn new(fam: i32, ty: i32) -> io::Result<Socket> {
         let fd = cvt(unsafe { netc::socket(fam, ty, 0) })?;
         Ok(Socket(unsafe { FileDesc::from_raw_fd(fd) }))
     }
diff --git a/library/std/src/sys/net/connection/socket/mod.rs b/library/std/src/sys/net/connection/socket/mod.rs
index d01a52b861091..d0a4a2fab497d 100644
--- a/library/std/src/sys/net/connection/socket/mod.rs
+++ b/library/std/src/sys/net/connection/socket/mod.rs
@@ -178,6 +178,13 @@ fn socket_addr_to_c(addr: &SocketAddr) -> (SocketAddrCRepr, c::socklen_t) {
     }
 }
 
+fn addr_family(addr: &SocketAddr) -> c_int {
+    match addr {
+        SocketAddr::V4(..) => c::AF_INET,
+        SocketAddr::V6(..) => c::AF_INET6,
+    }
+}
+
 /// Converts the C socket address stored in `storage` to a Rust `SocketAddr`.
 ///
 /// # Safety
@@ -364,7 +371,7 @@ impl TcpStream {
         return each_addr(addr, inner);
 
         fn inner(addr: &SocketAddr) -> io::Result<TcpStream> {
-            let sock = Socket::new(addr, c::SOCK_STREAM)?;
+            let sock = Socket::new(addr_family(addr), c::SOCK_STREAM)?;
             sock.connect(addr)?;
             Ok(TcpStream { inner: sock })
         }
@@ -373,7 +380,7 @@ impl TcpStream {
     pub fn connect_timeout(addr: &SocketAddr, timeout: Duration) -> io::Result<TcpStream> {
         init();
 
-        let sock = Socket::new(addr, c::SOCK_STREAM)?;
+        let sock = Socket::new(addr_family(addr), c::SOCK_STREAM)?;
         sock.connect_timeout(addr, timeout)?;
         Ok(TcpStream { inner: sock })
     }
@@ -535,7 +542,7 @@ impl TcpListener {
         return each_addr(addr, inner);
 
         fn inner(addr: &SocketAddr) -> io::Result<TcpListener> {
-            let sock = Socket::new(addr, c::SOCK_STREAM)?;
+            let sock = Socket::new(addr_family(addr), c::SOCK_STREAM)?;
 
             // On platforms with Berkeley-derived sockets, this allows to quickly
             // rebind a socket, without needing to wait for the OS to clean up the
@@ -661,7 +668,7 @@ impl UdpSocket {
         return each_addr(addr, inner);
 
         fn inner(addr: &SocketAddr) -> io::Result<UdpSocket> {
-            let sock = Socket::new(addr, c::SOCK_DGRAM)?;
+            let sock = Socket::new(addr_family(addr), c::SOCK_DGRAM)?;
             let (addr, len) = socket_addr_to_c(addr);
             cvt(unsafe { c::bind(sock.as_raw(), addr.as_ptr(), len as _) })?;
             Ok(UdpSocket { inner: sock })
diff --git a/library/std/src/sys/net/connection/socket/solid.rs b/library/std/src/sys/net/connection/socket/solid.rs
index dfde5513f909f..14cf75adcc06f 100644
--- a/library/std/src/sys/net/connection/socket/solid.rs
+++ b/library/std/src/sys/net/connection/socket/solid.rs
@@ -115,19 +115,9 @@ pub fn init() {}
 pub struct Socket(OwnedFd);
 
 impl Socket {
-    pub fn new(addr: &SocketAddr, ty: c_int) -> io::Result<Socket> {
-        let fam = match *addr {
-            SocketAddr::V4(..) => netc::AF_INET,
-            SocketAddr::V6(..) => netc::AF_INET6,
-        };
-        Socket::new_raw(fam, ty)
-    }
-
-    pub fn new_raw(fam: c_int, ty: c_int) -> io::Result<Socket> {
-        unsafe {
-            let fd = cvt(netc::socket(fam, ty, 0))?;
-            Ok(Self::from_raw_fd(fd))
-        }
+    pub fn new(fam: c_int, ty: c_int) -> io::Result<Socket> {
+        let fd = cvt(unsafe { netc::socket(fam, ty, 0) })?;
+        Ok(unsafe { Self::from_raw_fd(fd) })
     }
 
     pub fn connect(&self, addr: &SocketAddr) -> io::Result<()> {
diff --git a/library/std/src/sys/net/connection/socket/unix.rs b/library/std/src/sys/net/connection/socket/unix.rs
index 3f05449903fd1..559e27604a9d3 100644
--- a/library/std/src/sys/net/connection/socket/unix.rs
+++ b/library/std/src/sys/net/connection/socket/unix.rs
@@ -63,15 +63,7 @@ pub fn cvt_gai(err: c_int) -> io::Result<()> {
 }
 
 impl Socket {
-    pub fn new(addr: &SocketAddr, ty: c_int) -> io::Result<Socket> {
-        let fam = match *addr {
-            SocketAddr::V4(..) => libc::AF_INET,
-            SocketAddr::V6(..) => libc::AF_INET6,
-        };
-        Socket::new_raw(fam, ty)
-    }
-
-    pub fn new_raw(fam: c_int, ty: c_int) -> io::Result<Socket> {
+    pub fn new(family: c_int, ty: c_int) -> io::Result<Socket> {
         cfg_select! {
             any(
                 target_os = "android",
@@ -89,7 +81,7 @@ impl Socket {
                 // On platforms that support it we pass the SOCK_CLOEXEC
                 // flag to atomically create the socket and set it as
                 // CLOEXEC. On Linux this was added in 2.6.27.
-                let fd = cvt(unsafe { libc::socket(fam, ty | libc::SOCK_CLOEXEC, 0) })?;
+                let fd = cvt(unsafe { libc::socket(family, ty | libc::SOCK_CLOEXEC, 0) })?;
                 let socket = Socket(unsafe { FileDesc::from_raw_fd(fd) });
 
                 // DragonFlyBSD, FreeBSD and NetBSD use `SO_NOSIGPIPE` as a `setsockopt`
@@ -100,7 +92,7 @@ impl Socket {
                 Ok(socket)
             }
             _ => {
-                let fd = cvt(unsafe { libc::socket(fam, ty, 0) })?;
+                let fd = cvt(unsafe { libc::socket(family, ty, 0) })?;
                 let fd = unsafe { FileDesc::from_raw_fd(fd) };
                 fd.set_cloexec()?;
                 let socket = Socket(fd);
diff --git a/library/std/src/sys/net/connection/socket/wasip2.rs b/library/std/src/sys/net/connection/socket/wasip2.rs
index fbd89f3c8b054..a1b08609eb024 100644
--- a/library/std/src/sys/net/connection/socket/wasip2.rs
+++ b/library/std/src/sys/net/connection/socket/wasip2.rs
@@ -74,16 +74,8 @@ pub struct WasiSocket(OwnedFd);
 pub struct Socket(WasiSocket);
 
 impl Socket {
-    pub fn new(addr: &SocketAddr, ty: c_int) -> io::Result<Socket> {
-        let fam = match *addr {
-            SocketAddr::V4(..) => netc::AF_INET,
-            SocketAddr::V6(..) => netc::AF_INET6,
-        };
-        Socket::new_raw(fam, ty)
-    }
-
-    pub fn new_raw(fam: c_int, ty: c_int) -> io::Result<Socket> {
-        let fd = cvt(unsafe { netc::socket(fam, ty, 0) })?;
+    pub fn new(family: c_int, ty: c_int) -> io::Result<Socket> {
+        let fd = cvt(unsafe { netc::socket(family, ty, 0) })?;
         Ok(unsafe { Self::from_raw_fd(fd) })
     }
 
diff --git a/library/std/src/sys/net/connection/socket/windows.rs b/library/std/src/sys/net/connection/socket/windows.rs
index 2fdebe6c90d84..6dbebc5e276ec 100644
--- a/library/std/src/sys/net/connection/socket/windows.rs
+++ b/library/std/src/sys/net/connection/socket/windows.rs
@@ -117,11 +117,7 @@ pub use crate::sys::pal::winsock::{cvt, cvt_gai, cvt_r, startup as init};
 pub struct Socket(OwnedSocket);
 
 impl Socket {
-    pub fn new(addr: &SocketAddr, ty: c_int) -> io::Result<Socket> {
-        let family = match *addr {
-            SocketAddr::V4(..) => netc::AF_INET,
-            SocketAddr::V6(..) => netc::AF_INET6,
-        };
+    pub fn new(family: c_int, ty: c_int) -> io::Result<Socket> {
         let socket = unsafe {
             c::WSASocketW(
                 family,

From ba13b6ec6f919430412d99a3d50ff87042a787a7 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Mon, 29 Sep 2025 21:02:52 -0700
Subject: [PATCH 1595/1889] bootstrap: build bootstrap docs with in-tree
 rustdoc

All of the docs need to be built with the same rustdoc. Otherwise,
any change to the search index breaks everything, because the two
rustdocs don't agree on the format.
---
 src/bootstrap/src/core/build_steps/doc.rs | 21 +++++++++++----------
 src/bootstrap/src/core/builder/tests.rs   | 18 ++++++++++--------
 2 files changed, 21 insertions(+), 18 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/doc.rs b/src/bootstrap/src/core/build_steps/doc.rs
index 7865b68565930..37462c63f1b09 100644
--- a/src/bootstrap/src/core/build_steps/doc.rs
+++ b/src/bootstrap/src/core/build_steps/doc.rs
@@ -1024,12 +1024,9 @@ macro_rules! tool_doc {
                         run.builder.ensure(Rustc::from_build_compiler(run.builder, compilers.build_compiler(), target));
                         compilers.build_compiler()
                     }
-                    Mode::ToolBootstrap => {
-                        // bootstrap/host tools should be documented with the stage 0 compiler
-                        prepare_doc_compiler(run.builder, run.builder.host_target, 1)
-                    }
                     Mode::ToolTarget => {
-                        // target tools should be documented with the in-tree compiler
+                        // when shipping multiple docs together in one folder,
+                        // they all need to use the same rustdoc version
                         prepare_doc_compiler(run.builder, run.builder.host_target, run.builder.top_stage)
                     }
                     _ => {
@@ -1132,7 +1129,11 @@ macro_rules! tool_doc {
 tool_doc!(
     BuildHelper,
     "src/build_helper",
-    mode = Mode::ToolBootstrap,
+    // ideally, this would use ToolBootstrap,
+    // but we distribute these docs together in the same folder
+    // as a bunch of stage1 tools, and you can't mix rustdoc versions
+    // because that breaks cross-crate data (particularly search)
+    mode = Mode::ToolTarget,
     is_library = true,
     crates = ["build_helper"]
 );
@@ -1175,25 +1176,25 @@ tool_doc!(
     // "specialization" feature in its build script when it detects a nightly toolchain.
     allow_features: "specialization"
 );
-tool_doc!(Tidy, "src/tools/tidy", mode = Mode::ToolBootstrap, crates = ["tidy"]);
+tool_doc!(Tidy, "src/tools/tidy", mode = Mode::ToolTarget, crates = ["tidy"]);
 tool_doc!(
     Bootstrap,
     "src/bootstrap",
-    mode = Mode::ToolBootstrap,
+    mode = Mode::ToolTarget,
     is_library = true,
     crates = ["bootstrap"]
 );
 tool_doc!(
     RunMakeSupport,
     "src/tools/run-make-support",
-    mode = Mode::ToolBootstrap,
+    mode = Mode::ToolTarget,
     is_library = true,
     crates = ["run_make_support"]
 );
 tool_doc!(
     Compiletest,
     "src/tools/compiletest",
-    mode = Mode::ToolBootstrap,
+    mode = Mode::ToolTarget,
     is_library = true,
     crates = ["compiletest"]
 );
diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index 88df469e9a099..3306435758b45 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -1158,13 +1158,12 @@ mod snapshot {
         [doc] embedded-book (book) <host>
         [doc] edition-guide (book) <host>
         [doc] style-guide (book) <host>
-        [build] rustdoc 0 <host>
-        [doc] rustc 0 <host> -> Tidy 1 <host>
-        [doc] rustc 0 <host> -> Bootstrap 1 <host>
+        [doc] rustc 1 <host> -> Tidy 2 <host>
+        [doc] rustc 1 <host> -> Bootstrap 2 <host>
         [doc] rustc 1 <host> -> releases 2 <host>
-        [doc] rustc 0 <host> -> RunMakeSupport 1 <host>
-        [doc] rustc 0 <host> -> BuildHelper 1 <host>
-        [doc] rustc 0 <host> -> Compiletest 1 <host>
+        [doc] rustc 1 <host> -> RunMakeSupport 2 <host>
+        [doc] rustc 1 <host> -> BuildHelper 2 <host>
+        [doc] rustc 1 <host> -> Compiletest 2 <host>
         [build] rustc 0 <host> -> RustInstaller 1 <host>
         "
         );
@@ -2686,8 +2685,11 @@ mod snapshot {
                 .path("src/tools/compiletest")
                 .stage(2)
                 .render_steps(), @r"
-        [build] rustdoc 0 <host>
-        [doc] rustc 0 <host> -> Compiletest 1 <host>
+        [build] llvm <host>
+        [build] rustc 0 <host> -> rustc 1 <host>
+        [build] rustc 1 <host> -> std 1 <host>
+        [build] rustdoc 1 <host>
+        [doc] rustc 1 <host> -> Compiletest 2 <host>
         ");
     }
 

From 089fbd35aa7c606bc61c4fef6bf3da747d507b75 Mon Sep 17 00:00:00 2001
From: yanglsh <yanglsh@shanghaitech.edu.cn>
Date: Tue, 30 Sep 2025 10:53:35 +0800
Subject: [PATCH 1596/1889] fix: `let_unit_value` suggests wrongly for field
 init shorthand

---
 clippy_lints/src/unit_types/let_unit_value.rs | 48 +++++++++++++------
 tests/ui/let_unit.fixed                       | 10 ++++
 tests/ui/let_unit.rs                          | 10 ++++
 tests/ui/let_unit.stderr                      | 16 ++++++-
 4 files changed, 69 insertions(+), 15 deletions(-)

diff --git a/clippy_lints/src/unit_types/let_unit_value.rs b/clippy_lints/src/unit_types/let_unit_value.rs
index 424aa14cd6863..2645e94358e11 100644
--- a/clippy_lints/src/unit_types/let_unit_value.rs
+++ b/clippy_lints/src/unit_types/let_unit_value.rs
@@ -90,11 +90,12 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, format_args: &FormatArgsStorag
 
                         let mut has_in_format_capture = false;
                         suggestions.extend(visitor.spans.into_iter().filter_map(|span| match span {
-                            MaybeInFormatCapture::Yes => {
+                            VariableUsage::FormatCapture => {
                                 has_in_format_capture = true;
                                 None
                             },
-                            MaybeInFormatCapture::No(span) => Some((span, "()".to_string())),
+                            VariableUsage::Normal(span) => Some((span, "()".to_string())),
+                            VariableUsage::FieldShorthand(span) => Some((span.shrink_to_hi(), ": ()".to_string())),
                         }));
 
                         if has_in_format_capture {
@@ -141,19 +142,30 @@ struct UnitVariableCollector<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     format_args: &'a FormatArgsStorage,
     id: HirId,
-    spans: Vec<MaybeInFormatCapture>,
+    spans: Vec<VariableUsage>,
     macro_call: Option<&'a FormatArgs>,
 }
 
-/// Whether the unit variable is captured in a `format!`:
-///
-/// ```ignore
-/// let unit = ();
-/// eprintln!("{unit}");
-/// ```
-enum MaybeInFormatCapture {
-    Yes,
-    No(Span),
+/// How the unit variable is used
+enum VariableUsage {
+    Normal(Span),
+    /// Captured in a `format!`:
+    ///
+    /// ```ignore
+    /// let unit = ();
+    /// eprintln!("{unit}");
+    /// ```
+    FormatCapture,
+    /// In a field shorthand init:
+    ///
+    /// ```ignore
+    /// struct Foo {
+    ///    unit: (),
+    /// }
+    /// let unit = ();
+    /// Foo { unit };
+    /// ```
+    FieldShorthand(Span),
 }
 
 impl<'a, 'tcx> UnitVariableCollector<'a, 'tcx> {
@@ -193,9 +205,17 @@ impl<'tcx> Visitor<'tcx> for UnitVariableCollector<'_, 'tcx> {
                     matches!(arg.kind, FormatArgumentKind::Captured(_)) && find_format_arg_expr(ex, arg).is_some()
                 })
             {
-                self.spans.push(MaybeInFormatCapture::Yes);
+                self.spans.push(VariableUsage::FormatCapture);
             } else {
-                self.spans.push(MaybeInFormatCapture::No(path.span));
+                let parent = self.cx.tcx.parent_hir_node(ex.hir_id);
+                match parent {
+                    Node::ExprField(expr_field) if expr_field.is_shorthand => {
+                        self.spans.push(VariableUsage::FieldShorthand(ex.span));
+                    },
+                    _ => {
+                        self.spans.push(VariableUsage::Normal(path.span));
+                    },
+                }
             }
         }
 
diff --git a/tests/ui/let_unit.fixed b/tests/ui/let_unit.fixed
index e8517f18e788b..6d984a495d2bd 100644
--- a/tests/ui/let_unit.fixed
+++ b/tests/ui/let_unit.fixed
@@ -229,3 +229,13 @@ fn issue_15784() {
     takes_unit(());
     println!("{res:?}");
 }
+
+fn issue15789() {
+    struct Foo {
+        value: (),
+    }
+    println!();
+    //~^ let_unit_value
+
+    Foo { value: () };
+}
diff --git a/tests/ui/let_unit.rs b/tests/ui/let_unit.rs
index 3f6f0139b2fec..a0e32f0b67a02 100644
--- a/tests/ui/let_unit.rs
+++ b/tests/ui/let_unit.rs
@@ -227,3 +227,13 @@ fn issue_15784() {
     takes_unit(res);
     println!("{res:?}");
 }
+
+fn issue15789() {
+    struct Foo {
+        value: (),
+    }
+    let value = println!();
+    //~^ let_unit_value
+
+    Foo { value };
+}
diff --git a/tests/ui/let_unit.stderr b/tests/ui/let_unit.stderr
index 8ced32ab828f7..6e7b958df4d9a 100644
--- a/tests/ui/let_unit.stderr
+++ b/tests/ui/let_unit.stderr
@@ -114,5 +114,19 @@ LL |
 LL ~     takes_unit(());
    |
 
-error: aborting due to 8 previous errors
+error: this let-binding has unit value
+  --> tests/ui/let_unit.rs:235:5
+   |
+LL |     let value = println!();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: omit the `let` binding and replace variable usages with `()`
+   |
+LL ~     println!();
+LL |
+LL |
+LL ~     Foo { value: () };
+   |
+
+error: aborting due to 9 previous errors
 

From 195ff236c36df93fed8bee9106b3ecbfb4874df0 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Mon, 29 Sep 2025 01:03:16 +0200
Subject: [PATCH 1597/1889] `new_ret_no_self`: extract to a separate module

---
 clippy_lints/src/methods/mod.rs             | 33 ++-------------
 clippy_lints/src/methods/new_ret_no_self.rs | 46 +++++++++++++++++++++
 2 files changed, 50 insertions(+), 29 deletions(-)
 create mode 100644 clippy_lints/src/methods/new_ret_no_self.rs

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 8c2948e4a74e6..157fafa1c6155 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -80,6 +80,7 @@ mod needless_character_iteration;
 mod needless_collect;
 mod needless_option_as_deref;
 mod needless_option_take;
+mod new_ret_no_self;
 mod no_effect_replace;
 mod obfuscated_if_else;
 mod ok_expect;
@@ -148,11 +149,9 @@ mod zst_offset;
 
 use clippy_config::Conf;
 use clippy_utils::consts::{ConstEvalCtxt, Constant};
-use clippy_utils::diagnostics::span_lint;
 use clippy_utils::macros::FormatArgsStorage;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::ty::contains_ty_adt_constructor_opaque;
-use clippy_utils::{contains_return, is_trait_method, iter_input_pats, peel_blocks, return_ty, sym};
+use clippy_utils::{contains_return, is_trait_method, iter_input_pats, peel_blocks, sym};
 pub use path_ends_with_ext::DEFAULT_ALLOWED_DOTFILES;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::{self as hir, Expr, ExprKind, Node, Stmt, StmtKind, TraitItem, TraitItemKind};
@@ -4918,20 +4917,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 );
             }
 
-            // if this impl block implements a trait, lint in trait definition instead
-            if !implements_trait
-                && impl_item.ident.name == sym::new
-                && let ret_ty = return_ty(cx, impl_item.owner_id)
-                && ret_ty != self_ty
-                && !contains_ty_adt_constructor_opaque(cx, ret_ty, self_ty)
-            {
-                span_lint(
-                    cx,
-                    NEW_RET_NO_SELF,
-                    impl_item.span,
-                    "methods called `new` usually return `Self`",
-                );
-            }
+            new_ret_no_self::check_impl_item(cx, impl_item, self_ty, implements_trait);
         }
     }
 
@@ -4963,18 +4949,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 );
             }
 
-            if item.ident.name == sym::new
-                && let ret_ty = return_ty(cx, item.owner_id)
-                && let self_ty = TraitRef::identity(cx.tcx, item.owner_id.to_def_id()).self_ty()
-                && !ret_ty.contains(self_ty)
-            {
-                span_lint(
-                    cx,
-                    NEW_RET_NO_SELF,
-                    item.span,
-                    "methods called `new` usually return `Self`",
-                );
-            }
+            new_ret_no_self::check_trait_item(cx, item);
         }
     }
 }
diff --git a/clippy_lints/src/methods/new_ret_no_self.rs b/clippy_lints/src/methods/new_ret_no_self.rs
new file mode 100644
index 0000000000000..2aa28fbb5f406
--- /dev/null
+++ b/clippy_lints/src/methods/new_ret_no_self.rs
@@ -0,0 +1,46 @@
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::return_ty;
+use clippy_utils::ty::contains_ty_adt_constructor_opaque;
+use rustc_hir::{ImplItem, TraitItem};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, Ty};
+use rustc_span::sym;
+
+use super::NEW_RET_NO_SELF;
+
+pub(super) fn check_impl_item<'tcx>(
+    cx: &LateContext<'tcx>,
+    impl_item: &'tcx ImplItem<'_>,
+    self_ty: Ty<'tcx>,
+    implements_trait: bool,
+) {
+    // if this impl block implements a trait, lint in trait definition instead
+    if !implements_trait
+        && impl_item.ident.name == sym::new
+        && let ret_ty = return_ty(cx, impl_item.owner_id)
+        && ret_ty != self_ty
+        && !contains_ty_adt_constructor_opaque(cx, ret_ty, self_ty)
+    {
+        span_lint(
+            cx,
+            NEW_RET_NO_SELF,
+            impl_item.span,
+            "methods called `new` usually return `Self`",
+        );
+    }
+}
+
+pub(super) fn check_trait_item<'tcx>(cx: &LateContext<'tcx>, trait_item: &'tcx TraitItem<'tcx>) {
+    if trait_item.ident.name == sym::new
+        && let ret_ty = return_ty(cx, trait_item.owner_id)
+        && let self_ty = ty::TraitRef::identity(cx.tcx, trait_item.owner_id.to_def_id()).self_ty()
+        && !ret_ty.contains(self_ty)
+    {
+        span_lint(
+            cx,
+            NEW_RET_NO_SELF,
+            trait_item.span,
+            "methods called `new` usually return `Self`",
+        );
+    }
+}

From b3219502d71776bd2ab5be92734f1a05c2b01eb2 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Tue, 30 Sep 2025 17:43:02 +0200
Subject: [PATCH 1598/1889] `map_identity`: simplify lint emission

Instead of calling `span_lint_and_*` in multiple places, call
`span_lint_and_then` once and then use the `Diag` methods.
---
 clippy_lints/src/methods/map_identity.rs | 80 +++++++++++-------------
 1 file changed, 35 insertions(+), 45 deletions(-)

diff --git a/clippy_lints/src/methods/map_identity.rs b/clippy_lints/src/methods/map_identity.rs
index a98cfff8bfbd1..6190c43578e9b 100644
--- a/clippy_lints/src/methods/map_identity.rs
+++ b/clippy_lints/src/methods/map_identity.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_copy, is_type_diagnostic_item};
 use clippy_utils::{is_expr_untyped_identity_function, is_mutable, is_trait_method, path_to_local_with_projections};
@@ -27,48 +27,46 @@ pub(super) fn check(
         && is_expr_untyped_identity_function(cx, map_arg)
         && let Some(call_span) = expr.span.trim_start(caller.span)
     {
-        let main_sugg = (call_span, String::new());
-        let mut app = if is_copy(cx, caller_ty) {
-            // there is technically a behavioral change here for `Copy` iterators, where
-            // `iter.map(|x| x).next()` would mutate a temporary copy of the iterator and
-            // changing it to `iter.next()` mutates iter directly
-            Applicability::Unspecified
-        } else {
-            Applicability::MachineApplicable
-        };
+        span_lint_and_then(cx, MAP_IDENTITY, call_span, MSG, |diag| {
+            let main_sugg = (call_span, String::new());
+            let mut app = if is_copy(cx, caller_ty) {
+                // there is technically a behavioral change here for `Copy` iterators, where
+                // `iter.map(|x| x).next()` would mutate a temporary copy of the iterator and
+                // changing it to `iter.next()` mutates iter directly
+                Applicability::Unspecified
+            } else {
+                Applicability::MachineApplicable
+            };
 
-        let needs_to_be_mutable = cx.typeck_results().expr_ty_adjusted(expr).is_mutable_ptr();
-        if needs_to_be_mutable && !is_mutable(cx, caller) {
-            if let Some(hir_id) = path_to_local_with_projections(caller)
-                && let Node::Pat(pat) = cx.tcx.hir_node(hir_id)
-                && let PatKind::Binding(_, _, ident, _) = pat.kind
-            {
-                // We can reach the binding -- suggest making it mutable
-                let suggs = vec![main_sugg, (ident.span.shrink_to_lo(), String::from("mut "))];
+            let needs_to_be_mutable = cx.typeck_results().expr_ty_adjusted(expr).is_mutable_ptr();
+            if needs_to_be_mutable && !is_mutable(cx, caller) {
+                if let Some(hir_id) = path_to_local_with_projections(caller)
+                    && let Node::Pat(pat) = cx.tcx.hir_node(hir_id)
+                    && let PatKind::Binding(_, _, ident, _) = pat.kind
+                {
+                    // We can reach the binding -- suggest making it mutable
+                    let suggs = vec![main_sugg, (ident.span.shrink_to_lo(), String::from("mut "))];
 
-                let ident = snippet_with_applicability(cx.sess(), ident.span, "_", &mut app);
+                    let ident = snippet_with_applicability(cx.sess(), ident.span, "_", &mut app);
 
-                span_lint_and_then(cx, MAP_IDENTITY, call_span, MSG, |diag| {
                     diag.multipart_suggestion(
                         format!("remove the call to `{name}`, and make `{ident}` mutable"),
                         suggs,
                         app,
                     );
-                });
-            } else {
-                // If we can't make the binding mutable, prevent the suggestion from being automatically applied,
-                // and add a complementary help message.
-                app = Applicability::Unspecified;
-
-                let method_requiring_mut = if let Node::Expr(expr) = cx.tcx.parent_hir_node(expr.hir_id)
-                    && let ExprKind::MethodCall(method, ..) = expr.kind
-                {
-                    Some(method.ident)
                 } else {
-                    None
-                };
+                    // If we can't make the binding mutable, prevent the suggestion from being automatically applied,
+                    // and add a complementary help message.
+                    app = Applicability::Unspecified;
+
+                    let method_requiring_mut = if let Node::Expr(expr) = cx.tcx.parent_hir_node(expr.hir_id)
+                        && let ExprKind::MethodCall(method, ..) = expr.kind
+                    {
+                        Some(method.ident)
+                    } else {
+                        None
+                    };
 
-                span_lint_and_then(cx, MAP_IDENTITY, call_span, MSG, |diag| {
                     diag.span_suggestion(main_sugg.0, format!("remove the call to `{name}`"), main_sugg.1, app);
 
                     let note = if let Some(method_requiring_mut) = method_requiring_mut {
@@ -77,18 +75,10 @@ pub(super) fn check(
                         "this must be made mutable".to_string()
                     };
                     diag.span_note(caller.span, note);
-                });
+                }
+            } else {
+                diag.span_suggestion(main_sugg.0, format!("remove the call to `{name}`"), main_sugg.1, app);
             }
-        } else {
-            span_lint_and_sugg(
-                cx,
-                MAP_IDENTITY,
-                main_sugg.0,
-                MSG,
-                format!("remove the call to `{name}`"),
-                main_sugg.1,
-                app,
-            );
-        }
+        });
     }
 }

From e9ede27a5d880e5b8075ffb98dd381f4d5ce09ca Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sun, 24 Aug 2025 09:31:06 +0200
Subject: [PATCH 1599/1889] test: remove extraneous
 `#[allow(clippy::uninlined_format_args)]`

These were probably added automatically to avoid code churn. I'd like to
get rid of them bit by bit, so here's the first bit
---
 .../conf_deprecated_key.rs                    |   4 +-
 .../conf_deprecated_key.stderr                |   2 +-
 .../index_refutable_slice.fixed               |   1 -
 .../index_refutable_slice.rs                  |   1 -
 .../index_refutable_slice.stderr              |   4 +-
 tests/ui/bind_instead_of_map.fixed            |   1 -
 tests/ui/bind_instead_of_map.rs               |   1 -
 tests/ui/bind_instead_of_map.stderr           |   6 +-
 .../shared_at_top_and_bottom.rs               |   5 +-
 .../shared_at_top_and_bottom.stderr           |  24 ++--
 tests/ui/cast_abs_to_unsigned.fixed           |   4 +-
 tests/ui/cast_abs_to_unsigned.rs              |   4 +-
 tests/ui/crashes/ice-4775.rs                  |   2 +-
 tests/ui/default_trait_access.fixed           |   2 +-
 tests/ui/default_trait_access.rs              |   2 +-
 tests/ui/default_trait_access.stderr          |  16 +--
 tests/ui/explicit_counter_loop.rs             |  24 ++--
 tests/ui/explicit_write.fixed                 |   5 +-
 tests/ui/explicit_write.rs                    |   5 +-
 tests/ui/explicit_write.stderr                |  34 ++---
 tests/ui/fallible_impl_from.rs                |   3 +-
 tests/ui/fallible_impl_from.stderr            |  20 +--
 .../if_let_slice_binding.fixed                |  14 +-
 .../if_let_slice_binding.rs                   |  14 +-
 tests/ui/infinite_iter.rs                     |   4 +-
 tests/ui/infinite_iter.stderr                 |   4 +-
 tests/ui/issue_2356.fixed                     |   3 +-
 tests/ui/issue_2356.rs                        |   3 +-
 tests/ui/issue_2356.stderr                    |   2 +-
 tests/ui/issue_4266.rs                        |   3 +-
 tests/ui/issue_4266.stderr                    |   6 +-
 tests/ui/match_single_binding.fixed           |  37 +++--
 tests/ui/match_single_binding.rs              |  37 +++--
 tests/ui/match_single_binding.stderr          | 130 +++++++++---------
 tests/ui/match_single_binding2.fixed          |   3 +-
 tests/ui/match_single_binding2.rs             |   3 +-
 tests/ui/match_single_binding2.stderr         |  12 +-
 37 files changed, 214 insertions(+), 231 deletions(-)

diff --git a/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.rs b/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.rs
index ecb43dc34a8a0..b28e46af0a467 100644
--- a/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.rs
+++ b/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.rs
@@ -1,5 +1,3 @@
-#![allow(clippy::uninlined_format_args)]
-
 fn main() {}
 
 #[warn(clippy::cognitive_complexity)]
@@ -8,7 +6,7 @@ fn cognitive_complexity() {
     let x = vec![1, 2, 3];
     for i in x {
         if i == 1 {
-            println!("{}", i);
+            println!("{i}");
         }
     }
 }
diff --git a/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.stderr b/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.stderr
index 627498dc175cd..95b0508189e9c 100644
--- a/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.stderr
+++ b/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.stderr
@@ -11,7 +11,7 @@ LL | blacklisted-names = [ "..", "wibble" ]
    | ^^^^^^^^^^^^^^^^^
 
 error: the function has a cognitive complexity of (3/2)
-  --> tests/ui-toml/conf_deprecated_key/conf_deprecated_key.rs:6:4
+  --> tests/ui-toml/conf_deprecated_key/conf_deprecated_key.rs:4:4
    |
 LL | fn cognitive_complexity() {
    |    ^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui-toml/max_suggested_slice_pattern_length/index_refutable_slice.fixed b/tests/ui-toml/max_suggested_slice_pattern_length/index_refutable_slice.fixed
index 2877871d0bf4c..36540bf1dcf73 100644
--- a/tests/ui-toml/max_suggested_slice_pattern_length/index_refutable_slice.fixed
+++ b/tests/ui-toml/max_suggested_slice_pattern_length/index_refutable_slice.fixed
@@ -1,4 +1,3 @@
-#![allow(clippy::uninlined_format_args)]
 #![deny(clippy::index_refutable_slice)]
 
 fn below_limit() {
diff --git a/tests/ui-toml/max_suggested_slice_pattern_length/index_refutable_slice.rs b/tests/ui-toml/max_suggested_slice_pattern_length/index_refutable_slice.rs
index f958b92a102a3..da76bb20fd961 100644
--- a/tests/ui-toml/max_suggested_slice_pattern_length/index_refutable_slice.rs
+++ b/tests/ui-toml/max_suggested_slice_pattern_length/index_refutable_slice.rs
@@ -1,4 +1,3 @@
-#![allow(clippy::uninlined_format_args)]
 #![deny(clippy::index_refutable_slice)]
 
 fn below_limit() {
diff --git a/tests/ui-toml/max_suggested_slice_pattern_length/index_refutable_slice.stderr b/tests/ui-toml/max_suggested_slice_pattern_length/index_refutable_slice.stderr
index e1a8941e102f5..022deb330e6e3 100644
--- a/tests/ui-toml/max_suggested_slice_pattern_length/index_refutable_slice.stderr
+++ b/tests/ui-toml/max_suggested_slice_pattern_length/index_refutable_slice.stderr
@@ -1,11 +1,11 @@
 error: this binding can be a slice pattern to avoid indexing
-  --> tests/ui-toml/max_suggested_slice_pattern_length/index_refutable_slice.rs:6:17
+  --> tests/ui-toml/max_suggested_slice_pattern_length/index_refutable_slice.rs:5:17
    |
 LL |     if let Some(slice) = slice {
    |                 ^^^^^
    |
 note: the lint level is defined here
-  --> tests/ui-toml/max_suggested_slice_pattern_length/index_refutable_slice.rs:2:9
+  --> tests/ui-toml/max_suggested_slice_pattern_length/index_refutable_slice.rs:1:9
    |
 LL | #![deny(clippy::index_refutable_slice)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/bind_instead_of_map.fixed b/tests/ui/bind_instead_of_map.fixed
index 80e010e2dfd74..fa35a01242d1d 100644
--- a/tests/ui/bind_instead_of_map.fixed
+++ b/tests/ui/bind_instead_of_map.fixed
@@ -1,5 +1,4 @@
 #![deny(clippy::bind_instead_of_map)]
-#![allow(clippy::uninlined_format_args)]
 
 // need a main anyway, use it get rid of unused warnings too
 pub fn main() {
diff --git a/tests/ui/bind_instead_of_map.rs b/tests/ui/bind_instead_of_map.rs
index 09aa8480cbd9e..403077e72ff98 100644
--- a/tests/ui/bind_instead_of_map.rs
+++ b/tests/ui/bind_instead_of_map.rs
@@ -1,5 +1,4 @@
 #![deny(clippy::bind_instead_of_map)]
-#![allow(clippy::uninlined_format_args)]
 
 // need a main anyway, use it get rid of unused warnings too
 pub fn main() {
diff --git a/tests/ui/bind_instead_of_map.stderr b/tests/ui/bind_instead_of_map.stderr
index 08f85fb58549c..3f8d631591e93 100644
--- a/tests/ui/bind_instead_of_map.stderr
+++ b/tests/ui/bind_instead_of_map.stderr
@@ -1,5 +1,5 @@
 error: using `Option.and_then(Some)`, which is a no-op
-  --> tests/ui/bind_instead_of_map.rs:8:13
+  --> tests/ui/bind_instead_of_map.rs:7:13
    |
 LL |     let _ = x.and_then(Some);
    |             ^^^^^^^^^^^^^^^^ help: use the expression directly: `x`
@@ -11,13 +11,13 @@ LL | #![deny(clippy::bind_instead_of_map)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: using `Option.and_then(|x| Some(y))`, which is more succinctly expressed as `map(|x| y)`
-  --> tests/ui/bind_instead_of_map.rs:10:13
+  --> tests/ui/bind_instead_of_map.rs:9:13
    |
 LL |     let _ = x.and_then(|o| Some(o + 1));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.map(|o| o + 1)`
 
 error: using `Result.and_then(Ok)`, which is a no-op
-  --> tests/ui/bind_instead_of_map.rs:17:13
+  --> tests/ui/bind_instead_of_map.rs:16:13
    |
 LL |     let _ = x.and_then(Ok);
    |             ^^^^^^^^^^^^^^ help: use the expression directly: `x`
diff --git a/tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs b/tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs
index e848f0601e32d..1646b5705b6dd 100644
--- a/tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs
+++ b/tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs
@@ -1,6 +1,5 @@
 #![deny(clippy::branches_sharing_code, clippy::if_same_then_else)]
 #![allow(dead_code)]
-#![allow(clippy::uninlined_format_args)]
 //@no-rustfix
 // branches_sharing_code at the top and bottom of the if blocks
 
@@ -70,7 +69,7 @@ fn complexer_example() {
         let b = 0xffff00ff;
         let e_id = gen_id(a, b);
 
-        println!("From the a `{}` to the b `{}`", a, b);
+        println!("From the a `{a}` to the b `{b}`");
 
         let pack = DataPack {
             id: e_id,
@@ -83,7 +82,7 @@ fn complexer_example() {
         let b = 0xffff00ff;
         let e_id = gen_id(a, b);
 
-        println!("The new ID is '{}'", e_id);
+        println!("The new ID is '{e_id}'");
 
         let pack = DataPack {
             id: e_id,
diff --git a/tests/ui/branches_sharing_code/shared_at_top_and_bottom.stderr b/tests/ui/branches_sharing_code/shared_at_top_and_bottom.stderr
index 40f3453edb9ae..f5c51f7888d04 100644
--- a/tests/ui/branches_sharing_code/shared_at_top_and_bottom.stderr
+++ b/tests/ui/branches_sharing_code/shared_at_top_and_bottom.stderr
@@ -1,5 +1,5 @@
 error: all if blocks contain the same code at both the start and the end
-  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:17:5
+  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:16:5
    |
 LL | /     if x == 7 {
 LL | |
@@ -10,7 +10,7 @@ LL | |         let _overlap_end = 2 * t;
    | |_________________________________^
    |
 note: this code is shared at the end
-  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:31:5
+  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:30:5
    |
 LL | /         let _u = 9;
 LL | |     }
@@ -34,7 +34,7 @@ LL +     let _u = 9;
    |
 
 error: all if blocks contain the same code at both the start and the end
-  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:35:5
+  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:34:5
    |
 LL | /     if x == 99 {
 LL | |
@@ -45,7 +45,7 @@ LL | |         let _overlap_middle = r * r;
    | |____________________________________^
    |
 note: this code is shared at the end
-  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:48:5
+  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:47:5
    |
 LL | /         let _overlap_end = r * r * r;
 LL | |         let z = "end";
@@ -67,7 +67,7 @@ LL +     let z = "end";
    |
 
 error: all if blocks contain the same code at both the start and the end
-  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:66:5
+  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:65:5
    |
 LL | /     if (x > 7 && y < 13) || (x + y) % 2 == 1 {
 LL | |
@@ -78,7 +78,7 @@ LL | |         let e_id = gen_id(a, b);
    | |________________________________^
    |
 note: this code is shared at the end
-  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:88:5
+  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:87:5
    |
 LL | /         let pack = DataPack {
 LL | |             id: e_id,
@@ -108,7 +108,7 @@ LL +     process_data(pack);
    |
 
 error: all if blocks contain the same code at both the start and the end
-  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:101:5
+  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:100:5
    |
 LL | /     let _ = if x == 7 {
 ...  |
@@ -116,7 +116,7 @@ LL | |         let _ = 19;
    | |___________________^
    |
 note: this code is shared at the end
-  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:112:5
+  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:111:5
    |
 LL | /         x << 2
 LL | |     };
@@ -134,7 +134,7 @@ LL ~     x << 2;
    |
 
 error: all if blocks contain the same code at both the start and the end
-  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:115:5
+  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:114:5
    |
 LL | /     if x == 9 {
 ...  |
@@ -142,7 +142,7 @@ LL | |         let _ = 17;
    | |___________________^
    |
 note: this code is shared at the end
-  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:126:5
+  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:125:5
    |
 LL | /         x * 4
 LL | |     }
@@ -160,7 +160,7 @@ LL +     x * 4
    |
 
 error: all if blocks contain the same code at both the start and the end
-  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:158:9
+  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:157:9
    |
 LL | /         if false {
 LL | |
@@ -168,7 +168,7 @@ LL | |             let x = 1;
    | |______________________^
    |
 note: this code is shared at the end
-  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:166:9
+  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:165:9
    |
 LL | /             let y = 1;
 LL | |         }
diff --git a/tests/ui/cast_abs_to_unsigned.fixed b/tests/ui/cast_abs_to_unsigned.fixed
index b55c22f5ca83c..44cb66a8d1848 100644
--- a/tests/ui/cast_abs_to_unsigned.fixed
+++ b/tests/ui/cast_abs_to_unsigned.fixed
@@ -1,11 +1,11 @@
 #![warn(clippy::cast_abs_to_unsigned)]
-#![allow(clippy::uninlined_format_args, unused)]
+#![allow(unused)]
 
 fn main() {
     let x: i32 = -42;
     let y: u32 = x.unsigned_abs();
     //~^ cast_abs_to_unsigned
-    println!("The absolute value of {} is {}", x, y);
+    println!("The absolute value of {x} is {y}");
 
     let a: i32 = -3;
     let _: usize = a.unsigned_abs() as usize;
diff --git a/tests/ui/cast_abs_to_unsigned.rs b/tests/ui/cast_abs_to_unsigned.rs
index 466aa6aeb1fbb..555b9090fe437 100644
--- a/tests/ui/cast_abs_to_unsigned.rs
+++ b/tests/ui/cast_abs_to_unsigned.rs
@@ -1,11 +1,11 @@
 #![warn(clippy::cast_abs_to_unsigned)]
-#![allow(clippy::uninlined_format_args, unused)]
+#![allow(unused)]
 
 fn main() {
     let x: i32 = -42;
     let y: u32 = x.abs() as u32;
     //~^ cast_abs_to_unsigned
-    println!("The absolute value of {} is {}", x, y);
+    println!("The absolute value of {x} is {y}");
 
     let a: i32 = -3;
     let _: usize = a.abs() as usize;
diff --git a/tests/ui/crashes/ice-4775.rs b/tests/ui/crashes/ice-4775.rs
index dd6c6b8de25af..e8c47b4f3a77b 100644
--- a/tests/ui/crashes/ice-4775.rs
+++ b/tests/ui/crashes/ice-4775.rs
@@ -7,7 +7,7 @@ pub struct ArrayWrapper<const N: usize>([usize; N]);
 impl<const N: usize> ArrayWrapper<{ N }> {
     pub fn ice(&self) {
         for i in self.0.iter() {
-            println!("{}", i);
+            println!("{i}");
         }
     }
 }
diff --git a/tests/ui/default_trait_access.fixed b/tests/ui/default_trait_access.fixed
index d3fe09a052ef3..e3bf603da80f3 100644
--- a/tests/ui/default_trait_access.fixed
+++ b/tests/ui/default_trait_access.fixed
@@ -1,7 +1,6 @@
 //@aux-build: proc_macros.rs
 #![deny(clippy::default_trait_access)]
 #![allow(dead_code, unused_imports)]
-#![allow(clippy::uninlined_format_args)]
 
 extern crate proc_macros;
 
@@ -63,6 +62,7 @@ fn main() {
 
     let _s21: String = with_span!(s Default::default());
 
+    #[expect(clippy::uninlined_format_args)]
     println!(
         "[{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}]",
         s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20,
diff --git a/tests/ui/default_trait_access.rs b/tests/ui/default_trait_access.rs
index cdffb2a2ee8ca..8cc065e5bced2 100644
--- a/tests/ui/default_trait_access.rs
+++ b/tests/ui/default_trait_access.rs
@@ -1,7 +1,6 @@
 //@aux-build: proc_macros.rs
 #![deny(clippy::default_trait_access)]
 #![allow(dead_code, unused_imports)]
-#![allow(clippy::uninlined_format_args)]
 
 extern crate proc_macros;
 
@@ -63,6 +62,7 @@ fn main() {
 
     let _s21: String = with_span!(s Default::default());
 
+    #[expect(clippy::uninlined_format_args)]
     println!(
         "[{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}]",
         s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20,
diff --git a/tests/ui/default_trait_access.stderr b/tests/ui/default_trait_access.stderr
index aa7eb4f89558c..aa89516f175c4 100644
--- a/tests/ui/default_trait_access.stderr
+++ b/tests/ui/default_trait_access.stderr
@@ -1,5 +1,5 @@
 error: calling `String::default()` is more clear than this expression
-  --> tests/ui/default_trait_access.rs:13:22
+  --> tests/ui/default_trait_access.rs:12:22
    |
 LL |     let s1: String = Default::default();
    |                      ^^^^^^^^^^^^^^^^^^ help: try: `String::default()`
@@ -11,43 +11,43 @@ LL | #![deny(clippy::default_trait_access)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: calling `String::default()` is more clear than this expression
-  --> tests/ui/default_trait_access.rs:18:22
+  --> tests/ui/default_trait_access.rs:17:22
    |
 LL |     let s3: String = D2::default();
    |                      ^^^^^^^^^^^^^ help: try: `String::default()`
 
 error: calling `String::default()` is more clear than this expression
-  --> tests/ui/default_trait_access.rs:21:22
+  --> tests/ui/default_trait_access.rs:20:22
    |
 LL |     let s4: String = std::default::Default::default();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `String::default()`
 
 error: calling `String::default()` is more clear than this expression
-  --> tests/ui/default_trait_access.rs:26:22
+  --> tests/ui/default_trait_access.rs:25:22
    |
 LL |     let s6: String = default::Default::default();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `String::default()`
 
 error: calling `GenericDerivedDefault::default()` is more clear than this expression
-  --> tests/ui/default_trait_access.rs:37:46
+  --> tests/ui/default_trait_access.rs:36:46
    |
 LL |     let s11: GenericDerivedDefault<String> = Default::default();
    |                                              ^^^^^^^^^^^^^^^^^^ help: try: `GenericDerivedDefault::default()`
 
 error: calling `TupleDerivedDefault::default()` is more clear than this expression
-  --> tests/ui/default_trait_access.rs:44:36
+  --> tests/ui/default_trait_access.rs:43:36
    |
 LL |     let s14: TupleDerivedDefault = Default::default();
    |                                    ^^^^^^^^^^^^^^^^^^ help: try: `TupleDerivedDefault::default()`
 
 error: calling `ArrayDerivedDefault::default()` is more clear than this expression
-  --> tests/ui/default_trait_access.rs:47:36
+  --> tests/ui/default_trait_access.rs:46:36
    |
 LL |     let s15: ArrayDerivedDefault = Default::default();
    |                                    ^^^^^^^^^^^^^^^^^^ help: try: `ArrayDerivedDefault::default()`
 
 error: calling `TupleStructDerivedDefault::default()` is more clear than this expression
-  --> tests/ui/default_trait_access.rs:52:42
+  --> tests/ui/default_trait_access.rs:51:42
    |
 LL |     let s17: TupleStructDerivedDefault = Default::default();
    |                                          ^^^^^^^^^^^^^^^^^^ help: try: `TupleStructDerivedDefault::default()`
diff --git a/tests/ui/explicit_counter_loop.rs b/tests/ui/explicit_counter_loop.rs
index 13934785d7b15..ec4cecf377667 100644
--- a/tests/ui/explicit_counter_loop.rs
+++ b/tests/ui/explicit_counter_loop.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::explicit_counter_loop)]
-#![allow(clippy::uninlined_format_args, clippy::useless_vec)]
+#![allow(clippy::useless_vec)]
 //@no-rustfix: suggestion does not remove the `+= 1`
 fn main() {
     let mut vec = vec![1, 2, 3, 4];
@@ -89,13 +89,13 @@ mod issue_1219 {
         for _v in &vec {
             index += 1
         }
-        println!("index: {}", index);
+        println!("index: {index}");
 
         // should not trigger the lint because the count is conditional #1219
         let text = "banana";
         let mut count = 0;
         for ch in text.chars() {
-            println!("{}", count);
+            println!("{count}");
             if ch == 'a' {
                 continue;
             }
@@ -106,7 +106,7 @@ mod issue_1219 {
         let text = "banana";
         let mut count = 0;
         for ch in text.chars() {
-            println!("{}", count);
+            println!("{count}");
             if ch == 'a' {
                 count += 1;
             }
@@ -118,7 +118,7 @@ mod issue_1219 {
         for ch in text.chars() {
             //~^ explicit_counter_loop
 
-            println!("{}", count);
+            println!("{count}");
             count += 1;
             if ch == 'a' {
                 continue;
@@ -131,7 +131,7 @@ mod issue_1219 {
         for ch in text.chars() {
             //~^ explicit_counter_loop
 
-            println!("{}", count);
+            println!("{count}");
             count += 1;
             for i in 0..2 {
                 let _ = 123;
@@ -142,7 +142,7 @@ mod issue_1219 {
         let text = "banana";
         let mut count = 0;
         for ch in text.chars() {
-            println!("{}", count);
+            println!("{count}");
             count += 1;
             for i in 0..2 {
                 count += 1;
@@ -157,7 +157,7 @@ mod issue_3308 {
         let mut skips = 0;
         let erasures = vec![];
         for i in 0..10 {
-            println!("{}", skips);
+            println!("{skips}");
             while erasures.contains(&(i + skips)) {
                 skips += 1;
             }
@@ -166,7 +166,7 @@ mod issue_3308 {
         // should not trigger the lint because the count is incremented multiple times
         let mut skips = 0;
         for i in 0..10 {
-            println!("{}", skips);
+            println!("{skips}");
             let mut j = 0;
             while j < 5 {
                 skips += 1;
@@ -177,7 +177,7 @@ mod issue_3308 {
         // should not trigger the lint because the count is incremented multiple times
         let mut skips = 0;
         for i in 0..10 {
-            println!("{}", skips);
+            println!("{skips}");
             for j in 0..5 {
                 skips += 1;
             }
@@ -205,7 +205,7 @@ mod issue_4732 {
         for _v in slice {
             index += 1
         }
-        let _closure = || println!("index: {}", index);
+        let _closure = || println!("index: {index}");
     }
 }
 
@@ -217,7 +217,7 @@ mod issue_4677 {
         let mut count = 0;
         for _i in slice {
             count += 1;
-            println!("{}", count);
+            println!("{count}");
         }
     }
 }
diff --git a/tests/ui/explicit_write.fixed b/tests/ui/explicit_write.fixed
index 024999fc609ee..ab28c1ccd8e0d 100644
--- a/tests/ui/explicit_write.fixed
+++ b/tests/ui/explicit_write.fixed
@@ -1,6 +1,5 @@
 #![warn(clippy::explicit_write)]
 #![allow(unused_imports)]
-#![allow(clippy::uninlined_format_args)]
 
 fn stdout() -> String {
     String::new()
@@ -40,7 +39,7 @@ fn main() {
         //~^ explicit_write
 
         let value = 1;
-        eprintln!("with {}", value);
+        eprintln!("with {value}");
         //~^ explicit_write
         eprintln!("with {} {}", 2, value);
         //~^ explicit_write
@@ -49,7 +48,7 @@ fn main() {
         eprintln!("macro arg {}", one!());
         //~^ explicit_write
         let width = 2;
-        eprintln!("{:w$}", value, w = width);
+        eprintln!("{value:w$}", w = width);
         //~^ explicit_write
     }
     // these should not warn, different destination
diff --git a/tests/ui/explicit_write.rs b/tests/ui/explicit_write.rs
index c83c760d48c8b..975ee103b6278 100644
--- a/tests/ui/explicit_write.rs
+++ b/tests/ui/explicit_write.rs
@@ -1,6 +1,5 @@
 #![warn(clippy::explicit_write)]
 #![allow(unused_imports)]
-#![allow(clippy::uninlined_format_args)]
 
 fn stdout() -> String {
     String::new()
@@ -40,7 +39,7 @@ fn main() {
         //~^ explicit_write
 
         let value = 1;
-        writeln!(std::io::stderr(), "with {}", value).unwrap();
+        writeln!(std::io::stderr(), "with {value}").unwrap();
         //~^ explicit_write
         writeln!(std::io::stderr(), "with {} {}", 2, value).unwrap();
         //~^ explicit_write
@@ -49,7 +48,7 @@ fn main() {
         writeln!(std::io::stderr(), "macro arg {}", one!()).unwrap();
         //~^ explicit_write
         let width = 2;
-        writeln!(std::io::stderr(), "{:w$}", value, w = width).unwrap();
+        writeln!(std::io::stderr(), "{value:w$}", w = width).unwrap();
         //~^ explicit_write
     }
     // these should not warn, different destination
diff --git a/tests/ui/explicit_write.stderr b/tests/ui/explicit_write.stderr
index 670a0411b3107..ef4b2a049a6d9 100644
--- a/tests/ui/explicit_write.stderr
+++ b/tests/ui/explicit_write.stderr
@@ -1,5 +1,5 @@
 error: use of `write!(stdout(), ...).unwrap()`
-  --> tests/ui/explicit_write.rs:23:9
+  --> tests/ui/explicit_write.rs:22:9
    |
 LL |         write!(std::io::stdout(), "test").unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `print!("test")`
@@ -8,76 +8,76 @@ LL |         write!(std::io::stdout(), "test").unwrap();
    = help: to override `-D warnings` add `#[allow(clippy::explicit_write)]`
 
 error: use of `write!(stderr(), ...).unwrap()`
-  --> tests/ui/explicit_write.rs:25:9
+  --> tests/ui/explicit_write.rs:24:9
    |
 LL |         write!(std::io::stderr(), "test").unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprint!("test")`
 
 error: use of `writeln!(stdout(), ...).unwrap()`
-  --> tests/ui/explicit_write.rs:27:9
+  --> tests/ui/explicit_write.rs:26:9
    |
 LL |         writeln!(std::io::stdout(), "test").unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `println!("test")`
 
 error: use of `writeln!(stderr(), ...).unwrap()`
-  --> tests/ui/explicit_write.rs:29:9
+  --> tests/ui/explicit_write.rs:28:9
    |
 LL |         writeln!(std::io::stderr(), "test").unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprintln!("test")`
 
 error: use of `stdout().write_fmt(...).unwrap()`
-  --> tests/ui/explicit_write.rs:31:9
+  --> tests/ui/explicit_write.rs:30:9
    |
 LL |         std::io::stdout().write_fmt(format_args!("test")).unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `print!("test")`
 
 error: use of `stderr().write_fmt(...).unwrap()`
-  --> tests/ui/explicit_write.rs:33:9
+  --> tests/ui/explicit_write.rs:32:9
    |
 LL |         std::io::stderr().write_fmt(format_args!("test")).unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprint!("test")`
 
 error: use of `writeln!(stdout(), ...).unwrap()`
-  --> tests/ui/explicit_write.rs:37:9
+  --> tests/ui/explicit_write.rs:36:9
    |
 LL |         writeln!(std::io::stdout(), "test\ntest").unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `println!("test\ntest")`
 
 error: use of `writeln!(stderr(), ...).unwrap()`
-  --> tests/ui/explicit_write.rs:39:9
+  --> tests/ui/explicit_write.rs:38:9
    |
 LL |         writeln!(std::io::stderr(), "test\ntest").unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprintln!("test\ntest")`
 
 error: use of `writeln!(stderr(), ...).unwrap()`
-  --> tests/ui/explicit_write.rs:43:9
+  --> tests/ui/explicit_write.rs:42:9
    |
-LL |         writeln!(std::io::stderr(), "with {}", value).unwrap();
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprintln!("with {}", value)`
+LL |         writeln!(std::io::stderr(), "with {value}").unwrap();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprintln!("with {value}")`
 
 error: use of `writeln!(stderr(), ...).unwrap()`
-  --> tests/ui/explicit_write.rs:45:9
+  --> tests/ui/explicit_write.rs:44:9
    |
 LL |         writeln!(std::io::stderr(), "with {} {}", 2, value).unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprintln!("with {} {}", 2, value)`
 
 error: use of `writeln!(stderr(), ...).unwrap()`
-  --> tests/ui/explicit_write.rs:47:9
+  --> tests/ui/explicit_write.rs:46:9
    |
 LL |         writeln!(std::io::stderr(), "with {value}").unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprintln!("with {value}")`
 
 error: use of `writeln!(stderr(), ...).unwrap()`
-  --> tests/ui/explicit_write.rs:49:9
+  --> tests/ui/explicit_write.rs:48:9
    |
 LL |         writeln!(std::io::stderr(), "macro arg {}", one!()).unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprintln!("macro arg {}", one!())`
 
 error: use of `writeln!(stderr(), ...).unwrap()`
-  --> tests/ui/explicit_write.rs:52:9
+  --> tests/ui/explicit_write.rs:51:9
    |
-LL |         writeln!(std::io::stderr(), "{:w$}", value, w = width).unwrap();
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprintln!("{:w$}", value, w = width)`
+LL |         writeln!(std::io::stderr(), "{value:w$}", w = width).unwrap();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprintln!("{value:w$}", w = width)`
 
 error: aborting due to 13 previous errors
 
diff --git a/tests/ui/fallible_impl_from.rs b/tests/ui/fallible_impl_from.rs
index 1c62c1e937b63..28bb1157f6e52 100644
--- a/tests/ui/fallible_impl_from.rs
+++ b/tests/ui/fallible_impl_from.rs
@@ -1,5 +1,4 @@
 #![deny(clippy::fallible_impl_from)]
-#![allow(clippy::uninlined_format_args)]
 
 // docs example
 struct Foo(i32);
@@ -62,7 +61,7 @@ impl<'a> From<&'a mut <Box<u32> as ProjStrTrait>::ProjString> for Invalid {
 
     fn from(s: &'a mut <Box<u32> as ProjStrTrait>::ProjString) -> Invalid {
         if s.parse::<u32>().ok().unwrap() != 42 {
-            panic!("{:?}", s);
+            panic!("{s:?}");
         }
         Invalid
     }
diff --git a/tests/ui/fallible_impl_from.stderr b/tests/ui/fallible_impl_from.stderr
index 402494b39f30b..25ecc8b0a39a2 100644
--- a/tests/ui/fallible_impl_from.stderr
+++ b/tests/ui/fallible_impl_from.stderr
@@ -1,5 +1,5 @@
 error: consider implementing `TryFrom` instead
-  --> tests/ui/fallible_impl_from.rs:6:1
+  --> tests/ui/fallible_impl_from.rs:5:1
    |
 LL | / impl From<String> for Foo {
 LL | |
@@ -11,7 +11,7 @@ LL | | }
    |
    = help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail
 note: potential failure(s)
-  --> tests/ui/fallible_impl_from.rs:10:13
+  --> tests/ui/fallible_impl_from.rs:9:13
    |
 LL |         Foo(s.parse().unwrap())
    |             ^^^^^^^^^^^^^^^^^^
@@ -22,7 +22,7 @@ LL | #![deny(clippy::fallible_impl_from)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: consider implementing `TryFrom` instead
-  --> tests/ui/fallible_impl_from.rs:29:1
+  --> tests/ui/fallible_impl_from.rs:28:1
    |
 LL | / impl From<usize> for Invalid {
 LL | |
@@ -34,13 +34,13 @@ LL | | }
    |
    = help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail
 note: potential failure(s)
-  --> tests/ui/fallible_impl_from.rs:34:13
+  --> tests/ui/fallible_impl_from.rs:33:13
    |
 LL |             panic!();
    |             ^^^^^^^^
 
 error: consider implementing `TryFrom` instead
-  --> tests/ui/fallible_impl_from.rs:40:1
+  --> tests/ui/fallible_impl_from.rs:39:1
    |
 LL | / impl From<Option<String>> for Invalid {
 LL | |
@@ -52,7 +52,7 @@ LL | | }
    |
    = help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail
 note: potential failure(s)
-  --> tests/ui/fallible_impl_from.rs:44:17
+  --> tests/ui/fallible_impl_from.rs:43:17
    |
 LL |         let s = s.unwrap();
    |                 ^^^^^^^^^^
@@ -65,7 +65,7 @@ LL |             panic!("{:?}", s);
    |             ^^^^^^^^^^^^^^^^^
 
 error: consider implementing `TryFrom` instead
-  --> tests/ui/fallible_impl_from.rs:60:1
+  --> tests/ui/fallible_impl_from.rs:59:1
    |
 LL | / impl<'a> From<&'a mut <Box<u32> as ProjStrTrait>::ProjString> for Invalid {
 LL | |
@@ -77,12 +77,12 @@ LL | | }
    |
    = help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail
 note: potential failure(s)
-  --> tests/ui/fallible_impl_from.rs:64:12
+  --> tests/ui/fallible_impl_from.rs:63:12
    |
 LL |         if s.parse::<u32>().ok().unwrap() != 42 {
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-LL |             panic!("{:?}", s);
-   |             ^^^^^^^^^^^^^^^^^
+LL |             panic!("{s:?}");
+   |             ^^^^^^^^^^^^^^^
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/index_refutable_slice/if_let_slice_binding.fixed b/tests/ui/index_refutable_slice/if_let_slice_binding.fixed
index 050cdfcba966e..dc7e09bbdc7d2 100644
--- a/tests/ui/index_refutable_slice/if_let_slice_binding.fixed
+++ b/tests/ui/index_refutable_slice/if_let_slice_binding.fixed
@@ -1,5 +1,5 @@
 #![deny(clippy::index_refutable_slice)]
-#![allow(clippy::uninlined_format_args, clippy::needless_lifetimes, clippy::collapsible_if)]
+#![allow(clippy::needless_lifetimes, clippy::collapsible_if)]
 
 enum SomeEnum<T> {
     One(T),
@@ -60,7 +60,7 @@ fn lintable_examples() {
 
         println!("{:?}", slice_1);
     }
-    println!("{:?}", slice);
+    println!("{slice:?}");
 
     // This should not suggest using the `ref` keyword as the scrutinee is already
     // a reference
@@ -70,7 +70,7 @@ fn lintable_examples() {
 
         println!("{:?}", slice_0);
     }
-    println!("{:?}", slice);
+    println!("{slice:?}");
 }
 
 fn slice_index_above_limit() {
@@ -113,7 +113,7 @@ fn check_slice_as_arg() {
             println!("This is interesting {}", slice[0]);
         }
     }
-    println!("{:?}", slice_wrapped);
+    println!("{slice_wrapped:?}");
 }
 
 fn check_slice_in_struct() {
@@ -152,7 +152,7 @@ fn check_slice_in_struct() {
             println!("This is super awesome! {}", slice_0);
         }
     }
-    println!("Complete wrap: {:?}", wrap);
+    println!("Complete wrap: {wrap:?}");
 }
 
 /// This would be a nice additional feature to have in the future, but adding it
@@ -164,14 +164,14 @@ fn mutable_slice_index() {
     if let Some(ref mut slice) = slice {
         slice[0] = String::from("Mr. Penguin");
     }
-    println!("Use after modification: {:?}", slice);
+    println!("Use after modification: {slice:?}");
 
     // Mut access on reference
     let mut slice: Option<[String; 1]> = Some([String::from("Cat")]);
     if let Some(slice) = &mut slice {
         slice[0] = String::from("Lord Meow Meow");
     }
-    println!("Use after modification: {:?}", slice);
+    println!("Use after modification: {slice:?}");
 }
 
 /// The lint will ignore bindings with sub patterns as it would be hard
diff --git a/tests/ui/index_refutable_slice/if_let_slice_binding.rs b/tests/ui/index_refutable_slice/if_let_slice_binding.rs
index 91429bfea2762..f39ace101b45c 100644
--- a/tests/ui/index_refutable_slice/if_let_slice_binding.rs
+++ b/tests/ui/index_refutable_slice/if_let_slice_binding.rs
@@ -1,5 +1,5 @@
 #![deny(clippy::index_refutable_slice)]
-#![allow(clippy::uninlined_format_args, clippy::needless_lifetimes, clippy::collapsible_if)]
+#![allow(clippy::needless_lifetimes, clippy::collapsible_if)]
 
 enum SomeEnum<T> {
     One(T),
@@ -60,7 +60,7 @@ fn lintable_examples() {
 
         println!("{:?}", slice[1]);
     }
-    println!("{:?}", slice);
+    println!("{slice:?}");
 
     // This should not suggest using the `ref` keyword as the scrutinee is already
     // a reference
@@ -70,7 +70,7 @@ fn lintable_examples() {
 
         println!("{:?}", slice[0]);
     }
-    println!("{:?}", slice);
+    println!("{slice:?}");
 }
 
 fn slice_index_above_limit() {
@@ -113,7 +113,7 @@ fn check_slice_as_arg() {
             println!("This is interesting {}", slice[0]);
         }
     }
-    println!("{:?}", slice_wrapped);
+    println!("{slice_wrapped:?}");
 }
 
 fn check_slice_in_struct() {
@@ -152,7 +152,7 @@ fn check_slice_in_struct() {
             println!("This is super awesome! {}", slice[0]);
         }
     }
-    println!("Complete wrap: {:?}", wrap);
+    println!("Complete wrap: {wrap:?}");
 }
 
 /// This would be a nice additional feature to have in the future, but adding it
@@ -164,14 +164,14 @@ fn mutable_slice_index() {
     if let Some(ref mut slice) = slice {
         slice[0] = String::from("Mr. Penguin");
     }
-    println!("Use after modification: {:?}", slice);
+    println!("Use after modification: {slice:?}");
 
     // Mut access on reference
     let mut slice: Option<[String; 1]> = Some([String::from("Cat")]);
     if let Some(slice) = &mut slice {
         slice[0] = String::from("Lord Meow Meow");
     }
-    println!("Use after modification: {:?}", slice);
+    println!("Use after modification: {slice:?}");
 }
 
 /// The lint will ignore bindings with sub patterns as it would be hard
diff --git a/tests/ui/infinite_iter.rs b/tests/ui/infinite_iter.rs
index 701a86534ba00..4e1668ed04fb7 100644
--- a/tests/ui/infinite_iter.rs
+++ b/tests/ui/infinite_iter.rs
@@ -1,4 +1,4 @@
-#![allow(clippy::uninlined_format_args, clippy::double_ended_iterator_last)]
+#![allow(clippy::double_ended_iterator_last)]
 
 use std::iter::repeat;
 fn square_is_lower_64(x: &u32) -> bool {
@@ -30,7 +30,7 @@ fn infinite_iters() {
         .rev()
         .cycle()
         .map(|x| x + 1_u32)
-        .for_each(|x| println!("{}", x));
+        .for_each(|x| println!("{x}"));
     // infinite iter
     (0..3_u32).flat_map(|x| x..).sum::<u32>();
     // infinite iter
diff --git a/tests/ui/infinite_iter.stderr b/tests/ui/infinite_iter.stderr
index b9e7c008f93e0..3db97313b621d 100644
--- a/tests/ui/infinite_iter.stderr
+++ b/tests/ui/infinite_iter.stderr
@@ -30,8 +30,8 @@ LL | |
 LL | |         .rev()
 LL | |         .cycle()
 LL | |         .map(|x| x + 1_u32)
-LL | |         .for_each(|x| println!("{}", x));
-   | |________________________________________^
+LL | |         .for_each(|x| println!("{x}"));
+   | |______________________________________^
 
 error: infinite iteration detected
   --> tests/ui/infinite_iter.rs:37:5
diff --git a/tests/ui/issue_2356.fixed b/tests/ui/issue_2356.fixed
index 46ba653eba2cf..3e066df77bfb4 100644
--- a/tests/ui/issue_2356.fixed
+++ b/tests/ui/issue_2356.fixed
@@ -1,6 +1,5 @@
 #![deny(clippy::while_let_on_iterator)]
 #![allow(unused_mut)]
-#![allow(clippy::uninlined_format_args)]
 
 use std::iter::Iterator;
 
@@ -16,7 +15,7 @@ impl Foo {
     fn foo2<I: Iterator<Item = usize>>(mut it: I) {
         for e in it {
             //~^ while_let_on_iterator
-            println!("{:?}", e);
+            println!("{e:?}");
         }
     }
 }
diff --git a/tests/ui/issue_2356.rs b/tests/ui/issue_2356.rs
index defe2584a93e1..98600d17c6df7 100644
--- a/tests/ui/issue_2356.rs
+++ b/tests/ui/issue_2356.rs
@@ -1,6 +1,5 @@
 #![deny(clippy::while_let_on_iterator)]
 #![allow(unused_mut)]
-#![allow(clippy::uninlined_format_args)]
 
 use std::iter::Iterator;
 
@@ -16,7 +15,7 @@ impl Foo {
     fn foo2<I: Iterator<Item = usize>>(mut it: I) {
         while let Some(e) = it.next() {
             //~^ while_let_on_iterator
-            println!("{:?}", e);
+            println!("{e:?}");
         }
     }
 }
diff --git a/tests/ui/issue_2356.stderr b/tests/ui/issue_2356.stderr
index eae2ce97fc6b1..ddee91fcfcd52 100644
--- a/tests/ui/issue_2356.stderr
+++ b/tests/ui/issue_2356.stderr
@@ -1,5 +1,5 @@
 error: this loop could be written as a `for` loop
-  --> tests/ui/issue_2356.rs:17:9
+  --> tests/ui/issue_2356.rs:16:9
    |
 LL |         while let Some(e) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for e in it`
diff --git a/tests/ui/issue_4266.rs b/tests/ui/issue_4266.rs
index 664f0b84a2077..b2a01124995c5 100644
--- a/tests/ui/issue_4266.rs
+++ b/tests/ui/issue_4266.rs
@@ -1,5 +1,4 @@
 #![allow(dead_code)]
-#![allow(clippy::uninlined_format_args)]
 
 async fn sink1<'a>(_: &'a str) {} // lint
 //~^ needless_lifetimes
@@ -39,7 +38,7 @@ impl Foo {
 // rust-lang/rust#61115
 // ok
 async fn print(s: &str) {
-    println!("{}", s);
+    println!("{s}");
 }
 
 fn main() {}
diff --git a/tests/ui/issue_4266.stderr b/tests/ui/issue_4266.stderr
index 0e181025430f3..b80a738a50bee 100644
--- a/tests/ui/issue_4266.stderr
+++ b/tests/ui/issue_4266.stderr
@@ -1,5 +1,5 @@
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/issue_4266.rs:4:16
+  --> tests/ui/issue_4266.rs:3:16
    |
 LL | async fn sink1<'a>(_: &'a str) {} // lint
    |                ^^      ^^
@@ -8,13 +8,13 @@ LL | async fn sink1<'a>(_: &'a str) {} // lint
    = help: to override `-D warnings` add `#[allow(clippy::needless_lifetimes)]`
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/issue_4266.rs:10:21
+  --> tests/ui/issue_4266.rs:9:21
    |
 LL | async fn one_to_one<'a>(s: &'a str) -> &'a str {
    |                     ^^      ^^          ^^
 
 error: methods called `new` usually take no `self`
-  --> tests/ui/issue_4266.rs:32:22
+  --> tests/ui/issue_4266.rs:31:22
    |
 LL |     pub async fn new(&mut self) -> Self {
    |                      ^^^^^^^^^
diff --git a/tests/ui/match_single_binding.fixed b/tests/ui/match_single_binding.fixed
index e29fb87dbc300..7e899a4766661 100644
--- a/tests/ui/match_single_binding.fixed
+++ b/tests/ui/match_single_binding.fixed
@@ -4,7 +4,6 @@
     clippy::let_unit_value,
     clippy::no_effect,
     clippy::toplevel_ref_arg,
-    clippy::uninlined_format_args,
     clippy::useless_vec
 )]
 
@@ -32,11 +31,11 @@ fn main() {
     // Lint
     let (x, y, z) = (a, b, c);
     {
-        println!("{} {} {}", x, y, z);
+        println!("{x} {y} {z}");
     }
     // Lint
     let (x, y, z) = (a, b, c);
-    println!("{} {} {}", x, y, z);
+    println!("{x} {y} {z}");
     // Ok
     foo!(a);
     // Ok
@@ -47,7 +46,7 @@ fn main() {
     // Ok
     let d = Some(5);
     match d {
-        Some(d) => println!("{}", d),
+        Some(d) => println!("{d}"),
         _ => println!("None"),
     }
     // Lint
@@ -55,7 +54,7 @@ fn main() {
     // Lint
     {
         let x = 29;
-        println!("x has a value of {}", x);
+        println!("x has a value of {x}");
     }
     // Lint
     {
@@ -67,18 +66,18 @@ fn main() {
     // Lint
     let p = Point { x: 0, y: 7 };
     let Point { x, y } = p;
-    println!("Coords: ({}, {})", x, y);
+    println!("Coords: ({x}, {y})");
     // Lint
     let Point { x: x1, y: y1 } = p;
-    println!("Coords: ({}, {})", x1, y1);
+    println!("Coords: ({x1}, {y1})");
     // Lint
     let x = 5;
     let ref r = x;
-    println!("Got a reference to {}", r);
+    println!("Got a reference to {r}");
     // Lint
     let mut x = 5;
     let ref mut mr = x;
-    println!("Got a mutable reference to {}", mr);
+    println!("Got a mutable reference to {mr}");
     // Lint
     let Point { x, y } = coords();
     let product = x * y;
@@ -122,7 +121,7 @@ fn issue_8723() {
 
     let (pre, suf) = val.split_at(idx);
     val = {
-        println!("{}", pre);
+        println!("{pre}");
         suf
     };
 
@@ -210,20 +209,20 @@ mod issue15018 {
         let x = 1;
         {
             let (x, y, z) = (a, b, c);
-            println!("{} {} {}", x, y, z);
+            println!("{x} {y} {z}");
         }
         println!("x = {x}");
     }
 
     fn not_used_later(a: i32, b: i32, c: i32) {
         let (x, y, z) = (a, b, c);
-        println!("{} {} {}", x, y, z)
+        println!("{x} {y} {z}")
     }
 
     #[allow(irrefutable_let_patterns)]
     fn not_used_later_but_shadowed(a: i32, b: i32, c: i32) {
         let (x, y, z) = (a, b, c);
-        println!("{} {} {}", x, y, z);
+        println!("{x} {y} {z}");
         let x = 1;
         println!("x = {x}");
     }
@@ -231,27 +230,27 @@ mod issue15018 {
     #[allow(irrefutable_let_patterns)]
     fn not_used_later_but_shadowed_nested(a: i32, b: i32, c: i32) {
         let (x, y, z) = (a, b, c);
-        println!("{} {} {}", x, y, z);
+        println!("{x} {x} {y}");
         if let (x, y, z) = (a, b, c) {
-            println!("{} {} {}", x, y, z)
+            println!("{x} {y} {z}")
         }
 
         {
             let x: i32 = 1;
             {
                 let (x, y, z) = (a, b, c);
-                println!("{} {} {}", x, y, z);
+                println!("{x} {y} {z}");
             }
             if let (x, y, z) = (a, x, c) {
-                println!("{} {} {}", x, y, z)
+                println!("{x} {y} {z}")
             }
         }
 
         {
             let (x, y, z) = (a, b, c);
-            println!("{} {} {}", x, y, z);
+            println!("{x} {y} {z}");
             let fn_ = |y| {
-                println!("{} {} {}", a, b, y);
+                println!("{a} {b} {y}");
             };
             fn_(c);
         }
diff --git a/tests/ui/match_single_binding.rs b/tests/ui/match_single_binding.rs
index ede1ab32beb5f..37a96f2287c85 100644
--- a/tests/ui/match_single_binding.rs
+++ b/tests/ui/match_single_binding.rs
@@ -4,7 +4,6 @@
     clippy::let_unit_value,
     clippy::no_effect,
     clippy::toplevel_ref_arg,
-    clippy::uninlined_format_args,
     clippy::useless_vec
 )]
 
@@ -33,13 +32,13 @@ fn main() {
     match (a, b, c) {
         //~^ match_single_binding
         (x, y, z) => {
-            println!("{} {} {}", x, y, z);
+            println!("{x} {y} {z}");
         },
     }
     // Lint
     match (a, b, c) {
         //~^ match_single_binding
-        (x, y, z) => println!("{} {} {}", x, y, z),
+        (x, y, z) => println!("{x} {y} {z}"),
     }
     // Ok
     foo!(a);
@@ -51,7 +50,7 @@ fn main() {
     // Ok
     let d = Some(5);
     match d {
-        Some(d) => println!("{}", d),
+        Some(d) => println!("{d}"),
         _ => println!("None"),
     }
     // Lint
@@ -64,7 +63,7 @@ fn main() {
         //~^ match_single_binding
         _ => {
             let x = 29;
-            println!("x has a value of {}", x);
+            println!("x has a value of {x}");
         },
     }
     // Lint
@@ -81,24 +80,24 @@ fn main() {
     let p = Point { x: 0, y: 7 };
     match p {
         //~^ match_single_binding
-        Point { x, y } => println!("Coords: ({}, {})", x, y),
+        Point { x, y } => println!("Coords: ({x}, {y})"),
     }
     // Lint
     match p {
         //~^ match_single_binding
-        Point { x: x1, y: y1 } => println!("Coords: ({}, {})", x1, y1),
+        Point { x: x1, y: y1 } => println!("Coords: ({x1}, {y1})"),
     }
     // Lint
     let x = 5;
     match x {
         //~^ match_single_binding
-        ref r => println!("Got a reference to {}", r),
+        ref r => println!("Got a reference to {r}"),
     }
     // Lint
     let mut x = 5;
     match x {
         //~^ match_single_binding
-        ref mut mr => println!("Got a mutable reference to {}", mr),
+        ref mut mr => println!("Got a mutable reference to {mr}"),
     }
     // Lint
     let product = match coords() {
@@ -150,7 +149,7 @@ fn issue_8723() {
     val = match val.split_at(idx) {
         //~^ match_single_binding
         (pre, suf) => {
-            println!("{}", pre);
+            println!("{pre}");
             suf
         },
     };
@@ -273,7 +272,7 @@ mod issue15018 {
         let x = 1;
         match (a, b, c) {
             //~^ match_single_binding
-            (x, y, z) => println!("{} {} {}", x, y, z),
+            (x, y, z) => println!("{x} {y} {z}"),
         }
         println!("x = {x}");
     }
@@ -281,7 +280,7 @@ mod issue15018 {
     fn not_used_later(a: i32, b: i32, c: i32) {
         match (a, b, c) {
             //~^ match_single_binding
-            (x, y, z) => println!("{} {} {}", x, y, z),
+            (x, y, z) => println!("{x} {y} {z}"),
         }
     }
 
@@ -289,7 +288,7 @@ mod issue15018 {
     fn not_used_later_but_shadowed(a: i32, b: i32, c: i32) {
         match (a, b, c) {
             //~^ match_single_binding
-            (x, y, z) => println!("{} {} {}", x, y, z),
+            (x, y, z) => println!("{x} {y} {z}"),
         }
         let x = 1;
         println!("x = {x}");
@@ -299,30 +298,30 @@ mod issue15018 {
     fn not_used_later_but_shadowed_nested(a: i32, b: i32, c: i32) {
         match (a, b, c) {
             //~^ match_single_binding
-            (x, y, z) => println!("{} {} {}", x, y, z),
+            (x, y, z) => println!("{x} {x} {y}"),
         }
         if let (x, y, z) = (a, b, c) {
-            println!("{} {} {}", x, y, z)
+            println!("{x} {y} {z}")
         }
 
         {
             let x: i32 = 1;
             match (a, b, c) {
                 //~^ match_single_binding
-                (x, y, z) => println!("{} {} {}", x, y, z),
+                (x, y, z) => println!("{x} {y} {z}"),
             }
             if let (x, y, z) = (a, x, c) {
-                println!("{} {} {}", x, y, z)
+                println!("{x} {y} {z}")
             }
         }
 
         {
             match (a, b, c) {
                 //~^ match_single_binding
-                (x, y, z) => println!("{} {} {}", x, y, z),
+                (x, y, z) => println!("{x} {y} {z}"),
             }
             let fn_ = |y| {
-                println!("{} {} {}", a, b, y);
+                println!("{a} {b} {y}");
             };
             fn_(c);
         }
diff --git a/tests/ui/match_single_binding.stderr b/tests/ui/match_single_binding.stderr
index eea71777890e5..82fc43aaa5eae 100644
--- a/tests/ui/match_single_binding.stderr
+++ b/tests/ui/match_single_binding.stderr
@@ -1,10 +1,10 @@
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding.rs:33:5
+  --> tests/ui/match_single_binding.rs:32:5
    |
 LL | /     match (a, b, c) {
 LL | |
 LL | |         (x, y, z) => {
-LL | |             println!("{} {} {}", x, y, z);
+LL | |             println!("{x} {y} {z}");
 LL | |         },
 LL | |     }
    | |_____^
@@ -15,27 +15,27 @@ help: consider using a `let` statement
    |
 LL ~     let (x, y, z) = (a, b, c);
 LL +     {
-LL +         println!("{} {} {}", x, y, z);
+LL +         println!("{x} {y} {z}");
 LL +     }
    |
 
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding.rs:40:5
+  --> tests/ui/match_single_binding.rs:39:5
    |
 LL | /     match (a, b, c) {
 LL | |
-LL | |         (x, y, z) => println!("{} {} {}", x, y, z),
+LL | |         (x, y, z) => println!("{x} {y} {z}"),
 LL | |     }
    | |_____^
    |
 help: consider using a `let` statement
    |
 LL ~     let (x, y, z) = (a, b, c);
-LL +     println!("{} {} {}", x, y, z);
+LL +     println!("{x} {y} {z}");
    |
 
 error: this match could be replaced by its body itself
-  --> tests/ui/match_single_binding.rs:58:5
+  --> tests/ui/match_single_binding.rs:57:5
    |
 LL | /     match a {
 LL | |
@@ -44,13 +44,13 @@ LL | |     }
    | |_____^ help: consider using the match body instead: `println!("whatever");`
 
 error: this match could be replaced by its body itself
-  --> tests/ui/match_single_binding.rs:63:5
+  --> tests/ui/match_single_binding.rs:62:5
    |
 LL | /     match a {
 LL | |
 LL | |         _ => {
 LL | |             let x = 29;
-LL | |             println!("x has a value of {}", x);
+LL | |             println!("x has a value of {x}");
 LL | |         },
 LL | |     }
    | |_____^
@@ -59,12 +59,12 @@ help: consider using the match body instead
    |
 LL ~     {
 LL +         let x = 29;
-LL +         println!("x has a value of {}", x);
+LL +         println!("x has a value of {x}");
 LL +     }
    |
 
 error: this match could be replaced by its body itself
-  --> tests/ui/match_single_binding.rs:71:5
+  --> tests/ui/match_single_binding.rs:70:5
    |
 LL | /     match a {
 LL | |
@@ -86,67 +86,67 @@ LL +     }
    |
 
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding.rs:82:5
+  --> tests/ui/match_single_binding.rs:81:5
    |
 LL | /     match p {
 LL | |
-LL | |         Point { x, y } => println!("Coords: ({}, {})", x, y),
+LL | |         Point { x, y } => println!("Coords: ({x}, {y})"),
 LL | |     }
    | |_____^
    |
 help: consider using a `let` statement
    |
 LL ~     let Point { x, y } = p;
-LL +     println!("Coords: ({}, {})", x, y);
+LL +     println!("Coords: ({x}, {y})");
    |
 
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding.rs:87:5
+  --> tests/ui/match_single_binding.rs:86:5
    |
 LL | /     match p {
 LL | |
-LL | |         Point { x: x1, y: y1 } => println!("Coords: ({}, {})", x1, y1),
+LL | |         Point { x: x1, y: y1 } => println!("Coords: ({x1}, {y1})"),
 LL | |     }
    | |_____^
    |
 help: consider using a `let` statement
    |
 LL ~     let Point { x: x1, y: y1 } = p;
-LL +     println!("Coords: ({}, {})", x1, y1);
+LL +     println!("Coords: ({x1}, {y1})");
    |
 
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding.rs:93:5
+  --> tests/ui/match_single_binding.rs:92:5
    |
 LL | /     match x {
 LL | |
-LL | |         ref r => println!("Got a reference to {}", r),
+LL | |         ref r => println!("Got a reference to {r}"),
 LL | |     }
    | |_____^
    |
 help: consider using a `let` statement
    |
 LL ~     let ref r = x;
-LL +     println!("Got a reference to {}", r);
+LL +     println!("Got a reference to {r}");
    |
 
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding.rs:99:5
+  --> tests/ui/match_single_binding.rs:98:5
    |
 LL | /     match x {
 LL | |
-LL | |         ref mut mr => println!("Got a mutable reference to {}", mr),
+LL | |         ref mut mr => println!("Got a mutable reference to {mr}"),
 LL | |     }
    | |_____^
    |
 help: consider using a `let` statement
    |
 LL ~     let ref mut mr = x;
-LL +     println!("Got a mutable reference to {}", mr);
+LL +     println!("Got a mutable reference to {mr}");
    |
 
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding.rs:104:5
+  --> tests/ui/match_single_binding.rs:103:5
    |
 LL | /     let product = match coords() {
 LL | |
@@ -161,7 +161,7 @@ LL +     let product = x * y;
    |
 
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding.rs:113:18
+  --> tests/ui/match_single_binding.rs:112:18
    |
 LL |           .map(|i| match i.unwrap() {
    |  __________________^
@@ -179,7 +179,7 @@ LL ~         })
    |
 
 error: this match could be replaced by its body itself
-  --> tests/ui/match_single_binding.rs:140:5
+  --> tests/ui/match_single_binding.rs:139:5
    |
 LL | /     match x {
 LL | |
@@ -189,12 +189,12 @@ LL | |     }
    | |_____^ help: consider using the match body instead: `println!("Not an array index start")`
 
 error: this assignment could be simplified
-  --> tests/ui/match_single_binding.rs:150:5
+  --> tests/ui/match_single_binding.rs:149:5
    |
 LL | /     val = match val.split_at(idx) {
 LL | |
 LL | |         (pre, suf) => {
-LL | |             println!("{}", pre);
+LL | |             println!("{pre}");
 LL | |             suf
 LL | |         },
 LL | |     };
@@ -204,13 +204,13 @@ help: consider removing the `match` expression
    |
 LL ~     let (pre, suf) = val.split_at(idx);
 LL +     val = {
-LL +         println!("{}", pre);
+LL +         println!("{pre}");
 LL +         suf
 LL ~     };
    |
 
 error: this match could be replaced by its scrutinee and body
-  --> tests/ui/match_single_binding.rs:164:16
+  --> tests/ui/match_single_binding.rs:163:16
    |
 LL |       let _ = || match side_effects() {
    |  ________________^
@@ -228,7 +228,7 @@ LL ~     };
    |
 
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding.rs:171:5
+  --> tests/ui/match_single_binding.rs:170:5
    |
 LL | /     match r {
 LL | |
@@ -253,7 +253,7 @@ LL ~     };
    |
 
 error: this match could be replaced by its body itself
-  --> tests/ui/match_single_binding.rs:185:5
+  --> tests/ui/match_single_binding.rs:184:5
    |
 LL | /     match 1 {
 LL | |
@@ -262,7 +262,7 @@ LL | |     }
    | |_____^ help: consider using the match body instead: `();`
 
 error: this match could be replaced by its body itself
-  --> tests/ui/match_single_binding.rs:190:13
+  --> tests/ui/match_single_binding.rs:189:13
    |
 LL |       let a = match 1 {
    |  _____________^
@@ -272,7 +272,7 @@ LL | |     };
    | |_____^ help: consider using the match body instead: `()`
 
 error: this match could be replaced by its body itself
-  --> tests/ui/match_single_binding.rs:195:5
+  --> tests/ui/match_single_binding.rs:194:5
    |
 LL | /     match 1 {
 LL | |
@@ -281,7 +281,7 @@ LL | |     }
    | |_____^ help: consider using the match body instead: `side_effects();`
 
 error: this match could be replaced by its body itself
-  --> tests/ui/match_single_binding.rs:200:13
+  --> tests/ui/match_single_binding.rs:199:13
    |
 LL |       let b = match 1 {
    |  _____________^
@@ -291,7 +291,7 @@ LL | |     };
    | |_____^ help: consider using the match body instead: `side_effects()`
 
 error: this match could be replaced by its body itself
-  --> tests/ui/match_single_binding.rs:205:5
+  --> tests/ui/match_single_binding.rs:204:5
    |
 LL | /     match 1 {
 LL | |
@@ -300,7 +300,7 @@ LL | |     }
    | |_____^ help: consider using the match body instead: `println!("1");`
 
 error: this match could be replaced by its body itself
-  --> tests/ui/match_single_binding.rs:210:13
+  --> tests/ui/match_single_binding.rs:209:13
    |
 LL |       let c = match 1 {
    |  _____________^
@@ -310,7 +310,7 @@ LL | |     };
    | |_____^ help: consider using the match body instead: `println!("1")`
 
 error: this match could be replaced by its body itself
-  --> tests/ui/match_single_binding.rs:216:9
+  --> tests/ui/match_single_binding.rs:215:9
    |
 LL | /         match 1 {
 LL | |
@@ -319,7 +319,7 @@ LL | |         },
    | |_________^ help: consider using the match body instead: `()`
 
 error: this match could be replaced by its body itself
-  --> tests/ui/match_single_binding.rs:220:9
+  --> tests/ui/match_single_binding.rs:219:9
    |
 LL | /         match 1 {
 LL | |
@@ -328,7 +328,7 @@ LL | |         },
    | |_________^ help: consider using the match body instead: `side_effects()`
 
 error: this match could be replaced by its body itself
-  --> tests/ui/match_single_binding.rs:224:9
+  --> tests/ui/match_single_binding.rs:223:9
    |
 LL | /         match 1 {
 LL | |
@@ -337,7 +337,7 @@ LL | |         },
    | |_________^ help: consider using the match body instead: `println!("1")`
 
 error: this match could be replaced by its scrutinee and body
-  --> tests/ui/match_single_binding.rs:239:5
+  --> tests/ui/match_single_binding.rs:238:5
    |
 LL | /     match dbg!(3) {
 LL | |         _ => println!("here"),
@@ -351,7 +351,7 @@ LL +     println!("here");
    |
 
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding.rs:243:5
+  --> tests/ui/match_single_binding.rs:242:5
    |
 LL | /     match dbg!(3) {
 LL | |         id!(a) => println!("found {a}"),
@@ -365,7 +365,7 @@ LL +     println!("found {a}");
    |
 
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding.rs:247:5
+  --> tests/ui/match_single_binding.rs:246:5
    |
 LL | /     let id!(_a) = match dbg!(3) {
 LL | |         id!(b) => dbg!(b + 1),
@@ -379,7 +379,7 @@ LL +     let id!(_a) = dbg!(b + 1);
    |
 
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding.rs:255:21
+  --> tests/ui/match_single_binding.rs:254:21
    |
 LL |           inner: [(); match 1 {
    |  _____________________^
@@ -397,7 +397,7 @@ LL ~         }],
    |
 
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding.rs:263:13
+  --> tests/ui/match_single_binding.rs:262:13
    |
 LL | /             match 1 {
 LL | |
@@ -412,11 +412,11 @@ LL +             42
    |
 
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding.rs:274:9
+  --> tests/ui/match_single_binding.rs:273:9
    |
 LL | /         match (a, b, c) {
 LL | |
-LL | |             (x, y, z) => println!("{} {} {}", x, y, z),
+LL | |             (x, y, z) => println!("{x} {y} {z}"),
 LL | |         }
    | |_________^
    |
@@ -424,61 +424,61 @@ help: consider using a `let` statement
    |
 LL ~         {
 LL +             let (x, y, z) = (a, b, c);
-LL +             println!("{} {} {}", x, y, z);
+LL +             println!("{x} {y} {z}");
 LL +         }
    |
 
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding.rs:282:9
+  --> tests/ui/match_single_binding.rs:281:9
    |
 LL | /         match (a, b, c) {
 LL | |
-LL | |             (x, y, z) => println!("{} {} {}", x, y, z),
+LL | |             (x, y, z) => println!("{x} {y} {z}"),
 LL | |         }
    | |_________^
    |
 help: consider using a `let` statement
    |
 LL ~         let (x, y, z) = (a, b, c);
-LL +         println!("{} {} {}", x, y, z)
+LL +         println!("{x} {y} {z}")
    |
 
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding.rs:290:9
+  --> tests/ui/match_single_binding.rs:289:9
    |
 LL | /         match (a, b, c) {
 LL | |
-LL | |             (x, y, z) => println!("{} {} {}", x, y, z),
+LL | |             (x, y, z) => println!("{x} {y} {z}"),
 LL | |         }
    | |_________^
    |
 help: consider using a `let` statement
    |
 LL ~         let (x, y, z) = (a, b, c);
-LL +         println!("{} {} {}", x, y, z);
+LL +         println!("{x} {y} {z}");
    |
 
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding.rs:300:9
+  --> tests/ui/match_single_binding.rs:299:9
    |
 LL | /         match (a, b, c) {
 LL | |
-LL | |             (x, y, z) => println!("{} {} {}", x, y, z),
+LL | |             (x, y, z) => println!("{x} {x} {y}"),
 LL | |         }
    | |_________^
    |
 help: consider using a `let` statement
    |
 LL ~         let (x, y, z) = (a, b, c);
-LL +         println!("{} {} {}", x, y, z);
+LL +         println!("{x} {x} {y}");
    |
 
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding.rs:310:13
+  --> tests/ui/match_single_binding.rs:309:13
    |
 LL | /             match (a, b, c) {
 LL | |
-LL | |                 (x, y, z) => println!("{} {} {}", x, y, z),
+LL | |                 (x, y, z) => println!("{x} {y} {z}"),
 LL | |             }
    | |_____________^
    |
@@ -486,27 +486,27 @@ help: consider using a `let` statement
    |
 LL ~             {
 LL +                 let (x, y, z) = (a, b, c);
-LL +                 println!("{} {} {}", x, y, z);
+LL +                 println!("{x} {y} {z}");
 LL +             }
    |
 
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding.rs:320:13
+  --> tests/ui/match_single_binding.rs:319:13
    |
 LL | /             match (a, b, c) {
 LL | |
-LL | |                 (x, y, z) => println!("{} {} {}", x, y, z),
+LL | |                 (x, y, z) => println!("{x} {y} {z}"),
 LL | |             }
    | |_____________^
    |
 help: consider using a `let` statement
    |
 LL ~             let (x, y, z) = (a, b, c);
-LL +             println!("{} {} {}", x, y, z);
+LL +             println!("{x} {y} {z}");
    |
 
 error: this match could be replaced by its body itself
-  --> tests/ui/match_single_binding.rs:335:12
+  --> tests/ui/match_single_binding.rs:334:12
    |
 LL |           && match b {
    |  ____________^
@@ -516,7 +516,7 @@ LL | |         };
    | |_________^ help: consider using the match body instead: `b < c`
 
 error: this match could be replaced by its body itself
-  --> tests/ui/match_single_binding.rs:341:12
+  --> tests/ui/match_single_binding.rs:340:12
    |
 LL |           && match (a, b) {
    |  ____________^
diff --git a/tests/ui/match_single_binding2.fixed b/tests/ui/match_single_binding2.fixed
index 988121f50d0fa..f00987470ae1b 100644
--- a/tests/ui/match_single_binding2.fixed
+++ b/tests/ui/match_single_binding2.fixed
@@ -1,6 +1,5 @@
 #![warn(clippy::match_single_binding)]
 #![allow(unused_variables)]
-#![allow(clippy::uninlined_format_args)]
 
 fn main() {
     // Lint (additional curly braces needed, see #6572)
@@ -29,7 +28,7 @@ fn main() {
         #[rustfmt::skip]
         Some((first, _second)) => {
             let (a, b) = get_tup();
-            println!("a {:?} and b {:?}", a, b)
+            println!("a {a:?} and b {b:?}")
         },
         None => println!("nothing"),
     }
diff --git a/tests/ui/match_single_binding2.rs b/tests/ui/match_single_binding2.rs
index a4fb2bd6f3817..5416f647b4e6c 100644
--- a/tests/ui/match_single_binding2.rs
+++ b/tests/ui/match_single_binding2.rs
@@ -1,6 +1,5 @@
 #![warn(clippy::match_single_binding)]
 #![allow(unused_variables)]
-#![allow(clippy::uninlined_format_args)]
 
 fn main() {
     // Lint (additional curly braces needed, see #6572)
@@ -30,7 +29,7 @@ fn main() {
         Some((first, _second)) => {
             match get_tup() {
             //~^ match_single_binding
-                (a, b) => println!("a {:?} and b {:?}", a, b),
+                (a, b) => println!("a {a:?} and b {b:?}"),
             }
         },
         None => println!("nothing"),
diff --git a/tests/ui/match_single_binding2.stderr b/tests/ui/match_single_binding2.stderr
index a24cbe3eed766..65b8aa6acd5e1 100644
--- a/tests/ui/match_single_binding2.stderr
+++ b/tests/ui/match_single_binding2.stderr
@@ -1,5 +1,5 @@
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding2.rs:17:36
+  --> tests/ui/match_single_binding2.rs:16:36
    |
 LL |               Some((iter, _item)) => match iter.size_hint() {
    |  ____________________________________^
@@ -19,22 +19,22 @@ LL ~             },
    |
 
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding2.rs:31:13
+  --> tests/ui/match_single_binding2.rs:30:13
    |
 LL | /             match get_tup() {
 LL | |
-LL | |                 (a, b) => println!("a {:?} and b {:?}", a, b),
+LL | |                 (a, b) => println!("a {a:?} and b {b:?}"),
 LL | |             }
    | |_____________^
    |
 help: consider using a `let` statement
    |
 LL ~             let (a, b) = get_tup();
-LL +             println!("a {:?} and b {:?}", a, b)
+LL +             println!("a {a:?} and b {b:?}")
    |
 
 error: this match could be replaced by its scrutinee and body
-  --> tests/ui/match_single_binding2.rs:43:5
+  --> tests/ui/match_single_binding2.rs:42:5
    |
 LL | /     match side_effects() {
 LL | |
@@ -49,7 +49,7 @@ LL +     println!("Side effects");
    |
 
 error: this match could be replaced by its scrutinee and body
-  --> tests/ui/match_single_binding2.rs:51:5
+  --> tests/ui/match_single_binding2.rs:50:5
    |
 LL | /     match match x {
 LL | |

From f9852613a965f2f3daccec46d63b85fb0407960d Mon Sep 17 00:00:00 2001
From: yanglsh <yanglsh@shanghaitech.edu.cn>
Date: Mon, 25 Aug 2025 08:32:42 +0800
Subject: [PATCH 1600/1889] fix: `mem_replace_with_default` wrongly unmangled
 macros

---
 clippy_lints/src/mem_replace.rs | 13 +++++--------
 tests/ui/mem_replace.fixed      |  6 ++++++
 tests/ui/mem_replace.rs         |  6 ++++++
 tests/ui/mem_replace.stderr     |  8 +++++++-
 4 files changed, 24 insertions(+), 9 deletions(-)

diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index e39916f733d59..95ecef5987007 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -1,7 +1,7 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::source::{snippet, snippet_with_applicability};
+use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_non_aggregate_primitive_type;
 use clippy_utils::{
@@ -269,14 +269,11 @@ fn check_replace_with_default(
             ),
             |diag| {
                 if !expr.span.from_expansion() {
-                    let suggestion = format!("{top_crate}::mem::take({})", snippet(cx, dest.span, ""));
+                    let mut applicability = Applicability::MachineApplicable;
+                    let (dest_snip, _) = snippet_with_context(cx, dest.span, expr.span.ctxt(), "", &mut applicability);
+                    let suggestion = format!("{top_crate}::mem::take({dest_snip})");
 
-                    diag.span_suggestion(
-                        expr.span,
-                        "consider using",
-                        suggestion,
-                        Applicability::MachineApplicable,
-                    );
+                    diag.span_suggestion(expr.span, "consider using", suggestion, applicability);
                 }
             },
         );
diff --git a/tests/ui/mem_replace.fixed b/tests/ui/mem_replace.fixed
index 870ef23113a2f..94ad1aad3eb75 100644
--- a/tests/ui/mem_replace.fixed
+++ b/tests/ui/mem_replace.fixed
@@ -179,3 +179,9 @@ fn mem_replace_option_with_some_bad_msrv() {
     let mut an_option = Some(0);
     let replaced = mem::replace(&mut an_option, Some(1));
 }
+
+fn issue15785() {
+    let mut text = String::from("foo");
+    let replaced = std::mem::take(dbg!(&mut text));
+    //~^ mem_replace_with_default
+}
diff --git a/tests/ui/mem_replace.rs b/tests/ui/mem_replace.rs
index b4ed5eafea953..ac79660f0f1ee 100644
--- a/tests/ui/mem_replace.rs
+++ b/tests/ui/mem_replace.rs
@@ -179,3 +179,9 @@ fn mem_replace_option_with_some_bad_msrv() {
     let mut an_option = Some(0);
     let replaced = mem::replace(&mut an_option, Some(1));
 }
+
+fn issue15785() {
+    let mut text = String::from("foo");
+    let replaced = std::mem::replace(dbg!(&mut text), String::default());
+    //~^ mem_replace_with_default
+}
diff --git a/tests/ui/mem_replace.stderr b/tests/ui/mem_replace.stderr
index fb4a367266d30..104c985400282 100644
--- a/tests/ui/mem_replace.stderr
+++ b/tests/ui/mem_replace.stderr
@@ -181,5 +181,11 @@ error: replacing an `Option` with `Some(..)`
 LL |     let replaced = mem::replace(if b { &mut opt1 } else { &mut opt2 }, Some(1));
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider `Option::replace()` instead: `(if b { &mut opt1 } else { &mut opt2 }).replace(1)`
 
-error: aborting due to 29 previous errors
+error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
+  --> tests/ui/mem_replace.rs:185:20
+   |
+LL |     let replaced = std::mem::replace(dbg!(&mut text), String::default());
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(dbg!(&mut text))`
+
+error: aborting due to 30 previous errors
 

From d1bbd39c59523d7a5499816a9da200a5910f8b7f Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Sun, 28 Sep 2025 23:04:55 +0000
Subject: [PATCH 1601/1889] Split Bound into Canonical and Bound

---
 compiler/rustc_borrowck/src/lib.rs            |  2 +-
 .../src/collect/item_bounds.rs                | 16 ++--
 .../src/hir_ty_lowering/bounds.rs             |  6 +-
 .../src/infer/canonical/canonicalizer.rs      | 53 ++++---------
 .../src/infer/canonical/instantiate.rs        | 74 +++++--------------
 .../src/infer/canonical/query_response.rs     | 18 ++---
 .../src/infer/outlives/test_type_match.rs     |  6 +-
 compiler/rustc_middle/src/ty/consts.rs        | 14 +++-
 compiler/rustc_middle/src/ty/context.rs       | 47 +++++++++++-
 compiler/rustc_middle/src/ty/fold.rs          | 14 +++-
 compiler/rustc_middle/src/ty/print/pretty.rs  |  4 +-
 compiler/rustc_middle/src/ty/region.rs        | 36 +++++++--
 compiler/rustc_middle/src/ty/sty.rs           | 22 +++++-
 .../rustc_middle/src/ty/typeck_results.rs     | 12 +--
 compiler/rustc_middle/src/ty/visit.rs         |  6 +-
 .../src/canonical/canonicalizer.rs            | 34 ++-------
 .../src/canonical/mod.rs                      | 12 +--
 .../src/placeholder.rs                        | 18 +++--
 .../src/unstable/convert/stable/ty.rs         |  7 +-
 .../src/cfi/typeid/itanium_cxx_abi/encode.rs  |  5 +-
 compiler/rustc_symbol_mangling/src/v0.rs      |  5 +-
 .../src/traits/dyn_compatibility.rs           |  2 +-
 .../src/traits/query/normalize.rs             |  4 +-
 compiler/rustc_ty_utils/src/ty.rs             |  2 +-
 compiler/rustc_type_ir/src/binder.rs          | 43 ++++++++++-
 compiler/rustc_type_ir/src/canonical.rs       | 23 +++---
 compiler/rustc_type_ir/src/const_kind.rs      |  4 +-
 compiler/rustc_type_ir/src/flags.rs           | 18 ++++-
 compiler/rustc_type_ir/src/fold.rs            | 24 ++++--
 compiler/rustc_type_ir/src/inherent.rs        |  6 ++
 compiler/rustc_type_ir/src/lib.rs             | 17 +++--
 compiler/rustc_type_ir/src/region_kind.rs     |  4 +-
 compiler/rustc_type_ir/src/ty_kind.rs         |  4 +-
 compiler/rustc_type_ir/src/ty_kind/closure.rs |  5 +-
 .../clippy_lints/src/pass_by_ref_or_value.rs  |  4 +-
 src/tools/clippy/clippy_utils/src/ty/mod.rs   |  4 +-
 ..._of_reborrow.SimplifyCfg-initial.after.mir | 18 ++---
 ...st-mono-higher-ranked-hang.current.stderr} |  6 +-
 .../post-mono-higher-ranked-hang.next.stderr  | 21 ++++++
 .../post-mono-higher-ranked-hang.rs           |  4 +
 .../trait-bounds/issue-59311.stderr           |  2 +-
 .../trait-bounds/trivial-does-not-hold.stderr |  2 +-
 tests/ui/lifetimes/re-empty-in-error.stderr   |  2 +-
 .../ui/nll/user-annotations/dump-fn-method.rs |  4 +-
 .../user-annotations/dump-fn-method.stderr    |  4 +-
 45 files changed, 391 insertions(+), 247 deletions(-)
 rename tests/ui/async-await/async-closures/{post-mono-higher-ranked-hang.stderr => post-mono-higher-ranked-hang.current.stderr} (85%)
 create mode 100644 tests/ui/async-await/async-closures/post-mono-higher-ranked-hang.next.stderr

diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs
index 4c380ddcf7084..8b23bc2822bf3 100644
--- a/compiler/rustc_borrowck/src/lib.rs
+++ b/compiler/rustc_borrowck/src/lib.rs
@@ -278,7 +278,7 @@ impl<'tcx> ClosureOutlivesSubjectTy<'tcx> {
         mut map: impl FnMut(ty::RegionVid) -> ty::Region<'tcx>,
     ) -> Ty<'tcx> {
         fold_regions(tcx, self.inner, |r, depth| match r.kind() {
-            ty::ReBound(debruijn, br) => {
+            ty::ReBound(ty::BoundVarIndexKind::Bound(debruijn), br) => {
                 debug_assert_eq!(debruijn, depth);
                 map(ty::RegionVid::from_usize(br.var.index()))
             }
diff --git a/compiler/rustc_hir_analysis/src/collect/item_bounds.rs b/compiler/rustc_hir_analysis/src/collect/item_bounds.rs
index ba54fa8cc0dbf..664ca35ddfbc9 100644
--- a/compiler/rustc_hir_analysis/src/collect/item_bounds.rs
+++ b/compiler/rustc_hir_analysis/src/collect/item_bounds.rs
@@ -174,21 +174,25 @@ fn remap_gat_vars_and_recurse_into_nested_projections<'tcx>(
     for (param, var) in std::iter::zip(&generics.own_params, gat_vars) {
         let existing = match var.kind() {
             ty::GenericArgKind::Lifetime(re) => {
-                if let ty::RegionKind::ReBound(ty::INNERMOST, bv) = re.kind() {
+                if let ty::RegionKind::ReBound(ty::BoundVarIndexKind::Bound(ty::INNERMOST), bv) =
+                    re.kind()
+                {
                     mapping.insert(bv.var, tcx.mk_param_from_def(param))
                 } else {
                     return None;
                 }
             }
             ty::GenericArgKind::Type(ty) => {
-                if let ty::Bound(ty::INNERMOST, bv) = *ty.kind() {
+                if let ty::Bound(ty::BoundVarIndexKind::Bound(ty::INNERMOST), bv) = *ty.kind() {
                     mapping.insert(bv.var, tcx.mk_param_from_def(param))
                 } else {
                     return None;
                 }
             }
             ty::GenericArgKind::Const(ct) => {
-                if let ty::ConstKind::Bound(ty::INNERMOST, bv) = ct.kind() {
+                if let ty::ConstKind::Bound(ty::BoundVarIndexKind::Bound(ty::INNERMOST), bv) =
+                    ct.kind()
+                {
                     mapping.insert(bv.var, tcx.mk_param_from_def(param))
                 } else {
                     return None;
@@ -253,7 +257,7 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for MapAndCompressBoundVars<'tcx> {
             return ty;
         }
 
-        if let ty::Bound(binder, old_bound) = *ty.kind()
+        if let ty::Bound(ty::BoundVarIndexKind::Bound(binder), old_bound) = *ty.kind()
             && self.binder == binder
         {
             let mapped = if let Some(mapped) = self.mapping.get(&old_bound.var) {
@@ -279,7 +283,7 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for MapAndCompressBoundVars<'tcx> {
     }
 
     fn fold_region(&mut self, re: ty::Region<'tcx>) -> ty::Region<'tcx> {
-        if let ty::ReBound(binder, old_bound) = re.kind()
+        if let ty::ReBound(ty::BoundVarIndexKind::Bound(binder), old_bound) = re.kind()
             && self.binder == binder
         {
             let mapped = if let Some(mapped) = self.mapping.get(&old_bound.var) {
@@ -307,7 +311,7 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for MapAndCompressBoundVars<'tcx> {
             return ct;
         }
 
-        if let ty::ConstKind::Bound(binder, old_bound) = ct.kind()
+        if let ty::ConstKind::Bound(ty::BoundVarIndexKind::Bound(binder), old_bound) = ct.kind()
             && self.binder == binder
         {
             let mapped = if let Some(mapped) = self.mapping.get(&old_bound.var) {
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
index 99dc8e6e52217..4b2e20a78b9ce 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
@@ -915,7 +915,7 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for GenericParamAndBoundVarCollector<'_, 't
             ty::Param(param) => {
                 self.params.insert(param.index);
             }
-            ty::Bound(db, bt) if *db >= self.depth => {
+            ty::Bound(ty::BoundVarIndexKind::Bound(db), bt) if *db >= self.depth => {
                 self.vars.insert(match bt.kind {
                     ty::BoundTyKind::Param(def_id) => def_id,
                     ty::BoundTyKind::Anon => {
@@ -938,7 +938,7 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for GenericParamAndBoundVarCollector<'_, 't
             ty::ReEarlyParam(param) => {
                 self.params.insert(param.index);
             }
-            ty::ReBound(db, br) if db >= self.depth => {
+            ty::ReBound(ty::BoundVarIndexKind::Bound(db), br) if db >= self.depth => {
                 self.vars.insert(match br.kind {
                     ty::BoundRegionKind::Named(def_id) => def_id,
                     ty::BoundRegionKind::Anon | ty::BoundRegionKind::ClosureEnv => {
@@ -961,7 +961,7 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for GenericParamAndBoundVarCollector<'_, 't
             ty::ConstKind::Param(param) => {
                 self.params.insert(param.index);
             }
-            ty::ConstKind::Bound(db, _) if db >= self.depth => {
+            ty::ConstKind::Bound(ty::BoundVarIndexKind::Bound(db), _) if db >= self.depth => {
                 let guar = self.cx.dcx().delayed_bug("unexpected escaping late-bound const var");
                 return ControlFlow::Break(guar);
             }
diff --git a/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs b/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
index 3c5e4a91c98c7..e445def4faa73 100644
--- a/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
+++ b/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
@@ -303,8 +303,6 @@ struct Canonicalizer<'cx, 'tcx> {
     sub_root_lookup_table: SsoHashMap<ty::TyVid, usize>,
     canonicalize_mode: &'cx dyn CanonicalizeMode,
     needs_canonical_flags: TypeFlags,
-
-    binder_index: ty::DebruijnIndex,
 }
 
 impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
@@ -312,24 +310,12 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
         self.tcx
     }
 
-    fn fold_binder<T>(&mut self, t: ty::Binder<'tcx, T>) -> ty::Binder<'tcx, T>
-    where
-        T: TypeFoldable<TyCtxt<'tcx>>,
-    {
-        self.binder_index.shift_in(1);
-        let t = t.super_fold_with(self);
-        self.binder_index.shift_out(1);
-        t
-    }
-
     fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
         match r.kind() {
-            ty::ReBound(index, ..) => {
-                if index >= self.binder_index {
-                    bug!("escaping late-bound region during canonicalization");
-                } else {
-                    r
-                }
+            ty::ReBound(ty::BoundVarIndexKind::Bound(_), ..) => r,
+
+            ty::ReBound(ty::BoundVarIndexKind::Canonical, _) => {
+                bug!("canonicalized bound var found during canonicalization");
             }
 
             ty::ReStatic
@@ -403,12 +389,10 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
                 self.canonicalize_ty_var(CanonicalVarKind::PlaceholderTy(placeholder), t)
             }
 
-            ty::Bound(debruijn, _) => {
-                if debruijn >= self.binder_index {
-                    bug!("escaping bound type during canonicalization")
-                } else {
-                    t
-                }
+            ty::Bound(ty::BoundVarIndexKind::Bound(_), _) => t,
+
+            ty::Bound(ty::BoundVarIndexKind::Canonical, _) => {
+                bug!("canonicalized bound var found during canonicalization");
             }
 
             ty::Closure(..)
@@ -479,12 +463,11 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
             ty::ConstKind::Infer(InferConst::Fresh(_)) => {
                 bug!("encountered a fresh const during canonicalization")
             }
-            ty::ConstKind::Bound(debruijn, _) => {
-                if debruijn >= self.binder_index {
-                    bug!("escaping bound const during canonicalization")
-                } else {
-                    return ct;
-                }
+            ty::ConstKind::Bound(ty::BoundVarIndexKind::Bound(_), _) => {
+                return ct;
+            }
+            ty::ConstKind::Bound(ty::BoundVarIndexKind::Canonical, _) => {
+                bug!("canonicalized bound var found during canonicalization");
             }
             ty::ConstKind::Placeholder(placeholder) => {
                 return self
@@ -569,7 +552,6 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
             query_state,
             indices: FxHashMap::default(),
             sub_root_lookup_table: Default::default(),
-            binder_index: ty::INNERMOST,
         };
         if canonicalizer.query_state.var_values.spilled() {
             canonicalizer.indices = canonicalizer
@@ -751,8 +733,7 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
         r: ty::Region<'tcx>,
     ) -> ty::Region<'tcx> {
         let var = self.canonical_var(var_kind, r.into());
-        let br = ty::BoundRegion { var, kind: ty::BoundRegionKind::Anon };
-        ty::Region::new_bound(self.cx(), self.binder_index, br)
+        ty::Region::new_canonical_bound(self.cx(), var)
     }
 
     /// Given a type variable `ty_var` of the given kind, first check
@@ -766,8 +747,7 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
     ) -> Ty<'tcx> {
         debug_assert!(!self.infcx.is_some_and(|infcx| ty_var != infcx.shallow_resolve(ty_var)));
         let var = self.canonical_var(var_kind, ty_var.into());
-        let bt = ty::BoundTy { var, kind: ty::BoundTyKind::Anon };
-        Ty::new_bound(self.tcx, self.binder_index, bt)
+        Ty::new_canonical_bound(self.tcx, var)
     }
 
     /// Given a type variable `const_var` of the given kind, first check
@@ -783,7 +763,6 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> {
             !self.infcx.is_some_and(|infcx| ct_var != infcx.shallow_resolve_const(ct_var))
         );
         let var = self.canonical_var(var_kind, ct_var.into());
-        let bc = ty::BoundConst { var };
-        ty::Const::new_bound(self.tcx, self.binder_index, bc)
+        ty::Const::new_canonical_bound(self.tcx, var)
     }
 }
diff --git a/compiler/rustc_infer/src/infer/canonical/instantiate.rs b/compiler/rustc_infer/src/infer/canonical/instantiate.rs
index cc052fbd85c12..c215a9db2a0af 100644
--- a/compiler/rustc_infer/src/infer/canonical/instantiate.rs
+++ b/compiler/rustc_infer/src/infer/canonical/instantiate.rs
@@ -11,7 +11,7 @@ use rustc_middle::ty::{
     self, DelayedMap, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeSuperFoldable, TypeSuperVisitable,
     TypeVisitableExt, TypeVisitor,
 };
-use rustc_type_ir::TypeVisitable;
+use rustc_type_ir::{TypeFlags, TypeVisitable};
 
 use crate::infer::canonical::{Canonical, CanonicalVarValues};
 
@@ -66,7 +66,6 @@ where
 
     value.fold_with(&mut CanonicalInstantiator {
         tcx,
-        current_index: ty::INNERMOST,
         var_values: var_values.var_values,
         cache: Default::default(),
     })
@@ -79,12 +78,9 @@ struct CanonicalInstantiator<'tcx> {
     // The values that the bound vars are are being instantiated with.
     var_values: ty::GenericArgsRef<'tcx>,
 
-    /// As with `BoundVarReplacer`, represents the index of a binder *just outside*
-    /// the ones we have visited.
-    current_index: ty::DebruijnIndex,
-
-    // Instantiation is a pure function of `DebruijnIndex` and `Ty`.
-    cache: DelayedMap<(ty::DebruijnIndex, Ty<'tcx>), Ty<'tcx>>,
+    // Because we use `ty::BoundVarIndexKind::Canonical`, we can cache
+    // based only on the entire ty, not worrying about a `DebruijnIndex`
+    cache: DelayedMap<Ty<'tcx>, Ty<'tcx>>,
 }
 
 impl<'tcx> TypeFolder<TyCtxt<'tcx>> for CanonicalInstantiator<'tcx> {
@@ -92,29 +88,19 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for CanonicalInstantiator<'tcx> {
         self.tcx
     }
 
-    fn fold_binder<T: TypeFoldable<TyCtxt<'tcx>>>(
-        &mut self,
-        t: ty::Binder<'tcx, T>,
-    ) -> ty::Binder<'tcx, T> {
-        self.current_index.shift_in(1);
-        let t = t.super_fold_with(self);
-        self.current_index.shift_out(1);
-        t
-    }
-
     fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
         match *t.kind() {
-            ty::Bound(debruijn, bound_ty) if debruijn == self.current_index => {
+            ty::Bound(ty::BoundVarIndexKind::Canonical, bound_ty) => {
                 self.var_values[bound_ty.var.as_usize()].expect_ty()
             }
             _ => {
-                if !t.has_vars_bound_at_or_above(self.current_index) {
+                if !t.has_type_flags(TypeFlags::HAS_CANONICAL_BOUND) {
                     t
-                } else if let Some(&t) = self.cache.get(&(self.current_index, t)) {
+                } else if let Some(&t) = self.cache.get(&t) {
                     t
                 } else {
                     let res = t.super_fold_with(self);
-                    assert!(self.cache.insert((self.current_index, t), res));
+                    assert!(self.cache.insert(t, res));
                     res
                 }
             }
@@ -123,7 +109,7 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for CanonicalInstantiator<'tcx> {
 
     fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
         match r.kind() {
-            ty::ReBound(debruijn, br) if debruijn == self.current_index => {
+            ty::ReBound(ty::BoundVarIndexKind::Canonical, br) => {
                 self.var_values[br.var.as_usize()].expect_region()
             }
             _ => r,
@@ -132,7 +118,7 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for CanonicalInstantiator<'tcx> {
 
     fn fold_const(&mut self, ct: ty::Const<'tcx>) -> ty::Const<'tcx> {
         match ct.kind() {
-            ty::ConstKind::Bound(debruijn, bound_const) if debruijn == self.current_index => {
+            ty::ConstKind::Bound(ty::BoundVarIndexKind::Canonical, bound_const) => {
                 self.var_values[bound_const.var.as_usize()].expect_const()
             }
             _ => ct.super_fold_with(self),
@@ -140,22 +126,14 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for CanonicalInstantiator<'tcx> {
     }
 
     fn fold_predicate(&mut self, p: ty::Predicate<'tcx>) -> ty::Predicate<'tcx> {
-        if p.has_vars_bound_at_or_above(self.current_index) { p.super_fold_with(self) } else { p }
+        if p.has_type_flags(TypeFlags::HAS_CANONICAL_BOUND) { p.super_fold_with(self) } else { p }
     }
 
     fn fold_clauses(&mut self, c: ty::Clauses<'tcx>) -> ty::Clauses<'tcx> {
-        if !c.has_vars_bound_at_or_above(self.current_index) {
+        if !c.has_type_flags(TypeFlags::HAS_CANONICAL_BOUND) {
             return c;
         }
 
-        // Since instantiation is a function of `DebruijnIndex`, we don't want
-        // to have to cache more copies of clauses when we're inside of binders.
-        // Since we currently expect to only have clauses in the outermost
-        // debruijn index, we just fold if we're inside of a binder.
-        if self.current_index > ty::INNERMOST {
-            return c.super_fold_with(self);
-        }
-
         // Our cache key is `(clauses, var_values)`, but we also don't care about
         // var values that aren't named in the clauses, since they can change without
         // affecting the output. Since `ParamEnv`s are cached first, we compute the
@@ -185,45 +163,29 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for CanonicalInstantiator<'tcx> {
 fn highest_var_in_clauses<'tcx>(c: ty::Clauses<'tcx>) -> usize {
     struct HighestVarInClauses {
         max_var: usize,
-        current_index: ty::DebruijnIndex,
     }
     impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for HighestVarInClauses {
-        fn visit_binder<T: TypeVisitable<TyCtxt<'tcx>>>(
-            &mut self,
-            t: &ty::Binder<'tcx, T>,
-        ) -> Self::Result {
-            self.current_index.shift_in(1);
-            let t = t.super_visit_with(self);
-            self.current_index.shift_out(1);
-            t
-        }
         fn visit_ty(&mut self, t: Ty<'tcx>) {
-            if let ty::Bound(debruijn, bound_ty) = *t.kind()
-                && debruijn == self.current_index
-            {
+            if let ty::Bound(ty::BoundVarIndexKind::Canonical, bound_ty) = *t.kind() {
                 self.max_var = self.max_var.max(bound_ty.var.as_usize());
-            } else if t.has_vars_bound_at_or_above(self.current_index) {
+            } else if t.has_type_flags(TypeFlags::HAS_CANONICAL_BOUND) {
                 t.super_visit_with(self);
             }
         }
         fn visit_region(&mut self, r: ty::Region<'tcx>) {
-            if let ty::ReBound(debruijn, bound_region) = r.kind()
-                && debruijn == self.current_index
-            {
+            if let ty::ReBound(ty::BoundVarIndexKind::Canonical, bound_region) = r.kind() {
                 self.max_var = self.max_var.max(bound_region.var.as_usize());
             }
         }
         fn visit_const(&mut self, ct: ty::Const<'tcx>) {
-            if let ty::ConstKind::Bound(debruijn, bound_const) = ct.kind()
-                && debruijn == self.current_index
-            {
+            if let ty::ConstKind::Bound(ty::BoundVarIndexKind::Canonical, bound_const) = ct.kind() {
                 self.max_var = self.max_var.max(bound_const.var.as_usize());
-            } else if ct.has_vars_bound_at_or_above(self.current_index) {
+            } else if ct.has_type_flags(TypeFlags::HAS_CANONICAL_BOUND) {
                 ct.super_visit_with(self);
             }
         }
     }
-    let mut visitor = HighestVarInClauses { max_var: 0, current_index: ty::INNERMOST };
+    let mut visitor = HighestVarInClauses { max_var: 0 };
     c.visit_with(&mut visitor);
     visitor.max_var
 }
diff --git a/compiler/rustc_infer/src/infer/canonical/query_response.rs b/compiler/rustc_infer/src/infer/canonical/query_response.rs
index 5d1b4be9e57bb..3c20bdd9391ae 100644
--- a/compiler/rustc_infer/src/infer/canonical/query_response.rs
+++ b/compiler/rustc_infer/src/infer/canonical/query_response.rs
@@ -422,28 +422,28 @@ impl<'tcx> InferCtxt<'tcx> {
                     // and only use it for placeholders. We need to handle the
                     // `sub_root` of type inference variables which would make this
                     // more involved. They are also a lot rarer than region variables.
-                    if let ty::Bound(debruijn, b) = *result_value.kind()
+                    if let ty::Bound(index_kind, b) = *result_value.kind()
                         && !matches!(
                             query_response.variables[b.var.as_usize()],
                             CanonicalVarKind::Ty { .. }
                         )
                     {
-                        // We only allow a `ty::INNERMOST` index in generic parameters.
-                        assert_eq!(debruijn, ty::INNERMOST);
+                        // We only allow a `Canonical` index in generic parameters.
+                        assert!(matches!(index_kind, ty::BoundVarIndexKind::Canonical));
                         opt_values[b.var] = Some(*original_value);
                     }
                 }
                 GenericArgKind::Lifetime(result_value) => {
-                    if let ty::ReBound(debruijn, b) = result_value.kind() {
-                        // We only allow a `ty::INNERMOST` index in generic parameters.
-                        assert_eq!(debruijn, ty::INNERMOST);
+                    if let ty::ReBound(index_kind, b) = result_value.kind() {
+                        // We only allow a `Canonical` index in generic parameters.
+                        assert!(matches!(index_kind, ty::BoundVarIndexKind::Canonical));
                         opt_values[b.var] = Some(*original_value);
                     }
                 }
                 GenericArgKind::Const(result_value) => {
-                    if let ty::ConstKind::Bound(debruijn, b) = result_value.kind() {
-                        // We only allow a `ty::INNERMOST` index in generic parameters.
-                        assert_eq!(debruijn, ty::INNERMOST);
+                    if let ty::ConstKind::Bound(index_kind, b) = result_value.kind() {
+                        // We only allow a `Canonical` index in generic parameters.
+                        assert!(matches!(index_kind, ty::BoundVarIndexKind::Canonical));
                         opt_values[b.var] = Some(*original_value);
                     }
                 }
diff --git a/compiler/rustc_infer/src/infer/outlives/test_type_match.rs b/compiler/rustc_infer/src/infer/outlives/test_type_match.rs
index f06eb58a371c2..6592360cf0a5c 100644
--- a/compiler/rustc_infer/src/infer/outlives/test_type_match.rs
+++ b/compiler/rustc_infer/src/infer/outlives/test_type_match.rs
@@ -44,8 +44,8 @@ pub fn extract_verify_if_eq<'tcx>(
     let verify_if_eq = verify_if_eq_b.skip_binder();
     m.relate(verify_if_eq.ty, test_ty).ok()?;
 
-    if let ty::RegionKind::ReBound(depth, br) = verify_if_eq.bound.kind() {
-        assert!(depth == ty::INNERMOST);
+    if let ty::RegionKind::ReBound(index_kind, br) = verify_if_eq.bound.kind() {
+        assert!(matches!(index_kind, ty::BoundVarIndexKind::Bound(ty::INNERMOST)));
         match m.map.get(&br) {
             Some(&r) => Some(r),
             None => {
@@ -156,7 +156,7 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for MatchAgainstHigherRankedOutlives<'tcx>
         pattern: ty::Region<'tcx>,
         value: ty::Region<'tcx>,
     ) -> RelateResult<'tcx, ty::Region<'tcx>> {
-        if let ty::RegionKind::ReBound(depth, br) = pattern.kind()
+        if let ty::RegionKind::ReBound(ty::BoundVarIndexKind::Bound(depth), br) = pattern.kind()
             && depth == self.pattern_depth
         {
             self.bind(br, value)
diff --git a/compiler/rustc_middle/src/ty/consts.rs b/compiler/rustc_middle/src/ty/consts.rs
index 614b6471f188a..95adb561c704d 100644
--- a/compiler/rustc_middle/src/ty/consts.rs
+++ b/compiler/rustc_middle/src/ty/consts.rs
@@ -95,7 +95,15 @@ impl<'tcx> Const<'tcx> {
         debruijn: ty::DebruijnIndex,
         bound_const: ty::BoundConst,
     ) -> Const<'tcx> {
-        Const::new(tcx, ty::ConstKind::Bound(debruijn, bound_const))
+        Const::new(tcx, ty::ConstKind::Bound(ty::BoundVarIndexKind::Bound(debruijn), bound_const))
+    }
+
+    #[inline]
+    pub fn new_canonical_bound(tcx: TyCtxt<'tcx>, var: ty::BoundVar) -> Const<'tcx> {
+        Const::new(
+            tcx,
+            ty::ConstKind::Bound(ty::BoundVarIndexKind::Canonical, ty::BoundConst { var }),
+        )
     }
 
     #[inline]
@@ -180,6 +188,10 @@ impl<'tcx> rustc_type_ir::inherent::Const<TyCtxt<'tcx>> for Const<'tcx> {
         Const::new_bound(tcx, debruijn, ty::BoundConst { var })
     }
 
+    fn new_canonical_bound(tcx: TyCtxt<'tcx>, var: rustc_type_ir::BoundVar) -> Self {
+        Const::new_canonical_bound(tcx, var)
+    }
+
     fn new_placeholder(tcx: TyCtxt<'tcx>, placeholder: ty::PlaceholderConst) -> Self {
         Const::new_placeholder(tcx, placeholder)
     }
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 7d3e2c9965dad..161fec9245a84 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -1110,6 +1110,15 @@ const NUM_PREINTERNED_FRESH_TYS: u32 = 20;
 const NUM_PREINTERNED_FRESH_INT_TYS: u32 = 3;
 const NUM_PREINTERNED_FRESH_FLOAT_TYS: u32 = 3;
 const NUM_PREINTERNED_ANON_BOUND_TYS_I: u32 = 3;
+
+// From general profiling of the *max vars during canonicalization* of a value:
+// - about 90% of the time, there are no canonical vars
+// - about 9% of the time, there is only one canonical var
+// - there are rarely more than 3-5 canonical vars (with exceptions in particularly pathological cases)
+// This may not match the number of bound vars found in `for`s.
+// Given that this is all heap interned, it seems likely that interning fewer
+// vars here won't make an appreciable difference. Though, if we were to inline the data (in an array),
+// we may want to consider reducing the number for canonicalized vars down to 4 or so.
 const NUM_PREINTERNED_ANON_BOUND_TYS_V: u32 = 20;
 
 // This number may seem high, but it is reached in all but the smallest crates.
@@ -1160,9 +1169,14 @@ pub struct CommonTypes<'tcx> {
     pub fresh_float_tys: Vec<Ty<'tcx>>,
 
     /// Pre-interned values of the form:
-    /// `Bound(DebruijnIndex(i), BoundTy { var: v, kind: BoundTyKind::Anon})`
+    /// `Bound(BoundVarIndexKind::Bound(DebruijnIndex(i)), BoundTy { var: v, kind: BoundTyKind::Anon})`
     /// for small values of `i` and `v`.
     pub anon_bound_tys: Vec<Vec<Ty<'tcx>>>,
+
+    // Pre-interned values of the form:
+    // `Bound(BoundVarIndexKind::Canonical, BoundTy { var: v, kind: BoundTyKind::Anon })`
+    // for small values of `v`.
+    pub anon_canonical_bound_tys: Vec<Ty<'tcx>>,
 }
 
 pub struct CommonLifetimes<'tcx> {
@@ -1176,9 +1190,14 @@ pub struct CommonLifetimes<'tcx> {
     pub re_vars: Vec<Region<'tcx>>,
 
     /// Pre-interned values of the form:
-    /// `ReBound(DebruijnIndex(i), BoundRegion { var: v, kind: BoundRegionKind::Anon })`
+    /// `ReBound(BoundVarIndexKind::Bound(DebruijnIndex(i)), BoundRegion { var: v, kind: BoundRegionKind::Anon })`
     /// for small values of `i` and `v`.
     pub anon_re_bounds: Vec<Vec<Region<'tcx>>>,
+
+    // Pre-interned values of the form:
+    // `ReBound(BoundVarIndexKind::Canonical, BoundRegion { var: v, kind: BoundRegionKind::Anon })`
+    // for small values of `v`.
+    pub anon_re_canonical_bounds: Vec<Region<'tcx>>,
 }
 
 pub struct CommonConsts<'tcx> {
@@ -1211,7 +1230,7 @@ impl<'tcx> CommonTypes<'tcx> {
                 (0..NUM_PREINTERNED_ANON_BOUND_TYS_V)
                     .map(|v| {
                         mk(ty::Bound(
-                            ty::DebruijnIndex::from(i),
+                            ty::BoundVarIndexKind::Bound(ty::DebruijnIndex::from(i)),
                             ty::BoundTy { var: ty::BoundVar::from(v), kind: ty::BoundTyKind::Anon },
                         ))
                     })
@@ -1219,6 +1238,15 @@ impl<'tcx> CommonTypes<'tcx> {
             })
             .collect();
 
+        let anon_canonical_bound_tys = (0..NUM_PREINTERNED_ANON_BOUND_TYS_V)
+            .map(|v| {
+                mk(ty::Bound(
+                    ty::BoundVarIndexKind::Canonical,
+                    ty::BoundTy { var: ty::BoundVar::from(v), kind: ty::BoundTyKind::Anon },
+                ))
+            })
+            .collect();
+
         CommonTypes {
             unit: mk(Tuple(List::empty())),
             bool: mk(Bool),
@@ -1250,6 +1278,7 @@ impl<'tcx> CommonTypes<'tcx> {
             fresh_int_tys,
             fresh_float_tys,
             anon_bound_tys,
+            anon_canonical_bound_tys,
         }
     }
 }
@@ -1270,7 +1299,7 @@ impl<'tcx> CommonLifetimes<'tcx> {
                 (0..NUM_PREINTERNED_ANON_RE_BOUNDS_V)
                     .map(|v| {
                         mk(ty::ReBound(
-                            ty::DebruijnIndex::from(i),
+                            ty::BoundVarIndexKind::Bound(ty::DebruijnIndex::from(i)),
                             ty::BoundRegion {
                                 var: ty::BoundVar::from(v),
                                 kind: ty::BoundRegionKind::Anon,
@@ -1281,11 +1310,21 @@ impl<'tcx> CommonLifetimes<'tcx> {
             })
             .collect();
 
+        let anon_re_canonical_bounds = (0..NUM_PREINTERNED_ANON_RE_BOUNDS_V)
+            .map(|v| {
+                mk(ty::ReBound(
+                    ty::BoundVarIndexKind::Canonical,
+                    ty::BoundRegion { var: ty::BoundVar::from(v), kind: ty::BoundRegionKind::Anon },
+                ))
+            })
+            .collect();
+
         CommonLifetimes {
             re_static: mk(ty::ReStatic),
             re_erased: mk(ty::ReErased),
             re_vars,
             anon_re_bounds,
+            anon_re_canonical_bounds,
         }
     }
 }
diff --git a/compiler/rustc_middle/src/ty/fold.rs b/compiler/rustc_middle/src/ty/fold.rs
index 7d56ec1635f8d..ee29afcff638d 100644
--- a/compiler/rustc_middle/src/ty/fold.rs
+++ b/compiler/rustc_middle/src/ty/fold.rs
@@ -125,7 +125,9 @@ where
 
     fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
         match *t.kind() {
-            ty::Bound(debruijn, bound_ty) if debruijn == self.current_index => {
+            ty::Bound(ty::BoundVarIndexKind::Bound(debruijn), bound_ty)
+                if debruijn == self.current_index =>
+            {
                 let ty = self.delegate.replace_ty(bound_ty);
                 debug_assert!(!ty.has_vars_bound_above(ty::INNERMOST));
                 ty::shift_vars(self.tcx, ty, self.current_index.as_u32())
@@ -146,9 +148,11 @@ where
 
     fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
         match r.kind() {
-            ty::ReBound(debruijn, br) if debruijn == self.current_index => {
+            ty::ReBound(ty::BoundVarIndexKind::Bound(debruijn), br)
+                if debruijn == self.current_index =>
+            {
                 let region = self.delegate.replace_region(br);
-                if let ty::ReBound(debruijn1, br) = region.kind() {
+                if let ty::ReBound(ty::BoundVarIndexKind::Bound(debruijn1), br) = region.kind() {
                     // If the callback returns a bound region,
                     // that region should always use the INNERMOST
                     // debruijn index. Then we adjust it to the
@@ -165,7 +169,9 @@ where
 
     fn fold_const(&mut self, ct: ty::Const<'tcx>) -> ty::Const<'tcx> {
         match ct.kind() {
-            ty::ConstKind::Bound(debruijn, bound_const) if debruijn == self.current_index => {
+            ty::ConstKind::Bound(ty::BoundVarIndexKind::Bound(debruijn), bound_const)
+                if debruijn == self.current_index =>
+            {
                 let ct = self.delegate.replace_const(bound_const);
                 debug_assert!(!ct.has_vars_bound_above(ty::INNERMOST));
                 ty::shift_vars(self.tcx, ct, self.current_index.as_u32())
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index 8f7c8170f7adf..4d1fcaeda5e26 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -2664,7 +2664,7 @@ impl<'a, 'tcx> ty::TypeFolder<TyCtxt<'tcx>> for RegionFolder<'a, 'tcx> {
     fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
         let name = &mut self.name;
         let region = match r.kind() {
-            ty::ReBound(db, br) if db >= self.current_index => {
+            ty::ReBound(ty::BoundVarIndexKind::Bound(db), br) if db >= self.current_index => {
                 *self.region_map.entry(br).or_insert_with(|| name(Some(db), self.current_index, br))
             }
             ty::RePlaceholder(ty::PlaceholderRegion {
@@ -2687,7 +2687,7 @@ impl<'a, 'tcx> ty::TypeFolder<TyCtxt<'tcx>> for RegionFolder<'a, 'tcx> {
             }
             _ => return r,
         };
-        if let ty::ReBound(debruijn1, br) = region.kind() {
+        if let ty::ReBound(ty::BoundVarIndexKind::Bound(debruijn1), br) = region.kind() {
             assert_eq!(debruijn1, ty::INNERMOST);
             ty::Region::new_bound(self.tcx, self.current_index, br)
         } else {
diff --git a/compiler/rustc_middle/src/ty/region.rs b/compiler/rustc_middle/src/ty/region.rs
index 3a7852dea0680..f0687f2bc726d 100644
--- a/compiler/rustc_middle/src/ty/region.rs
+++ b/compiler/rustc_middle/src/ty/region.rs
@@ -31,7 +31,7 @@ impl<'tcx> rustc_type_ir::Flags for Region<'tcx> {
 
     fn outer_exclusive_binder(&self) -> ty::DebruijnIndex {
         match self.kind() {
-            ty::ReBound(debruijn, _) => debruijn.shifted_in(1),
+            ty::ReBound(ty::BoundVarIndexKind::Bound(debruijn), _) => debruijn.shifted_in(1),
             _ => ty::INNERMOST,
         }
     }
@@ -59,7 +59,20 @@ impl<'tcx> Region<'tcx> {
         {
             re
         } else {
-            tcx.intern_region(ty::ReBound(debruijn, bound_region))
+            tcx.intern_region(ty::ReBound(ty::BoundVarIndexKind::Bound(debruijn), bound_region))
+        }
+    }
+
+    #[inline]
+    pub fn new_canonical_bound(tcx: TyCtxt<'tcx>, var: ty::BoundVar) -> Region<'tcx> {
+        // Use a pre-interned one when possible.
+        if let Some(re) = tcx.lifetimes.anon_re_canonical_bounds.get(var.as_usize()).copied() {
+            re
+        } else {
+            tcx.intern_region(ty::ReBound(
+                ty::BoundVarIndexKind::Canonical,
+                ty::BoundRegion { var, kind: ty::BoundRegionKind::Anon },
+            ))
         }
     }
 
@@ -122,7 +135,12 @@ impl<'tcx> Region<'tcx> {
     pub fn new_from_kind(tcx: TyCtxt<'tcx>, kind: RegionKind<'tcx>) -> Region<'tcx> {
         match kind {
             ty::ReEarlyParam(region) => Region::new_early_param(tcx, region),
-            ty::ReBound(debruijn, region) => Region::new_bound(tcx, debruijn, region),
+            ty::ReBound(ty::BoundVarIndexKind::Bound(debruijn), region) => {
+                Region::new_bound(tcx, debruijn, region)
+            }
+            ty::ReBound(ty::BoundVarIndexKind::Canonical, region) => {
+                Region::new_canonical_bound(tcx, region.var)
+            }
             ty::ReLateParam(ty::LateParamRegion { scope, kind }) => {
                 Region::new_late_param(tcx, scope, kind)
             }
@@ -148,6 +166,10 @@ impl<'tcx> rustc_type_ir::inherent::Region<TyCtxt<'tcx>> for Region<'tcx> {
         Region::new_bound(tcx, debruijn, ty::BoundRegion { var, kind: ty::BoundRegionKind::Anon })
     }
 
+    fn new_canonical_bound(tcx: TyCtxt<'tcx>, var: rustc_type_ir::BoundVar) -> Self {
+        Region::new_canonical_bound(tcx, var)
+    }
+
     fn new_placeholder(tcx: TyCtxt<'tcx>, placeholder: ty::PlaceholderRegion) -> Self {
         Region::new_placeholder(tcx, placeholder)
     }
@@ -223,7 +245,7 @@ impl<'tcx> Region<'tcx> {
     #[inline]
     pub fn bound_at_or_above_binder(self, index: ty::DebruijnIndex) -> bool {
         match self.kind() {
-            ty::ReBound(debruijn, _) => debruijn >= index,
+            ty::ReBound(ty::BoundVarIndexKind::Bound(debruijn), _) => debruijn >= index,
             _ => false,
         }
     }
@@ -254,7 +276,11 @@ impl<'tcx> Region<'tcx> {
             ty::ReStatic => {
                 flags = flags | TypeFlags::HAS_FREE_REGIONS;
             }
-            ty::ReBound(..) => {
+            ty::ReBound(ty::BoundVarIndexKind::Canonical, _) => {
+                flags = flags | TypeFlags::HAS_RE_BOUND;
+                flags = flags | TypeFlags::HAS_CANONICAL_BOUND;
+            }
+            ty::ReBound(ty::BoundVarIndexKind::Bound(..), _) => {
                 flags = flags | TypeFlags::HAS_RE_BOUND;
             }
             ty::ReErased => {
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
index de35e5e847c81..a3fdd4e35b6aa 100644
--- a/compiler/rustc_middle/src/ty/sty.rs
+++ b/compiler/rustc_middle/src/ty/sty.rs
@@ -487,7 +487,23 @@ impl<'tcx> Ty<'tcx> {
         {
             ty
         } else {
-            Ty::new(tcx, Bound(index, bound_ty))
+            Ty::new(tcx, Bound(ty::BoundVarIndexKind::Bound(index), bound_ty))
+        }
+    }
+
+    #[inline]
+    pub fn new_canonical_bound(tcx: TyCtxt<'tcx>, var: BoundVar) -> Ty<'tcx> {
+        // Use a pre-interned one when possible.
+        if let Some(ty) = tcx.types.anon_canonical_bound_tys.get(var.as_usize()).copied() {
+            ty
+        } else {
+            Ty::new(
+                tcx,
+                Bound(
+                    ty::BoundVarIndexKind::Canonical,
+                    ty::BoundTy { var, kind: ty::BoundTyKind::Anon },
+                ),
+            )
         }
     }
 
@@ -952,6 +968,10 @@ impl<'tcx> rustc_type_ir::inherent::Ty<TyCtxt<'tcx>> for Ty<'tcx> {
         Ty::new_bound(tcx, debruijn, ty::BoundTy { var, kind: ty::BoundTyKind::Anon })
     }
 
+    fn new_canonical_bound(tcx: TyCtxt<'tcx>, var: ty::BoundVar) -> Self {
+        Ty::new_canonical_bound(tcx, var)
+    }
+
     fn new_alias(
         interner: TyCtxt<'tcx>,
         kind: ty::AliasTyKind,
diff --git a/compiler/rustc_middle/src/ty/typeck_results.rs b/compiler/rustc_middle/src/ty/typeck_results.rs
index 8dd80aab946d4..370ef364bf5cf 100644
--- a/compiler/rustc_middle/src/ty/typeck_results.rs
+++ b/compiler/rustc_middle/src/ty/typeck_results.rs
@@ -798,8 +798,8 @@ impl<'tcx> IsIdentity for CanonicalUserType<'tcx> {
                     match arg.kind() {
                         GenericArgKind::Type(ty) => match ty.kind() {
                             ty::Bound(debruijn, b) => {
-                                // We only allow a `ty::INNERMOST` index in generic parameters.
-                                assert_eq!(*debruijn, ty::INNERMOST);
+                                // We only allow a `ty::BoundVarIndexKind::Canonical` index in generic parameters.
+                                assert_eq!(*debruijn, ty::BoundVarIndexKind::Canonical);
                                 cvar == b.var
                             }
                             _ => false,
@@ -807,8 +807,8 @@ impl<'tcx> IsIdentity for CanonicalUserType<'tcx> {
 
                         GenericArgKind::Lifetime(r) => match r.kind() {
                             ty::ReBound(debruijn, b) => {
-                                // We only allow a `ty::INNERMOST` index in generic parameters.
-                                assert_eq!(debruijn, ty::INNERMOST);
+                                // We only allow a `ty::BoundVarIndexKind::Canonical` index in generic parameters.
+                                assert_eq!(debruijn, ty::BoundVarIndexKind::Canonical);
                                 cvar == b.var
                             }
                             _ => false,
@@ -816,8 +816,8 @@ impl<'tcx> IsIdentity for CanonicalUserType<'tcx> {
 
                         GenericArgKind::Const(ct) => match ct.kind() {
                             ty::ConstKind::Bound(debruijn, b) => {
-                                // We only allow a `ty::INNERMOST` index in generic parameters.
-                                assert_eq!(debruijn, ty::INNERMOST);
+                                // We only allow a `ty::BoundVarIndexKind::Canonical` index in generic parameters.
+                                assert_eq!(debruijn, ty::BoundVarIndexKind::Canonical);
                                 cvar == b.var
                             }
                             _ => false,
diff --git a/compiler/rustc_middle/src/ty/visit.rs b/compiler/rustc_middle/src/ty/visit.rs
index f0c47f257cc4e..e84ac56b31dfd 100644
--- a/compiler/rustc_middle/src/ty/visit.rs
+++ b/compiler/rustc_middle/src/ty/visit.rs
@@ -78,7 +78,9 @@ impl<'tcx> TyCtxt<'tcx> {
 
             fn visit_region(&mut self, r: ty::Region<'tcx>) -> Self::Result {
                 match r.kind() {
-                    ty::ReBound(debruijn, _) if debruijn < self.outer_index => {
+                    ty::ReBound(ty::BoundVarIndexKind::Bound(debruijn), _)
+                        if debruijn < self.outer_index =>
+                    {
                         ControlFlow::Continue(())
                     }
                     _ => {
@@ -205,7 +207,7 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for LateBoundRegionsCollector {
     }
 
     fn visit_region(&mut self, r: ty::Region<'tcx>) {
-        if let ty::ReBound(debruijn, br) = r.kind() {
+        if let ty::ReBound(ty::BoundVarIndexKind::Bound(debruijn), br) = r.kind() {
             if debruijn == self.current_index {
                 self.regions.insert(br.kind);
             }
diff --git a/compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs b/compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs
index b25671d676b9c..9162284422d0d 100644
--- a/compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs
+++ b/compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs
@@ -74,12 +74,10 @@ pub(super) struct Canonicalizer<'a, D: SolverDelegate<Interner = I>, I: Interner
     /// we set the `sub_root` of the second variable to the position of the first.
     /// Otherwise the `sub_root` of each type variable is just its own position.
     sub_root_lookup_table: HashMap<ty::TyVid, usize>,
-    binder_index: ty::DebruijnIndex,
 
-    /// We only use the debruijn index during lookup. We don't need to
-    /// track the `variables` as each generic arg only results in a single
-    /// bound variable regardless of how many times it is encountered.
-    cache: HashMap<(ty::DebruijnIndex, I::Ty), I::Ty>,
+    /// We can simply cache based on the ty itself, because we use
+    /// `ty::BoundVarIndexKind::Canonical`.
+    cache: HashMap<I::Ty, I::Ty>,
 }
 
 impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
@@ -97,7 +95,6 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
             variable_lookup_table: Default::default(),
             sub_root_lookup_table: Default::default(),
             var_kinds: Vec::new(),
-            binder_index: ty::INNERMOST,
 
             cache: Default::default(),
         };
@@ -141,12 +138,10 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
                         variable_lookup_table: Default::default(),
                         sub_root_lookup_table: Default::default(),
                         var_kinds: Vec::new(),
-                        binder_index: ty::INNERMOST,
 
                         cache: Default::default(),
                     };
                     let param_env = param_env.fold_with(&mut env_canonicalizer);
-                    debug_assert_eq!(env_canonicalizer.binder_index, ty::INNERMOST);
                     debug_assert!(env_canonicalizer.sub_root_lookup_table.is_empty());
                     CanonicalParamEnvCacheEntry {
                         param_env,
@@ -175,12 +170,10 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
                 variable_lookup_table: Default::default(),
                 sub_root_lookup_table: Default::default(),
                 var_kinds: Vec::new(),
-                binder_index: ty::INNERMOST,
 
                 cache: Default::default(),
             };
             let param_env = param_env.fold_with(&mut env_canonicalizer);
-            debug_assert_eq!(env_canonicalizer.binder_index, ty::INNERMOST);
             debug_assert!(env_canonicalizer.sub_root_lookup_table.is_empty());
             (param_env, env_canonicalizer.variable_lookup_table, env_canonicalizer.var_kinds)
         }
@@ -212,7 +205,6 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
             variable_lookup_table,
             sub_root_lookup_table: Default::default(),
             var_kinds,
-            binder_index: ty::INNERMOST,
 
             // We do not reuse the cache as it may contain entries whose canonicalized
             // value contains `'static`. While we could alternatively handle this by
@@ -409,7 +401,7 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
 
         let var = self.get_or_insert_bound_var(t, kind);
 
-        Ty::new_anon_bound(self.cx(), self.binder_index, var)
+        Ty::new_canonical_bound(self.cx(), var)
     }
 }
 
@@ -418,16 +410,6 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I> for Canonicaliz
         self.delegate.cx()
     }
 
-    fn fold_binder<T>(&mut self, t: ty::Binder<I, T>) -> ty::Binder<I, T>
-    where
-        T: TypeFoldable<I>,
-    {
-        self.binder_index.shift_in(1);
-        let t = t.super_fold_with(self);
-        self.binder_index.shift_out(1);
-        t
-    }
-
     fn fold_region(&mut self, r: I::Region) -> I::Region {
         let kind = match r.kind() {
             ty::ReBound(..) => return r,
@@ -491,15 +473,15 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I> for Canonicaliz
 
         let var = self.get_or_insert_bound_var(r, kind);
 
-        Region::new_anon_bound(self.cx(), self.binder_index, var)
+        Region::new_canonical_bound(self.cx(), var)
     }
 
     fn fold_ty(&mut self, t: I::Ty) -> I::Ty {
-        if let Some(&ty) = self.cache.get(&(self.binder_index, t)) {
+        if let Some(&ty) = self.cache.get(&t) {
             ty
         } else {
             let res = self.inner_fold_ty(t);
-            let old = self.cache.insert((self.binder_index, t), res);
+            let old = self.cache.insert(t, res);
             assert_eq!(old, None);
             res
         }
@@ -552,7 +534,7 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I> for Canonicaliz
 
         let var = self.get_or_insert_bound_var(c, kind);
 
-        Const::new_anon_bound(self.cx(), self.binder_index, var)
+        Const::new_canonical_bound(self.cx(), var)
     }
 
     fn fold_predicate(&mut self, p: I::Predicate) -> I::Predicate {
diff --git a/compiler/rustc_next_trait_solver/src/canonical/mod.rs b/compiler/rustc_next_trait_solver/src/canonical/mod.rs
index e3520e238ed37..4c1569e478f88 100644
--- a/compiler/rustc_next_trait_solver/src/canonical/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/canonical/mod.rs
@@ -167,25 +167,25 @@ where
                 // and only use it for placeholders. We need to handle the
                 // `sub_root` of type inference variables which would make this
                 // more involved. They are also a lot rarer than region variables.
-                if let ty::Bound(debruijn, b) = t.kind()
+                if let ty::Bound(index_kind, b) = t.kind()
                     && !matches!(
                         response.variables.get(b.var().as_usize()).unwrap(),
                         CanonicalVarKind::Ty { .. }
                     )
                 {
-                    assert_eq!(debruijn, ty::INNERMOST);
+                    assert!(matches!(index_kind, ty::BoundVarIndexKind::Canonical));
                     opt_values[b.var()] = Some(*original_value);
                 }
             }
             ty::GenericArgKind::Lifetime(r) => {
-                if let ty::ReBound(debruijn, br) = r.kind() {
-                    assert_eq!(debruijn, ty::INNERMOST);
+                if let ty::ReBound(index_kind, br) = r.kind() {
+                    assert!(matches!(index_kind, ty::BoundVarIndexKind::Canonical));
                     opt_values[br.var()] = Some(*original_value);
                 }
             }
             ty::GenericArgKind::Const(c) => {
-                if let ty::ConstKind::Bound(debruijn, bv) = c.kind() {
-                    assert_eq!(debruijn, ty::INNERMOST);
+                if let ty::ConstKind::Bound(index_kind, bv) = c.kind() {
+                    assert!(matches!(index_kind, ty::BoundVarIndexKind::Canonical));
                     opt_values[bv.var()] = Some(*original_value);
                 }
             }
diff --git a/compiler/rustc_next_trait_solver/src/placeholder.rs b/compiler/rustc_next_trait_solver/src/placeholder.rs
index c88fb8defae7b..c8016759f239a 100644
--- a/compiler/rustc_next_trait_solver/src/placeholder.rs
+++ b/compiler/rustc_next_trait_solver/src/placeholder.rs
@@ -90,7 +90,7 @@ where
 
     fn fold_region(&mut self, r: I::Region) -> I::Region {
         match r.kind() {
-            ty::ReBound(debruijn, _)
+            ty::ReBound(ty::BoundVarIndexKind::Bound(debruijn), _)
                 if debruijn.as_usize()
                     >= self.current_index.as_usize() + self.universe_indices.len() =>
             {
@@ -99,7 +99,9 @@ where
                     self.universe_indices
                 );
             }
-            ty::ReBound(debruijn, br) if debruijn >= self.current_index => {
+            ty::ReBound(ty::BoundVarIndexKind::Bound(debruijn), br)
+                if debruijn >= self.current_index =>
+            {
                 let universe = self.universe_for(debruijn);
                 let p = PlaceholderLike::new(universe, br);
                 self.mapped_regions.insert(p, br);
@@ -111,7 +113,7 @@ where
 
     fn fold_ty(&mut self, t: I::Ty) -> I::Ty {
         match t.kind() {
-            ty::Bound(debruijn, _)
+            ty::Bound(ty::BoundVarIndexKind::Bound(debruijn), _)
                 if debruijn.as_usize() + 1
                     > self.current_index.as_usize() + self.universe_indices.len() =>
             {
@@ -120,7 +122,9 @@ where
                     self.universe_indices
                 );
             }
-            ty::Bound(debruijn, bound_ty) if debruijn >= self.current_index => {
+            ty::Bound(ty::BoundVarIndexKind::Bound(debruijn), bound_ty)
+                if debruijn >= self.current_index =>
+            {
                 let universe = self.universe_for(debruijn);
                 let p = PlaceholderLike::new(universe, bound_ty);
                 self.mapped_types.insert(p, bound_ty);
@@ -133,7 +137,7 @@ where
 
     fn fold_const(&mut self, ct: I::Const) -> I::Const {
         match ct.kind() {
-            ty::ConstKind::Bound(debruijn, _)
+            ty::ConstKind::Bound(ty::BoundVarIndexKind::Bound(debruijn), _)
                 if debruijn.as_usize() + 1
                     > self.current_index.as_usize() + self.universe_indices.len() =>
             {
@@ -142,7 +146,9 @@ where
                     self.universe_indices
                 );
             }
-            ty::ConstKind::Bound(debruijn, bound_const) if debruijn >= self.current_index => {
+            ty::ConstKind::Bound(ty::BoundVarIndexKind::Bound(debruijn), bound_const)
+                if debruijn >= self.current_index =>
+            {
                 let universe = self.universe_for(debruijn);
                 let p = PlaceholderLike::new(universe, bound_const);
                 self.mapped_consts.insert(p, bound_const);
diff --git a/compiler/rustc_public/src/unstable/convert/stable/ty.rs b/compiler/rustc_public/src/unstable/convert/stable/ty.rs
index 7f14f878d3737..59440e5407f40 100644
--- a/compiler/rustc_public/src/unstable/convert/stable/ty.rs
+++ b/compiler/rustc_public/src/unstable/convert/stable/ty.rs
@@ -453,7 +453,10 @@ impl<'tcx> Stable<'tcx> for ty::TyKind<'tcx> {
                 TyKind::Alias(alias_kind.stable(tables, cx), alias_ty.stable(tables, cx))
             }
             ty::Param(param_ty) => TyKind::Param(param_ty.stable(tables, cx)),
-            ty::Bound(debruijn_idx, bound_ty) => {
+            ty::Bound(ty::BoundVarIndexKind::Canonical, _) => {
+                unreachable!()
+            }
+            ty::Bound(ty::BoundVarIndexKind::Bound(debruijn_idx), bound_ty) => {
                 TyKind::Bound(debruijn_idx.as_usize(), bound_ty.stable(tables, cx))
             }
             ty::CoroutineWitness(def_id, args) => TyKind::RigidTy(RigidTy::CoroutineWitness(
@@ -907,7 +910,7 @@ impl<'tcx> Stable<'tcx> for ty::RegionKind<'tcx> {
                 index: early_reg.index,
                 name: early_reg.name.to_string(),
             }),
-            ty::ReBound(db_index, bound_reg) => RegionKind::ReBound(
+            ty::ReBound(ty::BoundVarIndexKind::Bound(db_index), bound_reg) => RegionKind::ReBound(
                 db_index.as_u32(),
                 BoundRegion {
                     var: bound_reg.var.as_u32(),
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 ec7a4a81a71aa..621cc0fb3ef16 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
@@ -287,7 +287,7 @@ fn encode_region<'tcx>(region: Region<'tcx>, dict: &mut FxHashMap<DictKey<'tcx>,
     // u6region[I[<region-disambiguator>][<region-index>]E] as vendor extended type
     let mut s = String::new();
     match region.kind() {
-        RegionKind::ReBound(debruijn, r) => {
+        RegionKind::ReBound(ty::BoundVarIndexKind::Bound(debruijn), r) => {
             s.push_str("u6regionI");
             // Debruijn index, which identifies the binder, as region disambiguator
             let num = debruijn.index() as u64;
@@ -303,7 +303,8 @@ fn encode_region<'tcx>(region: Region<'tcx>, dict: &mut FxHashMap<DictKey<'tcx>,
             s.push_str("u6region");
             compress(dict, DictKey::Region(region), &mut s);
         }
-        RegionKind::ReEarlyParam(..)
+        RegionKind::ReBound(ty::BoundVarIndexKind::Canonical, _)
+        | RegionKind::ReEarlyParam(..)
         | RegionKind::ReLateParam(..)
         | RegionKind::ReStatic
         | RegionKind::ReError(_)
diff --git a/compiler/rustc_symbol_mangling/src/v0.rs b/compiler/rustc_symbol_mangling/src/v0.rs
index 9fa7e2f100393..d808ade58e693 100644
--- a/compiler/rustc_symbol_mangling/src/v0.rs
+++ b/compiler/rustc_symbol_mangling/src/v0.rs
@@ -412,7 +412,10 @@ impl<'tcx> Printer<'tcx> for V0SymbolMangler<'tcx> {
 
             // Bound lifetimes use indices starting at 1,
             // see `BinderLevel` for more details.
-            ty::ReBound(debruijn, ty::BoundRegion { var, kind: ty::BoundRegionKind::Anon }) => {
+            ty::ReBound(
+                ty::BoundVarIndexKind::Bound(debruijn),
+                ty::BoundRegion { var, kind: ty::BoundRegionKind::Anon },
+            ) => {
                 let binder = &self.binders[self.binders.len() - 1 - debruijn.index()];
                 let depth = binder.lifetime_depths.start + var.as_u32();
 
diff --git a/compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs b/compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs
index 3260dd712b9e4..6ab92531e4eff 100644
--- a/compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs
+++ b/compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs
@@ -830,7 +830,7 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for EraseEscapingBoundRegions<'tcx> {
     }
 
     fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
-        if let ty::ReBound(debruijn, _) = r.kind()
+        if let ty::ReBound(ty::BoundVarIndexKind::Bound(debruijn), _) = r.kind()
             && debruijn < self.binder
         {
             r
diff --git a/compiler/rustc_trait_selection/src/traits/query/normalize.rs b/compiler/rustc_trait_selection/src/traits/query/normalize.rs
index a54eb80fedc25..c6eb0caee1a6f 100644
--- a/compiler/rustc_trait_selection/src/traits/query/normalize.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/normalize.rs
@@ -145,7 +145,9 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for MaxEscapingBoundVarVisitor {
     #[inline]
     fn visit_region(&mut self, r: ty::Region<'tcx>) {
         match r.kind() {
-            ty::ReBound(debruijn, _) if debruijn > self.outer_index => {
+            ty::ReBound(ty::BoundVarIndexKind::Bound(debruijn), _)
+                if debruijn > self.outer_index =>
+            {
                 self.escaping =
                     self.escaping.max(debruijn.as_usize() - self.outer_index.as_usize());
             }
diff --git a/compiler/rustc_ty_utils/src/ty.rs b/compiler/rustc_ty_utils/src/ty.rs
index e91e5055e9053..bb25a14ef7443 100644
--- a/compiler/rustc_ty_utils/src/ty.rs
+++ b/compiler/rustc_ty_utils/src/ty.rs
@@ -235,7 +235,7 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for ImplTraitInTraitFinder<'_, 'tcx> {
             // bounds of the RPITIT. Shift these binders back out when
             // constructing the top-level projection predicate.
             let shifted_alias_ty = fold_regions(self.tcx, unshifted_alias_ty, |re, depth| {
-                if let ty::ReBound(index, bv) = re.kind() {
+                if let ty::ReBound(ty::BoundVarIndexKind::Bound(index), bv) = re.kind() {
                     if depth != ty::INNERMOST {
                         return ty::Region::new_error_with_message(
                             self.tcx,
diff --git a/compiler/rustc_type_ir/src/binder.rs b/compiler/rustc_type_ir/src/binder.rs
index 6591d3148cb14..94b950357e1e4 100644
--- a/compiler/rustc_type_ir/src/binder.rs
+++ b/compiler/rustc_type_ir/src/binder.rs
@@ -4,6 +4,7 @@ use std::ops::{ControlFlow, Deref};
 use derive_where::derive_where;
 #[cfg(feature = "nightly")]
 use rustc_macros::{Decodable_NoContext, Encodable_NoContext, HashStable_NoContext};
+use rustc_type_ir_macros::{TypeFoldable_Generic, TypeVisitable_Generic};
 use tracing::instrument;
 
 use crate::data_structures::SsoHashSet;
@@ -11,7 +12,7 @@ use crate::fold::{FallibleTypeFolder, TypeFoldable, TypeFolder, TypeSuperFoldabl
 use crate::inherent::*;
 use crate::lift::Lift;
 use crate::visit::{Flags, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor};
-use crate::{self as ty, Interner};
+use crate::{self as ty, DebruijnIndex, Interner};
 
 /// `Binder` is a binder for higher-ranked lifetimes or types. It is part of the
 /// compiler's representation for things like `for<'a> Fn(&'a isize)`
@@ -299,7 +300,9 @@ impl<I: Interner> TypeVisitor<I> for ValidateBoundVars<I> {
             return ControlFlow::Break(());
         }
         match t.kind() {
-            ty::Bound(debruijn, bound_ty) if debruijn == self.binder_index => {
+            ty::Bound(ty::BoundVarIndexKind::Bound(debruijn), bound_ty)
+                if debruijn == self.binder_index =>
+            {
                 let idx = bound_ty.var().as_usize();
                 if self.bound_vars.len() <= idx {
                     panic!("Not enough bound vars: {:?} not found in {:?}", t, self.bound_vars);
@@ -317,7 +320,9 @@ impl<I: Interner> TypeVisitor<I> for ValidateBoundVars<I> {
             return ControlFlow::Break(());
         }
         match c.kind() {
-            ty::ConstKind::Bound(debruijn, bound_const) if debruijn == self.binder_index => {
+            ty::ConstKind::Bound(debruijn, bound_const)
+                if debruijn == ty::BoundVarIndexKind::Bound(self.binder_index) =>
+            {
                 let idx = bound_const.var().as_usize();
                 if self.bound_vars.len() <= idx {
                     panic!("Not enough bound vars: {:?} not found in {:?}", c, self.bound_vars);
@@ -332,7 +337,7 @@ impl<I: Interner> TypeVisitor<I> for ValidateBoundVars<I> {
 
     fn visit_region(&mut self, r: I::Region) -> Self::Result {
         match r.kind() {
-            ty::ReBound(index, br) if index == self.binder_index => {
+            ty::ReBound(index, br) if index == ty::BoundVarIndexKind::Bound(self.binder_index) => {
                 let idx = br.var().as_usize();
                 if self.bound_vars.len() <= idx {
                     panic!("Not enough bound vars: {:?} not found in {:?}", r, self.bound_vars);
@@ -913,3 +918,33 @@ impl<'a, I: Interner> ArgFolder<'a, I> {
         }
     }
 }
+
+/// Okay, we do something fun for `Bound` types/regions/consts:
+/// Specifically, we distinguish between *canonically* bound things and
+/// `for<>` bound things. And, really, it comes down to caching during
+/// canonicalization and instantiation.
+///
+/// To understand why we do this, imagine we have a type `(T, for<> fn(T))`.
+/// If we just tracked canonically bound types with a `DebruijnIndex` (as we
+/// used to), then the canonicalized type would be something like
+/// `for<0> (^0.0, for<> fn(^1.0))` and so we can't cache `T -> ^0.0`,
+/// we have to also factor in binder level. (Of course, we don't cache that
+/// exactly, but rather the entire enclosing type, but the point stands.)
+///
+/// Of course, this is okay because we don't ever nest canonicalization, so
+/// `BoundVarIndexKind::Canonical` is unambiguous. We, alternatively, could
+/// have some sentinel `DebruijinIndex`, but that just seems too scary.
+///
+/// This doesn't seem to have a huge perf swing either way, but in the next
+/// solver, canonicalization is hot and there are some pathological cases where
+/// this is needed (`post-mono-higher-ranked-hang`).
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[cfg_attr(
+    feature = "nightly",
+    derive(Encodable_NoContext, Decodable_NoContext, HashStable_NoContext)
+)]
+#[derive(TypeVisitable_Generic, TypeFoldable_Generic)]
+pub enum BoundVarIndexKind {
+    Bound(DebruijnIndex),
+    Canonical,
+}
diff --git a/compiler/rustc_type_ir/src/canonical.rs b/compiler/rustc_type_ir/src/canonical.rs
index ecf3ae4f8b2c9..7b4b953b2cf65 100644
--- a/compiler/rustc_type_ir/src/canonical.rs
+++ b/compiler/rustc_type_ir/src/canonical.rs
@@ -230,13 +230,13 @@ impl<I: Interner> CanonicalVarValues<I> {
     pub fn is_identity(&self) -> bool {
         self.var_values.iter().enumerate().all(|(bv, arg)| match arg.kind() {
             ty::GenericArgKind::Lifetime(r) => {
-                matches!(r.kind(), ty::ReBound(ty::INNERMOST, br) if br.var().as_usize() == bv)
+                matches!(r.kind(), ty::ReBound(ty::BoundVarIndexKind::Canonical, br) if br.var().as_usize() == bv)
             }
             ty::GenericArgKind::Type(ty) => {
-                matches!(ty.kind(), ty::Bound(ty::INNERMOST, bt) if bt.var().as_usize() == bv)
+                matches!(ty.kind(), ty::Bound(ty::BoundVarIndexKind::Canonical, bt) if bt.var().as_usize() == bv)
             }
             ty::GenericArgKind::Const(ct) => {
-                matches!(ct.kind(), ty::ConstKind::Bound(ty::INNERMOST, bc) if bc.var().as_usize() == bv)
+                matches!(ct.kind(), ty::ConstKind::Bound(ty::BoundVarIndexKind::Canonical, bc) if bc.var().as_usize() == bv)
             }
         })
     }
@@ -246,21 +246,23 @@ impl<I: Interner> CanonicalVarValues<I> {
         for arg in self.var_values.iter() {
             match arg.kind() {
                 ty::GenericArgKind::Lifetime(r) => {
-                    if matches!(r.kind(), ty::ReBound(ty::INNERMOST, br) if var == br.var()) {
+                    if matches!(r.kind(), ty::ReBound(ty::BoundVarIndexKind::Canonical, br) if var == br.var())
+                    {
                         var = var + 1;
                     } else {
                         // It's ok if this region var isn't an identity variable
                     }
                 }
                 ty::GenericArgKind::Type(ty) => {
-                    if matches!(ty.kind(), ty::Bound(ty::INNERMOST, bt) if var == bt.var()) {
+                    if matches!(ty.kind(), ty::Bound(ty::BoundVarIndexKind::Canonical, bt) if var == bt.var())
+                    {
                         var = var + 1;
                     } else {
                         return false;
                     }
                 }
                 ty::GenericArgKind::Const(ct) => {
-                    if matches!(ct.kind(), ty::ConstKind::Bound(ty::INNERMOST, bc) if var == bc.var())
+                    if matches!(ct.kind(), ty::ConstKind::Bound(ty::BoundVarIndexKind::Canonical, bc) if var == bc.var())
                     {
                         var = var + 1;
                     } else {
@@ -284,16 +286,13 @@ impl<I: Interner> CanonicalVarValues<I> {
                         | CanonicalVarKind::Int
                         | CanonicalVarKind::Float
                         | CanonicalVarKind::PlaceholderTy(_) => {
-                            Ty::new_anon_bound(cx, ty::INNERMOST, ty::BoundVar::from_usize(i))
-                                .into()
+                            Ty::new_canonical_bound(cx, ty::BoundVar::from_usize(i)).into()
                         }
                         CanonicalVarKind::Region(_) | CanonicalVarKind::PlaceholderRegion(_) => {
-                            Region::new_anon_bound(cx, ty::INNERMOST, ty::BoundVar::from_usize(i))
-                                .into()
+                            Region::new_canonical_bound(cx, ty::BoundVar::from_usize(i)).into()
                         }
                         CanonicalVarKind::Const(_) | CanonicalVarKind::PlaceholderConst(_) => {
-                            Const::new_anon_bound(cx, ty::INNERMOST, ty::BoundVar::from_usize(i))
-                                .into()
+                            Const::new_canonical_bound(cx, ty::BoundVar::from_usize(i)).into()
                         }
                     }
                 },
diff --git a/compiler/rustc_type_ir/src/const_kind.rs b/compiler/rustc_type_ir/src/const_kind.rs
index 6de41b47bde08..273b609600876 100644
--- a/compiler/rustc_type_ir/src/const_kind.rs
+++ b/compiler/rustc_type_ir/src/const_kind.rs
@@ -7,7 +7,7 @@ use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_macros::{Decodable_NoContext, Encodable_NoContext, HashStable_NoContext};
 use rustc_type_ir_macros::{Lift_Generic, TypeFoldable_Generic, TypeVisitable_Generic};
 
-use crate::{self as ty, DebruijnIndex, Interner};
+use crate::{self as ty, BoundVarIndexKind, Interner};
 
 /// Represents a constant in Rust.
 #[derive_where(Clone, Copy, Hash, PartialEq; I: Interner)]
@@ -23,7 +23,7 @@ pub enum ConstKind<I: Interner> {
     Infer(InferConst),
 
     /// Bound const variable, used only when preparing a trait query.
-    Bound(DebruijnIndex, I::BoundConst),
+    Bound(BoundVarIndexKind, I::BoundConst),
 
     /// A placeholder const - universally quantified higher-ranked const.
     Placeholder(I::PlaceholderConst),
diff --git a/compiler/rustc_type_ir/src/flags.rs b/compiler/rustc_type_ir/src/flags.rs
index 24704c5bb5358..03099b3319843 100644
--- a/compiler/rustc_type_ir/src/flags.rs
+++ b/compiler/rustc_type_ir/src/flags.rs
@@ -133,6 +133,9 @@ bitflags::bitflags! {
 
         /// Does this type have any coroutines in it?
         const HAS_TY_CORO                 = 1 << 24;
+
+        /// Does this have have a `Bound(BoundVarIndexKind::Canonical, _)`?
+        const HAS_CANONICAL_BOUND      = 1 << 25;
     }
 }
 
@@ -254,7 +257,12 @@ impl<I: Interner> FlagComputation<I> {
                 self.add_args(args.as_slice());
             }
 
-            ty::Bound(debruijn, _) => {
+            ty::Bound(ty::BoundVarIndexKind::Canonical, _) => {
+                self.add_flags(TypeFlags::HAS_TY_BOUND);
+                self.add_flags(TypeFlags::HAS_CANONICAL_BOUND);
+            }
+
+            ty::Bound(ty::BoundVarIndexKind::Bound(debruijn), _) => {
                 self.add_bound_var(debruijn);
                 self.add_flags(TypeFlags::HAS_TY_BOUND);
             }
@@ -434,7 +442,7 @@ impl<I: Interner> FlagComputation<I> {
 
     fn add_region(&mut self, r: I::Region) {
         self.add_flags(r.flags());
-        if let ty::ReBound(debruijn, _) = r.kind() {
+        if let ty::ReBound(ty::BoundVarIndexKind::Bound(debruijn), _) = r.kind() {
             self.add_bound_var(debruijn);
         }
     }
@@ -454,10 +462,14 @@ impl<I: Interner> FlagComputation<I> {
                 ty::InferConst::Fresh(_) => self.add_flags(TypeFlags::HAS_CT_FRESH),
                 ty::InferConst::Var(_) => self.add_flags(TypeFlags::HAS_CT_INFER),
             },
-            ty::ConstKind::Bound(debruijn, _) => {
+            ty::ConstKind::Bound(ty::BoundVarIndexKind::Bound(debruijn), _) => {
                 self.add_bound_var(debruijn);
                 self.add_flags(TypeFlags::HAS_CT_BOUND);
             }
+            ty::ConstKind::Bound(ty::BoundVarIndexKind::Canonical, _) => {
+                self.add_flags(TypeFlags::HAS_CT_BOUND);
+                self.add_flags(TypeFlags::HAS_CANONICAL_BOUND);
+            }
             ty::ConstKind::Param(_) => {
                 self.add_flags(TypeFlags::HAS_CT_PARAM);
             }
diff --git a/compiler/rustc_type_ir/src/fold.rs b/compiler/rustc_type_ir/src/fold.rs
index a5eb8699e5fc6..d1a50599e8b9c 100644
--- a/compiler/rustc_type_ir/src/fold.rs
+++ b/compiler/rustc_type_ir/src/fold.rs
@@ -55,7 +55,7 @@ use tracing::{debug, instrument};
 
 use crate::inherent::*;
 use crate::visit::{TypeVisitable, TypeVisitableExt as _};
-use crate::{self as ty, Interner, TypeFlags};
+use crate::{self as ty, BoundVarIndexKind, Interner, TypeFlags};
 
 /// This trait is implemented for every type that can be folded,
 /// providing the skeleton of the traversal.
@@ -398,7 +398,9 @@ impl<I: Interner> TypeFolder<I> for Shifter<I> {
 
     fn fold_region(&mut self, r: I::Region) -> I::Region {
         match r.kind() {
-            ty::ReBound(debruijn, br) if debruijn >= self.current_index => {
+            ty::ReBound(ty::BoundVarIndexKind::Bound(debruijn), br)
+                if debruijn >= self.current_index =>
+            {
                 let debruijn = debruijn.shifted_in(self.amount);
                 Region::new_bound(self.cx, debruijn, br)
             }
@@ -408,7 +410,9 @@ impl<I: Interner> TypeFolder<I> for Shifter<I> {
 
     fn fold_ty(&mut self, ty: I::Ty) -> I::Ty {
         match ty.kind() {
-            ty::Bound(debruijn, bound_ty) if debruijn >= self.current_index => {
+            ty::Bound(BoundVarIndexKind::Bound(debruijn), bound_ty)
+                if debruijn >= self.current_index =>
+            {
                 let debruijn = debruijn.shifted_in(self.amount);
                 Ty::new_bound(self.cx, debruijn, bound_ty)
             }
@@ -420,7 +424,9 @@ impl<I: Interner> TypeFolder<I> for Shifter<I> {
 
     fn fold_const(&mut self, ct: I::Const) -> I::Const {
         match ct.kind() {
-            ty::ConstKind::Bound(debruijn, bound_ct) if debruijn >= self.current_index => {
+            ty::ConstKind::Bound(ty::BoundVarIndexKind::Bound(debruijn), bound_ct)
+                if debruijn >= self.current_index =>
+            {
                 let debruijn = debruijn.shifted_in(self.amount);
                 Const::new_bound(self.cx, debruijn, bound_ct)
             }
@@ -435,7 +441,7 @@ impl<I: Interner> TypeFolder<I> for Shifter<I> {
 
 pub fn shift_region<I: Interner>(cx: I, region: I::Region, amount: u32) -> I::Region {
     match region.kind() {
-        ty::ReBound(debruijn, br) if amount > 0 => {
+        ty::ReBound(ty::BoundVarIndexKind::Bound(debruijn), br) if amount > 0 => {
             Region::new_bound(cx, debruijn.shifted_in(amount), br)
         }
         _ => region,
@@ -515,7 +521,13 @@ where
     #[instrument(skip(self), level = "debug", ret)]
     fn fold_region(&mut self, r: I::Region) -> I::Region {
         match r.kind() {
-            ty::ReBound(debruijn, _) if debruijn < self.current_index => {
+            ty::ReBound(ty::BoundVarIndexKind::Bound(debruijn), _)
+                if debruijn < self.current_index =>
+            {
+                debug!(?self.current_index, "skipped bound region");
+                r
+            }
+            ty::ReBound(ty::BoundVarIndexKind::Canonical, _) => {
                 debug!(?self.current_index, "skipped bound region");
                 r
             }
diff --git a/compiler/rustc_type_ir/src/inherent.rs b/compiler/rustc_type_ir/src/inherent.rs
index b5b552dbaec09..75ba0231d98cb 100644
--- a/compiler/rustc_type_ir/src/inherent.rs
+++ b/compiler/rustc_type_ir/src/inherent.rs
@@ -48,6 +48,8 @@ pub trait Ty<I: Interner<Ty = Self>>:
 
     fn new_anon_bound(interner: I, debruijn: ty::DebruijnIndex, var: ty::BoundVar) -> Self;
 
+    fn new_canonical_bound(interner: I, var: ty::BoundVar) -> Self;
+
     fn new_alias(interner: I, kind: ty::AliasTyKind, alias_ty: ty::AliasTy<I>) -> Self;
 
     fn new_projection_from_args(interner: I, def_id: I::DefId, args: I::GenericArgs) -> Self {
@@ -230,6 +232,8 @@ pub trait Region<I: Interner<Region = Self>>:
 
     fn new_anon_bound(interner: I, debruijn: ty::DebruijnIndex, var: ty::BoundVar) -> Self;
 
+    fn new_canonical_bound(interner: I, var: ty::BoundVar) -> Self;
+
     fn new_static(interner: I) -> Self;
 
     fn new_placeholder(interner: I, var: I::PlaceholderRegion) -> Self;
@@ -260,6 +264,8 @@ pub trait Const<I: Interner<Const = Self>>:
 
     fn new_anon_bound(interner: I, debruijn: ty::DebruijnIndex, var: ty::BoundVar) -> Self;
 
+    fn new_canonical_bound(interner: I, var: ty::BoundVar) -> Self;
+
     fn new_placeholder(interner: I, param: I::PlaceholderConst) -> Self;
 
     fn new_unevaluated(interner: I, uv: ty::UnevaluatedConst<I>) -> Self;
diff --git a/compiler/rustc_type_ir/src/lib.rs b/compiler/rustc_type_ir/src/lib.rs
index 61e0b67b1639d..c1e3019612676 100644
--- a/compiler/rustc_type_ir/src/lib.rs
+++ b/compiler/rustc_type_ir/src/lib.rs
@@ -196,13 +196,20 @@ impl DebruijnIndex {
 
 pub fn debug_bound_var<T: std::fmt::Write>(
     fmt: &mut T,
-    debruijn: DebruijnIndex,
+    bound_index: BoundVarIndexKind,
     var: impl std::fmt::Debug,
 ) -> Result<(), std::fmt::Error> {
-    if debruijn == INNERMOST {
-        write!(fmt, "^{var:?}")
-    } else {
-        write!(fmt, "^{}_{:?}", debruijn.index(), var)
+    match bound_index {
+        BoundVarIndexKind::Bound(debruijn) => {
+            if debruijn == INNERMOST {
+                write!(fmt, "^{var:?}")
+            } else {
+                write!(fmt, "^{}_{:?}", debruijn.index(), var)
+            }
+        }
+        BoundVarIndexKind::Canonical => {
+            write!(fmt, "^c_{:?}", var)
+        }
     }
 }
 
diff --git a/compiler/rustc_type_ir/src/region_kind.rs b/compiler/rustc_type_ir/src/region_kind.rs
index 06048af043624..1e8585cf52ce8 100644
--- a/compiler/rustc_type_ir/src/region_kind.rs
+++ b/compiler/rustc_type_ir/src/region_kind.rs
@@ -7,7 +7,7 @@ use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_macros::{Decodable_NoContext, Encodable_NoContext, HashStable_NoContext};
 
 use self::RegionKind::*;
-use crate::{DebruijnIndex, Interner};
+use crate::{BoundVarIndexKind, Interner};
 
 rustc_index::newtype_index! {
     /// A **region** **v**ariable **ID**.
@@ -147,7 +147,7 @@ pub enum RegionKind<I: Interner> {
     /// Bound regions inside of types **must not** be erased, as they impact trait
     /// selection and the `TypeId` of that type. `for<'a> fn(&'a ())` and
     /// `fn(&'static ())` are different types and have to be treated as such.
-    ReBound(DebruijnIndex, I::BoundRegion),
+    ReBound(BoundVarIndexKind, I::BoundRegion),
 
     /// Late-bound function parameters are represented using a `ReBound`. When
     /// inside of a function, we convert these bound variables to placeholder
diff --git a/compiler/rustc_type_ir/src/ty_kind.rs b/compiler/rustc_type_ir/src/ty_kind.rs
index dda59283677cd..bb80e2cf46d45 100644
--- a/compiler/rustc_type_ir/src/ty_kind.rs
+++ b/compiler/rustc_type_ir/src/ty_kind.rs
@@ -15,7 +15,7 @@ pub use self::closure::*;
 use crate::inherent::*;
 #[cfg(feature = "nightly")]
 use crate::visit::TypeVisitable;
-use crate::{self as ty, DebruijnIndex, FloatTy, IntTy, Interner, UintTy};
+use crate::{self as ty, BoundVarIndexKind, FloatTy, IntTy, Interner, UintTy};
 
 mod closure;
 
@@ -229,7 +229,7 @@ pub enum TyKind<I: Interner> {
     ///
     /// [1]: https://rustc-dev-guide.rust-lang.org/traits/hrtb.html
     /// [2]: https://rustc-dev-guide.rust-lang.org/traits/canonical-queries.html
-    Bound(DebruijnIndex, I::BoundTy),
+    Bound(BoundVarIndexKind, I::BoundTy),
 
     /// A placeholder type, used during higher ranked subtyping to instantiate
     /// bound variables.
diff --git a/compiler/rustc_type_ir/src/ty_kind/closure.rs b/compiler/rustc_type_ir/src/ty_kind/closure.rs
index 3a6d1acfa8d93..4d9fd6040d8bf 100644
--- a/compiler/rustc_type_ir/src/ty_kind/closure.rs
+++ b/compiler/rustc_type_ir/src/ty_kind/closure.rs
@@ -344,7 +344,8 @@ impl<I: Interner> TypeVisitor<I> for HasRegionsBoundAt {
     }
 
     fn visit_region(&mut self, r: I::Region) -> Self::Result {
-        if matches!(r.kind(), ty::ReBound(binder, _) if self.binder == binder) {
+        if matches!(r.kind(), ty::ReBound(ty::BoundVarIndexKind::Bound(binder), _) if self.binder == binder)
+        {
             ControlFlow::Break(())
         } else {
             ControlFlow::Continue(())
@@ -531,7 +532,7 @@ impl<I: Interner> TypeFolder<I> for FoldEscapingRegions<I> {
     }
 
     fn fold_region(&mut self, r: <I as Interner>::Region) -> <I as Interner>::Region {
-        if let ty::ReBound(debruijn, _) = r.kind() {
+        if let ty::ReBound(ty::BoundVarIndexKind::Bound(debruijn), _) = r.kind() {
             assert!(
                 debruijn <= self.debruijn,
                 "cannot instantiate binder with escaping bound vars"
diff --git a/src/tools/clippy/clippy_lints/src/pass_by_ref_or_value.rs b/src/tools/clippy/clippy_lints/src/pass_by_ref_or_value.rs
index 1b1e77bbea8fb..6e9142b22e0ef 100644
--- a/src/tools/clippy/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/src/tools/clippy/clippy_lints/src/pass_by_ref_or_value.rs
@@ -14,7 +14,7 @@ use rustc_hir::{BindingMode, Body, FnDecl, Impl, ItemKind, MutTy, Mutability, No
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::adjustment::{Adjust, PointerCoercion};
 use rustc_middle::ty::layout::LayoutOf;
-use rustc_middle::ty::{self, RegionKind, TyCtxt};
+use rustc_middle::ty::{self, BoundVarIndexKind, RegionKind, TyCtxt};
 use rustc_session::impl_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{Span, sym};
@@ -151,7 +151,7 @@ impl PassByRefOrValue {
             match *ty.skip_binder().kind() {
                 ty::Ref(lt, ty, Mutability::Not) => {
                     match lt.kind() {
-                        RegionKind::ReBound(index, region)
+                        RegionKind::ReBound(BoundVarIndexKind::Bound(index), region)
                             if index.as_u32() == 0 && output_regions.contains(&region) =>
                         {
                             continue;
diff --git a/src/tools/clippy/clippy_utils/src/ty/mod.rs b/src/tools/clippy/clippy_utils/src/ty/mod.rs
index e4bc3b7682942..c03469c2b8851 100644
--- a/src/tools/clippy/clippy_utils/src/ty/mod.rs
+++ b/src/tools/clippy/clippy_utils/src/ty/mod.rs
@@ -21,7 +21,7 @@ use rustc_middle::traits::EvaluationResult;
 use rustc_middle::ty::adjustment::{Adjust, Adjustment};
 use rustc_middle::ty::layout::ValidityRequirement;
 use rustc_middle::ty::{
-    self, AdtDef, AliasTy, AssocItem, AssocTag, Binder, BoundRegion, FnSig, GenericArg, GenericArgKind, GenericArgsRef,
+    self, AdtDef, AliasTy, AssocItem, AssocTag, Binder, BoundRegion, BoundVarIndexKind, FnSig, GenericArg, GenericArgKind, GenericArgsRef,
     GenericParamDefKind, IntTy, Region, RegionKind, TraitRef, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable,
     TypeVisitableExt, TypeVisitor, UintTy, Upcast, VariantDef, VariantDiscr,
 };
@@ -826,7 +826,7 @@ pub fn for_each_top_level_late_bound_region<B>(
     impl<'tcx, B, F: FnMut(BoundRegion) -> ControlFlow<B>> TypeVisitor<TyCtxt<'tcx>> for V<F> {
         type Result = ControlFlow<B>;
         fn visit_region(&mut self, r: Region<'tcx>) -> Self::Result {
-            if let RegionKind::ReBound(idx, bound) = r.kind()
+            if let RegionKind::ReBound(BoundVarIndexKind::Bound(idx), bound) = r.kind()
                 && idx.as_u32() == self.index
             {
                 (self.f)(bound)
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 a18d7e7478fce..a1fe278c65207 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
@@ -1,30 +1,30 @@
 // MIR for `address_of_reborrow` after SimplifyCfg-initial
 
 | User Type Annotations
-| 0: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:8:10: 8:18, inferred_ty: *const [i32; 10]
+| 0: user_ty: Canonical { value: Ty(*const ^c_0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:8:10: 8:18, inferred_ty: *const [i32; 10]
 | 1: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:10:10: 10:25, inferred_ty: *const dyn std::marker::Send
-| 2: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:14:12: 14:20, inferred_ty: *const [i32; 10]
-| 3: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:14:12: 14:20, inferred_ty: *const [i32; 10]
+| 2: user_ty: Canonical { value: Ty(*const ^c_0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:14:12: 14:20, inferred_ty: *const [i32; 10]
+| 3: user_ty: Canonical { value: Ty(*const ^c_0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:14:12: 14:20, inferred_ty: *const [i32; 10]
 | 4: user_ty: Canonical { value: Ty(*const [i32; 10]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:15:12: 15:28, inferred_ty: *const [i32; 10]
 | 5: user_ty: Canonical { value: Ty(*const [i32; 10]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:15:12: 15:28, inferred_ty: *const [i32; 10]
 | 6: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:16:12: 16:27, inferred_ty: *const dyn std::marker::Send
 | 7: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:16:12: 16:27, inferred_ty: *const dyn std::marker::Send
 | 8: user_ty: Canonical { value: Ty(*const [i32]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:17:12: 17:24, inferred_ty: *const [i32]
 | 9: user_ty: Canonical { value: Ty(*const [i32]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:17:12: 17:24, inferred_ty: *const [i32]
-| 10: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:19:10: 19:18, inferred_ty: *const [i32; 10]
+| 10: user_ty: Canonical { value: Ty(*const ^c_0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:19:10: 19:18, inferred_ty: *const [i32; 10]
 | 11: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:21:10: 21:25, inferred_ty: *const dyn std::marker::Send
-| 12: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:24:12: 24:20, inferred_ty: *const [i32; 10]
-| 13: user_ty: Canonical { value: Ty(*const ^0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:24:12: 24:20, inferred_ty: *const [i32; 10]
+| 12: user_ty: Canonical { value: Ty(*const ^c_0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:24:12: 24:20, inferred_ty: *const [i32; 10]
+| 13: user_ty: Canonical { value: Ty(*const ^c_0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:24:12: 24:20, inferred_ty: *const [i32; 10]
 | 14: user_ty: Canonical { value: Ty(*const [i32; 10]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:25:12: 25:28, inferred_ty: *const [i32; 10]
 | 15: user_ty: Canonical { value: Ty(*const [i32; 10]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:25:12: 25:28, inferred_ty: *const [i32; 10]
 | 16: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:26:12: 26:27, inferred_ty: *const dyn std::marker::Send
 | 17: user_ty: Canonical { value: Ty(*const dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:26:12: 26:27, inferred_ty: *const dyn std::marker::Send
 | 18: user_ty: Canonical { value: Ty(*const [i32]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:27:12: 27:24, inferred_ty: *const [i32]
 | 19: user_ty: Canonical { value: Ty(*const [i32]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:27:12: 27:24, inferred_ty: *const [i32]
-| 20: user_ty: Canonical { value: Ty(*mut ^0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:29:10: 29:16, inferred_ty: *mut [i32; 10]
+| 20: user_ty: Canonical { value: Ty(*mut ^c_0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:29:10: 29:16, inferred_ty: *mut [i32; 10]
 | 21: user_ty: Canonical { value: Ty(*mut dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:31:10: 31:23, inferred_ty: *mut dyn std::marker::Send
-| 22: user_ty: Canonical { value: Ty(*mut ^0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:34:12: 34:18, inferred_ty: *mut [i32; 10]
-| 23: user_ty: Canonical { value: Ty(*mut ^0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:34:12: 34:18, inferred_ty: *mut [i32; 10]
+| 22: user_ty: Canonical { value: Ty(*mut ^c_0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:34:12: 34:18, inferred_ty: *mut [i32; 10]
+| 23: user_ty: Canonical { value: Ty(*mut ^c_0), max_universe: U0, variables: [Ty { ui: U0, sub_root: 0 }] }, span: $DIR/address_of.rs:34:12: 34:18, inferred_ty: *mut [i32; 10]
 | 24: user_ty: Canonical { value: Ty(*mut [i32; 10]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:35:12: 35:26, inferred_ty: *mut [i32; 10]
 | 25: user_ty: Canonical { value: Ty(*mut [i32; 10]), max_universe: U0, variables: [] }, span: $DIR/address_of.rs:35:12: 35:26, inferred_ty: *mut [i32; 10]
 | 26: user_ty: Canonical { value: Ty(*mut dyn std::marker::Send), max_universe: U0, variables: [Region(U0)] }, span: $DIR/address_of.rs:36:12: 36:25, inferred_ty: *mut dyn std::marker::Send
diff --git a/tests/ui/async-await/async-closures/post-mono-higher-ranked-hang.stderr b/tests/ui/async-await/async-closures/post-mono-higher-ranked-hang.current.stderr
similarity index 85%
rename from tests/ui/async-await/async-closures/post-mono-higher-ranked-hang.stderr
rename to tests/ui/async-await/async-closures/post-mono-higher-ranked-hang.current.stderr
index 486e5f9416550..f3938ff606f4d 100644
--- a/tests/ui/async-await/async-closures/post-mono-higher-ranked-hang.stderr
+++ b/tests/ui/async-await/async-closures/post-mono-higher-ranked-hang.current.stderr
@@ -1,5 +1,5 @@
-error: reached the recursion limit while instantiating `ToChain::<'_, '_>::perm_pairs::<{async closure@$DIR/post-mono-higher-ranked-hang.rs:43:45: 43:67}>`
-  --> $DIR/post-mono-higher-ranked-hang.rs:43:21
+error: reached the recursion limit while instantiating `ToChain::<'_, '_>::perm_pairs::<{async closure@$DIR/post-mono-higher-ranked-hang.rs:47:45: 47:67}>`
+  --> $DIR/post-mono-higher-ranked-hang.rs:47:21
    |
 LL | /                     self.perm_pairs(l, &mut async move |left_pair| {
 LL | |
@@ -8,7 +8,7 @@ LL | |                     })
    | |______________________^
    |
 note: `ToChain::<'env, 'db>::perm_pairs` defined here
-  --> $DIR/post-mono-higher-ranked-hang.rs:34:5
+  --> $DIR/post-mono-higher-ranked-hang.rs:38:5
    |
 LL | /     fn perm_pairs<'l>(
 LL | |         &'l self,
diff --git a/tests/ui/async-await/async-closures/post-mono-higher-ranked-hang.next.stderr b/tests/ui/async-await/async-closures/post-mono-higher-ranked-hang.next.stderr
new file mode 100644
index 0000000000000..f3938ff606f4d
--- /dev/null
+++ b/tests/ui/async-await/async-closures/post-mono-higher-ranked-hang.next.stderr
@@ -0,0 +1,21 @@
+error: reached the recursion limit while instantiating `ToChain::<'_, '_>::perm_pairs::<{async closure@$DIR/post-mono-higher-ranked-hang.rs:47:45: 47:67}>`
+  --> $DIR/post-mono-higher-ranked-hang.rs:47:21
+   |
+LL | /                     self.perm_pairs(l, &mut async move |left_pair| {
+LL | |
+LL | |                         self.perm_pairs(r, yield_chain).await
+LL | |                     })
+   | |______________________^
+   |
+note: `ToChain::<'env, 'db>::perm_pairs` defined here
+  --> $DIR/post-mono-higher-ranked-hang.rs:38:5
+   |
+LL | /     fn perm_pairs<'l>(
+LL | |         &'l self,
+LL | |         perm: &'l SymPerm<'db>,
+LL | |         yield_chain: &'l mut impl AsyncFnMut(&SymPerm<'db>),
+LL | |     ) -> Pin<Box<dyn std::future::Future<Output = ()> + 'l>> {
+   | |____________________________________________________________^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/async-await/async-closures/post-mono-higher-ranked-hang.rs b/tests/ui/async-await/async-closures/post-mono-higher-ranked-hang.rs
index f6ebf787f81b9..55d7cc30ec964 100644
--- a/tests/ui/async-await/async-closures/post-mono-higher-ranked-hang.rs
+++ b/tests/ui/async-await/async-closures/post-mono-higher-ranked-hang.rs
@@ -2,6 +2,10 @@
 //@ aux-build:block-on.rs
 //@ edition:2021
 
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
+
 // Regression test for <https://github.com/rust-lang/rust/issues/135780>.
 
 extern crate block_on;
diff --git a/tests/ui/higher-ranked/trait-bounds/issue-59311.stderr b/tests/ui/higher-ranked/trait-bounds/issue-59311.stderr
index a26c617dc931d..f8f64dcc545bc 100644
--- a/tests/ui/higher-ranked/trait-bounds/issue-59311.stderr
+++ b/tests/ui/higher-ranked/trait-bounds/issue-59311.stderr
@@ -37,7 +37,7 @@ error: higher-ranked lifetime error
 LL |     v.t(|| {});
    |         ^^^^^
    |
-   = note: could not prove `for<'a> &'a V: 'b`
+   = note: could not prove `for<'a> &'a V: '_`
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/higher-ranked/trait-bounds/trivial-does-not-hold.stderr b/tests/ui/higher-ranked/trait-bounds/trivial-does-not-hold.stderr
index 9e0d7e4b7be09..a04c6d770d73e 100644
--- a/tests/ui/higher-ranked/trait-bounds/trivial-does-not-hold.stderr
+++ b/tests/ui/higher-ranked/trait-bounds/trivial-does-not-hold.stderr
@@ -4,7 +4,7 @@ error: higher-ranked lifetime error
 LL |     || {};
    |     ^^^^^
    |
-   = note: could not prove `for<'a> &'a (): 'b`
+   = note: could not prove `for<'a> &'a (): '_`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/re-empty-in-error.stderr b/tests/ui/lifetimes/re-empty-in-error.stderr
index 554bcb5451fc0..b3b6d3d269c9b 100644
--- a/tests/ui/lifetimes/re-empty-in-error.stderr
+++ b/tests/ui/lifetimes/re-empty-in-error.stderr
@@ -4,7 +4,7 @@ error: higher-ranked lifetime error
 LL |     foo(&10);
    |     ^^^^^^^^
    |
-   = note: could not prove `for<'b> &'b (): 'a`
+   = note: could not prove `for<'b> &'b (): '_`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/user-annotations/dump-fn-method.rs b/tests/ui/nll/user-annotations/dump-fn-method.rs
index 26714b6ffe3a6..ec349e36839ad 100644
--- a/tests/ui/nll/user-annotations/dump-fn-method.rs
+++ b/tests/ui/nll/user-annotations/dump-fn-method.rs
@@ -31,7 +31,7 @@ fn main() {
     // Here: we only want the `T` to be given, the rest should be variables.
     //
     // (`T` refers to the declaration of `Bazoom`)
-    let x = <_ as Bazoom<u32>>::method::<_>; //~ ERROR [^0, u32, ^1]
+    let x = <_ as Bazoom<u32>>::method::<_>; //~ ERROR [^c_0, u32, ^c_1]
     x(&22, 44, 66);
 
     // Here: all are given and definitely contain no lifetimes, so we
@@ -48,7 +48,7 @@ fn main() {
     //
     // (`U` refers to the declaration of `Bazoom`)
     let y = 22_u32;
-    y.method::<u32>(44, 66); //~ ERROR [^0, ^1, u32]
+    y.method::<u32>(44, 66); //~ ERROR [^c_0, ^c_1, u32]
 
     // Here: nothing is given, so we don't have any annotation.
     let y = 22_u32;
diff --git a/tests/ui/nll/user-annotations/dump-fn-method.stderr b/tests/ui/nll/user-annotations/dump-fn-method.stderr
index 8e847b464e181..f00fb0013dfd8 100644
--- a/tests/ui/nll/user-annotations/dump-fn-method.stderr
+++ b/tests/ui/nll/user-annotations/dump-fn-method.stderr
@@ -4,7 +4,7 @@ error: user args: UserArgs { args: [&'static u32], user_self_ty: None }
 LL |     let x = foo::<&'static u32>;
    |             ^^^^^^^^^^^^^^^^^^^
 
-error: user args: UserArgs { args: [^0, u32, ^1], user_self_ty: None }
+error: user args: UserArgs { args: [^c_0, u32, ^c_1], user_self_ty: None }
   --> $DIR/dump-fn-method.rs:34:13
    |
 LL |     let x = <_ as Bazoom<u32>>::method::<_>;
@@ -16,7 +16,7 @@ error: user args: UserArgs { args: [u8, &'static u16, u32], user_self_ty: None }
 LL |     let x = <u8 as Bazoom<&'static u16>>::method::<u32>;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: user args: UserArgs { args: [^0, ^1, u32], user_self_ty: None }
+error: user args: UserArgs { args: [^c_0, ^c_1, u32], user_self_ty: None }
   --> $DIR/dump-fn-method.rs:51:5
    |
 LL |     y.method::<u32>(44, 66);

From 1db4d8ebfdf14896c43fc714507e37b97db5d289 Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Sun, 28 Sep 2025 23:04:55 +0000
Subject: [PATCH 1602/1889] Split Bound into Canonical and Bound

---
 clippy_lints/src/pass_by_ref_or_value.rs | 4 ++--
 clippy_utils/src/ty/mod.rs               | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index 1b1e77bbea8fb..6e9142b22e0ef 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -14,7 +14,7 @@ use rustc_hir::{BindingMode, Body, FnDecl, Impl, ItemKind, MutTy, Mutability, No
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::adjustment::{Adjust, PointerCoercion};
 use rustc_middle::ty::layout::LayoutOf;
-use rustc_middle::ty::{self, RegionKind, TyCtxt};
+use rustc_middle::ty::{self, BoundVarIndexKind, RegionKind, TyCtxt};
 use rustc_session::impl_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{Span, sym};
@@ -151,7 +151,7 @@ impl PassByRefOrValue {
             match *ty.skip_binder().kind() {
                 ty::Ref(lt, ty, Mutability::Not) => {
                     match lt.kind() {
-                        RegionKind::ReBound(index, region)
+                        RegionKind::ReBound(BoundVarIndexKind::Bound(index), region)
                             if index.as_u32() == 0 && output_regions.contains(&region) =>
                         {
                             continue;
diff --git a/clippy_utils/src/ty/mod.rs b/clippy_utils/src/ty/mod.rs
index e4bc3b7682942..c03469c2b8851 100644
--- a/clippy_utils/src/ty/mod.rs
+++ b/clippy_utils/src/ty/mod.rs
@@ -21,7 +21,7 @@ use rustc_middle::traits::EvaluationResult;
 use rustc_middle::ty::adjustment::{Adjust, Adjustment};
 use rustc_middle::ty::layout::ValidityRequirement;
 use rustc_middle::ty::{
-    self, AdtDef, AliasTy, AssocItem, AssocTag, Binder, BoundRegion, FnSig, GenericArg, GenericArgKind, GenericArgsRef,
+    self, AdtDef, AliasTy, AssocItem, AssocTag, Binder, BoundRegion, BoundVarIndexKind, FnSig, GenericArg, GenericArgKind, GenericArgsRef,
     GenericParamDefKind, IntTy, Region, RegionKind, TraitRef, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable,
     TypeVisitableExt, TypeVisitor, UintTy, Upcast, VariantDef, VariantDiscr,
 };
@@ -826,7 +826,7 @@ pub fn for_each_top_level_late_bound_region<B>(
     impl<'tcx, B, F: FnMut(BoundRegion) -> ControlFlow<B>> TypeVisitor<TyCtxt<'tcx>> for V<F> {
         type Result = ControlFlow<B>;
         fn visit_region(&mut self, r: Region<'tcx>) -> Self::Result {
-            if let RegionKind::ReBound(idx, bound) = r.kind()
+            if let RegionKind::ReBound(BoundVarIndexKind::Bound(idx), bound) = r.kind()
                 && idx.as_u32() == self.index
             {
                 (self.f)(bound)

From 50398e2e7505779323e5371b1905c4ad56a29097 Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Tue, 30 Sep 2025 17:56:18 +0000
Subject: [PATCH 1603/1889] iter repeat: add tests for new count and last
 behavior

---
 library/coretests/tests/iter/sources.rs | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/library/coretests/tests/iter/sources.rs b/library/coretests/tests/iter/sources.rs
index 506febaa056a8..5a391cb67751d 100644
--- a/library/coretests/tests/iter/sources.rs
+++ b/library/coretests/tests/iter/sources.rs
@@ -30,6 +30,17 @@ fn test_repeat_take_collect() {
     assert_eq!(v, vec![42, 42, 42]);
 }
 
+#[test]
+#[should_panic = "iterator is infinite"]
+fn test_repeat_count() {
+    repeat(42).count();
+}
+
+#[test]
+fn test_repeat_last() {
+    assert_eq!(repeat(42).last(), Some(42));
+}
+
 #[test]
 fn test_repeat_with() {
     #[derive(PartialEq, Debug)]

From 61b1f0e37fad6842c24c41b0de2cb7dbf90f658f Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 23 Aug 2025 06:51:50 -0400
Subject: [PATCH 1604/1889] `assertions_on_constants`: Don't suggest removing
 assertions with non-local constants.

---
 clippy_lints/src/assertions_on_constants.rs | 102 +++++++++++---------
 clippy_lints/src/lib.rs                     |   2 +-
 clippy_utils/src/msrvs.rs                   |   3 +-
 tests/ui/assertions_on_constants.rs         |  29 +++++-
 tests/ui/assertions_on_constants.stderr     |  88 +++++++++++------
 5 files changed, 145 insertions(+), 79 deletions(-)

diff --git a/clippy_lints/src/assertions_on_constants.rs b/clippy_lints/src/assertions_on_constants.rs
index b6684825835a9..a6518216aa820 100644
--- a/clippy_lints/src/assertions_on_constants.rs
+++ b/clippy_lints/src/assertions_on_constants.rs
@@ -1,10 +1,13 @@
+use clippy_config::Conf;
 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::{PanicExpn, find_assert_args, root_macro_call_first_node};
+use clippy_utils::macros::{find_assert_args, root_macro_call_first_node};
+use clippy_utils::msrvs::Msrv;
+use clippy_utils::{is_inside_always_const_context, msrvs};
+use rustc_ast::LitKind;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::declare_lint_pass;
+use rustc_session::impl_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
@@ -28,56 +31,59 @@ declare_clippy_lint! {
     "`assert!(true)` / `assert!(false)` will be optimized out by the compiler, and should probably be replaced by a `panic!()` or `unreachable!()`"
 }
 
-declare_lint_pass!(AssertionsOnConstants => [ASSERTIONS_ON_CONSTANTS]);
+impl_lint_pass!(AssertionsOnConstants => [ASSERTIONS_ON_CONSTANTS]);
+pub struct AssertionsOnConstants {
+    msrv: Msrv,
+}
+impl AssertionsOnConstants {
+    pub fn new(conf: &Conf) -> Self {
+        Self { msrv: conf.msrv }
+    }
+}
 
 impl<'tcx> LateLintPass<'tcx> for AssertionsOnConstants {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        let Some(macro_call) = root_macro_call_first_node(cx, e) else {
-            return;
-        };
-        let is_debug = match cx.tcx.get_diagnostic_name(macro_call.def_id) {
-            Some(sym::debug_assert_macro) => true,
-            Some(sym::assert_macro) => false,
-            _ => return,
-        };
-        let Some((condition, panic_expn)) = find_assert_args(cx, e, macro_call.expn) else {
-            return;
-        };
-        let Some(Constant::Bool(val)) = ConstEvalCtxt::new(cx).eval(condition) else {
-            return;
-        };
+        if let Some(macro_call) = root_macro_call_first_node(cx, e)
+            && let is_debug = match cx.tcx.get_diagnostic_name(macro_call.def_id) {
+                Some(sym::debug_assert_macro) => true,
+                Some(sym::assert_macro) => false,
+                _ => return,
+            }
+            && let Some((condition, _)) = find_assert_args(cx, e, macro_call.expn)
+            && let Some((Constant::Bool(assert_val), const_src)) = ConstEvalCtxt::new(cx).eval_with_source(condition)
+            && let in_const_context = is_inside_always_const_context(cx.tcx, e.hir_id)
+            && (const_src.is_local() || !in_const_context)
+            && !(is_debug && as_bool_lit(condition) == Some(false))
+        {
+            let (msg, help) = if !const_src.is_local() {
+                let help = if self.msrv.meets(cx, msrvs::CONST_BLOCKS) {
+                    "consider moving this into a const block: `const { assert!(..) }`"
+                } else if self.msrv.meets(cx, msrvs::CONST_PANIC) {
+                    "consider moving this to an anonymous constant: `const _: () = { assert!(..); }`"
+                } else {
+                    return;
+                };
+                ("this assertion has a constant value", help)
+            } else if assert_val {
+                ("this assertion is always `true`", "remove the assertion")
+            } else {
+                (
+                    "this assertion is always `false`",
+                    "replace this with `panic!()` or `unreachable!()`",
+                )
+            };
 
-        match condition.kind {
-            ExprKind::Path(..) | ExprKind::Lit(_) => {},
-            _ if is_inside_always_const_context(cx.tcx, e.hir_id) => return,
-            _ => {},
+            span_lint_and_help(cx, ASSERTIONS_ON_CONSTANTS, macro_call.span, msg, None, help);
         }
+    }
+}
 
-        if val {
-            span_lint_and_help(
-                cx,
-                ASSERTIONS_ON_CONSTANTS,
-                macro_call.span,
-                format!(
-                    "`{}!(true)` will be optimized out by the compiler",
-                    cx.tcx.item_name(macro_call.def_id)
-                ),
-                None,
-                "remove it",
-            );
-        } else if !is_debug {
-            let (assert_arg, panic_arg) = match panic_expn {
-                PanicExpn::Empty => ("", ""),
-                _ => (", ..", ".."),
-            };
-            span_lint_and_help(
-                cx,
-                ASSERTIONS_ON_CONSTANTS,
-                macro_call.span,
-                format!("`assert!(false{assert_arg})` should probably be replaced"),
-                None,
-                format!("use `panic!({panic_arg})` or `unreachable!({panic_arg})`"),
-            );
-        }
+fn as_bool_lit(e: &Expr<'_>) -> Option<bool> {
+    if let ExprKind::Lit(l) = e.kind
+        && let LitKind::Bool(b) = l.node
+    {
+        Some(b)
+    } else {
+        None
     }
 }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 51dabee78e9fb..0a955d2383194 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -595,7 +595,7 @@ pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Co
     store.register_late_pass(|_| Box::new(redundant_clone::RedundantClone));
     store.register_late_pass(|_| Box::new(slow_vector_initialization::SlowVectorInit));
     store.register_late_pass(move |_| Box::new(unnecessary_wraps::UnnecessaryWraps::new(conf)));
-    store.register_late_pass(|_| Box::new(assertions_on_constants::AssertionsOnConstants));
+    store.register_late_pass(|_| Box::new(assertions_on_constants::AssertionsOnConstants::new(conf)));
     store.register_late_pass(|_| Box::new(assertions_on_result_states::AssertionsOnResultStates));
     store.register_late_pass(|_| Box::new(inherent_to_string::InherentToString));
     store.register_late_pass(move |_| Box::new(trait_bounds::TraitBounds::new(conf)));
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 5ce28a582f4ab..995deba077788 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -31,6 +31,7 @@ msrv_aliases! {
     1,82,0 { IS_NONE_OR, REPEAT_N, RAW_REF_OP }
     1,81,0 { LINT_REASONS_STABILIZATION, ERROR_IN_CORE, EXPLICIT_SELF_TYPE_ELISION, DURATION_ABS_DIFF }
     1,80,0 { BOX_INTO_ITER, LAZY_CELL }
+    1,79,0 { CONST_BLOCKS }
     1,77,0 { C_STR_LITERALS }
     1,76,0 { PTR_FROM_REF, OPTION_RESULT_INSPECT }
     1,75,0 { OPTION_AS_SLICE }
@@ -46,7 +47,7 @@ msrv_aliases! {
     1,60,0 { ABS_DIFF }
     1,59,0 { THREAD_LOCAL_CONST_INIT }
     1,58,0 { FORMAT_ARGS_CAPTURE, PATTERN_TRAIT_CHAR_ARRAY, CONST_RAW_PTR_DEREF }
-    1,57,0 { MAP_WHILE }
+    1,57,0 { MAP_WHILE, CONST_PANIC }
     1,56,0 { CONST_FN_UNION }
     1,55,0 { SEEK_REWIND }
     1,54,0 { INTO_KEYS }
diff --git a/tests/ui/assertions_on_constants.rs b/tests/ui/assertions_on_constants.rs
index c2516c5414753..b613892f206a6 100644
--- a/tests/ui/assertions_on_constants.rs
+++ b/tests/ui/assertions_on_constants.rs
@@ -42,7 +42,6 @@ fn main() {
     assert_const!(3);
     assert_const!(-1);
 
-    // Don't lint if based on `cfg!(..)`:
     assert!(cfg!(feature = "hey") || cfg!(not(feature = "asdf")));
 
     let flag: bool = cfg!(not(feature = "asdf"));
@@ -62,9 +61,37 @@ fn main() {
     const _: () = assert!(N.is_power_of_two());
 }
 
+const C: bool = true;
+
 const _: () = {
     assert!(true);
     //~^ assertions_on_constants
 
     assert!(8 == (7 + 1));
+    //~^ assertions_on_constants
+
+    assert!(C);
 };
+
+#[clippy::msrv = "1.57"]
+fn _f1() {
+    assert!(C);
+    //~^ assertions_on_constants
+}
+
+#[clippy::msrv = "1.56"]
+fn _f2() {
+    assert!(C);
+}
+
+#[clippy::msrv = "1.79"]
+fn _f3() {
+    assert!(C);
+    //~^ assertions_on_constants
+}
+
+#[clippy::msrv = "1.78"]
+fn _f4() {
+    assert!(C);
+    //~^ assertions_on_constants
+}
diff --git a/tests/ui/assertions_on_constants.stderr b/tests/ui/assertions_on_constants.stderr
index 8b7440ec4832c..9aed1405fa043 100644
--- a/tests/ui/assertions_on_constants.stderr
+++ b/tests/ui/assertions_on_constants.stderr
@@ -1,100 +1,132 @@
-error: `assert!(true)` will be optimized out by the compiler
+error: this assertion is always `true`
   --> tests/ui/assertions_on_constants.rs:10:5
    |
 LL |     assert!(true);
    |     ^^^^^^^^^^^^^
    |
-   = help: remove it
+   = help: remove the assertion
    = note: `-D clippy::assertions-on-constants` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::assertions_on_constants)]`
 
-error: `assert!(false)` should probably be replaced
+error: this assertion is always `false`
   --> tests/ui/assertions_on_constants.rs:13:5
    |
 LL |     assert!(false);
    |     ^^^^^^^^^^^^^^
    |
-   = help: use `panic!()` or `unreachable!()`
+   = help: replace this with `panic!()` or `unreachable!()`
 
-error: `assert!(true)` will be optimized out by the compiler
+error: this assertion is always `true`
   --> tests/ui/assertions_on_constants.rs:16:5
    |
 LL |     assert!(true, "true message");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: remove it
+   = help: remove the assertion
 
-error: `assert!(false, ..)` should probably be replaced
+error: this assertion is always `false`
   --> tests/ui/assertions_on_constants.rs:19:5
    |
 LL |     assert!(false, "false message");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: use `panic!(..)` or `unreachable!(..)`
+   = help: replace this with `panic!()` or `unreachable!()`
 
-error: `assert!(false, ..)` should probably be replaced
+error: this assertion is always `false`
   --> tests/ui/assertions_on_constants.rs:23:5
    |
 LL |     assert!(false, "{}", msg.to_uppercase());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: use `panic!(..)` or `unreachable!(..)`
+   = help: replace this with `panic!()` or `unreachable!()`
 
-error: `assert!(true)` will be optimized out by the compiler
+error: this assertion has a constant value
   --> tests/ui/assertions_on_constants.rs:27:5
    |
 LL |     assert!(B);
    |     ^^^^^^^^^^
    |
-   = help: remove it
+   = help: consider moving this into a const block: `const { assert!(..) }`
 
-error: `assert!(false)` should probably be replaced
+error: this assertion has a constant value
   --> tests/ui/assertions_on_constants.rs:31:5
    |
 LL |     assert!(C);
    |     ^^^^^^^^^^
    |
-   = help: use `panic!()` or `unreachable!()`
+   = help: consider moving this into a const block: `const { assert!(..) }`
 
-error: `assert!(false, ..)` should probably be replaced
+error: this assertion has a constant value
   --> tests/ui/assertions_on_constants.rs:34:5
    |
 LL |     assert!(C, "C message");
    |     ^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: use `panic!(..)` or `unreachable!(..)`
+   = help: consider moving this into a const block: `const { assert!(..) }`
 
-error: `debug_assert!(true)` will be optimized out by the compiler
+error: this assertion is always `true`
   --> tests/ui/assertions_on_constants.rs:37:5
    |
 LL |     debug_assert!(true);
    |     ^^^^^^^^^^^^^^^^^^^
    |
-   = help: remove it
+   = help: remove the assertion
 
-error: `assert!(true)` will be optimized out by the compiler
-  --> tests/ui/assertions_on_constants.rs:54:19
+error: this assertion is always `true`
+  --> tests/ui/assertions_on_constants.rs:53:19
    |
 LL |     const _: () = assert!(true);
    |                   ^^^^^^^^^^^^^
    |
-   = help: remove it
+   = help: remove the assertion
 
-error: `assert!(true)` will be optimized out by the compiler
-  --> tests/ui/assertions_on_constants.rs:57:5
+error: this assertion is always `true`
+  --> tests/ui/assertions_on_constants.rs:56:5
    |
 LL |     assert!(8 == (7 + 1));
    |     ^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: remove it
+   = help: remove the assertion
 
-error: `assert!(true)` will be optimized out by the compiler
-  --> tests/ui/assertions_on_constants.rs:66:5
+error: this assertion is always `true`
+  --> tests/ui/assertions_on_constants.rs:67:5
    |
 LL |     assert!(true);
    |     ^^^^^^^^^^^^^
    |
-   = help: remove it
+   = help: remove the assertion
 
-error: aborting due to 12 previous errors
+error: this assertion is always `true`
+  --> tests/ui/assertions_on_constants.rs:70:5
+   |
+LL |     assert!(8 == (7 + 1));
+   |     ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: remove the assertion
+
+error: this assertion has a constant value
+  --> tests/ui/assertions_on_constants.rs:78:5
+   |
+LL |     assert!(C);
+   |     ^^^^^^^^^^
+   |
+   = help: consider moving this to an anonymous constant: `const _: () = { assert!(..); }`
+
+error: this assertion has a constant value
+  --> tests/ui/assertions_on_constants.rs:89:5
+   |
+LL |     assert!(C);
+   |     ^^^^^^^^^^
+   |
+   = help: consider moving this into a const block: `const { assert!(..) }`
+
+error: this assertion has a constant value
+  --> tests/ui/assertions_on_constants.rs:95:5
+   |
+LL |     assert!(C);
+   |     ^^^^^^^^^^
+   |
+   = help: consider moving this to an anonymous constant: `const _: () = { assert!(..); }`
+
+error: aborting due to 16 previous errors
 

From 6edf05b740070429e57ec18e5c027167dbb17ab4 Mon Sep 17 00:00:00 2001
From: Yotam Ofek <yotam.ofek@gmail.com>
Date: Tue, 30 Sep 2025 00:14:03 +0300
Subject: [PATCH 1605/1889] Add `#[bench]` for librustdoc's syntax highlighter

---
 src/bootstrap/src/core/builder/mod.rs  |  2 +-
 src/librustdoc/html/highlight/tests.rs | 14 ++++++++++++++
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/src/bootstrap/src/core/builder/mod.rs b/src/bootstrap/src/core/builder/mod.rs
index 006dea4b98d13..fc06db8f80b9d 100644
--- a/src/bootstrap/src/core/builder/mod.rs
+++ b/src/bootstrap/src/core/builder/mod.rs
@@ -1145,7 +1145,7 @@ impl<'a> Builder<'a> {
                 test::RunMakeCargo,
             ),
             Kind::Miri => describe!(test::Crate),
-            Kind::Bench => describe!(test::Crate, test::CrateLibrustc),
+            Kind::Bench => describe!(test::Crate, test::CrateLibrustc, test::CrateRustdoc),
             Kind::Doc => describe!(
                 doc::UnstableBook,
                 doc::UnstableBookGen,
diff --git a/src/librustdoc/html/highlight/tests.rs b/src/librustdoc/html/highlight/tests.rs
index 2603e887bead5..4d1bee9b3a1b3 100644
--- a/src/librustdoc/html/highlight/tests.rs
+++ b/src/librustdoc/html/highlight/tests.rs
@@ -1,6 +1,7 @@
 use expect_test::expect_file;
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_span::create_default_session_globals_then;
+use test::Bencher;
 
 use super::{DecorationInfo, write_code};
 
@@ -81,3 +82,16 @@ let a = 4;";
         expect_file!["fixtures/decorations.html"].assert_eq(&html);
     });
 }
+
+#[bench]
+fn bench_html_highlighting(b: &mut Bencher) {
+    let src = include_str!("../../../../compiler/rustc_ast/src/visit.rs");
+
+    create_default_session_globals_then(|| {
+        b.iter(|| {
+            let mut out = String::new();
+            write_code(&mut out, src, None, None, None);
+            out
+        });
+    });
+}

From cbaec31c10c5eff7342e5273360521911fbf7631 Mon Sep 17 00:00:00 2001
From: Josh Simmons <josh@nega.tv>
Date: Thu, 26 Jun 2025 21:31:05 +0200
Subject: [PATCH 1606/1889] Add fast-path for accessing the current thread id

Accessing the thread id is often used in profiling and debugging, as
well as some approaches for sound single-threaded access to data.

Currently the only way to access the thread id is by first obtaining a
handle to the current thread. While this is not exactly slow, it does
require an atomic inc-ref and dec-ref operation, as well as the
injection of `Thread`'s drop code into the caller.

This publicly exposes the existing fast-path for accessing the current
thread id.
---
 library/std/src/thread/current.rs | 24 ++++++++++++++++++++++--
 library/std/src/thread/mod.rs     |  4 +++-
 2 files changed, 25 insertions(+), 3 deletions(-)

diff --git a/library/std/src/thread/current.rs b/library/std/src/thread/current.rs
index 7da1621da45ce..f00212bfcb617 100644
--- a/library/std/src/thread/current.rs
+++ b/library/std/src/thread/current.rs
@@ -133,12 +133,32 @@ pub(super) fn set_current(thread: Thread) -> Result<(), Thread> {
     Ok(())
 }
 
-/// Gets the id of the thread that invokes it.
+/// Gets the unique identifier of the thread which invokes it.
+///
+/// Calling this function may be more efficient than accessing the current
+/// thread id through the current thread handle. i.e. `thread::current().id()`.
 ///
 /// This function will always succeed, will always return the same value for
 /// one thread and is guaranteed not to call the global allocator.
+///
+/// # Examples
+///
+/// ```
+/// #![feature(current_thread_id)]
+///
+/// use std::thread;
+///
+/// let other_thread = thread::spawn(|| {
+///     thread::current_id()
+/// });
+///
+/// let other_thread_id = other_thread.join().unwrap();
+/// assert_ne!(thread::current_id(), other_thread_id);
+/// ```
 #[inline]
-pub(crate) fn current_id() -> ThreadId {
+#[must_use]
+#[unstable(feature = "current_thread_id", issue = "147194")]
+pub fn current_id() -> ThreadId {
     // If accessing the persistent thread ID takes multiple TLS accesses, try
     // to retrieve it from the current thread handle, which will only take one
     // TLS access.
diff --git a/library/std/src/thread/mod.rs b/library/std/src/thread/mod.rs
index 4d09b2b4e9d2e..1768369792ae2 100644
--- a/library/std/src/thread/mod.rs
+++ b/library/std/src/thread/mod.rs
@@ -183,7 +183,9 @@ mod current;
 
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use current::current;
-pub(crate) use current::{current_id, current_or_unnamed, current_os_id, drop_current};
+#[unstable(feature = "current_thread_id", issue = "147194")]
+pub use current::current_id;
+pub(crate) use current::{current_or_unnamed, current_os_id, drop_current};
 use current::{set_current, try_with_current};
 
 mod spawnhook;

From 2d03ab1486c11f2c5f8a19ae040b94edc090b279 Mon Sep 17 00:00:00 2001
From: Yotam Ofek <yotam.ofek@gmail.com>
Date: Tue, 30 Sep 2025 17:12:31 +0300
Subject: [PATCH 1607/1889] Replace `rustc_span::Span` with a stripped down
 version for librustdoc's highlighter

---
 src/librustdoc/html/highlight.rs       |  3 +-
 src/librustdoc/html/render/context.rs  |  3 +-
 src/librustdoc/html/render/mod.rs      |  2 +-
 src/librustdoc/html/render/span_map.rs | 68 ++++++++++++++++++++------
 src/librustdoc/html/sources.rs         |  7 ++-
 5 files changed, 65 insertions(+), 18 deletions(-)

diff --git a/src/librustdoc/html/highlight.rs b/src/librustdoc/html/highlight.rs
index fad15573cde0c..1dcb4dcc3ff83 100644
--- a/src/librustdoc/html/highlight.rs
+++ b/src/librustdoc/html/highlight.rs
@@ -12,15 +12,16 @@ use std::iter;
 
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_lexer::{Cursor, FrontmatterAllowed, LiteralKind, TokenKind};
+use rustc_span::BytePos;
 use rustc_span::edition::Edition;
 use rustc_span::symbol::Symbol;
-use rustc_span::{BytePos, DUMMY_SP, Span};
 
 use super::format;
 use crate::clean::PrimitiveType;
 use crate::display::Joined as _;
 use crate::html::escape::EscapeBodyText;
 use crate::html::macro_expansion::ExpandedCode;
+use crate::html::render::span_map::{DUMMY_SP, Span};
 use crate::html::render::{Context, LinkFromSrc};
 
 /// This type is needed in case we want to render links on items to allow to go to their definition.
diff --git a/src/librustdoc/html/render/context.rs b/src/librustdoc/html/render/context.rs
index 5f92ab2fada9c..4c06d0da47013 100644
--- a/src/librustdoc/html/render/context.rs
+++ b/src/librustdoc/html/render/context.rs
@@ -30,6 +30,7 @@ use crate::formats::item_type::ItemType;
 use crate::html::escape::Escape;
 use crate::html::macro_expansion::ExpandedCode;
 use crate::html::markdown::{self, ErrorCodes, IdMap, plain_text_summary};
+use crate::html::render::span_map::Span;
 use crate::html::render::write_shared::write_shared;
 use crate::html::url_parts_builder::UrlPartsBuilder;
 use crate::html::{layout, sources, static_files};
@@ -139,7 +140,7 @@ pub(crate) struct SharedContext<'tcx> {
 
     /// Correspondence map used to link types used in the source code pages to allow to click on
     /// links to jump to the type's definition.
-    pub(crate) span_correspondence_map: FxHashMap<rustc_span::Span, LinkFromSrc>,
+    pub(crate) span_correspondence_map: FxHashMap<Span, LinkFromSrc>,
     pub(crate) expanded_codes: FxHashMap<BytePos, Vec<ExpandedCode>>,
     /// The [`Cache`] used during rendering.
     pub(crate) cache: Cache,
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index 97dcaf57cdfa6..d6371e4dbab3e 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -36,7 +36,7 @@ mod ordered_json;
 mod print_item;
 pub(crate) mod sidebar;
 mod sorted_template;
-mod span_map;
+pub(crate) mod span_map;
 mod type_layout;
 mod write_shared;
 
diff --git a/src/librustdoc/html/render/span_map.rs b/src/librustdoc/html/render/span_map.rs
index ef7ce33298d91..bc9417b1bb1de 100644
--- a/src/librustdoc/html/render/span_map.rs
+++ b/src/librustdoc/html/render/span_map.rs
@@ -8,11 +8,48 @@ use rustc_hir::{ExprKind, HirId, Item, ItemKind, Mod, Node, QPath};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::TyCtxt;
 use rustc_span::hygiene::MacroKind;
-use rustc_span::{BytePos, ExpnKind, Span};
+use rustc_span::{BytePos, ExpnKind};
 
 use crate::clean::{self, PrimitiveType, rustc_span};
 use crate::html::sources;
 
+/// This is a stripped down version of [`rustc_span::Span`] that only contains the start and end byte positions of the span.
+///
+/// Profiling showed that the `Span` interner was taking up a lot of the run-time when highlighting, and since we
+/// never actually use the context and parent that are stored in a normal `Span`, we can replace its usages with this
+/// one, which is much cheaper to construct.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub(crate) struct Span {
+    lo: BytePos,
+    hi: BytePos,
+}
+
+impl From<rustc_span::Span> for Span {
+    fn from(value: rustc_span::Span) -> Self {
+        Self { lo: value.lo(), hi: value.hi() }
+    }
+}
+
+impl Span {
+    pub(crate) fn lo(self) -> BytePos {
+        self.lo
+    }
+
+    pub(crate) fn hi(self) -> BytePos {
+        self.hi
+    }
+
+    pub(crate) fn with_lo(self, lo: BytePos) -> Self {
+        Self { lo, hi: self.hi() }
+    }
+
+    pub(crate) fn with_hi(self, hi: BytePos) -> Self {
+        Self { lo: self.lo(), hi }
+    }
+}
+
+pub(crate) const DUMMY_SP: Span = Span { lo: BytePos(0), hi: BytePos(0) };
+
 /// This enum allows us to store two different kinds of information:
 ///
 /// In case the `span` definition comes from the same crate, we can simply get the `span` and use
@@ -96,7 +133,7 @@ impl SpanMapVisitor<'_> {
                         })
                         .unwrap_or(path.span)
                 };
-                self.matches.insert(span, link);
+                self.matches.insert(span.into(), link);
             }
             Res::Local(_) if let Some(span) = self.tcx.hir_res_span(path.res) => {
                 let path_span = if only_use_last_segment
@@ -106,11 +143,12 @@ impl SpanMapVisitor<'_> {
                 } else {
                     path.span
                 };
-                self.matches.insert(path_span, LinkFromSrc::Local(clean::Span::new(span)));
+                self.matches.insert(path_span.into(), LinkFromSrc::Local(clean::Span::new(span)));
             }
             Res::PrimTy(p) => {
                 // FIXME: Doesn't handle "path-like" primitives like arrays or tuples.
-                self.matches.insert(path.span, LinkFromSrc::Primitive(PrimitiveType::from(p)));
+                self.matches
+                    .insert(path.span.into(), LinkFromSrc::Primitive(PrimitiveType::from(p)));
             }
             Res::Err => {}
             _ => {}
@@ -127,7 +165,7 @@ impl SpanMapVisitor<'_> {
             if cspan.inner().is_dummy() || cspan.cnum(self.tcx.sess) != LOCAL_CRATE {
                 return;
             }
-            self.matches.insert(span, LinkFromSrc::Doc(item.owner_id.to_def_id()));
+            self.matches.insert(span.into(), LinkFromSrc::Doc(item.owner_id.to_def_id()));
         }
     }
 
@@ -138,7 +176,7 @@ impl SpanMapVisitor<'_> {
     /// so, we loop until we find the macro definition by using `outer_expn_data` in a loop.
     /// Finally, we get the information about the macro itself (`span` if "local", `DefId`
     /// otherwise) and store it inside the span map.
-    fn handle_macro(&mut self, span: Span) -> bool {
+    fn handle_macro(&mut self, span: rustc_span::Span) -> bool {
         if !span.from_expansion() {
             return false;
         }
@@ -176,7 +214,7 @@ impl SpanMapVisitor<'_> {
         // The "call_site" includes the whole macro with its "arguments". We only want
         // the macro name.
         let new_span = new_span.with_hi(new_span.lo() + BytePos(macro_name.len() as u32));
-        self.matches.insert(new_span, link_from_src);
+        self.matches.insert(new_span.into(), link_from_src);
         true
     }
 
@@ -233,7 +271,7 @@ impl<'tcx> Visitor<'tcx> for SpanMapVisitor<'tcx> {
         intravisit::walk_path(self, path);
     }
 
-    fn visit_qpath(&mut self, qpath: &QPath<'tcx>, id: HirId, _span: Span) {
+    fn visit_qpath(&mut self, qpath: &QPath<'tcx>, id: HirId, _span: rustc_span::Span) {
         match *qpath {
             QPath::TypeRelative(qself, path) => {
                 if matches!(path.res, Res::Err) {
@@ -249,7 +287,7 @@ impl<'tcx> Visitor<'tcx> for SpanMapVisitor<'tcx> {
                         self.handle_path(&path, false);
                     }
                 } else {
-                    self.infer_id(path.hir_id, Some(id), path.ident.span);
+                    self.infer_id(path.hir_id, Some(id), path.ident.span.into());
                 }
 
                 rustc_ast::visit::try_visit!(self.visit_ty_unambig(qself));
@@ -267,7 +305,7 @@ impl<'tcx> Visitor<'tcx> for SpanMapVisitor<'tcx> {
         }
     }
 
-    fn visit_mod(&mut self, m: &'tcx Mod<'tcx>, span: Span, id: HirId) {
+    fn visit_mod(&mut self, m: &'tcx Mod<'tcx>, span: rustc_span::Span, id: HirId) {
         // To make the difference between "mod foo {}" and "mod foo;". In case we "import" another
         // file, we want to link to it. Otherwise no need to create a link.
         if !span.overlaps(m.spans.inner_span) {
@@ -275,8 +313,10 @@ impl<'tcx> Visitor<'tcx> for SpanMapVisitor<'tcx> {
             // name only and not all the "mod foo;".
             if let Node::Item(item) = self.tcx.hir_node(id) {
                 let (ident, _) = item.expect_mod();
-                self.matches
-                    .insert(ident.span, LinkFromSrc::Local(clean::Span::new(m.spans.inner_span)));
+                self.matches.insert(
+                    ident.span.into(),
+                    LinkFromSrc::Local(clean::Span::new(m.spans.inner_span)),
+                );
             }
         } else {
             // If it's a "mod foo {}", we want to look to its documentation page.
@@ -288,9 +328,9 @@ impl<'tcx> Visitor<'tcx> for SpanMapVisitor<'tcx> {
     fn visit_expr(&mut self, expr: &'tcx rustc_hir::Expr<'tcx>) {
         match expr.kind {
             ExprKind::MethodCall(segment, ..) => {
-                self.infer_id(segment.hir_id, Some(expr.hir_id), segment.ident.span)
+                self.infer_id(segment.hir_id, Some(expr.hir_id), segment.ident.span.into())
             }
-            ExprKind::Call(call, ..) => self.infer_id(call.hir_id, None, call.span),
+            ExprKind::Call(call, ..) => self.infer_id(call.hir_id, None, call.span.into()),
             _ => {
                 if self.handle_macro(expr.span) {
                     // We don't want to go deeper into the macro.
diff --git a/src/librustdoc/html/sources.rs b/src/librustdoc/html/sources.rs
index 9c5518a780e44..c79f63fbc2032 100644
--- a/src/librustdoc/html/sources.rs
+++ b/src/librustdoc/html/sources.rs
@@ -348,7 +348,12 @@ pub(crate) fn print_src(
         highlight::write_code(
             fmt,
             s,
-            Some(highlight::HrefContext { context, file_span, root_path, current_href }),
+            Some(highlight::HrefContext {
+                context,
+                file_span: file_span.into(),
+                root_path,
+                current_href,
+            }),
             Some(decoration_info),
             Some(line_info),
         );

From 80e598bb12297c5df04e5b380a4f51aa4dfc5d63 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Tue, 30 Sep 2025 13:29:39 +0200
Subject: [PATCH 1608/1889] clone region obligations instead of taking in
 implied bounds hack

---
 compiler/rustc_infer/src/infer/outlives/obligations.rs    | 4 ++++
 .../src/traits/query/type_op/implied_outlives_bounds.rs   | 8 +++++++-
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_infer/src/infer/outlives/obligations.rs b/compiler/rustc_infer/src/infer/outlives/obligations.rs
index b989d419057b1..a640dcb1b4e1e 100644
--- a/compiler/rustc_infer/src/infer/outlives/obligations.rs
+++ b/compiler/rustc_infer/src/infer/outlives/obligations.rs
@@ -170,6 +170,10 @@ impl<'tcx> InferCtxt<'tcx> {
         std::mem::take(&mut self.inner.borrow_mut().region_obligations)
     }
 
+    pub fn clone_registered_region_obligations(&self) -> Vec<TypeOutlivesConstraint<'tcx>> {
+        self.inner.borrow().region_obligations.clone()
+    }
+
     pub fn register_region_assumption(&self, assumption: ty::ArgOutlivesPredicate<'tcx>) {
         let mut inner = self.inner.borrow_mut();
         inner.undo_log.push(UndoLog::PushRegionAssumption);
diff --git a/compiler/rustc_trait_selection/src/traits/query/type_op/implied_outlives_bounds.rs b/compiler/rustc_trait_selection/src/traits/query/type_op/implied_outlives_bounds.rs
index 7540cbe3fd1a4..e55ffb4d5fdb9 100644
--- a/compiler/rustc_trait_selection/src/traits/query/type_op/implied_outlives_bounds.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/type_op/implied_outlives_bounds.rs
@@ -55,6 +55,12 @@ pub fn compute_implied_outlives_bounds_inner<'tcx>(
     span: Span,
     disable_implied_bounds_hack: bool,
 ) -> Result<Vec<OutlivesBound<'tcx>>, NoSolution> {
+    // Inside mir borrowck, each computation starts with an empty list.
+    assert!(
+        ocx.infcx.inner.borrow().region_obligations().is_empty(),
+        "compute_implied_outlives_bounds assumes region obligations are empty before starting"
+    );
+
     let normalize_ty = |ty| -> Result<_, NoSolution> {
         // We must normalize the type so we can compute the right outlives components.
         // for example, if we have some constrained param type like `T: Trait<Out = U>`,
@@ -143,7 +149,7 @@ pub fn compute_implied_outlives_bounds_inner<'tcx>(
         && ty.visit_with(&mut ContainsBevyParamSet { tcx: ocx.infcx.tcx }).is_break()
     {
         for TypeOutlivesConstraint { sup_type, sub_region, .. } in
-            ocx.infcx.take_registered_region_obligations()
+            ocx.infcx.clone_registered_region_obligations()
         {
             let mut components = smallvec![];
             push_outlives_components(ocx.infcx.tcx, sup_type, &mut components);

From bdebd479acb692319ace3f88bf874ea365503199 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Tue, 30 Sep 2025 14:01:05 +0200
Subject: [PATCH 1609/1889] remove outdated context (inner) infctx

---
 compiler/rustc_infer/src/infer/mod.rs         | 17 -----------------
 compiler/rustc_trait_selection/src/regions.rs |  2 ++
 2 files changed, 2 insertions(+), 17 deletions(-)

diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
index c9fc124d3bf8d..f3ebfde06ab6b 100644
--- a/compiler/rustc_infer/src/infer/mod.rs
+++ b/compiler/rustc_infer/src/infer/mod.rs
@@ -131,23 +131,6 @@ pub struct InferCtxtInner<'tcx> {
     /// `$0: 'static`. This will get checked later by regionck. (We
     /// can't generally check these things right away because we have
     /// to wait until types are resolved.)
-    ///
-    /// These are stored in a map keyed to the id of the innermost
-    /// enclosing fn body / static initializer expression. This is
-    /// because the location where the obligation was incurred can be
-    /// relevant with respect to which sublifetime assumptions are in
-    /// place. The reason that we store under the fn-id, and not
-    /// something more fine-grained, is so that it is easier for
-    /// regionck to be sure that it has found *all* the region
-    /// obligations (otherwise, it's easy to fail to walk to a
-    /// particular node-id).
-    ///
-    /// Before running `resolve_regions_and_report_errors`, the creator
-    /// of the inference context is expected to invoke
-    /// [`InferCtxt::process_registered_region_obligations`]
-    /// for each body-id in this map, which will process the
-    /// obligations within. This is expected to be done 'late enough'
-    /// that all type inference variables have been bound and so forth.
     region_obligations: Vec<TypeOutlivesConstraint<'tcx>>,
 
     /// The outlives bounds that we assume must hold about placeholders that
diff --git a/compiler/rustc_trait_selection/src/regions.rs b/compiler/rustc_trait_selection/src/regions.rs
index 2b33b8ac9f86c..debc4fda15a56 100644
--- a/compiler/rustc_trait_selection/src/regions.rs
+++ b/compiler/rustc_trait_selection/src/regions.rs
@@ -77,6 +77,8 @@ impl<'tcx> InferCtxt<'tcx> {
     ///
     /// Prefer this method over `resolve_regions_with_normalize`, unless you are
     /// doing something specific for normalization.
+    ///
+    /// This function assumes that all infer variables are already constrained.
     fn resolve_regions(
         &self,
         body_id: LocalDefId,

From c1318053e3ab0578420ba93720dc479e3b526f12 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Wed, 1 Oct 2025 00:10:49 +0200
Subject: [PATCH 1610/1889] add test for trait-system-refactor-initiative/239

---
 .../coroutine/handle_opaques_before_coroutines.rs | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 tests/ui/coroutine/handle_opaques_before_coroutines.rs

diff --git a/tests/ui/coroutine/handle_opaques_before_coroutines.rs b/tests/ui/coroutine/handle_opaques_before_coroutines.rs
new file mode 100644
index 0000000000000..2771c77429cac
--- /dev/null
+++ b/tests/ui/coroutine/handle_opaques_before_coroutines.rs
@@ -0,0 +1,15 @@
+// test for https://github.com/rust-lang/trait-system-refactor-initiative/issues/239
+//@edition: 2024
+//@ check-pass
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
+
+fn foo<'a>() -> impl Send {
+    if false {
+        foo();
+    }
+    async {}
+}
+
+fn main() {}

From 422f6bb7420e1f1fe1cd920ed0c6b22f5042ae35 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Wed, 1 Oct 2025 01:10:24 +0200
Subject: [PATCH 1611/1889] enable tests on next-solver for
 rust-lang/trait-system-refactor-initiative/237

---
 tests/ui/type/pattern_types/const_generics.rs                 | 3 +++
 .../{transmute.stderr => transmute.current.stderr}            | 4 ++--
 tests/ui/type/pattern_types/transmute.rs                      | 3 +++
 3 files changed, 8 insertions(+), 2 deletions(-)
 rename tests/ui/type/pattern_types/{transmute.stderr => transmute.current.stderr} (92%)

diff --git a/tests/ui/type/pattern_types/const_generics.rs b/tests/ui/type/pattern_types/const_generics.rs
index 79d46c010d733..f5eb90e94d4fd 100644
--- a/tests/ui/type/pattern_types/const_generics.rs
+++ b/tests/ui/type/pattern_types/const_generics.rs
@@ -1,4 +1,7 @@
 //@ check-pass
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
 
 #![feature(pattern_types, generic_pattern_types, pattern_type_macro)]
 #![expect(incomplete_features)]
diff --git a/tests/ui/type/pattern_types/transmute.stderr b/tests/ui/type/pattern_types/transmute.current.stderr
similarity index 92%
rename from tests/ui/type/pattern_types/transmute.stderr
rename to tests/ui/type/pattern_types/transmute.current.stderr
index 578549b515c10..edec542e5e151 100644
--- a/tests/ui/type/pattern_types/transmute.stderr
+++ b/tests/ui/type/pattern_types/transmute.current.stderr
@@ -1,5 +1,5 @@
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute.rs:20:14
+  --> $DIR/transmute.rs:23:14
    |
 LL |     unsafe { std::mem::transmute(x) }
    |              ^^^^^^^^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL |     unsafe { std::mem::transmute(x) }
    = note: target type: `u32` (32 bits)
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute.rs:28:14
+  --> $DIR/transmute.rs:31:14
    |
 LL |     unsafe { std::mem::transmute(x) }
    |              ^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/type/pattern_types/transmute.rs b/tests/ui/type/pattern_types/transmute.rs
index 43dd62a19e706..4e686245f9375 100644
--- a/tests/ui/type/pattern_types/transmute.rs
+++ b/tests/ui/type/pattern_types/transmute.rs
@@ -1,3 +1,6 @@
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
 #![feature(pattern_types, pattern_type_macro, generic_pattern_types)]
 #![expect(incomplete_features)]
 

From ddbaca521edf274b1462fced5b50ee6983fb8d01 Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Tue, 30 Sep 2025 17:56:12 -0400
Subject: [PATCH 1612/1889] fix void and empty struct ret

---
 compiler/rustc_codegen_llvm/src/builder/autodiff.rs | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
index c3485f563916f..4a749642265df 100644
--- a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
+++ b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
@@ -378,5 +378,12 @@ pub(crate) fn generate_enzyme_call<'ll, 'tcx>(
 
     let call = builder.call(enzyme_ty, None, None, ad_fn, &args, None, None);
 
-    builder.store_to_place(call, dest.val);
+    let fn_ret_ty = builder.cx.val_ty(call);
+    if fn_ret_ty != builder.cx.type_void() && fn_ret_ty != builder.cx.type_struct(&[], false) {
+        // If we return void or an empty struct, then our caller (due to how we generated it)
+        // does not expect a return value. As such, we have no pointer (or place) into which
+        // we could store our value, and would store into an undef, which would cause UB.
+        // As such, we just ignore the return value in those cases.
+        builder.store_to_place(call, dest.val);
+    }
 }

From 28ffbab35382164167a5f101bb0181d7f77bffc2 Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Tue, 30 Sep 2025 17:56:26 -0400
Subject: [PATCH 1613/1889] add empty struct ret testcase

---
 tests/codegen-llvm/autodiff/void_ret.rs | 41 +++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 tests/codegen-llvm/autodiff/void_ret.rs

diff --git a/tests/codegen-llvm/autodiff/void_ret.rs b/tests/codegen-llvm/autodiff/void_ret.rs
new file mode 100644
index 0000000000000..98c6b98eef4e3
--- /dev/null
+++ b/tests/codegen-llvm/autodiff/void_ret.rs
@@ -0,0 +1,41 @@
+//@ compile-flags: -Zautodiff=Enable,NoTT,NoPostopt -C no-prepopulate-passes -C opt-level=3  -Clto=fat
+//@ no-prefer-dynamic
+//@ needs-enzyme
+
+#![feature(autodiff)]
+use std::autodiff::*;
+
+// Usually we would store the return value of the differentiated function.
+// However, if the return type is void or an empty struct,
+// we don't need to store anything. Verify this, since it caused a bug.
+
+// CHECK:; void_ret::main
+// CHECK-NEXT:    ; Function Attrs:
+// CHECK-NEXT:    define internal
+// CHECK-NOT: store {} undef, ptr undef
+// CHECK: ret void
+
+#[autodiff_reverse(bar, Duplicated, Duplicated)]
+pub fn foo(r: &[f64; 10], res: &mut f64) {
+    let mut output = [0.0; 10];
+    output[0] = r[0];
+    output[1] = r[1] * r[2];
+    output[2] = r[4] * r[5];
+    output[3] = r[2] * r[6];
+    output[4] = r[1] * r[7];
+    output[5] = r[2] * r[8];
+    output[6] = r[1] * r[9];
+    output[7] = r[5] * r[6];
+    output[8] = r[5] * r[7];
+    output[9] = r[4] * r[8];
+    *res = output.iter().sum();
+}
+fn main() {
+    let inputs = Box::new([3.1; 10]);
+    let mut d_inputs = Box::new([0.0; 10]);
+    let mut res = Box::new(0.0);
+    let mut d_res = Box::new(1.0);
+
+    bar(&inputs, &mut d_inputs, &mut res, &mut d_res);
+    dbg!(&d_inputs);
+}

From de189fa982ad8830c326fac443ab830728567aff Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Sun, 28 Sep 2025 19:45:12 -0400
Subject: [PATCH 1614/1889] updating tests to not break from new typetree
 metadata

---
 tests/codegen-llvm/autodiff/abi_handling.rs | 4 ++--
 tests/codegen-llvm/autodiff/batched.rs      | 2 +-
 tests/codegen-llvm/autodiff/scalar.rs       | 2 +-
 tests/codegen-llvm/autodiff/sret.rs         | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/tests/codegen-llvm/autodiff/abi_handling.rs b/tests/codegen-llvm/autodiff/abi_handling.rs
index 454ec698b917c..5c8126898a8d7 100644
--- a/tests/codegen-llvm/autodiff/abi_handling.rs
+++ b/tests/codegen-llvm/autodiff/abi_handling.rs
@@ -1,7 +1,7 @@
 //@ revisions: debug release
 
-//@[debug] compile-flags: -Zautodiff=Enable -C opt-level=0 -Clto=fat
-//@[release] compile-flags: -Zautodiff=Enable -C opt-level=3 -Clto=fat
+//@[debug] compile-flags: -Zautodiff=Enable,NoTT -C opt-level=0 -Clto=fat
+//@[release] compile-flags: -Zautodiff=Enable,NoTT -C opt-level=3 -Clto=fat
 //@ no-prefer-dynamic
 //@ needs-enzyme
 
diff --git a/tests/codegen-llvm/autodiff/batched.rs b/tests/codegen-llvm/autodiff/batched.rs
index 306a6ed9d1f4f..dc82403212fb0 100644
--- a/tests/codegen-llvm/autodiff/batched.rs
+++ b/tests/codegen-llvm/autodiff/batched.rs
@@ -1,4 +1,4 @@
-//@ compile-flags: -Zautodiff=Enable -C opt-level=3  -Clto=fat
+//@ compile-flags: -Zautodiff=Enable,NoTT -C opt-level=3  -Clto=fat
 //@ no-prefer-dynamic
 //@ needs-enzyme
 //
diff --git a/tests/codegen-llvm/autodiff/scalar.rs b/tests/codegen-llvm/autodiff/scalar.rs
index 55b989f920da3..53672a89230ab 100644
--- a/tests/codegen-llvm/autodiff/scalar.rs
+++ b/tests/codegen-llvm/autodiff/scalar.rs
@@ -1,4 +1,4 @@
-//@ compile-flags: -Zautodiff=Enable -C opt-level=3  -Clto=fat
+//@ compile-flags: -Zautodiff=Enable,NoTT -C opt-level=3  -Clto=fat
 //@ no-prefer-dynamic
 //@ needs-enzyme
 #![feature(autodiff)]
diff --git a/tests/codegen-llvm/autodiff/sret.rs b/tests/codegen-llvm/autodiff/sret.rs
index dbc253ce89434..498cd3fea012d 100644
--- a/tests/codegen-llvm/autodiff/sret.rs
+++ b/tests/codegen-llvm/autodiff/sret.rs
@@ -1,4 +1,4 @@
-//@ compile-flags: -Zautodiff=Enable -C opt-level=3  -Clto=fat
+//@ compile-flags: -Zautodiff=Enable,NoTT -C opt-level=3  -Clto=fat
 //@ no-prefer-dynamic
 //@ needs-enzyme
 

From ec893d1a646bc0a1e09511ca80d71141da3b6997 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Wed, 1 Oct 2025 13:31:42 +0800
Subject: [PATCH 1615/1889] tests: remove `no-remap-src-base`

Previously in the `//`-compiletest-directive times, this was implemented
as a special `no-*` directive parsing. In the migration from `//` ->
`//@`, the `// no-remap-src-base` directive was lost, most likely
because it had no effect -- the default is not remapping `src-base`.

So remove occurrences of `no-remap-src-base`, as these are not valid
directives.
---
 tests/ui-fulldeps/mod_dir_path_canonicalized.rs                | 1 -
 tests/ui/errors/auxiliary/remapped_dep.rs                      | 2 +-
 tests/ui/errors/remap-path-prefix-reverse.local-self.stderr    | 2 +-
 tests/ui/errors/remap-path-prefix-reverse.remapped-self.stderr | 2 +-
 tests/ui/errors/remap-path-prefix-reverse.rs                   | 1 -
 tests/ui/errors/remap-path-prefix.rs                           | 2 +-
 tests/ui/proc-macro/expand-expr.rs                             | 2 +-
 tests/ui/proc-macro/pretty-print-hack-show.rs                  | 1 -
 8 files changed, 5 insertions(+), 8 deletions(-)

diff --git a/tests/ui-fulldeps/mod_dir_path_canonicalized.rs b/tests/ui-fulldeps/mod_dir_path_canonicalized.rs
index df5f29e35fe69..86f2d5f5954a4 100644
--- a/tests/ui-fulldeps/mod_dir_path_canonicalized.rs
+++ b/tests/ui-fulldeps/mod_dir_path_canonicalized.rs
@@ -2,7 +2,6 @@
 // Testing that a librustc_ast can parse modules with canonicalized base path
 //@ ignore-cross-compile
 //@ ignore-remote
-// no-remap-src-base: Reading `file!()` (expectedly) fails when enabled.
 
 #![feature(rustc_private)]
 
diff --git a/tests/ui/errors/auxiliary/remapped_dep.rs b/tests/ui/errors/auxiliary/remapped_dep.rs
index 36d4699a30600..997118f822c33 100644
--- a/tests/ui/errors/auxiliary/remapped_dep.rs
+++ b/tests/ui/errors/auxiliary/remapped_dep.rs
@@ -1,4 +1,4 @@
 //@ compile-flags: --remap-path-prefix={{src-base}}/errors/auxiliary=remapped-aux
-// no-remap-src-base: Manually remap, so the remapped path remains in .stderr file.
+// Manually remap, so the remapped path remains in .stderr file.
 
 pub struct SomeStruct {} // This line should be show as part of the error.
diff --git a/tests/ui/errors/remap-path-prefix-reverse.local-self.stderr b/tests/ui/errors/remap-path-prefix-reverse.local-self.stderr
index b4f83f6bfc0a6..b2651f3e03a6d 100644
--- a/tests/ui/errors/remap-path-prefix-reverse.local-self.stderr
+++ b/tests/ui/errors/remap-path-prefix-reverse.local-self.stderr
@@ -1,5 +1,5 @@
 error[E0423]: expected value, found struct `remapped_dep::SomeStruct`
-  --> $DIR/remap-path-prefix-reverse.rs:16:13
+  --> $DIR/remap-path-prefix-reverse.rs:15:13
    |
 LL |     let _ = remapped_dep::SomeStruct;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: use struct literal syntax instead: `remapped_dep::SomeStruct {}`
diff --git a/tests/ui/errors/remap-path-prefix-reverse.remapped-self.stderr b/tests/ui/errors/remap-path-prefix-reverse.remapped-self.stderr
index b4f83f6bfc0a6..b2651f3e03a6d 100644
--- a/tests/ui/errors/remap-path-prefix-reverse.remapped-self.stderr
+++ b/tests/ui/errors/remap-path-prefix-reverse.remapped-self.stderr
@@ -1,5 +1,5 @@
 error[E0423]: expected value, found struct `remapped_dep::SomeStruct`
-  --> $DIR/remap-path-prefix-reverse.rs:16:13
+  --> $DIR/remap-path-prefix-reverse.rs:15:13
    |
 LL |     let _ = remapped_dep::SomeStruct;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: use struct literal syntax instead: `remapped_dep::SomeStruct {}`
diff --git a/tests/ui/errors/remap-path-prefix-reverse.rs b/tests/ui/errors/remap-path-prefix-reverse.rs
index 28fdabb8f4df1..562e44690f768 100644
--- a/tests/ui/errors/remap-path-prefix-reverse.rs
+++ b/tests/ui/errors/remap-path-prefix-reverse.rs
@@ -2,7 +2,6 @@
 //@ compile-flags: --remap-path-prefix={{src-base}}/errors/auxiliary=remapped-aux
 
 //@ revisions: local-self remapped-self
-// [local-self] no-remap-src-base: The hack should work regardless of remapping.
 //@ [remapped-self] remap-src-base
 
 // Verify that the expected source code is shown.
diff --git a/tests/ui/errors/remap-path-prefix.rs b/tests/ui/errors/remap-path-prefix.rs
index 7e38e16280f51..de18aa8cc204b 100644
--- a/tests/ui/errors/remap-path-prefix.rs
+++ b/tests/ui/errors/remap-path-prefix.rs
@@ -2,7 +2,7 @@
 //@ compile-flags: --remap-path-prefix={{src-base}}=remapped
 //@ [with-diagnostic-scope]compile-flags: -Zremap-path-scope=diagnostics
 //@ [without-diagnostic-scope]compile-flags: -Zremap-path-scope=object
-// no-remap-src-base: Manually remap, so the remapped path remains in .stderr file.
+// Manually remap, so the remapped path remains in .stderr file.
 
 // The remapped paths are not normalized by compiletest.
 //@ normalize-stderr: "\\(errors)" -> "/$1"
diff --git a/tests/ui/proc-macro/expand-expr.rs b/tests/ui/proc-macro/expand-expr.rs
index 1e058abe3bc1b..c3dddd8e45940 100644
--- a/tests/ui/proc-macro/expand-expr.rs
+++ b/tests/ui/proc-macro/expand-expr.rs
@@ -1,6 +1,6 @@
 //@ proc-macro: expand-expr.rs
 //@ ignore-backends: gcc
-// no-remap-src-base: check_expand_expr_file!() fails when enabled.
+// No `remap-src-base`, since `check_expand_expr_file!()` fails when enabled.
 
 #![feature(concat_bytes)]
 extern crate expand_expr;
diff --git a/tests/ui/proc-macro/pretty-print-hack-show.rs b/tests/ui/proc-macro/pretty-print-hack-show.rs
index 70f0d5f6ea975..08e26c8114276 100644
--- a/tests/ui/proc-macro/pretty-print-hack-show.rs
+++ b/tests/ui/proc-macro/pretty-print-hack-show.rs
@@ -1,7 +1,6 @@
 //@ proc-macro: test-macros.rs
 //@ compile-flags: -Z span-debug
 //@ revisions: local remapped
-// [local] no-remap-src-base: The hack should work regardless of remapping.
 //@ [remapped] remap-src-base
 
 #![no_std] // Don't load unnecessary hygiene information from std

From f1079915b46f159e822a3f943ecafed8b7db8c6f Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Tue, 23 Sep 2025 18:22:08 +0200
Subject: [PATCH 1616/1889] Do not suggest using a `if let` chain if it is not
 supported

This might be due to a low edition (< 2024) or too low a MSRV.
---
 book/src/lint_configuration.md               |  1 +
 clippy_config/src/conf.rs                    |  1 +
 clippy_lints/src/collapsible_if.rs           |  7 ++-
 clippy_lints/src/lib.rs                      |  2 +-
 clippy_lints/src/unwrap.rs                   | 50 +++++++++++++-------
 clippy_utils/src/lib.rs                      |  6 +++
 tests/ui/checked_unwrap/if_let_chains.rs     | 24 ++++++++++
 tests/ui/checked_unwrap/if_let_chains.stderr | 29 ++++++++++++
 8 files changed, 97 insertions(+), 23 deletions(-)
 create mode 100644 tests/ui/checked_unwrap/if_let_chains.rs
 create mode 100644 tests/ui/checked_unwrap/if_let_chains.stderr

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index f8263bb8852ab..e7e0670357b3c 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -898,6 +898,7 @@ The minimum rust version that the project supports. Defaults to the `rust-versio
 * [`unchecked_duration_subtraction`](https://rust-lang.github.io/rust-clippy/master/index.html#unchecked_duration_subtraction)
 * [`uninlined_format_args`](https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args)
 * [`unnecessary_lazy_evaluations`](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_lazy_evaluations)
+* [`unnecessary_unwrap`](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_unwrap)
 * [`unnested_or_patterns`](https://rust-lang.github.io/rust-clippy/master/index.html#unnested_or_patterns)
 * [`unused_trait_names`](https://rust-lang.github.io/rust-clippy/master/index.html#unused_trait_names)
 * [`use_self`](https://rust-lang.github.io/rust-clippy/master/index.html#use_self)
diff --git a/clippy_config/src/conf.rs b/clippy_config/src/conf.rs
index e14e15a022f71..df8495dfe0ecf 100644
--- a/clippy_config/src/conf.rs
+++ b/clippy_config/src/conf.rs
@@ -794,6 +794,7 @@ define_Conf! {
         unchecked_duration_subtraction,
         uninlined_format_args,
         unnecessary_lazy_evaluations,
+        unnecessary_unwrap,
         unnested_or_patterns,
         unused_trait_names,
         use_self,
diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index b239c20ab4d89..b13e307a3f9c8 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -1,8 +1,8 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_hir_and_then;
-use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::msrvs::Msrv;
 use clippy_utils::source::{IntoSpan as _, SpanRangeExt, snippet, snippet_block_with_applicability};
-use clippy_utils::{span_contains_non_whitespace, sym, tokenize_with_text};
+use clippy_utils::{can_use_if_let_chains, span_contains_non_whitespace, sym, tokenize_with_text};
 use rustc_ast::{BinOpKind, MetaItemInner};
 use rustc_errors::Applicability;
 use rustc_hir::{Block, Expr, ExprKind, StmtKind};
@@ -216,8 +216,7 @@ impl CollapsibleIf {
     }
 
     fn eligible_condition(&self, cx: &LateContext<'_>, cond: &Expr<'_>) -> bool {
-        !matches!(cond.kind, ExprKind::Let(..))
-            || (cx.tcx.sess.edition().at_least_rust_2024() && self.msrv.meets(cx, msrvs::LET_CHAINS))
+        !matches!(cond.kind, ExprKind::Let(..)) || can_use_if_let_chains(cx, self.msrv)
     }
 
     // Check that nothing significant can be found between the initial `{` of `inner_if` and
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c56fa257b0689..1a706df567e55 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -589,7 +589,7 @@ pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Co
     store.register_late_pass(|_| Box::new(map_unit_fn::MapUnit));
     store.register_late_pass(|_| Box::new(inherent_impl::MultipleInherentImpl));
     store.register_late_pass(|_| Box::new(neg_cmp_op_on_partial_ord::NoNegCompOpForPartialOrd));
-    store.register_late_pass(|_| Box::new(unwrap::Unwrap));
+    store.register_late_pass(move |_| Box::new(unwrap::Unwrap::new(conf)));
     store.register_late_pass(move |_| Box::new(indexing_slicing::IndexingSlicing::new(conf)));
     store.register_late_pass(move |tcx| Box::new(non_copy_const::NonCopyConst::new(tcx, conf)));
     store.register_late_pass(|_| Box::new(redundant_clone::RedundantClone));
diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index 34dfe5b6546fa..aee8028a75de7 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -1,7 +1,9 @@
+use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_hir_and_then;
-use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::msrvs::Msrv;
+use clippy_utils::ty::get_type_diagnostic_name;
 use clippy_utils::usage::is_potentially_local_place;
-use clippy_utils::{higher, path_to_local, sym};
+use clippy_utils::{can_use_if_let_chains, higher, path_to_local, sym};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{FnKind, Visitor, walk_expr, walk_fn};
 use rustc_hir::{BinOpKind, Body, Expr, ExprKind, FnDecl, HirId, Node, UnOp};
@@ -10,7 +12,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::mir::FakeReadCause;
 use rustc_middle::ty::{self, Ty, TyCtxt};
-use rustc_session::declare_lint_pass;
+use rustc_session::impl_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{Span, Symbol};
 
@@ -72,10 +74,21 @@ declare_clippy_lint! {
     "checks for calls of `unwrap[_err]()` that will always fail"
 }
 
+pub(crate) struct Unwrap {
+    msrv: Msrv,
+}
+
+impl Unwrap {
+    pub fn new(conf: &'static Conf) -> Self {
+        Self { msrv: conf.msrv }
+    }
+}
+
 /// Visitor that keeps track of which variables are unwrappable.
 struct UnwrappableVariablesVisitor<'a, 'tcx> {
     unwrappables: Vec<UnwrapInfo<'tcx>>,
     cx: &'a LateContext<'tcx>,
+    msrv: Msrv,
 }
 
 /// What kind of unwrappable this is.
@@ -133,12 +146,14 @@ fn collect_unwrap_info<'tcx>(
     invert: bool,
     is_entire_condition: bool,
 ) -> Vec<UnwrapInfo<'tcx>> {
-    fn is_relevant_option_call(cx: &LateContext<'_>, ty: Ty<'_>, method_name: Symbol) -> bool {
-        is_type_diagnostic_item(cx, ty, sym::Option) && matches!(method_name, sym::is_none | sym::is_some)
-    }
-
-    fn is_relevant_result_call(cx: &LateContext<'_>, ty: Ty<'_>, method_name: Symbol) -> bool {
-        is_type_diagnostic_item(cx, ty, sym::Result) && matches!(method_name, sym::is_err | sym::is_ok)
+    fn option_or_result_call(cx: &LateContext<'_>, ty: Ty<'_>, method_name: Symbol) -> Option<(UnwrappableKind, bool)> {
+        match (get_type_diagnostic_name(cx, ty)?, method_name) {
+            (sym::Option, sym::is_some) => Some((UnwrappableKind::Option, true)),
+            (sym::Option, sym::is_none) => Some((UnwrappableKind::Option, false)),
+            (sym::Result, sym::is_ok) => Some((UnwrappableKind::Result, true)),
+            (sym::Result, sym::is_err) => Some((UnwrappableKind::Result, false)),
+            _ => None,
+        }
     }
 
     match expr.kind {
@@ -157,15 +172,9 @@ fn collect_unwrap_info<'tcx>(
             if let Some(local_id) = path_to_local(receiver)
                 && let ty = cx.typeck_results().expr_ty(receiver)
                 && let name = method_name.ident.name
-                && (is_relevant_option_call(cx, ty, name) || is_relevant_result_call(cx, ty, name)) =>
+                && let Some((kind, unwrappable)) = option_or_result_call(cx, ty, name) =>
         {
-            let unwrappable = matches!(name, sym::is_some | sym::is_ok);
             let safe_to_unwrap = unwrappable != invert;
-            let kind = if is_type_diagnostic_item(cx, ty, sym::Option) {
-                UnwrappableKind::Option
-            } else {
-                UnwrappableKind::Result
-            };
 
             vec![UnwrapInfo {
                 local_id,
@@ -357,7 +366,11 @@ impl<'tcx> Visitor<'tcx> for UnwrappableVariablesVisitor<'_, 'tcx> {
                                 );
                             } else {
                                 diag.span_label(unwrappable.check.span, "the check is happening here");
-                                diag.help("try using `if let` or `match`");
+                                if can_use_if_let_chains(self.cx, self.msrv) {
+                                    diag.help("try using `if let` or `match`");
+                                } else {
+                                    diag.help("try using `match`");
+                                }
                             }
                         },
                     );
@@ -383,7 +396,7 @@ impl<'tcx> Visitor<'tcx> for UnwrappableVariablesVisitor<'_, 'tcx> {
     }
 }
 
-declare_lint_pass!(Unwrap => [PANICKING_UNWRAP, UNNECESSARY_UNWRAP]);
+impl_lint_pass!(Unwrap => [PANICKING_UNWRAP, UNNECESSARY_UNWRAP]);
 
 impl<'tcx> LateLintPass<'tcx> for Unwrap {
     fn check_fn(
@@ -402,6 +415,7 @@ impl<'tcx> LateLintPass<'tcx> for Unwrap {
         let mut v = UnwrappableVariablesVisitor {
             unwrappables: Vec::new(),
             cx,
+            msrv: self.msrv,
         };
 
         walk_fn(&mut v, kind, decl, body.id(), fn_id);
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index feadc0ecf659a..1e0bd3a2c4dc8 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -129,6 +129,7 @@ use visitors::{Visitable, for_each_unconsumed_temporary};
 use crate::ast_utils::unordered_over;
 use crate::consts::{ConstEvalCtxt, Constant, mir_to_const};
 use crate::higher::Range;
+use crate::msrvs::Msrv;
 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;
 
@@ -3659,3 +3660,8 @@ pub fn is_expr_async_block(expr: &Expr<'_>) -> bool {
         })
     )
 }
+
+/// Checks if the chosen edition and `msrv` allows using `if let` chains.
+pub fn can_use_if_let_chains(cx: &LateContext<'_>, msrv: Msrv) -> bool {
+    cx.tcx.sess.edition().at_least_rust_2024() && msrv.meets(cx, msrvs::LET_CHAINS)
+}
diff --git a/tests/ui/checked_unwrap/if_let_chains.rs b/tests/ui/checked_unwrap/if_let_chains.rs
new file mode 100644
index 0000000000000..cfa7715965cdb
--- /dev/null
+++ b/tests/ui/checked_unwrap/if_let_chains.rs
@@ -0,0 +1,24 @@
+//@require-annotations-for-level: ERROR
+#![deny(clippy::unnecessary_unwrap)]
+
+#[clippy::msrv = "1.85"]
+fn if_let_chains_unsupported(a: Option<u32>, b: Option<u32>) {
+    if a.is_none() || b.is_none() {
+        println!("a or b is not set");
+    } else {
+        println!("the value of a is {}", a.unwrap());
+        //~^ unnecessary_unwrap
+        //~| HELP: try using `match`
+    }
+}
+
+#[clippy::msrv = "1.88"]
+fn if_let_chains_supported(a: Option<u32>, b: Option<u32>) {
+    if a.is_none() || b.is_none() {
+        println!("a or b is not set");
+    } else {
+        println!("the value of a is {}", a.unwrap());
+        //~^ unnecessary_unwrap
+        //~| HELP: try using `if let` or `match`
+    }
+}
diff --git a/tests/ui/checked_unwrap/if_let_chains.stderr b/tests/ui/checked_unwrap/if_let_chains.stderr
new file mode 100644
index 0000000000000..8a4137de37a3c
--- /dev/null
+++ b/tests/ui/checked_unwrap/if_let_chains.stderr
@@ -0,0 +1,29 @@
+error: called `unwrap` on `a` after checking its variant with `is_none`
+  --> tests/ui/checked_unwrap/if_let_chains.rs:9:42
+   |
+LL |     if a.is_none() || b.is_none() {
+   |        ----------- the check is happening here
+...
+LL |         println!("the value of a is {}", a.unwrap());
+   |                                          ^^^^^^^^^^
+   |
+   = help: try using `match`
+note: the lint level is defined here
+  --> tests/ui/checked_unwrap/if_let_chains.rs:2:9
+   |
+LL | #![deny(clippy::unnecessary_unwrap)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: called `unwrap` on `a` after checking its variant with `is_none`
+  --> tests/ui/checked_unwrap/if_let_chains.rs:20:42
+   |
+LL |     if a.is_none() || b.is_none() {
+   |        ----------- the check is happening here
+...
+LL |         println!("the value of a is {}", a.unwrap());
+   |                                          ^^^^^^^^^^
+   |
+   = help: try using `if let` or `match`
+
+error: aborting due to 2 previous errors
+

From 3186902bfca12d492ebbac70e2a41b15f0fb2b7f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Wed, 1 Oct 2025 09:05:30 +0200
Subject: [PATCH 1617/1889] Remove mention of `compiletest-use-stage0-libtest`
 from the bootstrap example config

---
 bootstrap.example.toml | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/bootstrap.example.toml b/bootstrap.example.toml
index 0a39c6d8f247d..f623a3db0029d 100644
--- a/bootstrap.example.toml
+++ b/bootstrap.example.toml
@@ -476,9 +476,6 @@
 # when the stage 0 compiler is actually built from in-tree sources.
 #build.compiletest-allow-stage0 = false
 
-# Whether to use the precompiled stage0 libtest with compiletest.
-#build.compiletest-use-stage0-libtest = true
-
 # Default value for the `--extra-checks` flag of tidy.
 #
 # See `./x test tidy --help` for details.

From 86f2d424c8cda473aa1bf91365f499cfe520c54a Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Mon, 15 Sep 2025 11:35:08 +0000
Subject: [PATCH 1618/1889] indexing: reword help

Co-authored-by: beef <ent3rm4n@gmail.com>
---
 .../src/error_codes/E0608.md                  | 15 ++++++++---
 compiler/rustc_hir_typeck/src/expr.rs         | 27 +++++--------------
 tests/ui/indexing/index_message.stderr        |  4 ++-
 tests/ui/issues/issue-27842.stderr            | 12 ++++-----
 tests/ui/span/suggestion-non-ascii.stderr     |  4 ++-
 ...for-indexing-expression-issue-40861.stderr |  2 +-
 6 files changed, 30 insertions(+), 34 deletions(-)

diff --git a/compiler/rustc_error_codes/src/error_codes/E0608.md b/compiler/rustc_error_codes/src/error_codes/E0608.md
index d0ebc3a26f082..3c29484f575ce 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0608.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0608.md
@@ -1,5 +1,5 @@
-An attempt to use index on a type which doesn't implement the `std::ops::Index`
-trait was performed.
+Attempted to index a value whose type doesn't implement the
+`std::ops::Index` trait.
 
 Erroneous code example:
 
@@ -7,8 +7,8 @@ Erroneous code example:
 0u8[2]; // error: cannot index into a value of type `u8`
 ```
 
-To be able to index into a type it needs to implement the `std::ops::Index`
-trait. Example:
+Only values with types that implement the `std::ops::Index` trait
+can be indexed with square brackets. Example:
 
 ```
 let v: Vec<u8> = vec![0, 1, 2, 3];
@@ -16,3 +16,10 @@ let v: Vec<u8> = vec![0, 1, 2, 3];
 // The `Vec` type implements the `Index` trait so you can do:
 println!("{}", v[2]);
 ```
+
+Tuples and structs are indexed with dot (`.`), not with brackets (`[]`),
+and tuple element names are their positions:
+```ignore(pseudo code)
+// this (pseudo code) expression is true for any tuple:
+tuple == (tuple.0, tuple.1, ...)
+```
diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index d1ce0afddf91c..f9cdc923670f0 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -3551,35 +3551,20 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     );
                     // Try to give some advice about indexing tuples.
                     if let ty::Tuple(types) = base_t.kind() {
-                        let mut needs_note = true;
-                        // If the index is an integer, we can show the actual
-                        // fixed expression:
+                        err.help(
+                            "tuples are indexed with a dot and a literal index: `tuple.0`, `tuple.1`, etc.",
+                        );
+                        // If index is an unsuffixed integer, show the fixed expression:
                         if let ExprKind::Lit(lit) = idx.kind
                             && let ast::LitKind::Int(i, ast::LitIntType::Unsuffixed) = lit.node
-                            && i.get()
-                                < types
-                                    .len()
-                                    .try_into()
-                                    .expect("expected tuple index to be < usize length")
+                            && i.get() < types.len().try_into().expect("tuple length fits in u128")
                         {
                             err.span_suggestion(
                                 brackets_span,
-                                "to access tuple elements, use",
+                                format!("to access tuple element `{i}`, use"),
                                 format!(".{i}"),
                                 Applicability::MachineApplicable,
                             );
-                            needs_note = false;
-                        } else if let ExprKind::Path(..) = idx.peel_borrows().kind {
-                            err.span_label(
-                                idx.span,
-                                "cannot access tuple elements at a variable index",
-                            );
-                        }
-                        if needs_note {
-                            err.help(
-                                "to access tuple elements, use tuple indexing \
-                                        syntax (e.g., `tuple.0`)",
-                            );
                         }
                     }
 
diff --git a/tests/ui/indexing/index_message.stderr b/tests/ui/indexing/index_message.stderr
index 6affb1ed96252..b6f61379f2af5 100644
--- a/tests/ui/indexing/index_message.stderr
+++ b/tests/ui/indexing/index_message.stderr
@@ -2,7 +2,9 @@ error[E0608]: cannot index into a value of type `({integer},)`
   --> $DIR/index_message.rs:3:14
    |
 LL |     let _ = z[0];
-   |              ^^^ help: to access tuple elements, use: `.0`
+   |              ^^^ help: to access tuple element `0`, use: `.0`
+   |
+   = help: tuples are indexed with a dot and a literal index: `tuple.0`, `tuple.1`, etc.
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-27842.stderr b/tests/ui/issues/issue-27842.stderr
index b18fe1512b50b..f388fdf85cde5 100644
--- a/tests/ui/issues/issue-27842.stderr
+++ b/tests/ui/issues/issue-27842.stderr
@@ -2,17 +2,17 @@ error[E0608]: cannot index into a value of type `({integer}, {integer}, {integer
   --> $DIR/issue-27842.rs:4:16
    |
 LL |     let _ = tup[0];
-   |                ^^^ help: to access tuple elements, use: `.0`
+   |                ^^^ help: to access tuple element `0`, use: `.0`
+   |
+   = help: tuples are indexed with a dot and a literal index: `tuple.0`, `tuple.1`, etc.
 
 error[E0608]: cannot index into a value of type `({integer}, {integer}, {integer})`
   --> $DIR/issue-27842.rs:9:16
    |
 LL |     let _ = tup[i];
-   |                ^-^
-   |                 |
-   |                 cannot access tuple elements at a variable index
+   |                ^^^
    |
-   = help: to access tuple elements, use tuple indexing syntax (e.g., `tuple.0`)
+   = help: tuples are indexed with a dot and a literal index: `tuple.0`, `tuple.1`, etc.
 
 error[E0608]: cannot index into a value of type `({integer},)`
   --> $DIR/issue-27842.rs:14:16
@@ -20,7 +20,7 @@ error[E0608]: cannot index into a value of type `({integer},)`
 LL |     let _ = tup[3];
    |                ^^^
    |
-   = help: to access tuple elements, use tuple indexing syntax (e.g., `tuple.0`)
+   = help: tuples are indexed with a dot and a literal index: `tuple.0`, `tuple.1`, etc.
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/span/suggestion-non-ascii.stderr b/tests/ui/span/suggestion-non-ascii.stderr
index 6e6e31a5698b8..361f744ee8eb6 100644
--- a/tests/ui/span/suggestion-non-ascii.stderr
+++ b/tests/ui/span/suggestion-non-ascii.stderr
@@ -2,7 +2,9 @@ error[E0608]: cannot index into a value of type `({integer},)`
   --> $DIR/suggestion-non-ascii.rs:3:24
    |
 LL |     println!("☃{}", tup[0]);
-   |                        ^^^ help: to access tuple elements, use: `.0`
+   |                        ^^^ help: to access tuple element `0`, use: `.0`
+   |
+   = help: tuples are indexed with a dot and a literal index: `tuple.0`, `tuple.1`, etc.
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/typeck/coercion-check-for-indexing-expression-issue-40861.stderr b/tests/ui/typeck/coercion-check-for-indexing-expression-issue-40861.stderr
index 13bc0cd94f37c..ef5f1786801a1 100644
--- a/tests/ui/typeck/coercion-check-for-indexing-expression-issue-40861.stderr
+++ b/tests/ui/typeck/coercion-check-for-indexing-expression-issue-40861.stderr
@@ -4,7 +4,7 @@ error[E0608]: cannot index into a value of type `()`
 LL |     ()[f(&[1.0])];
    |       ^^^^^^^^^^^
    |
-   = help: to access tuple elements, use tuple indexing syntax (e.g., `tuple.0`)
+   = help: tuples are indexed with a dot and a literal index: `tuple.0`, `tuple.1`, etc.
 
 error: aborting due to 1 previous error
 

From b1c212f8502e8e7fcb66da0e8da98db770cb7c02 Mon Sep 17 00:00:00 2001
From: ivmarkov <ivan.markov@gmail.com>
Date: Wed, 1 Oct 2025 08:12:44 +0000
Subject: [PATCH 1619/1889] Fix broken STD build for ESP-IDF

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

diff --git a/library/std/src/sys/net/hostname/mod.rs b/library/std/src/sys/net/hostname/mod.rs
index a4b5b76059d30..8ffe4894d7181 100644
--- a/library/std/src/sys/net/hostname/mod.rs
+++ b/library/std/src/sys/net/hostname/mod.rs
@@ -1,5 +1,5 @@
 cfg_select! {
-    target_family = "unix" => {
+    all(target_family = "unix", not(target_os = "espidf")) => {
         mod unix;
         pub use unix::hostname;
     }

From 3e24d50407e29f750ae8dc10e84bfef142b715e2 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 23 Aug 2025 04:33:46 -0400
Subject: [PATCH 1620/1889] Rename `eval_simple` to `eval_local` and take the
 `SyntaxContext` as an argument.

---
 clippy_lints/src/assertions_on_constants.rs   |  3 +-
 clippy_lints/src/floating_point_arithmetic.rs | 13 ++---
 clippy_lints/src/if_not_else.rs               | 12 +++--
 .../src/invalid_upcast_comparisons.rs         |  2 +-
 clippy_lints/src/manual_rem_euclid.rs         | 20 +++++---
 clippy_lints/src/matches/manual_unwrap_or.rs  |  2 +-
 .../src/methods/is_digit_ascii_radix.rs       |  2 +-
 .../src/methods/unnecessary_min_or_max.rs     |  5 +-
 clippy_lints/src/minmax.rs                    | 12 +++--
 .../src/operators/arithmetic_side_effects.rs  |  4 +-
 clippy_lints/src/operators/erasing_op.rs      |  4 +-
 clippy_lints/src/operators/float_cmp.rs       |  5 +-
 clippy_lints/src/operators/identity_op.rs     | 32 ++++++------
 .../src/operators/manual_is_multiple_of.rs    |  9 ++--
 .../src/operators/numeric_arithmetic.rs       |  2 +-
 clippy_lints/src/zero_div_zero.rs             |  5 +-
 clippy_utils/src/consts.rs                    | 49 +++++++++++++------
 clippy_utils/src/higher.rs                    |  2 +-
 clippy_utils/src/hir_utils.rs                 |  8 +--
 tests/ui/assertions_on_constants.rs           |  1 +
 tests/ui/assertions_on_constants.stderr       | 24 ++++++---
 21 files changed, 134 insertions(+), 82 deletions(-)

diff --git a/clippy_lints/src/assertions_on_constants.rs b/clippy_lints/src/assertions_on_constants.rs
index a6518216aa820..2586c89bc8680 100644
--- a/clippy_lints/src/assertions_on_constants.rs
+++ b/clippy_lints/src/assertions_on_constants.rs
@@ -50,7 +50,8 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnConstants {
                 _ => return,
             }
             && let Some((condition, _)) = find_assert_args(cx, e, macro_call.expn)
-            && let Some((Constant::Bool(assert_val), const_src)) = ConstEvalCtxt::new(cx).eval_with_source(condition)
+            && let Some((Constant::Bool(assert_val), const_src)) =
+                ConstEvalCtxt::new(cx).eval_with_source(condition, macro_call.span.ctxt())
             && let in_const_context = is_inside_always_const_context(cx.tcx, e.hir_id)
             && (const_src.is_local() || !in_const_context)
             && !(is_debug && as_bool_lit(condition) == Some(false))
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 84d39dd81c919..5052bbb3ca033 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -11,6 +11,7 @@ use rustc_hir::{BinOpKind, Expr, ExprKind, PathSegment, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::declare_lint_pass;
+use rustc_span::SyntaxContext;
 use rustc_span::source_map::Spanned;
 use std::f32::consts as f32_consts;
 use std::f64::consts as f64_consts;
@@ -517,8 +518,8 @@ fn check_mul_add(cx: &LateContext<'_>, expr: &Expr<'_>) {
 fn is_testing_positive(cx: &LateContext<'_>, expr: &Expr<'_>, test: &Expr<'_>) -> bool {
     if let ExprKind::Binary(Spanned { node: op, .. }, left, right) = expr.kind {
         match op {
-            BinOpKind::Gt | BinOpKind::Ge => is_zero(cx, right) && eq_expr_value(cx, left, test),
-            BinOpKind::Lt | BinOpKind::Le => is_zero(cx, left) && eq_expr_value(cx, right, test),
+            BinOpKind::Gt | BinOpKind::Ge => is_zero(cx, right, expr.span.ctxt()) && eq_expr_value(cx, left, test),
+            BinOpKind::Lt | BinOpKind::Le => is_zero(cx, left, expr.span.ctxt()) && eq_expr_value(cx, right, test),
             _ => false,
         }
     } else {
@@ -530,8 +531,8 @@ fn is_testing_positive(cx: &LateContext<'_>, expr: &Expr<'_>, test: &Expr<'_>) -
 fn is_testing_negative(cx: &LateContext<'_>, expr: &Expr<'_>, test: &Expr<'_>) -> bool {
     if let ExprKind::Binary(Spanned { node: op, .. }, left, right) = expr.kind {
         match op {
-            BinOpKind::Gt | BinOpKind::Ge => is_zero(cx, left) && eq_expr_value(cx, right, test),
-            BinOpKind::Lt | BinOpKind::Le => is_zero(cx, right) && eq_expr_value(cx, left, test),
+            BinOpKind::Gt | BinOpKind::Ge => is_zero(cx, left, expr.span.ctxt()) && eq_expr_value(cx, right, test),
+            BinOpKind::Lt | BinOpKind::Le => is_zero(cx, right, expr.span.ctxt()) && eq_expr_value(cx, left, test),
             _ => false,
         }
     } else {
@@ -540,8 +541,8 @@ 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 ConstEvalCtxt::new(cx).eval_simple(expr) {
+fn is_zero(cx: &LateContext<'_>, expr: &Expr<'_>, ctxt: SyntaxContext) -> bool {
+    match ConstEvalCtxt::new(cx).eval_local(expr, ctxt) {
         Some(Int(i)) => i == 0,
         Some(F32(f)) => f == 0.0,
         Some(F64(f)) => f == 0.0,
diff --git a/clippy_lints/src/if_not_else.rs b/clippy_lints/src/if_not_else.rs
index e8afa69b537ea..54e9538fcb993 100644
--- a/clippy_lints/src/if_not_else.rs
+++ b/clippy_lints/src/if_not_else.rs
@@ -60,10 +60,14 @@ impl LateLintPass<'_> for IfNotElse {
                 ),
                 // Don't lint on `… != 0`, as these are likely to be bit tests.
                 // For example, `if foo & 0x0F00 != 0 { … } else { … }` is already in the "proper" order.
-                ExprKind::Binary(op, _, rhs) if op.node == BinOpKind::Ne && !is_zero_integer_const(cx, rhs) => (
-                    "unnecessary `!=` operation",
-                    "change to `==` and swap the blocks of the `if`/`else`",
-                ),
+                ExprKind::Binary(op, _, rhs)
+                    if op.node == BinOpKind::Ne && !is_zero_integer_const(cx, rhs, e.span.ctxt()) =>
+                {
+                    (
+                        "unnecessary `!=` operation",
+                        "change to `==` and swap the blocks of the `if`/`else`",
+                    )
+                },
                 _ => return,
             };
 
diff --git a/clippy_lints/src/invalid_upcast_comparisons.rs b/clippy_lints/src/invalid_upcast_comparisons.rs
index 1666e8e5ae324..885649074ab63 100644
--- a/clippy_lints/src/invalid_upcast_comparisons.rs
+++ b/clippy_lints/src/invalid_upcast_comparisons.rs
@@ -101,7 +101,7 @@ fn upcast_comparison_bounds_err<'tcx>(
     invert: bool,
 ) {
     if let Some((lb, ub)) = lhs_bounds
-        && let Some(norm_rhs_val) = ConstEvalCtxt::new(cx).eval_full_int(rhs)
+        && let Some(norm_rhs_val) = ConstEvalCtxt::new(cx).eval_full_int(rhs, span.ctxt())
     {
         if rel == Rel::Eq || rel == Rel::Ne {
             if norm_rhs_val < lb || norm_rhs_val > ub {
diff --git a/clippy_lints/src/manual_rem_euclid.rs b/clippy_lints/src/manual_rem_euclid.rs
index 41e07e26bff0a..1e91a429fe45c 100644
--- a/clippy_lints/src/manual_rem_euclid.rs
+++ b/clippy_lints/src/manual_rem_euclid.rs
@@ -8,6 +8,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, Node, TyKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::impl_lint_pass;
+use rustc_span::SyntaxContext;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -58,13 +59,13 @@ impl<'tcx> LateLintPass<'tcx> for ManualRemEuclid {
             && add_lhs.span.ctxt() == ctxt
             && add_rhs.span.ctxt() == ctxt
             && !expr.span.in_external_macro(cx.sess().source_map())
-            && 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 Some(const1) = check_for_unsigned_int_constant(cx, ctxt, rem_rhs)
+            && let Some((const2, add_other)) = check_for_either_unsigned_int_constant(cx, ctxt, add_lhs, add_rhs)
             && let ExprKind::Binary(rem2_op, rem2_lhs, rem2_rhs) = add_other.kind
             && rem2_op.node == BinOpKind::Rem
             && const1 == const2
             && let Some(hir_id) = path_to_local(rem2_lhs)
-            && let Some(const3) = check_for_unsigned_int_constant(cx, rem2_rhs)
+            && let Some(const3) = check_for_unsigned_int_constant(cx, ctxt, rem2_rhs)
             // Also ensures the const is nonzero since zero can't be a divisor
             && const2 == const3
             && rem2_lhs.span.ctxt() == ctxt
@@ -103,16 +104,21 @@ impl<'tcx> LateLintPass<'tcx> for ManualRemEuclid {
 // constant along with the other expression unchanged if so
 fn check_for_either_unsigned_int_constant<'a>(
     cx: &'a LateContext<'_>,
+    ctxt: SyntaxContext,
     left: &'a Expr<'_>,
     right: &'a Expr<'_>,
 ) -> Option<(u128, &'a Expr<'a>)> {
-    check_for_unsigned_int_constant(cx, left)
+    check_for_unsigned_int_constant(cx, ctxt, left)
         .map(|int_const| (int_const, right))
-        .or_else(|| check_for_unsigned_int_constant(cx, right).map(|int_const| (int_const, left)))
+        .or_else(|| check_for_unsigned_int_constant(cx, ctxt, right).map(|int_const| (int_const, left)))
 }
 
-fn check_for_unsigned_int_constant<'a>(cx: &'a LateContext<'_>, expr: &'a Expr<'_>) -> Option<u128> {
-    let int_const = ConstEvalCtxt::new(cx).eval_full_int(expr)?;
+fn check_for_unsigned_int_constant<'a>(
+    cx: &'a LateContext<'_>,
+    ctxt: SyntaxContext,
+    expr: &'a Expr<'_>,
+) -> Option<u128> {
+    let int_const = ConstEvalCtxt::new(cx).eval_full_int(expr, ctxt)?;
     match int_const {
         FullInt::S(s) => s.try_into().ok(),
         FullInt::U(u) => Some(u),
diff --git a/clippy_lints/src/matches/manual_unwrap_or.rs b/clippy_lints/src/matches/manual_unwrap_or.rs
index 8c3f52542d917..ac9e51890362b 100644
--- a/clippy_lints/src/matches/manual_unwrap_or.rs
+++ b/clippy_lints/src/matches/manual_unwrap_or.rs
@@ -155,7 +155,7 @@ fn handle(
             && cx.typeck_results().expr_adjustments(body_some).is_empty()
             && let Some(or_body_snippet) = peel_blocks(body_none).span.get_source_text(cx)
             && let Some(indent) = indent_of(cx, expr.span)
-            && ConstEvalCtxt::new(cx).eval_simple(body_none).is_some()
+            && ConstEvalCtxt::new(cx).eval_local(body_none, expr.span.ctxt()).is_some()
         {
             let reindented_or_body = reindent_multiline(&or_body_snippet, true, Some(indent));
             let mut app = Applicability::MachineApplicable;
diff --git a/clippy_lints/src/methods/is_digit_ascii_radix.rs b/clippy_lints/src/methods/is_digit_ascii_radix.rs
index 9c32e9ac539d9..2aeb6f42d05cd 100644
--- a/clippy_lints/src/methods/is_digit_ascii_radix.rs
+++ b/clippy_lints/src/methods/is_digit_ascii_radix.rs
@@ -18,7 +18,7 @@ pub(super) fn check<'tcx>(
         return;
     }
 
-    if let Some(radix_val) = ConstEvalCtxt::new(cx).eval_full_int(radix) {
+    if let Some(radix_val) = ConstEvalCtxt::new(cx).eval_full_int(radix, expr.span.ctxt()) {
         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/unnecessary_min_or_max.rs b/clippy_lints/src/methods/unnecessary_min_or_max.rs
index b87d81b710269..130e4970a7163 100644
--- a/clippy_lints/src/methods/unnecessary_min_or_max.rs
+++ b/clippy_lints/src/methods/unnecessary_min_or_max.rs
@@ -25,8 +25,9 @@ pub(super) fn check<'tcx>(
         && let Some(fn_name) = cx.tcx.get_diagnostic_name(id)
         && matches!(fn_name, sym::cmp_ord_min | sym::cmp_ord_max)
     {
-        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 ctxt = expr.span.ctxt();
+        if let Some((left, ConstantSource::Local | ConstantSource::CoreConstant)) = ecx.eval_with_source(recv, ctxt)
+            && let Some((right, ConstantSource::Local | ConstantSource::CoreConstant)) = ecx.eval_with_source(arg, ctxt)
         {
             let Some(ord) = Constant::partial_cmp(cx.tcx, typeck_results.expr_ty(recv), &left, &right) else {
                 return;
diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs
index 64eafc0ebccdc..8f76e6c9048e1 100644
--- a/clippy_lints/src/minmax.rs
+++ b/clippy_lints/src/minmax.rs
@@ -4,6 +4,7 @@ use clippy_utils::{is_trait_method, sym};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
+use rustc_span::SyntaxContext;
 use std::cmp::Ordering::{Equal, Greater, Less};
 
 declare_clippy_lint! {
@@ -68,8 +69,8 @@ fn min_max<'a, 'tcx>(cx: &LateContext<'tcx>, expr: &'a Expr<'a>) -> Option<(MinM
                     .qpath_res(qpath, path.hir_id)
                     .opt_def_id()
                     .and_then(|def_id| match cx.tcx.get_diagnostic_name(def_id) {
-                        Some(sym::cmp_min) => fetch_const(cx, None, args, MinMax::Min),
-                        Some(sym::cmp_max) => fetch_const(cx, None, args, MinMax::Max),
+                        Some(sym::cmp_min) => fetch_const(cx, expr.span.ctxt(), None, args, MinMax::Min),
+                        Some(sym::cmp_max) => fetch_const(cx, expr.span.ctxt(), None, args, MinMax::Max),
                         _ => None,
                     })
             } else {
@@ -79,8 +80,8 @@ fn min_max<'a, 'tcx>(cx: &LateContext<'tcx>, expr: &'a Expr<'a>) -> Option<(MinM
         ExprKind::MethodCall(path, receiver, args @ [_], _) => {
             if cx.typeck_results().expr_ty(receiver).is_floating_point() || is_trait_method(cx, expr, sym::Ord) {
                 match path.ident.name {
-                    sym::max => fetch_const(cx, Some(receiver), args, MinMax::Max),
-                    sym::min => fetch_const(cx, Some(receiver), args, MinMax::Min),
+                    sym::max => fetch_const(cx, expr.span.ctxt(), Some(receiver), args, MinMax::Max),
+                    sym::min => fetch_const(cx, expr.span.ctxt(), Some(receiver), args, MinMax::Min),
                     _ => None,
                 }
             } else {
@@ -93,6 +94,7 @@ fn min_max<'a, 'tcx>(cx: &LateContext<'tcx>, expr: &'a Expr<'a>) -> Option<(MinM
 
 fn fetch_const<'a, 'tcx>(
     cx: &LateContext<'tcx>,
+    ctxt: SyntaxContext,
     receiver: Option<&'a Expr<'a>>,
     args: &'a [Expr<'a>],
     m: MinMax,
@@ -104,7 +106,7 @@ fn fetch_const<'a, 'tcx>(
         return None;
     }
     let ecx = ConstEvalCtxt::new(cx);
-    match (ecx.eval_simple(first_arg), ecx.eval_simple(second_arg)) {
+    match (ecx.eval_local(first_arg, ctxt), ecx.eval_local(second_arg, ctxt)) {
         (Some(c), None) => Some((m, c, second_arg)),
         (None, Some(c)) => Some((m, c, first_arg)),
         // otherwise ignore
diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index ea5b81aec31ea..e062e55dad894 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -190,7 +190,7 @@ impl ArithmeticSideEffects {
         lhs: &'tcx hir::Expr<'_>,
         rhs: &'tcx hir::Expr<'_>,
     ) {
-        if ConstEvalCtxt::new(cx).eval_simple(expr).is_some() {
+        if ConstEvalCtxt::new(cx).eval_local(expr, expr.span.ctxt()).is_some() {
             return;
         }
         if !matches!(
@@ -283,7 +283,7 @@ impl ArithmeticSideEffects {
         let Some(arg) = args.first() else {
             return;
         };
-        if ConstEvalCtxt::new(cx).eval_simple(receiver).is_some() {
+        if ConstEvalCtxt::new(cx).eval_local(receiver, expr.span.ctxt()).is_some() {
             return;
         }
         let instance_ty = cx.typeck_results().expr_ty_adjusted(receiver);
diff --git a/clippy_lints/src/operators/erasing_op.rs b/clippy_lints/src/operators/erasing_op.rs
index 8f5ee390f7222..ae1a94a3e23f0 100644
--- a/clippy_lints/src/operators/erasing_op.rs
+++ b/clippy_lints/src/operators/erasing_op.rs
@@ -39,7 +39,9 @@ fn check_op<'tcx>(
     other: &Expr<'tcx>,
     parent: &Expr<'tcx>,
 ) {
-    if ConstEvalCtxt::with_env(cx.tcx, cx.typing_env(), tck).eval_simple(op) == Some(Constant::Int(0)) {
+    if ConstEvalCtxt::with_env(cx.tcx, cx.typing_env(), tck).eval_local(op, parent.span.ctxt())
+        == 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 ded161c8576a1..03b2cf055d919 100644
--- a/clippy_lints/src/operators/float_cmp.rs
+++ b/clippy_lints/src/operators/float_cmp.rs
@@ -18,12 +18,13 @@ pub(crate) fn check<'tcx>(
 ) {
     if (op == BinOpKind::Eq || op == BinOpKind::Ne) && is_float(cx, left) {
         let ecx = ConstEvalCtxt::new(cx);
-        let left_is_local = match ecx.eval_with_source(left) {
+        let ctxt = expr.span.ctxt();
+        let left_is_local = match ecx.eval_with_source(left, ctxt) {
             Some((c, s)) if !is_allowed(&c) => s.is_local(),
             Some(_) => return,
             None => true,
         };
-        let right_is_local = match ecx.eval_with_source(right) {
+        let right_is_local = match ecx.eval_with_source(right, ctxt) {
             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 3efbb8963587f..43c62e1e131a3 100644
--- a/clippy_lints/src/operators/identity_op.rs
+++ b/clippy_lints/src/operators/identity_op.rs
@@ -7,7 +7,7 @@ use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{BinOpKind, Expr, ExprKind, Node, Path, QPath};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
-use rustc_span::{Span, kw};
+use rustc_span::{Span, SyntaxContext, kw};
 
 use super::IDENTITY_OP;
 
@@ -41,42 +41,43 @@ pub(crate) fn check<'tcx>(
         (span, is_coerced)
     };
 
+    let ctxt = expr.span.ctxt();
     match op {
         BinOpKind::Add | BinOpKind::BitOr | BinOpKind::BitXor => {
-            if is_redundant_op(cx, left, 0) {
+            if is_redundant_op(cx, left, 0, ctxt) {
                 let paren = needs_parenthesis(cx, expr, right);
                 span_ineffective_operation(cx, expr.span, peeled_right_span, paren, right_is_coerced_to_value);
-            } else if is_redundant_op(cx, right, 0) {
+            } else if is_redundant_op(cx, right, 0, ctxt) {
                 let paren = needs_parenthesis(cx, expr, left);
                 span_ineffective_operation(cx, expr.span, peeled_left_span, paren, left_is_coerced_to_value);
             }
         },
         BinOpKind::Shl | BinOpKind::Shr | BinOpKind::Sub => {
-            if is_redundant_op(cx, right, 0) {
+            if is_redundant_op(cx, right, 0, ctxt) {
                 let paren = needs_parenthesis(cx, expr, left);
                 span_ineffective_operation(cx, expr.span, peeled_left_span, paren, left_is_coerced_to_value);
             }
         },
         BinOpKind::Mul => {
-            if is_redundant_op(cx, left, 1) {
+            if is_redundant_op(cx, left, 1, ctxt) {
                 let paren = needs_parenthesis(cx, expr, right);
                 span_ineffective_operation(cx, expr.span, peeled_right_span, paren, right_is_coerced_to_value);
-            } else if is_redundant_op(cx, right, 1) {
+            } else if is_redundant_op(cx, right, 1, ctxt) {
                 let paren = needs_parenthesis(cx, expr, left);
                 span_ineffective_operation(cx, expr.span, peeled_left_span, paren, left_is_coerced_to_value);
             }
         },
         BinOpKind::Div => {
-            if is_redundant_op(cx, right, 1) {
+            if is_redundant_op(cx, right, 1, ctxt) {
                 let paren = needs_parenthesis(cx, expr, left);
                 span_ineffective_operation(cx, expr.span, peeled_left_span, paren, left_is_coerced_to_value);
             }
         },
         BinOpKind::BitAnd => {
-            if is_redundant_op(cx, left, -1) {
+            if is_redundant_op(cx, left, -1, ctxt) {
                 let paren = needs_parenthesis(cx, expr, right);
                 span_ineffective_operation(cx, expr.span, peeled_right_span, paren, right_is_coerced_to_value);
-            } else if is_redundant_op(cx, right, -1) {
+            } else if is_redundant_op(cx, right, -1, ctxt) {
                 let paren = needs_parenthesis(cx, expr, left);
                 span_ineffective_operation(cx, expr.span, peeled_left_span, paren, left_is_coerced_to_value);
             }
@@ -184,14 +185,17 @@ fn is_allowed<'tcx>(
 
     // This lint applies to integers and their references
     cx.typeck_results().expr_ty(left).peel_refs().is_integral()
-        && cx.typeck_results().expr_ty(right).peel_refs().is_integral()
+    && cx.typeck_results().expr_ty(right).peel_refs().is_integral()
         // `1 << 0` is a common pattern in bit manipulation code
-        && !(cmp == BinOpKind::Shl && is_zero_integer_const(cx, right) && integer_const(cx, left) == Some(1))
+        && !(cmp == BinOpKind::Shl
+            && is_zero_integer_const(cx, right, expr.span.ctxt())
+            && integer_const(cx, left, expr.span.ctxt()) == Some(1))
 }
 
 fn check_remainder(cx: &LateContext<'_>, left: &Expr<'_>, right: &Expr<'_>, span: Span, arg: Span) {
     let ecx = ConstEvalCtxt::new(cx);
-    if match (ecx.eval_full_int(left), ecx.eval_full_int(right)) {
+    let ctxt = span.ctxt();
+    if match (ecx.eval_full_int(left, ctxt), ecx.eval_full_int(right, ctxt)) {
         (Some(FullInt::S(lv)), Some(FullInt::S(rv))) => lv.abs() < rv.abs(),
         (Some(FullInt::U(lv)), Some(FullInt::U(rv))) => lv < rv,
         _ => return,
@@ -200,8 +204,8 @@ fn check_remainder(cx: &LateContext<'_>, left: &Expr<'_>, right: &Expr<'_>, span
     }
 }
 
-fn is_redundant_op(cx: &LateContext<'_>, e: &Expr<'_>, m: i8) -> bool {
-    if let Some(Constant::Int(v)) = ConstEvalCtxt::new(cx).eval_simple(e).map(Constant::peel_refs) {
+fn is_redundant_op(cx: &LateContext<'_>, e: &Expr<'_>, m: i8, ctxt: SyntaxContext) -> bool {
+    if let Some(Constant::Int(v)) = ConstEvalCtxt::new(cx).eval_local(e, ctxt).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/manual_is_multiple_of.rs b/clippy_lints/src/operators/manual_is_multiple_of.rs
index 55bb78cfce5fc..0b9bd4fb6d320 100644
--- a/clippy_lints/src/operators/manual_is_multiple_of.rs
+++ b/clippy_lints/src/operators/manual_is_multiple_of.rs
@@ -13,14 +13,14 @@ use super::MANUAL_IS_MULTIPLE_OF;
 
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
-    expr: &Expr<'_>,
+    expr: &'tcx Expr<'tcx>,
     op: BinOpKind,
     lhs: &'tcx Expr<'tcx>,
     rhs: &'tcx Expr<'tcx>,
     msrv: Msrv,
 ) {
     if msrv.meets(cx, msrvs::UNSIGNED_IS_MULTIPLE_OF)
-        && let Some(operand) = uint_compare_to_zero(cx, op, lhs, rhs)
+        && let Some(operand) = uint_compare_to_zero(cx, expr, op, lhs, rhs)
         && let ExprKind::Binary(operand_op, operand_left, operand_right) = operand.kind
         && operand_op.node == BinOpKind::Rem
         && matches!(
@@ -57,18 +57,19 @@ pub(super) fn check<'tcx>(
 // If we have a `x == 0`, `x != 0` or `x > 0` (or the reverted ones), return the non-zero operand
 fn uint_compare_to_zero<'tcx>(
     cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'tcx>,
     op: BinOpKind,
     lhs: &'tcx Expr<'tcx>,
     rhs: &'tcx Expr<'tcx>,
 ) -> Option<&'tcx Expr<'tcx>> {
     let operand = if matches!(lhs.kind, ExprKind::Binary(..))
         && matches!(op, BinOpKind::Eq | BinOpKind::Ne | BinOpKind::Gt)
-        && is_zero_integer_const(cx, rhs)
+        && is_zero_integer_const(cx, rhs, e.span.ctxt())
     {
         lhs
     } else if matches!(rhs.kind, ExprKind::Binary(..))
         && matches!(op, BinOpKind::Eq | BinOpKind::Ne | BinOpKind::Lt)
-        && is_zero_integer_const(cx, lhs)
+        && is_zero_integer_const(cx, lhs, e.span.ctxt())
     {
         rhs
     } else {
diff --git a/clippy_lints/src/operators/numeric_arithmetic.rs b/clippy_lints/src/operators/numeric_arithmetic.rs
index 9b1b063c4737d..622f328f369a5 100644
--- a/clippy_lints/src/operators/numeric_arithmetic.rs
+++ b/clippy_lints/src/operators/numeric_arithmetic.rs
@@ -55,7 +55,7 @@ impl Context {
             return;
         }
         let ty = cx.typeck_results().expr_ty(arg);
-        if ConstEvalCtxt::new(cx).eval_simple(expr).is_none() && ty.is_floating_point() {
+        if ConstEvalCtxt::new(cx).eval_local(expr, expr.span.ctxt()).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/zero_div_zero.rs b/clippy_lints/src/zero_div_zero.rs
index 5eb207a0aedb0..bb0cab3a30757 100644
--- a/clippy_lints/src/zero_div_zero.rs
+++ b/clippy_lints/src/zero_div_zero.rs
@@ -37,8 +37,9 @@ impl<'tcx> LateLintPass<'tcx> for ZeroDiv {
             // 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 ecx = ConstEvalCtxt::new(cx)
-            && let Some(lhs_value) = ecx.eval_simple(left)
-            && let Some(rhs_value) = ecx.eval_simple(right)
+            && let ctxt = expr.span.ctxt()
+            && let Some(lhs_value) = ecx.eval_local(left, ctxt)
+            && let Some(rhs_value) = ecx.eval_local(right, ctxt)
             // 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/src/consts.rs b/clippy_utils/src/consts.rs
index ecd88daa6b39f..29f4988b4211b 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -387,6 +387,7 @@ pub struct ConstEvalCtxt<'tcx> {
     typing_env: ty::TypingEnv<'tcx>,
     typeck: &'tcx TypeckResults<'tcx>,
     source: Cell<ConstantSource>,
+    ctxt: Cell<SyntaxContext>,
 }
 
 impl<'tcx> ConstEvalCtxt<'tcx> {
@@ -398,6 +399,7 @@ impl<'tcx> ConstEvalCtxt<'tcx> {
             typing_env: cx.typing_env(),
             typeck: cx.typeck_results(),
             source: Cell::new(ConstantSource::Local),
+            ctxt: Cell::new(SyntaxContext::root()),
         }
     }
 
@@ -408,13 +410,15 @@ impl<'tcx> ConstEvalCtxt<'tcx> {
             typing_env,
             typeck,
             source: Cell::new(ConstantSource::Local),
+            ctxt: Cell::new(SyntaxContext::root()),
         }
     }
 
     /// 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)> {
+    pub fn eval_with_source(&self, e: &Expr<'_>, ctxt: SyntaxContext) -> Option<(Constant<'tcx>, ConstantSource)> {
         self.source.set(ConstantSource::Local);
+        self.ctxt.set(ctxt);
         self.expr(e).map(|c| (c, self.source.get()))
     }
 
@@ -424,16 +428,16 @@ impl<'tcx> ConstEvalCtxt<'tcx> {
     }
 
     /// 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) {
+    pub fn eval_local(&self, e: &Expr<'_>, ctxt: SyntaxContext) -> Option<Constant<'tcx>> {
+        match self.eval_with_source(e, ctxt) {
             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) {
+    pub fn eval_full_int(&self, e: &Expr<'_>, ctxt: SyntaxContext) -> Option<FullInt> {
+        match self.eval_with_source(e, ctxt) {
             Some((x, ConstantSource::Local)) => x.int_value(self.tcx, self.typeck.expr_ty(e)),
             _ => None,
         }
@@ -455,6 +459,14 @@ impl<'tcx> ConstEvalCtxt<'tcx> {
         }
     }
 
+    fn check_ctxt(&self, ctxt: SyntaxContext) {
+        self.source.set(if self.ctxt.get() != ctxt {
+            ConstantSource::Constant
+        } else {
+            self.source.get()
+        });
+    }
+
     fn qpath(&self, qpath: &QPath<'_>, hir_id: HirId) -> Option<Constant<'tcx>> {
         let is_core_crate = if let Some(def_id) = self.typeck.qpath_res(qpath, hir_id).opt_def_id() {
             self.tcx.crate_name(def_id.krate) == sym::core
@@ -477,17 +489,18 @@ impl<'tcx> ConstEvalCtxt<'tcx> {
 
     /// Simple constant folding: Insert an expression, get a constant or none.
     fn expr(&self, e: &Expr<'_>) -> Option<Constant<'tcx>> {
+        self.check_ctxt(e.span.ctxt());
         match e.kind {
             ExprKind::ConstBlock(ConstBlock { body, .. }) => self.expr(self.tcx.hir_body(body).value),
             ExprKind::DropTemps(e) => self.expr(e),
             ExprKind::Path(ref qpath) => self.qpath(qpath, e.hir_id),
-            ExprKind::Block(block, _) => self.block(block),
+            ExprKind::Block(block, _) => {
+                self.check_ctxt(block.span.ctxt());
+                self.block(block)
+            },
             ExprKind::Lit(lit) => {
-                if is_direct_expn_of(e.span, sym::cfg).is_some() {
-                    None
-                } else {
-                    Some(lit_to_mir_constant(&lit.node, self.typeck.expr_ty_opt(e)))
-                }
+                self.check_ctxt(lit.span.ctxt());
+                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),
@@ -504,7 +517,10 @@ impl<'tcx> ConstEvalCtxt<'tcx> {
                 UnOp::Deref => Some(if let Constant::Ref(r) = o { *r } else { o }),
             }),
             ExprKind::If(cond, then, ref otherwise) => self.ifthenelse(cond, then, *otherwise),
-            ExprKind::Binary(op, left, right) => self.binop(op.node, left, right),
+            ExprKind::Binary(op, left, right) => {
+                self.check_ctxt(e.span.ctxt());
+                self.binop(op.node, left, right)
+            },
             ExprKind::Call(callee, []) => {
                 // We only handle a few const functions for now.
                 if let ExprKind::Path(qpath) = &callee.kind
@@ -525,6 +541,7 @@ impl<'tcx> ConstEvalCtxt<'tcx> {
             ExprKind::Index(arr, index, _) => self.index(arr, index),
             ExprKind::AddrOf(_, _, inner) => self.expr(inner).map(|r| Constant::Ref(Box::new(r))),
             ExprKind::Field(local_expr, ref field) => {
+                self.check_ctxt(field.span.ctxt());
                 let result = self.expr(local_expr);
                 if let Some(Constant::Adt(constant)) = &self.expr(local_expr)
                     && let ty::Adt(adt_def, _) = constant.ty().kind()
@@ -958,8 +975,8 @@ fn field_of_struct<'tcx>(
 }
 
 /// If `expr` evaluates to an integer constant, return its value.
-pub fn integer_const(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<u128> {
-    if let Some(Constant::Int(value)) = ConstEvalCtxt::new(cx).eval_simple(expr) {
+pub fn integer_const(cx: &LateContext<'_>, expr: &Expr<'_>, ctxt: SyntaxContext) -> Option<u128> {
+    if let Some(Constant::Int(value)) = ConstEvalCtxt::new(cx).eval_local(expr, ctxt) {
         Some(value)
     } else {
         None
@@ -968,6 +985,6 @@ pub fn integer_const(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<u128> {
 
 /// Check if `expr` evaluates to an integer constant of 0.
 #[inline]
-pub fn is_zero_integer_const(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    integer_const(cx, expr) == Some(0)
+pub fn is_zero_integer_const(cx: &LateContext<'_>, expr: &Expr<'_>, ctxt: SyntaxContext) -> bool {
+    integer_const(cx, expr, ctxt) == Some(0)
 }
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index bda28a663fb07..6f1bc28fbab81 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -454,7 +454,7 @@ pub fn get_vec_init_kind<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -
                     return Some(VecInitKind::Default);
                 } else if name.ident.name == sym::with_capacity {
                     let arg = args.first()?;
-                    return match ConstEvalCtxt::new(cx).eval_simple(arg) {
+                    return match ConstEvalCtxt::new(cx).eval_local(arg, expr.span.ctxt()) {
                         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 b79e15cd7170b..a6d821c99c1b5 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -290,8 +290,10 @@ 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)) = (
-                ConstEvalCtxt::with_env(self.inner.cx.tcx, self.inner.cx.typing_env(), typeck_lhs).eval_simple(left),
-                ConstEvalCtxt::with_env(self.inner.cx.tcx, self.inner.cx.typing_env(), typeck_rhs).eval_simple(right),
+                ConstEvalCtxt::with_env(self.inner.cx.tcx, self.inner.cx.typing_env(), typeck_lhs)
+                    .eval_local(left, self.left_ctxt),
+                ConstEvalCtxt::with_env(self.inner.cx.tcx, self.inner.cx.typing_env(), typeck_rhs)
+                    .eval_local(right, self.right_ctxt),
             )
             && l == r
         {
@@ -842,7 +844,7 @@ 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| {
-            ConstEvalCtxt::with_env(self.cx.tcx, self.cx.typing_env(), typeck_results).eval_simple(e)
+            ConstEvalCtxt::with_env(self.cx.tcx, self.cx.typing_env(), typeck_results).eval_local(e, e.span.ctxt())
         });
 
         // const hashing may result in the same hash as some unrelated node, so add a sort of
diff --git a/tests/ui/assertions_on_constants.rs b/tests/ui/assertions_on_constants.rs
index b613892f206a6..f467d4966aef7 100644
--- a/tests/ui/assertions_on_constants.rs
+++ b/tests/ui/assertions_on_constants.rs
@@ -43,6 +43,7 @@ fn main() {
     assert_const!(-1);
 
     assert!(cfg!(feature = "hey") || cfg!(not(feature = "asdf")));
+    //~^ assertions_on_constants
 
     let flag: bool = cfg!(not(feature = "asdf"));
     assert!(flag);
diff --git a/tests/ui/assertions_on_constants.stderr b/tests/ui/assertions_on_constants.stderr
index 9aed1405fa043..a996c41b69420 100644
--- a/tests/ui/assertions_on_constants.stderr
+++ b/tests/ui/assertions_on_constants.stderr
@@ -72,8 +72,16 @@ LL |     debug_assert!(true);
    |
    = help: remove the assertion
 
+error: this assertion has a constant value
+  --> tests/ui/assertions_on_constants.rs:45:5
+   |
+LL |     assert!(cfg!(feature = "hey") || cfg!(not(feature = "asdf")));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider moving this into a const block: `const { assert!(..) }`
+
 error: this assertion is always `true`
-  --> tests/ui/assertions_on_constants.rs:53:19
+  --> tests/ui/assertions_on_constants.rs:54:19
    |
 LL |     const _: () = assert!(true);
    |                   ^^^^^^^^^^^^^
@@ -81,7 +89,7 @@ LL |     const _: () = assert!(true);
    = help: remove the assertion
 
 error: this assertion is always `true`
-  --> tests/ui/assertions_on_constants.rs:56:5
+  --> tests/ui/assertions_on_constants.rs:57:5
    |
 LL |     assert!(8 == (7 + 1));
    |     ^^^^^^^^^^^^^^^^^^^^^
@@ -89,7 +97,7 @@ LL |     assert!(8 == (7 + 1));
    = help: remove the assertion
 
 error: this assertion is always `true`
-  --> tests/ui/assertions_on_constants.rs:67:5
+  --> tests/ui/assertions_on_constants.rs:68:5
    |
 LL |     assert!(true);
    |     ^^^^^^^^^^^^^
@@ -97,7 +105,7 @@ LL |     assert!(true);
    = help: remove the assertion
 
 error: this assertion is always `true`
-  --> tests/ui/assertions_on_constants.rs:70:5
+  --> tests/ui/assertions_on_constants.rs:71:5
    |
 LL |     assert!(8 == (7 + 1));
    |     ^^^^^^^^^^^^^^^^^^^^^
@@ -105,7 +113,7 @@ LL |     assert!(8 == (7 + 1));
    = help: remove the assertion
 
 error: this assertion has a constant value
-  --> tests/ui/assertions_on_constants.rs:78:5
+  --> tests/ui/assertions_on_constants.rs:79:5
    |
 LL |     assert!(C);
    |     ^^^^^^^^^^
@@ -113,7 +121,7 @@ LL |     assert!(C);
    = help: consider moving this to an anonymous constant: `const _: () = { assert!(..); }`
 
 error: this assertion has a constant value
-  --> tests/ui/assertions_on_constants.rs:89:5
+  --> tests/ui/assertions_on_constants.rs:90:5
    |
 LL |     assert!(C);
    |     ^^^^^^^^^^
@@ -121,12 +129,12 @@ LL |     assert!(C);
    = help: consider moving this into a const block: `const { assert!(..) }`
 
 error: this assertion has a constant value
-  --> tests/ui/assertions_on_constants.rs:95:5
+  --> tests/ui/assertions_on_constants.rs:96:5
    |
 LL |     assert!(C);
    |     ^^^^^^^^^^
    |
    = help: consider moving this to an anonymous constant: `const _: () = { assert!(..); }`
 
-error: aborting due to 16 previous errors
+error: aborting due to 17 previous errors
 

From e6429c74548aa2a5e20b78dca51c5f74ad59dea8 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 1 Oct 2025 21:05:28 +1000
Subject: [PATCH 1621/1889] Don't create a top-level `true` directory when
 running UI tests

---
 .../cmse-nonsecure-call/undeclared-lifetime.rs               | 5 +++--
 .../cmse-nonsecure-call/undeclared-lifetime.stderr           | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/undeclared-lifetime.rs b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/undeclared-lifetime.rs
index 5fa5b74c0c0b9..0a0dca804ef35 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/undeclared-lifetime.rs
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/undeclared-lifetime.rs
@@ -1,5 +1,6 @@
 //@ add-core-stubs
-//@ compile-flags: --target thumbv8m.main-none-eabi --crate-type lib -Cincremental=true
+//@ compile-flags: --target thumbv8m.main-none-eabi --crate-type lib
+//@ incremental (required to trigger the bug)
 //@ needs-llvm-components: arm
 #![feature(abi_cmse_nonsecure_call, no_core)]
 #![no_core]
@@ -8,7 +9,7 @@ extern crate minicore;
 use minicore::*;
 
 // A regression test for https://github.com/rust-lang/rust/issues/131639.
-// NOTE: -Cincremental=true was required for triggering the bug.
+// NOTE: `-Cincremental` was required for triggering the bug.
 
 fn foo() {
     id::<extern "cmse-nonsecure-call" fn(&'a ())>(PhantomData);
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/undeclared-lifetime.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/undeclared-lifetime.stderr
index 4aca17e73544d..7300bdb72cdda 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/undeclared-lifetime.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/undeclared-lifetime.stderr
@@ -1,5 +1,5 @@
 error[E0261]: use of undeclared lifetime name `'a`
-  --> $DIR/undeclared-lifetime.rs:14:43
+  --> $DIR/undeclared-lifetime.rs:15:43
    |
 LL |     id::<extern "cmse-nonsecure-call" fn(&'a ())>(PhantomData);
    |                                           ^^ undeclared lifetime

From b810a68197515bfbe5afd8557b566d6817035389 Mon Sep 17 00:00:00 2001
From: Kivooeo <Kivooeo123@gmail.com>
Date: Wed, 1 Oct 2025 11:53:47 +0000
Subject: [PATCH 1622/1889] added error for closures case in impl

---
 .../src/coherence/inherent_impls.rs               |  9 ++++-----
 .../rustc_hir_analysis/src/coherence/orphan.rs    | 10 ++++++----
 tests/ui/closures/impl-closure-147146.rs          |  7 +++++++
 tests/ui/closures/impl-closure-147146.stderr      | 15 +++++++++++++++
 4 files changed, 32 insertions(+), 9 deletions(-)
 create mode 100644 tests/ui/closures/impl-closure-147146.rs
 create mode 100644 tests/ui/closures/impl-closure-147146.stderr

diff --git a/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs b/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs
index 38ae7852ca99f..b069a74bf5adc 100644
--- a/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs
@@ -195,11 +195,10 @@ impl<'tcx> InherentCollect<'tcx> {
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
             | ty::Coroutine(..)
-            | ty::CoroutineWitness(..)
-            | ty::Alias(ty::Free, _)
-            | ty::Bound(..)
-            | ty::Placeholder(_)
-            | ty::Infer(_) => {
+            | ty::CoroutineWitness(..) => {
+                Err(self.tcx.dcx().delayed_bug("cannot define inherent `impl` for closure types"))
+            }
+            ty::Alias(ty::Free, _) | ty::Bound(..) | ty::Placeholder(_) | ty::Infer(_) => {
                 bug!("unexpected impl self type of impl: {:?} {:?}", id, self_ty);
             }
             // We could bail out here, but that will silence other useful errors.
diff --git a/compiler/rustc_hir_analysis/src/coherence/orphan.rs b/compiler/rustc_hir_analysis/src/coherence/orphan.rs
index 621431ae2343c..5a61248cab8fe 100644
--- a/compiler/rustc_hir_analysis/src/coherence/orphan.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/orphan.rs
@@ -230,10 +230,12 @@ pub(crate) fn orphan_check_impl(
             ty::Closure(..)
             | ty::CoroutineClosure(..)
             | ty::Coroutine(..)
-            | ty::CoroutineWitness(..)
-            | ty::Bound(..)
-            | ty::Placeholder(..)
-            | ty::Infer(..) => {
+            | ty::CoroutineWitness(..) => {
+                return Err(tcx
+                    .dcx()
+                    .delayed_bug("cannot define inherent `impl` for closure types"));
+            }
+            ty::Bound(..) | ty::Placeholder(..) | ty::Infer(..) => {
                 let sp = tcx.def_span(impl_def_id);
                 span_bug!(sp, "weird self type for autotrait impl")
             }
diff --git a/tests/ui/closures/impl-closure-147146.rs b/tests/ui/closures/impl-closure-147146.rs
new file mode 100644
index 0000000000000..b709e577354e5
--- /dev/null
+++ b/tests/ui/closures/impl-closure-147146.rs
@@ -0,0 +1,7 @@
+impl typeof(|| {}) {}
+//~^ ERROR `typeof` is a reserved keyword but unimplemented
+
+unsafe impl Send for typeof(|| {}) {}
+//~^ ERROR `typeof` is a reserved keyword but unimplemented
+
+fn main() {}
diff --git a/tests/ui/closures/impl-closure-147146.stderr b/tests/ui/closures/impl-closure-147146.stderr
new file mode 100644
index 0000000000000..6da16b5d450fd
--- /dev/null
+++ b/tests/ui/closures/impl-closure-147146.stderr
@@ -0,0 +1,15 @@
+error[E0516]: `typeof` is a reserved keyword but unimplemented
+  --> $DIR/impl-closure-147146.rs:1:6
+   |
+LL | impl typeof(|| {}) {}
+   |      ^^^^^^^^^^^^^ reserved keyword
+
+error[E0516]: `typeof` is a reserved keyword but unimplemented
+  --> $DIR/impl-closure-147146.rs:4:22
+   |
+LL | unsafe impl Send for typeof(|| {}) {}
+   |                      ^^^^^^^^^^^^^ reserved keyword
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0516`.

From 5ade7647b7ec9080aa91e174f4b12a1eac8e9bd5 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 30 Sep 2025 17:47:40 -0500
Subject: [PATCH 1623/1889] Change ArrayWindows to use a slice

---
 library/core/src/slice/iter.rs | 69 +++++++++++-----------------------
 1 file changed, 22 insertions(+), 47 deletions(-)

diff --git a/library/core/src/slice/iter.rs b/library/core/src/slice/iter.rs
index ae910e0525209..7053ae86e732f 100644
--- a/library/core/src/slice/iter.rs
+++ b/library/core/src/slice/iter.rs
@@ -2203,16 +2203,13 @@ unsafe impl<T> Sync for ChunksExactMut<'_, T> where T: Sync {}
 #[unstable(feature = "array_windows", issue = "75027")]
 #[must_use = "iterators are lazy and do nothing unless consumed"]
 pub struct ArrayWindows<'a, T: 'a, const N: usize> {
-    slice_head: *const T,
-    num: usize,
-    marker: PhantomData<&'a [T; N]>,
+    v: &'a [T],
 }
 
 impl<'a, T: 'a, const N: usize> ArrayWindows<'a, T, N> {
     #[inline]
     pub(super) const fn new(slice: &'a [T]) -> Self {
-        let num_windows = slice.len().saturating_sub(N - 1);
-        Self { slice_head: slice.as_ptr(), num: num_windows, marker: PhantomData }
+        Self { v: slice }
     }
 }
 
@@ -2222,49 +2219,34 @@ impl<'a, T, const N: usize> Iterator for ArrayWindows<'a, T, N> {
 
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
-        if self.num == 0 {
-            return None;
+        let ret = self.v.first_chunk();
+        if ret.is_some() {
+            self.v = &self.v[1..];
         }
-        // SAFETY:
-        // This is safe because it's indexing into a slice guaranteed to be length > N.
-        let ret = unsafe { &*self.slice_head.cast::<[T; N]>() };
-        // SAFETY: Guaranteed that there are at least 1 item remaining otherwise
-        // earlier branch would've been hit
-        self.slice_head = unsafe { self.slice_head.add(1) };
-
-        self.num -= 1;
-        Some(ret)
+        ret
     }
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.num, Some(self.num))
+        let size = self.v.len().saturating_sub(N - 1);
+        (size, Some(size))
     }
 
     #[inline]
     fn count(self) -> usize {
-        self.num
+        self.len()
     }
 
     #[inline]
     fn nth(&mut self, n: usize) -> Option<Self::Item> {
-        if self.num <= n {
-            self.num = 0;
-            return None;
-        }
-        // SAFETY:
-        // This is safe because it's indexing into a slice guaranteed to be length > N.
-        let ret = unsafe { &*self.slice_head.add(n).cast::<[T; N]>() };
-        // SAFETY: Guaranteed that there are at least n items remaining
-        self.slice_head = unsafe { self.slice_head.add(n + 1) };
-
-        self.num -= n + 1;
-        Some(ret)
+        let idx = n.min(self.v.len());
+        self.v = &self.v[idx..];
+        self.next()
     }
 
     #[inline]
-    fn last(mut self) -> Option<Self::Item> {
-        self.nth(self.num.checked_sub(1)?)
+    fn last(self) -> Option<Self::Item> {
+        self.v.last_chunk()
     }
 }
 
@@ -2272,32 +2254,25 @@ impl<'a, T, const N: usize> Iterator for ArrayWindows<'a, T, N> {
 impl<'a, T, const N: usize> DoubleEndedIterator for ArrayWindows<'a, T, N> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a [T; N]> {
-        if self.num == 0 {
-            return None;
+        let ret = self.v.last_chunk();
+        if ret.is_some() {
+            self.v = &self.v[..self.v.len() - 1];
         }
-        // SAFETY: Guaranteed that there are n items remaining, n-1 for 0-indexing.
-        let ret = unsafe { &*self.slice_head.add(self.num - 1).cast::<[T; N]>() };
-        self.num -= 1;
-        Some(ret)
+        ret
     }
 
     #[inline]
     fn nth_back(&mut self, n: usize) -> Option<&'a [T; N]> {
-        if self.num <= n {
-            self.num = 0;
-            return None;
-        }
-        // SAFETY: Guaranteed that there are n items remaining, n-1 for 0-indexing.
-        let ret = unsafe { &*self.slice_head.add(self.num - (n + 1)).cast::<[T; N]>() };
-        self.num -= n + 1;
-        Some(ret)
+        let idx = self.v.len().saturating_sub(n);
+        self.v = &self.v[..idx];
+        self.next_back()
     }
 }
 
 #[unstable(feature = "array_windows", issue = "75027")]
 impl<T, const N: usize> ExactSizeIterator for ArrayWindows<'_, T, N> {
     fn is_empty(&self) -> bool {
-        self.num == 0
+        self.v.len() < N
     }
 }
 

From 5b809b355c5c134e6848f800a2f8e692a3c10d44 Mon Sep 17 00:00:00 2001
From: daxpedda <daxpedda@gmail.com>
Date: Wed, 1 Oct 2025 14:47:42 +0200
Subject: [PATCH 1624/1889] Don't enable shared memory with Wasm atomics

---
 compiler/rustc_codegen_ssa/src/back/linker.rs | 33 +------------------
 1 file changed, 1 insertion(+), 32 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/linker.rs b/compiler/rustc_codegen_ssa/src/back/linker.rs
index e644a43f88340..ac12314373828 100644
--- a/compiler/rustc_codegen_ssa/src/back/linker.rs
+++ b/compiler/rustc_codegen_ssa/src/back/linker.rs
@@ -17,7 +17,6 @@ use rustc_middle::middle::exported_symbols::{
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Session;
 use rustc_session::config::{self, CrateType, DebugInfo, LinkerPluginLto, Lto, OptLevel, Strip};
-use rustc_span::sym;
 use rustc_target::spec::{Cc, LinkOutputKind, LinkerFlavor, Lld};
 use tracing::{debug, warn};
 
@@ -1324,37 +1323,7 @@ struct WasmLd<'a> {
 
 impl<'a> WasmLd<'a> {
     fn new(cmd: Command, sess: &'a Session) -> WasmLd<'a> {
-        // If the atomics feature is enabled for wasm then we need a whole bunch
-        // of flags:
-        //
-        // * `--shared-memory` - the link won't even succeed without this, flags
-        //   the one linear memory as `shared`
-        //
-        // * `--max-memory=1G` - when specifying a shared memory this must also
-        //   be specified. We conservatively choose 1GB but users should be able
-        //   to override this with `-C link-arg`.
-        //
-        // * `--import-memory` - it doesn't make much sense for memory to be
-        //   exported in a threaded module because typically you're
-        //   sharing memory and instantiating the module multiple times. As a
-        //   result if it were exported then we'd just have no sharing.
-        //
-        // On wasm32-unknown-unknown, we also export symbols for glue code to use:
-        //    * `--export=*tls*` - when `#[thread_local]` symbols are used these
-        //      symbols are how the TLS segments are initialized and configured.
-        let mut wasm_ld = WasmLd { cmd, sess };
-        if sess.target_features.contains(&sym::atomics) {
-            wasm_ld.link_args(&["--shared-memory", "--max-memory=1073741824", "--import-memory"]);
-            if sess.target.os == "unknown" || sess.target.os == "none" {
-                wasm_ld.link_args(&[
-                    "--export=__wasm_init_tls",
-                    "--export=__tls_size",
-                    "--export=__tls_align",
-                    "--export=__tls_base",
-                ]);
-            }
-        }
-        wasm_ld
+        WasmLd { cmd, sess }
     }
 }
 

From 96fb1b3b559ccc8ed051c95fa5385f9ba4030a01 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Wed, 1 Oct 2025 16:11:21 +0200
Subject: [PATCH 1625/1889] include outer_inclusive_binder of pattern types

---
 compiler/rustc_type_ir/src/flags.rs           |  1 +
 .../type/pattern_types/transmute.next.stderr  | 21 +++++++++++++++++++
 2 files changed, 22 insertions(+)
 create mode 100644 tests/ui/type/pattern_types/transmute.next.stderr

diff --git a/compiler/rustc_type_ir/src/flags.rs b/compiler/rustc_type_ir/src/flags.rs
index 24704c5bb5358..ea3903d401e39 100644
--- a/compiler/rustc_type_ir/src/flags.rs
+++ b/compiler/rustc_type_ir/src/flags.rs
@@ -347,6 +347,7 @@ impl<I: Interner> FlagComputation<I> {
 
     fn add_ty_pat(&mut self, pat: <I as Interner>::Pat) {
         self.add_flags(pat.flags());
+        self.add_exclusive_binder(pat.outer_exclusive_binder());
     }
 
     fn add_predicate(&mut self, binder: ty::Binder<I, ty::PredicateKind<I>>) {
diff --git a/tests/ui/type/pattern_types/transmute.next.stderr b/tests/ui/type/pattern_types/transmute.next.stderr
new file mode 100644
index 0000000000000..edec542e5e151
--- /dev/null
+++ b/tests/ui/type/pattern_types/transmute.next.stderr
@@ -0,0 +1,21 @@
+error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
+  --> $DIR/transmute.rs:23:14
+   |
+LL |     unsafe { std::mem::transmute(x) }
+   |              ^^^^^^^^^^^^^^^^^^^
+   |
+   = note: source type: `Option<(u32) is S..=E>` (size can vary because of u32)
+   = note: target type: `u32` (32 bits)
+
+error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
+  --> $DIR/transmute.rs:31:14
+   |
+LL |     unsafe { std::mem::transmute(x) }
+   |              ^^^^^^^^^^^^^^^^^^^
+   |
+   = note: source type: `Option<(u32) is S..=E>` (size can vary because of u32)
+   = note: target type: `Option<u32>` (64 bits)
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0512`.

From 0435b16f3b8d4b6139993a60528658416aa36d39 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Wed, 1 Oct 2025 00:20:47 +0200
Subject: [PATCH 1626/1889] swap order of resolve_coroutine_interiors and
 handle_opaque_type_uses

---
 compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs | 18 ++++++------------
 compiler/rustc_hir_typeck/src/lib.rs           |  9 +++------
 2 files changed, 9 insertions(+), 18 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
index 833ce433d56f0..35253e4c29195 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -611,19 +611,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         typeck_results.rvalue_scopes = rvalue_scopes;
     }
 
-    /// Unify the inference variables corresponding to coroutine witnesses, and save all the
-    /// predicates that were stalled on those inference variables.
-    ///
-    /// This process allows to conservatively save all predicates that do depend on the coroutine
-    /// interior types, for later processing by `check_coroutine_obligations`.
-    ///
-    /// We must not attempt to select obligations after this method has run, or risk query cycle
-    /// ICE.
+    /// Drain all obligations that are stalled on coroutines defined in this body.
     #[instrument(level = "debug", skip(self))]
-    pub(crate) fn resolve_coroutine_interiors(&self) {
-        // Try selecting all obligations that are not blocked on inference variables.
-        // Once we start unifying coroutine witnesses, trying to select obligations on them will
-        // trigger query cycle ICEs, as doing so requires MIR.
+    pub(crate) fn drain_stalled_coroutine_obligations(&self) {
+        // Make as much inference progress as possible before
+        // draining the stalled coroutine obligations as this may
+        // change obligations from being stalled on infer vars to
+        // being stalled on a coroutine.
         self.select_obligations_where_possible(|_| {});
 
         let ty::TypingMode::Analysis { defining_opaque_types_and_generators } = self.typing_mode()
diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
index acc0481e457fd..9f5a85b692642 100644
--- a/compiler/rustc_hir_typeck/src/lib.rs
+++ b/compiler/rustc_hir_typeck/src/lib.rs
@@ -243,18 +243,15 @@ fn typeck_with_inspect<'tcx>(
 
     debug!(pending_obligations = ?fcx.fulfillment_cx.borrow().pending_obligations());
 
-    // This must be the last thing before `report_ambiguity_errors`.
-    fcx.resolve_coroutine_interiors();
-
-    debug!(pending_obligations = ?fcx.fulfillment_cx.borrow().pending_obligations());
-
     // We need to handle opaque types before emitting ambiguity errors as applying
     // defining uses may guide type inference.
     if fcx.next_trait_solver() {
         fcx.handle_opaque_type_uses_next();
     }
 
-    fcx.select_obligations_where_possible(|_| {});
+    // This must be the last thing before `report_ambiguity_errors` below except `select_obligations_where_possible`.
+    // So don't put anything after this.
+    fcx.drain_stalled_coroutine_obligations();
     if fcx.infcx.tainted_by_errors().is_none() {
         fcx.report_ambiguity_errors();
     }

From 84864bcf89592a1c85b6646d600ca111291fbc66 Mon Sep 17 00:00:00 2001
From: Brian Caswell <bcaswell@gmail.com>
Date: Wed, 1 Oct 2025 11:07:42 -0400
Subject: [PATCH 1627/1889] Fix typo in 'unfulfilled_lint_expectation' to
 plural

---
 src/doc/rustc/src/lints/levels.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc/src/lints/levels.md b/src/doc/rustc/src/lints/levels.md
index 5b002b435a51e..09b55da741d6c 100644
--- a/src/doc/rustc/src/lints/levels.md
+++ b/src/doc/rustc/src/lints/levels.md
@@ -38,7 +38,7 @@ talk about later in this section.
 
 Sometimes, it can be helpful to suppress lints, but at the same time ensure that
 the code in question still emits them. The 'expect' level does exactly this. If
-the lint in question is not emitted, the `unfulfilled_lint_expectation` lint
+the lint in question is not emitted, the `unfulfilled_lint_expectations` lint
 triggers on the `expect` attribute, notifying you that the expectation is no
 longer fulfilled.
 

From 8dfea22c974fe18aca8322f1c73f8455dc42c66f Mon Sep 17 00:00:00 2001
From: edwloef <edwin.frank.loeffler@gmail.com>
Date: Wed, 1 Oct 2025 16:03:46 +0200
Subject: [PATCH 1628/1889] implement `Box::take`

---
 library/alloc/src/boxed.rs | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/library/alloc/src/boxed.rs b/library/alloc/src/boxed.rs
index 5a63d90b95fa0..49ff768bed1b2 100644
--- a/library/alloc/src/boxed.rs
+++ b/library/alloc/src/boxed.rs
@@ -619,6 +619,37 @@ impl<T, A: Allocator> Box<T, A> {
     pub fn into_inner(boxed: Self) -> T {
         *boxed
     }
+
+    /// Consumes the `Box` without consuming its allocation, returning the wrapped value and a `Box`
+    /// to the uninitialized memory where the wrapped value used to live.
+    ///
+    /// This can be used together with [`write`](Box::write) to reuse the allocation for multiple
+    /// boxed values.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(box_take)]
+    ///
+    /// let c = Box::new(5);
+    ///
+    /// // take the value out of the box
+    /// let (value, uninit) = Box::take(c);
+    /// assert_eq!(value, 5);
+    ///
+    /// // reuse the box for a second value
+    /// let c = Box::write(uninit, 6);
+    /// assert_eq!(*c, 6);
+    /// ```
+    #[unstable(feature = "box_take", issue = "147212")]
+    pub fn take(boxed: Self) -> (T, Box<mem::MaybeUninit<T>, A>) {
+        unsafe {
+            let (raw, alloc) = Box::into_raw_with_allocator(boxed);
+            let value = raw.read();
+            let uninit = Box::from_raw_in(raw.cast::<mem::MaybeUninit<T>>(), alloc);
+            (value, uninit)
+        }
+    }
 }
 
 impl<T> Box<[T]> {

From 69619535d9dbad6a7f5e622bfd3e3c3fb190e0aa Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Wed, 1 Oct 2025 17:36:53 +0200
Subject: [PATCH 1629/1889] Switch `citool` to 2024 edition

---
 src/ci/citool/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/ci/citool/Cargo.toml b/src/ci/citool/Cargo.toml
index f61243a4d712b..078b877e44b1c 100644
--- a/src/ci/citool/Cargo.toml
+++ b/src/ci/citool/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "citool"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 [dependencies]
 anyhow = "1"

From 4baf9208a129e5ea8b3973ce2eeb55fdd7404aea Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Wed, 1 Oct 2025 17:38:36 +0200
Subject: [PATCH 1630/1889] Initialize llvm submodule if not already the case
 to run citool

---
 src/ci/citool/src/main.rs  |  4 +++-
 src/ci/citool/src/utils.rs | 18 ++++++++++++++++++
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/src/ci/citool/src/main.rs b/src/ci/citool/src/main.rs
index fe1b36673a1b0..255d39846da1f 100644
--- a/src/ci/citool/src/main.rs
+++ b/src/ci/citool/src/main.rs
@@ -24,7 +24,7 @@ use crate::github::JobInfoResolver;
 use crate::jobs::RunType;
 use crate::metrics::{JobMetrics, download_auto_job_metrics, download_job_metrics, load_metrics};
 use crate::test_dashboard::generate_test_dashboard;
-use crate::utils::{load_env_var, output_details};
+use crate::utils::{init_submodule_if_needed, load_env_var, output_details};
 
 const CI_DIRECTORY: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/..");
 pub const DOCKER_DIRECTORY: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/../docker");
@@ -121,6 +121,8 @@ fn run_workflow_locally(db: JobDatabase, job_type: JobType, name: String) -> any
         (key.clone(), value)
     }));
 
+    init_submodule_if_needed("src/llvm-project/")?;
+
     let mut cmd = Command::new(Path::new(DOCKER_DIRECTORY).join("run.sh"));
     cmd.arg(job.image());
     cmd.envs(custom_env);
diff --git a/src/ci/citool/src/utils.rs b/src/ci/citool/src/utils.rs
index 3176cb62f6066..43b220255dc71 100644
--- a/src/ci/citool/src/utils.rs
+++ b/src/ci/citool/src/utils.rs
@@ -1,5 +1,7 @@
 use std::borrow::Cow;
+use std::convert::AsRef;
 use std::path::Path;
+use std::process::Command;
 
 use anyhow::Context;
 
@@ -34,3 +36,19 @@ where
 pub fn normalize_path_delimiters(name: &str) -> Cow<'_, str> {
     if name.contains("\\") { name.replace('\\', "/").into() } else { name.into() }
 }
+
+pub fn init_submodule_if_needed<P: AsRef<Path>>(path_to_submodule: P) -> anyhow::Result<()> {
+    let path_to_submodule = path_to_submodule.as_ref();
+
+    if let Ok(mut iter) = path_to_submodule.read_dir()
+        && iter.any(|entry| entry.is_ok())
+    {
+        // Seems like the submodule is already initialized, nothing to be done here.
+        return Ok(());
+    }
+    let mut child = Command::new("git")
+        .args(&["submodule", "update", "--init"])
+        .arg(path_to_submodule)
+        .spawn()?;
+    if !child.wait()?.success() { Err(anyhow::anyhow!("git command failed")) } else { Ok(()) }
+}

From 3e8ce2bda9e9563c546287b4715fcde61d008d3e Mon Sep 17 00:00:00 2001
From: daxpedda <daxpedda@gmail.com>
Date: Wed, 1 Oct 2025 17:43:53 +0200
Subject: [PATCH 1631/1889] Adjust WASI and WALI targets

---
 .../src/spec/targets/wasm32_wali_linux_musl.rs      | 13 ++++++++++---
 .../src/spec/targets/wasm32_wasip1_threads.rs       |  3 ++-
 2 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_target/src/spec/targets/wasm32_wali_linux_musl.rs b/compiler/rustc_target/src/spec/targets/wasm32_wali_linux_musl.rs
index a0eb4a254fc0e..06e5cfaed92da 100644
--- a/compiler/rustc_target/src/spec/targets/wasm32_wali_linux_musl.rs
+++ b/compiler/rustc_target/src/spec/targets/wasm32_wali_linux_musl.rs
@@ -6,11 +6,18 @@ use crate::spec::{Cc, LinkerFlavor, Target, TargetMetadata, base};
 pub(crate) fn target() -> Target {
     let mut options = base::linux_wasm::opts();
 
-    options
-        .add_pre_link_args(LinkerFlavor::WasmLld(Cc::No), &["--export-memory", "--shared-memory"]);
+    options.add_pre_link_args(
+        LinkerFlavor::WasmLld(Cc::No),
+        &["--export-memory", "--shared-memory", "--max-memory=1073741824"],
+    );
     options.add_pre_link_args(
         LinkerFlavor::WasmLld(Cc::Yes),
-        &["--target=wasm32-wasi-threads", "-Wl,--export-memory,", "-Wl,--shared-memory"],
+        &[
+            "--target=wasm32-wasi-threads",
+            "-Wl,--export-memory,",
+            "-Wl,--shared-memory",
+            "-Wl,--max-memory=1073741824",
+        ],
     );
 
     Target {
diff --git a/compiler/rustc_target/src/spec/targets/wasm32_wasip1_threads.rs b/compiler/rustc_target/src/spec/targets/wasm32_wasip1_threads.rs
index 44d906a507de1..c735c72cb1cb1 100644
--- a/compiler/rustc_target/src/spec/targets/wasm32_wasip1_threads.rs
+++ b/compiler/rustc_target/src/spec/targets/wasm32_wasip1_threads.rs
@@ -19,7 +19,7 @@ pub(crate) fn target() -> Target {
 
     options.add_pre_link_args(
         LinkerFlavor::WasmLld(Cc::No),
-        &["--import-memory", "--export-memory", "--shared-memory"],
+        &["--import-memory", "--export-memory", "--shared-memory", "--max-memory=1073741824"],
     );
     options.add_pre_link_args(
         LinkerFlavor::WasmLld(Cc::Yes),
@@ -28,6 +28,7 @@ pub(crate) fn target() -> Target {
             "-Wl,--import-memory",
             "-Wl,--export-memory,",
             "-Wl,--shared-memory",
+            "-Wl,--max-memory=1073741824",
         ],
     );
 

From a7eed086b913d708c9f38ce9c833e403f00fc15d Mon Sep 17 00:00:00 2001
From: LorrensP-2158466 <lorrens.pantelis@student.uhasselt.be>
Date: Tue, 30 Sep 2025 19:45:26 +0200
Subject: [PATCH 1632/1889] Add the check-pass and check-fail tests.

---
 .../same-res-ambigious-extern-fail.rs         | 16 +++++++++++++++
 .../same-res-ambigious-extern-macro.rs        |  8 ++++++++
 .../auxiliary/same-res-ambigious-extern.rs    | 11 ++++++++++
 .../ui/imports/same-res-ambigious.fail.stderr | 20 +++++++++++++++++++
 .../same-res-ambigious.nightly-fail.stderr    | 20 +++++++++++++++++++
 tests/ui/imports/same-res-ambigious.rs        | 11 ++++++++++
 6 files changed, 86 insertions(+)
 create mode 100644 tests/ui/imports/auxiliary/same-res-ambigious-extern-fail.rs
 create mode 100644 tests/ui/imports/auxiliary/same-res-ambigious-extern-macro.rs
 create mode 100644 tests/ui/imports/auxiliary/same-res-ambigious-extern.rs
 create mode 100644 tests/ui/imports/same-res-ambigious.fail.stderr
 create mode 100644 tests/ui/imports/same-res-ambigious.nightly-fail.stderr
 create mode 100644 tests/ui/imports/same-res-ambigious.rs

diff --git a/tests/ui/imports/auxiliary/same-res-ambigious-extern-fail.rs b/tests/ui/imports/auxiliary/same-res-ambigious-extern-fail.rs
new file mode 100644
index 0000000000000..61a8d8f0054a8
--- /dev/null
+++ b/tests/ui/imports/auxiliary/same-res-ambigious-extern-fail.rs
@@ -0,0 +1,16 @@
+//@ edition:2018
+//@ proc-macro: same-res-ambigious-extern-macro.rs
+
+macro_rules! globbing{
+    () => {
+        pub use same_res_ambigious_extern_macro::*;
+    }
+}
+
+#[macro_use] // this imports the `RustEmbed` macro with `pub(crate)` visibility
+extern crate same_res_ambigious_extern_macro;
+globbing! {} // this imports the same `RustEmbed` macro with `pub` visibility
+
+pub trait RustEmbed {}
+
+pub use RustEmbed as Embed;
diff --git a/tests/ui/imports/auxiliary/same-res-ambigious-extern-macro.rs b/tests/ui/imports/auxiliary/same-res-ambigious-extern-macro.rs
new file mode 100644
index 0000000000000..4e9b8427092f5
--- /dev/null
+++ b/tests/ui/imports/auxiliary/same-res-ambigious-extern-macro.rs
@@ -0,0 +1,8 @@
+//@ edition: 2018
+extern crate proc_macro;
+use proc_macro::TokenStream;
+
+#[proc_macro_derive(RustEmbed)]
+pub fn rust_embed_derive(_input: TokenStream) -> TokenStream {
+    TokenStream::new()
+}
diff --git a/tests/ui/imports/auxiliary/same-res-ambigious-extern.rs b/tests/ui/imports/auxiliary/same-res-ambigious-extern.rs
new file mode 100644
index 0000000000000..5269dcd0b17a2
--- /dev/null
+++ b/tests/ui/imports/auxiliary/same-res-ambigious-extern.rs
@@ -0,0 +1,11 @@
+//@ edition:2018
+//@ proc-macro: same-res-ambigious-extern-macro.rs
+
+#[macro_use] // this imports the `RustEmbed` macro with `pub(crate)` visibility
+extern crate same_res_ambigious_extern_macro;
+// this imports the same `RustEmbed` macro with `pub` visibility
+pub use same_res_ambigious_extern_macro::*;
+
+pub trait RustEmbed {}
+
+pub use RustEmbed as Embed;
diff --git a/tests/ui/imports/same-res-ambigious.fail.stderr b/tests/ui/imports/same-res-ambigious.fail.stderr
new file mode 100644
index 0000000000000..dfd7c5a5f94e0
--- /dev/null
+++ b/tests/ui/imports/same-res-ambigious.fail.stderr
@@ -0,0 +1,20 @@
+error[E0603]: derive macro `Embed` is private
+  --> $DIR/same-res-ambigious.rs:8:28
+   |
+LL | #[derive(ambigious_extern::Embed)]
+   |                            ^^^^^ private derive macro
+   |
+note: the derive macro `Embed` is defined here
+  --> $DIR/auxiliary/same-res-ambigious-extern-fail.rs:16:9
+   |
+LL | pub use RustEmbed as Embed;
+   |         ^^^^^^^^^
+help: import `Embed` directly
+   |
+LL - #[derive(ambigious_extern::Embed)]
+LL + #[derive(same_res_ambigious_extern_macro::RustEmbed)]
+   |
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0603`.
diff --git a/tests/ui/imports/same-res-ambigious.nightly-fail.stderr b/tests/ui/imports/same-res-ambigious.nightly-fail.stderr
new file mode 100644
index 0000000000000..dfd7c5a5f94e0
--- /dev/null
+++ b/tests/ui/imports/same-res-ambigious.nightly-fail.stderr
@@ -0,0 +1,20 @@
+error[E0603]: derive macro `Embed` is private
+  --> $DIR/same-res-ambigious.rs:8:28
+   |
+LL | #[derive(ambigious_extern::Embed)]
+   |                            ^^^^^ private derive macro
+   |
+note: the derive macro `Embed` is defined here
+  --> $DIR/auxiliary/same-res-ambigious-extern-fail.rs:16:9
+   |
+LL | pub use RustEmbed as Embed;
+   |         ^^^^^^^^^
+help: import `Embed` directly
+   |
+LL - #[derive(ambigious_extern::Embed)]
+LL + #[derive(same_res_ambigious_extern_macro::RustEmbed)]
+   |
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0603`.
diff --git a/tests/ui/imports/same-res-ambigious.rs b/tests/ui/imports/same-res-ambigious.rs
new file mode 100644
index 0000000000000..b5c13a15b7c9c
--- /dev/null
+++ b/tests/ui/imports/same-res-ambigious.rs
@@ -0,0 +1,11 @@
+//@ edition: 2018
+//@ revisions: fail pass
+//@[pass] check-pass
+//@[pass] aux-crate: ambigious_extern=same-res-ambigious-extern.rs
+//@[fail] aux-crate: ambigious_extern=same-res-ambigious-extern-fail.rs
+// see https://github.com/rust-lang/rust/pull/147196
+
+#[derive(ambigious_extern::Embed)] //[fail]~ ERROR: derive macro `Embed` is private
+struct Foo{}
+
+fn main(){}

From 94f00f4e4a0240bc7b8284c78482e37af252309a Mon Sep 17 00:00:00 2001
From: Jules Bertholet <julesbertholet@quoi.xyz>
Date: Wed, 1 Oct 2025 11:32:54 -0400
Subject: [PATCH 1633/1889] Fix memory leak in `os` impl

---
 library/std/src/sys/thread_local/os.rs        | 103 ++++++++++++------
 .../miri/tests/pass/thread_local-panic.rs     |   8 ++
 .../miri/tests/pass/thread_local-panic.stderr |   5 +
 3 files changed, 85 insertions(+), 31 deletions(-)
 create mode 100644 src/tools/miri/tests/pass/thread_local-panic.rs
 create mode 100644 src/tools/miri/tests/pass/thread_local-panic.stderr

diff --git a/library/std/src/sys/thread_local/os.rs b/library/std/src/sys/thread_local/os.rs
index b488f12fe841f..88bb5ae7c650d 100644
--- a/library/std/src/sys/thread_local/os.rs
+++ b/library/std/src/sys/thread_local/os.rs
@@ -1,9 +1,12 @@
 use super::key::{Key, LazyKey, get, set};
 use super::{abort_on_dtor_unwind, guard};
-use crate::alloc::Layout;
+use crate::alloc::{self, Layout};
 use crate::cell::Cell;
 use crate::marker::PhantomData;
-use crate::ptr;
+use crate::mem::ManuallyDrop;
+use crate::ops::Deref;
+use crate::panic::{AssertUnwindSafe, catch_unwind, resume_unwind};
+use crate::ptr::{self, NonNull};
 
 #[doc(hidden)]
 #[allow_internal_unstable(thread_local_internals)]
@@ -110,6 +113,60 @@ pub const fn value_align<T: 'static>() -> usize {
     crate::mem::align_of::<Value<T>>()
 }
 
+/// Equivalent to `Box<Value<T>>`, but potentially over-aligned.
+struct AlignedBox<T: 'static, const ALIGN: usize> {
+    ptr: NonNull<Value<T>>,
+}
+
+impl<T: 'static, const ALIGN: usize> AlignedBox<T, ALIGN> {
+    #[inline]
+    fn new(v: Value<T>) -> Self {
+        let layout = Layout::new::<Value<T>>().align_to(ALIGN).unwrap();
+
+        let ptr: *mut Value<T> = (unsafe { alloc::alloc(layout) }).cast();
+        let Some(ptr) = NonNull::new(ptr) else {
+            alloc::handle_alloc_error(layout);
+        };
+        unsafe { ptr.write(v) };
+        Self { ptr }
+    }
+
+    #[inline]
+    fn into_raw(b: Self) -> *mut Value<T> {
+        let md = ManuallyDrop::new(b);
+        md.ptr.as_ptr()
+    }
+
+    #[inline]
+    unsafe fn from_raw(ptr: *mut Value<T>) -> Self {
+        Self { ptr: unsafe { NonNull::new_unchecked(ptr) } }
+    }
+}
+
+impl<T: 'static, const ALIGN: usize> Deref for AlignedBox<T, ALIGN> {
+    type Target = Value<T>;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*(self.ptr.as_ptr()) }
+    }
+}
+
+impl<T: 'static, const ALIGN: usize> Drop for AlignedBox<T, ALIGN> {
+    #[inline]
+    fn drop(&mut self) {
+        let layout = Layout::new::<Value<T>>().align_to(ALIGN).unwrap();
+
+        unsafe {
+            let unwind_result = catch_unwind(AssertUnwindSafe(|| self.ptr.drop_in_place()));
+            alloc::dealloc(self.ptr.as_ptr().cast(), layout);
+            if let Err(payload) = unwind_result {
+                resume_unwind(payload);
+            }
+        }
+    }
+}
+
 impl<T: 'static, const ALIGN: usize> Storage<T, ALIGN> {
     pub const fn new() -> Storage<T, ALIGN> {
         Storage { key: LazyKey::new(Some(destroy_value::<T, ALIGN>)), marker: PhantomData }
@@ -148,15 +205,11 @@ impl<T: 'static, const ALIGN: usize> Storage<T, ALIGN> {
             return ptr::null();
         }
 
-        // Manually allocate with the requested alignment
-        let layout = Layout::new::<Value<T>>().align_to(ALIGN).unwrap();
-        let ptr: *mut Value<T> = (unsafe { crate::alloc::alloc(layout) }).cast();
-        if ptr.is_null() {
-            crate::alloc::handle_alloc_error(layout);
-        }
-        unsafe {
-            ptr.write(Value { value: i.and_then(Option::take).unwrap_or_else(f), key });
-        }
+        let value = AlignedBox::<T, ALIGN>::new(Value {
+            value: i.and_then(Option::take).unwrap_or_else(f),
+            key,
+        });
+        let ptr = AlignedBox::into_raw(value);
 
         // SAFETY:
         // * key came from a `LazyKey` and is thus correct.
@@ -174,10 +227,7 @@ impl<T: 'static, const ALIGN: usize> Storage<T, ALIGN> {
             // initializer has already returned and the next scope only starts
             // after we return the pointer. Therefore, there can be no references
             // to the old value.
-            unsafe {
-                old.drop_in_place();
-                crate::alloc::dealloc(old.cast(), layout);
-            }
+            drop(unsafe { AlignedBox::<T, ALIGN>::from_raw(old) });
         }
 
         // SAFETY: We just created this value above.
@@ -196,22 +246,13 @@ unsafe extern "C" fn destroy_value<T: 'static, const ALIGN: usize>(ptr: *mut u8)
     // Note that to prevent an infinite loop we reset it back to null right
     // before we return from the destructor ourselves.
     abort_on_dtor_unwind(|| {
-        let value_ptr: *mut Value<T> = ptr.cast();
-        unsafe {
-            let key = (*value_ptr).key;
-
-            // SAFETY: `key` is the TLS key `ptr` was stored under.
-            set(key, ptr::without_provenance_mut(1));
-
-            // drop and deallocate the value
-            let layout =
-                Layout::from_size_align_unchecked(crate::mem::size_of::<Value<T>>(), ALIGN);
-            value_ptr.drop_in_place();
-            crate::alloc::dealloc(ptr, layout);
-
-            // SAFETY: `key` is the TLS key `ptr` was stored under.
-            set(key, ptr::null_mut());
-        };
+        let ptr = unsafe { AlignedBox::<T, ALIGN>::from_raw(ptr as *mut Value<T>) };
+        let key = ptr.key;
+        // SAFETY: `key` is the TLS key `ptr` was stored under.
+        unsafe { set(key, ptr::without_provenance_mut(1)) };
+        drop(ptr);
+        // SAFETY: `key` is the TLS key `ptr` was stored under.
+        unsafe { set(key, ptr::null_mut()) };
         // Make sure that the runtime cleanup will be performed
         // after the next round of TLS destruction.
         guard::enable();
diff --git a/src/tools/miri/tests/pass/thread_local-panic.rs b/src/tools/miri/tests/pass/thread_local-panic.rs
new file mode 100644
index 0000000000000..549acd23987e9
--- /dev/null
+++ b/src/tools/miri/tests/pass/thread_local-panic.rs
@@ -0,0 +1,8 @@
+thread_local! {
+    static LOCAL: u64 = panic!();
+
+}
+
+fn main() {
+    let _ = std::panic::catch_unwind(|| LOCAL.with(|_| {}));
+}
diff --git a/src/tools/miri/tests/pass/thread_local-panic.stderr b/src/tools/miri/tests/pass/thread_local-panic.stderr
new file mode 100644
index 0000000000000..e69340a810268
--- /dev/null
+++ b/src/tools/miri/tests/pass/thread_local-panic.stderr
@@ -0,0 +1,5 @@
+
+thread 'main' ($TID) panicked at tests/pass/thread_local-panic.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 `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect

From 5991c8703d01cc73c31c51fef5d92b93ac1391b4 Mon Sep 17 00:00:00 2001
From: rustbot <47979223+rustbot@users.noreply.github.com>
Date: Wed, 1 Oct 2025 19:14:45 +0200
Subject: [PATCH 1634/1889] Update books

---
 src/doc/book          | 2 +-
 src/doc/edition-guide | 2 +-
 src/doc/nomicon       | 2 +-
 src/doc/reference     | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/doc/book b/src/doc/book
index 33f1af40cc44d..1d7c3e6abec2d 160000
--- a/src/doc/book
+++ b/src/doc/book
@@ -1 +1 @@
-Subproject commit 33f1af40cc44dde7e3e892f7a508e6f427d2cbc6
+Subproject commit 1d7c3e6abec2d5a9bfac798b29b7855b95025426
diff --git a/src/doc/edition-guide b/src/doc/edition-guide
index aa6ce337c0adf..e2ed891f00361 160000
--- a/src/doc/edition-guide
+++ b/src/doc/edition-guide
@@ -1 +1 @@
-Subproject commit aa6ce337c0adf7a63e33960d184270f2a45ab9ef
+Subproject commit e2ed891f00361efc26616d82590b1c85d7a8920e
diff --git a/src/doc/nomicon b/src/doc/nomicon
index f17a018b99894..23fc2682f8fcb 160000
--- a/src/doc/nomicon
+++ b/src/doc/nomicon
@@ -1 +1 @@
-Subproject commit f17a018b9989430967d1c58e9a12c51169abc744
+Subproject commit 23fc2682f8fcb887f77d0eaabba708809f834c11
diff --git a/src/doc/reference b/src/doc/reference
index cc7247d8dfaef..e11adf6016a36 160000
--- a/src/doc/reference
+++ b/src/doc/reference
@@ -1 +1 @@
-Subproject commit cc7247d8dfaef4c39000bb12c55c32ba5b5ba976
+Subproject commit e11adf6016a362766eea5a3f9832e193994dd0c8

From 6eef2859c73592967222f13c2d0ad599be75fe6b Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Wed, 1 Oct 2025 18:20:01 +0000
Subject: [PATCH 1635/1889] Add an ACP list item to the library tracking issue
 template

Most new API has an associated ACP that is useful to reference, but it
doesn't appear anywhere on the template for new tracking issues. Update
this template to include a link to the ACP.
---
 .github/ISSUE_TEMPLATE/library_tracking_issue.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/ISSUE_TEMPLATE/library_tracking_issue.md b/.github/ISSUE_TEMPLATE/library_tracking_issue.md
index d56da9d5d025a..de823dc300d15 100644
--- a/.github/ISSUE_TEMPLATE/library_tracking_issue.md
+++ b/.github/ISSUE_TEMPLATE/library_tracking_issue.md
@@ -51,6 +51,7 @@ If the feature is changed later, please add those PRs here as well.
 
 (Remember to update the `S-tracking-*` label when checking boxes.)
 
+- [ ] ACP: rust-lang/libs-team#...
 - [ ] Implementation: #...
 - [ ] Final comment period (FCP)[^1]
 - [ ] Stabilization PR

From a7bd285a6a3de46ec32c355865b449a56861bfd9 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Fri, 26 Sep 2025 14:21:08 +0200
Subject: [PATCH 1636/1889] cmse: use BackendRepr to determine valid 64-bit
 return types

---
 .../src/hir_ty_lowering/cmse.rs               | 48 ++++++++-----------
 1 file changed, 19 insertions(+), 29 deletions(-)

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 0a41659ec6685..378771c05ee33 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
@@ -1,8 +1,8 @@
-use rustc_abi::ExternAbi;
+use rustc_abi::{BackendRepr, ExternAbi, Float, Integer, Primitive, Scalar};
 use rustc_errors::{DiagCtxtHandle, E0781, struct_span_code_err};
 use rustc_hir::{self as hir, HirId};
 use rustc_middle::bug;
-use rustc_middle::ty::layout::LayoutError;
+use rustc_middle::ty::layout::{LayoutError, TyAndLayout};
 use rustc_middle::ty::{self, TyCtxt};
 
 use crate::errors;
@@ -164,44 +164,34 @@ fn is_valid_cmse_output<'tcx>(
 ) -> Result<bool, &'tcx LayoutError<'tcx>> {
     // this type is only used for layout computation, which does not rely on regions
     let fn_sig = tcx.instantiate_bound_regions_with_erased(fn_sig);
+    let fn_sig = tcx.erase_and_anonymize_regions(fn_sig);
 
     let typing_env = ty::TypingEnv::fully_monomorphized();
+    let layout = tcx.layout_of(typing_env.as_query_input(fn_sig.output()))?;
+
+    Ok(is_valid_cmse_output_layout(layout))
+}
 
-    let mut ret_ty = fn_sig.output();
-    let layout = tcx.layout_of(typing_env.as_query_input(ret_ty))?;
+/// Returns whether the output will fit into the available registers
+fn is_valid_cmse_output_layout<'tcx>(layout: TyAndLayout<'tcx>) -> bool {
     let size = layout.layout.size().bytes();
 
     if size <= 4 {
-        return Ok(true);
+        return true;
     } else if size > 8 {
-        return Ok(false);
+        return false;
     }
 
-    // next we need to peel any repr(transparent) layers off
-    'outer: loop {
-        let ty::Adt(adt_def, args) = ret_ty.kind() else {
-            break;
-        };
-
-        if !adt_def.repr().transparent() {
-            break;
-        }
+    // Accept scalar 64-bit types.
+    let BackendRepr::Scalar(scalar) = layout.layout.backend_repr else {
+        return false;
+    };
 
-        // the first field with non-trivial size and alignment must be the data
-        for variant_def in adt_def.variants() {
-            for field_def in variant_def.fields.iter() {
-                let ty = field_def.ty(tcx, args);
-                let layout = tcx.layout_of(typing_env.as_query_input(ty))?;
-
-                if !layout.layout.is_1zst() {
-                    ret_ty = ty;
-                    continue 'outer;
-                }
-            }
-        }
-    }
+    let Scalar::Initialized { value, .. } = scalar else {
+        return false;
+    };
 
-    Ok(ret_ty == tcx.types.i64 || ret_ty == tcx.types.u64 || ret_ty == tcx.types.f64)
+    matches!(value, Primitive::Int(Integer::I64, _) | Primitive::Float(Float::F64))
 }
 
 fn should_emit_generic_error<'tcx>(abi: ExternAbi, layout_err: &'tcx LayoutError<'tcx>) -> bool {

From 4735c2184c72b8b3a8bad642407a74d4b19838fb Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Wed, 2 Jul 2025 17:18:57 +0800
Subject: [PATCH 1637/1889] Fix diagnostics str::replace comma to bar

---
 .../rustc_parse/src/parser/diagnostics.rs     | 34 +++++++++----------
 1 file changed, 16 insertions(+), 18 deletions(-)

diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs
index a28af7833c387..5d6da60931200 100644
--- a/compiler/rustc_parse/src/parser/diagnostics.rs
+++ b/compiler/rustc_parse/src/parser/diagnostics.rs
@@ -2947,26 +2947,24 @@ impl<'a> Parser<'a> {
         }
         let seq_span = lo.to(self.prev_token.span);
         let mut err = self.dcx().struct_span_err(comma_span, "unexpected `,` in pattern");
-        if let Ok(seq_snippet) = self.span_to_snippet(seq_span) {
-            err.multipart_suggestion(
-                format!(
-                    "try adding parentheses to match on a tuple{}",
-                    if let CommaRecoveryMode::LikelyTuple = rt { "" } else { "..." },
-                ),
-                vec![
-                    (seq_span.shrink_to_lo(), "(".to_string()),
-                    (seq_span.shrink_to_hi(), ")".to_string()),
-                ],
+        err.multipart_suggestion(
+            format!(
+                "try adding parentheses to match on a tuple{}",
+                if let CommaRecoveryMode::LikelyTuple = rt { "" } else { "..." },
+            ),
+            vec![
+                (seq_span.shrink_to_lo(), "(".to_string()),
+                (seq_span.shrink_to_hi(), ")".to_string()),
+            ],
+            Applicability::MachineApplicable,
+        );
+        if let CommaRecoveryMode::EitherTupleOrPipe = rt {
+            err.span_suggestion(
+                comma_span,
+                "...or a vertical bar to match on alternative",
+                " |",
                 Applicability::MachineApplicable,
             );
-            if let CommaRecoveryMode::EitherTupleOrPipe = rt {
-                err.span_suggestion(
-                    seq_span,
-                    "...or a vertical bar to match on multiple alternatives",
-                    seq_snippet.replace(',', " |"),
-                    Applicability::MachineApplicable,
-                );
-            }
         }
         Err(err)
     }

From a08228d284a91e5b2514035b723e82deb9179985 Mon Sep 17 00:00:00 2001
From: Karol Zwolak <karolzwolak7@gmail.com>
Date: Sat, 27 Sep 2025 22:57:13 +0200
Subject: [PATCH 1638/1889] bless tests

---
 ...ssue-48492-tuple-destructure-missing-parens.stderr |  4 ++--
 .../feature-gates/feature-gate-never_patterns.stderr  |  2 +-
 tests/ui/parser/match-arm-without-body.rs             |  4 ++--
 tests/ui/parser/match-arm-without-body.stderr         | 11 ++++-------
 4 files changed, 9 insertions(+), 12 deletions(-)

diff --git a/tests/ui/did_you_mean/issue-48492-tuple-destructure-missing-parens.stderr b/tests/ui/did_you_mean/issue-48492-tuple-destructure-missing-parens.stderr
index c74cb89f85cb9..dc875ad27ea6e 100644
--- a/tests/ui/did_you_mean/issue-48492-tuple-destructure-missing-parens.stderr
+++ b/tests/ui/did_you_mean/issue-48492-tuple-destructure-missing-parens.stderr
@@ -32,10 +32,10 @@ help: try adding parentheses to match on a tuple...
    |
 LL |         (Nucleotide::Adenine, Nucleotide::Cytosine, _) => true
    |         +                                            +
-help: ...or a vertical bar to match on multiple alternatives
+help: ...or a vertical bar to match on alternative
    |
 LL -         Nucleotide::Adenine, Nucleotide::Cytosine, _ => true
-LL +         Nucleotide::Adenine | Nucleotide::Cytosine | _ => true
+LL +         Nucleotide::Adenine | Nucleotide::Cytosine, _ => true
    |
 
 error: unexpected `,` in pattern
diff --git a/tests/ui/feature-gates/feature-gate-never_patterns.stderr b/tests/ui/feature-gates/feature-gate-never_patterns.stderr
index 473e263c79650..5e810249b9063 100644
--- a/tests/ui/feature-gates/feature-gate-never_patterns.stderr
+++ b/tests/ui/feature-gates/feature-gate-never_patterns.stderr
@@ -8,7 +8,7 @@ help: try adding parentheses to match on a tuple...
    |
 LL |         (Some(_),)
    |         +        +
-help: ...or a vertical bar to match on multiple alternatives
+help: ...or a vertical bar to match on alternative
    |
 LL -         Some(_),
 LL +         Some(_) |
diff --git a/tests/ui/parser/match-arm-without-body.rs b/tests/ui/parser/match-arm-without-body.rs
index 4723abff8b6ae..7fe5b6d253980 100644
--- a/tests/ui/parser/match-arm-without-body.rs
+++ b/tests/ui/parser/match-arm-without-body.rs
@@ -17,13 +17,13 @@ fn main() {
         Some(_),
         //~^ ERROR unexpected `,` in pattern
         //~| HELP try adding parentheses to match on a tuple
-        //~| HELP or a vertical bar to match on multiple alternatives
+        //~| HELP or a vertical bar to match on alternative
     }
     match Some(false) {
         Some(_),
         //~^ ERROR unexpected `,` in pattern
         //~| HELP try adding parentheses to match on a tuple
-        //~| HELP or a vertical bar to match on multiple alternatives
+        //~| HELP or a vertical bar to match on alternative
         _ => {}
     }
     match Some(false) {
diff --git a/tests/ui/parser/match-arm-without-body.stderr b/tests/ui/parser/match-arm-without-body.stderr
index a65875b787a39..85ff7db8d4aa3 100644
--- a/tests/ui/parser/match-arm-without-body.stderr
+++ b/tests/ui/parser/match-arm-without-body.stderr
@@ -16,7 +16,7 @@ help: try adding parentheses to match on a tuple...
    |
 LL |         (Some(_),)
    |         +        +
-help: ...or a vertical bar to match on multiple alternatives
+help: ...or a vertical bar to match on alternative
    |
 LL -         Some(_),
 LL +         Some(_) |
@@ -36,13 +36,10 @@ LL |
 LL |
 LL ~         _) => {}
    |
-help: ...or a vertical bar to match on multiple alternatives
+help: ...or a vertical bar to match on alternative
    |
-LL ~         Some(_) |
-LL +
-LL +
-LL +
-LL ~         _ => {}
+LL -         Some(_),
+LL +         Some(_) |
    |
 
 error: expected one of `.`, `=>`, `?`, or an operator, found reserved identifier `_`

From 934ad740270944800d03f6290bcc131a8697e59f Mon Sep 17 00:00:00 2001
From: Karol Zwolak <karolzwolak7@gmail.com>
Date: Wed, 1 Oct 2025 22:40:23 +0200
Subject: [PATCH 1639/1889] regression test

---
 ...place-intended-bar-not-all-in-pattern.fixed | 18 ++++++++++++++++++
 ...-replace-intended-bar-not-all-in-pattern.rs | 18 ++++++++++++++++++
 ...lace-intended-bar-not-all-in-pattern.stderr | 18 ++++++++++++++++++
 3 files changed, 54 insertions(+)
 create mode 100644 tests/ui/suggestions/only-replace-intended-bar-not-all-in-pattern.fixed
 create mode 100644 tests/ui/suggestions/only-replace-intended-bar-not-all-in-pattern.rs
 create mode 100644 tests/ui/suggestions/only-replace-intended-bar-not-all-in-pattern.stderr

diff --git a/tests/ui/suggestions/only-replace-intended-bar-not-all-in-pattern.fixed b/tests/ui/suggestions/only-replace-intended-bar-not-all-in-pattern.fixed
new file mode 100644
index 0000000000000..5abc1edd381bf
--- /dev/null
+++ b/tests/ui/suggestions/only-replace-intended-bar-not-all-in-pattern.fixed
@@ -0,0 +1,18 @@
+//@ run-rustfix
+
+// Regression test for issue #143330.
+// Ensure we suggest to replace only the intended bar with a comma, not all bars in the pattern.
+
+fn main() {
+    struct Foo { x: i32, ch: char }
+    let pos = Foo { x: 2, ch: 'x' };
+    match pos {
+        // All commas here were replaced with bars.
+        // Foo { x: 2 | ch: ' |' } | Foo { x: 3 | ch: '@' } => (),
+        (Foo { x: 2, ch: ',' } | Foo { x: 3, ch: '@' }) => (),
+        //~^ ERROR unexpected `,` in pattern
+        //~| HELP try adding parentheses to match on a tuple...
+        //~| HELP ...or a vertical bar to match on alternative
+        _ => todo!(),
+    }
+}
diff --git a/tests/ui/suggestions/only-replace-intended-bar-not-all-in-pattern.rs b/tests/ui/suggestions/only-replace-intended-bar-not-all-in-pattern.rs
new file mode 100644
index 0000000000000..5bd267c3bc402
--- /dev/null
+++ b/tests/ui/suggestions/only-replace-intended-bar-not-all-in-pattern.rs
@@ -0,0 +1,18 @@
+//@ run-rustfix
+
+// Regression test for issue #143330.
+// Ensure we suggest to replace only the intended bar with a comma, not all bars in the pattern.
+
+fn main() {
+    struct Foo { x: i32, ch: char }
+    let pos = Foo { x: 2, ch: 'x' };
+    match pos {
+        // All commas here were replaced with bars.
+        // Foo { x: 2 | ch: ' |' } | Foo { x: 3 | ch: '@' } => (),
+        Foo { x: 2, ch: ',' }, Foo { x: 3, ch: '@' } => (),
+        //~^ ERROR unexpected `,` in pattern
+        //~| HELP try adding parentheses to match on a tuple...
+        //~| HELP ...or a vertical bar to match on alternative
+        _ => todo!(),
+    }
+}
diff --git a/tests/ui/suggestions/only-replace-intended-bar-not-all-in-pattern.stderr b/tests/ui/suggestions/only-replace-intended-bar-not-all-in-pattern.stderr
new file mode 100644
index 0000000000000..db0bb8c50e865
--- /dev/null
+++ b/tests/ui/suggestions/only-replace-intended-bar-not-all-in-pattern.stderr
@@ -0,0 +1,18 @@
+error: unexpected `,` in pattern
+  --> $DIR/only-replace-intended-bar-not-all-in-pattern.rs:12:30
+   |
+LL |         Foo { x: 2, ch: ',' }, Foo { x: 3, ch: '@' } => (),
+   |                              ^
+   |
+help: try adding parentheses to match on a tuple...
+   |
+LL |         (Foo { x: 2, ch: ',' }, Foo { x: 3, ch: '@' }) => (),
+   |         +                                            +
+help: ...or a vertical bar to match on alternative
+   |
+LL -         Foo { x: 2, ch: ',' }, Foo { x: 3, ch: '@' } => (),
+LL +         Foo { x: 2, ch: ',' } | Foo { x: 3, ch: '@' } => (),
+   |
+
+error: aborting due to 1 previous error
+

From 951d35eeb6aa3bd0ba6fd399290cbdeceec5a97a Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sun, 21 Sep 2025 17:30:57 +0200
Subject: [PATCH 1640/1889] Do not trigger `inefficient_to_string` after Rust
 1.82

Starting with Rust version 1.82.0, the compiler generates similar code with
and without the `with_ref` cfg:

```rust
fn f(x: impl IntoIterator<Item = String>) {
    for y in x { println!("{y}"); }
}

fn main() {
    #[cfg(with_ref)]
    let a = ["foo", "bar"].iter().map(|&s| s.to_string());
    #[cfg(not(with_ref))]
    let a = ["foo", "bar"].iter().map(|s| s.to_string());
    f(a);
}
```

The generated code is strictly identical with `-O`, and identical modulo
some minor reordering without.
---
 book/src/lint_configuration.md                    |  1 +
 clippy_config/src/conf.rs                         |  1 +
 clippy_lints/src/methods/inefficient_to_string.rs |  4 ++++
 clippy_lints/src/methods/mod.rs                   | 11 +++++++----
 clippy_utils/src/msrvs.rs                         |  2 +-
 tests/ui/inefficient_to_string.fixed              |  8 ++++++++
 tests/ui/inefficient_to_string.rs                 |  8 ++++++++
 tests/ui/inefficient_to_string.stderr             | 12 ++++++------
 8 files changed, 36 insertions(+), 11 deletions(-)

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index c2d080cd96a1d..5953e5048e4a6 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -845,6 +845,7 @@ The minimum rust version that the project supports. Defaults to the `rust-versio
 * [`from_over_into`](https://rust-lang.github.io/rust-clippy/master/index.html#from_over_into)
 * [`if_then_some_else_none`](https://rust-lang.github.io/rust-clippy/master/index.html#if_then_some_else_none)
 * [`index_refutable_slice`](https://rust-lang.github.io/rust-clippy/master/index.html#index_refutable_slice)
+* [`inefficient_to_string`](https://rust-lang.github.io/rust-clippy/master/index.html#inefficient_to_string)
 * [`io_other_error`](https://rust-lang.github.io/rust-clippy/master/index.html#io_other_error)
 * [`iter_kv_map`](https://rust-lang.github.io/rust-clippy/master/index.html#iter_kv_map)
 * [`legacy_numeric_constants`](https://rust-lang.github.io/rust-clippy/master/index.html#legacy_numeric_constants)
diff --git a/clippy_config/src/conf.rs b/clippy_config/src/conf.rs
index 2f28f6175ad82..6e8752c5f932d 100644
--- a/clippy_config/src/conf.rs
+++ b/clippy_config/src/conf.rs
@@ -741,6 +741,7 @@ define_Conf! {
         from_over_into,
         if_then_some_else_none,
         index_refutable_slice,
+        inefficient_to_string,
         io_other_error,
         iter_kv_map,
         legacy_numeric_constants,
diff --git a/clippy_lints/src/methods/inefficient_to_string.rs b/clippy_lints/src/methods/inefficient_to_string.rs
index 47195fdd65f5f..ab21515f47f78 100644
--- a/clippy_lints/src/methods/inefficient_to_string.rs
+++ b/clippy_lints/src/methods/inefficient_to_string.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_type_lang_item, peel_and_count_ty_refs};
 use rustc_errors::Applicability;
@@ -16,6 +17,7 @@ pub fn check(
     method_name: Symbol,
     receiver: &hir::Expr<'_>,
     args: &[hir::Expr<'_>],
+    msrv: Msrv,
 ) {
     if args.is_empty()
         && method_name == sym::to_string
@@ -26,6 +28,8 @@ pub fn check(
         && let self_ty = args.type_at(0)
         && let (deref_self_ty, deref_count, _) = peel_and_count_ty_refs(self_ty)
         && deref_count >= 1
+        // Since Rust 1.82, the specialized `ToString` is properly called
+        && !msrv.meets(cx, msrvs::SPECIALIZED_TO_STRING_FOR_REFS)
         && specializes_tostring(cx, deref_self_ty)
     {
         span_lint_and_then(
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 8679689c8ad4d..5448a266ab7d0 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -477,6 +477,9 @@ declare_clippy_lint! {
     /// ### What it does
     /// Checks for usage of `ok().expect(..)`.
     ///
+    /// Note: This lint only triggers for code marked compatible
+    /// with versions of the compiler older than Rust 1.82.0.
+    ///
     /// ### Why is this bad?
     /// Because you usually call `expect()` on the `Result`
     /// directly to get a better error message.
@@ -1080,9 +1083,9 @@ declare_clippy_lint! {
     /// `T` implements `ToString` directly (like `&&str` or `&&String`).
     ///
     /// ### Why is this bad?
-    /// This bypasses the specialized implementation of
-    /// `ToString` and instead goes through the more expensive string formatting
-    /// facilities.
+    /// In versions of the compiler before Rust 1.82.0, this bypasses the specialized
+    /// implementation of`ToString` and instead goes through the more expensive string
+    /// formatting facilities.
     ///
     /// ### Example
     /// ```no_run
@@ -4868,7 +4871,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 );
                 clone_on_copy::check(cx, expr, method_call.ident.name, receiver, args);
                 clone_on_ref_ptr::check(cx, expr, method_call.ident.name, receiver, args);
-                inefficient_to_string::check(cx, expr, method_call.ident.name, receiver, args);
+                inefficient_to_string::check(cx, expr, method_call.ident.name, receiver, args, self.msrv);
                 single_char_add_str::check(cx, expr, receiver, args);
                 into_iter_on_ref::check(cx, expr, method_span, method_call.ident.name, receiver);
                 unnecessary_to_owned::check(cx, expr, method_call.ident.name, receiver, args, self.msrv);
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 6e07ed9ffcc4d..43e9a8f505191 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -28,7 +28,7 @@ msrv_aliases! {
     1,85,0 { UINT_FLOAT_MIDPOINT, CONST_SIZE_OF_VAL }
     1,84,0 { CONST_OPTION_AS_SLICE, MANUAL_DANGLING_PTR }
     1,83,0 { CONST_EXTERN_FN, CONST_FLOAT_BITS_CONV, CONST_FLOAT_CLASSIFY, CONST_MUT_REFS, CONST_UNWRAP }
-    1,82,0 { IS_NONE_OR, REPEAT_N, RAW_REF_OP }
+    1,82,0 { IS_NONE_OR, REPEAT_N, RAW_REF_OP, SPECIALIZED_TO_STRING_FOR_REFS }
     1,81,0 { LINT_REASONS_STABILIZATION, ERROR_IN_CORE, EXPLICIT_SELF_TYPE_ELISION, DURATION_ABS_DIFF }
     1,80,0 { BOX_INTO_ITER, LAZY_CELL }
     1,77,0 { C_STR_LITERALS }
diff --git a/tests/ui/inefficient_to_string.fixed b/tests/ui/inefficient_to_string.fixed
index a0d34e58a9255..29cf6de6ae5e8 100644
--- a/tests/ui/inefficient_to_string.fixed
+++ b/tests/ui/inefficient_to_string.fixed
@@ -2,6 +2,7 @@
 
 use std::borrow::Cow;
 
+#[clippy::msrv = "1.81"]
 fn main() {
     let rstr: &str = "hello";
     let rrstr: &&str = &rstr;
@@ -34,3 +35,10 @@ fn main() {
     let _: String = (**rrrcow).to_string();
     //~^ inefficient_to_string
 }
+
+#[clippy::msrv = "1.82"]
+fn sufficient_msrv() {
+    let rstr: &str = "hello";
+    let rrstr: &&str = &rstr;
+    let _: String = rrstr.to_string();
+}
diff --git a/tests/ui/inefficient_to_string.rs b/tests/ui/inefficient_to_string.rs
index cbe90d4a125b0..724955c60f795 100644
--- a/tests/ui/inefficient_to_string.rs
+++ b/tests/ui/inefficient_to_string.rs
@@ -2,6 +2,7 @@
 
 use std::borrow::Cow;
 
+#[clippy::msrv = "1.81"]
 fn main() {
     let rstr: &str = "hello";
     let rrstr: &&str = &rstr;
@@ -34,3 +35,10 @@ fn main() {
     let _: String = rrrcow.to_string();
     //~^ inefficient_to_string
 }
+
+#[clippy::msrv = "1.82"]
+fn sufficient_msrv() {
+    let rstr: &str = "hello";
+    let rrstr: &&str = &rstr;
+    let _: String = rrstr.to_string();
+}
diff --git a/tests/ui/inefficient_to_string.stderr b/tests/ui/inefficient_to_string.stderr
index 8593c0addc5f8..ea3dd7e0ae2f8 100644
--- a/tests/ui/inefficient_to_string.stderr
+++ b/tests/ui/inefficient_to_string.stderr
@@ -1,5 +1,5 @@
 error: calling `to_string` on `&&str`
-  --> tests/ui/inefficient_to_string.rs:10:21
+  --> tests/ui/inefficient_to_string.rs:11:21
    |
 LL |     let _: String = rrstr.to_string();
    |                     ^^^^^^^^^^^^^^^^^ help: try dereferencing the receiver: `(*rrstr).to_string()`
@@ -12,7 +12,7 @@ LL | #![deny(clippy::inefficient_to_string)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: calling `to_string` on `&&&str`
-  --> tests/ui/inefficient_to_string.rs:12:21
+  --> tests/ui/inefficient_to_string.rs:13:21
    |
 LL |     let _: String = rrrstr.to_string();
    |                     ^^^^^^^^^^^^^^^^^^ help: try dereferencing the receiver: `(**rrrstr).to_string()`
@@ -20,7 +20,7 @@ LL |     let _: String = rrrstr.to_string();
    = help: `&&str` implements `ToString` through a slower blanket impl, but `str` has a fast specialization of `ToString`
 
 error: calling `to_string` on `&&std::string::String`
-  --> tests/ui/inefficient_to_string.rs:21:21
+  --> tests/ui/inefficient_to_string.rs:22:21
    |
 LL |     let _: String = rrstring.to_string();
    |                     ^^^^^^^^^^^^^^^^^^^^ help: try dereferencing the receiver: `(*rrstring).to_string()`
@@ -28,7 +28,7 @@ LL |     let _: String = rrstring.to_string();
    = help: `&std::string::String` implements `ToString` through a slower blanket impl, but `std::string::String` has a fast specialization of `ToString`
 
 error: calling `to_string` on `&&&std::string::String`
-  --> tests/ui/inefficient_to_string.rs:23:21
+  --> tests/ui/inefficient_to_string.rs:24:21
    |
 LL |     let _: String = rrrstring.to_string();
    |                     ^^^^^^^^^^^^^^^^^^^^^ help: try dereferencing the receiver: `(**rrrstring).to_string()`
@@ -36,7 +36,7 @@ LL |     let _: String = rrrstring.to_string();
    = help: `&&std::string::String` implements `ToString` through a slower blanket impl, but `std::string::String` has a fast specialization of `ToString`
 
 error: calling `to_string` on `&&std::borrow::Cow<'_, str>`
-  --> tests/ui/inefficient_to_string.rs:32:21
+  --> tests/ui/inefficient_to_string.rs:33:21
    |
 LL |     let _: String = rrcow.to_string();
    |                     ^^^^^^^^^^^^^^^^^ help: try dereferencing the receiver: `(*rrcow).to_string()`
@@ -44,7 +44,7 @@ LL |     let _: String = rrcow.to_string();
    = help: `&std::borrow::Cow<'_, str>` implements `ToString` through a slower blanket impl, but `std::borrow::Cow<'_, str>` has a fast specialization of `ToString`
 
 error: calling `to_string` on `&&&std::borrow::Cow<'_, str>`
-  --> tests/ui/inefficient_to_string.rs:34:21
+  --> tests/ui/inefficient_to_string.rs:35:21
    |
 LL |     let _: String = rrrcow.to_string();
    |                     ^^^^^^^^^^^^^^^^^^ help: try dereferencing the receiver: `(**rrrcow).to_string()`

From 8fcb7e18c108294b06fd4c27ab6f007d68a7ef1b Mon Sep 17 00:00:00 2001
From: Kivooeo <Kivooeo123@gmail.com>
Date: Wed, 1 Oct 2025 21:22:53 +0000
Subject: [PATCH 1641/1889] extended doc comment

---
 library/alloc/src/collections/btree/map.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/library/alloc/src/collections/btree/map.rs b/library/alloc/src/collections/btree/map.rs
index adcb444d08c66..ca5b46c9b0fd0 100644
--- a/library/alloc/src/collections/btree/map.rs
+++ b/library/alloc/src/collections/btree/map.rs
@@ -1368,7 +1368,8 @@ impl<K, V, A: Allocator + Clone> BTreeMap<K, V, A> {
     }
 
     /// Splits the collection into two at the given key. Returns everything after the given key,
-    /// including the key.
+    /// including the key. If the key is not present, the split will occur at the nearest
+    /// greater key, or return an empty map if no such key exists.
     ///
     /// # Examples
     ///

From 08b4641f50f6f8fa3aa222fa606a0c1a2482b72d Mon Sep 17 00:00:00 2001
From: Jeremy Smart <jeremy3141592@gmail.com>
Date: Wed, 20 Aug 2025 18:20:53 -0400
Subject: [PATCH 1642/1889] add CloneFromCell and Cell::get_cloned

---
 library/alloc/src/lib.rs  |  1 +
 library/alloc/src/rc.rs   | 10 ++++-
 library/alloc/src/sync.rs |  9 ++++
 library/core/src/cell.rs  | 92 ++++++++++++++++++++++++++++++++++++++-
 library/core/src/tuple.rs | 10 +++++
 5 files changed, 119 insertions(+), 3 deletions(-)

diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs
index cba1ce40f75d5..e7cfd01e654e4 100644
--- a/library/alloc/src/lib.rs
+++ b/library/alloc/src/lib.rs
@@ -103,6 +103,7 @@
 #![feature(bstr)]
 #![feature(bstr_internals)]
 #![feature(cast_maybe_uninit)]
+#![feature(cell_get_cloned)]
 #![feature(char_internals)]
 #![feature(char_max_len)]
 #![feature(clone_to_uninit)]
diff --git a/library/alloc/src/rc.rs b/library/alloc/src/rc.rs
index aed3357afbf4b..783b6147e9569 100644
--- a/library/alloc/src/rc.rs
+++ b/library/alloc/src/rc.rs
@@ -242,7 +242,7 @@
 #![stable(feature = "rust1", since = "1.0.0")]
 
 use core::any::Any;
-use core::cell::Cell;
+use core::cell::{Cell, CloneFromCell};
 #[cfg(not(no_global_oom_handling))]
 use core::clone::CloneToUninit;
 use core::clone::UseCloned;
@@ -338,6 +338,10 @@ impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Rc<U, A>> for
 #[unstable(feature = "dispatch_from_dyn", issue = "none")]
 impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Rc<U>> for Rc<T> {}
 
+// SAFETY: `Rc::clone` doesn't access any `Cell`s which could contain the `Rc` being cloned.
+#[unstable(feature = "cell_get_cloned", issue = "145329")]
+unsafe impl<T: ?Sized> CloneFromCell for Rc<T> {}
+
 impl<T: ?Sized> Rc<T> {
     #[inline]
     unsafe fn from_inner(ptr: NonNull<RcInner<T>>) -> Self {
@@ -3011,6 +3015,10 @@ impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Weak<U, A>> f
 #[unstable(feature = "dispatch_from_dyn", issue = "none")]
 impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Weak<U>> for Weak<T> {}
 
+// SAFETY: `Weak::clone` doesn't access any `Cell`s which could contain the `Weak` being cloned.
+#[unstable(feature = "cell_get_cloned", issue = "145329")]
+unsafe impl<T: ?Sized> CloneFromCell for Weak<T> {}
+
 impl<T> Weak<T> {
     /// Constructs a new `Weak<T>`, without allocating any memory.
     /// Calling [`upgrade`] on the return value always gives [`None`].
diff --git a/library/alloc/src/sync.rs b/library/alloc/src/sync.rs
index a466b74944c5d..eddc9047f21b8 100644
--- a/library/alloc/src/sync.rs
+++ b/library/alloc/src/sync.rs
@@ -9,6 +9,7 @@
 //! `#[cfg(target_has_atomic = "ptr")]`.
 
 use core::any::Any;
+use core::cell::CloneFromCell;
 #[cfg(not(no_global_oom_handling))]
 use core::clone::CloneToUninit;
 use core::clone::UseCloned;
@@ -281,6 +282,10 @@ impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Arc<U, A>> fo
 #[unstable(feature = "dispatch_from_dyn", issue = "none")]
 impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Arc<U>> for Arc<T> {}
 
+// SAFETY: `Arc::clone` doesn't access any `Cell`s which could contain the `Arc` being cloned.
+#[unstable(feature = "cell_get_cloned", issue = "145329")]
+unsafe impl<T: ?Sized> CloneFromCell for Arc<T> {}
+
 impl<T: ?Sized> Arc<T> {
     unsafe fn from_inner(ptr: NonNull<ArcInner<T>>) -> Self {
         unsafe { Self::from_inner_in(ptr, Global) }
@@ -356,6 +361,10 @@ impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Weak<U, A>> f
 #[unstable(feature = "dispatch_from_dyn", issue = "none")]
 impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Weak<U>> for Weak<T> {}
 
+// SAFETY: `Weak::clone` doesn't access any `Cell`s which could contain the `Weak` being cloned.
+#[unstable(feature = "cell_get_cloned", issue = "145329")]
+unsafe impl<T: ?Sized> CloneFromCell for Weak<T> {}
+
 #[stable(feature = "arc_weak", since = "1.4.0")]
 impl<T: ?Sized, A: Allocator> fmt::Debug for Weak<T, A> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
diff --git a/library/core/src/cell.rs b/library/core/src/cell.rs
index 7d4a66640b106..a991bbf46b1f2 100644
--- a/library/core/src/cell.rs
+++ b/library/core/src/cell.rs
@@ -253,11 +253,12 @@
 use crate::cmp::Ordering;
 use crate::fmt::{self, Debug, Display};
 use crate::marker::{PhantomData, Unsize};
-use crate::mem;
-use crate::ops::{CoerceUnsized, Deref, DerefMut, DerefPure, DispatchFromDyn};
+use crate::mem::{self, ManuallyDrop};
+use crate::ops::{self, CoerceUnsized, Deref, DerefMut, DerefPure, DispatchFromDyn};
 use crate::panic::const_panic;
 use crate::pin::PinCoerceUnsized;
 use crate::ptr::{self, NonNull};
+use crate::range;
 
 mod lazy;
 mod once;
@@ -713,6 +714,93 @@ impl<T, const N: usize> Cell<[T; N]> {
     }
 }
 
+/// Types for which cloning `Cell<Self>` is sound.
+///
+/// # Safety
+///
+/// Implementing this trait for a type is sound if and only if the following code is sound for T =
+/// that type.
+///
+/// ```
+/// #![feature(cell_get_cloned)]
+/// # use std::cell::{CloneFromCell, Cell};
+/// fn clone_from_cell<T: CloneFromCell>(cell: &Cell<T>) -> T {
+///     unsafe { T::clone(&*cell.as_ptr()) }
+/// }
+/// ```
+///
+/// Importantly, you can't just implement `CloneFromCell` for any arbitrary `Copy` type, e.g. the
+/// following is unsound:
+///
+/// ```rust
+/// #![feature(cell_get_cloned)]
+/// # use std::cell::Cell;
+///
+/// #[derive(Copy, Debug)]
+/// pub struct Bad<'a>(Option<&'a Cell<Bad<'a>>>, u8);
+///
+/// impl Clone for Bad<'_> {
+///     fn clone(&self) -> Self {
+///         let a: &u8 = &self.1;
+///         // when self.0 points to self, we write to self.1 while we have a live `&u8` pointing to
+///         // it -- this is UB
+///         self.0.unwrap().set(Self(None, 1));
+///         dbg!((a, self));
+///         Self(None, 0)
+///     }
+/// }
+///
+/// // this is not sound
+/// // unsafe impl CloneFromCell for Bad<'_> {}
+/// ```
+#[unstable(feature = "cell_get_cloned", issue = "145329")]
+// Allow potential overlapping implementations in user code
+#[marker]
+pub unsafe trait CloneFromCell: Clone {}
+
+// `CloneFromCell` can be implemented for types that don't have indirection and which don't access
+// `Cell`s in their `Clone` implementation. A commonly-used subset is covered here.
+#[unstable(feature = "cell_get_cloned", issue = "145329")]
+unsafe impl<T: CloneFromCell, const N: usize> CloneFromCell for [T; N] {}
+#[unstable(feature = "cell_get_cloned", issue = "145329")]
+unsafe impl<T: CloneFromCell> CloneFromCell for Option<T> {}
+#[unstable(feature = "cell_get_cloned", issue = "145329")]
+unsafe impl<T: CloneFromCell, E: CloneFromCell> CloneFromCell for Result<T, E> {}
+#[unstable(feature = "cell_get_cloned", issue = "145329")]
+unsafe impl<T: ?Sized> CloneFromCell for PhantomData<T> {}
+#[unstable(feature = "cell_get_cloned", issue = "145329")]
+unsafe impl<T: CloneFromCell> CloneFromCell for ManuallyDrop<T> {}
+#[unstable(feature = "cell_get_cloned", issue = "145329")]
+unsafe impl<T: CloneFromCell> CloneFromCell for ops::Range<T> {}
+#[unstable(feature = "cell_get_cloned", issue = "145329")]
+unsafe impl<T: CloneFromCell> CloneFromCell for range::Range<T> {}
+
+#[unstable(feature = "cell_get_cloned", issue = "145329")]
+impl<T: CloneFromCell> Cell<T> {
+    /// Get a clone of the `Cell` that contains a copy of the original value.
+    ///
+    /// This allows a cheaply `Clone`-able type like an `Rc` to be stored in a `Cell`, exposing the
+    /// cheaper `clone()` method.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(cell_get_cloned)]
+    ///
+    /// use core::cell::Cell;
+    /// use std::rc::Rc;
+    ///
+    /// let rc = Rc::new(1usize);
+    /// let c1 = Cell::new(rc);
+    /// let c2 = c1.get_cloned();
+    /// assert_eq!(*c2.into_inner(), 1);
+    /// ```
+    pub fn get_cloned(&self) -> Self {
+        // SAFETY: T is CloneFromCell, which guarantees that this is sound.
+        Cell::new(T::clone(unsafe { &*self.as_ptr() }))
+    }
+}
+
 /// A mutable memory location with dynamically checked borrow rules
 ///
 /// See the [module-level documentation](self) for more.
diff --git a/library/core/src/tuple.rs b/library/core/src/tuple.rs
index c57a8d81ade18..58f81372aff75 100644
--- a/library/core/src/tuple.rs
+++ b/library/core/src/tuple.rs
@@ -1,5 +1,6 @@
 // See core/src/primitive_docs.rs for documentation.
 
+use crate::cell::CloneFromCell;
 use crate::cmp::Ordering::{self, *};
 use crate::marker::{ConstParamTy_, StructuralPartialEq};
 use crate::ops::ControlFlow::{self, Break, Continue};
@@ -155,6 +156,15 @@ macro_rules! tuple_impls {
                 }
             }
         }
+
+        maybe_tuple_doc! {
+            $($T)+ @
+            // SAFETY: tuples introduce no additional indirection, so they can be copied whenever T
+            // can.
+            #[unstable(feature = "cell_get_cloned", issue = "145329")]
+            unsafe impl<$($T: CloneFromCell),+> CloneFromCell for ($($T,)+)
+            {}
+        }
     }
 }
 

From 30d57abccf7d55e9dd4e36be583c55f6b0090302 Mon Sep 17 00:00:00 2001
From: Josh Triplett <josh@joshtriplett.org>
Date: Sun, 14 Sep 2025 14:32:56 +0800
Subject: [PATCH 1643/1889] mbe: Rename a local variable to match corresponding
 field names

This simplifies subsequent initialization of enum variants.
---
 compiler/rustc_expand/src/mbe/macro_rules.rs | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/compiler/rustc_expand/src/mbe/macro_rules.rs b/compiler/rustc_expand/src/mbe/macro_rules.rs
index d4504ba720e46..8ed46a9fe9f67 100644
--- a/compiler/rustc_expand/src/mbe/macro_rules.rs
+++ b/compiler/rustc_expand/src/mbe/macro_rules.rs
@@ -741,10 +741,10 @@ pub fn compile_declarative_macro(
         if let Some(guar) = check_no_eof(sess, &p, "expected right-hand side of macro rule") {
             return dummy_syn_ext(guar);
         }
-        let rhs_tt = p.parse_token_tree();
-        let rhs_tt = parse_one_tt(rhs_tt, RulePart::Body, sess, node_id, features, edition);
-        check_emission(check_rhs(sess, &rhs_tt));
-        check_emission(check_meta_variables(&sess.psess, node_id, args.as_ref(), &lhs_tt, &rhs_tt));
+        let rhs = p.parse_token_tree();
+        let rhs = parse_one_tt(rhs, RulePart::Body, sess, node_id, features, edition);
+        check_emission(check_rhs(sess, &rhs));
+        check_emission(check_meta_variables(&sess.psess, node_id, args.as_ref(), &lhs_tt, &rhs));
         let lhs_span = lhs_tt.span();
         // Convert the lhs into `MatcherLoc` form, which is better for doing the
         // actual matching.
@@ -760,11 +760,11 @@ pub fn compile_declarative_macro(
             };
             let args = mbe::macro_parser::compute_locs(&delimited.tts);
             let body_span = lhs_span;
-            rules.push(MacroRule::Attr { args, args_span, body: lhs, body_span, rhs: rhs_tt });
+            rules.push(MacroRule::Attr { args, args_span, body: lhs, body_span, rhs });
         } else if is_derive {
-            rules.push(MacroRule::Derive { body: lhs, body_span: lhs_span, rhs: rhs_tt });
+            rules.push(MacroRule::Derive { body: lhs, body_span: lhs_span, rhs });
         } else {
-            rules.push(MacroRule::Func { lhs, lhs_span, rhs: rhs_tt });
+            rules.push(MacroRule::Func { lhs, lhs_span, rhs });
         }
         if p.token == token::Eof {
             break;

From 6bff1abf9d3c171d2380aacb8b4c6f52580192b3 Mon Sep 17 00:00:00 2001
From: Josh Triplett <josh@joshtriplett.org>
Date: Sun, 14 Sep 2025 16:17:51 +0800
Subject: [PATCH 1644/1889] mbe: Support `unsafe` attribute rules

---
 .../rustc_attr_parsing/src/validate_attr.rs   | 12 ++---
 compiler/rustc_expand/src/base.rs             | 17 ++++++-
 compiler/rustc_expand/src/expand.rs           |  6 ++-
 compiler/rustc_expand/src/mbe/macro_rules.rs  | 46 +++++++++++++++++--
 .../unsafe/double-unsafe-attributes.rs        |  2 +-
 .../unsafe/double-unsafe-attributes.stderr    |  6 +--
 .../unsafe-safe-attribute_diagnostic.rs       |  2 +-
 .../unsafe-safe-attribute_diagnostic.stderr   |  6 +--
 8 files changed, 75 insertions(+), 22 deletions(-)

diff --git a/compiler/rustc_attr_parsing/src/validate_attr.rs b/compiler/rustc_attr_parsing/src/validate_attr.rs
index 7a7624893bd21..927417f89f8c0 100644
--- a/compiler/rustc_attr_parsing/src/validate_attr.rs
+++ b/compiler/rustc_attr_parsing/src/validate_attr.rs
@@ -207,10 +207,9 @@ pub fn check_attribute_safety(
             }
         }
 
-        // - Normal builtin attribute, or any non-builtin attribute
-        // - All non-builtin attributes are currently considered safe; writing `#[unsafe(..)]` is
-        //   not permitted on non-builtin attributes or normal builtin attributes
-        (Some(AttributeSafety::Normal) | None, Safety::Unsafe(unsafe_span)) => {
+        // - Normal builtin attribute
+        // - Writing `#[unsafe(..)]` is not permitted on normal builtin attributes
+        (Some(AttributeSafety::Normal), Safety::Unsafe(unsafe_span)) => {
             psess.dcx().emit_err(errors::InvalidAttrUnsafe {
                 span: unsafe_span,
                 name: attr_item.path.clone(),
@@ -224,9 +223,8 @@ pub fn check_attribute_safety(
         }
 
         // - Non-builtin attribute
-        // - No explicit `#[unsafe(..)]` written.
-        (None, Safety::Default) => {
-            // OK
+        (None, Safety::Unsafe(_) | Safety::Default) => {
+            // OK (not checked here)
         }
 
         (
diff --git a/compiler/rustc_expand/src/base.rs b/compiler/rustc_expand/src/base.rs
index 33b712e3aedfc..810a5a21a055b 100644
--- a/compiler/rustc_expand/src/base.rs
+++ b/compiler/rustc_expand/src/base.rs
@@ -10,7 +10,7 @@ use rustc_ast::attr::{AttributeExt, MarkedAttrs};
 use rustc_ast::token::MetaVarKind;
 use rustc_ast::tokenstream::TokenStream;
 use rustc_ast::visit::{AssocCtxt, Visitor};
-use rustc_ast::{self as ast, AttrVec, Attribute, HasAttrs, Item, NodeId, PatKind};
+use rustc_ast::{self as ast, AttrVec, Attribute, HasAttrs, Item, NodeId, PatKind, Safety};
 use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
 use rustc_data_structures::sync;
 use rustc_errors::{BufferedEarlyLint, DiagCtxtHandle, ErrorGuaranteed, PResult};
@@ -345,6 +345,21 @@ pub trait AttrProcMacro {
         annotation: TokenStream,
         annotated: TokenStream,
     ) -> Result<TokenStream, ErrorGuaranteed>;
+
+    // Default implementation for safe attributes; override if the attribute can be unsafe.
+    fn expand_with_safety<'cx>(
+        &self,
+        ecx: &'cx mut ExtCtxt<'_>,
+        safety: Safety,
+        span: Span,
+        annotation: TokenStream,
+        annotated: TokenStream,
+    ) -> Result<TokenStream, ErrorGuaranteed> {
+        if let Safety::Unsafe(span) = safety {
+            ecx.dcx().span_err(span, "unnecessary `unsafe` on safe attribute");
+        }
+        self.expand(ecx, span, annotation, annotated)
+    }
 }
 
 impl<F> AttrProcMacro for F
diff --git a/compiler/rustc_expand/src/expand.rs b/compiler/rustc_expand/src/expand.rs
index 172bc3d1d9f86..a035896d5542c 100644
--- a/compiler/rustc_expand/src/expand.rs
+++ b/compiler/rustc_expand/src/expand.rs
@@ -812,11 +812,12 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
                         _ => item.to_tokens(),
                     };
                     let attr_item = attr.get_normal_item();
+                    let safety = attr_item.unsafety;
                     if let AttrArgs::Eq { .. } = attr_item.args {
                         self.cx.dcx().emit_err(UnsupportedKeyValue { span });
                     }
                     let inner_tokens = attr_item.args.inner_tokens();
-                    match expander.expand(self.cx, span, inner_tokens, tokens) {
+                    match expander.expand_with_safety(self.cx, safety, span, inner_tokens, tokens) {
                         Ok(tok_result) => {
                             let fragment = self.parse_ast_fragment(
                                 tok_result,
@@ -882,6 +883,9 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
                         }
                     }
                 } else if let SyntaxExtensionKind::NonMacroAttr = ext {
+                    if let ast::Safety::Unsafe(span) = attr.get_normal_item().unsafety {
+                        self.cx.dcx().span_err(span, "unnecessary `unsafe` on safe attribute");
+                    }
                     // `-Zmacro-stats` ignores these because they don't do any real expansion.
                     self.cx.expanded_inert_attrs.mark(&attr);
                     item.visit_attrs(|attrs| attrs.insert(pos, attr));
diff --git a/compiler/rustc_expand/src/mbe/macro_rules.rs b/compiler/rustc_expand/src/mbe/macro_rules.rs
index 8ed46a9fe9f67..c548cea537f40 100644
--- a/compiler/rustc_expand/src/mbe/macro_rules.rs
+++ b/compiler/rustc_expand/src/mbe/macro_rules.rs
@@ -8,7 +8,7 @@ use rustc_ast::token::NtPatKind::*;
 use rustc_ast::token::TokenKind::*;
 use rustc_ast::token::{self, Delimiter, NonterminalKind, Token, TokenKind};
 use rustc_ast::tokenstream::{self, DelimSpan, TokenStream};
-use rustc_ast::{self as ast, DUMMY_NODE_ID, NodeId};
+use rustc_ast::{self as ast, DUMMY_NODE_ID, NodeId, Safety};
 use rustc_ast_pretty::pprust;
 use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
 use rustc_errors::{Applicability, Diag, ErrorGuaranteed, MultiSpan};
@@ -131,6 +131,7 @@ pub(super) enum MacroRule {
     Func { lhs: Vec<MatcherLoc>, lhs_span: Span, rhs: mbe::TokenTree },
     /// An attr rule, for use with `#[m]`
     Attr {
+        unsafe_rule: bool,
         args: Vec<MatcherLoc>,
         args_span: Span,
         body: Vec<MatcherLoc>,
@@ -247,8 +248,19 @@ impl TTMacroExpander for MacroRulesMacroExpander {
 
 impl AttrProcMacro for MacroRulesMacroExpander {
     fn expand(
+        &self,
+        _cx: &mut ExtCtxt<'_>,
+        _sp: Span,
+        _args: TokenStream,
+        _body: TokenStream,
+    ) -> Result<TokenStream, ErrorGuaranteed> {
+        unreachable!("`expand` called on `MacroRulesMacroExpander`, expected `expand_with_safety`")
+    }
+
+    fn expand_with_safety(
         &self,
         cx: &mut ExtCtxt<'_>,
+        safety: Safety,
         sp: Span,
         args: TokenStream,
         body: TokenStream,
@@ -260,6 +272,7 @@ impl AttrProcMacro for MacroRulesMacroExpander {
             self.node_id,
             self.name,
             self.transparency,
+            safety,
             args,
             body,
             &self.rules,
@@ -408,6 +421,7 @@ fn expand_macro_attr(
     node_id: NodeId,
     name: Ident,
     transparency: Transparency,
+    safety: Safety,
     args: TokenStream,
     body: TokenStream,
     rules: &[MacroRule],
@@ -429,13 +443,26 @@ fn expand_macro_attr(
     // Track nothing for the best performance.
     match try_match_macro_attr(psess, name, &args, &body, rules, &mut NoopTracker) {
         Ok((i, rule, named_matches)) => {
-            let MacroRule::Attr { rhs, .. } = rule else {
+            let MacroRule::Attr { rhs, unsafe_rule, .. } = rule else {
                 panic!("try_macro_match_attr returned non-attr rule");
             };
             let mbe::TokenTree::Delimited(rhs_span, _, rhs) = rhs else {
                 cx.dcx().span_bug(sp, "malformed macro rhs");
             };
 
+            match (safety, unsafe_rule) {
+                (Safety::Default, false) | (Safety::Unsafe(_), true) => {}
+                (Safety::Default, true) => {
+                    cx.dcx().span_err(sp, "unsafe attribute invocation requires `unsafe`");
+                }
+                (Safety::Unsafe(span), false) => {
+                    cx.dcx().span_err(span, "unnecessary `unsafe` on safe attribute invocation");
+                }
+                (Safety::Safe(span), _) => {
+                    cx.dcx().span_bug(span, "unexpected `safe` keyword");
+                }
+            }
+
             let id = cx.current_expansion.id;
             let tts = transcribe(psess, &named_matches, rhs, *rhs_span, transparency, id)
                 .map_err(|e| e.emit())?;
@@ -681,6 +708,11 @@ pub fn compile_declarative_macro(
     let mut rules = Vec::new();
 
     while p.token != token::Eof {
+        let unsafe_rule = p.eat_keyword_noexpect(kw::Unsafe);
+        let unsafe_keyword_span = p.prev_token.span;
+        if unsafe_rule && let Some(guar) = check_no_eof(sess, &p, "expected `attr`") {
+            return dummy_syn_ext(guar);
+        }
         let (args, is_derive) = if p.eat_keyword_noexpect(sym::attr) {
             kinds |= MacroKinds::ATTR;
             if !features.macro_attr() {
@@ -705,6 +737,10 @@ pub fn compile_declarative_macro(
                 feature_err(sess, sym::macro_derive, span, "`macro_rules!` derives are unstable")
                     .emit();
             }
+            if unsafe_rule {
+                sess.dcx()
+                    .span_err(unsafe_keyword_span, "`unsafe` is only supported on `attr` rules");
+            }
             if let Some(guar) = check_no_eof(sess, &p, "expected `()` after `derive`") {
                 return dummy_syn_ext(guar);
             }
@@ -730,6 +766,10 @@ pub fn compile_declarative_macro(
             (None, true)
         } else {
             kinds |= MacroKinds::BANG;
+            if unsafe_rule {
+                sess.dcx()
+                    .span_err(unsafe_keyword_span, "`unsafe` is only supported on `attr` rules");
+            }
             (None, false)
         };
         let lhs_tt = p.parse_token_tree();
@@ -760,7 +800,7 @@ pub fn compile_declarative_macro(
             };
             let args = mbe::macro_parser::compute_locs(&delimited.tts);
             let body_span = lhs_span;
-            rules.push(MacroRule::Attr { args, args_span, body: lhs, body_span, rhs });
+            rules.push(MacroRule::Attr { unsafe_rule, args, args_span, body: lhs, body_span, rhs });
         } else if is_derive {
             rules.push(MacroRule::Derive { body: lhs, body_span: lhs_span, rhs });
         } else {
diff --git a/tests/ui/attributes/unsafe/double-unsafe-attributes.rs b/tests/ui/attributes/unsafe/double-unsafe-attributes.rs
index 894d1327da799..c0181d960539c 100644
--- a/tests/ui/attributes/unsafe/double-unsafe-attributes.rs
+++ b/tests/ui/attributes/unsafe/double-unsafe-attributes.rs
@@ -1,7 +1,7 @@
 #[unsafe(unsafe(no_mangle))]
 //~^ ERROR expected identifier, found keyword `unsafe`
 //~| ERROR cannot find attribute `r#unsafe` in this scope
-//~| ERROR `r#unsafe` is not an unsafe attribute
+//~| ERROR unnecessary `unsafe`
 fn a() {}
 
 fn main() {}
diff --git a/tests/ui/attributes/unsafe/double-unsafe-attributes.stderr b/tests/ui/attributes/unsafe/double-unsafe-attributes.stderr
index 0825cf794083d..846800daa5465 100644
--- a/tests/ui/attributes/unsafe/double-unsafe-attributes.stderr
+++ b/tests/ui/attributes/unsafe/double-unsafe-attributes.stderr
@@ -9,13 +9,11 @@ help: escape `unsafe` to use it as an identifier
 LL | #[unsafe(r#unsafe(no_mangle))]
    |          ++
 
-error: `r#unsafe` is not an unsafe attribute
+error: unnecessary `unsafe` on safe attribute
   --> $DIR/double-unsafe-attributes.rs:1:3
    |
 LL | #[unsafe(unsafe(no_mangle))]
-   |   ^^^^^^ this is not an unsafe attribute
-   |
-   = note: extraneous unsafe is not allowed in attributes
+   |   ^^^^^^
 
 error: cannot find attribute `r#unsafe` in this scope
   --> $DIR/double-unsafe-attributes.rs:1:10
diff --git a/tests/ui/attributes/unsafe/unsafe-safe-attribute_diagnostic.rs b/tests/ui/attributes/unsafe/unsafe-safe-attribute_diagnostic.rs
index 0f241cc439f34..d9054248a292c 100644
--- a/tests/ui/attributes/unsafe/unsafe-safe-attribute_diagnostic.rs
+++ b/tests/ui/attributes/unsafe/unsafe-safe-attribute_diagnostic.rs
@@ -1,4 +1,4 @@
-#[unsafe(diagnostic::on_unimplemented( //~ ERROR: is not an unsafe attribute
+#[unsafe(diagnostic::on_unimplemented( //~ ERROR: unnecessary `unsafe`
     message = "testing",
 ))]
 trait Foo {}
diff --git a/tests/ui/attributes/unsafe/unsafe-safe-attribute_diagnostic.stderr b/tests/ui/attributes/unsafe/unsafe-safe-attribute_diagnostic.stderr
index 3bc291db5acf8..a7662f5ee6c7d 100644
--- a/tests/ui/attributes/unsafe/unsafe-safe-attribute_diagnostic.stderr
+++ b/tests/ui/attributes/unsafe/unsafe-safe-attribute_diagnostic.stderr
@@ -1,10 +1,8 @@
-error: `diagnostic::on_unimplemented` is not an unsafe attribute
+error: unnecessary `unsafe` on safe attribute
   --> $DIR/unsafe-safe-attribute_diagnostic.rs:1:3
    |
 LL | #[unsafe(diagnostic::on_unimplemented(
-   |   ^^^^^^ this is not an unsafe attribute
-   |
-   = note: extraneous unsafe is not allowed in attributes
+   |   ^^^^^^
 
 error: aborting due to 1 previous error
 

From 05c5b8779704e20620e18c822a18f28e4961e86e Mon Sep 17 00:00:00 2001
From: Josh Triplett <josh@joshtriplett.org>
Date: Sun, 14 Sep 2025 16:23:39 +0800
Subject: [PATCH 1645/1889] mbe: Add parsing tests for `unsafe` macro rules

---
 tests/ui/parser/macro/bad-macro-definition.rs |  3 +++
 .../parser/macro/bad-macro-definition.stderr  |  8 +++++-
 tests/ui/parser/macro/macro-attr-bad.rs       |  6 +++++
 tests/ui/parser/macro/macro-attr-bad.stderr   | 26 ++++++++++++++-----
 tests/ui/parser/macro/macro-derive-bad.rs     |  3 +++
 tests/ui/parser/macro/macro-derive-bad.stderr |  8 +++++-
 6 files changed, 45 insertions(+), 9 deletions(-)

diff --git a/tests/ui/parser/macro/bad-macro-definition.rs b/tests/ui/parser/macro/bad-macro-definition.rs
index 3c5c93ea3b3e4..12df6e64bd2ca 100644
--- a/tests/ui/parser/macro/bad-macro-definition.rs
+++ b/tests/ui/parser/macro/bad-macro-definition.rs
@@ -20,3 +20,6 @@ macro_rules! e { {} }
 
 macro_rules! f {}
 //~^ ERROR: macros must contain at least one rule
+
+macro_rules! g { unsafe {} => {} }
+//~^ ERROR: `unsafe` is only supported on `attr` rules
diff --git a/tests/ui/parser/macro/bad-macro-definition.stderr b/tests/ui/parser/macro/bad-macro-definition.stderr
index de6d9d6a38b15..d15f33f708ded 100644
--- a/tests/ui/parser/macro/bad-macro-definition.stderr
+++ b/tests/ui/parser/macro/bad-macro-definition.stderr
@@ -52,5 +52,11 @@ error: macros must contain at least one rule
 LL | macro_rules! f {}
    | ^^^^^^^^^^^^^^^^^
 
-error: aborting due to 9 previous errors
+error: `unsafe` is only supported on `attr` rules
+  --> $DIR/bad-macro-definition.rs:24:18
+   |
+LL | macro_rules! g { unsafe {} => {} }
+   |                  ^^^^^^
+
+error: aborting due to 10 previous errors
 
diff --git a/tests/ui/parser/macro/macro-attr-bad.rs b/tests/ui/parser/macro/macro-attr-bad.rs
index 9f50b057a7a49..0ac46c8b76812 100644
--- a/tests/ui/parser/macro/macro-attr-bad.rs
+++ b/tests/ui/parser/macro/macro-attr-bad.rs
@@ -13,6 +13,12 @@ macro_rules! attr_incomplete_3 { attr() {} }
 macro_rules! attr_incomplete_4 { attr() {} => }
 //~^ ERROR macro definition ended unexpectedly
 
+macro_rules! attr_incomplete_5 { unsafe }
+//~^ ERROR macro definition ended unexpectedly
+
+macro_rules! attr_incomplete_6 { unsafe attr }
+//~^ ERROR macro definition ended unexpectedly
+
 macro_rules! attr_noparens_1 { attr{} {} => {} }
 //~^ ERROR `attr` rule argument matchers require parentheses
 
diff --git a/tests/ui/parser/macro/macro-attr-bad.stderr b/tests/ui/parser/macro/macro-attr-bad.stderr
index bf0ed13cd553f..481ef8118aebb 100644
--- a/tests/ui/parser/macro/macro-attr-bad.stderr
+++ b/tests/ui/parser/macro/macro-attr-bad.stderr
@@ -22,8 +22,20 @@ error: macro definition ended unexpectedly
 LL | macro_rules! attr_incomplete_4 { attr() {} => }
    |                                              ^ expected right-hand side of macro rule
 
+error: macro definition ended unexpectedly
+  --> $DIR/macro-attr-bad.rs:16:40
+   |
+LL | macro_rules! attr_incomplete_5 { unsafe }
+   |                                        ^ expected `attr`
+
+error: macro definition ended unexpectedly
+  --> $DIR/macro-attr-bad.rs:19:45
+   |
+LL | macro_rules! attr_incomplete_6 { unsafe attr }
+   |                                             ^ expected macro attr args
+
 error: `attr` rule argument matchers require parentheses
-  --> $DIR/macro-attr-bad.rs:16:36
+  --> $DIR/macro-attr-bad.rs:22:36
    |
 LL | macro_rules! attr_noparens_1 { attr{} {} => {} }
    |                                    ^^
@@ -35,7 +47,7 @@ LL + macro_rules! attr_noparens_1 { attr() {} => {} }
    |
 
 error: `attr` rule argument matchers require parentheses
-  --> $DIR/macro-attr-bad.rs:19:36
+  --> $DIR/macro-attr-bad.rs:25:36
    |
 LL | macro_rules! attr_noparens_2 { attr[] {} => {} }
    |                                    ^^
@@ -47,13 +59,13 @@ LL + macro_rules! attr_noparens_2 { attr() {} => {} }
    |
 
 error: invalid macro matcher; matchers must be contained in balanced delimiters
-  --> $DIR/macro-attr-bad.rs:22:37
+  --> $DIR/macro-attr-bad.rs:28:37
    |
 LL | macro_rules! attr_noparens_3 { attr _ {} => {} }
    |                                     ^
 
 error: duplicate matcher binding
-  --> $DIR/macro-attr-bad.rs:25:52
+  --> $DIR/macro-attr-bad.rs:31:52
    |
 LL | macro_rules! attr_dup_matcher_1 { attr() {$x:ident $x:ident} => {} }
    |                                           -------- ^^^^^^^^ duplicate binding
@@ -61,7 +73,7 @@ LL | macro_rules! attr_dup_matcher_1 { attr() {$x:ident $x:ident} => {} }
    |                                           previous binding
 
 error: duplicate matcher binding
-  --> $DIR/macro-attr-bad.rs:28:49
+  --> $DIR/macro-attr-bad.rs:34:49
    |
 LL | macro_rules! attr_dup_matcher_2 { attr($x:ident $x:ident) {} => {} }
    |                                        -------- ^^^^^^^^ duplicate binding
@@ -69,12 +81,12 @@ LL | macro_rules! attr_dup_matcher_2 { attr($x:ident $x:ident) {} => {} }
    |                                        previous binding
 
 error: duplicate matcher binding
-  --> $DIR/macro-attr-bad.rs:31:51
+  --> $DIR/macro-attr-bad.rs:37:51
    |
 LL | macro_rules! attr_dup_matcher_3 { attr($x:ident) {$x:ident} => {} }
    |                                        --------   ^^^^^^^^ duplicate binding
    |                                        |
    |                                        previous binding
 
-error: aborting due to 10 previous errors
+error: aborting due to 12 previous errors
 
diff --git a/tests/ui/parser/macro/macro-derive-bad.rs b/tests/ui/parser/macro/macro-derive-bad.rs
index 79b9eb8c113ca..74e7d9acdafc3 100644
--- a/tests/ui/parser/macro/macro-derive-bad.rs
+++ b/tests/ui/parser/macro/macro-derive-bad.rs
@@ -41,3 +41,6 @@ macro_rules! derive_dup_matcher { derive() {$x:ident $x:ident} => {} }
 //~^ ERROR duplicate matcher binding
 //~| NOTE duplicate binding
 //~| NOTE previous binding
+
+macro_rules! derive_unsafe { unsafe derive() {} => {} }
+//~^ ERROR `unsafe` is only supported on `attr` rules
diff --git a/tests/ui/parser/macro/macro-derive-bad.stderr b/tests/ui/parser/macro/macro-derive-bad.stderr
index ec750c9ac8220..c98535f4031f3 100644
--- a/tests/ui/parser/macro/macro-derive-bad.stderr
+++ b/tests/ui/parser/macro/macro-derive-bad.stderr
@@ -86,5 +86,11 @@ LL | macro_rules! derive_dup_matcher { derive() {$x:ident $x:ident} => {} }
    |                                             |
    |                                             previous binding
 
-error: aborting due to 12 previous errors
+error: `unsafe` is only supported on `attr` rules
+  --> $DIR/macro-derive-bad.rs:45:30
+   |
+LL | macro_rules! derive_unsafe { unsafe derive() {} => {} }
+   |                              ^^^^^^
+
+error: aborting due to 13 previous errors
 

From ea0e00c5738f56970ad3ed3cc3d27c19715cd9ea Mon Sep 17 00:00:00 2001
From: Josh Triplett <josh@joshtriplett.org>
Date: Sun, 14 Sep 2025 16:28:50 +0800
Subject: [PATCH 1646/1889] mbe: Add tests for `unsafe` attr invocation

---
 tests/ui/macros/macro-rules-attr-error.rs     | 19 +++++++++++++++++++
 tests/ui/macros/macro-rules-attr-error.stderr | 14 +++++++++++++-
 2 files changed, 32 insertions(+), 1 deletion(-)

diff --git a/tests/ui/macros/macro-rules-attr-error.rs b/tests/ui/macros/macro-rules-attr-error.rs
index 81eadb6692f22..60290b883cb86 100644
--- a/tests/ui/macros/macro-rules-attr-error.rs
+++ b/tests/ui/macros/macro-rules-attr-error.rs
@@ -50,3 +50,22 @@ macro_rules! forward_referenced_attr {
 macro_rules! cyclic_attr {
     attr() {} => {}
 }
+
+macro_rules! attr_with_safety {
+    unsafe attr() { struct RequiresUnsafe; } => {};
+    attr() { struct SafeInvocation; } => {};
+}
+
+#[attr_with_safety]
+struct SafeInvocation;
+
+//~v ERROR: unnecessary `unsafe` on safe attribute invocation
+#[unsafe(attr_with_safety)]
+struct SafeInvocation;
+
+//~v ERROR: unsafe attribute invocation requires `unsafe`
+#[attr_with_safety]
+struct RequiresUnsafe;
+
+#[unsafe(attr_with_safety)]
+struct RequiresUnsafe;
diff --git a/tests/ui/macros/macro-rules-attr-error.stderr b/tests/ui/macros/macro-rules-attr-error.stderr
index 674d35091b68d..27527a2da7ef2 100644
--- a/tests/ui/macros/macro-rules-attr-error.stderr
+++ b/tests/ui/macros/macro-rules-attr-error.stderr
@@ -9,6 +9,18 @@ LL |     #[local_attr]
    |
    = note: this error originates in the attribute macro `local_attr` (in Nightly builds, run with -Z macro-backtrace for more info)
 
+error: unnecessary `unsafe` on safe attribute invocation
+  --> $DIR/macro-rules-attr-error.rs:63:3
+   |
+LL | #[unsafe(attr_with_safety)]
+   |   ^^^^^^
+
+error: unsafe attribute invocation requires `unsafe`
+  --> $DIR/macro-rules-attr-error.rs:67:1
+   |
+LL | #[attr_with_safety]
+   | ^^^^^^^^^^^^^^^^^^^
+
 error: cannot find macro `local_attr` in this scope
   --> $DIR/macro-rules-attr-error.rs:27:5
    |
@@ -59,5 +71,5 @@ note: a macro with the same name exists, but it appears later
 LL | macro_rules! cyclic_attr {
    |              ^^^^^^^^^^^
 
-error: aborting due to 6 previous errors
+error: aborting due to 8 previous errors
 

From 4fc0a0d42a66e9b248fa527f7f063ec7226803dd Mon Sep 17 00:00:00 2001
From: Josh Triplett <josh@joshtriplett.org>
Date: Sun, 28 Sep 2025 09:15:02 -0700
Subject: [PATCH 1647/1889] mbe: `expand_invoc`: Add comment about not needing
 to check safety of `LegacyAttr` here

`LegacyAttr` is only used for builtin attributes, and builtin attributes
have their safety checked by `check_attribute_safety`, so we don't need
to check `unsafety` here.
---
 compiler/rustc_expand/src/expand.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/compiler/rustc_expand/src/expand.rs b/compiler/rustc_expand/src/expand.rs
index a035896d5542c..3dfa3cdcc3560 100644
--- a/compiler/rustc_expand/src/expand.rs
+++ b/compiler/rustc_expand/src/expand.rs
@@ -841,6 +841,9 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
                         Err(guar) => return ExpandResult::Ready(fragment_kind.dummy(span, guar)),
                     }
                 } else if let SyntaxExtensionKind::LegacyAttr(expander) = ext {
+                    // `LegacyAttr` is only used for builtin attribute macros, which have their
+                    // safety checked by `check_builtin_meta_item`, so we don't need to check
+                    // `unsafety` here.
                     match validate_attr::parse_meta(&self.cx.sess.psess, &attr) {
                         Ok(meta) => {
                             let item_clone = macro_stats.then(|| item.clone());

From 3e26e2a3a9f047060d7c098c3c82a77d7c33c2aa Mon Sep 17 00:00:00 2001
From: Jynn Nelson <jynn.nelson@ferrous-systems.com>
Date: Wed, 24 Sep 2025 15:09:16 -0700
Subject: [PATCH 1648/1889] Don't unconditionally build alloc for `no-std`
 targets

It's possible for targets to only support `core` and not `alloc`.
Instead of building alloc unconditionally, pass a list of crates to
build into `std_cargo`, and only pass `-p alloc` if the list of crates
wasn't already filtered to a subset.

The original use case was to reuse `std_cargo` for a rustc_driver that
doesn't emit metadata. But this seems like a reasonable change
regardless.
---
 src/bootstrap/src/core/build_steps/check.rs   | 18 +++++------------
 src/bootstrap/src/core/build_steps/clippy.rs  |  6 +-----
 src/bootstrap/src/core/build_steps/compile.rs | 20 +++++++++++++------
 src/bootstrap/src/core/build_steps/doc.rs     |  6 +-----
 src/bootstrap/src/core/build_steps/test.rs    |  2 +-
 5 files changed, 22 insertions(+), 30 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/check.rs b/src/bootstrap/src/core/build_steps/check.rs
index 20c54a28dda83..d0edf6c90899c 100644
--- a/src/bootstrap/src/core/build_steps/check.rs
+++ b/src/bootstrap/src/core/build_steps/check.rs
@@ -61,6 +61,9 @@ impl Step for Std {
             return;
         }
 
+        // Explicitly pass -p for all dependencies crates -- this will force cargo
+        // to also check the tests/benches/examples for these crates, rather
+        // than just the leaf crate.
         let crates = std_crates_for_run_make(&run);
         run.builder.ensure(Std {
             build_compiler: prepare_compiler_for_check(run.builder, run.target, Mode::Std)
@@ -83,16 +86,12 @@ impl Step for Std {
             Kind::Check,
         );
 
-        std_cargo(builder, target, &mut cargo);
+        std_cargo(builder, target, &mut cargo, &self.crates);
         if matches!(builder.config.cmd, Subcommand::Fix) {
             // By default, cargo tries to fix all targets. Tell it not to fix tests until we've added `test` to the sysroot.
             cargo.arg("--lib");
         }
 
-        for krate in &*self.crates {
-            cargo.arg("-p").arg(krate);
-        }
-
         let _guard = builder.msg(
             Kind::Check,
             format_args!("library artifacts{}", crate_description(&self.crates)),
@@ -135,14 +134,7 @@ impl Step for Std {
             Kind::Check,
         );
 
-        std_cargo(builder, target, &mut cargo);
-
-        // Explicitly pass -p for all dependencies krates -- this will force cargo
-        // to also check the tests/benches/examples for these crates, rather
-        // than just the leaf crate.
-        for krate in &*self.crates {
-            cargo.arg("-p").arg(krate);
-        }
+        std_cargo(builder, target, &mut cargo, &self.crates);
 
         let stamp =
             build_stamp::libstd_stamp(builder, build_compiler, target).with_prefix("check-test");
diff --git a/src/bootstrap/src/core/build_steps/clippy.rs b/src/bootstrap/src/core/build_steps/clippy.rs
index d5b15d7908646..290a00aa3c13a 100644
--- a/src/bootstrap/src/core/build_steps/clippy.rs
+++ b/src/bootstrap/src/core/build_steps/clippy.rs
@@ -195,11 +195,7 @@ impl Step for Std {
             Kind::Clippy,
         );
 
-        std_cargo(builder, target, &mut cargo);
-
-        for krate in &*self.crates {
-            cargo.arg("-p").arg(krate);
-        }
+        std_cargo(builder, target, &mut cargo, &self.crates);
 
         let _guard = builder.msg(
             Kind::Clippy,
diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index 96b4e15433f7e..03046b1126beb 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -266,10 +266,7 @@ impl Step for Std {
                 target,
                 Kind::Build,
             );
-            std_cargo(builder, target, &mut cargo);
-            for krate in &*self.crates {
-                cargo.arg("-p").arg(krate);
-            }
+            std_cargo(builder, target, &mut cargo, &self.crates);
             cargo
         };
 
@@ -497,7 +494,12 @@ fn compiler_rt_for_profiler(builder: &Builder<'_>) -> PathBuf {
 
 /// Configure cargo to compile the standard library, adding appropriate env vars
 /// and such.
-pub fn std_cargo(builder: &Builder<'_>, target: TargetSelection, cargo: &mut Cargo) {
+pub fn std_cargo(
+    builder: &Builder<'_>,
+    target: TargetSelection,
+    cargo: &mut Cargo,
+    crates: &[String],
+) {
     // rustc already ensures that it builds with the minimum deployment
     // target, so ideally we shouldn't need to do anything here.
     //
@@ -605,6 +607,10 @@ pub fn std_cargo(builder: &Builder<'_>, target: TargetSelection, cargo: &mut Car
         cargo.env("CFG_DISABLE_UNSTABLE_FEATURES", "1");
     }
 
+    for krate in crates {
+        cargo.args(["-p", krate]);
+    }
+
     let mut features = String::new();
 
     if builder.no_std(target) == Some(true) {
@@ -614,8 +620,10 @@ pub fn std_cargo(builder: &Builder<'_>, target: TargetSelection, cargo: &mut Car
         }
 
         // for no-std targets we only compile a few no_std crates
+        if crates.is_empty() {
+            cargo.args(["-p", "alloc"]);
+        }
         cargo
-            .args(["-p", "alloc"])
             .arg("--manifest-path")
             .arg(builder.src.join("library/alloc/Cargo.toml"))
             .arg("--features")
diff --git a/src/bootstrap/src/core/build_steps/doc.rs b/src/bootstrap/src/core/build_steps/doc.rs
index 7865b68565930..7fb0fe17eb0cf 100644
--- a/src/bootstrap/src/core/build_steps/doc.rs
+++ b/src/bootstrap/src/core/build_steps/doc.rs
@@ -783,7 +783,7 @@ fn doc_std(
         Kind::Doc,
     );
 
-    compile::std_cargo(builder, target, &mut cargo);
+    compile::std_cargo(builder, target, &mut cargo, requested_crates);
     cargo
         .arg("--no-deps")
         .arg("--target-dir")
@@ -803,10 +803,6 @@ fn doc_std(
         cargo.rustdocflag("--document-private-items").rustdocflag("--document-hidden-items");
     }
 
-    for krate in requested_crates {
-        cargo.arg("-p").arg(krate);
-    }
-
     let description =
         format!("library{} in {} format", crate_description(requested_crates), format.as_str());
     let _guard = builder.msg(Kind::Doc, description, Mode::Std, build_compiler, target);
diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index 00aea8feab7de..2910de5e29ef7 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -2963,7 +2963,7 @@ impl Step for Crate {
                         .arg("--manifest-path")
                         .arg(builder.src.join("library/sysroot/Cargo.toml"));
                 } else {
-                    compile::std_cargo(builder, target, &mut cargo);
+                    compile::std_cargo(builder, target, &mut cargo, &[]);
                 }
             }
             Mode::Rustc => {

From 59c4dfe59d587f0f09746958bf9a16c271cc02a7 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 1 Oct 2025 21:45:50 +1000
Subject: [PATCH 1649/1889] Forbid `//@ compile-flags: -Cincremental=` in tests

Tests should not try to manually enable incremental compilation with
`-Cincremental`, because that typically results in stray directories being
created in the repository root.

Instead, use the `//@ incremental` directive, which instructs compiletest to
handle the details of passing `-Cincremental` with a fresh directory.
---
 src/tools/compiletest/src/directives.rs         | 10 +++++++++-
 .../compile-flags-incremental.rs                | 17 +++++++++++++++++
 2 files changed, 26 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/compiletest-self-test/compile-flags-incremental.rs

diff --git a/src/tools/compiletest/src/directives.rs b/src/tools/compiletest/src/directives.rs
index e6916610190e6..0d85e76c2cc09 100644
--- a/src/tools/compiletest/src/directives.rs
+++ b/src/tools/compiletest/src/directives.rs
@@ -415,10 +415,18 @@ impl TestProps {
                         config.parse_name_value_directive(ln, COMPILE_FLAGS, testfile)
                     {
                         let flags = split_flags(&flags);
-                        for flag in &flags {
+                        for (i, flag) in flags.iter().enumerate() {
                             if flag == "--edition" || flag.starts_with("--edition=") {
                                 panic!("you must use `//@ edition` to configure the edition");
                             }
+                            if (flag == "-C"
+                                && flags.get(i + 1).is_some_and(|v| v.starts_with("incremental=")))
+                                || flag.starts_with("-Cincremental=")
+                            {
+                                panic!(
+                                    "you must use `//@ incremental` to enable incremental compilation"
+                                );
+                            }
                         }
                         self.compile_flags.extend(flags);
                     }
diff --git a/tests/ui/compiletest-self-test/compile-flags-incremental.rs b/tests/ui/compiletest-self-test/compile-flags-incremental.rs
new file mode 100644
index 0000000000000..62a1ad84d8f7d
--- /dev/null
+++ b/tests/ui/compiletest-self-test/compile-flags-incremental.rs
@@ -0,0 +1,17 @@
+//@ revisions: good bad bad-space
+//@ check-pass
+
+//@[bad] compile-flags: -Cincremental=true
+//@[bad] should-fail
+
+//@[bad-space] compile-flags:  -C  incremental=dir
+//@[bad-space] should-fail
+
+fn main() {}
+
+// Tests should not try to manually enable incremental compilation with
+// `-Cincremental`, because that typically results in stray directories being
+// created in the repository root.
+//
+// Instead, use the `//@ incremental` directive, which instructs compiletest
+// to handle the details of passing `-Cincremental` with a fresh directory.

From 571412f8190089c36758031fe09fc0ece59be6b7 Mon Sep 17 00:00:00 2001
From: dianqk <dianqk@dianqk.net>
Date: Sun, 8 Jun 2025 15:30:09 +0800
Subject: [PATCH 1650/1889] mir-opt: Eliminate dead ref statements

---
 compiler/rustc_codegen_ssa/src/mir/analyze.rs |   4 +
 compiler/rustc_middle/src/mir/mod.rs          |  45 ++-
 compiler/rustc_middle/src/mir/pretty.rs       |  19 +
 compiler/rustc_middle/src/mir/statement.rs    | 103 +++++-
 compiler/rustc_middle/src/mir/visit.rs        |  40 ++-
 compiler/rustc_mir_dataflow/src/debuginfo.rs  |  10 +-
 .../rustc_mir_dataflow/src/impls/liveness.rs  |  78 ++--
 .../src/cleanup_post_borrowck.rs              |   4 +-
 compiler/rustc_mir_transform/src/copy_prop.rs |   4 +-
 compiler/rustc_mir_transform/src/coroutine.rs |   2 +-
 .../src/dead_store_elimination.rs             |  55 ++-
 compiler/rustc_mir_transform/src/dest_prop.rs |   4 +-
 compiler/rustc_mir_transform/src/gvn.rs       |   2 +-
 .../rustc_mir_transform/src/large_enums.rs    |   2 +-
 compiler/rustc_mir_transform/src/patch.rs     |   2 +-
 .../rustc_mir_transform/src/promote_consts.rs |   2 +-
 compiler/rustc_mir_transform/src/ref_prop.rs  |   2 +-
 .../src/remove_place_mention.rs               |   2 +-
 .../src/remove_storage_markers.rs             |   2 +-
 .../rustc_mir_transform/src/remove_zsts.rs    |   2 +-
 compiler/rustc_mir_transform/src/simplify.rs  |  29 +-
 .../src/simplify_comparison_integral.rs       |   4 +-
 compiler/rustc_mir_transform/src/sroa.rs      |  10 +-
 tests/codegen-llvm/debug-fndef-size.rs        |   4 +-
 ...ad_first.DeadStoreElimination-initial.diff |  31 ++
 tests/mir-opt/dead-store-elimination/ref.rs   |  33 ++
 ...ef.tuple.DeadStoreElimination-initial.diff |  26 ++
 ...ycfg.drop_debuginfo.SimplifyCfg-final.diff |  26 ++
 ...reserve_debuginfo_1.SimplifyCfg-final.diff |  30 ++
 ...reserve_debuginfo_2.SimplifyCfg-final.diff |  29 ++
 .../inline_shims.drop.Inline.panic-abort.diff |  56 +--
 ...y.run2-{closure#0}.Inline.panic-abort.diff |   6 +-
 ....run2-{closure#0}.Inline.panic-unwind.diff |   6 +-
 ...implifyComparisonIntegral.panic-abort.diff |   6 +-
 ...mplifyComparisonIntegral.panic-unwind.diff |   6 +-
 ...git.PreCodegen.after.32bit.panic-abort.mir |   4 +
 ...it.PreCodegen.after.32bit.panic-unwind.mir |   4 +
 ...git.PreCodegen.after.64bit.panic-abort.mir |   4 +
 ...it.PreCodegen.after.64bit.panic-unwind.mir |   4 +
 ...p_forward.PreCodegen.after.panic-abort.mir |  40 ++-
 ..._forward.PreCodegen.after.panic-unwind.mir |  40 ++-
 ...as_copy.clone_as_copy.PreCodegen.after.mir |   2 +-
 ...py.enum_clone_as_copy.PreCodegen.after.mir |   6 +-
 ...ace.PreCodegen.after.32bit.panic-abort.mir |  38 +-
 ...ce.PreCodegen.after.32bit.panic-unwind.mir |  38 +-
 ...ace.PreCodegen.after.64bit.panic-abort.mir |  38 +-
 ...ce.PreCodegen.after.64bit.panic-unwind.mir |  38 +-
 tests/mir-opt/pre-codegen/drop_boxed_slice.rs |   2 +-
 .../loops.filter_mapped.PreCodegen.after.mir  |  44 +--
 .../loops.int_range.PreCodegen.after.mir      | 100 +++---
 .../loops.mapped.PreCodegen.after.mir         |  84 ++---
 tests/mir-opt/pre-codegen/loops.rs            |   1 +
 .../loops.vec_move.PreCodegen.after.mir       | 340 ++++++++++++++++--
 ...variant_a-{closure#0}.PreCodegen.after.mir | 199 +++++-----
 ...ated_loop.PreCodegen.after.panic-abort.mir |  14 +
 ...ward_loop.PreCodegen.after.panic-abort.mir |  14 +
 ...ard_loop.PreCodegen.after.panic-unwind.mir |  14 +
 ...erse_loop.PreCodegen.after.panic-abort.mir | 223 ++++++++++--
 ...rse_loop.PreCodegen.after.panic-unwind.mir | 231 ++++++++++--
 ..._is_empty.PreCodegen.after.panic-abort.mir |   8 +
 ...is_empty.PreCodegen.after.panic-unwind.mir |   8 +
 ...next_back.PreCodegen.after.panic-abort.mir | 189 +++++++++-
 ...ext_back.PreCodegen.after.panic-unwind.mir | 189 +++++++++-
 ...iter_next.PreCodegen.after.panic-abort.mir |  14 +
 ...ter_next.PreCodegen.after.panic-unwind.mir |  14 +
 ...ans.outer.PreCodegen.after.panic-abort.mir |   2 +-
 ...ns.outer.PreCodegen.after.panic-unwind.mir |   2 +-
 ..._to_slice.PreCodegen.after.panic-abort.mir |   8 +
 ...to_slice.PreCodegen.after.panic-unwind.mir |   8 +
 69 files changed, 2139 insertions(+), 511 deletions(-)
 create mode 100644 tests/mir-opt/dead-store-elimination/ref.dead_first.DeadStoreElimination-initial.diff
 create mode 100644 tests/mir-opt/dead-store-elimination/ref.rs
 create mode 100644 tests/mir-opt/dead-store-elimination/ref.tuple.DeadStoreElimination-initial.diff
 create mode 100644 tests/mir-opt/debuginfo/simplifycfg.drop_debuginfo.SimplifyCfg-final.diff
 create mode 100644 tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_1.SimplifyCfg-final.diff
 create mode 100644 tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_2.SimplifyCfg-final.diff

diff --git a/compiler/rustc_codegen_ssa/src/mir/analyze.rs b/compiler/rustc_codegen_ssa/src/mir/analyze.rs
index 45bc545194682..0a37a904193fa 100644
--- a/compiler/rustc_codegen_ssa/src/mir/analyze.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/analyze.rs
@@ -260,6 +260,10 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'b, 'tcx>> Visitor<'tcx> for LocalAnalyzer
             PlaceContext::MutatingUse(MutatingUseContext::Yield) => bug!(),
         }
     }
+
+    fn visit_statement_debuginfo(&mut self, _: &mir::StmtDebugInfo<'tcx>, _: Location) {
+        // Debuginfo does not generate actual code.
+    }
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs
index 28142382b130b..8eb7aa71fcdea 100644
--- a/compiler/rustc_middle/src/mir/mod.rs
+++ b/compiler/rustc_middle/src/mir/mod.rs
@@ -1298,6 +1298,10 @@ pub struct BasicBlockData<'tcx> {
     /// List of statements in this block.
     pub statements: Vec<Statement<'tcx>>,
 
+    /// All debuginfos happen before the statement.
+    /// Put debuginfos here when the last statement is eliminated.
+    pub after_last_stmt_debuginfos: StmtDebugInfos<'tcx>,
+
     /// Terminator for this block.
     ///
     /// N.B., this should generally ONLY be `None` during construction.
@@ -1325,7 +1329,12 @@ impl<'tcx> BasicBlockData<'tcx> {
         terminator: Option<Terminator<'tcx>>,
         is_cleanup: bool,
     ) -> BasicBlockData<'tcx> {
-        BasicBlockData { statements, terminator, is_cleanup }
+        BasicBlockData {
+            statements,
+            after_last_stmt_debuginfos: StmtDebugInfos::default(),
+            terminator,
+            is_cleanup,
+        }
     }
 
     /// Accessor for terminator.
@@ -1360,6 +1369,36 @@ impl<'tcx> BasicBlockData<'tcx> {
             self.terminator().successors()
         }
     }
+
+    pub fn retain_statements<F>(&mut self, mut f: F)
+    where
+        F: FnMut(&Statement<'tcx>) -> bool,
+    {
+        // Place debuginfos into the next retained statement,
+        // this `debuginfos` variable is used to cache debuginfos between two retained statements.
+        let mut debuginfos = StmtDebugInfos::default();
+        self.statements.retain_mut(|stmt| {
+            let retain = f(stmt);
+            if retain {
+                stmt.debuginfos.prepend(&mut debuginfos);
+            } else {
+                debuginfos.append(&mut stmt.debuginfos);
+            }
+            retain
+        });
+        self.after_last_stmt_debuginfos.prepend(&mut debuginfos);
+    }
+
+    pub fn strip_nops(&mut self) {
+        self.retain_statements(|stmt| !matches!(stmt.kind, StatementKind::Nop))
+    }
+
+    pub fn drop_debuginfo(&mut self) {
+        self.after_last_stmt_debuginfos.drop_debuginfo();
+        for stmt in self.statements.iter_mut() {
+            stmt.debuginfos.drop_debuginfo();
+        }
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////
@@ -1664,10 +1703,10 @@ mod size_asserts {
 
     use super::*;
     // tidy-alphabetical-start
-    static_assert_size!(BasicBlockData<'_>, 128);
+    static_assert_size!(BasicBlockData<'_>, 152);
     static_assert_size!(LocalDecl<'_>, 40);
     static_assert_size!(SourceScopeData<'_>, 64);
-    static_assert_size!(Statement<'_>, 32);
+    static_assert_size!(Statement<'_>, 56);
     static_assert_size!(Terminator<'_>, 96);
     static_assert_size!(VarDebugInfo<'_>, 88);
     // tidy-alphabetical-end
diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
index 350d75c2ee772..8cf89f778a2aa 100644
--- a/compiler/rustc_middle/src/mir/pretty.rs
+++ b/compiler/rustc_middle/src/mir/pretty.rs
@@ -719,6 +719,11 @@ impl<'de, 'tcx> MirWriter<'de, 'tcx> {
         let mut current_location = Location { block, statement_index: 0 };
         for statement in &data.statements {
             (self.extra_data)(PassWhere::BeforeLocation(current_location), w)?;
+
+            for debuginfo in statement.debuginfos.iter() {
+                writeln!(w, "{INDENT}{INDENT}// DBG: {debuginfo:?};")?;
+            }
+
             let indented_body = format!("{INDENT}{INDENT}{statement:?};");
             if self.options.include_extra_comments {
                 writeln!(
@@ -749,6 +754,10 @@ impl<'de, 'tcx> MirWriter<'de, 'tcx> {
             current_location.statement_index += 1;
         }
 
+        for debuginfo in data.after_last_stmt_debuginfos.iter() {
+            writeln!(w, "{INDENT}{INDENT}// DBG: {debuginfo:?};")?;
+        }
+
         // Terminator at the bottom.
         (self.extra_data)(PassWhere::BeforeLocation(current_location), w)?;
         if data.terminator.is_some() {
@@ -829,6 +838,16 @@ impl Debug for Statement<'_> {
     }
 }
 
+impl Debug for StmtDebugInfo<'_> {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
+        match self {
+            StmtDebugInfo::AssignRef(local, place) => {
+                write!(fmt, "{local:?} = &{place:?}")
+            }
+        }
+    }
+}
+
 impl Display for NonDivergingIntrinsic<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
diff --git a/compiler/rustc_middle/src/mir/statement.rs b/compiler/rustc_middle/src/mir/statement.rs
index e009fe05b53e6..9deb43eb7084b 100644
--- a/compiler/rustc_middle/src/mir/statement.rs
+++ b/compiler/rustc_middle/src/mir/statement.rs
@@ -1,5 +1,7 @@
 //! Functionality for statements, operands, places, and things that appear in them.
 
+use std::ops;
+
 use tracing::{debug, instrument};
 
 use super::interpret::GlobalAlloc;
@@ -15,17 +17,34 @@ use crate::ty::CoroutineArgsExt;
 pub struct Statement<'tcx> {
     pub source_info: SourceInfo,
     pub kind: StatementKind<'tcx>,
+    /// Some debuginfos appearing before the primary statement.
+    pub debuginfos: StmtDebugInfos<'tcx>,
 }
 
 impl<'tcx> Statement<'tcx> {
     /// Changes a statement to a nop. This is both faster than deleting instructions and avoids
     /// invalidating statement indices in `Location`s.
-    pub fn make_nop(&mut self) {
-        self.kind = StatementKind::Nop
+    pub fn make_nop(&mut self, drop_debuginfo: bool) {
+        if matches!(self.kind, StatementKind::Nop) {
+            return;
+        }
+        let replaced_stmt = std::mem::replace(&mut self.kind, StatementKind::Nop);
+        if !drop_debuginfo {
+            match replaced_stmt {
+                StatementKind::Assign(box (place, Rvalue::Ref(_, _, ref_place)))
+                    if let Some(local) = place.as_local() =>
+                {
+                    self.debuginfos.push(StmtDebugInfo::AssignRef(local, ref_place));
+                }
+                _ => {
+                    bug!("debuginfo is not yet supported.")
+                }
+            }
+        }
     }
 
     pub fn new(source_info: SourceInfo, kind: StatementKind<'tcx>) -> Self {
-        Statement { source_info, kind }
+        Statement { source_info, kind, debuginfos: StmtDebugInfos::default() }
     }
 }
 
@@ -63,6 +82,17 @@ impl<'tcx> StatementKind<'tcx> {
             _ => None,
         }
     }
+
+    pub fn as_debuginfo(&self) -> Option<StmtDebugInfo<'tcx>> {
+        match self {
+            StatementKind::Assign(box (place, Rvalue::Ref(_, _, ref_place)))
+                if let Some(local) = place.as_local() =>
+            {
+                Some(StmtDebugInfo::AssignRef(local, *ref_place))
+            }
+            _ => None,
+        }
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////
@@ -967,3 +997,70 @@ impl RawPtrKind {
         }
     }
 }
+
+#[derive(Default, Debug, Clone, TyEncodable, TyDecodable, HashStable, TypeFoldable, TypeVisitable)]
+pub struct StmtDebugInfos<'tcx>(Vec<StmtDebugInfo<'tcx>>);
+
+impl<'tcx> StmtDebugInfos<'tcx> {
+    pub fn push(&mut self, debuginfo: StmtDebugInfo<'tcx>) {
+        self.0.push(debuginfo);
+    }
+
+    pub fn drop_debuginfo(&mut self) {
+        self.0.clear();
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
+    pub fn prepend(&mut self, debuginfos: &mut Self) {
+        if debuginfos.is_empty() {
+            return;
+        };
+        debuginfos.0.append(self);
+        std::mem::swap(debuginfos, self);
+    }
+
+    pub fn append(&mut self, debuginfos: &mut Self) {
+        if debuginfos.is_empty() {
+            return;
+        };
+        self.0.append(debuginfos);
+    }
+
+    pub fn extend(&mut self, debuginfos: &Self) {
+        if debuginfos.is_empty() {
+            return;
+        };
+        self.0.extend_from_slice(debuginfos);
+    }
+
+    pub fn retain<F>(&mut self, f: F)
+    where
+        F: FnMut(&StmtDebugInfo<'tcx>) -> bool,
+    {
+        self.0.retain(f);
+    }
+}
+
+impl<'tcx> ops::Deref for StmtDebugInfos<'tcx> {
+    type Target = Vec<StmtDebugInfo<'tcx>>;
+
+    #[inline]
+    fn deref(&self) -> &Vec<StmtDebugInfo<'tcx>> {
+        &self.0
+    }
+}
+
+impl<'tcx> ops::DerefMut for StmtDebugInfos<'tcx> {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Vec<StmtDebugInfo<'tcx>> {
+        &mut self.0
+    }
+}
+
+#[derive(Clone, TyEncodable, TyDecodable, HashStable, TypeFoldable, TypeVisitable)]
+pub enum StmtDebugInfo<'tcx> {
+    AssignRef(Local, Place<'tcx>),
+}
diff --git a/compiler/rustc_middle/src/mir/visit.rs b/compiler/rustc_middle/src/mir/visit.rs
index f392347780051..47ae23afd556e 100644
--- a/compiler/rustc_middle/src/mir/visit.rs
+++ b/compiler/rustc_middle/src/mir/visit.rs
@@ -95,6 +95,14 @@ macro_rules! make_mir_visitor {
                 self.super_source_scope_data(scope_data);
             }
 
+            fn visit_statement_debuginfo(
+                &mut self,
+                stmt_debuginfo: & $($mutability)? StmtDebugInfo<'tcx>,
+                location: Location
+            ) {
+                self.super_statement_debuginfo(stmt_debuginfo, location);
+            }
+
             fn visit_statement(
                 &mut self,
                 statement: & $($mutability)? Statement<'tcx>,
@@ -301,6 +309,7 @@ macro_rules! make_mir_visitor {
             {
                 let BasicBlockData {
                     statements,
+                    after_last_stmt_debuginfos,
                     terminator,
                     is_cleanup: _
                 } = data;
@@ -312,8 +321,11 @@ macro_rules! make_mir_visitor {
                     index += 1;
                 }
 
+                let location = Location { block, statement_index: index };
+                for debuginfo in after_last_stmt_debuginfos as & $($mutability)? [_] {
+                    self.visit_statement_debuginfo(debuginfo, location);
+                }
                 if let Some(terminator) = terminator {
-                    let location = Location { block, statement_index: index };
                     self.visit_terminator(terminator, location);
                 }
             }
@@ -376,14 +388,38 @@ macro_rules! make_mir_visitor {
                 }
             }
 
+            fn super_statement_debuginfo(
+                &mut self,
+                stmt_debuginfo: & $($mutability)? StmtDebugInfo<'tcx>,
+                location: Location
+            ) {
+                match stmt_debuginfo {
+                    StmtDebugInfo::AssignRef(local, place) => {
+                        self.visit_local(
+                            $(& $mutability)? *local,
+                            PlaceContext::NonUse(NonUseContext::VarDebugInfo),
+                            location
+                        );
+                        self.visit_place(
+                            place,
+                            PlaceContext::NonUse(NonUseContext::VarDebugInfo),
+                            location
+                        );
+                    },
+                }
+            }
+
             fn super_statement(
                 &mut self,
                 statement: & $($mutability)? Statement<'tcx>,
                 location: Location
             ) {
-                let Statement { source_info, kind } = statement;
+                let Statement { source_info, kind, debuginfos } = statement;
 
                 self.visit_source_info(source_info);
+                for debuginfo in debuginfos as & $($mutability)? [_] {
+                    self.visit_statement_debuginfo(debuginfo, location);
+                }
                 match kind {
                     StatementKind::Assign(box (place, rvalue)) => {
                         self.visit_assign(place, rvalue, location);
diff --git a/compiler/rustc_mir_dataflow/src/debuginfo.rs b/compiler/rustc_mir_dataflow/src/debuginfo.rs
index 0d25ce91c9a9e..274c5943946c2 100644
--- a/compiler/rustc_mir_dataflow/src/debuginfo.rs
+++ b/compiler/rustc_mir_dataflow/src/debuginfo.rs
@@ -5,16 +5,16 @@ use rustc_middle::mir::*;
 /// Return the set of locals that appear in debuginfo.
 pub fn debuginfo_locals(body: &Body<'_>) -> DenseBitSet<Local> {
     let mut visitor = DebuginfoLocals(DenseBitSet::new_empty(body.local_decls.len()));
-    for debuginfo in body.var_debug_info.iter() {
-        visitor.visit_var_debug_info(debuginfo);
-    }
+    visitor.visit_body(body);
     visitor.0
 }
 
 struct DebuginfoLocals(DenseBitSet<Local>);
 
 impl Visitor<'_> for DebuginfoLocals {
-    fn visit_local(&mut self, local: Local, _: PlaceContext, _: Location) {
-        self.0.insert(local);
+    fn visit_local(&mut self, local: Local, place_context: PlaceContext, _: Location) {
+        if place_context == PlaceContext::NonUse(NonUseContext::VarDebugInfo) {
+            self.0.insert(local);
+        }
     }
 }
diff --git a/compiler/rustc_mir_dataflow/src/impls/liveness.rs b/compiler/rustc_mir_dataflow/src/impls/liveness.rs
index 5eba474a60c7a..24da4b0bea28a 100644
--- a/compiler/rustc_mir_dataflow/src/impls/liveness.rs
+++ b/compiler/rustc_mir_dataflow/src/impls/liveness.rs
@@ -210,6 +210,7 @@ impl DefUse {
 /// All of the caveats of `MaybeLiveLocals` apply.
 pub struct MaybeTransitiveLiveLocals<'a> {
     always_live: &'a DenseBitSet<Local>,
+    debuginfo_locals: &'a DenseBitSet<Local>,
 }
 
 impl<'a> MaybeTransitiveLiveLocals<'a> {
@@ -217,8 +218,46 @@ impl<'a> MaybeTransitiveLiveLocals<'a> {
     /// considered live.
     ///
     /// This should include at least all locals that are ever borrowed.
-    pub fn new(always_live: &'a DenseBitSet<Local>) -> Self {
-        MaybeTransitiveLiveLocals { always_live }
+    pub fn new(
+        always_live: &'a DenseBitSet<Local>,
+        debuginfo_locals: &'a DenseBitSet<Local>,
+    ) -> Self {
+        MaybeTransitiveLiveLocals { always_live, debuginfo_locals }
+    }
+
+    pub fn can_be_removed_if_dead<'tcx>(
+        stmt_kind: &StatementKind<'tcx>,
+        always_live: &DenseBitSet<Local>,
+        debuginfo_locals: &'a DenseBitSet<Local>,
+    ) -> Option<Place<'tcx>> {
+        // Compute the place that we are storing to, if any
+        let destination = match stmt_kind {
+            StatementKind::Assign(box (place, rvalue)) => (rvalue.is_safe_to_remove()
+                && (!debuginfo_locals.contains(place.local)
+                    || (place.as_local().is_some() && matches!(rvalue, mir::Rvalue::Ref(..)))))
+            .then_some(*place),
+            StatementKind::SetDiscriminant { place, .. } | StatementKind::Deinit(place) => {
+                (!debuginfo_locals.contains(place.local)).then_some(**place)
+            }
+            StatementKind::FakeRead(_)
+            | StatementKind::StorageLive(_)
+            | StatementKind::StorageDead(_)
+            | StatementKind::Retag(..)
+            | StatementKind::AscribeUserType(..)
+            | StatementKind::PlaceMention(..)
+            | StatementKind::Coverage(..)
+            | StatementKind::Intrinsic(..)
+            | StatementKind::ConstEvalCounter
+            | StatementKind::BackwardIncompatibleDropHint { .. }
+            | StatementKind::Nop => None,
+        };
+        if let Some(destination) = destination
+            && !destination.is_indirect()
+            && !always_live.contains(destination.local)
+        {
+            return Some(destination);
+        }
+        None
     }
 }
 
@@ -243,32 +282,15 @@ impl<'a, 'tcx> Analysis<'tcx> for MaybeTransitiveLiveLocals<'a> {
         statement: &mir::Statement<'tcx>,
         location: Location,
     ) {
-        // Compute the place that we are storing to, if any
-        let destination = match &statement.kind {
-            StatementKind::Assign(assign) => assign.1.is_safe_to_remove().then_some(assign.0),
-            StatementKind::SetDiscriminant { place, .. } | StatementKind::Deinit(place) => {
-                Some(**place)
-            }
-            StatementKind::FakeRead(_)
-            | StatementKind::StorageLive(_)
-            | StatementKind::StorageDead(_)
-            | StatementKind::Retag(..)
-            | StatementKind::AscribeUserType(..)
-            | StatementKind::PlaceMention(..)
-            | StatementKind::Coverage(..)
-            | StatementKind::Intrinsic(..)
-            | StatementKind::ConstEvalCounter
-            | StatementKind::BackwardIncompatibleDropHint { .. }
-            | StatementKind::Nop => None,
-        };
-        if let Some(destination) = destination {
-            if !destination.is_indirect()
-                && !state.contains(destination.local)
-                && !self.always_live.contains(destination.local)
-            {
-                // This store is dead
-                return;
-            }
+        if let Some(destination) =
+            Self::can_be_removed_if_dead(&statement.kind, &self.always_live, &self.debuginfo_locals)
+            && !state.contains(destination.local)
+            // FIXME: We can eliminate the statement, but we'll need the statements it depends on
+            // for debuginfos. We need a way to handle this.
+            && !self.debuginfo_locals.contains(destination.local)
+        {
+            // This store is dead
+            return;
         }
         TransferFunction(state).visit_statement(statement, location);
     }
diff --git a/compiler/rustc_mir_transform/src/cleanup_post_borrowck.rs b/compiler/rustc_mir_transform/src/cleanup_post_borrowck.rs
index 4be67b873f737..b0bf7f484bedf 100644
--- a/compiler/rustc_mir_transform/src/cleanup_post_borrowck.rs
+++ b/compiler/rustc_mir_transform/src/cleanup_post_borrowck.rs
@@ -36,7 +36,9 @@ impl<'tcx> crate::MirPass<'tcx> for CleanupPostBorrowck {
                         CoverageKind::BlockMarker { .. } | CoverageKind::SpanMarker { .. },
                     )
                     | StatementKind::FakeRead(..)
-                    | StatementKind::BackwardIncompatibleDropHint { .. } => statement.make_nop(),
+                    | StatementKind::BackwardIncompatibleDropHint { .. } => {
+                        statement.make_nop(true)
+                    }
                     StatementKind::Assign(box (
                         _,
                         Rvalue::Cast(
diff --git a/compiler/rustc_mir_transform/src/copy_prop.rs b/compiler/rustc_mir_transform/src/copy_prop.rs
index cddeefca68174..f0bc286a94022 100644
--- a/compiler/rustc_mir_transform/src/copy_prop.rs
+++ b/compiler/rustc_mir_transform/src/copy_prop.rs
@@ -138,7 +138,7 @@ impl<'tcx> MutVisitor<'tcx> for Replacer<'_, 'tcx> {
         if let StatementKind::StorageLive(l) | StatementKind::StorageDead(l) = stmt.kind
             && self.storage_to_remove.contains(l)
         {
-            stmt.make_nop();
+            stmt.make_nop(true);
             return;
         }
 
@@ -150,7 +150,7 @@ impl<'tcx> MutVisitor<'tcx> for Replacer<'_, 'tcx> {
                 *rhs
             && lhs == rhs
         {
-            stmt.make_nop();
+            stmt.make_nop(true);
         }
     }
 }
diff --git a/compiler/rustc_mir_transform/src/coroutine.rs b/compiler/rustc_mir_transform/src/coroutine.rs
index c5cd06f170c47..814eded910df5 100644
--- a/compiler/rustc_mir_transform/src/coroutine.rs
+++ b/compiler/rustc_mir_transform/src/coroutine.rs
@@ -411,7 +411,7 @@ impl<'tcx> MutVisitor<'tcx> for TransformVisitor<'tcx> {
             if let StatementKind::StorageLive(l) | StatementKind::StorageDead(l) = s.kind
                 && self.remap.contains(l)
             {
-                s.make_nop();
+                s.make_nop(true);
             }
         }
 
diff --git a/compiler/rustc_mir_transform/src/dead_store_elimination.rs b/compiler/rustc_mir_transform/src/dead_store_elimination.rs
index eea2b0990d730..a5f8a22e83c85 100644
--- a/compiler/rustc_mir_transform/src/dead_store_elimination.rs
+++ b/compiler/rustc_mir_transform/src/dead_store_elimination.rs
@@ -33,10 +33,9 @@ fn eliminate<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
 
     // If the user requests complete debuginfo, mark the locals that appear in it as live, so
     // we don't remove assignments to them.
-    let mut always_live = debuginfo_locals(body);
-    always_live.union(&borrowed_locals);
+    let debuginfo_locals = debuginfo_locals(body);
 
-    let mut live = MaybeTransitiveLiveLocals::new(&always_live)
+    let mut live = MaybeTransitiveLiveLocals::new(&borrowed_locals, &debuginfo_locals)
         .iterate_to_fixpoint(tcx, body, None)
         .into_results_cursor(body);
 
@@ -75,35 +74,23 @@ fn eliminate<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
         }
 
         for (statement_index, statement) in bb_data.statements.iter().enumerate().rev() {
-            let loc = Location { block: bb, statement_index };
-            if let StatementKind::Assign(assign) = &statement.kind {
-                if !assign.1.is_safe_to_remove() {
-                    continue;
-                }
-            }
-            match &statement.kind {
-                StatementKind::Assign(box (place, _))
-                | StatementKind::SetDiscriminant { place: box place, .. }
-                | StatementKind::Deinit(box place) => {
-                    if !place.is_indirect() && !always_live.contains(place.local) {
-                        live.seek_before_primary_effect(loc);
-                        if !live.get().contains(place.local) {
-                            patch.push(loc);
-                        }
-                    }
-                }
-                StatementKind::Retag(_, _)
-                | StatementKind::StorageLive(_)
-                | StatementKind::StorageDead(_)
-                | StatementKind::Coverage(_)
-                | StatementKind::Intrinsic(_)
-                | StatementKind::ConstEvalCounter
-                | StatementKind::PlaceMention(_)
-                | StatementKind::BackwardIncompatibleDropHint { .. }
-                | StatementKind::Nop => {}
-
-                StatementKind::FakeRead(_) | StatementKind::AscribeUserType(_, _) => {
-                    bug!("{:?} not found in this MIR phase!", statement.kind)
+            if let Some(destination) = MaybeTransitiveLiveLocals::can_be_removed_if_dead(
+                &statement.kind,
+                &borrowed_locals,
+                &debuginfo_locals,
+            ) {
+                let loc = Location { block: bb, statement_index };
+                live.seek_before_primary_effect(loc);
+                if !live.get().contains(destination.local) {
+                    let drop_debuginfo = !debuginfo_locals.contains(destination.local);
+                    // When eliminating a dead statement, we need to address
+                    // the debug information for that statement.
+                    assert!(
+                        drop_debuginfo || statement.kind.as_debuginfo().is_some(),
+                        "don't know how to retain the debug information for {:?}",
+                        statement.kind
+                    );
+                    patch.push((loc, drop_debuginfo));
                 }
             }
         }
@@ -114,8 +101,8 @@ fn eliminate<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
     }
 
     let bbs = body.basic_blocks.as_mut_preserves_cfg();
-    for Location { block, statement_index } in patch {
-        bbs[block].statements[statement_index].make_nop();
+    for (Location { block, statement_index }, drop_debuginfo) in patch {
+        bbs[block].statements[statement_index].make_nop(drop_debuginfo);
     }
     for (block, argument_index) in call_operands_to_move {
         let TerminatorKind::Call { ref mut args, .. } = bbs[block].terminator_mut().kind else {
diff --git a/compiler/rustc_mir_transform/src/dest_prop.rs b/compiler/rustc_mir_transform/src/dest_prop.rs
index 74c22ff10c198..1f38433fa5a41 100644
--- a/compiler/rustc_mir_transform/src/dest_prop.rs
+++ b/compiler/rustc_mir_transform/src/dest_prop.rs
@@ -276,7 +276,7 @@ impl<'tcx> MutVisitor<'tcx> for Merger<'tcx> {
             StatementKind::StorageDead(local) | StatementKind::StorageLive(local)
                 if self.merged_locals.contains(*local) =>
             {
-                statement.make_nop();
+                statement.make_nop(true);
                 return;
             }
             _ => (),
@@ -291,7 +291,7 @@ impl<'tcx> MutVisitor<'tcx> for Merger<'tcx> {
                         // (this includes the original statement we wanted to eliminate).
                         if dest == place {
                             debug!("{:?} turned into self-assignment, deleting", location);
-                            statement.make_nop();
+                            statement.make_nop(true);
                         }
                     }
                     _ => {}
diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index 99691d9e045b4..3ff8dc6dbb378 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -1877,7 +1877,7 @@ impl<'tcx> MutVisitor<'tcx> for StorageRemover<'tcx> {
             StatementKind::StorageLive(l) | StatementKind::StorageDead(l)
                 if self.reused_locals.contains(l) =>
             {
-                stmt.make_nop()
+                stmt.make_nop(true)
             }
             _ => self.super_statement(stmt, loc),
         }
diff --git a/compiler/rustc_mir_transform/src/large_enums.rs b/compiler/rustc_mir_transform/src/large_enums.rs
index 1a91d6bd7da98..1b90e9158f6b8 100644
--- a/compiler/rustc_mir_transform/src/large_enums.rs
+++ b/compiler/rustc_mir_transform/src/large_enums.rs
@@ -156,7 +156,7 @@ impl<'tcx> crate::MirPass<'tcx> for EnumSizeOpt {
                     patch.add_statement(location, stmt);
                 }
 
-                st.make_nop();
+                st.make_nop(true);
             }
         }
 
diff --git a/compiler/rustc_mir_transform/src/patch.rs b/compiler/rustc_mir_transform/src/patch.rs
index cc8ea76011bf6..2c535d011a0e2 100644
--- a/compiler/rustc_mir_transform/src/patch.rs
+++ b/compiler/rustc_mir_transform/src/patch.rs
@@ -270,7 +270,7 @@ impl<'tcx> MirPatch<'tcx> {
         body.local_decls.extend(self.new_locals);
 
         for loc in self.nop_statements {
-            bbs[loc.block].statements[loc.statement_index].make_nop();
+            bbs[loc.block].statements[loc.statement_index].make_nop(true);
         }
 
         let mut new_statements = self.new_statements;
diff --git a/compiler/rustc_mir_transform/src/promote_consts.rs b/compiler/rustc_mir_transform/src/promote_consts.rs
index 48ddf5a1bcabb..c7dc18a4a1343 100644
--- a/compiler/rustc_mir_transform/src/promote_consts.rs
+++ b/compiler/rustc_mir_transform/src/promote_consts.rs
@@ -1049,7 +1049,7 @@ fn promote_candidates<'tcx>(
     // Eliminate assignments to, and drops of promoted temps.
     let promoted = |index: Local| temps[index] == TempState::PromotedOut;
     for block in body.basic_blocks_mut() {
-        block.statements.retain(|statement| match &statement.kind {
+        block.retain_statements(|statement| match &statement.kind {
             StatementKind::Assign(box (place, _)) => {
                 if let Some(index) = place.as_local() {
                     !promoted(index)
diff --git a/compiler/rustc_mir_transform/src/ref_prop.rs b/compiler/rustc_mir_transform/src/ref_prop.rs
index b9d6e74ecae89..deb0a146476c3 100644
--- a/compiler/rustc_mir_transform/src/ref_prop.rs
+++ b/compiler/rustc_mir_transform/src/ref_prop.rs
@@ -435,7 +435,7 @@ impl<'tcx> MutVisitor<'tcx> for Replacer<'tcx> {
             StatementKind::StorageLive(l) | StatementKind::StorageDead(l)
                 if self.storage_to_remove.contains(l) =>
             {
-                stmt.make_nop();
+                stmt.make_nop(true);
             }
             // Do not remove assignments as they may still be useful for debuginfo.
             _ => self.super_statement(stmt, loc),
diff --git a/compiler/rustc_mir_transform/src/remove_place_mention.rs b/compiler/rustc_mir_transform/src/remove_place_mention.rs
index cb598ceb4dfea..d56b51bb496e4 100644
--- a/compiler/rustc_mir_transform/src/remove_place_mention.rs
+++ b/compiler/rustc_mir_transform/src/remove_place_mention.rs
@@ -14,7 +14,7 @@ impl<'tcx> crate::MirPass<'tcx> for RemovePlaceMention {
     fn run_pass(&self, _: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
         trace!("Running RemovePlaceMention on {:?}", body.source);
         for data in body.basic_blocks.as_mut_preserves_cfg() {
-            data.statements.retain(|statement| match statement.kind {
+            data.retain_statements(|statement| match statement.kind {
                 StatementKind::PlaceMention(..) | StatementKind::Nop => false,
                 _ => true,
             })
diff --git a/compiler/rustc_mir_transform/src/remove_storage_markers.rs b/compiler/rustc_mir_transform/src/remove_storage_markers.rs
index 1ae33c0096875..cb97d2c865ac9 100644
--- a/compiler/rustc_mir_transform/src/remove_storage_markers.rs
+++ b/compiler/rustc_mir_transform/src/remove_storage_markers.rs
@@ -14,7 +14,7 @@ impl<'tcx> crate::MirPass<'tcx> for RemoveStorageMarkers {
     fn run_pass(&self, _tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
         trace!("Running RemoveStorageMarkers on {:?}", body.source);
         for data in body.basic_blocks.as_mut_preserves_cfg() {
-            data.statements.retain(|statement| match statement.kind {
+            data.retain_statements(|statement| match statement.kind {
                 StatementKind::StorageLive(..)
                 | StatementKind::StorageDead(..)
                 | StatementKind::Nop => false,
diff --git a/compiler/rustc_mir_transform/src/remove_zsts.rs b/compiler/rustc_mir_transform/src/remove_zsts.rs
index c4dc8638b26ab..90c1b3520b96e 100644
--- a/compiler/rustc_mir_transform/src/remove_zsts.rs
+++ b/compiler/rustc_mir_transform/src/remove_zsts.rs
@@ -141,7 +141,7 @@ impl<'tcx> MutVisitor<'tcx> for Replacer<'_, 'tcx> {
             && let ty = place_for_ty.ty(self.local_decls, self.tcx).ty
             && self.known_to_be_zst(ty)
         {
-            statement.make_nop();
+            statement.make_nop(true);
         } else {
             self.super_statement(statement, loc);
         }
diff --git a/compiler/rustc_mir_transform/src/simplify.rs b/compiler/rustc_mir_transform/src/simplify.rs
index 75917d23883be..9f7bb3b03795a 100644
--- a/compiler/rustc_mir_transform/src/simplify.rs
+++ b/compiler/rustc_mir_transform/src/simplify.rs
@@ -36,7 +36,9 @@
 
 use itertools::Itertools as _;
 use rustc_index::{Idx, IndexSlice, IndexVec};
-use rustc_middle::mir::visit::{MutVisitor, MutatingUseContext, PlaceContext, Visitor};
+use rustc_middle::mir::visit::{
+    MutVisitor, MutatingUseContext, NonUseContext, PlaceContext, Visitor,
+};
 use rustc_middle::mir::*;
 use rustc_middle::ty::TyCtxt;
 use rustc_span::DUMMY_SP;
@@ -303,7 +305,7 @@ impl<'a, 'tcx> CfgSimplifier<'a, 'tcx> {
 
     fn strip_nops(&mut self) {
         for blk in self.basic_blocks.iter_mut() {
-            blk.statements.retain(|stmt| !matches!(stmt.kind, StatementKind::Nop))
+            blk.retain_statements(|stmt| !matches!(stmt.kind, StatementKind::Nop))
         }
     }
 }
@@ -539,12 +541,20 @@ impl<'tcx> Visitor<'tcx> for UsedLocals {
                 self.super_statement(statement, location);
             }
 
-            StatementKind::ConstEvalCounter | StatementKind::Nop => {}
-
-            StatementKind::StorageLive(_local) | StatementKind::StorageDead(_local) => {}
+            StatementKind::ConstEvalCounter
+            | StatementKind::Nop
+            | StatementKind::StorageLive(..)
+            | StatementKind::StorageDead(..) => {
+                for debuginfo in statement.debuginfos.iter() {
+                    self.visit_statement_debuginfo(debuginfo, location);
+                }
+            }
 
             StatementKind::Assign(box (ref place, ref rvalue)) => {
                 if rvalue.is_safe_to_remove() {
+                    for debuginfo in statement.debuginfos.iter() {
+                        self.visit_statement_debuginfo(debuginfo, location);
+                    }
                     self.visit_lhs(place, location);
                     self.visit_rvalue(rvalue, location);
                 } else {
@@ -555,15 +565,18 @@ impl<'tcx> Visitor<'tcx> for UsedLocals {
             StatementKind::SetDiscriminant { ref place, variant_index: _ }
             | StatementKind::Deinit(ref place)
             | StatementKind::BackwardIncompatibleDropHint { ref place, reason: _ } => {
+                for debuginfo in statement.debuginfos.iter() {
+                    self.visit_statement_debuginfo(debuginfo, location);
+                }
                 self.visit_lhs(place, location);
             }
         }
     }
 
-    fn visit_local(&mut self, local: Local, _ctx: PlaceContext, _location: Location) {
+    fn visit_local(&mut self, local: Local, ctx: PlaceContext, _location: Location) {
         if self.increment {
             self.use_count[local] += 1;
-        } else {
+        } else if ctx != PlaceContext::NonUse(NonUseContext::VarDebugInfo) {
             assert_ne!(self.use_count[local], 0);
             self.use_count[local] -= 1;
         }
@@ -583,7 +596,7 @@ fn remove_unused_definitions_helper(used_locals: &mut UsedLocals, body: &mut Bod
 
         for data in body.basic_blocks.as_mut_preserves_cfg() {
             // Remove unnecessary StorageLive and StorageDead annotations.
-            data.statements.retain(|statement| {
+            data.retain_statements(|statement| {
                 let keep = match &statement.kind {
                     StatementKind::StorageLive(local) | StatementKind::StorageDead(local) => {
                         used_locals.is_used(*local)
diff --git a/compiler/rustc_mir_transform/src/simplify_comparison_integral.rs b/compiler/rustc_mir_transform/src/simplify_comparison_integral.rs
index c60eb566521c5..4597439e269ff 100644
--- a/compiler/rustc_mir_transform/src/simplify_comparison_integral.rs
+++ b/compiler/rustc_mir_transform/src/simplify_comparison_integral.rs
@@ -76,7 +76,7 @@ impl<'tcx> crate::MirPass<'tcx> for SimplifyComparisonIntegral {
             // delete comparison statement if it the value being switched on was moved, which means
             // it can not be user later on
             if opt.can_remove_bin_op_stmt {
-                bb.statements[opt.bin_op_stmt_idx].make_nop();
+                bb.statements[opt.bin_op_stmt_idx].make_nop(true);
             } else {
                 // if the integer being compared to a const integral is being moved into the
                 // comparison, e.g `_2 = Eq(move _3, const 'x');`
@@ -136,7 +136,7 @@ impl<'tcx> crate::MirPass<'tcx> for SimplifyComparisonIntegral {
         }
 
         for (idx, bb_idx) in storage_deads_to_remove {
-            body.basic_blocks_mut()[bb_idx].statements[idx].make_nop();
+            body.basic_blocks_mut()[bb_idx].statements[idx].make_nop(true);
         }
 
         for (idx, stmt) in storage_deads_to_insert {
diff --git a/compiler/rustc_mir_transform/src/sroa.rs b/compiler/rustc_mir_transform/src/sroa.rs
index 38769885f368b..99f10b8d91d2c 100644
--- a/compiler/rustc_mir_transform/src/sroa.rs
+++ b/compiler/rustc_mir_transform/src/sroa.rs
@@ -318,7 +318,7 @@ impl<'tcx, 'll> MutVisitor<'tcx> for ReplacementVisitor<'tcx, 'll> {
                     for (_, _, fl) in final_locals {
                         self.patch.add_statement(location, StatementKind::StorageLive(fl));
                     }
-                    statement.make_nop();
+                    statement.make_nop(true);
                 }
                 return;
             }
@@ -327,7 +327,7 @@ impl<'tcx, 'll> MutVisitor<'tcx> for ReplacementVisitor<'tcx, 'll> {
                     for (_, _, fl) in final_locals {
                         self.patch.add_statement(location, StatementKind::StorageDead(fl));
                     }
-                    statement.make_nop();
+                    statement.make_nop(true);
                 }
                 return;
             }
@@ -337,7 +337,7 @@ impl<'tcx, 'll> MutVisitor<'tcx> for ReplacementVisitor<'tcx, 'll> {
                         self.patch
                             .add_statement(location, StatementKind::Deinit(Box::new(fl.into())));
                     }
-                    statement.make_nop();
+                    statement.make_nop(true);
                     return;
                 }
             }
@@ -367,7 +367,7 @@ impl<'tcx, 'll> MutVisitor<'tcx> for ReplacementVisitor<'tcx, 'll> {
                             );
                         }
                     }
-                    statement.make_nop();
+                    statement.make_nop(true);
                     return;
                 }
             }
@@ -429,7 +429,7 @@ impl<'tcx, 'll> MutVisitor<'tcx> for ReplacementVisitor<'tcx, 'll> {
                             StatementKind::Assign(Box::new((new_local.into(), rvalue))),
                         );
                     }
-                    statement.make_nop();
+                    statement.make_nop(true);
                     return;
                 }
             }
diff --git a/tests/codegen-llvm/debug-fndef-size.rs b/tests/codegen-llvm/debug-fndef-size.rs
index 8f716c34e7b74..02629bd748c45 100644
--- a/tests/codegen-llvm/debug-fndef-size.rs
+++ b/tests/codegen-llvm/debug-fndef-size.rs
@@ -16,5 +16,5 @@ pub fn main() {
 
 // CHECK: %compare.dbg.spill = alloca [0 x i8], align 1
 // CHECK: dbg{{.}}declare({{(metadata )?}}ptr %compare.dbg.spill, {{(metadata )?}}![[VAR:.*]], {{(metadata )?}}!DIExpression()
-// CHECK: ![[TYPE:.*]] = !DIDerivedType(tag: DW_TAG_pointer_type, name: "fn(&i32, &i32) -> core::cmp::Ordering", baseType: !{{.*}}, align: 8, dwarfAddressSpace: {{.*}})
-// CHECK: ![[VAR]] = !DILocalVariable(name: "compare", scope: !{{.*}}, file: !{{.*}}, line: {{.*}}, type: ![[TYPE]], align: 8)
+// CHECK-DAG: ![[TYPE:.*]] = !DIDerivedType(tag: DW_TAG_pointer_type, name: "fn(&i32, &i32) -> core::cmp::Ordering", baseType: !{{.*}}, align: 8, dwarfAddressSpace: {{.*}})
+// CHECK-DAG: ![[VAR]] = !DILocalVariable(name: "compare", scope: !{{.*}}, file: !{{.*}}, line: {{.*}}, type: ![[TYPE]], align: 8)
diff --git a/tests/mir-opt/dead-store-elimination/ref.dead_first.DeadStoreElimination-initial.diff b/tests/mir-opt/dead-store-elimination/ref.dead_first.DeadStoreElimination-initial.diff
new file mode 100644
index 0000000000000..d823241bc620a
--- /dev/null
+++ b/tests/mir-opt/dead-store-elimination/ref.dead_first.DeadStoreElimination-initial.diff
@@ -0,0 +1,31 @@
+- // MIR for `dead_first` before DeadStoreElimination-initial
++ // MIR for `dead_first` after DeadStoreElimination-initial
+  
+  fn dead_first(_1: &Foo) -> &i32 {
+      debug v => _1;
+      let mut _0: &i32;
+      let mut _2: &i32;
+      let mut _3: &i32;
+      let _4: &i32;
+      scope 1 {
+          debug a => _2;
+      }
+  
+      bb0: {
+          StorageLive(_2);
+-         _2 = &((*_1).2: i32);
++         // DBG: _2 = &((*_1).2: i32);
++         nop;
+          StorageLive(_3);
+          StorageLive(_4);
+          _4 = &((*_1).0: i32);
+          _3 = &(*_4);
+          _2 = move _3;
+          StorageDead(_3);
+          StorageDead(_4);
+          _0 = &(*_2);
+          StorageDead(_2);
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/dead-store-elimination/ref.rs b/tests/mir-opt/dead-store-elimination/ref.rs
new file mode 100644
index 0000000000000..18d9ea8b84d7d
--- /dev/null
+++ b/tests/mir-opt/dead-store-elimination/ref.rs
@@ -0,0 +1,33 @@
+//@ test-mir-pass: DeadStoreElimination-initial
+
+pub struct Foo {
+    a: i32,
+    b: i64,
+    c: i32,
+}
+
+// EMIT_MIR ref.tuple.DeadStoreElimination-initial.diff
+pub fn tuple(v: (i32, &Foo)) -> i32 {
+    // CHECK-LABEL: fn tuple
+    // CHECK: debug _dead => [[dead:_[0-9]+]];
+    // CHECK: bb0:
+    // FIXME: Preserve `tmp` for debuginfo, but we can merge it into the debuginfo.
+    // CHECK: [[tmp:_[0-9]+]] = deref_copy (_1.1: &Foo);
+    // CHECK-NEXT: DBG: [[dead]] = &((*[[tmp]]).2: i32)
+    let _dead = &v.1.c;
+    v.1.a
+}
+
+// EMIT_MIR ref.dead_first.DeadStoreElimination-initial.diff
+pub fn dead_first(v: &Foo) -> &i32 {
+    // CHECK-LABEL: fn dead_first
+    // CHECK: debug a => [[var_a:_[0-9]+]];
+    // CHECK: bb0:
+    // CHECK: DBG: [[var_a]] = &((*_1).2: i32)
+    // CHECK: [[tmp_4:_[0-9]+]] = &((*_1).0: i32)
+    // CHECK: [[tmp_3:_[0-9]+]] = &(*[[tmp_4]])
+    // CHECK: [[var_a]] = move [[tmp_3]]
+    let mut a = &v.c;
+    a = &v.a;
+    a
+}
diff --git a/tests/mir-opt/dead-store-elimination/ref.tuple.DeadStoreElimination-initial.diff b/tests/mir-opt/dead-store-elimination/ref.tuple.DeadStoreElimination-initial.diff
new file mode 100644
index 0000000000000..0547a42cab246
--- /dev/null
+++ b/tests/mir-opt/dead-store-elimination/ref.tuple.DeadStoreElimination-initial.diff
@@ -0,0 +1,26 @@
+- // MIR for `tuple` before DeadStoreElimination-initial
++ // MIR for `tuple` after DeadStoreElimination-initial
+  
+  fn tuple(_1: (i32, &Foo)) -> i32 {
+      debug v => _1;
+      let mut _0: i32;
+      let _2: &i32;
+      let mut _3: &Foo;
+      let mut _4: &Foo;
+      scope 1 {
+          debug _dead => _2;
+      }
+  
+      bb0: {
+          StorageLive(_2);
+          _3 = deref_copy (_1.1: &Foo);
+-         _2 = &((*_3).2: i32);
++         // DBG: _2 = &((*_3).2: i32);
++         nop;
+          _4 = deref_copy (_1.1: &Foo);
+          _0 = copy ((*_4).0: i32);
+          StorageDead(_2);
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/debuginfo/simplifycfg.drop_debuginfo.SimplifyCfg-final.diff b/tests/mir-opt/debuginfo/simplifycfg.drop_debuginfo.SimplifyCfg-final.diff
new file mode 100644
index 0000000000000..d4a73351ee4a5
--- /dev/null
+++ b/tests/mir-opt/debuginfo/simplifycfg.drop_debuginfo.SimplifyCfg-final.diff
@@ -0,0 +1,26 @@
+- // MIR for `drop_debuginfo` before SimplifyCfg-final
++ // MIR for `drop_debuginfo` after SimplifyCfg-final
+  
+  fn drop_debuginfo(_1: &Foo, _2: bool) -> i32 {
+      debug foo_a => _3;
+      debug foo_b => _4;
+      let mut _0: i32;
+      let mut _3: &i32;
+      let mut _4: &i64;
+  
+      bb0: {
+-         switchInt(copy _2) -> [1: bb1, otherwise: bb2];
+-     }
+- 
+-     bb1: {
+-         // DBG: _3 = &((*_1).0: i32);
+-         goto -> bb2;
+-     }
+- 
+-     bb2: {
+          // DBG: _4 = &((*_1).1: i64);
+          _0 = copy ((*_1).2: i32);
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_1.SimplifyCfg-final.diff b/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_1.SimplifyCfg-final.diff
new file mode 100644
index 0000000000000..1c12358ad8934
--- /dev/null
+++ b/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_1.SimplifyCfg-final.diff
@@ -0,0 +1,30 @@
+- // MIR for `preserve_debuginfo_1` before SimplifyCfg-final
++ // MIR for `preserve_debuginfo_1` after SimplifyCfg-final
+  
+  fn preserve_debuginfo_1(_1: &Foo, _2: &mut bool) -> i32 {
+      debug foo_a => _3;
+      debug foo_b => _4;
+      debug foo_c => _5;
+      let mut _0: i32;
+      let mut _3: &i32;
+      let mut _4: &i64;
+      let mut _5: &i32;
+  
+      bb0: {
+-         goto -> bb1;
+-     }
+- 
+-     bb1: {
+          (*_2) = const true;
+          // DBG: _3 = &((*_1).0: i32);
+-         goto -> bb2;
+-     }
+- 
+-     bb2: {
+          // DBG: _4 = &((*_1).1: i64);
+          _0 = copy ((*_1).2: i32);
+          // DBG: _5 = &((*_1).2: i32);
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_2.SimplifyCfg-final.diff b/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_2.SimplifyCfg-final.diff
new file mode 100644
index 0000000000000..de8e5612c8788
--- /dev/null
+++ b/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_2.SimplifyCfg-final.diff
@@ -0,0 +1,29 @@
+- // MIR for `preserve_debuginfo_2` before SimplifyCfg-final
++ // MIR for `preserve_debuginfo_2` after SimplifyCfg-final
+  
+  fn preserve_debuginfo_2(_1: &Foo) -> i32 {
+      debug foo_a => _2;
+      debug foo_b => _3;
+      debug foo_c => _4;
+      let mut _0: i32;
+      let mut _2: &i32;
+      let mut _3: &i64;
+      let mut _4: &i32;
+  
+      bb0: {
+-         goto -> bb1;
+-     }
+- 
+-     bb1: {
+          // DBG: _2 = &((*_1).0: i32);
+-         goto -> bb2;
+-     }
+- 
+-     bb2: {
+          // DBG: _3 = &((*_1).1: i64);
+          _0 = copy ((*_1).2: i32);
+          // DBG: _4 = &((*_1).2: i32);
+          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 f6c111a2228a9..f7729c7c5fa6d 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
@@ -16,10 +16,12 @@
 +             let mut _9: *mut A;
 +             let mut _10: usize;
 +             scope 3 (inlined Vec::<A>::as_mut_ptr) {
++                 let mut _11: &alloc::raw_vec::RawVec<A>;
 +                 scope 4 (inlined alloc::raw_vec::RawVec::<A>::ptr) {
++                     let mut _12: &alloc::raw_vec::RawVecInner;
 +                     scope 5 (inlined alloc::raw_vec::RawVecInner::ptr::<A>) {
 +                         scope 6 (inlined alloc::raw_vec::RawVecInner::non_null::<A>) {
-+                             let mut _11: std::ptr::NonNull<u8>;
++                             let mut _13: std::ptr::NonNull<u8>;
 +                             scope 7 (inlined Unique::<u8>::cast::<A>) {
 +                                 scope 8 (inlined NonNull::<u8>::cast::<A>) {
 +                                     scope 9 (inlined NonNull::<u8>::as_ptr) {
@@ -39,15 +41,15 @@
 +                 }
 +             }
 +             scope 14 (inlined drop_in_place::<[A]> - shim(Some([A]))) {
-+                 let mut _12: usize;
-+                 let mut _13: *mut A;
-+                 let mut _14: bool;
++                 let mut _14: usize;
++                 let mut _15: *mut A;
++                 let mut _16: bool;
 +             }
 +         }
 +     }
 +     scope 15 (inlined drop_in_place::<Option<B>> - shim(Some(Option<B>))) {
-+         let mut _15: isize;
-+         let mut _16: isize;
++         let mut _17: isize;
++         let mut _18: isize;
 +     }
   
       bb0: {
@@ -62,16 +64,22 @@
 +         StorageLive(_8);
 +         StorageLive(_9);
 +         StorageLive(_11);
-+         _11 = copy (((((*_6).0: alloc::raw_vec::RawVec<A>).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique<u8>).0: std::ptr::NonNull<u8>);
-+         _9 = copy _11 as *mut A (Transmute);
++         // DBG: _11 = &((*_6).0: alloc::raw_vec::RawVec<A>);
++         StorageLive(_12);
++         // DBG: _12 = &(((*_6).0: alloc::raw_vec::RawVec<A>).0: alloc::raw_vec::RawVecInner);
++         StorageLive(_13);
++         _13 = copy (((((*_6).0: alloc::raw_vec::RawVec<A>).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique<u8>).0: std::ptr::NonNull<u8>);
++         _9 = copy _13 as *mut A (Transmute);
++         StorageDead(_13);
++         StorageDead(_12);
 +         StorageDead(_11);
 +         _10 = copy ((*_6).1: usize);
 +         _8 = *mut [A] from (copy _9, copy _10);
 +         StorageDead(_9);
-+         StorageLive(_12);
-+         StorageLive(_13);
 +         StorageLive(_14);
-+         _12 = const 0_usize;
++         StorageLive(_15);
++         StorageLive(_16);
++         _14 = const 0_usize;
 +         goto -> bb4;
       }
   
@@ -83,35 +91,35 @@
           StorageLive(_5);
           _5 = copy _2;
 -         _0 = drop_in_place::<Option<B>>(move _5) -> [return: bb2, unwind unreachable];
-+         StorageLive(_15);
-+         StorageLive(_16);
-+         _15 = discriminant((*_5));
-+         switchInt(move _15) -> [0: bb5, otherwise: bb6];
++         StorageLive(_17);
++         StorageLive(_18);
++         _17 = discriminant((*_5));
++         switchInt(move _17) -> [0: bb5, otherwise: bb6];
       }
   
       bb2: {
++         StorageDead(_16);
++         StorageDead(_15);
 +         StorageDead(_14);
-+         StorageDead(_13);
-+         StorageDead(_12);
 +         StorageDead(_8);
 +         StorageDead(_10);
 +         drop(((*_4).0: alloc::raw_vec::RawVec<A>)) -> [return: bb1, unwind unreachable];
 +     }
 + 
 +     bb3: {
-+         _13 = &raw mut (*_8)[_12];
-+         _12 = Add(move _12, const 1_usize);
-+         drop((*_13)) -> [return: bb4, unwind unreachable];
++         _15 = &raw mut (*_8)[_14];
++         _14 = Add(move _14, const 1_usize);
++         drop((*_15)) -> [return: bb4, unwind unreachable];
 +     }
 + 
 +     bb4: {
-+         _14 = Eq(copy _12, copy _10);
-+         switchInt(move _14) -> [0: bb3, otherwise: bb2];
++         _16 = Eq(copy _14, copy _10);
++         switchInt(move _16) -> [0: bb3, otherwise: bb2];
 +     }
 + 
 +     bb5: {
-+         StorageDead(_16);
-+         StorageDead(_15);
++         StorageDead(_18);
++         StorageDead(_17);
           StorageDead(_5);
           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 2ae86e2eb8bbd..649b5a652027d 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
@@ -228,12 +228,12 @@
 +         StorageLive(_41);
 +         StorageLive(_42);
 +         StorageLive(_43);
-+         _45 = &mut _19;
++         // DBG: _45 = &_19;
 +         StorageLive(_46);
-+         _46 = &mut (_19.0: &mut std::future::Ready<()>);
++         // DBG: _46 = &(_19.0: &mut std::future::Ready<()>);
 +         _44 = copy (_19.0: &mut std::future::Ready<()>);
 +         StorageDead(_46);
-+         _43 = &mut ((*_44).0: std::option::Option<()>);
++         // DBG: _43 = &((*_44).0: std::option::Option<()>);
 +         StorageLive(_47);
 +         _47 = Option::<()>::None;
 +         _42 = copy ((*_44).0: std::option::Option<()>);
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 d7ae931aaae58..32021b20ef44b 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
@@ -245,12 +245,12 @@
 +         StorageLive(_43);
 +         StorageLive(_44);
 +         StorageLive(_45);
-+         _47 = &mut _19;
++         // DBG: _47 = &_19;
 +         StorageLive(_48);
-+         _48 = &mut (_19.0: &mut std::future::Ready<()>);
++         // DBG: _48 = &(_19.0: &mut std::future::Ready<()>);
 +         _46 = copy (_19.0: &mut std::future::Ready<()>);
 +         StorageDead(_48);
-+         _45 = &mut ((*_46).0: std::option::Option<()>);
++         // DBG: _45 = &((*_46).0: std::option::Option<()>);
 +         StorageLive(_49);
 +         _49 = Option::<()>::None;
 +         _44 = copy ((*_46).0: std::option::Option<()>);
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 5cf36b9aebf2f..a294c1b4588db 100644
--- a/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff
+++ b/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff
@@ -34,11 +34,11 @@
   
       bb2: {
           StorageLive(_5);
-          _5 = &(*_2)[0 of 3];
+          // DBG: _5 = &(*_2)[0 of 3];
           StorageLive(_6);
-          _6 = &(*_2)[1 of 3];
+          // DBG: _6 = &(*_2)[1 of 3];
           StorageLive(_7);
-          _7 = &(*_2)[2 of 3];
+          // DBG: _7 = &(*_2)[2 of 3];
           StorageDead(_7);
           StorageDead(_6);
           StorageDead(_5);
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 0598a3aa3f19a..691271cf94edf 100644
--- a/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff
+++ b/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff
@@ -34,11 +34,11 @@
   
       bb2: {
           StorageLive(_5);
-          _5 = &(*_2)[0 of 3];
+          // DBG: _5 = &(*_2)[0 of 3];
           StorageLive(_6);
-          _6 = &(*_2)[1 of 3];
+          // DBG: _6 = &(*_2)[1 of 3];
           StorageLive(_7);
-          _7 = &(*_2)[2 of 3];
+          // DBG: _7 = &(*_2)[2 of 3];
           StorageDead(_7);
           StorageDead(_6);
           StorageDead(_5);
diff --git a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.32bit.panic-abort.mir b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.32bit.panic-abort.mir
index b5c23822162c9..d4248f5d87fbc 100644
--- a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.32bit.panic-abort.mir
+++ b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.32bit.panic-abort.mir
@@ -6,6 +6,7 @@ fn num_to_digit(_1: char) -> u32 {
     let mut _4: std::option::Option<u32>;
     scope 1 (inlined char::methods::<impl char>::is_digit) {
         let _2: std::option::Option<u32>;
+        let mut _7: &std::option::Option<u32>;
         scope 2 (inlined Option::<u32>::is_some) {
             let mut _3: isize;
             scope 3 {
@@ -20,14 +21,17 @@ fn num_to_digit(_1: char) -> u32 {
     }
 
     bb0: {
+        StorageLive(_7);
         StorageLive(_2);
         _2 = char::methods::<impl char>::to_digit(copy _1, const 8_u32) -> [return: bb1, unwind unreachable];
     }
 
     bb1: {
+        // DBG: _7 = &_2;
         StorageLive(_3);
         _3 = discriminant(_2);
         StorageDead(_2);
+        StorageDead(_7);
         switchInt(move _3) -> [1: bb2, otherwise: bb7];
     }
 
diff --git a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.32bit.panic-unwind.mir b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.32bit.panic-unwind.mir
index f22b8835735d1..a834932df5a82 100644
--- a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.32bit.panic-unwind.mir
+++ b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.32bit.panic-unwind.mir
@@ -6,6 +6,7 @@ fn num_to_digit(_1: char) -> u32 {
     let mut _4: std::option::Option<u32>;
     scope 1 (inlined char::methods::<impl char>::is_digit) {
         let _2: std::option::Option<u32>;
+        let mut _7: &std::option::Option<u32>;
         scope 2 (inlined Option::<u32>::is_some) {
             let mut _3: isize;
             scope 3 {
@@ -20,14 +21,17 @@ fn num_to_digit(_1: char) -> u32 {
     }
 
     bb0: {
+        StorageLive(_7);
         StorageLive(_2);
         _2 = char::methods::<impl char>::to_digit(copy _1, const 8_u32) -> [return: bb1, unwind continue];
     }
 
     bb1: {
+        // DBG: _7 = &_2;
         StorageLive(_3);
         _3 = discriminant(_2);
         StorageDead(_2);
+        StorageDead(_7);
         switchInt(move _3) -> [1: bb2, otherwise: bb7];
     }
 
diff --git a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.64bit.panic-abort.mir b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.64bit.panic-abort.mir
index b5c23822162c9..d4248f5d87fbc 100644
--- a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.64bit.panic-abort.mir
+++ b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.64bit.panic-abort.mir
@@ -6,6 +6,7 @@ fn num_to_digit(_1: char) -> u32 {
     let mut _4: std::option::Option<u32>;
     scope 1 (inlined char::methods::<impl char>::is_digit) {
         let _2: std::option::Option<u32>;
+        let mut _7: &std::option::Option<u32>;
         scope 2 (inlined Option::<u32>::is_some) {
             let mut _3: isize;
             scope 3 {
@@ -20,14 +21,17 @@ fn num_to_digit(_1: char) -> u32 {
     }
 
     bb0: {
+        StorageLive(_7);
         StorageLive(_2);
         _2 = char::methods::<impl char>::to_digit(copy _1, const 8_u32) -> [return: bb1, unwind unreachable];
     }
 
     bb1: {
+        // DBG: _7 = &_2;
         StorageLive(_3);
         _3 = discriminant(_2);
         StorageDead(_2);
+        StorageDead(_7);
         switchInt(move _3) -> [1: bb2, otherwise: bb7];
     }
 
diff --git a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.64bit.panic-unwind.mir b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.64bit.panic-unwind.mir
index f22b8835735d1..a834932df5a82 100644
--- a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.64bit.panic-unwind.mir
+++ b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.64bit.panic-unwind.mir
@@ -6,6 +6,7 @@ fn num_to_digit(_1: char) -> u32 {
     let mut _4: std::option::Option<u32>;
     scope 1 (inlined char::methods::<impl char>::is_digit) {
         let _2: std::option::Option<u32>;
+        let mut _7: &std::option::Option<u32>;
         scope 2 (inlined Option::<u32>::is_some) {
             let mut _3: isize;
             scope 3 {
@@ -20,14 +21,17 @@ fn num_to_digit(_1: char) -> u32 {
     }
 
     bb0: {
+        StorageLive(_7);
         StorageLive(_2);
         _2 = char::methods::<impl char>::to_digit(copy _1, const 8_u32) -> [return: bb1, unwind continue];
     }
 
     bb1: {
+        // DBG: _7 = &_2;
         StorageLive(_3);
         _3 = discriminant(_2);
         StorageDead(_2);
+        StorageDead(_7);
         switchInt(move _3) -> [1: bb2, otherwise: bb7];
     }
 
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 83478e60b5d4e..23dbc066dd528 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
@@ -5,7 +5,9 @@ fn step_forward(_1: u16, _2: usize) -> u16 {
     debug n => _2;
     let mut _0: u16;
     scope 1 (inlined <u16 as Step>::forward) {
-        let mut _8: u16;
+        let _8: std::option::Option<u16>;
+        let mut _10: u16;
+        let mut _11: &std::option::Option<u16>;
         scope 2 {
         }
         scope 3 (inlined <u16 as Step>::forward_checked) {
@@ -13,8 +15,9 @@ fn step_forward(_1: u16, _2: usize) -> u16 {
                 scope 6 (inlined core::num::<impl u16>::checked_add) {
                     let mut _5: (u16, bool);
                     let mut _6: bool;
+                    let mut _7: u16;
                     scope 7 (inlined std::intrinsics::unlikely) {
-                        let _7: ();
+                        let _9: ();
                     }
                 }
             }
@@ -35,6 +38,8 @@ fn step_forward(_1: u16, _2: usize) -> u16 {
 
     bb0: {
         StorageLive(_4);
+        StorageLive(_11);
+        StorageLive(_8);
         StorageLive(_3);
         _3 = Gt(copy _2, const 65535_usize);
         switchInt(move _3) -> [0: bb1, otherwise: bb5];
@@ -53,34 +58,55 @@ fn step_forward(_1: u16, _2: usize) -> u16 {
     bb2: {
         StorageDead(_5);
         StorageDead(_6);
+        StorageLive(_7);
+        _7 = AddUnchecked(copy _1, copy _4);
+        _8 = Option::<u16>::Some(move _7);
+        StorageDead(_7);
+        // DBG: _11 = &_8;
+        StorageDead(_8);
+        StorageDead(_11);
         goto -> bb7;
     }
 
     bb3: {
-        _7 = std::intrinsics::cold_path() -> [return: bb4, unwind unreachable];
+        _9 = std::intrinsics::cold_path() -> [return: bb4, unwind unreachable];
     }
 
     bb4: {
         StorageDead(_5);
         StorageDead(_6);
+        _8 = const Option::<u16>::None;
+        // DBG: _11 = &_8;
         goto -> bb6;
     }
 
     bb5: {
         StorageDead(_3);
+        _8 = const Option::<u16>::None;
+        // DBG: _11 = &_8;
         goto -> bb6;
     }
 
     bb6: {
+        StorageDead(_8);
+        StorageDead(_11);
         assert(!const true, "attempt to compute `{} + {}`, which would overflow", const core::num::<impl u16>::MAX, const 1_u16) -> [success: bb7, unwind unreachable];
     }
 
     bb7: {
-        StorageLive(_8);
-        _8 = copy _2 as u16 (IntToInt);
-        _0 = Add(copy _1, copy _8);
-        StorageDead(_8);
+        StorageLive(_10);
+        _10 = copy _2 as u16 (IntToInt);
+        _0 = Add(copy _1, copy _10);
+        StorageDead(_10);
         StorageDead(_4);
         return;
     }
 }
+
+ALLOC0 (size: 4, align: 2) {
+    00 00 __ __                                     │ ..░░
+}
+
+ALLOC1 (size: 4, align: 2) {
+    00 00 __ __                                     │ ..░░
+}
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 ac7a6e0445191..ac15f070597ea 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
@@ -5,7 +5,9 @@ fn step_forward(_1: u16, _2: usize) -> u16 {
     debug n => _2;
     let mut _0: u16;
     scope 1 (inlined <u16 as Step>::forward) {
-        let mut _8: u16;
+        let _8: std::option::Option<u16>;
+        let mut _10: u16;
+        let mut _11: &std::option::Option<u16>;
         scope 2 {
         }
         scope 3 (inlined <u16 as Step>::forward_checked) {
@@ -13,8 +15,9 @@ fn step_forward(_1: u16, _2: usize) -> u16 {
                 scope 6 (inlined core::num::<impl u16>::checked_add) {
                     let mut _5: (u16, bool);
                     let mut _6: bool;
+                    let mut _7: u16;
                     scope 7 (inlined std::intrinsics::unlikely) {
-                        let _7: ();
+                        let _9: ();
                     }
                 }
             }
@@ -35,6 +38,8 @@ fn step_forward(_1: u16, _2: usize) -> u16 {
 
     bb0: {
         StorageLive(_4);
+        StorageLive(_11);
+        StorageLive(_8);
         StorageLive(_3);
         _3 = Gt(copy _2, const 65535_usize);
         switchInt(move _3) -> [0: bb1, otherwise: bb5];
@@ -53,34 +58,55 @@ fn step_forward(_1: u16, _2: usize) -> u16 {
     bb2: {
         StorageDead(_5);
         StorageDead(_6);
+        StorageLive(_7);
+        _7 = AddUnchecked(copy _1, copy _4);
+        _8 = Option::<u16>::Some(move _7);
+        StorageDead(_7);
+        // DBG: _11 = &_8;
+        StorageDead(_8);
+        StorageDead(_11);
         goto -> bb7;
     }
 
     bb3: {
-        _7 = std::intrinsics::cold_path() -> [return: bb4, unwind unreachable];
+        _9 = std::intrinsics::cold_path() -> [return: bb4, unwind unreachable];
     }
 
     bb4: {
         StorageDead(_5);
         StorageDead(_6);
+        _8 = const Option::<u16>::None;
+        // DBG: _11 = &_8;
         goto -> bb6;
     }
 
     bb5: {
         StorageDead(_3);
+        _8 = const Option::<u16>::None;
+        // DBG: _11 = &_8;
         goto -> bb6;
     }
 
     bb6: {
+        StorageDead(_8);
+        StorageDead(_11);
         assert(!const true, "attempt to compute `{} + {}`, which would overflow", const core::num::<impl u16>::MAX, const 1_u16) -> [success: bb7, unwind continue];
     }
 
     bb7: {
-        StorageLive(_8);
-        _8 = copy _2 as u16 (IntToInt);
-        _0 = Add(copy _1, copy _8);
-        StorageDead(_8);
+        StorageLive(_10);
+        _10 = copy _2 as u16 (IntToInt);
+        _0 = Add(copy _1, copy _10);
+        StorageDead(_10);
         StorageDead(_4);
         return;
     }
 }
+
+ALLOC0 (size: 4, align: 2) {
+    00 00 __ __                                     │ ..░░
+}
+
+ALLOC1 (size: 4, align: 2) {
+    00 00 __ __                                     │ ..░░
+}
diff --git a/tests/mir-opt/pre-codegen/clone_as_copy.clone_as_copy.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/clone_as_copy.clone_as_copy.PreCodegen.after.mir
index 34747e5a92854..66239a0ef6637 100644
--- a/tests/mir-opt/pre-codegen/clone_as_copy.clone_as_copy.PreCodegen.after.mir
+++ b/tests/mir-opt/pre-codegen/clone_as_copy.clone_as_copy.PreCodegen.after.mir
@@ -13,7 +13,7 @@ fn clone_as_copy(_1: &NestCopy) -> NestCopy {
 
     bb0: {
         StorageLive(_2);
-        _2 = &((*_1).1: AllCopy);
+        // DBG: _2 = &((*_1).1: AllCopy);
         _0 = copy (*_1);
         StorageDead(_2);
         return;
diff --git a/tests/mir-opt/pre-codegen/clone_as_copy.enum_clone_as_copy.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/clone_as_copy.enum_clone_as_copy.PreCodegen.after.mir
index e67f362ee04ae..aa03cec070ad3 100644
--- a/tests/mir-opt/pre-codegen/clone_as_copy.enum_clone_as_copy.PreCodegen.after.mir
+++ b/tests/mir-opt/pre-codegen/clone_as_copy.enum_clone_as_copy.PreCodegen.after.mir
@@ -35,15 +35,15 @@ fn enum_clone_as_copy(_1: &Enum1) -> Enum1 {
     }
 
     bb1: {
-        _3 = &(((*_1) as A).0: AllCopy);
+        // DBG: _3 = &(((*_1) as A).0: AllCopy);
         _0 = copy (*_1);
         goto -> bb3;
     }
 
     bb2: {
-        _4 = &(((*_1) as B).0: NestCopy);
+        // DBG: _4 = &(((*_1) as B).0: NestCopy);
         StorageLive(_5);
-        _5 = &((((*_1) as B).0: NestCopy).1: AllCopy);
+        // DBG: _5 = &((((*_1) as B).0: NestCopy).1: AllCopy);
         StorageDead(_5);
         _0 = copy (*_1);
         goto -> bb3;
diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-abort.mir b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-abort.mir
index ba6ce0ee5286f..0dd2125dbe0d2 100644
--- a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-abort.mir
@@ -8,9 +8,10 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
             let _2: std::ptr::NonNull<[T]>;
             let mut _3: *mut [T];
             let mut _4: *const [T];
-            let _11: ();
+            let _12: ();
+            let mut _13: &std::alloc::Layout;
             scope 3 {
-                let _8: std::ptr::alignment::AlignmentEnum;
+                let _8: std::alloc::Layout;
                 scope 4 {
                     scope 12 (inlined Layout::size) {
                     }
@@ -26,15 +27,19 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
                     }
                     scope 18 (inlined <std::alloc::Global as Allocator>::deallocate) {
                         let mut _9: *mut u8;
+                        let mut _14: &std::alloc::Layout;
                         scope 19 (inlined Layout::size) {
                         }
                         scope 20 (inlined NonNull::<u8>::as_ptr) {
                         }
                         scope 21 (inlined std::alloc::dealloc) {
-                            let mut _10: usize;
+                            let mut _11: usize;
+                            let mut _15: &std::alloc::Layout;
+                            let mut _16: &std::alloc::Layout;
                             scope 22 (inlined Layout::size) {
                             }
                             scope 23 (inlined Layout::align) {
+                                let mut _10: std::ptr::alignment::AlignmentEnum;
                                 scope 24 (inlined std::ptr::Alignment::as_usize) {
                                 }
                             }
@@ -63,6 +68,7 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
     }
 
     bb0: {
+        StorageLive(_8);
         StorageLive(_2);
         _2 = copy (((*_1).0: std::ptr::Unique<[T]>).0: std::ptr::NonNull<[T]>);
         StorageLive(_4);
@@ -74,31 +80,45 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
 
     bb1: {
         _6 = AlignOf(T);
-        StorageLive(_7);
         _7 = copy _6 as std::ptr::Alignment (Transmute);
-        _8 = move (_7.0: std::ptr::alignment::AlignmentEnum);
-        StorageDead(_7);
+        _8 = Layout { size: copy _5, align: copy _7 };
         StorageDead(_6);
         StorageDead(_4);
+        StorageLive(_13);
+        // DBG: _13 = &_8;
+        StorageDead(_13);
         switchInt(copy _5) -> [0: bb4, otherwise: bb2];
     }
 
     bb2: {
+        StorageLive(_14);
+        // DBG: _14 = &_8;
+        StorageDead(_14);
         StorageLive(_9);
         _9 = copy _3 as *mut u8 (PtrToPtr);
+        StorageLive(_15);
+        // DBG: _15 = &_8;
+        StorageDead(_15);
+        StorageLive(_11);
+        StorageLive(_16);
+        // DBG: _16 = &_8;
         StorageLive(_10);
-        _10 = discriminant(_8);
-        _11 = alloc::alloc::__rust_dealloc(move _9, move _5, move _10) -> [return: bb3, unwind unreachable];
+        _10 = copy (_7.0: std::ptr::alignment::AlignmentEnum);
+        _11 = discriminant(_10);
+        StorageDead(_10);
+        StorageDead(_16);
+        _12 = alloc::alloc::__rust_dealloc(move _9, move _5, move _11) -> [return: bb3, unwind unreachable];
     }
 
     bb3: {
-        StorageDead(_10);
+        StorageDead(_11);
         StorageDead(_9);
         goto -> bb4;
     }
 
     bb4: {
         StorageDead(_2);
+        StorageDead(_8);
         return;
     }
 }
diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-unwind.mir b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-unwind.mir
index ba6ce0ee5286f..0dd2125dbe0d2 100644
--- a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-unwind.mir
@@ -8,9 +8,10 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
             let _2: std::ptr::NonNull<[T]>;
             let mut _3: *mut [T];
             let mut _4: *const [T];
-            let _11: ();
+            let _12: ();
+            let mut _13: &std::alloc::Layout;
             scope 3 {
-                let _8: std::ptr::alignment::AlignmentEnum;
+                let _8: std::alloc::Layout;
                 scope 4 {
                     scope 12 (inlined Layout::size) {
                     }
@@ -26,15 +27,19 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
                     }
                     scope 18 (inlined <std::alloc::Global as Allocator>::deallocate) {
                         let mut _9: *mut u8;
+                        let mut _14: &std::alloc::Layout;
                         scope 19 (inlined Layout::size) {
                         }
                         scope 20 (inlined NonNull::<u8>::as_ptr) {
                         }
                         scope 21 (inlined std::alloc::dealloc) {
-                            let mut _10: usize;
+                            let mut _11: usize;
+                            let mut _15: &std::alloc::Layout;
+                            let mut _16: &std::alloc::Layout;
                             scope 22 (inlined Layout::size) {
                             }
                             scope 23 (inlined Layout::align) {
+                                let mut _10: std::ptr::alignment::AlignmentEnum;
                                 scope 24 (inlined std::ptr::Alignment::as_usize) {
                                 }
                             }
@@ -63,6 +68,7 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
     }
 
     bb0: {
+        StorageLive(_8);
         StorageLive(_2);
         _2 = copy (((*_1).0: std::ptr::Unique<[T]>).0: std::ptr::NonNull<[T]>);
         StorageLive(_4);
@@ -74,31 +80,45 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
 
     bb1: {
         _6 = AlignOf(T);
-        StorageLive(_7);
         _7 = copy _6 as std::ptr::Alignment (Transmute);
-        _8 = move (_7.0: std::ptr::alignment::AlignmentEnum);
-        StorageDead(_7);
+        _8 = Layout { size: copy _5, align: copy _7 };
         StorageDead(_6);
         StorageDead(_4);
+        StorageLive(_13);
+        // DBG: _13 = &_8;
+        StorageDead(_13);
         switchInt(copy _5) -> [0: bb4, otherwise: bb2];
     }
 
     bb2: {
+        StorageLive(_14);
+        // DBG: _14 = &_8;
+        StorageDead(_14);
         StorageLive(_9);
         _9 = copy _3 as *mut u8 (PtrToPtr);
+        StorageLive(_15);
+        // DBG: _15 = &_8;
+        StorageDead(_15);
+        StorageLive(_11);
+        StorageLive(_16);
+        // DBG: _16 = &_8;
         StorageLive(_10);
-        _10 = discriminant(_8);
-        _11 = alloc::alloc::__rust_dealloc(move _9, move _5, move _10) -> [return: bb3, unwind unreachable];
+        _10 = copy (_7.0: std::ptr::alignment::AlignmentEnum);
+        _11 = discriminant(_10);
+        StorageDead(_10);
+        StorageDead(_16);
+        _12 = alloc::alloc::__rust_dealloc(move _9, move _5, move _11) -> [return: bb3, unwind unreachable];
     }
 
     bb3: {
-        StorageDead(_10);
+        StorageDead(_11);
         StorageDead(_9);
         goto -> bb4;
     }
 
     bb4: {
         StorageDead(_2);
+        StorageDead(_8);
         return;
     }
 }
diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-abort.mir b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-abort.mir
index ba6ce0ee5286f..0dd2125dbe0d2 100644
--- a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-abort.mir
@@ -8,9 +8,10 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
             let _2: std::ptr::NonNull<[T]>;
             let mut _3: *mut [T];
             let mut _4: *const [T];
-            let _11: ();
+            let _12: ();
+            let mut _13: &std::alloc::Layout;
             scope 3 {
-                let _8: std::ptr::alignment::AlignmentEnum;
+                let _8: std::alloc::Layout;
                 scope 4 {
                     scope 12 (inlined Layout::size) {
                     }
@@ -26,15 +27,19 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
                     }
                     scope 18 (inlined <std::alloc::Global as Allocator>::deallocate) {
                         let mut _9: *mut u8;
+                        let mut _14: &std::alloc::Layout;
                         scope 19 (inlined Layout::size) {
                         }
                         scope 20 (inlined NonNull::<u8>::as_ptr) {
                         }
                         scope 21 (inlined std::alloc::dealloc) {
-                            let mut _10: usize;
+                            let mut _11: usize;
+                            let mut _15: &std::alloc::Layout;
+                            let mut _16: &std::alloc::Layout;
                             scope 22 (inlined Layout::size) {
                             }
                             scope 23 (inlined Layout::align) {
+                                let mut _10: std::ptr::alignment::AlignmentEnum;
                                 scope 24 (inlined std::ptr::Alignment::as_usize) {
                                 }
                             }
@@ -63,6 +68,7 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
     }
 
     bb0: {
+        StorageLive(_8);
         StorageLive(_2);
         _2 = copy (((*_1).0: std::ptr::Unique<[T]>).0: std::ptr::NonNull<[T]>);
         StorageLive(_4);
@@ -74,31 +80,45 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
 
     bb1: {
         _6 = AlignOf(T);
-        StorageLive(_7);
         _7 = copy _6 as std::ptr::Alignment (Transmute);
-        _8 = move (_7.0: std::ptr::alignment::AlignmentEnum);
-        StorageDead(_7);
+        _8 = Layout { size: copy _5, align: copy _7 };
         StorageDead(_6);
         StorageDead(_4);
+        StorageLive(_13);
+        // DBG: _13 = &_8;
+        StorageDead(_13);
         switchInt(copy _5) -> [0: bb4, otherwise: bb2];
     }
 
     bb2: {
+        StorageLive(_14);
+        // DBG: _14 = &_8;
+        StorageDead(_14);
         StorageLive(_9);
         _9 = copy _3 as *mut u8 (PtrToPtr);
+        StorageLive(_15);
+        // DBG: _15 = &_8;
+        StorageDead(_15);
+        StorageLive(_11);
+        StorageLive(_16);
+        // DBG: _16 = &_8;
         StorageLive(_10);
-        _10 = discriminant(_8);
-        _11 = alloc::alloc::__rust_dealloc(move _9, move _5, move _10) -> [return: bb3, unwind unreachable];
+        _10 = copy (_7.0: std::ptr::alignment::AlignmentEnum);
+        _11 = discriminant(_10);
+        StorageDead(_10);
+        StorageDead(_16);
+        _12 = alloc::alloc::__rust_dealloc(move _9, move _5, move _11) -> [return: bb3, unwind unreachable];
     }
 
     bb3: {
-        StorageDead(_10);
+        StorageDead(_11);
         StorageDead(_9);
         goto -> bb4;
     }
 
     bb4: {
         StorageDead(_2);
+        StorageDead(_8);
         return;
     }
 }
diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-unwind.mir b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-unwind.mir
index ba6ce0ee5286f..0dd2125dbe0d2 100644
--- a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-unwind.mir
@@ -8,9 +8,10 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
             let _2: std::ptr::NonNull<[T]>;
             let mut _3: *mut [T];
             let mut _4: *const [T];
-            let _11: ();
+            let _12: ();
+            let mut _13: &std::alloc::Layout;
             scope 3 {
-                let _8: std::ptr::alignment::AlignmentEnum;
+                let _8: std::alloc::Layout;
                 scope 4 {
                     scope 12 (inlined Layout::size) {
                     }
@@ -26,15 +27,19 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
                     }
                     scope 18 (inlined <std::alloc::Global as Allocator>::deallocate) {
                         let mut _9: *mut u8;
+                        let mut _14: &std::alloc::Layout;
                         scope 19 (inlined Layout::size) {
                         }
                         scope 20 (inlined NonNull::<u8>::as_ptr) {
                         }
                         scope 21 (inlined std::alloc::dealloc) {
-                            let mut _10: usize;
+                            let mut _11: usize;
+                            let mut _15: &std::alloc::Layout;
+                            let mut _16: &std::alloc::Layout;
                             scope 22 (inlined Layout::size) {
                             }
                             scope 23 (inlined Layout::align) {
+                                let mut _10: std::ptr::alignment::AlignmentEnum;
                                 scope 24 (inlined std::ptr::Alignment::as_usize) {
                                 }
                             }
@@ -63,6 +68,7 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
     }
 
     bb0: {
+        StorageLive(_8);
         StorageLive(_2);
         _2 = copy (((*_1).0: std::ptr::Unique<[T]>).0: std::ptr::NonNull<[T]>);
         StorageLive(_4);
@@ -74,31 +80,45 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
 
     bb1: {
         _6 = AlignOf(T);
-        StorageLive(_7);
         _7 = copy _6 as std::ptr::Alignment (Transmute);
-        _8 = move (_7.0: std::ptr::alignment::AlignmentEnum);
-        StorageDead(_7);
+        _8 = Layout { size: copy _5, align: copy _7 };
         StorageDead(_6);
         StorageDead(_4);
+        StorageLive(_13);
+        // DBG: _13 = &_8;
+        StorageDead(_13);
         switchInt(copy _5) -> [0: bb4, otherwise: bb2];
     }
 
     bb2: {
+        StorageLive(_14);
+        // DBG: _14 = &_8;
+        StorageDead(_14);
         StorageLive(_9);
         _9 = copy _3 as *mut u8 (PtrToPtr);
+        StorageLive(_15);
+        // DBG: _15 = &_8;
+        StorageDead(_15);
+        StorageLive(_11);
+        StorageLive(_16);
+        // DBG: _16 = &_8;
         StorageLive(_10);
-        _10 = discriminant(_8);
-        _11 = alloc::alloc::__rust_dealloc(move _9, move _5, move _10) -> [return: bb3, unwind unreachable];
+        _10 = copy (_7.0: std::ptr::alignment::AlignmentEnum);
+        _11 = discriminant(_10);
+        StorageDead(_10);
+        StorageDead(_16);
+        _12 = alloc::alloc::__rust_dealloc(move _9, move _5, move _11) -> [return: bb3, unwind unreachable];
     }
 
     bb3: {
-        StorageDead(_10);
+        StorageDead(_11);
         StorageDead(_9);
         goto -> bb4;
     }
 
     bb4: {
         StorageDead(_2);
+        StorageDead(_8);
         return;
     }
 }
diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.rs b/tests/mir-opt/pre-codegen/drop_boxed_slice.rs
index 9ceba9444b8da..c291366a694e7 100644
--- a/tests/mir-opt/pre-codegen/drop_boxed_slice.rs
+++ b/tests/mir-opt/pre-codegen/drop_boxed_slice.rs
@@ -11,7 +11,7 @@ pub unsafe fn generic_in_place<T: Copy>(ptr: *mut Box<[T]>) {
     // CHECK: [[SIZE:_.+]] = std::intrinsics::size_of_val::<[T]>
     // CHECK: [[ALIGN:_.+]] = AlignOf(T);
     // CHECK: [[B:_.+]] = copy [[ALIGN]] as std::ptr::Alignment (Transmute);
-    // CHECK: [[C:_.+]] = move ([[B]].0: std::ptr::alignment::AlignmentEnum);
+    // CHECK: [[C:_.+]] = copy ([[B]].0: std::ptr::alignment::AlignmentEnum);
     // CHECK: [[D:_.+]] = discriminant([[C]]);
     // CHECK: = alloc::alloc::__rust_dealloc({{.+}}, move [[SIZE]], move [[D]]) ->
     std::ptr::drop_in_place(ptr)
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 75e8cb1d8618c..8f30ad30fccdf 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
@@ -6,20 +6,20 @@ fn filter_mapped(_1: impl Iterator<Item = T>, _2: impl Fn(T) -> Option<U>) -> ()
     let mut _0: ();
     let mut _3: std::iter::FilterMap<impl Iterator<Item = T>, impl Fn(T) -> Option<U>>;
     let mut _4: std::iter::FilterMap<impl Iterator<Item = T>, impl Fn(T) -> Option<U>>;
-    let mut _5: &mut std::iter::FilterMap<impl Iterator<Item = T>, impl Fn(T) -> Option<U>>;
-    let mut _8: std::option::Option<U>;
-    let mut _9: isize;
-    let _11: ();
+    let mut _7: std::option::Option<U>;
+    let mut _8: isize;
+    let _10: ();
+    let mut _11: &mut std::iter::FilterMap<impl Iterator<Item = T>, impl Fn(T) -> Option<U>>;
     scope 1 {
         debug iter => _4;
-        let _10: U;
+        let _9: U;
         scope 2 {
-            debug x => _10;
+            debug x => _9;
         }
         scope 4 (inlined <FilterMap<impl Iterator<Item = T>, impl Fn(T) -> Option<U>> as Iterator>::next) {
-            debug self => _5;
-            let mut _6: &mut impl Iterator<Item = T>;
-            let mut _7: &mut impl Fn(T) -> Option<U>;
+            debug self => _11;
+            let mut _5: &mut impl Iterator<Item = T>;
+            let mut _6: &mut impl Fn(T) -> Option<U>;
         }
     }
     scope 3 (inlined <FilterMap<impl Iterator<Item = T>, impl Fn(T) -> Option<U>> as IntoIterator>::into_iter) {
@@ -37,24 +37,24 @@ fn filter_mapped(_1: impl Iterator<Item = T>, _2: impl Fn(T) -> Option<U>) -> ()
     }
 
     bb2: {
-        StorageLive(_8);
-        _5 = &mut _4;
-        StorageLive(_6);
-        _6 = &mut (_4.0: impl Iterator<Item = T>);
         StorageLive(_7);
-        _7 = &mut (_4.1: impl Fn(T) -> Option<U>);
-        _8 = <impl Iterator<Item = T> as Iterator>::find_map::<U, &mut impl Fn(T) -> Option<U>>(move _6, move _7) -> [return: bb3, unwind: bb9];
+        // DBG: _11 = &_4;
+        StorageLive(_5);
+        _5 = &mut (_4.0: impl Iterator<Item = T>);
+        StorageLive(_6);
+        _6 = &mut (_4.1: impl Fn(T) -> Option<U>);
+        _7 = <impl Iterator<Item = T> as Iterator>::find_map::<U, &mut impl Fn(T) -> Option<U>>(move _5, move _6) -> [return: bb3, unwind: bb9];
     }
 
     bb3: {
-        StorageDead(_7);
         StorageDead(_6);
-        _9 = discriminant(_8);
-        switchInt(move _9) -> [0: bb4, 1: bb6, otherwise: bb8];
+        StorageDead(_5);
+        _8 = discriminant(_7);
+        switchInt(move _8) -> [0: bb4, 1: bb6, otherwise: bb8];
     }
 
     bb4: {
-        StorageDead(_8);
+        StorageDead(_7);
         drop(_4) -> [return: bb5, unwind continue];
     }
 
@@ -64,12 +64,12 @@ fn filter_mapped(_1: impl Iterator<Item = T>, _2: impl Fn(T) -> Option<U>) -> ()
     }
 
     bb6: {
-        _10 = move ((_8 as Some).0: U);
-        _11 = opaque::<U>(move _10) -> [return: bb7, unwind: bb9];
+        _9 = move ((_7 as Some).0: U);
+        _10 = opaque::<U>(move _9) -> [return: bb7, unwind: bb9];
     }
 
     bb7: {
-        StorageDead(_8);
+        StorageDead(_7);
         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 154cbd3791cbd..b1af3141ee610 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
@@ -5,32 +5,31 @@ fn int_range(_1: usize, _2: usize) -> () {
     debug end => _2;
     let mut _0: ();
     let mut _3: std::ops::Range<usize>;
-    let mut _4: std::ops::Range<usize>;
-    let mut _5: &mut std::ops::Range<usize>;
-    let mut _13: std::option::Option<usize>;
-    let _15: ();
+    let mut _9: std::option::Option<usize>;
+    let _11: ();
+    let mut _12: &mut std::ops::Range<usize>;
     scope 1 {
-        debug iter => _4;
-        let _14: usize;
+        debug iter => _3;
+        let _10: usize;
         scope 2 {
-            debug i => _14;
+            debug i => _10;
         }
         scope 4 (inlined iter::range::<impl Iterator for std::ops::Range<usize>>::next) {
-            debug self => _5;
+            debug self => _12;
             scope 5 (inlined <std::ops::Range<usize> as iter::range::RangeIteratorImpl>::spec_next) {
-                debug self => _5;
-                let mut _6: &usize;
-                let mut _7: &usize;
-                let mut _10: bool;
-                let _11: usize;
-                let mut _12: usize;
+                debug self => _12;
+                let mut _6: bool;
+                let _7: usize;
+                let mut _8: usize;
+                let mut _13: &usize;
+                let mut _14: &usize;
                 scope 6 {
-                    debug old => _11;
+                    debug old => _7;
                     scope 8 (inlined <usize as Step>::forward_unchecked) {
-                        debug start => _11;
+                        debug start => _7;
                         debug n => const 1_usize;
                         scope 9 (inlined #[track_caller] core::num::<impl usize>::unchecked_add) {
-                            debug self => _11;
+                            debug self => _7;
                             debug rhs => const 1_usize;
                             scope 10 (inlined core::ub_checks::check_language_ub) {
                                 scope 11 (inlined core::ub_checks::check_language_ub::runtime) {
@@ -40,10 +39,10 @@ fn int_range(_1: usize, _2: usize) -> () {
                     }
                 }
                 scope 7 (inlined std::cmp::impls::<impl PartialOrd for usize>::lt) {
-                    debug self => _6;
-                    debug other => _7;
-                    let mut _8: usize;
-                    let mut _9: usize;
+                    debug self => _13;
+                    debug other => _14;
+                    let mut _4: usize;
+                    let mut _5: usize;
                 }
             }
         }
@@ -54,54 +53,51 @@ fn int_range(_1: usize, _2: usize) -> () {
 
     bb0: {
         _3 = std::ops::Range::<usize> { start: copy _1, end: copy _2 };
-        StorageLive(_4);
-        _4 = copy _3;
         goto -> bb1;
     }
 
     bb1: {
-        StorageLive(_13);
-        _5 = &mut _4;
-        StorageLive(_10);
-        StorageLive(_6);
-        _6 = &(_4.0: usize);
-        StorageLive(_7);
-        _7 = &(_4.1: usize);
-        StorageLive(_8);
-        _8 = copy (_4.0: usize);
         StorageLive(_9);
-        _9 = copy (_4.1: usize);
-        _10 = Lt(move _8, move _9);
-        StorageDead(_9);
-        StorageDead(_8);
-        switchInt(move _10) -> [0: bb2, otherwise: bb3];
+        // DBG: _12 = &_3;
+        StorageLive(_6);
+        StorageLive(_13);
+        // DBG: _13 = &(_3.0: usize);
+        StorageLive(_14);
+        // DBG: _14 = &(_3.1: usize);
+        StorageLive(_4);
+        _4 = copy (_3.0: usize);
+        StorageLive(_5);
+        _5 = copy (_3.1: usize);
+        _6 = Lt(move _4, move _5);
+        StorageDead(_5);
+        StorageDead(_4);
+        switchInt(move _6) -> [0: bb2, otherwise: bb3];
     }
 
     bb2: {
-        StorageDead(_7);
-        StorageDead(_6);
-        StorageDead(_10);
+        StorageDead(_14);
         StorageDead(_13);
-        StorageDead(_4);
+        StorageDead(_6);
+        StorageDead(_9);
         return;
     }
 
     bb3: {
-        StorageDead(_7);
+        StorageDead(_14);
+        StorageDead(_13);
+        _7 = copy (_3.0: usize);
+        StorageLive(_8);
+        _8 = AddUnchecked(copy _7, const 1_usize);
+        (_3.0: usize) = move _8;
+        StorageDead(_8);
+        _9 = Option::<usize>::Some(copy _7);
         StorageDead(_6);
-        _11 = copy (_4.0: usize);
-        StorageLive(_12);
-        _12 = AddUnchecked(copy _11, const 1_usize);
-        (_4.0: usize) = move _12;
-        StorageDead(_12);
-        _13 = Option::<usize>::Some(copy _11);
-        StorageDead(_10);
-        _14 = copy ((_13 as Some).0: usize);
-        _15 = opaque::<usize>(move _14) -> [return: bb4, unwind continue];
+        _10 = copy ((_9 as Some).0: usize);
+        _11 = opaque::<usize>(move _10) -> [return: bb4, unwind continue];
     }
 
     bb4: {
-        StorageDead(_13);
+        StorageDead(_9);
         goto -> bb1;
     }
 }
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 d22ea54004c91..406c96fc32f48 100644
--- a/tests/mir-opt/pre-codegen/loops.mapped.PreCodegen.after.mir
+++ b/tests/mir-opt/pre-codegen/loops.mapped.PreCodegen.after.mir
@@ -6,32 +6,32 @@ fn mapped(_1: impl Iterator<Item = T>, _2: impl Fn(T) -> U) -> () {
     let mut _0: ();
     let mut _3: std::iter::Map<impl Iterator<Item = T>, impl Fn(T) -> U>;
     let mut _4: std::iter::Map<impl Iterator<Item = T>, impl Fn(T) -> U>;
-    let mut _5: &mut std::iter::Map<impl Iterator<Item = T>, impl Fn(T) -> U>;
-    let mut _13: std::option::Option<U>;
-    let _15: ();
+    let mut _12: std::option::Option<U>;
+    let _14: ();
+    let mut _15: &mut std::iter::Map<impl Iterator<Item = T>, impl Fn(T) -> U>;
     scope 1 {
         debug iter => _4;
-        let _14: U;
+        let _13: U;
         scope 2 {
-            debug x => _14;
+            debug x => _13;
         }
         scope 4 (inlined <Map<impl Iterator<Item = T>, impl Fn(T) -> U> as Iterator>::next) {
-            debug self => _5;
-            let mut _6: &mut impl Iterator<Item = T>;
-            let mut _7: std::option::Option<T>;
-            let mut _8: &mut impl Fn(T) -> U;
+            debug self => _15;
+            let mut _5: &mut impl Iterator<Item = T>;
+            let mut _6: std::option::Option<T>;
+            let mut _7: &mut impl Fn(T) -> U;
             scope 5 (inlined Option::<T>::map::<U, &mut impl Fn(T) -> U>) {
-                debug self => _7;
-                debug f => _8;
-                let mut _9: isize;
-                let _10: T;
-                let mut _11: (T,);
-                let mut _12: U;
+                debug self => _6;
+                debug f => _7;
+                let mut _8: isize;
+                let _9: T;
+                let mut _10: (T,);
+                let mut _11: U;
                 scope 6 {
-                    debug x => _10;
+                    debug x => _9;
                     scope 7 (inlined ops::function::impls::<impl FnOnce<(T,)> for &mut impl Fn(T) -> U>::call_once) {
-                        debug self => _8;
-                        debug args => _11;
+                        debug self => _7;
+                        debug args => _10;
                     }
                 }
             }
@@ -52,30 +52,30 @@ fn mapped(_1: impl Iterator<Item = T>, _2: impl Fn(T) -> U) -> () {
     }
 
     bb2: {
-        StorageLive(_13);
-        _5 = &mut _4;
-        StorageLive(_8);
+        StorageLive(_12);
+        // DBG: _15 = &_4;
         StorageLive(_7);
         StorageLive(_6);
-        _6 = &mut (_4.0: impl Iterator<Item = T>);
-        _7 = <impl Iterator<Item = T> as Iterator>::next(move _6) -> [return: bb3, unwind: bb10];
+        StorageLive(_5);
+        _5 = &mut (_4.0: impl Iterator<Item = T>);
+        _6 = <impl Iterator<Item = T> as Iterator>::next(move _5) -> [return: bb3, unwind: bb10];
     }
 
     bb3: {
-        StorageDead(_6);
-        _8 = &mut (_4.1: impl Fn(T) -> U);
+        StorageDead(_5);
+        _7 = &mut (_4.1: impl Fn(T) -> U);
+        StorageLive(_8);
         StorageLive(_9);
-        StorageLive(_10);
-        _9 = discriminant(_7);
-        switchInt(move _9) -> [0: bb4, 1: bb6, otherwise: bb9];
+        _8 = discriminant(_6);
+        switchInt(move _8) -> [0: bb4, 1: bb6, otherwise: bb9];
     }
 
     bb4: {
-        StorageDead(_10);
         StorageDead(_9);
-        StorageDead(_7);
         StorageDead(_8);
-        StorageDead(_13);
+        StorageDead(_6);
+        StorageDead(_7);
+        StorageDead(_12);
         drop(_4) -> [return: bb5, unwind continue];
     }
 
@@ -85,27 +85,27 @@ fn mapped(_1: impl Iterator<Item = T>, _2: impl Fn(T) -> U) -> () {
     }
 
     bb6: {
-        _10 = move ((_7 as Some).0: T);
-        StorageLive(_12);
+        _9 = move ((_6 as Some).0: T);
         StorageLive(_11);
-        _11 = (copy _10,);
-        _12 = <impl Fn(T) -> U as FnMut<(T,)>>::call_mut(move _8, move _11) -> [return: bb7, unwind: bb10];
+        StorageLive(_10);
+        _10 = (copy _9,);
+        _11 = <impl Fn(T) -> U as FnMut<(T,)>>::call_mut(move _7, move _10) -> [return: bb7, unwind: bb10];
     }
 
     bb7: {
-        StorageDead(_11);
-        _13 = Option::<U>::Some(move _12);
-        StorageDead(_12);
         StorageDead(_10);
+        _12 = Option::<U>::Some(move _11);
+        StorageDead(_11);
         StorageDead(_9);
-        StorageDead(_7);
         StorageDead(_8);
-        _14 = move ((_13 as Some).0: U);
-        _15 = opaque::<U>(move _14) -> [return: bb8, unwind: bb10];
+        StorageDead(_6);
+        StorageDead(_7);
+        _13 = move ((_12 as Some).0: U);
+        _14 = opaque::<U>(move _13) -> [return: bb8, unwind: bb10];
     }
 
     bb8: {
-        StorageDead(_13);
+        StorageDead(_12);
         goto -> bb2;
     }
 
diff --git a/tests/mir-opt/pre-codegen/loops.rs b/tests/mir-opt/pre-codegen/loops.rs
index d0b8cc8db7a90..952dd8cac60fd 100644
--- a/tests/mir-opt/pre-codegen/loops.rs
+++ b/tests/mir-opt/pre-codegen/loops.rs
@@ -1,5 +1,6 @@
 // skip-filecheck
 //@ compile-flags: -O -Zmir-opt-level=2 -g
+//@ ignore-std-debug-assertions (debug assertions result in different inlines)
 //@ needs-unwind
 
 #![crate_type = "lib"]
diff --git a/tests/mir-opt/pre-codegen/loops.vec_move.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/loops.vec_move.PreCodegen.after.mir
index e537dd6a28ef8..03cdc221c3086 100644
--- a/tests/mir-opt/pre-codegen/loops.vec_move.PreCodegen.after.mir
+++ b/tests/mir-opt/pre-codegen/loops.vec_move.PreCodegen.after.mir
@@ -3,72 +3,354 @@
 fn vec_move(_1: Vec<impl Sized>) -> () {
     debug v => _1;
     let mut _0: ();
-    let mut _2: std::vec::IntoIter<impl Sized>;
-    let mut _3: std::vec::IntoIter<impl Sized>;
-    let mut _4: &mut std::vec::IntoIter<impl Sized>;
-    let mut _5: std::option::Option<impl Sized>;
-    let mut _6: isize;
-    let _8: ();
+    let mut _22: std::vec::IntoIter<impl Sized>;
+    let mut _23: std::vec::IntoIter<impl Sized>;
+    let mut _24: &mut std::vec::IntoIter<impl Sized>;
+    let mut _25: std::option::Option<impl Sized>;
+    let mut _26: isize;
+    let _28: ();
     scope 1 {
-        debug iter => _3;
-        let _7: impl Sized;
+        debug iter => _23;
+        let _27: impl Sized;
         scope 2 {
-            debug x => _7;
+            debug x => _27;
+        }
+    }
+    scope 3 (inlined <Vec<impl Sized> as IntoIterator>::into_iter) {
+        debug self => _1;
+        let _2: std::mem::ManuallyDrop<std::vec::Vec<impl Sized>>;
+        let mut _3: *const std::alloc::Global;
+        let mut _8: usize;
+        let mut _10: *mut impl Sized;
+        let mut _11: *const impl Sized;
+        let mut _12: usize;
+        let _29: &std::vec::Vec<impl Sized>;
+        let mut _30: &std::mem::ManuallyDrop<std::vec::Vec<impl Sized>>;
+        let mut _31: &alloc::raw_vec::RawVec<impl Sized>;
+        let mut _32: &std::mem::ManuallyDrop<std::vec::Vec<impl Sized>>;
+        let _33: &std::vec::Vec<impl Sized>;
+        let mut _34: &std::mem::ManuallyDrop<std::vec::Vec<impl Sized>>;
+        let _35: &std::vec::Vec<impl Sized>;
+        let mut _36: &std::mem::ManuallyDrop<std::vec::Vec<impl Sized>>;
+        let mut _37: &alloc::raw_vec::RawVec<impl Sized>;
+        let mut _38: &std::mem::ManuallyDrop<std::vec::Vec<impl Sized>>;
+        scope 4 {
+            debug me => _2;
+            scope 5 {
+                debug alloc => const ManuallyDrop::<std::alloc::Global> {{ value: std::alloc::Global }};
+                let _6: std::ptr::NonNull<impl Sized>;
+                scope 6 {
+                    debug buf => _6;
+                    let _7: *mut impl Sized;
+                    scope 7 {
+                        debug begin => _7;
+                        scope 8 {
+                            debug end => _11;
+                            let _20: usize;
+                            scope 9 {
+                                debug cap => _20;
+                            }
+                            scope 39 (inlined <ManuallyDrop<Vec<impl Sized>> as Deref>::deref) {
+                                debug self => _38;
+                            }
+                            scope 40 (inlined alloc::raw_vec::RawVec::<impl Sized>::capacity) {
+                                debug self => _37;
+                                let mut _19: usize;
+                                let mut _42: &alloc::raw_vec::RawVecInner;
+                                scope 41 (inlined std::mem::size_of::<impl Sized>) {
+                                }
+                                scope 42 (inlined alloc::raw_vec::RawVecInner::capacity) {
+                                    debug self => _42;
+                                    debug elem_size => _19;
+                                    let mut _21: core::num::niche_types::UsizeNoHighBit;
+                                    scope 43 (inlined core::num::niche_types::UsizeNoHighBit::as_inner) {
+                                        debug self => _21;
+                                    }
+                                }
+                            }
+                        }
+                        scope 25 (inlined <ManuallyDrop<Vec<impl Sized>> as Deref>::deref) {
+                            debug self => _34;
+                        }
+                        scope 26 (inlined Vec::<impl Sized>::len) {
+                            debug self => _33;
+                            let mut _13: bool;
+                            scope 27 {
+                            }
+                        }
+                        scope 28 (inlined std::ptr::mut_ptr::<impl *mut impl Sized>::wrapping_byte_add) {
+                            debug self => _7;
+                            debug count => _12;
+                            let mut _14: *mut u8;
+                            let mut _18: *mut u8;
+                            scope 29 (inlined std::ptr::mut_ptr::<impl *mut impl Sized>::cast::<u8>) {
+                                debug self => _7;
+                            }
+                            scope 30 (inlined std::ptr::mut_ptr::<impl *mut u8>::wrapping_add) {
+                                debug self => _14;
+                                debug count => _12;
+                                let mut _15: isize;
+                                scope 31 (inlined std::ptr::mut_ptr::<impl *mut u8>::wrapping_offset) {
+                                    debug self => _14;
+                                    debug count => _15;
+                                    let mut _16: *const u8;
+                                    let mut _17: *const u8;
+                                }
+                            }
+                            scope 32 (inlined std::ptr::mut_ptr::<impl *mut u8>::with_metadata_of::<impl Sized>) {
+                                debug self => _18;
+                                debug meta => _5;
+                                scope 33 (inlined std::ptr::metadata::<impl Sized>) {
+                                    debug ptr => _5;
+                                }
+                                scope 34 (inlined std::ptr::from_raw_parts_mut::<impl Sized, ()>) {
+                                }
+                            }
+                        }
+                        scope 35 (inlined <ManuallyDrop<Vec<impl Sized>> as Deref>::deref) {
+                            debug self => _36;
+                        }
+                        scope 36 (inlined Vec::<impl Sized>::len) {
+                            debug self => _35;
+                            let mut _9: bool;
+                            scope 37 {
+                            }
+                        }
+                        scope 38 (inlined #[track_caller] std::ptr::mut_ptr::<impl *mut impl Sized>::add) {
+                            debug self => _7;
+                            debug count => _8;
+                        }
+                    }
+                    scope 24 (inlined NonNull::<impl Sized>::as_ptr) {
+                        debug self => _6;
+                    }
+                }
+                scope 17 (inlined <ManuallyDrop<Vec<impl Sized>> as Deref>::deref) {
+                    debug self => _32;
+                }
+                scope 18 (inlined alloc::raw_vec::RawVec::<impl Sized>::non_null) {
+                    debug self => _31;
+                    let mut _41: &alloc::raw_vec::RawVecInner;
+                    scope 19 (inlined alloc::raw_vec::RawVecInner::non_null::<impl Sized>) {
+                        let mut _4: std::ptr::NonNull<u8>;
+                        scope 20 (inlined Unique::<u8>::cast::<impl Sized>) {
+                            scope 21 (inlined NonNull::<u8>::cast::<impl Sized>) {
+                                let mut _5: *const impl Sized;
+                                scope 22 (inlined NonNull::<u8>::as_ptr) {
+                                }
+                            }
+                        }
+                        scope 23 (inlined Unique::<impl Sized>::as_non_null_ptr) {
+                        }
+                    }
+                }
+            }
+            scope 11 (inlined <ManuallyDrop<Vec<impl Sized>> as Deref>::deref) {
+                debug self => _30;
+            }
+            scope 12 (inlined Vec::<impl Sized>::allocator) {
+                debug self => _29;
+                let mut _39: &alloc::raw_vec::RawVec<impl Sized>;
+                scope 13 (inlined alloc::raw_vec::RawVec::<impl Sized>::allocator) {
+                    let mut _40: &alloc::raw_vec::RawVecInner;
+                    scope 14 (inlined alloc::raw_vec::RawVecInner::allocator) {
+                    }
+                }
+            }
+            scope 15 (inlined #[track_caller] std::ptr::read::<std::alloc::Global>) {
+                debug src => _3;
+            }
+            scope 16 (inlined ManuallyDrop::<std::alloc::Global>::new) {
+                debug value => const std::alloc::Global;
+            }
+        }
+        scope 10 (inlined ManuallyDrop::<Vec<impl Sized>>::new) {
+            debug value => _1;
         }
     }
 
     bb0: {
+        StorageLive(_22);
+        StorageLive(_29);
+        StorageLive(_6);
+        StorageLive(_7);
+        StorageLive(_33);
+        StorageLive(_11);
+        StorageLive(_35);
+        StorageLive(_20);
+        StorageLive(_5);
+        StorageLive(_4);
+        StorageLive(_17);
         StorageLive(_2);
-        _2 = <Vec<impl Sized> as IntoIterator>::into_iter(move _1) -> [return: bb1, unwind continue];
+        _2 = ManuallyDrop::<Vec<impl Sized>> { value: copy _1 };
+        StorageLive(_3);
+        StorageLive(_30);
+        // DBG: _30 = &_2;
+        // DBG: _29 = &(_2.0: std::vec::Vec<impl Sized>);
+        StorageDead(_30);
+        StorageLive(_39);
+        // DBG: _39 = &((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>);
+        StorageLive(_40);
+        // DBG: _40 = &(((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>).0: alloc::raw_vec::RawVecInner);
+        StorageDead(_40);
+        StorageDead(_39);
+        _3 = &raw const ((((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>).0: alloc::raw_vec::RawVecInner).2: std::alloc::Global);
+        StorageDead(_3);
+        StorageLive(_31);
+        StorageLive(_32);
+        // DBG: _32 = &_2;
+        StorageDead(_32);
+        // DBG: _31 = &((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>);
+        StorageLive(_41);
+        // DBG: _41 = &(((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>).0: alloc::raw_vec::RawVecInner);
+        _4 = copy (((((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique<u8>).0: std::ptr::NonNull<u8>);
+        _5 = copy _4 as *const impl Sized (Transmute);
+        _6 = NonNull::<impl Sized> { pointer: copy _5 };
+        StorageDead(_41);
+        StorageDead(_31);
+        _7 = copy _4 as *mut impl Sized (Transmute);
+        switchInt(const <impl Sized as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
     }
 
     bb1: {
-        StorageLive(_3);
-        _3 = move _2;
-        goto -> bb2;
+        StorageLive(_10);
+        StorageLive(_8);
+        StorageLive(_36);
+        // DBG: _36 = &_2;
+        // DBG: _35 = &(_2.0: std::vec::Vec<impl Sized>);
+        StorageDead(_36);
+        _8 = copy ((_2.0: std::vec::Vec<impl Sized>).1: usize);
+        StorageLive(_9);
+        _9 = Le(copy _8, const <impl Sized as std::mem::SizedTypeProperties>::MAX_SLICE_LEN);
+        assume(move _9);
+        StorageDead(_9);
+        _10 = Offset(copy _7, copy _8);
+        _11 = copy _10 as *const impl Sized (PtrToPtr);
+        StorageDead(_8);
+        StorageDead(_10);
+        goto -> bb4;
     }
 
     bb2: {
-        StorageLive(_5);
-        _4 = &mut _3;
-        _5 = <std::vec::IntoIter<impl Sized> as Iterator>::next(move _4) -> [return: bb3, unwind: bb9];
+        StorageLive(_12);
+        StorageLive(_34);
+        // DBG: _34 = &_2;
+        // DBG: _33 = &(_2.0: std::vec::Vec<impl Sized>);
+        StorageDead(_34);
+        _12 = copy ((_2.0: std::vec::Vec<impl Sized>).1: usize);
+        StorageLive(_13);
+        _13 = Le(copy _12, const <impl Sized as std::mem::SizedTypeProperties>::MAX_SLICE_LEN);
+        assume(move _13);
+        StorageDead(_13);
+        StorageLive(_18);
+        StorageLive(_14);
+        _14 = copy _4 as *mut u8 (Transmute);
+        StorageLive(_15);
+        _15 = copy _12 as isize (IntToInt);
+        StorageLive(_16);
+        _16 = copy _4 as *const u8 (Transmute);
+        _17 = arith_offset::<u8>(move _16, move _15) -> [return: bb3, unwind unreachable];
     }
 
     bb3: {
-        _6 = discriminant(_5);
-        switchInt(move _6) -> [0: bb4, 1: bb6, otherwise: bb8];
+        StorageDead(_16);
+        _18 = copy _17 as *mut u8 (PtrToPtr);
+        StorageDead(_15);
+        StorageDead(_14);
+        StorageDead(_18);
+        StorageDead(_12);
+        _11 = copy _17 as *const impl Sized (PtrToPtr);
+        goto -> bb4;
     }
 
     bb4: {
-        StorageDead(_5);
-        drop(_3) -> [return: bb5, unwind continue];
+        StorageLive(_37);
+        StorageLive(_38);
+        // DBG: _38 = &_2;
+        StorageDead(_38);
+        // DBG: _37 = &((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>);
+        StorageLive(_42);
+        // DBG: _42 = &(((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>).0: alloc::raw_vec::RawVecInner);
+        StorageLive(_19);
+        _19 = SizeOf(impl Sized);
+        switchInt(move _19) -> [0: bb5, otherwise: bb6];
     }
 
     bb5: {
-        StorageDead(_3);
-        StorageDead(_2);
-        return;
+        _20 = const usize::MAX;
+        goto -> bb7;
     }
 
     bb6: {
-        _7 = move ((_5 as Some).0: impl Sized);
-        _8 = opaque::<impl Sized>(move _7) -> [return: bb7, unwind: bb9];
+        StorageLive(_21);
+        _21 = copy ((((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>).0: alloc::raw_vec::RawVecInner).1: core::num::niche_types::UsizeNoHighBit);
+        _20 = copy _21 as usize (Transmute);
+        StorageDead(_21);
+        goto -> bb7;
     }
 
     bb7: {
+        StorageDead(_19);
+        StorageDead(_42);
+        StorageDead(_37);
+        _22 = std::vec::IntoIter::<impl Sized> { buf: copy _6, phantom: const ZeroSized: PhantomData<impl Sized>, cap: move _20, alloc: const ManuallyDrop::<std::alloc::Global> {{ value: std::alloc::Global }}, ptr: copy _6, end: copy _11 };
+        StorageDead(_2);
+        StorageDead(_17);
+        StorageDead(_4);
         StorageDead(_5);
-        goto -> bb2;
+        StorageDead(_20);
+        StorageDead(_35);
+        StorageDead(_11);
+        StorageDead(_33);
+        StorageDead(_7);
+        StorageDead(_6);
+        StorageDead(_29);
+        StorageLive(_23);
+        _23 = move _22;
+        goto -> bb8;
     }
 
     bb8: {
+        StorageLive(_25);
+        _24 = &mut _23;
+        _25 = <std::vec::IntoIter<impl Sized> as Iterator>::next(move _24) -> [return: bb9, unwind: bb15];
+    }
+
+    bb9: {
+        _26 = discriminant(_25);
+        switchInt(move _26) -> [0: bb10, 1: bb12, otherwise: bb14];
+    }
+
+    bb10: {
+        StorageDead(_25);
+        drop(_23) -> [return: bb11, unwind continue];
+    }
+
+    bb11: {
+        StorageDead(_23);
+        StorageDead(_22);
+        return;
+    }
+
+    bb12: {
+        _27 = move ((_25 as Some).0: impl Sized);
+        _28 = opaque::<impl Sized>(move _27) -> [return: bb13, unwind: bb15];
+    }
+
+    bb13: {
+        StorageDead(_25);
+        goto -> bb8;
+    }
+
+    bb14: {
         unreachable;
     }
 
-    bb9 (cleanup): {
-        drop(_3) -> [return: bb10, unwind terminate(cleanup)];
+    bb15 (cleanup): {
+        drop(_23) -> [return: bb16, unwind terminate(cleanup)];
     }
 
-    bb10 (cleanup): {
+    bb16 (cleanup): {
         resume;
     }
 }
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 cbdd194afd3ab..9d4bacef954ef 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
@@ -3,183 +3,164 @@
 fn variant_a::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:7:25: 7:39}, _2: &&(usize, usize, usize, usize)) -> bool {
     let mut _0: bool;
     let mut _3: &(usize, usize, usize, usize);
-    let _4: &usize;
-    let _5: &usize;
-    let _6: &usize;
-    let _7: &usize;
-    let mut _8: &&usize;
-    let _9: &usize;
-    let mut _10: &&usize;
-    let mut _13: bool;
-    let mut _14: &&usize;
+    let mut _6: bool;
+    let mut _9: bool;
+    let mut _10: bool;
+    let _13: &usize;
+    let _14: &usize;
     let _15: &usize;
-    let mut _16: &&usize;
-    let mut _19: bool;
+    let _16: &usize;
+    let mut _17: &&usize;
+    let mut _18: &&usize;
+    let mut _19: &&usize;
     let mut _20: &&usize;
-    let _21: &usize;
+    let mut _21: &&usize;
     let mut _22: &&usize;
-    let mut _23: bool;
+    let mut _23: &&usize;
     let mut _24: &&usize;
-    let _25: &usize;
-    let mut _26: &&usize;
     scope 1 {
-        debug a => _4;
-        debug b => _5;
-        debug c => _6;
-        debug d => _7;
+        debug a => _13;
+        debug b => _14;
+        debug c => _15;
+        debug d => _16;
         scope 2 (inlined std::cmp::impls::<impl PartialOrd for &usize>::le) {
-            debug self => _8;
-            debug other => _10;
+            debug self => _17;
+            debug other => _18;
             scope 3 (inlined std::cmp::impls::<impl PartialOrd for usize>::le) {
-                debug self => _4;
-                debug other => _6;
-                let mut _11: usize;
-                let mut _12: usize;
+                debug self => _13;
+                debug other => _15;
+                let mut _4: usize;
+                let mut _5: usize;
             }
         }
         scope 4 (inlined std::cmp::impls::<impl PartialOrd for &usize>::le) {
-            debug self => _14;
-            debug other => _16;
+            debug self => _19;
+            debug other => _20;
             scope 5 (inlined std::cmp::impls::<impl PartialOrd for usize>::le) {
-                debug self => _7;
-                debug other => _5;
-                let mut _17: usize;
-                let mut _18: usize;
+                debug self => _16;
+                debug other => _14;
+                let mut _7: usize;
+                let mut _8: usize;
             }
         }
         scope 6 (inlined std::cmp::impls::<impl PartialOrd for &usize>::le) {
-            debug self => _20;
+            debug self => _21;
             debug other => _22;
             scope 7 (inlined std::cmp::impls::<impl PartialOrd for usize>::le) {
-                debug self => _6;
-                debug other => _4;
+                debug self => _15;
+                debug other => _13;
             }
         }
         scope 8 (inlined std::cmp::impls::<impl PartialOrd for &usize>::le) {
-            debug self => _24;
-            debug other => _26;
+            debug self => _23;
+            debug other => _24;
             scope 9 (inlined std::cmp::impls::<impl PartialOrd for usize>::le) {
-                debug self => _5;
-                debug other => _7;
-                let mut _27: usize;
-                let mut _28: usize;
+                debug self => _14;
+                debug other => _16;
+                let mut _11: usize;
+                let mut _12: usize;
             }
         }
     }
 
     bb0: {
         _3 = copy (*_2);
-        _4 = &((*_3).0: usize);
-        _5 = &((*_3).1: usize);
-        _6 = &((*_3).2: usize);
-        _7 = &((*_3).3: usize);
-        StorageLive(_13);
-        StorageLive(_8);
-        _8 = &_4;
-        StorageLive(_10);
-        StorageLive(_9);
-        _9 = copy _6;
-        _10 = &_9;
-        _11 = copy ((*_3).0: usize);
-        _12 = copy ((*_3).2: usize);
-        _13 = Le(copy _11, copy _12);
-        switchInt(move _13) -> [0: bb1, otherwise: bb2];
+        // DBG: _13 = &((*_3).0: usize);
+        // DBG: _14 = &((*_3).1: usize);
+        // DBG: _15 = &((*_3).2: usize);
+        // DBG: _16 = &((*_3).3: usize);
+        StorageLive(_6);
+        StorageLive(_17);
+        // DBG: _17 = &_13;
+        StorageLive(_18);
+        // DBG: _18 = &_15;
+        _4 = copy ((*_3).0: usize);
+        _5 = copy ((*_3).2: usize);
+        _6 = Le(copy _4, copy _5);
+        switchInt(move _6) -> [0: bb1, otherwise: bb2];
     }
 
     bb1: {
-        StorageDead(_9);
-        StorageDead(_10);
-        StorageDead(_8);
+        StorageDead(_18);
+        StorageDead(_17);
         goto -> bb4;
     }
 
     bb2: {
-        StorageDead(_9);
-        StorageDead(_10);
-        StorageDead(_8);
-        StorageLive(_19);
-        StorageLive(_14);
-        _14 = &_7;
-        StorageLive(_16);
-        StorageLive(_15);
-        _15 = copy _5;
-        _16 = &_15;
-        StorageLive(_17);
-        _17 = copy ((*_3).3: usize);
-        StorageLive(_18);
-        _18 = copy ((*_3).1: usize);
-        _19 = Le(move _17, move _18);
         StorageDead(_18);
         StorageDead(_17);
-        switchInt(move _19) -> [0: bb3, otherwise: bb8];
+        StorageLive(_9);
+        StorageLive(_19);
+        // DBG: _19 = &_16;
+        StorageLive(_20);
+        // DBG: _20 = &_14;
+        StorageLive(_7);
+        _7 = copy ((*_3).3: usize);
+        StorageLive(_8);
+        _8 = copy ((*_3).1: usize);
+        _9 = Le(move _7, move _8);
+        StorageDead(_8);
+        StorageDead(_7);
+        switchInt(move _9) -> [0: bb3, otherwise: bb8];
     }
 
     bb3: {
-        StorageDead(_15);
-        StorageDead(_16);
-        StorageDead(_14);
+        StorageDead(_20);
+        StorageDead(_19);
         goto -> bb4;
     }
 
     bb4: {
-        StorageLive(_23);
-        StorageLive(_20);
-        _20 = &_6;
-        StorageLive(_22);
+        StorageLive(_10);
         StorageLive(_21);
-        _21 = copy _4;
-        _22 = &_21;
-        _23 = Le(copy _12, copy _11);
-        switchInt(move _23) -> [0: bb5, otherwise: bb6];
+        // DBG: _21 = &_15;
+        StorageLive(_22);
+        // DBG: _22 = &_13;
+        _10 = Le(copy _5, copy _4);
+        switchInt(move _10) -> [0: bb5, otherwise: bb6];
     }
 
     bb5: {
-        StorageDead(_21);
         StorageDead(_22);
-        StorageDead(_20);
+        StorageDead(_21);
         _0 = const false;
         goto -> bb7;
     }
 
     bb6: {
-        StorageDead(_21);
         StorageDead(_22);
-        StorageDead(_20);
+        StorageDead(_21);
+        StorageLive(_23);
+        // DBG: _23 = &_14;
         StorageLive(_24);
-        _24 = &_5;
-        StorageLive(_26);
-        StorageLive(_25);
-        _25 = copy _7;
-        _26 = &_25;
-        StorageLive(_27);
-        _27 = copy ((*_3).1: usize);
-        StorageLive(_28);
-        _28 = copy ((*_3).3: usize);
-        _0 = Le(move _27, move _28);
-        StorageDead(_28);
-        StorageDead(_27);
-        StorageDead(_25);
-        StorageDead(_26);
+        // DBG: _24 = &_16;
+        StorageLive(_11);
+        _11 = copy ((*_3).1: usize);
+        StorageLive(_12);
+        _12 = copy ((*_3).3: usize);
+        _0 = Le(move _11, move _12);
+        StorageDead(_12);
+        StorageDead(_11);
         StorageDead(_24);
+        StorageDead(_23);
         goto -> bb7;
     }
 
     bb7: {
-        StorageDead(_23);
+        StorageDead(_10);
         goto -> bb9;
     }
 
     bb8: {
-        StorageDead(_15);
-        StorageDead(_16);
-        StorageDead(_14);
+        StorageDead(_20);
+        StorageDead(_19);
         _0 = const true;
         goto -> bb9;
     }
 
     bb9: {
-        StorageDead(_19);
-        StorageDead(_13);
+        StorageDead(_9);
+        StorageDead(_6);
         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 104987b0fdda9..1b2e7b7163cd8 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
@@ -51,6 +51,9 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
                 let mut _16: bool;
                 let mut _20: usize;
                 let _22: &T;
+                let mut _34: &std::ptr::NonNull<T>;
+                let mut _35: &std::ptr::NonNull<T>;
+                let mut _36: &std::ptr::NonNull<T>;
                 scope 29 {
                     let _12: *const T;
                     scope 30 {
@@ -186,7 +189,11 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
 
     bb5: {
         StorageLive(_16);
+        StorageLive(_34);
+        // DBG: _34 = &_11;
+        StorageLive(_35);
         _13 = copy _12 as std::ptr::NonNull<T> (Transmute);
+        // DBG: _35 = &_13;
         StorageLive(_14);
         _14 = copy _11 as *mut T (Transmute);
         StorageLive(_15);
@@ -198,6 +205,8 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb6: {
+        StorageDead(_35);
+        StorageDead(_34);
         StorageDead(_16);
         StorageLive(_18);
         StorageLive(_17);
@@ -210,6 +219,8 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb7: {
+        StorageDead(_35);
+        StorageDead(_34);
         StorageDead(_16);
         StorageDead(_22);
         StorageDead(_13);
@@ -255,10 +266,13 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb13: {
+        StorageLive(_36);
+        // DBG: _36 = &_11;
         StorageLive(_21);
         _21 = copy _11 as *const T (Transmute);
         _22 = &(*_21);
         StorageDead(_21);
+        StorageDead(_36);
         _23 = Option::<&T>::Some(copy _22);
         StorageDead(_22);
         StorageDead(_13);
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 4d0e3548e7d6b..c18dd01a189ad 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
@@ -23,6 +23,9 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
             let mut _15: bool;
             let mut _19: usize;
             let _21: &T;
+            let mut _27: &std::ptr::NonNull<T>;
+            let mut _28: &std::ptr::NonNull<T>;
+            let mut _29: &std::ptr::NonNull<T>;
             scope 17 {
                 let _11: *const T;
                 scope 18 {
@@ -148,7 +151,11 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
 
     bb5: {
         StorageLive(_15);
+        StorageLive(_27);
+        // DBG: _27 = &_10;
+        StorageLive(_28);
         _12 = copy _11 as std::ptr::NonNull<T> (Transmute);
+        // DBG: _28 = &_12;
         StorageLive(_13);
         _13 = copy _10 as *mut T (Transmute);
         StorageLive(_14);
@@ -160,6 +167,8 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb6: {
+        StorageDead(_28);
+        StorageDead(_27);
         StorageDead(_15);
         StorageLive(_17);
         StorageLive(_16);
@@ -172,6 +181,8 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb7: {
+        StorageDead(_28);
+        StorageDead(_27);
         StorageDead(_15);
         StorageDead(_21);
         StorageDead(_12);
@@ -213,10 +224,13 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb13: {
+        StorageLive(_29);
+        // DBG: _29 = &_10;
         StorageLive(_20);
         _20 = copy _10 as *const T (Transmute);
         _21 = &(*_20);
         StorageDead(_20);
+        StorageDead(_29);
         _22 = Option::<&T>::Some(copy _21);
         StorageDead(_21);
         StorageDead(_12);
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 2b5d8c27d7109..6334c611430ad 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
@@ -23,6 +23,9 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
             let mut _15: bool;
             let mut _19: usize;
             let _21: &T;
+            let mut _27: &std::ptr::NonNull<T>;
+            let mut _28: &std::ptr::NonNull<T>;
+            let mut _29: &std::ptr::NonNull<T>;
             scope 17 {
                 let _11: *const T;
                 scope 18 {
@@ -148,7 +151,11 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
 
     bb5: {
         StorageLive(_15);
+        StorageLive(_27);
+        // DBG: _27 = &_10;
+        StorageLive(_28);
         _12 = copy _11 as std::ptr::NonNull<T> (Transmute);
+        // DBG: _28 = &_12;
         StorageLive(_13);
         _13 = copy _10 as *mut T (Transmute);
         StorageLive(_14);
@@ -160,6 +167,8 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb6: {
+        StorageDead(_28);
+        StorageDead(_27);
         StorageDead(_15);
         StorageLive(_17);
         StorageLive(_16);
@@ -172,6 +181,8 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb7: {
+        StorageDead(_28);
+        StorageDead(_27);
         StorageDead(_15);
         StorageDead(_21);
         StorageDead(_12);
@@ -213,10 +224,13 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb13: {
+        StorageLive(_29);
+        // DBG: _29 = &_10;
         StorageLive(_20);
         _20 = copy _10 as *const T (Transmute);
         _21 = &(*_20);
         StorageDead(_20);
+        StorageDead(_29);
         _22 = Option::<&T>::Some(copy _21);
         StorageDead(_21);
         StorageDead(_12);
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 0adf268d766dd..24c6618d31cae 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
@@ -7,19 +7,90 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     let mut _10: std::slice::Iter<'_, T>;
     let mut _11: std::iter::Rev<std::slice::Iter<'_, T>>;
     let mut _12: std::iter::Rev<std::slice::Iter<'_, T>>;
-    let mut _14: std::option::Option<&T>;
-    let mut _15: isize;
-    let mut _17: &impl Fn(&T);
-    let mut _18: (&T,);
-    let _19: ();
+    let mut _33: std::option::Option<&T>;
+    let mut _35: &impl Fn(&T);
+    let mut _36: (&T,);
+    let _37: ();
     scope 1 {
         debug iter => _12;
-        let _16: &T;
+        let _34: &T;
         scope 2 {
-            debug x => _16;
+            debug x => _34;
         }
         scope 18 (inlined <Rev<std::slice::Iter<'_, T>> as Iterator>::next) {
-            let mut _13: &mut std::slice::Iter<'_, T>;
+            scope 19 (inlined <std::slice::Iter<'_, T> as DoubleEndedIterator>::next_back) {
+                let mut _13: *const T;
+                let mut _18: bool;
+                let mut _19: *const T;
+                let _32: &T;
+                let mut _38: &std::ptr::NonNull<T>;
+                let mut _39: &std::ptr::NonNull<T>;
+                scope 20 {
+                    let _14: std::ptr::NonNull<T>;
+                    let _20: usize;
+                    scope 21 {
+                    }
+                    scope 22 {
+                        scope 25 (inlined <NonNull<T> as PartialEq>::eq) {
+                            let mut _15: std::ptr::NonNull<T>;
+                            let mut _16: *mut T;
+                            let mut _17: *mut T;
+                            scope 26 (inlined NonNull::<T>::as_ptr) {
+                            }
+                            scope 27 (inlined NonNull::<T>::as_ptr) {
+                            }
+                        }
+                    }
+                    scope 23 (inlined std::ptr::const_ptr::<impl *const T>::addr) {
+                        scope 24 (inlined std::ptr::const_ptr::<impl *const T>::cast::<()>) {
+                        }
+                    }
+                }
+                scope 28 (inlined std::slice::Iter::<'_, T>::next_back_unchecked) {
+                    let _26: std::ptr::NonNull<T>;
+                    let mut _40: &std::ptr::NonNull<T>;
+                    scope 29 (inlined std::slice::Iter::<'_, T>::pre_dec_end) {
+                        let mut _21: *mut *const T;
+                        let mut _22: *mut std::ptr::NonNull<T>;
+                        let mut _23: std::ptr::NonNull<T>;
+                        let mut _27: *mut *const T;
+                        let mut _28: *mut usize;
+                        let mut _29: usize;
+                        let mut _30: usize;
+                        scope 30 {
+                            scope 31 {
+                            }
+                            scope 32 {
+                                scope 35 (inlined NonNull::<T>::sub) {
+                                    scope 36 (inlined #[track_caller] core::num::<impl isize>::unchecked_neg) {
+                                        scope 37 (inlined core::ub_checks::check_language_ub) {
+                                            scope 38 (inlined core::ub_checks::check_language_ub::runtime) {
+                                            }
+                                        }
+                                    }
+                                    scope 39 (inlined NonNull::<T>::offset) {
+                                        let mut _24: *const T;
+                                        let mut _25: *const T;
+                                        scope 40 (inlined NonNull::<T>::as_ptr) {
+                                        }
+                                    }
+                                }
+                            }
+                            scope 33 (inlined std::ptr::mut_ptr::<impl *mut *const T>::cast::<usize>) {
+                            }
+                            scope 34 (inlined std::ptr::mut_ptr::<impl *mut *const T>::cast::<NonNull<T>>) {
+                            }
+                        }
+                    }
+                    scope 41 (inlined NonNull::<T>::as_ref::<'_>) {
+                        let _31: *const T;
+                        scope 42 (inlined NonNull::<T>::as_ptr) {
+                        }
+                        scope 43 (inlined std::ptr::mut_ptr::<impl *mut T>::cast_const) {
+                        }
+                    }
+                }
+            }
         }
     }
     scope 3 (inlined core::slice::<impl [T]>::iter) {
@@ -105,45 +176,145 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb4: {
+        StorageLive(_33);
+        StorageLive(_20);
+        StorageLive(_19);
         StorageLive(_14);
-        StorageLive(_13);
-        _13 = &mut (_12.0: std::slice::Iter<'_, T>);
-        _14 = <std::slice::Iter<'_, T> as DoubleEndedIterator>::next_back(move _13) -> [return: bb5, unwind unreachable];
+        StorageLive(_32);
+        StorageLive(_18);
+        switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb5, otherwise: bb6];
     }
 
     bb5: {
+        StorageLive(_13);
+        _13 = copy ((_12.0: std::slice::Iter<'_, T>).1: *const T);
+        _14 = copy _13 as std::ptr::NonNull<T> (Transmute);
         StorageDead(_13);
-        _15 = discriminant(_14);
-        switchInt(move _15) -> [0: bb6, 1: bb8, otherwise: bb10];
+        StorageLive(_38);
+        // DBG: _38 = &((_12.0: std::slice::Iter<'_, T>).0: std::ptr::NonNull<T>);
+        StorageLive(_39);
+        // DBG: _39 = &_14;
+        StorageLive(_16);
+        StorageLive(_15);
+        _15 = copy ((_12.0: std::slice::Iter<'_, T>).0: std::ptr::NonNull<T>);
+        _16 = copy _15 as *mut T (Transmute);
+        StorageDead(_15);
+        StorageLive(_17);
+        _17 = copy _14 as *mut T (Transmute);
+        _18 = Eq(copy _16, copy _17);
+        StorageDead(_17);
+        StorageDead(_16);
+        StorageDead(_39);
+        StorageDead(_38);
+        goto -> bb7;
     }
 
     bb6: {
-        StorageDead(_14);
-        StorageDead(_12);
-        drop(_2) -> [return: bb7, unwind unreachable];
+        _19 = copy ((_12.0: std::slice::Iter<'_, T>).1: *const T);
+        _20 = copy _19 as usize (Transmute);
+        _18 = Eq(copy _20, const 0_usize);
+        goto -> bb7;
     }
 
     bb7: {
-        return;
+        switchInt(move _18) -> [0: bb8, otherwise: bb15];
     }
 
     bb8: {
-        _16 = copy ((_14 as Some).0: &T);
-        StorageLive(_17);
-        _17 = &_2;
-        StorageLive(_18);
-        _18 = (copy _16,);
-        _19 = <impl Fn(&T) as Fn<(&T,)>>::call(move _17, move _18) -> [return: bb9, unwind unreachable];
+        StorageLive(_26);
+        StorageLive(_40);
+        StorageLive(_28);
+        StorageLive(_22);
+        StorageLive(_23);
+        switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb9, otherwise: bb12];
     }
 
     bb9: {
+        StorageLive(_21);
+        _21 = &raw mut ((_12.0: std::slice::Iter<'_, T>).1: *const T);
+        _22 = copy _21 as *mut std::ptr::NonNull<T> (PtrToPtr);
+        StorageDead(_21);
+        _23 = copy (*_22);
+        switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb10, otherwise: bb11];
+    }
+
+    bb10: {
+        StorageLive(_25);
+        StorageLive(_24);
+        _24 = copy _23 as *const T (Transmute);
+        _25 = Offset(copy _24, const -1_isize);
+        StorageDead(_24);
+        _23 = NonNull::<T> { pointer: copy _25 };
+        StorageDead(_25);
+        goto -> bb11;
+    }
+
+    bb11: {
+        (*_22) = move _23;
+        _26 = copy (*_22);
+        goto -> bb13;
+    }
+
+    bb12: {
+        StorageLive(_27);
+        _27 = &raw mut ((_12.0: std::slice::Iter<'_, T>).1: *const T);
+        _28 = copy _27 as *mut usize (PtrToPtr);
+        StorageDead(_27);
+        StorageLive(_30);
+        StorageLive(_29);
+        _29 = copy (*_28);
+        _30 = SubUnchecked(move _29, const 1_usize);
+        StorageDead(_29);
+        (*_28) = move _30;
+        StorageDead(_30);
+        _26 = copy ((_12.0: std::slice::Iter<'_, T>).0: std::ptr::NonNull<T>);
+        goto -> bb13;
+    }
+
+    bb13: {
+        StorageDead(_23);
+        StorageDead(_22);
+        StorageDead(_28);
+        // DBG: _40 = &_26;
+        StorageLive(_31);
+        _31 = copy _26 as *const T (Transmute);
+        _32 = &(*_31);
+        StorageDead(_31);
+        StorageDead(_40);
+        StorageDead(_26);
+        _33 = Option::<&T>::Some(copy _32);
         StorageDead(_18);
-        StorageDead(_17);
+        StorageDead(_32);
         StorageDead(_14);
+        StorageDead(_19);
+        StorageDead(_20);
+        _34 = copy ((_33 as Some).0: &T);
+        StorageLive(_35);
+        _35 = &_2;
+        StorageLive(_36);
+        _36 = (copy _34,);
+        _37 = <impl Fn(&T) as Fn<(&T,)>>::call(move _35, move _36) -> [return: bb14, unwind unreachable];
+    }
+
+    bb14: {
+        StorageDead(_36);
+        StorageDead(_35);
+        StorageDead(_33);
         goto -> bb4;
     }
 
-    bb10: {
-        unreachable;
+    bb15: {
+        StorageDead(_18);
+        StorageDead(_32);
+        StorageDead(_14);
+        StorageDead(_19);
+        StorageDead(_20);
+        StorageDead(_33);
+        StorageDead(_12);
+        drop(_2) -> [return: bb16, unwind unreachable];
+    }
+
+    bb16: {
+        return;
     }
 }
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 cb0d640d445bb..e5c7bcca44b65 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
@@ -7,19 +7,90 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     let mut _10: std::slice::Iter<'_, T>;
     let mut _11: std::iter::Rev<std::slice::Iter<'_, T>>;
     let mut _12: std::iter::Rev<std::slice::Iter<'_, T>>;
-    let mut _14: std::option::Option<&T>;
-    let mut _15: isize;
-    let mut _17: &impl Fn(&T);
-    let mut _18: (&T,);
-    let _19: ();
+    let mut _33: std::option::Option<&T>;
+    let mut _35: &impl Fn(&T);
+    let mut _36: (&T,);
+    let _37: ();
     scope 1 {
         debug iter => _12;
-        let _16: &T;
+        let _34: &T;
         scope 2 {
-            debug x => _16;
+            debug x => _34;
         }
         scope 18 (inlined <Rev<std::slice::Iter<'_, T>> as Iterator>::next) {
-            let mut _13: &mut std::slice::Iter<'_, T>;
+            scope 19 (inlined <std::slice::Iter<'_, T> as DoubleEndedIterator>::next_back) {
+                let mut _13: *const T;
+                let mut _18: bool;
+                let mut _19: *const T;
+                let _32: &T;
+                let mut _38: &std::ptr::NonNull<T>;
+                let mut _39: &std::ptr::NonNull<T>;
+                scope 20 {
+                    let _14: std::ptr::NonNull<T>;
+                    let _20: usize;
+                    scope 21 {
+                    }
+                    scope 22 {
+                        scope 25 (inlined <NonNull<T> as PartialEq>::eq) {
+                            let mut _15: std::ptr::NonNull<T>;
+                            let mut _16: *mut T;
+                            let mut _17: *mut T;
+                            scope 26 (inlined NonNull::<T>::as_ptr) {
+                            }
+                            scope 27 (inlined NonNull::<T>::as_ptr) {
+                            }
+                        }
+                    }
+                    scope 23 (inlined std::ptr::const_ptr::<impl *const T>::addr) {
+                        scope 24 (inlined std::ptr::const_ptr::<impl *const T>::cast::<()>) {
+                        }
+                    }
+                }
+                scope 28 (inlined std::slice::Iter::<'_, T>::next_back_unchecked) {
+                    let _26: std::ptr::NonNull<T>;
+                    let mut _40: &std::ptr::NonNull<T>;
+                    scope 29 (inlined std::slice::Iter::<'_, T>::pre_dec_end) {
+                        let mut _21: *mut *const T;
+                        let mut _22: *mut std::ptr::NonNull<T>;
+                        let mut _23: std::ptr::NonNull<T>;
+                        let mut _27: *mut *const T;
+                        let mut _28: *mut usize;
+                        let mut _29: usize;
+                        let mut _30: usize;
+                        scope 30 {
+                            scope 31 {
+                            }
+                            scope 32 {
+                                scope 35 (inlined NonNull::<T>::sub) {
+                                    scope 36 (inlined #[track_caller] core::num::<impl isize>::unchecked_neg) {
+                                        scope 37 (inlined core::ub_checks::check_language_ub) {
+                                            scope 38 (inlined core::ub_checks::check_language_ub::runtime) {
+                                            }
+                                        }
+                                    }
+                                    scope 39 (inlined NonNull::<T>::offset) {
+                                        let mut _24: *const T;
+                                        let mut _25: *const T;
+                                        scope 40 (inlined NonNull::<T>::as_ptr) {
+                                        }
+                                    }
+                                }
+                            }
+                            scope 33 (inlined std::ptr::mut_ptr::<impl *mut *const T>::cast::<usize>) {
+                            }
+                            scope 34 (inlined std::ptr::mut_ptr::<impl *mut *const T>::cast::<NonNull<T>>) {
+                            }
+                        }
+                    }
+                    scope 41 (inlined NonNull::<T>::as_ref::<'_>) {
+                        let _31: *const T;
+                        scope 42 (inlined NonNull::<T>::as_ptr) {
+                        }
+                        scope 43 (inlined std::ptr::mut_ptr::<impl *mut T>::cast_const) {
+                        }
+                    }
+                }
+            }
         }
     }
     scope 3 (inlined core::slice::<impl [T]>::iter) {
@@ -105,53 +176,153 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb4: {
+        StorageLive(_33);
+        StorageLive(_20);
+        StorageLive(_19);
         StorageLive(_14);
-        StorageLive(_13);
-        _13 = &mut (_12.0: std::slice::Iter<'_, T>);
-        _14 = <std::slice::Iter<'_, T> as DoubleEndedIterator>::next_back(move _13) -> [return: bb5, unwind: bb11];
+        StorageLive(_32);
+        StorageLive(_18);
+        switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb5, otherwise: bb6];
     }
 
     bb5: {
+        StorageLive(_13);
+        _13 = copy ((_12.0: std::slice::Iter<'_, T>).1: *const T);
+        _14 = copy _13 as std::ptr::NonNull<T> (Transmute);
         StorageDead(_13);
-        _15 = discriminant(_14);
-        switchInt(move _15) -> [0: bb6, 1: bb8, otherwise: bb10];
+        StorageLive(_38);
+        // DBG: _38 = &((_12.0: std::slice::Iter<'_, T>).0: std::ptr::NonNull<T>);
+        StorageLive(_39);
+        // DBG: _39 = &_14;
+        StorageLive(_16);
+        StorageLive(_15);
+        _15 = copy ((_12.0: std::slice::Iter<'_, T>).0: std::ptr::NonNull<T>);
+        _16 = copy _15 as *mut T (Transmute);
+        StorageDead(_15);
+        StorageLive(_17);
+        _17 = copy _14 as *mut T (Transmute);
+        _18 = Eq(copy _16, copy _17);
+        StorageDead(_17);
+        StorageDead(_16);
+        StorageDead(_39);
+        StorageDead(_38);
+        goto -> bb7;
     }
 
     bb6: {
-        StorageDead(_14);
-        StorageDead(_12);
-        drop(_2) -> [return: bb7, unwind continue];
+        _19 = copy ((_12.0: std::slice::Iter<'_, T>).1: *const T);
+        _20 = copy _19 as usize (Transmute);
+        _18 = Eq(copy _20, const 0_usize);
+        goto -> bb7;
     }
 
     bb7: {
-        return;
+        switchInt(move _18) -> [0: bb8, otherwise: bb17];
     }
 
     bb8: {
-        _16 = copy ((_14 as Some).0: &T);
-        StorageLive(_17);
-        _17 = &_2;
-        StorageLive(_18);
-        _18 = (copy _16,);
-        _19 = <impl Fn(&T) as Fn<(&T,)>>::call(move _17, move _18) -> [return: bb9, unwind: bb11];
+        StorageLive(_26);
+        StorageLive(_40);
+        StorageLive(_28);
+        StorageLive(_22);
+        StorageLive(_23);
+        switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb9, otherwise: bb12];
     }
 
     bb9: {
+        StorageLive(_21);
+        _21 = &raw mut ((_12.0: std::slice::Iter<'_, T>).1: *const T);
+        _22 = copy _21 as *mut std::ptr::NonNull<T> (PtrToPtr);
+        StorageDead(_21);
+        _23 = copy (*_22);
+        switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb10, otherwise: bb11];
+    }
+
+    bb10: {
+        StorageLive(_25);
+        StorageLive(_24);
+        _24 = copy _23 as *const T (Transmute);
+        _25 = Offset(copy _24, const -1_isize);
+        StorageDead(_24);
+        _23 = NonNull::<T> { pointer: copy _25 };
+        StorageDead(_25);
+        goto -> bb11;
+    }
+
+    bb11: {
+        (*_22) = move _23;
+        _26 = copy (*_22);
+        goto -> bb13;
+    }
+
+    bb12: {
+        StorageLive(_27);
+        _27 = &raw mut ((_12.0: std::slice::Iter<'_, T>).1: *const T);
+        _28 = copy _27 as *mut usize (PtrToPtr);
+        StorageDead(_27);
+        StorageLive(_30);
+        StorageLive(_29);
+        _29 = copy (*_28);
+        _30 = SubUnchecked(move _29, const 1_usize);
+        StorageDead(_29);
+        (*_28) = move _30;
+        StorageDead(_30);
+        _26 = copy ((_12.0: std::slice::Iter<'_, T>).0: std::ptr::NonNull<T>);
+        goto -> bb13;
+    }
+
+    bb13: {
+        StorageDead(_23);
+        StorageDead(_22);
+        StorageDead(_28);
+        // DBG: _40 = &_26;
+        StorageLive(_31);
+        _31 = copy _26 as *const T (Transmute);
+        _32 = &(*_31);
+        StorageDead(_31);
+        StorageDead(_40);
+        StorageDead(_26);
+        _33 = Option::<&T>::Some(copy _32);
         StorageDead(_18);
-        StorageDead(_17);
+        StorageDead(_32);
         StorageDead(_14);
-        goto -> bb4;
+        StorageDead(_19);
+        StorageDead(_20);
+        _34 = copy ((_33 as Some).0: &T);
+        StorageLive(_35);
+        _35 = &_2;
+        StorageLive(_36);
+        _36 = (copy _34,);
+        _37 = <impl Fn(&T) as Fn<(&T,)>>::call(move _35, move _36) -> [return: bb14, unwind: bb15];
     }
 
-    bb10: {
-        unreachable;
+    bb14: {
+        StorageDead(_36);
+        StorageDead(_35);
+        StorageDead(_33);
+        goto -> bb4;
     }
 
-    bb11 (cleanup): {
-        drop(_2) -> [return: bb12, unwind terminate(cleanup)];
+    bb15 (cleanup): {
+        drop(_2) -> [return: bb16, unwind terminate(cleanup)];
     }
 
-    bb12 (cleanup): {
+    bb16 (cleanup): {
         resume;
     }
+
+    bb17: {
+        StorageDead(_18);
+        StorageDead(_32);
+        StorageDead(_14);
+        StorageDead(_19);
+        StorageDead(_20);
+        StorageDead(_33);
+        StorageDead(_12);
+        drop(_2) -> [return: bb18, unwind continue];
+    }
+
+    bb18: {
+        return;
+    }
 }
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 9b510380b10b2..18a3d8e7c4ad3 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
@@ -6,6 +6,8 @@ fn slice_iter_generic_is_empty(_1: &std::slice::Iter<'_, T>) -> bool {
     scope 1 (inlined <std::slice::Iter<'_, T> as ExactSizeIterator>::is_empty) {
         let mut _2: *const T;
         let mut _7: *const T;
+        let mut _9: &std::ptr::NonNull<T>;
+        let mut _10: &std::ptr::NonNull<T>;
         scope 2 {
             let _3: std::ptr::NonNull<T>;
             let _8: usize;
@@ -41,6 +43,10 @@ fn slice_iter_generic_is_empty(_1: &std::slice::Iter<'_, T>) -> bool {
         _2 = copy ((*_1).1: *const T);
         _3 = copy _2 as std::ptr::NonNull<T> (Transmute);
         StorageDead(_2);
+        StorageLive(_9);
+        // DBG: _9 = &((*_1).0: std::ptr::NonNull<T>);
+        StorageLive(_10);
+        // DBG: _10 = &_3;
         StorageLive(_5);
         StorageLive(_4);
         _4 = copy ((*_1).0: std::ptr::NonNull<T>);
@@ -51,6 +57,8 @@ fn slice_iter_generic_is_empty(_1: &std::slice::Iter<'_, T>) -> bool {
         _0 = Eq(copy _5, copy _6);
         StorageDead(_6);
         StorageDead(_5);
+        StorageDead(_10);
+        StorageDead(_9);
         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 9b510380b10b2..18a3d8e7c4ad3 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
@@ -6,6 +6,8 @@ fn slice_iter_generic_is_empty(_1: &std::slice::Iter<'_, T>) -> bool {
     scope 1 (inlined <std::slice::Iter<'_, T> as ExactSizeIterator>::is_empty) {
         let mut _2: *const T;
         let mut _7: *const T;
+        let mut _9: &std::ptr::NonNull<T>;
+        let mut _10: &std::ptr::NonNull<T>;
         scope 2 {
             let _3: std::ptr::NonNull<T>;
             let _8: usize;
@@ -41,6 +43,10 @@ fn slice_iter_generic_is_empty(_1: &std::slice::Iter<'_, T>) -> bool {
         _2 = copy ((*_1).1: *const T);
         _3 = copy _2 as std::ptr::NonNull<T> (Transmute);
         StorageDead(_2);
+        StorageLive(_9);
+        // DBG: _9 = &((*_1).0: std::ptr::NonNull<T>);
+        StorageLive(_10);
+        // DBG: _10 = &_3;
         StorageLive(_5);
         StorageLive(_4);
         _4 = copy ((*_1).0: std::ptr::NonNull<T>);
@@ -51,6 +57,8 @@ fn slice_iter_generic_is_empty(_1: &std::slice::Iter<'_, T>) -> bool {
         _0 = Eq(copy _5, copy _6);
         StorageDead(_6);
         StorageDead(_5);
+        StorageDead(_10);
+        StorageDead(_9);
         goto -> bb3;
     }
 
diff --git a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_mut_next_back.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_mut_next_back.PreCodegen.after.panic-abort.mir
index 78f96bf419559..590d4ac2c8381 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_mut_next_back.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_mut_next_back.PreCodegen.after.panic-abort.mir
@@ -3,12 +3,199 @@
 fn slice_iter_mut_next_back(_1: &mut std::slice::IterMut<'_, T>) -> Option<&mut T> {
     debug it => _1;
     let mut _0: std::option::Option<&mut T>;
+    scope 1 (inlined <std::slice::IterMut<'_, T> as DoubleEndedIterator>::next_back) {
+        let mut _2: *mut T;
+        let mut _7: bool;
+        let mut _8: *mut T;
+        let mut _21: &mut T;
+        let mut _22: &std::ptr::NonNull<T>;
+        let mut _23: &std::ptr::NonNull<T>;
+        scope 2 {
+            let _3: std::ptr::NonNull<T>;
+            let _9: usize;
+            scope 3 {
+            }
+            scope 4 {
+                scope 7 (inlined <NonNull<T> as PartialEq>::eq) {
+                    let mut _4: std::ptr::NonNull<T>;
+                    let mut _5: *mut T;
+                    let mut _6: *mut T;
+                    scope 8 (inlined NonNull::<T>::as_ptr) {
+                    }
+                    scope 9 (inlined NonNull::<T>::as_ptr) {
+                    }
+                }
+            }
+            scope 5 (inlined std::ptr::mut_ptr::<impl *mut T>::addr) {
+                scope 6 (inlined std::ptr::mut_ptr::<impl *mut T>::cast::<()>) {
+                }
+            }
+        }
+        scope 10 (inlined std::slice::IterMut::<'_, T>::next_back_unchecked) {
+            let mut _15: std::ptr::NonNull<T>;
+            let mut _24: &mut std::ptr::NonNull<T>;
+            scope 11 (inlined std::slice::IterMut::<'_, T>::pre_dec_end) {
+                let mut _10: *mut *mut T;
+                let mut _11: *mut std::ptr::NonNull<T>;
+                let mut _12: std::ptr::NonNull<T>;
+                let mut _16: *mut *mut T;
+                let mut _17: *mut usize;
+                let mut _18: usize;
+                let mut _19: usize;
+                scope 12 {
+                    scope 13 {
+                    }
+                    scope 14 {
+                        scope 17 (inlined NonNull::<T>::sub) {
+                            scope 18 (inlined #[track_caller] core::num::<impl isize>::unchecked_neg) {
+                                scope 19 (inlined core::ub_checks::check_language_ub) {
+                                    scope 20 (inlined core::ub_checks::check_language_ub::runtime) {
+                                    }
+                                }
+                            }
+                            scope 21 (inlined NonNull::<T>::offset) {
+                                let mut _13: *const T;
+                                let mut _14: *const T;
+                                scope 22 (inlined NonNull::<T>::as_ptr) {
+                                }
+                            }
+                        }
+                    }
+                    scope 15 (inlined std::ptr::mut_ptr::<impl *mut *mut T>::cast::<usize>) {
+                    }
+                    scope 16 (inlined std::ptr::mut_ptr::<impl *mut *mut T>::cast::<NonNull<T>>) {
+                    }
+                }
+            }
+            scope 23 (inlined NonNull::<T>::as_mut::<'_>) {
+                let mut _20: *mut T;
+                scope 24 (inlined NonNull::<T>::as_ptr) {
+                }
+            }
+        }
+    }
 
     bb0: {
-        _0 = <std::slice::IterMut<'_, T> as DoubleEndedIterator>::next_back(move _1) -> [return: bb1, unwind unreachable];
+        StorageLive(_9);
+        StorageLive(_8);
+        StorageLive(_3);
+        StorageLive(_2);
+        StorageLive(_21);
+        StorageLive(_7);
+        switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
     }
 
     bb1: {
+        _2 = copy ((*_1).1: *mut T);
+        _3 = copy _2 as std::ptr::NonNull<T> (Transmute);
+        StorageLive(_22);
+        // DBG: _22 = &((*_1).0: std::ptr::NonNull<T>);
+        StorageLive(_23);
+        // DBG: _23 = &_3;
+        StorageLive(_5);
+        StorageLive(_4);
+        _4 = copy ((*_1).0: std::ptr::NonNull<T>);
+        _5 = copy _4 as *mut T (Transmute);
+        StorageDead(_4);
+        StorageLive(_6);
+        _6 = copy _3 as *mut T (Transmute);
+        _7 = Eq(copy _5, copy _6);
+        StorageDead(_6);
+        StorageDead(_5);
+        StorageDead(_23);
+        StorageDead(_22);
+        goto -> bb3;
+    }
+
+    bb2: {
+        _8 = copy ((*_1).1: *mut T);
+        _9 = copy _8 as usize (Transmute);
+        _7 = Eq(copy _9, const 0_usize);
+        goto -> bb3;
+    }
+
+    bb3: {
+        switchInt(move _7) -> [0: bb4, otherwise: bb10];
+    }
+
+    bb4: {
+        StorageLive(_15);
+        StorageLive(_24);
+        StorageLive(_17);
+        StorageLive(_11);
+        StorageLive(_12);
+        switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb5, otherwise: bb8];
+    }
+
+    bb5: {
+        StorageLive(_10);
+        _10 = &raw mut ((*_1).1: *mut T);
+        _11 = copy _10 as *mut std::ptr::NonNull<T> (PtrToPtr);
+        StorageDead(_10);
+        _12 = copy (*_11);
+        switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb6, otherwise: bb7];
+    }
+
+    bb6: {
+        StorageLive(_14);
+        StorageLive(_13);
+        _13 = copy _12 as *const T (Transmute);
+        _14 = Offset(copy _13, const -1_isize);
+        StorageDead(_13);
+        _12 = NonNull::<T> { pointer: copy _14 };
+        StorageDead(_14);
+        goto -> bb7;
+    }
+
+    bb7: {
+        (*_11) = move _12;
+        _15 = copy (*_11);
+        goto -> bb9;
+    }
+
+    bb8: {
+        StorageLive(_16);
+        _16 = &raw mut ((*_1).1: *mut T);
+        _17 = copy _16 as *mut usize (PtrToPtr);
+        StorageDead(_16);
+        StorageLive(_19);
+        StorageLive(_18);
+        _18 = copy (*_17);
+        _19 = SubUnchecked(move _18, const 1_usize);
+        StorageDead(_18);
+        (*_17) = move _19;
+        StorageDead(_19);
+        _15 = copy ((*_1).0: std::ptr::NonNull<T>);
+        goto -> bb9;
+    }
+
+    bb9: {
+        StorageDead(_12);
+        StorageDead(_11);
+        StorageDead(_17);
+        // DBG: _24 = &_15;
+        StorageLive(_20);
+        _20 = copy _15 as *mut T (Transmute);
+        _21 = &mut (*_20);
+        StorageDead(_20);
+        StorageDead(_24);
+        StorageDead(_15);
+        _0 = Option::<&mut T>::Some(copy _21);
+        goto -> bb11;
+    }
+
+    bb10: {
+        _0 = const {transmute(0x0000000000000000): Option<&mut T>};
+        goto -> bb11;
+    }
+
+    bb11: {
+        StorageDead(_7);
+        StorageDead(_21);
+        StorageDead(_2);
+        StorageDead(_3);
+        StorageDead(_8);
+        StorageDead(_9);
         return;
     }
 }
diff --git a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_mut_next_back.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_mut_next_back.PreCodegen.after.panic-unwind.mir
index dfe5e206fadaf..590d4ac2c8381 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_mut_next_back.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_mut_next_back.PreCodegen.after.panic-unwind.mir
@@ -3,12 +3,199 @@
 fn slice_iter_mut_next_back(_1: &mut std::slice::IterMut<'_, T>) -> Option<&mut T> {
     debug it => _1;
     let mut _0: std::option::Option<&mut T>;
+    scope 1 (inlined <std::slice::IterMut<'_, T> as DoubleEndedIterator>::next_back) {
+        let mut _2: *mut T;
+        let mut _7: bool;
+        let mut _8: *mut T;
+        let mut _21: &mut T;
+        let mut _22: &std::ptr::NonNull<T>;
+        let mut _23: &std::ptr::NonNull<T>;
+        scope 2 {
+            let _3: std::ptr::NonNull<T>;
+            let _9: usize;
+            scope 3 {
+            }
+            scope 4 {
+                scope 7 (inlined <NonNull<T> as PartialEq>::eq) {
+                    let mut _4: std::ptr::NonNull<T>;
+                    let mut _5: *mut T;
+                    let mut _6: *mut T;
+                    scope 8 (inlined NonNull::<T>::as_ptr) {
+                    }
+                    scope 9 (inlined NonNull::<T>::as_ptr) {
+                    }
+                }
+            }
+            scope 5 (inlined std::ptr::mut_ptr::<impl *mut T>::addr) {
+                scope 6 (inlined std::ptr::mut_ptr::<impl *mut T>::cast::<()>) {
+                }
+            }
+        }
+        scope 10 (inlined std::slice::IterMut::<'_, T>::next_back_unchecked) {
+            let mut _15: std::ptr::NonNull<T>;
+            let mut _24: &mut std::ptr::NonNull<T>;
+            scope 11 (inlined std::slice::IterMut::<'_, T>::pre_dec_end) {
+                let mut _10: *mut *mut T;
+                let mut _11: *mut std::ptr::NonNull<T>;
+                let mut _12: std::ptr::NonNull<T>;
+                let mut _16: *mut *mut T;
+                let mut _17: *mut usize;
+                let mut _18: usize;
+                let mut _19: usize;
+                scope 12 {
+                    scope 13 {
+                    }
+                    scope 14 {
+                        scope 17 (inlined NonNull::<T>::sub) {
+                            scope 18 (inlined #[track_caller] core::num::<impl isize>::unchecked_neg) {
+                                scope 19 (inlined core::ub_checks::check_language_ub) {
+                                    scope 20 (inlined core::ub_checks::check_language_ub::runtime) {
+                                    }
+                                }
+                            }
+                            scope 21 (inlined NonNull::<T>::offset) {
+                                let mut _13: *const T;
+                                let mut _14: *const T;
+                                scope 22 (inlined NonNull::<T>::as_ptr) {
+                                }
+                            }
+                        }
+                    }
+                    scope 15 (inlined std::ptr::mut_ptr::<impl *mut *mut T>::cast::<usize>) {
+                    }
+                    scope 16 (inlined std::ptr::mut_ptr::<impl *mut *mut T>::cast::<NonNull<T>>) {
+                    }
+                }
+            }
+            scope 23 (inlined NonNull::<T>::as_mut::<'_>) {
+                let mut _20: *mut T;
+                scope 24 (inlined NonNull::<T>::as_ptr) {
+                }
+            }
+        }
+    }
 
     bb0: {
-        _0 = <std::slice::IterMut<'_, T> as DoubleEndedIterator>::next_back(move _1) -> [return: bb1, unwind continue];
+        StorageLive(_9);
+        StorageLive(_8);
+        StorageLive(_3);
+        StorageLive(_2);
+        StorageLive(_21);
+        StorageLive(_7);
+        switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
     }
 
     bb1: {
+        _2 = copy ((*_1).1: *mut T);
+        _3 = copy _2 as std::ptr::NonNull<T> (Transmute);
+        StorageLive(_22);
+        // DBG: _22 = &((*_1).0: std::ptr::NonNull<T>);
+        StorageLive(_23);
+        // DBG: _23 = &_3;
+        StorageLive(_5);
+        StorageLive(_4);
+        _4 = copy ((*_1).0: std::ptr::NonNull<T>);
+        _5 = copy _4 as *mut T (Transmute);
+        StorageDead(_4);
+        StorageLive(_6);
+        _6 = copy _3 as *mut T (Transmute);
+        _7 = Eq(copy _5, copy _6);
+        StorageDead(_6);
+        StorageDead(_5);
+        StorageDead(_23);
+        StorageDead(_22);
+        goto -> bb3;
+    }
+
+    bb2: {
+        _8 = copy ((*_1).1: *mut T);
+        _9 = copy _8 as usize (Transmute);
+        _7 = Eq(copy _9, const 0_usize);
+        goto -> bb3;
+    }
+
+    bb3: {
+        switchInt(move _7) -> [0: bb4, otherwise: bb10];
+    }
+
+    bb4: {
+        StorageLive(_15);
+        StorageLive(_24);
+        StorageLive(_17);
+        StorageLive(_11);
+        StorageLive(_12);
+        switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb5, otherwise: bb8];
+    }
+
+    bb5: {
+        StorageLive(_10);
+        _10 = &raw mut ((*_1).1: *mut T);
+        _11 = copy _10 as *mut std::ptr::NonNull<T> (PtrToPtr);
+        StorageDead(_10);
+        _12 = copy (*_11);
+        switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb6, otherwise: bb7];
+    }
+
+    bb6: {
+        StorageLive(_14);
+        StorageLive(_13);
+        _13 = copy _12 as *const T (Transmute);
+        _14 = Offset(copy _13, const -1_isize);
+        StorageDead(_13);
+        _12 = NonNull::<T> { pointer: copy _14 };
+        StorageDead(_14);
+        goto -> bb7;
+    }
+
+    bb7: {
+        (*_11) = move _12;
+        _15 = copy (*_11);
+        goto -> bb9;
+    }
+
+    bb8: {
+        StorageLive(_16);
+        _16 = &raw mut ((*_1).1: *mut T);
+        _17 = copy _16 as *mut usize (PtrToPtr);
+        StorageDead(_16);
+        StorageLive(_19);
+        StorageLive(_18);
+        _18 = copy (*_17);
+        _19 = SubUnchecked(move _18, const 1_usize);
+        StorageDead(_18);
+        (*_17) = move _19;
+        StorageDead(_19);
+        _15 = copy ((*_1).0: std::ptr::NonNull<T>);
+        goto -> bb9;
+    }
+
+    bb9: {
+        StorageDead(_12);
+        StorageDead(_11);
+        StorageDead(_17);
+        // DBG: _24 = &_15;
+        StorageLive(_20);
+        _20 = copy _15 as *mut T (Transmute);
+        _21 = &mut (*_20);
+        StorageDead(_20);
+        StorageDead(_24);
+        StorageDead(_15);
+        _0 = Option::<&mut T>::Some(copy _21);
+        goto -> bb11;
+    }
+
+    bb10: {
+        _0 = const {transmute(0x0000000000000000): Option<&mut T>};
+        goto -> bb11;
+    }
+
+    bb11: {
+        StorageDead(_7);
+        StorageDead(_21);
+        StorageDead(_2);
+        StorageDead(_3);
+        StorageDead(_8);
+        StorageDead(_9);
         return;
     }
 }
diff --git a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-abort.mir
index cc0fce26149e3..e9ed932cbafb6 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-abort.mir
@@ -10,6 +10,9 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
         let mut _10: std::ptr::NonNull<T>;
         let mut _12: usize;
         let _14: &T;
+        let mut _15: &std::ptr::NonNull<T>;
+        let mut _16: &std::ptr::NonNull<T>;
+        let mut _17: &std::ptr::NonNull<T>;
         scope 2 {
             let _3: *const T;
             scope 3 {
@@ -67,7 +70,11 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
 
     bb1: {
         StorageLive(_7);
+        StorageLive(_15);
+        // DBG: _15 = &_2;
+        StorageLive(_16);
         _4 = copy _3 as std::ptr::NonNull<T> (Transmute);
+        // DBG: _16 = &_4;
         StorageLive(_5);
         _5 = copy _2 as *mut T (Transmute);
         StorageLive(_6);
@@ -79,6 +86,8 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
     }
 
     bb2: {
+        StorageDead(_16);
+        StorageDead(_15);
         StorageDead(_7);
         StorageLive(_10);
         StorageLive(_9);
@@ -94,6 +103,8 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
     }
 
     bb3: {
+        StorageDead(_16);
+        StorageDead(_15);
         _0 = const {transmute(0x0000000000000000): Option<&T>};
         StorageDead(_7);
         goto -> bb8;
@@ -116,10 +127,13 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
     }
 
     bb7: {
+        StorageLive(_17);
+        // DBG: _17 = &_2;
         StorageLive(_13);
         _13 = copy _2 as *const T (Transmute);
         _14 = &(*_13);
         StorageDead(_13);
+        StorageDead(_17);
         _0 = Option::<&T>::Some(copy _14);
         goto -> bb8;
     }
diff --git a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-unwind.mir
index cc0fce26149e3..e9ed932cbafb6 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-unwind.mir
@@ -10,6 +10,9 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
         let mut _10: std::ptr::NonNull<T>;
         let mut _12: usize;
         let _14: &T;
+        let mut _15: &std::ptr::NonNull<T>;
+        let mut _16: &std::ptr::NonNull<T>;
+        let mut _17: &std::ptr::NonNull<T>;
         scope 2 {
             let _3: *const T;
             scope 3 {
@@ -67,7 +70,11 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
 
     bb1: {
         StorageLive(_7);
+        StorageLive(_15);
+        // DBG: _15 = &_2;
+        StorageLive(_16);
         _4 = copy _3 as std::ptr::NonNull<T> (Transmute);
+        // DBG: _16 = &_4;
         StorageLive(_5);
         _5 = copy _2 as *mut T (Transmute);
         StorageLive(_6);
@@ -79,6 +86,8 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
     }
 
     bb2: {
+        StorageDead(_16);
+        StorageDead(_15);
         StorageDead(_7);
         StorageLive(_10);
         StorageLive(_9);
@@ -94,6 +103,8 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
     }
 
     bb3: {
+        StorageDead(_16);
+        StorageDead(_15);
         _0 = const {transmute(0x0000000000000000): Option<&T>};
         StorageDead(_7);
         goto -> bb8;
@@ -116,10 +127,13 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
     }
 
     bb7: {
+        StorageLive(_17);
+        // DBG: _17 = &_2;
         StorageLive(_13);
         _13 = copy _2 as *const T (Transmute);
         _14 = &(*_13);
         StorageDead(_13);
+        StorageDead(_17);
         _0 = Option::<&T>::Some(copy _14);
         goto -> bb8;
     }
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 fe4e2deab8706..79aa9c5ae1e36 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
@@ -9,7 +9,7 @@ fn outer(_1: u8) -> u8 {
     }
 
     bb0: {
-        _2 = &_1;                        // scope 0 at $DIR/spans.rs:11:11: 11:13
+        // DBG: _2 = &_1;
         _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 fe4e2deab8706..79aa9c5ae1e36 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
@@ -9,7 +9,7 @@ fn outer(_1: u8) -> u8 {
     }
 
     bb0: {
-        _2 = &_1;                        // scope 0 at $DIR/spans.rs:11:11: 11:13
+        // DBG: _2 = &_1;
         _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/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 2eee8a97db0d4..eebd4a7eb50e3 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
@@ -11,7 +11,9 @@ fn vec_deref_to_slice(_1: &Vec<u8>) -> &[u8] {
             let mut _4: usize;
             scope 3 (inlined Vec::<u8>::as_ptr) {
                 debug self => _1;
+                let mut _6: &alloc::raw_vec::RawVec<u8>;
                 scope 4 (inlined alloc::raw_vec::RawVec::<u8>::ptr) {
+                    let mut _7: &alloc::raw_vec::RawVecInner;
                     scope 5 (inlined alloc::raw_vec::RawVecInner::ptr::<u8>) {
                         scope 6 (inlined alloc::raw_vec::RawVecInner::non_null::<u8>) {
                             let mut _2: std::ptr::NonNull<u8>;
@@ -55,8 +57,14 @@ fn vec_deref_to_slice(_1: &Vec<u8>) -> &[u8] {
     bb0: {
         StorageLive(_2);
         StorageLive(_3);
+        StorageLive(_6);
+        // DBG: _6 = &((*_1).0: alloc::raw_vec::RawVec<u8>);
+        StorageLive(_7);
+        // DBG: _7 = &(((*_1).0: alloc::raw_vec::RawVec<u8>).0: alloc::raw_vec::RawVecInner);
         _2 = copy (((((*_1).0: alloc::raw_vec::RawVec<u8>).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique<u8>).0: std::ptr::NonNull<u8>);
+        StorageDead(_7);
         _3 = copy _2 as *const u8 (Transmute);
+        StorageDead(_6);
         StorageLive(_4);
         _4 = copy ((*_1).1: usize);
         StorageLive(_5);
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 2eee8a97db0d4..eebd4a7eb50e3 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
@@ -11,7 +11,9 @@ fn vec_deref_to_slice(_1: &Vec<u8>) -> &[u8] {
             let mut _4: usize;
             scope 3 (inlined Vec::<u8>::as_ptr) {
                 debug self => _1;
+                let mut _6: &alloc::raw_vec::RawVec<u8>;
                 scope 4 (inlined alloc::raw_vec::RawVec::<u8>::ptr) {
+                    let mut _7: &alloc::raw_vec::RawVecInner;
                     scope 5 (inlined alloc::raw_vec::RawVecInner::ptr::<u8>) {
                         scope 6 (inlined alloc::raw_vec::RawVecInner::non_null::<u8>) {
                             let mut _2: std::ptr::NonNull<u8>;
@@ -55,8 +57,14 @@ fn vec_deref_to_slice(_1: &Vec<u8>) -> &[u8] {
     bb0: {
         StorageLive(_2);
         StorageLive(_3);
+        StorageLive(_6);
+        // DBG: _6 = &((*_1).0: alloc::raw_vec::RawVec<u8>);
+        StorageLive(_7);
+        // DBG: _7 = &(((*_1).0: alloc::raw_vec::RawVec<u8>).0: alloc::raw_vec::RawVecInner);
         _2 = copy (((((*_1).0: alloc::raw_vec::RawVec<u8>).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique<u8>).0: std::ptr::NonNull<u8>);
+        StorageDead(_7);
         _3 = copy _2 as *const u8 (Transmute);
+        StorageDead(_6);
         StorageLive(_4);
         _4 = copy ((*_1).1: usize);
         StorageLive(_5);

From cc93132ae4f5477297ecddb0c07d2e8c74075f0c Mon Sep 17 00:00:00 2001
From: dianqk <dianqk@dianqk.net>
Date: Thu, 10 Jul 2025 21:20:54 +0800
Subject: [PATCH 1651/1889] simplifycfg: Preserve debuginfos when merging bbs

---
 compiler/rustc_middle/src/mir/terminator.rs   |   8 +
 compiler/rustc_mir_transform/src/simplify.rs  |  30 ++-
 ...ycfg.drop_debuginfo.SimplifyCfg-final.diff |   2 +
 ...reserve_debuginfo_1.SimplifyCfg-final.diff |   3 +
 ...reserve_debuginfo_2.SimplifyCfg-final.diff |   3 +
 ...reserve_debuginfo_3.SimplifyCfg-final.diff |  40 ++++
 ...nfo_identical_succs.SimplifyCfg-final.diff |  32 +++
 tests/mir-opt/debuginfo/simplifycfg.rs        | 207 ++++++++++++++++++
 8 files changed, 322 insertions(+), 3 deletions(-)
 create mode 100644 tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_3.SimplifyCfg-final.diff
 create mode 100644 tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_identical_succs.SimplifyCfg-final.diff
 create mode 100644 tests/mir-opt/debuginfo/simplifycfg.rs

diff --git a/compiler/rustc_middle/src/mir/terminator.rs b/compiler/rustc_middle/src/mir/terminator.rs
index 4034a3a06e943..4249914346cd4 100644
--- a/compiler/rustc_middle/src/mir/terminator.rs
+++ b/compiler/rustc_middle/src/mir/terminator.rs
@@ -444,6 +444,14 @@ impl<'tcx> Terminator<'tcx> {
         self.kind.successors()
     }
 
+    /// Return `Some` if all successors are identical.
+    #[inline]
+    pub fn identical_successor(&self) -> Option<BasicBlock> {
+        let mut successors = self.successors();
+        let first_succ = successors.next()?;
+        if successors.all(|succ| first_succ == succ) { Some(first_succ) } else { None }
+    }
+
     #[inline]
     pub fn successors_mut<'a>(&'a mut self, f: impl FnMut(&'a mut BasicBlock)) {
         self.kind.successors_mut(f)
diff --git a/compiler/rustc_mir_transform/src/simplify.rs b/compiler/rustc_mir_transform/src/simplify.rs
index 9f7bb3b03795a..edea5cb2c7241 100644
--- a/compiler/rustc_mir_transform/src/simplify.rs
+++ b/compiler/rustc_mir_transform/src/simplify.rs
@@ -144,7 +144,7 @@ impl<'a, 'tcx> CfgSimplifier<'a, 'tcx> {
         // statements itself to avoid moving the (relatively) large statements twice.
         // We do not push the statements directly into the target block (`bb`) as that is slower
         // due to additional reallocations
-        let mut merged_blocks = Vec::new();
+        let mut merged_blocks: Vec<BasicBlock> = Vec::new();
         let mut outer_changed = false;
         loop {
             let mut changed = false;
@@ -159,8 +159,9 @@ impl<'a, 'tcx> CfgSimplifier<'a, 'tcx> {
                 let mut terminator =
                     self.basic_blocks[bb].terminator.take().expect("invalid terminator state");
 
-                terminator
-                    .successors_mut(|successor| self.collapse_goto_chain(successor, &mut changed));
+                terminator.successors_mut(|successor| {
+                    self.collapse_goto_chain(successor, &mut changed);
+                });
 
                 let mut inner_changed = true;
                 merged_blocks.clear();
@@ -177,10 +178,18 @@ impl<'a, 'tcx> CfgSimplifier<'a, 'tcx> {
                 if statements_to_merge > 0 {
                     let mut statements = std::mem::take(&mut self.basic_blocks[bb].statements);
                     statements.reserve(statements_to_merge);
+                    let mut parent_bb_last_debuginfos =
+                        std::mem::take(&mut self.basic_blocks[bb].after_last_stmt_debuginfos);
                     for &from in &merged_blocks {
+                        if let Some(stmt) = self.basic_blocks[from].statements.first_mut() {
+                            stmt.debuginfos.prepend(&mut parent_bb_last_debuginfos);
+                        }
                         statements.append(&mut self.basic_blocks[from].statements);
+                        parent_bb_last_debuginfos =
+                            std::mem::take(&mut self.basic_blocks[from].after_last_stmt_debuginfos);
                     }
                     self.basic_blocks[bb].statements = statements;
+                    self.basic_blocks[bb].after_last_stmt_debuginfos = parent_bb_last_debuginfos;
                 }
 
                 self.basic_blocks[bb].terminator = Some(terminator);
@@ -220,10 +229,14 @@ impl<'a, 'tcx> CfgSimplifier<'a, 'tcx> {
         // goto chains. We should probably benchmark different sizes.
         let mut terminators: SmallVec<[_; 1]> = Default::default();
         let mut current = *start;
+        // If each successor has only one predecessor, it's a trivial goto chain.
+        // We can move all debuginfos to the last basic block.
+        let mut trivial_goto_chain = true;
         while let Some(terminator) = self.take_terminator_if_simple_goto(current) {
             let Terminator { kind: TerminatorKind::Goto { target }, .. } = terminator else {
                 unreachable!();
             };
+            trivial_goto_chain &= self.pred_count[target] == 1;
             terminators.push((current, terminator));
             current = target;
         }
@@ -235,6 +248,17 @@ impl<'a, 'tcx> CfgSimplifier<'a, 'tcx> {
             else {
                 unreachable!();
             };
+            if trivial_goto_chain {
+                let mut pred_debuginfos =
+                    std::mem::take(&mut self.basic_blocks[current].after_last_stmt_debuginfos);
+                let debuginfos = if let Some(stmt) = self.basic_blocks[last].statements.first_mut()
+                {
+                    &mut stmt.debuginfos
+                } else {
+                    &mut self.basic_blocks[last].after_last_stmt_debuginfos
+                };
+                debuginfos.prepend(&mut pred_debuginfos);
+            }
             *changed |= *target != last;
             *target = last;
             debug!("collapsing goto chain from {:?} to {:?}", current, target);
diff --git a/tests/mir-opt/debuginfo/simplifycfg.drop_debuginfo.SimplifyCfg-final.diff b/tests/mir-opt/debuginfo/simplifycfg.drop_debuginfo.SimplifyCfg-final.diff
index d4a73351ee4a5..7a1ac92f6dde9 100644
--- a/tests/mir-opt/debuginfo/simplifycfg.drop_debuginfo.SimplifyCfg-final.diff
+++ b/tests/mir-opt/debuginfo/simplifycfg.drop_debuginfo.SimplifyCfg-final.diff
@@ -14,11 +14,13 @@
 - 
 -     bb1: {
 -         // DBG: _3 = &((*_1).0: i32);
+-         nop;
 -         goto -> bb2;
 -     }
 - 
 -     bb2: {
           // DBG: _4 = &((*_1).1: i64);
+-         nop;
           _0 = copy ((*_1).2: i32);
           return;
       }
diff --git a/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_1.SimplifyCfg-final.diff b/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_1.SimplifyCfg-final.diff
index 1c12358ad8934..fa4d3aebf8384 100644
--- a/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_1.SimplifyCfg-final.diff
+++ b/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_1.SimplifyCfg-final.diff
@@ -17,13 +17,16 @@
 -     bb1: {
           (*_2) = const true;
           // DBG: _3 = &((*_1).0: i32);
+-         nop;
 -         goto -> bb2;
 -     }
 - 
 -     bb2: {
           // DBG: _4 = &((*_1).1: i64);
+-         nop;
           _0 = copy ((*_1).2: i32);
           // DBG: _5 = &((*_1).2: i32);
+-         nop;
           return;
       }
   }
diff --git a/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_2.SimplifyCfg-final.diff b/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_2.SimplifyCfg-final.diff
index de8e5612c8788..b01c91f196b65 100644
--- a/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_2.SimplifyCfg-final.diff
+++ b/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_2.SimplifyCfg-final.diff
@@ -16,13 +16,16 @@
 - 
 -     bb1: {
           // DBG: _2 = &((*_1).0: i32);
+-         nop;
 -         goto -> bb2;
 -     }
 - 
 -     bb2: {
           // DBG: _3 = &((*_1).1: i64);
+-         nop;
           _0 = copy ((*_1).2: i32);
           // DBG: _4 = &((*_1).2: i32);
+-         nop;
           return;
       }
   }
diff --git a/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_3.SimplifyCfg-final.diff b/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_3.SimplifyCfg-final.diff
new file mode 100644
index 0000000000000..caa90d79a1c27
--- /dev/null
+++ b/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_3.SimplifyCfg-final.diff
@@ -0,0 +1,40 @@
+- // MIR for `preserve_debuginfo_3` before SimplifyCfg-final
++ // MIR for `preserve_debuginfo_3` after SimplifyCfg-final
+  
+  fn preserve_debuginfo_3(_1: &Foo, _2: bool) -> i32 {
+      debug foo_a => _3;
+      debug foo_b => _4;
+      debug foo_c => _5;
+      let mut _0: i32;
+      let mut _3: &i32;
+      let mut _4: &i64;
+      let mut _5: &i32;
+  
+      bb0: {
+-         switchInt(copy _2) -> [1: bb1, otherwise: bb2];
++         switchInt(copy _2) -> [1: bb2, otherwise: bb1];
+      }
+  
+      bb1: {
+-         // DBG: _3 = &((*_1).0: i32);
+-         nop;
+-         goto -> bb3;
+-     }
+- 
+-     bb2: {
+          // DBG: _4 = &((*_1).1: i64);
+-         nop;
+          _0 = copy ((*_1).2: i32);
+          return;
+      }
+  
+-     bb3: {
++     bb2: {
++         // DBG: _3 = &((*_1).0: i32);
+          // DBG: _5 = &((*_1).2: i32);
+-         nop;
+          _0 = copy ((*_1).0: i32);
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_identical_succs.SimplifyCfg-final.diff b/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_identical_succs.SimplifyCfg-final.diff
new file mode 100644
index 0000000000000..d8c36990a5ff0
--- /dev/null
+++ b/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_identical_succs.SimplifyCfg-final.diff
@@ -0,0 +1,32 @@
+- // MIR for `preserve_debuginfo_identical_succs` before SimplifyCfg-final
++ // MIR for `preserve_debuginfo_identical_succs` after SimplifyCfg-final
+  
+  fn preserve_debuginfo_identical_succs(_1: &Foo, _2: bool) -> i32 {
+      debug foo_a => _3;
+      debug foo_b => _4;
+      debug foo_c => _5;
+      let mut _0: i32;
+      let mut _3: &i32;
+      let mut _4: &i64;
+      let mut _5: &i32;
+  
+      bb0: {
+-         switchInt(copy _2) -> [1: bb1, otherwise: bb1];
+-     }
+- 
+-     bb1: {
+          // DBG: _3 = &((*_1).0: i32);
+-         nop;
+-         goto -> bb2;
+-     }
+- 
+-     bb2: {
+          // DBG: _4 = &((*_1).1: i64);
+-         nop;
+          _0 = copy ((*_1).2: i32);
+          // DBG: _5 = &((*_1).2: i32);
+-         nop;
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/debuginfo/simplifycfg.rs b/tests/mir-opt/debuginfo/simplifycfg.rs
new file mode 100644
index 0000000000000..2bd510fd3b9db
--- /dev/null
+++ b/tests/mir-opt/debuginfo/simplifycfg.rs
@@ -0,0 +1,207 @@
+//@ test-mir-pass: SimplifyCfg-final
+//@ compile-flags: -Zmir-enable-passes=+DeadStoreElimination-initial
+
+#![feature(core_intrinsics, custom_mir)]
+#![crate_type = "lib"]
+
+use std::intrinsics::mir::*;
+
+pub struct Foo {
+    a: i32,
+    b: i64,
+    c: i32,
+}
+
+// EMIT_MIR simplifycfg.drop_debuginfo.SimplifyCfg-final.diff
+#[custom_mir(dialect = "runtime", phase = "post-cleanup")]
+pub fn drop_debuginfo(foo: &Foo, c: bool) -> i32 {
+    // CHECK-LABEL: fn drop_debuginfo
+    // CHECK: debug foo_b => [[foo_b:_[0-9]+]];
+    // CHECK: bb0: {
+    // CHECK-NEXT: DBG: [[foo_b]] = &((*_1).1: i64)
+    // CHECK-NEXT: _0 = copy ((*_1).2: i32);
+    // CHECK-NEXT: return;
+    mir! {
+        let _foo_a: &i32;
+        let _foo_b: &i64;
+        debug foo_a => _foo_a;
+        debug foo_b => _foo_b;
+        {
+            match c {
+                true => tmp,
+                _ => ret,
+            }
+        }
+        tmp = {
+            // Because we don't know if `c` is always true, we must drop this debuginfo.
+            _foo_a = &(*foo).a;
+            Goto(ret)
+        }
+        ret = {
+            _foo_b = &(*foo).b;
+            RET = (*foo).c;
+            Return()
+        }
+    }
+}
+
+// EMIT_MIR simplifycfg.preserve_debuginfo_1.SimplifyCfg-final.diff
+#[custom_mir(dialect = "runtime", phase = "post-cleanup")]
+pub fn preserve_debuginfo_1(foo: &Foo, v: &mut bool) -> i32 {
+    // CHECK-LABEL: fn preserve_debuginfo_1
+    // CHECK: debug foo_a => [[foo_a:_[0-9]+]];
+    // CHECK: debug foo_b => [[foo_b:_[0-9]+]];
+    // CHECK: debug foo_c => [[foo_c:_[0-9]+]];
+    // CHECK: bb0: {
+    // CHECK-NEXT: (*_2) = const true;
+    // CHECK-NEXT: DBG: [[foo_a]] = &((*_1).0: i32)
+    // CHECK-NEXT: DBG: [[foo_b]] = &((*_1).1: i64)
+    // CHECK-NEXT: _0 = copy ((*_1).2: i32);
+    // CHECK-NEXT: DBG: [[foo_c]] = &((*_1).2: i32)
+    // CHECK-NEXT: return;
+    mir! {
+        let _foo_a: &i32;
+        let _foo_b: &i64;
+        let _foo_c: &i32;
+        debug foo_a => _foo_a;
+        debug foo_b => _foo_b;
+        debug foo_c => _foo_c;
+        {
+            Goto(tmp)
+        }
+        tmp = {
+            *v = true;
+            _foo_a = &(*foo).a;
+            Goto(ret)
+        }
+        ret = {
+            _foo_b = &(*foo).b;
+            RET = (*foo).c;
+            _foo_c = &(*foo).c;
+            Return()
+        }
+    }
+}
+
+// EMIT_MIR simplifycfg.preserve_debuginfo_2.SimplifyCfg-final.diff
+#[custom_mir(dialect = "runtime", phase = "post-cleanup")]
+pub fn preserve_debuginfo_2(foo: &Foo) -> i32 {
+    // CHECK-LABEL: fn preserve_debuginfo_2
+    // CHECK: debug foo_a => [[foo_a:_[0-9]+]];
+    // CHECK: debug foo_b => [[foo_b:_[0-9]+]];
+    // CHECK: debug foo_c => [[foo_c:_[0-9]+]];
+    // CHECK: bb0: {
+    // CHECK-NEXT: DBG: [[foo_a]] = &((*_1).0: i32)
+    // CHECK-NEXT: DBG: [[foo_b]] = &((*_1).1: i64)
+    // CHECK-NEXT: _0 = copy ((*_1).2: i32);
+    // CHECK-NEXT: DBG: [[foo_c]] = &((*_1).2: i32)
+    // CHECK-NEXT: return;
+    mir! {
+        let _foo_a: &i32;
+        let _foo_b: &i64;
+        let _foo_c: &i32;
+        debug foo_a => _foo_a;
+        debug foo_b => _foo_b;
+        debug foo_c => _foo_c;
+        {
+            Goto(tmp)
+        }
+        tmp = {
+            _foo_a = &(*foo).a;
+            Goto(ret)
+        }
+        ret = {
+            _foo_b = &(*foo).b;
+            RET = (*foo).c;
+            _foo_c = &(*foo).c;
+            Return()
+        }
+    }
+}
+
+// EMIT_MIR simplifycfg.preserve_debuginfo_3.SimplifyCfg-final.diff
+#[custom_mir(dialect = "runtime", phase = "post-cleanup")]
+pub fn preserve_debuginfo_3(foo: &Foo, c: bool) -> i32 {
+    // CHECK-LABEL: fn preserve_debuginfo_3
+    // CHECK: debug foo_a => [[foo_a:_[0-9]+]];
+    // CHECK: debug foo_b => [[foo_b:_[0-9]+]];
+    // CHECK: debug foo_c => [[foo_c:_[0-9]+]];
+    // CHECK: bb0: {
+    // CHECK-NEXT: switchInt(copy _2) -> [1: bb2, otherwise: bb1];
+    // CHECK: bb1: {
+    // CHECK-NEXT: DBG: [[foo_b]] = &((*_1).1: i64)
+    // CHECK-NEXT: _0 = copy ((*_1).2: i32);
+    // CHECK-NEXT: return;
+    // CHECK: bb2: {
+    // CHECK-NEXT: DBG: [[foo_a]] = &((*_1).0: i32)
+    // CHECK-NEXT: DBG: [[foo_c]] = &((*_1).2: i32)
+    // CHECK-NEXT: _0 = copy ((*_1).0: i32);
+    // CHECK-NEXT: return;
+    mir! {
+        let _foo_a: &i32;
+        let _foo_b: &i64;
+        let _foo_c: &i32;
+        debug foo_a => _foo_a;
+        debug foo_b => _foo_b;
+        debug foo_c => _foo_c;
+        {
+            match c {
+                true => tmp,
+                _ => ret,
+            }
+        }
+        tmp = {
+            _foo_a = &(*foo).a;
+            Goto(ret_1)
+        }
+        ret = {
+            _foo_b = &(*foo).b;
+            RET = (*foo).c;
+            Return()
+        }
+        ret_1 = {
+            _foo_c = &(*foo).c;
+            RET = (*foo).a;
+            Return()
+        }
+    }
+}
+
+// EMIT_MIR simplifycfg.preserve_debuginfo_identical_succs.SimplifyCfg-final.diff
+#[custom_mir(dialect = "runtime", phase = "post-cleanup")]
+pub fn preserve_debuginfo_identical_succs(foo: &Foo, c: bool) -> i32 {
+    // CHECK-LABEL: fn preserve_debuginfo_identical_succs
+    // CHECK: debug foo_a => [[foo_a:_[0-9]+]];
+    // CHECK: debug foo_b => [[foo_b:_[0-9]+]];
+    // CHECK: debug foo_c => [[foo_c:_[0-9]+]];
+    // CHECK: bb0: {
+    // CHECK-NEXT: DBG: [[foo_a]] = &((*_1).0: i32)
+    // CHECK-NEXT: DBG: [[foo_b]] = &((*_1).1: i64)
+    // CHECK-NEXT: _0 = copy ((*_1).2: i32);
+    // CHECK-NEXT: DBG: [[foo_c]] = &((*_1).2: i32)
+    // CHECK-NEXT: return;
+    mir! {
+        let _foo_a: &i32;
+        let _foo_b: &i64;
+        let _foo_c: &i32;
+        debug foo_a => _foo_a;
+        debug foo_b => _foo_b;
+        debug foo_c => _foo_c;
+        {
+            match c {
+                true => tmp,
+                _ => tmp,
+            }
+        }
+        tmp = {
+            _foo_a = &(*foo).a;
+            Goto(ret)
+        }
+        ret = {
+            _foo_b = &(*foo).b;
+            RET = (*foo).c;
+            _foo_c = &(*foo).c;
+            Return()
+        }
+    }
+}

From 85b2f706939528b5796d98e82c183637f8338cd1 Mon Sep 17 00:00:00 2001
From: dianqk <dianqk@dianqk.net>
Date: Tue, 15 Jul 2025 22:54:54 +0800
Subject: [PATCH 1652/1889] mir-opt: Eliminate trivial unnecessary storage
 annotations

---
 compiler/rustc_middle/src/mir/statement.rs    |  14 +--
 .../rustc_mir_dataflow/src/impls/liveness.rs  |   4 +-
 .../src/dead_store_elimination.rs             |  16 ++-
 compiler/rustc_mir_transform/src/inline.rs    |   8 +-
 compiler/rustc_mir_transform/src/simplify.rs  | 118 ++++++++++++------
 ...le.cycle.DeadStoreElimination-initial.diff |   4 -
 ...ad_first.DeadStoreElimination-initial.diff |   1 -
 ...ef.tuple.DeadStoreElimination-initial.diff |   5 +-
 ...ycfg.drop_debuginfo.SimplifyCfg-final.diff |   2 -
 ...reserve_debuginfo_1.SimplifyCfg-final.diff |   3 -
 ...reserve_debuginfo_2.SimplifyCfg-final.diff |   3 -
 ...reserve_debuginfo_3.SimplifyCfg-final.diff |   3 -
 ...nfo_identical_succs.SimplifyCfg-final.diff |   3 -
 .../inline_shims.drop.Inline.panic-abort.diff |   4 -
 ...inline_shims.drop.Inline.panic-unwind.diff |   2 -
 ...y.run2-{closure#0}.Inline.panic-abort.diff |  11 --
 ....run2-{closure#0}.Inline.panic-unwind.diff |  11 --
 .../issue_101973.inner.GVN.panic-abort.diff   |   1 -
 .../issue_101973.inner.GVN.panic-unwind.diff  |   1 -
 ...implifyComparisonIntegral.panic-abort.diff |   6 -
 ...mplifyComparisonIntegral.panic-unwind.diff |   6 -
 ...git.PreCodegen.after.32bit.panic-abort.mir |   4 -
 ...it.PreCodegen.after.32bit.panic-unwind.mir |   4 -
 ...git.PreCodegen.after.64bit.panic-abort.mir |   4 -
 ...it.PreCodegen.after.64bit.panic-unwind.mir |   4 -
 ...p_forward.PreCodegen.after.panic-abort.mir |  40 ++----
 ..._forward.PreCodegen.after.panic-unwind.mir |  40 ++----
 ...as_copy.clone_as_copy.PreCodegen.after.mir |   2 -
 ...py.enum_clone_as_copy.PreCodegen.after.mir |  46 ++-----
 tests/mir-opt/pre-codegen/clone_as_copy.rs    |  16 +--
 ...ace.PreCodegen.after.32bit.panic-abort.mir |  38 ++----
 ...ce.PreCodegen.after.32bit.panic-unwind.mir |  38 ++----
 ...ace.PreCodegen.after.64bit.panic-abort.mir |  38 ++----
 ...ce.PreCodegen.after.64bit.panic-unwind.mir |  38 ++----
 tests/mir-opt/pre-codegen/drop_boxed_slice.rs |   2 +-
 .../loops.int_range.PreCodegen.after.mir      |   6 -
 .../loops.vec_move.PreCodegen.after.mir       |  28 -----
 ...variant_a-{closure#0}.PreCodegen.after.mir |  22 ----
 ...ated_loop.PreCodegen.after.panic-abort.mir |  14 ---
 ...ward_loop.PreCodegen.after.panic-abort.mir |  14 ---
 ...ard_loop.PreCodegen.after.panic-unwind.mir |  14 ---
 ...erse_loop.PreCodegen.after.panic-abort.mir |  12 --
 ...rse_loop.PreCodegen.after.panic-unwind.mir |  12 --
 ..._is_empty.PreCodegen.after.panic-abort.mir |   8 --
 ...is_empty.PreCodegen.after.panic-unwind.mir |   8 --
 ...next_back.PreCodegen.after.panic-abort.mir |  12 --
 ...ext_back.PreCodegen.after.panic-unwind.mir |  12 --
 ...iter_next.PreCodegen.after.panic-abort.mir |  14 ---
 ...ter_next.PreCodegen.after.panic-unwind.mir |  14 ---
 tests/ui/extern/extern-types-field-offset.rs  |   5 +
 50 files changed, 179 insertions(+), 556 deletions(-)

diff --git a/compiler/rustc_middle/src/mir/statement.rs b/compiler/rustc_middle/src/mir/statement.rs
index 9deb43eb7084b..67b4448cfcddd 100644
--- a/compiler/rustc_middle/src/mir/statement.rs
+++ b/compiler/rustc_middle/src/mir/statement.rs
@@ -30,16 +30,10 @@ impl<'tcx> Statement<'tcx> {
         }
         let replaced_stmt = std::mem::replace(&mut self.kind, StatementKind::Nop);
         if !drop_debuginfo {
-            match replaced_stmt {
-                StatementKind::Assign(box (place, Rvalue::Ref(_, _, ref_place)))
-                    if let Some(local) = place.as_local() =>
-                {
-                    self.debuginfos.push(StmtDebugInfo::AssignRef(local, ref_place));
-                }
-                _ => {
-                    bug!("debuginfo is not yet supported.")
-                }
-            }
+            let Some(debuginfo) = replaced_stmt.as_debuginfo() else {
+                bug!("debuginfo is not yet supported.")
+            };
+            self.debuginfos.push(debuginfo);
         }
     }
 
diff --git a/compiler/rustc_mir_dataflow/src/impls/liveness.rs b/compiler/rustc_mir_dataflow/src/impls/liveness.rs
index 24da4b0bea28a..037e2720f3651 100644
--- a/compiler/rustc_mir_dataflow/src/impls/liveness.rs
+++ b/compiler/rustc_mir_dataflow/src/impls/liveness.rs
@@ -233,8 +233,10 @@ impl<'a> MaybeTransitiveLiveLocals<'a> {
         // Compute the place that we are storing to, if any
         let destination = match stmt_kind {
             StatementKind::Assign(box (place, rvalue)) => (rvalue.is_safe_to_remove()
+                // FIXME: We are not sure how we should represent this debugging information for some statements,
+                // keep it for now.
                 && (!debuginfo_locals.contains(place.local)
-                    || (place.as_local().is_some() && matches!(rvalue, mir::Rvalue::Ref(..)))))
+                    || (place.as_local().is_some() && stmt_kind.as_debuginfo().is_some())))
             .then_some(*place),
             StatementKind::SetDiscriminant { place, .. } | StatementKind::Deinit(place) => {
                 (!debuginfo_locals.contains(place.local)).then_some(**place)
diff --git a/compiler/rustc_mir_transform/src/dead_store_elimination.rs b/compiler/rustc_mir_transform/src/dead_store_elimination.rs
index a5f8a22e83c85..732c3dcd44ab8 100644
--- a/compiler/rustc_mir_transform/src/dead_store_elimination.rs
+++ b/compiler/rustc_mir_transform/src/dead_store_elimination.rs
@@ -22,13 +22,15 @@ use rustc_mir_dataflow::impls::{
     LivenessTransferFunction, MaybeTransitiveLiveLocals, borrowed_locals,
 };
 
+use crate::simplify::UsedInStmtLocals;
 use crate::util::is_within_packed;
 
 /// Performs the optimization on the body
 ///
 /// The `borrowed` set must be a `DenseBitSet` of all the locals that are ever borrowed in this
 /// body. It can be generated via the [`borrowed_locals`] function.
-fn eliminate<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
+/// Returns true if any instruction is eliminated.
+fn eliminate<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) -> bool {
     let borrowed_locals = borrowed_locals(body);
 
     // If the user requests complete debuginfo, mark the locals that appear in it as live, so
@@ -97,8 +99,9 @@ fn eliminate<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
     }
 
     if patch.is_empty() && call_operands_to_move.is_empty() {
-        return;
+        return false;
     }
+    let eliminated = !patch.is_empty();
 
     let bbs = body.basic_blocks.as_mut_preserves_cfg();
     for (Location { block, statement_index }, drop_debuginfo) in patch {
@@ -112,6 +115,8 @@ fn eliminate<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
         let Operand::Copy(place) = *arg else { bug!() };
         *arg = Operand::Move(place);
     }
+
+    eliminated
 }
 
 pub(super) enum DeadStoreElimination {
@@ -132,7 +137,12 @@ impl<'tcx> crate::MirPass<'tcx> for DeadStoreElimination {
     }
 
     fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
-        eliminate(tcx, body);
+        if eliminate(tcx, body) {
+            UsedInStmtLocals::new(body).remove_unused_storage_annotations(body);
+            for data in body.basic_blocks.as_mut_preserves_cfg() {
+                data.strip_nops();
+            }
+        }
     }
 
     fn is_required(&self) -> bool {
diff --git a/compiler/rustc_mir_transform/src/inline.rs b/compiler/rustc_mir_transform/src/inline.rs
index 3d49eb4e8ef75..8593e25d6aa5e 100644
--- a/compiler/rustc_mir_transform/src/inline.rs
+++ b/compiler/rustc_mir_transform/src/inline.rs
@@ -21,7 +21,7 @@ use tracing::{debug, instrument, trace, trace_span};
 
 use crate::cost_checker::{CostChecker, is_call_like};
 use crate::deref_separator::deref_finder;
-use crate::simplify::simplify_cfg;
+use crate::simplify::{UsedInStmtLocals, simplify_cfg};
 use crate::validate::validate_types;
 use crate::{check_inline, util};
 
@@ -935,7 +935,7 @@ fn inline_call<'tcx, I: Inliner<'tcx>>(
         in_cleanup_block: false,
         return_block,
         tcx,
-        always_live_locals: DenseBitSet::new_filled(callee_body.local_decls.len()),
+        always_live_locals: UsedInStmtLocals::new(&callee_body).locals,
     };
 
     // Map all `Local`s, `SourceScope`s and `BasicBlock`s to new ones
@@ -995,6 +995,10 @@ fn inline_call<'tcx, I: Inliner<'tcx>>(
         // people working on rust can build with or without debuginfo while
         // still getting consistent results from the mir-opt tests.
         caller_body.var_debug_info.append(&mut callee_body.var_debug_info);
+    } else {
+        for bb in callee_body.basic_blocks_mut() {
+            bb.drop_debuginfo();
+        }
     }
     caller_body.basic_blocks_mut().append(callee_body.basic_blocks_mut());
 
diff --git a/compiler/rustc_mir_transform/src/simplify.rs b/compiler/rustc_mir_transform/src/simplify.rs
index edea5cb2c7241..0f23482ea8b1b 100644
--- a/compiler/rustc_mir_transform/src/simplify.rs
+++ b/compiler/rustc_mir_transform/src/simplify.rs
@@ -35,12 +35,12 @@
 //! pre-"runtime" MIR!
 
 use itertools::Itertools as _;
+use rustc_index::bit_set::DenseBitSet;
 use rustc_index::{Idx, IndexSlice, IndexVec};
-use rustc_middle::mir::visit::{
-    MutVisitor, MutatingUseContext, NonUseContext, PlaceContext, Visitor,
-};
+use rustc_middle::mir::visit::{MutVisitor, MutatingUseContext, PlaceContext, Visitor};
 use rustc_middle::mir::*;
 use rustc_middle::ty::TyCtxt;
+use rustc_mir_dataflow::debuginfo::debuginfo_locals;
 use rustc_span::DUMMY_SP;
 use smallvec::SmallVec;
 use tracing::{debug, trace};
@@ -329,7 +329,7 @@ impl<'a, 'tcx> CfgSimplifier<'a, 'tcx> {
 
     fn strip_nops(&mut self) {
         for blk in self.basic_blocks.iter_mut() {
-            blk.retain_statements(|stmt| !matches!(stmt.kind, StatementKind::Nop))
+            blk.strip_nops();
         }
     }
 }
@@ -502,17 +502,22 @@ fn make_local_map<V>(
 /// Keeps track of used & unused locals.
 struct UsedLocals {
     increment: bool,
-    arg_count: u32,
     use_count: IndexVec<Local, u32>,
+    always_used: DenseBitSet<Local>,
 }
 
 impl UsedLocals {
     /// Determines which locals are used & unused in the given body.
     fn new(body: &Body<'_>) -> Self {
+        let mut always_used = debuginfo_locals(body);
+        always_used.insert(RETURN_PLACE);
+        for arg in body.args_iter() {
+            always_used.insert(arg);
+        }
         let mut this = Self {
             increment: true,
-            arg_count: body.arg_count.try_into().unwrap(),
             use_count: IndexVec::from_elem(0, &body.local_decls),
+            always_used,
         };
         this.visit_body(body);
         this
@@ -520,10 +525,16 @@ impl UsedLocals {
 
     /// Checks if local is used.
     ///
-    /// Return place and arguments are always considered used.
+    /// Return place, arguments, var debuginfo are always considered used.
     fn is_used(&self, local: Local) -> bool {
-        trace!("is_used({:?}): use_count: {:?}", local, self.use_count[local]);
-        local.as_u32() <= self.arg_count || self.use_count[local] != 0
+        trace!(
+            "is_used({:?}): use_count: {:?}, always_used: {}",
+            local,
+            self.use_count[local],
+            self.always_used.contains(local)
+        );
+        // To keep things simple, we don't handle debugging information here, these are in DSE.
+        self.always_used.contains(local) || self.use_count[local] != 0
     }
 
     /// Updates the use counts to reflect the removal of given statement.
@@ -568,17 +579,9 @@ impl<'tcx> Visitor<'tcx> for UsedLocals {
             StatementKind::ConstEvalCounter
             | StatementKind::Nop
             | StatementKind::StorageLive(..)
-            | StatementKind::StorageDead(..) => {
-                for debuginfo in statement.debuginfos.iter() {
-                    self.visit_statement_debuginfo(debuginfo, location);
-                }
-            }
-
+            | StatementKind::StorageDead(..) => {}
             StatementKind::Assign(box (ref place, ref rvalue)) => {
                 if rvalue.is_safe_to_remove() {
-                    for debuginfo in statement.debuginfos.iter() {
-                        self.visit_statement_debuginfo(debuginfo, location);
-                    }
                     self.visit_lhs(place, location);
                     self.visit_rvalue(rvalue, location);
                 } else {
@@ -589,18 +592,18 @@ impl<'tcx> Visitor<'tcx> for UsedLocals {
             StatementKind::SetDiscriminant { ref place, variant_index: _ }
             | StatementKind::Deinit(ref place)
             | StatementKind::BackwardIncompatibleDropHint { ref place, reason: _ } => {
-                for debuginfo in statement.debuginfos.iter() {
-                    self.visit_statement_debuginfo(debuginfo, location);
-                }
                 self.visit_lhs(place, location);
             }
         }
     }
 
     fn visit_local(&mut self, local: Local, ctx: PlaceContext, _location: Location) {
+        if matches!(ctx, PlaceContext::NonUse(_)) {
+            return;
+        }
         if self.increment {
             self.use_count[local] += 1;
-        } else if ctx != PlaceContext::NonUse(NonUseContext::VarDebugInfo) {
+        } else {
             assert_ne!(self.use_count[local], 0);
             self.use_count[local] -= 1;
         }
@@ -620,28 +623,26 @@ fn remove_unused_definitions_helper(used_locals: &mut UsedLocals, body: &mut Bod
 
         for data in body.basic_blocks.as_mut_preserves_cfg() {
             // Remove unnecessary StorageLive and StorageDead annotations.
-            data.retain_statements(|statement| {
-                let keep = match &statement.kind {
+            for statement in data.statements.iter_mut() {
+                let keep_statement = match &statement.kind {
                     StatementKind::StorageLive(local) | StatementKind::StorageDead(local) => {
                         used_locals.is_used(*local)
                     }
-                    StatementKind::Assign(box (place, _)) => used_locals.is_used(place.local),
-
-                    StatementKind::SetDiscriminant { place, .. }
-                    | StatementKind::BackwardIncompatibleDropHint { place, reason: _ }
-                    | StatementKind::Deinit(place) => used_locals.is_used(place.local),
-                    StatementKind::Nop => false,
-                    _ => true,
+                    StatementKind::Assign(box (place, _))
+                    | StatementKind::SetDiscriminant { box place, .. }
+                    | StatementKind::BackwardIncompatibleDropHint { box place, .. }
+                    | StatementKind::Deinit(box place) => used_locals.is_used(place.local),
+                    _ => continue,
                 };
-
-                if !keep {
-                    trace!("removing statement {:?}", statement);
-                    modified = true;
-                    used_locals.statement_removed(statement);
+                if keep_statement {
+                    continue;
                 }
-
-                keep
-            });
+                trace!("removing statement {:?}", statement);
+                modified = true;
+                used_locals.statement_removed(statement);
+                statement.make_nop(true);
+            }
+            data.strip_nops();
         }
     }
 }
@@ -660,3 +661,42 @@ impl<'tcx> MutVisitor<'tcx> for LocalUpdater<'tcx> {
         *l = self.map[*l].unwrap();
     }
 }
+
+pub(crate) struct UsedInStmtLocals {
+    pub(crate) locals: DenseBitSet<Local>,
+}
+
+impl UsedInStmtLocals {
+    pub(crate) fn new(body: &Body<'_>) -> Self {
+        let mut this = Self { locals: DenseBitSet::new_empty(body.local_decls.len()) };
+        this.visit_body(body);
+        this
+    }
+
+    pub(crate) fn remove_unused_storage_annotations<'tcx>(&self, body: &mut Body<'tcx>) {
+        for data in body.basic_blocks.as_mut_preserves_cfg() {
+            // Remove unnecessary StorageLive and StorageDead annotations.
+            for statement in data.statements.iter_mut() {
+                let keep_statement = match &statement.kind {
+                    StatementKind::StorageLive(local) | StatementKind::StorageDead(local) => {
+                        self.locals.contains(*local)
+                    }
+                    _ => continue,
+                };
+                if keep_statement {
+                    continue;
+                }
+                statement.make_nop(true);
+            }
+        }
+    }
+}
+
+impl<'tcx> Visitor<'tcx> for UsedInStmtLocals {
+    fn visit_local(&mut self, local: Local, context: PlaceContext, _: Location) {
+        if matches!(context, PlaceContext::NonUse(_)) {
+            return;
+        }
+        self.locals.insert(local);
+    }
+}
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 ff18df1efcfc9..d584de6861c0c 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
@@ -19,10 +19,6 @@
 -         _3 = copy _2;
 -         _2 = copy _1;
 -         _1 = copy _5;
-+         nop;
-+         nop;
-+         nop;
-+         nop;
           _4 = cond() -> [return: bb1, unwind continue];
       }
   
diff --git a/tests/mir-opt/dead-store-elimination/ref.dead_first.DeadStoreElimination-initial.diff b/tests/mir-opt/dead-store-elimination/ref.dead_first.DeadStoreElimination-initial.diff
index d823241bc620a..2a793e24990ae 100644
--- a/tests/mir-opt/dead-store-elimination/ref.dead_first.DeadStoreElimination-initial.diff
+++ b/tests/mir-opt/dead-store-elimination/ref.dead_first.DeadStoreElimination-initial.diff
@@ -15,7 +15,6 @@
           StorageLive(_2);
 -         _2 = &((*_1).2: i32);
 +         // DBG: _2 = &((*_1).2: i32);
-+         nop;
           StorageLive(_3);
           StorageLive(_4);
           _4 = &((*_1).0: i32);
diff --git a/tests/mir-opt/dead-store-elimination/ref.tuple.DeadStoreElimination-initial.diff b/tests/mir-opt/dead-store-elimination/ref.tuple.DeadStoreElimination-initial.diff
index 0547a42cab246..af28c1b9aa87a 100644
--- a/tests/mir-opt/dead-store-elimination/ref.tuple.DeadStoreElimination-initial.diff
+++ b/tests/mir-opt/dead-store-elimination/ref.tuple.DeadStoreElimination-initial.diff
@@ -12,14 +12,13 @@
       }
   
       bb0: {
-          StorageLive(_2);
+-         StorageLive(_2);
           _3 = deref_copy (_1.1: &Foo);
 -         _2 = &((*_3).2: i32);
 +         // DBG: _2 = &((*_3).2: i32);
-+         nop;
           _4 = deref_copy (_1.1: &Foo);
           _0 = copy ((*_4).0: i32);
-          StorageDead(_2);
+-         StorageDead(_2);
           return;
       }
   }
diff --git a/tests/mir-opt/debuginfo/simplifycfg.drop_debuginfo.SimplifyCfg-final.diff b/tests/mir-opt/debuginfo/simplifycfg.drop_debuginfo.SimplifyCfg-final.diff
index 7a1ac92f6dde9..d4a73351ee4a5 100644
--- a/tests/mir-opt/debuginfo/simplifycfg.drop_debuginfo.SimplifyCfg-final.diff
+++ b/tests/mir-opt/debuginfo/simplifycfg.drop_debuginfo.SimplifyCfg-final.diff
@@ -14,13 +14,11 @@
 - 
 -     bb1: {
 -         // DBG: _3 = &((*_1).0: i32);
--         nop;
 -         goto -> bb2;
 -     }
 - 
 -     bb2: {
           // DBG: _4 = &((*_1).1: i64);
--         nop;
           _0 = copy ((*_1).2: i32);
           return;
       }
diff --git a/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_1.SimplifyCfg-final.diff b/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_1.SimplifyCfg-final.diff
index fa4d3aebf8384..1c12358ad8934 100644
--- a/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_1.SimplifyCfg-final.diff
+++ b/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_1.SimplifyCfg-final.diff
@@ -17,16 +17,13 @@
 -     bb1: {
           (*_2) = const true;
           // DBG: _3 = &((*_1).0: i32);
--         nop;
 -         goto -> bb2;
 -     }
 - 
 -     bb2: {
           // DBG: _4 = &((*_1).1: i64);
--         nop;
           _0 = copy ((*_1).2: i32);
           // DBG: _5 = &((*_1).2: i32);
--         nop;
           return;
       }
   }
diff --git a/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_2.SimplifyCfg-final.diff b/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_2.SimplifyCfg-final.diff
index b01c91f196b65..de8e5612c8788 100644
--- a/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_2.SimplifyCfg-final.diff
+++ b/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_2.SimplifyCfg-final.diff
@@ -16,16 +16,13 @@
 - 
 -     bb1: {
           // DBG: _2 = &((*_1).0: i32);
--         nop;
 -         goto -> bb2;
 -     }
 - 
 -     bb2: {
           // DBG: _3 = &((*_1).1: i64);
--         nop;
           _0 = copy ((*_1).2: i32);
           // DBG: _4 = &((*_1).2: i32);
--         nop;
           return;
       }
   }
diff --git a/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_3.SimplifyCfg-final.diff b/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_3.SimplifyCfg-final.diff
index caa90d79a1c27..11372a262a76e 100644
--- a/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_3.SimplifyCfg-final.diff
+++ b/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_3.SimplifyCfg-final.diff
@@ -17,13 +17,11 @@
   
       bb1: {
 -         // DBG: _3 = &((*_1).0: i32);
--         nop;
 -         goto -> bb3;
 -     }
 - 
 -     bb2: {
           // DBG: _4 = &((*_1).1: i64);
--         nop;
           _0 = copy ((*_1).2: i32);
           return;
       }
@@ -32,7 +30,6 @@
 +     bb2: {
 +         // DBG: _3 = &((*_1).0: i32);
           // DBG: _5 = &((*_1).2: i32);
--         nop;
           _0 = copy ((*_1).0: i32);
           return;
       }
diff --git a/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_identical_succs.SimplifyCfg-final.diff b/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_identical_succs.SimplifyCfg-final.diff
index d8c36990a5ff0..0c6a75237d8b2 100644
--- a/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_identical_succs.SimplifyCfg-final.diff
+++ b/tests/mir-opt/debuginfo/simplifycfg.preserve_debuginfo_identical_succs.SimplifyCfg-final.diff
@@ -16,16 +16,13 @@
 - 
 -     bb1: {
           // DBG: _3 = &((*_1).0: i32);
--         nop;
 -         goto -> bb2;
 -     }
 - 
 -     bb2: {
           // DBG: _4 = &((*_1).1: i64);
--         nop;
           _0 = copy ((*_1).2: i32);
           // DBG: _5 = &((*_1).2: i32);
--         nop;
           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 f7729c7c5fa6d..7fa22524f0082 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
@@ -64,9 +64,7 @@
 +         StorageLive(_8);
 +         StorageLive(_9);
 +         StorageLive(_11);
-+         // DBG: _11 = &((*_6).0: alloc::raw_vec::RawVec<A>);
 +         StorageLive(_12);
-+         // DBG: _12 = &(((*_6).0: alloc::raw_vec::RawVec<A>).0: alloc::raw_vec::RawVecInner);
 +         StorageLive(_13);
 +         _13 = copy (((((*_6).0: alloc::raw_vec::RawVec<A>).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique<u8>).0: std::ptr::NonNull<u8>);
 +         _9 = copy _13 as *mut A (Transmute);
@@ -92,7 +90,6 @@
           _5 = copy _2;
 -         _0 = drop_in_place::<Option<B>>(move _5) -> [return: bb2, unwind unreachable];
 +         StorageLive(_17);
-+         StorageLive(_18);
 +         _17 = discriminant((*_5));
 +         switchInt(move _17) -> [0: bb5, otherwise: bb6];
       }
@@ -118,7 +115,6 @@
 +     }
 + 
 +     bb5: {
-+         StorageDead(_18);
 +         StorageDead(_17);
           StorageDead(_5);
           return;
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 1832427642528..34f89da19f51f 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
@@ -27,13 +27,11 @@
           _5 = copy _2;
 -         _0 = drop_in_place::<Option<B>>(move _5) -> [return: bb2, unwind continue];
 +         StorageLive(_6);
-+         StorageLive(_7);
 +         _6 = discriminant((*_5));
 +         switchInt(move _6) -> [0: bb2, otherwise: bb3];
       }
   
       bb2: {
-+         StorageDead(_7);
 +         StorageDead(_6);
           StorageDead(_5);
           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 649b5a652027d..bb81cb4e2600a 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
@@ -129,11 +129,8 @@
           _10 = deref_copy (_1.1: &mut std::task::Context<'_>);
           _9 = &mut (*_10);
 -         _7 = <{async fn body of ActionPermit<'_, T>::perform()} as Future>::poll(move _8, move _9) -> [return: bb3, unwind unreachable];
-+         StorageLive(_11);
-+         StorageLive(_15);
 +         StorageLive(_16);
 +         StorageLive(_25);
-+         StorageLive(_27);
 +         StorageLive(_30);
 +         StorageLive(_31);
 +         StorageLive(_32);
@@ -166,11 +163,8 @@
 +         StorageDead(_32);
 +         StorageDead(_31);
 +         StorageDead(_30);
-+         StorageDead(_27);
 +         StorageDead(_25);
 +         StorageDead(_16);
-+         StorageDead(_15);
-+         StorageDead(_11);
           StorageDead(_9);
           StorageDead(_8);
           StorageDead(_7);
@@ -223,17 +217,13 @@
 +         _22 = &mut (*_23);
 +         StorageDead(_24);
 +         StorageLive(_44);
-+         StorageLive(_45);
 +         StorageLive(_49);
 +         StorageLive(_41);
 +         StorageLive(_42);
 +         StorageLive(_43);
-+         // DBG: _45 = &_19;
 +         StorageLive(_46);
-+         // DBG: _46 = &(_19.0: &mut std::future::Ready<()>);
 +         _44 = copy (_19.0: &mut std::future::Ready<()>);
 +         StorageDead(_46);
-+         // DBG: _43 = &((*_44).0: std::option::Option<()>);
 +         StorageLive(_47);
 +         _47 = Option::<()>::None;
 +         _42 = copy ((*_44).0: std::option::Option<()>);
@@ -315,7 +305,6 @@
 +         _18 = Poll::<()>::Ready(move _41);
 +         StorageDead(_41);
 +         StorageDead(_49);
-+         StorageDead(_45);
 +         StorageDead(_44);
 +         StorageDead(_22);
 +         StorageDead(_19);
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 32021b20ef44b..520c54824e150 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
@@ -131,11 +131,8 @@
           _10 = deref_copy (_1.1: &mut std::task::Context<'_>);
           _9 = &mut (*_10);
 -         _7 = <{async fn body of ActionPermit<'_, T>::perform()} as Future>::poll(move _8, move _9) -> [return: bb3, unwind: bb5];
-+         StorageLive(_11);
-+         StorageLive(_15);
 +         StorageLive(_16);
 +         StorageLive(_25);
-+         StorageLive(_27);
 +         StorageLive(_30);
 +         StorageLive(_31);
 +         StorageLive(_32);
@@ -180,11 +177,8 @@
 +         StorageDead(_32);
 +         StorageDead(_31);
 +         StorageDead(_30);
-+         StorageDead(_27);
 +         StorageDead(_25);
 +         StorageDead(_16);
-+         StorageDead(_15);
-+         StorageDead(_11);
           StorageDead(_9);
           StorageDead(_8);
           StorageDead(_7);
@@ -240,17 +234,13 @@
 +         _22 = &mut (*_23);
 +         StorageDead(_24);
 +         StorageLive(_46);
-+         StorageLive(_47);
 +         StorageLive(_51);
 +         StorageLive(_43);
 +         StorageLive(_44);
 +         StorageLive(_45);
-+         // DBG: _47 = &_19;
 +         StorageLive(_48);
-+         // DBG: _48 = &(_19.0: &mut std::future::Ready<()>);
 +         _46 = copy (_19.0: &mut std::future::Ready<()>);
 +         StorageDead(_48);
-+         // DBG: _45 = &((*_46).0: std::option::Option<()>);
 +         StorageLive(_49);
 +         _49 = Option::<()>::None;
 +         _44 = copy ((*_46).0: std::option::Option<()>);
@@ -356,7 +346,6 @@
 +         _18 = Poll::<()>::Ready(move _43);
 +         StorageDead(_43);
 +         StorageDead(_51);
-+         StorageDead(_47);
 +         StorageDead(_46);
 +         StorageDead(_22);
 +         StorageDead(_19);
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 ac88fe67bb86f..3ea7387a48d3c 100644
--- a/tests/mir-opt/issue_101973.inner.GVN.panic-abort.diff
+++ b/tests/mir-opt/issue_101973.inner.GVN.panic-abort.diff
@@ -30,7 +30,6 @@
           StorageLive(_4);
           StorageLive(_5);
           _5 = copy _1;
-          nop;
 -         StorageLive(_14);
 -         _14 = BitAnd(copy _5, const 255_u32);
 -         _4 = BitOr(const 0_u32, move _14);
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 96c3cae2d334a..832db856b2cf9 100644
--- a/tests/mir-opt/issue_101973.inner.GVN.panic-unwind.diff
+++ b/tests/mir-opt/issue_101973.inner.GVN.panic-unwind.diff
@@ -30,7 +30,6 @@
           StorageLive(_4);
           StorageLive(_5);
           _5 = copy _1;
-          nop;
 -         StorageLive(_14);
 -         _14 = BitAnd(copy _5, const 255_u32);
 -         _4 = BitOr(const 0_u32, move _14);
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 a294c1b4588db..614d9ad440d20 100644
--- a/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff
+++ b/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff
@@ -33,15 +33,9 @@
       }
   
       bb2: {
-          StorageLive(_5);
           // DBG: _5 = &(*_2)[0 of 3];
-          StorageLive(_6);
           // DBG: _6 = &(*_2)[1 of 3];
-          StorageLive(_7);
           // DBG: _7 = &(*_2)[2 of 3];
-          StorageDead(_7);
-          StorageDead(_6);
-          StorageDead(_5);
           StorageDead(_4);
           return;
       }
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 691271cf94edf..57a88cf898412 100644
--- a/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff
+++ b/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff
@@ -33,15 +33,9 @@
       }
   
       bb2: {
-          StorageLive(_5);
           // DBG: _5 = &(*_2)[0 of 3];
-          StorageLive(_6);
           // DBG: _6 = &(*_2)[1 of 3];
-          StorageLive(_7);
           // DBG: _7 = &(*_2)[2 of 3];
-          StorageDead(_7);
-          StorageDead(_6);
-          StorageDead(_5);
           StorageDead(_4);
           return;
       }
diff --git a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.32bit.panic-abort.mir b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.32bit.panic-abort.mir
index d4248f5d87fbc..b5c23822162c9 100644
--- a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.32bit.panic-abort.mir
+++ b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.32bit.panic-abort.mir
@@ -6,7 +6,6 @@ fn num_to_digit(_1: char) -> u32 {
     let mut _4: std::option::Option<u32>;
     scope 1 (inlined char::methods::<impl char>::is_digit) {
         let _2: std::option::Option<u32>;
-        let mut _7: &std::option::Option<u32>;
         scope 2 (inlined Option::<u32>::is_some) {
             let mut _3: isize;
             scope 3 {
@@ -21,17 +20,14 @@ fn num_to_digit(_1: char) -> u32 {
     }
 
     bb0: {
-        StorageLive(_7);
         StorageLive(_2);
         _2 = char::methods::<impl char>::to_digit(copy _1, const 8_u32) -> [return: bb1, unwind unreachable];
     }
 
     bb1: {
-        // DBG: _7 = &_2;
         StorageLive(_3);
         _3 = discriminant(_2);
         StorageDead(_2);
-        StorageDead(_7);
         switchInt(move _3) -> [1: bb2, otherwise: bb7];
     }
 
diff --git a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.32bit.panic-unwind.mir b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.32bit.panic-unwind.mir
index a834932df5a82..f22b8835735d1 100644
--- a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.32bit.panic-unwind.mir
+++ b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.32bit.panic-unwind.mir
@@ -6,7 +6,6 @@ fn num_to_digit(_1: char) -> u32 {
     let mut _4: std::option::Option<u32>;
     scope 1 (inlined char::methods::<impl char>::is_digit) {
         let _2: std::option::Option<u32>;
-        let mut _7: &std::option::Option<u32>;
         scope 2 (inlined Option::<u32>::is_some) {
             let mut _3: isize;
             scope 3 {
@@ -21,17 +20,14 @@ fn num_to_digit(_1: char) -> u32 {
     }
 
     bb0: {
-        StorageLive(_7);
         StorageLive(_2);
         _2 = char::methods::<impl char>::to_digit(copy _1, const 8_u32) -> [return: bb1, unwind continue];
     }
 
     bb1: {
-        // DBG: _7 = &_2;
         StorageLive(_3);
         _3 = discriminant(_2);
         StorageDead(_2);
-        StorageDead(_7);
         switchInt(move _3) -> [1: bb2, otherwise: bb7];
     }
 
diff --git a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.64bit.panic-abort.mir b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.64bit.panic-abort.mir
index d4248f5d87fbc..b5c23822162c9 100644
--- a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.64bit.panic-abort.mir
+++ b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.64bit.panic-abort.mir
@@ -6,7 +6,6 @@ fn num_to_digit(_1: char) -> u32 {
     let mut _4: std::option::Option<u32>;
     scope 1 (inlined char::methods::<impl char>::is_digit) {
         let _2: std::option::Option<u32>;
-        let mut _7: &std::option::Option<u32>;
         scope 2 (inlined Option::<u32>::is_some) {
             let mut _3: isize;
             scope 3 {
@@ -21,17 +20,14 @@ fn num_to_digit(_1: char) -> u32 {
     }
 
     bb0: {
-        StorageLive(_7);
         StorageLive(_2);
         _2 = char::methods::<impl char>::to_digit(copy _1, const 8_u32) -> [return: bb1, unwind unreachable];
     }
 
     bb1: {
-        // DBG: _7 = &_2;
         StorageLive(_3);
         _3 = discriminant(_2);
         StorageDead(_2);
-        StorageDead(_7);
         switchInt(move _3) -> [1: bb2, otherwise: bb7];
     }
 
diff --git a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.64bit.panic-unwind.mir b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.64bit.panic-unwind.mir
index a834932df5a82..f22b8835735d1 100644
--- a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.64bit.panic-unwind.mir
+++ b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.64bit.panic-unwind.mir
@@ -6,7 +6,6 @@ fn num_to_digit(_1: char) -> u32 {
     let mut _4: std::option::Option<u32>;
     scope 1 (inlined char::methods::<impl char>::is_digit) {
         let _2: std::option::Option<u32>;
-        let mut _7: &std::option::Option<u32>;
         scope 2 (inlined Option::<u32>::is_some) {
             let mut _3: isize;
             scope 3 {
@@ -21,17 +20,14 @@ fn num_to_digit(_1: char) -> u32 {
     }
 
     bb0: {
-        StorageLive(_7);
         StorageLive(_2);
         _2 = char::methods::<impl char>::to_digit(copy _1, const 8_u32) -> [return: bb1, unwind continue];
     }
 
     bb1: {
-        // DBG: _7 = &_2;
         StorageLive(_3);
         _3 = discriminant(_2);
         StorageDead(_2);
-        StorageDead(_7);
         switchInt(move _3) -> [1: bb2, otherwise: bb7];
     }
 
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 23dbc066dd528..83478e60b5d4e 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
@@ -5,9 +5,7 @@ fn step_forward(_1: u16, _2: usize) -> u16 {
     debug n => _2;
     let mut _0: u16;
     scope 1 (inlined <u16 as Step>::forward) {
-        let _8: std::option::Option<u16>;
-        let mut _10: u16;
-        let mut _11: &std::option::Option<u16>;
+        let mut _8: u16;
         scope 2 {
         }
         scope 3 (inlined <u16 as Step>::forward_checked) {
@@ -15,9 +13,8 @@ fn step_forward(_1: u16, _2: usize) -> u16 {
                 scope 6 (inlined core::num::<impl u16>::checked_add) {
                     let mut _5: (u16, bool);
                     let mut _6: bool;
-                    let mut _7: u16;
                     scope 7 (inlined std::intrinsics::unlikely) {
-                        let _9: ();
+                        let _7: ();
                     }
                 }
             }
@@ -38,8 +35,6 @@ fn step_forward(_1: u16, _2: usize) -> u16 {
 
     bb0: {
         StorageLive(_4);
-        StorageLive(_11);
-        StorageLive(_8);
         StorageLive(_3);
         _3 = Gt(copy _2, const 65535_usize);
         switchInt(move _3) -> [0: bb1, otherwise: bb5];
@@ -58,55 +53,34 @@ fn step_forward(_1: u16, _2: usize) -> u16 {
     bb2: {
         StorageDead(_5);
         StorageDead(_6);
-        StorageLive(_7);
-        _7 = AddUnchecked(copy _1, copy _4);
-        _8 = Option::<u16>::Some(move _7);
-        StorageDead(_7);
-        // DBG: _11 = &_8;
-        StorageDead(_8);
-        StorageDead(_11);
         goto -> bb7;
     }
 
     bb3: {
-        _9 = std::intrinsics::cold_path() -> [return: bb4, unwind unreachable];
+        _7 = std::intrinsics::cold_path() -> [return: bb4, unwind unreachable];
     }
 
     bb4: {
         StorageDead(_5);
         StorageDead(_6);
-        _8 = const Option::<u16>::None;
-        // DBG: _11 = &_8;
         goto -> bb6;
     }
 
     bb5: {
         StorageDead(_3);
-        _8 = const Option::<u16>::None;
-        // DBG: _11 = &_8;
         goto -> bb6;
     }
 
     bb6: {
-        StorageDead(_8);
-        StorageDead(_11);
         assert(!const true, "attempt to compute `{} + {}`, which would overflow", const core::num::<impl u16>::MAX, const 1_u16) -> [success: bb7, unwind unreachable];
     }
 
     bb7: {
-        StorageLive(_10);
-        _10 = copy _2 as u16 (IntToInt);
-        _0 = Add(copy _1, copy _10);
-        StorageDead(_10);
+        StorageLive(_8);
+        _8 = copy _2 as u16 (IntToInt);
+        _0 = Add(copy _1, copy _8);
+        StorageDead(_8);
         StorageDead(_4);
         return;
     }
 }
-
-ALLOC0 (size: 4, align: 2) {
-    00 00 __ __                                     │ ..░░
-}
-
-ALLOC1 (size: 4, align: 2) {
-    00 00 __ __                                     │ ..░░
-}
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 ac15f070597ea..ac7a6e0445191 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
@@ -5,9 +5,7 @@ fn step_forward(_1: u16, _2: usize) -> u16 {
     debug n => _2;
     let mut _0: u16;
     scope 1 (inlined <u16 as Step>::forward) {
-        let _8: std::option::Option<u16>;
-        let mut _10: u16;
-        let mut _11: &std::option::Option<u16>;
+        let mut _8: u16;
         scope 2 {
         }
         scope 3 (inlined <u16 as Step>::forward_checked) {
@@ -15,9 +13,8 @@ fn step_forward(_1: u16, _2: usize) -> u16 {
                 scope 6 (inlined core::num::<impl u16>::checked_add) {
                     let mut _5: (u16, bool);
                     let mut _6: bool;
-                    let mut _7: u16;
                     scope 7 (inlined std::intrinsics::unlikely) {
-                        let _9: ();
+                        let _7: ();
                     }
                 }
             }
@@ -38,8 +35,6 @@ fn step_forward(_1: u16, _2: usize) -> u16 {
 
     bb0: {
         StorageLive(_4);
-        StorageLive(_11);
-        StorageLive(_8);
         StorageLive(_3);
         _3 = Gt(copy _2, const 65535_usize);
         switchInt(move _3) -> [0: bb1, otherwise: bb5];
@@ -58,55 +53,34 @@ fn step_forward(_1: u16, _2: usize) -> u16 {
     bb2: {
         StorageDead(_5);
         StorageDead(_6);
-        StorageLive(_7);
-        _7 = AddUnchecked(copy _1, copy _4);
-        _8 = Option::<u16>::Some(move _7);
-        StorageDead(_7);
-        // DBG: _11 = &_8;
-        StorageDead(_8);
-        StorageDead(_11);
         goto -> bb7;
     }
 
     bb3: {
-        _9 = std::intrinsics::cold_path() -> [return: bb4, unwind unreachable];
+        _7 = std::intrinsics::cold_path() -> [return: bb4, unwind unreachable];
     }
 
     bb4: {
         StorageDead(_5);
         StorageDead(_6);
-        _8 = const Option::<u16>::None;
-        // DBG: _11 = &_8;
         goto -> bb6;
     }
 
     bb5: {
         StorageDead(_3);
-        _8 = const Option::<u16>::None;
-        // DBG: _11 = &_8;
         goto -> bb6;
     }
 
     bb6: {
-        StorageDead(_8);
-        StorageDead(_11);
         assert(!const true, "attempt to compute `{} + {}`, which would overflow", const core::num::<impl u16>::MAX, const 1_u16) -> [success: bb7, unwind continue];
     }
 
     bb7: {
-        StorageLive(_10);
-        _10 = copy _2 as u16 (IntToInt);
-        _0 = Add(copy _1, copy _10);
-        StorageDead(_10);
+        StorageLive(_8);
+        _8 = copy _2 as u16 (IntToInt);
+        _0 = Add(copy _1, copy _8);
+        StorageDead(_8);
         StorageDead(_4);
         return;
     }
 }
-
-ALLOC0 (size: 4, align: 2) {
-    00 00 __ __                                     │ ..░░
-}
-
-ALLOC1 (size: 4, align: 2) {
-    00 00 __ __                                     │ ..░░
-}
diff --git a/tests/mir-opt/pre-codegen/clone_as_copy.clone_as_copy.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/clone_as_copy.clone_as_copy.PreCodegen.after.mir
index 66239a0ef6637..1e6e2ee1b8b73 100644
--- a/tests/mir-opt/pre-codegen/clone_as_copy.clone_as_copy.PreCodegen.after.mir
+++ b/tests/mir-opt/pre-codegen/clone_as_copy.clone_as_copy.PreCodegen.after.mir
@@ -12,10 +12,8 @@ fn clone_as_copy(_1: &NestCopy) -> NestCopy {
     }
 
     bb0: {
-        StorageLive(_2);
         // DBG: _2 = &((*_1).1: AllCopy);
         _0 = copy (*_1);
-        StorageDead(_2);
         return;
     }
 }
diff --git a/tests/mir-opt/pre-codegen/clone_as_copy.enum_clone_as_copy.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/clone_as_copy.enum_clone_as_copy.PreCodegen.after.mir
index aa03cec070ad3..76bb49bc9c1b3 100644
--- a/tests/mir-opt/pre-codegen/clone_as_copy.enum_clone_as_copy.PreCodegen.after.mir
+++ b/tests/mir-opt/pre-codegen/clone_as_copy.enum_clone_as_copy.PreCodegen.after.mir
@@ -5,58 +5,28 @@ fn enum_clone_as_copy(_1: &Enum1) -> Enum1 {
     let mut _0: Enum1;
     scope 1 (inlined <Enum1 as Clone>::clone) {
         debug self => _1;
-        let mut _2: isize;
-        let _3: &AllCopy;
-        let _4: &NestCopy;
+        let _2: &AllCopy;
+        let _3: &NestCopy;
         scope 2 {
-            debug __self_0 => _3;
+            debug __self_0 => _2;
             scope 6 (inlined <AllCopy as Clone>::clone) {
-                debug self => _3;
+                debug self => _2;
             }
         }
         scope 3 {
-            debug __self_0 => _4;
+            debug __self_0 => _3;
             scope 4 (inlined <NestCopy as Clone>::clone) {
-                debug self => _4;
-                let _5: &AllCopy;
+                debug self => _3;
+                let _4: &AllCopy;
                 scope 5 (inlined <AllCopy as Clone>::clone) {
-                    debug self => _5;
+                    debug self => _4;
                 }
             }
         }
     }
 
     bb0: {
-        StorageLive(_2);
-        StorageLive(_3);
-        StorageLive(_4);
-        _2 = discriminant((*_1));
-        switchInt(move _2) -> [0: bb1, 1: bb2, otherwise: bb4];
-    }
-
-    bb1: {
-        // DBG: _3 = &(((*_1) as A).0: AllCopy);
         _0 = copy (*_1);
-        goto -> bb3;
-    }
-
-    bb2: {
-        // DBG: _4 = &(((*_1) as B).0: NestCopy);
-        StorageLive(_5);
-        // DBG: _5 = &((((*_1) as B).0: NestCopy).1: AllCopy);
-        StorageDead(_5);
-        _0 = copy (*_1);
-        goto -> bb3;
-    }
-
-    bb3: {
-        StorageDead(_4);
-        StorageDead(_3);
-        StorageDead(_2);
         return;
     }
-
-    bb4: {
-        unreachable;
-    }
 }
diff --git a/tests/mir-opt/pre-codegen/clone_as_copy.rs b/tests/mir-opt/pre-codegen/clone_as_copy.rs
index f5ff1854d387d..00f24754d5913 100644
--- a/tests/mir-opt/pre-codegen/clone_as_copy.rs
+++ b/tests/mir-opt/pre-codegen/clone_as_copy.rs
@@ -25,19 +25,19 @@ enum Enum1 {
 // EMIT_MIR clone_as_copy.clone_as_copy.PreCodegen.after.mir
 fn clone_as_copy(v: &NestCopy) -> NestCopy {
     // CHECK-LABEL: fn clone_as_copy(
-    // CHECK-NOT: = AllCopy { {{.*}} };
-    // CHECK-NOT: = NestCopy { {{.*}} };
-    // CHECK: _0 = copy (*_1);
-    // CHECK: return;
+    // CHECK: let [[DEAD_VAR:_.*]]: &AllCopy;
+    // CHECK: bb0: {
+    // CHECK-NEXT: DBG: [[DEAD_VAR]] = &((*_1).1: AllCopy)
+    // CHECK-NEXT: _0 = copy (*_1);
+    // CHECK-NEXT: return;
     v.clone()
 }
 
-// FIXME: We can merge into exactly one assignment statement.
 // EMIT_MIR clone_as_copy.enum_clone_as_copy.PreCodegen.after.mir
 fn enum_clone_as_copy(v: &Enum1) -> Enum1 {
     // CHECK-LABEL: fn enum_clone_as_copy(
-    // CHECK-NOT: = Enum1::
-    // CHECK: _0 = copy (*_1);
-    // CHECK: _0 = copy (*_1);
+    // CHECK: bb0: {
+    // CHECK-NEXT: _0 = copy (*_1);
+    // CHECK-NEXT: return;
     v.clone()
 }
diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-abort.mir b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-abort.mir
index 0dd2125dbe0d2..ba6ce0ee5286f 100644
--- a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-abort.mir
@@ -8,10 +8,9 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
             let _2: std::ptr::NonNull<[T]>;
             let mut _3: *mut [T];
             let mut _4: *const [T];
-            let _12: ();
-            let mut _13: &std::alloc::Layout;
+            let _11: ();
             scope 3 {
-                let _8: std::alloc::Layout;
+                let _8: std::ptr::alignment::AlignmentEnum;
                 scope 4 {
                     scope 12 (inlined Layout::size) {
                     }
@@ -27,19 +26,15 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
                     }
                     scope 18 (inlined <std::alloc::Global as Allocator>::deallocate) {
                         let mut _9: *mut u8;
-                        let mut _14: &std::alloc::Layout;
                         scope 19 (inlined Layout::size) {
                         }
                         scope 20 (inlined NonNull::<u8>::as_ptr) {
                         }
                         scope 21 (inlined std::alloc::dealloc) {
-                            let mut _11: usize;
-                            let mut _15: &std::alloc::Layout;
-                            let mut _16: &std::alloc::Layout;
+                            let mut _10: usize;
                             scope 22 (inlined Layout::size) {
                             }
                             scope 23 (inlined Layout::align) {
-                                let mut _10: std::ptr::alignment::AlignmentEnum;
                                 scope 24 (inlined std::ptr::Alignment::as_usize) {
                                 }
                             }
@@ -68,7 +63,6 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
     }
 
     bb0: {
-        StorageLive(_8);
         StorageLive(_2);
         _2 = copy (((*_1).0: std::ptr::Unique<[T]>).0: std::ptr::NonNull<[T]>);
         StorageLive(_4);
@@ -80,45 +74,31 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
 
     bb1: {
         _6 = AlignOf(T);
+        StorageLive(_7);
         _7 = copy _6 as std::ptr::Alignment (Transmute);
-        _8 = Layout { size: copy _5, align: copy _7 };
+        _8 = move (_7.0: std::ptr::alignment::AlignmentEnum);
+        StorageDead(_7);
         StorageDead(_6);
         StorageDead(_4);
-        StorageLive(_13);
-        // DBG: _13 = &_8;
-        StorageDead(_13);
         switchInt(copy _5) -> [0: bb4, otherwise: bb2];
     }
 
     bb2: {
-        StorageLive(_14);
-        // DBG: _14 = &_8;
-        StorageDead(_14);
         StorageLive(_9);
         _9 = copy _3 as *mut u8 (PtrToPtr);
-        StorageLive(_15);
-        // DBG: _15 = &_8;
-        StorageDead(_15);
-        StorageLive(_11);
-        StorageLive(_16);
-        // DBG: _16 = &_8;
         StorageLive(_10);
-        _10 = copy (_7.0: std::ptr::alignment::AlignmentEnum);
-        _11 = discriminant(_10);
-        StorageDead(_10);
-        StorageDead(_16);
-        _12 = alloc::alloc::__rust_dealloc(move _9, move _5, move _11) -> [return: bb3, unwind unreachable];
+        _10 = discriminant(_8);
+        _11 = alloc::alloc::__rust_dealloc(move _9, move _5, move _10) -> [return: bb3, unwind unreachable];
     }
 
     bb3: {
-        StorageDead(_11);
+        StorageDead(_10);
         StorageDead(_9);
         goto -> bb4;
     }
 
     bb4: {
         StorageDead(_2);
-        StorageDead(_8);
         return;
     }
 }
diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-unwind.mir b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-unwind.mir
index 0dd2125dbe0d2..ba6ce0ee5286f 100644
--- a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-unwind.mir
@@ -8,10 +8,9 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
             let _2: std::ptr::NonNull<[T]>;
             let mut _3: *mut [T];
             let mut _4: *const [T];
-            let _12: ();
-            let mut _13: &std::alloc::Layout;
+            let _11: ();
             scope 3 {
-                let _8: std::alloc::Layout;
+                let _8: std::ptr::alignment::AlignmentEnum;
                 scope 4 {
                     scope 12 (inlined Layout::size) {
                     }
@@ -27,19 +26,15 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
                     }
                     scope 18 (inlined <std::alloc::Global as Allocator>::deallocate) {
                         let mut _9: *mut u8;
-                        let mut _14: &std::alloc::Layout;
                         scope 19 (inlined Layout::size) {
                         }
                         scope 20 (inlined NonNull::<u8>::as_ptr) {
                         }
                         scope 21 (inlined std::alloc::dealloc) {
-                            let mut _11: usize;
-                            let mut _15: &std::alloc::Layout;
-                            let mut _16: &std::alloc::Layout;
+                            let mut _10: usize;
                             scope 22 (inlined Layout::size) {
                             }
                             scope 23 (inlined Layout::align) {
-                                let mut _10: std::ptr::alignment::AlignmentEnum;
                                 scope 24 (inlined std::ptr::Alignment::as_usize) {
                                 }
                             }
@@ -68,7 +63,6 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
     }
 
     bb0: {
-        StorageLive(_8);
         StorageLive(_2);
         _2 = copy (((*_1).0: std::ptr::Unique<[T]>).0: std::ptr::NonNull<[T]>);
         StorageLive(_4);
@@ -80,45 +74,31 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
 
     bb1: {
         _6 = AlignOf(T);
+        StorageLive(_7);
         _7 = copy _6 as std::ptr::Alignment (Transmute);
-        _8 = Layout { size: copy _5, align: copy _7 };
+        _8 = move (_7.0: std::ptr::alignment::AlignmentEnum);
+        StorageDead(_7);
         StorageDead(_6);
         StorageDead(_4);
-        StorageLive(_13);
-        // DBG: _13 = &_8;
-        StorageDead(_13);
         switchInt(copy _5) -> [0: bb4, otherwise: bb2];
     }
 
     bb2: {
-        StorageLive(_14);
-        // DBG: _14 = &_8;
-        StorageDead(_14);
         StorageLive(_9);
         _9 = copy _3 as *mut u8 (PtrToPtr);
-        StorageLive(_15);
-        // DBG: _15 = &_8;
-        StorageDead(_15);
-        StorageLive(_11);
-        StorageLive(_16);
-        // DBG: _16 = &_8;
         StorageLive(_10);
-        _10 = copy (_7.0: std::ptr::alignment::AlignmentEnum);
-        _11 = discriminant(_10);
-        StorageDead(_10);
-        StorageDead(_16);
-        _12 = alloc::alloc::__rust_dealloc(move _9, move _5, move _11) -> [return: bb3, unwind unreachable];
+        _10 = discriminant(_8);
+        _11 = alloc::alloc::__rust_dealloc(move _9, move _5, move _10) -> [return: bb3, unwind unreachable];
     }
 
     bb3: {
-        StorageDead(_11);
+        StorageDead(_10);
         StorageDead(_9);
         goto -> bb4;
     }
 
     bb4: {
         StorageDead(_2);
-        StorageDead(_8);
         return;
     }
 }
diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-abort.mir b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-abort.mir
index 0dd2125dbe0d2..ba6ce0ee5286f 100644
--- a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-abort.mir
@@ -8,10 +8,9 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
             let _2: std::ptr::NonNull<[T]>;
             let mut _3: *mut [T];
             let mut _4: *const [T];
-            let _12: ();
-            let mut _13: &std::alloc::Layout;
+            let _11: ();
             scope 3 {
-                let _8: std::alloc::Layout;
+                let _8: std::ptr::alignment::AlignmentEnum;
                 scope 4 {
                     scope 12 (inlined Layout::size) {
                     }
@@ -27,19 +26,15 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
                     }
                     scope 18 (inlined <std::alloc::Global as Allocator>::deallocate) {
                         let mut _9: *mut u8;
-                        let mut _14: &std::alloc::Layout;
                         scope 19 (inlined Layout::size) {
                         }
                         scope 20 (inlined NonNull::<u8>::as_ptr) {
                         }
                         scope 21 (inlined std::alloc::dealloc) {
-                            let mut _11: usize;
-                            let mut _15: &std::alloc::Layout;
-                            let mut _16: &std::alloc::Layout;
+                            let mut _10: usize;
                             scope 22 (inlined Layout::size) {
                             }
                             scope 23 (inlined Layout::align) {
-                                let mut _10: std::ptr::alignment::AlignmentEnum;
                                 scope 24 (inlined std::ptr::Alignment::as_usize) {
                                 }
                             }
@@ -68,7 +63,6 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
     }
 
     bb0: {
-        StorageLive(_8);
         StorageLive(_2);
         _2 = copy (((*_1).0: std::ptr::Unique<[T]>).0: std::ptr::NonNull<[T]>);
         StorageLive(_4);
@@ -80,45 +74,31 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
 
     bb1: {
         _6 = AlignOf(T);
+        StorageLive(_7);
         _7 = copy _6 as std::ptr::Alignment (Transmute);
-        _8 = Layout { size: copy _5, align: copy _7 };
+        _8 = move (_7.0: std::ptr::alignment::AlignmentEnum);
+        StorageDead(_7);
         StorageDead(_6);
         StorageDead(_4);
-        StorageLive(_13);
-        // DBG: _13 = &_8;
-        StorageDead(_13);
         switchInt(copy _5) -> [0: bb4, otherwise: bb2];
     }
 
     bb2: {
-        StorageLive(_14);
-        // DBG: _14 = &_8;
-        StorageDead(_14);
         StorageLive(_9);
         _9 = copy _3 as *mut u8 (PtrToPtr);
-        StorageLive(_15);
-        // DBG: _15 = &_8;
-        StorageDead(_15);
-        StorageLive(_11);
-        StorageLive(_16);
-        // DBG: _16 = &_8;
         StorageLive(_10);
-        _10 = copy (_7.0: std::ptr::alignment::AlignmentEnum);
-        _11 = discriminant(_10);
-        StorageDead(_10);
-        StorageDead(_16);
-        _12 = alloc::alloc::__rust_dealloc(move _9, move _5, move _11) -> [return: bb3, unwind unreachable];
+        _10 = discriminant(_8);
+        _11 = alloc::alloc::__rust_dealloc(move _9, move _5, move _10) -> [return: bb3, unwind unreachable];
     }
 
     bb3: {
-        StorageDead(_11);
+        StorageDead(_10);
         StorageDead(_9);
         goto -> bb4;
     }
 
     bb4: {
         StorageDead(_2);
-        StorageDead(_8);
         return;
     }
 }
diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-unwind.mir b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-unwind.mir
index 0dd2125dbe0d2..ba6ce0ee5286f 100644
--- a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-unwind.mir
@@ -8,10 +8,9 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
             let _2: std::ptr::NonNull<[T]>;
             let mut _3: *mut [T];
             let mut _4: *const [T];
-            let _12: ();
-            let mut _13: &std::alloc::Layout;
+            let _11: ();
             scope 3 {
-                let _8: std::alloc::Layout;
+                let _8: std::ptr::alignment::AlignmentEnum;
                 scope 4 {
                     scope 12 (inlined Layout::size) {
                     }
@@ -27,19 +26,15 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
                     }
                     scope 18 (inlined <std::alloc::Global as Allocator>::deallocate) {
                         let mut _9: *mut u8;
-                        let mut _14: &std::alloc::Layout;
                         scope 19 (inlined Layout::size) {
                         }
                         scope 20 (inlined NonNull::<u8>::as_ptr) {
                         }
                         scope 21 (inlined std::alloc::dealloc) {
-                            let mut _11: usize;
-                            let mut _15: &std::alloc::Layout;
-                            let mut _16: &std::alloc::Layout;
+                            let mut _10: usize;
                             scope 22 (inlined Layout::size) {
                             }
                             scope 23 (inlined Layout::align) {
-                                let mut _10: std::ptr::alignment::AlignmentEnum;
                                 scope 24 (inlined std::ptr::Alignment::as_usize) {
                                 }
                             }
@@ -68,7 +63,6 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
     }
 
     bb0: {
-        StorageLive(_8);
         StorageLive(_2);
         _2 = copy (((*_1).0: std::ptr::Unique<[T]>).0: std::ptr::NonNull<[T]>);
         StorageLive(_4);
@@ -80,45 +74,31 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
 
     bb1: {
         _6 = AlignOf(T);
+        StorageLive(_7);
         _7 = copy _6 as std::ptr::Alignment (Transmute);
-        _8 = Layout { size: copy _5, align: copy _7 };
+        _8 = move (_7.0: std::ptr::alignment::AlignmentEnum);
+        StorageDead(_7);
         StorageDead(_6);
         StorageDead(_4);
-        StorageLive(_13);
-        // DBG: _13 = &_8;
-        StorageDead(_13);
         switchInt(copy _5) -> [0: bb4, otherwise: bb2];
     }
 
     bb2: {
-        StorageLive(_14);
-        // DBG: _14 = &_8;
-        StorageDead(_14);
         StorageLive(_9);
         _9 = copy _3 as *mut u8 (PtrToPtr);
-        StorageLive(_15);
-        // DBG: _15 = &_8;
-        StorageDead(_15);
-        StorageLive(_11);
-        StorageLive(_16);
-        // DBG: _16 = &_8;
         StorageLive(_10);
-        _10 = copy (_7.0: std::ptr::alignment::AlignmentEnum);
-        _11 = discriminant(_10);
-        StorageDead(_10);
-        StorageDead(_16);
-        _12 = alloc::alloc::__rust_dealloc(move _9, move _5, move _11) -> [return: bb3, unwind unreachable];
+        _10 = discriminant(_8);
+        _11 = alloc::alloc::__rust_dealloc(move _9, move _5, move _10) -> [return: bb3, unwind unreachable];
     }
 
     bb3: {
-        StorageDead(_11);
+        StorageDead(_10);
         StorageDead(_9);
         goto -> bb4;
     }
 
     bb4: {
         StorageDead(_2);
-        StorageDead(_8);
         return;
     }
 }
diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.rs b/tests/mir-opt/pre-codegen/drop_boxed_slice.rs
index c291366a694e7..9ceba9444b8da 100644
--- a/tests/mir-opt/pre-codegen/drop_boxed_slice.rs
+++ b/tests/mir-opt/pre-codegen/drop_boxed_slice.rs
@@ -11,7 +11,7 @@ pub unsafe fn generic_in_place<T: Copy>(ptr: *mut Box<[T]>) {
     // CHECK: [[SIZE:_.+]] = std::intrinsics::size_of_val::<[T]>
     // CHECK: [[ALIGN:_.+]] = AlignOf(T);
     // CHECK: [[B:_.+]] = copy [[ALIGN]] as std::ptr::Alignment (Transmute);
-    // CHECK: [[C:_.+]] = copy ([[B]].0: std::ptr::alignment::AlignmentEnum);
+    // CHECK: [[C:_.+]] = move ([[B]].0: std::ptr::alignment::AlignmentEnum);
     // CHECK: [[D:_.+]] = discriminant([[C]]);
     // CHECK: = alloc::alloc::__rust_dealloc({{.+}}, move [[SIZE]], move [[D]]) ->
     std::ptr::drop_in_place(ptr)
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 b1af3141ee610..beb7b936ccf74 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
@@ -60,9 +60,7 @@ fn int_range(_1: usize, _2: usize) -> () {
         StorageLive(_9);
         // DBG: _12 = &_3;
         StorageLive(_6);
-        StorageLive(_13);
         // DBG: _13 = &(_3.0: usize);
-        StorageLive(_14);
         // DBG: _14 = &(_3.1: usize);
         StorageLive(_4);
         _4 = copy (_3.0: usize);
@@ -75,16 +73,12 @@ fn int_range(_1: usize, _2: usize) -> () {
     }
 
     bb2: {
-        StorageDead(_14);
-        StorageDead(_13);
         StorageDead(_6);
         StorageDead(_9);
         return;
     }
 
     bb3: {
-        StorageDead(_14);
-        StorageDead(_13);
         _7 = copy (_3.0: usize);
         StorageLive(_8);
         _8 = AddUnchecked(copy _7, const 1_usize);
diff --git a/tests/mir-opt/pre-codegen/loops.vec_move.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/loops.vec_move.PreCodegen.after.mir
index 03cdc221c3086..f453741dc6c78 100644
--- a/tests/mir-opt/pre-codegen/loops.vec_move.PreCodegen.after.mir
+++ b/tests/mir-opt/pre-codegen/loops.vec_move.PreCodegen.after.mir
@@ -171,12 +171,9 @@ fn vec_move(_1: Vec<impl Sized>) -> () {
 
     bb0: {
         StorageLive(_22);
-        StorageLive(_29);
         StorageLive(_6);
         StorageLive(_7);
-        StorageLive(_33);
         StorageLive(_11);
-        StorageLive(_35);
         StorageLive(_20);
         StorageLive(_5);
         StorageLive(_4);
@@ -184,30 +181,18 @@ fn vec_move(_1: Vec<impl Sized>) -> () {
         StorageLive(_2);
         _2 = ManuallyDrop::<Vec<impl Sized>> { value: copy _1 };
         StorageLive(_3);
-        StorageLive(_30);
         // DBG: _30 = &_2;
         // DBG: _29 = &(_2.0: std::vec::Vec<impl Sized>);
-        StorageDead(_30);
-        StorageLive(_39);
         // DBG: _39 = &((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>);
-        StorageLive(_40);
         // DBG: _40 = &(((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>).0: alloc::raw_vec::RawVecInner);
-        StorageDead(_40);
-        StorageDead(_39);
         _3 = &raw const ((((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>).0: alloc::raw_vec::RawVecInner).2: std::alloc::Global);
         StorageDead(_3);
-        StorageLive(_31);
-        StorageLive(_32);
         // DBG: _32 = &_2;
-        StorageDead(_32);
         // DBG: _31 = &((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>);
-        StorageLive(_41);
         // DBG: _41 = &(((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>).0: alloc::raw_vec::RawVecInner);
         _4 = copy (((((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique<u8>).0: std::ptr::NonNull<u8>);
         _5 = copy _4 as *const impl Sized (Transmute);
         _6 = NonNull::<impl Sized> { pointer: copy _5 };
-        StorageDead(_41);
-        StorageDead(_31);
         _7 = copy _4 as *mut impl Sized (Transmute);
         switchInt(const <impl Sized as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
     }
@@ -215,10 +200,8 @@ fn vec_move(_1: Vec<impl Sized>) -> () {
     bb1: {
         StorageLive(_10);
         StorageLive(_8);
-        StorageLive(_36);
         // DBG: _36 = &_2;
         // DBG: _35 = &(_2.0: std::vec::Vec<impl Sized>);
-        StorageDead(_36);
         _8 = copy ((_2.0: std::vec::Vec<impl Sized>).1: usize);
         StorageLive(_9);
         _9 = Le(copy _8, const <impl Sized as std::mem::SizedTypeProperties>::MAX_SLICE_LEN);
@@ -233,10 +216,8 @@ fn vec_move(_1: Vec<impl Sized>) -> () {
 
     bb2: {
         StorageLive(_12);
-        StorageLive(_34);
         // DBG: _34 = &_2;
         // DBG: _33 = &(_2.0: std::vec::Vec<impl Sized>);
-        StorageDead(_34);
         _12 = copy ((_2.0: std::vec::Vec<impl Sized>).1: usize);
         StorageLive(_13);
         _13 = Le(copy _12, const <impl Sized as std::mem::SizedTypeProperties>::MAX_SLICE_LEN);
@@ -264,12 +245,8 @@ fn vec_move(_1: Vec<impl Sized>) -> () {
     }
 
     bb4: {
-        StorageLive(_37);
-        StorageLive(_38);
         // DBG: _38 = &_2;
-        StorageDead(_38);
         // DBG: _37 = &((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>);
-        StorageLive(_42);
         // DBG: _42 = &(((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>).0: alloc::raw_vec::RawVecInner);
         StorageLive(_19);
         _19 = SizeOf(impl Sized);
@@ -291,20 +268,15 @@ fn vec_move(_1: Vec<impl Sized>) -> () {
 
     bb7: {
         StorageDead(_19);
-        StorageDead(_42);
-        StorageDead(_37);
         _22 = std::vec::IntoIter::<impl Sized> { buf: copy _6, phantom: const ZeroSized: PhantomData<impl Sized>, cap: move _20, alloc: const ManuallyDrop::<std::alloc::Global> {{ value: std::alloc::Global }}, ptr: copy _6, end: copy _11 };
         StorageDead(_2);
         StorageDead(_17);
         StorageDead(_4);
         StorageDead(_5);
         StorageDead(_20);
-        StorageDead(_35);
         StorageDead(_11);
-        StorageDead(_33);
         StorageDead(_7);
         StorageDead(_6);
-        StorageDead(_29);
         StorageLive(_23);
         _23 = move _22;
         goto -> bb8;
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 9d4bacef954ef..86c729b3e95e3 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
@@ -70,9 +70,7 @@ fn variant_a::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:7:25: 7:39}, _2
         // DBG: _15 = &((*_3).2: usize);
         // DBG: _16 = &((*_3).3: usize);
         StorageLive(_6);
-        StorageLive(_17);
         // DBG: _17 = &_13;
-        StorageLive(_18);
         // DBG: _18 = &_15;
         _4 = copy ((*_3).0: usize);
         _5 = copy ((*_3).2: usize);
@@ -81,18 +79,12 @@ fn variant_a::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:7:25: 7:39}, _2
     }
 
     bb1: {
-        StorageDead(_18);
-        StorageDead(_17);
         goto -> bb4;
     }
 
     bb2: {
-        StorageDead(_18);
-        StorageDead(_17);
         StorageLive(_9);
-        StorageLive(_19);
         // DBG: _19 = &_16;
-        StorageLive(_20);
         // DBG: _20 = &_14;
         StorageLive(_7);
         _7 = copy ((*_3).3: usize);
@@ -105,34 +97,24 @@ fn variant_a::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:7:25: 7:39}, _2
     }
 
     bb3: {
-        StorageDead(_20);
-        StorageDead(_19);
         goto -> bb4;
     }
 
     bb4: {
         StorageLive(_10);
-        StorageLive(_21);
         // DBG: _21 = &_15;
-        StorageLive(_22);
         // DBG: _22 = &_13;
         _10 = Le(copy _5, copy _4);
         switchInt(move _10) -> [0: bb5, otherwise: bb6];
     }
 
     bb5: {
-        StorageDead(_22);
-        StorageDead(_21);
         _0 = const false;
         goto -> bb7;
     }
 
     bb6: {
-        StorageDead(_22);
-        StorageDead(_21);
-        StorageLive(_23);
         // DBG: _23 = &_14;
-        StorageLive(_24);
         // DBG: _24 = &_16;
         StorageLive(_11);
         _11 = copy ((*_3).1: usize);
@@ -141,8 +123,6 @@ fn variant_a::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:7:25: 7:39}, _2
         _0 = Le(move _11, move _12);
         StorageDead(_12);
         StorageDead(_11);
-        StorageDead(_24);
-        StorageDead(_23);
         goto -> bb7;
     }
 
@@ -152,8 +132,6 @@ fn variant_a::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:7:25: 7:39}, _2
     }
 
     bb8: {
-        StorageDead(_20);
-        StorageDead(_19);
         _0 = const true;
         goto -> bb9;
     }
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 1b2e7b7163cd8..104987b0fdda9 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
@@ -51,9 +51,6 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
                 let mut _16: bool;
                 let mut _20: usize;
                 let _22: &T;
-                let mut _34: &std::ptr::NonNull<T>;
-                let mut _35: &std::ptr::NonNull<T>;
-                let mut _36: &std::ptr::NonNull<T>;
                 scope 29 {
                     let _12: *const T;
                     scope 30 {
@@ -189,11 +186,7 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
 
     bb5: {
         StorageLive(_16);
-        StorageLive(_34);
-        // DBG: _34 = &_11;
-        StorageLive(_35);
         _13 = copy _12 as std::ptr::NonNull<T> (Transmute);
-        // DBG: _35 = &_13;
         StorageLive(_14);
         _14 = copy _11 as *mut T (Transmute);
         StorageLive(_15);
@@ -205,8 +198,6 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb6: {
-        StorageDead(_35);
-        StorageDead(_34);
         StorageDead(_16);
         StorageLive(_18);
         StorageLive(_17);
@@ -219,8 +210,6 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb7: {
-        StorageDead(_35);
-        StorageDead(_34);
         StorageDead(_16);
         StorageDead(_22);
         StorageDead(_13);
@@ -266,13 +255,10 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb13: {
-        StorageLive(_36);
-        // DBG: _36 = &_11;
         StorageLive(_21);
         _21 = copy _11 as *const T (Transmute);
         _22 = &(*_21);
         StorageDead(_21);
-        StorageDead(_36);
         _23 = Option::<&T>::Some(copy _22);
         StorageDead(_22);
         StorageDead(_13);
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 c18dd01a189ad..4d0e3548e7d6b 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
@@ -23,9 +23,6 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
             let mut _15: bool;
             let mut _19: usize;
             let _21: &T;
-            let mut _27: &std::ptr::NonNull<T>;
-            let mut _28: &std::ptr::NonNull<T>;
-            let mut _29: &std::ptr::NonNull<T>;
             scope 17 {
                 let _11: *const T;
                 scope 18 {
@@ -151,11 +148,7 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
 
     bb5: {
         StorageLive(_15);
-        StorageLive(_27);
-        // DBG: _27 = &_10;
-        StorageLive(_28);
         _12 = copy _11 as std::ptr::NonNull<T> (Transmute);
-        // DBG: _28 = &_12;
         StorageLive(_13);
         _13 = copy _10 as *mut T (Transmute);
         StorageLive(_14);
@@ -167,8 +160,6 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb6: {
-        StorageDead(_28);
-        StorageDead(_27);
         StorageDead(_15);
         StorageLive(_17);
         StorageLive(_16);
@@ -181,8 +172,6 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb7: {
-        StorageDead(_28);
-        StorageDead(_27);
         StorageDead(_15);
         StorageDead(_21);
         StorageDead(_12);
@@ -224,13 +213,10 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb13: {
-        StorageLive(_29);
-        // DBG: _29 = &_10;
         StorageLive(_20);
         _20 = copy _10 as *const T (Transmute);
         _21 = &(*_20);
         StorageDead(_20);
-        StorageDead(_29);
         _22 = Option::<&T>::Some(copy _21);
         StorageDead(_21);
         StorageDead(_12);
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 6334c611430ad..2b5d8c27d7109 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
@@ -23,9 +23,6 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
             let mut _15: bool;
             let mut _19: usize;
             let _21: &T;
-            let mut _27: &std::ptr::NonNull<T>;
-            let mut _28: &std::ptr::NonNull<T>;
-            let mut _29: &std::ptr::NonNull<T>;
             scope 17 {
                 let _11: *const T;
                 scope 18 {
@@ -151,11 +148,7 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
 
     bb5: {
         StorageLive(_15);
-        StorageLive(_27);
-        // DBG: _27 = &_10;
-        StorageLive(_28);
         _12 = copy _11 as std::ptr::NonNull<T> (Transmute);
-        // DBG: _28 = &_12;
         StorageLive(_13);
         _13 = copy _10 as *mut T (Transmute);
         StorageLive(_14);
@@ -167,8 +160,6 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb6: {
-        StorageDead(_28);
-        StorageDead(_27);
         StorageDead(_15);
         StorageLive(_17);
         StorageLive(_16);
@@ -181,8 +172,6 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb7: {
-        StorageDead(_28);
-        StorageDead(_27);
         StorageDead(_15);
         StorageDead(_21);
         StorageDead(_12);
@@ -224,13 +213,10 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb13: {
-        StorageLive(_29);
-        // DBG: _29 = &_10;
         StorageLive(_20);
         _20 = copy _10 as *const T (Transmute);
         _21 = &(*_20);
         StorageDead(_20);
-        StorageDead(_29);
         _22 = Option::<&T>::Some(copy _21);
         StorageDead(_21);
         StorageDead(_12);
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 24c6618d31cae..3009be3f9dc67 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
@@ -23,8 +23,6 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
                 let mut _18: bool;
                 let mut _19: *const T;
                 let _32: &T;
-                let mut _38: &std::ptr::NonNull<T>;
-                let mut _39: &std::ptr::NonNull<T>;
                 scope 20 {
                     let _14: std::ptr::NonNull<T>;
                     let _20: usize;
@@ -48,7 +46,6 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
                 }
                 scope 28 (inlined std::slice::Iter::<'_, T>::next_back_unchecked) {
                     let _26: std::ptr::NonNull<T>;
-                    let mut _40: &std::ptr::NonNull<T>;
                     scope 29 (inlined std::slice::Iter::<'_, T>::pre_dec_end) {
                         let mut _21: *mut *const T;
                         let mut _22: *mut std::ptr::NonNull<T>;
@@ -190,10 +187,6 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         _13 = copy ((_12.0: std::slice::Iter<'_, T>).1: *const T);
         _14 = copy _13 as std::ptr::NonNull<T> (Transmute);
         StorageDead(_13);
-        StorageLive(_38);
-        // DBG: _38 = &((_12.0: std::slice::Iter<'_, T>).0: std::ptr::NonNull<T>);
-        StorageLive(_39);
-        // DBG: _39 = &_14;
         StorageLive(_16);
         StorageLive(_15);
         _15 = copy ((_12.0: std::slice::Iter<'_, T>).0: std::ptr::NonNull<T>);
@@ -204,8 +197,6 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         _18 = Eq(copy _16, copy _17);
         StorageDead(_17);
         StorageDead(_16);
-        StorageDead(_39);
-        StorageDead(_38);
         goto -> bb7;
     }
 
@@ -222,7 +213,6 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
 
     bb8: {
         StorageLive(_26);
-        StorageLive(_40);
         StorageLive(_28);
         StorageLive(_22);
         StorageLive(_23);
@@ -275,12 +265,10 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         StorageDead(_23);
         StorageDead(_22);
         StorageDead(_28);
-        // DBG: _40 = &_26;
         StorageLive(_31);
         _31 = copy _26 as *const T (Transmute);
         _32 = &(*_31);
         StorageDead(_31);
-        StorageDead(_40);
         StorageDead(_26);
         _33 = Option::<&T>::Some(copy _32);
         StorageDead(_18);
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 e5c7bcca44b65..e40bff5ea3504 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
@@ -23,8 +23,6 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
                 let mut _18: bool;
                 let mut _19: *const T;
                 let _32: &T;
-                let mut _38: &std::ptr::NonNull<T>;
-                let mut _39: &std::ptr::NonNull<T>;
                 scope 20 {
                     let _14: std::ptr::NonNull<T>;
                     let _20: usize;
@@ -48,7 +46,6 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
                 }
                 scope 28 (inlined std::slice::Iter::<'_, T>::next_back_unchecked) {
                     let _26: std::ptr::NonNull<T>;
-                    let mut _40: &std::ptr::NonNull<T>;
                     scope 29 (inlined std::slice::Iter::<'_, T>::pre_dec_end) {
                         let mut _21: *mut *const T;
                         let mut _22: *mut std::ptr::NonNull<T>;
@@ -190,10 +187,6 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         _13 = copy ((_12.0: std::slice::Iter<'_, T>).1: *const T);
         _14 = copy _13 as std::ptr::NonNull<T> (Transmute);
         StorageDead(_13);
-        StorageLive(_38);
-        // DBG: _38 = &((_12.0: std::slice::Iter<'_, T>).0: std::ptr::NonNull<T>);
-        StorageLive(_39);
-        // DBG: _39 = &_14;
         StorageLive(_16);
         StorageLive(_15);
         _15 = copy ((_12.0: std::slice::Iter<'_, T>).0: std::ptr::NonNull<T>);
@@ -204,8 +197,6 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         _18 = Eq(copy _16, copy _17);
         StorageDead(_17);
         StorageDead(_16);
-        StorageDead(_39);
-        StorageDead(_38);
         goto -> bb7;
     }
 
@@ -222,7 +213,6 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
 
     bb8: {
         StorageLive(_26);
-        StorageLive(_40);
         StorageLive(_28);
         StorageLive(_22);
         StorageLive(_23);
@@ -275,12 +265,10 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         StorageDead(_23);
         StorageDead(_22);
         StorageDead(_28);
-        // DBG: _40 = &_26;
         StorageLive(_31);
         _31 = copy _26 as *const T (Transmute);
         _32 = &(*_31);
         StorageDead(_31);
-        StorageDead(_40);
         StorageDead(_26);
         _33 = Option::<&T>::Some(copy _32);
         StorageDead(_18);
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 18a3d8e7c4ad3..9b510380b10b2 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
@@ -6,8 +6,6 @@ fn slice_iter_generic_is_empty(_1: &std::slice::Iter<'_, T>) -> bool {
     scope 1 (inlined <std::slice::Iter<'_, T> as ExactSizeIterator>::is_empty) {
         let mut _2: *const T;
         let mut _7: *const T;
-        let mut _9: &std::ptr::NonNull<T>;
-        let mut _10: &std::ptr::NonNull<T>;
         scope 2 {
             let _3: std::ptr::NonNull<T>;
             let _8: usize;
@@ -43,10 +41,6 @@ fn slice_iter_generic_is_empty(_1: &std::slice::Iter<'_, T>) -> bool {
         _2 = copy ((*_1).1: *const T);
         _3 = copy _2 as std::ptr::NonNull<T> (Transmute);
         StorageDead(_2);
-        StorageLive(_9);
-        // DBG: _9 = &((*_1).0: std::ptr::NonNull<T>);
-        StorageLive(_10);
-        // DBG: _10 = &_3;
         StorageLive(_5);
         StorageLive(_4);
         _4 = copy ((*_1).0: std::ptr::NonNull<T>);
@@ -57,8 +51,6 @@ fn slice_iter_generic_is_empty(_1: &std::slice::Iter<'_, T>) -> bool {
         _0 = Eq(copy _5, copy _6);
         StorageDead(_6);
         StorageDead(_5);
-        StorageDead(_10);
-        StorageDead(_9);
         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 18a3d8e7c4ad3..9b510380b10b2 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
@@ -6,8 +6,6 @@ fn slice_iter_generic_is_empty(_1: &std::slice::Iter<'_, T>) -> bool {
     scope 1 (inlined <std::slice::Iter<'_, T> as ExactSizeIterator>::is_empty) {
         let mut _2: *const T;
         let mut _7: *const T;
-        let mut _9: &std::ptr::NonNull<T>;
-        let mut _10: &std::ptr::NonNull<T>;
         scope 2 {
             let _3: std::ptr::NonNull<T>;
             let _8: usize;
@@ -43,10 +41,6 @@ fn slice_iter_generic_is_empty(_1: &std::slice::Iter<'_, T>) -> bool {
         _2 = copy ((*_1).1: *const T);
         _3 = copy _2 as std::ptr::NonNull<T> (Transmute);
         StorageDead(_2);
-        StorageLive(_9);
-        // DBG: _9 = &((*_1).0: std::ptr::NonNull<T>);
-        StorageLive(_10);
-        // DBG: _10 = &_3;
         StorageLive(_5);
         StorageLive(_4);
         _4 = copy ((*_1).0: std::ptr::NonNull<T>);
@@ -57,8 +51,6 @@ fn slice_iter_generic_is_empty(_1: &std::slice::Iter<'_, T>) -> bool {
         _0 = Eq(copy _5, copy _6);
         StorageDead(_6);
         StorageDead(_5);
-        StorageDead(_10);
-        StorageDead(_9);
         goto -> bb3;
     }
 
diff --git a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_mut_next_back.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_mut_next_back.PreCodegen.after.panic-abort.mir
index 590d4ac2c8381..62b738c36bf4b 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_mut_next_back.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_mut_next_back.PreCodegen.after.panic-abort.mir
@@ -8,8 +8,6 @@ fn slice_iter_mut_next_back(_1: &mut std::slice::IterMut<'_, T>) -> Option<&mut
         let mut _7: bool;
         let mut _8: *mut T;
         let mut _21: &mut T;
-        let mut _22: &std::ptr::NonNull<T>;
-        let mut _23: &std::ptr::NonNull<T>;
         scope 2 {
             let _3: std::ptr::NonNull<T>;
             let _9: usize;
@@ -33,7 +31,6 @@ fn slice_iter_mut_next_back(_1: &mut std::slice::IterMut<'_, T>) -> Option<&mut
         }
         scope 10 (inlined std::slice::IterMut::<'_, T>::next_back_unchecked) {
             let mut _15: std::ptr::NonNull<T>;
-            let mut _24: &mut std::ptr::NonNull<T>;
             scope 11 (inlined std::slice::IterMut::<'_, T>::pre_dec_end) {
                 let mut _10: *mut *mut T;
                 let mut _11: *mut std::ptr::NonNull<T>;
@@ -88,10 +85,6 @@ fn slice_iter_mut_next_back(_1: &mut std::slice::IterMut<'_, T>) -> Option<&mut
     bb1: {
         _2 = copy ((*_1).1: *mut T);
         _3 = copy _2 as std::ptr::NonNull<T> (Transmute);
-        StorageLive(_22);
-        // DBG: _22 = &((*_1).0: std::ptr::NonNull<T>);
-        StorageLive(_23);
-        // DBG: _23 = &_3;
         StorageLive(_5);
         StorageLive(_4);
         _4 = copy ((*_1).0: std::ptr::NonNull<T>);
@@ -102,8 +95,6 @@ fn slice_iter_mut_next_back(_1: &mut std::slice::IterMut<'_, T>) -> Option<&mut
         _7 = Eq(copy _5, copy _6);
         StorageDead(_6);
         StorageDead(_5);
-        StorageDead(_23);
-        StorageDead(_22);
         goto -> bb3;
     }
 
@@ -120,7 +111,6 @@ fn slice_iter_mut_next_back(_1: &mut std::slice::IterMut<'_, T>) -> Option<&mut
 
     bb4: {
         StorageLive(_15);
-        StorageLive(_24);
         StorageLive(_17);
         StorageLive(_11);
         StorageLive(_12);
@@ -173,12 +163,10 @@ fn slice_iter_mut_next_back(_1: &mut std::slice::IterMut<'_, T>) -> Option<&mut
         StorageDead(_12);
         StorageDead(_11);
         StorageDead(_17);
-        // DBG: _24 = &_15;
         StorageLive(_20);
         _20 = copy _15 as *mut T (Transmute);
         _21 = &mut (*_20);
         StorageDead(_20);
-        StorageDead(_24);
         StorageDead(_15);
         _0 = Option::<&mut T>::Some(copy _21);
         goto -> bb11;
diff --git a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_mut_next_back.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_mut_next_back.PreCodegen.after.panic-unwind.mir
index 590d4ac2c8381..62b738c36bf4b 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_mut_next_back.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_mut_next_back.PreCodegen.after.panic-unwind.mir
@@ -8,8 +8,6 @@ fn slice_iter_mut_next_back(_1: &mut std::slice::IterMut<'_, T>) -> Option<&mut
         let mut _7: bool;
         let mut _8: *mut T;
         let mut _21: &mut T;
-        let mut _22: &std::ptr::NonNull<T>;
-        let mut _23: &std::ptr::NonNull<T>;
         scope 2 {
             let _3: std::ptr::NonNull<T>;
             let _9: usize;
@@ -33,7 +31,6 @@ fn slice_iter_mut_next_back(_1: &mut std::slice::IterMut<'_, T>) -> Option<&mut
         }
         scope 10 (inlined std::slice::IterMut::<'_, T>::next_back_unchecked) {
             let mut _15: std::ptr::NonNull<T>;
-            let mut _24: &mut std::ptr::NonNull<T>;
             scope 11 (inlined std::slice::IterMut::<'_, T>::pre_dec_end) {
                 let mut _10: *mut *mut T;
                 let mut _11: *mut std::ptr::NonNull<T>;
@@ -88,10 +85,6 @@ fn slice_iter_mut_next_back(_1: &mut std::slice::IterMut<'_, T>) -> Option<&mut
     bb1: {
         _2 = copy ((*_1).1: *mut T);
         _3 = copy _2 as std::ptr::NonNull<T> (Transmute);
-        StorageLive(_22);
-        // DBG: _22 = &((*_1).0: std::ptr::NonNull<T>);
-        StorageLive(_23);
-        // DBG: _23 = &_3;
         StorageLive(_5);
         StorageLive(_4);
         _4 = copy ((*_1).0: std::ptr::NonNull<T>);
@@ -102,8 +95,6 @@ fn slice_iter_mut_next_back(_1: &mut std::slice::IterMut<'_, T>) -> Option<&mut
         _7 = Eq(copy _5, copy _6);
         StorageDead(_6);
         StorageDead(_5);
-        StorageDead(_23);
-        StorageDead(_22);
         goto -> bb3;
     }
 
@@ -120,7 +111,6 @@ fn slice_iter_mut_next_back(_1: &mut std::slice::IterMut<'_, T>) -> Option<&mut
 
     bb4: {
         StorageLive(_15);
-        StorageLive(_24);
         StorageLive(_17);
         StorageLive(_11);
         StorageLive(_12);
@@ -173,12 +163,10 @@ fn slice_iter_mut_next_back(_1: &mut std::slice::IterMut<'_, T>) -> Option<&mut
         StorageDead(_12);
         StorageDead(_11);
         StorageDead(_17);
-        // DBG: _24 = &_15;
         StorageLive(_20);
         _20 = copy _15 as *mut T (Transmute);
         _21 = &mut (*_20);
         StorageDead(_20);
-        StorageDead(_24);
         StorageDead(_15);
         _0 = Option::<&mut T>::Some(copy _21);
         goto -> bb11;
diff --git a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-abort.mir
index e9ed932cbafb6..cc0fce26149e3 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-abort.mir
@@ -10,9 +10,6 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
         let mut _10: std::ptr::NonNull<T>;
         let mut _12: usize;
         let _14: &T;
-        let mut _15: &std::ptr::NonNull<T>;
-        let mut _16: &std::ptr::NonNull<T>;
-        let mut _17: &std::ptr::NonNull<T>;
         scope 2 {
             let _3: *const T;
             scope 3 {
@@ -70,11 +67,7 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
 
     bb1: {
         StorageLive(_7);
-        StorageLive(_15);
-        // DBG: _15 = &_2;
-        StorageLive(_16);
         _4 = copy _3 as std::ptr::NonNull<T> (Transmute);
-        // DBG: _16 = &_4;
         StorageLive(_5);
         _5 = copy _2 as *mut T (Transmute);
         StorageLive(_6);
@@ -86,8 +79,6 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
     }
 
     bb2: {
-        StorageDead(_16);
-        StorageDead(_15);
         StorageDead(_7);
         StorageLive(_10);
         StorageLive(_9);
@@ -103,8 +94,6 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
     }
 
     bb3: {
-        StorageDead(_16);
-        StorageDead(_15);
         _0 = const {transmute(0x0000000000000000): Option<&T>};
         StorageDead(_7);
         goto -> bb8;
@@ -127,13 +116,10 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
     }
 
     bb7: {
-        StorageLive(_17);
-        // DBG: _17 = &_2;
         StorageLive(_13);
         _13 = copy _2 as *const T (Transmute);
         _14 = &(*_13);
         StorageDead(_13);
-        StorageDead(_17);
         _0 = Option::<&T>::Some(copy _14);
         goto -> bb8;
     }
diff --git a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-unwind.mir
index e9ed932cbafb6..cc0fce26149e3 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-unwind.mir
@@ -10,9 +10,6 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
         let mut _10: std::ptr::NonNull<T>;
         let mut _12: usize;
         let _14: &T;
-        let mut _15: &std::ptr::NonNull<T>;
-        let mut _16: &std::ptr::NonNull<T>;
-        let mut _17: &std::ptr::NonNull<T>;
         scope 2 {
             let _3: *const T;
             scope 3 {
@@ -70,11 +67,7 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
 
     bb1: {
         StorageLive(_7);
-        StorageLive(_15);
-        // DBG: _15 = &_2;
-        StorageLive(_16);
         _4 = copy _3 as std::ptr::NonNull<T> (Transmute);
-        // DBG: _16 = &_4;
         StorageLive(_5);
         _5 = copy _2 as *mut T (Transmute);
         StorageLive(_6);
@@ -86,8 +79,6 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
     }
 
     bb2: {
-        StorageDead(_16);
-        StorageDead(_15);
         StorageDead(_7);
         StorageLive(_10);
         StorageLive(_9);
@@ -103,8 +94,6 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
     }
 
     bb3: {
-        StorageDead(_16);
-        StorageDead(_15);
         _0 = const {transmute(0x0000000000000000): Option<&T>};
         StorageDead(_7);
         goto -> bb8;
@@ -127,13 +116,10 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
     }
 
     bb7: {
-        StorageLive(_17);
-        // DBG: _17 = &_2;
         StorageLive(_13);
         _13 = copy _2 as *const T (Transmute);
         _14 = &(*_13);
         StorageDead(_13);
-        StorageDead(_17);
         _0 = Option::<&T>::Some(copy _14);
         goto -> bb8;
     }
diff --git a/tests/ui/extern/extern-types-field-offset.rs b/tests/ui/extern/extern-types-field-offset.rs
index 7a5f36da20917..470ae07a0b552 100644
--- a/tests/ui/extern/extern-types-field-offset.rs
+++ b/tests/ui/extern/extern-types-field-offset.rs
@@ -23,12 +23,17 @@ fn main() {
     let x: &Newtype = unsafe { &*(&buf as *const _ as *const Newtype) };
     // Projecting to the newtype works, because it is always at offset 0.
     let field = &x.0;
+    // Avoid being eliminated by DSE.
+    std::hint::black_box(field);
 
     let x: &S = unsafe { &*(&buf as *const _ as *const S) };
     // Accessing sized fields is perfectly fine, even at non-zero offsets.
     let field = &x.i;
+    std::hint::black_box(field);
     let field = &x.j;
+    std::hint::black_box(field);
     // This needs to compute the field offset, but we don't know the type's alignment,
     // so this panics.
     let field = &x.a;
+    std::hint::black_box(field);
 }

From 1bd89bd42e0bb6f29b8af5d6bdf3f756196bb8ee Mon Sep 17 00:00:00 2001
From: dianqk <dianqk@dianqk.net>
Date: Wed, 18 Jun 2025 22:04:48 +0800
Subject: [PATCH 1653/1889] codegen: Generate `dbg_value` for the ref statement

---
 compiler/rustc_codegen_gcc/src/debuginfo.rs   |  13 +-
 .../src/debuginfo/dwarf_const.rs              |   3 +
 .../rustc_codegen_llvm/src/debuginfo/mod.rs   |  53 +++++-
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs   |   9 +
 compiler/rustc_codegen_ssa/src/mir/block.rs   |   1 +
 .../rustc_codegen_ssa/src/mir/debuginfo.rs    |  54 +++++-
 compiler/rustc_codegen_ssa/src/mir/operand.rs |  17 +-
 .../rustc_codegen_ssa/src/mir/statement.rs    |  70 +++++++-
 .../rustc_codegen_ssa/src/traits/debuginfo.rs |  14 +-
 .../rustc_llvm/llvm-wrapper/RustWrapper.cpp   |   1 +
 tests/codegen-llvm/debuginfo-dse.rs           | 160 ++++++++++++++++++
 tests/debuginfo/opt/dead_refs.rs              |  50 ++++++
 12 files changed, 431 insertions(+), 14 deletions(-)
 create mode 100644 tests/codegen-llvm/debuginfo-dse.rs
 create mode 100644 tests/debuginfo/opt/dead_refs.rs

diff --git a/compiler/rustc_codegen_gcc/src/debuginfo.rs b/compiler/rustc_codegen_gcc/src/debuginfo.rs
index 4c8585192a1b1..0f015cc23f52f 100644
--- a/compiler/rustc_codegen_gcc/src/debuginfo.rs
+++ b/compiler/rustc_codegen_gcc/src/debuginfo.rs
@@ -29,13 +29,24 @@ impl<'a, 'gcc, 'tcx> DebugInfoBuilderMethods for Builder<'a, 'gcc, 'tcx> {
         _variable_alloca: Self::Value,
         _direct_offset: Size,
         _indirect_offsets: &[Size],
-        _fragment: Option<Range<Size>>,
+        _fragment: &Option<Range<Size>>,
     ) {
         // FIXME(tempdragon): Not sure if this is correct, probably wrong but still keep it here.
         #[cfg(feature = "master")]
         _variable_alloca.set_location(_dbg_loc);
     }
 
+    fn dbg_var_value(
+        &mut self,
+        _dbg_var: Self::DIVariable,
+        _dbg_loc: Self::DILocation,
+        _value: Self::Value,
+        _direct_offset: Size,
+        _indirect_offsets: &[Size],
+        _fragment: &Option<Range<Size>>,
+    ) {
+    }
+
     fn insert_reference_to_gdb_debug_scripts_section_global(&mut self) {
         // TODO(antoyo): insert reference to gdb debug scripts section global.
     }
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/dwarf_const.rs b/compiler/rustc_codegen_llvm/src/debuginfo/dwarf_const.rs
index 408429152223d..52d04625749b9 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/dwarf_const.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/dwarf_const.rs
@@ -35,3 +35,6 @@ declare_constant!(DW_OP_plus_uconst: u64);
 /// Double-checked by a static assertion in `RustWrapper.cpp`.
 #[allow(non_upper_case_globals)]
 pub(crate) const DW_OP_LLVM_fragment: u64 = 0x1000;
+// It describes the actual value of a source variable which might not exist in registers or in memory.
+#[allow(non_upper_case_globals)]
+pub(crate) const DW_OP_stack_value: u64 = 0x9f;
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
index af64e4ebed0f7..c6ad1c2e18ec7 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
@@ -156,7 +156,7 @@ impl<'ll> DebugInfoBuilderMethods for Builder<'_, 'll, '_> {
         variable_alloca: Self::Value,
         direct_offset: Size,
         indirect_offsets: &[Size],
-        fragment: Option<Range<Size>>,
+        fragment: &Option<Range<Size>>,
     ) {
         use dwarf_const::{DW_OP_LLVM_fragment, DW_OP_deref, DW_OP_plus_uconst};
 
@@ -187,7 +187,6 @@ impl<'ll> DebugInfoBuilderMethods for Builder<'_, 'll, '_> {
             llvm::LLVMDIBuilderCreateExpression(di_builder, addr_ops.as_ptr(), addr_ops.len())
         };
         unsafe {
-            // FIXME(eddyb) replace `llvm.dbg.declare` with `llvm.dbg.addr`.
             llvm::LLVMDIBuilderInsertDeclareRecordAtEnd(
                 di_builder,
                 variable_alloca,
@@ -199,6 +198,56 @@ impl<'ll> DebugInfoBuilderMethods for Builder<'_, 'll, '_> {
         };
     }
 
+    fn dbg_var_value(
+        &mut self,
+        dbg_var: &'ll DIVariable,
+        dbg_loc: &'ll DILocation,
+        value: Self::Value,
+        direct_offset: Size,
+        indirect_offsets: &[Size],
+        fragment: &Option<Range<Size>>,
+    ) {
+        use dwarf_const::{DW_OP_LLVM_fragment, DW_OP_deref, DW_OP_plus_uconst, DW_OP_stack_value};
+
+        // Convert the direct and indirect offsets and fragment byte range to address ops.
+        let mut addr_ops = SmallVec::<[u64; 8]>::new();
+
+        if direct_offset.bytes() > 0 {
+            addr_ops.push(DW_OP_plus_uconst);
+            addr_ops.push(direct_offset.bytes() as u64);
+            addr_ops.push(DW_OP_stack_value);
+        }
+        for &offset in indirect_offsets {
+            addr_ops.push(DW_OP_deref);
+            if offset.bytes() > 0 {
+                addr_ops.push(DW_OP_plus_uconst);
+                addr_ops.push(offset.bytes() as u64);
+            }
+        }
+        if let Some(fragment) = fragment {
+            // `DW_OP_LLVM_fragment` takes as arguments the fragment's
+            // offset and size, both of them in bits.
+            addr_ops.push(DW_OP_LLVM_fragment);
+            addr_ops.push(fragment.start.bits() as u64);
+            addr_ops.push((fragment.end - fragment.start).bits() as u64);
+        }
+
+        let di_builder = DIB(self.cx());
+        let addr_expr = unsafe {
+            llvm::LLVMDIBuilderCreateExpression(di_builder, addr_ops.as_ptr(), addr_ops.len())
+        };
+        unsafe {
+            llvm::LLVMDIBuilderInsertDbgValueRecordAtEnd(
+                di_builder,
+                value,
+                dbg_var,
+                addr_expr,
+                dbg_loc,
+                self.llbb(),
+            );
+        }
+    }
+
     fn set_dbg_loc(&mut self, dbg_loc: &'ll DILocation) {
         unsafe {
             llvm::LLVMSetCurrentDebugLocation2(self.llbuilder, dbg_loc);
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index e9f92267a7d4f..7fbba0294073f 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -1991,6 +1991,15 @@ unsafe extern "C" {
         Block: &'ll BasicBlock,
     ) -> &'ll DbgRecord;
 
+    pub(crate) fn LLVMDIBuilderInsertDbgValueRecordAtEnd<'ll>(
+        Builder: &DIBuilder<'ll>,
+        Val: &'ll Value,
+        VarInfo: &'ll Metadata,
+        Expr: &'ll Metadata,
+        DebugLoc: &'ll Metadata,
+        Block: &'ll BasicBlock,
+    ) -> &'ll DbgRecord;
+
     pub(crate) fn LLVMDIBuilderCreateAutoVariable<'ll>(
         Builder: &DIBuilder<'ll>,
         Scope: &'ll Metadata,
diff --git a/compiler/rustc_codegen_ssa/src/mir/block.rs b/compiler/rustc_codegen_ssa/src/mir/block.rs
index b2dc4fe32b0fe..e371f1a76231c 100644
--- a/compiler/rustc_codegen_ssa/src/mir/block.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/block.rs
@@ -1320,6 +1320,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             for statement in &data.statements {
                 self.codegen_statement(bx, statement);
             }
+            self.codegen_stmt_debuginfos(bx, &data.after_last_stmt_debuginfos);
 
             let merging_succ = self.codegen_terminator(bx, bb, data.terminator());
             if let MergingSucc::False = merging_succ {
diff --git a/compiler/rustc_codegen_ssa/src/mir/debuginfo.rs b/compiler/rustc_codegen_ssa/src/mir/debuginfo.rs
index b8f635ab78161..38bb6f24b1c3b 100644
--- a/compiler/rustc_codegen_ssa/src/mir/debuginfo.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/debuginfo.rs
@@ -253,6 +253,54 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         spill_slot
     }
 
+    // Indicates that local is set to a new value. The `layout` and `projection` are used to
+    // calculate the offset.
+    pub(crate) fn debug_new_val_to_local(
+        &self,
+        bx: &mut Bx,
+        local: mir::Local,
+        base: PlaceValue<Bx::Value>,
+        layout: TyAndLayout<'tcx>,
+        projection: &[mir::PlaceElem<'tcx>],
+    ) {
+        let full_debug_info = bx.sess().opts.debuginfo == DebugInfo::Full;
+        if !full_debug_info {
+            return;
+        }
+
+        let vars = match &self.per_local_var_debug_info {
+            Some(per_local) => &per_local[local],
+            None => return,
+        };
+
+        let DebugInfoOffset { direct_offset, indirect_offsets, result: _ } =
+            calculate_debuginfo_offset(bx, projection, layout);
+        for var in vars.iter() {
+            let Some(dbg_var) = var.dbg_var else {
+                continue;
+            };
+            let Some(dbg_loc) = self.dbg_loc(var.source_info) else {
+                continue;
+            };
+            bx.dbg_var_value(
+                dbg_var,
+                dbg_loc,
+                base.llval,
+                direct_offset,
+                &indirect_offsets,
+                &var.fragment,
+            );
+        }
+    }
+
+    pub(crate) fn debug_poison_to_local(&self, bx: &mut Bx, local: mir::Local) {
+        let ty = self.monomorphize(self.mir.local_decls[local].ty);
+        let layout = bx.cx().layout_of(ty);
+        let to_backend_ty = bx.cx().immediate_backend_type(layout);
+        let place_ref = PlaceRef::new_sized(bx.cx().const_poison(to_backend_ty), layout);
+        self.debug_new_val_to_local(bx, local, place_ref.val, layout, &[]);
+    }
+
     /// Apply debuginfo and/or name, after creating the `alloca` for a local,
     /// or initializing the local with an operand (whichever applies).
     pub(crate) fn debug_introduce_local(&self, bx: &mut Bx, local: mir::Local) {
@@ -424,7 +472,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 alloca.val.llval,
                 Size::ZERO,
                 &[Size::ZERO],
-                var.fragment,
+                &var.fragment,
             );
         } else {
             bx.dbg_var_addr(
@@ -433,7 +481,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 base.val.llval,
                 direct_offset,
                 &indirect_offsets,
-                var.fragment,
+                &var.fragment,
             );
         }
     }
@@ -455,7 +503,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 let base = FunctionCx::spill_operand_to_stack(operand, Some(name), bx);
                 bx.clear_dbg_loc();
 
-                bx.dbg_var_addr(dbg_var, dbg_loc, base.val.llval, Size::ZERO, &[], fragment);
+                bx.dbg_var_addr(dbg_var, dbg_loc, base.val.llval, Size::ZERO, &[], &fragment);
             }
         }
     }
diff --git a/compiler/rustc_codegen_ssa/src/mir/operand.rs b/compiler/rustc_codegen_ssa/src/mir/operand.rs
index 5f7f87fc69206..88a8e2a844cbc 100644
--- a/compiler/rustc_codegen_ssa/src/mir/operand.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/operand.rs
@@ -71,16 +71,23 @@ pub enum OperandValue<V> {
 }
 
 impl<V: CodegenObject> OperandValue<V> {
+    /// Return the data pointer and optional metadata as backend values
+    /// if this value can be treat as a pointer.
+    pub(crate) fn try_pointer_parts(self) -> Option<(V, Option<V>)> {
+        match self {
+            OperandValue::Immediate(llptr) => Some((llptr, None)),
+            OperandValue::Pair(llptr, llextra) => Some((llptr, Some(llextra))),
+            OperandValue::Ref(_) | OperandValue::ZeroSized => None,
+        }
+    }
+
     /// Treat this value as a pointer and return the data pointer and
     /// optional metadata as backend values.
     ///
     /// If you're making a place, use [`Self::deref`] instead.
     pub(crate) fn pointer_parts(self) -> (V, Option<V>) {
-        match self {
-            OperandValue::Immediate(llptr) => (llptr, None),
-            OperandValue::Pair(llptr, llextra) => (llptr, Some(llextra)),
-            _ => bug!("OperandValue cannot be a pointer: {self:?}"),
-        }
+        self.try_pointer_parts()
+            .unwrap_or_else(|| bug!("OperandValue cannot be a pointer: {self:?}"))
     }
 
     /// Treat this value as a pointer and return the place to which it points.
diff --git a/compiler/rustc_codegen_ssa/src/mir/statement.rs b/compiler/rustc_codegen_ssa/src/mir/statement.rs
index 0a50d7f18dbef..99bb31a68b688 100644
--- a/compiler/rustc_codegen_ssa/src/mir/statement.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/statement.rs
@@ -1,13 +1,17 @@
-use rustc_middle::mir::{self, NonDivergingIntrinsic};
-use rustc_middle::span_bug;
+use rustc_middle::mir::{self, NonDivergingIntrinsic, RETURN_PLACE, StmtDebugInfo};
+use rustc_middle::{bug, span_bug};
+use rustc_target::callconv::PassMode;
 use tracing::instrument;
 
 use super::{FunctionCx, LocalRef};
+use crate::common::TypeKind;
+use crate::mir::place::PlaceRef;
 use crate::traits::*;
 
 impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
     #[instrument(level = "debug", skip(self, bx))]
     pub(crate) fn codegen_statement(&mut self, bx: &mut Bx, statement: &mir::Statement<'tcx>) {
+        self.codegen_stmt_debuginfos(bx, &statement.debuginfos);
         self.set_debug_loc(bx, statement.source_info);
         match statement.kind {
             mir::StatementKind::Assign(box (ref place, ref rvalue)) => {
@@ -101,4 +105,66 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             | mir::StatementKind::Nop => {}
         }
     }
+
+    pub(crate) fn codegen_stmt_debuginfo(&mut self, bx: &mut Bx, debuginfo: &StmtDebugInfo<'tcx>) {
+        match debuginfo {
+            StmtDebugInfo::AssignRef(dest, place) => {
+                let local_ref = match self.locals[place.local] {
+                    LocalRef::Place(place_ref) | LocalRef::UnsizedPlace(place_ref) => {
+                        Some(place_ref)
+                    }
+                    LocalRef::Operand(operand_ref) => operand_ref
+                        .val
+                        .try_pointer_parts()
+                        .map(|(pointer, _)| PlaceRef::new_sized(pointer, operand_ref.layout)),
+                    LocalRef::PendingOperand => None,
+                }
+                .filter(|place_ref| {
+                    // For the reference of an argument (e.x. `&_1`), it's only valid if the pass mode is indirect, and its reference is
+                    // llval.
+                    let local_ref_pass_mode = place.as_local().and_then(|local| {
+                        if local == RETURN_PLACE {
+                            None
+                        } else {
+                            self.fn_abi.args.get(local.as_usize() - 1).map(|arg| &arg.mode)
+                        }
+                    });
+                    matches!(local_ref_pass_mode, Some(&PassMode::Indirect {..}) | None) &&
+                    // Drop unsupported projections.
+                    place.projection.iter().all(|p| p.can_use_in_debuginfo()) &&
+                    // Only pointers can be calculated addresses.
+                    bx.type_kind(bx.val_ty(place_ref.val.llval)) == TypeKind::Pointer
+                });
+                if let Some(local_ref) = local_ref {
+                    let (base_layout, projection) = if place.is_indirect_first_projection() {
+                        // For `_n = &((*_1).0: i32);`, we are calculating the address of `_1.0`, so
+                        // we should drop the deref projection.
+                        let projected_ty = local_ref
+                            .layout
+                            .ty
+                            .builtin_deref(true)
+                            .unwrap_or_else(|| bug!("deref of non-pointer {:?}", local_ref));
+                        let layout = bx.cx().layout_of(projected_ty);
+                        (layout, &place.projection[1..])
+                    } else {
+                        (local_ref.layout, place.projection.as_slice())
+                    };
+                    self.debug_new_val_to_local(bx, *dest, local_ref.val, base_layout, projection);
+                } else {
+                    // If the address cannot be computed, use poison to indicate that the value has been optimized out.
+                    self.debug_poison_to_local(bx, *dest);
+                }
+            }
+        }
+    }
+
+    pub(crate) fn codegen_stmt_debuginfos(
+        &mut self,
+        bx: &mut Bx,
+        debuginfos: &[StmtDebugInfo<'tcx>],
+    ) {
+        for debuginfo in debuginfos {
+            self.codegen_stmt_debuginfo(bx, debuginfo);
+        }
+    }
 }
diff --git a/compiler/rustc_codegen_ssa/src/traits/debuginfo.rs b/compiler/rustc_codegen_ssa/src/traits/debuginfo.rs
index b9d4950e0ad36..a4da6c915deec 100644
--- a/compiler/rustc_codegen_ssa/src/traits/debuginfo.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/debuginfo.rs
@@ -77,7 +77,19 @@ pub trait DebugInfoBuilderMethods: BackendTypes {
         indirect_offsets: &[Size],
         // Byte range in the `dbg_var` covered by this fragment,
         // if this is a fragment of a composite `DIVariable`.
-        fragment: Option<Range<Size>>,
+        fragment: &Option<Range<Size>>,
+    );
+    fn dbg_var_value(
+        &mut self,
+        dbg_var: Self::DIVariable,
+        dbg_loc: Self::DILocation,
+        value: Self::Value,
+        direct_offset: Size,
+        // NB: each offset implies a deref (i.e. they're steps in a pointer chain).
+        indirect_offsets: &[Size],
+        // Byte range in the `dbg_var` covered by this fragment,
+        // if this is a fragment of a composite `DIVariable`.
+        fragment: &Option<Range<Size>>,
     );
     fn set_dbg_loc(&mut self, dbg_loc: Self::DILocation);
     fn clear_dbg_loc(&mut self);
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index 2b83ea24ac61c..e38474f09ff7a 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -58,6 +58,7 @@ using namespace llvm::object;
 // This opcode is an LLVM detail that could hypothetically change (?), so
 // verify that the hard-coded value in `dwarf_const.rs` still agrees with LLVM.
 static_assert(dwarf::DW_OP_LLVM_fragment == 0x1000);
+static_assert(dwarf::DW_OP_stack_value == 0x9f);
 
 // LLVMAtomicOrdering is already an enum - don't create another
 // one.
diff --git a/tests/codegen-llvm/debuginfo-dse.rs b/tests/codegen-llvm/debuginfo-dse.rs
new file mode 100644
index 0000000000000..1fcb5fcfc543a
--- /dev/null
+++ b/tests/codegen-llvm/debuginfo-dse.rs
@@ -0,0 +1,160 @@
+//@ compile-flags: -Copt-level=3 -g -Zverify-llvm-ir
+//@ revisions: CODEGEN OPTIMIZED
+//@[CODEGEN] compile-flags: -Cno-prepopulate-passes
+// ignore-tidy-linelength
+
+#![crate_type = "lib"]
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct Foo(i32, i64, i32);
+
+#[no_mangle]
+fn r#ref(ref_foo: &Foo) -> i32 {
+    // CHECK-LABEL: define{{.*}} i32 @ref
+    // CHECK-SAME: (ptr {{.*}} [[ARG_ref_foo:%.*]])
+    // OPTIMIZED: #dbg_value(ptr [[ARG_ref_foo]], [[VAR_ref_foo:![0-9]+]], !DIExpression()
+    // CHECK: #dbg_value(ptr poison, [[VAR_invalid_ref_of_ref_foo:![0-9]+]], !DIExpression()
+    // CHECK: #dbg_value(ptr [[ARG_ref_foo]], [[VAR_ref_v0:![0-9]+]], !DIExpression()
+    // CHECK: #dbg_value(ptr [[ARG_ref_foo]], [[VAR_ref_v1:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 8, DW_OP_stack_value)
+    // CHECK: #dbg_value(ptr [[ARG_ref_foo]], [[VAR_ref_v2:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 16, DW_OP_stack_value)
+    let invalid_ref_of_ref_foo = &ref_foo;
+    let ref_v0 = &ref_foo.0;
+    let ref_v1 = &ref_foo.1;
+    let ref_v2 = &ref_foo.2;
+    ref_foo.0
+}
+
+#[no_mangle]
+pub fn dead_first(dead_first_foo: &Foo) -> &i32 {
+    // CHECK-LABEL: def {{.*}} ptr @dead_first
+    // CHECK-SAME: (ptr {{.*}} [[ARG_dead_first_foo:%.*]])
+    // CODEGEN: #dbg_declare(ptr %dead_first_foo.dbg.spill, [[ARG_dead_first_foo:![0-9]+]], !DIExpression()
+    // OPTIMIZED: #dbg_value(ptr %dead_first_foo, [[ARG_dead_first_foo:![0-9]+]], !DIExpression()
+    // CHECK: #dbg_value(ptr %dead_first_foo, [[VAR_dead_first_v0:![0-9]+]], !DIExpression()
+    // CHECK: %dead_first_v0 = getelementptr{{.*}} i8, ptr %dead_first_foo, i64 16
+    // CODEGEN: #dbg_declare(ptr %dead_first_v0.dbg.spill, [[VAR_dead_first_v0]], !DIExpression()
+    // OPTIMIZED: #dbg_value(ptr %dead_first_v0, [[VAR_dead_first_v0]], !DIExpression()
+    let mut dead_first_v0 = &dead_first_foo.0;
+    dead_first_v0 = &dead_first_foo.2;
+    dead_first_v0
+}
+
+#[no_mangle]
+fn ptr(ptr_foo: Foo) -> i32 {
+    // CHECK-LABEL: define{{.*}} i32 @ptr
+    // CHECK-SAME: (ptr {{.*}} [[ARG_ptr_foo:%.*]])
+    // CHECK: #dbg_value(ptr [[ARG_ptr_foo]], [[ref_ptr_foo:![0-9]+]], !DIExpression()
+    // CHECK: #dbg_value(ptr [[ARG_ptr_foo]], [[VAR_ptr_v0:![0-9]+]], !DIExpression()
+    // CHECK: #dbg_value(ptr [[ARG_ptr_foo]], [[VAR_ptr_v1:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 8, DW_OP_stack_value)
+    // CHECK: #dbg_value(ptr [[ARG_ptr_foo]], [[VAR_ptr_v2:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 16, DW_OP_stack_value)
+    let ref_ptr_foo = &ptr_foo;
+    let ptr_v0 = &ptr_foo.0;
+    let ptr_v1 = &ptr_foo.1;
+    let ptr_v2 = &ptr_foo.2;
+    ptr_foo.2
+}
+
+#[no_mangle]
+fn no_ptr(val: i32) -> i32 {
+    // CHECK-LABEL: define{{.*}} i32 @no_ptr
+    // CODEGEN: #dbg_value(ptr poison, [[VAR_val_ref:![0-9]+]], !DIExpression()
+    let val_ref = &val;
+    val
+}
+
+#[no_mangle]
+pub fn fragment(fragment_v1: Foo, mut fragment_v2: Foo) -> Foo {
+    // CHECK-LABEL: define void @fragment
+    // CHECK-SAME: (ptr {{.*}}, ptr {{.*}} [[ARG_fragment_v1:%.*]], ptr {{.*}} [[ARG_fragment_v2:%.*]])
+    // CHECK: #dbg_declare(ptr [[ARG_fragment_v1]]
+    // CHECK-NEXT: #dbg_declare(ptr [[ARG_fragment_v2]]
+    // CHECK-NEXT: #dbg_value(ptr [[ARG_fragment_v2]], [[VAR_fragment_f:![0-9]+]], !DIExpression(DW_OP_LLVM_fragment, 0, 64)
+    // CHECK-NEXT: #dbg_value(ptr [[ARG_fragment_v1]], [[VAR_fragment_f:![0-9]+]], !DIExpression(DW_OP_LLVM_fragment, 64, 64)
+    let fragment_f = || {
+        fragment_v2 = fragment_v1;
+    };
+    fragment_v2 = fragment_v1;
+    fragment_v2
+}
+
+#[no_mangle]
+pub fn tuple(foo: (i32, &Foo)) -> i32 {
+    // CHECK-LABEL: define{{.*}} i32 @tuple
+    // CHECK-SAME: (i32 {{.*}}, ptr {{.*}} [[ARG_tuple_foo_1:%.*]])
+    // CHECK: #dbg_value(ptr [[ARG_tuple_foo_1]], [[VAR_tuple_dead:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 16, DW_OP_stack_value)
+    let tuple_dead = &foo.1.2;
+    foo.1.0
+}
+
+pub struct ZST;
+
+#[no_mangle]
+pub fn zst(zst: ZST, v: &i32) -> i32 {
+    // CHECK-LABEL: define{{.*}} i32 @zst
+    // CHECK: #dbg_value(ptr poison, [[VAR_zst_ref:![0-9]+]], !DIExpression()
+    let zst_ref = &zst;
+    *v
+}
+
+#[no_mangle]
+fn index(slice: &[i32; 4], idx: usize) -> i32 {
+    // CHECK-LABEL: define{{.*}} i32 @index
+    // CHECK: bb1:
+    // CHECK-NEXT: #dbg_value(ptr poison, [[VAR_index_from_var:![0-9]+]], !DIExpression()
+    // CODEGEN: bb3:
+    // CHECK-NEXT: #dbg_value(ptr %slice, [[VAR_const_index_from_start:![0-9]+]], !DIExpression()
+    // CHECK-NEXT: #dbg_value(ptr poison, [[VAR_const_index_from_end:![0-9]+]], !DIExpression()
+    let index_from_var = &slice[idx];
+    let [ref const_index_from_start, .., ref const_index_from_end] = slice[..] else {
+        return 0;
+    };
+    slice[0]
+}
+
+unsafe extern "Rust" {
+    safe fn opaque_inner(_: *const core::ffi::c_void);
+}
+
+#[inline(never)]
+pub fn opaque_use<T>(p: &T) {
+    opaque_inner(&raw const p as *const _);
+}
+
+#[no_mangle]
+pub fn non_arg_ref(scalar: i32, foo: Foo, a: &i32) -> i32 {
+    // CHECK-LABEL: define{{.*}} i32 @non_arg_ref
+    // CHECK: #dbg_value(ptr %non_arg_ref_scalar, [[VAR_non_arg_ref_scalar_ref:![0-9]+]], !DIExpression()
+    // CHECK-NEXT: #dbg_value(ptr %non_arg_ref_foo, [[VAR_non_arg_ref_foo_ref:![0-9]+]], !DIExpression()
+    // CHECK-NEXT: #dbg_value(ptr %non_arg_ref_foo, [[VAR_non_arg_ref_foo_ref_2:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 16, DW_OP_stack_value)
+    let non_arg_ref_scalar = scalar;
+    let non_arg_ref_foo = foo;
+    opaque_use(&non_arg_ref_scalar);
+    opaque_use(&non_arg_ref_foo);
+    let non_arg_ref_scalar_ref = &non_arg_ref_scalar;
+    let non_arg_ref_foo_ref = &non_arg_ref_foo;
+    let non_arg_ref_foo_ref_2 = &non_arg_ref_foo.2;
+    *a
+}
+
+// CHECK-DAG: [[VAR_invalid_ref_of_ref_foo]] = !DILocalVariable(name: "invalid_ref_of_ref_foo"
+// OPTIMIZED-DAG: [[VAR_ref_foo]] = !DILocalVariable(name: "ref_foo"
+// CHECK-DAG: [[VAR_ref_v0]] = !DILocalVariable(name: "ref_v0"
+// CHECK-DAG: [[VAR_ref_v1]] = !DILocalVariable(name: "ref_v1"
+// CHECK-DAG: [[VAR_ref_v2]] = !DILocalVariable(name: "ref_v2"
+// CHECK-DAG: [[ref_ptr_foo]] = !DILocalVariable(name: "ref_ptr_foo"
+// CHECK-DAG: [[VAR_ptr_v0]] = !DILocalVariable(name: "ptr_v0"
+// CHECK-DAG: [[VAR_ptr_v1]] = !DILocalVariable(name: "ptr_v1"
+// CHECK-DAG: [[VAR_ptr_v2]] = !DILocalVariable(name: "ptr_v2"
+// CODEGEN-DAG: [[VAR_val_ref]] = !DILocalVariable(name: "val_ref"
+// CHECK-DAG: [[VAR_fragment_f]] = !DILocalVariable(name: "fragment_f"
+// CHECK-DAG: [[VAR_tuple_dead]] = !DILocalVariable(name: "tuple_dead"
+// CHECK-DAG: [[ARG_dead_first_foo]] = !DILocalVariable(name: "dead_first_foo"
+// CHECK-DAG: [[VAR_dead_first_v0]] = !DILocalVariable(name: "dead_first_v0"
+// CHECK-DAG: [[VAR_index_from_var]] = !DILocalVariable(name: "index_from_var"
+// CHECK-DAG: [[VAR_const_index_from_start]] = !DILocalVariable(name: "const_index_from_start"
+// CHECK-DAG: [[VAR_const_index_from_end]] = !DILocalVariable(name: "const_index_from_end"
+// CHECK-DAG: [[VAR_zst_ref]] = !DILocalVariable(name: "zst_ref"
+// CHECK-DAG: [[VAR_non_arg_ref_scalar_ref]] = !DILocalVariable(name: "non_arg_ref_scalar_ref"
+// CHECK-DAG: [[VAR_non_arg_ref_foo_ref]] = !DILocalVariable(name: "non_arg_ref_foo_ref"
+// CHECK-DAG: [[VAR_non_arg_ref_foo_ref_2]] = !DILocalVariable(name: "non_arg_ref_foo_ref_2"
diff --git a/tests/debuginfo/opt/dead_refs.rs b/tests/debuginfo/opt/dead_refs.rs
new file mode 100644
index 0000000000000..61e741573346e
--- /dev/null
+++ b/tests/debuginfo/opt/dead_refs.rs
@@ -0,0 +1,50 @@
+//@ min-lldb-version: 1800
+//@ min-gdb-version: 13.0
+//@ compile-flags: -g -Copt-level=3
+//@ disable-gdb-pretty-printers
+
+// Checks that we still can access dead variables from debuginfos.
+
+// === GDB TESTS ===================================================================================
+
+// gdb-command:run
+// gdb-command:print *ref_v0
+// gdb-check:$1 = 0
+
+// gdb-command:print *ref_v1
+// gdb-check:$2 = 1
+
+// gdb-command:print *ref_v2
+// gdb-check:$3 = 2
+
+// === LLDB TESTS ==================================================================================
+
+// lldb-command:run
+// lldb-command:v *ref_v0
+// lldb-check:[...] 0
+
+// lldb-command:v *ref_v1
+// lldb-check:[...] 1
+
+// lldb-command:v *ref_v2
+// lldb-check:[...] 2
+
+#![allow(unused_variables)]
+
+use std::hint::black_box;
+
+pub struct Foo(i32, i64, i32);
+
+#[inline(never)]
+#[no_mangle]
+fn test_ref(ref_foo: &Foo) -> i32 {
+    let ref_v0 = &ref_foo.0;
+    let ref_v1 = &ref_foo.1;
+    let ref_v2 = &ref_foo.2;
+    ref_foo.0 // #break
+}
+
+fn main() {
+    let foo = black_box(Foo(0, 1, 2));
+    black_box(test_ref(&foo));
+}

From 8da04285cf6fe61587e16155a8b224dba64bf0be Mon Sep 17 00:00:00 2001
From: dianqk <dianqk@dianqk.net>
Date: Sat, 19 Jul 2025 18:49:47 +0800
Subject: [PATCH 1654/1889] mir-opt: Eliminate dead statements even if they are
 used by debuginfos

---
 .../rustc_codegen_ssa/src/mir/statement.rs    |  3 ++
 compiler/rustc_middle/src/mir/pretty.rs       |  3 ++
 compiler/rustc_middle/src/mir/statement.rs    | 15 ++++++
 compiler/rustc_middle/src/mir/visit.rs        |  7 +++
 compiler/rustc_mir_dataflow/src/debuginfo.rs  | 10 ++--
 .../rustc_mir_dataflow/src/impls/liveness.rs  |  3 --
 compiler/rustc_mir_transform/src/simplify.rs  | 16 ++++++
 .../src/strip_debuginfo.rs                    | 17 +++++++
 tests/codegen-llvm/debuginfo-dse.rs           | 23 +++++++--
 tests/mir-opt/dead-store-elimination/ref.rs   |  4 +-
 ...ef.tuple.DeadStoreElimination-initial.diff |  2 +-
 .../inline_shims.drop.Inline.panic-abort.diff | 50 ++++++++-----------
 ...y.run2-{closure#0}.Inline.panic-abort.diff |  4 --
 ....run2-{closure#0}.Inline.panic-unwind.diff |  4 --
 ...d_place.invalid_place.PreCodegen.after.mir | 13 +++++
 .../pre-codegen/dead_on_invalid_place.rs      | 27 ++++++++++
 .../loops.vec_move.PreCodegen.after.mir       | 12 ++---
 ...variant_a-{closure#0}.PreCodegen.after.mir | 42 +++++++---------
 ..._to_slice.PreCodegen.after.panic-abort.mir |  8 ---
 ...to_slice.PreCodegen.after.panic-unwind.mir |  8 ---
 20 files changed, 170 insertions(+), 101 deletions(-)
 create mode 100644 tests/mir-opt/pre-codegen/dead_on_invalid_place.invalid_place.PreCodegen.after.mir
 create mode 100644 tests/mir-opt/pre-codegen/dead_on_invalid_place.rs

diff --git a/compiler/rustc_codegen_ssa/src/mir/statement.rs b/compiler/rustc_codegen_ssa/src/mir/statement.rs
index 99bb31a68b688..80f4f0fcda1ce 100644
--- a/compiler/rustc_codegen_ssa/src/mir/statement.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/statement.rs
@@ -155,6 +155,9 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                     self.debug_poison_to_local(bx, *dest);
                 }
             }
+            StmtDebugInfo::InvalidAssign(local) => {
+                self.debug_poison_to_local(bx, *local);
+            }
         }
     }
 
diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
index 8cf89f778a2aa..d87e3abe3b2ea 100644
--- a/compiler/rustc_middle/src/mir/pretty.rs
+++ b/compiler/rustc_middle/src/mir/pretty.rs
@@ -844,6 +844,9 @@ impl Debug for StmtDebugInfo<'_> {
             StmtDebugInfo::AssignRef(local, place) => {
                 write!(fmt, "{local:?} = &{place:?}")
             }
+            StmtDebugInfo::InvalidAssign(local) => {
+                write!(fmt, "{local:?} = &?")
+            }
         }
     }
 }
diff --git a/compiler/rustc_middle/src/mir/statement.rs b/compiler/rustc_middle/src/mir/statement.rs
index 67b4448cfcddd..f310e1e576250 100644
--- a/compiler/rustc_middle/src/mir/statement.rs
+++ b/compiler/rustc_middle/src/mir/statement.rs
@@ -527,6 +527,20 @@ impl<'tcx> PlaceRef<'tcx> {
         })
     }
 
+    /// Return the place accessed locals that include the base local.
+    pub fn accessed_locals(self) -> impl Iterator<Item = Local> {
+        std::iter::once(self.local).chain(self.projection.iter().filter_map(|proj| match proj {
+            ProjectionElem::Index(local) => Some(*local),
+            ProjectionElem::Deref
+            | ProjectionElem::Field(_, _)
+            | ProjectionElem::ConstantIndex { .. }
+            | ProjectionElem::Subslice { .. }
+            | ProjectionElem::Downcast(_, _)
+            | ProjectionElem::OpaqueCast(_)
+            | ProjectionElem::UnwrapUnsafeBinder(_) => None,
+        }))
+    }
+
     /// Generates a new place by appending `more_projections` to the existing ones
     /// and interning the result.
     pub fn project_deeper(
@@ -1057,4 +1071,5 @@ impl<'tcx> ops::DerefMut for StmtDebugInfos<'tcx> {
 #[derive(Clone, TyEncodable, TyDecodable, HashStable, TypeFoldable, TypeVisitable)]
 pub enum StmtDebugInfo<'tcx> {
     AssignRef(Local, Place<'tcx>),
+    InvalidAssign(Local),
 }
diff --git a/compiler/rustc_middle/src/mir/visit.rs b/compiler/rustc_middle/src/mir/visit.rs
index 47ae23afd556e..9654e189f2edf 100644
--- a/compiler/rustc_middle/src/mir/visit.rs
+++ b/compiler/rustc_middle/src/mir/visit.rs
@@ -406,6 +406,13 @@ macro_rules! make_mir_visitor {
                             location
                         );
                     },
+                    StmtDebugInfo::InvalidAssign(local) => {
+                        self.visit_local(
+                            $(& $mutability)? *local,
+                            PlaceContext::NonUse(NonUseContext::VarDebugInfo),
+                            location
+                        );
+                    }
                 }
             }
 
diff --git a/compiler/rustc_mir_dataflow/src/debuginfo.rs b/compiler/rustc_mir_dataflow/src/debuginfo.rs
index 274c5943946c2..0d25ce91c9a9e 100644
--- a/compiler/rustc_mir_dataflow/src/debuginfo.rs
+++ b/compiler/rustc_mir_dataflow/src/debuginfo.rs
@@ -5,16 +5,16 @@ use rustc_middle::mir::*;
 /// Return the set of locals that appear in debuginfo.
 pub fn debuginfo_locals(body: &Body<'_>) -> DenseBitSet<Local> {
     let mut visitor = DebuginfoLocals(DenseBitSet::new_empty(body.local_decls.len()));
-    visitor.visit_body(body);
+    for debuginfo in body.var_debug_info.iter() {
+        visitor.visit_var_debug_info(debuginfo);
+    }
     visitor.0
 }
 
 struct DebuginfoLocals(DenseBitSet<Local>);
 
 impl Visitor<'_> for DebuginfoLocals {
-    fn visit_local(&mut self, local: Local, place_context: PlaceContext, _: Location) {
-        if place_context == PlaceContext::NonUse(NonUseContext::VarDebugInfo) {
-            self.0.insert(local);
-        }
+    fn visit_local(&mut self, local: Local, _: PlaceContext, _: Location) {
+        self.0.insert(local);
     }
 }
diff --git a/compiler/rustc_mir_dataflow/src/impls/liveness.rs b/compiler/rustc_mir_dataflow/src/impls/liveness.rs
index 037e2720f3651..f6aaa65ad9fdd 100644
--- a/compiler/rustc_mir_dataflow/src/impls/liveness.rs
+++ b/compiler/rustc_mir_dataflow/src/impls/liveness.rs
@@ -287,9 +287,6 @@ impl<'a, 'tcx> Analysis<'tcx> for MaybeTransitiveLiveLocals<'a> {
         if let Some(destination) =
             Self::can_be_removed_if_dead(&statement.kind, &self.always_live, &self.debuginfo_locals)
             && !state.contains(destination.local)
-            // FIXME: We can eliminate the statement, but we'll need the statements it depends on
-            // for debuginfos. We need a way to handle this.
-            && !self.debuginfo_locals.contains(destination.local)
         {
             // This store is dead
             return;
diff --git a/compiler/rustc_mir_transform/src/simplify.rs b/compiler/rustc_mir_transform/src/simplify.rs
index 0f23482ea8b1b..8b5efb7420582 100644
--- a/compiler/rustc_mir_transform/src/simplify.rs
+++ b/compiler/rustc_mir_transform/src/simplify.rs
@@ -657,6 +657,22 @@ impl<'tcx> MutVisitor<'tcx> for LocalUpdater<'tcx> {
         self.tcx
     }
 
+    fn visit_statement_debuginfo(
+        &mut self,
+        stmt_debuginfo: &mut StmtDebugInfo<'tcx>,
+        location: Location,
+    ) {
+        match stmt_debuginfo {
+            StmtDebugInfo::AssignRef(local, place) => {
+                if place.as_ref().accessed_locals().any(|local| self.map[local].is_none()) {
+                    *stmt_debuginfo = StmtDebugInfo::InvalidAssign(*local);
+                }
+            }
+            StmtDebugInfo::InvalidAssign(_) => {}
+        }
+        self.super_statement_debuginfo(stmt_debuginfo, location);
+    }
+
     fn visit_local(&mut self, l: &mut Local, _: PlaceContext, _: Location) {
         *l = self.map[*l].unwrap();
     }
diff --git a/compiler/rustc_mir_transform/src/strip_debuginfo.rs b/compiler/rustc_mir_transform/src/strip_debuginfo.rs
index 9ede8aa79c44a..7fec25ccb5218 100644
--- a/compiler/rustc_mir_transform/src/strip_debuginfo.rs
+++ b/compiler/rustc_mir_transform/src/strip_debuginfo.rs
@@ -1,5 +1,6 @@
 use rustc_middle::mir::*;
 use rustc_middle::ty::TyCtxt;
+use rustc_mir_dataflow::debuginfo::debuginfo_locals;
 use rustc_session::config::MirStripDebugInfo;
 
 /// Conditionally remove some of the VarDebugInfo in MIR.
@@ -30,6 +31,22 @@ impl<'tcx> crate::MirPass<'tcx> for StripDebugInfo {
                     if place.local.as_usize() <= body.arg_count && place.local != RETURN_PLACE,
             )
         });
+
+        let debuginfo_locals = debuginfo_locals(body);
+        for data in body.basic_blocks.as_mut_preserves_cfg() {
+            for stmt in data.statements.iter_mut() {
+                stmt.debuginfos.retain(|debuginfo| match debuginfo {
+                    StmtDebugInfo::AssignRef(local, _) | StmtDebugInfo::InvalidAssign(local) => {
+                        debuginfo_locals.contains(*local)
+                    }
+                });
+            }
+            data.after_last_stmt_debuginfos.retain(|debuginfo| match debuginfo {
+                StmtDebugInfo::AssignRef(local, _) | StmtDebugInfo::InvalidAssign(local) => {
+                    debuginfo_locals.contains(*local)
+                }
+            });
+        }
     }
 
     fn is_required(&self) -> bool {
diff --git a/tests/codegen-llvm/debuginfo-dse.rs b/tests/codegen-llvm/debuginfo-dse.rs
index 1fcb5fcfc543a..78e145a3cdf12 100644
--- a/tests/codegen-llvm/debuginfo-dse.rs
+++ b/tests/codegen-llvm/debuginfo-dse.rs
@@ -1,4 +1,4 @@
-//@ compile-flags: -Copt-level=3 -g -Zverify-llvm-ir
+//@ compile-flags: -Copt-level=3 -g -Zverify-llvm-ir -Zmerge-functions=disabled
 //@ revisions: CODEGEN OPTIMIZED
 //@[CODEGEN] compile-flags: -Cno-prepopulate-passes
 // ignore-tidy-linelength
@@ -9,6 +9,13 @@
 #[derive(Clone, Copy)]
 pub struct Foo(i32, i64, i32);
 
+#[repr(C)]
+pub struct Bar<'a> {
+    a: i32,
+    b: i64,
+    foo: &'a Foo,
+}
+
 #[no_mangle]
 fn r#ref(ref_foo: &Foo) -> i32 {
     // CHECK-LABEL: define{{.*}} i32 @ref
@@ -78,11 +85,20 @@ pub fn fragment(fragment_v1: Foo, mut fragment_v2: Foo) -> Foo {
     fragment_v2
 }
 
+#[no_mangle]
+pub fn deref(bar: Bar) -> i32 {
+    // CHECK-LABEL: define {{.*}} i32 @deref
+    // We are unable to represent dereference within this expression.
+    // CHECK: #dbg_value(ptr poison, [[VAR_deref_dead:![0-9]+]], !DIExpression()
+    let deref_dead = &bar.foo.2;
+    bar.a
+}
+
 #[no_mangle]
 pub fn tuple(foo: (i32, &Foo)) -> i32 {
     // CHECK-LABEL: define{{.*}} i32 @tuple
-    // CHECK-SAME: (i32 {{.*}}, ptr {{.*}} [[ARG_tuple_foo_1:%.*]])
-    // CHECK: #dbg_value(ptr [[ARG_tuple_foo_1]], [[VAR_tuple_dead:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 16, DW_OP_stack_value)
+    // Although there is no dereference here, there is a dereference in the MIR.
+    // CHECK: #dbg_value(ptr poison, [[VAR_tuple_dead:![0-9]+]], !DIExpression()
     let tuple_dead = &foo.1.2;
     foo.1.0
 }
@@ -148,6 +164,7 @@ pub fn non_arg_ref(scalar: i32, foo: Foo, a: &i32) -> i32 {
 // CHECK-DAG: [[VAR_ptr_v2]] = !DILocalVariable(name: "ptr_v2"
 // CODEGEN-DAG: [[VAR_val_ref]] = !DILocalVariable(name: "val_ref"
 // CHECK-DAG: [[VAR_fragment_f]] = !DILocalVariable(name: "fragment_f"
+// CHECK-DAG: [[VAR_deref_dead]] = !DILocalVariable(name: "deref_dead"
 // CHECK-DAG: [[VAR_tuple_dead]] = !DILocalVariable(name: "tuple_dead"
 // CHECK-DAG: [[ARG_dead_first_foo]] = !DILocalVariable(name: "dead_first_foo"
 // CHECK-DAG: [[VAR_dead_first_v0]] = !DILocalVariable(name: "dead_first_v0"
diff --git a/tests/mir-opt/dead-store-elimination/ref.rs b/tests/mir-opt/dead-store-elimination/ref.rs
index 18d9ea8b84d7d..2d3200edab9f6 100644
--- a/tests/mir-opt/dead-store-elimination/ref.rs
+++ b/tests/mir-opt/dead-store-elimination/ref.rs
@@ -11,9 +11,7 @@ pub fn tuple(v: (i32, &Foo)) -> i32 {
     // CHECK-LABEL: fn tuple
     // CHECK: debug _dead => [[dead:_[0-9]+]];
     // CHECK: bb0:
-    // FIXME: Preserve `tmp` for debuginfo, but we can merge it into the debuginfo.
-    // CHECK: [[tmp:_[0-9]+]] = deref_copy (_1.1: &Foo);
-    // CHECK-NEXT: DBG: [[dead]] = &((*[[tmp]]).2: i32)
+    // CHECK: DBG: [[dead]] = &((*_3).2: i32)
     let _dead = &v.1.c;
     v.1.a
 }
diff --git a/tests/mir-opt/dead-store-elimination/ref.tuple.DeadStoreElimination-initial.diff b/tests/mir-opt/dead-store-elimination/ref.tuple.DeadStoreElimination-initial.diff
index af28c1b9aa87a..0b96569cbe4b1 100644
--- a/tests/mir-opt/dead-store-elimination/ref.tuple.DeadStoreElimination-initial.diff
+++ b/tests/mir-opt/dead-store-elimination/ref.tuple.DeadStoreElimination-initial.diff
@@ -13,7 +13,7 @@
   
       bb0: {
 -         StorageLive(_2);
-          _3 = deref_copy (_1.1: &Foo);
+-         _3 = deref_copy (_1.1: &Foo);
 -         _2 = &((*_3).2: i32);
 +         // DBG: _2 = &((*_3).2: i32);
           _4 = deref_copy (_1.1: &Foo);
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 7fa22524f0082..9509739413b76 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
@@ -16,12 +16,10 @@
 +             let mut _9: *mut A;
 +             let mut _10: usize;
 +             scope 3 (inlined Vec::<A>::as_mut_ptr) {
-+                 let mut _11: &alloc::raw_vec::RawVec<A>;
 +                 scope 4 (inlined alloc::raw_vec::RawVec::<A>::ptr) {
-+                     let mut _12: &alloc::raw_vec::RawVecInner;
 +                     scope 5 (inlined alloc::raw_vec::RawVecInner::ptr::<A>) {
 +                         scope 6 (inlined alloc::raw_vec::RawVecInner::non_null::<A>) {
-+                             let mut _13: std::ptr::NonNull<u8>;
++                             let mut _11: std::ptr::NonNull<u8>;
 +                             scope 7 (inlined Unique::<u8>::cast::<A>) {
 +                                 scope 8 (inlined NonNull::<u8>::cast::<A>) {
 +                                     scope 9 (inlined NonNull::<u8>::as_ptr) {
@@ -41,15 +39,15 @@
 +                 }
 +             }
 +             scope 14 (inlined drop_in_place::<[A]> - shim(Some([A]))) {
-+                 let mut _14: usize;
-+                 let mut _15: *mut A;
-+                 let mut _16: bool;
++                 let mut _12: usize;
++                 let mut _13: *mut A;
++                 let mut _14: bool;
 +             }
 +         }
 +     }
 +     scope 15 (inlined drop_in_place::<Option<B>> - shim(Some(Option<B>))) {
-+         let mut _17: isize;
-+         let mut _18: isize;
++         let mut _15: isize;
++         let mut _16: isize;
 +     }
   
       bb0: {
@@ -64,20 +62,16 @@
 +         StorageLive(_8);
 +         StorageLive(_9);
 +         StorageLive(_11);
-+         StorageLive(_12);
-+         StorageLive(_13);
-+         _13 = copy (((((*_6).0: alloc::raw_vec::RawVec<A>).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique<u8>).0: std::ptr::NonNull<u8>);
-+         _9 = copy _13 as *mut A (Transmute);
-+         StorageDead(_13);
-+         StorageDead(_12);
++         _11 = copy (((((*_6).0: alloc::raw_vec::RawVec<A>).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique<u8>).0: std::ptr::NonNull<u8>);
++         _9 = copy _11 as *mut A (Transmute);
 +         StorageDead(_11);
 +         _10 = copy ((*_6).1: usize);
 +         _8 = *mut [A] from (copy _9, copy _10);
 +         StorageDead(_9);
++         StorageLive(_12);
++         StorageLive(_13);
 +         StorageLive(_14);
-+         StorageLive(_15);
-+         StorageLive(_16);
-+         _14 = const 0_usize;
++         _12 = const 0_usize;
 +         goto -> bb4;
       }
   
@@ -89,33 +83,33 @@
           StorageLive(_5);
           _5 = copy _2;
 -         _0 = drop_in_place::<Option<B>>(move _5) -> [return: bb2, unwind unreachable];
-+         StorageLive(_17);
-+         _17 = discriminant((*_5));
-+         switchInt(move _17) -> [0: bb5, otherwise: bb6];
++         StorageLive(_15);
++         _15 = discriminant((*_5));
++         switchInt(move _15) -> [0: bb5, otherwise: bb6];
       }
   
       bb2: {
-+         StorageDead(_16);
-+         StorageDead(_15);
 +         StorageDead(_14);
++         StorageDead(_13);
++         StorageDead(_12);
 +         StorageDead(_8);
 +         StorageDead(_10);
 +         drop(((*_4).0: alloc::raw_vec::RawVec<A>)) -> [return: bb1, unwind unreachable];
 +     }
 + 
 +     bb3: {
-+         _15 = &raw mut (*_8)[_14];
-+         _14 = Add(move _14, const 1_usize);
-+         drop((*_15)) -> [return: bb4, unwind unreachable];
++         _13 = &raw mut (*_8)[_12];
++         _12 = Add(move _12, const 1_usize);
++         drop((*_13)) -> [return: bb4, unwind unreachable];
 +     }
 + 
 +     bb4: {
-+         _16 = Eq(copy _14, copy _10);
-+         switchInt(move _16) -> [0: bb3, otherwise: bb2];
++         _14 = Eq(copy _12, copy _10);
++         switchInt(move _14) -> [0: bb3, otherwise: bb2];
 +     }
 + 
 +     bb5: {
-+         StorageDead(_17);
++         StorageDead(_15);
           StorageDead(_5);
           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 bb81cb4e2600a..0acb33febe52b 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
@@ -220,16 +220,12 @@
 +         StorageLive(_49);
 +         StorageLive(_41);
 +         StorageLive(_42);
-+         StorageLive(_43);
-+         StorageLive(_46);
 +         _44 = copy (_19.0: &mut std::future::Ready<()>);
-+         StorageDead(_46);
 +         StorageLive(_47);
 +         _47 = Option::<()>::None;
 +         _42 = copy ((*_44).0: std::option::Option<()>);
 +         ((*_44).0: std::option::Option<()>) = copy _47;
 +         StorageDead(_47);
-+         StorageDead(_43);
 +         StorageLive(_48);
 +         _48 = discriminant(_42);
 +         switchInt(move _48) -> [0: bb11, 1: bb12, otherwise: bb5];
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 520c54824e150..98ee46c29b1be 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
@@ -237,16 +237,12 @@
 +         StorageLive(_51);
 +         StorageLive(_43);
 +         StorageLive(_44);
-+         StorageLive(_45);
-+         StorageLive(_48);
 +         _46 = copy (_19.0: &mut std::future::Ready<()>);
-+         StorageDead(_48);
 +         StorageLive(_49);
 +         _49 = Option::<()>::None;
 +         _44 = copy ((*_46).0: std::option::Option<()>);
 +         ((*_46).0: std::option::Option<()>) = copy _49;
 +         StorageDead(_49);
-+         StorageDead(_45);
 +         StorageLive(_50);
 +         _50 = discriminant(_44);
 +         switchInt(move _50) -> [0: bb16, 1: bb17, otherwise: bb7];
diff --git a/tests/mir-opt/pre-codegen/dead_on_invalid_place.invalid_place.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/dead_on_invalid_place.invalid_place.PreCodegen.after.mir
new file mode 100644
index 0000000000000..4a2127178fb0b
--- /dev/null
+++ b/tests/mir-opt/pre-codegen/dead_on_invalid_place.invalid_place.PreCodegen.after.mir
@@ -0,0 +1,13 @@
+// MIR for `invalid_place` after PreCodegen
+
+fn invalid_place(_1: bool) -> bool {
+    debug c1_ref => _2;
+    let mut _0: bool;
+    let mut _2: &bool;
+
+    bb0: {
+        // DBG: _2 = &?;
+        _0 = copy _1;
+        return;
+    }
+}
diff --git a/tests/mir-opt/pre-codegen/dead_on_invalid_place.rs b/tests/mir-opt/pre-codegen/dead_on_invalid_place.rs
new file mode 100644
index 0000000000000..5abe9fa43a5d2
--- /dev/null
+++ b/tests/mir-opt/pre-codegen/dead_on_invalid_place.rs
@@ -0,0 +1,27 @@
+#![feature(core_intrinsics, custom_mir)]
+#![crate_type = "lib"]
+
+use std::intrinsics::mir::*;
+
+// EMIT_MIR dead_on_invalid_place.invalid_place.PreCodegen.after.mir
+#[custom_mir(dialect = "runtime")]
+pub fn invalid_place(c: bool) -> bool {
+    // CHECK-LABEL: fn invalid_place
+    // CHECK: debug c1_ref => [[c1_ref:_[0-9]+]];
+    // CHECK: bb0: {
+    // We cannot read the reference, since `c1` is dead.
+    // CHECK-NEXT: DBG: [[c1_ref]] = &?
+    // CHECK-NEXT: _0 = copy _1;
+    // CHECK-NEXT: return;
+    mir! {
+        let _c1_ref: &bool;
+        let c1: bool;
+        debug c1_ref => _c1_ref;
+        {
+            c1 = c;
+            _c1_ref = &c1;
+            RET = c;
+            Return()
+        }
+    }
+}
diff --git a/tests/mir-opt/pre-codegen/loops.vec_move.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/loops.vec_move.PreCodegen.after.mir
index f453741dc6c78..66eb1bcfaa665 100644
--- a/tests/mir-opt/pre-codegen/loops.vec_move.PreCodegen.after.mir
+++ b/tests/mir-opt/pre-codegen/loops.vec_move.PreCodegen.after.mir
@@ -56,11 +56,11 @@ fn vec_move(_1: Vec<impl Sized>) -> () {
                             scope 40 (inlined alloc::raw_vec::RawVec::<impl Sized>::capacity) {
                                 debug self => _37;
                                 let mut _19: usize;
-                                let mut _42: &alloc::raw_vec::RawVecInner;
+                                let mut _39: &alloc::raw_vec::RawVecInner;
                                 scope 41 (inlined std::mem::size_of::<impl Sized>) {
                                 }
                                 scope 42 (inlined alloc::raw_vec::RawVecInner::capacity) {
-                                    debug self => _42;
+                                    debug self => _39;
                                     debug elem_size => _19;
                                     let mut _21: core::num::niche_types::UsizeNoHighBit;
                                     scope 43 (inlined core::num::niche_types::UsizeNoHighBit::as_inner) {
@@ -130,7 +130,6 @@ fn vec_move(_1: Vec<impl Sized>) -> () {
                 }
                 scope 18 (inlined alloc::raw_vec::RawVec::<impl Sized>::non_null) {
                     debug self => _31;
-                    let mut _41: &alloc::raw_vec::RawVecInner;
                     scope 19 (inlined alloc::raw_vec::RawVecInner::non_null::<impl Sized>) {
                         let mut _4: std::ptr::NonNull<u8>;
                         scope 20 (inlined Unique::<u8>::cast::<impl Sized>) {
@@ -150,9 +149,7 @@ fn vec_move(_1: Vec<impl Sized>) -> () {
             }
             scope 12 (inlined Vec::<impl Sized>::allocator) {
                 debug self => _29;
-                let mut _39: &alloc::raw_vec::RawVec<impl Sized>;
                 scope 13 (inlined alloc::raw_vec::RawVec::<impl Sized>::allocator) {
-                    let mut _40: &alloc::raw_vec::RawVecInner;
                     scope 14 (inlined alloc::raw_vec::RawVecInner::allocator) {
                     }
                 }
@@ -183,13 +180,10 @@ fn vec_move(_1: Vec<impl Sized>) -> () {
         StorageLive(_3);
         // DBG: _30 = &_2;
         // DBG: _29 = &(_2.0: std::vec::Vec<impl Sized>);
-        // DBG: _39 = &((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>);
-        // DBG: _40 = &(((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>).0: alloc::raw_vec::RawVecInner);
         _3 = &raw const ((((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>).0: alloc::raw_vec::RawVecInner).2: std::alloc::Global);
         StorageDead(_3);
         // DBG: _32 = &_2;
         // DBG: _31 = &((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>);
-        // DBG: _41 = &(((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>).0: alloc::raw_vec::RawVecInner);
         _4 = copy (((((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique<u8>).0: std::ptr::NonNull<u8>);
         _5 = copy _4 as *const impl Sized (Transmute);
         _6 = NonNull::<impl Sized> { pointer: copy _5 };
@@ -247,7 +241,7 @@ fn vec_move(_1: Vec<impl Sized>) -> () {
     bb4: {
         // DBG: _38 = &_2;
         // DBG: _37 = &((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>);
-        // DBG: _42 = &(((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>).0: alloc::raw_vec::RawVecInner);
+        // DBG: _39 = &(((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>).0: alloc::raw_vec::RawVecInner);
         StorageLive(_19);
         _19 = SizeOf(impl Sized);
         switchInt(move _19) -> [0: bb5, otherwise: bb6];
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 86c729b3e95e3..2cab88182962f 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
@@ -71,21 +71,17 @@ fn variant_a::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:7:25: 7:39}, _2
         // DBG: _16 = &((*_3).3: usize);
         StorageLive(_6);
         // DBG: _17 = &_13;
-        // DBG: _18 = &_15;
+        // DBG: _18 = &?;
         _4 = copy ((*_3).0: usize);
         _5 = copy ((*_3).2: usize);
         _6 = Le(copy _4, copy _5);
-        switchInt(move _6) -> [0: bb1, otherwise: bb2];
+        switchInt(move _6) -> [0: bb2, otherwise: bb1];
     }
 
     bb1: {
-        goto -> bb4;
-    }
-
-    bb2: {
         StorageLive(_9);
         // DBG: _19 = &_16;
-        // DBG: _20 = &_14;
+        // DBG: _20 = &?;
         StorageLive(_7);
         _7 = copy ((*_3).3: usize);
         StorageLive(_8);
@@ -93,29 +89,25 @@ fn variant_a::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:7:25: 7:39}, _2
         _9 = Le(move _7, move _8);
         StorageDead(_8);
         StorageDead(_7);
-        switchInt(move _9) -> [0: bb3, otherwise: bb8];
-    }
-
-    bb3: {
-        goto -> bb4;
+        switchInt(move _9) -> [0: bb2, otherwise: bb6];
     }
 
-    bb4: {
+    bb2: {
         StorageLive(_10);
         // DBG: _21 = &_15;
-        // DBG: _22 = &_13;
+        // DBG: _22 = &?;
         _10 = Le(copy _5, copy _4);
-        switchInt(move _10) -> [0: bb5, otherwise: bb6];
+        switchInt(move _10) -> [0: bb3, otherwise: bb4];
     }
 
-    bb5: {
+    bb3: {
         _0 = const false;
-        goto -> bb7;
+        goto -> bb5;
     }
 
-    bb6: {
+    bb4: {
         // DBG: _23 = &_14;
-        // DBG: _24 = &_16;
+        // DBG: _24 = &?;
         StorageLive(_11);
         _11 = copy ((*_3).1: usize);
         StorageLive(_12);
@@ -123,20 +115,20 @@ fn variant_a::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:7:25: 7:39}, _2
         _0 = Le(move _11, move _12);
         StorageDead(_12);
         StorageDead(_11);
-        goto -> bb7;
+        goto -> bb5;
     }
 
-    bb7: {
+    bb5: {
         StorageDead(_10);
-        goto -> bb9;
+        goto -> bb7;
     }
 
-    bb8: {
+    bb6: {
         _0 = const true;
-        goto -> bb9;
+        goto -> bb7;
     }
 
-    bb9: {
+    bb7: {
         StorageDead(_9);
         StorageDead(_6);
         return;
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 eebd4a7eb50e3..2eee8a97db0d4 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
@@ -11,9 +11,7 @@ fn vec_deref_to_slice(_1: &Vec<u8>) -> &[u8] {
             let mut _4: usize;
             scope 3 (inlined Vec::<u8>::as_ptr) {
                 debug self => _1;
-                let mut _6: &alloc::raw_vec::RawVec<u8>;
                 scope 4 (inlined alloc::raw_vec::RawVec::<u8>::ptr) {
-                    let mut _7: &alloc::raw_vec::RawVecInner;
                     scope 5 (inlined alloc::raw_vec::RawVecInner::ptr::<u8>) {
                         scope 6 (inlined alloc::raw_vec::RawVecInner::non_null::<u8>) {
                             let mut _2: std::ptr::NonNull<u8>;
@@ -57,14 +55,8 @@ fn vec_deref_to_slice(_1: &Vec<u8>) -> &[u8] {
     bb0: {
         StorageLive(_2);
         StorageLive(_3);
-        StorageLive(_6);
-        // DBG: _6 = &((*_1).0: alloc::raw_vec::RawVec<u8>);
-        StorageLive(_7);
-        // DBG: _7 = &(((*_1).0: alloc::raw_vec::RawVec<u8>).0: alloc::raw_vec::RawVecInner);
         _2 = copy (((((*_1).0: alloc::raw_vec::RawVec<u8>).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique<u8>).0: std::ptr::NonNull<u8>);
-        StorageDead(_7);
         _3 = copy _2 as *const u8 (Transmute);
-        StorageDead(_6);
         StorageLive(_4);
         _4 = copy ((*_1).1: usize);
         StorageLive(_5);
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 eebd4a7eb50e3..2eee8a97db0d4 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
@@ -11,9 +11,7 @@ fn vec_deref_to_slice(_1: &Vec<u8>) -> &[u8] {
             let mut _4: usize;
             scope 3 (inlined Vec::<u8>::as_ptr) {
                 debug self => _1;
-                let mut _6: &alloc::raw_vec::RawVec<u8>;
                 scope 4 (inlined alloc::raw_vec::RawVec::<u8>::ptr) {
-                    let mut _7: &alloc::raw_vec::RawVecInner;
                     scope 5 (inlined alloc::raw_vec::RawVecInner::ptr::<u8>) {
                         scope 6 (inlined alloc::raw_vec::RawVecInner::non_null::<u8>) {
                             let mut _2: std::ptr::NonNull<u8>;
@@ -57,14 +55,8 @@ fn vec_deref_to_slice(_1: &Vec<u8>) -> &[u8] {
     bb0: {
         StorageLive(_2);
         StorageLive(_3);
-        StorageLive(_6);
-        // DBG: _6 = &((*_1).0: alloc::raw_vec::RawVec<u8>);
-        StorageLive(_7);
-        // DBG: _7 = &(((*_1).0: alloc::raw_vec::RawVec<u8>).0: alloc::raw_vec::RawVecInner);
         _2 = copy (((((*_1).0: alloc::raw_vec::RawVec<u8>).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique<u8>).0: std::ptr::NonNull<u8>);
-        StorageDead(_7);
         _3 = copy _2 as *const u8 (Transmute);
-        StorageDead(_6);
         StorageLive(_4);
         _4 = copy ((*_1).1: usize);
         StorageLive(_5);

From ecb831dcf4c28d3b66c9bce7aa4c3a8eb221fa5e Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Thu, 2 Oct 2025 16:29:18 +1000
Subject: [PATCH 1655/1889] Extract helper method `set_metadata_node`

---
 compiler/rustc_codegen_llvm/src/asm.rs     |  4 +-
 compiler/rustc_codegen_llvm/src/builder.rs | 54 +++++++---------------
 compiler/rustc_codegen_llvm/src/context.rs | 19 ++++++++
 3 files changed, 36 insertions(+), 41 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/asm.rs b/compiler/rustc_codegen_llvm/src/asm.rs
index cc09fa5b69bac..93b1cf272ab7b 100644
--- a/compiler/rustc_codegen_llvm/src/asm.rs
+++ b/compiler/rustc_codegen_llvm/src/asm.rs
@@ -538,9 +538,7 @@ pub(crate) fn inline_asm_call<'ll>(
             bx.const_u64(u64::from(span.lo().to_u32()) | (u64::from(span.hi().to_u32()) << 32)),
         )
     }));
-    let md = unsafe { llvm::LLVMMDNodeInContext2(bx.llcx, srcloc.as_ptr(), srcloc.len()) };
-    let md = bx.get_metadata_value(md);
-    llvm::LLVMSetMetadata(call, kind, md);
+    bx.cx.set_metadata_node(call, kind, &srcloc);
 
     Some(call)
 }
diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
index 5271d0b4bb8a7..e7cb18ab22daf 100644
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -1,12 +1,12 @@
 use std::borrow::{Borrow, Cow};
+use std::iter;
 use std::ops::Deref;
-use std::{iter, ptr};
 
 use rustc_ast::expand::typetree::FncTree;
 pub(crate) mod autodiff;
 pub(crate) mod gpu_offload;
 
-use libc::{c_char, c_uint, size_t};
+use libc::{c_char, c_uint};
 use rustc_abi as abi;
 use rustc_abi::{Align, Size, WrappingRange};
 use rustc_codegen_ssa::MemFlags;
@@ -396,10 +396,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
             md.push(weight(is_cold));
         }
 
-        unsafe {
-            let md_node = llvm::LLVMMDNodeInContext2(self.cx.llcx, md.as_ptr(), md.len() as size_t);
-            self.cx.set_metadata(switch, llvm::MD_prof, md_node);
-        }
+        self.cx.set_metadata_node(switch, llvm::MD_prof, &md);
     }
 
     fn invoke(
@@ -801,22 +798,16 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
             return;
         }
 
-        unsafe {
-            let llty = self.cx.val_ty(load);
-            let md = [
-                llvm::LLVMValueAsMetadata(self.cx.const_uint_big(llty, range.start)),
-                llvm::LLVMValueAsMetadata(self.cx.const_uint_big(llty, range.end.wrapping_add(1))),
-            ];
-            let md = llvm::LLVMMDNodeInContext2(self.cx.llcx, md.as_ptr(), md.len());
-            self.set_metadata(load, llvm::MD_range, md);
-        }
+        let llty = self.cx.val_ty(load);
+        let md = [
+            llvm::LLVMValueAsMetadata(self.cx.const_uint_big(llty, range.start)),
+            llvm::LLVMValueAsMetadata(self.cx.const_uint_big(llty, range.end.wrapping_add(1))),
+        ];
+        self.set_metadata_node(load, llvm::MD_range, &md);
     }
 
     fn nonnull_metadata(&mut self, load: &'ll Value) {
-        unsafe {
-            let md = llvm::LLVMMDNodeInContext2(self.cx.llcx, ptr::null(), 0);
-            self.set_metadata(load, llvm::MD_nonnull, md);
-        }
+        self.set_metadata_node(load, llvm::MD_nonnull, &[]);
     }
 
     fn store(&mut self, val: &'ll Value, ptr: &'ll Value, align: Align) -> &'ll Value {
@@ -865,8 +856,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
                     //
                     // [1]: https://llvm.org/docs/LangRef.html#store-instruction
                     let one = llvm::LLVMValueAsMetadata(self.cx.const_i32(1));
-                    let md = llvm::LLVMMDNodeInContext2(self.cx.llcx, &one, 1);
-                    self.set_metadata(store, llvm::MD_nontemporal, md);
+                    self.set_metadata_node(store, llvm::MD_nontemporal, &[one]);
                 }
             }
             store
@@ -1381,10 +1371,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
     }
 
     fn set_invariant_load(&mut self, load: &'ll Value) {
-        unsafe {
-            let md = llvm::LLVMMDNodeInContext2(self.cx.llcx, ptr::null(), 0);
-            self.set_metadata(load, llvm::MD_invariant_load, md);
-        }
+        self.set_metadata_node(load, llvm::MD_invariant_load, &[]);
     }
 
     fn lifetime_start(&mut self, ptr: &'ll Value, size: Size) {
@@ -1528,25 +1515,16 @@ impl<'a, 'll, CX: Borrow<SCx<'ll>>> GenericBuilder<'a, 'll, CX> {
 }
 impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
     fn align_metadata(&mut self, load: &'ll Value, align: Align) {
-        unsafe {
-            let md = [llvm::LLVMValueAsMetadata(self.cx.const_u64(align.bytes()))];
-            let md = llvm::LLVMMDNodeInContext2(self.cx.llcx, md.as_ptr(), md.len());
-            self.set_metadata(load, llvm::MD_align, md);
-        }
+        let md = [llvm::LLVMValueAsMetadata(self.cx.const_u64(align.bytes()))];
+        self.set_metadata_node(load, llvm::MD_align, &md);
     }
 
     fn noundef_metadata(&mut self, load: &'ll Value) {
-        unsafe {
-            let md = llvm::LLVMMDNodeInContext2(self.cx.llcx, ptr::null(), 0);
-            self.set_metadata(load, llvm::MD_noundef, md);
-        }
+        self.set_metadata_node(load, llvm::MD_noundef, &[]);
     }
 
     pub(crate) fn set_unpredictable(&mut self, inst: &'ll Value) {
-        unsafe {
-            let md = llvm::LLVMMDNodeInContext2(self.cx.llcx, ptr::null(), 0);
-            self.set_metadata(inst, llvm::MD_unpredictable, md);
-        }
+        self.set_metadata_node(inst, llvm::MD_unpredictable, &[]);
     }
 }
 impl<'a, 'll, CX: Borrow<SCx<'ll>>> GenericBuilder<'a, 'll, CX> {
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index b1da6f7c74061..03d9daeea3603 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -1002,6 +1002,11 @@ impl CodegenCx<'_, '_> {
 }
 
 impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX> {
+    /// Wrapper for `LLVMMDNodeInContext2`, i.e. `llvm::MDNode::get`.
+    pub(crate) fn md_node_in_context(&self, md_list: &[&'ll Metadata]) -> &'ll Metadata {
+        unsafe { llvm::LLVMMDNodeInContext2(self.llcx(), md_list.as_ptr(), md_list.len()) }
+    }
+
     /// A wrapper for [`llvm::LLVMSetMetadata`], but it takes `Metadata` as a parameter instead of `Value`.
     pub(crate) fn set_metadata<'a>(
         &self,
@@ -1012,6 +1017,20 @@ impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX> {
         let node = self.get_metadata_value(md);
         llvm::LLVMSetMetadata(val, kind_id, node);
     }
+
+    /// Helper method for the sequence of calls:
+    /// - `LLVMMDNodeInContext2` (to create an `llvm::MDNode` from a list of metadata)
+    /// - `LLVMMetadataAsValue` (to adapt that node to an `llvm::Value`)
+    /// - `LLVMSetMetadata` (to set that node as metadata of `kind_id` for `instruction`)
+    pub(crate) fn set_metadata_node(
+        &self,
+        instruction: &'ll Value,
+        kind_id: MetadataKindId,
+        md_list: &[&'ll Metadata],
+    ) {
+        let md = self.md_node_in_context(md_list);
+        self.set_metadata(instruction, kind_id, md);
+    }
 }
 
 impl HasDataLayout for CodegenCx<'_, '_> {

From ffeed2b94ed432c959e3d9cf9bd5f7016f9577d3 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Thu, 2 Oct 2025 16:39:58 +1000
Subject: [PATCH 1656/1889] Extract helper method
 `module_add_named_metadata_node`

---
 compiler/rustc_codegen_llvm/src/consts.rs  | 11 +--------
 compiler/rustc_codegen_llvm/src/context.rs | 26 ++++++++++++++--------
 2 files changed, 18 insertions(+), 19 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/consts.rs b/compiler/rustc_codegen_llvm/src/consts.rs
index 40375ef651092..b4ca85a26c8b8 100644
--- a/compiler/rustc_codegen_llvm/src/consts.rs
+++ b/compiler/rustc_codegen_llvm/src/consts.rs
@@ -494,16 +494,7 @@ impl<'ll> CodegenCx<'ll, '_> {
                 let bytes = alloc.inspect_with_uninit_and_ptr_outside_interpreter(0..alloc.len());
                 let alloc = self.create_metadata(bytes);
                 let data = [section, alloc];
-                let meta =
-                    unsafe { llvm::LLVMMDNodeInContext2(self.llcx, data.as_ptr(), data.len()) };
-                let val = self.get_metadata_value(meta);
-                unsafe {
-                    llvm::LLVMAddNamedMetadataOperand(
-                        self.llmod,
-                        c"wasm.custom_sections".as_ptr(),
-                        val,
-                    )
-                };
+                self.module_add_named_metadata_node(self.llmod(), c"wasm.custom_sections", &data);
             }
         } else {
             base::set_link_section(g, attrs);
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index 03d9daeea3603..f1f3d6a8b62c0 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -34,7 +34,7 @@ use smallvec::SmallVec;
 use crate::back::write::to_llvm_code_model;
 use crate::callee::get_fn;
 use crate::debuginfo::metadata::apply_vcall_visibility_metadata;
-use crate::llvm::{Metadata, MetadataKindId};
+use crate::llvm::{Metadata, MetadataKindId, Module};
 use crate::type_::Type;
 use crate::value::Value;
 use crate::{attributes, common, coverageinfo, debuginfo, llvm, llvm_util};
@@ -495,14 +495,7 @@ pub(crate) unsafe fn create_module<'ll>(
         format!("rustc version {}", option_env!("CFG_VERSION").expect("CFG_VERSION"));
 
     let name_metadata = cx.create_metadata(rustc_producer.as_bytes());
-
-    unsafe {
-        llvm::LLVMAddNamedMetadataOperand(
-            llmod,
-            c"llvm.ident".as_ptr(),
-            &cx.get_metadata_value(llvm::LLVMMDNodeInContext2(llcx, &name_metadata, 1)),
-        );
-    }
+    cx.module_add_named_metadata_node(llmod, c"llvm.ident", &[name_metadata]);
 
     // Emit RISC-V specific target-abi metadata
     // to workaround lld as the LTO plugin not
@@ -1031,6 +1024,21 @@ impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX> {
         let md = self.md_node_in_context(md_list);
         self.set_metadata(instruction, kind_id, md);
     }
+
+    /// Helper method for the sequence of calls:
+    /// - `LLVMMDNodeInContext2` (to create an `llvm::MDNode` from a list of metadata)
+    /// - `LLVMMetadataAsValue` (to adapt that node to an `llvm::Value`)
+    /// - `LLVMAddNamedMetadataOperand` (to set that node as metadata of `kind_name` for `module`)
+    pub(crate) fn module_add_named_metadata_node(
+        &self,
+        module: &'ll Module,
+        kind_name: &CStr,
+        md_list: &[&'ll Metadata],
+    ) {
+        let md = self.md_node_in_context(md_list);
+        let md_as_val = self.get_metadata_value(md);
+        unsafe { llvm::LLVMAddNamedMetadataOperand(module, kind_name.as_ptr(), md_as_val) };
+    }
 }
 
 impl HasDataLayout for CodegenCx<'_, '_> {

From 6a58f80a3c4cf53f8092e75c07cebd5e913cccf0 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Thu, 2 Oct 2025 17:19:30 +1000
Subject: [PATCH 1657/1889] Extract helper method `global_add_metadata_node`

---
 compiler/rustc_codegen_llvm/src/context.rs    | 13 ++++++++++
 .../src/debuginfo/metadata.rs                 |  9 +++----
 compiler/rustc_codegen_llvm/src/type_.rs      | 24 ++++---------------
 3 files changed, 20 insertions(+), 26 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index f1f3d6a8b62c0..d09121016d059 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -1039,6 +1039,19 @@ impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX> {
         let md_as_val = self.get_metadata_value(md);
         unsafe { llvm::LLVMAddNamedMetadataOperand(module, kind_name.as_ptr(), md_as_val) };
     }
+
+    /// Helper method for the sequence of calls:
+    /// - `LLVMMDNodeInContext2` (to create an `llvm::MDNode` from a list of metadata)
+    /// - `LLVMRustGlobalAddMetadata` (to set that node as metadata of `kind_id` for `global`)
+    pub(crate) fn global_add_metadata_node(
+        &self,
+        global: &'ll Value,
+        kind_id: MetadataKindId,
+        md_list: &[&'ll Metadata],
+    ) {
+        let md = self.md_node_in_context(md_list);
+        unsafe { llvm::LLVMRustGlobalAddMetadata(global, kind_id, md) };
+    }
 }
 
 impl HasDataLayout for CodegenCx<'_, '_> {
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
index bc20c75941349..6b2fe27425e9e 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
@@ -1607,13 +1607,10 @@ pub(crate) fn apply_vcall_visibility_metadata<'ll, 'tcx>(
     let trait_ref_typeid = typeid_for_trait_ref(cx.tcx, trait_ref);
     let typeid = cx.create_metadata(trait_ref_typeid.as_bytes());
 
+    let type_ = [llvm::LLVMValueAsMetadata(cx.const_usize(0)), typeid];
+    cx.global_add_metadata_node(vtable, llvm::MD_type, &type_);
+
     unsafe {
-        let v = [llvm::LLVMValueAsMetadata(cx.const_usize(0)), typeid];
-        llvm::LLVMRustGlobalAddMetadata(
-            vtable,
-            llvm::MD_type,
-            llvm::LLVMMDNodeInContext2(cx.llcx, v.as_ptr(), v.len()),
-        );
         let vcall_visibility = llvm::LLVMValueAsMetadata(cx.const_u64(vcall_visibility as u64));
         let vcall_visibility_metadata = llvm::LLVMMDNodeInContext2(cx.llcx, &vcall_visibility, 1);
         llvm::LLVMGlobalSetMetadata(vtable, llvm::MD_vcall_visibility, vcall_visibility_metadata);
diff --git a/compiler/rustc_codegen_llvm/src/type_.rs b/compiler/rustc_codegen_llvm/src/type_.rs
index 5b97898a4b888..9f8b7d2efdb54 100644
--- a/compiler/rustc_codegen_llvm/src/type_.rs
+++ b/compiler/rustc_codegen_llvm/src/type_.rs
@@ -302,14 +302,8 @@ impl<'ll, 'tcx> LayoutTypeCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
 impl<'ll, 'tcx> TypeMembershipCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
     fn add_type_metadata(&self, function: &'ll Value, typeid: &[u8]) {
         let typeid_metadata = self.create_metadata(typeid);
-        unsafe {
-            let v = [llvm::LLVMValueAsMetadata(self.const_usize(0)), typeid_metadata];
-            llvm::LLVMRustGlobalAddMetadata(
-                function,
-                llvm::MD_type,
-                llvm::LLVMMDNodeInContext2(self.llcx, v.as_ptr(), v.len()),
-            )
-        }
+        let v = [llvm::LLVMValueAsMetadata(self.const_usize(0)), typeid_metadata];
+        self.global_add_metadata_node(function, llvm::MD_type, &v);
     }
 
     fn set_type_metadata(&self, function: &'ll Value, typeid: &[u8]) {
@@ -329,18 +323,8 @@ impl<'ll, 'tcx> TypeMembershipCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
     }
 
     fn add_kcfi_type_metadata(&self, function: &'ll Value, kcfi_typeid: u32) {
-        let kcfi_type_metadata = self.const_u32(kcfi_typeid);
-        unsafe {
-            llvm::LLVMRustGlobalAddMetadata(
-                function,
-                llvm::MD_kcfi_type,
-                llvm::LLVMMDNodeInContext2(
-                    self.llcx,
-                    &llvm::LLVMValueAsMetadata(kcfi_type_metadata),
-                    1,
-                ),
-            )
-        }
+        let kcfi_type_metadata = [llvm::LLVMValueAsMetadata(self.const_u32(kcfi_typeid))];
+        self.global_add_metadata_node(function, llvm::MD_kcfi_type, &kcfi_type_metadata);
     }
 
     fn set_kcfi_type_metadata(&self, function: &'ll Value, kcfi_typeid: u32) {

From 8ef9821bf2e27bf7ab4f9a0e3d0975dc59d3d932 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Thu, 2 Oct 2025 17:33:28 +1000
Subject: [PATCH 1658/1889] Extract helper method `global_set_metadata_node`

---
 compiler/rustc_codegen_llvm/src/context.rs    | 13 ++++++++++
 .../src/debuginfo/metadata.rs                 |  7 ++----
 compiler/rustc_codegen_llvm/src/type_.rs      | 24 ++++---------------
 3 files changed, 19 insertions(+), 25 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index d09121016d059..922575dd63cfa 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -1052,6 +1052,19 @@ impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX> {
         let md = self.md_node_in_context(md_list);
         unsafe { llvm::LLVMRustGlobalAddMetadata(global, kind_id, md) };
     }
+
+    /// Helper method for the sequence of calls:
+    /// - `LLVMMDNodeInContext2` (to create an `llvm::MDNode` from a list of metadata)
+    /// - `LLVMGlobalSetMetadata` (to set that node as metadata of `kind_id` for `global`)
+    pub(crate) fn global_set_metadata_node(
+        &self,
+        global: &'ll Value,
+        kind_id: MetadataKindId,
+        md_list: &[&'ll Metadata],
+    ) {
+        let md = self.md_node_in_context(md_list);
+        unsafe { llvm::LLVMGlobalSetMetadata(global, kind_id, md) };
+    }
 }
 
 impl HasDataLayout for CodegenCx<'_, '_> {
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
index 6b2fe27425e9e..2f9e7cae54f2b 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
@@ -1610,11 +1610,8 @@ pub(crate) fn apply_vcall_visibility_metadata<'ll, 'tcx>(
     let type_ = [llvm::LLVMValueAsMetadata(cx.const_usize(0)), typeid];
     cx.global_add_metadata_node(vtable, llvm::MD_type, &type_);
 
-    unsafe {
-        let vcall_visibility = llvm::LLVMValueAsMetadata(cx.const_u64(vcall_visibility as u64));
-        let vcall_visibility_metadata = llvm::LLVMMDNodeInContext2(cx.llcx, &vcall_visibility, 1);
-        llvm::LLVMGlobalSetMetadata(vtable, llvm::MD_vcall_visibility, vcall_visibility_metadata);
-    }
+    let vcall_visibility = [llvm::LLVMValueAsMetadata(cx.const_u64(vcall_visibility as u64))];
+    cx.global_set_metadata_node(vtable, llvm::MD_vcall_visibility, &vcall_visibility);
 }
 
 /// Creates debug information for the given vtable, which is for the
diff --git a/compiler/rustc_codegen_llvm/src/type_.rs b/compiler/rustc_codegen_llvm/src/type_.rs
index 9f8b7d2efdb54..1e5cf8374e379 100644
--- a/compiler/rustc_codegen_llvm/src/type_.rs
+++ b/compiler/rustc_codegen_llvm/src/type_.rs
@@ -308,14 +308,8 @@ impl<'ll, 'tcx> TypeMembershipCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
 
     fn set_type_metadata(&self, function: &'ll Value, typeid: &[u8]) {
         let typeid_metadata = self.create_metadata(typeid);
-        unsafe {
-            let v = [llvm::LLVMValueAsMetadata(self.const_usize(0)), typeid_metadata];
-            llvm::LLVMGlobalSetMetadata(
-                function,
-                llvm::MD_type,
-                llvm::LLVMMDNodeInContext2(self.llcx, v.as_ptr(), v.len()),
-            )
-        }
+        let v = [llvm::LLVMValueAsMetadata(self.const_usize(0)), typeid_metadata];
+        self.global_set_metadata_node(function, llvm::MD_type, &v);
     }
 
     fn typeid_metadata(&self, typeid: &[u8]) -> Option<&'ll Metadata> {
@@ -328,17 +322,7 @@ impl<'ll, 'tcx> TypeMembershipCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
     }
 
     fn set_kcfi_type_metadata(&self, function: &'ll Value, kcfi_typeid: u32) {
-        let kcfi_type_metadata = self.const_u32(kcfi_typeid);
-        unsafe {
-            llvm::LLVMGlobalSetMetadata(
-                function,
-                llvm::MD_kcfi_type,
-                llvm::LLVMMDNodeInContext2(
-                    self.llcx,
-                    &llvm::LLVMValueAsMetadata(kcfi_type_metadata),
-                    1,
-                ),
-            )
-        }
+        let kcfi_type_metadata = [llvm::LLVMValueAsMetadata(self.const_u32(kcfi_typeid))];
+        self.global_set_metadata_node(function, llvm::MD_kcfi_type, &kcfi_type_metadata);
     }
 }

From 608c6614b170dcb5867952acc23e3eb16a79ecb7 Mon Sep 17 00:00:00 2001
From: Walnut <39544927+Walnut356@users.noreply.github.com>
Date: Tue, 30 Sep 2025 03:33:26 -0500
Subject: [PATCH 1659/1889] fix msvc enum summary

---
 src/etc/lldb_providers.py | 26 ++++++++++++++++----------
 1 file changed, 16 insertions(+), 10 deletions(-)

diff --git a/src/etc/lldb_providers.py b/src/etc/lldb_providers.py
index 65f18baa937e7..058450e3c3650 100644
--- a/src/etc/lldb_providers.py
+++ b/src/etc/lldb_providers.py
@@ -652,6 +652,21 @@ def get_type_name(self) -> str:
         return name
 
 
+def StructSummaryProvider(valobj: SBValue, _dict: LLDBOpaque) -> str:
+    output = []
+    for i in range(valobj.GetNumChildren()):
+        child: SBValue = valobj.GetChildAtIndex(i)
+        summary = child.summary
+        if summary is None:
+            summary = child.value
+            if summary is None:
+                summary = StructSummaryProvider(child, _dict)
+        summary = child.GetName() + ":" + summary
+        output.append(summary)
+
+    return "{" + ", ".join(output) + "}"
+
+
 def MSVCEnumSummaryProvider(valobj: SBValue, _dict: LLDBOpaque) -> str:
     enum_synth = MSVCEnumSyntheticProvider(valobj.GetNonSyntheticValue(), _dict)
     variant_names: SBType = valobj.target.FindFirstType(
@@ -695,16 +710,7 @@ def MSVCEnumSummaryProvider(valobj: SBValue, _dict: LLDBOpaque) -> str:
         return name + TupleSummaryProvider(enum_synth.value, _dict)
     else:
         # enum variant is a regular struct
-        var_list = (
-            str(enum_synth.value.GetNonSyntheticValue()).split("= ", 1)[1].splitlines()
-        )
-        vars = [x.strip() for x in var_list if x not in ("{", "}")]
-        if vars[0][0] == "(":
-            vars[0] = vars[0][1:]
-        if vars[-1][-1] == ")":
-            vars[-1] = vars[-1][:-1]
-
-        return f"{name}{{{', '.join(vars)}}}"
+        return name + StructSummaryProvider(enum_synth.value, _dict)
 
 
 class TupleSyntheticProvider:

From 16cfde9703f74cfc96c0c0bd51958a2627dfb5ea Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Thu, 2 Oct 2025 16:44:40 +0800
Subject: [PATCH 1660/1889] triagebot: disable auto stable-regression compiler
 backport nominations

No prejudice against re-enabling them if the nominations include a bit
more context on _why_ it's automatically nominated and _which_
regression(s) are being addressed. Or as proposed, it could also simply
become a reminder-to-nominate _comment_.
---
 triagebot.toml | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/triagebot.toml b/triagebot.toml
index a04f8d2807235..79b5c2d1b7238 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -61,10 +61,6 @@ required-issue-label = "regression-from-stable-to-beta"
 # if the above conditions matches, the PR will receive these labels
 add-labels = ["beta-nominated"]
 
-[backport.t-compiler-stable-backport]
-required-pr-labels = ["T-compiler"]
-required-issue-label = "regression-from-stable-to-stable"
-add-labels = ["stable-nominated"]
 
 # ------------------------------------------------------------------------------
 # Ping groups

From 5bf5e7116099d85a99d047cfa43db155074e594a Mon Sep 17 00:00:00 2001
From: Reuben Cruise <reuben.cruise@arm.com>
Date: Thu, 25 Sep 2025 16:11:34 +0100
Subject: [PATCH 1661/1889] Extends `rustc_force_inline` to inherent methods

- Changes parser to allow application to inherent methods.
- Adds tests to confirm extended functionality works just as the existing.
---
 .../src/attributes/inline.rs                  |  6 ++-
 ...r-{closure#0}.ForceInline.panic-abort.diff | 21 ++++++++++
 ...-{closure#0}.ForceInline.panic-unwind.diff | 21 ++++++++++
 .../mir-opt/inline/forced_closure_inherent.rs | 19 ++++++++++
 ...herent.caller.ForceInline.panic-abort.diff | 21 ++++++++++
 ...erent.caller.ForceInline.panic-unwind.diff | 21 ++++++++++
 tests/mir-opt/inline/forced_inherent.rs       | 17 +++++++++
 ...iguous.caller.ForceInline.panic-abort.diff | 21 ++++++++++
 ...guous.caller.ForceInline.panic-unwind.diff | 21 ++++++++++
 .../inline/forced_inherent_ambiguous.rs       | 25 ++++++++++++
 ..._async.caller.ForceInline.panic-abort.diff | 12 ++++++
 ...async.caller.ForceInline.panic-unwind.diff | 12 ++++++
 tests/mir-opt/inline/forced_inherent_async.rs | 18 +++++++++
 ...d_code.caller.ForceInline.panic-abort.diff | 21 ++++++++++
 ..._code.caller.ForceInline.panic-unwind.diff | 21 ++++++++++
 .../inline/forced_inherent_dead_code.rs       | 21 ++++++++++
 tests/ui/force-inlining/inherent.rs           | 21 ++++++++++
 tests/ui/force-inlining/inherent.stderr       | 13 +++++++
 tests/ui/force-inlining/invalid.rs            |  1 -
 tests/ui/force-inlining/invalid.stderr        | 38 ++++++++-----------
 20 files changed, 346 insertions(+), 25 deletions(-)
 create mode 100644 tests/mir-opt/inline/forced_closure_inherent.caller-{closure#0}.ForceInline.panic-abort.diff
 create mode 100644 tests/mir-opt/inline/forced_closure_inherent.caller-{closure#0}.ForceInline.panic-unwind.diff
 create mode 100644 tests/mir-opt/inline/forced_closure_inherent.rs
 create mode 100644 tests/mir-opt/inline/forced_inherent.caller.ForceInline.panic-abort.diff
 create mode 100644 tests/mir-opt/inline/forced_inherent.caller.ForceInline.panic-unwind.diff
 create mode 100644 tests/mir-opt/inline/forced_inherent.rs
 create mode 100644 tests/mir-opt/inline/forced_inherent_ambiguous.caller.ForceInline.panic-abort.diff
 create mode 100644 tests/mir-opt/inline/forced_inherent_ambiguous.caller.ForceInline.panic-unwind.diff
 create mode 100644 tests/mir-opt/inline/forced_inherent_ambiguous.rs
 create mode 100644 tests/mir-opt/inline/forced_inherent_async.caller.ForceInline.panic-abort.diff
 create mode 100644 tests/mir-opt/inline/forced_inherent_async.caller.ForceInline.panic-unwind.diff
 create mode 100644 tests/mir-opt/inline/forced_inherent_async.rs
 create mode 100644 tests/mir-opt/inline/forced_inherent_dead_code.caller.ForceInline.panic-abort.diff
 create mode 100644 tests/mir-opt/inline/forced_inherent_dead_code.caller.ForceInline.panic-unwind.diff
 create mode 100644 tests/mir-opt/inline/forced_inherent_dead_code.rs
 create mode 100644 tests/ui/force-inlining/inherent.rs
 create mode 100644 tests/ui/force-inlining/inherent.stderr

diff --git a/compiler/rustc_attr_parsing/src/attributes/inline.rs b/compiler/rustc_attr_parsing/src/attributes/inline.rs
index a73430c9d0096..a10ad27fcc68b 100644
--- a/compiler/rustc_attr_parsing/src/attributes/inline.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/inline.rs
@@ -72,7 +72,11 @@ impl<S: Stage> SingleAttributeParser<S> for RustcForceInlineParser {
     const PATH: &'static [Symbol] = &[sym::rustc_force_inline];
     const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Fn)]);
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
+        Allow(Target::Fn),
+        Allow(Target::Method(MethodKind::Inherent)),
+    ]);
+
     const TEMPLATE: AttributeTemplate = template!(Word, List: &["reason"], NameValueStr: "reason");
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
diff --git a/tests/mir-opt/inline/forced_closure_inherent.caller-{closure#0}.ForceInline.panic-abort.diff b/tests/mir-opt/inline/forced_closure_inherent.caller-{closure#0}.ForceInline.panic-abort.diff
new file mode 100644
index 0000000000000..8e03432c2af2d
--- /dev/null
+++ b/tests/mir-opt/inline/forced_closure_inherent.caller-{closure#0}.ForceInline.panic-abort.diff
@@ -0,0 +1,21 @@
+- // MIR for `caller::{closure#0}` before ForceInline
++ // MIR for `caller::{closure#0}` after ForceInline
+  
+  fn caller::{closure#0}(_1: &{closure@$DIR/forced_closure_inherent.rs:14:6: 14:8}) -> () {
+      let mut _0: ();
+      let _2: ();
++     scope 1 (inlined Foo::callee_forced) {
++     }
+  
+      bb0: {
+          StorageLive(_2);
+-         _2 = Foo::callee_forced() -> [return: bb1, unwind unreachable];
+-     }
+- 
+-     bb1: {
+          StorageDead(_2);
+          _0 = const ();
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/inline/forced_closure_inherent.caller-{closure#0}.ForceInline.panic-unwind.diff b/tests/mir-opt/inline/forced_closure_inherent.caller-{closure#0}.ForceInline.panic-unwind.diff
new file mode 100644
index 0000000000000..0e41fd89dacf7
--- /dev/null
+++ b/tests/mir-opt/inline/forced_closure_inherent.caller-{closure#0}.ForceInline.panic-unwind.diff
@@ -0,0 +1,21 @@
+- // MIR for `caller::{closure#0}` before ForceInline
++ // MIR for `caller::{closure#0}` after ForceInline
+  
+  fn caller::{closure#0}(_1: &{closure@$DIR/forced_closure_inherent.rs:14:6: 14:8}) -> () {
+      let mut _0: ();
+      let _2: ();
++     scope 1 (inlined Foo::callee_forced) {
++     }
+  
+      bb0: {
+          StorageLive(_2);
+-         _2 = Foo::callee_forced() -> [return: bb1, unwind continue];
+-     }
+- 
+-     bb1: {
+          StorageDead(_2);
+          _0 = const ();
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/inline/forced_closure_inherent.rs b/tests/mir-opt/inline/forced_closure_inherent.rs
new file mode 100644
index 0000000000000..949c7d6ecbf28
--- /dev/null
+++ b/tests/mir-opt/inline/forced_closure_inherent.rs
@@ -0,0 +1,19 @@
+// EMIT_MIR_FOR_EACH_PANIC_STRATEGY
+//@ compile-flags: -Copt-level=0 --crate-type=lib
+#![feature(rustc_attrs)]
+
+struct Foo {}
+
+impl Foo {
+    #[rustc_force_inline]
+    pub fn callee_forced() {}
+}
+
+// EMIT_MIR forced_closure_inherent.caller-{closure#0}.ForceInline.diff
+pub fn caller() {
+    (|| {
+        Foo::callee_forced();
+        // CHECK-LABEL: fn caller::{closure#0}(
+        // CHECK: (inlined Foo::callee_forced)
+    })();
+}
diff --git a/tests/mir-opt/inline/forced_inherent.caller.ForceInline.panic-abort.diff b/tests/mir-opt/inline/forced_inherent.caller.ForceInline.panic-abort.diff
new file mode 100644
index 0000000000000..6ea1894af9895
--- /dev/null
+++ b/tests/mir-opt/inline/forced_inherent.caller.ForceInline.panic-abort.diff
@@ -0,0 +1,21 @@
+- // MIR for `caller` before ForceInline
++ // MIR for `caller` after ForceInline
+  
+  fn caller() -> () {
+      let mut _0: ();
+      let _1: ();
++     scope 1 (inlined Foo::bar) {
++     }
+  
+      bb0: {
+          StorageLive(_1);
+-         _1 = Foo::bar() -> [return: bb1, unwind unreachable];
+-     }
+- 
+-     bb1: {
+          StorageDead(_1);
+          _0 = const ();
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/inline/forced_inherent.caller.ForceInline.panic-unwind.diff b/tests/mir-opt/inline/forced_inherent.caller.ForceInline.panic-unwind.diff
new file mode 100644
index 0000000000000..dd91c3387723f
--- /dev/null
+++ b/tests/mir-opt/inline/forced_inherent.caller.ForceInline.panic-unwind.diff
@@ -0,0 +1,21 @@
+- // MIR for `caller` before ForceInline
++ // MIR for `caller` after ForceInline
+  
+  fn caller() -> () {
+      let mut _0: ();
+      let _1: ();
++     scope 1 (inlined Foo::bar) {
++     }
+  
+      bb0: {
+          StorageLive(_1);
+-         _1 = Foo::bar() -> [return: bb1, unwind continue];
+-     }
+- 
+-     bb1: {
+          StorageDead(_1);
+          _0 = const ();
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/inline/forced_inherent.rs b/tests/mir-opt/inline/forced_inherent.rs
new file mode 100644
index 0000000000000..24bf8daa64450
--- /dev/null
+++ b/tests/mir-opt/inline/forced_inherent.rs
@@ -0,0 +1,17 @@
+// EMIT_MIR_FOR_EACH_PANIC_STRATEGY
+//@ compile-flags: -Copt-level=0 --crate-type=lib
+#![feature(rustc_attrs)]
+
+struct Foo;
+
+impl Foo {
+    #[rustc_force_inline]
+    fn bar() {}
+}
+
+// EMIT_MIR forced_inherent.caller.ForceInline.diff
+fn caller() {
+    Foo::bar();
+    // CHECK-LABEL: fn caller(
+    // CHECK: (inlined Foo::bar)
+}
diff --git a/tests/mir-opt/inline/forced_inherent_ambiguous.caller.ForceInline.panic-abort.diff b/tests/mir-opt/inline/forced_inherent_ambiguous.caller.ForceInline.panic-abort.diff
new file mode 100644
index 0000000000000..6ea1894af9895
--- /dev/null
+++ b/tests/mir-opt/inline/forced_inherent_ambiguous.caller.ForceInline.panic-abort.diff
@@ -0,0 +1,21 @@
+- // MIR for `caller` before ForceInline
++ // MIR for `caller` after ForceInline
+  
+  fn caller() -> () {
+      let mut _0: ();
+      let _1: ();
++     scope 1 (inlined Foo::bar) {
++     }
+  
+      bb0: {
+          StorageLive(_1);
+-         _1 = Foo::bar() -> [return: bb1, unwind unreachable];
+-     }
+- 
+-     bb1: {
+          StorageDead(_1);
+          _0 = const ();
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/inline/forced_inherent_ambiguous.caller.ForceInline.panic-unwind.diff b/tests/mir-opt/inline/forced_inherent_ambiguous.caller.ForceInline.panic-unwind.diff
new file mode 100644
index 0000000000000..dd91c3387723f
--- /dev/null
+++ b/tests/mir-opt/inline/forced_inherent_ambiguous.caller.ForceInline.panic-unwind.diff
@@ -0,0 +1,21 @@
+- // MIR for `caller` before ForceInline
++ // MIR for `caller` after ForceInline
+  
+  fn caller() -> () {
+      let mut _0: ();
+      let _1: ();
++     scope 1 (inlined Foo::bar) {
++     }
+  
+      bb0: {
+          StorageLive(_1);
+-         _1 = Foo::bar() -> [return: bb1, unwind continue];
+-     }
+- 
+-     bb1: {
+          StorageDead(_1);
+          _0 = const ();
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/inline/forced_inherent_ambiguous.rs b/tests/mir-opt/inline/forced_inherent_ambiguous.rs
new file mode 100644
index 0000000000000..e3c5d3e4f9e81
--- /dev/null
+++ b/tests/mir-opt/inline/forced_inherent_ambiguous.rs
@@ -0,0 +1,25 @@
+// EMIT_MIR_FOR_EACH_PANIC_STRATEGY
+//@ compile-flags: -Copt-level=0 --crate-type=lib
+#![feature(rustc_attrs)]
+
+struct Foo;
+
+impl Foo {
+    #[rustc_force_inline]
+    fn bar() {}
+}
+
+trait Tr {
+    fn bar();
+}
+
+impl Tr for Foo {
+    fn bar() {}
+}
+
+// EMIT_MIR forced_inherent_ambiguous.caller.ForceInline.diff
+fn caller() {
+    Foo::bar();
+    // CHECK-LABEL: fn caller(
+    // CHECK: (inlined Foo::bar)
+}
diff --git a/tests/mir-opt/inline/forced_inherent_async.caller.ForceInline.panic-abort.diff b/tests/mir-opt/inline/forced_inherent_async.caller.ForceInline.panic-abort.diff
new file mode 100644
index 0000000000000..6495ddbafba41
--- /dev/null
+++ b/tests/mir-opt/inline/forced_inherent_async.caller.ForceInline.panic-abort.diff
@@ -0,0 +1,12 @@
+- // MIR for `caller` before ForceInline
++ // MIR for `caller` after ForceInline
+  
+  fn caller() -> {async fn body of caller()} {
+      let mut _0: {async fn body of caller()};
+  
+      bb0: {
+          _0 = {coroutine@$DIR/forced_inherent_async.rs:14:19: 18:2 (#0)};
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/inline/forced_inherent_async.caller.ForceInline.panic-unwind.diff b/tests/mir-opt/inline/forced_inherent_async.caller.ForceInline.panic-unwind.diff
new file mode 100644
index 0000000000000..6495ddbafba41
--- /dev/null
+++ b/tests/mir-opt/inline/forced_inherent_async.caller.ForceInline.panic-unwind.diff
@@ -0,0 +1,12 @@
+- // MIR for `caller` before ForceInline
++ // MIR for `caller` after ForceInline
+  
+  fn caller() -> {async fn body of caller()} {
+      let mut _0: {async fn body of caller()};
+  
+      bb0: {
+          _0 = {coroutine@$DIR/forced_inherent_async.rs:14:19: 18:2 (#0)};
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/inline/forced_inherent_async.rs b/tests/mir-opt/inline/forced_inherent_async.rs
new file mode 100644
index 0000000000000..ce58a0ac48f47
--- /dev/null
+++ b/tests/mir-opt/inline/forced_inherent_async.rs
@@ -0,0 +1,18 @@
+// EMIT_MIR_FOR_EACH_PANIC_STRATEGY
+//@ compile-flags: -Copt-level=0 --crate-type=lib
+//@ edition: 2021
+#![feature(rustc_attrs)]
+
+struct Foo {}
+
+impl Foo {
+    #[rustc_force_inline]
+    pub fn callee_forced() {}
+}
+
+// EMIT_MIR forced_inherent_async.caller.ForceInline.diff
+async fn caller() {
+    Foo::callee_forced();
+    // CHECK-LABEL: fn caller(
+    // CHECK: (inlined Foo::callee_forced)
+}
diff --git a/tests/mir-opt/inline/forced_inherent_dead_code.caller.ForceInline.panic-abort.diff b/tests/mir-opt/inline/forced_inherent_dead_code.caller.ForceInline.panic-abort.diff
new file mode 100644
index 0000000000000..edaf2820d85c3
--- /dev/null
+++ b/tests/mir-opt/inline/forced_inherent_dead_code.caller.ForceInline.panic-abort.diff
@@ -0,0 +1,21 @@
+- // MIR for `caller` before ForceInline
++ // MIR for `caller` after ForceInline
+  
+  fn caller() -> () {
+      let mut _0: ();
+      let _1: ();
++     scope 1 (inlined Foo::callee_forced) {
++     }
+  
+      bb0: {
+          StorageLive(_1);
+-         _1 = Foo::callee_forced() -> [return: bb1, unwind unreachable];
+-     }
+- 
+-     bb1: {
+          StorageDead(_1);
+          _0 = const ();
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/inline/forced_inherent_dead_code.caller.ForceInline.panic-unwind.diff b/tests/mir-opt/inline/forced_inherent_dead_code.caller.ForceInline.panic-unwind.diff
new file mode 100644
index 0000000000000..22f8b14a724b8
--- /dev/null
+++ b/tests/mir-opt/inline/forced_inherent_dead_code.caller.ForceInline.panic-unwind.diff
@@ -0,0 +1,21 @@
+- // MIR for `caller` before ForceInline
++ // MIR for `caller` after ForceInline
+  
+  fn caller() -> () {
+      let mut _0: ();
+      let _1: ();
++     scope 1 (inlined Foo::callee_forced) {
++     }
+  
+      bb0: {
+          StorageLive(_1);
+-         _1 = Foo::callee_forced() -> [return: bb1, unwind continue];
+-     }
+- 
+-     bb1: {
+          StorageDead(_1);
+          _0 = const ();
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/inline/forced_inherent_dead_code.rs b/tests/mir-opt/inline/forced_inherent_dead_code.rs
new file mode 100644
index 0000000000000..057a4cac52870
--- /dev/null
+++ b/tests/mir-opt/inline/forced_inherent_dead_code.rs
@@ -0,0 +1,21 @@
+// EMIT_MIR_FOR_EACH_PANIC_STRATEGY
+//@ compile-flags: -Copt-level=0 -Clink-dead-code
+#![feature(rustc_attrs)]
+
+struct Foo {}
+
+impl Foo {
+    #[rustc_force_inline]
+    pub fn callee_forced() {}
+}
+
+// EMIT_MIR forced_inherent_dead_code.caller.ForceInline.diff
+pub fn caller() {
+    Foo::callee_forced();
+    // CHECK-LABEL: fn caller(
+    // CHECK: (inlined Foo::callee_forced)
+}
+
+fn main() {
+    caller();
+}
diff --git a/tests/ui/force-inlining/inherent.rs b/tests/ui/force-inlining/inherent.rs
new file mode 100644
index 0000000000000..25c76eaf37a91
--- /dev/null
+++ b/tests/ui/force-inlining/inherent.rs
@@ -0,0 +1,21 @@
+//@ check-fail
+#![feature(rustc_attrs)]
+
+struct Foo;
+
+impl Foo {
+    #[rustc_force_inline]
+    //~^ ERROR: `Foo::bar` is incompatible with `#[rustc_force_inline]`
+    #[rustc_no_mir_inline]
+    fn bar() {}
+}
+
+fn bar_caller() {
+    unsafe {
+        Foo::bar();
+    }
+}
+
+fn main() {
+    bar_caller();
+}
diff --git a/tests/ui/force-inlining/inherent.stderr b/tests/ui/force-inlining/inherent.stderr
new file mode 100644
index 0000000000000..1ffc78848fea0
--- /dev/null
+++ b/tests/ui/force-inlining/inherent.stderr
@@ -0,0 +1,13 @@
+error: `Foo::bar` is incompatible with `#[rustc_force_inline]`
+  --> $DIR/inherent.rs:7:5
+   |
+LL |     #[rustc_force_inline]
+   |     ^^^^^^^^^^^^^^^^^^^^^
+...
+LL |     fn bar() {}
+   |     -------- `Foo::bar` defined here
+   |
+   = note: incompatible due to: #[rustc_no_mir_inline]
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/force-inlining/invalid.rs b/tests/ui/force-inlining/invalid.rs
index 6047739992f1a..eaacbb502090c 100644
--- a/tests/ui/force-inlining/invalid.rs
+++ b/tests/ui/force-inlining/invalid.rs
@@ -114,7 +114,6 @@ trait FooQux = FooBaz;
 //~^ ERROR attribute cannot be used on
 impl<T> Bar<T> {
     #[rustc_force_inline]
-//~^ ERROR attribute cannot be used on
     fn foo() {}
 }
 
diff --git a/tests/ui/force-inlining/invalid.stderr b/tests/ui/force-inlining/invalid.stderr
index 299a3ed4a462d..df3b646b6cec6 100644
--- a/tests/ui/force-inlining/invalid.stderr
+++ b/tests/ui/force-inlining/invalid.stderr
@@ -1,5 +1,5 @@
 error: allow, cfg, cfg_attr, deny, expect, forbid, and warn are the only allowed built-in attributes in function parameters
-  --> $DIR/invalid.rs:132:11
+  --> $DIR/invalid.rs:131:11
    |
 LL | fn barqux(#[rustc_force_inline] _x: u32) {}
    |           ^^^^^^^^^^^^^^^^^^^^^
@@ -134,7 +134,7 @@ error: `#[rustc_force_inline]` attribute cannot be used on foreign functions
 LL |     #[rustc_force_inline]
    |     ^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: `#[rustc_force_inline]` can only be applied to functions
+   = help: `#[rustc_force_inline]` can be applied to functions and inherent methods
 
 error: `#[rustc_force_inline]` attribute cannot be used on type aliases
   --> $DIR/invalid.rs:66:1
@@ -222,7 +222,7 @@ error: `#[rustc_force_inline]` attribute cannot be used on provided trait method
 LL |     #[rustc_force_inline]
    |     ^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: `#[rustc_force_inline]` can only be applied to functions
+   = help: `#[rustc_force_inline]` can be applied to functions and inherent methods
 
 error: `#[rustc_force_inline]` attribute cannot be used on trait aliases
   --> $DIR/invalid.rs:109:1
@@ -240,16 +240,8 @@ LL | #[rustc_force_inline]
    |
    = help: `#[rustc_force_inline]` can only be applied to functions
 
-error: `#[rustc_force_inline]` attribute cannot be used on inherent methods
-  --> $DIR/invalid.rs:116:5
-   |
-LL |     #[rustc_force_inline]
-   |     ^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: `#[rustc_force_inline]` can only be applied to functions
-
 error: `#[rustc_force_inline]` attribute cannot be used on trait impl blocks
-  --> $DIR/invalid.rs:121:1
+  --> $DIR/invalid.rs:120:1
    |
 LL | #[rustc_force_inline]
    | ^^^^^^^^^^^^^^^^^^^^^
@@ -257,7 +249,7 @@ LL | #[rustc_force_inline]
    = help: `#[rustc_force_inline]` can only be applied to functions
 
 error: `#[rustc_force_inline]` attribute cannot be used on macro defs
-  --> $DIR/invalid.rs:128:1
+  --> $DIR/invalid.rs:127:1
    |
 LL | #[rustc_force_inline]
    | ^^^^^^^^^^^^^^^^^^^^^
@@ -265,7 +257,7 @@ LL | #[rustc_force_inline]
    = help: `#[rustc_force_inline]` can only be applied to functions
 
 error: `#[rustc_force_inline]` attribute cannot be used on function params
-  --> $DIR/invalid.rs:132:11
+  --> $DIR/invalid.rs:131:11
    |
 LL | fn barqux(#[rustc_force_inline] _x: u32) {}
    |           ^^^^^^^^^^^^^^^^^^^^^
@@ -273,15 +265,15 @@ LL | fn barqux(#[rustc_force_inline] _x: u32) {}
    = help: `#[rustc_force_inline]` can only be applied to functions
 
 error: `#[rustc_force_inline]` attribute cannot be used on closures
-  --> $DIR/invalid.rs:149:14
+  --> $DIR/invalid.rs:148:14
    |
 LL |     let _x = #[rustc_force_inline] || { };
    |              ^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: `#[rustc_force_inline]` can only be applied to functions
+   = help: `#[rustc_force_inline]` can be applied to functions and inherent methods
 
 error: `#[rustc_force_inline]` attribute cannot be used on expressions
-  --> $DIR/invalid.rs:151:14
+  --> $DIR/invalid.rs:150:14
    |
 LL |     let _y = #[rustc_force_inline] 3 + 4;
    |              ^^^^^^^^^^^^^^^^^^^^^
@@ -289,7 +281,7 @@ LL |     let _y = #[rustc_force_inline] 3 + 4;
    = help: `#[rustc_force_inline]` can only be applied to functions
 
 error: `#[rustc_force_inline]` attribute cannot be used on statements
-  --> $DIR/invalid.rs:153:5
+  --> $DIR/invalid.rs:152:5
    |
 LL |     #[rustc_force_inline]
    |     ^^^^^^^^^^^^^^^^^^^^^
@@ -297,7 +289,7 @@ LL |     #[rustc_force_inline]
    = help: `#[rustc_force_inline]` can only be applied to functions
 
 error: `#[rustc_force_inline]` attribute cannot be used on match arms
-  --> $DIR/invalid.rs:158:9
+  --> $DIR/invalid.rs:157:9
    |
 LL |         #[rustc_force_inline]
    |         ^^^^^^^^^^^^^^^^^^^^^
@@ -305,7 +297,7 @@ LL |         #[rustc_force_inline]
    = help: `#[rustc_force_inline]` can only be applied to functions
 
 error: attribute cannot be applied to a `async`, `gen` or `async gen` function
-  --> $DIR/invalid.rs:136:1
+  --> $DIR/invalid.rs:135:1
    |
 LL | #[rustc_force_inline]
    | ^^^^^^^^^^^^^^^^^^^^^
@@ -314,7 +306,7 @@ LL | async fn async_foo() {}
    | -------------------- `async`, `gen` or `async gen` function
 
 error: attribute cannot be applied to a `async`, `gen` or `async gen` function
-  --> $DIR/invalid.rs:140:1
+  --> $DIR/invalid.rs:139:1
    |
 LL | #[rustc_force_inline]
    | ^^^^^^^^^^^^^^^^^^^^^
@@ -323,7 +315,7 @@ LL | gen fn gen_foo() {}
    | ---------------- `async`, `gen` or `async gen` function
 
 error: attribute cannot be applied to a `async`, `gen` or `async gen` function
-  --> $DIR/invalid.rs:144:1
+  --> $DIR/invalid.rs:143:1
    |
 LL | #[rustc_force_inline]
    | ^^^^^^^^^^^^^^^^^^^^^
@@ -331,7 +323,7 @@ LL |
 LL | async gen fn async_gen_foo() {}
    | ---------------------------- `async`, `gen` or `async gen` function
 
-error: aborting due to 37 previous errors
+error: aborting due to 36 previous errors
 
 Some errors have detailed explanations: E0539, E0805.
 For more information about an error, try `rustc --explain E0539`.

From 6e225424a66886fa44e671dfa94063fb3a9f4529 Mon Sep 17 00:00:00 2001
From: Scott Schafer <schaferjscott@gmail.com>
Date: Sun, 28 Sep 2025 16:45:24 -0600
Subject: [PATCH 1662/1889] test: Add empty line to tests getting new flag in
 next commit

---
 .../non-1-width-unicode-multiline-label.ascii.stderr      | 8 ++++----
 .../non-1-width-unicode-multiline-label.rs                | 1 +
 .../non-1-width-unicode-multiline-label.unicode.stderr    | 8 ++++----
 .../non-whitespace-trimming-2.ascii.stderr                | 2 +-
 tests/ui/diagnostic-width/non-whitespace-trimming-2.rs    | 1 +
 .../non-whitespace-trimming-2.unicode.stderr              | 2 +-
 .../diagnostic-width/non-whitespace-trimming-unicode.rs   | 1 +
 .../non-whitespace-trimming-unicode.stderr                | 2 +-
 tests/ui/diagnostic-width/non-whitespace-trimming.rs      | 1 +
 tests/ui/diagnostic-width/non-whitespace-trimming.stderr  | 2 +-
 10 files changed, 16 insertions(+), 12 deletions(-)

diff --git a/tests/ui/diagnostic-width/non-1-width-unicode-multiline-label.ascii.stderr b/tests/ui/diagnostic-width/non-1-width-unicode-multiline-label.ascii.stderr
index 60ce0d9a14839..fe1ecfbe71d4c 100644
--- a/tests/ui/diagnostic-width/non-1-width-unicode-multiline-label.ascii.stderr
+++ b/tests/ui/diagnostic-width/non-1-width-unicode-multiline-label.ascii.stderr
@@ -1,5 +1,5 @@
 error[E0369]: cannot add `&str` to `&str`
-  --> $DIR/non-1-width-unicode-multiline-label.rs:7:237
+  --> $DIR/non-1-width-unicode-multiline-label.rs:8:237
    |
 LL | ...👨👩👧👦👨👩👧👦👨👩👧👦👨👩👧👦👨👩👧👦"; let _a = unicode_is_fun + " really fun!";
    |                                                           -------------- ^ -------------- &str
@@ -14,7 +14,7 @@ LL |     let _ = "👨👩👧👦👨👩👧👦👨👩👧👦👨👩👧
    |                                                                                                                                                                                                                                                                                                                                                                                                                                                +++++++++++
 
 error[E0369]: cannot add `&str` to `&str`
-  --> $DIR/non-1-width-unicode-multiline-label.rs:9:384
+  --> $DIR/non-1-width-unicode-multiline-label.rs:10:384
    |
 LL | ...👧👦👨👩👧👦👨👩👧👦"; let _a = unicode_is_fun + " really fun!";
    |                                       -------------- ^ -------------- &str
@@ -29,7 +29,7 @@ LL |     let _ = "👨👩👧👦👨👩👧👦👨👩👧👦👨👩👧
    |                                                                                                                                                                                                                                                                                                                                                                                                                                                +++++++++++
 
 error[E0369]: cannot add `&str` to `&str`
-  --> $DIR/non-1-width-unicode-multiline-label.rs:11:260
+  --> $DIR/non-1-width-unicode-multiline-label.rs:12:260
    |
 LL | ...࿇࿈࿉࿊࿋࿌࿍࿎࿏࿐࿑࿒࿓࿔࿕࿖࿗࿘࿙࿚"; let _a = unicode_is_fun + " really fun!";
    |                                   -------------- ^ -------------- &str
@@ -44,7 +44,7 @@ LL |     let _ = "ༀ༁༂༃༄༅༆༇༈༉༊་༌།༎༏༐༑༒༓
    |                                                                                                                                                                                         +++++++++++
 
 error[E0369]: cannot add `&str` to `&str`
-  --> $DIR/non-1-width-unicode-multiline-label.rs:13:219
+  --> $DIR/non-1-width-unicode-multiline-label.rs:14:219
    |
 LL | ...xxxxxxxxxxxxxxxxxxxx"; let _a = unicode_is_fun + " really fun!";
    |                                    -------------- ^ -------------- &str
diff --git a/tests/ui/diagnostic-width/non-1-width-unicode-multiline-label.rs b/tests/ui/diagnostic-width/non-1-width-unicode-multiline-label.rs
index 6b9b27f6297fc..0940b987fea11 100644
--- a/tests/ui/diagnostic-width/non-1-width-unicode-multiline-label.rs
+++ b/tests/ui/diagnostic-width/non-1-width-unicode-multiline-label.rs
@@ -1,4 +1,5 @@
 //@ revisions: ascii unicode
+
 //@[unicode] compile-flags: -Zunstable-options --error-format=human-unicode
 // ignore-tidy-linelength
 
diff --git a/tests/ui/diagnostic-width/non-1-width-unicode-multiline-label.unicode.stderr b/tests/ui/diagnostic-width/non-1-width-unicode-multiline-label.unicode.stderr
index 15b5dd9d7e2d7..4dff15642aeb4 100644
--- a/tests/ui/diagnostic-width/non-1-width-unicode-multiline-label.unicode.stderr
+++ b/tests/ui/diagnostic-width/non-1-width-unicode-multiline-label.unicode.stderr
@@ -1,5 +1,5 @@
 error[E0369]: cannot add `&str` to `&str`
-   ╭▸ $DIR/non-1-width-unicode-multiline-label.rs:7:237
+   ╭▸ $DIR/non-1-width-unicode-multiline-label.rs:8:237
    │
 LL │ …👧👦👨👩👧👦👨👩👧👦👨👩👧👦👨👩👧👦👨👩👧👦"; let _a = unicode_is_fun + " really fun!";
    │                                                           ┬───────────── ┯ ────────────── &str
@@ -14,7 +14,7 @@ LL │     let _ = "👨👩👧👦👨👩👧👦👨👩👧👦👨👩👧
    ╰╴                                                                                                                                                                                                                                                                                                                                                                                                                                               +++++++++++
 
 error[E0369]: cannot add `&str` to `&str`
-   ╭▸ $DIR/non-1-width-unicode-multiline-label.rs:9:384
+   ╭▸ $DIR/non-1-width-unicode-multiline-label.rs:10:384
    │
 LL │ …👨👩👧👦👨👩👧👦👨👩👧👦"; let _a = unicode_is_fun + " really fun!";
    │                                       ┬───────────── ┯ ────────────── &str
@@ -29,7 +29,7 @@ LL │     let _ = "👨👩👧👦👨👩👧👦👨👩👧👦👨👩👧
    ╰╴                                                                                                                                                                                                                                                                                                                                                                                                                                               +++++++++++
 
 error[E0369]: cannot add `&str` to `&str`
-   ╭▸ $DIR/non-1-width-unicode-multiline-label.rs:11:260
+   ╭▸ $DIR/non-1-width-unicode-multiline-label.rs:12:260
    │
 LL │ …࿅࿆࿇࿈࿉࿊࿋࿌࿍࿎࿏࿐࿑࿒࿓࿔࿕࿖࿗࿘࿙࿚"; let _a = unicode_is_fun + " really fun!";
    │                                   ┬───────────── ┯ ────────────── &str
@@ -44,7 +44,7 @@ LL │     let _ = "ༀ༁༂༃༄༅༆༇༈༉༊་༌།༎༏༐༑༒༓
    ╰╴                                                                                                                                                                                        +++++++++++
 
 error[E0369]: cannot add `&str` to `&str`
-   ╭▸ $DIR/non-1-width-unicode-multiline-label.rs:13:219
+   ╭▸ $DIR/non-1-width-unicode-multiline-label.rs:14:219
    │
 LL │ …xxxxxxxxxxxxxxxxxxxxxx"; let _a = unicode_is_fun + " really fun!";
    │                                    ┬───────────── ┯ ────────────── &str
diff --git a/tests/ui/diagnostic-width/non-whitespace-trimming-2.ascii.stderr b/tests/ui/diagnostic-width/non-whitespace-trimming-2.ascii.stderr
index 70bd149545cfe..fe90cfc7b4168 100644
--- a/tests/ui/diagnostic-width/non-whitespace-trimming-2.ascii.stderr
+++ b/tests/ui/diagnostic-width/non-whitespace-trimming-2.ascii.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/non-whitespace-trimming-2.rs:6:311
+  --> $DIR/non-whitespace-trimming-2.rs:7:311
    |
 LL | ...13; let _: usize = 14; let _: usize = 15; let _: () = 42; let _: usize = 0; let _: usize = 1; let _: usize = 2; let _: usize = 3; let ...
    |                                                     --   ^^ expected `()`, found integer
diff --git a/tests/ui/diagnostic-width/non-whitespace-trimming-2.rs b/tests/ui/diagnostic-width/non-whitespace-trimming-2.rs
index de2f42a4a7292..cdbef418f888b 100644
--- a/tests/ui/diagnostic-width/non-whitespace-trimming-2.rs
+++ b/tests/ui/diagnostic-width/non-whitespace-trimming-2.rs
@@ -1,4 +1,5 @@
 //@ revisions: ascii unicode
+
 //@[unicode] compile-flags: -Zunstable-options --error-format=human-unicode
 // ignore-tidy-linelength
 
diff --git a/tests/ui/diagnostic-width/non-whitespace-trimming-2.unicode.stderr b/tests/ui/diagnostic-width/non-whitespace-trimming-2.unicode.stderr
index 600d196de1673..b0151272cd120 100644
--- a/tests/ui/diagnostic-width/non-whitespace-trimming-2.unicode.stderr
+++ b/tests/ui/diagnostic-width/non-whitespace-trimming-2.unicode.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-   ╭▸ $DIR/non-whitespace-trimming-2.rs:6:311
+   ╭▸ $DIR/non-whitespace-trimming-2.rs:7:311
    │
 LL │ …= 13; let _: usize = 14; let _: usize = 15; let _: () = 42; let _: usize = 0; let _: usize = 1; let _: usize = 2; let _: usize = 3; let _:…
    │                                                     ┬─   ━━ expected `()`, found integer
diff --git a/tests/ui/diagnostic-width/non-whitespace-trimming-unicode.rs b/tests/ui/diagnostic-width/non-whitespace-trimming-unicode.rs
index 8d4d1b1627940..f5d1926e1eb62 100644
--- a/tests/ui/diagnostic-width/non-whitespace-trimming-unicode.rs
+++ b/tests/ui/diagnostic-width/non-whitespace-trimming-unicode.rs
@@ -1,3 +1,4 @@
+
 // ignore-tidy-linelength
 
 fn main() {
diff --git a/tests/ui/diagnostic-width/non-whitespace-trimming-unicode.stderr b/tests/ui/diagnostic-width/non-whitespace-trimming-unicode.stderr
index 18d80810ab0c3..e74afbfeac478 100644
--- a/tests/ui/diagnostic-width/non-whitespace-trimming-unicode.stderr
+++ b/tests/ui/diagnostic-width/non-whitespace-trimming-unicode.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/non-whitespace-trimming-unicode.rs:4:415
+  --> $DIR/non-whitespace-trimming-unicode.rs:5:415
    |
 LL | ...♣♤♥♦♧♨♩♪♫♬♭♮♯♰♱♲♳♴♵♶♷♸♹♺♻♼♽♾♿⚀⚁⚂⚃⚄⚅⚆⚈⚉4"; let _: () = 42;  let _: &str = "🦀☀☁☂☃☄★☆☇☈☉☊☋☌☍☎☏☐☑☒☓  ☖☗☘☙☚☛☜☝☞☟☠☡☢☣☤☥☦☧☨☩☪☫☬☭☮☯☰☱☲☳☴☵☶☷☸☹☺☻☼☽       ...
    |                                                      --   ^^ expected `()`, found integer
diff --git a/tests/ui/diagnostic-width/non-whitespace-trimming.rs b/tests/ui/diagnostic-width/non-whitespace-trimming.rs
index f6c8d345c652e..67066157a60a2 100644
--- a/tests/ui/diagnostic-width/non-whitespace-trimming.rs
+++ b/tests/ui/diagnostic-width/non-whitespace-trimming.rs
@@ -1,3 +1,4 @@
+
 // ignore-tidy-linelength
 
 fn main() {
diff --git a/tests/ui/diagnostic-width/non-whitespace-trimming.stderr b/tests/ui/diagnostic-width/non-whitespace-trimming.stderr
index 872c5ae3b7642..3403dc0e6f1fa 100644
--- a/tests/ui/diagnostic-width/non-whitespace-trimming.stderr
+++ b/tests/ui/diagnostic-width/non-whitespace-trimming.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/non-whitespace-trimming.rs:4:241
+  --> $DIR/non-whitespace-trimming.rs:5:241
    |
 LL | ... () = (); let _: () = (); let _: () = (); let _: () = 42; let _: () = (); let _: () = (); let _: () = (); let _: () = (); let _: () = ...
    |                                                     --   ^^ expected `()`, found integer

From 0a5817aa2eb82f03fb8246eedaec089a81291aba Mon Sep 17 00:00:00 2001
From: Scott Schafer <schaferjscott@gmail.com>
Date: Tue, 29 Jul 2025 18:56:32 -0600
Subject: [PATCH 1663/1889] test: Set diagnostic-width flag for long diagnostic
 width tests

---
 .../ui/diagnostic-width/non-1-width-unicode-multiline-label.rs  | 2 +-
 tests/ui/diagnostic-width/non-whitespace-trimming-2.rs          | 2 +-
 tests/ui/diagnostic-width/non-whitespace-trimming-unicode.rs    | 2 +-
 tests/ui/diagnostic-width/non-whitespace-trimming.rs            | 2 +-
 tests/ui/diagnostic-width/tabs-trimming.rs                      | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/tests/ui/diagnostic-width/non-1-width-unicode-multiline-label.rs b/tests/ui/diagnostic-width/non-1-width-unicode-multiline-label.rs
index 0940b987fea11..7fb95a4ac1e21 100644
--- a/tests/ui/diagnostic-width/non-1-width-unicode-multiline-label.rs
+++ b/tests/ui/diagnostic-width/non-1-width-unicode-multiline-label.rs
@@ -1,5 +1,5 @@
 //@ revisions: ascii unicode
-
+//@ compile-flags: --diagnostic-width=145
 //@[unicode] compile-flags: -Zunstable-options --error-format=human-unicode
 // ignore-tidy-linelength
 
diff --git a/tests/ui/diagnostic-width/non-whitespace-trimming-2.rs b/tests/ui/diagnostic-width/non-whitespace-trimming-2.rs
index cdbef418f888b..6e80649fee86e 100644
--- a/tests/ui/diagnostic-width/non-whitespace-trimming-2.rs
+++ b/tests/ui/diagnostic-width/non-whitespace-trimming-2.rs
@@ -1,5 +1,5 @@
 //@ revisions: ascii unicode
-
+//@ compile-flags: --diagnostic-width=145
 //@[unicode] compile-flags: -Zunstable-options --error-format=human-unicode
 // ignore-tidy-linelength
 
diff --git a/tests/ui/diagnostic-width/non-whitespace-trimming-unicode.rs b/tests/ui/diagnostic-width/non-whitespace-trimming-unicode.rs
index f5d1926e1eb62..258eb090aae36 100644
--- a/tests/ui/diagnostic-width/non-whitespace-trimming-unicode.rs
+++ b/tests/ui/diagnostic-width/non-whitespace-trimming-unicode.rs
@@ -1,4 +1,4 @@
-
+//@ compile-flags: --diagnostic-width=145
 // ignore-tidy-linelength
 
 fn main() {
diff --git a/tests/ui/diagnostic-width/non-whitespace-trimming.rs b/tests/ui/diagnostic-width/non-whitespace-trimming.rs
index 67066157a60a2..cb9450f0de0bd 100644
--- a/tests/ui/diagnostic-width/non-whitespace-trimming.rs
+++ b/tests/ui/diagnostic-width/non-whitespace-trimming.rs
@@ -1,4 +1,4 @@
-
+//@ compile-flags: --diagnostic-width=145
 // ignore-tidy-linelength
 
 fn main() {
diff --git a/tests/ui/diagnostic-width/tabs-trimming.rs b/tests/ui/diagnostic-width/tabs-trimming.rs
index 96babde33e9a4..5cf6bc89a1675 100644
--- a/tests/ui/diagnostic-width/tabs-trimming.rs
+++ b/tests/ui/diagnostic-width/tabs-trimming.rs
@@ -1,5 +1,5 @@
 // Test for #78438: ensure underline alignment with many tabs on the left, long line on the right
-
+//@ compile-flags: --diagnostic-width=145
 // ignore-tidy-linelength
 // ignore-tidy-tab
 

From 9c6897bd07ddb519d0c2f809bb1f83044a170b92 Mon Sep 17 00:00:00 2001
From: Scott Schafer <schaferjscott@gmail.com>
Date: Fri, 30 May 2025 16:22:56 -0600
Subject: [PATCH 1664/1889] test: Subtract code_offset from width for
 ui_testing

---
 compiler/rustc_errors/src/emitter.rs          |  2 +-
 .../clippy/tests/ui/option_env_unwrap.stderr  |  2 +-
 .../ui/too_long_first_doc_paragraph.stderr    |  2 +-
 .../libc_pthread_join_joined.stderr           |  4 +-
 .../concurrency/libc_pthread_join_main.stderr |  4 +-
 .../fail/data_race/dealloc_read_race1.stderr  | 14 +++----
 .../data_race/dealloc_read_race_stack.stderr  |  4 +-
 .../fail/data_race/dealloc_write_race1.stderr | 14 +++----
 .../data_race/dealloc_write_race_stack.stderr |  4 +-
 .../fail/intrinsics/copy_unaligned.stderr     |  4 +-
 .../fail/intrinsics/simd-float-to-int.stderr  |  4 +-
 .../retag_data_race_read.stderr               |  4 +-
 .../ui/async-await/async-drop/ex-ice1.stderr  |  8 ++--
 .../ui/cast/func-pointer-issue-140491.stderr  |  4 +-
 tests/ui/consts/offset_ub.stderr              |  4 +-
 tests/ui/deprecation/deprecation-lint.stderr  | 24 +++++------
 .../ui/lint/lint-stability-deprecated.stderr  | 40 +++++++++----------
 tests/ui/parser/raw/too-many-hash.stderr      |  4 +-
 .../empty-match.exhaustive_patterns.stderr    |  4 +-
 .../usefulness/empty-match.normal.stderr      |  4 +-
 tests/ui/simd/not-out-of-bounds.stderr        |  4 +-
 .../alignment/align-fail.stderr               |  4 +-
 22 files changed, 81 insertions(+), 81 deletions(-)

diff --git a/compiler/rustc_errors/src/emitter.rs b/compiler/rustc_errors/src/emitter.rs
index 93b1e6b761520..cc3db167316e0 100644
--- a/compiler/rustc_errors/src/emitter.rs
+++ b/compiler/rustc_errors/src/emitter.rs
@@ -2021,7 +2021,7 @@ impl HumanEmitter {
         if let Some(width) = self.diagnostic_width {
             width.saturating_sub(code_offset)
         } else if self.ui_testing || cfg!(miri) {
-            DEFAULT_COLUMN_WIDTH
+            DEFAULT_COLUMN_WIDTH.saturating_sub(code_offset)
         } else {
             termize::dimensions()
                 .map(|(w, _)| w.saturating_sub(code_offset))
diff --git a/src/tools/clippy/tests/ui/option_env_unwrap.stderr b/src/tools/clippy/tests/ui/option_env_unwrap.stderr
index bbcbfedb78822..c14a3ea23ff3e 100644
--- a/src/tools/clippy/tests/ui/option_env_unwrap.stderr
+++ b/src/tools/clippy/tests/ui/option_env_unwrap.stderr
@@ -19,7 +19,7 @@ LL |     let _ = option_env!("PATH").expect("environment variable PATH isn't set
 error: this will panic at run-time if the environment variable doesn't exist at compile-time
   --> tests/ui/option_env_unwrap.rs:14:13
    |
-LL |     let _ = option_env!("__Y__do_not_use").unwrap(); // This test only works if you don't have a __Y__do_not_use env variable in your env...
+LL |     let _ = option_env!("__Y__do_not_use").unwrap(); // This test only works if you don't have a __Y__do_not_use env variable in you...
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider using the `env!` macro instead
diff --git a/src/tools/clippy/tests/ui/too_long_first_doc_paragraph.stderr b/src/tools/clippy/tests/ui/too_long_first_doc_paragraph.stderr
index f3f182aa54222..949ada30dc97d 100644
--- a/src/tools/clippy/tests/ui/too_long_first_doc_paragraph.stderr
+++ b/src/tools/clippy/tests/ui/too_long_first_doc_paragraph.stderr
@@ -42,7 +42,7 @@ LL | | /// gravida non lacinia at, rhoncus eu lacus.
 error: first doc comment paragraph is too long
   --> tests/ui/too_long_first_doc_paragraph.rs:65:1
    |
-LL | / /// Some function. This doc-string paragraph is too long. Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lore...
+LL | / /// Some function. This doc-string paragraph is too long. Lorem Ipsum is simply dummy text of the printing and typesetting industr...
 LL | |
 LL | | ///
 LL | | /// Here's a second paragraph. It would be preferable to put the details here.
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_join_joined.stderr b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_join_joined.stderr
index 354ad5dfc6022..e22f4dadf3f64 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_join_joined.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_join_joined.stderr
@@ -1,8 +1,8 @@
 error: Undefined Behavior: trying to join an already joined thread
   --> tests/fail-dep/concurrency/libc_pthread_join_joined.rs:LL:CC
    |
-LL |         assert_eq!(libc::pthread_join(native, ptr::null_mut()), 0);
-   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
+LL | ...   assert_eq!(libc::pthread_join(native, ptr::null_mut()), 0);
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
    |
    = 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
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_join_main.stderr b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_join_main.stderr
index 41190f3f903eb..978a9bdac94d5 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_join_main.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_join_main.stderr
@@ -1,8 +1,8 @@
 error: Undefined Behavior: trying to join a detached thread
   --> tests/fail-dep/concurrency/libc_pthread_join_main.rs:LL:CC
    |
-LL |             assert_eq!(libc::pthread_join(thread_id, ptr::null_mut()), 0);
-   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
+LL | ...   assert_eq!(libc::pthread_join(thread_id, ptr::null_mut()), 0);
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
    |
    = 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
diff --git a/src/tools/miri/tests/fail/data_race/dealloc_read_race1.stderr b/src/tools/miri/tests/fail/data_race/dealloc_read_race1.stderr
index 55e4c4a0d9e83..006946f3f5080 100644
--- a/src/tools/miri/tests/fail/data_race/dealloc_read_race1.stderr
+++ b/src/tools/miri/tests/fail/data_race/dealloc_read_race1.stderr
@@ -1,13 +1,13 @@
 error: Undefined Behavior: Data race detected between (1) non-atomic read on thread `unnamed-ID` and (2) deallocation on thread `unnamed-ID` at ALLOC
   --> tests/fail/data_race/dealloc_read_race1.rs:LL:CC
    |
-LL | /             __rust_dealloc(
-LL | |
-LL | |                 ptr.0 as *mut _,
-LL | |                 std::mem::size_of::<usize>(),
-LL | |                 std::mem::align_of::<usize>(),
-LL | |             );
-   | |_____________^ (2) just happened here
+LL | / ...   __rust_dealloc(
+LL | | ...
+LL | | ...       ptr.0 as *mut _,
+LL | | ...       std::mem::size_of::<usize>(),
+LL | | ...       std::mem::align_of::<usize>(),
+LL | | ...   );
+   | |_______^ (2) just happened here
    |
 help: and (1) occurred earlier here
   --> tests/fail/data_race/dealloc_read_race1.rs:LL:CC
diff --git a/src/tools/miri/tests/fail/data_race/dealloc_read_race_stack.stderr b/src/tools/miri/tests/fail/data_race/dealloc_read_race_stack.stderr
index ea8fd73393c4e..f80e36d4b8fbf 100644
--- a/src/tools/miri/tests/fail/data_race/dealloc_read_race_stack.stderr
+++ b/src/tools/miri/tests/fail/data_race/dealloc_read_race_stack.stderr
@@ -1,8 +1,8 @@
 error: Undefined Behavior: Data race detected between (1) non-atomic read on thread `unnamed-ID` and (2) deallocation on thread `unnamed-ID` at ALLOC
   --> tests/fail/data_race/dealloc_read_race_stack.rs:LL:CC
    |
-LL |             }
-   |             ^ (2) just happened here
+LL | ...   }
+   |       ^ (2) just happened here
    |
 help: and (1) occurred earlier here
   --> tests/fail/data_race/dealloc_read_race_stack.rs:LL:CC
diff --git a/src/tools/miri/tests/fail/data_race/dealloc_write_race1.stderr b/src/tools/miri/tests/fail/data_race/dealloc_write_race1.stderr
index b306f18123127..41482e4941c1b 100644
--- a/src/tools/miri/tests/fail/data_race/dealloc_write_race1.stderr
+++ b/src/tools/miri/tests/fail/data_race/dealloc_write_race1.stderr
@@ -1,13 +1,13 @@
 error: Undefined Behavior: Data race detected between (1) non-atomic write on thread `unnamed-ID` and (2) deallocation on thread `unnamed-ID` at ALLOC
   --> tests/fail/data_race/dealloc_write_race1.rs:LL:CC
    |
-LL | /             __rust_dealloc(
-LL | |
-LL | |                 ptr.0 as *mut _,
-LL | |                 std::mem::size_of::<usize>(),
-LL | |                 std::mem::align_of::<usize>(),
-LL | |             );
-   | |_____________^ (2) just happened here
+LL | / ...   __rust_dealloc(
+LL | | ...
+LL | | ...       ptr.0 as *mut _,
+LL | | ...       std::mem::size_of::<usize>(),
+LL | | ...       std::mem::align_of::<usize>(),
+LL | | ...   );
+   | |_______^ (2) just happened here
    |
 help: and (1) occurred earlier here
   --> tests/fail/data_race/dealloc_write_race1.rs:LL:CC
diff --git a/src/tools/miri/tests/fail/data_race/dealloc_write_race_stack.stderr b/src/tools/miri/tests/fail/data_race/dealloc_write_race_stack.stderr
index f3a8707ed14ed..e6ebd5b6278ec 100644
--- a/src/tools/miri/tests/fail/data_race/dealloc_write_race_stack.stderr
+++ b/src/tools/miri/tests/fail/data_race/dealloc_write_race_stack.stderr
@@ -1,8 +1,8 @@
 error: Undefined Behavior: Data race detected between (1) non-atomic write on thread `unnamed-ID` and (2) deallocation on thread `unnamed-ID` at ALLOC
   --> tests/fail/data_race/dealloc_write_race_stack.rs:LL:CC
    |
-LL |             }
-   |             ^ (2) just happened here
+LL | ...   }
+   |       ^ (2) just happened here
    |
 help: and (1) occurred earlier here
   --> tests/fail/data_race/dealloc_write_race_stack.rs:LL:CC
diff --git a/src/tools/miri/tests/fail/intrinsics/copy_unaligned.stderr b/src/tools/miri/tests/fail/intrinsics/copy_unaligned.stderr
index f561e502b5146..d9b41f5b0581c 100644
--- a/src/tools/miri/tests/fail/intrinsics/copy_unaligned.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/copy_unaligned.stderr
@@ -1,8 +1,8 @@
 error: Undefined Behavior: accessing memory with alignment ALIGN, but alignment ALIGN is required
   --> tests/fail/intrinsics/copy_unaligned.rs:LL:CC
    |
-LL |         std::intrinsics::copy_nonoverlapping(&data[5], ptr, 0);
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
+LL | ...   std::intrinsics::copy_nonoverlapping(&data[5], ptr, 0);
+   |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
    |
    = 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
diff --git a/src/tools/miri/tests/fail/intrinsics/simd-float-to-int.stderr b/src/tools/miri/tests/fail/intrinsics/simd-float-to-int.stderr
index 04e9cb338cdd3..64b8e166c1668 100644
--- a/src/tools/miri/tests/fail/intrinsics/simd-float-to-int.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/simd-float-to-int.stderr
@@ -1,8 +1,8 @@
 error: Undefined Behavior: `simd_cast` intrinsic called on 3.40282347E+38f32 which cannot be represented in target type `i32`
   --> tests/fail/intrinsics/simd-float-to-int.rs:LL:CC
    |
-LL |         let _x: i32x2 = f32x2::from_array([f32::MAX, f32::MIN]).to_int_unchecked();
-   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
+LL | ...   let _x: i32x2 = f32x2::from_array([f32::MAX, f32::MIN]).to_int_unchecked();
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
    |
    = 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
diff --git a/src/tools/miri/tests/fail/stacked_borrows/retag_data_race_read.stderr b/src/tools/miri/tests/fail/stacked_borrows/retag_data_race_read.stderr
index d84fbc76056d6..ee82bbbb1ed14 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/retag_data_race_read.stderr
+++ b/src/tools/miri/tests/fail/stacked_borrows/retag_data_race_read.stderr
@@ -1,8 +1,8 @@
 error: Undefined Behavior: Data race detected between (1) retag read on thread `unnamed-ID` and (2) non-atomic write on thread `unnamed-ID` at ALLOC
   --> tests/fail/stacked_borrows/retag_data_race_read.rs:LL:CC
    |
-LL |         *p = 5;
-   |         ^^^^^^ (2) just happened here
+LL | ...   *p = 5;
+   |       ^^^^^^ (2) just happened here
    |
 help: and (1) occurred earlier here
   --> tests/fail/stacked_borrows/retag_data_race_read.rs:LL:CC
diff --git a/tests/ui/async-await/async-drop/ex-ice1.stderr b/tests/ui/async-await/async-drop/ex-ice1.stderr
index 68533edeb086c..a1fa89f2c4001 100644
--- a/tests/ui/async-await/async-drop/ex-ice1.stderr
+++ b/tests/ui/async-await/async-drop/ex-ice1.stderr
@@ -1,14 +1,14 @@
 error[E0423]: expected function, found module `core::future::async_drop`
   --> $DIR/ex-ice1.rs:9:35
    |
-LL |         let async_drop_fut = pin!(core::future::async_drop(async {}));
-   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^ not a function
+LL | ...   let async_drop_fut = pin!(core::future::async_drop(async {}));
+   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^ not a function
 
 error[E0603]: module `async_drop` is private
   --> $DIR/ex-ice1.rs:9:49
    |
-LL |         let async_drop_fut = pin!(core::future::async_drop(async {}));
-   |                                                 ^^^^^^^^^^ private module
+LL | ...   let async_drop_fut = pin!(core::future::async_drop(async {}));
+   |                                               ^^^^^^^^^^ private module
    |
 note: the module `async_drop` is defined here
   --> $SRC_DIR/core/src/future/mod.rs:LL:COL
diff --git a/tests/ui/cast/func-pointer-issue-140491.stderr b/tests/ui/cast/func-pointer-issue-140491.stderr
index e1c07010e691c..0b777905da1f9 100644
--- a/tests/ui/cast/func-pointer-issue-140491.stderr
+++ b/tests/ui/cast/func-pointer-issue-140491.stderr
@@ -1,8 +1,8 @@
 error[E0605]: non-primitive cast: `&for<'a, 'b> fn(&'a Event<'b>) {my_fn}` as `&for<'a, 'b> fn(&'a Event<'b>)`
   --> $DIR/func-pointer-issue-140491.rs:6:34
    |
-LL | ..._>) = &my_fn as _;
-   |          ^^^^^^^^^^^ an `as` expression can only be used to convert between primitive types or to coerce to a specific trait object
+LL | ... = &my_fn as _;
+   |       ^^^^^^^^^^^ an `as` expression can only be used to convert between primitive types or to coerce to a specific trait object
    |
    = note: casting reference expression `&my_fn` because `&` binds tighter than `as`
 
diff --git a/tests/ui/consts/offset_ub.stderr b/tests/ui/consts/offset_ub.stderr
index d92ca09223de7..f40d342758360 100644
--- a/tests/ui/consts/offset_ub.stderr
+++ b/tests/ui/consts/offset_ub.stderr
@@ -43,8 +43,8 @@ LL | pub const UNDERFLOW_ADDRESS_SPACE: *const u8 = unsafe { (1 as *const u8).of
 error[E0080]: in-bounds pointer arithmetic failed: attempting to offset pointer by -$BYTES bytes, but got ALLOC3-0x2 which points to before the beginning of the allocation
   --> $DIR/offset_ub.rs:16:49
    |
-LL | ...*const u8 = unsafe { [0u8; 1].as_ptr().wrapping_offset(-2).offset(-2) };
-   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `NEGATIVE_OFFSET` failed here
+LL | ...nst u8 = unsafe { [0u8; 1].as_ptr().wrapping_offset(-2).offset(-2) };
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `NEGATIVE_OFFSET` failed here
 
 error[E0080]: in-bounds pointer arithmetic failed: attempting to offset pointer by 1 byte, but got ALLOC4 which is at or beyond the end of the allocation of size $BYTES bytes
   --> $DIR/offset_ub.rs:18:50
diff --git a/tests/ui/deprecation/deprecation-lint.stderr b/tests/ui/deprecation/deprecation-lint.stderr
index 95ae1b04d8611..5a39b0cf31516 100644
--- a/tests/ui/deprecation/deprecation-lint.stderr
+++ b/tests/ui/deprecation/deprecation-lint.stderr
@@ -73,8 +73,8 @@ LL |         let _ = nested::DeprecatedStruct {
 error: use of deprecated unit struct `deprecation_lint::nested::DeprecatedUnitStruct`: text
   --> $DIR/deprecation-lint.rs:48:25
    |
-LL |         let _ = nested::DeprecatedUnitStruct;
-   |                         ^^^^^^^^^^^^^^^^^^^^
+LL | ...   let _ = nested::DeprecatedUnitStruct;
+   |                       ^^^^^^^^^^^^^^^^^^^^
 
 error: use of deprecated unit variant `deprecation_lint::nested::Enum::DeprecatedVariant`: text
   --> $DIR/deprecation-lint.rs:50:31
@@ -97,8 +97,8 @@ LL |         macro_test_arg!(deprecated_text());
 error: use of deprecated function `deprecation_lint::deprecated_text`: text
   --> $DIR/deprecation-lint.rs:60:41
    |
-LL |         macro_test_arg!(macro_test_arg!(deprecated_text()));
-   |                                         ^^^^^^^^^^^^^^^
+LL | ...   macro_test_arg!(macro_test_arg!(deprecated_text()));
+   |                                       ^^^^^^^^^^^^^^^
 
 error: use of deprecated method `deprecation_lint::Trait::trait_deprecated`: text
   --> $DIR/deprecation-lint.rs:65:16
@@ -211,8 +211,8 @@ LL |         Trait::trait_deprecated_text(&foo);
 error: use of deprecated method `this_crate::Trait::trait_deprecated_text`: text
   --> $DIR/deprecation-lint.rs:261:25
    |
-LL |         <Foo as Trait>::trait_deprecated_text(&foo);
-   |                         ^^^^^^^^^^^^^^^^^^^^^
+LL | ...   <Foo as Trait>::trait_deprecated_text(&foo);
+   |                       ^^^^^^^^^^^^^^^^^^^^^
 
 error: use of deprecated function `this_crate::deprecated_future`: text
   --> $DIR/deprecation-lint.rs:264:9
@@ -295,8 +295,8 @@ LL |         Trait::trait_deprecated_text(&foo);
 error: use of deprecated method `this_crate::Trait::trait_deprecated_text`: text
   --> $DIR/deprecation-lint.rs:299:25
    |
-LL |         <Foo as Trait>::trait_deprecated_text(&foo);
-   |                         ^^^^^^^^^^^^^^^^^^^^^
+LL | ...   <Foo as Trait>::trait_deprecated_text(&foo);
+   |                       ^^^^^^^^^^^^^^^^^^^^^
 
 error: use of deprecated function `this_crate::test_fn_closure_body::{closure#0}::bar`
   --> $DIR/deprecation-lint.rs:317:13
@@ -391,8 +391,8 @@ LL |         foo.method_deprecated_text();
 error: use of deprecated method `deprecation_lint::MethodTester::method_deprecated_text`: text
   --> $DIR/deprecation-lint.rs:27:14
    |
-LL |         Foo::method_deprecated_text(&foo);
-   |              ^^^^^^^^^^^^^^^^^^^^^^
+LL | ...   Foo::method_deprecated_text(&foo);
+   |            ^^^^^^^^^^^^^^^^^^^^^^
 
 error: use of deprecated method `deprecation_lint::MethodTester::method_deprecated_text`: text
   --> $DIR/deprecation-lint.rs:28:16
@@ -589,8 +589,8 @@ LL |         Foo::method_deprecated_text(&foo);
 error: use of deprecated method `this_crate::MethodTester::method_deprecated_text`: text
   --> $DIR/deprecation-lint.rs:257:16
    |
-LL |         <Foo>::method_deprecated_text(&foo);
-   |                ^^^^^^^^^^^^^^^^^^^^^^
+LL | ...   <Foo>::method_deprecated_text(&foo);
+   |              ^^^^^^^^^^^^^^^^^^^^^^
 
 error: use of deprecated method `this_crate::Trait::trait_deprecated_text`: text
   --> $DIR/deprecation-lint.rs:258:13
diff --git a/tests/ui/lint/lint-stability-deprecated.stderr b/tests/ui/lint/lint-stability-deprecated.stderr
index 0399fab746ec4..bda4ee82d1fc6 100644
--- a/tests/ui/lint/lint-stability-deprecated.stderr
+++ b/tests/ui/lint/lint-stability-deprecated.stderr
@@ -43,8 +43,8 @@ LL |         Trait::trait_deprecated_text(&foo);
 warning: use of deprecated method `lint_stability::Trait::trait_deprecated_text`: text
   --> $DIR/lint-stability-deprecated.rs:40:25
    |
-LL |         <Foo as Trait>::trait_deprecated_text(&foo);
-   |                         ^^^^^^^^^^^^^^^^^^^^^
+LL | ...   <Foo as Trait>::trait_deprecated_text(&foo);
+   |                       ^^^^^^^^^^^^^^^^^^^^^
 
 warning: use of deprecated function `lint_stability::deprecated_unstable`: text
   --> $DIR/lint-stability-deprecated.rs:42:9
@@ -115,8 +115,8 @@ LL |         let _ = Enum::DeprecatedVariant;
 warning: use of deprecated unit variant `lint_stability::Enum::DeprecatedUnstableVariant`: text
   --> $DIR/lint-stability-deprecated.rs:121:23
    |
-LL |         let _ = Enum::DeprecatedUnstableVariant;
-   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | ...   let _ = Enum::DeprecatedUnstableVariant;
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: use of deprecated tuple struct `lint_stability::DeprecatedTupleStruct`: text
   --> $DIR/lint-stability-deprecated.rs:125:17
@@ -127,8 +127,8 @@ LL |         let _ = DeprecatedTupleStruct (1);
 warning: use of deprecated tuple struct `lint_stability::DeprecatedUnstableTupleStruct`: text
   --> $DIR/lint-stability-deprecated.rs:126:17
    |
-LL |         let _ = DeprecatedUnstableTupleStruct (1);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | ...   let _ = DeprecatedUnstableTupleStruct (1);
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: use of deprecated function `lint_stability::deprecated_text`: text
   --> $DIR/lint-stability-deprecated.rs:135:25
@@ -139,14 +139,14 @@ LL |         macro_test_arg!(deprecated_text());
 warning: use of deprecated function `lint_stability::deprecated_unstable_text`: text
   --> $DIR/lint-stability-deprecated.rs:136:25
    |
-LL |         macro_test_arg!(deprecated_unstable_text());
-   |                         ^^^^^^^^^^^^^^^^^^^^^^^^
+LL | ...   macro_test_arg!(deprecated_unstable_text());
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: use of deprecated function `lint_stability::deprecated_text`: text
   --> $DIR/lint-stability-deprecated.rs:137:41
    |
-LL |         macro_test_arg!(macro_test_arg!(deprecated_text()));
-   |                                         ^^^^^^^^^^^^^^^
+LL | ...   macro_test_arg!(macro_test_arg!(deprecated_text()));
+   |                                       ^^^^^^^^^^^^^^^
 
 warning: use of deprecated method `lint_stability::Trait::trait_deprecated`: text
   --> $DIR/lint-stability-deprecated.rs:142:16
@@ -169,8 +169,8 @@ LL |         Trait::trait_deprecated_text(&foo);
 warning: use of deprecated method `lint_stability::Trait::trait_deprecated_text`: text
   --> $DIR/lint-stability-deprecated.rs:148:25
    |
-LL |         <Foo as Trait>::trait_deprecated_text(&foo);
-   |                         ^^^^^^^^^^^^^^^^^^^^^
+LL | ...   <Foo as Trait>::trait_deprecated_text(&foo);
+   |                       ^^^^^^^^^^^^^^^^^^^^^
 
 warning: use of deprecated method `lint_stability::Trait::trait_deprecated_unstable`: text
   --> $DIR/lint-stability-deprecated.rs:150:16
@@ -211,8 +211,8 @@ LL |     trait LocalTrait2 : DeprecatedTrait { }
 warning: use of deprecated function `inheritance::inherited_stability::unstable_mod::deprecated`: text
   --> $DIR/lint-stability-deprecated.rs:205:23
    |
-LL |         unstable_mod::deprecated();
-   |                       ^^^^^^^^^^
+LL | ...   unstable_mod::deprecated();
+   |                     ^^^^^^^^^^
 
 warning: use of deprecated function `this_crate::deprecated`: text
   --> $DIR/lint-stability-deprecated.rs:327:9
@@ -367,14 +367,14 @@ LL |         foo.method_deprecated_text();
 warning: use of deprecated method `lint_stability::MethodTester::method_deprecated_text`: text
   --> $DIR/lint-stability-deprecated.rs:35:14
    |
-LL |         Foo::method_deprecated_text(&foo);
-   |              ^^^^^^^^^^^^^^^^^^^^^^
+LL | ...   Foo::method_deprecated_text(&foo);
+   |            ^^^^^^^^^^^^^^^^^^^^^^
 
 warning: use of deprecated method `lint_stability::MethodTester::method_deprecated_text`: text
   --> $DIR/lint-stability-deprecated.rs:36:16
    |
-LL |         <Foo>::method_deprecated_text(&foo);
-   |                ^^^^^^^^^^^^^^^^^^^^^^
+LL | ...   <Foo>::method_deprecated_text(&foo);
+   |              ^^^^^^^^^^^^^^^^^^^^^^
 
 warning: use of deprecated method `lint_stability::Trait::trait_deprecated_text`: text
   --> $DIR/lint-stability-deprecated.rs:37:13
@@ -397,8 +397,8 @@ LL |         foo.method_deprecated_unstable();
 warning: use of deprecated method `lint_stability::MethodTester::method_deprecated_unstable`: text
   --> $DIR/lint-stability-deprecated.rs:44:14
    |
-LL |         Foo::method_deprecated_unstable(&foo);
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | ...   Foo::method_deprecated_unstable(&foo);
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: use of deprecated method `lint_stability::MethodTester::method_deprecated_unstable`: text
   --> $DIR/lint-stability-deprecated.rs:45:16
diff --git a/tests/ui/parser/raw/too-many-hash.stderr b/tests/ui/parser/raw/too-many-hash.stderr
index 6b3854eb4a237..499b21d3982c8 100644
--- a/tests/ui/parser/raw/too-many-hash.stderr
+++ b/tests/ui/parser/raw/too-many-hash.stderr
@@ -1,8 +1,8 @@
 error: too many `#` symbols: raw strings may be delimited by up to 255 `#` symbols, but found 256
   --> $DIR/too-many-hash.rs:4:19
    |
-LL | ... = r####################################################...#######################################;
-   |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^...^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | ... = r###################################################...######################################;
+   |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^...^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/pattern/usefulness/empty-match.exhaustive_patterns.stderr b/tests/ui/pattern/usefulness/empty-match.exhaustive_patterns.stderr
index f2067f0341fcd..b649aa122b255 100644
--- a/tests/ui/pattern/usefulness/empty-match.exhaustive_patterns.stderr
+++ b/tests/ui/pattern/usefulness/empty-match.exhaustive_patterns.stderr
@@ -346,8 +346,8 @@ LL +                 NonEmptyEnum2::Foo(_) | NonEmptyEnum2::Bar => todo!()
 error[E0004]: non-exhaustive patterns: `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
   --> $DIR/empty-match.rs:71:24
    |
-LL |     match_guarded_arm!(NonEmptyEnum5::V1);
-   |                        ^^^^^^^^^^^^^^^^^ patterns `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
+LL | ...ded_arm!(NonEmptyEnum5::V1);
+   |             ^^^^^^^^^^^^^^^^^ patterns `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
    |
 note: `NonEmptyEnum5` defined here
   --> $DIR/empty-match.rs:38:10
diff --git a/tests/ui/pattern/usefulness/empty-match.normal.stderr b/tests/ui/pattern/usefulness/empty-match.normal.stderr
index f2067f0341fcd..b649aa122b255 100644
--- a/tests/ui/pattern/usefulness/empty-match.normal.stderr
+++ b/tests/ui/pattern/usefulness/empty-match.normal.stderr
@@ -346,8 +346,8 @@ LL +                 NonEmptyEnum2::Foo(_) | NonEmptyEnum2::Bar => todo!()
 error[E0004]: non-exhaustive patterns: `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
   --> $DIR/empty-match.rs:71:24
    |
-LL |     match_guarded_arm!(NonEmptyEnum5::V1);
-   |                        ^^^^^^^^^^^^^^^^^ patterns `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
+LL | ...ded_arm!(NonEmptyEnum5::V1);
+   |             ^^^^^^^^^^^^^^^^^ patterns `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
    |
 note: `NonEmptyEnum5` defined here
   --> $DIR/empty-match.rs:38:10
diff --git a/tests/ui/simd/not-out-of-bounds.stderr b/tests/ui/simd/not-out-of-bounds.stderr
index 734c21fbf4158..d5bcd15d97d6c 100644
--- a/tests/ui/simd/not-out-of-bounds.stderr
+++ b/tests/ui/simd/not-out-of-bounds.stderr
@@ -79,8 +79,8 @@ LL |         simd_insert(v, 2, 0u8);
 error[E0511]: invalid monomorphization of `simd_extract` intrinsic: SIMD index #1 is out of bounds (limit 2)
   --> $DIR/not-out-of-bounds.rs:85:24
    |
-LL |         let _val: u8 = simd_extract(v, 2);
-   |                        ^^^^^^^^^^^^^^^^^^
+LL | ...   let _val: u8 = simd_extract(v, 2);
+   |                      ^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 9 previous errors
 
diff --git a/tests/ui/transmutability/alignment/align-fail.stderr b/tests/ui/transmutability/alignment/align-fail.stderr
index 7b69820a3c6df..164c57a362442 100644
--- a/tests/ui/transmutability/alignment/align-fail.stderr
+++ b/tests/ui/transmutability/alignment/align-fail.stderr
@@ -1,8 +1,8 @@
 error[E0277]: `&[u8; 0]` cannot be safely transmuted into `&[u16; 0]`
   --> $DIR/align-fail.rs:21:55
    |
-LL | ...tatic [u8; 0], &'static [u16; 0]>();
-   |                   ^^^^^^^^^^^^^^^^^ the minimum alignment of `&[u8; 0]` (1) should be greater than that of `&[u16; 0]` (2)
+LL | ...ic [u8; 0], &'static [u16; 0]>();
+   |                ^^^^^^^^^^^^^^^^^ the minimum alignment of `&[u8; 0]` (1) should be greater than that of `&[u16; 0]` (2)
    |
 note: required by a bound in `is_maybe_transmutable`
   --> $DIR/align-fail.rs:9:14

From 6275a19255afb2a09b932986928e81cf431a7358 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 2 Oct 2025 15:24:04 +0200
Subject: [PATCH 1665/1889] Move doc_cfg-specific code into `cfg.rs`

---
 src/librustdoc/clean/cfg.rs   | 267 +++++++++++++++++++++++++++++++++-
 src/librustdoc/clean/mod.rs   |   1 +
 src/librustdoc/clean/types.rs | 264 +--------------------------------
 3 files changed, 268 insertions(+), 264 deletions(-)

diff --git a/src/librustdoc/clean/cfg.rs b/src/librustdoc/clean/cfg.rs
index aa614b73dea72..881a81b22f0f7 100644
--- a/src/librustdoc/clean/cfg.rs
+++ b/src/librustdoc/clean/cfg.rs
@@ -3,14 +3,18 @@
 // FIXME: Once the portability lint RFC is implemented (see tracking issue #41619),
 // switch to use those structures instead.
 
+use std::sync::Arc;
 use std::{fmt, mem, ops};
 
 use itertools::Either;
 use rustc_ast::{LitKind, MetaItem, MetaItemInner, MetaItemKind, MetaItemLit};
-use rustc_data_structures::fx::FxHashSet;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_hir::attrs::AttributeKind;
+use rustc_middle::ty::TyCtxt;
 use rustc_session::parse::ParseSess;
 use rustc_span::Span;
 use rustc_span::symbol::{Symbol, sym};
+use {rustc_ast as ast, rustc_hir as hir};
 
 use crate::display::{Joined as _, MaybeDisplay, Wrapped};
 use crate::html::escape::Escape;
@@ -600,3 +604,264 @@ impl fmt::Display for Display<'_> {
         }
     }
 }
+
+/// This type keeps track of (doc) cfg information as we go down the item tree.
+#[derive(Clone, Debug)]
+pub(crate) struct CfgInfo {
+    /// List of currently active `doc(auto_cfg(hide(...)))` cfgs, minus currently active
+    /// `doc(auto_cfg(show(...)))` cfgs.
+    hidden_cfg: FxHashSet<Cfg>,
+    /// Current computed `cfg`. Each time we enter a new item, this field is updated as well while
+    /// taking into account the `hidden_cfg` information.
+    current_cfg: Cfg,
+    /// Whether the `doc(auto_cfg())` feature is enabled or not at this point.
+    auto_cfg_active: bool,
+    /// If the parent item used `doc(cfg(...))`, then we don't want to overwrite `current_cfg`,
+    /// instead we will concatenate with it. However, if it's not the case, we need to overwrite
+    /// `current_cfg`.
+    parent_is_doc_cfg: bool,
+}
+
+impl Default for CfgInfo {
+    fn default() -> Self {
+        Self {
+            hidden_cfg: FxHashSet::from_iter([
+                Cfg::Cfg(sym::test, None),
+                Cfg::Cfg(sym::doc, None),
+                Cfg::Cfg(sym::doctest, None),
+            ]),
+            current_cfg: Cfg::True,
+            auto_cfg_active: true,
+            parent_is_doc_cfg: false,
+        }
+    }
+}
+
+fn show_hide_show_conflict_error(
+    tcx: TyCtxt<'_>,
+    item_span: rustc_span::Span,
+    previous: rustc_span::Span,
+) {
+    let mut diag = tcx.sess.dcx().struct_span_err(
+        item_span,
+        format!(
+            "same `cfg` was in `auto_cfg(hide(...))` and `auto_cfg(show(...))` on the same item"
+        ),
+    );
+    diag.span_note(previous, "first change was here");
+    diag.emit();
+}
+
+/// This functions updates the `hidden_cfg` field of the provided `cfg_info` argument.
+///
+/// It also checks if a same `cfg` is present in both `auto_cfg(hide(...))` and
+/// `auto_cfg(show(...))` on the same item and emits an error if it's the case.
+///
+/// Because we go through a list of `cfg`s, we keep track of the `cfg`s we saw in `new_show_attrs`
+/// and in `new_hide_attrs` arguments.
+fn handle_auto_cfg_hide_show(
+    tcx: TyCtxt<'_>,
+    cfg_info: &mut CfgInfo,
+    sub_attr: &MetaItemInner,
+    is_show: bool,
+    new_show_attrs: &mut FxHashMap<(Symbol, Option<Symbol>), rustc_span::Span>,
+    new_hide_attrs: &mut FxHashMap<(Symbol, Option<Symbol>), rustc_span::Span>,
+) {
+    if let MetaItemInner::MetaItem(item) = sub_attr
+        && let MetaItemKind::List(items) = &item.kind
+    {
+        for item in items {
+            // FIXME: Report in case `Cfg::parse` reports an error?
+            if let Ok(Cfg::Cfg(key, value)) = Cfg::parse(item) {
+                if is_show {
+                    if let Some(span) = new_hide_attrs.get(&(key, value)) {
+                        show_hide_show_conflict_error(tcx, item.span(), *span);
+                    } else {
+                        new_show_attrs.insert((key, value), item.span());
+                    }
+                    cfg_info.hidden_cfg.remove(&Cfg::Cfg(key, value));
+                } else {
+                    if let Some(span) = new_show_attrs.get(&(key, value)) {
+                        show_hide_show_conflict_error(tcx, item.span(), *span);
+                    } else {
+                        new_hide_attrs.insert((key, value), item.span());
+                    }
+                    cfg_info.hidden_cfg.insert(Cfg::Cfg(key, value));
+                }
+            }
+        }
+    }
+}
+
+pub(crate) fn extract_cfg_from_attrs<'a, I: Iterator<Item = &'a hir::Attribute> + Clone>(
+    attrs: I,
+    tcx: TyCtxt<'_>,
+    cfg_info: &mut CfgInfo,
+) -> Option<Arc<Cfg>> {
+    fn single<T: IntoIterator>(it: T) -> Option<T::Item> {
+        let mut iter = it.into_iter();
+        let item = iter.next()?;
+        if iter.next().is_some() {
+            return None;
+        }
+        Some(item)
+    }
+
+    fn check_changed_auto_active_status(
+        changed_auto_active_status: &mut Option<rustc_span::Span>,
+        attr: &ast::MetaItem,
+        cfg_info: &mut CfgInfo,
+        tcx: TyCtxt<'_>,
+        new_value: bool,
+    ) -> bool {
+        if let Some(first_change) = changed_auto_active_status {
+            if cfg_info.auto_cfg_active != new_value {
+                tcx.sess
+                    .dcx()
+                    .struct_span_err(
+                        vec![*first_change, attr.span],
+                        "`auto_cfg` was disabled and enabled more than once on the same item",
+                    )
+                    .emit();
+                return true;
+            }
+        } else {
+            *changed_auto_active_status = Some(attr.span);
+        }
+        cfg_info.auto_cfg_active = new_value;
+        false
+    }
+
+    let mut new_show_attrs = FxHashMap::default();
+    let mut new_hide_attrs = FxHashMap::default();
+
+    let mut doc_cfg = attrs
+        .clone()
+        .filter(|attr| attr.has_name(sym::doc))
+        .flat_map(|attr| attr.meta_item_list().unwrap_or_default())
+        .filter(|attr| attr.has_name(sym::cfg))
+        .peekable();
+    // If the item uses `doc(cfg(...))`, then we ignore the other `cfg(...)` attributes.
+    if doc_cfg.peek().is_some() {
+        let sess = tcx.sess;
+        // We overwrite existing `cfg`.
+        if !cfg_info.parent_is_doc_cfg {
+            cfg_info.current_cfg = Cfg::True;
+            cfg_info.parent_is_doc_cfg = true;
+        }
+        for attr in doc_cfg {
+            if let Some(cfg_mi) =
+                attr.meta_item().and_then(|attr| rustc_expand::config::parse_cfg(attr, sess))
+            {
+                match Cfg::parse(cfg_mi) {
+                    Ok(new_cfg) => cfg_info.current_cfg &= new_cfg,
+                    Err(e) => {
+                        sess.dcx().span_err(e.span, e.msg);
+                    }
+                }
+            }
+        }
+    } else {
+        cfg_info.parent_is_doc_cfg = false;
+    }
+
+    let mut changed_auto_active_status = None;
+
+    // We get all `doc(auto_cfg)`, `cfg` and `target_feature` attributes.
+    for attr in attrs {
+        if let Some(ident) = attr.ident()
+            && ident.name == sym::doc
+            && let Some(attrs) = attr.meta_item_list()
+        {
+            for attr in attrs.iter().filter(|attr| attr.has_name(sym::auto_cfg)) {
+                let MetaItemInner::MetaItem(attr) = attr else {
+                    continue;
+                };
+                match &attr.kind {
+                    MetaItemKind::Word => {
+                        if check_changed_auto_active_status(
+                            &mut changed_auto_active_status,
+                            attr,
+                            cfg_info,
+                            tcx,
+                            true,
+                        ) {
+                            return None;
+                        }
+                    }
+                    MetaItemKind::NameValue(lit) => {
+                        if let LitKind::Bool(value) = lit.kind {
+                            if check_changed_auto_active_status(
+                                &mut changed_auto_active_status,
+                                attr,
+                                cfg_info,
+                                tcx,
+                                value,
+                            ) {
+                                return None;
+                            }
+                        }
+                    }
+                    MetaItemKind::List(sub_attrs) => {
+                        if check_changed_auto_active_status(
+                            &mut changed_auto_active_status,
+                            attr,
+                            cfg_info,
+                            tcx,
+                            true,
+                        ) {
+                            return None;
+                        }
+                        for sub_attr in sub_attrs.iter() {
+                            if let Some(ident) = sub_attr.ident()
+                                && (ident.name == sym::show || ident.name == sym::hide)
+                            {
+                                handle_auto_cfg_hide_show(
+                                    tcx,
+                                    cfg_info,
+                                    &sub_attr,
+                                    ident.name == sym::show,
+                                    &mut new_show_attrs,
+                                    &mut new_hide_attrs,
+                                );
+                            }
+                        }
+                    }
+                }
+            }
+        } else if let hir::Attribute::Parsed(AttributeKind::TargetFeature { features, .. }) = attr {
+            // Treat `#[target_feature(enable = "feat")]` attributes as if they were
+            // `#[doc(cfg(target_feature = "feat"))]` attributes as well.
+            for (feature, _) in features {
+                cfg_info.current_cfg &= Cfg::Cfg(sym::target_feature, Some(*feature));
+            }
+            continue;
+        } else if !cfg_info.parent_is_doc_cfg
+            && let Some(ident) = attr.ident()
+            && matches!(ident.name, sym::cfg | sym::cfg_trace)
+            && let Some(attr) = single(attr.meta_item_list()?)
+            && let Ok(new_cfg) = Cfg::parse(&attr)
+        {
+            cfg_info.current_cfg &= new_cfg;
+        }
+    }
+
+    // If `doc(auto_cfg)` feature is disabled and `doc(cfg())` wasn't used, there is nothing
+    // to be done here.
+    if !cfg_info.auto_cfg_active && !cfg_info.parent_is_doc_cfg {
+        None
+    } else if cfg_info.parent_is_doc_cfg {
+        if cfg_info.current_cfg == Cfg::True {
+            None
+        } else {
+            Some(Arc::new(cfg_info.current_cfg.clone()))
+        }
+    } else {
+        // If `doc(auto_cfg)` feature is enabled, we want to collect all `cfg` items, we remove the
+        // hidden ones afterward.
+        match cfg_info.current_cfg.strip_hidden(&cfg_info.hidden_cfg) {
+            None | Some(Cfg::True) => None,
+            Some(cfg) => Some(Arc::new(cfg)),
+        }
+    }
+}
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index c6339dd475593..4fd8d245089e7 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -58,6 +58,7 @@ use tracing::{debug, instrument};
 use utils::*;
 use {rustc_ast as ast, rustc_hir as hir};
 
+pub(crate) use self::cfg::{CfgInfo, extract_cfg_from_attrs};
 pub(crate) use self::types::*;
 pub(crate) use self::utils::{krate, register_res, synthesize_auto_trait_and_blanket_impls};
 use crate::core::DocContext;
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index 6e3dfa0ac221c..f3662a67bbea2 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -6,8 +6,7 @@ use std::{fmt, iter};
 use arrayvec::ArrayVec;
 use itertools::Either;
 use rustc_abi::{ExternAbi, VariantIdx};
-use rustc_ast::ast::{LitKind, MetaItemInner, MetaItemKind};
-use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap, FxIndexSet};
+use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_hir::attrs::{AttributeKind, DeprecatedSince, Deprecation};
 use rustc_hir::def::{CtorKind, DefKind, Res};
 use rustc_hir::def_id::{CrateNum, DefId, LOCAL_CRATE, LocalDefId};
@@ -922,267 +921,6 @@ pub(crate) fn hir_attr_lists<'a, I: IntoIterator<Item = &'a hir::Attribute>>(
         .flatten()
 }
 
-/// This type keeps track of (doc) cfg information as we go down the item tree.
-#[derive(Clone, Debug)]
-pub(crate) struct CfgInfo {
-    /// List of currently active `doc(auto_cfg(hide(...)))` cfgs, minus currently active
-    /// `doc(auto_cfg(show(...)))` cfgs.
-    hidden_cfg: FxHashSet<Cfg>,
-    /// Current computed `cfg`. Each time we enter a new item, this field is updated as well while
-    /// taking into account the `hidden_cfg` information.
-    current_cfg: Cfg,
-    /// Whether the `doc(auto_cfg())` feature is enabled or not at this point.
-    auto_cfg_active: bool,
-    /// If the parent item used `doc(cfg(...))`, then we don't want to overwrite `current_cfg`,
-    /// instead we will concatenate with it. However, if it's not the case, we need to overwrite
-    /// `current_cfg`.
-    parent_is_doc_cfg: bool,
-}
-
-impl Default for CfgInfo {
-    fn default() -> Self {
-        Self {
-            hidden_cfg: FxHashSet::from_iter([
-                Cfg::Cfg(sym::test, None),
-                Cfg::Cfg(sym::doc, None),
-                Cfg::Cfg(sym::doctest, None),
-            ]),
-            current_cfg: Cfg::True,
-            auto_cfg_active: true,
-            parent_is_doc_cfg: false,
-        }
-    }
-}
-
-fn show_hide_show_conflict_error(
-    tcx: TyCtxt<'_>,
-    item_span: rustc_span::Span,
-    previous: rustc_span::Span,
-) {
-    let mut diag = tcx.sess.dcx().struct_span_err(
-        item_span,
-        format!(
-            "same `cfg` was in `auto_cfg(hide(...))` and `auto_cfg(show(...))` on the same item"
-        ),
-    );
-    diag.span_note(previous, "first change was here");
-    diag.emit();
-}
-
-/// This functions updates the `hidden_cfg` field of the provided `cfg_info` argument.
-///
-/// It also checks if a same `cfg` is present in both `auto_cfg(hide(...))` and
-/// `auto_cfg(show(...))` on the same item and emits an error if it's the case.
-///
-/// Because we go through a list of `cfg`s, we keep track of the `cfg`s we saw in `new_show_attrs`
-/// and in `new_hide_attrs` arguments.
-fn handle_auto_cfg_hide_show(
-    tcx: TyCtxt<'_>,
-    cfg_info: &mut CfgInfo,
-    sub_attr: &MetaItemInner,
-    is_show: bool,
-    new_show_attrs: &mut FxHashMap<(Symbol, Option<Symbol>), rustc_span::Span>,
-    new_hide_attrs: &mut FxHashMap<(Symbol, Option<Symbol>), rustc_span::Span>,
-) {
-    if let MetaItemInner::MetaItem(item) = sub_attr
-        && let MetaItemKind::List(items) = &item.kind
-    {
-        for item in items {
-            // FIXME: Report in case `Cfg::parse` reports an error?
-            if let Ok(Cfg::Cfg(key, value)) = Cfg::parse(item) {
-                if is_show {
-                    if let Some(span) = new_hide_attrs.get(&(key, value)) {
-                        show_hide_show_conflict_error(tcx, item.span(), *span);
-                    } else {
-                        new_show_attrs.insert((key, value), item.span());
-                    }
-                    cfg_info.hidden_cfg.remove(&Cfg::Cfg(key, value));
-                } else {
-                    if let Some(span) = new_show_attrs.get(&(key, value)) {
-                        show_hide_show_conflict_error(tcx, item.span(), *span);
-                    } else {
-                        new_hide_attrs.insert((key, value), item.span());
-                    }
-                    cfg_info.hidden_cfg.insert(Cfg::Cfg(key, value));
-                }
-            }
-        }
-    }
-}
-
-pub(crate) fn extract_cfg_from_attrs<'a, I: Iterator<Item = &'a hir::Attribute> + Clone>(
-    attrs: I,
-    tcx: TyCtxt<'_>,
-    cfg_info: &mut CfgInfo,
-) -> Option<Arc<Cfg>> {
-    fn single<T: IntoIterator>(it: T) -> Option<T::Item> {
-        let mut iter = it.into_iter();
-        let item = iter.next()?;
-        if iter.next().is_some() {
-            return None;
-        }
-        Some(item)
-    }
-
-    fn check_changed_auto_active_status(
-        changed_auto_active_status: &mut Option<rustc_span::Span>,
-        attr: &ast::MetaItem,
-        cfg_info: &mut CfgInfo,
-        tcx: TyCtxt<'_>,
-        new_value: bool,
-    ) -> bool {
-        if let Some(first_change) = changed_auto_active_status {
-            if cfg_info.auto_cfg_active != new_value {
-                tcx.sess
-                    .dcx()
-                    .struct_span_err(
-                        vec![*first_change, attr.span],
-                        "`auto_cfg` was disabled and enabled more than once on the same item",
-                    )
-                    .emit();
-                return true;
-            }
-        } else {
-            *changed_auto_active_status = Some(attr.span);
-        }
-        cfg_info.auto_cfg_active = new_value;
-        false
-    }
-
-    let mut new_show_attrs = FxHashMap::default();
-    let mut new_hide_attrs = FxHashMap::default();
-
-    let mut doc_cfg = attrs
-        .clone()
-        .filter(|attr| attr.has_name(sym::doc))
-        .flat_map(|attr| attr.meta_item_list().unwrap_or_default())
-        .filter(|attr| attr.has_name(sym::cfg))
-        .peekable();
-    // If the item uses `doc(cfg(...))`, then we ignore the other `cfg(...)` attributes.
-    if doc_cfg.peek().is_some() {
-        let sess = tcx.sess;
-        // We overwrite existing `cfg`.
-        if !cfg_info.parent_is_doc_cfg {
-            cfg_info.current_cfg = Cfg::True;
-            cfg_info.parent_is_doc_cfg = true;
-        }
-        for attr in doc_cfg {
-            if let Some(cfg_mi) =
-                attr.meta_item().and_then(|attr| rustc_expand::config::parse_cfg(attr, sess))
-            {
-                match Cfg::parse(cfg_mi) {
-                    Ok(new_cfg) => cfg_info.current_cfg &= new_cfg,
-                    Err(e) => {
-                        sess.dcx().span_err(e.span, e.msg);
-                    }
-                }
-            }
-        }
-    } else {
-        cfg_info.parent_is_doc_cfg = false;
-    }
-
-    let mut changed_auto_active_status = None;
-
-    // We get all `doc(auto_cfg)`, `cfg` and `target_feature` attributes.
-    for attr in attrs {
-        if let Some(ident) = attr.ident()
-            && ident.name == sym::doc
-            && let Some(attrs) = attr.meta_item_list()
-        {
-            for attr in attrs.iter().filter(|attr| attr.has_name(sym::auto_cfg)) {
-                let MetaItemInner::MetaItem(attr) = attr else {
-                    continue;
-                };
-                match &attr.kind {
-                    MetaItemKind::Word => {
-                        if check_changed_auto_active_status(
-                            &mut changed_auto_active_status,
-                            attr,
-                            cfg_info,
-                            tcx,
-                            true,
-                        ) {
-                            return None;
-                        }
-                    }
-                    MetaItemKind::NameValue(lit) => {
-                        if let LitKind::Bool(value) = lit.kind {
-                            if check_changed_auto_active_status(
-                                &mut changed_auto_active_status,
-                                attr,
-                                cfg_info,
-                                tcx,
-                                value,
-                            ) {
-                                return None;
-                            }
-                        }
-                    }
-                    MetaItemKind::List(sub_attrs) => {
-                        if check_changed_auto_active_status(
-                            &mut changed_auto_active_status,
-                            attr,
-                            cfg_info,
-                            tcx,
-                            true,
-                        ) {
-                            return None;
-                        }
-                        for sub_attr in sub_attrs.iter() {
-                            if let Some(ident) = sub_attr.ident()
-                                && (ident.name == sym::show || ident.name == sym::hide)
-                            {
-                                handle_auto_cfg_hide_show(
-                                    tcx,
-                                    cfg_info,
-                                    &sub_attr,
-                                    ident.name == sym::show,
-                                    &mut new_show_attrs,
-                                    &mut new_hide_attrs,
-                                );
-                            }
-                        }
-                    }
-                }
-            }
-        } else if let hir::Attribute::Parsed(AttributeKind::TargetFeature { features, .. }) = attr {
-            // Treat `#[target_feature(enable = "feat")]` attributes as if they were
-            // `#[doc(cfg(target_feature = "feat"))]` attributes as well.
-            for (feature, _) in features {
-                cfg_info.current_cfg &= Cfg::Cfg(sym::target_feature, Some(*feature));
-            }
-            continue;
-        } else if !cfg_info.parent_is_doc_cfg
-            && let Some(ident) = attr.ident()
-            && matches!(ident.name, sym::cfg | sym::cfg_trace)
-            && let Some(attr) = single(attr.meta_item_list()?)
-            && let Ok(new_cfg) = Cfg::parse(&attr)
-        {
-            cfg_info.current_cfg &= new_cfg;
-        }
-    }
-
-    // If `doc(auto_cfg)` feature is disabled and `doc(cfg())` wasn't used, there is nothing
-    // to be done here.
-    if !cfg_info.auto_cfg_active && !cfg_info.parent_is_doc_cfg {
-        None
-    } else if cfg_info.parent_is_doc_cfg {
-        if cfg_info.current_cfg == Cfg::True {
-            None
-        } else {
-            Some(Arc::new(cfg_info.current_cfg.clone()))
-        }
-    } else {
-        // If `doc(auto_cfg)` feature is enabled, we want to collect all `cfg` items, we remove the
-        // hidden ones afterward.
-        match cfg_info.current_cfg.strip_hidden(&cfg_info.hidden_cfg) {
-            None | Some(Cfg::True) => None,
-            Some(cfg) => Some(Arc::new(cfg)),
-        }
-    }
-}
-
 pub(crate) trait NestedAttributesExt {
     /// Returns `true` if the attribute list contains a specific `word`
     fn has_word(self, word: Symbol) -> bool

From 7715c0d648cade90c172ee73ca26c8d80ff752f0 Mon Sep 17 00:00:00 2001
From: David Wood <david.wood2@arm.com>
Date: Thu, 2 Oct 2025 11:47:14 +0100
Subject: [PATCH 1666/1889] add arm-maintainers to various targets

---
 src/doc/rustc/src/SUMMARY.md                  |  2 +
 src/doc/rustc/src/platform-support.md         |  6 +--
 .../aarch64-unknown-linux-gnu.md              | 50 ++++++++++++++++++
 .../platform-support/aarch64-unknown-none.md  |  5 +-
 .../rustc/src/platform-support/arm-linux.md   |  4 +-
 .../armv7-unknown-linux-gnueabi.md            | 51 +++++++++++++++++++
 .../src/platform-support/armv7a-none-eabi.md  |  5 +-
 .../src/platform-support/armv7r-none-eabi.md  |  7 ++-
 .../platform-support/armv8r-none-eabihf.md    |  7 ++-
 .../platform-support/thumbv7em-none-eabi.md   |  6 ++-
 .../platform-support/thumbv7m-none-eabi.md    |  6 ++-
 .../thumbv8m.base-none-eabi.md                |  6 ++-
 .../thumbv8m.main-none-eabi.md                |  6 ++-
 .../src/platform-support/unknown-uefi.md      |  8 ++-
 14 files changed, 152 insertions(+), 17 deletions(-)
 create mode 100644 src/doc/rustc/src/platform-support/aarch64-unknown-linux-gnu.md
 create mode 100644 src/doc/rustc/src/platform-support/armv7-unknown-linux-gnueabi.md

diff --git a/src/doc/rustc/src/SUMMARY.md b/src/doc/rustc/src/SUMMARY.md
index 67882bb38132a..a9ce738a01387 100644
--- a/src/doc/rustc/src/SUMMARY.md
+++ b/src/doc/rustc/src/SUMMARY.md
@@ -47,6 +47,7 @@
     - [\*-apple-watchos](platform-support/apple-watchos.md)
     - [\*-apple-visionos](platform-support/apple-visionos.md)
     - [aarch64-nintendo-switch-freestanding](platform-support/aarch64-nintendo-switch-freestanding.md)
+    - [aarch64-unknown-linux-gnu](platform-support/aarch64-unknown-linux-gnu.md)
     - [aarch64-unknown-linux-musl](platform-support/aarch64-unknown-linux-musl.md)
     - [aarch64-unknown-none*](platform-support/aarch64-unknown-none.md)
     - [aarch64_be-unknown-none-softfloat](platform-support/aarch64_be-unknown-none-softfloat.md)
@@ -67,6 +68,7 @@
     - [arm\*-unknown-linux-\*](./platform-support/arm-linux.md)
         - [armeb-unknown-linux-gnueabi](platform-support/armeb-unknown-linux-gnueabi.md)
         - [armv5te-unknown-linux-gnueabi](platform-support/armv5te-unknown-linux-gnueabi.md)
+        - [armv7-unknown-linux-gnueabi](platform-support/armv7-unknown-linux-gnueabi.md)
         - [armv7-unknown-linux-uclibceabi](platform-support/armv7-unknown-linux-uclibceabi.md)
         - [armv7-unknown-linux-uclibceabihf](platform-support/armv7-unknown-linux-uclibceabihf.md)
     - [armv6k-nintendo-3ds](platform-support/armv6k-nintendo-3ds.md)
diff --git a/src/doc/rustc/src/platform-support.md b/src/doc/rustc/src/platform-support.md
index d0b6ed51bc163..263ea1ddb4250 100644
--- a/src/doc/rustc/src/platform-support.md
+++ b/src/doc/rustc/src/platform-support.md
@@ -34,7 +34,7 @@ target | notes
 -------|-------
 [`aarch64-apple-darwin`](platform-support/apple-darwin.md) | ARM64 macOS (11.0+, Big Sur+)
 [`aarch64-pc-windows-msvc`](platform-support/windows-msvc.md) | ARM64 Windows MSVC
-`aarch64-unknown-linux-gnu` | ARM64 Linux (kernel 4.1+, glibc 2.17+)
+[`aarch64-unknown-linux-gnu`](platform-support/aarch64-unknown-linux-gnu.md) | ARM64 Linux (kernel 4.1+, glibc 2.17+)
 [`i686-pc-windows-msvc`](platform-support/windows-msvc.md) | 32-bit MSVC (Windows 10+, Windows Server 2016+, Pentium 4) [^x86_32-floats-return-ABI] [^win32-msvc-alignment]
 `i686-unknown-linux-gnu` | 32-bit Linux (kernel 3.2+, glibc 2.17+, Pentium 4) [^x86_32-floats-return-ABI]
 [`x86_64-pc-windows-gnu`](platform-support/windows-gnu.md) | 64-bit MinGW (Windows 10+, Windows Server 2016+)
@@ -93,7 +93,7 @@ target | notes
 [`aarch64-unknown-linux-ohos`](platform-support/openharmony.md) | ARM64 OpenHarmony
 `arm-unknown-linux-gnueabi` | Armv6 Linux (kernel 3.2+, glibc 2.17)
 `arm-unknown-linux-gnueabihf` | Armv6 Linux, hardfloat (kernel 3.2+, glibc 2.17)
-`armv7-unknown-linux-gnueabihf` | Armv7-A Linux, hardfloat (kernel 3.2+, glibc 2.17)
+[`armv7-unknown-linux-gnueabihf`](platform-support/armv7-unknown-linux-gnueabi.md) | Armv7-A Linux, hardfloat (kernel 3.2+, glibc 2.17)
 [`armv7-unknown-linux-ohos`](platform-support/openharmony.md) | Armv7-A OpenHarmony
 [`loongarch64-unknown-linux-gnu`](platform-support/loongarch-linux.md) | LoongArch64 Linux, LP64D ABI (kernel 5.19+, glibc 2.36), LSX required
 [`loongarch64-unknown-linux-musl`](platform-support/loongarch-linux.md) | LoongArch64 Linux, LP64D ABI (kernel 5.19+, musl 1.2.5), LSX required
@@ -159,7 +159,7 @@ target | std | notes
 [`armv5te-unknown-linux-gnueabi`](platform-support/armv5te-unknown-linux-gnueabi.md) | ✓ | Armv5TE Linux (kernel 4.4+, glibc 2.23)
 `armv5te-unknown-linux-musleabi` | ✓ | Armv5TE Linux with musl 1.2.3
 [`armv7-linux-androideabi`](platform-support/android.md) | ✓ | Armv7-A Android
-`armv7-unknown-linux-gnueabi` | ✓ | Armv7-A Linux (kernel 4.15+, glibc 2.27)
+[`armv7-unknown-linux-gnueabi`](platform-support/armv7-unknown-linux-gnueabi.md) | ✓ | Armv7-A Linux (kernel 4.15+, glibc 2.27)
 `armv7-unknown-linux-musleabi` | ✓ | Armv7-A Linux with musl 1.2.3
 `armv7-unknown-linux-musleabihf` | ✓ | Armv7-A Linux with musl 1.2.3, hardfloat
 [`armv7a-none-eabi`](platform-support/armv7a-none-eabi.md) | * | Bare Armv7-A
diff --git a/src/doc/rustc/src/platform-support/aarch64-unknown-linux-gnu.md b/src/doc/rustc/src/platform-support/aarch64-unknown-linux-gnu.md
new file mode 100644
index 0000000000000..2003a3cb9eaa2
--- /dev/null
+++ b/src/doc/rustc/src/platform-support/aarch64-unknown-linux-gnu.md
@@ -0,0 +1,50 @@
+# `aarch64-unknown-linux-gnu`
+
+**Tier: 1 (with Host Tools)**
+
+Target for 64-bit little endian ARMv8-A Linux 4.1+ programs using glibc 2.17+.
+
+## Target maintainers
+
+- [@rust-lang/arm-maintainers][arm_maintainers] ([rust@arm.com][arm_email])
+
+[arm_maintainers]: https://github.com/rust-lang/team/blob/master/teams/arm-maintainers.toml
+[arm_email]: mailto:rust@arm.com
+
+## Requirements
+
+Building the target itself requires a 64-bit little endian ARMv8-A compiler that is supported by
+`cc-rs`.
+
+## Building the target
+
+The target can be built by enabling it for a `rustc` build:
+
+```toml
+[build]
+target = ["aarch64-unknown-linux-gnu"]
+```
+
+If cross-compiling, make sure your C compiler is included in `$PATH`, then add it to the
+`bootstrap.toml`:
+
+```toml
+[target.aarch64-unknown-linux-musl]
+cc = "aarch64-linux-gnu-gcc"
+cxx = "aarch64-linux-gnu-g++"
+ar = "aarch64-linux-gnu-ar"
+linker = "aarch64-linux-gnu-gcc"
+```
+
+## Building Rust programs
+
+This target is distributed through `rustup`, and otherwise requires no special configuration.
+
+## Cross-compilation
+
+This target can be cross-compiled from any host.
+
+## Testing
+
+This target can be tested as normal with `x.py` on a 64-bit little endian ARMv8-A host or via QEMU
+emulation.
diff --git a/src/doc/rustc/src/platform-support/aarch64-unknown-none.md b/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
index 7e18e8c157f74..3d776677d23e1 100644
--- a/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
+++ b/src/doc/rustc/src/platform-support/aarch64-unknown-none.md
@@ -14,9 +14,12 @@ Processors in this family include the [Arm Cortex-A35, 53, 76, etc][aarch64-cpus
 
 ## Target maintainers
 
-[Rust Embedded Devices Working Group Arm Team]
+- [Rust Embedded Devices Working Group Arm Team]
+- [@rust-lang/arm-maintainers][arm_maintainers] ([rust@arm.com][arm_email])
 
 [Rust Embedded Devices Working Group Arm Team]: https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team
+[arm_maintainers]: https://github.com/rust-lang/team/blob/master/teams/arm-maintainers.toml
+[arm_email]: mailto:rust@arm.com
 
 ## Target CPU and Target Feature options
 
diff --git a/src/doc/rustc/src/platform-support/arm-linux.md b/src/doc/rustc/src/platform-support/arm-linux.md
index 5f40743f3d070..c461a1a3403d5 100644
--- a/src/doc/rustc/src/platform-support/arm-linux.md
+++ b/src/doc/rustc/src/platform-support/arm-linux.md
@@ -14,8 +14,8 @@ Linux (but not Android). Those targets are:
 * [`armv5te-unknown-linux-gnueabi`](armv5te-unknown-linux-gnueabi.md)
 * `armv5te-unknown-linux-musleabi`
 * `armv5te-unknown-linux-uclibceabi`
-* `armv7-unknown-linux-gnueabi`
-* `armv7-unknown-linux-gnueabihf`
+* [`armv7-unknown-linux-gnueabi`](armv7-unknown-linux-gnueabi.md)
+* [`armv7-unknown-linux-gnueabihf`](armv7-unknown-linux-gnueabi.md)
 * `armv7-unknown-linux-musleabi`
 * `armv7-unknown-linux-musleabihf`
 * `armv7-unknown-linux-ohos`
diff --git a/src/doc/rustc/src/platform-support/armv7-unknown-linux-gnueabi.md b/src/doc/rustc/src/platform-support/armv7-unknown-linux-gnueabi.md
new file mode 100644
index 0000000000000..c2fe63a49087c
--- /dev/null
+++ b/src/doc/rustc/src/platform-support/armv7-unknown-linux-gnueabi.md
@@ -0,0 +1,51 @@
+# `armv7-unknown-linux-gnueabi` and `armv7-unknown-linux-gnueabihf`
+
+* **Tier: 2 (with Host Tools)** for `armv7-unknown-linux-gnueabihf`
+* **Tier: 2** for `armv7-unknown-linux-gnueabi`
+
+Target for 32-bit little endian ARMv7-A Linux 3.2+ programs using glibc 2.17+.
+
+## Target maintainers
+
+- [@rust-lang/arm-maintainers][arm_maintainers] ([rust@arm.com][arm_email])
+
+[arm_maintainers]: https://github.com/rust-lang/team/blob/master/teams/arm-maintainers.toml
+[arm_email]: mailto:rust@arm.com
+
+## Requirements
+
+Building the targets themselves requires a 32-bit little endian ARMv7-A compiler that is supported
+by `cc-rs`.
+
+## Building the target
+
+These targets can be built by enabling it for a `rustc` build:
+
+```toml
+[build]
+target = ["armv7-unknown-linux-gnueabihf", "armv7-unknown-linux-gnueabi"]
+```
+
+If cross-compiling, make sure your C compiler is included in `$PATH`, then add it to the
+`bootstrap.toml`:
+
+```toml
+[target.aarch64-unknown-linux-musl]
+cc = "arm-linux-gnu-gcc"
+cxx = "arm-linux-gnu-g++"
+ar = "arm-linux-gnu-ar"
+linker = "arm-linux-gnu-gcc"
+```
+
+## Building Rust programs
+
+These targets is distributed through `rustup`, and otherwise requires no special configuration.
+
+## Cross-compilation
+
+These targets can be cross-compiled from any host.
+
+## Testing
+
+These targets can be tested as normal with `x.py` on a 32-bit little endian ARMv7-A host or via
+QEMU emulation.
diff --git a/src/doc/rustc/src/platform-support/armv7a-none-eabi.md b/src/doc/rustc/src/platform-support/armv7a-none-eabi.md
index 3dadda86a5f54..22278a0a7dc71 100644
--- a/src/doc/rustc/src/platform-support/armv7a-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/armv7a-none-eabi.md
@@ -19,9 +19,12 @@ See [`arm-none-eabi`](arm-none-eabi.md) for information applicable to all
 
 ## Target maintainers
 
-[Rust Embedded Devices Working Group Arm Team]
+- [Rust Embedded Devices Working Group Arm Team]
+- [@rust-lang/arm-maintainers][arm_maintainers] ([rust@arm.com][arm_email])
 
 [Rust Embedded Devices Working Group Arm Team]: https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team
+[arm_maintainers]: https://github.com/rust-lang/team/blob/master/teams/arm-maintainers.toml
+[arm_email]: mailto:rust@arm.com
 
 ## Requirements
 
diff --git a/src/doc/rustc/src/platform-support/armv7r-none-eabi.md b/src/doc/rustc/src/platform-support/armv7r-none-eabi.md
index c1252b4a4bf57..9429eb6ab8aed 100644
--- a/src/doc/rustc/src/platform-support/armv7r-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/armv7r-none-eabi.md
@@ -15,10 +15,13 @@ See [`arm-none-eabi`](arm-none-eabi.md) for information applicable to all
 
 ## Target maintainers
 
-[@chrisnc](https://github.com/chrisnc)
-[Rust Embedded Devices Working Group Arm Team]
+- [@chrisnc](https://github.com/chrisnc)
+- [Rust Embedded Devices Working Group Arm Team]
+- [@rust-lang/arm-maintainers][arm_maintainers] ([rust@arm.com][arm_email])
 
 [Rust Embedded Devices Working Group Arm Team]: https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team
+[arm_maintainers]: https://github.com/rust-lang/team/blob/master/teams/arm-maintainers.toml
+[arm_email]: mailto:rust@arm.com
 
 ## Requirements
 
diff --git a/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md b/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md
index 0d5a36c3ee2d6..e465eb79f49d1 100644
--- a/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md
+++ b/src/doc/rustc/src/platform-support/armv8r-none-eabihf.md
@@ -17,10 +17,13 @@ See [`arm-none-eabi`](arm-none-eabi.md) for information applicable to all
 
 ## Target maintainers
 
-[@chrisnc](https://github.com/chrisnc)
-[Rust Embedded Devices Working Group Arm Team]
+- [@chrisnc](https://github.com/chrisnc)
+- [Rust Embedded Devices Working Group Arm Team]
+- [@rust-lang/arm-maintainers][arm_maintainers] ([rust@arm.com][arm_email])
 
 [Rust Embedded Devices Working Group Arm Team]: https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team
+[arm_maintainers]: https://github.com/rust-lang/team/blob/master/teams/arm-maintainers.toml
+[arm_email]: mailto:rust@arm.com
 
 ## Requirements
 
diff --git a/src/doc/rustc/src/platform-support/thumbv7em-none-eabi.md b/src/doc/rustc/src/platform-support/thumbv7em-none-eabi.md
index 98dcf9bd3968a..192e013d3a43f 100644
--- a/src/doc/rustc/src/platform-support/thumbv7em-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/thumbv7em-none-eabi.md
@@ -22,7 +22,11 @@ See [`arm-none-eabi`](arm-none-eabi.md) for information applicable to all
 
 ## Target maintainers
 
-[Rust Embedded Devices Working Group Arm Team](https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team)
+- [Rust Embedded Devices Working Group Arm Team](https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team)
+- [@rust-lang/arm-maintainers][arm_maintainers] ([rust@arm.com][arm_email])
+
+[arm_maintainers]: https://github.com/rust-lang/team/blob/master/teams/arm-maintainers.toml
+[arm_email]: mailto:rust@arm.com
 
 ## Target CPU and Target Feature options
 
diff --git a/src/doc/rustc/src/platform-support/thumbv7m-none-eabi.md b/src/doc/rustc/src/platform-support/thumbv7m-none-eabi.md
index d8f3970c8bfab..b04cb7bfacfac 100644
--- a/src/doc/rustc/src/platform-support/thumbv7m-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/thumbv7m-none-eabi.md
@@ -23,7 +23,11 @@ only option because there is no FPU support in [Armv7-M].
 
 ## Target maintainers
 
-[Rust Embedded Devices Working Group Arm Team](https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team)
+- [Rust Embedded Devices Working Group Arm Team](https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team)
+- [@rust-lang/arm-maintainers][arm_maintainers] ([rust@arm.com][arm_email])
+
+[arm_maintainers]: https://github.com/rust-lang/team/blob/master/teams/arm-maintainers.toml
+[arm_email]: mailto:rust@arm.com
 
 ## Target CPU and Target Feature options
 
diff --git a/src/doc/rustc/src/platform-support/thumbv8m.base-none-eabi.md b/src/doc/rustc/src/platform-support/thumbv8m.base-none-eabi.md
index b16d450275df5..104520854b49c 100644
--- a/src/doc/rustc/src/platform-support/thumbv8m.base-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/thumbv8m.base-none-eabi.md
@@ -23,7 +23,11 @@ only option because there is no FPU support in [Armv8-M] Baseline.
 
 ## Target maintainers
 
-[Rust Embedded Devices Working Group Arm Team](https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team)
+- [Rust Embedded Devices Working Group Arm Team](https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team)
+- [@rust-lang/arm-maintainers][arm_maintainers] ([rust@arm.com][arm_email])
+
+[arm_maintainers]: https://github.com/rust-lang/team/blob/master/teams/arm-maintainers.toml
+[arm_email]: mailto:rust@arm.com
 
 ## Target CPU and Target Feature options
 
diff --git a/src/doc/rustc/src/platform-support/thumbv8m.main-none-eabi.md b/src/doc/rustc/src/platform-support/thumbv8m.main-none-eabi.md
index a2d515d07ea0d..5cc535ce376b3 100644
--- a/src/doc/rustc/src/platform-support/thumbv8m.main-none-eabi.md
+++ b/src/doc/rustc/src/platform-support/thumbv8m.main-none-eabi.md
@@ -26,7 +26,11 @@ See [`arm-none-eabi`](arm-none-eabi.md) for information applicable to all
 
 ## Target maintainers
 
-[Rust Embedded Devices Working Group Arm Team](https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team)
+- [Rust Embedded Devices Working Group Arm Team](https://github.com/rust-embedded/wg?tab=readme-ov-file#the-arm-team)
+- [@rust-lang/arm-maintainers][arm_maintainers] ([rust@arm.com][arm_email])
+
+[arm_maintainers]: https://github.com/rust-lang/team/blob/master/teams/arm-maintainers.toml
+[arm_email]: mailto:rust@arm.com
 
 ## Target CPU and Target Feature options
 
diff --git a/src/doc/rustc/src/platform-support/unknown-uefi.md b/src/doc/rustc/src/platform-support/unknown-uefi.md
index 9587590d12d1c..e8989616b844b 100644
--- a/src/doc/rustc/src/platform-support/unknown-uefi.md
+++ b/src/doc/rustc/src/platform-support/unknown-uefi.md
@@ -13,8 +13,12 @@ Available targets:
 
 ## Target maintainers
 
-[@dvdhrm](https://github.com/dvdhrm)
-[@nicholasbishop](https://github.com/nicholasbishop)
+- [@dvdhrm](https://github.com/dvdhrm)
+- [@nicholasbishop](https://github.com/nicholasbishop)
+- (for `aarch64-unknown-uefi` only) [@rust-lang/arm-maintainers][arm_maintainers] ([rust@arm.com][arm_email])
+
+[arm_maintainers]: https://github.com/rust-lang/team/blob/master/teams/arm-maintainers.toml
+[arm_email]: mailto:rust@arm.com
 
 ## Requirements
 

From 78c2e58a7acb3a73e65b9ccfe4a73e79baa0d9ca Mon Sep 17 00:00:00 2001
From: Yotam Ofek <yotam.ofek@gmail.com>
Date: Wed, 1 Oct 2025 19:58:49 +0300
Subject: [PATCH 1667/1889] [rustdoc] Optimize "highlight::end_expansion"

---
 src/librustdoc/html/highlight.rs | 39 +++++++++++++-------------------
 1 file changed, 16 insertions(+), 23 deletions(-)

diff --git a/src/librustdoc/html/highlight.rs b/src/librustdoc/html/highlight.rs
index 1dcb4dcc3ff83..eeb916494d1e7 100644
--- a/src/librustdoc/html/highlight.rs
+++ b/src/librustdoc/html/highlight.rs
@@ -8,7 +8,7 @@
 use std::borrow::Cow;
 use std::collections::VecDeque;
 use std::fmt::{self, Display, Write};
-use std::iter;
+use std::{cmp, iter};
 
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_lexer::{Cursor, FrontmatterAllowed, LiteralKind, TokenKind};
@@ -345,33 +345,26 @@ fn end_expansion<'a, W: Write>(
         token_handler.pending_elems.push((Cow::Borrowed("</span>"), Some(Class::Expansion)));
         return Some(expanded_code);
     }
-    if expansion_start_tags.is_empty() && token_handler.closing_tags.is_empty() {
-        // No need tag opened so we can just close expansion.
-        token_handler.pending_elems.push((Cow::Borrowed("</span></span>"), Some(Class::Expansion)));
-        return None;
-    }
 
-    // If tags were opened inside the expansion, we need to close them and re-open them outside
-    // of the expansion span.
-    let mut out = String::new();
-    let mut end = String::new();
+    let skip = iter::zip(token_handler.closing_tags.as_slice(), expansion_start_tags)
+        .position(|(tag, start_tag)| tag != start_tag)
+        .unwrap_or_else(|| cmp::min(token_handler.closing_tags.len(), expansion_start_tags.len()));
 
-    let mut closing_tags = token_handler.closing_tags.iter().peekable();
-    let mut start_closing_tags = expansion_start_tags.iter().peekable();
+    let tags = iter::chain(
+        expansion_start_tags.iter().skip(skip),
+        token_handler.closing_tags.iter().skip(skip),
+    );
 
-    while let (Some(tag), Some(start_tag)) = (closing_tags.peek(), start_closing_tags.peek())
-        && tag == start_tag
-    {
-        closing_tags.next();
-        start_closing_tags.next();
+    let mut elem = Cow::Borrowed("</span></span>");
+
+    for (tag, _) in tags.clone() {
+        elem.to_mut().push_str(tag);
     }
-    for (tag, class) in start_closing_tags.chain(closing_tags) {
-        out.push_str(tag);
-        end.push_str(&format!("<span class=\"{}\">", class.as_html()));
+    for (_, class) in tags {
+        write!(elem.to_mut(), "<span class=\"{}\">", class.as_html()).unwrap();
     }
-    token_handler
-        .pending_elems
-        .push((Cow::Owned(format!("</span></span>{out}{end}")), Some(Class::Expansion)));
+
+    token_handler.pending_elems.push((elem, Some(Class::Expansion)));
     None
 }
 

From c61ec946d24c559708d4d57fbe860817e854c610 Mon Sep 17 00:00:00 2001
From: Pietro Albini <pietro.albini@ferrous-systems.com>
Date: Tue, 22 Apr 2025 14:39:59 +0200
Subject: [PATCH 1668/1889] implement range support in `//@ edition`

---
 src/tools/compiletest/src/common.rs           |   6 +-
 src/tools/compiletest/src/directives.rs       |  97 +++++++++++-
 src/tools/compiletest/src/directives/tests.rs | 142 +++++++++++++++++-
 src/tools/compiletest/src/edition.rs          |  35 +++++
 src/tools/compiletest/src/lib.rs              |   4 +-
 5 files changed, 270 insertions(+), 14 deletions(-)
 create mode 100644 src/tools/compiletest/src/edition.rs

diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
index 6d9599489180b..65db816ad1a87 100644
--- a/src/tools/compiletest/src/common.rs
+++ b/src/tools/compiletest/src/common.rs
@@ -7,6 +7,7 @@ use build_helper::git::GitConfig;
 use camino::{Utf8Path, Utf8PathBuf};
 use semver::Version;
 
+use crate::edition::Edition;
 use crate::executor::ColorConfig;
 use crate::fatal;
 use crate::util::{Utf8PathBufExt, add_dylib_path, string_enum};
@@ -612,10 +613,7 @@ pub struct Config {
     pub git_hash: bool,
 
     /// The default Rust edition.
-    ///
-    /// FIXME: perform stronger validation for this. There are editions that *definitely* exists,
-    /// but there might also be "future" edition.
-    pub edition: Option<String>,
+    pub edition: Option<Edition>,
 
     // Configuration for various run-make tests frobbing things like C compilers or querying about
     // various LLVM component information.
diff --git a/src/tools/compiletest/src/directives.rs b/src/tools/compiletest/src/directives.rs
index 0d85e76c2cc09..a79978d036cea 100644
--- a/src/tools/compiletest/src/directives.rs
+++ b/src/tools/compiletest/src/directives.rs
@@ -16,10 +16,11 @@ use crate::directives::directive_names::{
     KNOWN_DIRECTIVE_NAMES, KNOWN_HTMLDOCCK_DIRECTIVE_NAMES, KNOWN_JSONDOCCK_DIRECTIVE_NAMES,
 };
 use crate::directives::needs::CachedNeedsConditions;
+use crate::edition::{Edition, parse_edition};
 use crate::errors::ErrorKind;
 use crate::executor::{CollectedTestDesc, ShouldPanic};
-use crate::help;
 use crate::util::static_regex;
+use crate::{fatal, help};
 
 pub(crate) mod auxiliary;
 mod cfg;
@@ -437,10 +438,13 @@ impl TestProps {
                         panic!("`compiler-flags` directive should be spelled `compile-flags`");
                     }
 
-                    if let Some(edition) = config.parse_edition(ln, testfile) {
+                    if let Some(range) = parse_edition_range(config, ln, testfile) {
                         // The edition is added at the start, since flags from //@compile-flags must
                         // be passed to rustc last.
-                        self.compile_flags.insert(0, format!("--edition={}", edition.trim()));
+                        self.compile_flags.insert(
+                            0,
+                            format!("--edition={}", range.edition_to_test(config.edition)),
+                        );
                         has_edition = true;
                     }
 
@@ -1124,10 +1128,6 @@ impl Config {
         }
     }
 
-    fn parse_edition(&self, line: &DirectiveLine<'_>, testfile: &Utf8Path) -> Option<String> {
-        self.parse_name_value_directive(line, "edition", testfile)
-    }
-
     fn set_name_directive(&self, line: &DirectiveLine<'_>, directive: &str, value: &mut bool) {
         // If the flag is already true, don't bother looking at the directive.
         *value = *value || self.parse_name_directive(line, directive);
@@ -1769,3 +1769,86 @@ enum IgnoreDecision {
     Continue,
     Error { message: String },
 }
+
+fn parse_edition_range(
+    config: &Config,
+    line: &DirectiveLine<'_>,
+    testfile: &Utf8Path,
+) -> Option<EditionRange> {
+    let raw = config.parse_name_value_directive(line, "edition", testfile)?;
+    let line_number = line.line_number;
+
+    // Edition range is half-open: `[lower_bound, upper_bound)`
+    if let Some((lower_bound, upper_bound)) = raw.split_once("..") {
+        Some(match (maybe_parse_edition(lower_bound), maybe_parse_edition(upper_bound)) {
+            (Some(lower_bound), Some(upper_bound)) if upper_bound <= lower_bound => {
+                fatal!(
+                    "{testfile}:{line_number}: the left side of `//@ edition` cannot be greater than or equal to the right side"
+                );
+            }
+            (Some(lower_bound), Some(upper_bound)) => {
+                EditionRange::Range { lower_bound, upper_bound }
+            }
+            (Some(lower_bound), None) => EditionRange::RangeFrom(lower_bound),
+            (None, Some(_)) => {
+                fatal!(
+                    "{testfile}:{line_number}: `..edition` is not a supported range in `//@ edition`"
+                );
+            }
+            (None, None) => {
+                fatal!("{testfile}:{line_number}: `..` is not a supported range in `//@ edition`");
+            }
+        })
+    } else {
+        match maybe_parse_edition(&raw) {
+            Some(edition) => Some(EditionRange::Exact(edition)),
+            None => {
+                fatal!("{testfile}:{line_number}: empty value for `//@ edition`");
+            }
+        }
+    }
+}
+
+fn maybe_parse_edition(mut input: &str) -> Option<Edition> {
+    input = input.trim();
+    if input.is_empty() {
+        return None;
+    }
+    Some(parse_edition(input))
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+enum EditionRange {
+    Exact(Edition),
+    RangeFrom(Edition),
+    /// Half-open range: `[lower_bound, upper_bound)`
+    Range {
+        lower_bound: Edition,
+        upper_bound: Edition,
+    },
+}
+
+impl EditionRange {
+    fn edition_to_test(&self, requested: impl Into<Option<Edition>>) -> Edition {
+        let min_edition = Edition::Year(2015);
+        let requested = requested.into().unwrap_or(min_edition);
+
+        match *self {
+            EditionRange::Exact(exact) => exact,
+            EditionRange::RangeFrom(lower_bound) => {
+                if requested >= lower_bound {
+                    requested
+                } else {
+                    lower_bound
+                }
+            }
+            EditionRange::Range { lower_bound, upper_bound } => {
+                if requested >= lower_bound && requested < upper_bound {
+                    requested
+                } else {
+                    lower_bound
+                }
+            }
+        }
+    }
+}
diff --git a/src/tools/compiletest/src/directives/tests.rs b/src/tools/compiletest/src/directives/tests.rs
index 16cf76be9a53f..93621192d4bd6 100644
--- a/src/tools/compiletest/src/directives/tests.rs
+++ b/src/tools/compiletest/src/directives/tests.rs
@@ -4,10 +4,11 @@ use camino::Utf8Path;
 use semver::Version;
 
 use super::{
-    DirectivesCache, EarlyProps, extract_llvm_version, extract_version_range, iter_directives,
-    parse_normalize_rule,
+    DirectivesCache, EarlyProps, Edition, EditionRange, extract_llvm_version,
+    extract_version_range, iter_directives, parse_normalize_rule,
 };
 use crate::common::{Config, Debugger, TestMode};
+use crate::directives::parse_edition;
 use crate::executor::{CollectedTestDesc, ShouldPanic};
 
 fn make_test_description<R: Read>(
@@ -73,6 +74,7 @@ fn test_parse_normalize_rule() {
 struct ConfigBuilder {
     mode: Option<String>,
     channel: Option<String>,
+    edition: Option<Edition>,
     host: Option<String>,
     target: Option<String>,
     stage: Option<u32>,
@@ -96,6 +98,11 @@ impl ConfigBuilder {
         self
     }
 
+    fn edition(&mut self, e: Edition) -> &mut Self {
+        self.edition = Some(e);
+        self
+    }
+
     fn host(&mut self, s: &str) -> &mut Self {
         self.host = Some(s.to_owned());
         self
@@ -183,6 +190,10 @@ impl ConfigBuilder {
         ];
         let mut args: Vec<String> = args.iter().map(ToString::to_string).collect();
 
+        if let Some(edition) = &self.edition {
+            args.push(format!("--edition={edition}"));
+        }
+
         if let Some(ref llvm_version) = self.llvm_version {
             args.push("--llvm-version".to_owned());
             args.push(llvm_version.clone());
@@ -941,3 +952,130 @@ fn test_needs_target_std() {
     let config = cfg().target("x86_64-unknown-linux-gnu").build();
     assert!(!check_ignore(&config, "//@ needs-target-std"));
 }
+
+fn parse_edition_range(line: &str) -> Option<EditionRange> {
+    let config = cfg().build();
+    let line = super::DirectiveLine { line_number: 0, revision: None, raw_directive: line };
+
+    super::parse_edition_range(&config, &line, "tmp.rs".into())
+}
+
+#[test]
+fn test_parse_edition_range() {
+    assert_eq!(None, parse_edition_range("hello-world"));
+    assert_eq!(None, parse_edition_range("edition"));
+
+    assert_eq!(Some(EditionRange::Exact(2018.into())), parse_edition_range("edition: 2018"));
+    assert_eq!(Some(EditionRange::Exact(2021.into())), parse_edition_range("edition:2021"));
+    assert_eq!(Some(EditionRange::Exact(2024.into())), parse_edition_range("edition: 2024 "));
+    assert_eq!(Some(EditionRange::Exact(Edition::Future)), parse_edition_range("edition: future"));
+
+    assert_eq!(Some(EditionRange::RangeFrom(2018.into())), parse_edition_range("edition: 2018.."));
+    assert_eq!(Some(EditionRange::RangeFrom(2021.into())), parse_edition_range("edition:2021 .."));
+    assert_eq!(
+        Some(EditionRange::RangeFrom(2024.into())),
+        parse_edition_range("edition: 2024 .. ")
+    );
+    assert_eq!(
+        Some(EditionRange::RangeFrom(Edition::Future)),
+        parse_edition_range("edition: future.. ")
+    );
+
+    assert_eq!(
+        Some(EditionRange::Range { lower_bound: 2018.into(), upper_bound: 2024.into() }),
+        parse_edition_range("edition: 2018..2024")
+    );
+    assert_eq!(
+        Some(EditionRange::Range { lower_bound: 2015.into(), upper_bound: 2021.into() }),
+        parse_edition_range("edition:2015 .. 2021 ")
+    );
+    assert_eq!(
+        Some(EditionRange::Range { lower_bound: 2021.into(), upper_bound: 2027.into() }),
+        parse_edition_range("edition: 2021 .. 2027 ")
+    );
+    assert_eq!(
+        Some(EditionRange::Range { lower_bound: 2021.into(), upper_bound: Edition::Future }),
+        parse_edition_range("edition: 2021..future")
+    );
+}
+
+#[test]
+#[should_panic]
+fn test_parse_edition_range_empty() {
+    parse_edition_range("edition:");
+}
+
+#[test]
+#[should_panic]
+fn test_parse_edition_range_invalid_edition() {
+    parse_edition_range("edition: hello");
+}
+
+#[test]
+#[should_panic]
+fn test_parse_edition_range_double_dots() {
+    parse_edition_range("edition: ..");
+}
+
+#[test]
+#[should_panic]
+fn test_parse_edition_range_inverted_range() {
+    parse_edition_range("edition: 2021..2015");
+}
+
+#[test]
+#[should_panic]
+fn test_parse_edition_range_inverted_range_future() {
+    parse_edition_range("edition: future..2015");
+}
+
+#[test]
+#[should_panic]
+fn test_parse_edition_range_empty_range() {
+    parse_edition_range("edition: 2021..2021");
+}
+
+#[track_caller]
+fn assert_edition_to_test(
+    expected: impl Into<Edition>,
+    range: EditionRange,
+    default: Option<Edition>,
+) {
+    let mut cfg = cfg();
+    if let Some(default) = default {
+        cfg.edition(default);
+    }
+    assert_eq!(expected.into(), range.edition_to_test(cfg.build().edition));
+}
+
+#[test]
+fn test_edition_range_edition_to_test() {
+    let e2015 = parse_edition("2015");
+    let e2018 = parse_edition("2018");
+    let e2021 = parse_edition("2021");
+    let e2024 = parse_edition("2024");
+    let efuture = parse_edition("future");
+
+    let exact = EditionRange::Exact(2021.into());
+    assert_edition_to_test(2021, exact, None);
+    assert_edition_to_test(2021, exact, Some(e2018));
+    assert_edition_to_test(2021, exact, Some(efuture));
+
+    assert_edition_to_test(Edition::Future, EditionRange::Exact(Edition::Future), None);
+
+    let greater_equal_than = EditionRange::RangeFrom(2021.into());
+    assert_edition_to_test(2021, greater_equal_than, None);
+    assert_edition_to_test(2021, greater_equal_than, Some(e2015));
+    assert_edition_to_test(2021, greater_equal_than, Some(e2018));
+    assert_edition_to_test(2021, greater_equal_than, Some(e2021));
+    assert_edition_to_test(2024, greater_equal_than, Some(e2024));
+    assert_edition_to_test(Edition::Future, greater_equal_than, Some(efuture));
+
+    let range = EditionRange::Range { lower_bound: 2018.into(), upper_bound: 2024.into() };
+    assert_edition_to_test(2018, range, None);
+    assert_edition_to_test(2018, range, Some(e2015));
+    assert_edition_to_test(2018, range, Some(e2018));
+    assert_edition_to_test(2021, range, Some(e2021));
+    assert_edition_to_test(2018, range, Some(e2024));
+    assert_edition_to_test(2018, range, Some(efuture));
+}
diff --git a/src/tools/compiletest/src/edition.rs b/src/tools/compiletest/src/edition.rs
new file mode 100644
index 0000000000000..36550cf5b2b95
--- /dev/null
+++ b/src/tools/compiletest/src/edition.rs
@@ -0,0 +1,35 @@
+use crate::fatal;
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum Edition {
+    // Note that the ordering here is load-bearing, as we want the future edition to be greater than
+    // any year-based edition.
+    Year(u32),
+    Future,
+}
+
+impl std::fmt::Display for Edition {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Edition::Year(year) => write!(f, "{year}"),
+            Edition::Future => f.write_str("future"),
+        }
+    }
+}
+
+impl From<u32> for Edition {
+    fn from(value: u32) -> Self {
+        Edition::Year(value)
+    }
+}
+
+pub fn parse_edition(mut input: &str) -> Edition {
+    input = input.trim();
+    if input == "future" {
+        Edition::Future
+    } else {
+        Edition::Year(input.parse().unwrap_or_else(|_| {
+            fatal!("`{input}` doesn't look like an edition");
+        }))
+    }
+}
diff --git a/src/tools/compiletest/src/lib.rs b/src/tools/compiletest/src/lib.rs
index 15e31dadf9711..2d759279f34bc 100644
--- a/src/tools/compiletest/src/lib.rs
+++ b/src/tools/compiletest/src/lib.rs
@@ -7,6 +7,7 @@ pub mod common;
 mod debuggers;
 pub mod diagnostics;
 pub mod directives;
+pub mod edition;
 pub mod errors;
 mod executor;
 mod json;
@@ -39,6 +40,7 @@ use crate::common::{
     expected_output_path, output_base_dir, output_relative_path,
 };
 use crate::directives::DirectivesCache;
+use crate::edition::parse_edition;
 use crate::executor::{CollectedTest, ColorConfig};
 
 /// Creates the `Config` instance for this invocation of compiletest.
@@ -449,7 +451,7 @@ pub fn parse_config(args: Vec<String>) -> Config {
         has_enzyme,
         channel: matches.opt_str("channel").unwrap(),
         git_hash: matches.opt_present("git-hash"),
-        edition: matches.opt_str("edition"),
+        edition: matches.opt_str("edition").as_deref().map(parse_edition),
 
         cc: matches.opt_str("cc").unwrap(),
         cxx: matches.opt_str("cxx").unwrap(),

From 6631c8ef5569920daba2e4ac46ac783b3a7c9c47 Mon Sep 17 00:00:00 2001
From: Christian Poveda <christian.poveda@ferrous-systems.com>
Date: Sun, 21 Sep 2025 16:56:04 -0500
Subject: [PATCH 1669/1889] Document range syntax on the rustc dev guide

---
 src/doc/rustc-dev-guide/src/tests/directives.md | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/src/doc/rustc-dev-guide/src/tests/directives.md b/src/doc/rustc-dev-guide/src/tests/directives.md
index 4be78fac4ec7f..3b6c891746455 100644
--- a/src/doc/rustc-dev-guide/src/tests/directives.md
+++ b/src/doc/rustc-dev-guide/src/tests/directives.md
@@ -262,6 +262,20 @@ Consider writing the test as a proper incremental test instead.
 
 </div>
 
+#### The edition directive
+
+The `//@ edition` directive can take an exact edition, a bounded half-open range of editions or a left-bounded half-open range of editions, this affects which edition is used by `./x test` to run the test. For example:
+
+- A test with the `//@ edition: 2018` directive will only run under the 2018 edition.
+- A test with the `//@ edition: 2015..2021` directive can be run under both the 2015 and 2018 editions. However, CI will only run the test with the lowest edition possible (2015 in this case).
+- A test with the `//@ edition: 2018..` directive will run under any edition greater or equal than 2018. However, CI will only run the test with the lowest edition possible (2018 in this case).
+
+You can also force `./x test` to use a specific edition by passing the `-- --edition=` argument. However, tests with the `//@ edition` directive will clamp the value passed to the argument. For example, if we run `./x test -- --edition=2015`:
+
+- A test with the `//@ edition: 2018` will run with the 2018 edition. 
+- A test with the `//@ edition: 2015..2021` will be run with the 2015 edition. 
+- A test with the `//@ edition: 2018..` will run with the 2018 edition. 
+
 ### Rustdoc
 
 | Directive   | Explanation                                                  | Supported test suites                   | Possible values           |

From fe66eaa67acc47525db6f13cf97d54780d87b805 Mon Sep 17 00:00:00 2001
From: Martin Nordholts <martin.nordholts@codetale.se>
Date: Mon, 7 Jul 2025 22:36:23 +0200
Subject: [PATCH 1670/1889] Fix backtraces with `-C panic=abort` on linux; emit
 unwind tables by default

The linux backtrace unwinder relies on unwind tables to work properly,
and generating and printing a backtrace is done by for example the
default panic hook.

Begin emitting unwind tables by default again with `-C panic=abort` (see
history below) so that backtraces work.

History
=======

Backtraces with `-C panic=abort` used to work in Rust 1.22 but broke in
Rust 1.23, because in 1.23 we stopped emitting unwind tables with `-C
panic=abort` (see 24cc38e3b00).

In 1.45 (see cda994633ee) a workaround in the form
of `-C force-unwind-tables=yes` was added.

`-C panic=abort` was added in [Rust
1.10](https://blog.rust-lang.org/2016/07/07/Rust-1.10/#what-s-in-1-10-stable)
and the motivation was binary size and compile time. But given how
confusing that behavior has turned out to be, it is better to make
binary size optimization opt-in with `-C force-unwind-tables=no` rather
than default since the current default breaks backtraces.

Besides, if binary size is a primary concern, there are many other
tricks that can be used that has a higher impact.
---
 compiler/rustc_session/src/session.rs         |  3 +-
 .../rustc_target/src/spec/base/android.rs     |  4 --
 compiler/rustc_target/src/spec/base/linux.rs  |  3 +
 .../targets/arm_unknown_linux_gnueabihf.rs    |  5 ++
 tests/run-make/panic-abort-eh_frame/rmake.rs  | 11 ++--
 ...panic-abort-backtrace-without-debuginfo.rs | 57 +++++++++++++++++++
 6 files changed, 74 insertions(+), 9 deletions(-)
 create mode 100644 tests/ui/panics/panic-abort-backtrace-without-debuginfo.rs

diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
index 25b46241c52df..172672a80fbd7 100644
--- a/compiler/rustc_session/src/session.rs
+++ b/compiler/rustc_session/src/session.rs
@@ -758,7 +758,8 @@ impl Session {
         //     ELF x86-64 abi, but it can be disabled for some compilation units.
         //
         // Typically when we're compiling with `-C panic=abort` we don't need
-        // `uwtable` because we can't generate any exceptions!
+        // `uwtable` because we can't generate any exceptions! But note that
+        // some targets require unwind tables to generate backtraces.
         // Unwind tables are needed when compiling with `-C panic=unwind`, but
         // LLVM won't omit unwind tables unless the function is also marked as
         // `nounwind`, so users are allowed to disable `uwtable` emission.
diff --git a/compiler/rustc_target/src/spec/base/android.rs b/compiler/rustc_target/src/spec/base/android.rs
index 0426ea44c6a21..df2757aaabf65 100644
--- a/compiler/rustc_target/src/spec/base/android.rs
+++ b/compiler/rustc_target/src/spec/base/android.rs
@@ -8,10 +8,6 @@ pub(crate) fn opts() -> TargetOptions {
     base.tls_model = TlsModel::Emulated;
     base.has_thread_local = false;
     base.supported_sanitizers = SanitizerSet::ADDRESS;
-    // This is for backward compatibility, see https://github.com/rust-lang/rust/issues/49867
-    // for context. (At that time, there was no `-C force-unwind-tables`, so the only solution
-    // was to always emit `uwtable`).
-    base.default_uwtable = true;
     base.crt_static_respected = true;
     base
 }
diff --git a/compiler/rustc_target/src/spec/base/linux.rs b/compiler/rustc_target/src/spec/base/linux.rs
index 9982c254eca52..26e4590cf5e69 100644
--- a/compiler/rustc_target/src/spec/base/linux.rs
+++ b/compiler/rustc_target/src/spec/base/linux.rs
@@ -12,6 +12,9 @@ pub(crate) fn opts() -> TargetOptions {
         relro_level: RelroLevel::Full,
         has_thread_local: true,
         crt_static_respected: true,
+        // We want backtraces to work by default and they rely on unwind tables
+        // (regardless of `-C panic` strategy).
+        default_uwtable: true,
         supported_split_debuginfo: Cow::Borrowed(&[
             SplitDebuginfo::Packed,
             SplitDebuginfo::Unpacked,
diff --git a/compiler/rustc_target/src/spec/targets/arm_unknown_linux_gnueabihf.rs b/compiler/rustc_target/src/spec/targets/arm_unknown_linux_gnueabihf.rs
index a3f5389f0aa76..0c711d5e71ab4 100644
--- a/compiler/rustc_target/src/spec/targets/arm_unknown_linux_gnueabihf.rs
+++ b/compiler/rustc_target/src/spec/targets/arm_unknown_linux_gnueabihf.rs
@@ -19,6 +19,11 @@ pub(crate) fn target() -> Target {
             max_atomic_width: Some(64),
             mcount: "\u{1}__gnu_mcount_nc".into(),
             llvm_mcount_intrinsic: Some("llvm.arm.gnu.eabi.mcount".into()),
+            // The default on linux is to have `default_uwtable=true`, but on
+            // this target we get an "`__aeabi_unwind_cpp_pr0` not defined"
+            // linker error, so set it to `true` here.
+            // FIXME(#146996): Remove this override once #146996 has been fixed.
+            default_uwtable: false,
             ..base::linux_gnu::opts()
         },
     }
diff --git a/tests/run-make/panic-abort-eh_frame/rmake.rs b/tests/run-make/panic-abort-eh_frame/rmake.rs
index 23d95dc577491..2eccde627955c 100644
--- a/tests/run-make/panic-abort-eh_frame/rmake.rs
+++ b/tests/run-make/panic-abort-eh_frame/rmake.rs
@@ -1,9 +1,11 @@
 // An `.eh_frame` section in an object file is a symptom of an UnwindAction::Terminate
 // being inserted, useful for determining whether or not unwinding is necessary.
-// This is useless when panics would NEVER unwind due to -C panic=abort. This section should
-// therefore never appear in the emit file of a -C panic=abort compilation, and this test
-// checks that this is respected.
-// See https://github.com/rust-lang/rust/pull/112403
+// This is useless when panics would NEVER unwind due to -C panic=abort and when we don't need
+// being able to generate backtraces (which depend on unwind tables on linux). This section should
+// therefore never appear in the emit file of a -C panic=abort compilation
+// with -C force-unwind-tables=no, and this test checks that this is respected.
+// See https://github.com/rust-lang/rust/pull/112403 and
+// https://github.com/rust-lang/rust/pull/143613.
 
 //@ only-linux
 // FIXME(Oneirical): the DW_CFA symbol appears on Windows-gnu, because uwtable
@@ -19,6 +21,7 @@ fn main() {
         .panic("abort")
         .edition("2021")
         .arg("-Zvalidate-mir")
+        .arg("-Cforce-unwind-tables=no")
         .run();
     llvm_objdump().arg("--dwarf=frames").input("foo.o").run().assert_stdout_not_contains("DW_CFA");
 }
diff --git a/tests/ui/panics/panic-abort-backtrace-without-debuginfo.rs b/tests/ui/panics/panic-abort-backtrace-without-debuginfo.rs
new file mode 100644
index 0000000000000..a29afd68523be
--- /dev/null
+++ b/tests/ui/panics/panic-abort-backtrace-without-debuginfo.rs
@@ -0,0 +1,57 @@
+//! Test that with `-C panic=abort` the backtrace is not cut off by default
+//! (i.e. without using `-C force-unwind-tables=yes`) by ensuring that our own
+//! functions are in the backtrace. If we just check one function it might be
+//! the last function, so make sure the backtrace can continue by checking for
+//! two functions. Regression test for
+//! <https://github.com/rust-lang/rust/issues/81902>.
+
+//@ run-pass
+//@ needs-subprocess
+// We want to test if unwind tables are emitted by default. We must make sure
+// to disable debuginfo to test that, because enabling debuginfo also means that
+// unwind tables are emitted, which prevents us from testing what we want.
+// We also need to set opt-level=0 to avoid optimizing away our functions.
+//@ compile-flags: -C panic=abort -C opt-level=0 -C debuginfo=0
+//@ no-prefer-dynamic
+//@ ignore-apple
+//@ ignore-arm-unknown-linux-gnueabihf FIXME(#146996) Try removing this once #146996 has been fixed.
+//@ ignore-msvc Backtraces on Windows requires debuginfo which we can't use here
+
+static FN_1: &str = "this_function_must_be_in_the_backtrace";
+fn this_function_must_be_in_the_backtrace() {
+    and_this_function_too();
+}
+
+static FN_2: &str = "and_this_function_too";
+fn and_this_function_too() {
+    panic!("generate panic backtrace");
+}
+
+fn run_test() {
+    let output = std::process::Command::new(std::env::current_exe().unwrap())
+        .arg("whatever")
+        .env("RUST_BACKTRACE", "full")
+        .output()
+        .unwrap();
+    let backtrace = std::str::from_utf8(&output.stderr).unwrap();
+
+    fn assert(function_name: &str, backtrace: &str) {
+        assert!(
+            backtrace.contains(function_name),
+            "ERROR: no `{}` in stderr! actual stderr: {}",
+            function_name,
+            backtrace
+        );
+    }
+    assert(FN_1, backtrace);
+    assert(FN_2, backtrace);
+}
+
+fn main() {
+    let args: Vec<String> = std::env::args().collect();
+    if args.len() == 1 {
+        run_test();
+    } else {
+        this_function_must_be_in_the_backtrace();
+    }
+}

From 5a8f963426c72c5bd306b2620a6c148b720217d0 Mon Sep 17 00:00:00 2001
From: Karol Zwolak <karolzwolak7@gmail.com>
Date: Thu, 2 Oct 2025 20:13:18 +0200
Subject: [PATCH 1671/1889] fix wording; we're replacing coma with a bar

---
 ...ixed => only-replace-intended-coma-not-all-in-pattern.fixed} | 2 +-
 ...tern.rs => only-replace-intended-coma-not-all-in-pattern.rs} | 2 +-
 ...err => only-replace-intended-coma-not-all-in-pattern.stderr} | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)
 rename tests/ui/suggestions/{only-replace-intended-bar-not-all-in-pattern.fixed => only-replace-intended-coma-not-all-in-pattern.fixed} (84%)
 rename tests/ui/suggestions/{only-replace-intended-bar-not-all-in-pattern.rs => only-replace-intended-coma-not-all-in-pattern.rs} (84%)
 rename tests/ui/suggestions/{only-replace-intended-bar-not-all-in-pattern.stderr => only-replace-intended-coma-not-all-in-pattern.stderr} (89%)

diff --git a/tests/ui/suggestions/only-replace-intended-bar-not-all-in-pattern.fixed b/tests/ui/suggestions/only-replace-intended-coma-not-all-in-pattern.fixed
similarity index 84%
rename from tests/ui/suggestions/only-replace-intended-bar-not-all-in-pattern.fixed
rename to tests/ui/suggestions/only-replace-intended-coma-not-all-in-pattern.fixed
index 5abc1edd381bf..0258f868f0072 100644
--- a/tests/ui/suggestions/only-replace-intended-bar-not-all-in-pattern.fixed
+++ b/tests/ui/suggestions/only-replace-intended-coma-not-all-in-pattern.fixed
@@ -1,7 +1,7 @@
 //@ run-rustfix
 
 // Regression test for issue #143330.
-// Ensure we suggest to replace only the intended bar with a comma, not all bars in the pattern.
+// Ensure we suggest to replace only the intended coma with a bar, not all commas in the pattern.
 
 fn main() {
     struct Foo { x: i32, ch: char }
diff --git a/tests/ui/suggestions/only-replace-intended-bar-not-all-in-pattern.rs b/tests/ui/suggestions/only-replace-intended-coma-not-all-in-pattern.rs
similarity index 84%
rename from tests/ui/suggestions/only-replace-intended-bar-not-all-in-pattern.rs
rename to tests/ui/suggestions/only-replace-intended-coma-not-all-in-pattern.rs
index 5bd267c3bc402..7d5087fa0ffae 100644
--- a/tests/ui/suggestions/only-replace-intended-bar-not-all-in-pattern.rs
+++ b/tests/ui/suggestions/only-replace-intended-coma-not-all-in-pattern.rs
@@ -1,7 +1,7 @@
 //@ run-rustfix
 
 // Regression test for issue #143330.
-// Ensure we suggest to replace only the intended bar with a comma, not all bars in the pattern.
+// Ensure we suggest to replace only the intended coma with a bar, not all commas in the pattern.
 
 fn main() {
     struct Foo { x: i32, ch: char }
diff --git a/tests/ui/suggestions/only-replace-intended-bar-not-all-in-pattern.stderr b/tests/ui/suggestions/only-replace-intended-coma-not-all-in-pattern.stderr
similarity index 89%
rename from tests/ui/suggestions/only-replace-intended-bar-not-all-in-pattern.stderr
rename to tests/ui/suggestions/only-replace-intended-coma-not-all-in-pattern.stderr
index db0bb8c50e865..050f1b8a2b33a 100644
--- a/tests/ui/suggestions/only-replace-intended-bar-not-all-in-pattern.stderr
+++ b/tests/ui/suggestions/only-replace-intended-coma-not-all-in-pattern.stderr
@@ -1,5 +1,5 @@
 error: unexpected `,` in pattern
-  --> $DIR/only-replace-intended-bar-not-all-in-pattern.rs:12:30
+  --> $DIR/only-replace-intended-coma-not-all-in-pattern.rs:12:30
    |
 LL |         Foo { x: 2, ch: ',' }, Foo { x: 3, ch: '@' } => (),
    |                              ^

From d1d7b9472a18780499162b4a91beea729bc2c13b Mon Sep 17 00:00:00 2001
From: Karol Zwolak <karolzwolak7@gmail.com>
Date: Thu, 2 Oct 2025 20:24:34 +0200
Subject: [PATCH 1672/1889] bring back plural 'alternatives' in suggestion
 message

---
 compiler/rustc_parse/src/parser/diagnostics.rs                | 2 +-
 .../issue-48492-tuple-destructure-missing-parens.stderr       | 2 +-
 tests/ui/feature-gates/feature-gate-never_patterns.stderr     | 2 +-
 tests/ui/parser/match-arm-without-body.stderr                 | 4 ++--
 .../only-replace-intended-coma-not-all-in-pattern.stderr      | 2 +-
 5 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs
index 5d6da60931200..1cb1618e5844b 100644
--- a/compiler/rustc_parse/src/parser/diagnostics.rs
+++ b/compiler/rustc_parse/src/parser/diagnostics.rs
@@ -2961,7 +2961,7 @@ impl<'a> Parser<'a> {
         if let CommaRecoveryMode::EitherTupleOrPipe = rt {
             err.span_suggestion(
                 comma_span,
-                "...or a vertical bar to match on alternative",
+                "...or a vertical bar to match on alternatives",
                 " |",
                 Applicability::MachineApplicable,
             );
diff --git a/tests/ui/did_you_mean/issue-48492-tuple-destructure-missing-parens.stderr b/tests/ui/did_you_mean/issue-48492-tuple-destructure-missing-parens.stderr
index dc875ad27ea6e..286d602139665 100644
--- a/tests/ui/did_you_mean/issue-48492-tuple-destructure-missing-parens.stderr
+++ b/tests/ui/did_you_mean/issue-48492-tuple-destructure-missing-parens.stderr
@@ -32,7 +32,7 @@ help: try adding parentheses to match on a tuple...
    |
 LL |         (Nucleotide::Adenine, Nucleotide::Cytosine, _) => true
    |         +                                            +
-help: ...or a vertical bar to match on alternative
+help: ...or a vertical bar to match on alternatives
    |
 LL -         Nucleotide::Adenine, Nucleotide::Cytosine, _ => true
 LL +         Nucleotide::Adenine | Nucleotide::Cytosine, _ => true
diff --git a/tests/ui/feature-gates/feature-gate-never_patterns.stderr b/tests/ui/feature-gates/feature-gate-never_patterns.stderr
index 5e810249b9063..e655209924a08 100644
--- a/tests/ui/feature-gates/feature-gate-never_patterns.stderr
+++ b/tests/ui/feature-gates/feature-gate-never_patterns.stderr
@@ -8,7 +8,7 @@ help: try adding parentheses to match on a tuple...
    |
 LL |         (Some(_),)
    |         +        +
-help: ...or a vertical bar to match on alternative
+help: ...or a vertical bar to match on alternatives
    |
 LL -         Some(_),
 LL +         Some(_) |
diff --git a/tests/ui/parser/match-arm-without-body.stderr b/tests/ui/parser/match-arm-without-body.stderr
index 85ff7db8d4aa3..59a323f2cc1cf 100644
--- a/tests/ui/parser/match-arm-without-body.stderr
+++ b/tests/ui/parser/match-arm-without-body.stderr
@@ -16,7 +16,7 @@ help: try adding parentheses to match on a tuple...
    |
 LL |         (Some(_),)
    |         +        +
-help: ...or a vertical bar to match on alternative
+help: ...or a vertical bar to match on alternatives
    |
 LL -         Some(_),
 LL +         Some(_) |
@@ -36,7 +36,7 @@ LL |
 LL |
 LL ~         _) => {}
    |
-help: ...or a vertical bar to match on alternative
+help: ...or a vertical bar to match on alternatives
    |
 LL -         Some(_),
 LL +         Some(_) |
diff --git a/tests/ui/suggestions/only-replace-intended-coma-not-all-in-pattern.stderr b/tests/ui/suggestions/only-replace-intended-coma-not-all-in-pattern.stderr
index 050f1b8a2b33a..ee75e2db1334c 100644
--- a/tests/ui/suggestions/only-replace-intended-coma-not-all-in-pattern.stderr
+++ b/tests/ui/suggestions/only-replace-intended-coma-not-all-in-pattern.stderr
@@ -8,7 +8,7 @@ help: try adding parentheses to match on a tuple...
    |
 LL |         (Foo { x: 2, ch: ',' }, Foo { x: 3, ch: '@' }) => (),
    |         +                                            +
-help: ...or a vertical bar to match on alternative
+help: ...or a vertical bar to match on alternatives
    |
 LL -         Foo { x: 2, ch: ',' }, Foo { x: 3, ch: '@' } => (),
 LL +         Foo { x: 2, ch: ',' } | Foo { x: 3, ch: '@' } => (),

From fab9906c21e8c751943760d44c4a12cac2bceb05 Mon Sep 17 00:00:00 2001
From: reddevilmidzy <midzy0228@gmail.com>
Date: Thu, 2 Oct 2025 22:15:37 +0900
Subject: [PATCH 1673/1889] test: Add regression test for ICE when projecting
 associated types through dyn traits

---
 .../projection-dyn-associated-type.rs         | 28 ++++++++++
 .../projection-dyn-associated-type.stderr     | 52 +++++++++++++++++++
 2 files changed, 80 insertions(+)
 create mode 100644 tests/ui/associated-types/projection-dyn-associated-type.rs
 create mode 100644 tests/ui/associated-types/projection-dyn-associated-type.stderr

diff --git a/tests/ui/associated-types/projection-dyn-associated-type.rs b/tests/ui/associated-types/projection-dyn-associated-type.rs
new file mode 100644
index 0000000000000..3b981e7987e0e
--- /dev/null
+++ b/tests/ui/associated-types/projection-dyn-associated-type.rs
@@ -0,0 +1,28 @@
+// Regression test for the projection bug in <https://github.com/rust-lang/rust/issues/123953>
+//
+//@ compile-flags: -Zincremental-verify-ich=yes
+//@ incremental
+
+pub trait A {}
+pub trait B: A {}
+
+pub trait Mirror {
+    type Assoc: ?Sized;
+}
+
+impl<T: ?Sized> Mirror for A {
+    //~^ ERROR the type parameter `T` is not constrained by the impl trait, self type, or predicates [E0207]
+    //~| WARN trait objects without an explicit `dyn` are deprecated [bare_trait_objects]
+    //~| WARN this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
+    type Assoc = T;
+}
+
+pub fn foo<'a>(
+    x: &'a <dyn A + 'static as Mirror>::Assoc
+) -> &'a <dyn B + 'static as Mirror>::Assoc {
+    //~^ ERROR the trait bound `(dyn B + 'static): Mirror` is not satisfied [E0277]
+    //~| ERROR the trait bound `(dyn B + 'static): Mirror` is not satisfied [E0277]
+    static
+} //~ ERROR expected identifier, found `}`
+
+pub fn main() {}
diff --git a/tests/ui/associated-types/projection-dyn-associated-type.stderr b/tests/ui/associated-types/projection-dyn-associated-type.stderr
new file mode 100644
index 0000000000000..1ac2beb0414e2
--- /dev/null
+++ b/tests/ui/associated-types/projection-dyn-associated-type.stderr
@@ -0,0 +1,52 @@
+error: expected identifier, found `}`
+  --> $DIR/projection-dyn-associated-type.rs:26:1
+   |
+LL | }
+   | ^ expected identifier
+
+warning: trait objects without an explicit `dyn` are deprecated
+  --> $DIR/projection-dyn-associated-type.rs:13:28
+   |
+LL | impl<T: ?Sized> Mirror for A {
+   |                            ^
+   |
+   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2021/warnings-promoted-to-error.html>
+   = note: `#[warn(bare_trait_objects)]` (part of `#[warn(rust_2021_compatibility)]`) on by default
+help: if this is a dyn-compatible trait, use `dyn`
+   |
+LL | impl<T: ?Sized> Mirror for dyn A {
+   |                            +++
+help: alternatively use a blanket implementation to implement `Mirror` for all types that also implement `A`
+   |
+LL - impl<T: ?Sized> Mirror for A {
+LL + impl<T: ?Sized, U: A> Mirror for U {
+   |
+
+error[E0207]: the type parameter `T` is not constrained by the impl trait, self type, or predicates
+  --> $DIR/projection-dyn-associated-type.rs:13:6
+   |
+LL | impl<T: ?Sized> Mirror for A {
+   |      ^ unconstrained type parameter
+
+error[E0277]: the trait bound `(dyn B + 'static): Mirror` is not satisfied
+  --> $DIR/projection-dyn-associated-type.rs:22:6
+   |
+LL | ) -> &'a <dyn B + 'static as Mirror>::Assoc {
+   |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Mirror` is not implemented for `(dyn B + 'static)`
+   |
+   = help: the trait `Mirror` is implemented for `dyn A`
+
+error[E0277]: the trait bound `(dyn B + 'static): Mirror` is not satisfied
+  --> $DIR/projection-dyn-associated-type.rs:22:6
+   |
+LL | ) -> &'a <dyn B + 'static as Mirror>::Assoc {
+   |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Mirror` is not implemented for `(dyn B + 'static)`
+   |
+   = help: the trait `Mirror` is implemented for `dyn A`
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 4 previous errors; 1 warning emitted
+
+Some errors have detailed explanations: E0207, E0277.
+For more information about an error, try `rustc --explain E0207`.

From 3d2a8df077dcf6f84a15a76dec511af286435e84 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 2 Oct 2025 13:29:14 -0400
Subject: [PATCH 1674/1889] Upgrade `toml` to 0.9.7 and remove the `serde`
 feature.

---
 Cargo.toml                                    |   7 +-
 clippy_lints/Cargo.toml                       |   7 +-
 .../src/cargo/lint_groups_priority.rs         | 186 +++++++++---------
 lintcheck/Cargo.toml                          |   2 +-
 tests/compile-test.rs                         |  22 ++-
 5 files changed, 119 insertions(+), 105 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index e06383499893a..bedcc300f8567 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -38,13 +38,18 @@ ui_test = "0.30.2"
 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"
 itertools = "0.12"
 pulldown-cmark = { version = "0.11", default-features = false, features = ["html"] }
 askama = { version = "0.14", default-features = false, features = ["alloc", "config", "derive"] }
 
+[dev-dependencies.toml]
+version = "0.9.7"
+default-features = false
+# preserve_order keeps diagnostic output in file order
+features = ["parse", "preserve_order"]
+
 [build-dependencies]
 rustc_tools_util = { path = "rustc_tools_util", version = "0.4.2" }
 
diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index 51e59ae205076..42486e182ee34 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -18,12 +18,17 @@ itertools = "0.12"
 quine-mc_cluskey = "0.2"
 regex-syntax = "0.8"
 serde = { version = "1.0", features = ["derive"] }
-toml = "0.7.3"
 unicode-normalization = "0.1"
 unicode-script = { version = "0.5", default-features = false }
 semver = "1.0"
 url = "2.2"
 
+[dependencies.toml]
+version = "0.9.7"
+default-features = false
+# preserve_order keeps diagnostic output in file order
+features = ["parse", "preserve_order"]
+
 [dev-dependencies]
 walkdir = "2.3"
 
diff --git a/clippy_lints/src/cargo/lint_groups_priority.rs b/clippy_lints/src/cargo/lint_groups_priority.rs
index ffd6c520c9ae8..14c5e22fb9cd5 100644
--- a/clippy_lints/src/cargo/lint_groups_priority.rs
+++ b/clippy_lints/src/cargo/lint_groups_priority.rs
@@ -4,142 +4,103 @@ use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_lint::{LateContext, unerased_lint_store};
 use rustc_span::{BytePos, Pos, SourceFile, Span, SyntaxContext};
-use serde::{Deserialize, Serialize};
-use std::collections::BTreeMap;
 use std::ops::Range;
 use std::path::Path;
 use toml::Spanned;
+use toml::de::{DeTable, DeValue};
 
-#[derive(Deserialize, Serialize, Debug)]
-struct LintConfigTable {
-    level: String,
-    priority: Option<i64>,
+fn toml_span(range: Range<usize>, file: &SourceFile) -> Span {
+    Span::new(
+        file.start_pos + BytePos::from_usize(range.start),
+        file.start_pos + BytePos::from_usize(range.end),
+        SyntaxContext::root(),
+        None,
+    )
 }
 
-#[derive(Deserialize, Debug)]
-#[serde(untagged)]
-enum LintConfig {
-    Level(String),
-    Table(LintConfigTable),
+struct LintConfig<'a> {
+    sp: Range<usize>,
+    level: &'a str,
+    priority: Option<i64>,
 }
-
-impl LintConfig {
-    fn level(&self) -> &str {
-        match self {
-            LintConfig::Level(level) => level,
-            LintConfig::Table(table) => &table.level,
-        }
-    }
-
+impl<'a> LintConfig<'a> {
     fn priority(&self) -> i64 {
-        match self {
-            LintConfig::Level(_) => 0,
-            LintConfig::Table(table) => table.priority.unwrap_or(0),
-        }
+        self.priority.unwrap_or(0)
     }
 
     fn is_implicit(&self) -> bool {
-        if let LintConfig::Table(table) = self {
-            table.priority.is_none()
-        } else {
-            true
-        }
+        self.priority.is_none()
     }
-}
-
-type LintTable = BTreeMap<Spanned<String>, Spanned<LintConfig>>;
-
-#[derive(Deserialize, Debug, Default)]
-struct Lints {
-    #[serde(default)]
-    rust: LintTable,
-    #[serde(default)]
-    clippy: LintTable,
-}
-
-#[derive(Deserialize, Debug, Default)]
-struct Workspace {
-    #[serde(default)]
-    lints: Lints,
-}
 
-#[derive(Deserialize, Debug)]
-struct CargoToml {
-    #[serde(default)]
-    lints: Lints,
-    #[serde(default)]
-    workspace: Workspace,
-}
-
-fn toml_span(range: Range<usize>, file: &SourceFile) -> Span {
-    Span::new(
-        file.start_pos + BytePos::from_usize(range.start),
-        file.start_pos + BytePos::from_usize(range.end),
-        SyntaxContext::root(),
-        None,
-    )
+    fn parse(value: &'a Spanned<DeValue<'a>>) -> Option<Self> {
+        let sp = value.span();
+        let (level, priority) = match value.get_ref() {
+            DeValue::String(level) => (&**level, None),
+            DeValue::Table(tbl) => {
+                let level = tbl.get("level")?.get_ref().as_str()?;
+                let priority = if let Some(priority) = tbl.get("priority") {
+                    let priority = priority.get_ref().as_integer()?;
+                    Some(i64::from_str_radix(priority.as_str(), priority.radix()).ok()?)
+                } else {
+                    None
+                };
+                (level, priority)
+            },
+            _ => return None,
+        };
+        Some(Self { sp, level, priority })
+    }
 }
 
-fn check_table(cx: &LateContext<'_>, table: LintTable, known_groups: &FxHashSet<&str>, file: &SourceFile) {
+fn check_table(cx: &LateContext<'_>, table: &DeTable<'_>, known_groups: &FxHashSet<&str>, file: &SourceFile) {
     let mut lints = Vec::new();
     let mut groups = Vec::new();
     for (name, config) in table {
-        if name.get_ref() == "warnings" {
-            continue;
-        }
-
-        if known_groups.contains(name.get_ref().as_str()) {
-            groups.push((name, config));
-        } else {
-            lints.push((name, config.into_inner()));
+        if name.get_ref() != "warnings"
+            && let Some(config) = LintConfig::parse(config)
+        {
+            if known_groups.contains(&**name.get_ref()) {
+                groups.push((name, config));
+            } else {
+                lints.push((name, config));
+            }
         }
     }
 
     for (group, group_config) in groups {
-        let priority = group_config.get_ref().priority();
-        let level = group_config.get_ref().level();
-        if let Some((conflict, _)) = lints
-            .iter()
-            .rfind(|(_, lint_config)| lint_config.priority() == priority && lint_config.level() != level)
-        {
+        if let Some((conflict, _)) = lints.iter().rfind(|(_, lint_config)| {
+            lint_config.priority() == group_config.priority() && lint_config.level != group_config.level
+        }) {
             span_lint_and_then(
                 cx,
                 LINT_GROUPS_PRIORITY,
                 toml_span(group.span(), file),
                 format!(
-                    "lint group `{}` has the same priority ({priority}) as a lint",
-                    group.as_ref()
+                    "lint group `{}` has the same priority ({}) as a lint",
+                    group.as_ref(),
+                    group_config.priority(),
                 ),
                 |diag| {
-                    let config_span = toml_span(group_config.span(), file);
+                    let config_span = toml_span(group_config.sp.clone(), file);
 
-                    if group_config.as_ref().is_implicit() {
+                    if group_config.is_implicit() {
                         diag.span_label(config_span, "has an implicit priority of 0");
                     }
                     diag.span_label(toml_span(conflict.span(), file), "has the same priority as this lint");
                     diag.note("the order of the lints in the table is ignored by Cargo");
 
-                    let mut suggestion = String::new();
                     let low_priority = lints
                         .iter()
-                        .map(|(_, config)| config.priority().saturating_sub(1))
+                        .map(|(_, lint_config)| lint_config.priority().saturating_sub(1))
                         .min()
                         .unwrap_or(-1);
-                    Serialize::serialize(
-                        &LintConfigTable {
-                            level: level.into(),
-                            priority: Some(low_priority),
-                        },
-                        toml::ser::ValueSerializer::new(&mut suggestion),
-                    )
-                    .unwrap();
                     diag.span_suggestion_verbose(
                         config_span,
                         format!(
                             "to have lints override the group set `{}` to a lower priority",
                             group.as_ref()
                         ),
-                        suggestion,
+                        format!("{{ level = {:?}, priority = {low_priority} }}", group_config.level,),
                         Applicability::MaybeIncorrect,
                     );
                 },
@@ -148,10 +109,29 @@ fn check_table(cx: &LateContext<'_>, table: LintTable, known_groups: &FxHashSet<
     }
 }
 
+struct LintTbls<'a> {
+    rust: Option<&'a DeTable<'a>>,
+    clippy: Option<&'a DeTable<'a>>,
+}
+fn get_lint_tbls<'a>(tbl: &'a DeTable<'a>) -> LintTbls<'a> {
+    if let Some(lints) = tbl.get("lints")
+        && let Some(lints) = lints.get_ref().as_table()
+    {
+        let rust = lints.get("rust").and_then(|x| x.get_ref().as_table());
+        let clippy = lints.get("clippy").and_then(|x| x.get_ref().as_table());
+        LintTbls { rust, clippy }
+    } else {
+        LintTbls {
+            rust: None,
+            clippy: None,
+        }
+    }
+}
+
 pub fn check(cx: &LateContext<'_>) {
     if let Ok(file) = cx.tcx.sess.source_map().load_file(Path::new("Cargo.toml"))
         && let Some(src) = file.src.as_deref()
-        && let Ok(cargo_toml) = toml::from_str::<CargoToml>(src)
+        && let Ok(cargo_toml) = DeTable::parse(src)
     {
         let mut rustc_groups = FxHashSet::default();
         let mut clippy_groups = FxHashSet::default();
@@ -167,9 +147,23 @@ pub fn check(cx: &LateContext<'_>) {
             }
         }
 
-        check_table(cx, cargo_toml.lints.rust, &rustc_groups, &file);
-        check_table(cx, cargo_toml.lints.clippy, &clippy_groups, &file);
-        check_table(cx, cargo_toml.workspace.lints.rust, &rustc_groups, &file);
-        check_table(cx, cargo_toml.workspace.lints.clippy, &clippy_groups, &file);
+        let lints = get_lint_tbls(cargo_toml.get_ref());
+        if let Some(lints) = lints.rust {
+            check_table(cx, lints, &rustc_groups, &file);
+        }
+        if let Some(lints) = lints.clippy {
+            check_table(cx, lints, &clippy_groups, &file);
+        }
+        if let Some(tbl) = cargo_toml.get_ref().get("workspace")
+            && let Some(tbl) = tbl.get_ref().as_table()
+        {
+            let lints = get_lint_tbls(tbl);
+            if let Some(lints) = lints.rust {
+                check_table(cx, lints, &rustc_groups, &file);
+            }
+            if let Some(lints) = lints.clippy {
+                check_table(cx, lints, &clippy_groups, &file);
+            }
+        }
     }
 }
diff --git a/lintcheck/Cargo.toml b/lintcheck/Cargo.toml
index 55e588f5ec736..0d0b80c309ddd 100644
--- a/lintcheck/Cargo.toml
+++ b/lintcheck/Cargo.toml
@@ -22,6 +22,6 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.85"
 strip-ansi-escapes = "0.2.0"
 tar = "0.4"
-toml = "0.7.3"
+toml = "0.9.7"
 ureq = { version = "2.2", features = ["json"] }
 walkdir = "2.3"
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index 6b6dfd7b81eab..71cd8a6c03cc9 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -405,11 +405,18 @@ fn ui_cargo_toml_metadata() {
             continue;
         }
 
-        let toml = fs::read_to_string(path).unwrap().parse::<toml::Value>().unwrap();
-
-        let package = toml.as_table().unwrap().get("package").unwrap().as_table().unwrap();
-
-        let name = package.get("name").unwrap().as_str().unwrap().replace('-', "_");
+        let toml = fs::read_to_string(path).unwrap();
+        let toml = toml::de::DeTable::parse(&toml).unwrap();
+
+        let package = toml.get_ref().get("package").unwrap().get_ref().as_table().unwrap();
+
+        let name = package
+            .get("name")
+            .unwrap()
+            .as_ref()
+            .as_str()
+            .unwrap()
+            .replace('-', "_");
         assert!(
             path.parent()
                 .unwrap()
@@ -421,7 +428,10 @@ fn ui_cargo_toml_metadata() {
             path.display(),
         );
 
-        let publish = package.get("publish").and_then(toml::Value::as_bool).unwrap_or(true);
+        let publish = package
+            .get("publish")
+            .and_then(|x| x.get_ref().as_bool())
+            .unwrap_or(true);
         assert!(
             !publish || publish_exceptions.contains(&path.parent().unwrap().to_path_buf()),
             "`{}` lacks `publish = false`",

From c407d340de1717a88537725c899c153c6fdda051 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Tue, 26 Aug 2025 13:41:33 -0500
Subject: [PATCH 1675/1889] if a trait item is shown in search results, hide
 the impl item

for example, if we're showing `Iterator::next`,
we don't need to also show `Range::next` in the results.

Co-authored-by: Michael Howell <michael@notriddle.com>
---
 src/librustdoc/formats/cache.rs            |  31 ++++---
 src/librustdoc/html/render/mod.rs          |   2 +
 src/librustdoc/html/render/search_index.rs |  78 ++++++++++------
 src/librustdoc/html/static/js/rustdoc.d.ts |  22 ++++-
 src/librustdoc/html/static/js/search.js    | 102 +++++++++++++++++----
 5 files changed, 174 insertions(+), 61 deletions(-)

diff --git a/src/librustdoc/formats/cache.rs b/src/librustdoc/formats/cache.rs
index 29b4c4caaf86d..75c848742ea5d 100644
--- a/src/librustdoc/formats/cache.rs
+++ b/src/librustdoc/formats/cache.rs
@@ -148,6 +148,14 @@ impl Cache {
         Cache { document_private, document_hidden, ..Cache::default() }
     }
 
+    fn parent_stack_last_impl_and_trait_id(&self) -> (Option<DefId>, Option<DefId>) {
+        if let Some(ParentStackItem::Impl { item_id, trait_, .. }) = self.parent_stack.last() {
+            (item_id.as_def_id(), trait_.as_ref().map(|tr| tr.def_id()))
+        } else {
+            (None, None)
+        }
+    }
+
     /// Populates the `Cache` with more data. The returned `Crate` will be missing some data that was
     /// in `krate` due to the data being moved into the `Cache`.
     pub(crate) fn populate(cx: &mut DocContext<'_>, mut krate: clean::Crate) -> clean::Crate {
@@ -574,11 +582,7 @@ fn add_item_to_search_index(tcx: TyCtxt<'_>, cache: &mut Cache, item: &clean::It
         clean::ItemKind::ImportItem(import) => import.source.did.unwrap_or(item_def_id),
         _ => item_def_id,
     };
-    let impl_id = if let Some(ParentStackItem::Impl { item_id, .. }) = cache.parent_stack.last() {
-        item_id.as_def_id()
-    } else {
-        None
-    };
+    let (impl_id, trait_parent) = cache.parent_stack_last_impl_and_trait_id();
     let search_type = get_function_type_for_search(
         item,
         tcx,
@@ -596,12 +600,15 @@ fn add_item_to_search_index(tcx: TyCtxt<'_>, cache: &mut Cache, item: &clean::It
         desc,
         parent: parent_did,
         parent_idx: None,
+        trait_parent,
+        trait_parent_idx: None,
         exact_module_path: None,
         impl_id,
         search_type,
         aliases,
         deprecation,
     };
+
     cache.search_index.push(index_item);
 }
 
@@ -610,19 +617,21 @@ fn add_item_to_search_index(tcx: TyCtxt<'_>, cache: &mut Cache, item: &clean::It
 /// See [`Cache::orphan_impl_items`].
 fn handle_orphan_impl_child(cache: &mut Cache, item: &clean::Item, parent_did: DefId) {
     let impl_generics = clean_impl_generics(cache.parent_stack.last());
-    let impl_id = if let Some(ParentStackItem::Impl { item_id, .. }) = cache.parent_stack.last() {
-        item_id.as_def_id()
-    } else {
-        None
+    let (impl_id, trait_parent) = cache.parent_stack_last_impl_and_trait_id();
+    let orphan_item = OrphanImplItem {
+        parent: parent_did,
+        trait_parent,
+        item: item.clone(),
+        impl_generics,
+        impl_id,
     };
-    let orphan_item =
-        OrphanImplItem { parent: parent_did, item: item.clone(), impl_generics, impl_id };
     cache.orphan_impl_items.push(orphan_item);
 }
 
 pub(crate) struct OrphanImplItem {
     pub(crate) parent: DefId,
     pub(crate) impl_id: Option<DefId>,
+    pub(crate) trait_parent: Option<DefId>,
     pub(crate) item: clean::Item,
     pub(crate) impl_generics: Option<(clean::Type, clean::Generics)>,
 }
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index 6d684449b6d2e..88184c9611ff0 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -134,6 +134,8 @@ pub(crate) struct IndexItem {
     pub(crate) desc: String,
     pub(crate) parent: Option<DefId>,
     pub(crate) parent_idx: Option<usize>,
+    pub(crate) trait_parent: Option<DefId>,
+    pub(crate) trait_parent_idx: Option<usize>,
     pub(crate) exact_module_path: Option<Vec<Symbol>>,
     pub(crate) impl_id: Option<DefId>,
     pub(crate) search_type: Option<IndexItemFunctionType>,
diff --git a/src/librustdoc/html/render/search_index.rs b/src/librustdoc/html/render/search_index.rs
index 2984f3ab50eea..81b38d157a868 100644
--- a/src/librustdoc/html/render/search_index.rs
+++ b/src/librustdoc/html/render/search_index.rs
@@ -580,6 +580,7 @@ impl SerializedSearchIndex {
                          module_path,
                          exact_module_path,
                          parent,
+                         trait_parent,
                          deprecated,
                          associated_item_disambiguator,
                      }| EntryData {
@@ -589,6 +590,7 @@ impl SerializedSearchIndex {
                         exact_module_path: exact_module_path
                             .and_then(|path_id| map.get(&path_id).copied()),
                         parent: parent.and_then(|path_id| map.get(&path_id).copied()),
+                        trait_parent: trait_parent.and_then(|path_id| map.get(&path_id).copied()),
                         deprecated: *deprecated,
                         associated_item_disambiguator: associated_item_disambiguator.clone(),
                     },
@@ -870,6 +872,7 @@ struct EntryData {
     module_path: Option<usize>,
     exact_module_path: Option<usize>,
     parent: Option<usize>,
+    trait_parent: Option<usize>,
     deprecated: bool,
     associated_item_disambiguator: Option<String>,
 }
@@ -885,6 +888,7 @@ impl Serialize for EntryData {
         seq.serialize_element(&self.module_path.map(|id| id + 1).unwrap_or(0))?;
         seq.serialize_element(&self.exact_module_path.map(|id| id + 1).unwrap_or(0))?;
         seq.serialize_element(&self.parent.map(|id| id + 1).unwrap_or(0))?;
+        seq.serialize_element(&self.trait_parent.map(|id| id + 1).unwrap_or(0))?;
         seq.serialize_element(&if self.deprecated { 1 } else { 0 })?;
         if let Some(disambig) = &self.associated_item_disambiguator {
             seq.serialize_element(&disambig)?;
@@ -916,6 +920,9 @@ impl<'de> Deserialize<'de> for EntryData {
                     .ok_or_else(|| A::Error::missing_field("exact_module_path"))?;
                 let parent: SerializedOptional32 =
                     v.next_element()?.ok_or_else(|| A::Error::missing_field("parent"))?;
+                let trait_parent: SerializedOptional32 =
+                    v.next_element()?.ok_or_else(|| A::Error::missing_field("trait_parent"))?;
+
                 let deprecated: u32 = v.next_element()?.unwrap_or(0);
                 let associated_item_disambiguator: Option<String> = v.next_element()?;
                 Ok(EntryData {
@@ -925,6 +932,7 @@ impl<'de> Deserialize<'de> for EntryData {
                     exact_module_path: Option::<i32>::from(exact_module_path)
                         .map(|path| path as usize),
                     parent: Option::<i32>::from(parent).map(|path| path as usize),
+                    trait_parent: Option::<i32>::from(trait_parent).map(|path| path as usize),
                     deprecated: deprecated != 0,
                     associated_item_disambiguator,
                 })
@@ -1275,7 +1283,8 @@ pub(crate) fn build_index(
 
     // Attach all orphan items to the type's definition if the type
     // has since been learned.
-    for &OrphanImplItem { impl_id, parent, ref item, ref impl_generics } in &cache.orphan_impl_items
+    for &OrphanImplItem { impl_id, parent, trait_parent, ref item, ref impl_generics } in
+        &cache.orphan_impl_items
     {
         if let Some((fqp, _)) = cache.paths.get(&parent) {
             let desc = short_markdown_summary(&item.doc_value(), &item.link_names(cache));
@@ -1287,6 +1296,8 @@ pub(crate) fn build_index(
                 desc,
                 parent: Some(parent),
                 parent_idx: None,
+                trait_parent,
+                trait_parent_idx: None,
                 exact_module_path: None,
                 impl_id,
                 search_type: get_function_type_for_search(
@@ -1391,6 +1402,7 @@ pub(crate) fn build_index(
                         module_path: None,
                         exact_module_path: None,
                         parent: None,
+                        trait_parent: None,
                         deprecated: false,
                         associated_item_disambiguator: None,
                     }),
@@ -1404,39 +1416,46 @@ pub(crate) fn build_index(
         }
     };
 
-    // First, populate associated item parents
+    // First, populate associated item parents and trait parents
     let crate_items: Vec<&mut IndexItem> = search_index
         .iter_mut()
         .map(|item| {
-            item.parent_idx = item.parent.and_then(|defid| {
-                cache.paths.get(&defid).map(|&(ref fqp, ty)| {
-                    let pathid = serialized_index.names.len();
-                    match serialized_index.crate_paths_index.entry((ty, fqp.clone())) {
-                        Entry::Occupied(entry) => *entry.get(),
-                        Entry::Vacant(entry) => {
-                            entry.insert(pathid);
-                            let (name, path) = fqp.split_last().unwrap();
-                            serialized_index.push_path(
-                                name.as_str().to_string(),
-                                PathData {
-                                    ty,
-                                    module_path: path.to_vec(),
-                                    exact_module_path: if let Some(exact_path) =
-                                        cache.exact_paths.get(&defid)
-                                        && let Some((name2, exact_path)) = exact_path.split_last()
-                                        && name == name2
-                                    {
-                                        Some(exact_path.to_vec())
-                                    } else {
-                                        None
+            let mut defid_to_rowid = |defid, check_external: bool| {
+                cache
+                    .paths
+                    .get(&defid)
+                    .or_else(|| check_external.then(|| cache.external_paths.get(&defid)).flatten())
+                    .map(|&(ref fqp, ty)| {
+                        let pathid = serialized_index.names.len();
+                        match serialized_index.crate_paths_index.entry((ty, fqp.clone())) {
+                            Entry::Occupied(entry) => *entry.get(),
+                            Entry::Vacant(entry) => {
+                                entry.insert(pathid);
+                                let (name, path) = fqp.split_last().unwrap();
+                                serialized_index.push_path(
+                                    name.as_str().to_string(),
+                                    PathData {
+                                        ty,
+                                        module_path: path.to_vec(),
+                                        exact_module_path: if let Some(exact_path) =
+                                            cache.exact_paths.get(&defid)
+                                            && let Some((name2, exact_path)) =
+                                                exact_path.split_last()
+                                            && name == name2
+                                        {
+                                            Some(exact_path.to_vec())
+                                        } else {
+                                            None
+                                        },
                                     },
-                                },
-                            );
-                            usize::try_from(pathid).unwrap()
+                                );
+                                usize::try_from(pathid).unwrap()
+                            }
                         }
-                    }
-                })
-            });
+                    })
+            };
+            item.parent_idx = item.parent.and_then(|p| defid_to_rowid(p, false));
+            item.trait_parent_idx = item.trait_parent.and_then(|p| defid_to_rowid(p, true));
 
             if let Some(defid) = item.defid
                 && item.parent_idx.is_none()
@@ -1519,6 +1538,7 @@ pub(crate) fn build_index(
             Some(EntryData {
                 ty: item.ty,
                 parent: item.parent_idx,
+                trait_parent: item.trait_parent_idx,
                 module_path,
                 exact_module_path,
                 deprecated: item.deprecation.is_some(),
diff --git a/src/librustdoc/html/static/js/rustdoc.d.ts b/src/librustdoc/html/static/js/rustdoc.d.ts
index 951eb2291b89e..e206d6633e630 100644
--- a/src/librustdoc/html/static/js/rustdoc.d.ts
+++ b/src/librustdoc/html/static/js/rustdoc.d.ts
@@ -241,6 +241,7 @@ declare namespace rustdoc {
         modulePath: number?,
         exactModulePath: number?,
         parent: number?,
+        traitParent: number?,
         deprecated: boolean,
         associatedItemDisambiguator: string?,
     }
@@ -291,9 +292,12 @@ declare namespace rustdoc {
         path: PathData?,
         functionData: FunctionData?,
         deprecated: boolean,
-        parent: { path: PathData, name: string}?,
+        parent: RowParent,
+        traitParent: RowParent,
     }
 
+    type RowParent = { path: PathData, name: string } | null;
+
     type ItemType = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
         11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 |
         21 | 22 | 23 | 24 | 25 | 26;
@@ -316,7 +320,23 @@ declare namespace rustdoc {
     interface ResultObject {
         desc: Promise<string|null>,
         displayPath: string,
+        /**
+         * path to where the item was defined (not inlined),
+         * then `|`, then the `ItemType` of the item.
+         *
+         * This is often a private path, so it should not be displayed,
+         * but this allows us to use it to reliably deduplicate reexported and inlined items
+         */
         fullPath: string,
+        /**
+         * The `fullPath` of the corresponding item within a trait.
+         * For example, for `File::read`, this would be `std::io::Read::read|12`
+         *
+         * This is used to hide items from trait impls when the trait itself is in the search results.
+         *
+         * `null` if the item is not from a trait impl block.
+         */
+        traitPath: string | null,
         href: string,
         id: number,
         dist: number,
diff --git a/src/librustdoc/html/static/js/search.js b/src/librustdoc/html/static/js/search.js
index 482134933a61e..71bad967026e8 100644
--- a/src/librustdoc/html/static/js/search.js
+++ b/src/librustdoc/html/static/js/search.js
@@ -1598,6 +1598,7 @@ class DocSearch {
          * module_path,
          * exact_module_path,
          * parent,
+         * trait_parent,
          * deprecated,
          * associated_item_disambiguator
          * @type {rustdoc.ArrayWithOptionals<[
@@ -1607,6 +1608,7 @@ class DocSearch {
          *     number,
          *     number,
          *     number,
+         *     number,
          * ], [string]>}
          */
         const raw = JSON.parse(encoded);
@@ -1616,8 +1618,9 @@ class DocSearch {
             modulePath: raw[2] === 0 ? null : raw[2] - 1,
             exactModulePath: raw[3] === 0 ? null : raw[3] - 1,
             parent: raw[4] === 0 ? null : raw[4] - 1,
-            deprecated: raw[5] === 1 ? true : false,
-            associatedItemDisambiguator: raw.length === 6 ? null : raw[6],
+            traitParent: raw[5] === 0 ? null : raw[5] - 1,
+            deprecated: raw[6] === 1 ? true : false,
+            associatedItemDisambiguator: raw.length === 7 ? null : raw[7],
         };
     }
 
@@ -1853,14 +1856,25 @@ class DocSearch {
         if (!entry && !path) {
             return null;
         }
+        /** @type {function("parent" | "traitParent"): Promise<rustdoc.RowParent>} */
+        const buildParentLike = async field => {
+            const [name, path] = entry !== null && entry[field] !== null ?
+                await Promise.all([this.getName(entry[field]), this.getPathData(entry[field])]) :
+                [null, null];
+            if (name !== null && path !== null) {
+                return { name, path };
+            }
+            return null;
+        };
+
         const [
             moduleName,
             modulePathData,
             exactModuleName,
             exactModulePathData,
-            parentName,
-            parentPath,
-            crate,
+            parent,
+            traitParent,
+            crateOrNull,
         ] = await Promise.all([
             entry && entry.modulePath !== null ? this.getName(entry.modulePath) : null,
             entry && entry.modulePath !== null ? this.getPathData(entry.modulePath) : null,
@@ -1870,14 +1884,11 @@ class DocSearch {
             entry && entry.exactModulePath !== null ?
                 this.getPathData(entry.exactModulePath) :
                 null,
-            entry && entry.parent !== null ?
-                this.getName(entry.parent) :
-                null,
-            entry && entry.parent !== null ?
-                this.getPathData(entry.parent) :
-                null,
-            entry ? nonnull(await this.getName(entry.krate)) : "",
+            buildParentLike("parent"),
+            buildParentLike("traitParent"),
+            entry ? this.getName(entry.krate) : "",
         ]);
+        const crate = crateOrNull === null ? "" : crateOrNull;
         const name = name_ === null ? "" : name_;
         const normalizedName = (name.indexOf("_") === -1 ?
             name :
@@ -1886,6 +1897,7 @@ class DocSearch {
             (modulePathData.modulePath === "" ?
                 moduleName :
                 `${modulePathData.modulePath}::${moduleName}`);
+
         return {
             id,
             crate,
@@ -1901,9 +1913,8 @@ class DocSearch {
             path,
             functionData,
             deprecated: entry ? entry.deprecated : false,
-            parent: parentName !== null && parentPath !== null ?
-                { name: parentName, path: parentPath } :
-                null,
+            parent,
+            traitParent,
         };
     }
 
@@ -2101,11 +2112,12 @@ class DocSearch {
 
         /**
          * @param {rustdoc.Row} item
-         * @returns {[string, string, string]}
+         * @returns {[string, string, string, string|null]}
          */
         const buildHrefAndPath = item => {
             let displayPath;
             let href;
+            let traitPath = null;
             const type = itemTypes[item.ty];
             const name = item.name;
             let path = item.modulePath;
@@ -2163,7 +2175,11 @@ class DocSearch {
                 href = this.rootPath + item.modulePath.replace(/::/g, "/") +
                     "/" + type + "." + name + ".html";
             }
-            return [displayPath, href, `${exactPath}::${name}`];
+            if (item.traitParent) {
+                const tparent = item.traitParent;
+                traitPath = `${tparent.path.exactModulePath}::${tparent.name}::${name}`;
+            }
+            return [displayPath, href, `${exactPath}::${name}`, traitPath];
         };
 
         /**
@@ -2598,7 +2614,13 @@ class DocSearch {
          * @returns {rustdoc.ResultObject[]}
          */
         const transformResults = (results, typeInfo, duplicates) => {
-            const out = [];
+            /** @type {rustdoc.ResultObject[]} */
+            let out = [];
+
+            // if we match a trait-associated item, we want to go back and
+            // remove all the items that are their equivalent but in an impl block.
+            /** @type {Map<string, number[]>} */
+            const traitImplIdxMap = new Map();
 
             for (const result of results) {
                 const item = result.item;
@@ -2630,17 +2652,35 @@ class DocSearch {
                         item,
                         displayPath: pathSplitter(res[0]),
                         fullPath: "",
+                        traitPath: null,
                         href: "",
                         displayTypeSignature: null,
                     }, result);
 
+                    // unlike other items, methods have a different ty when they are
+                    // in an impl block vs a trait.  want to normalize this away.
+                    let ty = obj.item.ty;
+                    if (ty === TY_TYMETHOD) {
+                        ty = TY_METHOD;
+                    }
                     // To be sure than it some items aren't considered as duplicate.
-                    obj.fullPath = res[2] + "|" + obj.item.ty;
+                    obj.fullPath = res[2] + "|" + ty;
+                    if (res[3]) {
+                        // "tymethod" is never used on impl blocks
+                        // (this is the reason we need to normalize tymethod away).
+                        obj.traitPath = res[3] + "|" + obj.item.ty;
+                    }
 
                     if (duplicates.has(obj.fullPath)) {
                         continue;
                     }
 
+                    // If we're showing something like `Iterator::next`,
+                    // we don't want to also show a bunch of `<SomeType as Iterator>::next`
+                    if (obj.traitPath && duplicates.has(obj.traitPath)) {
+                        continue;
+                    }
+
                     // Exports are specifically not shown if the items they point at
                     // are already in the results.
                     if (obj.item.ty === TY_IMPORT && duplicates.has(res[2])) {
@@ -2661,14 +2701,36 @@ class DocSearch {
                         );
                     }
 
+                    // FIXME: if the trait item matches but is cut off due to MAX_RESULTS,
+                    // this deduplication will not happen.
                     obj.href = res[1];
+                    if (obj.traitPath) {
+                        let list = traitImplIdxMap.get(obj.traitPath);
+                        if (list === undefined) {
+                            list = [];
+                        }
+                        list.push(out.length);
+                        traitImplIdxMap.set(obj.traitPath, list);
+                    } else {
+                        // FIXME: this is `O(n*m)` because we're repeatedly
+                        // shifting with Array.splice, but could be `O(n+m)` if
+                        // we did the shifting manually in a more clever way.
+                        const toRemoveList = traitImplIdxMap.get(obj.fullPath);
+                        if (toRemoveList) {
+                            // iterate in reverse order so we don't shift the indexes
+                            for (let i = toRemoveList.length - 1; i >= 0; i--) {
+                                const rmIdx = toRemoveList[i];
+                                out = out.splice(rmIdx, 1);
+                            }
+                        }
+                        traitImplIdxMap.delete(obj.fullPath);
+                    }
                     out.push(obj);
                     if (out.length >= MAX_RESULTS) {
                         break;
                     }
                 }
             }
-
             return out;
         };
 

From 2dd00d3391b82dd0928f50589eb37f6fbbe32980 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Tue, 2 Sep 2025 11:41:21 -0500
Subject: [PATCH 1676/1889] fix rustdoc tests broke by trait item filtering

---
 tests/rustdoc-gui/search-result-color.goml    | 45 +++++++++++--------
 tests/rustdoc-gui/search-tab.goml             |  2 +-
 tests/rustdoc-gui/sidebar.goml                |  2 +
 tests/rustdoc-js-std/asrawfd.js               |  4 +-
 tests/rustdoc-js-std/quoted.js                | 18 ++++----
 .../{bufread-fill-buf.js => trait-unbox.js}   |  6 +--
 6 files changed, 42 insertions(+), 35 deletions(-)
 rename tests/rustdoc-js-std/{bufread-fill-buf.js => trait-unbox.js} (58%)

diff --git a/tests/rustdoc-gui/search-result-color.goml b/tests/rustdoc-gui/search-result-color.goml
index fe0f64010895c..e5c11651bd27d 100644
--- a/tests/rustdoc-gui/search-result-color.goml
+++ b/tests/rustdoc-gui/search-result-color.goml
@@ -5,7 +5,7 @@ include: "utils.goml"
 define-function: (
     "check-search-color",
     [
-        theme, count_color, desc_color, path_color, bottom_border_color, keyword_color,
+        theme, count_color, path_color, bottom_border_color, keyword_color,
         struct_color, associatedtype_color, tymethod_color, method_color, structfield_color,
         structfield_hover_color, macro_color, fn_color, hover_path_color, hover_background,
         attribute_color, grey
@@ -21,10 +21,6 @@ define-function: (
             {"color": |count_color|},
             ALL,
         )
-        assert-css: (
-            "//*[@class='desc'][normalize-space()='Just a normal struct.']",
-            {"color": |desc_color|},
-        )
         assert-css: (
             "//*[@class='result-name']//*[normalize-space()='test_docs::']",
             {"color": |path_color|},
@@ -97,16 +93,6 @@ define-function: (
             ALL,
         )
 
-        // Checking color and background on hover.
-        move-cursor-to: "//*[@class='desc'][normalize-space()='Just a normal struct.']"
-        assert-css: (
-            "//*[@class='result-name']//*[normalize-space()='test_docs::']",
-            {"color": |hover_path_color|},
-        )
-        assert-css: (
-            "//*[@class='result-name']//*[normalize-space()='test_docs::']/ancestor::a",
-            {"color": |hover_path_color|, "background-color": |hover_background|},
-        )
     }
 )
 
@@ -157,7 +143,6 @@ show-text: true
 call-function: ("check-search-color", {
     "theme": "ayu",
     "count_color": "#888",
-    "desc_color": "#c5c5c5",
     "path_color": "#0096cf",
     "bottom_border_color": "#aaa3",
     "keyword_color": "#39afd7",
@@ -179,7 +164,6 @@ call-function: ("check-search-color", {
 call-function: ("check-search-color", {
     "theme": "dark",
     "count_color": "#888",
-    "desc_color": "#ddd",
     "path_color": "#ddd",
     "bottom_border_color": "#aaa3",
     "keyword_color": "#d2991d",
@@ -201,7 +185,6 @@ call-function: ("check-search-color", {
 call-function: ("check-search-color", {
     "theme": "light",
     "count_color": "#888",
-    "desc_color": "#000",
     "path_color": "#000",
     "bottom_border_color": "#aaa3",
     "keyword_color": "#3873ad",
@@ -226,12 +209,27 @@ call-function: ("perform-search", {"query": "thisisanalias"})
 
 define-function: (
     "check-alias",
-    [theme, alias, grey],
+    [theme, alias, grey, desc_color, hover_path_color, hover_background],
     block {
         call-function: ("switch-theme", {"theme": |theme|})
         // Checking that the colors for the alias element are the ones expected.
         assert-css: (".result-name .path .alias", {"color": |alias|})
         assert-css: (".result-name .path .alias > .grey", {"color": |grey|})
+        assert-css: (
+            "//*[@class='desc'][normalize-space()='Just a normal enum.']",
+            {"color": |desc_color|},
+        )
+        // Checking color and background on hover.
+        move-cursor-to: "//*[@class='desc'][normalize-space()='Just a normal enum.']"
+        assert-css: (
+            "//*[@class='result-name']//*[normalize-space()='test_docs::']",
+            {"color": |hover_path_color|},
+        )
+        assert-css: (
+            "//*[@class='result-name']//*[normalize-space()='test_docs::']/ancestor::a",
+            {"color": |hover_path_color|, "background-color": |hover_background|},
+        )
+
     },
 )
 
@@ -239,14 +237,23 @@ call-function: ("check-alias", {
     "theme": "ayu",
     "alias": "#c5c5c5",
     "grey": "#999",
+    "desc_color": "#c5c5c5",
+    "hover_path_color": "#fff",
+    "hover_background": "#3c3c3c",
 })
 call-function: ("check-alias", {
     "theme": "dark",
     "alias": "#fff",
     "grey": "#ccc",
+    "desc_color": "#ddd",
+    "hover_path_color": "#ddd",
+    "hover_background": "#616161",
 })
 call-function: ("check-alias", {
     "theme": "light",
     "alias": "#000",
     "grey": "#999",
+    "desc_color": "#000",
+    "hover_path_color": "#000",
+    "hover_background": "#ccc",
 })
diff --git a/tests/rustdoc-gui/search-tab.goml b/tests/rustdoc-gui/search-tab.goml
index 00ca952033dc6..0a3cfc231e50a 100644
--- a/tests/rustdoc-gui/search-tab.goml
+++ b/tests/rustdoc-gui/search-tab.goml
@@ -79,7 +79,7 @@ call-function: ("check-colors", {
 set-window-size: (851, 600)
 
 // Check the size and count in tabs
-assert-text: ("#search-tabs > button:nth-child(1) > .count", " (27) ")
+assert-text: ("#search-tabs > button:nth-child(1) > .count", " (25) ")
 assert-text: ("#search-tabs > button:nth-child(2) > .count", " (7)  ")
 assert-text: ("#search-tabs > button:nth-child(3) > .count", " (0)  ")
 store-property: ("#search-tabs > button:nth-child(1)", {"offsetWidth": buttonWidth})
diff --git a/tests/rustdoc-gui/sidebar.goml b/tests/rustdoc-gui/sidebar.goml
index 5ec0008ad8afe..0d371c8c6a46f 100644
--- a/tests/rustdoc-gui/sidebar.goml
+++ b/tests/rustdoc-gui/sidebar.goml
@@ -1,5 +1,7 @@
 // Checks multiple things on the sidebar display (width of its elements, colors, etc).
 include: "utils.goml"
+// Disable animations so they don't mess up color assertions later.
+emulate-media-features: { "prefers-reduced-motion": "reduce" }
 go-to: "file://" + |DOC_PATH| + "/test_docs/index.html"
 assert-property: (".sidebar", {"clientWidth": "199"})
 show-text: true
diff --git a/tests/rustdoc-js-std/asrawfd.js b/tests/rustdoc-js-std/asrawfd.js
index 5dbc4ba95d9a7..da08eeb8a53c8 100644
--- a/tests/rustdoc-js-std/asrawfd.js
+++ b/tests/rustdoc-js-std/asrawfd.js
@@ -1,12 +1,10 @@
 // ignore-order
 
 const EXPECTED = {
-    'query': 'RawFd::as_raw_fd',
+    'query': 'method:RawFd::as_raw_fd',
     'others': [
         // Reproduction test for https://github.com/rust-lang/rust/issues/78724
         // Validate that type alias methods get the correct path.
-        { 'path': 'std::os::fd::AsRawFd', 'name': 'as_raw_fd' },
-        { 'path': 'std::os::fd::AsRawFd', 'name': 'as_raw_fd' },
         { 'path': 'std::os::fd::RawFd', 'name': 'as_raw_fd' },
     ],
 };
diff --git a/tests/rustdoc-js-std/quoted.js b/tests/rustdoc-js-std/quoted.js
index 8a9275019255c..a8ca6521208ef 100644
--- a/tests/rustdoc-js-std/quoted.js
+++ b/tests/rustdoc-js-std/quoted.js
@@ -1,21 +1,21 @@
+// make sure quoted search works both for items and and without generics
 // ignore-order
 
 const FILTER_CRATE = 'std';
 
 const EXPECTED = {
-    'query': '"error"',
+    'query': '"result"',
     'others': [
-        { 'path': 'std', 'name': 'error' },
-        { 'path': 'std::fmt', 'name': 'Error' },
-        { 'path': 'std::io', 'name': 'Error' },
+        { 'path': 'std', 'name': 'result' },
+        { 'path': 'std::result', 'name': 'Result' },
+        { 'path': 'std::fmt', 'name': 'Result' },
     ],
     'in_args': [
-        { 'path': 'std::fmt::Error', 'name': 'eq' },
-        { 'path': 'std::fmt::Error', 'name': 'cmp' },
-        { 'path': 'std::fmt::Error', 'name': 'partial_cmp' },
-
+        { 'path': 'std::result::Result', 'name': 'branch' },
+        { 'path': 'std::result::Result', 'name': 'ok' },
+        { 'path': 'std::result::Result', 'name': 'unwrap' },
     ],
     'returned': [
-        { 'path': 'std::fmt::LowerExp', 'name': 'fmt' },
+        { 'path': 'std::bool', 'name': 'try_into' },
     ],
 };
diff --git a/tests/rustdoc-js-std/bufread-fill-buf.js b/tests/rustdoc-js-std/trait-unbox.js
similarity index 58%
rename from tests/rustdoc-js-std/bufread-fill-buf.js
rename to tests/rustdoc-js-std/trait-unbox.js
index 6b9309f686408..44ddc0c1e75ce 100644
--- a/tests/rustdoc-js-std/bufread-fill-buf.js
+++ b/tests/rustdoc-js-std/trait-unbox.js
@@ -1,10 +1,10 @@
-// ignore-order
+// make sure type-based searches with traits get unboxed too
 
 const EXPECTED = [
     {
-        'query': 'bufread -> result<[u8]>',
+        'query': 'any -> result<box>',
         'others': [
-            { 'path': 'std::boxed::Box', 'name': 'fill_buf' },
+            { 'path': 'std::boxed::Box', 'name': 'downcast' },
         ],
     },
     {

From a145dfff03d562584a4a00552fb5df67cdd0d2b6 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Sun, 21 Sep 2025 16:10:32 -0500
Subject: [PATCH 1677/1889] search.js: introduce optimized removeIdxListAsc
 routine

---
 src/librustdoc/html/static/js/search.js | 39 +++++++++++++++++++------
 1 file changed, 30 insertions(+), 9 deletions(-)

diff --git a/src/librustdoc/html/static/js/search.js b/src/librustdoc/html/static/js/search.js
index 71bad967026e8..9a6d4c710ff5d 100644
--- a/src/librustdoc/html/static/js/search.js
+++ b/src/librustdoc/html/static/js/search.js
@@ -1076,6 +1076,34 @@ function isPathSeparator(c) {
     return c === ":" || c === " ";
 }
 
+/**
+ * Given an array and an ascending list of indices,
+ * efficiently removes each index in the array.
+ *
+ * @template T
+ * @param {Array<T>} a
+ * @param {Array<number>} idxList
+ */
+function removeIdxListAsc(a, idxList) {
+    if (idxList.length === 0) {
+        return;
+    }
+    let removed = 0;
+    let i = idxList[0];
+    let nextToRemove = idxList[0];
+    while (i < a.length - idxList.length) {
+        while (i === nextToRemove && removed < idxList.length) {
+            removed++;
+            i++;
+            nextToRemove = idxList[removed];
+        }
+        a[i] = a[i + removed];
+        i++;
+    }
+    // truncate array
+    a.length -= idxList.length;
+}
+
 /**
  * @template T
  */
@@ -2615,7 +2643,7 @@ class DocSearch {
          */
         const transformResults = (results, typeInfo, duplicates) => {
             /** @type {rustdoc.ResultObject[]} */
-            let out = [];
+            const out = [];
 
             // if we match a trait-associated item, we want to go back and
             // remove all the items that are their equivalent but in an impl block.
@@ -2712,16 +2740,9 @@ class DocSearch {
                         list.push(out.length);
                         traitImplIdxMap.set(obj.traitPath, list);
                     } else {
-                        // FIXME: this is `O(n*m)` because we're repeatedly
-                        // shifting with Array.splice, but could be `O(n+m)` if
-                        // we did the shifting manually in a more clever way.
                         const toRemoveList = traitImplIdxMap.get(obj.fullPath);
                         if (toRemoveList) {
-                            // iterate in reverse order so we don't shift the indexes
-                            for (let i = toRemoveList.length - 1; i >= 0; i--) {
-                                const rmIdx = toRemoveList[i];
-                                out = out.splice(rmIdx, 1);
-                            }
+                            removeIdxListAsc(out, toRemoveList);
                         }
                         traitImplIdxMap.delete(obj.fullPath);
                     }

From d0dc603c3992cc4903bb77f949b0b9bebf1ea7a8 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Sun, 21 Sep 2025 16:42:12 -0500
Subject: [PATCH 1678/1889] rustdoc: add testcase for traitParent deduplication

---
 tests/rustdoc-js/trait-methods.js | 20 ++++++++++++++++++++
 tests/rustdoc-js/trait-methods.rs | 18 ++++++++++++++++++
 2 files changed, 38 insertions(+)

diff --git a/tests/rustdoc-js/trait-methods.js b/tests/rustdoc-js/trait-methods.js
index dafad5e43784f..083e52439f4ae 100644
--- a/tests/rustdoc-js/trait-methods.js
+++ b/tests/rustdoc-js/trait-methods.js
@@ -9,4 +9,24 @@ const EXPECTED = [
             { 'path': 'trait_methods::MyTrait', 'name': 'next' },
         ],
     },
+    // the traitParent deduplication pass should remove
+    // Empty::next, as it would be redundant
+    {
+        'query': 'next',
+        'correction': null,
+        'in_args': [],
+        'others': [
+            { 'path': 'trait_methods::MyTrait', 'name': 'next' },
+        ],
+    },
+    // if the trait does not match, no deduplication happens
+    {
+        'query': '-> option<()>',
+        'correction': null,
+        'in_args': [],
+        'others': [
+            { 'path': 'trait_methods::Empty', 'name': 'next' },
+                    { 'path': 'trait_methods::Void', 'name': 'next' },
+        ],
+    },
 ];
diff --git a/tests/rustdoc-js/trait-methods.rs b/tests/rustdoc-js/trait-methods.rs
index c88f5edfd55b7..a741b361a3392 100644
--- a/tests/rustdoc-js/trait-methods.rs
+++ b/tests/rustdoc-js/trait-methods.rs
@@ -2,3 +2,21 @@ pub trait MyTrait {
     type Item;
     fn next(&mut self) -> Option<Self::Item>;
 }
+
+pub struct Empty;
+
+impl MyTrait for Empty {
+    type Item = ();
+    fn next(&mut self) -> Option<()> {
+        None
+    }
+}
+
+pub struct Void;
+
+impl MyTrait for Void {
+    type Item = ();
+    fn next(&mut self) -> Option<()> {
+        Some(())
+    }
+}

From c7d6857f750a8c957ebca81340faa379cc3d110f Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Thu, 2 Oct 2025 10:19:42 -0700
Subject: [PATCH 1679/1889] rustdoc: use same stage for all pr check docs

---
 src/ci/docker/host-x86_64/pr-check-2/Dockerfile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/ci/docker/host-x86_64/pr-check-2/Dockerfile b/src/ci/docker/host-x86_64/pr-check-2/Dockerfile
index d6470e4deb8d1..0a95f428f5bd8 100644
--- a/src/ci/docker/host-x86_64/pr-check-2/Dockerfile
+++ b/src/ci/docker/host-x86_64/pr-check-2/Dockerfile
@@ -32,7 +32,7 @@ ENV SCRIPT \
         python3 ../x.py clippy ci --stage 2 && \
         python3 ../x.py test --stage 1 core alloc std test proc_macro && \
         python3 ../x.py test --stage 1 src/tools/compiletest && \
-        python3 ../x.py doc bootstrap && \
+        python3 ../x.py doc bootstrap --stage 1 && \
         # Build both public and internal documentation.
         RUSTDOCFLAGS=\"--document-private-items --document-hidden-items\" python3 ../x.py doc compiler --stage 1 && \
         RUSTDOCFLAGS=\"--document-private-items --document-hidden-items\" python3 ../x.py doc library --stage 1 && \

From 99550fbc3ea172a3cf90d2776a217e1ba19a196f Mon Sep 17 00:00:00 2001
From: Jubilee Young <workingjubilee@gmail.com>
Date: Thu, 2 Oct 2025 14:36:57 -0700
Subject: [PATCH 1680/1889] Return to needs-llvm-components being info-only

Partially revert a535042e80a38196a58c27a8c95552546affe5dc

Even with non-LLVM codegen backends, we want to allow for annotations
that express dependencies to LLVM-specific parts of the test suite.
This includes `//@ needs-llvm-components`, which just allows checking
that LLVM is built with relevant target support before the test is run.
It does not assert the test cannot work with another codegen backend.
---
 src/tools/compiletest/src/directives/needs.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/tools/compiletest/src/directives/needs.rs b/src/tools/compiletest/src/directives/needs.rs
index c8a729d8aab68..9d72492e5b078 100644
--- a/src/tools/compiletest/src/directives/needs.rs
+++ b/src/tools/compiletest/src/directives/needs.rs
@@ -281,10 +281,7 @@ pub(super) fn handle_needs(
 
     // Handled elsewhere.
     if name == "needs-llvm-components" {
-        if config.default_codegen_backend.is_llvm() {
-            return IgnoreDecision::Continue;
-        }
-        return IgnoreDecision::Ignore { reason: "LLVM specific test".into() };
+        return IgnoreDecision::Continue;
     }
 
     let mut found_valid = false;

From a5c9030271d48456ffefca83a416f0ee863ba965 Mon Sep 17 00:00:00 2001
From: Deadbeef <ent3rm4n@gmail.com>
Date: Thu, 2 Oct 2025 20:54:47 +0000
Subject: [PATCH 1681/1889] Extract common logic for iterating over features

Two places doing the same thing is enough to motivate me to extract this to a method :)
---
 compiler/rustc_ast_passes/src/feature_gate.rs |  6 +-----
 compiler/rustc_feature/src/unstable.rs        | 10 ++++++++++
 compiler/rustc_lint/src/builtin.rs            |  8 ++------
 3 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/compiler/rustc_ast_passes/src/feature_gate.rs b/compiler/rustc_ast_passes/src/feature_gate.rs
index 608ccfefeb69d..b8a29a9a08f43 100644
--- a/compiler/rustc_ast_passes/src/feature_gate.rs
+++ b/compiler/rustc_ast_passes/src/feature_gate.rs
@@ -622,11 +622,7 @@ fn maybe_stage_features(sess: &Session, features: &Features, krate: &ast::Crate)
 }
 
 fn check_incompatible_features(sess: &Session, features: &Features) {
-    let enabled_lang_features =
-        features.enabled_lang_features().iter().map(|feat| (feat.gate_name, feat.attr_sp));
-    let enabled_lib_features =
-        features.enabled_lib_features().iter().map(|feat| (feat.gate_name, feat.attr_sp));
-    let enabled_features = enabled_lang_features.chain(enabled_lib_features);
+    let enabled_features = features.enabled_features_iter_stable_order();
 
     for (f1, f2) in rustc_feature::INCOMPATIBLE_FEATURES
         .iter()
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index e63f29a9570de..8397cd294e0a9 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -93,6 +93,16 @@ impl Features {
         &self.enabled_features
     }
 
+    /// Returns a iterator of enabled features in stable order.
+    pub fn enabled_features_iter_stable_order(
+        &self,
+    ) -> impl Iterator<Item = (Symbol, Span)> + Clone {
+        self.enabled_lang_features
+            .iter()
+            .map(|feat| (feat.gate_name, feat.attr_sp))
+            .chain(self.enabled_lib_features.iter().map(|feat| (feat.gate_name, feat.attr_sp)))
+    }
+
     /// Is the given feature enabled (via `#[feature(...)]`)?
     pub fn enabled(&self, feature: Symbol) -> bool {
         self.enabled_features.contains(&feature)
diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs
index 75a0f89321b97..8a525eb11f7bb 100644
--- a/compiler/rustc_lint/src/builtin.rs
+++ b/compiler/rustc_lint/src/builtin.rs
@@ -2331,13 +2331,9 @@ declare_lint_pass!(
 impl EarlyLintPass for IncompleteInternalFeatures {
     fn check_crate(&mut self, cx: &EarlyContext<'_>, _: &ast::Crate) {
         let features = cx.builder.features();
-        let lang_features =
-            features.enabled_lang_features().iter().map(|feat| (feat.gate_name, feat.attr_sp));
-        let lib_features =
-            features.enabled_lib_features().iter().map(|feat| (feat.gate_name, feat.attr_sp));
 
-        lang_features
-            .chain(lib_features)
+        features
+            .enabled_features_iter_stable_order()
             .filter(|(name, _)| features.incomplete(*name) || features.internal(*name))
             .for_each(|(name, span)| {
                 if features.incomplete(name) {

From ce2087692f3cb6ff25a2b56f33cef20f6aa437cb Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Tue, 30 Sep 2025 13:40:27 -0700
Subject: [PATCH 1682/1889] Add a new `wasm32-wasip3` target to Rust

This commit adds a new tier 3 target to rustc, `wasm32-wasip3`. This
follows in the footsteps of the previous `wasm32-wasip2` target and is
used to represent binding to the WASIp3 set of APIs managed by the WASI
subgroup to the WebAssembly Community Group.

As of now the WASIp3 set of APIs are not finalized nor standardized.
They're in the process of doing so and the current trajectory is to have
the APIs published in December of this year. The goal here is to get the
wheels turning in Rust to have the target in a
more-ready-than-nonexistent state by the time this happens in December.

For now the `wasm32-wasip3` target looks exactly the same as
`wasm32-wasip2` except that `target_env = "p3"` is specified. This
indicates to crates in the ecosystem that WASIp3 APIs should be used,
such as the [`wasip3` crate]. Over time this target will evolve as
implementation in guest toolchains progress, notably:

* The standard library will use WASIp3 APIs natively once they're
  finalized in the WASI subgroup.
* Support through `wasi-libc` will be updated to use WASIp3 natively
  which Rust will then transitively use.
* Longer-term, features such as cooperative multithreading will be added
  to the WASIp3-track of targets to enable using `std::thread`, for
  example, on this target.

These changes are all expected to be non-breaking changes for users of
this target. Runtimes supporting WASIp3, currently Wasmtime and Jco,
support WASIp2 APIs as well and will work with components whether or not
they import WASIp2, both WASIp2 and WASIp3, or just WASIp3 APIs. This
means that changing the internal implementation details of libstd over
time is expected to be a non-breaking change.

[`wasip3` crate]: https://crates.io/crates/wasip3
---
 compiler/rustc_target/src/spec/mod.rs         |  1 +
 .../src/spec/targets/wasm32_wasip3.rs         | 20 +++++
 library/std/Cargo.toml                        |  5 ++
 library/std/src/os/mod.rs                     |  2 +-
 library/std/src/sys/args/mod.rs               |  2 +-
 library/std/src/sys/net/connection/mod.rs     |  2 +-
 .../std/src/sys/net/connection/socket/mod.rs  |  2 +-
 library/std/src/sys/pal/mod.rs                |  2 +-
 library/std/src/sys/random/mod.rs             |  4 +-
 library/std/src/sys/stdio/mod.rs              |  2 +-
 library/std/src/sys/thread/mod.rs             |  4 +-
 src/bootstrap/src/core/build_steps/compile.rs | 10 +++
 src/doc/rustc/src/SUMMARY.md                  |  1 +
 src/doc/rustc/src/platform-support.md         |  1 +
 .../src/platform-support/wasm32-wasip3.md     | 83 +++++++++++++++++++
 tests/assembly-llvm/targets/targets-elf.rs    |  3 +
 tests/ui/check-cfg/well-known-values.stderr   |  2 +-
 17 files changed, 135 insertions(+), 11 deletions(-)
 create mode 100644 compiler/rustc_target/src/spec/targets/wasm32_wasip3.rs
 create mode 100644 src/doc/rustc/src/platform-support/wasm32-wasip3.md

diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index 4a82a8bd888e6..e4b44e8b686c1 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -1624,6 +1624,7 @@ supported_targets! {
     ("wasm32v1-none", wasm32v1_none),
     ("wasm32-wasip1", wasm32_wasip1),
     ("wasm32-wasip2", wasm32_wasip2),
+    ("wasm32-wasip3", wasm32_wasip3),
     ("wasm32-wasip1-threads", wasm32_wasip1_threads),
     ("wasm32-wali-linux-musl", wasm32_wali_linux_musl),
     ("wasm64-unknown-unknown", wasm64_unknown_unknown),
diff --git a/compiler/rustc_target/src/spec/targets/wasm32_wasip3.rs b/compiler/rustc_target/src/spec/targets/wasm32_wasip3.rs
new file mode 100644
index 0000000000000..e3d5e6542c263
--- /dev/null
+++ b/compiler/rustc_target/src/spec/targets/wasm32_wasip3.rs
@@ -0,0 +1,20 @@
+//! The `wasm32-wasip3` target is the next in the chain of `wasm32-wasip1`, then
+//! `wasm32-wasip2`, then WASIp3. The main feature of WASIp3 is native async
+//! support in the component model itself.
+//!
+//! Like `wasm32-wasip2` this target produces a component by default. Support
+//! for `wasm32-wasip3` is very early as of the time of this writing so
+//! components produced will still import WASIp2 APIs, but that's ok since it's
+//! all component-model-level imports anyway. Over time the imports of the
+//! standard library will change to WASIp3.
+
+use crate::spec::Target;
+
+pub(crate) fn target() -> Target {
+    // As of now WASIp3 is a lightly edited wasip2 target, so start with that
+    // and this may grow over time as more features are supported.
+    let mut target = super::wasm32_wasip2::target();
+    target.llvm_target = "wasm32-wasip3".into();
+    target.options.env = "p3".into();
+    target
+}
diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
index 888914a2f772e..779b07ce240a6 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -85,6 +85,11 @@ wasip2 = { version = '0.14.4', features = [
     'rustc-dep-of-std',
 ], default-features = false, package = 'wasi' }
 
+[target.'cfg(all(target_os = "wasi", target_env = "p3"))'.dependencies]
+wasip2 = { version = '0.14.4', features = [
+    'rustc-dep-of-std',
+], default-features = false, package = 'wasi' }
+
 [target.'cfg(target_os = "uefi")'.dependencies]
 r-efi = { version = "5.2.0", features = ['rustc-dep-of-std'] }
 r-efi-alloc = { version = "2.0.0", features = ['rustc-dep-of-std'] }
diff --git a/library/std/src/os/mod.rs b/library/std/src/os/mod.rs
index 96d9bfae8ca32..fd7a11433af1b 100644
--- a/library/std/src/os/mod.rs
+++ b/library/std/src/os/mod.rs
@@ -103,7 +103,7 @@ pub mod linux;
         all(target_vendor = "fortanix", target_env = "sgx")
     )
 )))]
-#[cfg(any(target_os = "wasi", doc))]
+#[cfg(any(target_os = "wasi", any(target_env = "p1", target_env = "p2"), doc))]
 pub mod wasi;
 
 #[cfg(any(all(target_os = "wasi", target_env = "p2"), doc))]
diff --git a/library/std/src/sys/args/mod.rs b/library/std/src/sys/args/mod.rs
index e11e8e5430f06..75c59da721e19 100644
--- a/library/std/src/sys/args/mod.rs
+++ b/library/std/src/sys/args/mod.rs
@@ -36,7 +36,7 @@ cfg_select! {
         mod wasip1;
         pub use wasip1::*;
     }
-    all(target_os = "wasi", target_env = "p2") => {
+    all(target_os = "wasi", any(target_env = "p2", target_env = "p3")) => {
         mod wasip2;
         pub use wasip2::*;
     }
diff --git a/library/std/src/sys/net/connection/mod.rs b/library/std/src/sys/net/connection/mod.rs
index 7f9636a8ccfd6..41e7159f909ae 100644
--- a/library/std/src/sys/net/connection/mod.rs
+++ b/library/std/src/sys/net/connection/mod.rs
@@ -3,7 +3,7 @@ cfg_select! {
         all(target_family = "unix", not(target_os = "l4re")),
         target_os = "windows",
         target_os = "hermit",
-        all(target_os = "wasi", target_env = "p2"),
+        all(target_os = "wasi", any(target_env = "p2", target_env = "p3")),
         target_os = "solid_asp3",
     ) => {
         mod socket;
diff --git a/library/std/src/sys/net/connection/socket/mod.rs b/library/std/src/sys/net/connection/socket/mod.rs
index 1dd06e97bbabd..e59d01bdd9bb1 100644
--- a/library/std/src/sys/net/connection/socket/mod.rs
+++ b/library/std/src/sys/net/connection/socket/mod.rs
@@ -25,7 +25,7 @@ cfg_select! {
         mod unix;
         pub use unix::*;
     }
-    all(target_os = "wasi", target_env = "p2") => {
+    all(target_os = "wasi", any(target_env = "p2", target_env = "p3")) => {
         mod wasip2;
         pub use wasip2::*;
     }
diff --git a/library/std/src/sys/pal/mod.rs b/library/std/src/sys/pal/mod.rs
index dd5e83ee570b6..9e964540a87c1 100644
--- a/library/std/src/sys/pal/mod.rs
+++ b/library/std/src/sys/pal/mod.rs
@@ -49,7 +49,7 @@ cfg_select! {
         mod vexos;
         pub use self::vexos::*;
     }
-    all(target_os = "wasi", target_env = "p2") => {
+    all(target_os = "wasi", any(target_env = "p2", target_env = "p3")) => {
         mod wasip2;
         pub use self::wasip2::*;
     }
diff --git a/library/std/src/sys/random/mod.rs b/library/std/src/sys/random/mod.rs
index 3c5a4c82a9f1e..ec81d89a0f3af 100644
--- a/library/std/src/sys/random/mod.rs
+++ b/library/std/src/sys/random/mod.rs
@@ -90,7 +90,7 @@ cfg_select! {
         mod wasip1;
         pub use wasip1::fill_bytes;
     }
-    all(target_os = "wasi", target_env = "p2") => {
+    all(target_os = "wasi", any(target_env = "p2", target_env = "p3")) => {
         mod wasip2;
         pub use wasip2::{fill_bytes, hashmap_random_keys};
     }
@@ -115,7 +115,7 @@ cfg_select! {
     target_os = "linux",
     target_os = "android",
     all(target_family = "wasm", target_os = "unknown"),
-    all(target_os = "wasi", target_env = "p2"),
+    all(target_os = "wasi", not(target_env = "p1")),
     target_os = "xous",
     target_os = "vexos",
 )))]
diff --git a/library/std/src/sys/stdio/mod.rs b/library/std/src/sys/stdio/mod.rs
index 404ac87792696..660317e3ea844 100644
--- a/library/std/src/sys/stdio/mod.rs
+++ b/library/std/src/sys/stdio/mod.rs
@@ -37,7 +37,7 @@ cfg_select! {
         mod wasip1;
         pub use wasip1::*;
     }
-    all(target_os = "wasi", target_env = "p2") => {
+    all(target_os = "wasi", any(target_env = "p2", target_env = "p3")) => {
         mod wasip2;
         pub use wasip2::*;
     }
diff --git a/library/std/src/sys/thread/mod.rs b/library/std/src/sys/thread/mod.rs
index 3bd83dd760ac9..a20b2a3ddd8ce 100644
--- a/library/std/src/sys/thread/mod.rs
+++ b/library/std/src/sys/thread/mod.rs
@@ -99,7 +99,7 @@ cfg_select! {
         #[cfg(not(target_feature = "atomics"))]
         pub use unsupported::{Thread, available_parallelism};
     }
-    all(target_os = "wasi", target_env = "p2") => {
+    all(target_os = "wasi", any(target_env = "p2", target_env = "p3")) => {
         mod wasip2;
         pub use wasip2::{sleep, sleep_until};
         #[expect(dead_code)]
@@ -146,7 +146,7 @@ cfg_select! {
     target_os = "hurd",
     target_os = "fuchsia",
     target_os = "vxworks",
-    all(target_os = "wasi", target_env = "p2"),
+    all(target_os = "wasi", not(target_env = "p1")),
 )))]
 pub fn sleep_until(deadline: crate::time::Instant) {
     use crate::time::Instant;
diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index 96b4e15433f7e..715f7abe9477f 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -430,6 +430,16 @@ fn copy_self_contained_objects(
                 target.triple
             )
         });
+
+        // wasm32-wasip3 doesn't exist in wasi-libc yet, so instead use libs
+        // from the wasm32-wasip2 target. Once wasi-libc supports wasip3 this
+        // should be deleted and the native objects should be used.
+        let srcdir = if target == "wasm32-wasip3" {
+            assert!(!srcdir.exists(), "wasip3 support is in wasi-libc, this should be updated now");
+            builder.wasi_libdir(TargetSelection::from_user("wasm32-wasip2")).unwrap()
+        } else {
+            srcdir
+        };
         for &obj in &["libc.a", "crt1-command.o", "crt1-reactor.o"] {
             copy_and_stamp(
                 builder,
diff --git a/src/doc/rustc/src/SUMMARY.md b/src/doc/rustc/src/SUMMARY.md
index 67882bb38132a..1965a1b25498b 100644
--- a/src/doc/rustc/src/SUMMARY.md
+++ b/src/doc/rustc/src/SUMMARY.md
@@ -132,6 +132,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-wasip3](platform-support/wasm32-wasip3.md)
     - [wasm32-wali-linux-musl](platform-support/wasm32-wali-linux.md)
     - [wasm32-unknown-emscripten](platform-support/wasm32-unknown-emscripten.md)
     - [wasm32-unknown-unknown](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 d0b6ed51bc163..c23d7563aedb5 100644
--- a/src/doc/rustc/src/platform-support.md
+++ b/src/doc/rustc/src/platform-support.md
@@ -198,6 +198,7 @@ target | std | notes
 [`wasm32-wasip1`](platform-support/wasm32-wasip1.md) | ✓ | WebAssembly with WASIp1
 [`wasm32-wasip1-threads`](platform-support/wasm32-wasip1-threads.md) | ✓ | WebAssembly with WASI Preview 1 and threads
 [`wasm32-wasip2`](platform-support/wasm32-wasip2.md) | ✓ | WebAssembly with WASIp2
+[`wasm32-wasip3`](platform-support/wasm32-wasip3.md) | ✓ | WebAssembly with WASIp3
 [`wasm32v1-none`](platform-support/wasm32v1-none.md) | * | WebAssembly limited to 1.0 features and no imports
 [`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
diff --git a/src/doc/rustc/src/platform-support/wasm32-wasip3.md b/src/doc/rustc/src/platform-support/wasm32-wasip3.md
new file mode 100644
index 0000000000000..e8063a1bdcfed
--- /dev/null
+++ b/src/doc/rustc/src/platform-support/wasm32-wasip3.md
@@ -0,0 +1,83 @@
+# `wasm32-wasip3`
+
+**Tier: 3**
+
+The `wasm32-wasip3` target is the next stage of evolution of the
+[`wasm32-wasip2`](./wasm32-wasip2.md) target. The `wasm32-wasip3` target enables
+the Rust standard library to use WASIp3 APIs to implement various pieces of
+functionality. WASIp3 brings native async support over WASIp2, which integrates
+well with Rust's `async` ecosystem.
+
+> **Note**: As of 2025-10-01 WASIp3 has not yet been approved by the WASI
+> subgroup of the WebAssembly Community Group. Development is expected to
+> conclude in late 2025 or early 2026. Until then the Rust standard library
+> won't actually use WASIp3 APIs on the `wasm32-wasip3` target as they are not
+> yet stable and would reduce the stability of this target. Once WASIp3 is
+> approved, however, the standard library will update to use WASIp3 natively.
+
+> **Note**: This target does not yet build as of 2025-10-01 due to and update
+> needed in the `libc` crate. Using it will require a `[patch]` for now.
+
+> **Note**: Until the standard library is fully migrated to use the `wasip3`
+> crate then components produced for `wasm32-wasip3` may import WASIp2 APIs.
+> This is considered a transitionary phase until fully support of libstd is
+> implemented.
+
+## Target maintainers
+
+[@alexcrichton](https://github.com/alexcrichton)
+
+## Requirements
+
+This target is cross-compiled. The target supports `std` fully.
+
+## Platform requirements
+
+The WebAssembly runtime should support both WASIp2 and WASIp3. Runtimes also
+are required to support components since this target outputs a component as
+opposed to a core wasm module. Two example runtimes for WASIp3 are [Wasmtime]
+and [Jco].
+
+[Wasmtime]: https://wasmtime.dev/
+[Jco]: https://github.com/bytecodealliance/jco
+
+## Building the target
+
+To build this target first acquire a copy of
+[`wasi-sdk`](https://github.com/WebAssembly/wasi-sdk/). At this time version 22
+is the minimum needed.
+
+Next configure the `WASI_SDK_PATH` environment variable to point to where this
+is installed. For example:
+
+```text
+export WASI_SDK_PATH=/path/to/wasi-sdk-22.0
+```
+
+Next be sure to enable LLD when building Rust from source as LLVM's `wasm-ld`
+driver for LLD is required when linking WebAssembly code together. Rust's build
+system will automatically pick up any necessary binaries and programs from
+`WASI_SDK_PATH`.
+
+## Testing
+
+This target is not tested in CI at this time. Locally it can be tested with a
+`wasmtime` binary in `PATH` like so:
+
+```text
+./x.py test --target wasm32-wasip3 tests/ui
+```
+
+## Conditionally compiling code
+
+It's recommended to conditionally compile code for this target with:
+
+```text
+#[cfg(all(target_os = "wasi", target_env = "p3"))]
+```
+
+## Enabled WebAssembly features
+
+The default set of WebAssembly features enabled for compilation is currently the
+same as [`wasm32-unknown-unknown`](./wasm32-unknown-unknown.md). See the
+documentation there for more information.
diff --git a/tests/assembly-llvm/targets/targets-elf.rs b/tests/assembly-llvm/targets/targets-elf.rs
index ebea9fe40f518..e26c213837066 100644
--- a/tests/assembly-llvm/targets/targets-elf.rs
+++ b/tests/assembly-llvm/targets/targets-elf.rs
@@ -586,6 +586,9 @@
 //@ revisions: wasm32_wasip2
 //@ [wasm32_wasip2] compile-flags: --target wasm32-wasip2
 //@ [wasm32_wasip2] needs-llvm-components: webassembly
+//@ revisions: wasm32_wasip3
+//@ [wasm32_wasip3] compile-flags: --target wasm32-wasip3
+//@ [wasm32_wasip3] needs-llvm-components: webassembly
 //@ revisions: wasm32_wali_linux_musl
 //@ [wasm32_wali_linux_musl] compile-flags: --target wasm32-wali-linux-musl
 //@ [wasm32_wali_linux_musl] needs-llvm-components: webassembly
diff --git a/tests/ui/check-cfg/well-known-values.stderr b/tests/ui/check-cfg/well-known-values.stderr
index e62f741b3020c..3f14c7b08eac6 100644
--- a/tests/ui/check-cfg/well-known-values.stderr
+++ b/tests/ui/check-cfg/well-known-values.stderr
@@ -156,7 +156,7 @@ warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
 LL |     target_env = "_UNEXPECTED_VALUE",
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: expected values for `target_env` are: ``, `gnu`, `macabi`, `mlibc`, `msvc`, `musl`, `newlib`, `nto70`, `nto71`, `nto71_iosock`, `nto80`, `ohos`, `p1`, `p2`, `relibc`, `sgx`, `sim`, `uclibc`, and `v5`
+   = note: expected values for `target_env` are: ``, `gnu`, `macabi`, `mlibc`, `msvc`, `musl`, `newlib`, `nto70`, `nto71`, `nto71_iosock`, `nto80`, `ohos`, `p1`, `p2`, `p3`, `relibc`, `sgx`, `sim`, `uclibc`, and `v5`
    = 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`

From c2a03cefd8899941032940df0c6be3b364de0ed0 Mon Sep 17 00:00:00 2001
From: dianqk <dianqk@dianqk.net>
Date: Sun, 21 Sep 2025 20:58:34 +0800
Subject: [PATCH 1683/1889] debuginfo: Use `LocalRef` to simplify reference
 debuginfos

If the `LocalRef` is `LocalRef::Place`, we can refer to it directly,
because the local of place is an indirect pointer.
Such a statement is `_1 = &(_2.1)`.
If the `LocalRef` is `LocalRef::Operand`,
the `OperandRef` should provide the pointer of the reference.
Such a statement is `_1 = &((*_2).1)`.

But there is a special case that hasn't been handled, scalar pairs like `(&[i32; 16], i32)`.
---
 .../rustc_codegen_ssa/src/mir/debuginfo.rs    |   9 +-
 .../rustc_codegen_ssa/src/mir/statement.rs    |  61 +--
 tests/codegen-llvm/debuginfo-dse.rs           | 405 +++++++++++++-----
 3 files changed, 318 insertions(+), 157 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/mir/debuginfo.rs b/compiler/rustc_codegen_ssa/src/mir/debuginfo.rs
index 38bb6f24b1c3b..0c9acf087f9f3 100644
--- a/compiler/rustc_codegen_ssa/src/mir/debuginfo.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/debuginfo.rs
@@ -259,8 +259,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         &self,
         bx: &mut Bx,
         local: mir::Local,
-        base: PlaceValue<Bx::Value>,
-        layout: TyAndLayout<'tcx>,
+        base: PlaceRef<'tcx, Bx::Value>,
         projection: &[mir::PlaceElem<'tcx>],
     ) {
         let full_debug_info = bx.sess().opts.debuginfo == DebugInfo::Full;
@@ -274,7 +273,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         };
 
         let DebugInfoOffset { direct_offset, indirect_offsets, result: _ } =
-            calculate_debuginfo_offset(bx, projection, layout);
+            calculate_debuginfo_offset(bx, projection, base.layout);
         for var in vars.iter() {
             let Some(dbg_var) = var.dbg_var else {
                 continue;
@@ -285,7 +284,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             bx.dbg_var_value(
                 dbg_var,
                 dbg_loc,
-                base.llval,
+                base.val.llval,
                 direct_offset,
                 &indirect_offsets,
                 &var.fragment,
@@ -298,7 +297,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         let layout = bx.cx().layout_of(ty);
         let to_backend_ty = bx.cx().immediate_backend_type(layout);
         let place_ref = PlaceRef::new_sized(bx.cx().const_poison(to_backend_ty), layout);
-        self.debug_new_val_to_local(bx, local, place_ref.val, layout, &[]);
+        self.debug_new_val_to_local(bx, local, place_ref, &[]);
     }
 
     /// Apply debuginfo and/or name, after creating the `alloca` for a local,
diff --git a/compiler/rustc_codegen_ssa/src/mir/statement.rs b/compiler/rustc_codegen_ssa/src/mir/statement.rs
index 80f4f0fcda1ce..88590b6271bce 100644
--- a/compiler/rustc_codegen_ssa/src/mir/statement.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/statement.rs
@@ -1,11 +1,8 @@
-use rustc_middle::mir::{self, NonDivergingIntrinsic, RETURN_PLACE, StmtDebugInfo};
-use rustc_middle::{bug, span_bug};
-use rustc_target::callconv::PassMode;
+use rustc_middle::mir::{self, NonDivergingIntrinsic, StmtDebugInfo};
+use rustc_middle::span_bug;
 use tracing::instrument;
 
 use super::{FunctionCx, LocalRef};
-use crate::common::TypeKind;
-use crate::mir::place::PlaceRef;
 use crate::traits::*;
 
 impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
@@ -110,48 +107,28 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         match debuginfo {
             StmtDebugInfo::AssignRef(dest, place) => {
                 let local_ref = match self.locals[place.local] {
-                    LocalRef::Place(place_ref) | LocalRef::UnsizedPlace(place_ref) => {
-                        Some(place_ref)
+                    // For an rvalue like `&(_1.1)`, when `BackendRepr` is `BackendRepr::Memory`, we allocate a block of memory to this place.
+                    // The place is an indirect pointer, we can refer to it directly.
+                    LocalRef::Place(place_ref) => Some((place_ref, place.projection.as_slice())),
+                    // For an rvalue like `&((*_1).1)`, we are calculating the address of `_1.1`.
+                    // The deref projection is no-op here.
+                    LocalRef::Operand(operand_ref) if place.is_indirect_first_projection() => {
+                        Some((operand_ref.deref(bx.cx()), &place.projection[1..]))
                     }
-                    LocalRef::Operand(operand_ref) => operand_ref
-                        .val
-                        .try_pointer_parts()
-                        .map(|(pointer, _)| PlaceRef::new_sized(pointer, operand_ref.layout)),
-                    LocalRef::PendingOperand => None,
+                    // For an rvalue like `&1`, when `BackendRepr` is `BackendRepr::Scalar`,
+                    // we cannot get the address.
+                    // N.B. `non_ssa_locals` returns that this is an SSA local.
+                    LocalRef::Operand(_) => None,
+                    LocalRef::UnsizedPlace(_) | LocalRef::PendingOperand => None,
                 }
-                .filter(|place_ref| {
-                    // For the reference of an argument (e.x. `&_1`), it's only valid if the pass mode is indirect, and its reference is
-                    // llval.
-                    let local_ref_pass_mode = place.as_local().and_then(|local| {
-                        if local == RETURN_PLACE {
-                            None
-                        } else {
-                            self.fn_abi.args.get(local.as_usize() - 1).map(|arg| &arg.mode)
-                        }
-                    });
-                    matches!(local_ref_pass_mode, Some(&PassMode::Indirect {..}) | None) &&
+                .filter(|(_, projection)| {
                     // Drop unsupported projections.
-                    place.projection.iter().all(|p| p.can_use_in_debuginfo()) &&
-                    // Only pointers can be calculated addresses.
-                    bx.type_kind(bx.val_ty(place_ref.val.llval)) == TypeKind::Pointer
+                    projection.iter().all(|p| p.can_use_in_debuginfo())
                 });
-                if let Some(local_ref) = local_ref {
-                    let (base_layout, projection) = if place.is_indirect_first_projection() {
-                        // For `_n = &((*_1).0: i32);`, we are calculating the address of `_1.0`, so
-                        // we should drop the deref projection.
-                        let projected_ty = local_ref
-                            .layout
-                            .ty
-                            .builtin_deref(true)
-                            .unwrap_or_else(|| bug!("deref of non-pointer {:?}", local_ref));
-                        let layout = bx.cx().layout_of(projected_ty);
-                        (layout, &place.projection[1..])
-                    } else {
-                        (local_ref.layout, place.projection.as_slice())
-                    };
-                    self.debug_new_val_to_local(bx, *dest, local_ref.val, base_layout, projection);
+                if let Some((base, projection)) = local_ref {
+                    self.debug_new_val_to_local(bx, *dest, base, projection);
                 } else {
-                    // If the address cannot be computed, use poison to indicate that the value has been optimized out.
+                    // If the address cannot be calculated, use poison to indicate that the value has been optimized out.
                     self.debug_poison_to_local(bx, *dest);
                 }
             }
diff --git a/tests/codegen-llvm/debuginfo-dse.rs b/tests/codegen-llvm/debuginfo-dse.rs
index 78e145a3cdf12..fd0c9f1c676f1 100644
--- a/tests/codegen-llvm/debuginfo-dse.rs
+++ b/tests/codegen-llvm/debuginfo-dse.rs
@@ -1,9 +1,249 @@
 //@ compile-flags: -Copt-level=3 -g -Zverify-llvm-ir -Zmerge-functions=disabled
 //@ revisions: CODEGEN OPTIMIZED
 //@[CODEGEN] compile-flags: -Cno-prepopulate-passes
+//@ only-64bit
 // ignore-tidy-linelength
 
 #![crate_type = "lib"]
+#![feature(repr_simd, rustc_attrs)]
+
+// The pass mode is direct and the backend represent is scalar.
+type Scalar = i32; // scalar(i32)
+type Scalar_Ref = &'static i32; // scalar(ptr)
+
+// The pass modes are pair and the backend represents are scalar pair.
+type Tuple_Scalar_Scalar = (i32, i32);
+struct Tuple_Ref_Scalar(&'static i32, i32);
+struct Tuple_ArrayRef_Scalar(&'static [i32; 16], i32); // pair(ptr, i32)
+impl Default for Tuple_ArrayRef_Scalar {
+    fn default() -> Tuple_ArrayRef_Scalar {
+        Tuple_ArrayRef_Scalar(&[0; 16], 0)
+    }
+}
+struct Tuple_Scalar_ArrayRef(i32, &'static [i32; 16]); // pair(i32, ptr)
+impl Default for Tuple_Scalar_ArrayRef {
+    fn default() -> Tuple_Scalar_ArrayRef {
+        Tuple_Scalar_ArrayRef(0, &[0; 16])
+    }
+}
+// The pass mode is indirect and the backend represent is memory.
+type Tuple_SliceRef_Scalar = (&'static [i32], i32);
+
+// The pass mode is pair and the backend represent is scalar pair.
+type SliceRef = &'static [i32]; // pair(ptr, i32)
+// The pass mode is indirect and the backend represent is memory.
+type Array = [i32; 16];
+// The pass mode is direct and the backend represent is scalar.
+type ArrayRef = &'static [i32; 16];
+
+// The pass mode is indirect and the backend represent is memory.
+type Typle_i32_i64_i8 = (i32, i64, i8);
+// The pass mode is indirect and the backend represent is memory.
+#[repr(C)]
+struct Aggregate_i32_Array_i8(i32, &'static [i32; 16], i8);
+
+type ZST = ();
+
+impl Default for Aggregate_i32_Array_i8 {
+    fn default() -> Aggregate_i32_Array_i8 {
+        Aggregate_i32_Array_i8(0, &[0; 16], 0)
+    }
+}
+// The pass mode is cast and the backend represent is scalar.
+#[derive(Default)]
+struct Aggregate_4xi8(i8, i8, i8, i8); // scalar(i32)
+
+// The pass mode is indirect and the backend represent is simd vector.
+#[repr(simd)]
+struct Simd_i32x4([i32; 4]);
+
+unsafe extern "Rust" {
+    #[rustc_nounwind]
+    safe fn opaque_fn();
+    #[rustc_nounwind]
+    safe fn opaque_ptr(_: *const core::ffi::c_void);
+}
+
+#[inline(never)]
+#[rustc_nounwind]
+fn opaque_use<T>(p: &T) {
+    opaque_ptr(&raw const p as *const _);
+}
+
+#[inline(never)]
+#[rustc_nounwind]
+fn opaque_read<T: Default>() -> T {
+    core::hint::black_box(T::default())
+}
+
+#[unsafe(no_mangle)]
+fn local_var() {
+    // CHECK-LABEL: define{{( dso_local)?}} void @local_var
+    let local_var_scalar: Scalar = opaque_read();
+    opaque_use(&local_var_scalar);
+    let dead_local_var_scalar: Scalar = opaque_read();
+    let local_var_aggregate_4xi8: Aggregate_4xi8 = opaque_read();
+    opaque_use(&local_var_aggregate_4xi8);
+    let local_var_aggregate_i32_array_i8: Aggregate_i32_Array_i8 = opaque_read();
+    opaque_use(&local_var_aggregate_i32_array_i8);
+    // CHECK: call void @opaque_fn()
+    opaque_fn();
+    // CHECK-NEXT: #dbg_value(ptr %local_var_scalar, [[ref_local_var_scalar:![0-9]+]], !DIExpression()
+    let ref_local_var_scalar = &local_var_scalar;
+    // CHECK-NEXT: #dbg_value(ptr poison, [[ref_dead_local_var_scalar:![0-9]+]], !DIExpression()
+    let ref_dead_local_var_scalar = &dead_local_var_scalar;
+    // CHECK-NEXT: #dbg_value(ptr %local_var_aggregate_4xi8, [[ref_local_var_aggregate_4xi8:![0-9]+]], !DIExpression()
+    let ref_local_var_aggregate_4xi8 = &local_var_aggregate_4xi8;
+    // CHECK-NEXT: #dbg_value(ptr %local_var_aggregate_4xi8, [[ref_0_local_var_aggregate_4xi8:![0-9]+]], !DIExpression()
+    let ref_0_local_var_aggregate_4xi8 = &local_var_aggregate_4xi8.0;
+    // CHECK-NEXT: #dbg_value(ptr %local_var_aggregate_4xi8, [[ref_2_local_var_aggregate_4xi8:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 2, DW_OP_stack_value)
+    let ref_2_local_var_aggregate_4xi8 = &local_var_aggregate_4xi8.2;
+    // This introduces an extra load instruction.
+    // CHECK-NEXT: #dbg_value(ptr poison, [[ref_1_1_local_var_aggregate_i32_array_i8:![0-9]+]], !DIExpression()
+    let ref_1_1_local_var_aggregate_i32_array_i8 = &local_var_aggregate_i32_array_i8.1[1];
+    // CHECK-NEXT: #dbg_value(ptr %local_var_aggregate_i32_array_i8, [[ref_2_local_var_aggregate_i32_array_i8:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 16, DW_OP_stack_value)
+    let ref_2_local_var_aggregate_i32_array_i8 = &local_var_aggregate_i32_array_i8.2;
+    // CHECK: call void @opaque_fn()
+    opaque_fn();
+}
+
+#[unsafe(no_mangle)]
+fn zst(zst: ZST, zst_ref: &ZST) {
+    // CHECK-LABEL: define{{( dso_local)?}} void @zst
+    // CHECK: call void @opaque_fn()
+    opaque_fn();
+    // CHECK-NEXT: #dbg_value(ptr poison, [[ref_zst:![0-9]+]], !DIExpression()
+    let ref_zst = &zst;
+    // CHECK-NEXT: #dbg_value(ptr poison, [[ref_zst_ref:![0-9]+]], !DIExpression()
+    let ref_zst_ref = &zst_ref;
+    // CHECK: call void @opaque_fn()
+    opaque_fn();
+}
+
+// It only makes sense if the argument is a reference and it refer to projections.
+#[unsafe(no_mangle)]
+fn direct(
+    scalar: Scalar,
+    scalar_ref: Scalar_Ref,
+    array_ref: ArrayRef,
+    aggregate_4xi8_ref: &Aggregate_4xi8,
+) {
+    // CHECK-LABEL: define{{( dso_local)?}} void @direct
+    // CHECK: call void @opaque_fn()
+    opaque_fn();
+    // CHECK-NEXT: #dbg_value(ptr poison, [[ref_scalar:![0-9]+]], !DIExpression()
+    let ref_scalar = &scalar;
+    // CHECK-NEXT: #dbg_value(ptr poison, [[ref_scalar_ref:![0-9]+]], !DIExpression()
+    let ref_scalar_ref = &scalar_ref;
+    // CHECK-NEXT: #dbg_value(ptr %array_ref, [[ref_0_array_ref:![0-9]+]], !DIExpression()
+    let ref_0_array_ref = &array_ref[0];
+    // CHECK-NEXT: #dbg_value(ptr %array_ref, [[ref_1_array_ref:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 4, DW_OP_stack_value)
+    let ref_1_array_ref = &array_ref[1];
+    // CHECK-NEXT: #dbg_value(ptr %aggregate_4xi8_ref, [[ref_1_aggregate_4xi8_ref:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 1, DW_OP_stack_value)
+    let ref_1_aggregate_4xi8_ref = &aggregate_4xi8_ref.1;
+    // CHECK: call void @opaque_fn()
+    opaque_fn();
+}
+
+// Arguments are passed through registers, the final values are poison.
+#[unsafe(no_mangle)]
+fn cast(aggregate_4xi8: Aggregate_4xi8) {
+    // CHECK-LABEL: define{{( dso_local)?}} void @cast(i32 %0)
+    // CHECK: call void @opaque_fn()
+    opaque_fn();
+    // The temporary allocated variable is eliminated.
+    // CODEGEN-NEXT: #dbg_value(ptr %aggregate_4xi8, [[ref_aggregate_4xi8:![0-9]+]], !DIExpression()
+    // OPTIMIZED-NEXT: #dbg_value(ptr undef, [[ref_aggregate_4xi8:![0-9]+]], !DIExpression()
+    let ref_aggregate_4xi8 = &aggregate_4xi8;
+    // CODEGEN-NEXT: #dbg_value(ptr %aggregate_4xi8, [[ref_0_aggregate_4xi8:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 1, DW_OP_stack_value)
+    // OPTIMIZED-NEXT: #dbg_value(ptr undef, [[ref_0_aggregate_4xi8:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 1, DW_OP_stack_value)
+    let ref_0_aggregate_4xi8 = &aggregate_4xi8.1;
+    // CHECK: call void @opaque_fn()
+    opaque_fn();
+}
+
+// Arguments are passed indirectly via a pointer.
+// The reference of argument is the pointer itself.
+#[unsafe(no_mangle)]
+fn indirect(
+    tuple_sliceref_scalar: Tuple_SliceRef_Scalar,
+    array: Array,
+    typle_i32_i64_i8: Typle_i32_i64_i8,
+    simd_i32x4: Simd_i32x4,
+) {
+    // CHECK-LABEL: define{{( dso_local)?}} void @indirect
+    // CHECK-SAME: (ptr{{.*}} %tuple_sliceref_scalar, ptr{{.*}} %array, ptr{{.*}} %typle_i32_i64_i8, ptr{{.*}} %simd_i32x4)
+    // CHECK: call void @opaque_fn()
+    opaque_fn();
+    // CHECK-NEXT: #dbg_value(ptr %tuple_sliceref_scalar, [[ref_tuple_sliceref_scalar:![0-9]+]], !DIExpression()
+    let ref_tuple_sliceref_scalar = &tuple_sliceref_scalar;
+    // CHECK-NEXT: #dbg_value(ptr %tuple_sliceref_scalar, [[ref_1_tuple_sliceref_scalar:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 16, DW_OP_stack_value)
+    let ref_1_tuple_sliceref_scalar = &tuple_sliceref_scalar.1;
+    // CHECK-NEXT: #dbg_value(ptr %array, [[ref_1_array:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 4, DW_OP_stack_value)
+    let ref_1_array = &array[1];
+    // CHECK-NEXT: #dbg_value(ptr %typle_i32_i64_i8, [[ref_1_typle_i32_i64_i8:![0-9]+]], !DIExpression()
+    let ref_1_typle_i32_i64_i8 = &typle_i32_i64_i8.1;
+    // CHECK-NEXT: #dbg_value(ptr %simd_i32x4, [[ref_simd_i32x4:![0-9]+]], !DIExpression()
+    let ref_simd_i32x4 = &simd_i32x4;
+    // CHECK: call void @opaque_fn()
+    opaque_fn();
+}
+
+// They are different MIR statements, but they have the same LLVM IR statement due to the ABI of arguments.
+// Both `direct_ref` and `indirect_byval` are passed as a pointer here.
+#[unsafe(no_mangle)]
+fn direct_ref_and_indirect(
+    direct_ref: &Aggregate_i32_Array_i8,
+    indirect_byval: Aggregate_i32_Array_i8,
+) {
+    // CHECK-LABEL: define{{( dso_local)?}} void @direct_ref_and_indirect
+    // CHECK-SAME: (ptr{{.*}} %direct_ref, ptr{{.*}} %indirect_byval)
+    // CHECK: call void @opaque_fn()
+    opaque_fn();
+    // CHECK-NEXT: #dbg_value(ptr poison, [[ref_direct_ref:![0-9]+]], !DIExpression()
+    let ref_direct_ref: &&Aggregate_i32_Array_i8 = &direct_ref;
+    // CHECK-NEXT: #dbg_value(ptr %direct_ref, [[ref_1_direct_ref:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 8, DW_OP_stack_value)
+    let ref_1_direct_ref = &direct_ref.1;
+    // CHECK-NEXT: #dbg_value(ptr %indirect_byval, [[ref_indirect_byval:![0-9]+]], !DIExpression()
+    let ref_indirect_byval: &Aggregate_i32_Array_i8 = &indirect_byval;
+    // CHECK-NEXT: #dbg_value(ptr %indirect_byval, [[ref_1_indirect_byval:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 8, DW_OP_stack_value)
+    let ref_1_indirect_byval = &indirect_byval.1;
+    // CHECK: call void @opaque_fn()
+    opaque_fn();
+}
+
+#[unsafe(no_mangle)]
+fn pair(
+    tuple_scalar_scalar: Tuple_Scalar_Scalar,
+    tuple_ref_scalar: Tuple_Ref_Scalar,
+    tuple_arrayref_scalar: Tuple_ArrayRef_Scalar,
+    tuple_scalar_arrayref: Tuple_Scalar_ArrayRef,
+    sliceref: SliceRef,
+) {
+    // CHECK-LABEL: define{{( dso_local)?}} void @pair
+    // CHECK: call void @opaque_fn()
+    opaque_fn();
+    // CHECK-NEXT: #dbg_value(ptr poison, [[ref_0_tuple_scalar_scalar:![0-9]+]], !DIExpression()
+    let ref_0_tuple_scalar_scalar = &tuple_scalar_scalar.0;
+    // CHECK-NEXT: #dbg_value(ptr poison, [[ref_0_tuple_ref_scalar:![0-9]+]], !DIExpression()
+    let ref_0_tuple_ref_scalar = &tuple_ref_scalar.0;
+    // CHECK-NEXT: #dbg_value(ptr poison, [[ref_1_tuple_ref_scalar:![0-9]+]], !DIExpression()
+    let ref_1_tuple_ref_scalar = &tuple_ref_scalar.1;
+    // CHECK-NEXT: #dbg_value(ptr poison, [[ref_0_tuple_arrayref_scalar:![0-9]+]], !DIExpression()
+    let ref_0_tuple_arrayref_scalar = &tuple_arrayref_scalar.0;
+    // CHECK-NEXT: #dbg_value(ptr poison, [[ref_1_tuple_arrayref_scalar:![0-9]+]], !DIExpression()
+    let ref_1_tuple_arrayref_scalar = &tuple_arrayref_scalar.1;
+    // FIXME: This can be a valid value.
+    // CHECK-NEXT: #dbg_value(ptr poison, [[ref_0_1_tuple_arrayref_scalar:![0-9]+]], !DIExpression()
+    let ref_0_1_tuple_arrayref_scalar = &tuple_arrayref_scalar.0[1];
+    // FIXME: This can be a valid value.
+    // CHECK-NEXT: #dbg_value(ptr poison, [[ref_1_1_tuple_scalar_arrayref:![0-9]+]], !DIExpression()
+    let ref_1_1_tuple_scalar_arrayref = &tuple_scalar_arrayref.1[1];
+    // CHECK: #dbg_value(ptr %sliceref.0, [[ref_1_sliceref:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 4, DW_OP_stack_value)
+    let ref_1_sliceref = &sliceref[1];
+    // CHECK: call void @opaque_fn()
+    opaque_fn();
+}
 
 #[repr(C)]
 #[derive(Clone, Copy)]
@@ -16,23 +256,7 @@ pub struct Bar<'a> {
     foo: &'a Foo,
 }
 
-#[no_mangle]
-fn r#ref(ref_foo: &Foo) -> i32 {
-    // CHECK-LABEL: define{{.*}} i32 @ref
-    // CHECK-SAME: (ptr {{.*}} [[ARG_ref_foo:%.*]])
-    // OPTIMIZED: #dbg_value(ptr [[ARG_ref_foo]], [[VAR_ref_foo:![0-9]+]], !DIExpression()
-    // CHECK: #dbg_value(ptr poison, [[VAR_invalid_ref_of_ref_foo:![0-9]+]], !DIExpression()
-    // CHECK: #dbg_value(ptr [[ARG_ref_foo]], [[VAR_ref_v0:![0-9]+]], !DIExpression()
-    // CHECK: #dbg_value(ptr [[ARG_ref_foo]], [[VAR_ref_v1:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 8, DW_OP_stack_value)
-    // CHECK: #dbg_value(ptr [[ARG_ref_foo]], [[VAR_ref_v2:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 16, DW_OP_stack_value)
-    let invalid_ref_of_ref_foo = &ref_foo;
-    let ref_v0 = &ref_foo.0;
-    let ref_v1 = &ref_foo.1;
-    let ref_v2 = &ref_foo.2;
-    ref_foo.0
-}
-
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub fn dead_first(dead_first_foo: &Foo) -> &i32 {
     // CHECK-LABEL: def {{.*}} ptr @dead_first
     // CHECK-SAME: (ptr {{.*}} [[ARG_dead_first_foo:%.*]])
@@ -47,32 +271,9 @@ pub fn dead_first(dead_first_foo: &Foo) -> &i32 {
     dead_first_v0
 }
 
-#[no_mangle]
-fn ptr(ptr_foo: Foo) -> i32 {
-    // CHECK-LABEL: define{{.*}} i32 @ptr
-    // CHECK-SAME: (ptr {{.*}} [[ARG_ptr_foo:%.*]])
-    // CHECK: #dbg_value(ptr [[ARG_ptr_foo]], [[ref_ptr_foo:![0-9]+]], !DIExpression()
-    // CHECK: #dbg_value(ptr [[ARG_ptr_foo]], [[VAR_ptr_v0:![0-9]+]], !DIExpression()
-    // CHECK: #dbg_value(ptr [[ARG_ptr_foo]], [[VAR_ptr_v1:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 8, DW_OP_stack_value)
-    // CHECK: #dbg_value(ptr [[ARG_ptr_foo]], [[VAR_ptr_v2:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 16, DW_OP_stack_value)
-    let ref_ptr_foo = &ptr_foo;
-    let ptr_v0 = &ptr_foo.0;
-    let ptr_v1 = &ptr_foo.1;
-    let ptr_v2 = &ptr_foo.2;
-    ptr_foo.2
-}
-
-#[no_mangle]
-fn no_ptr(val: i32) -> i32 {
-    // CHECK-LABEL: define{{.*}} i32 @no_ptr
-    // CODEGEN: #dbg_value(ptr poison, [[VAR_val_ref:![0-9]+]], !DIExpression()
-    let val_ref = &val;
-    val
-}
-
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub fn fragment(fragment_v1: Foo, mut fragment_v2: Foo) -> Foo {
-    // CHECK-LABEL: define void @fragment
+    // CHECK-LABEL: define{{( dso_local)?}} void @fragment
     // CHECK-SAME: (ptr {{.*}}, ptr {{.*}} [[ARG_fragment_v1:%.*]], ptr {{.*}} [[ARG_fragment_v2:%.*]])
     // CHECK: #dbg_declare(ptr [[ARG_fragment_v1]]
     // CHECK-NEXT: #dbg_declare(ptr [[ARG_fragment_v2]]
@@ -85,93 +286,77 @@ pub fn fragment(fragment_v1: Foo, mut fragment_v2: Foo) -> Foo {
     fragment_v2
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub fn deref(bar: Bar) -> i32 {
-    // CHECK-LABEL: define {{.*}} i32 @deref
+    // CHECK-LABEL: define{{.*}} i32 @deref
     // We are unable to represent dereference within this expression.
     // CHECK: #dbg_value(ptr poison, [[VAR_deref_dead:![0-9]+]], !DIExpression()
     let deref_dead = &bar.foo.2;
     bar.a
 }
 
-#[no_mangle]
-pub fn tuple(foo: (i32, &Foo)) -> i32 {
-    // CHECK-LABEL: define{{.*}} i32 @tuple
-    // Although there is no dereference here, there is a dereference in the MIR.
-    // CHECK: #dbg_value(ptr poison, [[VAR_tuple_dead:![0-9]+]], !DIExpression()
-    let tuple_dead = &foo.1.2;
-    foo.1.0
-}
-
-pub struct ZST;
-
-#[no_mangle]
-pub fn zst(zst: ZST, v: &i32) -> i32 {
-    // CHECK-LABEL: define{{.*}} i32 @zst
-    // CHECK: #dbg_value(ptr poison, [[VAR_zst_ref:![0-9]+]], !DIExpression()
-    let zst_ref = &zst;
-    *v
-}
-
-#[no_mangle]
+#[unsafe(no_mangle)]
 fn index(slice: &[i32; 4], idx: usize) -> i32 {
     // CHECK-LABEL: define{{.*}} i32 @index
-    // CHECK: bb1:
-    // CHECK-NEXT: #dbg_value(ptr poison, [[VAR_index_from_var:![0-9]+]], !DIExpression()
-    // CODEGEN: bb3:
-    // CHECK-NEXT: #dbg_value(ptr %slice, [[VAR_const_index_from_start:![0-9]+]], !DIExpression()
-    // CHECK-NEXT: #dbg_value(ptr poison, [[VAR_const_index_from_end:![0-9]+]], !DIExpression()
+    // CHECK: call void @opaque_fn()
+    opaque_fn();
+    // CHECK: #dbg_value(ptr poison, [[VAR_index_from_var:![0-9]+]], !DIExpression()
     let index_from_var = &slice[idx];
+    // CHECK: #dbg_value(ptr %slice, [[VAR_const_index_from_start:![0-9]+]], !DIExpression()
+    // CHECK-NEXT: #dbg_value(ptr poison, [[VAR_const_index_from_end:![0-9]+]], !DIExpression()
     let [ref const_index_from_start, .., ref const_index_from_end] = slice[..] else {
         return 0;
     };
     slice[0]
 }
 
-unsafe extern "Rust" {
-    safe fn opaque_inner(_: *const core::ffi::c_void);
-}
+// CHECK-DAG: [[ref_local_var_scalar]] = !DILocalVariable(name: "ref_local_var_scalar"
+// CHECK-DAG: [[ref_dead_local_var_scalar]] = !DILocalVariable(name: "ref_dead_local_var_scalar"
+// CHECK-DAG: [[ref_local_var_aggregate_4xi8]] = !DILocalVariable(name: "ref_local_var_aggregate_4xi8"
+// CHECK-DAG: [[ref_0_local_var_aggregate_4xi8]] = !DILocalVariable(name: "ref_0_local_var_aggregate_4xi8"
+// CHECK-DAG: [[ref_2_local_var_aggregate_4xi8]] = !DILocalVariable(name: "ref_2_local_var_aggregate_4xi8"
+// CHECK-DAG: [[ref_1_1_local_var_aggregate_i32_array_i8]] = !DILocalVariable(name: "ref_1_1_local_var_aggregate_i32_array_i8"
+// CHECK-DAG: [[ref_2_local_var_aggregate_i32_array_i8]] = !DILocalVariable(name: "ref_2_local_var_aggregate_i32_array_i8"
+
+// CHECK-DAG: [[ref_zst]] = !DILocalVariable(name: "ref_zst"
+// CHECK-DAG: [[ref_zst_ref]] = !DILocalVariable(name: "ref_zst_ref"
+
+// CHECK-DAG: [[ref_scalar]] = !DILocalVariable(name: "ref_scalar"
+// CHECK-DAG: [[ref_scalar_ref]] = !DILocalVariable(name: "ref_scalar_ref"
+// CHECK-DAG: [[ref_0_array_ref]] = !DILocalVariable(name: "ref_0_array_ref"
+// CHECK-DAG: [[ref_1_array_ref]] = !DILocalVariable(name: "ref_1_array_ref"
+// CHECK-DAG: [[ref_1_aggregate_4xi8_ref]] = !DILocalVariable(name: "ref_1_aggregate_4xi8_ref"
+
+// CHECK-DAG: [[ref_aggregate_4xi8]] = !DILocalVariable(name: "ref_aggregate_4xi8"
+// CHECK-DAG: [[ref_0_aggregate_4xi8]] = !DILocalVariable(name: "ref_0_aggregate_4xi8"
+
+// CHECK-DAG: [[ref_tuple_sliceref_scalar]] = !DILocalVariable(name: "ref_tuple_sliceref_scalar"
+// CHECK-DAG: [[ref_1_tuple_sliceref_scalar]] = !DILocalVariable(name: "ref_1_tuple_sliceref_scalar"
+// CHECK-DAG: [[ref_1_array]] = !DILocalVariable(name: "ref_1_array"
+// CHECK-DAG: [[ref_1_typle_i32_i64_i8]] = !DILocalVariable(name: "ref_1_typle_i32_i64_i8"
+// CHECK-DAG: [[ref_simd_i32x4]] = !DILocalVariable(name: "ref_simd_i32x4"
+
+// CHECK-DAG: [[ref_direct_ref]] = !DILocalVariable(name: "ref_direct_ref"
+// CHECK-DAG: [[ref_1_direct_ref]] = !DILocalVariable(name: "ref_1_direct_ref"
+// CHECK-DAG: [[ref_indirect_byval]] = !DILocalVariable(name: "ref_indirect_byval"
+// CHECK-DAG: [[ref_1_indirect_byval]] = !DILocalVariable(name: "ref_1_indirect_byval"
+
+// CHECK-DAG: [[ref_0_tuple_scalar_scalar]] = !DILocalVariable(name: "ref_0_tuple_scalar_scalar"
+// CHECK-DAG: [[ref_0_tuple_ref_scalar]] = !DILocalVariable(name: "ref_0_tuple_ref_scalar"
+// CHECK-DAG: [[ref_1_tuple_ref_scalar]] = !DILocalVariable(name: "ref_1_tuple_ref_scalar"
+// CHECK-DAG: [[ref_0_tuple_arrayref_scalar]] = !DILocalVariable(name: "ref_0_tuple_arrayref_scalar"
+// CHECK-DAG: [[ref_1_tuple_arrayref_scalar]] = !DILocalVariable(name: "ref_1_tuple_arrayref_scalar"
+// CHECK-DAG: [[ref_0_1_tuple_arrayref_scalar]] = !DILocalVariable(name: "ref_0_1_tuple_arrayref_scalar"
+// CHECK-DAG: [[ref_1_1_tuple_scalar_arrayref]] = !DILocalVariable(name: "ref_1_1_tuple_scalar_arrayref"
+// CHECK-DAG: [[ref_1_sliceref]] = !DILocalVariable(name: "ref_1_sliceref"
 
-#[inline(never)]
-pub fn opaque_use<T>(p: &T) {
-    opaque_inner(&raw const p as *const _);
-}
-
-#[no_mangle]
-pub fn non_arg_ref(scalar: i32, foo: Foo, a: &i32) -> i32 {
-    // CHECK-LABEL: define{{.*}} i32 @non_arg_ref
-    // CHECK: #dbg_value(ptr %non_arg_ref_scalar, [[VAR_non_arg_ref_scalar_ref:![0-9]+]], !DIExpression()
-    // CHECK-NEXT: #dbg_value(ptr %non_arg_ref_foo, [[VAR_non_arg_ref_foo_ref:![0-9]+]], !DIExpression()
-    // CHECK-NEXT: #dbg_value(ptr %non_arg_ref_foo, [[VAR_non_arg_ref_foo_ref_2:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 16, DW_OP_stack_value)
-    let non_arg_ref_scalar = scalar;
-    let non_arg_ref_foo = foo;
-    opaque_use(&non_arg_ref_scalar);
-    opaque_use(&non_arg_ref_foo);
-    let non_arg_ref_scalar_ref = &non_arg_ref_scalar;
-    let non_arg_ref_foo_ref = &non_arg_ref_foo;
-    let non_arg_ref_foo_ref_2 = &non_arg_ref_foo.2;
-    *a
-}
-
-// CHECK-DAG: [[VAR_invalid_ref_of_ref_foo]] = !DILocalVariable(name: "invalid_ref_of_ref_foo"
-// OPTIMIZED-DAG: [[VAR_ref_foo]] = !DILocalVariable(name: "ref_foo"
-// CHECK-DAG: [[VAR_ref_v0]] = !DILocalVariable(name: "ref_v0"
-// CHECK-DAG: [[VAR_ref_v1]] = !DILocalVariable(name: "ref_v1"
-// CHECK-DAG: [[VAR_ref_v2]] = !DILocalVariable(name: "ref_v2"
-// CHECK-DAG: [[ref_ptr_foo]] = !DILocalVariable(name: "ref_ptr_foo"
-// CHECK-DAG: [[VAR_ptr_v0]] = !DILocalVariable(name: "ptr_v0"
-// CHECK-DAG: [[VAR_ptr_v1]] = !DILocalVariable(name: "ptr_v1"
-// CHECK-DAG: [[VAR_ptr_v2]] = !DILocalVariable(name: "ptr_v2"
-// CODEGEN-DAG: [[VAR_val_ref]] = !DILocalVariable(name: "val_ref"
-// CHECK-DAG: [[VAR_fragment_f]] = !DILocalVariable(name: "fragment_f"
-// CHECK-DAG: [[VAR_deref_dead]] = !DILocalVariable(name: "deref_dead"
-// CHECK-DAG: [[VAR_tuple_dead]] = !DILocalVariable(name: "tuple_dead"
 // CHECK-DAG: [[ARG_dead_first_foo]] = !DILocalVariable(name: "dead_first_foo"
 // CHECK-DAG: [[VAR_dead_first_v0]] = !DILocalVariable(name: "dead_first_v0"
+
+// CHECK-DAG: [[VAR_fragment_f]] = !DILocalVariable(name: "fragment_f"
+
+// CHECK-DAG: [[VAR_deref_dead]] = !DILocalVariable(name: "deref_dead"
+
 // CHECK-DAG: [[VAR_index_from_var]] = !DILocalVariable(name: "index_from_var"
 // CHECK-DAG: [[VAR_const_index_from_start]] = !DILocalVariable(name: "const_index_from_start"
 // CHECK-DAG: [[VAR_const_index_from_end]] = !DILocalVariable(name: "const_index_from_end"
-// CHECK-DAG: [[VAR_zst_ref]] = !DILocalVariable(name: "zst_ref"
-// CHECK-DAG: [[VAR_non_arg_ref_scalar_ref]] = !DILocalVariable(name: "non_arg_ref_scalar_ref"
-// CHECK-DAG: [[VAR_non_arg_ref_foo_ref]] = !DILocalVariable(name: "non_arg_ref_foo_ref"
-// CHECK-DAG: [[VAR_non_arg_ref_foo_ref_2]] = !DILocalVariable(name: "non_arg_ref_foo_ref_2"

From d6fdadb8e93401b4c98763e90c2e181390d0bfd5 Mon Sep 17 00:00:00 2001
From: Jules Bertholet <julesbertholet@quoi.xyz>
Date: Fri, 3 Oct 2025 00:00:39 -0400
Subject: [PATCH 1684/1889] Mitigate `thread_local!` shadowing issues

Mitigates https://github.com/rust-lang/rust/issues/147006
and https://github.com/rust-lang/rust/issues/99018
---
 .../std/src/sys/thread_local/native/mod.rs    | 26 +++++++++----------
 .../std/src/sys/thread_local/no_threads.rs    | 16 ++++++------
 library/std/src/sys/thread_local/os.rs        |  8 +++---
 3 files changed, 25 insertions(+), 25 deletions(-)

diff --git a/library/std/src/sys/thread_local/native/mod.rs b/library/std/src/sys/thread_local/native/mod.rs
index 5dc142408047e..38b373be56c9d 100644
--- a/library/std/src/sys/thread_local/native/mod.rs
+++ b/library/std/src/sys/thread_local/native/mod.rs
@@ -55,7 +55,7 @@ pub macro thread_local_inner {
 
     // Used to generate the `LocalKey` value for const-initialized thread locals.
     (@key $t:ty, $(#[$align_attr:meta])*, const $init:expr) => {{
-        const __INIT: $t = $init;
+        const __RUST_STD_INTERNAL_INIT: $t = $init;
 
         unsafe {
             $crate::thread::LocalKey::new(const {
@@ -63,16 +63,16 @@ pub macro thread_local_inner {
                     |_| {
                         #[thread_local]
                         $(#[$align_attr])*
-                        static VAL: $crate::thread::local_impl::EagerStorage<$t>
-                            = $crate::thread::local_impl::EagerStorage::new(__INIT);
-                        VAL.get()
+                        static __RUST_STD_INTERNAL_VAL: $crate::thread::local_impl::EagerStorage<$t>
+                            = $crate::thread::local_impl::EagerStorage::new(__RUST_STD_INTERNAL_INIT);
+                        __RUST_STD_INTERNAL_VAL.get()
                     }
                 } else {
                     |_| {
                         #[thread_local]
                         $(#[$align_attr])*
-                        static VAL: $t = __INIT;
-                        &VAL
+                        static __RUST_STD_INTERNAL_VAL: $t = __RUST_STD_INTERNAL_INIT;
+                        &__RUST_STD_INTERNAL_VAL
                     }
                 }
             })
@@ -82,27 +82,27 @@ pub macro thread_local_inner {
     // used to generate the `LocalKey` value for `thread_local!`
     (@key $t:ty, $(#[$align_attr:meta])*, $init:expr) => {{
         #[inline]
-        fn __init() -> $t {
+        fn __rust_std_internal_init_fn() -> $t {
             $init
         }
 
         unsafe {
             $crate::thread::LocalKey::new(const {
                 if $crate::mem::needs_drop::<$t>() {
-                    |init| {
+                    |__rust_std_internal_init| {
                         #[thread_local]
                         $(#[$align_attr])*
-                        static VAL: $crate::thread::local_impl::LazyStorage<$t, ()>
+                        static __RUST_STD_INTERNAL_VAL: $crate::thread::local_impl::LazyStorage<$t, ()>
                             = $crate::thread::local_impl::LazyStorage::new();
-                        VAL.get_or_init(init, __init)
+                        __RUST_STD_INTERNAL_VAL.get_or_init(__rust_std_internal_init, __rust_std_internal_init_fn)
                     }
                 } else {
-                    |init| {
+                    |__rust_std_internal_init| {
                         #[thread_local]
                         $(#[$align_attr])*
-                        static VAL: $crate::thread::local_impl::LazyStorage<$t, !>
+                        static __RUST_STD_INTERNAL_VAL: $crate::thread::local_impl::LazyStorage<$t, !>
                             = $crate::thread::local_impl::LazyStorage::new();
-                        VAL.get_or_init(init, __init)
+                        __RUST_STD_INTERNAL_VAL.get_or_init(__rust_std_internal_init, __rust_std_internal_init_fn)
                     }
                 }
             })
diff --git a/library/std/src/sys/thread_local/no_threads.rs b/library/std/src/sys/thread_local/no_threads.rs
index 409dfb19518d9..936d464be9f1c 100644
--- a/library/std/src/sys/thread_local/no_threads.rs
+++ b/library/std/src/sys/thread_local/no_threads.rs
@@ -13,15 +13,15 @@ use crate::ptr;
 pub macro thread_local_inner {
     // used to generate the `LocalKey` value for const-initialized thread locals
     (@key $t:ty, $(#[$align_attr:meta])*, const $init:expr) => {{
-        const __INIT: $t = $init;
+        const __RUST_STD_INTERNAL_INIT: $t = $init;
 
         // NOTE: Please update the shadowing test in `tests/thread.rs` if these types are renamed.
         unsafe {
             $crate::thread::LocalKey::new(|_| {
                 $(#[$align_attr])*
-                static VAL: $crate::thread::local_impl::EagerStorage<$t> =
-                    $crate::thread::local_impl::EagerStorage { value: __INIT };
-                &VAL.value
+                static __RUST_STD_INTERNAL_VAL: $crate::thread::local_impl::EagerStorage<$t> =
+                    $crate::thread::local_impl::EagerStorage { value: __RUST_STD_INTERNAL_INIT };
+                &__RUST_STD_INTERNAL_VAL.value
             })
         }
     }},
@@ -29,13 +29,13 @@ pub macro thread_local_inner {
     // used to generate the `LocalKey` value for `thread_local!`
     (@key $t:ty, $(#[$align_attr:meta])*, $init:expr) => {{
         #[inline]
-        fn __init() -> $t { $init }
+        fn __rust_std_internal_init_fn() -> $t { $init }
 
         unsafe {
-            $crate::thread::LocalKey::new(|init| {
+            $crate::thread::LocalKey::new(|__rust_std_internal_init| {
                 $(#[$align_attr])*
-                static VAL: $crate::thread::local_impl::LazyStorage<$t> = $crate::thread::local_impl::LazyStorage::new();
-                VAL.get(init, __init)
+                static __RUST_STD_INTERNAL_VAL: $crate::thread::local_impl::LazyStorage<$t> = $crate::thread::local_impl::LazyStorage::new();
+                __RUST_STD_INTERNAL_VAL.get(__rust_std_internal_init, __rust_std_internal_init_fn)
             })
         }
     }},
diff --git a/library/std/src/sys/thread_local/os.rs b/library/std/src/sys/thread_local/os.rs
index 88bb5ae7c650d..9f7a29236e926 100644
--- a/library/std/src/sys/thread_local/os.rs
+++ b/library/std/src/sys/thread_local/os.rs
@@ -21,14 +21,14 @@ pub macro thread_local_inner {
     // used to generate the `LocalKey` value for `thread_local!`.
     (@key $t:ty, $($(#[$($align_attr:tt)*])+)?, $init:expr) => {{
         #[inline]
-        fn __init() -> $t { $init }
+        fn __rust_std_internal_init_fn() -> $t { $init }
 
         // NOTE: this cannot import `LocalKey` or `Storage` with a `use` because that can shadow
         // user provided type or type alias with a matching name. Please update the shadowing test
         // in `tests/thread.rs` if these types are renamed.
         unsafe {
-            $crate::thread::LocalKey::new(|init| {
-                static VAL: $crate::thread::local_impl::Storage<$t, {
+            $crate::thread::LocalKey::new(|__rust_std_internal_init| {
+                static __RUST_STD_INTERNAL_VAL: $crate::thread::local_impl::Storage<$t, {
                     $({
                         // Ensure that attributes have valid syntax
                         // and that the proper feature gate is enabled
@@ -43,7 +43,7 @@ pub macro thread_local_inner {
                     final_align
                 }>
                     = $crate::thread::local_impl::Storage::new();
-                VAL.get(init, __init)
+                __RUST_STD_INTERNAL_VAL.get(__rust_std_internal_init, __rust_std_internal_init_fn)
             })
         }
     }},

From 3d5f54ad55a32c0f53271597145b5cd7bae9c3e2 Mon Sep 17 00:00:00 2001
From: Urgau <urgau@numericable.fr>
Date: Fri, 3 Oct 2025 11:27:57 +0200
Subject: [PATCH 1685/1889] Respect `-Z` unstable options in `rustdoc --test`

---
 src/librustdoc/doctest.rs                     |   1 +
 .../rustdoc-ui/doctest/check-attr-test.stderr | 164 +++++++++---------
 ...led-doctest-extra-semicolon-on-item.stderr |   2 +-
 .../doctest/main-alongside-stmts.stderr       |   4 +-
 .../doctest/standalone-warning-2024.stderr    |  30 ++--
 .../doctest/test-compile-fail1.stderr         |  18 +-
 .../doctest/test-compile-fail2.stderr         |   8 +-
 .../doctest/test-compile-fail3.stderr         |   8 +-
 .../doctest/warn-main-not-called.stderr       |   4 +-
 9 files changed, 120 insertions(+), 119 deletions(-)

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index 95bd31729de18..38a0c925d2a45 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -173,6 +173,7 @@ pub(crate) fn run(dcx: DiagCtxtHandle<'_>, input: Input, options: RustdocOptions
         target_triple: options.target.clone(),
         crate_name: options.crate_name.clone(),
         remap_path_prefix: options.remap_path_prefix.clone(),
+        unstable_opts: options.unstable_opts.clone(),
         ..config::Options::default()
     };
 
diff --git a/tests/rustdoc-ui/doctest/check-attr-test.stderr b/tests/rustdoc-ui/doctest/check-attr-test.stderr
index 257136d1633d3..4cf93033ae8a0 100644
--- a/tests/rustdoc-ui/doctest/check-attr-test.stderr
+++ b/tests/rustdoc-ui/doctest/check-attr-test.stderr
@@ -1,55 +1,55 @@
 error: unknown attribute `compile-fail`
- --> $DIR/check-attr-test.rs:5:1
-  |
-5 | / /// foo
-6 | | ///
-7 | | /// ```compile-fail,compilefail,comPile_fail
-8 | | /// boo
-9 | | /// ```
-  | |_______^
-  |
-  = help: use `compile_fail` to invert the results of this test, so that it passes if it cannot be compiled and fails if it can
-  = help: this code block may be skipped during testing, because unknown attributes are treated as markers for code samples written in other programming languages, unless it is also explicitly marked as `rust`
+  --> $DIR/check-attr-test.rs:5:1
+   |
+LL | / /// foo
+LL | | ///
+LL | | /// ```compile-fail,compilefail,comPile_fail
+LL | | /// boo
+LL | | /// ```
+   | |_______^
+   |
+   = help: use `compile_fail` to invert the results of this test, so that it passes if it cannot be compiled and fails if it can
+   = help: this code block may be skipped during testing, because unknown attributes are treated as markers for code samples written in other programming languages, unless it is also explicitly marked as `rust`
 note: the lint level is defined here
- --> $DIR/check-attr-test.rs:3:9
-  |
-3 | #![deny(rustdoc::invalid_codeblock_attributes)]
-  |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  --> $DIR/check-attr-test.rs:3:9
+   |
+LL | #![deny(rustdoc::invalid_codeblock_attributes)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: unknown attribute `compilefail`
- --> $DIR/check-attr-test.rs:5:1
-  |
-5 | / /// foo
-6 | | ///
-7 | | /// ```compile-fail,compilefail,comPile_fail
-8 | | /// boo
-9 | | /// ```
-  | |_______^
-  |
-  = help: use `compile_fail` to invert the results of this test, so that it passes if it cannot be compiled and fails if it can
-  = help: this code block may be skipped during testing, because unknown attributes are treated as markers for code samples written in other programming languages, unless it is also explicitly marked as `rust`
+  --> $DIR/check-attr-test.rs:5:1
+   |
+LL | / /// foo
+LL | | ///
+LL | | /// ```compile-fail,compilefail,comPile_fail
+LL | | /// boo
+LL | | /// ```
+   | |_______^
+   |
+   = help: use `compile_fail` to invert the results of this test, so that it passes if it cannot be compiled and fails if it can
+   = help: this code block may be skipped during testing, because unknown attributes are treated as markers for code samples written in other programming languages, unless it is also explicitly marked as `rust`
 
 error: unknown attribute `comPile_fail`
- --> $DIR/check-attr-test.rs:5:1
-  |
-5 | / /// foo
-6 | | ///
-7 | | /// ```compile-fail,compilefail,comPile_fail
-8 | | /// boo
-9 | | /// ```
-  | |_______^
-  |
-  = help: use `compile_fail` to invert the results of this test, so that it passes if it cannot be compiled and fails if it can
-  = help: this code block may be skipped during testing, because unknown attributes are treated as markers for code samples written in other programming languages, unless it is also explicitly marked as `rust`
+  --> $DIR/check-attr-test.rs:5:1
+   |
+LL | / /// foo
+LL | | ///
+LL | | /// ```compile-fail,compilefail,comPile_fail
+LL | | /// boo
+LL | | /// ```
+   | |_______^
+   |
+   = help: use `compile_fail` to invert the results of this test, so that it passes if it cannot be compiled and fails if it can
+   = help: this code block may be skipped during testing, because unknown attributes are treated as markers for code samples written in other programming languages, unless it is also explicitly marked as `rust`
 
 error: unknown attribute `should-panic`
   --> $DIR/check-attr-test.rs:12:1
    |
-12 | / /// bar
-13 | | ///
-14 | | /// ```should-panic,shouldpanic,shOuld_panic
-15 | | /// boo
-16 | | /// ```
+LL | / /// bar
+LL | | ///
+LL | | /// ```should-panic,shouldpanic,shOuld_panic
+LL | | /// boo
+LL | | /// ```
    | |_______^
    |
    = help: use `should_panic` to invert the results of this test, so that if passes if it panics and fails if it does not
@@ -58,11 +58,11 @@ error: unknown attribute `should-panic`
 error: unknown attribute `shouldpanic`
   --> $DIR/check-attr-test.rs:12:1
    |
-12 | / /// bar
-13 | | ///
-14 | | /// ```should-panic,shouldpanic,shOuld_panic
-15 | | /// boo
-16 | | /// ```
+LL | / /// bar
+LL | | ///
+LL | | /// ```should-panic,shouldpanic,shOuld_panic
+LL | | /// boo
+LL | | /// ```
    | |_______^
    |
    = help: use `should_panic` to invert the results of this test, so that if passes if it panics and fails if it does not
@@ -71,11 +71,11 @@ error: unknown attribute `shouldpanic`
 error: unknown attribute `shOuld_panic`
   --> $DIR/check-attr-test.rs:12:1
    |
-12 | / /// bar
-13 | | ///
-14 | | /// ```should-panic,shouldpanic,shOuld_panic
-15 | | /// boo
-16 | | /// ```
+LL | / /// bar
+LL | | ///
+LL | | /// ```should-panic,shouldpanic,shOuld_panic
+LL | | /// boo
+LL | | /// ```
    | |_______^
    |
    = help: use `should_panic` to invert the results of this test, so that if passes if it panics and fails if it does not
@@ -84,11 +84,11 @@ error: unknown attribute `shOuld_panic`
 error: unknown attribute `no-run`
   --> $DIR/check-attr-test.rs:19:1
    |
-19 | / /// foobar
-20 | | ///
-21 | | /// ```no-run,norun,nO_run
-22 | | /// boo
-23 | | /// ```
+LL | / /// foobar
+LL | | ///
+LL | | /// ```no-run,norun,nO_run
+LL | | /// boo
+LL | | /// ```
    | |_______^
    |
    = help: use `no_run` to compile, but not run, the code sample during testing
@@ -97,11 +97,11 @@ error: unknown attribute `no-run`
 error: unknown attribute `norun`
   --> $DIR/check-attr-test.rs:19:1
    |
-19 | / /// foobar
-20 | | ///
-21 | | /// ```no-run,norun,nO_run
-22 | | /// boo
-23 | | /// ```
+LL | / /// foobar
+LL | | ///
+LL | | /// ```no-run,norun,nO_run
+LL | | /// boo
+LL | | /// ```
    | |_______^
    |
    = help: use `no_run` to compile, but not run, the code sample during testing
@@ -110,11 +110,11 @@ error: unknown attribute `norun`
 error: unknown attribute `nO_run`
   --> $DIR/check-attr-test.rs:19:1
    |
-19 | / /// foobar
-20 | | ///
-21 | | /// ```no-run,norun,nO_run
-22 | | /// boo
-23 | | /// ```
+LL | / /// foobar
+LL | | ///
+LL | | /// ```no-run,norun,nO_run
+LL | | /// boo
+LL | | /// ```
    | |_______^
    |
    = help: use `no_run` to compile, but not run, the code sample during testing
@@ -123,11 +123,11 @@ error: unknown attribute `nO_run`
 error: unknown attribute `test-harness`
   --> $DIR/check-attr-test.rs:26:1
    |
-26 | / /// b
-27 | | ///
-28 | | /// ```test-harness,testharness,tesT_harness
-29 | | /// boo
-30 | | /// ```
+LL | / /// b
+LL | | ///
+LL | | /// ```test-harness,testharness,tesT_harness
+LL | | /// boo
+LL | | /// ```
    | |_______^
    |
    = help: use `test_harness` to run functions marked `#[test]` instead of a potentially-implicit `main` function
@@ -136,11 +136,11 @@ error: unknown attribute `test-harness`
 error: unknown attribute `testharness`
   --> $DIR/check-attr-test.rs:26:1
    |
-26 | / /// b
-27 | | ///
-28 | | /// ```test-harness,testharness,tesT_harness
-29 | | /// boo
-30 | | /// ```
+LL | / /// b
+LL | | ///
+LL | | /// ```test-harness,testharness,tesT_harness
+LL | | /// boo
+LL | | /// ```
    | |_______^
    |
    = help: use `test_harness` to run functions marked `#[test]` instead of a potentially-implicit `main` function
@@ -149,11 +149,11 @@ error: unknown attribute `testharness`
 error: unknown attribute `tesT_harness`
   --> $DIR/check-attr-test.rs:26:1
    |
-26 | / /// b
-27 | | ///
-28 | | /// ```test-harness,testharness,tesT_harness
-29 | | /// boo
-30 | | /// ```
+LL | / /// b
+LL | | ///
+LL | | /// ```test-harness,testharness,tesT_harness
+LL | | /// boo
+LL | | /// ```
    | |_______^
    |
    = help: use `test_harness` to run functions marked `#[test]` instead of a potentially-implicit `main` function
diff --git a/tests/rustdoc-ui/doctest/failed-doctest-extra-semicolon-on-item.stderr b/tests/rustdoc-ui/doctest/failed-doctest-extra-semicolon-on-item.stderr
index 113fb7ccb60ee..cffda43ba1c94 100644
--- a/tests/rustdoc-ui/doctest/failed-doctest-extra-semicolon-on-item.stderr
+++ b/tests/rustdoc-ui/doctest/failed-doctest-extra-semicolon-on-item.stderr
@@ -1,7 +1,7 @@
 warning: the `main` function of this doctest won't be run as it contains expressions at the top level, meaning that the whole doctest code will be wrapped in a function
   --> $DIR/failed-doctest-extra-semicolon-on-item.rs:11:1
    |
-11 | /// ```rust
+LL | /// ```rust
    | ^^^^^^^^^^^
 
 warning: 1 warning emitted
diff --git a/tests/rustdoc-ui/doctest/main-alongside-stmts.stderr b/tests/rustdoc-ui/doctest/main-alongside-stmts.stderr
index d90a289ca6989..3f347d96ab063 100644
--- a/tests/rustdoc-ui/doctest/main-alongside-stmts.stderr
+++ b/tests/rustdoc-ui/doctest/main-alongside-stmts.stderr
@@ -1,13 +1,13 @@
 warning: the `main` function of this doctest won't be run as it contains expressions at the top level, meaning that the whole doctest code will be wrapped in a function
   --> $DIR/main-alongside-stmts.rs:17:1
    |
-17 | //! ```
+LL | //! ```
    | ^^^^^^^
 
 warning: the `main` function of this doctest won't be run as it contains expressions at the top level, meaning that the whole doctest code will be wrapped in a function
   --> $DIR/main-alongside-stmts.rs:26:1
    |
-26 | //! ```
+LL | //! ```
    | ^^^^^^^
 
 warning: 2 warnings emitted
diff --git a/tests/rustdoc-ui/doctest/standalone-warning-2024.stderr b/tests/rustdoc-ui/doctest/standalone-warning-2024.stderr
index ce65557c2c4a4..1af2ded58e8b4 100644
--- a/tests/rustdoc-ui/doctest/standalone-warning-2024.stderr
+++ b/tests/rustdoc-ui/doctest/standalone-warning-2024.stderr
@@ -1,13 +1,13 @@
 error: unknown attribute `standalone`
   --> $DIR/standalone-warning-2024.rs:11:1
    |
-11 | / //! ```standalone
-12 | | //! bla
-13 | | //! ```
-14 | | //!
-15 | | //! ```standalone-crate
-16 | | //! bla
-17 | | //! ```
+LL | / //! ```standalone
+LL | | //! bla
+LL | | //! ```
+LL | | //!
+LL | | //! ```standalone-crate
+LL | | //! bla
+LL | | //! ```
    | |_______^
    |
    = help: use `standalone_crate` to compile this code block separately
@@ -15,20 +15,20 @@ error: unknown attribute `standalone`
 note: the lint level is defined here
   --> $DIR/standalone-warning-2024.rs:9:9
    |
- 9 | #![deny(warnings)]
+LL | #![deny(warnings)]
    |         ^^^^^^^^
    = note: `#[deny(rustdoc::invalid_codeblock_attributes)]` implied by `#[deny(warnings)]`
 
 error: unknown attribute `standalone-crate`
   --> $DIR/standalone-warning-2024.rs:11:1
    |
-11 | / //! ```standalone
-12 | | //! bla
-13 | | //! ```
-14 | | //!
-15 | | //! ```standalone-crate
-16 | | //! bla
-17 | | //! ```
+LL | / //! ```standalone
+LL | | //! bla
+LL | | //! ```
+LL | | //!
+LL | | //! ```standalone-crate
+LL | | //! bla
+LL | | //! ```
    | |_______^
    |
    = help: use `standalone_crate` to compile this code block separately
diff --git a/tests/rustdoc-ui/doctest/test-compile-fail1.stderr b/tests/rustdoc-ui/doctest/test-compile-fail1.stderr
index 02f4d8d754f9b..aa5cc2e14d6d6 100644
--- a/tests/rustdoc-ui/doctest/test-compile-fail1.stderr
+++ b/tests/rustdoc-ui/doctest/test-compile-fail1.stderr
@@ -1,13 +1,13 @@
 error[E0428]: the name `f` is defined multiple times
- --> $DIR/test-compile-fail1.rs:8:1
-  |
-6 | pub fn f() {}
-  | ---------- previous definition of the value `f` here
-7 |
-8 | pub fn f() {}
-  | ^^^^^^^^^^ `f` redefined here
-  |
-  = note: `f` must be defined only once in the value namespace of this module
+  --> $DIR/test-compile-fail1.rs:8:1
+   |
+LL | pub fn f() {}
+   | ---------- previous definition of the value `f` here
+LL |
+LL | pub fn f() {}
+   | ^^^^^^^^^^ `f` redefined here
+   |
+   = note: `f` must be defined only once in the value namespace of this module
 
 error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/doctest/test-compile-fail2.stderr b/tests/rustdoc-ui/doctest/test-compile-fail2.stderr
index f0ad40eb6ca81..9f50c857275c6 100644
--- a/tests/rustdoc-ui/doctest/test-compile-fail2.stderr
+++ b/tests/rustdoc-ui/doctest/test-compile-fail2.stderr
@@ -1,8 +1,8 @@
 error: expected one of `!` or `::`, found `<eof>`
- --> $DIR/test-compile-fail2.rs:3:1
-  |
-3 | fail
-  | ^^^^ expected one of `!` or `::`
+  --> $DIR/test-compile-fail2.rs:3:1
+   |
+LL | fail
+   | ^^^^ expected one of `!` or `::`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/doctest/test-compile-fail3.stderr b/tests/rustdoc-ui/doctest/test-compile-fail3.stderr
index 09d78b2f34673..9f90a428d480f 100644
--- a/tests/rustdoc-ui/doctest/test-compile-fail3.stderr
+++ b/tests/rustdoc-ui/doctest/test-compile-fail3.stderr
@@ -1,8 +1,8 @@
 error[E0765]: unterminated double quote string
- --> $DIR/test-compile-fail3.rs:3:1
-  |
-3 | "fail
-  | ^^^^^
+  --> $DIR/test-compile-fail3.rs:3:1
+   |
+LL | "fail
+   | ^^^^^
 
 error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/doctest/warn-main-not-called.stderr b/tests/rustdoc-ui/doctest/warn-main-not-called.stderr
index 3a079f47555b6..b5b7bc57644a6 100644
--- a/tests/rustdoc-ui/doctest/warn-main-not-called.stderr
+++ b/tests/rustdoc-ui/doctest/warn-main-not-called.stderr
@@ -1,13 +1,13 @@
 warning: the `main` function of this doctest won't be run as it contains expressions at the top level, meaning that the whole doctest code will be wrapped in a function
   --> $DIR/warn-main-not-called.rs:10:1
    |
-10 | //! ```
+LL | //! ```
    | ^^^^^^^
 
 warning: the `main` function of this doctest won't be run as it contains expressions at the top level, meaning that the whole doctest code will be wrapped in a function
   --> $DIR/warn-main-not-called.rs:19:1
    |
-19 | //! ```
+LL | //! ```
    | ^^^^^^^
 
 warning: 2 warnings emitted

From cb0f969b623a7e12a0d8166c9a498e17a8b5a3c4 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Fri, 3 Oct 2025 16:57:24 +1000
Subject: [PATCH 1686/1889] Avoid getting `dep_dep_node` unnecessarily.

It's gotten on a hot path but only for use within `debug!`.
---
 compiler/rustc_query_system/src/dep_graph/graph.rs | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/compiler/rustc_query_system/src/dep_graph/graph.rs b/compiler/rustc_query_system/src/dep_graph/graph.rs
index 7e258aaa54f79..eafb38bd25bbb 100644
--- a/compiler/rustc_query_system/src/dep_graph/graph.rs
+++ b/compiler/rustc_query_system/src/dep_graph/graph.rs
@@ -876,14 +876,19 @@ impl<D: Deps> DepGraphData<D> {
         frame: Option<&MarkFrame<'_>>,
     ) -> Option<()> {
         let dep_dep_node_color = self.colors.get(parent_dep_node_index);
-        let dep_dep_node = &self.previous.index_to_node(parent_dep_node_index);
+
+        let get_dep_dep_node = || self.previous.index_to_node(parent_dep_node_index);
 
         match dep_dep_node_color {
             Some(DepNodeColor::Green(_)) => {
                 // This dependency has been marked as green before, we are
                 // still fine and can continue with checking the other
                 // dependencies.
-                debug!("dependency {dep_dep_node:?} was immediately green");
+                //
+                // This path is extremely hot. We don't want to get the
+                // `dep_dep_node` unless it's necessary. Hence the
+                // `get_dep_dep_node` closure.
+                debug!("dependency {:?} was immediately green", get_dep_dep_node());
                 return Some(());
             }
             Some(DepNodeColor::Red) => {
@@ -891,12 +896,14 @@ impl<D: Deps> DepGraphData<D> {
                 // compared to the previous compilation session. We cannot
                 // mark the DepNode as green and also don't need to bother
                 // with checking any of the other dependencies.
-                debug!("dependency {dep_dep_node:?} was immediately red");
+                debug!("dependency {:?} was immediately red", get_dep_dep_node());
                 return None;
             }
             None => {}
         }
 
+        let dep_dep_node = &get_dep_dep_node();
+
         // We don't know the state of this dependency. If it isn't
         // an eval_always node, let's try to mark it green recursively.
         if !qcx.dep_context().is_eval_always(dep_dep_node.kind) {

From 3a287e6034e1339198908cd7253fa414447c97d3 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Fri, 3 Oct 2025 16:58:03 +1000
Subject: [PATCH 1687/1889] Remove some unnecessary locals.

They both have a single use. (They can't be united, though, because
`self.colors` might change between the two `get` calls.)
---
 compiler/rustc_query_system/src/dep_graph/graph.rs | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_query_system/src/dep_graph/graph.rs b/compiler/rustc_query_system/src/dep_graph/graph.rs
index eafb38bd25bbb..5e62dab0722c6 100644
--- a/compiler/rustc_query_system/src/dep_graph/graph.rs
+++ b/compiler/rustc_query_system/src/dep_graph/graph.rs
@@ -875,11 +875,9 @@ impl<D: Deps> DepGraphData<D> {
         parent_dep_node_index: SerializedDepNodeIndex,
         frame: Option<&MarkFrame<'_>>,
     ) -> Option<()> {
-        let dep_dep_node_color = self.colors.get(parent_dep_node_index);
-
         let get_dep_dep_node = || self.previous.index_to_node(parent_dep_node_index);
 
-        match dep_dep_node_color {
+        match self.colors.get(parent_dep_node_index) {
             Some(DepNodeColor::Green(_)) => {
                 // This dependency has been marked as green before, we are
                 // still fine and can continue with checking the other
@@ -929,9 +927,7 @@ impl<D: Deps> DepGraphData<D> {
             return None;
         }
 
-        let dep_dep_node_color = self.colors.get(parent_dep_node_index);
-
-        match dep_dep_node_color {
+        match self.colors.get(parent_dep_node_index) {
             Some(DepNodeColor::Green(_)) => {
                 debug!("managed to FORCE dependency {dep_dep_node:?} to green");
                 return Some(());

From 74caed9a4502c97c44d9c578e8ba50500da3d8fb Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Fri, 3 Oct 2025 15:15:45 +0200
Subject: [PATCH 1688/1889] cg_gcc.md: add missing quote

---
 .../rustc-dev-guide/src/tests/codegen-backend-tests/cg_gcc.md   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/src/tests/codegen-backend-tests/cg_gcc.md b/src/doc/rustc-dev-guide/src/tests/codegen-backend-tests/cg_gcc.md
index 74dbfb7d31b30..aa337754186d6 100644
--- a/src/doc/rustc-dev-guide/src/tests/codegen-backend-tests/cg_gcc.md
+++ b/src/doc/rustc-dev-guide/src/tests/codegen-backend-tests/cg_gcc.md
@@ -20,7 +20,7 @@ rust.codegen-backends = ["llvm", "gcc"]
 ```
 
 If you don't want to change your `bootstrap.toml` file, you can alternatively run your `x`
-commands with `--set rust.codegen-backends=["llvm", "gcc"]'`. For example:
+commands with `--set 'rust.codegen-backends=["llvm", "gcc"]'`. For example:
 
 ```bash
 ./x build --set 'rust.codegen-backends=["llvm", "gcc"]'

From 87d2891e82707c8c9730997f2f4771d4cebdbb22 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Mon, 29 Sep 2025 22:31:41 +0200
Subject: [PATCH 1689/1889] Cleanup `should_implement_trait` lint code

---
 .../src/methods/should_implement_trait.rs     | 153 ++++++++----------
 1 file changed, 69 insertions(+), 84 deletions(-)

diff --git a/clippy_lints/src/methods/should_implement_trait.rs b/clippy_lints/src/methods/should_implement_trait.rs
index 5f13b8c7e91df..599ff696f6aed 100644
--- a/clippy_lints/src/methods/should_implement_trait.rs
+++ b/clippy_lints/src/methods/should_implement_trait.rs
@@ -1,8 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::{is_bool, sym};
 use rustc_abi::ExternAbi;
-use rustc_hir as hir;
-use rustc_hir::{FnSig, ImplItem};
+use rustc_hir::{self as hir, FnRetTy, FnSig, GenericParamKind, ImplItem, LifetimeParamKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::Ty;
 use rustc_span::edition::Edition::{self, Edition2015, Edition2021};
@@ -20,51 +19,43 @@ pub(super) fn check_impl_item<'tcx>(
     sig: &FnSig<'_>,
 ) {
     // if this impl block implements a trait, lint in trait definition instead
-    if !impl_implements_trait && cx.effective_visibilities.is_exported(impl_item.owner_id.def_id) {
+    if !impl_implements_trait && cx.effective_visibilities.is_exported(impl_item.owner_id.def_id)
         // check missing trait implementations
-        for method_config in &TRAIT_METHODS {
-            if impl_item.ident.name == method_config.method_name
-                && sig.decl.inputs.len() == method_config.param_count
-                && method_config.output_type.matches(&sig.decl.output)
-                // in case there is no first arg, since we already have checked the number of arguments
-                // it's should be always true
-                && first_arg_ty_opt
-                    .is_none_or(|first_arg_ty| method_config.self_kind.matches(cx, self_ty, first_arg_ty))
-                && fn_header_equals(method_config.fn_header, sig.header)
-                && method_config.lifetime_param_cond(impl_item)
-                && method_config.in_prelude_since <= cx.tcx.sess.edition()
-            {
-                span_lint_and_help(
-                    cx,
-                    SHOULD_IMPLEMENT_TRAIT,
-                    impl_item.span,
-                    format!(
-                        "method `{}` can be confused for the standard trait method `{}::{}`",
-                        method_config.method_name, method_config.trait_name, method_config.method_name
-                    ),
-                    None,
-                    format!(
-                        "consider implementing the trait `{}` or choosing a less ambiguous method name",
-                        method_config.trait_name
-                    ),
-                );
-            }
-        }
+        && let Some(method_config) = TRAIT_METHODS.iter().find(|case| case.method_name == impl_item.ident.name)
+        && sig.decl.inputs.len() == method_config.param_count
+        && method_config.output_type.matches(&sig.decl.output)
+        // in case there is no first arg, since we already have checked the number of arguments
+        // it's should be always true
+        && first_arg_ty_opt
+            .is_none_or(|first_arg_ty| method_config.self_kind.matches(cx, self_ty, first_arg_ty))
+        && sig.header.is_safe()
+        && !sig.header.is_const()
+        && !sig.header.is_async()
+        && sig.header.abi == ExternAbi::Rust
+        && method_config.lifetime_param_cond(impl_item)
+        && method_config.in_prelude_since <= cx.tcx.sess.edition()
+    {
+        span_lint_and_help(
+            cx,
+            SHOULD_IMPLEMENT_TRAIT,
+            impl_item.span,
+            format!(
+                "method `{}` can be confused for the standard trait method `{}::{}`",
+                method_config.method_name, method_config.trait_name, method_config.method_name
+            ),
+            None,
+            format!(
+                "consider implementing the trait `{}` or choosing a less ambiguous method name",
+                method_config.trait_name
+            ),
+        );
     }
 }
 
-const FN_HEADER: hir::FnHeader = hir::FnHeader {
-    safety: hir::HeaderSafety::Normal(hir::Safety::Safe),
-    constness: hir::Constness::NotConst,
-    asyncness: hir::IsAsync::NotAsync,
-    abi: ExternAbi::Rust,
-};
-
 struct ShouldImplTraitCase {
     trait_name: &'static str,
     method_name: Symbol,
     param_count: usize,
-    fn_header: hir::FnHeader,
     // implicit self kind expected (none, self, &self, ...)
     self_kind: SelfKind,
     // checks against the output type
@@ -73,13 +64,12 @@ struct ShouldImplTraitCase {
     lint_explicit_lifetime: bool,
     in_prelude_since: Edition,
 }
+
 impl ShouldImplTraitCase {
-    #[expect(clippy::too_many_arguments)]
     const fn new(
         trait_name: &'static str,
         method_name: Symbol,
         param_count: usize,
-        fn_header: hir::FnHeader,
         self_kind: SelfKind,
         output_type: OutType,
         lint_explicit_lifetime: bool,
@@ -89,7 +79,6 @@ impl ShouldImplTraitCase {
             trait_name,
             method_name,
             param_count,
-            fn_header,
             self_kind,
             output_type,
             lint_explicit_lifetime,
@@ -102,8 +91,8 @@ impl ShouldImplTraitCase {
             || !impl_item.generics.params.iter().any(|p| {
                 matches!(
                     p.kind,
-                    hir::GenericParamKind::Lifetime {
-                        kind: hir::LifetimeParamKind::Explicit
+                    GenericParamKind::Lifetime {
+                        kind: LifetimeParamKind::Explicit
                     }
                 )
             })
@@ -112,36 +101,36 @@ impl ShouldImplTraitCase {
 
 #[rustfmt::skip]
 const TRAIT_METHODS: [ShouldImplTraitCase; 30] = [
-    ShouldImplTraitCase::new("std::ops::Add",           sym::add,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true,  Edition2015),
-    ShouldImplTraitCase::new("std::convert::AsMut",     sym::as_mut,     1,  FN_HEADER, SelfKind::RefMut, OutType::Ref,  true,  Edition2015),
-    ShouldImplTraitCase::new("std::convert::AsRef",     sym::as_ref,     1,  FN_HEADER, SelfKind::Ref,    OutType::Ref,  true,  Edition2015),
-    ShouldImplTraitCase::new("std::ops::BitAnd",        sym::bitand,     2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true,  Edition2015),
-    ShouldImplTraitCase::new("std::ops::BitOr",         sym::bitor,      2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true,  Edition2015),
-    ShouldImplTraitCase::new("std::ops::BitXor",        sym::bitxor,     2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true,  Edition2015),
-    ShouldImplTraitCase::new("std::borrow::Borrow",     sym::borrow,     1,  FN_HEADER, SelfKind::Ref,    OutType::Ref,  true,  Edition2015),
-    ShouldImplTraitCase::new("std::borrow::BorrowMut",  sym::borrow_mut, 1,  FN_HEADER, SelfKind::RefMut, OutType::Ref,  true,  Edition2015),
-    ShouldImplTraitCase::new("std::clone::Clone",       sym::clone,      1,  FN_HEADER, SelfKind::Ref,    OutType::Any,  true,  Edition2015),
-    ShouldImplTraitCase::new("std::cmp::Ord",           sym::cmp,        2,  FN_HEADER, SelfKind::Ref,    OutType::Any,  true,  Edition2015),
-    ShouldImplTraitCase::new("std::default::Default",   kw::Default,     0,  FN_HEADER, SelfKind::No,     OutType::Any,  true,  Edition2015),
-    ShouldImplTraitCase::new("std::ops::Deref",         sym::deref,      1,  FN_HEADER, SelfKind::Ref,    OutType::Ref,  true,  Edition2015),
-    ShouldImplTraitCase::new("std::ops::DerefMut",      sym::deref_mut,  1,  FN_HEADER, SelfKind::RefMut, OutType::Ref,  true,  Edition2015),
-    ShouldImplTraitCase::new("std::ops::Div",           sym::div,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true,  Edition2015),
-    ShouldImplTraitCase::new("std::ops::Drop",          sym::drop,       1,  FN_HEADER, SelfKind::RefMut, OutType::Unit, true,  Edition2015),
-    ShouldImplTraitCase::new("std::cmp::PartialEq",     sym::eq,         2,  FN_HEADER, SelfKind::Ref,    OutType::Bool, true,  Edition2015),
-    ShouldImplTraitCase::new("std::iter::FromIterator", sym::from_iter,  1,  FN_HEADER, SelfKind::No,     OutType::Any,  true,  Edition2021),
-    ShouldImplTraitCase::new("std::str::FromStr",       sym::from_str,   1,  FN_HEADER, SelfKind::No,     OutType::Any,  true,  Edition2015),
-    ShouldImplTraitCase::new("std::hash::Hash",         sym::hash,       2,  FN_HEADER, SelfKind::Ref,    OutType::Unit, true,  Edition2015),
-    ShouldImplTraitCase::new("std::ops::Index",         sym::index,      2,  FN_HEADER, SelfKind::Ref,    OutType::Ref,  true,  Edition2015),
-    ShouldImplTraitCase::new("std::ops::IndexMut",      sym::index_mut,  2,  FN_HEADER, SelfKind::RefMut, OutType::Ref,  true,  Edition2015),
-    ShouldImplTraitCase::new("std::iter::IntoIterator", sym::into_iter,  1,  FN_HEADER, SelfKind::Value,  OutType::Any,  true,  Edition2015),
-    ShouldImplTraitCase::new("std::ops::Mul",           sym::mul,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true,  Edition2015),
-    ShouldImplTraitCase::new("std::ops::Neg",           sym::neg,        1,  FN_HEADER, SelfKind::Value,  OutType::Any,  true,  Edition2015),
-    ShouldImplTraitCase::new("std::iter::Iterator",     sym::next,       1,  FN_HEADER, SelfKind::RefMut, OutType::Any,  false, Edition2015),
-    ShouldImplTraitCase::new("std::ops::Not",           sym::not,        1,  FN_HEADER, SelfKind::Value,  OutType::Any,  true,  Edition2015),
-    ShouldImplTraitCase::new("std::ops::Rem",           sym::rem,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true,  Edition2015),
-    ShouldImplTraitCase::new("std::ops::Shl",           sym::shl,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true,  Edition2015),
-    ShouldImplTraitCase::new("std::ops::Shr",           sym::shr,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true,  Edition2015),
-    ShouldImplTraitCase::new("std::ops::Sub",           sym::sub,        2,  FN_HEADER, SelfKind::Value,  OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::Add",           sym::add,        2,  SelfKind::Value,  OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::convert::AsMut",     sym::as_mut,     1,  SelfKind::RefMut, OutType::Ref,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::convert::AsRef",     sym::as_ref,     1,  SelfKind::Ref,    OutType::Ref,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::BitAnd",        sym::bitand,     2,  SelfKind::Value,  OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::BitOr",         sym::bitor,      2,  SelfKind::Value,  OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::BitXor",        sym::bitxor,     2,  SelfKind::Value,  OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::borrow::Borrow",     sym::borrow,     1,  SelfKind::Ref,    OutType::Ref,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::borrow::BorrowMut",  sym::borrow_mut, 1,  SelfKind::RefMut, OutType::Ref,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::clone::Clone",       sym::clone,      1,  SelfKind::Ref,    OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::cmp::Ord",           sym::cmp,        2,  SelfKind::Ref,    OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::default::Default",   kw::Default,     0,  SelfKind::No,     OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::Deref",         sym::deref,      1,  SelfKind::Ref,    OutType::Ref,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::DerefMut",      sym::deref_mut,  1,  SelfKind::RefMut, OutType::Ref,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::Div",           sym::div,        2,  SelfKind::Value,  OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::Drop",          sym::drop,       1,  SelfKind::RefMut, OutType::Unit, true,  Edition2015),
+    ShouldImplTraitCase::new("std::cmp::PartialEq",     sym::eq,         2,  SelfKind::Ref,    OutType::Bool, true,  Edition2015),
+    ShouldImplTraitCase::new("std::iter::FromIterator", sym::from_iter,  1,  SelfKind::No,     OutType::Any,  true,  Edition2021),
+    ShouldImplTraitCase::new("std::str::FromStr",       sym::from_str,   1,  SelfKind::No,     OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::hash::Hash",         sym::hash,       2,  SelfKind::Ref,    OutType::Unit, true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::Index",         sym::index,      2,  SelfKind::Ref,    OutType::Ref,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::IndexMut",      sym::index_mut,  2,  SelfKind::RefMut, OutType::Ref,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::iter::IntoIterator", sym::into_iter,  1,  SelfKind::Value,  OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::Mul",           sym::mul,        2,  SelfKind::Value,  OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::Neg",           sym::neg,        1,  SelfKind::Value,  OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::iter::Iterator",     sym::next,       1,  SelfKind::RefMut, OutType::Any,  false, Edition2015),
+    ShouldImplTraitCase::new("std::ops::Not",           sym::not,        1,  SelfKind::Value,  OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::Rem",           sym::rem,        2,  SelfKind::Value,  OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::Shl",           sym::shl,        2,  SelfKind::Value,  OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::Shr",           sym::shr,        2,  SelfKind::Value,  OutType::Any,  true,  Edition2015),
+    ShouldImplTraitCase::new("std::ops::Sub",           sym::sub,        2,  SelfKind::Value,  OutType::Any,  true,  Edition2015),
 ];
 
 #[derive(Clone, Copy)]
@@ -153,19 +142,15 @@ enum OutType {
 }
 
 impl OutType {
-    fn matches(self, ty: &hir::FnRetTy<'_>) -> bool {
+    fn matches(self, ty: &FnRetTy<'_>) -> bool {
         let is_unit = |ty: &hir::Ty<'_>| matches!(ty.kind, hir::TyKind::Tup(&[]));
         match (self, ty) {
-            (Self::Unit, &hir::FnRetTy::DefaultReturn(_)) => true,
-            (Self::Unit, &hir::FnRetTy::Return(ty)) if is_unit(ty) => true,
-            (Self::Bool, &hir::FnRetTy::Return(ty)) if is_bool(ty) => true,
-            (Self::Any, &hir::FnRetTy::Return(ty)) if !is_unit(ty) => true,
-            (Self::Ref, &hir::FnRetTy::Return(ty)) => matches!(ty.kind, hir::TyKind::Ref(_, _)),
+            (Self::Unit, &FnRetTy::DefaultReturn(_)) => true,
+            (Self::Unit, &FnRetTy::Return(ty)) if is_unit(ty) => true,
+            (Self::Bool, &FnRetTy::Return(ty)) if is_bool(ty) => true,
+            (Self::Any, &FnRetTy::Return(ty)) if !is_unit(ty) => true,
+            (Self::Ref, &FnRetTy::Return(ty)) => matches!(ty.kind, hir::TyKind::Ref(_, _)),
             _ => false,
         }
     }
 }
-
-fn fn_header_equals(expected: hir::FnHeader, actual: hir::FnHeader) -> bool {
-    expected.constness == actual.constness && expected.safety == actual.safety && expected.asyncness == actual.asyncness
-}

From 1485e7887b6407ce6326e044d9b3983364db52ad Mon Sep 17 00:00:00 2001
From: Fletcher Porter <me@fletcherporter.com>
Date: Wed, 18 Jun 2025 15:04:54 +0300
Subject: [PATCH 1690/1889] Document fully-qualified syntax in `as`' keyword
 doc

---
 library/std/src/keyword_docs.rs | 35 ++++++++++++++++++++++++++++++---
 1 file changed, 32 insertions(+), 3 deletions(-)

diff --git a/library/std/src/keyword_docs.rs b/library/std/src/keyword_docs.rs
index 7ff4af8ede84b..dc0d11b07a9f3 100644
--- a/library/std/src/keyword_docs.rs
+++ b/library/std/src/keyword_docs.rs
@@ -1,6 +1,8 @@
 #[doc(keyword = "as")]
 //
-/// Cast between types, or rename an import.
+/// Cast between types, rename an import, or qualify paths to associated items.
+///
+/// # Type casting
 ///
 /// `as` is most commonly used to turn primitive types into other primitive types, but it has other
 /// uses that include turning pointers into addresses, addresses into pointers, and pointers into
@@ -30,6 +32,8 @@
 /// `as *mut _` though the [`cast`][const-cast] method is recommended over `as *const _` and it is
 /// [the same][mut-cast] for `as *mut _`: those methods make the intent clearer.
 ///
+/// # Renaming imports
+///
 /// `as` is also used to rename imports in [`use`] and [`extern crate`][`crate`] statements:
 ///
 /// ```
@@ -37,9 +41,34 @@
 /// use std::{mem as memory, net as network};
 /// // Now you can use the names `memory` and `network` to refer to `std::mem` and `std::net`.
 /// ```
-/// For more information on what `as` is capable of, see the [Reference].
 ///
-/// [Reference]: ../reference/expressions/operator-expr.html#type-cast-expressions
+/// # Qualifying paths
+///
+/// You'll also find with `From` and `Into`, and indeed all traits, that `as` is used for the
+/// _fully qualified path_, a means of disambiguating associated items, i.e. functions,
+/// constants, and types.  For example, if you have a type which implements two traits with identical
+/// method names (e.g. `Into::<u32>::into` and `Into::<u64>::into`), you can clarify which method
+/// you'll use with `<MyThing as Into<u32>>::into(my_thing)`[^as-use-from].  This is quite verbose,
+/// but fortunately, Rust's type inference usually saves you from needing this, although it is
+/// occasionally necessary, especially with methods that return a generic type like `Into::into` or
+/// methods that don't take `self`.  It's more common to use in macros where it can provide necessary
+/// hygiene.
+///
+/// [^as-use-from]: You should probably never use this syntax with `Into` and instead write
+/// `T::from(my_thing)`.  It just happens that there aren't any great examples for this syntax in
+/// the standard library.  Also, at time of writing, the compiler tends to suggest fully-qualified
+/// paths to fix ambiguous `Into::into` calls, so the example should hopefully be familiar.
+///
+/// # Further reading
+///
+/// For more information on what `as` is capable of, see the Reference on [type cast expressions],
+/// [renaming imported entities], [renaming `extern` crates]
+/// and [qualified paths].
+///
+/// [type cast expressions]: ../reference/expressions/operator-expr.html#type-cast-expressions
+/// [renaming imported entities]: https://doc.rust-lang.org/reference/items/use-declarations.html#as-renames
+/// [renaming `extern` crates]: https://doc.rust-lang.org/reference/items/extern-crates.html#r-items.extern-crate.as
+/// [qualified paths]: ../reference/paths.html#qualified-paths
 /// [`crate`]: keyword.crate.html
 /// [`use`]: keyword.use.html
 /// [const-cast]: pointer::cast

From e3f104608c0ad26e80b1ebedef2ab8a748189e52 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Fri, 3 Oct 2025 10:32:11 -0400
Subject: [PATCH 1691/1889] Don't normalize higher-ranked assumptions if
 they're not used

---
 .../src/traits/select/confirmation.rs         | 31 ++++++-----
 .../higher-ranked-normalize-assumptions-2.rs  | 38 ++++++++++++++
 .../higher-ranked-normalize-assumptions.rs    | 51 +++++++++++++++++++
 3 files changed, 107 insertions(+), 13 deletions(-)
 create mode 100644 tests/ui/async-await/higher-ranked-normalize-assumptions-2.rs
 create mode 100644 tests/ui/async-await/higher-ranked-normalize-assumptions.rs

diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
index 7ad65a1df8e9b..708a53f6c650d 100644
--- a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
@@ -423,19 +423,24 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 constituents.types,
             );
 
-            // FIXME(coroutine_clone): We could uplift this into `collect_predicates_for_types`
-            // and do this for `Copy`/`Clone` too, but that's feature-gated so it doesn't really
-            // matter yet.
-            for assumption in constituents.assumptions {
-                let assumption = normalize_with_depth_to(
-                    self,
-                    obligation.param_env,
-                    cause.clone(),
-                    obligation.recursion_depth + 1,
-                    assumption,
-                    &mut obligations,
-                );
-                self.infcx.register_region_assumption(assumption);
+            // Only normalize these goals if `-Zhigher-ranked-assumptions` is enabled, since
+            // we don't want to cause ourselves to do extra work if we're not even able to
+            // take advantage of these assumption clauses.
+            if self.tcx().sess.opts.unstable_opts.higher_ranked_assumptions {
+                // FIXME(coroutine_clone): We could uplift this into `collect_predicates_for_types`
+                // and do this for `Copy`/`Clone` too, but that's feature-gated so it doesn't really
+                // matter yet.
+                for assumption in constituents.assumptions {
+                    let assumption = normalize_with_depth_to(
+                        self,
+                        obligation.param_env,
+                        cause.clone(),
+                        obligation.recursion_depth + 1,
+                        assumption,
+                        &mut obligations,
+                    );
+                    self.infcx.register_region_assumption(assumption);
+                }
             }
 
             Ok(obligations)
diff --git a/tests/ui/async-await/higher-ranked-normalize-assumptions-2.rs b/tests/ui/async-await/higher-ranked-normalize-assumptions-2.rs
new file mode 100644
index 0000000000000..410d4e503b7c2
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-normalize-assumptions-2.rs
@@ -0,0 +1,38 @@
+//@ revisions: stock hr
+//@[hr] compile-flags: -Zhigher-ranked-assumptions
+//@ edition: 2024
+//@ check-pass
+
+// Test that we don't normalize the higher-ranked assumptions of an auto trait goal
+// unless we have `-Zhigher-ranked-assumptions`, since obligations that result from
+// this normalization may lead to higher-ranked lifetime errors when the flag is not
+// enabled.
+
+// Regression test for <https://github.com/rust-lang/rust/issues/147244>.
+
+pub fn a() -> impl Future + Send {
+    async {
+        let queries = core::iter::empty().map(Thing::f);
+        b(queries).await;
+    }
+}
+
+async fn b(queries: impl IntoIterator) {
+    c(queries).await;
+}
+
+fn c<'a, I>(_queries: I) -> impl Future
+where
+    I: IntoIterator,
+    I::IntoIter: 'a,
+{
+    async {}
+}
+
+pub struct Thing<'a>(pub &'a ());
+
+impl Thing<'_> {
+    fn f(_: &Self) {}
+}
+
+fn main() {}
diff --git a/tests/ui/async-await/higher-ranked-normalize-assumptions.rs b/tests/ui/async-await/higher-ranked-normalize-assumptions.rs
new file mode 100644
index 0000000000000..ec9cf3a152214
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-normalize-assumptions.rs
@@ -0,0 +1,51 @@
+//@ revisions: stock hr
+//@[hr] compile-flags: -Zhigher-ranked-assumptions
+//@ edition: 2024
+//@ check-pass
+
+// Test that we don't normalize the higher-ranked assumptions of an auto trait goal
+// unless we have `-Zhigher-ranked-assumptions`, since obligations that result from
+// this normalization may lead to higher-ranked lifetime errors when the flag is not
+// enabled.
+
+// Regression test for <https://github.com/rust-lang/rust/issues/147285>.
+
+pub trait Service {
+    type Response;
+}
+
+impl<T, R> Service for T
+where
+    T: FnMut() -> R,
+    R: 'static,
+{
+    type Response = R;
+}
+
+async fn serve<C>(_: C)
+where
+    C: Service,
+    C::Response: 'static,
+{
+    connect::<C>().await;
+}
+
+async fn connect<C>()
+where
+    C: Service,
+    C::Response: 'static,
+{
+}
+
+fn repro() -> impl Send {
+    async {
+        let server = || do_something();
+        serve(server).await;
+    }
+}
+
+fn do_something() -> Box<dyn std::error::Error> {
+    unimplemented!()
+}
+
+fn main() {}

From e914a1a6e026d2c9db43300735a75ba25746e14c Mon Sep 17 00:00:00 2001
From: Urgau <urgau@numericable.fr>
Date: Fri, 3 Oct 2025 11:57:04 +0200
Subject: [PATCH 1692/1889] Respect `--error-format` in `rustdoc --test`

---
 src/librustdoc/doctest.rs                     |  1 +
 tests/rustdoc-ui/doctest/check-attr-test.rs   | 12 ++++++++++
 .../rustdoc-ui/doctest/check-attr-test.stderr | 24 +++++++++----------
 .../failed-doctest-extra-semicolon-on-item.rs |  1 +
 .../doctest/main-alongside-stmts.rs           |  2 ++
 .../doctest/main-alongside-stmts.stderr       |  8 +++----
 .../doctest/main-alongside-stmts.stdout       |  4 ++--
 .../doctest/standalone-warning-2024.rs        |  2 ++
 .../doctest/standalone-warning-2024.stderr    | 12 +++++-----
 .../rustdoc-ui/doctest/test-compile-fail1.rs  |  1 +
 .../rustdoc-ui/doctest/test-compile-fail2.rs  |  1 +
 .../rustdoc-ui/doctest/test-compile-fail3.rs  |  1 +
 .../doctest/test-compile-fail3.stderr         |  5 ++--
 .../doctest/warn-main-not-called.rs           |  2 ++
 .../doctest/warn-main-not-called.stderr       |  4 ++--
 15 files changed, 52 insertions(+), 28 deletions(-)

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index 38a0c925d2a45..27761511038ec 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -174,6 +174,7 @@ pub(crate) fn run(dcx: DiagCtxtHandle<'_>, input: Input, options: RustdocOptions
         crate_name: options.crate_name.clone(),
         remap_path_prefix: options.remap_path_prefix.clone(),
         unstable_opts: options.unstable_opts.clone(),
+        error_format: options.error_format.clone(),
         ..config::Options::default()
     };
 
diff --git a/tests/rustdoc-ui/doctest/check-attr-test.rs b/tests/rustdoc-ui/doctest/check-attr-test.rs
index 81281db624b3d..d69dae63860ee 100644
--- a/tests/rustdoc-ui/doctest/check-attr-test.rs
+++ b/tests/rustdoc-ui/doctest/check-attr-test.rs
@@ -2,6 +2,9 @@
 
 #![deny(rustdoc::invalid_codeblock_attributes)]
 
+//~vvv ERROR unknown attribute `compile-fail`
+//~| ERROR unknown attribute `compilefail`
+//~| ERROR unknown attribute `comPile_fail`
 /// foo
 ///
 /// ```compile-fail,compilefail,comPile_fail
@@ -9,6 +12,9 @@
 /// ```
 pub fn foo() {}
 
+//~vvv ERROR unknown attribute `should-panic`
+//~| ERROR unknown attribute `shouldpanic`
+//~| ERROR unknown attribute `shOuld_panic`
 /// bar
 ///
 /// ```should-panic,shouldpanic,shOuld_panic
@@ -16,6 +22,9 @@ pub fn foo() {}
 /// ```
 pub fn bar() {}
 
+//~vvv ERROR unknown attribute `no-run`
+//~| ERROR unknown attribute `norun`
+//~| ERROR unknown attribute `nO_run`
 /// foobar
 ///
 /// ```no-run,norun,nO_run
@@ -23,6 +32,9 @@ pub fn bar() {}
 /// ```
 pub fn foobar() {}
 
+//~vvv ERROR unknown attribute `test-harness`
+//~| ERROR unknown attribute `testharness`
+//~| ERROR unknown attribute `tesT_harness`
 /// b
 ///
 /// ```test-harness,testharness,tesT_harness
diff --git a/tests/rustdoc-ui/doctest/check-attr-test.stderr b/tests/rustdoc-ui/doctest/check-attr-test.stderr
index 4cf93033ae8a0..1fc7ab592de0c 100644
--- a/tests/rustdoc-ui/doctest/check-attr-test.stderr
+++ b/tests/rustdoc-ui/doctest/check-attr-test.stderr
@@ -1,5 +1,5 @@
 error: unknown attribute `compile-fail`
-  --> $DIR/check-attr-test.rs:5:1
+  --> $DIR/check-attr-test.rs:8:1
    |
 LL | / /// foo
 LL | | ///
@@ -17,7 +17,7 @@ LL | #![deny(rustdoc::invalid_codeblock_attributes)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: unknown attribute `compilefail`
-  --> $DIR/check-attr-test.rs:5:1
+  --> $DIR/check-attr-test.rs:8:1
    |
 LL | / /// foo
 LL | | ///
@@ -30,7 +30,7 @@ LL | | /// ```
    = help: this code block may be skipped during testing, because unknown attributes are treated as markers for code samples written in other programming languages, unless it is also explicitly marked as `rust`
 
 error: unknown attribute `comPile_fail`
-  --> $DIR/check-attr-test.rs:5:1
+  --> $DIR/check-attr-test.rs:8:1
    |
 LL | / /// foo
 LL | | ///
@@ -43,7 +43,7 @@ LL | | /// ```
    = help: this code block may be skipped during testing, because unknown attributes are treated as markers for code samples written in other programming languages, unless it is also explicitly marked as `rust`
 
 error: unknown attribute `should-panic`
-  --> $DIR/check-attr-test.rs:12:1
+  --> $DIR/check-attr-test.rs:18:1
    |
 LL | / /// bar
 LL | | ///
@@ -56,7 +56,7 @@ LL | | /// ```
    = help: this code block may be skipped during testing, because unknown attributes are treated as markers for code samples written in other programming languages, unless it is also explicitly marked as `rust`
 
 error: unknown attribute `shouldpanic`
-  --> $DIR/check-attr-test.rs:12:1
+  --> $DIR/check-attr-test.rs:18:1
    |
 LL | / /// bar
 LL | | ///
@@ -69,7 +69,7 @@ LL | | /// ```
    = help: this code block may be skipped during testing, because unknown attributes are treated as markers for code samples written in other programming languages, unless it is also explicitly marked as `rust`
 
 error: unknown attribute `shOuld_panic`
-  --> $DIR/check-attr-test.rs:12:1
+  --> $DIR/check-attr-test.rs:18:1
    |
 LL | / /// bar
 LL | | ///
@@ -82,7 +82,7 @@ LL | | /// ```
    = help: this code block may be skipped during testing, because unknown attributes are treated as markers for code samples written in other programming languages, unless it is also explicitly marked as `rust`
 
 error: unknown attribute `no-run`
-  --> $DIR/check-attr-test.rs:19:1
+  --> $DIR/check-attr-test.rs:28:1
    |
 LL | / /// foobar
 LL | | ///
@@ -95,7 +95,7 @@ LL | | /// ```
    = help: this code block may be skipped during testing, because unknown attributes are treated as markers for code samples written in other programming languages, unless it is also explicitly marked as `rust`
 
 error: unknown attribute `norun`
-  --> $DIR/check-attr-test.rs:19:1
+  --> $DIR/check-attr-test.rs:28:1
    |
 LL | / /// foobar
 LL | | ///
@@ -108,7 +108,7 @@ LL | | /// ```
    = help: this code block may be skipped during testing, because unknown attributes are treated as markers for code samples written in other programming languages, unless it is also explicitly marked as `rust`
 
 error: unknown attribute `nO_run`
-  --> $DIR/check-attr-test.rs:19:1
+  --> $DIR/check-attr-test.rs:28:1
    |
 LL | / /// foobar
 LL | | ///
@@ -121,7 +121,7 @@ LL | | /// ```
    = help: this code block may be skipped during testing, because unknown attributes are treated as markers for code samples written in other programming languages, unless it is also explicitly marked as `rust`
 
 error: unknown attribute `test-harness`
-  --> $DIR/check-attr-test.rs:26:1
+  --> $DIR/check-attr-test.rs:38:1
    |
 LL | / /// b
 LL | | ///
@@ -134,7 +134,7 @@ LL | | /// ```
    = help: this code block may be skipped during testing, because unknown attributes are treated as markers for code samples written in other programming languages, unless it is also explicitly marked as `rust`
 
 error: unknown attribute `testharness`
-  --> $DIR/check-attr-test.rs:26:1
+  --> $DIR/check-attr-test.rs:38:1
    |
 LL | / /// b
 LL | | ///
@@ -147,7 +147,7 @@ LL | | /// ```
    = help: this code block may be skipped during testing, because unknown attributes are treated as markers for code samples written in other programming languages, unless it is also explicitly marked as `rust`
 
 error: unknown attribute `tesT_harness`
-  --> $DIR/check-attr-test.rs:26:1
+  --> $DIR/check-attr-test.rs:38:1
    |
 LL | / /// b
 LL | | ///
diff --git a/tests/rustdoc-ui/doctest/failed-doctest-extra-semicolon-on-item.rs b/tests/rustdoc-ui/doctest/failed-doctest-extra-semicolon-on-item.rs
index ca5dd78746789..05e4a348d1190 100644
--- a/tests/rustdoc-ui/doctest/failed-doctest-extra-semicolon-on-item.rs
+++ b/tests/rustdoc-ui/doctest/failed-doctest-extra-semicolon-on-item.rs
@@ -9,6 +9,7 @@
 /// <https://github.com/rust-lang/rust/issues/91014>
 ///
 /// ```rust
+//~^ WARN the `main` function of this doctest won't be run
 /// struct S {};
 ///
 /// fn main() {
diff --git a/tests/rustdoc-ui/doctest/main-alongside-stmts.rs b/tests/rustdoc-ui/doctest/main-alongside-stmts.rs
index 5965f928cdd13..595de13393293 100644
--- a/tests/rustdoc-ui/doctest/main-alongside-stmts.rs
+++ b/tests/rustdoc-ui/doctest/main-alongside-stmts.rs
@@ -14,6 +14,7 @@
 //@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ check-pass
 
+//~v WARN the `main` function of this doctest won't be run
 //! ```
 //! # if cfg!(miri) { return; }
 //! use std::ops::Deref;
@@ -22,6 +23,7 @@
 //!     assert!(false);
 //! }
 //! ```
+//~v WARN the `main` function of this doctest won't be run
 //!
 //! ```
 //! let x = 2;
diff --git a/tests/rustdoc-ui/doctest/main-alongside-stmts.stderr b/tests/rustdoc-ui/doctest/main-alongside-stmts.stderr
index 3f347d96ab063..b7a5421f8f737 100644
--- a/tests/rustdoc-ui/doctest/main-alongside-stmts.stderr
+++ b/tests/rustdoc-ui/doctest/main-alongside-stmts.stderr
@@ -1,14 +1,14 @@
 warning: the `main` function of this doctest won't be run as it contains expressions at the top level, meaning that the whole doctest code will be wrapped in a function
-  --> $DIR/main-alongside-stmts.rs:17:1
+  --> $DIR/main-alongside-stmts.rs:18:1
    |
 LL | //! ```
    | ^^^^^^^
 
 warning: the `main` function of this doctest won't be run as it contains expressions at the top level, meaning that the whole doctest code will be wrapped in a function
-  --> $DIR/main-alongside-stmts.rs:26:1
+  --> $DIR/main-alongside-stmts.rs:27:1
    |
-LL | //! ```
-   | ^^^^^^^
+LL | //!
+   | ^^^
 
 warning: 2 warnings emitted
 
diff --git a/tests/rustdoc-ui/doctest/main-alongside-stmts.stdout b/tests/rustdoc-ui/doctest/main-alongside-stmts.stdout
index 9b9a3fe8a68f7..bebaeb49c5a90 100644
--- a/tests/rustdoc-ui/doctest/main-alongside-stmts.stdout
+++ b/tests/rustdoc-ui/doctest/main-alongside-stmts.stdout
@@ -1,7 +1,7 @@
 
 running 2 tests
-test $DIR/main-alongside-stmts.rs - (line 17) ... ok
-test $DIR/main-alongside-stmts.rs - (line 26) ... ok
+test $DIR/main-alongside-stmts.rs - (line 18) ... ok
+test $DIR/main-alongside-stmts.rs - (line 27) ... ok
 
 test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
 
diff --git a/tests/rustdoc-ui/doctest/standalone-warning-2024.rs b/tests/rustdoc-ui/doctest/standalone-warning-2024.rs
index c53a8b48749ce..3bb0083d849ff 100644
--- a/tests/rustdoc-ui/doctest/standalone-warning-2024.rs
+++ b/tests/rustdoc-ui/doctest/standalone-warning-2024.rs
@@ -9,6 +9,8 @@
 #![deny(warnings)]
 
 //! ```standalone
+//~^ ERROR unknown attribute `standalone`
+//~| ERROR unknown attribute `standalone-crate`
 //! bla
 //! ```
 //!
diff --git a/tests/rustdoc-ui/doctest/standalone-warning-2024.stderr b/tests/rustdoc-ui/doctest/standalone-warning-2024.stderr
index 1af2ded58e8b4..db0d53a204ced 100644
--- a/tests/rustdoc-ui/doctest/standalone-warning-2024.stderr
+++ b/tests/rustdoc-ui/doctest/standalone-warning-2024.stderr
@@ -2,10 +2,10 @@ error: unknown attribute `standalone`
   --> $DIR/standalone-warning-2024.rs:11:1
    |
 LL | / //! ```standalone
+LL | |
+LL | |
 LL | | //! bla
-LL | | //! ```
-LL | | //!
-LL | | //! ```standalone-crate
+...  |
 LL | | //! bla
 LL | | //! ```
    | |_______^
@@ -23,10 +23,10 @@ error: unknown attribute `standalone-crate`
   --> $DIR/standalone-warning-2024.rs:11:1
    |
 LL | / //! ```standalone
+LL | |
+LL | |
 LL | | //! bla
-LL | | //! ```
-LL | | //!
-LL | | //! ```standalone-crate
+...  |
 LL | | //! bla
 LL | | //! ```
    | |_______^
diff --git a/tests/rustdoc-ui/doctest/test-compile-fail1.rs b/tests/rustdoc-ui/doctest/test-compile-fail1.rs
index 278f01f4c8389..c692c4c61bcce 100644
--- a/tests/rustdoc-ui/doctest/test-compile-fail1.rs
+++ b/tests/rustdoc-ui/doctest/test-compile-fail1.rs
@@ -6,3 +6,4 @@
 pub fn f() {}
 
 pub fn f() {}
+//~^ ERROR the name `f` is defined multiple times
diff --git a/tests/rustdoc-ui/doctest/test-compile-fail2.rs b/tests/rustdoc-ui/doctest/test-compile-fail2.rs
index 7432cc9f8263b..8239440262d81 100644
--- a/tests/rustdoc-ui/doctest/test-compile-fail2.rs
+++ b/tests/rustdoc-ui/doctest/test-compile-fail2.rs
@@ -1,3 +1,4 @@
 //@ compile-flags:--test
 
 fail
+//~^ ERROR
diff --git a/tests/rustdoc-ui/doctest/test-compile-fail3.rs b/tests/rustdoc-ui/doctest/test-compile-fail3.rs
index a2486d9dc6f22..272ba95396c6d 100644
--- a/tests/rustdoc-ui/doctest/test-compile-fail3.rs
+++ b/tests/rustdoc-ui/doctest/test-compile-fail3.rs
@@ -1,3 +1,4 @@
 //@ compile-flags:--test
 
 "fail
+//~^ ERROR
diff --git a/tests/rustdoc-ui/doctest/test-compile-fail3.stderr b/tests/rustdoc-ui/doctest/test-compile-fail3.stderr
index 9f90a428d480f..8061097e73acd 100644
--- a/tests/rustdoc-ui/doctest/test-compile-fail3.stderr
+++ b/tests/rustdoc-ui/doctest/test-compile-fail3.stderr
@@ -1,8 +1,9 @@
 error[E0765]: unterminated double quote string
   --> $DIR/test-compile-fail3.rs:3:1
    |
-LL | "fail
-   | ^^^^^
+LL | / "fail
+LL | |
+   | |___________^
 
 error: aborting due to 1 previous error
 
diff --git a/tests/rustdoc-ui/doctest/warn-main-not-called.rs b/tests/rustdoc-ui/doctest/warn-main-not-called.rs
index 25d92e9cee9f4..ec762486d5d42 100644
--- a/tests/rustdoc-ui/doctest/warn-main-not-called.rs
+++ b/tests/rustdoc-ui/doctest/warn-main-not-called.rs
@@ -8,6 +8,7 @@
 // won't be called.
 
 //! ```
+//~^ WARN the `main` function of this doctest won't be run
 //! macro_rules! bla {
 //!     ($($x:tt)*) => {}
 //! }
@@ -17,6 +18,7 @@
 //! ```
 //!
 //! ```
+//~^^ WARN the `main` function of this doctest won't be run
 //! let x = 12;
 //! fn main() {}
 //! ```
diff --git a/tests/rustdoc-ui/doctest/warn-main-not-called.stderr b/tests/rustdoc-ui/doctest/warn-main-not-called.stderr
index b5b7bc57644a6..5feca6f9175fe 100644
--- a/tests/rustdoc-ui/doctest/warn-main-not-called.stderr
+++ b/tests/rustdoc-ui/doctest/warn-main-not-called.stderr
@@ -7,8 +7,8 @@ LL | //! ```
 warning: the `main` function of this doctest won't be run as it contains expressions at the top level, meaning that the whole doctest code will be wrapped in a function
   --> $DIR/warn-main-not-called.rs:19:1
    |
-LL | //! ```
-   | ^^^^^^^
+LL | //!
+   | ^^^
 
 warning: 2 warnings emitted
 

From c1443e2591c284f6ac8372d15c88f8d6c9470e4c Mon Sep 17 00:00:00 2001
From: Urgau <urgau@numericable.fr>
Date: Fri, 3 Oct 2025 12:02:35 +0200
Subject: [PATCH 1693/1889] Add regression test for `-Zcrate-attr` in `rustdoc
 --test`

---
 .../rustdoc-ui/doctest/unstable-opts-143930.rs  | 14 ++++++++++++++
 .../doctest/unstable-opts-143930.stdout         |  5 +++++
 .../unstable-opts-147276.crate_attr.stdout      |  5 +++++
 .../doctest/unstable-opts-147276.normal.stderr  | 13 +++++++++++++
 .../rustdoc-ui/doctest/unstable-opts-147276.rs  | 17 +++++++++++++++++
 5 files changed, 54 insertions(+)
 create mode 100644 tests/rustdoc-ui/doctest/unstable-opts-143930.rs
 create mode 100644 tests/rustdoc-ui/doctest/unstable-opts-143930.stdout
 create mode 100644 tests/rustdoc-ui/doctest/unstable-opts-147276.crate_attr.stdout
 create mode 100644 tests/rustdoc-ui/doctest/unstable-opts-147276.normal.stderr
 create mode 100644 tests/rustdoc-ui/doctest/unstable-opts-147276.rs

diff --git a/tests/rustdoc-ui/doctest/unstable-opts-143930.rs b/tests/rustdoc-ui/doctest/unstable-opts-143930.rs
new file mode 100644
index 0000000000000..30c47f5b7e9e3
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/unstable-opts-143930.rs
@@ -0,0 +1,14 @@
+// This test verifies that unstable options like `-Zcrate-attr` are respected when `--test` is
+// passed.
+//
+// <https://github.com/rust-lang/rust/issues/143930>
+//
+// NOTE: If any of these command line arguments or features get stabilized, please replace with
+// another unstable one.
+
+//@ check-pass
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ compile-flags: --test -Zcrate-attr=feature(register_tool) -Zcrate-attr=register_tool(rapx)
+
+#[rapx::tag]
+fn f() {}
diff --git a/tests/rustdoc-ui/doctest/unstable-opts-143930.stdout b/tests/rustdoc-ui/doctest/unstable-opts-143930.stdout
new file mode 100644
index 0000000000000..7326c0a25a069
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/unstable-opts-143930.stdout
@@ -0,0 +1,5 @@
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+
diff --git a/tests/rustdoc-ui/doctest/unstable-opts-147276.crate_attr.stdout b/tests/rustdoc-ui/doctest/unstable-opts-147276.crate_attr.stdout
new file mode 100644
index 0000000000000..7326c0a25a069
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/unstable-opts-147276.crate_attr.stdout
@@ -0,0 +1,5 @@
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+
diff --git a/tests/rustdoc-ui/doctest/unstable-opts-147276.normal.stderr b/tests/rustdoc-ui/doctest/unstable-opts-147276.normal.stderr
new file mode 100644
index 0000000000000..eebf4f307f127
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/unstable-opts-147276.normal.stderr
@@ -0,0 +1,13 @@
+error[E0658]: `#[used(linker)]` is currently unstable
+  --> $DIR/unstable-opts-147276.rs:15:1
+   |
+LL | #[used(linker)]
+   | ^^^^^^^^^^^^^^^
+   |
+   = note: see issue #93798 <https://github.com/rust-lang/rust/issues/93798> for more information
+   = help: add `#![feature(used_with_arg)]` 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/rustdoc-ui/doctest/unstable-opts-147276.rs b/tests/rustdoc-ui/doctest/unstable-opts-147276.rs
new file mode 100644
index 0000000000000..64cafcaaff4e3
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/unstable-opts-147276.rs
@@ -0,0 +1,17 @@
+// This test verifies that unstable options like `-Zcrate-attr` are respected when `--test` is
+// passed.
+//
+// <https://github.com/rust-lang/rust/issues/147276>
+//
+// NOTE: If any of these command line arguments or features get stabilized, please replace with
+// another unstable one.
+
+//@ revisions: normal crate_attr
+//@ compile-flags: --test
+//@ normalize-stdout: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@[crate_attr] check-pass
+//@[crate_attr] compile-flags: -Zcrate-attr=feature(used_with_arg)
+
+#[used(linker)]
+//[normal]~^ ERROR `#[used(linker)]` is currently unstable
+static REPRO: isize = 1;

From 3f9c493da1fa46ff0ef6d23e60a37c89ef3f5933 Mon Sep 17 00:00:00 2001
From: Scott Mabin <scott@mabez.dev>
Date: Fri, 3 Oct 2025 16:10:26 +0100
Subject: [PATCH 1694/1889] Add xtensa arch to object file creation

---
 compiler/rustc_target/src/spec/mod.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index 4a82a8bd888e6..2f7109de804ae 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -3182,6 +3182,7 @@ impl Target {
             "avr" => (Architecture::Avr, None),
             "msp430" => (Architecture::Msp430, None),
             "hexagon" => (Architecture::Hexagon, None),
+            "xtensa" => (Architecture::Xtensa, None),
             "bpf" => (Architecture::Bpf, None),
             "loongarch32" => (Architecture::LoongArch32, None),
             "loongarch64" => (Architecture::LoongArch64, None),

From e43a0b6bdbdf5a4bab5be6b925698971c55dae1a Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Fri, 3 Oct 2025 11:58:30 -0400
Subject: [PATCH 1695/1889] Update cargo submodule

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

diff --git a/src/tools/cargo b/src/tools/cargo
index f2932725b045d..2394ea6cea8b2 160000
--- a/src/tools/cargo
+++ b/src/tools/cargo
@@ -1 +1 @@
-Subproject commit f2932725b045d361ff5f18ba02b1409dd1f44e71
+Subproject commit 2394ea6cea8b26d717aa67eb1663a2dbf2d26078

From 58889457cac8225e6bae4855ca1911dd0a378f65 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 4 Aug 2025 16:08:14 +0200
Subject: [PATCH 1696/1889] Display merged doctests times as expected depending
 on the format specified

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

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index 9499258f983a1..5ea3ede78bc44 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -12,7 +12,7 @@ use std::process::{self, Command, Stdio};
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
-use std::{fmt, panic, str};
+use std::{panic, str};
 
 pub(crate) use make::{BuildDocTestBuilder, DocTestBuilder};
 pub(crate) use markdown::test as test_markdown;
@@ -60,24 +60,15 @@ impl MergedDoctestTimes {
         self.added_compilation_times += 1;
     }
 
-    fn display_times(&self) {
+    /// Returns `(total_time, compilation_time)`.
+    fn times_in_secs(&self) -> Option<(f64, f64)> {
         // If no merged doctest was compiled, then there is nothing to display since the numbers
         // displayed by `libtest` for standalone tests are already accurate (they include both
         // compilation and runtime).
-        if self.added_compilation_times > 0 {
-            println!("{self}");
+        if self.added_compilation_times == 0 {
+            return None;
         }
-    }
-}
-
-impl fmt::Display for MergedDoctestTimes {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "all doctests ran in {:.2}s; merged doctests compilation took {:.2}s",
-            self.total_time.elapsed().as_secs_f64(),
-            self.compilation_time.as_secs_f64(),
-        )
+        Some((self.total_time.elapsed().as_secs_f64(), self.compilation_time.as_secs_f64()))
     }
 }
 
@@ -400,15 +391,20 @@ pub(crate) fn run_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_with_exit_callback(&test_args, standalone_tests, None, || {
+            let times = times.times_in_secs();
             // We ensure temp dir destructor is called.
             std::mem::drop(temp_dir.take());
-            times.display_times();
+            if let Some((total_time, compilation_time)) = times {
+                test::print_merged_doctests_times(&test_args, total_time, compilation_time);
+            }
         });
     } else {
         // If the first condition branch exited successfully, `test_main_with_exit_callback` will
         // not exit the process. So to prevent displaying the times twice, we put it behind an
         // `else` condition.
-        times.display_times();
+        if let Some((total_time, compilation_time)) = times.times_in_secs() {
+            test::print_merged_doctests_times(&test_args, total_time, compilation_time);
+        }
     }
     // We ensure temp dir destructor is called.
     std::mem::drop(temp_dir);

From a9ab29cdb45005d69738c3a7cbec4c5cd0fceb73 Mon Sep 17 00:00:00 2001
From: Jeremy Smart <jeremy3141592@gmail.com>
Date: Fri, 12 Sep 2025 13:10:01 -0400
Subject: [PATCH 1697/1889] add mem::conjure_zst

---
 library/core/src/mem/mod.rs            | 58 ++++++++++++++++++++++++++
 tests/ui/consts/std/conjure_zst.rs     | 10 +++++
 tests/ui/consts/std/conjure_zst.stderr | 12 ++++++
 3 files changed, 80 insertions(+)
 create mode 100644 tests/ui/consts/std/conjure_zst.rs
 create mode 100644 tests/ui/consts/std/conjure_zst.stderr

diff --git a/library/core/src/mem/mod.rs b/library/core/src/mem/mod.rs
index db4c8e9e55150..c484551187cc3 100644
--- a/library/core/src/mem/mod.rs
+++ b/library/core/src/mem/mod.rs
@@ -7,6 +7,7 @@
 
 use crate::alloc::Layout;
 use crate::marker::DiscriminantKind;
+use crate::panic::const_assert;
 use crate::{clone, cmp, fmt, hash, intrinsics, ptr};
 
 mod manually_drop;
@@ -1407,3 +1408,60 @@ pub macro offset_of($Container:ty, $($fields:expr)+ $(,)?) {
     // The `{}` is for better error messages
     {builtin # offset_of($Container, $($fields)+)}
 }
+
+/// Create a fresh instance of the inhabited ZST type `T`.
+///
+/// Prefer this to [`zeroed`] or [`uninitialized`] or [`transmute_copy`]
+/// in places where you know that `T` is zero-sized, but don't have a bound
+/// (such as [`Default`]) that would allow you to instantiate it using safe code.
+///
+/// If you're not sure whether `T` is an inhabited ZST, then you should be
+/// using [`MaybeUninit`], not this function.
+///
+/// # Panics
+///
+/// If `size_of::<T>() != 0`.
+///
+/// # Safety
+///
+/// - `T` must be *[inhabited]*, i.e. possible to construct. This means that types
+///   like zero-variant enums and [`!`] are unsound to conjure.
+/// - You must use the value only in ways which do not violate any *safety*
+///   invariants of the type.
+///
+/// While it's easy to create a *valid* instance of an inhabited ZST, since having
+/// no bits in its representation means there's only one possible value, that
+/// doesn't mean that it's always *sound* to do so.
+///
+/// For example, a library could design zero-sized tokens that are `!Default + !Clone`, limiting
+/// their creation to functions that initialize some state or establish a scope. Conjuring such a
+/// token could break invariants and lead to unsoundness.
+///
+/// # Examples
+///
+/// ```
+/// #![feature(mem_conjure_zst)]
+/// use std::mem::conjure_zst;
+///
+/// assert_eq!(unsafe { conjure_zst::<()>() }, ());
+/// assert_eq!(unsafe { conjure_zst::<[i32; 0]>() }, []);
+/// ```
+///
+/// [inhabited]: https://doc.rust-lang.org/reference/glossary.html#inhabited
+#[unstable(feature = "mem_conjure_zst", issue = "95383")]
+pub const unsafe fn conjure_zst<T>() -> T {
+    const_assert!(
+        size_of::<T>() == 0,
+        "mem::conjure_zst invoked on a nonzero-sized type",
+        "mem::conjure_zst invoked on type {t}, which is not zero-sized",
+        t: &str = stringify!(T)
+    );
+
+    // SAFETY: because the caller must guarantee that it's inhabited and zero-sized,
+    // there's nothing in the representation that needs to be set.
+    // `assume_init` calls `assert_inhabited`, so we don't need to here.
+    unsafe {
+        #[allow(clippy::uninit_assumed_init)]
+        MaybeUninit::uninit().assume_init()
+    }
+}
diff --git a/tests/ui/consts/std/conjure_zst.rs b/tests/ui/consts/std/conjure_zst.rs
new file mode 100644
index 0000000000000..c04deae502b0f
--- /dev/null
+++ b/tests/ui/consts/std/conjure_zst.rs
@@ -0,0 +1,10 @@
+#![feature(mem_conjure_zst)]
+
+use std::{convert::Infallible, mem};
+
+const INVALID: Infallible = unsafe { mem::conjure_zst() };
+//~^ ERROR attempted to instantiate uninhabited type
+
+const VALID: () = unsafe { mem::conjure_zst() };
+
+fn main() {}
diff --git a/tests/ui/consts/std/conjure_zst.stderr b/tests/ui/consts/std/conjure_zst.stderr
new file mode 100644
index 0000000000000..0c4a978b81ee6
--- /dev/null
+++ b/tests/ui/consts/std/conjure_zst.stderr
@@ -0,0 +1,12 @@
+error[E0080]: evaluation panicked: aborted execution: attempted to instantiate uninhabited type `Infallible`
+  --> $DIR/conjure_zst.rs:5:38
+   |
+LL | const INVALID: Infallible = unsafe { mem::conjure_zst() };
+   |                                      ^^^^^^^^^^^^^^^^^^ evaluation of `INVALID` failed inside this call
+   |
+note: inside `conjure_zst::<Infallible>`
+  --> $SRC_DIR/core/src/mem/mod.rs:LL:COL
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0080`.

From d5ba5c1c925f82de2efbfbbe92ffee56a6a6a334 Mon Sep 17 00:00:00 2001
From: Jules Bertholet <julesbertholet@quoi.xyz>
Date: Fri, 3 Oct 2025 16:00:15 -0400
Subject: [PATCH 1698/1889] Mark `PatternTypo` suggestion as maybe incorrect

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

diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index f0726014e0afa..e01e9e384c035 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -1365,7 +1365,7 @@ pub(crate) struct UnusedVarAssignedOnly {
 #[multipart_suggestion(
     passes_unused_var_typo,
     style = "verbose",
-    applicability = "machine-applicable"
+    applicability = "maybe-incorrect"
 )]
 pub(crate) struct PatternTypo {
     #[suggestion_part(code = "{code}")]

From fd96a78092e77be45d5b60cedea0806b70d751fd Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Fri, 3 Oct 2025 12:14:41 -0700
Subject: [PATCH 1699/1889] Add documentation about unwinding to wasm targets

This commit adds some documentation about the state of `-Cpanic=unwind`
for the following wasm targets:

* `wasm32-unknown-unknown`
* `wasm32-wasip1`
* `wasm32-wasip2`
* `wasm32v1-none`

Notably it's possible to use `-Cpanic=unwind` with `-Zbuild-std` and
it's also mentioned that there are no concrete proposals at this time to
adding a new set of targets which support unwinding. My hunch is that in
a few years' time it would make sense to enable it by default on these
targets (except for `wasm32v1-none`) but that's a problem for
future folks to debate. For now this is an attempt to document the
status quo.
---
 .../wasm32-unknown-unknown.md                 | 62 ++++++++++++++++++-
 .../src/platform-support/wasm32-wasip1.md     |  6 ++
 .../src/platform-support/wasm32-wasip2.md     |  6 ++
 .../src/platform-support/wasm32v1-none.md     | 11 ++++
 4 files changed, 84 insertions(+), 1 deletion(-)

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 1e74c47221c78..ec20672f65403 100644
--- a/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
+++ b/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
@@ -157,7 +157,7 @@ $ cargo +nightly build -Zbuild-std=panic_abort,std --target wasm32-unknown-unkno
 ```
 
 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
+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.
@@ -207,3 +207,63 @@ 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.
+
+## Unwinding
+
+By default the `wasm32-unknown-unknown` target is compiled with `-Cpanic=abort`.
+Historically this was due to the fact that there was no way to catch panics in
+wasm, but since mid-2025 the WebAssembly [`exception-handling`
+proposal](https://github.com/WebAssembly/exception-handling) reached
+stabilization. LLVM has support for this proposal as well and when this is all
+combined together it's possible to enable `-Cpanic=unwind` on wasm targets.
+
+Compiling wasm targets with `-Cpanic=unwind` is not as easy as just passing
+`-Cpanic=unwind`, however:
+
+```sh
+$ rustc foo.rs -Cpanic=unwind --target wasm32-unknown-unknown
+error: the crate `panic_unwind` does not have the panic strategy `unwind`
+```
+
+Notably the precompiled standard library that is shipped through Rustup is
+compiled with `-Cpanic=abort`, not `-Cpanic=unwind`. While this is the case
+you're going to be required to use Cargo's [`-Zbuild-std`] feature to build with
+unwinding support:
+
+```sh
+$ RUSTFLAGS='-Cpanic=unwind' cargo +nightly build --target wasm32-unknown-unknown -Zbuild-std
+```
+
+Note, however, that as of 2025-10-03 LLVM is still using the "legacy exception
+instructions" by default, not the officially standard version of the
+exception-handling proposal:
+
+```sh
+$ wasm-tools validate target/wasm32-unknown-unknown/debug/foo.wasm
+error: <sysroot>/library/std/src/sys/backtrace.rs:161:5
+function `std::sys::backtrace::__rust_begin_short_backtrace` failed to validate
+
+Caused by:
+    0: func 2 failed to validate
+    1: legacy_exceptions feature required for try instruction (at offset 0x880)
+```
+
+Fixing this requires passing `-Cllvm-args=-wasm-use-legacy-eh=false` to the Rust
+compiler as well:
+
+```sh
+$ RUSTFLAGS='-Cpanic=unwind -Cllvm-args=-wasm-use-legacy-eh=false' cargo +nightly build --target wasm32-unknown-unknown -Zbuild-std
+$ wasm-tools validate target/wasm32-unknown-unknown/debug/foo.wasm
+```
+
+At this time there are no concrete plans for adding new targets to the Rust
+compiler which have `-Cpanic=unwind` enabled-by-default. The most likely route
+to having this enabled is that in a few years when the `exception-handling`
+target feature is enabled by default in LLVM (due to browsers/runtime support
+propagating widely enough) the targets will switch to using `-Cpanic=unwind` by
+default. This is not for certain, however, and will likely be accompanied with
+either an MCP or an RFC about changing all wasm targets in the same manner. In
+the meantime using `-Cpanic=unwind` will require using [`-Zbuild-std`] and
+passing the appropriate flags to rustc.
+
+[`-Zbuild-std`]: ../../cargo/reference/unstable.html#build-std
diff --git a/src/doc/rustc/src/platform-support/wasm32-wasip1.md b/src/doc/rustc/src/platform-support/wasm32-wasip1.md
index a8a9e5505810b..958a34a86928c 100644
--- a/src/doc/rustc/src/platform-support/wasm32-wasip1.md
+++ b/src/doc/rustc/src/platform-support/wasm32-wasip1.md
@@ -133,3 +133,9 @@ to Rust 1.80 the `target_env` condition was not set.
 The default set of WebAssembly features enabled for compilation is currently the
 same as [`wasm32-unknown-unknown`](./wasm32-unknown-unknown.md). See the
 documentation there for more information.
+
+## Unwinding
+
+This target is compiled with `-Cpanic=abort` by default. For information on
+using `-Cpanic=unwind` see the [documentation about unwinding for
+`wasm32-unknown-unknown`](./wasm32-unknown-unknown.md#unwinding).
diff --git a/src/doc/rustc/src/platform-support/wasm32-wasip2.md b/src/doc/rustc/src/platform-support/wasm32-wasip2.md
index dea33e62f2b43..861083ad4a61a 100644
--- a/src/doc/rustc/src/platform-support/wasm32-wasip2.md
+++ b/src/doc/rustc/src/platform-support/wasm32-wasip2.md
@@ -67,3 +67,9 @@ It's recommended to conditionally compile code for this target with:
 The default set of WebAssembly features enabled for compilation is currently the
 same as [`wasm32-unknown-unknown`](./wasm32-unknown-unknown.md). See the
 documentation there for more information.
+
+## Unwinding
+
+This target is compiled with `-Cpanic=abort` by default. For information on
+using `-Cpanic=unwind` see the [documentation about unwinding for
+`wasm32-unknown-unknown`](./wasm32-unknown-unknown.md#unwinding).
diff --git a/src/doc/rustc/src/platform-support/wasm32v1-none.md b/src/doc/rustc/src/platform-support/wasm32v1-none.md
index 51b00de5e578a..d2f9b3a1f9760 100644
--- a/src/doc/rustc/src/platform-support/wasm32v1-none.md
+++ b/src/doc/rustc/src/platform-support/wasm32v1-none.md
@@ -107,3 +107,14 @@ $ cargo +nightly build -Zbuild-std=panic_abort,std --target wasm32-unknown-unkno
 Which not only rebuilds `std`, `core` and `alloc` (which is somewhat costly and annoying) but more importantly requires the use of nightly Rust toolchains (for the `-Zbuild-std` flag). This is very undesirable for the target audience, which consists of people targeting WebAssembly implementations that prioritize stability, simplicity and/or security over feature support.
 
 This `wasm32v1-none` target exists as an alternative option that works on stable Rust toolchains, without rebuilding the stdlib.
+
+## Unwinding
+
+This target is compiled with `-Cpanic=abort` by default. Using `-Cpanic=unwind`
+would require using the WebAssembly exception-handling proposal stabilized
+mid-2025, and if that's desired then you most likely don't want to use this
+target and instead want to use `wasm32-unknown-unknown` instead. It's unlikely
+that this target will ever support unwinding with the precompiled artifacts
+shipped through rustup. For documentation about using `-Zbuild-std` to enable
+using `-Cpanic=unwind` see the [documentation of
+`wasm32-unknown-unknown`](./wasm32-unknown-unknown.md#unwinding).

From 55aeb1747d97b70c75220ade6cdc53523886defd Mon Sep 17 00:00:00 2001
From: jackh726 <git@jackhuey.me>
Date: Thu, 2 Oct 2025 00:51:44 +0000
Subject: [PATCH 1700/1889] Do not assert that a change in global cache only
 happens when concurrent

---
 compiler/rustc_middle/src/ty/context.rs       |  5 +-
 compiler/rustc_type_ir/src/interner.rs        |  8 +--
 .../src/search_graph/global_cache.rs          |  4 +-
 .../rustc_type_ir/src/search_graph/mod.rs     |  2 +-
 ...rted.stderr => unsupported.current.stderr} | 28 +++++-----
 tests/ui/delegation/unsupported.next.stderr   | 51 +++++++++++++++++++
 tests/ui/delegation/unsupported.rs            |  8 +++
 7 files changed, 84 insertions(+), 22 deletions(-)
 rename tests/ui/delegation/{unsupported.stderr => unsupported.current.stderr} (76%)
 create mode 100644 tests/ui/delegation/unsupported.next.stderr

diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 7d3e2c9965dad..9a0d2602a5f17 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -207,8 +207,9 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
         from_entry(entry)
     }
 
-    fn evaluation_is_concurrent(&self) -> bool {
-        self.sess.threads() > 1
+    fn assert_evaluation_is_concurrent(&self) {
+        // Turns out, the assumption for this function isn't perfect.
+        // See trait-system-refactor-initiative#234.
     }
 
     fn expand_abstract_consts<T: TypeFoldable<TyCtxt<'tcx>>>(self, t: T) -> T {
diff --git a/compiler/rustc_type_ir/src/interner.rs b/compiler/rustc_type_ir/src/interner.rs
index cf58aec14a680..f12dcbfef98bc 100644
--- a/compiler/rustc_type_ir/src/interner.rs
+++ b/compiler/rustc_type_ir/src/interner.rs
@@ -185,7 +185,9 @@ pub trait Interner:
         from_entry: impl FnOnce(&CanonicalParamEnvCacheEntry<Self>) -> R,
     ) -> R;
 
-    fn evaluation_is_concurrent(&self) -> bool;
+    /// Useful for testing. If a cache entry is replaced, this should
+    /// (in theory) only happen when concurrent.
+    fn assert_evaluation_is_concurrent(&self);
 
     fn expand_abstract_consts<T: TypeFoldable<Self>>(self, t: T) -> T;
 
@@ -569,7 +571,7 @@ impl<I: Interner> search_graph::Cx for I {
     fn with_global_cache<R>(self, f: impl FnOnce(&mut search_graph::GlobalCache<Self>) -> R) -> R {
         I::with_global_cache(self, f)
     }
-    fn evaluation_is_concurrent(&self) -> bool {
-        self.evaluation_is_concurrent()
+    fn assert_evaluation_is_concurrent(&self) {
+        self.assert_evaluation_is_concurrent()
     }
 }
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 eb56c1af408bb..7e438fefffca0 100644
--- a/compiler/rustc_type_ir/src/search_graph/global_cache.rs
+++ b/compiler/rustc_type_ir/src/search_graph/global_cache.rs
@@ -56,13 +56,13 @@ impl<X: Cx> GlobalCache<X> {
             let with_overflow = WithOverflow { nested_goals, result };
             let prev = entry.with_overflow.insert(required_depth, with_overflow);
             if let Some(prev) = &prev {
-                assert!(cx.evaluation_is_concurrent());
+                cx.assert_evaluation_is_concurrent();
                 assert_eq!(cx.get_tracked(&prev.result), evaluation_result.result);
             }
         } else {
             let prev = entry.success.replace(Success { required_depth, nested_goals, result });
             if let Some(prev) = &prev {
-                assert!(cx.evaluation_is_concurrent());
+                cx.assert_evaluation_is_concurrent();
                 assert_eq!(cx.get_tracked(&prev.result), evaluation_result.result);
             }
         }
diff --git a/compiler/rustc_type_ir/src/search_graph/mod.rs b/compiler/rustc_type_ir/src/search_graph/mod.rs
index 8f8f019510fe8..d7f91ef692c56 100644
--- a/compiler/rustc_type_ir/src/search_graph/mod.rs
+++ b/compiler/rustc_type_ir/src/search_graph/mod.rs
@@ -53,7 +53,7 @@ pub trait Cx: Copy {
 
     fn with_global_cache<R>(self, f: impl FnOnce(&mut GlobalCache<Self>) -> R) -> R;
 
-    fn evaluation_is_concurrent(&self) -> bool;
+    fn assert_evaluation_is_concurrent(&self);
 }
 
 pub trait Delegate: Sized {
diff --git a/tests/ui/delegation/unsupported.stderr b/tests/ui/delegation/unsupported.current.stderr
similarity index 76%
rename from tests/ui/delegation/unsupported.stderr
rename to tests/ui/delegation/unsupported.current.stderr
index f69be60133e2b..55564e8f231f7 100644
--- a/tests/ui/delegation/unsupported.stderr
+++ b/tests/ui/delegation/unsupported.current.stderr
@@ -1,43 +1,43 @@
-error[E0391]: cycle detected when computing type of `opaque::<impl at $DIR/unsupported.rs:21:5: 21:24>::opaque_ret::{anon_assoc#0}`
-  --> $DIR/unsupported.rs:22:25
+error[E0391]: cycle detected when computing type of `opaque::<impl at $DIR/unsupported.rs:29:5: 29:24>::opaque_ret::{anon_assoc#0}`
+  --> $DIR/unsupported.rs:30:25
    |
 LL |         reuse to_reuse::opaque_ret;
    |                         ^^^^^^^^^^
    |
 note: ...which requires comparing an impl and trait method signature, inferring any hidden `impl Trait` types in the process...
-  --> $DIR/unsupported.rs:22:25
+  --> $DIR/unsupported.rs:30:25
    |
 LL |         reuse to_reuse::opaque_ret;
    |                         ^^^^^^^^^^
-   = note: ...which again requires computing type of `opaque::<impl at $DIR/unsupported.rs:21:5: 21:24>::opaque_ret::{anon_assoc#0}`, completing the cycle
-note: cycle used when checking assoc item `opaque::<impl at $DIR/unsupported.rs:21:5: 21:24>::opaque_ret` is compatible with trait definition
-  --> $DIR/unsupported.rs:22:25
+   = note: ...which again requires computing type of `opaque::<impl at $DIR/unsupported.rs:29:5: 29:24>::opaque_ret::{anon_assoc#0}`, completing the cycle
+note: cycle used when checking assoc item `opaque::<impl at $DIR/unsupported.rs:29:5: 29:24>::opaque_ret` is compatible with trait definition
+  --> $DIR/unsupported.rs:30:25
    |
 LL |         reuse to_reuse::opaque_ret;
    |                         ^^^^^^^^^^
    = 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[E0391]: cycle detected when computing type of `opaque::<impl at $DIR/unsupported.rs:24:5: 24:25>::opaque_ret::{anon_assoc#0}`
-  --> $DIR/unsupported.rs:25:24
+error[E0391]: cycle detected when computing type of `opaque::<impl at $DIR/unsupported.rs:32:5: 32:25>::opaque_ret::{anon_assoc#0}`
+  --> $DIR/unsupported.rs:33:24
    |
 LL |         reuse ToReuse::opaque_ret;
    |                        ^^^^^^^^^^
    |
 note: ...which requires comparing an impl and trait method signature, inferring any hidden `impl Trait` types in the process...
-  --> $DIR/unsupported.rs:25:24
+  --> $DIR/unsupported.rs:33:24
    |
 LL |         reuse ToReuse::opaque_ret;
    |                        ^^^^^^^^^^
-   = note: ...which again requires computing type of `opaque::<impl at $DIR/unsupported.rs:24:5: 24:25>::opaque_ret::{anon_assoc#0}`, completing the cycle
-note: cycle used when checking assoc item `opaque::<impl at $DIR/unsupported.rs:24:5: 24:25>::opaque_ret` is compatible with trait definition
-  --> $DIR/unsupported.rs:25:24
+   = note: ...which again requires computing type of `opaque::<impl at $DIR/unsupported.rs:32:5: 32:25>::opaque_ret::{anon_assoc#0}`, completing the cycle
+note: cycle used when checking assoc item `opaque::<impl at $DIR/unsupported.rs:32:5: 32:25>::opaque_ret` is compatible with trait definition
+  --> $DIR/unsupported.rs:33:24
    |
 LL |         reuse ToReuse::opaque_ret;
    |                        ^^^^^^^^^^
    = 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: recursive delegation is not supported yet
-  --> $DIR/unsupported.rs:38:22
+  --> $DIR/unsupported.rs:46:22
    |
 LL |         pub reuse to_reuse2::foo;
    |                              --- callee defined here
@@ -46,7 +46,7 @@ LL |     reuse to_reuse1::foo;
    |                      ^^^
 
 error[E0283]: type annotations needed
-  --> $DIR/unsupported.rs:48:18
+  --> $DIR/unsupported.rs:56:18
    |
 LL |     reuse Trait::foo;
    |                  ^^^ cannot infer type
diff --git a/tests/ui/delegation/unsupported.next.stderr b/tests/ui/delegation/unsupported.next.stderr
new file mode 100644
index 0000000000000..606a25d4269a1
--- /dev/null
+++ b/tests/ui/delegation/unsupported.next.stderr
@@ -0,0 +1,51 @@
+error[E0391]: cycle detected when computing type of `opaque::<impl at $DIR/unsupported.rs:29:5: 29:24>::opaque_ret::{anon_assoc#0}`
+  --> $DIR/unsupported.rs:30:25
+   |
+LL |         reuse to_reuse::opaque_ret;
+   |                         ^^^^^^^^^^
+   |
+note: ...which requires comparing an impl and trait method signature, inferring any hidden `impl Trait` types in the process...
+  --> $DIR/unsupported.rs:30:25
+   |
+LL |         reuse to_reuse::opaque_ret;
+   |                         ^^^^^^^^^^
+   = note: ...which again requires computing type of `opaque::<impl at $DIR/unsupported.rs:29:5: 29:24>::opaque_ret::{anon_assoc#0}`, completing the cycle
+   = note: cycle used when computing implied outlives bounds for `<u8 as opaque::ToReuse>::opaque_ret::{anon_assoc#0}` (hack disabled = 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[E0391]: cycle detected when computing type of `opaque::<impl at $DIR/unsupported.rs:32:5: 32:25>::opaque_ret::{anon_assoc#0}`
+  --> $DIR/unsupported.rs:33:24
+   |
+LL |         reuse ToReuse::opaque_ret;
+   |                        ^^^^^^^^^^
+   |
+note: ...which requires comparing an impl and trait method signature, inferring any hidden `impl Trait` types in the process...
+  --> $DIR/unsupported.rs:33:24
+   |
+LL |         reuse ToReuse::opaque_ret;
+   |                        ^^^^^^^^^^
+   = note: ...which again requires computing type of `opaque::<impl at $DIR/unsupported.rs:32:5: 32:25>::opaque_ret::{anon_assoc#0}`, completing the cycle
+   = note: cycle used when computing implied outlives bounds for `<u16 as opaque::ToReuse>::opaque_ret::{anon_assoc#0}` (hack disabled = 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: recursive delegation is not supported yet
+  --> $DIR/unsupported.rs:46:22
+   |
+LL |         pub reuse to_reuse2::foo;
+   |                              --- callee defined here
+...
+LL |     reuse to_reuse1::foo;
+   |                      ^^^
+
+error[E0283]: type annotations needed
+  --> $DIR/unsupported.rs:56:18
+   |
+LL |     reuse Trait::foo;
+   |                  ^^^ cannot infer type
+   |
+   = note: cannot satisfy `_: effects::Trait`
+
+error: aborting due to 4 previous errors
+
+Some errors have detailed explanations: E0283, E0391.
+For more information about an error, try `rustc --explain E0283`.
diff --git a/tests/ui/delegation/unsupported.rs b/tests/ui/delegation/unsupported.rs
index af1c20976d7ad..79bab342da091 100644
--- a/tests/ui/delegation/unsupported.rs
+++ b/tests/ui/delegation/unsupported.rs
@@ -1,3 +1,11 @@
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
+//@ check-fail
+
+// Next solver revision included because of trait-system-refactor-initiative#234.
+// If we end up in a query cycle, it should be okay as long as results are the same.
+
 #![feature(const_trait_impl)]
 #![feature(c_variadic)]
 #![feature(fn_delegation)]

From c721fa243825255c0f195d4282021e7c263c3e7f Mon Sep 17 00:00:00 2001
From: iximeow <iximeow@oxide.computer>
Date: Sun, 28 Sep 2025 03:21:45 +0000
Subject: [PATCH 1701/1889] interpret #[used] as #[used(compiler)] on illumos

illumos' `ld` does not support a flag like either SHF_GNU_RETAIN or
SHF_SUNW_NODISCARD, so there is no way to communicate `#[used(linker)]`
for that target. Setting `USED_LINKER` to try results in LLVM setting
SHF_SUNW_NODISCARD for Solaris-like targets, which is an unknown section
header flag for illumos `ld` and prevents sections from being merged
that otherwise would.

As a motivating example, the `inventory` crate produces
`#[used]` items to merge into `.init_array`. Because those items have an
unknown section header flag they are not merged with the default
`.init_array` with `frame_dummy`, and end up never executed.

Downgrading `#[used]` to `#[used(compiler)]` on illumos keeps
so-attributed items as preserved as they had been before
https://github.com/rust-lang/rust/pull/140872. As was the case before
that change, because rustc passes `-z ignore` to illumos `ld`, it's
possible that `used` sections are GC'd at link time.
https://github.com/rust-lang/rust/issues/146169 describes this
unfortunate circumstance.
---
 .../src/attributes/codegen_attrs.rs           | 36 ++++++++++++++-----
 .../rustc_codegen_ssa/src/codegen_attrs.rs    | 13 +++++++
 .../rustc_hir/src/attrs/data_structures.rs    |  3 +-
 3 files changed, 43 insertions(+), 9 deletions(-)

diff --git a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
index 262b8213977b3..7978bf28214cf 100644
--- a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
@@ -370,6 +370,7 @@ impl<S: Stage> NoArgsAttributeParser<S> for NoMangleParser {
 pub(crate) struct UsedParser {
     first_compiler: Option<Span>,
     first_linker: Option<Span>,
+    first_default: Option<Span>,
 }
 
 // A custom `AttributeParser` is used rather than a Simple attribute parser because
@@ -382,7 +383,7 @@ impl<S: Stage> AttributeParser<S> for UsedParser {
         template!(Word, List: &["compiler", "linker"]),
         |group: &mut Self, cx, args| {
             let used_by = match args {
-                ArgParser::NoArgs => UsedBy::Linker,
+                ArgParser::NoArgs => UsedBy::Default,
                 ArgParser::List(list) => {
                     let Some(l) = list.single() else {
                         cx.expected_single_argument(list.span);
@@ -423,12 +424,29 @@ impl<S: Stage> AttributeParser<S> for UsedParser {
                 ArgParser::NameValue(_) => return,
             };
 
+            let attr_span = cx.attr_span;
+
+            // `#[used]` is interpreted as `#[used(linker)]` (though depending on target OS the
+            // circumstances are more complicated). While we're checking `used_by`, also report
+            // these cross-`UsedBy` duplicates to warn.
             let target = match used_by {
                 UsedBy::Compiler => &mut group.first_compiler,
-                UsedBy::Linker => &mut group.first_linker,
+                UsedBy::Linker => {
+                    if let Some(prev) = group.first_default {
+                        cx.warn_unused_duplicate(prev, attr_span);
+                        return;
+                    }
+                    &mut group.first_linker
+                }
+                UsedBy::Default => {
+                    if let Some(prev) = group.first_linker {
+                        cx.warn_unused_duplicate(prev, attr_span);
+                        return;
+                    }
+                    &mut group.first_default
+                }
             };
 
-            let attr_span = cx.attr_span;
             if let Some(prev) = *target {
                 cx.warn_unused_duplicate(prev, attr_span);
             } else {
@@ -440,11 +458,13 @@ impl<S: Stage> AttributeParser<S> for UsedParser {
         AllowedTargets::AllowList(&[Allow(Target::Static), Warn(Target::MacroCall)]);
 
     fn finalize(self, _cx: &FinalizeContext<'_, '_, S>) -> Option<AttributeKind> {
-        // Ratcheting behaviour, if both `linker` and `compiler` are specified, use `linker`
-        Some(match (self.first_compiler, self.first_linker) {
-            (_, Some(span)) => AttributeKind::Used { used_by: UsedBy::Linker, span },
-            (Some(span), _) => AttributeKind::Used { used_by: UsedBy::Compiler, span },
-            (None, None) => return None,
+        // If a specific form of `used` is specified, it takes precedence over generic `#[used]`.
+        // If both `linker` and `compiler` are specified, use `linker`.
+        Some(match (self.first_compiler, self.first_linker, self.first_default) {
+            (_, Some(span), _) => AttributeKind::Used { used_by: UsedBy::Linker, span },
+            (Some(span), _, _) => AttributeKind::Used { used_by: UsedBy::Compiler, span },
+            (_, _, Some(span)) => AttributeKind::Used { used_by: UsedBy::Default, span },
+            (None, None, None) => return None,
         })
     }
 }
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
index 32ae810ecc892..2c7643e46ceaa 100644
--- a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
+++ b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -263,6 +263,19 @@ fn process_builtin_attrs(
                 AttributeKind::Used { used_by, .. } => match used_by {
                     UsedBy::Compiler => codegen_fn_attrs.flags |= CodegenFnAttrFlags::USED_COMPILER,
                     UsedBy::Linker => codegen_fn_attrs.flags |= CodegenFnAttrFlags::USED_LINKER,
+                    UsedBy::Default => {
+                        let used_form = if tcx.sess.target.os == "illumos" {
+                            // illumos' `ld` doesn't support a section header that would represent
+                            // `#[used(linker)]`, see
+                            // https://github.com/rust-lang/rust/issues/146169. For that target,
+                            // downgrade as if `#[used(compiler)]` was requested and hope for the
+                            // best.
+                            CodegenFnAttrFlags::USED_COMPILER
+                        } else {
+                            CodegenFnAttrFlags::USED_LINKER
+                        };
+                        codegen_fn_attrs.flags |= used_form;
+                    }
                 },
                 AttributeKind::FfiConst(_) => {
                     codegen_fn_attrs.flags |= CodegenFnAttrFlags::FFI_CONST
diff --git a/compiler/rustc_hir/src/attrs/data_structures.rs b/compiler/rustc_hir/src/attrs/data_structures.rs
index ddcbaeaad8803..beeca7332cb17 100644
--- a/compiler/rustc_hir/src/attrs/data_structures.rs
+++ b/compiler/rustc_hir/src/attrs/data_structures.rs
@@ -146,12 +146,13 @@ impl Deprecation {
 }
 
 /// There are three valid forms of the attribute:
-/// `#[used]`, which is semantically equivalent to `#[used(linker)]` except that the latter is currently unstable.
+/// `#[used]`, which is equivalent to `#[used(linker)]` on targets that support it, but `#[used(compiler)]` if not.
 /// `#[used(compiler)]`
 /// `#[used(linker)]`
 #[derive(Encodable, Decodable, Copy, Clone, Debug, PartialEq, Eq, Hash)]
 #[derive(HashStable_Generic, PrintAttribute)]
 pub enum UsedBy {
+    Default,
     Compiler,
     Linker,
 }

From 12cfad9a8b6aeed10ddc240b4923913246353ebb Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Fri, 3 Oct 2025 18:12:22 -0400
Subject: [PATCH 1702/1889] update autodiff batching test

---
 tests/codegen-llvm/autodiff/batched.rs | 74 +++++++++++++++-----------
 1 file changed, 42 insertions(+), 32 deletions(-)

diff --git a/tests/codegen-llvm/autodiff/batched.rs b/tests/codegen-llvm/autodiff/batched.rs
index dc82403212fb0..0ff6134bc07d5 100644
--- a/tests/codegen-llvm/autodiff/batched.rs
+++ b/tests/codegen-llvm/autodiff/batched.rs
@@ -1,4 +1,4 @@
-//@ compile-flags: -Zautodiff=Enable,NoTT -C opt-level=3  -Clto=fat
+//@ compile-flags: -Zautodiff=Enable,NoTT,NoPostopt -C opt-level=3  -Clto=fat
 //@ no-prefer-dynamic
 //@ needs-enzyme
 //
@@ -23,7 +23,7 @@ fn square(x: &f32) -> f32 {
 }
 
 // d_square2
-// CHECK: define internal fastcc [4 x float] @fwddiffe4square(float %x.0.val, [4 x ptr] %"x'")
+// CHECK: define internal [4 x float] @fwddiffe4square(ptr noalias noundef readonly align 4 captures(none) dereferenceable(4) %x, [4 x ptr] %"x'")
 // CHECK-NEXT: start:
 // CHECK-NEXT:   %0 = extractvalue [4 x ptr] %"x'", 0
 // CHECK-NEXT:   %"_2'ipl" = load float, ptr %0, align 4
@@ -33,23 +33,28 @@ fn square(x: &f32) -> f32 {
 // CHECK-NEXT:   %"_2'ipl2" = load float, ptr %2, align 4
 // CHECK-NEXT:   %3 = extractvalue [4 x ptr] %"x'", 3
 // CHECK-NEXT:   %"_2'ipl3" = load float, ptr %3, align 4
-// CHECK-NEXT:   %4 = fmul float %"_2'ipl", 2.000000e+00
-// CHECK-NEXT:   %5 = fmul fast float %4, %x.0.val
-// CHECK-NEXT:   %6 = insertvalue [4 x float] undef, float %5, 0
-// CHECK-NEXT:   %7 = fmul float %"_2'ipl1", 2.000000e+00
-// CHECK-NEXT:   %8 = fmul fast float %7, %x.0.val
-// CHECK-NEXT:   %9 = insertvalue [4 x float] %6, float %8, 1
-// CHECK-NEXT:   %10 = fmul float %"_2'ipl2", 2.000000e+00
-// CHECK-NEXT:   %11 = fmul fast float %10, %x.0.val
-// CHECK-NEXT:   %12 = insertvalue [4 x float] %9, float %11, 2
-// CHECK-NEXT:   %13 = fmul float %"_2'ipl3", 2.000000e+00
-// CHECK-NEXT:   %14 = fmul fast float %13, %x.0.val
-// CHECK-NEXT:   %15 = insertvalue [4 x float] %12, float %14, 3
-// CHECK-NEXT:   ret [4 x float] %15
+// CHECK-NEXT:   %_2 = load float, ptr %x, align 4
+// CHECK-NEXT:   %4 = fmul fast float %"_2'ipl", %_2
+// CHECK-NEXT:   %5 = fmul fast float %"_2'ipl1", %_2
+// CHECK-NEXT:   %6 = fmul fast float %"_2'ipl2", %_2
+// CHECK-NEXT:   %7 = fmul fast float %"_2'ipl3", %_2
+// CHECK-NEXT:   %8 = fmul fast float %"_2'ipl", %_2
+// CHECK-NEXT:   %9 = fmul fast float %"_2'ipl1", %_2
+// CHECK-NEXT:   %10 = fmul fast float %"_2'ipl2", %_2
+// CHECK-NEXT:   %11 = fmul fast float %"_2'ipl3", %_2
+// CHECK-NEXT:   %12 = fadd fast float %4, %8
+// CHECK-NEXT:   %13 = insertvalue [4 x float] undef, float %12, 0
+// CHECK-NEXT:   %14 = fadd fast float %5, %9
+// CHECK-NEXT:   %15 = insertvalue [4 x float] %13, float %14, 1
+// CHECK-NEXT:   %16 = fadd fast float %6, %10
+// CHECK-NEXT:   %17 = insertvalue [4 x float] %15, float %16, 2
+// CHECK-NEXT:   %18 = fadd fast float %7, %11
+// CHECK-NEXT:   %19 = insertvalue [4 x float] %17, float %18, 3
+// CHECK-NEXT:   ret [4 x float] %19
 // CHECK-NEXT:   }
 
 // d_square3, the extra float is the original return value (x * x)
-// CHECK: define internal fastcc { float, [4 x float] } @fwddiffe4square.1(float %x.0.val, [4 x ptr] %"x'")
+// CHECK: define internal { float, [4 x float] } @fwddiffe4square.1(ptr noalias noundef readonly align 4 captures(none) dereferenceable(4) %x, [4 x ptr] %"x'")
 // CHECK-NEXT: start:
 // CHECK-NEXT:   %0 = extractvalue [4 x ptr] %"x'", 0
 // CHECK-NEXT:   %"_2'ipl" = load float, ptr %0, align 4
@@ -59,22 +64,27 @@ fn square(x: &f32) -> f32 {
 // CHECK-NEXT:   %"_2'ipl2" = load float, ptr %2, align 4
 // CHECK-NEXT:   %3 = extractvalue [4 x ptr] %"x'", 3
 // CHECK-NEXT:   %"_2'ipl3" = load float, ptr %3, align 4
-// CHECK-NEXT:   %_0 = fmul float %x.0.val, %x.0.val
-// CHECK-NEXT:   %4 = fmul float %"_2'ipl", 2.000000e+00
-// CHECK-NEXT:   %5 = fmul fast float %4, %x.0.val
-// CHECK-NEXT:   %6 = insertvalue [4 x float] undef, float %5, 0
-// CHECK-NEXT:   %7 = fmul float %"_2'ipl1", 2.000000e+00
-// CHECK-NEXT:   %8 = fmul fast float %7, %x.0.val
-// CHECK-NEXT:   %9 = insertvalue [4 x float] %6, float %8, 1
-// CHECK-NEXT:   %10 = fmul float %"_2'ipl2", 2.000000e+00
-// CHECK-NEXT:   %11 = fmul fast float %10, %x.0.val
-// CHECK-NEXT:   %12 = insertvalue [4 x float] %9, float %11, 2
-// CHECK-NEXT:   %13 = fmul float %"_2'ipl3", 2.000000e+00
-// CHECK-NEXT:   %14 = fmul fast float %13, %x.0.val
-// CHECK-NEXT:   %15 = insertvalue [4 x float] %12, float %14, 3
-// CHECK-NEXT:   %16 = insertvalue { float, [4 x float] } undef, float %_0, 0
-// CHECK-NEXT:   %17 = insertvalue { float, [4 x float] } %16, [4 x float] %15, 1
-// CHECK-NEXT:   ret { float, [4 x float] } %17
+// CHECK-NEXT:   %_2 = load float, ptr %x, align 4
+// CHECK-NEXT:   %_0 = fmul float %_2, %_2
+// CHECK-NEXT:   %4 = fmul fast float %"_2'ipl", %_2
+// CHECK-NEXT:   %5 = fmul fast float %"_2'ipl1", %_2
+// CHECK-NEXT:   %6 = fmul fast float %"_2'ipl2", %_2
+// CHECK-NEXT:   %7 = fmul fast float %"_2'ipl3", %_2
+// CHECK-NEXT:   %8 = fmul fast float %"_2'ipl", %_2
+// CHECK-NEXT:   %9 = fmul fast float %"_2'ipl1", %_2
+// CHECK-NEXT:   %10 = fmul fast float %"_2'ipl2", %_2
+// CHECK-NEXT:   %11 = fmul fast float %"_2'ipl3", %_2
+// CHECK-NEXT:   %12 = fadd fast float %4, %8
+// CHECK-NEXT:   %13 = insertvalue [4 x float] undef, float %12, 0
+// CHECK-NEXT:   %14 = fadd fast float %5, %9
+// CHECK-NEXT:   %15 = insertvalue [4 x float] %13, float %14, 1
+// CHECK-NEXT:   %16 = fadd fast float %6, %10
+// CHECK-NEXT:   %17 = insertvalue [4 x float] %15, float %16, 2
+// CHECK-NEXT:   %18 = fadd fast float %7, %11
+// CHECK-NEXT:   %19 = insertvalue [4 x float] %17, float %18, 3
+// CHECK-NEXT:   %20 = insertvalue { float, [4 x float] } undef, float %_0, 0
+// CHECK-NEXT:   %21 = insertvalue { float, [4 x float] } %20, [4 x float] %19, 1
+// CHECK-NEXT:   ret { float, [4 x float] } %21
 // CHECK-NEXT:   }
 
 fn main() {

From 422b91443f1016aec2a1f00316d01a117ddc7829 Mon Sep 17 00:00:00 2001
From: yukang <moorekang@gmail.com>
Date: Sat, 4 Oct 2025 15:02:43 +0800
Subject: [PATCH 1703/1889] Fix top level ui tests check in tidy

---
 src/tools/tidy/src/ui_tests.rs | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/src/tools/tidy/src/ui_tests.rs b/src/tools/tidy/src/ui_tests.rs
index 12eca47c171dc..c74ecf3d43f46 100644
--- a/src/tools/tidy/src/ui_tests.rs
+++ b/src/tools/tidy/src/ui_tests.rs
@@ -81,21 +81,20 @@ fn deny_new_top_level_ui_tests(check: &mut RunningCheck, tests_path: &Path) {
     // - <https://github.com/rust-lang/rust/issues/73494>
     // - <https://github.com/rust-lang/rust/issues/133895>
 
-    let top_level_ui_tests = walkdir::WalkDir::new(tests_path)
-        .min_depth(1)
-        .max_depth(1)
+    let top_level_ui_tests = ignore::WalkBuilder::new(tests_path)
+        .max_depth(Some(1))
         .follow_links(false)
-        .same_file_system(true)
-        .into_iter()
+        .build()
         .flatten()
         .filter(|e| {
             let file_name = e.file_name();
             file_name != ".gitattributes" && file_name != "README.md"
         })
-        .filter(|e| !e.file_type().is_dir());
+        .filter(|e| !e.file_type().is_some_and(|f| f.is_dir()));
+
     for entry in top_level_ui_tests {
         check.error(format!(
-            "ui tests should be added under meaningful subdirectories: `{}`",
+            "ui tests should be added under meaningful subdirectories: `{}`, see https://github.com/rust-lang/compiler-team/issues/902",
             entry.path().display()
         ));
     }

From f955c76a5b8ea3265d09139126d7f0df7fcebb18 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Fri, 3 Oct 2025 14:31:32 +1000
Subject: [PATCH 1704/1889] Remove inherent methods from several LLVM FFI types

Using a helper trait allows the conversions to remain in `rustc_codegen_llvm`,
even if the FFI types are moved to a different crate.
---
 compiler/rustc_codegen_llvm/src/allocator.rs  |   2 +-
 compiler/rustc_codegen_llvm/src/builder.rs    |   3 +-
 .../src/debuginfo/metadata.rs                 |   2 +-
 compiler/rustc_codegen_llvm/src/declare.rs    |   2 +-
 .../src/llvm/conversions.rs                   | 115 ++++++++++++++++++
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs   | 107 ----------------
 compiler/rustc_codegen_llvm/src/llvm/mod.rs   |   2 +
 7 files changed, 122 insertions(+), 111 deletions(-)
 create mode 100644 compiler/rustc_codegen_llvm/src/llvm/conversions.rs

diff --git a/compiler/rustc_codegen_llvm/src/allocator.rs b/compiler/rustc_codegen_llvm/src/allocator.rs
index 896d6755c7527..824aa501036d4 100644
--- a/compiler/rustc_codegen_llvm/src/allocator.rs
+++ b/compiler/rustc_codegen_llvm/src/allocator.rs
@@ -14,7 +14,7 @@ use rustc_symbol_mangling::mangle_internal_symbol;
 use crate::attributes::llfn_attrs_from_instance;
 use crate::builder::SBuilder;
 use crate::declare::declare_simple_fn;
-use crate::llvm::{self, FALSE, TRUE, Type, Value};
+use crate::llvm::{self, FALSE, FromGeneric, TRUE, Type, Value};
 use crate::{SimpleCx, attributes, debuginfo};
 
 pub(crate) unsafe fn codegen(
diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
index e7cb18ab22daf..08da90d535da1 100644
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -36,7 +36,8 @@ use crate::attributes;
 use crate::common::Funclet;
 use crate::context::{CodegenCx, FullCx, GenericCx, SCx};
 use crate::llvm::{
-    self, AtomicOrdering, AtomicRmwBinOp, BasicBlock, GEPNoWrapFlags, Metadata, TRUE, ToLlvmBool,
+    self, AtomicOrdering, AtomicRmwBinOp, BasicBlock, FromGeneric, GEPNoWrapFlags, Metadata, TRUE,
+    ToLlvmBool,
 };
 use crate::type_::Type;
 use crate::type_of::LayoutLlvmExt;
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
index 2f9e7cae54f2b..b8b5f3d30d7c8 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
@@ -37,11 +37,11 @@ use crate::common::{AsCCharPtr, CodegenCx};
 use crate::debuginfo::dwarf_const;
 use crate::debuginfo::metadata::type_map::build_type_with_children;
 use crate::debuginfo::utils::{WidePtrKind, wide_pointer_kind};
-use crate::llvm;
 use crate::llvm::debuginfo::{
     DIBasicType, DIBuilder, DICompositeType, DIDescriptor, DIFile, DIFlags, DILexicalBlock,
     DIScope, DIType, DebugEmissionKind, DebugNameTableKind,
 };
+use crate::llvm::{self, FromGeneric};
 use crate::value::Value;
 
 impl PartialEq for llvm::Metadata {
diff --git a/compiler/rustc_codegen_llvm/src/declare.rs b/compiler/rustc_codegen_llvm/src/declare.rs
index 36cdb49883957..f598763efcf22 100644
--- a/compiler/rustc_codegen_llvm/src/declare.rs
+++ b/compiler/rustc_codegen_llvm/src/declare.rs
@@ -26,7 +26,7 @@ use crate::abi::FnAbiLlvmExt;
 use crate::common::AsCCharPtr;
 use crate::context::{CodegenCx, GenericCx, SCx, SimpleCx};
 use crate::llvm::AttributePlace::Function;
-use crate::llvm::Visibility;
+use crate::llvm::{FromGeneric, Visibility};
 use crate::type_::Type;
 use crate::value::Value;
 use crate::{attributes, llvm};
diff --git a/compiler/rustc_codegen_llvm/src/llvm/conversions.rs b/compiler/rustc_codegen_llvm/src/llvm/conversions.rs
new file mode 100644
index 0000000000000..9e9f9339ade85
--- /dev/null
+++ b/compiler/rustc_codegen_llvm/src/llvm/conversions.rs
@@ -0,0 +1,115 @@
+//! Conversions from backend-independent data types to/from LLVM FFI types.
+
+use rustc_codegen_ssa::common::{AtomicRmwBinOp, IntPredicate, RealPredicate};
+use rustc_middle::ty::AtomicOrdering;
+use rustc_session::config::DebugInfo;
+use rustc_target::spec::SymbolVisibility;
+
+use crate::llvm;
+
+/// Helper trait for converting backend-independent types to LLVM-specific
+/// types, for FFI purposes.
+pub(crate) trait FromGeneric<T> {
+    fn from_generic(other: T) -> Self;
+}
+
+impl FromGeneric<SymbolVisibility> for llvm::Visibility {
+    fn from_generic(visibility: SymbolVisibility) -> Self {
+        match visibility {
+            SymbolVisibility::Hidden => Self::Hidden,
+            SymbolVisibility::Protected => Self::Protected,
+            SymbolVisibility::Interposable => Self::Default,
+        }
+    }
+}
+
+impl FromGeneric<IntPredicate> for llvm::IntPredicate {
+    fn from_generic(int_pred: IntPredicate) -> Self {
+        match int_pred {
+            IntPredicate::IntEQ => Self::IntEQ,
+            IntPredicate::IntNE => Self::IntNE,
+            IntPredicate::IntUGT => Self::IntUGT,
+            IntPredicate::IntUGE => Self::IntUGE,
+            IntPredicate::IntULT => Self::IntULT,
+            IntPredicate::IntULE => Self::IntULE,
+            IntPredicate::IntSGT => Self::IntSGT,
+            IntPredicate::IntSGE => Self::IntSGE,
+            IntPredicate::IntSLT => Self::IntSLT,
+            IntPredicate::IntSLE => Self::IntSLE,
+        }
+    }
+}
+
+impl FromGeneric<RealPredicate> for llvm::RealPredicate {
+    fn from_generic(real_pred: RealPredicate) -> Self {
+        match real_pred {
+            RealPredicate::RealPredicateFalse => Self::RealPredicateFalse,
+            RealPredicate::RealOEQ => Self::RealOEQ,
+            RealPredicate::RealOGT => Self::RealOGT,
+            RealPredicate::RealOGE => Self::RealOGE,
+            RealPredicate::RealOLT => Self::RealOLT,
+            RealPredicate::RealOLE => Self::RealOLE,
+            RealPredicate::RealONE => Self::RealONE,
+            RealPredicate::RealORD => Self::RealORD,
+            RealPredicate::RealUNO => Self::RealUNO,
+            RealPredicate::RealUEQ => Self::RealUEQ,
+            RealPredicate::RealUGT => Self::RealUGT,
+            RealPredicate::RealUGE => Self::RealUGE,
+            RealPredicate::RealULT => Self::RealULT,
+            RealPredicate::RealULE => Self::RealULE,
+            RealPredicate::RealUNE => Self::RealUNE,
+            RealPredicate::RealPredicateTrue => Self::RealPredicateTrue,
+        }
+    }
+}
+
+impl FromGeneric<AtomicRmwBinOp> for llvm::AtomicRmwBinOp {
+    fn from_generic(op: AtomicRmwBinOp) -> Self {
+        match op {
+            AtomicRmwBinOp::AtomicXchg => Self::AtomicXchg,
+            AtomicRmwBinOp::AtomicAdd => Self::AtomicAdd,
+            AtomicRmwBinOp::AtomicSub => Self::AtomicSub,
+            AtomicRmwBinOp::AtomicAnd => Self::AtomicAnd,
+            AtomicRmwBinOp::AtomicNand => Self::AtomicNand,
+            AtomicRmwBinOp::AtomicOr => Self::AtomicOr,
+            AtomicRmwBinOp::AtomicXor => Self::AtomicXor,
+            AtomicRmwBinOp::AtomicMax => Self::AtomicMax,
+            AtomicRmwBinOp::AtomicMin => Self::AtomicMin,
+            AtomicRmwBinOp::AtomicUMax => Self::AtomicUMax,
+            AtomicRmwBinOp::AtomicUMin => Self::AtomicUMin,
+        }
+    }
+}
+
+impl FromGeneric<AtomicOrdering> for llvm::AtomicOrdering {
+    fn from_generic(ordering: AtomicOrdering) -> Self {
+        match ordering {
+            AtomicOrdering::Relaxed => Self::Monotonic,
+            AtomicOrdering::Acquire => Self::Acquire,
+            AtomicOrdering::Release => Self::Release,
+            AtomicOrdering::AcqRel => Self::AcquireRelease,
+            AtomicOrdering::SeqCst => Self::SequentiallyConsistent,
+        }
+    }
+}
+
+impl FromGeneric<DebugInfo> for llvm::debuginfo::DebugEmissionKind {
+    fn from_generic(kind: DebugInfo) -> Self {
+        // We should be setting LLVM's emission kind to `LineTablesOnly` if
+        // we are compiling with "limited" debuginfo. However, some of the
+        // existing tools relied on slightly more debuginfo being generated than
+        // would be the case with `LineTablesOnly`, and we did not want to break
+        // these tools in a "drive-by fix", without a good idea or plan about
+        // what limited debuginfo should exactly look like. So for now we are
+        // instead adding a new debuginfo option "line-tables-only" so as to
+        // not break anything and to allow users to have 'limited' debug info.
+        //
+        // See https://github.com/rust-lang/rust/issues/60020 for details.
+        match kind {
+            DebugInfo::None => Self::NoDebug,
+            DebugInfo::LineDirectivesOnly => Self::DebugDirectivesOnly,
+            DebugInfo::LineTablesOnly => Self::LineTablesOnly,
+            DebugInfo::Limited | DebugInfo::Full => Self::FullDebug,
+        }
+    }
+}
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 7fbba0294073f..965e775bed704 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -20,7 +20,6 @@ use std::ptr;
 use bitflags::bitflags;
 use libc::{c_char, c_int, c_uchar, c_uint, c_ulonglong, c_void, size_t};
 use rustc_macros::TryFromU32;
-use rustc_target::spec::SymbolVisibility;
 
 use super::RustString;
 use super::debuginfo::{
@@ -220,16 +219,6 @@ pub(crate) enum Visibility {
     Protected = 2,
 }
 
-impl Visibility {
-    pub(crate) fn from_generic(visibility: SymbolVisibility) -> Self {
-        match visibility {
-            SymbolVisibility::Hidden => Visibility::Hidden,
-            SymbolVisibility::Protected => Visibility::Protected,
-            SymbolVisibility::Interposable => Visibility::Default,
-        }
-    }
-}
-
 /// LLVMUnnamedAddr
 #[repr(C)]
 pub(crate) enum UnnamedAddr {
@@ -319,24 +308,6 @@ pub(crate) enum IntPredicate {
     IntSLE = 41,
 }
 
-impl IntPredicate {
-    pub(crate) fn from_generic(intpre: rustc_codegen_ssa::common::IntPredicate) -> Self {
-        use rustc_codegen_ssa::common::IntPredicate as Common;
-        match intpre {
-            Common::IntEQ => Self::IntEQ,
-            Common::IntNE => Self::IntNE,
-            Common::IntUGT => Self::IntUGT,
-            Common::IntUGE => Self::IntUGE,
-            Common::IntULT => Self::IntULT,
-            Common::IntULE => Self::IntULE,
-            Common::IntSGT => Self::IntSGT,
-            Common::IntSGE => Self::IntSGE,
-            Common::IntSLT => Self::IntSLT,
-            Common::IntSLE => Self::IntSLE,
-        }
-    }
-}
-
 /// LLVMRealPredicate
 #[derive(Copy, Clone)]
 #[repr(C)]
@@ -359,30 +330,6 @@ pub(crate) enum RealPredicate {
     RealPredicateTrue = 15,
 }
 
-impl RealPredicate {
-    pub(crate) fn from_generic(realp: rustc_codegen_ssa::common::RealPredicate) -> Self {
-        use rustc_codegen_ssa::common::RealPredicate as Common;
-        match realp {
-            Common::RealPredicateFalse => Self::RealPredicateFalse,
-            Common::RealOEQ => Self::RealOEQ,
-            Common::RealOGT => Self::RealOGT,
-            Common::RealOGE => Self::RealOGE,
-            Common::RealOLT => Self::RealOLT,
-            Common::RealOLE => Self::RealOLE,
-            Common::RealONE => Self::RealONE,
-            Common::RealORD => Self::RealORD,
-            Common::RealUNO => Self::RealUNO,
-            Common::RealUEQ => Self::RealUEQ,
-            Common::RealUGT => Self::RealUGT,
-            Common::RealUGE => Self::RealUGE,
-            Common::RealULT => Self::RealULT,
-            Common::RealULE => Self::RealULE,
-            Common::RealUNE => Self::RealUNE,
-            Common::RealPredicateTrue => Self::RealPredicateTrue,
-        }
-    }
-}
-
 /// Must match the layout of `LLVMTypeKind`.
 ///
 /// Use [`RawEnum<TypeKind>`] for values of `LLVMTypeKind` returned from LLVM,
@@ -458,25 +405,6 @@ pub(crate) enum AtomicRmwBinOp {
     AtomicUMin = 10,
 }
 
-impl AtomicRmwBinOp {
-    pub(crate) fn from_generic(op: rustc_codegen_ssa::common::AtomicRmwBinOp) -> Self {
-        use rustc_codegen_ssa::common::AtomicRmwBinOp as Common;
-        match op {
-            Common::AtomicXchg => Self::AtomicXchg,
-            Common::AtomicAdd => Self::AtomicAdd,
-            Common::AtomicSub => Self::AtomicSub,
-            Common::AtomicAnd => Self::AtomicAnd,
-            Common::AtomicNand => Self::AtomicNand,
-            Common::AtomicOr => Self::AtomicOr,
-            Common::AtomicXor => Self::AtomicXor,
-            Common::AtomicMax => Self::AtomicMax,
-            Common::AtomicMin => Self::AtomicMin,
-            Common::AtomicUMax => Self::AtomicUMax,
-            Common::AtomicUMin => Self::AtomicUMin,
-        }
-    }
-}
-
 /// LLVMAtomicOrdering
 #[derive(Copy, Clone)]
 #[repr(C)]
@@ -493,19 +421,6 @@ pub(crate) enum AtomicOrdering {
     SequentiallyConsistent = 7,
 }
 
-impl AtomicOrdering {
-    pub(crate) fn from_generic(ao: rustc_middle::ty::AtomicOrdering) -> Self {
-        use rustc_middle::ty::AtomicOrdering as Common;
-        match ao {
-            Common::Relaxed => Self::Monotonic,
-            Common::Acquire => Self::Acquire,
-            Common::Release => Self::Release,
-            Common::AcqRel => Self::AcquireRelease,
-            Common::SeqCst => Self::SequentiallyConsistent,
-        }
-    }
-}
-
 /// LLVMRustFileType
 #[derive(Copy, Clone)]
 #[repr(C)]
@@ -940,28 +855,6 @@ pub(crate) mod debuginfo {
         DebugDirectivesOnly,
     }
 
-    impl DebugEmissionKind {
-        pub(crate) fn from_generic(kind: rustc_session::config::DebugInfo) -> Self {
-            // We should be setting LLVM's emission kind to `LineTablesOnly` if
-            // we are compiling with "limited" debuginfo. However, some of the
-            // existing tools relied on slightly more debuginfo being generated than
-            // would be the case with `LineTablesOnly`, and we did not want to break
-            // these tools in a "drive-by fix", without a good idea or plan about
-            // what limited debuginfo should exactly look like. So for now we are
-            // instead adding a new debuginfo option "line-tables-only" so as to
-            // not break anything and to allow users to have 'limited' debug info.
-            //
-            // See https://github.com/rust-lang/rust/issues/60020 for details.
-            use rustc_session::config::DebugInfo;
-            match kind {
-                DebugInfo::None => DebugEmissionKind::NoDebug,
-                DebugInfo::LineDirectivesOnly => DebugEmissionKind::DebugDirectivesOnly,
-                DebugInfo::LineTablesOnly => DebugEmissionKind::LineTablesOnly,
-                DebugInfo::Limited | DebugInfo::Full => DebugEmissionKind::FullDebug,
-            }
-        }
-    }
-
     /// LLVMRustDebugNameTableKind
     #[derive(Clone, Copy)]
     #[repr(C)]
diff --git a/compiler/rustc_codegen_llvm/src/llvm/mod.rs b/compiler/rustc_codegen_llvm/src/llvm/mod.rs
index 9a53dacb1dfdd..4c58a92106d5c 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/mod.rs
@@ -11,10 +11,12 @@ use rustc_llvm::RustString;
 
 pub(crate) use self::CallConv::*;
 pub(crate) use self::CodeGenOptSize::*;
+pub(crate) use self::conversions::*;
 pub(crate) use self::ffi::*;
 pub(crate) use self::metadata_kind::*;
 use crate::common::AsCCharPtr;
 
+mod conversions;
 pub(crate) mod diagnostic;
 pub(crate) mod enzyme_ffi;
 mod ffi;

From 0661a3d6fe4efd7127c66aeb6484f06b3441c63f Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Fri, 3 Oct 2025 17:11:53 +1000
Subject: [PATCH 1705/1889] Remove inherent methods from
 `coverageinfo::ffi::Counter`

This patch also moves `Regions` to a different module, since that type can stay
put when the FFI bindings move to another crate.
---
 .../src/coverageinfo/ffi.rs                   | 45 +------------------
 .../src/coverageinfo/llvm_cov.rs              | 27 ++++++++++-
 .../src/coverageinfo/mapgen/covfun.rs         | 27 +++++++----
 3 files changed, 45 insertions(+), 54 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/coverageinfo/ffi.rs b/compiler/rustc_codegen_llvm/src/coverageinfo/ffi.rs
index a4b60d420f3fb..caa36c5dd4992 100644
--- a/compiler/rustc_codegen_llvm/src/coverageinfo/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/coverageinfo/ffi.rs
@@ -1,5 +1,3 @@
-use rustc_middle::mir::coverage::{CounterId, CovTerm, ExpressionId};
-
 /// Must match the layout of `LLVMRustCounterKind`.
 #[derive(Copy, Clone, Debug)]
 #[repr(C)]
@@ -26,30 +24,12 @@ pub(crate) enum CounterKind {
 pub(crate) struct Counter {
     // Important: The layout (order and types of fields) must match its C++ counterpart.
     pub(crate) kind: CounterKind,
-    id: u32,
+    pub(crate) id: u32,
 }
 
 impl Counter {
     /// A `Counter` of kind `Zero`. For this counter kind, the `id` is not used.
     pub(crate) const ZERO: Self = Self { kind: CounterKind::Zero, id: 0 };
-
-    /// Constructs a new `Counter` of kind `CounterValueReference`.
-    pub(crate) fn counter_value_reference(counter_id: CounterId) -> Self {
-        Self { kind: CounterKind::CounterValueReference, id: counter_id.as_u32() }
-    }
-
-    /// Constructs a new `Counter` of kind `Expression`.
-    pub(crate) fn expression(expression_id: ExpressionId) -> Self {
-        Self { kind: CounterKind::Expression, id: expression_id.as_u32() }
-    }
-
-    pub(crate) fn from_term(term: CovTerm) -> Self {
-        match term {
-            CovTerm::Zero => Self::ZERO,
-            CovTerm::Counter(id) => Self::counter_value_reference(id),
-            CovTerm::Expression(id) => Self::expression(id),
-        }
-    }
 }
 
 /// Corresponds to enum `llvm::coverage::CounterExpression::ExprKind`.
@@ -94,29 +74,6 @@ pub(crate) struct CoverageSpan {
     pub(crate) end_col: u32,
 }
 
-/// Holds tables of the various region types in one struct.
-///
-/// Don't pass this struct across FFI; pass the individual region tables as
-/// pointer/length pairs instead.
-///
-/// Each field name has a `_regions` suffix for improved readability after
-/// exhaustive destructing, which ensures that all region types are handled.
-#[derive(Clone, Debug, Default)]
-pub(crate) struct Regions {
-    pub(crate) code_regions: Vec<CodeRegion>,
-    pub(crate) expansion_regions: Vec<ExpansionRegion>,
-    pub(crate) branch_regions: Vec<BranchRegion>,
-}
-
-impl Regions {
-    /// Returns true if none of this structure's tables contain any regions.
-    pub(crate) fn has_no_regions(&self) -> bool {
-        let Self { code_regions, expansion_regions, branch_regions } = self;
-
-        code_regions.is_empty() && expansion_regions.is_empty() && branch_regions.is_empty()
-    }
-}
-
 /// Must match the layout of `LLVMRustCoverageCodeRegion`.
 #[derive(Clone, Debug)]
 #[repr(C)]
diff --git a/compiler/rustc_codegen_llvm/src/coverageinfo/llvm_cov.rs b/compiler/rustc_codegen_llvm/src/coverageinfo/llvm_cov.rs
index d50eb533ffdbb..a58202834cfa5 100644
--- a/compiler/rustc_codegen_llvm/src/coverageinfo/llvm_cov.rs
+++ b/compiler/rustc_codegen_llvm/src/coverageinfo/llvm_cov.rs
@@ -57,12 +57,35 @@ pub(crate) fn write_filenames_to_buffer(filenames: &[impl AsRef<str>]) -> Vec<u8
     })
 }
 
+/// Holds tables of the various region types in one struct.
+///
+/// Don't pass this struct across FFI; pass the individual region tables as
+/// pointer/length pairs instead.
+///
+/// Each field name has a `_regions` suffix for improved readability after
+/// exhaustive destructing, which ensures that all region types are handled.
+#[derive(Clone, Debug, Default)]
+pub(crate) struct Regions {
+    pub(crate) code_regions: Vec<ffi::CodeRegion>,
+    pub(crate) expansion_regions: Vec<ffi::ExpansionRegion>,
+    pub(crate) branch_regions: Vec<ffi::BranchRegion>,
+}
+
+impl Regions {
+    /// Returns true if none of this structure's tables contain any regions.
+    pub(crate) fn has_no_regions(&self) -> bool {
+        let Self { code_regions, expansion_regions, branch_regions } = self;
+
+        code_regions.is_empty() && expansion_regions.is_empty() && branch_regions.is_empty()
+    }
+}
+
 pub(crate) fn write_function_mappings_to_buffer(
     virtual_file_mapping: &[u32],
     expressions: &[ffi::CounterExpression],
-    regions: &ffi::Regions,
+    regions: &Regions,
 ) -> Vec<u8> {
-    let ffi::Regions { code_regions, expansion_regions, branch_regions } = regions;
+    let Regions { code_regions, expansion_regions, branch_regions } = regions;
 
     // SAFETY:
     // - All types are FFI-compatible and have matching representations in Rust/C++.
diff --git a/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen/covfun.rs b/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen/covfun.rs
index e0da8d368762b..7835d18046860 100644
--- a/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen/covfun.rs
+++ b/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen/covfun.rs
@@ -10,8 +10,8 @@ use std::sync::Arc;
 use rustc_abi::Align;
 use rustc_codegen_ssa::traits::{BaseTypeCodegenMethods as _, ConstCodegenMethods};
 use rustc_middle::mir::coverage::{
-    BasicCoverageBlock, CovTerm, CoverageIdsInfo, Expression, FunctionCoverageInfo, Mapping,
-    MappingKind, Op,
+    BasicCoverageBlock, CounterId, CovTerm, CoverageIdsInfo, Expression, ExpressionId,
+    FunctionCoverageInfo, Mapping, MappingKind, Op,
 };
 use rustc_middle::ty::{Instance, TyCtxt};
 use rustc_span::{SourceFile, Span};
@@ -36,7 +36,7 @@ pub(crate) struct CovfunRecord<'tcx> {
 
     virtual_file_mapping: VirtualFileMapping,
     expressions: Vec<ffi::CounterExpression>,
-    regions: ffi::Regions,
+    regions: llvm_cov::Regions,
 }
 
 impl<'tcx> CovfunRecord<'tcx> {
@@ -64,7 +64,7 @@ pub(crate) fn prepare_covfun_record<'tcx>(
         is_used,
         virtual_file_mapping: VirtualFileMapping::default(),
         expressions,
-        regions: ffi::Regions::default(),
+        regions: llvm_cov::Regions::default(),
     };
 
     fill_region_tables(tcx, fn_cov_info, ids_info, &mut covfun);
@@ -77,10 +77,21 @@ pub(crate) fn prepare_covfun_record<'tcx>(
     Some(covfun)
 }
 
+pub(crate) fn counter_for_term(term: CovTerm) -> ffi::Counter {
+    use ffi::Counter;
+    match term {
+        CovTerm::Zero => Counter::ZERO,
+        CovTerm::Counter(id) => {
+            Counter { kind: ffi::CounterKind::CounterValueReference, id: CounterId::as_u32(id) }
+        }
+        CovTerm::Expression(id) => {
+            Counter { kind: ffi::CounterKind::Expression, id: ExpressionId::as_u32(id) }
+        }
+    }
+}
+
 /// Convert the function's coverage-counter expressions into a form suitable for FFI.
 fn prepare_expressions(ids_info: &CoverageIdsInfo) -> Vec<ffi::CounterExpression> {
-    let counter_for_term = ffi::Counter::from_term;
-
     // We know that LLVM will optimize out any unused expressions before
     // producing the final coverage map, so there's no need to do the same
     // thing on the Rust side unless we're confident we can do much better.
@@ -113,7 +124,7 @@ fn fill_region_tables<'tcx>(
         } else {
             CovTerm::Zero
         };
-        ffi::Counter::from_term(term)
+        counter_for_term(term)
     };
 
     // Currently a function's mappings must all be in the same file, so use the
@@ -136,7 +147,7 @@ fn fill_region_tables<'tcx>(
         if discard_all { None } else { spans::make_coords(source_map, &source_file, span) }
     };
 
-    let ffi::Regions {
+    let llvm_cov::Regions {
         code_regions,
         expansion_regions: _, // FIXME(Zalathar): Fill out support for expansion regions
         branch_regions,

From 3831b60ef3dd46d11f63041016bd1e6f6f9039f5 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sat, 4 Oct 2025 17:54:03 +1000
Subject: [PATCH 1706/1889] Remove inherent methods from `llvm::Type`

---
 compiler/rustc_codegen_llvm/src/back/write.rs |  4 ++--
 compiler/rustc_codegen_llvm/src/context.rs    |  2 +-
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs   |  4 ++--
 compiler/rustc_codegen_llvm/src/type_.rs      | 24 +++++++++----------
 4 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/back/write.rs b/compiler/rustc_codegen_llvm/src/back/write.rs
index 1950b8288d149..6ce1cbe072c06 100644
--- a/compiler/rustc_codegen_llvm/src/back/write.rs
+++ b/compiler/rustc_codegen_llvm/src/back/write.rs
@@ -44,7 +44,7 @@ use crate::errors::{
 };
 use crate::llvm::diagnostic::OptimizationDiagnosticKind::*;
 use crate::llvm::{self, DiagnosticInfo};
-use crate::type_::Type;
+use crate::type_::llvm_type_ptr;
 use crate::{LlvmCodegenBackend, ModuleLlvm, base, common, llvm_util};
 
 pub(crate) fn llvm_err<'a>(dcx: DiagCtxtHandle<'_>, err: LlvmError<'a>) -> ! {
@@ -1160,7 +1160,7 @@ fn create_msvc_imps(
     // underscores added in front).
     let prefix = if cgcx.target_arch == "x86" { "\x01__imp__" } else { "\x01__imp_" };
 
-    let ptr_ty = Type::ptr_llcx(llcx);
+    let ptr_ty = llvm_type_ptr(llcx);
     let globals = base::iter_globals(llmod)
         .filter(|&val| {
             llvm::get_linkage(val) == llvm::Linkage::ExternalLinkage && !llvm::is_declaration(val)
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index 922575dd63cfa..cda5b3a5f9aaf 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -740,7 +740,7 @@ impl<'ll> SimpleCx<'ll> {
         llcx: &'ll llvm::Context,
         pointer_size: Size,
     ) -> Self {
-        let isize_ty = llvm::Type::ix_llcx(llcx, pointer_size.bits());
+        let isize_ty = llvm::LLVMIntTypeInContext(llcx, pointer_size.bits() as c_uint);
         Self(SCx { llmod, llcx, isize_ty }, PhantomData)
     }
 }
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 965e775bed704..ccbc999dad1f0 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -954,7 +954,7 @@ unsafe extern "C" {
     pub(crate) fn LLVMInt16TypeInContext(C: &Context) -> &Type;
     pub(crate) fn LLVMInt32TypeInContext(C: &Context) -> &Type;
     pub(crate) fn LLVMInt64TypeInContext(C: &Context) -> &Type;
-    pub(crate) fn LLVMIntTypeInContext(C: &Context, NumBits: c_uint) -> &Type;
+    pub(crate) safe fn LLVMIntTypeInContext(C: &Context, NumBits: c_uint) -> &Type;
 
     pub(crate) fn LLVMGetIntTypeWidth(IntegerTy: &Type) -> c_uint;
 
@@ -983,7 +983,7 @@ unsafe extern "C" {
     ) -> &'a Type;
 
     // Operations on array, pointer, and vector types (sequence types)
-    pub(crate) fn LLVMPointerTypeInContext(C: &Context, AddressSpace: c_uint) -> &Type;
+    pub(crate) safe fn LLVMPointerTypeInContext(C: &Context, AddressSpace: c_uint) -> &Type;
     pub(crate) fn LLVMVectorType(ElementType: &Type, ElementCount: c_uint) -> &Type;
 
     pub(crate) fn LLVMGetElementType(Ty: &Type) -> &Type;
diff --git a/compiler/rustc_codegen_llvm/src/type_.rs b/compiler/rustc_codegen_llvm/src/type_.rs
index 1e5cf8374e379..9de9e0ec44c67 100644
--- a/compiler/rustc_codegen_llvm/src/type_.rs
+++ b/compiler/rustc_codegen_llvm/src/type_.rs
@@ -63,7 +63,7 @@ impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX> {
 
     ///x Creates an integer type with the given number of bits, e.g., i24
     pub(crate) fn type_ix(&self, num_bits: u64) -> &'ll Type {
-        unsafe { llvm::LLVMIntTypeInContext(self.llcx(), num_bits as c_uint) }
+        llvm::LLVMIntTypeInContext(self.llcx(), num_bits as c_uint)
     }
 
     pub(crate) fn type_vector(&self, ty: &'ll Type, len: u64) -> &'ll Type {
@@ -178,7 +178,7 @@ impl<'ll, CX: Borrow<SCx<'ll>>> BaseTypeCodegenMethods for GenericCx<'ll, CX> {
     }
 
     fn type_i128(&self) -> &'ll Type {
-        unsafe { llvm::LLVMIntTypeInContext(self.llcx(), 128) }
+        self.type_ix(128)
     }
 
     fn type_isize(&self) -> &'ll Type {
@@ -210,11 +210,11 @@ impl<'ll, CX: Borrow<SCx<'ll>>> BaseTypeCodegenMethods for GenericCx<'ll, CX> {
     }
 
     fn type_ptr(&self) -> &'ll Type {
-        self.type_ptr_ext(AddressSpace::ZERO)
+        llvm_type_ptr(self.llcx())
     }
 
     fn type_ptr_ext(&self, address_space: AddressSpace) -> &'ll Type {
-        unsafe { llvm::LLVMPointerTypeInContext(self.llcx(), address_space.0) }
+        llvm_type_ptr_in_address_space(self.llcx(), address_space)
     }
 
     fn element_type(&self, ty: &'ll Type) -> &'ll Type {
@@ -253,15 +253,15 @@ impl<'ll, CX: Borrow<SCx<'ll>>> BaseTypeCodegenMethods for GenericCx<'ll, CX> {
     }
 }
 
-impl Type {
-    /// Creates an integer type with the given number of bits, e.g., i24
-    pub(crate) fn ix_llcx(llcx: &llvm::Context, num_bits: u64) -> &Type {
-        unsafe { llvm::LLVMIntTypeInContext(llcx, num_bits as c_uint) }
-    }
+pub(crate) fn llvm_type_ptr(llcx: &llvm::Context) -> &Type {
+    llvm_type_ptr_in_address_space(llcx, AddressSpace::ZERO)
+}
 
-    pub(crate) fn ptr_llcx(llcx: &llvm::Context) -> &Type {
-        unsafe { llvm::LLVMPointerTypeInContext(llcx, AddressSpace::ZERO.0) }
-    }
+pub(crate) fn llvm_type_ptr_in_address_space<'ll>(
+    llcx: &'ll llvm::Context,
+    addr_space: AddressSpace,
+) -> &'ll Type {
+    llvm::LLVMPointerTypeInContext(llcx, addr_space.0)
 }
 
 impl<'ll, 'tcx> LayoutTypeCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {

From f8c54d24e2f4ca8539cb6d9b174e4c873bbb3ed7 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Fri, 3 Oct 2025 17:25:03 +1000
Subject: [PATCH 1707/1889] Remove inherent methods from
 `llvm::CallConv::from_conv`

---
 compiler/rustc_codegen_llvm/src/abi.rs     | 78 +++++++++++-----------
 compiler/rustc_codegen_llvm/src/context.rs |  6 +-
 2 files changed, 41 insertions(+), 43 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/abi.rs b/compiler/rustc_codegen_llvm/src/abi.rs
index 1703cab942bdd..15b4d5247a978 100644
--- a/compiler/rustc_codegen_llvm/src/abi.rs
+++ b/compiler/rustc_codegen_llvm/src/abi.rs
@@ -1,4 +1,3 @@
-use std::borrow::Borrow;
 use std::cmp;
 
 use libc::c_uint;
@@ -13,7 +12,7 @@ use rustc_codegen_ssa::traits::*;
 use rustc_middle::ty::Ty;
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::{bug, ty};
-use rustc_session::config;
+use rustc_session::{Session, config};
 use rustc_target::callconv::{
     ArgAbi, ArgAttribute, ArgAttributes, ArgExtension, CastTarget, FnAbi, PassMode,
 };
@@ -400,7 +399,7 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
     }
 
     fn llvm_cconv(&self, cx: &CodegenCx<'ll, 'tcx>) -> llvm::CallConv {
-        llvm::CallConv::from_conv(self.conv, cx.tcx.sess.target.arch.borrow())
+        to_llvm_calling_convention(cx.tcx.sess, self.conv)
     }
 
     fn apply_attrs_llfn(
@@ -663,43 +662,44 @@ impl AbiBuilderMethods for Builder<'_, '_, '_> {
     }
 }
 
-impl llvm::CallConv {
-    pub(crate) fn from_conv(conv: CanonAbi, arch: &str) -> Self {
-        match conv {
-            CanonAbi::C | CanonAbi::Rust => llvm::CCallConv,
-            CanonAbi::RustCold => llvm::PreserveMost,
-            // Functions with this calling convention can only be called from assembly, but it is
-            // possible to declare an `extern "custom"` block, so the backend still needs a calling
-            // convention for declaring foreign functions.
-            CanonAbi::Custom => llvm::CCallConv,
-            CanonAbi::GpuKernel => {
-                if arch == "amdgpu" {
-                    llvm::AmdgpuKernel
-                } else if arch == "nvptx64" {
-                    llvm::PtxKernel
-                } else {
-                    panic!("Architecture {arch} does not support GpuKernel calling convention");
-                }
+/// Determines the appropriate [`llvm::CallConv`] to use for a given function
+/// ABI, for the current target.
+pub(crate) fn to_llvm_calling_convention(sess: &Session, abi: CanonAbi) -> llvm::CallConv {
+    match abi {
+        CanonAbi::C | CanonAbi::Rust => llvm::CCallConv,
+        CanonAbi::RustCold => llvm::PreserveMost,
+        // Functions with this calling convention can only be called from assembly, but it is
+        // possible to declare an `extern "custom"` block, so the backend still needs a calling
+        // convention for declaring foreign functions.
+        CanonAbi::Custom => llvm::CCallConv,
+        CanonAbi::GpuKernel => {
+            let arch = sess.target.arch.as_ref();
+            if arch == "amdgpu" {
+                llvm::AmdgpuKernel
+            } else if arch == "nvptx64" {
+                llvm::PtxKernel
+            } else {
+                panic!("Architecture {arch} does not support GpuKernel calling convention");
             }
-            CanonAbi::Interrupt(interrupt_kind) => match interrupt_kind {
-                InterruptKind::Avr => llvm::AvrInterrupt,
-                InterruptKind::AvrNonBlocking => llvm::AvrNonBlockingInterrupt,
-                InterruptKind::Msp430 => llvm::Msp430Intr,
-                InterruptKind::RiscvMachine | InterruptKind::RiscvSupervisor => llvm::CCallConv,
-                InterruptKind::X86 => llvm::X86_Intr,
-            },
-            CanonAbi::Arm(arm_call) => match arm_call {
-                ArmCall::Aapcs => llvm::ArmAapcsCallConv,
-                ArmCall::CCmseNonSecureCall | ArmCall::CCmseNonSecureEntry => llvm::CCallConv,
-            },
-            CanonAbi::X86(x86_call) => match x86_call {
-                X86Call::Fastcall => llvm::X86FastcallCallConv,
-                X86Call::Stdcall => llvm::X86StdcallCallConv,
-                X86Call::SysV64 => llvm::X86_64_SysV,
-                X86Call::Thiscall => llvm::X86_ThisCall,
-                X86Call::Vectorcall => llvm::X86_VectorCall,
-                X86Call::Win64 => llvm::X86_64_Win64,
-            },
         }
+        CanonAbi::Interrupt(interrupt_kind) => match interrupt_kind {
+            InterruptKind::Avr => llvm::AvrInterrupt,
+            InterruptKind::AvrNonBlocking => llvm::AvrNonBlockingInterrupt,
+            InterruptKind::Msp430 => llvm::Msp430Intr,
+            InterruptKind::RiscvMachine | InterruptKind::RiscvSupervisor => llvm::CCallConv,
+            InterruptKind::X86 => llvm::X86_Intr,
+        },
+        CanonAbi::Arm(arm_call) => match arm_call {
+            ArmCall::Aapcs => llvm::ArmAapcsCallConv,
+            ArmCall::CCmseNonSecureCall | ArmCall::CCmseNonSecureEntry => llvm::CCallConv,
+        },
+        CanonAbi::X86(x86_call) => match x86_call {
+            X86Call::Fastcall => llvm::X86FastcallCallConv,
+            X86Call::Stdcall => llvm::X86StdcallCallConv,
+            X86Call::SysV64 => llvm::X86_64_SysV,
+            X86Call::Thiscall => llvm::X86_ThisCall,
+            X86Call::Vectorcall => llvm::X86_VectorCall,
+            X86Call::Win64 => llvm::X86_64_Win64,
+        },
     }
 }
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index cda5b3a5f9aaf..3ddbd81ef7580 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -31,6 +31,7 @@ use rustc_symbol_mangling::mangle_internal_symbol;
 use rustc_target::spec::{HasTargetSpec, RelocModel, SmallDataThresholdSupport, Target, TlsModel};
 use smallvec::SmallVec;
 
+use crate::abi::to_llvm_calling_convention;
 use crate::back::write::to_llvm_code_model;
 use crate::callee::get_fn;
 use crate::debuginfo::metadata::apply_vcall_visibility_metadata;
@@ -901,10 +902,7 @@ impl<'ll, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         if self.get_declared_value(entry_name).is_none() {
             let llfn = self.declare_entry_fn(
                 entry_name,
-                llvm::CallConv::from_conv(
-                    self.sess().target.entry_abi,
-                    self.sess().target.arch.borrow(),
-                ),
+                to_llvm_calling_convention(self.sess(), self.sess().target.entry_abi),
                 llvm::UnnamedAddr::Global,
                 fn_type,
             );

From e9a45e66461f3c324a249d7352eb2f4d184a6b2a Mon Sep 17 00:00:00 2001
From: yukang <moorekang@gmail.com>
Date: Sat, 4 Oct 2025 14:48:55 +0800
Subject: [PATCH 1708/1889] Avoid to suggest pattern match on the similarly
 named in fn signature

---
 compiler/rustc_passes/src/liveness.rs              |  7 +++++--
 .../ui/fn/invalid-sugg-for-unused-fn-arg-147303.rs | 13 +++++++++++++
 .../invalid-sugg-for-unused-fn-arg-147303.stderr   | 14 ++++++++++++++
 .../non-snake-case/lint-uppercase-variables.stderr | 11 +----------
 4 files changed, 33 insertions(+), 12 deletions(-)
 create mode 100644 tests/ui/fn/invalid-sugg-for-unused-fn-arg-147303.rs
 create mode 100644 tests/ui/fn/invalid-sugg-for-unused-fn-arg-147303.stderr

diff --git a/compiler/rustc_passes/src/liveness.rs b/compiler/rustc_passes/src/liveness.rs
index 1b2ffb5b3db27..b628ff8a12dfd 100644
--- a/compiler/rustc_passes/src/liveness.rs
+++ b/compiler/rustc_passes/src/liveness.rs
@@ -1691,7 +1691,10 @@ impl<'tcx> Liveness<'_, 'tcx> {
                 if ln == self.exit_ln { false } else { self.assigned_on_exit(ln, var) };
 
             let mut typo = None;
-            for (hir_id, _, span) in &hir_ids_and_spans {
+            let filtered_hir_ids_and_spans = hir_ids_and_spans.iter().filter(|(hir_id, ..)| {
+                !matches!(self.ir.tcx.parent_hir_node(*hir_id), hir::Node::Param(_))
+            });
+            for (hir_id, _, span) in filtered_hir_ids_and_spans.clone() {
                 let ty = self.typeck_results.node_type(*hir_id);
                 if let ty::Adt(adt, _) = ty.peel_refs().kind() {
                     let name = Symbol::intern(&name);
@@ -1717,7 +1720,7 @@ impl<'tcx> Liveness<'_, 'tcx> {
                 }
             }
             if typo.is_none() {
-                for (hir_id, _, span) in &hir_ids_and_spans {
+                for (hir_id, _, span) in filtered_hir_ids_and_spans {
                     let ty = self.typeck_results.node_type(*hir_id);
                     // Look for consts of the same type with similar names as well, not just unit
                     // structs and variants.
diff --git a/tests/ui/fn/invalid-sugg-for-unused-fn-arg-147303.rs b/tests/ui/fn/invalid-sugg-for-unused-fn-arg-147303.rs
new file mode 100644
index 0000000000000..137ba8dc103e4
--- /dev/null
+++ b/tests/ui/fn/invalid-sugg-for-unused-fn-arg-147303.rs
@@ -0,0 +1,13 @@
+// Regression test for <https://github.com/rust-lang/rust/issues/147303>.
+
+#![deny(unused_assignments, unused_variables)]
+
+mod m1 {
+    const _MAX_FMTVER_X1X_EVENTNUM: i32 = 0;
+}
+
+mod m2 {
+    fn fun(rough: i32) {} //~ERROR unused variable
+}
+
+fn main() {}
diff --git a/tests/ui/fn/invalid-sugg-for-unused-fn-arg-147303.stderr b/tests/ui/fn/invalid-sugg-for-unused-fn-arg-147303.stderr
new file mode 100644
index 0000000000000..30e4a758c13ce
--- /dev/null
+++ b/tests/ui/fn/invalid-sugg-for-unused-fn-arg-147303.stderr
@@ -0,0 +1,14 @@
+error: unused variable: `rough`
+  --> $DIR/invalid-sugg-for-unused-fn-arg-147303.rs:10:12
+   |
+LL |     fn fun(rough: i32) {}
+   |            ^^^^^ help: if this is intentional, prefix it with an underscore: `_rough`
+   |
+note: the lint level is defined here
+  --> $DIR/invalid-sugg-for-unused-fn-arg-147303.rs:3:29
+   |
+LL | #![deny(unused_assignments, unused_variables)]
+   |                             ^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/lint/non-snake-case/lint-uppercase-variables.stderr b/tests/ui/lint/non-snake-case/lint-uppercase-variables.stderr
index e5f2e65fd91d3..5dec20b2ac7ea 100644
--- a/tests/ui/lint/non-snake-case/lint-uppercase-variables.stderr
+++ b/tests/ui/lint/non-snake-case/lint-uppercase-variables.stderr
@@ -58,16 +58,7 @@ warning: unused variable: `Foo`
   --> $DIR/lint-uppercase-variables.rs:33:17
    |
 LL |     fn in_param(Foo: foo::Foo) {}
-   |                 ^^^
-   |
-help: if this is intentional, prefix it with an underscore
-   |
-LL |     fn in_param(_Foo: foo::Foo) {}
-   |                 +
-help: you might have meant to pattern match on the similarly named variant `Foo`
-   |
-LL |     fn in_param(foo::Foo::Foo: foo::Foo) {}
-   |                 ++++++++++
+   |                 ^^^ help: if this is intentional, prefix it with an underscore: `_Foo`
 
 error: structure field `X` should have a snake case name
   --> $DIR/lint-uppercase-variables.rs:10:5

From ba42380142e73765eab501b3ebc2b3e05ee6b0c0 Mon Sep 17 00:00:00 2001
From: EFanZh <efanzh@gmail.com>
Date: Sat, 4 Oct 2025 17:16:00 +0800
Subject: [PATCH 1709/1889] Implement non-poisoning `Mutex::with_mut`,
 `RwLock::with` and `RwLock::with_mut`

ACP: https://github.com/rust-lang/libs-team/issues/497.
---
 library/std/src/sync/nonpoison/mutex.rs  | 34 +++++++++++++
 library/std/src/sync/nonpoison/rwlock.rs | 62 ++++++++++++++++++++++++
 library/std/tests/sync/mutex.rs          | 14 ++++++
 library/std/tests/sync/rwlock.rs         | 22 +++++++++
 4 files changed, 132 insertions(+)

diff --git a/library/std/src/sync/nonpoison/mutex.rs b/library/std/src/sync/nonpoison/mutex.rs
index eeecf5d710767..ed3f8cfed821a 100644
--- a/library/std/src/sync/nonpoison/mutex.rs
+++ b/library/std/src/sync/nonpoison/mutex.rs
@@ -376,6 +376,40 @@ impl<T: ?Sized> Mutex<T> {
     pub const fn data_ptr(&self) -> *mut T {
         self.data.get()
     }
+
+    /// Acquires the mutex and provides mutable access to the underlying data by passing
+    /// a mutable reference to the given closure.
+    ///
+    /// This method acquires the lock, calls the provided closure with a mutable reference
+    /// to the data, and returns the result of the closure. The lock is released after
+    /// the closure completes, even if it panics.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(lock_value_accessors, nonpoison_mutex)]
+    ///
+    /// use std::sync::nonpoison::Mutex;
+    ///
+    /// let mutex = Mutex::new(2);
+    ///
+    /// let result = mutex.with_mut(|data| {
+    ///     *data += 3;
+    ///
+    ///     *data + 5
+    /// });
+    ///
+    /// assert_eq!(*mutex.lock(), 5);
+    /// assert_eq!(result, 10);
+    /// ```
+    #[unstable(feature = "lock_value_accessors", issue = "133407")]
+    // #[unstable(feature = "nonpoison_mutex", issue = "134645")]
+    pub fn with_mut<F, R>(&self, f: F) -> R
+    where
+        F: FnOnce(&mut T) -> R,
+    {
+        f(&mut self.lock())
+    }
 }
 
 #[unstable(feature = "nonpoison_mutex", issue = "134645")]
diff --git a/library/std/src/sync/nonpoison/rwlock.rs b/library/std/src/sync/nonpoison/rwlock.rs
index b2f26edc083e9..568c7f3868470 100644
--- a/library/std/src/sync/nonpoison/rwlock.rs
+++ b/library/std/src/sync/nonpoison/rwlock.rs
@@ -498,6 +498,68 @@ impl<T: ?Sized> RwLock<T> {
     pub const fn data_ptr(&self) -> *mut T {
         self.data.get()
     }
+
+    /// Locks this `RwLock` with shared read access to the underlying data by passing
+    /// a reference to the given closure.
+    ///
+    /// This method acquires the lock, calls the provided closure with a reference
+    /// to the data, and returns the result of the closure. The lock is released after
+    /// the closure completes, even if it panics.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(lock_value_accessors, nonpoison_rwlock)]
+    ///
+    /// use std::sync::nonpoison::RwLock;
+    ///
+    /// let rwlock = RwLock::new(2);
+    /// let result = rwlock.with(|data| *data + 3);
+    ///
+    /// assert_eq!(result, 5);
+    /// ```
+    #[unstable(feature = "lock_value_accessors", issue = "133407")]
+    // #[unstable(feature = "nonpoison_rwlock", issue = "134645")]
+    pub fn with<F, R>(&self, f: F) -> R
+    where
+        F: FnOnce(&T) -> R,
+    {
+        f(&self.read())
+    }
+
+    /// Locks this `RwLock` with exclusive write access to the underlying data by passing
+    /// a mutable reference to the given closure.
+    ///
+    /// This method acquires the lock, calls the provided closure with a mutable reference
+    /// to the data, and returns the result of the closure. The lock is released after
+    /// the closure completes, even if it panics.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(lock_value_accessors, nonpoison_rwlock)]
+    ///
+    /// use std::sync::nonpoison::RwLock;
+    ///
+    /// let rwlock = RwLock::new(2);
+    ///
+    /// let result = rwlock.with_mut(|data| {
+    ///     *data += 3;
+    ///
+    ///     *data + 5
+    /// });
+    ///
+    /// assert_eq!(*rwlock.read(), 5);
+    /// assert_eq!(result, 10);
+    /// ```
+    #[unstable(feature = "lock_value_accessors", issue = "133407")]
+    // #[unstable(feature = "nonpoison_rwlock", issue = "134645")]
+    pub fn with_mut<F, R>(&self, f: F) -> R
+    where
+        F: FnOnce(&mut T) -> R,
+    {
+        f(&mut self.write())
+    }
 }
 
 #[unstable(feature = "nonpoison_rwlock", issue = "134645")]
diff --git a/library/std/tests/sync/mutex.rs b/library/std/tests/sync/mutex.rs
index 2445764001b8b..ff6aef717936f 100644
--- a/library/std/tests/sync/mutex.rs
+++ b/library/std/tests/sync/mutex.rs
@@ -549,3 +549,17 @@ fn panic_while_mapping_unlocked_poison() {
 
     drop(lock);
 }
+
+#[test]
+fn test_mutex_with_mut() {
+    let mutex = std::sync::nonpoison::Mutex::new(2);
+
+    let result = mutex.with_mut(|value| {
+        *value += 3;
+
+        *value + 5
+    });
+
+    assert_eq!(*mutex.lock(), 5);
+    assert_eq!(result, 10);
+}
diff --git a/library/std/tests/sync/rwlock.rs b/library/std/tests/sync/rwlock.rs
index 65d8bac719456..392c45c8ba05d 100644
--- a/library/std/tests/sync/rwlock.rs
+++ b/library/std/tests/sync/rwlock.rs
@@ -861,3 +861,25 @@ fn panic_while_mapping_write_unlocked_poison() {
 
     drop(lock);
 }
+
+#[test]
+fn test_rwlock_with() {
+    let rwlock = std::sync::nonpoison::RwLock::new(2);
+    let result = rwlock.with(|value| *value + 3);
+
+    assert_eq!(result, 5);
+}
+
+#[test]
+fn test_rwlock_with_mut() {
+    let rwlock = std::sync::nonpoison::RwLock::new(2);
+
+    let result = rwlock.with_mut(|value| {
+        *value += 3;
+
+        *value + 5
+    });
+
+    assert_eq!(*rwlock.read(), 5);
+    assert_eq!(result, 10);
+}

From 5c95f8bea6ea37d750910e5b0ac7ae049579e437 Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Thu, 2 Oct 2025 10:15:00 +0200
Subject: [PATCH 1710/1889] Add failing regression test for #[link="dl"]

---
 .../ui/attributes/link-dl.default_fcw.stderr  | 26 +++++++++++++++++++
 tests/ui/attributes/link-dl.rs                | 19 ++++++++++++++
 2 files changed, 45 insertions(+)
 create mode 100644 tests/ui/attributes/link-dl.default_fcw.stderr
 create mode 100644 tests/ui/attributes/link-dl.rs

diff --git a/tests/ui/attributes/link-dl.default_fcw.stderr b/tests/ui/attributes/link-dl.default_fcw.stderr
new file mode 100644
index 0000000000000..6bff216ad03f4
--- /dev/null
+++ b/tests/ui/attributes/link-dl.default_fcw.stderr
@@ -0,0 +1,26 @@
+error[E0539]: malformed `link` attribute input
+  --> $DIR/link-dl.rs:14:1
+   |
+LL | #[link="dl"]
+   | ^^^^^^^^^^^^ expected this to be a list
+   |
+   = note: for more information, visit <https://doc.rust-lang.org/reference/items/external-blocks.html#the-link-attribute>
+help: try changing it to one of the following valid forms of the attribute
+   |
+LL - #[link="dl"]
+LL + #[link(name = "...")]
+   |
+LL - #[link="dl"]
+LL + #[link(name = "...", import_name_type = "decorated|noprefix|undecorated")]
+   |
+LL - #[link="dl"]
+LL + #[link(name = "...", kind = "dylib|static|...")]
+   |
+LL - #[link="dl"]
+LL + #[link(name = "...", kind = "dylib|static|...", wasm_import_module = "...", import_name_type = "decorated|noprefix|undecorated")]
+   |
+   = and 1 other candidate
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0539`.
diff --git a/tests/ui/attributes/link-dl.rs b/tests/ui/attributes/link-dl.rs
new file mode 100644
index 0000000000000..0785c83cb442f
--- /dev/null
+++ b/tests/ui/attributes/link-dl.rs
@@ -0,0 +1,19 @@
+// Regression test for an issue discovered in https://github.com/rust-lang/rust/pull/143193/files and rediscovered in https://github.com/rust-lang/rust/issues/147254#event-20049906781
+// Malformed #[link] attribute was supposed to be deny-by-default report-in-deps FCW,
+// but accidentally was landed as a hard error.
+//
+// revision `default_fcw` tests that with `ill_formed_attribute_input` (the default) denied,
+// the attribute produces an FCW
+// revision `allowed` tests that with `ill_formed_attribute_input` allowed the test passes
+
+//@ revisions: default_fcw allowed
+//@[allowed] check-pass
+
+#[cfg_attr(allowed, allow(ill_formed_attribute_input))]
+
+#[link="dl"]
+//[default_fcw]~^ ERROR valid forms for the attribute are
+//[default_fcw]~| WARN previously accepted
+extern "C" { }
+
+fn main() {}

From 1c85a1dc2eaa2cbc55b5d0a6bbde1ca73706385d Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Thu, 2 Oct 2025 10:20:08 +0200
Subject: [PATCH 1711/1889] Make `#[link="dl"]` a warning rather than an error

---
 .../src/attributes/link_attrs.rs              | 29 ++++++++++-----
 compiler/rustc_span/src/symbol.rs             |  1 +
 tests/ui/attributes/link-dl.allowed.stderr    | 10 ++++++
 .../ui/attributes/link-dl.default_fcw.stderr  | 35 +++++++++----------
 4 files changed, 47 insertions(+), 28 deletions(-)
 create mode 100644 tests/ui/attributes/link-dl.allowed.stderr

diff --git a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
index d4942e56f429d..04eaa485f736c 100644
--- a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
@@ -65,10 +65,22 @@ impl<S: Stage> CombineAttributeParser<S> for LinkParser {
         cx: &'c mut AcceptContext<'_, '_, S>,
         args: &'c ArgParser<'_>,
     ) -> impl IntoIterator<Item = Self::Item> + 'c {
-        let mut result = None;
-        let Some(items) = args.list() else {
-            cx.expected_list(cx.attr_span);
-            return result;
+        let items = match args {
+            ArgParser::List(list) => list,
+            // This is an edgecase added because making this a hard error would break too many crates
+            // Specifically `#[link = "dl"]` is accepted with a FCW
+            // For more information, see https://github.com/rust-lang/rust/pull/143193
+            ArgParser::NameValue(nv) if nv.value_as_str().is_some_and(|v| v == sym::dl) => {
+                let suggestions = <Self as CombineAttributeParser<S>>::TEMPLATE
+                    .suggestions(cx.attr_style, "link");
+                let span = cx.attr_span;
+                cx.emit_lint(AttributeLintKind::IllFormedAttributeInput { suggestions }, span);
+                return None;
+            }
+            _ => {
+                cx.expected_list(cx.attr_span);
+                return None;
+            }
         };
 
         let sess = cx.sess();
@@ -113,7 +125,7 @@ impl<S: Stage> CombineAttributeParser<S> for LinkParser {
                 }
             };
             if !cont {
-                return result;
+                return None;
             }
         }
 
@@ -202,7 +214,7 @@ impl<S: Stage> CombineAttributeParser<S> for LinkParser {
         }
         let Some((name, name_span)) = name else {
             cx.emit_err(LinkRequiresName { span: cx.attr_span });
-            return result;
+            return None;
         };
 
         // Do this outside of the loop so that `import_name_type` can be specified before `kind`.
@@ -218,15 +230,14 @@ impl<S: Stage> CombineAttributeParser<S> for LinkParser {
             cx.emit_err(RawDylibNoNul { span: name_span });
         }
 
-        result = Some(LinkEntry {
+        Some(LinkEntry {
             span: cx.attr_span,
             kind: kind.unwrap_or(NativeLibKind::Unspecified),
             name,
             cfg,
             verbatim,
             import_name_type,
-        });
-        result
+        })
     }
 }
 
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index b34a64108e3b4..20cdd79c34707 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -873,6 +873,7 @@ symbols! {
         div,
         div_assign,
         diverging_block_default,
+        dl,
         do_not_recommend,
         doc,
         doc_alias,
diff --git a/tests/ui/attributes/link-dl.allowed.stderr b/tests/ui/attributes/link-dl.allowed.stderr
new file mode 100644
index 0000000000000..e0070d970595f
--- /dev/null
+++ b/tests/ui/attributes/link-dl.allowed.stderr
@@ -0,0 +1,10 @@
+Future incompatibility report: Future breakage diagnostic:
+warning: valid forms for the attribute are `#[link(name = "...")]`, `#[link(name = "...", import_name_type = "decorated|noprefix|undecorated")]`, `#[link(name = "...", kind = "dylib|static|...")]`, `#[link(name = "...", kind = "dylib|static|...", wasm_import_module = "...", import_name_type = "decorated|noprefix|undecorated")]`, and `#[link(name = "...", wasm_import_module = "...")]`
+  --> $DIR/link-dl.rs:14:1
+   |
+LL | #[link="dl"]
+   | ^^^^^^^^^^^^
+   |
+   = 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 #57571 <https://github.com/rust-lang/rust/issues/57571>
+
diff --git a/tests/ui/attributes/link-dl.default_fcw.stderr b/tests/ui/attributes/link-dl.default_fcw.stderr
index 6bff216ad03f4..249895fd17d00 100644
--- a/tests/ui/attributes/link-dl.default_fcw.stderr
+++ b/tests/ui/attributes/link-dl.default_fcw.stderr
@@ -1,26 +1,23 @@
-error[E0539]: malformed `link` attribute input
+error: valid forms for the attribute are `#[link(name = "...")]`, `#[link(name = "...", import_name_type = "decorated|noprefix|undecorated")]`, `#[link(name = "...", kind = "dylib|static|...")]`, `#[link(name = "...", kind = "dylib|static|...", wasm_import_module = "...", import_name_type = "decorated|noprefix|undecorated")]`, and `#[link(name = "...", wasm_import_module = "...")]`
   --> $DIR/link-dl.rs:14:1
    |
 LL | #[link="dl"]
-   | ^^^^^^^^^^^^ expected this to be a list
+   | ^^^^^^^^^^^^
    |
-   = note: for more information, visit <https://doc.rust-lang.org/reference/items/external-blocks.html#the-link-attribute>
-help: try changing it to one of the following valid forms of the attribute
-   |
-LL - #[link="dl"]
-LL + #[link(name = "...")]
-   |
-LL - #[link="dl"]
-LL + #[link(name = "...", import_name_type = "decorated|noprefix|undecorated")]
-   |
-LL - #[link="dl"]
-LL + #[link(name = "...", kind = "dylib|static|...")]
-   |
-LL - #[link="dl"]
-LL + #[link(name = "...", kind = "dylib|static|...", wasm_import_module = "...", import_name_type = "decorated|noprefix|undecorated")]
-   |
-   = and 1 other candidate
+   = 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 #57571 <https://github.com/rust-lang/rust/issues/57571>
+   = note: `#[deny(ill_formed_attribute_input)]` (part of `#[deny(future_incompatible)]`) on by default
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0539`.
+Future incompatibility report: Future breakage diagnostic:
+error: valid forms for the attribute are `#[link(name = "...")]`, `#[link(name = "...", import_name_type = "decorated|noprefix|undecorated")]`, `#[link(name = "...", kind = "dylib|static|...")]`, `#[link(name = "...", kind = "dylib|static|...", wasm_import_module = "...", import_name_type = "decorated|noprefix|undecorated")]`, and `#[link(name = "...", wasm_import_module = "...")]`
+  --> $DIR/link-dl.rs:14:1
+   |
+LL | #[link="dl"]
+   | ^^^^^^^^^^^^
+   |
+   = 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 #57571 <https://github.com/rust-lang/rust/issues/57571>
+   = note: `#[deny(ill_formed_attribute_input)]` (part of `#[deny(future_incompatible)]`) on by default
+

From 24befed7279ae8be1c52e698172c1366e41e06b1 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Fri, 3 Oct 2025 22:56:05 +0200
Subject: [PATCH 1712/1889] clean-up

- inline `array_span_lint`
- use `match` instead of `if-let`
- give a more descriptive help message
---
 clippy_lints/src/zero_repeat_side_effects.rs | 104 ++++++-------------
 tests/ui/zero_repeat_side_effects.fixed      |   4 +-
 tests/ui/zero_repeat_side_effects.rs         |   4 +-
 tests/ui/zero_repeat_side_effects.stderr     |  89 ++++++++++++----
 4 files changed, 105 insertions(+), 96 deletions(-)

diff --git a/clippy_lints/src/zero_repeat_side_effects.rs b/clippy_lints/src/zero_repeat_side_effects.rs
index 30fdf22fdbb09..e51c4a6898164 100644
--- a/clippy_lints/src/zero_repeat_side_effects.rs
+++ b/clippy_lints/src/zero_repeat_side_effects.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::VecArgs;
 use clippy_utils::source::snippet;
 use clippy_utils::visitors::for_each_expr_without_closures;
@@ -7,9 +7,7 @@ use rustc_data_structures::packed::Pu128;
 use rustc_errors::Applicability;
 use rustc_hir::{ConstArgKind, ExprKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::Ty;
 use rustc_session::declare_lint_pass;
-use rustc_span::Span;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -85,77 +83,39 @@ fn inner_check(cx: &LateContext<'_>, expr: &'_ rustc_hir::Expr<'_>, inner_expr:
         let parent_hir_node = cx.tcx.parent_hir_node(expr.hir_id);
         let return_type = cx.typeck_results().expr_ty(expr);
 
-        if let Node::LetStmt(l) = parent_hir_node {
-            array_span_lint(
-                cx,
+        let inner_expr = snippet(cx, inner_expr.span.source_callsite(), "..");
+        let vec = if is_vec { "vec!" } else { "" };
+
+        let (span, sugg) = match parent_hir_node {
+            Node::LetStmt(l) => (
                 l.span,
-                inner_expr.span,
-                l.pat.span,
-                Some(return_type),
-                is_vec,
-                false,
-            );
-        } else if let Node::Expr(x) = parent_hir_node
-            && let ExprKind::Assign(l, _, _) = x.kind
-        {
-            array_span_lint(cx, x.span, inner_expr.span, l.span, Some(return_type), is_vec, true);
-        } else {
-            span_lint_and_sugg(
-                cx,
-                ZERO_REPEAT_SIDE_EFFECTS,
-                expr.span.source_callsite(),
-                "function or method calls as the initial value in zero-sized array initializers may cause side effects",
-                "consider using",
                 format!(
-                    "{{ {}; {}[] as {return_type} }}",
-                    snippet(cx, inner_expr.span.source_callsite(), ".."),
-                    if is_vec { "vec!" } else { "" },
+                    "{inner_expr}; let {var_name}: {return_type} = {vec}[];",
+                    var_name = snippet(cx, l.pat.span.source_callsite(), "..")
                 ),
-                Applicability::Unspecified,
-            );
-        }
-    }
-}
-
-fn array_span_lint(
-    cx: &LateContext<'_>,
-    expr_span: Span,
-    func_call_span: Span,
-    variable_name_span: Span,
-    expr_ty: Option<Ty<'_>>,
-    is_vec: bool,
-    is_assign: bool,
-) {
-    let has_ty = expr_ty.is_some();
-
-    span_lint_and_sugg(
-        cx,
-        ZERO_REPEAT_SIDE_EFFECTS,
-        expr_span.source_callsite(),
-        "function or method calls as the initial value in zero-sized array initializers may cause side effects",
-        "consider using",
-        format!(
-            "{}; {}{}{} = {}[]{}{}",
-            snippet(cx, func_call_span.source_callsite(), ".."),
-            if has_ty && !is_assign { "let " } else { "" },
-            snippet(cx, variable_name_span.source_callsite(), ".."),
-            if let Some(ty) = expr_ty
-                && !is_assign
-            {
-                format!(": {ty}")
-            } else {
-                String::new()
-            },
-            if is_vec { "vec!" } else { "" },
-            if let Some(ty) = expr_ty
-                && is_assign
-            {
-                format!(" as {ty}")
-            } else {
-                String::new()
+            ),
+            Node::Expr(x) if let ExprKind::Assign(l, _, _) = x.kind => (
+                x.span,
+                format!(
+                    "{inner_expr}; {var_name} = {vec}[] as {return_type}",
+                    var_name = snippet(cx, l.span.source_callsite(), "..")
+                ),
+            ),
+            _ => (expr.span, format!("{{ {inner_expr}; {vec}[] as {return_type} }}")),
+        };
+        span_lint_and_then(
+            cx,
+            ZERO_REPEAT_SIDE_EFFECTS,
+            span.source_callsite(),
+            "function or method calls as the initial value in zero-sized array initializers may cause side effects",
+            |diag| {
+                diag.span_suggestion_verbose(
+                    span.source_callsite(),
+                    "consider performing the side effect separately",
+                    sugg,
+                    Applicability::Unspecified,
+                );
             },
-            if is_assign { "" } else { ";" }
-        ),
-        Applicability::Unspecified,
-    );
+        );
+    }
 }
diff --git a/tests/ui/zero_repeat_side_effects.fixed b/tests/ui/zero_repeat_side_effects.fixed
index fb9d7880a4a7f..5184249e942d9 100644
--- a/tests/ui/zero_repeat_side_effects.fixed
+++ b/tests/ui/zero_repeat_side_effects.fixed
@@ -1,7 +1,5 @@
 #![warn(clippy::zero_repeat_side_effects)]
-#![allow(clippy::unnecessary_operation)]
-#![allow(clippy::useless_vec)]
-#![allow(clippy::needless_late_init)]
+#![expect(clippy::unnecessary_operation, clippy::useless_vec, clippy::needless_late_init)]
 
 fn f() -> i32 {
     println!("side effect");
diff --git a/tests/ui/zero_repeat_side_effects.rs b/tests/ui/zero_repeat_side_effects.rs
index 8b22ff840244e..9c6e758f2e28c 100644
--- a/tests/ui/zero_repeat_side_effects.rs
+++ b/tests/ui/zero_repeat_side_effects.rs
@@ -1,7 +1,5 @@
 #![warn(clippy::zero_repeat_side_effects)]
-#![allow(clippy::unnecessary_operation)]
-#![allow(clippy::useless_vec)]
-#![allow(clippy::needless_late_init)]
+#![expect(clippy::unnecessary_operation, clippy::useless_vec, clippy::needless_late_init)]
 
 fn f() -> i32 {
     println!("side effect");
diff --git a/tests/ui/zero_repeat_side_effects.stderr b/tests/ui/zero_repeat_side_effects.stderr
index 2dba52e2112ec..dc99110932d89 100644
--- a/tests/ui/zero_repeat_side_effects.stderr
+++ b/tests/ui/zero_repeat_side_effects.stderr
@@ -1,59 +1,112 @@
 error: function or method calls as the initial value in zero-sized array initializers may cause side effects
-  --> tests/ui/zero_repeat_side_effects.rs:18:5
+  --> tests/ui/zero_repeat_side_effects.rs:16:5
    |
 LL |     let a = [f(); 0];
-   |     ^^^^^^^^^^^^^^^^^ help: consider using: `f(); let a: [i32; 0] = [];`
+   |     ^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::zero-repeat-side-effects` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::zero_repeat_side_effects)]`
+help: consider performing the side effect separately
+   |
+LL -     let a = [f(); 0];
+LL +     f(); let a: [i32; 0] = [];
+   |
 
 error: function or method calls as the initial value in zero-sized array initializers may cause side effects
-  --> tests/ui/zero_repeat_side_effects.rs:21:5
+  --> tests/ui/zero_repeat_side_effects.rs:19:5
    |
 LL |     b = [f(); 0];
-   |     ^^^^^^^^^^^^ help: consider using: `f(); b = [] as [i32; 0]`
+   |     ^^^^^^^^^^^^
+   |
+help: consider performing the side effect separately
+   |
+LL -     b = [f(); 0];
+LL +     f(); b = [] as [i32; 0];
+   |
 
 error: function or method calls as the initial value in zero-sized array initializers may cause side effects
-  --> tests/ui/zero_repeat_side_effects.rs:26:5
+  --> tests/ui/zero_repeat_side_effects.rs:24:5
    |
 LL |     let c = vec![f(); 0];
-   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f(); let c: std::vec::Vec<i32> = vec![];`
+   |     ^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider performing the side effect separately
+   |
+LL -     let c = vec![f(); 0];
+LL +     f(); let c: std::vec::Vec<i32> = vec![];
+   |
 
 error: function or method calls as the initial value in zero-sized array initializers may cause side effects
-  --> tests/ui/zero_repeat_side_effects.rs:29:5
+  --> tests/ui/zero_repeat_side_effects.rs:27:5
    |
 LL |     d = vec![f(); 0];
-   |     ^^^^^^^^^^^^^^^^ help: consider using: `f(); d = vec![] as std::vec::Vec<i32>`
+   |     ^^^^^^^^^^^^^^^^
+   |
+help: consider performing the side effect separately
+   |
+LL -     d = vec![f(); 0];
+LL +     f(); d = vec![] as std::vec::Vec<i32>;
+   |
 
 error: function or method calls as the initial value in zero-sized array initializers may cause side effects
-  --> tests/ui/zero_repeat_side_effects.rs:33:5
+  --> tests/ui/zero_repeat_side_effects.rs:31:5
    |
 LL |     let e = [println!("side effect"); 0];
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `println!("side effect"); let e: [(); 0] = [];`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider performing the side effect separately
+   |
+LL -     let e = [println!("side effect"); 0];
+LL +     println!("side effect"); let e: [(); 0] = [];
+   |
 
 error: function or method calls as the initial value in zero-sized array initializers may cause side effects
-  --> tests/ui/zero_repeat_side_effects.rs:37:5
+  --> tests/ui/zero_repeat_side_effects.rs:35:5
    |
 LL |     let g = [{ f() }; 0];
-   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `{ f() }; let g: [i32; 0] = [];`
+   |     ^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider performing the side effect separately
+   |
+LL -     let g = [{ f() }; 0];
+LL +     { f() }; let g: [i32; 0] = [];
+   |
 
 error: function or method calls as the initial value in zero-sized array initializers may cause side effects
-  --> tests/ui/zero_repeat_side_effects.rs:41:10
+  --> tests/ui/zero_repeat_side_effects.rs:39:10
    |
 LL |     drop(vec![f(); 0]);
-   |          ^^^^^^^^^^^^ help: consider using: `{ f(); vec![] as std::vec::Vec<i32> }`
+   |          ^^^^^^^^^^^^
+   |
+help: consider performing the side effect separately
+   |
+LL -     drop(vec![f(); 0]);
+LL +     drop({ f(); vec![] as std::vec::Vec<i32> });
+   |
 
 error: function or method calls as the initial value in zero-sized array initializers may cause side effects
-  --> tests/ui/zero_repeat_side_effects.rs:45:5
+  --> tests/ui/zero_repeat_side_effects.rs:43:5
    |
 LL |     vec![f(); 0];
-   |     ^^^^^^^^^^^^ help: consider using: `{ f(); vec![] as std::vec::Vec<i32> }`
+   |     ^^^^^^^^^^^^
+   |
+help: consider performing the side effect separately
+   |
+LL -     vec![f(); 0];
+LL +     { f(); vec![] as std::vec::Vec<i32> };
+   |
 
 error: function or method calls as the initial value in zero-sized array initializers may cause side effects
-  --> tests/ui/zero_repeat_side_effects.rs:47:5
+  --> tests/ui/zero_repeat_side_effects.rs:45:5
    |
 LL |     [f(); 0];
-   |     ^^^^^^^^ help: consider using: `{ f(); [] as [i32; 0] }`
+   |     ^^^^^^^^
+   |
+help: consider performing the side effect separately
+   |
+LL -     [f(); 0];
+LL +     { f(); [] as [i32; 0] };
+   |
 
 error: aborting due to 9 previous errors
 

From adff9baeb3d16c5d9de8146a6d67f3b276429762 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sat, 4 Oct 2025 00:10:12 +0200
Subject: [PATCH 1713/1889] fix(zero_repeat_side_effects): better identify
 exprs with side effects

---
 clippy_lints/src/zero_repeat_side_effects.rs | 15 ++-----
 tests/ui/zero_repeat_side_effects.fixed      | 24 +++++++++++
 tests/ui/zero_repeat_side_effects.rs         | 24 +++++++++++
 tests/ui/zero_repeat_side_effects.stderr     | 44 +++++++++++++++-----
 4 files changed, 85 insertions(+), 22 deletions(-)

diff --git a/clippy_lints/src/zero_repeat_side_effects.rs b/clippy_lints/src/zero_repeat_side_effects.rs
index e51c4a6898164..cd6c11b512742 100644
--- a/clippy_lints/src/zero_repeat_side_effects.rs
+++ b/clippy_lints/src/zero_repeat_side_effects.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::VecArgs;
 use clippy_utils::source::snippet;
-use clippy_utils::visitors::for_each_expr_without_closures;
 use rustc_ast::LitKind;
 use rustc_data_structures::packed::Pu128;
 use rustc_errors::Applicability;
@@ -11,7 +10,7 @@ use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for array or vec initializations which call a function or method,
+    /// Checks for array or vec initializations which contain an expression with side effects,
     /// but which have a repeat count of zero.
     ///
     /// ### Why is this bad?
@@ -71,15 +70,7 @@ impl LateLintPass<'_> for ZeroRepeatSideEffects {
 
 fn inner_check(cx: &LateContext<'_>, expr: &'_ rustc_hir::Expr<'_>, inner_expr: &'_ rustc_hir::Expr<'_>, is_vec: bool) {
     // check if expr is a call or has a call inside it
-    if for_each_expr_without_closures(inner_expr, |x| {
-        if let ExprKind::Call(_, _) | ExprKind::MethodCall(_, _, _, _) = x.kind {
-            std::ops::ControlFlow::Break(())
-        } else {
-            std::ops::ControlFlow::Continue(())
-        }
-    })
-    .is_some()
-    {
+    if inner_expr.can_have_side_effects() {
         let parent_hir_node = cx.tcx.parent_hir_node(expr.hir_id);
         let return_type = cx.typeck_results().expr_ty(expr);
 
@@ -107,7 +98,7 @@ fn inner_check(cx: &LateContext<'_>, expr: &'_ rustc_hir::Expr<'_>, inner_expr:
             cx,
             ZERO_REPEAT_SIDE_EFFECTS,
             span.source_callsite(),
-            "function or method calls as the initial value in zero-sized array initializers may cause side effects",
+            "expression with side effects as the initial value in a zero-sized array initializer",
             |diag| {
                 diag.span_suggestion_verbose(
                     span.source_callsite(),
diff --git a/tests/ui/zero_repeat_side_effects.fixed b/tests/ui/zero_repeat_side_effects.fixed
index 5184249e942d9..e6c451ce7399e 100644
--- a/tests/ui/zero_repeat_side_effects.fixed
+++ b/tests/ui/zero_repeat_side_effects.fixed
@@ -77,3 +77,27 @@ fn issue_13110() {
     const LENGTH: usize = LEN!();
     let _data = [f(); LENGTH];
 }
+
+// TODO: consider moving the defintion+impl inside `issue_14681`
+// once https://github.com/rust-lang/rust/issues/146786 is fixed
+#[derive(Clone, Copy)]
+struct S;
+
+impl S {
+    fn new() -> Self {
+        println!("This is a side effect");
+        S
+    }
+}
+
+// should not trigger on non-function calls
+fn issue_14681() {
+    fn foo<T>(_s: &[Option<T>]) {}
+
+    foo(&[Some(0i64); 0]);
+    foo(&[Some(Some(0i64)); 0]);
+    foo(&{ Some(f()); [] as [std::option::Option<i32>; 0] });
+    //~^ zero_repeat_side_effects
+    foo(&{ Some(Some(S::new())); [] as [std::option::Option<std::option::Option<S>>; 0] });
+    //~^ zero_repeat_side_effects
+}
diff --git a/tests/ui/zero_repeat_side_effects.rs b/tests/ui/zero_repeat_side_effects.rs
index 9c6e758f2e28c..f8a497976aa43 100644
--- a/tests/ui/zero_repeat_side_effects.rs
+++ b/tests/ui/zero_repeat_side_effects.rs
@@ -77,3 +77,27 @@ fn issue_13110() {
     const LENGTH: usize = LEN!();
     let _data = [f(); LENGTH];
 }
+
+// TODO: consider moving the defintion+impl inside `issue_14681`
+// once https://github.com/rust-lang/rust/issues/146786 is fixed
+#[derive(Clone, Copy)]
+struct S;
+
+impl S {
+    fn new() -> Self {
+        println!("This is a side effect");
+        S
+    }
+}
+
+// should not trigger on non-function calls
+fn issue_14681() {
+    fn foo<T>(_s: &[Option<T>]) {}
+
+    foo(&[Some(0i64); 0]);
+    foo(&[Some(Some(0i64)); 0]);
+    foo(&[Some(f()); 0]);
+    //~^ zero_repeat_side_effects
+    foo(&[Some(Some(S::new())); 0]);
+    //~^ zero_repeat_side_effects
+}
diff --git a/tests/ui/zero_repeat_side_effects.stderr b/tests/ui/zero_repeat_side_effects.stderr
index dc99110932d89..771b71c686ae4 100644
--- a/tests/ui/zero_repeat_side_effects.stderr
+++ b/tests/ui/zero_repeat_side_effects.stderr
@@ -1,4 +1,4 @@
-error: function or method calls as the initial value in zero-sized array initializers may cause side effects
+error: expression with side effects as the initial value in a zero-sized array initializer
   --> tests/ui/zero_repeat_side_effects.rs:16:5
    |
 LL |     let a = [f(); 0];
@@ -12,7 +12,7 @@ LL -     let a = [f(); 0];
 LL +     f(); let a: [i32; 0] = [];
    |
 
-error: function or method calls as the initial value in zero-sized array initializers may cause side effects
+error: expression with side effects as the initial value in a zero-sized array initializer
   --> tests/ui/zero_repeat_side_effects.rs:19:5
    |
 LL |     b = [f(); 0];
@@ -24,7 +24,7 @@ LL -     b = [f(); 0];
 LL +     f(); b = [] as [i32; 0];
    |
 
-error: function or method calls as the initial value in zero-sized array initializers may cause side effects
+error: expression with side effects as the initial value in a zero-sized array initializer
   --> tests/ui/zero_repeat_side_effects.rs:24:5
    |
 LL |     let c = vec![f(); 0];
@@ -36,7 +36,7 @@ LL -     let c = vec![f(); 0];
 LL +     f(); let c: std::vec::Vec<i32> = vec![];
    |
 
-error: function or method calls as the initial value in zero-sized array initializers may cause side effects
+error: expression with side effects as the initial value in a zero-sized array initializer
   --> tests/ui/zero_repeat_side_effects.rs:27:5
    |
 LL |     d = vec![f(); 0];
@@ -48,7 +48,7 @@ LL -     d = vec![f(); 0];
 LL +     f(); d = vec![] as std::vec::Vec<i32>;
    |
 
-error: function or method calls as the initial value in zero-sized array initializers may cause side effects
+error: expression with side effects as the initial value in a zero-sized array initializer
   --> tests/ui/zero_repeat_side_effects.rs:31:5
    |
 LL |     let e = [println!("side effect"); 0];
@@ -60,7 +60,7 @@ LL -     let e = [println!("side effect"); 0];
 LL +     println!("side effect"); let e: [(); 0] = [];
    |
 
-error: function or method calls as the initial value in zero-sized array initializers may cause side effects
+error: expression with side effects as the initial value in a zero-sized array initializer
   --> tests/ui/zero_repeat_side_effects.rs:35:5
    |
 LL |     let g = [{ f() }; 0];
@@ -72,7 +72,7 @@ LL -     let g = [{ f() }; 0];
 LL +     { f() }; let g: [i32; 0] = [];
    |
 
-error: function or method calls as the initial value in zero-sized array initializers may cause side effects
+error: expression with side effects as the initial value in a zero-sized array initializer
   --> tests/ui/zero_repeat_side_effects.rs:39:10
    |
 LL |     drop(vec![f(); 0]);
@@ -84,7 +84,7 @@ LL -     drop(vec![f(); 0]);
 LL +     drop({ f(); vec![] as std::vec::Vec<i32> });
    |
 
-error: function or method calls as the initial value in zero-sized array initializers may cause side effects
+error: expression with side effects as the initial value in a zero-sized array initializer
   --> tests/ui/zero_repeat_side_effects.rs:43:5
    |
 LL |     vec![f(); 0];
@@ -96,7 +96,7 @@ LL -     vec![f(); 0];
 LL +     { f(); vec![] as std::vec::Vec<i32> };
    |
 
-error: function or method calls as the initial value in zero-sized array initializers may cause side effects
+error: expression with side effects as the initial value in a zero-sized array initializer
   --> tests/ui/zero_repeat_side_effects.rs:45:5
    |
 LL |     [f(); 0];
@@ -108,5 +108,29 @@ LL -     [f(); 0];
 LL +     { f(); [] as [i32; 0] };
    |
 
-error: aborting due to 9 previous errors
+error: expression with side effects as the initial value in a zero-sized array initializer
+  --> tests/ui/zero_repeat_side_effects.rs:99:10
+   |
+LL |     foo(&[Some(f()); 0]);
+   |          ^^^^^^^^^^^^^^
+   |
+help: consider performing the side effect separately
+   |
+LL -     foo(&[Some(f()); 0]);
+LL +     foo(&{ Some(f()); [] as [std::option::Option<i32>; 0] });
+   |
+
+error: expression with side effects as the initial value in a zero-sized array initializer
+  --> tests/ui/zero_repeat_side_effects.rs:101:10
+   |
+LL |     foo(&[Some(Some(S::new())); 0]);
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider performing the side effect separately
+   |
+LL -     foo(&[Some(Some(S::new())); 0]);
+LL +     foo(&{ Some(Some(S::new())); [] as [std::option::Option<std::option::Option<S>>; 0] });
+   |
+
+error: aborting due to 11 previous errors
 

From 2688f601ddc29b75caa2c48a4badc00d15042d7a Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Sat, 4 Oct 2025 16:07:06 +0200
Subject: [PATCH 1714/1889] Make `fmt::Write` a diagnostic item

---
 compiler/rustc_span/src/symbol.rs | 1 +
 library/core/src/fmt/mod.rs       | 1 +
 2 files changed, 2 insertions(+)

diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index b34a64108e3b4..083e04730bc37 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -236,6 +236,7 @@ symbols! {
         File,
         FileType,
         FmtArgumentsNew,
+        FmtWrite,
         Fn,
         FnMut,
         FnOnce,
diff --git a/library/core/src/fmt/mod.rs b/library/core/src/fmt/mod.rs
index fcd2e52101ff0..0f255e57fe585 100644
--- a/library/core/src/fmt/mod.rs
+++ b/library/core/src/fmt/mod.rs
@@ -115,6 +115,7 @@ pub struct Error;
 /// [`std::io::Write`]: ../../std/io/trait.Write.html
 /// [flushable]: ../../std/io/trait.Write.html#tymethod.flush
 #[stable(feature = "rust1", since = "1.0.0")]
+#[rustc_diagnostic_item = "FmtWrite"]
 pub trait Write {
     /// Writes a string slice into this writer, returning whether the write
     /// succeeded.

From b4578775b471b723b2210a838d6a8521f45de1db Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Sat, 4 Oct 2025 10:22:41 -0400
Subject: [PATCH 1715/1889] Update cargo submodule

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

diff --git a/src/tools/cargo b/src/tools/cargo
index 2394ea6cea8b2..801d9b4981dd0 160000
--- a/src/tools/cargo
+++ b/src/tools/cargo
@@ -1 +1 @@
-Subproject commit 2394ea6cea8b26d717aa67eb1663a2dbf2d26078
+Subproject commit 801d9b4981dd07e3aecdca1ab86834c13615737e

From 3d351c839dcb045adcc91372f78f0f0cbaf81033 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 23 Aug 2025 09:45:53 -0400
Subject: [PATCH 1716/1889] Const eval changes: * Remove `CoreConstant`. *
 Treat most constants from core as though they were inlined. * Don't evaluate
 `is_empty` for named constants.

---
 clippy_lints/src/enum_clike.rs                |   8 +-
 clippy_lints/src/floating_point_arithmetic.rs |   2 +-
 clippy_lints/src/manual_float_methods.rs      |   4 +-
 clippy_lints/src/matches/overlapping_arms.rs  |   6 +-
 .../src/methods/unnecessary_min_or_max.rs     |   6 +-
 clippy_lints/src/minmax.rs                    |   4 +-
 .../src/operators/const_comparisons.rs        |   2 +-
 clippy_lints/src/operators/float_cmp.rs       |   2 +-
 clippy_lints/src/ranges.rs                    |   6 +-
 clippy_utils/src/consts.rs                    | 485 ++++++++++++------
 clippy_utils/src/lib.rs                       |  10 +-
 clippy_utils/src/paths.rs                     |  18 +-
 clippy_utils/src/sym.rs                       |   1 +
 tests/ui/const_comparisons.rs                 |  14 +-
 tests/ui/const_comparisons.stderr             |  62 +--
 tests/ui/const_is_empty.rs                    |  50 +-
 tests/ui/const_is_empty.stderr                | 108 +---
 17 files changed, 395 insertions(+), 393 deletions(-)

diff --git a/clippy_lints/src/enum_clike.rs b/clippy_lints/src/enum_clike.rs
index c828fc57f7601..1a56c8f810ee7 100644
--- a/clippy_lints/src/enum_clike.rs
+++ b/clippy_lints/src/enum_clike.rs
@@ -43,12 +43,8 @@ impl<'tcx> LateLintPass<'tcx> for UnportableVariant {
                 if let Some(anon_const) = &var.disr_expr {
                     let def_id = cx.tcx.hir_body_owner_def_id(anon_const.body);
                     let mut ty = cx.tcx.type_of(def_id.to_def_id()).instantiate_identity();
-                    let constant = cx
-                        .tcx
-                        .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.tcx, c)) {
+                    let constant = cx.tcx.const_eval_poly(def_id.to_def_id()).ok();
+                    if let Some(Constant::Int(val)) = constant.and_then(|c| mir_to_const(cx.tcx, c, ty)) {
                         if let ty::Adt(adt, _) = ty.kind()
                             && adt.is_enum()
                         {
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 5052bbb3ca033..3ecc232caff43 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -206,7 +206,7 @@ fn check_ln1p(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>) {
 // ranges [-16777215, 16777216) for type f32 as whole number floats outside
 // this range are lossy and ambiguous.
 #[expect(clippy::cast_possible_truncation)]
-fn get_integer_from_float_constant(value: &Constant<'_>) -> Option<i32> {
+fn get_integer_from_float_constant(value: &Constant) -> Option<i32> {
     match value {
         F32(num) if num.fract() == 0.0 => {
             if (-16_777_215.0..16_777_216.0).contains(num) {
diff --git a/clippy_lints/src/manual_float_methods.rs b/clippy_lints/src/manual_float_methods.rs
index bd2785fea2709..7d6c30aa74ddd 100644
--- a/clippy_lints/src/manual_float_methods.rs
+++ b/clippy_lints/src/manual_float_methods.rs
@@ -202,7 +202,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualFloatMethods {
     }
 }
 
-fn is_infinity(constant: &Constant<'_>) -> bool {
+fn is_infinity(constant: &Constant) -> bool {
     match constant {
         // FIXME(f16_f128): add f16 and f128 when constants are available
         Constant::F32(float) => *float == f32::INFINITY,
@@ -211,7 +211,7 @@ fn is_infinity(constant: &Constant<'_>) -> bool {
     }
 }
 
-fn is_neg_infinity(constant: &Constant<'_>) -> bool {
+fn is_neg_infinity(constant: &Constant) -> bool {
     match constant {
         // FIXME(f16_f128): add f16 and f128 when constants are available
         Constant::F32(float) => *float == f32::NEG_INFINITY,
diff --git a/clippy_lints/src/matches/overlapping_arms.rs b/clippy_lints/src/matches/overlapping_arms.rs
index d3136c89178e6..d76218e6305b0 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::{ConstEvalCtxt, FullInt, mir_to_const};
+use clippy_utils::consts::{ConstEvalCtxt, Constant, FullInt};
 use clippy_utils::diagnostics::span_lint_and_note;
 use core::cmp::Ordering;
 use rustc_hir::{Arm, Expr, PatKind, RangeEnd};
@@ -35,12 +35,12 @@ fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>)
                     let lhs_const = if let Some(lhs) = lhs {
                         ConstEvalCtxt::new(cx).eval_pat_expr(lhs)?
                     } else {
-                        mir_to_const(cx.tcx, ty.numeric_min_val(cx.tcx)?)?
+                        Constant::new_numeric_min(cx.tcx, ty)?
                     };
                     let rhs_const = if let Some(rhs) = rhs {
                         ConstEvalCtxt::new(cx).eval_pat_expr(rhs)?
                     } else {
-                        mir_to_const(cx.tcx, ty.numeric_max_val(cx.tcx)?)?
+                        Constant::new_numeric_max(cx.tcx, ty)?
                     };
                     let lhs_val = lhs_const.int_value(cx.tcx, ty)?;
                     let rhs_val = rhs_const.int_value(cx.tcx, ty)?;
diff --git a/clippy_lints/src/methods/unnecessary_min_or_max.rs b/clippy_lints/src/methods/unnecessary_min_or_max.rs
index 130e4970a7163..bf91a469e7f01 100644
--- a/clippy_lints/src/methods/unnecessary_min_or_max.rs
+++ b/clippy_lints/src/methods/unnecessary_min_or_max.rs
@@ -1,7 +1,7 @@
 use std::cmp::Ordering;
 
 use super::UNNECESSARY_MIN_OR_MAX;
-use clippy_utils::consts::{ConstEvalCtxt, Constant, ConstantSource, FullInt};
+use clippy_utils::consts::{ConstEvalCtxt, Constant, FullInt};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 
@@ -26,8 +26,8 @@ pub(super) fn check<'tcx>(
         && matches!(fn_name, sym::cmp_ord_min | sym::cmp_ord_max)
     {
         let ctxt = expr.span.ctxt();
-        if let Some((left, ConstantSource::Local | ConstantSource::CoreConstant)) = ecx.eval_with_source(recv, ctxt)
-            && let Some((right, ConstantSource::Local | ConstantSource::CoreConstant)) = ecx.eval_with_source(arg, ctxt)
+        if let Some(left) = ecx.eval_local(recv, ctxt)
+            && let Some(right) = ecx.eval_local(arg, ctxt)
         {
             let Some(ord) = Constant::partial_cmp(cx.tcx, typeck_results.expr_ty(recv), &left, &right) else {
                 return;
diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs
index 8f76e6c9048e1..35b6af0c20f7f 100644
--- a/clippy_lints/src/minmax.rs
+++ b/clippy_lints/src/minmax.rs
@@ -61,7 +61,7 @@ enum MinMax {
     Max,
 }
 
-fn min_max<'a, 'tcx>(cx: &LateContext<'tcx>, expr: &'a Expr<'a>) -> Option<(MinMax, Constant<'tcx>, &'a Expr<'a>)> {
+fn min_max<'a, 'tcx>(cx: &LateContext<'tcx>, expr: &'a Expr<'a>) -> Option<(MinMax, Constant, &'a Expr<'a>)> {
     match expr.kind {
         ExprKind::Call(path, args) => {
             if let ExprKind::Path(ref qpath) = path.kind {
@@ -98,7 +98,7 @@ fn fetch_const<'a, 'tcx>(
     receiver: Option<&'a Expr<'a>>,
     args: &'a [Expr<'a>],
     m: MinMax,
-) -> Option<(MinMax, Constant<'tcx>, &'a Expr<'a>)> {
+) -> Option<(MinMax, Constant, &'a Expr<'a>)> {
     let mut args = receiver.into_iter().chain(args);
     let first_arg = args.next()?;
     let second_arg = args.next()?;
diff --git a/clippy_lints/src/operators/const_comparisons.rs b/clippy_lints/src/operators/const_comparisons.rs
index 10455d3b93a00..56001a185771a 100644
--- a/clippy_lints/src/operators/const_comparisons.rs
+++ b/clippy_lints/src/operators/const_comparisons.rs
@@ -22,7 +22,7 @@ fn comparison_to_const<'tcx>(
     cx: &LateContext<'tcx>,
     typeck: &'tcx TypeckResults<'tcx>,
     expr: &'tcx Expr<'tcx>,
-) -> Option<(CmpOp, &'tcx Expr<'tcx>, &'tcx Expr<'tcx>, Constant<'tcx>, Ty<'tcx>)> {
+) -> Option<(CmpOp, &'tcx Expr<'tcx>, &'tcx Expr<'tcx>, Constant, Ty<'tcx>)> {
     if let ExprKind::Binary(operator, left, right) = expr.kind
         && let Ok(cmp_op) = CmpOp::try_from(operator.node)
     {
diff --git a/clippy_lints/src/operators/float_cmp.rs b/clippy_lints/src/operators/float_cmp.rs
index 03b2cf055d919..eb2353cfd90bf 100644
--- a/clippy_lints/src/operators/float_cmp.rs
+++ b/clippy_lints/src/operators/float_cmp.rs
@@ -85,7 +85,7 @@ fn get_lint_and_message(is_local: bool, is_comparing_arrays: bool) -> (&'static
     }
 }
 
-fn is_allowed(val: &Constant<'_>) -> bool {
+fn is_allowed(val: &Constant) -> bool {
     match val {
         // FIXME(f16_f128): add when equality check is available on all platforms
         &Constant::F32(f) => f == 0.0 || f.is_infinite(),
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 03d00ba849f3c..8a216afb82c9a 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -299,8 +299,8 @@ fn check_possible_range_contains(
     }
 }
 
-struct RangeBounds<'a, 'tcx> {
-    val: Constant<'tcx>,
+struct RangeBounds<'a> {
+    val: Constant,
     expr: &'a Expr<'a>,
     id: HirId,
     name_span: Span,
@@ -312,7 +312,7 @@ struct RangeBounds<'a, 'tcx> {
 // Takes a binary expression such as x <= 2 as input
 // Breaks apart into various pieces, such as the value of the number,
 // hir id of the variable, and direction/inclusiveness of the operator
-fn check_range_bounds<'a, 'tcx>(cx: &'a LateContext<'tcx>, ex: &'a Expr<'_>) -> Option<RangeBounds<'a, 'tcx>> {
+fn check_range_bounds<'a, 'tcx>(cx: &'a LateContext<'tcx>, ex: &'a Expr<'_>) -> Option<RangeBounds<'a>> {
     if let ExprKind::Binary(ref op, l, r) = ex.kind {
         let (inclusive, ordering) = match op.node {
             BinOpKind::Gt => (false, Ordering::Greater),
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index 29f4988b4211b..f5f3786164608 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -5,25 +5,21 @@
 #![allow(clippy::float_cmp)]
 
 use crate::source::{SpanRangeExt, walk_span_to_context};
-use crate::{clip, is_direct_expn_of, sext, unsext};
+use crate::{clip, is_direct_expn_of, paths, sext, sym, unsext};
 
 use rustc_abi::Size;
 use rustc_apfloat::Float;
 use rustc_apfloat::ieee::{Half, Quad};
 use rustc_ast::ast::{LitFloatType, LitKind};
 use rustc_hir::def::{DefKind, Res};
-use rustc_hir::{
-    BinOpKind, Block, ConstBlock, Expr, ExprKind, HirId, Item, ItemKind, Node, PatExpr, PatExprKind, QPath, UnOp,
-};
+use rustc_hir::{BinOpKind, Block, ConstBlock, Expr, ExprKind, HirId, PatExpr, PatExprKind, QPath, TyKind, UnOp};
 use rustc_lexer::{FrontmatterAllowed, tokenize};
 use rustc_lint::LateContext;
 use rustc_middle::mir::ConstValue;
 use rustc_middle::mir::interpret::{Scalar, alloc_range};
 use rustc_middle::ty::{self, FloatTy, IntTy, ScalarInt, Ty, TyCtxt, TypeckResults, UintTy};
 use rustc_middle::{bug, mir, span_bug};
-use rustc_span::def_id::DefId;
-use rustc_span::symbol::Ident;
-use rustc_span::{SyntaxContext, sym};
+use rustc_span::{Symbol, SyntaxContext};
 use std::cell::Cell;
 use std::cmp::Ordering;
 use std::hash::{Hash, Hasher};
@@ -31,8 +27,8 @@ use std::iter;
 
 /// A `LitKind`-like enum to fold constant `Expr`s into.
 #[derive(Debug, Clone)]
-pub enum Constant<'tcx> {
-    Adt(mir::Const<'tcx>),
+pub enum Constant {
+    Adt(ConstValue),
     /// A `String` (e.g., "abc").
     Str(String),
     /// A binary string (e.g., `b"abc"`).
@@ -54,15 +50,15 @@ pub enum Constant<'tcx> {
     /// `true` or `false`.
     Bool(bool),
     /// An array of constants.
-    Vec(Vec<Constant<'tcx>>),
+    Vec(Vec<Constant>),
     /// Also an array, but with only one constant, repeated N times.
-    Repeat(Box<Constant<'tcx>>, u64),
+    Repeat(Box<Constant>, u64),
     /// A tuple of constants.
-    Tuple(Vec<Constant<'tcx>>),
+    Tuple(Vec<Constant>),
     /// A raw pointer.
     RawPtr(u128),
     /// A reference
-    Ref(Box<Constant<'tcx>>),
+    Ref(Box<Constant>),
     /// A literal with syntax error.
     Err,
 }
@@ -124,7 +120,7 @@ impl IntTypeBounds for IntTy {
     }
 }
 
-impl PartialEq for Constant<'_> {
+impl PartialEq for Constant {
     fn eq(&self, other: &Self) -> bool {
         match (self, other) {
             (Self::Str(ls), Self::Str(rs)) => ls == rs,
@@ -135,13 +131,13 @@ impl PartialEq for Constant<'_> {
                 // We want `Fw32 == FwAny` and `FwAny == Fw64`, and by transitivity we must have
                 // `Fw32 == Fw64`, so don’t compare them.
                 // `to_bits` is required to catch non-matching 0.0, -0.0, and NaNs.
-                l.to_bits() == r.to_bits()
+                l.to_bits() == r.to_bits() && !l.is_nan()
             },
             (&Self::F32(l), &Self::F32(r)) => {
                 // We want `Fw32 == FwAny` and `FwAny == Fw64`, and by transitivity we must have
                 // `Fw32 == Fw64`, so don’t compare them.
                 // `to_bits` is required to catch non-matching 0.0, -0.0, and NaNs.
-                f64::from(l).to_bits() == f64::from(r).to_bits()
+                l.to_bits() == r.to_bits() && !l.is_nan()
             },
             (&Self::Bool(l), &Self::Bool(r)) => l == r,
             (&Self::Vec(ref l), &Self::Vec(ref r)) | (&Self::Tuple(ref l), &Self::Tuple(ref r)) => l == r,
@@ -153,7 +149,7 @@ impl PartialEq for Constant<'_> {
     }
 }
 
-impl Hash for Constant<'_> {
+impl Hash for Constant {
     fn hash<H>(&self, state: &mut H)
     where
         H: Hasher,
@@ -209,7 +205,7 @@ impl Hash for Constant<'_> {
     }
 }
 
-impl Constant<'_> {
+impl Constant {
     pub fn partial_cmp(tcx: TyCtxt<'_>, cmp_type: Ty<'_>, left: &Self, right: &Self) -> Option<Ordering> {
         match (left, right) {
             (Self::Str(ls), Self::Str(rs)) => Some(ls.cmp(rs)),
@@ -297,10 +293,129 @@ impl Constant<'_> {
         let f: Quad = s.parse().unwrap();
         Self::F128(f.to_bits())
     }
+
+    pub fn new_numeric_min<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option<Self> {
+        match *ty.kind() {
+            ty::Uint(_) => Some(Self::Int(0)),
+            ty::Int(ty) => {
+                let val = match ty.normalize(tcx.sess.target.pointer_width) {
+                    IntTy::I8 => i128::from(i8::MIN),
+                    IntTy::I16 => i128::from(i16::MIN),
+                    IntTy::I32 => i128::from(i32::MIN),
+                    IntTy::I64 => i128::from(i64::MIN),
+                    IntTy::I128 => i128::MIN,
+                    IntTy::Isize => return None,
+                };
+                Some(Self::Int(val.cast_unsigned()))
+            },
+            ty::Char => Some(Self::Char(char::MIN)),
+            ty::Float(FloatTy::F32) => Some(Self::F32(f32::NEG_INFINITY)),
+            ty::Float(FloatTy::F64) => Some(Self::F64(f64::NEG_INFINITY)),
+            _ => None,
+        }
+    }
+
+    pub fn new_numeric_max<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option<Self> {
+        match *ty.kind() {
+            ty::Uint(ty) => Some(Self::Int(match ty.normalize(tcx.sess.target.pointer_width) {
+                UintTy::U8 => u128::from(u8::MAX),
+                UintTy::U16 => u128::from(u16::MAX),
+                UintTy::U32 => u128::from(u32::MAX),
+                UintTy::U64 => u128::from(u64::MAX),
+                UintTy::U128 => u128::MAX,
+                UintTy::Usize => return None,
+            })),
+            ty::Int(ty) => {
+                let val = match ty.normalize(tcx.sess.target.pointer_width) {
+                    IntTy::I8 => i128::from(i8::MAX),
+                    IntTy::I16 => i128::from(i16::MAX),
+                    IntTy::I32 => i128::from(i32::MAX),
+                    IntTy::I64 => i128::from(i64::MAX),
+                    IntTy::I128 => i128::MAX,
+                    IntTy::Isize => return None,
+                };
+                Some(Self::Int(val.cast_unsigned()))
+            },
+            ty::Char => Some(Self::Char(char::MAX)),
+            ty::Float(FloatTy::F32) => Some(Self::F32(f32::INFINITY)),
+            ty::Float(FloatTy::F64) => Some(Self::F64(f64::INFINITY)),
+            _ => None,
+        }
+    }
+
+    pub fn is_numeric_min<'tcx>(&self, tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool {
+        match (self, ty.kind()) {
+            (&Self::Int(x), &ty::Uint(_)) => x == 0,
+            (&Self::Int(x), &ty::Int(ty)) => {
+                let limit = match ty.normalize(tcx.sess.target.pointer_width) {
+                    IntTy::I8 => i128::from(i8::MIN),
+                    IntTy::I16 => i128::from(i16::MIN),
+                    IntTy::I32 => i128::from(i32::MIN),
+                    IntTy::I64 => i128::from(i64::MIN),
+                    IntTy::I128 => i128::MIN,
+                    IntTy::Isize => return false,
+                };
+                x.cast_signed() == limit
+            },
+            (&Self::Char(x), &ty::Char) => x == char::MIN,
+            (&Self::F32(x), &ty::Float(FloatTy::F32)) => x == f32::NEG_INFINITY,
+            (&Self::F64(x), &ty::Float(FloatTy::F64)) => x == f64::NEG_INFINITY,
+            _ => false,
+        }
+    }
+
+    pub fn is_numeric_max<'tcx>(&self, tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool {
+        match (self, ty.kind()) {
+            (&Self::Int(x), &ty::Uint(ty)) => {
+                let limit = match ty.normalize(tcx.sess.target.pointer_width) {
+                    UintTy::U8 => u128::from(u8::MAX),
+                    UintTy::U16 => u128::from(u16::MAX),
+                    UintTy::U32 => u128::from(u32::MAX),
+                    UintTy::U64 => u128::from(u64::MAX),
+                    UintTy::U128 => u128::MAX,
+                    UintTy::Usize => return false,
+                };
+                x == limit
+            },
+            (&Self::Int(x), &ty::Int(ty)) => {
+                let limit = match ty.normalize(tcx.sess.target.pointer_width) {
+                    IntTy::I8 => i128::from(i8::MAX),
+                    IntTy::I16 => i128::from(i16::MAX),
+                    IntTy::I32 => i128::from(i32::MAX),
+                    IntTy::I64 => i128::from(i64::MAX),
+                    IntTy::I128 => i128::MAX,
+                    IntTy::Isize => return false,
+                };
+                x.cast_signed() == limit
+            },
+            (&Self::Char(x), &ty::Char) => x == char::MAX,
+            (&Self::F32(x), &ty::Float(FloatTy::F32)) => x == f32::INFINITY,
+            (&Self::F64(x), &ty::Float(FloatTy::F64)) => x == f64::INFINITY,
+            _ => false,
+        }
+    }
+
+    pub fn is_pos_infinity(&self) -> bool {
+        match *self {
+            // FIXME(f16_f128): add f16 and f128 when constants are available
+            Constant::F32(x) => x == f32::INFINITY,
+            Constant::F64(x) => x == f64::INFINITY,
+            _ => false,
+        }
+    }
+
+    pub fn is_neg_infinity(&self) -> bool {
+        match *self {
+            // FIXME(f16_f128): add f16 and f128 when constants are available
+            Constant::F32(x) => x == f32::NEG_INFINITY,
+            Constant::F64(x) => x == f64::NEG_INFINITY,
+            _ => false,
+        }
+    }
 }
 
 /// Parses a `LitKind` to a `Constant`.
-pub fn lit_to_mir_constant<'tcx>(lit: &LitKind, ty: Option<Ty<'tcx>>) -> Constant<'tcx> {
+pub fn lit_to_mir_constant(lit: &LitKind, ty: Option<Ty<'_>>) -> Constant {
     match *lit {
         LitKind::Str(ref is, _) => Constant::Str(is.to_string()),
         LitKind::Byte(b) => Constant::Int(u128::from(b)),
@@ -331,10 +446,9 @@ pub fn lit_to_mir_constant<'tcx>(lit: &LitKind, ty: Option<Ty<'tcx>>) -> Constan
 pub enum ConstantSource {
     /// The value is determined solely from the expression.
     Local,
-    /// The value is dependent on a defined constant.
-    Constant,
-    /// The value is dependent on a constant defined in `core` crate.
-    CoreConstant,
+    /// The value is dependent on another definition that may change independently from the local
+    /// expression.
+    NonLocal,
 }
 impl ConstantSource {
     pub fn is_local(self) -> bool {
@@ -416,19 +530,24 @@ impl<'tcx> ConstEvalCtxt<'tcx> {
 
     /// 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<'_>, ctxt: SyntaxContext) -> Option<(Constant<'tcx>, ConstantSource)> {
+    pub fn eval_with_source(&self, e: &Expr<'_>, ctxt: SyntaxContext) -> Option<(Constant, ConstantSource)> {
         self.source.set(ConstantSource::Local);
         self.ctxt.set(ctxt);
         self.expr(e).map(|c| (c, self.source.get()))
     }
 
     /// Attempts to evaluate the expression.
-    pub fn eval(&self, e: &Expr<'_>) -> Option<Constant<'tcx>> {
+    pub fn eval(&self, e: &Expr<'_>) -> Option<Constant> {
         self.expr(e)
     }
 
     /// Attempts to evaluate the expression without accessing other items.
-    pub fn eval_local(&self, e: &Expr<'_>, ctxt: SyntaxContext) -> Option<Constant<'tcx>> {
+    ///
+    /// The context argument is the context used to view the evaluated expression. e.g. when
+    /// evaluating the argument in `f(m!(1))` the context of the call expression should be used.
+    /// This is need so the const evaluator can see the `m` macro and marke the evaluation as
+    /// non-local independant of what the macro expands to.
+    pub fn eval_local(&self, e: &Expr<'_>, ctxt: SyntaxContext) -> Option<Constant> {
         match self.eval_with_source(e, ctxt) {
             Some((x, ConstantSource::Local)) => Some(x),
             _ => None,
@@ -436,6 +555,11 @@ impl<'tcx> ConstEvalCtxt<'tcx> {
     }
 
     /// Attempts to evaluate the expression as an integer without accessing other items.
+    ///
+    /// The context argument is the context used to view the evaluated expression. e.g. when
+    /// evaluating the argument in `f(m!(1))` the context of the call expression should be used.
+    /// This is need so the const evaluator can see the `m` macro and marke the evaluation as
+    /// non-local independant of what the macro expands to.
     pub fn eval_full_int(&self, e: &Expr<'_>, ctxt: SyntaxContext) -> Option<FullInt> {
         match self.eval_with_source(e, ctxt) {
             Some((x, ConstantSource::Local)) => x.int_value(self.tcx, self.typeck.expr_ty(e)),
@@ -443,7 +567,7 @@ impl<'tcx> ConstEvalCtxt<'tcx> {
         }
     }
 
-    pub fn eval_pat_expr(&self, pat_expr: &PatExpr<'_>) -> Option<Constant<'tcx>> {
+    pub fn eval_pat_expr(&self, pat_expr: &PatExpr<'_>) -> Option<Constant> {
         match &pat_expr.kind {
             PatExprKind::Lit { lit, negated } => {
                 let ty = self.typeck.node_type_opt(pat_expr.hir_id);
@@ -460,35 +584,18 @@ impl<'tcx> ConstEvalCtxt<'tcx> {
     }
 
     fn check_ctxt(&self, ctxt: SyntaxContext) {
-        self.source.set(if self.ctxt.get() != ctxt {
-            ConstantSource::Constant
-        } else {
-            self.source.get()
-        });
+        if self.ctxt.get() != ctxt {
+            self.source.set(ConstantSource::NonLocal);
+        }
     }
 
-    fn qpath(&self, qpath: &QPath<'_>, hir_id: HirId) -> Option<Constant<'tcx>> {
-        let is_core_crate = if let Some(def_id) = self.typeck.qpath_res(qpath, hir_id).opt_def_id() {
-            self.tcx.crate_name(def_id.krate) == sym::core
-        } else {
-            false
-        };
-        self.fetch_path_and_apply(qpath, hir_id, self.typeck.node_type(hir_id), |self_, result| {
-            let result = mir_to_const(self_.tcx, result)?;
-            // If source is already Constant we wouldn't want to override it with CoreConstant
-            self_.source.set(
-                if is_core_crate && !matches!(self_.source.get(), ConstantSource::Constant) {
-                    ConstantSource::CoreConstant
-                } else {
-                    ConstantSource::Constant
-                },
-            );
-            Some(result)
-        })
+    fn qpath(&self, qpath: &QPath<'_>, hir_id: HirId) -> Option<Constant> {
+        self.fetch_path(qpath, hir_id)
+            .and_then(|c| mir_to_const(self.tcx, c, self.typeck.node_type(hir_id)))
     }
 
     /// Simple constant folding: Insert an expression, get a constant or none.
-    fn expr(&self, e: &Expr<'_>) -> Option<Constant<'tcx>> {
+    fn expr(&self, e: &Expr<'_>) -> Option<Constant> {
         self.check_ctxt(e.span.ctxt());
         match e.kind {
             ExprKind::ConstBlock(ConstBlock { body, .. }) => self.expr(self.tcx.hir_body(body).value),
@@ -540,18 +647,20 @@ impl<'tcx> ConstEvalCtxt<'tcx> {
             },
             ExprKind::Index(arr, index, _) => self.index(arr, index),
             ExprKind::AddrOf(_, _, inner) => self.expr(inner).map(|r| Constant::Ref(Box::new(r))),
-            ExprKind::Field(local_expr, ref field) => {
-                self.check_ctxt(field.span.ctxt());
-                let result = self.expr(local_expr);
-                if let Some(Constant::Adt(constant)) = &self.expr(local_expr)
-                    && let ty::Adt(adt_def, _) = constant.ty().kind()
+            ExprKind::Field(base, ref field)
+                if let base_ty = self.typeck.expr_ty(base)
+                    && match self.typeck.expr_adjustments(base) {
+                        [] => true,
+                        [.., a] => a.target == base_ty,
+                    }
+                    && let Some(Constant::Adt(constant)) = self.expr(base)
+                    && let ty::Adt(adt_def, _) = *base_ty.kind()
                     && adt_def.is_struct()
-                    && let Some(desired_field) = field_of_struct(*adt_def, self.tcx, *constant, field)
-                {
-                    mir_to_const(self.tcx, desired_field)
-                } else {
-                    result
-                }
+                    && let Some((desired_field, ty)) =
+                        field_of_struct(adt_def, self.tcx, constant, base_ty, field.name) =>
+            {
+                self.check_ctxt(field.span.ctxt());
+                mir_to_const(self.tcx, desired_field, ty)
             },
             _ => None,
         }
@@ -564,19 +673,6 @@ impl<'tcx> ConstEvalCtxt<'tcx> {
         match e.kind {
             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
-                    .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.expr_ty(e), |self_, result| {
-                    mir_is_empty(self_.tcx, result)
-                })
-            },
             ExprKind::Lit(lit) => {
                 if is_direct_expn_of(e.span, sym::cfg).is_some() {
                     None
@@ -601,7 +697,7 @@ impl<'tcx> ConstEvalCtxt<'tcx> {
     }
 
     #[expect(clippy::cast_possible_wrap)]
-    fn constant_not(&self, o: &Constant<'tcx>, ty: Ty<'_>) -> Option<Constant<'tcx>> {
+    fn constant_not(&self, o: &Constant, ty: Ty<'_>) -> Option<Constant> {
         use self::Constant::{Bool, Int};
         match *o {
             Bool(b) => Some(Bool(!b)),
@@ -617,7 +713,7 @@ impl<'tcx> ConstEvalCtxt<'tcx> {
         }
     }
 
-    fn constant_negate(&self, o: &Constant<'tcx>, ty: Ty<'_>) -> Option<Constant<'tcx>> {
+    fn constant_negate(&self, o: &Constant, ty: Ty<'_>) -> Option<Constant> {
         use self::Constant::{F32, F64, Int};
         match *o {
             Int(value) => {
@@ -643,48 +739,128 @@ impl<'tcx> ConstEvalCtxt<'tcx> {
 
     /// Create `Some(Vec![..])` of all constants, unless there is any
     /// non-constant part.
-    fn multi(&self, vec: &[Expr<'_>]) -> Option<Vec<Constant<'tcx>>> {
+    fn multi(&self, vec: &[Expr<'_>]) -> Option<Vec<Constant>> {
         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>(&self, qpath: &QPath<'_>, id: HirId, ty: Ty<'tcx>, f: F) -> Option<T>
-    where
-        F: FnOnce(&Self, mir::Const<'tcx>) -> Option<T>,
-    {
-        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.tcx.hir_get_if_local(def_id)
-                    && let Node::Item(Item {
-                        kind: ItemKind::Const(.., body_id),
-                        ..
-                    }) = node
-                    && let Node::Expr(Expr {
-                        kind: ExprKind::Lit(_),
-                        span,
-                        ..
-                    }) = self.tcx.hir_node(body_id.hir_id)
-                    && is_direct_expn_of(*span, sym::cfg).is_some()
-                {
-                    return None;
-                }
-
-                let args = self.typeck.node_args(id);
-                let result = self
-                    .tcx
-                    .const_eval_resolve(self.typing_env, mir::UnevaluatedConst::new(def_id, args), qpath.span())
-                    .ok()
-                    .map(|val| mir::Const::from_value(val, ty))?;
-                f(self, result)
+    #[expect(clippy::too_many_lines)]
+    fn fetch_path(&self, qpath: &QPath<'_>, id: HirId) -> Option<ConstValue> {
+        // Resolve the path to a constant and check if that constant is known to
+        // not change based on the target.
+        //
+        // This should be replaced with an attribute at some point.
+        let did = match *qpath {
+            QPath::Resolved(None, path)
+                if path.span.ctxt() == self.ctxt.get()
+                    && path.segments.iter().all(|s| self.ctxt.get() == s.ident.span.ctxt())
+                    && let Res::Def(DefKind::Const, did) = path.res
+                    && (matches!(
+                        self.tcx.get_diagnostic_name(did),
+                        Some(
+                            sym::f32_legacy_const_digits
+                                | sym::f32_legacy_const_epsilon
+                                | sym::f32_legacy_const_infinity
+                                | sym::f32_legacy_const_mantissa_dig
+                                | sym::f32_legacy_const_max
+                                | sym::f32_legacy_const_max_10_exp
+                                | sym::f32_legacy_const_max_exp
+                                | sym::f32_legacy_const_min
+                                | sym::f32_legacy_const_min_10_exp
+                                | sym::f32_legacy_const_min_exp
+                                | sym::f32_legacy_const_min_positive
+                                | sym::f32_legacy_const_nan
+                                | sym::f32_legacy_const_neg_infinity
+                                | sym::f32_legacy_const_radix
+                                | sym::f64_legacy_const_digits
+                                | sym::f64_legacy_const_epsilon
+                                | sym::f64_legacy_const_infinity
+                                | sym::f64_legacy_const_mantissa_dig
+                                | sym::f64_legacy_const_max
+                                | sym::f64_legacy_const_max_10_exp
+                                | sym::f64_legacy_const_max_exp
+                                | sym::f64_legacy_const_min
+                                | sym::f64_legacy_const_min_10_exp
+                                | sym::f64_legacy_const_min_exp
+                                | sym::f64_legacy_const_min_positive
+                                | sym::f64_legacy_const_nan
+                                | sym::f64_legacy_const_neg_infinity
+                                | sym::f64_legacy_const_radix
+                                | sym::u8_legacy_const_min
+                                | sym::u16_legacy_const_min
+                                | sym::u32_legacy_const_min
+                                | sym::u64_legacy_const_min
+                                | sym::u128_legacy_const_min
+                                | sym::usize_legacy_const_min
+                                | sym::u8_legacy_const_max
+                                | sym::u16_legacy_const_max
+                                | sym::u32_legacy_const_max
+                                | sym::u64_legacy_const_max
+                                | sym::u128_legacy_const_max
+                                | sym::i8_legacy_const_min
+                                | sym::i16_legacy_const_min
+                                | sym::i32_legacy_const_min
+                                | sym::i64_legacy_const_min
+                                | sym::i128_legacy_const_min
+                                | sym::i8_legacy_const_max
+                                | sym::i16_legacy_const_max
+                                | sym::i32_legacy_const_max
+                                | sym::i64_legacy_const_max
+                                | sym::i128_legacy_const_max
+                        )
+                    ) || self.tcx.opt_parent(did).is_some_and(|parent| {
+                        paths::F16_CONSTS.matches(&self.tcx, parent)
+                            || paths::F32_CONSTS.matches(&self.tcx, parent)
+                            || paths::F64_CONSTS.matches(&self.tcx, parent)
+                            || paths::F128_CONSTS.matches(&self.tcx, parent)
+                    })) =>
+            {
+                did
             },
-            _ => None,
-        }
+            QPath::TypeRelative(ty, const_name)
+                if let TyKind::Path(QPath::Resolved(None, ty_path)) = ty.kind
+                    && let [.., ty_name] = ty_path.segments
+                    && (matches!(
+                        ty_name.ident.name,
+                        sym::i8
+                            | sym::i16
+                            | sym::i32
+                            | sym::i64
+                            | sym::i128
+                            | sym::u8
+                            | sym::u16
+                            | sym::u32
+                            | sym::u64
+                            | sym::u128
+                            | sym::f32
+                            | sym::f64
+                            | sym::char
+                    ) || (ty_name.ident.name == sym::usize && const_name.ident.name == sym::MIN))
+                    && const_name.ident.span.ctxt() == self.ctxt.get()
+                    && ty.span.ctxt() == self.ctxt.get()
+                    && ty_name.ident.span.ctxt() == self.ctxt.get()
+                    && matches!(ty_path.res, Res::PrimTy(_))
+                    && let Some((DefKind::AssocConst, did)) = self.typeck.type_dependent_def(id) =>
+            {
+                did
+            },
+            _ if let Res::Def(DefKind::Const | DefKind::AssocConst, did) = self.typeck.qpath_res(qpath, id) => {
+                self.source.set(ConstantSource::NonLocal);
+                did
+            },
+            _ => return None,
+        };
+
+        self.tcx
+            .const_eval_resolve(
+                self.typing_env,
+                mir::UnevaluatedConst::new(did, self.typeck.node_args(id)),
+                qpath.span(),
+            )
+            .ok()
     }
 
-    fn index(&self, lhs: &'_ Expr<'_>, index: &'_ Expr<'_>) -> Option<Constant<'tcx>> {
+    fn index(&self, lhs: &'_ Expr<'_>, index: &'_ Expr<'_>) -> Option<Constant> {
         let lhs = self.expr(lhs);
         let index = self.expr(index);
 
@@ -714,7 +890,7 @@ impl<'tcx> ConstEvalCtxt<'tcx> {
     }
 
     /// A block can only yield a constant if it has exactly one constant expression.
-    fn block(&self, block: &Block<'_>) -> Option<Constant<'tcx>> {
+    fn block(&self, block: &Block<'_>) -> Option<Constant> {
         if block.stmts.is_empty()
             && let Some(expr) = block.expr
         {
@@ -733,11 +909,11 @@ impl<'tcx> ConstEvalCtxt<'tcx> {
                         .filter(|t| !matches!(t, Whitespace | LineComment { .. } | BlockComment { .. } | Semi))
                         .eq([OpenBrace])
                     {
-                        self.source.set(ConstantSource::Constant);
+                        self.source.set(ConstantSource::NonLocal);
                     }
                 } else {
                     // Unable to access the source. Assume a non-local dependency.
-                    self.source.set(ConstantSource::Constant);
+                    self.source.set(ConstantSource::NonLocal);
                 }
             }
 
@@ -747,7 +923,7 @@ impl<'tcx> ConstEvalCtxt<'tcx> {
         }
     }
 
-    fn ifthenelse(&self, cond: &Expr<'_>, then: &Expr<'_>, otherwise: Option<&Expr<'_>>) -> Option<Constant<'tcx>> {
+    fn ifthenelse(&self, cond: &Expr<'_>, then: &Expr<'_>, otherwise: Option<&Expr<'_>>) -> Option<Constant> {
         if let Some(Constant::Bool(b)) = self.expr(cond) {
             if b {
                 self.expr(then)
@@ -759,7 +935,7 @@ impl<'tcx> ConstEvalCtxt<'tcx> {
         }
     }
 
-    fn binop(&self, op: BinOpKind, left: &Expr<'_>, right: &Expr<'_>) -> Option<Constant<'tcx>> {
+    fn binop(&self, op: BinOpKind, left: &Expr<'_>, right: &Expr<'_>) -> Option<Constant> {
         let l = self.expr(left)?;
         let r = self.expr(right);
         match (l, r) {
@@ -795,6 +971,7 @@ impl<'tcx> ConstEvalCtxt<'tcx> {
                         BinOpKind::BitXor => Some(zext(l ^ r)),
                         BinOpKind::BitOr => Some(zext(l | r)),
                         BinOpKind::BitAnd => Some(zext(l & r)),
+                        // FIXME: f32/f64 currently consider `0.0` and `-0.0` as different.
                         BinOpKind::Eq => Some(Constant::Bool(l == r)),
                         BinOpKind::Ne => Some(Constant::Bool(l != r)),
                         BinOpKind::Lt => Some(Constant::Bool(l < r)),
@@ -873,14 +1050,10 @@ impl<'tcx> ConstEvalCtxt<'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;
-    };
-    match (val, result.ty().kind()) {
-        (ConstValue::Scalar(Scalar::Int(int)), _) => match result.ty().kind() {
-            ty::Adt(adt_def, _) if adt_def.is_struct() => Some(Constant::Adt(result)),
+pub fn mir_to_const<'tcx>(tcx: TyCtxt<'tcx>, val: ConstValue, ty: Ty<'tcx>) -> Option<Constant> {
+    match (val, ty.kind()) {
+        (_, &ty::Adt(adt_def, _)) if adt_def.is_struct() => Some(Constant::Adt(val)),
+        (ConstValue::Scalar(Scalar::Int(int)), _) => match ty.kind() {
             ty::Bool => Some(Constant::Bool(int == ScalarInt::TRUE)),
             ty::Uint(_) | ty::Int(_) => Some(Constant::Int(int.to_bits(int.size()))),
             ty::Float(FloatTy::F16) => Some(Constant::F16(int.into())),
@@ -894,7 +1067,6 @@ pub fn mir_to_const<'tcx>(tcx: TyCtxt<'tcx>, result: mir::Const<'tcx>) -> Option
             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 = tcx.global_alloc(alloc_id).unwrap_memory().inner();
             let len = len.try_to_target_usize(tcx)?;
@@ -919,62 +1091,30 @@ pub fn mir_to_const<'tcx>(tcx: TyCtxt<'tcx>, result: mir::Const<'tcx>) -> Option
     }
 }
 
-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;
-    };
-    match (val, result.ty().kind()) {
-        (_, ty::Ref(_, inner_ty, _)) => match inner_ty.kind() {
-            ty::Str | ty::Slice(_) => {
-                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 = 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(&tcx, alloc_range(offset + ptr_size, ptr_size), false)
-                        .ok()?
-                        .to_target_usize(&tcx)
-                        .discard_err()?;
-                    Some(len == 0)
-                } else {
-                    None
-                }
-            },
-            ty::Array(_, len) => Some(len.try_to_target_usize(tcx)? == 0),
-            _ => None,
-        },
-        (ConstValue::Indirect { .. }, ty::Array(_, len)) => Some(len.try_to_target_usize(tcx)? == 0),
-        (ConstValue::ZeroSized, _) => Some(true),
-        _ => None,
-    }
-}
-
 fn field_of_struct<'tcx>(
     adt_def: ty::AdtDef<'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) = tcx.try_destructure_mir_constant_for_user_output(result, ty)
+    value: ConstValue,
+    ty: Ty<'tcx>,
+    field: Symbol,
+) -> Option<(ConstValue, Ty<'tcx>)> {
+    if let Some(dc) = tcx.try_destructure_mir_constant_for_user_output(value, 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)
-        && let Some(&(val, ty)) = dc.fields.get(field_idx)
+        && let Some(field_idx) = variant.fields.iter().position(|el| el.name == field)
     {
-        Some(mir::Const::Val(val, ty))
+        dc.fields.get(field_idx).copied()
     } else {
         None
     }
 }
 
 /// If `expr` evaluates to an integer constant, return its value.
+///
+/// The context argument is the context used to view the evaluated expression. e.g. when evaluating
+/// the argument in `f(m!(1))` the context of the call expression should be used. This is need so
+/// the const evaluator can see the `m` macro and marke the evaluation as non-local independant of
+/// what the macro expands to.
 pub fn integer_const(cx: &LateContext<'_>, expr: &Expr<'_>, ctxt: SyntaxContext) -> Option<u128> {
     if let Some(Constant::Int(value)) = ConstEvalCtxt::new(cx).eval_local(expr, ctxt) {
         Some(value)
@@ -984,6 +1124,11 @@ pub fn integer_const(cx: &LateContext<'_>, expr: &Expr<'_>, ctxt: SyntaxContext)
 }
 
 /// Check if `expr` evaluates to an integer constant of 0.
+///
+/// The context argument is the context used to view the evaluated expression. e.g. when evaluating
+/// the argument in `f(m!(1))` the context of the call expression should be used. This is need so
+/// the const evaluator can see the `m` macro and marke the evaluation as non-local independant of
+/// what the macro expands to.
 #[inline]
 pub fn is_zero_integer_const(cx: &LateContext<'_>, expr: &Expr<'_>, ctxt: SyntaxContext) -> bool {
     integer_const(cx, expr, ctxt) == Some(0)
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 708491df77079..a2c8ec34c6be2 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -126,7 +126,7 @@ use source::{SpanRangeExt, walk_span_to_context};
 use visitors::{Visitable, for_each_unconsumed_temporary};
 
 use crate::ast_utils::unordered_over;
-use crate::consts::{ConstEvalCtxt, Constant, mir_to_const};
+use crate::consts::{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;
@@ -1422,11 +1422,9 @@ pub fn is_range_full(cx: &LateContext<'_>, expr: &Expr<'_>, container_path: Opti
         let start_is_none_or_min = start.is_none_or(|start| {
             if let rustc_ty::Adt(_, subst) = ty.kind()
                 && let bnd_ty = subst.type_at(0)
-                && let Some(min_const) = bnd_ty.numeric_min_val(cx.tcx)
-                && let Some(min_const) = mir_to_const(cx.tcx, min_const)
                 && let Some(start_const) = ConstEvalCtxt::new(cx).eval(start)
             {
-                start_const == min_const
+                start_const.is_numeric_min(cx.tcx, bnd_ty)
             } else {
                 false
             }
@@ -1435,11 +1433,9 @@ pub fn is_range_full(cx: &LateContext<'_>, expr: &Expr<'_>, container_path: Opti
             RangeLimits::Closed => {
                 if let rustc_ty::Adt(_, subst) = ty.kind()
                     && let bnd_ty = subst.type_at(0)
-                    && let Some(max_const) = bnd_ty.numeric_max_val(cx.tcx)
-                    && let Some(max_const) = mir_to_const(cx.tcx, max_const)
                     && let Some(end_const) = ConstEvalCtxt::new(cx).eval(end)
                 {
-                    end_const == max_const
+                    end_const.is_numeric_max(cx.tcx, bnd_ty)
                 } else {
                     false
                 }
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index ea8cfc59356a7..5ab8e16d88ed3 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -13,6 +13,7 @@ use rustc_hir::def_id::{DefId, LOCAL_CRATE, LocalDefId};
 use rustc_hir::{ItemKind, Node, UseKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::fast_reject::SimplifiedType;
+use rustc_middle::ty::layout::HasTyCtxt;
 use rustc_middle::ty::{FloatTy, IntTy, Ty, TyCtxt, UintTy};
 use rustc_span::{Ident, STDLIB_STABLE_CRATES, Symbol};
 use std::sync::OnceLock;
@@ -74,8 +75,8 @@ impl PathLookup {
     }
 
     /// Returns the list of [`DefId`]s that the path resolves to
-    pub fn get(&self, cx: &LateContext<'_>) -> &[DefId] {
-        self.once.get_or_init(|| lookup_path(cx.tcx, self.ns, self.path))
+    pub fn get<'tcx>(&self, tcx: &impl HasTyCtxt<'tcx>) -> &[DefId] {
+        self.once.get_or_init(|| lookup_path(tcx.tcx(), self.ns, self.path))
     }
 
     /// Returns the single [`DefId`] that the path resolves to, this can only be used for paths into
@@ -90,8 +91,8 @@ impl PathLookup {
     }
 
     /// Checks if the path resolves to the given `def_id`
-    pub fn matches(&self, cx: &LateContext<'_>, def_id: DefId) -> bool {
-        self.get(cx).contains(&def_id)
+    pub fn matches<'tcx>(&self, tcx: &impl HasTyCtxt<'tcx>, def_id: DefId) -> bool {
+        self.get(&tcx.tcx()).contains(&def_id)
     }
 
     /// Resolves `maybe_path` to a [`DefId`] and checks if the [`PathLookup`] matches it
@@ -100,8 +101,8 @@ impl PathLookup {
     }
 
     /// Checks if the path resolves to `ty`'s definition, must be an `Adt`
-    pub fn matches_ty(&self, cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
-        ty.ty_adt_def().is_some_and(|adt| self.matches(cx, adt.did()))
+    pub fn matches_ty<'tcx>(&self, tcx: &impl HasTyCtxt<'tcx>, ty: Ty<'_>) -> bool {
+        ty.ty_adt_def().is_some_and(|adt| self.matches(&tcx.tcx(), adt.did()))
     }
 }
 
@@ -126,6 +127,11 @@ path_macros! {
     macro_path: PathNS::Macro,
 }
 
+pub static F16_CONSTS: PathLookup = type_path!(core::f16::consts);
+pub static F32_CONSTS: PathLookup = type_path!(core::f32::consts);
+pub static F64_CONSTS: PathLookup = type_path!(core::f64::consts);
+pub static F128_CONSTS: PathLookup = type_path!(core::f128::consts);
+
 // Paths in external crates
 pub static FUTURES_IO_ASYNCREADEXT: PathLookup = type_path!(futures_util::AsyncReadExt);
 pub static FUTURES_IO_ASYNCWRITEEXT: PathLookup = type_path!(futures_util::AsyncWriteExt);
diff --git a/clippy_utils/src/sym.rs b/clippy_utils/src/sym.rs
index 4ba0e52572ddf..2d0d4a5319f3c 100644
--- a/clippy_utils/src/sym.rs
+++ b/clippy_utils/src/sym.rs
@@ -115,6 +115,7 @@ generate! {
     collapsible_if,
     collect,
     const_ptr,
+    consts,
     contains,
     copied,
     copy_from,
diff --git a/tests/ui/const_comparisons.rs b/tests/ui/const_comparisons.rs
index b732d7d142fc5..a2a1f0a7b4c09 100644
--- a/tests/ui/const_comparisons.rs
+++ b/tests/ui/const_comparisons.rs
@@ -1,9 +1,11 @@
-#![allow(unused)]
-#![warn(clippy::impossible_comparisons)]
-#![warn(clippy::redundant_comparisons)]
-#![allow(clippy::no_effect)]
-#![allow(clippy::short_circuit_statement)]
-#![allow(clippy::manual_range_contains)]
+#![allow(
+    unused,
+    clippy::identity_op,
+    clippy::manual_range_contains,
+    clippy::no_effect,
+    clippy::short_circuit_statement
+)]
+#![warn(clippy::impossible_comparisons, clippy::redundant_comparisons)]
 
 const STATUS_BAD_REQUEST: u16 = 400;
 const STATUS_SERVER_ERROR: u16 = 500;
diff --git a/tests/ui/const_comparisons.stderr b/tests/ui/const_comparisons.stderr
index 48a2c6e8d4879..1ce62c23ff293 100644
--- a/tests/ui/const_comparisons.stderr
+++ b/tests/ui/const_comparisons.stderr
@@ -1,5 +1,5 @@
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:45:5
+  --> tests/ui/const_comparisons.rs:47:5
    |
 LL |     status_code <= 400 && status_code > 500;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -9,7 +9,7 @@ LL |     status_code <= 400 && status_code > 500;
    = help: to override `-D warnings` add `#[allow(clippy::impossible_comparisons)]`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:48:5
+  --> tests/ui/const_comparisons.rs:50:5
    |
 LL |     status_code > 500 && status_code < 400;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL |     status_code > 500 && status_code < 400;
    = note: since `500` > `400`, the expression evaluates to false for any value of `status_code`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:51:5
+  --> tests/ui/const_comparisons.rs:53:5
    |
 LL |     status_code < 500 && status_code > 500;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL |     status_code < 500 && status_code > 500;
    = note: `status_code` cannot simultaneously be greater than and less than `500`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:55:5
+  --> tests/ui/const_comparisons.rs:57:5
    |
 LL |     status_code < { 400 } && status_code > { 500 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -33,7 +33,7 @@ LL |     status_code < { 400 } && status_code > { 500 };
    = note: since `{ 400 }` < `{ 500 }`, the expression evaluates to false for any value of `status_code`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:58:5
+  --> tests/ui/const_comparisons.rs:60:5
    |
 LL |     status_code < STATUS_BAD_REQUEST && status_code > STATUS_SERVER_ERROR;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -41,7 +41,7 @@ LL |     status_code < STATUS_BAD_REQUEST && status_code > STATUS_SERVER_ERROR;
    = note: since `STATUS_BAD_REQUEST` < `STATUS_SERVER_ERROR`, the expression evaluates to false for any value of `status_code`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:61:5
+  --> tests/ui/const_comparisons.rs:63:5
    |
 LL |     status_code <= u16::MIN + 1 && status_code > STATUS_SERVER_ERROR;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL |     status_code <= u16::MIN + 1 && status_code > STATUS_SERVER_ERROR;
    = note: since `u16::MIN + 1` < `STATUS_SERVER_ERROR`, the expression evaluates to false for any value of `status_code`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:64:5
+  --> tests/ui/const_comparisons.rs:66:5
    |
 LL |     status_code < STATUS_SERVER_ERROR && status_code > STATUS_SERVER_ERROR;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -57,7 +57,7 @@ LL |     status_code < STATUS_SERVER_ERROR && status_code > STATUS_SERVER_ERROR;
    = note: `status_code` cannot simultaneously be greater than and less than `STATUS_SERVER_ERROR`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:68:5
+  --> tests/ui/const_comparisons.rs:70:5
    |
 LL |     status < { 400 } && status > { 500 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -65,7 +65,7 @@ LL |     status < { 400 } && status > { 500 };
    = note: since `{ 400 }` < `{ 500 }`, the expression evaluates to false for any value of `status`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:71:5
+  --> tests/ui/const_comparisons.rs:73:5
    |
 LL |     status < STATUS_BAD_REQUEST && status > STATUS_SERVER_ERROR;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL |     status < STATUS_BAD_REQUEST && status > STATUS_SERVER_ERROR;
    = note: since `STATUS_BAD_REQUEST` < `STATUS_SERVER_ERROR`, the expression evaluates to false for any value of `status`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:74:5
+  --> tests/ui/const_comparisons.rs:76:5
    |
 LL |     status <= u16::MIN + 1 && status > STATUS_SERVER_ERROR;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -81,7 +81,7 @@ LL |     status <= u16::MIN + 1 && status > STATUS_SERVER_ERROR;
    = note: since `u16::MIN + 1` < `STATUS_SERVER_ERROR`, the expression evaluates to false for any value of `status`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:77:5
+  --> tests/ui/const_comparisons.rs:79:5
    |
 LL |     status < STATUS_SERVER_ERROR && status > STATUS_SERVER_ERROR;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -89,7 +89,7 @@ LL |     status < STATUS_SERVER_ERROR && status > STATUS_SERVER_ERROR;
    = note: `status` cannot simultaneously be greater than and less than `STATUS_SERVER_ERROR`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:86:5
+  --> tests/ui/const_comparisons.rs:88:5
    |
 LL |     500 >= status_code && 600 < status_code;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL |     500 >= status_code && 600 < status_code;
    = note: since `500` < `600`, the expression evaluates to false for any value of `status_code`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:90:5
+  --> tests/ui/const_comparisons.rs:92:5
    |
 LL |     500 >= status_code && status_code > 600;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -105,7 +105,7 @@ LL |     500 >= status_code && status_code > 600;
    = note: since `500` < `600`, the expression evaluates to false for any value of `status_code`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:99:5
+  --> tests/ui/const_comparisons.rs:101:5
    |
 LL |     500 >= status && 600 < status;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -113,7 +113,7 @@ LL |     500 >= status && 600 < status;
    = note: since `500` < `600`, the expression evaluates to false for any value of `status`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:103:5
+  --> tests/ui/const_comparisons.rs:105:5
    |
 LL |     500 >= status && status > 600;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -121,13 +121,13 @@ LL |     500 >= status && status > 600;
    = note: since `500` < `600`, the expression evaluates to false for any value of `status`
 
 error: right-hand side of `&&` operator has no effect
-  --> tests/ui/const_comparisons.rs:107:5
+  --> tests/ui/const_comparisons.rs:109:5
    |
 LL |     status_code < 200 && status_code <= 299;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: `if `status_code < 200` evaluates to true, status_code <= 299` will always evaluate to true as well
-  --> tests/ui/const_comparisons.rs:107:23
+  --> tests/ui/const_comparisons.rs:109:23
    |
 LL |     status_code < 200 && status_code <= 299;
    |                       ^^^^^^^^^^^^^^^^^^^^^
@@ -135,67 +135,67 @@ LL |     status_code < 200 && status_code <= 299;
    = help: to override `-D warnings` add `#[allow(clippy::redundant_comparisons)]`
 
 error: left-hand side of `&&` operator has no effect
-  --> tests/ui/const_comparisons.rs:110:5
+  --> tests/ui/const_comparisons.rs:112:5
    |
 LL |     status_code > 200 && status_code >= 299;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: `if `status_code >= 299` evaluates to true, status_code > 200` will always evaluate to true as well
-  --> tests/ui/const_comparisons.rs:110:5
+  --> tests/ui/const_comparisons.rs:112:5
    |
 LL |     status_code > 200 && status_code >= 299;
    |     ^^^^^^^^^^^^^^^^^^^^^
 
 error: left-hand side of `&&` operator has no effect
-  --> tests/ui/const_comparisons.rs:114:5
+  --> tests/ui/const_comparisons.rs:116:5
    |
 LL |     status_code >= 500 && status_code > 500;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: `if `status_code > 500` evaluates to true, status_code >= 500` will always evaluate to true as well
-  --> tests/ui/const_comparisons.rs:114:5
+  --> tests/ui/const_comparisons.rs:116:5
    |
 LL |     status_code >= 500 && status_code > 500;
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: right-hand side of `&&` operator has no effect
-  --> tests/ui/const_comparisons.rs:118:5
+  --> tests/ui/const_comparisons.rs:120:5
    |
 LL |     status_code > 500 && status_code >= 500;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: `if `status_code > 500` evaluates to true, status_code >= 500` will always evaluate to true as well
-  --> tests/ui/const_comparisons.rs:118:23
+  --> tests/ui/const_comparisons.rs:120:23
    |
 LL |     status_code > 500 && status_code >= 500;
    |                       ^^^^^^^^^^^^^^^^^^^^^
 
 error: left-hand side of `&&` operator has no effect
-  --> tests/ui/const_comparisons.rs:122:5
+  --> tests/ui/const_comparisons.rs:124:5
    |
 LL |     status_code <= 500 && status_code < 500;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: `if `status_code < 500` evaluates to true, status_code <= 500` will always evaluate to true as well
-  --> tests/ui/const_comparisons.rs:122:5
+  --> tests/ui/const_comparisons.rs:124:5
    |
 LL |     status_code <= 500 && status_code < 500;
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: right-hand side of `&&` operator has no effect
-  --> tests/ui/const_comparisons.rs:126:5
+  --> tests/ui/const_comparisons.rs:128:5
    |
 LL |     status_code < 500 && status_code <= 500;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: `if `status_code < 500` evaluates to true, status_code <= 500` will always evaluate to true as well
-  --> tests/ui/const_comparisons.rs:126:23
+  --> tests/ui/const_comparisons.rs:128:23
    |
 LL |     status_code < 500 && status_code <= 500;
    |                       ^^^^^^^^^^^^^^^^^^^^^
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:131:5
+  --> tests/ui/const_comparisons.rs:133:5
    |
 LL |     name < "Jennifer" && name > "Shannon";
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -203,7 +203,7 @@ LL |     name < "Jennifer" && name > "Shannon";
    = note: since `"Jennifer"` < `"Shannon"`, the expression evaluates to false for any value of `name`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:135:5
+  --> tests/ui/const_comparisons.rs:137:5
    |
 LL |     numbers < [3, 4] && numbers > [5, 6];
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -211,7 +211,7 @@ LL |     numbers < [3, 4] && numbers > [5, 6];
    = note: since `[3, 4]` < `[5, 6]`, the expression evaluates to false for any value of `numbers`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:139:5
+  --> tests/ui/const_comparisons.rs:141:5
    |
 LL |     letter < 'b' && letter > 'c';
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -219,7 +219,7 @@ LL |     letter < 'b' && letter > 'c';
    = note: since `'b'` < `'c'`, the expression evaluates to false for any value of `letter`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:143:5
+  --> tests/ui/const_comparisons.rs:145:5
    |
 LL |     area < std::f32::consts::E && area > std::f32::consts::PI;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/const_is_empty.rs b/tests/ui/const_is_empty.rs
index 8bb4f0e5d9750..2ad1b5276def8 100644
--- a/tests/ui/const_is_empty.rs
+++ b/tests/ui/const_is_empty.rs
@@ -55,53 +55,6 @@ const NON_EMPTY_ARRAY_REPEAT: [u32; 2] = [1; 2];
 const EMPTY_REF_ARRAY: &[u32; 0] = &[];
 const NON_EMPTY_REF_ARRAY: &[u32; 3] = &[1, 2, 3];
 
-fn test_from_const() {
-    let _ = EMPTY_STR.is_empty();
-    //~^ const_is_empty
-
-    let _ = NON_EMPTY_STR.is_empty();
-    //~^ const_is_empty
-
-    let _ = EMPTY_BSTR.is_empty();
-    //~^ const_is_empty
-
-    let _ = NON_EMPTY_BSTR.is_empty();
-    //~^ const_is_empty
-
-    let _ = EMPTY_ARRAY.is_empty();
-    //~^ const_is_empty
-
-    let _ = EMPTY_ARRAY_REPEAT.is_empty();
-    //~^ const_is_empty
-
-    let _ = EMPTY_U8_SLICE.is_empty();
-    //~^ const_is_empty
-
-    let _ = NON_EMPTY_U8_SLICE.is_empty();
-    //~^ const_is_empty
-
-    let _ = NON_EMPTY_ARRAY.is_empty();
-    //~^ const_is_empty
-
-    let _ = NON_EMPTY_ARRAY_REPEAT.is_empty();
-    //~^ const_is_empty
-
-    let _ = EMPTY_REF_ARRAY.is_empty();
-    //~^ const_is_empty
-
-    let _ = NON_EMPTY_REF_ARRAY.is_empty();
-    //~^ const_is_empty
-
-    let _ = EMPTY_SLICE.is_empty();
-    //~^ const_is_empty
-
-    let _ = NON_EMPTY_SLICE.is_empty();
-    //~^ const_is_empty
-
-    let _ = NON_EMPTY_SLICE_REPEAT.is_empty();
-    //~^ const_is_empty
-}
-
 fn main() {
     let value = "foobar";
     let _ = value.is_empty();
@@ -120,7 +73,7 @@ fn main() {
 
 fn str_from_arg(var: &str) {
     var.is_empty();
-    // Do not lint, we know nothiny about var
+    // Do not lint, we know nothing about var
 }
 
 fn update_str() {
@@ -200,6 +153,5 @@ fn issue_13106() {
 
     const {
         EMPTY_STR.is_empty();
-        //~^ const_is_empty
     }
 }
diff --git a/tests/ui/const_is_empty.stderr b/tests/ui/const_is_empty.stderr
index 2ba189058e832..e1837695bc1c9 100644
--- a/tests/ui/const_is_empty.stderr
+++ b/tests/ui/const_is_empty.stderr
@@ -37,131 +37,35 @@ error: this expression always evaluates to false
 LL |     if non_empty2.is_empty() {
    |        ^^^^^^^^^^^^^^^^^^^^^
 
-error: this expression always evaluates to true
-  --> tests/ui/const_is_empty.rs:59:13
-   |
-LL |     let _ = EMPTY_STR.is_empty();
-   |             ^^^^^^^^^^^^^^^^^^^^
-
-error: this expression always evaluates to false
-  --> tests/ui/const_is_empty.rs:62:13
-   |
-LL |     let _ = NON_EMPTY_STR.is_empty();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: this expression always evaluates to true
-  --> tests/ui/const_is_empty.rs:65:13
-   |
-LL |     let _ = EMPTY_BSTR.is_empty();
-   |             ^^^^^^^^^^^^^^^^^^^^^
-
-error: this expression always evaluates to false
-  --> tests/ui/const_is_empty.rs:68:13
-   |
-LL |     let _ = NON_EMPTY_BSTR.is_empty();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: this expression always evaluates to true
-  --> tests/ui/const_is_empty.rs:71:13
-   |
-LL |     let _ = EMPTY_ARRAY.is_empty();
-   |             ^^^^^^^^^^^^^^^^^^^^^^
-
-error: this expression always evaluates to true
-  --> tests/ui/const_is_empty.rs:74:13
-   |
-LL |     let _ = EMPTY_ARRAY_REPEAT.is_empty();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: this expression always evaluates to true
-  --> tests/ui/const_is_empty.rs:77:13
-   |
-LL |     let _ = EMPTY_U8_SLICE.is_empty();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: this expression always evaluates to false
-  --> tests/ui/const_is_empty.rs:80:13
-   |
-LL |     let _ = NON_EMPTY_U8_SLICE.is_empty();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
 error: this expression always evaluates to false
-  --> tests/ui/const_is_empty.rs:83:13
-   |
-LL |     let _ = NON_EMPTY_ARRAY.is_empty();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: this expression always evaluates to false
-  --> tests/ui/const_is_empty.rs:86:13
-   |
-LL |     let _ = NON_EMPTY_ARRAY_REPEAT.is_empty();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: this expression always evaluates to true
-  --> tests/ui/const_is_empty.rs:89:13
-   |
-LL |     let _ = EMPTY_REF_ARRAY.is_empty();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: this expression always evaluates to false
-  --> tests/ui/const_is_empty.rs:92:13
-   |
-LL |     let _ = NON_EMPTY_REF_ARRAY.is_empty();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: this expression always evaluates to true
-  --> tests/ui/const_is_empty.rs:95:13
-   |
-LL |     let _ = EMPTY_SLICE.is_empty();
-   |             ^^^^^^^^^^^^^^^^^^^^^^
-
-error: this expression always evaluates to false
-  --> tests/ui/const_is_empty.rs:98:13
-   |
-LL |     let _ = NON_EMPTY_SLICE.is_empty();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: this expression always evaluates to false
-  --> tests/ui/const_is_empty.rs:101:13
-   |
-LL |     let _ = NON_EMPTY_SLICE_REPEAT.is_empty();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: this expression always evaluates to false
-  --> tests/ui/const_is_empty.rs:107:13
+  --> tests/ui/const_is_empty.rs:60:13
    |
 LL |     let _ = value.is_empty();
    |             ^^^^^^^^^^^^^^^^
 
 error: this expression always evaluates to false
-  --> tests/ui/const_is_empty.rs:111:13
+  --> tests/ui/const_is_empty.rs:64:13
    |
 LL |     let _ = x.is_empty();
    |             ^^^^^^^^^^^^
 
 error: this expression always evaluates to true
-  --> tests/ui/const_is_empty.rs:114:13
+  --> tests/ui/const_is_empty.rs:67:13
    |
 LL |     let _ = "".is_empty();
    |             ^^^^^^^^^^^^^
 
 error: this expression always evaluates to true
-  --> tests/ui/const_is_empty.rs:117:13
+  --> tests/ui/const_is_empty.rs:70:13
    |
 LL |     let _ = b"".is_empty();
    |             ^^^^^^^^^^^^^^
 
 error: this expression always evaluates to true
-  --> tests/ui/const_is_empty.rs:171:13
+  --> tests/ui/const_is_empty.rs:124:13
    |
 LL |     let _ = val.is_empty();
    |             ^^^^^^^^^^^^^^
 
-error: this expression always evaluates to true
-  --> tests/ui/const_is_empty.rs:202:9
-   |
-LL |         EMPTY_STR.is_empty();
-   |         ^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 27 previous errors
+error: aborting due to 11 previous errors
 

From 47b0f903a3b0e2a863f34a6bd1c33196f851c796 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 24 Aug 2025 10:38:06 -0400
Subject: [PATCH 1717/1889] Use `eval_local` in more places.

---
 clippy_lints/src/floating_point_arithmetic.rs |   6 +-
 clippy_lints/src/implicit_saturating_add.rs   |   5 +-
 clippy_lints/src/manual_float_methods.rs      |  29 +---
 clippy_lints/src/manual_rotate.rs             |   2 +-
 clippy_lints/src/manual_strip.rs              |  24 ++-
 clippy_lints/src/methods/ip_constant.rs       |   4 +-
 clippy_lints/src/methods/iter_nth_zero.rs     |   2 +-
 clippy_lints/src/methods/iter_skip_zero.rs    |  16 +-
 clippy_lints/src/methods/repeat_once.rs       |   2 +-
 clippy_lints/src/methods/str_splitn.rs        |   2 +-
 clippy_lints/src/minmax.rs                    |   6 +-
 clippy_lints/src/operators/duration_subsec.rs |   2 +-
 .../src/operators/modulo_arithmetic.rs        |   6 +-
 clippy_lints/src/ranges.rs                    |   2 +-
 clippy_utils/src/consts.rs                    |   8 +-
 tests/ui/duration_subsec.fixed                |   3 +-
 tests/ui/duration_subsec.rs                   |   1 -
 tests/ui/duration_subsec.stderr               |   8 +-
 tests/ui/floating_point_log.fixed             |   6 +-
 tests/ui/floating_point_log.rs                |   2 -
 tests/ui/floating_point_log.stderr            |  60 +++----
 tests/ui/ip_constant.fixed                    |  45 ++++--
 tests/ui/ip_constant.rs                       |   9 --
 tests/ui/ip_constant.stderr                   | 146 +-----------------
 tests/ui/manual_float_methods.rs              |  15 +-
 tests/ui/manual_float_methods.stderr          |  40 +----
 tests/ui/manual_strip.stderr                  |   3 -
 tests/ui/repeat_once.fixed                    |   3 +-
 tests/ui/repeat_once.rs                       |   1 -
 tests/ui/repeat_once.stderr                   |  14 +-
 30 files changed, 132 insertions(+), 340 deletions(-)

diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 3ecc232caff43..407a3f1306739 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -111,8 +111,8 @@ 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) = ConstEvalCtxt::new(cx).eval(base) {
+fn get_specialized_log_method(cx: &LateContext<'_>, base: &Expr<'_>, ctxt: SyntaxContext) -> Option<&'static str> {
+    if let Some(value) = ConstEvalCtxt::new(cx).eval_local(base, ctxt) {
         if F32(2.0) == value || F64(2.0) == value {
             return Some("log2");
         } else if F32(10.0) == value || F64(10.0) == value {
@@ -158,7 +158,7 @@ fn prepare_receiver_sugg<'a>(cx: &LateContext<'_>, mut expr: &'a Expr<'a>) -> Su
 }
 
 fn check_log_base(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>, args: &[Expr<'_>]) {
-    if let Some(method) = get_specialized_log_method(cx, &args[0]) {
+    if let Some(method) = get_specialized_log_method(cx, &args[0], expr.span.ctxt()) {
         span_lint_and_sugg(
             cx,
             SUBOPTIMAL_FLOPS,
diff --git a/clippy_lints/src/implicit_saturating_add.rs b/clippy_lints/src/implicit_saturating_add.rs
index 0fdbf67973813..4bf3a390b050c 100644
--- a/clippy_lints/src/implicit_saturating_add.rs
+++ b/clippy_lints/src/implicit_saturating_add.rs
@@ -117,10 +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 ecx = ConstEvalCtxt::new(cx);
-        if let Some(Constant::Int(c)) = ecx.eval(r) {
+        let ctxt = expr.span.ctxt();
+        if let Some(Constant::Int(c)) = ecx.eval_local(r, ctxt) {
             return Some((c, op.node, l));
         }
-        if let Some(Constant::Int(c)) = ecx.eval(l) {
+        if let Some(Constant::Int(c)) = ecx.eval_local(l, ctxt) {
             return Some((c, invert_op(op.node)?, r));
         }
     }
diff --git a/clippy_lints/src/manual_float_methods.rs b/clippy_lints/src/manual_float_methods.rs
index 7d6c30aa74ddd..60782f445ab91 100644
--- a/clippy_lints/src/manual_float_methods.rs
+++ b/clippy_lints/src/manual_float_methods.rs
@@ -1,5 +1,5 @@
 use clippy_config::Conf;
-use clippy_utils::consts::{ConstEvalCtxt, Constant};
+use clippy_utils::consts::ConstEvalCtxt;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::SpanRangeExt;
@@ -146,13 +146,14 @@ impl<'tcx> LateLintPass<'tcx> for ManualFloatMethods {
             )
             && let [first, second, const_1, const_2] = exprs
             && let ecx = ConstEvalCtxt::new(cx)
-            && let Some(const_1) = ecx.eval(const_1)
-            && let Some(const_2) = ecx.eval(const_2)
+            && let ctxt = expr.span.ctxt()
+            && let Some(const_1) = ecx.eval_local(const_1, ctxt)
+            && let Some(const_2) = ecx.eval_local(const_2, ctxt)
             && 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
-            && (is_infinity(&const_1) && is_neg_infinity(&const_2)
-                || is_neg_infinity(&const_1) && is_infinity(&const_2))
+            && (const_1.is_pos_infinity() && const_2.is_neg_infinity()
+                || const_1.is_neg_infinity() && const_2.is_pos_infinity())
             && let Some(local_snippet) = first.span.get_source_text(cx)
         {
             let variant = match (kind.node, lhs_kind.node, rhs_kind.node) {
@@ -201,21 +202,3 @@ impl<'tcx> LateLintPass<'tcx> for ManualFloatMethods {
         }
     }
 }
-
-fn is_infinity(constant: &Constant) -> bool {
-    match constant {
-        // FIXME(f16_f128): add f16 and f128 when constants are available
-        Constant::F32(float) => *float == f32::INFINITY,
-        Constant::F64(float) => *float == f64::INFINITY,
-        _ => false,
-    }
-}
-
-fn is_neg_infinity(constant: &Constant) -> bool {
-    match constant {
-        // FIXME(f16_f128): add f16 and f128 when constants are available
-        Constant::F32(float) => *float == f32::NEG_INFINITY,
-        Constant::F64(float) => *float == f64::NEG_INFINITY,
-        _ => false,
-    }
-}
diff --git a/clippy_lints/src/manual_rotate.rs b/clippy_lints/src/manual_rotate.rs
index 06ee00c2cef3c..22e3407303f07 100644
--- a/clippy_lints/src/manual_rotate.rs
+++ b/clippy_lints/src/manual_rotate.rs
@@ -66,7 +66,7 @@ fn parse_shift<'tcx>(
             BinOpKind::Shr => ShiftDirection::Right,
             _ => return None,
         };
-        let const_expr = ConstEvalCtxt::new(cx).eval(r)?;
+        let const_expr = ConstEvalCtxt::new(cx).eval_local(r, expr.span.ctxt())?;
         if let Constant::Int(shift) = const_expr {
             return Some((dir, shift, l));
         }
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index 07cce4046ca4f..f5d15310879a3 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -16,7 +16,7 @@ use rustc_lint::{LateContext, LateLintPass, LintContext as _};
 use rustc_middle::ty;
 use rustc_session::impl_lint_pass;
 use rustc_span::source_map::Spanned;
-use rustc_span::{Symbol, sym};
+use rustc_span::{Symbol, SyntaxContext, sym};
 use std::iter;
 
 declare_clippy_lint! {
@@ -92,7 +92,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualStrip {
                 return;
             }
 
-            let (strippings, bindings) = find_stripping(cx, strip_kind, target_res, pattern, then);
+            let (strippings, bindings) = find_stripping(cx, strip_kind, target_res, pattern, then, expr.span.ctxt());
             if !strippings.is_empty() && self.msrv.meets(cx, msrvs::STR_STRIP_PREFIX) {
                 let kind_word = match strip_kind {
                     StripKind::Prefix => "prefix",
@@ -166,8 +166,8 @@ 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 = ConstEvalCtxt::new(cx).eval(expr)?;
+fn constant_length(cx: &LateContext<'_>, expr: &Expr<'_>, ctxt: SyntaxContext) -> Option<u128> {
+    let value = ConstEvalCtxt::new(cx).eval_local(expr, ctxt)?;
     match value {
         Constant::Str(value) => Some(value.len() as u128),
         Constant::Char(value) => Some(value.len_utf8() as u128),
@@ -176,13 +176,18 @@ fn constant_length(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<u128> {
 }
 
 // Tests if `expr` equals the length of the pattern.
-fn eq_pattern_length<'tcx>(cx: &LateContext<'tcx>, pattern: &Expr<'_>, expr: &'tcx Expr<'_>) -> bool {
+fn eq_pattern_length<'tcx>(
+    cx: &LateContext<'tcx>,
+    pattern: &Expr<'_>,
+    expr: &'tcx Expr<'_>,
+    ctxt: SyntaxContext,
+) -> bool {
     if let ExprKind::Lit(Spanned {
         node: LitKind::Int(n, _),
         ..
     }) = expr.kind
     {
-        constant_length(cx, pattern).is_some_and(|length| n == length)
+        constant_length(cx, pattern, ctxt).is_some_and(|length| n == length)
     } else {
         len_arg(cx, expr).is_some_and(|arg| eq_expr_value(cx, pattern, arg))
     }
@@ -215,6 +220,7 @@ fn find_stripping<'tcx>(
     target: Res,
     pattern: &'tcx Expr<'_>,
     expr: &'tcx Expr<'tcx>,
+    ctxt: SyntaxContext,
 ) -> (Vec<&'tcx Expr<'tcx>>, FxHashMap<Symbol, usize>) {
     struct StrippingFinder<'a, 'tcx> {
         cx: &'a LateContext<'tcx>,
@@ -223,6 +229,7 @@ fn find_stripping<'tcx>(
         pattern: &'tcx Expr<'tcx>,
         results: Vec<&'tcx Expr<'tcx>>,
         bindings: FxHashMap<Symbol, usize>,
+        ctxt: SyntaxContext,
     }
 
     impl<'tcx> Visitor<'tcx> for StrippingFinder<'_, 'tcx> {
@@ -236,7 +243,7 @@ fn find_stripping<'tcx>(
             {
                 match (self.strip_kind, start, end) {
                     (StripKind::Prefix, Some(start), None) => {
-                        if eq_pattern_length(self.cx, self.pattern, start) {
+                        if eq_pattern_length(self.cx, self.pattern, start, self.ctxt) {
                             self.results.push(ex);
                             return;
                         }
@@ -252,7 +259,7 @@ fn find_stripping<'tcx>(
                             && let Some(left_arg) = len_arg(self.cx, left)
                             && let ExprKind::Path(left_path) = &left_arg.kind
                             && self.cx.qpath_res(left_path, left_arg.hir_id) == self.target
-                            && eq_pattern_length(self.cx, self.pattern, right)
+                            && eq_pattern_length(self.cx, self.pattern, right, self.ctxt)
                         {
                             self.results.push(ex);
                             return;
@@ -280,6 +287,7 @@ fn find_stripping<'tcx>(
         pattern,
         results: vec![],
         bindings: FxHashMap::default(),
+        ctxt,
     };
     walk_expr(&mut finder, expr);
     (finder.results, finder.bindings)
diff --git a/clippy_lints/src/methods/ip_constant.rs b/clippy_lints/src/methods/ip_constant.rs
index a2ac4e54334ee..bf602811009a2 100644
--- a/clippy_lints/src/methods/ip_constant.rs
+++ b/clippy_lints/src/methods/ip_constant.rs
@@ -17,10 +17,12 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, func: &Expr<'_>, args
             cx.tcx.get_diagnostic_name(func_def_id),
             Some(sym::Ipv4Addr | sym::Ipv6Addr)
         )
+        && let ecx = ConstEvalCtxt::new(cx)
+        && let ctxt = expr.span.ctxt()
         && let Some(args) = args
             .iter()
             .map(|arg| {
-                if let Some(Constant::Int(constant @ (0 | 1 | 127 | 255))) = ConstEvalCtxt::new(cx).eval(arg) {
+                if let Some(Constant::Int(constant @ (0 | 1 | 127 | 255))) = ecx.eval_local(arg, ctxt) {
                     u8::try_from(constant).ok()
                 } else {
                     None
diff --git a/clippy_lints/src/methods/iter_nth_zero.rs b/clippy_lints/src/methods/iter_nth_zero.rs
index 4bdf589f48762..0f8abd0172423 100644
--- a/clippy_lints/src/methods/iter_nth_zero.rs
+++ b/clippy_lints/src/methods/iter_nth_zero.rs
@@ -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)) = ConstEvalCtxt::new(cx).eval(arg)
+        && let Some(Constant::Int(0)) = ConstEvalCtxt::new(cx).eval_local(arg, expr.span.ctxt())
         && !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 39e440e784f6d..663e34437a307 100644
--- a/clippy_lints/src/methods/iter_skip_zero.rs
+++ b/clippy_lints/src/methods/iter_skip_zero.rs
@@ -11,13 +11,15 @@ 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) = ConstEvalCtxt::new(cx).eval(arg_expr).and_then(|constant| {
-            if let Constant::Int(arg) = constant {
-                Some(arg)
-            } else {
-                None
-            }
-        })
+        && let Some(arg) = ConstEvalCtxt::new(cx)
+            .eval_local(arg_expr, expr.span.ctxt())
+            .and_then(|constant| {
+                if let Constant::Int(arg) = constant {
+                    Some(arg)
+                } else {
+                    None
+                }
+            })
         && arg == 0
         && !is_from_proc_macro(cx, expr)
     {
diff --git a/clippy_lints/src/methods/repeat_once.rs b/clippy_lints/src/methods/repeat_once.rs
index 7837517ed5d8a..9111604ef53b7 100644
--- a/clippy_lints/src/methods/repeat_once.rs
+++ b/clippy_lints/src/methods/repeat_once.rs
@@ -14,7 +14,7 @@ pub(super) fn check<'tcx>(
     recv: &'tcx Expr<'_>,
     repeat_arg: &'tcx Expr<'_>,
 ) {
-    if ConstEvalCtxt::new(cx).eval(repeat_arg) == Some(Constant::Int(1)) {
+    if ConstEvalCtxt::new(cx).eval_local(repeat_arg, expr.span.ctxt()) == 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 51dd4ac313a6d..8daa5db887acf 100644
--- a/clippy_lints/src/methods/str_splitn.rs
+++ b/clippy_lints/src/methods/str_splitn.rs
@@ -304,7 +304,7 @@ fn parse_iter_usage<'tcx>(
                     };
                 },
                 (sym::nth | sym::skip, [idx_expr]) if cx.tcx.trait_of_assoc(did) == Some(iter_id) => {
-                    if let Some(Constant::Int(idx)) = ConstEvalCtxt::new(cx).eval(idx_expr) {
+                    if let Some(Constant::Int(idx)) = ConstEvalCtxt::new(cx).eval_local(idx_expr, ctxt) {
                         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/minmax.rs b/clippy_lints/src/minmax.rs
index 35b6af0c20f7f..f9a7c562c7a59 100644
--- a/clippy_lints/src/minmax.rs
+++ b/clippy_lints/src/minmax.rs
@@ -61,7 +61,7 @@ enum MinMax {
     Max,
 }
 
-fn min_max<'a, 'tcx>(cx: &LateContext<'tcx>, expr: &'a Expr<'a>) -> Option<(MinMax, Constant, &'a Expr<'a>)> {
+fn min_max<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<(MinMax, Constant, &'a Expr<'a>)> {
     match expr.kind {
         ExprKind::Call(path, args) => {
             if let ExprKind::Path(ref qpath) = path.kind {
@@ -92,8 +92,8 @@ fn min_max<'a, 'tcx>(cx: &LateContext<'tcx>, expr: &'a Expr<'a>) -> Option<(MinM
     }
 }
 
-fn fetch_const<'a, 'tcx>(
-    cx: &LateContext<'tcx>,
+fn fetch_const<'a>(
+    cx: &LateContext<'_>,
     ctxt: SyntaxContext,
     receiver: Option<&'a Expr<'a>>,
     args: &'a [Expr<'a>],
diff --git a/clippy_lints/src/operators/duration_subsec.rs b/clippy_lints/src/operators/duration_subsec.rs
index 6c9be7c5e90b3..d897b0e8dd918 100644
--- a/clippy_lints/src/operators/duration_subsec.rs
+++ b/clippy_lints/src/operators/duration_subsec.rs
@@ -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)) = ConstEvalCtxt::new(cx).eval(right)
+        && let Some(Constant::Int(divisor)) = ConstEvalCtxt::new(cx).eval_local(right, expr.span.ctxt())
     {
         let suggested_fn = match (method_path.ident.name, divisor) {
             (sym::subsec_micros, 1_000) | (sym::subsec_nanos, 1_000_000) => "subsec_millis",
diff --git a/clippy_lints/src/operators/modulo_arithmetic.rs b/clippy_lints/src/operators/modulo_arithmetic.rs
index b79461663d7bf..ffe91fc2cef6d 100644
--- a/clippy_lints/src/operators/modulo_arithmetic.rs
+++ b/clippy_lints/src/operators/modulo_arithmetic.rs
@@ -39,7 +39,9 @@ fn used_in_comparison_with_zero(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
         && let BinOpKind::Eq | BinOpKind::Ne = op.node
     {
         let ecx = ConstEvalCtxt::new(cx);
-        matches!(ecx.eval(lhs), Some(Constant::Int(0))) || matches!(ecx.eval(rhs), Some(Constant::Int(0)))
+        let ctxt = expr.span.ctxt();
+        matches!(ecx.eval_local(lhs, ctxt), Some(Constant::Int(0)))
+            || matches!(ecx.eval_local(rhs, ctxt), Some(Constant::Int(0)))
     } else {
         false
     }
@@ -55,7 +57,7 @@ fn analyze_operand(operand: &Expr<'_>, cx: &LateContext<'_>, expr: &Expr<'_>) ->
     match ConstEvalCtxt::new(cx).eval(operand)? {
         Constant::Int(v) => match *cx.typeck_results().expr_ty(expr).kind() {
             ty::Int(ity) => {
-                let value = sext(cx.tcx, v, ity);
+                let value: i128 = sext(cx.tcx, v, ity);
                 Some(OperandInfo {
                     string_representation: Some(value.to_string()),
                     is_negative: value < 0,
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 8a216afb82c9a..0b2313cb7eeb9 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -312,7 +312,7 @@ struct RangeBounds<'a> {
 // Takes a binary expression such as x <= 2 as input
 // Breaks apart into various pieces, such as the value of the number,
 // hir id of the variable, and direction/inclusiveness of the operator
-fn check_range_bounds<'a, 'tcx>(cx: &'a LateContext<'tcx>, ex: &'a Expr<'_>) -> Option<RangeBounds<'a>> {
+fn check_range_bounds<'a>(cx: &'a LateContext<'_>, ex: &'a Expr<'_>) -> Option<RangeBounds<'a>> {
     if let ExprKind::Binary(ref op, l, r) = ex.kind {
         let (inclusive, ordering) = match op.node {
             BinOpKind::Gt => (false, Ordering::Greater),
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index f5f3786164608..9ba796137cc3a 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -128,15 +128,11 @@ impl PartialEq for Constant {
             (&Self::Char(l), &Self::Char(r)) => l == r,
             (&Self::Int(l), &Self::Int(r)) => l == r,
             (&Self::F64(l), &Self::F64(r)) => {
-                // We want `Fw32 == FwAny` and `FwAny == Fw64`, and by transitivity we must have
-                // `Fw32 == Fw64`, so don’t compare them.
-                // `to_bits` is required to catch non-matching 0.0, -0.0, and NaNs.
+                // `to_bits` is required to catch non-matching `0.0` and `-0.0`.
                 l.to_bits() == r.to_bits() && !l.is_nan()
             },
             (&Self::F32(l), &Self::F32(r)) => {
-                // We want `Fw32 == FwAny` and `FwAny == Fw64`, and by transitivity we must have
-                // `Fw32 == Fw64`, so don’t compare them.
-                // `to_bits` is required to catch non-matching 0.0, -0.0, and NaNs.
+                // `to_bits` is required to catch non-matching `0.0` and `-0.0`.
                 l.to_bits() == r.to_bits() && !l.is_nan()
             },
             (&Self::Bool(l), &Self::Bool(r)) => l == r,
diff --git a/tests/ui/duration_subsec.fixed b/tests/ui/duration_subsec.fixed
index a8c2f78ca383a..b6b2d156c0e0f 100644
--- a/tests/ui/duration_subsec.fixed
+++ b/tests/ui/duration_subsec.fixed
@@ -25,8 +25,7 @@ fn main() {
 
     // Handle constants
     const NANOS_IN_MICRO: u32 = 1_000;
-    let _ = dur.subsec_micros();
-    //~^ duration_subsec
+    let _ = dur.subsec_nanos() / NANOS_IN_MICRO;
 
     // Other literals aren't linted
     let _ = dur.subsec_nanos() / 699;
diff --git a/tests/ui/duration_subsec.rs b/tests/ui/duration_subsec.rs
index 582f4717de27f..1061e6003c35e 100644
--- a/tests/ui/duration_subsec.rs
+++ b/tests/ui/duration_subsec.rs
@@ -26,7 +26,6 @@ fn main() {
     // Handle constants
     const NANOS_IN_MICRO: u32 = 1_000;
     let _ = dur.subsec_nanos() / NANOS_IN_MICRO;
-    //~^ duration_subsec
 
     // Other literals aren't linted
     let _ = dur.subsec_nanos() / 699;
diff --git a/tests/ui/duration_subsec.stderr b/tests/ui/duration_subsec.stderr
index 1a41742e1fa6d..27756bc1c20f6 100644
--- a/tests/ui/duration_subsec.stderr
+++ b/tests/ui/duration_subsec.stderr
@@ -25,11 +25,5 @@ error: calling `subsec_micros()` is more concise than this calculation
 LL |     let _ = (&dur).subsec_nanos() / 1_000;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(&dur).subsec_micros()`
 
-error: calling `subsec_micros()` is more concise than this calculation
-  --> tests/ui/duration_subsec.rs:28:13
-   |
-LL |     let _ = dur.subsec_nanos() / NANOS_IN_MICRO;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `dur.subsec_micros()`
-
-error: aborting due to 5 previous errors
+error: aborting due to 4 previous errors
 
diff --git a/tests/ui/floating_point_log.fixed b/tests/ui/floating_point_log.fixed
index 275c9b4a3ab9a..e831e30a71d81 100644
--- a/tests/ui/floating_point_log.fixed
+++ b/tests/ui/floating_point_log.fixed
@@ -14,10 +14,8 @@ fn check_log_base() {
     //~^ suboptimal_flops
     let _ = x.ln();
     //~^ suboptimal_flops
-    let _ = x.log2();
-    //~^ suboptimal_flops
-    let _ = x.ln();
-    //~^ suboptimal_flops
+    let _ = x.log(TWO);
+    let _ = x.log(E);
     let _ = (x as f32).log2();
     //~^ suboptimal_flops
 
diff --git a/tests/ui/floating_point_log.rs b/tests/ui/floating_point_log.rs
index a372ccbb9fb03..06cb1c8d96039 100644
--- a/tests/ui/floating_point_log.rs
+++ b/tests/ui/floating_point_log.rs
@@ -15,9 +15,7 @@ fn check_log_base() {
     let _ = x.log(std::f32::consts::E);
     //~^ suboptimal_flops
     let _ = x.log(TWO);
-    //~^ suboptimal_flops
     let _ = x.log(E);
-    //~^ suboptimal_flops
     let _ = (x as f32).log(2f32);
     //~^ suboptimal_flops
 
diff --git a/tests/ui/floating_point_log.stderr b/tests/ui/floating_point_log.stderr
index e93b3af851cbe..3e141de626d94 100644
--- a/tests/ui/floating_point_log.stderr
+++ b/tests/ui/floating_point_log.stderr
@@ -19,44 +19,32 @@ error: logarithm for bases 2, 10 and e can be computed more accurately
 LL |     let _ = x.log(std::f32::consts::E);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.ln()`
 
-error: logarithm for bases 2, 10 and e can be computed more accurately
-  --> tests/ui/floating_point_log.rs:17:13
-   |
-LL |     let _ = x.log(TWO);
-   |             ^^^^^^^^^^ help: consider using: `x.log2()`
-
 error: logarithm for bases 2, 10 and e can be computed more accurately
   --> tests/ui/floating_point_log.rs:19:13
    |
-LL |     let _ = x.log(E);
-   |             ^^^^^^^^ help: consider using: `x.ln()`
-
-error: logarithm for bases 2, 10 and e can be computed more accurately
-  --> tests/ui/floating_point_log.rs:21:13
-   |
 LL |     let _ = (x as f32).log(2f32);
    |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x as f32).log2()`
 
 error: logarithm for bases 2, 10 and e can be computed more accurately
-  --> tests/ui/floating_point_log.rs:25:13
+  --> tests/ui/floating_point_log.rs:23:13
    |
 LL |     let _ = x.log(2f64);
    |             ^^^^^^^^^^^ help: consider using: `x.log2()`
 
 error: logarithm for bases 2, 10 and e can be computed more accurately
-  --> tests/ui/floating_point_log.rs:27:13
+  --> tests/ui/floating_point_log.rs:25:13
    |
 LL |     let _ = x.log(10f64);
    |             ^^^^^^^^^^^^ help: consider using: `x.log10()`
 
 error: logarithm for bases 2, 10 and e can be computed more accurately
-  --> tests/ui/floating_point_log.rs:29:13
+  --> tests/ui/floating_point_log.rs:27:13
    |
 LL |     let _ = x.log(std::f64::consts::E);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.ln()`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:35:13
+  --> tests/ui/floating_point_log.rs:33:13
    |
 LL |     let _ = (1f32 + 2.).ln();
    |             ^^^^^^^^^^^^^^^^ help: consider using: `2.0f32.ln_1p()`
@@ -65,118 +53,118 @@ LL |     let _ = (1f32 + 2.).ln();
    = help: to override `-D warnings` add `#[allow(clippy::imprecise_flops)]`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:37:13
+  --> tests/ui/floating_point_log.rs:35:13
    |
 LL |     let _ = (1f32 + 2.0).ln();
    |             ^^^^^^^^^^^^^^^^^ help: consider using: `2.0f32.ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:39:13
+  --> tests/ui/floating_point_log.rs:37:13
    |
 LL |     let _ = (1.0 + x).ln();
    |             ^^^^^^^^^^^^^^ help: consider using: `x.ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:41:13
+  --> tests/ui/floating_point_log.rs:39:13
    |
 LL |     let _ = (1.0 + x / 2.0).ln();
    |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x / 2.0).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:43:13
+  --> tests/ui/floating_point_log.rs:41:13
    |
 LL |     let _ = (1.0 + x.powi(3)).ln();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(3).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:45:13
+  --> tests/ui/floating_point_log.rs:43:13
    |
 LL |     let _ = (1.0 + x.powi(3) / 2.0).ln();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x.powi(3) / 2.0).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:47:13
+  --> tests/ui/floating_point_log.rs:45:13
    |
 LL |     let _ = (1.0 + (std::f32::consts::E - 1.0)).ln();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(std::f32::consts::E - 1.0).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:49:13
+  --> tests/ui/floating_point_log.rs:47:13
    |
 LL |     let _ = (x + 1.0).ln();
    |             ^^^^^^^^^^^^^^ help: consider using: `x.ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:51:13
+  --> tests/ui/floating_point_log.rs:49:13
    |
 LL |     let _ = (x.powi(3) + 1.0).ln();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(3).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:53:13
+  --> tests/ui/floating_point_log.rs:51:13
    |
 LL |     let _ = (x + 2.0 + 1.0).ln();
    |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x + 2.0).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:55:13
+  --> tests/ui/floating_point_log.rs:53:13
    |
 LL |     let _ = (x / 2.0 + 1.0).ln();
    |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x / 2.0).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:64:13
+  --> tests/ui/floating_point_log.rs:62:13
    |
 LL |     let _ = (1f64 + 2.).ln();
    |             ^^^^^^^^^^^^^^^^ help: consider using: `2.0f64.ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:66:13
+  --> tests/ui/floating_point_log.rs:64:13
    |
 LL |     let _ = (1f64 + 2.0).ln();
    |             ^^^^^^^^^^^^^^^^^ help: consider using: `2.0f64.ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:68:13
+  --> tests/ui/floating_point_log.rs:66:13
    |
 LL |     let _ = (1.0 + x).ln();
    |             ^^^^^^^^^^^^^^ help: consider using: `x.ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:70:13
+  --> tests/ui/floating_point_log.rs:68:13
    |
 LL |     let _ = (1.0 + x / 2.0).ln();
    |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x / 2.0).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:72:13
+  --> tests/ui/floating_point_log.rs:70:13
    |
 LL |     let _ = (1.0 + x.powi(3)).ln();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(3).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:74:13
+  --> tests/ui/floating_point_log.rs:72:13
    |
 LL |     let _ = (x + 1.0).ln();
    |             ^^^^^^^^^^^^^^ help: consider using: `x.ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:76:13
+  --> tests/ui/floating_point_log.rs:74:13
    |
 LL |     let _ = (x.powi(3) + 1.0).ln();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(3).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:78:13
+  --> tests/ui/floating_point_log.rs:76:13
    |
 LL |     let _ = (x + 2.0 + 1.0).ln();
    |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x + 2.0).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:80:13
+  --> tests/ui/floating_point_log.rs:78:13
    |
 LL |     let _ = (x / 2.0 + 1.0).ln();
    |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x / 2.0).ln_1p()`
 
-error: aborting due to 29 previous errors
+error: aborting due to 27 previous errors
 
diff --git a/tests/ui/ip_constant.fixed b/tests/ui/ip_constant.fixed
index c947968213948..afdf581bacf7a 100644
--- a/tests/ui/ip_constant.fixed
+++ b/tests/ui/ip_constant.fixed
@@ -72,33 +72,44 @@ const CONST_U16_1: u16 = 1;
 
 fn const_test1() {
     use std::net::Ipv4Addr;
-    let _ = Ipv4Addr::LOCALHOST;
-    //~^ ip_constant
-    let _ = Ipv4Addr::BROADCAST;
-    //~^ ip_constant
-    let _ = Ipv4Addr::UNSPECIFIED;
-    //~^ ip_constant
+    let _ = Ipv4Addr::new(CONST_U8_127, CONST_U8_0, CONST_U8_0, CONST_U8_1);
+    let _ = Ipv4Addr::new(CONST_U8_255, CONST_U8_255, CONST_U8_255, CONST_U8_255);
+    let _ = Ipv4Addr::new(CONST_U8_0, CONST_U8_0, CONST_U8_0, CONST_U8_0);
 
     use std::net::Ipv6Addr;
-    let _ = Ipv6Addr::LOCALHOST;
-
-    let _ = Ipv6Addr::UNSPECIFIED;
+    let _ = Ipv6Addr::new(
+        CONST_U16_0,
+        CONST_U16_0,
+        CONST_U16_0,
+        CONST_U16_0,
+        CONST_U16_0,
+        CONST_U16_0,
+        CONST_U16_0,
+        CONST_U16_1,
+    );
+
+    let _ = Ipv6Addr::new(
+        CONST_U16_0,
+        CONST_U16_0,
+        CONST_U16_0,
+        CONST_U16_0,
+        CONST_U16_0,
+        CONST_U16_0,
+        CONST_U16_0,
+        CONST_U16_0,
+    );
 }
 
 fn const_test2() {
     use std::net::Ipv4Addr;
     let _ = Ipv4Addr::LOCALHOST;
     //~^ ip_constant
-    let _ = Ipv4Addr::BROADCAST;
-    //~^ ip_constant
-    let _ = Ipv4Addr::UNSPECIFIED;
-    //~^ ip_constant
+    let _ = Ipv4Addr::new(254 + CONST_U8_1, 255, { 255 - CONST_U8_0 }, CONST_U8_255);
+    let _ = Ipv4Addr::new(0, CONST_U8_255 - 255, 0, { 1 + 0 - 1 });
 
     use std::net::Ipv6Addr;
-    let _ = Ipv6Addr::LOCALHOST;
-    //~^ ip_constant
-    let _ = Ipv6Addr::LOCALHOST;
-    //~^ ip_constant
+    let _ = Ipv6Addr::new(0 + CONST_U16_0, 0, 0, 0, 0, 0, 0, 1);
+    let _ = Ipv6Addr::new(0 + 0, 0, 0, 0, 0, { 2 - 1 - CONST_U16_1 }, 0, 1);
 }
 
 macro_rules! ipv4_new {
diff --git a/tests/ui/ip_constant.rs b/tests/ui/ip_constant.rs
index 69a5c3b4e9230..04fc2f0f6fdae 100644
--- a/tests/ui/ip_constant.rs
+++ b/tests/ui/ip_constant.rs
@@ -73,15 +73,11 @@ const CONST_U16_1: u16 = 1;
 fn const_test1() {
     use std::net::Ipv4Addr;
     let _ = Ipv4Addr::new(CONST_U8_127, CONST_U8_0, CONST_U8_0, CONST_U8_1);
-    //~^ ip_constant
     let _ = Ipv4Addr::new(CONST_U8_255, CONST_U8_255, CONST_U8_255, CONST_U8_255);
-    //~^ ip_constant
     let _ = Ipv4Addr::new(CONST_U8_0, CONST_U8_0, CONST_U8_0, CONST_U8_0);
-    //~^ ip_constant
 
     use std::net::Ipv6Addr;
     let _ = Ipv6Addr::new(
-        //~^ ip_constant
         CONST_U16_0,
         CONST_U16_0,
         CONST_U16_0,
@@ -93,7 +89,6 @@ fn const_test1() {
     );
 
     let _ = Ipv6Addr::new(
-        //~^ ip_constant
         CONST_U16_0,
         CONST_U16_0,
         CONST_U16_0,
@@ -110,15 +105,11 @@ fn const_test2() {
     let _ = Ipv4Addr::new(126 + 1, 0, 0, 1);
     //~^ ip_constant
     let _ = Ipv4Addr::new(254 + CONST_U8_1, 255, { 255 - CONST_U8_0 }, CONST_U8_255);
-    //~^ ip_constant
     let _ = Ipv4Addr::new(0, CONST_U8_255 - 255, 0, { 1 + 0 - 1 });
-    //~^ ip_constant
 
     use std::net::Ipv6Addr;
     let _ = Ipv6Addr::new(0 + CONST_U16_0, 0, 0, 0, 0, 0, 0, 1);
-    //~^ ip_constant
     let _ = Ipv6Addr::new(0 + 0, 0, 0, 0, 0, { 2 - 1 - CONST_U16_1 }, 0, 1);
-    //~^ ip_constant
 }
 
 macro_rules! ipv4_new {
diff --git a/tests/ui/ip_constant.stderr b/tests/ui/ip_constant.stderr
index 07d912b18a57b..44e3d6448dbd8 100644
--- a/tests/ui/ip_constant.stderr
+++ b/tests/ui/ip_constant.stderr
@@ -241,101 +241,7 @@ LL +     let _ = std::net::Ipv6Addr::UNSPECIFIED;
    |
 
 error: hand-coded well-known IP address
-  --> tests/ui/ip_constant.rs:75:13
-   |
-LL |     let _ = Ipv4Addr::new(CONST_U8_127, CONST_U8_0, CONST_U8_0, CONST_U8_1);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: use
-   |
-LL -     let _ = Ipv4Addr::new(CONST_U8_127, CONST_U8_0, CONST_U8_0, CONST_U8_1);
-LL +     let _ = Ipv4Addr::LOCALHOST;
-   |
-
-error: hand-coded well-known IP address
-  --> tests/ui/ip_constant.rs:77:13
-   |
-LL |     let _ = Ipv4Addr::new(CONST_U8_255, CONST_U8_255, CONST_U8_255, CONST_U8_255);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: use
-   |
-LL -     let _ = Ipv4Addr::new(CONST_U8_255, CONST_U8_255, CONST_U8_255, CONST_U8_255);
-LL +     let _ = Ipv4Addr::BROADCAST;
-   |
-
-error: hand-coded well-known IP address
-  --> tests/ui/ip_constant.rs:79:13
-   |
-LL |     let _ = Ipv4Addr::new(CONST_U8_0, CONST_U8_0, CONST_U8_0, CONST_U8_0);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: use
-   |
-LL -     let _ = Ipv4Addr::new(CONST_U8_0, CONST_U8_0, CONST_U8_0, CONST_U8_0);
-LL +     let _ = Ipv4Addr::UNSPECIFIED;
-   |
-
-error: hand-coded well-known IP address
-  --> tests/ui/ip_constant.rs:83:13
-   |
-LL |       let _ = Ipv6Addr::new(
-   |  _____________^
-LL | |
-LL | |         CONST_U16_0,
-LL | |         CONST_U16_0,
-...  |
-LL | |         CONST_U16_1,
-LL | |     );
-   | |_____^
-   |
-help: use
-   |
-LL -     let _ = Ipv6Addr::new(
-LL -
-LL -         CONST_U16_0,
-LL -         CONST_U16_0,
-LL -         CONST_U16_0,
-LL -         CONST_U16_0,
-LL -         CONST_U16_0,
-LL -         CONST_U16_0,
-LL -         CONST_U16_0,
-LL -         CONST_U16_1,
-LL -     );
-LL +     let _ = Ipv6Addr::LOCALHOST;
-   |
-
-error: hand-coded well-known IP address
-  --> tests/ui/ip_constant.rs:95:13
-   |
-LL |       let _ = Ipv6Addr::new(
-   |  _____________^
-LL | |
-LL | |         CONST_U16_0,
-LL | |         CONST_U16_0,
-...  |
-LL | |         CONST_U16_0,
-LL | |     );
-   | |_____^
-   |
-help: use
-   |
-LL -     let _ = Ipv6Addr::new(
-LL -
-LL -         CONST_U16_0,
-LL -         CONST_U16_0,
-LL -         CONST_U16_0,
-LL -         CONST_U16_0,
-LL -         CONST_U16_0,
-LL -         CONST_U16_0,
-LL -         CONST_U16_0,
-LL -         CONST_U16_0,
-LL -     );
-LL +     let _ = Ipv6Addr::UNSPECIFIED;
-   |
-
-error: hand-coded well-known IP address
-  --> tests/ui/ip_constant.rs:110:13
+  --> tests/ui/ip_constant.rs:105:13
    |
 LL |     let _ = Ipv4Addr::new(126 + 1, 0, 0, 1);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -346,53 +252,5 @@ LL -     let _ = Ipv4Addr::new(126 + 1, 0, 0, 1);
 LL +     let _ = Ipv4Addr::LOCALHOST;
    |
 
-error: hand-coded well-known IP address
-  --> tests/ui/ip_constant.rs:112:13
-   |
-LL |     let _ = Ipv4Addr::new(254 + CONST_U8_1, 255, { 255 - CONST_U8_0 }, CONST_U8_255);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: use
-   |
-LL -     let _ = Ipv4Addr::new(254 + CONST_U8_1, 255, { 255 - CONST_U8_0 }, CONST_U8_255);
-LL +     let _ = Ipv4Addr::BROADCAST;
-   |
-
-error: hand-coded well-known IP address
-  --> tests/ui/ip_constant.rs:114:13
-   |
-LL |     let _ = Ipv4Addr::new(0, CONST_U8_255 - 255, 0, { 1 + 0 - 1 });
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: use
-   |
-LL -     let _ = Ipv4Addr::new(0, CONST_U8_255 - 255, 0, { 1 + 0 - 1 });
-LL +     let _ = Ipv4Addr::UNSPECIFIED;
-   |
-
-error: hand-coded well-known IP address
-  --> tests/ui/ip_constant.rs:118:13
-   |
-LL |     let _ = Ipv6Addr::new(0 + CONST_U16_0, 0, 0, 0, 0, 0, 0, 1);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: use
-   |
-LL -     let _ = Ipv6Addr::new(0 + CONST_U16_0, 0, 0, 0, 0, 0, 0, 1);
-LL +     let _ = Ipv6Addr::LOCALHOST;
-   |
-
-error: hand-coded well-known IP address
-  --> tests/ui/ip_constant.rs:120:13
-   |
-LL |     let _ = Ipv6Addr::new(0 + 0, 0, 0, 0, 0, { 2 - 1 - CONST_U16_1 }, 0, 1);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: use
-   |
-LL -     let _ = Ipv6Addr::new(0 + 0, 0, 0, 0, 0, { 2 - 1 - CONST_U16_1 }, 0, 1);
-LL +     let _ = Ipv6Addr::LOCALHOST;
-   |
-
-error: aborting due to 30 previous errors
+error: aborting due to 21 previous errors
 
diff --git a/tests/ui/manual_float_methods.rs b/tests/ui/manual_float_methods.rs
index 62cdc1c141d0c..4b496a4932833 100644
--- a/tests/ui/manual_float_methods.rs
+++ b/tests/ui/manual_float_methods.rs
@@ -8,9 +8,6 @@
 #[macro_use]
 extern crate proc_macros;
 
-const INFINITE: f32 = f32::INFINITY;
-const NEG_INFINITE: f32 = f32::NEG_INFINITY;
-
 fn fn_test() -> f64 {
     f64::NEG_INFINITY
 }
@@ -25,10 +22,6 @@ fn main() {
     //~^ manual_is_infinite
     if x != f32::INFINITY && x != f32::NEG_INFINITY {}
     //~^ manual_is_finite
-    if x == INFINITE || x == NEG_INFINITE {}
-    //~^ manual_is_infinite
-    if x != INFINITE && x != NEG_INFINITE {}
-    //~^ manual_is_finite
     let x = 1.0f64;
     if x == f64::INFINITY || x == f64::NEG_INFINITY {}
     //~^ manual_is_infinite
@@ -64,4 +57,12 @@ fn main() {
         if x == f32::INFINITY || x == f32::NEG_INFINITY {}
         if x != f32::INFINITY && x != f32::NEG_INFINITY {}
     }
+
+    {
+        let x = 1.0f32;
+        const X: f32 = f32::INFINITY;
+        const Y: f32 = f32::NEG_INFINITY;
+        if x == X || x == Y {}
+        if x != X && x != Y {}
+    }
 }
diff --git a/tests/ui/manual_float_methods.stderr b/tests/ui/manual_float_methods.stderr
index 352c879c87d73..0a27e0eac48b3 100644
--- a/tests/ui/manual_float_methods.stderr
+++ b/tests/ui/manual_float_methods.stderr
@@ -1,5 +1,5 @@
 error: manually checking if a float is infinite
-  --> tests/ui/manual_float_methods.rs:24:8
+  --> tests/ui/manual_float_methods.rs:21:8
    |
 LL |     if x == f32::INFINITY || x == f32::NEG_INFINITY {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the dedicated method instead: `x.is_infinite()`
@@ -8,7 +8,7 @@ LL |     if x == f32::INFINITY || x == f32::NEG_INFINITY {}
    = help: to override `-D warnings` add `#[allow(clippy::manual_is_infinite)]`
 
 error: manually checking if a float is finite
-  --> tests/ui/manual_float_methods.rs:26:8
+  --> tests/ui/manual_float_methods.rs:23:8
    |
 LL |     if x != f32::INFINITY && x != f32::NEG_INFINITY {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -32,41 +32,13 @@ LL +     if !x.is_infinite() {}
    |
 
 error: manually checking if a float is infinite
-  --> tests/ui/manual_float_methods.rs:28:8
-   |
-LL |     if x == INFINITE || x == NEG_INFINITE {}
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the dedicated method instead: `x.is_infinite()`
-
-error: manually checking if a float is finite
-  --> tests/ui/manual_float_methods.rs:30:8
-   |
-LL |     if x != INFINITE && x != NEG_INFINITE {}
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: use the dedicated method instead
-   |
-LL -     if x != INFINITE && x != NEG_INFINITE {}
-LL +     if x.is_finite() {}
-   |
-help: this will alter how it handles NaN; if that is a problem, use instead
-   |
-LL -     if x != INFINITE && x != NEG_INFINITE {}
-LL +     if x.is_finite() || x.is_nan() {}
-   |
-help: or, for conciseness
-   |
-LL -     if x != INFINITE && x != NEG_INFINITE {}
-LL +     if !x.is_infinite() {}
-   |
-
-error: manually checking if a float is infinite
-  --> tests/ui/manual_float_methods.rs:33:8
+  --> tests/ui/manual_float_methods.rs:26:8
    |
 LL |     if x == f64::INFINITY || x == f64::NEG_INFINITY {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the dedicated method instead: `x.is_infinite()`
 
 error: manually checking if a float is finite
-  --> tests/ui/manual_float_methods.rs:35:8
+  --> tests/ui/manual_float_methods.rs:28:8
    |
 LL |     if x != f64::INFINITY && x != f64::NEG_INFINITY {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -88,10 +60,10 @@ LL +     if !x.is_infinite() {}
    |
 
 error: manually checking if a float is infinite
-  --> tests/ui/manual_float_methods.rs:50:12
+  --> tests/ui/manual_float_methods.rs:43:12
    |
 LL |         if x == f64::INFINITY || x == f64::NEG_INFINITY {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the dedicated method instead: `x.is_infinite()`
 
-error: aborting due to 7 previous errors
+error: aborting due to 5 previous errors
 
diff --git a/tests/ui/manual_strip.stderr b/tests/ui/manual_strip.stderr
index a323ef700e767..d147cdae1f3b1 100644
--- a/tests/ui/manual_strip.stderr
+++ b/tests/ui/manual_strip.stderr
@@ -97,9 +97,6 @@ LL |     if s.starts_with(PREFIX) {
 help: try using the `strip_prefix` method
    |
 LL ~     if let Some(<stripped>) = s.strip_prefix(PREFIX) {
-LL ~         str::to_string(<stripped>);
-LL |
-LL |
 LL ~         str::to_string(<stripped>);
    |
 
diff --git a/tests/ui/repeat_once.fixed b/tests/ui/repeat_once.fixed
index e739e176f0acd..c08d630a32f7f 100644
--- a/tests/ui/repeat_once.fixed
+++ b/tests/ui/repeat_once.fixed
@@ -10,8 +10,7 @@ fn main() {
     //~^ repeat_once
     let b = slice.to_vec();
     //~^ repeat_once
-    let c = "hello".to_string();
-    //~^ repeat_once
+    let c = "hello".repeat(N);
     let d = "hi".to_string();
     //~^ repeat_once
     let e = s.to_string();
diff --git a/tests/ui/repeat_once.rs b/tests/ui/repeat_once.rs
index 89ab94bbaee85..d967fdc466ed7 100644
--- a/tests/ui/repeat_once.rs
+++ b/tests/ui/repeat_once.rs
@@ -11,7 +11,6 @@ fn main() {
     let b = slice.repeat(1);
     //~^ repeat_once
     let c = "hello".repeat(N);
-    //~^ repeat_once
     let d = "hi".repeat(1);
     //~^ repeat_once
     let e = s.repeat(1);
diff --git a/tests/ui/repeat_once.stderr b/tests/ui/repeat_once.stderr
index 3db7a3568f8e6..62dbf7d233759 100644
--- a/tests/ui/repeat_once.stderr
+++ b/tests/ui/repeat_once.stderr
@@ -14,28 +14,22 @@ LL |     let b = slice.repeat(1);
    |             ^^^^^^^^^^^^^^^ help: consider using `.to_vec()` instead: `slice.to_vec()`
 
 error: calling `repeat(1)` on str
-  --> tests/ui/repeat_once.rs:13:13
-   |
-LL |     let c = "hello".repeat(N);
-   |             ^^^^^^^^^^^^^^^^^ help: consider using `.to_string()` instead: `"hello".to_string()`
-
-error: calling `repeat(1)` on str
-  --> tests/ui/repeat_once.rs:15:13
+  --> tests/ui/repeat_once.rs:14:13
    |
 LL |     let d = "hi".repeat(1);
    |             ^^^^^^^^^^^^^^ help: consider using `.to_string()` instead: `"hi".to_string()`
 
 error: calling `repeat(1)` on str
-  --> tests/ui/repeat_once.rs:17:13
+  --> tests/ui/repeat_once.rs:16:13
    |
 LL |     let e = s.repeat(1);
    |             ^^^^^^^^^^^ help: consider using `.to_string()` instead: `s.to_string()`
 
 error: calling `repeat(1)` on a string literal
-  --> tests/ui/repeat_once.rs:19:13
+  --> tests/ui/repeat_once.rs:18:13
    |
 LL |     let f = string.repeat(1);
    |             ^^^^^^^^^^^^^^^^ help: consider using `.clone()` instead: `string.clone()`
 
-error: aborting due to 6 previous errors
+error: aborting due to 5 previous errors
 

From 11802781f7afc504f926c09a324ac5065a1746dc Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Wed, 2 Jul 2025 12:33:37 +0000
Subject: [PATCH 1718/1889] Make Value Copy by arena-allocating vectors.

---
 compiler/rustc_mir_transform/src/gvn.rs | 129 ++++++++++++------------
 1 file changed, 66 insertions(+), 63 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index 3ff8dc6dbb378..da36c3e6926ba 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -91,6 +91,7 @@ use either::Either;
 use hashbrown::hash_table::{Entry, HashTable};
 use itertools::Itertools as _;
 use rustc_abi::{self as abi, BackendRepr, FIRST_VARIANT, FieldIdx, Primitive, Size, VariantIdx};
+use rustc_arena::DroplessArena;
 use rustc_const_eval::const_eval::DummyMachine;
 use rustc_const_eval::interpret::{
     ImmTy, Immediate, InterpCx, MemPlaceMeta, MemoryKind, OpTy, Projectable, Scalar,
@@ -129,7 +130,9 @@ impl<'tcx> crate::MirPass<'tcx> for GVN {
         // Clone dominators because we need them while mutating the body.
         let dominators = body.basic_blocks.dominators().clone();
 
-        let mut state = VnState::new(tcx, body, typing_env, &ssa, dominators, &body.local_decls);
+        let arena = DroplessArena::default();
+        let mut state =
+            VnState::new(tcx, body, typing_env, &ssa, dominators, &body.local_decls, &arena);
 
         for local in body.args_iter().filter(|&local| ssa.is_ssa(local)) {
             let opaque = state.new_opaque(body.local_decls[local].ty);
@@ -183,8 +186,8 @@ enum AddressKind {
     Address(RawPtrKind),
 }
 
-#[derive(Debug, PartialEq, Eq, Hash)]
-enum Value<'tcx> {
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+enum Value<'a, 'tcx> {
     // Root values.
     /// Used to represent values we know nothing about.
     /// The `usize` is a counter incremented by `new_opaque`.
@@ -201,7 +204,7 @@ enum Value<'tcx> {
     // Aggregates.
     /// An aggregate value, either tuple/closure/struct/enum.
     /// This does not contain unions, as we cannot reason with the value.
-    Aggregate(VariantIdx, Vec<VnIndex>),
+    Aggregate(VariantIdx, &'a [VnIndex]),
     /// A raw pointer aggregate built from a thin pointer and metadata.
     RawPtr {
         /// Thin pointer component. This is field 0 in MIR.
@@ -240,15 +243,15 @@ enum Value<'tcx> {
 /// This data structure is mostly a partial reimplementation of `FxIndexMap<VnIndex, (Value, Ty)>`.
 /// We do not use a regular `FxIndexMap` to skip hashing values that are unique by construction,
 /// like opaque values, address with provenance and non-deterministic constants.
-struct ValueSet<'tcx> {
+struct ValueSet<'a, 'tcx> {
     indices: HashTable<VnIndex>,
     hashes: IndexVec<VnIndex, u64>,
-    values: IndexVec<VnIndex, Value<'tcx>>,
+    values: IndexVec<VnIndex, Value<'a, 'tcx>>,
     types: IndexVec<VnIndex, Ty<'tcx>>,
 }
 
-impl<'tcx> ValueSet<'tcx> {
-    fn new(num_values: usize) -> ValueSet<'tcx> {
+impl<'a, 'tcx> ValueSet<'a, 'tcx> {
+    fn new(num_values: usize) -> ValueSet<'a, 'tcx> {
         ValueSet {
             indices: HashTable::with_capacity(num_values),
             hashes: IndexVec::with_capacity(num_values),
@@ -263,7 +266,7 @@ impl<'tcx> ValueSet<'tcx> {
     fn insert_unique(
         &mut self,
         ty: Ty<'tcx>,
-        value: impl FnOnce(VnOpaque) -> Value<'tcx>,
+        value: impl FnOnce(VnOpaque) -> Value<'a, 'tcx>,
     ) -> VnIndex {
         let value = value(VnOpaque);
 
@@ -284,7 +287,7 @@ impl<'tcx> ValueSet<'tcx> {
     /// Insert a `(Value, Ty)` pair to be deduplicated.
     /// Returns `true` as second tuple field if this value did not exist previously.
     #[allow(rustc::pass_by_value)] // closures take `&VnIndex`
-    fn insert(&mut self, ty: Ty<'tcx>, value: Value<'tcx>) -> (VnIndex, bool) {
+    fn insert(&mut self, ty: Ty<'tcx>, value: Value<'a, 'tcx>) -> (VnIndex, bool) {
         debug_assert!(match value {
             Value::Opaque(_) | Value::Address { .. } => false,
             Value::Constant { disambiguator, .. } => disambiguator.is_none(),
@@ -319,8 +322,8 @@ impl<'tcx> ValueSet<'tcx> {
 
     /// Return the `Value` associated with the given `VnIndex`.
     #[inline]
-    fn value(&self, index: VnIndex) -> &Value<'tcx> {
-        &self.values[index]
+    fn value(&self, index: VnIndex) -> Value<'a, 'tcx> {
+        self.values[index]
     }
 
     /// Return the type associated with the given `VnIndex`.
@@ -336,7 +339,7 @@ impl<'tcx> ValueSet<'tcx> {
     }
 }
 
-struct VnState<'body, 'tcx> {
+struct VnState<'body, 'a, 'tcx> {
     tcx: TyCtxt<'tcx>,
     ecx: InterpCx<'tcx, DummyMachine>,
     local_decls: &'body LocalDecls<'tcx>,
@@ -346,7 +349,7 @@ struct VnState<'body, 'tcx> {
     /// Locals that are assigned that value.
     // This vector does not hold all the values of `VnIndex` that we create.
     rev_locals: IndexVec<VnIndex, SmallVec<[Local; 1]>>,
-    values: ValueSet<'tcx>,
+    values: ValueSet<'a, 'tcx>,
     /// Values evaluated as constants if possible.
     evaluated: IndexVec<VnIndex, Option<OpTy<'tcx>>>,
     /// Cache the deref values.
@@ -354,9 +357,10 @@ struct VnState<'body, 'tcx> {
     ssa: &'body SsaLocals,
     dominators: Dominators<BasicBlock>,
     reused_locals: DenseBitSet<Local>,
+    arena: &'a DroplessArena,
 }
 
-impl<'body, 'tcx> VnState<'body, 'tcx> {
+impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
     fn new(
         tcx: TyCtxt<'tcx>,
         body: &Body<'tcx>,
@@ -364,6 +368,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
         ssa: &'body SsaLocals,
         dominators: Dominators<BasicBlock>,
         local_decls: &'body LocalDecls<'tcx>,
+        arena: &'a DroplessArena,
     ) -> Self {
         // Compute a rough estimate of the number of values in the body from the number of
         // statements. This is meant to reduce the number of allocations, but it's all right if
@@ -385,6 +390,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             ssa,
             dominators,
             reused_locals: DenseBitSet::new_empty(local_decls.len()),
+            arena,
         }
     }
 
@@ -393,7 +399,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
     }
 
     #[instrument(level = "trace", skip(self), ret)]
-    fn insert(&mut self, ty: Ty<'tcx>, value: Value<'tcx>) -> VnIndex {
+    fn insert(&mut self, ty: Ty<'tcx>, value: Value<'a, 'tcx>) -> VnIndex {
         let (index, new) = self.values.insert(ty, value);
         if new {
             // Grow `evaluated` and `rev_locals` here to amortize the allocations.
@@ -464,7 +470,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
     }
 
     #[inline]
-    fn get(&self, index: VnIndex) -> &Value<'tcx> {
+    fn get(&self, index: VnIndex) -> Value<'a, 'tcx> {
         self.values.value(index)
     }
 
@@ -495,8 +501,8 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
         self.insert(ty, Value::Constant { value, disambiguator: None })
     }
 
-    fn insert_tuple(&mut self, ty: Ty<'tcx>, values: Vec<VnIndex>) -> VnIndex {
-        self.insert(ty, Value::Aggregate(VariantIdx::ZERO, values))
+    fn insert_tuple(&mut self, ty: Ty<'tcx>, values: &[VnIndex]) -> VnIndex {
+        self.insert(ty, Value::Aggregate(VariantIdx::ZERO, self.arena.alloc_slice(values)))
     }
 
     fn insert_deref(&mut self, ty: Ty<'tcx>, value: VnIndex) -> VnIndex {
@@ -521,7 +527,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
         } else {
             return None;
         };
-        let op = match *self.get(value) {
+        let op = match self.get(value) {
             _ if ty.is_zst() => ImmTy::uninit(ty).into(),
 
             Opaque(_) => return None,
@@ -736,7 +742,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                 if let Value::Aggregate(_, fields) = self.get(value) {
                     return Some((projection_ty, fields[f.as_usize()]));
                 } else if let Value::Projection(outer_value, ProjectionElem::Downcast(_, read_variant)) = self.get(value)
-                    && let Value::Aggregate(written_variant, fields) = self.get(*outer_value)
+                    && let Value::Aggregate(written_variant, fields) = self.get(outer_value)
                     // This pass is not aware of control-flow, so we do not know whether the
                     // replacement we are doing is actually reachable. We could be in any arm of
                     // ```
@@ -761,7 +767,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             ProjectionElem::Index(idx) => {
                 if let Value::Repeat(inner, _) = self.get(value) {
                     *from_non_ssa_index |= self.locals[idx].is_none();
-                    return Some((projection_ty, *inner));
+                    return Some((projection_ty, inner));
                 }
                 let idx = self.locals[idx]?;
                 ProjectionElem::Index(idx)
@@ -769,7 +775,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             ProjectionElem::ConstantIndex { offset, min_length, from_end } => {
                 match self.get(value) {
                     Value::Repeat(inner, _) => {
-                        return Some((projection_ty, *inner));
+                        return Some((projection_ty, inner));
                     }
                     Value::Aggregate(_, operands) => {
                         let offset = if from_end {
@@ -858,8 +864,8 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
         let mut place_ty = PlaceTy::from_ty(self.local_decls[place.local].ty);
         let mut from_non_ssa_index = false;
         for (index, proj) in place.projection.iter().enumerate() {
-            if let Value::Projection(pointer, ProjectionElem::Deref) = *self.get(value)
-                && let Value::Address { place: mut pointee, kind, .. } = *self.get(pointer)
+            if let Value::Projection(pointer, ProjectionElem::Deref) = self.get(value)
+                && let Value::Address { place: mut pointee, kind, .. } = self.get(pointer)
                 && let AddressKind::Ref(BorrowKind::Shared) = kind
                 && let Some(v) = self.simplify_place_value(&mut pointee, location)
             {
@@ -882,8 +888,8 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             (place_ty, value) = self.project(place_ty, value, proj, &mut from_non_ssa_index)?;
         }
 
-        if let Value::Projection(pointer, ProjectionElem::Deref) = *self.get(value)
-            && let Value::Address { place: mut pointee, kind, .. } = *self.get(pointer)
+        if let Value::Projection(pointer, ProjectionElem::Deref) = self.get(value)
+            && let Value::Address { place: mut pointee, kind, .. } = self.get(pointer)
             && let AddressKind::Ref(BorrowKind::Shared) = kind
             && let Some(v) = self.simplify_place_value(&mut pointee, location)
         {
@@ -994,7 +1000,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
     fn simplify_discriminant(&mut self, place: VnIndex) -> Option<VnIndex> {
         let enum_ty = self.ty(place);
         if enum_ty.is_enum()
-            && let Value::Aggregate(variant, _) = *self.get(place)
+            && let Value::Aggregate(variant, _) = self.get(place)
         {
             let discr = self.ecx.discriminant_for_variant(enum_ty, variant).discard_err()?;
             return Some(self.insert_scalar(discr.layout.ty, discr.to_scalar()));
@@ -1026,11 +1032,11 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
         fields: &[VnIndex],
     ) -> Option<VnIndex> {
         let Some(&first_field) = fields.first() else { return None };
-        let Value::Projection(copy_from_value, _) = *self.get(first_field) else { return None };
+        let Value::Projection(copy_from_value, _) = self.get(first_field) else { return None };
 
         // All fields must correspond one-to-one and come from the same aggregate value.
         if fields.iter().enumerate().any(|(index, &v)| {
-            if let Value::Projection(pointer, ProjectionElem::Field(from_index, _)) = *self.get(v)
+            if let Value::Projection(pointer, ProjectionElem::Field(from_index, _)) = self.get(v)
                 && copy_from_value == pointer
                 && from_index.index() == index
             {
@@ -1042,7 +1048,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
         }
 
         let mut copy_from_local_value = copy_from_value;
-        if let Value::Projection(pointer, proj) = *self.get(copy_from_value)
+        if let Value::Projection(pointer, proj) = self.get(copy_from_value)
             && let ProjectionElem::Downcast(_, read_variant) = proj
         {
             if variant_index == read_variant {
@@ -1087,13 +1093,10 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             }
         }
 
-        let fields: Vec<_> = field_ops
-            .iter_mut()
-            .map(|op| {
-                self.simplify_operand(op, location)
-                    .unwrap_or_else(|| self.new_opaque(op.ty(self.local_decls, self.tcx)))
-            })
-            .collect();
+        let fields = self.arena.alloc_from_iter(field_ops.iter_mut().map(|op| {
+            self.simplify_operand(op, location)
+                .unwrap_or_else(|| self.new_opaque(op.ty(self.local_decls, self.tcx)))
+        }));
 
         let variant_index = match *kind {
             AggregateKind::Array(..) | AggregateKind::Tuple => {
@@ -1114,12 +1117,12 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                 let mut was_updated = false;
                 while let Value::Cast { kind: CastKind::PtrToPtr, value: cast_value } =
                     self.get(pointer)
-                    && let ty::RawPtr(from_pointee_ty, from_mtbl) = self.ty(*cast_value).kind()
+                    && let ty::RawPtr(from_pointee_ty, from_mtbl) = self.ty(cast_value).kind()
                     && let ty::RawPtr(_, output_mtbl) = ty.kind()
                     && from_mtbl == output_mtbl
                     && from_pointee_ty.is_sized(self.tcx, self.typing_env())
                 {
-                    pointer = *cast_value;
+                    pointer = cast_value;
                     was_updated = true;
                 }
 
@@ -1184,16 +1187,16 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                     // To allow things like `*mut (?A, ?T)` <-> `*mut (?B, ?T)`,
                     // it's fine to get a projection as the type.
                     Value::Cast { kind: CastKind::PtrToPtr, value: inner }
-                        if self.pointers_have_same_metadata(self.ty(*inner), arg_ty) =>
+                        if self.pointers_have_same_metadata(self.ty(inner), arg_ty) =>
                     {
-                        *inner
+                        inner
                     }
 
                     // We have an unsizing cast, which assigns the length to wide pointer metadata.
                     Value::Cast {
                         kind: CastKind::PointerCoercion(ty::adjustment::PointerCoercion::Unsize, _),
                         value: from,
-                    } if let Some(from) = self.ty(*from).builtin_deref(true)
+                    } if let Some(from) = self.ty(from).builtin_deref(true)
                         && let ty::Array(_, len) = from.kind()
                         && let Some(to) = self.ty(arg_index).builtin_deref(true)
                         && let ty::Slice(..) = to.kind() =>
@@ -1221,15 +1224,15 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
         }
 
         let value = match (op, self.get(arg_index)) {
-            (UnOp::Not, Value::UnaryOp(UnOp::Not, inner)) => return Some(*inner),
-            (UnOp::Neg, Value::UnaryOp(UnOp::Neg, inner)) => return Some(*inner),
+            (UnOp::Not, Value::UnaryOp(UnOp::Not, inner)) => return Some(inner),
+            (UnOp::Neg, Value::UnaryOp(UnOp::Neg, inner)) => return Some(inner),
             (UnOp::Not, Value::BinaryOp(BinOp::Eq, lhs, rhs)) => {
-                Value::BinaryOp(BinOp::Ne, *lhs, *rhs)
+                Value::BinaryOp(BinOp::Ne, lhs, rhs)
             }
             (UnOp::Not, Value::BinaryOp(BinOp::Ne, lhs, rhs)) => {
-                Value::BinaryOp(BinOp::Eq, *lhs, *rhs)
+                Value::BinaryOp(BinOp::Eq, lhs, rhs)
             }
-            (UnOp::PtrMetadata, Value::RawPtr { metadata, .. }) => return Some(*metadata),
+            (UnOp::PtrMetadata, Value::RawPtr { metadata, .. }) => return Some(metadata),
             // We have an unsizing cast, which assigns the length to wide pointer metadata.
             (
                 UnOp::PtrMetadata,
@@ -1238,7 +1241,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                     value: inner,
                 },
             ) if let ty::Slice(..) = arg_ty.builtin_deref(true).unwrap().kind()
-                && let ty::Array(_, len) = self.ty(*inner).builtin_deref(true).unwrap().kind() =>
+                && let ty::Array(_, len) = self.ty(inner).builtin_deref(true).unwrap().kind() =>
             {
                 return Some(self.insert_constant(Const::Ty(self.tcx.types.usize, *len)));
             }
@@ -1271,12 +1274,12 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             && lhs_ty.is_any_ptr()
             && let Value::Cast { kind: CastKind::PtrToPtr, value: lhs_value } = self.get(lhs)
             && let Value::Cast { kind: CastKind::PtrToPtr, value: rhs_value } = self.get(rhs)
-            && let lhs_from = self.ty(*lhs_value)
-            && lhs_from == self.ty(*rhs_value)
+            && let lhs_from = self.ty(lhs_value)
+            && lhs_from == self.ty(rhs_value)
             && self.pointers_have_same_metadata(lhs_from, lhs_ty)
         {
-            lhs = *lhs_value;
-            rhs = *rhs_value;
+            lhs = lhs_value;
+            rhs = rhs_value;
             if let Some(lhs_op) = self.try_as_operand(lhs, location)
                 && let Some(rhs_op) = self.try_as_operand(rhs, location)
             {
@@ -1410,7 +1413,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
         if op.is_overflowing() {
             let ty = Ty::new_tup(self.tcx, &[self.ty(result), self.tcx.types.bool]);
             let false_val = self.insert_bool(false);
-            Some(self.insert_tuple(ty, vec![result, false_val]))
+            Some(self.insert_tuple(ty, &[result, false_val]))
         } else {
             Some(result)
         }
@@ -1463,11 +1466,11 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                 && let ty::RawPtr(to_pointee, _) = to.kind()
                 && to_pointee.is_sized(self.tcx, self.typing_env())
             {
-                from = self.ty(*pointer);
-                value = *pointer;
+                from = self.ty(pointer);
+                value = pointer;
                 was_updated_this_iteration = true;
                 if from == to {
-                    return Some(*pointer);
+                    return Some(pointer);
                 }
             }
 
@@ -1476,7 +1479,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             if let Transmute = kind
                 && let Value::Aggregate(variant_idx, field_values) = self.get(value)
                 && let Some((field_idx, field_ty)) =
-                    self.value_is_all_in_one_field(from, *variant_idx)
+                    self.value_is_all_in_one_field(from, variant_idx)
             {
                 from = field_ty;
                 value = field_values[field_idx.as_usize()];
@@ -1487,7 +1490,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             }
 
             // Various cast-then-cast cases can be simplified.
-            if let Value::Cast { kind: inner_kind, value: inner_value } = *self.get(value) {
+            if let Value::Cast { kind: inner_kind, value: inner_value } = self.get(value) {
                 let inner_from = self.ty(inner_value);
                 let new_kind = match (inner_kind, kind) {
                     // Even if there's a narrowing cast in here that's fine, because
@@ -1686,7 +1689,7 @@ fn op_to_prop_const<'tcx>(
     None
 }
 
-impl<'tcx> VnState<'_, 'tcx> {
+impl<'tcx> VnState<'_, '_, 'tcx> {
     /// If either [`Self::try_as_constant`] as [`Self::try_as_place`] succeeds,
     /// returns that result as an [`Operand`].
     fn try_as_operand(&mut self, index: VnIndex, location: Location) -> Option<Operand<'tcx>> {
@@ -1705,7 +1708,7 @@ impl<'tcx> VnState<'_, 'tcx> {
         // This was already constant in MIR, do not change it. If the constant is not
         // deterministic, adding an additional mention of it in MIR will not give the same value as
         // the former mention.
-        if let Value::Constant { value, disambiguator: None } = *self.get(index) {
+        if let Value::Constant { value, disambiguator: None } = self.get(index) {
             debug_assert!(value.is_deterministic());
             return Some(ConstOperand { span: DUMMY_SP, user_ty: None, const_: value });
         }
@@ -1749,7 +1752,7 @@ impl<'tcx> VnState<'_, 'tcx> {
                 // If we are here, we failed to find a local, and we already have a `Deref`.
                 // Trying to add projections will only result in an ill-formed place.
                 return None;
-            } else if let Value::Projection(pointer, proj) = *self.get(index)
+            } else if let Value::Projection(pointer, proj) = self.get(index)
                 && (allow_complex_projection || proj.is_stable_offset())
                 && let Some(proj) = self.try_as_place_elem(self.ty(index), proj, loc)
             {
@@ -1772,7 +1775,7 @@ impl<'tcx> VnState<'_, 'tcx> {
     }
 }
 
-impl<'tcx> MutVisitor<'tcx> for VnState<'_, 'tcx> {
+impl<'tcx> MutVisitor<'tcx> for VnState<'_, '_, 'tcx> {
     fn tcx(&self) -> TyCtxt<'tcx> {
         self.tcx
     }

From 3d96e54656927e4870b7b4aaa0afa099e1fc012a Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Tue, 1 Jul 2025 10:01:12 +0000
Subject: [PATCH 1719/1889] Use a VnIndex in Address projection.

---
 compiler/rustc_mir_transform/src/gvn.rs       | 201 +++++++++++-------
 ....dereference_indexing.GVN.panic-abort.diff |   3 +-
 ...dereference_indexing.GVN.panic-unwind.diff |   3 +-
 tests/mir-opt/gvn.rs                          |   4 +-
 tests/mir-opt/gvn_repeat.index_place.GVN.diff |  15 ++
 .../mir-opt/gvn_repeat.repeat_local.GVN.diff  |   3 +-
 tests/mir-opt/gvn_repeat.rs                   |  21 +-
 7 files changed, 171 insertions(+), 79 deletions(-)
 create mode 100644 tests/mir-opt/gvn_repeat.index_place.GVN.diff

diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index da36c3e6926ba..03a40f83732ac 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -186,6 +186,14 @@ enum AddressKind {
     Address(RawPtrKind),
 }
 
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+enum AddressBase {
+    /// This address is based on this local.
+    Local(Local),
+    /// This address is based on the deref of this pointer.
+    Deref(VnIndex),
+}
+
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 enum Value<'a, 'tcx> {
     // Root values.
@@ -216,7 +224,10 @@ enum Value<'a, 'tcx> {
     Repeat(VnIndex, ty::Const<'tcx>),
     /// The address of a place.
     Address {
-        place: Place<'tcx>,
+        base: AddressBase,
+        // We do not use a plain `Place` as we want to be able to reason about indices.
+        // This does not contain any `Deref` projection.
+        projection: &'a [ProjectionElem<VnIndex, Ty<'tcx>>],
         kind: AddressKind,
         /// Give each borrow and pointer a different provenance, so we don't merge them.
         provenance: VnOpaque,
@@ -426,7 +437,7 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
 
     /// Create a new `Value::Address` distinct from all the others.
     #[instrument(level = "trace", skip(self), ret)]
-    fn new_pointer(&mut self, place: Place<'tcx>, kind: AddressKind) -> VnIndex {
+    fn new_pointer(&mut self, place: Place<'tcx>, kind: AddressKind) -> Option<VnIndex> {
         let pty = place.ty(self.local_decls, self.tcx).ty;
         let ty = match kind {
             AddressKind::Ref(bk) => {
@@ -434,14 +445,34 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
             }
             AddressKind::Address(mutbl) => Ty::new_ptr(self.tcx, pty, mutbl.to_mutbl_lossy()),
         };
-        let index =
-            self.values.insert_unique(ty, |provenance| Value::Address { place, kind, provenance });
+
+        let mut projection = place.projection.iter();
+        let base = if place.is_indirect_first_projection() {
+            let base = self.locals[place.local]?;
+            // Skip the initial `Deref`.
+            projection.next();
+            AddressBase::Deref(base)
+        } else {
+            AddressBase::Local(place.local)
+        };
+        // Do not try evaluating inside `Index`, this has been done by `simplify_place_projection`.
+        let projection =
+            projection.map(|proj| proj.try_map(|index| self.locals[index], |ty| ty).ok_or(()));
+        let projection = self.arena.try_alloc_from_iter(projection).ok()?;
+
+        let index = self.values.insert_unique(ty, |provenance| Value::Address {
+            base,
+            projection,
+            kind,
+            provenance,
+        });
         let evaluated = self.eval_to_const(index);
         let _index = self.evaluated.push(evaluated);
         debug_assert_eq!(index, _index);
         let _index = self.rev_locals.push(SmallVec::new());
         debug_assert_eq!(index, _index);
-        index
+
+        Some(index)
     }
 
     #[instrument(level = "trace", skip(self), ret)]
@@ -591,14 +622,15 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
                 let elem = elem.try_map(|_| None, |()| ty.ty)?;
                 self.ecx.project(base, elem).discard_err()?
             }
-            Address { place, kind: _, provenance: _ } => {
-                if !place.is_indirect_first_projection() {
-                    return None;
-                }
-                let local = self.locals[place.local]?;
-                let pointer = self.evaluated[local].as_ref()?;
+            Address { base, projection, .. } => {
+                debug_assert!(!projection.contains(&ProjectionElem::Deref));
+                let pointer = match base {
+                    AddressBase::Deref(pointer) => self.evaluated[pointer].as_ref()?,
+                    // We have no stack to point to.
+                    AddressBase::Local(_) => return None,
+                };
                 let mut mplace = self.ecx.deref_pointer(pointer).discard_err()?;
-                for elem in place.projection.iter().skip(1) {
+                for elem in projection {
                     // `Index` by constants should have been replaced by `ConstantIndex` by
                     // `simplify_place_projection`.
                     let elem = elem.try_map(|_| None, |ty| ty)?;
@@ -717,12 +749,38 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
         Some(op)
     }
 
+    /// Represent the *value* we obtain by dereferencing an `Address` value.
+    #[instrument(level = "trace", skip(self), ret)]
+    fn dereference_address(
+        &mut self,
+        base: AddressBase,
+        projection: &[ProjectionElem<VnIndex, Ty<'tcx>>],
+    ) -> Option<VnIndex> {
+        let (mut place_ty, mut value) = match base {
+            // The base is a local, so we take the local's value and project from it.
+            AddressBase::Local(local) => {
+                let local = self.locals[local]?;
+                let place_ty = PlaceTy::from_ty(self.ty(local));
+                (place_ty, local)
+            }
+            // The base is a pointer's deref, so we introduce the implicit deref.
+            AddressBase::Deref(reborrow) => {
+                let place_ty = PlaceTy::from_ty(self.ty(reborrow));
+                self.project(place_ty, reborrow, ProjectionElem::Deref)?
+            }
+        };
+        for &proj in projection {
+            (place_ty, value) = self.project(place_ty, value, proj)?;
+        }
+        Some(value)
+    }
+
+    #[instrument(level = "trace", skip(self), ret)]
     fn project(
         &mut self,
         place_ty: PlaceTy<'tcx>,
         value: VnIndex,
-        proj: PlaceElem<'tcx>,
-        from_non_ssa_index: &mut bool,
+        proj: ProjectionElem<VnIndex, Ty<'tcx>>,
     ) -> Option<(PlaceTy<'tcx>, VnIndex)> {
         let projection_ty = place_ty.projection_ty(self.tcx, proj);
         let proj = match proj {
@@ -730,6 +788,12 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
                 if let Some(Mutability::Not) = place_ty.ty.ref_mutability()
                     && projection_ty.ty.is_freeze(self.tcx, self.typing_env())
                 {
+                    if let Value::Address { base, projection, .. } = self.get(value)
+                        && let Some(value) = self.dereference_address(base, projection)
+                    {
+                        return Some((projection_ty, value));
+                    }
+
                     // An immutable borrow `_x` always points to the same value for the
                     // lifetime of the borrow, so we can merge all instances of `*_x`.
                     return Some((projection_ty, self.insert_deref(projection_ty.ty, value)));
@@ -766,10 +830,8 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
             }
             ProjectionElem::Index(idx) => {
                 if let Value::Repeat(inner, _) = self.get(value) {
-                    *from_non_ssa_index |= self.locals[idx].is_none();
                     return Some((projection_ty, inner));
                 }
-                let idx = self.locals[idx]?;
                 ProjectionElem::Index(idx)
             }
             ProjectionElem::ConstantIndex { offset, min_length, from_end } => {
@@ -844,40 +906,23 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
         trace!(?place);
     }
 
-    /// Represent the *value* which would be read from `place`, and point `place` to a preexisting
-    /// place with the same value (if that already exists).
+    /// Represent the *value* which would be read from `place`. If we succeed, return it.
+    /// If we fail, return a `PlaceRef` that contains the same value.
     #[instrument(level = "trace", skip(self), ret)]
-    fn simplify_place_value(
+    fn compute_place_value(
         &mut self,
-        place: &mut Place<'tcx>,
+        place: Place<'tcx>,
         location: Location,
-    ) -> Option<VnIndex> {
-        self.simplify_place_projection(place, location);
-
+    ) -> Result<VnIndex, PlaceRef<'tcx>> {
         // Invariant: `place` and `place_ref` point to the same value, even if they point to
         // different memory locations.
         let mut place_ref = place.as_ref();
 
         // Invariant: `value` holds the value up-to the `index`th projection excluded.
-        let mut value = self.locals[place.local]?;
+        let Some(mut value) = self.locals[place.local] else { return Err(place_ref) };
         // Invariant: `value` has type `place_ty`, with optional downcast variant if needed.
         let mut place_ty = PlaceTy::from_ty(self.local_decls[place.local].ty);
-        let mut from_non_ssa_index = false;
         for (index, proj) in place.projection.iter().enumerate() {
-            if let Value::Projection(pointer, ProjectionElem::Deref) = self.get(value)
-                && let Value::Address { place: mut pointee, kind, .. } = self.get(pointer)
-                && let AddressKind::Ref(BorrowKind::Shared) = kind
-                && let Some(v) = self.simplify_place_value(&mut pointee, location)
-            {
-                value = v;
-                // `pointee` holds a `Place`, so `ProjectionElem::Index` holds a `Local`.
-                // That local is SSA, but we otherwise have no guarantee on that local's value at
-                // the current location compared to its value where `pointee` was borrowed.
-                if pointee.projection.iter().all(|elem| !matches!(elem, ProjectionElem::Index(_))) {
-                    place_ref =
-                        pointee.project_deeper(&place.projection[index..], self.tcx).as_ref();
-                }
-            }
             if let Some(local) = self.try_as_local(value, location) {
                 // Both `local` and `Place { local: place.local, projection: projection[..index] }`
                 // hold the same value. Therefore, following place holds the value in the original
@@ -885,36 +930,50 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
                 place_ref = PlaceRef { local, projection: &place.projection[index..] };
             }
 
-            (place_ty, value) = self.project(place_ty, value, proj, &mut from_non_ssa_index)?;
+            let Some(proj) = proj.try_map(|value| self.locals[value], |ty| ty) else {
+                return Err(place_ref);
+            };
+            let Some(ty_and_value) = self.project(place_ty, value, proj) else {
+                return Err(place_ref);
+            };
+            (place_ty, value) = ty_and_value;
         }
 
-        if let Value::Projection(pointer, ProjectionElem::Deref) = self.get(value)
-            && let Value::Address { place: mut pointee, kind, .. } = self.get(pointer)
-            && let AddressKind::Ref(BorrowKind::Shared) = kind
-            && let Some(v) = self.simplify_place_value(&mut pointee, location)
-        {
-            value = v;
-            // `pointee` holds a `Place`, so `ProjectionElem::Index` holds a `Local`.
-            // That local is SSA, but we otherwise have no guarantee on that local's value at
-            // the current location compared to its value where `pointee` was borrowed.
-            if pointee.projection.iter().all(|elem| !matches!(elem, ProjectionElem::Index(_))) {
-                place_ref = pointee.project_deeper(&[], self.tcx).as_ref();
-            }
-        }
-        if let Some(new_local) = self.try_as_local(value, location) {
-            place_ref = PlaceRef { local: new_local, projection: &[] };
-        } else if from_non_ssa_index {
-            // If access to non-SSA locals is unavoidable, bail out.
-            return None;
-        }
+        Ok(value)
+    }
 
-        if place_ref.local != place.local || place_ref.projection.len() < place.projection.len() {
-            // By the invariant on `place_ref`.
-            *place = place_ref.project_deeper(&[], self.tcx);
-            self.reused_locals.insert(place_ref.local);
-        }
+    /// Represent the *value* which would be read from `place`, and point `place` to a preexisting
+    /// place with the same value (if that already exists).
+    #[instrument(level = "trace", skip(self), ret)]
+    fn simplify_place_value(
+        &mut self,
+        place: &mut Place<'tcx>,
+        location: Location,
+    ) -> Option<VnIndex> {
+        self.simplify_place_projection(place, location);
 
-        Some(value)
+        match self.compute_place_value(*place, location) {
+            Ok(value) => {
+                if let Some(new_place) = self.try_as_place(value, location, true)
+                    && (new_place.local != place.local
+                        || new_place.projection.len() < place.projection.len())
+                {
+                    *place = new_place;
+                    self.reused_locals.insert(new_place.local);
+                }
+                Some(value)
+            }
+            Err(place_ref) => {
+                if place_ref.local != place.local
+                    || place_ref.projection.len() < place.projection.len()
+                {
+                    // By the invariant on `place_ref`.
+                    *place = place_ref.project_deeper(&[], self.tcx);
+                    self.reused_locals.insert(place_ref.local);
+                }
+                None
+            }
+        }
     }
 
     #[instrument(level = "trace", skip(self), ret)]
@@ -961,11 +1020,11 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
             Rvalue::Aggregate(..) => return self.simplify_aggregate(lhs, rvalue, location),
             Rvalue::Ref(_, borrow_kind, ref mut place) => {
                 self.simplify_place_projection(place, location);
-                return Some(self.new_pointer(*place, AddressKind::Ref(borrow_kind)));
+                return self.new_pointer(*place, AddressKind::Ref(borrow_kind));
             }
             Rvalue::RawPtr(mutbl, ref mut place) => {
                 self.simplify_place_projection(place, location);
-                return Some(self.new_pointer(*place, AddressKind::Address(mutbl)));
+                return self.new_pointer(*place, AddressKind::Address(mutbl));
             }
             Rvalue::WrapUnsafeBinder(ref mut op, _) => {
                 let value = self.simplify_operand(op, location)?;
@@ -1205,12 +1264,10 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
                     }
 
                     // `&mut *p`, `&raw *p`, etc don't change metadata.
-                    Value::Address { place, kind: _, provenance: _ }
-                        if let PlaceRef { local, projection: [PlaceElem::Deref] } =
-                            place.as_ref()
-                            && let Some(local_index) = self.locals[local] =>
+                    Value::Address { base: AddressBase::Deref(reborrowed), projection, .. }
+                        if projection.is_empty() =>
                     {
-                        local_index
+                        reborrowed
                     }
 
                     _ => break,
diff --git a/tests/mir-opt/gvn.dereference_indexing.GVN.panic-abort.diff b/tests/mir-opt/gvn.dereference_indexing.GVN.panic-abort.diff
index 9bdcc2f108a6a..1a07638cbafea 100644
--- a/tests/mir-opt/gvn.dereference_indexing.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.dereference_indexing.GVN.panic-abort.diff
@@ -43,7 +43,8 @@
 +         nop;
           StorageLive(_8);
           StorageLive(_9);
-          _9 = copy (*_3);
+-         _9 = copy (*_3);
++         _9 = copy _1[_4];
           _8 = opaque::<u8>(move _9) -> [return: bb2, unwind unreachable];
       }
   
diff --git a/tests/mir-opt/gvn.dereference_indexing.GVN.panic-unwind.diff b/tests/mir-opt/gvn.dereference_indexing.GVN.panic-unwind.diff
index f38bc51adc480..6e67b66e783c4 100644
--- a/tests/mir-opt/gvn.dereference_indexing.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.dereference_indexing.GVN.panic-unwind.diff
@@ -43,7 +43,8 @@
 +         nop;
           StorageLive(_8);
           StorageLive(_9);
-          _9 = copy (*_3);
+-         _9 = copy (*_3);
++         _9 = copy _1[_4];
           _8 = opaque::<u8>(move _9) -> [return: bb2, unwind continue];
       }
   
diff --git a/tests/mir-opt/gvn.rs b/tests/mir-opt/gvn.rs
index 98f94fbf0b146..3c3241fefe22e 100644
--- a/tests/mir-opt/gvn.rs
+++ b/tests/mir-opt/gvn.rs
@@ -1065,8 +1065,8 @@ fn dereference_indexing(array: [u8; 2], index: usize) {
         &array[i]
     };
 
-    // CHECK-NOT: [{{.*}}]
-    // CHECK: [[tmp:_.*]] = copy (*[[a]]);
+    // CHECK-NOT: StorageDead([[i]]);
+    // CHECK: [[tmp:_.*]] = copy _1[[[i]]];
     // CHECK: opaque::<u8>(move [[tmp]])
     opaque(*a);
 }
diff --git a/tests/mir-opt/gvn_repeat.index_place.GVN.diff b/tests/mir-opt/gvn_repeat.index_place.GVN.diff
new file mode 100644
index 0000000000000..1eb7e9015cc3f
--- /dev/null
+++ b/tests/mir-opt/gvn_repeat.index_place.GVN.diff
@@ -0,0 +1,15 @@
+- // MIR for `index_place` before GVN
++ // MIR for `index_place` after GVN
+  
+  fn index_place(_1: usize, _2: usize, _3: [i32; 5]) -> i32 {
+      let mut _0: i32;
+      let mut _4: &i32;
+  
+      bb0: {
+          _4 = &_3[_1];
+          _1 = copy _2;
+          _0 = copy (*_4);
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/gvn_repeat.repeat_local.GVN.diff b/tests/mir-opt/gvn_repeat.repeat_local.GVN.diff
index fd04782528117..eb3f885b8665b 100644
--- a/tests/mir-opt/gvn_repeat.repeat_local.GVN.diff
+++ b/tests/mir-opt/gvn_repeat.repeat_local.GVN.diff
@@ -10,8 +10,7 @@
           _4 = [copy _3; 5];
           _5 = &_4[_1];
           _1 = copy _2;
--         _0 = copy (*_5);
-+         _0 = copy _3;
+          _0 = copy (*_5);
           return;
       }
   }
diff --git a/tests/mir-opt/gvn_repeat.rs b/tests/mir-opt/gvn_repeat.rs
index bbbb2a7ccbaf5..49364c6bfd232 100644
--- a/tests/mir-opt/gvn_repeat.rs
+++ b/tests/mir-opt/gvn_repeat.rs
@@ -6,6 +6,23 @@
 
 use std::intrinsics::mir::*;
 
+// EMIT_MIR gvn_repeat.index_place.GVN.diff
+#[custom_mir(dialect = "runtime")]
+pub fn index_place(mut idx1: usize, idx2: usize, array: [i32; 5]) -> i32 {
+    // CHECK-LABEL: fn index_place(
+    // CHECK: let mut [[ELEM:.*]]: &i32;
+    // CHECK: _0 = copy (*[[ELEM]])
+    mir! {
+        let elem;
+        {
+            elem = &array[idx1];
+            idx1 = idx2;
+            RET = *elem;
+            Return()
+        }
+    }
+}
+
 // EMIT_MIR gvn_repeat.repeat_place.GVN.diff
 #[custom_mir(dialect = "runtime")]
 pub fn repeat_place(mut idx1: usize, idx2: usize, val: &i32) -> i32 {
@@ -29,7 +46,8 @@ pub fn repeat_place(mut idx1: usize, idx2: usize, val: &i32) -> i32 {
 #[custom_mir(dialect = "runtime")]
 pub fn repeat_local(mut idx1: usize, idx2: usize, val: i32) -> i32 {
     // CHECK-LABEL: fn repeat_local(
-    // CHECK: _0 = copy _3
+    // CHECK: let mut [[ELEM:.*]]: &i32;
+    // CHECK: _0 = copy (*[[ELEM]]);
     mir! {
         let array;
         let elem;
@@ -44,6 +62,7 @@ pub fn repeat_local(mut idx1: usize, idx2: usize, val: i32) -> i32 {
 }
 
 fn main() {
+    assert_eq!(index_place(0, 5, [0; 5]), 0);
     assert_eq!(repeat_place(0, 5, &0), 0);
     assert_eq!(repeat_local(0, 5, 0), 0);
 }

From cf341eac195d85f8193de5052b68960605247a29 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Thu, 18 Sep 2025 00:36:52 +0000
Subject: [PATCH 1720/1889] Refactor remove_noop_landing_pads in two loops.

---
 .../src/remove_noop_landing_pads.rs           | 43 ++++++++++---------
 1 file changed, 23 insertions(+), 20 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/remove_noop_landing_pads.rs b/compiler/rustc_mir_transform/src/remove_noop_landing_pads.rs
index b53c1f6d20203..bbfa565a7b600 100644
--- a/compiler/rustc_mir_transform/src/remove_noop_landing_pads.rs
+++ b/compiler/rustc_mir_transform/src/remove_noop_landing_pads.rs
@@ -1,7 +1,7 @@
 use rustc_index::bit_set::DenseBitSet;
 use rustc_middle::mir::*;
 use rustc_middle::ty::TyCtxt;
-use tracing::debug;
+use tracing::{debug, instrument};
 
 use crate::patch::MirPatch;
 
@@ -15,6 +15,7 @@ impl<'tcx> crate::MirPass<'tcx> for RemoveNoopLandingPads {
         sess.panic_strategy().unwinds()
     }
 
+    #[instrument(level = "debug", skip(self, _tcx, body))]
     fn run_pass(&self, _tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
         let def_id = body.source.def_id();
         debug!(?def_id);
@@ -25,7 +26,7 @@ impl<'tcx> crate::MirPass<'tcx> for RemoveNoopLandingPads {
             .iter_enumerated()
             .any(|(_bb, block)| matches!(block.terminator().kind, TerminatorKind::UnwindResume));
         if !has_resume {
-            debug!("remove_noop_landing_pads: no resume block in MIR");
+            debug!("no resume block in MIR");
             return;
         }
 
@@ -36,42 +37,44 @@ impl<'tcx> crate::MirPass<'tcx> for RemoveNoopLandingPads {
             patch.apply(body);
             resume_block
         };
-        debug!("remove_noop_landing_pads: resume block is {:?}", resume_block);
+        debug!(?resume_block);
 
-        let mut jumps_folded = 0;
-        let mut landing_pads_removed = 0;
         let mut nop_landing_pads = DenseBitSet::new_empty(body.basic_blocks.len());
 
         // This is a post-order traversal, so that if A post-dominates B
         // then A will be visited before B.
-        let postorder: Vec<_> = traversal::postorder(body).map(|(bb, _)| bb).collect();
-        for bb in postorder {
-            debug!("  processing {:?}", bb);
-            if let Some(unwind) = body[bb].terminator_mut().unwind_mut()
+        for &bb in body.basic_blocks.reverse_postorder().iter().rev() {
+            let is_nop_landing_pad = self.is_nop_landing_pad(bb, body, &nop_landing_pads);
+            debug!("is_nop_landing_pad({bb:?}) = {is_nop_landing_pad}");
+            if is_nop_landing_pad {
+                nop_landing_pads.insert(bb);
+            }
+        }
+
+        if nop_landing_pads.is_empty() {
+            debug!("no nop landing pads in MIR");
+            return;
+        }
+
+        let basic_blocks = body.basic_blocks.as_mut();
+        for (bb, bbdata) in basic_blocks.iter_enumerated_mut() {
+            debug!("processing {:?}", bb);
+
+            if let Some(unwind) = bbdata.terminator_mut().unwind_mut()
                 && let UnwindAction::Cleanup(unwind_bb) = *unwind
                 && nop_landing_pads.contains(unwind_bb)
             {
                 debug!("    removing noop landing pad");
-                landing_pads_removed += 1;
                 *unwind = UnwindAction::Continue;
             }
 
-            body[bb].terminator_mut().successors_mut(|target| {
+            bbdata.terminator_mut().successors_mut(|target| {
                 if *target != resume_block && nop_landing_pads.contains(*target) {
                     debug!("    folding noop jump to {:?} to resume block", target);
                     *target = resume_block;
-                    jumps_folded += 1;
                 }
             });
-
-            let is_nop_landing_pad = self.is_nop_landing_pad(bb, body, &nop_landing_pads);
-            if is_nop_landing_pad {
-                nop_landing_pads.insert(bb);
-            }
-            debug!("    is_nop_landing_pad({:?}) = {}", bb, is_nop_landing_pad);
         }
-
-        debug!("removed {:?} jumps and {:?} landing pads", jumps_folded, landing_pads_removed);
     }
 
     fn is_required(&self) -> bool {

From 1ac5d4c2783a3ac23f19c8a71ba6e7fdf21034c7 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Sat, 27 Sep 2025 16:41:32 +0000
Subject: [PATCH 1721/1889] Create resume block later.

---
 .../src/remove_noop_landing_pads.rs            | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/remove_noop_landing_pads.rs b/compiler/rustc_mir_transform/src/remove_noop_landing_pads.rs
index bbfa565a7b600..0e6eef38cd2c5 100644
--- a/compiler/rustc_mir_transform/src/remove_noop_landing_pads.rs
+++ b/compiler/rustc_mir_transform/src/remove_noop_landing_pads.rs
@@ -30,15 +30,6 @@ impl<'tcx> crate::MirPass<'tcx> for RemoveNoopLandingPads {
             return;
         }
 
-        // make sure there's a resume block without any statements
-        let resume_block = {
-            let mut patch = MirPatch::new(body);
-            let resume_block = patch.resume_block();
-            patch.apply(body);
-            resume_block
-        };
-        debug!(?resume_block);
-
         let mut nop_landing_pads = DenseBitSet::new_empty(body.basic_blocks.len());
 
         // This is a post-order traversal, so that if A post-dominates B
@@ -56,6 +47,15 @@ impl<'tcx> crate::MirPass<'tcx> for RemoveNoopLandingPads {
             return;
         }
 
+        // make sure there's a resume block without any statements
+        let resume_block = {
+            let mut patch = MirPatch::new(body);
+            let resume_block = patch.resume_block();
+            patch.apply(body);
+            resume_block
+        };
+        debug!(?resume_block);
+
         let basic_blocks = body.basic_blocks.as_mut();
         for (bb, bbdata) in basic_blocks.iter_enumerated_mut() {
             debug!("processing {:?}", bb);

From 94b2c303aa9c9c6a1a34d1b5587e0a7a481fa97f Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Sat, 4 Oct 2025 17:02:08 +0000
Subject: [PATCH 1722/1889] Use traversal::postorder.

---
 .../src/remove_noop_landing_pads.rs                   | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/remove_noop_landing_pads.rs b/compiler/rustc_mir_transform/src/remove_noop_landing_pads.rs
index 0e6eef38cd2c5..38752bde6b417 100644
--- a/compiler/rustc_mir_transform/src/remove_noop_landing_pads.rs
+++ b/compiler/rustc_mir_transform/src/remove_noop_landing_pads.rs
@@ -34,8 +34,8 @@ impl<'tcx> crate::MirPass<'tcx> for RemoveNoopLandingPads {
 
         // This is a post-order traversal, so that if A post-dominates B
         // then A will be visited before B.
-        for &bb in body.basic_blocks.reverse_postorder().iter().rev() {
-            let is_nop_landing_pad = self.is_nop_landing_pad(bb, body, &nop_landing_pads);
+        for (bb, bbdata) in traversal::postorder(body) {
+            let is_nop_landing_pad = self.is_nop_landing_pad(bbdata, &nop_landing_pads);
             debug!("is_nop_landing_pad({bb:?}) = {is_nop_landing_pad}");
             if is_nop_landing_pad {
                 nop_landing_pads.insert(bb);
@@ -85,11 +85,10 @@ impl<'tcx> crate::MirPass<'tcx> for RemoveNoopLandingPads {
 impl RemoveNoopLandingPads {
     fn is_nop_landing_pad(
         &self,
-        bb: BasicBlock,
-        body: &Body<'_>,
+        bbdata: &BasicBlockData<'_>,
         nop_landing_pads: &DenseBitSet<BasicBlock>,
     ) -> bool {
-        for stmt in &body[bb].statements {
+        for stmt in &bbdata.statements {
             match &stmt.kind {
                 StatementKind::FakeRead(..)
                 | StatementKind::StorageLive(_)
@@ -122,7 +121,7 @@ impl RemoveNoopLandingPads {
             }
         }
 
-        let terminator = body[bb].terminator();
+        let terminator = bbdata.terminator();
         match terminator.kind {
             TerminatorKind::Goto { .. }
             | TerminatorKind::UnwindResume

From 67bc0308336a115c3ea45130d9845a97f33b8196 Mon Sep 17 00:00:00 2001
From: Kivooeo <Kivooeo123@gmail.com>
Date: Sat, 4 Oct 2025 17:43:59 +0000
Subject: [PATCH 1723/1889] change flt back to ftl

---
 compiler/rustc_attr_parsing/messages.ftl   | 157 ++++++++++-----------
 compiler/rustc_builtin_macros/messages.ftl |  18 +--
 compiler/rustc_codegen_ssa/messages.ftl    |   4 +-
 compiler/rustc_const_eval/messages.ftl     |   8 +-
 compiler/rustc_expand/messages.ftl         |  10 +-
 compiler/rustc_lint/messages.ftl           |  16 +--
 compiler/rustc_metadata/messages.ftl       |  25 ++--
 compiler/rustc_middle/messages.ftl         |   6 +-
 compiler/rustc_parse/messages.ftl          |  11 +-
 compiler/rustc_passes/messages.ftl         |   8 +-
 compiler/rustc_resolve/messages.ftl        |  12 +-
 compiler/rustc_ty_utils/messages.ftl       |   4 -
 src/tools/tidy/src/fluent_alphabetical.rs  |   2 +-
 13 files changed, 133 insertions(+), 148 deletions(-)

diff --git a/compiler/rustc_attr_parsing/messages.ftl b/compiler/rustc_attr_parsing/messages.ftl
index 6c5346e83554b..a432fa099ef4a 100644
--- a/compiler/rustc_attr_parsing/messages.ftl
+++ b/compiler/rustc_attr_parsing/messages.ftl
@@ -1,3 +1,9 @@
+attr_parsing_as_needed_compatibility =
+    linking modifier `as-needed` is only compatible with `dylib` and `framework` linking kinds
+
+attr_parsing_bundle_needs_static =
+    linking modifier `bundle` is only compatible with `static` linking kind
+
 attr_parsing_cfg_predicate_identifier =
     `cfg` predicate key must be an identifier
 
@@ -18,16 +24,12 @@ attr_parsing_empty_attribute =
     }
 
 
-attr_parsing_invalid_target = `#[{$name}]` attribute cannot be used on {$target}
-    .help = `#[{$name}]` can {$only}be applied to {$applied}
-    .suggestion = remove the attribute
-attr_parsing_invalid_target_lint = `#[{$name}]` attribute cannot be used on {$target}
-    .warn = {-attr_parsing_previously_accepted}
-    .help = `#[{$name}]` can {$only}be applied to {$applied}
-    .suggestion = remove the attribute
-
 attr_parsing_empty_confusables =
     expected at least one confusable name
+attr_parsing_empty_link_name =
+    link name must not be empty
+    .label = empty link name
+
 attr_parsing_expected_one_cfg_pattern =
     expected 1 cfg-pattern
 
@@ -48,6 +50,15 @@ attr_parsing_ill_formed_attribute_input = {$num_suggestions ->
         *[other] valid forms for the attribute are {$suggestions}
     }
 
+attr_parsing_import_name_type_raw =
+    import name type can only be used with link kind `raw-dylib`
+
+attr_parsing_import_name_type_x86 =
+    import name type is only supported on x86
+
+attr_parsing_incompatible_wasm_link =
+    `wasm_import_module` is incompatible with other arguments in `#[link]` attributes
+
 attr_parsing_incorrect_repr_format_align_one_arg =
     incorrect `repr(align)` attribute format: `align` takes exactly one argument in parentheses
 
@@ -67,6 +78,11 @@ attr_parsing_incorrect_repr_format_packed_one_or_zero_arg =
 attr_parsing_invalid_alignment_value =
     invalid alignment value: {$error_part}
 
+attr_parsing_invalid_attr_unsafe = `{$name}` is not an unsafe attribute
+    .label = this is not an unsafe attribute
+    .suggestion = remove the `unsafe(...)`
+    .note = extraneous unsafe is not allowed in attributes
+
 attr_parsing_invalid_issue_string =
     `issue` must be a non-zero numeric string or "none"
     .must_not_be_zero = `issue` must not be "0", use "none" instead
@@ -75,6 +91,13 @@ attr_parsing_invalid_issue_string =
     .pos_overflow = number too large to fit in target type
     .neg_overflow = number too small to fit in target type
 
+attr_parsing_invalid_link_modifier =
+    invalid linking modifier syntax, expected '+' or '-' prefix before one of: bundle, verbatim, whole-archive, as-needed
+
+attr_parsing_invalid_meta_item = expected a literal (`1u8`, `1.0f32`, `"string"`, etc.) here, found {$descr}
+    .remove_neg_sugg = negative numbers are not literals, try removing the `-` sign
+    .quote_ident_sugg = surround the identifier with quotation marks to make it into a string literal
+
 attr_parsing_invalid_predicate =
     invalid predicate `{$predicate}`
 
@@ -100,9 +123,36 @@ attr_parsing_invalid_style = {$is_used_as_inner ->
     }
     .note = This attribute does not have an `!`, which means it is applied to this {$target}
 
+attr_parsing_invalid_target = `#[{$name}]` attribute cannot be used on {$target}
+    .help = `#[{$name}]` can {$only}be applied to {$applied}
+    .suggestion = remove the attribute
+attr_parsing_invalid_target_lint = `#[{$name}]` attribute cannot be used on {$target}
+    .warn = {-attr_parsing_previously_accepted}
+    .help = `#[{$name}]` can {$only}be applied to {$applied}
+    .suggestion = remove the attribute
+
+attr_parsing_limit_invalid =
+    `limit` must be a non-negative integer
+    .label = {$error_str}
+attr_parsing_link_arg_unstable =
+    link kind `link-arg` is unstable
+
+attr_parsing_link_cfg_unstable =
+    link cfg is unstable
+
+attr_parsing_link_framework_apple =
+    link kind `framework` is only supported on Apple targets
+
 attr_parsing_link_ordinal_out_of_range = ordinal value in `link_ordinal` is too large: `{$ordinal}`
     .note = the value may not exceed `u16::MAX`
 
+attr_parsing_link_requires_name =
+    `#[link]` attribute requires a `name = "string"` argument
+    .label = missing `name` argument
+
+attr_parsing_meta_bad_delim = wrong meta list delimiters
+attr_parsing_meta_bad_delim_suggestion = the delimiters should be `(` and `)`
+
 attr_parsing_missing_feature =
     missing 'feature'
 
@@ -115,6 +165,9 @@ attr_parsing_missing_note =
 attr_parsing_missing_since =
     missing 'since'
 
+attr_parsing_multiple_modifiers =
+    multiple `{$modifier}` modifiers in a single `modifiers` argument
+
 attr_parsing_multiple_stability_levels =
     multiple stability levels
 
@@ -138,6 +191,15 @@ attr_parsing_objc_class_expected_string_literal = `objc::class!` expected a stri
 
 attr_parsing_objc_selector_expected_string_literal = `objc::selector!` expected a string literal
 
+attr_parsing_raw_dylib_elf_unstable =
+    link kind `raw-dylib` is unstable on ELF platforms
+
+attr_parsing_raw_dylib_no_nul =
+    link name must not contain NUL characters if link kind is `raw-dylib`
+
+attr_parsing_raw_dylib_only_windows =
+    link kind `raw-dylib` is only supported on Windows targets
+
 attr_parsing_repr_ident =
     meta item in `repr` must be an identifier
 
@@ -152,6 +214,9 @@ attr_parsing_soft_no_args =
 
 attr_parsing_stability_outside_std = stability attributes may not be used outside of the standard library
 
+attr_parsing_suffixed_literal_in_attribute = suffixed literals are not allowed in attributes
+    .help = instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
+
 attr_parsing_unknown_meta_item =
     unknown meta item '{$item}'
     .label = expected one of {$expected}
@@ -164,6 +229,10 @@ attr_parsing_unrecognized_repr_hint =
     .help = valid reprs are `Rust` (default), `C`, `align`, `packed`, `transparent`, `simd`, `i8`, `u8`, `i16`, `u16`, `i32`, `u32`, `i64`, `u64`, `i128`, `u128`, `isize`, `usize`
     .note = for more information, visit <https://doc.rust-lang.org/reference/type-layout.html?highlight=repr#representations>
 
+attr_parsing_unsafe_attr_outside_unsafe = unsafe attribute used without unsafe
+    .label = usage of unsafe attribute
+attr_parsing_unsafe_attr_outside_unsafe_suggestion = wrap the attribute in `unsafe(...)`
+
 attr_parsing_unstable_cfg_target_compact =
     compact `cfg(target(..))` is experimental and subject to change
 
@@ -193,77 +262,5 @@ attr_parsing_unused_multiple =
 -attr_parsing_previously_accepted =
     this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
-attr_parsing_meta_bad_delim = wrong meta list delimiters
-attr_parsing_meta_bad_delim_suggestion = the delimiters should be `(` and `)`
-
-attr_parsing_unsafe_attr_outside_unsafe = unsafe attribute used without unsafe
-    .label = usage of unsafe attribute
-attr_parsing_unsafe_attr_outside_unsafe_suggestion = wrap the attribute in `unsafe(...)`
-
-attr_parsing_invalid_attr_unsafe = `{$name}` is not an unsafe attribute
-    .label = this is not an unsafe attribute
-    .suggestion = remove the `unsafe(...)`
-    .note = extraneous unsafe is not allowed in attributes
-
-attr_parsing_invalid_meta_item = expected a literal (`1u8`, `1.0f32`, `"string"`, etc.) here, found {$descr}
-    .remove_neg_sugg = negative numbers are not literals, try removing the `-` sign
-    .quote_ident_sugg = surround the identifier with quotation marks to make it into a string literal
-
-attr_parsing_suffixed_literal_in_attribute = suffixed literals are not allowed in attributes
-    .help = instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
-
-attr_parsing_as_needed_compatibility =
-    linking modifier `as-needed` is only compatible with `dylib` and `framework` linking kinds
-
-attr_parsing_bundle_needs_static =
-    linking modifier `bundle` is only compatible with `static` linking kind
-
-attr_parsing_empty_link_name =
-    link name must not be empty
-    .label = empty link name
-
-attr_parsing_import_name_type_raw =
-    import name type can only be used with link kind `raw-dylib`
-
-attr_parsing_import_name_type_x86 =
-    import name type is only supported on x86
-
-attr_parsing_incompatible_wasm_link =
-    `wasm_import_module` is incompatible with other arguments in `#[link]` attributes
-
-attr_parsing_invalid_link_modifier =
-    invalid linking modifier syntax, expected '+' or '-' prefix before one of: bundle, verbatim, whole-archive, as-needed
-
-attr_parsing_link_arg_unstable =
-    link kind `link-arg` is unstable
-
-attr_parsing_link_cfg_unstable =
-    link cfg is unstable
-
-attr_parsing_link_framework_apple =
-    link kind `framework` is only supported on Apple targets
-
-attr_parsing_link_requires_name =
-    `#[link]` attribute requires a `name = "string"` argument
-    .label = missing `name` argument
-
-attr_parsing_multiple_modifiers =
-    multiple `{$modifier}` modifiers in a single `modifiers` argument
-
-attr_parsing_multiple_renamings =
-    multiple renamings were specified for library `{$lib_name}`
-attr_parsing_raw_dylib_no_nul =
-    link name must not contain NUL characters if link kind is `raw-dylib`
-
-attr_parsing_raw_dylib_elf_unstable =
-    link kind `raw-dylib` is unstable on ELF platforms
-
-attr_parsing_raw_dylib_only_windows =
-    link kind `raw-dylib` is only supported on Windows targets
-
 attr_parsing_whole_archive_needs_static =
     linking modifier `whole-archive` is only compatible with `static` linking kind
-
-attr_parsing_limit_invalid =
-    `limit` must be a non-negative integer
-    .label = {$error_str}
diff --git a/compiler/rustc_builtin_macros/messages.ftl b/compiler/rustc_builtin_macros/messages.ftl
index 7c1a5f44e165d..cbdd8199d7ba3 100644
--- a/compiler/rustc_builtin_macros/messages.ftl
+++ b/compiler/rustc_builtin_macros/messages.ftl
@@ -135,6 +135,15 @@ builtin_macros_concat_missing_literal = expected a literal
 builtin_macros_default_arg = `#[default]` attribute does not accept a value
     .suggestion = try using `#[default]`
 
+builtin_macros_derive_from_usage_note = `#[derive(From)]` can only be used on structs with exactly one field
+
+builtin_macros_derive_from_wrong_field_count = `#[derive(From)]` used on a struct with {$multiple_fields ->
+    [true] multiple fields
+    *[false] no fields
+}
+
+builtin_macros_derive_from_wrong_target = `#[derive(From)]` used on {$kind}
+
 builtin_macros_derive_macro_call = `derive` cannot be used on items with type macros
 
 builtin_macros_derive_path_args_list = traits in `#[derive(...)]` don't accept arguments
@@ -229,15 +238,6 @@ builtin_macros_format_unused_args = multiple unused formatting arguments
 
 builtin_macros_format_use_positional = consider using a positional formatting argument instead
 
-builtin_macros_derive_from_wrong_target = `#[derive(From)]` used on {$kind}
-
-builtin_macros_derive_from_wrong_field_count = `#[derive(From)]` used on a struct with {$multiple_fields ->
-    [true] multiple fields
-    *[false] no fields
-}
-
-builtin_macros_derive_from_usage_note = `#[derive(From)]` can only be used on structs with exactly one field
-
 builtin_macros_incomplete_include = include macro expected single expression in source
 
 builtin_macros_multiple_default_attrs = multiple `#[default]` attributes
diff --git a/compiler/rustc_codegen_ssa/messages.ftl b/compiler/rustc_codegen_ssa/messages.ftl
index 91c3806df4c34..97ff04f66daec 100644
--- a/compiler/rustc_codegen_ssa/messages.ftl
+++ b/compiler/rustc_codegen_ssa/messages.ftl
@@ -97,10 +97,10 @@ codegen_ssa_invalid_literal_value = invalid literal value
 
 codegen_ssa_invalid_monomorphization_basic_float_type = invalid monomorphization of `{$name}` intrinsic: expected basic float type, found `{$ty}`
 
-codegen_ssa_invalid_monomorphization_basic_integer_type = invalid monomorphization of `{$name}` intrinsic: expected basic integer type, found `{$ty}`
-
 codegen_ssa_invalid_monomorphization_basic_integer_or_ptr_type = invalid monomorphization of `{$name}` intrinsic: expected basic integer or pointer type, found `{$ty}`
 
+codegen_ssa_invalid_monomorphization_basic_integer_type = invalid monomorphization of `{$name}` intrinsic: expected basic integer type, found `{$ty}`
+
 codegen_ssa_invalid_monomorphization_cannot_return = invalid monomorphization of `{$name}` intrinsic: cannot return `{$ret_ty}`, expected `u{$expected_int_bits}` or `[u8; {$expected_bytes}]`
 
 codegen_ssa_invalid_monomorphization_cast_wide_pointer = invalid monomorphization of `{$name}` intrinsic: cannot cast wide pointer `{$ty}`
diff --git a/compiler/rustc_const_eval/messages.ftl b/compiler/rustc_const_eval/messages.ftl
index 010ffa60c7a53..13a49e80cf2dc 100644
--- a/compiler/rustc_const_eval/messages.ftl
+++ b/compiler/rustc_const_eval/messages.ftl
@@ -231,9 +231,6 @@ const_eval_mutable_borrow_escaping =
 
 const_eval_mutable_ptr_in_final = encountered mutable pointer in final value of {const_eval_intern_kind}
 
-const_eval_partial_pointer_in_final = encountered partial pointer in final value of {const_eval_intern_kind}
-    .note = while pointers can be broken apart into individual bytes during const-evaluation, only complete pointers (with all their bytes in the right order) are supported in the final value
-
 const_eval_nested_static_in_thread_local = #[thread_local] does not support implicit nested statics, please create explicit static items and refer to them instead
 
 const_eval_non_const_await =
@@ -302,6 +299,9 @@ const_eval_panic = evaluation panicked: {$msg}
 
 const_eval_panic_non_str = argument to `panic!()` in a const context must have type `&str`
 
+const_eval_partial_pointer_in_final = encountered partial pointer in final value of {const_eval_intern_kind}
+    .note = while pointers can be broken apart into individual bytes during const-evaluation, only complete pointers (with all their bytes in the right order) are supported in the final value
+
 const_eval_partial_pointer_read =
     unable to read parts of a pointer from memory at {$ptr}
 const_eval_pointer_arithmetic_overflow =
@@ -476,6 +476,7 @@ const_eval_validation_invalid_vtable_trait = {$front_matter}: wrong trait in wid
 const_eval_validation_mutable_ref_in_const = {$front_matter}: encountered mutable reference in `const` value
 const_eval_validation_mutable_ref_to_immutable = {$front_matter}: encountered mutable reference or box pointing to read-only memory
 const_eval_validation_never_val = {$front_matter}: encountered a value of the never type `!`
+const_eval_validation_nonnull_ptr_out_of_range = {$front_matter}: encountered a maybe-null pointer, but expected something that is definitely non-zero
 const_eval_validation_null_box = {$front_matter}: encountered a {$maybe ->
     [true] maybe-null
     *[false] null
@@ -485,7 +486,6 @@ const_eval_validation_null_ref = {$front_matter}: encountered a {$maybe ->
     [true] maybe-null
     *[false] null
   } reference
-const_eval_validation_nonnull_ptr_out_of_range = {$front_matter}: encountered a maybe-null pointer, but expected something that is definitely non-zero
 const_eval_validation_out_of_range = {$front_matter}: encountered {$value}, but expected something {$in_range}
 const_eval_validation_partial_pointer = {$front_matter}: encountered a partial pointer or a mix of pointers
 const_eval_validation_pointer_as_int = {$front_matter}: encountered a pointer, but {$expected}
diff --git a/compiler/rustc_expand/messages.ftl b/compiler/rustc_expand/messages.ftl
index 47c00bff5c950..e914f24e294cd 100644
--- a/compiler/rustc_expand/messages.ftl
+++ b/compiler/rustc_expand/messages.ftl
@@ -95,6 +95,8 @@ expand_malformed_feature_attribute =
     malformed `feature` attribute input
     .expected = expected just one word
 
+expand_meta_var_dif_seq_matchers = {$msg}
+
 expand_metavar_still_repeating = variable `{$ident}` is still repeating at this depth
     .label = expected repetition
 
@@ -102,8 +104,6 @@ expand_metavariable_wrong_operator = meta-variable repeats with different Kleene
     .binder_label = expected repetition
     .occurrence_label = conflicting repetition
 
-expand_meta_var_dif_seq_matchers = {$msg}
-
 expand_missing_fragment_specifier = missing fragment specifier
     .note = fragment specifiers must be provided
     .suggestion_add_fragspec = try adding a specifier here
@@ -198,12 +198,12 @@ expand_trailing_semi_macro = trailing semicolon in macro used in expression posi
 
 expand_unknown_macro_variable = unknown macro variable `{$name}`
 
+expand_unsupported_key_value =
+    key-value macro attributes are not supported
+
 expand_unused_builtin_attribute = unused attribute `{$attr_name}`
     .note = the built-in attribute `{$attr_name}` will be ignored, since it's applied to the macro invocation `{$macro_name}`
     .suggestion = remove the attribute
 
-expand_unsupported_key_value =
-    key-value macro attributes are not supported
-
 expand_wrong_fragment_kind =
     non-{$kind} macro in {$kind} position: {$name}
diff --git a/compiler/rustc_lint/messages.ftl b/compiler/rustc_lint/messages.ftl
index 5b98c9fafaad4..bc0a98fc7aa8a 100644
--- a/compiler/rustc_lint/messages.ftl
+++ b/compiler/rustc_lint/messages.ftl
@@ -392,6 +392,14 @@ lint_improper_ctypes_union_layout_help = consider adding a `#[repr(C)]` or `#[re
 lint_improper_ctypes_union_layout_reason = this union has unspecified layout
 lint_improper_ctypes_union_non_exhaustive = this union is non-exhaustive
 
+lint_int_to_ptr_transmutes = transmuting an integer to a pointer creates a pointer without provenance
+    .note = this is dangerous because dereferencing the resulting pointer is undefined behavior
+    .note_exposed_provenance = exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
+    .help_transmute = for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
+    .help_exposed_provenance = for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
+    .suggestion_with_exposed_provenance = use `std::ptr::with_exposed_provenance{$suffix}` instead to use a previously exposed provenance
+    .suggestion_without_provenance_mut = if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
+
 lint_invalid_asm_label_binary = avoid using labels containing only the digits `0` and `1` in inline assembly
     .label = use a different label that doesn't start with `0` or `1`
     .help = start numbering with `2` instead
@@ -439,14 +447,6 @@ lint_invalid_reference_casting_note_book = for more information, visit <https://
 
 lint_invalid_reference_casting_note_ty_has_interior_mutability = even for types with interior mutability, the only legal way to obtain a mutable pointer from a shared reference is through `UnsafeCell::get`
 
-lint_int_to_ptr_transmutes = transmuting an integer to a pointer creates a pointer without provenance
-    .note = this is dangerous because dereferencing the resulting pointer is undefined behavior
-    .note_exposed_provenance = exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
-    .help_transmute = for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
-    .help_exposed_provenance = for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
-    .suggestion_with_exposed_provenance = use `std::ptr::with_exposed_provenance{$suffix}` instead to use a previously exposed provenance
-    .suggestion_without_provenance_mut = if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
-
 lint_lintpass_by_hand = implementing `LintPass` by hand
     .help = try using `declare_lint_pass!` or `impl_lint_pass!` instead
 
diff --git a/compiler/rustc_metadata/messages.ftl b/compiler/rustc_metadata/messages.ftl
index e624bfc5b8bda..fac7b6c21f60c 100644
--- a/compiler/rustc_metadata/messages.ftl
+++ b/compiler/rustc_metadata/messages.ftl
@@ -98,13 +98,6 @@ metadata_full_metadata_not_found =
 metadata_global_alloc_required =
     no global memory allocator found but one is required; link to std or add `#[global_allocator]` to a static item that implements the GlobalAlloc trait
 
-metadata_incompatible_with_immediate_abort =
-    the crate `{$crate_name}` was compiled with a panic strategy which is incompatible with `immediate-abort`
-
-metadata_incompatible_with_immediate_abort_core =
-    the crate `core` was compiled with a panic strategy which is incompatible with `immediate-abort`
-    .help = consider building the standard library from source with `cargo build -Zbuild-std`
-
 metadata_incompatible_panic_in_drop_strategy =
     the crate `{$crate_name}` is compiled with the panic-in-drop strategy `{$found_strategy}` which is incompatible with this crate's strategy of `{$desired_strategy}`
 
@@ -132,6 +125,13 @@ metadata_incompatible_target_modifiers_r_missed =
     .note = `{$flag_name_prefixed}={$local_value}` in this crate is incompatible with unset `{$flag_name_prefixed}` in dependency `{$extern_crate}`
     .help = the `{$flag_name_prefixed}` flag modifies the ABI so Rust crates compiled with different values of this flag cannot be used together safely
 
+metadata_incompatible_with_immediate_abort =
+    the crate `{$crate_name}` was compiled with a panic strategy which is incompatible with `immediate-abort`
+
+metadata_incompatible_with_immediate_abort_core =
+    the crate `core` was compiled with a panic strategy which is incompatible with `immediate-abort`
+    .help = consider building the standard library from source with `cargo build -Zbuild-std`
+
 metadata_install_missing_components =
     maybe you need to install the missing components with: `rustup component add rust-src rustc-dev llvm-tools-preview`
 
@@ -197,6 +197,8 @@ metadata_prev_alloc_error_handler =
 metadata_prev_global_alloc =
     previous global allocator defined here
 
+metadata_raw_dylib_malformed =
+    link name must be well-formed if link kind is `raw-dylib`
 metadata_raw_dylib_unsupported_abi =
     ABI not supported by `#[link(kind = "raw-dylib")]` on this architecture
 
@@ -236,12 +238,3 @@ metadata_unknown_target_modifier_unsafe_allowed = unknown target modifier `{$fla
 
 metadata_wasm_c_abi =
     older versions of the `wasm-bindgen` crate are incompatible with current versions of Rust; please update to `wasm-bindgen` v0.2.88
-
-metadata_wasm_import_form =
-    wasm import module must be of the form `wasm_import_module = "string"`
-
-metadata_whole_archive_needs_static =
-    linking modifier `whole-archive` is only compatible with `static` linking kind
-
-metadata_raw_dylib_malformed =
-    link name must be well-formed if link kind is `raw-dylib`
diff --git a/compiler/rustc_middle/messages.ftl b/compiler/rustc_middle/messages.ftl
index 82f3df8da3b12..b46f43841c8e8 100644
--- a/compiler/rustc_middle/messages.ftl
+++ b/compiler/rustc_middle/messages.ftl
@@ -95,15 +95,15 @@ middle_layout_normalization_failure =
 middle_layout_references_error =
     the type has an unknown layout
 
-middle_layout_size_overflow =
-    values of the type `{$ty}` are too big for the target architecture
-
 middle_layout_simd_too_many =
     the SIMD type `{$ty}` has more elements than the limit {$max_lanes}
 
 middle_layout_simd_zero_length =
     the SIMD type `{$ty}` has zero elements
 
+middle_layout_size_overflow =
+    values of the type `{$ty}` are too big for the target architecture
+
 middle_layout_too_generic = the type `{$ty}` does not have a fixed layout
 
 middle_layout_unknown =
diff --git a/compiler/rustc_parse/messages.ftl b/compiler/rustc_parse/messages.ftl
index f83cf645f829d..b1894ab92192e 100644
--- a/compiler/rustc_parse/messages.ftl
+++ b/compiler/rustc_parse/messages.ftl
@@ -68,19 +68,19 @@ parse_attr_after_generic = trailing attribute after generic parameter
 parse_attr_without_generics = attribute without generic parameters
     .label = attributes are only permitted when preceding parameters
 
-parse_attribute_on_param_type = attributes cannot be applied to a function parameter's type
+parse_attribute_on_empty_type = attributes cannot be applied here
     .label = attributes are not allowed here
 
-parse_attribute_on_type = attributes cannot be applied to types
+parse_attribute_on_generic_arg = attributes cannot be applied to generic arguments
     .label = attributes are not allowed here
     .suggestion = remove attribute from here
 
-parse_attribute_on_generic_arg = attributes cannot be applied to generic arguments
+parse_attribute_on_param_type = attributes cannot be applied to a function parameter's type
     .label = attributes are not allowed here
-    .suggestion = remove attribute from here
 
-parse_attribute_on_empty_type = attributes cannot be applied here
+parse_attribute_on_type = attributes cannot be applied to types
     .label = attributes are not allowed here
+    .suggestion = remove attribute from here
 
 parse_bad_assoc_type_bounds = bounds on associated types do not belong here
     .label = belongs in `where` clause
@@ -868,7 +868,6 @@ parse_too_many_hashes = too many `#` symbols: raw strings may be delimited by up
 parse_too_short_hex_escape = numeric character escape is too short
 
 parse_trailing_vert_not_allowed = a trailing `{$token}` is not allowed in an or-pattern
-parse_trailing_vert_not_allowed_suggestion = remove the `{$token}`
 
 parse_trait_alias_cannot_be_auto = trait aliases cannot be `auto`
 parse_trait_alias_cannot_be_const = trait aliases cannot be `const`
diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index df4016dfa1b82..9971f0c3fa32e 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -13,10 +13,6 @@ passes_abi_ne =
 passes_abi_of =
     fn_abi_of({$fn_name}) = {$fn_abi}
 
-passes_macro_only_attribute =
-    attribute should be applied to a macro
-    .label = not a macro
-
 passes_attr_application_enum =
     attribute should be applied to an enum
     .label = not an enum
@@ -392,6 +388,10 @@ passes_macro_export_on_decl_macro =
     `#[macro_export]` has no effect on declarative macro definitions
     .note = declarative macros follow the same exporting rules as regular items
 
+passes_macro_only_attribute =
+    attribute should be applied to a macro
+    .label = not a macro
+
 passes_may_dangle =
     `#[may_dangle]` must be applied to a lifetime or type generic parameter in `Drop` impl
 
diff --git a/compiler/rustc_resolve/messages.ftl b/compiler/rustc_resolve/messages.ftl
index cc8fbc18b7377..5bf90d2637df5 100644
--- a/compiler/rustc_resolve/messages.ftl
+++ b/compiler/rustc_resolve/messages.ftl
@@ -93,9 +93,6 @@ resolve_consider_adding_a_derive =
 resolve_consider_adding_macro_export =
     consider adding a `#[macro_export]` to the macro in the imported module
 
-resolve_consider_marking_as_pub_crate =
-    in case you want to use the macro within this crate only, reduce the visibility to `pub(crate)`
-
 resolve_consider_declaring_with_pub =
     consider declaring type or module `{$ident}` with `pub`
 
@@ -108,6 +105,9 @@ resolve_consider_making_the_field_public =
 resolve_consider_marking_as_pub =
     consider marking `{$ident}` as `pub` in the imported module
 
+resolve_consider_marking_as_pub_crate =
+    in case you want to use the macro within this crate only, reduce the visibility to `pub(crate)`
+
 resolve_consider_move_macro_position =
     consider moving the definition of `{$ident}` before this call
 
@@ -248,15 +248,15 @@ resolve_lowercase_self =
     attempt to use a non-constant value in a constant
     .suggestion = try using `Self`
 
-resolve_macro_cannot_use_as_fn_like =
-    `{$ident}` exists, but has no rules for function-like invocation
-
 resolve_macro_cannot_use_as_attr =
     `{$ident}` exists, but has no `attr` rules
 
 resolve_macro_cannot_use_as_derive =
      `{$ident}` exists, but has no `derive` rules
 
+resolve_macro_cannot_use_as_fn_like =
+    `{$ident}` exists, but has no rules for function-like invocation
+
 resolve_macro_defined_later =
     a macro with the same name exists, but it appears later
 
diff --git a/compiler/rustc_ty_utils/messages.ftl b/compiler/rustc_ty_utils/messages.ftl
index 8bc7bf10865f5..c1684bfb43b66 100644
--- a/compiler/rustc_ty_utils/messages.ftl
+++ b/compiler/rustc_ty_utils/messages.ftl
@@ -52,8 +52,6 @@ ty_utils_non_primitive_simd_type = monomorphising SIMD type `{$ty}` with a non-p
 
 ty_utils_operation_not_supported = unsupported operation in generic constants
 
-ty_utils_oversized_simd_type = monomorphising SIMD type `{$ty}` of length greater than {$max_lanes}
-
 ty_utils_pointer_not_supported = pointer casts are not allowed in generic constants
 
 ty_utils_tuple_not_supported = tuple construction is not supported in generic constants
@@ -61,5 +59,3 @@ ty_utils_tuple_not_supported = tuple construction is not supported in generic co
 ty_utils_unexpected_fnptr_associated_item = `FnPtr` trait with unexpected associated item
 
 ty_utils_yield_not_supported = coroutine control flow is not allowed in generic constants
-
-ty_utils_zero_length_simd_type = monomorphising SIMD type `{$ty}` of zero length
diff --git a/src/tools/tidy/src/fluent_alphabetical.rs b/src/tools/tidy/src/fluent_alphabetical.rs
index 02b914c21aebf..b1d1c16b4549c 100644
--- a/src/tools/tidy/src/fluent_alphabetical.rs
+++ b/src/tools/tidy/src/fluent_alphabetical.rs
@@ -15,7 +15,7 @@ fn message() -> &'static Regex {
 }
 
 fn is_fluent(path: &Path) -> bool {
-    path.extension().is_some_and(|ext| ext == "flt")
+    path.extension().is_some_and(|ext| ext == "ftl")
 }
 
 fn check_alphabetic(

From b5fb01d67db9726180fd85b58d00e3b954fc7e45 Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Sat, 4 Oct 2025 15:53:00 -0400
Subject: [PATCH 1724/1889] Improve the advice given by panic_immediate_abort

---
 library/core/src/panicking.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/library/core/src/panicking.rs b/library/core/src/panicking.rs
index 3f30038dbc03e..b5150837e6a94 100644
--- a/library/core/src/panicking.rs
+++ b/library/core/src/panicking.rs
@@ -35,7 +35,8 @@ use crate::panic::{Location, PanicInfo};
 #[cfg(feature = "panic_immediate_abort")]
 compile_error!(
     "panic_immediate_abort is now a real panic strategy! \
-    Enable it with the compiler flags `-Zunstable-options -Cpanic=immediate-abort`"
+    Enable it with `panic = \"immediate-abort\"` in Cargo.toml, \
+    or with the compiler flags `-Zunstable-options -Cpanic=immediate-abort`"
 );
 
 // First we define the two main entry points that all panics go through.

From 5a38eb1ba8fbab69e03ba8521daeca8ff8dcb905 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Sat, 4 Oct 2025 23:58:30 +0200
Subject: [PATCH 1725/1889] a consistency fix

Others in the file skip the module name
---
 src/tools/compiletest/src/directives.rs | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/src/tools/compiletest/src/directives.rs b/src/tools/compiletest/src/directives.rs
index a79978d036cea..3dd9416516d2e 100644
--- a/src/tools/compiletest/src/directives.rs
+++ b/src/tools/compiletest/src/directives.rs
@@ -644,11 +644,9 @@ impl TestProps {
 
                     self.update_add_core_stubs(ln, config);
 
-                    if let Some(flags) = config.parse_name_value_directive(
-                        ln,
-                        directives::CORE_STUBS_COMPILE_FLAGS,
-                        testfile,
-                    ) {
+                    if let Some(flags) =
+                        config.parse_name_value_directive(ln, CORE_STUBS_COMPILE_FLAGS, testfile)
+                    {
                         let flags = split_flags(&flags);
                         for flag in &flags {
                             if flag == "--edition" || flag.starts_with("--edition=") {

From 757d98ce2b55162e22051be354418291e88f8d46 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Fri, 3 Oct 2025 13:20:39 +1000
Subject: [PATCH 1726/1889] Move `DirectiveLine` into its own submodule

---
 src/tools/compiletest/src/directives.rs      | 68 +-------------------
 src/tools/compiletest/src/directives/line.rs | 67 +++++++++++++++++++
 2 files changed, 69 insertions(+), 66 deletions(-)
 create mode 100644 src/tools/compiletest/src/directives/line.rs

diff --git a/src/tools/compiletest/src/directives.rs b/src/tools/compiletest/src/directives.rs
index a79978d036cea..edb06dd7345d9 100644
--- a/src/tools/compiletest/src/directives.rs
+++ b/src/tools/compiletest/src/directives.rs
@@ -15,6 +15,7 @@ use crate::directives::auxiliary::{AuxProps, parse_and_update_aux};
 use crate::directives::directive_names::{
     KNOWN_DIRECTIVE_NAMES, KNOWN_HTMLDOCCK_DIRECTIVE_NAMES, KNOWN_JSONDOCCK_DIRECTIVE_NAMES,
 };
+use crate::directives::line::{DirectiveLine, line_directive};
 use crate::directives::needs::CachedNeedsConditions;
 use crate::edition::{Edition, parse_edition};
 use crate::errors::ErrorKind;
@@ -25,6 +26,7 @@ use crate::{fatal, help};
 pub(crate) mod auxiliary;
 mod cfg;
 mod directive_names;
+mod line;
 mod needs;
 #[cfg(test)]
 mod tests;
@@ -824,70 +826,6 @@ impl TestProps {
     }
 }
 
-/// If the given line begins with the appropriate comment prefix for a directive,
-/// returns a struct containing various parts of the directive.
-fn line_directive<'line>(
-    line_number: usize,
-    original_line: &'line str,
-) -> Option<DirectiveLine<'line>> {
-    // Ignore lines that don't start with the comment prefix.
-    let after_comment =
-        original_line.trim_start().strip_prefix(COMPILETEST_DIRECTIVE_PREFIX)?.trim_start();
-
-    let revision;
-    let raw_directive;
-
-    if let Some(after_open_bracket) = after_comment.strip_prefix('[') {
-        // A comment like `//@[foo]` only applies to revision `foo`.
-        let Some((line_revision, after_close_bracket)) = after_open_bracket.split_once(']') else {
-            panic!(
-                "malformed condition directive: expected `{COMPILETEST_DIRECTIVE_PREFIX}[foo]`, found `{original_line}`"
-            )
-        };
-
-        revision = Some(line_revision);
-        raw_directive = after_close_bracket.trim_start();
-    } else {
-        revision = None;
-        raw_directive = after_comment;
-    };
-
-    Some(DirectiveLine { line_number, revision, raw_directive })
-}
-
-/// The (partly) broken-down contents of a line containing a test directive,
-/// which [`iter_directives`] passes to its callback function.
-///
-/// For example:
-///
-/// ```text
-/// //@ compile-flags: -O
-///     ^^^^^^^^^^^^^^^^^ raw_directive
-///
-/// //@ [foo] compile-flags: -O
-///      ^^^                    revision
-///           ^^^^^^^^^^^^^^^^^ raw_directive
-/// ```
-struct DirectiveLine<'ln> {
-    line_number: usize,
-    /// Some test directives start with a revision name in square brackets
-    /// (e.g. `[foo]`), and only apply to that revision of the test.
-    /// If present, this field contains the revision name (e.g. `foo`).
-    revision: Option<&'ln str>,
-    /// The main part of the directive, after removing the comment prefix
-    /// and the optional revision specifier.
-    ///
-    /// This is "raw" because the directive's name and colon-separated value
-    /// (if present) have not yet been extracted or checked.
-    raw_directive: &'ln str,
-}
-
-impl<'ln> DirectiveLine<'ln> {
-    fn applies_to_test_revision(&self, test_revision: Option<&str>) -> bool {
-        self.revision.is_none() || self.revision == test_revision
-    }
-}
-
 pub(crate) struct CheckDirectiveResult<'ln> {
     is_known_directive: bool,
     trailing_directive: Option<&'ln str>,
@@ -920,8 +858,6 @@ fn check_directive<'a>(
     CheckDirectiveResult { is_known_directive, trailing_directive }
 }
 
-const COMPILETEST_DIRECTIVE_PREFIX: &str = "//@";
-
 fn iter_directives(
     mode: TestMode,
     poisoned: &mut bool,
diff --git a/src/tools/compiletest/src/directives/line.rs b/src/tools/compiletest/src/directives/line.rs
new file mode 100644
index 0000000000000..584d5b5b35bec
--- /dev/null
+++ b/src/tools/compiletest/src/directives/line.rs
@@ -0,0 +1,67 @@
+const COMPILETEST_DIRECTIVE_PREFIX: &str = "//@";
+
+/// If the given line begins with the appropriate comment prefix for a directive,
+/// returns a struct containing various parts of the directive.
+pub(crate) fn line_directive<'line>(
+    line_number: usize,
+    original_line: &'line str,
+) -> Option<DirectiveLine<'line>> {
+    // Ignore lines that don't start with the comment prefix.
+    let after_comment =
+        original_line.trim_start().strip_prefix(COMPILETEST_DIRECTIVE_PREFIX)?.trim_start();
+
+    let revision;
+    let raw_directive;
+
+    if let Some(after_open_bracket) = after_comment.strip_prefix('[') {
+        // A comment like `//@[foo]` only applies to revision `foo`.
+        let Some((line_revision, after_close_bracket)) = after_open_bracket.split_once(']') else {
+            panic!(
+                "malformed condition directive: expected `{COMPILETEST_DIRECTIVE_PREFIX}[foo]`, found `{original_line}`"
+            )
+        };
+
+        revision = Some(line_revision);
+        raw_directive = after_close_bracket.trim_start();
+    } else {
+        revision = None;
+        raw_directive = after_comment;
+    };
+
+    Some(DirectiveLine { line_number, revision, raw_directive })
+}
+
+/// The (partly) broken-down contents of a line containing a test directive,
+/// which `iter_directives` passes to its callback function.
+///
+/// For example:
+///
+/// ```text
+/// //@ compile-flags: -O
+///     ^^^^^^^^^^^^^^^^^ raw_directive
+///
+/// //@ [foo] compile-flags: -O
+///      ^^^                    revision
+///           ^^^^^^^^^^^^^^^^^ raw_directive
+/// ```
+pub(crate) struct DirectiveLine<'ln> {
+    pub(crate) line_number: usize,
+
+    /// Some test directives start with a revision name in square brackets
+    /// (e.g. `[foo]`), and only apply to that revision of the test.
+    /// If present, this field contains the revision name (e.g. `foo`).
+    pub(crate) revision: Option<&'ln str>,
+
+    /// The main part of the directive, after removing the comment prefix
+    /// and the optional revision specifier.
+    ///
+    /// This is "raw" because the directive's name and colon-separated value
+    /// (if present) have not yet been extracted or checked.
+    pub(crate) raw_directive: &'ln str,
+}
+
+impl<'ln> DirectiveLine<'ln> {
+    pub(crate) fn applies_to_test_revision(&self, test_revision: Option<&str>) -> bool {
+        self.revision.is_none() || self.revision == test_revision
+    }
+}

From 6783e9465b62e77c7e3cb76a747d92b1de4339f7 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Thu, 2 Oct 2025 20:08:40 +1000
Subject: [PATCH 1727/1889] Allow easy extraction of name/value from a
 `DirectiveLine`

---
 src/tools/compiletest/src/directives.rs      | 10 +++--
 src/tools/compiletest/src/directives/line.rs | 45 +++++++++++++++++++-
 2 files changed, 50 insertions(+), 5 deletions(-)

diff --git a/src/tools/compiletest/src/directives.rs b/src/tools/compiletest/src/directives.rs
index edb06dd7345d9..bbbeecc1b71b0 100644
--- a/src/tools/compiletest/src/directives.rs
+++ b/src/tools/compiletest/src/directives.rs
@@ -875,15 +875,17 @@ fn iter_directives(
     // FIXME(jieyouxu): I feel like there's a better way to do this, leaving for later.
     if mode == TestMode::CoverageRun {
         let extra_directives: &[&str] = &[
-            "needs-profiler-runtime",
+            "//@ needs-profiler-runtime",
             // FIXME(pietroalbini): this test currently does not work on cross-compiled targets
             // because remote-test is not capable of sending back the *.profraw files generated by
             // the LLVM instrumentation.
-            "ignore-cross-compile",
+            "//@ ignore-cross-compile",
         ];
         // Process the extra implied directives, with a dummy line number of 0.
-        for raw_directive in extra_directives {
-            it(DirectiveLine { line_number: 0, revision: None, raw_directive });
+        for directive_str in extra_directives {
+            let directive_line = line_directive(0, directive_str)
+                .unwrap_or_else(|| panic!("bad extra-directive line: {directive_str:?}"));
+            it(directive_line);
         }
     }
 
diff --git a/src/tools/compiletest/src/directives/line.rs b/src/tools/compiletest/src/directives/line.rs
index 584d5b5b35bec..5c1b592d045d8 100644
--- a/src/tools/compiletest/src/directives/line.rs
+++ b/src/tools/compiletest/src/directives/line.rs
@@ -1,3 +1,7 @@
+#![expect(dead_code)] // (removed later in this PR)
+
+use std::fmt;
+
 const COMPILETEST_DIRECTIVE_PREFIX: &str = "//@";
 
 /// If the given line begins with the appropriate comment prefix for a directive,
@@ -28,7 +32,10 @@ pub(crate) fn line_directive<'line>(
         raw_directive = after_comment;
     };
 
-    Some(DirectiveLine { line_number, revision, raw_directive })
+    // The directive name ends at the first occurrence of colon, space, or end-of-string.
+    let name = raw_directive.split([':', ' ']).next().expect("split is never empty");
+
+    Some(DirectiveLine { line_number, revision, raw_directive, name })
 }
 
 /// The (partly) broken-down contents of a line containing a test directive,
@@ -39,10 +46,12 @@ pub(crate) fn line_directive<'line>(
 /// ```text
 /// //@ compile-flags: -O
 ///     ^^^^^^^^^^^^^^^^^ raw_directive
+///     ^^^^^^^^^^^^^     name
 ///
 /// //@ [foo] compile-flags: -O
 ///      ^^^                    revision
 ///           ^^^^^^^^^^^^^^^^^ raw_directive
+///           ^^^^^^^^^^^^^     name
 /// ```
 pub(crate) struct DirectiveLine<'ln> {
     pub(crate) line_number: usize,
@@ -58,10 +67,44 @@ pub(crate) struct DirectiveLine<'ln> {
     /// This is "raw" because the directive's name and colon-separated value
     /// (if present) have not yet been extracted or checked.
     pub(crate) raw_directive: &'ln str,
+
+    /// Name of the directive.
+    ///
+    /// Invariant: `self.raw_directive.starts_with(self.name)`
+    pub(crate) name: &'ln str,
 }
 
 impl<'ln> DirectiveLine<'ln> {
     pub(crate) fn applies_to_test_revision(&self, test_revision: Option<&str>) -> bool {
         self.revision.is_none() || self.revision == test_revision
     }
+
+    /// Helper method used by `value_after_colon` and `remark_after_space`.
+    /// Don't call this directly.
+    fn rest_after_separator(&self, separator: u8) -> Option<&'ln str> {
+        let n = self.name.len();
+        if self.raw_directive.as_bytes().get(n) != Some(&separator) {
+            return None;
+        }
+
+        Some(&self.raw_directive[n + 1..])
+    }
+
+    /// If this directive uses `name: value` syntax, returns the part after
+    /// the colon character.
+    pub(crate) fn value_after_colon(&self) -> Option<&'ln str> {
+        self.rest_after_separator(b':')
+    }
+
+    /// If this directive uses `name remark` syntax, returns the part after
+    /// the separating space.
+    pub(crate) fn remark_after_space(&self) -> Option<&'ln str> {
+        self.rest_after_separator(b' ')
+    }
+
+    /// Allows callers to print `raw_directive` if necessary,
+    /// without accessing the field directly.
+    pub(crate) fn display(&self) -> impl fmt::Display {
+        self.raw_directive
+    }
 }

From 33c99a0468302f1bb9bd7dd0d63d460b1a88ed52 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Thu, 2 Oct 2025 20:16:59 +1000
Subject: [PATCH 1728/1889] Use new `DirectiveLine` features in directive
 parsing

---
 src/tools/compiletest/src/directives.rs       | 102 +++++++++---------
 .../compiletest/src/directives/auxiliary.rs   |   4 +-
 src/tools/compiletest/src/directives/cfg.rs   |  26 ++---
 src/tools/compiletest/src/directives/line.rs  |   4 +-
 src/tools/compiletest/src/directives/needs.rs |  15 +--
 src/tools/compiletest/src/directives/tests.rs |  11 +-
 6 files changed, 73 insertions(+), 89 deletions(-)

diff --git a/src/tools/compiletest/src/directives.rs b/src/tools/compiletest/src/directives.rs
index bbbeecc1b71b0..dab6850e0d62a 100644
--- a/src/tools/compiletest/src/directives.rs
+++ b/src/tools/compiletest/src/directives.rs
@@ -835,9 +835,7 @@ fn check_directive<'a>(
     directive_ln: &DirectiveLine<'a>,
     mode: TestMode,
 ) -> CheckDirectiveResult<'a> {
-    let &DirectiveLine { raw_directive: directive_ln, .. } = directive_ln;
-
-    let (directive_name, post) = directive_ln.split_once([':', ' ']).unwrap_or((directive_ln, ""));
+    let &DirectiveLine { name: directive_name, .. } = directive_ln;
 
     let is_known_directive = KNOWN_DIRECTIVE_NAMES.contains(&directive_name)
         || match mode {
@@ -846,14 +844,13 @@ fn check_directive<'a>(
             _ => false,
         };
 
-    let trailing = post.trim().split_once(' ').map(|(pre, _)| pre).unwrap_or(post);
-    let trailing_directive = {
-        // 1. is the directive name followed by a space? (to exclude `:`)
-        directive_ln.get(directive_name.len()..).is_some_and(|s| s.starts_with(' '))
-            // 2. is what is after that directive also a directive (ex: "only-x86 only-arm")
-            && KNOWN_DIRECTIVE_NAMES.contains(&trailing)
-    }
-    .then_some(trailing);
+    // If it looks like the user tried to put two directives on the same line
+    // (e.g. `//@ only-linux only-x86_64`), signal an error, because the
+    // second "directive" would actually be ignored with no effect.
+    let trailing_directive = directive_ln
+        .remark_after_space()
+        .map(|remark| remark.trim_start().split(' ').next().unwrap())
+        .filter(|token| KNOWN_DIRECTIVE_NAMES.contains(token));
 
     CheckDirectiveResult { is_known_directive, trailing_directive }
 }
@@ -915,7 +912,7 @@ fn iter_directives(
 
                 error!(
                     "{testfile}:{line_number}: detected unknown compiletest test directive `{}`",
-                    directive_line.raw_directive,
+                    directive_line.display(),
                 );
 
                 return;
@@ -1011,13 +1008,9 @@ impl Config {
     }
 
     fn parse_custom_normalization(&self, line: &DirectiveLine<'_>) -> Option<NormalizeRule> {
-        let &DirectiveLine { raw_directive, .. } = line;
-
-        // FIXME(Zalathar): Integrate name/value splitting into `DirectiveLine`
-        // instead of doing it here.
-        let (directive_name, raw_value) = raw_directive.split_once(':')?;
+        let &DirectiveLine { name, .. } = line;
 
-        let kind = match directive_name {
+        let kind = match name {
             "normalize-stdout" => NormalizeKind::Stdout,
             "normalize-stderr" => NormalizeKind::Stderr,
             "normalize-stderr-32bit" => NormalizeKind::Stderr32bit,
@@ -1025,21 +1018,20 @@ impl Config {
             _ => return None,
         };
 
-        let Some((regex, replacement)) = parse_normalize_rule(raw_value) else {
-            error!("couldn't parse custom normalization rule: `{raw_directive}`");
-            help!("expected syntax is: `{directive_name}: \"REGEX\" -> \"REPLACEMENT\"`");
+        let Some((regex, replacement)) = line.value_after_colon().and_then(parse_normalize_rule)
+        else {
+            error!("couldn't parse custom normalization rule: `{}`", line.display());
+            help!("expected syntax is: `{name}: \"REGEX\" -> \"REPLACEMENT\"`");
             panic!("invalid normalization rule detected");
         };
         Some(NormalizeRule { kind, regex, replacement })
     }
 
     fn parse_name_directive(&self, line: &DirectiveLine<'_>, directive: &str) -> bool {
-        let &DirectiveLine { raw_directive: line, .. } = line;
-
-        // Ensure the directive is a whole word. Do not match "ignore-x86" when
-        // the line says "ignore-x86_64".
-        line.starts_with(directive)
-            && matches!(line.as_bytes().get(directive.len()), None | Some(&b' ') | Some(&b':'))
+        // FIXME(Zalathar): Ideally, this should raise an error if a name-only
+        // directive is followed by a colon, since that's the wrong syntax.
+        // But we would need to fix tests that rely on the current behaviour.
+        line.name == directive
     }
 
     fn parse_name_value_directive(
@@ -1048,22 +1040,26 @@ impl Config {
         directive: &str,
         testfile: &Utf8Path,
     ) -> Option<String> {
-        let &DirectiveLine { line_number, raw_directive: line, .. } = line;
-
-        let colon = directive.len();
-        if line.starts_with(directive) && line.as_bytes().get(colon) == Some(&b':') {
-            let value = line[(colon + 1)..].to_owned();
-            debug!("{}: {}", directive, value);
-            let value = expand_variables(value, self);
-            if value.is_empty() {
-                error!("{testfile}:{line_number}: empty value for directive `{directive}`");
-                help!("expected syntax is: `{directive}: value`");
-                panic!("empty directive value detected");
-            }
-            Some(value)
-        } else {
-            None
+        let &DirectiveLine { line_number, .. } = line;
+
+        if line.name != directive {
+            return None;
+        };
+
+        // FIXME(Zalathar): This silently discards directives with a matching
+        // name but no colon. Unfortunately, some directives (e.g. "pp-exact")
+        // currently rely on _not_ panicking here.
+        let value = line.value_after_colon()?;
+        debug!("{}: {}", directive, value);
+        let value = expand_variables(value.to_owned(), self);
+
+        if value.is_empty() {
+            error!("{testfile}:{line_number}: empty value for directive `{directive}`");
+            help!("expected syntax is: `{directive}: value`");
+            panic!("empty directive value detected");
         }
+
+        Some(value)
     }
 
     fn set_name_directive(&self, line: &DirectiveLine<'_>, directive: &str, value: &mut bool) {
@@ -1453,14 +1449,14 @@ pub(crate) fn make_test_description<R: Read>(
 }
 
 fn ignore_cdb(config: &Config, line: &DirectiveLine<'_>) -> IgnoreDecision {
-    let &DirectiveLine { raw_directive: line, .. } = line;
-
     if config.debugger != Some(Debugger::Cdb) {
         return IgnoreDecision::Continue;
     }
 
     if let Some(actual_version) = config.cdb_version {
-        if let Some(rest) = line.strip_prefix("min-cdb-version:").map(str::trim) {
+        if line.name == "min-cdb-version"
+            && let Some(rest) = line.value_after_colon().map(str::trim)
+        {
             let min_version = extract_cdb_version(rest).unwrap_or_else(|| {
                 panic!("couldn't parse version range: {:?}", rest);
             });
@@ -1478,14 +1474,14 @@ fn ignore_cdb(config: &Config, line: &DirectiveLine<'_>) -> IgnoreDecision {
 }
 
 fn ignore_gdb(config: &Config, line: &DirectiveLine<'_>) -> IgnoreDecision {
-    let &DirectiveLine { raw_directive: line, .. } = line;
-
     if config.debugger != Some(Debugger::Gdb) {
         return IgnoreDecision::Continue;
     }
 
     if let Some(actual_version) = config.gdb_version {
-        if let Some(rest) = line.strip_prefix("min-gdb-version:").map(str::trim) {
+        if line.name == "min-gdb-version"
+            && let Some(rest) = line.value_after_colon().map(str::trim)
+        {
             let (start_ver, end_ver) = extract_version_range(rest, extract_gdb_version)
                 .unwrap_or_else(|| {
                     panic!("couldn't parse version range: {:?}", rest);
@@ -1501,7 +1497,9 @@ fn ignore_gdb(config: &Config, line: &DirectiveLine<'_>) -> IgnoreDecision {
                     reason: format!("ignored when the GDB version is lower than {rest}"),
                 };
             }
-        } else if let Some(rest) = line.strip_prefix("ignore-gdb-version:").map(str::trim) {
+        } else if line.name == "ignore-gdb-version"
+            && let Some(rest) = line.value_after_colon().map(str::trim)
+        {
             let (min_version, max_version) = extract_version_range(rest, extract_gdb_version)
                 .unwrap_or_else(|| {
                     panic!("couldn't parse version range: {:?}", rest);
@@ -1528,14 +1526,14 @@ fn ignore_gdb(config: &Config, line: &DirectiveLine<'_>) -> IgnoreDecision {
 }
 
 fn ignore_lldb(config: &Config, line: &DirectiveLine<'_>) -> IgnoreDecision {
-    let &DirectiveLine { raw_directive: line, .. } = line;
-
     if config.debugger != Some(Debugger::Lldb) {
         return IgnoreDecision::Continue;
     }
 
     if let Some(actual_version) = config.lldb_version {
-        if let Some(rest) = line.strip_prefix("min-lldb-version:").map(str::trim) {
+        if line.name == "min-lldb-version"
+            && let Some(rest) = line.value_after_colon().map(str::trim)
+        {
             let min_version = rest.parse().unwrap_or_else(|e| {
                 panic!("Unexpected format of LLDB version string: {}\n{:?}", rest, e);
             });
diff --git a/src/tools/compiletest/src/directives/auxiliary.rs b/src/tools/compiletest/src/directives/auxiliary.rs
index 0675a6feac3f0..7cf98178e733f 100644
--- a/src/tools/compiletest/src/directives/auxiliary.rs
+++ b/src/tools/compiletest/src/directives/auxiliary.rs
@@ -50,9 +50,7 @@ pub(super) fn parse_and_update_aux(
     testfile: &Utf8Path,
     aux: &mut AuxProps,
 ) {
-    let &DirectiveLine { raw_directive: ln, .. } = directive_line;
-
-    if !(ln.starts_with("aux-") || ln.starts_with("proc-macro")) {
+    if !(directive_line.name.starts_with("aux-") || directive_line.name == "proc-macro") {
         return;
     }
 
diff --git a/src/tools/compiletest/src/directives/cfg.rs b/src/tools/compiletest/src/directives/cfg.rs
index 62a4b88a33a6e..3855ba7ac5f42 100644
--- a/src/tools/compiletest/src/directives/cfg.rs
+++ b/src/tools/compiletest/src/directives/cfg.rs
@@ -6,8 +6,8 @@ use crate::directives::{DirectiveLine, IgnoreDecision};
 const EXTRA_ARCHS: &[&str] = &["spirv"];
 
 pub(super) fn handle_ignore(config: &Config, line: &DirectiveLine<'_>) -> IgnoreDecision {
-    let parsed = parse_cfg_name_directive(config, line, "ignore");
-    let &DirectiveLine { raw_directive: line, .. } = line;
+    let parsed = parse_cfg_name_directive(config, line, "ignore-");
+    let line = line.display();
 
     match parsed.outcome {
         MatchOutcome::NoMatch => IgnoreDecision::Continue,
@@ -24,8 +24,8 @@ pub(super) fn handle_ignore(config: &Config, line: &DirectiveLine<'_>) -> Ignore
 }
 
 pub(super) fn handle_only(config: &Config, line: &DirectiveLine<'_>) -> IgnoreDecision {
-    let parsed = parse_cfg_name_directive(config, line, "only");
-    let &DirectiveLine { raw_directive: line, .. } = line;
+    let parsed = parse_cfg_name_directive(config, line, "only-");
+    let line = line.display();
 
     match parsed.outcome {
         MatchOutcome::Match => IgnoreDecision::Continue,
@@ -50,18 +50,14 @@ fn parse_cfg_name_directive<'a>(
     line: &'a DirectiveLine<'a>,
     prefix: &str,
 ) -> ParsedNameDirective<'a> {
-    let &DirectiveLine { raw_directive: line, .. } = line;
-
-    if !line.as_bytes().starts_with(prefix.as_bytes()) {
-        return ParsedNameDirective::not_a_directive();
-    }
-    if line.as_bytes().get(prefix.len()) != Some(&b'-') {
+    let Some(name) = line.name.strip_prefix(prefix) else {
         return ParsedNameDirective::not_a_directive();
-    }
-    let line = &line[prefix.len() + 1..];
+    };
 
-    let (name, comment) =
-        line.split_once(&[':', ' ']).map(|(l, c)| (l, Some(c))).unwrap_or((line, None));
+    // FIXME(Zalathar): This currently allows either a space or a colon, and
+    // treats any "value" after a colon as though it were a remark.
+    // We should instead forbid the colon syntax for these directives.
+    let comment = line.remark_after_space().or_else(|| line.value_after_colon());
 
     // Some of the matchers might be "" depending on what the target information is. To avoid
     // problems we outright reject empty directives.
@@ -269,7 +265,7 @@ fn parse_cfg_name_directive<'a>(
         message: "when performing tests on dist toolchain"
     }
 
-    if prefix == "ignore" && outcome == MatchOutcome::Invalid {
+    if prefix == "ignore-" && outcome == MatchOutcome::Invalid {
         // Don't error out for ignore-tidy-* diretives, as those are not handled by compiletest.
         if name.starts_with("tidy-") {
             outcome = MatchOutcome::External;
diff --git a/src/tools/compiletest/src/directives/line.rs b/src/tools/compiletest/src/directives/line.rs
index 5c1b592d045d8..49907207d2e61 100644
--- a/src/tools/compiletest/src/directives/line.rs
+++ b/src/tools/compiletest/src/directives/line.rs
@@ -1,5 +1,3 @@
-#![expect(dead_code)] // (removed later in this PR)
-
 use std::fmt;
 
 const COMPILETEST_DIRECTIVE_PREFIX: &str = "//@";
@@ -66,7 +64,7 @@ pub(crate) struct DirectiveLine<'ln> {
     ///
     /// This is "raw" because the directive's name and colon-separated value
     /// (if present) have not yet been extracted or checked.
-    pub(crate) raw_directive: &'ln str,
+    raw_directive: &'ln str,
 
     /// Name of the directive.
     ///
diff --git a/src/tools/compiletest/src/directives/needs.rs b/src/tools/compiletest/src/directives/needs.rs
index 9d72492e5b078..5e9fe59d8d1c3 100644
--- a/src/tools/compiletest/src/directives/needs.rs
+++ b/src/tools/compiletest/src/directives/needs.rs
@@ -181,17 +181,10 @@ pub(super) fn handle_needs(
         },
     ];
 
-    let &DirectiveLine { raw_directive: ln, .. } = ln;
+    let &DirectiveLine { name, .. } = ln;
 
-    let (name, rest) = match ln.split_once([':', ' ']) {
-        Some((name, rest)) => (name, Some(rest)),
-        None => (ln, None),
-    };
-
-    // FIXME(jieyouxu): tighten up this parsing to reject using both `:` and ` ` as means to
-    // delineate value.
     if name == "needs-target-has-atomic" {
-        let Some(rest) = rest else {
+        let Some(rest) = ln.value_after_colon() else {
             return IgnoreDecision::Error {
                 message: "expected `needs-target-has-atomic` to have a comma-separated list of atomic widths".to_string(),
             };
@@ -233,7 +226,7 @@ pub(super) fn handle_needs(
 
     // FIXME(jieyouxu): share multi-value directive logic with `needs-target-has-atomic` above.
     if name == "needs-crate-type" {
-        let Some(rest) = rest else {
+        let Some(rest) = ln.value_after_colon() else {
             return IgnoreDecision::Error {
                 message:
                     "expected `needs-crate-type` to have a comma-separated list of crate types"
@@ -292,7 +285,7 @@ pub(super) fn handle_needs(
                 break;
             } else {
                 return IgnoreDecision::Ignore {
-                    reason: if let Some(comment) = rest {
+                    reason: if let Some(comment) = ln.remark_after_space() {
                         format!("{} ({})", need.ignore_reason, comment.trim())
                     } else {
                         need.ignore_reason.into()
diff --git a/src/tools/compiletest/src/directives/tests.rs b/src/tools/compiletest/src/directives/tests.rs
index 93621192d4bd6..95dd46532ba88 100644
--- a/src/tools/compiletest/src/directives/tests.rs
+++ b/src/tools/compiletest/src/directives/tests.rs
@@ -3,12 +3,11 @@ use std::io::Read;
 use camino::Utf8Path;
 use semver::Version;
 
-use super::{
+use crate::common::{Config, Debugger, TestMode};
+use crate::directives::{
     DirectivesCache, EarlyProps, Edition, EditionRange, extract_llvm_version,
-    extract_version_range, iter_directives, parse_normalize_rule,
+    extract_version_range, iter_directives, line_directive, parse_edition, parse_normalize_rule,
 };
-use crate::common::{Config, Debugger, TestMode};
-use crate::directives::parse_edition;
 use crate::executor::{CollectedTestDesc, ShouldPanic};
 
 fn make_test_description<R: Read>(
@@ -955,7 +954,9 @@ fn test_needs_target_std() {
 
 fn parse_edition_range(line: &str) -> Option<EditionRange> {
     let config = cfg().build();
-    let line = super::DirectiveLine { line_number: 0, revision: None, raw_directive: line };
+
+    let line_with_comment = format!("//@ {line}");
+    let line = line_directive(0, &line_with_comment).unwrap();
 
     super::parse_edition_range(&config, &line, "tmp.rs".into())
 }

From 34ad9198584b2245024e8735809e6a3567e504cb Mon Sep 17 00:00:00 2001
From: yukang <moorekang@gmail.com>
Date: Sun, 5 Oct 2025 11:11:47 +0800
Subject: [PATCH 1729/1889] Remove extra space for missing associated type term

---
 compiler/rustc_parse/src/parser/path.rs       | 19 ++++++++-----------
 .../recover-assoc-eq-missing-term.stderr      |  2 +-
 2 files changed, 9 insertions(+), 12 deletions(-)

diff --git a/compiler/rustc_parse/src/parser/path.rs b/compiler/rustc_parse/src/parser/path.rs
index 8604564885916..f7757921cd426 100644
--- a/compiler/rustc_parse/src/parser/path.rs
+++ b/compiler/rustc_parse/src/parser/path.rs
@@ -753,18 +753,13 @@ impl<'a> Parser<'a> {
                     }
                     let kind = if self.eat(exp!(Colon)) {
                         AssocItemConstraintKind::Bound { bounds: self.parse_generic_bounds()? }
-                    } else if self.eat(exp!(Eq)) {
-                        self.parse_assoc_equality_term(
-                            ident,
-                            gen_args.as_ref(),
-                            self.prev_token.span,
-                        )?
+                    } else if self.check(exp!(Eq)) {
+                        self.parse_assoc_equality_term(ident, gen_args.as_ref())?
                     } else {
                         unreachable!();
                     };
 
                     let span = lo.to(self.prev_token.span);
-
                     let constraint =
                         AssocItemConstraint { id: ast::DUMMY_NODE_ID, ident, gen_args, kind, span };
                     Ok(Some(AngleBracketedArg::Constraint(constraint)))
@@ -792,8 +787,10 @@ impl<'a> Parser<'a> {
         &mut self,
         ident: Ident,
         gen_args: Option<&GenericArgs>,
-        eq: Span,
     ) -> PResult<'a, AssocItemConstraintKind> {
+        let prev_token_span = self.prev_token.span;
+        let eq_span = self.token.span;
+        self.expect(exp!(Eq))?;
         let arg = self.parse_generic_arg(None)?;
         let span = ident.span.to(self.prev_token.span);
         let term = match arg {
@@ -814,20 +811,20 @@ impl<'a> Parser<'a> {
                 self.mk_ty(lt.ident.span, ast::TyKind::Err(guar)).into()
             }
             None => {
-                let after_eq = eq.shrink_to_hi();
+                let after_eq = eq_span.shrink_to_hi();
                 let before_next = self.token.span.shrink_to_lo();
                 let mut err = self
                     .dcx()
                     .struct_span_err(after_eq.to(before_next), "missing type to the right of `=`");
                 if matches!(self.token.kind, token::Comma | token::Gt) {
                     err.span_suggestion(
-                        self.psess.source_map().next_point(eq).to(before_next),
+                        self.psess.source_map().next_point(eq_span).to(before_next),
                         "to constrain the associated type, add a type after `=`",
                         " TheType",
                         Applicability::HasPlaceholders,
                     );
                     err.span_suggestion(
-                        eq.to(before_next),
+                        prev_token_span.shrink_to_hi().to(before_next),
                         format!("remove the `=` if `{ident}` is a type"),
                         "",
                         Applicability::MaybeIncorrect,
diff --git a/tests/ui/parser/recover/recover-assoc-eq-missing-term.stderr b/tests/ui/parser/recover/recover-assoc-eq-missing-term.stderr
index cf50c026665b5..2d8ab7a3e2f76 100644
--- a/tests/ui/parser/recover/recover-assoc-eq-missing-term.stderr
+++ b/tests/ui/parser/recover/recover-assoc-eq-missing-term.stderr
@@ -11,7 +11,7 @@ LL |     bar::<Item = TheType>();
 help: remove the `=` if `Item` is a type
    |
 LL -     bar::<Item =   >();
-LL +     bar::<Item >();
+LL +     bar::<Item>();
    |
 
 error: aborting due to 1 previous error

From a175921d5e67997e359e71dc1602bd1e3547c0d7 Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Sat, 4 Oct 2025 23:52:33 -0400
Subject: [PATCH 1730/1889] update libEnzyme file name, and add missing
 strict-aliasing flag

---
 src/doc/rustc-dev-guide/src/autodiff/debugging.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/autodiff/debugging.md b/src/doc/rustc-dev-guide/src/autodiff/debugging.md
index bd46a66fade47..a66d775d98264 100644
--- a/src/doc/rustc-dev-guide/src/autodiff/debugging.md
+++ b/src/doc/rustc-dev-guide/src/autodiff/debugging.md
@@ -16,7 +16,7 @@ Before generating the llvm-ir, keep in mind two techniques that can help ensure
 ## 1) Generate an llvm-ir reproducer
 
 ```sh
-rustflags="-z autodiff=enable,printmodbefore" cargo +enzyme build --release &> out.ll 
+RUSTFLAGS="-Z autodiff=Enable,PrintModbefore" cargo +enzyme build --release &> out.ll 
 ```
 
 This also captures a few warnings and info messages above and below your module. open out.ll and remove every line above `; moduleid = <somehash>`. Now look at the end of the file and remove everything that's not part of llvm-ir, i.e. remove errors and warnings. The last line of your llvm-ir should now start with `!<somenumber> = `, i.e. `!40831 = !{i32 0, i32 1037508, i32 1037538, i32 1037559}` or `!43760 = !dilocation(line: 297, column: 5, scope: !43746)`.
@@ -25,10 +25,10 @@ The actual numbers will depend on your code.
 
 ## 2) Check your llvm-ir reproducer
 
-To confirm that your previous step worked, we will use llvm's `opt` tool. find your path to the opt binary, with a path similar to `<some_dir>/rust/build/<x86/arm/...-target-tripple>/build/bin/opt`. also find `llvmenzyme-19.<so/dll/dylib>` path, similar to `/rust/build/target-tripple/enzyme/build/enzyme/llvmenzyme-19`. Please keep in mind that llvm frequently updates it's llvm backend, so the version number might be higher (20, 21, ...). Once you have both, run the following command:
+To confirm that your previous step worked, we will use llvm's `opt` tool. find your path to the opt binary, with a path similar to `<some_dir>/rust/build/<x86/arm/...-target-triple>/build/bin/opt`. also find `llvmenzyme-19.<so/dll/dylib>` path, similar to `/rust/build/target-triple/enzyme/build/enzyme/llvmenzyme-19`. Please keep in mind that llvm frequently updates it's llvm backend, so the version number might be higher (20, 21, ...). Once you have both, run the following command:
 
 ```sh
-<path/to/opt> out.ll -load-pass-plugin=/path/to/llvmenzyme-19.so -passes="enzyme" -s
+<path/to/opt> out.ll -load-pass-plugin=/path/to/build/<target-triple>/stage1/lib/libEnzyme-21.so -passes="enzyme" -enzyme-strict-aliasing=0  -s
 ```
 
 If the previous step succeeded, you are going to see the same error that you saw when compiling your rust code with cargo. 

From 765e2fe6eed09e4fb61702ede01362336b6250e7 Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Sun, 5 Oct 2025 01:38:29 -0400
Subject: [PATCH 1731/1889] Add potential instability warning

---
 src/doc/rustc-dev-guide/src/autodiff/debugging.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/doc/rustc-dev-guide/src/autodiff/debugging.md b/src/doc/rustc-dev-guide/src/autodiff/debugging.md
index a66d775d98264..97893535cfe54 100644
--- a/src/doc/rustc-dev-guide/src/autodiff/debugging.md
+++ b/src/doc/rustc-dev-guide/src/autodiff/debugging.md
@@ -30,6 +30,7 @@ To confirm that your previous step worked, we will use llvm's `opt` tool. find y
 ```sh
 <path/to/opt> out.ll -load-pass-plugin=/path/to/build/<target-triple>/stage1/lib/libEnzyme-21.so -passes="enzyme" -enzyme-strict-aliasing=0  -s
 ```
+This command might fail for future versions or on your system, in which case you should replace libEnzyme-21.so with LLVMEnzyme-21.so. Look at the Enzyme docs for instructions on how to build it. You might need to also adjust how to build your LLVM version.
 
 If the previous step succeeded, you are going to see the same error that you saw when compiling your rust code with cargo. 
 

From 7c8fe29fd65d994e25a8eed3d0e2bbed3415ca61 Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Sun, 5 Oct 2025 03:07:51 -0400
Subject: [PATCH 1732/1889] solve autodiffv2.rs FIXME and make identical_fnc
 test more robust

---
 tests/codegen-llvm/autodiff/autodiffv2.rs    | 31 ++++++++------------
 tests/codegen-llvm/autodiff/identical_fnc.rs |  4 +--
 2 files changed, 15 insertions(+), 20 deletions(-)

diff --git a/tests/codegen-llvm/autodiff/autodiffv2.rs b/tests/codegen-llvm/autodiff/autodiffv2.rs
index 85aed6a183b63..c24a374148c34 100644
--- a/tests/codegen-llvm/autodiff/autodiffv2.rs
+++ b/tests/codegen-llvm/autodiff/autodiffv2.rs
@@ -18,11 +18,6 @@
 // but each shadow argument is `width` times larger (thus 16 and 20 elements here).
 // `d_square3` instead takes `width` (4) shadow arguments, which are all the same size as the
 // original function arguments.
-//
-// FIXME(autodiff): We currently can't test `d_square1` and `d_square3` in the same file, since they
-// generate the same dummy functions which get merged by LLVM, breaking pieces of our pipeline which
-// try to rewrite the dummy functions later. We should consider to change to pure declarations both
-// in our frontend and in the llvm backend to avoid these issues.
 
 #![feature(autodiff)]
 
@@ -30,7 +25,7 @@ use std::autodiff::autodiff_forward;
 
 // CHECK: ;
 #[no_mangle]
-//#[autodiff(d_square1, Forward, Dual, Dual)]
+#[autodiff_forward(d_square1, Dual, Dual)]
 #[autodiff_forward(d_square2, 4, Dualv, Dualv)]
 #[autodiff_forward(d_square3, 4, Dual, Dual)]
 fn square(x: &[f32], y: &mut [f32]) {
@@ -79,25 +74,25 @@ fn main() {
     let mut dy3_4 = std::hint::black_box(vec![0.0; 5]);
 
     // scalar.
-    //d_square1(&x1, &z1, &mut y1, &mut dy1_1);
-    //d_square1(&x1, &z2, &mut y2, &mut dy1_2);
-    //d_square1(&x1, &z3, &mut y3, &mut dy1_3);
-    //d_square1(&x1, &z4, &mut y4, &mut dy1_4);
+    d_square1(&x1, &z1, &mut y1, &mut dy1_1);
+    d_square1(&x1, &z2, &mut y2, &mut dy1_2);
+    d_square1(&x1, &z3, &mut y3, &mut dy1_3);
+    d_square1(&x1, &z4, &mut y4, &mut dy1_4);
 
     // assert y1 == y2 == y3 == y4
-    //for i in 0..5 {
-    //    assert_eq!(y1[i], y2[i]);
-    //    assert_eq!(y1[i], y3[i]);
-    //    assert_eq!(y1[i], y4[i]);
-    //}
+    for i in 0..5 {
+        assert_eq!(y1[i], y2[i]);
+        assert_eq!(y1[i], y3[i]);
+        assert_eq!(y1[i], y4[i]);
+    }
 
     // batch mode A)
     d_square2(&x1, &z5, &mut y5, &mut dy2);
 
     // assert y1 == y2 == y3 == y4 == y5
-    //for i in 0..5 {
-    //    assert_eq!(y1[i], y5[i]);
-    //}
+    for i in 0..5 {
+        assert_eq!(y1[i], y5[i]);
+    }
 
     // batch mode B)
     d_square3(&x1, &z1, &z2, &z3, &z4, &mut y6, &mut dy3_1, &mut dy3_2, &mut dy3_3, &mut dy3_4);
diff --git a/tests/codegen-llvm/autodiff/identical_fnc.rs b/tests/codegen-llvm/autodiff/identical_fnc.rs
index 6066f8cb34fb9..1c18e7acc4b63 100644
--- a/tests/codegen-llvm/autodiff/identical_fnc.rs
+++ b/tests/codegen-llvm/autodiff/identical_fnc.rs
@@ -32,9 +32,9 @@ fn square2(x: &f64) -> f64 {
 // CHECK-NOT:br
 // CHECK-NOT:ret
 // CHECK:; call identical_fnc::d_square
-// CHECK-NEXT:call fastcc void @_ZN13identical_fnc8d_square17hcb5768e95528c35fE(double %x.val, ptr noalias noundef align 8 dereferenceable(8) %dx1)
+// CHECK-NEXT:call fastcc void @_ZN13identical_fnc8d_square[[HASH:.+]](double %x.val, ptr noalias noundef align 8 dereferenceable(8) %dx1)
 // CHECK:; call identical_fnc::d_square
-// CHECK-NEXT:call fastcc void @_ZN13identical_fnc8d_square17hcb5768e95528c35fE(double %x.val, ptr noalias noundef align 8 dereferenceable(8) %dx2)
+// CHECK-NEXT:call fastcc void @_ZN13identical_fnc8d_square[[HASH]](double %x.val, ptr noalias noundef align 8 dereferenceable(8) %dx2)
 
 fn main() {
     let x = std::hint::black_box(3.0);

From 99c7959bb7fde07f1326c52312c12671239849b7 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 4 Aug 2025 16:59:58 +0200
Subject: [PATCH 1733/1889] Add regression test for rustdoc output format

---
 .../rustdoc-doctest-output-format/file.rs     |  3 +
 .../rustdoc-doctest-output-format/rmake.rs    | 83 +++++++++++++++++++
 2 files changed, 86 insertions(+)
 create mode 100644 tests/run-make/rustdoc-doctest-output-format/file.rs
 create mode 100644 tests/run-make/rustdoc-doctest-output-format/rmake.rs

diff --git a/tests/run-make/rustdoc-doctest-output-format/file.rs b/tests/run-make/rustdoc-doctest-output-format/file.rs
new file mode 100644
index 0000000000000..51d17849fd718
--- /dev/null
+++ b/tests/run-make/rustdoc-doctest-output-format/file.rs
@@ -0,0 +1,3 @@
+//! ```
+//! let x = 12;
+//! ```
diff --git a/tests/run-make/rustdoc-doctest-output-format/rmake.rs b/tests/run-make/rustdoc-doctest-output-format/rmake.rs
new file mode 100644
index 0000000000000..61b5c0c4fd11d
--- /dev/null
+++ b/tests/run-make/rustdoc-doctest-output-format/rmake.rs
@@ -0,0 +1,83 @@
+//! Regression test to ensure that the output format is respected for doctests.
+//!
+//! Regression test for <https://github.com/rust-lang/rust/issues/144798>.
+
+//@ ignore-cross-compile
+
+use run_make_support::{rustdoc, serde_json};
+
+fn run_test(edition: &str, format: Option<&str>) -> String {
+    let mut r = rustdoc();
+    r.input("file.rs").edition(edition).arg("--test");
+    if let Some(format) = format {
+        r.args(&[
+            "--test-args",
+            "-Zunstable-options",
+            "--test-args",
+            "--format",
+            "--test-args",
+            format,
+        ]);
+    }
+    r.run().stdout_utf8()
+}
+
+fn check_json_output(edition: &str, expected_reports: usize) {
+    let out = run_test(edition, Some("json"));
+    let mut found_report = 0;
+    for (line_nb, line) in out.lines().enumerate() {
+        match serde_json::from_str::<serde_json::Value>(&line) {
+            Ok(value) => {
+                if value.get("type") == Some(&serde_json::json!("report")) {
+                    found_report += 1;
+                }
+            }
+            Err(error) => panic!(
+                "failed for {edition} edition (json format) at line {}: non-JSON value: {error}\n\
+                ====== output ======\n{out}",
+                line_nb + 1,
+            ),
+        }
+    }
+    if found_report != expected_reports {
+        panic!(
+            "failed for {edition} edition (json format): expected {expected_reports} doctest \
+             time `report`, found {found_report}\n====== output ======\n{out}",
+        );
+    }
+}
+
+fn check_non_json_output(edition: &str, expected_reports: usize) {
+    let out = run_test(edition, None);
+    let mut found_report = 0;
+    for (line_nb, line) in out.lines().enumerate() {
+        if line.starts_with('{') && serde_json::from_str::<serde_json::Value>(&line).is_ok() {
+            panic!(
+                "failed for {edition} edition: unexpected json at line {}: `{line}`\n\
+                 ====== output ======\n{out}",
+                line_nb + 1
+            );
+        }
+        if line.starts_with("all doctests ran in")
+            && line.contains("; merged doctests compilation took ")
+        {
+            found_report += 1;
+        }
+    }
+    if found_report != expected_reports {
+        panic!(
+            "failed for {edition} edition: expected {expected_reports} doctest time `report`, \
+             found {found_report}\n====== output ======\n{out}",
+        );
+    }
+}
+
+fn main() {
+    // Only the merged doctests generate the "times report".
+    check_json_output("2021", 0);
+    check_json_output("2024", 1);
+
+    // Only the merged doctests generate the "times report".
+    check_non_json_output("2021", 0);
+    check_non_json_output("2024", 1);
+}

From 95445f9b9652c24a48493bafdc5a8fce12927aec Mon Sep 17 00:00:00 2001
From: yukang <moorekang@gmail.com>
Date: Sun, 5 Oct 2025 17:27:45 +0800
Subject: [PATCH 1734/1889] Trivial code cleanup in resolve

---
 compiler/rustc_resolve/src/imports.rs | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
index ce90a1bcd313d..04eb312a0f8ba 100644
--- a/compiler/rustc_resolve/src/imports.rs
+++ b/compiler/rustc_resolve/src/imports.rs
@@ -741,14 +741,10 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         errors.retain(|(_import, err)| match err.module {
             // Skip `use` errors for `use foo::Bar;` if `foo.rs` has unrecovered parse errors.
             Some(def_id) if self.mods_with_parse_errors.contains(&def_id) => false,
-            _ => true,
-        });
-        errors.retain(|(_import, err)| {
             // If we've encountered something like `use _;`, we've already emitted an error stating
             // that `_` is not a valid identifier, so we ignore that resolve error.
-            err.segment != Some(kw::Underscore)
+            _ => err.segment != Some(kw::Underscore),
         });
-
         if errors.is_empty() {
             self.tcx.dcx().delayed_bug("expected a parse or \"`_` can't be an identifier\" error");
             return;

From 9ccaf080cbef74aae96760564fd23447d5aa906b Mon Sep 17 00:00:00 2001
From: nora <48135649+Noratrieb@users.noreply.github.com>
Date: Sun, 5 Oct 2025 12:01:23 +0200
Subject: [PATCH 1735/1889] Fill out AVR target metadata

This will make `-Zbuild-std` automatically build the right crates, notably not building `std` by default, which will both be useful for users and also fix the build for https://does-it-build.noratrieb.dev.
---
 compiler/rustc_target/src/spec/targets/avr_none.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/compiler/rustc_target/src/spec/targets/avr_none.rs b/compiler/rustc_target/src/spec/targets/avr_none.rs
index ad056d0232670..65a171e4515af 100644
--- a/compiler/rustc_target/src/spec/targets/avr_none.rs
+++ b/compiler/rustc_target/src/spec/targets/avr_none.rs
@@ -5,9 +5,9 @@ pub(crate) fn target() -> Target {
         arch: "avr".into(),
         metadata: crate::spec::TargetMetadata {
             description: None,
-            tier: None,
-            host_tools: None,
-            std: None,
+            tier: Some(3),
+            host_tools: Some(false),
+            std: Some(false),
         },
         data_layout: "e-P1-p:16:8-i8:8-i16:8-i32:8-i64:8-f32:8-f64:8-n8:16-a:8".into(),
         llvm_target: "avr-unknown-unknown".into(),

From 0bc6945186ac733d959f761092fcf2be5f6e77a1 Mon Sep 17 00:00:00 2001
From: cyrgani <85427285+cyrgani@users.noreply.github.com>
Date: Sun, 5 Oct 2025 13:58:11 +0200
Subject: [PATCH 1736/1889] give a better example why `std` modules named like
 primitives are needed

---
 library/std/src/lib.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index da41c1216c4d5..46eb120d65de3 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -63,10 +63,10 @@
 //!    type, but not the all-important methods.
 //!
 //! So for example there is a [page for the primitive type
-//! `i32`](primitive::i32) that lists all the methods that can be called on
-//! 32-bit integers (very useful), and there is a [page for the module
-//! `std::i32`] that documents the constant values [`MIN`] and [`MAX`] (rarely
-//! useful).
+//! `char`](primitive::char) that lists all the methods that can be called on
+//! characters (very useful), and there is a [page for the module
+//! `std::char`] that documents iterator and error types created by these methods
+//! (rarely useful).
 //!
 //! Note the documentation for the primitives [`str`] and [`[T]`][prim@slice] (also
 //! called 'slice'). Many method calls on [`String`] and [`Vec<T>`] are actually

From a316f5b72e6a9277f0fb912eab8e7a47074bb500 Mon Sep 17 00:00:00 2001
From: Karol Zwolak <karolzwolak7@gmail.com>
Date: Sun, 5 Oct 2025 12:57:48 +0200
Subject: [PATCH 1737/1889] don't make empty ident when printing `'` ident from
 `extern "'"`

---
 compiler/rustc_span/src/symbol.rs | 22 +++++++++++++++-------
 1 file changed, 15 insertions(+), 7 deletions(-)

diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 083e04730bc37..35786d8932878 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -2463,9 +2463,10 @@ pub const STDLIB_STABLE_CRATES: &[Symbol] = &[sym::std, sym::core, sym::alloc, s
 
 #[derive(Copy, Clone, Eq, HashStable_Generic, Encodable, Decodable)]
 pub struct Ident {
-    // `name` should never be the empty symbol. If you are considering that,
-    // you are probably conflating "empty identifier with "no identifier" and
-    // you should use `Option<Ident>` instead.
+    /// `name` should never be the empty symbol. If you are considering that,
+    /// you are probably conflating "empty identifier with "no identifier" and
+    /// you should use `Option<Ident>` instead.
+    /// Trying to construct an `Ident` with an empty name will trigger debug assertions.
     pub name: Symbol,
     pub span: Span,
 }
@@ -2508,6 +2509,8 @@ impl Ident {
         Ident::new(self.name, span.with_ctxt(self.span.ctxt()))
     }
 
+    /// Creates a new ident with the same span and name with leading quote removed, if any.
+    /// If called on an empty ident, or with name just a single quote, returns an empty ident which is invalid.
     pub fn without_first_quote(self) -> Ident {
         Ident::new(Symbol::intern(self.as_str().trim_start_matches('\'')), self.span)
     }
@@ -3095,10 +3098,15 @@ impl Ident {
     }
 
     pub fn is_raw_lifetime_guess(self) -> bool {
-        let name_without_apostrophe = self.without_first_quote();
-        name_without_apostrophe.name != self.name
-            && name_without_apostrophe.name.can_be_raw()
-            && name_without_apostrophe.is_reserved_lifetime()
+        // Check that the name isn't just a single quote.
+        // `self.without_first_quote()` would return empty ident, which triggers debug assert.
+        if self.name.as_str() == "'" {
+            return false;
+        }
+        let ident_without_apostrophe = self.without_first_quote();
+        ident_without_apostrophe.name != self.name
+            && ident_without_apostrophe.name.can_be_raw()
+            && ident_without_apostrophe.is_reserved_lifetime()
     }
 
     pub fn guess_print_mode(self) -> IdentPrintMode {

From 87e8ec8114532e252fb93df5a115f7fb91c6d668 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sun, 5 Oct 2025 14:12:49 +0200
Subject: [PATCH 1738/1889] power align: format test file

---
 tests/ui/layout/reprc-power-alignment.rs     | 25 +++++++++----------
 tests/ui/layout/reprc-power-alignment.stderr | 26 ++++++++++----------
 2 files changed, 25 insertions(+), 26 deletions(-)

diff --git a/tests/ui/layout/reprc-power-alignment.rs b/tests/ui/layout/reprc-power-alignment.rs
index f144094d43fbc..3456c4ef80297 100644
--- a/tests/ui/layout/reprc-power-alignment.rs
+++ b/tests/ui/layout/reprc-power-alignment.rs
@@ -5,12 +5,12 @@
 #![feature(no_core)]
 #![no_core]
 #![no_std]
+#![crate_type = "lib"]
 
 extern crate minicore;
 use minicore::*;
 
 #[warn(uses_power_alignment)]
-
 #[repr(C)]
 pub struct Floats {
     a: f64,
@@ -96,32 +96,32 @@ pub struct FloatAgg7 {
 
 #[repr(C)]
 pub struct A {
-  d: f64,
+    d: f64,
 }
 #[repr(C)]
 pub struct B {
-  a: A,
-  f: f32,
-  d: f64, //~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+    a: A,
+    f: f32,
+    d: f64, //~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
 }
 #[repr(C)]
 pub struct C {
-  c: u8,
-  b: B, //~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+    c: u8,
+    b: B, //~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
 }
 #[repr(C)]
 pub struct D {
-  x: f64,
+    x: f64,
 }
 #[repr(C)]
 pub struct E {
-  x: i32,
-  d: D, //~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+    x: i32,
+    d: D, //~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
 }
 #[repr(C)]
 pub struct F {
-  a: u8,
-  b: f64, //~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
+    a: u8,
+    b: f64, //~ WARNING repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
 }
 #[repr(C)]
 pub struct G {
@@ -173,4 +173,3 @@ pub struct M {
     b: K,
     c: L,
 }
-fn main() { }
diff --git a/tests/ui/layout/reprc-power-alignment.stderr b/tests/ui/layout/reprc-power-alignment.stderr
index 18664e4d655d3..2f4612f3ff8f1 100644
--- a/tests/ui/layout/reprc-power-alignment.stderr
+++ b/tests/ui/layout/reprc-power-alignment.stderr
@@ -5,7 +5,7 @@ LL |     c: f64,
    |     ^^^^^^
    |
 note: the lint level is defined here
-  --> $DIR/reprc-power-alignment.rs:12:8
+  --> $DIR/reprc-power-alignment.rs:13:8
    |
 LL | #[warn(uses_power_alignment)]
    |        ^^^^^^^^^^^^^^^^^^^^
@@ -73,28 +73,28 @@ LL |     y: Floats,
    |     ^^^^^^^^^
 
 warning: repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
-  --> $DIR/reprc-power-alignment.rs:105:3
+  --> $DIR/reprc-power-alignment.rs:105:5
    |
-LL |   d: f64,
-   |   ^^^^^^
+LL |     d: f64,
+   |     ^^^^^^
 
 warning: repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
-  --> $DIR/reprc-power-alignment.rs:110:3
+  --> $DIR/reprc-power-alignment.rs:110:5
    |
-LL |   b: B,
-   |   ^^^^
+LL |     b: B,
+   |     ^^^^
 
 warning: repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
-  --> $DIR/reprc-power-alignment.rs:119:3
+  --> $DIR/reprc-power-alignment.rs:119:5
    |
-LL |   d: D,
-   |   ^^^^
+LL |     d: D,
+   |     ^^^^
 
 warning: repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
-  --> $DIR/reprc-power-alignment.rs:124:3
+  --> $DIR/reprc-power-alignment.rs:124:5
    |
-LL |   b: f64,
-   |   ^^^^^^
+LL |     b: f64,
+   |     ^^^^^^
 
 warning: repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type
   --> $DIR/reprc-power-alignment.rs:130:5

From 5a0ea3bfba56e4d1c768e25fa30088964b38277f Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sun, 5 Oct 2025 14:18:17 +0200
Subject: [PATCH 1739/1889] power align: ignore repr(C) unions and enums

---
 .../rustc_lint/src/types/improper_ctypes.rs   | 20 +++++++++----------
 tests/ui/layout/reprc-power-alignment.rs      | 16 +++++++++++++++
 2 files changed, 26 insertions(+), 10 deletions(-)

diff --git a/compiler/rustc_lint/src/types/improper_ctypes.rs b/compiler/rustc_lint/src/types/improper_ctypes.rs
index 7ca57b0094ee3..2c88397086699 100644
--- a/compiler/rustc_lint/src/types/improper_ctypes.rs
+++ b/compiler/rustc_lint/src/types/improper_ctypes.rs
@@ -220,21 +220,21 @@ fn check_struct_for_power_alignment<'tcx>(
     adt_def: AdtDef<'tcx>,
 ) {
     let tcx = cx.tcx;
-    // repr(C) structs also with packed or aligned representation
-    // should be ignored.
-    if adt_def.repr().c()
-        && !adt_def.repr().packed()
-        && adt_def.repr().align.is_none()
-        && tcx.sess.target.os == "aix"
-        && !adt_def.all_fields().next().is_none()
-    {
+
+    // Only consider structs (not enums or unions) on AIX.
+    if tcx.sess.target.os != "aix" || !adt_def.is_struct() {
+        return;
+    }
+
+    // The struct must be repr(C), but ignore it if it explicitly specifies its alignment with
+    // either `align(N)` or `packed(N)`.
+    if adt_def.repr().c() && !adt_def.repr().packed() && adt_def.repr().align.is_none() {
         let struct_variant_data = item.expect_struct().2;
         for field_def in struct_variant_data.fields().iter().skip(1) {
             // Struct fields (after the first field) are checked for the
             // power alignment rule, as fields after the first are likely
             // to be the fields that are misaligned.
-            let def_id = field_def.def_id;
-            let ty = tcx.type_of(def_id).instantiate_identity();
+            let ty = tcx.type_of(field_def.def_id).instantiate_identity();
             if check_arg_for_power_alignment(cx, ty) {
                 cx.emit_span_lint(USES_POWER_ALIGNMENT, field_def.span, UsesPowerAlignment);
             }
diff --git a/tests/ui/layout/reprc-power-alignment.rs b/tests/ui/layout/reprc-power-alignment.rs
index 3456c4ef80297..ffe311a9a2a8f 100644
--- a/tests/ui/layout/reprc-power-alignment.rs
+++ b/tests/ui/layout/reprc-power-alignment.rs
@@ -173,3 +173,19 @@ pub struct M {
     b: K,
     c: L,
 }
+
+// The lint ignores unions
+#[repr(C)]
+pub union Union {
+    a: f64,
+    b: u8,
+    c: f64,
+    d: f32,
+}
+
+// The lint ignores enums
+#[repr(C)]
+pub enum Enum {
+    A { a: f64, b: u8, c: f64, d: f32 },
+    B,
+}

From 7ed476f51fe6d3240abb4d54435dc12c9da0b91d Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Sun, 5 Oct 2025 19:58:56 +0800
Subject: [PATCH 1740/1889] bootstrap: don't build redirect pages during
 dry-run/test

---
 src/bootstrap/src/core/build_steps/doc.rs | 4 ++++
 src/bootstrap/src/core/builder/tests.rs   | 8 ++++----
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/doc.rs b/src/bootstrap/src/core/build_steps/doc.rs
index 37462c63f1b09..0a0f3b95b2cf8 100644
--- a/src/bootstrap/src/core/build_steps/doc.rs
+++ b/src/bootstrap/src/core/build_steps/doc.rs
@@ -274,6 +274,10 @@ impl Step for TheBook {
 
         // build the redirect pages
         let _guard = builder.msg(Kind::Doc, "book redirect pages", None, build_compiler, target);
+        if builder.config.dry_run() {
+            return;
+        }
+
         for file in t!(fs::read_dir(redirect_path)) {
             let file = t!(file);
             let path = file.path();
diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index 3306435758b45..d0429387f824e 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -1270,12 +1270,12 @@ mod snapshot {
         [doc] book/first-edition (book) <host>
         [doc] book/second-edition (book) <host>
         [doc] book/2018-edition (book) <host>
-        [build] rustdoc 1 <host>
         [build] rustc 1 <host> -> std 1 <target1>
         [doc] book (book) <target1>
         [doc] book/first-edition (book) <target1>
         [doc] book/second-edition (book) <target1>
         [doc] book/2018-edition (book) <target1>
+        [build] rustdoc 1 <host>
         [doc] rustc 1 <host> -> standalone 2 <host>
         [doc] rustc 1 <host> -> standalone 2 <target1>
         [doc] rustc 1 <host> -> std 1 <host> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,rustc-std-workspace-core,std,std_detect,sysroot,test,unwind]
@@ -1409,12 +1409,12 @@ mod snapshot {
         [doc] book/first-edition (book) <host>
         [doc] book/second-edition (book) <host>
         [doc] book/2018-edition (book) <host>
-        [build] rustdoc 1 <host>
         [build] rustc 1 <host> -> std 1 <target1>
         [doc] book (book) <target1>
         [doc] book/first-edition (book) <target1>
         [doc] book/second-edition (book) <target1>
         [doc] book/2018-edition (book) <target1>
+        [build] rustdoc 1 <host>
         [doc] rustc 1 <host> -> standalone 2 <host>
         [doc] rustc 1 <host> -> standalone 2 <target1>
         [doc] rustc 1 <host> -> std 1 <host> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,rustc-std-workspace-core,std,std_detect,sysroot,test,unwind]
@@ -1493,8 +1493,8 @@ mod snapshot {
         [doc] book/first-edition (book) <target1>
         [doc] book/second-edition (book) <target1>
         [doc] book/2018-edition (book) <target1>
-        [build] rustdoc 1 <host>
         [build] rustc 1 <host> -> std 1 <host>
+        [build] rustdoc 1 <host>
         [doc] rustc 1 <host> -> standalone 2 <target1>
         [doc] rustc 1 <host> -> std 1 <target1> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,rustc-std-workspace-core,std,std_detect,sysroot,test,unwind]
         [doc] nomicon (book) <target1>
@@ -1537,8 +1537,8 @@ mod snapshot {
         [doc] book/first-edition (book) <target1>
         [doc] book/second-edition (book) <target1>
         [doc] book/2018-edition (book) <target1>
-        [build] rustdoc 1 <host>
         [build] rustc 1 <host> -> std 1 <host>
+        [build] rustdoc 1 <host>
         [doc] rustc 1 <host> -> standalone 2 <target1>
         [doc] rustc 1 <host> -> std 1 <target1> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,rustc-std-workspace-core,std,std_detect,sysroot,test,unwind]
         [build] llvm <target1>

From 5234d36597b8f22aba25eef67d892315a439e927 Mon Sep 17 00:00:00 2001
From: Karol Zwolak <karolzwolak7@gmail.com>
Date: Sun, 5 Oct 2025 13:18:02 +0200
Subject: [PATCH 1741/1889] add test

---
 .../extern/extern-single-quote-issue-147365.rs   |  9 +++++++++
 .../extern-single-quote-issue-147365.stderr      | 16 ++++++++++++++++
 2 files changed, 25 insertions(+)
 create mode 100644 tests/ui/extern/extern-single-quote-issue-147365.rs
 create mode 100644 tests/ui/extern/extern-single-quote-issue-147365.stderr

diff --git a/tests/ui/extern/extern-single-quote-issue-147365.rs b/tests/ui/extern/extern-single-quote-issue-147365.rs
new file mode 100644
index 0000000000000..b50016bd65f31
--- /dev/null
+++ b/tests/ui/extern/extern-single-quote-issue-147365.rs
@@ -0,0 +1,9 @@
+//@ needs-rustc-debug-assertions
+
+// https://github.com/rust-lang/rust/issues/147365
+// Ensures we don't trigger debug assert by creating an empty Ident when determining whether
+// the single quote is a raw lifetime.
+
+extern "'" {} //~ ERROR invalid ABI: found `'`
+
+fn main() {}
diff --git a/tests/ui/extern/extern-single-quote-issue-147365.stderr b/tests/ui/extern/extern-single-quote-issue-147365.stderr
new file mode 100644
index 0000000000000..d761bc3ebf323
--- /dev/null
+++ b/tests/ui/extern/extern-single-quote-issue-147365.stderr
@@ -0,0 +1,16 @@
+error[E0703]: invalid ABI: found `'`
+  --> $DIR/extern-single-quote-issue-147365.rs:7:8
+   |
+LL | extern "'" {}
+   |        ^^^ invalid ABI
+   |
+   = note: invoke `rustc --print=calling-conventions` for a full list of supported calling conventions
+help: there's a similarly named valid ABI `C`
+   |
+LL - extern "'" {}
+LL + extern "C" {}
+   |
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0703`.

From a8b9a576745d4e6a13198952c7b4b4b8d825624d Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Sun, 5 Oct 2025 20:30:24 +0800
Subject: [PATCH 1742/1889] bootstrap: relax `compiler-rt` root assertion

Not needed during tests.
---
 src/bootstrap/src/core/build_steps/compile.rs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index 96b4e15433f7e..d29d1041486bd 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -590,7 +590,12 @@ pub fn std_cargo(builder: &Builder<'_>, target: TargetSelection, cargo: &mut Car
                 ),
             );
             let compiler_builtins_root = builder.src.join("src/llvm-project/compiler-rt");
-            assert!(compiler_builtins_root.exists());
+            if !builder.config.dry_run() {
+                // This assertion would otherwise trigger during tests if `llvm-project` is not
+                // checked out.
+                assert!(compiler_builtins_root.exists());
+            }
+
             // 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);

From 8a31837054e95417b7356848225583e33ec3c439 Mon Sep 17 00:00:00 2001
From: Shunpoco <tkngsnsk313320@gmail.com>
Date: Sat, 4 Oct 2025 11:29:07 +0100
Subject: [PATCH 1743/1889] Set opt-level for installing tool only on CI

ensure_version_or_cargo_install uses -Copt-level=0 for quicker installation.
However, the flag affects the tool's performance. For example, typos-cli with opt-level=0 takes 15 seconds for checking ./compiler, but the tool with default opt-level only takes less than 1 sec.
This commit enables the option only when the test tidy is run on CI.
---
 src/tools/tidy/src/lib.rs | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/src/tools/tidy/src/lib.rs b/src/tools/tidy/src/lib.rs
index 874a758bd9b38..0acbcd64f067c 100644
--- a/src/tools/tidy/src/lib.rs
+++ b/src/tools/tidy/src/lib.rs
@@ -194,8 +194,8 @@ pub fn ensure_version_or_cargo_install(
     // use --force to ensure that if the required version is bumped, we update it.
     // use --target-dir to ensure we have a build cache so repeated invocations aren't slow.
     // modify PATH so that cargo doesn't print a warning telling the user to modify the path.
-    let cargo_exit_code = Command::new(cargo)
-        .args(["install", "--locked", "--force", "--quiet"])
+    let mut cmd = Command::new(cargo);
+    cmd.args(["install", "--locked", "--force", "--quiet"])
         .arg("--root")
         .arg(&tool_root_dir)
         .arg("--target-dir")
@@ -208,10 +208,16 @@ pub fn ensure_version_or_cargo_install(
                     .chain(std::iter::once(tool_bin_dir.clone())),
             )
             .expect("build dir contains invalid char"),
-        )
-        .env("RUSTFLAGS", "-Copt-level=0")
-        .spawn()?
-        .wait()?;
+        );
+
+    // On CI, we set opt-level flag for quicker installation.
+    // Since lower opt-level decreases the tool's performance,
+    // we don't set this option on local.
+    if CiEnv::is_ci() {
+        cmd.env("RUSTFLAGS", "-Copt-level=0");
+    }
+
+    let cargo_exit_code = cmd.spawn()?.wait()?;
     if !cargo_exit_code.success() {
         return Err(io::Error::other("cargo install failed"));
     }

From 7e1c00dbce512b260c396b4425527b00891168a7 Mon Sep 17 00:00:00 2001
From: Alice Ryhl <aliceryhl@google.com>
Date: Wed, 17 Sep 2025 17:06:14 +0000
Subject: [PATCH 1744/1889] Prevent downstream impl DerefMut for Pin<LocalType>

---
 library/core/src/pin.rs                       | 59 ++++++++++++++++++-
 ...y.run2-{closure#0}.Inline.panic-abort.diff | 56 ++++++++++--------
 ....run2-{closure#0}.Inline.panic-unwind.diff | 56 ++++++++++--------
 tests/ui/deref/pin-impl-deref.rs              |  4 +-
 tests/ui/deref/pin-impl-deref.stderr          | 22 ++++---
 .../pin-unsound-issue-85099-derefmut.rs       |  4 +-
 .../pin-unsound-issue-85099-derefmut.stderr   | 14 +++++
 7 files changed, 146 insertions(+), 69 deletions(-)
 create mode 100644 tests/ui/typeck/pin-unsound-issue-85099-derefmut.stderr

diff --git a/library/core/src/pin.rs b/library/core/src/pin.rs
index 535830f2e749f..d7e348b71e1d0 100644
--- a/library/core/src/pin.rs
+++ b/library/core/src/pin.rs
@@ -1689,9 +1689,66 @@ impl<Ptr: [const] Deref> const Deref for Pin<Ptr> {
     }
 }
 
+mod helper {
+    /// Helper that prevents downstream crates from implementing `DerefMut` for `Pin`.
+    ///
+    /// This type is not `#[fundamental]`, so it's possible to relax its `DerefMut` impl bounds in
+    /// the future, so the orphan rules reject downstream impls of `DerefMut` of `Pin`.
+    #[repr(transparent)]
+    #[unstable(feature = "pin_derefmut_internals", issue = "none")]
+    #[allow(missing_debug_implementations)]
+    pub struct Pin<Ptr> {
+        pointer: Ptr,
+    }
+
+    #[unstable(feature = "pin_derefmut_internals", issue = "none")]
+    #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+    pub const trait DerefMut {
+        type Target: ?Sized;
+        fn deref_mut(&mut self) -> &mut Self::Target;
+    }
+
+    #[unstable(feature = "pin_derefmut_internals", issue = "none")]
+    #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+    impl<Ptr: [const] super::DerefMut> const DerefMut for Pin<Ptr>
+    where
+        Ptr::Target: crate::marker::Unpin,
+    {
+        type Target = Ptr::Target;
+
+        #[inline(always)]
+        fn deref_mut(&mut self) -> &mut Ptr::Target {
+            &mut self.pointer
+        }
+    }
+}
+
 #[stable(feature = "pin", since = "1.33.0")]
 #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
-impl<Ptr: [const] DerefMut<Target: Unpin>> const DerefMut for Pin<Ptr> {
+#[cfg(not(doc))]
+impl<Ptr> const DerefMut for Pin<Ptr>
+where
+    Ptr: [const] Deref,
+    helper::Pin<Ptr>: [const] helper::DerefMut<Target = Self::Target>,
+{
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Ptr::Target {
+        // SAFETY: Pin and helper::Pin have the same layout, so this is equivalent to
+        // `&mut self.pointer` which is safe because `Target: Unpin`.
+        helper::DerefMut::deref_mut(unsafe {
+            &mut *(self as *mut Pin<Ptr> as *mut helper::Pin<Ptr>)
+        })
+    }
+}
+
+#[stable(feature = "pin", since = "1.33.0")]
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+#[cfg(doc)]
+impl<Ptr> const DerefMut for Pin<Ptr>
+where
+    Ptr: [const] DerefMut,
+    Ptr::Target: Unpin,
+{
     fn deref_mut(&mut self) -> &mut Ptr::Target {
         Pin::get_mut(Pin::as_mut(self))
     }
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 0acb33febe52b..226a16d6eec39 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
@@ -63,27 +63,25 @@
 +                             let mut _44: &mut std::future::Ready<()>;
 +                             let mut _45: &mut std::pin::Pin<&mut std::future::Ready<()>>;
 +                             scope 14 (inlined <Pin<&mut std::future::Ready<()>> as DerefMut>::deref_mut) {
-+                                 scope 15 (inlined Pin::<&mut std::future::Ready<()>>::as_mut) {
-+                                     let mut _46: &mut &mut std::future::Ready<()>;
-+                                     scope 16 (inlined Pin::<&mut std::future::Ready<()>>::new_unchecked) {
++                                 let mut _46: *mut std::pin::helper::Pin<&mut std::future::Ready<()>>;
++                                 let mut _47: *mut std::pin::Pin<&mut std::future::Ready<()>>;
++                                 scope 15 (inlined <pin::helper::Pin<&mut std::future::Ready<()>> as pin::helper::DerefMut>::deref_mut) {
++                                     let mut _48: &mut &mut std::future::Ready<()>;
++                                     scope 16 (inlined <&mut std::future::Ready<()> as DerefMut>::deref_mut) {
 +                                     }
-+                                     scope 18 (inlined <&mut std::future::Ready<()> as DerefMut>::deref_mut) {
-+                                     }
-+                                 }
-+                                 scope 17 (inlined Pin::<&mut std::future::Ready<()>>::get_mut) {
 +                                 }
 +                             }
-+                             scope 19 (inlined Option::<()>::take) {
-+                                 let mut _47: std::option::Option<()>;
-+                                 scope 20 (inlined std::mem::replace::<Option<()>>) {
-+                                     scope 21 {
++                             scope 17 (inlined Option::<()>::take) {
++                                 let mut _49: std::option::Option<()>;
++                                 scope 18 (inlined std::mem::replace::<Option<()>>) {
++                                     scope 19 {
 +                                     }
 +                                 }
 +                             }
-+                             scope 22 (inlined #[track_caller] Option::<()>::expect) {
-+                                 let mut _48: isize;
-+                                 let mut _49: !;
-+                                 scope 23 {
++                             scope 20 (inlined #[track_caller] Option::<()>::expect) {
++                                 let mut _50: isize;
++                                 let mut _51: !;
++                                 scope 21 {
 +                                 }
 +                             }
 +                         }
@@ -217,18 +215,23 @@
 +         _22 = &mut (*_23);
 +         StorageDead(_24);
 +         StorageLive(_44);
-+         StorageLive(_49);
++         StorageLive(_46);
++         StorageLive(_51);
 +         StorageLive(_41);
 +         StorageLive(_42);
-+         _44 = copy (_19.0: &mut std::future::Ready<()>);
 +         StorageLive(_47);
-+         _47 = Option::<()>::None;
-+         _42 = copy ((*_44).0: std::option::Option<()>);
-+         ((*_44).0: std::option::Option<()>) = copy _47;
++         _47 = &raw mut _19;
++         _46 = copy _47 as *mut std::pin::helper::Pin<&mut std::future::Ready<()>> (PtrToPtr);
 +         StorageDead(_47);
-+         StorageLive(_48);
-+         _48 = discriminant(_42);
-+         switchInt(move _48) -> [0: bb11, 1: bb12, otherwise: bb5];
++         _44 = copy ((*_46).0: &mut std::future::Ready<()>);
++         StorageLive(_49);
++         _49 = Option::<()>::None;
++         _42 = copy ((*_44).0: std::option::Option<()>);
++         ((*_44).0: std::option::Option<()>) = copy _49;
++         StorageDead(_49);
++         StorageLive(_50);
++         _50 = discriminant(_42);
++         switchInt(move _50) -> [0: bb11, 1: bb12, otherwise: bb5];
       }
 + 
 +     bb5: {
@@ -291,16 +294,17 @@
 +     }
 + 
 +     bb11: {
-+         _49 = option::expect_failed(const "`Ready` polled after completion") -> unwind unreachable;
++         _51 = option::expect_failed(const "`Ready` polled after completion") -> unwind unreachable;
 +     }
 + 
 +     bb12: {
 +         _41 = move ((_42 as Some).0: ());
-+         StorageDead(_48);
++         StorageDead(_50);
 +         StorageDead(_42);
 +         _18 = Poll::<()>::Ready(move _41);
 +         StorageDead(_41);
-+         StorageDead(_49);
++         StorageDead(_51);
++         StorageDead(_46);
 +         StorageDead(_44);
 +         StorageDead(_22);
 +         StorageDead(_19);
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 98ee46c29b1be..770b6e471ff8b 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
@@ -65,27 +65,25 @@
 +                             let mut _46: &mut std::future::Ready<()>;
 +                             let mut _47: &mut std::pin::Pin<&mut std::future::Ready<()>>;
 +                             scope 14 (inlined <Pin<&mut std::future::Ready<()>> as DerefMut>::deref_mut) {
-+                                 scope 15 (inlined Pin::<&mut std::future::Ready<()>>::as_mut) {
-+                                     let mut _48: &mut &mut std::future::Ready<()>;
-+                                     scope 16 (inlined Pin::<&mut std::future::Ready<()>>::new_unchecked) {
++                                 let mut _48: *mut std::pin::helper::Pin<&mut std::future::Ready<()>>;
++                                 let mut _49: *mut std::pin::Pin<&mut std::future::Ready<()>>;
++                                 scope 15 (inlined <pin::helper::Pin<&mut std::future::Ready<()>> as pin::helper::DerefMut>::deref_mut) {
++                                     let mut _50: &mut &mut std::future::Ready<()>;
++                                     scope 16 (inlined <&mut std::future::Ready<()> as DerefMut>::deref_mut) {
 +                                     }
-+                                     scope 18 (inlined <&mut std::future::Ready<()> as DerefMut>::deref_mut) {
-+                                     }
-+                                 }
-+                                 scope 17 (inlined Pin::<&mut std::future::Ready<()>>::get_mut) {
 +                                 }
 +                             }
-+                             scope 19 (inlined Option::<()>::take) {
-+                                 let mut _49: std::option::Option<()>;
-+                                 scope 20 (inlined std::mem::replace::<Option<()>>) {
-+                                     scope 21 {
++                             scope 17 (inlined Option::<()>::take) {
++                                 let mut _51: std::option::Option<()>;
++                                 scope 18 (inlined std::mem::replace::<Option<()>>) {
++                                     scope 19 {
 +                                     }
 +                                 }
 +                             }
-+                             scope 22 (inlined #[track_caller] Option::<()>::expect) {
-+                                 let mut _50: isize;
-+                                 let mut _51: !;
-+                                 scope 23 {
++                             scope 20 (inlined #[track_caller] Option::<()>::expect) {
++                                 let mut _52: isize;
++                                 let mut _53: !;
++                                 scope 21 {
 +                                 }
 +                             }
 +                         }
@@ -234,18 +232,23 @@
 +         _22 = &mut (*_23);
 +         StorageDead(_24);
 +         StorageLive(_46);
-+         StorageLive(_51);
++         StorageLive(_48);
++         StorageLive(_53);
 +         StorageLive(_43);
 +         StorageLive(_44);
-+         _46 = copy (_19.0: &mut std::future::Ready<()>);
 +         StorageLive(_49);
-+         _49 = Option::<()>::None;
-+         _44 = copy ((*_46).0: std::option::Option<()>);
-+         ((*_46).0: std::option::Option<()>) = copy _49;
++         _49 = &raw mut _19;
++         _48 = copy _49 as *mut std::pin::helper::Pin<&mut std::future::Ready<()>> (PtrToPtr);
 +         StorageDead(_49);
-+         StorageLive(_50);
-+         _50 = discriminant(_44);
-+         switchInt(move _50) -> [0: bb16, 1: bb17, otherwise: bb7];
++         _46 = copy ((*_48).0: &mut std::future::Ready<()>);
++         StorageLive(_51);
++         _51 = Option::<()>::None;
++         _44 = copy ((*_46).0: std::option::Option<()>);
++         ((*_46).0: std::option::Option<()>) = copy _51;
++         StorageDead(_51);
++         StorageLive(_52);
++         _52 = discriminant(_44);
++         switchInt(move _52) -> [0: bb16, 1: bb17, otherwise: bb7];
       }
   
 -     bb6 (cleanup): {
@@ -332,16 +335,17 @@
 +     }
 + 
 +     bb16: {
-+         _51 = option::expect_failed(const "`Ready` polled after completion") -> bb11;
++         _53 = option::expect_failed(const "`Ready` polled after completion") -> bb11;
 +     }
 + 
 +     bb17: {
 +         _43 = move ((_44 as Some).0: ());
-+         StorageDead(_50);
++         StorageDead(_52);
 +         StorageDead(_44);
 +         _18 = Poll::<()>::Ready(move _43);
 +         StorageDead(_43);
-+         StorageDead(_51);
++         StorageDead(_53);
++         StorageDead(_48);
 +         StorageDead(_46);
 +         StorageDead(_22);
 +         StorageDead(_19);
diff --git a/tests/ui/deref/pin-impl-deref.rs b/tests/ui/deref/pin-impl-deref.rs
index b1dc8dea3f248..ccd8d0dfc72ae 100644
--- a/tests/ui/deref/pin-impl-deref.rs
+++ b/tests/ui/deref/pin-impl-deref.rs
@@ -22,7 +22,7 @@ impl MyPinType {
 fn impl_deref_mut(_: impl DerefMut) {}
 fn unpin_impl_ref(r_unpin: Pin<&MyUnpinType>) {
     impl_deref_mut(r_unpin)
-    //~^ ERROR: the trait bound `Pin<&MyUnpinType>: DerefMut` is not satisfied
+    //~^ ERROR: the trait bound `&MyUnpinType: DerefMut` is not satisfied
 }
 fn unpin_impl_mut(r_unpin: Pin<&mut MyUnpinType>) {
     impl_deref_mut(r_unpin)
@@ -30,7 +30,7 @@ fn unpin_impl_mut(r_unpin: Pin<&mut MyUnpinType>) {
 fn pin_impl_ref(r_pin: Pin<&MyPinType>) {
     impl_deref_mut(r_pin)
     //~^ ERROR: `PhantomPinned` cannot be unpinned
-    //~| ERROR: the trait bound `Pin<&MyPinType>: DerefMut` is not satisfied
+    //~| ERROR: the trait bound `&MyPinType: DerefMut` is not satisfied
 }
 fn pin_impl_mut(r_pin: Pin<&mut MyPinType>) {
     impl_deref_mut(r_pin)
diff --git a/tests/ui/deref/pin-impl-deref.stderr b/tests/ui/deref/pin-impl-deref.stderr
index 106654641a117..918ff7ca91218 100644
--- a/tests/ui/deref/pin-impl-deref.stderr
+++ b/tests/ui/deref/pin-impl-deref.stderr
@@ -1,40 +1,36 @@
-error[E0277]: the trait bound `Pin<&MyUnpinType>: DerefMut` is not satisfied
+error[E0277]: the trait bound `&MyUnpinType: DerefMut` is not satisfied
   --> $DIR/pin-impl-deref.rs:24:20
    |
 LL |     impl_deref_mut(r_unpin)
-   |     -------------- ^^^^^^^ the trait `DerefMut` is not implemented for `Pin<&MyUnpinType>`
+   |     -------------- ^^^^^^^ the trait `DerefMut` is not implemented for `&MyUnpinType`
    |     |
    |     required by a bound introduced by this call
    |
+   = note: `DerefMut` is implemented for `&mut MyUnpinType`, but not for `&MyUnpinType`
+   = note: required for `pin::helper::Pin<&MyUnpinType>` to implement `pin::helper::DerefMut`
    = note: required for `Pin<&MyUnpinType>` to implement `DerefMut`
 note: required by a bound in `impl_deref_mut`
   --> $DIR/pin-impl-deref.rs:22:27
    |
 LL | fn impl_deref_mut(_: impl DerefMut) {}
    |                           ^^^^^^^^ required by this bound in `impl_deref_mut`
-help: consider mutably borrowing here
-   |
-LL |     impl_deref_mut(&mut r_unpin)
-   |                    ++++
 
-error[E0277]: the trait bound `Pin<&MyPinType>: DerefMut` is not satisfied
+error[E0277]: the trait bound `&MyPinType: DerefMut` is not satisfied
   --> $DIR/pin-impl-deref.rs:31:20
    |
 LL |     impl_deref_mut(r_pin)
-   |     -------------- ^^^^^ the trait `DerefMut` is not implemented for `Pin<&MyPinType>`
+   |     -------------- ^^^^^ the trait `DerefMut` is not implemented for `&MyPinType`
    |     |
    |     required by a bound introduced by this call
    |
+   = note: `DerefMut` is implemented for `&mut MyPinType`, but not for `&MyPinType`
+   = note: required for `pin::helper::Pin<&MyPinType>` to implement `pin::helper::DerefMut`
    = note: required for `Pin<&MyPinType>` to implement `DerefMut`
 note: required by a bound in `impl_deref_mut`
   --> $DIR/pin-impl-deref.rs:22:27
    |
 LL | fn impl_deref_mut(_: impl DerefMut) {}
    |                           ^^^^^^^^ required by this bound in `impl_deref_mut`
-help: consider mutably borrowing here
-   |
-LL |     impl_deref_mut(&mut r_pin)
-   |                    ++++
 
 error[E0277]: `PhantomPinned` cannot be unpinned
   --> $DIR/pin-impl-deref.rs:31:20
@@ -51,6 +47,7 @@ note: required because it appears within the type `MyPinType`
    |
 LL | struct MyPinType(core::marker::PhantomPinned);
    |        ^^^^^^^^^
+   = note: required for `pin::helper::Pin<&MyPinType>` to implement `pin::helper::DerefMut`
    = note: required for `Pin<&MyPinType>` to implement `DerefMut`
 note: required by a bound in `impl_deref_mut`
   --> $DIR/pin-impl-deref.rs:22:27
@@ -73,6 +70,7 @@ note: required because it appears within the type `MyPinType`
    |
 LL | struct MyPinType(core::marker::PhantomPinned);
    |        ^^^^^^^^^
+   = note: required for `pin::helper::Pin<&mut MyPinType>` to implement `pin::helper::DerefMut`
    = note: required for `Pin<&mut MyPinType>` to implement `DerefMut`
 note: required by a bound in `impl_deref_mut`
   --> $DIR/pin-impl-deref.rs:22:27
diff --git a/tests/ui/typeck/pin-unsound-issue-85099-derefmut.rs b/tests/ui/typeck/pin-unsound-issue-85099-derefmut.rs
index f3ece563f5403..e8c3bbba1e458 100644
--- a/tests/ui/typeck/pin-unsound-issue-85099-derefmut.rs
+++ b/tests/ui/typeck/pin-unsound-issue-85099-derefmut.rs
@@ -1,5 +1,4 @@
-//@ check-pass
-//@ known-bug: #85099
+//@ check-fail
 
 // Should fail. Can coerce `Pin<T>` into `Pin<U>` where
 // `T: Deref<Target: Unpin>` and `U: Deref<Target: !Unpin>`, using the
@@ -43,6 +42,7 @@ impl<'a, Fut: Future<Output = ()>> SomeTrait<'a, Fut> for Fut {
 }
 
 impl<'b, 'a, Fut> DerefMut for Pin<&'b dyn SomeTrait<'a, Fut>> {
+//~^ ERROR: conflicting implementations of trait `DerefMut`
     fn deref_mut<'c>(
         self: &'c mut Pin<&'b dyn SomeTrait<'a, Fut>>,
     ) -> &'c mut (dyn SomeTrait<'a, Fut> + 'b) {
diff --git a/tests/ui/typeck/pin-unsound-issue-85099-derefmut.stderr b/tests/ui/typeck/pin-unsound-issue-85099-derefmut.stderr
new file mode 100644
index 0000000000000..cc56c77809eaa
--- /dev/null
+++ b/tests/ui/typeck/pin-unsound-issue-85099-derefmut.stderr
@@ -0,0 +1,14 @@
+error[E0119]: conflicting implementations of trait `DerefMut` for type `Pin<&dyn SomeTrait<'_, _>>`
+  --> $DIR/pin-unsound-issue-85099-derefmut.rs:44:1
+   |
+LL | impl<'b, 'a, Fut> DerefMut for Pin<&'b dyn SomeTrait<'a, Fut>> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: conflicting implementation in crate `core`:
+           - impl<Ptr> DerefMut for Pin<Ptr>
+             where <pin::helper::Pin<Ptr> as pin::helper::DerefMut>::Target == <Pin<Ptr> as Deref>::Target, Ptr: Deref, pin::helper::Pin<Ptr>: pin::helper::DerefMut, pin::helper::Pin<Ptr>: ?Sized;
+   = note: upstream crates may add a new impl of trait `std::pin::helper::DerefMut` for type `std::pin::helper::Pin<&dyn SomeTrait<'_, _>>` in future versions
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0119`.

From cd44cd0f63a7e67dcfc3618aa7bf6e2e70643561 Mon Sep 17 00:00:00 2001
From: Alice Ryhl <aliceryhl@google.com>
Date: Thu, 25 Sep 2025 08:39:35 +0000
Subject: [PATCH 1745/1889] Improve docs for module

---
 library/core/src/pin.rs | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

diff --git a/library/core/src/pin.rs b/library/core/src/pin.rs
index d7e348b71e1d0..fdbeaea464194 100644
--- a/library/core/src/pin.rs
+++ b/library/core/src/pin.rs
@@ -1692,8 +1692,22 @@ impl<Ptr: [const] Deref> const Deref for Pin<Ptr> {
 mod helper {
     /// Helper that prevents downstream crates from implementing `DerefMut` for `Pin`.
     ///
-    /// This type is not `#[fundamental]`, so it's possible to relax its `DerefMut` impl bounds in
-    /// the future, so the orphan rules reject downstream impls of `DerefMut` of `Pin`.
+    /// The `Pin` type implements the unsafe trait `PinCoerceUnsized`, which essentially requires
+    /// that the type does not have a malicious `Deref` or `DerefMut` impl. However, without this
+    /// helper module, downstream crates are able to write `impl DerefMut for Pin<LocalType>` as
+    /// long as it does not overlap with the impl provided by stdlib. This is because `Pin` is
+    /// `#[fundamental]`, so stdlib promises to never implement traits for `Pin` that it does not
+    /// implement today.
+    ///
+    /// However, this is problematic. Downstream crates could implement `DerefMut` for
+    /// `Pin<&LocalType>`, and they could do so maliciously. To prevent this, the implementation for
+    /// `Pin` delegates to this helper module. Since `helper::Pin` is not `#[fundamental]`, the
+    /// orphan rules assume that stdlib might implement `helper::DerefMut` for `helper::Pin<&_>` in
+    /// the future. Because of this, downstream crates can no longer provide an implementation of
+    /// `DerefMut` for `Pin<&_>`, as it might overlap with a trait impl that, according to the
+    /// orphan rules, the stdlib could introduce without a breaking change in a future release.
+    ///
+    /// See <https://github.com/rust-lang/rust/issues/85099> for the issue this fixes.
     #[repr(transparent)]
     #[unstable(feature = "pin_derefmut_internals", issue = "none")]
     #[allow(missing_debug_implementations)]

From f65250b3dd0eada1ab25ad4f766048f2ebe24623 Mon Sep 17 00:00:00 2001
From: Alice Ryhl <aliceryhl@google.com>
Date: Mon, 29 Sep 2025 09:34:18 +0000
Subject: [PATCH 1746/1889] Document workaround in docs

---
 library/core/src/pin.rs | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/library/core/src/pin.rs b/library/core/src/pin.rs
index fdbeaea464194..23950acd97610 100644
--- a/library/core/src/pin.rs
+++ b/library/core/src/pin.rs
@@ -1755,13 +1755,21 @@ where
     }
 }
 
+/// The `Target` type is restricted to `Unpin` types as it's not safe to obtain a mutable reference
+/// to a pinned value.
+///
+/// For soundness reasons, implementations of `DerefMut` for `Pin<T>` are rejected even when `T` is
+/// a local type not covered by this impl block. (Since `Pin` is [fundamental], such implementations
+/// would normally be possible.)
+///
+/// [fundamental]: ../../reference/items/implementations.html#r-items.impl.trait.fundamental
 #[stable(feature = "pin", since = "1.33.0")]
 #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 #[cfg(doc)]
 impl<Ptr> const DerefMut for Pin<Ptr>
 where
     Ptr: [const] DerefMut,
-    Ptr::Target: Unpin,
+    <Ptr as Deref>::Target: Unpin,
 {
     fn deref_mut(&mut self) -> &mut Ptr::Target {
         Pin::get_mut(Pin::as_mut(self))

From 76dcb39c240382a7d62cc8ee475e0c3866ad8025 Mon Sep 17 00:00:00 2001
From: Alice Ryhl <aliceryhl@google.com>
Date: Wed, 1 Oct 2025 11:14:08 +0000
Subject: [PATCH 1747/1889] Adjust error messages

---
 compiler/rustc_span/src/symbol.rs              |  1 +
 .../src/error_reporting/traits/suggestions.rs  | 18 ++++++++++++++++++
 library/core/src/pin.rs                        | 15 ++++++++-------
 ...dy.run2-{closure#0}.Inline.panic-abort.diff |  6 +++---
 ...y.run2-{closure#0}.Inline.panic-unwind.diff |  6 +++---
 tests/ui/deref/pin-impl-deref.stderr           |  4 ----
 .../pin-unsound-issue-85099-derefmut.stderr    |  4 ++--
 7 files changed, 35 insertions(+), 19 deletions(-)

diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 083e04730bc37..7f1ca96b2a75b 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -309,6 +309,7 @@ symbols! {
         PathBuf,
         Pending,
         PinCoerceUnsized,
+        PinDerefMutHelper,
         Pointer,
         Poll,
         ProcMacro,
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 37e622102e70f..5665229a4cbe6 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -3476,6 +3476,24 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     // can do about it. As far as they are concerned, `?` is compiler magic.
                     return;
                 }
+                if tcx.is_diagnostic_item(sym::PinDerefMutHelper, parent_def_id) {
+                    let parent_predicate =
+                        self.resolve_vars_if_possible(data.derived.parent_trait_pred);
+
+                    // Skip PinDerefMutHelper in suggestions, but still show downstream suggestions.
+                    ensure_sufficient_stack(|| {
+                        self.note_obligation_cause_code(
+                            body_id,
+                            err,
+                            parent_predicate,
+                            param_env,
+                            &data.derived.parent_code,
+                            obligated_types,
+                            seen_requirements,
+                        )
+                    });
+                    return;
+                }
                 let self_ty_str =
                     tcx.short_string(parent_trait_pred.skip_binder().self_ty(), err.long_ty_path());
                 let trait_name = tcx.short_string(
diff --git a/library/core/src/pin.rs b/library/core/src/pin.rs
index 23950acd97610..81c2dabf0d1d8 100644
--- a/library/core/src/pin.rs
+++ b/library/core/src/pin.rs
@@ -1711,20 +1711,21 @@ mod helper {
     #[repr(transparent)]
     #[unstable(feature = "pin_derefmut_internals", issue = "none")]
     #[allow(missing_debug_implementations)]
-    pub struct Pin<Ptr> {
+    pub struct PinHelper<Ptr> {
         pointer: Ptr,
     }
 
     #[unstable(feature = "pin_derefmut_internals", issue = "none")]
     #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
-    pub const trait DerefMut {
+    #[rustc_diagnostic_item = "PinDerefMutHelper"]
+    pub const trait PinDerefMutHelper {
         type Target: ?Sized;
         fn deref_mut(&mut self) -> &mut Self::Target;
     }
 
     #[unstable(feature = "pin_derefmut_internals", issue = "none")]
     #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
-    impl<Ptr: [const] super::DerefMut> const DerefMut for Pin<Ptr>
+    impl<Ptr: [const] super::DerefMut> const PinDerefMutHelper for PinHelper<Ptr>
     where
         Ptr::Target: crate::marker::Unpin,
     {
@@ -1743,14 +1744,14 @@ mod helper {
 impl<Ptr> const DerefMut for Pin<Ptr>
 where
     Ptr: [const] Deref,
-    helper::Pin<Ptr>: [const] helper::DerefMut<Target = Self::Target>,
+    helper::PinHelper<Ptr>: [const] helper::PinDerefMutHelper<Target = Self::Target>,
 {
     #[inline]
     fn deref_mut(&mut self) -> &mut Ptr::Target {
-        // SAFETY: Pin and helper::Pin have the same layout, so this is equivalent to
+        // SAFETY: Pin and PinHelper have the same layout, so this is equivalent to
         // `&mut self.pointer` which is safe because `Target: Unpin`.
-        helper::DerefMut::deref_mut(unsafe {
-            &mut *(self as *mut Pin<Ptr> as *mut helper::Pin<Ptr>)
+        helper::PinDerefMutHelper::deref_mut(unsafe {
+            &mut *(self as *mut Pin<Ptr> as *mut helper::PinHelper<Ptr>)
         })
     }
 }
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 226a16d6eec39..0203ff52d63f8 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
@@ -63,9 +63,9 @@
 +                             let mut _44: &mut std::future::Ready<()>;
 +                             let mut _45: &mut std::pin::Pin<&mut std::future::Ready<()>>;
 +                             scope 14 (inlined <Pin<&mut std::future::Ready<()>> as DerefMut>::deref_mut) {
-+                                 let mut _46: *mut std::pin::helper::Pin<&mut std::future::Ready<()>>;
++                                 let mut _46: *mut std::pin::helper::PinHelper<&mut std::future::Ready<()>>;
 +                                 let mut _47: *mut std::pin::Pin<&mut std::future::Ready<()>>;
-+                                 scope 15 (inlined <pin::helper::Pin<&mut std::future::Ready<()>> as pin::helper::DerefMut>::deref_mut) {
++                                 scope 15 (inlined <pin::helper::PinHelper<&mut std::future::Ready<()>> as pin::helper::PinDerefMutHelper>::deref_mut) {
 +                                     let mut _48: &mut &mut std::future::Ready<()>;
 +                                     scope 16 (inlined <&mut std::future::Ready<()> as DerefMut>::deref_mut) {
 +                                     }
@@ -221,7 +221,7 @@
 +         StorageLive(_42);
 +         StorageLive(_47);
 +         _47 = &raw mut _19;
-+         _46 = copy _47 as *mut std::pin::helper::Pin<&mut std::future::Ready<()>> (PtrToPtr);
++         _46 = copy _47 as *mut std::pin::helper::PinHelper<&mut std::future::Ready<()>> (PtrToPtr);
 +         StorageDead(_47);
 +         _44 = copy ((*_46).0: &mut std::future::Ready<()>);
 +         StorageLive(_49);
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 770b6e471ff8b..6c8cad3e992e7 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
@@ -65,9 +65,9 @@
 +                             let mut _46: &mut std::future::Ready<()>;
 +                             let mut _47: &mut std::pin::Pin<&mut std::future::Ready<()>>;
 +                             scope 14 (inlined <Pin<&mut std::future::Ready<()>> as DerefMut>::deref_mut) {
-+                                 let mut _48: *mut std::pin::helper::Pin<&mut std::future::Ready<()>>;
++                                 let mut _48: *mut std::pin::helper::PinHelper<&mut std::future::Ready<()>>;
 +                                 let mut _49: *mut std::pin::Pin<&mut std::future::Ready<()>>;
-+                                 scope 15 (inlined <pin::helper::Pin<&mut std::future::Ready<()>> as pin::helper::DerefMut>::deref_mut) {
++                                 scope 15 (inlined <pin::helper::PinHelper<&mut std::future::Ready<()>> as pin::helper::PinDerefMutHelper>::deref_mut) {
 +                                     let mut _50: &mut &mut std::future::Ready<()>;
 +                                     scope 16 (inlined <&mut std::future::Ready<()> as DerefMut>::deref_mut) {
 +                                     }
@@ -238,7 +238,7 @@
 +         StorageLive(_44);
 +         StorageLive(_49);
 +         _49 = &raw mut _19;
-+         _48 = copy _49 as *mut std::pin::helper::Pin<&mut std::future::Ready<()>> (PtrToPtr);
++         _48 = copy _49 as *mut std::pin::helper::PinHelper<&mut std::future::Ready<()>> (PtrToPtr);
 +         StorageDead(_49);
 +         _46 = copy ((*_48).0: &mut std::future::Ready<()>);
 +         StorageLive(_51);
diff --git a/tests/ui/deref/pin-impl-deref.stderr b/tests/ui/deref/pin-impl-deref.stderr
index 918ff7ca91218..4143d66f42723 100644
--- a/tests/ui/deref/pin-impl-deref.stderr
+++ b/tests/ui/deref/pin-impl-deref.stderr
@@ -7,7 +7,6 @@ LL |     impl_deref_mut(r_unpin)
    |     required by a bound introduced by this call
    |
    = note: `DerefMut` is implemented for `&mut MyUnpinType`, but not for `&MyUnpinType`
-   = note: required for `pin::helper::Pin<&MyUnpinType>` to implement `pin::helper::DerefMut`
    = note: required for `Pin<&MyUnpinType>` to implement `DerefMut`
 note: required by a bound in `impl_deref_mut`
   --> $DIR/pin-impl-deref.rs:22:27
@@ -24,7 +23,6 @@ LL |     impl_deref_mut(r_pin)
    |     required by a bound introduced by this call
    |
    = note: `DerefMut` is implemented for `&mut MyPinType`, but not for `&MyPinType`
-   = note: required for `pin::helper::Pin<&MyPinType>` to implement `pin::helper::DerefMut`
    = note: required for `Pin<&MyPinType>` to implement `DerefMut`
 note: required by a bound in `impl_deref_mut`
   --> $DIR/pin-impl-deref.rs:22:27
@@ -47,7 +45,6 @@ note: required because it appears within the type `MyPinType`
    |
 LL | struct MyPinType(core::marker::PhantomPinned);
    |        ^^^^^^^^^
-   = note: required for `pin::helper::Pin<&MyPinType>` to implement `pin::helper::DerefMut`
    = note: required for `Pin<&MyPinType>` to implement `DerefMut`
 note: required by a bound in `impl_deref_mut`
   --> $DIR/pin-impl-deref.rs:22:27
@@ -70,7 +67,6 @@ note: required because it appears within the type `MyPinType`
    |
 LL | struct MyPinType(core::marker::PhantomPinned);
    |        ^^^^^^^^^
-   = note: required for `pin::helper::Pin<&mut MyPinType>` to implement `pin::helper::DerefMut`
    = note: required for `Pin<&mut MyPinType>` to implement `DerefMut`
 note: required by a bound in `impl_deref_mut`
   --> $DIR/pin-impl-deref.rs:22:27
diff --git a/tests/ui/typeck/pin-unsound-issue-85099-derefmut.stderr b/tests/ui/typeck/pin-unsound-issue-85099-derefmut.stderr
index cc56c77809eaa..2bcd92b76a09d 100644
--- a/tests/ui/typeck/pin-unsound-issue-85099-derefmut.stderr
+++ b/tests/ui/typeck/pin-unsound-issue-85099-derefmut.stderr
@@ -6,8 +6,8 @@ LL | impl<'b, 'a, Fut> DerefMut for Pin<&'b dyn SomeTrait<'a, Fut>> {
    |
    = note: conflicting implementation in crate `core`:
            - impl<Ptr> DerefMut for Pin<Ptr>
-             where <pin::helper::Pin<Ptr> as pin::helper::DerefMut>::Target == <Pin<Ptr> as Deref>::Target, Ptr: Deref, pin::helper::Pin<Ptr>: pin::helper::DerefMut, pin::helper::Pin<Ptr>: ?Sized;
-   = note: upstream crates may add a new impl of trait `std::pin::helper::DerefMut` for type `std::pin::helper::Pin<&dyn SomeTrait<'_, _>>` in future versions
+             where <pin::helper::PinHelper<Ptr> as pin::helper::PinDerefMutHelper>::Target == <Pin<Ptr> as Deref>::Target, Ptr: Deref, pin::helper::PinHelper<Ptr>: pin::helper::PinDerefMutHelper, pin::helper::PinHelper<Ptr>: ?Sized;
+   = note: upstream crates may add a new impl of trait `std::pin::helper::PinDerefMutHelper` for type `std::pin::helper::PinHelper<&dyn SomeTrait<'_, _>>` in future versions
 
 error: aborting due to 1 previous error
 

From 0a6462be908f00555dd7fadc6c7ed2fa751856ee Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Sun, 5 Oct 2025 23:25:08 +0200
Subject: [PATCH 1748/1889] remove unneeded imports

---
 library/proc_macro/src/bridge/arena.rs  | 2 +-
 library/proc_macro/src/bridge/rpc.rs    | 3 +--
 library/proc_macro/src/bridge/symbol.rs | 1 -
 3 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/library/proc_macro/src/bridge/arena.rs b/library/proc_macro/src/bridge/arena.rs
index bf5a5b5a81821..dee4e7b976de6 100644
--- a/library/proc_macro/src/bridge/arena.rs
+++ b/library/proc_macro/src/bridge/arena.rs
@@ -7,7 +7,7 @@
 use std::cell::{Cell, RefCell};
 use std::mem::MaybeUninit;
 use std::ops::Range;
-use std::{cmp, ptr, slice, str};
+use std::{cmp, ptr, slice};
 
 // The arenas start with PAGE-sized chunks, and then each new chunk is twice as
 // big as its predecessor, up until we reach HUGE_PAGE-sized chunks, whereupon
diff --git a/library/proc_macro/src/bridge/rpc.rs b/library/proc_macro/src/bridge/rpc.rs
index 85fd7d138585c..26ea42b49b7f8 100644
--- a/library/proc_macro/src/bridge/rpc.rs
+++ b/library/proc_macro/src/bridge/rpc.rs
@@ -3,7 +3,6 @@
 use std::any::Any;
 use std::io::Write;
 use std::num::NonZero;
-use std::str;
 
 pub(super) type Writer = super::buffer::Buffer;
 
@@ -31,7 +30,7 @@ macro_rules! rpc_encode_decode {
 
         impl<S> DecodeMut<'_, '_, S> for $ty {
             fn decode(r: &mut Reader<'_>, _: &mut S) -> Self {
-                const N: usize = ::std::mem::size_of::<$ty>();
+                const N: usize = size_of::<$ty>();
 
                 let mut bytes = [0; N];
                 bytes.copy_from_slice(&r[..N]);
diff --git a/library/proc_macro/src/bridge/symbol.rs b/library/proc_macro/src/bridge/symbol.rs
index 57ca7db9fcdd7..eb7d30f9a6cc9 100644
--- a/library/proc_macro/src/bridge/symbol.rs
+++ b/library/proc_macro/src/bridge/symbol.rs
@@ -11,7 +11,6 @@
 
 use std::cell::RefCell;
 use std::num::NonZero;
-use std::str;
 
 use super::*;
 

From 21dd997aec1af5200a8b726ae6645f40b87baf7c Mon Sep 17 00:00:00 2001
From: usamoi <usamoi@outlook.com>
Date: Tue, 26 Aug 2025 16:24:29 +0800
Subject: [PATCH 1749/1889] support link modifier `as-needed` for raw-dylib-elf

---
 compiler/rustc_attr_parsing/messages.ftl      |  2 +-
 .../src/attributes/link_attrs.rs              |  9 ++--
 compiler/rustc_codegen_ssa/src/back/link.rs   | 12 +++---
 .../src/back/link/raw_dylib.rs                | 24 ++++++-----
 .../rustc_hir/src/attrs/data_structures.rs    | 18 +++++---
 compiler/rustc_metadata/src/native_libs.rs    |  2 +-
 .../rustc_session/src/config/native_libs.rs   |  3 +-
 .../linkage-attr/raw-dylib/elf/as_needed.rs   | 43 +++++++++++++++++++
 8 files changed, 82 insertions(+), 31 deletions(-)
 create mode 100644 tests/ui/linkage-attr/raw-dylib/elf/as_needed.rs

diff --git a/compiler/rustc_attr_parsing/messages.ftl b/compiler/rustc_attr_parsing/messages.ftl
index a432fa099ef4a..8b6b762f43102 100644
--- a/compiler/rustc_attr_parsing/messages.ftl
+++ b/compiler/rustc_attr_parsing/messages.ftl
@@ -1,5 +1,5 @@
 attr_parsing_as_needed_compatibility =
-    linking modifier `as-needed` is only compatible with `dylib` and `framework` linking kinds
+    linking modifier `as-needed` is only compatible with `dylib`, `framework` and `raw-dylib` linking kinds
 
 attr_parsing_bundle_needs_static =
     linking modifier `bundle` is only compatible with `static` linking kind
diff --git a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
index 04eaa485f736c..09f7bfa24e823 100644
--- a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
@@ -180,7 +180,8 @@ impl<S: Stage> CombineAttributeParser<S> for LinkParser {
                     }
 
                     (sym::as_dash_needed, Some(NativeLibKind::Dylib { as_needed }))
-                    | (sym::as_dash_needed, Some(NativeLibKind::Framework { as_needed })) => {
+                    | (sym::as_dash_needed, Some(NativeLibKind::Framework { as_needed }))
+                    | (sym::as_dash_needed, Some(NativeLibKind::RawDylib { as_needed })) => {
                         report_unstable_modifier!(native_link_modifiers_as_needed);
                         assign_modifier(as_needed)
                     }
@@ -219,12 +220,12 @@ impl<S: Stage> CombineAttributeParser<S> for LinkParser {
 
         // Do this outside of the loop so that `import_name_type` can be specified before `kind`.
         if let Some((_, span)) = import_name_type {
-            if kind != Some(NativeLibKind::RawDylib) {
+            if !matches!(kind, Some(NativeLibKind::RawDylib { .. })) {
                 cx.emit_err(ImportNameTypeRaw { span });
             }
         }
 
-        if let Some(NativeLibKind::RawDylib) = kind
+        if let Some(NativeLibKind::RawDylib { .. }) = kind
             && name.as_str().contains('\0')
         {
             cx.emit_err(RawDylibNoNul { span: name_span });
@@ -315,7 +316,7 @@ impl LinkParser {
                     cx.emit_err(RawDylibOnlyWindows { span: nv.value_span });
                 }
 
-                NativeLibKind::RawDylib
+                NativeLibKind::RawDylib { as_needed: None }
             }
             sym::link_dash_arg => {
                 if !features.link_arg_attribute() {
diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
index db2f2dd65b0b5..ea538d3d46981 100644
--- a/compiler/rustc_codegen_ssa/src/back/link.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -1490,7 +1490,7 @@ fn print_native_static_libs(
                 NativeLibKind::Static { bundle: None | Some(true), .. }
                 | NativeLibKind::LinkArg
                 | NativeLibKind::WasmImportModule
-                | NativeLibKind::RawDylib => None,
+                | NativeLibKind::RawDylib { .. } => None,
             }
         })
         // deduplication of consecutive repeated libraries, see rust-lang/rust#113209
@@ -2364,13 +2364,13 @@ fn linker_with_args(
             cmd.add_object(&output_path);
         }
     } else {
-        for link_path in raw_dylib::create_raw_dylib_elf_stub_shared_objects(
+        for (link_path, as_needed) in raw_dylib::create_raw_dylib_elf_stub_shared_objects(
             sess,
             codegen_results.crate_info.used_libraries.iter(),
             &raw_dylib_dir,
         ) {
             // Always use verbatim linkage, see comments in create_raw_dylib_elf_stub_shared_objects.
-            cmd.link_dylib_by_name(&link_path, true, false);
+            cmd.link_dylib_by_name(&link_path, true, as_needed);
         }
     }
     // As with add_upstream_native_libraries, we need to add the upstream raw-dylib symbols in case
@@ -2411,13 +2411,13 @@ fn linker_with_args(
             cmd.add_object(&output_path);
         }
     } else {
-        for link_path in raw_dylib::create_raw_dylib_elf_stub_shared_objects(
+        for (link_path, as_needed) in raw_dylib::create_raw_dylib_elf_stub_shared_objects(
             sess,
             native_libraries_from_nonstatics,
             &raw_dylib_dir,
         ) {
             // Always use verbatim linkage, see comments in create_raw_dylib_elf_stub_shared_objects.
-            cmd.link_dylib_by_name(&link_path, true, false);
+            cmd.link_dylib_by_name(&link_path, true, as_needed);
         }
     }
 
@@ -2726,7 +2726,7 @@ fn add_native_libs_from_crate(
                     cmd.link_framework_by_name(name, verbatim, as_needed.unwrap_or(true))
                 }
             }
-            NativeLibKind::RawDylib => {
+            NativeLibKind::RawDylib { as_needed: _ } => {
                 // Handled separately in `linker_with_args`.
             }
             NativeLibKind::WasmImportModule => {}
diff --git a/compiler/rustc_codegen_ssa/src/back/link/raw_dylib.rs b/compiler/rustc_codegen_ssa/src/back/link/raw_dylib.rs
index 9f42991d4c06a..7321bc1da391a 100644
--- a/compiler/rustc_codegen_ssa/src/back/link/raw_dylib.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link/raw_dylib.rs
@@ -31,7 +31,7 @@ fn collate_raw_dylibs_windows<'a>(
     let mut dylib_table = FxIndexMap::<String, FxIndexMap<Symbol, &DllImport>>::default();
 
     for lib in used_libraries {
-        if lib.kind == NativeLibKind::RawDylib {
+        if let NativeLibKind::RawDylib { .. } = lib.kind {
             let ext = if lib.verbatim { "" } else { ".dll" };
             let name = format!("{}{}", lib.name, ext);
             let imports = dylib_table.entry(name.clone()).or_default();
@@ -128,12 +128,12 @@ pub(super) fn create_raw_dylib_dll_import_libs<'a>(
 fn collate_raw_dylibs_elf<'a>(
     sess: &Session,
     used_libraries: impl IntoIterator<Item = &'a NativeLib>,
-) -> Vec<(String, Vec<DllImport>)> {
+) -> Vec<(String, Vec<DllImport>, bool)> {
     // Use index maps to preserve original order of imports and libraries.
-    let mut dylib_table = FxIndexMap::<String, FxIndexMap<Symbol, &DllImport>>::default();
+    let mut dylib_table = FxIndexMap::<String, (FxIndexMap<Symbol, &DllImport>, bool)>::default();
 
     for lib in used_libraries {
-        if lib.kind == NativeLibKind::RawDylib {
+        if let NativeLibKind::RawDylib { as_needed } = lib.kind {
             let filename = if lib.verbatim {
                 lib.name.as_str().to_owned()
             } else {
@@ -142,17 +142,19 @@ fn collate_raw_dylibs_elf<'a>(
                 format!("{prefix}{}{ext}", lib.name)
             };
 
-            let imports = dylib_table.entry(filename.clone()).or_default();
+            let (stub_imports, stub_as_needed) =
+                dylib_table.entry(filename.clone()).or_insert((Default::default(), true));
             for import in &lib.dll_imports {
-                imports.insert(import.name, import);
+                stub_imports.insert(import.name, import);
             }
+            *stub_as_needed = *stub_as_needed && as_needed.unwrap_or(true);
         }
     }
     sess.dcx().abort_if_errors();
     dylib_table
         .into_iter()
-        .map(|(name, imports)| {
-            (name, imports.into_iter().map(|(_, import)| import.clone()).collect())
+        .map(|(name, (imports, as_needed))| {
+            (name, imports.into_iter().map(|(_, import)| import.clone()).collect(), as_needed)
         })
         .collect()
 }
@@ -161,10 +163,10 @@ pub(super) fn create_raw_dylib_elf_stub_shared_objects<'a>(
     sess: &Session,
     used_libraries: impl IntoIterator<Item = &'a NativeLib>,
     raw_dylib_so_dir: &Path,
-) -> Vec<String> {
+) -> Vec<(String, bool)> {
     collate_raw_dylibs_elf(sess, used_libraries)
         .into_iter()
-        .map(|(load_filename, raw_dylib_imports)| {
+        .map(|(load_filename, raw_dylib_imports, as_needed)| {
             use std::hash::Hash;
 
             // `load_filename` is the *target/loader* filename that will end up in NEEDED.
@@ -205,7 +207,7 @@ pub(super) fn create_raw_dylib_elf_stub_shared_objects<'a>(
                 });
             };
 
-            temporary_lib_name
+            (temporary_lib_name, as_needed)
         })
         .collect()
 }
diff --git a/compiler/rustc_hir/src/attrs/data_structures.rs b/compiler/rustc_hir/src/attrs/data_structures.rs
index beeca7332cb17..2435363ef0eb8 100644
--- a/compiler/rustc_hir/src/attrs/data_structures.rs
+++ b/compiler/rustc_hir/src/attrs/data_structures.rs
@@ -309,7 +309,10 @@ pub enum NativeLibKind {
     },
     /// Dynamic library (e.g. `foo.dll` on Windows) without a corresponding import library.
     /// On Linux, it refers to a generated shared library stub.
-    RawDylib,
+    RawDylib {
+        /// Whether the dynamic library will be linked only if it satisfies some undefined symbols
+        as_needed: Option<bool>,
+    },
     /// A macOS-specific kind of dynamic libraries.
     Framework {
         /// Whether the framework will be linked only if it satisfies some undefined symbols
@@ -332,11 +335,10 @@ impl NativeLibKind {
             NativeLibKind::Static { bundle, whole_archive } => {
                 bundle.is_some() || whole_archive.is_some()
             }
-            NativeLibKind::Dylib { as_needed } | NativeLibKind::Framework { as_needed } => {
-                as_needed.is_some()
-            }
-            NativeLibKind::RawDylib
-            | NativeLibKind::Unspecified
+            NativeLibKind::Dylib { as_needed }
+            | NativeLibKind::Framework { as_needed }
+            | NativeLibKind::RawDylib { as_needed } => as_needed.is_some(),
+            NativeLibKind::Unspecified
             | NativeLibKind::LinkArg
             | NativeLibKind::WasmImportModule => false,
         }
@@ -349,7 +351,9 @@ impl NativeLibKind {
     pub fn is_dllimport(&self) -> bool {
         matches!(
             self,
-            NativeLibKind::Dylib { .. } | NativeLibKind::RawDylib | NativeLibKind::Unspecified
+            NativeLibKind::Dylib { .. }
+                | NativeLibKind::RawDylib { .. }
+                | NativeLibKind::Unspecified
         )
     }
 }
diff --git a/compiler/rustc_metadata/src/native_libs.rs b/compiler/rustc_metadata/src/native_libs.rs
index 82738c68c5921..15572063d45a6 100644
--- a/compiler/rustc_metadata/src/native_libs.rs
+++ b/compiler/rustc_metadata/src/native_libs.rs
@@ -218,7 +218,7 @@ impl<'tcx> Collector<'tcx> {
                 .flatten()
         {
             let dll_imports = match attr.kind {
-                NativeLibKind::RawDylib => foreign_items
+                NativeLibKind::RawDylib { .. } => foreign_items
                     .iter()
                     .map(|&child_item| {
                         self.build_dll_import(
diff --git a/compiler/rustc_session/src/config/native_libs.rs b/compiler/rustc_session/src/config/native_libs.rs
index 50a0593f88712..71d3e222c8a15 100644
--- a/compiler/rustc_session/src/config/native_libs.rs
+++ b/compiler/rustc_session/src/config/native_libs.rs
@@ -135,7 +135,8 @@ fn parse_and_apply_modifier(cx: &ParseNativeLibCx<'_>, modifier: &str, native_li
         ),
 
         ("as-needed", NativeLibKind::Dylib { as_needed })
-        | ("as-needed", NativeLibKind::Framework { as_needed }) => {
+        | ("as-needed", NativeLibKind::Framework { as_needed })
+        | ("as-needed", NativeLibKind::RawDylib { as_needed }) => {
             cx.on_unstable_value(
                 "linking modifier `as-needed` is unstable",
                 ", the `-Z unstable-options` flag must also be passed to use it",
diff --git a/tests/ui/linkage-attr/raw-dylib/elf/as_needed.rs b/tests/ui/linkage-attr/raw-dylib/elf/as_needed.rs
new file mode 100644
index 0000000000000..48ca39300f41c
--- /dev/null
+++ b/tests/ui/linkage-attr/raw-dylib/elf/as_needed.rs
@@ -0,0 +1,43 @@
+//@ only-elf
+//@ needs-dynamic-linking
+
+//@ only-gnu
+//@ only-x86_64
+//@ revisions: as_needed no_as_needed no_modifier merge_1 merge_2 merge_3 merge_4
+
+//@ [as_needed] run-pass
+//@ [no_as_needed] run-fail
+//@ [no_modifier] run-pass
+//@ [merge_1] run-fail
+//@ [merge_2] run-fail
+//@ [merge_3] run-fail
+//@ [merge_4] run-pass
+
+#![allow(incomplete_features)]
+#![feature(raw_dylib_elf)]
+#![feature(native_link_modifiers_as_needed)]
+
+#[cfg_attr(
+    as_needed,
+    link(name = "taiqannf1y28z2rw", kind = "raw-dylib", modifiers = "+as-needed")
+)]
+#[cfg_attr(
+    no_as_needed,
+    link(name = "taiqannf1y28z2rw", kind = "raw-dylib", modifiers = "-as-needed")
+)]
+#[cfg_attr(no_modifier, link(name = "taiqannf1y28z2rw", kind = "raw-dylib"))]
+unsafe extern "C" {}
+
+#[cfg_attr(merge_1, link(name = "k9nm7qxoa79bg7e6", kind = "raw-dylib", modifiers = "+as-needed"))]
+#[cfg_attr(merge_2, link(name = "k9nm7qxoa79bg7e6", kind = "raw-dylib", modifiers = "-as-needed"))]
+#[cfg_attr(merge_3, link(name = "k9nm7qxoa79bg7e6", kind = "raw-dylib", modifiers = "-as-needed"))]
+#[cfg_attr(merge_4, link(name = "k9nm7qxoa79bg7e6", kind = "raw-dylib", modifiers = "+as-needed"))]
+unsafe extern "C" {}
+
+#[cfg_attr(merge_1, link(name = "k9nm7qxoa79bg7e6", kind = "raw-dylib", modifiers = "-as-needed"))]
+#[cfg_attr(merge_2, link(name = "k9nm7qxoa79bg7e6", kind = "raw-dylib", modifiers = "+as-needed"))]
+#[cfg_attr(merge_3, link(name = "k9nm7qxoa79bg7e6", kind = "raw-dylib", modifiers = "-as-needed"))]
+#[cfg_attr(merge_4, link(name = "k9nm7qxoa79bg7e6", kind = "raw-dylib", modifiers = "+as-needed"))]
+unsafe extern "C" {}
+
+fn main() {}

From 69a975faa9804a0b693c3b57c4d5b36073f9ac16 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sat, 4 Oct 2025 16:51:58 +1000
Subject: [PATCH 1750/1889] Consistently import `llvm::Type` and `llvm::Value`

---
 compiler/rustc_codegen_llvm/src/abi.rs                | 4 +---
 compiler/rustc_codegen_llvm/src/asm.rs                | 6 ++----
 compiler/rustc_codegen_llvm/src/attributes.rs         | 5 +++--
 compiler/rustc_codegen_llvm/src/base.rs               | 4 ++--
 compiler/rustc_codegen_llvm/src/builder.rs            | 4 +---
 compiler/rustc_codegen_llvm/src/builder/autodiff.rs   | 4 +---
 compiler/rustc_codegen_llvm/src/callee.rs             | 3 +--
 compiler/rustc_codegen_llvm/src/common.rs             | 4 +---
 compiler/rustc_codegen_llvm/src/consts.rs             | 5 ++---
 compiler/rustc_codegen_llvm/src/context.rs            | 6 ++----
 compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs      | 3 +--
 compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs | 3 +--
 compiler/rustc_codegen_llvm/src/debuginfo/mod.rs      | 3 +--
 compiler/rustc_codegen_llvm/src/declare.rs            | 6 ++----
 compiler/rustc_codegen_llvm/src/intrinsic.rs          | 4 +---
 compiler/rustc_codegen_llvm/src/llvm/diagnostic.rs    | 2 +-
 compiler/rustc_codegen_llvm/src/type_.rs              | 6 ++----
 compiler/rustc_codegen_llvm/src/type_of.rs            | 2 +-
 compiler/rustc_codegen_llvm/src/va_arg.rs             | 3 +--
 compiler/rustc_codegen_llvm/src/value.rs              | 3 +--
 20 files changed, 28 insertions(+), 52 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/abi.rs b/compiler/rustc_codegen_llvm/src/abi.rs
index 15b4d5247a978..680ad98593e7e 100644
--- a/compiler/rustc_codegen_llvm/src/abi.rs
+++ b/compiler/rustc_codegen_llvm/src/abi.rs
@@ -22,11 +22,9 @@ use smallvec::SmallVec;
 use crate::attributes::{self, llfn_attrs_from_instance};
 use crate::builder::Builder;
 use crate::context::CodegenCx;
-use crate::llvm::{self, Attribute, AttributePlace};
+use crate::llvm::{self, Attribute, AttributePlace, Type, Value};
 use crate::llvm_util;
-use crate::type_::Type;
 use crate::type_of::LayoutLlvmExt;
-use crate::value::Value;
 
 trait ArgAttributesExt {
     fn apply_attrs_to_llfn(&self, idx: AttributePlace, cx: &CodegenCx<'_, '_>, llfn: &Value);
diff --git a/compiler/rustc_codegen_llvm/src/asm.rs b/compiler/rustc_codegen_llvm/src/asm.rs
index 93b1cf272ab7b..2b6a0ac9757b5 100644
--- a/compiler/rustc_codegen_llvm/src/asm.rs
+++ b/compiler/rustc_codegen_llvm/src/asm.rs
@@ -13,14 +13,12 @@ use rustc_target::asm::*;
 use smallvec::SmallVec;
 use tracing::debug;
 
+use crate::attributes;
 use crate::builder::Builder;
 use crate::common::Funclet;
 use crate::context::CodegenCx;
-use crate::llvm::ToLlvmBool;
-use crate::type_::Type;
+use crate::llvm::{self, ToLlvmBool, Type, Value};
 use crate::type_of::LayoutLlvmExt;
-use crate::value::Value;
-use crate::{attributes, llvm};
 
 impl<'ll, 'tcx> AsmBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
     fn codegen_inline_asm(
diff --git a/compiler/rustc_codegen_llvm/src/attributes.rs b/compiler/rustc_codegen_llvm/src/attributes.rs
index 8070ea0b3e927..209b8efa2c3b3 100644
--- a/compiler/rustc_codegen_llvm/src/attributes.rs
+++ b/compiler/rustc_codegen_llvm/src/attributes.rs
@@ -13,8 +13,9 @@ use smallvec::SmallVec;
 use crate::context::SimpleCx;
 use crate::errors::SanitizerMemtagRequiresMte;
 use crate::llvm::AttributePlace::Function;
-use crate::llvm::{self, AllocKindFlags, Attribute, AttributeKind, AttributePlace, MemoryEffects};
-use crate::value::Value;
+use crate::llvm::{
+    self, AllocKindFlags, Attribute, AttributeKind, AttributePlace, MemoryEffects, Value,
+};
 use crate::{Session, attributes, llvm_util};
 
 pub(crate) fn apply_to_llfn(llfn: &Value, idx: AttributePlace, attrs: &[&Attribute]) {
diff --git a/compiler/rustc_codegen_llvm/src/base.rs b/compiler/rustc_codegen_llvm/src/base.rs
index 6d12b511e9c81..4523d629b1ef6 100644
--- a/compiler/rustc_codegen_llvm/src/base.rs
+++ b/compiler/rustc_codegen_llvm/src/base.rs
@@ -28,10 +28,10 @@ use rustc_span::Symbol;
 use rustc_target::spec::SanitizerSet;
 
 use super::ModuleLlvm;
+use crate::attributes;
 use crate::builder::Builder;
 use crate::context::CodegenCx;
-use crate::value::Value;
-use crate::{attributes, llvm};
+use crate::llvm::{self, Value};
 
 pub(crate) struct ValueIter<'ll> {
     cur: Option<&'ll Value>,
diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
index 08da90d535da1..e65f3d292dbb8 100644
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -37,11 +37,9 @@ use crate::common::Funclet;
 use crate::context::{CodegenCx, FullCx, GenericCx, SCx};
 use crate::llvm::{
     self, AtomicOrdering, AtomicRmwBinOp, BasicBlock, FromGeneric, GEPNoWrapFlags, Metadata, TRUE,
-    ToLlvmBool,
+    ToLlvmBool, Type, Value,
 };
-use crate::type_::Type;
 use crate::type_of::LayoutLlvmExt;
-use crate::value::Value;
 
 #[must_use]
 pub(crate) struct GenericBuilder<'a, 'll, CX: Borrow<SCx<'ll>>> {
diff --git a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
index 4a749642265df..bf70a3f4a071d 100644
--- a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
+++ b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
@@ -12,9 +12,7 @@ use tracing::debug;
 use crate::builder::{Builder, PlaceRef, UNNAMED};
 use crate::context::SimpleCx;
 use crate::declare::declare_simple_fn;
-use crate::llvm;
-use crate::llvm::{Metadata, TRUE, Type};
-use crate::value::Value;
+use crate::llvm::{self, Metadata, TRUE, Type, Value};
 
 pub(crate) fn adjust_activity_to_abi<'tcx>(
     tcx: TyCtxt<'tcx>,
diff --git a/compiler/rustc_codegen_llvm/src/callee.rs b/compiler/rustc_codegen_llvm/src/callee.rs
index 791a71d73ae58..b86b32b92df04 100644
--- a/compiler/rustc_codegen_llvm/src/callee.rs
+++ b/compiler/rustc_codegen_llvm/src/callee.rs
@@ -10,8 +10,7 @@ use rustc_middle::ty::{self, Instance, TypeVisitableExt};
 use tracing::debug;
 
 use crate::context::CodegenCx;
-use crate::llvm;
-use crate::value::Value;
+use crate::llvm::{self, Value};
 
 /// Codegens a reference to a fn/method item, monomorphizing and
 /// inlining as it goes.
diff --git a/compiler/rustc_codegen_llvm/src/common.rs b/compiler/rustc_codegen_llvm/src/common.rs
index aa2df46329f22..175fc8535ac3f 100644
--- a/compiler/rustc_codegen_llvm/src/common.rs
+++ b/compiler/rustc_codegen_llvm/src/common.rs
@@ -20,9 +20,7 @@ use tracing::debug;
 use crate::consts::const_alloc_to_llvm;
 pub(crate) use crate::context::CodegenCx;
 use crate::context::{GenericCx, SCx};
-use crate::llvm::{self, BasicBlock, ConstantInt, FALSE, Metadata, TRUE, ToLlvmBool};
-use crate::type_::Type;
-use crate::value::Value;
+use crate::llvm::{self, BasicBlock, ConstantInt, FALSE, Metadata, TRUE, ToLlvmBool, Type, Value};
 
 /*
 * A note on nomenclature of linking: "extern", "foreign", and "upcall".
diff --git a/compiler/rustc_codegen_llvm/src/consts.rs b/compiler/rustc_codegen_llvm/src/consts.rs
index b4ca85a26c8b8..e14f0098dd9b4 100644
--- a/compiler/rustc_codegen_llvm/src/consts.rs
+++ b/compiler/rustc_codegen_llvm/src/consts.rs
@@ -21,10 +21,9 @@ use tracing::{debug, instrument, trace};
 
 use crate::common::CodegenCx;
 use crate::errors::SymbolAlreadyDefined;
-use crate::type_::Type;
+use crate::llvm::{self, Type, Value};
 use crate::type_of::LayoutLlvmExt;
-use crate::value::Value;
-use crate::{base, debuginfo, llvm};
+use crate::{base, debuginfo};
 
 pub(crate) fn const_alloc_to_llvm<'ll>(
     cx: &CodegenCx<'ll, '_>,
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index 3ddbd81ef7580..808aaceab4d20 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -35,10 +35,8 @@ use crate::abi::to_llvm_calling_convention;
 use crate::back::write::to_llvm_code_model;
 use crate::callee::get_fn;
 use crate::debuginfo::metadata::apply_vcall_visibility_metadata;
-use crate::llvm::{Metadata, MetadataKindId, Module};
-use crate::type_::Type;
-use crate::value::Value;
-use crate::{attributes, common, coverageinfo, debuginfo, llvm, llvm_util};
+use crate::llvm::{self, Metadata, MetadataKindId, Module, Type, Value};
+use crate::{attributes, common, coverageinfo, debuginfo, llvm_util};
 
 /// `TyCtxt` (and related cache datastructures) can't be move between threads.
 /// However, there are various cx related functions which we want to be available to the builder and
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs b/compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs
index 3081badb821fa..3a750b6b53eb1 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs
@@ -9,8 +9,7 @@ use rustc_session::config::{CrateType, DebugInfo};
 
 use crate::builder::Builder;
 use crate::common::CodegenCx;
-use crate::llvm;
-use crate::value::Value;
+use crate::llvm::{self, 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.
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
index b8b5f3d30d7c8..014715dd4fda5 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
@@ -41,8 +41,7 @@ use crate::llvm::debuginfo::{
     DIBasicType, DIBuilder, DICompositeType, DIDescriptor, DIFile, DIFlags, DILexicalBlock,
     DIScope, DIType, DebugEmissionKind, DebugNameTableKind,
 };
-use crate::llvm::{self, FromGeneric};
-use crate::value::Value;
+use crate::llvm::{self, FromGeneric, Value};
 
 impl PartialEq for llvm::Metadata {
     fn eq(&self, other: &Self) -> bool {
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
index c6ad1c2e18ec7..f61c25bccfad3 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
@@ -35,12 +35,11 @@ use self::namespace::mangled_name_of_instance;
 use self::utils::{DIB, create_DIArray, is_node_local_to_unit};
 use crate::builder::Builder;
 use crate::common::{AsCCharPtr, CodegenCx};
-use crate::llvm;
 use crate::llvm::debuginfo::{
     DIArray, DIBuilderBox, DIFile, DIFlags, DILexicalBlock, DILocation, DISPFlags, DIScope,
     DITemplateTypeParameter, DIType, DIVariable,
 };
-use crate::value::Value;
+use crate::llvm::{self, Value};
 
 mod create_scope_map;
 mod dwarf_const;
diff --git a/compiler/rustc_codegen_llvm/src/declare.rs b/compiler/rustc_codegen_llvm/src/declare.rs
index f598763efcf22..48b2d09afb674 100644
--- a/compiler/rustc_codegen_llvm/src/declare.rs
+++ b/compiler/rustc_codegen_llvm/src/declare.rs
@@ -23,13 +23,11 @@ use smallvec::SmallVec;
 use tracing::debug;
 
 use crate::abi::FnAbiLlvmExt;
+use crate::attributes;
 use crate::common::AsCCharPtr;
 use crate::context::{CodegenCx, GenericCx, SCx, SimpleCx};
 use crate::llvm::AttributePlace::Function;
-use crate::llvm::{FromGeneric, Visibility};
-use crate::type_::Type;
-use crate::value::Value;
-use crate::{attributes, llvm};
+use crate::llvm::{self, FromGeneric, Type, Value, Visibility};
 
 /// Declare a function with a SimpleCx.
 ///
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
index 467655b0bfcd7..c12383f19312d 100644
--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -25,11 +25,9 @@ use crate::builder::Builder;
 use crate::builder::autodiff::{adjust_activity_to_abi, generate_enzyme_call};
 use crate::context::CodegenCx;
 use crate::errors::AutoDiffWithoutEnable;
-use crate::llvm::{self, Metadata};
-use crate::type_::Type;
+use crate::llvm::{self, Metadata, Type, Value};
 use crate::type_of::LayoutLlvmExt;
 use crate::va_arg::emit_va_arg;
-use crate::value::Value;
 
 fn call_simple_intrinsic<'ll, 'tcx>(
     bx: &mut Builder<'_, 'll, 'tcx>,
diff --git a/compiler/rustc_codegen_llvm/src/llvm/diagnostic.rs b/compiler/rustc_codegen_llvm/src/llvm/diagnostic.rs
index 0e0f2b0eab016..59b2cd329ae76 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/diagnostic.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/diagnostic.rs
@@ -6,7 +6,7 @@ use rustc_span::InnerSpan;
 pub(crate) use self::Diagnostic::*;
 use self::OptimizationDiagnosticKind::*;
 use super::{DiagnosticInfo, SMDiagnostic};
-use crate::value::Value;
+use crate::llvm::Value;
 
 #[derive(Copy, Clone, Debug)]
 pub(crate) enum OptimizationDiagnosticKind {
diff --git a/compiler/rustc_codegen_llvm/src/type_.rs b/compiler/rustc_codegen_llvm/src/type_.rs
index 9de9e0ec44c67..81bb70c958790 100644
--- a/compiler/rustc_codegen_llvm/src/type_.rs
+++ b/compiler/rustc_codegen_llvm/src/type_.rs
@@ -13,12 +13,10 @@ use rustc_middle::ty::{self, Ty};
 use rustc_target::callconv::{CastTarget, FnAbi};
 
 use crate::abi::{FnAbiLlvmExt, LlvmType};
+use crate::common;
 use crate::context::{CodegenCx, GenericCx, SCx};
-pub(crate) use crate::llvm::Type;
-use crate::llvm::{FALSE, Metadata, TRUE, ToLlvmBool};
+use crate::llvm::{self, FALSE, Metadata, TRUE, ToLlvmBool, Type, Value};
 use crate::type_of::LayoutLlvmExt;
-use crate::value::Value;
-use crate::{common, llvm};
 
 impl PartialEq for Type {
     fn eq(&self, other: &Self) -> bool {
diff --git a/compiler/rustc_codegen_llvm/src/type_of.rs b/compiler/rustc_codegen_llvm/src/type_of.rs
index 84998b5499bdf..2b2ac1c6eb29f 100644
--- a/compiler/rustc_codegen_llvm/src/type_of.rs
+++ b/compiler/rustc_codegen_llvm/src/type_of.rs
@@ -11,7 +11,7 @@ use rustc_span::{DUMMY_SP, Span};
 use tracing::debug;
 
 use crate::common::*;
-use crate::type_::Type;
+use crate::llvm::Type;
 
 fn uncached_llvm_type<'a, 'tcx>(
     cx: &CodegenCx<'a, 'tcx>,
diff --git a/compiler/rustc_codegen_llvm/src/va_arg.rs b/compiler/rustc_codegen_llvm/src/va_arg.rs
index 234366e491c57..2d9abb412d4f1 100644
--- a/compiler/rustc_codegen_llvm/src/va_arg.rs
+++ b/compiler/rustc_codegen_llvm/src/va_arg.rs
@@ -9,9 +9,8 @@ use rustc_middle::ty::Ty;
 use rustc_middle::ty::layout::{HasTyCtxt, LayoutOf};
 
 use crate::builder::Builder;
-use crate::type_::Type;
+use crate::llvm::{Type, Value};
 use crate::type_of::LayoutLlvmExt;
-use crate::value::Value;
 
 fn round_up_to_alignment<'ll>(
     bx: &mut Builder<'_, 'll, '_>,
diff --git a/compiler/rustc_codegen_llvm/src/value.rs b/compiler/rustc_codegen_llvm/src/value.rs
index 2eabac3be8c56..37f05f10c50cd 100644
--- a/compiler/rustc_codegen_llvm/src/value.rs
+++ b/compiler/rustc_codegen_llvm/src/value.rs
@@ -1,8 +1,7 @@
 use std::hash::{Hash, Hasher};
 use std::{fmt, ptr};
 
-use crate::llvm;
-pub(crate) use crate::llvm::Value;
+use crate::llvm::{self, Value};
 
 impl PartialEq for Value {
     fn eq(&self, other: &Self) -> bool {

From c7d180cd60225779b5f2833f13d013f000f2efcb Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Mon, 6 Oct 2025 05:54:53 +0200
Subject: [PATCH 1751/1889] add multi-arch asm! label operand test

---
 .../src/directives/directive_names.rs         |  2 +
 tests/ui/asm/label-operand.rs                 | 53 +++++++++++++++++++
 2 files changed, 55 insertions(+)
 create mode 100644 tests/ui/asm/label-operand.rs

diff --git a/src/tools/compiletest/src/directives/directive_names.rs b/src/tools/compiletest/src/directives/directive_names.rs
index 4fef899256739..1ab73fd87e1d0 100644
--- a/src/tools/compiletest/src/directives/directive_names.rs
+++ b/src/tools/compiletest/src/directives/directive_names.rs
@@ -191,6 +191,7 @@ pub(crate) const KNOWN_DIRECTIVE_NAMES: &[&str] = &[
     "only-aarch64-unknown-linux-gnu",
     "only-apple",
     "only-arm",
+    "only-arm64ec",
     "only-avr",
     "only-beta",
     "only-bpf",
@@ -217,6 +218,7 @@ pub(crate) const KNOWN_DIRECTIVE_NAMES: &[&str] = &[
     "only-nightly",
     "only-nvptx64",
     "only-powerpc",
+    "only-riscv32",
     "only-riscv64",
     "only-rustc_abi-x86-sse2",
     "only-s390x",
diff --git a/tests/ui/asm/label-operand.rs b/tests/ui/asm/label-operand.rs
new file mode 100644
index 0000000000000..f1be5d7d85609
--- /dev/null
+++ b/tests/ui/asm/label-operand.rs
@@ -0,0 +1,53 @@
+//@ run-pass
+//@ reference: asm.operand-type.supported-operands.label
+//@ revisions: aarch64 arm arm64ec riscv32 riscv64 x86 x86_64
+//@ needs-asm-support
+//@[aarch64] only-aarch64
+//@[arm64ec] only-arm64ec
+//@[arm] only-arm
+//@[riscv32] only-riscv32
+//@[riscv64] only-riscv64
+//@[x86] only-x86
+//@[x86_64] only-x86_64
+
+#[cfg(any(aarch64, arm, arm64ec))]
+fn make_true(value: &mut bool) {
+    unsafe {
+        core::arch::asm!(
+            "b {}",
+            label {
+                *value = true;
+            }
+        );
+    }
+}
+
+#[cfg(any(riscv32, riscv64))]
+fn make_true(value: &mut bool) {
+    unsafe {
+        core::arch::asm!(
+            "j {}",
+            label {
+                *value = true;
+            }
+        );
+    }
+}
+
+#[cfg(any(x86, x86_64))]
+fn make_true(value: &mut bool) {
+    unsafe {
+        core::arch::asm!(
+            "jmp {}",
+            label {
+                *value = true;
+            }
+        );
+    }
+}
+
+fn main() {
+    let mut value = false;
+    make_true(&mut value);
+    assert!(value);
+}

From f54139aa310b4cd2cb2bfc144eec865464a8cc09 Mon Sep 17 00:00:00 2001
From: The rustc-josh-sync Cronjob Bot <github-actions@github.com>
Date: Mon, 6 Oct 2025 04:13:15 +0000
Subject: [PATCH 1752/1889] Prepare for merging from rust-lang/rust

This updates the rust-version file to 4fa824bb78318a3cba8c7339d5754b4909922547.
---
 src/doc/rustc-dev-guide/rust-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/rust-version b/src/doc/rustc-dev-guide/rust-version
index 0dc9ce843e9c9..47552aee08f74 100644
--- a/src/doc/rustc-dev-guide/rust-version
+++ b/src/doc/rustc-dev-guide/rust-version
@@ -1 +1 @@
-9f32ccf35fb877270bc44a86a126440f04d676d0
+4fa824bb78318a3cba8c7339d5754b4909922547

From eeb7cb1b8a42630458e6c6cdabf0c4264579aec7 Mon Sep 17 00:00:00 2001
From: Martin Nordholts <martin.nordholts@codetale.se>
Date: Mon, 22 Sep 2025 07:39:48 +0200
Subject: [PATCH 1753/1889] compiler: Hint at multiple crate versions if trait
 impl is for wrong ADT

If a user does e.g.

    impl From<Bar> for foo::Foo

and get a compilation error about that `From<Bar>` is not implemented
for `Foo`, check if multiple versions of the crate with `Foo` is present
in the dependency graph. If so, give a hint about it.

I encountered this case in the wild and didn't realize I had multiple
versions of a crate in my dependency graph. So I was a bit confused at
first. This fix will make life easier for others.
---
 .../traits/fulfillment_errors.rs              | 85 +++++++++++++++++--
 .../run-make/duplicate-dependency/main.stderr |  6 ++
 tests/run-make/duplicate-dependency/rmake.rs  |  4 +-
 3 files changed, 88 insertions(+), 7 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 149f5e638b1ad..7728f657bedad 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
@@ -467,7 +467,8 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                             span,
                             leaf_trait_predicate,
                         );
-                        self.note_version_mismatch(&mut err, leaf_trait_predicate);
+                        self.note_trait_version_mismatch(&mut err, leaf_trait_predicate);
+                        self.note_adt_version_mismatch(&mut err, leaf_trait_predicate);
                         self.suggest_remove_await(&obligation, &mut err);
                         self.suggest_derive(&obligation, &mut err, leaf_trait_predicate);
 
@@ -2406,7 +2407,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
     /// If the `Self` type of the unsatisfied trait `trait_ref` implements a trait
     /// with the same path as `trait_ref`, a help message about
     /// a probable version mismatch is added to `err`
-    fn note_version_mismatch(
+    fn note_trait_version_mismatch(
         &self,
         err: &mut Diag<'_>,
         trait_pred: ty::PolyTraitPredicate<'tcx>,
@@ -2446,15 +2447,87 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 impl_spans,
                 format!("trait impl{} with same name found", pluralize!(trait_impls.len())),
             );
-            let trait_crate = self.tcx.crate_name(trait_with_same_path.krate);
-            let crate_msg =
-                format!("perhaps two different versions of crate `{trait_crate}` are being used?");
-            err.note(crate_msg);
+            self.note_two_crate_versions(trait_with_same_path, err);
             suggested = true;
         }
         suggested
     }
 
+    fn note_two_crate_versions(&self, did: DefId, err: &mut Diag<'_>) {
+        let crate_name = self.tcx.crate_name(did.krate);
+        let crate_msg =
+            format!("perhaps two different versions of crate `{crate_name}` are being used?");
+        err.note(crate_msg);
+    }
+
+    fn note_adt_version_mismatch(
+        &self,
+        err: &mut Diag<'_>,
+        trait_pred: ty::PolyTraitPredicate<'tcx>,
+    ) {
+        let ty::Adt(impl_self_def, _) = trait_pred.self_ty().skip_binder().peel_refs().kind()
+        else {
+            return;
+        };
+
+        let impl_self_did = impl_self_def.did();
+
+        // We only want to warn about different versions of a dependency.
+        // If no dependency is involved, bail.
+        if impl_self_did.krate == LOCAL_CRATE {
+            return;
+        }
+
+        let impl_self_path = self.comparable_path(impl_self_did);
+        let impl_self_crate_name = self.tcx.crate_name(impl_self_did.krate);
+        let similar_items: UnordSet<_> = self
+            .tcx
+            .visible_parent_map(())
+            .items()
+            .filter_map(|(&item, _)| {
+                // If we found ourselves, ignore.
+                if impl_self_did == item {
+                    return None;
+                }
+                // We only want to warn about different versions of a dependency.
+                // Ignore items from our own crate.
+                if item.krate == LOCAL_CRATE {
+                    return None;
+                }
+                // We want to warn about different versions of a dependency.
+                // So make sure the crate names are the same.
+                if impl_self_crate_name != self.tcx.crate_name(item.krate) {
+                    return None;
+                }
+                // Filter out e.g. constructors that often have the same path
+                // str as the relevant ADT.
+                if !self.tcx.def_kind(item).is_adt() {
+                    return None;
+                }
+                let path = self.comparable_path(item);
+                // We don't know if our item or the one we found is the re-exported one.
+                // Check both cases.
+                let is_similar = path.ends_with(&impl_self_path) || impl_self_path.ends_with(&path);
+                is_similar.then_some((item, path))
+            })
+            .collect();
+
+        let mut similar_items =
+            similar_items.into_items().into_sorted_stable_ord_by_key(|(_, path)| path);
+        similar_items.dedup();
+
+        for (similar_item, _) in similar_items {
+            err.span_help(self.tcx.def_span(similar_item), "item with same name found");
+            self.note_two_crate_versions(similar_item, err);
+        }
+    }
+
+    /// Add a `::` prefix when comparing paths so that paths with just one item
+    /// like "Foo" does not equal the end of "OtherFoo".
+    fn comparable_path(&self, did: DefId) -> String {
+        format!("::{}", self.tcx.def_path_str(did))
+    }
+
     /// Creates a `PredicateObligation` with `new_self_ty` replacing the existing type in the
     /// `trait_ref`.
     ///
diff --git a/tests/run-make/duplicate-dependency/main.stderr b/tests/run-make/duplicate-dependency/main.stderr
index 2c912f872fe35..36d54988788f4 100644
--- a/tests/run-make/duplicate-dependency/main.stderr
+++ b/tests/run-make/duplicate-dependency/main.stderr
@@ -6,6 +6,12 @@ LL |     re_export_foo::into_foo(Bar);
    |     |
    |     required by a bound introduced by this call
    |
+help: item with same name found
+  --> $DIR/foo-v1.rs:1:1
+   |
+LL | pub struct Foo;
+   | ^^^^^^^^^^^^^^
+   = note: perhaps two different versions of crate `foo` are being used?
    = note: required for `Bar` to implement `Into<re_export_foo::foo::Foo>`
 note: required by a bound in `into_foo`
   --> $DIR/re-export-foo.rs:3:25
diff --git a/tests/run-make/duplicate-dependency/rmake.rs b/tests/run-make/duplicate-dependency/rmake.rs
index 13ab4caaba56f..762d97e4311f4 100644
--- a/tests/run-make/duplicate-dependency/rmake.rs
+++ b/tests/run-make/duplicate-dependency/rmake.rs
@@ -1,3 +1,5 @@
+//@ needs-target-std
+
 use run_make_support::{Rustc, cwd, diff, rust_lib_name, rustc};
 
 fn rustc_with_common_args() -> Rustc {
@@ -39,5 +41,5 @@ fn main() {
         .run_fail()
         .stderr_utf8();
 
-    diff().expected_file("main.stderr").actual_text("(rustc)", &stderr).run();
+    diff().expected_file("main.stderr").normalize(r"\\", "/").actual_text("(rustc)", &stderr).run();
 }

From 98afeb86453540ebdea0af21ba5064caed6b089b Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Mon, 6 Oct 2025 07:06:27 +0200
Subject: [PATCH 1754/1889] fix text describing edition range testing

---
 src/doc/rustc-dev-guide/src/tests/directives.md | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/tests/directives.md b/src/doc/rustc-dev-guide/src/tests/directives.md
index 3b6c891746455..25c8a4c354ab6 100644
--- a/src/doc/rustc-dev-guide/src/tests/directives.md
+++ b/src/doc/rustc-dev-guide/src/tests/directives.md
@@ -264,11 +264,16 @@ Consider writing the test as a proper incremental test instead.
 
 #### The edition directive
 
-The `//@ edition` directive can take an exact edition, a bounded half-open range of editions or a left-bounded half-open range of editions, this affects which edition is used by `./x test` to run the test. For example:
+The `//@ edition` directive can take an exact edition, a bounded range of editions, or a left-bounded half-open range of editions.
+This affects which edition is used by `./x test` to run the test.
+
+For example:
 
 - A test with the `//@ edition: 2018` directive will only run under the 2018 edition.
-- A test with the `//@ edition: 2015..2021` directive can be run under both the 2015 and 2018 editions. However, CI will only run the test with the lowest edition possible (2015 in this case).
-- A test with the `//@ edition: 2018..` directive will run under any edition greater or equal than 2018. However, CI will only run the test with the lowest edition possible (2018 in this case).
+- A test with the `//@ edition: 2015..2021` directive can be run under the 2015, 2018, and 2021 editions.
+  However, CI will only run the test with the lowest edition in the range (which is 2015 in this example).
+- A test with the `//@ edition: 2018..` directive will run under 2018 edition or greater.
+  However, CI will only run the test with the lowest edition in the range (which is 2018 in this example).
 
 You can also force `./x test` to use a specific edition by passing the `-- --edition=` argument. However, tests with the `//@ edition` directive will clamp the value passed to the argument. For example, if we run `./x test -- --edition=2015`:
 

From 2d6f590af115f16c57796162703cca62a5860ebd Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Mon, 6 Oct 2025 07:13:01 +0200
Subject: [PATCH 1755/1889] overlong

---
 src/doc/rustc-dev-guide/src/tests/directives.md | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/tests/directives.md b/src/doc/rustc-dev-guide/src/tests/directives.md
index 25c8a4c354ab6..2c6cfeb0ac702 100644
--- a/src/doc/rustc-dev-guide/src/tests/directives.md
+++ b/src/doc/rustc-dev-guide/src/tests/directives.md
@@ -264,7 +264,8 @@ Consider writing the test as a proper incremental test instead.
 
 #### The edition directive
 
-The `//@ edition` directive can take an exact edition, a bounded range of editions, or a left-bounded half-open range of editions.
+The `//@ edition` directive can take an exact edition, a bounded range of editions,
+or a left-bounded half-open range of editions.
 This affects which edition is used by `./x test` to run the test.
 
 For example:
@@ -275,7 +276,9 @@ For example:
 - A test with the `//@ edition: 2018..` directive will run under 2018 edition or greater.
   However, CI will only run the test with the lowest edition in the range (which is 2018 in this example).
 
-You can also force `./x test` to use a specific edition by passing the `-- --edition=` argument. However, tests with the `//@ edition` directive will clamp the value passed to the argument. For example, if we run `./x test -- --edition=2015`:
+You can also force `./x test` to use a specific edition by passing the `-- --edition=` argument.
+However, tests with the `//@ edition` directive will clamp the value passed to the argument.
+For example, if we run `./x test -- --edition=2015`:
 
 - A test with the `//@ edition: 2018` will run with the 2018 edition. 
 - A test with the `//@ edition: 2015..2021` will be run with the 2015 edition. 

From d24ee20876dc3438810ddf640f6ceb732bd75ed3 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 6 Oct 2025 12:09:57 +0200
Subject: [PATCH 1756/1889] use `fluent_syntax` to parse fluent files

---
 src/tools/tidy/src/fluent_alphabetical.rs | 41 ++++++++++++-----------
 1 file changed, 22 insertions(+), 19 deletions(-)

diff --git a/src/tools/tidy/src/fluent_alphabetical.rs b/src/tools/tidy/src/fluent_alphabetical.rs
index b1d1c16b4549c..1fadc523591c7 100644
--- a/src/tools/tidy/src/fluent_alphabetical.rs
+++ b/src/tools/tidy/src/fluent_alphabetical.rs
@@ -5,6 +5,8 @@ use std::fs::OpenOptions;
 use std::io::Write;
 use std::path::Path;
 
+use fluent_syntax::ast::Entry;
+use fluent_syntax::parser;
 use regex::Regex;
 
 use crate::diagnostics::{CheckId, DiagCtx, RunningCheck};
@@ -24,30 +26,31 @@ fn check_alphabetic(
     check: &mut RunningCheck,
     all_defined_msgs: &mut HashMap<String, String>,
 ) {
-    let mut matches = message().captures_iter(fluent).peekable();
-    while let Some(m) = matches.next() {
-        let name = m.get(1).unwrap();
-        if let Some(defined_filename) = all_defined_msgs.get(name.as_str()) {
-            check.error(format!(
-                "{filename}: message `{}` is already defined in {defined_filename}",
-                name.as_str(),
-            ));
-        }
+    let Ok(resource) = parser::parse(fluent) else {
+        panic!("Errors encountered while parsing fluent file `{filename}`");
+    };
 
-        all_defined_msgs.insert(name.as_str().to_owned(), filename.to_owned());
+    let mut prev: Option<&str> = None;
 
-        if let Some(next) = matches.peek() {
-            let next = next.get(1).unwrap();
-            if name.as_str() > next.as_str() {
+    for entry in &resource.body {
+        if let Entry::Message(msg) = entry {
+            let name: &str = msg.id.name;
+            if let Some(defined_filename) = all_defined_msgs.get(name) {
                 check.error(format!(
-                    "{filename}: message `{}` appears before `{}`, but is alphabetically later than it
-run `./x.py test tidy --bless` to sort the file correctly",
-                    name.as_str(),
-                    next.as_str()
+                    "{filename}: message `{name}` is already defined in {defined_filename}",
+                ));
+            } else {
+                all_defined_msgs.insert(name.to_string(), filename.to_owned());
+            }
+            if let Some(prev) = prev
+                && prev > name
+            {
+                check.error(format!(
+                    "{filename}: message `{prev}` appears before `{name}`, but is alphabetically \
+later than it. Run `./x.py test tidy --bless` to sort the file correctly",
                 ));
             }
-        } else {
-            break;
+            prev = Some(name);
         }
     }
 }

From 831cdf3144f23871e9923ddeb9a36d0192e7244a Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 6 Oct 2025 12:11:56 +0200
Subject: [PATCH 1757/1889] Fail if no fluent messages were found

---
 src/tools/tidy/src/fluent_alphabetical.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/tools/tidy/src/fluent_alphabetical.rs b/src/tools/tidy/src/fluent_alphabetical.rs
index 1fadc523591c7..769f92d04f0af 100644
--- a/src/tools/tidy/src/fluent_alphabetical.rs
+++ b/src/tools/tidy/src/fluent_alphabetical.rs
@@ -118,5 +118,7 @@ pub fn check(path: &Path, bless: bool, diag_ctx: DiagCtx) {
         },
     );
 
+    assert!(!all_defined_msgs.is_empty());
+
     crate::fluent_used::check(path, all_defined_msgs, diag_ctx);
 }

From f4b4fb9b7f1af29c3b9f6e25229a2514d5db35c7 Mon Sep 17 00:00:00 2001
From: Teodoro Freund <tfreund95@gmail.com>
Date: Mon, 6 Oct 2025 09:35:46 -0300
Subject: [PATCH 1758/1889] Fixed some lint deprecated versions

---
 clippy_lints/src/deprecated_lints.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/clippy_lints/src/deprecated_lints.rs b/clippy_lints/src/deprecated_lints.rs
index 80b74f50223a4..2147f72889093 100644
--- a/clippy_lints/src/deprecated_lints.rs
+++ b/clippy_lints/src/deprecated_lints.rs
@@ -18,11 +18,11 @@ declare_with_version! { DEPRECATED(DEPRECATED_VERSION) = [
     ("clippy::assign_ops", "compound operators are harmless and linting on them is not in scope for clippy"),
     #[clippy::version = "pre 1.29.0"]
     ("clippy::extend_from_slice", "`Vec::extend_from_slice` is no longer faster than `Vec::extend` due to specialization"),
-    #[clippy::version = "1.86.0"]
+    #[clippy::version = "1.88.0"]
     ("clippy::match_on_vec_items", "`clippy::indexing_slicing` covers indexing and slicing on `Vec<_>`"),
     #[clippy::version = "pre 1.29.0"]
     ("clippy::misaligned_transmute", "split into `clippy::cast_ptr_alignment` and `clippy::transmute_ptr_to_ptr`"),
-    #[clippy::version = "1.86.0"]
+    #[clippy::version = "1.87.0"]
     ("clippy::option_map_or_err_ok", "`clippy::manual_ok_or` covers this case"),
     #[clippy::version = "1.54.0"]
     ("clippy::pub_enum_variant_names", "`clippy::enum_variant_names` now covers this case via the `avoid-breaking-exported-api` config"),
@@ -34,7 +34,7 @@ declare_with_version! { DEPRECATED(DEPRECATED_VERSION) = [
     ("clippy::replace_consts", "`min_value` and `max_value` are now deprecated"),
     #[clippy::version = "pre 1.29.0"]
     ("clippy::should_assert_eq", "`assert!(a == b)` can now print the values the same way `assert_eq!(a, b) can"),
-    #[clippy::version = "1.90.0"]
+    #[clippy::version = "1.91.0"]
     ("clippy::string_to_string", "`clippy:implicit_clone` covers those cases"),
     #[clippy::version = "pre 1.29.0"]
     ("clippy::unsafe_vector_initialization", "the suggested alternative could be substantially slower"),

From 696b6ac14dd9c3aaae12c000cf5fa1bd0fec8c34 Mon Sep 17 00:00:00 2001
From: Deadbeef <ent3rm4n@gmail.com>
Date: Sat, 16 Aug 2025 22:08:41 +0800
Subject: [PATCH 1759/1889] use declarative macro for `#[derive(TryFromU32)]`

---
 .../src/coverageinfo/mapgen.rs                |  3 +-
 compiler/rustc_codegen_llvm/src/lib.rs        |  4 ++
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs   |  3 +-
 compiler/rustc_codegen_llvm/src/macros.rs     | 22 ++++++++
 compiler/rustc_macros/src/lib.rs              |  9 ---
 compiler/rustc_macros/src/try_from.rs         | 55 -------------------
 tests/ui-fulldeps/try-from-u32/errors.rs      | 24 --------
 tests/ui-fulldeps/try-from-u32/errors.stderr  | 32 -----------
 tests/ui-fulldeps/try-from-u32/hygiene.rs     | 32 -----------
 tests/ui-fulldeps/try-from-u32/values.rs      | 36 ------------
 10 files changed, 28 insertions(+), 192 deletions(-)
 create mode 100644 compiler/rustc_codegen_llvm/src/macros.rs
 delete mode 100644 compiler/rustc_macros/src/try_from.rs
 delete mode 100644 tests/ui-fulldeps/try-from-u32/errors.rs
 delete mode 100644 tests/ui-fulldeps/try-from-u32/errors.stderr
 delete mode 100644 tests/ui-fulldeps/try-from-u32/hygiene.rs
 delete mode 100644 tests/ui-fulldeps/try-from-u32/values.rs

diff --git a/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs b/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs
index d1cb95507d91c..7e873347c82b0 100644
--- a/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs
+++ b/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs
@@ -6,7 +6,6 @@ use rustc_abi::Align;
 use rustc_codegen_ssa::traits::{BaseTypeCodegenMethods, ConstCodegenMethods};
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_index::IndexVec;
-use rustc_macros::TryFromU32;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::RemapFileNameExt;
 use rustc_session::config::RemapPathScopeComponents;
@@ -16,7 +15,7 @@ use tracing::debug;
 use crate::common::CodegenCx;
 use crate::coverageinfo::llvm_cov;
 use crate::coverageinfo::mapgen::covfun::prepare_covfun_record;
-use crate::llvm;
+use crate::{TryFromU32, llvm};
 
 mod covfun;
 mod spans;
diff --git a/compiler/rustc_codegen_llvm/src/lib.rs b/compiler/rustc_codegen_llvm/src/lib.rs
index 2405a25c7020b..807049f08d367 100644
--- a/compiler/rustc_codegen_llvm/src/lib.rs
+++ b/compiler/rustc_codegen_llvm/src/lib.rs
@@ -14,6 +14,7 @@
 #![feature(if_let_guard)]
 #![feature(impl_trait_in_assoc_type)]
 #![feature(iter_intersperse)]
+#![feature(macro_derive)]
 #![feature(rustdoc_internals)]
 #![feature(slice_as_array)]
 #![feature(try_blocks)]
@@ -65,6 +66,7 @@ mod errors;
 mod intrinsic;
 mod llvm;
 mod llvm_util;
+mod macros;
 mod mono_item;
 mod type_;
 mod type_of;
@@ -74,6 +76,8 @@ mod value;
 
 rustc_fluent_macro::fluent_messages! { "../messages.ftl" }
 
+pub(crate) use macros::TryFromU32;
+
 #[derive(Clone)]
 pub struct LlvmCodegenBackend(());
 
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index ccbc999dad1f0..c4b5cf413a725 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -19,7 +19,6 @@ use std::ptr;
 
 use bitflags::bitflags;
 use libc::{c_char, c_int, c_uchar, c_uint, c_ulonglong, c_void, size_t};
-use rustc_macros::TryFromU32;
 
 use super::RustString;
 use super::debuginfo::{
@@ -27,8 +26,8 @@ use super::debuginfo::{
     DIGlobalVariableExpression, DILocation, DISPFlags, DIScope, DISubprogram,
     DITemplateTypeParameter, DIType, DebugEmissionKind, DebugNameTableKind,
 };
-use crate::llvm;
 use crate::llvm::MetadataKindId;
+use crate::{TryFromU32, llvm};
 
 /// In the LLVM-C API, boolean values are passed as `typedef int LLVMBool`,
 /// which has a different ABI from Rust or C++ `bool`.
diff --git a/compiler/rustc_codegen_llvm/src/macros.rs b/compiler/rustc_codegen_llvm/src/macros.rs
new file mode 100644
index 0000000000000..fddc428ca273b
--- /dev/null
+++ b/compiler/rustc_codegen_llvm/src/macros.rs
@@ -0,0 +1,22 @@
+macro_rules! TryFromU32 {
+    derive() (
+        $(#[$meta:meta])*
+        $vis:vis enum $Type:ident {
+            $(
+                $(#[$varmeta:meta])*
+                $Variant:ident $(= $discr:expr)?
+            ),* $(,)?
+        }
+    ) => {
+        impl ::core::convert::TryFrom<u32> for $Type {
+            type Error = u32;
+            #[allow(deprecated)] // Don't warn about deprecated variants.
+            fn try_from(value: u32) -> ::core::result::Result<$Type, Self::Error> {
+                $( if value == const { $Type::$Variant as u32 } { return Ok($Type::$Variant) } )*
+                Err(value)
+            }
+        }
+    }
+}
+
+pub(crate) use TryFromU32;
diff --git a/compiler/rustc_macros/src/lib.rs b/compiler/rustc_macros/src/lib.rs
index 803b3621c887e..a6f53d92e1006 100644
--- a/compiler/rustc_macros/src/lib.rs
+++ b/compiler/rustc_macros/src/lib.rs
@@ -18,7 +18,6 @@ mod print_attribute;
 mod query;
 mod serialize;
 mod symbols;
-mod try_from;
 mod type_foldable;
 mod type_visitable;
 mod visitable;
@@ -176,14 +175,6 @@ decl_derive!(
         applicability)] => diagnostics::subdiagnostic_derive
 );
 
-decl_derive! {
-    [TryFromU32] =>
-    /// Derives `TryFrom<u32>` for the annotated `enum`, which must have no fields.
-    /// Each variant maps to the value it would produce under an `as u32` cast.
-    ///
-    /// The error type is `u32`.
-    try_from::try_from_u32
-}
 decl_derive! {
     [PrintAttribute] =>
     /// Derives `PrintAttribute` for `AttributeKind`.
diff --git a/compiler/rustc_macros/src/try_from.rs b/compiler/rustc_macros/src/try_from.rs
deleted file mode 100644
index 9338c1c2b3361..0000000000000
--- a/compiler/rustc_macros/src/try_from.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-use proc_macro2::TokenStream;
-use quote::{quote, quote_spanned};
-use syn::Data;
-use syn::spanned::Spanned;
-use synstructure::Structure;
-
-pub(crate) fn try_from_u32(s: Structure<'_>) -> TokenStream {
-    let span_error = |span, message: &str| {
-        quote_spanned! { span => const _: () = ::core::compile_error!(#message); }
-    };
-
-    // Must be applied to an enum type.
-    if let Some(span) = match &s.ast().data {
-        Data::Enum(_) => None,
-        Data::Struct(s) => Some(s.struct_token.span()),
-        Data::Union(u) => Some(u.union_token.span()),
-    } {
-        return span_error(span, "type is not an enum (TryFromU32)");
-    }
-
-    // The enum's variants must not have fields.
-    let variant_field_errors = s
-        .variants()
-        .iter()
-        .filter_map(|v| v.ast().fields.iter().map(|f| f.span()).next())
-        .map(|span| span_error(span, "enum variant cannot have fields (TryFromU32)"))
-        .collect::<TokenStream>();
-    if !variant_field_errors.is_empty() {
-        return variant_field_errors;
-    }
-
-    let ctor = s
-        .variants()
-        .iter()
-        .map(|v| v.construct(|_, _| -> TokenStream { unreachable!() }))
-        .collect::<Vec<_>>();
-    // FIXME(edition_2024): Fix the `keyword_idents_2024` lint to not trigger here?
-    #[allow(keyword_idents_2024)]
-    s.gen_impl(quote! {
-        // The surrounding code might have shadowed these identifiers.
-        use ::core::convert::TryFrom;
-        use ::core::primitive::u32;
-        use ::core::result::Result::{self, Ok, Err};
-
-        gen impl TryFrom<u32> for @Self {
-            type Error = u32;
-
-            #[allow(deprecated)] // Don't warn about deprecated variants.
-            fn try_from(value: u32) -> Result<Self, Self::Error> {
-                #( if value == const { #ctor as u32 } { return Ok(#ctor) } )*
-                Err(value)
-            }
-        }
-    })
-}
diff --git a/tests/ui-fulldeps/try-from-u32/errors.rs b/tests/ui-fulldeps/try-from-u32/errors.rs
deleted file mode 100644
index a25069c0a53cb..0000000000000
--- a/tests/ui-fulldeps/try-from-u32/errors.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-#![feature(rustc_private)]
-//@ edition: 2021
-
-// Checks the error messages produced by `#[derive(TryFromU32)]`.
-
-extern crate rustc_macros;
-
-use rustc_macros::TryFromU32;
-
-#[derive(TryFromU32)]
-struct MyStruct {} //~ ERROR type is not an enum
-
-#[derive(TryFromU32)]
-enum NonTrivial {
-    A,
-    B(),
-    C {},
-    D(bool),                //~ ERROR enum variant cannot have fields
-    E(bool, bool),          //~ ERROR enum variant cannot have fields
-    F { x: bool },          //~ ERROR enum variant cannot have fields
-    G { x: bool, y: bool }, //~ ERROR enum variant cannot have fields
-}
-
-fn main() {}
diff --git a/tests/ui-fulldeps/try-from-u32/errors.stderr b/tests/ui-fulldeps/try-from-u32/errors.stderr
deleted file mode 100644
index d20567061d7bb..0000000000000
--- a/tests/ui-fulldeps/try-from-u32/errors.stderr
+++ /dev/null
@@ -1,32 +0,0 @@
-error: type is not an enum (TryFromU32)
-  --> $DIR/errors.rs:11:1
-   |
-LL | struct MyStruct {}
-   | ^^^^^^
-
-error: enum variant cannot have fields (TryFromU32)
-  --> $DIR/errors.rs:18:7
-   |
-LL |     D(bool),
-   |       ^^^^
-
-error: enum variant cannot have fields (TryFromU32)
-  --> $DIR/errors.rs:19:7
-   |
-LL |     E(bool, bool),
-   |       ^^^^
-
-error: enum variant cannot have fields (TryFromU32)
-  --> $DIR/errors.rs:20:9
-   |
-LL |     F { x: bool },
-   |         ^
-
-error: enum variant cannot have fields (TryFromU32)
-  --> $DIR/errors.rs:21:9
-   |
-LL |     G { x: bool, y: bool },
-   |         ^
-
-error: aborting due to 5 previous errors
-
diff --git a/tests/ui-fulldeps/try-from-u32/hygiene.rs b/tests/ui-fulldeps/try-from-u32/hygiene.rs
deleted file mode 100644
index e0655a64a64db..0000000000000
--- a/tests/ui-fulldeps/try-from-u32/hygiene.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-#![feature(rustc_private)]
-//@ edition: 2021
-//@ check-pass
-
-// Checks that the derive macro still works even if the surrounding code has
-// shadowed the relevant library types.
-
-extern crate rustc_macros;
-
-mod submod {
-    use rustc_macros::TryFromU32;
-
-    struct Result;
-    trait TryFrom {}
-    #[allow(non_camel_case_types)]
-    struct u32;
-    struct Ok;
-    struct Err;
-    mod core {}
-    mod std {}
-
-    #[derive(TryFromU32)]
-    pub(crate) enum MyEnum {
-        Zero,
-        One,
-    }
-}
-
-fn main() {
-    use submod::MyEnum;
-    let _: Result<MyEnum, u32> = MyEnum::try_from(1u32);
-}
diff --git a/tests/ui-fulldeps/try-from-u32/values.rs b/tests/ui-fulldeps/try-from-u32/values.rs
deleted file mode 100644
index 180a8f2beb75b..0000000000000
--- a/tests/ui-fulldeps/try-from-u32/values.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-#![feature(assert_matches)]
-#![feature(rustc_private)]
-//@ edition: 2021
-//@ run-pass
-
-// Checks the values accepted by the `TryFrom<u32>` impl produced by `#[derive(TryFromU32)]`.
-
-extern crate rustc_macros;
-
-use core::assert_matches::assert_matches;
-use rustc_macros::TryFromU32;
-
-#[derive(TryFromU32, Debug, PartialEq)]
-#[repr(u32)]
-enum Repr {
-    Zero,
-    One(),
-    Seven = 7,
-}
-
-#[derive(TryFromU32, Debug)]
-enum NoRepr {
-    Zero,
-    One,
-}
-
-fn main() {
-    assert_eq!(Repr::try_from(0u32), Ok(Repr::Zero));
-    assert_eq!(Repr::try_from(1u32), Ok(Repr::One()));
-    assert_eq!(Repr::try_from(2u32), Err(2));
-    assert_eq!(Repr::try_from(7u32), Ok(Repr::Seven));
-
-    assert_matches!(NoRepr::try_from(0u32), Ok(NoRepr::Zero));
-    assert_matches!(NoRepr::try_from(1u32), Ok(NoRepr::One));
-    assert_matches!(NoRepr::try_from(2u32), Err(2));
-}

From 085ddaaa97bf55914a33938462d133dd597c8f0b Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Mon, 6 Oct 2025 17:26:17 +0200
Subject: [PATCH 1760/1889] Bump nightly version -> 2025-10-06

---
 clippy_utils/README.md | 2 +-
 rust-toolchain.toml    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/clippy_utils/README.md b/clippy_utils/README.md
index 2c66fdc73f539..1f678a6a29f08 100644
--- a/clippy_utils/README.md
+++ b/clippy_utils/README.md
@@ -8,7 +8,7 @@ This crate is only guaranteed to build with this `nightly` toolchain:
 
 <!-- begin autogenerated nightly -->
 ```
-nightly-2025-09-18
+nightly-2025-10-06
 ```
 <!-- end autogenerated nightly -->
 
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index 9c102de448200..e936f5dc3b7a5 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,6 +1,6 @@
 [toolchain]
 # begin autogenerated nightly
-channel = "nightly-2025-09-18"
+channel = "nightly-2025-10-06"
 # end autogenerated nightly
 components = ["cargo", "llvm-tools", "rust-src", "rust-std", "rustc", "rustc-dev", "rustfmt"]
 profile = "minimal"

From 8c4be66084f62b6de4dece52f517b455b802edca Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Mon, 6 Oct 2025 18:10:44 +0200
Subject: [PATCH 1761/1889] Update Cargo.lock

---
 Cargo.lock | 99 +++++++++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 79 insertions(+), 20 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 2de9c84e3b031..92a9013ca2575 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -216,7 +216,7 @@ dependencies = [
  "memchr",
  "serde",
  "serde_derive",
- "winnow 0.7.12",
+ "winnow 0.7.13",
 ]
 
 [[package]]
@@ -590,7 +590,7 @@ dependencies = [
  "serde_json",
  "tempfile",
  "termize",
- "toml 0.7.8",
+ "toml 0.9.7",
  "ui_test",
  "walkdir",
 ]
@@ -632,7 +632,7 @@ dependencies = [
  "regex-syntax 0.8.5",
  "semver",
  "serde",
- "toml 0.7.8",
+ "toml 0.9.7",
  "unicode-normalization",
  "unicode-script",
  "url",
@@ -1866,13 +1866,14 @@ checksum = "964de6e86d545b246d84badc0fef527924ace5134f30641c203ef52ba83f58d5"
 
 [[package]]
 name = "indexmap"
-version = "2.10.0"
+version = "2.11.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe4cd85333e22411419a0bcae1297d25e58c9443848b11dc6a86fefe8c78a661"
+checksum = "4b0f83760fb341a774ed326568e19f5a863af4a952def8c39f9ab92fd95b88e5"
 dependencies = [
  "equivalent",
  "hashbrown",
  "serde",
+ "serde_core",
 ]
 
 [[package]]
@@ -5003,10 +5004,11 @@ dependencies = [
 
 [[package]]
 name = "serde"
-version = "1.0.219"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
 dependencies = [
+ "serde_core",
  "serde_derive",
 ]
 
@@ -5031,11 +5033,20 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
 [[package]]
 name = "serde_derive"
-version = "1.0.219"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -5084,6 +5095,15 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "serde_spanned"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5417783452c2be558477e104686f7de5dae53dba813c28435e0e70f82d9b04ee"
+dependencies = [
+ "serde_core",
+]
+
 [[package]]
 name = "sha1"
 version = "0.10.6"
@@ -5545,8 +5565,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dd79e69d3b627db300ff956027cc6c3798cef26d22526befdfcd12feeb6d2257"
 dependencies = [
  "serde",
- "serde_spanned",
- "toml_datetime",
+ "serde_spanned 0.6.9",
+ "toml_datetime 0.6.11",
  "toml_edit 0.19.15",
 ]
 
@@ -5558,11 +5578,26 @@ checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362"
 dependencies = [
  "indexmap",
  "serde",
- "serde_spanned",
- "toml_datetime",
+ "serde_spanned 0.6.9",
+ "toml_datetime 0.6.11",
  "toml_edit 0.22.27",
 ]
 
+[[package]]
+name = "toml"
+version = "0.9.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00e5e5d9bf2475ac9d4f0d9edab68cc573dc2fd644b0dba36b0c30a92dd9eaa0"
+dependencies = [
+ "indexmap",
+ "serde_core",
+ "serde_spanned 1.0.2",
+ "toml_datetime 0.7.2",
+ "toml_parser",
+ "toml_writer",
+ "winnow 0.7.13",
+]
+
 [[package]]
 name = "toml_datetime"
 version = "0.6.11"
@@ -5572,6 +5607,15 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "toml_datetime"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32f1085dec27c2b6632b04c80b3bb1b4300d6495d1e129693bdda7d91e72eec1"
+dependencies = [
+ "serde_core",
+]
+
 [[package]]
 name = "toml_edit"
 version = "0.19.15"
@@ -5580,8 +5624,8 @@ checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
 dependencies = [
  "indexmap",
  "serde",
- "serde_spanned",
- "toml_datetime",
+ "serde_spanned 0.6.9",
+ "toml_datetime 0.6.11",
  "winnow 0.5.40",
 ]
 
@@ -5593,10 +5637,19 @@ checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
 dependencies = [
  "indexmap",
  "serde",
- "serde_spanned",
- "toml_datetime",
+ "serde_spanned 0.6.9",
+ "toml_datetime 0.6.11",
  "toml_write",
- "winnow 0.7.12",
+ "winnow 0.7.13",
+]
+
+[[package]]
+name = "toml_parser"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cf893c33be71572e0e9aa6dd15e6677937abd686b066eac3f8cd3531688a627"
+dependencies = [
+ "winnow 0.7.13",
 ]
 
 [[package]]
@@ -5605,6 +5658,12 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801"
 
+[[package]]
+name = "toml_writer"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d163a63c116ce562a22cda521fcc4d79152e7aba014456fb5eb442f6d6a10109"
+
 [[package]]
 name = "tracing"
 version = "0.1.41"
@@ -6569,9 +6628,9 @@ dependencies = [
 
 [[package]]
 name = "winnow"
-version = "0.7.12"
+version = "0.7.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3edebf492c8125044983378ecb5766203ad3b4c2f7a922bd7dd207f6d443e95"
+checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf"
 dependencies = [
  "memchr",
 ]

From e652436f2adbb58f8754a12f8040b5093bd1e039 Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Mon, 6 Oct 2025 18:18:33 +0200
Subject: [PATCH 1762/1889] Allow serde_core as a dependency

---
 src/bootstrap/src/utils/proc_macro_deps.rs | 1 +
 src/tools/tidy/src/deps.rs                 | 1 +
 2 files changed, 2 insertions(+)

diff --git a/src/bootstrap/src/utils/proc_macro_deps.rs b/src/bootstrap/src/utils/proc_macro_deps.rs
index db2369097d6ce..83e5580eaa913 100644
--- a/src/bootstrap/src/utils/proc_macro_deps.rs
+++ b/src/bootstrap/src/utils/proc_macro_deps.rs
@@ -43,6 +43,7 @@ pub static CRATES: &[&str] = &[
     "rustc-hash",
     "self_cell",
     "serde",
+    "serde_core",
     "serde_derive_internals",
     "sha2",
     "smallvec",
diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs
index c76b46ec2bf26..3f40bef821c9d 100644
--- a/src/tools/tidy/src/deps.rs
+++ b/src/tools/tidy/src/deps.rs
@@ -458,6 +458,7 @@ const PERMITTED_RUSTC_DEPENDENCIES: &[&str] = &[
     "scopeguard",
     "self_cell",
     "serde",
+    "serde_core",
     "serde_derive",
     "serde_derive_internals",
     "serde_json",

From d3c3e25674fb132a1c905117e829b016a7d0c3cd Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Tue, 9 Sep 2025 14:23:28 -0700
Subject: [PATCH 1763/1889] rustdoc-search: remove animated throbber

Complaints about it being distracting, and causing people to wait
until all of the results are loaded instead of using the incremental
results as they come in, make me think this is a bad idea.
---
 src/librustdoc/html/static/css/rustdoc.css | 64 ----------------------
 1 file changed, 64 deletions(-)

diff --git a/src/librustdoc/html/static/css/rustdoc.css b/src/librustdoc/html/static/css/rustdoc.css
index 09d289d570c06..a0b3b2de3dbf4 100644
--- a/src/librustdoc/html/static/css/rustdoc.css
+++ b/src/librustdoc/html/static/css/rustdoc.css
@@ -1987,12 +1987,10 @@ a.tooltip:hover::after {
 	color: inherit;
 }
 #search-tabs button:not(.selected) {
-	--search-tab-button-background: var(--search-tab-button-not-selected-background);
 	background-color: var(--search-tab-button-not-selected-background);
 	border-top-color: var(--search-tab-button-not-selected-border-top-color);
 }
 #search-tabs button:hover, #search-tabs button.selected {
-	--search-tab-button-background: var(--search-tab-button-selected-background);
 	background-color: var(--search-tab-button-selected-background);
 	border-top-color: var(--search-tab-button-selected-border-top-color);
 }
@@ -2008,68 +2006,6 @@ a.tooltip:hover::after {
 	color: transparent;
 }
 
-.search-form.loading {
-	--search-tab-button-background: var(--button-background-color);
-}
-
-#search-tabs .count.loading::before,
-.search-form.loading::before
-{
-	width: 16px;
-	height: 16px;
-	border-radius: 16px;
-	background: radial-gradient(
-		var(--search-tab-button-background) 0 50%,
-		transparent 50% 100%
-	), conic-gradient(
-		var(--code-highlight-kw-color) 0deg 30deg,
-		var(--code-highlight-prelude-color) 30deg 60deg,
-		var(--code-highlight-number-color) 90deg 120deg,
-		var(--code-highlight-lifetime-color ) 120deg 150deg,
-		var(--code-highlight-comment-color) 150deg 180deg,
-		var(--code-highlight-self-color) 180deg 210deg,
-		var(--code-highlight-attribute-color) 210deg 240deg,
-		var(--code-highlight-literal-color) 210deg 240deg,
-		var(--code-highlight-macro-color) 240deg 270deg,
-		var(--code-highlight-question-mark-color) 270deg 300deg,
-		var(--code-highlight-prelude-val-color) 300deg 330deg,
-		var(--code-highlight-doc-comment-color) 330deg 360deg
-	);
-	content: "";
-	position: absolute;
-	left: 2px;
-	top: 2px;
-	animation: rotating 1.25s linear infinite;
-}
-#search-tabs .count.loading::after,
-.search-form.loading::after
-{
-	width: 18px;
-	height: 18px;
-	border-radius: 18px;
-	background: conic-gradient(
-		var(--search-tab-button-background) 0deg 180deg,
-		transparent 270deg 360deg
-	);
-	content: "";
-	position: absolute;
-	left: 1px;
-	top: 1px;
-	animation: rotating 0.66s linear infinite;
-}
-
-.search-form.loading::before {
-	left: auto;
-	right: 9px;
-	top: 8px;
-}
-
-.search-form.loading::after {
-	left: auto;
-	right: 8px;
-	top: 8px;
-}
-
 #search .error code {
 	border-radius: 3px;
 	background-color: var(--search-error-code-background-color);

From 2773d24fb701cb17d587289cf75725b5d9bcd328 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Wed, 10 Sep 2025 11:23:40 -0700
Subject: [PATCH 1764/1889] rustdoc-search: put throbber at bottom of search
 results instead

---
 src/librustdoc/html/static/css/rustdoc.css | 52 ++++++++++++++++++++++
 src/librustdoc/html/static/js/search.js    | 19 ++++++--
 2 files changed, 68 insertions(+), 3 deletions(-)

diff --git a/src/librustdoc/html/static/css/rustdoc.css b/src/librustdoc/html/static/css/rustdoc.css
index a0b3b2de3dbf4..d86dc66ab01be 100644
--- a/src/librustdoc/html/static/css/rustdoc.css
+++ b/src/librustdoc/html/static/css/rustdoc.css
@@ -339,6 +339,7 @@ summary.hideme,
 .scraped-example-list,
 .rustdoc-breadcrumbs,
 .search-switcher,
+.search-throbber,
 /* This selector is for the items listed in the "all items" page. */
 ul.all-items {
 	font-family: "Fira Sans", Arial, NanumBarunGothic, sans-serif;
@@ -2006,6 +2007,57 @@ a.tooltip:hover::after {
 	color: transparent;
 }
 
+.search-throbber {
+	position: relative;
+	height: 34px;
+}
+
+.search-throbber::before,
+.search-form.loading::before
+{
+	width: 16px;
+	height: 16px;
+	border-radius: 16px;
+	background: radial-gradient(
+		var(--button-background-color) 0 50%,
+		transparent 50% 100%
+	), conic-gradient(
+		var(--code-highlight-kw-color) 0deg 30deg,
+		var(--code-highlight-prelude-color) 30deg 60deg,
+		var(--code-highlight-number-color) 90deg 120deg,
+		var(--code-highlight-lifetime-color ) 120deg 150deg,
+		var(--code-highlight-comment-color) 150deg 180deg,
+		var(--code-highlight-self-color) 180deg 210deg,
+		var(--code-highlight-attribute-color) 210deg 240deg,
+		var(--code-highlight-literal-color) 210deg 240deg,
+		var(--code-highlight-macro-color) 240deg 270deg,
+		var(--code-highlight-question-mark-color) 270deg 300deg,
+		var(--code-highlight-prelude-val-color) 300deg 330deg,
+		var(--code-highlight-doc-comment-color) 330deg 360deg
+	);
+	content: "";
+	position: absolute;
+	right: 9px;
+	top: 8px;
+	animation: rotating 1.25s linear infinite;
+}
+.search-throbber::after,
+.search-form.loading::after
+{
+	width: 18px;
+	height: 18px;
+	border-radius: 18px;
+	background: conic-gradient(
+		var(--button-background-color) 0deg 180deg,
+		transparent 270deg 360deg
+	);
+	content: "";
+	position: absolute;
+	right: 8px;
+	top: 8px;
+	animation: rotating 0.66s linear infinite;
+}
+
 #search .error code {
 	border-radius: 3px;
 	background-color: var(--search-error-code-background-color);
diff --git a/src/librustdoc/html/static/js/search.js b/src/librustdoc/html/static/js/search.js
index 9a6d4c710ff5d..ba8363b1a9147 100644
--- a/src/librustdoc/html/static/js/search.js
+++ b/src/librustdoc/html/static/js/search.js
@@ -4904,6 +4904,11 @@ async function addTab(results, query, display, finishedCallback, isTypeSearch) {
     let output = document.createElement("ul");
     output.className = "search-results " + extraClass;
 
+    const throbber = document.createElement("div");
+    throbber.className = "search-throbber";
+    throbber.innerHTML = "Loading...";
+    output.appendChild(throbber);
+
     let count = 0;
 
     /** @type {Promise<string|null>[]} */
@@ -5010,7 +5015,7 @@ ${obj.displayPath}<span class="${type}">${name}</span>\
         }
 
         link.appendChild(description);
-        output.appendChild(link);
+        output.insertBefore(link, throbber);
 
         results.next().then(async nextResult => {
             if (nextResult.value) {
@@ -5019,7 +5024,10 @@ ${obj.displayPath}<span class="${type}">${name}</span>\
                 await Promise.all(descList);
                 // need to make sure the element is shown before
                 // running this callback
-                yieldToBrowser().then(() => finishedCallback(count, output));
+                yieldToBrowser().then(() => {
+                    finishedCallback(count, output);
+                    throbber.remove();
+                });
             }
         });
     };
@@ -5215,9 +5223,14 @@ async function showResults(docSearch, results, goToFirst, filterCrates) {
     resultsElem.id = "results";
 
     search.innerHTML = "";
-    for (const [tab, output] of tabs) {
+    for (const [tabNb, [tab, output]] of tabs.entries()) {
         tabsElem.appendChild(tab);
+        const isCurrentTab = window.searchState.currentTab === tabNb;
         const placeholder = document.createElement("div");
+        placeholder.className = isCurrentTab ?
+            "search-throbber search-results active" :
+            "search-throbber search-results";
+        placeholder.innerHTML = "Loading...";
         output.then(output => {
             if (placeholder.parentElement) {
                 placeholder.parentElement.replaceChild(output, placeholder);

From 490fd3ddd24418188dc6e419ed54ac0fa16f2cf4 Mon Sep 17 00:00:00 2001
From: rustbot <47979223+rustbot@users.noreply.github.com>
Date: Mon, 6 Oct 2025 19:01:25 +0200
Subject: [PATCH 1765/1889] Update books

---
 src/doc/reference | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/reference b/src/doc/reference
index e11adf6016a36..8efb980568672 160000
--- a/src/doc/reference
+++ b/src/doc/reference
@@ -1 +1 @@
-Subproject commit e11adf6016a362766eea5a3f9832e193994dd0c8
+Subproject commit 8efb9805686722dba511b7b27281bb6b77d32130

From e0c20a0476ef961121aa6c314a0f1c25870a97e3 Mon Sep 17 00:00:00 2001
From: Urgau <urgau@numericable.fr>
Date: Mon, 6 Oct 2025 19:25:40 +0200
Subject: [PATCH 1766/1889] Update `S-waiting-on-team` refs to new
 `S-waiting-on-{team}` labels

---
 rust-bors.toml | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/rust-bors.toml b/rust-bors.toml
index 56f48512b06a3..1014e31bae49e 100644
--- a/rust-bors.toml
+++ b/rust-bors.toml
@@ -15,5 +15,12 @@ labels_blocking_approval = [
     "S-waiting-on-crater",
     "S-waiting-on-fcp",
     "S-waiting-on-MCP",
-    "S-waiting-on-team"
+    "S-waiting-on-lang",
+    "S-waiting-on-compiler",
+    "S-waiting-on-libs-api",
+    "S-waiting-on-types",
+    "S-waiting-on-opsem",
+    "S-waiting-on-rustdoc",
+    "S-waiting-on-rustdoc-frontend",
+    "S-waiting-on-clippy"
 ]

From 5c31880034def5ce8fc22ded984a875fa39965d3 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Mon, 6 Oct 2025 10:43:37 -0700
Subject: [PATCH 1767/1889] rustdoc-search: use a throbbler with no motion

This change is a response to complaints about motion sickness.
---
 src/librustdoc/html/static/css/rustdoc.css | 48 ++++++----------------
 1 file changed, 13 insertions(+), 35 deletions(-)

diff --git a/src/librustdoc/html/static/css/rustdoc.css b/src/librustdoc/html/static/css/rustdoc.css
index d86dc66ab01be..8078f87756dd2 100644
--- a/src/librustdoc/html/static/css/rustdoc.css
+++ b/src/librustdoc/html/static/css/rustdoc.css
@@ -2012,50 +2012,28 @@ a.tooltip:hover::after {
 	height: 34px;
 }
 
-.search-throbber::before,
-.search-form.loading::before
-{
-	width: 16px;
-	height: 16px;
-	border-radius: 16px;
-	background: radial-gradient(
-		var(--button-background-color) 0 50%,
-		transparent 50% 100%
-	), conic-gradient(
-		var(--code-highlight-kw-color) 0deg 30deg,
-		var(--code-highlight-prelude-color) 30deg 60deg,
-		var(--code-highlight-number-color) 90deg 120deg,
-		var(--code-highlight-lifetime-color ) 120deg 150deg,
-		var(--code-highlight-comment-color) 150deg 180deg,
-		var(--code-highlight-self-color) 180deg 210deg,
-		var(--code-highlight-attribute-color) 210deg 240deg,
-		var(--code-highlight-literal-color) 210deg 240deg,
-		var(--code-highlight-macro-color) 240deg 270deg,
-		var(--code-highlight-question-mark-color) 270deg 300deg,
-		var(--code-highlight-prelude-val-color) 300deg 330deg,
-		var(--code-highlight-doc-comment-color) 330deg 360deg
-	);
-	content: "";
-	position: absolute;
-	right: 9px;
-	top: 8px;
-	animation: rotating 1.25s linear infinite;
-}
 .search-throbber::after,
 .search-form.loading::after
 {
 	width: 18px;
 	height: 18px;
 	border-radius: 18px;
-	background: conic-gradient(
-		var(--button-background-color) 0deg 180deg,
-		transparent 270deg 360deg
-	);
-	content: "";
+	/* hourglass */
+	content: url('data:image/svg+xml,\
+	<svg width="16" height="16" viewBox="0 0 8 8" xmlns="http://www.w3.org/2000/svg">\
+		<g fill="none">\
+			<path d="m3.019 1.496v1.496l0.5878 1.018-0.5751 0.996v1.494" stroke="%233f3f3f"/>\
+			<path d="m5.003 1.496v1.496l-0.5878 1.018 0.5751 0.996v1.494" stroke="%233f3f3f"/>\
+			<path d="m2.006 1.5h3.978" stroke="%23000"/>\
+			<path d="m2.006 6.49h3.993" stroke="%23000"/>\
+		</g>\
+		<path d="m4.005 5.301-0.3987 0.6905h0.7977z" fill="%237f7f7f"/>\
+		<path d="m4.011 3.712-0.3987-0.6905h0.7977z" fill="%237f7f7f"/>\
+	</svg>');
 	position: absolute;
 	right: 8px;
 	top: 8px;
-	animation: rotating 0.66s linear infinite;
+	filter: var(--settings-menu-filter);
 }
 
 #search .error code {

From 02126adc1b8d0b61ddaec2adb9c0d2c9dddcd493 Mon Sep 17 00:00:00 2001
From: reddevilmidzy <midzy0228@gmail.com>
Date: Mon, 6 Oct 2025 19:03:48 +0900
Subject: [PATCH 1768/1889] Improve diagnostics: replace 'non-inline module'
 with 'file module' and update note/help messages

---
 compiler/rustc_expand/messages.ftl                     |  5 +++--
 compiler/rustc_expand/src/errors.rs                    |  3 ++-
 tests/ui/directory_ownership/file-mod-restriction.rs   |  5 +++++
 .../ui/directory_ownership/file-mod-restriction.stderr | 10 ++++++++++
 tests/ui/directory_ownership/macro-expanded-mod.rs     |  4 ++--
 tests/ui/directory_ownership/macro-expanded-mod.stderr |  3 ++-
 .../directory_ownership/non-inline-mod-restriction.rs  |  5 -----
 .../non-inline-mod-restriction.stderr                  |  8 --------
 8 files changed, 24 insertions(+), 19 deletions(-)
 create mode 100644 tests/ui/directory_ownership/file-mod-restriction.rs
 create mode 100644 tests/ui/directory_ownership/file-mod-restriction.stderr
 delete mode 100644 tests/ui/directory_ownership/non-inline-mod-restriction.rs
 delete mode 100644 tests/ui/directory_ownership/non-inline-mod-restriction.stderr

diff --git a/compiler/rustc_expand/messages.ftl b/compiler/rustc_expand/messages.ftl
index 47c00bff5c950..7c2c9002a32c4 100644
--- a/compiler/rustc_expand/messages.ftl
+++ b/compiler/rustc_expand/messages.ftl
@@ -118,8 +118,9 @@ expand_module_file_not_found =
     .note = if there is a `mod {$name}` elsewhere in the crate already, import it with `use crate::...` instead
 
 expand_module_in_block =
-    cannot declare a non-inline module inside a block unless it has a path attribute
-    .note = maybe `use` the module `{$name}` instead of redeclaring it
+    cannot declare a file module inside a block unless it has a path attribute
+    .help = maybe `use` the module `{$name}` instead of redeclaring it
+    .note = file modules are usually placed outside of blocks, at the top level of the file
 
 expand_module_multiple_candidates =
     file for module `{$name}` found at both "{$default_path}" and "{$secondary_path}"
diff --git a/compiler/rustc_expand/src/errors.rs b/compiler/rustc_expand/src/errors.rs
index c37c2d88d9cd2..6bae16b3bba15 100644
--- a/compiler/rustc_expand/src/errors.rs
+++ b/compiler/rustc_expand/src/errors.rs
@@ -265,6 +265,7 @@ pub(crate) struct ModuleCircular {
 
 #[derive(Diagnostic)]
 #[diag(expand_module_in_block)]
+#[note]
 pub(crate) struct ModuleInBlock {
     #[primary_span]
     pub span: Span,
@@ -273,7 +274,7 @@ pub(crate) struct ModuleInBlock {
 }
 
 #[derive(Subdiagnostic)]
-#[note(expand_note)]
+#[help(expand_help)]
 pub(crate) struct ModuleInBlockName {
     #[primary_span]
     pub span: Span,
diff --git a/tests/ui/directory_ownership/file-mod-restriction.rs b/tests/ui/directory_ownership/file-mod-restriction.rs
new file mode 100644
index 0000000000000..cff876941dbc8
--- /dev/null
+++ b/tests/ui/directory_ownership/file-mod-restriction.rs
@@ -0,0 +1,5 @@
+// Test that file modules are not allowed inside blocks.
+
+fn main() {
+    mod foo; //~ ERROR cannot declare a file module inside a block unless it has a path attribute
+}
diff --git a/tests/ui/directory_ownership/file-mod-restriction.stderr b/tests/ui/directory_ownership/file-mod-restriction.stderr
new file mode 100644
index 0000000000000..4c1ff777f37fd
--- /dev/null
+++ b/tests/ui/directory_ownership/file-mod-restriction.stderr
@@ -0,0 +1,10 @@
+error: cannot declare a file module inside a block unless it has a path attribute
+  --> $DIR/file-mod-restriction.rs:4:5
+   |
+LL |     mod foo;
+   |     ^^^^^^^^
+   |
+   = note: file modules are usually placed outside of blocks, at the top level of the file
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/directory_ownership/macro-expanded-mod.rs b/tests/ui/directory_ownership/macro-expanded-mod.rs
index fa81769e5a800..1495764a9d8cb 100644
--- a/tests/ui/directory_ownership/macro-expanded-mod.rs
+++ b/tests/ui/directory_ownership/macro-expanded-mod.rs
@@ -1,8 +1,8 @@
-// Test that macro-expanded non-inline modules behave correctly
+// Test that macro-expanded file modules behave correctly
 
 macro_rules! mod_decl {
     ($i:ident) => {
-        mod $i; //~ ERROR cannot declare a non-inline module inside a block
+        mod $i; //~ ERROR cannot declare a file module inside a block unless it has a path attribute
     };
 }
 
diff --git a/tests/ui/directory_ownership/macro-expanded-mod.stderr b/tests/ui/directory_ownership/macro-expanded-mod.stderr
index 2cacd52b94ef6..cb00a3fe60823 100644
--- a/tests/ui/directory_ownership/macro-expanded-mod.stderr
+++ b/tests/ui/directory_ownership/macro-expanded-mod.stderr
@@ -1,4 +1,4 @@
-error: cannot declare a non-inline module inside a block unless it has a path attribute
+error: cannot declare a file module inside a block unless it has a path attribute
   --> $DIR/macro-expanded-mod.rs:5:9
    |
 LL |         mod $i;
@@ -7,6 +7,7 @@ LL |         mod $i;
 LL |     mod_decl!(foo);
    |     -------------- in this macro invocation
    |
+   = note: file modules are usually placed outside of blocks, at the top level of the file
    = note: this error originates in the macro `mod_decl` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/directory_ownership/non-inline-mod-restriction.rs b/tests/ui/directory_ownership/non-inline-mod-restriction.rs
deleted file mode 100644
index de4f816656cc4..0000000000000
--- a/tests/ui/directory_ownership/non-inline-mod-restriction.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-// Test that non-inline modules are not allowed inside blocks.
-
-fn main() {
-    mod foo; //~ ERROR cannot declare a non-inline module inside a block
-}
diff --git a/tests/ui/directory_ownership/non-inline-mod-restriction.stderr b/tests/ui/directory_ownership/non-inline-mod-restriction.stderr
deleted file mode 100644
index 882c8652520b0..0000000000000
--- a/tests/ui/directory_ownership/non-inline-mod-restriction.stderr
+++ /dev/null
@@ -1,8 +0,0 @@
-error: cannot declare a non-inline module inside a block unless it has a path attribute
-  --> $DIR/non-inline-mod-restriction.rs:4:5
-   |
-LL |     mod foo;
-   |     ^^^^^^^^
-
-error: aborting due to 1 previous error
-

From fc959e54646c956dda36d65c3f2e9a9dad01ecc4 Mon Sep 17 00:00:00 2001
From: beepster4096 <19316085+beepster4096@users.noreply.github.com>
Date: Wed, 13 Aug 2025 02:09:20 -0700
Subject: [PATCH 1769/1889] remove DerefTemp and CopyFromDeref from runtime mir

---
 compiler/rustc_borrowck/src/lib.rs            | 20 +------
 .../src/polonius/legacy/loan_invalidations.rs |  7 +--
 compiler/rustc_codegen_cranelift/src/base.rs  |  6 +-
 compiler/rustc_codegen_ssa/src/mir/rvalue.rs  |  4 +-
 .../src/check_consts/qualifs.rs               |  2 +-
 .../rustc_const_eval/src/interpret/step.rs    |  5 +-
 compiler/rustc_middle/src/mir/mod.rs          |  6 +-
 compiler/rustc_middle/src/mir/syntax.rs       |  8 ++-
 compiler/rustc_mir_transform/src/copy_prop.rs |  9 +--
 .../src/dataflow_const_prop.rs                | 11 +---
 compiler/rustc_mir_transform/src/dest_prop.rs |  5 +-
 .../src/erase_deref_temps.rs                  | 41 ++++++++++++++
 compiler/rustc_mir_transform/src/gvn.rs       |  7 +--
 .../rustc_mir_transform/src/jump_threading.rs |  1 -
 compiler/rustc_mir_transform/src/lib.rs       |  2 +
 compiler/rustc_mir_transform/src/ref_prop.rs  |  3 +-
 .../src/shim/async_destructor_ctor.rs         |  8 +--
 compiler/rustc_mir_transform/src/ssa.rs       |  4 +-
 compiler/rustc_mir_transform/src/validate.rs  | 55 ++++++++++++++++---
 19 files changed, 122 insertions(+), 82 deletions(-)
 create mode 100644 compiler/rustc_mir_transform/src/erase_deref_temps.rs

diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs
index a85dcf64d8d46..f05d34e47f8f8 100644
--- a/compiler/rustc_borrowck/src/lib.rs
+++ b/compiler/rustc_borrowck/src/lib.rs
@@ -1539,24 +1539,6 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                 self.consume_operand(location, (operand, span), state)
             }
 
-            &Rvalue::CopyForDeref(place) => {
-                self.access_place(
-                    location,
-                    (place, span),
-                    (Deep, Read(ReadKind::Copy)),
-                    LocalMutationIsAllowed::No,
-                    state,
-                );
-
-                // Finally, check if path was already moved.
-                self.check_if_path_or_subpath_is_moved(
-                    location,
-                    InitializationRequiringAction::Use,
-                    (place.as_ref(), span),
-                    state,
-                );
-            }
-
             &Rvalue::Discriminant(place) => {
                 let af = match *rvalue {
                     Rvalue::Discriminant(..) => None,
@@ -1618,6 +1600,8 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
             Rvalue::WrapUnsafeBinder(op, _) => {
                 self.consume_operand(location, (op, span), state);
             }
+
+            Rvalue::CopyForDeref(_) => bug!("`CopyForDeref` in borrowck"),
         }
     }
 
diff --git a/compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs b/compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs
index c2ad6fcb4b799..ebc9390914d61 100644
--- a/compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs
+++ b/compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs
@@ -301,11 +301,6 @@ impl<'a, 'tcx> LoanInvalidationsGenerator<'a, 'tcx> {
             | Rvalue::Cast(_ /*cast_kind*/, operand, _ /*ty*/)
             | Rvalue::ShallowInitBox(operand, _ /*ty*/) => self.consume_operand(location, operand),
 
-            &Rvalue::CopyForDeref(place) => {
-                let op = &Operand::Copy(place);
-                self.consume_operand(location, op);
-            }
-
             &Rvalue::Discriminant(place) => {
                 self.access_place(
                     location,
@@ -331,6 +326,8 @@ impl<'a, 'tcx> LoanInvalidationsGenerator<'a, 'tcx> {
             Rvalue::WrapUnsafeBinder(op, _) => {
                 self.consume_operand(location, op);
             }
+
+            Rvalue::CopyForDeref(_) => bug!("`CopyForDeref` in borrowck"),
         }
     }
 
diff --git a/compiler/rustc_codegen_cranelift/src/base.rs b/compiler/rustc_codegen_cranelift/src/base.rs
index ebf2ccf74de20..a529692c0743c 100644
--- a/compiler/rustc_codegen_cranelift/src/base.rs
+++ b/compiler/rustc_codegen_cranelift/src/base.rs
@@ -600,11 +600,6 @@ fn codegen_stmt<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, cur_block: Block, stmt:
                     let val = codegen_operand(fx, operand);
                     lval.write_cvalue(fx, val);
                 }
-                Rvalue::CopyForDeref(place) => {
-                    let cplace = codegen_place(fx, place);
-                    let val = cplace.to_cvalue(fx);
-                    lval.write_cvalue(fx, val)
-                }
                 Rvalue::Ref(_, _, place) | Rvalue::RawPtr(_, place) => {
                     let place = codegen_place(fx, place);
                     let ref_ = place.place_ref(fx, lval.layout());
@@ -928,6 +923,7 @@ fn codegen_stmt<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, cur_block: Block, stmt:
                     let operand = codegen_operand(fx, operand);
                     lval.write_cvalue_transmute(fx, operand);
                 }
+                Rvalue::CopyForDeref(_) => bug!("`CopyForDeref` in codegen"),
             }
         }
         StatementKind::StorageLive(_)
diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
index d629003bff5e8..86b5dea6c53fc 100644
--- a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -504,9 +504,6 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 self.codegen_place_to_pointer(bx, place, mk_ref)
             }
 
-            mir::Rvalue::CopyForDeref(place) => {
-                self.codegen_operand(bx, &mir::Operand::Copy(place))
-            }
             mir::Rvalue::RawPtr(kind, place) => {
                 let mk_ptr = move |tcx: TyCtxt<'tcx>, ty: Ty<'tcx>| {
                     Ty::new_ptr(tcx, ty, kind.to_mutbl_lossy())
@@ -742,6 +739,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 let layout = bx.cx().layout_of(binder_ty);
                 OperandRef { val: operand.val, layout }
             }
+            mir::Rvalue::CopyForDeref(_) => bug!("`CopyForDeref` in codegen"),
         }
     }
 
diff --git a/compiler/rustc_const_eval/src/check_consts/qualifs.rs b/compiler/rustc_const_eval/src/check_consts/qualifs.rs
index 8a6827bca2bd6..2cb87c2fad71d 100644
--- a/compiler/rustc_const_eval/src/check_consts/qualifs.rs
+++ b/compiler/rustc_const_eval/src/check_consts/qualifs.rs
@@ -234,7 +234,7 @@ where
 
         Rvalue::Discriminant(place) => in_place::<Q, _>(cx, in_local, place.as_ref()),
 
-        Rvalue::CopyForDeref(place) => in_place::<Q, _>(cx, in_local, place.as_ref()),
+        Rvalue::CopyForDeref(_) => bug!("`CopyForDeref` in runtime MIR"),
 
         Rvalue::Use(operand)
         | Rvalue::Repeat(operand, _)
diff --git a/compiler/rustc_const_eval/src/interpret/step.rs b/compiler/rustc_const_eval/src/interpret/step.rs
index 923e00ad4cf1a..e12eebb74a36a 100644
--- a/compiler/rustc_const_eval/src/interpret/step.rs
+++ b/compiler/rustc_const_eval/src/interpret/step.rs
@@ -188,10 +188,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 self.copy_op(&op, &dest)?;
             }
 
-            CopyForDeref(place) => {
-                let op = self.eval_place_to_op(place, Some(dest.layout))?;
-                self.copy_op(&op, &dest)?;
-            }
+            CopyForDeref(_) => bug!("`CopyForDeref` in runtime MIR"),
 
             BinaryOp(bin_op, box (ref left, ref right)) => {
                 let layout = util::binop_left_homogeneous(bin_op).then_some(dest.layout);
diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs
index 8eb7aa71fcdea..8eae8da4f44f8 100644
--- a/compiler/rustc_middle/src/mir/mod.rs
+++ b/compiler/rustc_middle/src/mir/mod.rs
@@ -1065,7 +1065,11 @@ pub enum LocalInfo<'tcx> {
     /// A temporary created during evaluating `if` predicate, possibly for pattern matching for `let`s,
     /// and subject to Edition 2024 temporary lifetime rules
     IfThenRescopeTemp { if_then: HirId },
-    /// A temporary created during the pass `Derefer` to avoid it's retagging
+    /// A temporary created during the pass `Derefer` treated as a transparent alias
+    /// for the place its copied from by analysis passes such as `AddRetag` and `ElaborateDrops`.
+    ///
+    /// It may only be written to by a `CopyForDeref` and otherwise only accessed through a deref.
+    /// In runtime MIR, it is replaced with a normal `Boring` local.
     DerefTemp,
     /// A temporary created for borrow checking.
     FakeBorrow,
diff --git a/compiler/rustc_middle/src/mir/syntax.rs b/compiler/rustc_middle/src/mir/syntax.rs
index a823c365394f7..0e66824299079 100644
--- a/compiler/rustc_middle/src/mir/syntax.rs
+++ b/compiler/rustc_middle/src/mir/syntax.rs
@@ -130,7 +130,9 @@ pub enum RuntimePhase {
     /// * [`TerminatorKind::Yield`]
     /// * [`TerminatorKind::CoroutineDrop`]
     /// * [`Rvalue::Aggregate`] for any `AggregateKind` except `Array`
+    /// * [`Rvalue::CopyForDeref`]
     /// * [`PlaceElem::OpaqueCast`]
+    /// * [`LocalInfo::DerefTemp`](super::LocalInfo::DerefTemp)
     ///
     /// And the following variants are allowed:
     /// * [`StatementKind::Retag`]
@@ -1460,11 +1462,13 @@ pub enum Rvalue<'tcx> {
     /// A CopyForDeref is equivalent to a read from a place at the
     /// codegen level, but is treated specially by drop elaboration. When such a read happens, it
     /// is guaranteed (via nature of the mir_opt `Derefer` in rustc_mir_transform/src/deref_separator)
-    /// that the only use of the returned value is a deref operation, immediately
-    /// followed by one or more projections. Drop elaboration treats this rvalue as if the
+    /// that the returned value is written into a `DerefTemp` local and that its only use is a deref operation,
+    /// immediately followed by one or more projections. Drop elaboration treats this rvalue as if the
     /// read never happened and just projects further. This allows simplifying various MIR
     /// optimizations and codegen backends that previously had to handle deref operations anywhere
     /// in a place.
+    ///
+    /// Disallowed in runtime MIR and is replaced by normal copies.
     CopyForDeref(Place<'tcx>),
 
     /// Wraps a value in an unsafe binder.
diff --git a/compiler/rustc_mir_transform/src/copy_prop.rs b/compiler/rustc_mir_transform/src/copy_prop.rs
index f0bc286a94022..2e9c3a5bf3eeb 100644
--- a/compiler/rustc_mir_transform/src/copy_prop.rs
+++ b/compiler/rustc_mir_transform/src/copy_prop.rs
@@ -74,9 +74,7 @@ fn fully_moved_locals(ssa: &SsaLocals, body: &Body<'_>) -> DenseBitSet<Local> {
     let mut fully_moved = DenseBitSet::new_filled(body.local_decls.len());
 
     for (_, rvalue, _) in ssa.assignments(body) {
-        let (Rvalue::Use(Operand::Copy(place) | Operand::Move(place))
-        | Rvalue::CopyForDeref(place)) = rvalue
-        else {
+        let Rvalue::Use(Operand::Copy(place) | Operand::Move(place)) = rvalue else {
             continue;
         };
 
@@ -85,7 +83,7 @@ fn fully_moved_locals(ssa: &SsaLocals, body: &Body<'_>) -> DenseBitSet<Local> {
             continue;
         }
 
-        if let Rvalue::Use(Operand::Copy(_)) | Rvalue::CopyForDeref(_) = rvalue {
+        if let Rvalue::Use(Operand::Copy(_)) = rvalue {
             fully_moved.remove(rhs);
         }
     }
@@ -146,8 +144,7 @@ impl<'tcx> MutVisitor<'tcx> for Replacer<'_, 'tcx> {
 
         // Do not leave tautological assignments around.
         if let StatementKind::Assign(box (lhs, ref rhs)) = stmt.kind
-            && let Rvalue::Use(Operand::Copy(rhs) | Operand::Move(rhs)) | Rvalue::CopyForDeref(rhs) =
-                *rhs
+            && let Rvalue::Use(Operand::Copy(rhs) | Operand::Move(rhs)) = *rhs
             && lhs == rhs
         {
             stmt.make_nop(true);
diff --git a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
index e970f7ff81adb..8e3ec33e53bb6 100644
--- a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
+++ b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
@@ -309,12 +309,7 @@ impl<'a, 'tcx> ConstAnalysis<'a, 'tcx> {
                     self.assign_operand(state, target, operand);
                 }
             }
-            Rvalue::CopyForDeref(rhs) => {
-                state.flood(target.as_ref(), &self.map);
-                if let Some(target) = self.map.find(target.as_ref()) {
-                    self.assign_operand(state, target, &Operand::Copy(*rhs));
-                }
-            }
+            Rvalue::CopyForDeref(_) => bug!("`CopyForDeref` in runtime MIR"),
             Rvalue::Aggregate(kind, operands) => {
                 // If we assign `target = Enum::Variant#0(operand)`,
                 // we must make sure that all `target as Variant#i` are `Top`.
@@ -488,9 +483,7 @@ impl<'a, 'tcx> ConstAnalysis<'a, 'tcx> {
             }
             Rvalue::Discriminant(place) => state.get_discr(place.as_ref(), &self.map),
             Rvalue::Use(operand) => return self.handle_operand(operand, state),
-            Rvalue::CopyForDeref(place) => {
-                return self.handle_operand(&Operand::Copy(*place), state);
-            }
+            Rvalue::CopyForDeref(_) => bug!("`CopyForDeref` in runtime MIR"),
             Rvalue::Ref(..) | Rvalue::RawPtr(..) => {
                 // We don't track such places.
                 return ValueOrPlace::TOP;
diff --git a/compiler/rustc_mir_transform/src/dest_prop.rs b/compiler/rustc_mir_transform/src/dest_prop.rs
index 1f38433fa5a41..ed52c60f3deb2 100644
--- a/compiler/rustc_mir_transform/src/dest_prop.rs
+++ b/compiler/rustc_mir_transform/src/dest_prop.rs
@@ -285,8 +285,7 @@ impl<'tcx> MutVisitor<'tcx> for Merger<'tcx> {
         match &statement.kind {
             StatementKind::Assign(box (dest, rvalue)) => {
                 match rvalue {
-                    Rvalue::CopyForDeref(place)
-                    | Rvalue::Use(Operand::Copy(place) | Operand::Move(place)) => {
+                    Rvalue::Use(Operand::Copy(place) | Operand::Move(place)) => {
                         // These might've been turned into self-assignments by the replacement
                         // (this includes the original statement we wanted to eliminate).
                         if dest == place {
@@ -400,7 +399,7 @@ impl<'tcx> Visitor<'tcx> for FindAssignments<'_, 'tcx> {
     fn visit_statement(&mut self, statement: &Statement<'tcx>, _: Location) {
         if let StatementKind::Assign(box (
             lhs,
-            Rvalue::CopyForDeref(rhs) | Rvalue::Use(Operand::Copy(rhs) | Operand::Move(rhs)),
+            Rvalue::Use(Operand::Copy(rhs) | Operand::Move(rhs)),
         )) = &statement.kind
             && let Some(src) = lhs.as_local()
             && let Some(dest) = rhs.as_local()
diff --git a/compiler/rustc_mir_transform/src/erase_deref_temps.rs b/compiler/rustc_mir_transform/src/erase_deref_temps.rs
new file mode 100644
index 0000000000000..ee0c7715c3cb5
--- /dev/null
+++ b/compiler/rustc_mir_transform/src/erase_deref_temps.rs
@@ -0,0 +1,41 @@
+//! This pass converts all `DerefTemp` locals into normal temporaries
+//! and turns their `CopyForDeref` rvalues into normal copies.
+
+use rustc_middle::mir::visit::MutVisitor;
+use rustc_middle::mir::*;
+use rustc_middle::ty::TyCtxt;
+
+struct EraseDerefTempsVisitor<'tcx> {
+    tcx: TyCtxt<'tcx>,
+}
+
+impl<'tcx> MutVisitor<'tcx> for EraseDerefTempsVisitor<'tcx> {
+    fn tcx(&self) -> TyCtxt<'tcx> {
+        self.tcx
+    }
+
+    fn visit_rvalue(&mut self, rvalue: &mut Rvalue<'tcx>, _: Location) {
+        if let &mut Rvalue::CopyForDeref(place) = rvalue {
+            *rvalue = Rvalue::Use(Operand::Copy(place))
+        }
+    }
+
+    fn visit_local_decl(&mut self, _: Local, local_decl: &mut LocalDecl<'tcx>) {
+        if local_decl.is_deref_temp() {
+            let info = local_decl.local_info.as_mut().unwrap_crate_local();
+            **info = LocalInfo::Boring;
+        }
+    }
+}
+
+pub(super) struct EraseDerefTemps;
+
+impl<'tcx> crate::MirPass<'tcx> for EraseDerefTemps {
+    fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
+        EraseDerefTempsVisitor { tcx }.visit_body_preserves_cfg(body);
+    }
+
+    fn is_required(&self) -> bool {
+        true
+    }
+}
diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index 3ff8dc6dbb378..8280b16f7c910 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -939,12 +939,6 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
         let value = match *rvalue {
             // Forward values.
             Rvalue::Use(ref mut operand) => return self.simplify_operand(operand, location),
-            Rvalue::CopyForDeref(place) => {
-                let mut operand = Operand::Copy(place);
-                let val = self.simplify_operand(&mut operand, location);
-                *rvalue = Rvalue::Use(operand);
-                return val;
-            }
 
             // Roots.
             Rvalue::Repeat(ref mut op, amount) => {
@@ -986,6 +980,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
 
             // Unsupported values.
             Rvalue::ThreadLocalRef(..) | Rvalue::ShallowInitBox(..) => return None,
+            Rvalue::CopyForDeref(_) => bug!("`CopyForDeref` in runtime MIR"),
         };
         let ty = rvalue.ty(self.local_decls, self.tcx);
         Some(self.insert(ty, value))
diff --git a/compiler/rustc_mir_transform/src/jump_threading.rs b/compiler/rustc_mir_transform/src/jump_threading.rs
index 68298767e7fd8..58ca8dbc8cc74 100644
--- a/compiler/rustc_mir_transform/src/jump_threading.rs
+++ b/compiler/rustc_mir_transform/src/jump_threading.rs
@@ -455,7 +455,6 @@ impl<'a, 'tcx> TOFinder<'a, 'tcx> {
         match rhs {
             Rvalue::Use(operand) => self.process_operand(bb, lhs, operand, state),
             // Transfer the conditions on the copy rhs.
-            Rvalue::CopyForDeref(rhs) => self.process_operand(bb, lhs, &Operand::Copy(*rhs), state),
             Rvalue::Discriminant(rhs) => {
                 let Some(rhs) = self.map.find_discr(rhs.as_ref()) else { return };
                 state.insert_place_idx(rhs, lhs, &self.map);
diff --git a/compiler/rustc_mir_transform/src/lib.rs b/compiler/rustc_mir_transform/src/lib.rs
index 9ff7e0b550030..fbf78a1431ffc 100644
--- a/compiler/rustc_mir_transform/src/lib.rs
+++ b/compiler/rustc_mir_transform/src/lib.rs
@@ -139,6 +139,7 @@ declare_passes! {
     mod dest_prop : DestinationPropagation;
     pub mod dump_mir : Marker;
     mod early_otherwise_branch : EarlyOtherwiseBranch;
+    mod erase_deref_temps : EraseDerefTemps;
     mod elaborate_box_derefs : ElaborateBoxDerefs;
     mod elaborate_drops : ElaborateDrops;
     mod function_item_references : FunctionItemReferences;
@@ -619,6 +620,7 @@ fn run_runtime_lowering_passes<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
         // `AddRetag` needs to run after `ElaborateDrops` but before `ElaborateBoxDerefs`.
         // Otherwise it should run fairly late, but before optimizations begin.
         &add_retag::AddRetag,
+        &erase_deref_temps::EraseDerefTemps,
         &elaborate_box_derefs::ElaborateBoxDerefs,
         &coroutine::StateTransform,
         &Lint(known_panics_lint::KnownPanicsLint),
diff --git a/compiler/rustc_mir_transform/src/ref_prop.rs b/compiler/rustc_mir_transform/src/ref_prop.rs
index deb0a146476c3..2ba4df906b742 100644
--- a/compiler/rustc_mir_transform/src/ref_prop.rs
+++ b/compiler/rustc_mir_transform/src/ref_prop.rs
@@ -247,8 +247,7 @@ fn compute_replacement<'tcx>(
             // This is a copy, just use the value we have in store for the previous one.
             // As we are visiting in `assignment_order`, ie. reverse postorder, `rhs` should
             // have been visited before.
-            Rvalue::Use(Operand::Copy(place) | Operand::Move(place))
-            | Rvalue::CopyForDeref(place) => {
+            Rvalue::Use(Operand::Copy(place) | Operand::Move(place)) => {
                 if let Some(rhs) = place.as_local()
                     && ssa.is_ssa(rhs)
                 {
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 18d09473c191e..a0f1260cd986d 100644
--- a/compiler/rustc_mir_transform/src/shim/async_destructor_ctor.rs
+++ b/compiler/rustc_mir_transform/src/shim/async_destructor_ctor.rs
@@ -240,7 +240,7 @@ fn build_adrop_for_coroutine_shim<'tcx>(
                 source_info,
                 StatementKind::Assign(Box::new((
                     Place::from(proxy_ref_local),
-                    Rvalue::CopyForDeref(proxy_ref_place),
+                    Rvalue::Use(Operand::Copy(proxy_ref_place)),
                 ))),
             ),
         );
@@ -261,7 +261,7 @@ fn build_adrop_for_coroutine_shim<'tcx>(
                         source_info,
                         StatementKind::Assign(Box::new((
                             Place::from(cor_ptr_local),
-                            Rvalue::CopyForDeref(impl_ptr_place),
+                            Rvalue::Use(Operand::Copy(impl_ptr_place)),
                         ))),
                     ),
                 );
@@ -334,7 +334,7 @@ fn build_adrop_for_adrop_shim<'tcx>(
         source_info,
         StatementKind::Assign(Box::new((
             Place::from(proxy_ref_local),
-            Rvalue::CopyForDeref(proxy_ref_place),
+            Rvalue::Use(Operand::Copy(proxy_ref_place)),
         ))),
     ));
 
@@ -350,7 +350,7 @@ fn build_adrop_for_adrop_shim<'tcx>(
                 source_info,
                 StatementKind::Assign(Box::new((
                     Place::from(cor_ptr_local),
-                    Rvalue::CopyForDeref(impl_ptr_place),
+                    Rvalue::Use(Operand::Copy(impl_ptr_place)),
                 ))),
             ));
         }
diff --git a/compiler/rustc_mir_transform/src/ssa.rs b/compiler/rustc_mir_transform/src/ssa.rs
index 73c249a3c8cdb..a56f04cf48422 100644
--- a/compiler/rustc_mir_transform/src/ssa.rs
+++ b/compiler/rustc_mir_transform/src/ssa.rs
@@ -297,9 +297,7 @@ fn compute_copy_classes(ssa: &mut SsaLocals, body: &Body<'_>) {
     let mut copies = IndexVec::from_fn_n(|l| l, body.local_decls.len());
 
     for (local, rvalue, _) in ssa.assignments(body) {
-        let (Rvalue::Use(Operand::Copy(place) | Operand::Move(place))
-        | Rvalue::CopyForDeref(place)) = rvalue
-        else {
+        let Rvalue::Use(Operand::Copy(place) | Operand::Move(place)) = rvalue else {
             continue;
         };
 
diff --git a/compiler/rustc_mir_transform/src/validate.rs b/compiler/rustc_mir_transform/src/validate.rs
index cbabb982df8b8..6a4c19dbd87c3 100644
--- a/compiler/rustc_mir_transform/src/validate.rs
+++ b/compiler/rustc_mir_transform/src/validate.rs
@@ -9,7 +9,7 @@ use rustc_index::bit_set::DenseBitSet;
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_infer::traits::{Obligation, ObligationCause};
 use rustc_middle::mir::coverage::CoverageKind;
-use rustc_middle::mir::visit::{NonUseContext, PlaceContext, Visitor};
+use rustc_middle::mir::visit::{MutatingUseContext, NonUseContext, PlaceContext, Visitor};
 use rustc_middle::mir::*;
 use rustc_middle::ty::adjustment::PointerCoercion;
 use rustc_middle::ty::print::with_no_trimmed_paths;
@@ -906,6 +906,20 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
             }
         }
 
+        if let ClearCrossCrate::Set(box LocalInfo::DerefTemp) =
+            self.body.local_decls[place.local].local_info
+            && !place.is_indirect_first_projection()
+        {
+            if cntxt != PlaceContext::MutatingUse(MutatingUseContext::Store)
+                || place.as_local().is_none()
+            {
+                self.fail(
+                    location,
+                    format!("`DerefTemp` locals must only be dereferenced or directly assigned to"),
+                );
+            }
+        }
+
         self.super_place(place, cntxt, location);
     }
 
@@ -918,7 +932,12 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
             };
         }
         match rvalue {
-            Rvalue::Use(_) | Rvalue::CopyForDeref(_) => {}
+            Rvalue::Use(_) => {}
+            Rvalue::CopyForDeref(_) => {
+                if self.body.phase >= MirPhase::Runtime(RuntimePhase::Initial) {
+                    self.fail(location, "`CopyForDeref` should have been removed in runtime MIR");
+                }
+            }
             Rvalue::Aggregate(kind, fields) => match **kind {
                 AggregateKind::Tuple => {}
                 AggregateKind::Array(dest) => {
@@ -1416,13 +1435,13 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                         ),
                     );
                 }
-                if let Rvalue::CopyForDeref(place) = rvalue {
-                    if place.ty(&self.body.local_decls, self.tcx).ty.builtin_deref(true).is_none() {
-                        self.fail(
-                            location,
-                            "`CopyForDeref` should only be used for dereferenceable types",
-                        )
-                    }
+
+                if let Some(local) = dest.as_local()
+                    && let ClearCrossCrate::Set(box LocalInfo::DerefTemp) =
+                        self.body.local_decls[local].local_info
+                    && !matches!(rvalue, Rvalue::CopyForDeref(_))
+                {
+                    self.fail(location, "assignment to a `DerefTemp` must use `CopyForDeref`")
                 }
             }
             StatementKind::AscribeUserType(..) => {
@@ -1594,4 +1613,22 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
 
         self.super_terminator(terminator, location);
     }
+
+    fn visit_local_decl(&mut self, local: Local, local_decl: &LocalDecl<'tcx>) {
+        if let ClearCrossCrate::Set(box LocalInfo::DerefTemp) = local_decl.local_info {
+            if self.body.phase >= MirPhase::Runtime(RuntimePhase::Initial) {
+                self.fail(
+                    START_BLOCK.start_location(),
+                    "`DerefTemp` should have been removed in runtime MIR",
+                );
+            } else if local_decl.ty.builtin_deref(true).is_none() {
+                self.fail(
+                    START_BLOCK.start_location(),
+                    "`DerefTemp` should only be used for dereferenceable types",
+                )
+            }
+        }
+
+        self.super_local_decl(local, local_decl);
+    }
 }

From a0e9cb7cb4388c2ed587d0ebc0265e4c8b682df7 Mon Sep 17 00:00:00 2001
From: beepster4096 <19316085+beepster4096@users.noreply.github.com>
Date: Wed, 13 Aug 2025 16:34:04 -0700
Subject: [PATCH 1770/1889] erase coroutine shim dereftemps

---
 compiler/rustc_mir_transform/src/coroutine.rs |  8 +++----
 .../src/deref_separator.rs                    | 24 +++++++++++++++----
 .../src/elaborate_drops.rs                    |  2 +-
 compiler/rustc_mir_transform/src/inline.rs    |  4 ++--
 compiler/rustc_mir_transform/src/shim.rs      | 10 ++++----
 5 files changed, 32 insertions(+), 16 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/coroutine.rs b/compiler/rustc_mir_transform/src/coroutine.rs
index 814eded910df5..2192fd0c53ab6 100644
--- a/compiler/rustc_mir_transform/src/coroutine.rs
+++ b/compiler/rustc_mir_transform/src/coroutine.rs
@@ -1625,19 +1625,19 @@ impl<'tcx> crate::MirPass<'tcx> for StateTransform {
             let mut drop_shim =
                 create_coroutine_drop_shim_async(tcx, &transform, body, drop_clean, can_unwind);
             // Run derefer to fix Derefs that are not in the first place
-            deref_finder(tcx, &mut drop_shim);
+            deref_finder(tcx, &mut drop_shim, false);
             body.coroutine.as_mut().unwrap().coroutine_drop_async = Some(drop_shim);
         } else {
             // If coroutine has no async drops, generating sync drop shim
             let mut drop_shim =
                 create_coroutine_drop_shim(tcx, &transform, coroutine_ty, body, drop_clean);
             // Run derefer to fix Derefs that are not in the first place
-            deref_finder(tcx, &mut drop_shim);
+            deref_finder(tcx, &mut drop_shim, false);
             body.coroutine.as_mut().unwrap().coroutine_drop = Some(drop_shim);
 
             // For coroutine with sync drop, generating async proxy for `future_drop_poll` call
             let mut proxy_shim = create_coroutine_drop_shim_proxy_async(tcx, body);
-            deref_finder(tcx, &mut proxy_shim);
+            deref_finder(tcx, &mut proxy_shim, false);
             body.coroutine.as_mut().unwrap().coroutine_drop_proxy_async = Some(proxy_shim);
         }
 
@@ -1645,7 +1645,7 @@ impl<'tcx> crate::MirPass<'tcx> for StateTransform {
         create_coroutine_resume_function(tcx, transform, body, can_return, can_unwind);
 
         // Run derefer to fix Derefs that are not in the first place
-        deref_finder(tcx, body);
+        deref_finder(tcx, body, false);
     }
 
     fn is_required(&self) -> bool {
diff --git a/compiler/rustc_mir_transform/src/deref_separator.rs b/compiler/rustc_mir_transform/src/deref_separator.rs
index bc914ea656415..1f380302804b9 100644
--- a/compiler/rustc_mir_transform/src/deref_separator.rs
+++ b/compiler/rustc_mir_transform/src/deref_separator.rs
@@ -11,6 +11,7 @@ struct DerefChecker<'a, 'tcx> {
     tcx: TyCtxt<'tcx>,
     patcher: MirPatch<'tcx>,
     local_decls: &'a LocalDecls<'tcx>,
+    add_deref_metadata: bool,
 }
 
 impl<'a, 'tcx> MutVisitor<'tcx> for DerefChecker<'a, 'tcx> {
@@ -39,7 +40,11 @@ impl<'a, 'tcx> MutVisitor<'tcx> for DerefChecker<'a, 'tcx> {
                     let temp = self.patcher.new_local_with_info(
                         ty,
                         self.local_decls[p_ref.local].source_info.span,
-                        LocalInfo::DerefTemp,
+                        if self.add_deref_metadata {
+                            LocalInfo::DerefTemp
+                        } else {
+                            LocalInfo::Boring
+                        },
                     );
 
                     // We are adding current p_ref's projections to our
@@ -50,7 +55,11 @@ impl<'a, 'tcx> MutVisitor<'tcx> for DerefChecker<'a, 'tcx> {
                     self.patcher.add_assign(
                         loc,
                         Place::from(temp),
-                        Rvalue::CopyForDeref(deref_place),
+                        if self.add_deref_metadata {
+                            Rvalue::CopyForDeref(deref_place)
+                        } else {
+                            Rvalue::Use(Operand::Copy(deref_place))
+                        },
                     );
                     place_local = temp;
                     last_len = p_ref.projection.len();
@@ -67,9 +76,14 @@ impl<'a, 'tcx> MutVisitor<'tcx> for DerefChecker<'a, 'tcx> {
     }
 }
 
-pub(super) fn deref_finder<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
+pub(super) fn deref_finder<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    body: &mut Body<'tcx>,
+    add_deref_metadata: bool,
+) {
     let patch = MirPatch::new(body);
-    let mut checker = DerefChecker { tcx, patcher: patch, local_decls: &body.local_decls };
+    let mut checker =
+        DerefChecker { tcx, patcher: patch, local_decls: &body.local_decls, add_deref_metadata };
 
     for (bb, data) in body.basic_blocks.as_mut_preserves_cfg().iter_enumerated_mut() {
         checker.visit_basic_block_data(bb, data);
@@ -80,7 +94,7 @@ pub(super) fn deref_finder<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
 
 impl<'tcx> crate::MirPass<'tcx> for Derefer {
     fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
-        deref_finder(tcx, body);
+        deref_finder(tcx, body, true);
     }
 
     fn is_required(&self) -> bool {
diff --git a/compiler/rustc_mir_transform/src/elaborate_drops.rs b/compiler/rustc_mir_transform/src/elaborate_drops.rs
index 58dff4514a04d..c4ad29d663010 100644
--- a/compiler/rustc_mir_transform/src/elaborate_drops.rs
+++ b/compiler/rustc_mir_transform/src/elaborate_drops.rs
@@ -87,7 +87,7 @@ impl<'tcx> crate::MirPass<'tcx> for ElaborateDrops {
             .elaborate()
         };
         elaborate_patch.apply(body);
-        deref_finder(tcx, body);
+        deref_finder(tcx, body, true);
     }
 
     fn is_required(&self) -> bool {
diff --git a/compiler/rustc_mir_transform/src/inline.rs b/compiler/rustc_mir_transform/src/inline.rs
index 8593e25d6aa5e..3c997cfd4fb01 100644
--- a/compiler/rustc_mir_transform/src/inline.rs
+++ b/compiler/rustc_mir_transform/src/inline.rs
@@ -64,7 +64,7 @@ impl<'tcx> crate::MirPass<'tcx> for Inline {
         if inline::<NormalInliner<'tcx>>(tcx, body) {
             debug!("running simplify cfg on {:?}", body.source);
             simplify_cfg(tcx, body);
-            deref_finder(tcx, body);
+            deref_finder(tcx, body, false);
         }
     }
 
@@ -100,7 +100,7 @@ impl<'tcx> crate::MirPass<'tcx> for ForceInline {
         if inline::<ForceInliner<'tcx>>(tcx, body) {
             debug!("running simplify cfg on {:?}", body.source);
             simplify_cfg(tcx, body);
-            deref_finder(tcx, body);
+            deref_finder(tcx, body, false);
         }
     }
 }
diff --git a/compiler/rustc_mir_transform/src/shim.rs b/compiler/rustc_mir_transform/src/shim.rs
index bca8ffb693b90..85e340c0a02ab 100644
--- a/compiler/rustc_mir_transform/src/shim.rs
+++ b/compiler/rustc_mir_transform/src/shim.rs
@@ -17,12 +17,13 @@ use rustc_span::source_map::{Spanned, dummy_spanned};
 use rustc_span::{DUMMY_SP, Span};
 use tracing::{debug, instrument};
 
+use crate::deref_separator::deref_finder;
 use crate::elaborate_drop::{DropElaborator, DropFlagMode, DropStyle, Unwind, elaborate_drop};
 use crate::patch::MirPatch;
 use crate::{
-    abort_unwinding_calls, add_call_guards, add_moves_for_packed_drops, deref_separator, inline,
-    instsimplify, mentioned_items, pass_manager as pm, remove_noop_landing_pads,
-    run_optimization_passes, simplify,
+    abort_unwinding_calls, add_call_guards, add_moves_for_packed_drops, inline, instsimplify,
+    mentioned_items, pass_manager as pm, remove_noop_landing_pads, run_optimization_passes,
+    simplify,
 };
 
 mod async_destructor_ctor;
@@ -222,6 +223,8 @@ fn make_shim<'tcx>(tcx: TyCtxt<'tcx>, instance: ty::InstanceKind<'tcx>) -> Body<
     };
     debug!("make_shim({:?}) = untransformed {:?}", instance, result);
 
+    deref_finder(tcx, &mut result, false);
+
     // We don't validate MIR here because the shims may generate code that's
     // only valid in a `PostAnalysis` param-env. However, since we do initial
     // validation with the MirBuilt phase, which uses a user-facing param-env.
@@ -232,7 +235,6 @@ fn make_shim<'tcx>(tcx: TyCtxt<'tcx>, instance: ty::InstanceKind<'tcx>) -> Body<
         &[
             &mentioned_items::MentionedItems,
             &add_moves_for_packed_drops::AddMovesForPackedDrops,
-            &deref_separator::Derefer,
             &remove_noop_landing_pads::RemoveNoopLandingPads,
             &simplify::SimplifyCfg::MakeShim,
             &instsimplify::InstSimplify::BeforeInline,

From 5407eb8ca2254db44b806ada123e389302eae04d Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Sun, 7 Sep 2025 20:51:16 +0000
Subject: [PATCH 1771/1889] GVN: Support unions.

---
 compiler/rustc_mir_transform/src/gvn.rs       | 38 ++++++++++++++-----
 .../const_prop/invalid_constant.main.GVN.diff | 30 ++++++++++++---
 tests/mir-opt/const_prop/transmute.rs         |  4 +-
 ...mute.undef_union_as_integer.GVN.32bit.diff |  9 ++++-
 ...mute.undef_union_as_integer.GVN.64bit.diff |  9 ++++-
 ...in.DestinationPropagation.panic-abort.diff | 10 +++--
 ...n.DestinationPropagation.panic-unwind.diff | 10 +++--
 tests/mir-opt/dest-prop/union.rs              |  5 ++-
 8 files changed, 85 insertions(+), 30 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index 03a40f83732ac..bd8ea7dddad83 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -213,6 +213,8 @@ enum Value<'a, 'tcx> {
     /// An aggregate value, either tuple/closure/struct/enum.
     /// This does not contain unions, as we cannot reason with the value.
     Aggregate(VariantIdx, &'a [VnIndex]),
+    /// A union aggregate value.
+    Union(FieldIdx, VnIndex),
     /// A raw pointer aggregate built from a thin pointer and metadata.
     RawPtr {
         /// Thin pointer component. This is field 0 in MIR.
@@ -600,6 +602,21 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
                     return None;
                 }
             }
+            Union(active_field, field) => {
+                let field = self.evaluated[field].as_ref()?;
+                if matches!(ty.backend_repr, BackendRepr::Scalar(..) | BackendRepr::ScalarPair(..))
+                {
+                    let dest = self.ecx.allocate(ty, MemoryKind::Stack).discard_err()?;
+                    let field_dest = self.ecx.project_field(&dest, active_field).discard_err()?;
+                    self.ecx.copy_op(field, &field_dest).discard_err()?;
+                    self.ecx
+                        .alloc_mark_immutable(dest.ptr().provenance.unwrap().alloc_id())
+                        .discard_err()?;
+                    dest.into()
+                } else {
+                    return None;
+                }
+            }
             RawPtr { pointer, metadata } => {
                 let pointer = self.evaluated[pointer].as_ref()?;
                 let metadata = self.evaluated[metadata].as_ref()?;
@@ -802,11 +819,11 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
                 }
             }
             ProjectionElem::Downcast(name, index) => ProjectionElem::Downcast(name, index),
-            ProjectionElem::Field(f, _) => {
-                if let Value::Aggregate(_, fields) = self.get(value) {
-                    return Some((projection_ty, fields[f.as_usize()]));
-                } else if let Value::Projection(outer_value, ProjectionElem::Downcast(_, read_variant)) = self.get(value)
-                    && let Value::Aggregate(written_variant, fields) = self.get(outer_value)
+            ProjectionElem::Field(f, _) => match self.get(value) {
+                Value::Aggregate(_, fields) => return Some((projection_ty, fields[f.as_usize()])),
+                Value::Union(active, field) if active == f => return Some((projection_ty, field)),
+                Value::Projection(outer_value, ProjectionElem::Downcast(_, read_variant))
+                    if let Value::Aggregate(written_variant, fields) = self.get(outer_value)
                     // This pass is not aware of control-flow, so we do not know whether the
                     // replacement we are doing is actually reachable. We could be in any arm of
                     // ```
@@ -822,12 +839,12 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
                     // accessing the wrong variant is not UB if the enum has repr.
                     // So it's not impossible for a series of MIR opts to generate
                     // a downcast to an inactive variant.
-                    && written_variant == read_variant
+                    && written_variant == read_variant =>
                 {
                     return Some((projection_ty, fields[f.as_usize()]));
                 }
-                ProjectionElem::Field(f, ())
-            }
+                _ => ProjectionElem::Field(f, ()),
+            },
             ProjectionElem::Index(idx) => {
                 if let Value::Repeat(inner, _) = self.get(value) {
                     return Some((projection_ty, inner));
@@ -1167,7 +1184,10 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
             | AggregateKind::Coroutine(..) => FIRST_VARIANT,
             AggregateKind::Adt(_, variant_index, _, _, None) => variant_index,
             // Do not track unions.
-            AggregateKind::Adt(_, _, _, _, Some(_)) => return None,
+            AggregateKind::Adt(_, _, _, _, Some(active_field)) => {
+                let field = *fields.first()?;
+                return Some(self.insert(ty, Value::Union(active_field, field)));
+            }
             AggregateKind::RawPtr(..) => {
                 assert_eq!(field_ops.len(), 2);
                 let [mut pointer, metadata] = fields.try_into().unwrap();
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 5e843da867923..a4900a1ac72ea 100644
--- a/tests/mir-opt/const_prop/invalid_constant.main.GVN.diff
+++ b/tests/mir-opt/const_prop/invalid_constant.main.GVN.diff
@@ -28,21 +28,27 @@
       bb0: {
           StorageLive(_1);
           StorageLive(_2);
-          _2 = InvalidChar { int: const 1114113_u32 };
-          _1 = copy (_2.1: char);
+-         _2 = InvalidChar { int: const 1114113_u32 };
+-         _1 = copy (_2.1: char);
++         _2 = const InvalidChar {{ int: 1114113_u32, chr: {transmute(0x00110001): char} }};
++         _1 = const {transmute(0x00110001): char};
           StorageDead(_2);
           StorageLive(_3);
           StorageLive(_4);
           StorageLive(_5);
-          _5 = InvalidTag { int: const 4_u32 };
-          _4 = copy (_5.1: E);
-          _3 = [move _4];
+-         _5 = InvalidTag { int: const 4_u32 };
+-         _4 = copy (_5.1: E);
+-         _3 = [move _4];
++         _5 = const InvalidTag {{ int: 4_u32, e: Scalar(0x00000004): E }};
++         _4 = const Scalar(0x00000004): E;
++         _3 = [const Scalar(0x00000004): E];
           StorageDead(_4);
           StorageDead(_5);
           nop;
           nop;
           StorageLive(_8);
-          _8 = NoVariants { int: const 0_u32 };
+-         _8 = NoVariants { int: const 0_u32 };
++         _8 = const NoVariants {{ int: 0_u32, empty: ZeroSized: Empty }};
           nop;
           nop;
           nop;
@@ -55,5 +61,17 @@
           StorageDead(_1);
           return;
       }
++ }
++ 
++ ALLOC0 (size: 4, align: 4) {
++     00 00 00 00                                     │ ....
++ }
++ 
++ ALLOC1 (size: 4, align: 4) {
++     04 00 00 00                                     │ ....
++ }
++ 
++ ALLOC2 (size: 4, align: 4) {
++     01 00 11 00                                     │ ....
   }
   
diff --git a/tests/mir-opt/const_prop/transmute.rs b/tests/mir-opt/const_prop/transmute.rs
index 33cbefbf053f5..ece6331ade279 100644
--- a/tests/mir-opt/const_prop/transmute.rs
+++ b/tests/mir-opt/const_prop/transmute.rs
@@ -43,8 +43,8 @@ pub unsafe fn invalid_bool() -> bool {
 // EMIT_MIR transmute.undef_union_as_integer.GVN.diff
 pub unsafe fn undef_union_as_integer() -> u32 {
     // CHECK-LABEL: fn undef_union_as_integer(
-    // CHECK: _1 = Union32 {
-    // CHECK: _0 = move _1 as u32 (Transmute);
+    // CHECK: _1 = const Union32
+    // CHECK: _0 = const {{.*}}: u32;
     union Union32 {
         value: u32,
         unit: (),
diff --git a/tests/mir-opt/const_prop/transmute.undef_union_as_integer.GVN.32bit.diff b/tests/mir-opt/const_prop/transmute.undef_union_as_integer.GVN.32bit.diff
index 2ac9769a0e773..be0450114b1c8 100644
--- a/tests/mir-opt/const_prop/transmute.undef_union_as_integer.GVN.32bit.diff
+++ b/tests/mir-opt/const_prop/transmute.undef_union_as_integer.GVN.32bit.diff
@@ -12,11 +12,16 @@
 -         _2 = ();
 -         _1 = Union32 { value: move _2 };
 +         _2 = const ();
-+         _1 = Union32 { value: const () };
++         _1 = const Union32 {{ value: Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: u32, unit: () }};
           StorageDead(_2);
-          _0 = move _1 as u32 (Transmute);
+-         _0 = move _1 as u32 (Transmute);
++         _0 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: u32;
           StorageDead(_1);
           return;
       }
++ }
++ 
++ ALLOC0 (size: 4, align: 4) {
++     __ __ __ __                                     │ ░░░░
   }
   
diff --git a/tests/mir-opt/const_prop/transmute.undef_union_as_integer.GVN.64bit.diff b/tests/mir-opt/const_prop/transmute.undef_union_as_integer.GVN.64bit.diff
index 2ac9769a0e773..be0450114b1c8 100644
--- a/tests/mir-opt/const_prop/transmute.undef_union_as_integer.GVN.64bit.diff
+++ b/tests/mir-opt/const_prop/transmute.undef_union_as_integer.GVN.64bit.diff
@@ -12,11 +12,16 @@
 -         _2 = ();
 -         _1 = Union32 { value: move _2 };
 +         _2 = const ();
-+         _1 = Union32 { value: const () };
++         _1 = const Union32 {{ value: Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: u32, unit: () }};
           StorageDead(_2);
-          _0 = move _1 as u32 (Transmute);
+-         _0 = move _1 as u32 (Transmute);
++         _0 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: u32;
           StorageDead(_1);
           return;
       }
++ }
++ 
++ ALLOC0 (size: 4, align: 4) {
++     __ __ __ __                                     │ ░░░░
   }
   
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 ef418798faaf7..013f1ea4e497d 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
@@ -6,9 +6,9 @@
       let _1: main::Un;
       let mut _2: u32;
       scope 1 {
-          debug un => _1;
+          debug un => const Un {{ us: 1_u32 }};
           scope 3 (inlined std::mem::drop::<u32>) {
-              debug _x => _2;
+              debug _x => const 1_u32;
           }
       }
       scope 2 (inlined val) {
@@ -16,12 +16,14 @@
   
       bb0: {
           StorageLive(_1);
-          _1 = Un { us: const 1_u32 };
           StorageLive(_2);
-          _2 = copy (_1.0: u32);
           StorageDead(_2);
           StorageDead(_1);
           return;
       }
   }
   
+  ALLOC0 (size: 4, align: 4) {
+      01 00 00 00                                     │ ....
+  }
+  
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 ef418798faaf7..013f1ea4e497d 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
@@ -6,9 +6,9 @@
       let _1: main::Un;
       let mut _2: u32;
       scope 1 {
-          debug un => _1;
+          debug un => const Un {{ us: 1_u32 }};
           scope 3 (inlined std::mem::drop::<u32>) {
-              debug _x => _2;
+              debug _x => const 1_u32;
           }
       }
       scope 2 (inlined val) {
@@ -16,12 +16,14 @@
   
       bb0: {
           StorageLive(_1);
-          _1 = Un { us: const 1_u32 };
           StorageLive(_2);
-          _2 = copy (_1.0: u32);
           StorageDead(_2);
           StorageDead(_1);
           return;
       }
   }
   
+  ALLOC0 (size: 4, align: 4) {
+      01 00 00 00                                     │ ....
+  }
+  
diff --git a/tests/mir-opt/dest-prop/union.rs b/tests/mir-opt/dest-prop/union.rs
index 85eded0998031..977ab9c57ad7e 100644
--- a/tests/mir-opt/dest-prop/union.rs
+++ b/tests/mir-opt/dest-prop/union.rs
@@ -8,7 +8,10 @@ fn val() -> u32 {
 // EMIT_MIR union.main.DestinationPropagation.diff
 fn main() {
     // CHECK-LABEL: fn main(
-    // CHECK: {{_.*}} = Un { us: const 1_u32 };
+    // CHECK: debug un => const Un
+    // CHECK: debug _x => const 1_u32;
+    // CHECK: bb0: {
+    // CHECK-NEXT: return;
     union Un {
         us: u32,
     }

From 96c3978eaa5d116a9ffff6b33c61e25d972a9aa2 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Fri, 26 Sep 2025 21:06:22 +0000
Subject: [PATCH 1772/1889] Repurpose defunct test.

---
 tests/mir-opt/const_prop/union.main.GVN.diff  | 42 +++++++++++++++++++
 .../{dest-prop => const_prop}/union.rs        | 12 +++---
 ...in.DestinationPropagation.panic-abort.diff | 29 -------------
 ...n.DestinationPropagation.panic-unwind.diff | 29 -------------
 4 files changed, 48 insertions(+), 64 deletions(-)
 create mode 100644 tests/mir-opt/const_prop/union.main.GVN.diff
 rename tests/mir-opt/{dest-prop => const_prop}/union.rs (52%)
 delete mode 100644 tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-abort.diff
 delete mode 100644 tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-unwind.diff

diff --git a/tests/mir-opt/const_prop/union.main.GVN.diff b/tests/mir-opt/const_prop/union.main.GVN.diff
new file mode 100644
index 0000000000000..16a0432ab9013
--- /dev/null
+++ b/tests/mir-opt/const_prop/union.main.GVN.diff
@@ -0,0 +1,42 @@
+- // MIR for `main` before GVN
++ // MIR for `main` after GVN
+  
+  fn main() -> () {
+      let mut _0: ();
+      let _1: main::Un;
+      let mut _2: u32;
+      let _3: ();
+      let mut _4: u32;
+      scope 1 {
+          debug un => _1;
+          scope 3 (inlined std::mem::drop::<u32>) {
+          }
+      }
+      scope 2 (inlined val) {
+      }
+  
+      bb0: {
+          StorageLive(_1);
+-         StorageLive(_2);
++         nop;
+          _2 = const 1_u32;
+-         _1 = Un { us: move _2 };
+-         StorageDead(_2);
++         _1 = const Un {{ us: 1_u32 }};
++         nop;
+          StorageLive(_3);
+          StorageLive(_4);
+-         _4 = copy (_1.0: u32);
++         _4 = const 1_u32;
+          StorageDead(_4);
+          StorageDead(_3);
+          _0 = const ();
+          StorageDead(_1);
+          return;
+      }
++ }
++ 
++ ALLOC0 (size: 4, align: 4) {
++     01 00 00 00                                     │ ....
+  }
+  
diff --git a/tests/mir-opt/dest-prop/union.rs b/tests/mir-opt/const_prop/union.rs
similarity index 52%
rename from tests/mir-opt/dest-prop/union.rs
rename to tests/mir-opt/const_prop/union.rs
index 977ab9c57ad7e..9f197a1a58338 100644
--- a/tests/mir-opt/dest-prop/union.rs
+++ b/tests/mir-opt/const_prop/union.rs
@@ -1,17 +1,17 @@
-// EMIT_MIR_FOR_EACH_PANIC_STRATEGY
 //! Tests that we can propagate into places that are projections into unions
-//@ compile-flags: -Zunsound-mir-opts -C debuginfo=full
+//@ test-mir-pass: GVN
+//@ compile-flags: -Zinline-mir
+
 fn val() -> u32 {
     1
 }
 
-// EMIT_MIR union.main.DestinationPropagation.diff
+// EMIT_MIR union.main.GVN.diff
 fn main() {
     // CHECK-LABEL: fn main(
-    // CHECK: debug un => const Un
-    // CHECK: debug _x => const 1_u32;
+    // CHECK: debug un => [[un:_.*]];
     // CHECK: bb0: {
-    // CHECK-NEXT: return;
+    // CHECK: [[un]] = const Un {{{{ us: 1_u32 }}}};
     union Un {
         us: u32,
     }
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
deleted file mode 100644
index 013f1ea4e497d..0000000000000
--- a/tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-abort.diff
+++ /dev/null
@@ -1,29 +0,0 @@
-- // MIR for `main` before DestinationPropagation
-+ // MIR for `main` after DestinationPropagation
-  
-  fn main() -> () {
-      let mut _0: ();
-      let _1: main::Un;
-      let mut _2: u32;
-      scope 1 {
-          debug un => const Un {{ us: 1_u32 }};
-          scope 3 (inlined std::mem::drop::<u32>) {
-              debug _x => const 1_u32;
-          }
-      }
-      scope 2 (inlined val) {
-      }
-  
-      bb0: {
-          StorageLive(_1);
-          StorageLive(_2);
-          StorageDead(_2);
-          StorageDead(_1);
-          return;
-      }
-  }
-  
-  ALLOC0 (size: 4, align: 4) {
-      01 00 00 00                                     │ ....
-  }
-  
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
deleted file mode 100644
index 013f1ea4e497d..0000000000000
--- a/tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-unwind.diff
+++ /dev/null
@@ -1,29 +0,0 @@
-- // MIR for `main` before DestinationPropagation
-+ // MIR for `main` after DestinationPropagation
-  
-  fn main() -> () {
-      let mut _0: ();
-      let _1: main::Un;
-      let mut _2: u32;
-      scope 1 {
-          debug un => const Un {{ us: 1_u32 }};
-          scope 3 (inlined std::mem::drop::<u32>) {
-              debug _x => const 1_u32;
-          }
-      }
-      scope 2 (inlined val) {
-      }
-  
-      bb0: {
-          StorageLive(_1);
-          StorageLive(_2);
-          StorageDead(_2);
-          StorageDead(_1);
-          return;
-      }
-  }
-  
-  ALLOC0 (size: 4, align: 4) {
-      01 00 00 00                                     │ ....
-  }
-  

From cb06d91cd0ec0cd0393cee3a943f312ed849b530 Mon Sep 17 00:00:00 2001
From: Karol Zwolak <karolzwolak7@gmail.com>
Date: Mon, 6 Oct 2025 19:51:37 +0200
Subject: [PATCH 1773/1889] don't panic on extern with just multiple quotes in
 the name

---
 compiler/rustc_span/src/symbol.rs             |  6 ++--
 ....rs => extern-only-quotes-issue-147365.rs} |  6 +++-
 .../extern-only-quotes-issue-147365.stderr    | 32 +++++++++++++++++++
 .../extern-single-quote-issue-147365.stderr   | 16 ----------
 4 files changed, 41 insertions(+), 19 deletions(-)
 rename tests/ui/extern/{extern-single-quote-issue-147365.rs => extern-only-quotes-issue-147365.rs} (63%)
 create mode 100644 tests/ui/extern/extern-only-quotes-issue-147365.stderr
 delete mode 100644 tests/ui/extern/extern-single-quote-issue-147365.stderr

diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 92dd56f3d5894..36214dd1c3ed2 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -2511,9 +2511,11 @@ impl Ident {
     }
 
     /// Creates a new ident with the same span and name with leading quote removed, if any.
-    /// If called on an empty ident, or with name just a single quote, returns an empty ident which is invalid.
+    /// Calling it on a `'` ident will return an empty ident, which triggers debug assertions.
     pub fn without_first_quote(self) -> Ident {
-        Ident::new(Symbol::intern(self.as_str().trim_start_matches('\'')), self.span)
+        self.as_str()
+            .strip_prefix('\'')
+            .map_or(self, |name| Ident::new(Symbol::intern(name), self.span))
     }
 
     /// "Normalize" ident for use in comparisons using "item hygiene".
diff --git a/tests/ui/extern/extern-single-quote-issue-147365.rs b/tests/ui/extern/extern-only-quotes-issue-147365.rs
similarity index 63%
rename from tests/ui/extern/extern-single-quote-issue-147365.rs
rename to tests/ui/extern/extern-only-quotes-issue-147365.rs
index b50016bd65f31..3a492b4fb4f86 100644
--- a/tests/ui/extern/extern-single-quote-issue-147365.rs
+++ b/tests/ui/extern/extern-only-quotes-issue-147365.rs
@@ -2,8 +2,12 @@
 
 // https://github.com/rust-lang/rust/issues/147365
 // Ensures we don't trigger debug assert by creating an empty Ident when determining whether
-// the single quote is a raw lifetime.
+// the quotes are a raw lifetime.
 
 extern "'" {} //~ ERROR invalid ABI: found `'`
 
+extern "''" {} //~ ERROR invalid ABI: found `''`
+
+extern "'''" {} //~ ERROR invalid ABI: found `'''`
+
 fn main() {}
diff --git a/tests/ui/extern/extern-only-quotes-issue-147365.stderr b/tests/ui/extern/extern-only-quotes-issue-147365.stderr
new file mode 100644
index 0000000000000..fabc0fd4916b7
--- /dev/null
+++ b/tests/ui/extern/extern-only-quotes-issue-147365.stderr
@@ -0,0 +1,32 @@
+error[E0703]: invalid ABI: found `'`
+  --> $DIR/extern-only-quotes-issue-147365.rs:7:8
+   |
+LL | extern "'" {}
+   |        ^^^ invalid ABI
+   |
+   = note: invoke `rustc --print=calling-conventions` for a full list of supported calling conventions
+help: there's a similarly named valid ABI `C`
+   |
+LL - extern "'" {}
+LL + extern "C" {}
+   |
+
+error[E0703]: invalid ABI: found `''`
+  --> $DIR/extern-only-quotes-issue-147365.rs:9:8
+   |
+LL | extern "''" {}
+   |        ^^^^ invalid ABI
+   |
+   = note: invoke `rustc --print=calling-conventions` for a full list of supported calling conventions
+
+error[E0703]: invalid ABI: found `'''`
+  --> $DIR/extern-only-quotes-issue-147365.rs:11:8
+   |
+LL | extern "'''" {}
+   |        ^^^^^ invalid ABI
+   |
+   = note: invoke `rustc --print=calling-conventions` for a full list of supported calling conventions
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0703`.
diff --git a/tests/ui/extern/extern-single-quote-issue-147365.stderr b/tests/ui/extern/extern-single-quote-issue-147365.stderr
deleted file mode 100644
index d761bc3ebf323..0000000000000
--- a/tests/ui/extern/extern-single-quote-issue-147365.stderr
+++ /dev/null
@@ -1,16 +0,0 @@
-error[E0703]: invalid ABI: found `'`
-  --> $DIR/extern-single-quote-issue-147365.rs:7:8
-   |
-LL | extern "'" {}
-   |        ^^^ invalid ABI
-   |
-   = note: invoke `rustc --print=calling-conventions` for a full list of supported calling conventions
-help: there's a similarly named valid ABI `C`
-   |
-LL - extern "'" {}
-LL + extern "C" {}
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0703`.

From 4787834edaa66a596be6b78459b85e20363adb0c Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Mon, 6 Oct 2025 22:31:38 +0200
Subject: [PATCH 1774/1889] Fix target list of `link_section`

Signed-off-by: Jonathan Brouwer <jonathantbrouwer@gmail.com>
---
 .../rustc_attr_parsing/src/attributes/link_attrs.rs  | 10 ++++++++--
 tests/ui/attributes/attr-on-mac-call.stderr          |  2 +-
 .../issue-43106-gating-of-builtin-attrs.stderr       | 12 ++++++------
 3 files changed, 15 insertions(+), 9 deletions(-)

diff --git a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
index 09f7bfa24e823..40ecd91e5cfc1 100644
--- a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
@@ -467,8 +467,14 @@ impl<S: Stage> SingleAttributeParser<S> for LinkSectionParser {
     const PATH: &[Symbol] = &[sym::link_section];
     const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
-    const ALLOWED_TARGETS: AllowedTargets =
-        AllowedTargets::AllowListWarnRest(&[Allow(Target::Static), Allow(Target::Fn)]);
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowListWarnRest(&[
+        Allow(Target::Static),
+        Allow(Target::Fn),
+        Allow(Target::Method(MethodKind::Inherent)),
+        Allow(Target::Method(MethodKind::Trait { body: false })),
+        Allow(Target::Method(MethodKind::Trait { body: true })),
+        Allow(Target::Method(MethodKind::TraitImpl)),
+    ]);
     const TEMPLATE: AttributeTemplate = template!(
         NameValueStr: "name",
         "https://doc.rust-lang.org/reference/abi.html#the-link_section-attribute"
diff --git a/tests/ui/attributes/attr-on-mac-call.stderr b/tests/ui/attributes/attr-on-mac-call.stderr
index a08d305916856..02c0ec8ea1d6c 100644
--- a/tests/ui/attributes/attr-on-mac-call.stderr
+++ b/tests/ui/attributes/attr-on-mac-call.stderr
@@ -82,7 +82,7 @@ LL |     #[link_section = "x"]
    |     ^^^^^^^^^^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[link_section]` can be applied to statics and functions
+   = help: `#[link_section]` can be applied to functions and statics
 
 warning: `#[link_ordinal]` attribute cannot be used on macro calls
   --> $DIR/attr-on-mac-call.rs:33:5
diff --git a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr
index 5e2029c45165a..2e2eea65b817a 100644
--- a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr
+++ b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr
@@ -1236,7 +1236,7 @@ LL | #[link_section = "1800"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[link_section]` can be applied to statics and functions
+   = help: `#[link_section]` can be applied to functions and statics
 
 warning: `#[link_section]` attribute cannot be used on modules
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:683:17
@@ -1245,7 +1245,7 @@ LL |     mod inner { #![link_section="1800"] }
    |                 ^^^^^^^^^^^^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[link_section]` can be applied to statics and functions
+   = help: `#[link_section]` can be applied to functions and statics
 
 warning: `#[link_section]` attribute cannot be used on structs
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:691:5
@@ -1254,7 +1254,7 @@ LL |     #[link_section = "1800"] struct S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[link_section]` can be applied to statics and functions
+   = help: `#[link_section]` can be applied to functions and statics
 
 warning: `#[link_section]` attribute cannot be used on type aliases
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:697:5
@@ -1263,7 +1263,7 @@ LL |     #[link_section = "1800"] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[link_section]` can be applied to statics and functions
+   = help: `#[link_section]` can be applied to functions and statics
 
 warning: `#[link_section]` attribute cannot be used on inherent impl blocks
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:703:5
@@ -1272,7 +1272,7 @@ LL |     #[link_section = "1800"] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[link_section]` can be applied to statics and functions
+   = help: `#[link_section]` can be applied to functions and statics
 
 warning: `#[must_use]` attribute cannot be used on modules
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:764:1
@@ -1572,7 +1572,7 @@ LL | #![link_section = "1800"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[link_section]` can be applied to statics and functions
+   = help: `#[link_section]` can be applied to functions and statics
 
 warning: `#[must_use]` attribute cannot be used on crates
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:84:1

From a11fe5d389b08d62b138aedb31ed04e8c08cff91 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Mon, 6 Oct 2025 23:50:47 +0200
Subject: [PATCH 1775/1889] Add diagnostic items for `pub mod consts` of FP
 types

They will be used in Clippy.
---
 compiler/rustc_span/src/symbol.rs | 4 ++++
 library/core/src/num/f128.rs      | 1 +
 library/core/src/num/f16.rs       | 1 +
 library/core/src/num/f32.rs       | 1 +
 library/core/src/num/f64.rs       | 1 +
 5 files changed, 8 insertions(+)

diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 92dd56f3d5894..29e708ae4e6d4 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -980,10 +980,12 @@ symbols! {
         external_doc,
         f,
         f16,
+        f16_consts_mod,
         f16_epsilon,
         f16_nan,
         f16c_target_feature,
         f32,
+        f32_consts_mod,
         f32_epsilon,
         f32_legacy_const_digits,
         f32_legacy_const_epsilon,
@@ -1001,6 +1003,7 @@ symbols! {
         f32_legacy_const_radix,
         f32_nan,
         f64,
+        f64_consts_mod,
         f64_epsilon,
         f64_legacy_const_digits,
         f64_legacy_const_epsilon,
@@ -1018,6 +1021,7 @@ symbols! {
         f64_legacy_const_radix,
         f64_nan,
         f128,
+        f128_consts_mod,
         f128_epsilon,
         f128_nan,
         fabsf16,
diff --git a/library/core/src/num/f128.rs b/library/core/src/num/f128.rs
index 4fe4735e304c9..e7101537b298f 100644
--- a/library/core/src/num/f128.rs
+++ b/library/core/src/num/f128.rs
@@ -18,6 +18,7 @@ use crate::{intrinsics, mem};
 
 /// Basic mathematical constants.
 #[unstable(feature = "f128", issue = "116909")]
+#[rustc_diagnostic_item = "f128_consts_mod"]
 pub mod consts {
     // FIXME: replace with mathematical constants from cmath.
 
diff --git a/library/core/src/num/f16.rs b/library/core/src/num/f16.rs
index 0bea6bc8801d8..aa8342a22ad58 100644
--- a/library/core/src/num/f16.rs
+++ b/library/core/src/num/f16.rs
@@ -20,6 +20,7 @@ use crate::{intrinsics, mem};
 
 /// Basic mathematical constants.
 #[unstable(feature = "f16", issue = "116909")]
+#[rustc_diagnostic_item = "f16_consts_mod"]
 pub mod consts {
     // FIXME: replace with mathematical constants from cmath.
 
diff --git a/library/core/src/num/f32.rs b/library/core/src/num/f32.rs
index e380cc698f574..3070e1dedbe43 100644
--- a/library/core/src/num/f32.rs
+++ b/library/core/src/num/f32.rs
@@ -277,6 +277,7 @@ pub const NEG_INFINITY: f32 = f32::NEG_INFINITY;
 
 /// Basic mathematical constants.
 #[stable(feature = "rust1", since = "1.0.0")]
+#[rustc_diagnostic_item = "f32_consts_mod"]
 pub mod consts {
     // FIXME: replace with mathematical constants from cmath.
 
diff --git a/library/core/src/num/f64.rs b/library/core/src/num/f64.rs
index ff7449fd996ce..dc8ccc551b2da 100644
--- a/library/core/src/num/f64.rs
+++ b/library/core/src/num/f64.rs
@@ -277,6 +277,7 @@ pub const NEG_INFINITY: f64 = f64::NEG_INFINITY;
 
 /// Basic mathematical constants.
 #[stable(feature = "rust1", since = "1.0.0")]
+#[rustc_diagnostic_item = "f64_consts_mod"]
 pub mod consts {
     // FIXME: replace with mathematical constants from cmath.
 

From f644f2c1f3844aa55d423c704164630035fdee81 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Mon, 6 Oct 2025 18:39:55 +1100
Subject: [PATCH 1776/1889] Avoid passing `Option<&MarkFrame<'_>>`.

Two functions take arguments of this type, but the `Option` is always
`Some`, so we can just pass `&MarkFrame<'_>` instead.
---
 compiler/rustc_query_system/src/dep_graph/graph.rs | 10 +++++-----
 compiler/rustc_query_system/src/dep_graph/mod.rs   |  2 +-
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_query_system/src/dep_graph/graph.rs b/compiler/rustc_query_system/src/dep_graph/graph.rs
index 5e62dab0722c6..ec9fc18c930cb 100644
--- a/compiler/rustc_query_system/src/dep_graph/graph.rs
+++ b/compiler/rustc_query_system/src/dep_graph/graph.rs
@@ -873,7 +873,7 @@ impl<D: Deps> DepGraphData<D> {
         &self,
         qcx: Qcx,
         parent_dep_node_index: SerializedDepNodeIndex,
-        frame: Option<&MarkFrame<'_>>,
+        frame: &MarkFrame<'_>,
     ) -> Option<()> {
         let get_dep_dep_node = || self.previous.index_to_node(parent_dep_node_index);
 
@@ -911,7 +911,7 @@ impl<D: Deps> DepGraphData<D> {
             );
 
             let node_index =
-                self.try_mark_previous_green(qcx, parent_dep_node_index, dep_dep_node, frame);
+                self.try_mark_previous_green(qcx, parent_dep_node_index, dep_dep_node, Some(frame));
 
             if node_index.is_some() {
                 debug!("managed to MARK dependency {dep_dep_node:?} as green");
@@ -976,7 +976,7 @@ impl<D: Deps> DepGraphData<D> {
         let prev_deps = self.previous.edge_targets_from(prev_dep_node_index);
 
         for dep_dep_node_index in prev_deps {
-            self.try_mark_parent_green(qcx, dep_dep_node_index, Some(&frame))?;
+            self.try_mark_parent_green(qcx, dep_dep_node_index, &frame)?;
         }
 
         // If we got here without hitting a `return` that means that all
@@ -1397,14 +1397,14 @@ impl DepNodeColorMap {
 
 #[inline(never)]
 #[cold]
-pub(crate) fn print_markframe_trace<D: Deps>(graph: &DepGraph<D>, frame: Option<&MarkFrame<'_>>) {
+pub(crate) fn print_markframe_trace<D: Deps>(graph: &DepGraph<D>, frame: &MarkFrame<'_>) {
     let data = graph.data.as_ref().unwrap();
 
     eprintln!("there was a panic while trying to force a dep node");
     eprintln!("try_mark_green dep node stack:");
 
     let mut i = 0;
-    let mut current = frame;
+    let mut current = Some(frame);
     while let Some(frame) = current {
         let node = data.previous.index_to_node(frame.index);
         eprintln!("#{i} {node:?}");
diff --git a/compiler/rustc_query_system/src/dep_graph/mod.rs b/compiler/rustc_query_system/src/dep_graph/mod.rs
index 512034a8b2f52..d648415c9fc67 100644
--- a/compiler/rustc_query_system/src/dep_graph/mod.rs
+++ b/compiler/rustc_query_system/src/dep_graph/mod.rs
@@ -63,7 +63,7 @@ pub trait DepContext: Copy {
         self,
         dep_node: DepNode,
         prev_index: SerializedDepNodeIndex,
-        frame: Option<&MarkFrame<'_>>,
+        frame: &MarkFrame<'_>,
     ) -> bool {
         let cb = self.dep_kind_info(dep_node.kind);
         if let Some(f) = cb.force_from_dep_node {

From a4162d9a8231702162068a25724d15c287da198e Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Mon, 6 Oct 2025 20:26:36 +1100
Subject: [PATCH 1777/1889] Change `DepNodeColorMap::insert` to `insert_red`.

Because it's only ever used for inserting red. (`None` is only used as a
starting value, and `Green` is inserted by `try_mark_green` and
friends.)
---
 .../rustc_query_system/src/dep_graph/graph.rs   | 17 +++++------------
 .../src/dep_graph/serialized.rs                 |  4 ++--
 2 files changed, 7 insertions(+), 14 deletions(-)

diff --git a/compiler/rustc_query_system/src/dep_graph/graph.rs b/compiler/rustc_query_system/src/dep_graph/graph.rs
index ec9fc18c930cb..550dd4a7b2deb 100644
--- a/compiler/rustc_query_system/src/dep_graph/graph.rs
+++ b/compiler/rustc_query_system/src/dep_graph/graph.rs
@@ -148,10 +148,9 @@ impl<D: Deps> DepGraph<D> {
         );
         assert_eq!(red_node_index, DepNodeIndex::FOREVER_RED_NODE);
         if prev_graph_node_count > 0 {
-            colors.insert(
-                SerializedDepNodeIndex::from_u32(DepNodeIndex::FOREVER_RED_NODE.as_u32()),
-                DepNodeColor::Red,
-            );
+            colors.insert_red(SerializedDepNodeIndex::from_u32(
+                DepNodeIndex::FOREVER_RED_NODE.as_u32(),
+            ));
         }
 
         DepGraph {
@@ -1384,14 +1383,8 @@ impl DepNodeColorMap {
     }
 
     #[inline]
-    pub(super) fn insert(&self, index: SerializedDepNodeIndex, color: DepNodeColor) {
-        self.values[index].store(
-            match color {
-                DepNodeColor::Red => COMPRESSED_RED,
-                DepNodeColor::Green(index) => index.as_u32(),
-            },
-            Ordering::Release,
-        )
+    pub(super) fn insert_red(&self, index: SerializedDepNodeIndex) {
+        self.values[index].store(COMPRESSED_RED, Ordering::Release)
     }
 }
 
diff --git a/compiler/rustc_query_system/src/dep_graph/serialized.rs b/compiler/rustc_query_system/src/dep_graph/serialized.rs
index 79b99c52d0c01..453002dea4b39 100644
--- a/compiler/rustc_query_system/src/dep_graph/serialized.rs
+++ b/compiler/rustc_query_system/src/dep_graph/serialized.rs
@@ -59,7 +59,7 @@ use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
 use rustc_session::Session;
 use tracing::{debug, instrument};
 
-use super::graph::{CurrentDepGraph, DepNodeColor, DepNodeColorMap};
+use super::graph::{CurrentDepGraph, DepNodeColorMap};
 use super::query::DepGraphQuery;
 use super::{DepKind, DepNode, DepNodeIndex, Deps};
 use crate::dep_graph::edges::EdgesVec;
@@ -906,7 +906,7 @@ impl<D: Deps> GraphEncoder<D> {
                 Err(dep_node_index) => return dep_node_index,
             }
         } else {
-            colors.insert(prev_index, DepNodeColor::Red);
+            colors.insert_red(prev_index);
         }
 
         self.status.bump_index(&mut *local);

From 659b758be75acf9c2a25e3e7b59dbc902bd9446d Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Mon, 6 Oct 2025 19:58:58 +1100
Subject: [PATCH 1778/1889] Make `DepNodeColor` tri-value.

Currently it's binary, either `Green` or `Red`. But it's almost always
used within an `Option`. So it's a bit neater, and possibly slightly
faster, to make it tri-value with `Unknown` as a first-class variant.
---
 .../rustc_query_system/src/dep_graph/graph.rs | 65 ++++++++-----------
 .../src/dep_graph/serialized.rs               |  5 +-
 2 files changed, 31 insertions(+), 39 deletions(-)

diff --git a/compiler/rustc_query_system/src/dep_graph/graph.rs b/compiler/rustc_query_system/src/dep_graph/graph.rs
index 550dd4a7b2deb..9c2b498901d86 100644
--- a/compiler/rustc_query_system/src/dep_graph/graph.rs
+++ b/compiler/rustc_query_system/src/dep_graph/graph.rs
@@ -68,20 +68,11 @@ pub struct MarkFrame<'a> {
 
 #[derive(Debug)]
 pub(super) enum DepNodeColor {
+    Unknown,
     Red,
     Green(DepNodeIndex),
 }
 
-impl DepNodeColor {
-    #[inline]
-    fn is_green(self) -> bool {
-        match self {
-            DepNodeColor::Red => false,
-            DepNodeColor::Green(_) => true,
-        }
-    }
-}
-
 pub(crate) struct DepGraphData<D: Deps> {
     /// The new encoding of the dependency graph, optimized for red/green
     /// tracking. The `current` field is the dependency graph of only the
@@ -624,7 +615,7 @@ impl<D: Deps> DepGraphData<D> {
     ) {
         if let Some(prev_index) = self.previous.node_to_index_opt(dep_node) {
             let current = self.colors.get(prev_index);
-            assert!(current.is_none(), "{}", msg())
+            assert_matches!(current, DepNodeColor::Unknown, "{}", msg())
         } else if let Some(nodes_in_current_session) = &self.current.nodes_in_current_session {
             outline(|| {
                 let seen = nodes_in_current_session.lock().contains_key(dep_node);
@@ -633,12 +624,12 @@ impl<D: Deps> DepGraphData<D> {
         }
     }
 
-    fn node_color(&self, dep_node: &DepNode) -> Option<DepNodeColor> {
+    fn node_color(&self, dep_node: &DepNode) -> DepNodeColor {
         if let Some(prev_index) = self.previous.node_to_index_opt(dep_node) {
             self.colors.get(prev_index)
         } else {
             // This is a node that did not exist in the previous compilation session.
-            None
+            DepNodeColor::Unknown
         }
     }
 
@@ -646,7 +637,7 @@ impl<D: Deps> DepGraphData<D> {
     /// current compilation session. Used in various assertions
     #[inline]
     pub(crate) fn is_index_green(&self, prev_index: SerializedDepNodeIndex) -> bool {
-        self.colors.get(prev_index).is_some_and(|c| c.is_green())
+        matches!(self.colors.get(prev_index), DepNodeColor::Green(_))
     }
 
     #[inline]
@@ -820,12 +811,12 @@ impl<D: Deps> DepGraph<D> {
         self.data.as_ref()?.dep_node_debug.borrow().get(&dep_node).cloned()
     }
 
-    fn node_color(&self, dep_node: &DepNode) -> Option<DepNodeColor> {
+    fn node_color(&self, dep_node: &DepNode) -> DepNodeColor {
         if let Some(ref data) = self.data {
             return data.node_color(dep_node);
         }
 
-        None
+        DepNodeColor::Unknown
     }
 
     pub fn try_mark_green<Qcx: QueryContext<Deps = D>>(
@@ -854,9 +845,9 @@ impl<D: Deps> DepGraphData<D> {
         let prev_index = self.previous.node_to_index_opt(dep_node)?;
 
         match self.colors.get(prev_index) {
-            Some(DepNodeColor::Green(dep_node_index)) => Some((prev_index, dep_node_index)),
-            Some(DepNodeColor::Red) => None,
-            None => {
+            DepNodeColor::Green(dep_node_index) => Some((prev_index, dep_node_index)),
+            DepNodeColor::Red => None,
+            DepNodeColor::Unknown => {
                 // This DepNode and the corresponding query invocation existed
                 // in the previous compilation session too, so we can try to
                 // mark it as green by recursively marking all of its
@@ -877,7 +868,7 @@ impl<D: Deps> DepGraphData<D> {
         let get_dep_dep_node = || self.previous.index_to_node(parent_dep_node_index);
 
         match self.colors.get(parent_dep_node_index) {
-            Some(DepNodeColor::Green(_)) => {
+            DepNodeColor::Green(_) => {
                 // This dependency has been marked as green before, we are
                 // still fine and can continue with checking the other
                 // dependencies.
@@ -888,7 +879,7 @@ impl<D: Deps> DepGraphData<D> {
                 debug!("dependency {:?} was immediately green", get_dep_dep_node());
                 return Some(());
             }
-            Some(DepNodeColor::Red) => {
+            DepNodeColor::Red => {
                 // We found a dependency the value of which has changed
                 // compared to the previous compilation session. We cannot
                 // mark the DepNode as green and also don't need to bother
@@ -896,7 +887,7 @@ impl<D: Deps> DepGraphData<D> {
                 debug!("dependency {:?} was immediately red", get_dep_dep_node());
                 return None;
             }
-            None => {}
+            DepNodeColor::Unknown => {}
         }
 
         let dep_dep_node = &get_dep_dep_node();
@@ -927,15 +918,15 @@ impl<D: Deps> DepGraphData<D> {
         }
 
         match self.colors.get(parent_dep_node_index) {
-            Some(DepNodeColor::Green(_)) => {
+            DepNodeColor::Green(_) => {
                 debug!("managed to FORCE dependency {dep_dep_node:?} to green");
                 return Some(());
             }
-            Some(DepNodeColor::Red) => {
+            DepNodeColor::Red => {
                 debug!("dependency {dep_dep_node:?} was red after forcing");
                 return None;
             }
-            None => {}
+            DepNodeColor::Unknown => {}
         }
 
         if let None = qcx.dep_context().sess().dcx().has_errors_or_delayed_bugs() {
@@ -1000,13 +991,13 @@ impl<D: Deps> DepGraph<D> {
     /// Returns true if the given node has been marked as red during the
     /// current compilation session. Used in various assertions
     pub fn is_red(&self, dep_node: &DepNode) -> bool {
-        matches!(self.node_color(dep_node), Some(DepNodeColor::Red))
+        matches!(self.node_color(dep_node), DepNodeColor::Red)
     }
 
     /// Returns true if the given node has been marked as green during the
     /// current compilation session. Used in various assertions
     pub fn is_green(&self, dep_node: &DepNode) -> bool {
-        self.node_color(dep_node).is_some_and(|c| c.is_green())
+        matches!(self.node_color(dep_node), DepNodeColor::Green(_))
     }
 
     pub fn assert_dep_node_not_yet_allocated_in_current_session<S: std::fmt::Display>(
@@ -1033,11 +1024,11 @@ impl<D: Deps> DepGraph<D> {
         let data = self.data.as_ref().unwrap();
         for prev_index in data.colors.values.indices() {
             match data.colors.get(prev_index) {
-                Some(DepNodeColor::Green(_)) => {
+                DepNodeColor::Green(_) => {
                     let dep_node = data.previous.index_to_node(prev_index);
                     tcx.try_load_from_on_disk_cache(dep_node);
                 }
-                None | Some(DepNodeColor::Red) => {
+                DepNodeColor::Unknown | DepNodeColor::Red => {
                     // We can skip red nodes because a node can only be marked
                     // as red if the query result was recomputed and thus is
                     // already in memory.
@@ -1324,14 +1315,14 @@ pub(super) struct DepNodeColorMap {
     sync: bool,
 }
 
-const COMPRESSED_NONE: u32 = u32::MAX;
+const COMPRESSED_UNKNOWN: u32 = u32::MAX;
 const COMPRESSED_RED: u32 = u32::MAX - 1;
 
 impl DepNodeColorMap {
     fn new(size: usize) -> DepNodeColorMap {
         debug_assert!(COMPRESSED_RED > DepNodeIndex::MAX_AS_U32);
         DepNodeColorMap {
-            values: (0..size).map(|_| AtomicU32::new(COMPRESSED_NONE)).collect(),
+            values: (0..size).map(|_| AtomicU32::new(COMPRESSED_UNKNOWN)).collect(),
             sync: is_dyn_thread_safe(),
         }
     }
@@ -1354,7 +1345,7 @@ impl DepNodeColorMap {
         let value = &self.values[prev_index];
         if self.sync {
             match value.compare_exchange(
-                COMPRESSED_NONE,
+                COMPRESSED_UNKNOWN,
                 index.as_u32(),
                 Ordering::Relaxed,
                 Ordering::Relaxed,
@@ -1364,7 +1355,7 @@ impl DepNodeColorMap {
             }
         } else {
             let v = value.load(Ordering::Relaxed);
-            if v == COMPRESSED_NONE {
+            if v == COMPRESSED_UNKNOWN {
                 value.store(index.as_u32(), Ordering::Relaxed);
                 Ok(())
             } else {
@@ -1374,11 +1365,11 @@ impl DepNodeColorMap {
     }
 
     #[inline]
-    pub(super) fn get(&self, index: SerializedDepNodeIndex) -> Option<DepNodeColor> {
+    pub(super) fn get(&self, index: SerializedDepNodeIndex) -> DepNodeColor {
         match self.values[index].load(Ordering::Acquire) {
-            COMPRESSED_NONE => None,
-            COMPRESSED_RED => Some(DepNodeColor::Red),
-            value => Some(DepNodeColor::Green(DepNodeIndex::from_u32(value))),
+            COMPRESSED_UNKNOWN => DepNodeColor::Unknown,
+            COMPRESSED_RED => DepNodeColor::Red,
+            value => DepNodeColor::Green(DepNodeIndex::from_u32(value)),
         }
     }
 
diff --git a/compiler/rustc_query_system/src/dep_graph/serialized.rs b/compiler/rustc_query_system/src/dep_graph/serialized.rs
index 453002dea4b39..43cac015c32af 100644
--- a/compiler/rustc_query_system/src/dep_graph/serialized.rs
+++ b/compiler/rustc_query_system/src/dep_graph/serialized.rs
@@ -914,8 +914,9 @@ impl<D: Deps> GraphEncoder<D> {
         index
     }
 
-    /// Encodes a node that was promoted from the previous graph. It reads the information directly from
-    /// the previous dep graph and expects all edges to already have a new dep node index assigned.
+    /// Encodes a node that was promoted from the previous graph. It reads the information directly
+    /// from the previous dep graph and expects all edges to already have a new dep node index
+    /// assigned.
     ///
     /// This will also ensure the dep node is marked green.
     #[inline]

From bc930cd2d101d1b0b858e9fcf981c916721e1c2d Mon Sep 17 00:00:00 2001
From: Jynn Nelson <jynn.nelson@ferrous-systems.com>
Date: Mon, 6 Oct 2025 11:56:08 -0400
Subject: [PATCH 1779/1889] collect-license-metadata: Print a diff of the
 expected output

Previously, `x test collect-license-metadata` gave the following message
on errors:
```
gathering license information from REUSE (this might take a minute...)
finished gathering the license information from REUSE in 78.69s
loading existing license information
The existing /home/runner/work/ferrocene/ferrocene/license-metadata.json
file is out of date.
Run ./x run collect-license-metadata to update it.
Error: The existing
/home/runner/work/ferrocene/ferrocene/license-metadata.json file doesn't
match what REUSE reports.
Bootstrap failed while executing `test collect-license-metadata`
```

Notable, this doesn't actually say what went wrong.
Print a diff in addition so it's more clear what broke:
```
...
                "license": {
                   "copyright": [
+                    "2010 The Rust Project Developers",
                     "2016, 2017, 2018, 2019, 2020, 2021 AXE Consultants. All Rights",
+                    "License. Subject to the terms and conditions of this",
                     "Notice",
-                    "The Ferrocene Developers"
+                    "The Ferrocene Developers",
+                    "[yyyy] [name of copyright owner]"
                   ],
...
```

Currently, this prints the entire text of the JSON file as context.
That's not ideal, but it's rare for this to fail, so I think it's ok for
now.

I considered using `assert_json_diff` instead of `similar`, but its
errors are a lot harder to read IMO, even though they are better at
omitting unnecessary context:

```
Diff: json atoms at path ".files.children[0].children[10].license.copyright[0]" are not equal:
    lhs:
        "2016 The Fuchsia Authors"
    rhs:
        "2019 The Crossbeam Project Developers"

json atoms at path ".files.children[0].children[10].license.spdx" are not equal:
    lhs:
        "BSD-2-Clause AND (Apache-2.0 OR MIT)"
    rhs:
        "Apache-2.0 OR MIT"

json atom at path ".files.children[0].children[10].children" is missing from lhs

json atoms at path ".files.children[0].children[10].name" are not equal:
    lhs:
        "library/std/src/sys/sync/mutex/fuchsia.rs"
    rhs:
        "library/std/src/sync/mpmc"
...
```
---
 Cargo.lock                                     |  1 +
 src/tools/collect-license-metadata/Cargo.toml  |  1 +
 src/tools/collect-license-metadata/src/main.rs | 14 ++++++++++++++
 3 files changed, 16 insertions(+)

diff --git a/Cargo.lock b/Cargo.lock
index 2de9c84e3b031..68fd8a8385ecd 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -686,6 +686,7 @@ dependencies = [
  "anyhow",
  "serde",
  "serde_json",
+ "similar",
  "spdx-rs",
 ]
 
diff --git a/src/tools/collect-license-metadata/Cargo.toml b/src/tools/collect-license-metadata/Cargo.toml
index edf9e5c5393ea..f84da24428155 100644
--- a/src/tools/collect-license-metadata/Cargo.toml
+++ b/src/tools/collect-license-metadata/Cargo.toml
@@ -9,4 +9,5 @@ license = "MIT OR Apache-2.0"
 anyhow = "1.0.65"
 serde = { version = "1.0.147", features = ["derive"] }
 serde_json = "1.0.85"
+similar = "2.7.0"
 spdx-rs = "0.5.1"
diff --git a/src/tools/collect-license-metadata/src/main.rs b/src/tools/collect-license-metadata/src/main.rs
index 08a30d0b8994f..4e218ea59fda6 100644
--- a/src/tools/collect-license-metadata/src/main.rs
+++ b/src/tools/collect-license-metadata/src/main.rs
@@ -5,9 +5,21 @@ mod reuse;
 use std::path::PathBuf;
 
 use anyhow::{Context, Error};
+use similar::{ChangeTag, TextDiff};
 
 use crate::licenses::LicensesInterner;
 
+fn diff_text(expected: &str, actual: &str) {
+    for change in TextDiff::from_lines(expected, actual).iter_all_changes() {
+        let sign = match change.tag() {
+            ChangeTag::Delete => "-",
+            ChangeTag::Insert => "+",
+            ChangeTag::Equal => " ",
+        };
+        print!("{}{}", sign, change);
+    }
+}
+
 /// The entry point to the binary.
 ///
 /// You should probably let `bootstrap` execute this program instead of running it directly.
@@ -41,6 +53,8 @@ fn main() -> Result<(), Error> {
         if existing_json != output {
             eprintln!("The existing {} file is out of date.", dest.display());
             eprintln!("Run ./x run collect-license-metadata to update it.");
+            eprintln!("Diff:");
+            diff_text(&existing, &serde_json::to_string_pretty(&output).unwrap());
             anyhow::bail!("The existing {} file doesn't match what REUSE reports.", dest.display());
         }
         println!("license information matches");

From 231c39545ee4610d946ad202545869d8f4e2efc4 Mon Sep 17 00:00:00 2001
From: yukang <moorekang@gmail.com>
Date: Tue, 7 Oct 2025 10:43:07 +0800
Subject: [PATCH 1780/1889] Fix wrong span for hightlight for duplicated diff
 lines

---
 compiler/rustc_errors/src/emitter.rs          |  2 +-
 ...g-highlight-span-extra-arguments-147070.rs | 30 ++++++++
 ...-highlight-span-extra-arguments-147070.svg | 72 +++++++++++++++++++
 3 files changed, 103 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/argument-suggestions/wrong-highlight-span-extra-arguments-147070.rs
 create mode 100644 tests/ui/argument-suggestions/wrong-highlight-span-extra-arguments-147070.svg

diff --git a/compiler/rustc_errors/src/emitter.rs b/compiler/rustc_errors/src/emitter.rs
index 93b1e6b761520..aa36713834815 100644
--- a/compiler/rustc_errors/src/emitter.rs
+++ b/compiler/rustc_errors/src/emitter.rs
@@ -2412,7 +2412,7 @@ impl HumanEmitter {
                             // too bad to begin with, so we side-step that issue here.
                             for (i, line) in snippet.lines().enumerate() {
                                 let line = normalize_whitespace(line);
-                                let row = row_num - 2 - (newlines - i - 1);
+                                let row = (row_num - 2 - (newlines - i - 1)).max(2);
                                 // On the first line, we highlight between the start of the part
                                 // span, and the end of that line.
                                 // On the last line, we highlight between the start of the line, and
diff --git a/tests/ui/argument-suggestions/wrong-highlight-span-extra-arguments-147070.rs b/tests/ui/argument-suggestions/wrong-highlight-span-extra-arguments-147070.rs
new file mode 100644
index 0000000000000..65408fd028604
--- /dev/null
+++ b/tests/ui/argument-suggestions/wrong-highlight-span-extra-arguments-147070.rs
@@ -0,0 +1,30 @@
+//@ only-linux
+//@ compile-flags: --error-format=human --color=always
+
+// The hightlight span should be correct. See #147070
+struct Thingie;
+
+impl Thingie {
+    pub(crate) fn new(
+        _a: String,
+        _b: String,
+        _c: String,
+        _d: String,
+        _e: String,
+        _f: String,
+    ) -> Self {
+        unimplemented!()
+    }
+}
+
+fn main() {
+    let foo = Thingie::new(
+        String::from(""),
+        String::from(""),
+        String::from(""),
+        String::from(""),
+        String::from(""),
+        String::from(""),
+        String::from(""),
+    );
+}
diff --git a/tests/ui/argument-suggestions/wrong-highlight-span-extra-arguments-147070.svg b/tests/ui/argument-suggestions/wrong-highlight-span-extra-arguments-147070.svg
new file mode 100644
index 0000000000000..67f9436b6a527
--- /dev/null
+++ b/tests/ui/argument-suggestions/wrong-highlight-span-extra-arguments-147070.svg
@@ -0,0 +1,72 @@
+<svg width="970px" height="434px" xmlns="http://www.w3.org/2000/svg">
+  <style>
+    .fg { fill: #AAAAAA }
+    .bg { fill: #000000 }
+    .fg-ansi256-009 { fill: #FF5555 }
+    .fg-ansi256-010 { fill: #55FF55 }
+    .fg-ansi256-012 { fill: #5555FF }
+    .fg-ansi256-014 { fill: #55FFFF }
+    .container {
+      padding: 0 10px;
+      line-height: 18px;
+    }
+    .bold { font-weight: bold; }
+    tspan {
+      font: 14px SFMono-Regular, Consolas, Liberation Mono, Menlo, monospace;
+      white-space: pre;
+      line-height: 18px;
+    }
+  </style>
+
+  <rect width="100%" height="100%" y="0" rx="4.5" class="bg" />
+
+  <text xml:space="preserve" class="container fg">
+    <tspan x="10px" y="28px"><tspan class="fg-ansi256-009 bold">error[E0061]</tspan><tspan class="bold">: this function takes 6 arguments but 7 arguments were supplied</tspan>
+</tspan>
+    <tspan x="10px" y="46px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/wrong-highlight-span-extra-arguments-147070.rs:21:15</tspan>
+</tspan>
+    <tspan x="10px" y="64px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="82px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>     let foo = Thingie::new(</tspan>
+</tspan>
+    <tspan x="10px" y="100px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>               </tspan><tspan class="fg-ansi256-009 bold">^^^^^^^^^^^^</tspan>
+</tspan>
+    <tspan x="10px" y="118px"><tspan class="fg-ansi256-012 bold">...</tspan>
+</tspan>
+    <tspan x="10px" y="136px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         String::from(""),</tspan>
+</tspan>
+    <tspan x="10px" y="154px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>         </tspan><tspan class="fg-ansi256-012 bold">----------------</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">unexpected argument #7 of type `String`</tspan>
+</tspan>
+    <tspan x="10px" y="172px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="190px"><tspan class="fg-ansi256-010 bold">note</tspan><tspan>: associated function defined here</tspan>
+</tspan>
+    <tspan x="10px" y="208px"><tspan>  </tspan><tspan class="fg-ansi256-012 bold">--&gt; </tspan><tspan>$DIR/wrong-highlight-span-extra-arguments-147070.rs:8:19</tspan>
+</tspan>
+    <tspan x="10px" y="226px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="244px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>     pub(crate) fn new(</tspan>
+</tspan>
+    <tspan x="10px" y="262px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan><tspan>                   </tspan><tspan class="fg-ansi256-010 bold">^^^</tspan>
+</tspan>
+    <tspan x="10px" y="280px"><tspan class="fg-ansi256-014 bold">help</tspan><tspan>: remove the extra argument</tspan>
+</tspan>
+    <tspan x="10px" y="298px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="316px"><tspan class="fg-ansi256-012 bold">LL</tspan><tspan> </tspan><tspan class="fg-ansi256-009">-         String::from(""),</tspan>
+</tspan>
+    <tspan x="10px" y="334px"><tspan>   </tspan><tspan class="fg-ansi256-012 bold">|</tspan>
+</tspan>
+    <tspan x="10px" y="352px">
+</tspan>
+    <tspan x="10px" y="370px"><tspan class="fg-ansi256-009 bold">error</tspan><tspan class="bold">: aborting due to 1 previous error</tspan>
+</tspan>
+    <tspan x="10px" y="388px">
+</tspan>
+    <tspan x="10px" y="406px"><tspan class="bold">For more information about this error, try `rustc --explain E0061`.</tspan>
+</tspan>
+    <tspan x="10px" y="424px">
+</tspan>
+  </text>
+
+</svg>

From ed6a137a3219554a18fbfa3b8ee1bd39e48bbb82 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Mon, 6 Oct 2025 20:09:22 +1100
Subject: [PATCH 1781/1889] Tweak `DepNodeColorMap::get`.

The most common `get` case is green. This commit changes `get` to use
use `if`/`else` instead of match, so that getting green requires one
comparison instead of two.
---
 .../rustc_query_system/src/dep_graph/graph.rs | 21 ++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

diff --git a/compiler/rustc_query_system/src/dep_graph/graph.rs b/compiler/rustc_query_system/src/dep_graph/graph.rs
index 9c2b498901d86..1ae6af0946689 100644
--- a/compiler/rustc_query_system/src/dep_graph/graph.rs
+++ b/compiler/rustc_query_system/src/dep_graph/graph.rs
@@ -68,9 +68,9 @@ pub struct MarkFrame<'a> {
 
 #[derive(Debug)]
 pub(super) enum DepNodeColor {
-    Unknown,
-    Red,
     Green(DepNodeIndex),
+    Red,
+    Unknown,
 }
 
 pub(crate) struct DepGraphData<D: Deps> {
@@ -1315,8 +1315,9 @@ pub(super) struct DepNodeColorMap {
     sync: bool,
 }
 
-const COMPRESSED_UNKNOWN: u32 = u32::MAX;
+// All values below `COMPRESSED_RED` are green.
 const COMPRESSED_RED: u32 = u32::MAX - 1;
+const COMPRESSED_UNKNOWN: u32 = u32::MAX;
 
 impl DepNodeColorMap {
     fn new(size: usize) -> DepNodeColorMap {
@@ -1366,10 +1367,16 @@ impl DepNodeColorMap {
 
     #[inline]
     pub(super) fn get(&self, index: SerializedDepNodeIndex) -> DepNodeColor {
-        match self.values[index].load(Ordering::Acquire) {
-            COMPRESSED_UNKNOWN => DepNodeColor::Unknown,
-            COMPRESSED_RED => DepNodeColor::Red,
-            value => DepNodeColor::Green(DepNodeIndex::from_u32(value)),
+        let value = self.values[index].load(Ordering::Acquire);
+        // Green is by far the most common case. Check for that first so we can succeed with a
+        // single comparison.
+        if value < COMPRESSED_RED {
+            DepNodeColor::Green(DepNodeIndex::from_u32(value))
+        } else if value == COMPRESSED_RED {
+            DepNodeColor::Red
+        } else {
+            debug_assert_eq!(value, COMPRESSED_UNKNOWN);
+            DepNodeColor::Unknown
         }
     }
 

From 19423b7f7fea2f0fdd0f4c5f02ead37754ebe78a Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Mon, 6 Oct 2025 20:22:25 +1100
Subject: [PATCH 1782/1889] Simplify `DepNodeColorMap::try_mark_green`.

It uses a different implementation depending on whether the compiler
front-end is running single-threaded or multi-threaded. The two
implementations are equivalent and I think the multi-threaded one
expresses the intent more clearly, and I imagine the perf is similar. So
this commit removes the single-threaded code.
---
 .../rustc_query_system/src/dep_graph/graph.rs | 35 ++++++-------------
 1 file changed, 11 insertions(+), 24 deletions(-)

diff --git a/compiler/rustc_query_system/src/dep_graph/graph.rs b/compiler/rustc_query_system/src/dep_graph/graph.rs
index 1ae6af0946689..58bacb1d5d406 100644
--- a/compiler/rustc_query_system/src/dep_graph/graph.rs
+++ b/compiler/rustc_query_system/src/dep_graph/graph.rs
@@ -11,7 +11,7 @@ use rustc_data_structures::outline;
 use rustc_data_structures::profiling::QueryInvocationId;
 use rustc_data_structures::sharded::{self, ShardedHashMap};
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
-use rustc_data_structures::sync::{AtomicU64, Lock, is_dyn_thread_safe};
+use rustc_data_structures::sync::{AtomicU64, Lock};
 use rustc_data_structures::unord::UnordMap;
 use rustc_errors::DiagInner;
 use rustc_index::IndexVec;
@@ -1308,11 +1308,11 @@ impl Default for TaskDeps {
         }
     }
 }
+
 // A data structure that stores Option<DepNodeColor> values as a contiguous
 // array, using one u32 per entry.
 pub(super) struct DepNodeColorMap {
     values: IndexVec<SerializedDepNodeIndex, AtomicU32>,
-    sync: bool,
 }
 
 // All values below `COMPRESSED_RED` are green.
@@ -1322,10 +1322,7 @@ const COMPRESSED_UNKNOWN: u32 = u32::MAX;
 impl DepNodeColorMap {
     fn new(size: usize) -> DepNodeColorMap {
         debug_assert!(COMPRESSED_RED > DepNodeIndex::MAX_AS_U32);
-        DepNodeColorMap {
-            values: (0..size).map(|_| AtomicU32::new(COMPRESSED_UNKNOWN)).collect(),
-            sync: is_dyn_thread_safe(),
-        }
+        DepNodeColorMap { values: (0..size).map(|_| AtomicU32::new(COMPRESSED_UNKNOWN)).collect() }
     }
 
     #[inline]
@@ -1344,24 +1341,14 @@ impl DepNodeColorMap {
         index: DepNodeIndex,
     ) -> Result<(), DepNodeIndex> {
         let value = &self.values[prev_index];
-        if self.sync {
-            match value.compare_exchange(
-                COMPRESSED_UNKNOWN,
-                index.as_u32(),
-                Ordering::Relaxed,
-                Ordering::Relaxed,
-            ) {
-                Ok(_) => Ok(()),
-                Err(v) => Err(DepNodeIndex::from_u32(v)),
-            }
-        } else {
-            let v = value.load(Ordering::Relaxed);
-            if v == COMPRESSED_UNKNOWN {
-                value.store(index.as_u32(), Ordering::Relaxed);
-                Ok(())
-            } else {
-                Err(DepNodeIndex::from_u32(v))
-            }
+        match value.compare_exchange(
+            COMPRESSED_UNKNOWN,
+            index.as_u32(),
+            Ordering::Relaxed,
+            Ordering::Relaxed,
+        ) {
+            Ok(_) => Ok(()),
+            Err(v) => Err(DepNodeIndex::from_u32(v)),
         }
     }
 

From 525ed4cc5cfc9a8230deccf92edd4a41fbebc8ee Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 7 Oct 2025 17:26:01 +1100
Subject: [PATCH 1783/1889] Read the whole test file before parsing directives

Few tests are larger than a handful of kilobytes, and nowadays we scan the
whole file for directives anyway, so there's little reason not to just read the
whole thing up-front.

This avoids having to deal with I/O within `iter_directives`, which should make
it easier to overhaul directive processing.
---
 src/tools/compiletest/src/directives.rs       | 37 +++++++------------
 src/tools/compiletest/src/directives/tests.rs | 36 ++++++++----------
 src/tools/compiletest/src/lib.rs              |  5 ++-
 3 files changed, 32 insertions(+), 46 deletions(-)

diff --git a/src/tools/compiletest/src/directives.rs b/src/tools/compiletest/src/directives.rs
index dab6850e0d62a..34ecbc2d59f10 100644
--- a/src/tools/compiletest/src/directives.rs
+++ b/src/tools/compiletest/src/directives.rs
@@ -1,9 +1,6 @@
 use std::collections::HashSet;
-use std::env;
-use std::fs::File;
-use std::io::BufReader;
-use std::io::prelude::*;
 use std::process::Command;
+use std::{env, fs};
 
 use camino::{Utf8Path, Utf8PathBuf};
 use semver::Version;
@@ -54,18 +51,19 @@ pub struct EarlyProps {
 
 impl EarlyProps {
     pub fn from_file(config: &Config, testfile: &Utf8Path) -> Self {
-        let file = File::open(testfile.as_std_path()).expect("open test file to parse earlyprops");
-        Self::from_reader(config, testfile, file)
+        let file_contents =
+            fs::read_to_string(testfile).expect("read test file to parse earlyprops");
+        Self::from_file_contents(config, testfile, &file_contents)
     }
 
-    pub fn from_reader<R: Read>(config: &Config, testfile: &Utf8Path, rdr: R) -> Self {
+    pub fn from_file_contents(config: &Config, testfile: &Utf8Path, file_contents: &str) -> Self {
         let mut props = EarlyProps::default();
         let mut poisoned = false;
         iter_directives(
             config.mode,
             &mut poisoned,
             testfile,
-            rdr,
+            file_contents,
             // (dummy comment to force args into vertical layout)
             &mut |ref ln: DirectiveLine<'_>| {
                 parse_and_update_aux(config, ln, testfile, &mut props.aux);
@@ -362,7 +360,7 @@ impl TestProps {
     fn load_from(&mut self, testfile: &Utf8Path, test_revision: Option<&str>, config: &Config) {
         let mut has_edition = false;
         if !testfile.is_dir() {
-            let file = File::open(testfile.as_std_path()).unwrap();
+            let file_contents = fs::read_to_string(testfile).unwrap();
 
             let mut poisoned = false;
 
@@ -370,7 +368,7 @@ impl TestProps {
                 config.mode,
                 &mut poisoned,
                 testfile,
-                file,
+                &file_contents,
                 &mut |ref ln: DirectiveLine<'_>| {
                     if !ln.applies_to_test_revision(test_revision) {
                         return;
@@ -859,7 +857,7 @@ fn iter_directives(
     mode: TestMode,
     poisoned: &mut bool,
     testfile: &Utf8Path,
-    rdr: impl Read,
+    file_contents: &str,
     it: &mut dyn FnMut(DirectiveLine<'_>),
 ) {
     if testfile.is_dir() {
@@ -886,16 +884,7 @@ fn iter_directives(
         }
     }
 
-    let mut rdr = BufReader::with_capacity(1024, rdr);
-    let mut ln = String::new();
-    let mut line_number = 0;
-
-    loop {
-        line_number += 1;
-        ln.clear();
-        if rdr.read_line(&mut ln).unwrap() == 0 {
-            break;
-        }
+    for (line_number, ln) in (1..).zip(file_contents.lines()) {
         let ln = ln.trim();
 
         let Some(directive_line) = line_directive(line_number, ln) else {
@@ -1359,13 +1348,13 @@ where
     Some((min, max))
 }
 
-pub(crate) fn make_test_description<R: Read>(
+pub(crate) fn make_test_description(
     config: &Config,
     cache: &DirectivesCache,
     name: String,
     path: &Utf8Path,
     filterable_path: &Utf8Path,
-    src: R,
+    file_contents: &str,
     test_revision: Option<&str>,
     poisoned: &mut bool,
 ) -> CollectedTestDesc {
@@ -1380,7 +1369,7 @@ pub(crate) fn make_test_description<R: Read>(
         config.mode,
         &mut local_poisoned,
         path,
-        src,
+        file_contents,
         &mut |ref ln @ DirectiveLine { line_number, .. }| {
             if !ln.applies_to_test_revision(test_revision) {
                 return;
diff --git a/src/tools/compiletest/src/directives/tests.rs b/src/tools/compiletest/src/directives/tests.rs
index 95dd46532ba88..77080c7469371 100644
--- a/src/tools/compiletest/src/directives/tests.rs
+++ b/src/tools/compiletest/src/directives/tests.rs
@@ -1,5 +1,3 @@
-use std::io::Read;
-
 use camino::Utf8Path;
 use semver::Version;
 
@@ -10,12 +8,12 @@ use crate::directives::{
 };
 use crate::executor::{CollectedTestDesc, ShouldPanic};
 
-fn make_test_description<R: Read>(
+fn make_test_description(
     config: &Config,
     name: String,
     path: &Utf8Path,
     filterable_path: &Utf8Path,
-    src: R,
+    file_contents: &str,
     revision: Option<&str>,
 ) -> CollectedTestDesc {
     let cache = DirectivesCache::load(config);
@@ -26,7 +24,7 @@ fn make_test_description<R: Read>(
         name,
         path,
         filterable_path,
-        src,
+        file_contents,
         revision,
         &mut poisoned,
     );
@@ -226,14 +224,13 @@ fn cfg() -> ConfigBuilder {
 }
 
 fn parse_rs(config: &Config, contents: &str) -> EarlyProps {
-    let bytes = contents.as_bytes();
-    EarlyProps::from_reader(config, Utf8Path::new("a.rs"), bytes)
+    EarlyProps::from_file_contents(config, Utf8Path::new("a.rs"), contents)
 }
 
 fn check_ignore(config: &Config, contents: &str) -> bool {
     let tn = String::new();
     let p = Utf8Path::new("a.rs");
-    let d = make_test_description(&config, tn, p, p, std::io::Cursor::new(contents), None);
+    let d = make_test_description(&config, tn, p, p, contents, None);
     d.ignore
 }
 
@@ -243,9 +240,9 @@ fn should_fail() {
     let tn = String::new();
     let p = Utf8Path::new("a.rs");
 
-    let d = make_test_description(&config, tn.clone(), p, p, std::io::Cursor::new(""), None);
+    let d = make_test_description(&config, tn.clone(), p, p, "", None);
     assert_eq!(d.should_panic, ShouldPanic::No);
-    let d = make_test_description(&config, tn, p, p, std::io::Cursor::new("//@ should-fail"), None);
+    let d = make_test_description(&config, tn, p, p, "//@ should-fail", None);
     assert_eq!(d.should_panic, ShouldPanic::Yes);
 }
 
@@ -778,9 +775,8 @@ fn threads_support() {
     }
 }
 
-fn run_path(poisoned: &mut bool, path: &Utf8Path, buf: &[u8]) {
-    let rdr = std::io::Cursor::new(&buf);
-    iter_directives(TestMode::Ui, poisoned, path, rdr, &mut |_| {});
+fn run_path(poisoned: &mut bool, path: &Utf8Path, file_contents: &str) {
+    iter_directives(TestMode::Ui, poisoned, path, file_contents, &mut |_| {});
 }
 
 #[test]
@@ -789,7 +785,7 @@ fn test_unknown_directive_check() {
     run_path(
         &mut poisoned,
         Utf8Path::new("a.rs"),
-        include_bytes!("./test-auxillary/unknown_directive.rs"),
+        include_str!("./test-auxillary/unknown_directive.rs"),
     );
     assert!(poisoned);
 }
@@ -800,7 +796,7 @@ fn test_known_directive_check_no_error() {
     run_path(
         &mut poisoned,
         Utf8Path::new("a.rs"),
-        include_bytes!("./test-auxillary/known_directive.rs"),
+        include_str!("./test-auxillary/known_directive.rs"),
     );
     assert!(!poisoned);
 }
@@ -811,7 +807,7 @@ fn test_error_annotation_no_error() {
     run_path(
         &mut poisoned,
         Utf8Path::new("a.rs"),
-        include_bytes!("./test-auxillary/error_annotation.rs"),
+        include_str!("./test-auxillary/error_annotation.rs"),
     );
     assert!(!poisoned);
 }
@@ -822,7 +818,7 @@ fn test_non_rs_unknown_directive_not_checked() {
     run_path(
         &mut poisoned,
         Utf8Path::new("a.Makefile"),
-        include_bytes!("./test-auxillary/not_rs.Makefile"),
+        include_str!("./test-auxillary/not_rs.Makefile"),
     );
     assert!(!poisoned);
 }
@@ -830,21 +826,21 @@ fn test_non_rs_unknown_directive_not_checked() {
 #[test]
 fn test_trailing_directive() {
     let mut poisoned = false;
-    run_path(&mut poisoned, Utf8Path::new("a.rs"), b"//@ only-x86 only-arm");
+    run_path(&mut poisoned, Utf8Path::new("a.rs"), "//@ only-x86 only-arm");
     assert!(poisoned);
 }
 
 #[test]
 fn test_trailing_directive_with_comment() {
     let mut poisoned = false;
-    run_path(&mut poisoned, Utf8Path::new("a.rs"), b"//@ only-x86   only-arm with comment");
+    run_path(&mut poisoned, Utf8Path::new("a.rs"), "//@ only-x86   only-arm with comment");
     assert!(poisoned);
 }
 
 #[test]
 fn test_not_trailing_directive() {
     let mut poisoned = false;
-    run_path(&mut poisoned, Utf8Path::new("a.rs"), b"//@ revisions: incremental");
+    run_path(&mut poisoned, Utf8Path::new("a.rs"), "//@ revisions: incremental");
     assert!(!poisoned);
 }
 
diff --git a/src/tools/compiletest/src/lib.rs b/src/tools/compiletest/src/lib.rs
index 2d759279f34bc..ac1a8226112a9 100644
--- a/src/tools/compiletest/src/lib.rs
+++ b/src/tools/compiletest/src/lib.rs
@@ -892,7 +892,8 @@ fn make_test(cx: &TestCollectorCx, collector: &mut TestCollector, testpaths: &Te
     // `CollectedTest` that can be handed over to the test executor.
     collector.tests.extend(revisions.into_iter().map(|revision| {
         // Create a test name and description to hand over to the executor.
-        let src_file = fs::File::open(&test_path).expect("open test file to parse ignores");
+        let file_contents =
+            fs::read_to_string(&test_path).expect("read test file to parse ignores");
         let (test_name, filterable_path) =
             make_test_name_and_filterable_path(&cx.config, testpaths, revision);
         // Create a description struct for the test/revision.
@@ -904,7 +905,7 @@ fn make_test(cx: &TestCollectorCx, collector: &mut TestCollector, testpaths: &Te
             test_name,
             &test_path,
             &filterable_path,
-            src_file,
+            &file_contents,
             revision,
             &mut collector.poisoned,
         );

From 1589c6c12d0f984343c6090c817e1dfbb9cf6d10 Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Tue, 7 Oct 2025 09:40:27 +0200
Subject: [PATCH 1784/1889] Add regression test for `link_section` targets

---
 .../issue-43106-gating-of-builtin-attrs.rs    |  26 +++
 ...issue-43106-gating-of-builtin-attrs.stderr | 159 +++++++++---------
 2 files changed, 110 insertions(+), 75 deletions(-)

diff --git a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.rs b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.rs
index aa5aab41e7258..a0d3ed97142cb 100644
--- a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.rs
+++ b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.rs
@@ -705,6 +705,32 @@ mod link_section {
     //~| WARN previously accepted
     //~| HELP can be applied to
     //~| HELP remove the attribute
+
+    #[link_section = "1800"]
+    //~^ WARN attribute cannot be used on
+    //~| WARN previously accepted
+    //~| HELP can be applied to
+    //~| HELP remove the attribute
+    trait Tr {
+        #[link_section = "1800"]
+        fn inside_tr_no_default(&self);
+
+        #[link_section = "1800"]
+        fn inside_tr_default(&self) { }
+    }
+
+    impl S {
+        #[link_section = "1800"]
+        fn inside_abc_123(&self) { }
+    }
+
+    impl Tr for S {
+        #[link_section = "1800"]
+        fn inside_tr_no_default(&self) { }
+    }
+
+    #[link_section = "1800"]
+    fn should_always_link() { }
 }
 
 
diff --git a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr
index 2e2eea65b817a..30b6d1c9180f1 100644
--- a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr
+++ b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr
@@ -203,7 +203,7 @@ LL | #![reexport_test_harness_main = "2900"]
    |  +
 
 warning: attribute should be applied to an `extern` block with non-Rust ABI
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:713:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:739:1
    |
 LL |   #[link(name = "x")]
    |   ^^^^^^^^^^^^^^^^^^^
@@ -219,7 +219,7 @@ LL | | }
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:789:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:815:1
    |
 LL | #[windows_subsystem = "windows"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -230,7 +230,7 @@ LL | #![windows_subsystem = "windows"]
    |  +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:839:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:865:1
    |
 LL | #[crate_type = "0800"]
    | ^^^^^^^^^^^^^^^^^^^^^^
@@ -241,7 +241,7 @@ LL | #![crate_type = "0800"]
    |  +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:863:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:889:1
    |
 LL | #[feature(x0600)]
    | ^^^^^^^^^^^^^^^^^
@@ -252,7 +252,7 @@ LL | #![feature(x0600)]
    |  +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:888:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:914:1
    |
 LL | #[no_main]
    | ^^^^^^^^^^
@@ -263,7 +263,7 @@ LL | #![no_main]
    |  +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:912:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:938:1
    |
 LL | #[no_builtins]
    | ^^^^^^^^^^^^^^
@@ -340,7 +340,7 @@ LL |     #![reexport_test_harness_main = "2900"] impl S { }
    |      +
 
 warning: attribute should be applied to an `extern` block with non-Rust ABI
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:719:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:745:17
    |
 LL |     mod inner { #![link(name = "x")] }
    |     ------------^^^^^^^^^^^^^^^^^^^^-- not an `extern` block
@@ -348,7 +348,7 @@ LL |     mod inner { #![link(name = "x")] }
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to an `extern` block with non-Rust ABI
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:724:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:750:5
    |
 LL |     #[link(name = "x")] fn f() { }
    |     ^^^^^^^^^^^^^^^^^^^ ---------- not an `extern` block
@@ -356,7 +356,7 @@ LL |     #[link(name = "x")] fn f() { }
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to an `extern` block with non-Rust ABI
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:729:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:755:5
    |
 LL |     #[link(name = "x")] struct S;
    |     ^^^^^^^^^^^^^^^^^^^ --------- not an `extern` block
@@ -364,7 +364,7 @@ LL |     #[link(name = "x")] struct S;
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to an `extern` block with non-Rust ABI
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:734:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:760:5
    |
 LL |     #[link(name = "x")] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^ ----------- not an `extern` block
@@ -372,7 +372,7 @@ LL |     #[link(name = "x")] type T = S;
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to an `extern` block with non-Rust ABI
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:739:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:765:5
    |
 LL |     #[link(name = "x")] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^ ---------- not an `extern` block
@@ -380,7 +380,7 @@ LL |     #[link(name = "x")] impl S { }
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to an `extern` block with non-Rust ABI
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:744:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:770:5
    |
 LL |     #[link(name = "x")] extern "Rust" {}
    |     ^^^^^^^^^^^^^^^^^^^
@@ -388,13 +388,13 @@ LL |     #[link(name = "x")] extern "Rust" {}
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: crate-level attribute should be in the root module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:793:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:819:17
    |
 LL |     mod inner { #![windows_subsystem="windows"] }
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:796:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:822:5
    |
 LL |     #[windows_subsystem = "windows"] fn f() { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -405,7 +405,7 @@ LL |     #![windows_subsystem = "windows"] fn f() { }
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:800:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:826:5
    |
 LL |     #[windows_subsystem = "windows"] struct S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -416,7 +416,7 @@ LL |     #![windows_subsystem = "windows"] struct S;
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:804:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:830:5
    |
 LL |     #[windows_subsystem = "windows"] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -427,7 +427,7 @@ LL |     #![windows_subsystem = "windows"] type T = S;
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:808:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:834:5
    |
 LL |     #[windows_subsystem = "windows"] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -438,13 +438,13 @@ LL |     #![windows_subsystem = "windows"] impl S { }
    |      +
 
 warning: crate-level attribute should be in the root module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:843:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:869:17
    |
 LL |     mod inner { #![crate_type="0800"] }
    |                 ^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:846:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:872:5
    |
 LL |     #[crate_type = "0800"] fn f() { }
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -455,7 +455,7 @@ LL |     #![crate_type = "0800"] fn f() { }
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:850:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:876:5
    |
 LL |     #[crate_type = "0800"] struct S;
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -466,7 +466,7 @@ LL |     #![crate_type = "0800"] struct S;
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:854:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:880:5
    |
 LL |     #[crate_type = "0800"] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -477,7 +477,7 @@ LL |     #![crate_type = "0800"] type T = S;
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:858:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:884:5
    |
 LL |     #[crate_type = "0800"] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -488,13 +488,13 @@ LL |     #![crate_type = "0800"] impl S { }
    |      +
 
 warning: crate-level attribute should be in the root module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:867:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:893:17
    |
 LL |     mod inner { #![feature(x0600)] }
    |                 ^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:870:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:896:5
    |
 LL |     #[feature(x0600)] fn f() { }
    |     ^^^^^^^^^^^^^^^^^
@@ -505,7 +505,7 @@ LL |     #![feature(x0600)] fn f() { }
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:874:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:900:5
    |
 LL |     #[feature(x0600)] struct S;
    |     ^^^^^^^^^^^^^^^^^
@@ -516,7 +516,7 @@ LL |     #![feature(x0600)] struct S;
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:878:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:904:5
    |
 LL |     #[feature(x0600)] type T = S;
    |     ^^^^^^^^^^^^^^^^^
@@ -527,7 +527,7 @@ LL |     #![feature(x0600)] type T = S;
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:882:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:908:5
    |
 LL |     #[feature(x0600)] impl S { }
    |     ^^^^^^^^^^^^^^^^^
@@ -538,13 +538,13 @@ LL |     #![feature(x0600)] impl S { }
    |      +
 
 warning: crate-level attribute should be in the root module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:892:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:918:17
    |
 LL |     mod inner { #![no_main] }
    |                 ^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:895:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:921:5
    |
 LL |     #[no_main] fn f() { }
    |     ^^^^^^^^^^
@@ -555,7 +555,7 @@ LL |     #![no_main] fn f() { }
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:899:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:925:5
    |
 LL |     #[no_main] struct S;
    |     ^^^^^^^^^^
@@ -566,7 +566,7 @@ LL |     #![no_main] struct S;
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:903:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:929:5
    |
 LL |     #[no_main] type T = S;
    |     ^^^^^^^^^^
@@ -577,7 +577,7 @@ LL |     #![no_main] type T = S;
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:907:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:933:5
    |
 LL |     #[no_main] impl S { }
    |     ^^^^^^^^^^
@@ -588,13 +588,13 @@ LL |     #![no_main] impl S { }
    |      +
 
 warning: crate-level attribute should be in the root module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:916:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:942:17
    |
 LL |     mod inner { #![no_builtins] }
    |                 ^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:919:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:945:5
    |
 LL |     #[no_builtins] fn f() { }
    |     ^^^^^^^^^^^^^^
@@ -605,7 +605,7 @@ LL |     #![no_builtins] fn f() { }
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:923:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:949:5
    |
 LL |     #[no_builtins] struct S;
    |     ^^^^^^^^^^^^^^
@@ -616,7 +616,7 @@ LL |     #![no_builtins] struct S;
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:927:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:953:5
    |
 LL |     #[no_builtins] type T = S;
    |     ^^^^^^^^^^^^^^
@@ -627,7 +627,7 @@ LL |     #![no_builtins] type T = S;
    |      +
 
 warning: crate-level attribute should be an inner attribute
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:931:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:957:5
    |
 LL |     #[no_builtins] impl S { }
    |     ^^^^^^^^^^^^^^
@@ -1274,8 +1274,17 @@ LL |     #[link_section = "1800"] impl S { }
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = help: `#[link_section]` can be applied to functions and statics
 
+warning: `#[link_section]` attribute cannot be used on traits
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:709:5
+   |
+LL |     #[link_section = "1800"]
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = help: `#[link_section]` can be applied to functions and statics
+
 warning: `#[must_use]` attribute cannot be used on modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:764:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:790:1
    |
 LL | #[must_use]
    | ^^^^^^^^^^^
@@ -1284,7 +1293,7 @@ LL | #[must_use]
    = help: `#[must_use]` can be applied to functions, data types, unions, and traits
 
 warning: `#[must_use]` attribute cannot be used on modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:769:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:795:17
    |
 LL |     mod inner { #![must_use] }
    |                 ^^^^^^^^^^^^
@@ -1293,7 +1302,7 @@ LL |     mod inner { #![must_use] }
    = help: `#[must_use]` can be applied to functions, data types, unions, and traits
 
 warning: `#[must_use]` attribute cannot be used on type aliases
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:778:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:804:5
    |
 LL |     #[must_use] type T = S;
    |     ^^^^^^^^^^^
@@ -1302,7 +1311,7 @@ LL |     #[must_use] type T = S;
    = help: `#[must_use]` can be applied to functions, data types, unions, and traits
 
 warning: `#[must_use]` attribute cannot be used on inherent impl blocks
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:783:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:809:5
    |
 LL |     #[must_use] impl S { }
    |     ^^^^^^^^^^^
@@ -1311,13 +1320,13 @@ LL |     #[must_use] impl S { }
    = help: `#[must_use]` can be applied to functions, data types, unions, and traits
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![crate_name]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:815:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:841:1
    |
 LL | #[crate_name = "0900"]
    | ^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:817:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:843:1
    |
 LL | / mod crate_name {
 LL | |
@@ -1327,67 +1336,67 @@ LL | | }
    | |_^
 
 warning: the `#![crate_name]` attribute can only be used at the crate root
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:819:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:845:17
    |
 LL |     mod inner { #![crate_name="0900"] }
    |                 ^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![crate_name]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:822:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:848:5
    |
 LL |     #[crate_name = "0900"] fn f() { }
    |     ^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this function
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:822:28
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:848:28
    |
 LL |     #[crate_name = "0900"] fn f() { }
    |                            ^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![crate_name]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:826:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:852:5
    |
 LL |     #[crate_name = "0900"] struct S;
    |     ^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this struct
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:826:28
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:852:28
    |
 LL |     #[crate_name = "0900"] struct S;
    |                            ^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![crate_name]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:830:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:856:5
    |
 LL |     #[crate_name = "0900"] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this type alias
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:830:28
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:856:28
    |
 LL |     #[crate_name = "0900"] type T = S;
    |                            ^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![crate_name]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:834:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:860:5
    |
 LL |     #[crate_name = "0900"] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this implementation block
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:834:28
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:860:28
    |
 LL |     #[crate_name = "0900"] impl S { }
    |                            ^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![recursion_limit]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:936:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:962:1
    |
 LL | #[recursion_limit="0200"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:938:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:964:1
    |
 LL | / mod recursion_limit {
 LL | |
@@ -1397,67 +1406,67 @@ LL | | }
    | |_^
 
 warning: the `#![recursion_limit]` attribute can only be used at the crate root
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:940:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:966:17
    |
 LL |     mod inner { #![recursion_limit="0200"] }
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![recursion_limit]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:943:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:969:5
    |
 LL |     #[recursion_limit="0200"] fn f() { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this function
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:943:31
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:969:31
    |
 LL |     #[recursion_limit="0200"] fn f() { }
    |                               ^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![recursion_limit]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:947:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:973:5
    |
 LL |     #[recursion_limit="0200"] struct S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this struct
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:947:31
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:973:31
    |
 LL |     #[recursion_limit="0200"] struct S;
    |                               ^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![recursion_limit]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:951:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:977:5
    |
 LL |     #[recursion_limit="0200"] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this type alias
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:951:31
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:977:31
    |
 LL |     #[recursion_limit="0200"] type T = S;
    |                               ^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![recursion_limit]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:955:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:981:5
    |
 LL |     #[recursion_limit="0200"] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this implementation block
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:955:31
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:981:31
    |
 LL |     #[recursion_limit="0200"] impl S { }
    |                               ^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![type_length_limit]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:960:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:986:1
    |
 LL | #[type_length_limit="0100"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:962:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:988:1
    |
 LL | / mod type_length_limit {
 LL | |
@@ -1467,55 +1476,55 @@ LL | | }
    | |_^
 
 warning: the `#![type_length_limit]` attribute can only be used at the crate root
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:964:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:990:17
    |
 LL |     mod inner { #![type_length_limit="0100"] }
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![type_length_limit]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:967:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:993:5
    |
 LL |     #[type_length_limit="0100"] fn f() { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this function
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:967:33
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:993:33
    |
 LL |     #[type_length_limit="0100"] fn f() { }
    |                                 ^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![type_length_limit]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:971:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:997:5
    |
 LL |     #[type_length_limit="0100"] struct S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this struct
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:971:33
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:997:33
    |
 LL |     #[type_length_limit="0100"] struct S;
    |                                 ^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![type_length_limit]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:975:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:1001:5
    |
 LL |     #[type_length_limit="0100"] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this type alias
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:975:33
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:1001:33
    |
 LL |     #[type_length_limit="0100"] type T = S;
    |                                 ^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![type_length_limit]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:979:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:1005:5
    |
 LL |     #[type_length_limit="0100"] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: This attribute does not have an `!`, which means it is applied to this implementation block
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:979:33
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:1005:33
    |
 LL |     #[type_length_limit="0100"] impl S { }
    |                                 ^^^^^^^^^^
@@ -1583,5 +1592,5 @@ LL | #![must_use]
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = help: `#[must_use]` can be applied to functions, data types, unions, and traits
 
-warning: 173 warnings emitted
+warning: 174 warnings emitted
 

From 0fe466cc25975a5d531a546ec7cce2f38f3e0d6a Mon Sep 17 00:00:00 2001
From: "Tim (Theemathas) Chirananthavat" <theemathas@gmail.com>
Date: Tue, 7 Oct 2025 14:47:39 +0700
Subject: [PATCH 1785/1889] Fix doc comment

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

diff --git a/compiler/rustc_middle/src/thir.rs b/compiler/rustc_middle/src/thir.rs
index f1d19800a7891..eed27345b747b 100644
--- a/compiler/rustc_middle/src/thir.rs
+++ b/compiler/rustc_middle/src/thir.rs
@@ -839,7 +839,7 @@ pub enum PatKind<'tcx> {
     ///   exhaustiveness to cover exactly its own value, similar to `&str`, but these values are
     ///   much simpler.
     /// * raw pointers derived from integers, other raw pointers will have already resulted in an
-    //    error.
+    ///   error.
     /// * `String`, if `string_deref_patterns` is enabled.
     Constant {
         value: ty::Value<'tcx>,

From 43f7eaa0ba4cbd2537260fe223ce1e7883c405fc Mon Sep 17 00:00:00 2001
From: James Barford-Evans <james.barford-evans@arm.com>
Date: Mon, 6 Oct 2025 11:38:09 +0100
Subject: [PATCH 1786/1889] Fix; correct placement of type inference error for
 method calls

---
 compiler/rustc_hir_typeck/src/method/probe.rs | 21 ++++++++++++++-----
 ...eref-ambiguity-becomes-nonambiguous.stderr |  2 +-
 ...tion-with-leaking-placeholders.next.stderr |  2 +-
 .../hidden-type-is-opaque-2.default.stderr    |  4 ++--
 .../hidden-type-is-opaque-2.next.stderr       |  4 ++--
 ...ncompat-call-after-qualified-path-0.stderr |  2 +-
 ...ncompat-call-after-qualified-path-1.stderr |  2 +-
 tests/ui/issues/issue-20261.stderr            |  4 ++--
 tests/ui/issues/issue-2151.stderr             |  2 +-
 .../branches3.stderr                          |  8 +++----
 .../call_method_unknown_pointee.stderr        | 18 +++++++---------
 .../call_method_unknown_referent.stderr       |  8 +++----
 .../ui/proc-macro/quote/not-repeatable.stderr |  4 ++--
 ...opy-inference-side-effects-are-lazy.stderr |  2 +-
 .../issue-42234-unknown-receiver-type.stderr  |  4 +---
 .../closures_in_branches.stderr               |  4 ++--
 .../regression-issue-81317.stderr             |  2 +-
 tests/ui/typeck/issue-13853.stderr            |  4 ++--
 18 files changed, 52 insertions(+), 45 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/method/probe.rs b/compiler/rustc_hir_typeck/src/method/probe.rs
index 12f80a197b1b8..45b87cee957c9 100644
--- a/compiler/rustc_hir_typeck/src/method/probe.rs
+++ b/compiler/rustc_hir_typeck/src/method/probe.rs
@@ -7,9 +7,8 @@ use rustc_attr_parsing::is_doc_alias_attrs_contain_symbol;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_data_structures::sso::SsoHashSet;
 use rustc_errors::Applicability;
-use rustc_hir as hir;
-use rustc_hir::HirId;
 use rustc_hir::def::DefKind;
+use rustc_hir::{self as hir, ExprKind, HirId, Node};
 use rustc_hir_analysis::autoderef::{self, Autoderef};
 use rustc_infer::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse};
 use rustc_infer::infer::{BoundRegionConversionTime, DefineOpaqueTypes, InferOk, TyCtxtInferExt};
@@ -486,13 +485,25 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 let ty = self.resolve_vars_if_possible(ty.value);
                 let guar = match *ty.kind() {
                     ty::Infer(ty::TyVar(_)) => {
+                        // We want to get the variable name that the method
+                        // is being called on. If it is a method call.
+                        let err_span = match (mode, self.tcx.hir_node(scope_expr_id)) {
+                            (
+                                Mode::MethodCall,
+                                Node::Expr(hir::Expr {
+                                    kind: ExprKind::MethodCall(_, recv, ..),
+                                    ..
+                                }),
+                            ) => recv.span,
+                            _ => span,
+                        };
+
                         let raw_ptr_call = bad_ty.reached_raw_pointer
                             && !self.tcx.features().arbitrary_self_types();
-                        // FIXME: Ideally we'd use the span of the self-expr here,
-                        // not of the method path.
+
                         let mut err = self.err_ctxt().emit_inference_failure_err(
                             self.body_id,
-                            span,
+                            err_span,
                             ty.into(),
                             TypeAnnotationNeeded::E0282,
                             !raw_ptr_call,
diff --git a/tests/ui/autoref-autoderef/deref-ambiguity-becomes-nonambiguous.stderr b/tests/ui/autoref-autoderef/deref-ambiguity-becomes-nonambiguous.stderr
index 19c3c64181985..bad799b2550b9 100644
--- a/tests/ui/autoref-autoderef/deref-ambiguity-becomes-nonambiguous.stderr
+++ b/tests/ui/autoref-autoderef/deref-ambiguity-becomes-nonambiguous.stderr
@@ -5,7 +5,7 @@ LL |     let var_fn = Value::wrap();
    |         ^^^^^^
 ...
 LL |     let _ = var_fn.clone();
-   |                    ----- type must be known at this point
+   |             ------ type must be known at this point
    |
 help: consider giving `var_fn` an explicit type, where the placeholders `_` are specified
    |
diff --git a/tests/ui/closures/deduce-signature/obligation-with-leaking-placeholders.next.stderr b/tests/ui/closures/deduce-signature/obligation-with-leaking-placeholders.next.stderr
index 4bb9047b3035d..3d667f12371ab 100644
--- a/tests/ui/closures/deduce-signature/obligation-with-leaking-placeholders.next.stderr
+++ b/tests/ui/closures/deduce-signature/obligation-with-leaking-placeholders.next.stderr
@@ -5,7 +5,7 @@ LL |     needs_foo(|x| {
    |                ^
 ...
 LL |         x.to_string();
-   |           --------- type must be known at this point
+   |         - type must be known at this point
    |
 help: consider giving this closure parameter an explicit type
    |
diff --git a/tests/ui/impl-trait/hidden-type-is-opaque-2.default.stderr b/tests/ui/impl-trait/hidden-type-is-opaque-2.default.stderr
index cb383b2db3893..dca0a7b0a1a9f 100644
--- a/tests/ui/impl-trait/hidden-type-is-opaque-2.default.stderr
+++ b/tests/ui/impl-trait/hidden-type-is-opaque-2.default.stderr
@@ -5,7 +5,7 @@ LL |     Thunk::new(|mut cont| {
    |                 ^^^^^^^^
 LL |
 LL |         cont.reify_as();
-   |              -------- type must be known at this point
+   |         ---- type must be known at this point
    |
 help: consider giving this closure parameter an explicit type
    |
@@ -19,7 +19,7 @@ LL |     Thunk::new(|mut cont| {
    |                 ^^^^^^^^
 LL |
 LL |         cont.reify_as();
-   |              -------- type must be known at this point
+   |         ---- type must be known at this point
    |
 help: consider giving this closure parameter an explicit type
    |
diff --git a/tests/ui/impl-trait/hidden-type-is-opaque-2.next.stderr b/tests/ui/impl-trait/hidden-type-is-opaque-2.next.stderr
index cb383b2db3893..dca0a7b0a1a9f 100644
--- a/tests/ui/impl-trait/hidden-type-is-opaque-2.next.stderr
+++ b/tests/ui/impl-trait/hidden-type-is-opaque-2.next.stderr
@@ -5,7 +5,7 @@ LL |     Thunk::new(|mut cont| {
    |                 ^^^^^^^^
 LL |
 LL |         cont.reify_as();
-   |              -------- type must be known at this point
+   |         ---- type must be known at this point
    |
 help: consider giving this closure parameter an explicit type
    |
@@ -19,7 +19,7 @@ LL |     Thunk::new(|mut cont| {
    |                 ^^^^^^^^
 LL |
 LL |         cont.reify_as();
-   |              -------- type must be known at this point
+   |         ---- type must be known at this point
    |
 help: consider giving this closure parameter an explicit type
    |
diff --git a/tests/ui/inference/need_type_info/incompat-call-after-qualified-path-0.stderr b/tests/ui/inference/need_type_info/incompat-call-after-qualified-path-0.stderr
index ba1c81c4518a7..10056bdf3d4f4 100644
--- a/tests/ui/inference/need_type_info/incompat-call-after-qualified-path-0.stderr
+++ b/tests/ui/inference/need_type_info/incompat-call-after-qualified-path-0.stderr
@@ -2,7 +2,7 @@ error[E0282]: type annotations needed
   --> $DIR/incompat-call-after-qualified-path-0.rs:21:6
    |
 LL |   f(|a, b| a.cmp(b));
-   |      ^       --- type must be known at this point
+   |      ^     - type must be known at this point
    |
 help: consider giving this closure parameter an explicit type
    |
diff --git a/tests/ui/inference/need_type_info/incompat-call-after-qualified-path-1.stderr b/tests/ui/inference/need_type_info/incompat-call-after-qualified-path-1.stderr
index 93bba3625b540..632a9b99f84ef 100644
--- a/tests/ui/inference/need_type_info/incompat-call-after-qualified-path-1.stderr
+++ b/tests/ui/inference/need_type_info/incompat-call-after-qualified-path-1.stderr
@@ -2,7 +2,7 @@ error[E0282]: type annotations needed
   --> $DIR/incompat-call-after-qualified-path-1.rs:25:6
    |
 LL |   f(|a, b| a.cmp(b));
-   |      ^       --- type must be known at this point
+   |      ^     - type must be known at this point
    |
 help: consider giving this closure parameter an explicit type
    |
diff --git a/tests/ui/issues/issue-20261.stderr b/tests/ui/issues/issue-20261.stderr
index 6738708ca225d..c5348abb3c501 100644
--- a/tests/ui/issues/issue-20261.stderr
+++ b/tests/ui/issues/issue-20261.stderr
@@ -1,8 +1,8 @@
 error[E0282]: type annotations needed
-  --> $DIR/issue-20261.rs:4:11
+  --> $DIR/issue-20261.rs:4:9
    |
 LL |         i.clone();
-   |           ^^^^^ cannot infer type
+   |         ^ cannot infer type
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-2151.stderr b/tests/ui/issues/issue-2151.stderr
index 59fef42eb5e8b..b130f162414d0 100644
--- a/tests/ui/issues/issue-2151.stderr
+++ b/tests/ui/issues/issue-2151.stderr
@@ -4,7 +4,7 @@ error[E0282]: type annotations needed
 LL |     let x = panic!();
    |         ^
 LL |     x.clone();
-   |       ----- type must be known at this point
+   |     - type must be known at this point
    |
 help: consider giving `x` an explicit type
    |
diff --git a/tests/ui/lazy-type-alias-impl-trait/branches3.stderr b/tests/ui/lazy-type-alias-impl-trait/branches3.stderr
index 539673bc343ce..117d189867bd7 100644
--- a/tests/ui/lazy-type-alias-impl-trait/branches3.stderr
+++ b/tests/ui/lazy-type-alias-impl-trait/branches3.stderr
@@ -2,7 +2,7 @@ error[E0282]: type annotations needed
   --> $DIR/branches3.rs:9:10
    |
 LL |         |s| s.len()
-   |          ^    --- type must be known at this point
+   |          ^  - type must be known at this point
    |
 help: consider giving this closure parameter an explicit type
    |
@@ -13,7 +13,7 @@ error[E0282]: type annotations needed
   --> $DIR/branches3.rs:18:10
    |
 LL |         |s| s.len()
-   |          ^    --- type must be known at this point
+   |          ^  - type must be known at this point
    |
 help: consider giving this closure parameter an explicit type
    |
@@ -24,7 +24,7 @@ error[E0282]: type annotations needed
   --> $DIR/branches3.rs:26:10
    |
 LL |         |s| s.len()
-   |          ^    --- type must be known at this point
+   |          ^  - type must be known at this point
    |
 help: consider giving this closure parameter an explicit type
    |
@@ -35,7 +35,7 @@ error[E0282]: type annotations needed
   --> $DIR/branches3.rs:33:10
    |
 LL |         |s| s.len()
-   |          ^    --- type must be known at this point
+   |          ^  - type must be known at this point
    |
 help: consider giving this closure parameter an explicit type
    |
diff --git a/tests/ui/methods/call_method_unknown_pointee.stderr b/tests/ui/methods/call_method_unknown_pointee.stderr
index 9d0f38cf6b5c1..e20c6f8e8a17c 100644
--- a/tests/ui/methods/call_method_unknown_pointee.stderr
+++ b/tests/ui/methods/call_method_unknown_pointee.stderr
@@ -1,11 +1,10 @@
 error[E0282]: type annotations needed
-  --> $DIR/call_method_unknown_pointee.rs:10:41
+  --> $DIR/call_method_unknown_pointee.rs:10:23
    |
 LL |         let _a: i32 = (ptr as *const _).read();
-   |                                         ^^^^
-   |                                         |
-   |                                         cannot infer type
-   |                                         cannot call a method on a raw pointer with an unknown pointee type
+   |                       ^^^^^^^^^^^^^^^^^ ---- cannot call a method on a raw pointer with an unknown pointee type
+   |                       |
+   |                       cannot infer type
 
 error[E0282]: type annotations needed for `*const _`
   --> $DIR/call_method_unknown_pointee.rs:12:13
@@ -22,13 +21,12 @@ LL |         let b: *const _ = ptr as *const _;
    |              ++++++++++
 
 error[E0282]: type annotations needed
-  --> $DIR/call_method_unknown_pointee.rs:21:39
+  --> $DIR/call_method_unknown_pointee.rs:21:23
    |
 LL |         let _a: i32 = (ptr as *mut _).read();
-   |                                       ^^^^
-   |                                       |
-   |                                       cannot infer type
-   |                                       cannot call a method on a raw pointer with an unknown pointee type
+   |                       ^^^^^^^^^^^^^^^ ---- cannot call a method on a raw pointer with an unknown pointee type
+   |                       |
+   |                       cannot infer type
 
 error[E0282]: type annotations needed for `*mut _`
   --> $DIR/call_method_unknown_pointee.rs:23:13
diff --git a/tests/ui/methods/call_method_unknown_referent.stderr b/tests/ui/methods/call_method_unknown_referent.stderr
index 5d6974a00c695..35c7d9caf3efa 100644
--- a/tests/ui/methods/call_method_unknown_referent.stderr
+++ b/tests/ui/methods/call_method_unknown_referent.stderr
@@ -1,14 +1,14 @@
 error[E0282]: type annotations needed
-  --> $DIR/call_method_unknown_referent.rs:20:31
+  --> $DIR/call_method_unknown_referent.rs:20:19
    |
 LL |     let _a: i32 = (ptr as &_).read();
-   |                               ^^^^ cannot infer type
+   |                   ^^^^^^^^^^^ cannot infer type
 
 error[E0282]: type annotations needed
-  --> $DIR/call_method_unknown_referent.rs:26:37
+  --> $DIR/call_method_unknown_referent.rs:26:14
    |
 LL |     let _b = (rc as std::rc::Rc<_>).read();
-   |                                     ^^^^ cannot infer type
+   |              ^^^^^^^^^^^^^^^^^^^^^^ cannot infer type
 
 error[E0599]: no method named `read` found for struct `SmartPtr<T>` in the current scope
   --> $DIR/call_method_unknown_referent.rs:46:35
diff --git a/tests/ui/proc-macro/quote/not-repeatable.stderr b/tests/ui/proc-macro/quote/not-repeatable.stderr
index ff31799abb007..5943111efd585 100644
--- a/tests/ui/proc-macro/quote/not-repeatable.stderr
+++ b/tests/ui/proc-macro/quote/not-repeatable.stderr
@@ -21,10 +21,10 @@ note: the traits `Iterator` and `ToTokens` must be implemented
   --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
 
 error[E0282]: type annotations needed
-  --> $DIR/not-repeatable.rs:11:13
+  --> $DIR/not-repeatable.rs:11:25
    |
 LL |     let _ = quote! { $($ip)* };
-   |             ^^^^^^^^^^^^^^^^^^ cannot infer type
+   |                         ^^ cannot infer type
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/repeat-expr/copy-inference-side-effects-are-lazy.stderr b/tests/ui/repeat-expr/copy-inference-side-effects-are-lazy.stderr
index b8a8f927542f0..c98b9bb38fdb0 100644
--- a/tests/ui/repeat-expr/copy-inference-side-effects-are-lazy.stderr
+++ b/tests/ui/repeat-expr/copy-inference-side-effects-are-lazy.stderr
@@ -5,7 +5,7 @@ LL |     let x = [Foo(PhantomData); 2];
    |         ^
 LL |
 LL |     extract(x).max(2);
-   |                --- type must be known at this point
+   |     ---------- type must be known at this point
    |
 help: consider giving `x` an explicit type, where the placeholders `_` are specified
    |
diff --git a/tests/ui/span/issue-42234-unknown-receiver-type.stderr b/tests/ui/span/issue-42234-unknown-receiver-type.stderr
index 71ac4f53b3f4f..10308ec07da5a 100644
--- a/tests/ui/span/issue-42234-unknown-receiver-type.stderr
+++ b/tests/ui/span/issue-42234-unknown-receiver-type.stderr
@@ -4,7 +4,7 @@ error[E0282]: type annotations needed
 LL |     let x: Option<_> = None;
    |                        ^^^^ cannot infer type of the type parameter `T` declared on the enum `Option`
 LL |     x.unwrap().method_that_could_exist_on_some_type();
-   |                ------------------------------------ type must be known at this point
+   |     ---------- type must be known at this point
    |
 help: consider specifying the generic argument
    |
@@ -16,8 +16,6 @@ error[E0282]: type annotations needed
    |
 LL |         .sum::<_>()
    |          ^^^ cannot infer type of the type parameter `S` declared on the method `sum`
-LL |         .to_string()
-   |          --------- type must be known at this point
    |
 
 error: aborting due to 2 previous errors
diff --git a/tests/ui/type-alias-impl-trait/closures_in_branches.stderr b/tests/ui/type-alias-impl-trait/closures_in_branches.stderr
index 559bc57d90638..849ffd214f07d 100644
--- a/tests/ui/type-alias-impl-trait/closures_in_branches.stderr
+++ b/tests/ui/type-alias-impl-trait/closures_in_branches.stderr
@@ -2,7 +2,7 @@ error[E0282]: type annotations needed
   --> $DIR/closures_in_branches.rs:8:10
    |
 LL |         |x| x.len()
-   |          ^    --- type must be known at this point
+   |          ^  - type must be known at this point
    |
 help: consider giving this closure parameter an explicit type
    |
@@ -13,7 +13,7 @@ error[E0282]: type annotations needed
   --> $DIR/closures_in_branches.rs:22:10
    |
 LL |         |x| x.len()
-   |          ^    --- type must be known at this point
+   |          ^  - type must be known at this point
    |
 help: consider giving this closure parameter an explicit type
    |
diff --git a/tests/ui/type-inference/regression-issue-81317.stderr b/tests/ui/type-inference/regression-issue-81317.stderr
index a070b50e31175..fcd3fca06e18b 100644
--- a/tests/ui/type-inference/regression-issue-81317.stderr
+++ b/tests/ui/type-inference/regression-issue-81317.stderr
@@ -5,7 +5,7 @@ LL |     let iv = S ^ index.into();
    |         ^^
 LL |
 LL |     &iv.to_bytes_be();
-   |         ----------- type must be known at this point
+   |      -- type must be known at this point
    |
 help: consider giving `iv` an explicit type
    |
diff --git a/tests/ui/typeck/issue-13853.stderr b/tests/ui/typeck/issue-13853.stderr
index 9b8698d6ed2c0..4a39b404770d0 100644
--- a/tests/ui/typeck/issue-13853.stderr
+++ b/tests/ui/typeck/issue-13853.stderr
@@ -18,10 +18,10 @@ LL |     for node in graph.iter() {
    |                       ^^^^ method not found in `&G`
 
 error[E0282]: type annotations needed
-  --> $DIR/issue-13853.rs:28:14
+  --> $DIR/issue-13853.rs:28:9
    |
 LL |         node.zomg();
-   |              ^^^^ cannot infer type
+   |         ^^^^ cannot infer type
 
 error[E0308]: mismatched types
   --> $DIR/issue-13853.rs:37:13

From eb8d87d1d84c27876a6f780356be102ac4337ffa Mon Sep 17 00:00:00 2001
From: Yotam Ofek <yotam.ofek@gmail.com>
Date: Mon, 6 Oct 2025 16:55:14 +0300
Subject: [PATCH 1787/1889] avoid in-process serializing&deserializing

---
 src/librustdoc/html/render/mod.rs          |  75 +++++-
 src/librustdoc/html/render/search_index.rs | 268 ++++++++-------------
 2 files changed, 168 insertions(+), 175 deletions(-)

diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index 84d684e0c95f9..52617b6c43204 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -61,6 +61,8 @@ use rustc_middle::ty::print::PrintTraitRefExt;
 use rustc_middle::ty::{self, TyCtxt};
 use rustc_span::symbol::{Symbol, sym};
 use rustc_span::{BytePos, DUMMY_SP, FileName, RealFileName};
+use serde::ser::SerializeSeq as _;
+use serde::{Deserialize, Serialize};
 use tracing::{debug, info};
 
 pub(crate) use self::context::*;
@@ -144,7 +146,7 @@ pub(crate) struct IndexItem {
 }
 
 /// A type used for the search index.
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 struct RenderType {
     id: Option<RenderTypeId>,
     generics: Option<Vec<RenderType>>,
@@ -301,7 +303,7 @@ impl RenderTypeId {
 }
 
 /// Full type of functions/methods in the search index.
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub(crate) struct IndexItemFunctionType {
     inputs: Vec<RenderType>,
     output: Vec<RenderType>,
@@ -423,6 +425,75 @@ impl IndexItemFunctionType {
     }
 }
 
+impl Serialize for IndexItemFunctionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut seq = serializer.serialize_seq(Some(2))?;
+        let mut fn_type = String::new();
+        self.write_to_string_without_param_names(&mut fn_type);
+        seq.serialize_element(&fn_type)?;
+
+        struct ParamNames<'a>(&'a [Option<Symbol>]);
+
+        impl<'a> Serialize for ParamNames<'a> {
+            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+            where
+                S: serde::Serializer,
+            {
+                serializer.collect_seq(
+                    self.0
+                        .iter()
+                        .map(|symbol| symbol.as_ref().map(ToString::to_string).unwrap_or_default()),
+                )
+            }
+        }
+
+        seq.serialize_element(&ParamNames(&self.param_names))?;
+        seq.end()
+    }
+}
+
+impl<'de> Deserialize<'de> for IndexItemFunctionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        use serde::de::{self, Error as _};
+
+        struct FunctionDataVisitor;
+        impl<'de> de::Visitor<'de> for FunctionDataVisitor {
+            type Value = IndexItemFunctionType;
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> fmt::Result {
+                write!(formatter, "fn data")
+            }
+            fn visit_seq<A: de::SeqAccess<'de>>(self, mut v: A) -> Result<Self::Value, A::Error> {
+                let (mut function_signature, _) = v
+                    .next_element()?
+                    .map(|fn_: String| {
+                        IndexItemFunctionType::read_from_string_without_param_names(fn_.as_bytes())
+                    })
+                    .ok_or_else(|| A::Error::missing_field("function_signature"))?;
+                let param_names: Vec<Option<Symbol>> = v
+                    .next_element()?
+                    .map(|param_names: Vec<String>| {
+                        param_names
+                            .into_iter()
+                            .map(|symbol| {
+                                if symbol.is_empty() { None } else { Some(Symbol::intern(&symbol)) }
+                            })
+                            .collect()
+                    })
+                    .ok_or_else(|| A::Error::missing_field("param_names"))?;
+                function_signature.param_names = param_names;
+                Ok(function_signature)
+            }
+        }
+        deserializer.deserialize_any(FunctionDataVisitor)
+    }
+}
+
 #[derive(Debug, Clone)]
 pub(crate) struct StylePath {
     /// The path to the theme
diff --git a/src/librustdoc/html/render/search_index.rs b/src/librustdoc/html/render/search_index.rs
index 253d90294687e..080faff3a6de6 100644
--- a/src/librustdoc/html/render/search_index.rs
+++ b/src/librustdoc/html/render/search_index.rs
@@ -34,7 +34,7 @@ pub(crate) struct SerializedSearchIndex {
     path_data: Vec<Option<PathData>>,
     entry_data: Vec<Option<EntryData>>,
     descs: Vec<String>,
-    function_data: Vec<Option<FunctionData>>,
+    function_data: Vec<Option<IndexItemFunctionType>>,
     alias_pointers: Vec<Option<usize>>,
     // inverted index for concrete types and generics
     type_data: Vec<Option<TypeData>>,
@@ -61,7 +61,7 @@ impl SerializedSearchIndex {
         let mut path_data: Vec<Option<PathData>> = Vec::new();
         let mut entry_data: Vec<Option<EntryData>> = Vec::new();
         let mut descs: Vec<String> = Vec::new();
-        let mut function_data: Vec<Option<FunctionData>> = Vec::new();
+        let mut function_data: Vec<Option<IndexItemFunctionType>> = Vec::new();
         let mut type_data: Vec<Option<TypeData>> = Vec::new();
         let mut alias_pointers: Vec<Option<usize>> = Vec::new();
 
@@ -207,7 +207,7 @@ impl SerializedSearchIndex {
         path_data: Option<PathData>,
         entry_data: Option<EntryData>,
         desc: String,
-        function_data: Option<FunctionData>,
+        function_data: Option<IndexItemFunctionType>,
         type_data: Option<TypeData>,
         alias_pointer: Option<usize>,
     ) -> usize {
@@ -446,73 +446,62 @@ impl SerializedSearchIndex {
                         ..other_entry_data.clone()
                     }),
                     other.descs[other_entryid].clone(),
-                    other.function_data[other_entryid].as_ref().map(|function_data| FunctionData {
-                        function_signature: {
-                            let (mut func, _offset) =
-                                IndexItemFunctionType::read_from_string_without_param_names(
-                                    function_data.function_signature.as_bytes(),
-                                );
-                            fn map_fn_sig_item(
-                                map_other_pathid_to_self_pathid: &mut Vec<usize>,
-                                ty: &mut RenderType,
-                            ) {
-                                match ty.id {
-                                    None => {}
-                                    Some(RenderTypeId::Index(generic)) if generic < 0 => {}
-                                    Some(RenderTypeId::Index(id)) => {
-                                        let id = usize::try_from(id).unwrap();
-                                        let id = map_other_pathid_to_self_pathid[id];
-                                        assert!(id != !0);
-                                        ty.id =
-                                            Some(RenderTypeId::Index(isize::try_from(id).unwrap()));
-                                    }
-                                    _ => unreachable!(),
+                    other.function_data[other_entryid].clone().map(|mut func| {
+                        fn map_fn_sig_item(
+                            map_other_pathid_to_self_pathid: &mut Vec<usize>,
+                            ty: &mut RenderType,
+                        ) {
+                            match ty.id {
+                                None => {}
+                                Some(RenderTypeId::Index(generic)) if generic < 0 => {}
+                                Some(RenderTypeId::Index(id)) => {
+                                    let id = usize::try_from(id).unwrap();
+                                    let id = map_other_pathid_to_self_pathid[id];
+                                    assert!(id != !0);
+                                    ty.id = Some(RenderTypeId::Index(isize::try_from(id).unwrap()));
                                 }
-                                if let Some(generics) = &mut ty.generics {
-                                    for generic in generics {
-                                        map_fn_sig_item(map_other_pathid_to_self_pathid, generic);
-                                    }
+                                _ => unreachable!(),
+                            }
+                            if let Some(generics) = &mut ty.generics {
+                                for generic in generics {
+                                    map_fn_sig_item(map_other_pathid_to_self_pathid, generic);
                                 }
-                                if let Some(bindings) = &mut ty.bindings {
-                                    for (param, constraints) in bindings {
-                                        *param = match *param {
-                                            param @ RenderTypeId::Index(generic) if generic < 0 => {
-                                                param
-                                            }
-                                            RenderTypeId::Index(id) => {
-                                                let id = usize::try_from(id).unwrap();
-                                                let id = map_other_pathid_to_self_pathid[id];
-                                                assert!(id != !0);
-                                                RenderTypeId::Index(isize::try_from(id).unwrap())
-                                            }
-                                            _ => unreachable!(),
-                                        };
-                                        for constraint in constraints {
-                                            map_fn_sig_item(
-                                                map_other_pathid_to_self_pathid,
-                                                constraint,
-                                            );
+                            }
+                            if let Some(bindings) = &mut ty.bindings {
+                                for (param, constraints) in bindings {
+                                    *param = match *param {
+                                        param @ RenderTypeId::Index(generic) if generic < 0 => {
+                                            param
+                                        }
+                                        RenderTypeId::Index(id) => {
+                                            let id = usize::try_from(id).unwrap();
+                                            let id = map_other_pathid_to_self_pathid[id];
+                                            assert!(id != !0);
+                                            RenderTypeId::Index(isize::try_from(id).unwrap())
                                         }
+                                        _ => unreachable!(),
+                                    };
+                                    for constraint in constraints {
+                                        map_fn_sig_item(
+                                            map_other_pathid_to_self_pathid,
+                                            constraint,
+                                        );
                                     }
                                 }
                             }
-                            for input in &mut func.inputs {
-                                map_fn_sig_item(&mut map_other_pathid_to_self_pathid, input);
-                            }
-                            for output in &mut func.output {
-                                map_fn_sig_item(&mut map_other_pathid_to_self_pathid, output);
-                            }
-                            for clause in &mut func.where_clause {
-                                for entry in clause {
-                                    map_fn_sig_item(&mut map_other_pathid_to_self_pathid, entry);
-                                }
+                        }
+                        for input in &mut func.inputs {
+                            map_fn_sig_item(&mut map_other_pathid_to_self_pathid, input);
+                        }
+                        for output in &mut func.output {
+                            map_fn_sig_item(&mut map_other_pathid_to_self_pathid, output);
+                        }
+                        for clause in &mut func.where_clause {
+                            for entry in clause {
+                                map_fn_sig_item(&mut map_other_pathid_to_self_pathid, entry);
                             }
-                            let mut result =
-                                String::with_capacity(function_data.function_signature.len());
-                            func.write_to_string_without_param_names(&mut result);
-                            result
-                        },
-                        param_names: function_data.param_names.clone(),
+                        }
+                        func
                     }),
                     other.type_data[other_entryid].as_ref().map(|type_data| TypeData {
                         inverted_function_inputs_index: type_data
@@ -626,69 +615,55 @@ impl SerializedSearchIndex {
                     },
                 ),
                 self.descs[id].clone(),
-                self.function_data[id].as_ref().map(
-                    |FunctionData { function_signature, param_names }| FunctionData {
-                        function_signature: {
-                            let (mut func, _offset) =
-                                IndexItemFunctionType::read_from_string_without_param_names(
-                                    function_signature.as_bytes(),
-                                );
-                            fn map_fn_sig_item(map: &FxHashMap<usize, usize>, ty: &mut RenderType) {
-                                match ty.id {
-                                    None => {}
-                                    Some(RenderTypeId::Index(generic)) if generic < 0 => {}
-                                    Some(RenderTypeId::Index(id)) => {
+                self.function_data[id].clone().map(|mut func| {
+                    fn map_fn_sig_item(map: &FxHashMap<usize, usize>, ty: &mut RenderType) {
+                        match ty.id {
+                            None => {}
+                            Some(RenderTypeId::Index(generic)) if generic < 0 => {}
+                            Some(RenderTypeId::Index(id)) => {
+                                let id = usize::try_from(id).unwrap();
+                                let id = *map.get(&id).unwrap();
+                                assert!(id != !0);
+                                ty.id = Some(RenderTypeId::Index(isize::try_from(id).unwrap()));
+                            }
+                            _ => unreachable!(),
+                        }
+                        if let Some(generics) = &mut ty.generics {
+                            for generic in generics {
+                                map_fn_sig_item(map, generic);
+                            }
+                        }
+                        if let Some(bindings) = &mut ty.bindings {
+                            for (param, constraints) in bindings {
+                                *param = match *param {
+                                    param @ RenderTypeId::Index(generic) if generic < 0 => param,
+                                    RenderTypeId::Index(id) => {
                                         let id = usize::try_from(id).unwrap();
                                         let id = *map.get(&id).unwrap();
                                         assert!(id != !0);
-                                        ty.id =
-                                            Some(RenderTypeId::Index(isize::try_from(id).unwrap()));
+                                        RenderTypeId::Index(isize::try_from(id).unwrap())
                                     }
                                     _ => unreachable!(),
+                                };
+                                for constraint in constraints {
+                                    map_fn_sig_item(map, constraint);
                                 }
-                                if let Some(generics) = &mut ty.generics {
-                                    for generic in generics {
-                                        map_fn_sig_item(map, generic);
-                                    }
-                                }
-                                if let Some(bindings) = &mut ty.bindings {
-                                    for (param, constraints) in bindings {
-                                        *param = match *param {
-                                            param @ RenderTypeId::Index(generic) if generic < 0 => {
-                                                param
-                                            }
-                                            RenderTypeId::Index(id) => {
-                                                let id = usize::try_from(id).unwrap();
-                                                let id = *map.get(&id).unwrap();
-                                                assert!(id != !0);
-                                                RenderTypeId::Index(isize::try_from(id).unwrap())
-                                            }
-                                            _ => unreachable!(),
-                                        };
-                                        for constraint in constraints {
-                                            map_fn_sig_item(map, constraint);
-                                        }
-                                    }
-                                }
-                            }
-                            for input in &mut func.inputs {
-                                map_fn_sig_item(&map, input);
-                            }
-                            for output in &mut func.output {
-                                map_fn_sig_item(&map, output);
                             }
-                            for clause in &mut func.where_clause {
-                                for entry in clause {
-                                    map_fn_sig_item(&map, entry);
-                                }
-                            }
-                            let mut result = String::with_capacity(function_signature.len());
-                            func.write_to_string_without_param_names(&mut result);
-                            result
-                        },
-                        param_names: param_names.clone(),
-                    },
-                ),
+                        }
+                    }
+                    for input in &mut func.inputs {
+                        map_fn_sig_item(&map, input);
+                    }
+                    for output in &mut func.output {
+                        map_fn_sig_item(&map, output);
+                    }
+                    for clause in &mut func.where_clause {
+                        for entry in clause {
+                            map_fn_sig_item(&map, entry);
+                        }
+                    }
+                    func
+                }),
                 self.type_data[id].as_ref().map(
                     |TypeData {
                          search_unbox,
@@ -1259,48 +1234,6 @@ impl<'de> Deserialize<'de> for SerializedOptional32 {
     }
 }
 
-#[derive(Clone, Debug)]
-pub struct FunctionData {
-    function_signature: String,
-    param_names: Vec<String>,
-}
-
-impl Serialize for FunctionData {
-    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.function_signature)?;
-        seq.serialize_element(&self.param_names)?;
-        seq.end()
-    }
-}
-
-impl<'de> Deserialize<'de> for FunctionData {
-    fn deserialize<D>(deserializer: D) -> Result<FunctionData, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        struct FunctionDataVisitor;
-        impl<'de> de::Visitor<'de> for FunctionDataVisitor {
-            type Value = FunctionData;
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                write!(formatter, "fn data")
-            }
-            fn visit_seq<A: de::SeqAccess<'de>>(self, mut v: A) -> Result<FunctionData, A::Error> {
-                let function_signature: String = v
-                    .next_element()?
-                    .ok_or_else(|| A::Error::missing_field("function_signature"))?;
-                let param_names: Vec<String> =
-                    v.next_element()?.ok_or_else(|| A::Error::missing_field("param_names"))?;
-                Ok(FunctionData { function_signature, param_names })
-            }
-        }
-        deserializer.deserialize_any(FunctionDataVisitor)
-    }
-}
-
 /// Builds the search index from the collected metadata
 pub(crate) fn build_index(
     krate: &clean::Crate,
@@ -1927,18 +1860,7 @@ pub(crate) fn build_index(
                 // because the postings list has to fill in an empty array for each
                 // unoccupied size.
                 if item.ty.is_fn_like() { 0 } else { 16 };
-            serialized_index.function_data[new_entry_id] = Some(FunctionData {
-                function_signature: {
-                    let mut function_signature = String::new();
-                    search_type.write_to_string_without_param_names(&mut function_signature);
-                    function_signature
-                },
-                param_names: search_type
-                    .param_names
-                    .iter()
-                    .map(|sym| sym.map(|sym| sym.to_string()).unwrap_or(String::new()))
-                    .collect::<Vec<String>>(),
-            });
+            serialized_index.function_data[new_entry_id] = Some(search_type.clone());
             for index in used_in_function_inputs {
                 let postings = if index >= 0 {
                     assert!(serialized_index.path_data[index as usize].is_some());

From 978ab7c54229359f62593d4afd8249a09bf7607c Mon Sep 17 00:00:00 2001
From: Yotam Ofek <yotam.ofek@gmail.com>
Date: Tue, 7 Oct 2025 12:57:59 +0300
Subject: [PATCH 1788/1889] nicer serde impls

---
 src/librustdoc/html/render/mod.rs | 103 +++++++++++++++++++-----------
 1 file changed, 65 insertions(+), 38 deletions(-)

diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index 52617b6c43204..d604526aa4a18 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -62,7 +62,7 @@ use rustc_middle::ty::{self, TyCtxt};
 use rustc_span::symbol::{Symbol, sym};
 use rustc_span::{BytePos, DUMMY_SP, FileName, RealFileName};
 use serde::ser::SerializeSeq as _;
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use tracing::{debug, info};
 
 pub(crate) use self::context::*;
@@ -428,29 +428,31 @@ impl IndexItemFunctionType {
 impl Serialize for IndexItemFunctionType {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
-        S: serde::Serializer,
+        S: Serializer,
     {
-        let mut seq = serializer.serialize_seq(Some(2))?;
-        let mut fn_type = String::new();
-        self.write_to_string_without_param_names(&mut fn_type);
-        seq.serialize_element(&fn_type)?;
-
         struct ParamNames<'a>(&'a [Option<Symbol>]);
 
         impl<'a> Serialize for ParamNames<'a> {
             fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
             where
-                S: serde::Serializer,
+                S: Serializer,
             {
                 serializer.collect_seq(
                     self.0
                         .iter()
-                        .map(|symbol| symbol.as_ref().map(ToString::to_string).unwrap_or_default()),
+                        .map(|symbol| symbol.as_ref().map(Symbol::as_str).unwrap_or_default()),
                 )
             }
         }
 
+        let mut seq = serializer.serialize_seq(Some(2))?;
+
+        let mut fn_type = String::new();
+        self.write_to_string_without_param_names(&mut fn_type);
+        seq.serialize_element(&fn_type)?;
+
         seq.serialize_element(&ParamNames(&self.param_names))?;
+
         seq.end()
     }
 }
@@ -458,39 +460,64 @@ impl Serialize for IndexItemFunctionType {
 impl<'de> Deserialize<'de> for IndexItemFunctionType {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
-        D: serde::Deserializer<'de>,
+        D: Deserializer<'de>,
     {
-        use serde::de::{self, Error as _};
+        use serde::de::{self, SeqAccess};
 
-        struct FunctionDataVisitor;
-        impl<'de> de::Visitor<'de> for FunctionDataVisitor {
-            type Value = IndexItemFunctionType;
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> fmt::Result {
-                write!(formatter, "fn data")
-            }
-            fn visit_seq<A: de::SeqAccess<'de>>(self, mut v: A) -> Result<Self::Value, A::Error> {
-                let (mut function_signature, _) = v
-                    .next_element()?
-                    .map(|fn_: String| {
-                        IndexItemFunctionType::read_from_string_without_param_names(fn_.as_bytes())
-                    })
-                    .ok_or_else(|| A::Error::missing_field("function_signature"))?;
-                let param_names: Vec<Option<Symbol>> = v
-                    .next_element()?
-                    .map(|param_names: Vec<String>| {
-                        param_names
-                            .into_iter()
-                            .map(|symbol| {
-                                if symbol.is_empty() { None } else { Some(Symbol::intern(&symbol)) }
-                            })
-                            .collect()
-                    })
-                    .ok_or_else(|| A::Error::missing_field("param_names"))?;
-                function_signature.param_names = param_names;
-                Ok(function_signature)
+        #[derive(Deserialize)]
+        struct Deserialized {
+            #[serde(deserialize_with = "function_signature")]
+            function_signature: IndexItemFunctionType,
+            #[serde(deserialize_with = "param_names")]
+            param_names: Vec<Option<Symbol>>,
+        }
+
+        fn function_signature<'de, D: Deserializer<'de>>(
+            deserializer: D,
+        ) -> Result<IndexItemFunctionType, D::Error> {
+            String::deserialize(deserializer).map(|sig| {
+                IndexItemFunctionType::read_from_string_without_param_names(sig.as_bytes()).0
+            })
+        }
+
+        fn param_names<'de, D: Deserializer<'de>>(
+            deserializer: D,
+        ) -> Result<Vec<Option<Symbol>>, D::Error> {
+            struct Visitor;
+
+            impl<'de> de::Visitor<'de> for Visitor {
+                type Value = Vec<Option<Symbol>>;
+
+                fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                    f.write_str("seq of param names")
+                }
+
+                fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+                where
+                    A: SeqAccess<'de>,
+                {
+                    let mut param_names = Vec::with_capacity(seq.size_hint().unwrap_or_default());
+
+                    while let Some(symbol) = seq.next_element::<String>()? {
+                        param_names.push(if symbol.is_empty() {
+                            None
+                        } else {
+                            Some(Symbol::intern(&symbol))
+                        });
+                    }
+
+                    Ok(param_names)
+                }
             }
+
+            deserializer.deserialize_seq(Visitor)
         }
-        deserializer.deserialize_any(FunctionDataVisitor)
+
+        let Deserialized { mut function_signature, param_names } =
+            Deserialized::deserialize(deserializer)?;
+        function_signature.param_names = param_names;
+
+        Ok(function_signature)
     }
 }
 

From f8ee9f018c53c7555c07a035ff2efaad9723adc9 Mon Sep 17 00:00:00 2001
From: yukang <moorekang@gmail.com>
Date: Tue, 7 Oct 2025 18:26:36 +0800
Subject: [PATCH 1789/1889] Print tip for human error format when check fail

---
 src/tools/compiletest/src/runtest.rs | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index bd32bec383fa3..e9dea95cafbdc 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -878,6 +878,21 @@ impl<'test> TestCx<'test> {
                     prefix = self.error_prefix(),
                     n = not_found.len(),
                 );
+
+                // FIXME: Ideally, we should check this at the place where we actually parse error annotations.
+                // it's better to use (negated) heuristic inside normalize_output if possible
+                if let Some(human_format) = self.props.compile_flags.iter().find(|flag| {
+                    // `human`, `human-unicode`, `short` will not generate JSON output
+                    flag.contains("error-format")
+                        && (flag.contains("short") || flag.contains("human"))
+                }) {
+                    let msg = format!(
+                        "tests with compile flag `{}` should not have error annotations such as `//~ ERROR`",
+                        human_format
+                    ).color(Color::Red);
+                    writeln!(self.stdout, "{}", msg);
+                }
+
                 for error in &not_found {
                     print_error(error);
                     let mut suggestions = Vec::new();

From c5ab5307497269eae873750c7890b579bac03fb0 Mon Sep 17 00:00:00 2001
From: Yotam Ofek <yotam.ofek@gmail.com>
Date: Tue, 7 Oct 2025 13:37:49 +0300
Subject: [PATCH 1790/1889] move serde impls to separate module

---
 src/librustdoc/html/render/mod.rs             |  98 -----------------
 src/librustdoc/html/render/search_index.rs    |   7 +-
 .../html/render/search_index/serde.rs         | 102 ++++++++++++++++++
 3 files changed, 106 insertions(+), 101 deletions(-)
 create mode 100644 src/librustdoc/html/render/search_index/serde.rs

diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index d604526aa4a18..c3b1e3eb6c087 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -61,8 +61,6 @@ use rustc_middle::ty::print::PrintTraitRefExt;
 use rustc_middle::ty::{self, TyCtxt};
 use rustc_span::symbol::{Symbol, sym};
 use rustc_span::{BytePos, DUMMY_SP, FileName, RealFileName};
-use serde::ser::SerializeSeq as _;
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use tracing::{debug, info};
 
 pub(crate) use self::context::*;
@@ -425,102 +423,6 @@ impl IndexItemFunctionType {
     }
 }
 
-impl Serialize for IndexItemFunctionType {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        struct ParamNames<'a>(&'a [Option<Symbol>]);
-
-        impl<'a> Serialize for ParamNames<'a> {
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: Serializer,
-            {
-                serializer.collect_seq(
-                    self.0
-                        .iter()
-                        .map(|symbol| symbol.as_ref().map(Symbol::as_str).unwrap_or_default()),
-                )
-            }
-        }
-
-        let mut seq = serializer.serialize_seq(Some(2))?;
-
-        let mut fn_type = String::new();
-        self.write_to_string_without_param_names(&mut fn_type);
-        seq.serialize_element(&fn_type)?;
-
-        seq.serialize_element(&ParamNames(&self.param_names))?;
-
-        seq.end()
-    }
-}
-
-impl<'de> Deserialize<'de> for IndexItemFunctionType {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        use serde::de::{self, SeqAccess};
-
-        #[derive(Deserialize)]
-        struct Deserialized {
-            #[serde(deserialize_with = "function_signature")]
-            function_signature: IndexItemFunctionType,
-            #[serde(deserialize_with = "param_names")]
-            param_names: Vec<Option<Symbol>>,
-        }
-
-        fn function_signature<'de, D: Deserializer<'de>>(
-            deserializer: D,
-        ) -> Result<IndexItemFunctionType, D::Error> {
-            String::deserialize(deserializer).map(|sig| {
-                IndexItemFunctionType::read_from_string_without_param_names(sig.as_bytes()).0
-            })
-        }
-
-        fn param_names<'de, D: Deserializer<'de>>(
-            deserializer: D,
-        ) -> Result<Vec<Option<Symbol>>, D::Error> {
-            struct Visitor;
-
-            impl<'de> de::Visitor<'de> for Visitor {
-                type Value = Vec<Option<Symbol>>;
-
-                fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                    f.write_str("seq of param names")
-                }
-
-                fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-                where
-                    A: SeqAccess<'de>,
-                {
-                    let mut param_names = Vec::with_capacity(seq.size_hint().unwrap_or_default());
-
-                    while let Some(symbol) = seq.next_element::<String>()? {
-                        param_names.push(if symbol.is_empty() {
-                            None
-                        } else {
-                            Some(Symbol::intern(&symbol))
-                        });
-                    }
-
-                    Ok(param_names)
-                }
-            }
-
-            deserializer.deserialize_seq(Visitor)
-        }
-
-        let Deserialized { mut function_signature, param_names } =
-            Deserialized::deserialize(deserializer)?;
-        function_signature.param_names = param_names;
-
-        Ok(function_signature)
-    }
-}
-
 #[derive(Debug, Clone)]
 pub(crate) struct StylePath {
     /// The path to the theme
diff --git a/src/librustdoc/html/render/search_index.rs b/src/librustdoc/html/render/search_index.rs
index 080faff3a6de6..67a88b1d2c57c 100644
--- a/src/librustdoc/html/render/search_index.rs
+++ b/src/librustdoc/html/render/search_index.rs
@@ -1,9 +1,13 @@
 pub(crate) mod encode;
+mod serde;
 
 use std::collections::BTreeSet;
 use std::collections::hash_map::Entry;
 use std::path::Path;
 
+use ::serde::de::{self, Deserializer, Error as _};
+use ::serde::ser::{SerializeSeq, Serializer};
+use ::serde::{Deserialize, Serialize};
 use rustc_ast::join_path_syms;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
 use rustc_hir::attrs::AttributeKind;
@@ -12,9 +16,6 @@ use rustc_middle::ty::TyCtxt;
 use rustc_span::def_id::DefId;
 use rustc_span::sym;
 use rustc_span::symbol::{Symbol, kw};
-use serde::de::{self, Deserializer, Error as _};
-use serde::ser::{SerializeSeq, Serializer};
-use serde::{Deserialize, Serialize};
 use stringdex::internals as stringdex_internals;
 use thin_vec::ThinVec;
 use tracing::instrument;
diff --git a/src/librustdoc/html/render/search_index/serde.rs b/src/librustdoc/html/render/search_index/serde.rs
new file mode 100644
index 0000000000000..2ba91a56031d5
--- /dev/null
+++ b/src/librustdoc/html/render/search_index/serde.rs
@@ -0,0 +1,102 @@
+use std::fmt::{self, Formatter};
+
+use rustc_span::Symbol;
+use serde::de::{self, SeqAccess};
+use serde::ser::SerializeSeq as _;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+use crate::html::render::IndexItemFunctionType;
+
+impl Serialize for IndexItemFunctionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        struct ParamNames<'a>(&'a [Option<Symbol>]);
+
+        impl<'a> Serialize for ParamNames<'a> {
+            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+            where
+                S: Serializer,
+            {
+                serializer.collect_seq(
+                    self.0
+                        .iter()
+                        .map(|symbol| symbol.as_ref().map(Symbol::as_str).unwrap_or_default()),
+                )
+            }
+        }
+
+        let mut seq = serializer.serialize_seq(Some(2))?;
+
+        let mut fn_type = String::new();
+        self.write_to_string_without_param_names(&mut fn_type);
+        seq.serialize_element(&fn_type)?;
+
+        seq.serialize_element(&ParamNames(&self.param_names))?;
+
+        seq.end()
+    }
+}
+
+impl<'de> Deserialize<'de> for IndexItemFunctionType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        struct Deserialized {
+            #[serde(deserialize_with = "function_signature")]
+            function_signature: IndexItemFunctionType,
+            #[serde(deserialize_with = "param_names")]
+            param_names: Vec<Option<Symbol>>,
+        }
+
+        fn function_signature<'de, D: Deserializer<'de>>(
+            deserializer: D,
+        ) -> Result<IndexItemFunctionType, D::Error> {
+            String::deserialize(deserializer).map(|sig| {
+                IndexItemFunctionType::read_from_string_without_param_names(sig.as_bytes()).0
+            })
+        }
+
+        fn param_names<'de, D: Deserializer<'de>>(
+            deserializer: D,
+        ) -> Result<Vec<Option<Symbol>>, D::Error> {
+            struct Visitor;
+
+            impl<'de> de::Visitor<'de> for Visitor {
+                type Value = Vec<Option<Symbol>>;
+
+                fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result {
+                    f.write_str("seq of param names")
+                }
+
+                fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+                where
+                    A: SeqAccess<'de>,
+                {
+                    let mut param_names = Vec::with_capacity(seq.size_hint().unwrap_or_default());
+
+                    while let Some(symbol) = seq.next_element::<String>()? {
+                        param_names.push(if symbol.is_empty() {
+                            None
+                        } else {
+                            Some(Symbol::intern(&symbol))
+                        });
+                    }
+
+                    Ok(param_names)
+                }
+            }
+
+            deserializer.deserialize_seq(Visitor)
+        }
+
+        let Deserialized { mut function_signature, param_names } =
+            Deserialized::deserialize(deserializer)?;
+        function_signature.param_names = param_names;
+
+        Ok(function_signature)
+    }
+}

From 713e0dddfd22ef37765fd5907b4639f7a690f8ed Mon Sep 17 00:00:00 2001
From: yukang <moorekang@gmail.com>
Date: Tue, 7 Oct 2025 21:05:45 +0800
Subject: [PATCH 1791/1889] Fix comments error for CtfeProvenance

---
 compiler/rustc_middle/src/mir/interpret/pointer.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_middle/src/mir/interpret/pointer.rs b/compiler/rustc_middle/src/mir/interpret/pointer.rs
index c581b2ebf092d..2aac8852b7e84 100644
--- a/compiler/rustc_middle/src/mir/interpret/pointer.rs
+++ b/compiler/rustc_middle/src/mir/interpret/pointer.rs
@@ -167,7 +167,7 @@ impl CtfeProvenance {
 }
 
 impl Provenance for CtfeProvenance {
-    // With the `AllocId` as provenance, the `offset` is interpreted *relative to the allocation*,
+    // With the `CtfeProvenance` as provenance, the `offset` is interpreted *relative to the allocation*,
     // so ptr-to-int casts are not possible (since we do not know the global physical offset).
     const OFFSET_IS_ADDR: bool = false;
 

From 0a3f1d5b9843c5e911a90ed9eb3010c29a407c66 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Tue, 7 Oct 2025 15:58:20 +0200
Subject: [PATCH 1792/1889] c-variadic: fix thir-print for `...` without a
 pattern

---
 compiler/rustc_mir_build/src/thir/print.rs |  4 +-
 tests/ui/thir-print/c-variadic.rs          |  6 +++
 tests/ui/thir-print/c-variadic.stdout      | 61 ++++++++++++++++++++++
 3 files changed, 70 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/thir-print/c-variadic.rs
 create mode 100644 tests/ui/thir-print/c-variadic.stdout

diff --git a/compiler/rustc_mir_build/src/thir/print.rs b/compiler/rustc_mir_build/src/thir/print.rs
index b7e8d6fea40bb..188f179669cb4 100644
--- a/compiler/rustc_mir_build/src/thir/print.rs
+++ b/compiler/rustc_mir_build/src/thir/print.rs
@@ -689,7 +689,9 @@ impl<'a, 'tcx> ThirPrinter<'a, 'tcx> {
         print_indented!(self, "kind: PatKind {", depth_lvl);
 
         match pat_kind {
-            PatKind::Missing => unreachable!(),
+            PatKind::Missing => {
+                print_indented!(self, "Missing", depth_lvl + 1);
+            }
             PatKind::Wild => {
                 print_indented!(self, "Wild", depth_lvl + 1);
             }
diff --git a/tests/ui/thir-print/c-variadic.rs b/tests/ui/thir-print/c-variadic.rs
new file mode 100644
index 0000000000000..e03c4b0838582
--- /dev/null
+++ b/tests/ui/thir-print/c-variadic.rs
@@ -0,0 +1,6 @@
+//@ compile-flags: -Zunpretty=thir-tree --crate-type=lib
+//@ check-pass
+#![feature(c_variadic)]
+
+// The `...` argument uses `PatKind::Missing`.
+unsafe extern "C" fn foo(_: i32, ...) {}
diff --git a/tests/ui/thir-print/c-variadic.stdout b/tests/ui/thir-print/c-variadic.stdout
new file mode 100644
index 0000000000000..8363f06ebe887
--- /dev/null
+++ b/tests/ui/thir-print/c-variadic.stdout
@@ -0,0 +1,61 @@
+DefId(0:3 ~ c_variadic[a5de]::foo):
+params: [
+    Param {
+        ty: i32
+        ty_span: Some($DIR/c-variadic.rs:6:29: 6:32 (#0))
+        self_kind: None
+        hir_id: Some(HirId(DefId(0:3 ~ c_variadic[a5de]::foo).1))
+        param: Some( 
+            Pat: {
+                ty: i32
+                span: $DIR/c-variadic.rs:6:26: 6:27 (#0)
+                kind: PatKind {
+                    Wild
+                }
+            }
+        )
+    }
+    Param {
+        ty: std::ffi::VaListImpl<'{erased}>
+        ty_span: None
+        self_kind: None
+        hir_id: Some(HirId(DefId(0:3 ~ c_variadic[a5de]::foo).3))
+        param: Some( 
+            Pat: {
+                ty: std::ffi::VaListImpl<'{erased}>
+                span: $DIR/c-variadic.rs:6:34: 6:37 (#0)
+                kind: PatKind {
+                    Missing
+                }
+            }
+        )
+    }
+]
+body:
+    Expr {
+        ty: ()
+        temp_lifetime: TempLifetime { temp_lifetime: Some(Node(6)), backwards_incompatible: None }
+        span: $DIR/c-variadic.rs:6:39: 6:41 (#0)
+        kind: 
+            Scope {
+                region_scope: Node(6)
+                lint_level: Explicit(HirId(DefId(0:3 ~ c_variadic[a5de]::foo).6))
+                value:
+                    Expr {
+                        ty: ()
+                        temp_lifetime: TempLifetime { temp_lifetime: Some(Node(6)), backwards_incompatible: None }
+                        span: $DIR/c-variadic.rs:6:39: 6:41 (#0)
+                        kind: 
+                            Block {
+                                targeted_by_break: false
+                                span: $DIR/c-variadic.rs:6:39: 6:41 (#0)
+                                region_scope: Node(5)
+                                safety_mode: Safe
+                                stmts: []
+                                expr: []
+                            }
+                    }
+            }
+    }
+
+

From e98856b6bbb4b11fbb6755a80d9a24249172ff78 Mon Sep 17 00:00:00 2001
From: Arthur Carcano <arthur.carcano@ocamlpro.com>
Date: Tue, 7 Oct 2025 15:49:27 +0200
Subject: [PATCH 1793/1889] Only allocate new string if there are DOS backlines

---
 src/librustdoc/html/highlight.rs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/librustdoc/html/highlight.rs b/src/librustdoc/html/highlight.rs
index eeb916494d1e7..f2055608aa9d2 100644
--- a/src/librustdoc/html/highlight.rs
+++ b/src/librustdoc/html/highlight.rs
@@ -408,7 +408,13 @@ pub(super) fn write_code(
     line_info: Option<LineInfo>,
 ) {
     // This replace allows to fix how the code source with DOS backline characters is displayed.
-    let src = src.replace("\r\n", "\n");
+    let src =
+        // The first "\r\n" should be fairly close to the beginning of the string relatively
+        // to its overall length, and most strings handled by rustdoc likely don't have
+        // DOS backlines anyway.
+        // Checking for the single ASCII character '\r' is much more efficient than checking for
+        // the whole string "\r\n".
+        if src.contains('\r') { src.replace("\r\n", "\n").into() } else { Cow::Borrowed(src) };
     let mut token_handler = TokenHandler {
         out,
         closing_tags: Vec::new(),

From eb20c6abd6b7282c3636c97870ae4e8c50d76632 Mon Sep 17 00:00:00 2001
From: Augie Fackler <augie@google.com>
Date: Tue, 7 Oct 2025 11:02:13 -0400
Subject: [PATCH 1794/1889] PassWrapper: use non-deprecated lookupTarget method

This avoids an extra trip through a triple string by directly passing
the Triple, and has been available since LLVM 21. The string overload
was deprecated today and throws an error on our CI for HEAD due to
-Werror paranoia, so we may as well clean this up now and also skip the
conversion on LLVM 21 since we can.

@rustbot label llvm-main
---
 compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
index 2e9fd6754f124..8d9c4b48b5c4a 100644
--- a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
@@ -283,7 +283,11 @@ extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
   std::string Error;
   auto Trip = Triple(Triple::normalize(TripleStr));
   const llvm::Target *TheTarget =
+#if LLVM_VERSION_GE(21, 0)
+      TargetRegistry::lookupTarget(Trip, Error);
+#else
       TargetRegistry::lookupTarget(Trip.getTriple(), Error);
+#endif
   if (TheTarget == nullptr) {
     LLVMRustSetLastError(Error.c_str());
     return nullptr;

From a914f827c8c50866f97627863eb6fa4702f44541 Mon Sep 17 00:00:00 2001
From: Mads Marquart <mads@marquart.dk>
Date: Tue, 7 Oct 2025 17:09:02 +0200
Subject: [PATCH 1795/1889] Set the minimum deployment target for
 aarch64-apple-watchos

To match what's done in LLVM 21.
---
 compiler/rustc_target/src/spec/base/apple/mod.rs | 5 ++++-
 tests/run-make/apple-deployment-target/rmake.rs  | 1 +
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_target/src/spec/base/apple/mod.rs b/compiler/rustc_target/src/spec/base/apple/mod.rs
index 39e604bcce7ce..c32e333eb8b02 100644
--- a/compiler/rustc_target/src/spec/base/apple/mod.rs
+++ b/compiler/rustc_target/src/spec/base/apple/mod.rs
@@ -304,7 +304,7 @@ impl OSVersion {
     /// to raise the minimum OS version.
     ///
     /// This matches what LLVM does, see in part:
-    /// <https://github.com/llvm/llvm-project/blob/llvmorg-18.1.8/llvm/lib/TargetParser/Triple.cpp#L1900-L1932>
+    /// <https://github.com/llvm/llvm-project/blob/llvmorg-21.1.3/llvm/lib/TargetParser/Triple.cpp#L2140-L2175>
     pub fn minimum_deployment_target(target: &Target) -> Self {
         let (major, minor, patch) = match (&*target.os, &*target.arch, &*target.env) {
             ("macos", "aarch64", _) => (11, 0, 0),
@@ -315,6 +315,9 @@ impl OSVersion {
             ("ios", _, "macabi") => (13, 1, 0),
             ("tvos", "aarch64", "sim") => (14, 0, 0),
             ("watchos", "aarch64", "sim") => (7, 0, 0),
+            // True Aarch64 on watchOS (instead of their Aarch64 Ilp32 called `arm64_32`) has been
+            // available since Xcode 14, but it's only actually used more recently in watchOS 26.
+            ("watchos", "aarch64", "") if !target.llvm_target.starts_with("arm64_32") => (26, 0, 0),
             (os, _, _) => return Self::os_minimum_deployment_target(os),
         };
         Self { major, minor, patch }
diff --git a/tests/run-make/apple-deployment-target/rmake.rs b/tests/run-make/apple-deployment-target/rmake.rs
index 7297a8622240d..5d4512843d534 100644
--- a/tests/run-make/apple-deployment-target/rmake.rs
+++ b/tests/run-make/apple-deployment-target/rmake.rs
@@ -33,6 +33,7 @@ fn main() {
         // armv7s-apple-ios and i386-apple-ios only supports iOS 10.0
         "ios" if target() == "armv7s-apple-ios" || target() == "i386-apple-ios" => ("10.0", "10.0"),
         "ios" => ("15.0", "16.0"),
+        "watchos" if target() == "aarch64-apple-watchos" => ("28.0", "30.0"),
         "watchos" => ("7.0", "9.0"),
         "tvos" => ("14.0", "15.0"),
         "visionos" => ("1.1", "1.2"),

From f7c9b30b1b74a0f8fc70aa6c947966aec03e3b0b Mon Sep 17 00:00:00 2001
From: Jynn Nelson <jynn.nelson@ferrous-systems.com>
Date: Tue, 7 Oct 2025 11:20:36 -0400
Subject: [PATCH 1796/1889] collect-license-metadata: update submodules before
 running

Previously, this could cause incorrect failures like the following:
```
diff --git a/license-metadata.json b/license-metadata.json
index 4fb59210854..b1291c00b94 100644
--- a/license-metadata.json
+++ b/license-metadata.json
@@ -244,19 +172,6 @@
             },
             "name": "src/doc/rustc-dev-guide/mermaid.min.js",
             "type": "file"
-          },
-          {
-            "children": [],
-            "license": {
-              "copyright": [
-                "2003-2019 University of Illinois at Urbana-Champaign",
-                "2003-2019 by the contributors listed in CREDITS.TXT (https://github.com/rust-lang/llvm-project/blob/7738295178045041669876bf32b0543ec8319a5c/llvm/CREDITS.TXT)",
-                "2010 Apple Inc"
-              ],
-              "spdx": "Apache-2.0 WITH LLVM-exception AND NCSA"
-            },
-            "name": "src/llvm-project",
-            "type": "directory"
```

Additionally, this prints a warning if there were untracked files, which
could cause a failure like the following:
```
diff --git a/license-metadata.json b/license-metadata.json
index 4fb59210854..ebf1c478282 100644
--- a/license-metadata.json
+++ b/license-metadata.json
@@ -155,6 +155,22 @@
             "name": "src/librustdoc/html/static/fonts",
             "type": "directory"
           },
+          {
+            "directories": [],
+            "files": [
+              "2015-edition.txt",
+              "diagnostics.json",
+              "license.diff",
+              "test.fixed.rs"
+            ],
+            "license": {
+              "copyright": [
+                "NONE"
+              ],
+              "spdx": "NONE"
+            },
+            "type": "group"
+          },
           {
             "license": {
               "copyright": [
```
---
 src/bootstrap/src/core/build_steps/run.rs | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/src/bootstrap/src/core/build_steps/run.rs b/src/bootstrap/src/core/build_steps/run.rs
index 9f7248b80f763..b9a4c1bf9b44b 100644
--- a/src/bootstrap/src/core/build_steps/run.rs
+++ b/src/bootstrap/src/core/build_steps/run.rs
@@ -6,6 +6,7 @@
 use std::path::PathBuf;
 
 use build_helper::exit;
+use build_helper::git::get_git_untracked_files;
 use clap_complete::{Generator, shells};
 
 use crate::core::build_steps::dist::distdir;
@@ -208,6 +209,16 @@ impl Step for CollectLicenseMetadata {
 
         let dest = builder.src.join("license-metadata.json");
 
+        if !builder.config.dry_run() {
+            builder.require_and_update_all_submodules();
+            if let Ok(Some(untracked)) = get_git_untracked_files(None) {
+                eprintln!(
+                    "Warning: {} untracked files may cause the license report to be incorrect.",
+                    untracked.len()
+                );
+            }
+        }
+
         let mut cmd = builder.tool_cmd(Tool::CollectLicenseMetadata);
         cmd.env("REUSE_EXE", reuse);
         cmd.env("DEST", &dest);

From fbdc685ed09f8315f583f9ba846c056b3ed810a4 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Wed, 1 Oct 2025 21:14:27 +0200
Subject: [PATCH 1797/1889] cmse: disallow `impl Trait` in
 `cmse-nonsecure-entry` return types

---
 .../src/hir_ty_lowering/cmse.rs               | 18 +++++++++--
 .../cmse-nonsecure-call/generics.rs           |  3 +-
 .../cmse-nonsecure-call/generics.stderr       | 24 ++++++++++-----
 .../cmse-nonsecure-entry/generics.rs          | 12 ++++++++
 .../cmse-nonsecure-entry/generics.stderr      | 30 ++++++++++++++++++-
 5 files changed, 75 insertions(+), 12 deletions(-)

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 378771c05ee33..91d1f89b74477 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
@@ -3,7 +3,7 @@ use rustc_errors::{DiagCtxtHandle, E0781, struct_span_code_err};
 use rustc_hir::{self as hir, HirId};
 use rustc_middle::bug;
 use rustc_middle::ty::layout::{LayoutError, TyAndLayout};
-use rustc_middle::ty::{self, TyCtxt};
+use rustc_middle::ty::{self, TyCtxt, TypeVisitableExt};
 
 use crate::errors;
 
@@ -165,9 +165,23 @@ fn is_valid_cmse_output<'tcx>(
     // this type is only used for layout computation, which does not rely on regions
     let fn_sig = tcx.instantiate_bound_regions_with_erased(fn_sig);
     let fn_sig = tcx.erase_and_anonymize_regions(fn_sig);
+    let return_type = fn_sig.output();
+
+    // `impl Trait` is already disallowed with `cmse-nonsecure-call`, because that ABI is only
+    // allowed on function pointers, and function pointers cannot contain `impl Trait` in their
+    // signature.
+    //
+    // Here we explicitly disallow `impl Trait` in the `cmse-nonsecure-entry` return type too, to
+    // prevent query cycles when calculating the layout. This ABI is meant to be used with
+    // `#[no_mangle]` or similar, so generics in the type really don't make sense.
+    //
+    // see also https://github.com/rust-lang/rust/issues/147242.
+    if return_type.has_opaque_types() {
+        return Err(tcx.arena.alloc(LayoutError::TooGeneric(return_type)));
+    }
 
     let typing_env = ty::TypingEnv::fully_monomorphized();
-    let layout = tcx.layout_of(typing_env.as_query_input(fn_sig.output()))?;
+    let layout = tcx.layout_of(typing_env.as_query_input(return_type))?;
 
     Ok(is_valid_cmse_output_layout(layout))
 }
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.rs b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.rs
index 4ce5890a2da30..2dc540675e2e6 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.rs
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.rs
@@ -14,8 +14,9 @@ struct Test<T: Copy> {
     f1: extern "cmse-nonsecure-call" fn<U: Copy>(U, u32, u32, u32) -> u64,
     //~^ ERROR cannot find type `U` in this scope
     //~| ERROR function pointer types may not have generic parameters
-    f2: extern "cmse-nonsecure-call" fn(impl Copy, u32, u32, u32) -> u64,
+    f2: extern "cmse-nonsecure-call" fn(impl Copy, u32, u32, u32) -> impl Copy,
     //~^ ERROR `impl Trait` is not allowed in `fn` pointer parameters
+    //~| ERROR `impl Trait` is not allowed in `fn` pointer return types
     f3: extern "cmse-nonsecure-call" fn(T, u32, u32, u32) -> u64, //~ ERROR [E0798]
     f4: extern "cmse-nonsecure-call" fn(Wrapper<T>, u32, u32, u32) -> u64, //~ ERROR [E0798]
 }
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.stderr
index 156568535763b..750dbf8d5707c 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.stderr
@@ -25,25 +25,33 @@ LL | struct Test<T: Copy, U> {
 error[E0562]: `impl Trait` is not allowed in `fn` pointer parameters
   --> $DIR/generics.rs:17:41
    |
-LL |     f2: extern "cmse-nonsecure-call" fn(impl Copy, u32, u32, u32) -> u64,
+LL |     f2: extern "cmse-nonsecure-call" fn(impl Copy, u32, u32, u32) -> impl Copy,
    |                                         ^^^^^^^^^
    |
    = note: `impl Trait` is only allowed in arguments and return types of functions and methods
 
+error[E0562]: `impl Trait` is not allowed in `fn` pointer return types
+  --> $DIR/generics.rs:17:70
+   |
+LL |     f2: extern "cmse-nonsecure-call" fn(impl Copy, u32, u32, u32) -> impl Copy,
+   |                                                                      ^^^^^^^^^
+   |
+   = note: `impl Trait` is only allowed in arguments and return types of functions and methods
+
 error[E0798]: function pointers with the `"cmse-nonsecure-call"` ABI cannot contain generics in their type
-  --> $DIR/generics.rs:19:9
+  --> $DIR/generics.rs:20:9
    |
 LL |     f3: extern "cmse-nonsecure-call" fn(T, u32, u32, u32) -> u64,
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0798]: function pointers with the `"cmse-nonsecure-call"` ABI cannot contain generics in their type
-  --> $DIR/generics.rs:20:9
+  --> $DIR/generics.rs:21:9
    |
 LL |     f4: extern "cmse-nonsecure-call" fn(Wrapper<T>, u32, u32, u32) -> u64,
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/generics.rs:26:71
+  --> $DIR/generics.rs:27:71
    |
 LL | type WithTraitObject = extern "cmse-nonsecure-call" fn(&dyn Trait) -> &dyn Trait;
    |                                                                       ^^^^^^^^^^ this type doesn't fit in the available registers
@@ -52,7 +60,7 @@ LL | type WithTraitObject = extern "cmse-nonsecure-call" fn(&dyn Trait) -> &dyn
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/generics.rs:30:60
+  --> $DIR/generics.rs:31:60
    |
 LL |     extern "cmse-nonsecure-call" fn(&'static dyn Trait) -> &'static dyn Trait;
    |                                                            ^^^^^^^^^^^^^^^^^^ this type doesn't fit in the available registers
@@ -61,7 +69,7 @@ LL |     extern "cmse-nonsecure-call" fn(&'static dyn Trait) -> &'static dyn Tra
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/generics.rs:37:60
+  --> $DIR/generics.rs:38:60
    |
 LL |     extern "cmse-nonsecure-call" fn(WrapperTransparent) -> WrapperTransparent;
    |                                                            ^^^^^^^^^^^^^^^^^^ this type doesn't fit in the available registers
@@ -70,12 +78,12 @@ LL |     extern "cmse-nonsecure-call" fn(WrapperTransparent) -> WrapperTranspare
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0045]: C-variadic functions with the "cmse-nonsecure-call" calling convention are not supported
-  --> $DIR/generics.rs:40:20
+  --> $DIR/generics.rs:41:20
    |
 LL | type WithVarArgs = extern "cmse-nonsecure-call" fn(u32, ...);
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ C-variadic function must have a compatible calling convention
 
-error: aborting due to 9 previous errors
+error: aborting due to 10 previous errors
 
 Some errors have detailed explanations: E0045, E0412, E0562, E0798.
 For more information about an error, try `rustc --explain E0045`.
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs
index aee01e25ddc4f..116f0fdc972fc 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs
@@ -65,3 +65,15 @@ extern "cmse-nonsecure-entry" fn wrapped_trait_object(x: WrapperTransparent) ->
     //~^ ERROR return value of `"cmse-nonsecure-entry"` function too large to pass via registers [E0798]
     x
 }
+
+extern "cmse-nonsecure-entry" fn return_impl_trait(_: impl Copy) -> impl Copy {
+    //~^ ERROR functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
+    //~| ERROR functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
+    0u128
+}
+
+extern "cmse-nonsecure-entry" fn return_impl_trait_nested(v: (impl Copy, i32)) -> (impl Copy, i32) {
+    //~^ ERROR functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
+    //~| ERROR functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
+    v
+}
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr
index df1a910704378..4158fef4553a4 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr
@@ -16,6 +16,34 @@ error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain gen
 LL | extern "cmse-nonsecure-entry" fn impl_trait(_: impl Copy, _: u32, _: u32, _: u32) -> u64 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
+  --> $DIR/generics.rs:69:1
+   |
+LL | extern "cmse-nonsecure-entry" fn return_impl_trait(_: impl Copy) -> impl Copy {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
+  --> $DIR/generics.rs:69:1
+   |
+LL | extern "cmse-nonsecure-entry" fn return_impl_trait(_: impl Copy) -> impl Copy {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
+  --> $DIR/generics.rs:75:1
+   |
+LL | extern "cmse-nonsecure-entry" fn return_impl_trait_nested(v: (impl Copy, i32)) -> (impl Copy, i32) {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
+  --> $DIR/generics.rs:75:1
+   |
+LL | extern "cmse-nonsecure-entry" fn return_impl_trait_nested(v: (impl Copy, i32)) -> (impl Copy, i32) {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
 error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
   --> $DIR/generics.rs:14:5
    |
@@ -61,6 +89,6 @@ LL | extern "cmse-nonsecure-entry" fn wrapped_trait_object(x: WrapperTransparent
    = note: functions with the `"cmse-nonsecure-entry"` ABI must pass their result via the available return registers
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
-error: aborting due to 7 previous errors
+error: aborting due to 11 previous errors
 
 For more information about this error, try `rustc --explain E0798`.

From 659575bfbe295d1ca6c86e6fe72325631ec4cf27 Mon Sep 17 00:00:00 2001
From: Urgau <urgau@numericable.fr>
Date: Tue, 7 Oct 2025 18:15:02 +0200
Subject: [PATCH 1798/1889] Add `t-` prefix to `S-waiting-on-{team}` labels

---
 rust-bors.toml | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/rust-bors.toml b/rust-bors.toml
index 1014e31bae49e..e813c6c4b1166 100644
--- a/rust-bors.toml
+++ b/rust-bors.toml
@@ -15,12 +15,13 @@ labels_blocking_approval = [
     "S-waiting-on-crater",
     "S-waiting-on-fcp",
     "S-waiting-on-MCP",
-    "S-waiting-on-lang",
-    "S-waiting-on-compiler",
-    "S-waiting-on-libs-api",
-    "S-waiting-on-types",
-    "S-waiting-on-opsem",
-    "S-waiting-on-rustdoc",
-    "S-waiting-on-rustdoc-frontend",
-    "S-waiting-on-clippy"
+    "S-waiting-on-t-lang",
+    "S-waiting-on-t-compiler",
+    "S-waiting-on-t-libs-api",
+    "S-waiting-on-t-libs",
+    "S-waiting-on-t-types",
+    "S-waiting-on-t-opsem",
+    "S-waiting-on-t-rustdoc",
+    "S-waiting-on-t-rustdoc-frontend",
+    "S-waiting-on-t-clippy"
 ]

From 03cdcb5cd5383857b339af226471f96c46e26b47 Mon Sep 17 00:00:00 2001
From: Josh Stone <jistone@redhat.com>
Date: Mon, 6 Oct 2025 13:34:42 -0700
Subject: [PATCH 1799/1889] bootstrap: add `Builder::rustc_cmd` that includes
 the lib path

When building with `rust.rpath = false`, every `rustc` invocation needs
to include the library path as well. I particularly ran into this in
`generate_target_spec_json_schema` when testing 1.91-beta in Fedora,
where we do disable rpath for our system builds. The new helper function
will hopefully encourage the right thing going forward.
---
 src/bootstrap/src/core/build_steps/compile.rs           | 2 +-
 src/bootstrap/src/core/build_steps/dist.rs              | 2 +-
 src/bootstrap/src/core/build_steps/synthetic_targets.rs | 3 +--
 src/bootstrap/src/core/builder/cargo.rs                 | 6 ++----
 src/bootstrap/src/core/builder/mod.rs                   | 8 ++++++++
 5 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index d29d1041486bd..b363b8f93b361 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -519,7 +519,7 @@ pub fn std_cargo(builder: &Builder<'_>, target: TargetSelection, cargo: &mut Car
         // Query rustc for the deployment target, and the associated env var.
         // The env var is one of the standard `*_DEPLOYMENT_TARGET` vars, i.e.
         // `MACOSX_DEPLOYMENT_TARGET`, `IPHONEOS_DEPLOYMENT_TARGET`, etc.
-        let mut cmd = command(builder.rustc(cargo.compiler()));
+        let mut cmd = builder.rustc_cmd(cargo.compiler());
         cmd.arg("--target").arg(target.rustc_target_arg());
         cmd.arg("--print=deployment-target");
         let output = cmd.run_capture_stdout(builder).stdout();
diff --git a/src/bootstrap/src/core/build_steps/dist.rs b/src/bootstrap/src/core/build_steps/dist.rs
index b79d2cb413db7..411d42962644d 100644
--- a/src/bootstrap/src/core/build_steps/dist.rs
+++ b/src/bootstrap/src/core/build_steps/dist.rs
@@ -625,7 +625,7 @@ fn generate_target_spec_json_schema(builder: &Builder<'_>, sysroot: &Path) {
     // We do this by using the stage 1 compiler, which is always compiled for the host,
     // even in a cross build.
     let stage1_host = builder.compiler(1, builder.host_target);
-    let mut rustc = command(builder.rustc(stage1_host)).fail_fast();
+    let mut rustc = builder.rustc_cmd(stage1_host).fail_fast();
     rustc
         .env("RUSTC_BOOTSTRAP", "1")
         .args(["--print=target-spec-json-schema", "-Zunstable-options"]);
diff --git a/src/bootstrap/src/core/build_steps/synthetic_targets.rs b/src/bootstrap/src/core/build_steps/synthetic_targets.rs
index 21733c5d9e3f7..2cc691832b5f0 100644
--- a/src/bootstrap/src/core/build_steps/synthetic_targets.rs
+++ b/src/bootstrap/src/core/build_steps/synthetic_targets.rs
@@ -10,7 +10,6 @@
 use crate::Compiler;
 use crate::core::builder::{Builder, ShouldRun, Step};
 use crate::core::config::TargetSelection;
-use crate::utils::exec::command;
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub(crate) struct MirOptPanicAbortSyntheticTarget {
@@ -55,7 +54,7 @@ fn create_synthetic_target(
         return TargetSelection::create_synthetic(&name, path.to_str().unwrap());
     }
 
-    let mut cmd = command(builder.rustc(compiler));
+    let mut cmd = builder.rustc_cmd(compiler);
     cmd.arg("--target").arg(base.rustc_target_arg());
     cmd.args(["-Zunstable-options", "--print", "target-spec-json"]);
 
diff --git a/src/bootstrap/src/core/builder/cargo.rs b/src/bootstrap/src/core/builder/cargo.rs
index a404aec512091..c2029f97391d4 100644
--- a/src/bootstrap/src/core/builder/cargo.rs
+++ b/src/bootstrap/src/core/builder/cargo.rs
@@ -728,10 +728,8 @@ impl Builder<'_> {
                 // Build proc macros both for the host and the target unless proc-macros are not
                 // supported by the target.
                 if target != compiler.host && cmd_kind != Kind::Check {
-                    let mut rustc_cmd = command(self.rustc(compiler));
-                    self.add_rustc_lib_path(compiler, &mut rustc_cmd);
-
-                    let error = rustc_cmd
+                    let error = self
+                        .rustc_cmd(compiler)
                         .arg("--target")
                         .arg(target.rustc_target_arg())
                         .arg("--print=file-names")
diff --git a/src/bootstrap/src/core/builder/mod.rs b/src/bootstrap/src/core/builder/mod.rs
index fc06db8f80b9d..1ddfbd51df523 100644
--- a/src/bootstrap/src/core/builder/mod.rs
+++ b/src/bootstrap/src/core/builder/mod.rs
@@ -1605,6 +1605,14 @@ Alternatively, you can set `build.local-rebuild=true` and use a stage0 compiler
         }
     }
 
+    /// Gets a command to run the compiler specified, including the dynamic library
+    /// path in case the executable has not been build with `rpath` enabled.
+    pub fn rustc_cmd(&self, compiler: Compiler) -> BootstrapCommand {
+        let mut cmd = command(self.rustc(compiler));
+        self.add_rustc_lib_path(compiler, &mut cmd);
+        cmd
+    }
+
     /// Gets the paths to all of the compiler's codegen backends.
     fn codegen_backends(&self, compiler: Compiler) -> impl Iterator<Item = PathBuf> {
         fs::read_dir(self.sysroot_codegen_backends(compiler))

From 81711747150a34d91b6642f973fe2379bf12907a Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 7 Oct 2025 19:16:58 +0200
Subject: [PATCH 1800/1889] fix panic with extra-const-ub-checks

---
 compiler/rustc_const_eval/messages.ftl        |  5 ++++-
 compiler/rustc_const_eval/src/errors.rs       |  5 ++---
 .../src/interpret/validity.rs                 |  8 +++-----
 .../rustc_middle/src/mir/interpret/error.rs   |  5 ++++-
 .../consts/extra-const-ub/detect-extra-ub.rs  | 10 ++++++++++
 .../detect-extra-ub.with_flag.stderr          | 20 +++++++++++++++----
 6 files changed, 39 insertions(+), 14 deletions(-)

diff --git a/compiler/rustc_const_eval/messages.ftl b/compiler/rustc_const_eval/messages.ftl
index 13a49e80cf2dc..3a2b3f8843191 100644
--- a/compiler/rustc_const_eval/messages.ftl
+++ b/compiler/rustc_const_eval/messages.ftl
@@ -481,7 +481,10 @@ const_eval_validation_null_box = {$front_matter}: encountered a {$maybe ->
     [true] maybe-null
     *[false] null
   } box
-const_eval_validation_null_fn_ptr = {$front_matter}: encountered a null function pointer
+const_eval_validation_null_fn_ptr = {$front_matter}: encountered a {$maybe ->
+    [true] maybe-null
+    *[false] null
+  } function pointer
 const_eval_validation_null_ref = {$front_matter}: encountered a {$maybe ->
     [true] maybe-null
     *[false] null
diff --git a/compiler/rustc_const_eval/src/errors.rs b/compiler/rustc_const_eval/src/errors.rs
index d352a6384245f..a0958a2b9ef3a 100644
--- a/compiler/rustc_const_eval/src/errors.rs
+++ b/compiler/rustc_const_eval/src/errors.rs
@@ -666,7 +666,7 @@ impl<'tcx> ReportErrorExt for ValidationErrorInfo<'tcx> {
             PartialPointer => const_eval_validation_partial_pointer,
             MutableRefToImmutable => const_eval_validation_mutable_ref_to_immutable,
             MutableRefInConst => const_eval_validation_mutable_ref_in_const,
-            NullFnPtr => const_eval_validation_null_fn_ptr,
+            NullFnPtr { .. } => const_eval_validation_null_fn_ptr,
             NeverVal => const_eval_validation_never_val,
             NonnullPtrMaybeNull { .. } => const_eval_validation_nonnull_ptr_out_of_range,
             PtrOutOfRange { .. } => const_eval_validation_ptr_out_of_range,
@@ -820,12 +820,11 @@ impl<'tcx> ReportErrorExt for ValidationErrorInfo<'tcx> {
                 err.arg("vtable_dyn_type", vtable_dyn_type.to_string());
                 err.arg("expected_dyn_type", expected_dyn_type.to_string());
             }
-            NullPtr { maybe, .. } => {
+            NullPtr { maybe, .. } | NullFnPtr { maybe } => {
                 err.arg("maybe", maybe);
             }
             MutableRefToImmutable
             | MutableRefInConst
-            | NullFnPtr
             | NonnullPtrMaybeNull
             | NeverVal
             | UnsafeCellInImmutable
diff --git a/compiler/rustc_const_eval/src/interpret/validity.rs b/compiler/rustc_const_eval/src/interpret/validity.rs
index 5f088fe37e80b..c62a23eb0b34b 100644
--- a/compiler/rustc_const_eval/src/interpret/validity.rs
+++ b/compiler/rustc_const_eval/src/interpret/validity.rs
@@ -757,14 +757,12 @@ impl<'rt, 'tcx, M: Machine<'tcx>> ValidityVisitor<'rt, 'tcx, M> {
                     );
                     // FIXME: Check if the signature matches
                 } else {
-                    // Otherwise (for standalone Miri), we have to still check it to be non-null.
+                    // Otherwise (for standalone Miri and for `-Zextra-const-ub-checks`),
+                    // we have to still check it to be non-null.
                     if self.ecx.scalar_may_be_null(scalar)? {
                         let maybe =
                             !M::Provenance::OFFSET_IS_ADDR && matches!(scalar, Scalar::Ptr(..));
-                        // This can't be a "maybe-null" pointer since the check for this being
-                        // a fn ptr at all already ensures that the pointer is inbounds.
-                        assert!(!maybe);
-                        throw_validation_failure!(self.path, NullFnPtr);
+                        throw_validation_failure!(self.path, NullFnPtr { maybe });
                     }
                 }
                 if self.reset_provenance_and_padding {
diff --git a/compiler/rustc_middle/src/mir/interpret/error.rs b/compiler/rustc_middle/src/mir/interpret/error.rs
index 951aac503fee8..976c209977b06 100644
--- a/compiler/rustc_middle/src/mir/interpret/error.rs
+++ b/compiler/rustc_middle/src/mir/interpret/error.rs
@@ -497,7 +497,10 @@ pub enum ValidationErrorKind<'tcx> {
     MutableRefToImmutable,
     UnsafeCellInImmutable,
     MutableRefInConst,
-    NullFnPtr,
+    NullFnPtr {
+        /// Records whether this pointer is definitely null or just may be null.
+        maybe: bool,
+    },
     NeverVal,
     NonnullPtrMaybeNull,
     PtrOutOfRange {
diff --git a/tests/ui/consts/extra-const-ub/detect-extra-ub.rs b/tests/ui/consts/extra-const-ub/detect-extra-ub.rs
index e17bac603b415..60086acc3707e 100644
--- a/tests/ui/consts/extra-const-ub/detect-extra-ub.rs
+++ b/tests/ui/consts/extra-const-ub/detect-extra-ub.rs
@@ -52,6 +52,16 @@ const UNALIGNED_PTR: () = unsafe {
     //[with_flag]~^ ERROR: invalid value
 };
 
+// A function pointer offset to be maybe-null.
+const MAYBE_NULL_FN_PTR: () = unsafe {
+    let _x: fn() = transmute({
+    //[with_flag]~^ ERROR: invalid value
+        fn fun() {}
+        let ptr = fun as fn();
+        (ptr as *const u8).wrapping_add(10)
+    });
+};
+
 const UNINHABITED_VARIANT: () = unsafe {
     let data = [1u8];
     // Not using transmute, we want to hit the ImmTy code path.
diff --git a/tests/ui/consts/extra-const-ub/detect-extra-ub.with_flag.stderr b/tests/ui/consts/extra-const-ub/detect-extra-ub.with_flag.stderr
index 6af72868045ac..96c1666a2d2eb 100644
--- a/tests/ui/consts/extra-const-ub/detect-extra-ub.with_flag.stderr
+++ b/tests/ui/consts/extra-const-ub/detect-extra-ub.with_flag.stderr
@@ -37,14 +37,26 @@ error[E0080]: constructing invalid value: encountered an unaligned reference (re
 LL |     let _x: &u32 = transmute(&[0u8; 4]);
    |                    ^^^^^^^^^^^^^^^^^^^^ evaluation of `UNALIGNED_PTR` failed here
 
+error[E0080]: constructing invalid value: encountered a maybe-null function pointer
+  --> $DIR/detect-extra-ub.rs:57:20
+   |
+LL |       let _x: fn() = transmute({
+   |  ____________________^
+LL | |
+LL | |         fn fun() {}
+LL | |         let ptr = fun as fn();
+LL | |         (ptr as *const u8).wrapping_add(10)
+LL | |     });
+   | |______^ evaluation of `MAYBE_NULL_FN_PTR` failed here
+
 error[E0080]: constructing invalid value at .<enum-tag>: encountered an uninhabited enum variant
-  --> $DIR/detect-extra-ub.rs:58:13
+  --> $DIR/detect-extra-ub.rs:68:13
    |
 LL |     let v = *addr_of!(data).cast::<UninhDiscriminant>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `UNINHABITED_VARIANT` failed here
 
 error[E0080]: constructing invalid value at [0]: encountered a partial pointer or a mix of pointers
-  --> $DIR/detect-extra-ub.rs:77:16
+  --> $DIR/detect-extra-ub.rs:87:16
    |
 LL |     let _val = *(&mem as *const Align as *const [*const u8; 2]);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `PARTIAL_POINTER` failed here
@@ -53,11 +65,11 @@ LL |     let _val = *(&mem as *const Align as *const [*const u8; 2]);
    = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
 
 error[E0080]: constructing invalid value: encountered invalid reference metadata: slice is bigger than largest supported object
-  --> $DIR/detect-extra-ub.rs:91:16
+  --> $DIR/detect-extra-ub.rs:101:16
    |
 LL |     let _val = &*slice;
    |                ^^^^^^^ evaluation of `OVERSIZED_REF` failed here
 
-error: aborting due to 8 previous errors
+error: aborting due to 9 previous errors
 
 For more information about this error, try `rustc --explain E0080`.

From 6d4b4d9ef080bd2fb2fe0cd81789998ff6064167 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Tue, 7 Oct 2025 11:17:44 -0700
Subject: [PATCH 1801/1889] rustdoc-search: keep hourglass in searchbar

---
 src/librustdoc/html/static/css/rustdoc.css |  7 ------
 src/librustdoc/html/static/js/search.js    | 29 ++++++++++------------
 2 files changed, 13 insertions(+), 23 deletions(-)

diff --git a/src/librustdoc/html/static/css/rustdoc.css b/src/librustdoc/html/static/css/rustdoc.css
index 8078f87756dd2..7f47856948493 100644
--- a/src/librustdoc/html/static/css/rustdoc.css
+++ b/src/librustdoc/html/static/css/rustdoc.css
@@ -339,7 +339,6 @@ summary.hideme,
 .scraped-example-list,
 .rustdoc-breadcrumbs,
 .search-switcher,
-.search-throbber,
 /* This selector is for the items listed in the "all items" page. */
 ul.all-items {
 	font-family: "Fira Sans", Arial, NanumBarunGothic, sans-serif;
@@ -2007,12 +2006,6 @@ a.tooltip:hover::after {
 	color: transparent;
 }
 
-.search-throbber {
-	position: relative;
-	height: 34px;
-}
-
-.search-throbber::after,
 .search-form.loading::after
 {
 	width: 18px;
diff --git a/src/librustdoc/html/static/js/search.js b/src/librustdoc/html/static/js/search.js
index ba8363b1a9147..0929d351463cc 100644
--- a/src/librustdoc/html/static/js/search.js
+++ b/src/librustdoc/html/static/js/search.js
@@ -1,5 +1,5 @@
 // ignore-tidy-filelength
-/* global addClass, getNakedUrl, getVar, nonnull, getSettingValue */
+/* global addClass, getNakedUrl, getVar, getSettingValue, hasClass, nonnull */
 /* global onEachLazy, removeClass, searchState, browserSupportsHistoryApi */
 
 "use strict";
@@ -4804,6 +4804,15 @@ function printTab(nb) {
         if (nb === iter) {
             addClass(elem, "selected");
             foundCurrentTab = true;
+            onEachLazy(document.querySelectorAll(
+                ".search-form",
+            ), form => {
+                if (hasClass(elem.firstElementChild, "loading")) {
+                    addClass(form, "loading");
+                } else {
+                    removeClass(form, "loading");
+                }
+            });
         } else {
             removeClass(elem, "selected");
         }
@@ -4904,11 +4913,6 @@ async function addTab(results, query, display, finishedCallback, isTypeSearch) {
     let output = document.createElement("ul");
     output.className = "search-results " + extraClass;
 
-    const throbber = document.createElement("div");
-    throbber.className = "search-throbber";
-    throbber.innerHTML = "Loading...";
-    output.appendChild(throbber);
-
     let count = 0;
 
     /** @type {Promise<string|null>[]} */
@@ -5015,7 +5019,7 @@ ${obj.displayPath}<span class="${type}">${name}</span>\
         }
 
         link.appendChild(description);
-        output.insertBefore(link, throbber);
+        output.appendChild(link);
 
         results.next().then(async nextResult => {
             if (nextResult.value) {
@@ -5026,7 +5030,6 @@ ${obj.displayPath}<span class="${type}">${name}</span>\
                 // running this callback
                 yieldToBrowser().then(() => {
                     finishedCallback(count, output);
-                    throbber.remove();
                 });
             }
         });
@@ -5164,6 +5167,7 @@ function makeTab(tabNb, text, results, query, isTypeSearch, goToFirst) {
                 count < 100 ? `\u{2007}(${count})\u{2007}` : `\u{2007}(${count})`;
             tabCount.innerHTML = fmtNbElems;
             tabCount.className = "count";
+            printTab(window.searchState.currentTab);
         }, isTypeSearch),
     ];
 }
@@ -5227,9 +5231,7 @@ async function showResults(docSearch, results, goToFirst, filterCrates) {
         tabsElem.appendChild(tab);
         const isCurrentTab = window.searchState.currentTab === tabNb;
         const placeholder = document.createElement("div");
-        placeholder.className = isCurrentTab ?
-            "search-throbber search-results active" :
-            "search-throbber search-results";
+        placeholder.className = isCurrentTab ? "search-results active" : "search-results";
         placeholder.innerHTML = "Loading...";
         output.then(output => {
             if (placeholder.parentElement) {
@@ -5487,11 +5489,6 @@ if (ROOT_PATH === null) {
 const database = await Stringdex.loadDatabase(hooks);
 if (typeof window !== "undefined") {
     docSearch = new DocSearch(ROOT_PATH, database);
-    onEachLazy(document.querySelectorAll(
-        ".search-form.loading",
-    ), form => {
-        removeClass(form, "loading");
-    });
     registerSearchEvents();
     // If there's a search term in the URL, execute the search now.
     if (window.searchState.getQueryStringParams().search !== undefined) {

From 74ec42e000d8385343a7b0ea96f28ed4371d4235 Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Tue, 7 Oct 2025 21:21:07 +0200
Subject: [PATCH 1802/1889] refactor confusing loop in `proc_macro` arena

---
 library/proc_macro/src/bridge/arena.rs | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/library/proc_macro/src/bridge/arena.rs b/library/proc_macro/src/bridge/arena.rs
index dee4e7b976de6..5e0393e98fdd2 100644
--- a/library/proc_macro/src/bridge/arena.rs
+++ b/library/proc_macro/src/bridge/arena.rs
@@ -90,14 +90,13 @@ impl Arena {
             return &mut [];
         }
 
-        loop {
-            if let Some(a) = self.alloc_raw_without_grow(bytes) {
-                break a;
-            }
-            // No free space left. Allocate a new chunk to satisfy the request.
-            // On failure the grow will panic or abort.
-            self.grow(bytes);
+        if let Some(a) = self.alloc_raw_without_grow(bytes) {
+            return a;
         }
+        // No free space left. Allocate a new chunk to satisfy the request.
+        // On failure the grow will panic or abort.
+        self.grow(bytes);
+        self.alloc_raw_without_grow(bytes).unwrap()
     }
 
     #[allow(clippy::mut_from_ref)] // arena allocator

From 7aa52ea97afe436b013f6276f1d9a866fb027846 Mon Sep 17 00:00:00 2001
From: cyrgani <ansgar.w.zielke@gmail.com>
Date: Tue, 7 Oct 2025 21:21:40 +0200
Subject: [PATCH 1803/1889] remove `Decode` trait and only impl

---
 library/proc_macro/src/bridge/mod.rs    | 2 +-
 library/proc_macro/src/bridge/rpc.rs    | 4 ----
 library/proc_macro/src/bridge/server.rs | 4 ++--
 3 files changed, 3 insertions(+), 7 deletions(-)

diff --git a/library/proc_macro/src/bridge/mod.rs b/library/proc_macro/src/bridge/mod.rs
index 1b09deb6bfe60..582c43c78fcbb 100644
--- a/library/proc_macro/src/bridge/mod.rs
+++ b/library/proc_macro/src/bridge/mod.rs
@@ -143,7 +143,7 @@ mod symbol;
 
 use buffer::Buffer;
 pub use rpc::PanicMessage;
-use rpc::{Decode, DecodeMut, Encode, Reader, Writer};
+use rpc::{DecodeMut, Encode, Reader, Writer};
 
 /// Configuration for establishing an active connection between a server and a
 /// client.  The server creates the bridge config (`run_server` in `server.rs`),
diff --git a/library/proc_macro/src/bridge/rpc.rs b/library/proc_macro/src/bridge/rpc.rs
index 26ea42b49b7f8..7f4f5fc3a97d5 100644
--- a/library/proc_macro/src/bridge/rpc.rs
+++ b/library/proc_macro/src/bridge/rpc.rs
@@ -12,10 +12,6 @@ pub(super) trait Encode<S>: Sized {
 
 pub(super) type Reader<'a> = &'a [u8];
 
-pub(super) trait Decode<'a, 's, S>: Sized {
-    fn decode(r: &mut Reader<'a>, s: &'s S) -> Self;
-}
-
 pub(super) trait DecodeMut<'a, 's, S>: Sized {
     fn decode(r: &mut Reader<'a>, s: &'s mut S) -> Self;
 }
diff --git a/library/proc_macro/src/bridge/server.rs b/library/proc_macro/src/bridge/server.rs
index 0bb30698aa1d7..2850e1099b700 100644
--- a/library/proc_macro/src/bridge/server.rs
+++ b/library/proc_macro/src/bridge/server.rs
@@ -40,10 +40,10 @@ macro_rules! define_server_handles {
                 }
             }
 
-            impl<'s, S: Types> Decode<'_, 's, HandleStore<MarkedTypes<S>>>
+            impl<'s, S: Types> DecodeMut<'_, 's, HandleStore<MarkedTypes<S>>>
                 for &'s Marked<S::$oty, client::$oty>
             {
-                fn decode(r: &mut Reader<'_>, s: &'s HandleStore<MarkedTypes<S>>) -> Self {
+                fn decode(r: &mut Reader<'_>, s: &'s mut HandleStore<MarkedTypes<S>>) -> Self {
                     &s.$oty[handle::Handle::decode(r, &mut ())]
                 }
             }

From c9293bfdae35a9975dca633435ed1b17bbacbf87 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Tue, 7 Oct 2025 12:59:58 -0700
Subject: [PATCH 1804/1889] rustdoc-search: add test case for throbber

---
 tests/rustdoc-gui/search-throbber.goml | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 tests/rustdoc-gui/search-throbber.goml

diff --git a/tests/rustdoc-gui/search-throbber.goml b/tests/rustdoc-gui/search-throbber.goml
new file mode 100644
index 0000000000000..9d41f933af8c1
--- /dev/null
+++ b/tests/rustdoc-gui/search-throbber.goml
@@ -0,0 +1,23 @@
+// We are intentionally triggering errors for race-free throbber test
+fail-on-request-error: false
+fail-on-js-error: false
+
+// First, make sure the throbber goes away when done
+go-to: "file://" + |DOC_PATH| + "/test_docs/index.html?search="
+wait-for: ".search-input"
+wait-for-false: ".search-form.loading"
+write-into: (".search-input", "test")
+press-key: 'Enter'
+wait-for-false: ".search-form.loading"
+
+// Make sure the throbber shows up if we prevent the search from
+// ever finishing (this tactic is needed to make sure we don't get stuck
+// with any race conditions).
+go-to: "file://" + |DOC_PATH| + "/test_docs/index.html?search="
+block-network-request: "*/desc/*.js"
+reload:
+wait-for: ".search-input"
+wait-for-false: ".search-form.loading"
+write-into: (".search-input", "test")
+press-key: 'Enter'
+wait-for: ".search-form.loading"

From 6920a8e8fcebef68cfd8eea2ef3d95262dfaf8b6 Mon Sep 17 00:00:00 2001
From: Jane Losare-Lusby <jlusby42@gmail.com>
Date: Mon, 6 Oct 2025 10:55:52 -0700
Subject: [PATCH 1805/1889] Convert impossible cases in macro resolution into
 assertions

---
 compiler/rustc_resolve/src/ident.rs | 21 ++++++++++++++-------
 compiler/rustc_resolve/src/lib.rs   | 18 ++++++++----------
 2 files changed, 22 insertions(+), 17 deletions(-)

diff --git a/compiler/rustc_resolve/src/ident.rs b/compiler/rustc_resolve/src/ident.rs
index 4415300777f98..3931c3c75f9fb 100644
--- a/compiler/rustc_resolve/src/ident.rs
+++ b/compiler/rustc_resolve/src/ident.rs
@@ -3,7 +3,7 @@ use Namespace::*;
 use rustc_ast::{self as ast, NodeId};
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir::def::{DefKind, MacroKinds, Namespace, NonMacroAttrKind, PartialRes, PerNS};
-use rustc_middle::bug;
+use rustc_middle::{bug, span_bug};
 use rustc_session::lint::builtin::PROC_MACRO_DERIVE_RESOLUTION_FALLBACK;
 use rustc_session::parse::feature_err;
 use rustc_span::hygiene::{ExpnId, ExpnKind, LocalExpnId, MacroKind, SyntaxContext};
@@ -677,14 +677,21 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                                         innermost_binding,
                                         binding,
                                     )
-                                    || flags.contains(Flags::MACRO_RULES)
-                                        && innermost_flags.contains(Flags::MODULE)
-                                        && !this.disambiguate_macro_rules_vs_modularized(
-                                            binding,
-                                            innermost_binding,
-                                        )
                                 {
                                     Some(AmbiguityKind::MacroRulesVsModularized)
+                                } else if flags.contains(Flags::MACRO_RULES)
+                                    && innermost_flags.contains(Flags::MODULE)
+                                {
+                                    // should be impossible because of visitation order in
+                                    // visit_scopes
+                                    //
+                                    // we visit all macro_rules scopes (e.g. textual scope macros)
+                                    // before we visit any modules (e.g. path-based scope macros)
+                                    span_bug!(
+                                        orig_ident.span,
+                                        "ambiguous scoped macro resolutions with path-based \
+                                        scope resolution as first candidate"
+                                    )
                                 } else if innermost_binding.is_glob_import() {
                                     Some(AmbiguityKind::GlobVsOuter)
                                 } else if innermost_binding
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index b44b1c966a431..d9c3f4089a0fb 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -2226,16 +2226,14 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         // Some non-controversial subset of ambiguities "modularized macro name" vs "macro_rules"
         // is disambiguated to mitigate regressions from macro modularization.
         // Scoping for `macro_rules` behaves like scoping for `let` at module level, in general.
-        match (
-            self.binding_parent_modules.get(&macro_rules),
-            self.binding_parent_modules.get(&modularized),
-        ) {
-            (Some(macro_rules), Some(modularized)) => {
-                macro_rules.nearest_parent_mod() == modularized.nearest_parent_mod()
-                    && modularized.is_ancestor_of(*macro_rules)
-            }
-            _ => false,
-        }
+        //
+        // panic on index should be impossible, the only name_bindings passed in should be from
+        // `resolve_ident_in_scope_set` which will always refer to a local binding from an
+        // import or macro definition
+        let macro_rules = &self.binding_parent_modules[&macro_rules];
+        let modularized = &self.binding_parent_modules[&modularized];
+        macro_rules.nearest_parent_mod() == modularized.nearest_parent_mod()
+            && modularized.is_ancestor_of(*macro_rules)
     }
 
     fn extern_prelude_get_item<'r>(

From 8e9b0c4ca9afaadf6c123901c200a9bfb666289f Mon Sep 17 00:00:00 2001
From: Boxy Uwu <rust@boxyuwu.dev>
Date: Sun, 28 Sep 2025 00:22:36 +0100
Subject: [PATCH 1806/1889] rename `select_where_possible` and
 `select_all_or_error`

---
 .../src/diagnostics/bound_region_errors.rs    |  2 +-
 .../src/diagnostics/conflict_errors.rs        |  4 ++--
 .../src/diagnostics/region_errors.rs          |  2 +-
 .../src/type_check/liveness/trace.rs          |  2 +-
 compiler/rustc_codegen_ssa/src/base.rs        |  2 +-
 .../src/check_consts/check.rs                 |  2 +-
 .../src/check_consts/qualifs.rs               |  4 ++--
 .../src/util/compare_types.rs                 |  2 +-
 compiler/rustc_hir_analysis/src/autoderef.rs  |  2 +-
 .../src/check/always_applicable.rs            |  2 +-
 .../rustc_hir_analysis/src/check/check.rs     |  6 ++---
 .../src/check/compare_impl_item.rs            | 12 +++++-----
 .../src/check/compare_impl_item/refine.rs     |  2 +-
 .../rustc_hir_analysis/src/check/entry.rs     |  2 +-
 compiler/rustc_hir_analysis/src/check/mod.rs  |  2 +-
 .../rustc_hir_analysis/src/check/wfcheck.rs   | 14 ++++++++---
 .../src/coherence/builtin.rs                  |  4 ++--
 .../src/coherence/orphan.rs                   |  2 +-
 compiler/rustc_hir_analysis/src/collect.rs    |  2 +-
 .../rustc_hir_analysis/src/hir_wf_check.rs    |  2 +-
 .../src/impl_wf_check/min_specialization.rs   |  2 +-
 compiler/rustc_hir_typeck/src/coercion.rs     | 10 ++++----
 compiler/rustc_hir_typeck/src/expr.rs         |  6 ++---
 compiler/rustc_hir_typeck/src/fallback.rs     |  2 +-
 .../rustc_hir_typeck/src/fn_ctxt/_impl.rs     |  2 +-
 .../rustc_hir_typeck/src/fn_ctxt/checks.rs    |  2 +-
 compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs  |  4 ++--
 compiler/rustc_hir_typeck/src/method/probe.rs |  8 +++----
 compiler/rustc_hir_typeck/src/op.rs           |  2 +-
 .../src/infer/canonical/query_response.rs     |  2 +-
 compiler/rustc_infer/src/traits/engine.rs     |  9 +++----
 .../src/for_loops_over_fallibles.rs           |  2 +-
 .../src/opaque_hidden_inferred_bound.rs       |  4 ++--
 compiler/rustc_mir_transform/src/coroutine.rs |  2 +-
 compiler/rustc_mir_transform/src/validate.rs  |  2 +-
 compiler/rustc_passes/src/check_attr.rs       |  4 ++--
 compiler/rustc_passes/src/layout_test.rs      |  2 +-
 .../src/error_reporting/traits/ambiguity.rs   |  4 ++--
 .../traits/fulfillment_errors.rs              |  8 +++----
 .../src/error_reporting/traits/suggestions.rs |  4 ++--
 compiler/rustc_trait_selection/src/infer.rs   |  4 ++--
 .../src/solve/fulfill.rs                      |  6 ++---
 .../src/solve/inspect/analyse.rs              |  2 +-
 .../src/solve/normalize.rs                    |  8 +++----
 .../src/traits/auto_trait.rs                  |  2 +-
 .../src/traits/coherence.rs                   |  8 +++----
 .../src/traits/const_evaluatable.rs           |  4 ++--
 .../src/traits/engine.rs                      | 24 +++++++++++++++----
 .../src/traits/fulfill.rs                     |  6 ++---
 .../rustc_trait_selection/src/traits/misc.rs  |  8 +++----
 .../rustc_trait_selection/src/traits/mod.rs   | 10 ++++----
 .../src/traits/normalize.rs                   |  2 +-
 .../src/traits/query/dropck_outlives.rs       |  2 +-
 .../src/traits/query/evaluate_obligation.rs   |  2 +-
 .../src/traits/query/type_op/custom.rs        |  2 +-
 .../src/traits/specialize/mod.rs              | 10 ++++----
 .../src/traits/structural_normalize.rs        |  2 +-
 compiler/rustc_traits/src/codegen.rs          |  2 +-
 .../rustc_traits/src/coroutine_witnesses.rs   |  2 +-
 .../src/normalize_projection_ty.rs            |  2 +-
 .../rustc_ty_utils/src/structural_match.rs    |  2 +-
 .../clippy_lints/src/future_not_send.rs       |  2 +-
 .../clippy_utils/src/qualify_min_const_fn.rs  |  2 +-
 .../crates/hir-ty/src/autoderef.rs            |  2 +-
 .../crates/hir-ty/src/infer/coerce.rs         |  6 ++---
 .../crates/hir-ty/src/infer/expr.rs           |  2 +-
 .../crates/hir-ty/src/infer/unify.rs          |  2 +-
 .../crates/hir-ty/src/method_resolution.rs    |  4 ++--
 .../crates/hir-ty/src/next_solver/fulfill.rs  | 14 +++++------
 .../crates/hir-ty/src/next_solver/inspect.rs  |  2 +-
 .../hir-ty/src/next_solver/normalize.rs       |  4 ++--
 .../hir-ty/src/next_solver/obligation_ctxt.rs |  8 +++----
 .../src/next_solver/structural_normalize.rs   |  2 +-
 .../impl-trait/lazy_subtyping_of_opaques.rs   |  2 +-
 74 files changed, 170 insertions(+), 145 deletions(-)

diff --git a/compiler/rustc_borrowck/src/diagnostics/bound_region_errors.rs b/compiler/rustc_borrowck/src/diagnostics/bound_region_errors.rs
index 76da9dc883231..15b2a5ef2e213 100644
--- a/compiler/rustc_borrowck/src/diagnostics/bound_region_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/bound_region_errors.rs
@@ -420,7 +420,7 @@ fn try_extract_error_from_fulfill_cx<'a, 'tcx>(
     // We generally shouldn't have errors here because the query was
     // already run, but there's no point using `span_delayed_bug`
     // when we're going to emit an error here anyway.
-    let _errors = ocx.select_all_or_error();
+    let _errors = ocx.evaluate_obligations_error_on_ambiguity();
     let region_constraints = ocx.infcx.with_region_constraints(|r| r.clone());
     try_extract_error_from_region_constraints(
         ocx.infcx,
diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
index fa1be4cec1ef7..47a1ad0d9489a 100644
--- a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
@@ -1313,7 +1313,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
             let ocx = ObligationCtxt::new_with_diagnostics(self.infcx);
             let cause = ObligationCause::misc(expr.span, self.mir_def_id());
             ocx.register_bound(cause, self.infcx.param_env, ty, clone_trait);
-            let errors = ocx.select_all_or_error();
+            let errors = ocx.evaluate_obligations_error_on_ambiguity();
             if errors.iter().all(|error| {
                 match error.obligation.predicate.as_clause().and_then(|c| c.as_trait_clause()) {
                     Some(clause) => match clause.self_ty().skip_binder().kind() {
@@ -1497,7 +1497,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
         let cause = ObligationCause::misc(span, self.mir_def_id());
 
         ocx.register_bound(cause, self.infcx.param_env, ty, def_id);
-        let errors = ocx.select_all_or_error();
+        let errors = ocx.evaluate_obligations_error_on_ambiguity();
 
         // Only emit suggestion if all required predicates are on generic
         let predicates: Result<Vec<_>, _> = errors
diff --git a/compiler/rustc_borrowck/src/diagnostics/region_errors.rs b/compiler/rustc_borrowck/src/diagnostics/region_errors.rs
index bec4c934502d8..bad5f03e41274 100644
--- a/compiler/rustc_borrowck/src/diagnostics/region_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/region_errors.rs
@@ -1134,7 +1134,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
             Obligation::misc(tcx, span, self.mir_def_id(), self.infcx.param_env, pred)
         }));
 
-        if ocx.select_all_or_error().is_empty() && count > 0 {
+        if ocx.evaluate_obligations_error_on_ambiguity().is_empty() && count > 0 {
             diag.span_suggestion_verbose(
                 tcx.hir_body(*body).value.peel_blocks().span.shrink_to_lo(),
                 fluent::borrowck_dereference_suggestion,
diff --git a/compiler/rustc_borrowck/src/type_check/liveness/trace.rs b/compiler/rustc_borrowck/src/type_check/liveness/trace.rs
index b704d8f0a7692..7ac94020de03b 100644
--- a/compiler/rustc_borrowck/src/type_check/liveness/trace.rs
+++ b/compiler/rustc_borrowck/src/type_check/liveness/trace.rs
@@ -657,7 +657,7 @@ impl<'tcx> LivenessContext<'_, '_, 'tcx> {
                     let errors = match dropck_outlives::compute_dropck_outlives_with_errors(
                         &ocx, op, span,
                     ) {
-                        Ok(_) => ocx.select_all_or_error(),
+                        Ok(_) => ocx.evaluate_obligations_error_on_ambiguity(),
                         Err(e) => e,
                     };
 
diff --git a/compiler/rustc_codegen_ssa/src/base.rs b/compiler/rustc_codegen_ssa/src/base.rs
index 422b06350e1fc..ac3bcb1ea269f 100644
--- a/compiler/rustc_codegen_ssa/src/base.rs
+++ b/compiler/rustc_codegen_ssa/src/base.rs
@@ -139,7 +139,7 @@ pub fn validate_trivial_unsize<'tcx>(
                 ) else {
                     return false;
                 };
-                if !ocx.select_all_or_error().is_empty() {
+                if !ocx.evaluate_obligations_error_on_ambiguity().is_empty() {
                     return false;
                 }
                 infcx.leak_check(universe, None).is_ok()
diff --git a/compiler/rustc_const_eval/src/check_consts/check.rs b/compiler/rustc_const_eval/src/check_consts/check.rs
index 3397bd9a68e4c..413aa5f8b8774 100644
--- a/compiler/rustc_const_eval/src/check_consts/check.rs
+++ b/compiler/rustc_const_eval/src/check_consts/check.rs
@@ -415,7 +415,7 @@ impl<'mir, 'tcx> Checker<'mir, 'tcx> {
             )
         }));
 
-        let errors = ocx.select_all_or_error();
+        let errors = ocx.evaluate_obligations_error_on_ambiguity();
         if errors.is_empty() {
             Some(ConstConditionsHold::Yes)
         } else {
diff --git a/compiler/rustc_const_eval/src/check_consts/qualifs.rs b/compiler/rustc_const_eval/src/check_consts/qualifs.rs
index 8a6827bca2bd6..5b65f1726f6c2 100644
--- a/compiler/rustc_const_eval/src/check_consts/qualifs.rs
+++ b/compiler/rustc_const_eval/src/check_consts/qualifs.rs
@@ -119,7 +119,7 @@ impl Qualif for HasMutInterior {
             ty::TraitRef::new(cx.tcx, freeze_def_id, [ty::GenericArg::from(ty)]),
         );
         ocx.register_obligation(obligation);
-        let errors = ocx.select_all_or_error();
+        let errors = ocx.evaluate_obligations_error_on_ambiguity();
         !errors.is_empty()
     }
 
@@ -197,7 +197,7 @@ impl Qualif for NeedsNonConstDrop {
                     },
                 ),
         ));
-        !ocx.select_all_or_error().is_empty()
+        !ocx.evaluate_obligations_error_on_ambiguity().is_empty()
     }
 
     fn is_structural_in_adt_value<'tcx>(cx: &ConstCx<'_, 'tcx>, adt: AdtDef<'tcx>) -> bool {
diff --git a/compiler/rustc_const_eval/src/util/compare_types.rs b/compiler/rustc_const_eval/src/util/compare_types.rs
index 9eed1a20f1523..8db056ed8737d 100644
--- a/compiler/rustc_const_eval/src/util/compare_types.rs
+++ b/compiler/rustc_const_eval/src/util/compare_types.rs
@@ -43,5 +43,5 @@ pub fn relate_types<'tcx>(
         Ok(()) => {}
         Err(_) => return false,
     };
-    ocx.select_all_or_error().is_empty()
+    ocx.evaluate_obligations_error_on_ambiguity().is_empty()
 }
diff --git a/compiler/rustc_hir_analysis/src/autoderef.rs b/compiler/rustc_hir_analysis/src/autoderef.rs
index 88bd3339e4e18..1f06b1c94237d 100644
--- a/compiler/rustc_hir_analysis/src/autoderef.rs
+++ b/compiler/rustc_hir_analysis/src/autoderef.rs
@@ -199,7 +199,7 @@ impl<'a, 'tcx> Autoderef<'a, 'tcx> {
             // evaluate/fulfill mismatches, but that's not a reason for an ICE.
             return None;
         };
-        let errors = ocx.select_where_possible();
+        let errors = ocx.try_evaluate_obligations();
         if !errors.is_empty() {
             if self.infcx.next_trait_solver() {
                 unreachable!();
diff --git a/compiler/rustc_hir_analysis/src/check/always_applicable.rs b/compiler/rustc_hir_analysis/src/check/always_applicable.rs
index 58c3020f60ede..0ff01477ff24c 100644
--- a/compiler/rustc_hir_analysis/src/check/always_applicable.rs
+++ b/compiler/rustc_hir_analysis/src/check/always_applicable.rs
@@ -235,7 +235,7 @@ fn ensure_impl_predicates_are_implied_by_item_defn<'tcx>(
     // They can probably get removed with better treatment of the new `DropImpl`
     // obligation cause code, and perhaps some custom logic in `report_region_errors`.
 
-    let errors = ocx.select_all_or_error();
+    let errors = ocx.evaluate_obligations_error_on_ambiguity();
     if !errors.is_empty() {
         let mut guar = None;
         let mut root_predicates = FxHashSet::default();
diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
index e1e6860e43004..9c2d52c3e8030 100644
--- a/compiler/rustc_hir_analysis/src/check/check.rs
+++ b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -375,7 +375,7 @@ fn check_opaque_meets_bounds<'tcx>(
 
     // Check that all obligations are satisfied by the implementation's
     // version.
-    let errors = ocx.select_all_or_error();
+    let errors = ocx.evaluate_obligations_error_on_ambiguity();
     if !errors.is_empty() {
         let guar = infcx.err_ctxt().report_fulfillment_errors(errors);
         return Err(guar);
@@ -2028,7 +2028,7 @@ pub(super) fn check_coroutine_obligations(
         ocx.register_obligation(Obligation::new(tcx, cause.clone(), param_env, *predicate));
     }
 
-    let errors = ocx.select_all_or_error();
+    let errors = ocx.evaluate_obligations_error_on_ambiguity();
     debug!(?errors);
     if !errors.is_empty() {
         return Err(infcx.err_ctxt().report_fulfillment_errors(errors));
@@ -2072,7 +2072,7 @@ pub(super) fn check_potentially_region_dependent_goals<'tcx>(
         ocx.register_obligation(Obligation::new(tcx, cause.clone(), param_env, predicate));
     }
 
-    let errors = ocx.select_all_or_error();
+    let errors = ocx.evaluate_obligations_error_on_ambiguity();
     debug!(?errors);
     if errors.is_empty() { Ok(()) } else { Err(infcx.err_ctxt().report_fulfillment_errors(errors)) }
 }
diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
index 946c4936bb64d..5b504cc246d85 100644
--- a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
+++ b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
@@ -363,7 +363,7 @@ fn compare_method_predicate_entailment<'tcx>(
 
     // Check that all obligations are satisfied by the implementation's
     // version.
-    let errors = ocx.select_all_or_error();
+    let errors = ocx.evaluate_obligations_error_on_ambiguity();
     if !errors.is_empty() {
         let reported = infcx.err_ctxt().report_fulfillment_errors(errors);
         return Err(reported);
@@ -669,7 +669,7 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
 
     // Check that all obligations are satisfied by the implementation's
     // RPITs.
-    let errors = ocx.select_all_or_error();
+    let errors = ocx.evaluate_obligations_error_on_ambiguity();
     if !errors.is_empty() {
         if let Err(guar) = try_report_async_mismatch(tcx, infcx, &errors, trait_m, impl_m, impl_sig)
         {
@@ -1215,7 +1215,7 @@ fn check_region_late_boundedness<'tcx>(
         return None;
     };
 
-    let errors = ocx.select_where_possible();
+    let errors = ocx.try_evaluate_obligations();
     if !errors.is_empty() {
         return None;
     }
@@ -2106,7 +2106,7 @@ fn compare_const_predicate_entailment<'tcx>(
 
     // Check that all obligations are satisfied by the implementation's
     // version.
-    let errors = ocx.select_all_or_error();
+    let errors = ocx.evaluate_obligations_error_on_ambiguity();
     if !errors.is_empty() {
         return Err(infcx.err_ctxt().report_fulfillment_errors(errors));
     }
@@ -2242,7 +2242,7 @@ fn compare_type_predicate_entailment<'tcx>(
 
     // Check that all obligations are satisfied by the implementation's
     // version.
-    let errors = ocx.select_all_or_error();
+    let errors = ocx.evaluate_obligations_error_on_ambiguity();
     if !errors.is_empty() {
         let reported = infcx.err_ctxt().report_fulfillment_errors(errors);
         return Err(reported);
@@ -2367,7 +2367,7 @@ pub(super) fn check_type_bounds<'tcx>(
     // Check that all obligations are satisfied by the implementation's
     // version.
     ocx.register_obligations(obligations);
-    let errors = ocx.select_all_or_error();
+    let errors = ocx.evaluate_obligations_error_on_ambiguity();
     if !errors.is_empty() {
         let reported = infcx.err_ctxt().report_fulfillment_errors(errors);
         return Err(reported);
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 3db1c40228f6f..c20e5146546a2 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
@@ -164,7 +164,7 @@ pub(crate) fn check_refining_return_position_impl_trait_in_trait<'tcx>(
         param_env,
         trait_m_sig.inputs_and_output,
     ));
-    if !ocx.select_all_or_error().is_empty() {
+    if !ocx.evaluate_obligations_error_on_ambiguity().is_empty() {
         tcx.dcx().delayed_bug("encountered errors when checking RPITIT refinement (selection)");
         return;
     }
diff --git a/compiler/rustc_hir_analysis/src/check/entry.rs b/compiler/rustc_hir_analysis/src/check/entry.rs
index 97787270be7c1..207cb83bcc8e4 100644
--- a/compiler/rustc_hir_analysis/src/check/entry.rs
+++ b/compiler/rustc_hir_analysis/src/check/entry.rs
@@ -138,7 +138,7 @@ fn check_main_fn_ty(tcx: TyCtxt<'_>, main_def_id: DefId) {
         let ocx = traits::ObligationCtxt::new_with_diagnostics(&infcx);
         let norm_return_ty = ocx.normalize(&cause, param_env, return_ty);
         ocx.register_bound(cause, param_env, norm_return_ty, term_did);
-        let errors = ocx.select_all_or_error();
+        let errors = ocx.evaluate_obligations_error_on_ambiguity();
         if !errors.is_empty() {
             infcx.err_ctxt().report_fulfillment_errors(errors);
             error = true;
diff --git a/compiler/rustc_hir_analysis/src/check/mod.rs b/compiler/rustc_hir_analysis/src/check/mod.rs
index e70d5505aae36..0166c3b980de3 100644
--- a/compiler/rustc_hir_analysis/src/check/mod.rs
+++ b/compiler/rustc_hir_analysis/src/check/mod.rs
@@ -660,7 +660,7 @@ pub fn check_function_signature<'tcx>(
 
     match ocx.eq(&cause, param_env, expected_sig, actual_sig) {
         Ok(()) => {
-            let errors = ocx.select_all_or_error();
+            let errors = ocx.evaluate_obligations_error_on_ambiguity();
             if !errors.is_empty() {
                 return Err(infcx.err_ctxt().report_fulfillment_errors(errors));
             }
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
index 0a555c7f6e9df..7921e34ae4bd5 100644
--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -142,7 +142,7 @@ where
     }
     f(&mut wfcx)?;
 
-    let errors = wfcx.select_all_or_error();
+    let errors = wfcx.evaluate_obligations_error_on_ambiguity();
     if !errors.is_empty() {
         return Err(infcx.err_ctxt().report_fulfillment_errors(errors));
     }
@@ -1803,7 +1803,11 @@ fn receiver_is_valid<'tcx>(
     if let Ok(()) = wfcx.infcx.commit_if_ok(|_| {
         let ocx = ObligationCtxt::new(wfcx.infcx);
         ocx.eq(&cause, wfcx.param_env, self_ty, receiver_ty)?;
-        if ocx.select_all_or_error().is_empty() { Ok(()) } else { Err(NoSolution) }
+        if ocx.evaluate_obligations_error_on_ambiguity().is_empty() {
+            Ok(())
+        } else {
+            Err(NoSolution)
+        }
     }) {
         return Ok(());
     }
@@ -1838,7 +1842,11 @@ fn receiver_is_valid<'tcx>(
         if let Ok(()) = wfcx.infcx.commit_if_ok(|_| {
             let ocx = ObligationCtxt::new(wfcx.infcx);
             ocx.eq(&cause, wfcx.param_env, self_ty, potential_self_ty)?;
-            if ocx.select_all_or_error().is_empty() { Ok(()) } else { Err(NoSolution) }
+            if ocx.evaluate_obligations_error_on_ambiguity().is_empty() {
+                Ok(())
+            } else {
+                Err(NoSolution)
+            }
         }) {
             wfcx.register_obligations(autoderef.into_obligations());
             return Ok(());
diff --git a/compiler/rustc_hir_analysis/src/coherence/builtin.rs b/compiler/rustc_hir_analysis/src/coherence/builtin.rs
index 0b9a01d6042f1..b7a74ac445bfc 100644
--- a/compiler/rustc_hir_analysis/src/coherence/builtin.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/builtin.rs
@@ -333,7 +333,7 @@ fn visit_implementation_of_dispatch_from_dyn(checker: &Checker<'_>) -> Result<()
                     param_env,
                     ty::TraitRef::new(tcx, trait_ref.def_id, [ty_a, ty_b]),
                 ));
-                let errors = ocx.select_all_or_error();
+                let errors = ocx.evaluate_obligations_error_on_ambiguity();
                 if !errors.is_empty() {
                     if is_from_coerce_pointee_derive(tcx, span) {
                         return Err(tcx.dcx().emit_err(errors::CoerceFieldValidity {
@@ -558,7 +558,7 @@ pub(crate) fn coerce_unsized_info<'tcx>(
         ty::TraitRef::new(tcx, trait_def_id, [source, target]),
     );
     ocx.register_obligation(obligation);
-    let errors = ocx.select_all_or_error();
+    let errors = ocx.evaluate_obligations_error_on_ambiguity();
 
     if !errors.is_empty() {
         if is_from_coerce_pointee_derive(tcx, span) {
diff --git a/compiler/rustc_hir_analysis/src/coherence/orphan.rs b/compiler/rustc_hir_analysis/src/coherence/orphan.rs
index 5a61248cab8fe..c4aeb4c85bb9e 100644
--- a/compiler/rustc_hir_analysis/src/coherence/orphan.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/orphan.rs
@@ -315,7 +315,7 @@ fn orphan_check<'tcx>(
         let ocx = traits::ObligationCtxt::new(&infcx);
         let ty = ocx.normalize(&cause, ty::ParamEnv::empty(), user_ty);
         let ty = infcx.resolve_vars_if_possible(ty);
-        let errors = ocx.select_where_possible();
+        let errors = ocx.try_evaluate_obligations();
         if !errors.is_empty() {
             return Ok(user_ty);
         }
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
index 02baaec37138c..f78eb2bae8ada 100644
--- a/compiler/rustc_hir_analysis/src/collect.rs
+++ b/compiler/rustc_hir_analysis/src/collect.rs
@@ -1267,7 +1267,7 @@ pub fn suggest_impl_trait<'tcx>(
                 Ty::new_projection_from_args(infcx.tcx, assoc_item_def_id, args),
             );
             // FIXME(compiler-errors): We may benefit from resolving regions here.
-            if ocx.select_where_possible().is_empty()
+            if ocx.try_evaluate_obligations().is_empty()
                 && let item_ty = infcx.resolve_vars_if_possible(item_ty)
                 && let Some(item_ty) = item_ty.make_suggestable(infcx.tcx, false, None)
                 && let Some(sugg) = formatter(
diff --git a/compiler/rustc_hir_analysis/src/hir_wf_check.rs b/compiler/rustc_hir_analysis/src/hir_wf_check.rs
index d8578970adc94..f879153c5765a 100644
--- a/compiler/rustc_hir_analysis/src/hir_wf_check.rs
+++ b/compiler/rustc_hir_analysis/src/hir_wf_check.rs
@@ -95,7 +95,7 @@ pub(super) fn diagnostic_hir_wf_check<'tcx>(
                 ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(tcx_ty.into())),
             ));
 
-            for error in ocx.select_all_or_error() {
+            for error in ocx.evaluate_obligations_error_on_ambiguity() {
                 debug!("Wf-check got error for {:?}: {:?}", ty, error);
                 if error.obligation.predicate == self.predicate {
                     // Save the cause from the greatest depth - this corresponds
diff --git a/compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs b/compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs
index 13c744ab46139..64a36e2d26813 100644
--- a/compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs
+++ b/compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs
@@ -183,7 +183,7 @@ fn get_impl_args(
         &ObligationCause::misc(impl1_span, impl1_def_id),
     );
 
-    let errors = ocx.select_all_or_error();
+    let errors = ocx.evaluate_obligations_error_on_ambiguity();
     if !errors.is_empty() {
         let guar = ocx.infcx.err_ctxt().report_fulfillment_errors(errors);
         return Err(guar);
diff --git a/compiler/rustc_hir_typeck/src/coercion.rs b/compiler/rustc_hir_typeck/src/coercion.rs
index ced2cf2b57b14..1e5fea1db9fcc 100644
--- a/compiler/rustc_hir_typeck/src/coercion.rs
+++ b/compiler/rustc_hir_typeck/src/coercion.rs
@@ -140,7 +140,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
                 Ok(InferOk { value, obligations }) if self.next_trait_solver() => {
                     let ocx = ObligationCtxt::new(self);
                     ocx.register_obligations(obligations);
-                    if ocx.select_where_possible().is_empty() {
+                    if ocx.try_evaluate_obligations().is_empty() {
                         Ok(InferOk { value, obligations: ocx.into_pending_obligations() })
                     } else {
                         Err(TypeError::Mismatch)
@@ -677,7 +677,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
                 Some(ty::PredicateKind::AliasRelate(..)) => {
                     let ocx = ObligationCtxt::new(self);
                     ocx.register_obligation(obligation);
-                    if !ocx.select_where_possible().is_empty() {
+                    if !ocx.try_evaluate_obligations().is_empty() {
                         return Err(TypeError::Mismatch);
                     }
                     coercion.obligations.extend(ocx.into_pending_obligations());
@@ -1099,7 +1099,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 return false;
             };
             ocx.register_obligations(ok.obligations);
-            ocx.select_where_possible().is_empty()
+            ocx.try_evaluate_obligations().is_empty()
         })
     }
 
@@ -1203,7 +1203,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             if self.next_trait_solver() {
                                 let ocx = ObligationCtxt::new(self);
                                 let value = ocx.lub(cause, self.param_env, prev_ty, new_ty)?;
-                                if ocx.select_where_possible().is_empty() {
+                                if ocx.try_evaluate_obligations().is_empty() {
                                     Ok(InferOk {
                                         value,
                                         obligations: ocx.into_pending_obligations(),
@@ -1818,7 +1818,7 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
                         ))
                     }),
                 );
-                ocx.select_where_possible().is_empty()
+                ocx.try_evaluate_obligations().is_empty()
             })
         };
 
diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index f9cdc923670f0..e663dd25e0ea9 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -2017,7 +2017,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             self.fudge_inference_if_ok(|| {
                 let ocx = ObligationCtxt::new(self);
                 ocx.sup(&self.misc(path_span), self.param_env, expected, adt_ty)?;
-                if !ocx.select_where_possible().is_empty() {
+                if !ocx.try_evaluate_obligations().is_empty() {
                     return Err(TypeError::Mismatch);
                 }
                 Ok(self.resolve_vars_if_possible(adt_ty))
@@ -3663,7 +3663,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 ),
             );
 
-            let true_errors = ocx.select_where_possible();
+            let true_errors = ocx.try_evaluate_obligations();
 
             // Do a leak check -- we can't really report a useful error here,
             // but it at least avoids an ICE when the error has to do with higher-ranked
@@ -3671,7 +3671,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             self.leak_check(outer_universe, Some(snapshot))?;
 
             // Bail if we have ambiguity errors, which we can't report in a useful way.
-            let ambiguity_errors = ocx.select_all_or_error();
+            let ambiguity_errors = ocx.evaluate_obligations_error_on_ambiguity();
             if true_errors.is_empty() && !ambiguity_errors.is_empty() {
                 return Err(NoSolution);
             }
diff --git a/compiler/rustc_hir_typeck/src/fallback.rs b/compiler/rustc_hir_typeck/src/fallback.rs
index ef88e02fd98c2..be1c173ffbf6f 100644
--- a/compiler/rustc_hir_typeck/src/fallback.rs
+++ b/compiler/rustc_hir_typeck/src/fallback.rs
@@ -495,7 +495,7 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
                         .expect("expected diverging var to be unconstrained");
                 }
 
-                ocx.select_where_possible()
+                ocx.try_evaluate_obligations()
             })
         };
 
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
index 35253e4c29195..dde6b8ce9b8b2 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -654,7 +654,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         &self,
         mutate_fulfillment_errors: impl Fn(&mut Vec<traits::FulfillmentError<'tcx>>),
     ) {
-        let mut result = self.fulfillment_cx.borrow_mut().select_where_possible(self);
+        let mut result = self.fulfillment_cx.borrow_mut().try_evaluate_obligations(self);
         if !result.is_empty() {
             mutate_fulfillment_errors(&mut result);
             self.adjust_fulfillment_errors_for_expr_obligation(&mut result);
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
index c8943d4634e29..4d1c7be391977 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -255,7 +255,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     // No argument expectations are produced if unification fails.
                     let origin = self.misc(call_span);
                     ocx.sup(&origin, self.param_env, expected_output, formal_output)?;
-                    if !ocx.select_where_possible().is_empty() {
+                    if !ocx.try_evaluate_obligations().is_empty() {
                         return Err(TypeError::Mismatch);
                     }
 
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs
index 7a060cafeab1c..e9f8bcd06be2d 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs
@@ -199,7 +199,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     let ocx = ObligationCtxt::new(self);
                     let normalized_fn_sig =
                         ocx.normalize(&ObligationCause::dummy(), self.param_env, fn_sig);
-                    if ocx.select_all_or_error().is_empty() {
+                    if ocx.evaluate_obligations_error_on_ambiguity().is_empty() {
                         let normalized_fn_sig = self.resolve_vars_if_possible(normalized_fn_sig);
                         if !normalized_fn_sig.has_infer() {
                             return normalized_fn_sig;
@@ -347,7 +347,7 @@ impl<'tcx> HirTyLowerer<'tcx> for FnCtxt<'_, 'tcx> {
             );
             ocx.register_obligations(impl_obligations);
 
-            let mut errors = ocx.select_where_possible();
+            let mut errors = ocx.try_evaluate_obligations();
             if !errors.is_empty() {
                 fulfillment_errors.append(&mut errors);
                 return false;
diff --git a/compiler/rustc_hir_typeck/src/method/probe.rs b/compiler/rustc_hir_typeck/src/method/probe.rs
index 12f80a197b1b8..1ef1fdef6c99d 100644
--- a/compiler/rustc_hir_typeck/src/method/probe.rs
+++ b/compiler/rustc_hir_typeck/src/method/probe.rs
@@ -1906,7 +1906,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
             // them to deal with defining uses in `method_autoderef_steps`.
             if self.next_trait_solver() {
                 ocx.register_obligations(instantiate_self_ty_obligations.iter().cloned());
-                let errors = ocx.select_where_possible();
+                let errors = ocx.try_evaluate_obligations();
                 if !errors.is_empty() {
                     unreachable!("unexpected autoderef error {errors:?}");
                 }
@@ -2103,7 +2103,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
             }
 
             // Evaluate those obligations to see if they might possibly hold.
-            for error in ocx.select_where_possible() {
+            for error in ocx.try_evaluate_obligations() {
                 result = ProbeResult::NoMatch;
                 let nested_predicate = self.resolve_vars_if_possible(error.obligation.predicate);
                 if let Some(trait_predicate) = trait_predicate
@@ -2143,7 +2143,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
                 }
 
                 // Evaluate those obligations to see if they might possibly hold.
-                for error in ocx.select_where_possible() {
+                for error in ocx.try_evaluate_obligations() {
                     result = ProbeResult::NoMatch;
                     possibly_unsatisfied_predicates.push((
                         error.obligation.predicate,
@@ -2230,7 +2230,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
                     };
                     let ocx = ObligationCtxt::new(self);
                     let self_ty = ocx.register_infer_ok_obligations(ok);
-                    if !ocx.select_where_possible().is_empty() {
+                    if !ocx.try_evaluate_obligations().is_empty() {
                         debug!("failed to prove instantiate self_ty obligations");
                         return false;
                     }
diff --git a/compiler/rustc_hir_typeck/src/op.rs b/compiler/rustc_hir_typeck/src/op.rs
index a8e8582c51c49..d18aed00a6f6d 100644
--- a/compiler/rustc_hir_typeck/src/op.rs
+++ b/compiler/rustc_hir_typeck/src/op.rs
@@ -1030,7 +1030,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 );
                 let ocx = ObligationCtxt::new_with_diagnostics(&self.infcx);
                 ocx.register_obligation(obligation);
-                Err(ocx.select_all_or_error())
+                Err(ocx.evaluate_obligations_error_on_ambiguity())
             }
         }
     }
diff --git a/compiler/rustc_infer/src/infer/canonical/query_response.rs b/compiler/rustc_infer/src/infer/canonical/query_response.rs
index 37a1960520661..b4952e7bfe153 100644
--- a/compiler/rustc_infer/src/infer/canonical/query_response.rs
+++ b/compiler/rustc_infer/src/infer/canonical/query_response.rs
@@ -125,7 +125,7 @@ impl<'tcx> InferCtxt<'tcx> {
         T: Debug + TypeFoldable<TyCtxt<'tcx>>,
     {
         // Select everything, returning errors.
-        let errors = fulfill_cx.select_all_or_error(self);
+        let errors = fulfill_cx.evaluate_obligations_error_on_ambiguity(self);
 
         // True error!
         if errors.iter().any(|e| e.is_true_error()) {
diff --git a/compiler/rustc_infer/src/traits/engine.rs b/compiler/rustc_infer/src/traits/engine.rs
index 4a252719694d5..39fff48de6aa6 100644
--- a/compiler/rustc_infer/src/traits/engine.rs
+++ b/compiler/rustc_infer/src/traits/engine.rs
@@ -72,6 +72,7 @@ pub trait TraitEngine<'tcx, E: 'tcx>: 'tcx {
             self.register_predicate_obligation(infcx, obligation);
         }
     }
+
     /// Go over the list of pending obligations and try to evaluate them.
     ///
     /// For each result:
@@ -81,7 +82,7 @@ pub trait TraitEngine<'tcx, E: 'tcx>: 'tcx {
     ///
     /// Returns a list of errors from obligations that evaluated to Err.
     #[must_use]
-    fn select_where_possible(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<E>;
+    fn try_evaluate_obligations(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<E>;
 
     fn collect_remaining_errors(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<E>;
 
@@ -94,8 +95,8 @@ pub trait TraitEngine<'tcx, E: 'tcx>: 'tcx {
     ///
     /// Returns a list of errors from obligations that evaluated to Ambiguous or Err.
     #[must_use]
-    fn select_all_or_error(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<E> {
-        let errors = self.select_where_possible(infcx);
+    fn evaluate_obligations_error_on_ambiguity(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<E> {
+        let errors = self.try_evaluate_obligations(infcx);
         if !errors.is_empty() {
             return errors;
         }
@@ -108,7 +109,7 @@ pub trait TraitEngine<'tcx, E: 'tcx>: 'tcx {
     fn pending_obligations(&self) -> PredicateObligations<'tcx>;
 
     /// Among all pending obligations, collect those are stalled on a inference variable which has
-    /// changed since the last call to `select_where_possible`. Those obligations are marked as
+    /// changed since the last call to `try_evaluate_obligations`. Those obligations are marked as
     /// successful and returned.
     fn drain_stalled_obligations_for_coroutines(
         &mut self,
diff --git a/compiler/rustc_lint/src/for_loops_over_fallibles.rs b/compiler/rustc_lint/src/for_loops_over_fallibles.rs
index 9e1fc59817119..fe95a682c6376 100644
--- a/compiler/rustc_lint/src/for_loops_over_fallibles.rs
+++ b/compiler/rustc_lint/src/for_loops_over_fallibles.rs
@@ -180,5 +180,5 @@ fn suggest_question_mark<'tcx>(
         into_iterator_did,
     );
 
-    ocx.select_all_or_error().is_empty()
+    ocx.evaluate_obligations_error_on_ambiguity().is_empty()
 }
diff --git a/compiler/rustc_lint/src/opaque_hidden_inferred_bound.rs b/compiler/rustc_lint/src/opaque_hidden_inferred_bound.rs
index f836094191e1d..3f2ca92a021a6 100644
--- a/compiler/rustc_lint/src/opaque_hidden_inferred_bound.rs
+++ b/compiler/rustc_lint/src/opaque_hidden_inferred_bound.rs
@@ -151,7 +151,7 @@ impl<'tcx> LateLintPass<'tcx> for OpaqueHiddenInferredBound {
                     let ocx = ObligationCtxt::new(infcx);
                     let assoc_pred =
                         ocx.normalize(&traits::ObligationCause::dummy(), cx.param_env, assoc_pred);
-                    if !ocx.select_all_or_error().is_empty() {
+                    if !ocx.evaluate_obligations_error_on_ambiguity().is_empty() {
                         // Can't normalize for some reason...?
                         continue;
                     }
@@ -166,7 +166,7 @@ impl<'tcx> LateLintPass<'tcx> for OpaqueHiddenInferredBound {
                     // If that predicate doesn't hold modulo regions (but passed during type-check),
                     // then we must've taken advantage of the hack in `project_and_unify_types` where
                     // we replace opaques with inference vars. Emit a warning!
-                    if !ocx.select_all_or_error().is_empty() {
+                    if !ocx.evaluate_obligations_error_on_ambiguity().is_empty() {
                         // If it's a trait bound and an opaque that doesn't satisfy it,
                         // then we can emit a suggestion to add the bound.
                         let add_bound = match (proj_term.kind(), assoc_pred.kind().skip_binder()) {
diff --git a/compiler/rustc_mir_transform/src/coroutine.rs b/compiler/rustc_mir_transform/src/coroutine.rs
index 814eded910df5..c136df812a3f0 100644
--- a/compiler/rustc_mir_transform/src/coroutine.rs
+++ b/compiler/rustc_mir_transform/src/coroutine.rs
@@ -1429,7 +1429,7 @@ fn check_field_tys_sized<'tcx>(
         );
     }
 
-    let errors = ocx.select_all_or_error();
+    let errors = ocx.evaluate_obligations_error_on_ambiguity();
     debug!(?errors);
     if !errors.is_empty() {
         infcx.err_ctxt().report_fulfillment_errors(errors);
diff --git a/compiler/rustc_mir_transform/src/validate.rs b/compiler/rustc_mir_transform/src/validate.rs
index cbabb982df8b8..95873484b6529 100644
--- a/compiler/rustc_mir_transform/src/validate.rs
+++ b/compiler/rustc_mir_transform/src/validate.rs
@@ -623,7 +623,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             param_env,
             pred,
         ));
-        ocx.select_all_or_error().is_empty()
+        ocx.evaluate_obligations_error_on_ambiguity().is_empty()
     }
 }
 
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 4ea237cfa0321..80879c88d1ba8 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -2013,7 +2013,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         let sig = ocx.normalize(&cause, param_env, sig);
 
         // proc macro is not WF.
-        let errors = ocx.select_where_possible();
+        let errors = ocx.try_evaluate_obligations();
         if !errors.is_empty() {
             return;
         }
@@ -2081,7 +2081,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             self.abort.set(true);
         }
 
-        let errors = ocx.select_all_or_error();
+        let errors = ocx.evaluate_obligations_error_on_ambiguity();
         if !errors.is_empty() {
             infcx.err_ctxt().report_fulfillment_errors(errors);
             self.abort.set(true);
diff --git a/compiler/rustc_passes/src/layout_test.rs b/compiler/rustc_passes/src/layout_test.rs
index a19faf0fa8367..4054cfa56330e 100644
--- a/compiler/rustc_passes/src/layout_test.rs
+++ b/compiler/rustc_passes/src/layout_test.rs
@@ -56,7 +56,7 @@ pub fn ensure_wf<'tcx>(
         pred,
     );
     ocx.register_obligation(obligation);
-    let errors = ocx.select_all_or_error();
+    let errors = ocx.evaluate_obligations_error_on_ambiguity();
     if !errors.is_empty() {
         infcx.err_ctxt().report_fulfillment_errors(errors);
         false
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/ambiguity.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/ambiguity.rs
index af912227ce4e4..edb002c69e760 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/ambiguity.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/ambiguity.rs
@@ -83,7 +83,7 @@ pub fn compute_applicable_impls_for_diagnostics<'tcx>(
                 });
             ocx.register_obligations(obligations);
 
-            ocx.select_where_possible().is_empty()
+            ocx.try_evaluate_obligations().is_empty()
         })
     };
 
@@ -113,7 +113,7 @@ pub fn compute_applicable_impls_for_diagnostics<'tcx>(
                 return false;
             }
 
-            ocx.select_where_possible().is_empty()
+            ocx.try_evaluate_obligations().is_empty()
         })
     };
 
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 7e2bec2876231..4305d4160ebf5 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
@@ -1470,7 +1470,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     //
                     // we intentionally drop errors from normalization here,
                     // since the normalization is just done to improve the error message.
-                    let _ = ocx.select_where_possible();
+                    let _ = ocx.try_evaluate_obligations();
 
                     if let Err(new_err) =
                         ocx.eq(&obligation.cause, obligation.param_env, data.term, normalized_term)
@@ -2086,7 +2086,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                                 )
                             }),
                     );
-                    if !ocx.select_where_possible().is_empty() {
+                    if !ocx.try_evaluate_obligations().is_empty() {
                         return false;
                     }
 
@@ -2102,7 +2102,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         {
                             terrs.push(terr);
                         }
-                        if !ocx.select_where_possible().is_empty() {
+                        if !ocx.try_evaluate_obligations().is_empty() {
                             return false;
                         }
                     }
@@ -3440,7 +3440,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 );
                 let ocx = ObligationCtxt::new(self);
                 ocx.register_obligation(obligation);
-                if ocx.select_all_or_error().is_empty() {
+                if ocx.evaluate_obligations_error_on_ambiguity().is_empty() {
                     return Ok((
                         self.tcx
                             .fn_trait_kind_from_def_id(trait_def_id)
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 5665229a4cbe6..136a61598d50e 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -4590,7 +4590,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 param_env,
                 projection,
             ));
-            if ocx.select_where_possible().is_empty()
+            if ocx.try_evaluate_obligations().is_empty()
                 && let ty = self.resolve_vars_if_possible(ty)
                 && !ty.is_ty_var()
             {
@@ -4737,7 +4737,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         pred,
                     ));
                 });
-                if !ocx.select_where_possible().is_empty() {
+                if !ocx.try_evaluate_obligations().is_empty() {
                     // encountered errors.
                     return;
                 }
diff --git a/compiler/rustc_trait_selection/src/infer.rs b/compiler/rustc_trait_selection/src/infer.rs
index cd076d1cb692a..f55468d6324af 100644
--- a/compiler/rustc_trait_selection/src/infer.rs
+++ b/compiler/rustc_trait_selection/src/infer.rs
@@ -25,7 +25,7 @@ impl<'tcx> InferCtxt<'tcx> {
             let Ok(()) = ocx.eq(&ObligationCause::dummy(), param_env, a, b) else {
                 return false;
             };
-            ocx.select_where_possible().is_empty()
+            ocx.try_evaluate_obligations().is_empty()
         })
     }
 
@@ -124,7 +124,7 @@ impl<'tcx> InferCtxt<'tcx> {
                 param_env,
                 ty::TraitRef::new(self.tcx, trait_def_id, [ty]),
             ));
-            let errors = ocx.select_where_possible();
+            let errors = ocx.try_evaluate_obligations();
             // Find the original predicate in the list of predicates that could definitely not be fulfilled.
             // If it is in that list, then we know this doesn't even shallowly implement the trait.
             // If it is not in that list, it was fulfilled, but there may be nested obligations, which we don't care about here.
diff --git a/compiler/rustc_trait_selection/src/solve/fulfill.rs b/compiler/rustc_trait_selection/src/solve/fulfill.rs
index bff4f6ce3fc6b..ddd79e1dc9405 100644
--- a/compiler/rustc_trait_selection/src/solve/fulfill.rs
+++ b/compiler/rustc_trait_selection/src/solve/fulfill.rs
@@ -60,7 +60,7 @@ struct ObligationStorage<'tcx> {
     /// Obligations which resulted in an overflow in fulfillment itself.
     ///
     /// We cannot eagerly return these as error so we instead store them here
-    /// to avoid recomputing them each time `select_where_possible` is called.
+    /// to avoid recomputing them each time `try_evaluate_obligations` is called.
     /// This also allows us to return the correct `FulfillmentError` for them.
     overflowed: Vec<PredicateObligation<'tcx>>,
     pending: PendingObligations<'tcx>,
@@ -101,7 +101,7 @@ impl<'tcx> ObligationStorage<'tcx> {
             // IMPORTANT: we must not use solve any inference variables in the obligations
             // as this is all happening inside of a probe. We use a probe to make sure
             // we get all obligations involved in the overflow. We pretty much check: if
-            // we were to do another step of `select_where_possible`, which goals would
+            // we were to do another step of `try_evaluate_obligations`, which goals would
             // change.
             // FIXME: <https://github.com/Gankra/thin-vec/pull/66> is merged, this can be removed.
             self.overflowed.extend(
@@ -179,7 +179,7 @@ where
             .collect()
     }
 
-    fn select_where_possible(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<E> {
+    fn try_evaluate_obligations(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<E> {
         assert_eq!(self.usable_in_snapshot, infcx.num_open_snapshots());
         let mut errors = Vec::new();
         loop {
diff --git a/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs b/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs
index c010add0fc50f..488315054c6aa 100644
--- a/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs
+++ b/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs
@@ -76,7 +76,7 @@ impl<'tcx> NormalizesToTermHack<'tcx> {
             self.unconstrained_term,
         )?;
         f(&ocx);
-        let errors = ocx.select_all_or_error();
+        let errors = ocx.evaluate_obligations_error_on_ambiguity();
         if errors.is_empty() {
             Ok(Certainty::Yes)
         } else if errors.iter().all(|e| !e.is_true_error()) {
diff --git a/compiler/rustc_trait_selection/src/solve/normalize.rs b/compiler/rustc_trait_selection/src/solve/normalize.rs
index 8f44c26b70dad..567f660a59383 100644
--- a/compiler/rustc_trait_selection/src/solve/normalize.rs
+++ b/compiler/rustc_trait_selection/src/solve/normalize.rs
@@ -79,7 +79,7 @@ where
         stalled_coroutine_goals: vec![],
     };
     let value = value.try_fold_with(&mut folder)?;
-    let errors = folder.fulfill_cx.select_all_or_error(at.infcx);
+    let errors = folder.fulfill_cx.evaluate_obligations_error_on_ambiguity(at.infcx);
     if errors.is_empty() { Ok((value, folder.stalled_coroutine_goals)) } else { Err(errors) }
 }
 
@@ -128,7 +128,7 @@ where
         );
 
         self.fulfill_cx.register_predicate_obligation(infcx, obligation);
-        self.select_all_and_stall_coroutine_predicates()?;
+        self.evaluate_all_error_on_ambiguity_stall_coroutine_predicates()?;
 
         // Alias is guaranteed to be fully structurally resolved,
         // so we can super fold here.
@@ -143,8 +143,8 @@ where
         Ok(result)
     }
 
-    fn select_all_and_stall_coroutine_predicates(&mut self) -> Result<(), Vec<E>> {
-        let errors = self.fulfill_cx.select_where_possible(self.at.infcx);
+    fn evaluate_all_error_on_ambiguity_stall_coroutine_predicates(&mut self) -> Result<(), Vec<E>> {
+        let errors = self.fulfill_cx.try_evaluate_obligations(self.at.infcx);
         if !errors.is_empty() {
             return Err(errors);
         }
diff --git a/compiler/rustc_trait_selection/src/traits/auto_trait.rs b/compiler/rustc_trait_selection/src/traits/auto_trait.rs
index c63cc0e17ab9f..09709291a4b95 100644
--- a/compiler/rustc_trait_selection/src/traits/auto_trait.rs
+++ b/compiler/rustc_trait_selection/src/traits/auto_trait.rs
@@ -155,7 +155,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {
         // an additional sanity check.
         let ocx = ObligationCtxt::new(&infcx);
         ocx.register_bound(ObligationCause::dummy(), full_env, ty, trait_did);
-        let errors = ocx.select_all_or_error();
+        let errors = ocx.evaluate_obligations_error_on_ambiguity();
         if !errors.is_empty() {
             panic!("Unable to fulfill trait {trait_did:?} for '{ty:?}': {errors:?}");
         }
diff --git a/compiler/rustc_trait_selection/src/traits/coherence.rs b/compiler/rustc_trait_selection/src/traits/coherence.rs
index 8e8c7dd7c9d48..d81030ad7c492 100644
--- a/compiler/rustc_trait_selection/src/traits/coherence.rs
+++ b/compiler/rustc_trait_selection/src/traits/coherence.rs
@@ -371,7 +371,7 @@ fn impl_intersection_has_impossible_obligation<'a, 'cx, 'tcx>(
 
         let ocx = ObligationCtxt::new(infcx);
         ocx.register_obligations(obligations.iter().cloned());
-        let hard_errors = ocx.select_where_possible();
+        let hard_errors = ocx.try_evaluate_obligations();
         if !hard_errors.is_empty() {
             assert!(
                 hard_errors.iter().all(|e| e.is_true_error()),
@@ -386,7 +386,7 @@ fn impl_intersection_has_impossible_obligation<'a, 'cx, 'tcx>(
         let ambiguities = ocx.into_pending_obligations();
         let ocx = ObligationCtxt::new_with_diagnostics(infcx);
         ocx.register_obligations(ambiguities);
-        let errors_and_ambiguities = ocx.select_all_or_error();
+        let errors_and_ambiguities = ocx.evaluate_obligations_error_on_ambiguity();
         // We only care about the obligations that are *definitely* true errors.
         // Ambiguities do not prove the disjointness of two impls.
         let (errors, ambiguities): (Vec<_>, Vec<_>) =
@@ -623,7 +623,7 @@ fn try_prove_negated_where_clause<'tcx>(
         param_env,
         negative_predicate,
     ));
-    if !ocx.select_all_or_error().is_empty() {
+    if !ocx.evaluate_obligations_error_on_ambiguity().is_empty() {
         return false;
     }
 
@@ -743,7 +743,7 @@ impl<'a, 'tcx> ProofTreeVisitor<'tcx> for AmbiguityCausesVisitor<'a, 'tcx> {
                 ty = ocx
                     .structurally_normalize_ty(&ObligationCause::dummy(), param_env, ty)
                     .map_err(|_| ())?;
-                if !ocx.select_where_possible().is_empty() {
+                if !ocx.try_evaluate_obligations().is_empty() {
                     return Err(());
                 }
             }
diff --git a/compiler/rustc_trait_selection/src/traits/const_evaluatable.rs b/compiler/rustc_trait_selection/src/traits/const_evaluatable.rs
index 39333082acdff..45f30cd14c672 100644
--- a/compiler/rustc_trait_selection/src/traits/const_evaluatable.rs
+++ b/compiler/rustc_trait_selection/src/traits/const_evaluatable.rs
@@ -176,7 +176,7 @@ fn satisfied_from_param_env<'tcx>(
             if self.infcx.probe(|_| {
                 let ocx = ObligationCtxt::new(self.infcx);
                 ocx.eq(&ObligationCause::dummy(), self.param_env, c, self.ct).is_ok()
-                    && ocx.select_all_or_error().is_empty()
+                    && ocx.evaluate_obligations_error_on_ambiguity().is_empty()
             }) {
                 self.single_match = match self.single_match {
                     None => Some(Ok(c)),
@@ -217,7 +217,7 @@ fn satisfied_from_param_env<'tcx>(
     if let Some(Ok(c)) = single_match {
         let ocx = ObligationCtxt::new(infcx);
         assert!(ocx.eq(&ObligationCause::dummy(), param_env, c, ct).is_ok());
-        assert!(ocx.select_all_or_error().is_empty());
+        assert!(ocx.evaluate_obligations_error_on_ambiguity().is_empty());
         return true;
     }
 
diff --git a/compiler/rustc_trait_selection/src/traits/engine.rs b/compiler/rustc_trait_selection/src/traits/engine.rs
index 18f28d72f6f8f..eee23a298449d 100644
--- a/compiler/rustc_trait_selection/src/traits/engine.rs
+++ b/compiler/rustc_trait_selection/src/traits/engine.rs
@@ -202,14 +202,30 @@ where
             .map(|infer_ok| self.register_infer_ok_obligations(infer_ok))
     }
 
+    /// Go over the list of pending obligations and try to evaluate them.
+    ///
+    /// For each result:
+    /// Ok: remove the obligation from the list
+    /// Ambiguous: leave the obligation in the list to be evaluated later
+    /// Err: remove the obligation from the list and return an error
+    ///
+    /// Returns a list of errors from obligations that evaluated to Err.
     #[must_use]
-    pub fn select_where_possible(&self) -> Vec<E> {
-        self.engine.borrow_mut().select_where_possible(self.infcx)
+    pub fn try_evaluate_obligations(&self) -> Vec<E> {
+        self.engine.borrow_mut().try_evaluate_obligations(self.infcx)
     }
 
+    /// Evaluate all pending obligations, return error if they can't be evaluated.
+    ///
+    /// For each result:
+    /// Ok: remove the obligation from the list
+    /// Ambiguous: remove the obligation from the list and return an error
+    /// Err: remove the obligation from the list and return an error
+    ///
+    /// Returns a list of errors from obligations that evaluated to Ambiguous or Err.
     #[must_use]
-    pub fn select_all_or_error(&self) -> Vec<E> {
-        self.engine.borrow_mut().select_all_or_error(self.infcx)
+    pub fn evaluate_obligations_error_on_ambiguity(&self) -> Vec<E> {
+        self.engine.borrow_mut().evaluate_obligations_error_on_ambiguity(self.infcx)
     }
 
     /// Returns the not-yet-processed and stalled obligations from the
diff --git a/compiler/rustc_trait_selection/src/traits/fulfill.rs b/compiler/rustc_trait_selection/src/traits/fulfill.rs
index 6b884b3608044..681f015c17990 100644
--- a/compiler/rustc_trait_selection/src/traits/fulfill.rs
+++ b/compiler/rustc_trait_selection/src/traits/fulfill.rs
@@ -52,11 +52,11 @@ impl<'tcx> ForestObligation for PendingPredicateObligation<'tcx> {
 /// consists of a list of obligations that must be (eventually)
 /// satisfied. The job is to track which are satisfied, which yielded
 /// errors, and which are still pending. At any point, users can call
-/// `select_where_possible`, and the fulfillment context will try to do
+/// `try_evaluate_obligations`, and the fulfillment context will try to do
 /// selection, retaining only those obligations that remain
 /// ambiguous. This may be helpful in pushing type inference
 /// along. Once all type inference constraints have been generated, the
-/// method `select_all_or_error` can be used to report any remaining
+/// method `evaluate_obligations_error_on_ambiguity` can be used to report any remaining
 /// ambiguous cases as errors.
 pub struct FulfillmentContext<'tcx, E: 'tcx> {
     /// A list of all obligations that have been registered with this
@@ -163,7 +163,7 @@ where
             .collect()
     }
 
-    fn select_where_possible(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<E> {
+    fn try_evaluate_obligations(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<E> {
         let selcx = SelectionContext::new(infcx);
         self.select(selcx)
     }
diff --git a/compiler/rustc_trait_selection/src/traits/misc.rs b/compiler/rustc_trait_selection/src/traits/misc.rs
index 4c25882daa92f..f33196bab6470 100644
--- a/compiler/rustc_trait_selection/src/traits/misc.rs
+++ b/compiler/rustc_trait_selection/src/traits/misc.rs
@@ -156,7 +156,7 @@ pub fn type_allowed_to_implement_const_param_ty<'tcx>(
                 ty::ClauseKind::UnstableFeature(sym::unsized_const_params),
             ));
 
-            if !ocx.select_all_or_error().is_empty() {
+            if !ocx.evaluate_obligations_error_on_ambiguity().is_empty() {
                 return Err(ConstParamTyImplementationError::UnsizedConstParamsFeatureRequired);
             }
         }
@@ -168,7 +168,7 @@ pub fn type_allowed_to_implement_const_param_ty<'tcx>(
             tcx.require_lang_item(LangItem::ConstParamTy, parent_cause.span),
         );
 
-        let errors = ocx.select_all_or_error();
+        let errors = ocx.evaluate_obligations_error_on_ambiguity();
         if !errors.is_empty() {
             infringing_inner_tys.push((inner_ty, InfringingFieldsReason::Fulfill(errors)));
             continue;
@@ -235,7 +235,7 @@ pub fn all_fields_implement_trait<'tcx>(
                 ObligationCause::dummy_with_span(field_ty_span)
             };
             let ty = ocx.normalize(&normalization_cause, param_env, unnormalized_ty);
-            let normalization_errors = ocx.select_where_possible();
+            let normalization_errors = ocx.try_evaluate_obligations();
 
             // NOTE: The post-normalization type may also reference errors,
             // such as when we project to a missing type or we have a mismatch
@@ -252,7 +252,7 @@ pub fn all_fields_implement_trait<'tcx>(
                 ty,
                 trait_def_id,
             );
-            let errors = ocx.select_all_or_error();
+            let errors = ocx.evaluate_obligations_error_on_ambiguity();
             if !errors.is_empty() {
                 infringing.push((field, ty, InfringingFieldsReason::Fulfill(errors)));
             }
diff --git a/compiler/rustc_trait_selection/src/traits/mod.rs b/compiler/rustc_trait_selection/src/traits/mod.rs
index 6fefac436994d..c6c2d70ef71f4 100644
--- a/compiler/rustc_trait_selection/src/traits/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/mod.rs
@@ -231,7 +231,7 @@ fn pred_known_to_hold_modulo_regions<'tcx>(
             let ocx = ObligationCtxt::new(infcx);
             ocx.register_obligation(obligation);
 
-            let errors = ocx.select_all_or_error();
+            let errors = ocx.evaluate_obligations_error_on_ambiguity();
             match errors.as_slice() {
                 // Only known to hold if we did no inference.
                 [] => infcx.resolve_vars_if_possible(goal) == goal,
@@ -273,7 +273,7 @@ fn do_normalize_predicates<'tcx>(
     let ocx = ObligationCtxt::new_with_diagnostics(&infcx);
     let predicates = ocx.normalize(&cause, elaborated_env, predicates);
 
-    let errors = ocx.select_all_or_error();
+    let errors = ocx.evaluate_obligations_error_on_ambiguity();
     if !errors.is_empty() {
         let reported = infcx.err_ctxt().report_fulfillment_errors(errors);
         return Err(reported);
@@ -738,13 +738,13 @@ pub fn impossible_predicates<'tcx>(tcx: TyCtxt<'tcx>, predicates: Vec<ty::Clause
         ocx.register_obligation(obligation);
     }
 
-    // Use `select_where_possible` to only return impossible for true errors,
+    // Use `try_evaluate_obligations` to only return impossible for true errors,
     // and not ambiguities or overflows. Since the new trait solver forces
     // some currently undetected overlap between `dyn Trait: Trait` built-in
     // vs user-written impls to AMBIGUOUS, this may return ambiguity even
     // with no infer vars. There may also be ways to encounter ambiguity due
     // to post-mono overflow.
-    let true_errors = ocx.select_where_possible();
+    let true_errors = ocx.try_evaluate_obligations();
     if !true_errors.is_empty() {
         return true;
     }
@@ -853,7 +853,7 @@ fn is_impossible_associated_item(
 
     let ocx = ObligationCtxt::new(&infcx);
     ocx.register_obligations(predicates_for_trait);
-    !ocx.select_where_possible().is_empty()
+    !ocx.try_evaluate_obligations().is_empty()
 }
 
 pub fn provide(providers: &mut Providers) {
diff --git a/compiler/rustc_trait_selection/src/traits/normalize.rs b/compiler/rustc_trait_selection/src/traits/normalize.rs
index 9e02ce32b21cd..800a599be789a 100644
--- a/compiler/rustc_trait_selection/src/traits/normalize.rs
+++ b/compiler/rustc_trait_selection/src/traits/normalize.rs
@@ -73,7 +73,7 @@ impl<'tcx> At<'_, 'tcx> {
             let value = self
                 .normalize(value)
                 .into_value_registering_obligations(self.infcx, &mut *fulfill_cx);
-            let errors = fulfill_cx.select_all_or_error(self.infcx);
+            let errors = fulfill_cx.evaluate_obligations_error_on_ambiguity(self.infcx);
             let value = self.infcx.resolve_vars_if_possible(value);
             if errors.is_empty() {
                 Ok(value)
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 945ca7c37758f..2e60805cd10a5 100644
--- a/compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs
@@ -199,7 +199,7 @@ where
                 // Flush errors b/c `deeply_normalize` doesn't expect pending
                 // obligations, and we may have pending obligations from the
                 // branch above (from other types).
-                let errors = ocx.select_all_or_error();
+                let errors = ocx.evaluate_obligations_error_on_ambiguity();
                 if !errors.is_empty() {
                     return Err(errors);
                 }
diff --git a/compiler/rustc_trait_selection/src/traits/query/evaluate_obligation.rs b/compiler/rustc_trait_selection/src/traits/query/evaluate_obligation.rs
index 34e0176d213f1..d383cdc1aefa6 100644
--- a/compiler/rustc_trait_selection/src/traits/query/evaluate_obligation.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/evaluate_obligation.rs
@@ -96,7 +96,7 @@ impl<'tcx> InferCtxt<'tcx> {
                 let ocx = ObligationCtxt::new(self);
                 ocx.register_obligation(obligation.clone());
                 let mut result = EvaluationResult::EvaluatedToOk;
-                for error in ocx.select_all_or_error() {
+                for error in ocx.evaluate_obligations_error_on_ambiguity() {
                     if error.is_true_error() {
                         return Ok(EvaluationResult::EvaluatedToErr);
                     } else {
diff --git a/compiler/rustc_trait_selection/src/traits/query/type_op/custom.rs b/compiler/rustc_trait_selection/src/traits/query/type_op/custom.rs
index a96cb738b81f0..2b58a65051e1a 100644
--- a/compiler/rustc_trait_selection/src/traits/query/type_op/custom.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/type_op/custom.rs
@@ -94,7 +94,7 @@ where
         let value = op(&ocx).map_err(|_| {
             infcx.dcx().span_delayed_bug(span, format!("error performing operation: {name}"))
         })?;
-        let errors = ocx.select_all_or_error();
+        let errors = ocx.evaluate_obligations_error_on_ambiguity();
         if errors.is_empty() {
             Ok(value)
         } else if let Err(guar) = infcx.tcx.check_potentially_region_dependent_goals(root_def_id) {
diff --git a/compiler/rustc_trait_selection/src/traits/specialize/mod.rs b/compiler/rustc_trait_selection/src/traits/specialize/mod.rs
index 4bb12694c478a..ab01d0707e0f1 100644
--- a/compiler/rustc_trait_selection/src/traits/specialize/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/specialize/mod.rs
@@ -164,7 +164,7 @@ fn fulfill_implication<'tcx>(
     let ocx = ObligationCtxt::new(infcx);
     let source_trait_ref = ocx.normalize(cause, param_env, source_trait_ref);
 
-    if !ocx.select_all_or_error().is_empty() {
+    if !ocx.evaluate_obligations_error_on_ambiguity().is_empty() {
         infcx.dcx().span_delayed_bug(
             infcx.tcx.def_span(source_impl),
             format!("failed to fully normalize {source_trait_ref}"),
@@ -197,7 +197,7 @@ fn fulfill_implication<'tcx>(
     let obligations = predicates_for_generics(|_, _| cause.clone(), param_env, predicates);
     ocx.register_obligations(obligations);
 
-    let errors = ocx.select_all_or_error();
+    let errors = ocx.evaluate_obligations_error_on_ambiguity();
     if !errors.is_empty() {
         // no dice!
         debug!(
@@ -295,7 +295,7 @@ pub(super) fn specializes(
     let ocx = ObligationCtxt::new(&infcx);
     let specializing_impl_trait_ref = ocx.normalize(cause, param_env, specializing_impl_trait_ref);
 
-    if !ocx.select_all_or_error().is_empty() {
+    if !ocx.evaluate_obligations_error_on_ambiguity().is_empty() {
         infcx.dcx().span_delayed_bug(
             infcx.tcx.def_span(specializing_impl_def_id),
             format!("failed to fully normalize {specializing_impl_trait_ref}"),
@@ -331,7 +331,7 @@ pub(super) fn specializes(
     let obligations = predicates_for_generics(|_, _| cause.clone(), param_env, predicates);
     ocx.register_obligations(obligations);
 
-    let errors = ocx.select_all_or_error();
+    let errors = ocx.evaluate_obligations_error_on_ambiguity();
     if !errors.is_empty() {
         // no dice!
         debug!(
@@ -367,7 +367,7 @@ pub(super) fn specializes(
             )
         }));
 
-        let errors = ocx.select_all_or_error();
+        let errors = ocx.evaluate_obligations_error_on_ambiguity();
         if !errors.is_empty() {
             // no dice!
             debug!(
diff --git a/compiler/rustc_trait_selection/src/traits/structural_normalize.rs b/compiler/rustc_trait_selection/src/traits/structural_normalize.rs
index 2e20ede2f50a8..ebeab8eddc6f5 100644
--- a/compiler/rustc_trait_selection/src/traits/structural_normalize.rs
+++ b/compiler/rustc_trait_selection/src/traits/structural_normalize.rs
@@ -52,7 +52,7 @@ impl<'tcx> At<'_, 'tcx> {
             );
 
             fulfill_cx.register_predicate_obligation(self.infcx, obligation);
-            let errors = fulfill_cx.select_where_possible(self.infcx);
+            let errors = fulfill_cx.try_evaluate_obligations(self.infcx);
             if !errors.is_empty() {
                 return Err(errors);
             }
diff --git a/compiler/rustc_traits/src/codegen.rs b/compiler/rustc_traits/src/codegen.rs
index 4b05e2cc38118..f3b43541b7cbe 100644
--- a/compiler/rustc_traits/src/codegen.rs
+++ b/compiler/rustc_traits/src/codegen.rs
@@ -59,7 +59,7 @@ pub(crate) fn codegen_select_candidate<'tcx>(
     // In principle, we only need to do this so long as `impl_source`
     // contains unbound type parameters. It could be a slight
     // optimization to stop iterating early.
-    let errors = ocx.select_all_or_error();
+    let errors = ocx.evaluate_obligations_error_on_ambiguity();
     if !errors.is_empty() {
         // `rustc_monomorphize::collector` assumes there are no type errors.
         // Cycle errors are the only post-monomorphization errors possible; emit them now so
diff --git a/compiler/rustc_traits/src/coroutine_witnesses.rs b/compiler/rustc_traits/src/coroutine_witnesses.rs
index 20f9b01372482..2544cd8a13cd8 100644
--- a/compiler/rustc_traits/src/coroutine_witnesses.rs
+++ b/compiler/rustc_traits/src/coroutine_witnesses.rs
@@ -63,7 +63,7 @@ fn compute_assumptions<'tcx>(
                 ty::ClauseKind::WellFormed(ty.into()),
             )
         }));
-        let _errors = ocx.select_all_or_error();
+        let _errors = ocx.evaluate_obligations_error_on_ambiguity();
 
         let region_obligations = infcx.take_registered_region_obligations();
         let region_assumptions = infcx.take_registered_region_assumptions();
diff --git a/compiler/rustc_traits/src/normalize_projection_ty.rs b/compiler/rustc_traits/src/normalize_projection_ty.rs
index e52898cc6e242..db871d4b0aaad 100644
--- a/compiler/rustc_traits/src/normalize_projection_ty.rs
+++ b/compiler/rustc_traits/src/normalize_projection_ty.rs
@@ -45,7 +45,7 @@ fn normalize_canonicalized_projection_ty<'tcx>(
             // are recursive (given some generic parameters of the opaque's type variables).
             // In that case, we may only realize a cycle error when calling
             // `normalize_erasing_regions` in mono.
-            let errors = ocx.select_where_possible();
+            let errors = ocx.try_evaluate_obligations();
             if !errors.is_empty() {
                 // Rustdoc may attempt to normalize type alias types which are not
                 // well-formed. Rustdoc also normalizes types that are just not
diff --git a/compiler/rustc_ty_utils/src/structural_match.rs b/compiler/rustc_ty_utils/src/structural_match.rs
index e900264a76c7e..80d9c53b108f5 100644
--- a/compiler/rustc_ty_utils/src/structural_match.rs
+++ b/compiler/rustc_ty_utils/src/structural_match.rs
@@ -28,7 +28,7 @@ fn has_structural_eq_impl<'tcx>(tcx: TyCtxt<'tcx>, adt_ty: Ty<'tcx>) -> bool {
     //
     // 2. We are sometimes doing future-incompatibility lints for
     //    now, so we do not want unconditional errors here.
-    ocx.select_all_or_error().is_empty()
+    ocx.evaluate_obligations_error_on_ambiguity().is_empty()
 }
 
 pub(crate) fn provide(providers: &mut Providers) {
diff --git a/src/tools/clippy/clippy_lints/src/future_not_send.rs b/src/tools/clippy/clippy_lints/src/future_not_send.rs
index 596047977a9b1..221107ba4b93e 100644
--- a/src/tools/clippy/clippy_lints/src/future_not_send.rs
+++ b/src/tools/clippy/clippy_lints/src/future_not_send.rs
@@ -90,7 +90,7 @@ impl<'tcx> LateLintPass<'tcx> for FutureNotSend {
             let ocx = ObligationCtxt::new_with_diagnostics(&infcx);
             let cause = traits::ObligationCause::misc(span, fn_def_id);
             ocx.register_bound(cause, cx.param_env, ret_ty, send_trait);
-            let send_errors = ocx.select_all_or_error();
+            let send_errors = ocx.evaluate_obligations_error_on_ambiguity();
 
             // Allow errors that try to prove `Send` for types that "mention" a generic parameter at the "top
             // level".
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 cc98fac45c7cb..1e3a7281bc734 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
@@ -475,7 +475,7 @@ fn is_ty_const_destruct<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, body: &Body<'tcx>
 
         let ocx = ObligationCtxt::new(&infcx);
         ocx.register_obligations(impl_src.nested_obligations());
-        ocx.select_all_or_error().is_empty()
+        ocx.evaluate_obligations_error_on_ambiguity().is_empty()
     }
 
     !ty.needs_drop(tcx, ConstCx::new(tcx, body).typing_env)
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs b/src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs
index 21a86d3e43727..4d348ec6b7f4a 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/autoderef.rs
@@ -304,7 +304,7 @@ fn structurally_normalize_ty<'db>(
         // evaluate/fulfill mismatches, but that's not a reason for an ICE.
         return None;
     };
-    let errors = ocx.select_where_possible();
+    let errors = ocx.try_evaluate_obligations();
     if !errors.is_empty() {
         unreachable!();
     }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
index 62ce00a2e33d4..0ca696ed08cb4 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/coerce.rs
@@ -160,7 +160,7 @@ impl<'a, 'b, 'db> Coerce<'a, 'b, 'db> {
                 Ok(InferOk { value, obligations }) => {
                     let mut ocx = ObligationCtxt::new(this.infer_ctxt());
                     ocx.register_obligations(obligations);
-                    if ocx.select_where_possible().is_empty() {
+                    if ocx.try_evaluate_obligations().is_empty() {
                         Ok(InferOk { value, obligations: ocx.into_pending_obligations() })
                     } else {
                         Err(TypeError::Mismatch)
@@ -743,7 +743,7 @@ impl<'a, 'b, 'db> Coerce<'a, 'b, 'db> {
                 Some(PredicateKind::AliasRelate(..)) => {
                     let mut ocx = ObligationCtxt::new(self.infer_ctxt());
                     ocx.register_obligation(obligation);
-                    if !ocx.select_where_possible().is_empty() {
+                    if !ocx.try_evaluate_obligations().is_empty() {
                         return Err(TypeError::Mismatch);
                     }
                     coercion.obligations.extend(ocx.into_pending_obligations());
@@ -1119,7 +1119,7 @@ impl<'db> InferenceContext<'db> {
                                 prev_ty,
                                 new_ty,
                             )?;
-                            if ocx.select_where_possible().is_empty() {
+                            if ocx.try_evaluate_obligations().is_empty() {
                                 Ok(InferOk { value, obligations: ocx.into_pending_obligations() })
                             } else {
                                 Err(TypeError::Mismatch)
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
index ddf632c1c81b5..7b404bb854132 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/expr.rs
@@ -2151,7 +2151,7 @@ impl<'db> InferenceContext<'db> {
                             expected_output.to_nextsolver(interner),
                             formal_output,
                         )?;
-                        if !ocx.select_where_possible().is_empty() {
+                        if !ocx.try_evaluate_obligations().is_empty() {
                             return Err(crate::next_solver::TypeError::Mismatch);
                         }
 
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
index 108cf5b1a2b8e..d8ca029815237 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/infer/unify.rs
@@ -818,7 +818,7 @@ impl<'db> InferenceTable<'db> {
     }
 
     pub(crate) fn select_obligations_where_possible(&mut self) {
-        self.fulfillment_cx.select_where_possible(&self.infer_ctxt);
+        self.fulfillment_cx.try_evaluate_obligations(&self.infer_ctxt);
     }
 
     pub(super) fn register_predicate(
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
index 61d3091a0c1d0..9b330d3f3f454 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/method_resolution.rs
@@ -1785,7 +1785,7 @@ fn is_valid_trait_method_candidate(
                         let mut ctxt = ObligationCtxt::new(&table.infer_ctxt);
                         ctxt.register_obligations(infer_ok.into_obligations());
                         // FIXME: Are we doing this correctly? Probably better to follow rustc more closely.
-                        check_that!(ctxt.select_where_possible().is_empty());
+                        check_that!(ctxt.try_evaluate_obligations().is_empty());
                     }
 
                     check_that!(table.unify(receiver_ty, &expected_receiver));
@@ -1871,7 +1871,7 @@ fn is_valid_impl_fn_candidate(
             )
         }));
 
-        if ctxt.select_where_possible().is_empty() {
+        if ctxt.try_evaluate_obligations().is_empty() {
             IsValidCandidate::Yes
         } else {
             IsValidCandidate::No
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill.rs
index 34dff37972e7e..262da858d466a 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/fulfill.rs
@@ -54,7 +54,7 @@ struct ObligationStorage<'db> {
     /// Obligations which resulted in an overflow in fulfillment itself.
     ///
     /// We cannot eagerly return these as error so we instead store them here
-    /// to avoid recomputing them each time `select_where_possible` is called.
+    /// to avoid recomputing them each time `try_evaluate_obligations` is called.
     /// This also allows us to return the correct `FulfillmentError` for them.
     overflowed: Vec<PredicateObligation<'db>>,
     pending: PendingObligations<'db>,
@@ -95,7 +95,7 @@ impl<'db> ObligationStorage<'db> {
             // IMPORTANT: we must not use solve any inference variables in the obligations
             // as this is all happening inside of a probe. We use a probe to make sure
             // we get all obligations involved in the overflow. We pretty much check: if
-            // we were to do another step of `select_where_possible`, which goals would
+            // we were to do another step of `try_evaluate_obligations`, which goals would
             // change.
             // FIXME: <https://github.com/Gankra/thin-vec/pull/66> is merged, this can be removed.
             self.overflowed.extend(
@@ -131,7 +131,7 @@ impl<'db> FulfillmentCtxt<'db> {
         infcx: &InferCtxt<'db>,
         obligation: PredicateObligation<'db>,
     ) {
-        // FIXME: See the comment in `select_where_possible()`.
+        // FIXME: See the comment in `try_evaluate_obligations()`.
         // assert_eq!(self.usable_in_snapshot, infcx.num_open_snapshots());
         self.obligations.register(obligation, None);
     }
@@ -141,7 +141,7 @@ impl<'db> FulfillmentCtxt<'db> {
         infcx: &InferCtxt<'db>,
         obligations: impl IntoIterator<Item = PredicateObligation<'db>>,
     ) {
-        // FIXME: See the comment in `select_where_possible()`.
+        // FIXME: See the comment in `try_evaluate_obligations()`.
         // assert_eq!(self.usable_in_snapshot, infcx.num_open_snapshots());
         obligations.into_iter().for_each(|obligation| self.obligations.register(obligation, None));
     }
@@ -158,7 +158,7 @@ impl<'db> FulfillmentCtxt<'db> {
             .collect()
     }
 
-    pub(crate) fn select_where_possible(
+    pub(crate) fn try_evaluate_obligations(
         &mut self,
         infcx: &InferCtxt<'db>,
     ) -> Vec<NextSolverError<'db>> {
@@ -223,11 +223,11 @@ impl<'db> FulfillmentCtxt<'db> {
         errors
     }
 
-    pub(crate) fn select_all_or_error(
+    pub(crate) fn evaluate_obligations_error_on_ambiguity(
         &mut self,
         infcx: &InferCtxt<'db>,
     ) -> Vec<NextSolverError<'db>> {
-        let errors = self.select_where_possible(infcx);
+        let errors = self.try_evaluate_obligations(infcx);
         if !errors.is_empty() {
             return errors;
         }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/inspect.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/inspect.rs
index bc19d51d23e32..0db4746721752 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/inspect.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/inspect.rs
@@ -92,7 +92,7 @@ impl<'db> NormalizesToTermHack<'db> {
         let mut ocx = ObligationCtxt::new(infcx);
         ocx.eq(&ObligationCause::dummy(), param_env, self.term, self.unconstrained_term)?;
         f(&mut ocx);
-        let errors = ocx.select_all_or_error();
+        let errors = ocx.evaluate_obligations_error_on_ambiguity();
         if errors.is_empty() {
             Ok(Certainty::Yes)
         } else if errors.iter().all(|e| !matches!(e, NextSolverError::TrueError(_))) {
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/normalize.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/normalize.rs
index 41cb4884404f1..2f241f8fecbe7 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/normalize.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/normalize.rs
@@ -77,7 +77,7 @@ where
         stalled_coroutine_goals: vec![],
     };
     let value = value.try_fold_with(&mut folder)?;
-    let errors = folder.fulfill_cx.select_all_or_error(at.infcx);
+    let errors = folder.fulfill_cx.evaluate_obligations_error_on_ambiguity(at.infcx);
     if errors.is_empty() { Ok((value, folder.stalled_coroutine_goals)) } else { Err(errors) }
 }
 
@@ -138,7 +138,7 @@ impl<'db> NormalizationFolder<'_, 'db> {
     fn select_all_and_stall_coroutine_predicates(
         &mut self,
     ) -> Result<(), Vec<NextSolverError<'db>>> {
-        let errors = self.fulfill_cx.select_where_possible(self.at.infcx);
+        let errors = self.fulfill_cx.try_evaluate_obligations(self.at.infcx);
         if !errors.is_empty() {
             return Err(errors);
         }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/obligation_ctxt.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/obligation_ctxt.rs
index 8e2dc0dec4ed3..e85574a8826ff 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/obligation_ctxt.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/obligation_ctxt.rs
@@ -144,13 +144,13 @@ impl<'a, 'db> ObligationCtxt<'a, 'db> {
     }
 
     #[must_use]
-    pub fn select_where_possible(&mut self) -> Vec<NextSolverError<'db>> {
-        self.engine.select_where_possible(self.infcx)
+    pub fn try_evaluate_obligations(&mut self) -> Vec<NextSolverError<'db>> {
+        self.engine.try_evaluate_obligations(self.infcx)
     }
 
     #[must_use]
-    pub fn select_all_or_error(&mut self) -> Vec<NextSolverError<'db>> {
-        self.engine.select_all_or_error(self.infcx)
+    pub fn evaluate_obligations_error_on_ambiguity(&mut self) -> Vec<NextSolverError<'db>> {
+        self.engine.evaluate_obligations_error_on_ambiguity(self.infcx)
     }
 
     /// Returns the not-yet-processed and stalled obligations from the
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/structural_normalize.rs b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/structural_normalize.rs
index 18859d8b79707..00c3708358b92 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/structural_normalize.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/next_solver/structural_normalize.rs
@@ -47,7 +47,7 @@ impl<'db> At<'_, 'db> {
         );
 
         fulfill_cx.register_predicate_obligation(self.infcx, obligation);
-        let errors = fulfill_cx.select_where_possible(self.infcx);
+        let errors = fulfill_cx.try_evaluate_obligations(self.infcx);
         if !errors.is_empty() {
             return Err(errors);
         }
diff --git a/tests/ui/impl-trait/lazy_subtyping_of_opaques.rs b/tests/ui/impl-trait/lazy_subtyping_of_opaques.rs
index 8fd1f35645a8a..8921090d98af5 100644
--- a/tests/ui/impl-trait/lazy_subtyping_of_opaques.rs
+++ b/tests/ui/impl-trait/lazy_subtyping_of_opaques.rs
@@ -13,7 +13,7 @@ fn foo() -> impl Default + Copy {
         // Make a tuple `(?x, ?y)` and equate it with `(impl Default, u32)`.
         // For us to try and prove a `Subtype(impl Default, u32)` obligation,
         // we have to instantiate both `?x` and `?y` without any
-        // `select_where_possible` calls inbetween.
+        // `try_evaluate_obligations` calls inbetween.
         let mut tup = &mut (x, y);
         let assign_tup = &mut (foo(), 1u32);
         tup = assign_tup;

From dcc36a864296cae5ee6e9e7402173b4e396a9b07 Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Sun, 5 Oct 2025 22:45:09 -0400
Subject: [PATCH 1807/1889] add incremental/debug test for autodiff

---
 .../src/builder/autodiff.rs                   |  2 +-
 tests/ui/autodiff/incremental.rs              | 41 +++++++++++++++++++
 2 files changed, 42 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/autodiff/incremental.rs

diff --git a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
index bf70a3f4a071d..b0f0fcfe84e4e 100644
--- a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
+++ b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
@@ -12,7 +12,7 @@ use tracing::debug;
 use crate::builder::{Builder, PlaceRef, UNNAMED};
 use crate::context::SimpleCx;
 use crate::declare::declare_simple_fn;
-use crate::llvm::{self, Metadata, TRUE, Type, Value};
+use crate::llvm::{self, TRUE, Type, Value};
 
 pub(crate) fn adjust_activity_to_abi<'tcx>(
     tcx: TyCtxt<'tcx>,
diff --git a/tests/ui/autodiff/incremental.rs b/tests/ui/autodiff/incremental.rs
new file mode 100644
index 0000000000000..a79059deaa778
--- /dev/null
+++ b/tests/ui/autodiff/incremental.rs
@@ -0,0 +1,41 @@
+//@ revisions: DEBUG RELEASE
+//@[RELEASE] compile-flags: -Zautodiff=Enable,NoTT -C opt-level=3 -Clto=fat
+//@[DEBUG]   compile-flags: -Zautodiff=Enable,NoTT -C opt-level=0 -Clto=fat -C debuginfo=2
+//@ needs-enzyme
+//@ incremental
+//@ no-prefer-dynamic
+//@ build-pass
+#![crate_type = "bin"]
+#![feature(autodiff)]
+
+// We used to use llvm's metadata to instruct enzyme how to differentiate a function.
+// In debug mode we would use incremental compilation which caused the metadata to be
+// dropped. We now use globals instead and add this test to verify that incremental
+// keeps working. Also testing debug mode while at it.
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(bar, Duplicated, Duplicated)]
+pub fn foo(r: &[f64; 10], res: &mut f64) {
+    let mut output = [0.0; 10];
+    output[0] = r[0];
+    output[1] = r[1] * r[2];
+    output[2] = r[4] * r[5];
+    output[3] = r[2] * r[6];
+    output[4] = r[1] * r[7];
+    output[5] = r[2] * r[8];
+    output[6] = r[1] * r[9];
+    output[7] = r[5] * r[6];
+    output[8] = r[5] * r[7];
+    output[9] = r[4] * r[8];
+    *res = output.iter().sum();
+}
+fn main() {
+    let inputs = Box::new([3.1; 10]);
+    let mut d_inputs = Box::new([0.0; 10]);
+    let mut res = Box::new(0.0);
+    let mut d_res = Box::new(1.0);
+
+    bar(&inputs, &mut d_inputs, &mut res, &mut d_res);
+    dbg!(&d_inputs);
+}

From 52e79175861f52eda933b52b7ba43efb169d099a Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Sun, 5 Oct 2025 21:47:02 -0400
Subject: [PATCH 1808/1889] Use globals instead of metadata, since metadata
 isn't emitted in debug builds

---
 .../src/builder/autodiff.rs                   | 54 ++++++++++---------
 1 file changed, 29 insertions(+), 25 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
index b0f0fcfe84e4e..4b433e2b63616 100644
--- a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
+++ b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
@@ -143,9 +143,9 @@ fn match_args_from_caller_to_enzyme<'ll, 'tcx>(
     cx: &SimpleCx<'ll>,
     builder: &mut Builder<'_, 'll, 'tcx>,
     width: u32,
-    args: &mut Vec<&'ll llvm::Value>,
+    args: &mut Vec<&'ll Value>,
     inputs: &[DiffActivity],
-    outer_args: &[&'ll llvm::Value],
+    outer_args: &[&'ll Value],
 ) {
     debug!("matching autodiff arguments");
     // We now handle the issue that Rust level arguments not always match the llvm-ir level
@@ -157,32 +157,36 @@ fn match_args_from_caller_to_enzyme<'ll, 'tcx>(
     let mut outer_pos: usize = 0;
     let mut activity_pos = 0;
 
-    let enzyme_const = cx.create_metadata(b"enzyme_const");
-    let enzyme_out = cx.create_metadata(b"enzyme_out");
-    let enzyme_dup = cx.create_metadata(b"enzyme_dup");
-    let enzyme_dupv = cx.create_metadata(b"enzyme_dupv");
-    let enzyme_dupnoneed = cx.create_metadata(b"enzyme_dupnoneed");
-    let enzyme_dupnoneedv = cx.create_metadata(b"enzyme_dupnoneedv");
+    // We used to use llvm's metadata to instruct enzyme how to differentiate a function.
+    // In debug mode we would use incremental compilation which caused the metadata to be
+    // dropped. This is prevented by now using named globals, which are also understood
+    // by Enzyme.
+    let global_const = cx.declare_global("enzyme_const", cx.type_ptr());
+    let global_out = cx.declare_global("enzyme_out", cx.type_ptr());
+    let global_dup = cx.declare_global("enzyme_dup", cx.type_ptr());
+    let global_dupv = cx.declare_global("enzyme_dupv", cx.type_ptr());
+    let global_dupnoneed = cx.declare_global("enzyme_dupnoneed", cx.type_ptr());
+    let global_dupnoneedv = cx.declare_global("enzyme_dupnoneedv", cx.type_ptr());
 
     while activity_pos < inputs.len() {
         let diff_activity = inputs[activity_pos as usize];
         // Duplicated arguments received a shadow argument, into which enzyme will write the
         // gradient.
-        let (activity, duplicated): (&Metadata, bool) = match diff_activity {
+        let (activity, duplicated): (&Value, bool) = match diff_activity {
             DiffActivity::None => panic!("not a valid input activity"),
-            DiffActivity::Const => (enzyme_const, false),
-            DiffActivity::Active => (enzyme_out, false),
-            DiffActivity::ActiveOnly => (enzyme_out, false),
-            DiffActivity::Dual => (enzyme_dup, true),
-            DiffActivity::Dualv => (enzyme_dupv, true),
-            DiffActivity::DualOnly => (enzyme_dupnoneed, true),
-            DiffActivity::DualvOnly => (enzyme_dupnoneedv, true),
-            DiffActivity::Duplicated => (enzyme_dup, true),
-            DiffActivity::DuplicatedOnly => (enzyme_dupnoneed, true),
-            DiffActivity::FakeActivitySize(_) => (enzyme_const, false),
+            DiffActivity::Const => (global_const, false),
+            DiffActivity::Active => (global_out, false),
+            DiffActivity::ActiveOnly => (global_out, false),
+            DiffActivity::Dual => (global_dup, true),
+            DiffActivity::Dualv => (global_dupv, true),
+            DiffActivity::DualOnly => (global_dupnoneed, true),
+            DiffActivity::DualvOnly => (global_dupnoneedv, true),
+            DiffActivity::Duplicated => (global_dup, true),
+            DiffActivity::DuplicatedOnly => (global_dupnoneed, true),
+            DiffActivity::FakeActivitySize(_) => (global_const, false),
         };
         let outer_arg = outer_args[outer_pos];
-        args.push(cx.get_metadata_value(activity));
+        args.push(activity);
         if matches!(diff_activity, DiffActivity::Dualv) {
             let next_outer_arg = outer_args[outer_pos + 1];
             let elem_bytes_size: u64 = match inputs[activity_pos + 1] {
@@ -242,7 +246,7 @@ fn match_args_from_caller_to_enzyme<'ll, 'tcx>(
                     assert_eq!(cx.type_kind(next_outer_ty3), TypeKind::Integer);
                     args.push(next_outer_arg2);
                 }
-                args.push(cx.get_metadata_value(enzyme_const));
+                args.push(global_const);
                 args.push(next_outer_arg);
                 outer_pos += 2 + 2 * iterations;
                 activity_pos += 2;
@@ -351,13 +355,13 @@ pub(crate) fn generate_enzyme_call<'ll, 'tcx>(
     let mut args = Vec::with_capacity(num_args as usize + 1);
     args.push(fn_to_diff);
 
-    let enzyme_primal_ret = cx.create_metadata(b"enzyme_primal_return");
+    let global_primal_ret = cx.declare_global("enzyme_primal_return", cx.type_ptr());
     if matches!(attrs.ret_activity, DiffActivity::Dual | DiffActivity::Active) {
-        args.push(cx.get_metadata_value(enzyme_primal_ret));
+        args.push(global_primal_ret);
     }
     if attrs.width > 1 {
-        let enzyme_width = cx.create_metadata(b"enzyme_width");
-        args.push(cx.get_metadata_value(enzyme_width));
+        let global_width = cx.declare_global("enzyme_width", cx.type_ptr());
+        args.push(global_width);
         args.push(cx.get_const_int(cx.type_i64(), attrs.width as u64));
     }
 

From 218fa60795164abc08dc448c63339d786f417c02 Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Sun, 5 Oct 2025 23:10:25 -0400
Subject: [PATCH 1809/1889] update ui test since the new frontend is a bit more
 lenient

---
 tests/ui/autodiff/autodiff_illegal.rs     | 23 -------------
 tests/ui/autodiff/autodiff_illegal.stderr | 39 +++--------------------
 2 files changed, 5 insertions(+), 57 deletions(-)

diff --git a/tests/ui/autodiff/autodiff_illegal.rs b/tests/ui/autodiff/autodiff_illegal.rs
index a53b6d5e58981..6bb384cc87e8d 100644
--- a/tests/ui/autodiff/autodiff_illegal.rs
+++ b/tests/ui/autodiff/autodiff_illegal.rs
@@ -110,15 +110,6 @@ fn f14(x: f32) -> Foo {
 
 type MyFloat = f32;
 
-// We would like to support type alias to f32/f64 in argument type in the future,
-// but that requires us to implement our checks at a later stage
-// like THIR which has type information available.
-#[autodiff_reverse(df15, Active, Active)]
-fn f15(x: MyFloat) -> f32 {
-    //~^^ ERROR failed to resolve: use of undeclared type `MyFloat` [E0433]
-    unimplemented!()
-}
-
 // We would like to support type alias to f32/f64 in return type in the future
 #[autodiff_reverse(df16, Active, Active)]
 fn f16(x: f32) -> MyFloat {
@@ -136,13 +127,6 @@ fn f17(x: f64) -> F64Trans {
     unimplemented!()
 }
 
-// We would like to support `#[repr(transparent)]` f32/f64 wrapper in argument type in the future
-#[autodiff_reverse(df18, Active, Active)]
-fn f18(x: F64Trans) -> f64 {
-    //~^^ ERROR failed to resolve: use of undeclared type `F64Trans` [E0433]
-    unimplemented!()
-}
-
 // Invalid return activity
 #[autodiff_forward(df19, Dual, Active)]
 fn f19(x: f32) -> f32 {
@@ -163,11 +147,4 @@ fn f21(x: f32) -> f32 {
     unimplemented!()
 }
 
-struct DoesNotImplDefault;
-#[autodiff_forward(df22, Dual)]
-pub fn f22() -> DoesNotImplDefault {
-    //~^^ ERROR the function or associated item `default` exists for tuple `(DoesNotImplDefault, DoesNotImplDefault)`, but its trait bounds were not satisfied
-    unimplemented!()
-}
-
 fn main() {}
diff --git a/tests/ui/autodiff/autodiff_illegal.stderr b/tests/ui/autodiff/autodiff_illegal.stderr
index ad6f10af46780..848ae1155e9c4 100644
--- a/tests/ui/autodiff/autodiff_illegal.stderr
+++ b/tests/ui/autodiff/autodiff_illegal.stderr
@@ -107,53 +107,24 @@ LL | #[autodiff_reverse(df13, Reverse)]
    |                          ^^^^^^^
 
 error: invalid return activity Active in Forward Mode
-  --> $DIR/autodiff_illegal.rs:147:1
+  --> $DIR/autodiff_illegal.rs:131:1
    |
 LL | #[autodiff_forward(df19, Dual, Active)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: invalid return activity Dual in Reverse Mode
-  --> $DIR/autodiff_illegal.rs:153:1
+  --> $DIR/autodiff_illegal.rs:137:1
    |
 LL | #[autodiff_reverse(df20, Active, Dual)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: invalid return activity Duplicated in Reverse Mode
-  --> $DIR/autodiff_illegal.rs:160:1
+  --> $DIR/autodiff_illegal.rs:144:1
    |
 LL | #[autodiff_reverse(df21, Active, Duplicated)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0433]: failed to resolve: use of undeclared type `MyFloat`
-  --> $DIR/autodiff_illegal.rs:116:1
-   |
-LL | #[autodiff_reverse(df15, Active, Active)]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ use of undeclared type `MyFloat`
-
-error[E0433]: failed to resolve: use of undeclared type `F64Trans`
-  --> $DIR/autodiff_illegal.rs:140:1
-   |
-LL | #[autodiff_reverse(df18, Active, Active)]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ use of undeclared type `F64Trans`
-
-error[E0599]: the function or associated item `default` exists for tuple `(DoesNotImplDefault, DoesNotImplDefault)`, but its trait bounds were not satisfied
-  --> $DIR/autodiff_illegal.rs:167:1
-   |
-LL | struct DoesNotImplDefault;
-   | ------------------------- doesn't satisfy `DoesNotImplDefault: Default`
-LL | #[autodiff_forward(df22, Dual)]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function or associated item cannot be called on `(DoesNotImplDefault, DoesNotImplDefault)` due to unsatisfied trait bounds
-   |
-   = note: the following trait bounds were not satisfied:
-           `DoesNotImplDefault: Default`
-           which is required by `(DoesNotImplDefault, DoesNotImplDefault): Default`
-help: consider annotating `DoesNotImplDefault` with `#[derive(Default)]`
-   |
-LL + #[derive(Default)]
-LL | struct DoesNotImplDefault;
-   |
-
-error: aborting due to 21 previous errors
+error: aborting due to 18 previous errors
 
-Some errors have detailed explanations: E0428, E0433, E0599, E0658.
+Some errors have detailed explanations: E0428, E0658.
 For more information about an error, try `rustc --explain E0428`.

From 1dbe831e471710b71e886bd1f6a97bc47b17b1ea Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jana=20D=C3=B6nszelmann?= <jana@donsz.nl>
Date: Tue, 7 Oct 2025 16:59:24 +0200
Subject: [PATCH 1810/1889] sort attribute targets for more consistent error
 messages

---
 .../rustc_attr_parsing/src/target_checking.rs | 22 ++++++----
 tests/ui/asm/naked-invalid-attr.stderr        |  4 +-
 tests/ui/attributes/attr-on-mac-call.stderr   | 10 ++---
 tests/ui/attributes/linkage.stderr            | 12 ++---
 .../attributes/malformed-static-align.stderr  |  2 +-
 .../ui/coverage-attr/allowed-positions.stderr | 34 +++++++-------
 tests/ui/coverage-attr/name-value.stderr      | 14 +++---
 tests/ui/coverage-attr/word-only.stderr       | 14 +++---
 .../ui/deprecation/deprecation-sanity.stderr  |  2 +-
 tests/ui/extern/extern-no-mangle.stderr       |  2 +-
 ...gate-allow-internal-unstable-struct.stderr |  2 +-
 ...43106-gating-of-builtin-attrs-error.stderr |  2 +-
 ...issue-43106-gating-of-builtin-attrs.stderr | 38 ++++++++--------
 .../invalid-debugger-visualizer-target.stderr |  2 +-
 tests/ui/issues/issue-32782.stderr            |  2 +-
 .../unused/unused-attr-macro-rules.stderr     |  2 +-
 .../unused/unused_attributes-must_use.stderr  | 44 +++++++++----------
 ...warn-unused-inline-on-fn-prototypes.stderr |  4 +-
 tests/ui/macros/issue-68060.stderr            |  2 +-
 .../target-feature/invalid-attribute.stderr   |  2 +-
 .../unsupported_attribute.stderr              |  8 ++--
 21 files changed, 114 insertions(+), 110 deletions(-)

diff --git a/compiler/rustc_attr_parsing/src/target_checking.rs b/compiler/rustc_attr_parsing/src/target_checking.rs
index c52253699b51c..d28f43943ba84 100644
--- a/compiler/rustc_attr_parsing/src/target_checking.rs
+++ b/compiler/rustc_attr_parsing/src/target_checking.rs
@@ -198,16 +198,20 @@ pub(crate) fn allowed_targets_applied(
     filter_targets(&mut allowed_targets, IMPL_LIKE, "impl blocks", target, &mut added_fake_targets);
     filter_targets(&mut allowed_targets, ADT_LIKE, "data types", target, &mut added_fake_targets);
 
+    let mut target_strings: Vec<_> = added_fake_targets
+        .iter()
+        .copied()
+        .chain(allowed_targets.iter().map(|t| t.plural_name()))
+        .map(|i| i.to_string())
+        .collect();
+
+    // ensure a consistent order
+    target_strings.sort();
+
     // If there is now only 1 target left, show that as the only possible target
-    (
-        added_fake_targets
-            .iter()
-            .copied()
-            .chain(allowed_targets.iter().map(|t| t.plural_name()))
-            .map(|i| i.to_string())
-            .collect(),
-        allowed_targets.len() + added_fake_targets.len() == 1,
-    )
+    let only_target = target_strings.len() == 1;
+
+    (target_strings, only_target)
 }
 
 fn filter_targets(
diff --git a/tests/ui/asm/naked-invalid-attr.stderr b/tests/ui/asm/naked-invalid-attr.stderr
index 33bbfc885da97..923d2de1f323d 100644
--- a/tests/ui/asm/naked-invalid-attr.stderr
+++ b/tests/ui/asm/naked-invalid-attr.stderr
@@ -18,7 +18,7 @@ error: `#[naked]` attribute cannot be used on foreign functions
 LL |     #[unsafe(naked)]
    |     ^^^^^^^^^^^^^^^^
    |
-   = help: `#[naked]` can be applied to methods and functions
+   = help: `#[naked]` can be applied to functions and methods
 
 error: `#[naked]` attribute cannot be used on structs
   --> $DIR/naked-invalid-attr.rs:13:1
@@ -50,7 +50,7 @@ error: `#[naked]` attribute cannot be used on closures
 LL |     #[unsafe(naked)]
    |     ^^^^^^^^^^^^^^^^
    |
-   = help: `#[naked]` can be applied to methods and functions
+   = help: `#[naked]` can be applied to functions and methods
 
 error[E0736]: attribute incompatible with `#[unsafe(naked)]`
   --> $DIR/naked-invalid-attr.rs:56:3
diff --git a/tests/ui/attributes/attr-on-mac-call.stderr b/tests/ui/attributes/attr-on-mac-call.stderr
index 02c0ec8ea1d6c..1aeec463c71cf 100644
--- a/tests/ui/attributes/attr-on-mac-call.stderr
+++ b/tests/ui/attributes/attr-on-mac-call.stderr
@@ -55,7 +55,7 @@ LL |     #[deprecated]
    |     ^^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[deprecated]` can be applied to functions, data types, modules, unions, constants, statics, macro defs, type aliases, use statements, foreign statics, struct fields, traits, associated types, associated consts, enum variants, inherent impl blocks, and crates
+   = help: `#[deprecated]` can be applied to associated consts, associated types, constants, crates, data types, enum variants, foreign statics, functions, inherent impl blocks, macro defs, modules, statics, struct fields, traits, type aliases, unions, and use statements
 
 warning: `#[inline]` attribute cannot be used on macro calls
   --> $DIR/attr-on-mac-call.rs:24:5
@@ -136,7 +136,7 @@ LL |     #[deprecated]
    |     ^^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[deprecated]` can be applied to functions, data types, modules, unions, constants, statics, macro defs, type aliases, use statements, foreign statics, struct fields, traits, associated types, associated consts, enum variants, inherent impl blocks, and crates
+   = help: `#[deprecated]` can be applied to associated consts, associated types, constants, crates, data types, enum variants, foreign statics, functions, inherent impl blocks, macro defs, modules, statics, struct fields, traits, type aliases, unions, and use statements
 
 warning: `#[automatically_derived]` attribute cannot be used on macro calls
   --> $DIR/attr-on-mac-call.rs:51:5
@@ -154,7 +154,7 @@ LL |     #[macro_use]
    |     ^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[macro_use]` can be applied to modules, extern crates, and crates
+   = help: `#[macro_use]` can be applied to crates, extern crates, and modules
 
 warning: `#[must_use]` attribute cannot be used on macro calls
   --> $DIR/attr-on-mac-call.rs:57:5
@@ -163,7 +163,7 @@ LL |     #[must_use]
    |     ^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[must_use]` can be applied to functions, data types, unions, and traits
+   = help: `#[must_use]` can be applied to data types, functions, traits, and unions
 
 warning: `#[no_implicit_prelude]` attribute cannot be used on macro calls
   --> $DIR/attr-on-mac-call.rs:60:5
@@ -172,7 +172,7 @@ LL |     #[no_implicit_prelude]
    |     ^^^^^^^^^^^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[no_implicit_prelude]` can be applied to modules and crates
+   = help: `#[no_implicit_prelude]` can be applied to crates and modules
 
 warning: `#[path]` attribute cannot be used on macro calls
   --> $DIR/attr-on-mac-call.rs:63:5
diff --git a/tests/ui/attributes/linkage.stderr b/tests/ui/attributes/linkage.stderr
index d2aee3840582f..167cdb0243a79 100644
--- a/tests/ui/attributes/linkage.stderr
+++ b/tests/ui/attributes/linkage.stderr
@@ -4,7 +4,7 @@ error: `#[linkage]` attribute cannot be used on type aliases
 LL | #[linkage = "weak"]
    | ^^^^^^^^^^^^^^^^^^^
    |
-   = help: `#[linkage]` can be applied to functions, statics, and foreign statics
+   = help: `#[linkage]` can be applied to foreign statics, functions, and statics
 
 error: `#[linkage]` attribute cannot be used on modules
   --> $DIR/linkage.rs:9:1
@@ -12,7 +12,7 @@ error: `#[linkage]` attribute cannot be used on modules
 LL | #[linkage = "weak"]
    | ^^^^^^^^^^^^^^^^^^^
    |
-   = help: `#[linkage]` can be applied to functions, statics, and foreign statics
+   = help: `#[linkage]` can be applied to foreign statics, functions, and statics
 
 error: `#[linkage]` attribute cannot be used on structs
   --> $DIR/linkage.rs:12:1
@@ -20,7 +20,7 @@ error: `#[linkage]` attribute cannot be used on structs
 LL | #[linkage = "weak"]
    | ^^^^^^^^^^^^^^^^^^^
    |
-   = help: `#[linkage]` can be applied to functions, statics, and foreign statics
+   = help: `#[linkage]` can be applied to foreign statics, functions, and statics
 
 error: `#[linkage]` attribute cannot be used on inherent impl blocks
   --> $DIR/linkage.rs:15:1
@@ -28,7 +28,7 @@ error: `#[linkage]` attribute cannot be used on inherent impl blocks
 LL | #[linkage = "weak"]
    | ^^^^^^^^^^^^^^^^^^^
    |
-   = help: `#[linkage]` can be applied to functions, statics, and foreign statics
+   = help: `#[linkage]` can be applied to foreign statics, functions, and statics
 
 error: `#[linkage]` attribute cannot be used on expressions
   --> $DIR/linkage.rs:23:5
@@ -36,7 +36,7 @@ error: `#[linkage]` attribute cannot be used on expressions
 LL |     #[linkage = "weak"]
    |     ^^^^^^^^^^^^^^^^^^^
    |
-   = help: `#[linkage]` can be applied to functions, statics, and foreign statics
+   = help: `#[linkage]` can be applied to foreign statics, functions, and statics
 
 error: `#[linkage]` attribute cannot be used on closures
   --> $DIR/linkage.rs:39:13
@@ -44,7 +44,7 @@ error: `#[linkage]` attribute cannot be used on closures
 LL |     let _ = #[linkage = "weak"]
    |             ^^^^^^^^^^^^^^^^^^^
    |
-   = help: `#[linkage]` can be applied to methods, functions, statics, foreign statics, and foreign functions
+   = help: `#[linkage]` can be applied to foreign functions, foreign statics, functions, methods, and statics
 
 error: aborting due to 6 previous errors
 
diff --git a/tests/ui/attributes/malformed-static-align.stderr b/tests/ui/attributes/malformed-static-align.stderr
index 35f654d3990f2..e618ca8acd75b 100644
--- a/tests/ui/attributes/malformed-static-align.stderr
+++ b/tests/ui/attributes/malformed-static-align.stderr
@@ -25,7 +25,7 @@ error: `#[rustc_align_static]` attribute cannot be used on structs
 LL | #[rustc_align_static(16)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: `#[rustc_align_static]` can be applied to statics and foreign statics
+   = help: `#[rustc_align_static]` can be applied to foreign statics and statics
 
 error: `#[repr(align(...))]` is not supported on statics
   --> $DIR/malformed-static-align.rs:13:8
diff --git a/tests/ui/coverage-attr/allowed-positions.stderr b/tests/ui/coverage-attr/allowed-positions.stderr
index 1690d089a8c5c..09d6bac497d21 100644
--- a/tests/ui/coverage-attr/allowed-positions.stderr
+++ b/tests/ui/coverage-attr/allowed-positions.stderr
@@ -14,7 +14,7 @@ error: `#[coverage]` attribute cannot be used on type aliases
 LL | #[coverage(off)]
    | ^^^^^^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
+   = help: `#[coverage]` can be applied to crates, functions, impl blocks, and modules
 
 error: `#[coverage]` attribute cannot be used on traits
   --> $DIR/allowed-positions.rs:17:1
@@ -22,7 +22,7 @@ error: `#[coverage]` attribute cannot be used on traits
 LL | #[coverage(off)]
    | ^^^^^^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
+   = help: `#[coverage]` can be applied to crates, functions, impl blocks, and modules
 
 error: `#[coverage]` attribute cannot be used on associated consts
   --> $DIR/allowed-positions.rs:19:5
@@ -30,7 +30,7 @@ error: `#[coverage]` attribute cannot be used on associated consts
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
+   = help: `#[coverage]` can be applied to crates, functions, impl blocks, and modules
 
 error: `#[coverage]` attribute cannot be used on associated types
   --> $DIR/allowed-positions.rs:22:5
@@ -38,7 +38,7 @@ error: `#[coverage]` attribute cannot be used on associated types
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
+   = help: `#[coverage]` can be applied to crates, functions, impl blocks, and modules
 
 error: `#[coverage]` attribute cannot be used on required trait methods
   --> $DIR/allowed-positions.rs:25:5
@@ -46,7 +46,7 @@ error: `#[coverage]` attribute cannot be used on required trait methods
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to impl blocks, functions, closures, provided trait methods, trait methods in impl blocks, inherent methods, modules, and crates
+   = help: `#[coverage]` can be applied to closures, crates, functions, impl blocks, inherent methods, modules, provided trait methods, and trait methods in impl blocks
 
 error: `#[coverage]` attribute cannot be used on required trait methods
   --> $DIR/allowed-positions.rs:31:5
@@ -54,7 +54,7 @@ error: `#[coverage]` attribute cannot be used on required trait methods
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to impl blocks, functions, closures, provided trait methods, trait methods in impl blocks, inherent methods, modules, and crates
+   = help: `#[coverage]` can be applied to closures, crates, functions, impl blocks, inherent methods, modules, provided trait methods, and trait methods in impl blocks
 
 error: `#[coverage]` attribute cannot be used on associated types
   --> $DIR/allowed-positions.rs:39:5
@@ -62,7 +62,7 @@ error: `#[coverage]` attribute cannot be used on associated types
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
+   = help: `#[coverage]` can be applied to crates, functions, impl blocks, and modules
 
 error: `#[coverage]` attribute cannot be used on associated types
   --> $DIR/allowed-positions.rs:56:5
@@ -70,7 +70,7 @@ error: `#[coverage]` attribute cannot be used on associated types
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
+   = help: `#[coverage]` can be applied to crates, functions, impl blocks, and modules
 
 error: `#[coverage]` attribute cannot be used on structs
   --> $DIR/allowed-positions.rs:61:1
@@ -78,7 +78,7 @@ error: `#[coverage]` attribute cannot be used on structs
 LL | #[coverage(off)]
    | ^^^^^^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
+   = help: `#[coverage]` can be applied to crates, functions, impl blocks, and modules
 
 error: `#[coverage]` attribute cannot be used on struct fields
   --> $DIR/allowed-positions.rs:63:5
@@ -86,7 +86,7 @@ error: `#[coverage]` attribute cannot be used on struct fields
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
+   = help: `#[coverage]` can be applied to crates, functions, impl blocks, and modules
 
 error: `#[coverage]` attribute cannot be used on foreign statics
   --> $DIR/allowed-positions.rs:76:5
@@ -94,7 +94,7 @@ error: `#[coverage]` attribute cannot be used on foreign statics
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
+   = help: `#[coverage]` can be applied to crates, functions, impl blocks, and modules
 
 error: `#[coverage]` attribute cannot be used on foreign types
   --> $DIR/allowed-positions.rs:79:5
@@ -102,7 +102,7 @@ error: `#[coverage]` attribute cannot be used on foreign types
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
+   = help: `#[coverage]` can be applied to crates, functions, impl blocks, and modules
 
 error: `#[coverage]` attribute cannot be used on foreign functions
   --> $DIR/allowed-positions.rs:82:5
@@ -110,7 +110,7 @@ error: `#[coverage]` attribute cannot be used on foreign functions
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to methods, impl blocks, functions, closures, modules, and crates
+   = help: `#[coverage]` can be applied to closures, crates, functions, impl blocks, methods, and modules
 
 error: `#[coverage]` attribute cannot be used on statements
   --> $DIR/allowed-positions.rs:88:5
@@ -118,7 +118,7 @@ error: `#[coverage]` attribute cannot be used on statements
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
+   = help: `#[coverage]` can be applied to crates, functions, impl blocks, and modules
 
 error: `#[coverage]` attribute cannot be used on statements
   --> $DIR/allowed-positions.rs:94:5
@@ -126,7 +126,7 @@ error: `#[coverage]` attribute cannot be used on statements
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
+   = help: `#[coverage]` can be applied to crates, functions, impl blocks, and modules
 
 error: `#[coverage]` attribute cannot be used on match arms
   --> $DIR/allowed-positions.rs:110:9
@@ -134,7 +134,7 @@ error: `#[coverage]` attribute cannot be used on match arms
 LL |         #[coverage(off)]
    |         ^^^^^^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
+   = help: `#[coverage]` can be applied to crates, functions, impl blocks, and modules
 
 error: `#[coverage]` attribute cannot be used on expressions
   --> $DIR/allowed-positions.rs:114:5
@@ -142,7 +142,7 @@ error: `#[coverage]` attribute cannot be used on expressions
 LL |     #[coverage(off)]
    |     ^^^^^^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
+   = help: `#[coverage]` can be applied to crates, functions, impl blocks, and modules
 
 error: aborting due to 18 previous errors
 
diff --git a/tests/ui/coverage-attr/name-value.stderr b/tests/ui/coverage-attr/name-value.stderr
index 77abaa42e311f..06e59e5a8646a 100644
--- a/tests/ui/coverage-attr/name-value.stderr
+++ b/tests/ui/coverage-attr/name-value.stderr
@@ -49,7 +49,7 @@ error: `#[coverage]` attribute cannot be used on structs
 LL | #[coverage = "off"]
    | ^^^^^^^^^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
+   = help: `#[coverage]` can be applied to crates, functions, impl blocks, and modules
 
 error[E0539]: malformed `coverage` attribute input
   --> $DIR/name-value.rs:26:1
@@ -87,7 +87,7 @@ error: `#[coverage]` attribute cannot be used on associated consts
 LL |     #[coverage = "off"]
    |     ^^^^^^^^^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
+   = help: `#[coverage]` can be applied to crates, functions, impl blocks, and modules
 
 error[E0539]: malformed `coverage` attribute input
   --> $DIR/name-value.rs:35:1
@@ -110,7 +110,7 @@ error: `#[coverage]` attribute cannot be used on traits
 LL | #[coverage = "off"]
    | ^^^^^^^^^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
+   = help: `#[coverage]` can be applied to crates, functions, impl blocks, and modules
 
 error[E0539]: malformed `coverage` attribute input
   --> $DIR/name-value.rs:39:5
@@ -133,7 +133,7 @@ error: `#[coverage]` attribute cannot be used on associated consts
 LL |     #[coverage = "off"]
    |     ^^^^^^^^^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
+   = help: `#[coverage]` can be applied to crates, functions, impl blocks, and modules
 
 error[E0539]: malformed `coverage` attribute input
   --> $DIR/name-value.rs:44:5
@@ -156,7 +156,7 @@ error: `#[coverage]` attribute cannot be used on associated types
 LL |     #[coverage = "off"]
    |     ^^^^^^^^^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
+   = help: `#[coverage]` can be applied to crates, functions, impl blocks, and modules
 
 error[E0539]: malformed `coverage` attribute input
   --> $DIR/name-value.rs:50:1
@@ -194,7 +194,7 @@ error: `#[coverage]` attribute cannot be used on associated consts
 LL |     #[coverage = "off"]
    |     ^^^^^^^^^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
+   = help: `#[coverage]` can be applied to crates, functions, impl blocks, and modules
 
 error[E0539]: malformed `coverage` attribute input
   --> $DIR/name-value.rs:58:5
@@ -217,7 +217,7 @@ error: `#[coverage]` attribute cannot be used on associated types
 LL |     #[coverage = "off"]
    |     ^^^^^^^^^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
+   = help: `#[coverage]` can be applied to crates, functions, impl blocks, and modules
 
 error[E0539]: malformed `coverage` attribute input
   --> $DIR/name-value.rs:64:1
diff --git a/tests/ui/coverage-attr/word-only.stderr b/tests/ui/coverage-attr/word-only.stderr
index 5fcffacc7fa7f..05478695256f9 100644
--- a/tests/ui/coverage-attr/word-only.stderr
+++ b/tests/ui/coverage-attr/word-only.stderr
@@ -43,7 +43,7 @@ error: `#[coverage]` attribute cannot be used on structs
 LL | #[coverage]
    | ^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
+   = help: `#[coverage]` can be applied to crates, functions, impl blocks, and modules
 
 error[E0539]: malformed `coverage` attribute input
   --> $DIR/word-only.rs:26:1
@@ -77,7 +77,7 @@ error: `#[coverage]` attribute cannot be used on associated consts
 LL |     #[coverage]
    |     ^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
+   = help: `#[coverage]` can be applied to crates, functions, impl blocks, and modules
 
 error[E0539]: malformed `coverage` attribute input
   --> $DIR/word-only.rs:35:1
@@ -98,7 +98,7 @@ error: `#[coverage]` attribute cannot be used on traits
 LL | #[coverage]
    | ^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
+   = help: `#[coverage]` can be applied to crates, functions, impl blocks, and modules
 
 error[E0539]: malformed `coverage` attribute input
   --> $DIR/word-only.rs:39:5
@@ -119,7 +119,7 @@ error: `#[coverage]` attribute cannot be used on associated consts
 LL |     #[coverage]
    |     ^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
+   = help: `#[coverage]` can be applied to crates, functions, impl blocks, and modules
 
 error[E0539]: malformed `coverage` attribute input
   --> $DIR/word-only.rs:44:5
@@ -140,7 +140,7 @@ error: `#[coverage]` attribute cannot be used on associated types
 LL |     #[coverage]
    |     ^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
+   = help: `#[coverage]` can be applied to crates, functions, impl blocks, and modules
 
 error[E0539]: malformed `coverage` attribute input
   --> $DIR/word-only.rs:50:1
@@ -174,7 +174,7 @@ error: `#[coverage]` attribute cannot be used on associated consts
 LL |     #[coverage]
    |     ^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
+   = help: `#[coverage]` can be applied to crates, functions, impl blocks, and modules
 
 error[E0539]: malformed `coverage` attribute input
   --> $DIR/word-only.rs:58:5
@@ -195,7 +195,7 @@ error: `#[coverage]` attribute cannot be used on associated types
 LL |     #[coverage]
    |     ^^^^^^^^^^^
    |
-   = help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
+   = help: `#[coverage]` can be applied to crates, functions, impl blocks, and modules
 
 error[E0539]: malformed `coverage` attribute input
   --> $DIR/word-only.rs:64:1
diff --git a/tests/ui/deprecation/deprecation-sanity.stderr b/tests/ui/deprecation/deprecation-sanity.stderr
index ea021b71e1485..48d08b18f8bda 100644
--- a/tests/ui/deprecation/deprecation-sanity.stderr
+++ b/tests/ui/deprecation/deprecation-sanity.stderr
@@ -177,7 +177,7 @@ LL | #[deprecated = "hello"]
    | ^^^^^^^^^^^^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[deprecated]` can be applied to functions, data types, modules, unions, constants, statics, macro defs, type aliases, use statements, foreign statics, struct fields, traits, associated types, associated consts, enum variants, inherent impl blocks, and crates
+   = help: `#[deprecated]` can be applied to associated consts, associated types, constants, crates, data types, enum variants, foreign statics, functions, inherent impl blocks, macro defs, modules, statics, struct fields, traits, type aliases, unions, and use statements
    = note: `#[deny(useless_deprecated)]` on by default
 
 error: aborting due to 10 previous errors
diff --git a/tests/ui/extern/extern-no-mangle.stderr b/tests/ui/extern/extern-no-mangle.stderr
index 69c4fbb935db6..61146e0ab56bc 100644
--- a/tests/ui/extern/extern-no-mangle.stderr
+++ b/tests/ui/extern/extern-no-mangle.stderr
@@ -19,7 +19,7 @@ LL |     #[no_mangle]
    |     ^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[no_mangle]` can be applied to methods, functions, and statics
+   = help: `#[no_mangle]` can be applied to functions, methods, and statics
 
 warning: `#[no_mangle]` attribute cannot be used on statements
   --> $DIR/extern-no-mangle.rs:24:5
diff --git a/tests/ui/feature-gates/feature-gate-allow-internal-unstable-struct.stderr b/tests/ui/feature-gates/feature-gate-allow-internal-unstable-struct.stderr
index 42141b891aef1..d68affa955aa8 100644
--- a/tests/ui/feature-gates/feature-gate-allow-internal-unstable-struct.stderr
+++ b/tests/ui/feature-gates/feature-gate-allow-internal-unstable-struct.stderr
@@ -13,7 +13,7 @@ error: `#[allow_internal_unstable]` attribute cannot be used on structs
 LL | #[allow_internal_unstable(something)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: `#[allow_internal_unstable]` can be applied to macro defs and functions
+   = help: `#[allow_internal_unstable]` can be applied to functions and macro defs
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.stderr b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.stderr
index 4f4edeef420fe..13152ca12e4b8 100644
--- a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.stderr
+++ b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.stderr
@@ -134,7 +134,7 @@ error: `#[export_name]` attribute cannot be used on required trait methods
 LL |         #[export_name = "2200"] fn foo();
    |         ^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: `#[export_name]` can be applied to statics, functions, inherent methods, provided trait methods, and trait methods in impl blocks
+   = help: `#[export_name]` can be applied to functions, inherent methods, provided trait methods, statics, and trait methods in impl blocks
 
 error: attribute should be applied to an `extern crate` item
   --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:55:1
diff --git a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr
index 30b6d1c9180f1..29044f1212c21 100644
--- a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr
+++ b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr
@@ -644,7 +644,7 @@ LL |     #[macro_use] fn f() { }
    |     ^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[macro_use]` can be applied to modules, extern crates, and crates
+   = help: `#[macro_use]` can be applied to crates, extern crates, and modules
 
 warning: `#[macro_use]` attribute cannot be used on structs
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:197:5
@@ -653,7 +653,7 @@ LL |     #[macro_use] struct S;
    |     ^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[macro_use]` can be applied to modules, extern crates, and crates
+   = help: `#[macro_use]` can be applied to crates, extern crates, and modules
 
 warning: `#[macro_use]` attribute cannot be used on type aliases
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:203:5
@@ -662,7 +662,7 @@ LL |     #[macro_use] type T = S;
    |     ^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[macro_use]` can be applied to modules, extern crates, and crates
+   = help: `#[macro_use]` can be applied to crates, extern crates, and modules
 
 warning: `#[macro_use]` attribute cannot be used on inherent impl blocks
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:209:5
@@ -671,7 +671,7 @@ LL |     #[macro_use] impl S { }
    |     ^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[macro_use]` can be applied to modules, extern crates, and crates
+   = help: `#[macro_use]` can be applied to crates, extern crates, and modules
 
 warning: `#[macro_export]` attribute cannot be used on modules
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:216:1
@@ -878,7 +878,7 @@ LL |         #[no_mangle] fn foo();
    |         ^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[no_mangle]` can be applied to functions, statics, inherent methods, and trait methods in impl blocks
+   = help: `#[no_mangle]` can be applied to functions, inherent methods, statics, and trait methods in impl blocks
 
 warning: `#[no_mangle]` attribute cannot be used on provided trait methods
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:398:9
@@ -887,7 +887,7 @@ LL |         #[no_mangle] fn bar() {}
    |         ^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[no_mangle]` can be applied to functions, statics, inherent methods, and trait methods in impl blocks
+   = help: `#[no_mangle]` can be applied to functions, inherent methods, statics, and trait methods in impl blocks
 
 warning: `#[should_panic]` attribute cannot be used on modules
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:406:1
@@ -986,7 +986,7 @@ LL |     #[no_implicit_prelude] fn f() { }
    |     ^^^^^^^^^^^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[no_implicit_prelude]` can be applied to modules and crates
+   = help: `#[no_implicit_prelude]` can be applied to crates and modules
 
 warning: `#[no_implicit_prelude]` attribute cannot be used on structs
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:482:5
@@ -995,7 +995,7 @@ LL |     #[no_implicit_prelude] struct S;
    |     ^^^^^^^^^^^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[no_implicit_prelude]` can be applied to modules and crates
+   = help: `#[no_implicit_prelude]` can be applied to crates and modules
 
 warning: `#[no_implicit_prelude]` attribute cannot be used on type aliases
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:488:5
@@ -1004,7 +1004,7 @@ LL |     #[no_implicit_prelude] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[no_implicit_prelude]` can be applied to modules and crates
+   = help: `#[no_implicit_prelude]` can be applied to crates and modules
 
 warning: `#[no_implicit_prelude]` attribute cannot be used on inherent impl blocks
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:494:5
@@ -1013,7 +1013,7 @@ LL |     #[no_implicit_prelude] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[no_implicit_prelude]` can be applied to modules and crates
+   = help: `#[no_implicit_prelude]` can be applied to crates and modules
 
 warning: `#[macro_escape]` attribute cannot be used on functions
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:533:5
@@ -1022,7 +1022,7 @@ LL |     #[macro_escape] fn f() { }
    |     ^^^^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[macro_escape]` can be applied to modules, extern crates, and crates
+   = help: `#[macro_escape]` can be applied to crates, extern crates, and modules
 
 warning: `#[macro_escape]` attribute cannot be used on structs
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:539:5
@@ -1031,7 +1031,7 @@ LL |     #[macro_escape] struct S;
    |     ^^^^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[macro_escape]` can be applied to modules, extern crates, and crates
+   = help: `#[macro_escape]` can be applied to crates, extern crates, and modules
 
 warning: `#[macro_escape]` attribute cannot be used on type aliases
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:545:5
@@ -1040,7 +1040,7 @@ LL |     #[macro_escape] type T = S;
    |     ^^^^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[macro_escape]` can be applied to modules, extern crates, and crates
+   = help: `#[macro_escape]` can be applied to crates, extern crates, and modules
 
 warning: `#[macro_escape]` attribute cannot be used on inherent impl blocks
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:551:5
@@ -1049,7 +1049,7 @@ LL |     #[macro_escape] impl S { }
    |     ^^^^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[macro_escape]` can be applied to modules, extern crates, and crates
+   = help: `#[macro_escape]` can be applied to crates, extern crates, and modules
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![no_std]`
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:558:1
@@ -1290,7 +1290,7 @@ LL | #[must_use]
    | ^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[must_use]` can be applied to functions, data types, unions, and traits
+   = help: `#[must_use]` can be applied to data types, functions, traits, and unions
 
 warning: `#[must_use]` attribute cannot be used on modules
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:795:17
@@ -1299,7 +1299,7 @@ LL |     mod inner { #![must_use] }
    |                 ^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[must_use]` can be applied to functions, data types, unions, and traits
+   = help: `#[must_use]` can be applied to data types, functions, traits, and unions
 
 warning: `#[must_use]` attribute cannot be used on type aliases
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:804:5
@@ -1308,7 +1308,7 @@ LL |     #[must_use] type T = S;
    |     ^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[must_use]` can be applied to functions, data types, unions, and traits
+   = help: `#[must_use]` can be applied to data types, functions, traits, and unions
 
 warning: `#[must_use]` attribute cannot be used on inherent impl blocks
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:809:5
@@ -1317,7 +1317,7 @@ LL |     #[must_use] impl S { }
    |     ^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[must_use]` can be applied to functions, data types, unions, and traits
+   = help: `#[must_use]` can be applied to data types, functions, traits, and unions
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![crate_name]`
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:841:1
@@ -1590,7 +1590,7 @@ LL | #![must_use]
    | ^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[must_use]` can be applied to functions, data types, unions, and traits
+   = help: `#[must_use]` can be applied to data types, functions, traits, and unions
 
 warning: 174 warnings emitted
 
diff --git a/tests/ui/invalid/invalid-debugger-visualizer-target.stderr b/tests/ui/invalid/invalid-debugger-visualizer-target.stderr
index 629af94c5ef22..c721e3dc10f59 100644
--- a/tests/ui/invalid/invalid-debugger-visualizer-target.stderr
+++ b/tests/ui/invalid/invalid-debugger-visualizer-target.stderr
@@ -4,7 +4,7 @@ error: `#[debugger_visualizer]` attribute cannot be used on functions
 LL | #[debugger_visualizer(natvis_file = "./foo.natvis.xml")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: `#[debugger_visualizer]` can be applied to modules and crates
+   = help: `#[debugger_visualizer]` can be applied to crates and modules
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-32782.stderr b/tests/ui/issues/issue-32782.stderr
index 96cd0489b2a71..2a1183ab978d0 100644
--- a/tests/ui/issues/issue-32782.stderr
+++ b/tests/ui/issues/issue-32782.stderr
@@ -20,7 +20,7 @@ LL |         #[allow_internal_unstable()]
 LL | foo!();
    | ------ in this macro invocation
    |
-   = help: `#[allow_internal_unstable]` can be applied to macro defs and functions
+   = help: `#[allow_internal_unstable]` can be applied to functions and macro defs
    = note: this error originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 2 previous errors
diff --git a/tests/ui/lint/unused/unused-attr-macro-rules.stderr b/tests/ui/lint/unused/unused-attr-macro-rules.stderr
index 0c6825026ed3b..e251ec65622ee 100644
--- a/tests/ui/lint/unused/unused-attr-macro-rules.stderr
+++ b/tests/ui/lint/unused/unused-attr-macro-rules.stderr
@@ -5,7 +5,7 @@ LL | #[macro_use]
    | ^^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[macro_use]` can be applied to modules, extern crates, and crates
+   = help: `#[macro_use]` can be applied to crates, extern crates, and modules
 note: the lint level is defined here
   --> $DIR/unused-attr-macro-rules.rs:1:9
    |
diff --git a/tests/ui/lint/unused/unused_attributes-must_use.stderr b/tests/ui/lint/unused/unused_attributes-must_use.stderr
index 001ec52ddd9e7..9b9a6a9c9f3d1 100644
--- a/tests/ui/lint/unused/unused_attributes-must_use.stderr
+++ b/tests/ui/lint/unused/unused_attributes-must_use.stderr
@@ -5,7 +5,7 @@ LL | #[must_use]
    | ^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[must_use]` can be applied to functions, data types, unions, and traits
+   = help: `#[must_use]` can be applied to data types, functions, traits, and unions
 note: the lint level is defined here
   --> $DIR/unused_attributes-must_use.rs:4:9
    |
@@ -19,7 +19,7 @@ LL | #[must_use]
    | ^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[must_use]` can be applied to functions, data types, unions, and traits
+   = help: `#[must_use]` can be applied to data types, functions, traits, and unions
 
 error: `#[must_use]` attribute cannot be used on modules
   --> $DIR/unused_attributes-must_use.rs:11:1
@@ -28,7 +28,7 @@ LL | #[must_use]
    | ^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[must_use]` can be applied to functions, data types, unions, and traits
+   = help: `#[must_use]` can be applied to data types, functions, traits, and unions
 
 error: `#[must_use]` attribute cannot be used on use statements
   --> $DIR/unused_attributes-must_use.rs:15:1
@@ -37,7 +37,7 @@ LL | #[must_use]
    | ^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[must_use]` can be applied to functions, data types, unions, and traits
+   = help: `#[must_use]` can be applied to data types, functions, traits, and unions
 
 error: `#[must_use]` attribute cannot be used on constants
   --> $DIR/unused_attributes-must_use.rs:19:1
@@ -46,7 +46,7 @@ LL | #[must_use]
    | ^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[must_use]` can be applied to functions, data types, unions, and traits
+   = help: `#[must_use]` can be applied to data types, functions, traits, and unions
 
 error: `#[must_use]` attribute cannot be used on statics
   --> $DIR/unused_attributes-must_use.rs:22:1
@@ -55,7 +55,7 @@ LL | #[must_use]
    | ^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[must_use]` can be applied to functions, data types, unions, and traits
+   = help: `#[must_use]` can be applied to data types, functions, traits, and unions
 
 error: `#[must_use]` attribute cannot be used on inherent impl blocks
   --> $DIR/unused_attributes-must_use.rs:40:1
@@ -64,7 +64,7 @@ LL | #[must_use]
    | ^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[must_use]` can be applied to functions, data types, unions, and traits
+   = help: `#[must_use]` can be applied to data types, functions, traits, and unions
 
 error: `#[must_use]` attribute cannot be used on foreign modules
   --> $DIR/unused_attributes-must_use.rs:55:1
@@ -73,7 +73,7 @@ LL | #[must_use]
    | ^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[must_use]` can be applied to functions, data types, unions, and traits
+   = help: `#[must_use]` can be applied to data types, functions, traits, and unions
 
 error: `#[must_use]` attribute cannot be used on foreign statics
   --> $DIR/unused_attributes-must_use.rs:59:5
@@ -82,7 +82,7 @@ LL |     #[must_use]
    |     ^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[must_use]` can be applied to functions, data types, unions, and traits
+   = help: `#[must_use]` can be applied to data types, functions, traits, and unions
 
 error: `#[must_use]` attribute cannot be used on type aliases
   --> $DIR/unused_attributes-must_use.rs:73:1
@@ -91,7 +91,7 @@ LL | #[must_use]
    | ^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[must_use]` can be applied to functions, data types, unions, and traits
+   = help: `#[must_use]` can be applied to data types, functions, traits, and unions
 
 error: `#[must_use]` attribute cannot be used on function params
   --> $DIR/unused_attributes-must_use.rs:77:8
@@ -100,7 +100,7 @@ LL | fn qux<#[must_use] T>(_: T) {}
    |        ^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[must_use]` can be applied to functions, data types, unions, and traits
+   = help: `#[must_use]` can be applied to data types, functions, traits, and unions
 
 error: `#[must_use]` attribute cannot be used on associated consts
   --> $DIR/unused_attributes-must_use.rs:82:5
@@ -109,7 +109,7 @@ LL |     #[must_use]
    |     ^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[must_use]` can be applied to functions, data types, unions, and traits
+   = help: `#[must_use]` can be applied to data types, functions, traits, and unions
 
 error: `#[must_use]` attribute cannot be used on associated types
   --> $DIR/unused_attributes-must_use.rs:85:5
@@ -118,7 +118,7 @@ LL |     #[must_use]
    |     ^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[must_use]` can be applied to functions, data types, unions, and traits
+   = help: `#[must_use]` can be applied to data types, functions, traits, and unions
 
 error: `#[must_use]` attribute cannot be used on trait impl blocks
   --> $DIR/unused_attributes-must_use.rs:95:1
@@ -127,7 +127,7 @@ LL | #[must_use]
    | ^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[must_use]` can be applied to functions, data types, unions, and traits
+   = help: `#[must_use]` can be applied to data types, functions, traits, and unions
 
 error: `#[must_use]` attribute cannot be used on trait methods in impl blocks
   --> $DIR/unused_attributes-must_use.rs:100:5
@@ -136,7 +136,7 @@ LL |     #[must_use]
    |     ^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[must_use]` can be applied to data types, functions, unions, required trait methods, provided trait methods, inherent methods, foreign functions, and traits
+   = help: `#[must_use]` can be applied to data types, foreign functions, functions, inherent methods, provided trait methods, required trait methods, traits, and unions
 
 error: `#[must_use]` attribute cannot be used on trait aliases
   --> $DIR/unused_attributes-must_use.rs:107:1
@@ -145,7 +145,7 @@ LL | #[must_use]
    | ^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[must_use]` can be applied to functions, data types, unions, and traits
+   = help: `#[must_use]` can be applied to data types, functions, traits, and unions
 
 error: `#[must_use]` attribute cannot be used on macro defs
   --> $DIR/unused_attributes-must_use.rs:111:1
@@ -154,7 +154,7 @@ LL | #[must_use]
    | ^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[must_use]` can be applied to functions, data types, unions, and traits
+   = help: `#[must_use]` can be applied to data types, functions, traits, and unions
 
 error: `#[must_use]` attribute cannot be used on statements
   --> $DIR/unused_attributes-must_use.rs:120:5
@@ -163,7 +163,7 @@ LL |     #[must_use]
    |     ^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[must_use]` can be applied to functions, data types, unions, and traits
+   = help: `#[must_use]` can be applied to data types, functions, traits, and unions
 
 error: `#[must_use]` attribute cannot be used on closures
   --> $DIR/unused_attributes-must_use.rs:125:13
@@ -172,7 +172,7 @@ LL |     let x = #[must_use]
    |             ^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[must_use]` can be applied to methods, data types, functions, unions, foreign functions, and traits
+   = help: `#[must_use]` can be applied to data types, foreign functions, functions, methods, traits, and unions
 
 error: `#[must_use]` attribute cannot be used on match arms
   --> $DIR/unused_attributes-must_use.rs:148:9
@@ -181,7 +181,7 @@ LL |         #[must_use]
    |         ^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[must_use]` can be applied to functions, data types, unions, and traits
+   = help: `#[must_use]` can be applied to data types, functions, traits, and unions
 
 error: `#[must_use]` attribute cannot be used on struct fields
   --> $DIR/unused_attributes-must_use.rs:157:28
@@ -190,7 +190,7 @@ LL |     let s = PatternField { #[must_use]  foo: 123 };
    |                            ^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[must_use]` can be applied to functions, data types, unions, and traits
+   = help: `#[must_use]` can be applied to data types, functions, traits, and unions
 
 error: `#[must_use]` attribute cannot be used on pattern fields
   --> $DIR/unused_attributes-must_use.rs:159:24
@@ -199,7 +199,7 @@ LL |     let PatternField { #[must_use] foo } = s;
    |                        ^^^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[must_use]` can be applied to functions, data types, unions, and traits
+   = help: `#[must_use]` can be applied to data types, functions, traits, and unions
 
 error: unused `X` that must be used
   --> $DIR/unused_attributes-must_use.rs:130:5
diff --git a/tests/ui/lint/warn-unused-inline-on-fn-prototypes.stderr b/tests/ui/lint/warn-unused-inline-on-fn-prototypes.stderr
index fcce1db7a9ac0..bdeaabbc253f4 100644
--- a/tests/ui/lint/warn-unused-inline-on-fn-prototypes.stderr
+++ b/tests/ui/lint/warn-unused-inline-on-fn-prototypes.stderr
@@ -5,7 +5,7 @@ LL |     #[inline]
    |     ^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[inline]` can be applied to functions, inherent methods, provided trait methods, trait methods in impl blocks, and closures
+   = help: `#[inline]` can be applied to closures, functions, inherent methods, provided trait methods, and trait methods in impl blocks
 note: the lint level is defined here
   --> $DIR/warn-unused-inline-on-fn-prototypes.rs:1:9
    |
@@ -19,7 +19,7 @@ LL |     #[inline]
    |     ^^^^^^^^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = help: `#[inline]` can be applied to methods, functions, and closures
+   = help: `#[inline]` can be applied to closures, functions, and methods
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/macros/issue-68060.stderr b/tests/ui/macros/issue-68060.stderr
index 4699594a2b002..54a6baaa39369 100644
--- a/tests/ui/macros/issue-68060.stderr
+++ b/tests/ui/macros/issue-68060.stderr
@@ -4,7 +4,7 @@ error: `#[target_feature]` attribute cannot be used on closures
 LL |             #[target_feature(enable = "")]
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: `#[target_feature]` can be applied to methods and functions
+   = help: `#[target_feature]` can be applied to functions and methods
 
 error[E0658]: `#[track_caller]` on closures is currently unstable
   --> $DIR/issue-68060.rs:6:13
diff --git a/tests/ui/target-feature/invalid-attribute.stderr b/tests/ui/target-feature/invalid-attribute.stderr
index d85bccce4410a..eaa26aa3ecafe 100644
--- a/tests/ui/target-feature/invalid-attribute.stderr
+++ b/tests/ui/target-feature/invalid-attribute.stderr
@@ -143,7 +143,7 @@ error: `#[target_feature]` attribute cannot be used on closures
 LL |     #[target_feature(enable = "sse2")]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: `#[target_feature]` can be applied to methods and functions
+   = help: `#[target_feature]` can be applied to functions and methods
 
 error[E0658]: cannot use `#[inline(always)]` with `#[target_feature]`
   --> $DIR/invalid-attribute.rs:62:1
diff --git a/tests/ui/where-clauses/unsupported_attribute.stderr b/tests/ui/where-clauses/unsupported_attribute.stderr
index 42a8a1350d2b5..9ebc14c40a145 100644
--- a/tests/ui/where-clauses/unsupported_attribute.stderr
+++ b/tests/ui/where-clauses/unsupported_attribute.stderr
@@ -48,7 +48,7 @@ error: `#[macro_use]` attribute cannot be used on where predicates
 LL |     #[macro_use] T: Trait,
    |     ^^^^^^^^^^^^
    |
-   = help: `#[macro_use]` can be applied to modules, extern crates, and crates
+   = help: `#[macro_use]` can be applied to crates, extern crates, and modules
 
 error: `#[macro_use]` attribute cannot be used on where predicates
   --> $DIR/unsupported_attribute.rs:21:5
@@ -56,7 +56,7 @@ error: `#[macro_use]` attribute cannot be used on where predicates
 LL |     #[macro_use] 'a: 'static,
    |     ^^^^^^^^^^^^
    |
-   = help: `#[macro_use]` can be applied to modules, extern crates, and crates
+   = help: `#[macro_use]` can be applied to crates, extern crates, and modules
 
 error: `#[deprecated]` attribute cannot be used on where predicates
   --> $DIR/unsupported_attribute.rs:24:5
@@ -64,7 +64,7 @@ error: `#[deprecated]` attribute cannot be used on where predicates
 LL |     #[deprecated] T: Trait,
    |     ^^^^^^^^^^^^^
    |
-   = help: `#[deprecated]` can be applied to functions, data types, modules, unions, constants, statics, macro defs, type aliases, use statements, foreign statics, struct fields, traits, associated types, associated consts, enum variants, inherent impl blocks, and crates
+   = help: `#[deprecated]` can be applied to associated consts, associated types, constants, crates, data types, enum variants, foreign statics, functions, inherent impl blocks, macro defs, modules, statics, struct fields, traits, type aliases, unions, and use statements
 
 error: `#[deprecated]` attribute cannot be used on where predicates
   --> $DIR/unsupported_attribute.rs:25:5
@@ -72,7 +72,7 @@ error: `#[deprecated]` attribute cannot be used on where predicates
 LL |     #[deprecated] 'a: 'static,
    |     ^^^^^^^^^^^^^
    |
-   = help: `#[deprecated]` can be applied to functions, data types, modules, unions, constants, statics, macro defs, type aliases, use statements, foreign statics, struct fields, traits, associated types, associated consts, enum variants, inherent impl blocks, and crates
+   = help: `#[deprecated]` can be applied to associated consts, associated types, constants, crates, data types, enum variants, foreign statics, functions, inherent impl blocks, macro defs, modules, statics, struct fields, traits, type aliases, unions, and use statements
 
 error: `#[automatically_derived]` attribute cannot be used on where predicates
   --> $DIR/unsupported_attribute.rs:26:5

From c33b667e8bc6623437c17e85519583796e38a1ae Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Mon, 6 Oct 2025 17:19:07 +1100
Subject: [PATCH 1811/1889] Hoist stranded `use` declarations

---
 compiler/rustc_middle/src/query/mod.rs      | 4 ++--
 compiler/rustc_middle/src/query/plumbing.rs | 6 ++----
 2 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 895c8c0295a04..30c4b4369830d 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -103,6 +103,8 @@ use rustc_span::{DUMMY_SP, Span, Symbol};
 use rustc_target::spec::{PanicStrategy, SanitizerSet};
 use {rustc_abi as abi, rustc_ast as ast, rustc_hir as hir};
 
+pub use self::keys::{AsLocalKey, Key, LocalCrate};
+pub use self::plumbing::{IntoQueryParam, TyCtxtAt, TyCtxtEnsureDone, TyCtxtEnsureOk};
 use crate::infer::canonical::{self, Canonical};
 use crate::lint::LintExpectation;
 use crate::metadata::ModChild;
@@ -146,11 +148,9 @@ use crate::{dep_graph, mir, thir};
 mod arena_cached;
 pub mod erase;
 mod keys;
-pub use keys::{AsLocalKey, Key, LocalCrate};
 pub mod on_disk_cache;
 #[macro_use]
 pub mod plumbing;
-pub use plumbing::{IntoQueryParam, TyCtxtAt, TyCtxtEnsureDone, TyCtxtEnsureOk};
 
 // Each of these queries corresponds to a function pointer field in the
 // `Providers` struct for requesting a value of that type, and a method
diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index 769df1ffd6f91..16cc81dacad4b 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -9,7 +9,9 @@ use rustc_query_system::dep_graph::{DepNodeIndex, SerializedDepNodeIndex};
 pub(crate) use rustc_query_system::query::QueryJobId;
 use rustc_query_system::query::*;
 use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span};
+pub use sealed::IntoQueryParam;
 
+use super::erase::EraseType;
 use crate::dep_graph;
 use crate::dep_graph::DepKind;
 use crate::query::on_disk_cache::{CacheEncoder, EncodedDepNodeIndex, OnDiskCache};
@@ -694,10 +696,6 @@ mod sealed {
     }
 }
 
-pub use sealed::IntoQueryParam;
-
-use super::erase::EraseType;
-
 #[derive(Copy, Clone, Debug, HashStable)]
 pub struct CyclePlaceholder(pub ErrorGuaranteed);
 

From 70a357a4c68b3a0c1a457d7a0fa06c295587bbdc Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 8 Oct 2025 09:04:22 +0200
Subject: [PATCH 1812/1889] prefer repeat_n() over repeat().take()

---
 compiler/rustc_const_eval/src/interpret/intrinsics.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
index 785978b4d7111..630e99ad4c74e 100644
--- a/compiler/rustc_const_eval/src/interpret/intrinsics.rs
+++ b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -878,7 +878,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             .compute_size_in_bytes(layout.size, count)
             .ok_or_else(|| err_ub_custom!(fluent::const_eval_size_overflow, name = name))?;
 
-        let bytes = std::iter::repeat(byte).take(len.bytes_usize());
+        let bytes = std::iter::repeat_n(byte, len.bytes_usize());
         self.write_bytes_ptr(dst, bytes)
     }
 

From ec99e3eca22bf97b1bed90173f0095ffa38bde75 Mon Sep 17 00:00:00 2001
From: dianne <diannes.gm@gmail.com>
Date: Tue, 15 Jul 2025 23:24:44 -0700
Subject: [PATCH 1813/1889] clarify wording of match ergonomics diagnostics

---
 compiler/rustc_hir_typeck/src/pat.rs          |  21 +-
 compiler/rustc_lint_defs/src/builtin.rs       |   2 +-
 .../rustc_middle/src/ty/typeck_results.rs     |   6 +-
 compiler/rustc_mir_build/messages.ftl         |  11 -
 compiler/rustc_mir_build/src/errors.rs        |  66 +--
 .../src/thir/pattern/migration.rs             | 112 +++--
 .../mixed-editions.classic2021.stderr         |  10 +-
 .../mixed-editions.classic2024.stderr         |   8 +-
 .../experimental/mixed-editions.rs            |   4 +-
 .../mixed-editions.structural2021.stderr      |  10 +-
 .../mixed-editions.structural2024.stderr      |   8 +-
 ...nding-on-inh-ref-errors.classic2024.stderr |  48 +-
 .../ref-binding-on-inh-ref-errors.rs          |  22 +-
 ...ng-on-inh-ref-errors.structural2024.stderr | 132 ++---
 .../migration_lint.fixed                      |  82 ++--
 .../migration_lint.rs                         |  82 ++--
 .../migration_lint.stderr                     | 459 ++++++++++--------
 .../min_match_ergonomics_fail.rs              |  14 +-
 .../min_match_ergonomics_fail.stderr          |  80 +--
 19 files changed, 629 insertions(+), 548 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/pat.rs b/compiler/rustc_hir_typeck/src/pat.rs
index 46accb76a184a..d14463e44a03f 100644
--- a/compiler/rustc_hir_typeck/src/pat.rs
+++ b/compiler/rustc_hir_typeck/src/pat.rs
@@ -3115,20 +3115,29 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // binding mode. This keeps it from making those suggestions, as doing so could panic.
         let info = table.entry(pat_id).or_insert_with(|| ty::Rust2024IncompatiblePatInfo {
             primary_labels: Vec::new(),
-            bad_modifiers: false,
+            bad_ref_modifiers: false,
+            bad_mut_modifiers: false,
             bad_ref_pats: false,
             suggest_eliding_modes: !self.tcx.features().ref_pat_eat_one_layer_2024()
                 && !self.tcx.features().ref_pat_eat_one_layer_2024_structural(),
         });
 
         let pat_kind = if let PatKind::Binding(user_bind_annot, _, _, _) = subpat.kind {
-            info.bad_modifiers = true;
             // If the user-provided binding modifier doesn't match the default binding mode, we'll
             // need to suggest reference patterns, which can affect other bindings.
             // For simplicity, we opt to suggest making the pattern fully explicit.
             info.suggest_eliding_modes &=
                 user_bind_annot == BindingMode(ByRef::Yes(def_br_mutbl), Mutability::Not);
-            "binding modifier"
+            if user_bind_annot == BindingMode(ByRef::No, Mutability::Mut) {
+                info.bad_mut_modifiers = true;
+                "`mut` binding modifier"
+            } else {
+                info.bad_ref_modifiers = true;
+                match user_bind_annot.1 {
+                    Mutability::Not => "explicit `ref` binding modifier",
+                    Mutability::Mut => "explicit `ref mut` binding modifier",
+                }
+            }
         } else {
             info.bad_ref_pats = true;
             // For simplicity, we don't try to suggest eliding reference patterns. Thus, we'll
@@ -3147,11 +3156,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             // so, we may want to inspect the span's source callee or macro backtrace.
             "occurs within macro expansion".to_owned()
         } else {
-            let dbm_str = match def_br_mutbl {
-                Mutability::Not => "ref",
-                Mutability::Mut => "ref mut",
-            };
-            format!("{pat_kind} not allowed under `{dbm_str}` default binding mode")
+            format!("{pat_kind} not allowed when implicitly borrowing")
         };
         info.primary_labels.push((trimmed_span, primary_label));
     }
diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs
index 939f3d088b12f..8b7b13a4c3622 100644
--- a/compiler/rustc_lint_defs/src/builtin.rs
+++ b/compiler/rustc_lint_defs/src/builtin.rs
@@ -1601,7 +1601,7 @@ declare_lint! {
     "detects patterns whose meaning will change in Rust 2024",
     @future_incompatible = FutureIncompatibleInfo {
         reason: FutureIncompatibilityReason::EditionSemanticsChange(Edition::Edition2024),
-        reference: "<https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>",
+        reference: "<https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>",
     };
 }
 
diff --git a/compiler/rustc_middle/src/ty/typeck_results.rs b/compiler/rustc_middle/src/ty/typeck_results.rs
index b276b993ec924..d1fb700913d91 100644
--- a/compiler/rustc_middle/src/ty/typeck_results.rs
+++ b/compiler/rustc_middle/src/ty/typeck_results.rs
@@ -858,8 +858,10 @@ impl<'tcx> std::fmt::Display for UserTypeKind<'tcx> {
 pub struct Rust2024IncompatiblePatInfo {
     /// Labeled spans for `&`s, `&mut`s, and binding modifiers incompatible with Rust 2024.
     pub primary_labels: Vec<(Span, String)>,
-    /// Whether any binding modifiers occur under a non-`move` default binding mode.
-    pub bad_modifiers: bool,
+    /// Whether any `mut` binding modifiers occur under a non-`move` default binding mode.
+    pub bad_mut_modifiers: bool,
+    /// Whether any `ref`/`ref mut` binding modifiers occur under a non-`move` default binding mode.
+    pub bad_ref_modifiers: bool,
     /// Whether any `&` or `&mut` patterns occur under a non-`move` default binding mode.
     pub bad_ref_pats: bool,
     /// If `true`, we can give a simpler suggestion solely by eliding explicit binding modifiers.
diff --git a/compiler/rustc_mir_build/messages.ftl b/compiler/rustc_mir_build/messages.ftl
index 83fbcb30dd941..e84e42b8a44b5 100644
--- a/compiler/rustc_mir_build/messages.ftl
+++ b/compiler/rustc_mir_build/messages.ftl
@@ -322,17 +322,6 @@ mir_build_pointer_pattern = function pointers and raw pointers not derived from
 
 mir_build_privately_uninhabited = pattern `{$witness_1}` is currently uninhabited, but this variant contains private fields which may become inhabited in the future
 
-mir_build_rust_2024_incompatible_pat = {$bad_modifiers ->
-        *[true] binding modifiers{$bad_ref_pats ->
-            *[true] {" "}and reference patterns
-            [false] {""}
-        }
-        [false] reference patterns
-    } may only be written when the default binding mode is `move`{$is_hard_error ->
-        *[true] {""}
-        [false] {" "}in Rust 2024
-    }
-
 mir_build_static_in_pattern = statics cannot be referenced in patterns
     .label = can't be used in patterns
 mir_build_static_in_pattern_def = `static` defined here
diff --git a/compiler/rustc_mir_build/src/errors.rs b/compiler/rustc_mir_build/src/errors.rs
index 58c3de4a8b59c..e2aae5b6283f2 100644
--- a/compiler/rustc_mir_build/src/errors.rs
+++ b/compiler/rustc_mir_build/src/errors.rs
@@ -1,8 +1,7 @@
-use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::codes::*;
 use rustc_errors::{
     Applicability, Diag, DiagArgValue, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level,
-    MultiSpan, Subdiagnostic, pluralize,
+    MultiSpan, Subdiagnostic,
 };
 use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
 use rustc_middle::ty::{self, Ty};
@@ -1087,69 +1086,6 @@ pub(crate) enum MiscPatternSuggestion {
     },
 }
 
-#[derive(LintDiagnostic)]
-#[diag(mir_build_rust_2024_incompatible_pat)]
-pub(crate) struct Rust2024IncompatiblePat {
-    #[subdiagnostic]
-    pub(crate) sugg: Rust2024IncompatiblePatSugg,
-    pub(crate) bad_modifiers: bool,
-    pub(crate) bad_ref_pats: bool,
-    pub(crate) is_hard_error: bool,
-}
-
-pub(crate) struct Rust2024IncompatiblePatSugg {
-    /// If true, our suggestion is to elide explicit binding modifiers.
-    /// If false, our suggestion is to make the pattern fully explicit.
-    pub(crate) suggest_eliding_modes: bool,
-    pub(crate) suggestion: Vec<(Span, String)>,
-    pub(crate) ref_pattern_count: usize,
-    pub(crate) binding_mode_count: usize,
-    /// Labels for where incompatibility-causing by-ref default binding modes were introduced.
-    pub(crate) default_mode_labels: FxIndexMap<Span, ty::Mutability>,
-}
-
-impl Subdiagnostic for Rust2024IncompatiblePatSugg {
-    fn add_to_diag<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>) {
-        // Format and emit explanatory notes about default binding modes. Reversing the spans' order
-        // means if we have nested spans, the innermost ones will be visited first.
-        for (span, def_br_mutbl) in self.default_mode_labels.into_iter().rev() {
-            // Don't point to a macro call site.
-            if !span.from_expansion() {
-                let note_msg = "matching on a reference type with a non-reference pattern changes the default binding mode";
-                let label_msg =
-                    format!("this matches on type `{}_`", def_br_mutbl.ref_prefix_str());
-                let mut label = MultiSpan::from(span);
-                label.push_span_label(span, label_msg);
-                diag.span_note(label, note_msg);
-            }
-        }
-
-        // Format and emit the suggestion.
-        let applicability =
-            if self.suggestion.iter().all(|(span, _)| span.can_be_used_for_suggestions()) {
-                Applicability::MachineApplicable
-            } else {
-                Applicability::MaybeIncorrect
-            };
-        let msg = if self.suggest_eliding_modes {
-            let plural_modes = pluralize!(self.binding_mode_count);
-            format!("remove the unnecessary binding modifier{plural_modes}")
-        } else {
-            let plural_derefs = pluralize!(self.ref_pattern_count);
-            let and_modes = if self.binding_mode_count > 0 {
-                format!(" and variable binding mode{}", pluralize!(self.binding_mode_count))
-            } else {
-                String::new()
-            };
-            format!("make the implied reference pattern{plural_derefs}{and_modes} explicit")
-        };
-        // FIXME(dianne): for peace of mind, don't risk emitting a 0-part suggestion (that panics!)
-        if !self.suggestion.is_empty() {
-            diag.multipart_suggestion_verbose(msg, self.suggestion, applicability);
-        }
-    }
-}
-
 #[derive(Diagnostic)]
 #[diag(mir_build_loop_match_invalid_update)]
 pub(crate) struct LoopMatchInvalidUpdate {
diff --git a/compiler/rustc_mir_build/src/thir/pattern/migration.rs b/compiler/rustc_mir_build/src/thir/pattern/migration.rs
index 12c457f13fc12..8887308530506 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/migration.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/migration.rs
@@ -1,15 +1,12 @@
 //! Automatic migration of Rust 2021 patterns to a form valid in both Editions 2021 and 2024.
 
 use rustc_data_structures::fx::FxIndexMap;
-use rustc_errors::MultiSpan;
+use rustc_errors::{Applicability, Diag, EmissionGuarantee, MultiSpan, pluralize};
 use rustc_hir::{BindingMode, ByRef, HirId, Mutability};
 use rustc_lint as lint;
 use rustc_middle::ty::{self, Rust2024IncompatiblePatInfo, TyCtxt};
 use rustc_span::{Ident, Span};
 
-use crate::errors::{Rust2024IncompatiblePat, Rust2024IncompatiblePatSugg};
-use crate::fluent_generated as fluent;
-
 /// For patterns flagged for migration during HIR typeck, this handles constructing and emitting
 /// a diagnostic suggestion.
 pub(super) struct PatMigration<'a> {
@@ -49,39 +46,90 @@ impl<'a> PatMigration<'a> {
         for (span, label) in self.info.primary_labels.iter() {
             spans.push_span_label(*span, label.clone());
         }
-        let sugg = Rust2024IncompatiblePatSugg {
-            suggest_eliding_modes: self.info.suggest_eliding_modes,
-            suggestion: self.suggestion,
-            ref_pattern_count: self.ref_pattern_count,
-            binding_mode_count: self.binding_mode_count,
-            default_mode_labels: self.default_mode_labels,
-        };
         // If a relevant span is from at least edition 2024, this is a hard error.
         let is_hard_error = spans.primary_spans().iter().any(|span| span.at_least_rust_2024());
+        let primary_message = self.primary_message(is_hard_error);
         if is_hard_error {
-            let mut err =
-                tcx.dcx().struct_span_err(spans, fluent::mir_build_rust_2024_incompatible_pat);
-            if let Some(info) = lint::builtin::RUST_2024_INCOMPATIBLE_PAT.future_incompatible {
-                // provide the same reference link as the lint
-                err.note(format!("for more information, see {}", info.reference));
-            }
-            err.arg("bad_modifiers", self.info.bad_modifiers);
-            err.arg("bad_ref_pats", self.info.bad_ref_pats);
-            err.arg("is_hard_error", true);
-            err.subdiagnostic(sugg);
+            let mut err = tcx.dcx().struct_span_err(spans, primary_message);
+            err.note("for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>");
+            self.format_subdiagnostics(&mut err);
             err.emit();
         } else {
-            tcx.emit_node_span_lint(
-                lint::builtin::RUST_2024_INCOMPATIBLE_PAT,
-                pat_id,
-                spans,
-                Rust2024IncompatiblePat {
-                    sugg,
-                    bad_modifiers: self.info.bad_modifiers,
-                    bad_ref_pats: self.info.bad_ref_pats,
-                    is_hard_error,
-                },
-            );
+            tcx.node_span_lint(lint::builtin::RUST_2024_INCOMPATIBLE_PAT, pat_id, spans, |diag| {
+                diag.primary_message(primary_message);
+                self.format_subdiagnostics(diag);
+            });
+        }
+    }
+
+    fn primary_message(&self, is_hard_error: bool) -> String {
+        let verb1 = match (self.info.bad_mut_modifiers, self.info.bad_ref_modifiers) {
+            (true, true) => "write explicit binding modifiers",
+            (true, false) => "mutably bind by value",
+            (false, true) => "explicitly borrow",
+            (false, false) => "explicitly dereference",
+        };
+        let or_verb2 = match (
+            self.info.bad_mut_modifiers,
+            self.info.bad_ref_modifiers,
+            self.info.bad_ref_pats,
+        ) {
+            // We only need two verb phrases if mentioning both modifiers and reference patterns.
+            (false, false, _) | (_, _, false) => "",
+            // If mentioning `mut`, we don't have an "explicitly" yet.
+            (true, _, true) => " or explicitly dereference",
+            // If mentioning `ref`/`ref mut` but not `mut`, we already have an "explicitly".
+            (false, true, true) => " or dereference",
+        };
+        let in_rust_2024 = if is_hard_error { "" } else { " in Rust 2024" };
+        format!("cannot {verb1}{or_verb2} within an implicitly-borrowing pattern{in_rust_2024}")
+    }
+
+    fn format_subdiagnostics(self, diag: &mut Diag<'_, impl EmissionGuarantee>) {
+        // Format and emit explanatory notes about default binding modes. Reversing the spans' order
+        // means if we have nested spans, the innermost ones will be visited first.
+        for (span, def_br_mutbl) in self.default_mode_labels.into_iter().rev() {
+            // Don't point to a macro call site.
+            if !span.from_expansion() {
+                let note_msg = "matching on a reference type with a non-reference pattern implicitly borrows the contents";
+                let label_msg = format!(
+                    "this non-reference pattern matches on a reference type `{}_`",
+                    def_br_mutbl.ref_prefix_str()
+                );
+                let mut label = MultiSpan::from(span);
+                label.push_span_label(span, label_msg);
+                diag.span_note(label, note_msg);
+            }
+        }
+
+        // Format and emit the suggestion.
+        let applicability =
+            if self.suggestion.iter().all(|(span, _)| span.can_be_used_for_suggestions()) {
+                Applicability::MachineApplicable
+            } else {
+                Applicability::MaybeIncorrect
+            };
+        let plural_modes = pluralize!(self.binding_mode_count);
+        let msg = if self.info.suggest_eliding_modes {
+            format!("remove the unnecessary binding modifier{plural_modes}")
+        } else {
+            let match_on_these_references = if self.ref_pattern_count == 1 {
+                "match on the reference with a reference pattern"
+            } else {
+                "match on these references with reference patterns"
+            };
+            let and_explain_modes = if self.binding_mode_count > 0 {
+                let a = if self.binding_mode_count == 1 { "a " } else { "" };
+                format!(" and borrow explicitly using {a}variable binding mode{plural_modes}")
+            } else {
+                " to avoid implicitly borrowing".to_owned()
+            };
+            format!("{match_on_these_references}{and_explain_modes}")
+        };
+        // FIXME(dianne): for peace of mind, don't risk emitting a 0-part suggestion (that panics!)
+        debug_assert!(!self.suggestion.is_empty());
+        if !self.suggestion.is_empty() {
+            diag.multipart_suggestion_verbose(msg, self.suggestion, applicability);
         }
     }
 
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mixed-editions.classic2021.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mixed-editions.classic2021.stderr
index 7e3caaf979748..fc1ca18c12026 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mixed-editions.classic2021.stderr
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mixed-editions.classic2021.stderr
@@ -59,20 +59,20 @@ LL |     let [&bind_ref_mut!(x)] = &mut [0];
    |          |
    |          help: replace this `&` with `&mut`: `&mut`
 
-error: binding modifiers may only be written when the default binding mode is `move`
+error: cannot explicitly borrow within an implicitly-borrowing pattern
   --> $DIR/mixed-editions.rs:30:10
    |
 LL |     let [bind_ref!(y)] = &[0];
    |          ^^^^^^^^^^^^ occurs within macro expansion
    |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/mixed-editions.rs:30:9
    |
 LL |     let [bind_ref!(y)] = &[0];
-   |         ^^^^^^^^^^^^^^ this matches on type `&_`
+   |         ^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
    = note: this error originates in the macro `bind_ref` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: make the implied reference pattern explicit
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &[bind_ref!(y)] = &[0];
    |         +
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mixed-editions.classic2024.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mixed-editions.classic2024.stderr
index 466993a1671f4..9377d535f1874 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mixed-editions.classic2024.stderr
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mixed-editions.classic2024.stderr
@@ -58,14 +58,14 @@ LL |     let [&bind_ref_mut!(x)] = &mut [0];
    |          |
    |          help: replace this `&` with `&mut`: `&mut`
 
-error: binding modifiers may only be written when the default binding mode is `move`
+error: cannot explicitly borrow within an implicitly-borrowing pattern
   --> $DIR/mixed-editions.rs:26:21
    |
 LL |     let match_ctor!(ref x) = &[0];
-   |                     ^^^ binding modifier not allowed under `ref` default binding mode
+   |                     ^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
    |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-help: make the implied reference pattern explicit
+   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
+help: match on the reference with a reference pattern to avoid implicitly borrowing
   --> $DIR/auxiliary/mixed-editions-macros.rs:11:9
    |
 LL |         &[$p]
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mixed-editions.rs b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mixed-editions.rs
index 0a22b55ab6374..3580ed3862703 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mixed-editions.rs
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mixed-editions.rs
@@ -24,11 +24,11 @@ fn assert_type_eq<T, U: Eq<T>>(_: T, _: U) {}
 /// only when the binding is from edition 2024.
 fn ref_binding_tests() {
     let match_ctor!(ref x) = &[0];
-    //[classic2024,structural2024]~^ ERROR: binding modifiers may only be written when the default binding mode is `move`
+    //[classic2024,structural2024]~^ ERROR: cannot explicitly borrow within an implicitly-borrowing pattern
     #[cfg(any(classic2021, structural2021))] assert_type_eq(x, &0u32);
 
     let [bind_ref!(y)] = &[0];
-    //[classic2021,structural2021]~^ ERROR: binding modifiers may only be written when the default binding mode is `move`
+    //[classic2021,structural2021]~^ ERROR: cannot explicitly borrow within an implicitly-borrowing pattern
     #[cfg(any(classic2024, structural2024))] assert_type_eq(y, &0u32);
 }
 
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mixed-editions.structural2021.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mixed-editions.structural2021.stderr
index 4075dc9529da1..69ddb0720526e 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mixed-editions.structural2021.stderr
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mixed-editions.structural2021.stderr
@@ -37,20 +37,20 @@ LL |     let [&bind_ref_mut!(x)] = &mut [0];
    |          |
    |          help: replace this `&` with `&mut`: `&mut`
 
-error: binding modifiers may only be written when the default binding mode is `move`
+error: cannot explicitly borrow within an implicitly-borrowing pattern
   --> $DIR/mixed-editions.rs:30:10
    |
 LL |     let [bind_ref!(y)] = &[0];
    |          ^^^^^^^^^^^^ occurs within macro expansion
    |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/mixed-editions.rs:30:9
    |
 LL |     let [bind_ref!(y)] = &[0];
-   |         ^^^^^^^^^^^^^^ this matches on type `&_`
+   |         ^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
    = note: this error originates in the macro `bind_ref` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: make the implied reference pattern explicit
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &[bind_ref!(y)] = &[0];
    |         +
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mixed-editions.structural2024.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mixed-editions.structural2024.stderr
index 819a54299ea1c..bc1fee35a6bb4 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mixed-editions.structural2024.stderr
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mixed-editions.structural2024.stderr
@@ -36,14 +36,14 @@ LL |     let [&bind_ref_mut!(x)] = &mut [0];
    |          |
    |          help: replace this `&` with `&mut`: `&mut`
 
-error: binding modifiers may only be written when the default binding mode is `move`
+error: cannot explicitly borrow within an implicitly-borrowing pattern
   --> $DIR/mixed-editions.rs:26:21
    |
 LL |     let match_ctor!(ref x) = &[0];
-   |                     ^^^ binding modifier not allowed under `ref` default binding mode
+   |                     ^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
    |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-help: make the implied reference pattern explicit
+   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
+help: match on the reference with a reference pattern to avoid implicitly borrowing
   --> $DIR/auxiliary/mixed-editions-macros.rs:11:9
    |
 LL |         &[$p]
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-binding-on-inh-ref-errors.classic2024.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-binding-on-inh-ref-errors.classic2024.stderr
index 04e53e06a22e6..956cd2166433a 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-binding-on-inh-ref-errors.classic2024.stderr
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-binding-on-inh-ref-errors.classic2024.stderr
@@ -11,19 +11,19 @@ LL -     let [&mut ref x] = &[&mut 0];
 LL +     let [&ref x] = &[&mut 0];
    |
 
-error: binding modifiers may only be written when the default binding mode is `move`
+error: cannot explicitly borrow within an implicitly-borrowing pattern
   --> $DIR/ref-binding-on-inh-ref-errors.rs:73:10
    |
 LL |     let [ref mut x] = &[0];
-   |          ^^^^^^^ binding modifier not allowed under `ref` default binding mode
+   |          ^^^^^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
    |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/ref-binding-on-inh-ref-errors.rs:73:9
    |
 LL |     let [ref mut x] = &[0];
-   |         ^^^^^^^^^^^ this matches on type `&_`
-help: make the implied reference pattern explicit
+   |         ^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &[ref mut x] = &[0];
    |         +
@@ -34,53 +34,53 @@ error[E0596]: cannot borrow data in a `&` reference as mutable
 LL |     let [ref mut x] = &[0];
    |          ^^^^^^^^^ cannot borrow as mutable
 
-error: binding modifiers may only be written when the default binding mode is `move`
+error: cannot explicitly borrow within an implicitly-borrowing pattern
   --> $DIR/ref-binding-on-inh-ref-errors.rs:81:10
    |
 LL |     let [ref x] = &[0];
-   |          ^^^ binding modifier not allowed under `ref` default binding mode
+   |          ^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
    |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/ref-binding-on-inh-ref-errors.rs:81:9
    |
 LL |     let [ref x] = &[0];
-   |         ^^^^^^^ this matches on type `&_`
-help: make the implied reference pattern explicit
+   |         ^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &[ref x] = &[0];
    |         +
 
-error: binding modifiers may only be written when the default binding mode is `move`
+error: cannot explicitly borrow within an implicitly-borrowing pattern
   --> $DIR/ref-binding-on-inh-ref-errors.rs:85:10
    |
 LL |     let [ref x] = &mut [0];
-   |          ^^^ binding modifier not allowed under `ref mut` default binding mode
+   |          ^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
    |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/ref-binding-on-inh-ref-errors.rs:85:9
    |
 LL |     let [ref x] = &mut [0];
-   |         ^^^^^^^ this matches on type `&mut _`
-help: make the implied reference pattern explicit
+   |         ^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &mut [ref x] = &mut [0];
    |         ++++
 
-error: binding modifiers may only be written when the default binding mode is `move`
+error: cannot explicitly borrow within an implicitly-borrowing pattern
   --> $DIR/ref-binding-on-inh-ref-errors.rs:89:10
    |
 LL |     let [ref mut x] = &mut [0];
-   |          ^^^^^^^ binding modifier not allowed under `ref mut` default binding mode
+   |          ^^^^^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
    |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/ref-binding-on-inh-ref-errors.rs:89:9
    |
 LL |     let [ref mut x] = &mut [0];
-   |         ^^^^^^^^^^^ this matches on type `&mut _`
-help: make the implied reference pattern explicit
+   |         ^^^^^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &mut [ref mut x] = &mut [0];
    |         ++++
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-binding-on-inh-ref-errors.rs b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-binding-on-inh-ref-errors.rs
index c9e3f75cf178a..628cb60b8495c 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-binding-on-inh-ref-errors.rs
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-binding-on-inh-ref-errors.rs
@@ -17,22 +17,22 @@
 /// The eat-outer variant eats the inherited reference, so binding with `ref` isn't a problem.
 fn errors_from_eating_the_real_reference() {
     let [&ref x] = &[&0];
-    //[structural2024]~^ ERROR: binding modifiers may only be written when the default binding mode is `move`
+    //[structural2024]~^ ERROR: cannot explicitly borrow within an implicitly-borrowing pattern
     #[cfg(any(stable2021, classic2021, structural2021))] let _: &u32 = x;
     #[cfg(classic2024)] let _: &&u32 = x;
 
     let [&ref x] = &mut [&0];
-    //[structural2024]~^ ERROR: binding modifiers may only be written when the default binding mode is `move`
+    //[structural2024]~^ ERROR: cannot explicitly borrow within an implicitly-borrowing pattern
     #[cfg(any(stable2021, classic2021, structural2021))] let _: &u32 = x;
     #[cfg(classic2024)] let _: &&u32 = x;
 
     let [&mut ref x] = &mut [&mut 0];
-    //[structural2024]~^ ERROR: binding modifiers may only be written when the default binding mode is `move`
+    //[structural2024]~^ ERROR: cannot explicitly borrow within an implicitly-borrowing pattern
     #[cfg(any(stable2021, classic2021, structural2021))] let _: &u32 = x;
     #[cfg(classic2024)] let _: &&mut u32 = x;
 
     let [&mut ref mut x] = &mut [&mut 0];
-    //[structural2024]~^ ERROR: binding modifiers may only be written when the default binding mode is `move`
+    //[structural2024]~^ ERROR: cannot explicitly borrow within an implicitly-borrowing pattern
     #[cfg(any(stable2021, classic2021, structural2021))] let _: &mut u32 = x;
     #[cfg(classic2024)] let _: &mut &mut u32 = x;
 }
@@ -43,14 +43,14 @@ fn errors_from_eating_the_real_reference_caught_in_hir_typeck_on_stable() {
     let [&ref x] = &[&mut 0];
     //[stable2021]~^ ERROR: mismatched types
     //[stable2021]~| NOTE types differ in mutability
-    //[structural2024]~^^^ ERROR: binding modifiers may only be written when the default binding mode is `move`
+    //[structural2024]~^^^ ERROR: cannot explicitly borrow within an implicitly-borrowing pattern
     #[cfg(any(classic2021, structural2021))] let _: &u32 = x;
     #[cfg(classic2024)] let _: &&mut u32 = x;
 
     let [&ref x] = &mut [&mut 0];
     //[stable2021]~^ ERROR: mismatched types
     //[stable2021]~| NOTE types differ in mutability
-    //[structural2024]~^^^ ERROR: binding modifiers may only be written when the default binding mode is `move`
+    //[structural2024]~^^^ ERROR: cannot explicitly borrow within an implicitly-borrowing pattern
     #[cfg(any(classic2021, structural2021))] let _: &u32 = x;
     #[cfg(classic2024)] let _: &&mut u32 = x;
 }
@@ -60,7 +60,7 @@ fn errors_dependent_on_eating_order_caught_in_hir_typeck_when_eating_outer() {
     let [&mut ref x] = &[&mut 0];
     //[classic2024]~^ ERROR: mismatched types
     //[classic2024]~| NOTE cannot match inherited `&` with `&mut` pattern
-    //[structural2024]~^^^ ERROR: binding modifiers may only be written when the default binding mode is `move`
+    //[structural2024]~^^^ ERROR: cannot explicitly borrow within an implicitly-borrowing pattern
     #[cfg(any(stable2021, classic2021, structural2021))] let _: &u32 = x;
 }
 
@@ -72,21 +72,21 @@ fn errors_dependent_on_eating_order_caught_in_hir_typeck_when_eating_outer() {
 fn borrowck_errors_in_old_editions() {
     let [ref mut x] = &[0];
     //~^ ERROR: cannot borrow data in a `&` reference as mutable
-    //[classic2024,structural2024]~| ERROR: binding modifiers may only be written when the default binding mode is `move`
+    //[classic2024,structural2024]~| ERROR: cannot explicitly borrow within an implicitly-borrowing pattern
 }
 
 /// The remaining tests are purely for testing `ref` bindings in the presence of an inherited
 /// reference. These should always fail on edition 2024 and succeed on edition 2021.
 pub fn main() {
     let [ref x] = &[0];
-    //[classic2024,structural2024]~^ ERROR: binding modifiers may only be written when the default binding mode is `move`
+    //[classic2024,structural2024]~^ ERROR: cannot explicitly borrow within an implicitly-borrowing pattern
     #[cfg(any(stable2021, classic2021, structural2021))] let _: &u32 = x;
 
     let [ref x] = &mut [0];
-    //[classic2024,structural2024]~^ ERROR: binding modifiers may only be written when the default binding mode is `move`
+    //[classic2024,structural2024]~^ ERROR: cannot explicitly borrow within an implicitly-borrowing pattern
     #[cfg(any(stable2021, classic2021, structural2021))] let _: &u32 = x;
 
     let [ref mut x] = &mut [0];
-    //[classic2024,structural2024]~^ ERROR: binding modifiers may only be written when the default binding mode is `move`
+    //[classic2024,structural2024]~^ ERROR: cannot explicitly borrow within an implicitly-borrowing pattern
     #[cfg(any(stable2021, classic2021, structural2021))] let _: &mut u32 = x;
 }
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-binding-on-inh-ref-errors.structural2024.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-binding-on-inh-ref-errors.structural2024.stderr
index def6deb325acd..9753e3e5fbfea 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-binding-on-inh-ref-errors.structural2024.stderr
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-binding-on-inh-ref-errors.structural2024.stderr
@@ -1,135 +1,135 @@
-error: binding modifiers may only be written when the default binding mode is `move`
+error: cannot explicitly borrow within an implicitly-borrowing pattern
   --> $DIR/ref-binding-on-inh-ref-errors.rs:19:11
    |
 LL |     let [&ref x] = &[&0];
-   |           ^^^ binding modifier not allowed under `ref` default binding mode
+   |           ^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
    |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/ref-binding-on-inh-ref-errors.rs:19:9
    |
 LL |     let [&ref x] = &[&0];
-   |         ^^^^^^^^ this matches on type `&_`
-help: make the implied reference pattern explicit
+   |         ^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &[&ref x] = &[&0];
    |         +
 
-error: binding modifiers may only be written when the default binding mode is `move`
+error: cannot explicitly borrow within an implicitly-borrowing pattern
   --> $DIR/ref-binding-on-inh-ref-errors.rs:24:11
    |
 LL |     let [&ref x] = &mut [&0];
-   |           ^^^ binding modifier not allowed under `ref` default binding mode
+   |           ^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
    |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/ref-binding-on-inh-ref-errors.rs:24:9
    |
 LL |     let [&ref x] = &mut [&0];
-   |         ^^^^^^^^ this matches on type `&mut _`
-help: make the implied reference pattern explicit
+   |         ^^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &mut [&ref x] = &mut [&0];
    |         ++++
 
-error: binding modifiers may only be written when the default binding mode is `move`
+error: cannot explicitly borrow within an implicitly-borrowing pattern
   --> $DIR/ref-binding-on-inh-ref-errors.rs:29:15
    |
 LL |     let [&mut ref x] = &mut [&mut 0];
-   |               ^^^ binding modifier not allowed under `ref mut` default binding mode
+   |               ^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
    |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/ref-binding-on-inh-ref-errors.rs:29:9
    |
 LL |     let [&mut ref x] = &mut [&mut 0];
-   |         ^^^^^^^^^^^^ this matches on type `&mut _`
-help: make the implied reference pattern explicit
+   |         ^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &mut [&mut ref x] = &mut [&mut 0];
    |         ++++
 
-error: binding modifiers may only be written when the default binding mode is `move`
+error: cannot explicitly borrow within an implicitly-borrowing pattern
   --> $DIR/ref-binding-on-inh-ref-errors.rs:34:15
    |
 LL |     let [&mut ref mut x] = &mut [&mut 0];
-   |               ^^^^^^^ binding modifier not allowed under `ref mut` default binding mode
+   |               ^^^^^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
    |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/ref-binding-on-inh-ref-errors.rs:34:9
    |
 LL |     let [&mut ref mut x] = &mut [&mut 0];
-   |         ^^^^^^^^^^^^^^^^ this matches on type `&mut _`
-help: make the implied reference pattern explicit
+   |         ^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &mut [&mut ref mut x] = &mut [&mut 0];
    |         ++++
 
-error: binding modifiers may only be written when the default binding mode is `move`
+error: cannot explicitly borrow within an implicitly-borrowing pattern
   --> $DIR/ref-binding-on-inh-ref-errors.rs:43:11
    |
 LL |     let [&ref x] = &[&mut 0];
-   |           ^^^ binding modifier not allowed under `ref` default binding mode
+   |           ^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
    |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/ref-binding-on-inh-ref-errors.rs:43:9
    |
 LL |     let [&ref x] = &[&mut 0];
-   |         ^^^^^^^^ this matches on type `&_`
-help: make the implied reference pattern explicit
+   |         ^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &[&ref x] = &[&mut 0];
    |         +
 
-error: binding modifiers may only be written when the default binding mode is `move`
+error: cannot explicitly borrow within an implicitly-borrowing pattern
   --> $DIR/ref-binding-on-inh-ref-errors.rs:50:11
    |
 LL |     let [&ref x] = &mut [&mut 0];
-   |           ^^^ binding modifier not allowed under `ref` default binding mode
+   |           ^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
    |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/ref-binding-on-inh-ref-errors.rs:50:9
    |
 LL |     let [&ref x] = &mut [&mut 0];
-   |         ^^^^^^^^ this matches on type `&mut _`
-help: make the implied reference pattern explicit
+   |         ^^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &mut [&ref x] = &mut [&mut 0];
    |         ++++
 
-error: binding modifiers may only be written when the default binding mode is `move`
+error: cannot explicitly borrow within an implicitly-borrowing pattern
   --> $DIR/ref-binding-on-inh-ref-errors.rs:60:15
    |
 LL |     let [&mut ref x] = &[&mut 0];
-   |               ^^^ binding modifier not allowed under `ref` default binding mode
+   |               ^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
    |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/ref-binding-on-inh-ref-errors.rs:60:9
    |
 LL |     let [&mut ref x] = &[&mut 0];
-   |         ^^^^^^^^^^^^ this matches on type `&_`
-help: make the implied reference pattern explicit
+   |         ^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &[&mut ref x] = &[&mut 0];
    |         +
 
-error: binding modifiers may only be written when the default binding mode is `move`
+error: cannot explicitly borrow within an implicitly-borrowing pattern
   --> $DIR/ref-binding-on-inh-ref-errors.rs:73:10
    |
 LL |     let [ref mut x] = &[0];
-   |          ^^^^^^^ binding modifier not allowed under `ref` default binding mode
+   |          ^^^^^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
    |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/ref-binding-on-inh-ref-errors.rs:73:9
    |
 LL |     let [ref mut x] = &[0];
-   |         ^^^^^^^^^^^ this matches on type `&_`
-help: make the implied reference pattern explicit
+   |         ^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &[ref mut x] = &[0];
    |         +
@@ -140,53 +140,53 @@ error[E0596]: cannot borrow data in a `&` reference as mutable
 LL |     let [ref mut x] = &[0];
    |          ^^^^^^^^^ cannot borrow as mutable
 
-error: binding modifiers may only be written when the default binding mode is `move`
+error: cannot explicitly borrow within an implicitly-borrowing pattern
   --> $DIR/ref-binding-on-inh-ref-errors.rs:81:10
    |
 LL |     let [ref x] = &[0];
-   |          ^^^ binding modifier not allowed under `ref` default binding mode
+   |          ^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
    |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/ref-binding-on-inh-ref-errors.rs:81:9
    |
 LL |     let [ref x] = &[0];
-   |         ^^^^^^^ this matches on type `&_`
-help: make the implied reference pattern explicit
+   |         ^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &[ref x] = &[0];
    |         +
 
-error: binding modifiers may only be written when the default binding mode is `move`
+error: cannot explicitly borrow within an implicitly-borrowing pattern
   --> $DIR/ref-binding-on-inh-ref-errors.rs:85:10
    |
 LL |     let [ref x] = &mut [0];
-   |          ^^^ binding modifier not allowed under `ref mut` default binding mode
+   |          ^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
    |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/ref-binding-on-inh-ref-errors.rs:85:9
    |
 LL |     let [ref x] = &mut [0];
-   |         ^^^^^^^ this matches on type `&mut _`
-help: make the implied reference pattern explicit
+   |         ^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &mut [ref x] = &mut [0];
    |         ++++
 
-error: binding modifiers may only be written when the default binding mode is `move`
+error: cannot explicitly borrow within an implicitly-borrowing pattern
   --> $DIR/ref-binding-on-inh-ref-errors.rs:89:10
    |
 LL |     let [ref mut x] = &mut [0];
-   |          ^^^^^^^ binding modifier not allowed under `ref mut` default binding mode
+   |          ^^^^^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
    |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/ref-binding-on-inh-ref-errors.rs:89:9
    |
 LL |     let [ref mut x] = &mut [0];
-   |         ^^^^^^^^^^^ this matches on type `&mut _`
-help: make the implied reference pattern explicit
+   |         ^^^^^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &mut [ref mut x] = &mut [0];
    |         ++++
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/migration_lint.fixed b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/migration_lint.fixed
index bb4ecc09063b7..2df39fdd6103d 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/migration_lint.fixed
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/migration_lint.fixed
@@ -23,22 +23,22 @@ fn main() {
     assert_type_eq(x, &mut 0u8);
 
     let &Foo(mut x) = &Foo(0);
-    //~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot mutably bind by value within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, 0u8);
 
     let &mut Foo(mut x) = &mut Foo(0);
-    //~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot mutably bind by value within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, 0u8);
 
     let Foo(x) = &Foo(0);
-    //~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly borrow within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, &0u8);
 
     let &mut Foo(ref x) = &mut Foo(0);
-    //~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly borrow within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, &0u8);
 
@@ -55,22 +55,22 @@ fn main() {
     assert_type_eq(x, &0u8);
 
     let &Foo(&x) = &Foo(&0);
-    //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, 0u8);
 
     let &Foo(&mut x) = &Foo(&mut 0);
-    //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, 0u8);
 
     let &mut Foo(&x) = &mut Foo(&0);
-    //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, 0u8);
 
     let &mut Foo(&mut x) = &mut Foo(&mut 0);
-    //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, 0u8);
 
@@ -79,25 +79,25 @@ fn main() {
     }
 
     if let &&&&&Some(&x) = &&&&&Some(&0u8) {
-        //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+        //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
         //~| WARN: this changes meaning in Rust 2024
         assert_type_eq(x, 0u8);
     }
 
     if let &&&&&Some(&mut x) = &&&&&Some(&mut 0u8) {
-        //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+        //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
         //~| WARN: this changes meaning in Rust 2024
         assert_type_eq(x, 0u8);
     }
 
     if let &&&&&mut Some(&x) = &&&&&mut Some(&0u8) {
-        //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+        //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
         //~| WARN: this changes meaning in Rust 2024
         assert_type_eq(x, 0u8);
     }
 
     if let &mut Some(&mut Some(&mut Some(ref mut x))) = &mut Some(&mut Some(&mut Some(0u8))) {
-        //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+        //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
         //~| WARN: this changes meaning in Rust 2024
         assert_type_eq(x, &mut 0u8);
     }
@@ -109,20 +109,20 @@ fn main() {
     }
 
     let &Struct { ref a, mut b, ref c } = &Struct { a: 0, b: 0, c: 0 };
-    //~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot mutably bind by value within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, &0u32);
     assert_type_eq(b, 0u32);
 
     let &Struct { a: &a, ref b, ref c } = &Struct { a: &0, b: &0, c: &0 };
-    //~^ ERROR: binding modifiers and reference patterns may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly borrow or dereference within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, 0u32);
     assert_type_eq(b, &&0u32);
     assert_type_eq(c, &&0u32);
 
     if let &Struct { a: &Some(a), b: &Some(&b), c: &Some(ref c) } =
-        //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+        //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
         //~| WARN: this changes meaning in Rust 2024
         &(Struct { a: &Some(&0), b: &Some(&0), c: &Some(&0) })
     {
@@ -135,7 +135,7 @@ fn main() {
         // The two patterns are the same syntactically, but because they're defined in different
         // editions they don't mean the same thing.
         &(Some(mut x), migration_lint_macros::mixed_edition_pat!(y)) => {
-            //~^ ERROR: binding modifiers may only be written when the default binding mode is `move`
+            //~^ ERROR: cannot mutably bind by value within an implicitly-borrowing pattern
             assert_type_eq(x, 0u32);
             assert_type_eq(y, 0u32);
         }
@@ -143,26 +143,26 @@ fn main() {
     }
 
     let &mut [&mut &[ref a]] = &mut [&mut &[0]];
-    //~^ ERROR: binding modifiers and reference patterns may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly borrow or dereference within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, &0u32);
 
     let &[&(_)] = &[&0];
-    //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
 
     // NB: Most of the following tests are for possible future improvements to migration suggestions
 
     // Test removing multiple binding modifiers.
     let Struct { a, b, c } = &Struct { a: 0, b: 0, c: 0 };
-    //~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly borrow within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, &0u32);
     assert_type_eq(c, &0u32);
 
     // Test that we don't change bindings' modes when removing binding modifiers.
     let &mut Struct { ref a, ref mut b, ref mut c } = &mut Struct { a: 0, b: 0, c: 0 };
-    //~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly borrow within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, &0u32);
     assert_type_eq(b, &mut 0u32);
@@ -170,7 +170,7 @@ fn main() {
 
     // Test removing multiple reference patterns of various mutabilities, plus a binding modifier.
     let &mut &Struct { a: &[ref a], b: &mut [&[ref b]], ref c } = &mut &Struct { a: &[0], b: &mut [&[0]], c: 0 };
-    //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, &0u32);
     assert_type_eq(b, &0u32);
@@ -178,13 +178,13 @@ fn main() {
 
     // Test that we don't change bindings' types when removing reference patterns.
     let &Foo(&ref a) = &Foo(&0);
-    //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, &0u32);
 
     // Test that we don't change bindings' modes when adding reference paterns (caught early).
     let &(&a, ref b, &[ref c], &mut [&mut (ref d, &[ref e])]) = &(&0, 0, &[0], &mut [&mut (0, &[0])]);
-    //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, 0u32);
     assert_type_eq(b, &0u32);
@@ -194,7 +194,7 @@ fn main() {
 
     // Test that we don't change bindings' modes when adding reference patterns (caught late).
     let &(ref a, &mut [ref b], &[mut c]) = &(0, &mut [0], &[0]);
-    //~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot mutably bind by value within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, &0u32);
     assert_type_eq(b, &0u32);
@@ -202,7 +202,7 @@ fn main() {
 
     // Test featuring both additions and removals.
     let &(&a, &mut (ref b, &[ref c])) = &(&0, &mut (0, &[0]));
-    //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, 0u32);
     assert_type_eq(b, &0u32);
@@ -210,21 +210,21 @@ fn main() {
 
     // Test that bindings' subpatterns' modes are updated properly.
     let &[mut a @ ref b] = &[0];
-    //~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot mutably bind by value within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, 0u32);
     assert_type_eq(b, &0u32);
 
     // Test that bindings' subpatterns' modes are checked properly.
     let &[ref a @ mut b] = &[0];
-    //~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot mutably bind by value within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, &0u32);
     assert_type_eq(b, 0u32);
 
     // Test that we respect bindings' subpatterns' types when rewriting `&ref x` to `x`.
     let [&Foo(&ref a @ ref b), &Foo(&ref c @ d)] = [&Foo(&0); 2];
-    //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, &0u32);
     assert_type_eq(b, &0u32);
@@ -233,7 +233,7 @@ fn main() {
 
     // Test that we respect bindings' subpatterns' modes when rewriting `&ref x` to `x`.
     let [&Foo(&ref a @ [ref b]), &Foo(&ref c @ [d])] = [&Foo(&[0]); 2];
-    //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, &[0u32]);
     assert_type_eq(b, &0u32);
@@ -242,12 +242,32 @@ fn main() {
 
     // Test that we use the correct message and suggestion style when pointing inside expansions.
     let &[migration_lint_macros::bind_ref!(a)] = &[0];
-    //~^ ERROR: binding modifiers may only be written when the default binding mode is `move`
+    //~^ ERROR: cannot explicitly borrow within an implicitly-borrowing pattern
     assert_type_eq(a, &0u32);
 
     // Test that we use the correct span when labeling a `&` whose subpattern is from an expansion.
     let &[&migration_lint_macros::bind_ref!(a)] = &[&0];
-    //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, &0u32);
+
+    // Test the primary diagnostic message for mixes of `mut`/`ref`/`&`.
+    let &(mut a, ref b) = &(0, 0);
+    //~^ ERROR: cannot write explicit binding modifiers within an implicitly-borrowing pattern in Rust 2024
+    //~| WARN: this changes meaning in Rust 2024
+    assert_type_eq(a, 0u32);
+    assert_type_eq(b, &0u32);
+
+    let &(mut a, &b) = &(0, &0);
+    //~^ ERROR: cannot mutably bind by value or explicitly dereference within an implicitly-borrowing pattern in Rust 2024
+    //~| WARN: this changes meaning in Rust 2024
+    assert_type_eq(a, 0u32);
+    assert_type_eq(b, 0u32);
+
+    let &(mut a, ref b, &c) = &(0, 0, &0);
+    //~^ ERROR: cannot write explicit binding modifiers or explicitly dereference within an implicitly-borrowing pattern in Rust 2024
+    //~| WARN: this changes meaning in Rust 2024
+    assert_type_eq(a, 0u32);
+    assert_type_eq(b, &0u32);
+    assert_type_eq(c, 0u32);
 }
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/migration_lint.rs b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/migration_lint.rs
index 2837c8d81dbdd..0d727ad7d7a5c 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/migration_lint.rs
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/migration_lint.rs
@@ -23,22 +23,22 @@ fn main() {
     assert_type_eq(x, &mut 0u8);
 
     let Foo(mut x) = &Foo(0);
-    //~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot mutably bind by value within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, 0u8);
 
     let Foo(mut x) = &mut Foo(0);
-    //~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot mutably bind by value within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, 0u8);
 
     let Foo(ref x) = &Foo(0);
-    //~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly borrow within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, &0u8);
 
     let Foo(ref x) = &mut Foo(0);
-    //~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly borrow within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, &0u8);
 
@@ -55,22 +55,22 @@ fn main() {
     assert_type_eq(x, &0u8);
 
     let Foo(&x) = &Foo(&0);
-    //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, 0u8);
 
     let Foo(&mut x) = &Foo(&mut 0);
-    //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, 0u8);
 
     let Foo(&x) = &mut Foo(&0);
-    //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, 0u8);
 
     let Foo(&mut x) = &mut Foo(&mut 0);
-    //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(x, 0u8);
 
@@ -79,25 +79,25 @@ fn main() {
     }
 
     if let Some(&x) = &&&&&Some(&0u8) {
-        //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+        //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
         //~| WARN: this changes meaning in Rust 2024
         assert_type_eq(x, 0u8);
     }
 
     if let Some(&mut x) = &&&&&Some(&mut 0u8) {
-        //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+        //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
         //~| WARN: this changes meaning in Rust 2024
         assert_type_eq(x, 0u8);
     }
 
     if let Some(&x) = &&&&&mut Some(&0u8) {
-        //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+        //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
         //~| WARN: this changes meaning in Rust 2024
         assert_type_eq(x, 0u8);
     }
 
     if let Some(&mut Some(Some(x))) = &mut Some(&mut Some(&mut Some(0u8))) {
-        //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+        //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
         //~| WARN: this changes meaning in Rust 2024
         assert_type_eq(x, &mut 0u8);
     }
@@ -109,20 +109,20 @@ fn main() {
     }
 
     let Struct { a, mut b, c } = &Struct { a: 0, b: 0, c: 0 };
-    //~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot mutably bind by value within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, &0u32);
     assert_type_eq(b, 0u32);
 
     let Struct { a: &a, b, ref c } = &Struct { a: &0, b: &0, c: &0 };
-    //~^ ERROR: binding modifiers and reference patterns may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly borrow or dereference within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, 0u32);
     assert_type_eq(b, &&0u32);
     assert_type_eq(c, &&0u32);
 
     if let Struct { a: &Some(a), b: Some(&b), c: Some(c) } =
-        //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+        //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
         //~| WARN: this changes meaning in Rust 2024
         &(Struct { a: &Some(&0), b: &Some(&0), c: &Some(&0) })
     {
@@ -135,7 +135,7 @@ fn main() {
         // The two patterns are the same syntactically, but because they're defined in different
         // editions they don't mean the same thing.
         (Some(mut x), migration_lint_macros::mixed_edition_pat!(y)) => {
-            //~^ ERROR: binding modifiers may only be written when the default binding mode is `move`
+            //~^ ERROR: cannot mutably bind by value within an implicitly-borrowing pattern
             assert_type_eq(x, 0u32);
             assert_type_eq(y, 0u32);
         }
@@ -143,26 +143,26 @@ fn main() {
     }
 
     let [&mut [ref a]] = &mut [&mut &[0]];
-    //~^ ERROR: binding modifiers and reference patterns may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly borrow or dereference within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, &0u32);
 
     let [&(_)] = &[&0];
-    //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
 
     // NB: Most of the following tests are for possible future improvements to migration suggestions
 
     // Test removing multiple binding modifiers.
     let Struct { ref a, ref b, c } = &Struct { a: 0, b: 0, c: 0 };
-    //~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly borrow within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, &0u32);
     assert_type_eq(c, &0u32);
 
     // Test that we don't change bindings' modes when removing binding modifiers.
     let Struct { ref a, ref mut b, c } = &mut Struct { a: 0, b: 0, c: 0 };
-    //~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly borrow within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, &0u32);
     assert_type_eq(b, &mut 0u32);
@@ -170,7 +170,7 @@ fn main() {
 
     // Test removing multiple reference patterns of various mutabilities, plus a binding modifier.
     let Struct { a: &[ref a], b: &mut [[b]], c } = &mut &Struct { a: &[0], b: &mut [&[0]], c: 0 };
-    //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, &0u32);
     assert_type_eq(b, &0u32);
@@ -178,13 +178,13 @@ fn main() {
 
     // Test that we don't change bindings' types when removing reference patterns.
     let Foo(&ref a) = &Foo(&0);
-    //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, &0u32);
 
     // Test that we don't change bindings' modes when adding reference paterns (caught early).
     let (&a, b, [c], [(d, [e])]) = &(&0, 0, &[0], &mut [&mut (0, &[0])]);
-    //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, 0u32);
     assert_type_eq(b, &0u32);
@@ -194,7 +194,7 @@ fn main() {
 
     // Test that we don't change bindings' modes when adding reference patterns (caught late).
     let (a, [b], [mut c]) = &(0, &mut [0], &[0]);
-    //~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot mutably bind by value within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, &0u32);
     assert_type_eq(b, &0u32);
@@ -202,7 +202,7 @@ fn main() {
 
     // Test featuring both additions and removals.
     let (&a, (b, &[ref c])) = &(&0, &mut (0, &[0]));
-    //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, 0u32);
     assert_type_eq(b, &0u32);
@@ -210,21 +210,21 @@ fn main() {
 
     // Test that bindings' subpatterns' modes are updated properly.
     let [mut a @ b] = &[0];
-    //~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot mutably bind by value within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, 0u32);
     assert_type_eq(b, &0u32);
 
     // Test that bindings' subpatterns' modes are checked properly.
     let [a @ mut b] = &[0];
-    //~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot mutably bind by value within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, &0u32);
     assert_type_eq(b, 0u32);
 
     // Test that we respect bindings' subpatterns' types when rewriting `&ref x` to `x`.
     let [Foo(&ref a @ ref b), Foo(&ref c @ d)] = [&Foo(&0); 2];
-    //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, &0u32);
     assert_type_eq(b, &0u32);
@@ -233,7 +233,7 @@ fn main() {
 
     // Test that we respect bindings' subpatterns' modes when rewriting `&ref x` to `x`.
     let [Foo(&ref a @ [ref b]), Foo(&ref c @ [d])] = [&Foo(&[0]); 2];
-    //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, &[0u32]);
     assert_type_eq(b, &0u32);
@@ -242,12 +242,32 @@ fn main() {
 
     // Test that we use the correct message and suggestion style when pointing inside expansions.
     let [migration_lint_macros::bind_ref!(a)] = &[0];
-    //~^ ERROR: binding modifiers may only be written when the default binding mode is `move`
+    //~^ ERROR: cannot explicitly borrow within an implicitly-borrowing pattern
     assert_type_eq(a, &0u32);
 
     // Test that we use the correct span when labeling a `&` whose subpattern is from an expansion.
     let [&migration_lint_macros::bind_ref!(a)] = &[&0];
-    //~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+    //~^ ERROR: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
     //~| WARN: this changes meaning in Rust 2024
     assert_type_eq(a, &0u32);
+
+    // Test the primary diagnostic message for mixes of `mut`/`ref`/`&`.
+    let (mut a, ref b) = &(0, 0);
+    //~^ ERROR: cannot write explicit binding modifiers within an implicitly-borrowing pattern in Rust 2024
+    //~| WARN: this changes meaning in Rust 2024
+    assert_type_eq(a, 0u32);
+    assert_type_eq(b, &0u32);
+
+    let (mut a, &b) = &(0, &0);
+    //~^ ERROR: cannot mutably bind by value or explicitly dereference within an implicitly-borrowing pattern in Rust 2024
+    //~| WARN: this changes meaning in Rust 2024
+    assert_type_eq(a, 0u32);
+    assert_type_eq(b, 0u32);
+
+    let (mut a, ref b, &c) = &(0, 0, &0);
+    //~^ ERROR: cannot write explicit binding modifiers or explicitly dereference within an implicitly-borrowing pattern in Rust 2024
+    //~| WARN: this changes meaning in Rust 2024
+    assert_type_eq(a, 0u32);
+    assert_type_eq(b, &0u32);
+    assert_type_eq(c, 0u32);
 }
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/migration_lint.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/migration_lint.stderr
index 6efda4f757ff6..01fcfdc8be6ee 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/migration_lint.stderr
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/migration_lint.stderr
@@ -1,602 +1,663 @@
-error: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+error: cannot mutably bind by value within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:25:13
    |
 LL |     let Foo(mut x) = &Foo(0);
-   |             ^^^ binding modifier not allowed under `ref` default binding mode
+   |             ^^^ `mut` binding modifier not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:25:9
    |
 LL |     let Foo(mut x) = &Foo(0);
-   |         ^^^^^^^^^^ this matches on type `&_`
+   |         ^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
 note: the lint level is defined here
   --> $DIR/migration_lint.rs:7:9
    |
 LL | #![deny(rust_2024_incompatible_pat)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: make the implied reference pattern explicit
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &Foo(mut x) = &Foo(0);
    |         +
 
-error: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+error: cannot mutably bind by value within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:30:13
    |
 LL |     let Foo(mut x) = &mut Foo(0);
-   |             ^^^ binding modifier not allowed under `ref mut` default binding mode
+   |             ^^^ `mut` binding modifier not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:30:9
    |
 LL |     let Foo(mut x) = &mut Foo(0);
-   |         ^^^^^^^^^^ this matches on type `&mut _`
-help: make the implied reference pattern explicit
+   |         ^^^^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &mut Foo(mut x) = &mut Foo(0);
    |         ++++
 
-error: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+error: cannot explicitly borrow within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:35:13
    |
 LL |     let Foo(ref x) = &Foo(0);
-   |             ^^^ binding modifier not allowed under `ref` default binding mode
+   |             ^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:35:9
    |
 LL |     let Foo(ref x) = &Foo(0);
-   |         ^^^^^^^^^^ this matches on type `&_`
+   |         ^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
 help: remove the unnecessary binding modifier
    |
 LL -     let Foo(ref x) = &Foo(0);
 LL +     let Foo(x) = &Foo(0);
    |
 
-error: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+error: cannot explicitly borrow within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:40:13
    |
 LL |     let Foo(ref x) = &mut Foo(0);
-   |             ^^^ binding modifier not allowed under `ref mut` default binding mode
+   |             ^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:40:9
    |
 LL |     let Foo(ref x) = &mut Foo(0);
-   |         ^^^^^^^^^^ this matches on type `&mut _`
-help: make the implied reference pattern explicit
+   |         ^^^^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &mut Foo(ref x) = &mut Foo(0);
    |         ++++
 
-error: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+error: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:57:13
    |
 LL |     let Foo(&x) = &Foo(&0);
-   |             ^ reference pattern not allowed under `ref` default binding mode
+   |             ^ reference pattern not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:57:9
    |
 LL |     let Foo(&x) = &Foo(&0);
-   |         ^^^^^^^ this matches on type `&_`
-help: make the implied reference pattern explicit
+   |         ^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &Foo(&x) = &Foo(&0);
    |         +
 
-error: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+error: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:62:13
    |
 LL |     let Foo(&mut x) = &Foo(&mut 0);
-   |             ^^^^ reference pattern not allowed under `ref` default binding mode
+   |             ^^^^ reference pattern not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:62:9
    |
 LL |     let Foo(&mut x) = &Foo(&mut 0);
-   |         ^^^^^^^^^^^ this matches on type `&_`
-help: make the implied reference pattern explicit
+   |         ^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &Foo(&mut x) = &Foo(&mut 0);
    |         +
 
-error: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+error: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:67:13
    |
 LL |     let Foo(&x) = &mut Foo(&0);
-   |             ^ reference pattern not allowed under `ref mut` default binding mode
+   |             ^ reference pattern not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:67:9
    |
 LL |     let Foo(&x) = &mut Foo(&0);
-   |         ^^^^^^^ this matches on type `&mut _`
-help: make the implied reference pattern explicit
+   |         ^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &mut Foo(&x) = &mut Foo(&0);
    |         ++++
 
-error: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+error: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:72:13
    |
 LL |     let Foo(&mut x) = &mut Foo(&mut 0);
-   |             ^^^^ reference pattern not allowed under `ref mut` default binding mode
+   |             ^^^^ reference pattern not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:72:9
    |
 LL |     let Foo(&mut x) = &mut Foo(&mut 0);
-   |         ^^^^^^^^^^^ this matches on type `&mut _`
-help: make the implied reference pattern explicit
+   |         ^^^^^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &mut Foo(&mut x) = &mut Foo(&mut 0);
    |         ++++
 
-error: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+error: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:81:17
    |
 LL |     if let Some(&x) = &&&&&Some(&0u8) {
-   |                 ^ reference pattern not allowed under `ref` default binding mode
+   |                 ^ reference pattern not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:81:12
    |
 LL |     if let Some(&x) = &&&&&Some(&0u8) {
-   |            ^^^^^^^^ this matches on type `&_`
-help: make the implied reference patterns explicit
+   |            ^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on these references with reference patterns to avoid implicitly borrowing
    |
 LL |     if let &&&&&Some(&x) = &&&&&Some(&0u8) {
    |            +++++
 
-error: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+error: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:87:17
    |
 LL |     if let Some(&mut x) = &&&&&Some(&mut 0u8) {
-   |                 ^^^^ reference pattern not allowed under `ref` default binding mode
+   |                 ^^^^ reference pattern not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:87:12
    |
 LL |     if let Some(&mut x) = &&&&&Some(&mut 0u8) {
-   |            ^^^^^^^^^^^^ this matches on type `&_`
-help: make the implied reference patterns explicit
+   |            ^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on these references with reference patterns to avoid implicitly borrowing
    |
 LL |     if let &&&&&Some(&mut x) = &&&&&Some(&mut 0u8) {
    |            +++++
 
-error: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+error: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:93:17
    |
 LL |     if let Some(&x) = &&&&&mut Some(&0u8) {
-   |                 ^ reference pattern not allowed under `ref` default binding mode
+   |                 ^ reference pattern not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:93:12
    |
 LL |     if let Some(&x) = &&&&&mut Some(&0u8) {
-   |            ^^^^^^^^ this matches on type `&_`
-help: make the implied reference patterns explicit
+   |            ^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on these references with reference patterns to avoid implicitly borrowing
    |
 LL |     if let &&&&&mut Some(&x) = &&&&&mut Some(&0u8) {
    |            ++++++++
 
-error: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+error: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:99:17
    |
 LL |     if let Some(&mut Some(Some(x))) = &mut Some(&mut Some(&mut Some(0u8))) {
-   |                 ^^^^ reference pattern not allowed under `ref mut` default binding mode
+   |                 ^^^^ reference pattern not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:99:12
    |
 LL |     if let Some(&mut Some(Some(x))) = &mut Some(&mut Some(&mut Some(0u8))) {
-   |            ^^^^^^^^^^^^^^^^^^^^^^^^ this matches on type `&mut _`
-help: make the implied reference patterns and variable binding mode explicit
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
+help: match on these references with reference patterns and borrow explicitly using a variable binding mode
    |
 LL |     if let &mut Some(&mut Some(&mut Some(ref mut x))) = &mut Some(&mut Some(&mut Some(0u8))) {
    |            ++++                ++++      +++++++
 
-error: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+error: cannot mutably bind by value within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:111:21
    |
 LL |     let Struct { a, mut b, c } = &Struct { a: 0, b: 0, c: 0 };
-   |                     ^^^ binding modifier not allowed under `ref` default binding mode
+   |                     ^^^ `mut` binding modifier not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:111:9
    |
 LL |     let Struct { a, mut b, c } = &Struct { a: 0, b: 0, c: 0 };
-   |         ^^^^^^^^^^^^^^^^^^^^^^ this matches on type `&_`
-help: make the implied reference pattern and variable binding modes explicit
+   |         ^^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on the reference with a reference pattern and borrow explicitly using variable binding modes
    |
 LL |     let &Struct { ref a, mut b, ref c } = &Struct { a: 0, b: 0, c: 0 };
    |         +         +++           +++
 
-error: binding modifiers and reference patterns may only be written when the default binding mode is `move` in Rust 2024
+error: cannot explicitly borrow or dereference within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:117:21
    |
 LL |     let Struct { a: &a, b, ref c } = &Struct { a: &0, b: &0, c: &0 };
-   |                     ^      ^^^ binding modifier not allowed under `ref` default binding mode
+   |                     ^      ^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
    |                     |
-   |                     reference pattern not allowed under `ref` default binding mode
+   |                     reference pattern not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:117:9
    |
 LL |     let Struct { a: &a, b, ref c } = &Struct { a: &0, b: &0, c: &0 };
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ this matches on type `&_`
-help: make the implied reference pattern and variable binding mode explicit
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on the reference with a reference pattern and borrow explicitly using a variable binding mode
    |
 LL |     let &Struct { a: &a, ref b, ref c } = &Struct { a: &0, b: &0, c: &0 };
    |         +                +++
 
-error: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+error: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:124:24
    |
 LL |     if let Struct { a: &Some(a), b: Some(&b), c: Some(c) } =
-   |                        ^                 ^ reference pattern not allowed under `ref` default binding mode
+   |                        ^                 ^ reference pattern not allowed when implicitly borrowing
    |                        |
-   |                        reference pattern not allowed under `ref` default binding mode
+   |                        reference pattern not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:124:12
    |
 LL |     if let Struct { a: &Some(a), b: Some(&b), c: Some(c) } =
-   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this matches on type `&_`
-help: make the implied reference patterns and variable binding mode explicit
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on these references with reference patterns and borrow explicitly using a variable binding mode
    |
 LL |     if let &Struct { a: &Some(a), b: &Some(&b), c: &Some(ref c) } =
    |            +                         +             +     +++
 
-error: binding modifiers may only be written when the default binding mode is `move`
+error: cannot mutably bind by value within an implicitly-borrowing pattern
   --> $DIR/migration_lint.rs:137:15
    |
 LL |         (Some(mut x), migration_lint_macros::mixed_edition_pat!(y)) => {
    |               ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ occurs within macro expansion
    |               |
-   |               binding modifier not allowed under `ref` default binding mode
+   |               `mut` binding modifier not allowed when implicitly borrowing
    |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:137:9
    |
 LL |         (Some(mut x), migration_lint_macros::mixed_edition_pat!(y)) => {
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this matches on type `&_`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
    = note: this error originates in the macro `migration_lint_macros::mixed_edition_pat` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: make the implied reference pattern explicit
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |         &(Some(mut x), migration_lint_macros::mixed_edition_pat!(y)) => {
    |         +
 
-error: binding modifiers and reference patterns may only be written when the default binding mode is `move` in Rust 2024
+error: cannot explicitly borrow or dereference within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:145:10
    |
 LL |     let [&mut [ref a]] = &mut [&mut &[0]];
-   |          ^^^^  ^^^ binding modifier not allowed under `ref` default binding mode
+   |          ^^^^  ^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
    |          |
-   |          reference pattern not allowed under `ref mut` default binding mode
+   |          reference pattern not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:145:15
    |
 LL |     let [&mut [ref a]] = &mut [&mut &[0]];
-   |               ^^^^^^^ this matches on type `&_`
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   |               ^^^^^^^ this non-reference pattern matches on a reference type `&_`
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:145:9
    |
 LL |     let [&mut [ref a]] = &mut [&mut &[0]];
-   |         ^^^^^^^^^^^^^^ this matches on type `&mut _`
-help: make the implied reference patterns explicit
+   |         ^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
+help: match on these references with reference patterns to avoid implicitly borrowing
    |
 LL |     let &mut [&mut &[ref a]] = &mut [&mut &[0]];
    |         ++++       +
 
-error: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+error: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:150:10
    |
 LL |     let [&(_)] = &[&0];
-   |          ^ reference pattern not allowed under `ref` default binding mode
+   |          ^ reference pattern not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:150:9
    |
 LL |     let [&(_)] = &[&0];
-   |         ^^^^^^ this matches on type `&_`
-help: make the implied reference pattern explicit
+   |         ^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &[&(_)] = &[&0];
    |         +
 
-error: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+error: cannot explicitly borrow within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:157:18
    |
 LL |     let Struct { ref a, ref b, c } = &Struct { a: 0, b: 0, c: 0 };
-   |                  ^^^    ^^^ binding modifier not allowed under `ref` default binding mode
+   |                  ^^^    ^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
    |                  |
-   |                  binding modifier not allowed under `ref` default binding mode
+   |                  explicit `ref` binding modifier not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:157:9
    |
 LL |     let Struct { ref a, ref b, c } = &Struct { a: 0, b: 0, c: 0 };
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ this matches on type `&_`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
 help: remove the unnecessary binding modifiers
    |
 LL -     let Struct { ref a, ref b, c } = &Struct { a: 0, b: 0, c: 0 };
 LL +     let Struct { a, b, c } = &Struct { a: 0, b: 0, c: 0 };
    |
 
-error: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+error: cannot explicitly borrow within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:164:18
    |
 LL |     let Struct { ref a, ref mut b, c } = &mut Struct { a: 0, b: 0, c: 0 };
-   |                  ^^^    ^^^^^^^ binding modifier not allowed under `ref mut` default binding mode
+   |                  ^^^    ^^^^^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
    |                  |
-   |                  binding modifier not allowed under `ref mut` default binding mode
+   |                  explicit `ref` binding modifier not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:164:9
    |
 LL |     let Struct { ref a, ref mut b, c } = &mut Struct { a: 0, b: 0, c: 0 };
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this matches on type `&mut _`
-help: make the implied reference pattern and variable binding mode explicit
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
+help: match on the reference with a reference pattern and borrow explicitly using a variable binding mode
    |
 LL |     let &mut Struct { ref a, ref mut b, ref mut c } = &mut Struct { a: 0, b: 0, c: 0 };
    |         ++++                            +++++++
 
-error: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+error: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:172:21
    |
 LL |     let Struct { a: &[ref a], b: &mut [[b]], c } = &mut &Struct { a: &[0], b: &mut [&[0]], c: 0 };
-   |                     ^            ^^^^ reference pattern not allowed under `ref` default binding mode
+   |                     ^            ^^^^ reference pattern not allowed when implicitly borrowing
    |                     |
-   |                     reference pattern not allowed under `ref` default binding mode
+   |                     reference pattern not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:172:9
    |
 LL |     let Struct { a: &[ref a], b: &mut [[b]], c } = &mut &Struct { a: &[0], b: &mut [&[0]], c: 0 };
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this matches on type `&_`
-help: make the implied reference patterns and variable binding modes explicit
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on these references with reference patterns and borrow explicitly using variable binding modes
    |
 LL |     let &mut &Struct { a: &[ref a], b: &mut [&[ref b]], ref c } = &mut &Struct { a: &[0], b: &mut [&[0]], c: 0 };
    |         ++++++                               + +++      +++
 
-error: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+error: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:180:13
    |
 LL |     let Foo(&ref a) = &Foo(&0);
-   |             ^ reference pattern not allowed under `ref` default binding mode
+   |             ^ reference pattern not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:180:9
    |
 LL |     let Foo(&ref a) = &Foo(&0);
-   |         ^^^^^^^^^^^ this matches on type `&_`
-help: make the implied reference pattern explicit
+   |         ^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &Foo(&ref a) = &Foo(&0);
    |         +
 
-error: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+error: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:186:10
    |
 LL |     let (&a, b, [c], [(d, [e])]) = &(&0, 0, &[0], &mut [&mut (0, &[0])]);
-   |          ^ reference pattern not allowed under `ref` default binding mode
+   |          ^ reference pattern not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:186:9
    |
 LL |     let (&a, b, [c], [(d, [e])]) = &(&0, 0, &[0], &mut [&mut (0, &[0])]);
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^ this matches on type `&_`
-help: make the implied reference patterns and variable binding modes explicit
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on these references with reference patterns and borrow explicitly using variable binding modes
    |
 LL |     let &(&a, ref b, &[ref c], &mut [&mut (ref d, &[ref e])]) = &(&0, 0, &[0], &mut [&mut (0, &[0])]);
    |         +     +++    + +++     ++++  ++++  +++    + +++
 
-error: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+error: cannot mutably bind by value within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:196:19
    |
 LL |     let (a, [b], [mut c]) = &(0, &mut [0], &[0]);
-   |                   ^^^ binding modifier not allowed under `ref` default binding mode
+   |                   ^^^ `mut` binding modifier not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:196:9
    |
 LL |     let (a, [b], [mut c]) = &(0, &mut [0], &[0]);
-   |         ^^^^^^^^^^^^^^^^^ this matches on type `&_`
-help: make the implied reference patterns and variable binding modes explicit
+   |         ^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on these references with reference patterns and borrow explicitly using variable binding modes
    |
 LL |     let &(ref a, &mut [ref b], &[mut c]) = &(0, &mut [0], &[0]);
    |         + +++    ++++  +++     +
 
-error: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+error: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:204:10
    |
 LL |     let (&a, (b, &[ref c])) = &(&0, &mut (0, &[0]));
-   |          ^       ^ reference pattern not allowed under `ref` default binding mode
+   |          ^       ^ reference pattern not allowed when implicitly borrowing
    |          |
-   |          reference pattern not allowed under `ref` default binding mode
+   |          reference pattern not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:204:9
    |
 LL |     let (&a, (b, &[ref c])) = &(&0, &mut (0, &[0]));
-   |         ^^^^^^^^^^^^^^^^^^^ this matches on type `&_`
-help: make the implied reference patterns and variable binding mode explicit
+   |         ^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on these references with reference patterns and borrow explicitly using a variable binding mode
    |
 LL |     let &(&a, &mut (ref b, &[ref c])) = &(&0, &mut (0, &[0]));
    |         +     ++++  +++
 
-error: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+error: cannot mutably bind by value within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:212:10
    |
 LL |     let [mut a @ b] = &[0];
-   |          ^^^ binding modifier not allowed under `ref` default binding mode
+   |          ^^^ `mut` binding modifier not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:212:9
    |
 LL |     let [mut a @ b] = &[0];
-   |         ^^^^^^^^^^^ this matches on type `&_`
-help: make the implied reference pattern and variable binding mode explicit
+   |         ^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on the reference with a reference pattern and borrow explicitly using a variable binding mode
    |
 LL |     let &[mut a @ ref b] = &[0];
    |         +         +++
 
-error: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
+error: cannot mutably bind by value within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:219:14
    |
 LL |     let [a @ mut b] = &[0];
-   |              ^^^ binding modifier not allowed under `ref` default binding mode
+   |              ^^^ `mut` binding modifier not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:219:9
    |
 LL |     let [a @ mut b] = &[0];
-   |         ^^^^^^^^^^^ this matches on type `&_`
-help: make the implied reference pattern and variable binding mode explicit
+   |         ^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on the reference with a reference pattern and borrow explicitly using a variable binding mode
    |
 LL |     let &[ref a @ mut b] = &[0];
    |         + +++
 
-error: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+error: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:226:14
    |
 LL |     let [Foo(&ref a @ ref b), Foo(&ref c @ d)] = [&Foo(&0); 2];
-   |              ^                    ^ reference pattern not allowed under `ref` default binding mode
+   |              ^                    ^ reference pattern not allowed when implicitly borrowing
    |              |
-   |              reference pattern not allowed under `ref` default binding mode
+   |              reference pattern not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:226:31
    |
 LL |     let [Foo(&ref a @ ref b), Foo(&ref c @ d)] = [&Foo(&0); 2];
-   |                               ^^^^^^^^^^^^^^^ this matches on type `&_`
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   |                               ^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:226:10
    |
 LL |     let [Foo(&ref a @ ref b), Foo(&ref c @ d)] = [&Foo(&0); 2];
-   |          ^^^^^^^^^^^^^^^^^^^ this matches on type `&_`
-help: make the implied reference patterns explicit
+   |          ^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on these references with reference patterns to avoid implicitly borrowing
    |
 LL |     let [&Foo(&ref a @ ref b), &Foo(&ref c @ d)] = [&Foo(&0); 2];
    |          +                     +
 
-error: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+error: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:235:14
    |
 LL |     let [Foo(&ref a @ [ref b]), Foo(&ref c @ [d])] = [&Foo(&[0]); 2];
-   |              ^                      ^ reference pattern not allowed under `ref` default binding mode
+   |              ^                      ^ reference pattern not allowed when implicitly borrowing
    |              |
-   |              reference pattern not allowed under `ref` default binding mode
+   |              reference pattern not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:235:33
    |
 LL |     let [Foo(&ref a @ [ref b]), Foo(&ref c @ [d])] = [&Foo(&[0]); 2];
-   |                                 ^^^^^^^^^^^^^^^^^ this matches on type `&_`
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   |                                 ^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:235:10
    |
 LL |     let [Foo(&ref a @ [ref b]), Foo(&ref c @ [d])] = [&Foo(&[0]); 2];
-   |          ^^^^^^^^^^^^^^^^^^^^^ this matches on type `&_`
-help: make the implied reference patterns explicit
+   |          ^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on these references with reference patterns to avoid implicitly borrowing
    |
 LL |     let [&Foo(&ref a @ [ref b]), &Foo(&ref c @ [d])] = [&Foo(&[0]); 2];
    |          +                       +
 
-error: binding modifiers may only be written when the default binding mode is `move`
+error: cannot explicitly borrow within an implicitly-borrowing pattern
   --> $DIR/migration_lint.rs:244:10
    |
 LL |     let [migration_lint_macros::bind_ref!(a)] = &[0];
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ occurs within macro expansion
    |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:244:9
    |
 LL |     let [migration_lint_macros::bind_ref!(a)] = &[0];
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this matches on type `&_`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
    = note: this error originates in the macro `migration_lint_macros::bind_ref` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: make the implied reference pattern explicit
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &[migration_lint_macros::bind_ref!(a)] = &[0];
    |         +
 
-error: reference patterns may only be written when the default binding mode is `move` in Rust 2024
+error: cannot explicitly dereference within an implicitly-borrowing pattern in Rust 2024
   --> $DIR/migration_lint.rs:249:10
    |
 LL |     let [&migration_lint_macros::bind_ref!(a)] = &[&0];
-   |          ^ reference pattern not allowed under `ref` default binding mode
+   |          ^ reference pattern not allowed when implicitly borrowing
    |
    = warning: this changes meaning in Rust 2024
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/migration_lint.rs:249:9
    |
 LL |     let [&migration_lint_macros::bind_ref!(a)] = &[&0];
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this matches on type `&_`
-help: make the implied reference pattern explicit
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |     let &[&migration_lint_macros::bind_ref!(a)] = &[&0];
    |         +
 
-error: aborting due to 31 previous errors
+error: cannot write explicit binding modifiers within an implicitly-borrowing pattern in Rust 2024
+  --> $DIR/migration_lint.rs:255:10
+   |
+LL |     let (mut a, ref b) = &(0, 0);
+   |          ^^^    ^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
+   |          |
+   |          `mut` binding modifier not allowed when implicitly borrowing
+   |
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
+  --> $DIR/migration_lint.rs:255:9
+   |
+LL |     let (mut a, ref b) = &(0, 0);
+   |         ^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
+   |
+LL |     let &(mut a, ref b) = &(0, 0);
+   |         +
+
+error: cannot mutably bind by value or explicitly dereference within an implicitly-borrowing pattern in Rust 2024
+  --> $DIR/migration_lint.rs:261:10
+   |
+LL |     let (mut a, &b) = &(0, &0);
+   |          ^^^    ^ reference pattern not allowed when implicitly borrowing
+   |          |
+   |          `mut` binding modifier not allowed when implicitly borrowing
+   |
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
+  --> $DIR/migration_lint.rs:261:9
+   |
+LL |     let (mut a, &b) = &(0, &0);
+   |         ^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
+   |
+LL |     let &(mut a, &b) = &(0, &0);
+   |         +
+
+error: cannot write explicit binding modifiers or explicitly dereference within an implicitly-borrowing pattern in Rust 2024
+  --> $DIR/migration_lint.rs:267:10
+   |
+LL |     let (mut a, ref b, &c) = &(0, 0, &0);
+   |          ^^^    ^^^    ^ reference pattern not allowed when implicitly borrowing
+   |          |      |
+   |          |      explicit `ref` binding modifier not allowed when implicitly borrowing
+   |          `mut` binding modifier not allowed when implicitly borrowing
+   |
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
+  --> $DIR/migration_lint.rs:267:9
+   |
+LL |     let (mut a, ref b, &c) = &(0, 0, &0);
+   |         ^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
+   |
+LL |     let &(mut a, ref b, &c) = &(0, 0, &0);
+   |         +
+
+error: aborting due to 34 previous errors
 
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/min_match_ergonomics_fail.rs b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/min_match_ergonomics_fail.rs
index 4dc04d90aaf5e..d56b835ac5dfc 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/min_match_ergonomics_fail.rs
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/min_match_ergonomics_fail.rs
@@ -21,17 +21,17 @@ macro_rules! test_pat_on_type {
 }
 
 test_pat_on_type![(&x,): &(T,)]; //~ ERROR mismatched types
-test_pat_on_type![(&x,): &(&T,)]; //~ ERROR reference patterns may only be written when the default binding mode is `move`
+test_pat_on_type![(&x,): &(&T,)]; //~ ERROR cannot explicitly dereference within an implicitly-borrowing pattern
 test_pat_on_type![(&x,): &(&mut T,)]; //~ ERROR mismatched types
 test_pat_on_type![(&mut x,): &(&T,)]; //~ ERROR mismatched types
-test_pat_on_type![(&mut x,): &(&mut T,)]; //~ ERROR reference patterns may only be written when the default binding mode is `move`
+test_pat_on_type![(&mut x,): &(&mut T,)]; //~ ERROR cannot explicitly dereference within an implicitly-borrowing pattern
 test_pat_on_type![(&x,): &&mut &(T,)]; //~ ERROR mismatched types
 test_pat_on_type![Foo { f: (&x,) }: Foo]; //~ ERROR mismatched types
 test_pat_on_type![Foo { f: (&x,) }: &mut Foo]; //~ ERROR mismatched types
-test_pat_on_type![Foo { f: &(x,) }: &Foo]; //~ ERROR reference patterns may only be written when the default binding mode is `move`
-test_pat_on_type![(mut x,): &(T,)]; //~ ERROR binding modifiers may only be written when the default binding mode is `move`
-test_pat_on_type![(ref x,): &(T,)]; //~ ERROR binding modifiers may only be written when the default binding mode is `move`
-test_pat_on_type![(ref mut x,): &mut (T,)]; //~ ERROR binding modifiers may only be written when the default binding mode is `move`
+test_pat_on_type![Foo { f: &(x,) }: &Foo]; //~ ERROR cannot explicitly dereference within an implicitly-borrowing pattern
+test_pat_on_type![(mut x,): &(T,)]; //~ ERROR cannot mutably bind by value within an implicitly-borrowing pattern
+test_pat_on_type![(ref x,): &(T,)]; //~ ERROR cannot explicitly borrow within an implicitly-borrowing pattern
+test_pat_on_type![(ref mut x,): &mut (T,)]; //~ ERROR cannot explicitly borrow within an implicitly-borrowing pattern
 
 fn get<X>() -> X {
     unimplemented!()
@@ -40,6 +40,6 @@ fn get<X>() -> X {
 // Make sure this works even when the underlying type is inferred. This test passes on rust stable.
 fn infer<X: Copy>() -> X {
     match &get() {
-        (&x,) => x, //~ ERROR reference patterns may only be written when the default binding mode is `move`
+        (&x,) => x, //~ ERROR cannot explicitly dereference within an implicitly-borrowing pattern
     }
 }
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/min_match_ergonomics_fail.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/min_match_ergonomics_fail.stderr
index 0c6b2ff3a2f09..23f1557e56d39 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/min_match_ergonomics_fail.stderr
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/min_match_ergonomics_fail.stderr
@@ -99,123 +99,123 @@ LL - test_pat_on_type![Foo { f: (&x,) }: &mut Foo];
 LL + test_pat_on_type![Foo { f: (x,) }: &mut Foo];
    |
 
-error: reference patterns may only be written when the default binding mode is `move`
+error: cannot explicitly dereference within an implicitly-borrowing pattern
   --> $DIR/min_match_ergonomics_fail.rs:24:20
    |
 LL | test_pat_on_type![(&x,): &(&T,)];
-   |                    ^ reference pattern not allowed under `ref` default binding mode
+   |                    ^ reference pattern not allowed when implicitly borrowing
    |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/min_match_ergonomics_fail.rs:24:19
    |
 LL | test_pat_on_type![(&x,): &(&T,)];
-   |                   ^^^^^ this matches on type `&_`
-help: make the implied reference pattern explicit
+   |                   ^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL | test_pat_on_type![&(&x,): &(&T,)];
    |                   +
 
-error: reference patterns may only be written when the default binding mode is `move`
+error: cannot explicitly dereference within an implicitly-borrowing pattern
   --> $DIR/min_match_ergonomics_fail.rs:27:20
    |
 LL | test_pat_on_type![(&mut x,): &(&mut T,)];
-   |                    ^^^^ reference pattern not allowed under `ref` default binding mode
+   |                    ^^^^ reference pattern not allowed when implicitly borrowing
    |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/min_match_ergonomics_fail.rs:27:19
    |
 LL | test_pat_on_type![(&mut x,): &(&mut T,)];
-   |                   ^^^^^^^^^ this matches on type `&_`
-help: make the implied reference pattern explicit
+   |                   ^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL | test_pat_on_type![&(&mut x,): &(&mut T,)];
    |                   +
 
-error: reference patterns may only be written when the default binding mode is `move`
+error: cannot explicitly dereference within an implicitly-borrowing pattern
   --> $DIR/min_match_ergonomics_fail.rs:31:28
    |
 LL | test_pat_on_type![Foo { f: &(x,) }: &Foo];
-   |                            ^ reference pattern not allowed under `ref` default binding mode
+   |                            ^ reference pattern not allowed when implicitly borrowing
    |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/min_match_ergonomics_fail.rs:31:19
    |
 LL | test_pat_on_type![Foo { f: &(x,) }: &Foo];
-   |                   ^^^^^^^^^^^^^^^^ this matches on type `&_`
-help: make the implied reference pattern explicit
+   |                   ^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL | test_pat_on_type![&Foo { f: &(x,) }: &Foo];
    |                   +
 
-error: binding modifiers may only be written when the default binding mode is `move`
+error: cannot mutably bind by value within an implicitly-borrowing pattern
   --> $DIR/min_match_ergonomics_fail.rs:32:20
    |
 LL | test_pat_on_type![(mut x,): &(T,)];
-   |                    ^^^ binding modifier not allowed under `ref` default binding mode
+   |                    ^^^ `mut` binding modifier not allowed when implicitly borrowing
    |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/min_match_ergonomics_fail.rs:32:19
    |
 LL | test_pat_on_type![(mut x,): &(T,)];
-   |                   ^^^^^^^^ this matches on type `&_`
-help: make the implied reference pattern explicit
+   |                   ^^^^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL | test_pat_on_type![&(mut x,): &(T,)];
    |                   +
 
-error: binding modifiers may only be written when the default binding mode is `move`
+error: cannot explicitly borrow within an implicitly-borrowing pattern
   --> $DIR/min_match_ergonomics_fail.rs:33:20
    |
 LL | test_pat_on_type![(ref x,): &(T,)];
-   |                    ^^^ binding modifier not allowed under `ref` default binding mode
+   |                    ^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
    |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/min_match_ergonomics_fail.rs:33:19
    |
 LL | test_pat_on_type![(ref x,): &(T,)];
-   |                   ^^^^^^^^ this matches on type `&_`
+   |                   ^^^^^^^^ this non-reference pattern matches on a reference type `&_`
 help: remove the unnecessary binding modifier
    |
 LL - test_pat_on_type![(ref x,): &(T,)];
 LL + test_pat_on_type![(x,): &(T,)];
    |
 
-error: binding modifiers may only be written when the default binding mode is `move`
+error: cannot explicitly borrow within an implicitly-borrowing pattern
   --> $DIR/min_match_ergonomics_fail.rs:34:20
    |
 LL | test_pat_on_type![(ref mut x,): &mut (T,)];
-   |                    ^^^^^^^ binding modifier not allowed under `ref mut` default binding mode
+   |                    ^^^^^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
    |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/min_match_ergonomics_fail.rs:34:19
    |
 LL | test_pat_on_type![(ref mut x,): &mut (T,)];
-   |                   ^^^^^^^^^^^^ this matches on type `&mut _`
+   |                   ^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
 help: remove the unnecessary binding modifier
    |
 LL - test_pat_on_type![(ref mut x,): &mut (T,)];
 LL + test_pat_on_type![(x,): &mut (T,)];
    |
 
-error: reference patterns may only be written when the default binding mode is `move`
+error: cannot explicitly dereference within an implicitly-borrowing pattern
   --> $DIR/min_match_ergonomics_fail.rs:43:10
    |
 LL |         (&x,) => x,
-   |          ^ reference pattern not allowed under `ref` default binding mode
+   |          ^ reference pattern not allowed when implicitly borrowing
    |
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
-note: matching on a reference type with a non-reference pattern changes the default binding mode
+   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
+note: matching on a reference type with a non-reference pattern implicitly borrows the contents
   --> $DIR/min_match_ergonomics_fail.rs:43:9
    |
 LL |         (&x,) => x,
-   |         ^^^^^ this matches on type `&_`
-help: make the implied reference pattern explicit
+   |         ^^^^^ this non-reference pattern matches on a reference type `&_`
+help: match on the reference with a reference pattern to avoid implicitly borrowing
    |
 LL |         &(&x,) => x,
    |         +

From 594f9c6c4fc7dd747820c058b78bf5c1b4480734 Mon Sep 17 00:00:00 2001
From: Julien Cretin <cretin@google.com>
Date: Wed, 8 Oct 2025 11:29:20 +0200
Subject: [PATCH 1814/1889] Clarify how to remediate the panic_immediate_abort
 error

Users who build `core` for the sole purpose of enabling `panic_immediate_abort` might expect
"`panic_immediate_abort` is now a real panic strategy" to mean that setting `panic =
"immediate-abort"` in `Cargo.toml` or `-Cpanic=immediate-abort` in `RUSTFLAGS` to be sufficient for
migration. But this is not the case, `core` still needs to be built for those changes to take
effect.

See https://github.com/rust-lang/rust/issues/146974 for additional context.
---
 library/core/src/panicking.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/library/core/src/panicking.rs b/library/core/src/panicking.rs
index b5150837e6a94..448f4ffc3dae0 100644
--- a/library/core/src/panicking.rs
+++ b/library/core/src/panicking.rs
@@ -36,7 +36,8 @@ use crate::panic::{Location, PanicInfo};
 compile_error!(
     "panic_immediate_abort is now a real panic strategy! \
     Enable it with `panic = \"immediate-abort\"` in Cargo.toml, \
-    or with the compiler flags `-Zunstable-options -Cpanic=immediate-abort`"
+    or with the compiler flags `-Zunstable-options -Cpanic=immediate-abort`. \
+    In both cases, you still need to build core, e.g. with `-Zbuild-std`"
 );
 
 // First we define the two main entry points that all panics go through.

From b97bdcb0a03abe95db5cdb4ea685ee320ac8ef29 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 8 Oct 2025 17:39:21 +1100
Subject: [PATCH 1815/1889] Extract query-method inner functions to
 `query::inner`

---
 compiler/rustc_middle/src/query/inner.rs    | 78 ++++++++++++++++++++
 compiler/rustc_middle/src/query/mod.rs      |  5 +-
 compiler/rustc_middle/src/query/plumbing.rs | 82 +++------------------
 3 files changed, 90 insertions(+), 75 deletions(-)
 create mode 100644 compiler/rustc_middle/src/query/inner.rs

diff --git a/compiler/rustc_middle/src/query/inner.rs b/compiler/rustc_middle/src/query/inner.rs
new file mode 100644
index 0000000000000..6efe21bc89976
--- /dev/null
+++ b/compiler/rustc_middle/src/query/inner.rs
@@ -0,0 +1,78 @@
+//! Helper functions that serve as the immediate implementation of
+//! `tcx.$query(..)` and its variations.
+
+use rustc_query_system::query::{QueryCache, QueryMode, try_get_cached};
+use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span};
+
+use crate::query::IntoQueryParam;
+use crate::query::erase::{self, Erase, EraseType};
+use crate::ty::TyCtxt;
+
+/// Shared implementation of `tcx.$query(..)` and `tcx.at(span).$query(..)`
+/// for all queries.
+#[inline(always)]
+pub(crate) fn query_get_at<'tcx, Cache>(
+    tcx: TyCtxt<'tcx>,
+    execute_query: fn(TyCtxt<'tcx>, Span, Cache::Key, QueryMode) -> Option<Cache::Value>,
+    query_cache: &Cache,
+    span: Span,
+    key: Cache::Key,
+) -> Cache::Value
+where
+    Cache: QueryCache,
+{
+    let key = key.into_query_param();
+    match try_get_cached(tcx, query_cache, &key) {
+        Some(value) => value,
+        None => execute_query(tcx, span, key, QueryMode::Get).unwrap(),
+    }
+}
+
+/// Shared implementation of `tcx.ensure_ok().$query(..)` for most queries,
+/// and `tcx.ensure_done().$query(..)` for all queries.
+#[inline]
+pub(crate) fn query_ensure<'tcx, Cache>(
+    tcx: TyCtxt<'tcx>,
+    execute_query: fn(TyCtxt<'tcx>, Span, Cache::Key, QueryMode) -> Option<Cache::Value>,
+    query_cache: &Cache,
+    key: Cache::Key,
+    check_cache: bool,
+) where
+    Cache: QueryCache,
+{
+    let key = key.into_query_param();
+    if try_get_cached(tcx, query_cache, &key).is_none() {
+        execute_query(tcx, DUMMY_SP, key, QueryMode::Ensure { check_cache });
+    }
+}
+
+/// Shared implementation of `tcx.ensure_ok().$query(..)` for queries that
+/// have the `return_result_from_ensure_ok` modifier.
+#[inline]
+pub(crate) fn query_ensure_error_guaranteed<'tcx, Cache, T>(
+    tcx: TyCtxt<'tcx>,
+    execute_query: fn(TyCtxt<'tcx>, Span, Cache::Key, QueryMode) -> Option<Cache::Value>,
+    query_cache: &Cache,
+    key: Cache::Key,
+    check_cache: bool,
+) -> Result<(), ErrorGuaranteed>
+where
+    Cache: QueryCache<Value = Erase<Result<T, ErrorGuaranteed>>>,
+    Result<T, ErrorGuaranteed>: EraseType,
+{
+    let key = key.into_query_param();
+    if let Some(res) = try_get_cached(tcx, query_cache, &key) {
+        erase::restore(res).map(drop)
+    } else {
+        execute_query(tcx, DUMMY_SP, key, QueryMode::Ensure { check_cache })
+            .map(erase::restore)
+            .map(|res| res.map(drop))
+            // Either we actually executed the query, which means we got a full `Result`,
+            // or we can just assume the query succeeded, because it was green in the
+            // incremental cache. If it is green, that means that the previous compilation
+            // that wrote to the incremental cache compiles successfully. That is only
+            // possible if the cache entry was `Ok(())`, so we emit that here, without
+            // actually encoding the `Result` in the cache or loading it from there.
+            .unwrap_or(Ok(()))
+    }
+}
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 30c4b4369830d..4bac1e8406c14 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -121,9 +121,7 @@ use crate::mir::interpret::{
 };
 use crate::mir::mono::{CodegenUnit, CollectionMode, MonoItem, MonoItemPartitions};
 use crate::query::erase::{Erase, erase, restore};
-use crate::query::plumbing::{
-    CyclePlaceholder, DynamicQuery, query_ensure, query_ensure_error_guaranteed, query_get_at,
-};
+use crate::query::plumbing::{CyclePlaceholder, DynamicQuery};
 use crate::traits::query::{
     CanonicalAliasGoal, CanonicalDropckOutlivesGoal, CanonicalImpliedOutlivesBoundsGoal,
     CanonicalMethodAutoderefStepsGoal, CanonicalPredicateGoal, CanonicalTypeOpAscribeUserTypeGoal,
@@ -147,6 +145,7 @@ use crate::{dep_graph, mir, thir};
 
 mod arena_cached;
 pub mod erase;
+pub(crate) mod inner;
 mod keys;
 pub mod on_disk_cache;
 #[macro_use]
diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index 16cc81dacad4b..c2fc43b444b87 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -8,10 +8,9 @@ use rustc_query_system::HandleCycleError;
 use rustc_query_system::dep_graph::{DepNodeIndex, SerializedDepNodeIndex};
 pub(crate) use rustc_query_system::query::QueryJobId;
 use rustc_query_system::query::*;
-use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span};
+use rustc_span::{ErrorGuaranteed, Span};
 pub use sealed::IntoQueryParam;
 
-use super::erase::EraseType;
 use crate::dep_graph;
 use crate::dep_graph::DepKind;
 use crate::query::on_disk_cache::{CacheEncoder, EncodedDepNodeIndex, OnDiskCache};
@@ -167,78 +166,17 @@ impl<'tcx> TyCtxt<'tcx> {
     }
 }
 
-#[inline(always)]
-pub fn query_get_at<'tcx, Cache>(
-    tcx: TyCtxt<'tcx>,
-    execute_query: fn(TyCtxt<'tcx>, Span, Cache::Key, QueryMode) -> Option<Cache::Value>,
-    query_cache: &Cache,
-    span: Span,
-    key: Cache::Key,
-) -> Cache::Value
-where
-    Cache: QueryCache,
-{
-    let key = key.into_query_param();
-    match try_get_cached(tcx, query_cache, &key) {
-        Some(value) => value,
-        None => execute_query(tcx, span, key, QueryMode::Get).unwrap(),
-    }
-}
-
-#[inline]
-pub fn query_ensure<'tcx, Cache>(
-    tcx: TyCtxt<'tcx>,
-    execute_query: fn(TyCtxt<'tcx>, Span, Cache::Key, QueryMode) -> Option<Cache::Value>,
-    query_cache: &Cache,
-    key: Cache::Key,
-    check_cache: bool,
-) where
-    Cache: QueryCache,
-{
-    let key = key.into_query_param();
-    if try_get_cached(tcx, query_cache, &key).is_none() {
-        execute_query(tcx, DUMMY_SP, key, QueryMode::Ensure { check_cache });
-    }
-}
-
-#[inline]
-pub fn query_ensure_error_guaranteed<'tcx, Cache, T>(
-    tcx: TyCtxt<'tcx>,
-    execute_query: fn(TyCtxt<'tcx>, Span, Cache::Key, QueryMode) -> Option<Cache::Value>,
-    query_cache: &Cache,
-    key: Cache::Key,
-    check_cache: bool,
-) -> Result<(), ErrorGuaranteed>
-where
-    Cache: QueryCache<Value = super::erase::Erase<Result<T, ErrorGuaranteed>>>,
-    Result<T, ErrorGuaranteed>: EraseType,
-{
-    let key = key.into_query_param();
-    if let Some(res) = try_get_cached(tcx, query_cache, &key) {
-        super::erase::restore(res).map(drop)
-    } else {
-        execute_query(tcx, DUMMY_SP, key, QueryMode::Ensure { check_cache })
-            .map(super::erase::restore)
-            .map(|res| res.map(drop))
-            // Either we actually executed the query, which means we got a full `Result`,
-            // or we can just assume the query succeeded, because it was green in the
-            // incremental cache. If it is green, that means that the previous compilation
-            // that wrote to the incremental cache compiles successfully. That is only
-            // possible if the cache entry was `Ok(())`, so we emit that here, without
-            // actually encoding the `Result` in the cache or loading it from there.
-            .unwrap_or(Ok(()))
-    }
-}
-
-macro_rules! query_ensure {
+/// Calls either `query_ensure` or `query_ensure_error_guaranteed`, depending
+/// on whether the list of modifiers contains `return_result_from_ensure_ok`.
+macro_rules! query_ensure_select {
     ([]$($args:tt)*) => {
-        query_ensure($($args)*)
+        crate::query::inner::query_ensure($($args)*)
     };
     ([(return_result_from_ensure_ok) $($rest:tt)*]$($args:tt)*) => {
-        query_ensure_error_guaranteed($($args)*).map(|_| ())
+        crate::query::inner::query_ensure_error_guaranteed($($args)*)
     };
     ([$other:tt $($modifiers:tt)*]$($args:tt)*) => {
-        query_ensure!([$($modifiers)*]$($args)*)
+        query_ensure_select!([$($modifiers)*]$($args)*)
     };
 }
 
@@ -434,7 +372,7 @@ macro_rules! define_callbacks {
                 self,
                 key: query_helper_param_ty!($($K)*),
             ) -> ensure_ok_result!([$($modifiers)*]) {
-                query_ensure!(
+                query_ensure_select!(
                     [$($modifiers)*]
                     self.tcx,
                     self.tcx.query_system.fns.engine.$name,
@@ -449,7 +387,7 @@ macro_rules! define_callbacks {
             $($(#[$attr])*
             #[inline(always)]
             pub fn $name(self, key: query_helper_param_ty!($($K)*)) {
-                query_ensure(
+                crate::query::inner::query_ensure(
                     self.tcx,
                     self.tcx.query_system.fns.engine.$name,
                     &self.tcx.query_system.caches.$name,
@@ -474,7 +412,7 @@ macro_rules! define_callbacks {
             #[inline(always)]
             pub fn $name(self, key: query_helper_param_ty!($($K)*)) -> $V
             {
-                restore::<$V>(query_get_at(
+                restore::<$V>(crate::query::inner::query_get_at(
                     self.tcx,
                     self.tcx.query_system.fns.engine.$name,
                     &self.tcx.query_system.caches.$name,

From cb0c092c786acebe56b915344b82e53d06b0e1d4 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Mon, 6 Oct 2025 17:22:39 +1100
Subject: [PATCH 1816/1889] Prepare `define_feedable!` for code extraction

---
 compiler/rustc_middle/src/query/mod.rs      |  5 +----
 compiler/rustc_middle/src/query/plumbing.rs | 20 ++++++++++++--------
 2 files changed, 13 insertions(+), 12 deletions(-)

diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 4bac1e8406c14..a81c2530a3928 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -70,7 +70,6 @@ use std::sync::Arc;
 use rustc_abi::Align;
 use rustc_arena::TypedArena;
 use rustc_ast::expand::allocator::AllocatorKind;
-use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
 use rustc_data_structures::sorted_map::SortedMap;
 use rustc_data_structures::steal::Steal;
@@ -88,9 +87,7 @@ use rustc_index::IndexVec;
 use rustc_lint_defs::LintId;
 use rustc_macros::rustc_queries;
 use rustc_query_system::ich::StableHashingContext;
-use rustc_query_system::query::{
-    QueryCache, QueryMode, QueryStackDeferred, QueryState, try_get_cached,
-};
+use rustc_query_system::query::{QueryMode, QueryStackDeferred, QueryState};
 use rustc_session::Limits;
 use rustc_session::config::{EntryFnType, OptLevel, OutputFilenames, SymbolManglingVersion};
 use rustc_session::cstore::{
diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index c2fc43b444b87..cb8a15c029f4b 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -501,17 +501,22 @@ macro_rules! define_feedable {
             $(#[$attr])*
             #[inline(always)]
             pub fn $name(self, value: queries::$name::ProvidedValue<'tcx>) {
+                #![allow(unused_imports)] // Removed later in this PR.
+                use rustc_data_structures::fingerprint::Fingerprint;
+                use rustc_query_system::query::{QueryCache, try_get_cached};
+
                 let key = self.key().into_query_param();
 
                 let tcx = self.tcx;
                 let erased = queries::$name::provided_to_erased(tcx, value);
-                let value = restore::<$V>(erased);
+                let value = erase::restore::<$V>(erased);
                 let cache = &tcx.query_system.caches.$name;
 
+                let dep_kind: dep_graph::DepKind = dep_graph::dep_kinds::$name;
                 let hasher: Option<fn(&mut StableHashingContext<'_>, &_) -> _> = hash_result!([$($modifiers)*]);
                 match try_get_cached(tcx, cache, &key) {
                     Some(old) => {
-                        let old = restore::<$V>(old);
+                        let old = erase::restore::<$V>(old);
                         if let Some(hasher) = hasher {
                             let (value_hash, old_hash): (Fingerprint, Fingerprint) = tcx.with_stable_hashing_context(|mut hcx|
                                 (hasher(&mut hcx, &value), hasher(&mut hcx, &old))
@@ -521,9 +526,8 @@ macro_rules! define_feedable {
                                 // results is tainted by errors. In this case, delay a bug to
                                 // ensure compilation is doomed, and keep the `old` value.
                                 tcx.dcx().delayed_bug(format!(
-                                    "Trying to feed an already recorded value for query {} key={key:?}:\n\
+                                    "Trying to feed an already recorded value for query {dep_kind:?} key={key:?}:\n\
                                     old value: {old:?}\nnew value: {value:?}",
-                                    stringify!($name),
                                 ));
                             }
                         } else {
@@ -531,18 +535,18 @@ macro_rules! define_feedable {
                             // If feeding the same value multiple times needs to be supported,
                             // the query should not be marked `no_hash`.
                             bug!(
-                                "Trying to feed an already recorded value for query {} key={key:?}:\nold value: {old:?}\nnew value: {value:?}",
-                                stringify!($name),
+                                "Trying to feed an already recorded value for query {dep_kind:?} key={key:?}:\n\
+                                old value: {old:?}\nnew value: {value:?}",
                             )
                         }
                     }
                     None => {
-                        let dep_node = dep_graph::DepNode::construct(tcx, dep_graph::dep_kinds::$name, &key);
+                        let dep_node = dep_graph::DepNode::construct(tcx, dep_kind, &key);
                         let dep_node_index = tcx.dep_graph.with_feed_task(
                             dep_node,
                             tcx,
                             &value,
-                            hash_result!([$($modifiers)*]),
+                            hasher,
                         );
                         cache.complete(key, erased, dep_node_index);
                     }

From a282336c5ca01d1be21ee21f7fb872341a36a65b Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Mon, 6 Oct 2025 16:07:09 +1100
Subject: [PATCH 1817/1889] Extract most code from `define_feedable!`

---
 compiler/rustc_middle/src/query/inner.rs    | 56 +++++++++++++++++++++
 compiler/rustc_middle/src/query/plumbing.rs | 51 ++++---------------
 2 files changed, 65 insertions(+), 42 deletions(-)

diff --git a/compiler/rustc_middle/src/query/inner.rs b/compiler/rustc_middle/src/query/inner.rs
index 6efe21bc89976..ee828ae55f7a3 100644
--- a/compiler/rustc_middle/src/query/inner.rs
+++ b/compiler/rustc_middle/src/query/inner.rs
@@ -1,9 +1,15 @@
 //! Helper functions that serve as the immediate implementation of
 //! `tcx.$query(..)` and its variations.
 
+use std::fmt::Debug;
+
+use rustc_data_structures::fingerprint::Fingerprint;
+use rustc_query_system::dep_graph::{DepKind, DepNodeParams};
+use rustc_query_system::ich::StableHashingContext;
 use rustc_query_system::query::{QueryCache, QueryMode, try_get_cached};
 use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span};
 
+use crate::dep_graph;
 use crate::query::IntoQueryParam;
 use crate::query::erase::{self, Erase, EraseType};
 use crate::ty::TyCtxt;
@@ -76,3 +82,53 @@ where
             .unwrap_or(Ok(()))
     }
 }
+
+/// Common implementation of query feeding, used by `define_feedable!`.
+pub(crate) fn query_feed<'tcx, Cache, Value>(
+    tcx: TyCtxt<'tcx>,
+    dep_kind: DepKind,
+    hasher: Option<fn(&mut StableHashingContext<'_>, &Value) -> Fingerprint>,
+    cache: &Cache,
+    key: Cache::Key,
+    erased: Erase<Value>,
+) where
+    Cache: QueryCache<Value = Erase<Value>>,
+    Cache::Key: DepNodeParams<TyCtxt<'tcx>>,
+    Value: EraseType + Debug,
+{
+    let value = erase::restore::<Value>(erased);
+
+    match try_get_cached(tcx, cache, &key) {
+        Some(old) => {
+            let old = erase::restore::<Value>(old);
+            if let Some(hasher) = hasher {
+                let (value_hash, old_hash): (Fingerprint, Fingerprint) = tcx
+                    .with_stable_hashing_context(|mut hcx| {
+                        (hasher(&mut hcx, &value), hasher(&mut hcx, &old))
+                    });
+                if old_hash != value_hash {
+                    // We have an inconsistency. This can happen if one of the two
+                    // results is tainted by errors. In this case, delay a bug to
+                    // ensure compilation is doomed, and keep the `old` value.
+                    tcx.dcx().delayed_bug(format!(
+                        "Trying to feed an already recorded value for query {dep_kind:?} key={key:?}:\n\
+                        old value: {old:?}\nnew value: {value:?}",
+                    ));
+                }
+            } else {
+                // The query is `no_hash`, so we have no way to perform a sanity check.
+                // If feeding the same value multiple times needs to be supported,
+                // the query should not be marked `no_hash`.
+                bug!(
+                    "Trying to feed an already recorded value for query {dep_kind:?} key={key:?}:\n\
+                    old value: {old:?}\nnew value: {value:?}",
+                )
+            }
+        }
+        None => {
+            let dep_node = dep_graph::DepNode::construct(tcx, dep_kind, &key);
+            let dep_node_index = tcx.dep_graph.with_feed_task(dep_node, tcx, &value, hasher);
+            cache.complete(key, erased, dep_node_index);
+        }
+    }
+}
diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index cb8a15c029f4b..8d01d9482ed4b 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -501,56 +501,23 @@ macro_rules! define_feedable {
             $(#[$attr])*
             #[inline(always)]
             pub fn $name(self, value: queries::$name::ProvidedValue<'tcx>) {
-                #![allow(unused_imports)] // Removed later in this PR.
-                use rustc_data_structures::fingerprint::Fingerprint;
-                use rustc_query_system::query::{QueryCache, try_get_cached};
-
                 let key = self.key().into_query_param();
 
                 let tcx = self.tcx;
                 let erased = queries::$name::provided_to_erased(tcx, value);
-                let value = erase::restore::<$V>(erased);
                 let cache = &tcx.query_system.caches.$name;
 
                 let dep_kind: dep_graph::DepKind = dep_graph::dep_kinds::$name;
                 let hasher: Option<fn(&mut StableHashingContext<'_>, &_) -> _> = hash_result!([$($modifiers)*]);
-                match try_get_cached(tcx, cache, &key) {
-                    Some(old) => {
-                        let old = erase::restore::<$V>(old);
-                        if let Some(hasher) = hasher {
-                            let (value_hash, old_hash): (Fingerprint, Fingerprint) = tcx.with_stable_hashing_context(|mut hcx|
-                                (hasher(&mut hcx, &value), hasher(&mut hcx, &old))
-                            );
-                            if old_hash != value_hash {
-                                // We have an inconsistency. This can happen if one of the two
-                                // results is tainted by errors. In this case, delay a bug to
-                                // ensure compilation is doomed, and keep the `old` value.
-                                tcx.dcx().delayed_bug(format!(
-                                    "Trying to feed an already recorded value for query {dep_kind:?} key={key:?}:\n\
-                                    old value: {old:?}\nnew value: {value:?}",
-                                ));
-                            }
-                        } else {
-                            // The query is `no_hash`, so we have no way to perform a sanity check.
-                            // If feeding the same value multiple times needs to be supported,
-                            // the query should not be marked `no_hash`.
-                            bug!(
-                                "Trying to feed an already recorded value for query {dep_kind:?} key={key:?}:\n\
-                                old value: {old:?}\nnew value: {value:?}",
-                            )
-                        }
-                    }
-                    None => {
-                        let dep_node = dep_graph::DepNode::construct(tcx, dep_kind, &key);
-                        let dep_node_index = tcx.dep_graph.with_feed_task(
-                            dep_node,
-                            tcx,
-                            &value,
-                            hasher,
-                        );
-                        cache.complete(key, erased, dep_node_index);
-                    }
-                }
+
+                $crate::query::inner::query_feed(
+                    tcx,
+                    dep_kind,
+                    hasher,
+                    cache,
+                    key,
+                    erased,
+                );
             }
         })*
     }

From 2c1e796ed0ac8af3441869a2b1458d9bcf566b61 Mon Sep 17 00:00:00 2001
From: James Barford-Evans <james.barford-evans@arm.com>
Date: Wed, 8 Oct 2025 09:45:10 +0100
Subject: [PATCH 1818/1889] Improve missing create level error message

---
 src/librustdoc/core.rs                                | 3 +++
 tests/rustdoc-ui/lints/check.rs                       | 4 +---
 tests/rustdoc-ui/lints/check.stderr                   | 9 +++++++++
 tests/rustdoc-ui/lints/no-crate-level-doc-lint.rs     | 4 +---
 tests/rustdoc-ui/lints/no-crate-level-doc-lint.stderr | 6 ++++++
 5 files changed, 20 insertions(+), 6 deletions(-)

diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs
index b8aaafcb517a9..0d4e24538e0d5 100644
--- a/src/librustdoc/core.rs
+++ b/src/librustdoc/core.rs
@@ -407,6 +407,9 @@ pub(crate) fn run_global_ctxt(
             crate::lint::MISSING_CRATE_LEVEL_DOCS,
             DocContext::as_local_hir_id(tcx, krate.module.item_id).unwrap(),
             |lint| {
+                if let Some(local_def_id) = krate.module.item_id.as_local_def_id() {
+                    lint.span(tcx.def_span(local_def_id));
+                }
                 lint.primary_message("no documentation found for this crate's top-level module");
                 lint.help(help);
             },
diff --git a/tests/rustdoc-ui/lints/check.rs b/tests/rustdoc-ui/lints/check.rs
index 0943f9f6053e9..9a4cc96094108 100644
--- a/tests/rustdoc-ui/lints/check.rs
+++ b/tests/rustdoc-ui/lints/check.rs
@@ -2,7 +2,7 @@
 //@ compile-flags: -Z unstable-options --check
 //@ normalize-stderr: "nightly|beta|1\.[0-9][0-9]\.[0-9]" -> "$$CHANNEL"
 
-#![feature(rustdoc_missing_doc_code_examples)]
+#![feature(rustdoc_missing_doc_code_examples)] //~ WARN no documentation found for this crate's top-level module
 //~^ WARN
 
 #![warn(missing_docs)]
@@ -12,5 +12,3 @@
 pub fn foo() {}
 //~^ WARN
 //~^^ WARN
-
-//~? WARN no documentation found for this crate's top-level module
diff --git a/tests/rustdoc-ui/lints/check.stderr b/tests/rustdoc-ui/lints/check.stderr
index dcdf25dda649c..52c8c176084a2 100644
--- a/tests/rustdoc-ui/lints/check.stderr
+++ b/tests/rustdoc-ui/lints/check.stderr
@@ -22,6 +22,15 @@ LL | pub fn foo() {}
    | ^^^^^^^^^^^^
 
 warning: no documentation found for this crate's top-level module
+  --> $DIR/check.rs:5:1
+   |
+LL | / #![feature(rustdoc_missing_doc_code_examples)]
+LL | |
+LL | |
+LL | | #![warn(missing_docs)]
+...  |
+LL | | pub fn foo() {}
+   | |_______________^
    |
    = help: The following guide may be of use:
            https://doc.rust-lang.org/$CHANNEL/rustdoc/how-to-write-documentation.html
diff --git a/tests/rustdoc-ui/lints/no-crate-level-doc-lint.rs b/tests/rustdoc-ui/lints/no-crate-level-doc-lint.rs
index 5e7dc377f5d53..0402fa5241cc9 100644
--- a/tests/rustdoc-ui/lints/no-crate-level-doc-lint.rs
+++ b/tests/rustdoc-ui/lints/no-crate-level-doc-lint.rs
@@ -1,7 +1,5 @@
 //@ normalize-stderr: "nightly|beta|1\.[0-9][0-9]\.[0-9]" -> "$$CHANNEL"
-#![deny(rustdoc::missing_crate_level_docs)]
+#![deny(rustdoc::missing_crate_level_docs)] //~ ERROR no documentation found for this crate's top-level module
 //^~ NOTE defined here
 
 pub fn foo() {}
-
-//~? ERROR no documentation found for this crate's top-level module
diff --git a/tests/rustdoc-ui/lints/no-crate-level-doc-lint.stderr b/tests/rustdoc-ui/lints/no-crate-level-doc-lint.stderr
index 721d3662c93ba..8d2b9b4fc8e81 100644
--- a/tests/rustdoc-ui/lints/no-crate-level-doc-lint.stderr
+++ b/tests/rustdoc-ui/lints/no-crate-level-doc-lint.stderr
@@ -1,4 +1,10 @@
 error: no documentation found for this crate's top-level module
+  --> $DIR/no-crate-level-doc-lint.rs:2:1
+   |
+LL | / #![deny(rustdoc::missing_crate_level_docs)]
+...  |
+LL | | pub fn foo() {}
+   | |_______________^
    |
    = help: The following guide may be of use:
            https://doc.rust-lang.org/$CHANNEL/rustdoc/how-to-write-documentation.html

From f62be66e9447bcf00064af4c8f42d789cc5e9782 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Wed, 8 Oct 2025 01:07:26 +0200
Subject: [PATCH 1819/1889] cmse: additional `impl Trait` tests

---
 .../src/hir_ty_lowering/cmse.rs               |  2 +-
 .../cmse-nonsecure-call/generics.rs           |  7 ++-
 .../cmse-nonsecure-call/generics.stderr       | 34 ++++++++----
 .../cmse-nonsecure-entry/generics.rs          | 28 +++++++---
 .../cmse-nonsecure-entry/generics.stderr      | 54 +++++++++++++------
 5 files changed, 88 insertions(+), 37 deletions(-)

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 91d1f89b74477..857d04593c277 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
@@ -216,7 +216,7 @@ fn should_emit_generic_error<'tcx>(abi: ExternAbi, layout_err: &'tcx LayoutError
             match abi {
                 ExternAbi::CmseNonSecureCall => {
                     // prevent double reporting of this error
-                    !ty.is_impl_trait()
+                    !ty.has_opaque_types()
                 }
                 ExternAbi::CmseNonSecureEntry => true,
                 _ => bug!("invalid ABI: {abi}"),
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.rs b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.rs
index 2dc540675e2e6..72efd05814325 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.rs
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.rs
@@ -17,8 +17,11 @@ struct Test<T: Copy> {
     f2: extern "cmse-nonsecure-call" fn(impl Copy, u32, u32, u32) -> impl Copy,
     //~^ ERROR `impl Trait` is not allowed in `fn` pointer parameters
     //~| ERROR `impl Trait` is not allowed in `fn` pointer return types
-    f3: extern "cmse-nonsecure-call" fn(T, u32, u32, u32) -> u64, //~ ERROR [E0798]
-    f4: extern "cmse-nonsecure-call" fn(Wrapper<T>, u32, u32, u32) -> u64, //~ ERROR [E0798]
+    f3: extern "cmse-nonsecure-call" fn((impl Copy, u32), u32, u32, u32) -> (impl Copy, u32),
+    //~^ ERROR `impl Trait` is not allowed in `fn` pointer parameters
+    //~| ERROR `impl Trait` is not allowed in `fn` pointer return types
+    f4: extern "cmse-nonsecure-call" fn(T, u32, u32, u32) -> u64, //~ ERROR [E0798]
+    f5: extern "cmse-nonsecure-call" fn(Wrapper<T>, u32, u32, u32) -> u64, //~ ERROR [E0798]
 }
 
 type WithReference = extern "cmse-nonsecure-call" fn(&usize);
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.stderr
index 750dbf8d5707c..d3ef87394be6c 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.stderr
@@ -38,20 +38,36 @@ LL |     f2: extern "cmse-nonsecure-call" fn(impl Copy, u32, u32, u32) -> impl C
    |
    = note: `impl Trait` is only allowed in arguments and return types of functions and methods
 
+error[E0562]: `impl Trait` is not allowed in `fn` pointer parameters
+  --> $DIR/generics.rs:20:42
+   |
+LL |     f3: extern "cmse-nonsecure-call" fn((impl Copy, u32), u32, u32, u32) -> (impl Copy, u32),
+   |                                          ^^^^^^^^^
+   |
+   = note: `impl Trait` is only allowed in arguments and return types of functions and methods
+
+error[E0562]: `impl Trait` is not allowed in `fn` pointer return types
+  --> $DIR/generics.rs:20:78
+   |
+LL |     f3: extern "cmse-nonsecure-call" fn((impl Copy, u32), u32, u32, u32) -> (impl Copy, u32),
+   |                                                                              ^^^^^^^^^
+   |
+   = note: `impl Trait` is only allowed in arguments and return types of functions and methods
+
 error[E0798]: function pointers with the `"cmse-nonsecure-call"` ABI cannot contain generics in their type
-  --> $DIR/generics.rs:20:9
+  --> $DIR/generics.rs:23:9
    |
-LL |     f3: extern "cmse-nonsecure-call" fn(T, u32, u32, u32) -> u64,
+LL |     f4: extern "cmse-nonsecure-call" fn(T, u32, u32, u32) -> u64,
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0798]: function pointers with the `"cmse-nonsecure-call"` ABI cannot contain generics in their type
-  --> $DIR/generics.rs:21:9
+  --> $DIR/generics.rs:24:9
    |
-LL |     f4: extern "cmse-nonsecure-call" fn(Wrapper<T>, u32, u32, u32) -> u64,
+LL |     f5: extern "cmse-nonsecure-call" fn(Wrapper<T>, u32, u32, u32) -> u64,
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/generics.rs:27:71
+  --> $DIR/generics.rs:30:71
    |
 LL | type WithTraitObject = extern "cmse-nonsecure-call" fn(&dyn Trait) -> &dyn Trait;
    |                                                                       ^^^^^^^^^^ this type doesn't fit in the available registers
@@ -60,7 +76,7 @@ LL | type WithTraitObject = extern "cmse-nonsecure-call" fn(&dyn Trait) -> &dyn
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/generics.rs:31:60
+  --> $DIR/generics.rs:34:60
    |
 LL |     extern "cmse-nonsecure-call" fn(&'static dyn Trait) -> &'static dyn Trait;
    |                                                            ^^^^^^^^^^^^^^^^^^ this type doesn't fit in the available registers
@@ -69,7 +85,7 @@ LL |     extern "cmse-nonsecure-call" fn(&'static dyn Trait) -> &'static dyn Tra
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/generics.rs:38:60
+  --> $DIR/generics.rs:41:60
    |
 LL |     extern "cmse-nonsecure-call" fn(WrapperTransparent) -> WrapperTransparent;
    |                                                            ^^^^^^^^^^^^^^^^^^ this type doesn't fit in the available registers
@@ -78,12 +94,12 @@ LL |     extern "cmse-nonsecure-call" fn(WrapperTransparent) -> WrapperTranspare
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0045]: C-variadic functions with the "cmse-nonsecure-call" calling convention are not supported
-  --> $DIR/generics.rs:41:20
+  --> $DIR/generics.rs:44:20
    |
 LL | type WithVarArgs = extern "cmse-nonsecure-call" fn(u32, ...);
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ C-variadic function must have a compatible calling convention
 
-error: aborting due to 10 previous errors
+error: aborting due to 12 previous errors
 
 Some errors have detailed explanations: E0045, E0412, E0562, E0798.
 For more information about an error, try `rustc --explain E0045`.
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs
index 116f0fdc972fc..6f835538be9a3 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs
@@ -37,11 +37,6 @@ extern "cmse-nonsecure-entry" fn introduced_generic<U: Copy>(
     0
 }
 
-extern "cmse-nonsecure-entry" fn impl_trait(_: impl Copy, _: u32, _: u32, _: u32) -> u64 {
-    //~^ ERROR [E0798]
-    0
-}
-
 extern "cmse-nonsecure-entry" fn reference(x: &usize) -> usize {
     *x
 }
@@ -66,14 +61,31 @@ extern "cmse-nonsecure-entry" fn wrapped_trait_object(x: WrapperTransparent) ->
     x
 }
 
-extern "cmse-nonsecure-entry" fn return_impl_trait(_: impl Copy) -> impl Copy {
+extern "cmse-nonsecure-entry" fn impl_trait(_: impl Copy, _: u32, _: u32, _: u32) -> u64 {
+    //~^ ERROR [E0798]
+    0
+}
+
+extern "cmse-nonsecure-entry" fn return_impl_trait() -> impl Copy {
     //~^ ERROR functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
-    //~| ERROR functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
     0u128
 }
 
-extern "cmse-nonsecure-entry" fn return_impl_trait_nested(v: (impl Copy, i32)) -> (impl Copy, i32) {
+extern "cmse-nonsecure-entry" fn return_impl_trait_nested() -> (impl Copy, i32) {
+    //~^ ERROR functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
+    (0u128, 0i32)
+}
+
+extern "cmse-nonsecure-entry" fn identity_impl_trait(v: impl Copy) -> impl Copy {
+    //~^ ERROR functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
+    //~| ERROR functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
+    v
+}
+
+extern "cmse-nonsecure-entry" fn identity_impl_trait_nested(
     //~^ ERROR functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
     //~| ERROR functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
+    v: (impl Copy, i32),
+) -> (impl Copy, i32) {
     v
 }
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr
index 4158fef4553a4..2c46cd708960f 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr
@@ -11,36 +11,44 @@ LL | | ) -> u64 {
    | |________^
 
 error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
-  --> $DIR/generics.rs:40:1
+  --> $DIR/generics.rs:64:1
    |
 LL | extern "cmse-nonsecure-entry" fn impl_trait(_: impl Copy, _: u32, _: u32, _: u32) -> u64 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
-  --> $DIR/generics.rs:69:1
+  --> $DIR/generics.rs:79:1
    |
-LL | extern "cmse-nonsecure-entry" fn return_impl_trait(_: impl Copy) -> impl Copy {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | extern "cmse-nonsecure-entry" fn identity_impl_trait(v: impl Copy) -> impl Copy {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
-  --> $DIR/generics.rs:69:1
+  --> $DIR/generics.rs:79:1
    |
-LL | extern "cmse-nonsecure-entry" fn return_impl_trait(_: impl Copy) -> impl Copy {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | extern "cmse-nonsecure-entry" fn identity_impl_trait(v: impl Copy) -> impl Copy {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
-  --> $DIR/generics.rs:75:1
+  --> $DIR/generics.rs:85:1
    |
-LL | extern "cmse-nonsecure-entry" fn return_impl_trait_nested(v: (impl Copy, i32)) -> (impl Copy, i32) {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | / extern "cmse-nonsecure-entry" fn identity_impl_trait_nested(
+LL | |
+LL | |
+LL | |     v: (impl Copy, i32),
+LL | | ) -> (impl Copy, i32) {
+   | |_____________________^
 
 error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
-  --> $DIR/generics.rs:75:1
+  --> $DIR/generics.rs:85:1
    |
-LL | extern "cmse-nonsecure-entry" fn return_impl_trait_nested(v: (impl Copy, i32)) -> (impl Copy, i32) {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | / extern "cmse-nonsecure-entry" fn identity_impl_trait_nested(
+LL | |
+LL | |
+LL | |     v: (impl Copy, i32),
+LL | | ) -> (impl Copy, i32) {
+   | |_____________________^
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
@@ -63,7 +71,7 @@ LL | |     ) -> u64 {
    | |____________^
 
 error[E0798]: return value of `"cmse-nonsecure-entry"` function too large to pass via registers
-  --> $DIR/generics.rs:51:65
+  --> $DIR/generics.rs:46:65
    |
 LL | extern "cmse-nonsecure-entry" fn trait_object(x: &dyn Trait) -> &dyn Trait {
    |                                                                 ^^^^^^^^^^ this type doesn't fit in the available registers
@@ -72,7 +80,7 @@ LL | extern "cmse-nonsecure-entry" fn trait_object(x: &dyn Trait) -> &dyn Trait
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0798]: return value of `"cmse-nonsecure-entry"` function too large to pass via registers
-  --> $DIR/generics.rs:56:80
+  --> $DIR/generics.rs:51:80
    |
 LL | extern "cmse-nonsecure-entry" fn static_trait_object(x: &'static dyn Trait) -> &'static dyn Trait {
    |                                                                                ^^^^^^^^^^^^^^^^^^ this type doesn't fit in the available registers
@@ -81,7 +89,7 @@ LL | extern "cmse-nonsecure-entry" fn static_trait_object(x: &'static dyn Trait)
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0798]: return value of `"cmse-nonsecure-entry"` function too large to pass via registers
-  --> $DIR/generics.rs:64:81
+  --> $DIR/generics.rs:59:81
    |
 LL | extern "cmse-nonsecure-entry" fn wrapped_trait_object(x: WrapperTransparent) -> WrapperTransparent {
    |                                                                                 ^^^^^^^^^^^^^^^^^^ this type doesn't fit in the available registers
@@ -89,6 +97,18 @@ LL | extern "cmse-nonsecure-entry" fn wrapped_trait_object(x: WrapperTransparent
    = note: functions with the `"cmse-nonsecure-entry"` ABI must pass their result via the available return registers
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
-error: aborting due to 11 previous errors
+error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
+  --> $DIR/generics.rs:69:1
+   |
+LL | extern "cmse-nonsecure-entry" fn return_impl_trait() -> impl Copy {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
+  --> $DIR/generics.rs:74:1
+   |
+LL | extern "cmse-nonsecure-entry" fn return_impl_trait_nested() -> (impl Copy, i32) {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 13 previous errors
 
 For more information about this error, try `rustc --explain E0798`.

From 1aed495ed73205854deb7e2904b141faf86d5f50 Mon Sep 17 00:00:00 2001
From: AMS21 <ams21.github@gmail.com>
Date: Wed, 8 Oct 2025 10:43:16 +0200
Subject: [PATCH 1820/1889] refactor: replace `LLVMRustAtomicLoad/Store` with
 LLVM built-in functions

---
 compiler/rustc_codegen_llvm/src/builder.rs    | 19 +++------
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs   | 17 +-------
 .../rustc_llvm/llvm-wrapper/RustWrapper.cpp   | 41 -------------------
 3 files changed, 7 insertions(+), 70 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
index e65f3d292dbb8..9673f69906f7b 100644
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -639,13 +639,9 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         size: Size,
     ) -> &'ll Value {
         unsafe {
-            let load = llvm::LLVMRustBuildAtomicLoad(
-                self.llbuilder,
-                ty,
-                ptr,
-                UNNAMED,
-                AtomicOrdering::from_generic(order),
-            );
+            let load = llvm::LLVMBuildLoad2(self.llbuilder, ty, ptr, UNNAMED);
+            // Set atomic ordering
+            llvm::LLVMSetOrdering(load, AtomicOrdering::from_generic(order));
             // LLVM requires the alignment of atomic loads to be at least the size of the type.
             llvm::LLVMSetAlignment(load, size.bytes() as c_uint);
             load
@@ -872,12 +868,9 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         debug!("Store {:?} -> {:?}", val, ptr);
         assert_eq!(self.cx.type_kind(self.cx.val_ty(ptr)), TypeKind::Pointer);
         unsafe {
-            let store = llvm::LLVMRustBuildAtomicStore(
-                self.llbuilder,
-                val,
-                ptr,
-                AtomicOrdering::from_generic(order),
-            );
+            let store = llvm::LLVMBuildStore(self.llbuilder, val, ptr);
+            // Set atomic ordering
+            llvm::LLVMSetOrdering(store, AtomicOrdering::from_generic(order));
             // LLVM requires the alignment of atomic stores to be at least the size of the type.
             llvm::LLVMSetAlignment(store, size.bytes() as c_uint);
         }
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index c4b5cf413a725..7e62630f3f98f 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -1151,6 +1151,7 @@ unsafe extern "C" {
 
     // Operations on load/store instructions (only)
     pub(crate) fn LLVMSetVolatile(MemoryAccessInst: &Value, volatile: Bool);
+    pub(crate) fn LLVMSetOrdering(MemoryAccessInst: &Value, Ordering: AtomicOrdering);
 
     // Operations on phi nodes
     pub(crate) fn LLVMAddIncoming<'a>(
@@ -2090,22 +2091,6 @@ unsafe extern "C" {
         RHS: &'a Value,
     ) -> &'a Value;
 
-    // Atomic Operations
-    pub(crate) fn LLVMRustBuildAtomicLoad<'a>(
-        B: &Builder<'a>,
-        ElementType: &'a Type,
-        PointerVal: &'a Value,
-        Name: *const c_char,
-        Order: AtomicOrdering,
-    ) -> &'a Value;
-
-    pub(crate) fn LLVMRustBuildAtomicStore<'a>(
-        B: &Builder<'a>,
-        Val: &'a Value,
-        Ptr: &'a Value,
-        Order: AtomicOrdering,
-    ) -> &'a Value;
-
     pub(crate) fn LLVMRustTimeTraceProfilerInitialize();
 
     pub(crate) fn LLVMRustTimeTraceProfilerFinishThread();
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index e38474f09ff7a..38d677cfa3403 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -60,29 +60,6 @@ using namespace llvm::object;
 static_assert(dwarf::DW_OP_LLVM_fragment == 0x1000);
 static_assert(dwarf::DW_OP_stack_value == 0x9f);
 
-// LLVMAtomicOrdering is already an enum - don't create another
-// one.
-static AtomicOrdering fromRust(LLVMAtomicOrdering Ordering) {
-  switch (Ordering) {
-  case LLVMAtomicOrderingNotAtomic:
-    return AtomicOrdering::NotAtomic;
-  case LLVMAtomicOrderingUnordered:
-    return AtomicOrdering::Unordered;
-  case LLVMAtomicOrderingMonotonic:
-    return AtomicOrdering::Monotonic;
-  case LLVMAtomicOrderingAcquire:
-    return AtomicOrdering::Acquire;
-  case LLVMAtomicOrderingRelease:
-    return AtomicOrdering::Release;
-  case LLVMAtomicOrderingAcquireRelease:
-    return AtomicOrdering::AcquireRelease;
-  case LLVMAtomicOrderingSequentiallyConsistent:
-    return AtomicOrdering::SequentiallyConsistent;
-  }
-
-  report_fatal_error("Invalid LLVMAtomicOrdering value!");
-}
-
 static LLVM_THREAD_LOCAL char *LastError;
 
 // Custom error handler for fatal LLVM errors.
@@ -623,24 +600,6 @@ extern "C" void LLVMRustSetAllowReassoc(LLVMValueRef V) {
   }
 }
 
-extern "C" LLVMValueRef
-LLVMRustBuildAtomicLoad(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Source,
-                        const char *Name, LLVMAtomicOrdering Order) {
-  Value *Ptr = unwrap(Source);
-  LoadInst *LI = unwrap(B)->CreateLoad(unwrap(Ty), Ptr, Name);
-  LI->setAtomic(fromRust(Order));
-  return wrap(LI);
-}
-
-extern "C" LLVMValueRef LLVMRustBuildAtomicStore(LLVMBuilderRef B,
-                                                 LLVMValueRef V,
-                                                 LLVMValueRef Target,
-                                                 LLVMAtomicOrdering Order) {
-  StoreInst *SI = unwrap(B)->CreateStore(unwrap(V), unwrap(Target));
-  SI->setAtomic(fromRust(Order));
-  return wrap(SI);
-}
-
 extern "C" uint64_t LLVMRustGetArrayNumElements(LLVMTypeRef Ty) {
   return unwrap(Ty)->getArrayNumElements();
 }

From 5da52f57c59a5a269f747390769a4bd343b590e8 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Mon, 22 Sep 2025 01:04:40 +0000
Subject: [PATCH 1821/1889] Evaluate constants lazily in GVN.

---
 compiler/rustc_mir_transform/src/gvn.rs | 84 +++++++++++++------------
 1 file changed, 45 insertions(+), 39 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index bd8ea7dddad83..7ee31486a43e2 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -364,7 +364,10 @@ struct VnState<'body, 'a, 'tcx> {
     rev_locals: IndexVec<VnIndex, SmallVec<[Local; 1]>>,
     values: ValueSet<'a, 'tcx>,
     /// Values evaluated as constants if possible.
-    evaluated: IndexVec<VnIndex, Option<OpTy<'tcx>>>,
+    /// - `None` are values not computed yet;
+    /// - `Some(None)` are values for which computation has failed;
+    /// - `Some(Some(op))` are successful computations.
+    evaluated: IndexVec<VnIndex, Option<Option<&'a OpTy<'tcx>>>>,
     /// Cache the deref values.
     derefs: Vec<VnIndex>,
     ssa: &'body SsaLocals,
@@ -416,8 +419,7 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
         let (index, new) = self.values.insert(ty, value);
         if new {
             // Grow `evaluated` and `rev_locals` here to amortize the allocations.
-            let evaluated = self.eval_to_const(index);
-            let _index = self.evaluated.push(evaluated);
+            let _index = self.evaluated.push(None);
             debug_assert_eq!(index, _index);
             let _index = self.rev_locals.push(SmallVec::new());
             debug_assert_eq!(index, _index);
@@ -430,7 +432,7 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
     #[instrument(level = "trace", skip(self), ret)]
     fn new_opaque(&mut self, ty: Ty<'tcx>) -> VnIndex {
         let index = self.values.insert_unique(ty, Value::Opaque);
-        let _index = self.evaluated.push(None);
+        let _index = self.evaluated.push(Some(None));
         debug_assert_eq!(index, _index);
         let _index = self.rev_locals.push(SmallVec::new());
         debug_assert_eq!(index, _index);
@@ -468,8 +470,7 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
             kind,
             provenance,
         });
-        let evaluated = self.eval_to_const(index);
-        let _index = self.evaluated.push(evaluated);
+        let _index = self.evaluated.push(None);
         debug_assert_eq!(index, _index);
         let _index = self.rev_locals.push(SmallVec::new());
         debug_assert_eq!(index, _index);
@@ -493,8 +494,7 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
             (index, true)
         };
         if new {
-            let evaluated = self.eval_to_const(index);
-            let _index = self.evaluated.push(evaluated);
+            let _index = self.evaluated.push(None);
             debug_assert_eq!(index, _index);
             let _index = self.rev_locals.push(SmallVec::new());
             debug_assert_eq!(index, _index);
@@ -551,7 +551,7 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
     }
 
     #[instrument(level = "trace", skip(self), ret)]
-    fn eval_to_const(&mut self, value: VnIndex) -> Option<OpTy<'tcx>> {
+    fn eval_to_const_inner(&mut self, value: VnIndex) -> Option<OpTy<'tcx>> {
         use Value::*;
         let ty = self.ty(value);
         // Avoid computing layouts inside a coroutine, as that can cause cycles.
@@ -571,10 +571,8 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
                 self.ecx.eval_mir_constant(value, DUMMY_SP, None).discard_err()?
             }
             Aggregate(variant, ref fields) => {
-                let fields = fields
-                    .iter()
-                    .map(|&f| self.evaluated[f].as_ref())
-                    .collect::<Option<Vec<_>>>()?;
+                let fields =
+                    fields.iter().map(|&f| self.eval_to_const(f)).collect::<Option<Vec<_>>>()?;
                 let variant = if ty.ty.is_enum() { Some(variant) } else { None };
                 if matches!(ty.backend_repr, BackendRepr::Scalar(..) | BackendRepr::ScalarPair(..))
                 {
@@ -603,7 +601,7 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
                 }
             }
             Union(active_field, field) => {
-                let field = self.evaluated[field].as_ref()?;
+                let field = self.eval_to_const(field)?;
                 if matches!(ty.backend_repr, BackendRepr::Scalar(..) | BackendRepr::ScalarPair(..))
                 {
                     let dest = self.ecx.allocate(ty, MemoryKind::Stack).discard_err()?;
@@ -618,8 +616,8 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
                 }
             }
             RawPtr { pointer, metadata } => {
-                let pointer = self.evaluated[pointer].as_ref()?;
-                let metadata = self.evaluated[metadata].as_ref()?;
+                let pointer = self.eval_to_const(pointer)?;
+                let metadata = self.eval_to_const(metadata)?;
 
                 // Pointers don't have fields, so don't `project_field` them.
                 let data = self.ecx.read_pointer(pointer).discard_err()?;
@@ -633,7 +631,7 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
             }
 
             Projection(base, elem) => {
-                let base = self.evaluated[base].as_ref()?;
+                let base = self.eval_to_const(base)?;
                 // `Index` by constants should have been replaced by `ConstantIndex` by
                 // `simplify_place_projection`.
                 let elem = elem.try_map(|_| None, |()| ty.ty)?;
@@ -642,7 +640,7 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
             Address { base, projection, .. } => {
                 debug_assert!(!projection.contains(&ProjectionElem::Deref));
                 let pointer = match base {
-                    AddressBase::Deref(pointer) => self.evaluated[pointer].as_ref()?,
+                    AddressBase::Deref(pointer) => self.eval_to_const(pointer)?,
                     // We have no stack to point to.
                     AddressBase::Local(_) => return None,
                 };
@@ -658,7 +656,7 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
             }
 
             Discriminant(base) => {
-                let base = self.evaluated[base].as_ref()?;
+                let base = self.eval_to_const(base)?;
                 let variant = self.ecx.read_discriminant(base).discard_err()?;
                 let discr_value =
                     self.ecx.discriminant_for_variant(base.layout.ty, variant).discard_err()?;
@@ -675,7 +673,6 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
                     NullOp::SizeOf => arg_layout.size.bytes(),
                     NullOp::AlignOf => arg_layout.align.bytes(),
                     NullOp::OffsetOf(fields) => self
-                        .ecx
                         .tcx
                         .offset_of_subfield(self.typing_env(), arg_layout, fields.iter())
                         .bytes(),
@@ -685,34 +682,34 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
                 ImmTy::from_uint(val, ty).into()
             }
             UnaryOp(un_op, operand) => {
-                let operand = self.evaluated[operand].as_ref()?;
+                let operand = self.eval_to_const(operand)?;
                 let operand = self.ecx.read_immediate(operand).discard_err()?;
                 let val = self.ecx.unary_op(un_op, &operand).discard_err()?;
                 val.into()
             }
             BinaryOp(bin_op, lhs, rhs) => {
-                let lhs = self.evaluated[lhs].as_ref()?;
+                let lhs = self.eval_to_const(lhs)?;
+                let rhs = self.eval_to_const(rhs)?;
                 let lhs = self.ecx.read_immediate(lhs).discard_err()?;
-                let rhs = self.evaluated[rhs].as_ref()?;
                 let rhs = self.ecx.read_immediate(rhs).discard_err()?;
                 let val = self.ecx.binary_op(bin_op, &lhs, &rhs).discard_err()?;
                 val.into()
             }
             Cast { kind, value } => match kind {
                 CastKind::IntToInt | CastKind::IntToFloat => {
-                    let value = self.evaluated[value].as_ref()?;
+                    let value = self.eval_to_const(value)?;
                     let value = self.ecx.read_immediate(value).discard_err()?;
                     let res = self.ecx.int_to_int_or_float(&value, ty).discard_err()?;
                     res.into()
                 }
                 CastKind::FloatToFloat | CastKind::FloatToInt => {
-                    let value = self.evaluated[value].as_ref()?;
+                    let value = self.eval_to_const(value)?;
                     let value = self.ecx.read_immediate(value).discard_err()?;
                     let res = self.ecx.float_to_float_or_int(&value, ty).discard_err()?;
                     res.into()
                 }
                 CastKind::Transmute | CastKind::Subtype => {
-                    let value = self.evaluated[value].as_ref()?;
+                    let value = self.eval_to_const(value)?;
                     // `offset` for immediates generally only supports projections that match the
                     // type of the immediate. However, as a HACK, we exploit that it can also do
                     // limited transmutes: it only works between types with the same layout, and
@@ -724,12 +721,12 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
                                     && !matches!(s1.primitive(), Primitive::Pointer(..))
                             }
                             (BackendRepr::ScalarPair(a1, b1), BackendRepr::ScalarPair(a2, b2)) => {
-                                a1.size(&self.ecx) == a2.size(&self.ecx) &&
-                                b1.size(&self.ecx) == b2.size(&self.ecx) &&
-                                // The alignment of the second component determines its offset, so that also needs to match.
-                                b1.align(&self.ecx) == b2.align(&self.ecx) &&
-                                // None of the inputs may be a pointer.
-                                !matches!(a1.primitive(), Primitive::Pointer(..))
+                                a1.size(&self.ecx) == a2.size(&self.ecx)
+                                    && b1.size(&self.ecx) == b2.size(&self.ecx)
+                                    // The alignment of the second component determines its offset, so that also needs to match.
+                                    && b1.align(&self.ecx) == b2.align(&self.ecx)
+                                    // None of the inputs may be a pointer.
+                                    && !matches!(a1.primitive(), Primitive::Pointer(..))
                                     && !matches!(b1.primitive(), Primitive::Pointer(..))
                             }
                             _ => false,
@@ -741,7 +738,7 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
                     value.offset(Size::ZERO, ty, &self.ecx).discard_err()?
                 }
                 CastKind::PointerCoercion(ty::adjustment::PointerCoercion::Unsize, _) => {
-                    let src = self.evaluated[value].as_ref()?;
+                    let src = self.eval_to_const(value)?;
                     let dest = self.ecx.allocate(ty, MemoryKind::Stack).discard_err()?;
                     self.ecx.unsize_into(src, ty, &dest).discard_err()?;
                     self.ecx
@@ -750,13 +747,13 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
                     dest.into()
                 }
                 CastKind::FnPtrToPtr | CastKind::PtrToPtr => {
-                    let src = self.evaluated[value].as_ref()?;
+                    let src = self.eval_to_const(value)?;
                     let src = self.ecx.read_immediate(src).discard_err()?;
                     let ret = self.ecx.ptr_to_ptr(&src, ty).discard_err()?;
                     ret.into()
                 }
                 CastKind::PointerCoercion(ty::adjustment::PointerCoercion::UnsafeFnPointer, _) => {
-                    let src = self.evaluated[value].as_ref()?;
+                    let src = self.eval_to_const(value)?;
                     let src = self.ecx.read_immediate(src).discard_err()?;
                     ImmTy::from_immediate(*src, ty).into()
                 }
@@ -766,6 +763,15 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
         Some(op)
     }
 
+    fn eval_to_const(&mut self, index: VnIndex) -> Option<&'a OpTy<'tcx>> {
+        if let Some(op) = self.evaluated[index] {
+            return op;
+        }
+        let op = self.eval_to_const_inner(index);
+        self.evaluated[index] = Some(self.arena.alloc(op).as_ref());
+        self.evaluated[index].unwrap()
+    }
+
     /// Represent the *value* we obtain by dereferencing an `Address` value.
     #[instrument(level = "trace", skip(self), ret)]
     fn dereference_address(
@@ -901,7 +907,7 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
             if let ProjectionElem::Index(idx_local) = elem
                 && let Some(idx) = self.locals[idx_local]
             {
-                if let Some(offset) = self.evaluated[idx].as_ref()
+                if let Some(offset) = self.eval_to_const(idx)
                     && let Some(offset) = self.ecx.read_target_usize(offset).discard_err()
                     && let Some(min_length) = offset.checked_add(1)
                 {
@@ -1389,8 +1395,8 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
 
         let layout = self.ecx.layout_of(lhs_ty).ok()?;
 
-        let as_bits = |value: VnIndex| {
-            let constant = self.evaluated[value].as_ref()?;
+        let mut as_bits = |value: VnIndex| {
+            let constant = self.eval_to_const(value)?;
             if layout.backend_repr.is_scalar() {
                 let scalar = self.ecx.read_scalar(constant).discard_err()?;
                 scalar.to_bits(constant.layout.size).discard_err()
@@ -1790,7 +1796,7 @@ impl<'tcx> VnState<'_, '_, 'tcx> {
             return Some(ConstOperand { span: DUMMY_SP, user_ty: None, const_: value });
         }
 
-        let op = self.evaluated[index].as_ref()?;
+        let op = self.eval_to_const(index)?;
         if op.layout.is_unsized() {
             // Do not attempt to propagate unsized locals.
             return None;

From f4d8bd3b47d9b9fd695b894927b04b2bb711a475 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Wed, 8 Oct 2025 13:40:42 +0200
Subject: [PATCH 1822/1889] cmse: more accurate spans for excess parameters

Use the span of the types that don't fit, rather than the span of the
whole signature.
---
 compiler/rustc_hir_analysis/src/errors.rs     |  2 +-
 .../src/hir_ty_lowering/cmse.rs               | 89 ++++++++-----------
 .../params-via-stack.stderr                   |  6 +-
 .../params-via-stack.stderr                   |  4 +-
 4 files changed, 43 insertions(+), 58 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/errors.rs b/compiler/rustc_hir_analysis/src/errors.rs
index 3b6367219b7ff..db69653a27e9b 100644
--- a/compiler/rustc_hir_analysis/src/errors.rs
+++ b/compiler/rustc_hir_analysis/src/errors.rs
@@ -1616,7 +1616,7 @@ pub(crate) struct InvalidGenericReceiverTy<'tcx> {
 pub(crate) struct CmseInputsStackSpill {
     #[primary_span]
     #[label]
-    pub span: Span,
+    pub spans: Vec<Span>,
     pub plural: bool,
     pub abi: ExternAbi,
 }
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 857d04593c277..7e2938d1447ca 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
@@ -44,20 +44,8 @@ pub(crate) fn validate_cmse_abi<'tcx>(
                 return;
             };
 
-            match is_valid_cmse_inputs(tcx, fn_sig) {
-                Ok(Ok(())) => {}
-                Ok(Err(index)) => {
-                    // fn(x: u32, u32, u32, u16, y: u16) -> u32,
-                    //                           ^^^^^^
-                    let span = if let Some(ident) = fn_ptr_ty.param_idents[index] {
-                        ident.span.to(fn_ptr_ty.decl.inputs[index].span)
-                    } else {
-                        fn_ptr_ty.decl.inputs[index].span
-                    }
-                    .to(fn_ptr_ty.decl.inputs.last().unwrap().span);
-                    let plural = fn_ptr_ty.param_idents.len() - index != 1;
-                    dcx.emit_err(errors::CmseInputsStackSpill { span, plural, abi });
-                }
+            match is_valid_cmse_inputs(tcx, dcx, fn_sig, fn_ptr_ty.decl, abi) {
+                Ok(()) => {}
                 Err(layout_err) => {
                     if should_emit_generic_error(abi, layout_err) {
                         dcx.emit_err(errors::CmseCallGeneric { span: *fn_ptr_span });
@@ -65,18 +53,11 @@ pub(crate) fn validate_cmse_abi<'tcx>(
                 }
             }
 
-            match is_valid_cmse_output(tcx, fn_sig) {
-                Ok(true) => {}
-                Ok(false) => {
-                    let span = fn_ptr_ty.decl.output.span();
-                    dcx.emit_err(errors::CmseOutputStackSpill { span, abi });
-                }
-                Err(layout_err) => {
-                    if should_emit_generic_error(abi, layout_err) {
-                        dcx.emit_err(errors::CmseCallGeneric { span: *fn_ptr_span });
-                    }
+            if let Err(layout_err) = is_valid_cmse_output(tcx, dcx, fn_sig, fn_ptr_ty.decl, abi) {
+                if should_emit_generic_error(abi, layout_err) {
+                    dcx.emit_err(errors::CmseCallGeneric { span: *fn_ptr_span });
                 }
-            };
+            }
         }
         ExternAbi::CmseNonSecureEntry => {
             let hir_node = tcx.hir_node(hir_id);
@@ -91,15 +72,8 @@ pub(crate) fn validate_cmse_abi<'tcx>(
                 return;
             }
 
-            match is_valid_cmse_inputs(tcx, fn_sig) {
-                Ok(Ok(())) => {}
-                Ok(Err(index)) => {
-                    // fn f(x: u32, y: u32, z: u32, w: u16, q: u16) -> u32,
-                    //                                      ^^^^^^
-                    let span = decl.inputs[index].span.to(decl.inputs.last().unwrap().span);
-                    let plural = decl.inputs.len() - index != 1;
-                    dcx.emit_err(errors::CmseInputsStackSpill { span, plural, abi });
-                }
+            match is_valid_cmse_inputs(tcx, dcx, fn_sig, decl, abi) {
+                Ok(()) => {}
                 Err(layout_err) => {
                     if should_emit_generic_error(abi, layout_err) {
                         dcx.emit_err(errors::CmseEntryGeneric { span: *fn_sig_span });
@@ -107,18 +81,11 @@ pub(crate) fn validate_cmse_abi<'tcx>(
                 }
             }
 
-            match is_valid_cmse_output(tcx, fn_sig) {
-                Ok(true) => {}
-                Ok(false) => {
-                    let span = decl.output.span();
-                    dcx.emit_err(errors::CmseOutputStackSpill { span, abi });
-                }
-                Err(layout_err) => {
-                    if should_emit_generic_error(abi, layout_err) {
-                        dcx.emit_err(errors::CmseEntryGeneric { span: *fn_sig_span });
-                    }
+            if let Err(layout_err) = is_valid_cmse_output(tcx, dcx, fn_sig, decl, abi) {
+                if should_emit_generic_error(abi, layout_err) {
+                    dcx.emit_err(errors::CmseEntryGeneric { span: *fn_sig_span });
                 }
-            };
+            }
         }
         _ => (),
     }
@@ -127,16 +94,19 @@ pub(crate) fn validate_cmse_abi<'tcx>(
 /// Returns whether the inputs will fit into the available registers
 fn is_valid_cmse_inputs<'tcx>(
     tcx: TyCtxt<'tcx>,
+    dcx: DiagCtxtHandle<'_>,
     fn_sig: ty::PolyFnSig<'tcx>,
-) -> Result<Result<(), usize>, &'tcx LayoutError<'tcx>> {
-    let mut span = None;
+    fn_decl: &hir::FnDecl<'tcx>,
+    abi: ExternAbi,
+) -> Result<(), &'tcx LayoutError<'tcx>> {
     let mut accum = 0u64;
+    let mut excess_argument_spans = Vec::new();
 
     // this type is only used for layout computation, which does not rely on regions
     let fn_sig = tcx.instantiate_bound_regions_with_erased(fn_sig);
     let fn_sig = tcx.erase_and_anonymize_regions(fn_sig);
 
-    for (index, ty) in fn_sig.inputs().iter().enumerate() {
+    for (ty, hir_ty) in fn_sig.inputs().iter().zip(fn_decl.inputs) {
         let layout = tcx.layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(*ty))?;
 
         let align = layout.layout.align().bytes();
@@ -147,21 +117,28 @@ fn is_valid_cmse_inputs<'tcx>(
 
         // i.e. exceeds 4 32-bit registers
         if accum > 16 {
-            span = span.or(Some(index));
+            excess_argument_spans.push(hir_ty.span);
         }
     }
 
-    match span {
-        None => Ok(Ok(())),
-        Some(span) => Ok(Err(span)),
+    if !excess_argument_spans.is_empty() {
+        // fn f(x: u32, y: u32, z: u32, w: u16, q: u16) -> u32,
+        //                                      ^^^^^^
+        let plural = excess_argument_spans.len() != 1;
+        dcx.emit_err(errors::CmseInputsStackSpill { spans: excess_argument_spans, plural, abi });
     }
+
+    Ok(())
 }
 
 /// Returns whether the output will fit into the available registers
 fn is_valid_cmse_output<'tcx>(
     tcx: TyCtxt<'tcx>,
+    dcx: DiagCtxtHandle<'_>,
     fn_sig: ty::PolyFnSig<'tcx>,
-) -> Result<bool, &'tcx LayoutError<'tcx>> {
+    fn_decl: &hir::FnDecl<'tcx>,
+    abi: ExternAbi,
+) -> Result<(), &'tcx LayoutError<'tcx>> {
     // this type is only used for layout computation, which does not rely on regions
     let fn_sig = tcx.instantiate_bound_regions_with_erased(fn_sig);
     let fn_sig = tcx.erase_and_anonymize_regions(fn_sig);
@@ -183,7 +160,11 @@ fn is_valid_cmse_output<'tcx>(
     let typing_env = ty::TypingEnv::fully_monomorphized();
     let layout = tcx.layout_of(typing_env.as_query_input(return_type))?;
 
-    Ok(is_valid_cmse_output_layout(layout))
+    if !is_valid_cmse_output_layout(layout) {
+        dcx.emit_err(errors::CmseOutputStackSpill { span: fn_decl.output.span(), abi });
+    }
+
+    Ok(())
 }
 
 /// Returns whether the output will fit into the available registers
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/params-via-stack.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/params-via-stack.stderr
index 5d59405fbd1b2..313f2bb8a6ae4 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/params-via-stack.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/params-via-stack.stderr
@@ -1,8 +1,10 @@
 error[E0798]: arguments for `"cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/params-via-stack.rs:16:61
+  --> $DIR/params-via-stack.rs:16:64
    |
 LL |     f1: extern "cmse-nonsecure-call" fn(u32, u32, u32, u32, x: u32, y: u32),
-   |                                                             ^^^^^^^^^^^^^^ these arguments don't fit in the available registers
+   |                                                                ^^^     ^^^ these arguments don't fit in the available registers
+   |                                                                |
+   |                                                                these arguments don't fit in the available registers
    |
    = note: functions with the `"cmse-nonsecure-call"` ABI must pass all their arguments via the 4 32-bit available argument registers
 
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/params-via-stack.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/params-via-stack.stderr
index f8b96bddc9479..221fc7cf86475 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/params-via-stack.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/params-via-stack.stderr
@@ -2,7 +2,9 @@ error[E0798]: arguments for `"cmse-nonsecure-entry"` function too large to pass
   --> $DIR/params-via-stack.rs:15:76
    |
 LL | pub extern "cmse-nonsecure-entry" fn f1(_: u32, _: u32, _: u32, _: u32, _: u32, _: u32) {}
-   |                                                                            ^^^^^^^^^^^ these arguments don't fit in the available registers
+   |                                                                            ^^^     ^^^ these arguments don't fit in the available registers
+   |                                                                            |
+   |                                                                            these arguments don't fit in the available registers
    |
    = note: functions with the `"cmse-nonsecure-entry"` ABI must pass all their arguments via the 4 32-bit available argument registers
 

From b47de64cdbfade1e8f3b4c21d338875a2c2ace7d Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Wed, 8 Oct 2025 13:42:49 +0200
Subject: [PATCH 1823/1889] cmse: rephrase error message when types don't fit

---
 compiler/rustc_hir_analysis/messages.ftl      |  7 ++----
 compiler/rustc_hir_analysis/src/errors.rs     |  1 -
 .../src/hir_ty_lowering/cmse.rs               |  3 +--
 .../params-via-stack.stderr                   | 22 +++++++++----------
 .../params-via-stack.stderr                   | 22 +++++++++----------
 5 files changed, 25 insertions(+), 30 deletions(-)

diff --git a/compiler/rustc_hir_analysis/messages.ftl b/compiler/rustc_hir_analysis/messages.ftl
index 06f2ec512ab1f..3ffced25489c5 100644
--- a/compiler/rustc_hir_analysis/messages.ftl
+++ b/compiler/rustc_hir_analysis/messages.ftl
@@ -80,11 +80,8 @@ hir_analysis_cmse_entry_generic =
 
 hir_analysis_cmse_inputs_stack_spill =
     arguments for `{$abi}` function too large to pass via registers
-    .label = {$plural ->
-        [false] this argument doesn't
-        *[true] these arguments don't
-    } fit in the available registers
-    .note = functions with the `{$abi}` ABI must pass all their arguments via the 4 32-bit available argument registers
+    .label = does not fit in the available registers
+    .note = functions with the `{$abi}` ABI must pass all their arguments via the 4 32-bit argument registers
 
 hir_analysis_cmse_output_stack_spill =
     return value of `{$abi}` function too large to pass via registers
diff --git a/compiler/rustc_hir_analysis/src/errors.rs b/compiler/rustc_hir_analysis/src/errors.rs
index db69653a27e9b..b57783ff6222b 100644
--- a/compiler/rustc_hir_analysis/src/errors.rs
+++ b/compiler/rustc_hir_analysis/src/errors.rs
@@ -1617,7 +1617,6 @@ pub(crate) struct CmseInputsStackSpill {
     #[primary_span]
     #[label]
     pub spans: Vec<Span>,
-    pub plural: bool,
     pub abi: ExternAbi,
 }
 
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 7e2938d1447ca..a648653744411 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
@@ -124,8 +124,7 @@ fn is_valid_cmse_inputs<'tcx>(
     if !excess_argument_spans.is_empty() {
         // fn f(x: u32, y: u32, z: u32, w: u16, q: u16) -> u32,
         //                                      ^^^^^^
-        let plural = excess_argument_spans.len() != 1;
-        dcx.emit_err(errors::CmseInputsStackSpill { spans: excess_argument_spans, plural, abi });
+        dcx.emit_err(errors::CmseInputsStackSpill { spans: excess_argument_spans, abi });
     }
 
     Ok(())
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/params-via-stack.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/params-via-stack.stderr
index 313f2bb8a6ae4..5a059e4df7b10 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/params-via-stack.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/params-via-stack.stderr
@@ -2,43 +2,43 @@ error[E0798]: arguments for `"cmse-nonsecure-call"` function too large to pass v
   --> $DIR/params-via-stack.rs:16:64
    |
 LL |     f1: extern "cmse-nonsecure-call" fn(u32, u32, u32, u32, x: u32, y: u32),
-   |                                                                ^^^     ^^^ these arguments don't fit in the available registers
+   |                                                                ^^^     ^^^ does not fit in the available registers
    |                                                                |
-   |                                                                these arguments don't fit in the available registers
+   |                                                                does not fit in the available registers
    |
-   = note: functions with the `"cmse-nonsecure-call"` ABI must pass all their arguments via the 4 32-bit available argument registers
+   = note: functions with the `"cmse-nonsecure-call"` ABI must pass all their arguments via the 4 32-bit argument registers
 
 error[E0798]: arguments for `"cmse-nonsecure-call"` function too large to pass via registers
   --> $DIR/params-via-stack.rs:17:61
    |
 LL |     f2: extern "cmse-nonsecure-call" fn(u32, u32, u32, u16, u16),
-   |                                                             ^^^ this argument doesn't fit in the available registers
+   |                                                             ^^^ does not fit in the available registers
    |
-   = note: functions with the `"cmse-nonsecure-call"` ABI must pass all their arguments via the 4 32-bit available argument registers
+   = note: functions with the `"cmse-nonsecure-call"` ABI must pass all their arguments via the 4 32-bit argument registers
 
 error[E0798]: arguments for `"cmse-nonsecure-call"` function too large to pass via registers
   --> $DIR/params-via-stack.rs:18:51
    |
 LL |     f3: extern "cmse-nonsecure-call" fn(u32, u64, u32),
-   |                                                   ^^^ this argument doesn't fit in the available registers
+   |                                                   ^^^ does not fit in the available registers
    |
-   = note: functions with the `"cmse-nonsecure-call"` ABI must pass all their arguments via the 4 32-bit available argument registers
+   = note: functions with the `"cmse-nonsecure-call"` ABI must pass all their arguments via the 4 32-bit argument registers
 
 error[E0798]: arguments for `"cmse-nonsecure-call"` function too large to pass via registers
   --> $DIR/params-via-stack.rs:19:56
    |
 LL |     f4: extern "cmse-nonsecure-call" fn(AlignRelevant, u32),
-   |                                                        ^^^ this argument doesn't fit in the available registers
+   |                                                        ^^^ does not fit in the available registers
    |
-   = note: functions with the `"cmse-nonsecure-call"` ABI must pass all their arguments via the 4 32-bit available argument registers
+   = note: functions with the `"cmse-nonsecure-call"` ABI must pass all their arguments via the 4 32-bit argument registers
 
 error[E0798]: arguments for `"cmse-nonsecure-call"` function too large to pass via registers
   --> $DIR/params-via-stack.rs:20:41
    |
 LL |     f5: extern "cmse-nonsecure-call" fn([u32; 5]),
-   |                                         ^^^^^^^^ this argument doesn't fit in the available registers
+   |                                         ^^^^^^^^ does not fit in the available registers
    |
-   = note: functions with the `"cmse-nonsecure-call"` ABI must pass all their arguments via the 4 32-bit available argument registers
+   = note: functions with the `"cmse-nonsecure-call"` ABI must pass all their arguments via the 4 32-bit argument registers
 
 error: aborting due to 5 previous errors
 
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/params-via-stack.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/params-via-stack.stderr
index 221fc7cf86475..3d523fc7be679 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/params-via-stack.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/params-via-stack.stderr
@@ -2,43 +2,43 @@ error[E0798]: arguments for `"cmse-nonsecure-entry"` function too large to pass
   --> $DIR/params-via-stack.rs:15:76
    |
 LL | pub extern "cmse-nonsecure-entry" fn f1(_: u32, _: u32, _: u32, _: u32, _: u32, _: u32) {}
-   |                                                                            ^^^     ^^^ these arguments don't fit in the available registers
+   |                                                                            ^^^     ^^^ does not fit in the available registers
    |                                                                            |
-   |                                                                            these arguments don't fit in the available registers
+   |                                                                            does not fit in the available registers
    |
-   = note: functions with the `"cmse-nonsecure-entry"` ABI must pass all their arguments via the 4 32-bit available argument registers
+   = note: functions with the `"cmse-nonsecure-entry"` ABI must pass all their arguments via the 4 32-bit argument registers
 
 error[E0798]: arguments for `"cmse-nonsecure-entry"` function too large to pass via registers
   --> $DIR/params-via-stack.rs:17:76
    |
 LL | pub extern "cmse-nonsecure-entry" fn f2(_: u32, _: u32, _: u32, _: u16, _: u16) {}
-   |                                                                            ^^^ this argument doesn't fit in the available registers
+   |                                                                            ^^^ does not fit in the available registers
    |
-   = note: functions with the `"cmse-nonsecure-entry"` ABI must pass all their arguments via the 4 32-bit available argument registers
+   = note: functions with the `"cmse-nonsecure-entry"` ABI must pass all their arguments via the 4 32-bit argument registers
 
 error[E0798]: arguments for `"cmse-nonsecure-entry"` function too large to pass via registers
   --> $DIR/params-via-stack.rs:19:60
    |
 LL | pub extern "cmse-nonsecure-entry" fn f3(_: u32, _: u64, _: u32) {}
-   |                                                            ^^^ this argument doesn't fit in the available registers
+   |                                                            ^^^ does not fit in the available registers
    |
-   = note: functions with the `"cmse-nonsecure-entry"` ABI must pass all their arguments via the 4 32-bit available argument registers
+   = note: functions with the `"cmse-nonsecure-entry"` ABI must pass all their arguments via the 4 32-bit argument registers
 
 error[E0798]: arguments for `"cmse-nonsecure-entry"` function too large to pass via registers
   --> $DIR/params-via-stack.rs:21:62
    |
 LL | pub extern "cmse-nonsecure-entry" fn f4(_: AlignRelevant, _: u32) {}
-   |                                                              ^^^ this argument doesn't fit in the available registers
+   |                                                              ^^^ does not fit in the available registers
    |
-   = note: functions with the `"cmse-nonsecure-entry"` ABI must pass all their arguments via the 4 32-bit available argument registers
+   = note: functions with the `"cmse-nonsecure-entry"` ABI must pass all their arguments via the 4 32-bit argument registers
 
 error[E0798]: arguments for `"cmse-nonsecure-entry"` function too large to pass via registers
   --> $DIR/params-via-stack.rs:25:44
    |
 LL | pub extern "cmse-nonsecure-entry" fn f5(_: [u32; 5]) {}
-   |                                            ^^^^^^^^ this argument doesn't fit in the available registers
+   |                                            ^^^^^^^^ does not fit in the available registers
    |
-   = note: functions with the `"cmse-nonsecure-entry"` ABI must pass all their arguments via the 4 32-bit available argument registers
+   = note: functions with the `"cmse-nonsecure-entry"` ABI must pass all their arguments via the 4 32-bit argument registers
 
 error: aborting due to 5 previous errors
 

From 98d3864310711946f1374c8bac5723edf626efb8 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Wed, 8 Oct 2025 14:05:47 +0200
Subject: [PATCH 1824/1889] cmse: rephrase error message when signature uses
 generics

---
 compiler/rustc_hir_analysis/messages.ftl      |  8 ++--
 compiler/rustc_hir_analysis/src/errors.rs     | 14 +++---
 .../src/hir_ty_lowering/cmse.rs               | 13 ++---
 .../cmse-nonsecure-call/generics.stderr       |  4 +-
 .../cmse-nonsecure-entry/generics.rs          | 12 ++---
 .../cmse-nonsecure-entry/generics.stderr      | 47 ++++++++-----------
 6 files changed, 46 insertions(+), 52 deletions(-)

diff --git a/compiler/rustc_hir_analysis/messages.ftl b/compiler/rustc_hir_analysis/messages.ftl
index 3ffced25489c5..6add9baa1520f 100644
--- a/compiler/rustc_hir_analysis/messages.ftl
+++ b/compiler/rustc_hir_analysis/messages.ftl
@@ -72,11 +72,11 @@ hir_analysis_cannot_capture_late_bound_ty =
 hir_analysis_closure_implicit_hrtb = implicit types in closure signatures are forbidden when `for<...>` is present
     .label = `for<...>` is here
 
-hir_analysis_cmse_call_generic =
-    function pointers with the `"cmse-nonsecure-call"` ABI cannot contain generics in their type
+hir_analysis_cmse_generic =
+    generics are not allowed in `extern {$abi}` signatures
 
-hir_analysis_cmse_entry_generic =
-    functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
+hir_analysis_cmse_impl_trait =
+    `impl Trait` is not allowed in `extern {$abi}` signatures
 
 hir_analysis_cmse_inputs_stack_spill =
     arguments for `{$abi}` function too large to pass via registers
diff --git a/compiler/rustc_hir_analysis/src/errors.rs b/compiler/rustc_hir_analysis/src/errors.rs
index b57783ff6222b..49c5106422881 100644
--- a/compiler/rustc_hir_analysis/src/errors.rs
+++ b/compiler/rustc_hir_analysis/src/errors.rs
@@ -1632,22 +1632,24 @@ pub(crate) struct CmseOutputStackSpill {
 }
 
 #[derive(Diagnostic)]
-#[diag(hir_analysis_cmse_call_generic, code = E0798)]
-pub(crate) struct CmseCallGeneric {
+#[diag(hir_analysis_cmse_generic, code = E0798)]
+pub(crate) struct CmseGeneric {
     #[primary_span]
     pub span: Span,
+    pub abi: ExternAbi,
 }
 
 #[derive(Diagnostic)]
-#[diag(hir_analysis_bad_return_type_notation_position)]
-pub(crate) struct BadReturnTypeNotation {
+#[diag(hir_analysis_cmse_impl_trait, code = E0798)]
+pub(crate) struct CmseImplTrait {
     #[primary_span]
     pub span: Span,
+    pub abi: ExternAbi,
 }
 
 #[derive(Diagnostic)]
-#[diag(hir_analysis_cmse_entry_generic, code = E0798)]
-pub(crate) struct CmseEntryGeneric {
+#[diag(hir_analysis_bad_return_type_notation_position)]
+pub(crate) struct BadReturnTypeNotation {
     #[primary_span]
     pub span: Span,
 }
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 a648653744411..9a31119c7f5a7 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
@@ -48,14 +48,14 @@ pub(crate) fn validate_cmse_abi<'tcx>(
                 Ok(()) => {}
                 Err(layout_err) => {
                     if should_emit_generic_error(abi, layout_err) {
-                        dcx.emit_err(errors::CmseCallGeneric { span: *fn_ptr_span });
+                        dcx.emit_err(errors::CmseGeneric { span: *fn_ptr_span, abi });
                     }
                 }
             }
 
             if let Err(layout_err) = is_valid_cmse_output(tcx, dcx, fn_sig, fn_ptr_ty.decl, abi) {
                 if should_emit_generic_error(abi, layout_err) {
-                    dcx.emit_err(errors::CmseCallGeneric { span: *fn_ptr_span });
+                    dcx.emit_err(errors::CmseGeneric { span: *fn_ptr_span, abi });
                 }
             }
         }
@@ -76,14 +76,14 @@ pub(crate) fn validate_cmse_abi<'tcx>(
                 Ok(()) => {}
                 Err(layout_err) => {
                     if should_emit_generic_error(abi, layout_err) {
-                        dcx.emit_err(errors::CmseEntryGeneric { span: *fn_sig_span });
+                        dcx.emit_err(errors::CmseGeneric { span: *fn_sig_span, abi });
                     }
                 }
             }
 
             if let Err(layout_err) = is_valid_cmse_output(tcx, dcx, fn_sig, decl, abi) {
                 if should_emit_generic_error(abi, layout_err) {
-                    dcx.emit_err(errors::CmseEntryGeneric { span: *fn_sig_span });
+                    dcx.emit_err(errors::CmseGeneric { span: *fn_sig_span, abi });
                 }
             }
         }
@@ -152,8 +152,9 @@ fn is_valid_cmse_output<'tcx>(
     // `#[no_mangle]` or similar, so generics in the type really don't make sense.
     //
     // see also https://github.com/rust-lang/rust/issues/147242.
-    if return_type.has_opaque_types() {
-        return Err(tcx.arena.alloc(LayoutError::TooGeneric(return_type)));
+    if abi == ExternAbi::CmseNonSecureEntry && return_type.has_opaque_types() {
+        dcx.emit_err(errors::CmseImplTrait { span: fn_decl.output.span(), abi });
+        return Ok(());
     }
 
     let typing_env = ty::TypingEnv::fully_monomorphized();
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.stderr
index d3ef87394be6c..d70369c46fbeb 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.stderr
@@ -54,13 +54,13 @@ LL |     f3: extern "cmse-nonsecure-call" fn((impl Copy, u32), u32, u32, u32) ->
    |
    = note: `impl Trait` is only allowed in arguments and return types of functions and methods
 
-error[E0798]: function pointers with the `"cmse-nonsecure-call"` ABI cannot contain generics in their type
+error[E0798]: generics are not allowed in `extern "cmse-nonsecure-call"` signatures
   --> $DIR/generics.rs:23:9
    |
 LL |     f4: extern "cmse-nonsecure-call" fn(T, u32, u32, u32) -> u64,
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0798]: function pointers with the `"cmse-nonsecure-call"` ABI cannot contain generics in their type
+error[E0798]: generics are not allowed in `extern "cmse-nonsecure-call"` signatures
   --> $DIR/generics.rs:24:9
    |
 LL |     f5: extern "cmse-nonsecure-call" fn(Wrapper<T>, u32, u32, u32) -> u64,
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs
index 6f835538be9a3..2b4ddf5e31d33 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs
@@ -67,25 +67,25 @@ extern "cmse-nonsecure-entry" fn impl_trait(_: impl Copy, _: u32, _: u32, _: u32
 }
 
 extern "cmse-nonsecure-entry" fn return_impl_trait() -> impl Copy {
-    //~^ ERROR functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
+    //~^ ERROR `impl Trait` is not allowed in `extern "cmse-nonsecure-entry"` signatures
     0u128
 }
 
 extern "cmse-nonsecure-entry" fn return_impl_trait_nested() -> (impl Copy, i32) {
-    //~^ ERROR functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
+    //~^ ERROR `impl Trait` is not allowed in `extern "cmse-nonsecure-entry"` signatures
     (0u128, 0i32)
 }
 
 extern "cmse-nonsecure-entry" fn identity_impl_trait(v: impl Copy) -> impl Copy {
-    //~^ ERROR functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
-    //~| ERROR functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
+    //~^ ERROR generics are not allowed in `extern "cmse-nonsecure-entry"` signatures
+    //~| ERROR `impl Trait` is not allowed in `extern "cmse-nonsecure-entry"` signatures
     v
 }
 
 extern "cmse-nonsecure-entry" fn identity_impl_trait_nested(
-    //~^ ERROR functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
-    //~| ERROR functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
+    //~^ ERROR generics are not allowed in `extern "cmse-nonsecure-entry"` signatures
     v: (impl Copy, i32),
 ) -> (impl Copy, i32) {
+    //~^ ERROR `impl Trait` is not allowed in `extern "cmse-nonsecure-entry"` signatures
     v
 }
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr
index 2c46cd708960f..e61051a4a26f4 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr
@@ -1,4 +1,4 @@
-error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
+error[E0798]: generics are not allowed in `extern "cmse-nonsecure-entry"` signatures
   --> $DIR/generics.rs:30:1
    |
 LL | / extern "cmse-nonsecure-entry" fn introduced_generic<U: Copy>(
@@ -10,55 +10,46 @@ LL | |     _: u32,
 LL | | ) -> u64 {
    | |________^
 
-error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
+error[E0798]: generics are not allowed in `extern "cmse-nonsecure-entry"` signatures
   --> $DIR/generics.rs:64:1
    |
 LL | extern "cmse-nonsecure-entry" fn impl_trait(_: impl Copy, _: u32, _: u32, _: u32) -> u64 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
+error[E0798]: generics are not allowed in `extern "cmse-nonsecure-entry"` signatures
   --> $DIR/generics.rs:79:1
    |
 LL | extern "cmse-nonsecure-entry" fn identity_impl_trait(v: impl Copy) -> impl Copy {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
-  --> $DIR/generics.rs:79:1
+error[E0798]: `impl Trait` is not allowed in `extern "cmse-nonsecure-entry"` signatures
+  --> $DIR/generics.rs:79:71
    |
 LL | extern "cmse-nonsecure-entry" fn identity_impl_trait(v: impl Copy) -> impl Copy {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+   |                                                                       ^^^^^^^^^
 
-error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
+error[E0798]: generics are not allowed in `extern "cmse-nonsecure-entry"` signatures
   --> $DIR/generics.rs:85:1
    |
 LL | / extern "cmse-nonsecure-entry" fn identity_impl_trait_nested(
 LL | |
-LL | |
 LL | |     v: (impl Copy, i32),
 LL | | ) -> (impl Copy, i32) {
    | |_____________________^
 
-error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
-  --> $DIR/generics.rs:85:1
+error[E0798]: `impl Trait` is not allowed in `extern "cmse-nonsecure-entry"` signatures
+  --> $DIR/generics.rs:88:6
    |
-LL | / extern "cmse-nonsecure-entry" fn identity_impl_trait_nested(
-LL | |
-LL | |
-LL | |     v: (impl Copy, i32),
-LL | | ) -> (impl Copy, i32) {
-   | |_____________________^
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+LL | ) -> (impl Copy, i32) {
+   |      ^^^^^^^^^^^^^^^^
 
-error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
+error[E0798]: generics are not allowed in `extern "cmse-nonsecure-entry"` signatures
   --> $DIR/generics.rs:14:5
    |
 LL |     extern "cmse-nonsecure-entry" fn ambient_generic(_: T, _: u32, _: u32, _: u32) -> u64 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
+error[E0798]: generics are not allowed in `extern "cmse-nonsecure-entry"` signatures
   --> $DIR/generics.rs:19:5
    |
 LL | /     extern "cmse-nonsecure-entry" fn ambient_generic_nested(
@@ -97,17 +88,17 @@ LL | extern "cmse-nonsecure-entry" fn wrapped_trait_object(x: WrapperTransparent
    = note: functions with the `"cmse-nonsecure-entry"` ABI must pass their result via the available return registers
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
-error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
-  --> $DIR/generics.rs:69:1
+error[E0798]: `impl Trait` is not allowed in `extern "cmse-nonsecure-entry"` signatures
+  --> $DIR/generics.rs:69:57
    |
 LL | extern "cmse-nonsecure-entry" fn return_impl_trait() -> impl Copy {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                                         ^^^^^^^^^
 
-error[E0798]: functions with the `"cmse-nonsecure-entry"` ABI cannot contain generics in their type
-  --> $DIR/generics.rs:74:1
+error[E0798]: `impl Trait` is not allowed in `extern "cmse-nonsecure-entry"` signatures
+  --> $DIR/generics.rs:74:64
    |
 LL | extern "cmse-nonsecure-entry" fn return_impl_trait_nested() -> (impl Copy, i32) {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                                                ^^^^^^^^^^^^^^^^
 
 error: aborting due to 13 previous errors
 

From 760ea07840f7eb78664355a52150a64964f57c47 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Wed, 8 Oct 2025 14:10:13 +0200
Subject: [PATCH 1825/1889] cmse: more accurate span for generic arguments

---
 .../src/hir_ty_lowering/cmse.rs               | 46 ++++++++---------
 .../cmse-nonsecure-call/generics.stderr       |  8 +--
 .../cmse-nonsecure-entry/generics.rs          |  6 +--
 .../cmse-nonsecure-entry/generics.stderr      | 49 +++++++------------
 4 files changed, 45 insertions(+), 64 deletions(-)

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 9a31119c7f5a7..b6c6e43b1d950 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
@@ -4,6 +4,7 @@ use rustc_hir::{self as hir, HirId};
 use rustc_middle::bug;
 use rustc_middle::ty::layout::{LayoutError, TyAndLayout};
 use rustc_middle::ty::{self, TyCtxt, TypeVisitableExt};
+use rustc_span::Span;
 
 use crate::errors;
 
@@ -20,11 +21,7 @@ pub(crate) fn validate_cmse_abi<'tcx>(
     match abi {
         ExternAbi::CmseNonSecureCall => {
             let hir_node = tcx.hir_node(hir_id);
-            let hir::Node::Ty(hir::Ty {
-                span: fn_ptr_span,
-                kind: hir::TyKind::FnPtr(fn_ptr_ty),
-                ..
-            }) = hir_node
+            let hir::Node::Ty(hir::Ty { kind: hir::TyKind::FnPtr(fn_ptr_ty), .. }) = hir_node
             else {
                 let span = match tcx.parent_hir_node(hir_id) {
                     hir::Node::Item(hir::Item {
@@ -44,24 +41,24 @@ pub(crate) fn validate_cmse_abi<'tcx>(
                 return;
             };
 
-            match is_valid_cmse_inputs(tcx, dcx, fn_sig, fn_ptr_ty.decl, abi) {
-                Ok(()) => {}
-                Err(layout_err) => {
-                    if should_emit_generic_error(abi, layout_err) {
-                        dcx.emit_err(errors::CmseGeneric { span: *fn_ptr_span, abi });
-                    }
+            if let Err((span, layout_err)) =
+                is_valid_cmse_inputs(tcx, dcx, fn_sig, fn_ptr_ty.decl, abi)
+            {
+                if should_emit_layout_error(abi, layout_err) {
+                    dcx.emit_err(errors::CmseGeneric { span, abi });
                 }
             }
 
             if let Err(layout_err) = is_valid_cmse_output(tcx, dcx, fn_sig, fn_ptr_ty.decl, abi) {
-                if should_emit_generic_error(abi, layout_err) {
-                    dcx.emit_err(errors::CmseGeneric { span: *fn_ptr_span, abi });
+                if should_emit_layout_error(abi, layout_err) {
+                    let span = fn_ptr_ty.decl.output.span();
+                    dcx.emit_err(errors::CmseGeneric { span, abi });
                 }
             }
         }
         ExternAbi::CmseNonSecureEntry => {
             let hir_node = tcx.hir_node(hir_id);
-            let Some(hir::FnSig { decl, span: fn_sig_span, .. }) = hir_node.fn_sig() else {
+            let Some(hir::FnSig { decl, .. }) = hir_node.fn_sig() else {
                 // might happen when this ABI is used incorrectly. That will be handled elsewhere
                 return;
             };
@@ -72,18 +69,15 @@ pub(crate) fn validate_cmse_abi<'tcx>(
                 return;
             }
 
-            match is_valid_cmse_inputs(tcx, dcx, fn_sig, decl, abi) {
-                Ok(()) => {}
-                Err(layout_err) => {
-                    if should_emit_generic_error(abi, layout_err) {
-                        dcx.emit_err(errors::CmseGeneric { span: *fn_sig_span, abi });
-                    }
+            if let Err((span, layout_err)) = is_valid_cmse_inputs(tcx, dcx, fn_sig, decl, abi) {
+                if should_emit_layout_error(abi, layout_err) {
+                    dcx.emit_err(errors::CmseGeneric { span, abi });
                 }
             }
 
             if let Err(layout_err) = is_valid_cmse_output(tcx, dcx, fn_sig, decl, abi) {
-                if should_emit_generic_error(abi, layout_err) {
-                    dcx.emit_err(errors::CmseGeneric { span: *fn_sig_span, abi });
+                if should_emit_layout_error(abi, layout_err) {
+                    dcx.emit_err(errors::CmseGeneric { span: decl.output.span(), abi });
                 }
             }
         }
@@ -98,7 +92,7 @@ fn is_valid_cmse_inputs<'tcx>(
     fn_sig: ty::PolyFnSig<'tcx>,
     fn_decl: &hir::FnDecl<'tcx>,
     abi: ExternAbi,
-) -> Result<(), &'tcx LayoutError<'tcx>> {
+) -> Result<(), (Span, &'tcx LayoutError<'tcx>)> {
     let mut accum = 0u64;
     let mut excess_argument_spans = Vec::new();
 
@@ -107,7 +101,9 @@ fn is_valid_cmse_inputs<'tcx>(
     let fn_sig = tcx.erase_and_anonymize_regions(fn_sig);
 
     for (ty, hir_ty) in fn_sig.inputs().iter().zip(fn_decl.inputs) {
-        let layout = tcx.layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(*ty))?;
+        let layout = tcx
+            .layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(*ty))
+            .map_err(|e| (hir_ty.span, e))?;
 
         let align = layout.layout.align().bytes();
         let size = layout.layout.size().bytes();
@@ -189,7 +185,7 @@ fn is_valid_cmse_output_layout<'tcx>(layout: TyAndLayout<'tcx>) -> bool {
     matches!(value, Primitive::Int(Integer::I64, _) | Primitive::Float(Float::F64))
 }
 
-fn should_emit_generic_error<'tcx>(abi: ExternAbi, layout_err: &'tcx LayoutError<'tcx>) -> bool {
+fn should_emit_layout_error<'tcx>(abi: ExternAbi, layout_err: &'tcx LayoutError<'tcx>) -> bool {
     use LayoutError::*;
 
     match layout_err {
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.stderr
index d70369c46fbeb..75da78b0b75a9 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.stderr
@@ -55,16 +55,16 @@ LL |     f3: extern "cmse-nonsecure-call" fn((impl Copy, u32), u32, u32, u32) ->
    = note: `impl Trait` is only allowed in arguments and return types of functions and methods
 
 error[E0798]: generics are not allowed in `extern "cmse-nonsecure-call"` signatures
-  --> $DIR/generics.rs:23:9
+  --> $DIR/generics.rs:23:41
    |
 LL |     f4: extern "cmse-nonsecure-call" fn(T, u32, u32, u32) -> u64,
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                         ^
 
 error[E0798]: generics are not allowed in `extern "cmse-nonsecure-call"` signatures
-  --> $DIR/generics.rs:24:9
+  --> $DIR/generics.rs:24:41
    |
 LL |     f5: extern "cmse-nonsecure-call" fn(Wrapper<T>, u32, u32, u32) -> u64,
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                         ^^^^^^^^^^
 
 error[E0798]: return value of `"cmse-nonsecure-call"` function too large to pass via registers
   --> $DIR/generics.rs:30:71
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs
index 2b4ddf5e31d33..d01934929d97f 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs
@@ -17,8 +17,8 @@ impl<T: Copy> Wrapper<T> {
     }
 
     extern "cmse-nonsecure-entry" fn ambient_generic_nested(
-        //~^ ERROR [E0798]
         _: Wrapper<T>,
+        //~^ ERROR [E0798]
         _: u32,
         _: u32,
         _: u32,
@@ -28,8 +28,8 @@ impl<T: Copy> Wrapper<T> {
 }
 
 extern "cmse-nonsecure-entry" fn introduced_generic<U: Copy>(
-    //~^ ERROR [E0798]
     _: U,
+    //~^ ERROR [E0798]
     _: u32,
     _: u32,
     _: u32,
@@ -83,8 +83,8 @@ extern "cmse-nonsecure-entry" fn identity_impl_trait(v: impl Copy) -> impl Copy
 }
 
 extern "cmse-nonsecure-entry" fn identity_impl_trait_nested(
-    //~^ ERROR generics are not allowed in `extern "cmse-nonsecure-entry"` signatures
     v: (impl Copy, i32),
+    //~^ ERROR generics are not allowed in `extern "cmse-nonsecure-entry"` signatures
 ) -> (impl Copy, i32) {
     //~^ ERROR `impl Trait` is not allowed in `extern "cmse-nonsecure-entry"` signatures
     v
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr
index e61051a4a26f4..5ddd29883f867 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr
@@ -1,26 +1,20 @@
 error[E0798]: generics are not allowed in `extern "cmse-nonsecure-entry"` signatures
-  --> $DIR/generics.rs:30:1
-   |
-LL | / extern "cmse-nonsecure-entry" fn introduced_generic<U: Copy>(
-LL | |
-LL | |     _: U,
-LL | |     _: u32,
-LL | |     _: u32,
-LL | |     _: u32,
-LL | | ) -> u64 {
-   | |________^
+  --> $DIR/generics.rs:31:8
+   |
+LL |     _: U,
+   |        ^
 
 error[E0798]: generics are not allowed in `extern "cmse-nonsecure-entry"` signatures
-  --> $DIR/generics.rs:64:1
+  --> $DIR/generics.rs:64:48
    |
 LL | extern "cmse-nonsecure-entry" fn impl_trait(_: impl Copy, _: u32, _: u32, _: u32) -> u64 {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                                ^^^^^^^^^
 
 error[E0798]: generics are not allowed in `extern "cmse-nonsecure-entry"` signatures
-  --> $DIR/generics.rs:79:1
+  --> $DIR/generics.rs:79:57
    |
 LL | extern "cmse-nonsecure-entry" fn identity_impl_trait(v: impl Copy) -> impl Copy {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                                         ^^^^^^^^^
 
 error[E0798]: `impl Trait` is not allowed in `extern "cmse-nonsecure-entry"` signatures
   --> $DIR/generics.rs:79:71
@@ -29,13 +23,10 @@ LL | extern "cmse-nonsecure-entry" fn identity_impl_trait(v: impl Copy) -> impl
    |                                                                       ^^^^^^^^^
 
 error[E0798]: generics are not allowed in `extern "cmse-nonsecure-entry"` signatures
-  --> $DIR/generics.rs:85:1
+  --> $DIR/generics.rs:86:8
    |
-LL | / extern "cmse-nonsecure-entry" fn identity_impl_trait_nested(
-LL | |
-LL | |     v: (impl Copy, i32),
-LL | | ) -> (impl Copy, i32) {
-   | |_____________________^
+LL |     v: (impl Copy, i32),
+   |        ^^^^^^^^^^^^^^^^
 
 error[E0798]: `impl Trait` is not allowed in `extern "cmse-nonsecure-entry"` signatures
   --> $DIR/generics.rs:88:6
@@ -44,22 +35,16 @@ LL | ) -> (impl Copy, i32) {
    |      ^^^^^^^^^^^^^^^^
 
 error[E0798]: generics are not allowed in `extern "cmse-nonsecure-entry"` signatures
-  --> $DIR/generics.rs:14:5
+  --> $DIR/generics.rs:14:57
    |
 LL |     extern "cmse-nonsecure-entry" fn ambient_generic(_: T, _: u32, _: u32, _: u32) -> u64 {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                                         ^
 
 error[E0798]: generics are not allowed in `extern "cmse-nonsecure-entry"` signatures
-  --> $DIR/generics.rs:19:5
-   |
-LL | /     extern "cmse-nonsecure-entry" fn ambient_generic_nested(
-LL | |
-LL | |         _: Wrapper<T>,
-LL | |         _: u32,
-LL | |         _: u32,
-LL | |         _: u32,
-LL | |     ) -> u64 {
-   | |____________^
+  --> $DIR/generics.rs:20:12
+   |
+LL |         _: Wrapper<T>,
+   |            ^^^^^^^^^^
 
 error[E0798]: return value of `"cmse-nonsecure-entry"` function too large to pass via registers
   --> $DIR/generics.rs:46:65

From bd5f908152b7b7dc2acf30bec6cd114e45ce4af3 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Wed, 8 Oct 2025 14:16:26 +0200
Subject: [PATCH 1826/1889] cmse: simplify input/output check control flow

---
 .../src/hir_ty_lowering/cmse.rs               | 53 +++++++------------
 1 file changed, 19 insertions(+), 34 deletions(-)

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 b6c6e43b1d950..f8af6888923ce 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
@@ -18,11 +18,10 @@ pub(crate) fn validate_cmse_abi<'tcx>(
     abi: ExternAbi,
     fn_sig: ty::PolyFnSig<'tcx>,
 ) {
-    match abi {
-        ExternAbi::CmseNonSecureCall => {
-            let hir_node = tcx.hir_node(hir_id);
-            let hir::Node::Ty(hir::Ty { kind: hir::TyKind::FnPtr(fn_ptr_ty), .. }) = hir_node
-            else {
+    let fn_decl = match abi {
+        ExternAbi::CmseNonSecureCall => match tcx.hir_node(hir_id) {
+            hir::Node::Ty(hir::Ty { kind: hir::TyKind::FnPtr(fn_ptr_ty), .. }) => fn_ptr_ty.decl,
+            _ => {
                 let span = match tcx.parent_hir_node(hir_id) {
                     hir::Node::Item(hir::Item {
                         kind: hir::ItemKind::ForeignMod { .. },
@@ -39,26 +38,10 @@ pub(crate) fn validate_cmse_abi<'tcx>(
                 )
                 .emit();
                 return;
-            };
-
-            if let Err((span, layout_err)) =
-                is_valid_cmse_inputs(tcx, dcx, fn_sig, fn_ptr_ty.decl, abi)
-            {
-                if should_emit_layout_error(abi, layout_err) {
-                    dcx.emit_err(errors::CmseGeneric { span, abi });
-                }
-            }
-
-            if let Err(layout_err) = is_valid_cmse_output(tcx, dcx, fn_sig, fn_ptr_ty.decl, abi) {
-                if should_emit_layout_error(abi, layout_err) {
-                    let span = fn_ptr_ty.decl.output.span();
-                    dcx.emit_err(errors::CmseGeneric { span, abi });
-                }
             }
-        }
+        },
         ExternAbi::CmseNonSecureEntry => {
-            let hir_node = tcx.hir_node(hir_id);
-            let Some(hir::FnSig { decl, .. }) = hir_node.fn_sig() else {
+            let Some(hir::FnSig { decl, .. }) = tcx.hir_node(hir_id).fn_sig() else {
                 // might happen when this ABI is used incorrectly. That will be handled elsewhere
                 return;
             };
@@ -69,19 +52,21 @@ pub(crate) fn validate_cmse_abi<'tcx>(
                 return;
             }
 
-            if let Err((span, layout_err)) = is_valid_cmse_inputs(tcx, dcx, fn_sig, decl, abi) {
-                if should_emit_layout_error(abi, layout_err) {
-                    dcx.emit_err(errors::CmseGeneric { span, abi });
-                }
-            }
+            decl
+        }
+        _ => return,
+    };
 
-            if let Err(layout_err) = is_valid_cmse_output(tcx, dcx, fn_sig, decl, abi) {
-                if should_emit_layout_error(abi, layout_err) {
-                    dcx.emit_err(errors::CmseGeneric { span: decl.output.span(), abi });
-                }
-            }
+    if let Err((span, layout_err)) = is_valid_cmse_inputs(tcx, dcx, fn_sig, fn_decl, abi) {
+        if should_emit_layout_error(abi, layout_err) {
+            dcx.emit_err(errors::CmseGeneric { span, abi });
+        }
+    }
+
+    if let Err(layout_err) = is_valid_cmse_output(tcx, dcx, fn_sig, fn_decl, abi) {
+        if should_emit_layout_error(abi, layout_err) {
+            dcx.emit_err(errors::CmseGeneric { span: fn_decl.output.span(), abi });
         }
-        _ => (),
     }
 }
 

From 973ddd8bc7483cb944a6632eacffea84ef814181 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Wed, 8 Oct 2025 14:21:37 +0000
Subject: [PATCH 1827/1889] Do not invalidate CFG caches in CtfeLimit.

---
 compiler/rustc_mir_transform/src/ctfe_limit.rs | 17 +++++------------
 1 file changed, 5 insertions(+), 12 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/ctfe_limit.rs b/compiler/rustc_mir_transform/src/ctfe_limit.rs
index ac46336b83473..e2f518bb4ee81 100644
--- a/compiler/rustc_mir_transform/src/ctfe_limit.rs
+++ b/compiler/rustc_mir_transform/src/ctfe_limit.rs
@@ -28,12 +28,12 @@ impl<'tcx> crate::MirPass<'tcx> for CtfeLimit {
                 }
             })
             .collect();
+
+        let basic_blocks = body.basic_blocks.as_mut_preserves_cfg();
         for index in indices {
-            insert_counter(
-                body.basic_blocks_mut()
-                    .get_mut(index)
-                    .expect("basic_blocks index {index} should exist"),
-            );
+            let bbdata = &mut basic_blocks[index];
+            let source_info = bbdata.terminator().source_info;
+            bbdata.statements.push(Statement::new(source_info, StatementKind::ConstEvalCounter));
         }
     }
 
@@ -53,10 +53,3 @@ fn has_back_edge(
     // Check if any of the dominators of the node are also the node's successor.
     node_data.terminator().successors().any(|succ| doms.dominates(succ, node))
 }
-
-fn insert_counter(basic_block_data: &mut BasicBlockData<'_>) {
-    basic_block_data.statements.push(Statement::new(
-        basic_block_data.terminator().source_info,
-        StatementKind::ConstEvalCounter,
-    ));
-}

From d4ecd710a5de576a8b9f891c8169a107a638f3d6 Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Wed, 8 Oct 2025 15:13:47 +0000
Subject: [PATCH 1828/1889] format: some small cleanup

---
 compiler/rustc_ast/src/token.rs             |  4 +--
 compiler/rustc_builtin_macros/src/format.rs | 37 ++++++++++-----------
 2 files changed, 19 insertions(+), 22 deletions(-)

diff --git a/compiler/rustc_ast/src/token.rs b/compiler/rustc_ast/src/token.rs
index 6dc6d1026f621..e1231312a2afd 100644
--- a/compiler/rustc_ast/src/token.rs
+++ b/compiler/rustc_ast/src/token.rs
@@ -881,11 +881,11 @@ impl Token {
     }
 
     pub fn is_qpath_start(&self) -> bool {
-        self == &Lt || self == &Shl
+        matches!(self.kind, Lt | Shl)
     }
 
     pub fn is_path_start(&self) -> bool {
-        self == &PathSep
+        self.kind == PathSep
             || self.is_qpath_start()
             || matches!(self.is_metavar_seq(), Some(MetaVarKind::Path))
             || self.is_path_segment_keyword()
diff --git a/compiler/rustc_builtin_macros/src/format.rs b/compiler/rustc_builtin_macros/src/format.rs
index bffc0407e8112..a0ee7ac19899b 100644
--- a/compiler/rustc_builtin_macros/src/format.rs
+++ b/compiler/rustc_builtin_macros/src/format.rs
@@ -69,35 +69,26 @@ struct MacroInput {
 /// Ok((fmtstr, parsed arguments))
 /// ```
 fn parse_args<'a>(ecx: &ExtCtxt<'a>, sp: Span, tts: TokenStream) -> PResult<'a, MacroInput> {
-    let mut args = FormatArguments::new();
-
     let mut p = ecx.new_parser_from_tts(tts);
 
-    if p.token == token::Eof {
-        return Err(ecx.dcx().create_err(errors::FormatRequiresString { span: sp }));
-    }
-
-    let first_token = &p.token;
-
-    let fmtstr = if let token::Literal(lit) = first_token.kind
-        && matches!(lit.kind, token::Str | token::StrRaw(_))
-    {
+    // parse the format string
+    let fmtstr = match p.token.kind {
+        token::Eof => return Err(ecx.dcx().create_err(errors::FormatRequiresString { span: sp })),
         // This allows us to properly handle cases when the first comma
         // after the format string is mistakenly replaced with any operator,
         // which cause the expression parser to eat too much tokens.
-        p.parse_literal_maybe_minus()?
-    } else {
+        token::Literal(token::Lit { kind: token::Str | token::StrRaw(_), .. }) => {
+            p.parse_literal_maybe_minus()?
+        }
         // Otherwise, we fall back to the expression parser.
-        p.parse_expr()?
+        _ => p.parse_expr()?,
     };
 
-    // Only allow implicit captures to be used when the argument is a direct literal
-    // instead of a macro expanding to one.
-    let is_direct_literal = matches!(fmtstr.kind, ExprKind::Lit(_));
-
+    // parse comma FormatArgument pairs
+    let mut args = FormatArguments::new();
     let mut first = true;
-
     while p.token != token::Eof {
+        // parse a comma, or else report an error
         if !p.eat(exp!(Comma)) {
             if first {
                 p.clear_expected_token_types();
@@ -120,9 +111,11 @@ fn parse_args<'a>(ecx: &ExtCtxt<'a>, sp: Span, tts: TokenStream) -> PResult<'a,
             }
         }
         first = false;
+        // accept a trailing comma
         if p.token == token::Eof {
             break;
-        } // accept trailing commas
+        }
+        // parse a FormatArgument
         match p.token.ident() {
             Some((ident, _)) if p.look_ahead(1, |t| *t == token::Eq) => {
                 p.bump();
@@ -156,6 +149,10 @@ fn parse_args<'a>(ecx: &ExtCtxt<'a>, sp: Span, tts: TokenStream) -> PResult<'a,
             }
         }
     }
+
+    // Only allow implicit captures for direct literals
+    let is_direct_literal = matches!(fmtstr.kind, ExprKind::Lit(_));
+
     Ok(MacroInput { fmtstr, args, is_direct_literal })
 }
 

From 2533f78d62dfdaec52b77d37167bba246e211378 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Wed, 8 Oct 2025 15:17:15 +0000
Subject: [PATCH 1829/1889] Reorder passes.

---
 compiler/rustc_mir_transform/src/lib.rs | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/lib.rs b/compiler/rustc_mir_transform/src/lib.rs
index 9ff7e0b550030..acf5a5c86f715 100644
--- a/compiler/rustc_mir_transform/src/lib.rs
+++ b/compiler/rustc_mir_transform/src/lib.rs
@@ -684,6 +684,8 @@ pub(crate) fn run_optimization_passes<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'
             &inline::ForceInline,
             // Perform inlining, which may add a lot of code.
             &inline::Inline,
+            // Inlining may have introduced a lot of redundant code and a large move pattern.
+            // Now, we need to shrink the generated MIR.
             // Code from other crates may have storage markers, so this needs to happen after
             // inlining.
             &remove_storage_markers::RemoveStorageMarkers,
@@ -695,14 +697,13 @@ pub(crate) fn run_optimization_passes<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'
             &unreachable_enum_branching::UnreachableEnumBranching,
             &unreachable_prop::UnreachablePropagation,
             &o1(simplify::SimplifyCfg::AfterUnreachableEnumBranching),
-            // Inlining may have introduced a lot of redundant code and a large move pattern.
-            // Now, we need to shrink the generated MIR.
-            &ref_prop::ReferencePropagation,
-            &sroa::ScalarReplacementOfAggregates,
             &multiple_return_terminators::MultipleReturnTerminators,
             // After simplifycfg, it allows us to discover new opportunities for peephole
-            // optimizations.
+            // optimizations. This invalidates CFG caches, so avoid putting between two SSA
+            // analyses.
             &instsimplify::InstSimplify::AfterSimplifyCfg,
+            &ref_prop::ReferencePropagation,
+            &sroa::ScalarReplacementOfAggregates,
             &simplify::SimplifyLocals::BeforeConstProp,
             &dead_store_elimination::DeadStoreElimination::Initial,
             &gvn::GVN,

From 45ca537746f9fdb4c68eaf4bdbb8145aec554fab Mon Sep 17 00:00:00 2001
From: sayantn <sayantn05@gmail.com>
Date: Wed, 8 Oct 2025 20:24:03 +0530
Subject: [PATCH 1830/1889] Port the Miri implementations of SIMD intrinsics to
 `rustc_const_eval`

---
 .../src/interpret/intrinsics.rs               | 104 ++-
 .../src/interpret/intrinsics/simd.rs          | 782 ++++++++++++++++++
 src/tools/miri/src/helpers.rs                 |  86 +-
 src/tools/miri/src/intrinsics/mod.rs          |   2 +-
 src/tools/miri/src/intrinsics/simd.rs         | 747 +----------------
 5 files changed, 898 insertions(+), 823 deletions(-)
 create mode 100644 compiler/rustc_const_eval/src/interpret/intrinsics/simd.rs

diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
index 785978b4d7111..968b5fc64c336 100644
--- a/compiler/rustc_const_eval/src/interpret/intrinsics.rs
+++ b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -2,6 +2,8 @@
 //! looking at their MIR. Intrinsics/functions supported here are shared by CTFE
 //! and miri.
 
+mod simd;
+
 use std::assert_matches::assert_matches;
 
 use rustc_abi::{FieldIdx, HasDataLayout, Size};
@@ -9,8 +11,8 @@ use rustc_apfloat::ieee::{Double, Half, Quad, Single};
 use rustc_middle::mir::interpret::{CTFE_ALLOC_SALT, read_target_uint, write_target_uint};
 use rustc_middle::mir::{self, BinOp, ConstValue, NonDivergingIntrinsic};
 use rustc_middle::ty::layout::TyAndLayout;
-use rustc_middle::ty::{Ty, TyCtxt};
-use rustc_middle::{bug, ty};
+use rustc_middle::ty::{FloatTy, Ty, TyCtxt};
+use rustc_middle::{bug, span_bug, ty};
 use rustc_span::{Symbol, sym};
 use tracing::trace;
 
@@ -121,6 +123,11 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
     ) -> InterpResult<'tcx, bool> {
         let instance_args = instance.args;
         let intrinsic_name = self.tcx.item_name(instance.def_id());
+
+        if intrinsic_name.as_str().starts_with("simd_") {
+            return self.eval_simd_intrinsic(intrinsic_name, instance_args, args, dest, ret);
+        }
+
         let tcx = self.tcx.tcx;
 
         match intrinsic_name {
@@ -454,37 +461,6 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 self.exact_div(&val, &size, dest)?;
             }
 
-            sym::simd_insert => {
-                let index = u64::from(self.read_scalar(&args[1])?.to_u32()?);
-                let elem = &args[2];
-                let (input, input_len) = self.project_to_simd(&args[0])?;
-                let (dest, dest_len) = self.project_to_simd(dest)?;
-                assert_eq!(input_len, dest_len, "Return vector length must match input length");
-                // Bounds are not checked by typeck so we have to do it ourselves.
-                if index >= input_len {
-                    throw_ub_format!(
-                        "`simd_insert` index {index} is out-of-bounds of vector with length {input_len}"
-                    );
-                }
-
-                for i in 0..dest_len {
-                    let place = self.project_index(&dest, i)?;
-                    let value =
-                        if i == index { elem.clone() } else { self.project_index(&input, i)? };
-                    self.copy_op(&value, &place)?;
-                }
-            }
-            sym::simd_extract => {
-                let index = u64::from(self.read_scalar(&args[1])?.to_u32()?);
-                let (input, input_len) = self.project_to_simd(&args[0])?;
-                // Bounds are not checked by typeck so we have to do it ourselves.
-                if index >= input_len {
-                    throw_ub_format!(
-                        "`simd_extract` index {index} is out-of-bounds of vector with length {input_len}"
-                    );
-                }
-                self.copy_op(&self.project_index(&input, index)?, dest)?;
-            }
             sym::black_box => {
                 // These just return their argument
                 self.copy_op(&args[0], dest)?;
@@ -1081,4 +1057,66 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         self.write_scalar(res, dest)?;
         interp_ok(())
     }
+
+    /// Converts `src` from floating point to integer type `dest_ty`
+    /// after rounding with mode `round`.
+    /// Returns `None` if `f` is NaN or out of range.
+    pub fn float_to_int_checked(
+        &self,
+        src: &ImmTy<'tcx, M::Provenance>,
+        cast_to: TyAndLayout<'tcx>,
+        round: rustc_apfloat::Round,
+    ) -> InterpResult<'tcx, Option<ImmTy<'tcx, M::Provenance>>> {
+        fn float_to_int_inner<'tcx, F: rustc_apfloat::Float, M: Machine<'tcx>>(
+            ecx: &InterpCx<'tcx, M>,
+            src: F,
+            cast_to: TyAndLayout<'tcx>,
+            round: rustc_apfloat::Round,
+        ) -> (Scalar<M::Provenance>, rustc_apfloat::Status) {
+            let int_size = cast_to.layout.size;
+            match cast_to.ty.kind() {
+                // Unsigned
+                ty::Uint(_) => {
+                    let res = src.to_u128_r(int_size.bits_usize(), round, &mut false);
+                    (Scalar::from_uint(res.value, int_size), res.status)
+                }
+                // Signed
+                ty::Int(_) => {
+                    let res = src.to_i128_r(int_size.bits_usize(), round, &mut false);
+                    (Scalar::from_int(res.value, int_size), res.status)
+                }
+                // Nothing else
+                _ => span_bug!(
+                    ecx.cur_span(),
+                    "attempted float-to-int conversion with non-int output type {}",
+                    cast_to.ty,
+                ),
+            }
+        }
+
+        let ty::Float(fty) = src.layout.ty.kind() else {
+            bug!("float_to_int_checked: non-float input type {}", src.layout.ty)
+        };
+
+        let (val, status) = match fty {
+            FloatTy::F16 => float_to_int_inner(self, src.to_scalar().to_f16()?, cast_to, round),
+            FloatTy::F32 => float_to_int_inner(self, src.to_scalar().to_f32()?, cast_to, round),
+            FloatTy::F64 => float_to_int_inner(self, src.to_scalar().to_f64()?, cast_to, round),
+            FloatTy::F128 => float_to_int_inner(self, src.to_scalar().to_f128()?, cast_to, round),
+        };
+
+        if status.intersects(
+            rustc_apfloat::Status::INVALID_OP
+                | rustc_apfloat::Status::OVERFLOW
+                | rustc_apfloat::Status::UNDERFLOW,
+        ) {
+            // Floating point value is NaN (flagged with INVALID_OP) or outside the range
+            // of values of the integer type (flagged with OVERFLOW or UNDERFLOW).
+            interp_ok(None)
+        } else {
+            // Floating point value can be represented by the integer type after rounding.
+            // The INEXACT flag is ignored on purpose to allow rounding.
+            interp_ok(Some(ImmTy::from_scalar(val, cast_to)))
+        }
+    }
 }
diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics/simd.rs b/compiler/rustc_const_eval/src/interpret/intrinsics/simd.rs
new file mode 100644
index 0000000000000..0dba66ae93721
--- /dev/null
+++ b/compiler/rustc_const_eval/src/interpret/intrinsics/simd.rs
@@ -0,0 +1,782 @@
+use either::Either;
+use rustc_abi::Endian;
+use rustc_apfloat::{Float, Round};
+use rustc_middle::mir::interpret::{InterpErrorKind, UndefinedBehaviorInfo};
+use rustc_middle::ty::FloatTy;
+use rustc_middle::{bug, err_ub_format, mir, span_bug, throw_unsup_format, ty};
+use rustc_span::{Symbol, sym};
+use tracing::trace;
+
+use super::{
+    ImmTy, InterpCx, InterpResult, Machine, OpTy, PlaceTy, Provenance, Scalar, Size, interp_ok,
+    throw_ub_format,
+};
+use crate::interpret::Writeable;
+
+#[derive(Copy, Clone)]
+pub(crate) enum MinMax {
+    Min,
+    Max,
+}
+
+impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
+    /// Returns `true` if emulation happened.
+    /// Here we implement the intrinsics that are common to all CTFE instances; individual machines can add their own
+    /// intrinsic handling.
+    pub fn eval_simd_intrinsic(
+        &mut self,
+        intrinsic_name: Symbol,
+        generic_args: ty::GenericArgsRef<'tcx>,
+        args: &[OpTy<'tcx, M::Provenance>],
+        dest: &PlaceTy<'tcx, M::Provenance>,
+        ret: Option<mir::BasicBlock>,
+    ) -> InterpResult<'tcx, bool> {
+        let dest = dest.force_mplace(self)?;
+
+        match intrinsic_name {
+            sym::simd_insert => {
+                let index = u64::from(self.read_scalar(&args[1])?.to_u32()?);
+                let elem = &args[2];
+                let (input, input_len) = self.project_to_simd(&args[0])?;
+                let (dest, dest_len) = self.project_to_simd(&dest)?;
+                assert_eq!(input_len, dest_len, "Return vector length must match input length");
+                // Bounds are not checked by typeck so we have to do it ourselves.
+                if index >= input_len {
+                    throw_ub_format!(
+                        "`simd_insert` index {index} is out-of-bounds of vector with length {input_len}"
+                    );
+                }
+
+                for i in 0..dest_len {
+                    let place = self.project_index(&dest, i)?;
+                    let value =
+                        if i == index { elem.clone() } else { self.project_index(&input, i)? };
+                    self.copy_op(&value, &place)?;
+                }
+            }
+            sym::simd_extract => {
+                let index = u64::from(self.read_scalar(&args[1])?.to_u32()?);
+                let (input, input_len) = self.project_to_simd(&args[0])?;
+                // Bounds are not checked by typeck so we have to do it ourselves.
+                if index >= input_len {
+                    throw_ub_format!(
+                        "`simd_extract` index {index} is out-of-bounds of vector with length {input_len}"
+                    );
+                }
+                self.copy_op(&self.project_index(&input, index)?, &dest)?;
+            }
+            sym::simd_neg
+            | sym::simd_fabs
+            | sym::simd_ceil
+            | sym::simd_floor
+            | sym::simd_round
+            | sym::simd_round_ties_even
+            | sym::simd_trunc
+            | sym::simd_ctlz
+            | sym::simd_ctpop
+            | sym::simd_cttz
+            | sym::simd_bswap
+            | sym::simd_bitreverse => {
+                let (op, op_len) = self.project_to_simd(&args[0])?;
+                let (dest, dest_len) = self.project_to_simd(&dest)?;
+
+                assert_eq!(dest_len, op_len);
+
+                #[derive(Copy, Clone)]
+                enum Op {
+                    MirOp(mir::UnOp),
+                    Abs,
+                    Round(rustc_apfloat::Round),
+                    Numeric(Symbol),
+                }
+                let which = match intrinsic_name {
+                    sym::simd_neg => Op::MirOp(mir::UnOp::Neg),
+                    sym::simd_fabs => Op::Abs,
+                    sym::simd_ceil => Op::Round(rustc_apfloat::Round::TowardPositive),
+                    sym::simd_floor => Op::Round(rustc_apfloat::Round::TowardNegative),
+                    sym::simd_round => Op::Round(rustc_apfloat::Round::NearestTiesToAway),
+                    sym::simd_round_ties_even => Op::Round(rustc_apfloat::Round::NearestTiesToEven),
+                    sym::simd_trunc => Op::Round(rustc_apfloat::Round::TowardZero),
+                    sym::simd_ctlz => Op::Numeric(sym::ctlz),
+                    sym::simd_ctpop => Op::Numeric(sym::ctpop),
+                    sym::simd_cttz => Op::Numeric(sym::cttz),
+                    sym::simd_bswap => Op::Numeric(sym::bswap),
+                    sym::simd_bitreverse => Op::Numeric(sym::bitreverse),
+                    _ => unreachable!(),
+                };
+
+                for i in 0..dest_len {
+                    let op = self.read_immediate(&self.project_index(&op, i)?)?;
+                    let dest = self.project_index(&dest, i)?;
+                    let val = match which {
+                        Op::MirOp(mir_op) => {
+                            // this already does NaN adjustments
+                            self.unary_op(mir_op, &op)?.to_scalar()
+                        }
+                        Op::Abs => {
+                            // Works for f32 and f64.
+                            let ty::Float(float_ty) = op.layout.ty.kind() else {
+                                span_bug!(
+                                    self.cur_span(),
+                                    "{} operand is not a float",
+                                    intrinsic_name
+                                )
+                            };
+                            let op = op.to_scalar();
+                            // "Bitwise" operation, no NaN adjustments
+                            match float_ty {
+                                FloatTy::F16 => unimplemented!("f16_f128"),
+                                FloatTy::F32 => Scalar::from_f32(op.to_f32()?.abs()),
+                                FloatTy::F64 => Scalar::from_f64(op.to_f64()?.abs()),
+                                FloatTy::F128 => unimplemented!("f16_f128"),
+                            }
+                        }
+                        Op::Round(rounding) => {
+                            let ty::Float(float_ty) = op.layout.ty.kind() else {
+                                span_bug!(
+                                    self.cur_span(),
+                                    "{} operand is not a float",
+                                    intrinsic_name
+                                )
+                            };
+                            match float_ty {
+                                FloatTy::F16 => unimplemented!("f16_f128"),
+                                FloatTy::F32 => {
+                                    let f = op.to_scalar().to_f32()?;
+                                    let res = f.round_to_integral(rounding).value;
+                                    let res = self.adjust_nan(res, &[f]);
+                                    Scalar::from_f32(res)
+                                }
+                                FloatTy::F64 => {
+                                    let f = op.to_scalar().to_f64()?;
+                                    let res = f.round_to_integral(rounding).value;
+                                    let res = self.adjust_nan(res, &[f]);
+                                    Scalar::from_f64(res)
+                                }
+                                FloatTy::F128 => unimplemented!("f16_f128"),
+                            }
+                        }
+                        Op::Numeric(name) => {
+                            self.numeric_intrinsic(name, op.to_scalar(), op.layout, op.layout)?
+                        }
+                    };
+                    self.write_scalar(val, &dest)?;
+                }
+            }
+            sym::simd_add
+            | sym::simd_sub
+            | sym::simd_mul
+            | sym::simd_div
+            | sym::simd_rem
+            | sym::simd_shl
+            | sym::simd_shr
+            | sym::simd_and
+            | sym::simd_or
+            | sym::simd_xor
+            | sym::simd_eq
+            | sym::simd_ne
+            | sym::simd_lt
+            | sym::simd_le
+            | sym::simd_gt
+            | sym::simd_ge
+            | sym::simd_fmax
+            | sym::simd_fmin
+            | sym::simd_saturating_add
+            | sym::simd_saturating_sub
+            | sym::simd_arith_offset => {
+                use mir::BinOp;
+
+                let (left, left_len) = self.project_to_simd(&args[0])?;
+                let (right, right_len) = self.project_to_simd(&args[1])?;
+                let (dest, dest_len) = self.project_to_simd(&dest)?;
+
+                assert_eq!(dest_len, left_len);
+                assert_eq!(dest_len, right_len);
+
+                enum Op {
+                    MirOp(BinOp),
+                    SaturatingOp(BinOp),
+                    FMinMax(MinMax),
+                    WrappingOffset,
+                }
+                let which = match intrinsic_name {
+                    sym::simd_add => Op::MirOp(BinOp::Add),
+                    sym::simd_sub => Op::MirOp(BinOp::Sub),
+                    sym::simd_mul => Op::MirOp(BinOp::Mul),
+                    sym::simd_div => Op::MirOp(BinOp::Div),
+                    sym::simd_rem => Op::MirOp(BinOp::Rem),
+                    sym::simd_shl => Op::MirOp(BinOp::ShlUnchecked),
+                    sym::simd_shr => Op::MirOp(BinOp::ShrUnchecked),
+                    sym::simd_and => Op::MirOp(BinOp::BitAnd),
+                    sym::simd_or => Op::MirOp(BinOp::BitOr),
+                    sym::simd_xor => Op::MirOp(BinOp::BitXor),
+                    sym::simd_eq => Op::MirOp(BinOp::Eq),
+                    sym::simd_ne => Op::MirOp(BinOp::Ne),
+                    sym::simd_lt => Op::MirOp(BinOp::Lt),
+                    sym::simd_le => Op::MirOp(BinOp::Le),
+                    sym::simd_gt => Op::MirOp(BinOp::Gt),
+                    sym::simd_ge => Op::MirOp(BinOp::Ge),
+                    sym::simd_fmax => Op::FMinMax(MinMax::Max),
+                    sym::simd_fmin => Op::FMinMax(MinMax::Min),
+                    sym::simd_saturating_add => Op::SaturatingOp(BinOp::Add),
+                    sym::simd_saturating_sub => Op::SaturatingOp(BinOp::Sub),
+                    sym::simd_arith_offset => Op::WrappingOffset,
+                    _ => unreachable!(),
+                };
+
+                for i in 0..dest_len {
+                    let left = self.read_immediate(&self.project_index(&left, i)?)?;
+                    let right = self.read_immediate(&self.project_index(&right, i)?)?;
+                    let dest = self.project_index(&dest, i)?;
+                    let val = match which {
+                        Op::MirOp(mir_op) => {
+                            // this does NaN adjustments.
+                            let val = self.binary_op(mir_op, &left, &right).map_err_kind(|kind| {
+                                match kind {
+                                    InterpErrorKind::UndefinedBehavior(UndefinedBehaviorInfo::ShiftOverflow { shift_amount, .. }) => {
+                                        // this resets the interpreter backtrace, but it's not worth avoiding that.
+                                        let shift_amount = match shift_amount {
+                                            Either::Left(v) => v.to_string(),
+                                            Either::Right(v) => v.to_string(),
+                                        };
+                                        err_ub_format!("overflowing shift by {shift_amount} in `{intrinsic_name}` in lane {i}")
+                                    }
+                                    kind => kind
+                                }
+                            })?;
+                            if matches!(
+                                mir_op,
+                                BinOp::Eq
+                                    | BinOp::Ne
+                                    | BinOp::Lt
+                                    | BinOp::Le
+                                    | BinOp::Gt
+                                    | BinOp::Ge
+                            ) {
+                                // Special handling for boolean-returning operations
+                                assert_eq!(val.layout.ty, self.tcx.types.bool);
+                                let val = val.to_scalar().to_bool().unwrap();
+                                bool_to_simd_element(val, dest.layout.size)
+                            } else {
+                                assert_ne!(val.layout.ty, self.tcx.types.bool);
+                                assert_eq!(val.layout.ty, dest.layout.ty);
+                                val.to_scalar()
+                            }
+                        }
+                        Op::SaturatingOp(mir_op) => self.saturating_arith(mir_op, &left, &right)?,
+                        Op::WrappingOffset => {
+                            let ptr = left.to_scalar().to_pointer(self)?;
+                            let offset_count = right.to_scalar().to_target_isize(self)?;
+                            let pointee_ty = left.layout.ty.builtin_deref(true).unwrap();
+
+                            let pointee_size =
+                                i64::try_from(self.layout_of(pointee_ty)?.size.bytes()).unwrap();
+                            let offset_bytes = offset_count.wrapping_mul(pointee_size);
+                            let offset_ptr = ptr.wrapping_signed_offset(offset_bytes, self);
+                            Scalar::from_maybe_pointer(offset_ptr, self)
+                        }
+                        Op::FMinMax(op) => self.fminmax_op(op, &left, &right)?,
+                    };
+                    self.write_scalar(val, &dest)?;
+                }
+            }
+            sym::simd_reduce_and
+            | sym::simd_reduce_or
+            | sym::simd_reduce_xor
+            | sym::simd_reduce_any
+            | sym::simd_reduce_all
+            | sym::simd_reduce_max
+            | sym::simd_reduce_min => {
+                use mir::BinOp;
+
+                let (op, op_len) = self.project_to_simd(&args[0])?;
+
+                let imm_from_bool = |b| {
+                    ImmTy::from_scalar(
+                        Scalar::from_bool(b),
+                        self.layout_of(self.tcx.types.bool).unwrap(),
+                    )
+                };
+
+                enum Op {
+                    MirOp(BinOp),
+                    MirOpBool(BinOp),
+                    MinMax(MinMax),
+                }
+                let which = match intrinsic_name {
+                    sym::simd_reduce_and => Op::MirOp(BinOp::BitAnd),
+                    sym::simd_reduce_or => Op::MirOp(BinOp::BitOr),
+                    sym::simd_reduce_xor => Op::MirOp(BinOp::BitXor),
+                    sym::simd_reduce_any => Op::MirOpBool(BinOp::BitOr),
+                    sym::simd_reduce_all => Op::MirOpBool(BinOp::BitAnd),
+                    sym::simd_reduce_max => Op::MinMax(MinMax::Max),
+                    sym::simd_reduce_min => Op::MinMax(MinMax::Min),
+                    _ => unreachable!(),
+                };
+
+                // Initialize with first lane, then proceed with the rest.
+                let mut res = self.read_immediate(&self.project_index(&op, 0)?)?;
+                if matches!(which, Op::MirOpBool(_)) {
+                    // Convert to `bool` scalar.
+                    res = imm_from_bool(simd_element_to_bool(res)?);
+                }
+                for i in 1..op_len {
+                    let op = self.read_immediate(&self.project_index(&op, i)?)?;
+                    res = match which {
+                        Op::MirOp(mir_op) => self.binary_op(mir_op, &res, &op)?,
+                        Op::MirOpBool(mir_op) => {
+                            let op = imm_from_bool(simd_element_to_bool(op)?);
+                            self.binary_op(mir_op, &res, &op)?
+                        }
+                        Op::MinMax(mmop) => {
+                            if matches!(res.layout.ty.kind(), ty::Float(_)) {
+                                ImmTy::from_scalar(self.fminmax_op(mmop, &res, &op)?, res.layout)
+                            } else {
+                                // Just boring integers, so NaNs to worry about
+                                let mirop = match mmop {
+                                    MinMax::Min => BinOp::Le,
+                                    MinMax::Max => BinOp::Ge,
+                                };
+                                if self.binary_op(mirop, &res, &op)?.to_scalar().to_bool()? {
+                                    res
+                                } else {
+                                    op
+                                }
+                            }
+                        }
+                    };
+                }
+                self.write_immediate(*res, &dest)?;
+            }
+            sym::simd_reduce_add_ordered | sym::simd_reduce_mul_ordered => {
+                use mir::BinOp;
+
+                let (op, op_len) = self.project_to_simd(&args[0])?;
+                let init = self.read_immediate(&args[1])?;
+
+                let mir_op = match intrinsic_name {
+                    sym::simd_reduce_add_ordered => BinOp::Add,
+                    sym::simd_reduce_mul_ordered => BinOp::Mul,
+                    _ => unreachable!(),
+                };
+
+                let mut res = init;
+                for i in 0..op_len {
+                    let op = self.read_immediate(&self.project_index(&op, i)?)?;
+                    res = self.binary_op(mir_op, &res, &op)?;
+                }
+                self.write_immediate(*res, &dest)?;
+            }
+            sym::simd_select => {
+                let (mask, mask_len) = self.project_to_simd(&args[0])?;
+                let (yes, yes_len) = self.project_to_simd(&args[1])?;
+                let (no, no_len) = self.project_to_simd(&args[2])?;
+                let (dest, dest_len) = self.project_to_simd(&dest)?;
+
+                assert_eq!(dest_len, mask_len);
+                assert_eq!(dest_len, yes_len);
+                assert_eq!(dest_len, no_len);
+
+                for i in 0..dest_len {
+                    let mask = self.read_immediate(&self.project_index(&mask, i)?)?;
+                    let yes = self.read_immediate(&self.project_index(&yes, i)?)?;
+                    let no = self.read_immediate(&self.project_index(&no, i)?)?;
+                    let dest = self.project_index(&dest, i)?;
+
+                    let val = if simd_element_to_bool(mask)? { yes } else { no };
+                    self.write_immediate(*val, &dest)?;
+                }
+            }
+            // Variant of `select` that takes a bitmask rather than a "vector of bool".
+            sym::simd_select_bitmask => {
+                let mask = &args[0];
+                let (yes, yes_len) = self.project_to_simd(&args[1])?;
+                let (no, no_len) = self.project_to_simd(&args[2])?;
+                let (dest, dest_len) = self.project_to_simd(&dest)?;
+                let bitmask_len = dest_len.next_multiple_of(8);
+                if bitmask_len > 64 {
+                    throw_unsup_format!(
+                        "simd_select_bitmask: vectors larger than 64 elements are currently not supported"
+                    );
+                }
+
+                assert_eq!(dest_len, yes_len);
+                assert_eq!(dest_len, no_len);
+
+                // Read the mask, either as an integer or as an array.
+                let mask: u64 = match mask.layout.ty.kind() {
+                    ty::Uint(_) => {
+                        // Any larger integer type is fine.
+                        assert!(mask.layout.size.bits() >= bitmask_len);
+                        self.read_scalar(mask)?.to_bits(mask.layout.size)?.try_into().unwrap()
+                    }
+                    ty::Array(elem, _len) if elem == &self.tcx.types.u8 => {
+                        // The array must have exactly the right size.
+                        assert_eq!(mask.layout.size.bits(), bitmask_len);
+                        // Read the raw bytes.
+                        let mask = mask.assert_mem_place(); // arrays cannot be immediate
+                        let mask_bytes =
+                            self.read_bytes_ptr_strip_provenance(mask.ptr(), mask.layout.size)?;
+                        // Turn them into a `u64` in the right way.
+                        let mask_size = mask.layout.size.bytes_usize();
+                        let mut mask_arr = [0u8; 8];
+                        match self.tcx.data_layout.endian {
+                            Endian::Little => {
+                                // Fill the first N bytes.
+                                mask_arr[..mask_size].copy_from_slice(mask_bytes);
+                                u64::from_le_bytes(mask_arr)
+                            }
+                            Endian::Big => {
+                                // Fill the last N bytes.
+                                let i = mask_arr.len().strict_sub(mask_size);
+                                mask_arr[i..].copy_from_slice(mask_bytes);
+                                u64::from_be_bytes(mask_arr)
+                            }
+                        }
+                    }
+                    _ => bug!("simd_select_bitmask: invalid mask type {}", mask.layout.ty),
+                };
+
+                let dest_len = u32::try_from(dest_len).unwrap();
+                for i in 0..dest_len {
+                    let bit_i = simd_bitmask_index(i, dest_len, self.tcx.data_layout.endian);
+                    let mask = mask & 1u64.strict_shl(bit_i);
+                    let yes = self.read_immediate(&self.project_index(&yes, i.into())?)?;
+                    let no = self.read_immediate(&self.project_index(&no, i.into())?)?;
+                    let dest = self.project_index(&dest, i.into())?;
+
+                    let val = if mask != 0 { yes } else { no };
+                    self.write_immediate(*val, &dest)?;
+                }
+                // The remaining bits of the mask are ignored.
+            }
+            // Converts a "vector of bool" into a bitmask.
+            sym::simd_bitmask => {
+                let (op, op_len) = self.project_to_simd(&args[0])?;
+                let bitmask_len = op_len.next_multiple_of(8);
+                if bitmask_len > 64 {
+                    throw_unsup_format!(
+                        "simd_bitmask: vectors larger than 64 elements are currently not supported"
+                    );
+                }
+
+                let op_len = u32::try_from(op_len).unwrap();
+                let mut res = 0u64;
+                for i in 0..op_len {
+                    let op = self.read_immediate(&self.project_index(&op, i.into())?)?;
+                    if simd_element_to_bool(op)? {
+                        let bit_i = simd_bitmask_index(i, op_len, self.tcx.data_layout.endian);
+                        res |= 1u64.strict_shl(bit_i);
+                    }
+                }
+                // Write the result, depending on the `dest` type.
+                // Returns either an unsigned integer or array of `u8`.
+                match dest.layout.ty.kind() {
+                    ty::Uint(_) => {
+                        // Any larger integer type is fine, it will be zero-extended.
+                        assert!(dest.layout.size.bits() >= bitmask_len);
+                        self.write_scalar(Scalar::from_uint(res, dest.layout.size), &dest)?;
+                    }
+                    ty::Array(elem, _len) if elem == &self.tcx.types.u8 => {
+                        // The array must have exactly the right size.
+                        assert_eq!(dest.layout.size.bits(), bitmask_len);
+                        // We have to write the result byte-for-byte.
+                        let res_size = dest.layout.size.bytes_usize();
+                        let res_bytes;
+                        let res_bytes_slice = match self.tcx.data_layout.endian {
+                            Endian::Little => {
+                                res_bytes = res.to_le_bytes();
+                                &res_bytes[..res_size] // take the first N bytes
+                            }
+                            Endian::Big => {
+                                res_bytes = res.to_be_bytes();
+                                &res_bytes[res_bytes.len().strict_sub(res_size)..] // take the last N bytes
+                            }
+                        };
+                        self.write_bytes_ptr(dest.ptr(), res_bytes_slice.iter().cloned())?;
+                    }
+                    _ => bug!("simd_bitmask: invalid return type {}", dest.layout.ty),
+                }
+            }
+            sym::simd_cast
+            | sym::simd_as
+            | sym::simd_cast_ptr
+            | sym::simd_with_exposed_provenance => {
+                let (op, op_len) = self.project_to_simd(&args[0])?;
+                let (dest, dest_len) = self.project_to_simd(&dest)?;
+
+                assert_eq!(dest_len, op_len);
+
+                let unsafe_cast = intrinsic_name == sym::simd_cast;
+                let safe_cast = intrinsic_name == sym::simd_as;
+                let ptr_cast = intrinsic_name == sym::simd_cast_ptr;
+                let from_exposed_cast = intrinsic_name == sym::simd_with_exposed_provenance;
+
+                for i in 0..dest_len {
+                    let op = self.read_immediate(&self.project_index(&op, i)?)?;
+                    let dest = self.project_index(&dest, i)?;
+
+                    let val = match (op.layout.ty.kind(), dest.layout.ty.kind()) {
+                        // Int-to-(int|float): always safe
+                        (ty::Int(_) | ty::Uint(_), ty::Int(_) | ty::Uint(_) | ty::Float(_))
+                            if safe_cast || unsafe_cast =>
+                            self.int_to_int_or_float(&op, dest.layout)?,
+                        // Float-to-float: always safe
+                        (ty::Float(_), ty::Float(_)) if safe_cast || unsafe_cast =>
+                            self.float_to_float_or_int(&op, dest.layout)?,
+                        // Float-to-int in safe mode
+                        (ty::Float(_), ty::Int(_) | ty::Uint(_)) if safe_cast =>
+                            self.float_to_float_or_int(&op, dest.layout)?,
+                        // Float-to-int in unchecked mode
+                        (ty::Float(_), ty::Int(_) | ty::Uint(_)) if unsafe_cast => {
+                            self.float_to_int_checked(&op, dest.layout, Round::TowardZero)?
+                                .ok_or_else(|| {
+                                    err_ub_format!(
+                                        "`simd_cast` intrinsic called on {op} which cannot be represented in target type `{:?}`",
+                                        dest.layout.ty
+                                    )
+                                })?
+                        }
+                        // Ptr-to-ptr cast
+                        (ty::RawPtr(..), ty::RawPtr(..)) if ptr_cast =>
+                            self.ptr_to_ptr(&op, dest.layout)?,
+                        // Int->Ptr casts
+                        (ty::Int(_) | ty::Uint(_), ty::RawPtr(..)) if from_exposed_cast =>
+                            self.pointer_with_exposed_provenance_cast(&op, dest.layout)?,
+                        // Error otherwise
+                        _ =>
+                            throw_unsup_format!(
+                                "Unsupported SIMD cast from element type {from_ty} to {to_ty}",
+                                from_ty = op.layout.ty,
+                                to_ty = dest.layout.ty,
+                            ),
+                    };
+                    self.write_immediate(*val, &dest)?;
+                }
+            }
+            sym::simd_shuffle_const_generic => {
+                let (left, left_len) = self.project_to_simd(&args[0])?;
+                let (right, right_len) = self.project_to_simd(&args[1])?;
+                let (dest, dest_len) = self.project_to_simd(&dest)?;
+
+                let index = generic_args[2].expect_const().to_value().valtree.unwrap_branch();
+                let index_len = index.len();
+
+                assert_eq!(left_len, right_len);
+                assert_eq!(u64::try_from(index_len).unwrap(), dest_len);
+
+                for i in 0..dest_len {
+                    let src_index: u64 =
+                        index[usize::try_from(i).unwrap()].unwrap_leaf().to_u32().into();
+                    let dest = self.project_index(&dest, i)?;
+
+                    let val = if src_index < left_len {
+                        self.read_immediate(&self.project_index(&left, src_index)?)?
+                    } else if src_index < left_len.strict_add(right_len) {
+                        let right_idx = src_index.strict_sub(left_len);
+                        self.read_immediate(&self.project_index(&right, right_idx)?)?
+                    } else {
+                        throw_ub_format!(
+                            "`simd_shuffle_const_generic` index {src_index} is out-of-bounds for 2 vectors with length {dest_len}"
+                        );
+                    };
+                    self.write_immediate(*val, &dest)?;
+                }
+            }
+            sym::simd_shuffle => {
+                let (left, left_len) = self.project_to_simd(&args[0])?;
+                let (right, right_len) = self.project_to_simd(&args[1])?;
+                let (index, index_len) = self.project_to_simd(&args[2])?;
+                let (dest, dest_len) = self.project_to_simd(&dest)?;
+
+                assert_eq!(left_len, right_len);
+                assert_eq!(index_len, dest_len);
+
+                for i in 0..dest_len {
+                    let src_index: u64 = self
+                        .read_immediate(&self.project_index(&index, i)?)?
+                        .to_scalar()
+                        .to_u32()?
+                        .into();
+                    let dest = self.project_index(&dest, i)?;
+
+                    let val = if src_index < left_len {
+                        self.read_immediate(&self.project_index(&left, src_index)?)?
+                    } else if src_index < left_len.strict_add(right_len) {
+                        let right_idx = src_index.strict_sub(left_len);
+                        self.read_immediate(&self.project_index(&right, right_idx)?)?
+                    } else {
+                        throw_ub_format!(
+                            "`simd_shuffle` index {src_index} is out-of-bounds for 2 vectors with length {dest_len}"
+                        );
+                    };
+                    self.write_immediate(*val, &dest)?;
+                }
+            }
+            sym::simd_gather => {
+                let (passthru, passthru_len) = self.project_to_simd(&args[0])?;
+                let (ptrs, ptrs_len) = self.project_to_simd(&args[1])?;
+                let (mask, mask_len) = self.project_to_simd(&args[2])?;
+                let (dest, dest_len) = self.project_to_simd(&dest)?;
+
+                assert_eq!(dest_len, passthru_len);
+                assert_eq!(dest_len, ptrs_len);
+                assert_eq!(dest_len, mask_len);
+
+                for i in 0..dest_len {
+                    let passthru = self.read_immediate(&self.project_index(&passthru, i)?)?;
+                    let ptr = self.read_immediate(&self.project_index(&ptrs, i)?)?;
+                    let mask = self.read_immediate(&self.project_index(&mask, i)?)?;
+                    let dest = self.project_index(&dest, i)?;
+
+                    let val = if simd_element_to_bool(mask)? {
+                        let place = self.deref_pointer(&ptr)?;
+                        self.read_immediate(&place)?
+                    } else {
+                        passthru
+                    };
+                    self.write_immediate(*val, &dest)?;
+                }
+            }
+            sym::simd_scatter => {
+                let (value, value_len) = self.project_to_simd(&args[0])?;
+                let (ptrs, ptrs_len) = self.project_to_simd(&args[1])?;
+                let (mask, mask_len) = self.project_to_simd(&args[2])?;
+
+                assert_eq!(ptrs_len, value_len);
+                assert_eq!(ptrs_len, mask_len);
+
+                for i in 0..ptrs_len {
+                    let value = self.read_immediate(&self.project_index(&value, i)?)?;
+                    let ptr = self.read_immediate(&self.project_index(&ptrs, i)?)?;
+                    let mask = self.read_immediate(&self.project_index(&mask, i)?)?;
+
+                    if simd_element_to_bool(mask)? {
+                        let place = self.deref_pointer(&ptr)?;
+                        self.write_immediate(*value, &place)?;
+                    }
+                }
+            }
+            sym::simd_masked_load => {
+                let (mask, mask_len) = self.project_to_simd(&args[0])?;
+                let ptr = self.read_pointer(&args[1])?;
+                let (default, default_len) = self.project_to_simd(&args[2])?;
+                let (dest, dest_len) = self.project_to_simd(&dest)?;
+
+                assert_eq!(dest_len, mask_len);
+                assert_eq!(dest_len, default_len);
+
+                for i in 0..dest_len {
+                    let mask = self.read_immediate(&self.project_index(&mask, i)?)?;
+                    let default = self.read_immediate(&self.project_index(&default, i)?)?;
+                    let dest = self.project_index(&dest, i)?;
+
+                    let val = if simd_element_to_bool(mask)? {
+                        // Size * u64 is implemented as always checked
+                        let ptr = ptr.wrapping_offset(dest.layout.size * i, self);
+                        let place = self.ptr_to_mplace(ptr, dest.layout);
+                        self.read_immediate(&place)?
+                    } else {
+                        default
+                    };
+                    self.write_immediate(*val, &dest)?;
+                }
+            }
+            sym::simd_masked_store => {
+                let (mask, mask_len) = self.project_to_simd(&args[0])?;
+                let ptr = self.read_pointer(&args[1])?;
+                let (vals, vals_len) = self.project_to_simd(&args[2])?;
+
+                assert_eq!(mask_len, vals_len);
+
+                for i in 0..vals_len {
+                    let mask = self.read_immediate(&self.project_index(&mask, i)?)?;
+                    let val = self.read_immediate(&self.project_index(&vals, i)?)?;
+
+                    if simd_element_to_bool(mask)? {
+                        // Size * u64 is implemented as always checked
+                        let ptr = ptr.wrapping_offset(val.layout.size * i, self);
+                        let place = self.ptr_to_mplace(ptr, val.layout);
+                        self.write_immediate(*val, &place)?
+                    };
+                }
+            }
+
+            // Unsupported intrinsic: skip the return_to_block below.
+            _ => return interp_ok(false),
+        }
+
+        trace!("{:?}", self.dump_place(&dest.clone().into()));
+        self.return_to_block(ret)?;
+        interp_ok(true)
+    }
+
+    fn fminmax_op<Prov: Provenance>(
+        &self,
+        op: MinMax,
+        left: &ImmTy<'tcx, Prov>,
+        right: &ImmTy<'tcx, Prov>,
+    ) -> InterpResult<'tcx, Scalar<Prov>> {
+        assert_eq!(left.layout.ty, right.layout.ty);
+        let ty::Float(float_ty) = left.layout.ty.kind() else {
+            bug!("fmax operand is not a float")
+        };
+        let left = left.to_scalar();
+        let right = right.to_scalar();
+        interp_ok(match float_ty {
+            FloatTy::F16 => unimplemented!("f16_f128"),
+            FloatTy::F32 => {
+                let left = left.to_f32()?;
+                let right = right.to_f32()?;
+                let res = match op {
+                    MinMax::Min => left.min(right),
+                    MinMax::Max => left.max(right),
+                };
+                let res = self.adjust_nan(res, &[left, right]);
+                Scalar::from_f32(res)
+            }
+            FloatTy::F64 => {
+                let left = left.to_f64()?;
+                let right = right.to_f64()?;
+                let res = match op {
+                    MinMax::Min => left.min(right),
+                    MinMax::Max => left.max(right),
+                };
+                let res = self.adjust_nan(res, &[left, right]);
+                Scalar::from_f64(res)
+            }
+            FloatTy::F128 => unimplemented!("f16_f128"),
+        })
+    }
+}
+
+fn simd_bitmask_index(idx: u32, vec_len: u32, endianness: Endian) -> u32 {
+    assert!(idx < vec_len);
+    match endianness {
+        Endian::Little => idx,
+        #[expect(clippy::arithmetic_side_effects)] // idx < vec_len
+        Endian::Big => vec_len - 1 - idx, // reverse order of bits
+    }
+}
+
+fn bool_to_simd_element<Prov: Provenance>(b: bool, size: Size) -> Scalar<Prov> {
+    // SIMD uses all-1 as pattern for "true". In two's complement,
+    // -1 has all its bits set to one and `from_int` will truncate or
+    // sign-extend it to `size` as required.
+    let val = if b { -1 } else { 0 };
+    Scalar::from_int(val, size)
+}
+
+fn simd_element_to_bool<Prov: Provenance>(elem: ImmTy<'_, Prov>) -> InterpResult<'_, bool> {
+    assert!(
+        matches!(elem.layout.ty.kind(), ty::Int(_) | ty::Uint(_)),
+        "SIMD mask element type must be an integer, but this is `{}`",
+        elem.layout.ty
+    );
+    let val = elem.to_scalar().to_int(elem.layout.size)?;
+    interp_ok(match val {
+        0 => false,
+        -1 => true,
+        _ => throw_ub_format!("each element of a SIMD mask must be all-0-bits or all-1-bits"),
+    })
+}
diff --git a/src/tools/miri/src/helpers.rs b/src/tools/miri/src/helpers.rs
index e0c077e99319a..d6646f9586aa6 100644
--- a/src/tools/miri/src/helpers.rs
+++ b/src/tools/miri/src/helpers.rs
@@ -5,7 +5,6 @@ use std::{cmp, iter};
 use rand::RngCore;
 use rustc_abi::{Align, ExternAbi, FieldIdx, FieldsShape, Size, Variants};
 use rustc_apfloat::Float;
-use rustc_apfloat::ieee::{Double, Half, Quad, Single};
 use rustc_hir::Safety;
 use rustc_hir::def::{DefKind, Namespace};
 use rustc_hir::def_id::{CRATE_DEF_INDEX, CrateNum, DefId, LOCAL_CRATE};
@@ -14,7 +13,7 @@ use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use rustc_middle::middle::dependency_format::Linkage;
 use rustc_middle::middle::exported_symbols::ExportedSymbol;
 use rustc_middle::ty::layout::{LayoutOf, MaybeResult, TyAndLayout};
-use rustc_middle::ty::{self, FloatTy, IntTy, Ty, TyCtxt, UintTy};
+use rustc_middle::ty::{self, IntTy, Ty, TyCtxt, UintTy};
 use rustc_session::config::CrateType;
 use rustc_span::{Span, Symbol};
 use rustc_symbol_mangling::mangle_internal_symbol;
@@ -961,75 +960,6 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         this.alloc_mark_immutable(provenance.get_alloc_id().unwrap()).unwrap();
     }
 
-    /// Converts `src` from floating point to integer type `dest_ty`
-    /// after rounding with mode `round`.
-    /// Returns `None` if `f` is NaN or out of range.
-    fn float_to_int_checked(
-        &self,
-        src: &ImmTy<'tcx>,
-        cast_to: TyAndLayout<'tcx>,
-        round: rustc_apfloat::Round,
-    ) -> InterpResult<'tcx, Option<ImmTy<'tcx>>> {
-        let this = self.eval_context_ref();
-
-        fn float_to_int_inner<'tcx, F: rustc_apfloat::Float>(
-            ecx: &MiriInterpCx<'tcx>,
-            src: F,
-            cast_to: TyAndLayout<'tcx>,
-            round: rustc_apfloat::Round,
-        ) -> (Scalar, rustc_apfloat::Status) {
-            let int_size = cast_to.layout.size;
-            match cast_to.ty.kind() {
-                // Unsigned
-                ty::Uint(_) => {
-                    let res = src.to_u128_r(int_size.bits_usize(), round, &mut false);
-                    (Scalar::from_uint(res.value, int_size), res.status)
-                }
-                // Signed
-                ty::Int(_) => {
-                    let res = src.to_i128_r(int_size.bits_usize(), round, &mut false);
-                    (Scalar::from_int(res.value, int_size), res.status)
-                }
-                // Nothing else
-                _ =>
-                    span_bug!(
-                        ecx.cur_span(),
-                        "attempted float-to-int conversion with non-int output type {}",
-                        cast_to.ty,
-                    ),
-            }
-        }
-
-        let ty::Float(fty) = src.layout.ty.kind() else {
-            bug!("float_to_int_checked: non-float input type {}", src.layout.ty)
-        };
-
-        let (val, status) = match fty {
-            FloatTy::F16 =>
-                float_to_int_inner::<Half>(this, src.to_scalar().to_f16()?, cast_to, round),
-            FloatTy::F32 =>
-                float_to_int_inner::<Single>(this, src.to_scalar().to_f32()?, cast_to, round),
-            FloatTy::F64 =>
-                float_to_int_inner::<Double>(this, src.to_scalar().to_f64()?, cast_to, round),
-            FloatTy::F128 =>
-                float_to_int_inner::<Quad>(this, src.to_scalar().to_f128()?, cast_to, round),
-        };
-
-        if status.intersects(
-            rustc_apfloat::Status::INVALID_OP
-                | rustc_apfloat::Status::OVERFLOW
-                | rustc_apfloat::Status::UNDERFLOW,
-        ) {
-            // Floating point value is NaN (flagged with INVALID_OP) or outside the range
-            // of values of the integer type (flagged with OVERFLOW or UNDERFLOW).
-            interp_ok(None)
-        } else {
-            // Floating point value can be represented by the integer type after rounding.
-            // The INEXACT flag is ignored on purpose to allow rounding.
-            interp_ok(Some(ImmTy::from_scalar(val, cast_to)))
-        }
-    }
-
     /// Returns an integer type that is twice wide as `ty`
     fn get_twice_wide_int_ty(&self, ty: Ty<'tcx>) -> Ty<'tcx> {
         let this = self.eval_context_ref();
@@ -1194,20 +1124,6 @@ pub(crate) fn bool_to_simd_element(b: bool, size: Size) -> Scalar {
     Scalar::from_int(val, size)
 }
 
-pub(crate) fn simd_element_to_bool(elem: ImmTy<'_>) -> InterpResult<'_, bool> {
-    assert!(
-        matches!(elem.layout.ty.kind(), ty::Int(_) | ty::Uint(_)),
-        "SIMD mask element type must be an integer, but this is `{}`",
-        elem.layout.ty
-    );
-    let val = elem.to_scalar().to_int(elem.layout.size)?;
-    interp_ok(match val {
-        0 => false,
-        -1 => true,
-        _ => throw_ub_format!("each element of a SIMD mask must be all-0-bits or all-1-bits"),
-    })
-}
-
 /// Check whether an operation that writes to a target buffer was successful.
 /// Accordingly select return value.
 /// Local helper function to be used in Windows shims.
diff --git a/src/tools/miri/src/intrinsics/mod.rs b/src/tools/miri/src/intrinsics/mod.rs
index a80b939d84ea9..f09fc6c187896 100644
--- a/src/tools/miri/src/intrinsics/mod.rs
+++ b/src/tools/miri/src/intrinsics/mod.rs
@@ -118,7 +118,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             return this.emulate_atomic_intrinsic(name, generic_args, args, dest);
         }
         if let Some(name) = intrinsic_name.strip_prefix("simd_") {
-            return this.emulate_simd_intrinsic(name, generic_args, args, dest);
+            return this.emulate_simd_intrinsic(name, args, dest);
         }
 
         match intrinsic_name {
diff --git a/src/tools/miri/src/intrinsics/simd.rs b/src/tools/miri/src/intrinsics/simd.rs
index b26516c0ff0e8..5f75657e0a220 100644
--- a/src/tools/miri/src/intrinsics/simd.rs
+++ b/src/tools/miri/src/intrinsics/simd.rs
@@ -1,21 +1,12 @@
-use either::Either;
 use rand::Rng;
-use rustc_abi::{Endian, HasDataLayout};
-use rustc_apfloat::{Float, Round};
+use rustc_apfloat::Float;
 use rustc_middle::ty::FloatTy;
-use rustc_middle::{mir, ty};
-use rustc_span::{Symbol, sym};
+use rustc_middle::ty;
 
 use super::check_intrinsic_arg_count;
-use crate::helpers::{ToHost, ToSoft, bool_to_simd_element, simd_element_to_bool};
+use crate::helpers::{ToHost, ToSoft};
 use crate::*;
 
-#[derive(Copy, Clone)]
-pub(crate) enum MinMax {
-    Min,
-    Max,
-}
-
 impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
 pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     /// Calls the simd intrinsic `intrinsic`; the `simd_` prefix has already been removed.
@@ -23,20 +14,12 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     fn emulate_simd_intrinsic(
         &mut self,
         intrinsic_name: &str,
-        generic_args: ty::GenericArgsRef<'tcx>,
         args: &[OpTy<'tcx>],
         dest: &MPlaceTy<'tcx>,
     ) -> InterpResult<'tcx, EmulateItemResult> {
         let this = self.eval_context_mut();
         match intrinsic_name {
             #[rustfmt::skip]
-            | "neg"
-            | "fabs"
-            | "ceil"
-            | "floor"
-            | "round"
-            | "round_ties_even"
-            | "trunc"
             | "fsqrt"
             | "fsin"
             | "fcos"
@@ -45,11 +28,6 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             | "flog"
             | "flog2"
             | "flog10"
-            | "ctlz"
-            | "ctpop"
-            | "cttz"
-            | "bswap"
-            | "bitreverse"
             => {
                 let [op] = check_intrinsic_arg_count(args)?;
                 let (op, op_len) = this.project_to_simd(op)?;
@@ -57,235 +35,51 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
                 assert_eq!(dest_len, op_len);
 
-                #[derive(Copy, Clone)]
-                enum Op<'a> {
-                    MirOp(mir::UnOp),
-                    Abs,
-                    Round(rustc_apfloat::Round),
-                    Numeric(Symbol),
-                    HostOp(&'a str),
-                }
-                let which = match intrinsic_name {
-                    "neg" => Op::MirOp(mir::UnOp::Neg),
-                    "fabs" => Op::Abs,
-                    "ceil" => Op::Round(rustc_apfloat::Round::TowardPositive),
-                    "floor" => Op::Round(rustc_apfloat::Round::TowardNegative),
-                    "round" => Op::Round(rustc_apfloat::Round::NearestTiesToAway),
-                    "round_ties_even" => Op::Round(rustc_apfloat::Round::NearestTiesToEven),
-                    "trunc" => Op::Round(rustc_apfloat::Round::TowardZero),
-                    "ctlz" => Op::Numeric(sym::ctlz),
-                    "ctpop" => Op::Numeric(sym::ctpop),
-                    "cttz" => Op::Numeric(sym::cttz),
-                    "bswap" => Op::Numeric(sym::bswap),
-                    "bitreverse" => Op::Numeric(sym::bitreverse),
-                    _ => Op::HostOp(intrinsic_name),
-                };
-
                 for i in 0..dest_len {
                     let op = this.read_immediate(&this.project_index(&op, i)?)?;
                     let dest = this.project_index(&dest, i)?;
-                    let val = match which {
-                        Op::MirOp(mir_op) => {
-                            // This already does NaN adjustments
-                            this.unary_op(mir_op, &op)?.to_scalar()
-                        }
-                        Op::Abs => {
-                            // Works for f32 and f64.
-                            let ty::Float(float_ty) = op.layout.ty.kind() else {
-                                span_bug!(this.cur_span(), "{} operand is not a float", intrinsic_name)
-                            };
-                            let op = op.to_scalar();
-                            // "Bitwise" operation, no NaN adjustments
-                            match float_ty {
-                                FloatTy::F16 => unimplemented!("f16_f128"),
-                                FloatTy::F32 => Scalar::from_f32(op.to_f32()?.abs()),
-                                FloatTy::F64 => Scalar::from_f64(op.to_f64()?.abs()),
-                                FloatTy::F128 => unimplemented!("f16_f128"),
-                            }
-                        }
-                        Op::HostOp(host_op) => {
-                            let ty::Float(float_ty) = op.layout.ty.kind() else {
-                                span_bug!(this.cur_span(), "{} operand is not a float", intrinsic_name)
+                    let ty::Float(float_ty) = op.layout.ty.kind() else {
+                        span_bug!(this.cur_span(), "{} operand is not a float", intrinsic_name)
+                    };
+                    // Using host floats except for sqrt (but it's fine, these operations do not
+                    // have guaranteed precision).
+                    let val = match float_ty {
+                        FloatTy::F16 => unimplemented!("f16_f128"),
+                        FloatTy::F32 => {
+                            let f = op.to_scalar().to_f32()?;
+                            let res = match intrinsic_name {
+                                "fsqrt" => math::sqrt(f),
+                                "fsin" => f.to_host().sin().to_soft(),
+                                "fcos" => f.to_host().cos().to_soft(),
+                                "fexp" => f.to_host().exp().to_soft(),
+                                "fexp2" => f.to_host().exp2().to_soft(),
+                                "flog" => f.to_host().ln().to_soft(),
+                                "flog2" => f.to_host().log2().to_soft(),
+                                "flog10" => f.to_host().log10().to_soft(),
+                                _ => bug!(),
                             };
-                            // Using host floats except for sqrt (but it's fine, these operations do not
-                            // have guaranteed precision).
-                            match float_ty {
-                                FloatTy::F16 => unimplemented!("f16_f128"),
-                                FloatTy::F32 => {
-                                    let f = op.to_scalar().to_f32()?;
-                                    let res = match host_op {
-                                        "fsqrt" => math::sqrt(f),
-                                        "fsin" => f.to_host().sin().to_soft(),
-                                        "fcos" => f.to_host().cos().to_soft(),
-                                        "fexp" => f.to_host().exp().to_soft(),
-                                        "fexp2" => f.to_host().exp2().to_soft(),
-                                        "flog" => f.to_host().ln().to_soft(),
-                                        "flog2" => f.to_host().log2().to_soft(),
-                                        "flog10" => f.to_host().log10().to_soft(),
-                                        _ => bug!(),
-                                    };
-                                    let res = this.adjust_nan(res, &[f]);
-                                    Scalar::from(res)
-                                }
-                                FloatTy::F64 => {
-                                    let f = op.to_scalar().to_f64()?;
-                                    let res = match host_op {
-                                        "fsqrt" => math::sqrt(f),
-                                        "fsin" => f.to_host().sin().to_soft(),
-                                        "fcos" => f.to_host().cos().to_soft(),
-                                        "fexp" => f.to_host().exp().to_soft(),
-                                        "fexp2" => f.to_host().exp2().to_soft(),
-                                        "flog" => f.to_host().ln().to_soft(),
-                                        "flog2" => f.to_host().log2().to_soft(),
-                                        "flog10" => f.to_host().log10().to_soft(),
-                                        _ => bug!(),
-                                    };
-                                    let res = this.adjust_nan(res, &[f]);
-                                    Scalar::from(res)
-                                }
-                                FloatTy::F128 => unimplemented!("f16_f128"),
-                            }
+                            let res = this.adjust_nan(res, &[f]);
+                            Scalar::from(res)
                         }
-                        Op::Round(rounding) => {
-                            let ty::Float(float_ty) = op.layout.ty.kind() else {
-                                span_bug!(this.cur_span(), "{} operand is not a float", intrinsic_name)
+                        FloatTy::F64 => {
+                            let f = op.to_scalar().to_f64()?;
+                            let res = match intrinsic_name {
+                                "fsqrt" => math::sqrt(f),
+                                "fsin" => f.to_host().sin().to_soft(),
+                                "fcos" => f.to_host().cos().to_soft(),
+                                "fexp" => f.to_host().exp().to_soft(),
+                                "fexp2" => f.to_host().exp2().to_soft(),
+                                "flog" => f.to_host().ln().to_soft(),
+                                "flog2" => f.to_host().log2().to_soft(),
+                                "flog10" => f.to_host().log10().to_soft(),
+                                _ => bug!(),
                             };
-                            match float_ty {
-                                FloatTy::F16 => unimplemented!("f16_f128"),
-                                FloatTy::F32 => {
-                                    let f = op.to_scalar().to_f32()?;
-                                    let res = f.round_to_integral(rounding).value;
-                                    let res = this.adjust_nan(res, &[f]);
-                                    Scalar::from_f32(res)
-                                }
-                                FloatTy::F64 => {
-                                    let f = op.to_scalar().to_f64()?;
-                                    let res = f.round_to_integral(rounding).value;
-                                    let res = this.adjust_nan(res, &[f]);
-                                    Scalar::from_f64(res)
-                                }
-                                FloatTy::F128 => unimplemented!("f16_f128"),
-                            }
-                        }
-                        Op::Numeric(name) => {
-                            this.numeric_intrinsic(name, op.to_scalar(), op.layout, op.layout)?
-                        }
-                    };
-                    this.write_scalar(val, &dest)?;
-                }
-            }
-            #[rustfmt::skip]
-            | "add"
-            | "sub"
-            | "mul"
-            | "div"
-            | "rem"
-            | "shl"
-            | "shr"
-            | "and"
-            | "or"
-            | "xor"
-            | "eq"
-            | "ne"
-            | "lt"
-            | "le"
-            | "gt"
-            | "ge"
-            | "fmax"
-            | "fmin"
-            | "saturating_add"
-            | "saturating_sub"
-            | "arith_offset"
-            => {
-                use mir::BinOp;
-
-                let [left, right] = check_intrinsic_arg_count(args)?;
-                let (left, left_len) = this.project_to_simd(left)?;
-                let (right, right_len) = this.project_to_simd(right)?;
-                let (dest, dest_len) = this.project_to_simd(dest)?;
-
-                assert_eq!(dest_len, left_len);
-                assert_eq!(dest_len, right_len);
-
-                enum Op {
-                    MirOp(BinOp),
-                    SaturatingOp(BinOp),
-                    FMinMax(MinMax),
-                    WrappingOffset,
-                }
-                let which = match intrinsic_name {
-                    "add" => Op::MirOp(BinOp::Add),
-                    "sub" => Op::MirOp(BinOp::Sub),
-                    "mul" => Op::MirOp(BinOp::Mul),
-                    "div" => Op::MirOp(BinOp::Div),
-                    "rem" => Op::MirOp(BinOp::Rem),
-                    "shl" => Op::MirOp(BinOp::ShlUnchecked),
-                    "shr" => Op::MirOp(BinOp::ShrUnchecked),
-                    "and" => Op::MirOp(BinOp::BitAnd),
-                    "or" => Op::MirOp(BinOp::BitOr),
-                    "xor" => Op::MirOp(BinOp::BitXor),
-                    "eq" => Op::MirOp(BinOp::Eq),
-                    "ne" => Op::MirOp(BinOp::Ne),
-                    "lt" => Op::MirOp(BinOp::Lt),
-                    "le" => Op::MirOp(BinOp::Le),
-                    "gt" => Op::MirOp(BinOp::Gt),
-                    "ge" => Op::MirOp(BinOp::Ge),
-                    "fmax" => Op::FMinMax(MinMax::Max),
-                    "fmin" => Op::FMinMax(MinMax::Min),
-                    "saturating_add" => Op::SaturatingOp(BinOp::Add),
-                    "saturating_sub" => Op::SaturatingOp(BinOp::Sub),
-                    "arith_offset" => Op::WrappingOffset,
-                    _ => unreachable!(),
-                };
-
-                for i in 0..dest_len {
-                    let left = this.read_immediate(&this.project_index(&left, i)?)?;
-                    let right = this.read_immediate(&this.project_index(&right, i)?)?;
-                    let dest = this.project_index(&dest, i)?;
-                    let val = match which {
-                        Op::MirOp(mir_op) => {
-                            // This does NaN adjustments.
-                            let val = this.binary_op(mir_op, &left, &right).map_err_kind(|kind| {
-                                match kind {
-                                    InterpErrorKind::UndefinedBehavior(UndefinedBehaviorInfo::ShiftOverflow { shift_amount, .. }) => {
-                                        // This resets the interpreter backtrace, but it's not worth avoiding that.
-                                        let shift_amount = match shift_amount {
-                                            Either::Left(v) => v.to_string(),
-                                            Either::Right(v) => v.to_string(),
-                                        };
-                                        err_ub_format!("overflowing shift by {shift_amount} in `simd_{intrinsic_name}` in lane {i}")
-                                    }
-                                    kind => kind
-                                }
-                            })?;
-                            if matches!(mir_op, BinOp::Eq | BinOp::Ne | BinOp::Lt | BinOp::Le | BinOp::Gt | BinOp::Ge) {
-                                // Special handling for boolean-returning operations
-                                assert_eq!(val.layout.ty, this.tcx.types.bool);
-                                let val = val.to_scalar().to_bool().unwrap();
-                                bool_to_simd_element(val, dest.layout.size)
-                            } else {
-                                assert_ne!(val.layout.ty, this.tcx.types.bool);
-                                assert_eq!(val.layout.ty, dest.layout.ty);
-                                val.to_scalar()
-                            }
-                        }
-                        Op::SaturatingOp(mir_op) => {
-                            this.saturating_arith(mir_op, &left, &right)?
-                        }
-                        Op::WrappingOffset => {
-                            let ptr = left.to_scalar().to_pointer(this)?;
-                            let offset_count = right.to_scalar().to_target_isize(this)?;
-                            let pointee_ty = left.layout.ty.builtin_deref(true).unwrap();
-
-                            let pointee_size = i64::try_from(this.layout_of(pointee_ty)?.size.bytes()).unwrap();
-                            let offset_bytes = offset_count.wrapping_mul(pointee_size);
-                            let offset_ptr = ptr.wrapping_signed_offset(offset_bytes, this);
-                            Scalar::from_maybe_pointer(offset_ptr, this)
-                        }
-                        Op::FMinMax(op) => {
-                            this.fminmax_op(op, &left, &right)?
+                            let res = this.adjust_nan(res, &[f]);
+                            Scalar::from(res)
                         }
+                        FloatTy::F128 => unimplemented!("f16_f128"),
                     };
+                    
                     this.write_scalar(val, &dest)?;
                 }
             }
@@ -345,279 +139,25 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     this.write_scalar(val, &dest)?;
                 }
             }
-            #[rustfmt::skip]
-            | "reduce_and"
-            | "reduce_or"
-            | "reduce_xor"
-            | "reduce_any"
-            | "reduce_all"
-            | "reduce_max"
-            | "reduce_min" => {
-                use mir::BinOp;
-
-                let [op] = check_intrinsic_arg_count(args)?;
-                let (op, op_len) = this.project_to_simd(op)?;
-
-                let imm_from_bool =
-                    |b| ImmTy::from_scalar(Scalar::from_bool(b), this.machine.layouts.bool);
-
-                enum Op {
-                    MirOp(BinOp),
-                    MirOpBool(BinOp),
-                    MinMax(MinMax),
-                }
-                let which = match intrinsic_name {
-                    "reduce_and" => Op::MirOp(BinOp::BitAnd),
-                    "reduce_or" => Op::MirOp(BinOp::BitOr),
-                    "reduce_xor" => Op::MirOp(BinOp::BitXor),
-                    "reduce_any" => Op::MirOpBool(BinOp::BitOr),
-                    "reduce_all" => Op::MirOpBool(BinOp::BitAnd),
-                    "reduce_max" => Op::MinMax(MinMax::Max),
-                    "reduce_min" => Op::MinMax(MinMax::Min),
-                    _ => unreachable!(),
-                };
-
-                // Initialize with first lane, then proceed with the rest.
-                let mut res = this.read_immediate(&this.project_index(&op, 0)?)?;
-                if matches!(which, Op::MirOpBool(_)) {
-                    // Convert to `bool` scalar.
-                    res = imm_from_bool(simd_element_to_bool(res)?);
-                }
-                for i in 1..op_len {
-                    let op = this.read_immediate(&this.project_index(&op, i)?)?;
-                    res = match which {
-                        Op::MirOp(mir_op) => {
-                            this.binary_op(mir_op, &res, &op)?
-                        }
-                        Op::MirOpBool(mir_op) => {
-                            let op = imm_from_bool(simd_element_to_bool(op)?);
-                            this.binary_op(mir_op, &res, &op)?
-                        }
-                        Op::MinMax(mmop) => {
-                            if matches!(res.layout.ty.kind(), ty::Float(_)) {
-                                ImmTy::from_scalar(this.fminmax_op(mmop, &res, &op)?, res.layout)
-                            } else {
-                                // Just boring integers, so NaNs to worry about
-                                let mirop = match mmop {
-                                    MinMax::Min => BinOp::Le,
-                                    MinMax::Max => BinOp::Ge,
-                                };
-                                if this.binary_op(mirop, &res, &op)?.to_scalar().to_bool()? {
-                                    res
-                                } else {
-                                    op
-                                }
-                            }
-                        }
-                    };
-                }
-                this.write_immediate(*res, dest)?;
-            }
-            #[rustfmt::skip]
-            | "reduce_add_ordered"
-            | "reduce_mul_ordered" => {
-                use mir::BinOp;
-
-                let [op, init] = check_intrinsic_arg_count(args)?;
-                let (op, op_len) = this.project_to_simd(op)?;
-                let init = this.read_immediate(init)?;
-
-                let mir_op = match intrinsic_name {
-                    "reduce_add_ordered" => BinOp::Add,
-                    "reduce_mul_ordered" => BinOp::Mul,
-                    _ => unreachable!(),
-                };
-
-                let mut res = init;
-                for i in 0..op_len {
-                    let op = this.read_immediate(&this.project_index(&op, i)?)?;
-                    res = this.binary_op(mir_op, &res, &op)?;
-                }
-                this.write_immediate(*res, dest)?;
-            }
-            "select" => {
-                let [mask, yes, no] = check_intrinsic_arg_count(args)?;
-                let (mask, mask_len) = this.project_to_simd(mask)?;
-                let (yes, yes_len) = this.project_to_simd(yes)?;
-                let (no, no_len) = this.project_to_simd(no)?;
-                let (dest, dest_len) = this.project_to_simd(dest)?;
-
-                assert_eq!(dest_len, mask_len);
-                assert_eq!(dest_len, yes_len);
-                assert_eq!(dest_len, no_len);
-
-                for i in 0..dest_len {
-                    let mask = this.read_immediate(&this.project_index(&mask, i)?)?;
-                    let yes = this.read_immediate(&this.project_index(&yes, i)?)?;
-                    let no = this.read_immediate(&this.project_index(&no, i)?)?;
-                    let dest = this.project_index(&dest, i)?;
-
-                    let val = if simd_element_to_bool(mask)? { yes } else { no };
-                    this.write_immediate(*val, &dest)?;
-                }
-            }
-            // Variant of `select` that takes a bitmask rather than a "vector of bool".
-            "select_bitmask" => {
-                let [mask, yes, no] = check_intrinsic_arg_count(args)?;
-                let (yes, yes_len) = this.project_to_simd(yes)?;
-                let (no, no_len) = this.project_to_simd(no)?;
-                let (dest, dest_len) = this.project_to_simd(dest)?;
-                let bitmask_len = dest_len.next_multiple_of(8);
-                if bitmask_len > 64 {
-                    throw_unsup_format!(
-                        "simd_select_bitmask: vectors larger than 64 elements are currently not supported"
-                    );
-                }
-
-                assert_eq!(dest_len, yes_len);
-                assert_eq!(dest_len, no_len);
-
-                // Read the mask, either as an integer or as an array.
-                let mask: u64 = match mask.layout.ty.kind() {
-                    ty::Uint(_) => {
-                        // Any larger integer type is fine.
-                        assert!(mask.layout.size.bits() >= bitmask_len);
-                        this.read_scalar(mask)?.to_bits(mask.layout.size)?.try_into().unwrap()
-                    }
-                    ty::Array(elem, _len) if elem == &this.tcx.types.u8 => {
-                        // The array must have exactly the right size.
-                        assert_eq!(mask.layout.size.bits(), bitmask_len);
-                        // Read the raw bytes.
-                        let mask = mask.assert_mem_place(); // arrays cannot be immediate
-                        let mask_bytes =
-                            this.read_bytes_ptr_strip_provenance(mask.ptr(), mask.layout.size)?;
-                        // Turn them into a `u64` in the right way.
-                        let mask_size = mask.layout.size.bytes_usize();
-                        let mut mask_arr = [0u8; 8];
-                        match this.data_layout().endian {
-                            Endian::Little => {
-                                // Fill the first N bytes.
-                                mask_arr[..mask_size].copy_from_slice(mask_bytes);
-                                u64::from_le_bytes(mask_arr)
-                            }
-                            Endian::Big => {
-                                // Fill the last N bytes.
-                                let i = mask_arr.len().strict_sub(mask_size);
-                                mask_arr[i..].copy_from_slice(mask_bytes);
-                                u64::from_be_bytes(mask_arr)
-                            }
-                        }
-                    }
-                    _ => bug!("simd_select_bitmask: invalid mask type {}", mask.layout.ty),
-                };
-
-                let dest_len = u32::try_from(dest_len).unwrap();
-                for i in 0..dest_len {
-                    let bit_i = simd_bitmask_index(i, dest_len, this.data_layout().endian);
-                    let mask = mask & 1u64.strict_shl(bit_i);
-                    let yes = this.read_immediate(&this.project_index(&yes, i.into())?)?;
-                    let no = this.read_immediate(&this.project_index(&no, i.into())?)?;
-                    let dest = this.project_index(&dest, i.into())?;
-
-                    let val = if mask != 0 { yes } else { no };
-                    this.write_immediate(*val, &dest)?;
-                }
-                // The remaining bits of the mask are ignored.
-            }
-            // Converts a "vector of bool" into a bitmask.
-            "bitmask" => {
-                let [op] = check_intrinsic_arg_count(args)?;
-                let (op, op_len) = this.project_to_simd(op)?;
-                let bitmask_len = op_len.next_multiple_of(8);
-                if bitmask_len > 64 {
-                    throw_unsup_format!(
-                        "simd_bitmask: vectors larger than 64 elements are currently not supported"
-                    );
-                }
-
-                let op_len = u32::try_from(op_len).unwrap();
-                let mut res = 0u64;
-                for i in 0..op_len {
-                    let op = this.read_immediate(&this.project_index(&op, i.into())?)?;
-                    if simd_element_to_bool(op)? {
-                        let bit_i = simd_bitmask_index(i, op_len, this.data_layout().endian);
-                        res |= 1u64.strict_shl(bit_i);
-                    }
-                }
-                // Write the result, depending on the `dest` type.
-                // Returns either an unsigned integer or array of `u8`.
-                match dest.layout.ty.kind() {
-                    ty::Uint(_) => {
-                        // Any larger integer type is fine, it will be zero-extended.
-                        assert!(dest.layout.size.bits() >= bitmask_len);
-                        this.write_int(res, dest)?;
-                    }
-                    ty::Array(elem, _len) if elem == &this.tcx.types.u8 => {
-                        // The array must have exactly the right size.
-                        assert_eq!(dest.layout.size.bits(), bitmask_len);
-                        // We have to write the result byte-for-byte.
-                        let res_size = dest.layout.size.bytes_usize();
-                        let res_bytes;
-                        let res_bytes_slice = match this.data_layout().endian {
-                            Endian::Little => {
-                                res_bytes = res.to_le_bytes();
-                                &res_bytes[..res_size] // take the first N bytes
-                            }
-                            Endian::Big => {
-                                res_bytes = res.to_be_bytes();
-                                &res_bytes[res_bytes.len().strict_sub(res_size)..] // take the last N bytes
-                            }
-                        };
-                        this.write_bytes_ptr(dest.ptr(), res_bytes_slice.iter().cloned())?;
-                    }
-                    _ => bug!("simd_bitmask: invalid return type {}", dest.layout.ty),
-                }
-            }
-            "cast" | "as" | "cast_ptr" | "expose_provenance" | "with_exposed_provenance" => {
+            "expose_provenance" => {
                 let [op] = check_intrinsic_arg_count(args)?;
                 let (op, op_len) = this.project_to_simd(op)?;
                 let (dest, dest_len) = this.project_to_simd(dest)?;
 
                 assert_eq!(dest_len, op_len);
 
-                let unsafe_cast = intrinsic_name == "cast";
-                let safe_cast = intrinsic_name == "as";
-                let ptr_cast = intrinsic_name == "cast_ptr";
-                let expose_cast = intrinsic_name == "expose_provenance";
-                let from_exposed_cast = intrinsic_name == "with_exposed_provenance";
-
                 for i in 0..dest_len {
                     let op = this.read_immediate(&this.project_index(&op, i)?)?;
                     let dest = this.project_index(&dest, i)?;
 
                     let val = match (op.layout.ty.kind(), dest.layout.ty.kind()) {
-                        // Int-to-(int|float): always safe
-                        (ty::Int(_) | ty::Uint(_), ty::Int(_) | ty::Uint(_) | ty::Float(_))
-                            if safe_cast || unsafe_cast =>
-                            this.int_to_int_or_float(&op, dest.layout)?,
-                        // Float-to-float: always safe
-                        (ty::Float(_), ty::Float(_)) if safe_cast || unsafe_cast =>
-                            this.float_to_float_or_int(&op, dest.layout)?,
-                        // Float-to-int in safe mode
-                        (ty::Float(_), ty::Int(_) | ty::Uint(_)) if safe_cast =>
-                            this.float_to_float_or_int(&op, dest.layout)?,
-                        // Float-to-int in unchecked mode
-                        (ty::Float(_), ty::Int(_) | ty::Uint(_)) if unsafe_cast => {
-                            this.float_to_int_checked(&op, dest.layout, Round::TowardZero)?
-                                .ok_or_else(|| {
-                                    err_ub_format!(
-                                        "`simd_cast` intrinsic called on {op} which cannot be represented in target type `{:?}`",
-                                        dest.layout.ty
-                                    )
-                                })?
-                        }
-                        // Ptr-to-ptr cast
-                        (ty::RawPtr(..), ty::RawPtr(..)) if ptr_cast =>
-                            this.ptr_to_ptr(&op, dest.layout)?,
                         // Ptr/Int casts
-                        (ty::RawPtr(..), ty::Int(_) | ty::Uint(_)) if expose_cast =>
+                        (ty::RawPtr(..), ty::Int(_) | ty::Uint(_)) =>
                             this.pointer_expose_provenance_cast(&op, dest.layout)?,
-                        (ty::Int(_) | ty::Uint(_), ty::RawPtr(..)) if from_exposed_cast =>
-                            this.pointer_with_exposed_provenance_cast(&op, dest.layout)?,
                         // Error otherwise
                         _ =>
                             throw_unsup_format!(
-                                "Unsupported SIMD cast from element type {from_ty} to {to_ty}",
+                                "Unsupported `simd_expose_provenance` from element type {from_ty} to {to_ty}",
                                 from_ty = op.layout.ty,
                                 to_ty = dest.layout.ty,
                             ),
@@ -625,210 +165,9 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     this.write_immediate(*val, &dest)?;
                 }
             }
-            "shuffle_const_generic" => {
-                let [left, right] = check_intrinsic_arg_count(args)?;
-                let (left, left_len) = this.project_to_simd(left)?;
-                let (right, right_len) = this.project_to_simd(right)?;
-                let (dest, dest_len) = this.project_to_simd(dest)?;
-
-                let index = generic_args[2].expect_const().to_value().valtree.unwrap_branch();
-                let index_len = index.len();
-
-                assert_eq!(left_len, right_len);
-                assert_eq!(u64::try_from(index_len).unwrap(), dest_len);
-
-                for i in 0..dest_len {
-                    let src_index: u64 =
-                        index[usize::try_from(i).unwrap()].unwrap_leaf().to_u32().into();
-                    let dest = this.project_index(&dest, i)?;
-
-                    let val = if src_index < left_len {
-                        this.read_immediate(&this.project_index(&left, src_index)?)?
-                    } else if src_index < left_len.strict_add(right_len) {
-                        let right_idx = src_index.strict_sub(left_len);
-                        this.read_immediate(&this.project_index(&right, right_idx)?)?
-                    } else {
-                        throw_ub_format!(
-                            "`simd_shuffle_const_generic` index {src_index} is out-of-bounds for 2 vectors with length {dest_len}"
-                        );
-                    };
-                    this.write_immediate(*val, &dest)?;
-                }
-            }
-            "shuffle" => {
-                let [left, right, index] = check_intrinsic_arg_count(args)?;
-                let (left, left_len) = this.project_to_simd(left)?;
-                let (right, right_len) = this.project_to_simd(right)?;
-                let (index, index_len) = this.project_to_simd(index)?;
-                let (dest, dest_len) = this.project_to_simd(dest)?;
-
-                assert_eq!(left_len, right_len);
-                assert_eq!(index_len, dest_len);
-
-                for i in 0..dest_len {
-                    let src_index: u64 = this
-                        .read_immediate(&this.project_index(&index, i)?)?
-                        .to_scalar()
-                        .to_u32()?
-                        .into();
-                    let dest = this.project_index(&dest, i)?;
-
-                    let val = if src_index < left_len {
-                        this.read_immediate(&this.project_index(&left, src_index)?)?
-                    } else if src_index < left_len.strict_add(right_len) {
-                        let right_idx = src_index.strict_sub(left_len);
-                        this.read_immediate(&this.project_index(&right, right_idx)?)?
-                    } else {
-                        throw_ub_format!(
-                            "`simd_shuffle` index {src_index} is out-of-bounds for 2 vectors with length {dest_len}"
-                        );
-                    };
-                    this.write_immediate(*val, &dest)?;
-                }
-            }
-            "gather" => {
-                let [passthru, ptrs, mask] = check_intrinsic_arg_count(args)?;
-                let (passthru, passthru_len) = this.project_to_simd(passthru)?;
-                let (ptrs, ptrs_len) = this.project_to_simd(ptrs)?;
-                let (mask, mask_len) = this.project_to_simd(mask)?;
-                let (dest, dest_len) = this.project_to_simd(dest)?;
-
-                assert_eq!(dest_len, passthru_len);
-                assert_eq!(dest_len, ptrs_len);
-                assert_eq!(dest_len, mask_len);
-
-                for i in 0..dest_len {
-                    let passthru = this.read_immediate(&this.project_index(&passthru, i)?)?;
-                    let ptr = this.read_immediate(&this.project_index(&ptrs, i)?)?;
-                    let mask = this.read_immediate(&this.project_index(&mask, i)?)?;
-                    let dest = this.project_index(&dest, i)?;
-
-                    let val = if simd_element_to_bool(mask)? {
-                        let place = this.deref_pointer(&ptr)?;
-                        this.read_immediate(&place)?
-                    } else {
-                        passthru
-                    };
-                    this.write_immediate(*val, &dest)?;
-                }
-            }
-            "scatter" => {
-                let [value, ptrs, mask] = check_intrinsic_arg_count(args)?;
-                let (value, value_len) = this.project_to_simd(value)?;
-                let (ptrs, ptrs_len) = this.project_to_simd(ptrs)?;
-                let (mask, mask_len) = this.project_to_simd(mask)?;
-
-                assert_eq!(ptrs_len, value_len);
-                assert_eq!(ptrs_len, mask_len);
-
-                for i in 0..ptrs_len {
-                    let value = this.read_immediate(&this.project_index(&value, i)?)?;
-                    let ptr = this.read_immediate(&this.project_index(&ptrs, i)?)?;
-                    let mask = this.read_immediate(&this.project_index(&mask, i)?)?;
-
-                    if simd_element_to_bool(mask)? {
-                        let place = this.deref_pointer(&ptr)?;
-                        this.write_immediate(*value, &place)?;
-                    }
-                }
-            }
-            "masked_load" => {
-                let [mask, ptr, default] = check_intrinsic_arg_count(args)?;
-                let (mask, mask_len) = this.project_to_simd(mask)?;
-                let ptr = this.read_pointer(ptr)?;
-                let (default, default_len) = this.project_to_simd(default)?;
-                let (dest, dest_len) = this.project_to_simd(dest)?;
-
-                assert_eq!(dest_len, mask_len);
-                assert_eq!(dest_len, default_len);
-
-                for i in 0..dest_len {
-                    let mask = this.read_immediate(&this.project_index(&mask, i)?)?;
-                    let default = this.read_immediate(&this.project_index(&default, i)?)?;
-                    let dest = this.project_index(&dest, i)?;
-
-                    let val = if simd_element_to_bool(mask)? {
-                        // Size * u64 is implemented as always checked
-                        let ptr = ptr.wrapping_offset(dest.layout.size * i, this);
-                        let place = this.ptr_to_mplace(ptr, dest.layout);
-                        this.read_immediate(&place)?
-                    } else {
-                        default
-                    };
-                    this.write_immediate(*val, &dest)?;
-                }
-            }
-            "masked_store" => {
-                let [mask, ptr, vals] = check_intrinsic_arg_count(args)?;
-                let (mask, mask_len) = this.project_to_simd(mask)?;
-                let ptr = this.read_pointer(ptr)?;
-                let (vals, vals_len) = this.project_to_simd(vals)?;
-
-                assert_eq!(mask_len, vals_len);
-
-                for i in 0..vals_len {
-                    let mask = this.read_immediate(&this.project_index(&mask, i)?)?;
-                    let val = this.read_immediate(&this.project_index(&vals, i)?)?;
-
-                    if simd_element_to_bool(mask)? {
-                        // Size * u64 is implemented as always checked
-                        let ptr = ptr.wrapping_offset(val.layout.size * i, this);
-                        let place = this.ptr_to_mplace(ptr, val.layout);
-                        this.write_immediate(*val, &place)?
-                    };
-                }
-            }
 
             _ => return interp_ok(EmulateItemResult::NotSupported),
         }
         interp_ok(EmulateItemResult::NeedsReturn)
     }
-
-    fn fminmax_op(
-        &self,
-        op: MinMax,
-        left: &ImmTy<'tcx>,
-        right: &ImmTy<'tcx>,
-    ) -> InterpResult<'tcx, Scalar> {
-        let this = self.eval_context_ref();
-        assert_eq!(left.layout.ty, right.layout.ty);
-        let ty::Float(float_ty) = left.layout.ty.kind() else {
-            bug!("fmax operand is not a float")
-        };
-        let left = left.to_scalar();
-        let right = right.to_scalar();
-        interp_ok(match float_ty {
-            FloatTy::F16 => unimplemented!("f16_f128"),
-            FloatTy::F32 => {
-                let left = left.to_f32()?;
-                let right = right.to_f32()?;
-                let res = match op {
-                    MinMax::Min => left.min(right),
-                    MinMax::Max => left.max(right),
-                };
-                let res = this.adjust_nan(res, &[left, right]);
-                Scalar::from_f32(res)
-            }
-            FloatTy::F64 => {
-                let left = left.to_f64()?;
-                let right = right.to_f64()?;
-                let res = match op {
-                    MinMax::Min => left.min(right),
-                    MinMax::Max => left.max(right),
-                };
-                let res = this.adjust_nan(res, &[left, right]);
-                Scalar::from_f64(res)
-            }
-            FloatTy::F128 => unimplemented!("f16_f128"),
-        })
-    }
-}
-
-fn simd_bitmask_index(idx: u32, vec_len: u32, endianness: Endian) -> u32 {
-    assert!(idx < vec_len);
-    match endianness {
-        Endian::Little => idx,
-        #[expect(clippy::arithmetic_side_effects)] // idx < vec_len
-        Endian::Big => vec_len - 1 - idx, // reverse order of bits
-    }
 }

From 730221e654d2d017465807f16cddef4a88b72d7c Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Wed, 8 Oct 2025 09:39:11 +0200
Subject: [PATCH 1831/1889] Fix double error for `#[no_mangle]` on closures

---
 .../src/attributes/codegen_attrs.rs                 |  1 +
 compiler/rustc_codegen_ssa/messages.ftl             |  2 --
 compiler/rustc_codegen_ssa/src/codegen_attrs.rs     | 13 ++++---------
 compiler/rustc_codegen_ssa/src/errors.rs            |  8 --------
 tests/ui/attributes/no-mangle-closure.rs            |  2 +-
 tests/ui/attributes/no-mangle-closure.stderr        |  4 +++-
 6 files changed, 9 insertions(+), 21 deletions(-)

diff --git a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
index 7978bf28214cf..0f92968385f6f 100644
--- a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
@@ -362,6 +362,7 @@ impl<S: Stage> NoArgsAttributeParser<S> for NoMangleParser {
         Allow(Target::Static),
         Allow(Target::Method(MethodKind::Inherent)),
         Allow(Target::Method(MethodKind::TraitImpl)),
+        Error(Target::Closure),
     ]);
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::NoMangle;
 }
diff --git a/compiler/rustc_codegen_ssa/messages.ftl b/compiler/rustc_codegen_ssa/messages.ftl
index 97ff04f66daec..e321b0773ec39 100644
--- a/compiler/rustc_codegen_ssa/messages.ftl
+++ b/compiler/rustc_codegen_ssa/messages.ftl
@@ -223,8 +223,6 @@ codegen_ssa_multiple_main_functions = entry symbol `main` declared multiple time
 
 codegen_ssa_no_field = no field `{$name}`
 
-codegen_ssa_no_mangle_nameless = `#[no_mangle]` cannot be used on {$definition} as it has no name
-
 codegen_ssa_no_module_named =
     no module named `{$user_path}` (mangled: {$cgu_name}). available modules: {$cgu_names}
 
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
index 2c7643e46ceaa..e8c8729f597b9 100644
--- a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
+++ b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -19,7 +19,6 @@ use rustc_span::{Ident, Span, sym};
 use rustc_target::spec::SanitizerSet;
 
 use crate::errors;
-use crate::errors::NoMangleNameless;
 use crate::target_features::{
     check_target_feature_trait_unsafe, check_tied_features, from_target_feature_attr,
 };
@@ -182,14 +181,10 @@ fn process_builtin_attrs(
                     if tcx.opt_item_name(did.to_def_id()).is_some() {
                         codegen_fn_attrs.flags |= CodegenFnAttrFlags::NO_MANGLE;
                     } else {
-                        tcx.dcx().emit_err(NoMangleNameless {
-                            span: *attr_span,
-                            definition: format!(
-                                "{} {}",
-                                tcx.def_descr_article(did.to_def_id()),
-                                tcx.def_descr(did.to_def_id())
-                            ),
-                        });
+                        tcx.dcx().span_delayed_bug(
+                            *attr_span,
+                            "no_mangle should be on a named function",
+                        );
                     }
                 }
                 AttributeKind::Optimize(optimize, _) => codegen_fn_attrs.optimize = *optimize,
diff --git a/compiler/rustc_codegen_ssa/src/errors.rs b/compiler/rustc_codegen_ssa/src/errors.rs
index d5c30c5c7a6b0..2dd7c6fa7c080 100644
--- a/compiler/rustc_codegen_ssa/src/errors.rs
+++ b/compiler/rustc_codegen_ssa/src/errors.rs
@@ -1284,14 +1284,6 @@ impl<G: EmissionGuarantee> Diagnostic<'_, G> for TargetFeatureDisableOrEnable<'_
     }
 }
 
-#[derive(Diagnostic)]
-#[diag(codegen_ssa_no_mangle_nameless)]
-pub(crate) struct NoMangleNameless {
-    #[primary_span]
-    pub span: Span,
-    pub definition: String,
-}
-
 #[derive(Diagnostic)]
 #[diag(codegen_ssa_feature_not_valid)]
 pub(crate) struct FeatureNotValid<'a> {
diff --git a/tests/ui/attributes/no-mangle-closure.rs b/tests/ui/attributes/no-mangle-closure.rs
index c76baa27f38a0..05dcbf8e5bed7 100644
--- a/tests/ui/attributes/no-mangle-closure.rs
+++ b/tests/ui/attributes/no-mangle-closure.rs
@@ -7,5 +7,5 @@ pub struct S([usize; 8]);
 
 pub fn outer_function(x: S, y: S) -> usize {
     (#[no_mangle] || y.0[0])()
-    //~^ ERROR `#[no_mangle]` cannot be used on a closure as it has no name
+    //~^ ERROR `#[no_mangle]` attribute cannot be used on closures
 }
diff --git a/tests/ui/attributes/no-mangle-closure.stderr b/tests/ui/attributes/no-mangle-closure.stderr
index c183783493bdb..f81e65d926752 100644
--- a/tests/ui/attributes/no-mangle-closure.stderr
+++ b/tests/ui/attributes/no-mangle-closure.stderr
@@ -1,8 +1,10 @@
-error: `#[no_mangle]` cannot be used on a closure as it has no name
+error: `#[no_mangle]` attribute cannot be used on closures
   --> $DIR/no-mangle-closure.rs:9:6
    |
 LL |     (#[no_mangle] || y.0[0])()
    |      ^^^^^^^^^^^^
+   |
+   = help: `#[no_mangle]` can be applied to functions, methods, and statics
 
 error: aborting due to 1 previous error
 

From c050bfbf6f1c932ae955a81a0571a0fa354442fc Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Wed, 8 Oct 2025 10:10:20 +0200
Subject: [PATCH 1832/1889] Fix double error for `#[no_mangle]` on consts

---
 .../src/attributes/codegen_attrs.rs             |  2 ++
 .../rustc_attr_parsing/src/target_checking.rs   | 17 +++++++++++++++--
 tests/ui/issues/issue-45562.fixed               |  2 ++
 tests/ui/issues/issue-45562.rs                  |  2 ++
 tests/ui/issues/issue-45562.stderr              |  2 +-
 5 files changed, 22 insertions(+), 3 deletions(-)

diff --git a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
index 0f92968385f6f..f09b02251e4d0 100644
--- a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
@@ -6,6 +6,7 @@ use crate::session_diagnostics::{
     NakedFunctionIncompatibleAttribute, NullOnExport, NullOnObjcClass, NullOnObjcSelector,
     ObjcClassExpectedStringLiteral, ObjcSelectorExpectedStringLiteral,
 };
+use crate::target_checking::Policy::AllowSilent;
 
 pub(crate) struct OptimizeParser;
 
@@ -362,6 +363,7 @@ impl<S: Stage> NoArgsAttributeParser<S> for NoMangleParser {
         Allow(Target::Static),
         Allow(Target::Method(MethodKind::Inherent)),
         Allow(Target::Method(MethodKind::TraitImpl)),
+        AllowSilent(Target::Const), // Handled in the `InvalidNoMangleItems` pass
         Error(Target::Closure),
     ]);
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::NoMangle;
diff --git a/compiler/rustc_attr_parsing/src/target_checking.rs b/compiler/rustc_attr_parsing/src/target_checking.rs
index d28f43943ba84..fabd364d3d7f8 100644
--- a/compiler/rustc_attr_parsing/src/target_checking.rs
+++ b/compiler/rustc_attr_parsing/src/target_checking.rs
@@ -31,7 +31,9 @@ impl AllowedTargets {
     pub(crate) fn is_allowed(&self, target: Target) -> AllowedResult {
         match self {
             AllowedTargets::AllowList(list) => {
-                if list.contains(&Policy::Allow(target)) {
+                if list.contains(&Policy::Allow(target))
+                    || list.contains(&Policy::AllowSilent(target))
+                {
                     AllowedResult::Allowed
                 } else if list.contains(&Policy::Warn(target)) {
                     AllowedResult::Warn
@@ -40,7 +42,9 @@ impl AllowedTargets {
                 }
             }
             AllowedTargets::AllowListWarnRest(list) => {
-                if list.contains(&Policy::Allow(target)) {
+                if list.contains(&Policy::Allow(target))
+                    || list.contains(&Policy::AllowSilent(target))
+                {
                     AllowedResult::Allowed
                 } else if list.contains(&Policy::Error(target)) {
                     AllowedResult::Error
@@ -61,6 +65,7 @@ impl AllowedTargets {
         .iter()
         .filter_map(|target| match target {
             Policy::Allow(target) => Some(*target),
+            Policy::AllowSilent(_) => None, // Not listed in possible targets
             Policy::Warn(_) => None,
             Policy::Error(_) => None,
         })
@@ -68,10 +73,18 @@ impl AllowedTargets {
     }
 }
 
+/// This policy determines what diagnostics should be emitted based on the `Target` of the attribute.
 #[derive(Debug, Eq, PartialEq)]
 pub(crate) enum Policy {
+    /// A target that is allowed.
     Allow(Target),
+    /// A target that is allowed and not listed in the possible targets.
+    /// This is useful if the target is checked elsewhere.
+    AllowSilent(Target),
+    /// Emits a FCW on this target.
+    /// This is useful if the target was previously allowed but should not be.
     Warn(Target),
+    /// Emits an error on this target.
     Error(Target),
 }
 
diff --git a/tests/ui/issues/issue-45562.fixed b/tests/ui/issues/issue-45562.fixed
index 8dcdd3a541ce4..529b5bd744e03 100644
--- a/tests/ui/issues/issue-45562.fixed
+++ b/tests/ui/issues/issue-45562.fixed
@@ -1,5 +1,7 @@
 //@ run-rustfix
 
+#![deny(unused_attributes)]
+
 #[no_mangle] pub static RAH: usize = 5;
 //~^ ERROR const items should never be `#[no_mangle]`
 
diff --git a/tests/ui/issues/issue-45562.rs b/tests/ui/issues/issue-45562.rs
index 08f6c8046dce4..7c30a967c7848 100644
--- a/tests/ui/issues/issue-45562.rs
+++ b/tests/ui/issues/issue-45562.rs
@@ -1,5 +1,7 @@
 //@ run-rustfix
 
+#![deny(unused_attributes)]
+
 #[no_mangle] pub const RAH: usize = 5;
 //~^ ERROR const items should never be `#[no_mangle]`
 
diff --git a/tests/ui/issues/issue-45562.stderr b/tests/ui/issues/issue-45562.stderr
index 6fae86f9f31ca..55d35f76a0198 100644
--- a/tests/ui/issues/issue-45562.stderr
+++ b/tests/ui/issues/issue-45562.stderr
@@ -1,5 +1,5 @@
 error: const items should never be `#[no_mangle]`
-  --> $DIR/issue-45562.rs:3:14
+  --> $DIR/issue-45562.rs:5:14
    |
 LL | #[no_mangle] pub const RAH: usize = 5;
    |              ---------^^^^^^^^^^^^^^^^

From 1654cce2108dd73173c5bd978ba6523d5a1834d7 Mon Sep 17 00:00:00 2001
From: yukang <moorekang@gmail.com>
Date: Thu, 9 Oct 2025 01:24:55 +0800
Subject: [PATCH 1833/1889] prefer to use repeat_n over repeat and take

---
 compiler/rustc_builtin_macros/src/asm.rs             |  4 ++--
 compiler/rustc_codegen_cranelift/src/constant.rs     |  2 +-
 compiler/rustc_const_eval/src/const_eval/error.rs    |  2 +-
 .../rustc_const_eval/src/interpret/intrinsics.rs     |  2 +-
 .../src/util/check_validity_requirement.rs           |  2 +-
 compiler/rustc_hir_analysis/src/collect.rs           |  2 +-
 .../src/errors/wrong_number_of_generic_args.rs       |  9 +++------
 compiler/rustc_hir_typeck/src/expr.rs                |  2 +-
 compiler/rustc_lint/src/if_let_rescope.rs            |  4 ++--
 compiler/rustc_middle/src/values.rs                  |  2 +-
 compiler/rustc_mir_build/src/check_tail_calls.rs     |  2 +-
 compiler/rustc_passes/src/check_attr.rs              |  2 +-
 .../rustc_query_system/src/dep_graph/serialized.rs   |  4 ++--
 compiler/rustc_resolve/src/late/diagnostics.rs       | 12 +++---------
 .../infer/nice_region_error/static_impl_trait.rs     |  2 +-
 compiler/rustc_transmute/src/layout/tree.rs          |  3 +--
 16 files changed, 23 insertions(+), 33 deletions(-)

diff --git a/compiler/rustc_builtin_macros/src/asm.rs b/compiler/rustc_builtin_macros/src/asm.rs
index ae62b5ea2a097..971b68d14757a 100644
--- a/compiler/rustc_builtin_macros/src/asm.rs
+++ b/compiler/rustc_builtin_macros/src/asm.rs
@@ -368,7 +368,7 @@ fn expand_preparsed_asm(
         if args.options.contains(ast::InlineAsmOptions::RAW) {
             template.push(ast::InlineAsmTemplatePiece::String(template_str.to_string().into()));
             let template_num_lines = 1 + template_str.matches('\n').count();
-            line_spans.extend(std::iter::repeat(template_sp).take(template_num_lines));
+            line_spans.extend(std::iter::repeat_n(template_sp, template_num_lines));
             continue;
         }
 
@@ -523,7 +523,7 @@ fn expand_preparsed_asm(
 
         if parser.line_spans.is_empty() {
             let template_num_lines = 1 + template_str.matches('\n').count();
-            line_spans.extend(std::iter::repeat(template_sp).take(template_num_lines));
+            line_spans.extend(std::iter::repeat_n(template_sp, template_num_lines));
         } else {
             line_spans.extend(
                 parser
diff --git a/compiler/rustc_codegen_cranelift/src/constant.rs b/compiler/rustc_codegen_cranelift/src/constant.rs
index a56466750e75c..faca92957e1a6 100644
--- a/compiler/rustc_codegen_cranelift/src/constant.rs
+++ b/compiler/rustc_codegen_cranelift/src/constant.rs
@@ -318,7 +318,7 @@ fn data_id_for_static(
         let mut data = DataDescription::new();
         data.set_align(align);
         let data_gv = module.declare_data_in_data(data_id, &mut data);
-        data.define(std::iter::repeat(0).take(pointer_ty(tcx).bytes() as usize).collect());
+        data.define(std::iter::repeat_n(0, pointer_ty(tcx).bytes() as usize).collect());
         data.write_data_addr(0, data_gv, 0);
         match module.define_data(ref_data_id, &data) {
             // Every time the static is referenced there will be another definition of this global,
diff --git a/compiler/rustc_const_eval/src/const_eval/error.rs b/compiler/rustc_const_eval/src/const_eval/error.rs
index e00fb2c1eaf98..69a8f163ca93c 100644
--- a/compiler/rustc_const_eval/src/const_eval/error.rs
+++ b/compiler/rustc_const_eval/src/const_eval/error.rs
@@ -110,7 +110,7 @@ pub fn get_span_and_frames<'tcx>(
             if frame.times < 3 {
                 let times = frame.times;
                 frame.times = 0;
-                frames.extend(std::iter::repeat(frame).take(times as usize));
+                frames.extend(std::iter::repeat_n(frame, times as usize));
             } else {
                 frames.push(frame);
             }
diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
index 785978b4d7111..630e99ad4c74e 100644
--- a/compiler/rustc_const_eval/src/interpret/intrinsics.rs
+++ b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -878,7 +878,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             .compute_size_in_bytes(layout.size, count)
             .ok_or_else(|| err_ub_custom!(fluent::const_eval_size_overflow, name = name))?;
 
-        let bytes = std::iter::repeat(byte).take(len.bytes_usize());
+        let bytes = std::iter::repeat_n(byte, len.bytes_usize());
         self.write_bytes_ptr(dst, bytes)
     }
 
diff --git a/compiler/rustc_const_eval/src/util/check_validity_requirement.rs b/compiler/rustc_const_eval/src/util/check_validity_requirement.rs
index 1dea7e4252d7f..34bd8423e8e15 100644
--- a/compiler/rustc_const_eval/src/util/check_validity_requirement.rs
+++ b/compiler/rustc_const_eval/src/util/check_validity_requirement.rs
@@ -59,7 +59,7 @@ fn check_validity_requirement_strict<'tcx>(
     if kind == ValidityRequirement::Zero {
         cx.write_bytes_ptr(
             allocated.ptr(),
-            std::iter::repeat(0_u8).take(ty.layout.size().bytes_usize()),
+            std::iter::repeat_n(0_u8, ty.layout.size().bytes_usize()),
         )
         .expect("failed to write bytes for zero valid check");
     }
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
index 02baaec37138c..24e20ef5b1b2e 100644
--- a/compiler/rustc_hir_analysis/src/collect.rs
+++ b/compiler/rustc_hir_analysis/src/collect.rs
@@ -590,7 +590,7 @@ fn get_new_lifetime_name<'tcx>(
     let a_to_z_repeat_n = |n| {
         (b'a'..=b'z').map(move |c| {
             let mut s = '\''.to_string();
-            s.extend(std::iter::repeat(char::from(c)).take(n));
+            s.extend(std::iter::repeat_n(char::from(c), n));
             s
         })
     };
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 8a9f9130feacb..86ac9f21809e4 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
@@ -339,8 +339,7 @@ impl<'a, 'tcx> WrongNumberOfGenericArgs<'a, 'tcx> {
             hir::GenericArg::Lifetime(lt) => Some(lt),
             _ => None,
         }) {
-            return std::iter::repeat(lt.to_string())
-                .take(num_params_to_take)
+            return std::iter::repeat_n(lt.to_string(), num_params_to_take)
                 .collect::<Vec<_>>()
                 .join(", ");
         }
@@ -362,8 +361,7 @@ impl<'a, 'tcx> WrongNumberOfGenericArgs<'a, 'tcx> {
                     matches!(fn_decl.output, hir::FnRetTy::Return(ty) if ty.hir_id == ty_id);
 
                 if in_arg || (in_ret && fn_decl.lifetime_elision_allowed) {
-                    return std::iter::repeat("'_".to_owned())
-                        .take(num_params_to_take)
+                    return std::iter::repeat_n("'_".to_owned(), num_params_to_take)
                         .collect::<Vec<_>>()
                         .join(", ");
                 }
@@ -388,8 +386,7 @@ impl<'a, 'tcx> WrongNumberOfGenericArgs<'a, 'tcx> {
             })
             | hir::Node::AnonConst(..) = node
             {
-                return std::iter::repeat("'static".to_owned())
-                    .take(num_params_to_take.saturating_sub(ret.len()))
+                return std::iter::repeat_n("'static".to_owned(), num_params_to_take.saturating_sub(ret.len()))
                     .collect::<Vec<_>>()
                     .join(", ");
             }
diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index f9cdc923670f0..e57f970a0e9a2 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -2602,7 +2602,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             let suggestion = |name, args| {
                 format!(
                     "::{name}({})",
-                    std::iter::repeat("_").take(args).collect::<Vec<_>>().join(", ")
+                    std::iter::repeat_n("_", args).collect::<Vec<_>>().join(", ")
                 )
             };
             match &items[..] {
diff --git a/compiler/rustc_lint/src/if_let_rescope.rs b/compiler/rustc_lint/src/if_let_rescope.rs
index ff67ed1bc5532..2521c2b4eb6ac 100644
--- a/compiler/rustc_lint/src/if_let_rescope.rs
+++ b/compiler/rustc_lint/src/if_let_rescope.rs
@@ -1,4 +1,4 @@
-use std::iter::repeat;
+use std::iter::repeat_n;
 use std::ops::ControlFlow;
 
 use hir::intravisit::{self, Visitor};
@@ -351,7 +351,7 @@ impl Subdiagnostic for IfLetRescopeRewrite {
                 .then_some(" _ => {}".chars())
                 .into_iter()
                 .flatten()
-                .chain(repeat('}').take(closing_brackets.count))
+                .chain(repeat_n('}', closing_brackets.count))
                 .collect(),
         ));
         let msg = diag.eagerly_translate(crate::fluent_generated::lint_suggestion);
diff --git a/compiler/rustc_middle/src/values.rs b/compiler/rustc_middle/src/values.rs
index 4d70a70873267..bc73d36216ef4 100644
--- a/compiler/rustc_middle/src/values.rs
+++ b/compiler/rustc_middle/src/values.rs
@@ -63,7 +63,7 @@ impl<'tcx> Value<TyCtxt<'tcx>> for ty::Binder<'_, ty::FnSig<'_>> {
         };
 
         let fn_sig = ty::Binder::dummy(tcx.mk_fn_sig(
-            std::iter::repeat(err).take(arity),
+            std::iter::repeat_n(err, arity),
             err,
             false,
             rustc_hir::Safety::Safe,
diff --git a/compiler/rustc_mir_build/src/check_tail_calls.rs b/compiler/rustc_mir_build/src/check_tail_calls.rs
index d40c77d145f47..9115c17f37525 100644
--- a/compiler/rustc_mir_build/src/check_tail_calls.rs
+++ b/compiler/rustc_mir_build/src/check_tail_calls.rs
@@ -283,7 +283,7 @@ impl<'tcx> TailCallCkVisitor<'_, 'tcx> {
     fn report_calling_closure(&mut self, fun: &Expr<'_>, tupled_args: Ty<'_>, expr: &Expr<'_>) {
         let underscored_args = match tupled_args.kind() {
             ty::Tuple(tys) if tys.is_empty() => "".to_owned(),
-            ty::Tuple(tys) => std::iter::repeat("_, ").take(tys.len() - 1).chain(["_"]).collect(),
+            ty::Tuple(tys) => std::iter::repeat_n("_, ", tys.len() - 1).chain(["_"]).collect(),
             _ => "_".to_owned(),
         };
 
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 4ea237cfa0321..a5a6cf503524c 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -2019,7 +2019,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         }
 
         let expected_sig = tcx.mk_fn_sig(
-            std::iter::repeat(token_stream).take(match kind {
+            std::iter::repeat_n(token_stream, match kind {
                 ProcMacroKind::Attribute => 2,
                 ProcMacroKind::Derive | ProcMacroKind::FunctionLike => 1,
             }),
diff --git a/compiler/rustc_query_system/src/dep_graph/serialized.rs b/compiler/rustc_query_system/src/dep_graph/serialized.rs
index 79b99c52d0c01..f5eb61a449f8b 100644
--- a/compiler/rustc_query_system/src/dep_graph/serialized.rs
+++ b/compiler/rustc_query_system/src/dep_graph/serialized.rs
@@ -566,7 +566,7 @@ impl<D: Deps> EncoderState<D> {
                     edge_count: 0,
                     node_count: 0,
                     encoder: MemEncoder::new(),
-                    kind_stats: iter::repeat(0).take(D::DEP_KIND_MAX as usize + 1).collect(),
+                    kind_stats: iter::repeat_n(0, D::DEP_KIND_MAX as usize + 1).collect(),
                 })
             }),
             marker: PhantomData,
@@ -735,7 +735,7 @@ impl<D: Deps> EncoderState<D> {
 
         let mut encoder = self.file.lock().take().unwrap();
 
-        let mut kind_stats: Vec<u32> = iter::repeat(0).take(D::DEP_KIND_MAX as usize + 1).collect();
+        let mut kind_stats: Vec<u32> = iter::repeat_n(0, D::DEP_KIND_MAX as usize + 1).collect();
 
         let mut node_max = 0;
         let mut node_count = 0;
diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs
index 8c2ddda7f9834..1589e3f4092c4 100644
--- a/compiler/rustc_resolve/src/late/diagnostics.rs
+++ b/compiler/rustc_resolve/src/late/diagnostics.rs
@@ -2214,10 +2214,7 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
             .collect::<Vec<_>>();
         items.sort_by_key(|(order, _, _)| *order);
         let suggestion = |name, args| {
-            format!(
-                "::{name}({})",
-                std::iter::repeat("_").take(args).collect::<Vec<_>>().join(", ")
-            )
+            format!("::{name}({})", std::iter::repeat_n("_", args).collect::<Vec<_>>().join(", "))
         };
         match &items[..] {
             [] => {}
@@ -3485,17 +3482,14 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
                 (lt.span.shrink_to_hi(), format!("{existing_name} "))
             }
             MissingLifetimeKind::Comma => {
-                let sugg: String = std::iter::repeat([existing_name.as_str(), ", "])
-                    .take(lt.count)
+                let sugg: String = std::iter::repeat_n([existing_name.as_str(), ", "], lt.count)
                     .flatten()
                     .collect();
                 (lt.span.shrink_to_hi(), sugg)
             }
             MissingLifetimeKind::Brackets => {
                 let sugg: String = std::iter::once("<")
-                    .chain(
-                        std::iter::repeat(existing_name.as_str()).take(lt.count).intersperse(", "),
-                    )
+                    .chain(std::iter::repeat_n(existing_name.as_str(), lt.count).intersperse(", "))
                     .chain([">"])
                     .collect();
                 (lt.span.shrink_to_hi(), sugg)
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/static_impl_trait.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/static_impl_trait.rs
index 5b8315841765b..3ee6e6b739c03 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/static_impl_trait.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/static_impl_trait.rs
@@ -305,7 +305,7 @@ fn make_elided_region_spans_suggs<'a>(
                 consecutive_brackets += 1;
             } else if let Some(bracket_span) = bracket_span.take() {
                 let sugg = std::iter::once("<")
-                    .chain(std::iter::repeat(name).take(consecutive_brackets).intersperse(", "))
+                    .chain(std::iter::repeat_n(name, consecutive_brackets).intersperse(", "))
                     .chain([">"])
                     .collect();
                 spans_suggs.push((bracket_span.shrink_to_hi(), sugg));
diff --git a/compiler/rustc_transmute/src/layout/tree.rs b/compiler/rustc_transmute/src/layout/tree.rs
index 7f626e8c4e886..d9ebdadf3b79c 100644
--- a/compiler/rustc_transmute/src/layout/tree.rs
+++ b/compiler/rustc_transmute/src/layout/tree.rs
@@ -326,8 +326,7 @@ pub(crate) mod rustc {
                     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)
-                        .take(*count as usize)
+                    Ok(std::iter::repeat_n(elt, *count as usize)
                         .fold(Tree::unit(), |tree, elt| tree.then(elt)))
                 }
 

From affaf532f923df7ee1fb5a4aae1d844913ca1c74 Mon Sep 17 00:00:00 2001
From: yukang <moorekang@gmail.com>
Date: Thu, 9 Oct 2025 01:25:32 +0800
Subject: [PATCH 1834/1889] referring to repeat_n in std::iter::repeat

---
 library/core/src/iter/sources/repeat.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/library/core/src/iter/sources/repeat.rs b/library/core/src/iter/sources/repeat.rs
index 4bcd5b16aea6a..7fcd6f8963a48 100644
--- a/library/core/src/iter/sources/repeat.rs
+++ b/library/core/src/iter/sources/repeat.rs
@@ -8,6 +8,9 @@ use crate::num::NonZero;
 /// Infinite iterators like `repeat()` are often used with adapters like
 /// [`Iterator::take()`], in order to make them finite.
 ///
+/// If you know the number of repetitions in advance, consider using [`repeat_n()`]
+/// instead, as it is more efficient and conveys the intent more clearly.
+///
 /// Use [`str::repeat()`] instead of this function if you just want to repeat
 /// a char/string `n` times.
 ///
@@ -15,6 +18,7 @@ use crate::num::NonZero;
 /// or if you do not want to keep the repeated element in memory, you can
 /// instead use the [`repeat_with()`] function.
 ///
+/// [`repeat_n()`]: crate::iter::repeat_n
 /// [`repeat_with()`]: crate::iter::repeat_with
 /// [`str::repeat()`]: ../../std/primitive.str.html#method.repeat
 ///

From 53c79f4523b228cf04a772dc474ac9315b456f7f Mon Sep 17 00:00:00 2001
From: yukang <moorekang@gmail.com>
Date: Thu, 9 Oct 2025 01:29:16 +0800
Subject: [PATCH 1835/1889] bless format

---
 .../src/errors/wrong_number_of_generic_args.rs        |  9 ++++++---
 compiler/rustc_passes/src/check_attr.rs               | 11 +++++++----
 2 files changed, 13 insertions(+), 7 deletions(-)

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 86ac9f21809e4..30324da3c6516 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
@@ -386,9 +386,12 @@ impl<'a, 'tcx> WrongNumberOfGenericArgs<'a, 'tcx> {
             })
             | hir::Node::AnonConst(..) = node
             {
-                return std::iter::repeat_n("'static".to_owned(), num_params_to_take.saturating_sub(ret.len()))
-                    .collect::<Vec<_>>()
-                    .join(", ");
+                return std::iter::repeat_n(
+                    "'static".to_owned(),
+                    num_params_to_take.saturating_sub(ret.len()),
+                )
+                .collect::<Vec<_>>()
+                .join(", ");
             }
 
             let params = if let Some(generics) = node.generics() {
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index a5a6cf503524c..ad4b035916cd9 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -2019,10 +2019,13 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         }
 
         let expected_sig = tcx.mk_fn_sig(
-            std::iter::repeat_n(token_stream, match kind {
-                ProcMacroKind::Attribute => 2,
-                ProcMacroKind::Derive | ProcMacroKind::FunctionLike => 1,
-            }),
+            std::iter::repeat_n(
+                token_stream,
+                match kind {
+                    ProcMacroKind::Attribute => 2,
+                    ProcMacroKind::Derive | ProcMacroKind::FunctionLike => 1,
+                },
+            ),
             token_stream,
             false,
             Safety::Safe,

From 99ab27f90cf9e3b020e61fca65f9a8c1ec9a1695 Mon Sep 17 00:00:00 2001
From: The 8472 <git@infinite-source.de>
Date: Fri, 3 Oct 2025 13:43:11 +0200
Subject: [PATCH 1836/1889] specialize slice::fill to use memset when possible

LLVM generally can do this on its own, but it helps miri and other backends.
---
 library/core/src/slice/specialize.rs          | 47 ++++++++++++++++++-
 .../lib-optimizations/slice_fill.rs           | 28 +++++++++++
 2 files changed, 74 insertions(+), 1 deletion(-)
 create mode 100644 tests/codegen-llvm/lib-optimizations/slice_fill.rs

diff --git a/library/core/src/slice/specialize.rs b/library/core/src/slice/specialize.rs
index 80eb590587f99..17436395fee69 100644
--- a/library/core/src/slice/specialize.rs
+++ b/library/core/src/slice/specialize.rs
@@ -15,9 +15,54 @@ impl<T: Clone> SpecFill<T> for [T] {
 }
 
 impl<T: Copy> SpecFill<T> for [T] {
-    fn spec_fill(&mut self, value: T) {
+    default fn spec_fill(&mut self, value: T) {
         for item in self.iter_mut() {
             *item = value;
         }
     }
 }
+
+impl SpecFill<u8> for [u8] {
+    fn spec_fill(&mut self, value: u8) {
+        // SAFETY: The pointer is derived from a reference, so it's writable.
+        unsafe {
+            crate::intrinsics::write_bytes(self.as_mut_ptr(), value, self.len());
+        }
+    }
+}
+
+impl SpecFill<i8> for [i8] {
+    fn spec_fill(&mut self, value: i8) {
+        // SAFETY: The pointer is derived from a reference, so it's writable.
+        unsafe {
+            crate::intrinsics::write_bytes(self.as_mut_ptr(), value.cast_unsigned(), self.len());
+        }
+    }
+}
+
+macro spec_fill_int {
+    ($($type:ty)*) => {$(
+        impl SpecFill<$type> for [$type] {
+            #[inline]
+            fn spec_fill(&mut self, value: $type) {
+                // We always take this fastpath in Miri for long slices as the manual `for`
+                // loop can be prohibitively slow.
+                if (cfg!(miri) && self.len() > 32) || crate::intrinsics::is_val_statically_known(value) {
+                    let bytes = value.to_ne_bytes();
+                    if value == <$type>::from_ne_bytes([bytes[0]; size_of::<$type>()]) {
+                        // SAFETY: The pointer is derived from a reference, so it's writable.
+                        unsafe {
+                            crate::intrinsics::write_bytes(self.as_mut_ptr(), bytes[0], self.len());
+                        }
+                        return;
+                    }
+                }
+                for item in self.iter_mut() {
+                    *item = value;
+                }
+            }
+        }
+    )*}
+}
+
+spec_fill_int! { u16 i16 u32 i32 u64 i64 u128 i128 usize isize }
diff --git a/tests/codegen-llvm/lib-optimizations/slice_fill.rs b/tests/codegen-llvm/lib-optimizations/slice_fill.rs
new file mode 100644
index 0000000000000..2d924ebf726d8
--- /dev/null
+++ b/tests/codegen-llvm/lib-optimizations/slice_fill.rs
@@ -0,0 +1,28 @@
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+
+use std::mem::MaybeUninit;
+
+// CHECK-LABEL: @slice_fill_pass_undef
+#[no_mangle]
+pub fn slice_fill_pass_undef(s: &mut [MaybeUninit<u8>], v: MaybeUninit<u8>) {
+    // CHECK: tail call void @llvm.memset.{{.*}}(ptr nonnull align 1 %s.0, i8 %v, {{.*}} %s.1, i1 false)
+    // CHECK: ret
+    s.fill(v);
+}
+
+// CHECK-LABEL: @slice_fill_uninit
+#[no_mangle]
+pub fn slice_fill_uninit(s: &mut [MaybeUninit<u8>]) {
+    // CHECK-NOT: call
+    // CHECK: ret void
+    s.fill(MaybeUninit::uninit());
+}
+
+// CHECK-LABEL: @slice_wide_memset
+#[no_mangle]
+pub fn slice_wide_memset(s: &mut [u16]) {
+    // CHECK: tail call void @llvm.memset.{{.*}}(ptr nonnull align 2 %s.0, i8 -1
+    // CHECK: ret
+    s.fill(0xFFFF);
+}

From 5702fbf03d35ae38573e5861231ad2dda83bc5c8 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Wed, 8 Oct 2025 13:40:12 +0000
Subject: [PATCH 1837/1889] Refactor AddCallGuards in two loops.

---
 .../src/add_call_guards.rs                    | 137 +++++++++++-------
 1 file changed, 81 insertions(+), 56 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/add_call_guards.rs b/compiler/rustc_mir_transform/src/add_call_guards.rs
index 26839ebf61e46..d96c7d84dbefd 100644
--- a/compiler/rustc_mir_transform/src/add_call_guards.rs
+++ b/compiler/rustc_mir_transform/src/add_call_guards.rs
@@ -1,3 +1,20 @@
+//! Breaks outgoing critical edges for call terminators in the MIR.
+//!
+//! Critical edges are edges that are neither the only edge leaving a
+//! block, nor the only edge entering one.
+//!
+//! When you want something to happen "along" an edge, you can either
+//! do at the end of the predecessor block, or at the start of the
+//! successor block. Critical edges have to be broken in order to prevent
+//! "edge actions" from affecting other edges. We need this for calls that are
+//! codegened to LLVM invoke instructions, because invoke is a block terminator
+//! in LLVM so we can't insert any code to handle the call's result into the
+//! block that performs the call.
+//!
+//! This function will break those edges by inserting new blocks along them.
+//!
+//! NOTE: Simplify CFG will happily undo most of the work this pass does.
+
 use rustc_index::{Idx, IndexVec};
 use rustc_middle::mir::*;
 use rustc_middle::ty::TyCtxt;
@@ -10,26 +27,6 @@ pub(super) enum AddCallGuards {
 }
 pub(super) use self::AddCallGuards::*;
 
-/**
- * Breaks outgoing critical edges for call terminators in the MIR.
- *
- * Critical edges are edges that are neither the only edge leaving a
- * block, nor the only edge entering one.
- *
- * When you want something to happen "along" an edge, you can either
- * do at the end of the predecessor block, or at the start of the
- * successor block. Critical edges have to be broken in order to prevent
- * "edge actions" from affecting other edges. We need this for calls that are
- * codegened to LLVM invoke instructions, because invoke is a block terminator
- * in LLVM so we can't insert any code to handle the call's result into the
- * block that performs the call.
- *
- * This function will break those edges by inserting new blocks along them.
- *
- * NOTE: Simplify CFG will happily undo most of the work this pass does.
- *
- */
-
 impl<'tcx> crate::MirPass<'tcx> for AddCallGuards {
     fn run_pass(&self, _tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
         let mut pred_count = IndexVec::from_elem(0u8, &body.basic_blocks);
@@ -39,51 +36,38 @@ impl<'tcx> crate::MirPass<'tcx> for AddCallGuards {
             }
         }
 
-        // We need a place to store the new blocks generated
-        let mut new_blocks = Vec::new();
-
-        let cur_len = body.basic_blocks.len();
-        let mut new_block = |source_info: SourceInfo, is_cleanup: bool, target: BasicBlock| {
-            let block = BasicBlockData::new(
-                Some(Terminator { source_info, kind: TerminatorKind::Goto { target } }),
-                is_cleanup,
-            );
-            let idx = cur_len + new_blocks.len();
-            new_blocks.push(block);
-            BasicBlock::new(idx)
-        };
+        enum Action {
+            Call,
+            Asm { target_index: usize },
+        }
 
-        for block in body.basic_blocks_mut() {
-            match block.terminator {
-                Some(Terminator {
-                    kind: TerminatorKind::Call { target: Some(ref mut destination), unwind, .. },
-                    source_info,
-                }) if pred_count[*destination] > 1
-                    && (generates_invoke(unwind) || self == &AllCallEdges) =>
+        let mut work = Vec::with_capacity(body.basic_blocks.len());
+        for (bb, block) in body.basic_blocks.iter_enumerated() {
+            let term = block.terminator();
+            match term.kind {
+                TerminatorKind::Call { target: Some(destination), unwind, .. }
+                    if pred_count[destination] > 1
+                        && (generates_invoke(unwind) || self == &AllCallEdges) =>
                 {
                     // It's a critical edge, break it
-                    *destination = new_block(source_info, block.is_cleanup, *destination);
+                    work.push((bb, Action::Call));
                 }
-                Some(Terminator {
-                    kind:
-                        TerminatorKind::InlineAsm {
-                            asm_macro: InlineAsmMacro::Asm,
-                            ref mut targets,
-                            ref operands,
-                            unwind,
-                            ..
-                        },
-                    source_info,
-                }) if self == &CriticalCallEdges => {
+                TerminatorKind::InlineAsm {
+                    asm_macro: InlineAsmMacro::Asm,
+                    ref targets,
+                    ref operands,
+                    unwind,
+                    ..
+                } if self == &CriticalCallEdges => {
                     let has_outputs = operands.iter().any(|op| {
                         matches!(op, InlineAsmOperand::InOut { .. } | InlineAsmOperand::Out { .. })
                     });
                     let has_labels =
                         operands.iter().any(|op| matches!(op, InlineAsmOperand::Label { .. }));
                     if has_outputs && (has_labels || generates_invoke(unwind)) {
-                        for target in targets.iter_mut() {
+                        for (target_index, target) in targets.iter().enumerate() {
                             if pred_count[*target] > 1 {
-                                *target = new_block(source_info, block.is_cleanup, *target);
+                                work.push((bb, Action::Asm { target_index }));
                             }
                         }
                     }
@@ -92,9 +76,50 @@ impl<'tcx> crate::MirPass<'tcx> for AddCallGuards {
             }
         }
 
-        debug!("Broke {} N edges", new_blocks.len());
+        if work.is_empty() {
+            return;
+        }
 
-        body.basic_blocks_mut().extend(new_blocks);
+        // We need a place to store the new blocks generated
+        let mut new_blocks = Vec::with_capacity(work.len());
+
+        let cur_len = body.basic_blocks.len();
+        let mut new_block = |source_info: SourceInfo, is_cleanup: bool, target: BasicBlock| {
+            let block = BasicBlockData::new(
+                Some(Terminator { source_info, kind: TerminatorKind::Goto { target } }),
+                is_cleanup,
+            );
+            let idx = cur_len + new_blocks.len();
+            new_blocks.push(block);
+            BasicBlock::new(idx)
+        };
+
+        let basic_blocks = body.basic_blocks.as_mut();
+        for (source, action) in work {
+            let block = &mut basic_blocks[source];
+            let is_cleanup = block.is_cleanup;
+            let term = block.terminator_mut();
+            let source_info = term.source_info;
+            let destination = match action {
+                Action::Call => {
+                    let TerminatorKind::Call { target: Some(ref mut destination), .. } = term.kind
+                    else {
+                        unreachable!()
+                    };
+                    destination
+                }
+                Action::Asm { target_index } => {
+                    let TerminatorKind::InlineAsm { ref mut targets, .. } = term.kind else {
+                        unreachable!()
+                    };
+                    &mut targets[target_index]
+                }
+            };
+            *destination = new_block(source_info, is_cleanup, *destination);
+        }
+
+        debug!("Broke {} N edges", new_blocks.len());
+        basic_blocks.extend(new_blocks);
     }
 
     fn is_required(&self) -> bool {

From 036ab3a925f7b449edc3d2da14fb6bb25fb52c47 Mon Sep 17 00:00:00 2001
From: AMS21 <ams21.github@gmail.com>
Date: Wed, 8 Oct 2025 19:08:49 +0200
Subject: [PATCH 1838/1889] refactor: Remove `LLVMRustInsertPrivateGlobal` and
 `define_private_global`

Since it can easily be implemented using the existing LLVM C API in
terms of `LLVMAddGlobal` and `LLVMSetLinkage` and `define_private_global`
was only used in one place.
---
 compiler/rustc_codegen_llvm/src/consts.rs        | 6 ++++--
 compiler/rustc_codegen_llvm/src/declare.rs       | 7 -------
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs      | 1 -
 compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp | 6 ------
 4 files changed, 4 insertions(+), 16 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/consts.rs b/compiler/rustc_codegen_llvm/src/consts.rs
index e14f0098dd9b4..9844c9444b3d0 100644
--- a/compiler/rustc_codegen_llvm/src/consts.rs
+++ b/compiler/rustc_codegen_llvm/src/consts.rs
@@ -240,11 +240,13 @@ impl<'ll> CodegenCx<'ll, '_> {
                 let gv = self.define_global(&name, self.val_ty(cv)).unwrap_or_else(|| {
                     bug!("symbol `{}` is already defined", name);
                 });
-                llvm::set_linkage(gv, llvm::Linkage::PrivateLinkage);
                 gv
             }
-            _ => self.define_private_global(self.val_ty(cv)),
+            _ => self.define_global("", self.val_ty(cv)).unwrap_or_else(|| {
+                bug!("anonymous global symbol is already defined");
+            }),
         };
+        llvm::set_linkage(gv, llvm::Linkage::PrivateLinkage);
         llvm::set_initializer(gv, cv);
         set_global_alignment(self, gv, align);
         llvm::set_unnamed_address(gv, llvm::UnnamedAddr::Global);
diff --git a/compiler/rustc_codegen_llvm/src/declare.rs b/compiler/rustc_codegen_llvm/src/declare.rs
index 48b2d09afb674..8f69f176138cf 100644
--- a/compiler/rustc_codegen_llvm/src/declare.rs
+++ b/compiler/rustc_codegen_llvm/src/declare.rs
@@ -230,13 +230,6 @@ impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX> {
         }
     }
 
-    /// Declare a private global
-    ///
-    /// Use this function when you intend to define a global without a name.
-    pub(crate) fn define_private_global(&self, ty: &'ll Type) -> &'ll Value {
-        unsafe { llvm::LLVMRustInsertPrivateGlobal(self.llmod(), ty) }
-    }
-
     /// Gets declared value by name.
     pub(crate) fn get_declared_value(&self, name: &str) -> Option<&'ll Value> {
         debug!("get_declared_value(name={:?})", name);
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index c4b5cf413a725..3a3bae3bb2bf9 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -1954,7 +1954,6 @@ unsafe extern "C" {
         NameLen: size_t,
         T: &'a Type,
     ) -> &'a Value;
-    pub(crate) fn LLVMRustInsertPrivateGlobal<'a>(M: &'a Module, T: &'a Type) -> &'a Value;
     pub(crate) fn LLVMRustGetNamedValue(
         M: &Module,
         Name: *const c_char,
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index e38474f09ff7a..08b6334bf404c 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -228,12 +228,6 @@ extern "C" LLVMValueRef LLVMRustGetOrInsertGlobal(LLVMModuleRef M,
   return wrap(GV);
 }
 
-extern "C" LLVMValueRef LLVMRustInsertPrivateGlobal(LLVMModuleRef M,
-                                                    LLVMTypeRef Ty) {
-  return wrap(new GlobalVariable(*unwrap(M), unwrap(Ty), false,
-                                 GlobalValue::PrivateLinkage, nullptr));
-}
-
 // Must match the layout of `rustc_codegen_llvm::llvm::ffi::AttributeKind`.
 enum class LLVMRustAttributeKind {
   AlwaysInline = 0,

From 4b6bc9a66b8eb84f96d3fa524ca30d7dde7f7560 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Wed, 8 Oct 2025 13:20:42 -0700
Subject: [PATCH 1839/1889] Update wasm-component-ld to 0.5.18

Keeping it up-to-date with upstream for the latest bug fixes and such
related to wasm-tools-implemented internals.
---
 Cargo.lock                             | 87 +++++++++++++++-----------
 src/tools/wasm-component-ld/Cargo.toml |  2 +-
 2 files changed, 52 insertions(+), 37 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index e67898756fad5..be45b93ff20f5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -495,7 +495,7 @@ dependencies = [
  "iana-time-zone",
  "num-traits",
  "serde",
- "windows-link",
+ "windows-link 0.1.3",
 ]
 
 [[package]]
@@ -6059,9 +6059,9 @@ dependencies = [
 
 [[package]]
 name = "wasi-preview1-component-adapter-provider"
-version = "36.0.1"
+version = "37.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20689c88791776219f78c2529700d15e6a9bd57a27858c62e9ef8487956b571c"
+checksum = "8d0fcd636ad2b29a7c0490799a23ad61d1c8dedfafdb970447fddd0549502b60"
 
 [[package]]
 name = "wasm-bindgen"
@@ -6123,9 +6123,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-component-ld"
-version = "0.5.17"
+version = "0.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c9208f87cac2332fd80dcf36d54e9163d3446e28301e0c6e424984425738984"
+checksum = "11f565dfcfd9aabb10d865b608a92ce1f93051aeb56f4c89550ed9cd97d8ce0e"
 dependencies = [
  "anyhow",
  "clap",
@@ -6133,9 +6133,9 @@ dependencies = [
  "libc",
  "tempfile",
  "wasi-preview1-component-adapter-provider",
- "wasmparser 0.239.0",
+ "wasmparser 0.240.0",
  "wat",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
  "winsplit",
  "wit-component",
  "wit-parser",
@@ -6160,24 +6160,24 @@ dependencies = [
 
 [[package]]
 name = "wasm-encoder"
-version = "0.239.0"
+version = "0.240.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5be00faa2b4950c76fe618c409d2c3ea5a3c9422013e079482d78544bb2d184c"
+checksum = "06d642d8c5ecc083aafe9ceb32809276a304547a3a6eeecceb5d8152598bc71f"
 dependencies = [
  "leb128fmt",
- "wasmparser 0.239.0",
+ "wasmparser 0.240.0",
 ]
 
 [[package]]
 name = "wasm-metadata"
-version = "0.239.0"
+version = "0.240.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20b3ec880a9ac69ccd92fbdbcf46ee833071cf09f82bb005b2327c7ae6025ae2"
+checksum = "ee093e1e1ccffa005b9b778f7a10ccfd58e25a20eccad294a1a93168d076befb"
 dependencies = [
  "anyhow",
  "indexmap",
- "wasm-encoder 0.239.0",
- "wasmparser 0.239.0",
+ "wasm-encoder 0.240.0",
+ "wasmparser 0.240.0",
 ]
 
 [[package]]
@@ -6202,9 +6202,9 @@ dependencies = [
 
 [[package]]
 name = "wasmparser"
-version = "0.239.0"
+version = "0.240.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c9d90bb93e764f6beabf1d02028c70a2156a6583e63ac4218dd07ef733368b0"
+checksum = "b722dcf61e0ea47440b53ff83ccb5df8efec57a69d150e4f24882e4eba7e24a4"
 dependencies = [
  "bitflags",
  "hashbrown",
@@ -6215,22 +6215,22 @@ dependencies = [
 
 [[package]]
 name = "wast"
-version = "239.0.0"
+version = "240.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9139176fe8a2590e0fb174cdcaf373b224cb93c3dde08e4297c1361d2ba1ea5d"
+checksum = "b0efe1c93db4ac562b9733e3dca19ed7fc878dba29aef22245acf84f13da4a19"
 dependencies = [
  "bumpalo",
  "leb128fmt",
  "memchr",
  "unicode-width 0.2.1",
- "wasm-encoder 0.239.0",
+ "wasm-encoder 0.240.0",
 ]
 
 [[package]]
 name = "wat"
-version = "1.239.0"
+version = "1.240.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e1c941927d34709f255558166f8901a2005f8ab4a9650432e9281b7cc6f3b75"
+checksum = "4ec9b6eab7ecd4d639d78515e9ea491c9bacf494aa5eda10823bd35992cf8c1e"
 dependencies = [
  "wast",
 ]
@@ -6295,7 +6295,7 @@ dependencies = [
  "windows-collections",
  "windows-core 0.61.2",
  "windows-future",
- "windows-link",
+ "windows-link 0.1.3",
  "windows-numerics",
 ]
 
@@ -6340,7 +6340,7 @@ checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
 dependencies = [
  "windows-implement 0.60.0",
  "windows-interface 0.59.1",
- "windows-link",
+ "windows-link 0.1.3",
  "windows-result 0.3.4",
  "windows-strings 0.4.2",
 ]
@@ -6352,7 +6352,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
 dependencies = [
  "windows-core 0.61.2",
- "windows-link",
+ "windows-link 0.1.3",
  "windows-threading",
 ]
 
@@ -6406,6 +6406,12 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
 
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
 [[package]]
 name = "windows-numerics"
 version = "0.2.0"
@@ -6413,7 +6419,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
 dependencies = [
  "windows-core 0.61.2",
- "windows-link",
+ "windows-link 0.1.3",
 ]
 
 [[package]]
@@ -6431,7 +6437,7 @@ version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6"
 dependencies = [
- "windows-link",
+ "windows-link 0.1.3",
 ]
 
 [[package]]
@@ -6450,7 +6456,7 @@ version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57"
 dependencies = [
- "windows-link",
+ "windows-link 0.1.3",
 ]
 
 [[package]]
@@ -6480,6 +6486,15 @@ dependencies = [
  "windows-targets 0.53.3",
 ]
 
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
 [[package]]
 name = "windows-targets"
 version = "0.52.6"
@@ -6502,7 +6517,7 @@ version = "0.53.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d5fe6031c4041849d7c496a8ded650796e7b6ecc19df1a431c1a363342e5dc91"
 dependencies = [
- "windows-link",
+ "windows-link 0.1.3",
  "windows_aarch64_gnullvm 0.53.0",
  "windows_aarch64_msvc 0.53.0",
  "windows_i686_gnu 0.53.0",
@@ -6519,7 +6534,7 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6"
 dependencies = [
- "windows-link",
+ "windows-link 0.1.3",
 ]
 
 [[package]]
@@ -6653,9 +6668,9 @@ dependencies = [
 
 [[package]]
 name = "wit-component"
-version = "0.239.0"
+version = "0.240.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88a866b19dba2c94d706ec58c92a4c62ab63e482b4c935d2a085ac94caecb136"
+checksum = "7dc5474b078addc5fe8a72736de8da3acfb3ff324c2491133f8b59594afa1a20"
 dependencies = [
  "anyhow",
  "bitflags",
@@ -6664,17 +6679,17 @@ dependencies = [
  "serde",
  "serde_derive",
  "serde_json",
- "wasm-encoder 0.239.0",
+ "wasm-encoder 0.240.0",
  "wasm-metadata",
- "wasmparser 0.239.0",
+ "wasmparser 0.240.0",
  "wit-parser",
 ]
 
 [[package]]
 name = "wit-parser"
-version = "0.239.0"
+version = "0.240.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55c92c939d667b7bf0c6bf2d1f67196529758f99a2a45a3355cc56964fd5315d"
+checksum = "9875ea3fa272f57cc1fc50f225a7b94021a7878c484b33792bccad0d93223439"
 dependencies = [
  "anyhow",
  "id-arena",
@@ -6685,7 +6700,7 @@ dependencies = [
  "serde_derive",
  "serde_json",
  "unicode-xid",
- "wasmparser 0.239.0",
+ "wasmparser 0.240.0",
 ]
 
 [[package]]
diff --git a/src/tools/wasm-component-ld/Cargo.toml b/src/tools/wasm-component-ld/Cargo.toml
index 3def2391a13f6..235e934b55412 100644
--- a/src/tools/wasm-component-ld/Cargo.toml
+++ b/src/tools/wasm-component-ld/Cargo.toml
@@ -10,4 +10,4 @@ name = "wasm-component-ld"
 path = "src/main.rs"
 
 [dependencies]
-wasm-component-ld = "0.5.17"
+wasm-component-ld = "0.5.18"

From 8f0815602c193ca55f4ca39c86dbb1240d6ee8f1 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Thu, 9 Oct 2025 13:11:22 +1100
Subject: [PATCH 1840/1889] compiletest: Isolate APIs used by rustdoc-gui-test

---
 Cargo.lock                                    |   1 -
 src/tools/compiletest/src/common.rs           | 104 -------------
 src/tools/compiletest/src/lib.rs              |   1 +
 src/tools/compiletest/src/rustdoc_gui_test.rs | 143 ++++++++++++++++++
 src/tools/rustdoc-gui-test/Cargo.toml         |   1 -
 src/tools/rustdoc-gui-test/src/main.rs        |  10 +-
 6 files changed, 146 insertions(+), 114 deletions(-)
 create mode 100644 src/tools/compiletest/src/rustdoc_gui_test.rs

diff --git a/Cargo.lock b/Cargo.lock
index e67898756fad5..973214a802e6e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4805,7 +4805,6 @@ name = "rustdoc-gui-test"
 version = "0.1.0"
 dependencies = [
  "build_helper",
- "camino",
  "compiletest",
  "getopts",
  "walkdir",
diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
index 65db816ad1a87..7a75803c78277 100644
--- a/src/tools/compiletest/src/common.rs
+++ b/src/tools/compiletest/src/common.rs
@@ -686,110 +686,6 @@ pub struct Config {
 }
 
 impl Config {
-    /// Incomplete config intended for `src/tools/rustdoc-gui-test` **only** as
-    /// `src/tools/rustdoc-gui-test` wants to reuse `compiletest`'s directive -> test property
-    /// handling for `//@ {compile,run}-flags`, do not use for any other purpose.
-    ///
-    /// FIXME(#143827): this setup feels very hacky. It so happens that `tests/rustdoc-gui/`
-    /// **only** uses `//@ {compile,run}-flags` for now and not any directives that actually rely on
-    /// info that is assumed available in a fully populated [`Config`].
-    pub fn incomplete_for_rustdoc_gui_test() -> Config {
-        // FIXME(#143827): spelling this out intentionally, because this is questionable.
-        //
-        // For instance, `//@ ignore-stage1` will not work at all.
-        Config {
-            mode: TestMode::Rustdoc,
-            // E.g. this has no sensible default tbh.
-            suite: TestSuite::Ui,
-
-            // Dummy values.
-            edition: Default::default(),
-            bless: Default::default(),
-            fail_fast: Default::default(),
-            compile_lib_path: Utf8PathBuf::default(),
-            run_lib_path: Utf8PathBuf::default(),
-            rustc_path: Utf8PathBuf::default(),
-            cargo_path: Default::default(),
-            stage0_rustc_path: Default::default(),
-            query_rustc_path: Default::default(),
-            rustdoc_path: Default::default(),
-            coverage_dump_path: Default::default(),
-            python: Default::default(),
-            jsondocck_path: Default::default(),
-            jsondoclint_path: Default::default(),
-            llvm_filecheck: Default::default(),
-            llvm_bin_dir: Default::default(),
-            run_clang_based_tests_with: Default::default(),
-            src_root: Utf8PathBuf::default(),
-            src_test_suite_root: Utf8PathBuf::default(),
-            build_root: Utf8PathBuf::default(),
-            build_test_suite_root: Utf8PathBuf::default(),
-            sysroot_base: Utf8PathBuf::default(),
-            stage: Default::default(),
-            stage_id: String::default(),
-            debugger: Default::default(),
-            run_ignored: Default::default(),
-            with_rustc_debug_assertions: Default::default(),
-            with_std_debug_assertions: Default::default(),
-            filters: Default::default(),
-            skip: Default::default(),
-            filter_exact: Default::default(),
-            force_pass_mode: Default::default(),
-            run: Default::default(),
-            runner: Default::default(),
-            host_rustcflags: Default::default(),
-            target_rustcflags: Default::default(),
-            rust_randomized_layout: Default::default(),
-            optimize_tests: Default::default(),
-            target: Default::default(),
-            host: Default::default(),
-            cdb: Default::default(),
-            cdb_version: Default::default(),
-            gdb: Default::default(),
-            gdb_version: Default::default(),
-            lldb_version: Default::default(),
-            llvm_version: Default::default(),
-            system_llvm: Default::default(),
-            android_cross_path: Default::default(),
-            adb_path: Default::default(),
-            adb_test_dir: Default::default(),
-            adb_device_status: Default::default(),
-            lldb_python_dir: Default::default(),
-            verbose: Default::default(),
-            color: Default::default(),
-            remote_test_client: Default::default(),
-            compare_mode: Default::default(),
-            rustfix_coverage: Default::default(),
-            has_html_tidy: Default::default(),
-            has_enzyme: Default::default(),
-            channel: Default::default(),
-            git_hash: Default::default(),
-            cc: Default::default(),
-            cxx: Default::default(),
-            cflags: Default::default(),
-            cxxflags: Default::default(),
-            ar: Default::default(),
-            target_linker: Default::default(),
-            host_linker: Default::default(),
-            llvm_components: Default::default(),
-            nodejs: Default::default(),
-            npm: Default::default(),
-            force_rerun: Default::default(),
-            only_modified: Default::default(),
-            target_cfgs: Default::default(),
-            builtin_cfg_names: Default::default(),
-            supported_crate_types: Default::default(),
-            nocapture: Default::default(),
-            nightly_branch: Default::default(),
-            git_merge_commit_email: Default::default(),
-            profiler_runtime: Default::default(),
-            diff_command: Default::default(),
-            minicore_path: Default::default(),
-            default_codegen_backend: CodegenBackend::Llvm,
-            override_codegen_backend: None,
-        }
-    }
-
     /// FIXME: this run scheme is... confusing.
     pub fn run_enabled(&self) -> bool {
         self.run.unwrap_or_else(|| {
diff --git a/src/tools/compiletest/src/lib.rs b/src/tools/compiletest/src/lib.rs
index ac1a8226112a9..1a0b117e4b297 100644
--- a/src/tools/compiletest/src/lib.rs
+++ b/src/tools/compiletest/src/lib.rs
@@ -16,6 +16,7 @@ mod panic_hook;
 mod raise_fd_limit;
 mod read2;
 pub mod runtest;
+pub mod rustdoc_gui_test;
 pub mod util;
 
 use core::panic;
diff --git a/src/tools/compiletest/src/rustdoc_gui_test.rs b/src/tools/compiletest/src/rustdoc_gui_test.rs
new file mode 100644
index 0000000000000..fcb8327a9245c
--- /dev/null
+++ b/src/tools/compiletest/src/rustdoc_gui_test.rs
@@ -0,0 +1,143 @@
+//! This module isolates the compiletest APIs used by the rustdoc-gui-test tool.
+//!
+//! Thanks to this isolation layer, changes to compiletest directive parsing
+//! might require changes to the items in this module, but shouldn't require
+//! changes to rustdoc-gui-test itself.
+//!
+//! The current relationship between compiletest and rustdoc-gui-test is
+//! awkward. Ideally, rustdoc-gui-test should either split off its own
+//! directive parser and become fully independent, or be incorporated into
+//! compiletest as another test mode.
+//!
+//! See <https://github.com/rust-lang/rust/issues/143827> for more context.
+
+use std::path::Path;
+
+use camino::{Utf8Path, Utf8PathBuf};
+
+use crate::common::{CodegenBackend, Config, TestMode, TestSuite};
+use crate::directives::TestProps;
+
+/// Subset of compiletest directive values that are actually used by
+/// rustdoc-gui-test.
+#[derive(Debug)]
+pub struct RustdocGuiTestProps {
+    pub compile_flags: Vec<String>,
+    pub run_flags: Vec<String>,
+}
+
+impl RustdocGuiTestProps {
+    pub fn from_file(test_file_path: &Path) -> Self {
+        let test_file_path = Utf8Path::from_path(test_file_path).unwrap();
+        let config = incomplete_config_for_rustdoc_gui_test();
+
+        let props = TestProps::from_file(test_file_path, None, &config);
+
+        let TestProps { compile_flags, run_flags, .. } = props;
+        Self { compile_flags, run_flags }
+    }
+}
+
+/// Incomplete config intended for `src/tools/rustdoc-gui-test` **only** as
+/// `src/tools/rustdoc-gui-test` wants to reuse `compiletest`'s directive -> test property
+/// handling for `//@ {compile,run}-flags`, do not use for any other purpose.
+///
+/// FIXME(#143827): this setup feels very hacky. It so happens that `tests/rustdoc-gui/`
+/// **only** uses `//@ {compile,run}-flags` for now and not any directives that actually rely on
+/// info that is assumed available in a fully populated [`Config`].
+fn incomplete_config_for_rustdoc_gui_test() -> Config {
+    // FIXME(#143827): spelling this out intentionally, because this is questionable.
+    //
+    // For instance, `//@ ignore-stage1` will not work at all.
+    Config {
+        mode: TestMode::Rustdoc,
+        // E.g. this has no sensible default tbh.
+        suite: TestSuite::Ui,
+
+        // Dummy values.
+        edition: Default::default(),
+        bless: Default::default(),
+        fail_fast: Default::default(),
+        compile_lib_path: Utf8PathBuf::default(),
+        run_lib_path: Utf8PathBuf::default(),
+        rustc_path: Utf8PathBuf::default(),
+        cargo_path: Default::default(),
+        stage0_rustc_path: Default::default(),
+        query_rustc_path: Default::default(),
+        rustdoc_path: Default::default(),
+        coverage_dump_path: Default::default(),
+        python: Default::default(),
+        jsondocck_path: Default::default(),
+        jsondoclint_path: Default::default(),
+        llvm_filecheck: Default::default(),
+        llvm_bin_dir: Default::default(),
+        run_clang_based_tests_with: Default::default(),
+        src_root: Utf8PathBuf::default(),
+        src_test_suite_root: Utf8PathBuf::default(),
+        build_root: Utf8PathBuf::default(),
+        build_test_suite_root: Utf8PathBuf::default(),
+        sysroot_base: Utf8PathBuf::default(),
+        stage: Default::default(),
+        stage_id: String::default(),
+        debugger: Default::default(),
+        run_ignored: Default::default(),
+        with_rustc_debug_assertions: Default::default(),
+        with_std_debug_assertions: Default::default(),
+        filters: Default::default(),
+        skip: Default::default(),
+        filter_exact: Default::default(),
+        force_pass_mode: Default::default(),
+        run: Default::default(),
+        runner: Default::default(),
+        host_rustcflags: Default::default(),
+        target_rustcflags: Default::default(),
+        rust_randomized_layout: Default::default(),
+        optimize_tests: Default::default(),
+        target: Default::default(),
+        host: Default::default(),
+        cdb: Default::default(),
+        cdb_version: Default::default(),
+        gdb: Default::default(),
+        gdb_version: Default::default(),
+        lldb_version: Default::default(),
+        llvm_version: Default::default(),
+        system_llvm: Default::default(),
+        android_cross_path: Default::default(),
+        adb_path: Default::default(),
+        adb_test_dir: Default::default(),
+        adb_device_status: Default::default(),
+        lldb_python_dir: Default::default(),
+        verbose: Default::default(),
+        color: Default::default(),
+        remote_test_client: Default::default(),
+        compare_mode: Default::default(),
+        rustfix_coverage: Default::default(),
+        has_html_tidy: Default::default(),
+        has_enzyme: Default::default(),
+        channel: Default::default(),
+        git_hash: Default::default(),
+        cc: Default::default(),
+        cxx: Default::default(),
+        cflags: Default::default(),
+        cxxflags: Default::default(),
+        ar: Default::default(),
+        target_linker: Default::default(),
+        host_linker: Default::default(),
+        llvm_components: Default::default(),
+        nodejs: Default::default(),
+        npm: Default::default(),
+        force_rerun: Default::default(),
+        only_modified: Default::default(),
+        target_cfgs: Default::default(),
+        builtin_cfg_names: Default::default(),
+        supported_crate_types: Default::default(),
+        nocapture: Default::default(),
+        nightly_branch: Default::default(),
+        git_merge_commit_email: Default::default(),
+        profiler_runtime: Default::default(),
+        diff_command: Default::default(),
+        minicore_path: Default::default(),
+        default_codegen_backend: CodegenBackend::Llvm,
+        override_codegen_backend: None,
+    }
+}
diff --git a/src/tools/rustdoc-gui-test/Cargo.toml b/src/tools/rustdoc-gui-test/Cargo.toml
index 8d958ac94f30e..f7384a98f8565 100644
--- a/src/tools/rustdoc-gui-test/Cargo.toml
+++ b/src/tools/rustdoc-gui-test/Cargo.toml
@@ -5,7 +5,6 @@ edition = "2021"
 
 [dependencies]
 build_helper = { path = "../../build_helper" }
-camino = "1"
 compiletest = { path = "../compiletest" }
 getopts = "0.2"
 walkdir = "2"
diff --git a/src/tools/rustdoc-gui-test/src/main.rs b/src/tools/rustdoc-gui-test/src/main.rs
index 5062c2597f15e..cd10882fc2269 100644
--- a/src/tools/rustdoc-gui-test/src/main.rs
+++ b/src/tools/rustdoc-gui-test/src/main.rs
@@ -5,7 +5,7 @@ use std::sync::Arc;
 
 use build_helper::npm;
 use build_helper::util::try_run;
-use compiletest::directives::TestProps;
+use compiletest::rustdoc_gui_test::RustdocGuiTestProps;
 use config::Config;
 
 mod config;
@@ -43,13 +43,7 @@ fn main() -> Result<(), ()> {
                 .current_dir(path);
 
             if let Some(librs) = find_librs(entry.path()) {
-                let compiletest_c = compiletest::common::Config::incomplete_for_rustdoc_gui_test();
-
-                let test_props = TestProps::from_file(
-                    &camino::Utf8PathBuf::try_from(librs).unwrap(),
-                    None,
-                    &compiletest_c,
-                );
+                let test_props = RustdocGuiTestProps::from_file(&librs);
 
                 if !test_props.compile_flags.is_empty() {
                     cargo.env("RUSTDOCFLAGS", test_props.compile_flags.join(" "));

From b4f64fda4fcbb021f5a85a456b4b3c3560113e86 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Thu, 9 Oct 2025 13:52:01 +1100
Subject: [PATCH 1841/1889] compiletest: Isolate APIs used by `bin/main.rs`

---
 src/tools/compiletest/src/bin/main.rs | 22 +---------------------
 src/tools/compiletest/src/cli.rs      | 26 ++++++++++++++++++++++++++
 src/tools/compiletest/src/lib.rs      |  1 +
 3 files changed, 28 insertions(+), 21 deletions(-)
 create mode 100644 src/tools/compiletest/src/cli.rs

diff --git a/src/tools/compiletest/src/bin/main.rs b/src/tools/compiletest/src/bin/main.rs
index 8fac6ccdc582b..3e608d57e81a7 100644
--- a/src/tools/compiletest/src/bin/main.rs
+++ b/src/tools/compiletest/src/bin/main.rs
@@ -1,23 +1,3 @@
-use std::env;
-use std::io::IsTerminal;
-use std::sync::Arc;
-
-use compiletest::{early_config_check, parse_config, run_tests};
-
 fn main() {
-    tracing_subscriber::fmt::init();
-
-    // colored checks stdout by default, but for some reason only stderr is a terminal.
-    // compiletest *does* print many things to stdout, but it doesn't really matter.
-    if std::io::stderr().is_terminal()
-        && matches!(std::env::var("NO_COLOR").as_deref(), Err(_) | Ok("0"))
-    {
-        colored::control::set_override(true);
-    }
-
-    let config = Arc::new(parse_config(env::args().collect()));
-
-    early_config_check(&config);
-
-    run_tests(config);
+    compiletest::cli::main();
 }
diff --git a/src/tools/compiletest/src/cli.rs b/src/tools/compiletest/src/cli.rs
new file mode 100644
index 0000000000000..763c46550b411
--- /dev/null
+++ b/src/tools/compiletest/src/cli.rs
@@ -0,0 +1,26 @@
+//! Isolates the APIs used by `bin/main.rs`, to help minimize the surface area
+//! of public exports from the compiletest library crate.
+
+use std::env;
+use std::io::IsTerminal;
+use std::sync::Arc;
+
+use crate::{early_config_check, parse_config, run_tests};
+
+pub fn main() {
+    tracing_subscriber::fmt::init();
+
+    // colored checks stdout by default, but for some reason only stderr is a terminal.
+    // compiletest *does* print many things to stdout, but it doesn't really matter.
+    if std::io::stderr().is_terminal()
+        && matches!(std::env::var("NO_COLOR").as_deref(), Err(_) | Ok("0"))
+    {
+        colored::control::set_override(true);
+    }
+
+    let config = Arc::new(parse_config(env::args().collect()));
+
+    early_config_check(&config);
+
+    run_tests(config);
+}
diff --git a/src/tools/compiletest/src/lib.rs b/src/tools/compiletest/src/lib.rs
index 1a0b117e4b297..c8f844c60016c 100644
--- a/src/tools/compiletest/src/lib.rs
+++ b/src/tools/compiletest/src/lib.rs
@@ -3,6 +3,7 @@
 #[cfg(test)]
 mod tests;
 
+pub mod cli;
 pub mod common;
 mod debuggers;
 pub mod diagnostics;

From ce4699deffc6cc00169b130d2acd541696db2299 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Thu, 9 Oct 2025 14:19:58 +1100
Subject: [PATCH 1842/1889] compiletest: Make all other modules non-public

All APIs used from outside the compiletest library crate have been isolated to
the `cli` and `rustdoc_gui_test` modules, so no other items need to be publicly
exported.
---
 src/bootstrap/src/core/build_steps/test.rs    |  3 --
 src/tools/compiletest/src/common.rs           |  5 ++-
 src/tools/compiletest/src/directives.rs       |  3 --
 src/tools/compiletest/src/lib.rs              | 34 +++++++------------
 src/tools/compiletest/src/rustdoc_gui_test.rs |  1 -
 src/tools/compiletest/src/util.rs             |  2 ++
 6 files changed, 17 insertions(+), 31 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index 00aea8feab7de..154b209b20252 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -1974,9 +1974,6 @@ HELP: You can add it into `bootstrap.toml` in `rust.codegen-backends = [{name:?}
         } else if mode == "rustdoc-js" {
             panic!("need nodejs to run rustdoc-js suite");
         }
-        if let Some(ref npm) = builder.config.npm {
-            cmd.arg("--npm").arg(npm);
-        }
         if builder.config.rust_optimize_tests {
             cmd.arg("--optimize-tests");
         }
diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
index 7a75803c78277..58330ed20dc88 100644
--- a/src/tools/compiletest/src/common.rs
+++ b/src/tools/compiletest/src/common.rs
@@ -631,8 +631,6 @@ pub struct Config {
 
     /// Path to a NodeJS executable. Used for JS doctests, emscripten and WASM tests.
     pub nodejs: Option<String>,
-    /// Path to a npm executable. Used for rustdoc GUI tests.
-    pub npm: Option<String>,
 
     /// Whether to rerun tests even if the inputs are unchanged.
     pub force_rerun: bool,
@@ -721,7 +719,8 @@ impl Config {
         self.target_cfg().abi == abi
     }
 
-    pub fn matches_family(&self, family: &str) -> bool {
+    #[cfg_attr(not(test), expect(dead_code, reason = "only used by tests for `ignore-{family}`"))]
+    pub(crate) fn matches_family(&self, family: &str) -> bool {
         self.target_cfg().families.iter().any(|f| f == family)
     }
 
diff --git a/src/tools/compiletest/src/directives.rs b/src/tools/compiletest/src/directives.rs
index 34ecbc2d59f10..2d45495d4f8ae 100644
--- a/src/tools/compiletest/src/directives.rs
+++ b/src/tools/compiletest/src/directives.rs
@@ -198,8 +198,6 @@ pub struct TestProps {
     pub filecheck_flags: Vec<String>,
     /// Don't automatically insert any `--check-cfg` args
     pub no_auto_check_cfg: bool,
-    /// Run tests which require enzyme being build
-    pub has_enzyme: bool,
     /// Build and use `minicore` as `core` stub for `no_core` tests in cross-compilation scenarios
     /// that don't otherwise want/need `-Z build-std`.
     pub add_core_stubs: bool,
@@ -314,7 +312,6 @@ impl TestProps {
             llvm_cov_flags: vec![],
             filecheck_flags: vec![],
             no_auto_check_cfg: false,
-            has_enzyme: false,
             add_core_stubs: false,
             core_stubs_compile_flags: vec![],
             dont_require_annotations: Default::default(),
diff --git a/src/tools/compiletest/src/lib.rs b/src/tools/compiletest/src/lib.rs
index c8f844c60016c..48ae38b61b93d 100644
--- a/src/tools/compiletest/src/lib.rs
+++ b/src/tools/compiletest/src/lib.rs
@@ -4,21 +4,21 @@
 mod tests;
 
 pub mod cli;
-pub mod common;
+mod common;
 mod debuggers;
-pub mod diagnostics;
-pub mod directives;
-pub mod edition;
-pub mod errors;
+mod diagnostics;
+mod directives;
+mod edition;
+mod errors;
 mod executor;
 mod json;
 mod output_capture;
 mod panic_hook;
 mod raise_fd_limit;
 mod read2;
-pub mod runtest;
+mod runtest;
 pub mod rustdoc_gui_test;
-pub mod util;
+mod util;
 
 use core::panic;
 use std::collections::HashSet;
@@ -50,7 +50,7 @@ use crate::executor::{CollectedTest, ColorConfig};
 /// The config mostly reflects command-line arguments, but there might also be
 /// some code here that inspects environment variables or even runs executables
 /// (e.g. when discovering debugger versions).
-pub fn parse_config(args: Vec<String>) -> Config {
+fn parse_config(args: Vec<String>) -> Config {
     let mut opts = Options::new();
     opts.reqopt("", "compile-lib-path", "path to host shared libraries", "PATH")
         .reqopt("", "run-lib-path", "path to target shared libraries", "PATH")
@@ -464,7 +464,6 @@ pub fn parse_config(args: Vec<String>) -> Config {
         host_linker: matches.opt_str("host-linker"),
         llvm_components: matches.opt_str("llvm-components").unwrap(),
         nodejs: matches.opt_str("nodejs"),
-        npm: matches.opt_str("npm"),
 
         force_rerun: matches.opt_present("force-rerun"),
 
@@ -488,14 +487,7 @@ pub fn parse_config(args: Vec<String>) -> Config {
     }
 }
 
-pub fn opt_str(maybestr: &Option<String>) -> &str {
-    match *maybestr {
-        None => "(none)",
-        Some(ref s) => s,
-    }
-}
-
-pub fn opt_str2(maybestr: Option<String>) -> String {
+fn opt_str2(maybestr: Option<String>) -> String {
     match maybestr {
         None => "(none)".to_owned(),
         Some(s) => s,
@@ -503,7 +495,7 @@ pub fn opt_str2(maybestr: Option<String>) -> String {
 }
 
 /// Called by `main` after the config has been parsed.
-pub fn run_tests(config: Arc<Config>) {
+fn run_tests(config: Arc<Config>) {
     debug!(?config, "run_tests");
 
     panic_hook::install_panic_hook();
@@ -641,7 +633,7 @@ impl TestCollector {
 /// FIXME(Zalathar): Now that we no longer rely on libtest, try to overhaul
 /// test discovery to take into account the filters/tests specified on the
 /// command-line, instead of having to enumerate everything.
-pub(crate) fn collect_and_make_tests(config: Arc<Config>) -> Vec<CollectedTest> {
+fn collect_and_make_tests(config: Arc<Config>) -> Vec<CollectedTest> {
     debug!("making tests from {}", config.src_test_suite_root);
     let common_inputs_stamp = common_inputs_stamp(&config);
     let modified_tests =
@@ -853,7 +845,7 @@ fn collect_tests_from_dir(
 }
 
 /// Returns true if `file_name` looks like a proper test file name.
-pub fn is_test(file_name: &str) -> bool {
+fn is_test(file_name: &str) -> bool {
     if !file_name.ends_with(".rs") {
         return false;
     }
@@ -1133,7 +1125,7 @@ fn check_for_overlapping_test_paths(found_path_stems: &HashSet<Utf8PathBuf>) {
     }
 }
 
-pub fn early_config_check(config: &Config) {
+fn early_config_check(config: &Config) {
     if !config.has_html_tidy && config.mode == TestMode::Rustdoc {
         warning!("`tidy` (html-tidy.org) is not installed; diffs will not be generated");
     }
diff --git a/src/tools/compiletest/src/rustdoc_gui_test.rs b/src/tools/compiletest/src/rustdoc_gui_test.rs
index fcb8327a9245c..4bd3531f4b433 100644
--- a/src/tools/compiletest/src/rustdoc_gui_test.rs
+++ b/src/tools/compiletest/src/rustdoc_gui_test.rs
@@ -125,7 +125,6 @@ fn incomplete_config_for_rustdoc_gui_test() -> Config {
         host_linker: Default::default(),
         llvm_components: Default::default(),
         nodejs: Default::default(),
-        npm: Default::default(),
         force_rerun: Default::default(),
         only_modified: Default::default(),
         target_cfgs: Default::default(),
diff --git a/src/tools/compiletest/src/util.rs b/src/tools/compiletest/src/util.rs
index 558e9a58697e7..a189c1d1c2dfc 100644
--- a/src/tools/compiletest/src/util.rs
+++ b/src/tools/compiletest/src/util.rs
@@ -102,7 +102,9 @@ macro_rules! string_enum {
         }
 
         impl $name {
+            #[allow(dead_code)]
             $vis const VARIANTS: &'static [Self] = &[$(Self::$variant,)*];
+            #[allow(dead_code)]
             $vis const STR_VARIANTS: &'static [&'static str] = &[$(Self::$variant.to_str(),)*];
 
             $vis const fn to_str(&self) -> &'static str {

From 064e3b82120992d44a1a0bd65bb502624a600521 Mon Sep 17 00:00:00 2001
From: AMS21 <ams21.github@gmail.com>
Date: Thu, 9 Oct 2025 08:09:56 +0200
Subject: [PATCH 1843/1889] remove intrinsic wrapper functions from LLVM
 bindings

---
 compiler/rustc_codegen_llvm/src/builder.rs    | 50 ++++++++-------
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs   | 47 --------------
 .../rustc_llvm/llvm-wrapper/RustWrapper.cpp   | 63 -------------------
 3 files changed, 28 insertions(+), 132 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
index 9673f69906f7b..c082a82306848 100644
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -1518,14 +1518,13 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
     pub(crate) fn set_unpredictable(&mut self, inst: &'ll Value) {
         self.set_metadata_node(inst, llvm::MD_unpredictable, &[]);
     }
-}
-impl<'a, 'll, CX: Borrow<SCx<'ll>>> GenericBuilder<'a, 'll, CX> {
+
     pub(crate) fn minnum(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
-        unsafe { llvm::LLVMRustBuildMinNum(self.llbuilder, lhs, rhs) }
+        self.call_intrinsic("llvm.minnum", &[self.val_ty(lhs)], &[lhs, rhs])
     }
 
     pub(crate) fn maxnum(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
-        unsafe { llvm::LLVMRustBuildMaxNum(self.llbuilder, lhs, rhs) }
+        self.call_intrinsic("llvm.maxnum", &[self.val_ty(lhs)], &[lhs, rhs])
     }
 
     pub(crate) fn insert_element(
@@ -1547,10 +1546,10 @@ impl<'a, 'll, CX: Borrow<SCx<'ll>>> GenericBuilder<'a, 'll, CX> {
     }
 
     pub(crate) fn vector_reduce_fadd(&mut self, acc: &'ll Value, src: &'ll Value) -> &'ll Value {
-        unsafe { llvm::LLVMRustBuildVectorReduceFAdd(self.llbuilder, acc, src) }
+        self.call_intrinsic("llvm.vector.reduce.fadd", &[self.val_ty(src)], &[acc, src])
     }
     pub(crate) fn vector_reduce_fmul(&mut self, acc: &'ll Value, src: &'ll Value) -> &'ll Value {
-        unsafe { llvm::LLVMRustBuildVectorReduceFMul(self.llbuilder, acc, src) }
+        self.call_intrinsic("llvm.vector.reduce.fmul", &[self.val_ty(src)], &[acc, src])
     }
     pub(crate) fn vector_reduce_fadd_reassoc(
         &mut self,
@@ -1558,7 +1557,8 @@ impl<'a, 'll, CX: Borrow<SCx<'ll>>> GenericBuilder<'a, 'll, CX> {
         src: &'ll Value,
     ) -> &'ll Value {
         unsafe {
-            let instr = llvm::LLVMRustBuildVectorReduceFAdd(self.llbuilder, acc, src);
+            let instr =
+                self.call_intrinsic("llvm.vector.reduce.fadd", &[self.val_ty(src)], &[acc, src]);
             llvm::LLVMRustSetAllowReassoc(instr);
             instr
         }
@@ -1569,43 +1569,49 @@ impl<'a, 'll, CX: Borrow<SCx<'ll>>> GenericBuilder<'a, 'll, CX> {
         src: &'ll Value,
     ) -> &'ll Value {
         unsafe {
-            let instr = llvm::LLVMRustBuildVectorReduceFMul(self.llbuilder, acc, src);
+            let instr =
+                self.call_intrinsic("llvm.vector.reduce.fmul", &[self.val_ty(src)], &[acc, src]);
             llvm::LLVMRustSetAllowReassoc(instr);
             instr
         }
     }
     pub(crate) fn vector_reduce_add(&mut self, src: &'ll Value) -> &'ll Value {
-        unsafe { llvm::LLVMRustBuildVectorReduceAdd(self.llbuilder, src) }
+        self.call_intrinsic("llvm.vector.reduce.add", &[self.val_ty(src)], &[src])
     }
     pub(crate) fn vector_reduce_mul(&mut self, src: &'ll Value) -> &'ll Value {
-        unsafe { llvm::LLVMRustBuildVectorReduceMul(self.llbuilder, src) }
+        self.call_intrinsic("llvm.vector.reduce.mul", &[self.val_ty(src)], &[src])
     }
     pub(crate) fn vector_reduce_and(&mut self, src: &'ll Value) -> &'ll Value {
-        unsafe { llvm::LLVMRustBuildVectorReduceAnd(self.llbuilder, src) }
+        self.call_intrinsic("llvm.vector.reduce.and", &[self.val_ty(src)], &[src])
     }
     pub(crate) fn vector_reduce_or(&mut self, src: &'ll Value) -> &'ll Value {
-        unsafe { llvm::LLVMRustBuildVectorReduceOr(self.llbuilder, src) }
+        self.call_intrinsic("llvm.vector.reduce.or", &[self.val_ty(src)], &[src])
     }
     pub(crate) fn vector_reduce_xor(&mut self, src: &'ll Value) -> &'ll Value {
-        unsafe { llvm::LLVMRustBuildVectorReduceXor(self.llbuilder, src) }
+        self.call_intrinsic("llvm.vector.reduce.xor", &[self.val_ty(src)], &[src])
     }
     pub(crate) fn vector_reduce_fmin(&mut self, src: &'ll Value) -> &'ll Value {
-        unsafe {
-            llvm::LLVMRustBuildVectorReduceFMin(self.llbuilder, src, /*NoNaNs:*/ false)
-        }
+        self.call_intrinsic("llvm.vector.reduce.fmin", &[self.val_ty(src)], &[src])
     }
     pub(crate) fn vector_reduce_fmax(&mut self, src: &'ll Value) -> &'ll Value {
-        unsafe {
-            llvm::LLVMRustBuildVectorReduceFMax(self.llbuilder, src, /*NoNaNs:*/ false)
-        }
+        self.call_intrinsic("llvm.vector.reduce.fmax", &[self.val_ty(src)], &[src])
     }
     pub(crate) fn vector_reduce_min(&mut self, src: &'ll Value, is_signed: bool) -> &'ll Value {
-        unsafe { llvm::LLVMRustBuildVectorReduceMin(self.llbuilder, src, is_signed) }
+        self.call_intrinsic(
+            if is_signed { "llvm.vector.reduce.smin" } else { "llvm.vector.reduce.umin" },
+            &[self.val_ty(src)],
+            &[src],
+        )
     }
     pub(crate) fn vector_reduce_max(&mut self, src: &'ll Value, is_signed: bool) -> &'ll Value {
-        unsafe { llvm::LLVMRustBuildVectorReduceMax(self.llbuilder, src, is_signed) }
+        self.call_intrinsic(
+            if is_signed { "llvm.vector.reduce.smax" } else { "llvm.vector.reduce.umax" },
+            &[self.val_ty(src)],
+            &[src],
+        )
     }
-
+}
+impl<'a, 'll, CX: Borrow<SCx<'ll>>> GenericBuilder<'a, 'll, CX> {
     pub(crate) fn add_clause(&mut self, landing_pad: &'ll Value, clause: &'ll Value) {
         unsafe {
             llvm::LLVMAddClause(landing_pad, clause);
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 7e62630f3f98f..fdd73ad86e463 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -2044,53 +2044,6 @@ unsafe extern "C" {
         IsVolatile: bool,
     ) -> &'a Value;
 
-    pub(crate) fn LLVMRustBuildVectorReduceFAdd<'a>(
-        B: &Builder<'a>,
-        Acc: &'a Value,
-        Src: &'a Value,
-    ) -> &'a Value;
-    pub(crate) fn LLVMRustBuildVectorReduceFMul<'a>(
-        B: &Builder<'a>,
-        Acc: &'a Value,
-        Src: &'a Value,
-    ) -> &'a Value;
-    pub(crate) fn LLVMRustBuildVectorReduceAdd<'a>(B: &Builder<'a>, Src: &'a Value) -> &'a Value;
-    pub(crate) fn LLVMRustBuildVectorReduceMul<'a>(B: &Builder<'a>, Src: &'a Value) -> &'a Value;
-    pub(crate) fn LLVMRustBuildVectorReduceAnd<'a>(B: &Builder<'a>, Src: &'a Value) -> &'a Value;
-    pub(crate) fn LLVMRustBuildVectorReduceOr<'a>(B: &Builder<'a>, Src: &'a Value) -> &'a Value;
-    pub(crate) fn LLVMRustBuildVectorReduceXor<'a>(B: &Builder<'a>, Src: &'a Value) -> &'a Value;
-    pub(crate) fn LLVMRustBuildVectorReduceMin<'a>(
-        B: &Builder<'a>,
-        Src: &'a Value,
-        IsSigned: bool,
-    ) -> &'a Value;
-    pub(crate) fn LLVMRustBuildVectorReduceMax<'a>(
-        B: &Builder<'a>,
-        Src: &'a Value,
-        IsSigned: bool,
-    ) -> &'a Value;
-    pub(crate) fn LLVMRustBuildVectorReduceFMin<'a>(
-        B: &Builder<'a>,
-        Src: &'a Value,
-        IsNaN: bool,
-    ) -> &'a Value;
-    pub(crate) fn LLVMRustBuildVectorReduceFMax<'a>(
-        B: &Builder<'a>,
-        Src: &'a Value,
-        IsNaN: bool,
-    ) -> &'a Value;
-
-    pub(crate) fn LLVMRustBuildMinNum<'a>(
-        B: &Builder<'a>,
-        LHS: &'a Value,
-        RHS: &'a Value,
-    ) -> &'a Value;
-    pub(crate) fn LLVMRustBuildMaxNum<'a>(
-        B: &Builder<'a>,
-        LHS: &'a Value,
-        RHS: &'a Value,
-    ) -> &'a Value;
-
     pub(crate) fn LLVMRustTimeTraceProfilerInitialize();
 
     pub(crate) fn LLVMRustTimeTraceProfilerFinishThread();
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index 38d677cfa3403..29cef07462af7 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -1481,69 +1481,6 @@ extern "C" void LLVMRustModuleInstructionStats(LLVMModuleRef M,
   });
 }
 
-// Vector reductions:
-extern "C" LLVMValueRef LLVMRustBuildVectorReduceFAdd(LLVMBuilderRef B,
-                                                      LLVMValueRef Acc,
-                                                      LLVMValueRef Src) {
-  return wrap(unwrap(B)->CreateFAddReduce(unwrap(Acc), unwrap(Src)));
-}
-extern "C" LLVMValueRef LLVMRustBuildVectorReduceFMul(LLVMBuilderRef B,
-                                                      LLVMValueRef Acc,
-                                                      LLVMValueRef Src) {
-  return wrap(unwrap(B)->CreateFMulReduce(unwrap(Acc), unwrap(Src)));
-}
-extern "C" LLVMValueRef LLVMRustBuildVectorReduceAdd(LLVMBuilderRef B,
-                                                     LLVMValueRef Src) {
-  return wrap(unwrap(B)->CreateAddReduce(unwrap(Src)));
-}
-extern "C" LLVMValueRef LLVMRustBuildVectorReduceMul(LLVMBuilderRef B,
-                                                     LLVMValueRef Src) {
-  return wrap(unwrap(B)->CreateMulReduce(unwrap(Src)));
-}
-extern "C" LLVMValueRef LLVMRustBuildVectorReduceAnd(LLVMBuilderRef B,
-                                                     LLVMValueRef Src) {
-  return wrap(unwrap(B)->CreateAndReduce(unwrap(Src)));
-}
-extern "C" LLVMValueRef LLVMRustBuildVectorReduceOr(LLVMBuilderRef B,
-                                                    LLVMValueRef Src) {
-  return wrap(unwrap(B)->CreateOrReduce(unwrap(Src)));
-}
-extern "C" LLVMValueRef LLVMRustBuildVectorReduceXor(LLVMBuilderRef B,
-                                                     LLVMValueRef Src) {
-  return wrap(unwrap(B)->CreateXorReduce(unwrap(Src)));
-}
-extern "C" LLVMValueRef LLVMRustBuildVectorReduceMin(LLVMBuilderRef B,
-                                                     LLVMValueRef Src,
-                                                     bool IsSigned) {
-  return wrap(unwrap(B)->CreateIntMinReduce(unwrap(Src), IsSigned));
-}
-extern "C" LLVMValueRef LLVMRustBuildVectorReduceMax(LLVMBuilderRef B,
-                                                     LLVMValueRef Src,
-                                                     bool IsSigned) {
-  return wrap(unwrap(B)->CreateIntMaxReduce(unwrap(Src), IsSigned));
-}
-extern "C" LLVMValueRef
-LLVMRustBuildVectorReduceFMin(LLVMBuilderRef B, LLVMValueRef Src, bool NoNaN) {
-  Instruction *I = unwrap(B)->CreateFPMinReduce(unwrap(Src));
-  I->setHasNoNaNs(NoNaN);
-  return wrap(I);
-}
-extern "C" LLVMValueRef
-LLVMRustBuildVectorReduceFMax(LLVMBuilderRef B, LLVMValueRef Src, bool NoNaN) {
-  Instruction *I = unwrap(B)->CreateFPMaxReduce(unwrap(Src));
-  I->setHasNoNaNs(NoNaN);
-  return wrap(I);
-}
-
-extern "C" LLVMValueRef LLVMRustBuildMinNum(LLVMBuilderRef B, LLVMValueRef LHS,
-                                            LLVMValueRef RHS) {
-  return wrap(unwrap(B)->CreateMinNum(unwrap(LHS), unwrap(RHS)));
-}
-extern "C" LLVMValueRef LLVMRustBuildMaxNum(LLVMBuilderRef B, LLVMValueRef LHS,
-                                            LLVMValueRef RHS) {
-  return wrap(unwrap(B)->CreateMaxNum(unwrap(LHS), unwrap(RHS)));
-}
-
 // Transfers ownership of DiagnosticHandler unique_ptr to the caller.
 extern "C" DiagnosticHandler *
 LLVMRustContextGetDiagnosticHandler(LLVMContextRef C) {

From 7374789331637f3c32f33fc851227728b73d9b61 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 8 Oct 2025 21:25:13 +1100
Subject: [PATCH 1844/1889] Support `x check rustdoc-gui-test`

This is useful for ensuring that changes to compiletest haven't broken
rustdoc-gui-test.
---
 src/bootstrap/src/core/build_steps/check.rs | 9 +++++++++
 src/bootstrap/src/core/builder/mod.rs       | 1 +
 2 files changed, 10 insertions(+)

diff --git a/src/bootstrap/src/core/build_steps/check.rs b/src/bootstrap/src/core/build_steps/check.rs
index 20c54a28dda83..400c6f732c3c3 100644
--- a/src/bootstrap/src/core/build_steps/check.rs
+++ b/src/bootstrap/src/core/build_steps/check.rs
@@ -821,6 +821,15 @@ tool_check_step!(Compiletest {
     default: false,
 });
 
+// As with compiletest, rustdoc-gui-test is automatically built when running
+// relevant tests. So being able to check it is mainly useful for people
+// working on on rustdoc-gui-test itself, or on its compiletest dependency.
+tool_check_step!(RustdocGuiTest {
+    path: "src/tools/rustdoc-gui-test",
+    mode: Mode::ToolBootstrap,
+    default: false,
+});
+
 tool_check_step!(Linkchecker {
     path: "src/tools/linkchecker",
     mode: Mode::ToolBootstrap,
diff --git a/src/bootstrap/src/core/builder/mod.rs b/src/bootstrap/src/core/builder/mod.rs
index fc06db8f80b9d..cd3961056d2c1 100644
--- a/src/bootstrap/src/core/builder/mod.rs
+++ b/src/bootstrap/src/core/builder/mod.rs
@@ -1071,6 +1071,7 @@ impl<'a> Builder<'a> {
                 check::Bootstrap,
                 check::RunMakeSupport,
                 check::Compiletest,
+                check::RustdocGuiTest,
                 check::FeaturesStatusDump,
                 check::CoverageDump,
                 check::Linkchecker,

From 0be0a0a8d2b09441767e17ab1c30c7ef27c80713 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 8 Oct 2025 21:42:28 +1100
Subject: [PATCH 1845/1889] Do `x check` on various bootstrap tools in CI

---
 src/ci/docker/host-x86_64/pr-check-1/Dockerfile | 12 +++++++++++-
 src/ci/docker/host-x86_64/pr-check-2/Dockerfile |  1 -
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/src/ci/docker/host-x86_64/pr-check-1/Dockerfile b/src/ci/docker/host-x86_64/pr-check-1/Dockerfile
index 776bbb12e445b..32e1b30dab962 100644
--- a/src/ci/docker/host-x86_64/pr-check-1/Dockerfile
+++ b/src/ci/docker/host-x86_64/pr-check-1/Dockerfile
@@ -40,7 +40,17 @@ COPY host-x86_64/pr-check-1/validate-toolstate.sh /scripts/
 # We disable optimized compiler built-ins because that requires a C toolchain for the target.
 # We also skip the x86_64-unknown-linux-gnu target as it is well-tested by other jobs.
 ENV SCRIPT \
-  python3 ../x.py check bootstrap && \
+  # Check some tools that aren't included in `x check` by default, to
+  # ensure that maintainers can still do check builds locally.
+  python3 ../x.py check \
+    bootstrap \
+    bump-stage0 \
+    compiletest \
+    coverage-dump \
+    linkchecker \
+    run-make-support \
+    rustdoc-gui-test \
+    && \
   /scripts/check-default-config-profiles.sh && \
   python3 ../x.py build src/tools/build-manifest && \
   python3 ../x.py check --target=i686-pc-windows-gnu --host=i686-pc-windows-gnu && \
diff --git a/src/ci/docker/host-x86_64/pr-check-2/Dockerfile b/src/ci/docker/host-x86_64/pr-check-2/Dockerfile
index 0a95f428f5bd8..c005eceb6ef4a 100644
--- a/src/ci/docker/host-x86_64/pr-check-2/Dockerfile
+++ b/src/ci/docker/host-x86_64/pr-check-2/Dockerfile
@@ -28,7 +28,6 @@ RUN sh /scripts/sccache.sh
 
 ENV SCRIPT \
         python3 ../x.py check && \
-        python3 ../x.py check src/tools/bump-stage0 && \
         python3 ../x.py clippy ci --stage 2 && \
         python3 ../x.py test --stage 1 core alloc std test proc_macro && \
         python3 ../x.py test --stage 1 src/tools/compiletest && \

From d4edd67f71fb3949c9280acbbb96a5391b9e1dac Mon Sep 17 00:00:00 2001
From: dianqk <dianqk@dianqk.net>
Date: Thu, 9 Oct 2025 18:23:56 +0800
Subject: [PATCH 1846/1889] Update LLVM to 21.1.3

---
 src/llvm-project | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/llvm-project b/src/llvm-project
index 8c30b9c5098bd..4f74b76fb6968 160000
--- a/src/llvm-project
+++ b/src/llvm-project
@@ -1 +1 @@
-Subproject commit 8c30b9c5098bdff1d3d9a2d460ee091cd1171e60
+Subproject commit 4f74b76fb69688474e073fb26b316d9ea571388f

From c3432bbec01a6b72374b95f721e936969d4a04a8 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Thu, 9 Oct 2025 11:51:17 +0000
Subject: [PATCH 1847/1889] Explicit comment.

---
 compiler/rustc_mir_transform/src/lib.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/lib.rs b/compiler/rustc_mir_transform/src/lib.rs
index acf5a5c86f715..f4f61c80a220a 100644
--- a/compiler/rustc_mir_transform/src/lib.rs
+++ b/compiler/rustc_mir_transform/src/lib.rs
@@ -699,8 +699,8 @@ pub(crate) fn run_optimization_passes<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'
             &o1(simplify::SimplifyCfg::AfterUnreachableEnumBranching),
             &multiple_return_terminators::MultipleReturnTerminators,
             // After simplifycfg, it allows us to discover new opportunities for peephole
-            // optimizations. This invalidates CFG caches, so avoid putting between two SSA
-            // analyses.
+            // optimizations. This invalidates CFG caches, so avoid putting between
+            // `ReferencePropagation` and `GVN` which both use the dominator tree.
             &instsimplify::InstSimplify::AfterSimplifyCfg,
             &ref_prop::ReferencePropagation,
             &sroa::ScalarReplacementOfAggregates,

From f3f83857d928d931171339910f37900fd5f03283 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 8 Oct 2025 21:08:40 +1100
Subject: [PATCH 1848/1889] Use the same directive lines for EarlyProps and
 ignore/only/needs

---
 src/tools/compiletest/src/directives.rs       | 58 ++++++++-----------
 src/tools/compiletest/src/directives/file.rs  | 24 ++++++++
 src/tools/compiletest/src/directives/tests.rs | 12 ++--
 src/tools/compiletest/src/lib.rs              | 11 ++--
 4 files changed, 62 insertions(+), 43 deletions(-)
 create mode 100644 src/tools/compiletest/src/directives/file.rs

diff --git a/src/tools/compiletest/src/directives.rs b/src/tools/compiletest/src/directives.rs
index 34a9d77ce0dfa..c96a1be38fee3 100644
--- a/src/tools/compiletest/src/directives.rs
+++ b/src/tools/compiletest/src/directives.rs
@@ -12,6 +12,7 @@ use crate::directives::auxiliary::{AuxProps, parse_and_update_aux};
 use crate::directives::directive_names::{
     KNOWN_DIRECTIVE_NAMES, KNOWN_HTMLDOCCK_DIRECTIVE_NAMES, KNOWN_JSONDOCCK_DIRECTIVE_NAMES,
 };
+pub(crate) use crate::directives::file::FileDirectives;
 use crate::directives::line::{DirectiveLine, line_directive};
 use crate::directives::needs::CachedNeedsConditions;
 use crate::edition::{Edition, parse_edition};
@@ -23,6 +24,7 @@ use crate::{fatal, help};
 pub(crate) mod auxiliary;
 mod cfg;
 mod directive_names;
+mod file;
 mod line;
 mod needs;
 #[cfg(test)]
@@ -41,31 +43,29 @@ impl DirectivesCache {
 /// Properties which must be known very early, before actually running
 /// the test.
 #[derive(Default)]
-pub struct EarlyProps {
+pub(crate) struct EarlyProps {
     /// Auxiliary crates that should be built and made available to this test.
     /// Included in [`EarlyProps`] so that the indicated files can participate
     /// in up-to-date checking. Building happens via [`TestProps::aux`] instead.
     pub(crate) aux: AuxProps,
-    pub revisions: Vec<String>,
+    pub(crate) revisions: Vec<String>,
 }
 
 impl EarlyProps {
-    pub fn from_file(config: &Config, testfile: &Utf8Path) -> Self {
-        let file_contents =
-            fs::read_to_string(testfile).expect("read test file to parse earlyprops");
-        Self::from_file_contents(config, testfile, &file_contents)
-    }
-
-    pub fn from_file_contents(config: &Config, testfile: &Utf8Path, file_contents: &str) -> Self {
+    pub(crate) fn from_file_directives(
+        config: &Config,
+        file_directives: &FileDirectives<'_>,
+    ) -> Self {
+        let testfile = file_directives.path;
         let mut props = EarlyProps::default();
         let mut poisoned = false;
+
         iter_directives(
             config.mode,
             &mut poisoned,
-            testfile,
-            file_contents,
+            file_directives,
             // (dummy comment to force args into vertical layout)
-            &mut |ref ln: DirectiveLine<'_>| {
+            &mut |ln: &DirectiveLine<'_>| {
                 parse_and_update_aux(config, ln, testfile, &mut props.aux);
                 config.parse_and_update_revisions(testfile, ln, &mut props.revisions);
             },
@@ -358,15 +358,15 @@ impl TestProps {
         let mut has_edition = false;
         if !testfile.is_dir() {
             let file_contents = fs::read_to_string(testfile).unwrap();
+            let file_directives = FileDirectives::from_file_contents(testfile, &file_contents);
 
             let mut poisoned = false;
 
             iter_directives(
                 config.mode,
                 &mut poisoned,
-                testfile,
-                &file_contents,
-                &mut |ref ln: DirectiveLine<'_>| {
+                &file_directives,
+                &mut |ln: &DirectiveLine<'_>| {
                     if !ln.applies_to_test_revision(test_revision) {
                         return;
                     }
@@ -851,13 +851,10 @@ fn check_directive<'a>(
 fn iter_directives(
     mode: TestMode,
     poisoned: &mut bool,
-    testfile: &Utf8Path,
-    file_contents: &str,
-    it: &mut dyn FnMut(DirectiveLine<'_>),
+    file_directives: &FileDirectives<'_>,
+    it: &mut dyn FnMut(&DirectiveLine<'_>),
 ) {
-    if testfile.is_dir() {
-        return;
-    }
+    let testfile = file_directives.path;
 
     // Coverage tests in coverage-run mode always have these extra directives, without needing to
     // specify them manually in every test file.
@@ -875,21 +872,15 @@ fn iter_directives(
         for directive_str in extra_directives {
             let directive_line = line_directive(0, directive_str)
                 .unwrap_or_else(|| panic!("bad extra-directive line: {directive_str:?}"));
-            it(directive_line);
+            it(&directive_line);
         }
     }
 
-    for (line_number, ln) in (1..).zip(file_contents.lines()) {
-        let ln = ln.trim();
-
-        let Some(directive_line) = line_directive(line_number, ln) else {
-            continue;
-        };
-
+    for directive_line @ &DirectiveLine { line_number, .. } in &file_directives.lines {
         // Perform unknown directive check on Rust files.
         if testfile.extension() == Some("rs") {
             let CheckDirectiveResult { is_known_directive, trailing_directive } =
-                check_directive(&directive_line, mode);
+                check_directive(directive_line, mode);
 
             if !is_known_directive {
                 *poisoned = true;
@@ -1349,7 +1340,7 @@ pub(crate) fn make_test_description(
     name: String,
     path: &Utf8Path,
     filterable_path: &Utf8Path,
-    file_contents: &str,
+    file_directives: &FileDirectives<'_>,
     test_revision: Option<&str>,
     poisoned: &mut bool,
 ) -> CollectedTestDesc {
@@ -1363,9 +1354,8 @@ pub(crate) fn make_test_description(
     iter_directives(
         config.mode,
         &mut local_poisoned,
-        path,
-        file_contents,
-        &mut |ref ln @ DirectiveLine { line_number, .. }| {
+        file_directives,
+        &mut |ln @ &DirectiveLine { line_number, .. }| {
             if !ln.applies_to_test_revision(test_revision) {
                 return;
             }
diff --git a/src/tools/compiletest/src/directives/file.rs b/src/tools/compiletest/src/directives/file.rs
new file mode 100644
index 0000000000000..afb9bb188bd39
--- /dev/null
+++ b/src/tools/compiletest/src/directives/file.rs
@@ -0,0 +1,24 @@
+use camino::Utf8Path;
+
+use crate::directives::line::{DirectiveLine, line_directive};
+
+pub(crate) struct FileDirectives<'a> {
+    pub(crate) path: &'a Utf8Path,
+    pub(crate) lines: Vec<DirectiveLine<'a>>,
+}
+
+impl<'a> FileDirectives<'a> {
+    pub(crate) fn from_file_contents(path: &'a Utf8Path, file_contents: &'a str) -> Self {
+        let mut lines = vec![];
+
+        for (line_number, ln) in (1..).zip(file_contents.lines()) {
+            let ln = ln.trim();
+
+            if let Some(directive_line) = line_directive(line_number, ln) {
+                lines.push(directive_line);
+            }
+        }
+
+        Self { path, lines }
+    }
+}
diff --git a/src/tools/compiletest/src/directives/tests.rs b/src/tools/compiletest/src/directives/tests.rs
index 77080c7469371..4e7ae6de76a52 100644
--- a/src/tools/compiletest/src/directives/tests.rs
+++ b/src/tools/compiletest/src/directives/tests.rs
@@ -3,7 +3,7 @@ use semver::Version;
 
 use crate::common::{Config, Debugger, TestMode};
 use crate::directives::{
-    DirectivesCache, EarlyProps, Edition, EditionRange, extract_llvm_version,
+    DirectivesCache, EarlyProps, Edition, EditionRange, FileDirectives, extract_llvm_version,
     extract_version_range, iter_directives, line_directive, parse_edition, parse_normalize_rule,
 };
 use crate::executor::{CollectedTestDesc, ShouldPanic};
@@ -18,13 +18,15 @@ fn make_test_description(
 ) -> CollectedTestDesc {
     let cache = DirectivesCache::load(config);
     let mut poisoned = false;
+    let file_directives = FileDirectives::from_file_contents(path, file_contents);
+
     let test = crate::directives::make_test_description(
         config,
         &cache,
         name,
         path,
         filterable_path,
-        file_contents,
+        &file_directives,
         revision,
         &mut poisoned,
     );
@@ -224,7 +226,8 @@ fn cfg() -> ConfigBuilder {
 }
 
 fn parse_rs(config: &Config, contents: &str) -> EarlyProps {
-    EarlyProps::from_file_contents(config, Utf8Path::new("a.rs"), contents)
+    let file_directives = FileDirectives::from_file_contents(Utf8Path::new("a.rs"), contents);
+    EarlyProps::from_file_directives(config, &file_directives)
 }
 
 fn check_ignore(config: &Config, contents: &str) -> bool {
@@ -776,7 +779,8 @@ fn threads_support() {
 }
 
 fn run_path(poisoned: &mut bool, path: &Utf8Path, file_contents: &str) {
-    iter_directives(TestMode::Ui, poisoned, path, file_contents, &mut |_| {});
+    let file_directives = FileDirectives::from_file_contents(path, file_contents);
+    iter_directives(TestMode::Ui, poisoned, &file_directives, &mut |_| {});
 }
 
 #[test]
diff --git a/src/tools/compiletest/src/lib.rs b/src/tools/compiletest/src/lib.rs
index 48ae38b61b93d..4cfb1e20f9ae9 100644
--- a/src/tools/compiletest/src/lib.rs
+++ b/src/tools/compiletest/src/lib.rs
@@ -41,7 +41,7 @@ use crate::common::{
     CodegenBackend, CompareMode, Config, Debugger, PassMode, TestMode, TestPaths, UI_EXTENSIONS,
     expected_output_path, output_base_dir, output_relative_path,
 };
-use crate::directives::DirectivesCache;
+use crate::directives::{DirectivesCache, FileDirectives};
 use crate::edition::parse_edition;
 use crate::executor::{CollectedTest, ColorConfig};
 
@@ -868,7 +868,10 @@ fn make_test(cx: &TestCollectorCx, collector: &mut TestCollector, testpaths: &Te
     };
 
     // Scan the test file to discover its revisions, if any.
-    let early_props = EarlyProps::from_file(&cx.config, &test_path);
+    let file_contents =
+        fs::read_to_string(&test_path).expect("reading test file for directives should succeed");
+    let file_directives = FileDirectives::from_file_contents(&test_path, &file_contents);
+    let early_props = EarlyProps::from_file_directives(&cx.config, &file_directives);
 
     // Normally we create one structure per revision, with two exceptions:
     // - If a test doesn't use revisions, create a dummy revision (None) so that
@@ -886,8 +889,6 @@ fn make_test(cx: &TestCollectorCx, collector: &mut TestCollector, testpaths: &Te
     // `CollectedTest` that can be handed over to the test executor.
     collector.tests.extend(revisions.into_iter().map(|revision| {
         // Create a test name and description to hand over to the executor.
-        let file_contents =
-            fs::read_to_string(&test_path).expect("read test file to parse ignores");
         let (test_name, filterable_path) =
             make_test_name_and_filterable_path(&cx.config, testpaths, revision);
         // Create a description struct for the test/revision.
@@ -899,7 +900,7 @@ fn make_test(cx: &TestCollectorCx, collector: &mut TestCollector, testpaths: &Te
             test_name,
             &test_path,
             &filterable_path,
-            &file_contents,
+            &file_directives,
             revision,
             &mut collector.poisoned,
         );

From 71c05330dfa8bc6280dd779eb91f18ccd4e98d88 Mon Sep 17 00:00:00 2001
From: Krasimir Georgiev <krasimir@google.com>
Date: Thu, 9 Oct 2025 12:28:06 +0000
Subject: [PATCH 1849/1889] x86_64-bigint-helpers test: update test assertion

---
 tests/assembly-llvm/x86_64-bigint-helpers.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/assembly-llvm/x86_64-bigint-helpers.rs b/tests/assembly-llvm/x86_64-bigint-helpers.rs
index 64aa025723856..9d998a31cf306 100644
--- a/tests/assembly-llvm/x86_64-bigint-helpers.rs
+++ b/tests/assembly-llvm/x86_64-bigint-helpers.rs
@@ -44,7 +44,7 @@ pub unsafe extern "sysv64" fn bigint_chain_borrowing_sub(
     n: usize,
     mut carry: bool,
 ) -> bool {
-    // CHECK: mov [[TEMP:r..]], qword ptr [rsi + 8*[[IND:r..]] + 8]
+    // CHECK: mov [[TEMP:r.+]], qword ptr [rsi + 8*[[IND:r.+]] + 8]
     // CHECK: sbb [[TEMP]], qword ptr [rdx + 8*[[IND]] + 8]
     // CHECK: mov qword ptr [rdi + 8*[[IND]] + 8], [[TEMP]]
     // CHECK: mov [[TEMP]], qword ptr [rsi + 8*[[IND]] + 16]

From 690071c28a6fbce6cc1f6d958a8f60a5cd1b80be Mon Sep 17 00:00:00 2001
From: dianqk <dianqk@dianqk.net>
Date: Thu, 9 Oct 2025 20:14:21 +0800
Subject: [PATCH 1850/1889] Add regression test for 147485

---
 tests/crashes/147485-2.rs                     | 16 +++++++++
 tests/crashes/147485.rs                       | 14 ++++++++
 ...buginfo_locals.DestinationPropagation.diff | 35 ++++++++++++++++++
 tests/mir-opt/debuginfo/dest_prop.rs          | 36 +++++++++++++++++++
 ...debuginfo_locals.ReferencePropagation.diff | 33 +++++++++++++++++
 tests/mir-opt/debuginfo/ref_prop.rs           | 26 ++++++++++++++
 6 files changed, 160 insertions(+)
 create mode 100644 tests/crashes/147485-2.rs
 create mode 100644 tests/crashes/147485.rs
 create mode 100644 tests/mir-opt/debuginfo/dest_prop.remap_debuginfo_locals.DestinationPropagation.diff
 create mode 100644 tests/mir-opt/debuginfo/dest_prop.rs
 create mode 100644 tests/mir-opt/debuginfo/ref_prop.remap_debuginfo_locals.ReferencePropagation.diff
 create mode 100644 tests/mir-opt/debuginfo/ref_prop.rs

diff --git a/tests/crashes/147485-2.rs b/tests/crashes/147485-2.rs
new file mode 100644
index 0000000000000..da092a3af76aa
--- /dev/null
+++ b/tests/crashes/147485-2.rs
@@ -0,0 +1,16 @@
+//@ known-bug: #147485
+//@ compile-flags: -g -O
+
+#![crate_type = "lib"]
+
+pub fn foo(a: bool, b: bool) -> bool {
+    let mut c = &a;
+    if false {
+        return *c;
+    }
+    let d = b && a;
+    if d {
+        c = &b;
+    }
+    b
+}
diff --git a/tests/crashes/147485.rs b/tests/crashes/147485.rs
new file mode 100644
index 0000000000000..86f3705e636b4
--- /dev/null
+++ b/tests/crashes/147485.rs
@@ -0,0 +1,14 @@
+//@ known-bug: #147485
+//@ compile-flags: -g -O
+
+#![crate_type = "lib"]
+
+pub fn f(x: *const usize) -> &'static usize {
+    let mut a = unsafe { &*x };
+    a = unsafe { &*x };
+    a
+}
+
+pub fn g() {
+    f(&0);
+}
diff --git a/tests/mir-opt/debuginfo/dest_prop.remap_debuginfo_locals.DestinationPropagation.diff b/tests/mir-opt/debuginfo/dest_prop.remap_debuginfo_locals.DestinationPropagation.diff
new file mode 100644
index 0000000000000..6f3233d85c9fc
--- /dev/null
+++ b/tests/mir-opt/debuginfo/dest_prop.remap_debuginfo_locals.DestinationPropagation.diff
@@ -0,0 +1,35 @@
+- // MIR for `remap_debuginfo_locals` before DestinationPropagation
++ // MIR for `remap_debuginfo_locals` after DestinationPropagation
+  
+  fn remap_debuginfo_locals(_1: bool, _2: &bool) -> &bool {
+-     debug c => _3;
++     debug c => _2;
+      let mut _0: &bool;
+      let mut _3: &bool;
+      let mut _4: bool;
+  
+      bb0: {
+          // DBG: _3 = &_1;
+-         StorageLive(_4);
+-         _4 = copy _1;
+-         _3 = copy _2;
+-         switchInt(copy _4) -> [1: bb1, otherwise: bb2];
++         nop;
++         nop;
++         nop;
++         switchInt(copy _1) -> [1: bb1, otherwise: bb2];
+      }
+  
+      bb1: {
+          goto -> bb2;
+      }
+  
+      bb2: {
+-         StorageDead(_4);
+-         _0 = copy _3;
++         nop;
++         _0 = copy _2;
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/debuginfo/dest_prop.rs b/tests/mir-opt/debuginfo/dest_prop.rs
new file mode 100644
index 0000000000000..9c9d95ebfb3f3
--- /dev/null
+++ b/tests/mir-opt/debuginfo/dest_prop.rs
@@ -0,0 +1,36 @@
+// skip-filecheck
+//@ test-mir-pass: DestinationPropagation
+//@ compile-flags: -g -Zmir-enable-passes=+DeadStoreElimination-initial
+
+#![feature(core_intrinsics, custom_mir)]
+#![crate_type = "lib"]
+
+use std::intrinsics::mir::*;
+
+// EMIT_MIR dest_prop.remap_debuginfo_locals.DestinationPropagation.diff
+#[custom_mir(dialect = "runtime", phase = "post-cleanup")]
+pub fn remap_debuginfo_locals(a: bool, b: &bool) -> &bool {
+    mir! {
+        let _3: &bool;
+        let _4: bool;
+        debug c => _3;
+        {
+            _3 = &a;
+            StorageLive(_4);
+            _4 = a;
+            _3 = b;
+            match _4 {
+                true => bb1,
+                _ => bb2,
+            }
+        }
+        bb1 = {
+            Goto(bb2)
+        }
+        bb2 = {
+            StorageDead(_4);
+            RET = _3;
+            Return()
+        }
+    }
+}
diff --git a/tests/mir-opt/debuginfo/ref_prop.remap_debuginfo_locals.ReferencePropagation.diff b/tests/mir-opt/debuginfo/ref_prop.remap_debuginfo_locals.ReferencePropagation.diff
new file mode 100644
index 0000000000000..87941aadab4dd
--- /dev/null
+++ b/tests/mir-opt/debuginfo/ref_prop.remap_debuginfo_locals.ReferencePropagation.diff
@@ -0,0 +1,33 @@
+- // MIR for `remap_debuginfo_locals` before ReferencePropagation
++ // MIR for `remap_debuginfo_locals` after ReferencePropagation
+  
+  fn remap_debuginfo_locals() -> () {
+      let mut _0: ();
+      let _1: &usize;
+      let mut _2: *const usize;
+      let _3: &usize;
+      let _4: usize;
+      let mut _5: &usize;
+      scope 1 (inlined foo) {
+-         debug a => _1;
++         debug a => _5;
+      }
+  
+      bb0: {
+-         StorageLive(_1);
+-         StorageLive(_2);
+-         StorageLive(_3);
+          _5 = const remap_debuginfo_locals::promoted[0];
+-         _3 = &(*_5);
+-         _2 = &raw const (*_3);
+-         // DBG: _1 = &(*_2);
+-         _1 = &(*_2);
+-         StorageDead(_2);
+-         StorageDead(_3);
+-         StorageDead(_1);
++         // DBG: _1 = &(*_5);
+          _0 = const ();
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/debuginfo/ref_prop.rs b/tests/mir-opt/debuginfo/ref_prop.rs
new file mode 100644
index 0000000000000..5f2f1ce09c707
--- /dev/null
+++ b/tests/mir-opt/debuginfo/ref_prop.rs
@@ -0,0 +1,26 @@
+// skip-filecheck
+//@ test-mir-pass: ReferencePropagation
+//@ compile-flags: -g -Zub_checks=false -Zinline-mir -Zmir-enable-passes=+DeadStoreElimination-initial
+
+#![feature(core_intrinsics, custom_mir)]
+#![crate_type = "lib"]
+
+use std::intrinsics::mir::*;
+
+// EMIT_MIR ref_prop.remap_debuginfo_locals.ReferencePropagation.diff
+pub fn remap_debuginfo_locals() {
+    foo(&0);
+}
+
+#[custom_mir(dialect = "runtime", phase = "post-cleanup")]
+#[inline]
+fn foo(x: *const usize) -> &'static usize {
+    mir! {
+        debug a => RET;
+        {
+            RET = &*x;
+            RET = &*x;
+            Return()
+        }
+    }
+}

From 9462e7301fb831f011b927494fd74c9f31c24b9b Mon Sep 17 00:00:00 2001
From: dianqk <dianqk@dianqk.net>
Date: Thu, 9 Oct 2025 21:32:23 +0800
Subject: [PATCH 1851/1889] MIR validation: ensure that debuginfo records are
 not emitted for locals that are not in debuginfo

---
 compiler/rustc_mir_transform/src/validate.rs | 33 ++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/compiler/rustc_mir_transform/src/validate.rs b/compiler/rustc_mir_transform/src/validate.rs
index 95873484b6529..6790dda780c5d 100644
--- a/compiler/rustc_mir_transform/src/validate.rs
+++ b/compiler/rustc_mir_transform/src/validate.rs
@@ -17,6 +17,7 @@ use rustc_middle::ty::{
     self, CoroutineArgsExt, InstanceKind, ScalarInt, Ty, TyCtxt, TypeVisitableExt, Upcast, Variance,
 };
 use rustc_middle::{bug, span_bug};
+use rustc_mir_dataflow::debuginfo::debuginfo_locals;
 use rustc_trait_selection::traits::ObligationCtxt;
 
 use crate::util::{self, is_within_packed};
@@ -80,6 +81,11 @@ impl<'tcx> crate::MirPass<'tcx> for Validator {
             cfg_checker.fail(location, msg);
         }
 
+        // Ensure that debuginfo records are not emitted for locals that are not in debuginfo.
+        for (location, msg) in validate_debuginfos(body) {
+            cfg_checker.fail(location, msg);
+        }
+
         if let MirPhase::Runtime(_) = body.phase
             && let ty::InstanceKind::Item(_) = body.source.instance
             && body.has_free_regions()
@@ -1595,3 +1601,30 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
         self.super_terminator(terminator, location);
     }
 }
+
+pub(super) fn validate_debuginfos<'tcx>(body: &Body<'tcx>) -> Vec<(Location, String)> {
+    let mut debuginfo_checker =
+        DebuginfoChecker { debuginfo_locals: debuginfo_locals(body), failures: Vec::new() };
+    debuginfo_checker.visit_body(body);
+    debuginfo_checker.failures
+}
+
+struct DebuginfoChecker {
+    debuginfo_locals: DenseBitSet<Local>,
+    failures: Vec<(Location, String)>,
+}
+
+impl<'tcx> Visitor<'tcx> for DebuginfoChecker {
+    fn visit_statement_debuginfo(
+        &mut self,
+        stmt_debuginfo: &StmtDebugInfo<'tcx>,
+        location: Location,
+    ) {
+        let local = match stmt_debuginfo {
+            StmtDebugInfo::AssignRef(local, _) | StmtDebugInfo::InvalidAssign(local) => *local,
+        };
+        if !self.debuginfo_locals.contains(local) {
+            self.failures.push((location, format!("{local:?} is not in debuginfo")));
+        }
+    }
+}

From b2e81b00e5cd6f0ad7f883413b983b2c6e25c25e Mon Sep 17 00:00:00 2001
From: dianqk <dianqk@dianqk.net>
Date: Thu, 9 Oct 2025 21:53:05 +0800
Subject: [PATCH 1852/1889] Replace locals in debuginfo records during ref_prop

---
 compiler/rustc_middle/src/mir/visit.rs        |  8 ++--
 compiler/rustc_mir_transform/src/ref_prop.rs  | 45 +++++++++++++++----
 ...debuginfo_locals.ReferencePropagation.diff |  2 +-
 tests/mir-opt/debuginfo/ref_prop.rs           |  6 ++-
 .../debuginfo/ref_prop_debuginfo-147485.rs}   |  4 +-
 5 files changed, 49 insertions(+), 16 deletions(-)
 rename tests/{crashes/147485.rs => ui/debuginfo/ref_prop_debuginfo-147485.rs} (79%)

diff --git a/compiler/rustc_middle/src/mir/visit.rs b/compiler/rustc_middle/src/mir/visit.rs
index 9654e189f2edf..29cf3977dc807 100644
--- a/compiler/rustc_middle/src/mir/visit.rs
+++ b/compiler/rustc_middle/src/mir/visit.rs
@@ -1098,6 +1098,10 @@ macro_rules! super_body {
             }
         }
 
+        for var_debug_info in &$($mutability)? $body.var_debug_info {
+            $self.visit_var_debug_info(var_debug_info);
+        }
+
         for (bb, data) in basic_blocks_iter!($body, $($mutability, $invalidate)?) {
             $self.visit_basic_block_data(bb, data);
         }
@@ -1127,10 +1131,6 @@ macro_rules! super_body {
             );
         }
 
-        for var_debug_info in &$($mutability)? $body.var_debug_info {
-            $self.visit_var_debug_info(var_debug_info);
-        }
-
         $self.visit_span($(& $mutability)? $body.span);
 
         if let Some(required_consts) = &$($mutability)? $body.required_consts {
diff --git a/compiler/rustc_mir_transform/src/ref_prop.rs b/compiler/rustc_mir_transform/src/ref_prop.rs
index deb0a146476c3..c5b53dbbd309b 100644
--- a/compiler/rustc_mir_transform/src/ref_prop.rs
+++ b/compiler/rustc_mir_transform/src/ref_prop.rs
@@ -302,6 +302,7 @@ fn compute_replacement<'tcx>(
     return Replacer {
         tcx,
         targets: finder.targets,
+        remap_var_debug_infos: IndexVec::from_elem(None, body.local_decls()),
         storage_to_remove,
         allowed_replacements,
         any_replacement: false,
@@ -381,6 +382,7 @@ fn fully_replaceable_locals(ssa: &SsaLocals) -> DenseBitSet<Local> {
 struct Replacer<'tcx> {
     tcx: TyCtxt<'tcx>,
     targets: IndexVec<Local, Value<'tcx>>,
+    remap_var_debug_infos: IndexVec<Local, Option<Local>>,
     storage_to_remove: DenseBitSet<Local>,
     allowed_replacements: FxHashSet<(Local, Location)>,
     any_replacement: bool,
@@ -392,21 +394,45 @@ impl<'tcx> MutVisitor<'tcx> for Replacer<'tcx> {
     }
 
     fn visit_var_debug_info(&mut self, debuginfo: &mut VarDebugInfo<'tcx>) {
-        // If the debuginfo is a pointer to another place
-        // and it's a reborrow: see through it
-        while let VarDebugInfoContents::Place(ref mut place) = debuginfo.value
+        if let VarDebugInfoContents::Place(ref mut place) = debuginfo.value
             && place.projection.is_empty()
-            && let Value::Pointer(target, _) = self.targets[place.local]
-            && let &[PlaceElem::Deref] = &target.projection[..]
         {
-            *place = Place::from(target.local);
-            self.any_replacement = true;
+            let mut new_local = place.local;
+
+            // If the debuginfo is a pointer to another place
+            // and it's a reborrow: see through it
+            while let Value::Pointer(target, _) = self.targets[new_local]
+                && let &[PlaceElem::Deref] = &target.projection[..]
+            {
+                new_local = target.local;
+            }
+            if place.local != new_local {
+                self.remap_var_debug_infos[place.local] = Some(new_local);
+                place.local = new_local;
+
+                self.any_replacement = true;
+            }
         }
 
         // Simplify eventual projections left inside `debuginfo`.
         self.super_var_debug_info(debuginfo);
     }
 
+    fn visit_statement_debuginfo(
+        &mut self,
+        stmt_debuginfo: &mut StmtDebugInfo<'tcx>,
+        location: Location,
+    ) {
+        let local = match stmt_debuginfo {
+            StmtDebugInfo::AssignRef(local, _) | StmtDebugInfo::InvalidAssign(local) => local,
+        };
+        if let Some(target) = self.remap_var_debug_infos[*local] {
+            *local = target;
+            self.any_replacement = true;
+        }
+        self.super_statement_debuginfo(stmt_debuginfo, location);
+    }
+
     fn visit_place(&mut self, place: &mut Place<'tcx>, ctxt: PlaceContext, loc: Location) {
         loop {
             let Some((&PlaceElem::Deref, rest)) = place.projection.split_first() else { return };
@@ -437,8 +463,9 @@ impl<'tcx> MutVisitor<'tcx> for Replacer<'tcx> {
             {
                 stmt.make_nop(true);
             }
-            // Do not remove assignments as they may still be useful for debuginfo.
-            _ => self.super_statement(stmt, loc),
+            _ => {}
         }
+        // Do not remove assignments as they may still be useful for debuginfo.
+        self.super_statement(stmt, loc);
     }
 }
diff --git a/tests/mir-opt/debuginfo/ref_prop.remap_debuginfo_locals.ReferencePropagation.diff b/tests/mir-opt/debuginfo/ref_prop.remap_debuginfo_locals.ReferencePropagation.diff
index 87941aadab4dd..2d93b1d842fa1 100644
--- a/tests/mir-opt/debuginfo/ref_prop.remap_debuginfo_locals.ReferencePropagation.diff
+++ b/tests/mir-opt/debuginfo/ref_prop.remap_debuginfo_locals.ReferencePropagation.diff
@@ -25,7 +25,7 @@
 -         StorageDead(_2);
 -         StorageDead(_3);
 -         StorageDead(_1);
-+         // DBG: _1 = &(*_5);
++         // DBG: _5 = &(*_5);
           _0 = const ();
           return;
       }
diff --git a/tests/mir-opt/debuginfo/ref_prop.rs b/tests/mir-opt/debuginfo/ref_prop.rs
index 5f2f1ce09c707..60d68ba178a7b 100644
--- a/tests/mir-opt/debuginfo/ref_prop.rs
+++ b/tests/mir-opt/debuginfo/ref_prop.rs
@@ -1,4 +1,3 @@
-// skip-filecheck
 //@ test-mir-pass: ReferencePropagation
 //@ compile-flags: -g -Zub_checks=false -Zinline-mir -Zmir-enable-passes=+DeadStoreElimination-initial
 
@@ -9,6 +8,11 @@ use std::intrinsics::mir::*;
 
 // EMIT_MIR ref_prop.remap_debuginfo_locals.ReferencePropagation.diff
 pub fn remap_debuginfo_locals() {
+    // CHECK-LABEL: fn remap_debuginfo_locals()
+    // CHECK: debug a => [[a:_.*]];
+    // CHECK: bb0:
+    // CHECK-NEXT: [[a]] = const
+    // CHECK-NEXT: DBG: [[a]] = &(*[[a]]);
     foo(&0);
 }
 
diff --git a/tests/crashes/147485.rs b/tests/ui/debuginfo/ref_prop_debuginfo-147485.rs
similarity index 79%
rename from tests/crashes/147485.rs
rename to tests/ui/debuginfo/ref_prop_debuginfo-147485.rs
index 86f3705e636b4..15899626aff7b 100644
--- a/tests/crashes/147485.rs
+++ b/tests/ui/debuginfo/ref_prop_debuginfo-147485.rs
@@ -1,6 +1,8 @@
-//@ known-bug: #147485
+//@ build-pass
 //@ compile-flags: -g -O
 
+// Regression test for #147485.
+
 #![crate_type = "lib"]
 
 pub fn f(x: *const usize) -> &'static usize {

From 5ab4e18dfc73540220d015c09f2aa05bb7cfa51a Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Fri, 10 Oct 2025 12:51:41 +0200
Subject: [PATCH 1853/1889] remove `#[rustc_inherit_overflow_checks]` from
 `is_multiple_of`

---
 library/core/src/num/uint_macros.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs
index 752498bfbd815..b5b768cf677aa 100644
--- a/library/core/src/num/uint_macros.rs
+++ b/library/core/src/num/uint_macros.rs
@@ -3552,7 +3552,6 @@ macro_rules! uint_impl {
         #[rustc_const_stable(feature = "unsigned_is_multiple_of", since = "1.87.0")]
         #[must_use]
         #[inline]
-        #[rustc_inherit_overflow_checks]
         pub const fn is_multiple_of(self, rhs: Self) -> bool {
             match rhs {
                 0 => self == 0,

From 6660d75710a98b8a3a5ef455e68fdc8cd4aaf733 Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Fri, 10 Oct 2025 07:52:49 -0400
Subject: [PATCH 1854/1889] Move  to the tier 3 table

---
 src/doc/rustc/src/platform-support.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc/src/platform-support.md b/src/doc/rustc/src/platform-support.md
index 7efeb216a886f..c833567e342a9 100644
--- a/src/doc/rustc/src/platform-support.md
+++ b/src/doc/rustc/src/platform-support.md
@@ -198,7 +198,6 @@ target | std | notes
 [`wasm32-wasip1`](platform-support/wasm32-wasip1.md) | ✓ | WebAssembly with WASIp1
 [`wasm32-wasip1-threads`](platform-support/wasm32-wasip1-threads.md) | ✓ | WebAssembly with WASI Preview 1 and threads
 [`wasm32-wasip2`](platform-support/wasm32-wasip2.md) | ✓ | WebAssembly with WASIp2
-[`wasm32-wasip3`](platform-support/wasm32-wasip3.md) | ✓ | WebAssembly with WASIp3
 [`wasm32v1-none`](platform-support/wasm32v1-none.md) | * | WebAssembly limited to 1.0 features and no imports
 [`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
@@ -417,6 +416,7 @@ target | std | host | notes
 [`thumbv8m.main-nuttx-eabihf`](platform-support/nuttx.md) | ✓ |  | ARMv8M Mainline with NuttX, hardfloat
 [`wasm64-unknown-unknown`](platform-support/wasm64-unknown-unknown.md) | ? |  | WebAssembly
 [`wasm32-wali-linux-musl`](platform-support/wasm32-wali-linux.md) | ? |  | WebAssembly with [WALI](https://github.com/arjunr2/WALI)
+[`wasm32-wasip3`](platform-support/wasm32-wasip3.md) | ✓ | WebAssembly with WASIp3
 [`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-lynx-lynxos178`](platform-support/lynxos178.md) |   |  | x86_64 LynxOS-178

From 4c6caaa3a6d80a895a40389a8b37808b4cea30e1 Mon Sep 17 00:00:00 2001
From: dianqk <dianqk@dianqk.net>
Date: Thu, 9 Oct 2025 18:19:15 +0800
Subject: [PATCH 1855/1889] Always print disk usage

---
 .github/workflows/ci.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index f539b64d8c829..d440b296d2753 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -246,6 +246,8 @@ jobs:
         run: src/ci/scripts/create-doc-artifacts.sh
 
       - name: print disk usage
+        # We also want to know the disk usage when the job fails.
+        if: always()
         run: |
           echo "disk usage:"
           df -h

From c86474ca0719cc24a6686215ab0fae1c98ce3eb9 Mon Sep 17 00:00:00 2001
From: Vitali Borsak <borsak.vitali@gmail.com>
Date: Wed, 20 Aug 2025 09:57:14 +0000
Subject: [PATCH 1856/1889] Adding a regression test (const promotion with
 Option<Ordering>)

---
 ...on_ordering_eq.direct.PreCodegen.after.mir | 46 +++++++++++++++++
 .../const_promotion_option_ordering_eq.rs     | 30 ++++++++++++
 ..._ordering_eq.with_let.PreCodegen.after.mir | 49 +++++++++++++++++++
 3 files changed, 125 insertions(+)
 create mode 100644 tests/mir-opt/pre-codegen/const_promotion_option_ordering_eq.direct.PreCodegen.after.mir
 create mode 100644 tests/mir-opt/pre-codegen/const_promotion_option_ordering_eq.rs
 create mode 100644 tests/mir-opt/pre-codegen/const_promotion_option_ordering_eq.with_let.PreCodegen.after.mir

diff --git a/tests/mir-opt/pre-codegen/const_promotion_option_ordering_eq.direct.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/const_promotion_option_ordering_eq.direct.PreCodegen.after.mir
new file mode 100644
index 0000000000000..66b51ad48e7a5
--- /dev/null
+++ b/tests/mir-opt/pre-codegen/const_promotion_option_ordering_eq.direct.PreCodegen.after.mir
@@ -0,0 +1,46 @@
+// MIR for `direct` after PreCodegen
+
+fn direct(_1: Option<std::cmp::Ordering>) -> bool {
+    debug e => _1;
+    let mut _0: bool;
+    scope 1 (inlined <Option<std::cmp::Ordering> as PartialEq>::eq) {
+        let mut _2: isize;
+        scope 2 {
+            scope 3 (inlined <std::cmp::Ordering as PartialEq>::eq) {
+                let _3: i8;
+                scope 4 {
+                    scope 5 {
+                    }
+                }
+            }
+        }
+    }
+
+    bb0: {
+        StorageLive(_2);
+        _2 = discriminant(_1);
+        switchInt(move _2) -> [0: bb1, 1: bb2, otherwise: bb4];
+    }
+
+    bb1: {
+        _0 = const false;
+        goto -> bb3;
+    }
+
+    bb2: {
+        StorageLive(_3);
+        _3 = discriminant(((_1 as Some).0: std::cmp::Ordering));
+        _0 = Eq(copy _3, const 0_i8);
+        StorageDead(_3);
+        goto -> bb3;
+    }
+
+    bb3: {
+        StorageDead(_2);
+        return;
+    }
+
+    bb4: {
+        unreachable;
+    }
+}
diff --git a/tests/mir-opt/pre-codegen/const_promotion_option_ordering_eq.rs b/tests/mir-opt/pre-codegen/const_promotion_option_ordering_eq.rs
new file mode 100644
index 0000000000000..3c1e96fa47484
--- /dev/null
+++ b/tests/mir-opt/pre-codegen/const_promotion_option_ordering_eq.rs
@@ -0,0 +1,30 @@
+//@ compile-flags: -O -Zmir-opt-level=2 -Cdebuginfo=0
+
+// Check that comparing `Option<Ordering>` to a constant inlined `Some(...)`
+// does not produce unnecessarily complex MIR compared to using a local binding.
+//
+// Regression test for <https://github.com/rust-lang/rust/issues/139093>.
+// Originally, inlined constants like `Some(Ordering::Equal)` would get promoted,
+// leading to more MIR (and extra LLVM IR checks) than necessary.
+// Both cases should now generate identical MIR.
+
+use std::cmp::Ordering;
+
+// EMIT_MIR const_promotion_option_ordering_eq.direct.PreCodegen.after.mir
+pub fn direct(e: Option<Ordering>) -> bool {
+    // CHECK-LABEL: fn direct(
+    // CHECK-NOT: promoted[
+    // CHECK: switchInt(
+    // CHECK: return
+    e == Some(Ordering::Equal)
+}
+
+// EMIT_MIR const_promotion_option_ordering_eq.with_let.PreCodegen.after.mir
+pub fn with_let(e: Option<Ordering>) -> bool {
+    // CHECK-LABEL: fn with_let(
+    // CHECK-NOT: promoted[
+    // CHECK: switchInt(
+    // CHECK: return
+    let eq = Ordering::Equal;
+    e == Some(eq)
+}
diff --git a/tests/mir-opt/pre-codegen/const_promotion_option_ordering_eq.with_let.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/const_promotion_option_ordering_eq.with_let.PreCodegen.after.mir
new file mode 100644
index 0000000000000..f089e9ad960bd
--- /dev/null
+++ b/tests/mir-opt/pre-codegen/const_promotion_option_ordering_eq.with_let.PreCodegen.after.mir
@@ -0,0 +1,49 @@
+// MIR for `with_let` after PreCodegen
+
+fn with_let(_1: Option<std::cmp::Ordering>) -> bool {
+    debug e => _1;
+    let mut _0: bool;
+    scope 1 {
+        debug eq => const Equal;
+        scope 2 (inlined <Option<std::cmp::Ordering> as PartialEq>::eq) {
+            let mut _2: isize;
+            scope 3 {
+                scope 4 (inlined <std::cmp::Ordering as PartialEq>::eq) {
+                    let _3: i8;
+                    scope 5 {
+                        scope 6 {
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    bb0: {
+        StorageLive(_2);
+        _2 = discriminant(_1);
+        switchInt(move _2) -> [0: bb1, 1: bb2, otherwise: bb4];
+    }
+
+    bb1: {
+        _0 = const false;
+        goto -> bb3;
+    }
+
+    bb2: {
+        StorageLive(_3);
+        _3 = discriminant(((_1 as Some).0: std::cmp::Ordering));
+        _0 = Eq(copy _3, const 0_i8);
+        StorageDead(_3);
+        goto -> bb3;
+    }
+
+    bb3: {
+        StorageDead(_2);
+        return;
+    }
+
+    bb4: {
+        unreachable;
+    }
+}

From b7c2b3dc80e03dbbde6ff869c1f975c036703590 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Fri, 10 Oct 2025 01:48:09 +0000
Subject: [PATCH 1857/1889] Remove StatementKind::Deinit.

---
 compiler/rustc_borrowck/src/dataflow.rs            |  1 -
 compiler/rustc_borrowck/src/def_use.rs             |  2 +-
 compiler/rustc_borrowck/src/lib.rs                 |  1 -
 .../src/polonius/legacy/loan_invalidations.rs      |  1 -
 compiler/rustc_borrowck/src/type_check/mod.rs      |  1 -
 compiler/rustc_codegen_cranelift/src/base.rs       |  1 -
 compiler/rustc_codegen_cranelift/src/constant.rs   |  1 -
 compiler/rustc_codegen_ssa/src/mir/analyze.rs      |  1 -
 compiler/rustc_codegen_ssa/src/mir/statement.rs    |  5 -----
 .../rustc_const_eval/src/check_consts/check.rs     |  1 -
 compiler/rustc_const_eval/src/interpret/step.rs    |  5 -----
 compiler/rustc_middle/src/mir/pretty.rs            |  1 -
 compiler/rustc_middle/src/mir/statement.rs         |  1 -
 compiler/rustc_middle/src/mir/syntax.rs            |  6 ------
 compiler/rustc_middle/src/mir/visit.rs             |  9 ---------
 .../src/builder/custom/parse/instruction.rs        |  3 ---
 compiler/rustc_mir_dataflow/src/impls/liveness.rs  |  5 ++---
 .../src/impls/storage_liveness.rs                  |  3 +--
 .../rustc_mir_dataflow/src/move_paths/builder.rs   |  2 +-
 compiler/rustc_mir_transform/src/coroutine.rs      |  1 -
 .../src/coverage/spans/from_mir.rs                 |  1 -
 .../rustc_mir_transform/src/cross_crate_inline.rs  |  5 +----
 .../rustc_mir_transform/src/dataflow_const_prop.rs |  4 ----
 compiler/rustc_mir_transform/src/jump_threading.rs |  3 +--
 .../rustc_mir_transform/src/known_panics_lint.rs   |  1 -
 compiler/rustc_mir_transform/src/large_enums.rs    |  3 ---
 .../src/remove_noop_landing_pads.rs                |  1 -
 compiler/rustc_mir_transform/src/remove_zsts.rs    |  3 +--
 compiler/rustc_mir_transform/src/simplify.rs       |  6 +++---
 compiler/rustc_mir_transform/src/sroa.rs           | 14 +-------------
 compiler/rustc_mir_transform/src/validate.rs       | 10 ----------
 compiler/rustc_public/src/mir/body.rs              |  1 -
 compiler/rustc_public/src/mir/pretty.rs            |  1 -
 compiler/rustc_public/src/mir/visit.rs             |  1 -
 .../src/unstable/convert/stable/mir.rs             |  3 ---
 library/core/src/intrinsics/mir.rs                 |  3 +--
 .../clippy_utils/src/qualify_min_const_fn.rs       |  2 +-
 tests/mir-opt/building/custom/enums.rs             |  1 -
 .../custom/enums.set_discr.built.after.mir         |  1 -
 tests/mir-opt/enum_opt.cand.EnumSizeOpt.32bit.diff |  2 --
 tests/mir-opt/enum_opt.cand.EnumSizeOpt.64bit.diff |  2 --
 tests/mir-opt/enum_opt.unin.EnumSizeOpt.32bit.diff |  2 --
 tests/mir-opt/enum_opt.unin.EnumSizeOpt.64bit.diff |  2 --
 43 files changed, 14 insertions(+), 109 deletions(-)

diff --git a/compiler/rustc_borrowck/src/dataflow.rs b/compiler/rustc_borrowck/src/dataflow.rs
index d3f6c01ab8c3a..84d5ffb947914 100644
--- a/compiler/rustc_borrowck/src/dataflow.rs
+++ b/compiler/rustc_borrowck/src/dataflow.rs
@@ -577,7 +577,6 @@ impl<'tcx> rustc_mir_dataflow::Analysis<'tcx> for Borrows<'_, 'tcx> {
 
             mir::StatementKind::FakeRead(..)
             | mir::StatementKind::SetDiscriminant { .. }
-            | mir::StatementKind::Deinit(..)
             | mir::StatementKind::StorageLive(..)
             | mir::StatementKind::Retag { .. }
             | mir::StatementKind::PlaceMention(..)
diff --git a/compiler/rustc_borrowck/src/def_use.rs b/compiler/rustc_borrowck/src/def_use.rs
index b9ced81c46c19..502265a83523e 100644
--- a/compiler/rustc_borrowck/src/def_use.rs
+++ b/compiler/rustc_borrowck/src/def_use.rs
@@ -80,7 +80,7 @@ pub(crate) fn categorize(context: PlaceContext) -> Option<DefUse> {
         // Backwards incompatible drop hint is not a use, just a marker for linting.
         PlaceContext::NonUse(NonUseContext::BackwardIncompatibleDropHint) => None,
 
-        PlaceContext::MutatingUse(MutatingUseContext::Deinit | MutatingUseContext::SetDiscriminant) => {
+        PlaceContext::MutatingUse(MutatingUseContext::SetDiscriminant) => {
             bug!("These statements are not allowed in this MIR phase")
         }
     }
diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs
index a85dcf64d8d46..d13de8c972265 100644
--- a/compiler/rustc_borrowck/src/lib.rs
+++ b/compiler/rustc_borrowck/src/lib.rs
@@ -857,7 +857,6 @@ impl<'a, 'tcx> ResultsVisitor<'tcx, Borrowck<'a, 'tcx>> for MirBorrowckCtxt<'a,
             }
             StatementKind::Nop
             | StatementKind::Retag { .. }
-            | StatementKind::Deinit(..)
             | StatementKind::SetDiscriminant { .. } => {
                 bug!("Statement not allowed in this MIR phase")
             }
diff --git a/compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs b/compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs
index c2ad6fcb4b799..f6cf0212ef305 100644
--- a/compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs
+++ b/compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs
@@ -84,7 +84,6 @@ impl<'a, 'tcx> Visitor<'tcx> for LoanInvalidationsGenerator<'a, 'tcx> {
             StatementKind::ConstEvalCounter
             | StatementKind::Nop
             | StatementKind::Retag { .. }
-            | StatementKind::Deinit(..)
             | StatementKind::BackwardIncompatibleDropHint { .. }
             | StatementKind::SetDiscriminant { .. } => {
                 bug!("Statement not allowed in this MIR phase")
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
index 781fb5ba113ab..984a154853a98 100644
--- a/compiler/rustc_borrowck/src/type_check/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -748,7 +748,6 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
             | StatementKind::BackwardIncompatibleDropHint { .. }
             | StatementKind::Nop => {}
             StatementKind::Intrinsic(box NonDivergingIntrinsic::CopyNonOverlapping(..))
-            | StatementKind::Deinit(..)
             | StatementKind::SetDiscriminant { .. } => {
                 bug!("Statement not allowed in this MIR phase")
             }
diff --git a/compiler/rustc_codegen_cranelift/src/base.rs b/compiler/rustc_codegen_cranelift/src/base.rs
index ebf2ccf74de20..b3f9f598926c2 100644
--- a/compiler/rustc_codegen_cranelift/src/base.rs
+++ b/compiler/rustc_codegen_cranelift/src/base.rs
@@ -932,7 +932,6 @@ fn codegen_stmt<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, cur_block: Block, stmt:
         }
         StatementKind::StorageLive(_)
         | StatementKind::StorageDead(_)
-        | StatementKind::Deinit(_)
         | StatementKind::ConstEvalCounter
         | StatementKind::Nop
         | StatementKind::FakeRead(..)
diff --git a/compiler/rustc_codegen_cranelift/src/constant.rs b/compiler/rustc_codegen_cranelift/src/constant.rs
index faca92957e1a6..293459cc11c2f 100644
--- a/compiler/rustc_codegen_cranelift/src/constant.rs
+++ b/compiler/rustc_codegen_cranelift/src/constant.rs
@@ -597,7 +597,6 @@ pub(crate) fn mir_operand_get_const_val<'tcx>(
                         StatementKind::Assign(_)
                         | StatementKind::FakeRead(_)
                         | StatementKind::SetDiscriminant { .. }
-                        | StatementKind::Deinit(_)
                         | StatementKind::StorageLive(_)
                         | StatementKind::StorageDead(_)
                         | StatementKind::Retag(_, _)
diff --git a/compiler/rustc_codegen_ssa/src/mir/analyze.rs b/compiler/rustc_codegen_ssa/src/mir/analyze.rs
index 0a37a904193fa..de755d5617801 100644
--- a/compiler/rustc_codegen_ssa/src/mir/analyze.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/analyze.rs
@@ -229,7 +229,6 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'b, 'tcx>> Visitor<'tcx> for LocalAnalyzer
 
             PlaceContext::MutatingUse(
                 MutatingUseContext::Store
-                | MutatingUseContext::Deinit
                 | MutatingUseContext::SetDiscriminant
                 | MutatingUseContext::AsmOutput
                 | MutatingUseContext::Borrow
diff --git a/compiler/rustc_codegen_ssa/src/mir/statement.rs b/compiler/rustc_codegen_ssa/src/mir/statement.rs
index 88590b6271bce..d0121f7643800 100644
--- a/compiler/rustc_codegen_ssa/src/mir/statement.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/statement.rs
@@ -50,11 +50,6 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             mir::StatementKind::SetDiscriminant { box ref place, variant_index } => {
                 self.codegen_place(bx, place.as_ref()).codegen_set_discr(bx, variant_index);
             }
-            mir::StatementKind::Deinit(..) => {
-                // For now, don't codegen this to anything. In the future it may be worth
-                // experimenting with what kind of information we can emit to LLVM without hurting
-                // perf here
-            }
             mir::StatementKind::StorageLive(local) => {
                 if let LocalRef::Place(cg_place) = self.locals[local] {
                     cg_place.storage_live(bx);
diff --git a/compiler/rustc_const_eval/src/check_consts/check.rs b/compiler/rustc_const_eval/src/check_consts/check.rs
index 413aa5f8b8774..2c6dd5bd01f9c 100644
--- a/compiler/rustc_const_eval/src/check_consts/check.rs
+++ b/compiler/rustc_const_eval/src/check_consts/check.rs
@@ -732,7 +732,6 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
         match statement.kind {
             StatementKind::Assign(..)
             | StatementKind::SetDiscriminant { .. }
-            | StatementKind::Deinit(..)
             | StatementKind::FakeRead(..)
             | StatementKind::StorageLive(_)
             | StatementKind::StorageDead(_)
diff --git a/compiler/rustc_const_eval/src/interpret/step.rs b/compiler/rustc_const_eval/src/interpret/step.rs
index 923e00ad4cf1a..088cacf2e6403 100644
--- a/compiler/rustc_const_eval/src/interpret/step.rs
+++ b/compiler/rustc_const_eval/src/interpret/step.rs
@@ -98,11 +98,6 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 self.write_discriminant(*variant_index, &dest)?;
             }
 
-            Deinit(place) => {
-                let dest = self.eval_place(**place)?;
-                self.write_uninit(&dest)?;
-            }
-
             // Mark locals as alive
             StorageLive(local) => {
                 self.storage_live(*local)?;
diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
index d87e3abe3b2ea..60c2ef4d563e4 100644
--- a/compiler/rustc_middle/src/mir/pretty.rs
+++ b/compiler/rustc_middle/src/mir/pretty.rs
@@ -818,7 +818,6 @@ impl Debug for Statement<'_> {
             SetDiscriminant { ref place, variant_index } => {
                 write!(fmt, "discriminant({place:?}) = {variant_index:?}")
             }
-            Deinit(ref place) => write!(fmt, "Deinit({place:?})"),
             PlaceMention(ref place) => {
                 write!(fmt, "PlaceMention({place:?})")
             }
diff --git a/compiler/rustc_middle/src/mir/statement.rs b/compiler/rustc_middle/src/mir/statement.rs
index f310e1e576250..74c39afbbc823 100644
--- a/compiler/rustc_middle/src/mir/statement.rs
+++ b/compiler/rustc_middle/src/mir/statement.rs
@@ -50,7 +50,6 @@ impl<'tcx> StatementKind<'tcx> {
             StatementKind::Assign(..) => "Assign",
             StatementKind::FakeRead(..) => "FakeRead",
             StatementKind::SetDiscriminant { .. } => "SetDiscriminant",
-            StatementKind::Deinit(..) => "Deinit",
             StatementKind::StorageLive(..) => "StorageLive",
             StatementKind::StorageDead(..) => "StorageDead",
             StatementKind::Retag(..) => "Retag",
diff --git a/compiler/rustc_middle/src/mir/syntax.rs b/compiler/rustc_middle/src/mir/syntax.rs
index a823c365394f7..0fffa009d9ad8 100644
--- a/compiler/rustc_middle/src/mir/syntax.rs
+++ b/compiler/rustc_middle/src/mir/syntax.rs
@@ -135,7 +135,6 @@ pub enum RuntimePhase {
     /// And the following variants are allowed:
     /// * [`StatementKind::Retag`]
     /// * [`StatementKind::SetDiscriminant`]
-    /// * [`StatementKind::Deinit`]
     ///
     /// Furthermore, `Copy` operands are allowed for non-`Copy` types.
     Initial = 0,
@@ -362,11 +361,6 @@ pub enum StatementKind<'tcx> {
     /// the type.
     SetDiscriminant { place: Box<Place<'tcx>>, variant_index: VariantIdx },
 
-    /// Deinitializes the place.
-    ///
-    /// This writes `uninit` bytes to the entire place.
-    Deinit(Box<Place<'tcx>>),
-
     /// `StorageLive` and `StorageDead` statements mark the live range of a local.
     ///
     /// At any point during the execution of a function, each local is either allocated or
diff --git a/compiler/rustc_middle/src/mir/visit.rs b/compiler/rustc_middle/src/mir/visit.rs
index 9654e189f2edf..fd81bdeb3f952 100644
--- a/compiler/rustc_middle/src/mir/visit.rs
+++ b/compiler/rustc_middle/src/mir/visit.rs
@@ -445,13 +445,6 @@ macro_rules! make_mir_visitor {
                             location
                         );
                     }
-                    StatementKind::Deinit(place) => {
-                        self.visit_place(
-                            place,
-                            PlaceContext::MutatingUse(MutatingUseContext::Deinit),
-                            location
-                        )
-                    }
                     StatementKind::StorageLive(local) => {
                         self.visit_local(
                             $(& $mutability)? *local,
@@ -1372,8 +1365,6 @@ pub enum MutatingUseContext {
     Store,
     /// Appears on `SetDiscriminant`
     SetDiscriminant,
-    /// Appears on `Deinit`
-    Deinit,
     /// Output operand of an inline assembly block.
     AsmOutput,
     /// Destination of a call.
diff --git a/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs b/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs
index 54490e0050902..b1d1d67947a05 100644
--- a/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs
+++ b/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs
@@ -24,9 +24,6 @@ impl<'a, 'tcx> ParseCtxt<'a, 'tcx> {
                 let op = self.parse_operand(args[0])?;
                 Ok(StatementKind::Intrinsic(Box::new(NonDivergingIntrinsic::Assume(op))))
             },
-            @call(mir_deinit, args) => {
-                Ok(StatementKind::Deinit(Box::new(self.parse_place(args[0])?)))
-            },
             @call(mir_retag, args) => {
                 Ok(StatementKind::Retag(RetagKind::Default, Box::new(self.parse_place(args[0])?)))
             },
diff --git a/compiler/rustc_mir_dataflow/src/impls/liveness.rs b/compiler/rustc_mir_dataflow/src/impls/liveness.rs
index f6aaa65ad9fdd..596da18e3d1b4 100644
--- a/compiler/rustc_mir_dataflow/src/impls/liveness.rs
+++ b/compiler/rustc_mir_dataflow/src/impls/liveness.rs
@@ -159,8 +159,7 @@ impl DefUse {
                 MutatingUseContext::Call
                 | MutatingUseContext::Yield
                 | MutatingUseContext::AsmOutput
-                | MutatingUseContext::Store
-                | MutatingUseContext::Deinit,
+                | MutatingUseContext::Store,
             ) => {
                 // Treat derefs as a use of the base local. `*p = 4` is not a def of `p` but a use.
                 if place.is_indirect() {
@@ -238,7 +237,7 @@ impl<'a> MaybeTransitiveLiveLocals<'a> {
                 && (!debuginfo_locals.contains(place.local)
                     || (place.as_local().is_some() && stmt_kind.as_debuginfo().is_some())))
             .then_some(*place),
-            StatementKind::SetDiscriminant { place, .. } | StatementKind::Deinit(place) => {
+            StatementKind::SetDiscriminant { place, .. } => {
                 (!debuginfo_locals.contains(place.local)).then_some(**place)
             }
             StatementKind::FakeRead(_)
diff --git a/compiler/rustc_mir_dataflow/src/impls/storage_liveness.rs b/compiler/rustc_mir_dataflow/src/impls/storage_liveness.rs
index e3aa8f5a62014..026826fc379c7 100644
--- a/compiler/rustc_mir_dataflow/src/impls/storage_liveness.rs
+++ b/compiler/rustc_mir_dataflow/src/impls/storage_liveness.rs
@@ -156,8 +156,7 @@ impl<'tcx> Analysis<'tcx> for MaybeRequiresStorage<'_, 'tcx> {
 
             // If a place is assigned to in a statement, it needs storage for that statement.
             StatementKind::Assign(box (place, _))
-            | StatementKind::SetDiscriminant { box place, .. }
-            | StatementKind::Deinit(box place) => {
+            | StatementKind::SetDiscriminant { box place, .. } => {
                 state.gen_(place.local);
             }
 
diff --git a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
index 434f106302f5d..c60713cea0300 100644
--- a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
+++ b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
@@ -371,7 +371,7 @@ impl<'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> MoveDataBuilder<'a, 'tcx, F> {
                     self.gather_move(Place::from(*local));
                 }
             }
-            StatementKind::SetDiscriminant { .. } | StatementKind::Deinit(..) => {
+            StatementKind::SetDiscriminant { .. } => {
                 span_bug!(
                     stmt.source_info.span,
                     "SetDiscriminant/Deinit should not exist during borrowck"
diff --git a/compiler/rustc_mir_transform/src/coroutine.rs b/compiler/rustc_mir_transform/src/coroutine.rs
index c136df812a3f0..34e03ef69f30c 100644
--- a/compiler/rustc_mir_transform/src/coroutine.rs
+++ b/compiler/rustc_mir_transform/src/coroutine.rs
@@ -1723,7 +1723,6 @@ impl<'tcx> Visitor<'tcx> for EnsureCoroutineFieldAssignmentsNeverAlias<'_> {
 
             StatementKind::FakeRead(..)
             | StatementKind::SetDiscriminant { .. }
-            | StatementKind::Deinit(..)
             | StatementKind::StorageLive(_)
             | StatementKind::StorageDead(_)
             | StatementKind::Retag(..)
diff --git a/compiler/rustc_mir_transform/src/coverage/spans/from_mir.rs b/compiler/rustc_mir_transform/src/coverage/spans/from_mir.rs
index dfeaa90dc2e22..c096f1e2632ce 100644
--- a/compiler/rustc_mir_transform/src/coverage/spans/from_mir.rs
+++ b/compiler/rustc_mir_transform/src/coverage/spans/from_mir.rs
@@ -91,7 +91,6 @@ fn filtered_statement_span(statement: &Statement<'_>) -> Option<Span> {
         )
         | StatementKind::Assign(_)
         | StatementKind::SetDiscriminant { .. }
-        | StatementKind::Deinit(..)
         | StatementKind::Retag(_, _)
         | StatementKind::PlaceMention(..)
         | StatementKind::AscribeUserType(_, _) => Some(statement.source_info.span),
diff --git a/compiler/rustc_mir_transform/src/cross_crate_inline.rs b/compiler/rustc_mir_transform/src/cross_crate_inline.rs
index df98c07f54958..7fc9fb9cca2d7 100644
--- a/compiler/rustc_mir_transform/src/cross_crate_inline.rs
+++ b/compiler/rustc_mir_transform/src/cross_crate_inline.rs
@@ -115,10 +115,7 @@ impl<'tcx> Visitor<'tcx> for CostChecker<'_, 'tcx> {
     fn visit_statement(&mut self, statement: &Statement<'tcx>, _: Location) {
         // Don't count StorageLive/StorageDead in the inlining cost.
         match statement.kind {
-            StatementKind::StorageLive(_)
-            | StatementKind::StorageDead(_)
-            | StatementKind::Deinit(_)
-            | StatementKind::Nop => {}
+            StatementKind::StorageLive(_) | StatementKind::StorageDead(_) | StatementKind::Nop => {}
             _ => self.statements += 1,
         }
     }
diff --git a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
index e970f7ff81adb..8451ebed4f705 100644
--- a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
+++ b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
@@ -178,10 +178,6 @@ impl<'a, 'tcx> ConstAnalysis<'a, 'tcx> {
                     FlatSet::<Scalar>::BOTTOM,
                 );
             }
-            StatementKind::Deinit(box place) => {
-                // Deinit makes the place uninitialized.
-                state.flood_with(place.as_ref(), &self.map, FlatSet::<Scalar>::BOTTOM);
-            }
             StatementKind::Retag(..) => {
                 // We don't track references.
             }
diff --git a/compiler/rustc_mir_transform/src/jump_threading.rs b/compiler/rustc_mir_transform/src/jump_threading.rs
index 68298767e7fd8..37a3da94f9689 100644
--- a/compiler/rustc_mir_transform/src/jump_threading.rs
+++ b/compiler/rustc_mir_transform/src/jump_threading.rs
@@ -332,8 +332,7 @@ impl<'a, 'tcx> TOFinder<'a, 'tcx> {
         stmt: &Statement<'tcx>,
     ) -> Option<(Place<'tcx>, Option<TrackElem>)> {
         match stmt.kind {
-            StatementKind::Assign(box (place, _))
-            | StatementKind::Deinit(box place) => Some((place, None)),
+            StatementKind::Assign(box (place, _)) => Some((place, None)),
             StatementKind::SetDiscriminant { box place, variant_index: _ } => {
                 Some((place, Some(TrackElem::Discriminant)))
             }
diff --git a/compiler/rustc_mir_transform/src/known_panics_lint.rs b/compiler/rustc_mir_transform/src/known_panics_lint.rs
index 93abc0f8860b9..c67e875175fee 100644
--- a/compiler/rustc_mir_transform/src/known_panics_lint.rs
+++ b/compiler/rustc_mir_transform/src/known_panics_lint.rs
@@ -926,7 +926,6 @@ impl<'tcx> Visitor<'tcx> for CanConstProp {
             // mutations of the same local via `Store`
             | MutatingUse(MutatingUseContext::Call)
             | MutatingUse(MutatingUseContext::AsmOutput)
-            | MutatingUse(MutatingUseContext::Deinit)
             // Actual store that can possibly even propagate a value
             | MutatingUse(MutatingUseContext::Store)
             | MutatingUse(MutatingUseContext::SetDiscriminant) => {
diff --git a/compiler/rustc_mir_transform/src/large_enums.rs b/compiler/rustc_mir_transform/src/large_enums.rs
index 1b90e9158f6b8..89bd91e7013da 100644
--- a/compiler/rustc_mir_transform/src/large_enums.rs
+++ b/compiler/rustc_mir_transform/src/large_enums.rs
@@ -126,8 +126,6 @@ impl<'tcx> crate::MirPass<'tcx> for EnumSizeOpt {
                     Rvalue::Cast(CastKind::PtrToPtr, Operand::Copy(src), src_cast_ty),
                 )));
 
-                let deinit_old = StatementKind::Deinit(Box::new(dst));
-
                 let copy_bytes = StatementKind::Intrinsic(Box::new(
                     NonDivergingIntrinsic::CopyNonOverlapping(CopyNonOverlapping {
                         src: Operand::Copy(src_cast_place),
@@ -148,7 +146,6 @@ impl<'tcx> crate::MirPass<'tcx> for EnumSizeOpt {
                     dst_cast,
                     src_ptr,
                     src_cast,
-                    deinit_old,
                     copy_bytes,
                     store_dead,
                 ];
diff --git a/compiler/rustc_mir_transform/src/remove_noop_landing_pads.rs b/compiler/rustc_mir_transform/src/remove_noop_landing_pads.rs
index 38752bde6b417..f7105f62e4beb 100644
--- a/compiler/rustc_mir_transform/src/remove_noop_landing_pads.rs
+++ b/compiler/rustc_mir_transform/src/remove_noop_landing_pads.rs
@@ -113,7 +113,6 @@ impl RemoveNoopLandingPads {
 
                 StatementKind::Assign { .. }
                 | StatementKind::SetDiscriminant { .. }
-                | StatementKind::Deinit(..)
                 | StatementKind::Intrinsic(..)
                 | StatementKind::Retag { .. } => {
                     return false;
diff --git a/compiler/rustc_mir_transform/src/remove_zsts.rs b/compiler/rustc_mir_transform/src/remove_zsts.rs
index 90c1b3520b96e..bebd8fab74565 100644
--- a/compiler/rustc_mir_transform/src/remove_zsts.rs
+++ b/compiler/rustc_mir_transform/src/remove_zsts.rs
@@ -122,8 +122,7 @@ impl<'tcx> MutVisitor<'tcx> for Replacer<'_, 'tcx> {
             StatementKind::Assign(box (place, ref rvalue)) => {
                 rvalue.is_safe_to_remove().then_some(place)
             }
-            StatementKind::Deinit(box place)
-            | StatementKind::SetDiscriminant { box place, variant_index: _ }
+            StatementKind::SetDiscriminant { box place, variant_index: _ }
             | StatementKind::AscribeUserType(box (place, _), _)
             | StatementKind::Retag(_, box place)
             | StatementKind::PlaceMention(box place)
diff --git a/compiler/rustc_mir_transform/src/simplify.rs b/compiler/rustc_mir_transform/src/simplify.rs
index 8b5efb7420582..da31600e8324c 100644
--- a/compiler/rustc_mir_transform/src/simplify.rs
+++ b/compiler/rustc_mir_transform/src/simplify.rs
@@ -590,7 +590,6 @@ impl<'tcx> Visitor<'tcx> for UsedLocals {
             }
 
             StatementKind::SetDiscriminant { ref place, variant_index: _ }
-            | StatementKind::Deinit(ref place)
             | StatementKind::BackwardIncompatibleDropHint { ref place, reason: _ } => {
                 self.visit_lhs(place, location);
             }
@@ -630,8 +629,9 @@ fn remove_unused_definitions_helper(used_locals: &mut UsedLocals, body: &mut Bod
                     }
                     StatementKind::Assign(box (place, _))
                     | StatementKind::SetDiscriminant { box place, .. }
-                    | StatementKind::BackwardIncompatibleDropHint { box place, .. }
-                    | StatementKind::Deinit(box place) => used_locals.is_used(place.local),
+                    | StatementKind::BackwardIncompatibleDropHint { box place, .. } => {
+                        used_locals.is_used(place.local)
+                    }
                     _ => continue,
                 };
                 if keep_statement {
diff --git a/compiler/rustc_mir_transform/src/sroa.rs b/compiler/rustc_mir_transform/src/sroa.rs
index 99f10b8d91d2c..801383493837d 100644
--- a/compiler/rustc_mir_transform/src/sroa.rs
+++ b/compiler/rustc_mir_transform/src/sroa.rs
@@ -136,9 +136,7 @@ fn escaping_locals<'tcx>(
         fn visit_statement(&mut self, statement: &Statement<'tcx>, location: Location) {
             match statement.kind {
                 // Storage statements are expanded in run_pass.
-                StatementKind::StorageLive(..)
-                | StatementKind::StorageDead(..)
-                | StatementKind::Deinit(..) => return,
+                StatementKind::StorageLive(..) | StatementKind::StorageDead(..) => return,
                 _ => self.super_statement(statement, location),
             }
         }
@@ -331,16 +329,6 @@ impl<'tcx, 'll> MutVisitor<'tcx> for ReplacementVisitor<'tcx, 'll> {
                 }
                 return;
             }
-            StatementKind::Deinit(box place) => {
-                if let Some(final_locals) = self.replacements.place_fragments(place) {
-                    for (_, _, fl) in final_locals {
-                        self.patch
-                            .add_statement(location, StatementKind::Deinit(Box::new(fl.into())));
-                    }
-                    statement.make_nop(true);
-                    return;
-                }
-            }
 
             // We have `a = Struct { 0: x, 1: y, .. }`.
             // We replace it by
diff --git a/compiler/rustc_mir_transform/src/validate.rs b/compiler/rustc_mir_transform/src/validate.rs
index 95873484b6529..ed453a580e854 100644
--- a/compiler/rustc_mir_transform/src/validate.rs
+++ b/compiler/rustc_mir_transform/src/validate.rs
@@ -313,11 +313,6 @@ impl<'a, 'tcx> Visitor<'tcx> for CfgChecker<'a, 'tcx> {
                     self.fail(location, "`SetDiscriminant`is not allowed until deaggregation");
                 }
             }
-            StatementKind::Deinit(..) => {
-                if self.body.phase < MirPhase::Runtime(RuntimePhase::Initial) {
-                    self.fail(location, "`Deinit`is not allowed until deaggregation");
-                }
-            }
             StatementKind::Retag(kind, _) => {
                 // FIXME(JakobDegen) The validator should check that `self.body.phase <
                 // DropsLowered`. However, this causes ICEs with generation of drop shims, which
@@ -1501,11 +1496,6 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                     );
                 }
             }
-            StatementKind::Deinit(..) => {
-                if self.body.phase < MirPhase::Runtime(RuntimePhase::Initial) {
-                    self.fail(location, "`Deinit`is not allowed until deaggregation");
-                }
-            }
             StatementKind::Retag(kind, _) => {
                 // FIXME(JakobDegen) The validator should check that `self.body.phase <
                 // DropsLowered`. However, this causes ICEs with generation of drop shims, which
diff --git a/compiler/rustc_public/src/mir/body.rs b/compiler/rustc_public/src/mir/body.rs
index 7bd06fee721ce..615a5a48d15b7 100644
--- a/compiler/rustc_public/src/mir/body.rs
+++ b/compiler/rustc_public/src/mir/body.rs
@@ -478,7 +478,6 @@ pub enum StatementKind {
     Assign(Place, Rvalue),
     FakeRead(FakeReadCause, Place),
     SetDiscriminant { place: Place, variant_index: VariantIdx },
-    Deinit(Place),
     StorageLive(Local),
     StorageDead(Local),
     Retag(RetagKind, Place),
diff --git a/compiler/rustc_public/src/mir/pretty.rs b/compiler/rustc_public/src/mir/pretty.rs
index 9dd1ce4de0ea6..8904870f29e32 100644
--- a/compiler/rustc_public/src/mir/pretty.rs
+++ b/compiler/rustc_public/src/mir/pretty.rs
@@ -102,7 +102,6 @@ fn pretty_statement<W: Write>(writer: &mut W, statement: &StatementKind) -> io::
         StatementKind::SetDiscriminant { place, variant_index } => {
             writeln!(writer, "{INDENT}discriminant({place:?}) = {};", variant_index.to_index())
         }
-        StatementKind::Deinit(place) => writeln!(writer, "Deinit({place:?};"),
         StatementKind::StorageLive(local) => {
             writeln!(writer, "{INDENT}StorageLive(_{local});")
         }
diff --git a/compiler/rustc_public/src/mir/visit.rs b/compiler/rustc_public/src/mir/visit.rs
index 7563c9ca00820..1cb9bfe79a096 100644
--- a/compiler/rustc_public/src/mir/visit.rs
+++ b/compiler/rustc_public/src/mir/visit.rs
@@ -170,7 +170,6 @@ macro_rules! make_mir_visitor {
                         self.visit_place(place, PlaceContext::NON_MUTATING, location);
                     }
                     StatementKind::SetDiscriminant { place, .. }
-                    | StatementKind::Deinit(place)
                     | StatementKind::Retag(_, place) => {
                         self.visit_place(place, PlaceContext::MUTATING, location);
                     }
diff --git a/compiler/rustc_public/src/unstable/convert/stable/mir.rs b/compiler/rustc_public/src/unstable/convert/stable/mir.rs
index 62ab91d17baee..392347ce345a0 100644
--- a/compiler/rustc_public/src/unstable/convert/stable/mir.rs
+++ b/compiler/rustc_public/src/unstable/convert/stable/mir.rs
@@ -149,9 +149,6 @@ impl<'tcx> Stable<'tcx> for mir::StatementKind<'tcx> {
                     variant_index: variant_index.stable(tables, cx),
                 }
             }
-            mir::StatementKind::Deinit(place) => {
-                crate::mir::StatementKind::Deinit(place.stable(tables, cx))
-            }
 
             mir::StatementKind::StorageLive(place) => {
                 crate::mir::StatementKind::StorageLive(place.stable(tables, cx))
diff --git a/library/core/src/intrinsics/mir.rs b/library/core/src/intrinsics/mir.rs
index a800ef1cb9375..8ddce1c758438 100644
--- a/library/core/src/intrinsics/mir.rs
+++ b/library/core/src/intrinsics/mir.rs
@@ -227,7 +227,7 @@
 //!
 //! #### Statements
 //!  - Assign statements work via normal Rust assignment.
-//!  - [`Retag`], [`StorageLive`], [`StorageDead`], [`Deinit`] statements have an associated function.
+//!  - [`Retag`], [`StorageLive`], [`StorageDead`] statements have an associated function.
 //!
 //! #### Rvalues
 //!
@@ -400,7 +400,6 @@ define!("mir_unwind_resume",
 define!("mir_storage_live", fn StorageLive<T>(local: T));
 define!("mir_storage_dead", fn StorageDead<T>(local: T));
 define!("mir_assume", fn Assume(operand: bool));
-define!("mir_deinit", fn Deinit<T>(place: T));
 define!("mir_checked", fn Checked<T>(binop: T) -> (T, bool));
 define!(
     "mir_ptr_metadata",
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 1e3a7281bc734..b9027fea468eb 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
@@ -232,7 +232,7 @@ fn check_statement<'tcx>(
 
         StatementKind::FakeRead(box (_, place)) => check_place(cx, *place, span, body, msrv),
         // just an assignment
-        StatementKind::SetDiscriminant { place, .. } | StatementKind::Deinit(place) => {
+        StatementKind::SetDiscriminant { place, .. } => {
             check_place(cx, **place, span, body, msrv)
         },
 
diff --git a/tests/mir-opt/building/custom/enums.rs b/tests/mir-opt/building/custom/enums.rs
index 88ec228986ab7..6fad373203a69 100644
--- a/tests/mir-opt/building/custom/enums.rs
+++ b/tests/mir-opt/building/custom/enums.rs
@@ -88,7 +88,6 @@ fn switch_option_repr(option: Bool) -> bool {
 fn set_discr(option: &mut Option<()>) {
     mir! {
         {
-            Deinit(*option);
             SetDiscriminant(*option, 0);
             Return()
         }
diff --git a/tests/mir-opt/building/custom/enums.set_discr.built.after.mir b/tests/mir-opt/building/custom/enums.set_discr.built.after.mir
index 8cc66e7e50d6a..d9b46dff43aa4 100644
--- a/tests/mir-opt/building/custom/enums.set_discr.built.after.mir
+++ b/tests/mir-opt/building/custom/enums.set_discr.built.after.mir
@@ -4,7 +4,6 @@ fn set_discr(_1: &mut Option<()>) -> () {
     let mut _0: ();
 
     bb0: {
-        Deinit((*_1));
         discriminant((*_1)) = 0;
         return;
     }
diff --git a/tests/mir-opt/enum_opt.cand.EnumSizeOpt.32bit.diff b/tests/mir-opt/enum_opt.cand.EnumSizeOpt.32bit.diff
index 267a4c1cf6beb..cf850351c1d62 100644
--- a/tests/mir-opt/enum_opt.cand.EnumSizeOpt.32bit.diff
+++ b/tests/mir-opt/enum_opt.cand.EnumSizeOpt.32bit.diff
@@ -44,7 +44,6 @@
 +         _9 = copy _8 as *mut u8 (PtrToPtr);
 +         _10 = &raw const _2;
 +         _11 = copy _10 as *const u8 (PtrToPtr);
-+         Deinit(_8);
 +         copy_nonoverlapping(dst = copy _9, src = copy _11, count = copy _7);
 +         StorageDead(_4);
 +         nop;
@@ -59,7 +58,6 @@
 +         _17 = copy _16 as *mut u8 (PtrToPtr);
 +         _18 = &raw const _1;
 +         _19 = copy _18 as *const u8 (PtrToPtr);
-+         Deinit(_16);
 +         copy_nonoverlapping(dst = copy _17, src = copy _19, count = copy _15);
 +         StorageDead(_12);
 +         nop;
diff --git a/tests/mir-opt/enum_opt.cand.EnumSizeOpt.64bit.diff b/tests/mir-opt/enum_opt.cand.EnumSizeOpt.64bit.diff
index 8e5c403cd7e6b..dc5ea1add0005 100644
--- a/tests/mir-opt/enum_opt.cand.EnumSizeOpt.64bit.diff
+++ b/tests/mir-opt/enum_opt.cand.EnumSizeOpt.64bit.diff
@@ -44,7 +44,6 @@
 +         _9 = copy _8 as *mut u8 (PtrToPtr);
 +         _10 = &raw const _2;
 +         _11 = copy _10 as *const u8 (PtrToPtr);
-+         Deinit(_8);
 +         copy_nonoverlapping(dst = copy _9, src = copy _11, count = copy _7);
 +         StorageDead(_4);
 +         nop;
@@ -59,7 +58,6 @@
 +         _17 = copy _16 as *mut u8 (PtrToPtr);
 +         _18 = &raw const _1;
 +         _19 = copy _18 as *const u8 (PtrToPtr);
-+         Deinit(_16);
 +         copy_nonoverlapping(dst = copy _17, src = copy _19, count = copy _15);
 +         StorageDead(_12);
 +         nop;
diff --git a/tests/mir-opt/enum_opt.unin.EnumSizeOpt.32bit.diff b/tests/mir-opt/enum_opt.unin.EnumSizeOpt.32bit.diff
index 96c5aadd85fd4..3cd2e74a0db6f 100644
--- a/tests/mir-opt/enum_opt.unin.EnumSizeOpt.32bit.diff
+++ b/tests/mir-opt/enum_opt.unin.EnumSizeOpt.32bit.diff
@@ -44,7 +44,6 @@
 +         _9 = copy _8 as *mut u8 (PtrToPtr);
 +         _10 = &raw const _2;
 +         _11 = copy _10 as *const u8 (PtrToPtr);
-+         Deinit(_8);
 +         copy_nonoverlapping(dst = copy _9, src = copy _11, count = copy _7);
 +         StorageDead(_4);
 +         nop;
@@ -59,7 +58,6 @@
 +         _17 = copy _16 as *mut u8 (PtrToPtr);
 +         _18 = &raw const _1;
 +         _19 = copy _18 as *const u8 (PtrToPtr);
-+         Deinit(_16);
 +         copy_nonoverlapping(dst = copy _17, src = copy _19, count = copy _15);
 +         StorageDead(_12);
 +         nop;
diff --git a/tests/mir-opt/enum_opt.unin.EnumSizeOpt.64bit.diff b/tests/mir-opt/enum_opt.unin.EnumSizeOpt.64bit.diff
index d20e2e08eaafd..10b0ec5a63fa4 100644
--- a/tests/mir-opt/enum_opt.unin.EnumSizeOpt.64bit.diff
+++ b/tests/mir-opt/enum_opt.unin.EnumSizeOpt.64bit.diff
@@ -44,7 +44,6 @@
 +         _9 = copy _8 as *mut u8 (PtrToPtr);
 +         _10 = &raw const _2;
 +         _11 = copy _10 as *const u8 (PtrToPtr);
-+         Deinit(_8);
 +         copy_nonoverlapping(dst = copy _9, src = copy _11, count = copy _7);
 +         StorageDead(_4);
 +         nop;
@@ -59,7 +58,6 @@
 +         _17 = copy _16 as *mut u8 (PtrToPtr);
 +         _18 = &raw const _1;
 +         _19 = copy _18 as *const u8 (PtrToPtr);
-+         Deinit(_16);
 +         copy_nonoverlapping(dst = copy _17, src = copy _19, count = copy _15);
 +         StorageDead(_12);
 +         nop;

From ce671f998f9093e9fb215cc7e6ee036bc7094c21 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Thu, 9 Oct 2025 11:27:35 +0200
Subject: [PATCH 1858/1889] Update rustc-perf submodule

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

diff --git a/src/tools/rustc-perf b/src/tools/rustc-perf
index dde879cf1087c..c0301bc44d175 160000
--- a/src/tools/rustc-perf
+++ b/src/tools/rustc-perf
@@ -1 +1 @@
-Subproject commit dde879cf1087cb34a32287bd8ccc4d545bb9fee5
+Subproject commit c0301bc44d175b9b2c5442b25049475c39d7700c

From 0abecda9edebdea76e07092ffb4f6c4261b25228 Mon Sep 17 00:00:00 2001
From: AMS21 <ams21.github@gmail.com>
Date: Fri, 10 Oct 2025 12:16:11 +0200
Subject: [PATCH 1859/1889] Replace `LLVMRustContextCreate` with normal LLVM-C
 API calls

Since `LLVMRustContextCreate` can easily be replaced with a call to
`LLVMContextCreate` and `LLVMContextSetDiscardValueNames`.
---
 compiler/rustc_codegen_llvm/src/lib.rs           | 11 ++++++++---
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs      |  5 ++---
 compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp |  6 ------
 3 files changed, 10 insertions(+), 12 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/lib.rs b/compiler/rustc_codegen_llvm/src/lib.rs
index 807049f08d367..a2ed11a83b13a 100644
--- a/compiler/rustc_codegen_llvm/src/lib.rs
+++ b/compiler/rustc_codegen_llvm/src/lib.rs
@@ -48,6 +48,8 @@ use rustc_session::config::{OptLevel, OutputFilenames, PrintKind, PrintRequest};
 use rustc_span::Symbol;
 use rustc_target::spec::{RelocModel, TlsModel};
 
+use crate::llvm::ToLlvmBool;
+
 mod abi;
 mod allocator;
 mod asm;
@@ -384,7 +386,8 @@ unsafe impl Sync for ModuleLlvm {}
 impl ModuleLlvm {
     fn new(tcx: TyCtxt<'_>, mod_name: &str) -> Self {
         unsafe {
-            let llcx = llvm::LLVMRustContextCreate(tcx.sess.fewer_names());
+            let llcx = llvm::LLVMContextCreate();
+            llvm::LLVMContextSetDiscardValueNames(llcx, tcx.sess.fewer_names().to_llvm_bool());
             let llmod_raw = context::create_module(tcx, llcx, mod_name) as *const _;
             ModuleLlvm {
                 llmod_raw,
@@ -396,7 +399,8 @@ impl ModuleLlvm {
 
     fn new_metadata(tcx: TyCtxt<'_>, mod_name: &str) -> Self {
         unsafe {
-            let llcx = llvm::LLVMRustContextCreate(tcx.sess.fewer_names());
+            let llcx = llvm::LLVMContextCreate();
+            llvm::LLVMContextSetDiscardValueNames(llcx, tcx.sess.fewer_names().to_llvm_bool());
             let llmod_raw = context::create_module(tcx, llcx, mod_name) as *const _;
             ModuleLlvm {
                 llmod_raw,
@@ -427,7 +431,8 @@ impl ModuleLlvm {
         dcx: DiagCtxtHandle<'_>,
     ) -> Self {
         unsafe {
-            let llcx = llvm::LLVMRustContextCreate(cgcx.fewer_names);
+            let llcx = llvm::LLVMContextCreate();
+            llvm::LLVMContextSetDiscardValueNames(llcx, cgcx.fewer_names.to_llvm_bool());
             let llmod_raw = back::lto::parse_module(llcx, name, buffer, dcx);
             let tm = ModuleLlvm::tm_from_cgcx(cgcx, name.to_str().unwrap(), dcx);
 
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 67e8bc7062bd9..1740dbd1684d0 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -905,7 +905,9 @@ pub(crate) type GetSymbolsErrorCallback = unsafe extern "C" fn(*const c_char) ->
 
 unsafe extern "C" {
     // Create and destroy contexts.
+    pub(crate) fn LLVMContextCreate() -> &'static mut Context;
     pub(crate) fn LLVMContextDispose(C: &'static mut Context);
+    pub(crate) fn LLVMContextSetDiscardValueNames(C: &Context, Discard: Bool);
     pub(crate) fn LLVMGetMDKindIDInContext(
         C: &Context,
         Name: *const c_char,
@@ -1925,9 +1927,6 @@ unsafe extern "C" {
     pub(crate) fn LLVMRustInstallErrorHandlers();
     pub(crate) fn LLVMRustDisableSystemDialogsOnCrash();
 
-    // Create and destroy contexts.
-    pub(crate) fn LLVMRustContextCreate(shouldDiscardNames: bool) -> &'static mut Context;
-
     // Operations on all values
     pub(crate) fn LLVMRustGlobalAddMetadata<'a>(
         Val: &'a Value,
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index 3722f8d689e53..094e018058aad 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -123,12 +123,6 @@ extern "C" void LLVMRustSetLastError(const char *Err) {
   LastError = strdup(Err);
 }
 
-extern "C" LLVMContextRef LLVMRustContextCreate(bool shouldDiscardNames) {
-  auto ctx = new LLVMContext();
-  ctx->setDiscardValueNames(shouldDiscardNames);
-  return wrap(ctx);
-}
-
 extern "C" void LLVMRustSetNormalizedTarget(LLVMModuleRef M,
                                             const char *Target) {
 #if LLVM_VERSION_GE(21, 0)

From 1ee2c58e8925315a45500d73c5527b7a340cc8a5 Mon Sep 17 00:00:00 2001
From: dianqk <dianqk@dianqk.net>
Date: Fri, 10 Oct 2025 13:50:01 +0800
Subject: [PATCH 1860/1889] Replace locals in debuginfo records during
 dest_prop

---
 compiler/rustc_mir_transform/src/dest_prop.rs                | 1 -
 ...t_prop.remap_debuginfo_locals.DestinationPropagation.diff | 3 ++-
 tests/mir-opt/debuginfo/dest_prop.rs                         | 5 ++++-
 .../debuginfo/dest_prop_debuginfo-147485.rs}                 | 4 +++-
 4 files changed, 9 insertions(+), 4 deletions(-)
 rename tests/{crashes/147485-2.rs => ui/debuginfo/dest_prop_debuginfo-147485.rs} (81%)

diff --git a/compiler/rustc_mir_transform/src/dest_prop.rs b/compiler/rustc_mir_transform/src/dest_prop.rs
index 1f38433fa5a41..92556e7c5f6c5 100644
--- a/compiler/rustc_mir_transform/src/dest_prop.rs
+++ b/compiler/rustc_mir_transform/src/dest_prop.rs
@@ -277,7 +277,6 @@ impl<'tcx> MutVisitor<'tcx> for Merger<'tcx> {
                 if self.merged_locals.contains(*local) =>
             {
                 statement.make_nop(true);
-                return;
             }
             _ => (),
         };
diff --git a/tests/mir-opt/debuginfo/dest_prop.remap_debuginfo_locals.DestinationPropagation.diff b/tests/mir-opt/debuginfo/dest_prop.remap_debuginfo_locals.DestinationPropagation.diff
index 6f3233d85c9fc..fe00da67e8bb0 100644
--- a/tests/mir-opt/debuginfo/dest_prop.remap_debuginfo_locals.DestinationPropagation.diff
+++ b/tests/mir-opt/debuginfo/dest_prop.remap_debuginfo_locals.DestinationPropagation.diff
@@ -9,11 +9,12 @@
       let mut _4: bool;
   
       bb0: {
-          // DBG: _3 = &_1;
+-         // DBG: _3 = &_1;
 -         StorageLive(_4);
 -         _4 = copy _1;
 -         _3 = copy _2;
 -         switchInt(copy _4) -> [1: bb1, otherwise: bb2];
++         // DBG: _2 = &_1;
 +         nop;
 +         nop;
 +         nop;
diff --git a/tests/mir-opt/debuginfo/dest_prop.rs b/tests/mir-opt/debuginfo/dest_prop.rs
index 9c9d95ebfb3f3..a734cacb4d29a 100644
--- a/tests/mir-opt/debuginfo/dest_prop.rs
+++ b/tests/mir-opt/debuginfo/dest_prop.rs
@@ -1,4 +1,3 @@
-// skip-filecheck
 //@ test-mir-pass: DestinationPropagation
 //@ compile-flags: -g -Zmir-enable-passes=+DeadStoreElimination-initial
 
@@ -10,6 +9,10 @@ use std::intrinsics::mir::*;
 // EMIT_MIR dest_prop.remap_debuginfo_locals.DestinationPropagation.diff
 #[custom_mir(dialect = "runtime", phase = "post-cleanup")]
 pub fn remap_debuginfo_locals(a: bool, b: &bool) -> &bool {
+    // CHECK-LABEL: fn remap_debuginfo_locals(
+    // CHECK: debug c => [[c:_.*]];
+    // CHECK: bb0:
+    // CHECK-NEXT: DBG: [[c]] = &_1;
     mir! {
         let _3: &bool;
         let _4: bool;
diff --git a/tests/crashes/147485-2.rs b/tests/ui/debuginfo/dest_prop_debuginfo-147485.rs
similarity index 81%
rename from tests/crashes/147485-2.rs
rename to tests/ui/debuginfo/dest_prop_debuginfo-147485.rs
index da092a3af76aa..652660d473b15 100644
--- a/tests/crashes/147485-2.rs
+++ b/tests/ui/debuginfo/dest_prop_debuginfo-147485.rs
@@ -1,6 +1,8 @@
-//@ known-bug: #147485
+//@ build-pass
 //@ compile-flags: -g -O
 
+// Regression test for #147485.
+
 #![crate_type = "lib"]
 
 pub fn foo(a: bool, b: bool) -> bool {

From 4eccd0222962bf3203b11f103f391c866e039512 Mon Sep 17 00:00:00 2001
From: Asger Hautop Drewsen <asger@tyilo.com>
Date: Fri, 10 Oct 2025 18:01:03 +0200
Subject: [PATCH 1861/1889] Stabilize unsigned_nonzero_div_ceil

---
 library/core/src/num/nonzero.rs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/library/core/src/num/nonzero.rs b/library/core/src/num/nonzero.rs
index d9184e3c9c229..fcdb65bd45c95 100644
--- a/library/core/src/num/nonzero.rs
+++ b/library/core/src/num/nonzero.rs
@@ -1373,7 +1373,6 @@ macro_rules! nonzero_integer_signedness_dependent_impls {
             /// # Examples
             ///
             /// ```
-            /// # #![feature(unsigned_nonzero_div_ceil)]
             /// # use std::num::NonZero;
             #[doc = concat!("let one = NonZero::new(1", stringify!($Int), ").unwrap();")]
             #[doc = concat!("let max = NonZero::new(", stringify!($Int), "::MAX).unwrap();")]
@@ -1383,7 +1382,11 @@ macro_rules! nonzero_integer_signedness_dependent_impls {
             #[doc = concat!("let three = NonZero::new(3", stringify!($Int), ").unwrap();")]
             /// assert_eq!(three.div_ceil(two), two);
             /// ```
-            #[unstable(feature = "unsigned_nonzero_div_ceil", issue = "132968")]
+            #[stable(feature = "unsigned_nonzero_div_ceil", since = "CURRENT_RUSTC_VERSION")]
+            #[rustc_const_stable(
+                feature = "unsigned_nonzero_div_ceil",
+                since = "CURRENT_RUSTC_VERSION"
+            )]
             #[must_use = "this returns the result of the operation, \
                           without modifying the original"]
             #[inline]

From dff4561f591cca31938763b577e81a98e425f6ea Mon Sep 17 00:00:00 2001
From: Stepan Koltsov <stepan.koltsov@gmail.com>
Date: Fri, 10 Oct 2025 20:01:02 +0100
Subject: [PATCH 1862/1889] Fix documentation of Instant::now on mac

---
 library/std/src/time.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/library/std/src/time.rs b/library/std/src/time.rs
index 31187adb6feae..87aaf9091f1bc 100644
--- a/library/std/src/time.rs
+++ b/library/std/src/time.rs
@@ -112,19 +112,19 @@ use crate::sys_common::{FromInner, IntoInner};
 /// |  Platform |               System call                                            |
 /// |-----------|----------------------------------------------------------------------|
 /// | SGX       | [`insecure_time` usercall]. More information on [timekeeping in SGX] |
-/// | UNIX      | [clock_gettime (Monotonic Clock)]                                    |
-/// | Darwin    | [clock_gettime (Monotonic Clock)]                                    |
-/// | VXWorks   | [clock_gettime (Monotonic Clock)]                                    |
+/// | UNIX      | [clock_gettime] with `CLOCK_MONOTONIC`                               |
+/// | Darwin    | [clock_gettime] with `CLOCK_UPTIME_RAW`                              |
+/// | VXWorks   | [clock_gettime] with `CLOCK_MONOTONIC`                               |
 /// | SOLID     | `get_tim`                                                            |
-/// | WASI      | [__wasi_clock_time_get (Monotonic Clock)]                            |
+/// | WASI      | [__wasi_clock_time_get] with `monotonic`                             |
 /// | Windows   | [QueryPerformanceCounter]                                            |
 ///
 /// [currently]: crate::io#platform-specific-behavior
 /// [QueryPerformanceCounter]: https://docs.microsoft.com/en-us/windows/win32/api/profileapi/nf-profileapi-queryperformancecounter
 /// [`insecure_time` usercall]: https://edp.fortanix.com/docs/api/fortanix_sgx_abi/struct.Usercalls.html#method.insecure_time
 /// [timekeeping in SGX]: https://edp.fortanix.com/docs/concepts/rust-std/#codestdtimecode
-/// [__wasi_clock_time_get (Monotonic Clock)]: https://github.com/WebAssembly/WASI/blob/main/legacy/preview1/docs.md#clock_time_get
-/// [clock_gettime (Monotonic Clock)]: https://linux.die.net/man/3/clock_gettime
+/// [__wasi_clock_time_get]: https://github.com/WebAssembly/WASI/blob/main/legacy/preview1/docs.md#clock_time_get
+/// [clock_gettime]: https://linux.die.net/man/3/clock_gettime
 ///
 /// **Disclaimer:** These system calls might change over time.
 ///

From 9c6c702431eb62695c4cc28d77c3c19775ff3494 Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Fri, 10 Oct 2025 15:45:46 -0400
Subject: [PATCH 1863/1889] Update cargo submodule

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

diff --git a/src/tools/cargo b/src/tools/cargo
index 801d9b4981dd0..81c3f77a46735 160000
--- a/src/tools/cargo
+++ b/src/tools/cargo
@@ -1 +1 @@
-Subproject commit 801d9b4981dd07e3aecdca1ab86834c13615737e
+Subproject commit 81c3f77a467359c8be6bc747dc93ec66a6e4ce11

From a3482d97c6442d00097b47c846a90d9688c56e2c Mon Sep 17 00:00:00 2001
From: dianqk <dianqk@dianqk.net>
Date: Fri, 10 Oct 2025 20:29:59 +0800
Subject: [PATCH 1864/1889] Remove the temporary directory when a check ends

---
 src/bootstrap/src/core/build_steps/test.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index 00aea8feab7de..f1de43bd4624a 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -3262,6 +3262,8 @@ fn distcheck_plain_source_tarball(builder: &Builder<'_>, plain_src_dir: &Path) {
         .env("GITHUB_ACTIONS", "0")
         .current_dir(plain_src_dir)
         .run(builder);
+    // Mitigate pressure on small-capacity disks.
+    builder.remove_dir(plain_src_dir);
 }
 
 /// Check that rust-src has all of libstd's dependencies
@@ -3287,6 +3289,8 @@ fn distcheck_rust_src(builder: &Builder<'_>, src_dir: &Path) {
         .arg(&toml)
         .current_dir(src_dir)
         .run(builder);
+    // Mitigate pressure on small-capacity disks.
+    builder.remove_dir(src_dir);
 }
 
 /// Check that rustc-dev's compiler crate source code can be loaded with `cargo metadata`
@@ -3311,6 +3315,8 @@ fn distcheck_rustc_dev(builder: &Builder<'_>, dir: &Path) {
         .env("RUSTC", &builder.initial_rustc)
         .current_dir(dir)
         .run(builder);
+    // Mitigate pressure on small-capacity disks.
+    builder.remove_dir(dir);
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]

From 33cc7787bf0b17f9b951205be94f602b67ffc379 Mon Sep 17 00:00:00 2001
From: beepster4096 <19316085+beepster4096@users.noreply.github.com>
Date: Wed, 13 Aug 2025 14:59:08 -0700
Subject: [PATCH 1865/1889] trivial test blessings

---
 ....main-{closure#0}.StateTransform.after.mir | 16 ++++++------
 ....main-{closure#1}.StateTransform.after.mir | 16 ++++++------
 .../struct.main.DataflowConstProp.32bit.diff  | 16 ++++++------
 .../struct.main.DataflowConstProp.64bit.diff  | 16 ++++++------
 ...ef.tuple.DeadStoreElimination-initial.diff |  4 +--
 ...ch_68867.try_sum.EarlyOtherwiseBranch.diff | 26 +++++++++----------
 ...ness.no_downcast.EarlyOtherwiseBranch.diff |  2 +-
 .../gvn_copy_aggregate.all_copy_2.GVN.diff    |  7 +++--
 ...y.run2-{closure#0}.Inline.panic-abort.diff | 18 ++++++-------
 ....run2-{closure#0}.Inline.panic-unwind.diff | 22 ++++++++--------
 ...ef_nested_borrows.src.GVN.panic-abort.diff |  6 ++---
 ...f_nested_borrows.src.GVN.panic-unwind.diff |  6 ++---
 ...fg-pre-optimizations.after.panic-abort.mir |  2 +-
 ...g-pre-optimizations.after.panic-unwind.mir |  2 +-
 ...mes.foo.ScalarReplacementOfAggregates.diff |  8 +++---
 .../async-closure.stdout                      | 18 ++++++-------
 16 files changed, 90 insertions(+), 95 deletions(-)

diff --git a/tests/mir-opt/building/coroutine.main-{closure#0}.StateTransform.after.mir b/tests/mir-opt/building/coroutine.main-{closure#0}.StateTransform.after.mir
index d8fdb446135b3..cd776ad7170a3 100644
--- a/tests/mir-opt/building/coroutine.main-{closure#0}.StateTransform.after.mir
+++ b/tests/mir-opt/building/coroutine.main-{closure#0}.StateTransform.after.mir
@@ -50,19 +50,19 @@ fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:18:5: 18:18}>, _2
     let mut _25: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18};
 
     bb0: {
-        _18 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18});
+        _18 = copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18});
         _17 = discriminant((*_18));
         switchInt(move _17) -> [0: bb1, 1: bb19, 3: bb17, 4: bb18, otherwise: bb20];
     }
 
     bb1: {
-        _19 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18});
+        _19 = copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18});
         (((*_19) as variant#4).0: std::string::String) = move _2;
         StorageLive(_3);
         StorageLive(_4);
         StorageLive(_5);
         StorageLive(_6);
-        _20 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18});
+        _20 = copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18});
         _6 = &(((*_20) as variant#4).0: std::string::String);
         _5 = <String as Clone>::clone(move _6) -> [return: bb2, unwind unreachable];
     }
@@ -84,7 +84,7 @@ fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:18:5: 18:18}>, _2
         _0 = CoroutineState::<(&str, String, &Location<'_>), ()>::Yielded(move _4);
         StorageDead(_3);
         StorageDead(_4);
-        _21 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18});
+        _21 = copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18});
         discriminant((*_21)) = 3;
         return;
     }
@@ -108,7 +108,7 @@ fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:18:5: 18:18}>, _2
         _10 = &(*_11);
         StorageLive(_12);
         StorageLive(_13);
-        _22 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18});
+        _22 = copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18});
         _13 = &(((*_22) as variant#4).0: std::string::String);
         _12 = <String as Clone>::clone(move _13) -> [return: bb8, unwind unreachable];
     }
@@ -135,7 +135,7 @@ fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:18:5: 18:18}>, _2
         StorageDead(_9);
         StorageDead(_11);
         StorageDead(_15);
-        _23 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18});
+        _23 = copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18});
         discriminant((*_23)) = 4;
         return;
     }
@@ -154,7 +154,7 @@ fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:18:5: 18:18}>, _2
         StorageDead(_11);
         StorageDead(_8);
         _16 = const ();
-        _24 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18});
+        _24 = copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18});
         drop((((*_24) as variant#4).0: std::string::String)) -> [return: bb14, unwind unreachable];
     }
 
@@ -164,7 +164,7 @@ fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:18:5: 18:18}>, _2
 
     bb15: {
         _0 = CoroutineState::<(&str, String, &Location<'_>), ()>::Complete(move _16);
-        _25 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18});
+        _25 = copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18});
         discriminant((*_25)) = 1;
         return;
     }
diff --git a/tests/mir-opt/building/coroutine.main-{closure#1}.StateTransform.after.mir b/tests/mir-opt/building/coroutine.main-{closure#1}.StateTransform.after.mir
index dd17afad656b8..981bc21dc878a 100644
--- a/tests/mir-opt/building/coroutine.main-{closure#1}.StateTransform.after.mir
+++ b/tests/mir-opt/building/coroutine.main-{closure#1}.StateTransform.after.mir
@@ -50,19 +50,19 @@ fn main::{closure#1}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:25:5: 25:18}>, _2
     let mut _25: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18};
 
     bb0: {
-        _18 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18});
+        _18 = copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18});
         _17 = discriminant((*_18));
         switchInt(move _17) -> [0: bb1, 1: bb19, 3: bb17, 4: bb18, otherwise: bb20];
     }
 
     bb1: {
-        _19 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18});
+        _19 = copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18});
         (((*_19) as variant#4).0: std::string::String) = move _2;
         StorageLive(_3);
         StorageLive(_4);
         StorageLive(_5);
         StorageLive(_6);
-        _20 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18});
+        _20 = copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18});
         _6 = &(((*_20) as variant#4).0: std::string::String);
         _5 = <String as Clone>::clone(move _6) -> [return: bb2, unwind unreachable];
     }
@@ -84,7 +84,7 @@ fn main::{closure#1}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:25:5: 25:18}>, _2
         _0 = CoroutineState::<(&str, String, &Location<'_>), ()>::Yielded(move _4);
         StorageDead(_3);
         StorageDead(_4);
-        _21 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18});
+        _21 = copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18});
         discriminant((*_21)) = 3;
         return;
     }
@@ -108,7 +108,7 @@ fn main::{closure#1}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:25:5: 25:18}>, _2
         _10 = &(*_11);
         StorageLive(_12);
         StorageLive(_13);
-        _22 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18});
+        _22 = copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18});
         _13 = &(((*_22) as variant#4).0: std::string::String);
         _12 = <String as Clone>::clone(move _13) -> [return: bb8, unwind unreachable];
     }
@@ -135,7 +135,7 @@ fn main::{closure#1}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:25:5: 25:18}>, _2
         StorageDead(_9);
         StorageDead(_11);
         StorageDead(_15);
-        _23 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18});
+        _23 = copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18});
         discriminant((*_23)) = 4;
         return;
     }
@@ -154,7 +154,7 @@ fn main::{closure#1}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:25:5: 25:18}>, _2
         StorageDead(_11);
         StorageDead(_8);
         _16 = const ();
-        _24 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18});
+        _24 = copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18});
         drop((((*_24) as variant#4).0: std::string::String)) -> [return: bb14, unwind unreachable];
     }
 
@@ -164,7 +164,7 @@ fn main::{closure#1}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:25:5: 25:18}>, _2
 
     bb15: {
         _0 = CoroutineState::<(&str, String, &Location<'_>), ()>::Complete(move _16);
-        _25 = deref_copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18});
+        _25 = copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:25:5: 25:18});
         discriminant((*_25)) = 1;
         return;
     }
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 3ea49265cee33..132dfd3d8178a 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
@@ -112,16 +112,16 @@
           StorageDead(_10);
           StorageLive(_14);
           _14 = const {ALLOC0: &&SmallStruct};
-          _31 = deref_copy (*_14);
+          _31 = copy (*_14);
           StorageLive(_11);
-          _32 = deref_copy (*_14);
+          _32 = copy (*_14);
 -         _11 = copy ((*_32).0: f32);
 +         _11 = const 9f32;
           StorageLive(_12);
-          _33 = deref_copy (*_14);
+          _33 = copy (*_14);
           _12 = copy ((*_33).1: std::option::Option<S>);
           StorageLive(_13);
-          _34 = deref_copy (*_14);
+          _34 = copy (*_14);
           _13 = copy ((*_34).2: &[f32]);
           StorageDead(_14);
           StorageLive(_15);
@@ -149,16 +149,16 @@
           StorageDead(_22);
           StorageLive(_26);
           _26 = const {ALLOC1: &&BigStruct};
-          _35 = deref_copy (*_26);
+          _35 = copy (*_26);
           StorageLive(_23);
-          _36 = deref_copy (*_26);
+          _36 = copy (*_26);
 -         _23 = copy ((*_36).0: f32);
 +         _23 = const 82f32;
           StorageLive(_24);
-          _37 = deref_copy (*_26);
+          _37 = copy (*_26);
           _24 = copy ((*_37).1: std::option::Option<S>);
           StorageLive(_25);
-          _38 = deref_copy (*_26);
+          _38 = copy (*_26);
           _25 = copy ((*_38).2: &[f32]);
           StorageDead(_26);
           StorageLive(_27);
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 78a0944975c86..0f3e6f0cb17f7 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
@@ -112,16 +112,16 @@
           StorageDead(_10);
           StorageLive(_14);
           _14 = const {ALLOC0: &&SmallStruct};
-          _31 = deref_copy (*_14);
+          _31 = copy (*_14);
           StorageLive(_11);
-          _32 = deref_copy (*_14);
+          _32 = copy (*_14);
 -         _11 = copy ((*_32).0: f32);
 +         _11 = const 9f32;
           StorageLive(_12);
-          _33 = deref_copy (*_14);
+          _33 = copy (*_14);
           _12 = copy ((*_33).1: std::option::Option<S>);
           StorageLive(_13);
-          _34 = deref_copy (*_14);
+          _34 = copy (*_14);
           _13 = copy ((*_34).2: &[f32]);
           StorageDead(_14);
           StorageLive(_15);
@@ -149,16 +149,16 @@
           StorageDead(_22);
           StorageLive(_26);
           _26 = const {ALLOC1: &&BigStruct};
-          _35 = deref_copy (*_26);
+          _35 = copy (*_26);
           StorageLive(_23);
-          _36 = deref_copy (*_26);
+          _36 = copy (*_26);
 -         _23 = copy ((*_36).0: f32);
 +         _23 = const 82f32;
           StorageLive(_24);
-          _37 = deref_copy (*_26);
+          _37 = copy (*_26);
           _24 = copy ((*_37).1: std::option::Option<S>);
           StorageLive(_25);
-          _38 = deref_copy (*_26);
+          _38 = copy (*_26);
           _25 = copy ((*_38).2: &[f32]);
           StorageDead(_26);
           StorageLive(_27);
diff --git a/tests/mir-opt/dead-store-elimination/ref.tuple.DeadStoreElimination-initial.diff b/tests/mir-opt/dead-store-elimination/ref.tuple.DeadStoreElimination-initial.diff
index 0b96569cbe4b1..3e677d13b89c1 100644
--- a/tests/mir-opt/dead-store-elimination/ref.tuple.DeadStoreElimination-initial.diff
+++ b/tests/mir-opt/dead-store-elimination/ref.tuple.DeadStoreElimination-initial.diff
@@ -13,10 +13,10 @@
   
       bb0: {
 -         StorageLive(_2);
--         _3 = deref_copy (_1.1: &Foo);
+-         _3 = copy (_1.1: &Foo);
 -         _2 = &((*_3).2: i32);
 +         // DBG: _2 = &((*_3).2: i32);
-          _4 = deref_copy (_1.1: &Foo);
+          _4 = copy (_1.1: &Foo);
           _0 = copy ((*_4).0: i32);
 -         StorageDead(_2);
           return;
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 fec318c1ab492..c8b516c14987b 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
@@ -76,7 +76,7 @@
           _4 = (move _5, move _6);
           StorageDead(_6);
           StorageDead(_5);
-          _34 = deref_copy (_4.0: &ViewportPercentageLength);
+          _34 = copy (_4.0: &ViewportPercentageLength);
           _11 = discriminant((*_34));
           switchInt(move _11) -> [0: bb2, 1: bb3, 2: bb4, 3: bb5, otherwise: bb12];
       }
@@ -92,35 +92,35 @@
       }
   
       bb2: {
-          _35 = deref_copy (_4.1: &ViewportPercentageLength);
+          _35 = copy (_4.1: &ViewportPercentageLength);
           _7 = discriminant((*_35));
           switchInt(move _7) -> [0: bb9, otherwise: bb1];
       }
   
       bb3: {
-          _36 = deref_copy (_4.1: &ViewportPercentageLength);
+          _36 = copy (_4.1: &ViewportPercentageLength);
           _8 = discriminant((*_36));
           switchInt(move _8) -> [1: bb8, otherwise: bb1];
       }
   
       bb4: {
-          _37 = deref_copy (_4.1: &ViewportPercentageLength);
+          _37 = copy (_4.1: &ViewportPercentageLength);
           _9 = discriminant((*_37));
           switchInt(move _9) -> [2: bb7, otherwise: bb1];
       }
   
       bb5: {
-          _38 = deref_copy (_4.1: &ViewportPercentageLength);
+          _38 = copy (_4.1: &ViewportPercentageLength);
           _10 = discriminant((*_38));
           switchInt(move _10) -> [3: bb6, otherwise: bb1];
       }
   
       bb6: {
           StorageLive(_27);
-          _39 = deref_copy (_4.0: &ViewportPercentageLength);
+          _39 = copy (_4.0: &ViewportPercentageLength);
           _27 = copy (((*_39) as Vmax).0: f32);
           StorageLive(_28);
-          _40 = deref_copy (_4.1: &ViewportPercentageLength);
+          _40 = copy (_4.1: &ViewportPercentageLength);
           _28 = copy (((*_40) as Vmax).0: f32);
           StorageLive(_29);
           StorageLive(_30);
@@ -139,10 +139,10 @@
   
       bb7: {
           StorageLive(_22);
-          _41 = deref_copy (_4.0: &ViewportPercentageLength);
+          _41 = copy (_4.0: &ViewportPercentageLength);
           _22 = copy (((*_41) as Vmin).0: f32);
           StorageLive(_23);
-          _42 = deref_copy (_4.1: &ViewportPercentageLength);
+          _42 = copy (_4.1: &ViewportPercentageLength);
           _23 = copy (((*_42) as Vmin).0: f32);
           StorageLive(_24);
           StorageLive(_25);
@@ -161,10 +161,10 @@
   
       bb8: {
           StorageLive(_17);
-          _43 = deref_copy (_4.0: &ViewportPercentageLength);
+          _43 = copy (_4.0: &ViewportPercentageLength);
           _17 = copy (((*_43) as Vh).0: f32);
           StorageLive(_18);
-          _44 = deref_copy (_4.1: &ViewportPercentageLength);
+          _44 = copy (_4.1: &ViewportPercentageLength);
           _18 = copy (((*_44) as Vh).0: f32);
           StorageLive(_19);
           StorageLive(_20);
@@ -183,10 +183,10 @@
   
       bb9: {
           StorageLive(_12);
-          _45 = deref_copy (_4.0: &ViewportPercentageLength);
+          _45 = copy (_4.0: &ViewportPercentageLength);
           _12 = copy (((*_45) as Vw).0: f32);
           StorageLive(_13);
-          _46 = deref_copy (_4.1: &ViewportPercentageLength);
+          _46 = copy (_4.1: &ViewportPercentageLength);
           _13 = copy (((*_46) as Vw).0: f32);
           StorageLive(_14);
           StorageLive(_15);
diff --git a/tests/mir-opt/early_otherwise_branch_soundness.no_downcast.EarlyOtherwiseBranch.diff b/tests/mir-opt/early_otherwise_branch_soundness.no_downcast.EarlyOtherwiseBranch.diff
index 6a4c947b8826e..ab81f0a67e4eb 100644
--- a/tests/mir-opt/early_otherwise_branch_soundness.no_downcast.EarlyOtherwiseBranch.diff
+++ b/tests/mir-opt/early_otherwise_branch_soundness.no_downcast.EarlyOtherwiseBranch.diff
@@ -16,7 +16,7 @@
       }
   
       bb1: {
-          _4 = deref_copy (((*_1) as Some).0: &E<'_>);
+          _4 = copy (((*_1) as Some).0: &E<'_>);
           _2 = discriminant((*_4));
           switchInt(move _2) -> [1: bb2, 0: bb3, otherwise: bb5];
       }
diff --git a/tests/mir-opt/gvn_copy_aggregate.all_copy_2.GVN.diff b/tests/mir-opt/gvn_copy_aggregate.all_copy_2.GVN.diff
index 452d8a9332036..eed8cb7d62e70 100644
--- a/tests/mir-opt/gvn_copy_aggregate.all_copy_2.GVN.diff
+++ b/tests/mir-opt/gvn_copy_aggregate.all_copy_2.GVN.diff
@@ -25,15 +25,14 @@
   
       bb0: {
 -         StorageLive(_2);
--         _8 = deref_copy (*_1);
 +         nop;
-+         _8 = copy (*_1);
+          _8 = copy (*_1);
           _2 = copy ((*_8).0: i32);
 -         StorageLive(_3);
--         _9 = deref_copy (*_1);
+-         _9 = copy (*_1);
 -         _3 = copy ((*_9).1: u64);
 -         StorageLive(_4);
--         _10 = deref_copy (*_1);
+-         _10 = copy (*_1);
 -         _4 = copy ((*_10).2: [i8; 3]);
 +         nop;
 +         _9 = copy _8;
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 0acb33febe52b..09b7efd632e35 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
@@ -126,7 +126,7 @@
           StorageLive(_8);
           _8 = move _4;
           StorageLive(_9);
-          _10 = deref_copy (_1.1: &mut std::task::Context<'_>);
+          _10 = copy (_1.1: &mut std::task::Context<'_>);
           _9 = &mut (*_10);
 -         _7 = <{async fn body of ActionPermit<'_, T>::perform()} as Future>::poll(move _8, move _9) -> [return: bb3, unwind unreachable];
 +         StorageLive(_16);
@@ -141,7 +141,7 @@
 +         StorageLive(_37);
 +         StorageLive(_38);
 +         StorageLive(_39);
-+         _32 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         _32 = copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
 +         _31 = discriminant((*_32));
 +         switchInt(move _31) -> [0: bb3, 1: bb10, 3: bb9, otherwise: bb5];
       }
@@ -177,8 +177,8 @@
       }
   
 +     bb3: {
-+         _33 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
-+         _34 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         _33 = copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         _34 = copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
 +         (((*_33) as variant#3).0: ActionPermit<'_, T>) = move ((*_34).0: ActionPermit<'_, T>);
 +         StorageLive(_12);
 +         StorageLive(_13);
@@ -191,7 +191,7 @@
 +         StorageDead(_14);
 +         _12 = move _13;
 +         StorageDead(_13);
-+         _35 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         _35 = copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
 +         (((*_35) as variant#3).1: std::future::Ready<()>) = move _12;
 +         goto -> bb4;
 +     }
@@ -204,7 +204,7 @@
 +         StorageLive(_19);
 +         StorageLive(_20);
 +         StorageLive(_21);
-+         _36 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         _36 = copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
 +         _21 = &mut (((*_36) as variant#3).1: std::future::Ready<()>);
 +         _20 = &mut (*_21);
 +         _19 = Pin::<&mut std::future::Ready<()>> { pointer: copy _20 };
@@ -248,7 +248,7 @@
 +         StorageDead(_12);
 +         StorageDead(_28);
 +         StorageDead(_29);
-+         _37 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         _37 = copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
 +         discriminant((*_37)) = 3;
 +         goto -> bb2;
 +     }
@@ -263,13 +263,13 @@
 +         StorageDead(_18);
 +         StorageDead(_17);
 +         StorageDead(_12);
-+         _38 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         _38 = copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
 +         drop((((*_38) as variant#3).0: ActionPermit<'_, T>)) -> [return: bb8, unwind unreachable];
 +     }
 + 
 +     bb8: {
 +         _7 = Poll::<()>::Ready(move _30);
-+         _39 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         _39 = copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
 +         discriminant((*_39)) = 1;
 +         goto -> bb2;
 +     }
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 98ee46c29b1be..b630753ed0157 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
@@ -128,7 +128,7 @@
           StorageLive(_8);
           _8 = move _4;
           StorageLive(_9);
-          _10 = deref_copy (_1.1: &mut std::task::Context<'_>);
+          _10 = copy (_1.1: &mut std::task::Context<'_>);
           _9 = &mut (*_10);
 -         _7 = <{async fn body of ActionPermit<'_, T>::perform()} as Future>::poll(move _8, move _9) -> [return: bb3, unwind: bb5];
 +         StorageLive(_16);
@@ -145,7 +145,7 @@
 +         StorageLive(_39);
 +         StorageLive(_40);
 +         StorageLive(_41);
-+         _32 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         _32 = copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
 +         _31 = discriminant((*_32));
 +         switchInt(move _31) -> [0: bb5, 1: bb15, 2: bb14, 3: bb13, otherwise: bb7];
       }
@@ -194,8 +194,8 @@
 -         StorageDead(_2);
 -         return;
 +     bb5: {
-+         _33 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
-+         _34 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         _33 = copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         _34 = copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
 +         (((*_33) as variant#3).0: ActionPermit<'_, T>) = move ((*_34).0: ActionPermit<'_, T>);
 +         StorageLive(_12);
 +         StorageLive(_13);
@@ -208,7 +208,7 @@
 +         StorageDead(_14);
 +         _12 = move _13;
 +         StorageDead(_13);
-+         _35 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         _35 = copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
 +         (((*_35) as variant#3).1: std::future::Ready<()>) = move _12;
 +         goto -> bb6;
       }
@@ -221,7 +221,7 @@
 +         StorageLive(_19);
 +         StorageLive(_20);
 +         StorageLive(_21);
-+         _36 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         _36 = copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
 +         _21 = &mut (((*_36) as variant#3).1: std::future::Ready<()>);
 +         _20 = &mut (*_21);
 +         _19 = Pin::<&mut std::future::Ready<()>> { pointer: copy _20 };
@@ -267,7 +267,7 @@
 +         StorageDead(_12);
 +         StorageDead(_28);
 +         StorageDead(_29);
-+         _37 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         _37 = copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
 +         discriminant((*_37)) = 3;
 +         goto -> bb4;
 +     }
@@ -282,13 +282,13 @@
 +         StorageDead(_18);
 +         StorageDead(_17);
 +         StorageDead(_12);
-+         _38 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         _38 = copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
 +         drop((((*_38) as variant#3).0: ActionPermit<'_, T>)) -> [return: bb10, unwind: bb12];
 +     }
 + 
 +     bb10: {
 +         _7 = Poll::<()>::Ready(move _30);
-+         _39 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         _39 = copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
 +         discriminant((*_39)) = 1;
 +         goto -> bb4;
 +     }
@@ -301,12 +301,12 @@
 +         StorageDead(_18);
 +         StorageDead(_17);
 +         StorageDead(_12);
-+         _40 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         _40 = copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
 +         drop((((*_40) as variant#3).0: ActionPermit<'_, T>)) -> [return: bb12, unwind terminate(cleanup)];
 +     }
 + 
 +     bb12 (cleanup): {
-+         _41 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
++         _41 = copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
 +         discriminant((*_41)) = 2;
 +         goto -> bb2;
 +     }
diff --git a/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-abort.diff b/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-abort.diff
index 993857f225a81..269af438e37ef 100644
--- a/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-abort.diff
+++ b/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-abort.diff
@@ -16,17 +16,15 @@
   
       bb0: {
 -         StorageLive(_2);
--         _6 = deref_copy (*_1);
 +         nop;
-+         _6 = copy (*_1);
+          _6 = copy (*_1);
           _2 = copy (*_6);
           _3 = unknown() -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
           StorageLive(_4);
--         _7 = deref_copy (*_1);
-+         _7 = copy (*_1);
+          _7 = copy (*_1);
           _4 = copy (*_7);
           StorageLive(_5);
           _5 = copy _2;
diff --git a/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-unwind.diff b/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-unwind.diff
index d81bfa9310bc1..9ce17342a445c 100644
--- a/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-unwind.diff
+++ b/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-unwind.diff
@@ -16,17 +16,15 @@
   
       bb0: {
 -         StorageLive(_2);
--         _6 = deref_copy (*_1);
 +         nop;
-+         _6 = copy (*_1);
+          _6 = copy (*_1);
           _2 = copy (*_6);
           _3 = unknown() -> [return: bb1, unwind continue];
       }
   
       bb1: {
           StorageLive(_4);
--         _7 = deref_copy (*_1);
-+         _7 = copy (*_1);
+          _7 = copy (*_1);
           _4 = copy (*_7);
           StorageLive(_5);
           _5 = copy _2;
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 da005d552e2bf..4861abead2f32 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
@@ -8,7 +8,7 @@ fn box_to_raw_mut(_1: &mut Box<i32>) -> *mut i32 {
 
     bb0: {
         Retag([fn entry] _1);
-        _2 = deref_copy (*_1);
+        _2 = copy (*_1);
         _3 = copy ((_2.0: std::ptr::Unique<i32>).0: std::ptr::NonNull<i32>) as *const i32 (Transmute);
         _0 = &raw mut (*_3);
         Retag([raw] _0);
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 da005d552e2bf..4861abead2f32 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
@@ -8,7 +8,7 @@ fn box_to_raw_mut(_1: &mut Box<i32>) -> *mut i32 {
 
     bb0: {
         Retag([fn entry] _1);
-        _2 = deref_copy (*_1);
+        _2 = copy (*_1);
         _3 = copy ((_2.0: std::ptr::Unique<i32>).0: std::ptr::NonNull<i32>) as *const i32 (Transmute);
         _0 = &raw mut (*_3);
         Retag([raw] _0);
diff --git a/tests/mir-opt/sroa/lifetimes.foo.ScalarReplacementOfAggregates.diff b/tests/mir-opt/sroa/lifetimes.foo.ScalarReplacementOfAggregates.diff
index 0d5fcf9ef1432..056dc4c42c11f 100644
--- a/tests/mir-opt/sroa/lifetimes.foo.ScalarReplacementOfAggregates.diff
+++ b/tests/mir-opt/sroa/lifetimes.foo.ScalarReplacementOfAggregates.diff
@@ -117,8 +117,8 @@
           StorageLive(_15);
           StorageLive(_16);
           StorageLive(_17);
--         _26 = deref_copy (_12.0: &std::boxed::Box<dyn std::fmt::Display>);
-+         _26 = deref_copy _34;
+-         _26 = copy (_12.0: &std::boxed::Box<dyn std::fmt::Display>);
++         _26 = copy _34;
           _17 = &(*_26);
           _16 = core::fmt::rt::Argument::<'_>::new_display::<Box<dyn std::fmt::Display>>(move _17) -> [return: bb3, unwind unreachable];
       }
@@ -127,8 +127,8 @@
           StorageDead(_17);
           StorageLive(_18);
           StorageLive(_19);
--         _27 = deref_copy (_12.1: &u32);
-+         _27 = deref_copy _35;
+-         _27 = copy (_12.1: &u32);
++         _27 = copy _35;
           _19 = &(*_27);
           _18 = core::fmt::rt::Argument::<'_>::new_display::<u32>(move _19) -> [return: bb4, unwind unreachable];
       }
diff --git a/tests/ui/rustc_public-ir-print/async-closure.stdout b/tests/ui/rustc_public-ir-print/async-closure.stdout
index 5113dc5048b93..550f0512569d7 100644
--- a/tests/ui/rustc_public-ir-print/async-closure.stdout
+++ b/tests/ui/rustc_public-ir-print/async-closure.stdout
@@ -28,7 +28,7 @@ fn foo::{closure#0}(_1: &{async closure@$DIR/async-closure.rs:9:13: 9:21}) -> {a
     debug y => (*((*_1).0: &i32));
     bb0: {
         StorageLive(_2);
-        _3 = CopyForDeref(((*_1).0: &i32));
+        _3 = ((*_1).0: &i32);
         _2 = &(*_3);
         _0 = {coroutine@$DIR/async-closure.rs:9:22: 11:6}(move _2);
         StorageDead(_2);
@@ -48,19 +48,19 @@ fn foo::{closure#0}::{closure#0}(_1: Pin<&mut {async closure body@$DIR/async-clo
     debug y => (*((*(_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6})).0: &i32));
     debug y => _3;
     bb0: {
-        _7 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
+        _7 = (_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6});
         _6 = discriminant((*_7));
         switchInt(move _6) -> [0: bb1, 1: bb2, otherwise: bb3];
     }
     bb1: {
         StorageLive(_3);
-        _8 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
-        _4 = CopyForDeref(((*_8).0: &i32));
+        _8 = (_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6});
+        _4 = ((*_8).0: &i32);
         _3 = (*_4);
         _5 = ();
         StorageDead(_3);
         _0 = std::task::Poll::Ready(move _5);
-        _9 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
+        _9 = (_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6});
         discriminant((*_9)) = 1;
         return;
     }
@@ -84,19 +84,19 @@ fn foo::{closure#0}::{synthetic#0}(_1: Pin<&mut {async closure body@$DIR/async-c
     debug y => (*((*(_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6})).0: &i32));
     debug y => _3;
     bb0: {
-        _7 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
+        _7 = (_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6});
         _6 = discriminant((*_7));
         switchInt(move _6) -> [0: bb1, 1: bb2, otherwise: bb3];
     }
     bb1: {
         StorageLive(_3);
-        _8 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
-        _4 = CopyForDeref(((*_8).0: &i32));
+        _8 = (_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6});
+        _4 = ((*_8).0: &i32);
         _3 = (*_4);
         _5 = ();
         StorageDead(_3);
         _0 = std::task::Poll::Ready(move _5);
-        _9 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
+        _9 = (_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6});
         discriminant((*_9)) = 1;
         return;
     }

From 1bd490113ca22ecd3d817c75f4a4f796f2ba1eb8 Mon Sep 17 00:00:00 2001
From: beepster4096 <19316085+beepster4096@users.noreply.github.com>
Date: Wed, 13 Aug 2025 15:08:08 -0700
Subject: [PATCH 1866/1889] slightly less trivial blessings

some optimization is behaving slightly differently on box derefs after this change, but the difference is irrelevant
---
 ...ng_operand.test.GVN.32bit.panic-abort.diff | 119 +++++++++---------
 ...g_operand.test.GVN.32bit.panic-unwind.diff |  29 +++--
 ...ng_operand.test.GVN.64bit.panic-abort.diff | 119 +++++++++---------
 ...g_operand.test.GVN.64bit.panic-unwind.diff |  29 +++--
 ...ric_rust_call.call.Inline.panic-abort.diff |  10 +-
 ...ic_rust_call.call.Inline.panic-unwind.diff |  10 +-
 ...inline_box_fn.call.Inline.panic-abort.diff |  10 +-
 ...nline_box_fn.call.Inline.panic-unwind.diff |  10 +-
 ...67_inline_as_ref_as_mut.b.Inline.after.mir |  10 +-
 ...67_inline_as_ref_as_mut.d.Inline.after.mir |  10 +-
 10 files changed, 176 insertions(+), 180 deletions(-)

diff --git a/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.32bit.panic-abort.diff b/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.32bit.panic-abort.diff
index f203b80e4776c..bb10fc8ac642d 100644
--- a/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.32bit.panic-abort.diff
+++ b/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.32bit.panic-abort.diff
@@ -8,14 +8,14 @@
       let _3: std::boxed::Box<()>;
       let mut _6: *const ();
       let mut _8: *const [()];
-      let mut _9: std::boxed::Box<()>;
-      let mut _10: *const ();
-      let mut _23: usize;
+      let mut _9: *const ();
+      let mut _22: usize;
+      let mut _23: std::ptr::NonNull<()>;
       scope 1 {
           debug vp_ctx => _1;
           let _4: *const ();
           scope 2 {
-              debug slf => _10;
+              debug slf => _9;
               let _5: *const [()];
               scope 3 {
                   debug bytes => _5;
@@ -33,21 +33,21 @@
           }
       }
       scope 5 (inlined Box::<()>::new) {
+          let mut _10: usize;
           let mut _11: usize;
-          let mut _12: usize;
-          let mut _13: *mut u8;
+          let mut _12: *mut u8;
           scope 6 (inlined alloc::alloc::exchange_malloc) {
-              let _14: std::alloc::Layout;
-              let mut _15: std::result::Result<std::ptr::NonNull<[u8]>, std::alloc::AllocError>;
-              let mut _16: isize;
-              let mut _18: !;
+              let _13: std::alloc::Layout;
+              let mut _14: std::result::Result<std::ptr::NonNull<[u8]>, std::alloc::AllocError>;
+              let mut _15: isize;
+              let mut _17: !;
               scope 7 {
-                  let _17: std::ptr::NonNull<[u8]>;
+                  let _16: std::ptr::NonNull<[u8]>;
                   scope 8 {
                       scope 11 (inlined NonNull::<[u8]>::as_mut_ptr) {
                           scope 12 (inlined NonNull::<[u8]>::as_non_null_ptr) {
                               scope 13 (inlined NonNull::<[u8]>::cast::<u8>) {
-                                  let mut _22: *mut [u8];
+                                  let mut _21: *mut [u8];
                                   scope 14 (inlined NonNull::<[u8]>::as_ptr) {
                                   }
                               }
@@ -60,9 +60,9 @@
                   }
               }
               scope 9 (inlined #[track_caller] Layout::from_size_align_unchecked) {
-                  let mut _19: bool;
-                  let _20: ();
-                  let mut _21: std::ptr::Alignment;
+                  let mut _18: bool;
+                  let _19: ();
+                  let mut _20: std::ptr::Alignment;
               }
           }
       }
@@ -71,19 +71,19 @@
           StorageLive(_1);
           StorageLive(_2);
           StorageLive(_3);
+          StorageLive(_10);
           StorageLive(_11);
           StorageLive(_12);
+-         _10 = SizeOf(());
+-         _11 = AlignOf(());
++         _10 = const 0_usize;
++         _11 = const 1_usize;
           StorageLive(_13);
--         _11 = SizeOf(());
--         _12 = AlignOf(());
-+         _11 = const 0_usize;
-+         _12 = const 1_usize;
-          StorageLive(_14);
+          StorageLive(_15);
           StorageLive(_16);
-          StorageLive(_17);
-          StorageLive(_19);
-          _19 = const false;
--         switchInt(move _19) -> [0: bb6, otherwise: bb5];
+          StorageLive(_18);
+          _18 = const false;
+-         switchInt(move _18) -> [0: bb6, otherwise: bb5];
 +         switchInt(const false) -> [0: bb6, otherwise: bb5];
       }
   
@@ -98,48 +98,47 @@
       }
   
       bb3: {
--         _18 = handle_alloc_error(move _14) -> unwind unreachable;
-+         _18 = handle_alloc_error(const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}) -> unwind unreachable;
+-         _17 = handle_alloc_error(move _13) -> unwind unreachable;
++         _17 = handle_alloc_error(const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}) -> unwind unreachable;
       }
   
       bb4: {
-          _17 = copy ((_15 as Ok).0: std::ptr::NonNull<[u8]>);
-          StorageLive(_22);
-          _22 = copy _17 as *mut [u8] (Transmute);
-          _13 = copy _22 as *mut u8 (PtrToPtr);
-          StorageDead(_22);
-          StorageDead(_15);
-          StorageDead(_17);
-          StorageDead(_16);
+          _16 = copy ((_14 as Ok).0: std::ptr::NonNull<[u8]>);
+          StorageLive(_21);
+          _21 = copy _16 as *mut [u8] (Transmute);
+          _12 = copy _21 as *mut u8 (PtrToPtr);
+          StorageDead(_21);
           StorageDead(_14);
-          _3 = ShallowInitBox(copy _13, ());
+          StorageDead(_16);
+          StorageDead(_15);
           StorageDead(_13);
+          _3 = ShallowInitBox(copy _12, ());
           StorageDead(_12);
           StorageDead(_11);
+          StorageDead(_10);
           _2 = &_3;
           _1 = copy _2;
           StorageDead(_2);
           StorageLive(_4);
--         _9 = deref_copy _3;
-+         _9 = copy _3;
-          _10 = copy ((_9.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *const () (Transmute);
-          _4 = copy _10;
+          _23 = copy ((_3.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>);
+          _9 = copy _23 as *const () (Transmute);
+          _4 = copy _9;
 -         StorageLive(_5);
 +         nop;
           StorageLive(_6);
 -         _6 = copy _4;
-+         _6 = copy _10;
-          StorageLive(_23);
-          _23 = const 1_usize;
--         _5 = *const [()] from (copy _6, copy _23);
-+         _5 = *const [()] from (copy _10, const 1_usize);
-          StorageDead(_23);
++         _6 = copy _9;
+          StorageLive(_22);
+          _22 = const 1_usize;
+-         _5 = *const [()] from (copy _6, copy _22);
++         _5 = *const [()] from (copy _9, const 1_usize);
+          StorageDead(_22);
           StorageDead(_6);
           StorageLive(_7);
           StorageLive(_8);
           _8 = copy _5;
 -         _7 = copy _8 as *mut () (PtrToPtr);
-+         _7 = copy ((_9.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *mut () (Transmute);
++         _7 = copy _23 as *mut () (Transmute);
           StorageDead(_8);
           StorageDead(_7);
 -         StorageDead(_5);
@@ -149,26 +148,26 @@
       }
   
       bb5: {
--         _20 = Layout::from_size_align_unchecked::precondition_check(copy _11, copy _12) -> [return: bb6, unwind unreachable];
-+         _20 = Layout::from_size_align_unchecked::precondition_check(const 0_usize, const 1_usize) -> [return: bb6, unwind unreachable];
+-         _19 = Layout::from_size_align_unchecked::precondition_check(copy _10, copy _11) -> [return: bb6, unwind unreachable];
++         _19 = Layout::from_size_align_unchecked::precondition_check(const 0_usize, const 1_usize) -> [return: bb6, unwind unreachable];
       }
   
       bb6: {
-          StorageDead(_19);
-          StorageLive(_21);
--         _21 = copy _12 as std::ptr::Alignment (Transmute);
--         _14 = Layout { size: copy _11, align: move _21 };
-+         _21 = const std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0);
-+         _14 = const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }};
-          StorageDead(_21);
-          StorageLive(_15);
--         _15 = std::alloc::Global::alloc_impl(const alloc::alloc::exchange_malloc::promoted[0], copy _14, const false) -> [return: bb7, unwind unreachable];
-+         _15 = std::alloc::Global::alloc_impl(const alloc::alloc::exchange_malloc::promoted[0], const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}, const false) -> [return: bb7, unwind unreachable];
+          StorageDead(_18);
+          StorageLive(_20);
+-         _20 = copy _11 as std::ptr::Alignment (Transmute);
+-         _13 = Layout { size: copy _10, align: move _20 };
++         _20 = const std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0);
++         _13 = const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }};
+          StorageDead(_20);
+          StorageLive(_14);
+-         _14 = std::alloc::Global::alloc_impl(const alloc::alloc::exchange_malloc::promoted[0], copy _13, const false) -> [return: bb7, unwind unreachable];
++         _14 = std::alloc::Global::alloc_impl(const alloc::alloc::exchange_malloc::promoted[0], const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}, const false) -> [return: bb7, unwind unreachable];
       }
   
       bb7: {
-          _16 = discriminant(_15);
-          switchInt(move _16) -> [0: bb4, 1: bb3, otherwise: bb2];
+          _15 = discriminant(_14);
+          switchInt(move _15) -> [0: bb4, 1: bb3, otherwise: bb2];
       }
 + }
 + 
diff --git a/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.32bit.panic-unwind.diff b/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.32bit.panic-unwind.diff
index b2085afb71379..88754cb02776c 100644
--- a/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.32bit.panic-unwind.diff
+++ b/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.32bit.panic-unwind.diff
@@ -8,14 +8,14 @@
       let _3: std::boxed::Box<()>;
       let mut _6: *const ();
       let mut _8: *const [()];
-      let mut _9: std::boxed::Box<()>;
-      let mut _10: *const ();
-      let mut _11: usize;
+      let mut _9: *const ();
+      let mut _10: usize;
+      let mut _11: std::ptr::NonNull<()>;
       scope 1 {
           debug vp_ctx => _1;
           let _4: *const ();
           scope 2 {
-              debug slf => _10;
+              debug slf => _9;
               let _5: *const [()];
               scope 3 {
                   debug bytes => _5;
@@ -45,26 +45,25 @@
           _1 = copy _2;
           StorageDead(_2);
           StorageLive(_4);
--         _9 = deref_copy _3;
-+         _9 = copy _3;
-          _10 = copy ((_9.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *const () (Transmute);
-          _4 = copy _10;
+          _11 = copy ((_3.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>);
+          _9 = copy _11 as *const () (Transmute);
+          _4 = copy _9;
 -         StorageLive(_5);
 +         nop;
           StorageLive(_6);
 -         _6 = copy _4;
-+         _6 = copy _10;
-          StorageLive(_11);
-          _11 = const 1_usize;
--         _5 = *const [()] from (copy _6, copy _11);
-+         _5 = *const [()] from (copy _10, const 1_usize);
-          StorageDead(_11);
++         _6 = copy _9;
+          StorageLive(_10);
+          _10 = const 1_usize;
+-         _5 = *const [()] from (copy _6, copy _10);
++         _5 = *const [()] from (copy _9, const 1_usize);
+          StorageDead(_10);
           StorageDead(_6);
           StorageLive(_7);
           StorageLive(_8);
           _8 = copy _5;
 -         _7 = copy _8 as *mut () (PtrToPtr);
-+         _7 = copy ((_9.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *mut () (Transmute);
++         _7 = copy _11 as *mut () (Transmute);
           StorageDead(_8);
           StorageDead(_7);
 -         StorageDead(_5);
diff --git a/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-abort.diff b/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-abort.diff
index f072eb6ef8bf6..97b7c9a1d5584 100644
--- a/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-abort.diff
+++ b/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-abort.diff
@@ -8,14 +8,14 @@
       let _3: std::boxed::Box<()>;
       let mut _6: *const ();
       let mut _8: *const [()];
-      let mut _9: std::boxed::Box<()>;
-      let mut _10: *const ();
-      let mut _23: usize;
+      let mut _9: *const ();
+      let mut _22: usize;
+      let mut _23: std::ptr::NonNull<()>;
       scope 1 {
           debug vp_ctx => _1;
           let _4: *const ();
           scope 2 {
-              debug slf => _10;
+              debug slf => _9;
               let _5: *const [()];
               scope 3 {
                   debug bytes => _5;
@@ -33,21 +33,21 @@
           }
       }
       scope 5 (inlined Box::<()>::new) {
+          let mut _10: usize;
           let mut _11: usize;
-          let mut _12: usize;
-          let mut _13: *mut u8;
+          let mut _12: *mut u8;
           scope 6 (inlined alloc::alloc::exchange_malloc) {
-              let _14: std::alloc::Layout;
-              let mut _15: std::result::Result<std::ptr::NonNull<[u8]>, std::alloc::AllocError>;
-              let mut _16: isize;
-              let mut _18: !;
+              let _13: std::alloc::Layout;
+              let mut _14: std::result::Result<std::ptr::NonNull<[u8]>, std::alloc::AllocError>;
+              let mut _15: isize;
+              let mut _17: !;
               scope 7 {
-                  let _17: std::ptr::NonNull<[u8]>;
+                  let _16: std::ptr::NonNull<[u8]>;
                   scope 8 {
                       scope 11 (inlined NonNull::<[u8]>::as_mut_ptr) {
                           scope 12 (inlined NonNull::<[u8]>::as_non_null_ptr) {
                               scope 13 (inlined NonNull::<[u8]>::cast::<u8>) {
-                                  let mut _22: *mut [u8];
+                                  let mut _21: *mut [u8];
                                   scope 14 (inlined NonNull::<[u8]>::as_ptr) {
                                   }
                               }
@@ -60,9 +60,9 @@
                   }
               }
               scope 9 (inlined #[track_caller] Layout::from_size_align_unchecked) {
-                  let mut _19: bool;
-                  let _20: ();
-                  let mut _21: std::ptr::Alignment;
+                  let mut _18: bool;
+                  let _19: ();
+                  let mut _20: std::ptr::Alignment;
               }
           }
       }
@@ -71,19 +71,19 @@
           StorageLive(_1);
           StorageLive(_2);
           StorageLive(_3);
+          StorageLive(_10);
           StorageLive(_11);
           StorageLive(_12);
+-         _10 = SizeOf(());
+-         _11 = AlignOf(());
++         _10 = const 0_usize;
++         _11 = const 1_usize;
           StorageLive(_13);
--         _11 = SizeOf(());
--         _12 = AlignOf(());
-+         _11 = const 0_usize;
-+         _12 = const 1_usize;
-          StorageLive(_14);
+          StorageLive(_15);
           StorageLive(_16);
-          StorageLive(_17);
-          StorageLive(_19);
-          _19 = const false;
--         switchInt(move _19) -> [0: bb6, otherwise: bb5];
+          StorageLive(_18);
+          _18 = const false;
+-         switchInt(move _18) -> [0: bb6, otherwise: bb5];
 +         switchInt(const false) -> [0: bb6, otherwise: bb5];
       }
   
@@ -98,48 +98,47 @@
       }
   
       bb3: {
--         _18 = handle_alloc_error(move _14) -> unwind unreachable;
-+         _18 = handle_alloc_error(const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}) -> unwind unreachable;
+-         _17 = handle_alloc_error(move _13) -> unwind unreachable;
++         _17 = handle_alloc_error(const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}) -> unwind unreachable;
       }
   
       bb4: {
-          _17 = copy ((_15 as Ok).0: std::ptr::NonNull<[u8]>);
-          StorageLive(_22);
-          _22 = copy _17 as *mut [u8] (Transmute);
-          _13 = copy _22 as *mut u8 (PtrToPtr);
-          StorageDead(_22);
-          StorageDead(_15);
-          StorageDead(_17);
-          StorageDead(_16);
+          _16 = copy ((_14 as Ok).0: std::ptr::NonNull<[u8]>);
+          StorageLive(_21);
+          _21 = copy _16 as *mut [u8] (Transmute);
+          _12 = copy _21 as *mut u8 (PtrToPtr);
+          StorageDead(_21);
           StorageDead(_14);
-          _3 = ShallowInitBox(copy _13, ());
+          StorageDead(_16);
+          StorageDead(_15);
           StorageDead(_13);
+          _3 = ShallowInitBox(copy _12, ());
           StorageDead(_12);
           StorageDead(_11);
+          StorageDead(_10);
           _2 = &_3;
           _1 = copy _2;
           StorageDead(_2);
           StorageLive(_4);
--         _9 = deref_copy _3;
-+         _9 = copy _3;
-          _10 = copy ((_9.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *const () (Transmute);
-          _4 = copy _10;
+          _23 = copy ((_3.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>);
+          _9 = copy _23 as *const () (Transmute);
+          _4 = copy _9;
 -         StorageLive(_5);
 +         nop;
           StorageLive(_6);
 -         _6 = copy _4;
-+         _6 = copy _10;
-          StorageLive(_23);
-          _23 = const 1_usize;
--         _5 = *const [()] from (copy _6, copy _23);
-+         _5 = *const [()] from (copy _10, const 1_usize);
-          StorageDead(_23);
++         _6 = copy _9;
+          StorageLive(_22);
+          _22 = const 1_usize;
+-         _5 = *const [()] from (copy _6, copy _22);
++         _5 = *const [()] from (copy _9, const 1_usize);
+          StorageDead(_22);
           StorageDead(_6);
           StorageLive(_7);
           StorageLive(_8);
           _8 = copy _5;
 -         _7 = copy _8 as *mut () (PtrToPtr);
-+         _7 = copy ((_9.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *mut () (Transmute);
++         _7 = copy _23 as *mut () (Transmute);
           StorageDead(_8);
           StorageDead(_7);
 -         StorageDead(_5);
@@ -149,26 +148,26 @@
       }
   
       bb5: {
--         _20 = Layout::from_size_align_unchecked::precondition_check(copy _11, copy _12) -> [return: bb6, unwind unreachable];
-+         _20 = Layout::from_size_align_unchecked::precondition_check(const 0_usize, const 1_usize) -> [return: bb6, unwind unreachable];
+-         _19 = Layout::from_size_align_unchecked::precondition_check(copy _10, copy _11) -> [return: bb6, unwind unreachable];
++         _19 = Layout::from_size_align_unchecked::precondition_check(const 0_usize, const 1_usize) -> [return: bb6, unwind unreachable];
       }
   
       bb6: {
-          StorageDead(_19);
-          StorageLive(_21);
--         _21 = copy _12 as std::ptr::Alignment (Transmute);
--         _14 = Layout { size: copy _11, align: move _21 };
-+         _21 = const std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0);
-+         _14 = const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }};
-          StorageDead(_21);
-          StorageLive(_15);
--         _15 = std::alloc::Global::alloc_impl(const alloc::alloc::exchange_malloc::promoted[0], copy _14, const false) -> [return: bb7, unwind unreachable];
-+         _15 = std::alloc::Global::alloc_impl(const alloc::alloc::exchange_malloc::promoted[0], const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}, const false) -> [return: bb7, unwind unreachable];
+          StorageDead(_18);
+          StorageLive(_20);
+-         _20 = copy _11 as std::ptr::Alignment (Transmute);
+-         _13 = Layout { size: copy _10, align: move _20 };
++         _20 = const std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0);
++         _13 = const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }};
+          StorageDead(_20);
+          StorageLive(_14);
+-         _14 = std::alloc::Global::alloc_impl(const alloc::alloc::exchange_malloc::promoted[0], copy _13, const false) -> [return: bb7, unwind unreachable];
++         _14 = std::alloc::Global::alloc_impl(const alloc::alloc::exchange_malloc::promoted[0], const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}, const false) -> [return: bb7, unwind unreachable];
       }
   
       bb7: {
-          _16 = discriminant(_15);
-          switchInt(move _16) -> [0: bb4, 1: bb3, otherwise: bb2];
+          _15 = discriminant(_14);
+          switchInt(move _15) -> [0: bb4, 1: bb3, otherwise: bb2];
       }
 + }
 + 
diff --git a/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-unwind.diff b/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-unwind.diff
index b2085afb71379..88754cb02776c 100644
--- a/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-unwind.diff
+++ b/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-unwind.diff
@@ -8,14 +8,14 @@
       let _3: std::boxed::Box<()>;
       let mut _6: *const ();
       let mut _8: *const [()];
-      let mut _9: std::boxed::Box<()>;
-      let mut _10: *const ();
-      let mut _11: usize;
+      let mut _9: *const ();
+      let mut _10: usize;
+      let mut _11: std::ptr::NonNull<()>;
       scope 1 {
           debug vp_ctx => _1;
           let _4: *const ();
           scope 2 {
-              debug slf => _10;
+              debug slf => _9;
               let _5: *const [()];
               scope 3 {
                   debug bytes => _5;
@@ -45,26 +45,25 @@
           _1 = copy _2;
           StorageDead(_2);
           StorageLive(_4);
--         _9 = deref_copy _3;
-+         _9 = copy _3;
-          _10 = copy ((_9.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *const () (Transmute);
-          _4 = copy _10;
+          _11 = copy ((_3.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>);
+          _9 = copy _11 as *const () (Transmute);
+          _4 = copy _9;
 -         StorageLive(_5);
 +         nop;
           StorageLive(_6);
 -         _6 = copy _4;
-+         _6 = copy _10;
-          StorageLive(_11);
-          _11 = const 1_usize;
--         _5 = *const [()] from (copy _6, copy _11);
-+         _5 = *const [()] from (copy _10, const 1_usize);
-          StorageDead(_11);
++         _6 = copy _9;
+          StorageLive(_10);
+          _10 = const 1_usize;
+-         _5 = *const [()] from (copy _6, copy _10);
++         _5 = *const [()] from (copy _9, const 1_usize);
+          StorageDead(_10);
           StorageDead(_6);
           StorageLive(_7);
           StorageLive(_8);
           _8 = copy _5;
 -         _7 = copy _8 as *mut () (PtrToPtr);
-+         _7 = copy ((_9.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *mut () (Transmute);
++         _7 = copy _11 as *mut () (Transmute);
           StorageDead(_8);
           StorageDead(_7);
 -         StorageDead(_5);
diff --git a/tests/mir-opt/inline/dont_ice_on_generic_rust_call.call.Inline.panic-abort.diff b/tests/mir-opt/inline/dont_ice_on_generic_rust_call.call.Inline.panic-abort.diff
index 0615f8132af00..86e8749fb0b51 100644
--- a/tests/mir-opt/inline/dont_ice_on_generic_rust_call.call.Inline.panic-abort.diff
+++ b/tests/mir-opt/inline/dont_ice_on_generic_rust_call.call.Inline.panic-abort.diff
@@ -9,8 +9,8 @@
       let mut _4: I;
 +     scope 1 (inlined <Box<dyn FnMut<I, Output = ()>> as FnMut<I>>::call_mut) {
 +         let mut _5: &mut dyn std::ops::FnMut<I, Output = ()>;
-+         let mut _6: std::boxed::Box<dyn std::ops::FnMut<I, Output = ()>>;
-+         let mut _7: *const dyn std::ops::FnMut<I, Output = ()>;
++         let mut _6: *const dyn std::ops::FnMut<I, Output = ()>;
++         let mut _7: std::ptr::NonNull<dyn std::ops::FnMut<I, Output = ()>>;
 +     }
   
       bb0: {
@@ -22,9 +22,9 @@
 +         StorageLive(_6);
 +         StorageLive(_7);
 +         StorageLive(_5);
-+         _6 = copy (*_3);
-+         _7 = copy ((_6.0: std::ptr::Unique<dyn std::ops::FnMut<I, Output = ()>>).0: std::ptr::NonNull<dyn std::ops::FnMut<I, Output = ()>>) as *const dyn std::ops::FnMut<I, Output = ()> (Transmute);
-+         _5 = &mut (*_7);
++         _7 = copy (((*_3).0: std::ptr::Unique<dyn std::ops::FnMut<I, Output = ()>>).0: std::ptr::NonNull<dyn std::ops::FnMut<I, Output = ()>>);
++         _6 = copy _7 as *const dyn std::ops::FnMut<I, Output = ()> (Transmute);
++         _5 = &mut (*_6);
 +         _0 = <dyn FnMut<I, Output = ()> as FnMut<I>>::call_mut(move _5, move _4) -> [return: bb2, unwind unreachable];
       }
   
diff --git a/tests/mir-opt/inline/dont_ice_on_generic_rust_call.call.Inline.panic-unwind.diff b/tests/mir-opt/inline/dont_ice_on_generic_rust_call.call.Inline.panic-unwind.diff
index 21b20329d4fa9..50136ae8766b2 100644
--- a/tests/mir-opt/inline/dont_ice_on_generic_rust_call.call.Inline.panic-unwind.diff
+++ b/tests/mir-opt/inline/dont_ice_on_generic_rust_call.call.Inline.panic-unwind.diff
@@ -9,8 +9,8 @@
       let mut _4: I;
 +     scope 1 (inlined <Box<dyn FnMut<I, Output = ()>> as FnMut<I>>::call_mut) {
 +         let mut _5: &mut dyn std::ops::FnMut<I, Output = ()>;
-+         let mut _6: std::boxed::Box<dyn std::ops::FnMut<I, Output = ()>>;
-+         let mut _7: *const dyn std::ops::FnMut<I, Output = ()>;
++         let mut _6: *const dyn std::ops::FnMut<I, Output = ()>;
++         let mut _7: std::ptr::NonNull<dyn std::ops::FnMut<I, Output = ()>>;
 +     }
   
       bb0: {
@@ -22,9 +22,9 @@
 +         StorageLive(_6);
 +         StorageLive(_7);
 +         StorageLive(_5);
-+         _6 = copy (*_3);
-+         _7 = copy ((_6.0: std::ptr::Unique<dyn std::ops::FnMut<I, Output = ()>>).0: std::ptr::NonNull<dyn std::ops::FnMut<I, Output = ()>>) as *const dyn std::ops::FnMut<I, Output = ()> (Transmute);
-+         _5 = &mut (*_7);
++         _7 = copy (((*_3).0: std::ptr::Unique<dyn std::ops::FnMut<I, Output = ()>>).0: std::ptr::NonNull<dyn std::ops::FnMut<I, Output = ()>>);
++         _6 = copy _7 as *const dyn std::ops::FnMut<I, Output = ()> (Transmute);
++         _5 = &mut (*_6);
 +         _0 = <dyn FnMut<I, Output = ()> as FnMut<I>>::call_mut(move _5, move _4) -> [return: bb4, unwind: bb2];
       }
   
diff --git a/tests/mir-opt/inline/inline_box_fn.call.Inline.panic-abort.diff b/tests/mir-opt/inline/inline_box_fn.call.Inline.panic-abort.diff
index ecea7a97513d5..97a8a99d9805e 100644
--- a/tests/mir-opt/inline/inline_box_fn.call.Inline.panic-abort.diff
+++ b/tests/mir-opt/inline/inline_box_fn.call.Inline.panic-abort.diff
@@ -9,8 +9,8 @@
       let mut _4: (i32,);
 +     scope 1 (inlined <Box<dyn Fn(i32)> as Fn<(i32,)>>::call) {
 +         let mut _5: &dyn std::ops::Fn(i32);
-+         let mut _6: std::boxed::Box<dyn std::ops::Fn(i32)>;
-+         let mut _7: *const dyn std::ops::Fn(i32);
++         let mut _6: *const dyn std::ops::Fn(i32);
++         let mut _7: std::ptr::NonNull<dyn std::ops::Fn(i32)>;
 +     }
   
       bb0: {
@@ -23,9 +23,9 @@
 +         StorageLive(_6);
 +         StorageLive(_7);
 +         StorageLive(_5);
-+         _6 = copy (*_3);
-+         _7 = copy ((_6.0: std::ptr::Unique<dyn std::ops::Fn(i32)>).0: std::ptr::NonNull<dyn std::ops::Fn(i32)>) as *const dyn std::ops::Fn(i32) (Transmute);
-+         _5 = &(*_7);
++         _7 = copy (((*_3).0: std::ptr::Unique<dyn std::ops::Fn(i32)>).0: std::ptr::NonNull<dyn std::ops::Fn(i32)>);
++         _6 = copy _7 as *const dyn std::ops::Fn(i32) (Transmute);
++         _5 = &(*_6);
 +         _2 = <dyn Fn(i32) as Fn<(i32,)>>::call(move _5, move _4) -> [return: bb2, unwind unreachable];
       }
   
diff --git a/tests/mir-opt/inline/inline_box_fn.call.Inline.panic-unwind.diff b/tests/mir-opt/inline/inline_box_fn.call.Inline.panic-unwind.diff
index 3a4a528e879fb..3b18052616e2f 100644
--- a/tests/mir-opt/inline/inline_box_fn.call.Inline.panic-unwind.diff
+++ b/tests/mir-opt/inline/inline_box_fn.call.Inline.panic-unwind.diff
@@ -9,8 +9,8 @@
       let mut _4: (i32,);
 +     scope 1 (inlined <Box<dyn Fn(i32)> as Fn<(i32,)>>::call) {
 +         let mut _5: &dyn std::ops::Fn(i32);
-+         let mut _6: std::boxed::Box<dyn std::ops::Fn(i32)>;
-+         let mut _7: *const dyn std::ops::Fn(i32);
++         let mut _6: *const dyn std::ops::Fn(i32);
++         let mut _7: std::ptr::NonNull<dyn std::ops::Fn(i32)>;
 +     }
   
       bb0: {
@@ -23,9 +23,9 @@
 +         StorageLive(_6);
 +         StorageLive(_7);
 +         StorageLive(_5);
-+         _6 = copy (*_3);
-+         _7 = copy ((_6.0: std::ptr::Unique<dyn std::ops::Fn(i32)>).0: std::ptr::NonNull<dyn std::ops::Fn(i32)>) as *const dyn std::ops::Fn(i32) (Transmute);
-+         _5 = &(*_7);
++         _7 = copy (((*_3).0: std::ptr::Unique<dyn std::ops::Fn(i32)>).0: std::ptr::NonNull<dyn std::ops::Fn(i32)>);
++         _6 = copy _7 as *const dyn std::ops::Fn(i32) (Transmute);
++         _5 = &(*_6);
 +         _2 = <dyn Fn(i32) as Fn<(i32,)>>::call(move _5, move _4) -> [return: bb4, unwind: bb2];
       }
   
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 103475b608cee..688e6967c2f85 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
@@ -8,8 +8,8 @@ fn b(_1: &mut Box<T>) -> &mut T {
     let mut _4: &mut std::boxed::Box<T>;
     scope 1 (inlined <Box<T> as AsMut<T>>::as_mut) {
         debug self => _4;
-        let mut _5: std::boxed::Box<T>;
-        let mut _6: *const T;
+        let mut _5: *const T;
+        let mut _6: std::ptr::NonNull<T>;
     }
 
     bb0: {
@@ -19,9 +19,9 @@ fn b(_1: &mut Box<T>) -> &mut T {
         _4 = copy _1;
         StorageLive(_5);
         StorageLive(_6);
-        _5 = copy (*_4);
-        _6 = copy ((_5.0: std::ptr::Unique<T>).0: std::ptr::NonNull<T>) as *const T (Transmute);
-        _3 = &mut (*_6);
+        _6 = copy (((*_4).0: std::ptr::Unique<T>).0: std::ptr::NonNull<T>);
+        _5 = copy _6 as *const T (Transmute);
+        _3 = &mut (*_5);
         StorageDead(_6);
         StorageDead(_5);
         _2 = copy _3;
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 babb26808cece..663741c62fb84 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
@@ -7,8 +7,8 @@ fn d(_1: &Box<T>) -> &T {
     let mut _3: &std::boxed::Box<T>;
     scope 1 (inlined <Box<T> as AsRef<T>>::as_ref) {
         debug self => _3;
-        let mut _4: std::boxed::Box<T>;
-        let mut _5: *const T;
+        let mut _4: *const T;
+        let mut _5: std::ptr::NonNull<T>;
     }
 
     bb0: {
@@ -17,9 +17,9 @@ fn d(_1: &Box<T>) -> &T {
         _3 = copy _1;
         StorageLive(_4);
         StorageLive(_5);
-        _4 = copy (*_3);
-        _5 = copy ((_4.0: std::ptr::Unique<T>).0: std::ptr::NonNull<T>) as *const T (Transmute);
-        _2 = &(*_5);
+        _5 = copy (((*_3).0: std::ptr::Unique<T>).0: std::ptr::NonNull<T>);
+        _4 = copy _5 as *const T (Transmute);
+        _2 = &(*_4);
         StorageDead(_5);
         StorageDead(_4);
         _0 = copy _2;

From 2da55cdb2cfcafa73e6c06eda0535b534c0e8365 Mon Sep 17 00:00:00 2001
From: beepster4096 <19316085+beepster4096@users.noreply.github.com>
Date: Wed, 13 Aug 2025 18:02:24 -0700
Subject: [PATCH 1867/1889] remove copyforderef from custom_mir

it did not create DerefTemp locals when used, so it was never actually correct.
---
 .../src/builder/custom/parse/instruction.rs      |  1 -
 compiler/rustc_span/src/symbol.rs                |  1 -
 library/core/src/intrinsics/mir.rs               |  3 +--
 .../projections.copy_for_deref.built.after.mir   | 12 ------------
 tests/mir-opt/building/custom/projections.rs     | 16 ----------------
 5 files changed, 1 insertion(+), 32 deletions(-)
 delete mode 100644 tests/mir-opt/building/custom/projections.copy_for_deref.built.after.mir

diff --git a/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs b/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs
index 54490e0050902..e33e83723c102 100644
--- a/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs
+++ b/compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs
@@ -253,7 +253,6 @@ impl<'a, 'tcx> ParseCtxt<'a, 'tcx> {
                 Ok(Rvalue::BinaryOp(BinOp::Offset, Box::new((ptr, offset))))
             },
             @call(mir_ptr_metadata, args) => Ok(Rvalue::UnaryOp(UnOp::PtrMetadata, self.parse_operand(args[0])?)),
-            @call(mir_copy_for_deref, args) => Ok(Rvalue::CopyForDeref(self.parse_place(args[0])?)),
             ExprKind::Borrow { borrow_kind, arg } => Ok(
                 Rvalue::Ref(self.tcx.lifetimes.re_erased, *borrow_kind, self.parse_place(*arg)?)
             ),
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 92dd56f3d5894..dee5bac7c54ea 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1423,7 +1423,6 @@ symbols! {
         mir_cast_transmute,
         mir_cast_unsize,
         mir_checked,
-        mir_copy_for_deref,
         mir_debuginfo,
         mir_deinit,
         mir_discriminant,
diff --git a/library/core/src/intrinsics/mir.rs b/library/core/src/intrinsics/mir.rs
index a800ef1cb9375..85c5a2c5228e1 100644
--- a/library/core/src/intrinsics/mir.rs
+++ b/library/core/src/intrinsics/mir.rs
@@ -233,7 +233,7 @@
 //!
 //!  - Operands implicitly convert to `Use` rvalues.
 //!  - `&`, `&mut`, `addr_of!`, and `addr_of_mut!` all work to create their associated rvalue.
-//!  - [`CopyForDeref`], [`CastTransmute`], [`CastPtrToPtr`], [`CastUnsize`], and [`Discriminant`]
+//!  - [`CastTransmute`], [`CastPtrToPtr`], [`CastUnsize`], and [`Discriminant`]
 //!    have associated functions.
 //!  - Unary and binary operations use their normal Rust syntax - `a * b`, `!c`, etc.
 //!  - The binary operation `Offset` can be created via [`Offset`].
@@ -406,7 +406,6 @@ define!(
     "mir_ptr_metadata",
     fn PtrMetadata<P: ?Sized>(place: *const P) -> <P as ::core::ptr::Pointee>::Metadata
 );
-define!("mir_copy_for_deref", fn CopyForDeref<T>(place: T) -> T);
 define!("mir_retag", fn Retag<T>(place: T));
 define!("mir_move", fn Move<T>(place: T) -> T);
 define!("mir_static", fn Static<T>(s: T) -> &'static T);
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
deleted file mode 100644
index b28e96f10eae7..0000000000000
--- a/tests/mir-opt/building/custom/projections.copy_for_deref.built.after.mir
+++ /dev/null
@@ -1,12 +0,0 @@
-// MIR for `copy_for_deref` after built
-
-fn copy_for_deref(_1: (&i32, i32)) -> i32 {
-    let mut _0: i32;
-    let mut _2: &i32;
-
-    bb0: {
-        _2 = deref_copy (_1.0: &i32);
-        _0 = copy (*_2);
-        return;
-    }
-}
diff --git a/tests/mir-opt/building/custom/projections.rs b/tests/mir-opt/building/custom/projections.rs
index 0250b9b84b621..e59eebd9952d7 100644
--- a/tests/mir-opt/building/custom/projections.rs
+++ b/tests/mir-opt/building/custom/projections.rs
@@ -79,19 +79,6 @@ fn simple_index(a: [i32; 10], b: &[i32]) -> i32 {
     }
 }
 
-// EMIT_MIR projections.copy_for_deref.built.after.mir
-#[custom_mir(dialect = "runtime", phase = "initial")]
-fn copy_for_deref(x: (&i32, i32)) -> i32 {
-    mir! {
-        let temp: &i32;
-        {
-            temp = CopyForDeref(x.0);
-            RET = *temp;
-            Return()
-        }
-    }
-}
-
 fn main() {
     assert_eq!(unions(U { a: 5 }), 5);
     assert_eq!(tuples((5, 6)), (5, 6));
@@ -103,7 +90,4 @@ fn main() {
     assert_eq!(o, Some(10));
 
     assert_eq!(simple_index([0; 10], &[0; 10]), 0);
-
-    let one = 1;
-    assert_eq!(copy_for_deref((&one, one)), 1);
 }

From 033474bacf62c7ca2c3d113d94422e4ef93ba4c9 Mon Sep 17 00:00:00 2001
From: beepster4096 <19316085+beepster4096@users.noreply.github.com>
Date: Sun, 17 Aug 2025 14:30:27 -0700
Subject: [PATCH 1868/1889] remove some deref_finder uses

elaborate drops and inline don't seem to actually need it
---
 compiler/rustc_mir_transform/src/elaborate_drops.rs | 2 --
 compiler/rustc_mir_transform/src/inline.rs          | 3 ---
 2 files changed, 5 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/elaborate_drops.rs b/compiler/rustc_mir_transform/src/elaborate_drops.rs
index c4ad29d663010..833a671de1d7d 100644
--- a/compiler/rustc_mir_transform/src/elaborate_drops.rs
+++ b/compiler/rustc_mir_transform/src/elaborate_drops.rs
@@ -14,7 +14,6 @@ use rustc_mir_dataflow::{
 use rustc_span::Span;
 use tracing::{debug, instrument};
 
-use crate::deref_separator::deref_finder;
 use crate::elaborate_drop::{DropElaborator, DropFlagMode, DropStyle, Unwind, elaborate_drop};
 use crate::patch::MirPatch;
 
@@ -87,7 +86,6 @@ impl<'tcx> crate::MirPass<'tcx> for ElaborateDrops {
             .elaborate()
         };
         elaborate_patch.apply(body);
-        deref_finder(tcx, body, true);
     }
 
     fn is_required(&self) -> bool {
diff --git a/compiler/rustc_mir_transform/src/inline.rs b/compiler/rustc_mir_transform/src/inline.rs
index 3c997cfd4fb01..38c7d8370e78d 100644
--- a/compiler/rustc_mir_transform/src/inline.rs
+++ b/compiler/rustc_mir_transform/src/inline.rs
@@ -20,7 +20,6 @@ use rustc_span::source_map::Spanned;
 use tracing::{debug, instrument, trace, trace_span};
 
 use crate::cost_checker::{CostChecker, is_call_like};
-use crate::deref_separator::deref_finder;
 use crate::simplify::{UsedInStmtLocals, simplify_cfg};
 use crate::validate::validate_types;
 use crate::{check_inline, util};
@@ -64,7 +63,6 @@ impl<'tcx> crate::MirPass<'tcx> for Inline {
         if inline::<NormalInliner<'tcx>>(tcx, body) {
             debug!("running simplify cfg on {:?}", body.source);
             simplify_cfg(tcx, body);
-            deref_finder(tcx, body, false);
         }
     }
 
@@ -100,7 +98,6 @@ impl<'tcx> crate::MirPass<'tcx> for ForceInline {
         if inline::<ForceInliner<'tcx>>(tcx, body) {
             debug!("running simplify cfg on {:?}", body.source);
             simplify_cfg(tcx, body);
-            deref_finder(tcx, body, false);
         }
     }
 }

From 7f0adce34ace20fb1167498596aa2910cb0f33eb Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sat, 11 Oct 2025 15:55:44 +1100
Subject: [PATCH 1869/1889] ci: Use GNU coreutils to work around a libffi-sys
 build failure

---
 src/ci/docker/host-aarch64/aarch64-gnu-debug/Dockerfile   | 2 ++
 src/ci/docker/host-aarch64/aarch64-gnu-llvm-20/Dockerfile | 2 ++
 src/ci/docker/host-aarch64/aarch64-gnu/Dockerfile         | 2 ++
 3 files changed, 6 insertions(+)

diff --git a/src/ci/docker/host-aarch64/aarch64-gnu-debug/Dockerfile b/src/ci/docker/host-aarch64/aarch64-gnu-debug/Dockerfile
index 04b46226acfa4..e840113047e6d 100644
--- a/src/ci/docker/host-aarch64/aarch64-gnu-debug/Dockerfile
+++ b/src/ci/docker/host-aarch64/aarch64-gnu-debug/Dockerfile
@@ -2,6 +2,8 @@ FROM ubuntu:25.10
 
 ARG DEBIAN_FRONTEND=noninteractive
 RUN apt-get update && apt-get install -y --no-install-recommends \
+  # FIXME(#147556): Use GNU coreutils to work around a libffi-sys build failure.
+  coreutils-from-gnu coreutils-from-uutils- --allow-remove-essential \
   g++ \
   make \
   ninja-build \
diff --git a/src/ci/docker/host-aarch64/aarch64-gnu-llvm-20/Dockerfile b/src/ci/docker/host-aarch64/aarch64-gnu-llvm-20/Dockerfile
index 095624d6fb714..f5c0f6127a8d1 100644
--- a/src/ci/docker/host-aarch64/aarch64-gnu-llvm-20/Dockerfile
+++ b/src/ci/docker/host-aarch64/aarch64-gnu-llvm-20/Dockerfile
@@ -3,6 +3,8 @@ FROM ubuntu:25.10
 ARG DEBIAN_FRONTEND=noninteractive
 
 RUN apt-get update && apt-get install -y --no-install-recommends \
+  # FIXME(#147556): Use GNU coreutils to work around a libffi-sys build failure.
+  coreutils-from-gnu coreutils-from-uutils- --allow-remove-essential \
   bzip2 \
   g++ \
   make \
diff --git a/src/ci/docker/host-aarch64/aarch64-gnu/Dockerfile b/src/ci/docker/host-aarch64/aarch64-gnu/Dockerfile
index 4b61fd94a6cfa..a54ce19f97168 100644
--- a/src/ci/docker/host-aarch64/aarch64-gnu/Dockerfile
+++ b/src/ci/docker/host-aarch64/aarch64-gnu/Dockerfile
@@ -2,6 +2,8 @@ FROM ubuntu:25.10
 
 ARG DEBIAN_FRONTEND=noninteractive
 RUN apt-get update && apt-get install -y --no-install-recommends \
+  # FIXME(#147556): Use GNU coreutils to work around a libffi-sys build failure.
+  coreutils-from-gnu coreutils-from-uutils- --allow-remove-essential \
   g++ \
   make \
   ninja-build \

From 5620c82e5344b42e99c317a550bdd1be878c5267 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Sat, 10 Aug 2024 19:46:48 +0000
Subject: [PATCH 1870/1889] Report uninhabited call return types on MIR.

---
 compiler/rustc_mir_build/messages.ftl         |  5 ++
 .../rustc_mir_build/src/builder/expr/into.rs  | 13 +---
 compiler/rustc_mir_build/src/builder/mod.rs   | 76 +++++++++++++++++++
 compiler/rustc_mir_build/src/errors.rs        | 12 +++
 compiler/rustc_passes/messages.ftl            |  5 --
 compiler/rustc_passes/src/errors.rs           | 12 ---
 compiler/rustc_passes/src/liveness.rs         | 49 +-----------
 tests/ui/enum-discriminant/issue-46519.rs     |  1 +
 tests/ui/enum-discriminant/issue-46519.stderr | 18 +++++
 .../intrinsics/panic-uninitialized-zeroed.rs  |  2 +-
 tests/ui/lint/dead-code/issue-85071-2.rs      |  2 +-
 tests/ui/lint/dead-code/issue-85071-2.stderr  | 33 ++++----
 tests/ui/lint/dead-code/issue-85071.rs        |  2 +-
 tests/ui/lint/dead-code/issue-85071.stderr    | 33 ++++----
 14 files changed, 150 insertions(+), 113 deletions(-)
 create mode 100644 tests/ui/enum-discriminant/issue-46519.stderr

diff --git a/compiler/rustc_mir_build/messages.ftl b/compiler/rustc_mir_build/messages.ftl
index e84e42b8a44b5..4a741169443dd 100644
--- a/compiler/rustc_mir_build/messages.ftl
+++ b/compiler/rustc_mir_build/messages.ftl
@@ -372,6 +372,11 @@ mir_build_union_field_requires_unsafe_unsafe_op_in_unsafe_fn_allowed =
 mir_build_union_pattern = cannot use unions in constant patterns
     .label = can't use a `union` here
 
+mir_build_unreachable_due_to_uninhabited = unreachable {$descr}
+    .label = unreachable {$descr}
+    .label_orig = any code following this expression is unreachable
+    .note = this expression has type `{$ty}`, which is uninhabited
+
 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
diff --git a/compiler/rustc_mir_build/src/builder/expr/into.rs b/compiler/rustc_mir_build/src/builder/expr/into.rs
index 7676b720e3579..bb65ef28bdc8c 100644
--- a/compiler/rustc_mir_build/src/builder/expr/into.rs
+++ b/compiler/rustc_mir_build/src/builder/expr/into.rs
@@ -390,18 +390,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         args,
                         unwind: UnwindAction::Continue,
                         destination,
-                        // The presence or absence of a return edge affects control-flow sensitive
-                        // MIR checks and ultimately whether code is accepted or not. We can only
-                        // omit the return edge if a return type is visibly uninhabited to a module
-                        // that makes the call.
-                        target: expr
-                            .ty
-                            .is_inhabited_from(
-                                this.tcx,
-                                this.parent_module,
-                                this.infcx.typing_env(this.param_env),
-                            )
-                            .then_some(success),
+                        target: Some(success),
                         call_source: if from_hir_call {
                             CallSource::Normal
                         } else {
diff --git a/compiler/rustc_mir_build/src/builder/mod.rs b/compiler/rustc_mir_build/src/builder/mod.rs
index 7ca94e655fb20..c0b5d3bb8f8b6 100644
--- a/compiler/rustc_mir_build/src/builder/mod.rs
+++ b/compiler/rustc_mir_build/src/builder/mod.rs
@@ -24,10 +24,12 @@ use rustc_middle::mir::*;
 use rustc_middle::thir::{self, ExprId, LintLevel, LocalVarId, Param, ParamId, PatKind, Thir};
 use rustc_middle::ty::{self, ScalarInt, Ty, TyCtxt, TypeVisitableExt, TypingMode};
 use rustc_middle::{bug, span_bug};
+use rustc_session::lint;
 use rustc_span::{Span, Symbol, sym};
 
 use crate::builder::expr::as_place::PlaceBuilder;
 use crate::builder::scope::DropKind;
+use crate::errors;
 
 pub(crate) fn closure_saved_names_of_captured_variables<'tcx>(
     tcx: TyCtxt<'tcx>,
@@ -531,6 +533,7 @@ fn construct_fn<'tcx>(
         return_block.unit()
     });
 
+    builder.lint_and_remove_uninhabited();
     let mut body = builder.finish();
 
     body.spread_arg = if abi == ExternAbi::RustCall {
@@ -588,6 +591,7 @@ fn construct_const<'a, 'tcx>(
 
     builder.build_drop_trees();
 
+    builder.lint_and_remove_uninhabited();
     builder.finish()
 }
 
@@ -806,6 +810,78 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         writer.write_mir_fn(&body, &mut std::io::stdout()).unwrap();
     }
 
+    fn lint_and_remove_uninhabited(&mut self) {
+        let mut lints = vec![];
+
+        for bbdata in self.cfg.basic_blocks.iter_mut() {
+            let term = bbdata.terminator_mut();
+            let TerminatorKind::Call { ref mut target, destination, .. } = term.kind else {
+                continue;
+            };
+            let Some(target_bb) = *target else { continue };
+
+            let ty = destination.ty(&self.local_decls, self.tcx).ty;
+            let ty_is_inhabited = ty.is_inhabited_from(
+                self.tcx,
+                self.parent_module,
+                self.infcx.typing_env(self.param_env),
+            );
+
+            if !ty_is_inhabited {
+                // Unreachable code warnings are already emitted during type checking.
+                // However, during type checking, full type information is being
+                // calculated but not yet available, so the check for diverging
+                // expressions due to uninhabited result types is pretty crude and
+                // only checks whether ty.is_never(). Here, we have full type
+                // information available and can issue warnings for less obviously
+                // uninhabited types (e.g. empty enums). The check above is used so
+                // that we do not emit the same warning twice if the uninhabited type
+                // is indeed `!`.
+                if !ty.is_never() {
+                    lints.push((target_bb, ty, term.source_info.span));
+                }
+
+                // The presence or absence of a return edge affects control-flow sensitive
+                // MIR checks and ultimately whether code is accepted or not. We can only
+                // omit the return edge if a return type is visibly uninhabited to a module
+                // that makes the call.
+                *target = None;
+            }
+        }
+
+        for (target_bb, orig_ty, orig_span) in lints {
+            if orig_span.in_external_macro(self.tcx.sess.source_map()) {
+                continue;
+            }
+            let target_bb = &self.cfg.basic_blocks[target_bb];
+            let (target_loc, descr) = target_bb
+                .statements
+                .iter()
+                .find_map(|stmt| match stmt.kind {
+                    StatementKind::StorageLive(_) | StatementKind::StorageDead(_) => None,
+                    StatementKind::FakeRead(..) => Some((stmt.source_info, "definition")),
+                    _ => Some((stmt.source_info, "expression")),
+                })
+                .unwrap_or_else(|| (target_bb.terminator().source_info, "expression"));
+            let lint_root = self.source_scopes[target_loc.scope]
+                .local_data
+                .as_ref()
+                .unwrap_crate_local()
+                .lint_root;
+            self.tcx.emit_node_span_lint(
+                lint::builtin::UNREACHABLE_CODE,
+                lint_root,
+                target_loc.span,
+                errors::UnreachableDueToUninhabited {
+                    expr: target_loc.span,
+                    orig: orig_span,
+                    descr,
+                    ty: orig_ty,
+                },
+            );
+        }
+    }
+
     fn finish(self) -> Body<'tcx> {
         let mut body = Body::new(
             MirSource::item(self.def_id.to_def_id()),
diff --git a/compiler/rustc_mir_build/src/errors.rs b/compiler/rustc_mir_build/src/errors.rs
index e2aae5b6283f2..3d9753d72da58 100644
--- a/compiler/rustc_mir_build/src/errors.rs
+++ b/compiler/rustc_mir_build/src/errors.rs
@@ -720,6 +720,18 @@ pub(crate) struct WantedConstant {
     pub(crate) const_path: String,
 }
 
+#[derive(LintDiagnostic)]
+#[diag(mir_build_unreachable_due_to_uninhabited)]
+pub(crate) struct UnreachableDueToUninhabited<'desc, 'tcx> {
+    pub descr: &'desc str,
+    #[label]
+    pub expr: Span,
+    #[label(mir_build_label_orig)]
+    #[note]
+    pub orig: Span,
+    pub 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_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index 9971f0c3fa32e..be9843988669a 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -619,11 +619,6 @@ passes_unnecessary_partial_stable_feature = the feature `{$feature}` has been pa
 
 passes_unnecessary_stable_feature = the feature `{$feature}` has been stable since {$since} and no longer requires an attribute to enable
 
-passes_unreachable_due_to_uninhabited = unreachable {$descr}
-    .label = unreachable {$descr}
-    .label_orig = any code following this expression is unreachable
-    .note = this expression has type `{$ty}`, which is uninhabited
-
 passes_unrecognized_argument =
     unrecognized argument
 
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index e01e9e384c035..8ca0641c4dd25 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -1308,18 +1308,6 @@ pub(crate) struct ProcMacroBadSig {
     pub kind: ProcMacroKind,
 }
 
-#[derive(LintDiagnostic)]
-#[diag(passes_unreachable_due_to_uninhabited)]
-pub(crate) struct UnreachableDueToUninhabited<'desc, 'tcx> {
-    pub descr: &'desc str,
-    #[label]
-    pub expr: Span,
-    #[label(passes_label_orig)]
-    #[note]
-    pub orig: Span,
-    pub ty: Ty<'tcx>,
-}
-
 #[derive(LintDiagnostic)]
 #[diag(passes_unused_var_maybe_capture_ref)]
 #[help]
diff --git a/compiler/rustc_passes/src/liveness.rs b/compiler/rustc_passes/src/liveness.rs
index b628ff8a12dfd..e175ac1c035e1 100644
--- a/compiler/rustc_passes/src/liveness.rs
+++ b/compiler/rustc_passes/src/liveness.rs
@@ -96,7 +96,7 @@ use rustc_index::IndexVec;
 use rustc_middle::query::Providers;
 use rustc_middle::span_bug;
 use rustc_middle::ty::print::with_no_trimmed_paths;
-use rustc_middle::ty::{self, RootVariableMinCaptureList, Ty, TyCtxt};
+use rustc_middle::ty::{self, RootVariableMinCaptureList, TyCtxt};
 use rustc_session::lint;
 use rustc_span::edit_distance::find_best_match_for_name;
 use rustc_span::{BytePos, Span, Symbol};
@@ -1317,52 +1317,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
     fn check_is_ty_uninhabited(&mut self, expr: &Expr<'_>, succ: LiveNode) -> LiveNode {
         let ty = self.typeck_results.expr_ty(expr);
         let m = self.ir.tcx.parent_module(expr.hir_id).to_def_id();
-        if ty.is_inhabited_from(self.ir.tcx, m, self.typing_env) {
-            return succ;
-        }
-        match self.ir.lnks[succ] {
-            LiveNodeKind::ExprNode(succ_span, succ_id) => {
-                self.warn_about_unreachable(expr.span, ty, succ_span, succ_id, "expression");
-            }
-            LiveNodeKind::VarDefNode(succ_span, succ_id) => {
-                self.warn_about_unreachable(expr.span, ty, succ_span, succ_id, "definition");
-            }
-            _ => {}
-        };
-        self.exit_ln
-    }
-
-    fn warn_about_unreachable<'desc>(
-        &mut self,
-        orig_span: Span,
-        orig_ty: Ty<'tcx>,
-        expr_span: Span,
-        expr_id: HirId,
-        descr: &'desc str,
-    ) {
-        if !orig_ty.is_never() {
-            // Unreachable code warnings are already emitted during type checking.
-            // However, during type checking, full type information is being
-            // calculated but not yet available, so the check for diverging
-            // expressions due to uninhabited result types is pretty crude and
-            // only checks whether ty.is_never(). Here, we have full type
-            // information available and can issue warnings for less obviously
-            // uninhabited types (e.g. empty enums). The check above is used so
-            // that we do not emit the same warning twice if the uninhabited type
-            // is indeed `!`.
-
-            self.ir.tcx.emit_node_span_lint(
-                lint::builtin::UNREACHABLE_CODE,
-                expr_id,
-                expr_span,
-                errors::UnreachableDueToUninhabited {
-                    expr: expr_span,
-                    orig: orig_span,
-                    descr,
-                    ty: orig_ty,
-                },
-            );
-        }
+        if ty.is_inhabited_from(self.ir.tcx, m, self.typing_env) { succ } else { self.exit_ln }
     }
 }
 
diff --git a/tests/ui/enum-discriminant/issue-46519.rs b/tests/ui/enum-discriminant/issue-46519.rs
index e5f0138c95cee..bad568ca6c5a7 100644
--- a/tests/ui/enum-discriminant/issue-46519.rs
+++ b/tests/ui/enum-discriminant/issue-46519.rs
@@ -7,6 +7,7 @@
 #[should_panic(expected = "creating inhabited type")]
 fn test() {
     FontLanguageOverride::system_font(SystemFont::new());
+    //~^ WARNING unreachable expression
 }
 
 pub enum FontLanguageOverride {
diff --git a/tests/ui/enum-discriminant/issue-46519.stderr b/tests/ui/enum-discriminant/issue-46519.stderr
new file mode 100644
index 0000000000000..5e4f536a59a7b
--- /dev/null
+++ b/tests/ui/enum-discriminant/issue-46519.stderr
@@ -0,0 +1,18 @@
+warning: unreachable expression
+  --> $DIR/issue-46519.rs:9:5
+   |
+LL |     FontLanguageOverride::system_font(SystemFont::new());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-----------------^
+   |     |                                 |
+   |     |                                 any code following this expression is unreachable
+   |     unreachable expression
+   |
+note: this expression has type `SystemFont`, which is uninhabited
+  --> $DIR/issue-46519.rs:9:39
+   |
+LL |     FontLanguageOverride::system_font(SystemFont::new());
+   |                                       ^^^^^^^^^^^^^^^^^
+   = note: `#[warn(unreachable_code)]` (part of `#[warn(unused)]`) on by default
+
+warning: 1 warning emitted
+
diff --git a/tests/ui/intrinsics/panic-uninitialized-zeroed.rs b/tests/ui/intrinsics/panic-uninitialized-zeroed.rs
index db2b4a6ad20a7..00fb2b029f9aa 100644
--- a/tests/ui/intrinsics/panic-uninitialized-zeroed.rs
+++ b/tests/ui/intrinsics/panic-uninitialized-zeroed.rs
@@ -7,7 +7,7 @@
 //@ ignore-backends: gcc
 //@ edition:2024
 
-#![allow(deprecated, invalid_value)]
+#![allow(deprecated, invalid_value, unreachable_code)]
 #![feature(never_type, rustc_private)]
 
 use std::{
diff --git a/tests/ui/lint/dead-code/issue-85071-2.rs b/tests/ui/lint/dead-code/issue-85071-2.rs
index 5db8735899410..06bbcac737397 100644
--- a/tests/ui/lint/dead-code/issue-85071-2.rs
+++ b/tests/ui/lint/dead-code/issue-85071-2.rs
@@ -17,6 +17,6 @@ fn main() {
     let s = S;
     let x = s.f();
     //~^ WARNING: unused variable: `x`
+    //~| WARNING: unreachable definition
     let _y = x;
-    //~^ WARNING: unreachable definition
 }
diff --git a/tests/ui/lint/dead-code/issue-85071-2.stderr b/tests/ui/lint/dead-code/issue-85071-2.stderr
index 5e963183d094b..ab88d72359695 100644
--- a/tests/ui/lint/dead-code/issue-85071-2.stderr
+++ b/tests/ui/lint/dead-code/issue-85071-2.stderr
@@ -1,34 +1,33 @@
-warning: unreachable definition
-  --> $DIR/issue-85071-2.rs:20:9
+warning: unused variable: `x`
+  --> $DIR/issue-85071-2.rs:18:9
    |
 LL |     let x = s.f();
-   |             ----- any code following this expression is unreachable
-LL |
-LL |     let _y = x;
-   |         ^^ unreachable definition
-   |
-note: this expression has type `Foo`, which is uninhabited
-  --> $DIR/issue-85071-2.rs:18:13
+   |         ^ help: if this is intentional, prefix it with an underscore: `_x`
    |
-LL |     let x = s.f();
-   |             ^^^^^
 note: the lint level is defined here
-  --> $DIR/issue-85071-2.rs:7:26
+  --> $DIR/issue-85071-2.rs:7:9
    |
 LL | #![warn(unused_variables,unreachable_code)]
-   |                          ^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^
 
-warning: unused variable: `x`
+warning: unreachable definition
   --> $DIR/issue-85071-2.rs:18:9
    |
 LL |     let x = s.f();
-   |         ^ help: if this is intentional, prefix it with an underscore: `_x`
+   |         ^   ----- any code following this expression is unreachable
+   |         |
+   |         unreachable definition
+   |
+note: this expression has type `Foo`, which is uninhabited
+  --> $DIR/issue-85071-2.rs:18:13
    |
+LL |     let x = s.f();
+   |             ^^^^^
 note: the lint level is defined here
-  --> $DIR/issue-85071-2.rs:7:9
+  --> $DIR/issue-85071-2.rs:7:26
    |
 LL | #![warn(unused_variables,unreachable_code)]
-   |         ^^^^^^^^^^^^^^^^
+   |                          ^^^^^^^^^^^^^^^^
 
 warning: 2 warnings emitted
 
diff --git a/tests/ui/lint/dead-code/issue-85071.rs b/tests/ui/lint/dead-code/issue-85071.rs
index 84f2c9fc74eeb..6f177905b5968 100644
--- a/tests/ui/lint/dead-code/issue-85071.rs
+++ b/tests/ui/lint/dead-code/issue-85071.rs
@@ -14,6 +14,6 @@ fn f() -> Foo {todo!()}
 fn main() {
     let x = f();
     //~^ WARNING: unused variable: `x`
+    //~| WARNING: unreachable definition
     let _ = x;
-    //~^ WARNING: unreachable expression
 }
diff --git a/tests/ui/lint/dead-code/issue-85071.stderr b/tests/ui/lint/dead-code/issue-85071.stderr
index 721fb8148d96b..c94923063903a 100644
--- a/tests/ui/lint/dead-code/issue-85071.stderr
+++ b/tests/ui/lint/dead-code/issue-85071.stderr
@@ -1,34 +1,33 @@
-warning: unreachable expression
-  --> $DIR/issue-85071.rs:17:13
+warning: unused variable: `x`
+  --> $DIR/issue-85071.rs:15:9
    |
 LL |     let x = f();
-   |             --- any code following this expression is unreachable
-LL |
-LL |     let _ = x;
-   |             ^ unreachable expression
-   |
-note: this expression has type `Foo`, which is uninhabited
-  --> $DIR/issue-85071.rs:15:13
+   |         ^ help: if this is intentional, prefix it with an underscore: `_x`
    |
-LL |     let x = f();
-   |             ^^^
 note: the lint level is defined here
-  --> $DIR/issue-85071.rs:9:26
+  --> $DIR/issue-85071.rs:9:9
    |
 LL | #![warn(unused_variables,unreachable_code)]
-   |                          ^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^
 
-warning: unused variable: `x`
+warning: unreachable definition
   --> $DIR/issue-85071.rs:15:9
    |
 LL |     let x = f();
-   |         ^ help: if this is intentional, prefix it with an underscore: `_x`
+   |         ^   --- any code following this expression is unreachable
+   |         |
+   |         unreachable definition
+   |
+note: this expression has type `Foo`, which is uninhabited
+  --> $DIR/issue-85071.rs:15:13
    |
+LL |     let x = f();
+   |             ^^^
 note: the lint level is defined here
-  --> $DIR/issue-85071.rs:9:9
+  --> $DIR/issue-85071.rs:9:26
    |
 LL | #![warn(unused_variables,unreachable_code)]
-   |         ^^^^^^^^^^^^^^^^
+   |                          ^^^^^^^^^^^^^^^^
 
 warning: 2 warnings emitted
 

From aacf9a612a9d3d3745ed6714574589e8e54b55fa Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Sat, 21 Jun 2025 14:07:06 +0000
Subject: [PATCH 1871/1889] Add test for uninhabited `std::mem::uninitialized`
 uses.

---
 tests/ui/uninhabited/void-branch.rs     | 30 +++++++++++++++++++
 tests/ui/uninhabited/void-branch.stderr | 40 +++++++++++++++++++++++++
 2 files changed, 70 insertions(+)
 create mode 100644 tests/ui/uninhabited/void-branch.rs
 create mode 100644 tests/ui/uninhabited/void-branch.stderr

diff --git a/tests/ui/uninhabited/void-branch.rs b/tests/ui/uninhabited/void-branch.rs
new file mode 100644
index 0000000000000..e000f946dc156
--- /dev/null
+++ b/tests/ui/uninhabited/void-branch.rs
@@ -0,0 +1,30 @@
+#![deny(unreachable_code)]
+#![allow(deprecated, invalid_value)]
+
+enum Void {}
+
+fn with_void() {
+    if false {
+        unsafe {
+            //~^ ERROR unreachable expression
+            std::mem::uninitialized::<Void>();
+        }
+    }
+
+    println!();
+}
+
+fn infallible() -> std::convert::Infallible {
+    loop {}
+}
+
+fn with_infallible() {
+    if false {
+        //~^ ERROR unreachable expression
+        infallible();
+    }
+
+    println!()
+}
+
+fn main() {}
diff --git a/tests/ui/uninhabited/void-branch.stderr b/tests/ui/uninhabited/void-branch.stderr
new file mode 100644
index 0000000000000..7bbcb763ddf7c
--- /dev/null
+++ b/tests/ui/uninhabited/void-branch.stderr
@@ -0,0 +1,40 @@
+error: unreachable expression
+  --> $DIR/void-branch.rs:8:9
+   |
+LL | /         unsafe {
+LL | |
+LL | |             std::mem::uninitialized::<Void>();
+   | |             --------------------------------- any code following this expression is unreachable
+LL | |         }
+   | |_________^ unreachable expression
+   |
+note: this expression has type `Void`, which is uninhabited
+  --> $DIR/void-branch.rs:10:13
+   |
+LL |             std::mem::uninitialized::<Void>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+note: the lint level is defined here
+  --> $DIR/void-branch.rs:1:9
+   |
+LL | #![deny(unreachable_code)]
+   |         ^^^^^^^^^^^^^^^^
+
+error: unreachable expression
+  --> $DIR/void-branch.rs:22:14
+   |
+LL |       if false {
+   |  ______________^
+LL | |
+LL | |         infallible();
+   | |         ------------ any code following this expression is unreachable
+LL | |     }
+   | |_____^ unreachable expression
+   |
+note: this expression has type `Infallible`, which is uninhabited
+  --> $DIR/void-branch.rs:24:9
+   |
+LL |         infallible();
+   |         ^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+

From 9df200386006f3cddca7d1664fc7e8438b7d0419 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Tue, 6 Sep 2022 18:58:52 +0200
Subject: [PATCH 1872/1889] Record for each MIR local where it has been
 introduced.

---
 .../src/diagnostics/move_errors.rs             |  4 +---
 .../src/diagnostics/mutability_errors.rs       |  4 ++--
 compiler/rustc_middle/src/mir/mod.rs           | 18 ++++++------------
 compiler/rustc_middle/src/thir.rs              |  1 +
 compiler/rustc_mir_build/src/builder/block.rs  |  1 +
 .../src/builder/matches/match_pair.rs          |  3 ++-
 .../rustc_mir_build/src/builder/matches/mod.rs | 12 ++++++++++++
 compiler/rustc_mir_build/src/builder/mod.rs    |  1 +
 .../rustc_mir_build/src/thir/pattern/mod.rs    | 11 ++++++++---
 compiler/rustc_mir_build/src/thir/print.rs     |  3 ++-
 .../ui/thir-print/thir-tree-loop-match.stdout  |  1 +
 tests/ui/thir-print/thir-tree-match.stdout     |  1 +
 12 files changed, 38 insertions(+), 22 deletions(-)

diff --git a/compiler/rustc_borrowck/src/diagnostics/move_errors.rs b/compiler/rustc_borrowck/src/diagnostics/move_errors.rs
index 0b3151fd8b82d..be2a5b1ebe22d 100644
--- a/compiler/rustc_borrowck/src/diagnostics/move_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/move_errors.rs
@@ -139,9 +139,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
             // whether or not the right-hand side is a place expression
             if let LocalInfo::User(BindingForm::Var(VarBindingForm {
                 opt_match_place: Some((opt_match_place, match_span)),
-                binding_mode: _,
-                opt_ty_info: _,
-                pat_span: _,
+                ..
             })) = *local_decl.local_info()
             {
                 let stmt_source_info = self.body.source_info(location);
diff --git a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
index 727cf19cd8bb3..6b5af15febea0 100644
--- a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
@@ -335,8 +335,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                         LocalInfo::User(BindingForm::Var(mir::VarBindingForm {
                             binding_mode: BindingMode(ByRef::No, Mutability::Not),
                             opt_ty_info: Some(sp),
-                            opt_match_place: _,
-                            pat_span: _,
+                            ..
                         })) => {
                             if suggest {
                                 err.span_note(sp, "the binding is already a mutable borrow");
@@ -750,6 +749,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                 opt_ty_info: _,
                 opt_match_place: _,
                 pat_span,
+                introductions: _,
             })) => pat_span,
             _ => local_decl.source_info.span,
         };
diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs
index 8eb7aa71fcdea..668265b8fd083 100644
--- a/compiler/rustc_middle/src/mir/mod.rs
+++ b/compiler/rustc_middle/src/mir/mod.rs
@@ -882,6 +882,8 @@ pub struct VarBindingForm<'tcx> {
     pub opt_match_place: Option<(Option<Place<'tcx>>, Span)>,
     /// The span of the pattern in which this variable was bound.
     pub pat_span: Span,
+    /// For each introduction place, record here the span and whether this was a shorthand pattern.
+    pub introductions: Vec<(Span, /* is_shorthand */ bool)>,
 }
 
 #[derive(Clone, Debug, TyEncodable, TyDecodable)]
@@ -1088,12 +1090,8 @@ impl<'tcx> LocalDecl<'tcx> {
         matches!(
             self.local_info(),
             LocalInfo::User(
-                BindingForm::Var(VarBindingForm {
-                    binding_mode: BindingMode(ByRef::No, _),
-                    opt_ty_info: _,
-                    opt_match_place: _,
-                    pat_span: _,
-                }) | BindingForm::ImplicitSelf(ImplicitSelfKind::Imm),
+                BindingForm::Var(VarBindingForm { binding_mode: BindingMode(ByRef::No, _), .. })
+                    | BindingForm::ImplicitSelf(ImplicitSelfKind::Imm),
             )
         )
     }
@@ -1105,12 +1103,8 @@ impl<'tcx> LocalDecl<'tcx> {
         matches!(
             self.local_info(),
             LocalInfo::User(
-                BindingForm::Var(VarBindingForm {
-                    binding_mode: BindingMode(ByRef::No, _),
-                    opt_ty_info: _,
-                    opt_match_place: _,
-                    pat_span: _,
-                }) | BindingForm::ImplicitSelf(_),
+                BindingForm::Var(VarBindingForm { binding_mode: BindingMode(ByRef::No, _), .. })
+                    | BindingForm::ImplicitSelf(_),
             )
         )
     }
diff --git a/compiler/rustc_middle/src/thir.rs b/compiler/rustc_middle/src/thir.rs
index eed27345b747b..0ae4f13f3ca94 100644
--- a/compiler/rustc_middle/src/thir.rs
+++ b/compiler/rustc_middle/src/thir.rs
@@ -798,6 +798,7 @@ pub enum PatKind<'tcx> {
         /// (The same binding can occur multiple times in different branches of
         /// an or-pattern, but only one of them will be primary.)
         is_primary: bool,
+        is_shorthand: bool,
     },
 
     /// `Foo(...)` or `Foo{...}` or `Foo`, where `Foo` is a variant name from an ADT with
diff --git a/compiler/rustc_mir_build/src/builder/block.rs b/compiler/rustc_mir_build/src/builder/block.rs
index 566d89f4269c0..cc99d2b42eebc 100644
--- a/compiler/rustc_mir_build/src/builder/block.rs
+++ b/compiler/rustc_mir_build/src/builder/block.rs
@@ -286,6 +286,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                                 block,
                                 node,
                                 span,
+                                false,
                                 OutsideGuard,
                                 ScheduleDrops::Yes,
                             );
diff --git a/compiler/rustc_mir_build/src/builder/matches/match_pair.rs b/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
index 7a848536d0e33..82c769eb3d584 100644
--- a/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
+++ b/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
@@ -170,7 +170,7 @@ impl<'tcx> MatchPairTree<'tcx> {
                 None
             }
 
-            PatKind::Binding { mode, var, ref subpattern, .. } => {
+            PatKind::Binding { mode, var, is_shorthand, ref subpattern, .. } => {
                 // In order to please the borrow checker, when lowering a pattern
                 // like `x @ subpat` we must establish any bindings in `subpat`
                 // before establishing the binding for `x`.
@@ -209,6 +209,7 @@ impl<'tcx> MatchPairTree<'tcx> {
                         source,
                         var_id: var,
                         binding_mode: mode,
+                        is_shorthand,
                     }));
                 }
 
diff --git a/compiler/rustc_mir_build/src/builder/matches/mod.rs b/compiler/rustc_mir_build/src/builder/matches/mod.rs
index d216c4ecd1155..d3727e0c9a145 100644
--- a/compiler/rustc_mir_build/src/builder/matches/mod.rs
+++ b/compiler/rustc_mir_build/src/builder/matches/mod.rs
@@ -579,6 +579,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     block,
                     var,
                     irrefutable_pat.span,
+                    false,
                     OutsideGuard,
                     ScheduleDrops::Yes,
                 );
@@ -608,6 +609,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     block,
                     var,
                     irrefutable_pat.span,
+                    false,
                     OutsideGuard,
                     ScheduleDrops::Yes,
                 );
@@ -799,6 +801,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         block: BasicBlock,
         var: LocalVarId,
         span: Span,
+        is_shorthand: bool,
         for_guard: ForGuard,
         schedule_drop: ScheduleDrops,
     ) -> Place<'tcx> {
@@ -812,6 +815,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         {
             self.schedule_drop(span, region_scope, local_id, DropKind::Storage);
         }
+        let local_info = self.local_decls[local_id].local_info.as_mut().unwrap_crate_local();
+        if let LocalInfo::User(BindingForm::Var(var_info)) = &mut **local_info {
+            var_info.introductions.push((span, is_shorthand));
+        }
         Place::from(local_id)
     }
 
@@ -1217,6 +1224,7 @@ struct Binding<'tcx> {
     source: Place<'tcx>,
     var_id: LocalVarId,
     binding_mode: BindingMode,
+    is_shorthand: bool,
 }
 
 /// Indicates that the type of `source` must be a subtype of the
@@ -2725,6 +2733,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 block,
                 binding.var_id,
                 binding.span,
+                binding.is_shorthand,
                 RefWithinGuard,
                 ScheduleDrops::Yes,
             );
@@ -2742,6 +2751,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         block,
                         binding.var_id,
                         binding.span,
+                        binding.is_shorthand,
                         OutsideGuard,
                         ScheduleDrops::Yes,
                     );
@@ -2775,6 +2785,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 block,
                 binding.var_id,
                 binding.span,
+                binding.is_shorthand,
                 OutsideGuard,
                 schedule_drops,
             );
@@ -2827,6 +2838,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     opt_ty_info: None,
                     opt_match_place,
                     pat_span,
+                    introductions: Vec::new(),
                 },
             )))),
         };
diff --git a/compiler/rustc_mir_build/src/builder/mod.rs b/compiler/rustc_mir_build/src/builder/mod.rs
index c0b5d3bb8f8b6..dbc0441a66d9b 100644
--- a/compiler/rustc_mir_build/src/builder/mod.rs
+++ b/compiler/rustc_mir_build/src/builder/mod.rs
@@ -1054,6 +1054,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                                 opt_ty_info: param.ty_span,
                                 opt_match_place: Some((None, span)),
                                 pat_span: span,
+                                introductions: vec![(span, false)],
                             }))
                         };
                     self.var_indices.insert(var, LocalsForNode::One(local));
diff --git a/compiler/rustc_mir_build/src/thir/pattern/mod.rs b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
index 166e64a5fcb85..dc6b958904497 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/mod.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
@@ -369,6 +369,7 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
                     ty: var_ty,
                     subpattern: self.lower_opt_pattern(sub),
                     is_primary: id == pat.hir_id,
+                    is_shorthand: false,
                 }
             }
 
@@ -386,9 +387,13 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
                 let res = self.typeck_results.qpath_res(qpath, pat.hir_id);
                 let subpatterns = fields
                     .iter()
-                    .map(|field| FieldPat {
-                        field: self.typeck_results.field_index(field.hir_id),
-                        pattern: *self.lower_pattern(field.pat),
+                    .map(|field| {
+                        let mut pattern = *self.lower_pattern(field.pat);
+                        if let PatKind::Binding { ref mut is_shorthand, .. } = pattern.kind {
+                            *is_shorthand = field.is_shorthand;
+                        }
+                        let field = self.typeck_results.field_index(field.hir_id);
+                        FieldPat { field, pattern }
                     })
                     .collect();
 
diff --git a/compiler/rustc_mir_build/src/thir/print.rs b/compiler/rustc_mir_build/src/thir/print.rs
index 188f179669cb4..e0a5c18a2eedb 100644
--- a/compiler/rustc_mir_build/src/thir/print.rs
+++ b/compiler/rustc_mir_build/src/thir/print.rs
@@ -705,13 +705,14 @@ impl<'a, 'tcx> ThirPrinter<'a, 'tcx> {
                 self.print_pat(subpattern, depth_lvl + 3);
                 print_indented!(self, "}", depth_lvl + 1);
             }
-            PatKind::Binding { name, mode, var, ty, subpattern, is_primary } => {
+            PatKind::Binding { name, mode, var, ty, subpattern, is_primary, is_shorthand } => {
                 print_indented!(self, "Binding {", depth_lvl + 1);
                 print_indented!(self, format!("name: {:?}", name), depth_lvl + 2);
                 print_indented!(self, format!("mode: {:?}", mode), depth_lvl + 2);
                 print_indented!(self, format!("var: {:?}", var), depth_lvl + 2);
                 print_indented!(self, format!("ty: {:?}", ty), depth_lvl + 2);
                 print_indented!(self, format!("is_primary: {:?}", is_primary), depth_lvl + 2);
+                print_indented!(self, format!("is_shorthand: {:?}", is_shorthand), depth_lvl + 2);
 
                 if let Some(subpattern) = subpattern {
                     print_indented!(self, "subpattern: Some( ", depth_lvl + 2);
diff --git a/tests/ui/thir-print/thir-tree-loop-match.stdout b/tests/ui/thir-print/thir-tree-loop-match.stdout
index f2b63782c596c..c9117c3048b03 100644
--- a/tests/ui/thir-print/thir-tree-loop-match.stdout
+++ b/tests/ui/thir-print/thir-tree-loop-match.stdout
@@ -16,6 +16,7 @@ params: [
                         var: LocalVarId(HirId(DefId(0:3 ~ thir_tree_loop_match[3c53]::boolean).2))
                         ty: bool
                         is_primary: true
+                        is_shorthand: false
                         subpattern: None
                     }
                 }
diff --git a/tests/ui/thir-print/thir-tree-match.stdout b/tests/ui/thir-print/thir-tree-match.stdout
index 2049c531abd99..fde5003176679 100644
--- a/tests/ui/thir-print/thir-tree-match.stdout
+++ b/tests/ui/thir-print/thir-tree-match.stdout
@@ -16,6 +16,7 @@ params: [
                         var: LocalVarId(HirId(DefId(0:16 ~ thir_tree_match[fcf8]::has_match).2))
                         ty: Foo
                         is_primary: true
+                        is_shorthand: false
                         subpattern: None
                     }
                 }

From f2535764d42eb44c99998f800344ce0a2bc8f678 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Sat, 21 Jun 2025 12:44:19 +0000
Subject: [PATCH 1873/1889] Introduce VarBindingIntroduction.

---
 compiler/rustc_middle/src/mir/mod.rs                | 13 +++++++++++--
 compiler/rustc_middle/src/thir.rs                   |  1 +
 compiler/rustc_mir_build/src/builder/matches/mod.rs |  2 +-
 compiler/rustc_mir_build/src/builder/mod.rs         |  5 ++++-
 4 files changed, 17 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs
index 668265b8fd083..afc5b9992e28c 100644
--- a/compiler/rustc_middle/src/mir/mod.rs
+++ b/compiler/rustc_middle/src/mir/mod.rs
@@ -882,8 +882,9 @@ pub struct VarBindingForm<'tcx> {
     pub opt_match_place: Option<(Option<Place<'tcx>>, Span)>,
     /// The span of the pattern in which this variable was bound.
     pub pat_span: Span,
-    /// For each introduction place, record here the span and whether this was a shorthand pattern.
-    pub introductions: Vec<(Span, /* is_shorthand */ bool)>,
+    /// A binding can be introduced multiple times, with or patterns:
+    /// `Foo::A { x } | Foo::B { z: x }`. This stores information for each of those introductions.
+    pub introductions: Vec<VarBindingIntroduction>,
 }
 
 #[derive(Clone, Debug, TyEncodable, TyDecodable)]
@@ -896,6 +897,14 @@ pub enum BindingForm<'tcx> {
     RefForGuard,
 }
 
+#[derive(Clone, Debug, TyEncodable, TyDecodable, HashStable)]
+pub struct VarBindingIntroduction {
+    /// Where this additional introduction happened.
+    pub span: Span,
+    /// Is that introduction a shorthand struct pattern, i.e. `Foo { x }`.
+    pub is_shorthand: bool,
+}
+
 mod binding_form_impl {
     use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
     use rustc_query_system::ich::StableHashingContext;
diff --git a/compiler/rustc_middle/src/thir.rs b/compiler/rustc_middle/src/thir.rs
index 0ae4f13f3ca94..e72ed78d07e6a 100644
--- a/compiler/rustc_middle/src/thir.rs
+++ b/compiler/rustc_middle/src/thir.rs
@@ -798,6 +798,7 @@ pub enum PatKind<'tcx> {
         /// (The same binding can occur multiple times in different branches of
         /// an or-pattern, but only one of them will be primary.)
         is_primary: bool,
+        /// Is this binding a shorthand struct pattern, i.e. `Foo { a }`?
         is_shorthand: bool,
     },
 
diff --git a/compiler/rustc_mir_build/src/builder/matches/mod.rs b/compiler/rustc_mir_build/src/builder/matches/mod.rs
index d3727e0c9a145..c4b4ee448dce1 100644
--- a/compiler/rustc_mir_build/src/builder/matches/mod.rs
+++ b/compiler/rustc_mir_build/src/builder/matches/mod.rs
@@ -817,7 +817,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         }
         let local_info = self.local_decls[local_id].local_info.as_mut().unwrap_crate_local();
         if let LocalInfo::User(BindingForm::Var(var_info)) = &mut **local_info {
-            var_info.introductions.push((span, is_shorthand));
+            var_info.introductions.push(VarBindingIntroduction { span, is_shorthand });
         }
         Place::from(local_id)
     }
diff --git a/compiler/rustc_mir_build/src/builder/mod.rs b/compiler/rustc_mir_build/src/builder/mod.rs
index dbc0441a66d9b..f2c153578433f 100644
--- a/compiler/rustc_mir_build/src/builder/mod.rs
+++ b/compiler/rustc_mir_build/src/builder/mod.rs
@@ -1054,7 +1054,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                                 opt_ty_info: param.ty_span,
                                 opt_match_place: Some((None, span)),
                                 pat_span: span,
-                                introductions: vec![(span, false)],
+                                introductions: vec![VarBindingIntroduction {
+                                    span,
+                                    is_shorthand: false,
+                                }],
                             }))
                         };
                     self.var_indices.insert(var, LocalsForNode::One(local));

From 89191084d5c3c8fa9fed9b70e744c8fd6b066e03 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Tue, 10 Jun 2025 18:17:32 +0000
Subject: [PATCH 1874/1889] Correct binding scope when building MIR.

---
 compiler/rustc_mir_build/src/builder/matches/mod.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/compiler/rustc_mir_build/src/builder/matches/mod.rs b/compiler/rustc_mir_build/src/builder/matches/mod.rs
index c4b4ee448dce1..165fb4b6517d5 100644
--- a/compiler/rustc_mir_build/src/builder/matches/mod.rs
+++ b/compiler/rustc_mir_build/src/builder/matches/mod.rs
@@ -741,6 +741,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             pattern,
             &ProjectedUserTypesNode::None,
             &mut |this, name, mode, var, span, ty, user_tys| {
+                let saved_scope = this.source_scope;
+                this.set_correct_source_scope_for_arg(var.0, saved_scope, span);
                 let vis_scope = *visibility_scope
                     .get_or_insert_with(|| this.new_source_scope(scope_span, LintLevel::Inherited));
                 let source_info = SourceInfo { span, scope: this.source_scope };
@@ -758,6 +760,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     opt_match_place.map(|(x, y)| (x.cloned(), y)),
                     pattern.span,
                 );
+                this.source_scope = saved_scope;
             },
         );
         if let Some(guard_expr) = guard {

From 96b70fc3a13697bdf6dfb7a0a1fc3338d6bfb37d Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Tue, 26 Aug 2025 22:38:56 +0000
Subject: [PATCH 1875/1889] Always compile hir_id_validator.

Making this compilation conditional causes an unused crate dependency
warning.
---
 compiler/rustc_passes/src/lib.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/compiler/rustc_passes/src/lib.rs b/compiler/rustc_passes/src/lib.rs
index 2ad0b5ff60e84..06a127577d432 100644
--- a/compiler/rustc_passes/src/lib.rs
+++ b/compiler/rustc_passes/src/lib.rs
@@ -23,7 +23,6 @@ mod debugger_visualizer;
 mod diagnostic_items;
 pub mod entry;
 mod errors;
-#[cfg(debug_assertions)]
 pub mod hir_id_validator;
 pub mod input_stats;
 mod lang_items;

From ca0379d6cdbb17abc3afe1ac1cbf869626d047df Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Tue, 10 Jun 2025 18:17:09 +0000
Subject: [PATCH 1876/1889] Diagnose liveness on MIR.

---
 compiler/rustc_interface/src/passes.rs        |    1 +
 compiler/rustc_middle/src/mir/mod.rs          |    6 +-
 compiler/rustc_middle/src/mir/statement.rs    |    2 +-
 compiler/rustc_middle/src/query/mod.rs        |    6 +-
 compiler/rustc_middle/src/ty/closure.rs       |    5 +
 .../src/builder/matches/mod.rs                |    2 +-
 compiler/rustc_mir_build/src/builder/mod.rs   |    5 -
 compiler/rustc_mir_transform/messages.ftl     |   27 +
 compiler/rustc_mir_transform/src/errors.rs    |  110 +-
 compiler/rustc_mir_transform/src/lib.rs       |    4 +
 compiler/rustc_mir_transform/src/liveness.rs  | 1328 ++++++++++++
 compiler/rustc_passes/messages.ftl            |   35 -
 compiler/rustc_passes/src/errors.rs           |  153 +-
 compiler/rustc_passes/src/lib.rs              |    2 -
 compiler/rustc_passes/src/liveness.rs         | 1853 -----------------
 .../rustc_passes/src/liveness/rwu_table.rs    |  146 --
 .../clippy/tests/ui/needless_match.fixed      |    2 +-
 src/tools/clippy/tests/ui/needless_match.rs   |    2 +-
 .../clippy/tests/ui/useless_conversion.fixed  |    2 +-
 .../clippy/tests/ui/useless_conversion.rs     |    2 +-
 tests/ui/asm/x86_64/goto.rs                   |    1 +
 tests/ui/asm/x86_64/goto.stderr               |   11 +-
 .../async-closures/precise-captures.rs        |    1 +
 .../borrowck/borrowck-assign-to-subfield.rs   |    1 +
 .../diagnostics/liveness.rs                   |   48 +-
 .../diagnostics/liveness.stderr               |  115 +-
 .../liveness_unintentional_copy.rs            |   24 +-
 .../liveness_unintentional_copy.stderr        |   85 +-
 ...ture-pattern-closure-within-closure.stderr |   16 +-
 .../closures/moved-upvar-mut-rebind-11958.rs  |    5 +-
 .../moved-upvar-mut-rebind-11958.stderr       |   23 +-
 .../defaults/trait_object_lt_defaults.rs      |    2 +-
 tests/ui/drop/or-pattern-drop-order.rs        |    2 +-
 tests/ui/dropck/dropck-empty-array.rs         |    3 +-
 ...-type-meant-to-be-arg-of-mut-borrow.stderr |   50 +-
 tests/ui/issues/issue-19367.rs                |    3 +
 tests/ui/lint/dead-code/issue-85071-2.stderr  |   24 +-
 tests/ui/lint/dead-code/issue-85071.stderr    |   24 +-
 .../ui/lint/future-incompat-json-test.stderr  |    2 +-
 ...orthand-field-patterns-in-pattern-macro.rs |    1 +
 ...and-field-patterns-in-pattern-macro.stderr |   11 +
 .../lint-uppercase-variables.stderr           |   21 +-
 .../expect_lint_from_macro.stderr             |   20 +-
 ...force_warn_expected_lints_fulfilled.stderr |   12 +-
 .../lint/unused/issue-117284-arg-in-macro.rs  |    4 +-
 .../unused/issue-117284-arg-in-macro.stderr   |    7 +-
 ...0-unused-variable-in-struct-pattern.stderr |   68 +-
 .../issue-54180-unused-ref-field.stderr       |   12 +-
 .../lint/unused/lint-unused-variables.stderr  |   22 +-
 tests/ui/liveness/liveness-asm.stderr         |    8 +-
 tests/ui/liveness/liveness-consts.rs          |    6 +-
 tests/ui/liveness/liveness-consts.stderr      |   42 +-
 tests/ui/liveness/liveness-dead.stderr        |   12 +-
 tests/ui/liveness/liveness-unused.rs          |  113 +-
 tests/ui/liveness/liveness-unused.stderr      |  199 +-
 tests/ui/liveness/liveness-upvars.rs          |   47 +-
 tests/ui/liveness/liveness-upvars.stderr      |  147 +-
 ...ject-lifetime-default-default-to-static.rs |    2 +-
 ...object-lifetime-default-from-ref-struct.rs |    2 +-
 .../object-lifetime-default-from-rptr-box.rs  |    2 +-
 .../object-lifetime-default-from-rptr-mut.rs  |    2 +-
 ...bject-lifetime-default-from-rptr-struct.rs |    2 +-
 .../object-lifetime-default-from-rptr.rs      |    2 +-
 .../object-lifetime-default-inferred.rs       |    2 +-
 tests/ui/or-patterns/binding-typo-2.stderr    |  114 +-
 tests/ui/packed/packed-struct-drop-aligned.rs |    2 +
 tests/ui/parser/intersection-patterns-1.fixed |    1 +
 tests/ui/parser/intersection-patterns-1.rs    |    1 +
 .../ui/parser/intersection-patterns-1.stderr  |    4 +-
 .../pattern/bindings-after-at/bind-by-copy.rs |    5 +
 .../bindings-after-at/bind-by-copy.stderr     |   39 +
 ...arly-return-with-unreachable-code-24353.rs |    1 +
 ...-return-with-unreachable-code-24353.stderr |   10 +
 .../rfc-2005-default-binding-mode/general.rs  |    1 +
 .../general.stderr                            |   11 +
 .../std-panic-locations.default.stderr        |   11 +
 .../std-panic-locations.mir-opt.stderr        |   11 +
 .../std-panic-locations.rs                    |    1 +
 .../param-attrs-cfg.stderr                    |   24 +-
 .../ui/suggestions/try-removing-the-field.rs  |    4 +-
 .../suggestions/try-removing-the-field.stderr |    8 +-
 .../unused-closure-argument.stderr            |   12 +-
 tests/ui/type/issue-100584.stderr             |    4 +-
 tests/ui/type/type-ascription.rs              |    5 +-
 .../unboxed-closures-counter-not-moved.rs     |    5 +-
 .../unboxed-closures-counter-not-moved.stderr |   24 +-
 .../unboxed-closures-move-mutable.rs          |   10 +-
 .../unboxed-closures-move-mutable.stderr      |   42 +-
 88 files changed, 2540 insertions(+), 2709 deletions(-)
 create mode 100644 compiler/rustc_mir_transform/src/liveness.rs
 delete mode 100644 compiler/rustc_passes/src/liveness.rs
 delete mode 100644 compiler/rustc_passes/src/liveness/rwu_table.rs
 create mode 100644 tests/ui/lint/issue-49588-non-shorthand-field-patterns-in-pattern-macro.stderr
 create mode 100644 tests/ui/pattern/bindings-after-at/bind-by-copy.stderr
 create mode 100644 tests/ui/return/early-return-with-unreachable-code-24353.stderr
 create mode 100644 tests/ui/rfcs/rfc-2005-default-binding-mode/general.stderr
 create mode 100644 tests/ui/rfcs/rfc-2091-track-caller/std-panic-locations.default.stderr
 create mode 100644 tests/ui/rfcs/rfc-2091-track-caller/std-panic-locations.mir-opt.stderr

diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs
index c1bba0b01975e..a41d6b858795c 100644
--- a/compiler/rustc_interface/src/passes.rs
+++ b/compiler/rustc_interface/src/passes.rs
@@ -1095,6 +1095,7 @@ fn run_required_analyses(tcx: TyCtxt<'_>) {
                 tcx.ensure_ok().check_transmutes(def_id);
             }
             tcx.ensure_ok().has_ffi_unwind_calls(def_id);
+            tcx.ensure_ok().check_liveness(def_id);
 
             // If we need to codegen, ensure that we emit all errors from
             // `mir_drops_elaborated_and_const_checked` now, to avoid discovering
diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs
index afc5b9992e28c..f2d2d567beee4 100644
--- a/compiler/rustc_middle/src/mir/mod.rs
+++ b/compiler/rustc_middle/src/mir/mod.rs
@@ -894,7 +894,7 @@ pub enum BindingForm<'tcx> {
     /// Binding for a `self`/`&self`/`&mut self` binding where the type is implicit.
     ImplicitSelf(ImplicitSelfKind),
     /// Reference used in a guard expression to ensure immutability.
-    RefForGuard,
+    RefForGuard(Local),
 }
 
 #[derive(Clone, Debug, TyEncodable, TyDecodable, HashStable)]
@@ -917,7 +917,7 @@ mod binding_form_impl {
             match self {
                 Var(binding) => binding.hash_stable(hcx, hasher),
                 ImplicitSelf(kind) => kind.hash_stable(hcx, hasher),
-                RefForGuard => (),
+                RefForGuard(local) => local.hash_stable(hcx, hasher),
             }
         }
     }
@@ -1129,7 +1129,7 @@ impl<'tcx> LocalDecl<'tcx> {
     /// expression that is used to access said variable for the guard of the
     /// match arm.
     pub fn is_ref_for_guard(&self) -> bool {
-        matches!(self.local_info(), LocalInfo::User(BindingForm::RefForGuard))
+        matches!(self.local_info(), LocalInfo::User(BindingForm::RefForGuard(_)))
     }
 
     /// Returns `Some` if this is a reference to a static item that is used to
diff --git a/compiler/rustc_middle/src/mir/statement.rs b/compiler/rustc_middle/src/mir/statement.rs
index 74c39afbbc823..91a528678901b 100644
--- a/compiler/rustc_middle/src/mir/statement.rs
+++ b/compiler/rustc_middle/src/mir/statement.rs
@@ -259,7 +259,7 @@ impl<'tcx> PlaceTy<'tcx> {
 impl<V, T> ProjectionElem<V, T> {
     /// Returns `true` if the target of this projection may refer to a different region of memory
     /// than the base.
-    fn is_indirect(&self) -> bool {
+    pub fn is_indirect(&self) -> bool {
         match self {
             Self::Deref => true,
 
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 895c8c0295a04..c6dfcb20e5605 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -1195,8 +1195,10 @@ rustc_queries! {
         desc { |tcx| "checking privacy in {}", describe_as_module(key.to_local_def_id(), tcx) }
     }
 
-    query check_liveness(key: LocalDefId) {
-        desc { |tcx| "checking liveness of variables in `{}`", tcx.def_path_str(key) }
+    query check_liveness(key: LocalDefId) -> &'tcx rustc_index::bit_set::DenseBitSet<abi::FieldIdx> {
+        arena_cache
+        desc { |tcx| "checking liveness of variables in `{}`", tcx.def_path_str(key.to_def_id()) }
+        cache_on_disk_if(tcx) { tcx.is_typeck_child(key.to_def_id()) }
     }
 
     /// Return the live symbols in the crate for dead code check.
diff --git a/compiler/rustc_middle/src/ty/closure.rs b/compiler/rustc_middle/src/ty/closure.rs
index b8c7d6cf3b134..ce6f87668beff 100644
--- a/compiler/rustc_middle/src/ty/closure.rs
+++ b/compiler/rustc_middle/src/ty/closure.rs
@@ -327,6 +327,11 @@ pub fn place_to_string_for_capture<'tcx>(tcx: TyCtxt<'tcx>, place: &HirPlace<'tc
                     )
                 }
             },
+            HirProjectionKind::UnwrapUnsafeBinder => {
+                curr_string = format!("unwrap_binder!({curr_string})");
+            }
+            // Just change the type to the hidden type, so we can actually project.
+            HirProjectionKind::OpaqueCast => {}
             proj => bug!("{:?} unexpected because it isn't captured", proj),
         }
     }
diff --git a/compiler/rustc_mir_build/src/builder/matches/mod.rs b/compiler/rustc_mir_build/src/builder/matches/mod.rs
index 165fb4b6517d5..926a3eb018ff0 100644
--- a/compiler/rustc_mir_build/src/builder/matches/mod.rs
+++ b/compiler/rustc_mir_build/src/builder/matches/mod.rs
@@ -2864,7 +2864,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 user_ty: None,
                 source_info,
                 local_info: ClearCrossCrate::Set(Box::new(LocalInfo::User(
-                    BindingForm::RefForGuard,
+                    BindingForm::RefForGuard(for_arm_body),
                 ))),
             });
             if self.should_emit_debug_info_for_binding(name, var_id) {
diff --git a/compiler/rustc_mir_build/src/builder/mod.rs b/compiler/rustc_mir_build/src/builder/mod.rs
index f2c153578433f..7ce2abaf804a9 100644
--- a/compiler/rustc_mir_build/src/builder/mod.rs
+++ b/compiler/rustc_mir_build/src/builder/mod.rs
@@ -69,11 +69,6 @@ pub fn build_mir<'tcx>(tcx: TyCtxt<'tcx>, def: LocalDefId) -> Body<'tcx> {
                 }
             };
 
-            // Checking liveness after building the THIR ensures there were no typeck errors.
-            //
-            // maybe move the check to a MIR pass?
-            tcx.ensure_ok().check_liveness(def);
-
             // Don't steal here, instead steal in unsafeck. This is so that
             // pattern inline constants can be evaluated as part of building the
             // THIR of the parent function without a cycle.
diff --git a/compiler/rustc_mir_transform/messages.ftl b/compiler/rustc_mir_transform/messages.ftl
index 2e08f50e8a9aa..e8d29c414edca 100644
--- a/compiler/rustc_mir_transform/messages.ftl
+++ b/compiler/rustc_mir_transform/messages.ftl
@@ -34,12 +34,16 @@ mir_transform_force_inline_attr =
 mir_transform_force_inline_justification =
     `{$callee}` is required to be inlined to: {$sym}
 
+mir_transform_maybe_string_interpolation = you might have meant to use string interpolation in this string literal
+
 mir_transform_must_not_suspend = {$pre}`{$def_path}`{$post} held across a suspend point, but should not be
     .label = the value is held across this suspend point
     .note = {$reason}
     .help = consider using a block (`{"{ ... }"}`) to shrink the value's scope, ending before the suspend point
 mir_transform_operation_will_panic = this operation will panic at runtime
 
+mir_transform_string_interpolation_only_works = string interpolation only works in `format!` invocations
+
 mir_transform_tail_expr_drop_order = relative drop order changing in Rust 2024
     .temporaries = in Rust 2024, this temporary value will be dropped first
     .observers = in Rust 2024, this local variable or temporary value will be dropped second
@@ -77,3 +81,26 @@ mir_transform_unconditional_recursion = function cannot return without recursing
 mir_transform_unconditional_recursion_call_site_label = recursive call site
 
 mir_transform_unknown_pass_name = MIR pass `{$name}` is unknown and will be ignored
+
+mir_transform_unused_assign = value assigned to `{$name}` is never read
+    .help = maybe it is overwritten before being read?
+
+mir_transform_unused_assign_passed = value passed to `{$name}` is never read
+    .help = maybe it is overwritten before being read?
+
+mir_transform_unused_assign_suggestion =
+    you might have meant to mutate the pointed at value being passed in, instead of changing the reference in the local binding
+
+mir_transform_unused_capture_maybe_capture_ref = value captured by `{$name}` is never read
+    .help = did you mean to capture by reference instead?
+
+mir_transform_unused_var_assigned_only = variable `{$name}` is assigned to, but never used
+    .note = consider using `_{$name}` instead
+
+mir_transform_unused_var_underscore = if this is intentional, prefix it with an underscore
+
+mir_transform_unused_variable = unused variable: `{$name}`
+
+mir_transform_unused_variable_args_in_macro = `{$name}` is captured in macro and introduced a unused variable
+
+mir_transform_unused_variable_try_ignore = try ignoring the field
diff --git a/compiler/rustc_mir_transform/src/errors.rs b/compiler/rustc_mir_transform/src/errors.rs
index 775f5f9a7cf10..87430b8225b61 100644
--- a/compiler/rustc_mir_transform/src/errors.rs
+++ b/compiler/rustc_mir_transform/src/errors.rs
@@ -1,5 +1,5 @@
 use rustc_errors::codes::*;
-use rustc_errors::{Diag, LintDiagnostic};
+use rustc_errors::{Applicability, Diag, EmissionGuarantee, LintDiagnostic, Subdiagnostic};
 use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
 use rustc_middle::mir::AssertKind;
 use rustc_middle::query::Key;
@@ -158,6 +158,114 @@ pub(crate) struct FnItemRef {
     pub ident: Ident,
 }
 
+#[derive(LintDiagnostic)]
+#[diag(mir_transform_unused_capture_maybe_capture_ref)]
+#[help]
+pub(crate) struct UnusedCaptureMaybeCaptureRef {
+    pub name: Symbol,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(mir_transform_unused_var_assigned_only)]
+#[note]
+pub(crate) struct UnusedVarAssignedOnly {
+    pub name: Symbol,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(mir_transform_unused_assign)]
+pub(crate) struct UnusedAssign {
+    pub name: Symbol,
+    #[subdiagnostic]
+    pub suggestion: Option<UnusedAssignSuggestion>,
+    #[help]
+    pub help: bool,
+}
+
+#[derive(Subdiagnostic)]
+#[multipart_suggestion(mir_transform_unused_assign_suggestion, applicability = "maybe-incorrect")]
+pub(crate) struct UnusedAssignSuggestion {
+    pub pre: &'static str,
+    #[suggestion_part(code = "{pre}mut ")]
+    pub ty_span: Option<Span>,
+    #[suggestion_part(code = "")]
+    pub ty_ref_span: Span,
+    #[suggestion_part(code = "*")]
+    pub pre_lhs_span: Span,
+    #[suggestion_part(code = "")]
+    pub rhs_borrow_span: Span,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(mir_transform_unused_assign_passed)]
+#[help]
+pub(crate) struct UnusedAssignPassed {
+    pub name: Symbol,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(mir_transform_unused_variable)]
+pub(crate) struct UnusedVariable {
+    pub name: Symbol,
+    #[subdiagnostic]
+    pub string_interp: Vec<UnusedVariableStringInterp>,
+    #[subdiagnostic]
+    pub sugg: UnusedVariableSugg,
+}
+
+#[derive(Subdiagnostic)]
+pub(crate) enum UnusedVariableSugg {
+    #[multipart_suggestion(
+        mir_transform_unused_variable_try_ignore,
+        applicability = "machine-applicable"
+    )]
+    TryIgnore {
+        #[suggestion_part(code = "{name}: _")]
+        shorthands: Vec<Span>,
+        #[suggestion_part(code = "_")]
+        non_shorthands: Vec<Span>,
+        name: Symbol,
+    },
+
+    #[multipart_suggestion(
+        mir_transform_unused_var_underscore,
+        applicability = "machine-applicable"
+    )]
+    TryPrefix {
+        #[suggestion_part(code = "_{name}")]
+        spans: Vec<Span>,
+        name: Symbol,
+    },
+
+    #[help(mir_transform_unused_variable_args_in_macro)]
+    NoSugg {
+        #[primary_span]
+        span: Span,
+        name: Symbol,
+    },
+}
+
+pub(crate) struct UnusedVariableStringInterp {
+    pub lit: Span,
+}
+
+impl Subdiagnostic for UnusedVariableStringInterp {
+    fn add_to_diag<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>) {
+        diag.span_label(
+            self.lit,
+            crate::fluent_generated::mir_transform_maybe_string_interpolation,
+        );
+        diag.multipart_suggestion(
+            crate::fluent_generated::mir_transform_string_interpolation_only_works,
+            vec![
+                (self.lit.shrink_to_lo(), String::from("format!(")),
+                (self.lit.shrink_to_hi(), String::from(")")),
+            ],
+            Applicability::MachineApplicable,
+        );
+    }
+}
+
 pub(crate) struct MustNotSupend<'a, 'tcx> {
     pub tcx: TyCtxt<'tcx>,
     pub yield_sp: Span,
diff --git a/compiler/rustc_mir_transform/src/lib.rs b/compiler/rustc_mir_transform/src/lib.rs
index f4f61c80a220a..fb1036c282845 100644
--- a/compiler/rustc_mir_transform/src/lib.rs
+++ b/compiler/rustc_mir_transform/src/lib.rs
@@ -51,6 +51,7 @@ mod errors;
 mod ffi_unwind_calls;
 mod lint;
 mod lint_tail_expr_drop_order;
+mod liveness;
 mod patch;
 mod shim;
 mod ssa;
@@ -215,6 +216,7 @@ pub fn provide(providers: &mut Providers) {
         mir_for_ctfe,
         mir_coroutine_witnesses: coroutine::mir_coroutine_witnesses,
         optimized_mir,
+        check_liveness: liveness::check_liveness,
         is_mir_available,
         is_ctfe_mir_available: is_mir_available,
         mir_callgraph_cyclic: inline::cycle::mir_callgraph_cyclic,
@@ -512,6 +514,8 @@ fn mir_drops_elaborated_and_const_checked(tcx: TyCtxt<'_>, def: LocalDefId) -> &
         }
     }
 
+    tcx.ensure_done().check_liveness(def);
+
     let (body, _) = tcx.mir_promoted(def);
     let mut body = body.steal();
 
diff --git a/compiler/rustc_mir_transform/src/liveness.rs b/compiler/rustc_mir_transform/src/liveness.rs
new file mode 100644
index 0000000000000..83b50e7be61b1
--- /dev/null
+++ b/compiler/rustc_mir_transform/src/liveness.rs
@@ -0,0 +1,1328 @@
+use rustc_abi::FieldIdx;
+use rustc_data_structures::fx::{FxHashSet, FxIndexMap, IndexEntry};
+use rustc_hir::attrs::AttributeKind;
+use rustc_hir::def::DefKind;
+use rustc_hir::def_id::LocalDefId;
+use rustc_hir::find_attr;
+use rustc_index::IndexVec;
+use rustc_index::bit_set::DenseBitSet;
+use rustc_middle::bug;
+use rustc_middle::mir::visit::{
+    MutatingUseContext, NonMutatingUseContext, NonUseContext, PlaceContext, Visitor,
+};
+use rustc_middle::mir::*;
+use rustc_middle::ty::{self, Ty, TyCtxt};
+use rustc_mir_dataflow::fmt::DebugWithContext;
+use rustc_mir_dataflow::{Analysis, Backward, ResultsCursor};
+use rustc_session::lint;
+use rustc_span::Span;
+use rustc_span::symbol::{Symbol, kw, sym};
+
+use crate::errors;
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+enum AccessKind {
+    Param,
+    Assign,
+    Capture,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+enum CaptureKind {
+    Closure(ty::ClosureKind),
+    Coroutine,
+    CoroutineClosure,
+    None,
+}
+
+#[derive(Copy, Clone, Debug)]
+struct Access {
+    /// Describe the current access.
+    kind: AccessKind,
+    /// Is the accessed place is live at the current statement?
+    /// When we encounter multiple statements at the same location, we only increase the liveness,
+    /// in order to avoid false positives.
+    live: bool,
+}
+
+#[tracing::instrument(level = "debug", skip(tcx), ret)]
+pub(crate) fn check_liveness<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> DenseBitSet<FieldIdx> {
+    // Don't run on synthetic MIR, as that will ICE trying to access HIR.
+    if tcx.is_synthetic_mir(def_id) {
+        return DenseBitSet::new_empty(0);
+    }
+
+    // Don't run unused pass for intrinsics
+    if tcx.intrinsic(def_id.to_def_id()).is_some() {
+        return DenseBitSet::new_empty(0);
+    }
+
+    // Don't run unused pass for #[naked]
+    if find_attr!(tcx.get_all_attrs(def_id.to_def_id()), AttributeKind::Naked(..)) {
+        return DenseBitSet::new_empty(0);
+    }
+
+    // Don't run unused pass for #[derive]
+    let parent = tcx.parent(tcx.typeck_root_def_id(def_id.to_def_id()));
+    if let DefKind::Impl { of_trait: true } = tcx.def_kind(parent)
+        && find_attr!(tcx.get_all_attrs(parent), AttributeKind::AutomaticallyDerived(..))
+    {
+        return DenseBitSet::new_empty(0);
+    }
+
+    let mut body = &*tcx.mir_promoted(def_id).0.borrow();
+    let mut body_mem;
+
+    // Don't run if there are errors.
+    if body.tainted_by_errors.is_some() {
+        return DenseBitSet::new_empty(0);
+    }
+
+    let mut checked_places = PlaceSet::default();
+    checked_places.insert_locals(&body.local_decls);
+
+    // The body is the one of a closure or generator, so we also want to analyse captures.
+    let (capture_kind, num_captures) = if tcx.is_closure_like(def_id.to_def_id()) {
+        let mut self_ty = body.local_decls[ty::CAPTURE_STRUCT_LOCAL].ty;
+        let mut self_is_ref = false;
+        if let ty::Ref(_, ty, _) = self_ty.kind() {
+            self_ty = *ty;
+            self_is_ref = true;
+        }
+
+        let (capture_kind, args) = match self_ty.kind() {
+            ty::Closure(_, args) => {
+                (CaptureKind::Closure(args.as_closure().kind()), ty::UpvarArgs::Closure(args))
+            }
+            &ty::Coroutine(_, args) => (CaptureKind::Coroutine, ty::UpvarArgs::Coroutine(args)),
+            &ty::CoroutineClosure(_, args) => {
+                (CaptureKind::CoroutineClosure, ty::UpvarArgs::CoroutineClosure(args))
+            }
+            _ => bug!("expected closure or generator, found {:?}", self_ty),
+        };
+
+        let captures = tcx.closure_captures(def_id);
+        checked_places.insert_captures(tcx, self_is_ref, captures, args.upvar_tys());
+
+        // `FnMut` closures can modify captured values and carry those
+        // modified values with them in subsequent calls. To model this behaviour,
+        // we consider the `FnMut` closure as jumping to `bb0` upon return.
+        if let CaptureKind::Closure(ty::ClosureKind::FnMut) = capture_kind {
+            // FIXME: stop cloning the body.
+            body_mem = body.clone();
+            for bbdata in body_mem.basic_blocks_mut() {
+                // We can call a closure again, either after a normal return or an unwind.
+                if let TerminatorKind::Return | TerminatorKind::UnwindResume =
+                    bbdata.terminator().kind
+                {
+                    bbdata.terminator_mut().kind = TerminatorKind::Goto { target: START_BLOCK };
+                }
+            }
+            body = &body_mem;
+        }
+
+        (capture_kind, args.upvar_tys().len())
+    } else {
+        (CaptureKind::None, 0)
+    };
+
+    // Get the remaining variables' names from debuginfo.
+    checked_places.record_debuginfo(&body.var_debug_info);
+
+    let self_assignment = find_self_assignments(&checked_places, body);
+
+    let mut live =
+        MaybeLivePlaces { tcx, capture_kind, checked_places: &checked_places, self_assignment }
+            .iterate_to_fixpoint(tcx, body, None)
+            .into_results_cursor(body);
+
+    let typing_env = ty::TypingEnv::post_analysis(tcx, body.source.def_id());
+
+    let mut assignments =
+        AssignmentResult::find_dead_assignments(tcx, typing_env, &checked_places, &mut live, body);
+
+    assignments.merge_guards();
+
+    let dead_captures = assignments.compute_dead_captures(num_captures);
+
+    assignments.report_fully_unused();
+    assignments.report_unused_assignments();
+
+    dead_captures
+}
+
+/// Small helper to make semantics easier to read.
+#[inline]
+fn is_capture(place: PlaceRef<'_>) -> bool {
+    if !place.projection.is_empty() {
+        debug_assert_eq!(place.local, ty::CAPTURE_STRUCT_LOCAL);
+        true
+    } else {
+        false
+    }
+}
+
+/// Give a diagnostic when any of the string constants look like a naked format string that would
+/// interpolate our dead local.
+fn maybe_suggest_literal_matching_name(
+    body: &Body<'_>,
+    name: Symbol,
+) -> Vec<errors::UnusedVariableStringInterp> {
+    struct LiteralFinder<'body, 'tcx> {
+        body: &'body Body<'tcx>,
+        name: String,
+        name_colon: String,
+        found: Vec<errors::UnusedVariableStringInterp>,
+    }
+
+    impl<'tcx> Visitor<'tcx> for LiteralFinder<'_, 'tcx> {
+        fn visit_const_operand(&mut self, constant: &ConstOperand<'tcx>, loc: Location) {
+            if let ty::Ref(_, ref_ty, _) = constant.ty().kind()
+                && ref_ty.kind() == &ty::Str
+            {
+                let rendered_constant = constant.const_.to_string();
+                if rendered_constant.contains(&self.name)
+                    || rendered_constant.contains(&self.name_colon)
+                {
+                    let lit = self.body.source_info(loc).span;
+                    self.found.push(errors::UnusedVariableStringInterp { lit });
+                }
+            }
+        }
+    }
+
+    let mut finder = LiteralFinder {
+        body,
+        name: format!("{{{name}}}"),
+        name_colon: format!("{{{name}:"),
+        found: vec![],
+    };
+    finder.visit_body(body);
+    finder.found
+}
+
+/// Return whether we should consider the current place as a drop guard and skip reporting.
+fn maybe_drop_guard<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    typing_env: ty::TypingEnv<'tcx>,
+    index: PlaceIndex,
+    ever_dropped: &DenseBitSet<PlaceIndex>,
+    checked_places: &PlaceSet<'tcx>,
+    body: &Body<'tcx>,
+) -> bool {
+    if ever_dropped.contains(index) {
+        let ty = checked_places.places[index].ty(&body.local_decls, tcx).ty;
+        matches!(
+            ty.kind(),
+            ty::Closure(..)
+                | ty::Coroutine(..)
+                | ty::Tuple(..)
+                | ty::Adt(..)
+                | ty::Dynamic(..)
+                | ty::Array(..)
+                | ty::Slice(..)
+                | ty::Alias(ty::Opaque, ..)
+        ) && ty.needs_drop(tcx, typing_env)
+    } else {
+        false
+    }
+}
+
+/// Detect the following case
+///
+/// ```text
+/// fn change_object(mut a: &Ty) {
+///     let a = Ty::new();
+///     b = &a;
+/// }
+/// ```
+///
+/// where the user likely meant to modify the value behind there reference, use `a` as an out
+/// parameter, instead of mutating the local binding. When encountering this we suggest:
+///
+/// ```text
+/// fn change_object(a: &'_ mut Ty) {
+///     let a = Ty::new();
+///     *b = a;
+/// }
+/// ```
+fn annotate_mut_binding_to_immutable_binding<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    place: PlaceRef<'tcx>,
+    body_def_id: LocalDefId,
+    assignment_span: Span,
+    body: &Body<'tcx>,
+) -> Option<errors::UnusedAssignSuggestion> {
+    use rustc_hir as hir;
+    use rustc_hir::intravisit::{self, Visitor};
+
+    // Verify we have a mutable argument...
+    let local = place.as_local()?;
+    let LocalKind::Arg = body.local_kind(local) else { return None };
+    let Mutability::Mut = body.local_decls[local].mutability else { return None };
+
+    // ... with reference type...
+    let hir_param_index =
+        local.as_usize() - if tcx.is_closure_like(body_def_id.to_def_id()) { 2 } else { 1 };
+    let fn_decl = tcx.hir_node_by_def_id(body_def_id).fn_decl()?;
+    let ty = fn_decl.inputs[hir_param_index];
+    let hir::TyKind::Ref(lt, mut_ty) = ty.kind else { return None };
+
+    // ... as a binding pattern.
+    let hir_body = tcx.hir_maybe_body_owned_by(body_def_id)?;
+    let param = hir_body.params[hir_param_index];
+    let hir::PatKind::Binding(hir::BindingMode::MUT, _hir_id, ident, _) = param.pat.kind else {
+        return None;
+    };
+
+    // Find the assignment to modify.
+    let mut finder = ExprFinder { assignment_span, lhs: None, rhs: None };
+    finder.visit_body(hir_body);
+    let lhs = finder.lhs?;
+    let rhs = finder.rhs?;
+
+    let hir::ExprKind::AddrOf(hir::BorrowKind::Ref, _mut, inner) = rhs.kind else { return None };
+
+    // Changes to the parameter's type.
+    let pre = if lt.ident.span.is_empty() { "" } else { " " };
+    let ty_span = if mut_ty.mutbl.is_mut() {
+        // Leave `&'name mut Ty` and `&mut Ty` as they are (#136028).
+        None
+    } else {
+        // `&'name Ty` -> `&'name mut Ty` or `&Ty` -> `&mut Ty`
+        Some(mut_ty.ty.span.shrink_to_lo())
+    };
+
+    return Some(errors::UnusedAssignSuggestion {
+        ty_span,
+        pre,
+        // Span of the `mut` before the binding.
+        ty_ref_span: param.pat.span.until(ident.span),
+        // Where to add a `*`.
+        pre_lhs_span: lhs.span.shrink_to_lo(),
+        // Where to remove the borrow.
+        rhs_borrow_span: rhs.span.until(inner.span),
+    });
+
+    #[derive(Debug)]
+    struct ExprFinder<'hir> {
+        assignment_span: Span,
+        lhs: Option<&'hir hir::Expr<'hir>>,
+        rhs: Option<&'hir hir::Expr<'hir>>,
+    }
+    impl<'hir> Visitor<'hir> for ExprFinder<'hir> {
+        fn visit_expr(&mut self, expr: &'hir hir::Expr<'hir>) {
+            if expr.span == self.assignment_span
+                && let hir::ExprKind::Assign(lhs, rhs, _) = expr.kind
+            {
+                self.lhs = Some(lhs);
+                self.rhs = Some(rhs);
+            } else {
+                intravisit::walk_expr(self, expr)
+            }
+        }
+    }
+}
+
+/// Compute self-assignments of the form `a += b`.
+///
+/// MIR building generates 2 statements and 1 terminator for such assignments:
+/// - _temp = CheckedBinaryOp(a, b)
+/// - assert(!_temp.1)
+/// - a = _temp.0
+///
+/// This function tries to detect this pattern in order to avoid marking statement as a definition
+/// and use. This will let the analysis be dictated by the next use of `a`.
+///
+/// Note that we will still need to account for the use of `b`.
+fn find_self_assignments<'tcx>(
+    checked_places: &PlaceSet<'tcx>,
+    body: &Body<'tcx>,
+) -> FxHashSet<Location> {
+    let mut self_assign = FxHashSet::default();
+
+    const FIELD_0: FieldIdx = FieldIdx::from_u32(0);
+    const FIELD_1: FieldIdx = FieldIdx::from_u32(1);
+
+    for (bb, bb_data) in body.basic_blocks.iter_enumerated() {
+        for (statement_index, stmt) in bb_data.statements.iter().enumerate() {
+            let StatementKind::Assign(box (first_place, rvalue)) = &stmt.kind else { continue };
+            match rvalue {
+                // For checked binary ops, the MIR builder inserts an assertion in between.
+                Rvalue::BinaryOp(
+                    BinOp::AddWithOverflow | BinOp::SubWithOverflow | BinOp::MulWithOverflow,
+                    box (Operand::Copy(lhs), _),
+                ) => {
+                    // Checked binary ops only appear at the end of the block, before the assertion.
+                    if statement_index + 1 != bb_data.statements.len() {
+                        continue;
+                    }
+
+                    let TerminatorKind::Assert {
+                        cond,
+                        target,
+                        msg: box AssertKind::Overflow(..),
+                        ..
+                    } = &bb_data.terminator().kind
+                    else {
+                        continue;
+                    };
+                    let Some(assign) = body.basic_blocks[*target].statements.first() else {
+                        continue;
+                    };
+                    let StatementKind::Assign(box (dest, Rvalue::Use(Operand::Move(temp)))) =
+                        assign.kind
+                    else {
+                        continue;
+                    };
+
+                    if dest != *lhs {
+                        continue;
+                    }
+
+                    let Operand::Move(cond) = cond else { continue };
+                    let [PlaceElem::Field(FIELD_0, _)] = &temp.projection.as_slice() else {
+                        continue;
+                    };
+                    let [PlaceElem::Field(FIELD_1, _)] = &cond.projection.as_slice() else {
+                        continue;
+                    };
+
+                    // We ignore indirect self-assignment, because both occurrences of `dest` are uses.
+                    let is_indirect = checked_places
+                        .get(dest.as_ref())
+                        .map_or(false, |(_, projections)| is_indirect(projections));
+                    if is_indirect {
+                        continue;
+                    }
+
+                    if first_place.local == temp.local
+                        && first_place.local == cond.local
+                        && first_place.projection.is_empty()
+                    {
+                        // Original block
+                        self_assign.insert(Location {
+                            block: bb,
+                            statement_index: bb_data.statements.len() - 1,
+                        });
+                        self_assign.insert(Location {
+                            block: bb,
+                            statement_index: bb_data.statements.len(),
+                        });
+                        // Target block
+                        self_assign.insert(Location { block: *target, statement_index: 0 });
+                    }
+                }
+                // Straight self-assignment.
+                Rvalue::BinaryOp(op, box (Operand::Copy(lhs), _)) => {
+                    if lhs != first_place {
+                        continue;
+                    }
+
+                    // We ignore indirect self-assignment, because both occurrences of `dest` are uses.
+                    let is_indirect = checked_places
+                        .get(first_place.as_ref())
+                        .map_or(false, |(_, projections)| is_indirect(projections));
+                    if is_indirect {
+                        continue;
+                    }
+
+                    self_assign.insert(Location { block: bb, statement_index });
+
+                    // Checked division verifies overflow before performing the division, so we
+                    // need to go and ignore this check in the predecessor block.
+                    if let BinOp::Div | BinOp::Rem = op
+                        && statement_index == 0
+                        && let &[pred] = body.basic_blocks.predecessors()[bb].as_slice()
+                        && let TerminatorKind::Assert { msg, .. } =
+                            &body.basic_blocks[pred].terminator().kind
+                        && let AssertKind::Overflow(..) = **msg
+                        && let len = body.basic_blocks[pred].statements.len()
+                        && len >= 2
+                    {
+                        // BitAnd of two checks.
+                        self_assign.insert(Location { block: pred, statement_index: len - 1 });
+                        // `lhs == MIN`.
+                        self_assign.insert(Location { block: pred, statement_index: len - 2 });
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+
+    self_assign
+}
+
+#[derive(Default, Debug)]
+struct PlaceSet<'tcx> {
+    places: IndexVec<PlaceIndex, PlaceRef<'tcx>>,
+    names: IndexVec<PlaceIndex, Option<(Symbol, Span)>>,
+
+    /// Places corresponding to locals, common case.
+    locals: IndexVec<Local, Option<PlaceIndex>>,
+
+    // Handling of captures.
+    /// If `_1` is a reference, we need to add a `Deref` to the matched place.
+    capture_field_pos: usize,
+    /// Captured fields.
+    captures: IndexVec<FieldIdx, (PlaceIndex, bool)>,
+}
+
+impl<'tcx> PlaceSet<'tcx> {
+    fn insert_locals(&mut self, decls: &IndexVec<Local, LocalDecl<'tcx>>) {
+        self.locals = IndexVec::from_elem(None, &decls);
+        for (local, decl) in decls.iter_enumerated() {
+            // Record all user-written locals for the analysis.
+            // We also keep the `RefForGuard` locals (more on that below).
+            if let LocalInfo::User(BindingForm::Var(_) | BindingForm::RefForGuard(_)) =
+                decl.local_info()
+            {
+                let index = self.places.push(local.into());
+                self.locals[local] = Some(index);
+                let _index = self.names.push(None);
+                debug_assert_eq!(index, _index);
+            }
+        }
+    }
+
+    fn insert_captures(
+        &mut self,
+        tcx: TyCtxt<'tcx>,
+        self_is_ref: bool,
+        captures: &[&'tcx ty::CapturedPlace<'tcx>],
+        upvars: &ty::List<Ty<'tcx>>,
+    ) {
+        // We should not track the environment local separately.
+        debug_assert_eq!(self.locals[ty::CAPTURE_STRUCT_LOCAL], None);
+
+        let self_place = Place {
+            local: ty::CAPTURE_STRUCT_LOCAL,
+            projection: tcx.mk_place_elems(if self_is_ref { &[PlaceElem::Deref] } else { &[] }),
+        };
+        if self_is_ref {
+            self.capture_field_pos = 1;
+        }
+
+        for (f, (capture, ty)) in std::iter::zip(captures, upvars).enumerate() {
+            let f = FieldIdx::from_usize(f);
+            let elem = PlaceElem::Field(f, ty);
+            let by_ref = matches!(capture.info.capture_kind, ty::UpvarCapture::ByRef(..));
+            let place = if by_ref {
+                self_place.project_deeper(&[elem, PlaceElem::Deref], tcx)
+            } else {
+                self_place.project_deeper(&[elem], tcx)
+            };
+            let index = self.places.push(place.as_ref());
+            let _f = self.captures.push((index, by_ref));
+            debug_assert_eq!(_f, f);
+
+            // Record a variable name from the capture, because it is much friendlier than the
+            // debuginfo name.
+            self.names.insert(
+                index,
+                (Symbol::intern(&capture.to_string(tcx)), capture.get_path_span(tcx)),
+            );
+        }
+    }
+
+    fn record_debuginfo(&mut self, var_debug_info: &Vec<VarDebugInfo<'tcx>>) {
+        let ignore_name = |name: Symbol| {
+            name == sym::empty || name == kw::SelfLower || name.as_str().starts_with('_')
+        };
+        for var_debug_info in var_debug_info {
+            if let VarDebugInfoContents::Place(place) = var_debug_info.value
+                && let Some(index) = self.locals[place.local]
+                && !ignore_name(var_debug_info.name)
+            {
+                self.names.get_or_insert_with(index, || {
+                    (var_debug_info.name, var_debug_info.source_info.span)
+                });
+            }
+        }
+
+        // Discard places that will not result in a diagnostic.
+        for index_opt in self.locals.iter_mut() {
+            if let Some(index) = *index_opt {
+                let remove = match self.names[index] {
+                    None => true,
+                    Some((name, _)) => ignore_name(name),
+                };
+                if remove {
+                    *index_opt = None;
+                }
+            }
+        }
+    }
+
+    #[inline]
+    fn get(&self, place: PlaceRef<'tcx>) -> Option<(PlaceIndex, &'tcx [PlaceElem<'tcx>])> {
+        if let Some(index) = self.locals[place.local] {
+            return Some((index, place.projection));
+        }
+        if place.local == ty::CAPTURE_STRUCT_LOCAL
+            && !self.captures.is_empty()
+            && self.capture_field_pos < place.projection.len()
+            && let PlaceElem::Field(f, _) = place.projection[self.capture_field_pos]
+            && let Some((index, by_ref)) = self.captures.get(f)
+        {
+            let mut start = self.capture_field_pos + 1;
+            if *by_ref {
+                // Account for an extra Deref.
+                start += 1;
+            }
+            // We may have an attempt to access `_1.f` as a shallow reborrow. Just ignore it.
+            if start <= place.projection.len() {
+                let projection = &place.projection[start..];
+                return Some((*index, projection));
+            }
+        }
+        None
+    }
+
+    fn iter(&self) -> impl Iterator<Item = (PlaceIndex, &PlaceRef<'tcx>)> {
+        self.places.iter_enumerated()
+    }
+
+    fn len(&self) -> usize {
+        self.places.len()
+    }
+}
+
+struct AssignmentResult<'a, 'tcx> {
+    tcx: TyCtxt<'tcx>,
+    typing_env: ty::TypingEnv<'tcx>,
+    checked_places: &'a PlaceSet<'tcx>,
+    body: &'a Body<'tcx>,
+    /// Set of locals that are live at least once. This is used to report fully unused locals.
+    ever_live: DenseBitSet<PlaceIndex>,
+    /// Set of locals that have a non-trivial drop. This is used to skip reporting unused
+    /// assignment if it would be used by the `Drop` impl.
+    ever_dropped: DenseBitSet<PlaceIndex>,
+    /// Set of assignments for each local. Here, assignment is understood in the AST sense. Any
+    /// MIR that may look like an assignment (Assign, DropAndReplace, Yield, Call) are considered.
+    ///
+    /// For each local, we return a map: for each source position, whether the statement is live
+    /// and which kind of access it performs. When we encounter multiple statements at the same
+    /// location, we only increase the liveness, in order to avoid false positives.
+    assignments: IndexVec<PlaceIndex, FxIndexMap<SourceInfo, Access>>,
+}
+
+impl<'a, 'tcx> AssignmentResult<'a, 'tcx> {
+    /// Collect all assignments to checked locals.
+    ///
+    /// Assignments are collected, even if they are live. Dead assignments are reported, and live
+    /// assignments are used to make diagnostics correct for match guards.
+    fn find_dead_assignments(
+        tcx: TyCtxt<'tcx>,
+        typing_env: ty::TypingEnv<'tcx>,
+        checked_places: &'a PlaceSet<'tcx>,
+        cursor: &mut ResultsCursor<'_, 'tcx, MaybeLivePlaces<'_, 'tcx>>,
+        body: &'a Body<'tcx>,
+    ) -> AssignmentResult<'a, 'tcx> {
+        let mut ever_live = DenseBitSet::new_empty(checked_places.len());
+        let mut ever_dropped = DenseBitSet::new_empty(checked_places.len());
+        let mut assignments = IndexVec::<PlaceIndex, FxIndexMap<_, _>>::from_elem(
+            Default::default(),
+            &checked_places.places,
+        );
+
+        let mut check_place =
+            |place: Place<'tcx>, kind, source_info: SourceInfo, live: &DenseBitSet<PlaceIndex>| {
+                if let Some((index, extra_projections)) = checked_places.get(place.as_ref()) {
+                    if !is_indirect(extra_projections) {
+                        match assignments[index].entry(source_info) {
+                            IndexEntry::Vacant(v) => {
+                                let access = Access { kind, live: live.contains(index) };
+                                v.insert(access);
+                            }
+                            IndexEntry::Occupied(mut o) => {
+                                // There were already a sighting. Mark this statement as live if it
+                                // was, to avoid false positives.
+                                o.get_mut().live |= live.contains(index);
+                            }
+                        }
+                    }
+                }
+            };
+
+        let mut record_drop = |place: Place<'tcx>| {
+            if let Some((index, &[])) = checked_places.get(place.as_ref()) {
+                ever_dropped.insert(index);
+            }
+        };
+
+        for (bb, bb_data) in traversal::postorder(body) {
+            cursor.seek_to_block_end(bb);
+            let live = cursor.get();
+            ever_live.union(live);
+
+            let terminator = bb_data.terminator();
+            match &terminator.kind {
+                TerminatorKind::Call { destination: place, .. }
+                | TerminatorKind::Yield { resume_arg: place, .. } => {
+                    check_place(*place, AccessKind::Assign, terminator.source_info, live);
+                    record_drop(*place)
+                }
+                TerminatorKind::Drop { place, .. } => record_drop(*place),
+                TerminatorKind::InlineAsm { operands, .. } => {
+                    for operand in operands {
+                        if let InlineAsmOperand::Out { place: Some(place), .. }
+                        | InlineAsmOperand::InOut { out_place: Some(place), .. } = operand
+                        {
+                            check_place(*place, AccessKind::Assign, terminator.source_info, live);
+                        }
+                    }
+                }
+                _ => {}
+            }
+
+            for (statement_index, statement) in bb_data.statements.iter().enumerate().rev() {
+                cursor.seek_before_primary_effect(Location { block: bb, statement_index });
+                let live = cursor.get();
+                ever_live.union(live);
+                match &statement.kind {
+                    StatementKind::Assign(box (place, _))
+                    | StatementKind::Deinit(box place)
+                    | StatementKind::SetDiscriminant { box place, .. } => {
+                        check_place(*place, AccessKind::Assign, statement.source_info, live);
+                    }
+                    StatementKind::Retag(_, _)
+                    | StatementKind::StorageLive(_)
+                    | StatementKind::StorageDead(_)
+                    | StatementKind::Coverage(_)
+                    | StatementKind::Intrinsic(_)
+                    | StatementKind::Nop
+                    | StatementKind::FakeRead(_)
+                    | StatementKind::PlaceMention(_)
+                    | StatementKind::ConstEvalCounter
+                    | StatementKind::BackwardIncompatibleDropHint { .. }
+                    | StatementKind::AscribeUserType(_, _) => (),
+                }
+            }
+        }
+
+        // Check liveness of function arguments on entry.
+        {
+            cursor.seek_to_block_start(START_BLOCK);
+            let live = cursor.get();
+            ever_live.union(live);
+
+            // Verify that arguments and captured values are useful.
+            for (index, place) in checked_places.iter() {
+                let kind = if is_capture(*place) {
+                    // This is a by-ref capture, an assignment to it will modify surrounding
+                    // environment, so we do not report it.
+                    if place.projection.last() == Some(&PlaceElem::Deref) {
+                        continue;
+                    }
+
+                    AccessKind::Capture
+                } else if body.local_kind(place.local) == LocalKind::Arg {
+                    AccessKind::Param
+                } else {
+                    continue;
+                };
+                let source_info = body.local_decls[place.local].source_info;
+                let access = Access { kind, live: live.contains(index) };
+                assignments[index].insert(source_info, access);
+            }
+        }
+
+        AssignmentResult {
+            tcx,
+            typing_env,
+            checked_places,
+            ever_live,
+            ever_dropped,
+            assignments,
+            body,
+        }
+    }
+
+    /// Match guards introduce a different local to freeze the guarded value as immutable.
+    /// Having two locals, we need to make sure that we do not report an unused_variable
+    /// when the guard local is used but not the arm local, or vice versa, like in this example.
+    ///
+    ///    match 5 {
+    ///      x if x > 2 => {}
+    ///      ^    ^- This is `local`
+    ///      +------ This is `arm_local`
+    ///      _ => {}
+    ///    }
+    ///
+    fn merge_guards(&mut self) {
+        for (index, place) in self.checked_places.iter() {
+            let local = place.local;
+            if let &LocalInfo::User(BindingForm::RefForGuard(arm_local)) =
+                self.body.local_decls[local].local_info()
+            {
+                debug_assert!(place.projection.is_empty());
+
+                // Local to use in the arm.
+                let Some((arm_index, _proj)) = self.checked_places.get(arm_local.into()) else {
+                    continue;
+                };
+                debug_assert_ne!(index, arm_index);
+                debug_assert_eq!(_proj, &[]);
+
+                // Mark the arm local as used if the guard local is used.
+                if self.ever_live.contains(index) {
+                    self.ever_live.insert(arm_index);
+                }
+
+                // Some assignments are common to both locals in the source code.
+                // Sadly, we can only detect this using the `source_info`.
+                // Therefore, we loop over all the assignments we have for the guard local:
+                // - if they already appeared for the arm local, the assignment is live if one of the
+                //   two versions is live;
+                // - if it does not appear for the arm local, it happened inside the guard, so we add
+                //   it as-is.
+                let guard_assignments = std::mem::take(&mut self.assignments[index]);
+                let arm_assignments = &mut self.assignments[arm_index];
+                for (source_info, access) in guard_assignments {
+                    match arm_assignments.entry(source_info) {
+                        IndexEntry::Vacant(v) => {
+                            v.insert(access);
+                        }
+                        IndexEntry::Occupied(mut o) => {
+                            o.get_mut().live |= access.live;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /// Compute captures that are fully dead.
+    fn compute_dead_captures(&self, num_captures: usize) -> DenseBitSet<FieldIdx> {
+        // Report to caller the set of dead captures.
+        let mut dead_captures = DenseBitSet::new_empty(num_captures);
+        for (index, place) in self.checked_places.iter() {
+            if self.ever_live.contains(index) {
+                continue;
+            }
+
+            // This is a capture: pass information to the enclosing function.
+            if is_capture(*place) {
+                for p in place.projection {
+                    if let PlaceElem::Field(f, _) = p {
+                        dead_captures.insert(*f);
+                        break;
+                    }
+                }
+                continue;
+            }
+        }
+
+        dead_captures
+    }
+
+    /// Report fully unused locals, and forget the corresponding assignments.
+    fn report_fully_unused(&mut self) {
+        let tcx = self.tcx;
+
+        // First, report fully unused locals.
+        for (index, place) in self.checked_places.iter() {
+            if self.ever_live.contains(index) {
+                continue;
+            }
+
+            // this is a capture: let the enclosing function report the unused variable.
+            if is_capture(*place) {
+                continue;
+            }
+
+            let local = place.local;
+            let decl = &self.body.local_decls[local];
+
+            if decl.from_compiler_desugaring() {
+                continue;
+            }
+
+            // Only report actual user-defined binding from now on.
+            let LocalInfo::User(BindingForm::Var(binding)) = decl.local_info() else { continue };
+            let Some(hir_id) = decl.source_info.scope.lint_root(&self.body.source_scopes) else {
+                continue;
+            };
+
+            let introductions = &binding.introductions;
+
+            let Some((name, def_span)) = self.checked_places.names[index] else { continue };
+
+            // #117284, when `ident_span` and `def_span` have different contexts
+            // we can't provide a good suggestion, instead we pointed out the spans from macro
+            let from_macro = def_span.from_expansion()
+                && introductions.iter().any(|intro| intro.span.eq_ctxt(def_span));
+
+            let statements = &mut self.assignments[index];
+            if statements.is_empty() {
+                let sugg = if from_macro {
+                    errors::UnusedVariableSugg::NoSugg { span: def_span, name }
+                } else {
+                    errors::UnusedVariableSugg::TryPrefix { spans: vec![def_span], name }
+                };
+                tcx.emit_node_span_lint(
+                    lint::builtin::UNUSED_VARIABLES,
+                    hir_id,
+                    def_span,
+                    errors::UnusedVariable {
+                        name,
+                        string_interp: maybe_suggest_literal_matching_name(self.body, name),
+                        sugg,
+                    },
+                );
+                continue;
+            }
+
+            // Idiomatic rust assigns a value to a local upon definition. However, we do not want to
+            // warn twice, for the unused local and for the unused assignment. Therefore, we remove
+            // from the list of assignments the ones that happen at the definition site.
+            statements.retain(|source_info, _| {
+                source_info.span.find_ancestor_inside(binding.pat_span).is_none()
+            });
+
+            // Extra assignments that we recognize thanks to the initialization span. We need to
+            // take care of macro contexts here to be accurate.
+            if let Some((_, initializer_span)) = binding.opt_match_place {
+                statements.retain(|source_info, _| {
+                    let within = source_info.span.find_ancestor_inside(initializer_span);
+                    let outer_initializer_span =
+                        initializer_span.find_ancestor_in_same_ctxt(source_info.span);
+                    within.is_none()
+                        && outer_initializer_span.map_or(true, |s| !s.contains(source_info.span))
+                });
+            }
+
+            if !statements.is_empty() {
+                // We have a dead local with outstanding assignments and with non-trivial drop.
+                // This is probably a drop-guard, so we do not issue a warning there.
+                if maybe_drop_guard(
+                    tcx,
+                    self.typing_env,
+                    index,
+                    &self.ever_dropped,
+                    self.checked_places,
+                    self.body,
+                ) {
+                    statements.clear();
+                    continue;
+                }
+
+                tcx.emit_node_span_lint(
+                    lint::builtin::UNUSED_VARIABLES,
+                    hir_id,
+                    def_span,
+                    errors::UnusedVarAssignedOnly { name },
+                );
+                continue;
+            }
+
+            // We do not have outstanding assignments, suggest renaming the binding.
+            let spans = introductions.iter().map(|intro| intro.span).collect::<Vec<_>>();
+
+            let any_shorthand = introductions.iter().any(|intro| intro.is_shorthand);
+
+            let sugg = if any_shorthand {
+                errors::UnusedVariableSugg::TryIgnore {
+                    name,
+                    shorthands: introductions
+                        .iter()
+                        .filter_map(
+                            |intro| if intro.is_shorthand { Some(intro.span) } else { None },
+                        )
+                        .collect(),
+                    non_shorthands: introductions
+                        .iter()
+                        .filter_map(
+                            |intro| {
+                                if !intro.is_shorthand { Some(intro.span) } else { None }
+                            },
+                        )
+                        .collect(),
+                }
+            } else if from_macro {
+                errors::UnusedVariableSugg::NoSugg { span: def_span, name }
+            } else if !introductions.is_empty() {
+                errors::UnusedVariableSugg::TryPrefix { name, spans: spans.clone() }
+            } else {
+                errors::UnusedVariableSugg::TryPrefix { name, spans: vec![def_span] }
+            };
+
+            tcx.emit_node_span_lint(
+                lint::builtin::UNUSED_VARIABLES,
+                hir_id,
+                spans,
+                errors::UnusedVariable {
+                    name,
+                    string_interp: maybe_suggest_literal_matching_name(self.body, name),
+                    sugg,
+                },
+            );
+        }
+    }
+
+    /// Second, report unused assignments that do not correspond to initialization.
+    /// Initializations have been removed in the previous loop reporting unused variables.
+    fn report_unused_assignments(self) {
+        let tcx = self.tcx;
+
+        for (index, statements) in self.assignments.into_iter_enumerated() {
+            if statements.is_empty() {
+                continue;
+            }
+
+            let Some((name, decl_span)) = self.checked_places.names[index] else { continue };
+
+            // We have outstanding assignments and with non-trivial drop.
+            // This is probably a drop-guard, so we do not issue a warning there.
+            if maybe_drop_guard(
+                tcx,
+                self.typing_env,
+                index,
+                &self.ever_dropped,
+                self.checked_places,
+                self.body,
+            ) {
+                continue;
+            }
+
+            // We probed MIR in reverse order for dataflow.
+            // We revert the vector to give a consistent order to the user.
+            for (source_info, Access { live, kind }) in statements.into_iter().rev() {
+                if live {
+                    continue;
+                }
+
+                // Report the dead assignment.
+                let Some(hir_id) = source_info.scope.lint_root(&self.body.source_scopes) else {
+                    continue;
+                };
+
+                match kind {
+                    AccessKind::Assign => {
+                        let suggestion = annotate_mut_binding_to_immutable_binding(
+                            tcx,
+                            self.checked_places.places[index],
+                            self.body.source.def_id().expect_local(),
+                            source_info.span,
+                            self.body,
+                        );
+                        tcx.emit_node_span_lint(
+                            lint::builtin::UNUSED_ASSIGNMENTS,
+                            hir_id,
+                            source_info.span,
+                            errors::UnusedAssign { name, help: suggestion.is_none(), suggestion },
+                        )
+                    }
+                    AccessKind::Param => tcx.emit_node_span_lint(
+                        lint::builtin::UNUSED_ASSIGNMENTS,
+                        hir_id,
+                        source_info.span,
+                        errors::UnusedAssignPassed { name },
+                    ),
+                    AccessKind::Capture => tcx.emit_node_span_lint(
+                        lint::builtin::UNUSED_ASSIGNMENTS,
+                        hir_id,
+                        decl_span,
+                        errors::UnusedCaptureMaybeCaptureRef { name },
+                    ),
+                }
+            }
+        }
+    }
+}
+
+rustc_index::newtype_index! {
+    pub struct PlaceIndex {}
+}
+
+impl DebugWithContext<MaybeLivePlaces<'_, '_>> for PlaceIndex {
+    fn fmt_with(
+        &self,
+        ctxt: &MaybeLivePlaces<'_, '_>,
+        f: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
+        std::fmt::Debug::fmt(&ctxt.checked_places.places[*self], f)
+    }
+}
+
+pub struct MaybeLivePlaces<'a, 'tcx> {
+    tcx: TyCtxt<'tcx>,
+    checked_places: &'a PlaceSet<'tcx>,
+    capture_kind: CaptureKind,
+    self_assignment: FxHashSet<Location>,
+}
+
+impl<'tcx> MaybeLivePlaces<'_, 'tcx> {
+    fn transfer_function<'a>(
+        &'a self,
+        trans: &'a mut DenseBitSet<PlaceIndex>,
+    ) -> TransferFunction<'a, 'tcx> {
+        TransferFunction {
+            tcx: self.tcx,
+            checked_places: &self.checked_places,
+            capture_kind: self.capture_kind,
+            trans,
+            self_assignment: &self.self_assignment,
+        }
+    }
+}
+
+impl<'tcx> Analysis<'tcx> for MaybeLivePlaces<'_, 'tcx> {
+    type Domain = DenseBitSet<PlaceIndex>;
+    type Direction = Backward;
+
+    const NAME: &'static str = "liveness-lint";
+
+    fn bottom_value(&self, _: &Body<'tcx>) -> Self::Domain {
+        // bottom = not live
+        DenseBitSet::new_empty(self.checked_places.len())
+    }
+
+    fn initialize_start_block(&self, _: &Body<'tcx>, _: &mut Self::Domain) {
+        // No variables are live until we observe a use
+    }
+
+    fn apply_primary_statement_effect(
+        &mut self,
+        trans: &mut Self::Domain,
+        statement: &Statement<'tcx>,
+        location: Location,
+    ) {
+        self.transfer_function(trans).visit_statement(statement, location);
+    }
+
+    fn apply_primary_terminator_effect<'mir>(
+        &mut self,
+        trans: &mut Self::Domain,
+        terminator: &'mir Terminator<'tcx>,
+        location: Location,
+    ) -> TerminatorEdges<'mir, 'tcx> {
+        self.transfer_function(trans).visit_terminator(terminator, location);
+        terminator.edges()
+    }
+
+    fn apply_call_return_effect(
+        &mut self,
+        _trans: &mut Self::Domain,
+        _block: BasicBlock,
+        _return_places: CallReturnPlaces<'_, 'tcx>,
+    ) {
+        // FIXME: what should happen here?
+    }
+}
+
+struct TransferFunction<'a, 'tcx> {
+    tcx: TyCtxt<'tcx>,
+    checked_places: &'a PlaceSet<'tcx>,
+    trans: &'a mut DenseBitSet<PlaceIndex>,
+    capture_kind: CaptureKind,
+    self_assignment: &'a FxHashSet<Location>,
+}
+
+impl<'tcx> Visitor<'tcx> for TransferFunction<'_, 'tcx> {
+    fn visit_statement(&mut self, statement: &Statement<'tcx>, location: Location) {
+        match statement.kind {
+            // `ForLet(None)` fake read erroneously marks the just-assigned local as live.
+            // This defeats the purpose of the analysis for `let` bindings.
+            StatementKind::FakeRead(box (FakeReadCause::ForLet(None), _)) => return,
+            // Handle self-assignment by restricting the read/write they do.
+            StatementKind::Assign(box (ref dest, ref rvalue))
+                if self.self_assignment.contains(&location) =>
+            {
+                if let Rvalue::BinaryOp(
+                    BinOp::AddWithOverflow | BinOp::SubWithOverflow | BinOp::MulWithOverflow,
+                    box (_, rhs),
+                ) = rvalue
+                {
+                    // We are computing the binary operation:
+                    // - the LHS will be assigned, so we don't read it;
+                    // - the RHS still needs to be read.
+                    self.visit_operand(rhs, location);
+                    self.visit_place(
+                        dest,
+                        PlaceContext::MutatingUse(MutatingUseContext::Store),
+                        location,
+                    );
+                } else if let Rvalue::BinaryOp(_, box (_, rhs)) = rvalue {
+                    // We are computing the binary operation:
+                    // - the LHS is being updated, so we don't read it;
+                    // - the RHS still needs to be read.
+                    self.visit_operand(rhs, location);
+                } else {
+                    // This is the second part of a checked self-assignment,
+                    // we are assigning the result.
+                    // We do not consider the write to the destination as a `def`.
+                    // `self_assignment` must be false if the assignment is indirect.
+                    self.visit_rvalue(rvalue, location);
+                }
+            }
+            _ => self.super_statement(statement, location),
+        }
+    }
+
+    fn visit_terminator(&mut self, terminator: &Terminator<'tcx>, location: Location) {
+        // By-ref captures could be read by the surrounding environment, so we mark
+        // them as live upon yield and return.
+        match terminator.kind {
+            TerminatorKind::Return
+            | TerminatorKind::Yield { .. }
+            | TerminatorKind::Goto { target: START_BLOCK } // Inserted for the `FnMut` case.
+                if self.capture_kind != CaptureKind::None =>
+            {
+                // All indirect captures have an effect on the environment, so we mark them as live.
+                for (index, place) in self.checked_places.iter() {
+                    if place.local == ty::CAPTURE_STRUCT_LOCAL
+                        && place.projection.last() == Some(&PlaceElem::Deref)
+                    {
+                        self.trans.insert(index);
+                    }
+                }
+            }
+            // Do not consider a drop to be a use. We whitelist interesting drops elsewhere.
+            TerminatorKind::Drop { .. } => {}
+            // Ignore assertions since they must be triggered by actual code.
+            TerminatorKind::Assert { .. } => {}
+            _ => self.super_terminator(terminator, location),
+        }
+    }
+
+    fn visit_rvalue(&mut self, rvalue: &Rvalue<'tcx>, location: Location) {
+        match rvalue {
+            // When a closure/generator does not use some of its captures, do not consider these
+            // captures as live in the surrounding function. This allows to report unused variables,
+            // even if they have been (uselessly) captured.
+            Rvalue::Aggregate(
+                box AggregateKind::Closure(def_id, _) | box AggregateKind::Coroutine(def_id, _),
+                operands,
+            ) => {
+                if let Some(def_id) = def_id.as_local() {
+                    let dead_captures = self.tcx.check_liveness(def_id);
+                    for (field, operand) in
+                        operands.iter_enumerated().take(dead_captures.domain_size())
+                    {
+                        if !dead_captures.contains(field) {
+                            self.visit_operand(operand, location);
+                        }
+                    }
+                }
+            }
+            _ => self.super_rvalue(rvalue, location),
+        }
+    }
+
+    fn visit_place(&mut self, place: &Place<'tcx>, context: PlaceContext, location: Location) {
+        if let Some((index, extra_projections)) = self.checked_places.get(place.as_ref()) {
+            for i in (extra_projections.len()..=place.projection.len()).rev() {
+                let place_part =
+                    PlaceRef { local: place.local, projection: &place.projection[..i] };
+                let extra_projections = &place.projection[i..];
+
+                if let Some(&elem) = extra_projections.get(0) {
+                    self.visit_projection_elem(place_part, elem, context, location);
+                }
+            }
+
+            match DefUse::for_place(extra_projections, context) {
+                Some(DefUse::Def) => {
+                    self.trans.remove(index);
+                }
+                Some(DefUse::Use) => {
+                    self.trans.insert(index);
+                }
+                None => {}
+            }
+        } else {
+            self.super_place(place, context, location)
+        }
+    }
+
+    fn visit_local(&mut self, local: Local, context: PlaceContext, _: Location) {
+        if let Some((index, _proj)) = self.checked_places.get(local.into()) {
+            debug_assert_eq!(_proj, &[]);
+            match DefUse::for_place(&[], context) {
+                Some(DefUse::Def) => {
+                    self.trans.remove(index);
+                }
+                Some(DefUse::Use) => {
+                    self.trans.insert(index);
+                }
+                _ => {}
+            }
+        }
+    }
+}
+
+#[derive(Eq, PartialEq, Debug, Clone)]
+enum DefUse {
+    Def,
+    Use,
+}
+
+fn is_indirect(proj: &[PlaceElem<'_>]) -> bool {
+    proj.iter().any(|p| p.is_indirect())
+}
+
+impl DefUse {
+    fn for_place<'tcx>(projection: &[PlaceElem<'tcx>], context: PlaceContext) -> Option<DefUse> {
+        let is_indirect = is_indirect(projection);
+        match context {
+            PlaceContext::MutatingUse(
+                MutatingUseContext::Store
+                | MutatingUseContext::Deinit
+                | MutatingUseContext::SetDiscriminant,
+            ) => {
+                if is_indirect {
+                    // Treat derefs as a use of the base local. `*p = 4` is not a def of `p` but a
+                    // use.
+                    Some(DefUse::Use)
+                } else if projection.is_empty() {
+                    Some(DefUse::Def)
+                } else {
+                    None
+                }
+            }
+
+            // For the associated terminators, this is only a `Def` when the terminator returns
+            // "successfully." As such, we handle this case separately in `call_return_effect`
+            // above. However, if the place looks like `*_5`, this is still unconditionally a use of
+            // `_5`.
+            PlaceContext::MutatingUse(
+                MutatingUseContext::Call
+                | MutatingUseContext::Yield
+                | MutatingUseContext::AsmOutput,
+            ) => is_indirect.then_some(DefUse::Use),
+
+            // All other contexts are uses...
+            PlaceContext::MutatingUse(
+                MutatingUseContext::RawBorrow
+                | MutatingUseContext::Borrow
+                | MutatingUseContext::Drop
+                | MutatingUseContext::Retag,
+            )
+            | PlaceContext::NonMutatingUse(
+                NonMutatingUseContext::RawBorrow
+                | NonMutatingUseContext::Copy
+                | NonMutatingUseContext::Inspect
+                | NonMutatingUseContext::Move
+                | NonMutatingUseContext::FakeBorrow
+                | NonMutatingUseContext::SharedBorrow
+                | NonMutatingUseContext::PlaceMention,
+            ) => Some(DefUse::Use),
+
+            PlaceContext::NonUse(
+                NonUseContext::StorageLive
+                | NonUseContext::StorageDead
+                | NonUseContext::AscribeUserTy(_)
+                | NonUseContext::BackwardIncompatibleDropHint
+                | NonUseContext::VarDebugInfo,
+            ) => None,
+
+            PlaceContext::MutatingUse(MutatingUseContext::Projection)
+            | PlaceContext::NonMutatingUse(NonMutatingUseContext::Projection) => {
+                unreachable!("A projection could be a def or a use and must be handled separately")
+            }
+        }
+    }
+}
diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index be9843988669a..dc956b9f3169b 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -395,8 +395,6 @@ passes_macro_only_attribute =
 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]`, `#[rustc_const_stable]` and `#[rustc_const_stable_indirect]` require the function or method to be `const`
     .help = make the function or method const
@@ -568,8 +566,6 @@ passes_should_be_applied_to_trait =
     attribute should be applied to a trait
     .label = not a trait
 
-passes_string_interpolation_only_works = string interpolation only works in `format!` invocations
-
 passes_trait_impl_const_stability_mismatch = const stability on the impl does not match the const stability on the trait
 passes_trait_impl_const_stability_mismatch_impl_stable = this impl is (implicitly) stable...
 passes_trait_impl_const_stability_mismatch_impl_unstable = this impl is unstable...
@@ -636,18 +632,6 @@ passes_unused =
     unused attribute
     .suggestion = remove this attribute
 
-passes_unused_assign = value assigned to `{$name}` is never read
-    .help = maybe it is overwritten before being read?
-
-passes_unused_assign_passed = value passed to `{$name}` is never read
-    .help = maybe it is overwritten before being read?
-
-passes_unused_assign_suggestion =
-    you might have meant to mutate the pointed at value being passed in, instead of changing the reference in the local binding
-
-passes_unused_capture_maybe_capture_ref = value captured by `{$name}` is never read
-    .help = did you mean to capture by reference instead?
-
 passes_unused_default_method_body_const_note =
     `default_method_body_is_const` has been replaced with `const` on traits
 
@@ -671,25 +655,6 @@ passes_unused_multiple =
 passes_unused_no_lints_note =
     attribute `{$name}` without any lints has no effect
 
-passes_unused_var_assigned_only = variable `{$name}` is assigned to, but never used
-    .note = consider using `_{$name}` instead
-
-passes_unused_var_maybe_capture_ref = unused variable: `{$name}`
-    .help = did you mean to capture by reference instead?
-
-passes_unused_var_remove_field = unused variable: `{$name}`
-passes_unused_var_remove_field_suggestion = try removing the field
-passes_unused_var_typo = you might have meant to pattern match on the similarly named {$kind} `{$item_name}`
-
-passes_unused_variable_args_in_macro = `{$name}` is captured in macro and introduced a unused variable
-
-passes_unused_variable_try_ignore = unused variable: `{$name}`
-    .suggestion = try ignoring the field
-
-passes_unused_variable_try_prefix = unused variable: `{$name}`
-    .label = unused variable
-    .suggestion = if this is intentional, prefix it with an underscore
-
 passes_useless_assignment =
     useless assignment of {$is_field_assign ->
         [true] field
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index 8ca0641c4dd25..7d184d8bb694c 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -4,7 +4,7 @@ use std::path::{Path, PathBuf};
 use rustc_errors::codes::*;
 use rustc_errors::{
     Applicability, Diag, DiagCtxtHandle, DiagSymbolList, Diagnostic, EmissionGuarantee, Level,
-    MultiSpan, Subdiagnostic,
+    MultiSpan,
 };
 use rustc_hir::Target;
 use rustc_hir::attrs::{MirDialect, MirPhase};
@@ -1308,61 +1308,6 @@ pub(crate) struct ProcMacroBadSig {
     pub kind: ProcMacroKind,
 }
 
-#[derive(LintDiagnostic)]
-#[diag(passes_unused_var_maybe_capture_ref)]
-#[help]
-pub(crate) struct UnusedVarMaybeCaptureRef {
-    pub name: String,
-}
-
-#[derive(LintDiagnostic)]
-#[diag(passes_unused_capture_maybe_capture_ref)]
-#[help]
-pub(crate) struct UnusedCaptureMaybeCaptureRef {
-    pub name: String,
-}
-
-#[derive(LintDiagnostic)]
-#[diag(passes_unused_var_remove_field)]
-pub(crate) struct UnusedVarRemoveField {
-    pub name: String,
-    #[subdiagnostic]
-    pub sugg: UnusedVarRemoveFieldSugg,
-}
-
-#[derive(Subdiagnostic)]
-#[multipart_suggestion(
-    passes_unused_var_remove_field_suggestion,
-    applicability = "machine-applicable"
-)]
-pub(crate) struct UnusedVarRemoveFieldSugg {
-    #[suggestion_part(code = "")]
-    pub spans: Vec<Span>,
-}
-
-#[derive(LintDiagnostic)]
-#[diag(passes_unused_var_assigned_only)]
-#[note]
-pub(crate) struct UnusedVarAssignedOnly {
-    pub name: String,
-    #[subdiagnostic]
-    pub typo: Option<PatternTypo>,
-}
-
-#[derive(Subdiagnostic)]
-#[multipart_suggestion(
-    passes_unused_var_typo,
-    style = "verbose",
-    applicability = "maybe-incorrect"
-)]
-pub(crate) struct PatternTypo {
-    #[suggestion_part(code = "{code}")]
-    pub span: Span,
-    pub code: String,
-    pub item_name: String,
-    pub kind: String,
-}
-
 #[derive(LintDiagnostic)]
 #[diag(passes_unnecessary_stable_feature)]
 pub(crate) struct UnnecessaryStableFeature {
@@ -1387,102 +1332,6 @@ pub(crate) struct UnnecessaryPartialStableFeature {
 #[note]
 pub(crate) struct IneffectiveUnstableImpl;
 
-#[derive(LintDiagnostic)]
-#[diag(passes_unused_assign)]
-pub(crate) struct UnusedAssign {
-    pub name: String,
-    #[subdiagnostic]
-    pub suggestion: Option<UnusedAssignSuggestion>,
-    #[help]
-    pub help: bool,
-}
-
-#[derive(Subdiagnostic)]
-#[multipart_suggestion(passes_unused_assign_suggestion, applicability = "maybe-incorrect")]
-pub(crate) struct UnusedAssignSuggestion {
-    pub pre: &'static str,
-    #[suggestion_part(code = "{pre}mut ")]
-    pub ty_span: Option<Span>,
-    #[suggestion_part(code = "")]
-    pub ty_ref_span: Span,
-    #[suggestion_part(code = "*")]
-    pub ident_span: Span,
-    #[suggestion_part(code = "")]
-    pub expr_ref_span: Span,
-}
-
-#[derive(LintDiagnostic)]
-#[diag(passes_unused_assign_passed)]
-#[help]
-pub(crate) struct UnusedAssignPassed {
-    pub name: String,
-}
-
-#[derive(LintDiagnostic)]
-#[diag(passes_unused_variable_try_prefix)]
-pub(crate) struct UnusedVariableTryPrefix {
-    #[label]
-    pub label: Option<Span>,
-    #[subdiagnostic]
-    pub string_interp: Vec<UnusedVariableStringInterp>,
-    #[subdiagnostic]
-    pub sugg: UnusedVariableSugg,
-    pub name: String,
-    #[subdiagnostic]
-    pub typo: Option<PatternTypo>,
-}
-
-#[derive(Subdiagnostic)]
-pub(crate) enum UnusedVariableSugg {
-    #[multipart_suggestion(passes_suggestion, applicability = "maybe-incorrect")]
-    TryPrefixSugg {
-        #[suggestion_part(code = "_{name}")]
-        spans: Vec<Span>,
-        name: String,
-    },
-    #[help(passes_unused_variable_args_in_macro)]
-    NoSugg {
-        #[primary_span]
-        span: Span,
-        name: String,
-    },
-}
-
-pub(crate) struct UnusedVariableStringInterp {
-    pub lit: Span,
-    pub lo: Span,
-    pub hi: Span,
-}
-
-impl Subdiagnostic for UnusedVariableStringInterp {
-    fn add_to_diag<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>) {
-        diag.span_label(self.lit, crate::fluent_generated::passes_maybe_string_interpolation);
-        diag.multipart_suggestion(
-            crate::fluent_generated::passes_string_interpolation_only_works,
-            vec![(self.lo, String::from("format!(")), (self.hi, String::from(")"))],
-            Applicability::MachineApplicable,
-        );
-    }
-}
-
-#[derive(LintDiagnostic)]
-#[diag(passes_unused_variable_try_ignore)]
-pub(crate) struct UnusedVarTryIgnore {
-    pub name: String,
-    #[subdiagnostic]
-    pub sugg: UnusedVarTryIgnoreSugg,
-}
-
-#[derive(Subdiagnostic)]
-#[multipart_suggestion(passes_suggestion, applicability = "maybe-incorrect")]
-pub(crate) struct UnusedVarTryIgnoreSugg {
-    #[suggestion_part(code = "{name}: _")]
-    pub shorthands: Vec<Span>,
-    #[suggestion_part(code = "_")]
-    pub non_shorthands: Vec<Span>,
-    pub name: String,
-}
-
 #[derive(LintDiagnostic)]
 #[diag(passes_attr_crate_level)]
 #[note]
diff --git a/compiler/rustc_passes/src/lib.rs b/compiler/rustc_passes/src/lib.rs
index 06a127577d432..c98e971185795 100644
--- a/compiler/rustc_passes/src/lib.rs
+++ b/compiler/rustc_passes/src/lib.rs
@@ -28,7 +28,6 @@ pub mod input_stats;
 mod lang_items;
 pub mod layout_test;
 mod lib_features;
-mod liveness;
 mod reachable;
 pub mod stability;
 mod upvars;
@@ -44,7 +43,6 @@ pub fn provide(providers: &mut Providers) {
     entry::provide(providers);
     lang_items::provide(providers);
     lib_features::provide(providers);
-    liveness::provide(providers);
     reachable::provide(providers);
     stability::provide(providers);
     upvars::provide(providers);
diff --git a/compiler/rustc_passes/src/liveness.rs b/compiler/rustc_passes/src/liveness.rs
deleted file mode 100644
index e175ac1c035e1..0000000000000
--- a/compiler/rustc_passes/src/liveness.rs
+++ /dev/null
@@ -1,1853 +0,0 @@
-//! A classic liveness analysis based on dataflow over the AST. Computes,
-//! for each local variable in a function, whether that variable is live
-//! at a given point. Program execution points are identified by their
-//! IDs.
-//!
-//! # Basic idea
-//!
-//! The basic model is that each local variable is assigned an index. We
-//! represent sets of local variables using a vector indexed by this
-//! index. The value in the vector is either 0, indicating the variable
-//! is dead, or the ID of an expression that uses the variable.
-//!
-//! We conceptually walk over the AST in reverse execution order. If we
-//! find a use of a variable, we add it to the set of live variables. If
-//! we find an assignment to a variable, we remove it from the set of live
-//! variables. When we have to merge two flows, we take the union of
-//! those two flows -- if the variable is live on both paths, we simply
-//! pick one ID. In the event of loops, we continue doing this until a
-//! fixed point is reached.
-//!
-//! ## Checking initialization
-//!
-//! At the function entry point, all variables must be dead. If this is
-//! not the case, we can report an error using the ID found in the set of
-//! live variables, which identifies a use of the variable which is not
-//! dominated by an assignment.
-//!
-//! ## Checking moves
-//!
-//! After each explicit move, the variable must be dead.
-//!
-//! ## Computing last uses
-//!
-//! Any use of the variable where the variable is dead afterwards is a
-//! last use.
-//!
-//! # Implementation details
-//!
-//! The actual implementation contains two (nested) walks over the AST.
-//! The outer walk has the job of building up the ir_maps instance for the
-//! enclosing function. On the way down the tree, it identifies those AST
-//! nodes and variable IDs that will be needed for the liveness analysis
-//! and assigns them contiguous IDs. The liveness ID for an AST node is
-//! called a `live_node` (it's a newtype'd `u32`) and the ID for a variable
-//! is called a `variable` (another newtype'd `u32`).
-//!
-//! On the way back up the tree, as we are about to exit from a function
-//! declaration we allocate a `liveness` instance. Now that we know
-//! precisely how many nodes and variables we need, we can allocate all
-//! the various arrays that we will need to precisely the right size. We then
-//! perform the actual propagation on the `liveness` instance.
-//!
-//! This propagation is encoded in the various `propagate_through_*()`
-//! methods. It effectively does a reverse walk of the AST; whenever we
-//! reach a loop node, we iterate until a fixed point is reached.
-//!
-//! ## The `RWU` struct
-//!
-//! At each live node `N`, we track three pieces of information for each
-//! variable `V` (these are encapsulated in the `RWU` struct):
-//!
-//! - `reader`: the `LiveNode` ID of some node which will read the value
-//!    that `V` holds on entry to `N`. Formally: a node `M` such
-//!    that there exists a path `P` from `N` to `M` where `P` does not
-//!    write `V`. If the `reader` is `None`, then the current
-//!    value will never be read (the variable is dead, essentially).
-//!
-//! - `writer`: the `LiveNode` ID of some node which will write the
-//!    variable `V` and which is reachable from `N`. Formally: a node `M`
-//!    such that there exists a path `P` from `N` to `M` and `M` writes
-//!    `V`. If the `writer` is `None`, then there is no writer
-//!    of `V` that follows `N`.
-//!
-//! - `used`: a boolean value indicating whether `V` is *used*. We
-//!   distinguish a *read* from a *use* in that a *use* is some read that
-//!   is not just used to generate a new value. For example, `x += 1` is
-//!   a read but not a use. This is used to generate better warnings.
-//!
-//! ## Special nodes and variables
-//!
-//! We generate various special nodes for various, well, special purposes.
-//! These are described in the `Liveness` struct.
-
-use std::io;
-use std::io::prelude::*;
-use std::rc::Rc;
-
-use rustc_data_structures::fx::FxIndexMap;
-use rustc_hir as hir;
-use rustc_hir::attrs::AttributeKind;
-use rustc_hir::def::*;
-use rustc_hir::def_id::LocalDefId;
-use rustc_hir::intravisit::{self, Visitor};
-use rustc_hir::{Expr, HirId, HirIdMap, HirIdSet, find_attr};
-use rustc_index::IndexVec;
-use rustc_middle::query::Providers;
-use rustc_middle::span_bug;
-use rustc_middle::ty::print::with_no_trimmed_paths;
-use rustc_middle::ty::{self, RootVariableMinCaptureList, TyCtxt};
-use rustc_session::lint;
-use rustc_span::edit_distance::find_best_match_for_name;
-use rustc_span::{BytePos, Span, Symbol};
-use tracing::{debug, instrument};
-
-use self::LiveNodeKind::*;
-use self::VarKind::*;
-use crate::errors;
-
-mod rwu_table;
-
-rustc_index::newtype_index! {
-    #[debug_format = "v({})"]
-    pub struct Variable {}
-}
-
-rustc_index::newtype_index! {
-    #[debug_format = "ln({})"]
-    pub struct LiveNode {}
-}
-
-#[derive(Copy, Clone, PartialEq, Debug)]
-enum LiveNodeKind {
-    UpvarNode(Span),
-    ExprNode(Span, HirId),
-    VarDefNode(Span, HirId),
-    ClosureNode,
-    ExitNode,
-}
-
-fn live_node_kind_to_string(lnk: LiveNodeKind, tcx: TyCtxt<'_>) -> String {
-    let sm = tcx.sess.source_map();
-    match lnk {
-        UpvarNode(s) => format!("Upvar node [{}]", sm.span_to_diagnostic_string(s)),
-        ExprNode(s, _) => format!("Expr node [{}]", sm.span_to_diagnostic_string(s)),
-        VarDefNode(s, _) => format!("Var def node [{}]", sm.span_to_diagnostic_string(s)),
-        ClosureNode => "Closure node".to_owned(),
-        ExitNode => "Exit node".to_owned(),
-    }
-}
-
-fn check_liveness(tcx: TyCtxt<'_>, def_id: LocalDefId) {
-    // Don't run unused pass for #[derive()]
-    let parent = tcx.local_parent(def_id);
-    if let DefKind::Impl { .. } = tcx.def_kind(parent)
-        && find_attr!(tcx.get_all_attrs(parent), AttributeKind::AutomaticallyDerived(..))
-    {
-        return;
-    }
-
-    // Don't run unused pass for #[naked]
-    if find_attr!(tcx.get_all_attrs(def_id.to_def_id()), AttributeKind::Naked(..)) {
-        return;
-    }
-
-    let mut maps = IrMaps::new(tcx);
-    let body = tcx.hir_body_owned_by(def_id);
-    let hir_id = tcx.hir_body_owner(body.id());
-
-    if let Some(upvars) = tcx.upvars_mentioned(def_id) {
-        for &var_hir_id in upvars.keys() {
-            let var_name = tcx.hir_name(var_hir_id);
-            maps.add_variable(Upvar(var_hir_id, var_name));
-        }
-    }
-
-    // gather up the various local variables, significant expressions,
-    // and so forth:
-    maps.visit_body(&body);
-
-    // compute liveness
-    let mut lsets = Liveness::new(&mut maps, def_id);
-    let entry_ln = lsets.compute(&body, hir_id);
-    lsets.log_liveness(entry_ln, body.id().hir_id);
-
-    // check for various error conditions
-    lsets.visit_body(&body);
-    lsets.warn_about_unused_upvars(entry_ln);
-    lsets.warn_about_unused_args(&body, entry_ln);
-}
-
-pub(crate) fn provide(providers: &mut Providers) {
-    *providers = Providers { check_liveness, ..*providers };
-}
-
-// ______________________________________________________________________
-// Creating ir_maps
-//
-// This is the first pass and the one that drives the main
-// computation. It walks up and down the IR once. On the way down,
-// we count for each function the number of variables as well as
-// liveness nodes. A liveness node is basically an expression or
-// capture clause that does something of interest: either it has
-// interesting control flow or it uses/defines a local variable.
-//
-// On the way back up, at each function node we create liveness sets
-// (we now know precisely how big to make our various vectors and so
-// forth) and then do the data-flow propagation to compute the set
-// of live variables at each program point.
-//
-// Finally, we run back over the IR one last time and, using the
-// computed liveness, check various safety conditions. For example,
-// there must be no live nodes at the definition site for a variable
-// unless it has an initializer. Similarly, each non-mutable local
-// variable must not be assigned if there is some successor
-// assignment. And so forth.
-
-struct CaptureInfo {
-    ln: LiveNode,
-    var_hid: HirId,
-}
-
-#[derive(Copy, Clone, Debug)]
-struct LocalInfo {
-    id: HirId,
-    name: Symbol,
-    is_shorthand: bool,
-}
-
-#[derive(Copy, Clone, Debug)]
-enum VarKind {
-    Param(HirId, Symbol),
-    Local(LocalInfo),
-    Upvar(HirId, Symbol),
-}
-
-struct CollectLitsVisitor<'tcx> {
-    lit_exprs: Vec<&'tcx hir::Expr<'tcx>>,
-}
-
-impl<'tcx> Visitor<'tcx> for CollectLitsVisitor<'tcx> {
-    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
-        if let hir::ExprKind::Lit(_) = expr.kind {
-            self.lit_exprs.push(expr);
-        }
-        intravisit::walk_expr(self, expr);
-    }
-}
-
-struct IrMaps<'tcx> {
-    tcx: TyCtxt<'tcx>,
-    live_node_map: HirIdMap<LiveNode>,
-    variable_map: HirIdMap<Variable>,
-    capture_info_map: HirIdMap<Rc<Vec<CaptureInfo>>>,
-    var_kinds: IndexVec<Variable, VarKind>,
-    lnks: IndexVec<LiveNode, LiveNodeKind>,
-}
-
-impl<'tcx> IrMaps<'tcx> {
-    fn new(tcx: TyCtxt<'tcx>) -> IrMaps<'tcx> {
-        IrMaps {
-            tcx,
-            live_node_map: HirIdMap::default(),
-            variable_map: HirIdMap::default(),
-            capture_info_map: Default::default(),
-            var_kinds: IndexVec::new(),
-            lnks: IndexVec::new(),
-        }
-    }
-
-    fn add_live_node(&mut self, lnk: LiveNodeKind) -> LiveNode {
-        let ln = self.lnks.push(lnk);
-
-        debug!("{:?} is of kind {}", ln, live_node_kind_to_string(lnk, self.tcx));
-
-        ln
-    }
-
-    fn add_live_node_for_node(&mut self, hir_id: HirId, lnk: LiveNodeKind) {
-        let ln = self.add_live_node(lnk);
-        self.live_node_map.insert(hir_id, ln);
-
-        debug!("{:?} is node {:?}", ln, hir_id);
-    }
-
-    fn add_variable(&mut self, vk: VarKind) -> Variable {
-        let v = self.var_kinds.push(vk);
-
-        match vk {
-            Local(LocalInfo { id: node_id, .. }) | Param(node_id, _) | Upvar(node_id, _) => {
-                self.variable_map.insert(node_id, v);
-            }
-        }
-
-        debug!("{:?} is {:?}", v, vk);
-
-        v
-    }
-
-    fn variable(&self, hir_id: HirId, span: Span) -> Variable {
-        match self.variable_map.get(&hir_id) {
-            Some(&var) => var,
-            None => {
-                span_bug!(span, "no variable registered for id {:?}", hir_id);
-            }
-        }
-    }
-
-    fn variable_name(&self, var: Variable) -> Symbol {
-        match self.var_kinds[var] {
-            Local(LocalInfo { name, .. }) | Param(_, name) | Upvar(_, name) => name,
-        }
-    }
-
-    fn variable_is_shorthand(&self, var: Variable) -> bool {
-        match self.var_kinds[var] {
-            Local(LocalInfo { is_shorthand, .. }) => is_shorthand,
-            Param(..) | Upvar(..) => false,
-        }
-    }
-
-    fn set_captures(&mut self, hir_id: HirId, cs: Vec<CaptureInfo>) {
-        self.capture_info_map.insert(hir_id, Rc::new(cs));
-    }
-
-    fn collect_shorthand_field_ids(&self, pat: &hir::Pat<'tcx>) -> HirIdSet {
-        // For struct patterns, take note of which fields used shorthand
-        // (`x` rather than `x: x`).
-        let mut shorthand_field_ids = HirIdSet::default();
-
-        pat.walk_always(|pat| {
-            if let hir::PatKind::Struct(_, fields, _) = pat.kind {
-                let short = fields.iter().filter(|f| f.is_shorthand);
-                shorthand_field_ids.extend(short.map(|f| f.pat.hir_id));
-            }
-        });
-
-        shorthand_field_ids
-    }
-
-    fn add_from_pat(&mut self, pat: &hir::Pat<'tcx>) {
-        let shorthand_field_ids = self.collect_shorthand_field_ids(pat);
-
-        pat.each_binding(|_, hir_id, _, ident| {
-            self.add_live_node_for_node(hir_id, VarDefNode(ident.span, hir_id));
-            self.add_variable(Local(LocalInfo {
-                id: hir_id,
-                name: ident.name,
-                is_shorthand: shorthand_field_ids.contains(&hir_id),
-            }));
-        });
-    }
-}
-
-impl<'tcx> Visitor<'tcx> for IrMaps<'tcx> {
-    fn visit_local(&mut self, local: &'tcx hir::LetStmt<'tcx>) {
-        self.add_from_pat(local.pat);
-        if local.els.is_some() {
-            self.add_live_node_for_node(local.hir_id, ExprNode(local.span, local.hir_id));
-        }
-        intravisit::walk_local(self, local);
-    }
-
-    fn visit_arm(&mut self, arm: &'tcx hir::Arm<'tcx>) {
-        self.add_from_pat(&arm.pat);
-        intravisit::walk_arm(self, arm);
-    }
-
-    fn visit_param(&mut self, param: &'tcx hir::Param<'tcx>) {
-        let shorthand_field_ids = self.collect_shorthand_field_ids(param.pat);
-        param.pat.each_binding(|_bm, hir_id, _x, ident| {
-            let var = match param.pat.kind {
-                rustc_hir::PatKind::Struct(..) => Local(LocalInfo {
-                    id: hir_id,
-                    name: ident.name,
-                    is_shorthand: shorthand_field_ids.contains(&hir_id),
-                }),
-                _ => Param(hir_id, ident.name),
-            };
-            self.add_variable(var);
-        });
-        intravisit::walk_param(self, param);
-    }
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
-        match expr.kind {
-            // live nodes required for uses or definitions of variables:
-            hir::ExprKind::Path(hir::QPath::Resolved(_, path)) => {
-                debug!("expr {}: path that leads to {:?}", expr.hir_id, path.res);
-                if let Res::Local(_var_hir_id) = path.res {
-                    self.add_live_node_for_node(expr.hir_id, ExprNode(expr.span, expr.hir_id));
-                }
-            }
-            hir::ExprKind::Closure(closure) => {
-                // Interesting control flow (for loops can contain labeled
-                // breaks or continues)
-                self.add_live_node_for_node(expr.hir_id, ExprNode(expr.span, expr.hir_id));
-
-                // Make a live_node for each mentioned variable, with the span
-                // being the location that the variable is used. This results
-                // in better error messages than just pointing at the closure
-                // construction site.
-                let mut call_caps = Vec::new();
-                if let Some(upvars) = self.tcx.upvars_mentioned(closure.def_id) {
-                    call_caps.extend(upvars.keys().map(|var_id| {
-                        let upvar = upvars[var_id];
-                        let upvar_ln = self.add_live_node(UpvarNode(upvar.span));
-                        CaptureInfo { ln: upvar_ln, var_hid: *var_id }
-                    }));
-                }
-                self.set_captures(expr.hir_id, call_caps);
-            }
-
-            hir::ExprKind::Let(let_expr) => {
-                self.add_from_pat(let_expr.pat);
-            }
-
-            // live nodes required for interesting control flow:
-            hir::ExprKind::If(..)
-            | hir::ExprKind::Match(..)
-            | hir::ExprKind::Loop(..)
-            | hir::ExprKind::Yield(..) => {
-                self.add_live_node_for_node(expr.hir_id, ExprNode(expr.span, expr.hir_id));
-            }
-            hir::ExprKind::Binary(op, ..) if op.node.is_lazy() => {
-                self.add_live_node_for_node(expr.hir_id, ExprNode(expr.span, expr.hir_id));
-            }
-
-            // Inline assembly may contain labels.
-            hir::ExprKind::InlineAsm(asm) if asm.contains_label() => {
-                self.add_live_node_for_node(expr.hir_id, ExprNode(expr.span, expr.hir_id));
-                intravisit::walk_expr(self, expr);
-            }
-
-            // otherwise, live nodes are not required:
-            hir::ExprKind::Index(..)
-            | hir::ExprKind::Field(..)
-            | hir::ExprKind::Array(..)
-            | hir::ExprKind::Call(..)
-            | hir::ExprKind::MethodCall(..)
-            | hir::ExprKind::Use(..)
-            | hir::ExprKind::Tup(..)
-            | hir::ExprKind::Binary(..)
-            | hir::ExprKind::AddrOf(..)
-            | hir::ExprKind::Cast(..)
-            | hir::ExprKind::DropTemps(..)
-            | hir::ExprKind::Unary(..)
-            | hir::ExprKind::Break(..)
-            | hir::ExprKind::Continue(_)
-            | hir::ExprKind::Lit(_)
-            | hir::ExprKind::ConstBlock(..)
-            | hir::ExprKind::Ret(..)
-            | hir::ExprKind::Become(..)
-            | hir::ExprKind::Block(..)
-            | hir::ExprKind::Assign(..)
-            | hir::ExprKind::AssignOp(..)
-            | hir::ExprKind::Struct(..)
-            | hir::ExprKind::Repeat(..)
-            | hir::ExprKind::InlineAsm(..)
-            | hir::ExprKind::OffsetOf(..)
-            | hir::ExprKind::Type(..)
-            | hir::ExprKind::UnsafeBinderCast(..)
-            | hir::ExprKind::Err(_)
-            | hir::ExprKind::Path(hir::QPath::TypeRelative(..))
-            | hir::ExprKind::Path(hir::QPath::LangItem(..)) => {}
-        }
-        intravisit::walk_expr(self, expr);
-    }
-}
-
-// ______________________________________________________________________
-// Computing liveness sets
-//
-// Actually we compute just a bit more than just liveness, but we use
-// the same basic propagation framework in all cases.
-
-const ACC_READ: u32 = 1;
-const ACC_WRITE: u32 = 2;
-const ACC_USE: u32 = 4;
-
-struct Liveness<'a, 'tcx> {
-    ir: &'a mut IrMaps<'tcx>,
-    typeck_results: &'a ty::TypeckResults<'tcx>,
-    typing_env: ty::TypingEnv<'tcx>,
-    closure_min_captures: Option<&'tcx RootVariableMinCaptureList<'tcx>>,
-    successors: IndexVec<LiveNode, Option<LiveNode>>,
-    rwu_table: rwu_table::RWUTable,
-
-    /// A live node representing a point of execution before closure entry &
-    /// after closure exit. Used to calculate liveness of captured variables
-    /// through calls to the same closure. Used for Fn & FnMut closures only.
-    closure_ln: LiveNode,
-    /// A live node representing every 'exit' from the function, whether it be
-    /// by explicit return, panic, or other means.
-    exit_ln: LiveNode,
-
-    // mappings from loop node ID to LiveNode
-    // ("break" label should map to loop node ID,
-    // it probably doesn't now)
-    break_ln: HirIdMap<LiveNode>,
-    cont_ln: HirIdMap<LiveNode>,
-}
-
-impl<'a, 'tcx> Liveness<'a, 'tcx> {
-    fn new(ir: &'a mut IrMaps<'tcx>, body_owner: LocalDefId) -> Liveness<'a, 'tcx> {
-        let typeck_results = ir.tcx.typeck(body_owner);
-        // Liveness linting runs after building the THIR. We make several assumptions based on
-        // typeck succeeding, e.g. that breaks and continues are well-formed.
-        assert!(typeck_results.tainted_by_errors.is_none());
-        // FIXME(#132279): we're in a body here.
-        let typing_env = ty::TypingEnv::non_body_analysis(ir.tcx, body_owner);
-        let closure_min_captures = typeck_results.closure_min_captures.get(&body_owner);
-        let closure_ln = ir.add_live_node(ClosureNode);
-        let exit_ln = ir.add_live_node(ExitNode);
-
-        let num_live_nodes = ir.lnks.len();
-        let num_vars = ir.var_kinds.len();
-
-        Liveness {
-            ir,
-            typeck_results,
-            typing_env,
-            closure_min_captures,
-            successors: IndexVec::from_elem_n(None, num_live_nodes),
-            rwu_table: rwu_table::RWUTable::new(num_live_nodes, num_vars),
-            closure_ln,
-            exit_ln,
-            break_ln: Default::default(),
-            cont_ln: Default::default(),
-        }
-    }
-
-    fn live_node(&self, hir_id: HirId, span: Span) -> LiveNode {
-        match self.ir.live_node_map.get(&hir_id) {
-            Some(&ln) => ln,
-            None => {
-                // This must be a mismatch between the ir_map construction
-                // above and the propagation code below; the two sets of
-                // code have to agree about which AST nodes are worth
-                // creating liveness nodes for.
-                span_bug!(span, "no live node registered for node {:?}", hir_id);
-            }
-        }
-    }
-
-    fn variable(&self, hir_id: HirId, span: Span) -> Variable {
-        self.ir.variable(hir_id, span)
-    }
-
-    fn define_bindings_in_pat(&mut self, pat: &hir::Pat<'_>, mut succ: LiveNode) -> LiveNode {
-        // In an or-pattern, only consider the first non-never pattern; any later patterns
-        // must have the same bindings, and we also consider that pattern
-        // to be the "authoritative" set of ids.
-        pat.each_binding_or_first(&mut |_, hir_id, pat_sp, ident| {
-            let ln = self.live_node(hir_id, pat_sp);
-            let var = self.variable(hir_id, ident.span);
-            self.init_from_succ(ln, succ);
-            self.define(ln, var);
-            succ = ln;
-        });
-        succ
-    }
-
-    fn live_on_entry(&self, ln: LiveNode, var: Variable) -> bool {
-        self.rwu_table.get_reader(ln, var)
-    }
-
-    // Is this variable live on entry to any of its successor nodes?
-    fn live_on_exit(&self, ln: LiveNode, var: Variable) -> bool {
-        let successor = self.successors[ln].unwrap();
-        self.live_on_entry(successor, var)
-    }
-
-    fn used_on_entry(&self, ln: LiveNode, var: Variable) -> bool {
-        self.rwu_table.get_used(ln, var)
-    }
-
-    fn assigned_on_entry(&self, ln: LiveNode, var: Variable) -> bool {
-        self.rwu_table.get_writer(ln, var)
-    }
-
-    fn assigned_on_exit(&self, ln: LiveNode, var: Variable) -> bool {
-        match self.successors[ln] {
-            Some(successor) => self.assigned_on_entry(successor, var),
-            None => {
-                self.ir.tcx.dcx().delayed_bug("no successor");
-                true
-            }
-        }
-    }
-
-    fn write_vars<F>(&self, wr: &mut dyn Write, mut test: F) -> io::Result<()>
-    where
-        F: FnMut(Variable) -> bool,
-    {
-        for var in self.ir.var_kinds.indices() {
-            if test(var) {
-                write!(wr, " {var:?}")?;
-            }
-        }
-        Ok(())
-    }
-
-    #[allow(unused_must_use)]
-    fn ln_str(&self, ln: LiveNode) -> String {
-        let mut wr = Vec::new();
-        {
-            let wr = &mut wr as &mut dyn Write;
-            write!(wr, "[{:?} of kind {:?} reads", ln, self.ir.lnks[ln]);
-            self.write_vars(wr, |var| self.rwu_table.get_reader(ln, var));
-            write!(wr, "  writes");
-            self.write_vars(wr, |var| self.rwu_table.get_writer(ln, var));
-            write!(wr, "  uses");
-            self.write_vars(wr, |var| self.rwu_table.get_used(ln, var));
-
-            write!(wr, "  precedes {:?}]", self.successors[ln]);
-        }
-        String::from_utf8(wr).unwrap()
-    }
-
-    fn log_liveness(&self, entry_ln: LiveNode, hir_id: HirId) {
-        // hack to skip the loop unless debug! is enabled:
-        debug!(
-            "^^ liveness computation results for body {} (entry={:?})",
-            {
-                for ln_idx in self.ir.lnks.indices() {
-                    debug!("{:?}", self.ln_str(ln_idx));
-                }
-                hir_id
-            },
-            entry_ln
-        );
-    }
-
-    fn init_empty(&mut self, ln: LiveNode, succ_ln: LiveNode) {
-        self.successors[ln] = Some(succ_ln);
-
-        // It is not necessary to initialize the RWUs here because they are all
-        // empty when created, and the sets only grow during iterations.
-    }
-
-    fn init_from_succ(&mut self, ln: LiveNode, succ_ln: LiveNode) {
-        // more efficient version of init_empty() / merge_from_succ()
-        self.successors[ln] = Some(succ_ln);
-        self.rwu_table.copy(ln, succ_ln);
-        debug!("init_from_succ(ln={}, succ={})", self.ln_str(ln), self.ln_str(succ_ln));
-    }
-
-    fn merge_from_succ(&mut self, ln: LiveNode, succ_ln: LiveNode) -> bool {
-        if ln == succ_ln {
-            return false;
-        }
-
-        let changed = self.rwu_table.union(ln, succ_ln);
-        debug!("merge_from_succ(ln={:?}, succ={}, changed={})", ln, self.ln_str(succ_ln), changed);
-        changed
-    }
-
-    // Indicates that a local variable was *defined*; we know that no
-    // uses of the variable can precede the definition (resolve checks
-    // this) so we just clear out all the data.
-    fn define(&mut self, writer: LiveNode, var: Variable) {
-        let used = self.rwu_table.get_used(writer, var);
-        self.rwu_table.set(writer, var, rwu_table::RWU { reader: false, writer: false, used });
-        debug!("{:?} defines {:?}: {}", writer, var, self.ln_str(writer));
-    }
-
-    // Either read, write, or both depending on the acc bitset
-    fn acc(&mut self, ln: LiveNode, var: Variable, acc: u32) {
-        debug!("{:?} accesses[{:x}] {:?}: {}", ln, acc, var, self.ln_str(ln));
-
-        let mut rwu = self.rwu_table.get(ln, var);
-
-        if (acc & ACC_WRITE) != 0 {
-            rwu.reader = false;
-            rwu.writer = true;
-        }
-
-        // Important: if we both read/write, must do read second
-        // or else the write will override.
-        if (acc & ACC_READ) != 0 {
-            rwu.reader = true;
-        }
-
-        if (acc & ACC_USE) != 0 {
-            rwu.used = true;
-        }
-
-        self.rwu_table.set(ln, var, rwu);
-    }
-
-    fn compute(&mut self, body: &hir::Body<'_>, hir_id: HirId) -> LiveNode {
-        debug!("compute: for body {:?}", body.id().hir_id);
-
-        // # Liveness of captured variables
-        //
-        // When computing the liveness for captured variables we take into
-        // account how variable is captured (ByRef vs ByValue) and what is the
-        // closure kind (Coroutine / FnOnce vs Fn / FnMut).
-        //
-        // Variables captured by reference are assumed to be used on the exit
-        // from the closure.
-        //
-        // In FnOnce closures, variables captured by value are known to be dead
-        // on exit since it is impossible to call the closure again.
-        //
-        // In Fn / FnMut closures, variables captured by value are live on exit
-        // if they are live on the entry to the closure, since only the closure
-        // itself can access them on subsequent calls.
-
-        if let Some(closure_min_captures) = self.closure_min_captures {
-            // Mark upvars captured by reference as used after closure exits.
-            for (&var_hir_id, min_capture_list) in closure_min_captures {
-                for captured_place in min_capture_list {
-                    match captured_place.info.capture_kind {
-                        ty::UpvarCapture::ByRef(_) => {
-                            let var = self.variable(
-                                var_hir_id,
-                                captured_place.get_capture_kind_span(self.ir.tcx),
-                            );
-                            self.acc(self.exit_ln, var, ACC_READ | ACC_USE);
-                        }
-                        ty::UpvarCapture::ByValue | ty::UpvarCapture::ByUse => {}
-                    }
-                }
-            }
-        }
-
-        let succ = self.propagate_through_expr(body.value, self.exit_ln);
-
-        if self.closure_min_captures.is_none() {
-            // Either not a closure, or closure without any captured variables.
-            // No need to determine liveness of captured variables, since there
-            // are none.
-            return succ;
-        }
-
-        let ty = self.typeck_results.node_type(hir_id);
-        match ty.kind() {
-            ty::Closure(_def_id, args) => match args.as_closure().kind() {
-                ty::ClosureKind::Fn => {}
-                ty::ClosureKind::FnMut => {}
-                ty::ClosureKind::FnOnce => return succ,
-            },
-            ty::CoroutineClosure(_def_id, args) => match args.as_coroutine_closure().kind() {
-                ty::ClosureKind::Fn => {}
-                ty::ClosureKind::FnMut => {}
-                ty::ClosureKind::FnOnce => return succ,
-            },
-            ty::Coroutine(..) => return succ,
-            _ => {
-                span_bug!(
-                    body.value.span,
-                    "{} has upvars so it should have a closure type: {:?}",
-                    hir_id,
-                    ty
-                );
-            }
-        };
-
-        // Propagate through calls to the closure.
-        loop {
-            self.init_from_succ(self.closure_ln, succ);
-            for param in body.params {
-                param.pat.each_binding(|_bm, hir_id, _x, ident| {
-                    let var = self.variable(hir_id, ident.span);
-                    self.define(self.closure_ln, var);
-                })
-            }
-
-            if !self.merge_from_succ(self.exit_ln, self.closure_ln) {
-                break;
-            }
-            assert_eq!(succ, self.propagate_through_expr(body.value, self.exit_ln));
-        }
-
-        succ
-    }
-
-    fn propagate_through_block(&mut self, blk: &hir::Block<'_>, succ: LiveNode) -> LiveNode {
-        if blk.targeted_by_break {
-            self.break_ln.insert(blk.hir_id, succ);
-        }
-        let succ = self.propagate_through_opt_expr(blk.expr, succ);
-        blk.stmts.iter().rev().fold(succ, |succ, stmt| self.propagate_through_stmt(stmt, succ))
-    }
-
-    fn propagate_through_stmt(&mut self, stmt: &hir::Stmt<'_>, succ: LiveNode) -> LiveNode {
-        match stmt.kind {
-            hir::StmtKind::Let(local) => {
-                // Note: we mark the variable as defined regardless of whether
-                // there is an initializer. Initially I had thought to only mark
-                // the live variable as defined if it was initialized, and then we
-                // could check for uninit variables just by scanning what is live
-                // at the start of the function. But that doesn't work so well for
-                // immutable variables defined in a loop:
-                //     loop { let x; x = 5; }
-                // because the "assignment" loops back around and generates an error.
-                //
-                // So now we just check that variables defined w/o an
-                // initializer are not live at the point of their
-                // initialization, which is mildly more complex than checking
-                // once at the func header but otherwise equivalent.
-
-                if let Some(els) = local.els {
-                    // Eventually, `let pat: ty = init else { els };` is mostly equivalent to
-                    // `let (bindings, ...) = match init { pat => (bindings, ...), _ => els };`
-                    // except that extended lifetime applies at the `init` location.
-                    //
-                    //       (e)
-                    //        |
-                    //        v
-                    //      (expr)
-                    //      /   \
-                    //     |     |
-                    //     v     v
-                    // bindings  els
-                    //     |
-                    //     v
-                    // ( succ )
-                    //
-                    if let Some(init) = local.init {
-                        let else_ln = self.propagate_through_block(els, succ);
-                        let ln = self.live_node(local.hir_id, local.span);
-                        self.init_from_succ(ln, succ);
-                        self.merge_from_succ(ln, else_ln);
-                        let succ = self.propagate_through_expr(init, ln);
-                        self.define_bindings_in_pat(local.pat, succ)
-                    } else {
-                        span_bug!(
-                            stmt.span,
-                            "variable is uninitialized but an unexpected else branch is found"
-                        )
-                    }
-                } else {
-                    let succ = self.propagate_through_opt_expr(local.init, succ);
-                    self.define_bindings_in_pat(local.pat, succ)
-                }
-            }
-            hir::StmtKind::Item(..) => succ,
-            hir::StmtKind::Expr(ref expr) | hir::StmtKind::Semi(ref expr) => {
-                self.propagate_through_expr(expr, succ)
-            }
-        }
-    }
-
-    fn propagate_through_exprs(&mut self, exprs: &[Expr<'_>], succ: LiveNode) -> LiveNode {
-        exprs.iter().rev().fold(succ, |succ, expr| self.propagate_through_expr(expr, succ))
-    }
-
-    fn propagate_through_opt_expr(
-        &mut self,
-        opt_expr: Option<&Expr<'_>>,
-        succ: LiveNode,
-    ) -> LiveNode {
-        opt_expr.map_or(succ, |expr| self.propagate_through_expr(expr, succ))
-    }
-
-    fn propagate_through_expr(&mut self, expr: &Expr<'_>, succ: LiveNode) -> LiveNode {
-        debug!("propagate_through_expr: {:?}", expr);
-
-        match expr.kind {
-            // Interesting cases with control flow or which gen/kill
-            hir::ExprKind::Path(hir::QPath::Resolved(_, path)) => {
-                self.access_path(expr.hir_id, path, succ, ACC_READ | ACC_USE)
-            }
-
-            hir::ExprKind::Field(ref e, _) => self.propagate_through_expr(e, succ),
-
-            hir::ExprKind::Closure { .. } => {
-                debug!("{:?} is an ExprKind::Closure", expr);
-
-                // the construction of a closure itself is not important,
-                // but we have to consider the closed over variables.
-                let caps = self
-                    .ir
-                    .capture_info_map
-                    .get(&expr.hir_id)
-                    .cloned()
-                    .unwrap_or_else(|| span_bug!(expr.span, "no registered caps"));
-
-                caps.iter().rev().fold(succ, |succ, cap| {
-                    self.init_from_succ(cap.ln, succ);
-                    let var = self.variable(cap.var_hid, expr.span);
-                    self.acc(cap.ln, var, ACC_READ | ACC_USE);
-                    cap.ln
-                })
-            }
-
-            hir::ExprKind::Let(let_expr) => {
-                let succ = self.propagate_through_expr(let_expr.init, succ);
-                self.define_bindings_in_pat(let_expr.pat, succ)
-            }
-
-            // Note that labels have been resolved, so we don't need to look
-            // at the label ident
-            hir::ExprKind::Loop(ref blk, ..) => self.propagate_through_loop(expr, blk, succ),
-
-            hir::ExprKind::Yield(e, ..) => {
-                let yield_ln = self.live_node(expr.hir_id, expr.span);
-                self.init_from_succ(yield_ln, succ);
-                self.merge_from_succ(yield_ln, self.exit_ln);
-                self.propagate_through_expr(e, yield_ln)
-            }
-
-            hir::ExprKind::If(ref cond, ref then, ref else_opt) => {
-                //
-                //     (cond)
-                //       |
-                //       v
-                //     (expr)
-                //     /   \
-                //    |     |
-                //    v     v
-                //  (then)(els)
-                //    |     |
-                //    v     v
-                //   (  succ  )
-                //
-                let else_ln = self.propagate_through_opt_expr(else_opt.as_deref(), succ);
-                let then_ln = self.propagate_through_expr(then, succ);
-                let ln = self.live_node(expr.hir_id, expr.span);
-                self.init_from_succ(ln, else_ln);
-                self.merge_from_succ(ln, then_ln);
-                self.propagate_through_expr(cond, ln)
-            }
-
-            hir::ExprKind::Match(ref e, arms, _) => {
-                //
-                //      (e)
-                //       |
-                //       v
-                //     (expr)
-                //     / | \
-                //    |  |  |
-                //    v  v  v
-                //   (..arms..)
-                //    |  |  |
-                //    v  v  v
-                //   (  succ  )
-                //
-                //
-                let ln = self.live_node(expr.hir_id, expr.span);
-                self.init_empty(ln, succ);
-                for arm in arms {
-                    let body_succ = self.propagate_through_expr(arm.body, succ);
-
-                    let guard_succ = arm
-                        .guard
-                        .as_ref()
-                        .map_or(body_succ, |g| self.propagate_through_expr(g, body_succ));
-                    let arm_succ = self.define_bindings_in_pat(&arm.pat, guard_succ);
-                    self.merge_from_succ(ln, arm_succ);
-                }
-                self.propagate_through_expr(e, ln)
-            }
-
-            hir::ExprKind::Ret(ref o_e) => {
-                // Ignore succ and subst exit_ln.
-                self.propagate_through_opt_expr(o_e.as_deref(), self.exit_ln)
-            }
-
-            hir::ExprKind::Become(e) => {
-                // Ignore succ and subst exit_ln.
-                self.propagate_through_expr(e, self.exit_ln)
-            }
-
-            hir::ExprKind::Break(label, ref opt_expr) => {
-                // Find which label this break jumps to
-                let target = match label.target_id {
-                    Ok(hir_id) => self.break_ln.get(&hir_id),
-                    Err(err) => span_bug!(expr.span, "loop scope error: {}", err),
-                }
-                .cloned();
-
-                // Now that we know the label we're going to,
-                // look it up in the break loop nodes table
-
-                match target {
-                    Some(b) => self.propagate_through_opt_expr(opt_expr.as_deref(), b),
-                    None => span_bug!(expr.span, "`break` to unknown label"),
-                }
-            }
-
-            hir::ExprKind::Continue(label) => {
-                // Find which label this expr continues to
-                let sc = label
-                    .target_id
-                    .unwrap_or_else(|err| span_bug!(expr.span, "loop scope error: {}", err));
-
-                // Now that we know the label we're going to,
-                // look it up in the continue loop nodes table
-                self.cont_ln.get(&sc).cloned().unwrap_or_else(|| {
-                    // Liveness linting happens after building the THIR. Bad labels should already
-                    // have been caught.
-                    span_bug!(expr.span, "continue to unknown label");
-                })
-            }
-
-            hir::ExprKind::Assign(ref l, ref r, _) => {
-                // see comment on places in
-                // propagate_through_place_components()
-                let succ = self.write_place(l, succ, ACC_WRITE);
-                let succ = self.propagate_through_place_components(l, succ);
-                self.propagate_through_expr(r, succ)
-            }
-
-            hir::ExprKind::AssignOp(_, ref l, ref r) => {
-                // an overloaded assign op is like a method call
-                if self.typeck_results.is_method_call(expr) {
-                    let succ = self.propagate_through_expr(l, succ);
-                    self.propagate_through_expr(r, succ)
-                } else {
-                    // see comment on places in
-                    // propagate_through_place_components()
-                    let succ = self.write_place(l, succ, ACC_WRITE | ACC_READ);
-                    let succ = self.propagate_through_expr(r, succ);
-                    self.propagate_through_place_components(l, succ)
-                }
-            }
-
-            // Uninteresting cases: just propagate in rev exec order
-            hir::ExprKind::Array(exprs) => self.propagate_through_exprs(exprs, succ),
-
-            hir::ExprKind::Struct(_, fields, ref with_expr) => {
-                let succ = match with_expr {
-                    hir::StructTailExpr::Base(base) => {
-                        self.propagate_through_opt_expr(Some(base), succ)
-                    }
-                    hir::StructTailExpr::None | hir::StructTailExpr::DefaultFields(_) => succ,
-                };
-                fields
-                    .iter()
-                    .rev()
-                    .fold(succ, |succ, field| self.propagate_through_expr(field.expr, succ))
-            }
-
-            hir::ExprKind::Call(ref f, args) => {
-                let is_ctor = |f: &Expr<'_>| matches!(f.kind, hir::ExprKind::Path(hir::QPath::Resolved(_, path)) if matches!(path.res, rustc_hir::def::Res::Def(rustc_hir::def::DefKind::Ctor(_, _), _)));
-                let succ =
-                    if !is_ctor(f) { self.check_is_ty_uninhabited(expr, succ) } else { succ };
-
-                let succ = self.propagate_through_exprs(args, succ);
-                self.propagate_through_expr(f, succ)
-            }
-
-            hir::ExprKind::MethodCall(.., receiver, args, _) => {
-                let succ = self.check_is_ty_uninhabited(expr, succ);
-                let succ = self.propagate_through_exprs(args, succ);
-                self.propagate_through_expr(receiver, succ)
-            }
-
-            hir::ExprKind::Use(expr, _) => {
-                let succ = self.check_is_ty_uninhabited(expr, succ);
-                self.propagate_through_expr(expr, succ)
-            }
-
-            hir::ExprKind::Tup(exprs) => self.propagate_through_exprs(exprs, succ),
-
-            hir::ExprKind::Binary(op, ref l, ref r) if op.node.is_lazy() => {
-                let r_succ = self.propagate_through_expr(r, succ);
-
-                let ln = self.live_node(expr.hir_id, expr.span);
-                self.init_from_succ(ln, succ);
-                self.merge_from_succ(ln, r_succ);
-
-                self.propagate_through_expr(l, ln)
-            }
-
-            hir::ExprKind::Index(ref l, ref r, _) | hir::ExprKind::Binary(_, ref l, ref r) => {
-                let r_succ = self.propagate_through_expr(r, succ);
-                self.propagate_through_expr(l, r_succ)
-            }
-
-            hir::ExprKind::AddrOf(_, _, ref e)
-            | hir::ExprKind::Cast(ref e, _)
-            | hir::ExprKind::Type(ref e, _)
-            | hir::ExprKind::UnsafeBinderCast(_, ref e, _)
-            | hir::ExprKind::DropTemps(ref e)
-            | hir::ExprKind::Unary(_, ref e)
-            | hir::ExprKind::Repeat(ref e, _) => self.propagate_through_expr(e, succ),
-
-            hir::ExprKind::InlineAsm(asm) => {
-                //
-                //     (inputs)
-                //        |
-                //        v
-                //     (outputs)
-                //    /         \
-                //    |         |
-                //    v         v
-                // (labels)(fallthrough)
-                //    |         |
-                //    v         v
-                // ( succ / exit_ln )
-
-                // Handle non-returning asm
-                let mut succ =
-                    if self.typeck_results.expr_ty(expr).is_never() { self.exit_ln } else { succ };
-
-                // Do a first pass for labels only
-                if asm.contains_label() {
-                    let ln = self.live_node(expr.hir_id, expr.span);
-                    self.init_from_succ(ln, succ);
-                    for (op, _op_sp) in asm.operands.iter().rev() {
-                        match op {
-                            hir::InlineAsmOperand::Label { block } => {
-                                let label_ln = self.propagate_through_block(block, succ);
-                                self.merge_from_succ(ln, label_ln);
-                            }
-                            hir::InlineAsmOperand::In { .. }
-                            | hir::InlineAsmOperand::Out { .. }
-                            | hir::InlineAsmOperand::InOut { .. }
-                            | hir::InlineAsmOperand::SplitInOut { .. }
-                            | hir::InlineAsmOperand::Const { .. }
-                            | hir::InlineAsmOperand::SymFn { .. }
-                            | hir::InlineAsmOperand::SymStatic { .. } => {}
-                        }
-                    }
-                    succ = ln;
-                }
-
-                // Do a second pass for writing outputs only
-                for (op, _op_sp) in asm.operands.iter().rev() {
-                    match op {
-                        hir::InlineAsmOperand::In { .. }
-                        | hir::InlineAsmOperand::Const { .. }
-                        | hir::InlineAsmOperand::SymFn { .. }
-                        | hir::InlineAsmOperand::SymStatic { .. }
-                        | hir::InlineAsmOperand::Label { .. } => {}
-                        hir::InlineAsmOperand::Out { expr, .. } => {
-                            if let Some(expr) = expr {
-                                succ = self.write_place(expr, succ, ACC_WRITE);
-                            }
-                        }
-                        hir::InlineAsmOperand::InOut { expr, .. } => {
-                            succ = self.write_place(expr, succ, ACC_READ | ACC_WRITE | ACC_USE);
-                        }
-                        hir::InlineAsmOperand::SplitInOut { out_expr, .. } => {
-                            if let Some(expr) = out_expr {
-                                succ = self.write_place(expr, succ, ACC_WRITE);
-                            }
-                        }
-                    }
-                }
-
-                // Then do a third pass for inputs
-                for (op, _op_sp) in asm.operands.iter().rev() {
-                    match op {
-                        hir::InlineAsmOperand::In { expr, .. } => {
-                            succ = self.propagate_through_expr(expr, succ)
-                        }
-                        hir::InlineAsmOperand::Out { expr, .. } => {
-                            if let Some(expr) = expr {
-                                succ = self.propagate_through_place_components(expr, succ);
-                            }
-                        }
-                        hir::InlineAsmOperand::InOut { expr, .. } => {
-                            succ = self.propagate_through_place_components(expr, succ);
-                        }
-                        hir::InlineAsmOperand::SplitInOut { in_expr, out_expr, .. } => {
-                            if let Some(expr) = out_expr {
-                                succ = self.propagate_through_place_components(expr, succ);
-                            }
-                            succ = self.propagate_through_expr(in_expr, succ);
-                        }
-                        hir::InlineAsmOperand::Const { .. }
-                        | hir::InlineAsmOperand::SymFn { .. }
-                        | hir::InlineAsmOperand::SymStatic { .. }
-                        | hir::InlineAsmOperand::Label { .. } => {}
-                    }
-                }
-                succ
-            }
-
-            hir::ExprKind::Lit(..)
-            | hir::ExprKind::ConstBlock(..)
-            | hir::ExprKind::Err(_)
-            | hir::ExprKind::Path(hir::QPath::TypeRelative(..))
-            | hir::ExprKind::Path(hir::QPath::LangItem(..))
-            | hir::ExprKind::OffsetOf(..) => succ,
-
-            // Note that labels have been resolved, so we don't need to look
-            // at the label ident
-            hir::ExprKind::Block(ref blk, _) => self.propagate_through_block(blk, succ),
-        }
-    }
-
-    fn propagate_through_place_components(&mut self, expr: &Expr<'_>, succ: LiveNode) -> LiveNode {
-        // # Places
-        //
-        // In general, the full flow graph structure for an
-        // assignment/move/etc can be handled in one of two ways,
-        // depending on whether what is being assigned is a "tracked
-        // value" or not. A tracked value is basically a local
-        // variable or argument.
-        //
-        // The two kinds of graphs are:
-        //
-        //    Tracked place          Untracked place
-        // ----------------------++-----------------------
-        //                       ||
-        //         |             ||           |
-        //         v             ||           v
-        //     (rvalue)          ||       (rvalue)
-        //         |             ||           |
-        //         v             ||           v
-        // (write of place)      ||   (place components)
-        //         |             ||           |
-        //         v             ||           v
-        //      (succ)           ||        (succ)
-        //                       ||
-        // ----------------------++-----------------------
-        //
-        // I will cover the two cases in turn:
-        //
-        // # Tracked places
-        //
-        // A tracked place is a local variable/argument `x`. In
-        // these cases, the link_node where the write occurs is linked
-        // to node id of `x`. The `write_place()` routine generates
-        // the contents of this node. There are no subcomponents to
-        // consider.
-        //
-        // # Non-tracked places
-        //
-        // These are places like `x[5]` or `x.f`. In that case, we
-        // basically ignore the value which is written to but generate
-        // reads for the components---`x` in these two examples. The
-        // components reads are generated by
-        // `propagate_through_place_components()` (this fn).
-        //
-        // # Illegal places
-        //
-        // It is still possible to observe assignments to non-places;
-        // these errors are detected in the later pass borrowck. We
-        // just ignore such cases and treat them as reads.
-
-        match expr.kind {
-            hir::ExprKind::Path(_) => succ,
-            hir::ExprKind::Field(ref e, _) => self.propagate_through_expr(e, succ),
-            _ => self.propagate_through_expr(expr, succ),
-        }
-    }
-
-    // see comment on propagate_through_place()
-    fn write_place(&mut self, expr: &Expr<'_>, succ: LiveNode, acc: u32) -> LiveNode {
-        match expr.kind {
-            hir::ExprKind::Path(hir::QPath::Resolved(_, path)) => {
-                self.access_path(expr.hir_id, path, succ, acc)
-            }
-
-            // We do not track other places, so just propagate through
-            // to their subcomponents. Also, it may happen that
-            // non-places occur here, because those are detected in the
-            // later pass borrowck.
-            _ => succ,
-        }
-    }
-
-    fn access_var(
-        &mut self,
-        hir_id: HirId,
-        var_hid: HirId,
-        succ: LiveNode,
-        acc: u32,
-        span: Span,
-    ) -> LiveNode {
-        let ln = self.live_node(hir_id, span);
-        if acc != 0 {
-            self.init_from_succ(ln, succ);
-            let var = self.variable(var_hid, span);
-            self.acc(ln, var, acc);
-        }
-        ln
-    }
-
-    fn access_path(
-        &mut self,
-        hir_id: HirId,
-        path: &hir::Path<'_>,
-        succ: LiveNode,
-        acc: u32,
-    ) -> LiveNode {
-        match path.res {
-            Res::Local(hid) => self.access_var(hir_id, hid, succ, acc, path.span),
-            _ => succ,
-        }
-    }
-
-    fn propagate_through_loop(
-        &mut self,
-        expr: &Expr<'_>,
-        body: &hir::Block<'_>,
-        succ: LiveNode,
-    ) -> LiveNode {
-        /*
-        We model control flow like this:
-
-              (expr) <-+
-                |      |
-                v      |
-              (body) --+
-
-        Note that a `continue` expression targeting the `loop` will have a successor of `expr`.
-        Meanwhile, a `break` expression will have a successor of `succ`.
-        */
-
-        // first iteration:
-        let ln = self.live_node(expr.hir_id, expr.span);
-        self.init_empty(ln, succ);
-        debug!("propagate_through_loop: using id for loop body {} {:?}", expr.hir_id, body);
-
-        self.break_ln.insert(expr.hir_id, succ);
-
-        self.cont_ln.insert(expr.hir_id, ln);
-
-        let body_ln = self.propagate_through_block(body, ln);
-
-        // repeat until fixed point is reached:
-        while self.merge_from_succ(ln, body_ln) {
-            assert_eq!(body_ln, self.propagate_through_block(body, ln));
-        }
-
-        ln
-    }
-
-    fn check_is_ty_uninhabited(&mut self, expr: &Expr<'_>, succ: LiveNode) -> LiveNode {
-        let ty = self.typeck_results.expr_ty(expr);
-        let m = self.ir.tcx.parent_module(expr.hir_id).to_def_id();
-        if ty.is_inhabited_from(self.ir.tcx, m, self.typing_env) { succ } else { self.exit_ln }
-    }
-}
-
-// _______________________________________________________________________
-// Checking for error conditions
-
-impl<'a, 'tcx> Visitor<'tcx> for Liveness<'a, 'tcx> {
-    fn visit_local(&mut self, local: &'tcx hir::LetStmt<'tcx>) {
-        self.check_unused_vars_in_pat(local.pat, None, None, |spans, hir_id, ln, var| {
-            if local.init.is_some() {
-                self.warn_about_dead_assign(spans, hir_id, ln, var, None);
-            }
-        });
-
-        intravisit::walk_local(self, local);
-    }
-
-    fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {
-        check_expr(self, ex);
-        intravisit::walk_expr(self, ex);
-    }
-
-    fn visit_arm(&mut self, arm: &'tcx hir::Arm<'tcx>) {
-        self.check_unused_vars_in_pat(arm.pat, None, None, |_, _, _, _| {});
-        intravisit::walk_arm(self, arm);
-    }
-}
-
-fn check_expr<'tcx>(this: &mut Liveness<'_, 'tcx>, expr: &'tcx Expr<'tcx>) {
-    match expr.kind {
-        hir::ExprKind::Assign(ref l, ..) => {
-            this.check_place(l);
-        }
-
-        hir::ExprKind::AssignOp(_, ref l, _) => {
-            if !this.typeck_results.is_method_call(expr) {
-                this.check_place(l);
-            }
-        }
-
-        hir::ExprKind::InlineAsm(asm) => {
-            for (op, _op_sp) in asm.operands {
-                match op {
-                    hir::InlineAsmOperand::Out { expr, .. } => {
-                        if let Some(expr) = expr {
-                            this.check_place(expr);
-                        }
-                    }
-                    hir::InlineAsmOperand::InOut { expr, .. } => {
-                        this.check_place(expr);
-                    }
-                    hir::InlineAsmOperand::SplitInOut { out_expr, .. } => {
-                        if let Some(out_expr) = out_expr {
-                            this.check_place(out_expr);
-                        }
-                    }
-                    _ => {}
-                }
-            }
-        }
-
-        hir::ExprKind::Let(let_expr) => {
-            this.check_unused_vars_in_pat(let_expr.pat, None, None, |_, _, _, _| {});
-        }
-
-        // no correctness conditions related to liveness
-        hir::ExprKind::Call(..)
-        | hir::ExprKind::MethodCall(..)
-        | hir::ExprKind::Use(..)
-        | hir::ExprKind::Match(..)
-        | hir::ExprKind::Loop(..)
-        | hir::ExprKind::Index(..)
-        | hir::ExprKind::Field(..)
-        | hir::ExprKind::Array(..)
-        | hir::ExprKind::Tup(..)
-        | hir::ExprKind::Binary(..)
-        | hir::ExprKind::Cast(..)
-        | hir::ExprKind::If(..)
-        | hir::ExprKind::DropTemps(..)
-        | hir::ExprKind::Unary(..)
-        | hir::ExprKind::Ret(..)
-        | hir::ExprKind::Become(..)
-        | hir::ExprKind::Break(..)
-        | hir::ExprKind::Continue(..)
-        | hir::ExprKind::Lit(_)
-        | hir::ExprKind::ConstBlock(..)
-        | hir::ExprKind::Block(..)
-        | hir::ExprKind::AddrOf(..)
-        | hir::ExprKind::OffsetOf(..)
-        | hir::ExprKind::Struct(..)
-        | hir::ExprKind::Repeat(..)
-        | hir::ExprKind::Closure { .. }
-        | hir::ExprKind::Path(_)
-        | hir::ExprKind::Yield(..)
-        | hir::ExprKind::Type(..)
-        | hir::ExprKind::UnsafeBinderCast(..)
-        | hir::ExprKind::Err(_) => {}
-    }
-}
-
-impl<'tcx> Liveness<'_, 'tcx> {
-    fn check_place(&mut self, expr: &'tcx Expr<'tcx>) {
-        match expr.kind {
-            hir::ExprKind::Path(hir::QPath::Resolved(_, path)) => {
-                if let Res::Local(var_hid) = path.res {
-                    // Assignment to an immutable variable or argument: only legal
-                    // if there is no later assignment. If this local is actually
-                    // mutable, then check for a reassignment to flag the mutability
-                    // as being used.
-                    let ln = self.live_node(expr.hir_id, expr.span);
-                    let var = self.variable(var_hid, expr.span);
-                    let sugg = self.annotate_mut_binding_to_immutable_binding(var_hid, expr);
-                    self.warn_about_dead_assign(vec![expr.span], expr.hir_id, ln, var, sugg);
-                }
-            }
-            _ => {
-                // For other kinds of places, no checks are required,
-                // and any embedded expressions are actually rvalues
-                intravisit::walk_expr(self, expr);
-            }
-        }
-    }
-
-    fn should_warn(&self, var: Variable) -> Option<String> {
-        let name = self.ir.variable_name(var);
-        let name = name.as_str();
-        if name.as_bytes()[0] == b'_' {
-            return None;
-        }
-        Some(name.to_owned())
-    }
-
-    fn warn_about_unused_upvars(&self, entry_ln: LiveNode) {
-        let Some(closure_min_captures) = self.closure_min_captures else {
-            return;
-        };
-
-        // If closure_min_captures is Some(), upvars must be Some() too.
-        for (&var_hir_id, min_capture_list) in closure_min_captures {
-            for captured_place in min_capture_list {
-                match captured_place.info.capture_kind {
-                    ty::UpvarCapture::ByValue | ty::UpvarCapture::ByUse => {}
-                    ty::UpvarCapture::ByRef(..) => continue,
-                };
-                let span = captured_place.get_capture_kind_span(self.ir.tcx);
-                let var = self.variable(var_hir_id, span);
-                if self.used_on_entry(entry_ln, var) {
-                    if !self.live_on_entry(entry_ln, var) {
-                        if let Some(name) = self.should_warn(var) {
-                            self.ir.tcx.emit_node_span_lint(
-                                lint::builtin::UNUSED_ASSIGNMENTS,
-                                var_hir_id,
-                                vec![span],
-                                errors::UnusedCaptureMaybeCaptureRef { name },
-                            );
-                        }
-                    }
-                } else if let Some(name) = self.should_warn(var) {
-                    self.ir.tcx.emit_node_span_lint(
-                        lint::builtin::UNUSED_VARIABLES,
-                        var_hir_id,
-                        vec![span],
-                        errors::UnusedVarMaybeCaptureRef { name },
-                    );
-                }
-            }
-        }
-    }
-
-    fn warn_about_unused_args(&self, body: &hir::Body<'_>, entry_ln: LiveNode) {
-        if let Some(intrinsic) = self.ir.tcx.intrinsic(self.ir.tcx.hir_body_owner_def_id(body.id()))
-        {
-            if intrinsic.must_be_overridden {
-                return;
-            }
-        }
-
-        for p in body.params {
-            self.check_unused_vars_in_pat(
-                p.pat,
-                Some(entry_ln),
-                Some(body),
-                |spans, hir_id, ln, var| {
-                    if !self.live_on_entry(ln, var)
-                        && let Some(name) = self.should_warn(var)
-                    {
-                        self.ir.tcx.emit_node_span_lint(
-                            lint::builtin::UNUSED_ASSIGNMENTS,
-                            hir_id,
-                            spans,
-                            errors::UnusedAssignPassed { name },
-                        );
-                    }
-                },
-            );
-        }
-    }
-
-    fn check_unused_vars_in_pat(
-        &self,
-        pat: &hir::Pat<'_>,
-        entry_ln: Option<LiveNode>,
-        opt_body: Option<&hir::Body<'_>>,
-        on_used_on_entry: impl Fn(Vec<Span>, HirId, LiveNode, Variable),
-    ) {
-        // In an or-pattern, only consider the variable; any later patterns must have the same
-        // bindings, and we also consider the first pattern to be the "authoritative" set of ids.
-        // However, we should take the ids and spans of variables with the same name from the later
-        // patterns so the suggestions to prefix with underscores will apply to those too.
-        let mut vars: FxIndexMap<Symbol, (LiveNode, Variable, Vec<(HirId, Span, Span)>)> =
-            <_>::default();
-
-        pat.each_binding(|_, hir_id, pat_sp, ident| {
-            let ln = entry_ln.unwrap_or_else(|| self.live_node(hir_id, pat_sp));
-            let var = self.variable(hir_id, ident.span);
-            let id_and_sp = (hir_id, pat_sp, ident.span);
-            vars.entry(self.ir.variable_name(var))
-                .and_modify(|(.., hir_ids_and_spans)| hir_ids_and_spans.push(id_and_sp))
-                .or_insert_with(|| (ln, var, vec![id_and_sp]));
-        });
-
-        let can_remove = match pat.kind {
-            hir::PatKind::Struct(_, fields, Some(_)) => {
-                // if all fields are shorthand, remove the struct field, otherwise, mark with _ as prefix
-                fields.iter().all(|f| f.is_shorthand)
-            }
-            _ => false,
-        };
-
-        for (_, (ln, var, hir_ids_and_spans)) in vars {
-            if self.used_on_entry(ln, var) {
-                let id = hir_ids_and_spans[0].0;
-                let spans =
-                    hir_ids_and_spans.into_iter().map(|(_, _, ident_span)| ident_span).collect();
-                on_used_on_entry(spans, id, ln, var);
-            } else {
-                self.report_unused(hir_ids_and_spans, ln, var, can_remove, pat, opt_body);
-            }
-        }
-    }
-
-    /// Detect the following case
-    ///
-    /// ```text
-    /// fn change_object(mut a: &Ty) {
-    ///     let a = Ty::new();
-    ///     b = &a;
-    /// }
-    /// ```
-    ///
-    /// where the user likely meant to modify the value behind there reference, use `a` as an out
-    /// parameter, instead of mutating the local binding. When encountering this we suggest:
-    ///
-    /// ```text
-    /// fn change_object(a: &'_ mut Ty) {
-    ///     let a = Ty::new();
-    ///     *b = a;
-    /// }
-    /// ```
-    fn annotate_mut_binding_to_immutable_binding(
-        &self,
-        var_hid: HirId,
-        expr: &'tcx Expr<'tcx>,
-    ) -> Option<errors::UnusedAssignSuggestion> {
-        if let hir::Node::Expr(parent) = self.ir.tcx.parent_hir_node(expr.hir_id)
-            && let hir::ExprKind::Assign(_, rhs, _) = parent.kind
-            && let hir::ExprKind::AddrOf(borrow_kind, _mut, inner) = rhs.kind
-            && let hir::BorrowKind::Ref = borrow_kind
-            && let hir::Node::Pat(pat) = self.ir.tcx.hir_node(var_hid)
-            && let hir::Node::Param(hir::Param { ty_span, .. }) =
-                self.ir.tcx.parent_hir_node(pat.hir_id)
-            && let item_id = self.ir.tcx.hir_get_parent_item(pat.hir_id)
-            && let item = self.ir.tcx.hir_owner_node(item_id)
-            && let Some(fn_decl) = item.fn_decl()
-            && let hir::PatKind::Binding(hir::BindingMode::MUT, _hir_id, ident, _) = pat.kind
-            && let Some((lt, mut_ty)) = fn_decl
-                .inputs
-                .iter()
-                .filter_map(|ty| {
-                    if ty.span == *ty_span
-                        && let hir::TyKind::Ref(lt, mut_ty) = ty.kind
-                    {
-                        Some((lt, mut_ty))
-                    } else {
-                        None
-                    }
-                })
-                .next()
-        {
-            let ty_span = if mut_ty.mutbl.is_mut() {
-                // Leave `&'name mut Ty` and `&mut Ty` as they are (#136028).
-                None
-            } else {
-                // `&'name Ty` -> `&'name mut Ty` or `&Ty` -> `&mut Ty`
-                Some(mut_ty.ty.span.shrink_to_lo())
-            };
-            let pre = if lt.ident.span.is_empty() { "" } else { " " };
-            Some(errors::UnusedAssignSuggestion {
-                ty_span,
-                pre,
-                ty_ref_span: pat.span.until(ident.span),
-                ident_span: expr.span.shrink_to_lo(),
-                expr_ref_span: rhs.span.until(inner.span),
-            })
-        } else {
-            None
-        }
-    }
-
-    #[instrument(skip(self), level = "INFO")]
-    fn report_unused(
-        &self,
-        hir_ids_and_spans: Vec<(HirId, Span, Span)>,
-        ln: LiveNode,
-        var: Variable,
-        can_remove: bool,
-        pat: &hir::Pat<'_>,
-        opt_body: Option<&hir::Body<'_>>,
-    ) {
-        let first_hir_id = hir_ids_and_spans[0].0;
-        if let Some(name) = self.should_warn(var).filter(|name| name != "self") {
-            // annoying: for parameters in funcs like `fn(x: i32)
-            // {ret}`, there is only one node, so asking about
-            // assigned_on_exit() is not meaningful.
-            let is_assigned =
-                if ln == self.exit_ln { false } else { self.assigned_on_exit(ln, var) };
-
-            let mut typo = None;
-            let filtered_hir_ids_and_spans = hir_ids_and_spans.iter().filter(|(hir_id, ..)| {
-                !matches!(self.ir.tcx.parent_hir_node(*hir_id), hir::Node::Param(_))
-            });
-            for (hir_id, _, span) in filtered_hir_ids_and_spans.clone() {
-                let ty = self.typeck_results.node_type(*hir_id);
-                if let ty::Adt(adt, _) = ty.peel_refs().kind() {
-                    let name = Symbol::intern(&name);
-                    let adt_def = self.ir.tcx.adt_def(adt.did());
-                    let variant_names: Vec<_> = adt_def
-                        .variants()
-                        .iter()
-                        .filter(|v| matches!(v.ctor, Some((CtorKind::Const, _))))
-                        .map(|v| v.name)
-                        .collect();
-                    if let Some(name) = find_best_match_for_name(&variant_names, name, None)
-                        && let Some(variant) = adt_def.variants().iter().find(|v| {
-                            v.name == name && matches!(v.ctor, Some((CtorKind::Const, _)))
-                        })
-                    {
-                        typo = Some(errors::PatternTypo {
-                            span: *span,
-                            code: with_no_trimmed_paths!(self.ir.tcx.def_path_str(variant.def_id)),
-                            kind: self.ir.tcx.def_descr(variant.def_id).to_string(),
-                            item_name: variant.name.to_string(),
-                        });
-                    }
-                }
-            }
-            if typo.is_none() {
-                for (hir_id, _, span) in filtered_hir_ids_and_spans {
-                    let ty = self.typeck_results.node_type(*hir_id);
-                    // Look for consts of the same type with similar names as well, not just unit
-                    // structs and variants.
-                    for def_id in self.ir.tcx.hir_body_owners() {
-                        if let DefKind::Const = self.ir.tcx.def_kind(def_id)
-                            && self.ir.tcx.type_of(def_id).instantiate_identity() == ty
-                        {
-                            typo = Some(errors::PatternTypo {
-                                span: *span,
-                                code: with_no_trimmed_paths!(self.ir.tcx.def_path_str(def_id)),
-                                kind: "constant".to_string(),
-                                item_name: self.ir.tcx.item_name(def_id).to_string(),
-                            });
-                        }
-                    }
-                }
-            }
-            if is_assigned {
-                self.ir.tcx.emit_node_span_lint(
-                    lint::builtin::UNUSED_VARIABLES,
-                    first_hir_id,
-                    hir_ids_and_spans
-                        .into_iter()
-                        .map(|(_, _, ident_span)| ident_span)
-                        .collect::<Vec<_>>(),
-                    errors::UnusedVarAssignedOnly { name, typo },
-                )
-            } else if can_remove {
-                let spans = hir_ids_and_spans
-                    .iter()
-                    .map(|(_, pat_span, _)| {
-                        let span = self
-                            .ir
-                            .tcx
-                            .sess
-                            .source_map()
-                            .span_extend_to_next_char(*pat_span, ',', true);
-                        span.with_hi(BytePos(span.hi().0 + 1))
-                    })
-                    .collect();
-                self.ir.tcx.emit_node_span_lint(
-                    lint::builtin::UNUSED_VARIABLES,
-                    first_hir_id,
-                    hir_ids_and_spans.iter().map(|(_, pat_span, _)| *pat_span).collect::<Vec<_>>(),
-                    errors::UnusedVarRemoveField {
-                        name,
-                        sugg: errors::UnusedVarRemoveFieldSugg { spans },
-                    },
-                );
-            } else {
-                let (shorthands, non_shorthands): (Vec<_>, Vec<_>) =
-                    hir_ids_and_spans.iter().copied().partition(|(hir_id, _, ident_span)| {
-                        let var = self.variable(*hir_id, *ident_span);
-                        self.ir.variable_is_shorthand(var)
-                    });
-
-                // If we have both shorthand and non-shorthand, prefer the "try ignoring
-                // the field" message, and suggest `_` for the non-shorthands. If we only
-                // have non-shorthand, then prefix with an underscore instead.
-                if !shorthands.is_empty() {
-                    let shorthands =
-                        shorthands.into_iter().map(|(_, pat_span, _)| pat_span).collect();
-                    let non_shorthands =
-                        non_shorthands.into_iter().map(|(_, pat_span, _)| pat_span).collect();
-
-                    self.ir.tcx.emit_node_span_lint(
-                        lint::builtin::UNUSED_VARIABLES,
-                        first_hir_id,
-                        hir_ids_and_spans
-                            .iter()
-                            .map(|(_, pat_span, _)| *pat_span)
-                            .collect::<Vec<_>>(),
-                        errors::UnusedVarTryIgnore {
-                            name: name.clone(),
-                            sugg: errors::UnusedVarTryIgnoreSugg {
-                                shorthands,
-                                non_shorthands,
-                                name,
-                            },
-                        },
-                    );
-                } else {
-                    // #117284, when `pat_span` and `ident_span` have different contexts
-                    // we can't provide a good suggestion, instead we pointed out the spans from macro
-                    let from_macro = non_shorthands
-                        .iter()
-                        .find(|(_, pat_span, ident_span)| {
-                            !pat_span.eq_ctxt(*ident_span) && pat_span.from_expansion()
-                        })
-                        .map(|(_, pat_span, _)| *pat_span);
-                    let non_shorthands = non_shorthands
-                        .into_iter()
-                        .map(|(_, _, ident_span)| ident_span)
-                        .collect::<Vec<_>>();
-
-                    let suggestions = self.string_interp_suggestions(&name, opt_body);
-                    let sugg = if let Some(span) = from_macro {
-                        errors::UnusedVariableSugg::NoSugg { span, name: name.clone() }
-                    } else {
-                        errors::UnusedVariableSugg::TryPrefixSugg {
-                            spans: non_shorthands,
-                            name: name.clone(),
-                        }
-                    };
-
-                    self.ir.tcx.emit_node_span_lint(
-                        lint::builtin::UNUSED_VARIABLES,
-                        first_hir_id,
-                        hir_ids_and_spans
-                            .iter()
-                            .map(|(_, _, ident_span)| *ident_span)
-                            .collect::<Vec<_>>(),
-                        errors::UnusedVariableTryPrefix {
-                            label: if !suggestions.is_empty() { Some(pat.span) } else { None },
-                            name,
-                            sugg,
-                            string_interp: suggestions,
-                            typo,
-                        },
-                    );
-                }
-            }
-        }
-    }
-
-    fn string_interp_suggestions(
-        &self,
-        name: &str,
-        opt_body: Option<&hir::Body<'_>>,
-    ) -> Vec<errors::UnusedVariableStringInterp> {
-        let mut suggs = Vec::new();
-        let Some(opt_body) = opt_body else {
-            return suggs;
-        };
-        let mut visitor = CollectLitsVisitor { lit_exprs: vec![] };
-        intravisit::walk_body(&mut visitor, opt_body);
-        for lit_expr in visitor.lit_exprs {
-            let hir::ExprKind::Lit(litx) = &lit_expr.kind else { continue };
-            let rustc_ast::LitKind::Str(syb, _) = litx.node else {
-                continue;
-            };
-            let name_str: &str = syb.as_str();
-            let name_pa = format!("{{{name}}}");
-            if name_str.contains(&name_pa) {
-                suggs.push(errors::UnusedVariableStringInterp {
-                    lit: lit_expr.span,
-                    lo: lit_expr.span.shrink_to_lo(),
-                    hi: lit_expr.span.shrink_to_hi(),
-                });
-            }
-        }
-        suggs
-    }
-
-    fn warn_about_dead_assign(
-        &self,
-        spans: Vec<Span>,
-        hir_id: HirId,
-        ln: LiveNode,
-        var: Variable,
-        suggestion: Option<errors::UnusedAssignSuggestion>,
-    ) {
-        if !self.live_on_exit(ln, var)
-            && let Some(name) = self.should_warn(var)
-        {
-            let help = suggestion.is_none();
-            self.ir.tcx.emit_node_span_lint(
-                lint::builtin::UNUSED_ASSIGNMENTS,
-                hir_id,
-                spans,
-                errors::UnusedAssign { name, suggestion, help },
-            );
-        }
-    }
-}
diff --git a/compiler/rustc_passes/src/liveness/rwu_table.rs b/compiler/rustc_passes/src/liveness/rwu_table.rs
deleted file mode 100644
index a1177946f8684..0000000000000
--- a/compiler/rustc_passes/src/liveness/rwu_table.rs
+++ /dev/null
@@ -1,146 +0,0 @@
-use std::iter;
-
-use crate::liveness::{LiveNode, Variable};
-
-#[derive(Clone, Copy)]
-pub(super) struct RWU {
-    pub(super) reader: bool,
-    pub(super) writer: bool,
-    pub(super) used: bool,
-}
-
-/// Conceptually, this is like a `Vec<Vec<RWU>>`. But the number of
-/// RWU's can get very large, so it uses a more compact representation.
-pub(super) struct RWUTable {
-    /// Total number of live nodes.
-    live_nodes: usize,
-    /// Total number of variables.
-    vars: usize,
-
-    /// A compressed representation of `RWU`s.
-    ///
-    /// Each word represents 2 different `RWU`s packed together. Each packed RWU
-    /// is stored in 4 bits: a reader bit, a writer bit, a used bit and a
-    /// padding bit.
-    ///
-    /// The data for each live node is contiguous and starts at a word boundary,
-    /// so there might be an unused space left.
-    words: Vec<u8>,
-    /// Number of words per each live node.
-    live_node_words: usize,
-}
-
-impl RWUTable {
-    const RWU_READER: u8 = 0b0001;
-    const RWU_WRITER: u8 = 0b0010;
-    const RWU_USED: u8 = 0b0100;
-    const RWU_MASK: u8 = 0b1111;
-
-    /// Size of packed RWU in bits.
-    const RWU_BITS: usize = 4;
-    /// Size of a word in bits.
-    const WORD_BITS: usize = size_of::<u8>() * 8;
-    /// Number of packed RWUs that fit into a single word.
-    const WORD_RWU_COUNT: usize = Self::WORD_BITS / Self::RWU_BITS;
-
-    pub(super) fn new(live_nodes: usize, vars: usize) -> RWUTable {
-        let live_node_words = vars.div_ceil(Self::WORD_RWU_COUNT);
-        Self { live_nodes, vars, live_node_words, words: vec![0u8; live_node_words * live_nodes] }
-    }
-
-    fn word_and_shift(&self, ln: LiveNode, var: Variable) -> (usize, u32) {
-        assert!(ln.index() < self.live_nodes);
-        assert!(var.index() < self.vars);
-
-        let var = var.index();
-        let word = var / Self::WORD_RWU_COUNT;
-        let shift = Self::RWU_BITS * (var % Self::WORD_RWU_COUNT);
-        (ln.index() * self.live_node_words + word, shift as u32)
-    }
-
-    fn pick2_rows_mut(&mut self, a: LiveNode, b: LiveNode) -> (&mut [u8], &mut [u8]) {
-        assert!(a.index() < self.live_nodes);
-        assert!(b.index() < self.live_nodes);
-        assert!(a != b);
-
-        let a_start = a.index() * self.live_node_words;
-        let b_start = b.index() * self.live_node_words;
-
-        unsafe {
-            let ptr = self.words.as_mut_ptr();
-            (
-                std::slice::from_raw_parts_mut(ptr.add(a_start), self.live_node_words),
-                std::slice::from_raw_parts_mut(ptr.add(b_start), self.live_node_words),
-            )
-        }
-    }
-
-    pub(super) fn copy(&mut self, dst: LiveNode, src: LiveNode) {
-        if dst == src {
-            return;
-        }
-
-        let (dst_row, src_row) = self.pick2_rows_mut(dst, src);
-        dst_row.copy_from_slice(src_row);
-    }
-
-    /// Sets `dst` to the union of `dst` and `src`, returns true if `dst` was
-    /// changed.
-    pub(super) fn union(&mut self, dst: LiveNode, src: LiveNode) -> bool {
-        if dst == src {
-            return false;
-        }
-
-        let mut changed = false;
-        let (dst_row, src_row) = self.pick2_rows_mut(dst, src);
-        for (dst_word, src_word) in iter::zip(dst_row, &*src_row) {
-            let old = *dst_word;
-            let new = *dst_word | src_word;
-            *dst_word = new;
-            changed |= old != new;
-        }
-        changed
-    }
-
-    pub(super) fn get_reader(&self, ln: LiveNode, var: Variable) -> bool {
-        let (word, shift) = self.word_and_shift(ln, var);
-        (self.words[word] >> shift) & Self::RWU_READER != 0
-    }
-
-    pub(super) fn get_writer(&self, ln: LiveNode, var: Variable) -> bool {
-        let (word, shift) = self.word_and_shift(ln, var);
-        (self.words[word] >> shift) & Self::RWU_WRITER != 0
-    }
-
-    pub(super) fn get_used(&self, ln: LiveNode, var: Variable) -> bool {
-        let (word, shift) = self.word_and_shift(ln, var);
-        (self.words[word] >> shift) & Self::RWU_USED != 0
-    }
-
-    pub(super) fn get(&self, ln: LiveNode, var: Variable) -> RWU {
-        let (word, shift) = self.word_and_shift(ln, var);
-        let rwu_packed = self.words[word] >> shift;
-        RWU {
-            reader: rwu_packed & Self::RWU_READER != 0,
-            writer: rwu_packed & Self::RWU_WRITER != 0,
-            used: rwu_packed & Self::RWU_USED != 0,
-        }
-    }
-
-    pub(super) fn set(&mut self, ln: LiveNode, var: Variable, rwu: RWU) {
-        let mut packed = 0;
-        if rwu.reader {
-            packed |= Self::RWU_READER;
-        }
-        if rwu.writer {
-            packed |= Self::RWU_WRITER;
-        }
-        if rwu.used {
-            packed |= Self::RWU_USED;
-        }
-
-        let (word, shift) = self.word_and_shift(ln, var);
-        let word = &mut self.words[word];
-        *word = (*word & !(Self::RWU_MASK << shift)) | (packed << shift)
-    }
-}
diff --git a/src/tools/clippy/tests/ui/needless_match.fixed b/src/tools/clippy/tests/ui/needless_match.fixed
index 41acf44023f63..57273012a192b 100644
--- a/src/tools/clippy/tests/ui/needless_match.fixed
+++ b/src/tools/clippy/tests/ui/needless_match.fixed
@@ -1,7 +1,7 @@
 #![warn(clippy::needless_match)]
 #![allow(clippy::manual_map)]
 #![allow(dead_code)]
-
+#![allow(unused)]
 #[derive(Clone, Copy)]
 enum Simple {
     A,
diff --git a/src/tools/clippy/tests/ui/needless_match.rs b/src/tools/clippy/tests/ui/needless_match.rs
index 936653b961bbb..3eb577868f2b4 100644
--- a/src/tools/clippy/tests/ui/needless_match.rs
+++ b/src/tools/clippy/tests/ui/needless_match.rs
@@ -1,7 +1,7 @@
 #![warn(clippy::needless_match)]
 #![allow(clippy::manual_map)]
 #![allow(dead_code)]
-
+#![allow(unused)]
 #[derive(Clone, Copy)]
 enum Simple {
     A,
diff --git a/src/tools/clippy/tests/ui/useless_conversion.fixed b/src/tools/clippy/tests/ui/useless_conversion.fixed
index ad30c94f34781..2942f64741e91 100644
--- a/src/tools/clippy/tests/ui/useless_conversion.fixed
+++ b/src/tools/clippy/tests/ui/useless_conversion.fixed
@@ -1,5 +1,5 @@
 #![deny(clippy::useless_conversion)]
-#![allow(clippy::needless_if, clippy::unnecessary_wraps)]
+#![allow(clippy::needless_if, clippy::unnecessary_wraps, unused)]
 // FIXME(static_mut_refs): Do not allow `static_mut_refs` lint
 #![allow(static_mut_refs)]
 
diff --git a/src/tools/clippy/tests/ui/useless_conversion.rs b/src/tools/clippy/tests/ui/useless_conversion.rs
index 505afb340009a..f2da414e9f652 100644
--- a/src/tools/clippy/tests/ui/useless_conversion.rs
+++ b/src/tools/clippy/tests/ui/useless_conversion.rs
@@ -1,5 +1,5 @@
 #![deny(clippy::useless_conversion)]
-#![allow(clippy::needless_if, clippy::unnecessary_wraps)]
+#![allow(clippy::needless_if, clippy::unnecessary_wraps, unused)]
 // FIXME(static_mut_refs): Do not allow `static_mut_refs` lint
 #![allow(static_mut_refs)]
 
diff --git a/tests/ui/asm/x86_64/goto.rs b/tests/ui/asm/x86_64/goto.rs
index c1dbce0d1c912..455bb3239895b 100644
--- a/tests/ui/asm/x86_64/goto.rs
+++ b/tests/ui/asm/x86_64/goto.rs
@@ -69,6 +69,7 @@ fn goto_out_jump() {
 fn goto_out_jump_noreturn() {
     unsafe {
         let mut value = false;
+        //~^ WARN value assigned to `value` is never read
         let mut out: usize;
         asm!(
             "lea {}, [{} + 1]",
diff --git a/tests/ui/asm/x86_64/goto.stderr b/tests/ui/asm/x86_64/goto.stderr
index f8f09f32f6cbc..230faf8001136 100644
--- a/tests/ui/asm/x86_64/goto.stderr
+++ b/tests/ui/asm/x86_64/goto.stderr
@@ -18,5 +18,14 @@ note: the lint level is defined here
 LL | #[warn(unreachable_code)]
    |        ^^^^^^^^^^^^^^^^
 
-warning: 1 warning emitted
+warning: value assigned to `value` is never read
+  --> $DIR/goto.rs:70:25
+   |
+LL |         let mut value = false;
+   |                         ^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+   = note: `#[warn(unused_assignments)]` on by default
+
+warning: 2 warnings emitted
 
diff --git a/tests/ui/async-await/async-closures/precise-captures.rs b/tests/ui/async-await/async-closures/precise-captures.rs
index 638fb67c3a465..d654906e8d4a1 100644
--- a/tests/ui/async-await/async-closures/precise-captures.rs
+++ b/tests/ui/async-await/async-closures/precise-captures.rs
@@ -10,6 +10,7 @@
 //   in <https://github.com/rust-lang/rust/pull/123350>.
 
 #![allow(unused_mut)]
+#![allow(unused_assignments)]
 
 extern crate block_on;
 
diff --git a/tests/ui/borrowck/borrowck-assign-to-subfield.rs b/tests/ui/borrowck/borrowck-assign-to-subfield.rs
index 27d9046e7b7cb..8e5192611ffd9 100644
--- a/tests/ui/borrowck/borrowck-assign-to-subfield.rs
+++ b/tests/ui/borrowck/borrowck-assign-to-subfield.rs
@@ -1,5 +1,6 @@
 //@ run-pass
 
+#[allow(unused)]
 pub fn main() {
     struct A {
         a: isize,
diff --git a/tests/ui/closures/2229_closure_analysis/diagnostics/liveness.rs b/tests/ui/closures/2229_closure_analysis/diagnostics/liveness.rs
index c550af21f0753..641066b002273 100644
--- a/tests/ui/closures/2229_closure_analysis/diagnostics/liveness.rs
+++ b/tests/ui/closures/2229_closure_analysis/diagnostics/liveness.rs
@@ -13,13 +13,11 @@ struct Point {
 
 pub fn f() {
     let mut a = 1;
-    let mut c = Point{ x:1, y:0 };
+    let mut c = Point { x: 1, y: 0 };
 
     // Captured by value, but variable is dead on entry.
     (move || {
-        // This will not trigger a warning for unused variable as
-        // c.x will be treated as a Non-tracked place
-        c.x = 1;
+        c.x = 1; //~ WARN value captured by `c.x` is never read
         println!("{}", c.x);
         a = 1; //~ WARN value captured by `a` is never read
         println!("{}", a);
@@ -27,10 +25,10 @@ pub fn f() {
 
     // Read and written to, but never actually used.
     (move || {
-        // This will not trigger a warning for unused variable as
-        // c.x will be treated as a Non-tracked place
-        c.x += 1;
-        a += 1; //~ WARN unused variable: `a`
+        c.x += 1; //~  WARN value captured by `c.x` is never read
+                  //~| WARN value assigned to `c.x` is never read
+        a += 1; //~  WARN value captured by `a` is never read
+                //~| WARN value assigned to `a` is never read
     })();
 
     (move || {
@@ -45,10 +43,7 @@ pub fn f() {
     let b = Box::new(42);
     (move || {
         println!("{}", c.x);
-        // Never read because this is FnOnce closure.
-        // This will not trigger a warning for unused variable as
-        // c.x will be treated as a Non-tracked place
-        c.x += 1;
+        c.x += 1; //~ WARN value assigned to `c.x` is never read
         println!("{}", a);
         a += 1; //~ WARN value assigned to `a` is never read
         drop(b);
@@ -56,35 +51,32 @@ pub fn f() {
 }
 
 #[derive(Debug)]
-struct MyStruct<'a>  {
-    x: Option<& 'a str>,
+struct MyStruct<'a> {
+    x: Option<&'a str>,
     y: i32,
 }
 
 pub fn nested() {
-    let mut a : Option<& str>;
+    let mut a: Option<&str>;
     a = None;
-    let mut b : Option<& str>;
+    let mut b: Option<&str>;
     b = None;
-    let mut d = MyStruct{ x: None, y: 1};
-    let mut e = MyStruct{ x: None, y: 1};
+    let mut d = MyStruct { x: None, y: 1 };
+    let mut e = MyStruct { x: None, y: 1 };
     (|| {
         (|| {
-            // This will not trigger a warning for unused variable as
-            // d.x will be treated as a Non-tracked place
-            d.x = Some("d1");
+            d.x = Some("d1"); //~ WARN value assigned to `d.x` is never read
             d.x = Some("d2");
             a = Some("d1"); //~ WARN value assigned to `a` is never read
             a = Some("d2");
         })();
         (move || {
-            // This will not trigger a warning for unused variable as
-            //e.x will be treated as a Non-tracked place
-            e.x = Some("e1");
-            e.x = Some("e2");
-            b = Some("e1"); //~ WARN value assigned to `b` is never read
-                            //~| WARN unused variable: `b`
-            b = Some("e2"); //~ WARN value assigned to `b` is never read
+            e.x = Some("e1"); //~  WARN value captured by `e.x` is never read
+                              //~| WARN value assigned to `e.x` is never read
+            e.x = Some("e2"); //~  WARN value assigned to `e.x` is never read
+            b = Some("e1"); //~  WARN value captured by `b` is never read
+                            //~| WARN value assigned to `b` is never read
+            b = Some("e2"); //~  WARN value assigned to `b` is never read
         })();
     })();
 }
diff --git a/tests/ui/closures/2229_closure_analysis/diagnostics/liveness.stderr b/tests/ui/closures/2229_closure_analysis/diagnostics/liveness.stderr
index cf414adc0b943..f697662d3ee93 100644
--- a/tests/ui/closures/2229_closure_analysis/diagnostics/liveness.stderr
+++ b/tests/ui/closures/2229_closure_analysis/diagnostics/liveness.stderr
@@ -1,10 +1,10 @@
-warning: value captured by `a` is never read
-  --> $DIR/liveness.rs:24:9
+warning: value assigned to `c.x` is never read
+  --> $DIR/liveness.rs:46:9
    |
-LL |         a = 1;
-   |         ^
+LL |         c.x += 1;
+   |         ^^^^^^^^
    |
-   = help: did you mean to capture by reference instead?
+   = help: maybe it is overwritten before being read?
 note: the lint level is defined here
   --> $DIR/liveness.rs:5:9
    |
@@ -12,54 +12,125 @@ LL | #![warn(unused)]
    |         ^^^^^^
    = note: `#[warn(unused_assignments)]` implied by `#[warn(unused)]`
 
-warning: unused variable: `a`
-  --> $DIR/liveness.rs:33:9
+warning: value assigned to `a` is never read
+  --> $DIR/liveness.rs:48:9
+   |
+LL |         a += 1;
+   |         ^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+warning: value captured by `c.x` is never read
+  --> $DIR/liveness.rs:28:9
+   |
+LL |         c.x += 1;
+   |         ^^^
+   |
+   = help: did you mean to capture by reference instead?
+
+warning: value assigned to `c.x` is never read
+  --> $DIR/liveness.rs:28:9
+   |
+LL |         c.x += 1;
+   |         ^^^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+warning: value captured by `a` is never read
+  --> $DIR/liveness.rs:30:9
    |
 LL |         a += 1;
    |         ^
    |
    = help: did you mean to capture by reference instead?
-   = note: `#[warn(unused_variables)]` implied by `#[warn(unused)]`
 
 warning: value assigned to `a` is never read
-  --> $DIR/liveness.rs:53:9
+  --> $DIR/liveness.rs:30:9
    |
 LL |         a += 1;
+   |         ^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+warning: value captured by `c.x` is never read
+  --> $DIR/liveness.rs:20:9
+   |
+LL |         c.x = 1;
+   |         ^^^
+   |
+   = help: did you mean to capture by reference instead?
+
+warning: value captured by `a` is never read
+  --> $DIR/liveness.rs:22:9
+   |
+LL |         a = 1;
    |         ^
    |
+   = help: did you mean to capture by reference instead?
+
+warning: value captured by `e.x` is never read
+  --> $DIR/liveness.rs:74:13
+   |
+LL |             e.x = Some("e1");
+   |             ^^^
+   |
+   = help: did you mean to capture by reference instead?
+
+warning: value assigned to `e.x` is never read
+  --> $DIR/liveness.rs:74:13
+   |
+LL |             e.x = Some("e1");
+   |             ^^^^^^^^^^^^^^^^
+   |
    = help: maybe it is overwritten before being read?
 
-warning: value assigned to `a` is never read
+warning: value assigned to `e.x` is never read
+  --> $DIR/liveness.rs:76:13
+   |
+LL |             e.x = Some("e2");
+   |             ^^^^^^^^^^^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+warning: value captured by `b` is never read
   --> $DIR/liveness.rs:77:13
    |
-LL |             a = Some("d1");
+LL |             b = Some("e1");
    |             ^
    |
-   = help: maybe it is overwritten before being read?
+   = help: did you mean to capture by reference instead?
 
 warning: value assigned to `b` is never read
-  --> $DIR/liveness.rs:85:13
+  --> $DIR/liveness.rs:77:13
    |
 LL |             b = Some("e1");
-   |             ^
+   |             ^^^^^^^^^^^^^^
    |
    = help: maybe it is overwritten before being read?
 
 warning: value assigned to `b` is never read
-  --> $DIR/liveness.rs:87:13
+  --> $DIR/liveness.rs:79:13
    |
 LL |             b = Some("e2");
-   |             ^
+   |             ^^^^^^^^^^^^^^
    |
    = help: maybe it is overwritten before being read?
 
-warning: unused variable: `b`
-  --> $DIR/liveness.rs:85:13
+warning: value assigned to `d.x` is never read
+  --> $DIR/liveness.rs:68:13
    |
-LL |             b = Some("e1");
-   |             ^
+LL |             d.x = Some("d1");
+   |             ^^^^^^^^^^^^^^^^
    |
-   = help: did you mean to capture by reference instead?
+   = help: maybe it is overwritten before being read?
+
+warning: value assigned to `a` is never read
+  --> $DIR/liveness.rs:70:13
+   |
+LL |             a = Some("d1");
+   |             ^^^^^^^^^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
 
-warning: 7 warnings emitted
+warning: 16 warnings emitted
 
diff --git a/tests/ui/closures/2229_closure_analysis/diagnostics/liveness_unintentional_copy.rs b/tests/ui/closures/2229_closure_analysis/diagnostics/liveness_unintentional_copy.rs
index bcd4d1090a411..2d4451d988ebc 100644
--- a/tests/ui/closures/2229_closure_analysis/diagnostics/liveness_unintentional_copy.rs
+++ b/tests/ui/closures/2229_closure_analysis/diagnostics/liveness_unintentional_copy.rs
@@ -12,14 +12,16 @@ struct MyStruct {
 
 pub fn unintentional_copy_one() {
     let mut a = 1;
-    let mut last = MyStruct{ a: 1, b: 1};
+    //~^ WARN unused variable: `a`
+    let mut last = MyStruct { a: 1, b: 1 };
+    //~^ WARN unused variable: `last`
     let mut f = move |s| {
-        // This will not trigger a warning for unused variable
-        // as last.a will be treated as a Non-tracked place
         last.a = s;
+        //~^ WARN value captured by `last.a` is never read
+        //~| WARN value assigned to `last.a` is never read
         a = s;
-        //~^ WARN value assigned to `a` is never read
-        //~| WARN unused variable: `a`
+        //~^ WARN value captured by `a` is never read
+        //~| WARN value assigned to `a` is never read
     };
     f(2);
     f(3);
@@ -28,12 +30,16 @@ pub fn unintentional_copy_one() {
 
 pub fn unintentional_copy_two() {
     let mut a = 1;
-    let mut sum = MyStruct{ a: 1, b: 0};
+    //~^ WARN unused variable: `a`
+    let mut sum = MyStruct { a: 1, b: 0 };
+    //~^ WARN unused variable: `sum`
     (1..10).for_each(move |x| {
-        // This will not trigger a warning for unused variable
-        // as sum.b will be treated as a Non-tracked place
         sum.b += x;
-        a += x; //~ WARN unused variable: `a`
+        //~^ WARN value captured by `sum.b` is never read
+        //~| WARN value assigned to `sum.b` is never read
+        a += x;
+        //~^ WARN value captured by `a` is never read
+        //~| WARN value assigned to `a` is never read
     });
 }
 
diff --git a/tests/ui/closures/2229_closure_analysis/diagnostics/liveness_unintentional_copy.stderr b/tests/ui/closures/2229_closure_analysis/diagnostics/liveness_unintentional_copy.stderr
index 0410de4c7982a..35b6d547eece0 100644
--- a/tests/ui/closures/2229_closure_analysis/diagnostics/liveness_unintentional_copy.stderr
+++ b/tests/ui/closures/2229_closure_analysis/diagnostics/liveness_unintentional_copy.stderr
@@ -1,10 +1,10 @@
-warning: value assigned to `a` is never read
-  --> $DIR/liveness_unintentional_copy.rs:20:9
+warning: value captured by `last.a` is never read
+  --> $DIR/liveness_unintentional_copy.rs:19:9
    |
-LL |         a = s;
-   |         ^
+LL |         last.a = s;
+   |         ^^^^^^
    |
-   = help: maybe it is overwritten before being read?
+   = help: did you mean to capture by reference instead?
 note: the lint level is defined here
   --> $DIR/liveness_unintentional_copy.rs:4:9
    |
@@ -12,22 +12,87 @@ LL | #![warn(unused)]
    |         ^^^^^^
    = note: `#[warn(unused_assignments)]` implied by `#[warn(unused)]`
 
-warning: unused variable: `a`
-  --> $DIR/liveness_unintentional_copy.rs:20:9
+warning: value assigned to `last.a` is never read
+  --> $DIR/liveness_unintentional_copy.rs:19:9
+   |
+LL |         last.a = s;
+   |         ^^^^^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+warning: value captured by `a` is never read
+  --> $DIR/liveness_unintentional_copy.rs:22:9
    |
 LL |         a = s;
    |         ^
    |
    = help: did you mean to capture by reference instead?
-   = note: `#[warn(unused_variables)]` implied by `#[warn(unused)]`
+
+warning: value assigned to `a` is never read
+  --> $DIR/liveness_unintentional_copy.rs:22:9
+   |
+LL |         a = s;
+   |         ^^^^^
+   |
+   = help: maybe it is overwritten before being read?
 
 warning: unused variable: `a`
-  --> $DIR/liveness_unintentional_copy.rs:36:9
+  --> $DIR/liveness_unintentional_copy.rs:14:9
+   |
+LL |     let mut a = 1;
+   |         ^^^^^ help: if this is intentional, prefix it with an underscore: `_a`
+   |
+   = note: `#[warn(unused_variables)]` implied by `#[warn(unused)]`
+
+warning: unused variable: `last`
+  --> $DIR/liveness_unintentional_copy.rs:16:9
+   |
+LL |     let mut last = MyStruct { a: 1, b: 1 };
+   |         ^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_last`
+
+warning: value captured by `sum.b` is never read
+  --> $DIR/liveness_unintentional_copy.rs:37:9
+   |
+LL |         sum.b += x;
+   |         ^^^^^
+   |
+   = help: did you mean to capture by reference instead?
+
+warning: value assigned to `sum.b` is never read
+  --> $DIR/liveness_unintentional_copy.rs:37:9
+   |
+LL |         sum.b += x;
+   |         ^^^^^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+warning: value captured by `a` is never read
+  --> $DIR/liveness_unintentional_copy.rs:40:9
    |
 LL |         a += x;
    |         ^
    |
    = help: did you mean to capture by reference instead?
 
-warning: 3 warnings emitted
+warning: value assigned to `a` is never read
+  --> $DIR/liveness_unintentional_copy.rs:40:9
+   |
+LL |         a += x;
+   |         ^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+warning: unused variable: `a`
+  --> $DIR/liveness_unintentional_copy.rs:32:9
+   |
+LL |     let mut a = 1;
+   |         ^^^^^ help: if this is intentional, prefix it with an underscore: `_a`
+
+warning: unused variable: `sum`
+  --> $DIR/liveness_unintentional_copy.rs:34:9
+   |
+LL |     let mut sum = MyStruct { a: 1, b: 0 };
+   |         ^^^^^^^ help: if this is intentional, prefix it with an underscore: `_sum`
+
+warning: 12 warnings emitted
 
diff --git a/tests/ui/closures/2229_closure_analysis/run_pass/destructure-pattern-closure-within-closure.stderr b/tests/ui/closures/2229_closure_analysis/run_pass/destructure-pattern-closure-within-closure.stderr
index cf8bd7a0a2765..40274c88318c3 100644
--- a/tests/ui/closures/2229_closure_analysis/run_pass/destructure-pattern-closure-within-closure.stderr
+++ b/tests/ui/closures/2229_closure_analysis/run_pass/destructure-pattern-closure-within-closure.stderr
@@ -1,8 +1,8 @@
-warning: unused variable: `g2`
-  --> $DIR/destructure-pattern-closure-within-closure.rs:10:17
+warning: unused variable: `t2`
+  --> $DIR/destructure-pattern-closure-within-closure.rs:13:21
    |
-LL |         let (_, g2) = g;
-   |                 ^^ help: if this is intentional, prefix it with an underscore: `_g2`
+LL |             let (_, t2) = t;
+   |                     ^^ help: if this is intentional, prefix it with an underscore: `_t2`
    |
 note: the lint level is defined here
   --> $DIR/destructure-pattern-closure-within-closure.rs:3:9
@@ -11,11 +11,11 @@ LL | #![warn(unused)]
    |         ^^^^^^
    = note: `#[warn(unused_variables)]` implied by `#[warn(unused)]`
 
-warning: unused variable: `t2`
-  --> $DIR/destructure-pattern-closure-within-closure.rs:13:21
+warning: unused variable: `g2`
+  --> $DIR/destructure-pattern-closure-within-closure.rs:10:17
    |
-LL |             let (_, t2) = t;
-   |                     ^^ help: if this is intentional, prefix it with an underscore: `_t2`
+LL |         let (_, g2) = g;
+   |                 ^^ help: if this is intentional, prefix it with an underscore: `_g2`
 
 warning: 2 warnings emitted
 
diff --git a/tests/ui/closures/moved-upvar-mut-rebind-11958.rs b/tests/ui/closures/moved-upvar-mut-rebind-11958.rs
index 701dc1a2cefd2..f308028bdd7b6 100644
--- a/tests/ui/closures/moved-upvar-mut-rebind-11958.rs
+++ b/tests/ui/closures/moved-upvar-mut-rebind-11958.rs
@@ -7,7 +7,8 @@
 
 pub fn main() {
     let mut x = 1;
+    //~^ WARN unused variable: `x`
     let _thunk = Box::new(move|| { x = 2; });
-    //~^ WARN value assigned to `x` is never read
-    //~| WARN unused variable: `x`
+    //~^ WARN value captured by `x` is never read
+    //~| WARN value assigned to `x` is never read
 }
diff --git a/tests/ui/closures/moved-upvar-mut-rebind-11958.stderr b/tests/ui/closures/moved-upvar-mut-rebind-11958.stderr
index 1bf8a8b23a1d0..e28db65392a4b 100644
--- a/tests/ui/closures/moved-upvar-mut-rebind-11958.stderr
+++ b/tests/ui/closures/moved-upvar-mut-rebind-11958.stderr
@@ -1,20 +1,27 @@
-warning: value assigned to `x` is never read
-  --> $DIR/moved-upvar-mut-rebind-11958.rs:10:36
+warning: value captured by `x` is never read
+  --> $DIR/moved-upvar-mut-rebind-11958.rs:11:36
    |
 LL |     let _thunk = Box::new(move|| { x = 2; });
    |                                    ^
    |
-   = help: maybe it is overwritten before being read?
+   = help: did you mean to capture by reference instead?
    = note: `#[warn(unused_assignments)]` (part of `#[warn(unused)]`) on by default
 
-warning: unused variable: `x`
-  --> $DIR/moved-upvar-mut-rebind-11958.rs:10:36
+warning: value assigned to `x` is never read
+  --> $DIR/moved-upvar-mut-rebind-11958.rs:11:36
    |
 LL |     let _thunk = Box::new(move|| { x = 2; });
-   |                                    ^
+   |                                    ^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+warning: unused variable: `x`
+  --> $DIR/moved-upvar-mut-rebind-11958.rs:9:9
+   |
+LL |     let mut x = 1;
+   |         ^^^^^ help: if this is intentional, prefix it with an underscore: `_x`
    |
-   = help: did you mean to capture by reference instead?
    = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default
 
-warning: 2 warnings emitted
+warning: 3 warnings emitted
 
diff --git a/tests/ui/const-generics/defaults/trait_object_lt_defaults.rs b/tests/ui/const-generics/defaults/trait_object_lt_defaults.rs
index 39dd6cb031f79..da25c0146c543 100644
--- a/tests/ui/const-generics/defaults/trait_object_lt_defaults.rs
+++ b/tests/ui/const-generics/defaults/trait_object_lt_defaults.rs
@@ -1,6 +1,6 @@
 //@ aux-build:trait_object_lt_defaults_lib.rs
 //@ run-pass
-#![allow(dead_code)]
+#![allow(dead_code, unused)]
 extern crate trait_object_lt_defaults_lib;
 
 // Tests that `A<'a, 3, dyn Test>` is short for `A<'a, 3, dyn Test + 'a>`
diff --git a/tests/ui/drop/or-pattern-drop-order.rs b/tests/ui/drop/or-pattern-drop-order.rs
index cca81673ac3ac..88355a4937e4f 100644
--- a/tests/ui/drop/or-pattern-drop-order.rs
+++ b/tests/ui/drop/or-pattern-drop-order.rs
@@ -25,7 +25,7 @@ fn assert_drop_order(expected_drops: impl IntoIterator<Item = u32>, f: impl Fn(&
     assert_eq!(order, correct_order);
 }
 
-#[expect(unused_variables, unused_assignments, irrefutable_let_patterns)]
+#[expect(unused_variables, irrefutable_let_patterns)]
 fn main() {
     // When bindings are declared with `let pat;`, they're visited in left-to-right order, using the
     // order given by the first occurrence of each variable. They're later dropped in reverse.
diff --git a/tests/ui/dropck/dropck-empty-array.rs b/tests/ui/dropck/dropck-empty-array.rs
index f3eca6aed8d5e..5df274d455420 100644
--- a/tests/ui/dropck/dropck-empty-array.rs
+++ b/tests/ui/dropck/dropck-empty-array.rs
@@ -1,6 +1,7 @@
 //@ run-pass
 
-#[allow(dead_code)]
+#![allow(dead_code, unused_variables, unused_assignments)]
+
 struct Struct<'s>(&'s str);
 
 impl<'s> Drop for Struct<'s> {
diff --git a/tests/ui/fn/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.stderr b/tests/ui/fn/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.stderr
index c2c7378f07a20..98cdafaf8b799 100644
--- a/tests/ui/fn/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.stderr
+++ b/tests/ui/fn/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.stderr
@@ -14,25 +14,6 @@ LL |    let object2 = Object;
 LL ~    *object = object2;
    |
 
-error: value assigned to `object` is never read
-  --> $DIR/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.rs:14:4
-   |
-LL |    object = &object2;
-   |    ^^^^^^
-   |
-note: the lint level is defined here
-  --> $DIR/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.rs:2:9
-   |
-LL | #![deny(unused_assignments)]
-   |         ^^^^^^^^^^^^^^^^^^
-help: you might have meant to mutate the pointed at value being passed in, instead of changing the reference in the local binding
-   |
-LL ~ fn change_object2(object: &mut Object) {
-LL |
-LL |    let object2 = Object;
-LL ~    *object = object2;
-   |
-
 error[E0597]: `object2` does not live long enough
   --> $DIR/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.rs:14:13
    |
@@ -51,17 +32,22 @@ LL | }
    | - `object2` dropped here while still borrowed
 
 error: value assigned to `object` is never read
-  --> $DIR/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.rs:22:5
+  --> $DIR/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.rs:14:4
    |
-LL |     object = &mut object2;
-   |     ^^^^^^
+LL |    object = &object2;
+   |    ^^^^^^^^^^^^^^^^^
+   |
+note: the lint level is defined here
+  --> $DIR/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.rs:2:9
    |
+LL | #![deny(unused_assignments)]
+   |         ^^^^^^^^^^^^^^^^^^
 help: you might have meant to mutate the pointed at value being passed in, instead of changing the reference in the local binding
    |
-LL ~ fn change_object3(object: &mut Object) {
+LL ~ fn change_object2(object: &mut Object) {
 LL |
-LL |     let object2 = Object;
-LL ~     *object = object2;
+LL |    let object2 = Object;
+LL ~    *object = object2;
    |
 
 error[E0596]: cannot borrow `object2` as mutable, as it is not declared as mutable
@@ -75,6 +61,20 @@ help: consider changing this to be mutable
 LL |     let mut object2 = Object;
    |         +++
 
+error: value assigned to `object` is never read
+  --> $DIR/mut-arg-of-borrowed-type-meant-to-be-arg-of-mut-borrow.rs:22:5
+   |
+LL |     object = &mut object2;
+   |     ^^^^^^^^^^^^^^^^^^^^^
+   |
+help: you might have meant to mutate the pointed at value being passed in, instead of changing the reference in the local binding
+   |
+LL ~ fn change_object3(object: &mut Object) {
+LL |
+LL |     let object2 = Object;
+LL ~     *object = object2;
+   |
+
 error: aborting due to 5 previous errors
 
 Some errors have detailed explanations: E0308, E0596, E0597.
diff --git a/tests/ui/issues/issue-19367.rs b/tests/ui/issues/issue-19367.rs
index ce8451dd2de13..1cd6c483375ab 100644
--- a/tests/ui/issues/issue-19367.rs
+++ b/tests/ui/issues/issue-19367.rs
@@ -1,4 +1,7 @@
 //@ run-pass
+
+#![allow(unused_assignments)]
+
 struct S {
     o: Option<String>
 }
diff --git a/tests/ui/lint/dead-code/issue-85071-2.stderr b/tests/ui/lint/dead-code/issue-85071-2.stderr
index ab88d72359695..5cc94e25e3a69 100644
--- a/tests/ui/lint/dead-code/issue-85071-2.stderr
+++ b/tests/ui/lint/dead-code/issue-85071-2.stderr
@@ -1,15 +1,3 @@
-warning: unused variable: `x`
-  --> $DIR/issue-85071-2.rs:18:9
-   |
-LL |     let x = s.f();
-   |         ^ help: if this is intentional, prefix it with an underscore: `_x`
-   |
-note: the lint level is defined here
-  --> $DIR/issue-85071-2.rs:7:9
-   |
-LL | #![warn(unused_variables,unreachable_code)]
-   |         ^^^^^^^^^^^^^^^^
-
 warning: unreachable definition
   --> $DIR/issue-85071-2.rs:18:9
    |
@@ -29,5 +17,17 @@ note: the lint level is defined here
 LL | #![warn(unused_variables,unreachable_code)]
    |                          ^^^^^^^^^^^^^^^^
 
+warning: unused variable: `x`
+  --> $DIR/issue-85071-2.rs:18:9
+   |
+LL |     let x = s.f();
+   |         ^ help: if this is intentional, prefix it with an underscore: `_x`
+   |
+note: the lint level is defined here
+  --> $DIR/issue-85071-2.rs:7:9
+   |
+LL | #![warn(unused_variables,unreachable_code)]
+   |         ^^^^^^^^^^^^^^^^
+
 warning: 2 warnings emitted
 
diff --git a/tests/ui/lint/dead-code/issue-85071.stderr b/tests/ui/lint/dead-code/issue-85071.stderr
index c94923063903a..b95ae09385dec 100644
--- a/tests/ui/lint/dead-code/issue-85071.stderr
+++ b/tests/ui/lint/dead-code/issue-85071.stderr
@@ -1,15 +1,3 @@
-warning: unused variable: `x`
-  --> $DIR/issue-85071.rs:15:9
-   |
-LL |     let x = f();
-   |         ^ help: if this is intentional, prefix it with an underscore: `_x`
-   |
-note: the lint level is defined here
-  --> $DIR/issue-85071.rs:9:9
-   |
-LL | #![warn(unused_variables,unreachable_code)]
-   |         ^^^^^^^^^^^^^^^^
-
 warning: unreachable definition
   --> $DIR/issue-85071.rs:15:9
    |
@@ -29,5 +17,17 @@ note: the lint level is defined here
 LL | #![warn(unused_variables,unreachable_code)]
    |                          ^^^^^^^^^^^^^^^^
 
+warning: unused variable: `x`
+  --> $DIR/issue-85071.rs:15:9
+   |
+LL |     let x = f();
+   |         ^ help: if this is intentional, prefix it with an underscore: `_x`
+   |
+note: the lint level is defined here
+  --> $DIR/issue-85071.rs:9:9
+   |
+LL | #![warn(unused_variables,unreachable_code)]
+   |         ^^^^^^^^^^^^^^^^
+
 warning: 2 warnings emitted
 
diff --git a/tests/ui/lint/future-incompat-json-test.stderr b/tests/ui/lint/future-incompat-json-test.stderr
index bf29b9577db5e..2e7d0cf626f1d 100644
--- a/tests/ui/lint/future-incompat-json-test.stderr
+++ b/tests/ui/lint/future-incompat-json-test.stderr
@@ -1,4 +1,4 @@
-{"$message_type":"future_incompat","future_incompat_report":[{"diagnostic":{"$message_type":"diagnostic","message":"unused variable: `x`","code":{"code":"unused_variables","explanation":null},"level":"warning","spans":[{"file_name":"$DIR/future-incompat-json-test.rs","byte_start":340,"byte_end":341,"line_start":9,"line_end":9,"column_start":9,"column_end":10,"is_primary":true,"text":[{"text":"    let x = 1;","highlight_start":9,"highlight_end":10}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"if this is intentional, prefix it with an underscore","code":null,"level":"help","spans":[{"file_name":"$DIR/future-incompat-json-test.rs","byte_start":340,"byte_end":341,"line_start":9,"line_end":9,"column_start":9,"column_end":10,"is_primary":true,"text":[{"text":"    let x = 1;","highlight_start":9,"highlight_end":10}],"label":null,"suggested_replacement":"_x","suggestion_applicability":"MaybeIncorrect","expansion":null}],"children":[],"rendered":null}],"rendered":"warning: unused variable: `x`
+{"$message_type":"future_incompat","future_incompat_report":[{"diagnostic":{"$message_type":"diagnostic","message":"unused variable: `x`","code":{"code":"unused_variables","explanation":null},"level":"warning","spans":[{"file_name":"$DIR/future-incompat-json-test.rs","byte_start":340,"byte_end":341,"line_start":9,"line_end":9,"column_start":9,"column_end":10,"is_primary":true,"text":[{"text":"    let x = 1;","highlight_start":9,"highlight_end":10}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"if this is intentional, prefix it with an underscore","code":null,"level":"help","spans":[{"file_name":"$DIR/future-incompat-json-test.rs","byte_start":340,"byte_end":341,"line_start":9,"line_end":9,"column_start":9,"column_end":10,"is_primary":true,"text":[{"text":"    let x = 1;","highlight_start":9,"highlight_end":10}],"label":null,"suggested_replacement":"_x","suggestion_applicability":"MachineApplicable","expansion":null}],"children":[],"rendered":null}],"rendered":"warning: unused variable: `x`
   --> $DIR/future-incompat-json-test.rs:9:9
    |
 LL |     let x = 1;
diff --git a/tests/ui/lint/issue-49588-non-shorthand-field-patterns-in-pattern-macro.rs b/tests/ui/lint/issue-49588-non-shorthand-field-patterns-in-pattern-macro.rs
index 8e74531e7762a..5b5843a8ddbb6 100644
--- a/tests/ui/lint/issue-49588-non-shorthand-field-patterns-in-pattern-macro.rs
+++ b/tests/ui/lint/issue-49588-non-shorthand-field-patterns-in-pattern-macro.rs
@@ -13,4 +13,5 @@ macro_rules! pat {
 
 fn main() {
     let pat!(value) = Value { value: () };
+    //~^ WARN value assigned to `value` is never read
 }
diff --git a/tests/ui/lint/issue-49588-non-shorthand-field-patterns-in-pattern-macro.stderr b/tests/ui/lint/issue-49588-non-shorthand-field-patterns-in-pattern-macro.stderr
new file mode 100644
index 0000000000000..ba7d3515b0d8d
--- /dev/null
+++ b/tests/ui/lint/issue-49588-non-shorthand-field-patterns-in-pattern-macro.stderr
@@ -0,0 +1,11 @@
+warning: value assigned to `value` is never read
+  --> $DIR/issue-49588-non-shorthand-field-patterns-in-pattern-macro.rs:15:14
+   |
+LL |     let pat!(value) = Value { value: () };
+   |              ^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+   = note: `#[warn(unused_assignments)]` (part of `#[warn(unused)]`) on by default
+
+warning: 1 warning emitted
+
diff --git a/tests/ui/lint/non-snake-case/lint-uppercase-variables.stderr b/tests/ui/lint/non-snake-case/lint-uppercase-variables.stderr
index 5dec20b2ac7ea..b0c56003957c9 100644
--- a/tests/ui/lint/non-snake-case/lint-uppercase-variables.stderr
+++ b/tests/ui/lint/non-snake-case/lint-uppercase-variables.stderr
@@ -16,7 +16,7 @@ warning: unused variable: `Foo`
   --> $DIR/lint-uppercase-variables.rs:22:9
    |
 LL |         Foo => {}
-   |         ^^^
+   |         ^^^ help: if this is intentional, prefix it with an underscore: `_Foo`
    |
 note: the lint level is defined here
   --> $DIR/lint-uppercase-variables.rs:1:9
@@ -24,29 +24,12 @@ note: the lint level is defined here
 LL | #![warn(unused)]
    |         ^^^^^^
    = note: `#[warn(unused_variables)]` implied by `#[warn(unused)]`
-help: if this is intentional, prefix it with an underscore
-   |
-LL |         _Foo => {}
-   |         +
-help: you might have meant to pattern match on the similarly named variant `Foo`
-   |
-LL |         foo::Foo::Foo => {}
-   |         ++++++++++
 
 warning: unused variable: `Foo`
   --> $DIR/lint-uppercase-variables.rs:28:9
    |
 LL |     let Foo = foo::Foo::Foo;
-   |         ^^^
-   |
-help: if this is intentional, prefix it with an underscore
-   |
-LL |     let _Foo = foo::Foo::Foo;
-   |         +
-help: you might have meant to pattern match on the similarly named variant `Foo`
-   |
-LL |     let foo::Foo::Foo = foo::Foo::Foo;
-   |         ++++++++++
+   |         ^^^ help: if this is intentional, prefix it with an underscore: `_Foo`
 
 error[E0170]: pattern binding `Foo` is named the same as one of the variants of the type `foo::Foo`
   --> $DIR/lint-uppercase-variables.rs:33:17
diff --git a/tests/ui/lint/rfc-2383-lint-reason/expect_lint_from_macro.stderr b/tests/ui/lint/rfc-2383-lint-reason/expect_lint_from_macro.stderr
index 49dba1c7ffe8c..b09270d94ba31 100644
--- a/tests/ui/lint/rfc-2383-lint-reason/expect_lint_from_macro.stderr
+++ b/tests/ui/lint/rfc-2383-lint-reason/expect_lint_from_macro.stderr
@@ -2,11 +2,19 @@ warning: unused variable: `x`
   --> $DIR/expect_lint_from_macro.rs:7:13
    |
 LL |         let x = 0;
-   |             ^ help: if this is intentional, prefix it with an underscore: `_x`
+   |             ^
 ...
 LL |     trigger_unused_variables_macro!();
    |     --------------------------------- in this macro invocation
    |
+help: `x` is captured in macro and introduced a unused variable
+  --> $DIR/expect_lint_from_macro.rs:7:13
+   |
+LL |         let x = 0;
+   |             ^
+...
+LL |     trigger_unused_variables_macro!();
+   |     --------------------------------- in this macro invocation
 note: the lint level is defined here
   --> $DIR/expect_lint_from_macro.rs:3:9
    |
@@ -18,11 +26,19 @@ warning: unused variable: `x`
   --> $DIR/expect_lint_from_macro.rs:7:13
    |
 LL |         let x = 0;
-   |             ^ help: if this is intentional, prefix it with an underscore: `_x`
+   |             ^
 ...
 LL |     trigger_unused_variables_macro!();
    |     --------------------------------- in this macro invocation
    |
+help: `x` is captured in macro and introduced a unused variable
+  --> $DIR/expect_lint_from_macro.rs:7:13
+   |
+LL |         let x = 0;
+   |             ^
+...
+LL |     trigger_unused_variables_macro!();
+   |     --------------------------------- in this macro invocation
    = note: this warning originates in the macro `trigger_unused_variables_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 warning: 2 warnings emitted
diff --git a/tests/ui/lint/rfc-2383-lint-reason/force_warn_expected_lints_fulfilled.stderr b/tests/ui/lint/rfc-2383-lint-reason/force_warn_expected_lints_fulfilled.stderr
index eaf9edd8e8fee..dbfdfc7d4fa7a 100644
--- a/tests/ui/lint/rfc-2383-lint-reason/force_warn_expected_lints_fulfilled.stderr
+++ b/tests/ui/lint/rfc-2383-lint-reason/force_warn_expected_lints_fulfilled.stderr
@@ -14,12 +14,6 @@ LL |     let x = 2;
    |
    = note: requested on the command line with `--force-warn unused-variables`
 
-warning: unused variable: `fox_name`
-  --> $DIR/force_warn_expected_lints_fulfilled.rs:26:9
-   |
-LL |     let fox_name = "Sir Nibbles";
-   |         ^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_fox_name`
-
 warning: variable does not need to be mutable
   --> $DIR/force_warn_expected_lints_fulfilled.rs:30:9
    |
@@ -30,6 +24,12 @@ LL |     let mut what_does_the_fox_say = "*ding* *deng* *dung*";
    |
    = note: requested on the command line with `--force-warn unused-mut`
 
+warning: unused variable: `fox_name`
+  --> $DIR/force_warn_expected_lints_fulfilled.rs:26:9
+   |
+LL |     let fox_name = "Sir Nibbles";
+   |         ^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_fox_name`
+
 warning: unused variable: `this_should_fulfill_the_expectation`
   --> $DIR/force_warn_expected_lints_fulfilled.rs:41:9
    |
diff --git a/tests/ui/lint/unused/issue-117284-arg-in-macro.rs b/tests/ui/lint/unused/issue-117284-arg-in-macro.rs
index eea0f4c594dc8..3d622b6991300 100644
--- a/tests/ui/lint/unused/issue-117284-arg-in-macro.rs
+++ b/tests/ui/lint/unused/issue-117284-arg-in-macro.rs
@@ -1,7 +1,7 @@
 #![deny(unused_variables)]
 macro_rules! make_var {
     ($struct:ident, $var:ident) => {
-        let $var = $struct.$var;
+        let $var = $struct.$var; //~ ERROR unused variable: `var`
     };
 }
 
@@ -12,6 +12,6 @@ struct MyStruct {
 
 fn main() {
     let s = MyStruct { var: 42 };
-    make_var!(s, var); //~ ERROR unused variable: `var`
+    make_var!(s, var);
     let a = 1; //~ ERROR unused variable: `a`
 }
diff --git a/tests/ui/lint/unused/issue-117284-arg-in-macro.stderr b/tests/ui/lint/unused/issue-117284-arg-in-macro.stderr
index 84efaa4f3687b..b4a6871713c06 100644
--- a/tests/ui/lint/unused/issue-117284-arg-in-macro.stderr
+++ b/tests/ui/lint/unused/issue-117284-arg-in-macro.stderr
@@ -1,8 +1,11 @@
 error: unused variable: `var`
-  --> $DIR/issue-117284-arg-in-macro.rs:15:18
+  --> $DIR/issue-117284-arg-in-macro.rs:4:13
    |
+LL |         let $var = $struct.$var;
+   |             ^^^^
+...
 LL |     make_var!(s, var);
-   |                  ^^^
+   |     ----------------- in this macro invocation
    |
 help: `var` is captured in macro and introduced a unused variable
   --> $DIR/issue-117284-arg-in-macro.rs:4:13
diff --git a/tests/ui/lint/unused/issue-47390-unused-variable-in-struct-pattern.stderr b/tests/ui/lint/unused/issue-47390-unused-variable-in-struct-pattern.stderr
index fe2e3afc82ec8..c378b307b8b54 100644
--- a/tests/ui/lint/unused/issue-47390-unused-variable-in-struct-pattern.stderr
+++ b/tests/ui/lint/unused/issue-47390-unused-variable-in-struct-pattern.stderr
@@ -1,27 +1,45 @@
-warning: unused variable: `i_think_continually`
-  --> $DIR/issue-47390-unused-variable-in-struct-pattern.rs:26:9
+warning: variable does not need to be mutable
+  --> $DIR/issue-47390-unused-variable-in-struct-pattern.rs:33:9
    |
-LL |     let i_think_continually = 2;
-   |         ^^^^^^^^^^^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_i_think_continually`
+LL |     let mut mut_unused_var = 1;
+   |         ----^^^^^^^^^^^^^^
+   |         |
+   |         help: remove this `mut`
    |
 note: the lint level is defined here
   --> $DIR/issue-47390-unused-variable-in-struct-pattern.rs:5:9
    |
 LL | #![warn(unused)] // UI tests pass `-A unused` (#43896)
    |         ^^^^^^
+   = note: `#[warn(unused_mut)]` implied by `#[warn(unused)]`
+
+warning: variable does not need to be mutable
+  --> $DIR/issue-47390-unused-variable-in-struct-pattern.rs:37:10
+   |
+LL |     let (mut var, unused_var) = (1, 2);
+   |          ----^^^
+   |          |
+   |          help: remove this `mut`
+
+warning: unused variable: `i_think_continually`
+  --> $DIR/issue-47390-unused-variable-in-struct-pattern.rs:26:9
+   |
+LL |     let i_think_continually = 2;
+   |         ^^^^^^^^^^^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_i_think_continually`
+   |
    = note: `#[warn(unused_variables)]` implied by `#[warn(unused)]`
 
 warning: unused variable: `mut_unused_var`
-  --> $DIR/issue-47390-unused-variable-in-struct-pattern.rs:33:13
+  --> $DIR/issue-47390-unused-variable-in-struct-pattern.rs:33:9
    |
 LL |     let mut mut_unused_var = 1;
-   |             ^^^^^^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_mut_unused_var`
+   |         ^^^^^^^^^^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_mut_unused_var`
 
 warning: unused variable: `var`
-  --> $DIR/issue-47390-unused-variable-in-struct-pattern.rs:37:14
+  --> $DIR/issue-47390-unused-variable-in-struct-pattern.rs:37:10
    |
 LL |     let (mut var, unused_var) = (1, 2);
-   |              ^^^ help: if this is intentional, prefix it with an underscore: `_var`
+   |          ^^^^^^^ help: if this is intentional, prefix it with an underscore: `_var`
 
 warning: unused variable: `unused_var`
   --> $DIR/issue-47390-unused-variable-in-struct-pattern.rs:37:19
@@ -36,22 +54,13 @@ LL |     if let SoulHistory { corridors_of_light,
    |                          ^^^^^^^^^^^^^^^^^^ help: try ignoring the field: `corridors_of_light: _`
 
 warning: variable `hours_are_suns` is assigned to, but never used
-  --> $DIR/issue-47390-unused-variable-in-struct-pattern.rs:46:30
+  --> $DIR/issue-47390-unused-variable-in-struct-pattern.rs:46:26
    |
 LL |                          mut hours_are_suns,
-   |                              ^^^^^^^^^^^^^^
+   |                          ^^^^^^^^^^^^^^^^^^
    |
    = note: consider using `_hours_are_suns` instead
 
-warning: value assigned to `hours_are_suns` is never read
-  --> $DIR/issue-47390-unused-variable-in-struct-pattern.rs:48:9
-   |
-LL |         hours_are_suns = false;
-   |         ^^^^^^^^^^^^^^
-   |
-   = help: maybe it is overwritten before being read?
-   = note: `#[warn(unused_assignments)]` implied by `#[warn(unused)]`
-
 warning: unused variable: `fire`
   --> $DIR/issue-47390-unused-variable-in-struct-pattern.rs:52:32
    |
@@ -94,23 +103,14 @@ warning: unused variable: `case`
 LL |         Tuple(Large::Suit { case }, ()) => {}
    |                             ^^^^ help: try ignoring the field: `case: _`
 
-warning: variable does not need to be mutable
-  --> $DIR/issue-47390-unused-variable-in-struct-pattern.rs:33:9
-   |
-LL |     let mut mut_unused_var = 1;
-   |         ----^^^^^^^^^^^^^^
-   |         |
-   |         help: remove this `mut`
+warning: value assigned to `hours_are_suns` is never read
+  --> $DIR/issue-47390-unused-variable-in-struct-pattern.rs:48:9
    |
-   = note: `#[warn(unused_mut)]` implied by `#[warn(unused)]`
-
-warning: variable does not need to be mutable
-  --> $DIR/issue-47390-unused-variable-in-struct-pattern.rs:37:10
+LL |         hours_are_suns = false;
+   |         ^^^^^^^^^^^^^^^^^^^^^^
    |
-LL |     let (mut var, unused_var) = (1, 2);
-   |          ----^^^
-   |          |
-   |          help: remove this `mut`
+   = help: maybe it is overwritten before being read?
+   = note: `#[warn(unused_assignments)]` implied by `#[warn(unused)]`
 
 warning: 16 warnings emitted
 
diff --git a/tests/ui/lint/unused/issue-54180-unused-ref-field.stderr b/tests/ui/lint/unused/issue-54180-unused-ref-field.stderr
index f2e6168998c44..c501aa25f1352 100644
--- a/tests/ui/lint/unused/issue-54180-unused-ref-field.stderr
+++ b/tests/ui/lint/unused/issue-54180-unused-ref-field.stderr
@@ -11,6 +11,12 @@ LL | #![deny(unused)]
    |         ^^^^^^
    = note: `#[deny(unused_variables)]` implied by `#[deny(unused)]`
 
+error: unused variable: `x`
+  --> $DIR/issue-54180-unused-ref-field.rs:29:45
+   |
+LL |     let _: i32 = points.iter().map(|Point { x, y }| y).sum();
+   |                                             ^ help: try ignoring the field: `x: _`
+
 error: unused variable: `f1`
   --> $DIR/issue-54180-unused-ref-field.rs:26:13
    |
@@ -23,11 +29,5 @@ error: unused variable: `x`
 LL |         Point { y, ref mut x } => y,
    |                    ^^^^^^^^^ help: try ignoring the field: `x: _`
 
-error: unused variable: `x`
-  --> $DIR/issue-54180-unused-ref-field.rs:29:45
-   |
-LL |     let _: i32 = points.iter().map(|Point { x, y }| y).sum();
-   |                                             ^ help: try ignoring the field: `x: _`
-
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/lint/unused/lint-unused-variables.stderr b/tests/ui/lint/unused/lint-unused-variables.stderr
index 6106d4cd1bfc9..beb1c0d736b35 100644
--- a/tests/ui/lint/unused/lint-unused-variables.stderr
+++ b/tests/ui/lint/unused/lint-unused-variables.stderr
@@ -10,24 +10,18 @@ note: the lint level is defined here
 LL | #![deny(unused_variables)]
    |         ^^^^^^^^^^^^^^^^
 
-error: unused variable: `a`
-  --> $DIR/lint-unused-variables.rs:21:9
+error: unused variable: `b`
+  --> $DIR/lint-unused-variables.rs:13:5
    |
-LL |         a: i32,
-   |         ^ help: if this is intentional, prefix it with an underscore: `_a`
+LL |     b: i32,
+   |     ^ help: if this is intentional, prefix it with an underscore: `_b`
 
 error: unused variable: `a`
-  --> $DIR/lint-unused-variables.rs:67:9
+  --> $DIR/lint-unused-variables.rs:21:9
    |
 LL |         a: i32,
    |         ^ help: if this is intentional, prefix it with an underscore: `_a`
 
-error: unused variable: `b`
-  --> $DIR/lint-unused-variables.rs:13:5
-   |
-LL |     b: i32,
-   |     ^ help: if this is intentional, prefix it with an underscore: `_b`
-
 error: unused variable: `b`
   --> $DIR/lint-unused-variables.rs:28:9
    |
@@ -70,5 +64,11 @@ 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:67:9
+   |
+LL |         a: i32,
+   |         ^ help: if this is intentional, prefix it with an underscore: `_a`
+
 error: aborting due to 11 previous errors
 
diff --git a/tests/ui/liveness/liveness-asm.stderr b/tests/ui/liveness/liveness-asm.stderr
index 57d89e44dcb86..ca1c07046d0ef 100644
--- a/tests/ui/liveness/liveness-asm.stderr
+++ b/tests/ui/liveness/liveness-asm.stderr
@@ -1,8 +1,8 @@
 warning: value assigned to `src` is never read
-  --> $DIR/liveness-asm.rs:14:32
+  --> $DIR/liveness-asm.rs:14:5
    |
 LL |     asm!("/*{0}*/", inout(reg) src);
-   |                                ^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: maybe it is overwritten before being read?
 note: the lint level is defined here
@@ -12,10 +12,10 @@ LL | #![warn(unused_assignments)]
    |         ^^^^^^^^^^^^^^^^^^
 
 warning: value assigned to `src` is never read
-  --> $DIR/liveness-asm.rs:24:39
+  --> $DIR/liveness-asm.rs:24:5
    |
 LL |     asm!("/*{0}*/", inout(reg) src => src);
-   |                                       ^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: maybe it is overwritten before being read?
 
diff --git a/tests/ui/liveness/liveness-consts.rs b/tests/ui/liveness/liveness-consts.rs
index 40d30fb9113a9..7e56bf8c2cda4 100644
--- a/tests/ui/liveness/liveness-consts.rs
+++ b/tests/ui/liveness/liveness-consts.rs
@@ -4,16 +4,18 @@
 
 pub static A: i32 = {
     let mut i = 0;
-    let mut a = 0; //~ WARN variable `a` is assigned to, but never used
+    let mut a = 0;
+    //~^ WARN variable `a` is assigned to, but never used
     while i < 10 {
         i += 1;
         a += 1;
+        //~^ WARN value assigned to `a` is never read
     }
     i
 };
 
 pub const B: u32 = {
-    let mut b = 1;
+    let mut b = 1; //~ WARN value assigned to `b` is never read
     b += 1; //~ WARN value assigned to `b` is never read
     b = 42;
     b
diff --git a/tests/ui/liveness/liveness-consts.stderr b/tests/ui/liveness/liveness-consts.stderr
index 34ce39473379e..2d2750fbaddff 100644
--- a/tests/ui/liveness/liveness-consts.stderr
+++ b/tests/ui/liveness/liveness-consts.stderr
@@ -1,5 +1,5 @@
 warning: unused variable: `e`
-  --> $DIR/liveness-consts.rs:24:13
+  --> $DIR/liveness-consts.rs:26:13
    |
 LL |         let e = 1;
    |             ^ help: if this is intentional, prefix it with an underscore: `_e`
@@ -12,53 +12,69 @@ LL | #![warn(unused)]
    = note: `#[warn(unused_variables)]` implied by `#[warn(unused)]`
 
 warning: unused variable: `s`
-  --> $DIR/liveness-consts.rs:33:24
+  --> $DIR/liveness-consts.rs:35:24
    |
 LL | pub fn f(x: [u8; { let s = 17; 100 }]) -> [u8;  { let z = 18; 100 }] {
    |                        ^ help: if this is intentional, prefix it with an underscore: `_s`
 
 warning: unused variable: `z`
-  --> $DIR/liveness-consts.rs:33:55
+  --> $DIR/liveness-consts.rs:35:55
    |
 LL | pub fn f(x: [u8; { let s = 17; 100 }]) -> [u8;  { let z = 18; 100 }] {
    |                                                       ^ help: if this is intentional, prefix it with an underscore: `_z`
 
 warning: variable `a` is assigned to, but never used
-  --> $DIR/liveness-consts.rs:7:13
+  --> $DIR/liveness-consts.rs:7:9
    |
 LL |     let mut a = 0;
-   |             ^
+   |         ^^^^^
    |
    = note: consider using `_a` instead
 
+warning: value assigned to `a` is never read
+  --> $DIR/liveness-consts.rs:11:9
+   |
+LL |         a += 1;
+   |         ^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+   = note: `#[warn(unused_assignments)]` implied by `#[warn(unused)]`
+
 warning: value assigned to `b` is never read
-  --> $DIR/liveness-consts.rs:17:5
+  --> $DIR/liveness-consts.rs:18:17
+   |
+LL |     let mut b = 1;
+   |                 ^
+   |
+   = help: maybe it is overwritten before being read?
+
+warning: value assigned to `b` is never read
+  --> $DIR/liveness-consts.rs:19:5
    |
 LL |     b += 1;
-   |     ^
+   |     ^^^^^^
    |
    = help: maybe it is overwritten before being read?
-   = note: `#[warn(unused_assignments)]` implied by `#[warn(unused)]`
 
 warning: unused variable: `z`
-  --> $DIR/liveness-consts.rs:60:13
+  --> $DIR/liveness-consts.rs:62:13
    |
 LL |         let z = 42;
    |             ^ help: if this is intentional, prefix it with an underscore: `_z`
 
 warning: value assigned to `t` is never read
-  --> $DIR/liveness-consts.rs:42:9
+  --> $DIR/liveness-consts.rs:44:9
    |
 LL |         t = t + t;
-   |         ^
+   |         ^^^^^^^^^
    |
    = help: maybe it is overwritten before being read?
 
 warning: unused variable: `w`
-  --> $DIR/liveness-consts.rs:49:13
+  --> $DIR/liveness-consts.rs:51:13
    |
 LL |         let w = 10;
    |             ^ help: if this is intentional, prefix it with an underscore: `_w`
 
-warning: 8 warnings emitted
+warning: 10 warnings emitted
 
diff --git a/tests/ui/liveness/liveness-dead.stderr b/tests/ui/liveness/liveness-dead.stderr
index de6d5bd993d62..4f7dda49cd03e 100644
--- a/tests/ui/liveness/liveness-dead.stderr
+++ b/tests/ui/liveness/liveness-dead.stderr
@@ -1,8 +1,8 @@
 error: value assigned to `x` is never read
-  --> $DIR/liveness-dead.rs:9:13
+  --> $DIR/liveness-dead.rs:9:24
    |
 LL |     let mut x: isize = 3;
-   |             ^
+   |                        ^
    |
    = help: maybe it is overwritten before being read?
 note: the lint level is defined here
@@ -15,15 +15,15 @@ error: value assigned to `x` is never read
   --> $DIR/liveness-dead.rs:17:5
    |
 LL |     x = 4;
-   |     ^
+   |     ^^^^^
    |
    = help: maybe it is overwritten before being read?
 
 error: value passed to `x` is never read
-  --> $DIR/liveness-dead.rs:20:11
+  --> $DIR/liveness-dead.rs:20:7
    |
 LL | fn f4(mut x: i32) {
-   |           ^
+   |       ^^^^^
    |
    = help: maybe it is overwritten before being read?
 
@@ -31,7 +31,7 @@ error: value assigned to `x` is never read
   --> $DIR/liveness-dead.rs:27:5
    |
 LL |     x = 4;
-   |     ^
+   |     ^^^^^
    |
    = help: maybe it is overwritten before being read?
 
diff --git a/tests/ui/liveness/liveness-unused.rs b/tests/ui/liveness/liveness-unused.rs
index 49e7044aeda1f..639d7c2776dee 100644
--- a/tests/ui/liveness/liveness-unused.rs
+++ b/tests/ui/liveness/liveness-unused.rs
@@ -39,6 +39,7 @@ fn f3b() {
     //~^ ERROR variable `z` is assigned to, but never used
     loop {
         z += 4;
+        //~^ ERROR value assigned to `z` is never read
     }
 }
 
@@ -46,6 +47,7 @@ fn f3b() {
 fn f3c() {
     let mut z = 3;
     loop { z += 4; }
+    //~^ ERROR value assigned to `z` is never read
 }
 
 #[allow(unused_variables)]
@@ -55,6 +57,16 @@ fn f3d() {
     x += 4;
 }
 
+fn f3e() {
+    let a = 13;
+    let mut z = 3;
+    //~^ ERROR variable `z` is assigned to, but never used
+    loop {
+        z += a;
+        //~^ ERROR value assigned to `z` is never read
+    }
+}
+
 fn f4() {
     match Some(3) {
       Some(i) => {
@@ -68,7 +80,15 @@ enum tri {
     a(isize), b(isize), c(isize)
 }
 
-fn f4b() -> isize {
+fn f4b() {
+    match tri::a(3) {
+      tri::a(i) | tri::b(i) | tri::c(i) => {
+          //~^ ERROR unused variable: `i`
+      }
+    }
+}
+
+fn f4c() -> isize {
     match tri::a(3) {
       tri::a(i) | tri::b(i) | tri::c(i) => {
         i
@@ -76,6 +96,13 @@ fn f4b() -> isize {
     }
 }
 
+fn f4d() {
+    match tri::a(3) {
+      tri::a(i) | tri::b(i) | tri::c(i) if i == 0 => {}
+      _ => {}
+    }
+}
+
 fn f5a() {
     for x in 1..10 { }
     //~^ ERROR unused variable: `x`
@@ -138,10 +165,92 @@ fn f7() {
     drop(a);
 }
 
+fn f8(a: u32) {
+    let _ = a;
+}
+
+fn f9() {
+    let mut a = 10;
+    //~^ ERROR variable `a` is assigned to, but never used
+    let b = 13;
+    let c = 13;
+    let d = 13;
+    let e = 13;
+    let f = 13;
+    let g = 13;
+    let h = 13;
+
+    a += b;
+    //~^ ERROR value assigned to `a` is never read
+    a -= c;
+    //~^ ERROR value assigned to `a` is never read
+    a *= d;
+    //~^ ERROR value assigned to `a` is never read
+    a /= e;
+    //~^ ERROR value assigned to `a` is never read
+    a |= f;
+    //~^ ERROR value assigned to `a` is never read
+    a &= g;
+    //~^ ERROR value assigned to `a` is never read
+    a %= h;
+    //~^ ERROR value assigned to `a` is never read
+}
+
+fn f9b() {
+    let mut a = 10;
+    let b = 13;
+    let c = 13;
+    let d = 13;
+    let e = 13;
+    let f = 13;
+    let g = 13;
+    let h = 13;
+
+    a += b;
+    a -= c;
+    a *= d;
+    a /= e;
+    a |= f;
+    a &= g;
+    a %= h;
+
+    let _ = a;
+}
+
+fn f9c() {
+    let mut a = 10.;
+    //~^ ERROR variable `a` is assigned to, but never used
+    let b = 13.;
+    let c = 13.;
+    let d = 13.;
+    let e = 13.;
+    let f = 13.;
+
+    a += b;
+    //~^ ERROR value assigned to `a` is never read
+    a -= c;
+    //~^ ERROR value assigned to `a` is never read
+    a *= d;
+    //~^ ERROR value assigned to `a` is never read
+    a /= e;
+    //~^ ERROR value assigned to `a` is never read
+    a %= f;
+    //~^ ERROR value assigned to `a` is never read
+}
+
+fn f10<T>(mut a: T, b: T) {
+    //~^ ERROR variable `a` is assigned to, but never used
+    a = b;
+    //~^ ERROR value assigned to `a` is never read
+}
+
+fn f10b<T>(mut a: Box<T>, b: Box<T>) {
+    a = b;
+}
+
 // unused params warnings are not needed for intrinsic functions without bodies
 #[rustc_intrinsic]
 unsafe fn simd_shuffle<T, I, U>(a: T, b: T, i: I) -> U;
 
-
 fn main() {
 }
diff --git a/tests/ui/liveness/liveness-unused.stderr b/tests/ui/liveness/liveness-unused.stderr
index a69fc10dff271..23a26841be2fc 100644
--- a/tests/ui/liveness/liveness-unused.stderr
+++ b/tests/ui/liveness/liveness-unused.stderr
@@ -1,5 +1,5 @@
 warning: unreachable statement
-  --> $DIR/liveness-unused.rs:93:9
+  --> $DIR/liveness-unused.rs:120:9
    |
 LL |         continue;
    |         -------- any code following this expression is unreachable
@@ -44,10 +44,10 @@ LL |     let x = 3;
    |         ^ help: if this is intentional, prefix it with an underscore: `_x`
 
 error: variable `x` is assigned to, but never used
-  --> $DIR/liveness-unused.rs:31:13
+  --> $DIR/liveness-unused.rs:31:9
    |
 LL |     let mut x = 3;
-   |             ^
+   |         ^^^^^
    |
    = note: consider using `_x` instead
 
@@ -55,7 +55,7 @@ error: value assigned to `x` is never read
   --> $DIR/liveness-unused.rs:33:5
    |
 LL |     x += 4;
-   |     ^
+   |     ^^^^^^
    |
    = help: maybe it is overwritten before being read?
 note: the lint level is defined here
@@ -65,39 +65,82 @@ LL | #![deny(unused_assignments)]
    |         ^^^^^^^^^^^^^^^^^^
 
 error: variable `z` is assigned to, but never used
-  --> $DIR/liveness-unused.rs:38:13
+  --> $DIR/liveness-unused.rs:38:9
    |
 LL |     let mut z = 3;
-   |             ^
+   |         ^^^^^
    |
    = note: consider using `_z` instead
 
+error: value assigned to `z` is never read
+  --> $DIR/liveness-unused.rs:41:9
+   |
+LL |         z += 4;
+   |         ^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+error: value assigned to `z` is never read
+  --> $DIR/liveness-unused.rs:49:12
+   |
+LL |     loop { z += 4; }
+   |            ^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+error: variable `z` is assigned to, but never used
+  --> $DIR/liveness-unused.rs:62:9
+   |
+LL |     let mut z = 3;
+   |         ^^^^^
+   |
+   = note: consider using `_z` instead
+
+error: value assigned to `z` is never read
+  --> $DIR/liveness-unused.rs:65:9
+   |
+LL |         z += a;
+   |         ^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
 error: unused variable: `i`
-  --> $DIR/liveness-unused.rs:60:12
+  --> $DIR/liveness-unused.rs:72:12
    |
 LL |       Some(i) => {
    |            ^ help: if this is intentional, prefix it with an underscore: `_i`
 
+error: unused variable: `i`
+  --> $DIR/liveness-unused.rs:85:14
+   |
+LL |       tri::a(i) | tri::b(i) | tri::c(i) => {
+   |              ^           ^           ^
+   |
+help: if this is intentional, prefix it with an underscore
+   |
+LL |       tri::a(_i) | tri::b(_i) | tri::c(_i) => {
+   |              +            +            +
+
 error: unused variable: `x`
-  --> $DIR/liveness-unused.rs:80:9
+  --> $DIR/liveness-unused.rs:107:9
    |
 LL |     for x in 1..10 { }
    |         ^ help: if this is intentional, prefix it with an underscore: `_x`
 
 error: unused variable: `x`
-  --> $DIR/liveness-unused.rs:85:10
+  --> $DIR/liveness-unused.rs:112:10
    |
 LL |     for (x, _) in [1, 2, 3].iter().enumerate() { }
    |          ^ help: if this is intentional, prefix it with an underscore: `_x`
 
 error: unused variable: `x`
-  --> $DIR/liveness-unused.rs:90:13
+  --> $DIR/liveness-unused.rs:117:13
    |
 LL |     for (_, x) in [1, 2, 3].iter().enumerate() {
    |             ^ help: if this is intentional, prefix it with an underscore: `_x`
 
 error: variable `x` is assigned to, but never used
-  --> $DIR/liveness-unused.rs:113:9
+  --> $DIR/liveness-unused.rs:140:9
    |
 LL |     let x;
    |         ^
@@ -105,12 +148,140 @@ LL |     let x;
    = note: consider using `_x` instead
 
 error: value assigned to `x` is never read
-  --> $DIR/liveness-unused.rs:117:9
+  --> $DIR/liveness-unused.rs:144:9
    |
 LL |         x = 0;
-   |         ^
+   |         ^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+error: variable `a` is assigned to, but never used
+  --> $DIR/liveness-unused.rs:173:9
+   |
+LL |     let mut a = 10;
+   |         ^^^^^
+   |
+   = note: consider using `_a` instead
+
+error: value assigned to `a` is never read
+  --> $DIR/liveness-unused.rs:183:5
+   |
+LL |     a += b;
+   |     ^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+error: value assigned to `a` is never read
+  --> $DIR/liveness-unused.rs:185:5
+   |
+LL |     a -= c;
+   |     ^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+error: value assigned to `a` is never read
+  --> $DIR/liveness-unused.rs:187:5
+   |
+LL |     a *= d;
+   |     ^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+error: value assigned to `a` is never read
+  --> $DIR/liveness-unused.rs:189:5
+   |
+LL |     a /= e;
+   |     ^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+error: value assigned to `a` is never read
+  --> $DIR/liveness-unused.rs:191:5
+   |
+LL |     a |= f;
+   |     ^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+error: value assigned to `a` is never read
+  --> $DIR/liveness-unused.rs:193:5
+   |
+LL |     a &= g;
+   |     ^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+error: value assigned to `a` is never read
+  --> $DIR/liveness-unused.rs:195:5
+   |
+LL |     a %= h;
+   |     ^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+error: variable `a` is assigned to, but never used
+  --> $DIR/liveness-unused.rs:221:9
+   |
+LL |     let mut a = 10.;
+   |         ^^^^^
+   |
+   = note: consider using `_a` instead
+
+error: value assigned to `a` is never read
+  --> $DIR/liveness-unused.rs:229:5
+   |
+LL |     a += b;
+   |     ^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+error: value assigned to `a` is never read
+  --> $DIR/liveness-unused.rs:231:5
+   |
+LL |     a -= c;
+   |     ^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+error: value assigned to `a` is never read
+  --> $DIR/liveness-unused.rs:233:5
+   |
+LL |     a *= d;
+   |     ^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+error: value assigned to `a` is never read
+  --> $DIR/liveness-unused.rs:235:5
+   |
+LL |     a /= e;
+   |     ^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+error: value assigned to `a` is never read
+  --> $DIR/liveness-unused.rs:237:5
+   |
+LL |     a %= f;
+   |     ^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+error: variable `a` is assigned to, but never used
+  --> $DIR/liveness-unused.rs:241:11
+   |
+LL | fn f10<T>(mut a: T, b: T) {
+   |           ^^^^^
+   |
+   = note: consider using `_a` instead
+
+error: value assigned to `a` is never read
+  --> $DIR/liveness-unused.rs:243:5
+   |
+LL |     a = b;
+   |     ^
    |
    = help: maybe it is overwritten before being read?
 
-error: aborting due to 13 previous errors; 1 warning emitted
+error: aborting due to 34 previous errors; 1 warning emitted
 
diff --git a/tests/ui/liveness/liveness-upvars.rs b/tests/ui/liveness/liveness-upvars.rs
index f76efba3e6b3a..be58b48a40576 100644
--- a/tests/ui/liveness/liveness-upvars.rs
+++ b/tests/ui/liveness/liveness-upvars.rs
@@ -7,8 +7,8 @@
 pub fn unintentional_copy_one() {
     let mut last = None;
     let mut f = move |s| {
-        last = Some(s); //~  WARN value assigned to `last` is never read
-                        //~| WARN unused variable: `last`
+        last = Some(s); //~  WARN value captured by `last` is never read
+                        //~| WARN value assigned to `last` is never read
     };
     f("a");
     f("b");
@@ -19,7 +19,9 @@ pub fn unintentional_copy_one() {
 pub fn unintentional_copy_two() {
     let mut sum = 0;
     (1..10).for_each(move |x| {
-        sum += x; //~ WARN unused variable: `sum`
+        sum += x;
+        //~^ WARN value captured by `sum` is never read
+        //~| WARN value assigned to `sum` is never read
     });
     dbg!(sum);
 }
@@ -39,11 +41,14 @@ pub fn f() {
 
     // Read and written to, but never actually used.
     let _ = move || {
-        c += 1; //~ WARN unused variable: `c`
+        c += 1;
+        //~^ WARN value captured by `c` is never read
+        //~|  WARN value assigned to `c` is never read
     };
     let _ = async move {
-        c += 1; //~  WARN value assigned to `c` is never read
-                //~| WARN unused variable: `c`
+        c += 1;
+        //~^ WARN value captured by `c` is never read
+        //~|  WARN value assigned to `c` is never read
     };
 
     let _ = move || {
@@ -74,8 +79,8 @@ pub fn nested() {
             d = Some("d2");
         };
         let _ = move || {
-            e = Some("e1"); //~  WARN value assigned to `e` is never read
-                            //~| WARN unused variable: `e`
+            e = Some("e1"); //~  WARN value captured by `e` is never read
+                            //~| WARN value assigned to `e` is never read
             e = Some("e2"); //~  WARN value assigned to `e` is never read
         };
     };
@@ -84,7 +89,8 @@ pub fn nested() {
 pub fn g<T: Default>(mut v: T) {
     let _ = |r| {
         if r {
-            v = T::default(); //~ WARN value assigned to `v` is never read
+            v = T::default();
+            //~^ WARN value assigned to `v` is never read
         } else {
             drop(v);
         }
@@ -96,8 +102,8 @@ pub fn h<T: Copy + Default + std::fmt::Debug>() {
     let _ = move |b| {
         loop {
             if b {
-                z = T::default(); //~  WARN value assigned to `z` is never read
-                                  //~| WARN unused variable: `z`
+                z = T::default(); //~  WARN value captured by `z` is never read
+                                  //~| WARN value assigned to `z` is never read
             } else {
                 return;
             }
@@ -123,7 +129,7 @@ pub fn async_coroutine() {
 
     let _ = async move {
         state = 4;  //~  WARN value assigned to `state` is never read
-                    //~| WARN unused variable: `state`
+                    //~| WARN value captured by `state` is never read
         yield_now().await;
         state = 5;  //~ WARN value assigned to `state` is never read
     };
@@ -141,4 +147,21 @@ pub fn coroutine() {
     };
 }
 
+pub fn panics() {
+    use std::panic::{AssertUnwindSafe, catch_unwind, resume_unwind};
+
+    let mut panic = true;
+
+    // `a` can be called again, even if it has panicked at an earlier run.
+    let mut a = || {
+        if panic {
+            panic = false;
+            resume_unwind(Box::new(()))
+        }
+    };
+
+    catch_unwind(AssertUnwindSafe(|| a())).ok();
+    a();
+}
+
 fn main() {}
diff --git a/tests/ui/liveness/liveness-upvars.stderr b/tests/ui/liveness/liveness-upvars.stderr
index 82f62371ec59d..cfed2830164ad 100644
--- a/tests/ui/liveness/liveness-upvars.stderr
+++ b/tests/ui/liveness/liveness-upvars.stderr
@@ -1,10 +1,10 @@
-warning: value assigned to `last` is never read
+warning: value captured by `last` is never read
   --> $DIR/liveness-upvars.rs:10:9
    |
 LL |         last = Some(s);
    |         ^^^^
    |
-   = help: maybe it is overwritten before being read?
+   = help: did you mean to capture by reference instead?
 note: the lint level is defined here
   --> $DIR/liveness-upvars.rs:4:9
    |
@@ -12,16 +12,15 @@ LL | #![warn(unused)]
    |         ^^^^^^
    = note: `#[warn(unused_assignments)]` implied by `#[warn(unused)]`
 
-warning: unused variable: `last`
+warning: value assigned to `last` is never read
   --> $DIR/liveness-upvars.rs:10:9
    |
 LL |         last = Some(s);
-   |         ^^^^
+   |         ^^^^^^^^^^^^^^
    |
-   = help: did you mean to capture by reference instead?
-   = note: `#[warn(unused_variables)]` implied by `#[warn(unused)]`
+   = help: maybe it is overwritten before being read?
 
-warning: unused variable: `sum`
+warning: value captured by `sum` is never read
   --> $DIR/liveness-upvars.rs:22:9
    |
 LL |         sum += x;
@@ -29,24 +28,32 @@ LL |         sum += x;
    |
    = help: did you mean to capture by reference instead?
 
-warning: value captured by `c` is never read
-  --> $DIR/liveness-upvars.rs:32:9
+warning: value assigned to `sum` is never read
+  --> $DIR/liveness-upvars.rs:22:9
    |
-LL |         c = 1;
-   |         ^
+LL |         sum += x;
+   |         ^^^^^^^^
    |
-   = help: did you mean to capture by reference instead?
+   = help: maybe it is overwritten before being read?
 
-warning: value captured by `c` is never read
-  --> $DIR/liveness-upvars.rs:36:9
+warning: value assigned to `c` is never read
+  --> $DIR/liveness-upvars.rs:69:9
    |
-LL |         c = 1;
-   |         ^
+LL |         c += 1;
+   |         ^^^^^^
    |
-   = help: did you mean to capture by reference instead?
+   = help: maybe it is overwritten before being read?
 
-warning: unused variable: `c`
-  --> $DIR/liveness-upvars.rs:42:9
+warning: value assigned to `c` is never read
+  --> $DIR/liveness-upvars.rs:63:9
+   |
+LL |         c += 1;
+   |         ^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+warning: value captured by `c` is never read
+  --> $DIR/liveness-upvars.rs:49:9
    |
 LL |         c += 1;
    |         ^
@@ -54,15 +61,15 @@ LL |         c += 1;
    = help: did you mean to capture by reference instead?
 
 warning: value assigned to `c` is never read
-  --> $DIR/liveness-upvars.rs:45:9
+  --> $DIR/liveness-upvars.rs:49:9
    |
 LL |         c += 1;
-   |         ^
+   |         ^^^^^^
    |
    = help: maybe it is overwritten before being read?
 
-warning: unused variable: `c`
-  --> $DIR/liveness-upvars.rs:45:9
+warning: value captured by `c` is never read
+  --> $DIR/liveness-upvars.rs:44:9
    |
 LL |         c += 1;
    |         ^
@@ -70,116 +77,124 @@ LL |         c += 1;
    = help: did you mean to capture by reference instead?
 
 warning: value assigned to `c` is never read
-  --> $DIR/liveness-upvars.rs:58:9
+  --> $DIR/liveness-upvars.rs:44:9
    |
 LL |         c += 1;
-   |         ^
+   |         ^^^^^^
    |
    = help: maybe it is overwritten before being read?
 
-warning: value assigned to `c` is never read
-  --> $DIR/liveness-upvars.rs:64:9
+warning: value captured by `c` is never read
+  --> $DIR/liveness-upvars.rs:38:9
    |
-LL |         c += 1;
+LL |         c = 1;
    |         ^
    |
-   = help: maybe it is overwritten before being read?
+   = help: did you mean to capture by reference instead?
 
-warning: value assigned to `d` is never read
-  --> $DIR/liveness-upvars.rs:73:13
+warning: value captured by `c` is never read
+  --> $DIR/liveness-upvars.rs:34:9
    |
-LL |             d = Some("d1");
+LL |         c = 1;
+   |         ^
+   |
+   = help: did you mean to capture by reference instead?
+
+warning: value captured by `e` is never read
+  --> $DIR/liveness-upvars.rs:82:13
+   |
+LL |             e = Some("e1");
    |             ^
    |
-   = help: maybe it is overwritten before being read?
+   = help: did you mean to capture by reference instead?
 
 warning: value assigned to `e` is never read
-  --> $DIR/liveness-upvars.rs:77:13
+  --> $DIR/liveness-upvars.rs:82:13
    |
 LL |             e = Some("e1");
-   |             ^
+   |             ^^^^^^^^^^^^^^
    |
    = help: maybe it is overwritten before being read?
 
 warning: value assigned to `e` is never read
-  --> $DIR/liveness-upvars.rs:79:13
+  --> $DIR/liveness-upvars.rs:84:13
    |
 LL |             e = Some("e2");
-   |             ^
+   |             ^^^^^^^^^^^^^^
    |
    = help: maybe it is overwritten before being read?
 
-warning: unused variable: `e`
-  --> $DIR/liveness-upvars.rs:77:13
+warning: value assigned to `d` is never read
+  --> $DIR/liveness-upvars.rs:78:13
    |
-LL |             e = Some("e1");
-   |             ^
+LL |             d = Some("d1");
+   |             ^^^^^^^^^^^^^^
    |
-   = help: did you mean to capture by reference instead?
+   = help: maybe it is overwritten before being read?
 
 warning: value assigned to `v` is never read
-  --> $DIR/liveness-upvars.rs:87:13
+  --> $DIR/liveness-upvars.rs:92:13
    |
 LL |             v = T::default();
    |             ^
    |
    = help: maybe it is overwritten before being read?
 
-warning: value assigned to `z` is never read
-  --> $DIR/liveness-upvars.rs:99:17
+warning: value captured by `z` is never read
+  --> $DIR/liveness-upvars.rs:105:17
    |
 LL |                 z = T::default();
    |                 ^
    |
-   = help: maybe it is overwritten before being read?
+   = help: did you mean to capture by reference instead?
 
-warning: unused variable: `z`
-  --> $DIR/liveness-upvars.rs:99:17
+warning: value assigned to `z` is never read
+  --> $DIR/liveness-upvars.rs:105:17
    |
 LL |                 z = T::default();
-   |                 ^
+   |                 ^^^^^^^^^^^^^^^^
    |
-   = help: did you mean to capture by reference instead?
+   = help: maybe it is overwritten before being read?
 
-warning: value assigned to `state` is never read
-  --> $DIR/liveness-upvars.rs:125:9
+warning: value captured by `state` is never read
+  --> $DIR/liveness-upvars.rs:131:9
    |
 LL |         state = 4;
    |         ^^^^^
    |
-   = help: maybe it is overwritten before being read?
+   = help: did you mean to capture by reference instead?
 
 warning: value assigned to `state` is never read
-  --> $DIR/liveness-upvars.rs:128:9
+  --> $DIR/liveness-upvars.rs:131:9
    |
-LL |         state = 5;
-   |         ^^^^^
+LL |         state = 4;
+   |         ^^^^^^^^^
    |
    = help: maybe it is overwritten before being read?
 
-warning: unused variable: `state`
-  --> $DIR/liveness-upvars.rs:125:9
+warning: value assigned to `state` is never read
+  --> $DIR/liveness-upvars.rs:134:9
    |
-LL |         state = 4;
-   |         ^^^^^
+LL |         state = 5;
+   |         ^^^^^^^^^
    |
-   = help: did you mean to capture by reference instead?
+   = help: maybe it is overwritten before being read?
 
 warning: value assigned to `s` is never read
-  --> $DIR/liveness-upvars.rs:137:9
+  --> $DIR/liveness-upvars.rs:143:9
    |
 LL |         s = 1;
-   |         ^
+   |         ^^^^^
    |
    = help: maybe it is overwritten before being read?
 
 warning: value assigned to `s` is never read
-  --> $DIR/liveness-upvars.rs:139:9
+  --> $DIR/liveness-upvars.rs:145:9
    |
 LL |         s = yield ();
-   |         ^
+   |         ^^^^^^^^^^^^
    |
    = help: maybe it is overwritten before being read?
 
-warning: 22 warnings emitted
+warning: 24 warnings emitted
 
diff --git a/tests/ui/object-lifetime/object-lifetime-default-default-to-static.rs b/tests/ui/object-lifetime/object-lifetime-default-default-to-static.rs
index 23e5852335611..ab3887f2e4108 100644
--- a/tests/ui/object-lifetime/object-lifetime-default-default-to-static.rs
+++ b/tests/ui/object-lifetime/object-lifetime-default-default-to-static.rs
@@ -3,7 +3,7 @@
 // fields and fn arguments.
 
 
-#![allow(dead_code)]
+#![allow(dead_code, unused)]
 
 trait Test {
     fn foo(&self) { }
diff --git a/tests/ui/object-lifetime/object-lifetime-default-from-ref-struct.rs b/tests/ui/object-lifetime/object-lifetime-default-from-ref-struct.rs
index 040ac1f891326..e74e67f5b6891 100644
--- a/tests/ui/object-lifetime/object-lifetime-default-from-ref-struct.rs
+++ b/tests/ui/object-lifetime/object-lifetime-default-from-ref-struct.rs
@@ -3,7 +3,7 @@
 // lifetime bound.
 
 
-#![allow(dead_code)]
+#![allow(dead_code, unused)]
 
 use std::fmt::Display;
 
diff --git a/tests/ui/object-lifetime/object-lifetime-default-from-rptr-box.rs b/tests/ui/object-lifetime/object-lifetime-default-from-rptr-box.rs
index c3f3101155cf1..2402bb24d787f 100644
--- a/tests/ui/object-lifetime/object-lifetime-default-from-rptr-box.rs
+++ b/tests/ui/object-lifetime/object-lifetime-default-from-rptr-box.rs
@@ -3,7 +3,7 @@
 // through the `Box` struct.
 
 
-#![allow(dead_code)]
+#![allow(dead_code, unused)]
 
 trait Test {
     fn foo(&self) { }
diff --git a/tests/ui/object-lifetime/object-lifetime-default-from-rptr-mut.rs b/tests/ui/object-lifetime/object-lifetime-default-from-rptr-mut.rs
index db4f9a40235d4..03a4cb9ec709e 100644
--- a/tests/ui/object-lifetime/object-lifetime-default-from-rptr-mut.rs
+++ b/tests/ui/object-lifetime/object-lifetime-default-from-rptr-mut.rs
@@ -3,7 +3,7 @@
 // lifetime bound.
 
 
-#![allow(dead_code)]
+#![allow(dead_code, unused)]
 
 trait Test {
     fn foo(&self) { }
diff --git a/tests/ui/object-lifetime/object-lifetime-default-from-rptr-struct.rs b/tests/ui/object-lifetime/object-lifetime-default-from-rptr-struct.rs
index 5163ff1c2455a..988cef49fe03e 100644
--- a/tests/ui/object-lifetime/object-lifetime-default-from-rptr-struct.rs
+++ b/tests/ui/object-lifetime/object-lifetime-default-from-rptr-struct.rs
@@ -3,7 +3,7 @@
 // through the `MyBox` struct.
 
 
-#![allow(dead_code)]
+#![allow(dead_code, unused)]
 
 trait Test {
     fn foo(&self) { }
diff --git a/tests/ui/object-lifetime/object-lifetime-default-from-rptr.rs b/tests/ui/object-lifetime/object-lifetime-default-from-rptr.rs
index 556bde784152d..d4fc295f4fc62 100644
--- a/tests/ui/object-lifetime/object-lifetime-default-from-rptr.rs
+++ b/tests/ui/object-lifetime/object-lifetime-default-from-rptr.rs
@@ -3,7 +3,7 @@
 // lifetime bound.
 
 
-#![allow(dead_code)]
+#![allow(dead_code, unused)]
 
 use std::fmt::Display;
 
diff --git a/tests/ui/object-lifetime/object-lifetime-default-inferred.rs b/tests/ui/object-lifetime/object-lifetime-default-inferred.rs
index 1ab821764de08..d3162231faf77 100644
--- a/tests/ui/object-lifetime/object-lifetime-default-inferred.rs
+++ b/tests/ui/object-lifetime/object-lifetime-default-inferred.rs
@@ -3,7 +3,7 @@
 // valid.
 
 
-#![allow(dead_code)]
+#![allow(dead_code, unused)]
 
 trait Test {
     fn foo(&self) { }
diff --git a/tests/ui/or-patterns/binding-typo-2.stderr b/tests/ui/or-patterns/binding-typo-2.stderr
index 81ea6e6b1bc08..1935d538edc66 100644
--- a/tests/ui/or-patterns/binding-typo-2.stderr
+++ b/tests/ui/or-patterns/binding-typo-2.stderr
@@ -97,157 +97,71 @@ LL -         (Foo, _) | (Ban, Foo) => {}
 LL +         (Foo, _) | (Bat, Foo) => {}
    |
 
-error: variable `Ban` is assigned to, but never used
+error: unused variable: `Ban`
   --> $DIR/binding-typo-2.rs:14:23
    |
 LL |         (Foo, Bar) | (Ban, Foo) => {}
-   |                       ^^^
+   |                       ^^^ help: if this is intentional, prefix it with an underscore: `_Ban`
    |
-   = note: consider using `_Ban` instead
 note: the lint level is defined here
   --> $DIR/binding-typo-2.rs:2:9
    |
 LL | #![deny(unused_variables)]
    |         ^^^^^^^^^^^^^^^^
-help: you might have meant to pattern match on the similarly named variant `Bar`
-   |
-LL -         (Foo, Bar) | (Ban, Foo) => {}
-LL +         (Foo, Bar) | (Lol::Bar, Foo) => {}
-   |
 
-error: variable `Ban` is assigned to, but never used
+error: unused variable: `Ban`
   --> $DIR/binding-typo-2.rs:25:21
    |
 LL |         (Foo, _) | (Ban, Foo) => {}
-   |                     ^^^
-   |
-   = note: consider using `_Ban` instead
-help: you might have meant to pattern match on the similarly named variant `Bar`
-   |
-LL -         (Foo, _) | (Ban, Foo) => {}
-LL +         (Foo, _) | (Lol::Bar, Foo) => {}
-   |
+   |                     ^^^ help: if this is intentional, prefix it with an underscore: `_Ban`
 
 error: unused variable: `Non`
   --> $DIR/binding-typo-2.rs:37:9
    |
 LL |         Non => {}
-   |         ^^^
-   |
-help: if this is intentional, prefix it with an underscore
-   |
-LL |         _Non => {}
-   |         +
-help: you might have meant to pattern match on the similarly named variant `None`
-   |
-LL -         Non => {}
-LL +         std::prelude::v1::None => {}
-   |
+   |         ^^^ help: if this is intentional, prefix it with an underscore: `_Non`
 
 error: unused variable: `Non`
   --> $DIR/binding-typo-2.rs:44:9
    |
 LL |         Non | None => {}
-   |         ^^^
-   |
-help: if this is intentional, prefix it with an underscore
-   |
-LL |         _Non | None => {}
-   |         +
-help: you might have meant to pattern match on the similarly named variant `None`
-   |
-LL -         Non | None => {}
-LL +         std::prelude::v1::None | None => {}
-   |
+   |         ^^^ help: if this is intentional, prefix it with an underscore: `_Non`
 
 error: unused variable: `Non`
   --> $DIR/binding-typo-2.rs:54:9
    |
 LL |         Non | Some(_) => {}
-   |         ^^^
-   |
-help: if this is intentional, prefix it with an underscore
-   |
-LL |         _Non | Some(_) => {}
-   |         +
-help: you might have meant to pattern match on the similarly named variant `None`
-   |
-LL -         Non | Some(_) => {}
-LL +         std::prelude::v1::None | Some(_) => {}
-   |
+   |         ^^^ help: if this is intentional, prefix it with an underscore: `_Non`
 
-error: variable `Ban` is assigned to, but never used
+error: unused variable: `Ban`
   --> $DIR/binding-typo-2.rs:69:21
    |
 LL |         (Foo, _) | (Ban, Foo) => {}
-   |                     ^^^
-   |
-   = note: consider using `_Ban` instead
-help: you might have meant to pattern match on the similarly named variant `Bar`
-   |
-LL -         (Foo, _) | (Ban, Foo) => {}
-LL +         (Foo, _) | (Lol::Bar, Foo) => {}
-   |
+   |                     ^^^ help: if this is intentional, prefix it with an underscore: `_Ban`
 
-error: variable `Ban` is assigned to, but never used
+error: unused variable: `Ban`
   --> $DIR/binding-typo-2.rs:86:21
    |
 LL |         (Foo, _) | (Ban, Foo) => {}
-   |                     ^^^
-   |
-   = note: consider using `_Ban` instead
-help: you might have meant to pattern match on the similarly named variant `Bar`
-   |
-LL -         (Foo, _) | (Ban, Foo) => {}
-LL +         (Foo, _) | (Lol::Bar, Foo) => {}
-   |
+   |                     ^^^ help: if this is intentional, prefix it with an underscore: `_Ban`
 
 error: unused variable: `Ban`
   --> $DIR/binding-typo-2.rs:98:10
    |
 LL |         (Ban, _) => {}
-   |          ^^^
-   |
-help: if this is intentional, prefix it with an underscore
-   |
-LL |         (_Ban, _) => {}
-   |          +
-help: you might have meant to pattern match on the similarly named variant `Bar`
-   |
-LL -         (Ban, _) => {}
-LL +         (Lol::Bar, _) => {}
-   |
+   |          ^^^ help: if this is intentional, prefix it with an underscore: `_Ban`
 
 error: unused variable: `Ban`
   --> $DIR/binding-typo-2.rs:104:9
    |
 LL |         Ban => {}
-   |         ^^^
-   |
-help: if this is intentional, prefix it with an underscore
-   |
-LL |         _Ban => {}
-   |         +
-help: you might have meant to pattern match on the similarly named struct `Bay`
-   |
-LL -         Ban => {}
-LL +         Bay => {}
-   |
+   |         ^^^ help: if this is intentional, prefix it with an underscore: `_Ban`
 
 error: unused variable: `Batery`
   --> $DIR/binding-typo-2.rs:110:9
    |
 LL |         Batery => {}
-   |         ^^^^^^
-   |
-help: if this is intentional, prefix it with an underscore
-   |
-LL |         _Batery => {}
-   |         +
-help: you might have meant to pattern match on the similarly named constant `Battery`
-   |
-LL |         Battery => {}
-   |            +
+   |         ^^^^^^ help: if this is intentional, prefix it with an underscore: `_Batery`
 
 error: aborting due to 16 previous errors
 
diff --git a/tests/ui/packed/packed-struct-drop-aligned.rs b/tests/ui/packed/packed-struct-drop-aligned.rs
index ba3dcb10c61e5..e8125115d45e6 100644
--- a/tests/ui/packed/packed-struct-drop-aligned.rs
+++ b/tests/ui/packed/packed-struct-drop-aligned.rs
@@ -1,6 +1,8 @@
 //@ run-pass
 #![feature(coroutines, stmt_expr_attributes)]
 #![feature(coroutine_trait)]
+#![allow(unused_assignments, unused_variables)]
+
 use std::cell::Cell;
 use std::mem;
 use std::ops::Coroutine;
diff --git a/tests/ui/parser/intersection-patterns-1.fixed b/tests/ui/parser/intersection-patterns-1.fixed
index 8ade795f7eef9..3ac9837e1a4da 100644
--- a/tests/ui/parser/intersection-patterns-1.fixed
+++ b/tests/ui/parser/intersection-patterns-1.fixed
@@ -9,6 +9,7 @@
 //@ run-rustfix
 
 #![allow(unused_variables)]
+#![allow(unused_assignments)]
 
 fn main() {
     let s: Option<u8> = None;
diff --git a/tests/ui/parser/intersection-patterns-1.rs b/tests/ui/parser/intersection-patterns-1.rs
index b5a7892fd1c5a..aab3655540505 100644
--- a/tests/ui/parser/intersection-patterns-1.rs
+++ b/tests/ui/parser/intersection-patterns-1.rs
@@ -9,6 +9,7 @@
 //@ run-rustfix
 
 #![allow(unused_variables)]
+#![allow(unused_assignments)]
 
 fn main() {
     let s: Option<u8> = None;
diff --git a/tests/ui/parser/intersection-patterns-1.stderr b/tests/ui/parser/intersection-patterns-1.stderr
index c191b46fa45db..8bcb884d8e7cb 100644
--- a/tests/ui/parser/intersection-patterns-1.stderr
+++ b/tests/ui/parser/intersection-patterns-1.stderr
@@ -1,5 +1,5 @@
 error: pattern on wrong side of `@`
-  --> $DIR/intersection-patterns-1.rs:17:9
+  --> $DIR/intersection-patterns-1.rs:18:9
    |
 LL |         Some(x) @ y => {}
    |         -------^^^-
@@ -14,7 +14,7 @@ LL +         y @ Some(x) => {}
    |
 
 error: pattern on wrong side of `@`
-  --> $DIR/intersection-patterns-1.rs:27:9
+  --> $DIR/intersection-patterns-1.rs:28:9
    |
 LL |         1 ..= 5 @ e => {}
    |         -------^^^-
diff --git a/tests/ui/pattern/bindings-after-at/bind-by-copy.rs b/tests/ui/pattern/bindings-after-at/bind-by-copy.rs
index 3d26b5e87d93f..d766411e4f980 100644
--- a/tests/ui/pattern/bindings-after-at/bind-by-copy.rs
+++ b/tests/ui/pattern/bindings-after-at/bind-by-copy.rs
@@ -1,5 +1,6 @@
 //@ run-pass
 #![allow(unused)]
+#![warn(unused_assignments)]
 
 // Test copy
 
@@ -34,10 +35,12 @@ pub fn main() {
     let mut x@B {b, ..} = B {a: 10, b: C {c: 20}};
     assert_eq!(x.a, 10);
     x.b.c = 30;
+    //~^ WARN value assigned to `x` is never read
     assert_eq!(b.c, 20);
     let mut y@D {d, ..} = D {a: 10, d: C {c: 20}};
     assert_eq!(y.a, 10);
     y.d.c = 30;
+    //~^ WARN value assigned to `y` is never read
     assert_eq!(d.c, 20);
 
     match (E::E { a: 10, e: C { c: 20 } }) {
@@ -50,7 +53,9 @@ pub fn main() {
     }
     match (E::E { a: 10, e: C { c: 20 } }) {
         mut x @ E::E{ a, e: C { mut c } } => {
+            //~^ WARN value assigned to `a` is never read
             x = E::NotE;
+            //~^ WARN value assigned to `x` is never read
             c += 30;
             assert_eq!(c, 50);
         }
diff --git a/tests/ui/pattern/bindings-after-at/bind-by-copy.stderr b/tests/ui/pattern/bindings-after-at/bind-by-copy.stderr
new file mode 100644
index 0000000000000..d775b69ef0a5e
--- /dev/null
+++ b/tests/ui/pattern/bindings-after-at/bind-by-copy.stderr
@@ -0,0 +1,39 @@
+warning: value assigned to `x` is never read
+  --> $DIR/bind-by-copy.rs:37:5
+   |
+LL |     x.b.c = 30;
+   |     ^^^^^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+note: the lint level is defined here
+  --> $DIR/bind-by-copy.rs:3:9
+   |
+LL | #![warn(unused_assignments)]
+   |         ^^^^^^^^^^^^^^^^^^
+
+warning: value assigned to `y` is never read
+  --> $DIR/bind-by-copy.rs:42:5
+   |
+LL |     y.d.c = 30;
+   |     ^^^^^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+warning: value assigned to `x` is never read
+  --> $DIR/bind-by-copy.rs:57:13
+   |
+LL |             x = E::NotE;
+   |             ^^^^^^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+warning: value assigned to `a` is never read
+  --> $DIR/bind-by-copy.rs:55:23
+   |
+LL |         mut x @ E::E{ a, e: C { mut c } } => {
+   |                       ^
+   |
+   = help: maybe it is overwritten before being read?
+
+warning: 4 warnings emitted
+
diff --git a/tests/ui/return/early-return-with-unreachable-code-24353.rs b/tests/ui/return/early-return-with-unreachable-code-24353.rs
index 13add4652d994..41d77fea49ac9 100644
--- a/tests/ui/return/early-return-with-unreachable-code-24353.rs
+++ b/tests/ui/return/early-return-with-unreachable-code-24353.rs
@@ -4,6 +4,7 @@ fn main() {
     return ();
 
     let x = ();
+    //~^ WARN unused variable: `x`
     x
 }
 
diff --git a/tests/ui/return/early-return-with-unreachable-code-24353.stderr b/tests/ui/return/early-return-with-unreachable-code-24353.stderr
new file mode 100644
index 0000000000000..92526faef33bb
--- /dev/null
+++ b/tests/ui/return/early-return-with-unreachable-code-24353.stderr
@@ -0,0 +1,10 @@
+warning: unused variable: `x`
+  --> $DIR/early-return-with-unreachable-code-24353.rs:6:9
+   |
+LL |     let x = ();
+   |         ^ help: if this is intentional, prefix it with an underscore: `_x`
+   |
+   = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default
+
+warning: 1 warning emitted
+
diff --git a/tests/ui/rfcs/rfc-2005-default-binding-mode/general.rs b/tests/ui/rfcs/rfc-2005-default-binding-mode/general.rs
index 3090f68c72b77..b3dc9e5842334 100644
--- a/tests/ui/rfcs/rfc-2005-default-binding-mode/general.rs
+++ b/tests/ui/rfcs/rfc-2005-default-binding-mode/general.rs
@@ -58,6 +58,7 @@ fn match_with_or() {
 fn nested_mixed() {
     match (&Some(5), &Some(6)) {
         (Some(a), &Some(mut b)) => {
+            //~^ WARN value assigned to `b` is never read
             // Here, the `a` will be `&i32`, because in the first half of the tuple
             // we hit a non-reference pattern and shift into `ref` mode.
             //
diff --git a/tests/ui/rfcs/rfc-2005-default-binding-mode/general.stderr b/tests/ui/rfcs/rfc-2005-default-binding-mode/general.stderr
new file mode 100644
index 0000000000000..a953e85844943
--- /dev/null
+++ b/tests/ui/rfcs/rfc-2005-default-binding-mode/general.stderr
@@ -0,0 +1,11 @@
+warning: value assigned to `b` is never read
+  --> $DIR/general.rs:60:25
+   |
+LL |         (Some(a), &Some(mut b)) => {
+   |                         ^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+   = note: `#[warn(unused_assignments)]` (part of `#[warn(unused)]`) on by default
+
+warning: 1 warning emitted
+
diff --git a/tests/ui/rfcs/rfc-2091-track-caller/std-panic-locations.default.stderr b/tests/ui/rfcs/rfc-2091-track-caller/std-panic-locations.default.stderr
new file mode 100644
index 0000000000000..259a2e2c5e73b
--- /dev/null
+++ b/tests/ui/rfcs/rfc-2091-track-caller/std-panic-locations.default.stderr
@@ -0,0 +1,11 @@
+warning: value assigned to `small` is never read
+  --> $DIR/std-panic-locations.rs:47:31
+   |
+LL |     assert_panicked(move || { small[1] += 1; });
+   |                               ^^^^^^^^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+   = note: `#[warn(unused_assignments)]` (part of `#[warn(unused)]`) on by default
+
+warning: 1 warning emitted
+
diff --git a/tests/ui/rfcs/rfc-2091-track-caller/std-panic-locations.mir-opt.stderr b/tests/ui/rfcs/rfc-2091-track-caller/std-panic-locations.mir-opt.stderr
new file mode 100644
index 0000000000000..259a2e2c5e73b
--- /dev/null
+++ b/tests/ui/rfcs/rfc-2091-track-caller/std-panic-locations.mir-opt.stderr
@@ -0,0 +1,11 @@
+warning: value assigned to `small` is never read
+  --> $DIR/std-panic-locations.rs:47:31
+   |
+LL |     assert_panicked(move || { small[1] += 1; });
+   |                               ^^^^^^^^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+   = note: `#[warn(unused_assignments)]` (part of `#[warn(unused)]`) on by default
+
+warning: 1 warning emitted
+
diff --git a/tests/ui/rfcs/rfc-2091-track-caller/std-panic-locations.rs b/tests/ui/rfcs/rfc-2091-track-caller/std-panic-locations.rs
index b1df1b191bcf1..b365e786fd050 100644
--- a/tests/ui/rfcs/rfc-2091-track-caller/std-panic-locations.rs
+++ b/tests/ui/rfcs/rfc-2091-track-caller/std-panic-locations.rs
@@ -45,6 +45,7 @@ fn main() {
     assert_panicked(move || { small[1]; });
     assert_panicked(move || { small.index_mut(1); });
     assert_panicked(move || { small[1] += 1; });
+    //~^ WARN value assigned to `small` is never read
 
     let sorted: BTreeMap<bool, bool> = Default::default();
     assert_panicked(|| { sorted.index(&false); });
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 ba92bc4a71d85..90282793fa284 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
@@ -10,18 +10,6 @@ note: the lint level is defined here
 LL | #![deny(unused_variables)]
    |         ^^^^^^^^^^^^^^^^
 
-error: unused variable: `a`
-  --> $DIR/param-attrs-cfg.rs:40:27
-   |
-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:106: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:29:23
    |
@@ -34,6 +22,12 @@ 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:40: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:47:27
    |
@@ -118,5 +112,11 @@ 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:106:27
+   |
+LL |         #[cfg(something)] a: i32,
+   |                           ^ help: if this is intentional, prefix it with an underscore: `_a`
+
 error: aborting due to 19 previous errors
 
diff --git a/tests/ui/suggestions/try-removing-the-field.rs b/tests/ui/suggestions/try-removing-the-field.rs
index dc1bde082c4f1..29da1964354ec 100644
--- a/tests/ui/suggestions/try-removing-the-field.rs
+++ b/tests/ui/suggestions/try-removing-the-field.rs
@@ -10,7 +10,7 @@ struct Foo {
 
 fn use_foo(x: Foo) -> i32 {
     let Foo { foo, bar, .. } = x; //~ WARNING unused variable: `bar`
-                                  //~| help: try removing the field
+                                  //~| help: try ignoring the field
     return foo;
 }
 
@@ -24,7 +24,7 @@ fn use_match(x: Foo) {
 
     match x {
         Foo { foo, .. } => { //~ WARNING unused variable
-                             //~| help: try removing the field
+                             //~| help: try ignoring the field
         }
     }
 }
diff --git a/tests/ui/suggestions/try-removing-the-field.stderr b/tests/ui/suggestions/try-removing-the-field.stderr
index aaf260bb86ede..f83f63642f617 100644
--- a/tests/ui/suggestions/try-removing-the-field.stderr
+++ b/tests/ui/suggestions/try-removing-the-field.stderr
@@ -2,9 +2,7 @@ warning: unused variable: `bar`
   --> $DIR/try-removing-the-field.rs:12:20
    |
 LL |     let Foo { foo, bar, .. } = x;
-   |                    ^^^-
-   |                    |
-   |                    help: try removing the field
+   |                    ^^^ help: try ignoring the field: `bar: _`
    |
    = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default
 
@@ -18,9 +16,7 @@ warning: unused variable: `foo`
   --> $DIR/try-removing-the-field.rs:26:15
    |
 LL |         Foo { foo, .. } => {
-   |               ^^^-
-   |               |
-   |               help: try removing the field
+   |               ^^^ help: try ignoring the field: `foo: _`
 
 warning: 3 warnings emitted
 
diff --git a/tests/ui/suggestions/unused-closure-argument.stderr b/tests/ui/suggestions/unused-closure-argument.stderr
index 55195ce50a13e..9f70501389c43 100644
--- a/tests/ui/suggestions/unused-closure-argument.stderr
+++ b/tests/ui/suggestions/unused-closure-argument.stderr
@@ -1,8 +1,8 @@
 error: unused variable: `x`
-  --> $DIR/unused-closure-argument.rs:12:23
+  --> $DIR/unused-closure-argument.rs:17:15
    |
-LL |         .map(|Point { x, y }| y)
-   |                       ^ help: try ignoring the field: `x: _`
+LL |         .map(|x| 4)
+   |               ^ help: if this is intentional, prefix it with an underscore: `_x`
    |
 note: the lint level is defined here
   --> $DIR/unused-closure-argument.rs:1:9
@@ -11,10 +11,10 @@ LL | #![deny(unused_variables)]
    |         ^^^^^^^^^^^^^^^^
 
 error: unused variable: `x`
-  --> $DIR/unused-closure-argument.rs:17:15
+  --> $DIR/unused-closure-argument.rs:12:23
    |
-LL |         .map(|x| 4)
-   |               ^ help: if this is intentional, prefix it with an underscore: `_x`
+LL |         .map(|Point { x, y }| y)
+   |                       ^ help: try ignoring the field: `x: _`
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/type/issue-100584.stderr b/tests/ui/type/issue-100584.stderr
index 1523bdda7614b..29b567eb74405 100644
--- a/tests/ui/type/issue-100584.stderr
+++ b/tests/ui/type/issue-100584.stderr
@@ -2,7 +2,7 @@ error: unused variable: `xyza`
   --> $DIR/issue-100584.rs:2:8
    |
 LL | fn foo(xyza: &str) {
-   |        ^^^^ unused variable
+   |        ^^^^
 LL |
 LL |     let _ = "{xyza}";
    |             -------- you might have meant to use string interpolation in this string literal
@@ -26,7 +26,7 @@ error: unused variable: `xyza`
   --> $DIR/issue-100584.rs:7:9
    |
 LL | fn foo3(xyza: &str) {
-   |         ^^^^ unused variable
+   |         ^^^^
 LL |
 LL |     let _ = "aaa{xyza}bbb";
    |             -------------- you might have meant to use string interpolation in this string literal
diff --git a/tests/ui/type/type-ascription.rs b/tests/ui/type/type-ascription.rs
index 76d6d923affc2..3649c707f3046 100644
--- a/tests/ui/type/type-ascription.rs
+++ b/tests/ui/type/type-ascription.rs
@@ -1,9 +1,8 @@
 //@ run-pass
 
-#![allow(dead_code)]
-#![allow(unused_variables)]
-// Type ascription doesn't lead to unsoundness
+#![allow(dead_code, unused_variables, unused_assignments)]
 
+// Type ascription doesn't lead to unsoundness
 #![feature(type_ascription)]
 
 use std::mem;
diff --git a/tests/ui/unboxed-closures/unboxed-closures-counter-not-moved.rs b/tests/ui/unboxed-closures/unboxed-closures-counter-not-moved.rs
index 42287ac50701b..ee425abfd1e27 100644
--- a/tests/ui/unboxed-closures/unboxed-closures-counter-not-moved.rs
+++ b/tests/ui/unboxed-closures/unboxed-closures-counter-not-moved.rs
@@ -21,8 +21,9 @@ fn main() {
 
     call(move || {
         // this mutates a moved copy, and hence doesn't affect original
-        counter += 1; //~  WARN value assigned to `counter` is never read
-                      //~| WARN unused variable: `counter`
+        counter += 1;
+        //~^ WARN value captured by `counter` is never read
+        //~| WARN value assigned to `counter` is never read
     });
     assert_eq!(counter, 88);
 }
diff --git a/tests/ui/unboxed-closures/unboxed-closures-counter-not-moved.stderr b/tests/ui/unboxed-closures/unboxed-closures-counter-not-moved.stderr
index 190ef0f472463..3afb032747734 100644
--- a/tests/ui/unboxed-closures/unboxed-closures-counter-not-moved.stderr
+++ b/tests/ui/unboxed-closures/unboxed-closures-counter-not-moved.stderr
@@ -1,27 +1,27 @@
-warning: unused variable: `item`
-  --> $DIR/unboxed-closures-counter-not-moved.rs:15:13
+warning: value captured by `counter` is never read
+  --> $DIR/unboxed-closures-counter-not-moved.rs:24:9
    |
-LL |         for item in y {
-   |             ^^^^ help: if this is intentional, prefix it with an underscore: `_item`
+LL |         counter += 1;
+   |         ^^^^^^^
    |
-   = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default
+   = help: did you mean to capture by reference instead?
+   = note: `#[warn(unused_assignments)]` (part of `#[warn(unused)]`) on by default
 
 warning: value assigned to `counter` is never read
   --> $DIR/unboxed-closures-counter-not-moved.rs:24:9
    |
 LL |         counter += 1;
-   |         ^^^^^^^
+   |         ^^^^^^^^^^^^
    |
    = help: maybe it is overwritten before being read?
-   = note: `#[warn(unused_assignments)]` (part of `#[warn(unused)]`) on by default
 
-warning: unused variable: `counter`
-  --> $DIR/unboxed-closures-counter-not-moved.rs:24:9
+warning: unused variable: `item`
+  --> $DIR/unboxed-closures-counter-not-moved.rs:15:13
    |
-LL |         counter += 1;
-   |         ^^^^^^^
+LL |         for item in y {
+   |             ^^^^ help: if this is intentional, prefix it with an underscore: `_item`
    |
-   = help: did you mean to capture by reference instead?
+   = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default
 
 warning: 3 warnings emitted
 
diff --git a/tests/ui/unboxed-closures/unboxed-closures-move-mutable.rs b/tests/ui/unboxed-closures/unboxed-closures-move-mutable.rs
index f27461808c390..5710998cda799 100644
--- a/tests/ui/unboxed-closures/unboxed-closures-move-mutable.rs
+++ b/tests/ui/unboxed-closures/unboxed-closures-move-mutable.rs
@@ -13,11 +13,17 @@ fn set(x: &mut usize) { *x = 42; }
 fn main() {
     {
         let mut x = 0_usize;
-        move || x += 1; //~ WARN unused variable: `x`
+        //~^ WARN unused variable: `x`
+        move || x += 1;
+        //~^ WARN value captured by `x` is never read
+        //~| WARN value assigned to `x` is never read
     }
     {
         let mut x = 0_usize;
-        move || x += 1; //~ WARN unused variable: `x`
+        //~^ WARN unused variable: `x`
+        move || x += 1;
+        //~^ WARN value captured by `x` is never read
+        //~| WARN value assigned to `x` is never read
     }
     {
         let mut x = 0_usize;
diff --git a/tests/ui/unboxed-closures/unboxed-closures-move-mutable.stderr b/tests/ui/unboxed-closures/unboxed-closures-move-mutable.stderr
index 24590128107b3..70c48b596c0ec 100644
--- a/tests/ui/unboxed-closures/unboxed-closures-move-mutable.stderr
+++ b/tests/ui/unboxed-closures/unboxed-closures-move-mutable.stderr
@@ -1,19 +1,49 @@
-warning: unused variable: `x`
-  --> $DIR/unboxed-closures-move-mutable.rs:16:17
+warning: value captured by `x` is never read
+  --> $DIR/unboxed-closures-move-mutable.rs:24:17
    |
 LL |         move || x += 1;
    |                 ^
    |
    = help: did you mean to capture by reference instead?
-   = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default
+   = note: `#[warn(unused_assignments)]` (part of `#[warn(unused)]`) on by default
 
-warning: unused variable: `x`
-  --> $DIR/unboxed-closures-move-mutable.rs:20:17
+warning: value assigned to `x` is never read
+  --> $DIR/unboxed-closures-move-mutable.rs:24:17
+   |
+LL |         move || x += 1;
+   |                 ^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+warning: value captured by `x` is never read
+  --> $DIR/unboxed-closures-move-mutable.rs:17:17
    |
 LL |         move || x += 1;
    |                 ^
    |
    = help: did you mean to capture by reference instead?
 
-warning: 2 warnings emitted
+warning: value assigned to `x` is never read
+  --> $DIR/unboxed-closures-move-mutable.rs:17:17
+   |
+LL |         move || x += 1;
+   |                 ^^^^^^
+   |
+   = help: maybe it is overwritten before being read?
+
+warning: unused variable: `x`
+  --> $DIR/unboxed-closures-move-mutable.rs:15:13
+   |
+LL |         let mut x = 0_usize;
+   |             ^^^^^ help: if this is intentional, prefix it with an underscore: `_x`
+   |
+   = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default
+
+warning: unused variable: `x`
+  --> $DIR/unboxed-closures-move-mutable.rs:22:13
+   |
+LL |         let mut x = 0_usize;
+   |             ^^^^^ help: if this is intentional, prefix it with an underscore: `_x`
+
+warning: 6 warnings emitted
 

From c653430714e28dea3b39118fd9f05ab8d2bc33ab Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Sun, 7 Sep 2025 02:17:13 +0000
Subject: [PATCH 1877/1889] Suggest unit struct and constants.

---
 compiler/rustc_mir_transform/messages.ftl     |   2 +
 compiler/rustc_mir_transform/src/errors.rs    |  18 +++
 compiler/rustc_mir_transform/src/liveness.rs  |  88 ++++++++++++-
 .../lint-uppercase-variables.stderr           |  21 +++-
 tests/ui/or-patterns/binding-typo-2.rs        |  16 +--
 tests/ui/or-patterns/binding-typo-2.stderr    | 118 ++++++++++++++++--
 6 files changed, 237 insertions(+), 26 deletions(-)

diff --git a/compiler/rustc_mir_transform/messages.ftl b/compiler/rustc_mir_transform/messages.ftl
index e8d29c414edca..71ec2db1ef00c 100644
--- a/compiler/rustc_mir_transform/messages.ftl
+++ b/compiler/rustc_mir_transform/messages.ftl
@@ -104,3 +104,5 @@ mir_transform_unused_variable = unused variable: `{$name}`
 mir_transform_unused_variable_args_in_macro = `{$name}` is captured in macro and introduced a unused variable
 
 mir_transform_unused_variable_try_ignore = try ignoring the field
+
+mir_transform_unused_variable_typo = you might have meant to pattern match on the similarly named {$kind} `{$item_name}`
diff --git a/compiler/rustc_mir_transform/src/errors.rs b/compiler/rustc_mir_transform/src/errors.rs
index 87430b8225b61..a039851681a67 100644
--- a/compiler/rustc_mir_transform/src/errors.rs
+++ b/compiler/rustc_mir_transform/src/errors.rs
@@ -170,6 +170,8 @@ pub(crate) struct UnusedCaptureMaybeCaptureRef {
 #[note]
 pub(crate) struct UnusedVarAssignedOnly {
     pub name: Symbol,
+    #[subdiagnostic]
+    pub typo: Option<PatternTypo>,
 }
 
 #[derive(LintDiagnostic)]
@@ -235,6 +237,8 @@ pub(crate) enum UnusedVariableSugg {
         #[suggestion_part(code = "_{name}")]
         spans: Vec<Span>,
         name: Symbol,
+        #[subdiagnostic]
+        typo: Option<PatternTypo>,
     },
 
     #[help(mir_transform_unused_variable_args_in_macro)]
@@ -266,6 +270,20 @@ impl Subdiagnostic for UnusedVariableStringInterp {
     }
 }
 
+#[derive(Subdiagnostic)]
+#[multipart_suggestion(
+    mir_transform_unused_variable_typo,
+    style = "verbose",
+    applicability = "maybe-incorrect"
+)]
+pub(crate) struct PatternTypo {
+    #[suggestion_part(code = "{code}")]
+    pub span: Span,
+    pub code: String,
+    pub item_name: Symbol,
+    pub kind: &'static str,
+}
+
 pub(crate) struct MustNotSupend<'a, 'tcx> {
     pub tcx: TyCtxt<'tcx>,
     pub yield_sp: Span,
diff --git a/compiler/rustc_mir_transform/src/liveness.rs b/compiler/rustc_mir_transform/src/liveness.rs
index 83b50e7be61b1..573c794f2838d 100644
--- a/compiler/rustc_mir_transform/src/liveness.rs
+++ b/compiler/rustc_mir_transform/src/liveness.rs
@@ -1,8 +1,8 @@
 use rustc_abi::FieldIdx;
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap, IndexEntry};
 use rustc_hir::attrs::AttributeKind;
-use rustc_hir::def::DefKind;
-use rustc_hir::def_id::LocalDefId;
+use rustc_hir::def::{CtorKind, DefKind};
+use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::find_attr;
 use rustc_index::IndexVec;
 use rustc_index::bit_set::DenseBitSet;
@@ -11,11 +11,13 @@ use rustc_middle::mir::visit::{
     MutatingUseContext, NonMutatingUseContext, NonUseContext, PlaceContext, Visitor,
 };
 use rustc_middle::mir::*;
+use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_mir_dataflow::fmt::DebugWithContext;
 use rustc_mir_dataflow::{Analysis, Backward, ResultsCursor};
 use rustc_session::lint;
 use rustc_span::Span;
+use rustc_span::edit_distance::find_best_match_for_name;
 use rustc_span::symbol::{Symbol, kw, sym};
 
 use crate::errors;
@@ -201,6 +203,62 @@ fn maybe_suggest_literal_matching_name(
     finder.found
 }
 
+/// Give a diagnostic when an unused variable may be a typo of a unit variant or a struct.
+fn maybe_suggest_unit_pattern_typo<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    body_def_id: DefId,
+    name: Symbol,
+    span: Span,
+    ty: Ty<'tcx>,
+) -> Option<errors::PatternTypo> {
+    if let ty::Adt(adt_def, _) = ty.peel_refs().kind() {
+        let variant_names: Vec<_> = adt_def
+            .variants()
+            .iter()
+            .filter(|v| matches!(v.ctor, Some((CtorKind::Const, _))))
+            .map(|v| v.name)
+            .collect();
+        if let Some(name) = find_best_match_for_name(&variant_names, name, None)
+            && let Some(variant) = adt_def
+                .variants()
+                .iter()
+                .find(|v| v.name == name && matches!(v.ctor, Some((CtorKind::Const, _))))
+        {
+            return Some(errors::PatternTypo {
+                span,
+                code: with_no_trimmed_paths!(tcx.def_path_str(variant.def_id)),
+                kind: tcx.def_descr(variant.def_id),
+                item_name: variant.name,
+            });
+        }
+    }
+
+    // Look for consts of the same type with similar names as well,
+    // not just unit structs and variants.
+    let constants = tcx
+        .hir_body_owners()
+        .filter(|&def_id| {
+            matches!(tcx.def_kind(def_id), DefKind::Const)
+                && tcx.type_of(def_id).instantiate_identity() == ty
+                && tcx.visibility(def_id).is_accessible_from(body_def_id, tcx)
+        })
+        .collect::<Vec<_>>();
+    let names = constants.iter().map(|&def_id| tcx.item_name(def_id)).collect::<Vec<_>>();
+    if let Some(item_name) = find_best_match_for_name(&names, name, None)
+        && let Some(position) = names.iter().position(|&n| n == item_name)
+        && let Some(&def_id) = constants.get(position)
+    {
+        return Some(errors::PatternTypo {
+            span,
+            code: with_no_trimmed_paths!(tcx.def_path_str(def_id)),
+            kind: "constant",
+            item_name,
+        });
+    }
+
+    None
+}
+
 /// Return whether we should consider the current place as a drop guard and skip reporting.
 fn maybe_drop_guard<'tcx>(
     tcx: TyCtxt<'tcx>,
@@ -855,12 +913,27 @@ impl<'a, 'tcx> AssignmentResult<'a, 'tcx> {
             let from_macro = def_span.from_expansion()
                 && introductions.iter().any(|intro| intro.span.eq_ctxt(def_span));
 
+            let maybe_suggest_typo = || {
+                if let LocalKind::Arg = self.body.local_kind(local) {
+                    None
+                } else {
+                    maybe_suggest_unit_pattern_typo(
+                        tcx,
+                        self.body.source.def_id(),
+                        name,
+                        def_span,
+                        decl.ty,
+                    )
+                }
+            };
+
             let statements = &mut self.assignments[index];
             if statements.is_empty() {
                 let sugg = if from_macro {
                     errors::UnusedVariableSugg::NoSugg { span: def_span, name }
                 } else {
-                    errors::UnusedVariableSugg::TryPrefix { spans: vec![def_span], name }
+                    let typo = maybe_suggest_typo();
+                    errors::UnusedVariableSugg::TryPrefix { spans: vec![def_span], name, typo }
                 };
                 tcx.emit_node_span_lint(
                     lint::builtin::UNUSED_VARIABLES,
@@ -909,11 +982,12 @@ impl<'a, 'tcx> AssignmentResult<'a, 'tcx> {
                     continue;
                 }
 
+                let typo = maybe_suggest_typo();
                 tcx.emit_node_span_lint(
                     lint::builtin::UNUSED_VARIABLES,
                     hir_id,
                     def_span,
-                    errors::UnusedVarAssignedOnly { name },
+                    errors::UnusedVarAssignedOnly { name, typo },
                 );
                 continue;
             }
@@ -944,9 +1018,11 @@ impl<'a, 'tcx> AssignmentResult<'a, 'tcx> {
             } else if from_macro {
                 errors::UnusedVariableSugg::NoSugg { span: def_span, name }
             } else if !introductions.is_empty() {
-                errors::UnusedVariableSugg::TryPrefix { name, spans: spans.clone() }
+                let typo = maybe_suggest_typo();
+                errors::UnusedVariableSugg::TryPrefix { name, typo, spans: spans.clone() }
             } else {
-                errors::UnusedVariableSugg::TryPrefix { name, spans: vec![def_span] }
+                let typo = maybe_suggest_typo();
+                errors::UnusedVariableSugg::TryPrefix { name, typo, spans: vec![def_span] }
             };
 
             tcx.emit_node_span_lint(
diff --git a/tests/ui/lint/non-snake-case/lint-uppercase-variables.stderr b/tests/ui/lint/non-snake-case/lint-uppercase-variables.stderr
index b0c56003957c9..09f76f86a4b14 100644
--- a/tests/ui/lint/non-snake-case/lint-uppercase-variables.stderr
+++ b/tests/ui/lint/non-snake-case/lint-uppercase-variables.stderr
@@ -16,7 +16,7 @@ warning: unused variable: `Foo`
   --> $DIR/lint-uppercase-variables.rs:22:9
    |
 LL |         Foo => {}
-   |         ^^^ help: if this is intentional, prefix it with an underscore: `_Foo`
+   |         ^^^
    |
 note: the lint level is defined here
   --> $DIR/lint-uppercase-variables.rs:1:9
@@ -24,12 +24,29 @@ note: the lint level is defined here
 LL | #![warn(unused)]
    |         ^^^^^^
    = note: `#[warn(unused_variables)]` implied by `#[warn(unused)]`
+help: you might have meant to pattern match on the similarly named variant `Foo`
+   |
+LL |         foo::Foo::Foo => {}
+   |         ++++++++++
+help: if this is intentional, prefix it with an underscore
+   |
+LL |         _Foo => {}
+   |         +
 
 warning: unused variable: `Foo`
   --> $DIR/lint-uppercase-variables.rs:28:9
    |
 LL |     let Foo = foo::Foo::Foo;
-   |         ^^^ help: if this is intentional, prefix it with an underscore: `_Foo`
+   |         ^^^
+   |
+help: you might have meant to pattern match on the similarly named variant `Foo`
+   |
+LL |     let foo::Foo::Foo = foo::Foo::Foo;
+   |         ++++++++++
+help: if this is intentional, prefix it with an underscore
+   |
+LL |     let _Foo = foo::Foo::Foo;
+   |         +
 
 error[E0170]: pattern binding `Foo` is named the same as one of the variants of the type `foo::Foo`
   --> $DIR/lint-uppercase-variables.rs:33:17
diff --git a/tests/ui/or-patterns/binding-typo-2.rs b/tests/ui/or-patterns/binding-typo-2.rs
index 275b68a22e22f..59df4459b88ef 100644
--- a/tests/ui/or-patterns/binding-typo-2.rs
+++ b/tests/ui/or-patterns/binding-typo-2.rs
@@ -16,8 +16,8 @@ fn foo(x: (Lol, Lol)) {
         //~| HELP: you might have meant to use the similarly named previously used binding `Bar`
         //~| NOTE: pattern doesn't bind `Ban`
         //~| NOTE: variable not in all patterns
-        //~| ERROR: variable `Ban` is assigned to, but never used
-        //~| NOTE: consider using `_Ban` instead
+        //~| ERROR: unused variable: `Ban`
+        //~| HELP: if this is intentional, prefix it with an underscore
         //~| HELP: you might have meant to pattern match on the similarly named
         _ => {}
     }
@@ -27,8 +27,8 @@ fn foo(x: (Lol, Lol)) {
         //~| HELP: you might have meant to use the similarly named unit variant `Bar`
         //~| NOTE: pattern doesn't bind `Ban`
         //~| NOTE: variable not in all patterns
-        //~| ERROR: variable `Ban` is assigned to, but never used
-        //~| NOTE: consider using `_Ban` instead
+        //~| ERROR: unused variable: `Ban`
+        //~| HELP: if this is intentional, prefix it with an underscore
         //~| HELP: you might have meant to pattern match on the similarly named
         _ => {}
     }
@@ -73,8 +73,8 @@ fn bar(x: (Lol, Lol)) {
         //~| HELP: you might have meant to use the similarly named constant `Bat`
         //~| NOTE: pattern doesn't bind `Ban`
         //~| NOTE: variable not in all patterns
-        //~| ERROR: variable `Ban` is assigned to, but never used
-        //~| NOTE: consider using `_Ban` instead
+        //~| ERROR: unused variable: `Ban`
+        //~| HELP: if this is intentional, prefix it with an underscore
         //~| HELP: you might have meant to pattern match on the similarly named
         _ => {}
     }
@@ -89,8 +89,8 @@ fn baz(x: (Lol, Lol)) {
         //~| HELP: you might have meant to use the similarly named constant `Bat`
         //~| NOTE: pattern doesn't bind `Ban`
         //~| NOTE: variable not in all patterns
-        //~| ERROR: variable `Ban` is assigned to, but never used
-        //~| NOTE: consider using `_Ban` instead
+        //~| ERROR: unused variable: `Ban`
+        //~| HELP: if this is intentional, prefix it with an underscore
         //~| HELP: you might have meant to pattern match on the similarly named
         _ => {}
     }
diff --git a/tests/ui/or-patterns/binding-typo-2.stderr b/tests/ui/or-patterns/binding-typo-2.stderr
index 1935d538edc66..23b570b3c23cf 100644
--- a/tests/ui/or-patterns/binding-typo-2.stderr
+++ b/tests/ui/or-patterns/binding-typo-2.stderr
@@ -101,67 +101,165 @@ error: unused variable: `Ban`
   --> $DIR/binding-typo-2.rs:14:23
    |
 LL |         (Foo, Bar) | (Ban, Foo) => {}
-   |                       ^^^ help: if this is intentional, prefix it with an underscore: `_Ban`
+   |                       ^^^
    |
 note: the lint level is defined here
   --> $DIR/binding-typo-2.rs:2:9
    |
 LL | #![deny(unused_variables)]
    |         ^^^^^^^^^^^^^^^^
+help: you might have meant to pattern match on the similarly named variant `Bar`
+   |
+LL -         (Foo, Bar) | (Ban, Foo) => {}
+LL +         (Foo, Bar) | (Lol::Bar, Foo) => {}
+   |
+help: if this is intentional, prefix it with an underscore
+   |
+LL |         (Foo, Bar) | (_Ban, Foo) => {}
+   |                       +
 
 error: unused variable: `Ban`
   --> $DIR/binding-typo-2.rs:25:21
    |
 LL |         (Foo, _) | (Ban, Foo) => {}
-   |                     ^^^ help: if this is intentional, prefix it with an underscore: `_Ban`
+   |                     ^^^
+   |
+help: you might have meant to pattern match on the similarly named variant `Bar`
+   |
+LL -         (Foo, _) | (Ban, Foo) => {}
+LL +         (Foo, _) | (Lol::Bar, Foo) => {}
+   |
+help: if this is intentional, prefix it with an underscore
+   |
+LL |         (Foo, _) | (_Ban, Foo) => {}
+   |                     +
 
 error: unused variable: `Non`
   --> $DIR/binding-typo-2.rs:37:9
    |
 LL |         Non => {}
-   |         ^^^ help: if this is intentional, prefix it with an underscore: `_Non`
+   |         ^^^
+   |
+help: you might have meant to pattern match on the similarly named variant `None`
+   |
+LL -         Non => {}
+LL +         std::prelude::v1::None => {}
+   |
+help: if this is intentional, prefix it with an underscore
+   |
+LL |         _Non => {}
+   |         +
 
 error: unused variable: `Non`
   --> $DIR/binding-typo-2.rs:44:9
    |
 LL |         Non | None => {}
-   |         ^^^ help: if this is intentional, prefix it with an underscore: `_Non`
+   |         ^^^
+   |
+help: you might have meant to pattern match on the similarly named variant `None`
+   |
+LL -         Non | None => {}
+LL +         std::prelude::v1::None | None => {}
+   |
+help: if this is intentional, prefix it with an underscore
+   |
+LL |         _Non | None => {}
+   |         +
 
 error: unused variable: `Non`
   --> $DIR/binding-typo-2.rs:54:9
    |
 LL |         Non | Some(_) => {}
-   |         ^^^ help: if this is intentional, prefix it with an underscore: `_Non`
+   |         ^^^
+   |
+help: you might have meant to pattern match on the similarly named variant `None`
+   |
+LL -         Non | Some(_) => {}
+LL +         std::prelude::v1::None | Some(_) => {}
+   |
+help: if this is intentional, prefix it with an underscore
+   |
+LL |         _Non | Some(_) => {}
+   |         +
 
 error: unused variable: `Ban`
   --> $DIR/binding-typo-2.rs:69:21
    |
 LL |         (Foo, _) | (Ban, Foo) => {}
-   |                     ^^^ help: if this is intentional, prefix it with an underscore: `_Ban`
+   |                     ^^^
+   |
+help: you might have meant to pattern match on the similarly named variant `Bar`
+   |
+LL -         (Foo, _) | (Ban, Foo) => {}
+LL +         (Foo, _) | (Lol::Bar, Foo) => {}
+   |
+help: if this is intentional, prefix it with an underscore
+   |
+LL |         (Foo, _) | (_Ban, Foo) => {}
+   |                     +
 
 error: unused variable: `Ban`
   --> $DIR/binding-typo-2.rs:86:21
    |
 LL |         (Foo, _) | (Ban, Foo) => {}
-   |                     ^^^ help: if this is intentional, prefix it with an underscore: `_Ban`
+   |                     ^^^
+   |
+help: you might have meant to pattern match on the similarly named variant `Bar`
+   |
+LL -         (Foo, _) | (Ban, Foo) => {}
+LL +         (Foo, _) | (Lol::Bar, Foo) => {}
+   |
+help: if this is intentional, prefix it with an underscore
+   |
+LL |         (Foo, _) | (_Ban, Foo) => {}
+   |                     +
 
 error: unused variable: `Ban`
   --> $DIR/binding-typo-2.rs:98:10
    |
 LL |         (Ban, _) => {}
-   |          ^^^ help: if this is intentional, prefix it with an underscore: `_Ban`
+   |          ^^^
+   |
+help: you might have meant to pattern match on the similarly named variant `Bar`
+   |
+LL -         (Ban, _) => {}
+LL +         (Lol::Bar, _) => {}
+   |
+help: if this is intentional, prefix it with an underscore
+   |
+LL |         (_Ban, _) => {}
+   |          +
 
 error: unused variable: `Ban`
   --> $DIR/binding-typo-2.rs:104:9
    |
 LL |         Ban => {}
-   |         ^^^ help: if this is intentional, prefix it with an underscore: `_Ban`
+   |         ^^^
+   |
+help: you might have meant to pattern match on the similarly named struct `Bay`
+   |
+LL -         Ban => {}
+LL +         Bay => {}
+   |
+help: if this is intentional, prefix it with an underscore
+   |
+LL |         _Ban => {}
+   |         +
 
 error: unused variable: `Batery`
   --> $DIR/binding-typo-2.rs:110:9
    |
 LL |         Batery => {}
-   |         ^^^^^^ help: if this is intentional, prefix it with an underscore: `_Batery`
+   |         ^^^^^^
+   |
+help: you might have meant to pattern match on the similarly named constant `Battery`
+   |
+LL |         Battery => {}
+   |            +
+help: if this is intentional, prefix it with an underscore
+   |
+LL |         _Batery => {}
+   |         +
 
 error: aborting due to 16 previous errors
 

From 72a04a7e0a871280cbeea1d19f2c32724092e88e Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Thu, 3 Jul 2025 13:02:28 +0000
Subject: [PATCH 1878/1889] Silence warning in r-a.

---
 .../rust-analyzer/crates/ide-db/src/imports/merge_imports.rs    | 2 ++
 src/tools/rust-analyzer/crates/test-fixture/src/lib.rs          | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/ide-db/src/imports/merge_imports.rs b/src/tools/rust-analyzer/crates/ide-db/src/imports/merge_imports.rs
index 4e779a7d858e5..635ed7368c4c0 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/imports/merge_imports.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/imports/merge_imports.rs
@@ -405,6 +405,8 @@ fn recursive_normalize(use_tree: &ast::UseTree, style: NormalizationStyle) -> Op
                 } else {
                     ted::replace_with_many(subtree.syntax(), elements);
                 }
+                // Silence unused assignment warning on `modified`.
+                let _ = modified;
                 modified = true;
             } else {
                 modified |= recursive_normalize(&subtree, NormalizationStyle::Default).is_some();
diff --git a/src/tools/rust-analyzer/crates/test-fixture/src/lib.rs b/src/tools/rust-analyzer/crates/test-fixture/src/lib.rs
index 7574d12c0cfd0..a4549794db336 100644
--- a/src/tools/rust-analyzer/crates/test-fixture/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/test-fixture/src/lib.rs
@@ -383,6 +383,8 @@ impl ChangeFixture {
             }
         }
 
+        let _ = file_id;
+
         let root = match current_source_root_kind {
             SourceRootKind::Local => SourceRoot::new_local(mem::take(&mut file_set)),
             SourceRootKind::Library => SourceRoot::new_library(mem::take(&mut file_set)),

From f216ec23ba658d3515a9dd43953998ecdbefa0d1 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Thu, 3 Jul 2025 14:17:20 +0000
Subject: [PATCH 1879/1889] Silence warning in miri tests.

---
 .../miri/tests/fail/function_calls/arg_inplace_locals_alias.rs | 3 +++
 .../tests/fail/function_calls/arg_inplace_observe_after.rs     | 1 +
 .../tests/fail/function_calls/arg_inplace_observe_during.rs    | 1 +
 .../miri/tests/pass/align_repeat_into_well_aligned_array.rs    | 1 +
 4 files changed, 6 insertions(+)

diff --git a/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias.rs b/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias.rs
index 744d64b9b1e88..03cca04702fee 100644
--- a/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias.rs
+++ b/src/tools/miri/tests/fail/function_calls/arg_inplace_locals_alias.rs
@@ -4,7 +4,10 @@
 //@[tree]compile-flags: -Zmiri-tree-borrows
 // Validation forces more things into memory, which we can't have here.
 //@compile-flags: -Zmiri-disable-validation
+
 #![feature(custom_mir, core_intrinsics)]
+#![allow(unused)]
+
 use std::intrinsics::mir::*;
 
 pub struct S(i32);
diff --git a/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_after.rs b/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_after.rs
index 18daf9497a15b..cea6c141c4de9 100644
--- a/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_after.rs
+++ b/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_after.rs
@@ -22,6 +22,7 @@ fn main() {
     }
 }
 
+#[expect(unused_variables, unused_assignments)]
 pub fn change_arg(mut x: S) {
     x.0 = 0;
 }
diff --git a/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.rs b/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.rs
index 2201bf17bfc78..581b71499575c 100644
--- a/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.rs
+++ b/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.rs
@@ -23,6 +23,7 @@ fn main() {
     }
 }
 
+#[expect(unused_variables, unused_assignments)]
 pub fn change_arg(mut x: S, ptr: *mut S) {
     x.0 = 0;
     // If `x` got passed in-place, we'd see the write through `ptr`!
diff --git a/src/tools/miri/tests/pass/align_repeat_into_well_aligned_array.rs b/src/tools/miri/tests/pass/align_repeat_into_well_aligned_array.rs
index 735251039f772..82a74e392b9cc 100644
--- a/src/tools/miri/tests/pass/align_repeat_into_well_aligned_array.rs
+++ b/src/tools/miri/tests/pass/align_repeat_into_well_aligned_array.rs
@@ -2,6 +2,7 @@
 
 use std::mem::size_of;
 
+#[expect(unused_variables, unused_assignments)]
 fn main() {
     let mut a = Params::new();
     // The array itself here happens to be quite well-aligned, but not all its elements have that

From 4419d890c6d1169601f10dc62ef8d985f636b499 Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Sat, 30 Aug 2025 13:10:06 +0000
Subject: [PATCH 1880/1889] Bless ui asm.

---
 tests/ui/asm/x86_64/goto.stderr | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/ui/asm/x86_64/goto.stderr b/tests/ui/asm/x86_64/goto.stderr
index 230faf8001136..5342e43c58a1c 100644
--- a/tests/ui/asm/x86_64/goto.stderr
+++ b/tests/ui/asm/x86_64/goto.stderr
@@ -25,7 +25,7 @@ LL |         let mut value = false;
    |                         ^^^^^
    |
    = help: maybe it is overwritten before being read?
-   = note: `#[warn(unused_assignments)]` on by default
+   = note: `#[warn(unused_assignments)]` (part of `#[warn(unused)]`) on by default
 
 warning: 2 warnings emitted
 

From 49922d5b96594a005467fbea2d8e438c90e3699d Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Sat, 30 Aug 2025 18:23:34 +0000
Subject: [PATCH 1881/1889] Remove unreachable expression warning from std.

---
 library/std/src/sync/poison.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/library/std/src/sync/poison.rs b/library/std/src/sync/poison.rs
index 17abdb9819bf9..5517082033380 100644
--- a/library/std/src/sync/poison.rs
+++ b/library/std/src/sync/poison.rs
@@ -60,6 +60,9 @@
 //!   while it is locked exclusively (write mode). If a panic occurs in any reader,
 //!   then the lock will not be poisoned.
 
+// If we are not unwinding, `PoisonError` is uninhabited.
+#![cfg_attr(not(panic = "unwind"), expect(unreachable_code))]
+
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use self::condvar::Condvar;
 #[unstable(feature = "mapped_lock_guards", issue = "117108")]

From b198bf80602db74c2517c06aad19e200999024cb Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Sat, 11 Oct 2025 20:56:10 +0000
Subject: [PATCH 1882/1889] Rebase fallout.

---
 compiler/rustc_mir_transform/src/liveness.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/liveness.rs b/compiler/rustc_mir_transform/src/liveness.rs
index 573c794f2838d..82f9dfe4745d2 100644
--- a/compiler/rustc_mir_transform/src/liveness.rs
+++ b/compiler/rustc_mir_transform/src/liveness.rs
@@ -741,7 +741,6 @@ impl<'a, 'tcx> AssignmentResult<'a, 'tcx> {
                 ever_live.union(live);
                 match &statement.kind {
                     StatementKind::Assign(box (place, _))
-                    | StatementKind::Deinit(box place)
                     | StatementKind::SetDiscriminant { box place, .. } => {
                         check_place(*place, AccessKind::Assign, statement.source_info, live);
                     }
@@ -1345,9 +1344,7 @@ impl DefUse {
         let is_indirect = is_indirect(projection);
         match context {
             PlaceContext::MutatingUse(
-                MutatingUseContext::Store
-                | MutatingUseContext::Deinit
-                | MutatingUseContext::SetDiscriminant,
+                MutatingUseContext::Store | MutatingUseContext::SetDiscriminant,
             ) => {
                 if is_indirect {
                     // Treat derefs as a use of the base local. `*p = 4` is not a def of `p` but a

From 340702c0c2524e57e1a4950c22c3bd1b01e4a586 Mon Sep 17 00:00:00 2001
From: Shunpoco <tkngsnsk313320@gmail.com>
Date: Wed, 17 Sep 2025 22:56:47 +0100
Subject: [PATCH 1883/1889] write x.py's help for saving output time

Currently x.py help (or x.py --help) builds bootstrap binary everytime, but it delays printing help.
This change saves the current top level help text into a file. x.py help prints the file and doesn't touch bootstrap binary.
x.py test bootstrap checks if the file is up to date.
Note that subcommand level helps (e.g., x.py check --help) aren't saved.
---
 src/bootstrap/bootstrap.py                 | 24 +++++-
 src/bootstrap/src/core/build_steps/run.rs  | 29 ++++++-
 src/bootstrap/src/core/build_steps/test.rs | 21 ++++-
 src/bootstrap/src/core/builder/mod.rs      |  1 +
 src/bootstrap/src/core/config/flags.rs     |  6 ++
 src/etc/xhelp                              | 96 ++++++++++++++++++++++
 6 files changed, 170 insertions(+), 7 deletions(-)
 create mode 100644 src/etc/xhelp

diff --git a/src/bootstrap/bootstrap.py b/src/bootstrap/bootstrap.py
index 8b1775178c915..4dd465edb0df9 100644
--- a/src/bootstrap/bootstrap.py
+++ b/src/bootstrap/bootstrap.py
@@ -1379,11 +1379,26 @@ def main():
         sys.argv[1] = "-h"
 
     args = parse_args(sys.argv)
-    help_triggered = args.help or len(sys.argv) == 1
 
-    # If the user is asking for help, let them know that the whole download-and-build
+    # Root help (e.g., x.py --help) prints help from the saved file to save the time
+    if len(sys.argv) == 1 or sys.argv[1] in ["-h", "--help"]:
+        try:
+            with open(
+                os.path.join(os.path.dirname(__file__), "../etc/xhelp"), "r"
+            ) as f:
+                # The file from bootstrap func already has newline.
+                print(f.read(), end="")
+                sys.exit(0)
+        except Exception as error:
+            eprint(
+                f"ERROR: unable to run help: {error}\n",
+                "x.py run generate-help may solve the problem.",
+            )
+            sys.exit(1)
+
+    # If the user is asking for other helps, let them know that the whole download-and-build
     # process has to happen before anything is printed out.
-    if help_triggered:
+    if args.help:
         eprint(
             "INFO: Downloading and building bootstrap before processing --help command.\n"
             "      See src/bootstrap/README.md for help with common commands."
@@ -1401,13 +1416,14 @@ def main():
             eprint(error)
         success_word = "unsuccessfully"
 
-    if not help_triggered:
+    if not args.help:
         eprint(
             "Build completed",
             success_word,
             "in",
             format_build_time(time() - start_time),
         )
+
     sys.exit(exit_code)
 
 
diff --git a/src/bootstrap/src/core/build_steps/run.rs b/src/bootstrap/src/core/build_steps/run.rs
index b9a4c1bf9b44b..bd5ba89229117 100644
--- a/src/bootstrap/src/core/build_steps/run.rs
+++ b/src/bootstrap/src/core/build_steps/run.rs
@@ -15,7 +15,7 @@ use crate::core::build_steps::tool::{self, RustcPrivateCompilers, SourceType, To
 use crate::core::build_steps::vendor::{Vendor, default_paths_to_vendor};
 use crate::core::builder::{Builder, Kind, RunConfig, ShouldRun, Step, StepMetadata};
 use crate::core::config::TargetSelection;
-use crate::core::config::flags::get_completion;
+use crate::core::config::flags::{get_completion, top_level_help};
 use crate::utils::exec::command;
 use crate::{Mode, t};
 
@@ -512,3 +512,30 @@ impl Step for Rustfmt {
         rustfmt.into_cmd().run(builder);
     }
 }
+
+/// Return the path of x.py's help.
+pub fn get_help_path(builder: &Builder<'_>) -> PathBuf {
+    builder.src.join("src/etc/xhelp")
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct GenerateHelp;
+
+impl Step for GenerateHelp {
+    type Output = ();
+
+    fn run(self, builder: &Builder<'_>) {
+        let help = top_level_help();
+        let path = get_help_path(builder);
+        std::fs::write(&path, help)
+            .unwrap_or_else(|e| panic!("writing help into {} failed: {e:?}", path.display()));
+    }
+
+    fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
+        run.alias("generate-help")
+    }
+
+    fn make_run(run: RunConfig<'_>) {
+        run.builder.ensure(GenerateHelp)
+    }
+}
diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index 154b209b20252..4babd32d5d4c4 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -15,7 +15,7 @@ use crate::core::build_steps::compile::{Std, run_cargo};
 use crate::core::build_steps::doc::{DocumentationFormat, prepare_doc_compiler};
 use crate::core::build_steps::gcc::{Gcc, add_cg_gcc_cargo_flags};
 use crate::core::build_steps::llvm::get_llvm_version;
-use crate::core::build_steps::run::get_completion_paths;
+use crate::core::build_steps::run::{get_completion_paths, get_help_path};
 use crate::core::build_steps::synthetic_targets::MirOptPanicAbortSyntheticTarget;
 use crate::core::build_steps::tool::{
     self, RustcPrivateCompilers, SourceType, TEST_FLOAT_PARSE_ALLOW_FEATURES, Tool,
@@ -28,7 +28,7 @@ use crate::core::builder::{
     crate_description,
 };
 use crate::core::config::TargetSelection;
-use crate::core::config::flags::{Subcommand, get_completion};
+use crate::core::config::flags::{Subcommand, get_completion, top_level_help};
 use crate::utils::build_stamp::{self, BuildStamp};
 use crate::utils::exec::{BootstrapCommand, command};
 use crate::utils::helpers::{
@@ -1292,6 +1292,23 @@ HELP: to skip test's attempt to check tidiness, pass `--skip src/tools/tidy` to
             );
             crate::exit!(1);
         }
+
+        builder.info("x.py help check");
+        if builder.config.cmd.bless() {
+            builder.ensure(crate::core::build_steps::run::GenerateHelp);
+        } else {
+            let help_path = get_help_path(builder);
+            let cur_help = std::fs::read_to_string(&help_path).unwrap_or_else(|err| {
+                eprintln!("couldn't read {}: {}", help_path.display(), err);
+                crate::exit!(1);
+            });
+            let new_help = top_level_help();
+
+            if new_help != cur_help {
+                eprintln!("x.py help was changed; run `x.py run generate-help` to update it");
+                crate::exit!(1);
+            }
+        }
     }
 
     fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
diff --git a/src/bootstrap/src/core/builder/mod.rs b/src/bootstrap/src/core/builder/mod.rs
index 99fb62ea31c9d..d660680942751 100644
--- a/src/bootstrap/src/core/builder/mod.rs
+++ b/src/bootstrap/src/core/builder/mod.rs
@@ -1239,6 +1239,7 @@ impl<'a> Builder<'a> {
                 run::CyclicStep,
                 run::CoverageDump,
                 run::Rustfmt,
+                run::GenerateHelp,
             ),
             Kind::Setup => {
                 describe!(setup::Profile, setup::Hook, setup::Link, setup::Editor)
diff --git a/src/bootstrap/src/core/config/flags.rs b/src/bootstrap/src/core/config/flags.rs
index c01b71b926068..9e408505933d3 100644
--- a/src/bootstrap/src/core/config/flags.rs
+++ b/src/bootstrap/src/core/config/flags.rs
@@ -701,3 +701,9 @@ pub fn get_completion(shell: &dyn Generator, path: &Path) -> Option<String> {
     }
     Some(String::from_utf8(buf).expect("completion script should be UTF-8"))
 }
+
+/// Return the top level help of the bootstrap.
+pub fn top_level_help() -> String {
+    let mut cmd = Flags::command();
+    cmd.render_help().to_string()
+}
diff --git a/src/etc/xhelp b/src/etc/xhelp
new file mode 100644
index 0000000000000..5880d070d3d66
--- /dev/null
+++ b/src/etc/xhelp
@@ -0,0 +1,96 @@
+
+Usage: x.py <subcommand> [options] [<paths>...]
+
+Commands:
+  build    Compile either the compiler or libraries
+  check    Compile either the compiler or libraries, using cargo check
+  clippy   Run Clippy (uses rustup/cargo-installed clippy binary)
+  fix      Run cargo fix
+  fmt      Run rustfmt
+  doc      Build documentation
+  test     Build and run some test suites
+  miri     Build and run some test suites *in Miri*
+  bench    Build and run some benchmarks
+  clean    Clean out build directories
+  dist     Build distribution artifacts
+  install  Install distribution artifacts
+  run      Run tools contained in this repository
+  setup    Set up the environment for development
+  vendor   Vendor dependencies
+  perf     Perform profiling and benchmarking of the compiler using `rustc-perf`
+
+Arguments:
+  [PATHS]...  paths for the subcommand
+  [ARGS]...   arguments passed to subcommands
+
+Options:
+  -v, --verbose...
+          use verbose output (-vv for very verbose)
+  -i, --incremental
+          use incremental compilation
+      --config <FILE>
+          TOML configuration file for build
+      --build-dir <DIR>
+          Build directory, overrides `build.build-dir` in `bootstrap.toml`
+      --build <BUILD>
+          host target of the stage0 compiler
+      --host <HOST>
+          host targets to build
+      --target <TARGET>
+          target targets to build
+      --exclude <PATH>
+          build paths to exclude
+      --skip <PATH>
+          build paths to skip
+      --include-default-paths
+          include default paths in addition to the provided ones
+      --rustc-error-format <RUSTC_ERROR_FORMAT>
+          rustc error format
+      --on-fail <CMD>
+          command to run on failure
+      --dry-run
+          dry run; don't build anything
+      --dump-bootstrap-shims
+          Indicates whether to dump the work done from bootstrap shims
+      --stage <N>
+          stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)
+      --keep-stage <N>
+          stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)
+      --keep-stage-std <N>
+          stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)
+      --src <DIR>
+          path to the root of the rust checkout
+  -j, --jobs <JOBS>
+          number of jobs to run in parallel
+      --warnings <deny|warn>
+          if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour [default: default] [possible values: deny, warn, default]
+      --json-output
+          use message-format=json
+      --compile-time-deps
+          only build proc-macros and build scripts (for rust-analyzer)
+      --color <STYLE>
+          whether to use color in cargo and rustc output [default: auto] [possible values: always, never, auto]
+      --bypass-bootstrap-lock
+          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)
+      --rust-profile-generate <PROFILE>
+          generate PGO profile with rustc build
+      --rust-profile-use <PROFILE>
+          use PGO profile for rustc build
+      --llvm-profile-use <PROFILE>
+          use PGO profile for LLVM build
+      --llvm-profile-generate
+          generate PGO profile with llvm built for rustc
+      --enable-bolt-settings
+          Enable BOLT link flags
+      --skip-stage0-validation
+          Skip stage0 compiler validation
+      --reproducible-artifact <REPRODUCIBLE_ARTIFACT>
+          Additional reproducible artifacts that should be added to the reproducible artifacts archive
+      --set <section.option=value>
+          override options in bootstrap.toml
+      --ci <bool>
+          Make bootstrap to behave as it's running on the CI environment or not [possible values: true, false]
+      --skip-std-check-if-no-download-rustc
+          Skip checking the standard library if `rust.download-rustc` isn't available. This is mostly for RA as building the stage1 compiler to check the library tree on each code change might be too much for some computers
+  -h, --help
+          Print help (see more with '--help')

From 08f16a9c46cd33b21435cbf1da2abb8b001c7c4f Mon Sep 17 00:00:00 2001
From: Adwin White <adwinw01@gmail.com>
Date: Fri, 29 Aug 2025 10:53:45 +0800
Subject: [PATCH 1884/1889] check normalization overflow in monomorphization

---
 compiler/rustc_middle/src/mir/mono.rs         |  3 +
 compiler/rustc_middle/src/query/erase.rs      | 13 ++++
 compiler/rustc_middle/src/query/mod.rs        |  6 +-
 compiler/rustc_monomorphize/src/collector.rs  | 74 ++++++++++++++++---
 .../src/normalize_erasing_regions.rs          | 13 +++-
 .../recursion-issue-105275.rs}                |  3 +-
 .../recursion-issue-105275.stderr             | 14 ++++
 .../recursion-issue-105937.rs}                |  3 +-
 .../recursion-issue-105937.stderr             | 14 ++++
 .../recursion-issue-117696-1.rs}              |  3 +-
 .../recursion-issue-117696-1.stderr           | 11 +++
 .../recursion-issue-117696-2.rs}              |  3 +-
 .../recursion-issue-117696-2.stderr           | 14 ++++
 .../recursion-issue-118590.rs}                |  3 +-
 .../recursion-issue-118590.stderr             | 11 +++
 .../recursion-issue-122823.rs}                |  3 +-
 .../recursion-issue-122823.stderr             | 11 +++
 .../recursion-issue-131342.rs}                |  3 +-
 .../recursion-issue-131342.stderr             | 11 +++
 .../recursion-issue-139659.rs}                |  3 +-
 .../recursion-issue-139659.stderr             | 10 +++
 .../recursion-issue-92004.rs}                 |  3 +-
 .../recursion-issue-92004.stderr              | 11 +++
 .../recursion-issue-92470.rs}                 |  4 +-
 .../recursion-issue-92470.stderr              | 26 +++++++
 .../recursion-issue-95134.rs}                 |  3 +-
 .../recursion-issue-95134.stderr              | 14 ++++
 27 files changed, 266 insertions(+), 24 deletions(-)
 rename tests/{crashes/105275.rs => ui/codegen/normalization-overflow/recursion-issue-105275.rs} (84%)
 create mode 100644 tests/ui/codegen/normalization-overflow/recursion-issue-105275.stderr
 rename tests/{crashes/105937.rs => ui/codegen/normalization-overflow/recursion-issue-105937.rs} (84%)
 create mode 100644 tests/ui/codegen/normalization-overflow/recursion-issue-105937.stderr
 rename tests/{crashes/117696-1.rs => ui/codegen/normalization-overflow/recursion-issue-117696-1.rs} (81%)
 create mode 100644 tests/ui/codegen/normalization-overflow/recursion-issue-117696-1.stderr
 rename tests/{crashes/117696-2.rs => ui/codegen/normalization-overflow/recursion-issue-117696-2.rs} (70%)
 create mode 100644 tests/ui/codegen/normalization-overflow/recursion-issue-117696-2.stderr
 rename tests/{crashes/118590.rs => ui/codegen/normalization-overflow/recursion-issue-118590.rs} (65%)
 create mode 100644 tests/ui/codegen/normalization-overflow/recursion-issue-118590.stderr
 rename tests/{crashes/122823.rs => ui/codegen/normalization-overflow/recursion-issue-122823.rs} (95%)
 create mode 100644 tests/ui/codegen/normalization-overflow/recursion-issue-122823.stderr
 rename tests/{crashes/131342.rs => ui/codegen/normalization-overflow/recursion-issue-131342.rs} (79%)
 create mode 100644 tests/ui/codegen/normalization-overflow/recursion-issue-131342.stderr
 rename tests/{crashes/139659.rs => ui/codegen/normalization-overflow/recursion-issue-139659.rs} (86%)
 create mode 100644 tests/ui/codegen/normalization-overflow/recursion-issue-139659.stderr
 rename tests/{crashes/92004.rs => ui/codegen/normalization-overflow/recursion-issue-92004.rs} (95%)
 create mode 100644 tests/ui/codegen/normalization-overflow/recursion-issue-92004.stderr
 rename tests/{crashes/92470.rs => ui/codegen/normalization-overflow/recursion-issue-92470.rs} (76%)
 create mode 100644 tests/ui/codegen/normalization-overflow/recursion-issue-92470.stderr
 rename tests/{crashes/95134.rs => ui/codegen/normalization-overflow/recursion-issue-95134.rs} (85%)
 create mode 100644 tests/ui/codegen/normalization-overflow/recursion-issue-95134.stderr

diff --git a/compiler/rustc_middle/src/mir/mono.rs b/compiler/rustc_middle/src/mir/mono.rs
index 6b45b2dc3ff50..a499f149a42b6 100644
--- a/compiler/rustc_middle/src/mir/mono.rs
+++ b/compiler/rustc_middle/src/mir/mono.rs
@@ -47,6 +47,9 @@ pub enum InstantiationMode {
     LocalCopy,
 }
 
+#[derive(PartialEq, Eq, Clone, Copy, Debug, Hash, HashStable, TyEncodable, TyDecodable)]
+pub struct NormalizationErrorInMono;
+
 #[derive(PartialEq, Eq, Clone, Copy, Debug, Hash, HashStable, TyEncodable, TyDecodable)]
 pub enum MonoItem<'tcx> {
     Fn(Instance<'tcx>),
diff --git a/compiler/rustc_middle/src/query/erase.rs b/compiler/rustc_middle/src/query/erase.rs
index 4c00b769237f3..cad10fcfb0101 100644
--- a/compiler/rustc_middle/src/query/erase.rs
+++ b/compiler/rustc_middle/src/query/erase.rs
@@ -3,8 +3,10 @@ use std::intrinsics::transmute_unchecked;
 use std::mem::MaybeUninit;
 
 use rustc_span::ErrorGuaranteed;
+use rustc_span::source_map::Spanned;
 
 use crate::mir::interpret::EvalToValTreeResult;
+use crate::mir::mono::{MonoItem, NormalizationErrorInMono};
 use crate::query::CyclePlaceholder;
 use crate::traits::solve;
 use crate::ty::adjustment::CoerceUnsizedInfo;
@@ -171,6 +173,17 @@ impl EraseType for Result<ty::EarlyBinder<'_, Ty<'_>>, CyclePlaceholder> {
     type Result = [u8; size_of::<Result<ty::EarlyBinder<'static, Ty<'_>>, CyclePlaceholder>>()];
 }
 
+impl EraseType
+    for Result<(&'_ [Spanned<MonoItem<'_>>], &'_ [Spanned<MonoItem<'_>>]), NormalizationErrorInMono>
+{
+    type Result = [u8; size_of::<
+        Result<
+            (&'static [Spanned<MonoItem<'static>>], &'static [Spanned<MonoItem<'static>>]),
+            NormalizationErrorInMono,
+        >,
+    >()];
+}
+
 impl<T> EraseType for Option<&'_ T> {
     type Result = [u8; size_of::<Option<&'static ()>>()];
 }
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 0e645a3aae45b..9ed7ebea3a40e 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -117,7 +117,9 @@ use crate::mir::interpret::{
     EvalStaticInitializerRawResult, EvalToAllocationRawResult, EvalToConstValueResult,
     EvalToValTreeResult, GlobalId, LitToConstInput,
 };
-use crate::mir::mono::{CodegenUnit, CollectionMode, MonoItem, MonoItemPartitions};
+use crate::mir::mono::{
+    CodegenUnit, CollectionMode, MonoItem, MonoItemPartitions, NormalizationErrorInMono,
+};
 use crate::query::erase::{Erase, erase, restore};
 use crate::query::plumbing::{
     CyclePlaceholder, DynamicQuery, query_ensure, query_ensure_error_guaranteed, query_get_at,
@@ -2704,7 +2706,7 @@ rustc_queries! {
         desc { "functions to skip for move-size check" }
     }
 
-    query items_of_instance(key: (ty::Instance<'tcx>, CollectionMode)) -> (&'tcx [Spanned<MonoItem<'tcx>>], &'tcx [Spanned<MonoItem<'tcx>>]) {
+    query items_of_instance(key: (ty::Instance<'tcx>, CollectionMode)) -> Result<(&'tcx [Spanned<MonoItem<'tcx>>], &'tcx [Spanned<MonoItem<'tcx>>]), NormalizationErrorInMono> {
         desc { "collecting items used by `{}`", key.0 }
         cache_on_disk_if { true }
     }
diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs
index 378d71cb1fcd3..2169ed3c254b8 100644
--- a/compiler/rustc_monomorphize/src/collector.rs
+++ b/compiler/rustc_monomorphize/src/collector.rs
@@ -208,6 +208,7 @@
 mod autodiff;
 
 use std::cell::OnceCell;
+use std::ops::ControlFlow;
 
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::sync::{MTLock, par_for_each_in};
@@ -220,15 +221,17 @@ use rustc_hir::lang_items::LangItem;
 use rustc_hir::limit::Limit;
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use rustc_middle::mir::interpret::{AllocId, ErrorHandled, GlobalAlloc, Scalar};
-use rustc_middle::mir::mono::{CollectionMode, InstantiationMode, MonoItem};
+use rustc_middle::mir::mono::{
+    CollectionMode, InstantiationMode, MonoItem, NormalizationErrorInMono,
+};
 use rustc_middle::mir::visit::Visitor as MirVisitor;
-use rustc_middle::mir::{self, Location, MentionedItem, traversal};
+use rustc_middle::mir::{self, Body, Location, MentionedItem, traversal};
 use rustc_middle::query::TyCtxtAt;
 use rustc_middle::ty::adjustment::{CustomCoerceUnsized, PointerCoercion};
 use rustc_middle::ty::layout::ValidityRequirement;
 use rustc_middle::ty::{
     self, GenericArgs, GenericParamDefKind, Instance, InstanceKind, Ty, TyCtxt, TypeFoldable,
-    TypeVisitableExt, VtblEntry,
+    TypeVisitable, TypeVisitableExt, TypeVisitor, VtblEntry,
 };
 use rustc_middle::util::Providers;
 use rustc_middle::{bug, span_bug};
@@ -474,7 +477,22 @@ fn collect_items_rec<'tcx>(
             ));
 
             rustc_data_structures::stack::ensure_sufficient_stack(|| {
-                let (used, mentioned) = tcx.items_of_instance((instance, mode));
+                let Ok((used, mentioned)) = tcx.items_of_instance((instance, mode)) else {
+                    // Normalization errors here are usually due to trait solving overflow.
+                    // FIXME: I assume that there are few type errors at post-analysis stage, but not
+                    // entirely sure.
+                    // We have to emit the error outside of `items_of_instance` to access the
+                    // span of the `starting_item`.
+                    let def_id = instance.def_id();
+                    let def_span = tcx.def_span(def_id);
+                    let def_path_str = tcx.def_path_str(def_id);
+                    tcx.dcx().emit_fatal(RecursionLimit {
+                        span: starting_item.span,
+                        instance,
+                        def_span,
+                        def_path_str,
+                    });
+                };
                 used_items.extend(used.into_iter().copied());
                 mentioned_items.extend(mentioned.into_iter().copied());
             });
@@ -603,6 +621,35 @@ fn collect_items_rec<'tcx>(
     }
 }
 
+// Check whether we can normalize every type in the instantiated MIR body.
+fn check_normalization_error<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    instance: Instance<'tcx>,
+    body: &Body<'tcx>,
+) -> Result<(), NormalizationErrorInMono> {
+    struct NormalizationChecker<'tcx> {
+        tcx: TyCtxt<'tcx>,
+        instance: Instance<'tcx>,
+    }
+    impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for NormalizationChecker<'tcx> {
+        type Result = ControlFlow<()>;
+
+        fn visit_ty(&mut self, t: Ty<'tcx>) -> Self::Result {
+            match self.instance.try_instantiate_mir_and_normalize_erasing_regions(
+                self.tcx,
+                ty::TypingEnv::fully_monomorphized(),
+                ty::EarlyBinder::bind(t),
+            ) {
+                Ok(_) => ControlFlow::Continue(()),
+                Err(_) => ControlFlow::Break(()),
+            }
+        }
+    }
+
+    let mut checker = NormalizationChecker { tcx, instance };
+    if body.visit_with(&mut checker).is_break() { Err(NormalizationErrorInMono) } else { Ok(()) }
+}
+
 fn check_recursion_limit<'tcx>(
     tcx: TyCtxt<'tcx>,
     instance: Instance<'tcx>,
@@ -1259,11 +1306,15 @@ fn collect_items_of_instance<'tcx>(
     tcx: TyCtxt<'tcx>,
     instance: Instance<'tcx>,
     mode: CollectionMode,
-) -> (MonoItems<'tcx>, MonoItems<'tcx>) {
+) -> Result<(MonoItems<'tcx>, MonoItems<'tcx>), NormalizationErrorInMono> {
     // This item is getting monomorphized, do mono-time checks.
+    let body = tcx.instance_mir(instance.def);
+    // Plenty of code paths later assume that everything can be normalized. So we have to check
+    // normalization first.
+    // We choose to emit the error outside to provide helpful diagnostics.
+    check_normalization_error(tcx, instance, body)?;
     tcx.ensure_ok().check_mono_item(instance);
 
-    let body = tcx.instance_mir(instance.def);
     // Naively, in "used" collection mode, all functions get added to *both* `used_items` and
     // `mentioned_items`. Mentioned items processing will then notice that they have already been
     // visited, but at that point each mentioned item has been monomorphized, added to the
@@ -1313,19 +1364,22 @@ fn collect_items_of_instance<'tcx>(
         }
     }
 
-    (used_items, mentioned_items)
+    Ok((used_items, mentioned_items))
 }
 
 fn items_of_instance<'tcx>(
     tcx: TyCtxt<'tcx>,
     (instance, mode): (Instance<'tcx>, CollectionMode),
-) -> (&'tcx [Spanned<MonoItem<'tcx>>], &'tcx [Spanned<MonoItem<'tcx>>]) {
-    let (used_items, mentioned_items) = collect_items_of_instance(tcx, instance, mode);
+) -> Result<
+    (&'tcx [Spanned<MonoItem<'tcx>>], &'tcx [Spanned<MonoItem<'tcx>>]),
+    NormalizationErrorInMono,
+> {
+    let (used_items, mentioned_items) = collect_items_of_instance(tcx, instance, mode)?;
 
     let used_items = tcx.arena.alloc_from_iter(used_items);
     let mentioned_items = tcx.arena.alloc_from_iter(mentioned_items);
 
-    (used_items, mentioned_items)
+    Ok((used_items, mentioned_items))
 }
 
 /// `item` must be already monomorphized.
diff --git a/compiler/rustc_traits/src/normalize_erasing_regions.rs b/compiler/rustc_traits/src/normalize_erasing_regions.rs
index c98b56abe9c1d..d3a2c4d20f95d 100644
--- a/compiler/rustc_traits/src/normalize_erasing_regions.rs
+++ b/compiler/rustc_traits/src/normalize_erasing_regions.rs
@@ -42,7 +42,18 @@ fn try_normalize_after_erasing_regions<'tcx, T: TypeFoldable<TyCtxt<'tcx>> + Par
             // us a test case.
             debug_assert_eq!(normalized_value, resolved_value);
             let erased = infcx.tcx.erase_and_anonymize_regions(resolved_value);
-            debug_assert!(!erased.has_infer(), "{erased:?}");
+            if infcx.next_trait_solver() {
+                debug_assert!(!erased.has_infer(), "{erased:?}");
+            } else {
+                // The old solver returns an ty var with the failed obligation in case of
+                // selection error. And when the obligation is re-tried, the error should be
+                // reported. However in case of overflow error, the obligation may be fulfilled
+                // due to the original depth being dropped.
+                // In conclusion, overflow results in an unconstrained ty var.
+                if erased.has_infer() {
+                    return Err(NoSolution);
+                }
+            }
             Ok(erased)
         }
         Err(NoSolution) => Err(NoSolution),
diff --git a/tests/crashes/105275.rs b/tests/ui/codegen/normalization-overflow/recursion-issue-105275.rs
similarity index 84%
rename from tests/crashes/105275.rs
rename to tests/ui/codegen/normalization-overflow/recursion-issue-105275.rs
index a97f36d19872c..98bbfd4420dc6 100644
--- a/tests/crashes/105275.rs
+++ b/tests/ui/codegen/normalization-overflow/recursion-issue-105275.rs
@@ -1,9 +1,10 @@
-//@ known-bug: #105275
+//@ build-fail
 //@ compile-flags: -Copt-level=0
 
 pub fn encode_num<Writer: ExampleWriter>(n: u32, mut writer: Writer) -> Result<(), Writer::Error> {
     if n > 15 {
         encode_num(n / 16, &mut writer)?;
+        //~^ ERROR: reached the recursion limit while instantiating
     }
     Ok(())
 }
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-105275.stderr b/tests/ui/codegen/normalization-overflow/recursion-issue-105275.stderr
new file mode 100644
index 0000000000000..94fba4621d0a0
--- /dev/null
+++ b/tests/ui/codegen/normalization-overflow/recursion-issue-105275.stderr
@@ -0,0 +1,14 @@
+error: reached the recursion limit while instantiating `encode_num::<&mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut Error>`
+  --> $DIR/recursion-issue-105275.rs:6:9
+   |
+LL |         encode_num(n / 16, &mut writer)?;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `encode_num` defined here
+  --> $DIR/recursion-issue-105275.rs:4:1
+   |
+LL | pub fn encode_num<Writer: ExampleWriter>(n: u32, mut writer: Writer) -> Result<(), Writer::Error> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/crashes/105937.rs b/tests/ui/codegen/normalization-overflow/recursion-issue-105937.rs
similarity index 84%
rename from tests/crashes/105937.rs
rename to tests/ui/codegen/normalization-overflow/recursion-issue-105937.rs
index ffd1a493e46d5..98bbfd4420dc6 100644
--- a/tests/crashes/105937.rs
+++ b/tests/ui/codegen/normalization-overflow/recursion-issue-105937.rs
@@ -1,9 +1,10 @@
-//@ known-bug: #105937
+//@ build-fail
 //@ compile-flags: -Copt-level=0
 
 pub fn encode_num<Writer: ExampleWriter>(n: u32, mut writer: Writer) -> Result<(), Writer::Error> {
     if n > 15 {
         encode_num(n / 16, &mut writer)?;
+        //~^ ERROR: reached the recursion limit while instantiating
     }
     Ok(())
 }
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-105937.stderr b/tests/ui/codegen/normalization-overflow/recursion-issue-105937.stderr
new file mode 100644
index 0000000000000..64f33d251d5f0
--- /dev/null
+++ b/tests/ui/codegen/normalization-overflow/recursion-issue-105937.stderr
@@ -0,0 +1,14 @@
+error: reached the recursion limit while instantiating `encode_num::<&mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut Error>`
+  --> $DIR/recursion-issue-105937.rs:6:9
+   |
+LL |         encode_num(n / 16, &mut writer)?;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `encode_num` defined here
+  --> $DIR/recursion-issue-105937.rs:4:1
+   |
+LL | pub fn encode_num<Writer: ExampleWriter>(n: u32, mut writer: Writer) -> Result<(), Writer::Error> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/crashes/117696-1.rs b/tests/ui/codegen/normalization-overflow/recursion-issue-117696-1.rs
similarity index 81%
rename from tests/crashes/117696-1.rs
rename to tests/ui/codegen/normalization-overflow/recursion-issue-117696-1.rs
index dfca39177855d..2109afbd84237 100644
--- a/tests/crashes/117696-1.rs
+++ b/tests/ui/codegen/normalization-overflow/recursion-issue-117696-1.rs
@@ -1,4 +1,4 @@
-//@ known-bug: #117696
+//@ build-fail
 fn main() {
     let mut it = (Empty);
     rec(&mut it);
@@ -23,6 +23,7 @@ where
 {
     if () == () {
         T::count(it);
+        //~^ ERROR: reached the recursion limit while instantiating
     } else {
         rec(identity(&mut it))
     }
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-117696-1.stderr b/tests/ui/codegen/normalization-overflow/recursion-issue-117696-1.stderr
new file mode 100644
index 0000000000000..b261530c010d5
--- /dev/null
+++ b/tests/ui/codegen/normalization-overflow/recursion-issue-117696-1.stderr
@@ -0,0 +1,11 @@
+error: reached the recursion limit while instantiating `<&mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut Empty as Iterator>::count`
+  --> $DIR/recursion-issue-117696-1.rs:25:9
+   |
+LL |         T::count(it);
+   |         ^^^^^^^^^^^^
+   |
+note: `count` defined here
+  --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
+
+error: aborting due to 1 previous error
+
diff --git a/tests/crashes/117696-2.rs b/tests/ui/codegen/normalization-overflow/recursion-issue-117696-2.rs
similarity index 70%
rename from tests/crashes/117696-2.rs
rename to tests/ui/codegen/normalization-overflow/recursion-issue-117696-2.rs
index 9c2a68d3a915c..0236e799bcb8b 100644
--- a/tests/crashes/117696-2.rs
+++ b/tests/ui/codegen/normalization-overflow/recursion-issue-117696-2.rs
@@ -1,4 +1,4 @@
-//@ known-bug: #117696
+//@ build-fail
 //@ compile-flags: -Copt-level=0
 fn main() {
     rec(&mut None::<()>.into_iter());
@@ -9,5 +9,6 @@ fn rec<T: Iterator>(mut it: T) {
         it.next();
     } else {
         rec(&mut it);
+        //~^ ERROR: reached the recursion limit while instantiating
     }
 }
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-117696-2.stderr b/tests/ui/codegen/normalization-overflow/recursion-issue-117696-2.stderr
new file mode 100644
index 0000000000000..88cfb8904d2c7
--- /dev/null
+++ b/tests/ui/codegen/normalization-overflow/recursion-issue-117696-2.stderr
@@ -0,0 +1,14 @@
+error: reached the recursion limit while instantiating `rec::<&mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut std::option::IntoIter<()>>`
+  --> $DIR/recursion-issue-117696-2.rs:11:9
+   |
+LL |         rec(&mut it);
+   |         ^^^^^^^^^^^^
+   |
+note: `rec` defined here
+  --> $DIR/recursion-issue-117696-2.rs:7:1
+   |
+LL | fn rec<T: Iterator>(mut it: T) {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/crashes/118590.rs b/tests/ui/codegen/normalization-overflow/recursion-issue-118590.rs
similarity index 65%
rename from tests/crashes/118590.rs
rename to tests/ui/codegen/normalization-overflow/recursion-issue-118590.rs
index 829c16582dc92..dba23d9d0bdd9 100644
--- a/tests/crashes/118590.rs
+++ b/tests/ui/codegen/normalization-overflow/recursion-issue-118590.rs
@@ -1,4 +1,4 @@
-//@ known-bug: #118590
+//@ build-fail
 
 fn main() {
     recurse(std::iter::empty::<()>())
@@ -8,4 +8,5 @@ fn recurse(nums: impl Iterator) {
     if true { return }
 
     recurse(nums.skip(42).peekable())
+    //~^ ERROR: reached the recursion limit while instantiating
 }
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-118590.stderr b/tests/ui/codegen/normalization-overflow/recursion-issue-118590.stderr
new file mode 100644
index 0000000000000..bf07c19f70479
--- /dev/null
+++ b/tests/ui/codegen/normalization-overflow/recursion-issue-118590.stderr
@@ -0,0 +1,11 @@
+error: reached the recursion limit while instantiating `<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<Peekable<Skip<std::iter::Empty<()>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as Iterator>::peekable`
+  --> $DIR/recursion-issue-118590.rs:10:13
+   |
+LL |     recurse(nums.skip(42).peekable())
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `peekable` defined here
+  --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
+
+error: aborting due to 1 previous error
+
diff --git a/tests/crashes/122823.rs b/tests/ui/codegen/normalization-overflow/recursion-issue-122823.rs
similarity index 95%
rename from tests/crashes/122823.rs
rename to tests/ui/codegen/normalization-overflow/recursion-issue-122823.rs
index ec22b331ad929..9df8e7f28386f 100644
--- a/tests/crashes/122823.rs
+++ b/tests/ui/codegen/normalization-overflow/recursion-issue-122823.rs
@@ -1,4 +1,4 @@
-//@ known-bug: #122823
+//@ build-fail
 //@ compile-flags: -Copt-level=0
 // ignore-tidy-linelength
 
@@ -41,6 +41,7 @@ pub fn operator_packet<I: Iterator<Item = u64>>(version: u64, type_id: u64, itr:
         version: version,
         type_id: type_id,
         packets: decode_packets(&mut itr.take(0).peekable()),
+        //~^ ERROR: reached the recursion limit while instantiating
     };
 
     return Some(Packet::Operator(p));
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-122823.stderr b/tests/ui/codegen/normalization-overflow/recursion-issue-122823.stderr
new file mode 100644
index 0000000000000..7102298bcc6fc
--- /dev/null
+++ b/tests/ui/codegen/normalization-overflow/recursion-issue-122823.stderr
@@ -0,0 +1,11 @@
+error: reached the recursion limit while instantiating `<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::vec::IntoIter<u64>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as Iterator>::peekable`
+  --> $DIR/recursion-issue-122823.rs:43:38
+   |
+LL |         packets: decode_packets(&mut itr.take(0).peekable()),
+   |                                      ^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `peekable` defined here
+  --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
+
+error: aborting due to 1 previous error
+
diff --git a/tests/crashes/131342.rs b/tests/ui/codegen/normalization-overflow/recursion-issue-131342.rs
similarity index 79%
rename from tests/crashes/131342.rs
rename to tests/ui/codegen/normalization-overflow/recursion-issue-131342.rs
index f4404092917a4..55a2c0647c2f4 100644
--- a/tests/crashes/131342.rs
+++ b/tests/ui/codegen/normalization-overflow/recursion-issue-131342.rs
@@ -1,4 +1,4 @@
-//@ known-bug: #131342
+//@ build-fail
 
 fn main() {
     let mut items = vec![1, 2, 3, 4, 5].into_iter();
@@ -7,6 +7,7 @@ fn main() {
 
 fn problem_thingy(items: &mut impl Iterator<Item = u8>) {
     let mut peeker = items.peekable();
+    //~^ ERROR: reached the recursion limit while instantiating
     match peeker.peek() {
         Some(_) => (),
         None => return (),
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-131342.stderr b/tests/ui/codegen/normalization-overflow/recursion-issue-131342.stderr
new file mode 100644
index 0000000000000..fa313be0b8142
--- /dev/null
+++ b/tests/ui/codegen/normalization-overflow/recursion-issue-131342.stderr
@@ -0,0 +1,11 @@
+error: reached the recursion limit while instantiating `<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut Peekable<&mut std::vec::IntoIter<u8>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as Iterator>::peekable`
+  --> $DIR/recursion-issue-131342.rs:9:22
+   |
+LL |     let mut peeker = items.peekable();
+   |                      ^^^^^^^^^^^^^^^^
+   |
+note: `peekable` defined here
+  --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
+
+error: aborting due to 1 previous error
+
diff --git a/tests/crashes/139659.rs b/tests/ui/codegen/normalization-overflow/recursion-issue-139659.rs
similarity index 86%
rename from tests/crashes/139659.rs
rename to tests/ui/codegen/normalization-overflow/recursion-issue-139659.rs
index 7fc33f7e6a7cf..30f97dba6ee58 100644
--- a/tests/crashes/139659.rs
+++ b/tests/ui/codegen/normalization-overflow/recursion-issue-139659.rs
@@ -1,5 +1,6 @@
-//@ known-bug: #139659
+//@ build-fail
 //@compile-flags: -Cdebuginfo=2 -Copt-level=0 --crate-type lib
+//~^^ ERROR: reached the recursion limit while instantiating
 trait Trait {
     type Output;
 }
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-139659.stderr b/tests/ui/codegen/normalization-overflow/recursion-issue-139659.stderr
new file mode 100644
index 0000000000000..5e1e4fe18f842
--- /dev/null
+++ b/tests/ui/codegen/normalization-overflow/recursion-issue-139659.stderr
@@ -0,0 +1,10 @@
+error: reached the recursion limit while instantiating `recurse`
+   |
+note: `recurse` defined here
+  --> $DIR/recursion-issue-139659.rs:27:1
+   |
+LL | pub fn recurse() -> impl Sized {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/crashes/92004.rs b/tests/ui/codegen/normalization-overflow/recursion-issue-92004.rs
similarity index 95%
rename from tests/crashes/92004.rs
rename to tests/ui/codegen/normalization-overflow/recursion-issue-92004.rs
index bc2ca2a7ba389..949359cfa4238 100644
--- a/tests/crashes/92004.rs
+++ b/tests/ui/codegen/normalization-overflow/recursion-issue-92004.rs
@@ -1,4 +1,4 @@
-//@ known-bug: #102310
+//@ build-fail
 //@ compile-flags: -Copt-level=0
 //@ edition:2021
 // ignore-tidy-linelength
@@ -42,6 +42,7 @@ pub fn operator_packet<I: Iterator<Item = u64>>(version: u64, type_id: u64, itr:
         version: version,
         type_id: type_id,
         packets: decode_packets(&mut itr.take(0).peekable()),
+        //~^ ERROR: reached the recursion limit while instantiating
     };
 
     return Some(Packet::Operator(p));
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-92004.stderr b/tests/ui/codegen/normalization-overflow/recursion-issue-92004.stderr
new file mode 100644
index 0000000000000..e6f14b995a82e
--- /dev/null
+++ b/tests/ui/codegen/normalization-overflow/recursion-issue-92004.stderr
@@ -0,0 +1,11 @@
+error: reached the recursion limit while instantiating `<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::iter::Take<&mut Peekable<std::vec::IntoIter<u64>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as Iterator>::peekable`
+  --> $DIR/recursion-issue-92004.rs:44:38
+   |
+LL |         packets: decode_packets(&mut itr.take(0).peekable()),
+   |                                      ^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `peekable` defined here
+  --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
+
+error: aborting due to 1 previous error
+
diff --git a/tests/crashes/92470.rs b/tests/ui/codegen/normalization-overflow/recursion-issue-92470.rs
similarity index 76%
rename from tests/crashes/92470.rs
rename to tests/ui/codegen/normalization-overflow/recursion-issue-92470.rs
index a3c518f5ec62f..cd024d75897e1 100644
--- a/tests/crashes/92470.rs
+++ b/tests/ui/codegen/normalization-overflow/recursion-issue-92470.rs
@@ -1,4 +1,4 @@
-//@ known-bug: #92470
+//@ build-fail
 fn main() {
     encode(&mut EncoderImpl);
 }
@@ -10,8 +10,10 @@ pub trait Encoder {
 }
 
 fn encode<E: Encoder>(mut encoder: E) {
+//~^ WARN: function cannot return without recursing
     encoder.writer();
     encode(&mut encoder);
+    //~^ ERROR: reached the recursion limit while instantiating
 }
 
 struct EncoderImpl;
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-92470.stderr b/tests/ui/codegen/normalization-overflow/recursion-issue-92470.stderr
new file mode 100644
index 0000000000000..1775a99928853
--- /dev/null
+++ b/tests/ui/codegen/normalization-overflow/recursion-issue-92470.stderr
@@ -0,0 +1,26 @@
+warning: function cannot return without recursing
+  --> $DIR/recursion-issue-92470.rs:12:1
+   |
+LL | fn encode<E: Encoder>(mut encoder: E) {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot return without recursing
+...
+LL |     encode(&mut encoder);
+   |     -------------------- recursive call site
+   |
+   = help: a `loop` may express intention better if this is on purpose
+   = note: `#[warn(unconditional_recursion)]` on by default
+
+error: reached the recursion limit while instantiating `encode::<&mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut EncoderImpl>`
+  --> $DIR/recursion-issue-92470.rs:15:5
+   |
+LL |     encode(&mut encoder);
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+note: `encode` defined here
+  --> $DIR/recursion-issue-92470.rs:12:1
+   |
+LL | fn encode<E: Encoder>(mut encoder: E) {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error; 1 warning emitted
+
diff --git a/tests/crashes/95134.rs b/tests/ui/codegen/normalization-overflow/recursion-issue-95134.rs
similarity index 85%
rename from tests/crashes/95134.rs
rename to tests/ui/codegen/normalization-overflow/recursion-issue-95134.rs
index bcd88b1076fd9..bbeeeeda6090a 100644
--- a/tests/crashes/95134.rs
+++ b/tests/ui/codegen/normalization-overflow/recursion-issue-95134.rs
@@ -1,9 +1,10 @@
-//@ known-bug: #95134
+//@ build-fail
 //@ compile-flags: -Copt-level=0
 
 pub fn encode_num<Writer: ExampleWriter>(n: u32, mut writer: Writer) -> Result<(), Writer::Error> {
     if n > 15 {
         encode_num(n / 16, &mut writer)?;
+        //~^ ERROR: reached the recursion limit while instantiating
     }
     Ok(())
 }
diff --git a/tests/ui/codegen/normalization-overflow/recursion-issue-95134.stderr b/tests/ui/codegen/normalization-overflow/recursion-issue-95134.stderr
new file mode 100644
index 0000000000000..0c49e0010f54c
--- /dev/null
+++ b/tests/ui/codegen/normalization-overflow/recursion-issue-95134.stderr
@@ -0,0 +1,14 @@
+error: reached the recursion limit while instantiating `encode_num::<&mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut &mut EmptyWriter>`
+  --> $DIR/recursion-issue-95134.rs:6:9
+   |
+LL |         encode_num(n / 16, &mut writer)?;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `encode_num` defined here
+  --> $DIR/recursion-issue-95134.rs:4:1
+   |
+LL | pub fn encode_num<Writer: ExampleWriter>(n: u32, mut writer: Writer) -> Result<(), Writer::Error> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+

From e0b7b2350e0fd22e65175ba4f600162b69805280 Mon Sep 17 00:00:00 2001
From: Yuki Okushi <huyuumi.dev@gmail.com>
Date: Sun, 12 Oct 2025 08:23:44 +0900
Subject: [PATCH 1885/1889] Add a regression test for #72207

---
 .../associated-type-fn-bound-issue-72207.rs   | 57 +++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 tests/ui/impl-trait/associated-type-fn-bound-issue-72207.rs

diff --git a/tests/ui/impl-trait/associated-type-fn-bound-issue-72207.rs b/tests/ui/impl-trait/associated-type-fn-bound-issue-72207.rs
new file mode 100644
index 0000000000000..67e4ed9f4c87a
--- /dev/null
+++ b/tests/ui/impl-trait/associated-type-fn-bound-issue-72207.rs
@@ -0,0 +1,57 @@
+//@ check-pass
+//@ compile-flags: --crate-type=lib
+
+#![allow(dead_code)]
+
+use std::marker::PhantomData;
+
+pub struct XImpl<T, E, F2, F1>
+where
+    F2: Fn(E),
+{
+    f1: F1,
+    f2: F2,
+    _ghost: PhantomData<(T, E)>,
+}
+
+pub trait X<T>: Sized {
+    type F1;
+    type F2: Fn(Self::E);
+    type E;
+
+    fn and<NewF1, NewF1Generator>(self, f: NewF1Generator) -> XImpl<T, Self::E, Self::F2, NewF1>
+    where
+        NewF1Generator: FnOnce(Self::F1) -> NewF1;
+}
+
+impl<T, E, F2, F1> X<T> for XImpl<T, E, F2, F1>
+where
+    F2: Fn(E),
+{
+    type E = E;
+    type F2 = F2;
+    type F1 = F1;
+
+    fn and<NewF1, NewF1Generator>(self, f: NewF1Generator) -> XImpl<T, E, F2, NewF1>
+    where
+        NewF1Generator: FnOnce(F1) -> NewF1,
+    {
+        XImpl {
+            f1: f(self.f1),
+            f2: self.f2,
+            _ghost: PhantomData,
+        }
+    }
+}
+
+fn f() -> impl X<(), E = ()> {
+    XImpl {
+        f1: || (),
+        f2: |()| (),
+        _ghost: PhantomData,
+    }
+}
+
+fn f2() -> impl X<(), E = ()> {
+    f().and(|rb| rb)
+}

From 6ca69812cd69969dc4ff74fa0ea2d5ebedf62b2f Mon Sep 17 00:00:00 2001
From: Oneirical <manchot@videotron.ca>
Date: Wed, 20 Aug 2025 14:02:57 -0400
Subject: [PATCH 1886/1889] Add test batch 4

---
 ...large-zst-array-compilation-time-68010.rs} |  1 +
 .../mismatched-types-in-trait-impl-65230.rs}  |  1 +
 ...smatched-types-in-trait-impl-65230.stderr} |  4 +--
 .../labeled-break-in-async-fn-ice-66702.rs}   |  1 +
 ...abeled-break-in-async-fn-ice-66702.stderr} |  4 +--
 ...orrow-of-moved-value-in-for-loop-61108.rs} |  1 +
 ...w-of-moved-value-in-for-loop-61108.stderr} |  2 +-
 ...oved-value-in-closure-suggestion-64559.rs} |  1 +
 ...-value-in-closure-suggestion-64559.stderr} |  2 +-
 .../multiple-mutable-borrows-error-65131.rs}  |  1 +
 ...ltiple-mutable-borrows-error-65131.stderr} |  2 +-
 .../mutable-borrow-behind-reference-61623.rs} |  1 +
 ...able-borrow-behind-reference-61623.stderr} |  2 +-
 .../labeled-break-inside-closure-62480.rs}    |  1 +
 ...labeled-break-inside-closure-62480.stderr} |  4 +--
 ...emscripten-llvm-crash-regression-66308.rs} |  1 +
 ...ure-type-error-during-const-eval-66706.rs} |  1 +
 ...type-error-during-const-eval-66706.stderr} | 12 ++++-----
 ...comparing-function-inside-itself-66667.rs} |  1 +
 ...aring-function-inside-itself-66667.stderr} | 18 ++++++-------
 .../extern-rust-ffi-warning-64593.rs}         |  1 +
 ...elf-unconstrained-inference-vars-69306.rs} |  1 +
 ...unconstrained-inference-vars-69306.stderr} | 26 +++++++++----------
 .../bitwise-integer-inference-68951.rs}       |  1 +
 .../late-bound-lifetime-parameters-60622.rs}  |  1 +
 ...te-bound-lifetime-parameters-60622.stderr} |  8 +++---
 ...ror-on-tuple-and-struct-variants-63983.rs} |  1 +
 ...on-tuple-and-struct-variants-63983.stderr} |  4 +--
 .../collect-method-type-mismatch-66923.rs}    |  1 +
 ...collect-method-type-mismatch-66923.stderr} |  8 +++---
 .../string-clone-mismatch-61106.rs}           |  1 +
 .../string-clone-mismatch-61106.stderr}       |  4 +--
 .../no-std-panic-abort-error-64430.rs}        |  1 +
 .../no-std-panic-abort-error-64430.stderr}    |  2 +-
 .../catch-unwind-during-unwind-68696.rs}      |  1 +
 ...ter-indexing-bug-in-splice-lines-69130.rs} |  0
 ...indexing-bug-in-splice-lines-69130.stderr} |  4 +--
 ...-matching-with-double-references-61475.rs} |  1 +
 ...code-string-literal-syntax-error-64792.rs} |  1 +
 ...-string-literal-syntax-error-64792.stderr} |  2 +-
 ...plementation-for-non-local-types-67535.rs} |  1 +
 ...entation-for-non-local-types-67535.stderr} |  6 ++---
 .../associated-type-ice-recovery-66353.rs}    |  1 +
 ...associated-type-ice-recovery-66353.stderr} |  8 +++---
 ...type-arguments-on-local-variable-60989.rs} |  1 +
 ...-arguments-on-local-variable-60989.stderr} |  4 +--
 .../type-name-intrinsic-usage-61894.rs}       |  3 ++-
 .../union-field-access-error-65462.rs}        |  1 +
 48 files changed, 91 insertions(+), 64 deletions(-)
 rename tests/ui/{issues/issue-68010-large-zst-consts.rs => array-slice-vec/large-zst-array-compilation-time-68010.rs} (59%)
 rename tests/ui/{issues/issue-65230.rs => associated-types/mismatched-types-in-trait-impl-65230.rs} (75%)
 rename tests/ui/{issues/issue-65230.stderr => associated-types/mismatched-types-in-trait-impl-65230.stderr} (81%)
 rename tests/ui/{issues/issue-66702-break-outside-loop-val.rs => async-await/labeled-break-in-async-fn-ice-66702.rs} (82%)
 rename tests/ui/{issues/issue-66702-break-outside-loop-val.stderr => async-await/labeled-break-in-async-fn-ice-66702.stderr} (86%)
 rename tests/ui/{issues/issue-61108.rs => borrowck/borrow-of-moved-value-in-for-loop-61108.rs} (79%)
 rename tests/ui/{issues/issue-61108.stderr => borrowck/borrow-of-moved-value-in-for-loop-61108.stderr} (93%)
 rename tests/ui/{issues/issue-64559.rs => borrowck/moved-value-in-closure-suggestion-64559.rs} (72%)
 rename tests/ui/{issues/issue-64559.stderr => borrowck/moved-value-in-closure-suggestion-64559.stderr} (93%)
 rename tests/ui/{issues/issue-65131.rs => borrowck/multiple-mutable-borrows-error-65131.rs} (89%)
 rename tests/ui/{issues/issue-65131.stderr => borrowck/multiple-mutable-borrows-error-65131.stderr} (87%)
 rename tests/ui/{issues/issue-61623.rs => borrowck/mutable-borrow-behind-reference-61623.rs} (80%)
 rename tests/ui/{issues/issue-61623.stderr => borrowck/mutable-borrow-behind-reference-61623.stderr} (89%)
 rename tests/ui/{issues/issue-62480.rs => closures/labeled-break-inside-closure-62480.rs} (87%)
 rename tests/ui/{issues/issue-62480.stderr => closures/labeled-break-inside-closure-62480.stderr} (85%)
 rename tests/ui/{issues/issue-66308.rs => codegen/emscripten-llvm-crash-regression-66308.rs} (77%)
 rename tests/ui/{issues/issue-66706.rs => consts/closure-type-error-during-const-eval-66706.rs} (91%)
 rename tests/ui/{issues/issue-66706.stderr => consts/closure-type-error-during-const-eval-66706.stderr} (75%)
 rename tests/ui/{issues/issue-66667-function-cmp-cycle.rs => cycle-trait/cycle-error-comparing-function-inside-itself-66667.rs} (88%)
 rename tests/ui/{issues/issue-66667-function-cmp-cycle.stderr => cycle-trait/cycle-error-comparing-function-inside-itself-66667.stderr} (73%)
 rename tests/ui/{issues/issue-64593.rs => foreign/extern-rust-ffi-warning-64593.rs} (80%)
 rename tests/ui/{issues/issue-69306.rs => generics/generic-struct-self-unconstrained-inference-vars-69306.rs} (93%)
 rename tests/ui/{issues/issue-69306.stderr => generics/generic-struct-self-unconstrained-inference-vars-69306.stderr} (80%)
 rename tests/ui/{issues/issue-68951.rs => inference/bitwise-integer-inference-68951.rs} (74%)
 rename tests/ui/{issues/issue-60622.rs => lifetimes/late-bound-lifetime-parameters-60622.rs} (89%)
 rename tests/ui/{issues/issue-60622.stderr => lifetimes/late-bound-lifetime-parameters-60622.stderr} (83%)
 rename tests/ui/{issues/issue-63983.rs => match/unit-pattern-error-on-tuple-and-struct-variants-63983.rs} (87%)
 rename tests/ui/{issues/issue-63983.stderr => match/unit-pattern-error-on-tuple-and-struct-variants-63983.stderr} (85%)
 rename tests/ui/{issues/issue-66923-show-error-for-correct-call.rs => mismatched_types/collect-method-type-mismatch-66923.rs} (89%)
 rename tests/ui/{issues/issue-66923-show-error-for-correct-call.stderr => mismatched_types/collect-method-type-mismatch-66923.stderr} (89%)
 rename tests/ui/{issues/issue-61106.rs => mismatched_types/string-clone-mismatch-61106.rs} (68%)
 rename tests/ui/{issues/issue-61106.stderr => mismatched_types/string-clone-mismatch-61106.stderr} (82%)
 rename tests/ui/{issues/issue-64430.rs => no_std/no-std-panic-abort-error-64430.rs} (79%)
 rename tests/ui/{issues/issue-64430.stderr => no_std/no-std-panic-abort-error-64430.stderr} (87%)
 rename tests/ui/{issues/issue-68696-catch-during-unwind.rs => panic-handler/catch-unwind-during-unwind-68696.rs} (92%)
 rename tests/ui/{issues/issue-69130.rs => parser/character-indexing-bug-in-splice-lines-69130.rs} (100%)
 rename tests/ui/{issues/issue-69130.stderr => parser/character-indexing-bug-in-splice-lines-69130.stderr} (75%)
 rename tests/ui/{issues/issue-61475.rs => parser/pattern-matching-with-double-references-61475.rs} (75%)
 rename tests/ui/{issues/issue-64792-bad-unicode-ctor.rs => parser/unicode-string-literal-syntax-error-64792.rs} (71%)
 rename tests/ui/{issues/issue-64792-bad-unicode-ctor.stderr => parser/unicode-string-literal-syntax-error-64792.stderr} (85%)
 rename tests/ui/{issues/issue-67535.rs => traits/trait-implementation-for-non-local-types-67535.rs} (92%)
 rename tests/ui/{issues/issue-67535.stderr => traits/trait-implementation-for-non-local-types-67535.stderr} (91%)
 rename tests/ui/{issues/issue-66353.rs => typeck/associated-type-ice-recovery-66353.rs} (86%)
 rename tests/ui/{issues/issue-66353.stderr => typeck/associated-type-ice-recovery-66353.stderr} (78%)
 rename tests/ui/{issues/issue-60989.rs => typeck/type-arguments-on-local-variable-60989.rs} (86%)
 rename tests/ui/{issues/issue-60989.stderr => typeck/type-arguments-on-local-variable-60989.stderr} (80%)
 rename tests/ui/{issues/issue-61894.rs => typeck/type-name-intrinsic-usage-61894.rs} (70%)
 rename tests/ui/{issues/issue-65462.rs => union/union-field-access-error-65462.rs} (80%)

diff --git a/tests/ui/issues/issue-68010-large-zst-consts.rs b/tests/ui/array-slice-vec/large-zst-array-compilation-time-68010.rs
similarity index 59%
rename from tests/ui/issues/issue-68010-large-zst-consts.rs
rename to tests/ui/array-slice-vec/large-zst-array-compilation-time-68010.rs
index 167c92f004e1d..607104dbaa12f 100644
--- a/tests/ui/issues/issue-68010-large-zst-consts.rs
+++ b/tests/ui/array-slice-vec/large-zst-array-compilation-time-68010.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/68010
 //@ build-pass
 
 fn main() {
diff --git a/tests/ui/issues/issue-65230.rs b/tests/ui/associated-types/mismatched-types-in-trait-impl-65230.rs
similarity index 75%
rename from tests/ui/issues/issue-65230.rs
rename to tests/ui/associated-types/mismatched-types-in-trait-impl-65230.rs
index 54141d2214cd9..e762f5a748549 100644
--- a/tests/ui/issues/issue-65230.rs
+++ b/tests/ui/associated-types/mismatched-types-in-trait-impl-65230.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/65230
 trait T0 {}
 trait T1: T0 {}
 
diff --git a/tests/ui/issues/issue-65230.stderr b/tests/ui/associated-types/mismatched-types-in-trait-impl-65230.stderr
similarity index 81%
rename from tests/ui/issues/issue-65230.stderr
rename to tests/ui/associated-types/mismatched-types-in-trait-impl-65230.stderr
index c959658c0ce27..c34685aacad5c 100644
--- a/tests/ui/issues/issue-65230.stderr
+++ b/tests/ui/associated-types/mismatched-types-in-trait-impl-65230.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/issue-65230.rs:8:13
+  --> $DIR/mismatched-types-in-trait-impl-65230.rs:9:13
    |
 LL | impl T1 for &dyn T2 {}
    |             ^^^^^^^ lifetime mismatch
@@ -7,7 +7,7 @@ LL | impl T1 for &dyn T2 {}
    = note: expected trait `<&dyn T2 as T0>`
               found trait `<&(dyn T2 + 'static) as T0>`
 note: the anonymous lifetime as defined here...
-  --> $DIR/issue-65230.rs:8:13
+  --> $DIR/mismatched-types-in-trait-impl-65230.rs:9:13
    |
 LL | impl T1 for &dyn T2 {}
    |             ^
diff --git a/tests/ui/issues/issue-66702-break-outside-loop-val.rs b/tests/ui/async-await/labeled-break-in-async-fn-ice-66702.rs
similarity index 82%
rename from tests/ui/issues/issue-66702-break-outside-loop-val.rs
rename to tests/ui/async-await/labeled-break-in-async-fn-ice-66702.rs
index 05b86cbbf8f05..923c2ad61164e 100644
--- a/tests/ui/issues/issue-66702-break-outside-loop-val.rs
+++ b/tests/ui/async-await/labeled-break-in-async-fn-ice-66702.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/66702
 // Breaks with values inside closures used to ICE (#66863)
 
 fn main() {
diff --git a/tests/ui/issues/issue-66702-break-outside-loop-val.stderr b/tests/ui/async-await/labeled-break-in-async-fn-ice-66702.stderr
similarity index 86%
rename from tests/ui/issues/issue-66702-break-outside-loop-val.stderr
rename to tests/ui/async-await/labeled-break-in-async-fn-ice-66702.stderr
index f92ede311afb4..781e4e63913f4 100644
--- a/tests/ui/issues/issue-66702-break-outside-loop-val.stderr
+++ b/tests/ui/async-await/labeled-break-in-async-fn-ice-66702.stderr
@@ -1,5 +1,5 @@
 error[E0767]: use of unreachable label `'some_label`
-  --> $DIR/issue-66702-break-outside-loop-val.rs:5:18
+  --> $DIR/labeled-break-in-async-fn-ice-66702.rs:6:18
    |
 LL |     'some_label: loop {
    |     ----------- unreachable label defined here
@@ -9,7 +9,7 @@ LL |         || break 'some_label ();
    = note: labels are unreachable through functions, closures, async blocks and modules
 
 error[E0267]: `break` inside of a closure
-  --> $DIR/issue-66702-break-outside-loop-val.rs:5:12
+  --> $DIR/labeled-break-in-async-fn-ice-66702.rs:6:12
    |
 LL |         || break 'some_label ();
    |         -- ^^^^^^^^^^^^^^^^^^^^ cannot `break` inside of a closure
diff --git a/tests/ui/issues/issue-61108.rs b/tests/ui/borrowck/borrow-of-moved-value-in-for-loop-61108.rs
similarity index 79%
rename from tests/ui/issues/issue-61108.rs
rename to tests/ui/borrowck/borrow-of-moved-value-in-for-loop-61108.rs
index 0a883b9581835..d2e11b2dbffe9 100644
--- a/tests/ui/issues/issue-61108.rs
+++ b/tests/ui/borrowck/borrow-of-moved-value-in-for-loop-61108.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/61108
 fn main() {
     let mut bad_letters = vec!['e', 't', 'o', 'i'];
     for l in bad_letters {
diff --git a/tests/ui/issues/issue-61108.stderr b/tests/ui/borrowck/borrow-of-moved-value-in-for-loop-61108.stderr
similarity index 93%
rename from tests/ui/issues/issue-61108.stderr
rename to tests/ui/borrowck/borrow-of-moved-value-in-for-loop-61108.stderr
index d018986efecec..4c3fa5e56dc9b 100644
--- a/tests/ui/issues/issue-61108.stderr
+++ b/tests/ui/borrowck/borrow-of-moved-value-in-for-loop-61108.stderr
@@ -1,5 +1,5 @@
 error[E0382]: borrow of moved value: `bad_letters`
-  --> $DIR/issue-61108.rs:6:5
+  --> $DIR/borrow-of-moved-value-in-for-loop-61108.rs:7:5
    |
 LL |     let mut bad_letters = vec!['e', 't', 'o', 'i'];
    |         --------------- move occurs because `bad_letters` has type `Vec<char>`, which does not implement the `Copy` trait
diff --git a/tests/ui/issues/issue-64559.rs b/tests/ui/borrowck/moved-value-in-closure-suggestion-64559.rs
similarity index 72%
rename from tests/ui/issues/issue-64559.rs
rename to tests/ui/borrowck/moved-value-in-closure-suggestion-64559.rs
index 71e054b5d9876..c13f91c082a39 100644
--- a/tests/ui/issues/issue-64559.rs
+++ b/tests/ui/borrowck/moved-value-in-closure-suggestion-64559.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/64559
 fn main() {
     let orig = vec![true];
     for _val in orig {}
diff --git a/tests/ui/issues/issue-64559.stderr b/tests/ui/borrowck/moved-value-in-closure-suggestion-64559.stderr
similarity index 93%
rename from tests/ui/issues/issue-64559.stderr
rename to tests/ui/borrowck/moved-value-in-closure-suggestion-64559.stderr
index 0cab37553406c..09d4d04295c7c 100644
--- a/tests/ui/issues/issue-64559.stderr
+++ b/tests/ui/borrowck/moved-value-in-closure-suggestion-64559.stderr
@@ -1,5 +1,5 @@
 error[E0382]: use of moved value: `orig`
-  --> $DIR/issue-64559.rs:4:20
+  --> $DIR/moved-value-in-closure-suggestion-64559.rs:5:20
    |
 LL |     let orig = vec![true];
    |         ---- move occurs because `orig` has type `Vec<bool>`, which does not implement the `Copy` trait
diff --git a/tests/ui/issues/issue-65131.rs b/tests/ui/borrowck/multiple-mutable-borrows-error-65131.rs
similarity index 89%
rename from tests/ui/issues/issue-65131.rs
rename to tests/ui/borrowck/multiple-mutable-borrows-error-65131.rs
index 8b5345da900aa..ccf8b00a78a2d 100644
--- a/tests/ui/issues/issue-65131.rs
+++ b/tests/ui/borrowck/multiple-mutable-borrows-error-65131.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/65131
 fn get_pair(_a: &mut u32, _b: &mut u32) {}
 
 macro_rules! x10 {
diff --git a/tests/ui/issues/issue-65131.stderr b/tests/ui/borrowck/multiple-mutable-borrows-error-65131.stderr
similarity index 87%
rename from tests/ui/issues/issue-65131.stderr
rename to tests/ui/borrowck/multiple-mutable-borrows-error-65131.stderr
index 70e85b584bd22..1d97403923f99 100644
--- a/tests/ui/issues/issue-65131.stderr
+++ b/tests/ui/borrowck/multiple-mutable-borrows-error-65131.stderr
@@ -1,5 +1,5 @@
 error[E0499]: cannot borrow `x` as mutable more than once at a time
-  --> $DIR/issue-65131.rs:14:22
+  --> $DIR/multiple-mutable-borrows-error-65131.rs:15:22
    |
 LL |     get_pair(&mut x, &mut x);
    |     -------- ------  ^^^^^^ second mutable borrow occurs here
diff --git a/tests/ui/issues/issue-61623.rs b/tests/ui/borrowck/mutable-borrow-behind-reference-61623.rs
similarity index 80%
rename from tests/ui/issues/issue-61623.rs
rename to tests/ui/borrowck/mutable-borrow-behind-reference-61623.rs
index 82df50d9dc34f..ae7bb1c0a76b4 100644
--- a/tests/ui/issues/issue-61623.rs
+++ b/tests/ui/borrowck/mutable-borrow-behind-reference-61623.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/61623
 fn f1<'a>(_: &'a mut ()) {}
 
 fn f2<P>(_: P, _: ()) {}
diff --git a/tests/ui/issues/issue-61623.stderr b/tests/ui/borrowck/mutable-borrow-behind-reference-61623.stderr
similarity index 89%
rename from tests/ui/issues/issue-61623.stderr
rename to tests/ui/borrowck/mutable-borrow-behind-reference-61623.stderr
index be6e28edfc24f..cc7761acda9de 100644
--- a/tests/ui/issues/issue-61623.stderr
+++ b/tests/ui/borrowck/mutable-borrow-behind-reference-61623.stderr
@@ -1,5 +1,5 @@
 error[E0596]: cannot borrow `*x.1` as mutable, as it is behind a `&` reference
-  --> $DIR/issue-61623.rs:6:19
+  --> $DIR/mutable-borrow-behind-reference-61623.rs:7:19
    |
 LL |     f2(|| x.0, f1(x.1))
    |                   ^^^ `x` is a `&` reference, so the data it refers to cannot be borrowed as mutable
diff --git a/tests/ui/issues/issue-62480.rs b/tests/ui/closures/labeled-break-inside-closure-62480.rs
similarity index 87%
rename from tests/ui/issues/issue-62480.rs
rename to tests/ui/closures/labeled-break-inside-closure-62480.rs
index 94a9c2ab8be8e..620f1e220fe42 100644
--- a/tests/ui/issues/issue-62480.rs
+++ b/tests/ui/closures/labeled-break-inside-closure-62480.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/62480
 fn main() {
     // This used to ICE during liveness check because `target_id` passed to
     // `propagate_through_expr` would be the closure and not the `loop`, which wouldn't be found in
diff --git a/tests/ui/issues/issue-62480.stderr b/tests/ui/closures/labeled-break-inside-closure-62480.stderr
similarity index 85%
rename from tests/ui/issues/issue-62480.stderr
rename to tests/ui/closures/labeled-break-inside-closure-62480.stderr
index db230537037a4..a4ca60bb97365 100644
--- a/tests/ui/issues/issue-62480.stderr
+++ b/tests/ui/closures/labeled-break-inside-closure-62480.stderr
@@ -1,5 +1,5 @@
 error[E0767]: use of unreachable label `'a`
-  --> $DIR/issue-62480.rs:6:18
+  --> $DIR/labeled-break-inside-closure-62480.rs:7:18
    |
 LL |     'a: {
    |     -- unreachable label defined here
@@ -9,7 +9,7 @@ LL |         || break 'a
    = note: labels are unreachable through functions, closures, async blocks and modules
 
 error[E0267]: `break` inside of a closure
-  --> $DIR/issue-62480.rs:6:12
+  --> $DIR/labeled-break-inside-closure-62480.rs:7:12
    |
 LL |         || break 'a
    |         -- ^^^^^^^^ cannot `break` inside of a closure
diff --git a/tests/ui/issues/issue-66308.rs b/tests/ui/codegen/emscripten-llvm-crash-regression-66308.rs
similarity index 77%
rename from tests/ui/issues/issue-66308.rs
rename to tests/ui/codegen/emscripten-llvm-crash-regression-66308.rs
index 41f81323e6fbf..c18d6761e8872 100644
--- a/tests/ui/issues/issue-66308.rs
+++ b/tests/ui/codegen/emscripten-llvm-crash-regression-66308.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/66308
 //@ build-pass
 //@ compile-flags: --crate-type lib -C opt-level=0
 
diff --git a/tests/ui/issues/issue-66706.rs b/tests/ui/consts/closure-type-error-during-const-eval-66706.rs
similarity index 91%
rename from tests/ui/issues/issue-66706.rs
rename to tests/ui/consts/closure-type-error-during-const-eval-66706.rs
index 87dc3437a57bd..d88aa30615861 100644
--- a/tests/ui/issues/issue-66706.rs
+++ b/tests/ui/consts/closure-type-error-during-const-eval-66706.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/66706
 fn a() {
     [0; [|_: _ &_| ()].len()]
     //~^ ERROR expected one of `,` or `|`, found `&`
diff --git a/tests/ui/issues/issue-66706.stderr b/tests/ui/consts/closure-type-error-during-const-eval-66706.stderr
similarity index 75%
rename from tests/ui/issues/issue-66706.stderr
rename to tests/ui/consts/closure-type-error-during-const-eval-66706.stderr
index cfe8576400025..e774b1adf1187 100644
--- a/tests/ui/issues/issue-66706.stderr
+++ b/tests/ui/consts/closure-type-error-during-const-eval-66706.stderr
@@ -1,5 +1,5 @@
 error: expected one of `,` or `|`, found `&`
-  --> $DIR/issue-66706.rs:2:16
+  --> $DIR/closure-type-error-during-const-eval-66706.rs:3:16
    |
 LL |     [0; [|_: _ &_| ()].len()]
    |               -^ expected one of `,` or `|`
@@ -7,13 +7,13 @@ LL |     [0; [|_: _ &_| ()].len()]
    |               help: missing `,`
 
 error: expected identifier, found reserved identifier `_`
-  --> $DIR/issue-66706.rs:8:20
+  --> $DIR/closure-type-error-during-const-eval-66706.rs:9:20
    |
 LL |     [0; [|f @ &ref _| {} ; 0 ].len() ];
    |                    ^ expected identifier, found reserved identifier
 
 error: expected one of `,` or `|`, found `&`
-  --> $DIR/issue-66706.rs:13:17
+  --> $DIR/closure-type-error-during-const-eval-66706.rs:14:17
    |
 LL |     [0; [|&_: _ &_| {}; 0 ].len()]
    |                -^ expected one of `,` or `|`
@@ -21,7 +21,7 @@ LL |     [0; [|&_: _ &_| {}; 0 ].len()]
    |                help: missing `,`
 
 error: expected identifier, found reserved identifier `_`
-  --> $DIR/issue-66706.rs:19:26
+  --> $DIR/closure-type-error-during-const-eval-66706.rs:20:26
    |
 LL |     [0; match [|f @ &ref _| () ] {} ]
    |         -----            ^ expected identifier, found reserved identifier
@@ -29,13 +29,13 @@ LL |     [0; match [|f @ &ref _| () ] {} ]
    |         while parsing this `match` expression
 
 error[E0282]: type annotations needed
-  --> $DIR/issue-66706.rs:2:14
+  --> $DIR/closure-type-error-during-const-eval-66706.rs:3:14
    |
 LL |     [0; [|_: _ &_| ()].len()]
    |              ^ cannot infer type
 
 error[E0282]: type annotations needed
-  --> $DIR/issue-66706.rs:13:11
+  --> $DIR/closure-type-error-during-const-eval-66706.rs:14:11
    |
 LL |     [0; [|&_: _ &_| {}; 0 ].len()]
    |           ^^^^^ cannot infer type
diff --git a/tests/ui/issues/issue-66667-function-cmp-cycle.rs b/tests/ui/cycle-trait/cycle-error-comparing-function-inside-itself-66667.rs
similarity index 88%
rename from tests/ui/issues/issue-66667-function-cmp-cycle.rs
rename to tests/ui/cycle-trait/cycle-error-comparing-function-inside-itself-66667.rs
index b4f09fbbb04d0..f0260d090820c 100644
--- a/tests/ui/issues/issue-66667-function-cmp-cycle.rs
+++ b/tests/ui/cycle-trait/cycle-error-comparing-function-inside-itself-66667.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/66667
 fn first() {
     second == 1 //~ ERROR binary operation
     //~^ ERROR mismatched types
diff --git a/tests/ui/issues/issue-66667-function-cmp-cycle.stderr b/tests/ui/cycle-trait/cycle-error-comparing-function-inside-itself-66667.stderr
similarity index 73%
rename from tests/ui/issues/issue-66667-function-cmp-cycle.stderr
rename to tests/ui/cycle-trait/cycle-error-comparing-function-inside-itself-66667.stderr
index cec8117702a9b..6d9f8d85a9cbe 100644
--- a/tests/ui/issues/issue-66667-function-cmp-cycle.stderr
+++ b/tests/ui/cycle-trait/cycle-error-comparing-function-inside-itself-66667.stderr
@@ -1,5 +1,5 @@
 error[E0369]: binary operation `==` cannot be applied to type `fn() {second}`
-  --> $DIR/issue-66667-function-cmp-cycle.rs:2:12
+  --> $DIR/cycle-error-comparing-function-inside-itself-66667.rs:3:12
    |
 LL |     second == 1
    |     ------ ^^ - {integer}
@@ -7,7 +7,7 @@ LL |     second == 1
    |     fn() {second}
 
 error[E0308]: mismatched types
-  --> $DIR/issue-66667-function-cmp-cycle.rs:2:15
+  --> $DIR/cycle-error-comparing-function-inside-itself-66667.rs:3:15
    |
 LL |     second == 1
    |               ^ expected fn item, found integer
@@ -16,7 +16,7 @@ LL |     second == 1
                  found type `{integer}`
 
 error[E0308]: mismatched types
-  --> $DIR/issue-66667-function-cmp-cycle.rs:2:5
+  --> $DIR/cycle-error-comparing-function-inside-itself-66667.rs:3:5
    |
 LL | fn first() {
    |           - help: try adding a return type: `-> bool`
@@ -24,7 +24,7 @@ LL |     second == 1
    |     ^^^^^^^^^^^ expected `()`, found `bool`
 
 error[E0369]: binary operation `==` cannot be applied to type `fn() {first}`
-  --> $DIR/issue-66667-function-cmp-cycle.rs:8:11
+  --> $DIR/cycle-error-comparing-function-inside-itself-66667.rs:9:11
    |
 LL |     first == 1
    |     ----- ^^ - {integer}
@@ -32,7 +32,7 @@ LL |     first == 1
    |     fn() {first}
 
 error[E0308]: mismatched types
-  --> $DIR/issue-66667-function-cmp-cycle.rs:8:14
+  --> $DIR/cycle-error-comparing-function-inside-itself-66667.rs:9:14
    |
 LL |     first == 1
    |              ^ expected fn item, found integer
@@ -41,7 +41,7 @@ LL |     first == 1
                  found type `{integer}`
 
 error[E0308]: mismatched types
-  --> $DIR/issue-66667-function-cmp-cycle.rs:8:5
+  --> $DIR/cycle-error-comparing-function-inside-itself-66667.rs:9:5
    |
 LL | fn second() {
    |            - help: try adding a return type: `-> bool`
@@ -49,7 +49,7 @@ LL |     first == 1
    |     ^^^^^^^^^^ expected `()`, found `bool`
 
 error[E0369]: binary operation `==` cannot be applied to type `fn() {bar}`
-  --> $DIR/issue-66667-function-cmp-cycle.rs:14:9
+  --> $DIR/cycle-error-comparing-function-inside-itself-66667.rs:15:9
    |
 LL |     bar == 1
    |     --- ^^ - {integer}
@@ -57,7 +57,7 @@ LL |     bar == 1
    |     fn() {bar}
 
 error[E0308]: mismatched types
-  --> $DIR/issue-66667-function-cmp-cycle.rs:14:12
+  --> $DIR/cycle-error-comparing-function-inside-itself-66667.rs:15:12
    |
 LL |     bar == 1
    |            ^ expected fn item, found integer
@@ -66,7 +66,7 @@ LL |     bar == 1
                  found type `{integer}`
 
 error[E0308]: mismatched types
-  --> $DIR/issue-66667-function-cmp-cycle.rs:14:5
+  --> $DIR/cycle-error-comparing-function-inside-itself-66667.rs:15:5
    |
 LL | fn bar() {
    |         - help: try adding a return type: `-> bool`
diff --git a/tests/ui/issues/issue-64593.rs b/tests/ui/foreign/extern-rust-ffi-warning-64593.rs
similarity index 80%
rename from tests/ui/issues/issue-64593.rs
rename to tests/ui/foreign/extern-rust-ffi-warning-64593.rs
index e28b9577347be..d4b35bde92abb 100644
--- a/tests/ui/issues/issue-64593.rs
+++ b/tests/ui/foreign/extern-rust-ffi-warning-64593.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/64593
 //@ check-pass
 #![deny(improper_ctypes)]
 
diff --git a/tests/ui/issues/issue-69306.rs b/tests/ui/generics/generic-struct-self-unconstrained-inference-vars-69306.rs
similarity index 93%
rename from tests/ui/issues/issue-69306.rs
rename to tests/ui/generics/generic-struct-self-unconstrained-inference-vars-69306.rs
index 85d60952ac823..b8e7dff95a591 100644
--- a/tests/ui/issues/issue-69306.rs
+++ b/tests/ui/generics/generic-struct-self-unconstrained-inference-vars-69306.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/69306
 fn main() {}
 
 struct S0<T>(T);
diff --git a/tests/ui/issues/issue-69306.stderr b/tests/ui/generics/generic-struct-self-unconstrained-inference-vars-69306.stderr
similarity index 80%
rename from tests/ui/issues/issue-69306.stderr
rename to tests/ui/generics/generic-struct-self-unconstrained-inference-vars-69306.stderr
index 6fc5c33af6acd..f2fd4340a5804 100644
--- a/tests/ui/issues/issue-69306.stderr
+++ b/tests/ui/generics/generic-struct-self-unconstrained-inference-vars-69306.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/issue-69306.rs:5:28
+  --> $DIR/generic-struct-self-unconstrained-inference-vars-69306.rs:6:28
    |
 LL | impl<T> S0<T> {
    |      - expected this type parameter
@@ -11,13 +11,13 @@ LL |     const C: S0<u8> = Self(0);
    = note: expected type parameter `T`
                         found type `{integer}`
 note: tuple struct defined here
-  --> $DIR/issue-69306.rs:3:8
+  --> $DIR/generic-struct-self-unconstrained-inference-vars-69306.rs:4:8
    |
 LL | struct S0<T>(T);
    |        ^^
 
 error[E0308]: mismatched types
-  --> $DIR/issue-69306.rs:5:23
+  --> $DIR/generic-struct-self-unconstrained-inference-vars-69306.rs:6:23
    |
 LL | impl<T> S0<T> {
    |      - found this type parameter
@@ -28,7 +28,7 @@ LL |     const C: S0<u8> = Self(0);
               found struct `S0<T>`
 
 error[E0308]: mismatched types
-  --> $DIR/issue-69306.rs:10:14
+  --> $DIR/generic-struct-self-unconstrained-inference-vars-69306.rs:11:14
    |
 LL | impl<T> S0<T> {
    |      - expected this type parameter
@@ -41,13 +41,13 @@ LL |         Self(0);
    = note: expected type parameter `T`
                         found type `{integer}`
 note: tuple struct defined here
-  --> $DIR/issue-69306.rs:3:8
+  --> $DIR/generic-struct-self-unconstrained-inference-vars-69306.rs:4:8
    |
 LL | struct S0<T>(T);
    |        ^^
 
 error[E0308]: mismatched types
-  --> $DIR/issue-69306.rs:27:14
+  --> $DIR/generic-struct-self-unconstrained-inference-vars-69306.rs:28:14
    |
 LL | impl<T> Foo<T> for <S0<T> as Fun>::Out {
    |      - expected this type parameter
@@ -60,13 +60,13 @@ LL |         Self(0);
    = note: expected type parameter `T`
                         found type `{integer}`
 note: tuple struct defined here
-  --> $DIR/issue-69306.rs:3:8
+  --> $DIR/generic-struct-self-unconstrained-inference-vars-69306.rs:4:8
    |
 LL | struct S0<T>(T);
    |        ^^
 
 error[E0308]: mismatched types
-  --> $DIR/issue-69306.rs:33:32
+  --> $DIR/generic-struct-self-unconstrained-inference-vars-69306.rs:34:32
    |
 LL | impl<T> S1<T, u8> {
    |      - expected this type parameter
@@ -78,13 +78,13 @@ LL |     const C: S1<u8, u8> = Self(0, 1);
    = note: expected type parameter `T`
                         found type `{integer}`
 note: tuple struct defined here
-  --> $DIR/issue-69306.rs:31:8
+  --> $DIR/generic-struct-self-unconstrained-inference-vars-69306.rs:32:8
    |
 LL | struct S1<T, U>(T, U);
    |        ^^
 
 error[E0308]: mismatched types
-  --> $DIR/issue-69306.rs:33:27
+  --> $DIR/generic-struct-self-unconstrained-inference-vars-69306.rs:34:27
    |
 LL | impl<T> S1<T, u8> {
    |      - found this type parameter
@@ -95,7 +95,7 @@ LL |     const C: S1<u8, u8> = Self(0, 1);
               found struct `S1<T, _>`
 
 error[E0308]: mismatched types
-  --> $DIR/issue-69306.rs:41:14
+  --> $DIR/generic-struct-self-unconstrained-inference-vars-69306.rs:42:14
    |
 LL | impl<T> S2<T> {
    |      - expected type parameter
@@ -111,13 +111,13 @@ LL |         Self(x)
    = note: a type parameter was expected, but a different one was found; you might be missing a type parameter or trait bound
    = note: for more information, visit https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters
 note: tuple struct defined here
-  --> $DIR/issue-69306.rs:38:8
+  --> $DIR/generic-struct-self-unconstrained-inference-vars-69306.rs:39:8
    |
 LL | struct S2<T>(T);
    |        ^^
 
 error[E0308]: mismatched types
-  --> $DIR/issue-69306.rs:41:9
+  --> $DIR/generic-struct-self-unconstrained-inference-vars-69306.rs:42:9
    |
 LL | impl<T> S2<T> {
    |      - found type parameter
diff --git a/tests/ui/issues/issue-68951.rs b/tests/ui/inference/bitwise-integer-inference-68951.rs
similarity index 74%
rename from tests/ui/issues/issue-68951.rs
rename to tests/ui/inference/bitwise-integer-inference-68951.rs
index 2d639a62d45ac..4904af3e1f3b0 100644
--- a/tests/ui/issues/issue-68951.rs
+++ b/tests/ui/inference/bitwise-integer-inference-68951.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/68951
 //@ check-pass
 
 fn main() {
diff --git a/tests/ui/issues/issue-60622.rs b/tests/ui/lifetimes/late-bound-lifetime-parameters-60622.rs
similarity index 89%
rename from tests/ui/issues/issue-60622.rs
rename to tests/ui/lifetimes/late-bound-lifetime-parameters-60622.rs
index 7b9443eee5013..d56bc18f669ed 100644
--- a/tests/ui/issues/issue-60622.rs
+++ b/tests/ui/lifetimes/late-bound-lifetime-parameters-60622.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/60622
 #![deny(warnings)]
 
 struct Borked {}
diff --git a/tests/ui/issues/issue-60622.stderr b/tests/ui/lifetimes/late-bound-lifetime-parameters-60622.stderr
similarity index 83%
rename from tests/ui/issues/issue-60622.stderr
rename to tests/ui/lifetimes/late-bound-lifetime-parameters-60622.stderr
index 298ef3799f242..880513e02823b 100644
--- a/tests/ui/issues/issue-60622.stderr
+++ b/tests/ui/lifetimes/late-bound-lifetime-parameters-60622.stderr
@@ -1,5 +1,5 @@
 error: cannot specify lifetime arguments explicitly if late bound lifetime parameters are present
-  --> $DIR/issue-60622.rs:10:11
+  --> $DIR/late-bound-lifetime-parameters-60622.rs:11:11
    |
 LL |     fn a(&self) {}
    |          - the late bound lifetime parameter is introduced here
@@ -10,14 +10,14 @@ LL |     b.a::<'_, T>();
    = 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 #42868 <https://github.com/rust-lang/rust/issues/42868>
 note: the lint level is defined here
-  --> $DIR/issue-60622.rs:1:9
+  --> $DIR/late-bound-lifetime-parameters-60622.rs:2:9
    |
 LL | #![deny(warnings)]
    |         ^^^^^^^^
    = note: `#[deny(late_bound_lifetime_arguments)]` implied by `#[deny(warnings)]`
 
 error[E0107]: method takes 0 generic arguments but 1 generic argument was supplied
-  --> $DIR/issue-60622.rs:10:7
+  --> $DIR/late-bound-lifetime-parameters-60622.rs:11:7
    |
 LL |     b.a::<'_, T>();
    |       ^       - help: remove the unnecessary generic argument
@@ -25,7 +25,7 @@ LL |     b.a::<'_, T>();
    |       expected 0 generic arguments
    |
 note: method defined here, with 0 generic parameters
-  --> $DIR/issue-60622.rs:6:8
+  --> $DIR/late-bound-lifetime-parameters-60622.rs:7:8
    |
 LL |     fn a(&self) {}
    |        ^
diff --git a/tests/ui/issues/issue-63983.rs b/tests/ui/match/unit-pattern-error-on-tuple-and-struct-variants-63983.rs
similarity index 87%
rename from tests/ui/issues/issue-63983.rs
rename to tests/ui/match/unit-pattern-error-on-tuple-and-struct-variants-63983.rs
index ab952666fd1da..e53d14f256e79 100644
--- a/tests/ui/issues/issue-63983.rs
+++ b/tests/ui/match/unit-pattern-error-on-tuple-and-struct-variants-63983.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/63983
 enum MyEnum {
     Tuple(i32),
     Struct{ s: i32 },
diff --git a/tests/ui/issues/issue-63983.stderr b/tests/ui/match/unit-pattern-error-on-tuple-and-struct-variants-63983.stderr
similarity index 85%
rename from tests/ui/issues/issue-63983.stderr
rename to tests/ui/match/unit-pattern-error-on-tuple-and-struct-variants-63983.stderr
index 3539732451ce2..5c937a9ddab0b 100644
--- a/tests/ui/issues/issue-63983.stderr
+++ b/tests/ui/match/unit-pattern-error-on-tuple-and-struct-variants-63983.stderr
@@ -1,5 +1,5 @@
 error[E0532]: expected unit struct, unit variant or constant, found tuple variant `MyEnum::Tuple`
-  --> $DIR/issue-63983.rs:8:9
+  --> $DIR/unit-pattern-error-on-tuple-and-struct-variants-63983.rs:9:9
    |
 LL |     Tuple(i32),
    |     ---------- `MyEnum::Tuple` defined here
@@ -8,7 +8,7 @@ LL |         MyEnum::Tuple => "",
    |         ^^^^^^^^^^^^^ help: use the tuple variant pattern syntax instead: `MyEnum::Tuple(_)`
 
 error[E0533]: expected unit struct, unit variant or constant, found struct variant `MyEnum::Struct`
-  --> $DIR/issue-63983.rs:10:9
+  --> $DIR/unit-pattern-error-on-tuple-and-struct-variants-63983.rs:11:9
    |
 LL |         MyEnum::Struct => "",
    |         ^^^^^^^^^^^^^^ not a unit struct, unit variant or constant
diff --git a/tests/ui/issues/issue-66923-show-error-for-correct-call.rs b/tests/ui/mismatched_types/collect-method-type-mismatch-66923.rs
similarity index 89%
rename from tests/ui/issues/issue-66923-show-error-for-correct-call.rs
rename to tests/ui/mismatched_types/collect-method-type-mismatch-66923.rs
index 8332807397247..d20228891c027 100644
--- a/tests/ui/issues/issue-66923-show-error-for-correct-call.rs
+++ b/tests/ui/mismatched_types/collect-method-type-mismatch-66923.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/66923
 // This test checks that errors are showed for lines with `collect` rather than `push` method.
 
 fn main() {
diff --git a/tests/ui/issues/issue-66923-show-error-for-correct-call.stderr b/tests/ui/mismatched_types/collect-method-type-mismatch-66923.stderr
similarity index 89%
rename from tests/ui/issues/issue-66923-show-error-for-correct-call.stderr
rename to tests/ui/mismatched_types/collect-method-type-mismatch-66923.stderr
index d2852093725ce..89c755cdf47a7 100644
--- a/tests/ui/issues/issue-66923-show-error-for-correct-call.stderr
+++ b/tests/ui/mismatched_types/collect-method-type-mismatch-66923.stderr
@@ -1,5 +1,5 @@
 error[E0277]: a value of type `Vec<f64>` cannot be built from an iterator over elements of type `&f64`
-  --> $DIR/issue-66923-show-error-for-correct-call.rs:8:39
+  --> $DIR/collect-method-type-mismatch-66923.rs:9:39
    |
 LL |     let x2: Vec<f64> = x1.into_iter().collect();
    |                                       ^^^^^^^ value of type `Vec<f64>` cannot be built from `std::iter::Iterator<Item=&f64>`
@@ -8,7 +8,7 @@ LL |     let x2: Vec<f64> = x1.into_iter().collect();
            but trait `FromIterator<_>` is implemented for it
    = help: for that trait implementation, expected `f64`, found `&f64`
 note: the method call chain might not have had the expected associated types
-  --> $DIR/issue-66923-show-error-for-correct-call.rs:8:27
+  --> $DIR/collect-method-type-mismatch-66923.rs:9:27
    |
 LL |     let x1: &[f64] = &v;
    |                      -- this expression has type `&Vec<f64>`
@@ -18,7 +18,7 @@ note: required by a bound in `collect`
   --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
 
 error[E0277]: a value of type `Vec<f64>` cannot be built from an iterator over elements of type `&f64`
-  --> $DIR/issue-66923-show-error-for-correct-call.rs:12:39
+  --> $DIR/collect-method-type-mismatch-66923.rs:13:39
    |
 LL |     let x3 = x1.into_iter().collect::<Vec<f64>>();
    |                             -------   ^^^^^^^^ value of type `Vec<f64>` cannot be built from `std::iter::Iterator<Item=&f64>`
@@ -29,7 +29,7 @@ LL |     let x3 = x1.into_iter().collect::<Vec<f64>>();
            but trait `FromIterator<_>` is implemented for it
    = help: for that trait implementation, expected `f64`, found `&f64`
 note: the method call chain might not have had the expected associated types
-  --> $DIR/issue-66923-show-error-for-correct-call.rs:12:17
+  --> $DIR/collect-method-type-mismatch-66923.rs:13:17
    |
 LL |     let x1: &[f64] = &v;
    |                      -- this expression has type `&Vec<f64>`
diff --git a/tests/ui/issues/issue-61106.rs b/tests/ui/mismatched_types/string-clone-mismatch-61106.rs
similarity index 68%
rename from tests/ui/issues/issue-61106.rs
rename to tests/ui/mismatched_types/string-clone-mismatch-61106.rs
index 308ef1de3ccc3..1582ed3ec978d 100644
--- a/tests/ui/issues/issue-61106.rs
+++ b/tests/ui/mismatched_types/string-clone-mismatch-61106.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/61106
 fn main() {
     let x = String::new();
     foo(x.clone()); //~ ERROR mismatched types
diff --git a/tests/ui/issues/issue-61106.stderr b/tests/ui/mismatched_types/string-clone-mismatch-61106.stderr
similarity index 82%
rename from tests/ui/issues/issue-61106.stderr
rename to tests/ui/mismatched_types/string-clone-mismatch-61106.stderr
index f825141fa062a..8e41f42a6d8f8 100644
--- a/tests/ui/issues/issue-61106.stderr
+++ b/tests/ui/mismatched_types/string-clone-mismatch-61106.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/issue-61106.rs:3:9
+  --> $DIR/string-clone-mismatch-61106.rs:4:9
    |
 LL |     foo(x.clone());
    |     --- ^^^^^^^^^ expected `&str`, found `String`
@@ -7,7 +7,7 @@ LL |     foo(x.clone());
    |     arguments to this function are incorrect
    |
 note: function defined here
-  --> $DIR/issue-61106.rs:6:4
+  --> $DIR/string-clone-mismatch-61106.rs:7:4
    |
 LL | fn foo(_: &str) {}
    |    ^^^ -------
diff --git a/tests/ui/issues/issue-64430.rs b/tests/ui/no_std/no-std-panic-abort-error-64430.rs
similarity index 79%
rename from tests/ui/issues/issue-64430.rs
rename to tests/ui/no_std/no-std-panic-abort-error-64430.rs
index bc98dbf8520f0..bd25597d6d754 100644
--- a/tests/ui/issues/issue-64430.rs
+++ b/tests/ui/no_std/no-std-panic-abort-error-64430.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/64430
 //@ compile-flags:-C panic=abort
 
 #![no_std]
diff --git a/tests/ui/issues/issue-64430.stderr b/tests/ui/no_std/no-std-panic-abort-error-64430.stderr
similarity index 87%
rename from tests/ui/issues/issue-64430.stderr
rename to tests/ui/no_std/no-std-panic-abort-error-64430.stderr
index 1c8e020e9cbb4..452721cd4fdd7 100644
--- a/tests/ui/issues/issue-64430.stderr
+++ b/tests/ui/no_std/no-std-panic-abort-error-64430.stderr
@@ -1,5 +1,5 @@
 error[E0599]: no method named `bar` found for struct `Foo` in the current scope
-  --> $DIR/issue-64430.rs:7:9
+  --> $DIR/no-std-panic-abort-error-64430.rs:8:9
    |
 LL | pub struct Foo;
    | -------------- method `bar` not found for this struct
diff --git a/tests/ui/issues/issue-68696-catch-during-unwind.rs b/tests/ui/panic-handler/catch-unwind-during-unwind-68696.rs
similarity index 92%
rename from tests/ui/issues/issue-68696-catch-during-unwind.rs
rename to tests/ui/panic-handler/catch-unwind-during-unwind-68696.rs
index 655879e186929..b4645a39691c2 100644
--- a/tests/ui/issues/issue-68696-catch-during-unwind.rs
+++ b/tests/ui/panic-handler/catch-unwind-during-unwind-68696.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/68696
 // Checks that catch_unwind can be used if unwinding is already in progress.
 // Used to fail when standard library had been compiled with debug assertions,
 // due to incorrect assumption that a current thread is not panicking when
diff --git a/tests/ui/issues/issue-69130.rs b/tests/ui/parser/character-indexing-bug-in-splice-lines-69130.rs
similarity index 100%
rename from tests/ui/issues/issue-69130.rs
rename to tests/ui/parser/character-indexing-bug-in-splice-lines-69130.rs
diff --git a/tests/ui/issues/issue-69130.stderr b/tests/ui/parser/character-indexing-bug-in-splice-lines-69130.stderr
similarity index 75%
rename from tests/ui/issues/issue-69130.stderr
rename to tests/ui/parser/character-indexing-bug-in-splice-lines-69130.stderr
index e67cc295d43e1..a06532b67d3a3 100644
--- a/tests/ui/issues/issue-69130.stderr
+++ b/tests/ui/parser/character-indexing-bug-in-splice-lines-69130.stderr
@@ -1,11 +1,11 @@
 error: unknown start of token: \u{a7}
-  --> $DIR/issue-69130.rs:4:4
+  --> $DIR/character-indexing-bug-in-splice-lines-69130.rs:4:4
    |
 LL | M (§& u8)}
    |    ^
 
 error[E0106]: missing lifetime specifier
-  --> $DIR/issue-69130.rs:4:5
+  --> $DIR/character-indexing-bug-in-splice-lines-69130.rs:4:5
    |
 LL | M (§& u8)}
    |     ^ expected named lifetime parameter
diff --git a/tests/ui/issues/issue-61475.rs b/tests/ui/parser/pattern-matching-with-double-references-61475.rs
similarity index 75%
rename from tests/ui/issues/issue-61475.rs
rename to tests/ui/parser/pattern-matching-with-double-references-61475.rs
index ff5e109ea7c8c..bf800ec8b2c66 100644
--- a/tests/ui/issues/issue-61475.rs
+++ b/tests/ui/parser/pattern-matching-with-double-references-61475.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/61475
 //@ run-pass
 #![allow(dead_code)]
 
diff --git a/tests/ui/issues/issue-64792-bad-unicode-ctor.rs b/tests/ui/parser/unicode-string-literal-syntax-error-64792.rs
similarity index 71%
rename from tests/ui/issues/issue-64792-bad-unicode-ctor.rs
rename to tests/ui/parser/unicode-string-literal-syntax-error-64792.rs
index f1427ef46e928..6497509a1233c 100644
--- a/tests/ui/issues/issue-64792-bad-unicode-ctor.rs
+++ b/tests/ui/parser/unicode-string-literal-syntax-error-64792.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/64792
 struct X {}
 
 const Y: X = X("ö"); //~ ERROR expected function, tuple struct or tuple variant, found struct `X`
diff --git a/tests/ui/issues/issue-64792-bad-unicode-ctor.stderr b/tests/ui/parser/unicode-string-literal-syntax-error-64792.stderr
similarity index 85%
rename from tests/ui/issues/issue-64792-bad-unicode-ctor.stderr
rename to tests/ui/parser/unicode-string-literal-syntax-error-64792.stderr
index 7fc414602d281..7a37b4a5f3a0c 100644
--- a/tests/ui/issues/issue-64792-bad-unicode-ctor.stderr
+++ b/tests/ui/parser/unicode-string-literal-syntax-error-64792.stderr
@@ -1,5 +1,5 @@
 error[E0423]: expected function, tuple struct or tuple variant, found struct `X`
-  --> $DIR/issue-64792-bad-unicode-ctor.rs:3:14
+  --> $DIR/unicode-string-literal-syntax-error-64792.rs:4:14
    |
 LL | struct X {}
    | ----------- `X` defined here
diff --git a/tests/ui/issues/issue-67535.rs b/tests/ui/traits/trait-implementation-for-non-local-types-67535.rs
similarity index 92%
rename from tests/ui/issues/issue-67535.rs
rename to tests/ui/traits/trait-implementation-for-non-local-types-67535.rs
index 24f50621310f1..198576ba5357d 100644
--- a/tests/ui/issues/issue-67535.rs
+++ b/tests/ui/traits/trait-implementation-for-non-local-types-67535.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/67535
 fn main() {}
 
 impl std::ops::AddAssign for () {
diff --git a/tests/ui/issues/issue-67535.stderr b/tests/ui/traits/trait-implementation-for-non-local-types-67535.stderr
similarity index 91%
rename from tests/ui/issues/issue-67535.stderr
rename to tests/ui/traits/trait-implementation-for-non-local-types-67535.stderr
index 2afa2199a6afe..ef20f0c60ce19 100644
--- a/tests/ui/issues/issue-67535.stderr
+++ b/tests/ui/traits/trait-implementation-for-non-local-types-67535.stderr
@@ -1,5 +1,5 @@
 error[E0117]: only traits defined in the current crate can be implemented for arbitrary types
-  --> $DIR/issue-67535.rs:3:1
+  --> $DIR/trait-implementation-for-non-local-types-67535.rs:4:1
    |
 LL | impl std::ops::AddAssign for () {
    | ^^^^^-------------------^^^^^--
@@ -12,7 +12,7 @@ LL | impl std::ops::AddAssign for () {
    = note: define and implement a trait or new type instead
 
 error[E0117]: only traits defined in the current crate can be implemented for arbitrary types
-  --> $DIR/issue-67535.rs:10:1
+  --> $DIR/trait-implementation-for-non-local-types-67535.rs:11:1
    |
 LL | impl std::ops::AddAssign for [(); 1] {
    | ^^^^^-------------------^^^^^-------
@@ -25,7 +25,7 @@ LL | impl std::ops::AddAssign for [(); 1] {
    = note: define and implement a trait or new type instead
 
 error[E0117]: only traits defined in the current crate can be implemented for arbitrary types
-  --> $DIR/issue-67535.rs:17:1
+  --> $DIR/trait-implementation-for-non-local-types-67535.rs:18:1
    |
 LL | impl std::ops::AddAssign for &[u8] {
    | ^^^^^-------------------^^^^^-----
diff --git a/tests/ui/issues/issue-66353.rs b/tests/ui/typeck/associated-type-ice-recovery-66353.rs
similarity index 86%
rename from tests/ui/issues/issue-66353.rs
rename to tests/ui/typeck/associated-type-ice-recovery-66353.rs
index d8abdd5206ef4..472bc11108231 100644
--- a/tests/ui/issues/issue-66353.rs
+++ b/tests/ui/typeck/associated-type-ice-recovery-66353.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/66353
 // #66353: ICE when trying to recover from incorrect associated type
 
 trait _Func<T> {
diff --git a/tests/ui/issues/issue-66353.stderr b/tests/ui/typeck/associated-type-ice-recovery-66353.stderr
similarity index 78%
rename from tests/ui/issues/issue-66353.stderr
rename to tests/ui/typeck/associated-type-ice-recovery-66353.stderr
index 7ab7547b42dc6..30740f66dcd90 100644
--- a/tests/ui/issues/issue-66353.stderr
+++ b/tests/ui/typeck/associated-type-ice-recovery-66353.stderr
@@ -1,17 +1,17 @@
 error[E0277]: the trait bound `(): _A` is not satisfied
-  --> $DIR/issue-66353.rs:12:15
+  --> $DIR/associated-type-ice-recovery-66353.rs:13:15
    |
 LL |     _Func::< <() as _A>::AssocT >::func(());
    |               ^^ the trait `_A` is not implemented for `()`
    |
 help: this trait has no implementations, consider adding one
-  --> $DIR/issue-66353.rs:7:1
+  --> $DIR/associated-type-ice-recovery-66353.rs:8:1
    |
 LL | trait _A {
    | ^^^^^^^^
 
 error[E0277]: the trait bound `(): _Func<_>` is not satisfied
-  --> $DIR/issue-66353.rs:12:41
+  --> $DIR/associated-type-ice-recovery-66353.rs:13:41
    |
 LL |     _Func::< <() as _A>::AssocT >::func(());
    |     ----------------------------------- ^^ the trait `_Func<_>` is not implemented for `()`
@@ -19,7 +19,7 @@ LL |     _Func::< <() as _A>::AssocT >::func(());
    |     required by a bound introduced by this call
    |
 help: this trait has no implementations, consider adding one
-  --> $DIR/issue-66353.rs:3:1
+  --> $DIR/associated-type-ice-recovery-66353.rs:4:1
    |
 LL | trait _Func<T> {
    | ^^^^^^^^^^^^^^
diff --git a/tests/ui/issues/issue-60989.rs b/tests/ui/typeck/type-arguments-on-local-variable-60989.rs
similarity index 86%
rename from tests/ui/issues/issue-60989.rs
rename to tests/ui/typeck/type-arguments-on-local-variable-60989.rs
index 29db3fdb47104..134188754b4ce 100644
--- a/tests/ui/issues/issue-60989.rs
+++ b/tests/ui/typeck/type-arguments-on-local-variable-60989.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/60989
 struct A {}
 struct B {}
 
diff --git a/tests/ui/issues/issue-60989.stderr b/tests/ui/typeck/type-arguments-on-local-variable-60989.stderr
similarity index 80%
rename from tests/ui/issues/issue-60989.stderr
rename to tests/ui/typeck/type-arguments-on-local-variable-60989.stderr
index e0236567b2fa6..20cb4752079a2 100644
--- a/tests/ui/issues/issue-60989.stderr
+++ b/tests/ui/typeck/type-arguments-on-local-variable-60989.stderr
@@ -1,5 +1,5 @@
 error[E0109]: type arguments are not allowed on local variable
-  --> $DIR/issue-60989.rs:12:10
+  --> $DIR/type-arguments-on-local-variable-60989.rs:13:10
    |
 LL |     c1::<()>;
    |     --   ^^ type argument not allowed
@@ -7,7 +7,7 @@ LL |     c1::<()>;
    |     not allowed on local variable
 
 error[E0109]: type arguments are not allowed on local variable
-  --> $DIR/issue-60989.rs:16:10
+  --> $DIR/type-arguments-on-local-variable-60989.rs:17:10
    |
 LL |     c1::<dyn Into<B>>;
    |     --   ^^^^^^^^^^^ type argument not allowed
diff --git a/tests/ui/issues/issue-61894.rs b/tests/ui/typeck/type-name-intrinsic-usage-61894.rs
similarity index 70%
rename from tests/ui/issues/issue-61894.rs
rename to tests/ui/typeck/type-name-intrinsic-usage-61894.rs
index 40ad6a8d76a01..8131bb273909d 100644
--- a/tests/ui/issues/issue-61894.rs
+++ b/tests/ui/typeck/type-name-intrinsic-usage-61894.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/61894
 //@ run-pass
 
 #![feature(core_intrinsics)]
@@ -17,5 +18,5 @@ impl<M> Bar<M> {
 }
 
 fn main() {
-    assert_eq!(Bar(()).foo(), "issue_61894::Bar<_>::foo::f");
+    assert_eq!(Bar(()).foo(), "type_name_intrinsic_usage_61894::Bar<_>::foo::f");
 }
diff --git a/tests/ui/issues/issue-65462.rs b/tests/ui/union/union-field-access-error-65462.rs
similarity index 80%
rename from tests/ui/issues/issue-65462.rs
rename to tests/ui/union/union-field-access-error-65462.rs
index e148c8aeeb2b5..ead403bc526cd 100644
--- a/tests/ui/issues/issue-65462.rs
+++ b/tests/ui/union/union-field-access-error-65462.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/65462
 //@ build-pass
 
 enum Empty {}

From be46a90a8b4148afe2099f24686c589238249d2e Mon Sep 17 00:00:00 2001
From: Camille Gillot <gillot.camille@gmail.com>
Date: Sun, 12 Oct 2025 03:15:18 +0000
Subject: [PATCH 1887/1889] Bless x86_64 test.

---
 tests/ui/asm/x86_64/goto.stderr | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/ui/asm/x86_64/goto.stderr b/tests/ui/asm/x86_64/goto.stderr
index 5342e43c58a1c..da3f7d6763fa8 100644
--- a/tests/ui/asm/x86_64/goto.stderr
+++ b/tests/ui/asm/x86_64/goto.stderr
@@ -1,5 +1,5 @@
 warning: unreachable statement
-  --> $DIR/goto.rs:144:9
+  --> $DIR/goto.rs:145:9
    |
 LL | /         asm!(
 LL | |             "jmp {}",
@@ -13,13 +13,13 @@ LL |           unreachable!();
    |           ^^^^^^^^^^^^^^ unreachable statement
    |
 note: the lint level is defined here
-  --> $DIR/goto.rs:134:8
+  --> $DIR/goto.rs:135:8
    |
 LL | #[warn(unreachable_code)]
    |        ^^^^^^^^^^^^^^^^
 
 warning: value assigned to `value` is never read
-  --> $DIR/goto.rs:70:25
+  --> $DIR/goto.rs:71:25
    |
 LL |         let mut value = false;
    |                         ^^^^^

From d70857a1e04c7ccfb2606a760784bb41bc695fa0 Mon Sep 17 00:00:00 2001
From: Shunpoco <tkngsnsk313320@gmail.com>
Date: Sat, 11 Oct 2025 18:37:29 +0100
Subject: [PATCH 1888/1889] Add tidy into ./x check

This commit adds src/tools/tidy into `./x check`. It enables rust-analyzer hightlights errors/warns on all codes in src/tools/tidy.
Since tidy is implicitly checked by `./x test tidy`, this new check is off by default.
---
 src/bootstrap/src/core/build_steps/check.rs     | 5 +++++
 src/bootstrap/src/core/builder/mod.rs           | 1 +
 src/ci/docker/host-x86_64/pr-check-1/Dockerfile | 1 +
 3 files changed, 7 insertions(+)

diff --git a/src/bootstrap/src/core/build_steps/check.rs b/src/bootstrap/src/core/build_steps/check.rs
index 400c6f732c3c3..6faa1d018234a 100644
--- a/src/bootstrap/src/core/build_steps/check.rs
+++ b/src/bootstrap/src/core/build_steps/check.rs
@@ -841,3 +841,8 @@ tool_check_step!(BumpStage0 {
     mode: Mode::ToolBootstrap,
     default: false
 });
+
+// Tidy is implicitly checked when `./x test tidy` is executed
+// (if you set a pre-push hook, the command is called).
+// So this is mainly for people working on tidy.
+tool_check_step!(Tidy { path: "src/tools/tidy", mode: Mode::ToolBootstrap, default: false });
diff --git a/src/bootstrap/src/core/builder/mod.rs b/src/bootstrap/src/core/builder/mod.rs
index 99fb62ea31c9d..d493f97f307bd 100644
--- a/src/bootstrap/src/core/builder/mod.rs
+++ b/src/bootstrap/src/core/builder/mod.rs
@@ -1076,6 +1076,7 @@ impl<'a> Builder<'a> {
                 check::CoverageDump,
                 check::Linkchecker,
                 check::BumpStage0,
+                check::Tidy,
                 // This has special staging logic, it may run on stage 1 while others run on stage 0.
                 // It takes quite some time to build stage 1, so put this at the end.
                 //
diff --git a/src/ci/docker/host-x86_64/pr-check-1/Dockerfile b/src/ci/docker/host-x86_64/pr-check-1/Dockerfile
index 32e1b30dab962..c1742720f7789 100644
--- a/src/ci/docker/host-x86_64/pr-check-1/Dockerfile
+++ b/src/ci/docker/host-x86_64/pr-check-1/Dockerfile
@@ -50,6 +50,7 @@ ENV SCRIPT \
     linkchecker \
     run-make-support \
     rustdoc-gui-test \
+    tidy \
     && \
   /scripts/check-default-config-profiles.sh && \
   python3 ../x.py build src/tools/build-manifest && \

From dc05250c2f0ea765d68b05f5399761107555127a Mon Sep 17 00:00:00 2001
From: Kivooeo <Kivooeo123@gmail.com>
Date: Sun, 12 Oct 2025 08:08:30 +0000
Subject: [PATCH 1889/1889] some cleanups in compiler

---
 compiler/rustc_arena/src/tests.rs                   |  4 ++--
 compiler/rustc_fluent_macro/src/fluent.rs           |  2 +-
 compiler/rustc_graphviz/src/tests.rs                |  8 ++++----
 compiler/rustc_hashes/src/lib.rs                    |  2 +-
 compiler/rustc_llvm/build.rs                        |  2 +-
 compiler/rustc_log/src/lib.rs                       | 13 +++++--------
 compiler/rustc_thread_pool/src/registry.rs          |  2 +-
 compiler/rustc_thread_pool/src/scope/tests.rs       |  2 +-
 compiler/rustc_thread_pool/src/thread_pool/tests.rs |  2 +-
 compiler/rustc_thread_pool/src/worker_local.rs      |  4 ++--
 compiler/rustc_type_ir_macros/src/lib.rs            |  8 ++++----
 11 files changed, 23 insertions(+), 26 deletions(-)

diff --git a/compiler/rustc_arena/src/tests.rs b/compiler/rustc_arena/src/tests.rs
index bfde8abd5893a..eb9406d691b10 100644
--- a/compiler/rustc_arena/src/tests.rs
+++ b/compiler/rustc_arena/src/tests.rs
@@ -19,8 +19,8 @@ impl<T> TypedArena<T> {
         unsafe {
             // Clear the last chunk, which is partially filled.
             let mut chunks_borrow = self.chunks.borrow_mut();
-            if let Some(mut last_chunk) = chunks_borrow.last_mut() {
-                self.clear_last_chunk(&mut last_chunk);
+            if let Some(last_chunk) = chunks_borrow.last_mut() {
+                self.clear_last_chunk(last_chunk);
                 let len = chunks_borrow.len();
                 // If `T` is ZST, code below has no effect.
                 for mut chunk in chunks_borrow.drain(..len - 1) {
diff --git a/compiler/rustc_fluent_macro/src/fluent.rs b/compiler/rustc_fluent_macro/src/fluent.rs
index d58c70674f6aa..e383d085bb3d3 100644
--- a/compiler/rustc_fluent_macro/src/fluent.rs
+++ b/compiler/rustc_fluent_macro/src/fluent.rs
@@ -265,7 +265,7 @@ pub(crate) fn fluent_messages(input: proc_macro::TokenStream) -> proc_macro::Tok
                 Level::Error,
                 format!("referenced message `{mref}` does not exist (in message `{name}`)"),
             )
-            .help(&format!("you may have meant to use a variable reference (`{{${mref}}}`)"))
+            .help(format!("you may have meant to use a variable reference (`{{${mref}}}`)"))
             .emit();
         }
     }
diff --git a/compiler/rustc_graphviz/src/tests.rs b/compiler/rustc_graphviz/src/tests.rs
index bf2f43fde2ee9..6a569d10c34a8 100644
--- a/compiler/rustc_graphviz/src/tests.rs
+++ b/compiler/rustc_graphviz/src/tests.rs
@@ -63,10 +63,10 @@ impl NodeLabels<&'static str> {
     }
 
     fn len(&self) -> usize {
-        match self {
-            &UnlabelledNodes(len) => len,
-            &AllNodesLabelled(ref lbls) => lbls.len(),
-            &SomeNodesLabelled(ref lbls) => lbls.len(),
+        match *self {
+            UnlabelledNodes(len) => len,
+            AllNodesLabelled(ref lbls) => lbls.len(),
+            SomeNodesLabelled(ref lbls) => lbls.len(),
         }
     }
 }
diff --git a/compiler/rustc_hashes/src/lib.rs b/compiler/rustc_hashes/src/lib.rs
index 3755caaaa2963..c8f3057dac5fc 100644
--- a/compiler/rustc_hashes/src/lib.rs
+++ b/compiler/rustc_hashes/src/lib.rs
@@ -54,7 +54,7 @@ impl FromStableHash for Hash64 {
     type Hash = StableHasherHash;
 
     #[inline]
-    fn from(StableHasherHash([_0, __1]): Self::Hash) -> Self {
+    fn from(StableHasherHash([_0, _]): Self::Hash) -> Self {
         Self { inner: _0 }
     }
 }
diff --git a/compiler/rustc_llvm/build.rs b/compiler/rustc_llvm/build.rs
index 2cfda7a5fb4b2..d5c43c4fa0661 100644
--- a/compiler/rustc_llvm/build.rs
+++ b/compiler/rustc_llvm/build.rs
@@ -197,7 +197,7 @@ fn main() {
 
         // Include path contains host directory, replace it with target
         if is_crossed && flag.starts_with("-I") {
-            cfg.flag(&flag.replace(&host, &target));
+            cfg.flag(flag.replace(&host, &target));
             continue;
         }
 
diff --git a/compiler/rustc_log/src/lib.rs b/compiler/rustc_log/src/lib.rs
index 26475eec1c102..0643d5b23bc51 100644
--- a/compiler/rustc_log/src/lib.rs
+++ b/compiler/rustc_log/src/lib.rs
@@ -73,7 +73,7 @@ impl LoggerConfig {
 
 /// Initialize the logger with the given values for the filter, coloring, and other options env variables.
 pub fn init_logger(cfg: LoggerConfig) -> Result<(), Error> {
-    init_logger_with_additional_layer(cfg, || Registry::default())
+    init_logger_with_additional_layer(cfg, Registry::default)
 }
 
 /// Trait alias for the complex return type of `build_subscriber` in
@@ -145,14 +145,11 @@ where
         .with_thread_ids(verbose_thread_ids)
         .with_thread_names(verbose_thread_ids);
 
-    match cfg.wraptree {
-        Ok(v) => match v.parse::<usize>() {
-            Ok(v) => {
-                layer = layer.with_wraparound(v);
-            }
+    if let Ok(v) = cfg.wraptree {
+        match v.parse::<usize>() {
+            Ok(v) => layer = layer.with_wraparound(v),
             Err(_) => return Err(Error::InvalidWraptree(v)),
-        },
-        Err(_) => {} // no wraptree
+        }
     }
 
     let subscriber = build_subscriber().with(layer.with_filter(filter));
diff --git a/compiler/rustc_thread_pool/src/registry.rs b/compiler/rustc_thread_pool/src/registry.rs
index 22d3a78604523..4a018ea743aea 100644
--- a/compiler/rustc_thread_pool/src/registry.rs
+++ b/compiler/rustc_thread_pool/src/registry.rs
@@ -808,7 +808,7 @@ impl WorkerThread {
         latch: &L,
         mut all_jobs_started: impl FnMut() -> bool,
         mut is_job: impl FnMut(&JobRef) -> bool,
-        mut execute_job: impl FnMut(JobRef) -> (),
+        mut execute_job: impl FnMut(JobRef),
     ) {
         let mut jobs = SmallVec::<[JobRef; 8]>::new();
         let mut broadcast_jobs = SmallVec::<[JobRef; 8]>::new();
diff --git a/compiler/rustc_thread_pool/src/scope/tests.rs b/compiler/rustc_thread_pool/src/scope/tests.rs
index 9b9ac98d066c2..cdd378096c41d 100644
--- a/compiler/rustc_thread_pool/src/scope/tests.rs
+++ b/compiler/rustc_thread_pool/src/scope/tests.rs
@@ -168,7 +168,7 @@ fn the_final_countdown<'scope>(
     let top_of_stack = 0;
     let p = bottom_of_stack as *const i32 as usize;
     let q = &top_of_stack as *const i32 as usize;
-    let diff = if p > q { p - q } else { q - p };
+    let diff = p.abs_diff(q);
 
     let mut data = max.lock().unwrap();
     *data = Ord::max(diff, *data);
diff --git a/compiler/rustc_thread_pool/src/thread_pool/tests.rs b/compiler/rustc_thread_pool/src/thread_pool/tests.rs
index f2baab4c85986..a77af7b73e087 100644
--- a/compiler/rustc_thread_pool/src/thread_pool/tests.rs
+++ b/compiler/rustc_thread_pool/src/thread_pool/tests.rs
@@ -97,7 +97,7 @@ fn failed_thread_stack() {
     // macOS and Windows weren't fazed, or at least didn't fail the way we want.
     // They work with `isize::MAX`, but 32-bit platforms may feasibly allocate a
     // 2GB stack, so it might not fail until the second thread.
-    let stack_size = ::std::isize::MAX as usize;
+    let stack_size = isize::MAX as usize;
 
     let (start_count, start_handler) = count_handler();
     let (exit_count, exit_handler) = count_handler();
diff --git a/compiler/rustc_thread_pool/src/worker_local.rs b/compiler/rustc_thread_pool/src/worker_local.rs
index d108c91f9ee53..912001233bfea 100644
--- a/compiler/rustc_thread_pool/src/worker_local.rs
+++ b/compiler/rustc_thread_pool/src/worker_local.rs
@@ -43,7 +43,7 @@ impl<T> WorkerLocal<T> {
         unsafe {
             let worker_thread = WorkerThread::current();
             if worker_thread.is_null()
-                || &*(*worker_thread).registry as *const _ != &*self.registry as *const _
+                || !std::ptr::eq(&*(*worker_thread).registry, &*self.registry)
             {
                 panic!("WorkerLocal can only be used on the thread pool it was created on")
             }
@@ -55,7 +55,7 @@ impl<T> WorkerLocal<T> {
 impl<T> WorkerLocal<Vec<T>> {
     /// Joins the elements of all the worker locals into one Vec
     pub fn join(self) -> Vec<T> {
-        self.into_inner().into_iter().flat_map(|v| v).collect()
+        self.into_inner().into_iter().flatten().collect()
     }
 }
 
diff --git a/compiler/rustc_type_ir_macros/src/lib.rs b/compiler/rustc_type_ir_macros/src/lib.rs
index 3a10d0d41ef32..37617b789dba7 100644
--- a/compiler/rustc_type_ir_macros/src/lib.rs
+++ b/compiler/rustc_type_ir_macros/src/lib.rs
@@ -197,10 +197,10 @@ fn lift(mut ty: syn::Type) -> syn::Type {
     impl VisitMut for ItoJ {
         fn visit_type_path_mut(&mut self, i: &mut syn::TypePath) {
             if i.qself.is_none() {
-                if let Some(first) = i.path.segments.first_mut() {
-                    if first.ident == "I" {
-                        *first = parse_quote! { J };
-                    }
+                if let Some(first) = i.path.segments.first_mut()
+                    && first.ident == "I"
+                {
+                    *first = parse_quote! { J };
                 }
             }
             syn::visit_mut::visit_type_path_mut(self, i);